Code Wrangling at its Best
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”
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”
Before we add paging, a heap, processes, filesystems, or user programs, the kernel must answer a basic question: Which physical 4 KiB pages of RAM are safe for me to use? Right now, our kernel can boot, print text, catch CPU exceptions, and receive timer/keyboard interrupts. But it still cannot safely allocate memory. This chapter
Continue Reading “Chapter 4 — Reading the Memory Map and Building a Physical Page Allocator”
Code pages were once the backbone of character encoding in computers, providing a way to map binary values to text in different languages. However, they had significant limitations, particularly when dealing with multiple languages at once. This article explores the history of code pages, how they were used, and why they have been largely replaced by the modern Unicode standard, which offers a universal character set for all languages.
Continue Reading “Introduction to Code Pages: Legacy Character Encoding Systems”
In software development, trust is not just a matter of functionality but a critical aspect of security. This article delves into the intricacies of software security, particularly in the context of Large Language Models (LLMs), emphasizing the need to trust not only the final product but also the data, models, training methods, and the checks and balances implemented within these systems.
Continue Reading “Trusting Software Security: A Comprehensive Approach”
Python has become a very popular language for software development. Over the decades since it was first introduced, the language has slowly grown and matured while keeping its ease of use and shallow learning curve. This has made it the go-to language for much of the AI and ML communities and many web applications have
Recent Comments