Dokumen tersebut membahas tentang membangun sistem operasi mini menggunakan Qemu, Linux kernel, dan Busybox. Langkah-langkahnya meliputi persiapan perangkat lunak yang dibutuhkan, membuat direktori kerja, mengkompilasi Linux kernel dan Busybox, serta menguji sistem operasi mini tersebut menggunakan Qemu. Selanjutnya dibahas cara menambahkan dukungan NFS agar sistem dapat diakses dan diperbarui secara

1. Table of Contents
1Tentang Qemu..........................................................................................................................................1
2Minimum System dengan Qemu + Busybox...........................................................................................2
2.1Persiapan..........................................................................................................................................2
2.2Quick Start........................................................................................................................................2
2.3Membangun Sendiri Sebuah Mini System.......................................................................................3
2.3.1Persiapan ..................................................................................................................................3
2.3.2Working Directory....................................................................................................................4
2.3.3Cross Compiler.........................................................................................................................4
2.3.4Linux Kernel.............................................................................................................................5
2.3.5Busybox....................................................................................................................................8
2.3.6Testing.....................................................................................................................................10
2.4Mini System dengan Qemu + Linux + Busybox + NFS................................................................11
2.4.1Konfigurasi Kernel.................................................................................................................13
2.4.2Testing.....................................................................................................................................13

2. 1 Tentang Qemu
Qemu adalah sebuah processor emulator yang berguna bagi pengembangan perangkat
lunak di atas satu processor tertentu. Seperti yang kita tahu, banyak sekali jenis processor
seperti Intel x86, ARM, MIPS, PPC, dll. Qemu mendukung emulasi processor sehingga
system dapat dikembangkan tanpa ketersediaan perangkat keras.
Bayangkan ketika kita ingin membuat aplikasi di atas salah satu processor tersebut
sementara kita belum memiliki perangkat keras. Di sini Qemu hadir untuk memberikan
kemudahan mengembangkan perangkat lunak tanpa harus memiliki perangkat keras.
Tentu pada beberapa kasus Qemu tidak dapat memberikan solusi, akan tetapi fungsi minimal
dari system sudah dapat dipenuhi oleh Qemu.
Lebih jauh lagi, dalam proyek skala besar yang melibatkan banyak pengembang yang
bekerja di beberapa bagian proyek yang berbeda (misalkan bagian device driver, bagian user
interface, user library, dll) distribusi pekerjaan dapat dilakukan secara parallel. Pengembang
user interface dan library dapat bekerja tanpa harus menunggu ketersediaan perangkat keras,
dan hal semacamnya.
Pemakai Qemu sebagai emulator atau bagian dari Standard Development Kit dapat
dijumpai di: Google Android Emulator, QT Greenphone, OpenMoko.
Qemu merupakan perangkat lunak bebas, dapat diperoleh di http://qemu.org
2 Minimum System dengan Qemu + Busybox
Bagian ini akan membahas tentang pembuatan sebuah mini system menggunakan
Qemu sebagai emulator, Linux kernel, dan busybox. Pembaca diharapkan dapat mereproduksi
mini system sesuai dengan petunjuk yang diberikan.
2.1 Persiapan
Buku ini ditulis di atas sistem operasi Ubuntu dan semua listing kode telah dipastikan
berjalan di atasnya. Bagi pembaca, dapat menggunakan sistem operasi Ubuntu atau BlankOn
Ombilin yang dapat diperoleh di:
Ubuntu: http://ubuntu.com
BlankOn: http://blankonlinux.or.id
Dibutuhkan koneksi internet untuk menginstall development package yang tersedia di

3. Ubuntu atau BlankOn repository. Petunjuk lebih detil tersedia di CD bagian 1 (Persiapan).
Setelah development-package terinstall, kita dapat melanjutkan ke bab selanjutnya.
2.2 Quick Start
Untuk memulainya, cukup buka direktori di CD bagian 2 (Demo: Qemu + Linux +
Busybox) kemudian ketik perintah berikut:
qemu­system­arm ­M versatilepb ­m 128M ­kernel zImage ­append
"root=/dev/ram init=/bin/sh"
Qemu window akan muncul dan menampilkan loading process Linux dan berakhir
dengan console dengan tanda '#'
Anda sudah berada di sebuah Embedded Linux sistem yang terdiri dari Linux kernel,

