Home
Repository 32bit  Forum
Repository 64bit  Wiki

Modifiche

Slackware su pennina USB

3 075 byte aggiunti, 19:54, 3 dic 2013
m
Eliminato gzip. Già segnalato prima.
[[Category:Install_e_Upgrade]]
=Introduzione=
Questo wiki vuole essere una guida, il più completa possibile, sui passi da fare per crearsi un propria distribuzione Slackware su un dispositivo di archiviazione di massa USB (che da ora in poi chiameremo più semplicemente, pennina).<BRbr />Affronteremo tutti i vari passaggi strettamente necessari a far partire un kernel installato sulla pennina ed a creare/configurare la distribuzione Slackware.<BRbr />Ovviamente, benché pensata e testata sulla Slackware, la teoria che acquisiremo alla fine di questo wiki sarà tale da permetterci di installare una qualsivoglia distribuzione, la differenza sarà solo sugli strumenti che useremo.
Tutti o quasi tutti i comandi che eseguiremo durante Ad ogni comando verrà anteposto il wiki devono poter godere simbolo '$' se non necessita dei diritti dall'utente di root, e per questo saranno caratterizzati dal carattere iniziale '#' che è tipico della shell del super-utentealtrimenti.
I path e i comandi verranno evidenziati rispettivamente dallo stile corsivo e dal font grassetto in questo modo:
* '''questo è un comando'''
 =Perché installare A chi è rivolta la distribuzione su una pennina?guida=Alcuni esempi d'uso verranno esposti alla fine del wiki, ma facciamo comunque alcune considerazioni importanti.<BR>Questa La guida è rivolta a tutti coloro che sono curiosi, affamati di conoscenza, che usano il PC non solo come strumento di lavoro, ma anche con la voglia di portare alla luce ciò che sembra arcano. Lo scopo del wiki non è la creazione della distribuzione tascabile, bensì la divulgazione della conoscenza, è . È importante che il lettore tenga presente questo concetto, perché è quello che ci preme rimanga più a lungo nella mente di chi legge questo wiki.<BRbr />Oltre ad avere una pennina da portare nei negozi di informatica per testare i PC che solitamente hanno installato solo lo scadente Windows, acquisiremo una conoscenza più o meno approfondita di tutti i programmi necessari all'avvio di una distribuzione GNU/Linux.  =Software usato=Gli strumenti software che sono stati usati per testare questo wiki sono:* Slackware 12 (sebbene alcuni utenti l'abbiano testato con successo anche sulla 13 e sulla 13.1)* kernel huge, presente nella directory della serie ''a/'' della Slackware* comandi linux che verranno citati man mano, tutti comunque presenti nella distribuzione SlackwareL'elenco sopra citato è da tenere a mente sia perché citeremo nomi di pacchetti Slackware, sia perché il kernel huge fornisce un sopporto tale che alcuni problemi che si potrebbero incontrare verranno solo citati, in quanto risolti grazie alla sua configurazione statica.
=Fase 0: preparazione della pennina=
Noi installeremo Installeremo la distribuzione Slackware direttamente sulla pennina, iniziamo allora preparando proprio il nostro supporto di archiviazione di massa USB.<BRbr />
L'unica cosa di cui abbiamo bisogno e di installarci dentro un file system ext3. Le pennine USB, proprio come gli hard disk, possono essere partizionate, supponiamo quindi che sulla pennina ci sia un unica partizione e che questa venga collegata dal kernel al device ''/dev/sda1''. Installiamoci dentro un file system ext3 con il seguente comando:
# mkfs.ext3 -L minislack /dev/sda1
bene, quella che abbiamo appena creato sarà la directory radice della nostra distribuzione.
'''ATTENZIONE{{Hint|Suggerimento|Dalla Slackware 13.0 è possibile usare ext4:''' tutti # mkfs.ext4 -L minislack /dev/sda1}} {{Warning|Attenzione|Tutti i file sulla pennina saranno ovviamente persi dopo l'esecuzione del comando '''mkfs.ext3''', quindi facciamo in modo che la pennina sia vuota prima di lanciare il comandoo '''mkfs.ext4'''.}}
'''Nota{{Hint|Suggerimento|Per salvaguardare la salute della nostra pennina possiamo disattivare il journaling, che di default è attivo su questi filesystem, in modo da ridurre le scritture su disco:''' si noti l'uso dell'opzione # tune2fs -L per impostare un etichetta al file system appena creato, vedremo dopo a cosa ci servirà. L'etichetta del file system la si può impostareO ^has_journal /dev/modificare anche successivamente attraverso l'uso del comando '''e2label'''.sda1}}
{{Information
|Nota
|Si noti l'uso dell'opzione '''-L''' per impostare un'etichetta al file system appena creato, vedremo dopo a cosa ci servirà. L'etichetta del file system la si può impostare/modificare anche successivamente attraverso l'uso dei comandi '''e2label''' o '''tune2fs -L'''.
}}
=Fase 1: creazione dell'initrd=
Più in là nel wiki, vedremo come far caricare il kernel di linux installato su una pennina, qui invece ci apprestiamo ad affrontare Ora affronteremo un problema inerente proprio al fatto che la distribuzione si trova verrà a trovare su una periferica USB.
==Perché dobbiamo creare un initrd?==
Una volta caricato il kernel, esso si preoccupa di attivare tutti i driver che sono stati compilati in maniera statica al suo interno. L'attivazione avviene in maniera parallela, il kernel cioè non attiva un driver, aspetta che esso abbia finito di inizializzarsi e poi ne attiva un altro, ma li attiva tutti quanti "contemporaneamente". Dopo questa fase di inizializzazione dei driver il kernel deve montare quella che è la root directory (o directory radice) della distribuzione, (la famosa directory ''/''. Una volta montata la directory radice), e quindi esegue quello che sarà l'unico processo avviato direttamente dal kernel (che in generale è il processo '''/sbin/init''').Ma:* Ma i driver (o controller) USB potrebbero non essere stati compilati in maniera statica nel kernel, e senza i driver il kernel non si accorge neanche della presenza della pennina, come possiamo risolvere questo problema?;* Non solo, ma anche ammesso che il kernel abbia i driver compilati in maniera statica, questi statici devono comunque avere il tempo di accorgersi che al PC è collegata una pennina USB, come si può dire al kernel di aspettare visto che i driver sono attivati in maniera parallela?* Ancora, come facciamo a sapere su quale device si verrà a trovare la root directory radice? Il driver USB collegherà la pennina al device sda o sdb, oppure ad un altro?* E infine, la root directory radice che abbiamo creato sulla pennina usa il file system ext3(o ext4), il kernel per poter riconoscere e di conseguenza usare questo file system ha bisogno del driver, e se questo driver non è compilato in maniera statica?
Per tutti questi problemi esiste una soluzione unica, l'initrd. L'initrd fondamentalmente non è altro che una mini distribuzione la cui root directory radice viene montata in ram, più precisamente collegata al device ''/dev/ram0'', con . L'initrd contiene un programma o uno script (che si deve chiamare '''init''' o '''linuxrc''') che viene avviato dal kernel (il quale deve essere compilato con il supporto all'initrd) subito dopo aver inizializzato i driver. Il kernel in pratica non si occupa più di montare la root directory e di lanciare il processo '''/sbin/init''', ma semplicemente lancia il comando (o script) '''init''' che è nell'initrd e delega a lui tutto il resto.<BRbr />
Questo semplice meccanismo ci permette in pratica di creare uno script per risolvere tutti i problemi sopra citati.
 
'''Nota:''' Quando il kernel carica in memoria l'initrd e lancia il programma (o lo script) init, la root directory della nostra distribuzione non è ancora montata! Quindi la distribuzione non esiste, e con lei non esistono tutti i programmi usuali che uno pensa di usare nell'initrd. Se si vuole usare un programma, lo si deve copiare nell'ambiente dell'initrd e si devono copiare anche tutte quelle librerie condivise di cui il programma necessita.
==Initrd come archivio cpio==
Uno dei modi più semplici per creare un initrd è quello di inserire tutto il necessario in una directory vuota (programmi che si voglio vogliono usare nell'initrd, librerie di cui necessitano questi programmi, eventuali moduli del kernel, etc...etc...) e poi di creare un archivio cpio, magari compresso con gzip, di questa directory. Il kernel sarà poi in grado di decomprimere (se era compresso) l'archivio e di estrarne il contenuto.<BRbr />Creiamoci allora una la directory vuota ed entriamoci dentro conche conterrà il nostro initrd: # $ mkdir /tmp/initrd # cd /tmp/initrd
==Il pacchetto mkinitrd e la busybox==
Il pacchetto mkinitrd della Slackware (che si trova nella directory ''a/'') contiene lo script omonimo '''mkinitrd''', che generalmente viene usato da coloro che necessitano di un initrd e non vogliono (o non hanno le competenze adatte a) crearsene uno a mano.<BRbr />
Noi useremo il pacchetto, che quindi deve essere installato, non per lanciare l''''mkinitrd''' ma per prelevare il programma '''busybox''' che è al suo interno. Busybox è un programma che si può comportare in maniera diversa a seconda di come lo si invoca, se noi infatti creiamo un link simbolico chiamato mount a '''busybox''', allora questo si comporterà come '''mount'''. L'elenco di tutti i programmi che è in grado di simulare lo si può ottenere lanciando '''busybox''' senza parametri.
''/usr/share/mkinitrd/initrd-tree.tar.gz''
preleviamo la busybox con:
# $ tar -C /tmp/initrd -zxf /usr/share/mkinitrd/initrd-tree.tar.gz './bin/busybox'
a questo punto la nostra directory ''/tmp/initrd'' avrà questa struttura:
# <pre>$ tree /tmp/initrd /tmp/initrd `-- bin `-- busybox 1 directory, 1 file</pre> {{Be Careful|Nota per le Slackware dalla 13.1|A partire dalla Slackware 13.1, il comando '''busybox''' è linkato dinamicamente. Ciò vuol dire che necessita di alcune librerie in fase di esecuzione. Per scoprirle lanciamo:<pre>$ ldd /tmp/initrd/bin/busyboxldd busybox linux-gate.so.1 (0xffffe000) libm.so.6 => /lib/libm.so.6 (0xb776e000) libc.so.6 => /lib/libc.so.6 (0xb75e3000) /lib/ld-linux.so.2 (0xb77b6000)</pre>Copiamole nel nostro initrd:<pre>$ mkdir -p /tmp/initrd/lib$ cp /lib/lib{c,m}.so.6 /tmp/initrd/lib$ cp /lib/ld-linux.so.2 /tmp/initrd/lib</pre> Il nostro initrd sarà quindi:<pre>$ tree /tmp/initrd/tmp/initrd|-- bin/| `-- busybox*`-- lib/ |-- ld-linux.so.2* |-- libc.so.6* `-- libm.so.6* 2 directories, 4 files</pre>}}
==Creiamo lo script init==
Ora dobbiamo creare lo script '''init''', ovvero lo script che verrà eseguito dal kernel dopo l'inizializzazione dei driver e che è incaricato di risolvere i problemi su citati, cioè:
* caricare eventualmente i moduli del kernel per i controller USB e per il file system ext3/4;* dare il tempo ai controller USB di rilevare la pennina e montare, dopo averla scovata, la root directory;* eseguire il vero processo init della distribuzione. Prima di cimentarci nella risoluzione di questi problemi dobbiamo notare che '''init''', per come lo vogliamo utilizzare noi, è uno script, e in quanto tale ha bisogno di un interprete, la '''busybox''' può fare questo per noi visto che al suo interno ha anche una piccola shell: $ cd /tmp/initrd/bin $ ln -s busybox ashIniziamo quindi il nostro '''init''' in questo modo:<pre>$ cat <<EOF > /tmp/initrd/init#!/bin/ash
Prima di cimentarci nella risoluzione di questi problemi dobbiamo notare che '''init''', per come lo vogliamo utilizzare noi, è uno script, e in quanto tale ha bisogno di un interprete, la '''busybox''' può fare questo per noi visto che al suo interno ha anche una piccola shell. Andiamo nella directory ''/tmp/initrd/bin'' e creiamo un link simbolico a '''busybox''' in questo modo:EOF # ln -s busybox ashe quindi con un qualsiasi editor di testo creiamo il file ''/tmp/initrd/init'' e mettiamoci come prima riga: #!/bin</ashpre>
===Caricare i moduli del kernel necessari al rilevamento della periferica USB e del file system ext3/4===Il kernel huge della Slackware 12.0 è compilato con il supporto sia alle periferiche USB, sia al file system ext3 in maniera statica, e quindi . Questo ci permette di superare in maniera trasparente questo problema.<BRbr />
Si fa notare che il fatto di avere il supporto compilato in maniera statica nel kernel è un fattore da non sottovalutare. Infatti l'ambiente dell'initrd dovrebbe essere il più generale possibile, se spettasse all'initrd (e quindi allo script '''init''') caricare qualche modulo del kernel, allora l'initrd non sarebbe più indipendente, ma al suo interno dovrebbe avere i moduli compilati per il kernel specifico che lo ha eseguito.
 
{{Be Careful
|Nota per la Slackware 14.1
|Il kernel huge della Slackware 14.1 ha mantenuto statici i driver relativi ai filesystem (ext3 o ext4), ma quelli per i controller USB sono abilitati come moduli, quindi andranno aggiunti all'initrd come segue:
<pre>
$ mkdir -p /tmp/initrd/lib/modules/3.10.17/kernel/drivers/usb/{storage,host}
$ cp /lib/modules/3.10.17/kernel/drivers/usb/storage/usb-storage.ko \
/tmp/initrd/lib/modules/3.10.17/kernel/drivers/usb/storage
$ cp -r /lib/modules/3.10.17/kernel/drivers/usb/host/ \
/tmp/initrd/lib/modules/3.10.17/kernel/drivers/usb
$ cp /lib/modules/3.10.17/modules.dep* /tmp/initrd/lib/modules/3.10.17
</pre>
 
Questi moduli vanno anche caricati nell'ambiente dell'initrd. Abbiamo bisogno quindi, del comando '''modprobe'''. Fortunatamente '''busybox''' si comporta anche come '''modprobe''' se gli viene fatto un link simbolico con questo nome. Facciamolo:
$ cd /tmp/initrd/bin/
$ ln -s busybox modprobe
Ci basterà caricare il solo i moduli ehci-pci e usb-storage. Avendo copiato anche i file ''modules.dep*'' il kernel è in grado di risalire alle corrette dipendenze e caricherà per noi anche gli altri moduli (ove necessario). Aggiungiamo a '''init''' il comando per caricare i moduli:
<pre>
$ cat <<EOF >> /tmp/initrd/init
# Caricamento dei moduli usb.
modprobe ehci-pci
modprobe usb-storage
 
EOF
</pre>
 
Si noti come ora (nella Slackware 14.1) l'initrd non è più indipendente dal kernel che verrà installato nella pennina. Il kernel deve essere proprio il 3.10.17. Questo a mio avviso è un peccato.
}}
===Dare il tempo ai controller USB di rilevare la pennina e montaggio della root directory===
Abbiamo installato sulla nostra pennina USB un file system del tipo ext3 (o ext4) che abbiamo anche etichettato con il nome di 'minislack'. Bene, grazie alla capacità del comando '''mount''' di utilizzare il nome di etichetta per identificare un file system, il problema di conoscere il device al quale sarà collegato il file system può essere risolto semplicemente mettendo nello script '''init''' quanto segue: <pre>$ cat <<EOF >> /tmp/initrd/init# Rilevamento e montaggio del file system "minislack".mount -n proc -t proc /proc while ! mount -n -r -L minislack /mnt 2> /dev/null; do sleep 1 done umount -n /proc EOF</pre>Il "montaggio" del file system proc è necessario in quanto il comando '''mount''' fa uso di questo file system per scovare l'etichetta 'minislack'.<BRbr />
Il ciclo '''while''' con lo '''sleep''' non fa altro che dare il tempo necessario ai driver USB del kernel di rilevare la pennina.
Quindi la nostra root directory, o meglio il file system che noi abbiamo etichettato come 'minislack' sarà montato nella directory ''/mnt'' a prescindere dal device a cui il driver USB (e più precisamente il modulo che gestisce le periferiche di archiviazione di massa USB, l'usb_storage) lo ha collegatocollegherà.
Nelle sei righe di codice precedenti abbiamo:
* usato il comando mount;* caricato il file system proc nella directory /proc;* usato il device null per ridirigere lo standard error del comando mount;* usato il comando sleep per far attendere alla shell 1 secondo;* montato la root directory in /mnt;* utilizzato il comando umount.per quanto potevano possano sembrare innocenti, quelle sei righe implicano:* che il kernel al momento dell'esecuzione di queste righe, abbia il supporto al procfs e al tipo di file system della root directory che montiamo su ''/mnt'' (nel nostro caso il kernel huge ce li ha entrambi in maniera statica);* che esistano i programmi mount, umount e sleep;* che esistano il device ''/dev/null'' e quello al quale sarà collegata la pennina USB (è vero che mount può scovare il device grazie all'etichetta del suo file system, ma è altrettanto vero che poi '''mount''' dovrà montare questo device);* che esistano le directory ''/proc'' e ''/mnt''.
La '''busybox''' può comportarsi come '''mount''' semplicemente facendo un link simbolico ad essa chiamato appunto ''mount'', il problema è che quello fornito dalla '''busybox''' non è in grado di scovare le etichette dei file system (non riconosce il flag l'opzione '''-L'''). Abbiamo necessariamente bisogno del comando '''mount''' del pacchetto util-linux (dalla Slackware 12installato nel nostro sistema.1 e successive, il pacchetto si chiama util-linux-ng) contenutosempre nella directory della serie ''a/'' della Slackware.<BR>Copiamo quindi il comando '''mount''' come segue: # $ cp -p /bin/mount /tmp/initrd/bin
ora però dobbiamo copiare anche le librerie condivise di cui necessita. Vediamo quali sono lanciando:
# <pre>$ ldd /tmp/initrd/bin/mount linux-gate.so.1 => (0xffffe000) libblkid.so.1 => /lib/libblkid.so.1 (0xb7f80000) libuuid.so.1 => /lib/libuuid.so.1 (0xb7f7d000) libc.so.6 => /lib/libc.so.6 (0xb7e4e000) /lib/ld-linux.so.2 (0x80000000)</pre>
Creiamoci la directory ''lib'' all'interno del nostro initrd con:
# $ mkdir -p /tmp/initrd/lib
e copiamoci dentro le librerie condivise con:
# $ cp -p /lib/libblkid.so.1 /lib/libuuid.so.1 /lib/libc.so.6 /lib/ld-linux.so.2 /tmp/initrd/lib
Si noti che i file originali probabilmente sono link simbolici, ma il comando '''cp''' copierà il file al quale puntano e non il link.
<nowiki>** NOTA **</nowiki>{{Be Careful A partire |Nota per le Slackware dalla slackware 1314.1 il comando '''mount''' necessita di altre librerie0|Dalla Slackware 14.0 le dipendenze diventano: # <pre>$ ldd /bin/mount linux-gate.so.1 => (0xffffe0000xf771b000) /usr/lib/libv4l/v4l1compat libblkid.so (0xb7838000) /usr.1 => /lib/libv4l/v4l2convertlibblkid.so .1 (0xb78360000xf76b3000) libblkid libmount.so.1 => /lib/libblkidlibmount.so.1 (0xb77eb0000xf7687000) libuuid.so.1 => /lib/libuuid.so.1 (0xb77e70000xf7683000) libc.so.6 => /lib/libc.so.6 (0xb76830000xf74fe000) libv4l1.so.0 => /usr/lib/libv4l1.so.0 (0xb767e000) libv4l2.so.0 => /usr/lib/libv4l2.so.0 (0xb7674000) /lib/ld-linux.so.2 (0xb783b0000xf771c000) libpthread.so.0 => </lib/libpthread.so.0 (0xb765b000) libv4lconvert.so.0 =pre> /usr/lib/libv4lconvert.so.0 (0xb75ef000) librtCome si vede mount dipende anche da 'libmount.so.1 => /lib/librt.so.1 (0xb75e5000) libm.so.6 => /lib/libm.so.6 (0xb75bf000) Quindi sarà necessario copiare anche le nuove librerie' che va quindi copiata in questo modo: # $ cp -p /usr/lib/libv4l/v4l1compat.so /usr/lib/libv4l/v4l2convert.so /usr/lib/libv4l1.so.0 /usr/lib/libv4l2.so.0 /tmp/initrd/lib # cp -p /lib/libpthread.so.0 /usr/lib/libv4lconvert.so.0 /lib/librtlibmount.so.1 /lib/libm.so.6 /tmp/initrd/lib<nowiki>** FINE NOTA **</nowiki>}}
Per il comando i comandi '''umount''' e '''sleep''' invece possiamo tranquillamente usare quelli della '''busybox''', quindi andiamo nella directory '':<pre>$ cd /tmp/initrd/bin'' e facciamo: # $ ln -s busybox umount # $ ln -s busybox sleep</pre>
Il programma Nel nostro '''init''' abbiamo passato al comando '''mount''' l'abbiamo utilizzato passandogli anche il flag opzione '''-n''', dicendogli quindi di non scrivere quello che sarà il file ''/etc/mtab'', benché . Benché esso non lo scriva, vuole comunque leggerlo per controllare se il file system che si sta tentando di montare non sia già stato montato. Dobbiamo quindi creare il file vuoto ''/tmp/initrd/etc/mtab'': # <pre>$ mkdir /tmp/initrd/etc # $ touch /tmp/initrd/etc/mtab</pre>
Proseguiamo quindi con la creazione del device null e dei possibili device a cui sarà collegata la pennina USB. In generale la pennina USB viene vista come una periferica SCSI disk e quindi sarà attaccata ad un device del tipo ''/dev/sdXY'' dove X varia a seconda di quante periferiche di archiviazione rilevate come SCSI (ad esempio i dischi sata) sono state trovate prima della pennina, mentre Y rappresenta una qualsiasi partizione.<BRbr />Se, ad esempio, un PC non ha nessun disco rilevato come SCSI e ci si inserisce una pennina con tre partizioni, queste tre partizioni saranno collegate rispettivamente ai device: sda1, sda2 e sda3.Y la possiamo ricavare facilmente, infatti all'inizio abbiamo supposto che la nostra pennina avesse solo una partizione e che essa (la partizione) venisse attaccata ad device ''/dev/sda1'', allora Y=1 e la pennina sarà sempre collegata ad un device dal nome ''/dev/sdX1''.<br />
Y allora la possiamo ricavare facilmente, infatti all'inizio abbiamo supposto che la nostra pennina avesse solo una partizione e che essa (la partizione) venisse attaccata ad device ''/dev/sda1'', allora Y=1 e la pennina sarà sempre collegata ad un device dal nome ''/dev/sdX1''.<BR>Quindi creiamoci Creiamoci la directory in cui inserire i device: # $ mkdir /tmp/initrd/dev
e copiamoci subito dentro il device ''/dev/null'' con:
# cp -R /dev/null /tmp/initrd/dev
Al momento attuale gli SCSI disk sono gestiti dal device driver con major number 8. Questo device driver è in grado di gestire sino a 15 partizioni per ogni disco, questo vuol dire che due device con X consecutive e con uguale Y hanno una distanza (in termini di minor number) pari a 16. Ad esempio il device sda avrà un minor number uguale a 0 laddove il device sdb avrà invece minor number uguale a 16, e così via.
Possiamo allora creare i quattro device con(dovrebbero essere sufficienti): <pre># mknod /tmp/initrd/dev/sda1 b 8 1 # mknod /tmp/initrd/dev/sdb1 b 8 17 # mknod /tmp/initrd/dev/sdc1 b 8 33 # mknod /tmp/initrd/dev/sdd1 b 8 49</pre>
Ora per rendere tutto coerente con quanto scritto sempre nelle sei innocenti righe di codice inserite nel file ''init'', non ci resta che creare due directory vuote nelle quali verranno montati i file system proc e quello contenente la nostra directory radice.
# $ mkdir /tmp/initrd/proc /tmp/initrd/mnt
===Eseguire il vero processo init===
L'ultimo passo che deve eseguire lo script '''init''' dell'initrd è quello di lanciare il vero processo '''init''' situato nella directory radice della distribuzione e poi liberare la memoria allocata.<BRbr />
I passi teorici da eseguire sono:
* spostare la directory radice dell'initrd sulla directory radice della distribuzione;* smontare l'initrd;* deallocare la memoria allocata dal kernel per l'initrd;* eseguire il vero processo '''init'''.Che poi praticamentein pratica, dato che per ognuno dei passi precedenti esiste uno specifico programma che lo esegue, diventa:* cd /mnt; mkdir initrd; pivot_root . initrd;* umount /initrd;* blockdev --flushbufs /dev/ram0;* exec chroot . /sbin/init $@.
Il comando '''pivot_root''' ultimamente sembra non comportarsi bene nell'ambiente dell'initrd. Fortunatamente la '''busybox''' ha al suo interno un programma che dovrebbe eseguire tutti i passi precedenti, il comando si chiama '''switch_root ''' e come al solito quindi basta fare un link simbolico a '''busybox''' entrando in '':<pre>$ cd /tmp/initrd/bin''ed eseguendo: # $ ln -s busybox switch_root</pre>
Ora non resta che inserire nello script dire al nostro '''init quanto segue''' di eseguire '''switch_root''': <pre>$ cat <<EOF >> /tmp/initrd/init# Esecuzione del vero init.exec switch_root /mnt /sbin/init $@EOF</pre>
'''NOTA:''' si {{Information|Nota|Si noti il passaggio a '''/sbin/init''' dei parametri '''$@''', questi sono i parametri che il kernel non ha riconosciuto nella sua riga di comando (quella passatagli dal loader, generalmente '''lilo''' o '''grub'''), e che quindi passa al comando che esegue.}}
===Lo script init nella sua interezza===
Riassumendo, lo script ''/tmp/initrd/init'' è questo:
<PREpre>$ cat /tmp/initrd/init
#!/bin/ash
 # Aspetto finché i driver USB non rilevano la pennina Rilevamento e monto la vera directory radicemontaggio del file system "minislack".mount -n proc /proc -t proc /proc
while ! mount -n -r -L minislack /mnt 2> /dev/null;
do
sleep 1;
done
umount -n /proc
# Avvio il Esecuzione del vero /sbin/init.
exec switch_root /mnt /sbin/init $@
</PREpre>{{Be Careful|Nota per la Slackware 14.1|Sulla Slackware 14.1 lo script risulta:<pre>$ cat /tmp/initrd/init#!/bin/ash # Caricamento dei moduli usb.modprobe ehci-pcimodprobe usb-storage # Rilevamento e montaggio del file system "minislack".mount -n proc -t proc /procwhile ! mount -n -r -L minislack /mnt 2> /dev/null; do sleep 1 doneumount -n /proc # Esecuzione del vero init.exec switch_root /mnt /sbin/init $@</pre>}} 
questo script deve essere eseguito dal kernel è quindi dobbiamo assicurarci che abbia i diritti di esecuzione:
# $ chmod u+x /tmp/initrd/init
==Creazione dell'archivio cpio compresso initrd.gz==
La directory ''/tmp/initrd'' ora dovrebbe essere così strutturata:
# <pre>$ tree /tmp/initrd /tmp/initrd/ |-- bin | |-- ash -> busybox | |-- busybox | |-- mount | |-- sleep -> busybox | |-- switch_root -> busybox | `-- umount -> busybox |-- dev | |-- null | |-- sda1 | |-- sdb1 | |-- sdc1 | `-- sdd1 |-- etc | `-- mtab |-- init |-- lib | |-- ld-linux.so.2 | |-- libblkid.so.1 | |-- libc.so.6 | `-- libuuid.so.1 |-- mnt `-- proc 6 directories, 17 files</pre>{{Be Careful|Nota per le Slackware dalla 13.1|Per le Slackware dalla 13.1 ci sarà anche la libreria ''libm.so.6''. Per le Slackware dalla 14.0 ci sarà anche la libreria ''libmount.so.1''.}} {{Be Careful|Nota per la Slackware 14.1|Per la Slackware 14.1 la struttra sarà la seguente:<pre>$ tree /tmp/initrd /tmp/initrd/ |-- bin/ | |-- ash -> busybox* | |-- busybox* | |-- modprobe -> busybox* | |-- mount* | |-- sleep -> busybox* | |-- switch_root -> busybox* | `-- umount -> busybox* |-- dev/ | |-- null | |-- sda1 | |-- sdb1 | |-- sdc1 | `-- sdd1 |-- etc/ | `-- mtab |-- init* |-- lib/ | |-- ld-linux.so.2* | |-- libblkid.so.1* | |-- libc.so.6* | |-- libm.so.6* | |-- libmount.so.1* | |-- libuuid.so.1 | `-- modules/ | `-- 3.10.17/ | |-- kernel/ | | `-- drivers/ | | `-- usb/ | | |-- host/ | | | |-- ehci-hcd.ko | | | |-- ehci-pci.ko | | | |-- ehci-platform.ko | | | |-- hwa-hc.ko | | | |-- isp116x-hcd.ko | | | |-- isp1362-hcd.ko | | | |-- isp1760.ko | | | |-- ohci-hcd.ko | | | |-- oxu210hp-hcd.ko | | | |-- r8a66597-hcd.ko | | | |-- sl811-hcd.ko | | | |-- sl811_cs.ko | | | |-- ssb-hcd.ko | | | |-- u132-hcd.ko | | | |-- uhci-hcd.ko | | | |-- whci/ | | | | `-- whci-hcd.ko | | | `-- xhci-hcd.ko | | `-- storage/ | | `-- usb-storage.ko | |-- modules.dep | `-- modules.dep.bin |-- mnt/ `-- proc/ 14 directories, 40 files</pre>}} Non resta altro da fare che creare un archivio cpio di questa directory, comprimerla con il comando '''gzip''' e renderla disponibile al loader di linux.<BRbr />
Partendo dal solito presupposto che la pennina sia collegata dal kernel al device sda1, la si monti montiamola ad esempio nella directory ''/mnt/memory'' con:
# mount /dev/sda1 /mnt/memory
si crei e poi una creiao la directory in cui inserire l'archivio cpio compresso che è inseriremo l'initrd con:
# mkdir /mnt/memory/boot
ed infine si crei creiamo l'archivio cpio compresso (il tanto sudato initrd): <pre># cd /tmp/initrd # find . | cpio -o -R root: -H newc | gzip -9 -n > /mnt/memory/boot/initrd.gz</pre>
Quando, più in là nel wiki, si configurerà il loader di linux, si vedrà come utilizzare questo file.Intanto la nostra pennina dovrebbe avere una struttura simile a questa:<pre>$ tree /mnt/memory/mnt/memory|-- boot| `-- initrd.gz`-- lost+found
2 directories, 1 file
</pre>
=Fase 2: installazione della distribuzione sulla pennina=
Ora ci si occuperà occuperemo di installare e configurare una serie minimale ma importantissima di pacchetti Slackware.<BRbr />Ovviamente non ci sono limitazioni, se non quelle fisiche della pennina, al numero di pacchetti che il lettore può possiamo installare, ma per lo scopo di questo wiki è sufficiente installare i pacchetti essenziali a far partire la distribuzione.<BRbr />I pacchetti che verranno installati si trovano tutti nella directory ''a/'' della Slackware, quindi, supponendo che il CD o DVD della Slackware sia stato montato nella directory ''/mnt/dvd/'', per prima cosa ci si deve dobbiamo spostare dentro questa directory con: # $ cd /mnt/dvd/slackware/a
==Un piccolo accorgimento==
I Installeremo i pacchetti verranno installati sfruttando l'opzione -root dello script '''installpkg''', alcuni dei pacchetti hanno uno script aggiuntivo, il famoso chiamato '''doinst.sh''', che viene avviato dopo l'installazione del pacchettostesso. Gli Questo script '''doinst.sh''' sono "chrootati" sulla pennina e devono poter eseguire inoltre esegue comandi, quali ad esempio '''cd''', '''rm''' o'''ln'''. Questo implica che:* il programma lo script '''doinst.sh''' deve essere "chrootato" sulla pennina;* i comandi che il '''doinst.sh''' vuole vorrà eseguire deve devranno essere presente sulla pennina;* si abbiano i diritti di esecuzione sulla pennina.
La prima implicazione è risolta usando l'opzione '''--root''' di '''installpkg'''. La seconda installando i pacchetti in un ordine ben preciso, facendo in modo di installare prima i pacchetti che contengono i programmi comandi usuali usati dai '''doinst.sh'''. La seconda terza implicazione viene verificata se si esegue un piccolo accorgimento, ovvero smontare la pennina e rimontarla con l'opzione '''exec' del '' di '''mount''', in questo modo:
# umount /mnt/memory
# mount -o exec -rw -t ext3 /dev/sda1 /mnt/memory
==I pacchetti da installare==
La domanda è semplice, come si determinano i pacchetti che si devono installare?<BRbr />La risposta non è altrettanto semplice, sicuramente ci sarà il programma ''/sbin/init'' per avere un collegamento all'initrd creato nella 'Fase 1', ma poi? Poi bisogna seguire l''''init''' e capire cosa esegue, in modo da fargli trovare i programmi comandi che tenta di eseguire. Se è necessario, bisogna anche seguire i programmi comandi che '''init''' esegue per capire cosa fanno e se hanno bisogno di altri programmi comandi o file di configurazione.<BRbr />In generale quindi, il primo file da analizzare è ''/etc/inittab'', file di configurazione di '''init''', ci . Ci si accorge quindi che '''init''' esegue una serie di script di inizializzazione, e quindi bisogna seguire questi script per capire cosa fanno.
Per lo scopo di questo wiki il lavoro è stato già fatto dall'autore e quindi verranno segnalati solo i passi fondamentali da fare affinché la distribuzione possa partire.
Qui si riporta l'elenco dei pacchetti che devono essere installati nell'ordine di seguito riportato (l'ordine è importante solo per i primi tre sette pacchetti). Accanto al nome del pacchetto vi è una piccola descrizione di cosa contiene: <pre>a/aaa_base - --> Crea tutte le directory base a/coreutils -aaa_elflibs --> Programmi utilizzati dagli script '''doisnt.sh''' a/glibc-solibs ---> La libreria glibc, usata da molti eseguibili (tra cui '''init''')Libreria libtermcap per i terminali a/glibc-zoneinfo aaa_terminfo ---> Contiene lo script '''timeconfig''' che verrà usato in seguito a/dialog ---> Usato per visualizzare i box dei dialoghi da altri programmiFile di informazione sui terminali usati dalla libreria libtermcap (tra cui '''timeconfig''') a/bash -etc --> La shell a/etc ---> File di configurazione dei programmi utilizzati a/util-linux -coreutils --> Contiene, tra l'altro, il programma '''mount'''. Dalla Slackware 12.1 in poi, il pacchetto si chiama util-linux-ng a/sysvinit ---> Contiene il programma '''init''' a/sysvinit-scripts ---> I famosi Programmi utilizzati dagli script '''rcdoisnt.d''' della Slackware, invocati da '''initsh''' a/module-init-tools glibc-solibs --> '''modprobe''' e altri programmi per gestire i moduli a/e2fsprogs ---> Comandi per i filesystem ext2/3 a/devs ---> I deviceLa libreria glibc, senza di questi.... a/findutils ---> usata da molti eseguibili (tra cui '''findinit''', usato dagli script di inizializzazione) a/aaa_elflibs glibc-zoneinfo --> Libreria libtermcap per i terminali a/aaa_terminfo ---> File di informazione sui terminali usati dalla libreria libtermcap a/shadow ---> Contiene, tra l'altro, i programmi '''login''' e '''sulogin''' a/grep ---> '''grep''', usato dagli lo script di inizializzazione a/procps ---> '''pstimeconfig''', che verrà usato dagli script di inizializzazione a/kernel-huge ---> Il kernel... a/kernel-modules ---> ... i suoi moduliin seguito
<nowikia/bash --> La shella/devs --> I device, senza di questi....a/dialog --> Crea box di dialogo. Utilizzato da '''timeconfig''' (che vedremo dopo)a/e2fsprogs --> Comandi per i filesystem ext2/3/4a/findutils --> '''find''', usato dagli script di inizializzazionea/grep --> '''grep''', usato dagli script di inizializzazionea/gzip --> usato da '''loadkeys'''a/kbd --> '''loadkeys''' per tastiere non US. Non strettamente necessario ma utilea/kernel-huge --> Il kernel...a/kernel-modules --> ... i suoi modulia/module-init-tools --> '''modprobe''' e altri programmi per gestire i modulia/procps --> '''ps''', usato dagli script di inizializzazionea/shadow --> Contiene, tra l'altro, i programmi '''login''' e '''sulogin'''a/sysvinit --> Contiene il programma '''init'''a/sysvinit-scripts --> I famosi script '''rc.d''' della Slackware, invocati da '''init'''a/util-linux -->** NOTA ** Contiene, tra l'altro, il programma '''mount'''</nowikipre>
A partire da slackware 13{{Be Careful|Nota per le Slackware dalla 14.1 è necessario anche il seguente pacchetto0|Per le Slackware dalla 14.0 non troveremo module-init-tools, ma al suo posto: la/v4l-utils -kmod --> Librerie necessarie ai programmi di sistema (ad es: '''mountmodprobe''')e altri programmi per gestire i moduli}}
<nowiki>** FINE NOTA **<Per installare questi pacchetti si deve eseguire '''installpkg''' con l'opzione '''-root''' ''/nowiki>mnt/memory'', ad esempio: # installpkg -root /mnt/memory aaa_base-12.0.0-noarch-1.tgz
Per installare questi pacchetti si deve eseguire '{{Hint|La simpatica storia del pacchetto util-linux|Il pacchetto ''installpkg''' con l'opzione util-root linux'ha cambiato nome in '/mnt/memory'', ad esempio: # installpkg util-root /mnt/memory aaa_baselinux-ng' a partire dalla Slackware 12.01 sino alla 13.0-noarch-1.tgzPer poi tornare a chiamarsi 'util-linux' dalla Slackware 13.37.}}
==Una facile configurazione==
Come per la domanda 'Quali pacchetti si devono installare?', così la risposta alla domanda 'Cosa si deve configurare?' dipende sempre dall'amministratore del sistema e da cosa esso intenda far eseguire all'avvio della macchina.<BRbr />
Nel wiki si intende lasciare intatti gli script di inizializzazione fatti da Patrick J. Volkerding, creatore della Slackware, e quindi si procederà nella minima configurazione necessaria proprio a questi script di inizializzazione.
===/etc/fstab===
Si comincia con il creare Cominciamo creando il file ''/etc/fstab'' come segue: <pre># echo -e "cat <<EOF > /mnt/memory/etc/fstabLABEL=minislack\t\t /\text3\trw\t1 ext3 rw,noatime 0 1" EOF</pre>Nel caso si abbia scelto di usare file system ext4 , il comando diventa:<pre># cat <<EOF > /mnt/memory/etc/fstabLABEL=minislack / ext4 rw,noatime 0 1EOF</pre>
===/etc/hardwareclock===
Un altro file richiesto dagli script di inizializzazione della Slackware è il file ''/etc/hardwareclock'' che indica come è impostato l'orologio hardware. In effetti questo file non contiene granché, ma viene consigliato di editarlo/crearlo tramite lo script '''/usr/sbin/timeconfig''', . Eseguiamo quindi bisogna eseguire lo script spostandogli la "chrootandolo" nella directory root, in questo modo:
# cd /mnt/memory
# chroot . usr/sbin/timeconfig
===La tastiera italiana===
Benché non strettamente necessario, è utile poter utilizzare direttamente la tastiera italiana nella console di avvio. Quindi aggiungiamo al file ''/etc/rc.c/rc.local'' il comando '''loadkeys''':
<pre>
# cat <<EOF >> /mnt/memory/etc/rc.d/rc.local
loadkeys it
EOF
</pre>
=Fase 3: impostare il boot loader e testare il tutto=
L'ultima cosa da fare è quella di rendere la pennina "bootabile", ovvero di inserire nel suo primo settore, il famoso settore di boot. Per fare questo basta creare un file ''lilo.conf'' ad-hoc, e poi lanciare LILO '''lilo''' passandogli il file appena creato.<BRbr />Si crei Creiamo quindi il file, ad esempio ''/mnt/memory/etc/lilo.conf'', direttamente sulla pennina in modo che rimanga con essa, con all'interno quanto segue:<PREpre># cat <<EOF > /mnt/memory/etc/lilo.conf
boot = /dev/sda
backup = ""
image = /mnt/memory/boot/vmlinuz
initrd = /mnt/memory/boot/initrd.gz
EOF</PREpre>
Si noti l'opzione 'initrd', con la quale si indica al kernel che deve usare l'initrd creato nella 'Fase 1'. Ora non resta quindi che lanciare LILO come segue:
# lilo -C /mnt/memory/etc/lilo.conf
smontare la pennina: # umount /mnt/memorye riavviare il PC facendogli fare il boot dalla pennina USB.<BRbr />
Con la configurazione minimale che si è fatta nella 'Fase 2', basta, al momento del login, inserire l'username di 'root' per avere una shell con tutti i privilegi del super-utente.
{{Warning=Esempi d|Attenzione|Se al riavvio ci capitasse di notare l'uso=errore:Una volta hwclock: Cannot access the Hardware Clock via any known method.vuol dire che si ha una pennina USB "bootabile", con stranamente, ci manca il device per accedere all'interno un intera distribuzione, serve solo la fantasia per farci quello che ci pareorologio hardware.<BR>Esempi d'uso potrebbero essere quello di crearsi una distribuzione adatta alla lettura di contenuti multimedialiLo possiamo copiare, in questo modo basta trovare un PC per vedere un DVD o ascoltare della musica, senza preoccuparsi che il PC sia dotato di tutti i programmi o codec adatti.: # cp -r /dev/rtc0 /mnt/memory/dev/Un altro esempio è che si ha sempre a portata di mano un "disco di ripristino". Se la distribuzione installata sul PC Questo errore non dovesse partire perché ci succede se si è divertiti un poinstalla il pacchetto 'udev' troppo con i file di configurazione, si può sempre fare il boot del PC con la pennina e provvedere a rimediare agli eventuali danni che si è combinatimenzionato nell'[[#A: altri pacchetti utili|Appendice A]].}}
=Appendice=
==A: altri pacchetti utili==
Se si vuole rendere la distribuzione che si è installata sulla pennina un po' più indipendente, bisogna essere in grado di manipolare i pacchetti della Slackware, non . Non solo, ma sarebbe anche carino poter utilizzare tutta una serie di comandi utili ad un sistemista. Quindi, oltre all'insieme minimo di pacchetti menzionati nella sezione
'[[#I_pacchetti_da_installare|I pacchetti da installare]]', qui di seguito c'è un elenco dei pacchetti che rendono la distribuzione sulla pennina, più user-friendly:
<pre>a/pkgtools ---> Per gestire i pacchetti della Slackware a/bin ---> Usato dagli script di pkgtools a/sed ---> Usato dagli script di pkgtools a/gzip ---> Usato dagli script di pkgtools a/tar ---> Usato dagli script di pkgtools a/xz ---> Usato dagli script di pkgtools per il nuovo formato '.txz' della Slackware 13  ap/man ---> Il comando man più tornare molto utile ap/man-pages ---> Le pagine di manuale di molti comandi ap/groff ---> Il formattatore usato da man a/cxxlibs ---> Libreria c++ standard usata da groff a/less ---> Il comando che man usa per visualizzare le pagine di manuale
ap/man --> Il comando man più tornare molto utileap/man-pages --> Le pagine di manuale di molti comandiap/groff --> Il formattatore usato da mana/udev cxxlibs --> Libreria c++ standard usata da groffa/less --> Utile se si vogliono usare driver Il comando che necessitano man usa per visualizzare le pagine di firmwaremanuale
apa/nano -udev --> Il famoso e semplice editor Utile se si vogliono usare driver che necessitano di testofirmware
aap/bzip2 nano ---> Sempre più spesso si trovano archivi bzip Il famoso e semplice editor di testo
a/reiserfsprogs -bzip2 --> Per gestire il famoso file system reiser Sempre più spesso si trovano archivi bzip
a/reiserfsprogs --> Per gestire il famoso file system reiser
</pre>
=Ringraziamenti=
Ringrazio ZeroUno per i suoi consigli e le sue prove.
Note per slackware Slackware 13.1 a cura di [[Utente:Ansa89|Ansa89]].
Integrazioni per Slackware 13.37, 14.0 e 14.1, ext4 e tune2fs a cura di sya54M.
Per qualsiasi cosa scrivetemi pure:<BRbr />[[Utente:targzetaTargzeta|targzetaTargzeta]]([[Discussioni utente:Targzeta|discussioni]]) 22:50, 30 nov 2013 (CET)