UefiLib.c

Go to the documentation of this file.

 
#include "UefiLibInternal.h"
 
EFI_STATUS
EFIAPI
UefiLibConstructor (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  return EFI_SUCCESS;
}
 
BOOLEAN
CompareIso639LanguageCode (
  IN CONST CHAR8  *Language1,
  IN CONST CHAR8  *Language2
  )
{
  UINT32  Name1;
  UINT32  Name2;
 
  Name1 = ReadUnaligned24 ((CONST UINT32 *)Language1);
  Name2 = ReadUnaligned24 ((CONST UINT32 *)Language2);
 
  return (BOOLEAN)(Name1 == Name2);
}
 
EFI_STATUS
EFIAPI
EfiGetSystemConfigurationTable (
  IN  EFI_GUID  *TableGuid,
  OUT VOID      **Table
  )
{
  EFI_SYSTEM_TABLE  *SystemTable;
  UINTN             Index;
 
  ASSERT (TableGuid != NULL);
  ASSERT (Table != NULL);
 
  SystemTable = gST;
  *Table      = NULL;
  for (Index = 0; Index < SystemTable->NumberOfTableEntries; Index++) {
    if (CompareGuid (TableGuid, &(SystemTable->ConfigurationTable[Index].VendorGuid))) {
      *Table = SystemTable->ConfigurationTable[Index].VendorTable;
      return EFI_SUCCESS;
    }
  }
 
  return EFI_NOT_FOUND;
}
 
EFI_EVENT
EFIAPI
EfiCreateProtocolNotifyEvent (
  IN  EFI_GUID          *ProtocolGuid,
  IN  EFI_TPL           NotifyTpl,
  IN  EFI_EVENT_NOTIFY  NotifyFunction,
  IN  VOID              *NotifyContext   OPTIONAL,
  OUT VOID              **Registration
  )
{
  EFI_STATUS  Status;
  EFI_EVENT   Event;
 
  ASSERT (ProtocolGuid != NULL);
  ASSERT (NotifyFunction != NULL);
  ASSERT (Registration != NULL);
 
  //
  // Create the event
  //
 
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  NotifyTpl,
                  NotifyFunction,
                  NotifyContext,
                  &Event
                  );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Register for protocol notifications on this event
  //
 
  Status = gBS->RegisterProtocolNotify (
                  ProtocolGuid,
                  Event,
                  Registration
                  );
 
  ASSERT_EFI_ERROR (Status);
 
  //
  // Kick the event so we will perform an initial pass of
  // current installed drivers
  //
 
  gBS->SignalEvent (Event);
  return Event;
}
 
