메모리 맵과 파일 쓰기

typedef struct {
    UINT32                 Type;
    EFI_PHYSICAL_ADDRESS   PhysicalStart;
    EFI_VIRTUAL_ADDRESS    VirtualStart;
    UINT64                 NumberOfPages;
    UINT64                 Attribute;
} EFI_MEMORY_DESCRIPTOR;

EFI_STATUS GetMemoryMap(
    IN OUT UINTN *MemoryMapSize,
    IN OUT EFI_MEMORY_DESCRIPTOR *MemoryMap,
    OUT UINTN *MapKey,
    OUT UINTN *DescriptorSize,
    OUT UINT32 *DescriptorVersion);

struct MemoryMap {
  UINTN buffer_size;         // 메모리 맵을 저장할 버퍼 크기
  VOID* buffer;              // 메모리 맵이 저장될 버퍼 포인터
  UINTN map_size;            // 실제 메모리 맵 크기
  UINTN map_key;             // 메모리 맵의 고유 키 (ExitBootServices에서 필요)
  UINTN descriptor_size;     // 각 메모리 디스크립터의 크기
  UINT32 descriptor_version; // 디스크립터 버전
};

EFI_STATUS GetMemoryMap(struct MemoryMap* map) {
  if (map->buffer == NULL) {
    return EFI_BUFFER_TOO_SMALL;
  }

  map->map_size = map->buffer_size;
  return gBS->GetMemoryMap(
      &map->map_size,                         // IN OUT UINTN
      (EFI_MEMORY_DESCRIPTOR*)map->buffer,    // IN OUT EFI_MEMORY_DESCRIPTOR
      &map->map_key,                          // OUT UINTN
      &map->descriptor_size,                  // OUT UINTN
      &map->descriptor_version);              // OUT UINT32
}

EFI_STATUS EFIAPI UefiMain(
    EFI_HANDLE image_handle,
    EFI_SYSTEM_TABLE* system_table) {
  Print(L"Hello, Mikan World!\n");

  CHAR8 memmap_buf[4096 * 4];
  struct MemoryMap memmap = {sizeof(memmap_buf), memmap_buf, 0, 0, 0, 0};
  GetMemoryMap(&memmap);

  // ...
}

EFI_STATUS EFIAPI UefiMain(
    EFI_HANDLE image_handle,
    EFI_SYSTEM_TABLE* system_table) {
  // ...
  EFI_FILE_PROTOCOL* root_dir;
  OpenRootDir(image_handle, &root_dir);

  EFI_FILE_PROTOCOL* memmap_file;
  root_dir->Open(
      root_dir,         // 루트 디렉터리 핸들
      &memmap_file,     // 열 파일의 핸들을 받을 포인터
      L"\\memmap",      // 열 파일 경로
      EFI_FILE_MODE_READ | EFI_FILE_MODE_WRITE | EFI_FILE_MODE_CREATE,  // 파일 모드
      0);

  SaveMemoryMap(&memmap, memmap_file);
  memmap_file->Close(memmap_file);
  while (1);
  return EFI_SUCCESS;
}

EFI_STATUS OpenRootDir(EFI_HANDLE image_handle, EFI_FILE_PROTOCOL** root) {
  EFI_LOADED_IMAGE_PROTOCOL* loaded_image;
  EFI_SIMPLE_FILE_SYSTEM_PROTOCOL* fs;

  // 이미지 핸들은 현재 실행중인 UEFI 어플리케이션을 식별하는 핸들이며 EntryPoint 에서부터 받아온다.  
  // 현재 로드된 어플리케이션 관련 인터페이스를 가져올 수 있다. 
  // ex) DeviceHandle: 현재 어플리케이션이 저장된 장치 핸들 (파일시스템 접근시 사용)
  // ex2) ImageBase, ImageSize, FilePath, LoadOptions 등
  gBS->OpenProtocol(
      image_handle,                          // 프로토콜이 존재하는 핸들 (디바이스, 드라이버 등)
      &gEfiLoadedImageProtocolGuid,          // EFI_LOADED_IMAGE_PROTOCOL 프로토콜의 GUID
      (VOID**)&loaded_image,                 // 인터페이스를 전달 받을 포인터
      image_handle,                          // 프로토콜을 여는 주체
      NULL,                                  // 컨트롤러에 바인딩할때만 사용
      EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL); // 프로토콜을 여는 방식

  // 어플리케이션이 저장된 장치에서 파일시스템 프로토콜을 가져온다. 
  gBS->OpenProtocol(
      loaded_image->DeviceHandle,
      &gEfiSimpleFileSystemProtocolGuid,     // EFI_SIMPLE_FILE_SYSTEM_PROTOCOL
      (VOID**)&fs,
      image_handle,
      NULL,
      EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);

  fs->OpenVolume(fs, root);     // 루트 디렉터리를 가리키는 핸들

  return EFI_SUCCESS;
}

EFI_STATUS SaveMemoryMap(struct MemoryMap* map, EFI_FILE_PROTOCOL* file) {
  CHAR8 buf[256];
  CHAR16 unicode_buf[256];
  UINTN len;

  CHAR8* header =
    "Index, Type, Type(name), PhysicalStart, NumberOfPages, Attribute\n";
  len = AsciiStrLen(header);
  file->Write(file, &len, header);

  Print(L"map->buffer = %08lx, map->map_size = %08lx\n",
      map->buffer, map->map_size);

  EFI_PHYSICAL_ADDRESS iter;
  int i;
  for (iter = (EFI_PHYSICAL_ADDRESS)map->buffer, i = 0;
       iter < (EFI_PHYSICAL_ADDRESS)map->buffer + map->map_size;
       iter += map->descriptor_size, i++) {
    EFI_MEMORY_DESCRIPTOR* desc = (EFI_MEMORY_DESCRIPTOR*)iter;
    len = AsciiSPrint(
        buf, sizeof(buf),
        "%4u | %08lx -> %08lx | %x, %-25ls, %lx, %lx\n",
        i, desc->PhysicalStart, desc->VirtualStart,   // 메모리타입은 값 -> 문자열로 치환
        desc->Type, GetMemoryTypeUnicode(desc->Type), desc->NumberOfPages,
        desc->Attribute & 0xffffflu);
    DEBUG((DEBUG_INFO, buf)); 
    // Ascii -> Unicode 로 변경 후 그대로 Print
    AsciiStrToUnicodeStrS(buf, unicode_buf, sizeof(unicode_buf) / sizeof(CHAR16));
    Print(L"%s", unicode_buf);

    file->Write(file, &len, buf);
  }

  return EFI_SUCCESS;
}