[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home] [volume] [parte]


Capitolo 51.   GRUB 1

GRUB 1,(1) ovvero «GRUB legacy», è una per il caricamento di un sistema GNU/Linux e molti altri sistemi operativi negli elaboratori con architettura x86. GRUB 1 è un sistema molto sofisticato e in questo capitolo vengono descritti solo gli aspetti più importanti, per un utilizzo secondo le convenzioni comuni. Eventualmente si può contare sulla documentazione originale che è molto accurata e dettagliata. Va osservato che GRUB 1 non viene più sviluppato e che viene rimpiazzato da GRUB 2, con l'obiettivo di poter utilizzare piattaforme hardware differenti.

Nella sezione 170.4.8 viene descritto l'uso di GRUB 1 per rendere avviabile un CD o un DVD.

51.1   Logica generale

In condizioni normali, quando si installa il pacchetto GRUB 1 nel proprio sistema, si dovrebbero trovare i file salienti nella directory /lib/grub/i386-pc/. Esistono qui due file fondamentali, denominati stage1 e stage2, assieme ad altri file che corrispondono al modello *_stage1_5.

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, eventuale, che potrebbe inserirsi subito prima di stage2, se necessario.

L'installazione del sistema di avvio avviene collocando una copia del file stage1 nel settore di avvio dell'unità usata per questo scopo; potrebbe trattarsi del primo settore di un dischetto, del primo settore del disco fisso (MBR), oppure il primo settore di una partizione primaria (o anche di una partizione «logica»), ma in tal caso si lascia il compito di avviarlo a un altro sistema del genere. Anche gli altri file vanno copiati in un'altra posizione, soprattutto perché, a seconda della circostanza, vengono modificati.

In condizioni normali, si colloca una copia di tutti i file contenuti nella directory /lib/grub/i386-pc/ in /boot/grub/; inoltre, sempre nella directory /boot/grub/ si crea un file di configurazione denominato convenzionalmente menu.lst.

Perché GRUB 1 funzioni è sufficiente che sia stato fissato il collegamento tra il codice contenuto nel settore di avvio (il file stage1) e il codice contenuto nel file stage2, con la mediazione eventuale di un file *_stage1_5. Ciò permette a GRUB 1 di avere il controllo della situazione, così l'utente può osservare il contenuto delle partizioni e indicare un kernel da avviare, anche senza alcuna configurazione. Infatti, GRUB 1 è realizzato in modo da poter leggere autonomamente i file system più comuni; in particolare i formati Second-extended di GNU/Linux e di GNU/Hurd, (ovvero Ext2 e Ext3), come i formati FAT di Dos e MS-Windows.

GRUB 1, quando è installato correttamente, è una sorta di shell, con una serie di comandi interni che facilitano la gestione dell'avvio, senza bisogno di creare un legame diretto con il file o i file del kernel e la configurazione eventuale. In questo modo si possono modificare (sostituire, aggiungere o eliminare) i file del kernel; inoltre, anche il file di configurazione, se utilizzato, può essere modificato a piacimento, senza bisogno di reinstallare il sistema di avvio. Eventualmente, in un sistema già avviato, è disponibile anche l'eseguibile grub, che riproduce il comportamento del sistema di avvio e può essere usato proprio per installarlo. La riga di comando di GRUB 1 offre anche un sistema di completamento automatico che facilita notevolmente l'utilizzo, specialmente quando non è stato preparato un file di configurazione. In tal caso, il funzionamento è molto simile a quello della shell Bash (si veda la parte xxv, che si riferisce in generale alle shell POSIX).

51.2   Dischi, partizioni, percorsi e blocchi di settori

GRUB 1 è un sistema di avvio pensato per diversi sistemi operativi, in grado di accedere da solo ai file system. In questo senso, utilizza una sua notazione per fare riferimento ai dischi, alle partizioni e ai percorsi contenuti nelle partizioni. Un disco, nella sua interezza, si indica secondo la sintassi seguente:

(hdn) | (fdn)

La sigla hd fa riferimento a un disco fisso, di qualsiasi genere, mentre la sigla fd fa riferimento a un dischetto. Il numero specifica quale disco o dischetto, secondo l'ordine attribuito dal BIOS (il firmware nell'architettura x86). In questo senso, il primo disco fisso, di qualunque tipo sia (ATA, SCSI, ecc.) è sempre (hd0); nello stesso modo, il primo dischetto è sempre (fd0).

