Osdev Notes

The kernel build process involves setting up building scripts, selecting compilers, and choosing a bootloader. The process is broken down into several key stages:

1. High-level Overview: Understanding the purpose of each step in the build pipeline.
2. Boot Protocols & Bootloaders: Configuring the kernel to boot using protocols like Multiboot2 or Limine.
3. Build Scripts: Using Makefiles to automate the compilation and linking process.
4. Linker Scripts: Writing scripts to define how the kernel's code and data are laid out in memory.
5. ISO Generation: Packaging the compiled kernel into a bootable ISO image for testing on emulators or real hardware.

This section of the notes covers the transition between supervisor mode (kernel) and user mode, specifically targeting the x86_64 architecture. It provides guidance on the lifecycle of a process, how to move between privilege levels, and how to manage resources once in userspace.

Key topics covered include:

• Switching modes between user and supervisor.
• Interrupt handling while in User Mode.
• Implementing and using System Calls.
• Defining and implementing a System Call ABI (Application Binary Interface).
• Resource management within the userspace environment.

The Video Output section provides guidance on implementing basic graphical capabilities in a custom operating system kernel. It focuses on two primary tasks:

1. Framebuffer Management: Learning how to access a linear framebuffer and perform basic pixel plotting.
2. Text Rendering: Loading a font into the kernel and rendering text directly onto the framebuffer.

Refer to the specific chapters for implementation details on framebuffer access and font rendering.

The Architecture section of the Osdev Notes provides a structured learning path for low-level system development, covering kernel initialization, memory management, interrupt handling, and hardware drivers.

Key topics include:

• Kernel Basics: Overview of architecture topics, 'Hello World' kernel implementation, and moving the kernel to the Higher Half of memory.
• Memory & CPU Management: Configuring the Global Descriptor Table (GDT) and managing memory segments.
• Interrupts & Hardware Control: Handling CPU exceptions and external interrupts via the Advanced Programmable Interrupt Controller (APIC) and IOAPIC, parsing ACPI tables, and configuring system timers.
• Device Drivers: A complete implementation guide for a PS/2 Keyboard driver, covering hardware overview, interrupt handling, and scancode-to-character translation.

Connect with other developers in these communities:

• Forums/Reddit: OSDev Forum and r/osdev on Reddit.
• Discord: OSDev Discord and Friendly Operating System Devs.

The IPC section provides methods for allowing two processes to safely communicate with each other. The available implementations include:

• Shared Memory: The simplest method, achieved by mapping the same physical memory into the address spaces of both processes.
• Message Passing: A method that moves discrete packets of information between two processes.

The Virtual File System (VFS) module provides educational content on implementing a filesystem abstraction layer in an operating system. It covers theoretical foundations, internal component architecture, and practical implementations like a Tar-based filesystem for initramdisks.

Key learning paths include:

• High-level theory: Understanding why a VFS is necessary for OS design.
• Internal mechanics: Detailed analysis of VFS components and implementation patterns.
• Tar FS implementation: A practical example of a read-only, in-memory filesystem used for loading initial system files (initramdisk) from a tar archive provided by the bootloader.