디스크파티션과 파일시스템

 1### 디스크 만들기
 2$ dd if=/dev/zero of=fake_disk.img bs=1M count=50
 3$ sudo parted fake_disk.img mklabel msdos
 4
 5###  파티션 만들기
 6## 512byte까지 MBR인데, 1MiB로 Alignment 권장
 7$ sudo parted fake_disk.img mkpart primary fat32 1MiB 40MiB
 8$ parted fake_disk.img print
 9Number  Start   End     Size    Type     File system  Flags
10 1      1049kB  41.9MB  40.9MB  primary               lba
11
12### 마운트해서 FAT32로 포맷하기
13$ sudo losetup -fP fake_disk.img
14$ sudo mkfs.fat -F 32 /dev/loop0p1    # 안되면 sudo losetup -l 로 확인
15$ sudo mount /dev/loop0p1 /mnt
16$ df -h /mnt
17Filesystem      Size  Used Avail Use% Mounted on
18/dev/loop0p1     39M   512   39M   1% /mnt

 1### install-mbr은 필요 없는 작업이지만, 좀 더 읽기 쉬워진다.
 2$ sudo apt-get install mbr
 3$ sudo install-mbr /dev/loop0
 4$ sudo dd if=fake_disk.img of=mbr.bin bs=512 count=1
 5$ objdump -D -b binary -m i8086 -M intel mbr.bin
 6   b:   be 00 7c                mov    si,0x7c00           # MBR을 0x600으로 자가복제
 7   e:   bf 00 06                mov    di,0x600
 8  11:   b9 00 01                mov    cx,0x100
 9  14:   f3 a5                   rep movs WORD PTR es:[di],WORD PTR ds:[si]
10  1b:   ea 20 06 00 00          jmp    0x0:0x620           # 자가복제된 코드로 점프
11  20:   80 3e b2 07 ff          cmp    BYTE PTR ds:0x7b2,0xff  # 여기로 점프됨
12
13  7e:   be be 07                mov    si,0x7be            # 파티션테이블 시작위치 (0x1be)
14  81:   b0 00                   mov    al,0x0
15  83:   b9 04 00                mov    cx,0x4              # 파티션테이블만큼 4번 반복
16  86:   80 3c 00                cmp    BYTE PTR [si],0x0   # bootable 플래그가 0인지 확인
17  89:   75 66                   jne    0xf1
18  8b:   fe c0                   inc    al
19  8d:   83 c6 10                add    si,0x10             # 다음 파티션테이블로 이동
20  90:   e2 f4                   loop   0x86
21
22  f1:   e8 83 00                call   0x177
23 117:   b4 41                   mov    ah,0x41             # EDD(디스크 확장 RW) 지원여부 확인
24 119:   bb aa 55                mov    bx,0x55aa
25 11c:   52                      push   dx
26 11d:   cd 13                   int    0x13
27 12a:   f6 c1 01                test   cl,0x1              # cl이 1이라면 지원. & 연산으로 확인
28 12d:   74 13                   je     0x142               # & 연산 결과가 zero 플래그 세팅되면 미지원
29 12f:   8b 44 08                mov    ax,WORD PTR [si+0x8]
30 132:   8b 5c 0a                mov    bx,WORD PTR [si+0xa]
31 135:   be 90 07                mov    si,0x790
32 138:   89 44 08                mov    WORD PTR [si+0x8],ax
33 13b:   89 5c 0a                mov    WORD PTR [si+0xa],bx
34 13e:   b4 42                   mov    ah,0x42             # AH=42h=함수번호(DAP)
35 140:   eb 0c                   jmp    0x14e
36 142:   8a 74 01                mov    dh,BYTE PTR [si+0x1]
37 145:   8b 4c 02                mov    cx,WORD PTR [si+0x2]
38 148:   b8 01 02                mov    ax,0x201            # AH=02h=함수번호(CHS), AL=1 sector
39 14b:   bb 00 7c                mov    bx,0x7c00           # destination 주소
40 14e:   50                      push   ax
41 14f:   c6 06 92 07 01          mov    BYTE PTR ds:0x792,0x1
42 154:   cd 13                   int    0x13                # 어쨌든 VBR을 0x7c00으로 복사
43
44 15f:   81 3e fe 7d 55 aa       cmp    WORD PTR ds:0x7dfe,0xaa55  # VBR 시그니쳐 확인
45 172:   ea 00 7c 00 00          jmp    0x0:0x7c00          # 대충 맞으면 VBR로 점프

 1### 부트 플래그 설정
 2$ sudo fdisk /dev/loop0
 3Command (m for help): a
 4Selected partition 1
 5The bootable flag on partition 1 is enabled now.
 6
 7Command (m for help): w
 8The partition table has been altered.
 9Syncing disks.
