부트로더와 커널과 디버깅

1extern "C" void KernelMain() {
2    while (1) __asm__("hlt");
3}

1$ clang++ -O2 -Wall -g --target=x86_64-elf -ffreestanding -mno-red-zone -fno-exceptions -fno-rtti -std=c++17 -c main.cpp

1$ ld.lld --entry KernelMain -z norelro --image-base 0x100000 --static -o kernel.elf main.o

 1// 루트 파일시스템에서 커널 이미지를 Open 한다.
 2  EFI_FILE_PROTOCOL* kernel_file;
 3  root_dir->Open(
 4      root_dir, &kernel_file, L"\\kernel.elf",
 5      EFI_FILE_MODE_READ, 0);
 6
 7// 커널 이미지 파일에 대한 정보 획득.
 8// 파일 크기를 알아야 얼마나 메모리를 할당할지 알 수 있기 때문
 9// GetInfo 로 얻는 파일 정보는 EFI_FILE_INFO 와 파일명이 나란히 저장된다.
10  UINTN file_info_size = sizeof(EFI_FILE_INFO) + sizeof(CHAR16) * 12;
11  UINT8 file_info_buffer[file_info_size];
12  kernel_file->GetInfo(
13      kernel_file, &gEfiFileInfoGuid,
14      &file_info_size, file_info_buffer);
15
16  EFI_FILE_INFO* file_info = (EFI_FILE_INFO*)file_info_buffer;
17  UINTN kernel_file_size = file_info->FileSize;
18
19// 커널 베이스 주소부터 커널 이미지 파일의 크기를 페이지 단위 크기로 메모리를 할당한다.
20// 링크할 때 커널의 베이스주소가 0x100000 부터 시작되도록 바이너리가 만들어져있기 때문에 
21// 무조건 베이스주소가 맞도록 할당해야한다. (AllocateAddress 방식 사용)
22  EFI_PHYSICAL_ADDRESS kernel_base_addr = 0x100000;
23  gBS->AllocatePages(
24      AllocateAddress, EfiLoaderData,
25// 최소한 커널 사이즈만큼 할당해야 하기 때문에 페이지 단위로 올림 처리
26      (kernel_file_size + 0xfff) / 0x1000, &kernel_base_addr);
27  kernel_file->Read(kernel_file, &kernel_file_size, (VOID*)kernel_base_addr);
28  Print(L"Kernel: 0x%0lx (%lu bytes)\n", kernel_base_addr, kernel_file_size);

1typedef struct {
2  UINT64 Size, FileSize, PhysicalSize;
3  EFI_TIME CreateTime, LastAccessTime, ModificationTime;
4  UINT64 Attribute;
5  CHAR16 FileName[];
6} EFI_FILE_INFO;

 1  EFI_STATUS status;
 2// 메모리 상태가 변경되면 map_key가 변경된다. 
 3// 부트서비스 종료 시 현재 메모리 상태와 알고있는 map_key가 같은지 확인한다.
 4// 다르면 실패한다. 
 5// 부트로더(UEFI 앱)가 실행되는 동안 여러 gBS 객체를 통해 부트서비스 API를 호출하게 되는데,
 6// 메모리 상태를 계속 변경시키기 때문에 보통은 업데이트 되지않는 경우가 없어 실패한다.
 7  status = gBS->ExitBootServices(image_handle, memmap.map_key);
 8  if (EFI_ERROR(status)) {
 9// 실패하면 현재 메모리 상태에 맞는 맵으로 업데이트한다.
10    status = GetMemoryMap(&memmap);
11    if (EFI_ERROR(status)) {
12      Print(L"failed to get memory map: %r\n", status);
13      while (1);
14    }
15// 가져온 메모리맵 키를 사용하여 다시 종료를 시도한다. 
16// 여기에서 실패하면 중대한 에러이다. 
17    status = gBS->ExitBootServices(image_handle, memmap.map_key);
18    if (EFI_ERROR(status)) {
19      Print(L"Could not exit boot service: %r\n", status);
20      while (1);
21    }
22  }

