OSDev.org

Code: Select all

 
 
; boot.asm — Stage 1 BIOS bootloader (must fit in 512 bytes)
; Loads a second-stage bootloader (sector 2) to memory at 0x0000:0x8000 and jumps to it
; This code is released to the public domain. 
; "Share and enjoy....." :)
BITS 16 ; We are in 16-bit real mode
ORG 0x7C00 ; BIOS loads the boot sector here (segment:offset = 0x0000:0x7C00)
start:
 ;-------------------------------------------
 ; Print "STAGE 1 OK" using BIOS teletype (INT 10h, AH=0x0E)
 ; This helps confirm that Stage 1 actually runs.
 ;-------------------------------------------
 mov si, msg ; Load address of message string into SI (source index)
.print:
 lodsb ; Load byte at [SI] into AL, and increment SI
 or al, al ; Set flags based on AL — if AL == 0 (null terminator), ZF is set
 jz .done ; Jump if ZF is set (end of string)
 mov ah, 0x0E ; BIOS function: teletype output
 mov bh, 0x00 ; Page number (always 0 in text mode)
 mov bl, 0x07 ; Text attribute: light gray on black (standard BIOS default)
 int 0x10 ; BIOS video interrupt
 jmp .print ; Loop to print next character
.done:
 ;-------------------------------------------
 ; Set up segment registers for clean execution
 ; Why? BIOS leaves segments in unknown state
 ; AX=0 means segment base = 0x0000
 ; SP is set to 0x7C00 so we avoid stack overflows
 ;-------------------------------------------
 cli ; Disable interrupts (for safety during segment setup)
 xor ax, ax ; AX = 0
 mov ds, ax ; Set DS (Data Segment) to 0x0000
 mov es, ax ; Set ES (Extra Segment) to 0x0000
 mov ss, ax ; Set SS (Stack Segment) to 0x0000
 mov sp, 0x7C00 ; Set stack pointer to 0x7C00 (just below the bootloader code)
 sti ; Re-enable interrupts
 ;-------------------------------------------
 ; Load Stage 2 loader (sector 2) from floppy disk into memory
 ; BIOS INT 13h uses CHS (Cylinder, Head, Sector) addressing
 ; We use LBA = 2 = CH=0, H=0, S=2
 ; Loads 1 sector (512 bytes) into 0x0000:0x8000
 ;-------------------------------------------
 mov ah, 0x02 ; BIOS INT 13h: function 2 = read sectors
 mov al, 1 ; Read 1 sector
 mov ch, 0 ; Cylinder number = 0
 mov cl, 2 ; Sector number = 2 (starts at 1)
 mov dh, 0 ; Head = 0
 mov dl, 0x00 ; Drive = 0x00 = first floppy drive (what BIOS booted from)
 mov bx, 0x8000 ; Offset where data will be loaded
 mov es, ax ; ES = 0x0000 (same as before), so ES:BX = 0x0000:0x8000
 int 0x13 ; BIOS Disk I/O interrupt
 jc fail ; If carry flag is set, read failed → jump to fail
 ;-------------------------------------------
 ; Jump to Stage 2 code we just loaded at 0x0000:0x8000
 ; This transfers control to Stage 2
 ;-------------------------------------------
 jmp 0x0000:0x8000 ; Far jump — loads CS and IP together
fail:
 ;-------------------------------------------
 ; If disk read failed, hang the system
 ;-------------------------------------------
 cli ; Disable interrupts
 hlt ; Halt CPU
 jmp $ ; Infinite loop: jump to current address
;-------------------------------------------
; Null-terminated message string (for printing)
;-------------------------------------------
msg: db "STAGE 1 OK", 0
;-------------------------------------------
; Padding to 510 bytes, then BIOS signature
; BIOS requires 0x55 0xAA at bytes 511-512
;-------------------------------------------
times 510-($-$$) db 0 ; Pad the rest of the sector with zeroes
dw 0xAA55 ; Boot signature — must be exactly here

