Run Linux on ARM architecture with QEMU

Introduction

• We have summarized how to use QEMU to run Linux on ARM architecture.

Overview

• QEMU is a Linux emulator. Here, the Linux kernel is cross-compiled for ARM and the root filesystem is created using BusyBox.
• BusyBox is software that combines standard Linux commands into a single binary file.

Operating environment

• Ubuntu 20.04 LTS

Environment

1. Install git.

   $ sudo apt-get install git
   

2. Install the ARM cross-compiler.

   $ sudo apt-get install gcc-arm-linux-gnueabi
   

3. Install the software needed to build the Linux kernel.

   $ sudo apt-get install flex bison libncurses-dev libssl-dev
   

4. Install QEMU for ARM.

   $ sudo apt-get install qemu-system-arm
   

Directory structure at build time

• In the following items, the structure of the created directory is as follows.

{top_directory} ├ linux-stable │ └ arch │ └ arm │ └ boot │ ├ zImage: Kernel image │ └ dts │ └ versatile-pb.dtb: Device tree │ ├ busybox │ ├ _install: root file system │ └ rootfs.img: Image of root file system │ ├ driver │ └ sample │ └ driver_sample.ko: Device driver module │ └ app └ sample └ app_sample: Run binary file of the app ~~~

Linux kernel build

1. Clone the Linux kernel (Stable Kernel).

   $ git clone git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable.git
   

2. Navigate to the cloned directory.

   $ cd linux-stable
   

3. Apply the default settings for Arm Versatile boards (versatilepb).

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- versatile_defconfig
   

4. Build.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
   

5. Make sure that the kernel image and device tree have been generated.

   $ ls -latr arch/arm/boot/dts/versatile-pb.dtb
   $ ls -latr arch/arm/boot/zImage
   

Build BusyBox

1. Clone BusyBox.

   $ git clone git://git.busybox.net/busybox
   

2. Navigate to the cloned directory.

   $ cd busybox
   

3. Apply the default settings.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- defconfig
   

4. We need to statically link to work with a single binary, so run the make menuconfig command to enable the kernel config "Build static binary (no shared libs)".

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- menuconfig
   

   Settings --> Build static binary (no shared libs)
   

5. Build.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
   

6. Install. When the installation is complete, a root file system will be created under the _install directory.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- install
   

Creating a device driver

1. Create a directory for the device driver and change to it.

   $ mkdir -p driver/sample
   $ cd driver/sample
   

2. Create the source code for the device driver. (The following source code is a sample device driver that just loads / unloads.)

   $ nano driver_sample.c
   

   #include <linux/module.h>
   #include <linux/kernel.h>
   
   static int __init sample_module_init( void )
   {
   	printk( "driver sample load\n" );
   	return 0;
   }
   
   static void __exit sample_module_exit( void )
   {
   	printk( "driver sample remove\n" );
   }
   
   module_init( sample_module_init );
   module_exit( sample_module_exit );
   
   MODULE_DESCRIPTION( "sample_module" );
   MODULE_LICENSE( "GPL" );
   

3. Create a Makefile.

   $ nano Makefile
   

   obj-m := driver_sample.o
   
   all:
   	make -C $(shell pwd)/../../linux M=$(shell pwd) modules
   clean:
   	make -C $(shell pwd)/../../linux M=$(shell pwd) clean
   

4. Cross-compile the device driver.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
   

5. Copy the device driver into busybox's _install directory.

   $ cp driver_sample.ko ../../busybox/_install/
   

Creating an app

1. Create a directory for your app and change to it.

   $ mkdir -p app/sample
   $ cd app/sample
   

2. Create the source code for your app. (The following source code is a sample application that only outputs logs.)

   $ nano app_sample.c
   

   #include <stdio.h>
   
   int main(int argc, char *argv[])
   {
   	printf( "app sample run\n" );
   	return 0;
   }
   

3. Create a Makefile.

   $ nano Makefile
   

   TARGET	= app_sample
   
   CC		= ${CROSS_COMPILE}gcc
   LD		= ${CROSS_COMPILE}gcc
   
   CSRCS	= $(TARGET).c
   CFLAGS	= -c
   LDFLAGS	= -static -o $(TARGET)
   
   OBJS	= $(CSRCS:.c=.o)
   LIBS	=
   
   .c.o:
   	$(CC) $(CFLAGS) $<
   
   $(TARGET): $(OBJS)
   	$(LD) $(LDFLAGS) $(OBJS) $(LIBS)
   
   clean: ;
   	rm $(OBJS) $(TARGET)
   

4. Cross-compile your app.

   $ make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi-
   

5. Copy the app into busybox's _install directory.

   $ cp app_sample ../../busybox/_install/
   

Run QEMU

1. Image the root file system.

   $ cd busybox/_install/
   $ find .| cpio -o --format=newc > ../rootfs.img
   $ cd ../../
   

2. Run QEMU.

   $ qemu-system-arm \
   	-M versatilepb \
   	-kernel ./linux/arch/arm/boot/zImage \
   	-dtb ./linux/arch/arm/boot/dts/versatile-pb.dtb \
   	-nographic \
   	-append "rdinit=/bin/sh" \
   	-initrd ./busybox/rootfs.img
   

3. When the startup is complete, the shell will start. Checking with the ls command, the root file system looks like this:

   / # ls
   app_sample        dev               linuxrc           sbin
   bin               driver_sample.ko  root              usr
   / #
   

4. Load the device driver.

   / # insmod driver_sample.ko
   driver_sample: loading out-of-tree module taints kernel.
   driver sample load
   

5. Run the app.

   / # ./app_sample
   app sample run