PE GG G /L U GR G UR

drwxrwxr-x 2 righiandr righiandr 4096 Dec 14 lo stesso meccanismo di BusyBox: creiamo un

15:07 sbin link simbolico a /sbin/init, all’interno dell’immagi-
drwxrwxr-x 2 righiandr righiandr 4096 Dec 14 ne del nostro initramfs:
17:11 sys
drwxrwxr-x 4 righiandr righiandr 4096 Dec 14 $ cd /tmp/initrd
15:01 usr $ ln -s sbin/init init
Per /dev, invece è necessario fare un passo $ ls -l
aggiuntivo, che consiste nell’inizializzare i le $ ls -l
di dispositivo base che il kernel e l’ambiente total 24
BusyBox si aspettano di trovare. drwxrwxr-x 2 righiandr righiandr 4096 Dec 15
Per questo possiamo usare il comando mknod: 00:29 bin
drwxrwxr-x 2 righiandr righiandr 4096 Dec 15
$ cd /tmp/initrd 00:29 dev
$ mkdir dev lrwxrwxrwx 1 righiandr righiandr 9 Dec 15 01:25
$ cd dev init -> sbin/init
$ sudo mknod tty1 c 4 1 drwxrwxr-x 2 righiandr righiandr 4096 Dec 15
$ sudo mknod tty2 c 4 2 00:29 proc
$ sudo mknod tty3 c 4 3 drwxrwxr-x 2 righiandr righiandr 4096 Dec 15
$ sudo mknod tty4 c 4 4 00:29 sbin
$ sudo mknod tty5 c 4 5 drwxrwxr-x 2 righiandr righiandr 4096 Dec 15
$ sudo mknod tty6 c 4 6 00:29 sys
$ sudo mknod console c 5 1 drwxrwxr-x 4 righiandr righiandr 4096 Dec 15
$ sudo mknod null c 1 3 00:29 usr
$ sudo mknod zero c 1 5 A questo punto abbiamo completato l’immagine
I primi sei dispositivi (tty1 ... tty6) rappresentano di un lesystem GNU/Linux minimale: la stessa
i terminali virtuali (quelli a cui possiamo acce- base di quello che troviamo in qualsiasi distribu-
dere su un tipico sistema GNU/Linux premen- zione GNU/Linux.
do la combinazione ALT+F1 ... ALT+F6); il le / Il passo nale è quindi di creare l’initramfs (sem-
dev/console è il terminale principale. In ne /dev/ pre come abbiamo visto nella puntata prece-
null e /dev/zero sono device virtuali: il primo, se dente) e far partire nalmente la nostra micro-
viene letto ritorna sempre un buffer vuoto, se ci distribuzione:
scriviamo sopra i dati vengono ignorati; in ne /
dev/zero se letto ritorna un buffer pieno di zeri # cd /tmp/initrd/
(esattamente una quantità pari alla dimensione # nd . | cpio -o --format=newc > ../initramfs
del buffer speci cato per la lettura). 2667 blocks
L’ultimo passo, come visto nella puntata prece- # du -sh ../initramfs
dente, è di creare nell’initramfs un binario chia- 1.4M ../initramfs
mato /init, che il kernel provvederà ad eseguire Come possiamo notare la nostra distribuzione
al termine della fase di boot. Per questo usiamo occupa solo 1.4MB. Decisamente minimale.
 PE GG G /L U GR G UR

Adesso possiamo far partire la board virtuale su

