VirtualBox

Ignore:
Timestamp:
Apr 14, 2023 3:17:44 PM (2 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
156854
Message:

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643

Location:
trunk/src/VBox/Devices/EFI/FirmwareNew
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/FirmwareNew

  • trunk/src/VBox/Devices/EFI/FirmwareNew/MdePkg/Library/DxeServicesLib/DxeServicesLib.c

    r85718 r99404  
    4141EFI_HANDLE
    4242InternalImageHandleToFvHandle (
    43   EFI_HANDLE ImageHandle
     43  EFI_HANDLE  ImageHandle
    4444  )
    4545{
    46   EFI_STATUS                    Status;
    47   EFI_LOADED_IMAGE_PROTOCOL     *LoadedImage;
     46  EFI_STATUS                 Status;
     47  EFI_LOADED_IMAGE_PROTOCOL  *LoadedImage;
    4848
    4949  ASSERT (ImageHandle != NULL);
    5050
    5151  Status = gBS->HandleProtocol (
    52              ImageHandle,
    53              &gEfiLoadedImageProtocolGuid,
    54              (VOID **) &LoadedImage
    55              );
     52                  ImageHandle,
     53                  &gEfiLoadedImageProtocolGuid,
     54                  (VOID **)&LoadedImage
     55                  );
    5656
    5757  ASSERT_EFI_ERROR (Status);
    … …  
    6464  //
    6565  return LoadedImage->DeviceHandle;
    66 
    6766}
    6867
    … …  
    112111EFI_STATUS
    113112InternalGetSectionFromFv (
    114   IN  EFI_HANDLE                    FvHandle,
    115   IN  CONST EFI_GUID                *NameGuid,
    116   IN  EFI_SECTION_TYPE              SectionType,
    117   IN  UINTN                         SectionInstance,
    118   OUT VOID                          **Buffer,
    119   OUT UINTN                         *Size
     113  IN  EFI_HANDLE        FvHandle,
     114  IN  CONST EFI_GUID    *NameGuid,
     115  IN  EFI_SECTION_TYPE  SectionType,
     116  IN  UINTN             SectionInstance,
     117  OUT VOID              **Buffer,
     118  OUT UINTN             *Size
    120119  )
    121120{
    122   EFI_STATUS                    Status;
    123   EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;
    124   UINT32                        AuthenticationStatus;
     121  EFI_STATUS                     Status;
     122  EFI_FIRMWARE_VOLUME2_PROTOCOL  *Fv;
     123  UINT32                         AuthenticationStatus;
    125124
    126125  ASSERT (NameGuid != NULL);
    … …  
    138137                  FvHandle,
    139138                  &gEfiFirmwareVolume2ProtocolGuid,
    140                   (VOID **) &Fv
     139                  (VOID **)&Fv
    141140                  );
    142141  if (EFI_ERROR (Status)) {
    … …  
    147146  // Read desired section content in NameGuid file
    148147  //
    149   *Buffer     = NULL;
    150   *Size       = 0;
    151   Status      = Fv->ReadSection (
    152                       Fv,
    153                       NameGuid,
    154                       SectionType,
    155                       SectionInstance,
    156                       Buffer,
    157                       Size,
    158                       &AuthenticationStatus
    159                       );
     148  *Buffer = NULL;
     149  *Size   = 0;
     150  Status  = Fv->ReadSection (
     151                  Fv,
     152                  NameGuid,
     153                  SectionType,
     154                  SectionInstance,
     155                  Buffer,
     156                  Size,
     157                  &AuthenticationStatus
     158                  );
    160159
    161160  if (EFI_ERROR (Status) && (SectionType == EFI_SECTION_TE)) {
    … …  
    230229EFIAPI
    231230GetSectionFromAnyFvByFileType  (
    232   IN  EFI_FV_FILETYPE               FileType,
    233   IN  UINTN                         FileInstance,
    234   IN  EFI_SECTION_TYPE              SectionType,
    235   IN  UINTN                         SectionInstance,
    236   OUT VOID                          **Buffer,
    237   OUT UINTN                         *Size
     231  IN  EFI_FV_FILETYPE   FileType,
     232  IN  UINTN             FileInstance,
     233  IN  EFI_SECTION_TYPE  SectionType,
     234  IN  UINTN             SectionInstance,
     235  OUT VOID              **Buffer,
     236  OUT UINTN             *Size
    238237  )
    239238{
    240   EFI_STATUS                    Status;
    241   EFI_HANDLE                    *HandleBuffer;
    242   UINTN                         HandleCount;
    243   UINTN                         IndexFv;
    244   UINTN                         IndexFile;
    245   UINTN                         Key;
    246   EFI_GUID                      NameGuid;
    247   EFI_FV_FILE_ATTRIBUTES        Attributes;
    248   EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;
     239  EFI_STATUS                     Status;
     240  EFI_HANDLE                     *HandleBuffer;
     241  UINTN                          HandleCount;
     242  UINTN                          IndexFv;
     243  UINTN                          IndexFile;
     244  UINTN                          Key;
     245  EFI_GUID                       NameGuid;
     246  EFI_FV_FILE_ATTRIBUTES         Attributes;
     247  EFI_FIRMWARE_VOLUME2_PROTOCOL  *Fv;
    249248
    250249  ASSERT (Buffer != NULL);
    … …  
    255254  //
    256255  HandleBuffer = NULL;
    257   Status = gBS->LocateHandleBuffer (
    258                   ByProtocol,
    259                   &gEfiFirmwareVolume2ProtocolGuid,
    260                   NULL,
    261                   &HandleCount,
    262                   &HandleBuffer
    263                   );
     256  Status       = gBS->LocateHandleBuffer (
     257                        ByProtocol,
     258                        &gEfiFirmwareVolume2ProtocolGuid,
     259                        NULL,
     260                        &HandleCount,
     261                        &HandleBuffer
     262                        );
    264263  if (EFI_ERROR (Status)) {
    265264    return Status;
    … …  
    283282    //
    284283    IndexFile = FileInstance + 1;
    285     Key = 0;
     284    Key       = 0;
    286285    do {
    287286      Status = Fv->GetNextFile (Fv, &Key, &FileType, &NameGuid, &Attributes, Size);
    … …  
    289288        break;
    290289      }
    291       IndexFile --;
     290
     291      IndexFile--;
    292292    } while (IndexFile > 0);
    293293
    … …  
    321321Done:
    322322  if (HandleBuffer != NULL) {
    323     FreePool(HandleBuffer);
     323    FreePool (HandleBuffer);
    324324  }
    325325
    … …  
    373373EFIAPI
    374374GetSectionFromAnyFv  (
    375   IN CONST  EFI_GUID           *NameGuid,
    376   IN        EFI_SECTION_TYPE   SectionType,
    377   IN        UINTN              SectionInstance,
    378   OUT       VOID               **Buffer,
    379   OUT       UINTN              *Size
     375  IN CONST  EFI_GUID          *NameGuid,
     376  IN        EFI_SECTION_TYPE  SectionType,
     377  IN        UINTN             SectionInstance,
     378  OUT       VOID              **Buffer,
     379  OUT       UINTN             *Size
    380380  )
    381381{
    382   EFI_STATUS                    Status;
    383   EFI_HANDLE                    *HandleBuffer;
    384   UINTN                         HandleCount;
    385   UINTN                         Index;
    386   EFI_HANDLE                    FvHandle;
     382  EFI_STATUS  Status;
     383  EFI_HANDLE  *HandleBuffer;
     384  UINTN       HandleCount;
     385  UINTN       Index;
     386  EFI_HANDLE  FvHandle;
    387387
    388388  //
    … …  
    393393  //
    394394  FvHandle = InternalImageHandleToFvHandle (gImageHandle);
    395   Status = InternalGetSectionFromFv (
    396              FvHandle,
    397              NameGuid,
    398              SectionType,
    399              SectionInstance,
    400              Buffer,
    401              Size
    402              );
     395  Status   = InternalGetSectionFromFv (
     396               FvHandle,
     397               NameGuid,
     398               SectionType,
     399               SectionInstance,
     400               Buffer,
     401               Size
     402               );
    403403  if (!EFI_ERROR (Status)) {
    404404    return EFI_SUCCESS;
    … …  
    406406
    407407  HandleBuffer = NULL;
    408   Status = gBS->LocateHandleBuffer (
    409                   ByProtocol,
    410                   &gEfiFirmwareVolume2ProtocolGuid,
    411                   NULL,
    412                   &HandleCount,
    413                   &HandleBuffer
    414                   );
     408  Status       = gBS->LocateHandleBuffer (
     409                        ByProtocol,
     410                        &gEfiFirmwareVolume2ProtocolGuid,
     411                        NULL,
     412                        &HandleCount,
     413                        &HandleBuffer
     414                        );
    415415  if (EFI_ERROR (Status)) {
    416416    goto Done;
    … …  
    435435      }
    436436    }
    437 
    438437  }
    439438
    … …  
    445444
    446445  if (HandleBuffer != NULL) {
    447     FreePool(HandleBuffer);
    448   }
     446    FreePool (HandleBuffer);
     447  }
     448
    449449  return Status;
    450 
    451450}
    452451
    … …  
    499498EFIAPI
    500499GetSectionFromFv (
    501   IN  CONST EFI_GUID                *NameGuid,
    502   IN  EFI_SECTION_TYPE              SectionType,
    503   IN  UINTN                         SectionInstance,
    504   OUT VOID                          **Buffer,
    505   OUT UINTN                         *Size
    506     )
     500  IN  CONST EFI_GUID    *NameGuid,
     501  IN  EFI_SECTION_TYPE  SectionType,
     502  IN  UINTN             SectionInstance,
     503  OUT VOID              **Buffer,
     504  OUT UINTN             *Size
     505  )
    507506{
    508507  return InternalGetSectionFromFv (
    509            InternalImageHandleToFvHandle(gImageHandle),
     508           InternalImageHandleToFvHandle (gImageHandle),
    510509           NameGuid,
    511510           SectionType,
    … …  
    515514           );
    516515}
    517 
    518516
    519517/**
    … …  
    562560EFIAPI
    563561GetSectionFromFfs (
    564   IN  EFI_SECTION_TYPE              SectionType,
    565   IN  UINTN                         SectionInstance,
    566   OUT VOID                          **Buffer,
    567   OUT UINTN                         *Size
    568     )
     562  IN  EFI_SECTION_TYPE  SectionType,
     563  IN  UINTN             SectionInstance,
     564  OUT VOID              **Buffer,
     565  OUT UINTN             *Size
     566  )
    569567{
    570   return InternalGetSectionFromFv(
    571            InternalImageHandleToFvHandle(gImageHandle),
     568  return InternalGetSectionFromFv (
     569           InternalImageHandleToFvHandle (gImageHandle),
    572570           &gEfiCallerIdGuid,
    573571           SectionType,
    … …  
    577575           );
    578576}
    579 
    580577
    581578/**
    … …  
    609606EFIAPI
    610607GetFileBufferByFilePath (
    611   IN BOOLEAN                           BootPolicy,
    612   IN CONST EFI_DEVICE_PATH_PROTOCOL    *FilePath,
    613   OUT      UINTN                       *FileSize,
    614   OUT UINT32                           *AuthenticationStatus
     608  IN BOOLEAN                         BootPolicy,
     609  IN CONST EFI_DEVICE_PATH_PROTOCOL  *FilePath,
     610  OUT      UINTN                     *FileSize,
     611  OUT UINT32                         *AuthenticationStatus
    615612  )
    616613{
    617   EFI_DEVICE_PATH_PROTOCOL          *DevicePathNode;
    618   EFI_DEVICE_PATH_PROTOCOL          *OrigDevicePathNode;
    619   EFI_DEVICE_PATH_PROTOCOL          *TempDevicePathNode;
    620   EFI_HANDLE                        Handle;
    621   EFI_GUID                          *FvNameGuid;
    622   EFI_FIRMWARE_VOLUME2_PROTOCOL     *FwVol;
    623   EFI_SECTION_TYPE                  SectionType;
    624   UINT8                             *ImageBuffer;
    625   UINTN                             ImageBufferSize;
    626   EFI_FV_FILETYPE                   Type;
    627   EFI_FV_FILE_ATTRIBUTES            Attrib;
    628   EFI_SIMPLE_FILE_SYSTEM_PROTOCOL   *Volume;
    629   EFI_FILE_HANDLE                   FileHandle;
    630   EFI_FILE_HANDLE                   LastHandle;
    631   EFI_FILE_INFO                     *FileInfo;
    632   UINTN                             FileInfoSize;
    633   EFI_LOAD_FILE_PROTOCOL            *LoadFile;
    634   EFI_LOAD_FILE2_PROTOCOL           *LoadFile2;
    635   EFI_STATUS                        Status;
     614  EFI_DEVICE_PATH_PROTOCOL         *DevicePathNode;
     615  EFI_DEVICE_PATH_PROTOCOL         *OrigDevicePathNode;
     616  EFI_DEVICE_PATH_PROTOCOL         *TempDevicePathNode;
     617  EFI_HANDLE                       Handle;
     618  EFI_GUID                         *FvNameGuid;
     619  EFI_FIRMWARE_VOLUME2_PROTOCOL    *FwVol;
     620  EFI_SECTION_TYPE                 SectionType;
     621  UINT8                            *ImageBuffer;
     622  UINTN                            ImageBufferSize;
     623  EFI_FV_FILETYPE                  Type;
     624  EFI_FV_FILE_ATTRIBUTES           Attrib;
     625  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *Volume;
     626  EFI_FILE_HANDLE                  FileHandle;
     627  EFI_FILE_HANDLE                  LastHandle;
     628  EFI_FILE_INFO                    *FileInfo;
     629  UINTN                            FileInfoSize;
     630  EFI_LOAD_FILE_PROTOCOL           *LoadFile;
     631  EFI_LOAD_FILE2_PROTOCOL          *LoadFile2;
     632  EFI_STATUS                       Status;
    636633
    637634  //
    638635  // Check input File device path.
    639636  //
    640   if (FilePath == NULL || FileSize == NULL || AuthenticationStatus == NULL) {
     637  if ((FilePath == NULL) || (FileSize == NULL) || (AuthenticationStatus == NULL)) {
    641638    return NULL;
    642639  }
    … …  
    645642  // Init local variable
    646643  //
    647   TempDevicePathNode  = NULL;
    648   FvNameGuid          = NULL;
    649   FileInfo            = NULL;
    650   FileHandle          = NULL;
    651   ImageBuffer         = NULL;
    652   ImageBufferSize     = 0;
     644  TempDevicePathNode    = NULL;
     645  FvNameGuid            = NULL;
     646  FileInfo              = NULL;
     647  FileHandle            = NULL;
     648  ImageBuffer           = NULL;
     649  ImageBufferSize       = 0;
    653650  *AuthenticationStatus = 0;
    654651
    … …  
    666663  //
    667664  DevicePathNode = OrigDevicePathNode;
    668   Status = gBS->LocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &DevicePathNode, &Handle);
     665  Status         = gBS->LocateDevicePath (&gEfiFirmwareVolume2ProtocolGuid, &DevicePathNode, &Handle);
    669666  if (!EFI_ERROR (Status)) {
    670667    //
    671668    // For FwVol File system there is only a single file name that is a GUID.
    672669    //
    673     FvNameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *) DevicePathNode);
     670    FvNameGuid = EfiGetNameGuidFromFwVolDevicePathNode ((CONST MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)DevicePathNode);
    674671    if (FvNameGuid == NULL) {
    675672      Status = EFI_INVALID_PARAMETER;
    … …  
    678675      // Read image from the firmware file
    679676      //
    680       Status = gBS->HandleProtocol (Handle, &gEfiFirmwareVolume2ProtocolGuid, (VOID**)&FwVol);
     677      Status = gBS->HandleProtocol (Handle, &gEfiFirmwareVolume2ProtocolGuid, (VOID **)&FwVol);
    681678      if (!EFI_ERROR (Status)) {
    682679        SectionType = EFI_SECTION_PE32;
    683680        ImageBuffer = NULL;
    684         Status = FwVol->ReadSection (
    685                           FwVol,
    686                           FvNameGuid,
    687                           SectionType,
    688                           0,
    689                           (VOID **)&ImageBuffer,
    690                           &ImageBufferSize,
    691                           AuthenticationStatus
    692                           );
     681        Status      = FwVol->ReadSection (
     682                               FwVol,
     683                               FvNameGuid,
     684                               SectionType,
     685                               0,
     686                               (VOID **)&ImageBuffer,
     687                               &ImageBufferSize,
     688                               AuthenticationStatus
     689                               );
    693690        if (EFI_ERROR (Status)) {
    694691          //
    … …  
    699696            *AuthenticationStatus = 0;
    700697          }
     698
    701699          ImageBuffer = NULL;
    702           Status = FwVol->ReadFile (
    703                             FwVol,
    704                             FvNameGuid,
    705                             (VOID **)&ImageBuffer,
    706                             &ImageBufferSize,
    707                             &Type,
    708                             &Attrib,
    709                             AuthenticationStatus
    710                             );
     700          Status      = FwVol->ReadFile (
     701                                 FwVol,
     702                                 FvNameGuid,
     703                                 (VOID **)&ImageBuffer,
     704                                 &ImageBufferSize,
     705                                 &Type,
     706                                 &Attrib,
     707                                 AuthenticationStatus
     708                                 );
    711709        }
    712710      }
    713711    }
     712
    714713    if (!EFI_ERROR (Status)) {
    715714      goto Finish;
    … …  
    721720  //
    722721  DevicePathNode = OrigDevicePathNode;
    723   Status = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &DevicePathNode, &Handle);
     722  Status         = gBS->LocateDevicePath (&gEfiSimpleFileSystemProtocolGuid, &DevicePathNode, &Handle);
    724723  if (!EFI_ERROR (Status)) {
    725     Status = gBS->HandleProtocol (Handle, &gEfiSimpleFileSystemProtocolGuid, (VOID**)&Volume);
     724    Status = gBS->HandleProtocol (Handle, &gEfiSimpleFileSystemProtocolGuid, (VOID **)&Volume);
    726725    if (!EFI_ERROR (Status)) {
    727726      //
    … …  
    744743          Status = EFI_OUT_OF_RESOURCES;
    745744        }
     745
    746746        //
    747747        // Parse each MEDIA_FILEPATH_DP node. There may be more than one, since the
    … …  
    751751        DevicePathNode = TempDevicePathNode;
    752752        while (!EFI_ERROR (Status) && !IsDevicePathEnd (DevicePathNode)) {
    753           if (DevicePathType (DevicePathNode) != MEDIA_DEVICE_PATH ||
    754               DevicePathSubType (DevicePathNode) != MEDIA_FILEPATH_DP) {
     753          if ((DevicePathType (DevicePathNode) != MEDIA_DEVICE_PATH) ||
     754              (DevicePathSubType (DevicePathNode) != MEDIA_FILEPATH_DP))
     755          {
    755756            Status = EFI_UNSUPPORTED;
    756757            break;
    … …  
    761762
    762763          Status = LastHandle->Open (
    763                                 LastHandle,
    764                                 &FileHandle,
    765                                 ((FILEPATH_DEVICE_PATH *) DevicePathNode)->PathName,
    766                                 EFI_FILE_MODE_READ,
    767                                 0
    768                                 );
     764                                 LastHandle,
     765                                 &FileHandle,
     766                                 ((FILEPATH_DEVICE_PATH *)DevicePathNode)->PathName,
     767                                 EFI_FILE_MODE_READ,
     768                                 0
     769                                 );
    769770
    770771          //
    … …  
    781782          // figure out how big the file is.
    782783          //
    783           FileInfo = NULL;
     784          FileInfo     = NULL;
    784785          FileInfoSize = 0;
    785           Status = FileHandle->GetInfo (
    786                                 FileHandle,
    787                                 &gEfiFileInfoGuid,
    788                                 &FileInfoSize,
    789                                 FileInfo
    790                                 );
     786          Status       = FileHandle->GetInfo (
     787                                       FileHandle,
     788                                       &gEfiFileInfoGuid,
     789                                       &FileInfoSize,
     790                                       FileInfo
     791                                       );
    791792
    792793          if (Status == EFI_BUFFER_TOO_SMALL) {
    … …  
    796797            } else {
    797798              Status = FileHandle->GetInfo (
    798                                     FileHandle,
    799                                     &gEfiFileInfoGuid,
    800                                     &FileInfoSize,
    801                                     FileInfo
    802                                     );
     799                                     FileHandle,
     800                                     &gEfiFileInfoGuid,
     801                                     &FileInfoSize,
     802                                     FileInfo
     803                                     );
    803804            }
    804805          }
    … …  
    822823          }
    823824        }
     825
    824826        //
    825827        // Close the file and Free FileInfo and TempDevicePathNode since we are done
    … …  
    828830          FreePool (FileInfo);
    829831        }
     832
    830833        if (FileHandle != NULL) {
    831834          FileHandle->Close (FileHandle);
    832835        }
     836
    833837        if (TempDevicePathNode != NULL) {
    834838          FreePool (TempDevicePathNode);
    … …  
    836840      }
    837841    }
     842
    838843    if (!EFI_ERROR (Status)) {
    839844      goto Finish;
    … …  
    846851  if (!BootPolicy) {
    847852    DevicePathNode = OrigDevicePathNode;
    848     Status = gBS->LocateDevicePath (&gEfiLoadFile2ProtocolGuid, &DevicePathNode, &Handle);
     853    Status         = gBS->LocateDevicePath (&gEfiLoadFile2ProtocolGuid, &DevicePathNode, &Handle);
    849854    if (!EFI_ERROR (Status)) {
    850       Status = gBS->HandleProtocol (Handle, &gEfiLoadFile2ProtocolGuid, (VOID**)&LoadFile2);
     855      Status = gBS->HandleProtocol (Handle, &gEfiLoadFile2ProtocolGuid, (VOID **)&LoadFile2);
    851856      if (!EFI_ERROR (Status)) {
    852857        //
    … …  
    855860        ImageBufferSize = 0;
    856861        ImageBuffer     = NULL;
    857         Status = LoadFile2->LoadFile (
    858                              LoadFile2,
    859                              DevicePathNode,
    860                              FALSE,
    861                              &ImageBufferSize,
    862                              ImageBuffer
    863                              );
     862        Status          = LoadFile2->LoadFile (
     863                                       LoadFile2,
     864                                       DevicePathNode,
     865                                       FALSE,
     866                                       &ImageBufferSize,
     867                                       ImageBuffer
     868                                       );
    864869        if (Status == EFI_BUFFER_TOO_SMALL) {
    865870          ImageBuffer = AllocatePool (ImageBufferSize);
    … …  
    868873          } else {
    869874            Status = LoadFile2->LoadFile (
    870                                  LoadFile2,
    871                                  DevicePathNode,
    872                                  FALSE,
    873                                  &ImageBufferSize,
    874                                  ImageBuffer
    875                                  );
     875                                  LoadFile2,
     876                                  DevicePathNode,
     877                                  FALSE,
     878                                  &ImageBufferSize,
     879                                  ImageBuffer
     880                                  );
    876881          }
    877882        }
    878883      }
     884
    879885      if (!EFI_ERROR (Status)) {
    880886        goto Finish;
    … …  
    887893  //
    888894  DevicePathNode = OrigDevicePathNode;
    889   Status = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &DevicePathNode, &Handle);
     895  Status         = gBS->LocateDevicePath (&gEfiLoadFileProtocolGuid, &DevicePathNode, &Handle);
    890896  if (!EFI_ERROR (Status)) {
    891     Status = gBS->HandleProtocol (Handle, &gEfiLoadFileProtocolGuid, (VOID**)&LoadFile);
     897    Status = gBS->HandleProtocol (Handle, &gEfiLoadFileProtocolGuid, (VOID **)&LoadFile);
    892898    if (!EFI_ERROR (Status)) {
    893899      //
    … …  
    896902      ImageBufferSize = 0;
    897903      ImageBuffer     = NULL;
    898       Status = LoadFile->LoadFile (
    899                            LoadFile,
    900                            DevicePathNode,
    901                            BootPolicy,
    902                            &ImageBufferSize,
    903                            ImageBuffer
    904                            );
     904      Status          = LoadFile->LoadFile (
     905                                    LoadFile,
     906                                    DevicePathNode,
     907                                    BootPolicy,
     908                                    &ImageBufferSize,
     909                                    ImageBuffer
     910                                    );
    905911      if (Status == EFI_BUFFER_TOO_SMALL) {
    906912        ImageBuffer = AllocatePool (ImageBufferSize);
    … …  
    927933      ImageBuffer = NULL;
    928934    }
     935
    929936    *FileSize = 0;
    930937  } else {
    … …  
    979986  )
    980987{
    981   EFI_STATUS                        Status;
    982   EFI_HANDLE                        *HandleBuffer;
    983   UINTN                             HandleCount;
    984   UINTN                             Index;
    985   EFI_HANDLE                        FvHandle;
    986   EFI_DEVICE_PATH_PROTOCOL          *FvDevicePath;
    987   MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *TempFvFileDevicePath;
    988   VOID                              *Buffer;
    989   UINTN                             Size;
     988  EFI_STATUS                         Status;
     989  EFI_HANDLE                         *HandleBuffer;
     990  UINTN                              HandleCount;
     991  UINTN                              Index;
     992  EFI_HANDLE                         FvHandle;
     993  EFI_DEVICE_PATH_PROTOCOL           *FvDevicePath;
     994  MEDIA_FW_VOL_FILEPATH_DEVICE_PATH  *TempFvFileDevicePath;
     995  VOID                               *Buffer;
     996  UINTN                              Size;
    990997
    991998  if (FvFileDevicePath == NULL) {
    … …  
    10061013  //
    10071014  FvHandle = InternalImageHandleToFvHandle (gImageHandle);
    1008   Status = InternalGetSectionFromFv (
    1009              FvHandle,
    1010              NameGuid,
    1011              SectionType,
    1012              SectionInstance,
    1013              &Buffer,
    1014              &Size
    1015              );
     1015  Status   = InternalGetSectionFromFv (
     1016               FvHandle,
     1017               NameGuid,
     1018               SectionType,
     1019               SectionInstance,
     1020               &Buffer,
     1021               &Size
     1022               );
    10161023  if (!EFI_ERROR (Status)) {
    10171024    goto Done;
    … …  
    10711078        return EFI_OUT_OF_RESOURCES;
    10721079      }
    1073       EfiInitializeFwVolDevicepathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH*)TempFvFileDevicePath, NameGuid);
     1080
     1081      EfiInitializeFwVolDevicepathNode ((MEDIA_FW_VOL_FILEPATH_DEVICE_PATH *)TempFvFileDevicePath, NameGuid);
    10741082      SetDevicePathEndNode (NextDevicePathNode (TempFvFileDevicePath));
    10751083      *FvFileDevicePath = AppendDevicePath (
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette