부록 L — 기계가 깨어나는 순서: 부팅과 부트로더

55장에서 「main 을 누가 부르는가」를 물었고, 답은 운영체제였다. 그러면 운영체제는 누가 부르는가. 이 부록은 그 물음을 따라 전원 스위치까지 내려간다.

세부는 기계마다 다르고, 다 알 필요도 없다. 대신 한 문장을 붙잡으면 어떤 기계의 부팅이든 읽어 낼 수 있다. 부팅은 사슬이고, 각 칸이 하는 일은 같다 — 다음 것을 찾고, 읽어 싣고, 맞는지 보고, 제어를 넘긴다.

그림 105.1 — 부팅의 사슬 — 기계는 달라도 각 칸이 하는 일은 같다.

전원이 들어오면#

CPU 는 아무것도 모르는 채로 깨어난다. 기억에는 쓰레기가 있고, 장치는 초기화되어 있지 않으며, 「프로그램」이라는 개념도 아직 없다. CPU 가 아는 것은 하나다 — 정해진 주소를 읽어 거기서부터 실행한다. 「OS 없이 도는 C」 부록에서 본 리셋 벡터가 그것이다.

그 정해진 자리에는 대개 ROM 이 배선되어 있고, 거기 든 프로그램을 펌웨어라 부른다. PC 라면 BIOS 또는 UEFI 펌웨어이고, 작은 칩이라면 제조사가 넣어 둔 부트 ROM 이다.

BIOS 시대 — 512바이트가 전부였다#

옛 PC 의 방식은 놀랄 만큼 단순하다. BIOS 는 부팅 장치의 첫 섹터 512바이트를 주소 0x7C00 에 싣고, 그 끝 두 바이트가 0x55 0xAA 인지 보고, 맞으면 그리로 뛴다. 그게 전부다. 그 512바이트를 부팅 섹터, 디스크 전체의 첫 섹터를 MBR(master boot record)이라 부른다.

직접 만들어 보면 자리 나눔이 눈에 들어온다. 다만 무엇을 만드는지를 먼저 분명히 해 두자.

/* 디스크의 첫 섹터에 무엇이 있는가 --- 직접 만들어 보고, 다시 읽어 본다.

   주의: 이 프로그램은 디스크를 건드리지 않는다. 파일도 장치도 열지 않고, 아무것도 쓰지
   않는다. 기억 속의 배열 하나를 옛 규약 그대로 채운 뒤, 그 배열을 다시 읽어 해독해
   화면에 찍을 뿐이다. 돌리면 글자만 나오고 끝난다.

   여기서 만드는 바이트는 진짜 규칙을 따른다: 512바이트, 0x1BE 의 파티션 표 네 칸,
   그리고 끝의 0x55 0xAA. GPT 를 쓰는 디스크의 첫 섹터(보호 MBR)와 EFI PART 헤더도
   같이 만든다. 이 바이트를 실제 디스크의 0번 섹터에 쓰는 일은 하지 않는다. */
#include <stdio.h>
#include <stdint.h>
#include <string.h>

static uint32_t crc32(const void *buf, size_t n)
{
    const unsigned char *p = buf;
    uint32_t c = 0xFFFFFFFFu;
    for (size_t i = 0; i < n; i++) {
        c ^= p[i];
        for (int k = 0; k < 8; k++)
            c = (c >> 1) ^ (0xEDB88320u & (uint32_t)-(int32_t)(c & 1));
    }
    return c ^ 0xFFFFFFFFu;
}

static void put32(unsigned char *p, uint32_t v)
{ p[0] = v & 0xff; p[1] = v >> 8 & 0xff; p[2] = v >> 16 & 0xff; p[3] = v >> 24; }

static void put_part(unsigned char *e, uint8_t boot, uint8_t type,
                     uint32_t lba, uint32_t count)
{
    e[0] = boot;              /* 0x80 이면 「이것으로 부팅」 */
    e[1] = 0xfe; e[2] = 0xff; e[3] = 0xff;   /* 옛 CHS 자리 --- 이제는 채우는 시늉만 한다 */
    e[4] = type;
    e[5] = 0xfe; e[6] = 0xff; e[7] = 0xff;
    put32(e + 8, lba);        /* 시작 --- 이쪽이 진짜로 쓰인다 */
    put32(e + 12, count);
}

static void hexdump(const unsigned char *p, size_t off, size_t n)
{
    for (size_t i = 0; i < n; i += 16) {
        printf("  %04zx  ", off + i);
        for (size_t j = 0; j < 16; j++) printf("%02x%s", p[off + i + j], j == 7 ? "  " : " ");
        printf("\n");
    }
}

int main(void)
{
    unsigned char mbr[512] = { 0 };

    /* (1) 부트스트랩 자리 --- 446바이트. 진짜 부트로더의 첫 조각이 여기 들어간다. */
    memcpy(mbr, "\xfa\x31\xc0\x8e\xd8\x8e\xd0\xbc\x00\x7c", 10);  /* cli; 세그먼트·스택 차리기 */
    printf("how the first sector divides up\n");
    printf("  0x000 - 0x1bd : bootstrap code, %d bytes\n", 0x1be);
    printf("  0x1be - 0x1fd : partition table --- 16 bytes x 4 entries\n");
    printf("  0x1fe - 0x1ff : signature 0x55 0xaa\n\n");

    /* (2) 파티션 표 --- 흔한 배치 하나를 적어 둔다 */
    put_part(mbr + 0x1be, 0x80, 0x83, 2048, 1024000);   /* 부팅 가능, 리눅스 */
    put_part(mbr + 0x1ce, 0x00, 0x82, 1026048, 262144); /* 리눅스 스왑 */
    mbr[510] = 0x55; mbr[511] = 0xaa;

    printf("the partition table (from 0x1be)\n");
    hexdump(mbr, 0x1be, 32);
    printf("\n  entry 1: bootable %s · type 0x%02x (Linux) · start LBA %u · %u sectors (%u MiB)\n",
           mbr[0x1be] == 0x80 ? "yes" : "no", mbr[0x1be + 4],
           2048u, 1024000u, 1024000u / 2048u);
    printf("  entry 2: bootable %s · type 0x%02x (swap) · start LBA %u\n\n",
           mbr[0x1ce] == 0x80 ? "yes" : "no", mbr[0x1ce + 4], 1026048u);

    printf("the last two bytes: %02x %02x --- %s\n\n", mbr[510], mbr[511],
           (mbr[510] == 0x55 && mbr[511] == 0xaa)
           ? "the BIOS accepts this as a boot sector only with these" : "not a boot sector");

    /* (3) GPT 를 쓰는 디스크의 첫 섹터 --- 보호 MBR */
    unsigned char pmbr[512] = { 0 };
    put_part(pmbr + 0x1be, 0x00, 0xee, 1, 0xffffffffu);  /* 0xEE = 「여기부터 끝까지 남의 것」 */
    pmbr[510] = 0x55; pmbr[511] = 0xaa;
    printf("the protective MBR (first sector of a GPT disk)\n");
    printf("  partition type 0x%02x --- it tells old tools the disk is fully used\n",
           pmbr[0x1be + 4]);
    printf("  the reason: to stop a tool that does not know GPT taking it for empty\n\n");

    /* (4) 진짜 지도는 두 번째 섹터(LBA 1)에 있다 --- GPT 헤더 */
    unsigned char gpt[92] = { 0 };
    memcpy(gpt, "EFI PART", 8);
    put32(gpt + 8, 0x00010000u);      /* 개정 1.0 */
    put32(gpt + 12, 92);              /* 헤더 크기 */
    put32(gpt + 16, 0);               /* CRC 자리는 0 으로 두고 계산한다 */
    put32(gpt + 16, crc32(gpt, 92));

    printf("the GPT header (LBA 1)\n");
    printf("  signature : %.8s\n", gpt);
    printf("  header CRC32: 0x%08x --- it checks itself (this field is zero while computing)\n",
           (unsigned)(gpt[16] | gpt[17] << 8 | gpt[18] << 16 | (uint32_t)gpt[19] << 24));
    printf("  and the same table exists once more at the very end of the disk, to survive damage\n");
    return 0;
}

