DevicePathUtilities.c

Go to the documentation of this file.

 
#include "UefiDevicePathLib.h"
 
//
// Template for an end-of-device path node.
//
GLOBAL_REMOVE_IF_UNREFERENCED CONST EFI_DEVICE_PATH_PROTOCOL  mUefiDevicePathLibEndDevicePath = {
  END_DEVICE_PATH_TYPE,
  END_ENTIRE_DEVICE_PATH_SUBTYPE,
  {
    END_DEVICE_PATH_LENGTH,
    0
  }
};
 
BOOLEAN
EFIAPI
IsDevicePathValid (
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath,
  IN       UINTN                     MaxSize
  )
{
  UINTN  Count;
  UINTN  Size;
  UINTN  NodeLength;
 
  //
  // Validate the input whether exists and its size big enough to touch the first node
  //
  if ((DevicePath == NULL) || ((MaxSize > 0) && (MaxSize < END_DEVICE_PATH_LENGTH))) {
    return FALSE;
  }
 
  if (MaxSize == 0) {
    MaxSize = MAX_UINTN;
  }
 
  for (Count = 0, Size = 0; !IsDevicePathEnd (DevicePath); DevicePath = NextDevicePathNode (DevicePath)) {
    NodeLength = DevicePathNodeLength (DevicePath);
    if (NodeLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
      return FALSE;
    }
 
    if (NodeLength > MAX_UINTN - Size) {
      return FALSE;
    }
 
    Size += NodeLength;
 
    //
    // Validate next node before touch it.
    //
    if (Size > MaxSize - END_DEVICE_PATH_LENGTH ) {
      return FALSE;
    }
 
    if (PcdGet32 (PcdMaximumDevicePathNodeCount) > 0) {
      Count++;
      if (Count >= PcdGet32 (PcdMaximumDevicePathNodeCount)) {
        return FALSE;
      }
    }
 
    //
    // FilePath must be a NULL-terminated string.
    //
    if ((DevicePathType (DevicePath) == MEDIA_DEVICE_PATH) &&
        (DevicePathSubType (DevicePath) == MEDIA_FILEPATH_DP) &&
        (*(CHAR16 *)((UINT8 *)DevicePath + NodeLength - 2) != 0))
    {
      return FALSE;
    }
  }
 
  //
  // Only return TRUE when the End Device Path node is valid.
  //
  return (BOOLEAN)(DevicePathNodeLength (DevicePath) == END_DEVICE_PATH_LENGTH);
}
 
UINT8
EFIAPI
DevicePathType (
  IN CONST VOID  *Node
  )
{
  ASSERT (Node != NULL);
  return ((EFI_DEVICE_PATH_PROTOCOL *)(Node))->Type;
}
 
UINT8
EFIAPI
DevicePathSubType (
  IN CONST VOID  *Node
  )
{
  ASSERT (Node != NULL);
  return ((EFI_DEVICE_PATH_PROTOCOL *)(Node))->SubType;
}
 
UINTN
EFIAPI
DevicePathNodeLength (
  IN CONST VOID  *Node
  )
{
  ASSERT (Node != NULL);
  return ReadUnaligned16 ((UINT16 *)&((EFI_DEVICE_PATH_PROTOCOL *)(Node))->Length[0]);
}
 
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
NextDevicePathNode (
  IN CONST VOID  *Node
  )
{
  ASSERT (Node != NULL);
  return (EFI_DEVICE_PATH_PROTOCOL *)((UINT8 *)(Node) + DevicePathNodeLength (Node));
}
 
BOOLEAN
EFIAPI
IsDevicePathEndType (
  IN CONST VOID  *Node
  )
{
  ASSERT (Node != NULL);
  return (BOOLEAN)(DevicePathType (Node) == END_DEVICE_PATH_TYPE);
}
 
BOOLEAN
EFIAPI
IsDevicePathEnd (
  IN CONST VOID  *Node
  )
{
  ASSERT (Node != NULL);
  return (BOOLEAN)(IsDevicePathEndType (Node) && DevicePathSubType (Node) == END_ENTIRE_DEVICE_PATH_SUBTYPE);
}
 
BOOLEAN
EFIAPI
IsDevicePathEndInstance (
  IN CONST VOID  *Node
  )
{
  ASSERT (Node != NULL);
  return (BOOLEAN)(IsDevicePathEndType (Node) && DevicePathSubType (Node) == END_INSTANCE_DEVICE_PATH_SUBTYPE);
}
 
UINT16
EFIAPI
SetDevicePathNodeLength (
  IN OUT VOID  *Node,
  IN UINTN     Length
  )
{
  ASSERT (Node != NULL);
  ASSERT ((Length >= sizeof (EFI_DEVICE_PATH_PROTOCOL)) && (Length < SIZE_64KB));
  return WriteUnaligned16 ((UINT16 *)&((EFI_DEVICE_PATH_PROTOCOL *)(Node))->Length[0], (UINT16)(Length));
}
 
VOID
EFIAPI
SetDevicePathEndNode (
  OUT VOID  *Node
  )
{
  ASSERT (Node != NULL);
  CopyMem (Node, &mUefiDevicePathLibEndDevicePath, sizeof (mUefiDevicePathLibEndDevicePath));
}
 
