What Does It Take to Make a Kernel?

The kernel this. The kernel that. People
often refer to one operating system’s kernel or another without
truly knowing what it does or how it works or what it takes to make
one. What does it take to write a custom (and non-Linux) kernel?

So, what am I going to do here? In June 2018, I wrote a guide
to build a complete Linux distribution from source packages
, and in
January 2019, I expanded
on that guide
by adding more packages to
the original guide. Now it’s time to dive deeper into the custom
operating system topic. This article describes how to write your very own kernel from scratch
and then boot up into it. Sounds pretty straightforward, right? Now,
don’t get too excited here. This kernel won’t do much of anything.
It’ll
print a few messages onto the screen and then halt the CPU. Sure,
you can build on top of it and create something more, but that is not
the purpose of this article. My main goal is to provide you, the reader,
with a deep understanding of how a kernel is written.

Once upon a time, in an era long ago, embedded Linux was not really a
thing. I kno that sounds a bit crazy, but it’s true! If you worked with
a microcontroller, you were given (from the vendor) a specification, a
design sheet, a manual of all its registers and nothing more. Translation:
you had to write your own operating system (kernel included)
from scratch.
Although this guide assumes the standard generic
32-bit x86 architecture, a lot of it reflects what had to be done
back in the day.

The exercises below require that you install a few packages in
your preferred Linux distribution. For instance, on an Ubuntu machine,
you will need the following:

  • binutils
  • gcc
  • grub-common
  • make
  • nasm
  • xorriso

An Extreme Crash Course into the Assembly Language

Note: I’m going to simplify things by pretending to work with
a not-so-complex 8-bit microprocessor. This doesn’t
reflect the modern (and possibly past) designs of any commercial
processor.

Powered by WPeMatico