10
11### DOS Bootloader 설치. 사실 FAT32는 33MB 이상 크기여야 인식된다. 
12$ sudo apt-get install syslinux
13$ sudo syslinux --install /dev/loop0p1
14$ ls /mnt
15ldlinux.c32  ldlinux.sys
16
17### 확인 및 마운트 해제
18$ sudo dd if=/dev/loop0p1 bs=512 count=1 of=vbr.bin
19$ sudo dd if=/dev/loop0 bs=512 count=1 of=mbr.bin
20$ objdump -D -b binary -m i8086 -M intel --start-address=0x7c5a --adjust-vma=0x7c00 vbr.bin
21$ objdump -D -b binary -m i8086 -M intel --start-address=0x8030 --adjust-vma=0x8000 /mnt/ldlinux.sys
22
23$ sudo umount /mnt
24$ sudo losetup -d /dev/loop0

 1    7d01:       b4 41                   mov    ah,0x41
 2    7d03:       e8 cb 00                call   0x7dd1
 3    7d0e:       f6 c1 01                test   cl,0x1        ; 여기에서도 EDD가 지원되는지 확인
 4    7d11:       74 05                   je     0x7d18
 5    7d13:       c6 06 46 7d 00          mov    BYTE PTR ds:0x7d46,0x0    ; [7d46] = 0 세팅
 6    7d18:       66 b8 ef 04 00 00       mov    eax,0x4ef
 7    7d1e:       66 ba 00 00 00 00       mov    edx,0x0
 8    7d24:       bb 00 80                mov    bx,0x8000
 9    7d27:       e8 0e 00                call   0x7d38        ; CHS 방식으로 파티션의 섹터 성공할때까지 읽기 (int 13h)
10    7d2a:       66 81 3e 1c 80 dc 50    cmp    DWORD PTR ds:0x801c,0x5fa150dc     ; ldlinux.sys 의 0x1c 오프셋의 값을 비교
11    7d31:       a1 5f                                        ; 9byte짜리 명령이 해석이 잘못된 것이지만, 포함해도 해석이 달라지진 않음. 무시
12    7d33:       75 74                   jne    0x7da9        ; 읽어왔는데도 다르다면 에러 출력
13    7d35:       e9 f8 02                jmp    0x8030        ; ldlinux.sys 의 0x30 (entry) 으로 점프
14
15; 얘는 그냥 중간중간 호출하면서 0x13 인터럽트 호출해주는 함수이다. 
16    7dd1:       8a 16 74 7b             mov    dl,BYTE PTR ds:0x7b74   ; dl에는 드라이브인덱스를 넣어둬야함
17    7dd5:       06                      push   es
18    7dd6:       cd 13                   int    0x13                    ; 인터럽트로 드라이브의 특정섹터 읽기
19    7dd8:       07                      pop    es
20    7dd9:       c3                      ret

 1$ dd if=/dev/zero of=fake_disk.img bs=1M count=50
 2$ sudo parted fake_disk.img mklabel msdos
 3$ sudo losetup -fP fake_disk.img
 4$ sudo parted /dev/loop0 --script mklabel gpt
 5
 6### 파티션 테이블에 ESP 파티션을 만든다.
 7$ sudo parted fake_disk.img mkpart ESP fat32 1MiB 40MiB
 8$ parted fake_disk.img print
 9Number  Start   End     Size    File system  Name  Flags
10 1      1049kB  41.9MB  40.9MB               ESP   msftdata
11
12### 첫번째 파티션에 EFI System Partition GUID 설정하고 파일시스템 생성
13$ sudo parted /dev/loop0 set 1 esp on
14$ sudo mkfs.vfat -F 32 -n ESP /dev/loop0p1
15
16$ sudo umount /mnt
17$ sudo losetup -d /dev/loop0

 1+-----------------------+ ← FAT32 sector 0 (0x00100000)
 2| Reserved Region       | Boot sector, FSInfo sector
 3+-----------------------+
 4| FAT Table 1           | 클러스터 체인 정보 (e.g. 2 → 5 → 8 …)
 5+-----------------------+
 6| FAT Table 2 (optional)| 백업용 FAT
 7+-----------------------+
 8| Data Region           | 실제 데이터가 저장되는 영역
 9| - Cluster #2          | 루트 디렉토리 시작
