Embedded Gentoo – Tagebuch eines Versuchs (Teil 2)

Aufgrund der hohen Compile-Zeit von Gentoo setze ich dieses Howto bzw dieses Log der Installation heute fort. emerge -e system hatte 72 Pakete zu bauen und meine Kaffeekanne erreichte die kritische Mindestmenge – Zeit um ins Bett zu gehen. Dann graut Morgen – kein Brandgeruch in der Luft, kein Brennen am Tisch – der Laptop hat es überlebt Gentoo-Embedded zu bauen; Hoffnungsvoll blicke ich auf den LCD und siehe da – es ist vollbracht.

Also auf zum nächsten Schritt unserer Installation. Die bisherige Installation beinhaltet – wie bislang jede Gentoo-Installation alle Distfiles, den kompletten Portage und einen grossen Satz Tools und Libraries, welche sich in der Zwischenzeit schon auf 1,8 GB ausbreiten. Wie das wohl je auf eine CF Karte passen sollte? Es wird!

Jedes System benötigt einen Kernel, also emergen wir diesen. Dann vervollständigen wir die Bash-Umgebungsskripte des Default-Users und legen uns schliesslich ein Verzeichnis an, in welchem das endgültige und vorallem Abgespeckte Embedded Gentoo liegen wird. Ein weiteres Problem welches sich uns stellt ist, dass das normale Baselayout welches Gentoo Linux benützt, nicht unbedingt embedded-tauglich ist. Aus diesem Grund verwenden wir das noch maskierte Baselayout-Lite, welches jedoch zuerst in die Keywords aufgenommen werden muss:

* sys-apps/baselayout-lite
Available versions: *1.0_pre1
Installed: none
Homepage: http://www.gentoo.org/proj/en/base/embedded/
Description: Baselayout for embedded systems

emerge gentoo-sources
cp /etc/skel/.bash_profile /etc/skel/.bashrc /root/
mkdir /tinygentoo
mkdir -p /etc/portage
echo "sys-apps/baselayout-lite -*" >> /etc/portage/package.keywords

Um unser kleines Gentoo nun endgültig zu bauen setzen wir ROOT=/tinygentoo vor die neuen emerge-Befehle, wenn das Paket nicht in der Entwicklungsumgebung, sondern am zukünftigen Echtsystem laufen soll – so bei unseren Grundbausteinen baselayout-lite, uclib und Busybox, womit wir ein minimales System schaffen:

ROOT=/tinygentoo emerge -av baselayout-lite uclibc busybox

Nun ist es Zeit Benutzer anzulegen, wozu wir ein weiteres mal chrooten. Ich nenne den Benutzer einfach operator:


chroot /tinygentoo /bin/ash
passwd
addgroup -g 100 users operator
adduser -h /home/operator -s /bin/bash -G users operator
exit

Der etwas delikatere Teil liegt nun in der Konfiguration des Systems, wobei das Anlegen der nötigen Verzeichnisse nicht vergessen werden sollte:

echo "eBrick" > /tinygentoo/etc/hostname
mkdir /tinygentoo/boot
mkdir /tinygentoo/mnt/usbstick
mkdir /tinygentoo/proc
chmod 555 /tinygentoo/proc

Die /tinygentoo/etc/fstab birgt ihre Tücken:

/dev/ram0 / ext2 defaults 0 0
none /tmp tmpfs defaults 0 0
none /proc proc defaults 0 0
none /dev/shm tmpfs defaults 0 0

/dev/hda1 /boot ext2 noauto,ro 0 0
/dev/hda2 /mnt/usb vfat defaults 0 0

Die einfachste Art unser System sicher zu gestalten ist, alles in einen Initrd zu packen – was wir auch später machen werden. Dieser wird zu allererst unter /dev/initrd und später als /dev/ram0 verfügbar sein, welches wir nach dem Booten als / mounten.

Beachte: Flash Speicher mag es nicht, wenn man ihn permanent be- und überschreibt – aus diesem Grund liegen jene Teile wie /tmp auf einer Ramdisk.

Nun wird es Zeit, Applikationen zu bauen, welche uns das Arbeiten mit dem kleinen System ermöglichen. Ich habe mich für die Net-Tools, einen DHCP-Clienten, einen Browser und einen SSHd entschieden. Natürlich darf ‘screen’ auch nicht fehlen:

ROOT=/tinygentoo emerge -av net-tools udhcp links dropbear screen

Den Kernel zu compilieren ist eine Prozedur, welche ich nicht extra beschreibe. Als Hinweis sei jedoch gesagt dass sich vieles als Modul compilen lässt und alles was nicht gebraucht wird den Kernel nur unnötig gross macht. Da wir einen Kernel der Version 2.6.x verwenden, wurde make dep obsolet:


make clean bzImage modules modules_install
cp arch/i386/boot/bzImage /tmp/kernel-2.6
mkdir -p /tinygentoo/lib/modules
cp -vr /lib/modules/* /tinygentoo/lib/modules/

Die letzten beiden Befehle sind nötig um die Kernel-Module in unser kleines System zu übernehmen. Nun ist es Zeit aufzuräumen und das eben erstellte Verzeichnis zu einem Initrd zusammenzufassen, was wir wie folgt bewerkstelligen:

cp -r /tinygentoo /tmp/
rm -r /tmp/tinygentoo/var/* /tmp/tinygentoo/tmp/*
du -hs /tmp/tinygentoo

Es ist wichtig, die genaue Grösse des zukünftigen Initrds zu kennen! Mein Verzeichnis hat 21 MB. Da das Filesystem selbst auch Platz benötigt lege ich den initrd mit einer Grösse von 25 MB an.

dd if=/dev/zero of=/tmp/initrd.img bs=1MB count=25
mke2fs -F /tmp/initrd.img
mkdir /mnt/initrd
mount -o loop /tmp/initrd.img /mnt/initrd
rsync -avz /tmp/tinygentoo/ /mnt/initrd
umount /mnt/initrd
cd /tmp
gzip -9 initrd.img
du -hs initrd.img.gz

Nach dem Komprimieren des Initrds bekomme ich ein File mit der Grösse von 6.2 MB, was man durchaus als ‘klein’ bezeichnen kann. Auf meinem Notebook wird die CompactFlash Karte via USB angesprochen – Somit hängt sie als /dev/sda in meinem System. Ich partitioniere sie mit fdisk /dev/sda. Da diese Karte nur zum Booten dient ist es nicht nötig auf ihr weitere Partitionen anzulegen. Man darf jedoch nicht vergessen, die Partition als Bootfähig zu markieren!

Das Anlegen des Dateisystems erledigt mke2fs für uns. Was dann folgt ist das Kopieren der GRUB Dateien, welche

mount /dev/sda1 /media/floppy
mkdir /media/floppy/grub
cp /boot/grub/stage? /media/floppy/grub
cp /boot/grub/e2fs_stage1_5 /media/floppy/grub
umount /media/floppy

Es folgt der Kampf mit GRUB:


grub> device (hd0) /dev/sda
grub> root (hd0,0)
grub> setup (hd0)
grub> quit

.. und schliesslich ein Entfernen einer überflüssigen Stage-Datei und kopieren alle Dateien zusammen auf die CF:

mount /dev/sda1 /media/floppy
rm /media/floppy/grub/e2fs_stage1_5
cp /root/gentoo_uclibc/tmp/kernel-2.6 /media/floppy/
cp /root/gentoo_uclibc/tmp/initrd.img.gz /media/floppy/

Die Grub Config, menu.lst sieht wie folgt aus:

timeout 3
default 0

title Embedded Gentoo
root (hd0,0)
kernel /kernel-2.6 root=/dev/ram0 vga=791 ramdisk_size=24000 init=/sbin/init
initrd /initrd.img.gz

Nachdem alles gebaut und kopiert ist können wir die CF Karte unmounten und mit Zufriedenheit feststellen, dass wir ein System auf weniger als 8 MB untergebracht haben. Die Grösse variiert natürlich vin Build zu Build aufgrund der installierten Applikationen und den Kernelmodulen.

Nur… Wozu der Aufwand? – Der Aufwand lohnt sich für spezielle Hardware wie Visualisierungs-PCs oder Appliance Gerätschaften welche auf spezieller Hardware arbeiten wie zum Beispiel Industrie-PCs.

Author:

Leave a Reply

Your email address will not be published. Required fields are marked *

Notify me of followup comments via e-mail. You can also subscribe without commenting.