EFI_STATUS
EFIAPI
EfiNamedEventListen (
  IN CONST EFI_GUID    *Name,
  IN EFI_TPL           NotifyTpl,
  IN EFI_EVENT_NOTIFY  NotifyFunction,
  IN CONST VOID        *NotifyContext   OPTIONAL,
  OUT VOID             *Registration OPTIONAL
  )
{
  EFI_STATUS  Status;
  EFI_EVENT   Event;
  VOID        *RegistrationLocal;
 
  ASSERT (Name != NULL);
  ASSERT (NotifyFunction != NULL);
  ASSERT (NotifyTpl <= TPL_HIGH_LEVEL);
 
  //
  // Create event
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  NotifyTpl,
                  NotifyFunction,
                  (VOID *)NotifyContext,
                  &Event
                  );
  ASSERT_EFI_ERROR (Status);
 
  //
  // The Registration is not optional to RegisterProtocolNotify().
  // To make it optional to EfiNamedEventListen(), may need to substitute with a local.
  //
  if (Registration != NULL) {
    RegistrationLocal = Registration;
  } else {
    RegistrationLocal = &RegistrationLocal;
  }
 
  //
  // Register for an installation of protocol interface
  //
 
  Status = gBS->RegisterProtocolNotify (
                  (EFI_GUID *)Name,
                  Event,
                  RegistrationLocal
                  );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiNamedEventSignal (
  IN CONST EFI_GUID  *Name
  )
{
  EFI_STATUS  Status;
  EFI_HANDLE  Handle;
 
  ASSERT (Name != NULL);
 
  Handle = NULL;
  Status = gBS->InstallProtocolInterface (
                  &Handle,
                  (EFI_GUID *)Name,
                  EFI_NATIVE_INTERFACE,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);
 
  Status = gBS->UninstallProtocolInterface (
                  Handle,
                  (EFI_GUID *)Name,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
EfiEventGroupSignal (
  IN CONST EFI_GUID  *EventGroup
  )
{
  EFI_STATUS  Status;
  EFI_EVENT   Event;
 
  if (EventGroup == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  Status = gBS->CreateEventEx (
                  EVT_NOTIFY_SIGNAL,
                  TPL_CALLBACK,
                  EfiEventEmptyFunction,
                  NULL,
                  EventGroup,
                  &Event
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = gBS->SignalEvent (Event);
  gBS->CloseEvent (Event);
 
  return Status;
}
 
VOID
EFIAPI
EfiEventEmptyFunction (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
}
 
EFI_TPL
EFIAPI
EfiGetCurrentTpl (
  VOID
  )
{
  EFI_TPL  Tpl;
 
  Tpl = gBS->RaiseTPL (TPL_HIGH_LEVEL);
  gBS->RestoreTPL (Tpl);
 
  return Tpl;
}
 
EFI_LOCK *
EFIAPI
EfiInitializeLock (
  IN OUT EFI_LOCK  *Lock,
  IN EFI_TPL       Priority
  )
{
  ASSERT (Lock != NULL);
  ASSERT (Priority <= TPL_HIGH_LEVEL);
 
  Lock->Tpl      = Priority;
  Lock->OwnerTpl = TPL_APPLICATION;
  Lock->Lock     = EfiLockReleased;
  return Lock;
}
 
VOID
EFIAPI
EfiAcquireLock (
  IN EFI_LOCK  *Lock
  )
{
  ASSERT (Lock != NULL);
  ASSERT (Lock->Lock == EfiLockReleased);
 
  Lock->OwnerTpl = gBS->RaiseTPL (Lock->Tpl);
  Lock->Lock     = EfiLockAcquired;
}
 
EFI_STATUS
EFIAPI
EfiAcquireLockOrFail (
  IN EFI_LOCK  *Lock
  )
{
  ASSERT (Lock != NULL);
  ASSERT (Lock->Lock != EfiLockUninitialized);
 
  if (Lock->Lock == EfiLockAcquired) {
    //
    // Lock is already owned, so bail out
    //
    return EFI_ACCESS_DENIED;
  }
 
  Lock->OwnerTpl = gBS->RaiseTPL (Lock->Tpl);
 
  Lock->Lock = EfiLockAcquired;
 
  return EFI_SUCCESS;
}
 
VOID
EFIAPI
EfiReleaseLock (
  IN EFI_LOCK  *Lock
  )
{
  EFI_TPL  Tpl;
 
  ASSERT (Lock != NULL);
  ASSERT (Lock->Lock == EfiLockAcquired);
 
  Tpl = Lock->OwnerTpl;
 
  Lock->Lock = EfiLockReleased;
 
  gBS->RestoreTPL (Tpl);
}
 
EFI_STATUS
EFIAPI
EfiTestManagedDevice (
  IN CONST EFI_HANDLE  ControllerHandle,
  IN CONST EFI_HANDLE  DriverBindingHandle,
  IN CONST EFI_GUID    *ProtocolGuid
  )
{
  EFI_STATUS  Status;
  VOID        *ManagedInterface;
 
  ASSERT (ProtocolGuid != NULL);
 
  Status = gBS->OpenProtocol (
                  ControllerHandle,
                  (EFI_GUID *)ProtocolGuid,
                  &ManagedInterface,
                  DriverBindingHandle,
                  ControllerHandle,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (!EFI_ERROR (Status)) {
    gBS->CloseProtocol (
           ControllerHandle,
           (EFI_GUID *)ProtocolGuid,
           DriverBindingHandle,
           ControllerHandle
           );
    return EFI_UNSUPPORTED;
  }
 
  if (Status != EFI_ALREADY_STARTED) {
    return EFI_UNSUPPORTED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EfiTestChildHandle (
  IN CONST EFI_HANDLE  ControllerHandle,
  IN CONST EFI_HANDLE  ChildHandle,
  IN CONST EFI_GUID    *ProtocolGuid
  )
{
  EFI_STATUS                           Status;
  EFI_OPEN_PROTOCOL_INFORMATION_ENTRY  *OpenInfoBuffer;
  UINTN                                EntryCount;
  UINTN                                Index;
 
  ASSERT (ProtocolGuid != NULL);
 
  //
  // Retrieve the list of agents that are consuming the specific protocol
  // on ControllerHandle.
  //
  Status = gBS->OpenProtocolInformation (
                  ControllerHandle,
                  (EFI_GUID *)ProtocolGuid,
                  &OpenInfoBuffer,
                  &EntryCount
                  );
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Inspect if ChildHandle is one of the agents.
  //
  Status = EFI_UNSUPPORTED;
  for (Index = 0; Index < EntryCount; Index++) {
    if ((OpenInfoBuffer[Index].ControllerHandle == ChildHandle) &&
        ((OpenInfoBuffer[Index].Attributes & EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER) != 0))
    {
      Status = EFI_SUCCESS;
      break;
    }
  }
 
  FreePool (OpenInfoBuffer);
  return Status;
}
 
EFI_STATUS
EFIAPI
IsLanguageSupported (
  IN CONST CHAR8  *SupportedLanguages,
  IN CONST CHAR8  *TargetLanguage
  )
{
  UINTN  Index;
 
  while (*SupportedLanguages != 0) {
    for (Index = 0; SupportedLanguages[Index] != 0 && SupportedLanguages[Index] != ';'; Index++) {
    }
 
    if ((AsciiStrnCmp (SupportedLanguages, TargetLanguage, Index) == 0) && (TargetLanguage[Index] == 0)) {
      return EFI_SUCCESS;
    }
 
    SupportedLanguages += Index;
    for ( ; *SupportedLanguages != 0 && *SupportedLanguages == ';'; SupportedLanguages++) {
    }
  }
 
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
LookupUnicodeString (
  IN CONST CHAR8                     *Language,
  IN CONST CHAR8                     *SupportedLanguages,
  IN CONST EFI_UNICODE_STRING_TABLE  *UnicodeStringTable,
  OUT CHAR16                         **UnicodeString
  )
{
  //
  // Make sure the parameters are valid
  //
  if ((Language == NULL) || (UnicodeString == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // If there are no supported languages, or the Unicode String Table is empty, then the
  // Unicode String specified by Language is not supported by this Unicode String Table
  //
  if ((SupportedLanguages == NULL) || (UnicodeStringTable == NULL)) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Make sure Language is in the set of Supported Languages
  //
  while (*SupportedLanguages != 0) {
    if (CompareIso639LanguageCode (Language, SupportedLanguages)) {
      //
      // Search the Unicode String Table for the matching Language specifier
      //
      while (UnicodeStringTable->Language != NULL) {
        if (CompareIso639LanguageCode (Language, UnicodeStringTable->Language)) {
          //
          // A matching string was found, so return it
          //
          *UnicodeString = UnicodeStringTable->UnicodeString;
          return EFI_SUCCESS;
        }
 
        UnicodeStringTable++;
      }
 
      return EFI_UNSUPPORTED;
    }
 
    SupportedLanguages += 3;
  }
 
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
LookupUnicodeString2 (
  IN CONST CHAR8                     *Language,
  IN CONST CHAR8                     *SupportedLanguages,
  IN CONST EFI_UNICODE_STRING_TABLE  *UnicodeStringTable,
  OUT CHAR16                         **UnicodeString,
  IN BOOLEAN                         Iso639Language
  )
{
  BOOLEAN  Found;
  UINTN    Index;
  CHAR8    *LanguageString;
 
  //
  // Make sure the parameters are valid
  //
  if ((Language == NULL) || (UnicodeString == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // If there are no supported languages, or the Unicode String Table is empty, then the
  // Unicode String specified by Language is not supported by this Unicode String Table
  //
  if ((SupportedLanguages == NULL) || (UnicodeStringTable == NULL)) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Make sure Language is in the set of Supported Languages
  //
  Found = FALSE;
  if (Iso639Language) {
    while (*SupportedLanguages != 0) {
      if (CompareIso639LanguageCode (Language, SupportedLanguages)) {
        Found = TRUE;
        break;
      }
 
      SupportedLanguages += 3;
    }
  } else {
    Found = !IsLanguageSupported (SupportedLanguages, Language);
  }
 
  //
  // If Language is not a member of SupportedLanguages, then return EFI_UNSUPPORTED
  //
  if (!Found) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Search the Unicode String Table for the matching Language specifier
  //
  while (UnicodeStringTable->Language != NULL) {
    LanguageString = UnicodeStringTable->Language;
    while (0 != *LanguageString) {
      for (Index = 0; LanguageString[Index] != 0 && LanguageString[Index] != ';'; Index++) {
      }
 
      if (AsciiStrnCmp (LanguageString, Language, Index) == 0) {
        *UnicodeString = UnicodeStringTable->UnicodeString;
        return EFI_SUCCESS;
      }
 
      LanguageString += Index;
      for (Index = 0; LanguageString[Index] != 0 && LanguageString[Index] == ';'; Index++) {
      }
    }
 
    UnicodeStringTable++;
  }
 
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
AddUnicodeString (
  IN     CONST CHAR8               *Language,
  IN     CONST CHAR8               *SupportedLanguages,
  IN OUT EFI_UNICODE_STRING_TABLE  **UnicodeStringTable,
  IN     CONST CHAR16              *UnicodeString
  )
{
  UINTN                     NumberOfEntries;
  EFI_UNICODE_STRING_TABLE  *OldUnicodeStringTable;
  EFI_UNICODE_STRING_TABLE  *NewUnicodeStringTable;
  UINTN                     UnicodeStringLength;
 
  //
  // Make sure the parameter are valid
  //
  if ((Language == NULL) || (UnicodeString == NULL) || (UnicodeStringTable == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // If there are no supported languages, then a Unicode String can not be added
  //
  if (SupportedLanguages == NULL) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // If the Unicode String is empty, then a Unicode String can not be added
  //
  if (UnicodeString[0] == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Make sure Language is a member of SupportedLanguages
  //
  while (*SupportedLanguages != 0) {
    if (CompareIso639LanguageCode (Language, SupportedLanguages)) {
      //
      // Determine the size of the Unicode String Table by looking for a NULL Language entry
      //
      NumberOfEntries = 0;
      if (*UnicodeStringTable != NULL) {
        OldUnicodeStringTable = *UnicodeStringTable;
        while (OldUnicodeStringTable->Language != NULL) {
          if (CompareIso639LanguageCode (Language, OldUnicodeStringTable->Language)) {
            return EFI_ALREADY_STARTED;
          }
 
          OldUnicodeStringTable++;
          NumberOfEntries++;
        }
      }
 
      //
      // Allocate space for a new Unicode String Table.  It must hold the current number of
      // entries, plus 1 entry for the new Unicode String, plus 1 entry for the end of table
      // marker
      //
      NewUnicodeStringTable = AllocatePool ((NumberOfEntries + 2) * sizeof (EFI_UNICODE_STRING_TABLE));
      if (NewUnicodeStringTable == NULL) {
        return EFI_OUT_OF_RESOURCES;
      }
 
      //
      // If the current Unicode String Table contains any entries, then copy them to the
      // newly allocated Unicode String Table.
      //
      if (*UnicodeStringTable != NULL) {
        CopyMem (
          NewUnicodeStringTable,
          *UnicodeStringTable,
          NumberOfEntries * sizeof (EFI_UNICODE_STRING_TABLE)
          );
      }
 
      //
      // Allocate space for a copy of the Language specifier
      //
      NewUnicodeStringTable[NumberOfEntries].Language = AllocateCopyPool (3, Language);
      if (NewUnicodeStringTable[NumberOfEntries].Language == NULL) {
        FreePool (NewUnicodeStringTable);
        return EFI_OUT_OF_RESOURCES;
      }
 
      //
      // Compute the length of the Unicode String
      //
      for (UnicodeStringLength = 0; UnicodeString[UnicodeStringLength] != 0; UnicodeStringLength++) {
      }
 
      //
      // Allocate space for a copy of the Unicode String
      //
      NewUnicodeStringTable[NumberOfEntries].UnicodeString = AllocateCopyPool (
                                                               (UnicodeStringLength + 1) * sizeof (CHAR16),
                                                               UnicodeString
                                                               );
      if (NewUnicodeStringTable[NumberOfEntries].UnicodeString == NULL) {
        FreePool (NewUnicodeStringTable[NumberOfEntries].Language);
        FreePool (NewUnicodeStringTable);
        return EFI_OUT_OF_RESOURCES;
      }
 
      //
      // Mark the end of the Unicode String Table
      //
      NewUnicodeStringTable[NumberOfEntries + 1].Language      = NULL;
      NewUnicodeStringTable[NumberOfEntries + 1].UnicodeString = NULL;
 
      //
      // Free the old Unicode String Table
      //
      if (*UnicodeStringTable != NULL) {
        FreePool (*UnicodeStringTable);
      }
 
      //
      // Point UnicodeStringTable at the newly allocated Unicode String Table
      //
      *UnicodeStringTable = NewUnicodeStringTable;
 
      return EFI_SUCCESS;
    }
 
    SupportedLanguages += 3;
  }
 
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
AddUnicodeString2 (
  IN     CONST CHAR8               *Language,
  IN     CONST CHAR8               *SupportedLanguages,
  IN OUT EFI_UNICODE_STRING_TABLE  **UnicodeStringTable,
  IN     CONST CHAR16              *UnicodeString,
  IN     BOOLEAN                   Iso639Language
  )
{
  UINTN                     NumberOfEntries;
  EFI_UNICODE_STRING_TABLE  *OldUnicodeStringTable;
  EFI_UNICODE_STRING_TABLE  *NewUnicodeStringTable;
  UINTN                     UnicodeStringLength;
  BOOLEAN                   Found;
  UINTN                     Index;
  CHAR8                     *LanguageString;
 
  //
  // Make sure the parameter are valid
  //
  if ((Language == NULL) || (UnicodeString == NULL) || (UnicodeStringTable == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // If there are no supported languages, then a Unicode String can not be added
  //
  if (SupportedLanguages == NULL) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // If the Unicode String is empty, then a Unicode String can not be added
  //
  if (UnicodeString[0] == 0) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Make sure Language is a member of SupportedLanguages
  //
  Found = FALSE;
  if (Iso639Language) {
    while (*SupportedLanguages != 0) {
      if (CompareIso639LanguageCode (Language, SupportedLanguages)) {
        Found = TRUE;
        break;
      }
 
      SupportedLanguages += 3;
    }
  } else {
    Found = !IsLanguageSupported (SupportedLanguages, Language);
  }
 
  //
  // If Language is not a member of SupportedLanguages, then return EFI_UNSUPPORTED
  //
  if (!Found) {
    return EFI_UNSUPPORTED;
  }
 
  //
  // Determine the size of the Unicode String Table by looking for a NULL Language entry
  //
  NumberOfEntries = 0;
  if (*UnicodeStringTable != NULL) {
    OldUnicodeStringTable = *UnicodeStringTable;
    while (OldUnicodeStringTable->Language != NULL) {
      LanguageString = OldUnicodeStringTable->Language;
 
      while (*LanguageString != 0) {
        for (Index = 0; LanguageString[Index] != 0 && LanguageString[Index] != ';'; Index++) {
        }
 
        if (AsciiStrnCmp (Language, LanguageString, Index) == 0) {
          return EFI_ALREADY_STARTED;
        }
 
        LanguageString += Index;
        for ( ; *LanguageString != 0 && *LanguageString == ';'; LanguageString++) {
        }
      }
 
      OldUnicodeStringTable++;
      NumberOfEntries++;
    }
  }
 
  //
  // Allocate space for a new Unicode String Table.  It must hold the current number of
  // entries, plus 1 entry for the new Unicode String, plus 1 entry for the end of table
  // marker
  //
  NewUnicodeStringTable = AllocatePool ((NumberOfEntries + 2) * sizeof (EFI_UNICODE_STRING_TABLE));
  if (NewUnicodeStringTable == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // If the current Unicode String Table contains any entries, then copy them to the
  // newly allocated Unicode String Table.
  //
  if (*UnicodeStringTable != NULL) {
    CopyMem (
      NewUnicodeStringTable,
      *UnicodeStringTable,
      NumberOfEntries * sizeof (EFI_UNICODE_STRING_TABLE)
      );
  }
 
  //
  // Allocate space for a copy of the Language specifier
  //
  NewUnicodeStringTable[NumberOfEntries].Language = AllocateCopyPool (AsciiStrSize (Language), Language);
  if (NewUnicodeStringTable[NumberOfEntries].Language == NULL) {
    FreePool (NewUnicodeStringTable);
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Compute the length of the Unicode String
  //
  for (UnicodeStringLength = 0; UnicodeString[UnicodeStringLength] != 0; UnicodeStringLength++) {
  }
 
  //
  // Allocate space for a copy of the Unicode String
  //
  NewUnicodeStringTable[NumberOfEntries].UnicodeString = AllocateCopyPool (StrSize (UnicodeString), UnicodeString);
  if (NewUnicodeStringTable[NumberOfEntries].UnicodeString == NULL) {
    FreePool (NewUnicodeStringTable[NumberOfEntries].Language);
    FreePool (NewUnicodeStringTable);
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Mark the end of the Unicode String Table
  //
  NewUnicodeStringTable[NumberOfEntries + 1].Language      = NULL;
  NewUnicodeStringTable[NumberOfEntries + 1].UnicodeString = NULL;
 
  //
  // Free the old Unicode String Table
  //
  if (*UnicodeStringTable != NULL) {
    FreePool (*UnicodeStringTable);
  }
 
  //
  // Point UnicodeStringTable at the newly allocated Unicode String Table
  //
  *UnicodeStringTable = NewUnicodeStringTable;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
FreeUnicodeStringTable (
  IN EFI_UNICODE_STRING_TABLE  *UnicodeStringTable
  )
{
  UINTN  Index;
 
  //
  // If the Unicode String Table is NULL, then it is already freed
  //
  if (UnicodeStringTable == NULL) {
    return EFI_SUCCESS;
  }
 
  //
  // Loop through the Unicode String Table until we reach the end of table marker
  //
  for (Index = 0; UnicodeStringTable[Index].Language != NULL; Index++) {
    //
    // Free the Language string from the Unicode String Table
    //
    FreePool (UnicodeStringTable[Index].Language);
 
    //
    // Free the Unicode String from the Unicode String Table
    //
    if (UnicodeStringTable[Index].UnicodeString != NULL) {
      FreePool (UnicodeStringTable[Index].UnicodeString);
    }
  }
 
  //
  // Free the Unicode String Table itself
  //
  FreePool (UnicodeStringTable);
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
GetVariable2 (
  IN CONST CHAR16    *Name,
  IN CONST EFI_GUID  *Guid,
  OUT VOID           **Value,
  OUT UINTN          *Size OPTIONAL
  )
{
  EFI_STATUS  Status;
  UINTN       BufferSize;
 
  ASSERT (Name != NULL && Guid != NULL && Value != NULL);
 
  //
  // Try to get the variable size.
  //
  BufferSize = 0;
  *Value     = NULL;
  if (Size != NULL) {
    *Size = 0;
  }
 
  Status = gRT->GetVariable ((CHAR16 *)Name, (EFI_GUID *)Guid, NULL, &BufferSize, *Value);
  if (Status != EFI_BUFFER_TOO_SMALL) {
    return Status;
  }
 
  //
  // Allocate buffer to get the variable.
  //
  *Value = AllocatePool (BufferSize);
  ASSERT (*Value != NULL);
  if (*Value == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Get the variable data.
  //
  Status = gRT->GetVariable ((CHAR16 *)Name, (EFI_GUID *)Guid, NULL, &BufferSize, *Value);
  if (EFI_ERROR (Status)) {
    FreePool (*Value);
    *Value = NULL;
  }
 
  if (Size != NULL) {
    *Size = BufferSize;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
GetVariable3 (
  IN CONST CHAR16    *Name,
  IN CONST EFI_GUID  *Guid,
  OUT VOID           **Value,
  OUT UINTN          *Size OPTIONAL,
  OUT UINT32         *Attr OPTIONAL
  )
{
  EFI_STATUS  Status;
  UINTN       BufferSize;
 
  ASSERT (Name != NULL && Guid != NULL && Value != NULL);
 
  //
  // Try to get the variable size.
  //
  BufferSize = 0;
  *Value     = NULL;
  if (Size != NULL) {
    *Size = 0;
  }
 
  if (Attr != NULL) {
    *Attr = 0;
  }
 
  Status = gRT->GetVariable ((CHAR16 *)Name, (EFI_GUID *)Guid, Attr, &BufferSize, *Value);
  if (Status != EFI_BUFFER_TOO_SMALL) {
    return Status;
  }
 
  //
  // Allocate buffer to get the variable.
  //
  *Value = AllocatePool (BufferSize);
  ASSERT (*Value != NULL);
  if (*Value == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Get the variable data.
  //
  Status = gRT->GetVariable ((CHAR16 *)Name, (EFI_GUID *)Guid, Attr, &BufferSize, *Value);
  if (EFI_ERROR (Status)) {
    FreePool (*Value);
    *Value = NULL;
  }
 
  if (Size != NULL) {
    *Size = BufferSize;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
GetEfiGlobalVariable2 (
  IN CONST CHAR16  *Name,
  OUT VOID         **Value,
  OUT UINTN        *Size OPTIONAL
  )
{
  return GetVariable2 (Name, &gEfiGlobalVariableGuid, Value, Size);
}
 
CHAR8 *
EFIAPI
GetBestLanguage (
  IN CONST CHAR8  *SupportedLanguages,
  IN UINTN        Iso639Language,
  ...
  )
{
  VA_LIST      Args;
  CHAR8        *Language;
  UINTN        CompareLength;
  UINTN        LanguageLength;
  CONST CHAR8  *Supported;
  CHAR8        *BestLanguage;
 
  ASSERT (SupportedLanguages != NULL);
 
  VA_START (Args, Iso639Language);
  while ((Language = VA_ARG (Args, CHAR8 *)) != NULL) {
    //
    // Default to ISO 639-2 mode
    //
    CompareLength  = 3;
    LanguageLength = MIN (3, AsciiStrLen (Language));
 
    //
    // If in RFC 4646 mode, then determine the length of the first RFC 4646 language code in Language
    //
    if (Iso639Language == 0) {
      for (LanguageLength = 0; Language[LanguageLength] != 0 && Language[LanguageLength] != ';'; LanguageLength++) {
      }
    }
 
    //
    // Trim back the length of Language used until it is empty
    //
    while (LanguageLength > 0) {
      //
      // Loop through all language codes in SupportedLanguages
      //
      for (Supported = SupportedLanguages; *Supported != '\0'; Supported += CompareLength) {
        //
        // In RFC 4646 mode, then Loop through all language codes in SupportedLanguages
        //
        if (Iso639Language == 0) {
          //
          // Skip ';' characters in Supported
          //
          for ( ; *Supported != '\0' && *Supported == ';'; Supported++) {
          }
 
          //
          // Determine the length of the next language code in Supported
          //
          for (CompareLength = 0; Supported[CompareLength] != 0 && Supported[CompareLength] != ';'; CompareLength++) {
          }
 
          //
          // If Language is longer than the Supported, then skip to the next language
          //
          if (LanguageLength > CompareLength) {
            continue;
          }
        }
 
        //
        // See if the first LanguageLength characters in Supported match Language
        //
        if (AsciiStrnCmp (Supported, Language, LanguageLength) == 0) {
          VA_END (Args);
          //
          // Allocate, copy, and return the best matching language code from SupportedLanguages
          //
          BestLanguage = AllocateZeroPool (CompareLength + 1);
          if (BestLanguage == NULL) {
            return NULL;
          }
 
          return CopyMem (BestLanguage, Supported, CompareLength);
        }
      }
 
      if (Iso639Language != 0) {
        //
        // If ISO 639 mode, then each language can only be tested once
        //
        LanguageLength = 0;
      } else {
        //
        // If RFC 4646 mode, then trim Language from the right to the next '-' character
        //
        for (LanguageLength--; LanguageLength > 0 && Language[LanguageLength] != '-'; LanguageLength--) {
        }
      }
    }
  }
 
  VA_END (Args);
 
  //
  // No matches were found
  //
  return NULL;
}
 
EFI_STATUS
EFIAPI
EfiLocateProtocolBuffer (
  IN  EFI_GUID  *Protocol,
  OUT UINTN     *NoProtocols,
  OUT VOID      ***Buffer
  )
{
  EFI_STATUS  Status;
  UINTN       NoHandles;
  EFI_HANDLE  *HandleBuffer;
  UINTN       Index;
 
  //
  // Check input parameters
  //
  if ((Protocol == NULL) || (NoProtocols == NULL) || (Buffer == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Initialze output parameters
  //
  *NoProtocols = 0;
  *Buffer      = NULL;
 
  //
  // Retrieve the array of handles that support Protocol
  //
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  Protocol,
                  NULL,
                  &NoHandles,
                  &HandleBuffer
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Allocate array of protocol instances
  //
  Status = gBS->AllocatePool (
                  EfiBootServicesData,
                  NoHandles * sizeof (VOID *),
                  (VOID **)Buffer
                  );
  if (EFI_ERROR (Status)) {
    //
    // Free the handle buffer
    //
    gBS->FreePool (HandleBuffer);
    return EFI_OUT_OF_RESOURCES;
  }
 
  ZeroMem (*Buffer, NoHandles * sizeof (VOID *));
 
  //
  // Lookup Protocol on each handle in HandleBuffer to fill in the array of
  // protocol instances.  Handle case where protocol instance was present when
  // LocateHandleBuffer() was called, but is not present when HandleProtocol()
  // is called.
  //
  for (Index = 0, *NoProtocols = 0; Index < NoHandles; Index++) {
    Status = gBS->HandleProtocol (
                    HandleBuffer[Index],
                    Protocol,
                    &((*Buffer)[*NoProtocols])
                    );
    if (!EFI_ERROR (Status)) {
      (*NoProtocols)++;
    }
  }
 
  //
  // Free the handle buffer
  //
  gBS->FreePool (HandleBuffer);
 
  //
  // Make sure at least one protocol instance was found
  //
  if (*NoProtocols == 0) {
    gBS->FreePool (*Buffer);
    *Buffer = NULL;
    return EFI_NOT_FOUND;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
EfiOpenFileByDevicePath (
  IN OUT EFI_DEVICE_PATH_PROTOCOL  **FilePath,
  OUT    EFI_FILE_PROTOCOL         **File,
  IN     UINT64                    OpenMode,
  IN     UINT64                    Attributes
  )
{
  EFI_STATUS                       Status;
  EFI_HANDLE                       FileSystemHandle;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL  *FileSystem;
  EFI_FILE_PROTOCOL                *LastFile;
  FILEPATH_DEVICE_PATH             *FilePathNode;
  CHAR16                           *AlignedPathName;
  CHAR16                           *PathName;
  EFI_FILE_PROTOCOL                *NextFile;
 
  if (File == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  *File = NULL;
 
  if (FilePath == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Look up the filesystem.
  //
  Status = gBS->LocateDevicePath (
                  &gEfiSimpleFileSystemProtocolGuid,
                  FilePath,
                  &FileSystemHandle
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = gBS->OpenProtocol (
                  FileSystemHandle,
                  &gEfiSimpleFileSystemProtocolGuid,
                  (VOID **)&FileSystem,
                  gImageHandle,
                  NULL,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Open the root directory of the filesystem. After this operation succeeds,
  // we have to release LastFile on error.
  //
  Status = FileSystem->OpenVolume (FileSystem, &LastFile);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Traverse the device path nodes relative to the filesystem.
  //
  while (!IsDevicePathEnd (*FilePath)) {
    if ((DevicePathType (*FilePath) != MEDIA_DEVICE_PATH) ||
        (DevicePathSubType (*FilePath) != MEDIA_FILEPATH_DP))
    {
      Status = EFI_INVALID_PARAMETER;
      goto CloseLastFile;
    }
 
    FilePathNode = (FILEPATH_DEVICE_PATH *)*FilePath;
 
    //
    // FilePathNode->PathName may be unaligned, and the UEFI specification
    // requires pointers that are passed to protocol member functions to be
    // aligned. Create an aligned copy of the pathname if necessary.
    //
    if ((UINTN)FilePathNode->PathName % sizeof *FilePathNode->PathName == 0) {
      AlignedPathName = NULL;
      PathName        = FilePathNode->PathName;
    } else {
      AlignedPathName = AllocateCopyPool (
                          (DevicePathNodeLength (FilePathNode) -
                           SIZE_OF_FILEPATH_DEVICE_PATH),
                          FilePathNode->PathName
                          );
      if (AlignedPathName == NULL) {
        Status = EFI_OUT_OF_RESOURCES;
        goto CloseLastFile;
      }
 
      PathName = AlignedPathName;
    }
 
    //
    // Open or create the file corresponding to the next pathname fragment.
    //
    Status = LastFile->Open (
                         LastFile,
                         &NextFile,
                         PathName,
                         OpenMode,
                         Attributes
                         );
 
    //
    // Release any AlignedPathName on both error and success paths; PathName is
    // no longer needed.
    //
    if (AlignedPathName != NULL) {
      FreePool (AlignedPathName);
    }
 
    if (EFI_ERROR (Status)) {
      goto CloseLastFile;
    }
 
    //
    // Advance to the next device path node.
    //
    LastFile->Close (LastFile);
    LastFile  = NextFile;
    *FilePath = NextDevicePathNode (FilePathNode);
  }
 
  *File = LastFile;
  return EFI_SUCCESS;
 
CloseLastFile:
  LastFile->Close (LastFile);
 
  //
  // We are on the error path; we must have set an error Status for returning
  // to the caller.
  //
  ASSERT (EFI_ERROR (Status));
  return Status;
}