Build a tiny kernel with a superpower

Build a binary with no standard library and a linker script that puts your entry point where the bootloader expects it. Write a few lines of assembly to set up a stack and call your main function.

Then print. On x86-64, write bytes to the COM1 serial port; on RISC-V's QEMU virt machine, write to the 16550 UART. Pass -serial stdio or -nographic so the output lands in your terminal. You'll use that print function for the rest of the project, so make it formatted.

Install a handler table. On x86-64 that's the IDT, with small assembly stubs that save registers into a trap frame before calling your code. On RISC-V it's one entry point in stvec, and scause tells you what happened.

Handle a breakpoint first, since it's harmless and returns. Then page faults, printing the address from CR2 or stval. On x86-64, give the double-fault handler its own stack through the TSS; otherwise a kernel stack overflow faults again inside the handler and you're back to silent resets.

Enable hardware interrupts. On x86-64, remap the legacy PIC so its vectors don't collide with CPU exceptions, or set up the APIC. On RISC-V, ask OpenSBI to arm the timer and use the PLIC for the UART. Count timer ticks, and echo keyboard or serial input.

Two things will bite here. Forget to acknowledge an interrupt and it fires once, then never again. And if a handler takes a lock the interrupted code already holds, you deadlock; disable interrupts while holding any lock a handler also takes.

Parse the bootloader's memory map and build a frame allocator that hands out free 4 KiB physical pages. A bitmap or a free list is fine. Then write map(virtual, physical, flags) for four-level x86-64 tables or RISC-V's Sv39.

Switch to your own tables carefully: the code doing the switch, its stack and the serial port all have to be mapped in the new tables, or the next instruction fetch faults. After changing a mapping, flush it with invlpg or sfence.vma. Stale TLB entries cause bugs that look random.

Map a region for the heap and start with a bump allocator. It's a few lines and can't free anything, which you'll notice soon. Replace it with a free-list allocator that splits and merges blocks, then try fixed size classes for small objects.

Hook it into your language so ordinary collections work: GlobalAlloc in Rust, malloc and free in C. Run a stress test that allocates in a random pattern and watch fragmentation happen. Chapter 05 explains what you're seeing.

Give each thread its own kernel stack and a saved-register area. A context switch is a short assembly routine: save the callee-saved registers and stack pointer of one thread, load another's, return. Seeing it work the first time is one of the best moments in the project.

Then make it preemptive. On each timer tick, the handler asks the scheduler for the next runnable thread and switches to it. Start with round robin. Add sleeping and a way for a thread to block waiting on an event.

Give each process its own page table, with the kernel mapped into all of them but marked supervisor-only. Load a small ELF program into the user half, and drop to user mode with sysret or sret.

Programs come back in through the syscall instruction on x86-64 or ecall on RISC-V. Implement write, exit and yield, and check every pointer a program passes you: it must be inside that process's user memory. A kernel that trusts user pointers is the textbook privilege escalation.

Choose one, and let it reshape the kernel:

• A unikernel. Link a single application, such as a key-value server over the serial port or virtio-net, straight into the kernel. One address space, no user/kernel switch, no scheduler to speak of. Measure time from power-on to first response, and write down exactly what isolation you gave up.
• A real-time kernel. Tasks declare a period, a worst-case execution time and a deadline. Schedule with earliest deadline first or rate-monotonic priorities, refuse tasks that would push utilisation past what the algorithm can guarantee, and log every miss and its jitter. Add priority inheritance so a low-priority task holding a lock can't stall a high-priority one.
• A microkernel. Move the serial driver and a tiny filesystem into user processes. The kernel keeps only address spaces, threads and synchronous message-passing IPC: send, receive and reply on endpoints. Measure an IPC round trip; making it fast is the core problem Liedtke's L4 work attacked.

Whichever you pick, write down the numbers. A kernel that can say what it's good at, and prove it, is worth far more than one that runs a copy of ls.