4. root filesystem yang ada di RAM, dan sebuah console yang berfungsi seperti terminal
desktop.
TIPS: CTRL+ALT untuk keluar dari Qemu jika mouse anda sudah terperangkap di dalamnya
Coba ketikkan perintah: ls, pwd, ps
2.3 Membangun Sendiri Sebuah Mini System
Essensi dari Free Software adalah anda dapat membuat segala sesuatunya
sendiri/reproduce system yang dikembangkan di atas free software. Mari kita coba
membangun sendiri sebuah sistem seperti demo di atas.
2.3.1 Persiapan
Beberapa aplikasi perlu disiapkan di atas development machine seperti yang disebutkan
pada bagian Persiapan. Selanjutnya, kita akan membuat sebuah direktori tempat kita bekerja.
Sebaiknya direktori ini dibuat di dalam HOME direktori dari user yang bersangkutan.
2.3.2 Working Directory
Buat satu direktori di home direktori sebagai working directory.
cd ~
mkdir ­p hack hack/src/ hack/debug hack/compiler hack/staging
Sehingga susunan direktori yang terbentuk sebagai berikut:
hack/
├── compiler
├── debug
├── src
└── staging
Direktori src akan kita gunakan sebagai tempat menyimpan source file, sementara
debug untuk binary image yang dihasilkan sesudah proses kompilasi. Direktori compiler untuk
meletakkan Cross compiler, staging digunakan sebagai tempat pengerjaan kompilasi.

5. 2.3.3 Cross Compiler
Cross compiler dibutuhkan untuk membangun binary dengan format yang sesuai
dengan instruksi processor. Dalam hal ini kita menggunakan processor ARM maka dipakai
cross compiler bagi mesin ARM. Anda dapat menggunakan cross compiler dari Code
Sourcery, Linaro, atau membuatnya sendiri dengan crosstool-ng. Pembahasan mengenai cross
compiler tersedia di bagian lain buku ini. Saya menggunakan Code Sourcery sebagai compiler
ARM yang dapat diperoleh di sini:
http://codesourcery.com/uri/to/cross-compiler-binary
Ekstrak compiler ke direktori hack/compiler
[NOTE]
Code Sourcery toolchain juga tersedia di CD bagian Compiler
[/NOTE]
Cross compiler yang akan kita gunakan dapat di export ke PATH sehingga dapat
diakses dari mana saja tanpa memberikan absolute path-nya. Jika tidak, setiap kali proses
compile dipanggil maka CROSS_COMPILER parameter harus ditentukan dengan absolute
path-nya.
Anda dapat mengexport cross compiler di file ~/.bashrc dengan menambahkan baris
di bawah ini:
export PATH=${PATH}:/path/to/cross­compiler­binary
Pada kasus kita, cross compiler diextract di /home/<user>/hack/compiler/arm-
2010.09/ maka tambahkan baris tersebut di ~/.bashrc
2.3.4 Linux Kernel
Inti dari system kita adalah Linux kernel yang dapat diperoleh dari
http://kernel.org/pub/v2.6 Di dalam CD juga sudah tersedia beberapa versi Linux kernel
yang akan kita gunakan pada bab selanjutnya.
Kita pilih kernel versi 2.6.27.58, extract di dalam direktori hack/staging dengan
perintah berikut:

6. [CODE]
# tar xjvf linux-2.6.27.58.tar.bz2
# head -n 5 linux-2.6.27.58/Makefile
VERSION = 2
PATCHLEVEL = 6
SUBLEVEL = 27
EXTRAVERSION = .58
NAME = Trembling Tortoise
[/CODE]
Lakukan konfigurasi kernel dengan perintah berikut:
[CODE]
cd ~/hack/staging/linux-2.6.27.58
make ARCH=arm versatile_defconfig
[/CODE]
Perintah tersebut mengkopi file konfigurasi mesin ARM versatile dari
arch/arm/configs/versatile_defconfig ke .config.
File konfigurasi ini belum mendukung ARM EABI instruction set yang harus
diaktifkan karena compiler yang kita gunakan adalah compiler EABI. Buka file .config dengan
text editor idaman anda, lalu cari CONFIG_AEABI yang masih di-comment, lalu ganti
dengan:
CONFIG_AEABI=y
Update konfigurasi kernel dengan perintah:
make ARCH=arm oldconfig
atau gunakan fasilitas konfigurasi kernel (Kconfig)
[CODE]
make ARCH=arm menuconfig
→ Kernel Features
→ Use the ARM EABI to compile the kernel
[/CODE]

