Write Your Own Operating System From Scratch - Step by Step

Enable the Windows Subsystem for Linux on Windows 10 or 11 to set up the OS project environment and install Ubuntu 18.04. Run PowerShell as administrator and follow installation steps.

Install gcc and nasm on ubuntu, set up bochs for machine testing, create a 10 mb boot image with bximage, and boot from disk using Rufus and Visual Studio Code.

Learn to use course resources by downloading and unzipping the package, accessing the source code and boot image, and running the Mac build script with gcc.

Learn to build and test projects on Ubuntu, using a prepared boot image, build script, and bochs configuration, then create a bootable USB with dd and run the virtual machine.

Build and test the macOS project by preparing boot.img, running ./build.sh, launching bochs, and writing boot.img to a USB drive to boot a test computer with CSM enabled.

This lecture tests the disk extension service in the boot file to load the kernel from disk, checks for support, and prints 'disk extension is supported' using bochs.

Relocate the kernel from 10000 to 200000, load it into memory, and jump to execute, while handling interrupts and exceptions.

Guides building a kernel by loading gdt and idt, using a far return, setting up the code segment, jumping to kernel entry, printing K, and looping.

Learn how to transition from ring0 to ring3 by creating code and data segment descriptors with DPL 3, then perform an iret-based switch using a prepared stack.

Configure a task state segment (tss) with the ring0 stack pointer (rsp0), set up its descriptor in the gdt, load the tss selector, and enable interrupts from ring3.

Configure a recurring 10 ms timer interrupt, increment the printed character each time, and acknowledge the interrupt by writing 20 to the master pic command register.

Learn to handle spurious interrupts in a minimal system by implementing an IRQ7 spurious handler, configuring the IDT entry, reading the ISR, and returning without end of interrupt when needed.

Implement an assert macro in the kernel to halt on failure and report file and line. Avoid asserts in the print module to prevent recursion with printk.

Builds a memory manager and retrieves the memory map using BIOS services, parsing E820 structures to identify free regions above 1 mb and total memory of 1023 mb.

Configure paging to remap the kernel to a higher memory region. Explain 1g, 2m, and 4k page translations using hierarchical page tables and cr3 in 64-bit mode.

allocate and manage free physical memory by dividing it into 2mb pages stored as a linked list, mapping virtual to physical addresses in kernel space, limited to first 1gb.

Map the kernel to the same address space using 2m pages and implement paging with pml4, pdpt, and page directory tables, then switch to the new kernel memory via cr3.

Implement the setup uvm function to create a 400000-based user space, map one page for the program, allocate, zero, and copy data, and handle cleanup with free vm.

Create and manage processes with a process control block, separate user spaces, shared kernel space, and per-process stacks and trap frames for ring3 to ring0 transitions.

Learn how system calls let user programs print messages via software interrupt vector 80, switching to kernel mode to execute write screen and linking kernel and user parts.

Implement a process scheduler that switches between multiple processes using a ready list and timer interrupts, and perform context switches with an assembly swap routine.

Explore how a simple operating system handles process exit and cleanup using exit and wait, including pid 1 init, the killed list, wakeups, and freeing the kernel stack and vm.

Terminate a process by detecting user-mode exceptions via trap.c, call exit and later wait to free the process, and halt the system for kernel-mode exceptions, with test programs.

Implement a user-mode console to read keyboard input, parse commands, and execute a get total memory command that retrieves the kernel's total memory and prints it in mb.

Create and test a 100mb fat16 os image using free dos and bochs, mount and inspect the image with hexdump, and adjust partition data for boot testing.

Learn how the new loader loads a fat16 image, moves the kernel and user files into memory, and uses a c module to parse the file system.

Initialize the kernel and idle process, enable interrupts, and run the system in the idle loop while preparing the first user process.

Learn how the kernel manages files with a file descriptor table and FCB cache. Open, read, get file size, and close operations link process entries to file data.

Fork creates a new process by copying the current process, assigns a new pid, copies the user space and trap frame, and updates shared file descriptors and wait semantics.

Implement the execute SQL function to fork a process, load a program into user space, and launch it, with kernel and library steps illustrated through a test bin file.

Implement an ls command by adding a read root directory function, exposing it via a syscall, and updating the library and main to display root directory data.