QEMU: / # mount -t proc none /proc
/ # ps
$ qemu-system-arm -M vexpress-a9 -kernel ./ PID USER TIME COMMAND
arch/arm/boot/zImage -serial stdio -display 1 0 0:01 init
none -append “console=ttyAMA0” -initrd /tmp/ 2 0 0:00 [kthreadd]
initramfs 3 0 0:00 [ksoftirqd/0]
Booting Linux on physical CPU 0 5 0 0:00 [kworker/u:0]
Initializing cgroup subsys cpuset 6 0 0:00 [migration/0]
Linux version 3.5.4 (righiandr@thinkpad) (gcc 7 0 0:00 [cpuset]
version 4.7.2 20120910 (prerelease) (crosstool- 8 0 0:00 [khelper]
NG linaro-1.13.1-2012.09-20120921 - Linaro 9 0 0:00 [kworker/u:1]
GCC 2012.09) ) #1 SMP Fri Dec 14 14:15:35 158 0 0:00 [sync_supers]
CET 2012 160 0 0:00 [bdi-default]
CPU: ARMv7 Processor [410fc090] revision 0 162 0 0:00 [kblockd]
(ARMv7), cr=10c53c7d 168 0 0:00 [ata_sff]
... 178 0 0:00 [khubd]
Freeing init memory: 172K 273 0 0:00 [rpciod]
can’t run ‘/etc/init.d/rcS’: No such le or directory 274 0 0:00 [kworker/0:1]
Please press Enter to activate this console. 280 0 0:00 [khungtaskd]
/ # ls -l 285 0 0:00 [kswapd0]
total 0 330 0 0:00 [fsnotify_mark]
drwxrwxr-x 2 1000 1000 0 Dec 14 23:29 bin 339 0 0:00 [nfsiod]
drwxrwxr-x 2 1000 1000 0 Dec 15 00:28 dev 410 0 0:00 [kpsmoused]
lrwxrwxrwx 1 1000 1000 9 Dec 15 00:25 init -> 413 0 0:00 [kworker/0:2]
sbin/init 463 0 0:00 [deferwq]
drwxrwxr-x 2 1000 1000 0 Dec 14 23:29 proc 468 0 0:00 -/bin/sh
drwx------ 2 0 0 0 Dec 14 13:11 root 469 0 0:00 init
drwxrwxr-x 2 1000 1000 0 Dec 14 23:29 sbin 471 0 0:00 init
drwxrwxr-x 2 1000 1000 0 Dec 14 23:29 sys 472 0 0:00 init
drwxrwxr-x 4 1000 1000 0 Dec 14 23:29 usr 481 0 0:00 ps
Oppure visualizzare il tipo di architettura da /
E al termine del boot otteniamo nalmente proc/cpuinfo:
WPC TC NN WNNC P VTC CTF TVWCN
A questo punto possiamo gestire la board come / # cat /proc/cpuinfo
gestiremo un generico sistema GNU/Linux. Processor : ARMv7 Processor rev 0 (v7l)
Possiamo usare il comando “ls” per listare i le processor :0
del root lesystem (come visto sopra). O mon- BogoMIPS : 129.43
tare il procfs e visualizzare la lista dei processi: Features : swp half thumb fastmult vfp edsp
 PE GG G /L U GR G UR

neon vfpv3 tls

CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part : 0xc09
CPU revision : 0
Hardware : ARM-Versatile Express
Revision : 0000
Serial : 0000000000000000

P NW P
In questa puntata abbiamo visto come popola-
re l’initramfs implementando una vera e propria
micro-distribuzione GNU/Linux, integrando così
quello che avevamo visto nelle puntate prece-
denti e chiudendo la serie teorica “GNU/Linux
partendo da zero”.

GNNC RTQUU OC R P C C CPCN GTGOQ R P

G CIN Q N CURG Q RTC EQ T RG GP Q
RCUU GQT E U PGNNG R P C G RTGEG GP
su una board reale: la Raspberry Pi.

T PV
1. http://www.busybox.net/
2. http://en.wikipedia.org/wiki/Everything_
is_a_ le
3. http://en.wikipedia.org/wiki/Procfs
4. http://en.wikipedia.org/wiki/Sysfs
5. http://en.wikipedia.org/wiki/Device_ le

UGI Q N N PM RGT CEEG GTG TG COGP G CNN CT EQNQ U N NQI G RCT GE RCTG CNNC UE UU QPG
R GOEGNG TQP EC EQO GODG G IP N P Z RCT GP Q C GTQ P GITC QPG G GU
 PE GG G /L U GR G UR

OO SE UU 3L
, WURG LR H boot-loader (bootcode.bin), che è memorizzato