UINTN
EFIAPI
UefiDevicePathLibGetDevicePathSize (
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
  )
{
  CONST EFI_DEVICE_PATH_PROTOCOL  *Start;
 
  if (DevicePath == NULL) {
    return 0;
  }
 
  if (!IsDevicePathValid (DevicePath, 0)) {
    return 0;
  }
 
  //
  // Search for the end of the device path structure
  //
  Start = DevicePath;
  while (!IsDevicePathEnd (DevicePath)) {
    DevicePath = NextDevicePathNode (DevicePath);
  }
 
  //
  // Compute the size and add back in the size of the end device path structure
  //
  return ((UINTN)DevicePath - (UINTN)Start) + DevicePathNodeLength (DevicePath);
}
 
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
UefiDevicePathLibDuplicateDevicePath (
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
  )
{
  UINTN  Size;
 
  //
  // Compute the size
  //
  Size = GetDevicePathSize (DevicePath);
  if (Size == 0) {
    return NULL;
  }
 
  //
  // Allocate space for duplicate device path
  //
 
  return AllocateCopyPool (Size, DevicePath);
}
 
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
UefiDevicePathLibAppendDevicePath (
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *FirstDevicePath   OPTIONAL,
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *SecondDevicePath  OPTIONAL
  )
{
  UINTN                     Size;
  UINTN                     Size1;
  UINTN                     Size2;
  EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath2;
 
  //
  // If there's only 1 path, just duplicate it.
  //
  if (FirstDevicePath == NULL) {
    return DuplicateDevicePath ((SecondDevicePath != NULL) ? SecondDevicePath : &mUefiDevicePathLibEndDevicePath);
  }
 
  if (SecondDevicePath == NULL) {
    return DuplicateDevicePath (FirstDevicePath);
  }
 
  if (!IsDevicePathValid (FirstDevicePath, 0) || !IsDevicePathValid (SecondDevicePath, 0)) {
    return NULL;
  }
 
  //
  // Allocate space for the combined device path. It only has one end node of
  // length EFI_DEVICE_PATH_PROTOCOL.
  //
  Size1 = GetDevicePathSize (FirstDevicePath);
  Size2 = GetDevicePathSize (SecondDevicePath);
  Size  = Size1 + Size2 - END_DEVICE_PATH_LENGTH;
 
  NewDevicePath = AllocatePool (Size);
 
  if (NewDevicePath != NULL) {
    NewDevicePath = CopyMem (NewDevicePath, FirstDevicePath, Size1);
    //
    // Over write FirstDevicePath EndNode and do the copy
    //
    DevicePath2 = (EFI_DEVICE_PATH_PROTOCOL *)((CHAR8 *)NewDevicePath +
                                               (Size1 - END_DEVICE_PATH_LENGTH));
    CopyMem (DevicePath2, SecondDevicePath, Size2);
  }
 
  return NewDevicePath;
}
 
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
UefiDevicePathLibAppendDevicePathNode (
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath      OPTIONAL,
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathNode  OPTIONAL
  )
{
  EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;
  EFI_DEVICE_PATH_PROTOCOL  *NextNode;
  EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
  UINTN                     NodeLength;
 
  if (DevicePathNode == NULL) {
    return DuplicateDevicePath ((DevicePath != NULL) ? DevicePath : &mUefiDevicePathLibEndDevicePath);
  }
 
  //
  // Build a Node that has a terminator on it
  //
  NodeLength = DevicePathNodeLength (DevicePathNode);
 
  TempDevicePath = AllocatePool (NodeLength + END_DEVICE_PATH_LENGTH);
  if (TempDevicePath == NULL) {
    return NULL;
  }
 
  TempDevicePath = CopyMem (TempDevicePath, DevicePathNode, NodeLength);
  //
  // Add and end device path node to convert Node to device path
  //
  NextNode = NextDevicePathNode (TempDevicePath);
  SetDevicePathEndNode (NextNode);
  //
  // Append device paths
  //
  NewDevicePath = AppendDevicePath (DevicePath, TempDevicePath);
 
  FreePool (TempDevicePath);
 
  return NewDevicePath;
}
 
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
UefiDevicePathLibAppendDevicePathInstance (
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath         OPTIONAL,
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePathInstance OPTIONAL
  )
{
  EFI_DEVICE_PATH_PROTOCOL  *NewDevicePath;
  EFI_DEVICE_PATH_PROTOCOL  *TempDevicePath;
  UINTN                     SrcSize;
  UINTN                     InstanceSize;
 
  if (DevicePath == NULL) {
    return DuplicateDevicePath (DevicePathInstance);
  }
 
  if (DevicePathInstance == NULL) {
    return NULL;
  }
 
  if (!IsDevicePathValid (DevicePath, 0) || !IsDevicePathValid (DevicePathInstance, 0)) {
    return NULL;
  }
 
  SrcSize      = GetDevicePathSize (DevicePath);
  InstanceSize = GetDevicePathSize (DevicePathInstance);
 
  NewDevicePath = AllocatePool (SrcSize + InstanceSize);
  if (NewDevicePath != NULL) {
    TempDevicePath = CopyMem (NewDevicePath, DevicePath, SrcSize);
 
    while (!IsDevicePathEnd (TempDevicePath)) {
      TempDevicePath = NextDevicePathNode (TempDevicePath);
    }
 
    TempDevicePath->SubType = END_INSTANCE_DEVICE_PATH_SUBTYPE;
    TempDevicePath          = NextDevicePathNode (TempDevicePath);
    CopyMem (TempDevicePath, DevicePathInstance, InstanceSize);
  }
 
  return NewDevicePath;
}
 
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
UefiDevicePathLibGetNextDevicePathInstance (
  IN OUT EFI_DEVICE_PATH_PROTOCOL  **DevicePath,
  OUT UINTN                        *Size
  )
{
  EFI_DEVICE_PATH_PROTOCOL  *DevPath;
  EFI_DEVICE_PATH_PROTOCOL  *ReturnValue;
  UINT8                     Temp;
 
  ASSERT (Size != NULL);
 
  if ((DevicePath == NULL) || (*DevicePath == NULL)) {
    *Size = 0;
    return NULL;
  }
 
  if (!IsDevicePathValid (*DevicePath, 0)) {
    return NULL;
  }
 
  //
  // Find the end of the device path instance
  //
  DevPath = *DevicePath;
  while (!IsDevicePathEndType (DevPath)) {
    DevPath = NextDevicePathNode (DevPath);
  }
 
  //
  // Compute the size of the device path instance
  //
  *Size = ((UINTN)DevPath - (UINTN)(*DevicePath)) + sizeof (EFI_DEVICE_PATH_PROTOCOL);
 
  //
  // Make a copy and return the device path instance
  //
  Temp             = DevPath->SubType;
  DevPath->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
  ReturnValue      = DuplicateDevicePath (*DevicePath);
  DevPath->SubType = Temp;
 
  //
  // If DevPath is the end of an entire device path, then another instance
  // does not follow, so *DevicePath is set to NULL.
  //
  if (DevicePathSubType (DevPath) == END_ENTIRE_DEVICE_PATH_SUBTYPE) {
    *DevicePath = NULL;
  } else {
    *DevicePath = NextDevicePathNode (DevPath);
  }
 
  return ReturnValue;
}
 
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
UefiDevicePathLibCreateDeviceNode (
  IN UINT8   NodeType,
  IN UINT8   NodeSubType,
  IN UINT16  NodeLength
  )
{
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
 
  if (NodeLength < sizeof (EFI_DEVICE_PATH_PROTOCOL)) {
    //
    // NodeLength is less than the size of the header.
    //
    return NULL;
  }
 
  DevicePath = AllocateZeroPool (NodeLength);
  if (DevicePath != NULL) {
    DevicePath->Type    = NodeType;
    DevicePath->SubType = NodeSubType;
    SetDevicePathNodeLength (DevicePath, NodeLength);
  }
 
  return DevicePath;
}
 
