Writing a x86 Bootloader in Assembly with NASM

This tutorial demonstrates how to implement disk reading functionality in a bootloader using BIOS interrupt 13h, covering the conversion from Logical Block Addressing (LBA) to Cylinder-Head-Sector (CHS) addressing required by BIOS functions, error handling with retry mechanisms, and practical debugging techniques using Bochs emulator. The implementation shows how to read additional operating system modules from floppy disk sectors beyond the initial 512-byte boot sector, enabling the creation of multi-module operating systems.

Bootloaders interact with BIOS using interrupts (0x10 for video, 0x13 for disk). Since everything runs at ring zero, interrupts can be invoked directly. Interrupt 0x13 with AH=0x02 reads sectors using CHS addressing (cylinders, heads, sectors), limiting drives to approximately 8GB due to 255-head limitation. Extended read sector interrupt 0x42 uses a disk address packet for LBA addressing, supporting much larger drives by specifying number of sectors, buffer location, and starting sector in a data structure.

To read disk sectors beyond the boot sector in x86 real mode, use BIOS interrupt 13H with CHS addressing (cylinder-head-sector), where AH=2 specifies the read operation, AL holds the number of sectors to read, CH and CL hold the cylinder and sector numbers respectively, DH holds the head number, DL holds the drive number, and ES:BX points to the memory destination; error checking involves verifying the carry flag and ensuring the correct number of sectors were actually read.

This video demonstrates how to modify a bootloader to load a kernel into memory using BIOS interrupt 0x13 for disk reading. The process involves creating a makefile to automate the build process, compiling the bootloader with nasm and linking it at 0x7c00, then compiling the kernel and linking it at 0x7e00 (512 bytes after the bootloader). The kernel loading function sets up the stack, calls BIOS interrupt 0x13 with parameters for reading sectors, and handles errors by checking the carry flag. The kernel is loaded into memory at 0x9000, and the bootloader transfers control to it.

This segment covers reading the kernel from disk using BIOS interrupt 13h (INT 13h). The interrupt requires setting AH=0x02 (read function), AL=number of sectors, CH=cylinder, CL=sector, DH=head, DL=drive number (0x80 or 0x81), and ES:BX=destination buffer. The kernel is read from the beginning of the disk (cylinder 0, sector 0, head 0) to a memory address calculated using segment:offset addressing. The bootloader checks the carry flag for errors and prints status messages. The kernel is loaded at address 0x2000 (segment 0x200, offset 0x0000). The bootloader then jumps to this address to execute the kernel. Real mode memory addressing uses (segment << 4) + offset to calculate effective addresses.

This lecture demonstrates how to bootstrap a C kernel by compiling C code into an object file, linking it with the linker to produce a raw binary executable, and then loading this binary from a boot sector written in assembly. The process involves using GCC with freestanding mode and M32 options to compile C code into 32-bit object files, then using the linker with appropriate memory origin settings to create a flat binary. The boot sector code loads this kernel binary from disk into memory at a specific address (0x7e00) and transfers control to it, allowing the C code to execute directly after the boot process completes.

Transitioning from bootloader to C code requires assembly initialization: clear AX, set SS and SP registers, initialize BP, enable interrupts with STI, then call C's _start function. The C entry point uses cdecl calling convention with __cdecl attribute. Standard type definitions (stdint.h) provide fixed-size types (int8_t, uint16_t, etc.) for cross-platform consistency. The complete system integrates: bootloader jumps to assembly initialization, which transfers control to C's main function, which calls puts to print "Hello World" using the standard I/O abstraction built on BIOS video interrupts.

Operating systems start in assembly language because they need to perform low-level hardware initialization before C code can run. The linker script specifies the entry point (entry.s) and memory layout, telling the linker where the entry point symbol is located. In entry.s, the stack is initialized by loading the address of stack0 (defined in start.c) into the stack pointer register. Each CPU needs its own stack space (4096 bytes per CPU in xv6), calculated as stack0 address + (hartid + 1) * 4096. The hartid is read from the Mhartid CSR, which identifies which CPU core is executing. This stack setup enables C function calls and variable storage, transitioning from assembly to C code.

This video demonstrates how to transition from assembly to C for bootloader development by setting up a two-stage bootloader architecture where Stage 1 loads Stage 2, which then switches from 16-bit real mode to 64-bit protected mode using the cdecl calling convention to interface between C and assembly code, with detailed coverage of memory models, linking processes, and system call integration.

The bootloader transitions from assembly to C code by properly initializing the stack and calling C functions. Stack pointer (ESP) and base pointer (EBP) are configured to create a valid execution context. Function calls push return addresses onto the stack, enabling nested execution. GCC-generated prologues set up stack frames for local variables. The bootloader then loads disk sectors containing the kernel, demonstrating how low-level boot code interfaces with higher-level C implementations to complete the boot process.