L
a Raspberry Pi [1] (o più brevemente RPi nella ROM del SoC Broadcom
da ora in poi) è un computer vero e proprio BCM2835. Il primo stage reperisce dalla prima
realizzato su una singola scheda elettronica partizione dell’SD card esterna il boot-loader di
sviluppato dalla Raspberry Pi Fundation, un’or- secondo livello (bootloader.bin), che si occu-
ganizzazione di bene cenza che ha sede nel pa di leggere tutti gli altri le necessari al boot,
Regno Unito. Lo scopo di tale progetto è di pro- compresa l’immagine del kernel (kernel.img),
muovere lo studio dell’informatica, in particolar caricando tutto nell’SDRAM. A questo punto il
modo in ambito accademico. Proprio per questa boot-loader ha terminato il suo compito e passa
ragione tale dispositivo è facilmente accessibi- il controllo al kernel.
le a costi molto contenuti (il prezzo va da $25 016# T E OR NCTG P MGTPGN C GT U PC D
per la prima versione a $35 per la seconda della
CT E OG NC 42 R GUUGTG U CPE G E OG
versione).
P OC RR T P RGT TGCN CTG P NCD
Per maggiori dettagli sulle speci che della bo-
TC T MGTPGN G GN ROGP .C D CT R
ard si rimanda all’articolo seguente:
T GUUGTG N C C P UGI CPE G RGT HCTG
http://it.emcelettronica.com/computer-meno-di-
GURGT OGP U N MGTPGN . P UGP C C GT RC TC
25-dollari-con-arm11-e-hdmi.
CPPGII CTG E ORT OG GTG N UR U
In questo nuovo articolo vedremo come ricom-
U GUU HC RGT T RT U PCTG N MGTPGN T I PCNG
pilare un kernel e come preparare un root lesy-
basta semplicemente sovrascrivere il le kernel.
stem minimale per la RPi, partendo dai sorgenti
OI RTGUGP G PGNNC RCT PG D GNNC 5
e da una SD card vuota.
ECT C GUGOR PUGTGP N 5 ECT P P2
Per una visione più generica sulla procedura di
ricompilazione del kernel si consiglia la lettura
UHUHT LVLWL
degli articoli precedenti della serie “Embedded
• una RaspBerry Pi
GNU/Linux partendo da zero”:
• una SD card (la nostra sarà una distro ultra-
http://it.emcelettronica.com/embedded-gnuli-
minimale quindi va bene di qualsiasi dimen-
nux-partendo-da-zero-ricompil...
sione)
http://it.emcelettronica.com/embedded-gnuli-
• un PC con una distribuzione GNU/Linux
nux-partendo-da-zero-preparaz...
• una connessione a Internet per scaricare i
http://it.emcelettronica.com/embedded-gnuli-
sorgenti e il cross-compilatore
nux-partendo-da-zero-integraz...

UHSDUDUH O DPELH WH GL V LO SSR

URFHG UD GL D LR V OOD L
Per prima cosa è necessario reperire il cross
La procedura di avvio della RPi utilizza un pro-
compilatore e tutti i sorgenti richiesti a creare
cesso di boot a più stage.
da zero la nostra distribuzione per la RPi. Per
Quando la RPi viene accesa la GPU inizia ad
quanto riguarda il boot-loader si può trovare una
eseguire il primo stage del
versione precompilata nel repository git “uf cia-
 PE GG G /L U GR G UR

le” della RPi (github.com/raspberrypi). S GU N O . U CN T ET UU E OR NC T

Per preparare l’ambiente di sviluppo della no- NCUE C E OG GUGTE RGT N NG TG
stra micro-distribuzione per la RPi è suf ciente
lanciare i comandi seguenti: , L LDOL DUH O FDUG
Dopo aver reperito tutti i sorgenti e gli strumenti
$ mkdir raspberry per lo sviluppo possiamo formattare l’SD card
$ cd raspberry utilizzando un layout compatibile al boot della
$ git clone git://github.com/raspberrypi/ rmwa- RPi.
re.git Possiamo quindi inserire l’SD card nel PC e (da
$ git clone git://github.com/raspberrypi/tools.git Linux) partizionarla usando il comando seguen-
$ git clone git://github.com/raspberrypi/linux.git te:
$ git clone git://busybox.net/busybox.git
Il primo repository git contiene i le binari del $ sudo sfdisk /dev/mmcblk0 << EOF
boot loader, che andremo a copiare direttamen- unit: sectors
te sull’SD card. Gli altri repository contengono /dev/mmcblk0p1 : start= 16, size= 97648, Id= c,
rispettivamente i cross-compilatori (e utility va- bootable
rie per la gestione dei binari), e in ne i sorgenti /dev/mmcblk0p2 : start= 97664, size= 97648,
del kernel Linux e BusyBox per la parte user- Id=83
space, che andremo a ricompilare. /dev/mmcblk0p3 : start= 0, size= 0, Id= 0
016# G T ECOGP G R TGO RCT TG C U T /dev/mmcblk0p4 : start= 0, size= 0, Id= 0
genti “uf ciali” di Linux EOF
GP O PC CP NNC UR P D N U R # 1 GU Q EQOCP Q EC UC NC
MGTPGN TI C C MGTPGN CP NNC P P CPP CN RGT C EQP GP E G GTCPQ RTGUGP
N T P GTP T GT G O N RGT IGU TG N 5 ti sull’SD card, quindi veri cate di utilizzare
T C E O / RTGUGP G U NNC 42 2GT PC ECT Q C Q EQP GPGP G PHQTOC Q
S GU O UCTG P MGTPGN CP NNC IGPGT E P E G QNG G ECPEGNNCTG
RTGU RR TTGDDG PC N PIC G E ORNGUUC HCUG Con questo comando abbiamo creato una parti-
di porting di tutte le patch speci che della RPi zione primaria FAT (/dev/mmcblk0p1) che verrà
U NN G GP CNG MGTPGN UEGN E OG DCUG RCT usata per il boot (cioè dove copieremo i le del
tenza. In questo caso ci af diamo direttamente boot-loader e l’immagine del kernel che cross-
CN MGTPGN I RC E C G OGUU C UR U PG U compileremo nei passi successivi) e una parti-
) D CNNC E O P N C T zione per il root lesystem (/dev/mmcblk0p2),
016# R UU D NG N CTG N U GUU ET UU dove copieremo i binari user-space (BusyBox).
E OR NC TG U PGNNG 016# NG OGPU P GNNG G RCT P U P
R PCG ODG G )07 . P RCT GP C GP TCODG / N TGU GNN 5 ECT C
zero, in n dei conti siamo sempre su architet COGP G URTGEC C C P S GU ECU CNG
TG #4/ P S GU ECU RGT U E G PG URC TU NC C T TC U TC OGPU PC RGT
TGR U T U TIGP GNNC 42 T CO I P UR CTG NC P U TC O ET U TD PG OC P
ET UU E OR NC TG RT P CNN U R CO RGT S GU O U CO U E T T GP TCTE E P NG
 PE GG G /L U GR G UR

