This post gives an overview of the recent updates to the Writing an OS in Rust blog and the corresponding libraries and tools. I focused my time this month on finishing the long-planned post about Async/Await. In addition to that, there were a few updates to the crates behind the scenes, including s...

In this post, we explore cooperative multitasking and the async/await feature of Rust. We take a detailed look at how async/await works in Rust, including the design of the Future trait, the state machine transformation, and pinning. We then add basic support for async/await to our kernel by creatin...

This post gives an overview of the recent updates to the Writing an OS in Rust blog and the corresponding libraries and tools. blog_os The repository of the Writing an OS in Rust blog received the following updates: Mention potential bump allocator extensions Don’t panic on overflow in allocator; re...

This post gives an overview of the recent updates to the Writing an OS in Rust blog and the corresponding libraries and tools. blog_os The repository of the Writing an OS in Rust blog received the following updates: Move #[global_allocator] into allocator module Update many_boxes test to scale with ...

This post explains how to implement heap allocators from scratch. It presents and discusses different allocator designs, including bump allocation, linked list allocation, and fixed-size block allocation. For each of the three designs, we will create a basic implementation that can be used for our k...

Happy New Year! This post gives an overview of the recent updates to the Writing an OS in Rust blog and the corresponding libraries and tools. blog_os The repository of the Writing an OS in Rust blog received the following updates: Update x86_64 dependency to version 0.8.1. This included the depende...

This post gives an overview of the recent updates to the Writing an OS in Rust blog and the used libraries and tools. I moved to a new apartment mid-October and had lots of work to do there, so I didn’t have the time for creating the October status update post. Therefore, this post lists the changes...

This post gives an overview of the recent updates to the Writing an OS in Rust blog and the used libraries and tools. I finished my master thesis and got my degree this month, so I only had limited time for my open source work. I still managed to perform a few minor updates, including code simplicat...

This post gives an overview of the recent updates to the Writing an OS in Rust blog and the used libraries and tools. I was very busy with finishing my master’s thesis, so I didn’t have any to implement any notable changes myself. Thanks to contributions by @vinaychandra and @64, we were still able ...

This post gives an overview of the recent updates to the Writing an OS in Rust blog and the used libraries and tools. Since I’m still very busy with my master thesis, I haven’t had the time to work on a new post. But there were quite a few maintenance updates this month and also a few new features s...

This post gives an overview of the recent updates to the Writing an OS in Rust blog and the used libraries and tools. My focus this month was to finish the Heap Allocation post, on which I had been working since March. I originally wanted to include a section about different allocator designs (bump,...

This post adds support for heap allocation to our kernel. First, it gives an introduction to dynamic memory and shows how the borrow checker prevents common allocation errors. It then implements the basic allocation interface of Rust, creates a heap memory region, and sets up an allocator crate. At ...

This post gives an overview of the recent updates to the Writing an OS in Rust blog and to the used tools. I was quite busy with my master thesis this month, so I didn’t have the time to create new content or major new features. However, there were quite a few minor updates. x86_64 Use cast crate in...

Lot’s of things changed in the Writing an OS in Rust series in the past month, both on the blog itself and in the tools behind the scenes. This post gives an overview of the most important updates. This post is an experiment inspired by This Week in Rust and similar series. The goal is to provide a ...

This post explores unit and integration testing in no_std executables. We will use Rust’s support for custom test frameworks to execute test functions inside our kernel. To report the results out of QEMU, we will use different features of QEMU and the bootimage tool. This blog is openly developed on...

This post shows how to implement paging support in our kernel. It first explores different techniques to make the physical page table frames accessible to the kernel and discusses their respective advantages and drawbacks. It then implements an address translation function and a function to create a...

This post explains techniques to make the physical page table frames accessible to our kernel. It then uses such a technique to implement a function that translates virtual to physical addresses. It also explains how to create new mappings in the page tables. This blog is openly developed on GitHub....

This post introduces paging, a very common memory management scheme that we will also use for our operating system. It explains why memory isolation is needed, how segmentation works, what virtual memory is, and how paging solves memory fragmentation issues. It also explores the layout of multilevel...

In this post, we set up the programmable interrupt controller to correctly forward hardware interrupts to the CPU. To handle these interrupts, we add new entries to our interrupt descriptor table, just like we did for our exception handlers. We will learn how to get periodic timer interrupts and how...

This post explores the double fault exception in detail, which occurs when the CPU fails to invoke an exception handler. By handling this exception, we avoid fatal triple faults that cause a system reset. To prevent triple faults in all cases, we also set up an Interrupt Stack Table to catch double ...

CPU exceptions occur in various erroneous situations, for example, when accessing an invalid memory address or when dividing by zero. To react to them, we have to set up an interrupt descriptor table that provides handler functions. At the end of this post, our kernel will be able to catch breakpoin...

To complete the testing picture we implement a basic integration test framework, which allows us to run tests on the target system. The idea is to run tests inside QEMU and report the results back to the host through the serial port. This blog is openly developed on GitHub. If you have any problems ...

This post explores unit testing in no_std executables using Rust’s built-in test framework. We will adjust our code so that cargo test works and add some basic unit tests to our VGA buffer module. This blog is openly developed on GitHub. If you have any problems or questions, please open an issue th...

Over the past six months we’ve been working on a second edition of this blog. Our goals for this new version are numerous and we are still not done yet, but today we reached a major milestone: It is now possible to build the OS natively on Windows, macOS, and Linux without any non-Rust dependendenci...

The VGA text mode is a simple way to print text to the screen. In this post, we create an interface that makes its usage safe and simple by encapsulating all unsafety in a separate module. We also implement support for Rust’s formatting macros. This blog is openly developed on GitHub. If you have an...

The first step in creating our own operating system kernel is to create a Rust executable that does not link the standard library. This makes it possible to run Rust code on the bare metal without an underlying operating system. This blog is openly developed on GitHub. If you have any problems or qu...

In this post, we create a minimal 64-bit Rust kernel for the x86 architecture. We build upon the freestanding Rust binary from the previous post to create a bootable disk image that prints something to the screen. This blog is openly developed on GitHub. If you have any problems or questions, please...

In this post, we start exploring CPU exceptions. Exceptions occur in various erroneous situations, for example when accessing an invalid memory address or when dividing by zero. To catch them, we have to set up an interrupt descriptor table that provides handler functions. At the end of this post, o...

In this post we explore double faults in detail. We also set up an Interrupt Stack Table to catch double faults on a separate kernel stack. This way, we can completely prevent triple faults, even on kernel stack overflow. As always, the complete source code is available on GitHub. Please file issues...

In this post, we learn how to return from exceptions correctly. In the course of this, we will explore the iretq instruction, the C calling convention, multimedia registers, and the red zone. As always, the complete source code is on GitHub. Please file issues for any problems, questions, or improve...