Code: Select all

 
 
; ============================================================================
; stage2.asm — Stage 2 BIOS Bootloader (FAT12)
; ============================================================================
; Description:
; - This runs at 0x0000:0x8000, loaded by Stage 1 (boot.asm)
; - It prints a short message to show it is working
; - Then loads `KERNEL.BIN` from the FAT12 root directory (assumes contiguous)
; - Finally, jumps to the loaded 32-bit kernel (at 0x0000:0x1000)
;
; Limitations:
; - Only loads root directory files
; - Assumes no fragmentation (clusters are contiguous)
; - Hardcoded FAT12 geometry for 1.44MB floppy
; 
; This code is released to the public domain. 
; "Share and enjoy....." :)
; 
; ============================================================================
BITS 16
ORG 0x8000 ; Stage 1 loads us here
start:
 ; ---------------------------------------------
 ; Print "STAGE2 OK" to screen using BIOS INT 10h
 ; ---------------------------------------------
 mov si, msg ; Load message address
.print:
 lodsb ; Load next byte into AL from [SI], advance SI
 or al, al ; Check for null terminator
 jz .done ; If zero, message done
 mov ah, 0x0E ; BIOS teletype print function
 mov bh, 0x00 ; Page number
 mov bl, 0x02 ; Attribute: green on black
 int 0x10 ; BIOS video interrupt
 jmp .print
.done:
 ; ---------------------------------------------
 ; Set up DS/ES to 0x0000 for memory access
 ; ---------------------------------------------
 xor ax, ax
 mov ds, ax
 mov es, ax
 ; ---------------------------------------------
 ; Load KERNEL.BIN from FAT12 into 0x0000:0x1000
 ; ---------------------------------------------
 mov si, kernel_filename ; File name to find
 mov bx, 0x1000 ; Destination offset for kernel load
 call load_file
 ; ---------------------------------------------
 ; Transfer control to kernel at 0x1000:0x0000
 ; ---------------------------------------------
 jmp 0x1000:0x0000 ; Segment:Offset = 0x10000