Per fare riferimento a una partizione, si usa la notazione seguente:

(hdn,m)

In questo modo, si fa riferimento al disco n-esimo (come è già stato mostrato) e alla partizione m-esima, anche in questo caso si parte da zero. Per esempio, (hd0,1) fa riferimento alla seconda partizione del primo disco fisso; se si trattasse di un disco ATA, per GNU/Linux corrisponderebbe al file di dispositivo /dev/hda2.

Nel caso particolare delle partizioni *BSD, queste si articolano in sottopartizioni conosciute come disklabel, identificate da una lettera alfabetica:

(hdn[,m],x)

In pratica, il numero della partizione può essere omesso se si tratta della prima, mentre x rappresenta la lettera minuscola che identifica l'etichetta BSD a cui si vuole fare riferimento. Per esempio, (hd0,a) fa riferimento alla sottopartizione «a» (secondo BSD), della prima partizione del primo disco fisso; la stessa cosa si potrebbe annotare in modo più dettagliato come (hd0,0,a).

C'è un'ultima cosa da tenere in considerazione a proposito della notazione riferita ai dischi e delle partizioni. Al posto della forma (hd...), oppure (fd...), si può indicare direttamente il numero attribuito dal BIOS, espresso in esadecimale, secondo la notazione 0xhh, oppure in decimale. Per esempio, il primo disco fisso si può indicare anche come (0x80), oppure (128). A ogni modo, in condizioni normali non c'è ragione di usare questa notazione.

Per fare riferimento a un file o a una directory, si indicano percorsi simili a quelli comuni nei sistemi Unix (indipendentemente dal tipo di file system a cui si accede), con l'indicazione eventuale del disco o della partizione a cui si fa riferimento:

[disco_o_partizione]percorso

Per esempio, per fare riferimento alla prima partizione del primo disco fisso, in cui si trova il file o il collegamento /boot/vmlinuz, si può indicare (hd0,0)/boot/vmlinuz.

Bisogna evitare di fare confusione: il percorso che segue l'indicazione del disco o della partizione è riferito al disco o alla partizione stessa. GRUB 1 non può essere al corrente della struttura di un file system articolato attraverso diversi innesti, che uniscono assieme più partizioni in uno stesso albero. In pratica, è un po' come succede nei sistemi Dos e MS-Windows, in cui i percorsi sono sempre riferiti a unità distinte in base a una lettera (C:\...\...).

GRUB 1 è un sistema di avvio, che deve poter fare anche riferimento a settori dei dischi, indipendentemente dal file system contenuto. Per questo si aggiunge un'altra notazione, che va a sostituire quella del percorso di un file:

[inizio]+lunghezza[,[inizio]+lunghezza]...

Il modello sintattico fa riferimento alla possibilità di individuare uno o più gruppi di settori, ognuno a partire da una posizione, che se non viene specificata è implicitamente il settore zero, per una quantità (lunghezza) di settori stabilita. In pratica, la notazione 0+2 fa riferimento a un gruppo composto da due settori, a partire dal primo (il settore zero). Secondo la sintassi, la stessa cosa si potrebbe indicare omettendo il settore iniziale: +2. Potrebbe capitare, con maggiore probabilità, di dover fare riferimento soltanto al primo settore di una partizione, come nel caso di (hd0,0)+1, in cui si indica il primo settore della prima partizione del primo disco fisso.

51.3   Dischetto GRUB 1 di emergenza

Prima di installare GRUB 1 come sistema di avvio per il proprio elaboratore, conviene fare delle prove non distruttive. La cosa migliore è preparare almeno un dischetto contenente GRUB 1, che potrebbe servire anche per sistemare dei problemi in altre situazioni in cui il sistema di avvio è compromesso per qualche ragione.

