AlcaLabs

[[projects:openwrt:from-scratch]]

Traccia: » OpenWrt from scratch

Ti trovi qui: Alca Labs » projects » openwrt » OpenWrt from scratch

Login

Non sei ancora collegato! Inserisci il tuo nome utente e la tua password per autenticarti. E' necessario che il tuo browser abbia i cookie abilitati.

Entra

Hai dimenticato la password? Richiedine una nuova: Invia nuova password

OpenWrt from scratch

Abstract

Sono tantissime le distribuzioni GNU/Linux che si possono installare con facilità su macchine Desktop o Server. Esse sono completamente personalizzabili, contengono una grande quantità di software e spesso sono ulteriormente estendibili con nuovi pacchetti software. Inoltre possono essere compilate interamente sulla propria macchina, ottendo così importanti ottimizzazioni.

OpenWrt 1) consente di avere la stessa flessibilità e potenza di queste distribuzioni su macchine embedded come router, access point wireless, ecc.

L'obiettivo di questo articolo è far vedere come sia possibile compilare un firmware OpenWrt from scratch.

Il firmware

La creazione di un firmware per un dispositivo embedded non è affatto un operazione semplice, ma OpenWrt permette di semplificare molto tale processo. OpenWrt non contiene applicativi software sviluppati ad-hoc (escluso ovviamente l'ambiente di building), ma sfrutta del software standard, opportunamente patchato; inoltre la gestione del software a pacchetti consente di installare nuovo software a run-time, prelevando i pacchetti da repository locali o remoti2).

Il processo di building

La compilazione dell'immagine di OpenWrt prevede le seguenti fasi:

  1. la generazione del compilatore: è necessario avere un compilatore capace di produrre codice eseguibile sulla piattaforma target;
  2. la generazione del toolchain: il compilatore da solo non basta, sono necessarie le librerie e i tool per la generazione dell'immagine;
  3. la generazione dei pacchetti software di base ed esterni: che possono essere integrati nel firmware oppure possono essere in forma di pacchetto ipkg da installare successivamente;
  4. la generazione dell'immagine con partizioni e filesystem.

A secondo del risultato che si vuole ottenere, è possibile usare tre metodi differenti:

  • Building Root
  • SDK
  • Image Builder

La Building Root3) è l'ambiente di sviluppo completo: consente di generare l'immagine interamente from scratch, oltre che ovviamente l'SDK e l'Image Builder.

L'SDK4) contiene un ambiente di building minimo e viene utilizzato di solito per effettuare il porting di nuovo software in OpenWrt. Comprende il toolchain, gli header e le librerie per effetturare il cross-compiling.

L'Image Builder5) permette di generare immagini personalizzate, scegliendo i pacchetti da includere e definendo i file di configurazione. Tutto questo è possibile senza ricompilare i sorgenti, ma è richiesto che i pacchetti siano già disponibili in formato ipkg.

La Building Root

Nella root dei sorgenti di possono identificare le directory fondamentali:

  • tools
  • toolchain
  • package
  • target

tools e toolchain contengono i tool necessari per creare il compilatore, la libreria c e il firmware. Gli eseguibili risultanti vengono posti build_dir.

package contiene i pacchetti software di base.

target contiene degli oggetti specifici per le diverse piattaforme embedded: la configurazione del kernel e le patch, le modalità per creare l'immagine, l'Image Builder e l'SDK.

Generare il firmware

Avvertenze

E' necessario disporre di notevole spazio su disco per accogliere i sorgenti e tutti i file generati al momento della compilazione. Si consiglia perciò di avere una directory di building da riutilizzare nelle successive ricompilazioni. Considerare che sono circa 400MB di sorgenti (tra sistema base e feeds) ma nel building si arriva ad oltre 2G! Inoltre non si può compilare da root (ma questo non vale solo per OpenWrt…;-)), quindi usare un utente standard.

Quick Compile

Come prima cosa ci si procura la Building Root. In questo caso si lavora direttamente col trunk, all'ultima versione disponibile:

$ svn co https://svn.openwrt.org/openwrt/trunk openwrt

Ovviamente, se si possiede già il trunk, non è necessario il checkout: si possono aggiornare i sorgenti col comando:

$ svn up

Prima di procedere con la compilazione, si deve verificare di possedere tutte le librerie e i tool di sviluppo necessari. Il comando seguente provvede a segnalare eventuali mancanze:

$ make prereq

Se è tutto ok, viene generata l'interfaccia di configurazione altrimenti si può digitare:

$ make menuconfig

In questo modo verrà compilata la UI ncurses che, come si può notare, è simile a quella del kernel Linux.

Fatte le opportune scelte di configurazione, si lancia il comando di compilazione. Si possono ritrovare un esempio di configurazione qui.

:!: Attenzione, la fase di compilazione può richiedere alcune ore!

$ make

Alla fine della procedura di compilazione, in ./bin, per ogni filesystem selezionato in fase di configurazione ci saranno:

  • il firmware (ad esempio openwrt-x86-ext2.image)
  • il kernel (ad es. openwrt-x86-vmlinuz)
  • il filesystem (ad es. openwrt-x86-ext2.fs)
  • gli md5sums di verifica
  • un repository di pacchetti in formato ipkg in ./bin/packages