1  UINT64 entry_addr = *(UINT64*)(kernel_base_addr + 24);
2
3  typedef void EntryPointType(void);
4  EntryPointType* entry_point = (EntryPointType*)entry_addr;
5  entry_point();

1/kernel.elf
2/EFI/BOOT/BOOTX64.EFI

 1EFI_STATUS EFIAPI UefiMain(
 2    EFI_HANDLE image_handle,
 3    EFI_SYSTEM_TABLE* system_table) {
 4  EFI_STATUS                 Status;
 5  EFI_LOADED_IMAGE_PROTOCOL *LoadedImage = NULL;
 6      Status = gBS->OpenProtocol(
 7                  image_handle,
 8                  &gEfiLoadedImageProtocolGuid,
 9                  (VOID **) &LoadedImage,
10                  image_handle,
11                  NULL,
12                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
13                  );
14  if (EFI_ERROR(Status)) {
15    Print(L"OpenProtocol (LoadedImage) Failed: %r\n", Status);
16    return Status;
17  }
18  Print(L"Base = %p\n", LoadedImage->ImageBase);

1(gdb) target remote :1234
2(gdb) file
3(gdb) add-symbol-file build/Loader.debug 0x3E257240 -s .data 0x3E25b200
4# 커널도 마찬가지로 로드하면 양쪽 다 볼 수 있다. 
5# (gdb) add-symbol-file build/kernel.elf 0x103de0 -s .data 0x1136f0
6(gdb) disassemble UefiMain

1(gdb) x/10gx UefiMain
20x3e2574eb <UefiMain>:          0x0000000000000000      0x0000000000000000
30x3e2574fb <UefiMain+16>:       0x0000000000000000      0x0000000000000000
40x3e25750b <UefiMain+32>:       0x0000000000000000      0x0000000000000000
5
6(gdb) b UefiMain
7Breakpoint 1 at 0x3e2574eb: file /home/kdh/min-os/devenv/edk2/MinLoaderPkg/Main.c, line 172.
8
9(gdb) continue

 1// 파일 정보를 가져오는 것 까지는 같다.
 2  EFI_FILE_PROTOCOL* kernel_file;
 3  root_dir->Open(
 4      root_dir, &kernel_file, L"\\kernel.elf",
 5      EFI_FILE_MODE_READ, 0);
 6  _IfErrorHalt(L"open file '\\kernel.elf' Failed", status);
 7
 8  UINTN file_info_size = sizeof(EFI_FILE_INFO) + sizeof(CHAR16) * 12;
 9  UINT8 file_info_buffer[file_info_size];
10  kernel_file->GetInfo(
11      kernel_file, &gEfiFileInfoGuid,
12      &file_info_size, file_info_buffer);
13  _IfErrorHalt(L"get file information Failed", status);
14
15  EFI_FILE_INFO* file_info = (EFI_FILE_INFO*)file_info_buffer;
16  UINTN kernel_file_size = file_info->FileSize;
17
18  VOID* kernel_buffer;
19  status = gBS->AllocatePool(EfiLoaderData, kernel_file_size, &kernel_buffer);
20  _IfErrorHalt(L"allocate pool Failed", status);
21  status = kernel_file->Read(kernel_file, &kernel_file_size, kernel_buffer);
22  _IfErrorHalt(L"Read from kernel_file Failed..", status);
23
24  EFI_FILE_INFO* file_info = (EFI_FILE_INFO*)file_info_buffer;
25  UINTN kernel_file_size = file_info->FileSize;
26
27// AllocatePool 로 파일을 읽어올 임시 버퍼를 할당받는다. (바이트단위)
28  VOID* kernel_buffer;
29  status = gBS->AllocatePool(EfiLoaderData, kernel_file_size, &kernel_buffer);
30  _IfErrorHalt(L"allocate pool Failed", status);
31  status = kernel_file->Read(kernel_file, &kernel_file_size, kernel_buffer);
32  _IfErrorHalt(L"Read from kernel_file Failed..", status);

 1// 전체 Program Header를 확인해서 로드의 시작 주소, 끝 주소를 찾아오는 함수
 2void CalcLoadAddressRange(Elf64_Ehdr* ehdr, UINT64* first, UINT64* last) {
 3  Elf64_Phdr* phdr = (Elf64_Phdr*)((UINT64)ehdr + ehdr->e_phoff);
 4  *first = MAX_UINT64;
 5  *last = 0;
 6// Program Header의 수 만큼 반복
 7  for (Elf64_Half i = 0; i < ehdr->e_phnum; ++i) {
 8// PT_LOAD 만 메모리에 로드하면 된다. 
 9    if (phdr[i].p_type != PT_LOAD) continue;
10// Program Header가 가상메모리 주소 기준으로 정렬되지 않았을 수 있다.
11    *first = MIN(*first, phdr[i].p_vaddr);
12    *last = MAX(*last, phdr[i].p_vaddr + phdr[i].p_memsz);
13  }
14}
15// ---
16
17// 커널버퍼를 ELF Header 구조체로 읽을 수 있도록 Elf64_Ehdr* 타입에 포인터 저장
18// ELF64 Header 구조체 포맷을 미리 정의해야한다. elf.hpp에 작성
19  Elf64_Ehdr* kernel_ehdr = (Elf64_Ehdr*)kernel_buffer;
20  UINT64 kernel_first_addr, kernel_last_addr;
21  CalcLoadAddressRange(kernel_ehdr, &kernel_first_addr, &kernel_last_addr);
22  Print(L"Kernel: 0x%0lx - 0x%0lx\n", kernel_first_addr, kernel_last_addr);

 1// 커널을 섹션 단위로 로드하는 코드
 2void CopyLoadSegments(Elf64_Ehdr* ehdr) {
 3  Elf64_Phdr* phdr = (Elf64_Phdr*)((UINT64)ehdr + ehdr->e_phoff);
 4// Program Header의 수 만큼 반복
 5  for (Elf64_Half i = 0; i < ehdr->e_phnum; ++i) {
 6// PT_LOAD 만 로드하면 된다.
 7    if (phdr[i].p_type != PT_LOAD) continue;
 8// 각 세그먼트마다 파일의 오프셋 위치를 가상주소에 filesz 만큼 복사(로드)한다.
 9    UINT64 segm_in_file = (UINT64)ehdr + phdr[i].p_offset;
10    CopyMem((VOID*)phdr[i].p_vaddr, (VOID*)segm_in_file, phdr[i].p_filesz);
11// 메모리상의 사이즈보다 파일상 섹션 사이즈가 작으면 나머지는 0으로 채운다.
12// .bss 영역의 경우엔 초기화되지 않은 전역변수가 담겨져있고, 
13// 개발자가 초기화하지 않았지만 무조건 0인 이유는 여기에 있다. 
14    UINTN remain_bytes = phdr[i].p_memsz - phdr[i].p_filesz;
15    SetMem((VOID*)(phdr[i].p_vaddr + phdr[i].p_filesz), remain_bytes, 0);
16  }
17}
18// ---
19
20// 페이지 수 계산 후 커널 시작주소(이미지베이스)에 할당
21  UINTN num_pages = (kernel_last_addr - kernel_first_addr + 0xfff) / 0x1000;
22  status = gBS->AllocatePages(AllocateAddress, EfiLoaderData,
23                                num_pages, &kernel_first_addr);
24  _IfErrorHalt(L"AllocatePages Failed!", status);
25
26  CopyLoadSegments(kernel_ehdr);
27// 커널을 이미지베이스에 잘 로드했으니 임시버퍼는 해제한다. 
28  status = gBS->FreePool(kernel_buffer);
29  _IfErrorHalt(L"FreePool Failed", status);

1// 엔트리포인트 위치 계산(0x18 오프셋) 후 실행한다.
2  UINT64 entry_addr = *(UINT64*)(kernel_first_addr + 24);
3  typedef void EntryPointType(UINT64, UINT64);
4  EntryPointType* entry_point = (EntryPointType*)entry_addr;
5  entry_point(gop->Mode->FrameBufferBase, gop->Mode->FrameBufferSize);