Code Wrangling at its Best
In Chapter 23, we crossed another major boundary: But the user program still started like this: That is not how we want user programs to look long-term. This chapter adds a real initial user stack with: Then crt0.S will pass those arguments to: This moves us closer to a normal process startup model. ELF process
Continue Reading “Chapter 24 — User argc / argv and a Real Initial Stack”
In Chapter 22, the kernel gained a first ELF32 loader. That was a big step, but our test ELF was still built by hand inside process.c: This chapter removes that artificial piece. We will add a tiny userland build pipeline: GNU objcopy is specifically designed to copy and transform object files between formats; we will
Continue Reading “Chapter 23 — Building a Real User C Program and Embedding Its ELF”
In Chapter 21, we completed the process lifecycle: Now we can replace the temporary TOYEXE format with the first real executable-loader milestone: ELF32. ELF is the Executable and Linkable Format used by many Unix-like systems. The ELF specification defines the file header, program header table, and how loadable segments describe a process image; the generic
Continue Reading “Chapter 22 — First ELF32 Loader Milestone”
In Chapter 20, we added the TOYEXE loader: But there is still a lifecycle problem. The process can exit, but we are not yet reclaiming everything it owns. Right now this leaks: This chapter closes that loop. After this chapter, the process lifecycle becomes: The milestone output will look like: 1. What this chapter adds
Continue Reading “Chapter 21 — Process Teardown and Address-Space Cleanup”
In Chapter 19, we gave each process its own address space: That was a major architectural milestone. But our user program is still not really “loaded.” We are still building a TOYEXE image inside process.c and handing it to the loader. This chapter adds a small executable format before jumping to ELF. We will call
Continue Reading “Chapter 20 — A Tiny Executable Format and User Program Loader”
In Chapter 18, user programs gained a much more realistic syscall interface: But all user processes still shared the same page directory. That means every process saw the same user mappings: This chapter gives each process its own address space. The new model becomes: When the scheduler switches between processes, it will also switch CR3.
Continue Reading “Chapter 19 — Per-Process Address Spaces and CR3 Switching”
In Chapter 17, we added the first minimal process object: That was a big step, but the syscall interface was still a little too artificial. This chapter makes user programs feel more like real programs by adding a tiny file-descriptor-style interface: We will update SYS_WRITE to use a file descriptor, add SYS_READ, and run a
Continue Reading “Chapter 18 — File-Descriptor Syscalls and a Tiny User-Mode Console Program”
In Chapter 16, we proved the biggest privilege milestone so far: But the user-mode test was still mostly a raw thread experiment. The kernel did not yet have a real object representing a user program. This chapter adds the first process abstraction. A process will own: We will also add safer user-memory access helpers: and
Continue Reading “Chapter 17 — Minimal Processes, User Memory Copying, and More Robust Syscalls”
We now have an interactive, preemptive kernel with memory management, blocking, synchronization, keyboard input, terminal editing, and a monitor. So far, however, everything runs in ring 0. That means every thread has full kernel privilege. There is no separation between kernel code and user code yet. This chapter adds the first user-mode milestone: Intel’s IA-32
Continue Reading “Chapter 16 — Entering User Mode and Returning Through Syscalls”
In Chapter 14, we added the first interactive kernel monitor: That worked, but the monitor command parser was still a chain of if statements: That is fine for five commands, but it does not scale. This chapter cleans that up by adding: The keyboard improvement matters because our monitor is interactive now. A monitor where
Continue Reading “Chapter 15 — Command Tables, Argument Parsing, and Shift-Aware Keyboard Input”
Recent Comments