Android KitKat
Contents
Building Android KitKat for gem5
Overview
The easiest way to build Android for gem5 is to base the system on a the emulated Goldfish device. The main difference between the actual qemu-based Goldfish model and gem5 is a small number of gem5-specific configuration files. These files are mainly related to differences in block device naming and scripts to start use gem5's pseudo-op interface to start experiments.
Build Instructions
Follow the directions on Android Open Source to download and build Android. Make sure to create a local mirror (see the download page) to speed up things if you ever need to create a new working directory. The following instructions are based on our experience from bringing up Android 4.4.4r2 (KitKat).
Make sure to quickly read the AOSP build instructions. In particular the section about Java dependencies. KitKat and earlier all depend on particular Sun/Oracle JDK versions. Lollipop and newer seem to be able to build with OpenJDK.
When setting up your build directories, I'd suggest a structure as follows:
- /work/android (or some other directory with plenty of free space)
- .../repos/aosp-mirro - Mirror of the upstream Android repository
- .../gem5kitkat/
- .../aosp - Clone of the Android repository
Build a vanilla AOSP KitKat distribution using the following command:
. build/envsetup.sh lunch aosp_arm-userdebug make -j8
This builds a plain Android for the Goldfish device (an Android specific qemu version). We are going to use this as a base for our gem5 distribution.
Useful commands:
hmm | Show a list of build system commands |
mm | Build the Android module in the current directory |
mma | Build the Android module in the current directory and its dependencies |
emulator | Launch Android in qemu |
The mm command is especially useful since just running make in a directory with an existing build of Android (i.e., make doesn't need to build anything) can take several minutes.
Preparing a filesystem for gem5
First, create an empty disk (this example creates a 2GiB image) image:
dd if=/dev/zero of=myimage.img bs=1M count=2048
As root, hook up the disk image to a loopback device (the following
assumes /dev/loop0 is free).
losetup /dev/loop0 myimage.img
Using fdisk, create the following partitions:
Part. No | Usage | Approximate Size |
---|---|---|
1 | / | 500MB |
2 | /data | 1GB |
3 | /cache | 500MB |
Use common sense when setting up the partitions. The root partition will contain both Android's root file system and the system file system and should be big enough for both of them. The data partition will contain any apps that are not a part of the system (i.e., anything you install).
As root, tell the kernel about the partitions and format them to ext4:
partprobe /dev/loop0 mkfs.ext4 -L AndroidRoot /dev/loop0p1 mkfs.ext4 -L AndroidData /dev/loop0p2 mkfs.ext4 -L AndroidCache /dev/loop0p3
Mount the filesystem and extract the root file system:
mkdir -p /mnt/android mount /dev/loop0p1 /mnt/android cd /mnt/android zcat AOSP/out/target/product/generic/ramdisk.img | cpio -i mkdir cache mkdir -p /mnt/tmp mount -oro,loop AOSP/out/target/product/generic/system.img /mnt/tmp cp -a /mnt/tmp/* system/
At this point, the new disk image is a (mostly) vanilla Goldfish
image. Add the gem5 pixie dust by copying all the files in the
attached tar-ball into the new root file system and adding an
m5 binary (see util/m5 in your gem5 work directory)
to /sbin. This directory contains a gem5-specific init.rc that
is based on the original Goldfish device, with additional
tweaks. Specifically, it runs /gem5/postboot.sh when Android
has booted. This script is responsible for disabling the screen lock
and downloading and executing a run script from gem5.
At this point, everything should just work. Unmount everything and
disconnect the loop back device:
umount /mnt/android losetup -d /dev/loop0
Android systems generally does a lot of initialization (JIT
compilation etc.) on the first boot. Since gem5 normally mounts the
root file system as CoW and stores the file system differences in
memory. To speed up future experiments, make sure to follow the guide
in BBench-gem5 to make these changes permanent.
Building the kernel
You will need a recent ARM cross compiler to build the kernel. If
you're using Ubuntu 10.04, install it by running:
sudo apt-get install gcc-arm-linux-gnueabihf
Checkout the gem5 kernel from the following git repository:
git://linux-arm.org/linux-linaro-tracking-gem5.git
Configure and build the kernel using:
make CROSS_COMPILE=arm-linux-gnueabihf- ARCH=arm vexpress_gem5_defconfig make CROSS_COMPILE=arm-linux-gnueabihf- ARCH=arm vmlinux -j8
Android Runtime Configuration
Simulation-specific kernel boot options options:
Kernel Option | Function |
---|---|
qemu=1 | Enable emulation support |
qemu.gles=1 | Don't use software rendering (usually enables GLES pass through) |
androidboot.hardware=NAME | Overrides the device's platform name (used to select configuration files at boot) |
A simulated system should normally set qemu=1 on the kernel command line. This enables software rendering and some emulation specific services. In order to load the right boot configuration, set androidboot.hardware to gem5.
Kernel command line to properties mapping:
Kernel Option | Android Property |
---|---|
androidboot.* | ro.boot.* |
androidboot.serialno | ro.serialno |
androidboot.mode | ro.bootmode |
androidboot.baseband | ro.baseband |
androidboot.bootloader | ro.bootloader |
androidboot.hardware | ro.hardware & ro.boot.hardware |
* | ro.kernel.* if running in emulation mode |
Emulation Mode Specifics (qemu=1)
OpenGL & Graphics
- Setting the ro.kernel.qemu property forces libGLES_android to be used unless ro.kernel.qemu.gles is also set.
- qemu.sf.lcd_density instead of ro.sf.lcd_density is used to specify display density.
Resources
Running workloads with Kitkat
To run workloads we advice the use of Workload Automation. For detailed instructions on how to use this see: WA-gem5
NoMali
To use a NoMali model in gem5, you need to perform the following steps:
- Add it to the configuration file
- Add the user-space drivers to your Android image
- Add the kernel-side driver to your kernel
- Inform the kernel of the device by adding it to the device tree
These steps are described in detail in the sections below.
Once you have started gem5,
Configuration Changes
The NoMali GPU is not instantiated by default in any of the example configurations. To instantiate it, add the following code to your configuration script:
my_system.gpu = NoMaliGpu( gpu_type="T760", ver_maj=0, ver_min=0, ver_status=1, int_job=114, int_mmu=115, int_gpu=116, pio_addr=0x2d000000)
The code above instantiates a NoMali model of a Mali T760 r0p0-1 at address 0x2d000000. The GPU type and revision must match the driver.
Android User Space Drivers
Download the Mali drivers for gem5 from the ARM Mali Midgard User Space Drivers section on MaliDeveloper. Make sure that you download a driver that matches your Android version. Make a note of the driver version number, you'll need a matching kernel-side driver of the same version.
The downloaded file will contain at least the following files:
- lib/egl/libGLES_mali.so
- lib/hw/gralloc.default.so
Copy the entire lib directory into /system/vendor in the target system. The resulting disk image should contain (at least) the following files:
- /system/vendor/lib/egl/libGLES_mali.so
- /system/vendor/lib/hw/gralloc.default.so
Make sure that everyone can access the files (i.e., files have permission 0644 and directories 0755), or you'll end up with permission errors when booting the system.
Kernel Drivers
Download the Mali kernel-side drivers from the ARM Mali Midgard Kernel Drivers section on MaliDeveloper. Make sure that you download a driver version that matches your user space driver version.
Copy the directory driver/product/kernel/drivers/gpu/arm into drivers/gpu/ in your target kernel. You now need to wire up the driver to the kernel's build system. Do that by adding arm/ to the list of subdirectories in drivers/gpu/Makefile. To add it to the configuration system, add source "drivers/gpu/arm/Kconfig to drivers/video/Kconfig.
Enable the driver in the kernel configuration (set MALI_MIDGARD / Device Drivers -> Graphics support -> ARM GPU Configuration -> Mali Midgard series support). The default options should work and enable device tree support. Do not set the NoMali option in the kernel.
Device Tree
Add the following node to your device tree:
gpu@0x2d000000 { compatible = "arm,mali-midgard"; reg = <0 0x2d000000 0 0x4000>; interrupts = <0 82 4>, <0 83 4>, <0 84 4>; interrupt-names = "JOB", "MMU", "GPU"; };
Note that there is an offset between interrupts in gem5 and in the device tree. Linux starts counting SPIs from 0, while gem5 starts from 32.