自学教程：C++ AllocateCopyPool函数代码示例

STATICEFI_STATUSEFIAPIQemuRamfbGraphicsOutputQueryMode (  IN  EFI_GRAPHICS_OUTPUT_PROTOCOL          *This,  IN  UINT32                                ModeNumber,  OUT UINTN                                 *SizeOfInfo,  OUT EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  **Info  ){  EFI_GRAPHICS_OUTPUT_MODE_INFORMATION  *ModeInfo;  if (Info == NULL || SizeOfInfo == NULL ||      ModeNumber >= mQemuRamfbMode.MaxMode) {    return EFI_INVALID_PARAMETER;  }  ModeInfo = &mQemuRamfbModeInfo[ModeNumber];  *Info = AllocateCopyPool (sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION),            ModeInfo);  if (*Info == NULL) {    return EFI_OUT_OF_RESOURCES;  }  *SizeOfInfo = sizeof (EFI_GRAPHICS_OUTPUT_MODE_INFORMATION);  return EFI_SUCCESS;}

/**  Extract filename from device path. The returned buffer is allocated using AllocateCopyPool.  The caller is responsible for freeing the allocated buffer using FreePool().  @param DevicePath       Device path.  @return                 A new allocated string that represents the file name.**/CHAR16 *ExtractFileNameFromDevicePath (  IN   EFI_DEVICE_PATH_PROTOCOL *DevicePath  ){  CHAR16          *String;  CHAR16          *MatchString;  CHAR16          *LastMatch;  CHAR16          *FileName;  UINTN           Length;  ASSERT(DevicePath != NULL);  String = UiDevicePathToStr(DevicePath);  MatchString = String;  LastMatch   = String;  while(MatchString != NULL){    LastMatch   = MatchString + 1;    MatchString = StrStr(LastMatch,L"//");  }  Length = StrLen(LastMatch);  FileName = AllocateCopyPool ((Length + 1) * sizeof(CHAR16), LastMatch);  *(FileName + Length) = 0;  FreePool(String);  return FileName;}

CHAR8*AsciiStrDup (  IN CONST CHAR8* Str  ){  return AllocateCopyPool (AsciiStrSize (Str), Str);}

/**  Returns the current state information for the adapter.  This function returns information of type InformationType from the adapter.  If an adapter does not support the requested informational type, then  EFI_UNSUPPORTED is returned.   @param[in]  This                   A pointer to the EFI_ADAPTER_INFORMATION_PROTOCOL instance.  @param[in]  InformationType        A pointer to an EFI_GUID that defines the contents of InformationBlock.  @param[out] InformationBlock       The service returns a pointer to the buffer with the InformationBlock                                     structure which contains details about the data specific to InformationType.  @param[out] InformationBlockSize   The driver returns the size of the InformationBlock in bytes.  @retval EFI_SUCCESS                The InformationType information was retrieved.  @retval EFI_UNSUPPORTED            The InformationType is not known.  @retval EFI_DEVICE_ERROR           The device reported an error.  @retval EFI_OUT_OF_RESOURCES       The request could not be completed due to a lack of resources.  @retval EFI_INVALID_PARAMETER      This is NULL.   @retval EFI_INVALID_PARAMETER      InformationBlock is NULL.   @retval EFI_INVALID_PARAMETER      InformationBlockSize is NULL.**/EFI_STATUSEFIAPIHstiAipGetInfo (  IN  EFI_ADAPTER_INFORMATION_PROTOCOL  *This,  IN  EFI_GUID                          *InformationType,  OUT VOID                              **InformationBlock,  OUT UINTN                             *InformationBlockSize  ){  HSTI_AIP_PRIVATE_DATA  *HstiAip;  if ((This == NULL) || (InformationBlock == NULL) || (InformationBlockSize == NULL)) {    return EFI_INVALID_PARAMETER;  }  if (!CompareGuid (InformationType, &gAdapterInfoPlatformSecurityGuid)) {    return EFI_UNSUPPORTED;  }  HstiAip = HSTI_AIP_PRIVATE_DATA_FROM_THIS(This);  *InformationBlock = AllocateCopyPool (HstiAip->HstiSize, HstiAip->Hsti);  if (*InformationBlock == NULL) {    return EFI_OUT_OF_RESOURCES;  }  *InformationBlockSize = HstiAip->HstiSize;  return EFI_SUCCESS;}

EFI_STATUSSemihostFsEntryPoint (  IN EFI_HANDLE           ImageHandle,  IN EFI_SYSTEM_TABLE     *SystemTable  ){  EFI_STATUS    Status;  Status = EFI_NOT_FOUND;  if (SemihostConnectionSupported ()) {    mSemihostFsLabel = AllocateCopyPool (StrSize (DEFAULT_SEMIHOST_FS_LABEL), DEFAULT_SEMIHOST_FS_LABEL);    if (mSemihostFsLabel == NULL) {      return EFI_OUT_OF_RESOURCES;    }    Status = gBS->InstallMultipleProtocolInterfaces (                    &gInstallHandle,                    &gEfiSimpleFileSystemProtocolGuid, &gSemihostFs,                    &gEfiDevicePathProtocolGuid,       &gDevicePath,                    NULL                    );    if (EFI_ERROR(Status)) {      FreePool (mSemihostFsLabel);    }  }  return Status;}

CHAR16*UnicodeStrDup (  IN CONST CHAR16* Str  ){  return AllocateCopyPool (StrSize (Str), Str);}