7. [GAMBAR 03: Kernel menuconfig]
Saatnya mengompile kernel! Karena kernel yang akan dibangun adalah untuk mesin
ARM, kita perlu memberikan parameter CROSS_COMPILE yang menunjuk pada path ke
cross compiler yang akan kita gunakan.
make ARCH=arm CROSS_COMPILE=arm­none­linux­gnueabi­
Tunggu beberapa saat hingga proses kompilasi selesai dan kernel image tersedia di
arch/arm/boot/zImage. Kita akan gunakan file zImage ini sebagai parameter di Qemu.
TIPS: Konfigurasi kernel yang lebih detil terdapat di bagian lain buku ini [Appendix A:
Konfigurasi Kernel]

8. 2.3.5 Busybox
Busybox adalah swiss knife of embedded Linux, satu aplikasi yang mencakup hampir
semua perintah shell. Cukup dengan Busybox kita dapat memperoleh fungsi dari sebuah
terminal yang sama dengan yang kita dapati di Desktop. Busybox dapat diperoleh di
http://busybox.net/downloads/busybox-1.18.4.tar.gz
Ekstrak busybox-1.18.4.tar.gz di dalam direktori hack/staging
cd ~/hack/staging
tar xfvz busybox­1.18.4.tar.gz
Busybox akan kita konfigurasi dengan static build di mana busybox binary tidak akan
membutuhkan shared library dan dapat dipakai sebagai aplikasi yang berdiri sendiri. Untuk
mengkonfigurasinya:
make ARCH=arm defconfig
Untuk mengubah konfigurasi BusyBox, kita dapat melakukan perintah berikut:
make ARCH=arm menuconfig
Busybox Settings
-> Build Options
-> Build BusyBox as a static binary
Tampilan dari BusyBox configurator dapat dilihat pada gambar di halaman berikutnya.
Kemudian lakukan proses kompilasi dengan perintah berikut:
make ARCH=arm CROSS_COMPILE=arm­none­linux­gnueabi­ install
Tunggu beberapa saat hingga proses compile selesai dan hasil compile tersedia di dalam
direktori _install. Hasil dari kompilasi BusyBox berupa root file system skeleton, kita
memerlukan image yang nantinya akan dikenali oleh Kernel, salah satunya initramfs/cpio
image. Untuk membuatnya, kita lakukan perintah berikut:
cd _install
find . | cpio ­o ­­format=newc > ../rootfs.img
Ukuran yang dihasilkan masih cukup besar yang mana akan berpengaruh pada
konsumsi RAM kernel atau bahkan menyebabkan kernel panic jika ukuran initramfs tersebut

9. lebih besar dari yang ditentukan oleh kernel. Lakukan proses kompresi initramfs tadi:
cd ..
gzip ­c rootfs.img > rootfs.img.gz

10. [GAMBAR 04: Busybox configurator]
2.3.6 Testing
Kernel image telah kita miliki begitu pula dengan busybox dan mini root file system.
Saatnya kita coba untuk menjalankan mini system ini di atas Qemu:
qemu­system­arm ­M versatilepb ­m 128 ­kernel zImage ­initrd
rootfs.img.gz ­append "root=/dev/ram rdinit=/bin/sh"
-M adalah parameter tipe machine