how the first sector divides up
  0x000 - 0x1bd : bootstrap code, 446 bytes
  0x1be - 0x1fd : partition table --- 16 bytes x 4 entries
  0x1fe - 0x1ff : signature 0x55 0xaa

the partition table (from 0x1be)
  01be  80 fe ff ff 83 fe ff ff  00 08 00 00 00 a0 0f 00 
  01ce  00 fe ff ff 82 fe ff ff  00 a8 0f 00 00 00 04 00 

  entry 1: bootable yes · type 0x83 (Linux) · start LBA 2048 · 1024000 sectors (500 MiB)
  entry 2: bootable no · type 0x82 (swap) · start LBA 1026048

the last two bytes: 55 aa --- the BIOS accepts this as a boot sector only with these

the protective MBR (first sector of a GPT disk)
  partition type 0xee --- it tells old tools the disk is fully used
  the reason: to stop a tool that does not know GPT taking it for empty

the GPT header (LBA 1)
  signature : EFI PART
  header CRC32: 0x36425678 --- it checks itself (this field is zero while computing)
  and the same table exists once more at the very end of the disk, to survive damage

시연은 네 걸음으로 간다.

1. 자리를 선언한다. 512바이트를 446 + 16×4 + 2 로 나누어 찍는다. 맨 앞에 넣는 열 바이트(fa 31 c0 8e d8 … — 인터럽트를 끄고 세그먼트와 스택을 차리는 코드)는 진짜 부트로더의 첫머리가 대개 어떤 모양인지 보이려는 것이지, 도는 부트로더가 아니다.
2. 파티션 항목 둘을 규약대로 적는다. 부팅 표시 0x80, 종류 0x83(리눅스)과 0x82(스왑), 시작 LBA 와 섹터 수를 작은 끝 차례의 4바이트로. 옛 CHS 자리는 요즘 관례대로 fe ff ff 로 채운다 — 「CHS 로는 못 적는 크기」라는 뜻의 관용 값이다. 그리고 510·511 번 바이트에 55 aa 를 둔다.
3. 자기가 적은 것을 다시 읽는다. 그 64바이트를 16진수로 찍고, 같은 바이트에서 「부팅 가능 · 종류 0x83 · 시작 LBA 2048 · 500 MiB」를 도로 꺼낸다. 쓰기와 읽기가 같은 규약을 쓰는지가 그 자리에서 드러난다.
4. GPT 쪽도 같은 방식으로 지어 본다. 종류 0xEE 하나로 디스크를 덮는 보호 MBR 을 만들고, EFI PART 서명이 붙은 92바이트 헤더를 만들어 CRC 자리를 0 으로 둔 채 CRC32 를 계산해 그 자리에 써 넣는다 — 규격이 정한 그대로다. 출력에 나온 0x36425678 은 그렇게 계산된 진짜 값이다. 다만 GUID 와 LBA 필드들은 0 이므로 모양을 보이는 표본이지 쓸 수 있는 GPT 헤더는 아니다.

여기서 얻는 것은 「어느 필드가 몇 번째 바이트인가」가 아니다. 446바이트라는 숫자 하나다. 그 좁은 자리가 뒤의 모든 것을 설명한다.

446바이트에 운영체제를 읽어 들이는 코드가 들어갈 리 없다. 그래서 옛 부트로더는 전부 여러 단계로 쪼개졌다 — 첫 조각은 「둘째 조각이 어디 있는지」만 알고, 둘째 조각이 파일 시스템을 읽을 줄 알며, 그다음이 커널을 싣는다.

디스크의 배치도 — MBR 에서 GPT 로#

