[successivo] [precedente] [inizio] [fine] [indice generale] [violazione licenza] [translators] [docinfo] [indice analitico] [volume] [parte]

Capitolo 27. GRUB

GRUB ⁽¹⁾ è una procedura relativamente nuova per il caricamento di GNU/Linux e molti altri sistemi operativi negli elaboratori con architettura i386. GRUB è 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.

27.1 Logica generale

In condizioni normali, quando si installa il pacchetto GRUB nel proprio sistema, si dovrebbero trovare i file salienti nella directory /usr/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 (lasciando 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 /usr/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 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 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 è 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, 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 emula il comportamento del sistema di avvio e può essere usato proprio per installarlo. La riga di comando di GRUB 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 xvi, che si riferisce in generale alle shell POSIX).

27.2 Dischi, partizioni, percorsi e blocchi di settori

GRUB è 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 i386). 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:

(hdm,n)

In questo modo, si fa riferimento al disco m-esimo (come è già stato mostrato) e alla partizione n-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:

(hdm[,n],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 /boot/vmlinuz-2.4.2, si può indicare (hd0,0)/boot/vmlinuz-2.4.2.

Bisogna evitare di fare confusione: il percorso che segue l'indicazione del disco o della partizione è riferito al disco o alla partizione stessa. GRUB non può essere al corrente della struttura di un file system articolato attraverso diversi innesti, montando più partizioni assieme 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 è 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.

27.3 Dischetto GRUB di emergenza

Prima di installare GRUB come sistema di avvio per il proprio elaboratore, conviene fare delle prove non distruttive. La cosa migliore è preparare almeno un dischetto contenente GRUB, 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 /usr/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 /usr/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 /usr/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.ROW, 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]

27.4 Funzionamento interattivo

Una volta preparato il dischetto contenente GRUB, 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 è un sistema di avvio molto potente, ma rimangono ugualmente 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 è 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 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.prese
rved chain.b chain.b.preserved config-2.2.15 map mbr.b os2_d.b os2_d.b.preserve
d 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 è terminata, perché le altre informazioni sono specifiche del kernel (per cui GRUB 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]

27.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 si aspetta: la directory /boot/grub/.

GRUB è 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 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 usato per installare è diversa da quella dei file in /boot/grub/. Pertanto, prima di procedere con un'installazione è indispensabile ricopiare i file necessari da /usr/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: si tratta precisamente dei file che nella distribuzione di GRUB potrebbero trovarsi nella directory /usr/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 /usr/lib/grub/i386-pc/* /boot/grub/[Invio]

Quindi si avvia GRUB 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 avviato da un dischetto, oppure, in presenza di un sistema funzionante, con l'ausilio dell'eseguibile grub.

Quando si utilizza GRUB 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]

27.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, 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 (2.4.2)
kernel (hd0,5)/boot/vmlinuz-2.4.2 root=/dev/hda6 console=tty12 ro

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

title FreeDOS
chainloader (hd0,1)+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). 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 27.1.

Figura 27.1. Esempio di un menù di GRUB.

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

.-------------------------------------------------------------------------.
| Debian GNU/Linux (2.4.2)                                                |
| Debian GNU/Linux (2.2.15)                                               |
| 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 27.2 mostra come funziona la modifica di una voce del menù, mostrando il caso della prima.

Figura 27.2. Modifica della prima voce del menù di GRUB.

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

.-------------------------------------------------------------------------.
| kernel (hd0,5)/boot/vmlinuz-2.4.2 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.

27.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.

default n

Consente di specificare l'n-esima voce del menù come predefinita (la prima voce corrisponde allo zero). Si abbina normalmente alla direttiva timeout.
fallback n

Si usa questa direttiva in abbinamento con default, per indicare una voce alternativa del menù, nel caso quella predefinita non sia valida per qualche ragione.
timeout n

Fissa la quantità di secondi, trascorsi i quali viene selezionata automaticamente la voce predefinita, corrispondente alla prima, oppure a quella indicata con la direttiva default.
title titolo

Descrive l'inizio di una voce del menù, denominata con il titolo indicato. Tutti i comandi che seguono questa direttiva, fino alla direttiva title successiva, appartengono a questa voce.

27.6.2 Comandi

I comandi sono quelle istruzioni che possono essere impartite a GRUB attraverso la riga di comando, oppure sotto una voce di menù, nel file di configurazione.

boot

Richiede esplicitamente l'avvio del sistema operativo in base ai comandi impartiti in precedenza. Generalmente si usa solo in modalità interattiva, perché nell'ambito del file di configurazione, questo comando è implicito.
cat file

Consente di visualizzare il contenuto di un file. Può essere utile per verificare quello che sembra essere un file di configurazione, prima di caricarlo.
chainloader file

Avvia un altro programma di avvio. In generale, il file viene indicato come un gruppo di settori; di solito si tratta di un solo settore.
configfile file

Carica un file inteso come menù (file di configurazione) e lo esegue.
initrd file

Carica il file come disco RAM iniziale (riguarda solo i kernel Linux).
kernel file [opzioni]

Seleziona il kernel indicato; se si aggiungono altre informazioni, vengono passate come opzioni al kernel stesso.
install file_stage1 [d] disco_di_avvio file_stage2 [p] [file_di_configurazione]

Il comando install può essere usato da solo al posto di root e setup, per installare il sistema di avvio, ma richiede più dettagli rispetto a questi ultimi.

Il modello sintattico che si vede qui è semplificato rispetto a quello reale, ma è sufficiente nelle situazioni più comuni. L'opzione d serve a stabilire la collocazione del file stage2 nel disco e nella partizione indicati, senza una relazione con il disco di avvio; l'opzione p è necessaria quasi sempre e serve a richiedere una serie di modifiche al file stage2 e anche al settore di avvio. Si veda eventualmente la documentazione originale per un dettaglio maggiore nell'uso di questo comando.
pause messaggio

Mostra il messaggio e attende la pressione di un tasto.
quit

Nel caso si stia utilizzando GRUB attraverso l'eseguibile grub, su un sistema già avviato, è possibile concludere il funzionamento con questo comando.
root partizione

Definisce la «partizione corrente», ovvero la partizione a cui fare riferimento quando ciò non viene indicato nei percorsi. Si usa normalmente in abbinamento a setup, per installare il sistema di avvio (senza dover dare il comando install che può risultare eccessivamente complesso).
setup {disco|partizione}

Installa il sistema di avvio, modificando il primo settore del disco o della partizione specificati. Il comando setup va a cercare i file necessari (stage1, stage2, *_stage1_5 e menu.lst nella directory /boot/grub/, o in mancanza in /grub/, della partizione che deve essere specificata precedentemente con il comando root.

Tabella 27.1. Uso della tastiera nella riga di comando di GRUB.

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.

1) GRUB GNU GPL

Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome grub.html

[successivo] [precedente] [inizio] [fine] [indice generale] [violazione licenza] [translators] [docinfo] [indice analitico]