Implement a Multiboot-Compliant Bootloader Header

Topic Overview

Multiboot header

Multiboot lets compliant bootloaders pass metadata to kernels like GRUB does for hobby OS projects. A valid header starts with magic 0x1BADB002, sets flags, and ends with a checksum making the sum of all three dwords zero. For example, flags 0x00000003 requests memory info and page-aligned modules.

Header layout

nasmCopy
Loading…

• Place the header in the first 8 KB of the OS image (often first 32 KB for GRUB2)
• Kernel entry must be 32-bit protected mode for Multiboot v1
• GRUB fills the multiboot info structure with memory map and cmdline pointers

Loader expectations

QEMU can boot a Multiboot kernel with -kernel when the header is valid. GRUB's multiboot command passes a magic value in EAX and a pointer to the info structure in EBX at entry. The header must be dword-aligned and located within the first 8 KB of the file. If QEMU reports invalid magic, double-check endianness and that the checksum sum wraps to zero in 32-bit arithmetic.

Why for this exercise

You will embed a Multiboot-compliant header in your kernel image and boot it with QEMU/GRUB. This exercise requires the correct magic, flags, and checksum so a Multiboot loader recognizes your binary.

Your Task

GRUB can boot any kernel that carries a Multiboot header: three little-endian 32-bit words (magic 0x1BADB002, flags, checksum) where magic + flags + checksum ≡ 0 (mod 2^32), 4-byte aligned and entirely within the first 8192 bytes of the file. Write the scanner a bootloader runs: find the header, verify it, decode the flags, work out exactly which file bytes get loaded where, and describe the hand-off.

Input

cCopy
Loading…

Tokens are a byte (two hex digits), #XXXXXXXX (a 32-bit word written little-endian), or a double-quoted ASCII string without spaces.

Rules

1. Find: the first offset that is a multiple of 4, with offset + 12 ≤ min(SIZE, 8192), holding the magic. If there is none, look for a Multiboot2 magic 0xE85250D6 at a multiple of 8 with offset + 16 ≤ min(SIZE, 32768). Otherwise report that nothing was found.

2. Verify the checksum.

3. Flags:

   • bit 0: align modules on 4 KiB pages;
   • bit 1: pass the memory map;
   • bit 2: pass video mode information;
   • bit 16: the address fields are valid.

   Any other bit in 0-15 is required, and a loader that does not know it must refuse the kernel. Unknown bits in 17-31 are optional and ignored.

4. Load (bit 16): the words at +12..+28 are header_addr, load_addr, load_end_addr, bss_end_addr and entry_addr (the header needs 32 bytes).

   • The load starts at file offset header_offset − (header_addr − load_addr).
   • Its length is load_end_addr − load_addr, or up to the end of the file when load_end_addr is 0.
   • The bss runs from the end of the load to bss_end_addr (none if 0).
   • The entry must be inside the loaded range.

   Without bit 16, the kernel is loaded from its ELF program headers.

Output

cCopy
Loading…

• Flag lines print in bit order: 0, 1, 2, 16. Then either:
  • unsupported required flags 0xNNNN: a bootloader must refuse this kernel (it stops there), or
  • optional flags 0xNNNNNNNN ignored.
• Without bit 16, the load line is load: from the kernel's ELF program headers.
• A bad checksum ends the first line with INVALID (magic + flags + checksum = 0xNNNNNNNN), and nothing more is printed.
• Nothing found: no Multiboot header in the first 8192 bytes, or no Multiboot header; found a Multiboot2 header at 0xNNNN instead.
• Load errors (indented, and they stop the report before handoff):
  • error: header truncated (address fields need 32 bytes);
  • error: load_addr 0x… is above header_addr 0x…;
  • error: load would start N bytes before the file;
  • error: load_end_addr 0x… is not above load_addr;
  • error: load range needs N bytes but the file has M after offset 0xNNNN;
  • error: bss_end_addr 0x… is below the loaded end;
  • error: entry 0x… is outside the loaded image.
• image prints image: N bytes, and checksum prints checksum for flags 0x00000003 = 0xE4524FFB.
• Other errors:
  • error: image size must be 1..65536;
  • error: no image;
  • error: bad offset X;
  • error: bad token X (the rest of the line is skipped);
  • error: write past the end of the image;
  • error: bad flags;
  • error: bad line: LINE.

Example

Input:

cCopy
Loading…

Output:

cCopy
Loading…

Requirements

1. Do all header arithmetic in 32-bit unsigned integers. The checksum relies on wrap-around.
2. Scan only aligned offsets, as a real loader does: a magic at an unaligned offset is not a header.

Hidden tests cover unaligned and too-late magics, a Multiboot2-only image, required and optional unknown flags, video mode, a load_end of 0 (load to end of file), and every load error.