UEFI——HOB简单使用

HOB简介

HOB的全称是Hand-Off Block，用来存储交接的数据。

PEI是HOB的生成阶段，用来创建和修改HOB

DXE是HOB的消费阶段，用来使用HOB，此时HOB是只读的

【有博客说：SEC也可以作为HOB的生成阶段、BDS也可以作为HOB的消费阶段】

HOB在PEI阶段创建，并返回一个列表（称为HOB List，HOB列表），HOB堆叠放置在其中，最终形成如下形式：

HOB列表中的第一个必须是PHIT HOB，最后一个是End of HOB。HOB结构的实现分为三部分，PHIT头：描述HOB的起始位置和内存使用信息；

各种HOB列表，DXE从该列表上获取资源，传参为Hob Type和GUID；

最后是HOB结束部分。 

在UEFI（Unified Extensible Firmware Interface）启动过程中，HOB（Hand-Off Block）是一种数据结构，用于在不同的启动阶段之间传递信息。HOB可以包含不同类型的数据，如硬件描述符、内存描述符、处理器描述符等。
以下是UEFI启动过程中常见的HOB类型及其用途：

/// Union of all the possible HOB Types.
///
typedef union {
  EFI_HOB_GENERIC_HEADER                 *Header;
  EFI_HOB_HANDOFF_INFO_TABLE             *HandoffInformationTable;
  EFI_HOB_MEMORY_ALLOCATION              *MemoryAllocation;
  EFI_HOB_MEMORY_ALLOCATION_BSP_STORE    *MemoryAllocationBspStore;
  EFI_HOB_MEMORY_ALLOCATION_STACK        *MemoryAllocationStack;
  EFI_HOB_MEMORY_ALLOCATION_MODULE       *MemoryAllocationModule;
  EFI_HOB_RESOURCE_DESCRIPTOR            *ResourceDescriptor;
  EFI_HOB_GUID_TYPE                      *Guid;
  EFI_HOB_FIRMWARE_VOLUME                *FirmwareVolume;
  EFI_HOB_FIRMWARE_VOLUME2               *FirmwareVolume2;
  EFI_HOB_FIRMWARE_VOLUME3               *FirmwareVolume3;
  EFI_HOB_CPU                            *Cpu;
  EFI_HOB_MEMORY_POOL                    *Pool;
  EFI_HOB_UEFI_CAPSULE                   *Capsule;
  UINT8                                  *Raw;
} EFI_PEI_HOB_POINTERS;

这些HOB类型涵盖了UEFI启动过程中可能需要传递的各种信息。通过使用不同的HOB类型，UEFI启动过程可以确保正确地处理和存储HOB，并在需要时正确地使用它们。

上面的是HOB的种类，还有HOB的数据类型（存储于EFI_HOB_GENERIC_HEADER）：

// HobType of EFI_HOB_GENERIC_HEADER.
//
#define EFI_HOB_TYPE_HANDOFF              0x0001
#define EFI_HOB_TYPE_MEMORY_ALLOCATION    0x0002
#define EFI_HOB_TYPE_RESOURCE_DESCRIPTOR  0x0003
#define EFI_HOB_TYPE_GUID_EXTENSION       0x0004
#define EFI_HOB_TYPE_FV                   0x0005
#define EFI_HOB_TYPE_CPU                  0x0006
#define EFI_HOB_TYPE_MEMORY_POOL          0x0007
#define EFI_HOB_TYPE_FV2                  0x0009
#define EFI_HOB_TYPE_LOAD_PEIM_UNUSED     0x000A
#define EFI_HOB_TYPE_UEFI_CAPSULE         0x000B
#define EFI_HOB_TYPE_FV3                  0x000C
#define EFI_HOB_TYPE_UNUSED               0xFFFE
#define EFI_HOB_TYPE_END_OF_HOB_LIST      0xFFFF

HOB简单使用

1、编写

在PEIM生成HOB的时候需要用到PeiServicesCreateHob()，其代码原型为：

/**
  这个服务能够使PEIM产生一系列的Hobs

  @param  Type                  The type of HOB to be installed.
  @param  Length                The length of the HOB to be added.
  @param  Hob                   The address of a pointer that will contain the HOB header.

  @retval EFI_SUCCESS           The HOB was successfully created.
  @retval EFI_OUT_OF_RESOURCES  There is no additional space for HOB creation.

**/
EFI_STATUS
EFIAPI
PeiServicesCreateHob (
  IN UINT16  Type, //要生成的HOB的类型
  IN UINT16  Length, // 指定HOB的长度，即从开始到结束的字节数
  OUT VOID   **Hob //输出参数，Hob是指针的地址，包含HOB的头部，即指针的指针
  );

 并且使用一个数据结构EFI_HOB_GENERIC_HEADER用来存储HOB的基本信息，其代码原型为：

