Given my interests in enterprise computing and embedded systems, I decided to mix the two disciplines and use Docker to create a C development environment to generate Arm executable from my OS X based Mac. This may seem like a stretch, but the traditional way to do this is to fire up a full-blown virtual machine, install Linux, install the gcc based cross compiler, edit code on the host machine, switch to the VM, compile, and iterate.  This is slow and cumbersome, and not nearly as educational or fun!

The first step was to install boot2docker and follow the directions. This provided a simple and clean way to get Docker running on OS X.  Next I created a Dockerfile to create a Docker image FROM Ubuntu, loaded all the required modules and configured the image for cross compilation.  Here is my Dockerfile:

##################################################

# This docker file creates an Arm cross compiler

# platform from Ubunto

##################################################

# Ubunto as base image

FROM ubuntu

MAINTAINER J. Kelly Flanagan, Brigham Young University

# update ubuntu image

RUN apt-get update

# enable 32 bit code to run on 64 bit machine

RUN apt-get -y install lib32z1

# install the gcc tools to enable compilation

RUN apt-get -y install gcc build-essential libncurses5-dev mtd-utils u-boot-tools

# ADD cross compiler tools and unpack in appropriate location

# create destination directory

RUN mkdir /opt/codesourcery/

# ADD source

ADD arm* /opt/codesourcery/

ADD mkubifsimage /bin/

RUN chmod 777 /bin/mkubifsimage

# for interactive use set path

RUN echo ‘PATH=/opt/codesourcery/arm-2011.09/bin:$PATH’ >> /root/.bashrc

# set environment variable so I know I’m in a container

ENV ARM_CROSS_COMPILER TRUE

# create build directory where a volume will be mounted

RUN mkdir -p /tmp/arm_cross_compiler

# End Dockerfile

With this Dockerfile I ran the following build command using docker,

docker build -t ubuntu_arm_crosscompiler .

this resulted in a new Docker image called ubuntu_arm_crosscompiler. This image can be used to create an interactive Docker container by executing,

docker run -i -t ubuntu_arm_crosscompiler

This yields a shell where you can invoke gcc to create Arm object and executable files from source. However, I don’t use it interactively; I invoke it from make so that it appears as if I am compiling from my Mac, but end up with the desired Arm executable file.

As an example let’s assume we have a source directory with a Makefile and a few source files: Makefile, test.c, test.h, and testfunc.c.  The Makefile uses conditionals to determine whether it is executing on the host machine or the Docker container. In the Dockerfile the environment variable ARM_CROSS_COMPILER was set and will exist in any container derived from that image. The contents of the Makefile are included below.

# Name: Makefile

# Purpose: Build Arm executable via Docker based cross compiler

# Author: J. Kelly Flanagan

# Docker specific stuff

DOCKER_ARGS = -v $(PWD):/tmp/arm_cross_compiler -w /tmp/arm_cross_compiler

CC=/opt/codesourcery/arm-2011.09/bin/arm-none-linux-gnueabi-gcc

RM=rm -f

HEADERS = test.h

OBJECTS = test.o testfunc.o

TARGET = test

test: $(OBJECTS)

ifeq ($(ARM_CROSS_COMPILER),TRUE)

            $(CC) -o $@ $^ $(CFLAGS)

else

            @docker run $(DOCKER_ARGS) ubuntu_arm_crosscompiler make $@

endif

%.o: %.c $(HEADERS)

ifeq ($(ARM_CROSS_COMPILER),TRUE)

            $(CC) -c -o $@ $

else

            @docker run $(DOCKER_ARGS) ubuntu_arm_crosscompiler make $@

endif

clean:

            $(RM) $(OBJECTS) $(TARGET)

Docker works well in this case because it is efficient enough to be invoked and destroyed quickly enough to not be a major contributor to compile time and it is much more convenient than switching back and forth between my host and a VM. Finally, I can share either the Dockerfile or the image with others, enabling them to easily use my tool chain. I’m definitely adding Docker to my standard set of tools for solving problems.