Linuxstamp:Buildroot

Building a Toolchain and Kernel for the Linux Stamp using Buildroot

When the Linux Stamp boots, a tiny little loader called the Darren Loader fires up, which in terms passes control to U-Boot. U-Boot's job is to locate and pass control to the Linux Kernel, which is the piece of software that sticks around, interfacing to the hardware, but at the very beginning it it responsible for locating a root file system, mounting it, and then creating the initial userland processes.

In other words, there are two distinct pieces of code that you need to supply so that the Stamp can be up and running with Linux: these two are (i) the Linux Kernel and (ii) the Linux Root File System (i.e. all the files under "/").

To be able to build any of this stuff though, you can't use the compiler you have on your x86 machine. The gcc on your x86 machine will normally generate x86 code targeted at an x86 machine. Unfortunately, the Linux Stamp doesn't have an x86 processor - it has an ARM processor. To be able to get gcc to create code that will run on the ARM processor on the Linux Stamp, you will need a cross compiler (aka toolchain) i.e. something that runs on a HOST machine and compiles to a different architecture, called the TARGET architecture. In your case, the HOST architecture is presumably x86 and your TARGET architecture is arm (which is what the Linux Stamp has on it).

That brings out list of things we have to create up to three: (i) the cross compiling toolchain (ii) the linux kernel and (iii) the root file system.

For purposes of this discussion, I'm going to assume that your desktop or server (called the "HOST") where you are going to run the compiler is an x86 machine running Ubuntu (or some other Debian based) Linux.

Getting to Hello World

This page will try and get you to the point where you will create a "Hello World" executable that you can run on your newly customized and compiled Kernel and Root File System.

Before we can do that, recaall that you will need to solve three problems: (i) toolchain (ii) kernel and (iii) root file system. Once you have all three, you will use that toolchain to (cross) compile your HelloWorld.c file into a HelloWorld ARM executable, which you can then transfer over to the Stamp's new file system and run it on the Stamp!

The beauty of Buildroot

Buildroot is a very cool set of makefiles and scripts that can do all three of these for you. For a variety of reasons though, we are going to use Buildroot to do just two of the three ... we'll use it to build the toolchain and to build the root file system. We'll build the kernel separately, because, well ... once you have the toolchain ready, recompiling the kernel is pretty straightforward and the tools that come with the kernel to build it are perfectly adequate, and it's nice to keep things simple when we can :-)

Buildroot, as the name suggests, allows you to build a root file system. What's nice about it is that it allows you to build the root file system in a self contained directory, and you wont need to build it as root! The only point where you may need to become root or use 'sudo' is to install any packages that you may not already have installed. One of the nicest things about buildroot is that it will create a corss compiler that uses the uClibc library, which is a super-slimmed down version of the usual glibc library. uClibc is designed for embedded systems, and dramatically reduces the size of the binaries that you create.

So, lets get started with that ... before you can use buildroot, you need to have a bunch of packages installed. On Ubuntu/Debian, you can do this as follows:

$ sudo apt-get install build-essential libncurses-dev bison flex texinfo zlib1g-dev gettext libssl-dev wget autoconf

While we're at it, let's grab a couple of utilities that will come in handy later on, though they aren't really needed for getting buildroot to work:

$ sudo apt-get install autoconf dropbear minicom lrzsz

Grabbing Buildroot

Getting Buildroot is easy ... provided you have subversion installed. Before you begin, create a new directory that will contain all the files and build environment for the stamp. I'm going to assume you will create a directory called stamp in your home directory, and we'll do all our work from within that directory.

$ mkdir ~/stamp
$ cd ~/stamp
$ svn co svn://uclibc.org/trunk/buildroot

You should see a LOT of output as the files are pulled across the network. When all is done, and if all goes well, you should have a new subdirectory called 'buildroot' ... let's switch to that directory:

$ cd buildroot

You are now ready to configure and build the toolchain and your root file system!

Building the Root File System

Buildroot allows you to very carefully finetune just what goes on your root file system. You can build a very comprehensive root file system that includes a compiler and a full development toolchain, or, you can build a very minimal root file system that can boot linux and do very little else!

The decisions on what to include and what not to include, are up to you, but the process of deciding that can be a little overwhelming to begin with. Fortunately, buildroot is designed so it saves the specific choices on what and how to build in a file called '.config'. To save yourself the hassle of building a configuration from scratch, I have created and saved a few config files for you. I have tried most of them, so they should work on your system as well.

(this is a work in progress ... to be continued)