The book

Transcript

The book
The book
Nicola Corriero - Eustrat Zhupa
Indice
I
Primo Avvio
1
1 Download
2
2 How to
3
2.1
Kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3
2.2
Hard Disk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.3
Grub . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4
2.4
Bash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5
2.5
How To . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6
3 Whys
7
3.1
7
Kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.1.1
Configurazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
11
3.1.2
Componenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
12
Hard Disk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
15
3.2.1
Problems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
18
3.3
BootLoader - Grub . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
19
3.4
Bash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
21
3.5
Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
22
3.5.1
24
3.2
Configurazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4 FAQ
25
4.1
Kernel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25
4.2
Hard disk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
4.3
Grub . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
4.4
Bash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
26
I
II
Shell
27
5 Download
28
6 How to
29
6.1
Coreutils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
6.2
e2fsprogs
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
29
6.3
Util-Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
30
6.4
Startup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
32
III
Emacs
37
7 Download
38
II
Parte I
Primo Avvio
Capitolo 1
Download
Il seguente è un elenco esaustivo delle componenti da scaricare dalla rete e necessarie per la creazione della distribuzione in questione. Si suggerisce di scaricare i sorgenti all’interno della cartella
/usr/src della distro ospite e scompattare i sorgenti ognuno in una propria cartella. A tal proposito
si suggerisce la creazione di uno script in bash per automatizzare il tutto.
#! /bin/sh
for i in *.tar.gz;
{
tar xvf $i
}
for j in *.tar.bz2;
{
tar xjvf $j
}
Salviamo il file in scompatta.s e dopo aver reso eseguibile lo script tramite il comando chmod
+x scompatta.s. Il risultato sarà la creazione per ogni file all’interno della cartella di esecuzione
dello script di una cartella contenente la decompattazione del file sorgente.
• Scaricare i (file) sorgente del kernel dal sito http://www.kernel.org/pub/linux/kernel/
• Scaricare i sorgenti dal sito ftp://alpha.gnu.org/gnu/grub/grub-0.97.tar.gz
• Scaricare i sorgenti dal sito http://ftp.gnu.org/gnu/bash/
2
Capitolo 2
How to
2.1
Kernel
1. Aprire la cartella /usr/src/Linux-source-{ versione }
2. Lanciare la configurazione del kernel tramite uno dei comandi
• make menuconfig
• make xconfig
• make qconfig
3. Includere nel kernel, non come moduli, le componenti relative al riconoscimento delle perifiche
usb o sata
4. Includere nel kernel le componenti relative ai filesystem ext e alle perifiche di input come
mouse e tastiera1
5. Salvare la configurazione appena creata (di default nel file .config)
6. Lanciare il comando make
7. Lanciare il comando make bzImage
8. Lanciare il comando make modules
1 Si
veda la sezione Whys per un esempio di selezione moduli
3
2 – How to
2.2
Hard Disk
1. Procurarsi una hard disk rimovibile usb di almeno 1 gb (consigliate 2 gb).
2. Avviare Linux e collegarlo al pc
3. Entrare nella shell
4. Lanciare il comando cfdisk /dev/sda (sdb o sdc o ... nel caso siano presenti altre periferiche
usb o sata)
5. Creare una partizione delle dimensioni desiderate di tipo Linux (83).
6. Confermare i cambiamenti effettuati tramite la scrittura sul disco.
7. Uscire da cfdisk
8. Lanciare il comando mkfs.ext2 /dev/sda1 (mkfs.ext3) per creare una filesystem sul hard
disk rimovibile
9. Creare la cartella come punto di montaggio /mnt/hd
10. Montare l’hd appena formattato tramite mount -t ext2 /dev/sda1 /mnt/hd
11. Entrare nella cartella /mnt/hd
12. Creare alcune cartelle tramite il comando mkdir bin boot etc dev lib sbin boot/grub
lib/tls tmp var
13. Entrare nella cartella dev e lanciare il seguente comando
mknod console c 5 1
2.3
Grub
1. Entrare nella cartella /usr/src/grub-0.97
2. Lanciare la verifica della configurazione tramite lo script ./configure
3. Lanciare il comando make per la compilazione del codice sorgente
4. Verificare la presenza dei file stage1 e stage2 nella cartella
5. Entrare nella sottocartella /usr/src/grub-0.97/grub
6. Verificare la presenza dell’eseguibile chiamato grub
4
2 – How to
7. Copiare all’interno della cartella boot/grub dell’hard disk rimovibile i file stage1 e stage2
presenti nella cartelle /usr/src/grub-0.97/{ stage1 - stage2}
8. Copiare i file ∗ stage1 5 dalla cartella ./grub-0.97/stage2 alla cartella /mnt/hd/boot/grub
9. Avviare grub tramite il comando grub da digitare nella shell di comando
10. Lanciare il comando root ( e tramite il tasto TAB verificare le possibiltà
11. Dovrebbero essere almeno 2 uno per l’hard disk su cui è attualmente installato Linux, l’altro
per l’hard disk rimovibile su cui stiamo installando Linux. In particolare saranno visualizzati
anche le partizioni presenti con i relativi filesystem
12. Scegliamo il secondo hard disk, cioè l’hard disk rimovibile (il comando sarà qualcosa simile
a root (hd1,0) )
13. Lanciamo il comando setup (hd1) si noti che non è necessario specificare la partizione
14. Se tutto è ok, possiamo lanciare il comando quit per uscire dal grub.
2.4
Bash
1. Entrare nella cartella /usr/src/bash-3.2
2. Lanciare il comando ./configure per verificare la configurazione del sistema
3. Lanciare il comando make per compilare i sorgenti
4. Verificare la presenza dell’eseguibile bash nella cartella
5. Entrare nella cartella /usr/src/{ linux-source - versione}/arch/i386/boot
6. Copiare il file bzImage qui presente nella cartella boot dell’hard disk rimovibile cambiando il
nome in vmlinuz tramite il comando cp bzImage /mnt/hd/boot/vmlinuz
7. Copiare l’eseguibile di bash compilato nella cartella bin dell’hard disk rimovibile
8. Entrare nella shell
9. Posizionarsi nella cartella dove è presente l’eseguibile bash
10. Lanciare il comando ldd ./bash
11. Verranno visualizzate un elenco di librerie necessarie per l’esecuzione di bash ciascuna con il
proprio PATH.
5
2 – How to
12. Copiare tutte le librerie rispettando il PATH sull’hard disk rimovibile.
13. Entrare nella cartella /bin dell’hard disk rimovibile
14. Creare un link simbolico a bash tramite il comando ln -s bash sh
2.5
How To
1. Spegnere il pc
2. Inserire l’hard disk rimovibile
3. Avviare il pc
4. Entrare nel Bios (solitamente i tasti per accedervi sono DEL o F12 o F2)
5. Entrare nel menu Boot
6. Verificare la presenza del proprio hard disk rimovibile tra i dischi rigidi e impostare la priorità
di boot come primaria per l’hd stesso
7. Nel caso in cui l’hd non sia presente tra i dischi rigidi impostare come primo dispositivo di
boot le periferiche rimovibili seguite dagli hard disk.
8. Salvare le modifiche ed uscire dal bios (solitamente tramite F10)
9. Attendere l’avvio del pc dall’hard disk rimovibile
10. Verrà mostrato la riga di comando del grub
11. Lanciare il comando root(hd0,0)
12. Lanciare il comando kernel con i parametri
kernel /boot/vmlinuz root=/dev/sda1 rootdelay=10 init=/bin/bash
13. Lanciare il comando boot
6
Capitolo 3
Whys
3.1
Kernel
Tutte le componenti del sistema operativo Linux hanno il codice sorgente aperto e disponibile per
la consultazione e la compilazione.
Il codice sorgente del kernel di Linux è depositato sul sito www.kernel.org. Su questo sito è possibile scaricare qualsiasi versione del kernel a partire dalla 1.0 datata 1994 e di soli 1,2 mb. Per
ogni versione sono disponibili i codici sorgenti, eventuali patch applicabili su di essi, un file per
ogni release in cui sono contenute le differenze rispetto la precedente. La versione attuale è la
2.6. Le sue dimensioni sono di circa 50 mb. La gestione delle release avviene tramite l’uso della
punteggiatura. L’importanza del dominio va da sinistra a destra. Con la versione attuale è stato
deciso di aumentare il numero di livelli di dominio e portarli a 4. L’ultima versione sarà la 2.6.24.3.
Qualsiasi cosa presente su questo sito scaricabile è fornita in due tipi di compressione la bz2 e la
gz. Il codice del kernel presenta un’ulteriore compressione, applicata prima di queste ultime, la tar.
Le compressioni sono in formato tipico per ambienti Linux. Per questioni puramente di semantica
delle cartelle sarebbe opportuno scaricare e decomprimere il codice appena scaricato all’interno
della cartella /usr/src, la quale rappresenta di default la cartella contenente il codice scaricato
dall’utente all’interno del filesystem Linux. Si veda la man page per la sintassi e semantica dei
comandi da usare per questa sezione quali ad esempio tar.
La configurazione del kernel è la parte più importante e problematica. Il kernel è composto da
tante componenti. Alcune di queste sono parte integrante e necessaria. Per tante altre, invece,
si ha sia la possibilità di includerle direttamente, facendole quindi diventare parte integrante,
sia di implementarle come moduli da includere nel kernel quando questo è già in esecuzione.
La procedura di compilazione del kernel è preceduta dalla configurazione dello stesso tramite un
7
3 – Whys
qualsiasi ambiente di configurazione. Per poter entrare in uno di questi ambienti è necessario
andare sulla shell, entrare all’interno della cartella in cui si è scompattato il codice sorgente del
kernel, e lanciare uno di questi comandi:
make menuconfig
Tool di configurazione basato su menu testuale.
make xconfig
Tool di configurazione basato su librerie QT.
make gconfig
Tool di configurazione basato su librerie GTK+.
make oldconfig
Aggiorna la configurazione corrente del kernel
usando il file .config corrente e chiedendo conferma
per ogni nuova opzione aggiunta al kernel.
make silentoldconfig
Come oldconfig, ma non stampa nulla su schermo
tranne quando una questione ha bisogno di una risposta.
make defconfig
Tool di configurazione che usa le risposte presenti
nel file /$ARCH/defconfig. per tutte le opzioni.
make allyesconfig
Genera una nuova configurazione del kernel
nel quale tutte le opzioni sono impostate a yes.
make allmodconfig
Genera una nuova configurazione del kernel nel
quale i moduli sono attivati dove possibile.
make allnoconfig
Genera una nuova configurazione del kernel nel
quale tutte le opzioni sono impostate a no.
make randconfig
Genera una nuova configurazione di kernel con
risposte casuali a tutte le differenti opzioni.
In questi ambienti si ha la possibilità di scegliere per ogni componente tra le tipologie. Y
(include nel kernel quella componente come parte integrante); M (compila la componente come
modulo inizialmente esterno al kernel); N (non specifica niente su quella componente ossia non
la compila). La differenza tra gli ambienti è di tipo grafico. I primi tre comandi permettono di
accedere ad un’interfaccia grafica in cui tramite una vista ad albero si ha la possibilità di scegliere
l’opzione da attivare per ogni componente del kernel. Ognuna di queste interfacce utilizza delle
librerie particolari, quindi è probabile che il tentativo di eseguire uno di questi comandi non vada
a buon fine per la mancanza all’interno del proprio sistema di alcune librerie o programmi necessari. In tal caso si può tentare di esaudire le richieste dell’interfaccia installando le librerie o i
programmi o di optare per un altro ambiente di configurazione. L’ultimo comando, invece, fornisce
la possibilità di configurare le componenti tramite un’interfaccia di tipo testuale molto semplice
e poco personalizzabile dall’utente per la presenza di molte scelte di default che l’utente non può
modificare.
Quando si lancia il comando per la configurazione, vengono eseguiti dei controlli e delle verifiche
8
3 – Whys
del sistema al fine di accertarsi la presenza delle librerie e dei programmi necessari per poter eseguire la configurazione e successivamente la compilazione del kernel stesso. Nei prossimi paragrafi
saranno presentati alcuni errori comuni per ogni tipologia di configurazione scelte con le relative
soluzioni.
Il comando make è uno dei più importanti dell’intero sistema Linux. Esso, infatti, è il responsabile della compilazione del codice. É possibile compilare un singolo file o programma o un’intera
gerarchia di file come nel caso dei sorgenti di Linux. Per poter essere eseguito, make necessita di
alcune regole di compilazione. Queste regole sono scritte nel makefile e di solito sono generate dallo
script che precede la compilazione chiamato configure. Nel kernel, in particolare, oltre al makefile
si ha la necessità di leggere ciò che è scritto nel .config che è il file generato dalla configurazione del
passo precedente e che contiene informazioni circa ogni componente del kernel. Il comando make
quindi leggendo dal makefile e dal .config compila ricorsivamente il codice C presente nei sorgenti.
Le figure che seguono illustrano come si presenta l’esecuzione dei diversi comandi utili alla configurazione del kernel.
Figura 3.1.
Schermata comando config
Compilazione. Il comando make bzImage ha l’obiettivo di creare un eseguibile del kernel
bzImage, collocato nella cartella /usr/src/Linux-source/arch/i386/boot/ e compresso tramite il
formato bz. Nei vecchi kernel era presente solamente il formato zImage solo che per la scarsa
capacità di questo formato a gestire kernel di grosse dimensioni e dal momento che con il passare del tempo i kernel stanno inglobando moduli sempre più voluminosi si è pensato di usare un
9
3 – Whys
Figura 3.2.
Figura 3.3.
Schermata comando menuconfig
Schermata comando xconfig
formato di compressione più efficiente. Il kernel compresso in fase di esecuzione si decomprime
automaticamente.
Compilazione dei moduli. La compilazione dei moduli è altrettanto importante in quanto ci
fornisce la possibilità di avere a disposizione tutti le componenti del kernel che in fase di compilazione abbiamo scelto di compilare come moduli e di usarli inserendoli nel kernel già in esecuzione.
10
3 – Whys
Figura 3.4.
Schermata comando gconfig
Se necessario dopo la compilazione è utile lanciare il comando make modules install il quale avrà
come output la creazione della cartella /lib/modules/{versione − del − kernel} al cui interno sarà
presente l’albero dei moduli appena compilati.
3.1.1
Configurazione
La configurazione del kernel è alla base di tutto il lavoro utile per la realizzazione della distro.
A questo proposito ci si soffermi sull’importanza della scelta di includere alcuni moduli piuttosto
che altri: oltre alla scelta del processore per un’ottimizzazione del kernel, alla disattivazione di
funzioni di cui non si necessita , alla scelta del dispositivo adatto per il funzionamento corretto
delle unità disco IDE e all’attivazione del supporto per i file system presenti e cosı̀ via, ci sono delle
opzioni, apparentemente nascoste, che invece possono essere molto più importanti di quanto non
si possa credere. Cambiando postazione ospitante, da una portatile ad una fissa, ci si accorge che
mentre il mouse e/o la tastiera prima funzionavano perfettamente, ora il pc, che ha le periferiche
stesse collegate tramite porta PS/2, non le riconosce assolutamente. Il tutto inizialmente può
sembrare strano, ma cosı̀ non è, infatti è sufficiente andare a ricercare all’interno dell’ambiente di
configurazione del kernel la voce riguardante i collegamenti del mouse e la tastiera e includerle nel
kernel. Un semplice riavvio del kernel permette di notare che tutti i dispositivi ora collegati al
pc funzionano perfettamente. Questo appena riscontrato è un semplice caso che però può essere
esteso a una qualsiasi altra componente hardware del pc. In parole povere spesso la causa di
problemi di natura hardware del computer risiede nel kernel, o meglio nella sua configurazione.
11
3 – Whys
Una volta raggiunta una configurazione accettabile si può pensare di migliorare il kernel stesso
seguendo questi tre punti:
• SNELLIRE. Il kernel standard fornito con i CD di installazione è un modello universale adatto
un pò per tutti i computer e tutti i componenti hardware, ma contenente una sovrabbondanza
di accessori inutili per il caso specifico. Ricompilandolo, si eliminano i driver relativi a
dispositivi che non sono presenti nel vostro computer e quindi il kernel occupa meno spazio
in memoria. Lo spazio liberato diventa disponibile per eseguire altri programmi.
• OTTIMIZZARE. Il kernel può essere impostato in modo da sfruttare le caratteristiche specifiche del vostro particolare modello di processore, consentendo elaborazioni più rapide ed
efficienti.
• AGGIORNARE. Periodicamente il kernel di Linux viene aggiornato per perfezionarlo o consentirgli di gestire nuovi componenti hardware. La ricompilazione serve per includere questi
aggiornamenti nella vostra installazione senza dover reinstallare tutto il sistema operativo.
3.1.2
Componenti
Solitamente nelle distro Linux si usa una initrd da passare tramite Grub all’avvio del sistema
operativo.
Per poter eseguire il boot, il kernel deve arrivare a montare il filesystem radice.
Se si usa un initrd, il kernel carica prima un file initrd e lo monta nella RAM come RAM disk.
L’initrd contiene essenzialmente i moduli del kernel necessari a montare il filesystem radice ed
uno o più script che caricano questi moduli e quando è possibile montano il vero filesystem radice
ed eseguono il programma init, che completerà l’avvio del sistema operativo.
I moduli fondamentali che un’initrd passa al kernel sono quelli relativi ai driver necessari al
funzionamento del dispositivo in cui è presente il file system radice, ad esempio IDE o SCSI o USB.
Per precisa scelta progettuale legata alla scarsa possibilità di personalizzazione dell’initrd, si è
optati per la creazione di un kernel contenente i moduli necessari all’avvio senza quindi, utilizzare
l’in initrd stesso.
Questa scelta rende la fase di configurazione del kernel molto importante. I moduli fondamentali
da includere sono quelli relativi come detto ai device di memorizzazione e al filesystem.
• Sezione Device Driver
– SCSI device support
– Serial Ata and Parallel Ata drivers
12
3 – Whys
– Usb Support
• Sezione File Systems
– Scegliere il filesystem da utilizzare (consigliato ext3)
– Scegliere il supporto per eventuali filesystem Windows (NTFS,VFAT)
• Sezione Processor Type and features
– Processor Family
Esiste un comando che elenca i dispositivi collegati tramite la porta pci. In questo esempio di
esecuzione del comando si ha un’idea dell’importanza di tale comando.
debian:~# lspci
0000:00:00.0 Host bridge: Intel Corporation 915G/P/GV/GL/PL/910GL Processor to I/O Controller (rev 0e)
0000:00:02.0 VGA compatible controller: Intel Corporation 82915G/GV/910GL Express Chipset
Family Graphics Controller (rev 0e)
0000:00:1d.0 USB Controller: Intel Corporation 82801FB/FBM/FR/FW/FRW (ICH6 Family) USB UHCI #1 (rev 04)
0000:00:1d.1 USB Controller: Intel Corporation 82801FB/FBM/FR/FW/FRW (ICH6 Family) USB UHCI #2 (rev 04)
0000:00:1d.2 USB Controller: Intel Corporation 82801FB/FBM/FR/FW/FRW (ICH6 Family) USB UHCI #3 (rev 04)
0000:00:1d.3 USB Controller: Intel Corporation 82801FB/FBM/FR/FW/FRW (ICH6 Family) USB UHCI #4 (rev 04)
0000:00:1d.7 USB Controller: Intel Corporation 82801FB/FBM/FR/FW/FRW (ICH6 Family) USB2 EHCI
Controller (rev 04)
0000:00:1e.0 PCI bridge: Intel Corporation 82801 PCI Bridge (rev d4)
0000:00:1e.2 Multimedia audio controller: Intel Corporation 82801FB/FBM/FR/FW/FRW (ICH6 Family)
AC’97 Audio Controller (rev 04)
0000:00:1f.0 ISA bridge: Intel Corporation 82801FB/FR (ICH6/ICH6R) LPC Interface Bridge (rev 04)
0000:00:1f.1 IDE interface: Intel Corporation 82801FB/FBM/FR/FW/FRW (ICH6 Family) IDE Controller (rev 04)
0000:00:1f.2 IDE interface: Intel Corporation 82801FB/FW (ICH6/ICH6W) SATA Controller (rev 04)
0000:00:1f.3 SMBus: Intel Corporation 82801FB/FBM/FR/FW/FRW (ICH6 Family) SMBus Controller (rev 04)
0000:01:01.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL-8139/8139C/8139C+ (rev 10)
debian:~#
L’output del comando ci fornisce le direttive per la scelta dei moduli da includere nel kernel in
fase di configurazione.
Bus options (PCI, PCMCIA, EISA, MCA, ISA)
--->
-- PCI support
...
[*]
PCI Express support
Processor type and features
--->
Processor family (Pentium-Pro)
--->
( ) 386
( ) 486
( ) 586/K5/5x86/6x86/6x86MX
( ) Pentium-Classic
13
3 – Whys
( ) Pentium-MMX
(X) Pentium-Pro
Device Drivers
--->
SCSI device support
--->
<*> SCSI device support
...
---
SCSI support type (disk, tape, CD-ROM)
<*>
SCSI disk support
...
SCSI low-level drivers
--->
<*> Serial ATA (SATA) support
...
<*>
File systems
Intel PIIX/ICH SATA support
--->
<*> Second extended fs support
...
<*> Ext3 journalling file system support
Per la versione del kernel 2.6.23 l’insieme dei moduli minimo necessari per l’avvio di un sistema
linux da penna usb con filesystem ext3 è rappresentato dal seguente elenco
Processor type and features
--->
Processor family (Pentium-4/Celeron(P4-based)/Pentium-4 M/older Xeon)
Device Drivers
--->
<*> ATA/ATAPI/MFM/RLL support
<*>
--->
Enhanced IDE/MFM/RLL disk/cdrom/tape/floppy support
---
Please see Documentation/ide.txt for help/info on ID
[*]
Support for SATA (deprecated; conflicts with libata
[*]
Use old disk-only driver on primary interface
<*>
Include IDE/ATA-2 DISK support
[*]
Use multi-mode by default
...
<*>
SCSI emulation support
[*]
IDE ACPI support
SCSI device support
--->
<*> RAID Transport Class
--- SCSI device support
<*> SCSI target support
[*] legacy /proc/scsi/ support
--- SCSI support type (disk, tape, CD-ROM)
<*> SCSI disk support
...
<*> SCSI generic support
<*> SCSI media changer support
14
--->
3 – Whys
<*> Serial ATA (prod) and Parallel ATA (experimental) drivers
<*>
--->
AHCI SATA support
...
<*>
Generic ATA support
[*] USB support
<*>
--->
Support for Host-side USB
[*]
USB verbose debug messages
---
Miscellaneous USB options
[*]
USB device filesystem
[*]
USB device class-devices (DEPRECATED)
<*>
EHCI HCD (USB 2.0) support
...
<*>
USB Mass Storage verbose debug
[*]
Datafab Compact Flash Reader support (EXPERIMENTAL)
[*]
Freecom USB/ATAPI Bridge support
[*]
ISD-200 USB/ATA Bridge support
[*]
Microtech/ZiO! CompactFlash/SmartMedia support
[*]
USBAT/USBAT02-based storage support (EXPERIMENTAL)
[*]
SanDisk SDDR-09 (and other SmartMedia) support
[*]
SanDisk SDDR-55 SmartMedia support (EXPERIMENTAL)
[*]
Lexar Jumpshot Compact Flash Reader (EXPERIMENTAL)
[*]
Olympus MAUSB-10/Fuji DPC-R1 support (EXPERIMENTAL)
[*]
[*]
File systems
USB Mass Storage support
[*]
Support for Rio Karma music player
The shared table of common (or usual) storage devices
--->
...
<*> Ext3 journalling file system support
...
DOS/FAT/NT Filesystems
--->
<*> VFAT (Windows-95) fs support
<*> NTFS file system support
3.2
[*]
NTFS debugging support
[*]
NTFS write support
Hard Disk
Per poter eseguire tutte le operazioni di seguito è necessario aver installato su un calcolatore
una qualsiasi release di Linux. Data la generalità dei comandi usati e dei programmi cui si è
fatto riferimento, infatti, qualsiasi release di Linux soddisfa i requisiti minimi richiesti. Tuttavia è
necessario ricordare come talvolta sarà necessario installare delle librerie, programmi o pacchetti
15
3 – Whys
di utility alla nostra release per poter soddisfare le singole richieste di requisiti dei singoli software
che si andrà a compilare.
La shell rappresenta nei sistemi Linux la riga di comando. Nel corso degli anni sono state
implementate diverse versioni di shell. La shell che abbiamo adottato è Bash, comunissima shell
con cui è possibile lanciare comandi built-in e comandi di sistema esterni a bash stesso.
[1 - 7]
Creazione della partizione.
Nell’ambiente di shell sono presenti due possibilità per poter creare una partizione: una testuale
(fdisk), l’altra grafica (cfdisk). Sono due programmini molto semplice e con un help abbastanza
esauriente. Per poter comprendere quale dispositivo aprire è necessario inserire l’hard disk e
lanciare il comando mount il quale mostrerà un elenco di tutti i dispositivi o risorse montate nel
filesystem. L’output del comando mount è in forma tabellare e ci dà la possibilità di leggere molte
informazioni sui dispositivi montati quale: punto di montaggio, tipo di file dispositivo cui si fa
riferimento, filesystem del dispositivo e le opzioni per il montaggio. Il motivo per cui abbiamo
lanciato il comando mount è quello di verificare se vi sono presenti altri dispositivi che utilizzano
i file dispositivo di tipo sd. Nel caso non ci sia alcun dispositivo possiamo lanciare il comando
cfdisk /dev/sda. In alternativa i file cui si farà riferimento sono /dev/sdb o /dev/sdc a seconda
se vi siano presenti uno o più hard disk sul proprio computer di tale tipologia. É consigliata una
partizione di 1 gb per il sistema base.
Figura 3.5.
Schermata comando cfdisk
[8]
16
3 – Whys
Creazione del filesystem. In questa fase sarà creato il filesystem sulla partizione appena creata.
La scelta del filesystem non è univoca, infatti, per Linux sono disponibili alcuni filesystem diversi
ognuno con delle peculiarità che li rendono molto caratteristici. Nonostante ciò è consigliabile
usare un filesystem della famiglia ext perchè più performante. I filesystem tra cui scegliere sono il
filesystem ext2 ed ext3. Con il filesystem ext3 sono state introdotte alcuni funzionalità , prima non
previste, molto interessanti quali il journaling.Un filesystem che supporta il journaling registra i
cambiamenti prima di effettuarli sul sistema principale. Questi filesystem hanno minori probabilità
di risultare alterati (corrotti) in caso di mancata alimentazione o di caduta del sistema.
Figura 3.6.
Schermata comando gparted
Un’alternativa più user-friendly del sistema di gestione delle partizioni e dei filesystem è l’uso di
un programma grafico gparted di cui è possibile osservare uno screenshot nella figura precedente.
[9 - 11 ]
Montaggio del dispositivo. La fase del montaggio è molto importante in quanto ci dà la possibilità
di scrivere e leggere dal dispositivo. Questo è possibile poichè il montaggio prevede l’inserimento
all’interno dell’albero del filesystem del contenuto del dispositivo in questione. Per una questione di
pura semantica delle cartelle del filesystem di Linux sarebbe opportuno montare il dispositivo nella
cartella /mnt. La sintassi del comando mount è semplice e prevede una prima parte per definire
il file dispositivo ed una seconda che definisce il mount-point all’interno del filesystem. Questa
impostazione di default può essere eventualmente estesa con delle opzioni tra cui la specifica del
filesystem (-t ext2, -t vfat , -t ntfs, ...) o i permessi di scrittura sul disposito (ro , rw).
[ 12 ]
17
3 – Whys
Creazione dell’albero del filesystem. Tramite il comando mkdir si creano le cartelle dell’albero del
filesystem. Il comando dà la possibiltà di creazione delle cartelle inserendo sia un path assoluto sia
relativo a partire dalla cartella in cui siamo. Infatti al punto precedente era richiesto di cambiare
la cartella locale per non appesantire la sintassi del comando. Alcune cartelle per il momento
resteranno vuote, altre saranno riempite a seconda delle necessità .
[ 13 ]
Creazione della console. Il comando mknod è usato per la creazione di file speciali quali quelli
a caratteri o a blocchi. Nel caso in questione si sta cercando di creare un file speciale a caratteri
di tipo console. L’opzione c, infatti, fa riferimento ai file a caratteri e i due interi successivi sono
il numero primario e secondario di dispositivo. É possibile dichiarare ed usare sino a 63 console
facendo variare il numero secondario tra il valore 1 e il 63. La console per il momento è l’unico
dispositivo di cui abbiamo bisogno per poter visualizzare a video i messaggi.
3.2.1
Problems
I file di dispositivo o device file sono particolari file che i sistemi Unix-like associano ai dispositivi fisici. La maggior parte dei file dei device sono creati durante l’installazione della distribuzione. La lista dei file di device supportati dal kernel Linux si trova in /usr/src/linux/Documentation/devices.txt.
Un file di dispositivo è caratterizzato da :
• nome è il nome del file che identifica il dispositivo (non ha nessuna influenza sul funzionamento
del dispositivo);
• tipo è il tipo del dispositivo. Può essere a blocchi (hard disk, CD-ROM, ...) o a caratteri
(terminali, unità a nastro, ...);
• major number indica il driver che gestisce il funzionamento del dispositivo;
• minor number identifica il dispostivo per il driver;
Nel caso fosse necessario creare un nuovo file di device, si può usare lo script MAKEDEV presente in
/dev/MAKEDEV o all’interno della cartella /sbin. Questi file di dispositivo fungono da driver per
il sistema e permettono di gestire i meccanismi per la comunicazione con un particolare dispositivo
considerato. A tal proposito provando a far partire la distribuzione all’interno di una partizione
del pc, senza utilizzare un hard disk rimovibile, ci si rende conto dell’assenza dei file dispositivo
corretti, e se mentre con lo script MAKEDEV si erano creati sotto /dev i file sd*, ora ci sarà bisogno
di altri file che però siano hd*. L’elenco delle partizioni riconosciute dal sistema è contenuto nel
file /proc/partitions.
18
3 – Whys
3.3
BootLoader - Grub
Il BootLoader è un programma indispensabile per l’avvio del sistema operativo Linux. La sua
importanza risiede nel fatto che fornisce la possibilità di definire gli eseguibili da avviare e di poter
specificare delle opzioni su questi eseguibili. Inoltre è possibile anche specificare su quale hard disk
e su quale partizione risiedono questi eseguibili. Vi sono diversi bootloader presenti nel mondo
Linux. Si è scelti di usare il grub senza un motivo preciso essendo tutti molto semplici da usare e
configurare.
[1 - 3]
La compilazione della maggior parte dei programmi in ambiente Linux è preceduta dalla configurazione la quale avviene solitamente tramite l’esecuzione di uno script il cui scopo principale è
verificare che il sistema sia in grado di affrontare con successo la compilazione. In questa fase,
infatti, vengono verificate le presenze dei programmi e librerie necessarie per la compilazione. La
scelta di far precedere la compilazione con l’esecuzione di questo script è funzionale anche alla
ricerca dei problemi in quanto lo script è progettato per il blocco immediato in caso di problemi in
modo da dar la possibiltà all’utente di capire e risolvere velocemente i problemi incontrati. L’output di questo script è la creazione del makefile la cui assenza impedisce l’esecuzione del comando
di compilazione make. Il comando make come detto anche in precedenza compila ricorsivamente
tutte le cartelle presenti. Per questo motivo è necessario spostarsi nella sottocartella grub per poter
ritrovare il grub appena compilato.
[4 - 8]
La fase di installazione è abbastanza atipica ed è dovuta al fatto di installare un programma su
un computer diverso da quello su cui si è effettuati la compilazione. La prima fase prevede la
copia di alcuni eseguibili dalla cartella di origine alla cartella /boot/grub presente sull’hard disk di
destinazione. Questi nomi hanno un significato molto chiaro, riferendosi agli stadi in cui è suddivisa
la fase di avvio. Se si osserva bene, si può notare che il file stage1 è lungo esattamente 512 byte,
ovvero un settore: questo è il primo pezzo di codice che viene utilizzato durante l’avvio. Il file
stage2 rappresenta invece il codice necessario al completamento dell’avvio, mentre i file della serie
∗ stage1 5 rappresentano una fase intermedia che potrebbe inserirsi, sempre se necessario, subito
prima di stage2. Si può notare come i file eseguibili, i cui nomi hanno come suffisso stage1 5,
hanno come prefisso il nome di un filesystem. Tra questi, quindi, sarebbe opportuno copiare quelli
rappresentanti filesystem in uso sul computer su cui si farà partire il sistema. Ovviamente sono
consigliati i filesystem windows (vfat e ntfs) e quelli Linux.
[9 - 14]
All’interno dell’ambiente grub è possibile eseguire alcuni comandi tipici. Per poter avere un elenco
19
3 – Whys
di questi comandi è sufficiente premere il tasto TAB. Un’interessante funzionalità della linea di
comando di grub è il completamento automatico sia dei comandi che dei valori in input. Tramite il
tasto TAB, infatti, è possibile sia avere il completamento della scrittura del comando sia ottenere,
fissato il comando, un elenco dei possibili valori di input. Ad esempio, il comando root prevede
in input il disco e la partizione da far diventare root. Dopo aver scritto il comando e aperta
la parentesi premendo il tasto TAB ci apparirà una lista esaustiva degli hard disk rilevati, delle
partizioni rilevate su ogni hard disk e dei filesystem presenti su ogni partizione facilitando in
maniera considerevole la comprensione e la ricerca della partizione. Nel caso di ambiguità sulla
scelta lanciare il comando find /boot/grub/stage1 per ottenere l’elenco delle partizioni candidate
Figura 3.7.
Schermata comando root all’interno di grub nella shell
Il comando root come detto serve per poter definire quale partizione contiene i file per l’avvio, mentre il comando setup contiene solo l’identificativo del disco sul cui Master Boot Record
(MBR) andrà ad installare il bootloader. Durante l’esecuzione del comando setup verrà verificata la presenza dei su citati file richiesti per una corretta installazione di grub. Eventualmente è
possibile estendere il grub tramite alcuni file di configurazione da inserire all’interno della cartella
/boot/grub quali ad esempio il menu.lst. In questo file sarà possibile creare e settare un menu
testuale che facilita l’inserimento dei comandi in quanto dà la possibilità di definire delle voci
rappresentanti dei gruppi di comandi con opzioni (root - kernel - boot).
20
3 – Whys
Figura 3.8.
3.4
Schermata comando setup all’interno di grub nella shell
Bash
Installazione del kernel. In questa fase verrà copiato il kernel compilato in precedenza sull’hard
disk. Per questioni storiche e di semantica sarebbe opportuno rinominare nella copia il nome della
bzImage in vmlinuz. La bzImage si trova nella cartella
/usr/src/{ linux-source-versione }/arch/i386/boot,
mentre la copia va inserita nella cartella /mnt/hd/boot/.
Installazione di bash. Ogni eseguibile in ambiente Linux necessita di alcune librerie per poter
essere eseguito. Il comando ldd fornisce in output una tabella rappresentante la lista delle librerie
necessarie per l’esecuzione del file in input. La lista comprende anche la collocazione fisica della
libreria in questione all’interno del filesystem. Per poter quindi installare bash o qualsiasi altro
eseguibile dal disco ospite a quello target è necessario copiare, rispettando fedelmente il percorso
fisico all’interno del filesystem, le librerie in output dal comando ldd. Si noterà sicuramente la
presenza di ridondanza nelle librerie in quanto molti eseguibili dipendono dallo stesso gruppo di
librerie. Infine si può notare come le cartelle in cui saranno copiate le librerie e quindi da cui
saranno prelevate sono la cartella /lib e la cartella /usr/lib.
Nel nostro caso avviando il comando ldd bash nella shell della distro ospite otterremo l’elenco
delle librerie e la loro collocazione fisica all’interno del nostro filesystem.
/usr/src/bash-3.2... ldd ./bash
21
3 – Whys
linux-gate.so.1 =>
(0xffffe000)
libncurses.so.5 => /lib/libncurses.so.5 (0xb7f68000)
libdl.so.2 => /lib/i686/cmov/libdl.so.2 (0xb7f64000)
libc.so.6 => /lib/i686/cmov/libc.so.6 (0xb7e1b000)
/lib/ld-linux.so.2 (0xb7fad000)
/usr/src/bash-3.2...
L’output è composto da due colonne indicanti il nome della libreria e la collocazione fisica della
stessa nel filesystem dopo il simbolo =>. Durante la copia delle librerie è necessario rispettare il
path della stessa nel filesystem.
L’unica eccezione riguarda la libreria linux-gate.so.1 a cui non fa riferimento alcun file fisico ma
solo una cella di memoria. Tale libreria è infatti creata dinamicamente dal kernel (a partire dalla
versione 2.6) ed è usata per gestire gli interrupt. Infatti il kernel all’avvio quando riconosce il
processore su cui sta partendo il sistema crea tale libreria a seconda della tipologia dello stesso per
ottimizzare la gestione delle chiamate di sistema.
3.5
Test
Il Bios (Basic Input Output System) è il primo codice eseguito da un personal computer. Le
sue funzionalità sono inerenti l’hardware. Entrando nel menu del Bios, infatti, è possibile settare l’orario e la data di sistema, verificare la presenza e il corretto funzionamento dei dispostivi
hardware installati, decidere su quale componente reperire il codice del sistema operativo. La
nostra necessità di interagire con il menu del Bios è proprio quella di modificare e impostare la
componente su cui ricercare il sistema operativo da avviare. Gli hard disk rimovibili dovrebbero
essere riconosciuti dal Bios tra le perifiche rimovibili, ma dal momento che sono presenti numerose varianti di Bios diverse tra loro, a volte capita di ritrovare il proprio hard disk rimovibile tra
gli hard disk (non rimovibili). Ora, poichè è molto frequente la presenza di più hard disk su di
un computer, è stato introdotto nel menu del Bios la funzionalità di scelta della priorità tra gli
hard disk in fase di boot. Qualora il proprio hard disk rimovibile fosse incluso in questo menu
di scelta basterà settare la priorità maggiore. Nel Bios è presente sia la possibilità di salvare le
modifiche sia quella di resettare le scelte di default in modo da evitare spiacevoli problemi all’avvio.
Dopo aver avviato il pc dall’hard disk rimovibile appare la shell di grub dal momento che non
abbiamo ancora personalizzato grub con il menu (file menu.lst). Lanciamo il comando root (hd0,0).
Per conferma è possibile usare il tasto Tab per capire quanti hard disk vengono rilevati dal grub. Nel
nostro caso non ci sono dubbi in quanto hd0 risulta coincidere sempre con l’hard disk di boot, quindi
22
3 – Whys
quello rimovibile. Lanciamo il comando kernel. Questo comando serve a definire in maniera precisa
quale sarà il file eseguibile da avviare e soprattutto fornisce la possibilità di settare alcuni parametri
fondamentali per il corretto avvio del sistema operativo. Nella definizione dell’eseguibile dobbiamo
indicare esplicitamente il percorso in cui si trova quindi dobbiamo precisare il file /boot/vmlinuz.
Le opzioni necessarie in questa fase sono root, rootdelay e init.
L’opzione root.
Dopo l’esecuzione del kernel e il riconoscimento da parte dello stesso dei dispositivi presenti sul pc
in esecuzione, il kernel passa il comando ad una partizione con un proprio filesystem su un hard disk
presente. Per poter specificare quale partizione e quale hard disk aver come riferimento è necessario
passare al boot loader tramite l’opzione root= il device di riferimento con la relativa partizione. Si
noti che la partizione e l’hard disk vengono individuati come se l’ambiente Linux fosse già caricato.
In particolare quindi viene specificata la cartella su cui sarà presente il file dispositivo e il nome
di tale file. La sintassi per il file è semplice: si specifica anzitutto il prefisso indicante la tipologia
dell’hard disk, segue una lettera indicante la gerarchia tra i vari dispositivi dello stesso tipo. Infine
viene specificata la partizione attraverso un numero. Per intenderci facciamo degli esempi:
• /dev/hda1
Prima partizione presente sul primo hard disk di tipo eide/scsi.
• /dev/hda4
Quarta partizione presente sul primo hard disk di tipo eide/scsi.
• /dev/hdb1
Prima partizione presente sul secondo hard disk di tipo eide/scsi.
• /dev/sda1
Prima partizione presente sul primo hard disk di tipo sata/usb.
• /dev/sdc6
Sesta partizione presente sul terzo hard disk di tipo sata/usb.
Con la versione del kernel 2.6.22 sono state implementate alcune nuove funzionalità . Per
la gestione delle perferiche usb sono stati introdotti i device uba. Tale funzione ci permette di
considerare in maniera distinta gli hard disk sata rispetto alle periferiche usb con vantaggi ben
visibili all’interno del grub ad esempio dove il comando kernel diventa univoco per tutte le macchine
kernel /boot/vmlinuz root=/dev/uba1 rootdelay=10 init=/bin/bash
cosa che prima non accadeva in quanto era necessario personalizzarlo a seconda del numero di hard
disk presenti.
23
3 – Whys
3.5.1
Configurazione
L’opzione rootdelay, invece serve a definire il numero di secondi che deve attendere il kernel prima
di cercare la root. Questa opzione è fondamentale per kernel su hard disk usb, in quanto queste
necessitano di alcuni secondi per poter essere riconosciute. Un tempo abbastanza ragionevole si
aggira sui 10 secondi.
L’opzione init.
Dopo aver caricato il kernel in memoria e dopo aver riconosciuto il filesystem della partizione di
root, è necessario specificare quale sarà il processo iniziale tramite l’opzione init. Nelle distribuzioni
Linux classiche questo è un processo fondamentale in quanto è il responsabile dell’avvio dei processi
demoni, del caricamento in memoria dei moduli del kernel, dell’avvio degli script di configurazione,
dell’avvio del server grafico o di altri server necessari al sistema operativo. Nel caso in questione
non avendo ancora installato alcun programma sarà sufficiente specificare come processo iniziale
l’eseguibile di bash collocato nella cartella /bin per poter far avviare il sistema con la shell di bash.
Dopo aver lanciato questo comando grub preleva il kernel dal filesystem e lo carica in memoria
verificando quindi che non vi siano problemi di file not found. Lanciando il comando boot verrà
eseguito tale file dando l’avvio effettivo al sistema operativo.
Alla fine del caricamento dovrebbe apparire la shell di bash. Ora è possibile verificare il funzionamento della stessa tramite il test di qualche comando presente (echo, eval,... ) e di qualche
comando assente (ls, cd, ...).
La procedura vista per l’installazione di bash sarà ripetuta in maniera piuttosto simile per altri
comandi tipici della shell.
24
Capitolo 4
FAQ
4.1
Kernel
Segnalate problemi ed eventuali domande da inserire in questa sezione
• Cosa rappresenta un Kernel Panic?
Una condizione di “kernel panic” si presenta quando il sistema operativo rileva un errore
irreversibile che necessita il riavvio del sistema. La procedura del kernel che gestisce la
condizione di “panico” è conosciuta come panic() ed è stata progettata per visualizzare un
messaggio sulla console, copiare su disco un’immagine della memoria del kernel per consentire
un successivo debugging e attende un riavvio manuale del sistema.
Molto spesso le condizioni di “kernel panic” sono determinate dai tentativi del sistema operativo di leggere un indirizzo di memoria non valido o non autorizzato. In altri casi, sono
determinate da un errore a livello di hardware oppure da un “bug” del sistema operativo.
Quando Linux non sa come procedere, come in questo caso, esso visualizza un messaggio
di “kernel panic” e si ferma. Ma, anche in caso di “panico”, il sistema si ferma in modo
“elegante”. Cerca di scrivere su disco tutto quello che non è stato possibile trascrivere
(operazione che si chiama “syncing”), e se l’operazione riesce, viene visualizzato il messagio
“not syncing”. Chiaramente il messaggio visualizzato è fuorviante, perché in realtà non è
quello il motivo del “panico”.
Molto spesso nei casi di “panico” viene visualizzato il messaggio “tried to kill init”. In realtà
, il messaggio indica che il processo chiamato init sta “morendo”, cosa che non è permessa
perché init è un programma speciale per Linux, creato quando il sistema viene avviato.
25
4 – FAQ
• Non parte il comando make menuconfig. Come faccio a capire il problema?
4.2
Hard disk
• scrittura cfdisk
4.3
Grub
• root(hd0,0)
• setup(hd0)
4.4
Bash
26
Parte II
Shell
Capitolo 5
Download
• Scaricare l’ultima versione dal sito ftp://ftp.gnu.org/gnu/coreutils/ attualmente la 6.9
• Scaricare dal sito http://sourceforge.net/projects/e2fsprogs/ il pacchetto contenente utility
sul filesystem
• Scaricare dal sito ftp://ftp.win.tue.nl/pub/linux-local/utils/util-linux/ l’ultima release del
pacchetto util-Linux
28
Capitolo 6
How to
6.1
Coreutils
1. Entrare nella cartella /usr/src/coreutils-6.9
2. Lanciare il comando da shell ./configure
3. Lanciare il comando make
4. Entrare nella sottocartella src
5. In questa cartella è possibile ritrovare il codice sorgente dei comandi più comuni della shell,
il codice oggetto frutto della compilazione e l’eseguibile appena creato
6. Copiare i più importanti e comuni da questa cartella alla cartella bin dell’hard disk tramite
in comando cp. Ad esempio si potrebbe lanciare il comando
cp cat chgrp chmod chown cp date dd df /mnt/hd/bin
cp hostname ln ls mkdir mkfifo mknod /mnt/hd/bin
cp mv rm rmdir stty su sync uname /mnt/hd/bin
7. Verificare la necessità di altre librerie da includere tramite il comando ldd come fatto per
bash
8. Copiare le librerie necessarie rispettando lo stesso PATH.
6.2
e2fsprogs
1. Entrare nella directory e2fsprogs contenente i sorgenti
29
6 – How to
2. Configurare la variabile d’ambiente come segue export CC=“gcc -mcpu=i386”
3. Lanciare il comando ./configure –host=i386-pc-linux-gnu
4. Lanciare la compilazione tramite il comando make
5. Entrare nella cartella e2fsck
6. Lanciare il comando cp e2fsck.shared /mnt/hd/sbin/e2fsck
7. Entrare nella cartella ../misc
8. Lanciare il comando cp fsck mke2fs /mnt/hd/sbin
9. Entrare nella cartella /mnt/hd/sbin
10. Creare dei lik simbolici tramite i comandi
• ln -s e2fsck fsck.ext2
• ln -s mke2fs mkfs.ext2
6.3
Util-Linux
1. Entrare nella cartella /usr/src/{util-Linux-versione}
2. Lanciare il comando ./configure
3. Lanciare il comando make
4. Copiare gli eseguibili appena creati sull’hard disk rimovibile tramite i comandi
• cp disk-utils/mkfs /mnt/hd/sbin
• cp fdisk/fdisk /mnt/hd/sbin
• cp login-utils/agetty /mnt/hd/sbin
• ln -s agetty /mnt/hd/sbin/getty
• cp login-utils/login /mnt/hd/bin
• cp misc-utils/kill /mnt/hd/bin
• cp mount/mount /mnt/hd/bin
• cp mount/umount /mnt/hd/bin
• cp mount/swapon /mnt/hd/sbin
30
6 – How to
• cp sys-utils/dmesg /mnt/hd/bin
5. Verificare la necessità di copiare le librerie necessarie tramite il comando ldd
6. Entrare nella cartella /mnt/hd/dev
7. Creare il file dispositivo
• mknod null c 1 3
• mknod fd0 b 2 0
• mknod ram0 b 1 0
8. Entrare nella cartella /mnt/hd/etc
9. Usando un editor di testo (grafico o anche testuale come vi o emacs) creare il seguente file
fstab
proc
/proc
proc
defaults
0
0
/dev/sda1
/
ext2
defaults
1
1
10. Creare un file vuoto sempre nella cartella /mnt/hd/etc tramite il comando
echo -n ¿ mtab
11. Lanciare il comando mkdir /mnt/hd/etc/init.d
31
6 – How to
12. Creare il seguente file in questa cartella e rinominarlo local fs
#!/bin/sh
#
# local fs - check and mount local filesystems
#
PATH=/sbin:/bin ; export PATH
fsck -ATCp
if [ $? -gt 1 ]; then
echo “Errori presenti nel filesystem! Si richiede
intervento manuale.”
/bin/sh
else
echo “Rimontaggio di / in modalità lettura-scrittura.”
mount -n -o remount,rw /
echo -n >/etc/mtab
mount -f -o remount,rw /
echo “Montaggio del filesystem locale.”
mount -a -t nonfs,nosmbfs
fi
#
# end of local fs
13. Lanciare il seguente comando per rendere eseguibile il file appena creato
chmod +x local fs
6.4
Startup
1. Creare il file menu.lst all’interno della cartella /boot/grub sull’hard disk destinazione.
2. Popolare il file con
default 0
timeout 3
color cyan/red white/blue
title MVux
32
6 – How to
root (hd0,0)
kernel /boot/vmlinuz root=/dev/sda1 rootdelay=10
boot
3. Entrare nella cartella /usr/src/sysvinit{versione}/src sulla distro ospite
4. Lanciare il comando make
5. cp init halt shutdown /mnt/hd/sbin
6. ln -s halt /mnt/hd/sbin/reboot
7. ln -s init /mnt/hd/sbin/telinit
8. mknod /mnt/hd/dev/initctl p
9. Creare il seguente file di testo e salvarlo come /etc/inittab sull’hard disk destinazione
# /etc/inittab - init daemon configuration file
#
# Default runlevel
id:1:initdefault:
#
# System initialization
si:S:sysinit:/etc/init.d/rc S
#
# Runlevel scripts
r0:0:wait:/etc/init.d/rc 0
r1:1:respawn:/bin/sh
r2:2:wait:/etc/init.d/rc 2
r3:3:wait:/etc/init.d/rc 3
r4:4:wait:/etc/init.d/rc 4
r5:5:wait:/etc/init.d/rc 5
r6:6:wait:/etc/init.d/rc 6
#
# end of /etc/inittab
10. Creare il seguente file di testo e salvarlo come /etc/init.d/rc
#!/bin/sh
# /etc/init.d/rc - runlevel change script
#
PATH=/sbin:/bin
SCRIPT_DIR="/etc/rc$1.d"
#
# Check that the rcN.d directory really exists.
if [ -d $SCRIPT_DIR ]; then
# Execute the kill scripts first.
for SCRIPT in $SCRIPT_DIR/K*; do
if [ -x $SCRIPT ]; then
33
6 – How to
$SCRIPT stop;
fi;
done;
# Do the Start scripts last.
for SCRIPT in $SCRIPT_DIR/S*; do
if [ -x $SCRIPT ]; then
$SCRIPT start;
fi;
done;
fi
# end of /etc/init.d/rc
11. chmod +x /mnt/hd/etc/init.d/rc
12. Modificare il file local fs in modo da inserire la sezione per l’unmount del filesystem come
di seguito riportato
#!/bin/sh
#
# local_fs - check and mount local filesystems
#
PATH=/sbin:/bin ; export PATH
case $1 in
start)
echo "Checking local filesystem integrity."
fsck -ATCp
if [ $? -gt 1 ]; then
echo "Filesystem errors still exist! Manual intervention required."
/bin/sh
else
echo "Remounting / as readwrite."
mount -n -o remount,rw /
echo -n > /etc/mtab
mount -f -o remount,rw /
echo "Mounting local filesystems."
mount -a -t nonfs,smbfs
fi
;;
stop)
echo "Unmounting local filesystems."
umount -a -r
;;
*)
echo "usage: $0 start|stop";
;;
esac
#
# end of local_fs
13. Creare il seguente file di testo e salvarlo in /etc/init.d/hostname sull’hard disk destinazione
34
6 – How to
#!/bin/sh
#
# hostname - set the system name to the name stored in /etc/hostname
#
PATH=/sbin:/bin:/usr/bin:/usr/sbin ; export PATH
echo "Setting hostname."
if [ -f /etc/hostname ]; then
hostname $(cat /etc/hostname)
else
hostname mvux-linux
fi
#
# end of hostname
14. Creare il seguente file di testo e salvarlo come /etc/init.d/halt sull’hard disk destinazione
#!/bin/sh
#
# halt - halt the system
#
PATH=/sbin:/bin ; export PATH
echo "Initiating system halt."
halt
#
# end of /etc/init.d/halt
15. Creare il seguente file di testo e salvarlo come /etc/init.d/reboot sull’hard disk destinazione
#!/bin/sh
#
# reboot - reboot the system
#
PATH=/sbin:/bin ; export PATH
echo "Initiating system reboot."
reboot
#
# end of /etc/init.d/reboot
16. chmod +x /mnt/hd/etc/init.d/*
17. cd /mnt/hd/etc
18. mkdir rc0.d rc1.d rc2.d rc3.d rc4.d rc5.d rc6.d rcS.d
19. cd rcS.d
20. ln -s ../init.d/local fs S20local fs
21. ln -s ../init.d/hostname S30hostname
35
6 – How to
22. cd ../rc0.d
23. ln -s ../init.d/local fs K10local fs
24. ln -s ../init.d/halt K90halt
25. cd ../rc6.d
26. ln -s ../init.d/local fs K10local fs
27. ln -s ../init.d/reboot K90reboot
36
Parte III
Emacs
Capitolo 7
Download
1. Entrare nella cartella /var/cache/apt/archives
2. Lanciare il comando rm *.deb
3. Scaricare il seguente elenco di pacchetti debian tramite il comando
apt-get install -d --reinstall nomepacchetto
dove per nomepacchetto si intende:
• libncurses5
• ncurses-base
• ncurses-term
• emacs22-nox
1
• emacs22-bin-common
• emacs22-common
• emacsen-common
• bsdutils
• bsdmainutils
• liblockfile1
• debianutils
4. Creare il seguente file di testo e rinominarlo in scompattadeb
1A
seconda della distro usata potrebbe essere necessario far riferimento alla versione 21 o precedente del pacchetto
38
7 – Download
#! /bin/sh
for i in *.deb;
{
dpkg-deb -x $i $1
}
5. Dare permessi di esecuzione al file appena creato tramite il comando chmod +x scompattadeb
6. Eseguire il comando scompattadeb emacs per creare la cartella emacs all’interno della directory
7. Cancellare i pacchetti appena scaricati.
8. Copiare il contenuto della cartella emacs all’interno dell’hard disk destinazione
9. Entrare nella cartella /var/cache/apt/archives/emacs/usr/bin
10. Lanciare il comando ldd emacs21
11. Verificare la presenza di tutte le librerie richieste ed eventualmente copiare quelle non presenti
nell’hard disk destinazione (probabilmente manca libm.so.*)
12. Riavviare la distro e testare lanciando il comando all’interno della cartella /usr/bin ./emacs22.
39

Documenti analoghi