10| - Cluster #3          |
11| - Cluster #4          |
12| - ...                 |
13+-----------------------+

 1VOID* volume_image;
 2
 3EFI_FILE_PROTOCOL* volume_file;
 4status = root_dir->Open(
 5  root_dir, &volume_file, L"\\fat_disk",
 6  EFI_FILE_MODE_READ, 0);
 7if (status == EFI_SUCCESS) {
 8  status = ReadFile(volume_file, &volume_image);
 9  _IfErrorHalt(L"failed to open Block I/O Protocol", status);
10} else {
11  EFI_BLOCK_IO_PROTOCOL* block_io;
12  // 부팅미디어에 연결된 block_io를 획득
13  status = OpenBlockIoProtocolForLoadedImage(image_handle, &block_io);
14  _IfErrorHalt(L"failed to open Block I/O Protocol", status);
15
16  // media 에는 프로토콜과 연결된 블록디바이스의 정보가 담긴다. 
17  // 블록당 바이트 수와 블록번호를 이용해서 블록디바이스의 크기를 알아낸다. 
18  EFI_BLOCK_IO_MEDIA* media = block_io->Media;
19  UINTN volume_bytes = (UINTN)media->BlockSize * (media->LastBlock + 1);
20  if (volume_bytes > 16 * 1024 * 1024) {
21    volume_bytes = 16 * 1024 * 1024;
22  }
23
24  Print(L"Reading &lu bytes (Present %d, BlockSize %u, Lastblock %u)\n",
25    volume_bytes, media->MediaPresent, media->BlockSize, media->LastBlock);
26  // 모든 블록을 읽어와서 volume_image에 저장한다. 
27  status = ReadBlocks(block_io, media->MediaId, volume_bytes, &volume_image);
28  _IfErrorHalt(L"failed to read blocks", status);
29}
30
31// 커널에 volume_image(볼륨을 읽어온 바이트버퍼) 를 전달함
32typedef void EntryPointType(const struct FrameBufferConfig*,
33                            const struct MemoryMap*,
34                            const VOID*,
35                            VOID*
36                          );
37EntryPointType* entry_point = (EntryPointType*)entry_addr;
38entry_point(&config, &memmap, acpi_table, volume_image);

 1EFI_STATUS ReadFile(EFI_FILE_PROTOCOL* file, VOID** buffer) {
 2  EFI_STATUS status;
 3
 4  UINTN file_info_size = sizeof(EFI_FILE_INFO) + sizeof(CHAR16) * 12;
 5  UINT8 file_info_buffer[file_info_size];
 6  status = file->GetInfo(
 7    file, &gEfiFileInfoGuid,
 8    &file_info_size, file_info_buffer);
 9  if (EFI_ERROR(status)) {
10    return status;
11  }
12
13  EFI_FILE_INFO* file_info = (EFI_FILE_INFO*)file_info_buffer;
14  UINTN file_size = file_info->FileSize;
15
16  status = gBS->AllocatePool(EfiLoaderData, file_size, buffer);
17  if (EFI_ERROR(status)) {
18    return status;
19  }
20  return file->Read(file, &file_size, *buffer);
21}

 1EFI_STATUS OpenBlockIoProtocolForLoadedImage(
 2    EFI_HANDLE image_handle, EFI_BLOCK_IO_PROTOCOL** block_io) {
 3  EFI_STATUS  status;
 4  EFI_LOADED_IMAGE_PROTOCOL* loaded_image;
 5
 6  // 메인에 전달된 image_handle 을 이용해서 현재 실행중인 부트로더(BOOTX64.EFI)의 정보를 획득한다.
 7  status = gBS->OpenProtocol(
 8    image_handle,
 9    &gEfiLoadedImageProtocolGuid,
10    (VOID**)&loaded_image,
11    image_handle,
12    NULL,
13    EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
14  if (EFI_ERROR(status)) {
15    return status;
16  }
17
18  // 부트로더가 저장된 기억장치에 대한 DeviceHandle을 이용해서 Block IO Protocol을 획득
19  status = gBS->OpenProtocol(
20    loaded_image->DeviceHandle,
21    &gEfiBlockIoProtocolGuid,
22    (VOID**)block_io,
23    image_handle,
24    NULL,
25    EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL);
26  return status;
27}

 1EFI_STATUS ReadBlocks(
 2    EFI_BLOCK_IO_PROTOCOL* block_io, UINT32 media_id,
 3    UINTN read_bytes, VOID** buffer) {
 4  EFI_STATUS status;
 5
 6  status = gBS->AllocatePool(EfiLoaderData, read_bytes, buffer);
 7  if (EFI_ERROR(status)) {
 8    return status;
 9  }
10
11  status = block_io->ReadBlocks(
12    block_io,
13    media_id,
14    0,
15    read_bytes,
16    *buffer);
17  return status;
18}

 1struct BPB {
 2  uint8_t jump_boot[3];
 3  char oem_name[8];
 4  uint16_t bytes_per_sector;
 5  uint8_t sectors_per_cluster;
 6  uint16_t reserved_sector_count;
 7  uint8_t num_fats;
 8  uint16_t root_entry_count;
 9  // ...
10} __attribute__((packed));
11
12enum class Attribute : uint8_t {
13  kReadOnly  = 0x01,
14  kHidden    = 0x02,
15  kSystem    = 0x04,
16  kVolumeID  = 0x08,
17  kDirectory = 0x10,
18  kArchive   = 0x20,
19  kLongName  = 0x0f,
20};
21
22struct DirectoryEntry {
23  unsigned char name[11];
24  Attribute attr;
25  uint8_t ntres;
26  uint8_t create_time_tenth;
27  // ...
28  uint16_t first_cluster_low;
29  uint32_t file_size;
30
31  // 현재 엔트리의 파일이 실제로 저장된 시작 클러스터
32  uint32_t FirstCluster() const {
33    return first_cluster_low |
34      (static_cast<uint32_t>(first_cluster_high) << 16);
35  }
36} __attribute__((packed));

 1// 이 함수는 SFN을 기준으로 작성된 코드이다. 
 2void ReadName(const DirectoryEntry& entry, char* base, char* ext) {
 3  memcpy(base, &entry.name[0], 8);
 4  base[8] = 0;
 5  for (int i = 7; i >= 0 && base[i] == 0x20; --i) {
 6    base[i] = 0;
 7  }
 8
 9  memcpy(ext, &entry.name[8], 3);
10  ext[3] = 0;
11  for (int i = 2; i >= 0 && ext[i] == 0x20; --i) {
12    ext[i] = 0;
13  }
14}
15
16// 섹터의 주소를 가져오는 함수인데, 템플릿으로 만들어져 있다. 
17// 해당 섹터가 Directory Entry 배열일 수도 있고, 파일이 들어있을수도 있기 때문이다.
18template <class T>
19T* GetSectorByCluster(unsigned long cluster) {
20  return reinterpret_cast<T*>(GetClusterAddr(cluster));
21}
22
23// 클러스터 계산하는 방식대로 계산하고 실제 주소니까 바이트만큼 곱해주면 된다.
24// boot_volume_image 는 UEFI에서 할당받은 주소라서 메모리상 베이스주소를 더해줘야한다. 
25uintptr_t GetClusterAddr(unsigned long cluster) {
26  unsigned long sector_num =
27    boot_volume_image->reserved_sector_count +
28    boot_volume_image->num_fats * boot_volume_image->fat_size_32 +
29    (cluster - 2) * boot_volume_image->sectors_per_cluster;
30  uintptr_t offset = sector_num * boot_volume_image->bytes_per_sector;
31  return reinterpret_cast<uintptr_t>(boot_volume_image) + offset;
32}

 1  } else if (strcmp(command, "ls") == 0) {
 2    // root 클러스터에서 디렉터리 엔트리를 가져온다. 
 3    auto root_dir_entries = fat::GetSectorByCluster<fat::DirectoryEntry>(
 4        fat::boot_volume_image->root_cluster);
 5    // 클러스터 당 엔트리배열 수를 가져온다. 
 6    auto entries_per_cluster =
 7       fat::boot_volume_image->bytes_per_sector / sizeof(fat::DirectoryEntry)
 8       * fat::boot_volume_image->sectors_per_cluster;
 9
10    char base[9], ext[4];
11    char s[64];
12    // 전체 엔트리 순회 
13    for (int i = 0; i < entries_per_cluster; ++i) {
14      // SFN을 읽어서 base, ext에 넣는다. 
15      ReadName(root_dir_entries[i], base, ext);
16      // 0x00: 저장되지 않음, 0xe5: 삭제됨, LFN 엔트리 제외
17      if (base[0] == 0x00) {
18        break;
19      } else if (static_cast<uint8_t>(base[0]) == 0xe5) {
20        continue;
21      } else if (root_dir_entries[i].attr == fat::Attribute::kLongName) {
22        continue;
23      }
24
25      // 확장자가 있다면 base.ext 형태로 출력 
26      if (ext[0]) {
27        sprintf(s, "%s.%s\n", base, ext);
28      } else {
29        sprintf(s, "%s\n", base);
30      }
31      Print(s);
32    }