Category: Informative

Chapter 9 — Cooperative Multitasking and Kernel Threads

Posted By: R. MorganPosted On:
This entry is part 9 of 38 in the series Writing A Linux Style Operating System From Scratch

We now have enough foundation to start multitasking: This chapter adds the first scheduler. Not a preemptive scheduler yet. A cooperative scheduler. That means each kernel thread keeps running until it voluntarily calls: “` cthread_yield(); textkernel thread objectper-thread kernel stackready queuex86 context switch assemblythread_create()thread_yield()thread_exit()round-robin cooperative schedulingtwo-thread test textcreate two kernel threadsswitch between them cooperativelyprove both

Continue Reading “Chapter 9 — Cooperative Multitasking and Kernel Threads” →

Chapter 8 – Moving the Heap onto Virtual Memory

Posted By: R. MorganPosted On:
Chapter 8 – Moving the Heap onto Virtual Memory
This entry is part 8 of 38 in the series Writing A Linux Style Operating System From Scratch

In Chapter 6, the kernel heap still depended on low identity-mapped physical pages. That worked as a bootstrap step, but it tied the heap to the first 16 MiB of RAM. In Chapter 7, we added a real VMM and proved that the kernel can map and unmap pages anywhere the page tables allow. That

Continue Reading “Chapter 8 – Moving the Heap onto Virtual Memory” →

Chapter 7 — A Real Virtual Memory Mapping Layer

Posted By: R. MorganPosted On:
Chapter 7 — A Real Virtual Memory Mapping Layer
This entry is part 7 of 38 in the series Writing A Linux Style Operating System From Scratch

In Chapter 5 we enabled paging, but only with a fixed identity map: In Chapter 6 we built a heap, but it still had an important weakness: because only the first 16 MiB were identity-mapped. Now we fix the architectural problem. This chapter adds a small virtual memory manager, or VMM: This lets the kernel

Continue Reading “Chapter 7 — A Real Virtual Memory Mapping Layer” →

Chapter 6 — Building the First Kernel Heap

Posted By: R. MorganPosted On:
Chapter 6 — Building the First Kernel Heap
This entry is part 6 of 38 in the series Writing A Linux Style Operating System From Scratch

In Chapter 5, we enabled paging with a simple identity map: That gave us a working paged kernel, but not yet a comfortable way to allocate variable-sized objects. The physical memory manager gives us whole pages: But kernel code usually needs smaller objects: So this chapter builds the first kernel heap. We will keep it

Continue Reading “Chapter 6 — Building the First Kernel Heap” →

Chapter 5 — Turning On Paging

Posted By: R. MorganPosted On:
Chapter 5 — Turning On Paging
This entry is part 5 of 38 in the series Writing A Linux Style Operating System From Scratch

In Chapter 4, we built the first memory-management layer: Now we add the next layer: paging. Paging lets the CPU translate a virtual address into a physical address through page tables. In 32-bit x86 paging without PAE, a virtual address is split into a page-directory index, page-table index, and page offset; page directories and page

Continue Reading “Chapter 5 — Turning On Paging” →

Chapter 3 — Hardware Interrupts: PIC, PIT Timer, and Keyboard Input

Posted By: R. MorganPosted On:
Chapter 3 — Hardware Interrupts: PIC, PIT Timer, and Keyboard Input
This entry is part 3 of 38 in the series Writing A Linux Style Operating System From Scratch

In Chapter 2 we taught the CPU how to call our code when something goes wrong: Now we will teach the machine how to call our code when hardware wants attention: This is the first step toward a living kernel. A timer interrupt eventually gives us scheduling. Keyboard input eventually gives us a kernel monitor

Continue Reading “Chapter 3 — Hardware Interrupts: PIC, PIT Timer, and Keyboard Input” →

Writing a Linux-style Operating System From Scratch

Posted By: R. MorganPosted On:
Writing a Linux-style Operating System From Scratch
This entry is part 1 of 38 in the series Writing A Linux Style Operating System From Scratch

Today, we are beginning a new article series: “Writing a Linux-Style Operating System From Scratch.” In this series, we will walk step by step through the process of creating our own operating system from the ground up. Many operating system tutorials stop shortly after the system boots and prints a simple message on the screen.

Continue Reading “Writing a Linux-style Operating System From Scratch” →

The Pirate Software Paradox: What Happens When Influence Outpaces Skill

Posted By: R. MorganPosted On:
The Pirate Software Paradox: What Happens When Influence Outpaces Skill
pirate

There’s a real disconnect between the code that’s visible and the veteran status that’s claimed. This discrepancy isn’t trivial

Continue Reading “The Pirate Software Paradox: What Happens When Influence Outpaces Skill” →

Why GAMBAS BASIC Deserves a Place in Your Development Toolbox

Posted By: R. MorganPosted On:

One of GAMBAS’s biggest advantages is its fully integrated development environment (IDE), which resembles VB6 and offers an easy-to-use graphical interface. This makes creating forms, handling events, and connecting to databases significantly faster than using more complex frameworks.

Continue Reading “Why GAMBAS BASIC Deserves a Place in Your Development Toolbox” →

Developing an Open Hardware Device Programmer

Posted By: R. MorganPosted On:
This entry is part 1 of 1 in the series Open Universal Device Programmer

Introduction As an electronics enthusiast with over 50 years of experience, I’ve had the privilege of witnessing the dramatic evolution of computing systems. From the early days of 4 and 8-bit machines with minimal RAM to today’s powerful 64-bit computers with terabytes of storage, the progress has been nothing short of extraordinary. The same transformative

Continue Reading “Developing an Open Hardware Device Programmer” →