In 80286 protected mode, the Interrupt Descriptor Table (IDT) stores interrupt and trap gate descriptors that define how the CPU handles exceptions and interrupts; interrupt gates disable further interrupts by clearing the interrupt flag upon entry, while trap gates allow nested interrupts, and the first 32 interrupt numbers are reserved for CPU exceptions, with exception handling typically implemented through a common handler that displays the exception number on screen to diagnose protection violations like accessing memory beyond segment limits, which trigger General Protection Exception (Exception 13).

The IDT consists of up to 256 entries, each 16 bytes long, with the first 32 reserved for hardware exceptions. Each entry contains a far pointer with a segment selector and offset. For code execution, the segment base is treated as zero, using only the GDT/LDT access control bits for permission checks. Key exceptions include Divide Error (0), Debug Exception (1), Breakpoint (3), Overflow (4), UD (6), General Protection Fault (13 - most common), and Page Fault. These exceptions trigger specific OS responses, with GPF being particularly prevalent in assembly programming documentation.

This section explains how the Interrupt Descriptor Table (IDT) is configured to handle all types of interrupts in an operating system. The IDT contains 32 entries, each pointing to a specific ISR function that handles a particular interrupt or exception. The set IDT gate function uses the lidt assembly instruction to load the IDT into the CPU. When the CPU encounters an interrupt, it looks up the corresponding ISR in the IDT and executes that function. This mechanism allows the operating system to handle various interrupt types including hardware interrupts (keyboard, mouse, clock ticks) and software exceptions (division by zero, breakpoints).

The Interrupt Descriptor Table (IDT) is a critical kernel data structure that maps interrupt numbers to their corresponding handler addresses, enabling the CPU to locate and execute the appropriate interrupt service routine when an interrupt occurs. In protected mode, the kernel must create its own IDT since the BIOS-provided vector table is unavailable. Each IDT entry is 8 bytes (64 bits) and contains a segment selector (16 bits) and an offset (32 bits), with the handler address calculated as the segment base address plus the offset. The IDT must be initialized with the first entry pointing to the divide-by-zero error handler, and the table must be loaded into memory using the lidt instruction before the kernel can handle hardware interrupts.

UEFI (Unified Extensible Firmware Interface) is an industry-standard firmware interface developed by Intel, AMD, Microsoft, and computer manufacturers in 2007. Unlike BIOS, UEFI supports hard drives exceeding 2.2 TB (theoretically up to 9.4 ZB) by using GPT partitioning instead of MBR. UEFI runs in 32-bit or 64-bit modes with larger address spaces, enabling faster boot times. It features a graphical interface with mouse support, Secure Boot for malware protection, and network capabilities for remote debugging. UEFI is essentially a small operating system stored on flash memory, capable of loading from hard drives or networks. Most modern computers use UEFI, with Windows Vista SP1 and Windows 7 adding UEFI support.

UEFI (Unified Extensible Firmware Interface) represents a fundamental shift from traditional BIOS firmware, functioning as a small operating system that enables modern boot capabilities such as GPT partitioning (supporting drives larger than 2TB), secure boot with anti-malware before OS load, and native 32/64-bit CPU operation, unlike BIOS which operated in 16-bit mode with limited memory access; systems can transition from CSM-enabled UEFI (which emulates legacy BIOS behavior) to native UEFI mode using Microsoft's MBR2GPT conversion tool, which restructures disk partitions to enable full UEFI functionality without data loss.

BIOS (Basic Input Output System) is legacy firmware that initializes hardware and loads the Master Boot Record (MBR) from the first sector of a hard drive, which then finds an active partition and transfers control to its boot sector containing the boot manager; UEFI (Unified Extensible Firmware Interface) is a modern replacement that can boot from both MBR and GPT disks, supports network booting, and provides a more extensible API for developers, with boot variables specifying device paths, partition identifiers, and file paths to execute.

To format new notebooks with UEFI-protected BIOS, users must disable UEFI and switch to Legacy boot mode by accessing the setup (typically by pressing F2), navigating to the boot options, changing the boot mode from UEFI to Legacy, saving and exiting the setup, then using a bootable installation media (CD/DVD/USB) to format and install the operating system; after installation, users should switch back to UEFI boot mode for better performance and security with Windows 8 and above.

UEFI (Unified Extensible Firmware Interface) is a modern BIOS standard introduced around 2011 that addresses limitations of traditional BIOS. Key features include a graphical interface supporting mouse input, proper handling of hard drives larger than 2 terabytes, multi-language support (including Russian), and accelerated boot times. UEFI BIOS offers power profiles (quiet mode for minimum energy consumption, maximum performance mode for full resource utilization), boot device selection, language options, and an Advanced Mode for detailed parameter configuration. Exit options include saving changes, discarding changes, loading defaults, and accessing boot menus.