파티션 넷과 32비트 LBA(2 TiB 한계)는 곧 좁아졌다. 그 자리를 GPT(GUID Partition Table)가 대신한다. 위 시연의 뒷부분이 그 이야기다.

• 첫 섹터에는 여전히 MBR 이 있다. 다만 파티션 하나가 종류 0xEE 로 디스크 전체를 덮고 있다 — 보호 MBR. GPT 를 모르는 옛 도구가 「빈 디스크」로 알고 덮어쓰는 것을 막으려는 장치다.
• 진짜 배치도는 두 번째 섹터(LBA 1)의 GPT 헤더에 있다. 서명이 EFI PART 이고, 자기 자신의 CRC32 를 담으며, 같은 표가 디스크 맨 끝에 한 벌 더 있다.

이 두 방식의 필드 하나하나와 파티션 안의 파일 시스템까지는 「디스크는 어떻게 나뉘어 있는가」 부록이 표로 다룬다. 여기서는 사슬 이야기에 필요한 만큼만 본다.

★ 옛 방식과 새 방식의 차이가 두 낱말로 요약된다 — 검사와 사본. 0x55 0xAA 두 바이트가 하던 「맞는가」를 CRC 가 대신하고, 한 벌뿐이던 표가 두 벌이 되었다. 신뢰성 설계는 대체로 이 두 가지의 되풀이다.

UEFI — 펌웨어가 파일 시스템을 읽는다#

UEFI 는 「512바이트」라는 제약 자체를 없앤다. 펌웨어가 FAT 파일 시스템을 읽을 줄 알고, 디스크의 한 파티션(ESP, EFI System Partition)에서 실행 파일을 찾아 그냥 실행한다.

여기서 앞 부록과 이어진다. 그 실행 파일은 PE 형식이다 — 윈도우 실행 파일과 같은 옷을 입었고, 헤더의 서브시스템 필드만 「UEFI 응용」으로 되어 있다. 파일 이름도 약속되어 있어서, 아무 설정이 없으면 \EFI\BOOT\BOOTX64.EFI 를 찾는다.

부트로더가 실제로 하는 일#

이름은 여럿이지만 하는 일은 표 105.1의 뒷부분과 같다. 그런데 그 「같은 일」을 어떻게 해내는지가 방식마다 꽤 다르고, 실무에서 부딪히는 문제는 대부분 그 차이에서 나온다. 하나씩 연다.

왜 여러 단계인가 — 446바이트의 그늘#

옛 BIOS 방식에서 첫 조각에 허락된 자리는 446바이트다 — 512바이트 가운데 파티션 표와 서명을 뺀 나머지다(자리 나눔의 전체 표는 「디스크는 어떻게 나뉘어 있는가」 부록에 있다). 파일 시스템을 읽는 코드가 그 안에 들어갈 리 없다. 그래서 부트로더는 쪼개진다.

★ 둘째 줄이 핵심이다. boot.img 는 파일 이름으로 다음 조각을 찾지 못한다 — 파일 시스템을 모르니까. 대신 섹터 번호를 박아 둔다. 그래서 core.img 가 놓일 「파일 시스템 바깥의 빈 자리」가 필요하다.

UEFI 경로 — 이름과 변수로 찾는다#

UEFI 에서는 이 모든 우회가 사라진다. 펌웨어가 FAT 를 읽을 줄 알기 때문에, 부트로더는 그냥 파일이다(디스크 부록의 ESP 항목 참고).

★ 그래서 UEFI 기계에서 「부팅 순서가 사라졌다」는 사고는 디스크가 아니라 메인보드의 변수가 지워진 것이다. 폴백 이름이 있는 이유가 여기 있다 — USB 하나로 아무 기계나 부팅할 수 있는 것도 그 약속 덕이다.

부트로더 없이 — 리눅스 EFI 스텁#

리눅스 커널 이미지는 그 자체가 PE 실행 파일로 만들어질 수 있다. 그러면 펌웨어가 커널을 직접 실행한다. 얇고 빠르지만 대가가 있다 — 메뉴가 없고, 명령줄과 initramfs 를 누가 정해 주느냐가 문제가 된다(펌웨어 변수에 박아 두거나, 커널에 박아 넣거나).