Servono soltanto i file stage1 e stage2 originali (quelli contenuti nella directory /lib/grub/i386-pc/ e non quelli già utilizzati per l'installazione di un sistema di avvio), che vanno copiati sequenzialmente a partire dal primo settore del dischetto. In pratica, con un sistema GNU/Linux si può agire nel modo seguente:

cd /lib/grub/i386-pc[Invio]

cat stage1 stage2 > /dev/fd0[Invio]

Diversamente, con un altro sistema operativo Unix in cui questo meccanismo non sia attuabile, si possono usare i comandi seguenti:

cd /lib/grub/i386-pc[Invio]

dd if=stage1 of=/dev/fd0 bs=512 count=1[Invio]

dd if=stage2 of=/dev/fd0 bs=512 seek=1[Invio]

In pratica, con dd bisogna copiare il file stage2 a partire dal secondo settore del dischetto, perché il primo contiene il file stage1.

Eventualmente, si può fare anche attraverso il Dos, con l'aiuto del programma RAWRITE.EXE:

C:\> COPY /B STAGE1 + STAGE2 GRUB.RAW[Invio]

C:\> RAWRITE GRUB.RAW A:[Invio]

In questo modo, si crea prima il file GRUB.RAW, unendo i due file di partenza, quindi si passa al trasferimento nel dischetto. Ovviamente, la stessa tecnica si può sfruttare anche in un sistema Unix:

cat stage1 stage2 > grub.raw[Invio]

dd if=grub.raw of=/dev/fd0 bs=512[Invio]

51.4   Funzionamento interattivo

Una volta preparato il dischetto contenente GRUB 1, si può provare ad avviare un elaboratore. Quello che si ottiene è lo stesso funzionamento che si avrebbe in un'installazione priva di configurazione:

    GRUB  version 0.90  (640K lower / 3072K upper memory)

 [ Minimal BASH-like line editing is supported.  For the first word, TAB
   lists possible command completions.  Anywhere else TAB lists the possible
   completions of a device/filename. ]

grub> 

Come si vede, appare anche una breve spiegazione sull'uso della riga di comando, che segue l'invito grub>.

Se non si ricordano i comandi disponibili, si può ottenere un elenco di questi con il comando help; inoltre, sempre con help si può ottenere una descrizione più dettagliata sulla sintassi di un comando particolare:

grub> help[Invio]

cat FILE                               chainloader [--force] FILE
cmp FILE1 FILE2                        color NORMAL [HIGHLIGHT]
configfile FILE                        debug
device DRIVE DEVICE                    displayapm
displaymem                             embed STAGE1_5 DEVICE
find FILENAME                          fstest
geometry DRIVE [CYLINDER HEAD SECTOR [ halt [--no-apm]
help [PATTERN ...]                     hide PARTITION
impsprobe                              initrd FILE [ARG ...]
install [--stage2=STAGE2_FILE] [--forc ioprobe DRIVE
kernel [--no-mem-option] [--type=TYPE] lock
makeactive                             map TO_DRIVE FROM_DRIVE
md5crypt                               module FILE [ARG ...]
modulenounzip FILE [ARG ...]           partnew PART TYPE START LEN
parttype PART TYPE                     password [--md5] PASSWD [FILE]
pause [MESSAGE ...]                    quit
read ADDR                              reboot
root [DEVICE [HDBIAS]]                 rootnoverify [DEVICE [HDBIAS]]
savedefault                            serial [--unit=UNIT] [--port=PORT] [--
setkey [TO_KEY FROM_KEY]               setup [--prefix=DIR] [--stage2=STAGE2_
terminal [--dumb] [--timeout=SECS] [co testload FILE
testvbe MODE                           unhide PARTITION
uppermem KBYTES                        vbeprobe [MODE]

Per esempio, si può cercare di vedere meglio la sintassi del comando find:

grub> help find[Invio]

find: find FILENAME
    Search for the filename FILENAME in all of partitions and print
    the list of the devices which contain the file.

GRUB 1 è un sistema di avvio potente, ma ugualmente con delle limitazioni. In questo caso è stato mostrato un comando molto promettente, find, che però non può essere efficace quanto il programma omonimo dei sistemi Unix. Infatti, si deve tenere presente che GRUB 1 è sì in grado di completare i nomi, come fa la shell Bash, ma attualmente non riconosce i caratteri jolly. Pertanto, i file vanno indicati sempre come percorsi assoluti, dove spesso è obbligatoria anche l'indicazione del disco o della partizione in cui si trovano.

Volendo fare un esempio concreto, si può immaginare di voler avviare un sistema GNU/Linux con la partizione principale corrispondente al file di dispositivo /dev/hda6, ma con il kernel collocato all'inizio di una partizione separata, corrispondente al file di dispositivo /dev/hda1:

grub> kernel (hd0,0)/vmlinuz-2.4.2 root=/dev/hda6 ro[Invio]

Evidentemente, per scrivere un comando del genere occorre sapere bene come è strutturato il sistema di partizioni, oltre al nome e alla collocazione del file del kernel. Se le idee sono un po' confuse, si può sfruttare l'abilità di GRUB 1 nel completare i comandi. Si comincia con l'ispezionare i dischi:

grub> kernel (hd[Tab]

 Possible disks are:  hd0 hd1

In questo caso sono stati individuati due dischi fissi, ma si ritiene che il sistema da avviare risieda nel primo di questi due:

grub> kernel (hd0,[Tab]

 Possible partitions are:
   Partition num: 0,  Filesystem type is ext2fs, partition type 0x83
   Partition num: 1,  Filesystem type is fat, partition type 0x6
   Partition num: 4,  Filesystem type unknown, partition type 0x82
   Partition num: 5,  Filesystem type is ext2fs, partition type 0x83
   Partition num: 6,  Filesystem type is ext2fs, partition type 0x83

Si intuisce (oppure si riesce a ricordare) che la prima partizione dovrebbe essere stata usata per contenere i file del kernel, oltre ad altri file del sistema di avvio usato precedentemente, mentre si intende che la partizione principale del sistema operativo dovrebbe essere quella che qui viene indicata come la numero cinque. In pratica, non può esserlo la numero uno, perché contiene un file system Dos-FAT e non può esserlo la numero quattro, perché è una partizione di scambio della memoria virtuale.

grub> kernel (hd0,0)/[Tab]

Possible files are: lost+found System.map-2.2.15 boot.0300 boot.b
boot.b.preserved chain.b chain.b.preserved config-2.2.15 map mbr.b
os2_d.b os2_d.b.preserved part.0300 vmlinuz-2.2.15 System.map-2.4.2
config-2.4.2 vmlinuz-2.4.2

Come si vede, si ottiene così l'elenco dei file contenuti all'inizio della prima partizione del primo disco fisso. Si tratta evidentemente dei file usati da un altro sistema di avvio, assieme a due kernel. Si decide di avviare il kernel vmlinuz-2.4.2 e la ricerca termina, perché le altre informazioni sono specifiche del kernel (per cui GRUB 1 non può suggerirle):

grub> kernel (hd0,0)/vmlinuz-2.4.2 root=/dev/hda6 ro[Invio]

Naturalmente, così come sono state aggiunte le opzioni root=/dev/hda6 e ro, se ne possono aggiungere altre, in base alle proprie esigenze. Ciò che è stato mostrato rappresenta il minimo: l'indicazione della partizione principale del sistema e il fatto che la si vuole aprire inizialmente in sola lettura.

Al termine, si richiede espressamente di avviare il sistema con il comando boot:

grub> boot[Invio]

Un sistema GNU/Linux può richiedere per l'avvio anche l'utilizzo di un disco RAM iniziale. Supponendo che si tratti del file initrd contenuto all'inizio della prima partizione del primo disco fisso, bisogna aggiungere anche il comando seguente, prima di avviare con boot:

grub> initrd (hd0,0)/initrd[Invio]

51.5   Installazione

In questo contesto, per installazione si intende la sistemazione del sistema di avvio; ciò si può ottenere con il comando install, che però è molto complesso, oppure attraverso i comandi root e setup, dopo aver collocato i file necessari nella posizione che GRUB 1 si aspetta: la directory /boot/grub/.

GRUB 1 è un sistema di avvio molto «comodo», che consente di spostare il kernel e il file di configurazione senza dover ripristinare il settore di avvio. Tuttavia, dal momento che l'aggiornamento del pacchetto applicativo relativo a GRUB 1 non può andare a rimpiazzare i file della directory /boot/grub/, quando ci si dovesse ritrovare a reinstallare il settore di avvio nel modo che sta per essere descritto, è molto probabile che questo processo non funzioni più, a causa del fatto che la versione di GRUB 1 usato per installare è diversa da quella dei file in /boot/grub/. Pertanto, prima di procedere con un'installazione è indispensabile ricopiare i file necessari da /lib/grub/i386-pc/, o comunque dalla directory riferita alla propria architettura.

Come si può comprendere, la prima cosa da fare è decidere dove collocare i file di avvio di GRUB 1: si tratta precisamente dei file che nella distribuzione di GRUB 1 potrebbero trovarsi nella directory /lib/grub/i386-pc/. In condizioni normali, questa directory potrebbe trovarsi nella stessa partizione principale. Nella stessa directory va collocato il file di configurazione menu.lst, che viene descritto successivamente.

Si osservi che l'estensione di questo file è precisamente «elle-esse-ti».

A titolo di esempio, si potrebbe iniziare così:

cp /lib/grub/i386-pc/* /boot/grub/[Invio]

Quindi si avvia GRUB 1 dal sistema già in funzione, come nell'esempio seguente, oppure da un dischetto preparato appositamente (dischetto che comunque deve essere stato realizzato con la stessa versione dei file che si trovano poi nella directory /boot/grub/ della partizione usata per l'avvio):

grub[Invio]

Fatto questo si procede indicando la partizione in cui si trova la directory /boot/grub/, attraverso il comando root:

root partizione_di_avvio

Il comando root può far pensare alla partizione contenente il file system principale, ma invece si tratta solo di quello che contiene i file di avvio. Con questo comando, si indicano in un colpo solo tutti i file necessari, che per un sistema GNU/Linux sono normalmente /boot/grub/stage1, /boot/grub/e2fs_stage1_5, /boot/grub/stage2 e possibilmente anche /boot/grub/menu.lst.

Successivamente il comando setup verifica che i file si trovino effettivamente dove dovrebbero e provvede a installare il settore di avvio, assieme eventualmente al file *stage1_5, all'inizio del disco che gli viene indicato:

setup disco_di_avvio

Se i file di avvio non si trovano nella solita directory /boot/grub/, si può passare questa informazione al comando setup con un'opzione speciale:

setup --prefix=directory_file_di_avvio disco_di_avvio

In caso di dubbio, si può usare il comando find per individuare in modo certo la collocazione della directory /boot/grub/, specificando un file che sicuramente si deve trovare al suo interno, come nell'esempio seguente:

grub> find /boot/grub/stage1[Invio]

 (hd0,1)

Supponendo di avere verificato che si tratta della partizione corrispondente alla sigla (hd0,1), ovvero la seconda partizione del primo disco, sapendo che il settore di avvio va collocato all'inizio del primo disco, i comandi necessari potrebbero essere i seguenti:

grub> root (hd0,1)[Invio]

 Filesystem type is ext2fs, partition type 0x83

grub> setup (hd0)[Invio]

 Checking if "/boot/grub/stage1" exists... yes
 Checking if "/boot/grub/stage2" exists... yes
 Checking if "/boot/grub/e2fs_stage1_5" exists... yes
 Running "embed /boot/grub/e2fs_stage1_5 (hd0)"...  16 sectors are embedded.
succeeded
 Running "install /boot/grub/stage1 (hd0) (hd0)1+16 p (hd0,1)/boot/grub/stage2
/boot/grub/menu.lst"... succeeded
Done.

Come si può osservare, il comando setup, dopo una serie di controlli, avvia i comandi embed e install, che sarebbero un po' troppo difficili da usare direttamente.

Evidentemente, l'installazione può avvenire attraverso GRUB 1 avviato da un dischetto, oppure, in presenza di un sistema funzionante, con l'ausilio dell'eseguibile grub.

Quando si utilizza GRUB 1 attraverso il suo eseguibile avviato da un sistema già in funzione, si deve avere l'accortezza di non usare il comando boot e di terminare l'installazione con il comando quit.

grub> quit[Invio]

51.6   Configurazione

Il file di configurazione usato per l'avvio è, più precisamente, un menù di voci; come tale non si tratta di un file indispensabile e nemmeno è necessario ripetere l'installazione quando lo si modifica.

La struttura di questo file è molto semplice. In generale le righe vuote o bianche vengono ignorate; inoltre, le righe che iniziano con il simbolo # sono ignorate nello stesso modo (non sono ammessi commenti in coda a delle direttive).

Le direttive di questo file sono fondamentalmente gli stessi comandi che si possono impartire attraverso la riga di comando di GRUB 1, se il contesto lo consente, con l'aggiunta di qualche direttiva specifica:

[direttiva_specifica_del_menù
...
...]

title titolo
comando
...

[title titolo
comando
...]...

In pratica, a parte le righe bianche, vuote e quelle di commento, si possono inserire inizialmente delle direttive specifiche, quindi si individuano dei gruppi di direttive introdotti dalla direttiva title, che le distingue con un titolo.

All'avvio, viene visualizzato un menù composto dalle voci corrispondenti ai titoli indicati dalle direttive title. Selezionando una di quelle voci si ottiene l'esecuzione dei comandi indicati sotto la direttiva title corrispondente, con l'aggiunta finale del comando boot che è implicito e non va indicato nel file del menù.

default 0
timeout 5

title Debian GNU/Linux
kernel (hd0,5)/boot/vmlinuz root=/dev/hda6 console=tty12 ro

title Debian GNU/Linux (kernel vecchio)
kernel (hd0,5)/boot/vmlinuz.old root=/dev/hda6 console=tty12 ro

title FreeDOS
chainloader (hd0,0)+1

Si osservi l'esempio del listato che appare sopra. La direttiva default 0 indica di utilizzare in modo predefinito i comandi corrispondenti al primo titolo, se l'utente non tocca la tastiera entro cinque secondi, in base alla direttiva timeout 5, che appare subito dopo.

Sono presenti due voci per l'avvio di due kernel differenti utilizzando la stessa partizione principale, corrispondente al file di dispositivo /dev/hda6, con le stesse opzioni (che comunque riguardano il kernel e non GRUB 1). Inoltre, si può notare anche un titolo che fa riferimento a un sistema Dos, specificando che si deve usare il primo settore della prima partizione per avviarlo. Si può vedere il menù che si ottiene nella figura 51.11.

Figura 51.11. Esempio di un menù di GRUB 1.

    GRUB  version 0.90  (640K lower / 3072K upper memory)

.-------------------------------------------------------------------------.
| Debian GNU/Linux                                                        |
| Debian GNU/Linux (kernel vecchio)                                       |
| FreeDOS                                                                 |
|                                                                         |
|                                                                         |
|                                                                         |
|                                                                         |
`-------------------------------------------------------------------------'
     Use the ^ and v keys to select which entry is highlighted.
     Press enter to boot the selected OS, 'e' to edit the
     commands before booting, or 'c' for a command-line.


  The highlighted entry will be booted automatically in 5 seconds.

Come si può vedere dagli stessi suggerimenti che appaiono sullo schermo, quando ci si trova di fronte a un menù del genere, è possibile rinunciare e passare alla riga di comando premendo il tasto [c], oppure è possibile modificare i comandi di una voce utilizzando il tasto [e]. La figura 51.12 mostra come funziona la modifica di una voce del menù, nel caso fosse stata selezionata la prima voce.

Figura 51.12. Modifica della prima voce del menù di GRUB 1.

    GRUB  version 0.90  (640K lower / 3072K upper memory)

.-------------------------------------------------------------------------.
| kernel (hd0,5)/boot/vmlinuz root=/dev/hda6 console=tty12 ro            _|
|                                                                         |
|                                                                         |
|                                                                         |
|                                                                         |
|                                                                         |
|                                                                         |
`-------------------------------------------------------------------------'
     Use the ^ and v keys to select which entry is highlighted.
     Press 'b' to boot, 'e' to edit the selected command in the
     boot sequence, 'c' for a command-line, 'o' to open a new line
     after ('O' for before) the selected line, 'd' to remove the
     selected line, or escape to go back to the main menu.

Nelle sezioni seguenti vengono descritte le direttive e i comandi più importanti di GRUB 1.

51.6.1   Direttive specifiche per il file da usare come menù

Come accennato, alcune direttive hanno significato solo nel file di configurazione usato come menù. Queste direttive vanno collocate prima delle altre; precisamente vanno messe prima dell'elenco dei titoli che compongono in pratica le voci del menù stesso.

51.6.2   Comandi

I comandi sono quelle istruzioni che possono essere impartite a GRUB 1 attraverso la riga di comando, oppure sotto una voce di menù, nel file di configurazione. Alcuni dei comandi possono essere collocati prima delle voci del menù, quando si tratta di azioni da eseguire subito; ma in questa sezione non ne vengono descritti.

Tabella 51.13. Uso della tastiera nella riga di comando di GRUB 1.

Combinazione Alternativa Descrizione
[Ctrl f] [freccia destra] Sposta il cursore in avanti.
[Ctrl b] [freccia sinistra] Sposta il cursore all'indietro.
[Ctrl a] [Inizio] Sposta il cursore all'inizio della riga.
[Ctrl e] [Fine] Sposta il cursore alla fine della riga.
[Ctrl d] [Canc] Cancella il carattere nella posizione del cursore.
[Ctrl k] Taglia il testo dal cursore alla fine della riga.
[Ctrl u] Taglia il testo dall'inizio della riga al cursore.
[Ctrl y] Incolla quanto tagliato in precedenza nella posizione del cursore.
[Ctrl p] [freccia su] Scorre all'indietro lo storico dei comandi.
[Ctrl n] [freccia giù] Scorre in avanti lo storico dei comandi.

51.7   Configurazione dello sfondo

È possibile cambiare il colore dell'area del menù di GRUB 1 con il comando color, che può essere collocato sia prima delle voci del menù, sia al loro interno:

color primo_piano/sfondo [primo_piano/sfondo]

Gli argomenti del comando definiscono i colori da applicare, in due gruppi: il primo gruppo rappresenta i colori per il testo normale, mentre il secondo gruppo, eventuale, i colori per il testo evidenziato. In pratica, il testo normale in questione è costituito dalla zona delimitata dal bordo del menù e a questa zona si applica il primo gruppo di colori, mentre la barra di scorrimento delle voci del menù appare in modo evidenziato, utilizzando il gruppo di colori finale. Naturalmente, in mancanza del gruppo di colori finale vengono usati gli stessi colori del primo gruppo, ma invertiti.

I due gruppi di colori vanno specificati usando delle denominazioni prestabilite, secondo l'elenco della tabella successiva, ma si osservi che solo alcuni colori possono essere usati con successo per lo sfondo.

Tabella 51.14. Denominazione dei colori. Le tonalità scure si possono usare come colore dello sfondo, mentre quelle chiare si possono usare in primo piano.

Tonalità scura Tonalità chiara Descrizione
black
white
Nero, bianco.
blue
light-blue
Blu, blu chiaro.
green
light-green
Verde, verde chiaro.
cyan
light-cyan
Ciano (azzurro).
red
light-red
Rosso, rosso chiaro.
magenta
light-magenta
Magenta (violetto).
brown
yellow
Marrone, giallo.
dark-gray
light-gray
Grigio scuro, grigio chiaro.

Oltre alle denominazioni che appaiono in tabella, esclusivamente per la dichiarazione del colore di primo piano, si può specificare un nome con il prefisso blick-, per fare in modo che lampeggi. Vengono descritti alcuni esempi.

Oltre a cambiare il colore, è possibile mettere sullo sfondo un'immagine, preparata appositamente, da richiamare con il comando splashimage:

splashimage file

Il file in questione deve avere un formato particolare, in quanto deve trattarsi di un file XPM, da 640×480 punti con soli 14 livelli di colore, compresso con Gzip. Se si può contare sul pacchetto ImageMagick (sezione 756.2), si può trasformare un file da un formato comune a quello che serve con due passaggi molto semplici:

convert -resize 640x480! -colors 14 sfondo.png sfondo.xpm[Invio]

gzip sfondo.xpm[Invio]

Come si intuisce, si suppone di disporre di un file di partenza in formato PNG (sfondo.png), che prima viene trasformato generando il file XPM (sfondo.xpm) e poi viene compresso (sfondo.xpm.gz).

Il tutto è molto semplice, quello che non è semplice è trovare un'immagine che mantenga la sua grazia anche quando viene ridotta a soli 14 colori. A parte questa difficoltà, si deve tenere presente l'aspetto del menù di GRUB 1, che in pratica suggerisce di mettere le cose più significative dell'immagine nella parte inferiore (dove il menù non arriva).

Viene mostrato un esempio di compilazione del file /boot/grub/menu.lst, dove si fa uso dell'immagine di sfondo:

default 0
timeout 5
#
splashimage (hd0,1)/boot/grub/sfondo.xpm.gz
#
title Debian GNU/Linux
kernel (hd0,1)/boot/vmlinuz root=/dev/hda2 ro
#
title FreeDOS
chainloader (hd0,0)+1
#
title alt picture 1
splashimage (hd0,1)/boot/grub/spiaggia.xpm.gz
#
title alt picture 2
splashimage (hd0,1)/boot/grub/stelle.xpm.gz

Con questo file, viene mostrato inizialmente il menù con lo sfondo costituito dal file /boot/grub/sfondo.xpm.gz, ma l'utente, può selezionare la voce "alt picture 1", oppure "alt picture 2", per ottenere immagini diverse, prima dell'avvio di uno dei due sistemi previsti.

51.8   Menù con spiegazioni

Diversi sistemi di avvio, specialmente quando si usano da dischetto, consentono di scrivere delle note all'interno di file di testo richiamabili attraverso i tasti funzionali da [F1] a [F10]. Di solito in questi file si mettono delle spiegazioni, soprattutto delle note sulle opzioni del kernel da dare al volo.

GRUB 1 non consente di leggere dei file, ma offre il comando pause. Si potrebbe scrivere una voce del menù come questa:

...
title help 1
pause To install this system you have to... bla bla bla bla bla \
  \bla bla bla bla bla bla bla bla bla bla bla... # title help 2 pause If you want to run the system in single user mode you have \
  \to add an option...

Selezionando una delle due voci dal menù, queste vengono visualizzate, quindi, premendo un tasto qualunque, si passa oltre, ma non essendoci altre istruzioni, si ritorna al menù.

Ci sono due inconvenienti nell'uso del comando pause: non è possibile indicare espressamente dove si vuole andare a capo con il testo e si possono rappresentare soltanto circa 1 500 caratteri, pari a circa 19 righe di testo. Per risolvere il primo di questi due problemi si può realizzare un piccolo programma in Perl, dove si calcolano esattamente gli spazi necessari per andare a capo:

#!/usr/bin/perl
sub spaces
{
    my ($n)      = $_[0];
    my ($spaces) = "";
    while ($n > 0)
      {
        $spaces = $spaces . " ";
        $n--;
      }
    return ("$spaces");
}
#
($line) = "";
while ($line = <STDIN>)
  {
    chomp ($line);
    $line = $line . &spaces (80);
    print (substr ($line, 0, 79));
  }

In pratica, si leggono le righe del testo originale dallo standard input, a queste righe si aggiungono 80 spazi in coda, quindi si emettono solo i primi 79 caratteri, che non contengono alcun codice di avanzamento alla riga successiva. Ammesso che questo programma abbia il nome 79_col_no_ret, si potrebbe usare così:

79_col_no_ret < mio_file.txt > mia_riga[Invio]

Il file mio_file.txt viene trasformato nel file mia_riga, contenente solo una riga adatta a essere incollata come argomento del comando pause.

51.9   Protezione

Quando GRUB 1 mostra il menù derivante dalla configurazione contenuta nel file menu.lst, come già descritto, è possibile usare il tasto [e] per modificare delle opzioni. In questo modo, per esempio dando al kernel Linux l'opzione init=/bin/sh, è possibile acquisire i privilegi dell'utente root senza conoscere la parola d'ordine usata per questo nel sistema operativo. Per ovviare a questo inconveniente è possibile usare, all'inizio del file menu.lst, la direttiva password, per esempio così:

password --md5 $1$.zk80$GBhCYk6ig20coXJQG3ltk/
default 0
timeout 5
...
...

La stringa $1$.zk8... rappresenta la trasformazione della parola d'ordine scelta, attraverso un certo algoritmo. Per produrre tale stringa si usa il programma grub-md5-crypt:

grub-md5-crypt[Invio]

Password: parola_d'ordine[Invio]

Retype password: parola_d'ordine[Invio]

$1$.zk80$GBhCYk6ig20coXJQG3ltk/

La parola d'ordine cifrata viene emessa attraverso lo standard output, quindi va copiata in qualche modo nel file menu.lst, come già descritto. Quando poi ci si trova di fronte al menù di GRUB 1, tutti i comandi delicati risultano bloccati (pertanto il tasto [e] non funziona inizialmente), fino a quando si preme il tasto [p] (password): a quel punto GRUB 1 chiede la parola d'ordine e se corrisponde a quella che ha prodotto la stringa cifrata, si ottiene accesso ai comandi più impegnativi.


1) GRUB 1   GNU GPL


Appunti di informatica libera 2008 --- Copyright © 2000-2008 Daniele Giacomini -- <appunti2 (ad) gmail·com>


Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome grub_160_1.htm

[successivo] [precedente] [inizio] [fine] [indice generale] [indice ridotto] [indice analitico] [home]

Valid ISO-HTML!

CSS validator!

Gjlg Metamotore e Web Directory