Code Wrangling at its Best
By the end of Chapter 33, Toyix could launch child processes, inspect child state from the shell, and request cooperative termination: At this point, Toyix can: The next major subsystem is files. This chapter adds the first tiny filesystem path: After this chapter, the user shell can do: This is not a disk filesystem yet.
Continue Reading “Chapter 34 — First RAMFS and Core File APIs”
By the end of Chapter 32, Toyix could launch child processes, wait for them, and keep exited children around as zombies until the parent collected them. For this chapter, we also extend the shell and syscall ABI just enough to inspect child state from user mode: That gives the shell basic process ownership and job-state
Continue Reading “Chapter 33 — Process Termination and Kill Checks”
In Chapter 32, the user shell gained: That let a user process launch another user process: The flow worked: But the process model was too loose. Any process could wait for any PID. This chapter tightens that up. We will add: After this chapter, a child process belongs to the process that launched it: Then:
Continue Reading “Chapter 32 — Process Ownership, Waiting, and Job State”
In Chapter 30, Toyix gained its first user-mode shell: But the shell could not launch programs yet. The kernel monitor could run programs: but the user shell could not. This chapter adds the first user-facing process-control syscalls: At first, SYS_EXEC still launches programs from the embedded program registry. We are not loading from a filesystem
Continue Reading “Chapter 31 — SYS_EXEC, SYS_WAITPID, and Shell-Launched Programs”
In Chapter 29, we added the first shared userland runtime. This chapter extends that runtime with formatted output and shell-oriented helpers, then uses it to build the first real long-running user-mode program: This first shell will run entirely in ring 3. It will read lines from stdin, parse commands, and execute a few built-in commands.
In Chapter 28, we cleaned up the user-program build system: now automatically builds: But our user programs still duplicate small helper functions: Both demo.c and counter.c contain nearly the same code. This chapter adds the first tiny Toyix userland support library: This is not a real libc yet, but it is the beginning of one.
In Chapter 27, we added a second user program: That proved the program registry can handle more than one embedded ELF. But the Makefile now has duplicated build rules: That will not scale. This chapter cleans up the user-program build system so adding a new user program is mostly: and then adding: The build system
Continue Reading “Chapter 28 — Pattern-Based User Program Build System”
In Chapter 26, we added: That gave us a real background process path. But our only user program, demo, waits for terminal input: That makes it awkward for runbg, because a background process can compete with the monitor for keyboard input. This chapter adds a second embedded user program: counter does not read from stdin.
Continue Reading “Chapter 27 — A Second User Program for Safe Background Execution”
In Chapter 25, the monitor gained an embedded program registry and a foreground run command: That gave us an exec-like path, but only in foreground mode: This chapter adds the next process-management layer: After this chapter, the monitor will support: The kernel still does not have job control, signals, or a filesystem, but it now
Continue Reading “Chapter 26 — Process Table, ps, runbg, and wait PID”
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”
Recent Comments