:!: NB: quando si compila si deve essere online per scaricare i sorgenti.

Il sistema dei pacchetti

OpenWrt adotta un'architettura per la compilazione del software simile a quella di *BSD o Gentoo. C'è un indice dei pacchetti disponibili che si preleva online, e per ogni pacchetto vengono forniti il makefile e le eventuali patch da applicare. Solo in fase di compilazione di scaricano i sorgenti veri e propri del pacchetto software – anche il sistema base e il toolchain funzionano così.

Dopo aver selezionato le opzioni per il target specifico, si ottiene un sistema minimale. Di solito però si ha bisogno di altro software non contenuto nell'ambiente di default. Per questo motivo si scaricano i feeds dei pacchetti extra. Tutte queste operazioni si possono eseguire manualmente, ma è meglio ricorrere agli script inclusi.

Per recuperare tutti i feeds disponibili, si esegue:

$ make package/symlinks

Ora i pacchetti saranno visibili nell'interfaccia ncurses e potranno essere selezionati:

$ make menuconfig

:!: TIP: Per cercare una parola chiave nell'interfaccia di menuconfig usa lo slash '/'.

Come per il kernel, i pacchetti si possono trovare in tre stati [Y/M/N]:

  • <*>, il pacchetto viene incluso nell'immagine, ma viene creato in formato ipkg e posto nel repository;
  • <M>, il pacchetto non è inserito nel firmware: è un modulo, cioè viene creato solo in formato ipkg;
  • <N>, il pacchetto non verrà compilato;

:!: Le dipendenze tra i pacchetti sono soddisfatte automaticamente al momento della compilazione.

I feeds

Il comando make package/symlinks richiama lo script feeds in ./scripts/feeds.

Con questo script si possono effetture molte operazioni sui feeds: selezionare i singoli pacchetti, effettuarne la disinstallazione o aggiornare la lista.

Usage di feeds: Usage: ./scripts/feeds <command> [options]

Commands:
	list [options]: List feeds and their content
	Options:
	    -s :           List of feed names and their URL.
	    -r <feedname>: List packages of specified feed.

	install [options] <package>: Install a package
	Options:
	    -a :           Install all packages from all feeds or from the specified feed using the -p option.
	    -p <feedname>: Prefer this feed when installing packages.
	    -d <y|m|n>:    Set default for newly installed packages.

	search [options] <substring>: Search for a package
	Options:
	    -r <feedname>: Only search in this feed

	uninstall -a|<package>: Uninstall a package
	Options:
	    -a :           Uninstalls all packages.

	update -a|<feedname(s)>: Update packages and lists of feeds in feeds.conf .
	Options:
	    -a :           Update all feeds listed within feeds.conf. Otherwise the spezified feeds will be updated.
	    -i :           Recreate the index only. No feed update from repository is performed.

	clean:             Remove downloaded/generated files.

Installare singoli pacchetti

Affinchè i pacchetti vengano compilati si devono verificare due condizioni:

  1. deve essere presente il feed del pacchetto
  2. lo stato del pacchetto deve essere Y o M

Ad esempio per installare un singolo feed (e le sue dipendenze), si aggiorna l'indice:

$ ./scripts/feeds update

Si cerca il pacchetto se non si è sicuri della sua denominazione:

$ ./scripts/feeds search [nome]

Si installa il feed (non è necessario se è già stato eseguito make package/symlinks):

$ ./scripts/feeds install [nome_pacchetto]

Se i pacchetti devono essere inclusi nell'immagine (stato Y) si deve eseguire il make per rigenerare il firmware con i nuovi pacchetti.

Altrimenti, se è sufficiente avere il pacchetto in formato ipkg, per compilarlo si può scrivere:

$ make package/<nome_pacchetto>-clean V=99
$ make package/<nome_pacchetto>-compile V=99

:!: Se il pacchetto è extra la linea di comando diventa:

$ make package/feeds/packages/<nome_pacchetto>-clean V=99
$ make package/feeds/packages/<nome_pacchetto>-compile V=99

Il risultato sarà posto in ./bin/packages/{ARCH}/{PACCHETTO}.ipkg

Testing

Prima di installare il firmware appena creato su un dispositivo reale, lo si può testare con QEmu o VirtualBox.

Per QEmu il comando è:

$ qemu -hda {image} -boot c -m 64

Per VirtualBox è necessario aver attivato il supporto alla generazione delle immagini VDI in fase di configurazione. E' necessario vditool.

Risoluzione dei problemi

Quando c'è qualche problema, si possono avere dei messaggi di debug aggiungendo la variabile V=99 al comando lanciato.

Per problemi di compilazione, dovuti ad un aggiornamento del trunk o del software di sistema, eseguire: FUNZIONA??? FIXME

$ make distclean

Note

Per configurare il kernel:

$ make kernel_menuconfig

Maggiori informazioni sul kernel e i moduli si possono trovare qui.

Riferimenti


Per commenti, suggerimenti, chiarimenti:francesco.palermo@alcacoop.it 2008/11/06 20:00