; ============================================================================
; load_file — Find and load a file from the FAT12 root directory
; ============================================================================
; Inputs:
; SI = pointer to 11-char filename (e.g., "KERNEL BIN")
; BX = offset to load file into (ES assumed 0x0000)
; ============================================================================
load_file:
 ; ----------------------------
 ; Load Root Directory (14 sectors starting at LBA 19)
 ; ----------------------------
 mov ax, 0x0200 ; Start with sector 0x0200 (arbitrary sector #)
 mov cx, 14 ; Root directory spans 14 sectors (224 entries)
find_entry:
 push cx ; Save loop counter
 ; Setup BIOS CHS parameters to read root sector
 mov dx, ax ; Save current sector index in DX
 mov ah, 0x02 ; BIOS read sector
 mov al, 1 ; Read 1 sector
 mov ch, dl ; Cylinder 0 (simple map)
 mov cl, 1 ; Sector 1
 mov dh, 0 ; Head 0
 mov dl, 0x00 ; Drive 0 = floppy
 mov bx, 0x9000 ; Temp buffer to store root entries
 mov es, ax ; ES = 0
 int 0x13
 jc fail ; Abort on failure
 ; Scan 16 directory entries per sector
 mov di, 0x9000 ; Start of loaded sector
 mov cx, 16 ; 16 entries per 512-byte sector
scan_sector:
 push cx
 mov cx, 11 ; Filename is 11 bytes (8+3)
 mov si, kernel_filename
 repe cmpsb ; Compare filename to directory entry
 je found ; If match, jump to found
 add di, 21 ; Move to next directory entry (skip name + attrs + ...)
 pop cx
 loop scan_sector ; Loop over entries
 inc ax ; Next sector
 pop cx
 loop find_entry ; Continue scanning root directory
 jmp fail ; If nothing found, fail
found:
 ; ---------------------------------------------
 ; Found file. Get first cluster and load sectors.
 ; ---------------------------------------------
 mov si, di ; DI points to matched entry
 add si, 26 ; Offset 26 = start cluster
 mov ax, [si] ; Load start cluster number
 ; ------------------------------
 ; Load 8 sectors from cluster (assumes contiguous)
 ; ------------------------------
 mov cx, 8 ; Load up to 8 sectors (max 4096 bytes)
load_clusters:
 push ax ; Save cluster number
 mov dx, ax
 add dx, 31 ; Convert cluster → LBA (cluster 2 = sector 33)
 mov ah, 0x02 ; BIOS read sector
 mov al, 1 ; Read 1 sector
 mov ch, dl ; Cylinder (simple map)
 mov cl, 1
 mov dh, 0
 mov dl, 0x00 ; Floppy
 mov es, bx ; Load into ES:BX (BX = segment offset)
 mov bx, 0 ; Offset within segment (start of buffer)
 int 0x13
 jc fail ; Abort on read failure
 add bx, 512 ; Advance destination pointer by one sector
 pop ax
 inc ax ; Next cluster (naive assumption of contiguity)
 loop load_clusters
 ret
fail:
 cli
 hlt
 jmp $
; ============================================================================
; Data Section
; ============================================================================
msg: db "STAGE2 OK", 0
; Must be exactly 11 characters (8.3 filename)
; Filename = "KERNEL.BIN" → "KERNEL BIN"
kernel_filename: db "KERNEL BIN"
; Pad to 510 bytes, add boot signature
times 510-($-$$) db 0
dw 0xAA55 ; BIOS magic number (must be last 2 bytes)

Code: Select all

 
 
// ============================================================================
// kernel.c — Minimal 32-bit Kernel (Protected Mode)
// ============================================================================
// - Executed from 0x00100000 (1MB), loaded by Stage 2
// - Writes a string directly to VGA text mode memory (0xB8000)
// - Enters infinite loop using HLT to idle the CPU
// - No external dependencies or libc required
//
// This code is released to the public domain.
// "Share and enjoy....." :)
// ============================================================================
#include <stdint.h> // For fixed-width integer types like uint16_t
// --------------------------------------------------------------------------
// print() — Write a null-terminated string to VGA text screen
// --------------------------------------------------------------------------
// VGA text mode is mapped to memory address 0xB8000
// Each character cell is 2 bytes: [ASCII character][attribute byte]
// - Attribute byte 0x07 = light gray text on black background
// --------------------------------------------------------------------------
void print(const char *s) {
 volatile uint16_t *vga = (uint16_t*)0xB8000; // VGA text buffer base
 uint16_t attr = 0x0700; // Attribute byte in high byte (0x07 = light gray on black)
 for (int i = 0; s[i] != 0; i++) {
 vga[i] = attr | s[i]; // Lower byte = character, upper byte = color
 // Example: 'A' (0x41) becomes 0x0741 in VGA memory
 }
}
// --------------------------------------------------------------------------
// kernel_main() — Kernel entry point called from stage2 loader
// --------------------------------------------------------------------------
// In protected mode with flat segments already set up by stage2
// Writes message and halts forever
// --------------------------------------------------------------------------
__attribute__((section(".text"))) __attribute__((used)) void kernel_main(void) {
 print("Hello from the public domain!"); // Print greeting to top of screen
 // Infinite loop — halt CPU until next interrupt to save power
 while (1) {
 __asm__ __volatile__("hlt"); // Inline assembly: HLT instruction
 }
}

Code: Select all

 mov es, ax ; ES = 0x0000 (same as before), so ES:BX = 0x0000:0x8000

Code: Select all

 mov ah, 0x02 ; BIOS INT 13h: function 2 = read sectors
 mov al, 1 ; Read 1 sector