임베디드 — U-Boot 와 MCUboot#

작은 기계에서는 「램조차 아직 없는」 자리에서 시작한다.

넘겨줄 때 무엇을 물려주는가#

사슬의 각 칸은 사라지기 전에 다음 칸에게 짐을 남긴다. 그 짐의 목록이 곧 규약이다.

★ UEFI 줄의 ExitBootServices 를 눈여겨보라. 그 호출 전까지는 펌웨어가 디스크·화면· 네트워크를 대신 다뤄 준다. 부른 뒤에는 그 서비스가 전부 사라지고, 기억 배치표의 사본만 남는다. 「운영체제가 기계를 넘겨받는 순간」이 함수 호출 하나로 정확히 정해져 있는 것이다.

안 뜰 때 — 증상으로 칸을 가린다#

운영체제마다 — 그 뒤에 무슨 일이 일어나는가#

MS-DOS#

부팅 섹터가 IO.SYS 를 읽고, 그것이 MSDOS.SYS(커널에 해당)를 올린 뒤, CONFIG.SYS 를 읽어 장치 드라이버를 싣고, 마지막으로 COMMAND.COM 을 띄운다. 그리고 AUTOEXEC.BAT 가 돈다. 사슬이 파일 이름으로 그대로 드러나 있어서, 이 시절 사용자는 부팅 과정을 편집할 수 있었다.

윈도우#

바뀐 것은 「고르기」의 자리다. 텍스트 파일(boot.ini)이 이진 저장소(BCD)로 바뀌었고, .efi 실행 파일이 되었다. 바뀌지 않은 것은 사슬의 모양이다.

리눅스#

1. 부트로더가 커널 이미지(vmlinuz)와 initramfs 를 기억에 싣고 명령줄을 물려준다.
2. 커널 이미지의 앞부분은 자기 자신을 푸는 코드다. 압축을 풀고 진짜 커널로 뛴다.
3. 커널이 자기 자료 구조를 세우고, initramfs 를 임시 루트 파일 시스템으로 삼는다.
4. initramfs 안의 /init 가 진짜 루트를 찾는 데 필요한 드라이버를 싣는다.
5. 진짜 루트로 갈아탄 뒤(switch_root), PID 1 로 init(요즘은 대개 systemd)를 실행한다.

RTOS 와 작은 기계#

작은 기계 — RTOS(real-time operating system)를 쓰는 자리 — 에는 대개 「운영체제를 싣는」 단계가 없다. 커널이 응용과 함께 링크되어 이미지 하나가 되기 때문이다. FreeRTOS·Zephyr·NuttX 가 그렇다. 리셋 벡터에서 시작 코드가 돌고, main 이 불리고, 거기서 스케줄러를 시작하면 그때부터 태스크가 돈다.

그렇다고 부트로더가 없는 것은 아니다. 오히려 여기서 부트로더의 본래 일이 선명해진다.

사슬이 곧 신뢰의 사슬#

각 칸이 다음 칸을 검사한다고 했다. 그 검사를 서명으로 하면 사슬 전체가 신뢰의 사슬이 된다 — 펌웨어가 부트로더의 서명을 보고, 부트로더가 커널의 서명을 보고, 커널이 모듈의 서명을 본다. 보안 부팅(secure boot)과 임베디드의 서명 부팅이 같은 이야기다.

★ 이 구조의 성질을 하나만 짚어 둔다. 사슬은 맨 앞에서만 신뢰를 만들 수 있다. 첫 칸 (ROM 안의 코드)은 바꿀 수 없어야 하고, 그래서 그 자리를 「신뢰의 뿌리」라 부른다. 뿌리가 흔들리면 뒤의 모든 검사는 의미가 없다 — 검사하는 코드 자체를 바꿔치기할 수 있으니까.

여기서 남기는 것#