///  描述 HOB 内部数据的格式和大小，所有的HOB都包含这个结构
typedef struct {
  UINT16    HobType; //标识HOB数据结构类型
  UINT16    HobLength; //HOB的长度
  UINT32    Reserved; //该字段必须始终设置为0
} EFI_HOB_GENERIC_HEADER;

#include <uefi.h> 
#include <Library/UefiLib.h> 
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Library/PeimEntryPoint.h>
#include <Library/PeiServicesLib.h>
#include <Library/PeiServicesTablePointerLib.h>
#include <Pi/PiHob.h>

EFI_GUID gMyHelloWorldPEIGUID = { 0xbdb38129, 0x4d65, 0x39f4, { 0x72, 0x12, 0x68, 0xcf, 0x5a, 0x19, 0xa, 0xf8 }};

VOID
EfiCommonLibCopyMem ( //从源拷贝Length字节到目
  IN VOID   *Destination,
  IN VOID   *Source,
  IN UINTN  Length
  )
{
  CHAR8 *Destination8;//8位无符号字符
  CHAR8 *Source8;
  
  //考虑到源地址和目的地址的关系来进行数据拷贝
  if (Source < Destination) {
    Destination8  = (CHAR8 *) Destination + Length - 1;
    Source8       = (CHAR8 *) Source + Length - 1;
    while (Length--) {
      *(Destination8--) = *(Source8--);
    }
  } else {
    Destination8  = (CHAR8 *) Destination;
    Source8       = (CHAR8 *) Source;
    while (Length--) {
      *(Destination8++) = *(Source8++);
    }
  }
}

UINTN
EFIAPI
MyStrlen (
  IN CONST CHAR16               *String,
  IN UINTN                     MaxSize
  )
{
  UINTN                             Length;
  Length = 0;
  if ((String == 0) || (MaxSize == 0)) {
    return 0;
  }

  while (String[Length] != 0) {
    if (Length >= MaxSize - 1) {
      return MaxSize;
    }
    Length++;
  }
  return Length;
}

EFI_STATUS
EFIAPI
MyHelloWorldPEIMHobEntry(
  IN       EFI_PEI_FILE_HANDLE  FileHandle,
  IN CONST EFI_PEI_SERVICES     **PeiServices
)
{ 
  EFI_STATUS                              Status = EFI_SUCCESS;
  DEBUG ((EFI_D_ERROR, "[MyHelloWorldHob] MyHelloWorldPEIMHobEntry Start..\n"));
  
  CHAR8  *Hob = NULL;

  PeiServices = GetPeiServicesTablePointer();//返回PEI Services Table指针的缓存值，也就是指向Pei Services Table
  Status = PeiServicesCreateHob (//产生Hob
                           EFI_HOB_TYPE_MEMORY_ALLOCATION, //HOb的type
                           64, //Hob的长度，即64字节
                           &Hob //输出参数，包含HOB头的指针地址
                           );

  CHAR8 *HobEnd = (Hob + sizeof (EFI_HOB_GENERIC_HEADER));
  EfiCommonLibCopyMem(HobEnd, &gMyHelloWorldPEIGUID, sizeof(gMyHelloWorldPEIGUID));
  CHAR16 StrHob[] = L"CSDN HOB Data ...";
  // EfiCommonLibCopyMem(HobEnd+16,StrHob,2*MyStrlen(StrHob,128));
  EfiCommonLibCopyMem(HobEnd+16,StrHob,2*17);
  
  DEBUG ((EFI_D_ERROR, "[MyHelloWorldHob] MyHelloWorldPEIMHobEntry End..\n"));
  return Status;
}

2、编写UEFI DXE  驱动

在DXE阶段首先要使用GetHobList()函数找到HOB列表，其代码原型为

//返回HOB列表的指针，这个函数返回HOB列表中第一个HOB的指针
VOID *
EFIAPI
GetHobList (
  VOID
  );

然后使用 GetNextHob()从某个HOB开始寻找特定类型的HOB，并返回指向该HOB的指针，其代码原型为