11. -m parameter memory yang digunakan oleh system
-kernel adalah parameter untuk kernel image yang digunakan oleh Qemu
-initrd adalah initial ram disk image (root file system) yang akan digunakan oleh mini
system
-append adalah parameter bagi kernel, root berarti menunjuk device node root
filesystem, init adalah aplikasi pertama kali yang akan dieksekusi
TIPS: Dalam CD sudah disediakan Makefile untuk membentuk demo di atas.
2.4 Mini System dengan Qemu + Linux + Busybox + NFS
Dalam pengembangan riil embedded system, sering dijumpai kendala ketika harus
mendebug aplikasi yang sedang dikembangkan. Kadang langkah untuk mendownload binary
ke board, kemudian menulis ke memory area cukup memakan waktu dan tentunya
menghambat pengembangan. Untuk mengatasi hal ini, Linux memberikan kemudahan dengan
kemampuannya mengakses network, terutama NFS root. Kali ini kita akan membuat system
yang menggunakan NFS sebagai root file system.
Dengan NFS kita dapat mengupdate root file system on the fly, tanpa harus mereboot
system dengan syarat user permission harus sama antara qemu dan pemilik direktori /srv/nfs.
Misalkan kita memiliki aplikasi untuk ditest, aplikasi tersebut cukup di copy-paste ke
direktori NFS dan dapat langsung diakses dari sistem yang berjalan.
Pada bagian sebelumnya kita telah membahas tentang pembuatan minimum system
dengan Linux dan Busybox yang telah dapat berfungsi seperti terminal/console di desktop.
Akan tetapi masih banyak kekurangan di sistem tersebut, misal perintah `ps' tidak dapat
bekerja karena membutuhkan /proc filesystem, dan beberapa kendala lainnya. Pada bagian
ini, kita akan membahas dan mencobanya lebih lanjut.
Beberapa persiapan harus dilakukan untuk menjalankan mini system dengan NFS root
file system. Install nfs-kernel-server di Ubuntu dengan perintah berikut:
sudo apt­get install nfs­kernel­server
Lalu siapkan satu direktori sebagai NFS root, misalkan /srv/nfs. Setelah NFS server
terinstall, update file /etc/exports tambahkan baris di bawah ini:
/srv/nfs 10.0.2.*(rw,sync,no_subtree_check,all_squash,insecure,anonuid=1000,anongid=1000)

12. Perubahan pada file /etc/exports perlu diupdate dengan perintah berikut:
exportfs ­av
Perintah di atas menginstruksikan nfs-kernel-server untuk mereload file /etc/exports sehingga
perubahan yang kita lakukan dapat berjalan.
Root file system yang nantinya akan dipakai oleh kernel akan diletakkan di dalam
direktori /srv/nfs. Kita akan menggunakan root file system hasil dari kompilasi busybox.
sudo cp ­dpfa busybox/_install /srv/nfs
Sehingga kita memiliki struktur direktori sebagai berikut:
/srv/nfs/_install
├── bin
├── dev
├── etc
├── proc
├── sbin
├── sys
└── usr
├── bin
└── sbin
Program yang pertama kali dieksekusi oleh Linux adalah /sbin/init, program ini
bertugas untuk menginisialisasi sistem dengan menjalankan perintah-perintah yang diletakkan
di /etc/inittab. File ini dapat berisi apa saja yang dibutuhkan untuk memulai sebuah sistem;
menjalankan script inisialisasi, membuka console, dll.
Akan tetapi hasil kompilasi dari busybox masih kekurangan beberapa direktori
tambahan yang memungkinkan Linux untuk booting dengan lancar. Untuk kita akan
membuatnya:
mkdir /srv/nfs/_install/etc/init.d
mkdir /srv/nfs/_install/dev
mkdir /srv/nfs/_install/proc
mkdir /srv/nfs/_install/sys
Kemudian akan membuat file /etc/inittab sebagai berikut:
::sysinit:/etc/init.d/rcS
::respawn:/sbin/getty ­n ­l /bin/sh ­L 115200 tty1 vt100

13. ::restart:/sbin/init
Baris pertama menginstruksikan system untuk menjalankan file /etc/init.d/rcS,
kemudian mengeksport output dari system ke tty1, kemudian restart /sbin/init
Pada baris pertama, init akan menjalankan file /etc/init.d/rcS, dalam file ini, kita
akan mounting file system minimum yang dibutuhkan:
mount ­t proc none /proc
mount ­t sysfs none /sys
mount ­t ramfs ramfs /dev
/sbin/mdev ­s
Karena NFS root filesystem dimiliki oleh user maka kita tidak dapat membuat
direktori/atau membuat file baru di dalamnya, sedangkan kita perlu untuk populate /dev
beserta isinya. Untuk mengakali hal tesebut, /dev dimount sebagai ramfs (temporary file
system).
2.4.1 Konfigurasi Kernel
Linux kernel memiliki fitur untuk mengakses NFS server dengan mengaktifkan NFS
support. Pada konfigurasi yang kita pakai di bab sebelumnya, NFS support telah diaktifkan.
2.4.2 Testing
Jalankan qemu dengan perintah berikut:
qemu­system­arm ­M versatilepb ­m 128M ­kernel zImage ­append
"root=/dev/nfs nfsroot=10.0.2.2:/srv/nfs/_install rw
ip=10.0.2.15::10.0.2.1:255.255.255
.0 init=/sbin/init"

14. [GAMBAR]
-append adalah parameter untuk kernel command line
root root fs device
nfsroot ip address dari server diikuti path ke root file system
rw opsi untuk baca tulis file system
ip ip address dari qemu dengan format:
IP:HOSTNAME:GATEWAY:NETMASK
init menunjuk pada program pertama yang akan dieksekusi oleh kernel