Sviluppo software

Linux embedded 4/5: creare l'immagine del filesystem con Buildroot

Questo articolo fa parte della serie:

Una volta pronto il bootloader e preparata l'immagine del kernel, l'ultimo passo che rimane per avere un sistema Linux embedded funzionante è quello di creare il filesystem del sistema target con tutti i file, le directory e gli applicativi necessari.

Nei sistemi Linux embedded questa operazione viene realizzata con Buildroot .

Buildroot è un software open source che permette di creare il filesystem di un sistema embedded partendo dai sorgenti dei vari applicativi che vengono poi cross-compilati per l'ambiente target e insieme ai file di configurazione compongono il filesystem.

I vantaggi di Buildroot sono:

  • Buildroot conosce tutti i siti da cui scaricare i sorgenti dei vari software che si scelgono per il sistema target;
  • Buildroot conosce come modificare i pacchetti scaricati in modo da consentirne la cross-compilazione;
  • Buildroot è in grado di combinare tutti i pacchetti fino a comporre il root filesystem, in altri termini Buildroot conosce le dipendenze che sussistono tra i vari pacchetti software;
  • Buildroot ha un ambiente di configurazione a menù molto intuitivo e facile da usare che permette di scegliere quali pacchetti includere nel file system che si va a creare;

Anche in questo caso, come per il kernel e il boot loader, solitamente il produttore della scheda embedded fornisce i sorgenti di Buildroot con piccole variazioni e una configurazione base già pronta per la scheda embedded.

La prima cosa da fare quindi è estrarre l'archivio contenente i sorgenti di buildroot


tar jxvf buildroot-<versione>.tar.bz2

Il comando precedente crea la directory con i sorgenti. Si procede quindi entrando in tale directory con il comando:


cd buildroot-<versione>

A questo punto con il comando seguente si carica la configurazione di default per la scheda del produttore


make <nomescheda>_defconfig

A questo punto, in modo simile alla compilazione del kernel, con il comando seguente si apre il menù di configurazione di buildroot.


make menuconfig

Dal menù che si apre, per prima cosa bisogna configurare i riferimenti alla toolchain di cross-compilazione che nell'esempio abbiamo posizionato nella directory /usr/local/arm/<nomescheda>. L'opzione da configurare si trova nel menù alla voce Toolchain -> Toolchain path.

Fatto questo si può procedere a variare le opzioni del menù aggiungendo o togliendo i pacchetti software della nostra distribuzione personalizzata.

Una volta terminata la configurazione si procede alla creazione del filesystem con il comando:


make

Quando Buildroot inizia il suo processo di creazione, parte scaricando i pacchetti dei sorgenti dei software selezionati, li configura, li compila e li assembla nell'immagine del filesystem.

Tutti i risultati della compilazione vengono posti nella sottodirectory output.

La configurazione di default produce due immagini di filesystem. Una in formato EXT2, pensata per essere mappata in locale sull'ambiente host e l'altra in formato UBIFS che invece è pensata per essere scritta direttamente sulla scheda target.

Abbiamo trattato come utilizzare queste due immagini nell'articolo Linux Embedded 2/5 - Il bootloader U-Boot.

Nel caso si voglia esporre l'immagine EXT2 presente sul sistema host al sistema target, utilizzando il filesystem di rete NFS, bisogna procedere come segue:

Bisogna mappare l'immagine del filesystem prodotto da buildroot output/images/rootfs.ext2 sulla directory di rete condivisa con NFS /rootfs.


# con l'utente root
umount /rootfs # questo comando serve solo se c'era già un'immagine montata su rootfs
mount -o loop output/images/rootfs.ext2 /rootfs
service nfs restart # quando si effettua il mount bisogna riavviare il servizio nfs

La directory /rootfs, se abbiamo seguito l'articolo Linux Embedded 1/5 - Come configurare l'ambiente di sviluppo, è già condivisa in rete con il protocollo NFS, quindi non resta che modificare la configurazione del bootloader della scheda embedded per effettuare il boot da rete Linux Embedded 2/5 - Il bootloader U-Boot.

La prima volta che si crea il filesystem con Buildroot, la compilazione può richiedere parecchio tempo, anche più di un'ora. Successivamente però quando vengono apportate solo modifiche minori alla configurazione di buildroot, allora la compilazione procede in pochi minuti, perché il grosso del lavoro è già stato fatto la prima volta.

Per questioni interne a Buildroot (si veda Understanding when a full rebuild is necessary e Understanding how to rebuild packages ), una volta compilato un pacchetto, se si procede a variarne la configurazione dal menù di buildroot, non è detto che questo venga ricompilato all'esecuzione del comando make. In questi casi bisogna forzare la ricompilazione.

Similmente, inoltre, man mano che si aggiungono pacchetti al filesystem questi vengono compilati e aggiunti, quando invece si tolgono dalla configurazione non è detto che i relativi file vengano tolti dal filesystem. L'idea è che fintanto che si sviluppa si aggiungono i pacchetti che servono e si tolgono quelli che non servono, ma solo dalla configurazione. Alla fine però prima di rilasciare l'immagine si procede a una ricompilazione da zero di Buildroot in modo da essere sicuri che solo i pacchetti voluti siano presenti nel filesystem.

I comandi per forzare una ricompilazione da zero sono:


make
make clean

Aggiungere i propri file all'immagine del filesystem creata con Buildroot#

Come abbiamo visto è possibile mappare in locale (sulla directory /rootfs) ed esportare quindi sulla rete l'immagine del filesystem EXT2 output/images/rootfs.ext2 con il protocollo NFS. Una volta effettuato questo mappaggio con il comando mount, le modifiche apportate alla directory /rootfs sono subito disponibili per la scheda embedded e vengono registrate nel file output/images/rootfs.ext2.

Questa modalità di modifica va bene in fase di sviluppo per copiare file (es. configurazioni personalizzate, eseguibili, ecc.) nel filesystem target in modo rapido.

C'è da dire però che ad ogni ricompilazione del filesystem con buildroot, il file rootfs.ext2 viene ricreato e queste modifiche vanno perse. Quindi in qualche modo queste modifiche vanno inserite nel sistema di creazione dell'immagine.

Nella documentazione di Buildroot le varie possibilità sono ben documentate nel punto Customizing the generated target filesystem .

Una modalità poco invasiva e molto usata è quella di aggiungere dei Post-build scripts. In altri termini è possibile configurare Buildroot (l'opzione si trova nel menù System configuration) in modo che esegua degli script bash indicati dall'utente un attimo prima di archiviare i file del filesystem nelle immagini rootfs.ext2 e rootfs.ubifs. Quindi si può creare uno script bash che aggiunge, toglie o modifica i file un attimo prima che buildroot congeli i file del filesystem nel file immagine.

ATTENZIONE: SERVIZIO DI CONSULENZA SOSPESO#

Non offriamo più questo tipo di consulenza.

Questo articolo resta per documentare un'attività che abbiamo svolto in passato, ma che non facciamo più.

Votazione pagina#

[Voti: 39 Media voto: 4.3/5]
Autore: Lorenzo Chiodi
Senior software developer con più di 10 anni di esperienza nello sviluppo di soluzioni web based, enterprise, su misura. Dal 2011 socio fondatore di Garda Informatica Snc condivide questa avventura col fratello Giovanni.

Promemoria sui Cookie e sulla Privacy

Leggi l'informativa
closeIcona closesearchIcona searchmore vertIcona more vertmenuIcona menulinkIcona link