OGPU P G R GT U RR T CTG 5 ECT S CN con gurazione con i comandi seguenti:

U CU CIN $ cd linux
Una volta partizionata l’SD card con uno sche- $ make ARCH=arm CROSS_COMPILE=arm-
ma compatibile per il boot-loader andremo a bcm2708-linux-gnueabi- bcmrpi_defcon g
creare i lesystem su entrambe le partizioni: 2GT TGP GTG NC EQUC P RQ R P GTGUUCP G
RQUU COQ ECOD CTG NC GTU QPG GN MGTPGN
$ sudo mkfs.vfat /dev/mmcblk0p1 appendendo alla ne della stringa originale
$ sudo mkfs.ext4 /dev/mmcblk0p2 PC U T PIC RGTUQPCN C C GU GQU G
La partizione primaria deve essere necessaria- U C U T PIC EQORCT T PGNNC PQU TC UTD
mente VFAT. Per la secondaria QPG RGTUQPCN C C QIP QN C E G GTT
(root lesystem) possiamo scegliere un qualsia- U CORC C NC GTU QPG GN MGTPGN.
si lesystem supportato da Per fare ciò possiamo lanciare:
Linux. In questo caso abbiamo scelto ext4.
$ make ARCH=arm CROSS_COMPILE=arm-
LFRPSLODUH LO NHU HO bcm2708-linux-gnueabi- menucon g
E` in ne giunto il momento di cross-compilare il E dall’interfaccia andare a modi care il parame-
kernel. Percorreremo tro:
velocemente questi passi, perché sono esatta-
mente gli stessi visti nei General setup ---> Local version - append to
precedenti articoli di questa serie. kernel release
Le uniche differenze consistono in: Aggiungendo la stringa “-eos” (o quella che più
1) aggiungere al PATH della shell il cross-com- ci piace).
pilatore giusto (lanciare il A questo punto è giunto il momento di lanciare il
comando dalla directory “raspberry” dove ab- passo di compilazione
biamo scaricato i repository git): effettiva del kernel:
export PATH=$PWD/tools/arm-bcm2708/arm-
bcm2708-linux-gnueabi/bin:$PATH $ make ARCH=arm CROSS_COMPILE=arm-
bcm2708-linux-gnueabi-
2) selezionare il branch rpi-3.2.27 (il ramo del Per generare un le immagine del kernel com-
kernel stabile che si trova nel repository git del patibile con il boot-loader della RPi dobbiamo
kernel della RPi) anche “pacchettizzarlo” in modo opportuno.
$ git checkout rpi-3.2.27 Questo passaggio non è sempre richiesto; in
questo caso può essere effettuato lanciando lo
3) con gurare il kernel per abilitare i settaggi di script OCIG N PE ORTGUUG R (che si trova
default per la RPi nel repository “tools” insieme al cross-compila-
(la con gurazione di default per questa board è tore):
chiamata bcmrpi_defcon g).
Spostiamoci quindi nella directory dei sorgenti $ cd ../tools/mkimage
del kernel e lanciamo la $ ./imagetool-uncompressed.py ../../linux/arch/