/**  Boot a file selected by user at File Expoloer of BMM.  @param FileContext     The file context data, which contains the device path                         of the file to be boot from.  @retval EFI_SUCCESS    The function completed successfull.  @return Other value if the boot from the file fails.**/EFI_STATUSBootThisFile (  IN BM_FILE_CONTEXT                   *FileContext  ){  EFI_STATUS        Status;  UINTN             ExitDataSize;  CHAR16            *ExitData;  BDS_COMMON_OPTION *Option;  Option = (BDS_COMMON_OPTION *) AllocatePool (sizeof (BDS_COMMON_OPTION));  ASSERT (Option != NULL);  Option->Description     = (CHAR16 *) AllocateCopyPool (StrSize (FileContext->FileName), FileContext->FileName);  Option->DevicePath      = FileContext->DevicePath;  Option->LoadOptionsSize = 0;  Option->LoadOptions     = NULL;  //  // Since current no boot from removable media directly is allowed */  //  gST->ConOut->ClearScreen (gST->ConOut);  ExitDataSize  = 0;  Status        = BdsLibBootViaBootOption (Option, Option->DevicePath, &ExitDataSize, &ExitData);  return Status;}

/**  Copy register table from ACPI NVS memory into SMRAM.  @param[in] DestinationRegisterTableList  Points to destination register table.  @param[in] SourceRegisterTableList       Points to source register table.  @param[in] NumberOfCpus                  Number of CPUs.**/VOIDCopyRegisterTable (  IN CPU_REGISTER_TABLE         *DestinationRegisterTableList,  IN CPU_REGISTER_TABLE         *SourceRegisterTableList,  IN UINT32                     NumberOfCpus  ){  UINTN                      Index;  UINTN                      Index1;  CPU_REGISTER_TABLE_ENTRY   *RegisterTableEntry;  CopyMem (DestinationRegisterTableList, SourceRegisterTableList, NumberOfCpus * sizeof (CPU_REGISTER_TABLE));  for (Index = 0; Index < NumberOfCpus; Index++) {    if (DestinationRegisterTableList[Index].AllocatedSize != 0) {      RegisterTableEntry = AllocateCopyPool (        DestinationRegisterTableList[Index].AllocatedSize,        (VOID *)(UINTN)SourceRegisterTableList[Index].RegisterTableEntry        );      ASSERT (RegisterTableEntry != NULL);      DestinationRegisterTableList[Index].RegisterTableEntry = (EFI_PHYSICAL_ADDRESS)(UINTN)RegisterTableEntry;      //      // Go though all MSRs in register table to initialize MSR spin lock      //      for (Index1 = 0; Index1 < DestinationRegisterTableList[Index].TableLength; Index1++, RegisterTableEntry++) {        if ((RegisterTableEntry->RegisterType == Msr) && (RegisterTableEntry->ValidBitLength < 64)) {          //          // Initialize MSR spin lock only for those MSRs need bit field writing          //          InitMsrSpinLockByIndex (RegisterTableEntry->Index);        }      }    }  }}

EFIAPIGetManFileName(  IN CONST CHAR16 *ManFileName  ){  CHAR16 *Buffer;  if (ManFileName == NULL) {    return (NULL);  }  //  // Fix the file name  //  if (StrnCmp(ManFileName+StrLen(ManFileName)-4, L".man", 4)==0) {    Buffer = AllocateCopyPool(StrSize(ManFileName), ManFileName);  } else {    Buffer = AllocateZeroPool(StrSize(ManFileName) + 4*sizeof(CHAR16));    if (Buffer != NULL) {      StrnCpyS( Buffer,                 (StrSize(ManFileName) + 4*sizeof(CHAR16))/sizeof(CHAR16),                 ManFileName,                 StrLen(ManFileName)                );      StrnCatS( Buffer,                 (StrSize(ManFileName) + 4*sizeof(CHAR16))/sizeof(CHAR16),                L".man",                 4                );    }  }  return (Buffer);}

/**  This function gets driver name from Component Name 2 protocol interface and Component Name protocol interface  in turn. It first tries UEFI 2.0 Component Name 2 protocol interface and try to get the driver name.  If the attempt fails, it then gets the driver name from EFI 1.1 Component Name protocol for backward  compatibility support.  @param  DriverBindingHandle  The handle on which the Component Name (2) protocol instance is retrieved.  @return A pointer to the Unicode string to return. This Unicode string is the name of the controller          specified by ControllerHandle and ChildHandle.**/CHAR16 *DriverHealthManagerGetDriverName (  IN  EFI_HANDLE  DriverBindingHandle  ){  EFI_STATUS      Status;  CHAR16          *DriverName;  //  // Get driver name from UEFI 2.0 Component Name 2 protocol interface.  //  Status = DriverHealthManagerGetDriverNameWorker (&gEfiComponentName2ProtocolGuid, DriverBindingHandle, &DriverName);  if (EFI_ERROR (Status)) {    //    // If it fails to get the driver name from Component Name protocol interface, we should fall back on    // EFI 1.1 Component Name protocol interface.    //    Status = DriverHealthManagerGetDriverNameWorker (&gEfiComponentNameProtocolGuid, DriverBindingHandle, &DriverName);  }  if (!EFI_ERROR (Status)) {    return AllocateCopyPool (StrSize (DriverName), DriverName);  } else {    return ConvertDevicePathToText (DevicePathFromHandle (DriverBindingHandle), FALSE, TRUE);  }}

/**  Check whether current FileName point to a valid  Efi Image File.  @param FileName  File need to be checked.  @retval TRUE  Is Efi Image  @retval FALSE Not a valid Efi Image**/BOOLEANLibIsSupportedFileType (  IN UINT16  *FileName  ){  CHAR16     *InputFileType;  CHAR16     *TmpStr;  BOOLEAN    IsSupported;  if (gFileExplorerPrivate.FileType == NULL) {    return TRUE;  }  InputFileType = LibGetTypeFromName (FileName);  //  // If the file not has *.* style, always return TRUE.  //  if (InputFileType == NULL) {    return TRUE;  }  TmpStr = AllocateCopyPool (StrSize (InputFileType), InputFileType);  ASSERT(TmpStr != NULL);  LibToLowerString(TmpStr);  IsSupported = (StrStr (gFileExplorerPrivate.FileType, TmpStr) == NULL ? FALSE : TRUE);  FreePool (TmpStr);  return IsSupported;}

/**  Cleans off all the quotes in the string.  @param[in]     OriginalString   pointer to the string to be cleaned.  @param[out]   CleanString      The new string with all quotes removed.                                                   Memory allocated in the function and free                                                   by caller.  @retval EFI_SUCCESS   The operation was successful.**/EFI_STATUSShellLevel2StripQuotes (  IN  CONST CHAR16     *OriginalString,  OUT CHAR16           **CleanString  ){  CHAR16            *Walker;    if (OriginalString == NULL || CleanString == NULL) {    return EFI_INVALID_PARAMETER;  }  *CleanString = AllocateCopyPool (StrSize (OriginalString), OriginalString);  if (*CleanString == NULL) {    return EFI_OUT_OF_RESOURCES;  }  for (Walker = *CleanString; Walker != NULL && *Walker != CHAR_NULL ; Walker++) {    if (*Walker == L'/"') {      CopyMem(Walker, Walker+1, StrSize(Walker) - sizeof(Walker[0]));    }  }  return EFI_SUCCESS;}

EFI_STATUSEFIAPIEfiBootManagerRegisterContinueKeyOption (  IN UINT32           Modifier,  ...  ){  EFI_STATUS                   Status;  EFI_BOOT_MANAGER_KEY_OPTION  KeyOption;  VA_LIST                      Args;    if (mContinueKeyOption != NULL) {    return EFI_ALREADY_STARTED;  }  ZeroMem (&KeyOption, sizeof (EFI_BOOT_MANAGER_KEY_OPTION));  VA_START (Args, Modifier);  Status = InitializeKeyFields (Modifier, Args, &KeyOption);  VA_END (Args);  if (!EFI_ERROR (Status)) {    mContinueKeyOption = AllocateCopyPool (sizeof (EFI_BOOT_MANAGER_KEY_OPTION), &KeyOption);    ASSERT (mContinueKeyOption != NULL);    if (mHotkeyServiceStarted) {      ProcessKeyOption (mContinueKeyOption);    }  }  return Status;}

/**  Used to allocate and build a device path node for an SD card on the SD controller.  The BuildDevicePath() function allocates and builds a single device node for the SD  card specified by Slot.  If the SD card specified by Slot is not present on the SD controller, then EFI_NOT_FOUND  is returned.  If DevicePath is NULL, then EFI_INVALID_PARAMETER is returned.  If there are not enough resources to allocate the device path node, then EFI_OUT_OF_RESOURCES  is returned.  Otherwise, DevicePath is allocated with the boot service AllocatePool(), the contents of  DevicePath are initialized to describe the SD card specified by Slot, and EFI_SUCCESS is  returned.  @param[in]     This           A pointer to the EFI_SD_MMMC_PASS_THRU_PROTOCOL instance.  @param[in]     Slot           Specifies the slot number of the SD card for which a device                                path node is to be allocated and built.  @param[in,out] DevicePath     A pointer to a single device path node that describes the SD                                card specified by Slot. This function is responsible for                                allocating the buffer DevicePath with the boot service                                AllocatePool(). It is the caller's responsibility to free                                DevicePath when the caller is finished with DevicePath.  @retval EFI_SUCCESS           The device path node that describes the SD card specified by                                Slot was allocated and returned in DevicePath.  @retval EFI_NOT_FOUND         The SD card specified by Slot does not exist on the SD controller.  @retval EFI_INVALID_PARAMETER DevicePath is NULL.  @retval EFI_OUT_OF_RESOURCES  There are not enough resources to allocate DevicePath.**/EFI_STATUSEFIAPISdMmcPassThruBuildDevicePath (  IN     EFI_SD_MMC_PASS_THRU_PROTOCOL       *This,  IN     UINT8                               Slot,  IN OUT EFI_DEVICE_PATH_PROTOCOL            **DevicePath  ){  SD_MMC_HC_PRIVATE_DATA          *Private;  SD_DEVICE_PATH                  *SdNode;  EMMC_DEVICE_PATH                *EmmcNode;  if ((This == NULL) || (DevicePath == NULL) || (Slot >= SD_MMC_HC_MAX_SLOT)) {    return EFI_INVALID_PARAMETER;  }  Private = SD_MMC_HC_PRIVATE_FROM_THIS (This);  if ((!Private->Slot[Slot].Enable) || (!Private->Slot[Slot].MediaPresent)) {    return EFI_NOT_FOUND;  }  if (Private->Slot[Slot].CardType == SdCardType) {    SdNode = AllocateCopyPool (sizeof (SD_DEVICE_PATH), &mSdDpTemplate);    if (SdNode == NULL) {      return EFI_OUT_OF_RESOURCES;    }    SdNode->SlotNumber = Slot;    *DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) SdNode;  } else if (Private->Slot[Slot].CardType == EmmcCardType) {    EmmcNode = AllocateCopyPool (sizeof (EMMC_DEVICE_PATH), &mEmmcDpTemplate);    if (EmmcNode == NULL) {      return EFI_OUT_OF_RESOURCES;    }    EmmcNode->SlotNumber = Slot;    *DevicePath = (EFI_DEVICE_PATH_PROTOCOL *) EmmcNode;  } else {    //    // Currently we only support SD and EMMC two device nodes.    //    return EFI_NOT_FOUND;  }  return EFI_SUCCESS;}

/**  Get PCD name.  @param[in]    OnlyTokenSpaceName  If TRUE, only need to get the TokenSpaceCName.                                    If FALSE, need to get the full PCD name.  @param[in]    Database            PCD database.  @param[in]    TokenNumber         The PCD token number.  @return       The TokenSpaceCName or full PCD name.**/CHAR8 *GetPcdName (  IN BOOLEAN            OnlyTokenSpaceName,  IN PEI_PCD_DATABASE   *Database,  IN UINTN              TokenNumber  ){  UINT8             *StringTable;  UINTN             NameSize;  PCD_NAME_INDEX    *PcdNameIndex;  CHAR8             *TokenSpaceName;  CHAR8             *PcdName;  CHAR8             *Name;  //  // Return NULL when PCD name table is absent.   //  if (Database->PcdNameTableOffset == 0) {    return NULL;  }  //  // TokenNumber Zero is reserved as PCD_INVALID_TOKEN_NUMBER.  // We have to decrement TokenNumber by 1 to make it usable  // as the array index.  //  TokenNumber--;  StringTable = (UINT8 *) Database + Database->StringTableOffset;  //  // Get the PCD name index.  //  PcdNameIndex = (PCD_NAME_INDEX *)((UINT8 *) Database + Database->PcdNameTableOffset) + TokenNumber;  TokenSpaceName = (CHAR8 *)&StringTable[PcdNameIndex->TokenSpaceCNameIndex];  PcdName = (CHAR8 *)&StringTable[PcdNameIndex->PcdCNameIndex];  if (OnlyTokenSpaceName) {    //    // Only need to get the TokenSpaceCName.    //    Name = AllocateCopyPool (AsciiStrSize (TokenSpaceName), TokenSpaceName);  } else {    //    // Need to get the full PCD name.    //    NameSize = AsciiStrSize (TokenSpaceName) + AsciiStrSize (PcdName);    Name = AllocateZeroPool (NameSize);    ASSERT (Name != NULL);    //    // Catenate TokenSpaceCName and PcdCName with a '.' to form the full PCD name.    //    AsciiStrCatS (Name, NameSize, TokenSpaceName);    Name[AsciiStrSize (TokenSpaceName) - sizeof (CHAR8)] = '.';    AsciiStrCatS (Name, NameSize, PcdName);    }  return Name;}

/**  Save question id and prompt id to the mac device list.  If the same mac address has saved yet, no need to add more.  @param MacAddrString               Mac address string.  @retval  EFI_SUCCESS               Add the item is successful.  @return  Other values if failed to Add the item.**/BOOLEAN AddIdToMacDeviceList (  IN  EFI_STRING        MacAddrString  ){  MENU_INFO_ITEM *TempDeviceList;  UINTN          Index;  EFI_STRING     StoredString;  EFI_STRING_ID  PromptId;  EFI_HII_HANDLE HiiHandle;  HiiHandle =   gDeviceManagerPrivate.HiiHandle;  TempDeviceList = NULL;  for (Index = 0; Index < mMacDeviceList.CurListLen; Index ++) {    StoredString = HiiGetString (HiiHandle, mMacDeviceList.NodeList[Index].PromptId, NULL);    if (StoredString == NULL) {      return FALSE;    }    //    // Already has save the same mac address to the list.    //    if (StrCmp (MacAddrString, StoredString) == 0) {      return FALSE;    }  }  PromptId = HiiSetString(HiiHandle, 0, MacAddrString, NULL);  //  // If not in the list, save it.  //  if (mMacDeviceList.MaxListLen > mMacDeviceList.CurListLen + 1) {    mMacDeviceList.NodeList[mMacDeviceList.CurListLen].PromptId = PromptId;    mMacDeviceList.NodeList[mMacDeviceList.CurListLen].QuestionId = (EFI_QUESTION_ID) (mMacDeviceList.CurListLen + NETWORK_DEVICE_LIST_KEY_OFFSET);  } else {    mMacDeviceList.MaxListLen += MAX_MAC_ADDRESS_NODE_LIST_LEN;    if (mMacDeviceList.CurListLen != 0) {      TempDeviceList = (MENU_INFO_ITEM *)AllocateCopyPool (sizeof (MENU_INFO_ITEM) * mMacDeviceList.MaxListLen, (VOID *)mMacDeviceList.NodeList);    } else {      TempDeviceList = (MENU_INFO_ITEM *)AllocatePool (sizeof (MENU_INFO_ITEM) * mMacDeviceList.MaxListLen);    }    if (TempDeviceList == NULL) {      return FALSE;    }    TempDeviceList[mMacDeviceList.CurListLen].PromptId = PromptId;      TempDeviceList[mMacDeviceList.CurListLen].QuestionId = (EFI_QUESTION_ID) (mMacDeviceList.CurListLen + NETWORK_DEVICE_LIST_KEY_OFFSET);    if (mMacDeviceList.CurListLen > 0) {      FreePool(mMacDeviceList.NodeList);    }    mMacDeviceList.NodeList = TempDeviceList;  }  mMacDeviceList.CurListLen ++;  return TRUE;}

/**  Set information about a file or a file system.  @param[in]  This             A pointer to the EFI_FILE_PROTOCOL instance that                               is the file handle the information is for.  @param[in]  InformationType  The type identifier for the information being set :                               EFI_FILE_INFO_ID or EFI_FILE_SYSTEM_INFO_ID or                               EFI_FILE_SYSTEM_VOLUME_LABEL_ID  @param[in]  BufferSize       The size, in bytes, of Buffer.  @param[in]  Buffer           A pointer to the data buffer to write. The type of the                               data inside the buffer is indicated by InformationType.  @retval  EFI_SUCCESS            The information was set.  @retval  EFI_UNSUPPORTED        The InformationType is not known.  @retval  EFI_DEVICE_ERROR       The last issued semi-hosting operation failed.  @retval  EFI_ACCESS_DENIED      An attempt is being made to change the                                  EFI_FILE_DIRECTORY Attribute.  @retval  EFI_ACCESS_DENIED      InformationType is EFI_FILE_INFO_ID and                                  the file is a read-only file or has been                                  opened in read-only mode and an attempt is                                  being made to modify a field other than                                  Attribute.  @retval  EFI_ACCESS_DENIED      An attempt is made to change the name of a file                                  to a file that is already present.  @retval  EFI_WRITE_PROTECTED    An attempt is being made to modify a                                  read-only attribute.  @retval  EFI_BAD_BUFFER_SIZE    The size of the buffer is lower than that indicated by                                  the data inside the buffer.  @retval  EFI_OUT_OF_RESOURCES   An allocation needed to process the request failed.  @retval  EFI_INVALID_PARAMETER  At least one of the parameters is invalid.**/EFI_STATUSFileSetInfo (  IN EFI_FILE  *This,  IN EFI_GUID  *InformationType,  IN UINTN     BufferSize,  IN VOID      *Buffer  ){  SEMIHOST_FCB          *Fcb;  EFI_FILE_INFO         *Info;  EFI_FILE_SYSTEM_INFO  *SystemInfo;  CHAR16                *VolumeLabel;  if ((This == NULL) || (InformationType == NULL) || (Buffer == NULL)) {    return EFI_INVALID_PARAMETER;  }  Fcb = SEMIHOST_FCB_FROM_THIS (This);  if (CompareGuid (InformationType, &gEfiFileInfoGuid)) {    Info = Buffer;    if (Info->Size < (SIZE_OF_EFI_FILE_INFO + StrSize (Info->FileName))) {      return EFI_INVALID_PARAMETER;    }    if (BufferSize < Info->Size) {      return EFI_BAD_BUFFER_SIZE;    }    return SetFileInfo (Fcb, Info);  } else if (CompareGuid (InformationType, &gEfiFileSystemInfoGuid)) {    SystemInfo = Buffer;    if (SystemInfo->Size <        (SIZE_OF_EFI_FILE_SYSTEM_INFO + StrSize (SystemInfo->VolumeLabel))) {      return EFI_INVALID_PARAMETER;    }    if (BufferSize < SystemInfo->Size) {      return EFI_BAD_BUFFER_SIZE;    }    Buffer = SystemInfo->VolumeLabel;    if (StrSize (Buffer) > 0) {      VolumeLabel = AllocateCopyPool (StrSize (Buffer), Buffer);      if (VolumeLabel != NULL) {        FreePool (mSemihostFsLabel);        mSemihostFsLabel = VolumeLabel;        return EFI_SUCCESS;      } else {        return EFI_OUT_OF_RESOURCES;      }    } else {      return EFI_INVALID_PARAMETER;    }  } else if (!CompareGuid (InformationType, &gEfiFileSystemVolumeLabelInfoIdGuid)) {    return EFI_UNSUPPORTED;  } else {    return EFI_UNSUPPORTED;  }}

/**  This function installs a EFI_CONFIG_ACCESS_PROTOCOL instance for a form package registered  by a module using Framework HII Protocol Interfaces.  UEFI HII require EFI_HII_CONFIG_ACCESS_PROTOCOL to be installed on a EFI_HANDLE, so  that Setup Utility can load the Buffer Storage using this protocol.     @param Packages             The Package List.  @param ThunkContext         The Thunk Context.     @retval  EFI_SUCCESS        The Config Access Protocol is installed successfully.  @retval  EFI_OUT_RESOURCE   There is not enough memory.   **/EFI_STATUSInstallDefaultConfigAccessProtocol (  IN  CONST EFI_HII_PACKAGES                    *Packages,  IN  OUT   HII_THUNK_CONTEXT                   *ThunkContext  ){  EFI_STATUS                                  Status;  CONFIG_ACCESS_PRIVATE                       *ConfigAccessInstance;  HII_VENDOR_DEVICE_PATH                      *HiiVendorPath;  ASSERT (ThunkContext->IfrPackageCount != 0);  ConfigAccessInstance = AllocateCopyPool (                           sizeof (CONFIG_ACCESS_PRIVATE),                            &gConfigAccessPrivateTempate                           );  ASSERT (ConfigAccessInstance != NULL);  //  // Use memory address as unique ID to distinguish from different device paths  // This function may be called multi times by the framework HII driver.  //  HiiVendorPath = AllocateCopyPool (                           sizeof (HII_VENDOR_DEVICE_PATH),                            &mUefiHiiVendorDevicePath                           );  ASSERT (HiiVendorPath != NULL);  HiiVendorPath->Node.UniqueId = (UINT64) ((UINTN) HiiVendorPath);  Status = gBS->InstallMultipleProtocolInterfaces (          &ThunkContext->UefiHiiDriverHandle,          &gEfiDevicePathProtocolGuid,                    HiiVendorPath,          &gEfiHiiConfigAccessProtocolGuid,          &ConfigAccessInstance->ConfigAccessProtocol,          NULL          );  ASSERT_EFI_ERROR (Status);    ConfigAccessInstance->ThunkContext = ThunkContext;    return EFI_SUCCESS;}

/**  Starts a device controller or a bus controller.  @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.  @param[in]  ControllerHandle     The handle of the controller to start. This handle                                    must support a protocol interface that supplies                                    an I/O abstraction to the driver.  @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This                                    parameter is ignored by device drivers, and is optional for bus                                    drivers. For a bus driver, if this parameter is NULL, then handles                                    for all the children of Controller are created by this driver.                                     If this parameter is not NULL and the first Device Path Node is                                    not the End of Device Path Node, then only the handle for the                                    child device specified by the first Device Path Node of                                    RemainingDevicePath is created by this driver.                                   If the first Device Path Node of RemainingDevicePath is                                    the End of Device Path Node, no child handle is created by this                                   driver.  @retval EFI_SUCCESS              The device was started.  @retval EFI_DEVICE_ERROR         The device could not be started due to a device error.Currently not implemented.  @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a lack of resources.  @retval Others                   The driver failded to start the device.**/EFI_STATUSEFIAPIIsaBusDriverBindingStart (  IN EFI_DRIVER_BINDING_PROTOCOL    *This,  IN EFI_HANDLE                     Controller,  IN EFI_DEVICE_PATH_PROTOCOL       *RemainingDevicePath  ){  EFI_STATUS                        Status;  EFI_DEVICE_PATH_PROTOCOL          *DevicePath;  ISA_BUS_PRIVATE_DATA              *Private;  Status = gBS->OpenProtocol (                  Controller,                  &gEfiIsaHcProtocolGuid,                  (VOID **) &mIsaBusPrivateTemplate.IsaHc,                  This->DriverBindingHandle,                  Controller,                  EFI_OPEN_PROTOCOL_BY_DRIVER                  );  if (EFI_ERROR (Status)) {    return Status;  }  Status = gBS->OpenProtocol (                  Controller,                  &gEfiDevicePathProtocolGuid,                  (VOID **) &DevicePath,                  This->DriverBindingHandle,                  Controller,                  EFI_OPEN_PROTOCOL_BY_DRIVER                  );  if (EFI_ERROR (Status)) {    gBS->CloseProtocol (           Controller,           &gEfiIsaHcProtocolGuid,           This->DriverBindingHandle,           Controller           );    return Status;  }  Private = AllocateCopyPool (sizeof (mIsaBusPrivateTemplate), &mIsaBusPrivateTemplate);  ASSERT (Private != NULL);  Private->IsaHcHandle = Controller;  Status = gBS->InstallMultipleProtocolInterfaces (                  &Controller,                  &gEfiIsaHcServiceBindingProtocolGuid, &Private->ServiceBinding,                  NULL                  );  ASSERT_EFI_ERROR (Status);  return Status;}

/**  Extract drive string and path string from FullPath.  The caller must be free Drive and Path.  @param[in]    FullPath    A path to be extracted.  @param[out]   Drive       Buffer to save drive identifier.  @param[out]   Path        Buffer to save path.  @retval       EFI_SUCCESS           Success.  @retval       EFI_OUT_OF_RESOUCES   A memory allocation failed.**/EFI_STATUSExtractDriveAndPath (  IN CONST CHAR16   *FullPath,  OUT CHAR16        **Drive,  OUT CHAR16        **Path  ){  CHAR16 *Splitter;  ASSERT (FullPath != NULL);  Splitter = StrStr (FullPath, L":");  if (Splitter == NULL) {    *Drive = NULL;    *Path = AllocateCopyPool (StrSize (FullPath), FullPath);    if (*Path == NULL) {      return EFI_OUT_OF_RESOURCES;    }  } else {    if (*(Splitter + 1) == CHAR_NULL) {      *Drive = AllocateCopyPool (StrSize (FullPath), FullPath);      *Path = NULL;      if (*Drive == NULL) {        return EFI_OUT_OF_RESOURCES;      }    } else {      *Drive = AllocateCopyPool ((Splitter - FullPath + 2) * sizeof(CHAR16), FullPath);      if (*Drive == NULL) {        return EFI_OUT_OF_RESOURCES;      }      (*Drive)[Splitter - FullPath + 1] = CHAR_NULL;      *Path = AllocateCopyPool (StrSize (Splitter + 1), Splitter + 1);      if (*Path == NULL) {        FreePool (*Drive);        return EFI_OUT_OF_RESOURCES;      }    }  }  return EFI_SUCCESS;}

/**  Make two serial consoles: 1) StdIn and StdOut via GDB. 2) StdErr via GDB.  These console show up on the remote system running GDB**/VOIDGdbInitializeSerialConsole (  VOID  ){  EFI_STATUS      Status;  GDB_SERIAL_DEV  *StdOutSerialDev;  GDB_SERIAL_DEV  *StdErrSerialDev;  // Use the template to make a copy of the Serial Console private data structure.  StdOutSerialDev = AllocateCopyPool (sizeof (GDB_SERIAL_DEV),  &gdbSerialDevTemplate);  ASSERT (StdOutSerialDev != NULL);  // Fixup pointer after the copy  StdOutSerialDev->SerialIo.Mode = &StdOutSerialDev->SerialMode;  StdErrSerialDev = AllocateCopyPool (sizeof (GDB_SERIAL_DEV),  &gdbSerialDevTemplate);  ASSERT (StdErrSerialDev != NULL);  // Fixup pointer and modify stuff that is different for StdError  StdErrSerialDev->SerialIo.Mode = &StdErrSerialDev->SerialMode;  StdErrSerialDev->DevicePath.Index = 1;  StdErrSerialDev->OutFileDescriptor = GDB_STDERR;  // Make a new handle with Serial IO protocol and its device path on it.  Status = gBS->InstallMultipleProtocolInterfaces (                  &StdOutSerialDev->Handle,                  &gEfiSerialIoProtocolGuid,   &StdOutSerialDev->SerialIo,                  &gEfiDevicePathProtocolGuid, &StdOutSerialDev->DevicePath,                  NULL                  );  ASSERT_EFI_ERROR (Status);  // Make a new handle with Serial IO protocol and its device path on it.  Status = gBS->InstallMultipleProtocolInterfaces (                  &StdErrSerialDev->Handle,                  &gEfiSerialIoProtocolGuid,   &StdErrSerialDev->SerialIo,                  &gEfiDevicePathProtocolGuid, &StdErrSerialDev->DevicePath,                  NULL                  );  ASSERT_EFI_ERROR (Status);}

/**  Return the boot description for the controller based on the type.  @param Handle                Controller handle.  @return  The description string.**/CHAR16 *BmGetMiscDescription (  IN EFI_HANDLE                  Handle  ){  EFI_STATUS                      Status;  CHAR16                          *Description;  EFI_BLOCK_IO_PROTOCOL           *BlockIo;  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *Fs;  switch (BmDevicePathType (DevicePathFromHandle (Handle))) {  case BmAcpiFloppyBoot:    Description = L"Floppy";    break;  case BmMessageAtapiBoot:  case BmMessageSataBoot:    Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);    ASSERT_EFI_ERROR (Status);    //    // Assume a removable SATA device should be the DVD/CD device    //    Description = BlockIo->Media->RemovableMedia ? L"DVD/CDROM" : L"Hard Drive";    break;  case BmMessageUsbBoot:    Description = L"USB Device";    break;  case BmMessageScsiBoot:    Description = L"SCSI Device";    break;  case BmHardwareDeviceBoot:    Status = gBS->HandleProtocol (Handle, &gEfiBlockIoProtocolGuid, (VOID **) &BlockIo);    if (!EFI_ERROR (Status)) {      Description = BlockIo->Media->RemovableMedia ? L"Removable Disk" : L"Hard Drive";    } else {      Description = L"Misc Device";    }    break;  default:    Status = gBS->HandleProtocol (Handle, &gEfiSimpleFileSystemProtocolGuid, (VOID **) &Fs);    if (!EFI_ERROR (Status)) {      Description = L"Non-Block Boot Device";    } else {      Description = L"Misc Device";    }    break;  }  return AllocateCopyPool (StrSize (Description), Description);}

/**  Initialize a PCI_ROOT_BRIDGE structure.  @param[in]  Supports         Supported attributes.  @param[in]  Attributes       Initial attributes.  @param[in]  AllocAttributes  Allocation attributes.  @param[in]  RootBusNumber    The bus number to store in RootBus.  @param[in]  MaxSubBusNumber  The inclusive maximum bus number that can be                               assigned to any subordinate bus found behind any                               PCI bridge hanging off this root bus.                               The caller is repsonsible for ensuring that                               RootBusNumber <= MaxSubBusNumber. If                               RootBusNumber equals MaxSubBusNumber, then the                               root bus has no room for subordinate buses.  @param[in]  Io               IO aperture.  @param[in]  Mem              MMIO aperture.  @param[in]  MemAbove4G       MMIO aperture above 4G.  @param[in]  PMem             Prefetchable MMIO aperture.  @param[in]  PMemAbove4G      Prefetchable MMIO aperture above 4G.  @param[out] RootBus          The PCI_ROOT_BRIDGE structure (allocated by the                               caller) that should be filled in by this                               function.  @retval EFI_SUCCESS           Initialization successful. A device path                                consisting of an ACPI device path node, with                                UID = RootBusNumber, has been allocated and                                linked into RootBus.  @retval EFI_OUT_OF_RESOURCES  Memory allocation failed.**/EFI_STATUSInitRootBridge (  IN  UINT64                   Supports,  IN  UINT64                   Attributes,  IN  UINT64                   AllocAttributes,  IN  UINT8                    RootBusNumber,  IN  UINT8                    MaxSubBusNumber,  IN  PCI_ROOT_BRIDGE_APERTURE *Io,  IN  PCI_ROOT_BRIDGE_APERTURE *Mem,  IN  PCI_ROOT_BRIDGE_APERTURE *MemAbove4G,  IN  PCI_ROOT_BRIDGE_APERTURE *PMem,  IN  PCI_ROOT_BRIDGE_APERTURE *PMemAbove4G,  OUT PCI_ROOT_BRIDGE          *RootBus){  CB_PCI_ROOT_BRIDGE_DEVICE_PATH *DevicePath;  //  // Be safe if other fields are added to PCI_ROOT_BRIDGE later.  //  ZeroMem (RootBus, sizeof *RootBus);  RootBus->Segment = 0;  RootBus->Supports   = Supports;  RootBus->Attributes = Attributes;  RootBus->DmaAbove4G = FALSE;  RootBus->AllocationAttributes = AllocAttributes;  RootBus->Bus.Base  = RootBusNumber;  RootBus->Bus.Limit = MaxSubBusNumber;  CopyMem (&RootBus->Io, Io, sizeof (*Io));  CopyMem (&RootBus->Mem, Mem, sizeof (*Mem));  CopyMem (&RootBus->MemAbove4G, MemAbove4G, sizeof (*MemAbove4G));  CopyMem (&RootBus->PMem, PMem, sizeof (*PMem));  CopyMem (&RootBus->PMemAbove4G, PMemAbove4G, sizeof (*PMemAbove4G));  RootBus->NoExtendedConfigSpace = FALSE;  DevicePath = AllocateCopyPool (sizeof (mRootBridgeDevicePathTemplate),                                 &mRootBridgeDevicePathTemplate);  if (DevicePath == NULL) {    DEBUG ((EFI_D_ERROR, "%a: %r/n", __FUNCTION__, EFI_OUT_OF_RESOURCES));    return EFI_OUT_OF_RESOURCES;  }  DevicePath->AcpiDevicePath.UID = RootBusNumber;  RootBus->DevicePath = (EFI_DEVICE_PATH_PROTOCOL *)DevicePath;  DEBUG ((EFI_D_INFO,          "%a: populated root bus %d, with room for %d subordinate bus(es)/n",          __FUNCTION__, RootBusNumber, MaxSubBusNumber - RootBusNumber));  return EFI_SUCCESS;}

/**  Caller provided function to be invoked at the end of DebugPortInitialize().  Refer to the description for DebugPortInitialize() for more details.  @param[in] Context           The first input argument of DebugPortInitialize().  @param[in] DebugPortHandle   Debug port handle created by Debug Communication Library.**/VOIDEFIAPIInitializeDebugAgentPhase2 (  IN VOID                  *Context,  IN DEBUG_PORT_HANDLE     DebugPortHandle  ){  DEBUG_AGENT_PHASE2_CONTEXT *Phase2Context;  UINT64                     *MailboxLocation;  DEBUG_AGENT_MAILBOX        *Mailbox;  EFI_SEC_PEI_HAND_OFF       *SecCoreData;  UINT16                     BufferSize;  UINT64                     NewDebugPortHandle;  Phase2Context = (DEBUG_AGENT_PHASE2_CONTEXT *) Context;  MailboxLocation = GetLocationSavedMailboxPointerInIdtEntry ();  Mailbox = (DEBUG_AGENT_MAILBOX *)(UINTN)(*MailboxLocation);  BufferSize = PcdGet16(PcdDebugPortHandleBufferSize);  if (Phase2Context->InitFlag == DEBUG_AGENT_INIT_PEI && BufferSize != 0) {    NewDebugPortHandle = (UINT64)(UINTN)AllocateCopyPool (BufferSize, DebugPortHandle);  } else {    NewDebugPortHandle = (UINT64)(UINTN)DebugPortHandle;  }  UpdateMailboxContent (Mailbox, DEBUG_MAILBOX_DEBUG_PORT_HANDLE_INDEX, NewDebugPortHandle);  //  // Trigger one software interrupt to inform HOST  //  TriggerSoftInterrupt (SYSTEM_RESET_SIGNATURE);  if (Phase2Context->InitFlag == DEBUG_AGENT_INIT_PREMEM_SEC) {    //    // If Temporary RAM region is below 128 MB, then send message to    // host to disable low memory filtering.    //    SecCoreData = (EFI_SEC_PEI_HAND_OFF *)Phase2Context->Context;    if ((UINTN)SecCoreData->TemporaryRamBase < BASE_128MB && IsHostAttached ()) {      SetDebugFlag (DEBUG_AGENT_FLAG_MEMORY_READY, 1);      TriggerSoftInterrupt (MEMORY_READY_SIGNATURE);    }    //    // Enable Debug Timer interrupt    //    SaveAndSetDebugTimerInterrupt (TRUE);    //    // Enable CPU interrupts so debug timer interrupts can be delivered    //    EnableInterrupts ();    //    // Call continuation function if it is not NULL.    //    Phase2Context->Function (Phase2Context->Context);  }}

STATICEFI_STATUSSupportedDevicePathsInit (  VOID  ){  EFI_STATUS                          Status;  CHAR16*                             DevicePathListStr;  CHAR16*                             DevicePathStr;  CHAR16*                             NextDevicePathStr;  EFI_DEVICE_PATH_FROM_TEXT_PROTOCOL *EfiDevicePathFromTextProtocol;  EFI_DEVICE_PATH_PROTOCOL           *Instance;  Status = gBS->LocateProtocol (&gEfiDevicePathFromTextProtocolGuid, NULL, (VOID **)&EfiDevicePathFromTextProtocol);  ASSERT_EFI_ERROR (Status);  // Initialize Variable  DevicePathListStr = (CHAR16*)PcdGetPtr (PcdBootMonFsSupportedDevicePaths);  mBootMonFsSupportedDevicePaths = NULL;  // Extract the Device Path instances from the multi-device path string  while ((DevicePathListStr != NULL) && (DevicePathListStr[0] != L'/0')) {    NextDevicePathStr = StrStr (DevicePathListStr, L";");    if (NextDevicePathStr == NULL) {      DevicePathStr = DevicePathListStr;      DevicePathListStr = NULL;    } else {      DevicePathStr = (CHAR16*)AllocateCopyPool ((NextDevicePathStr - DevicePathListStr + 1) * sizeof (CHAR16), DevicePathListStr);      if (DevicePathStr == NULL) {        return EFI_OUT_OF_RESOURCES;      }      *(DevicePathStr + (NextDevicePathStr - DevicePathListStr)) = L'/0';      DevicePathListStr = NextDevicePathStr;      if (DevicePathListStr[0] == L';') {        DevicePathListStr++;      }    }    Instance = EfiDevicePathFromTextProtocol->ConvertTextToDevicePath (DevicePathStr);    ASSERT (Instance != NULL);    mBootMonFsSupportedDevicePaths = AppendDevicePathInstance (mBootMonFsSupportedDevicePaths, Instance);    if (NextDevicePathStr != NULL) {      FreePool (DevicePathStr);    }    FreePool (Instance);  }  if (mBootMonFsSupportedDevicePaths == NULL) {    return EFI_UNSUPPORTED;  } else {    return EFI_SUCCESS;  }}

EFIAPIGetExecuatableFileName (  IN CONST CHAR16    *NameString  ){  CHAR16  *Buffer;  CHAR16  *SuffixStr;  if (NameString == NULL) {    return (NULL);  }  //  // Fix the file name  //  if (StrnCmp(NameString+StrLen(NameString)-StrLen(L".efi"), L".efi", StrLen(L".efi"))==0) {    Buffer = AllocateCopyPool(StrSize(NameString), NameString);  } else if (StrnCmp(NameString+StrLen(NameString)-StrLen(L".man"), L".man", StrLen(L".man"))==0) {    Buffer = AllocateCopyPool(StrSize(NameString), NameString);    if (Buffer != NULL) {      SuffixStr = Buffer+StrLen(Buffer)-StrLen(L".man");      StrnCpyS (SuffixStr, StrSize(L".man")/sizeof(CHAR16), L".efi", StrLen(L".efi"));    }  } else {    Buffer = AllocateZeroPool(StrSize(NameString) + StrLen(L".efi")*sizeof(CHAR16));    if (Buffer != NULL) {      StrnCpyS( Buffer,                (StrSize(NameString) + StrLen(L".efi")*sizeof(CHAR16))/sizeof(CHAR16),                NameString,                StrLen(NameString)                );      StrnCatS( Buffer,                (StrSize(NameString) + StrLen(L".efi")*sizeof(CHAR16))/sizeof(CHAR16),                L".efi",                StrLen(L".efi")                );    }  }  return (Buffer);}

/**  Returns a list of ACPI resource descriptors that detail the special resource  configuration requirements for an incompatible PCI device.  Prior to bus enumeration, the PCI bus driver will look for the presence of  the EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL. Only one instance of this  protocol can be present in the system. For each PCI device that the PCI bus  driver discovers, the PCI bus driver calls this function with the device's  vendor ID, device ID, revision ID, subsystem vendor ID, and subsystem device  ID. If the VendorId, DeviceId, RevisionId, SubsystemVendorId, or  SubsystemDeviceId value is set to (UINTN)-1, that field will be ignored. The  ID values that are not (UINTN)-1 will be used to identify the current device.  This function will only return EFI_SUCCESS. However, if the device is an  incompatible PCI device, a list of ACPI resource descriptors will be returned  in Configuration. Otherwise, NULL will be returned in Configuration instead.  The PCI bus driver does not need to allocate memory for Configuration.  However, it is the PCI bus driver's responsibility to free it. The PCI bus  driver then can configure this device with the information that is derived  from this list of resource nodes, rather than the result of BAR probing.  Only the following two resource descriptor types from the ACPI Specification  may be used to describe the incompatible PCI device resource requirements:  - QWORD Address Space Descriptor (ACPI 2.0, section 6.4.3.5.1; also ACPI 3.0)  - End Tag (ACPI 2.0, section 6.4.2.8; also ACPI 3.0)  The QWORD Address Space Descriptor can describe memory, I/O, and bus number  ranges for dynamic or fixed resources. The configuration of a PCI root bridge  is described with one or more QWORD Address Space Descriptors, followed by an  End Tag. See the ACPI Specification for details on the field values.  @param[in]  This                Pointer to the                                  EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL                                  instance.  @param[in]  VendorId            A unique ID to identify the manufacturer of                                  the PCI device.  See the Conventional PCI                                  Specification 3.0 for details.  @param[in]  DeviceId            A unique ID to identify the particular PCI                                  device. See the Conventional PCI                                  Specification 3.0 for details.  @param[in]  RevisionId          A PCI device-specific revision identifier.                                  See the Conventional PCI Specification 3.0                                  for details.  @param[in]  SubsystemVendorId   Specifies the subsystem vendor ID. See the                                  Conventional PCI Specification 3.0 for                                  details.  @param[in]  SubsystemDeviceId   Specifies the subsystem device ID. See the                                  Conventional PCI Specification 3.0 for                                  details.  @param[out] Configuration       A list of ACPI resource descriptors that                                  detail the configuration requirement.  @retval EFI_SUCCESS   The function always returns EFI_SUCCESS.**/STATICEFI_STATUSEFIAPICheckDevice (  IN  EFI_INCOMPATIBLE_PCI_DEVICE_SUPPORT_PROTOCOL  *This,  IN  UINTN                                         VendorId,  IN  UINTN                                         DeviceId,  IN  UINTN                                         RevisionId,  IN  UINTN                                         SubsystemVendorId,  IN  UINTN                                         SubsystemDeviceId,  OUT VOID                                          **Configuration  ){  mCheckDeviceCalled = TRUE;  //  // Unlike the general description of this protocol member suggests, there is  // nothing incompatible about the PCI devices that we'll match here. We'll  // match all PCI devices, and generate exactly one QWORD Address Space  // Descriptor for each. That descriptor will instruct the PCI Bus UEFI_DRIVER  // not to degrade 64-bit MMIO BARs for the device, even if a PCI option ROM  // BAR is present on the device.  //  // The concern captured in the PCI Bus UEFI_DRIVER is that a legacy BIOS boot  // (via a CSM) could dispatch a legacy option ROM on the device, which might  // have trouble with MMIO BARs that have been allocated outside of the 32-bit  // address space. But, if we don't support legacy option ROMs at all, then  // this problem cannot arise.  //  if (mLegacyBiosInstalled) {    //    // Don't interfere with resource degradation.    //    *Configuration = NULL;    return EFI_SUCCESS;  }  //  // This member function is mis-specified actually: it is supposed to allocate  // memory, but as specified, it could not return an error status. Thankfully,//.........这里部分代码省略.........

/**  Initialize a load option.  @param Option           Pointer to the load option to be initialized.  @param OptionNumber     Option number of the load option.  @param OptionType       Type of the load option.  @param Attributes       Attributes of the load option.  @param Description      Description of the load option.  @param FilePath         Device path of the load option.  @param OptionalData     Optional data of the load option.  @param OptionalDataSize Size of the optional data of the load option.  @retval EFI_SUCCESS           The load option was initialized successfully.  @retval EFI_INVALID_PARAMETER Option, Description or FilePath is NULL.**/EFI_STATUSEFIAPIEfiBootManagerInitializeLoadOption (  IN OUT EFI_BOOT_MANAGER_LOAD_OPTION   *Option,  IN  UINTN                             OptionNumber,  IN  EFI_BOOT_MANAGER_LOAD_OPTION_TYPE OptionType,  IN  UINT32                            Attributes,  IN  CHAR16                            *Description,  IN  EFI_DEVICE_PATH_PROTOCOL          *FilePath,  IN  UINT8                             *OptionalData,   OPTIONAL  IN  UINT32                            OptionalDataSize  ){  if ((Option == NULL) || (Description == NULL) || (FilePath == NULL)) {    return EFI_INVALID_PARAMETER;  }  if (((OptionalData != NULL) && (OptionalDataSize == 0)) ||      ((OptionalData == NULL) && (OptionalDataSize != 0))) {    return EFI_INVALID_PARAMETER;  }  if ((UINT32) OptionType >= LoadOptionTypeMax) {    return EFI_INVALID_PARAMETER;  }  ZeroMem (Option, sizeof (EFI_BOOT_MANAGER_LOAD_OPTION));  Option->OptionNumber       = OptionNumber;  Option->OptionType         = OptionType;  Option->Attributes         = Attributes;  Option->Description        = AllocateCopyPool (StrSize (Description), Description);  Option->FilePath           = DuplicateDevicePath (FilePath);  if (OptionalData != NULL) {    Option->OptionalData     = AllocateCopyPool (OptionalDataSize, OptionalData);    Option->OptionalDataSize = OptionalDataSize;  }  return EFI_SUCCESS;}

/**  Split a string with specified separator and save the substring to a list.  @param[in]    String       The pointer of the input string.  @param[in]    Separator    The specified separator.  @return The pointer of headnode of ARG_LIST.**/ARG_LIST *SplitStrToList (  IN CONST CHAR16    *String,  IN CHAR16          Separator  ){  CHAR16      *Str;  CHAR16      *ArgStr;  ARG_LIST    *ArgList;  ARG_LIST    *ArgNode;  if (String == NULL || *String == L'/0') {    return NULL;  }  //  // Copy the CONST string to a local copy.  //  Str     = AllocateCopyPool (StrSize (String), String);  ASSERT (Str != NULL);  ArgStr  = Str;  //  // init a node for the list head.  //  ArgNode = (ARG_LIST *) AllocateZeroPool (sizeof (ARG_LIST));  ASSERT (ArgNode != NULL);  ArgList = ArgNode;  //  // Split the local copy and save in the list node.  //  while (*Str != L'/0') {    if (*Str == Separator) {      *Str          = L'/0';      ArgNode->Arg  = ArgStr;      ArgStr        = Str + 1;      ArgNode->Next = (ARG_LIST *) AllocateZeroPool (sizeof (ARG_LIST));      ASSERT (ArgNode->Next != NULL);      ArgNode = ArgNode->Next;    }    Str++;  }  ArgNode->Arg  = ArgStr;  ArgNode->Next = NULL;  return ArgList;}