BOOLEAN
EFIAPI
UefiDevicePathLibIsDevicePathMultiInstance (
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath
  )
{
  CONST EFI_DEVICE_PATH_PROTOCOL  *Node;
 
  if (DevicePath == NULL) {
    return FALSE;
  }
 
  if (!IsDevicePathValid (DevicePath, 0)) {
    return FALSE;
  }
 
  Node = DevicePath;
  while (!IsDevicePathEnd (Node)) {
    if (IsDevicePathEndInstance (Node)) {
      return TRUE;
    }
 
    Node = NextDevicePathNode (Node);
  }
 
  return FALSE;
}
 
EFI_DEVICE_PATH_PROTOCOL *
EFIAPI
FileDevicePath (
  IN EFI_HANDLE    Device      OPTIONAL,
  IN CONST CHAR16  *FileName
  )
{
  UINTN                     Size;
  FILEPATH_DEVICE_PATH      *FilePath;
  EFI_DEVICE_PATH_PROTOCOL  *DevicePath;
  EFI_DEVICE_PATH_PROTOCOL  *FileDevicePath;
 
  DevicePath = NULL;
 
  Size           = StrSize (FileName);
  FileDevicePath = AllocatePool (Size + SIZE_OF_FILEPATH_DEVICE_PATH + END_DEVICE_PATH_LENGTH);
  if (FileDevicePath != NULL) {
    FilePath                 = (FILEPATH_DEVICE_PATH *)FileDevicePath;
    FilePath->Header.Type    = MEDIA_DEVICE_PATH;
    FilePath->Header.SubType = MEDIA_FILEPATH_DP;
    CopyMem (&FilePath->PathName, FileName, Size);
    SetDevicePathNodeLength (&FilePath->Header, Size + SIZE_OF_FILEPATH_DEVICE_PATH);
    SetDevicePathEndNode (NextDevicePathNode (&FilePath->Header));
 
    if (Device != NULL) {
      DevicePath = DevicePathFromHandle (Device);
    }
 
    DevicePath = AppendDevicePath (DevicePath, FileDevicePath);
    FreePool (FileDevicePath);
  }
 
  return DevicePath;
}