/**
  Returns the next instance of a HOB type from the starting HOB.
  从某一个HOB开始搜索特定type的HOB，并返回特定HOB的指针，如果没有搜索到，返回NULL

与宏 GET_NEXT_HOB() 不同，该函数不会无端跳过起始HOB  
this function does not skip the starting HOB pointer
  unconditionally: it returns HobStart back if HobStart itself meets the requirement;
  caller is required to use GET_NEXT_HOB() if it wishes to skip current HobStart.

  If HobStart is NULL, then ASSERT().

  @return The next instance of a HOB type from the starting HOB.

**/
VOID *
EFIAPI
GetNextHob (
  IN UINT16      Type, //要返回的HOB的type
  IN CONST VOID  *HobStart //从哪一个HOB开始搜索的指针
  );

在这里找的是EFI_HOB_TYPE_MEMORY_ALLOCATION类型的HOB，将这种类型的HOB的AllocDescriptor的GUID与PEIM生成的HOB的GUID进行比较

完整代码为：

#include <Library/UefiLib.h> 
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/UefiDriverEntryPoint.h>
#include <Pi/PiBootMode.h>
#include <Pi/PiHob.h>
#include <Library/HobLib.h>
#include <Library/UefiBootServicesTableLib.h>

EFI_GUID gMyHelloWorldPEIGUID = { 0xbdb38129, 0x4d65, 0x39f4, { 0x72, 0x12, 0x68, 0xcf, 0x5a, 0x19, 0xa, 0xf8 }};

EFI_STATUS
EFIAPI
MyHelloWorldDXEHobEntry(
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
)
{ 
  EFI_STATUS                              Status = EFI_SUCCESS;
  DEBUG ((EFI_D_ERROR , "[MyHelloWorldHob] MyHelloWorldDXEHobEntry Start..\n"));
  
  EFI_PEI_HOB_POINTERS            Hob; //EFI_PEI_HOB_POINTERS是一个包含很多HOB type的联合体，这是因为HOB有很多种type，故HOB的指针也有很多type，因此用了一个union
  UINT8 *HobEnd = NULL;
  Hob.Raw   = GetHobList();//获取第一个HOB的指针
  while ((Hob.Raw = GetNextHob (EFI_HOB_TYPE_MEMORY_ALLOCATION, Hob.Raw)) != NULL) { //从第一个HOB开始寻找EFI_HOB_TYPE_MEMORY_ALLOCATION类型的HOB，并将指针赋值给Hob.Raw
    //
    // Compare FileGuid both.
    //
    if (CompareGuid (&gMyHelloWorldPEIGUID, &Hob.MemoryAllocation->AllocDescriptor.Name) ) {
	  DEBUG ((EFI_D_ERROR, "[MyHelloWorldHob] MyHelloWorldDXEHobEntry  Guid:0x%x\n",Hob.MemoryAllocation->AllocDescriptor.Name.Data1));
	  HobEnd = (Hob.Raw + sizeof (EFI_HOB_GENERIC_HEADER) + 16);
      DEBUG ((EFI_D_ERROR, "[MyHelloWorldHob] MyHelloWorldDXEHobEntry content:%s\n", (CHAR16 *)HobEnd));
      return EFI_SUCCESS;
    }
    Hob.Raw = GET_NEXT_HOB (Hob);
  }  
  
  Hob.Raw = GetHobList ();
  //Dump all hobs transfered from PEI
  for (; !END_OF_HOB_LIST(Hob); Hob.Raw = GET_NEXT_HOB(Hob)) { //GET_NEXT_HOB会搜索HOB list中的下一个宏，在这里采用了GET_NEXT_HOB的宏，是因为该宏会跳过当前的起始HOB，搜索下一个
    DEBUG((DEBUG_ERROR, "[Csdn] Guid:%g Type:0x%x Length:%x\n",
  	Hob.Guid,
  	Hob.Header->HobType,
  	Hob.Header->HobLength
  	));
  }
  DEBUG ((EFI_D_ERROR , "[MyHelloWorldHob] MyHelloWorldDXEHobEntry End..\n"));
  return Status;
}

编译整个包，并运行

总结

UEFI提供了HOB（Hand-Off-Block）机制,即在PEI阶段将数据打包成数据块存放在一段连续的内存中，数据块的标识为GUID，DXE阶段可以通过该GUID在HOB中找到对应数据块。

HOB 是非常重要数据结构，在CAR时期将会初始化好，UEFI的早期的堆栈都基于HOB，
PEI Phase会创建大量的HOB，包含板级数据（UBA）, silicon Hob(Memmap, RC resource),Setup，当进入PEI PostMem phase后，CAR里的HOB会shadown到Mem, 当进入DXE(调用TempPtr.DxeIpl->Entry)后，这些HOB会被DXE driver大量采用, 用来创建Protocol或者其他初始化。