GRUB Legacy (Italiano) - ArchWiki

# GRUB Legacy (Italiano)

From ArchWiki

Articoli correlati

- Boot debugging
- GRUB2 (Italiano)
- grub-gfx (Italiano)
- Kernel parameters
- LILO
- MBR

GNU GRUB (Legacy) è un bootloader multiboot mantenuto dal GNU Project. Deriva da GRUB, il GRand Unified Bootloader, che è stato originariamente progettato e realizzato da Erich Stefan Boleyn.

Brevemente, il bootloader è il primo programma che si avvia quando si accende il computer. È il responsabile del controllo di caricamento e di trasferimento al kernel Linux. Il kernel, a sua volta, inizializza il resto del sistema operativo.

Nota: GRUB Legacy è completamente deprecato e rimpiazzato da GRUB 2.x. Si consiglia di prendere visione di questa news. Si raccomanda l'utilizzo di GRUB2 o Syslinux.

## Installazione

grub-legacyAUR era installato di base quando si installava Arch Linux. Ora il suo supporto è terminato ed è stato spostato su aur.

GRUB deve essere installato nel settore di boot di un'unità o di una partizione per funzionare come bootloader. Ciò è spiegato nella sezione #Installazione del bootloader.

## Aggiornamento a GRUB(2)

### È necessario aggiornare?

La risposta breve è no. GRUB legacy non sarà rimosso dal sistema e continuerà a funzionare.

D'altra parte però, come ogni pacchetto non più supportato dall'upstream, eventuali bug non verranno risolti. Per questo motivo è necessario prendere in considerazione l'idea di aggiornare GRUB alla versione 2.x, o un altro Boot loader supportato.

GRUB Legacy non supporta partizioni GPT, il filesystem Btrfs e il firmware UEFI.

### Come effettuare l'aggiornamento

Aggiornare da GRUB Legacy a GRUB 2.x) è la stessa cosa che installare GRUB 2.x da un sistema Arch avviato. Tutti i dettagli sono sulla relativa pagina GRUB (Italiano)#Installazione.

## Configurazione

Il file di configurazione si trova in `/boot/grub/menu.lst`. Modificare questo file in base alle proprie esigenze.

- `timeout #` -- tempo d'attesa (in secondi) prima che il sistema operativo di `default` venga automaticamente caricato.
- `default #` -- la voce d'avvio di default che viene scelta quando il `timeout` termina.

Una configurazione d'esempio (con `/boot` su una partizione separata):

    /boot/grub/menu.lst

    # Config file for GRUB - The GNU GRand Unified Bootloader
    # /boot/grub/menu.lst

    # DEVICE NAME CONVERSIONS
    #
    #  Linux           GRUB
    # -------------------------
    #  /dev/fd0        (fd0)
    #  /dev/sda        (hd0)
    #  /dev/sdb2       (hd1,1)
    #  /dev/sda3       (hd0,2) (hd0,0
    #

    #  FRAMEBUFFER RESOLUTION SETTINGS
    #     +-------------------------------------------------+
    #          | 640x480    800x600    1024x768   1280x1024
    #      ----+--------------------------------------------
    #      256 | 0x301=769  0x303=771  0x305=773   0x307=775
    #      32K | 0x310=784  0x313=787  0x316=790   0x319=793
    #      64K | 0x311=785  0x314=788  0x317=791   0x31A=794
    #      16M | 0x312=786  0x315=789  0x318=792   0x31B=795
    #     +-------------------------------------------------+
    #  for more details and different resolutions see
    #  https://wiki.archlinux.org/index.php/GRUB#Framebuffer_Resolution

    # general configuration:
    timeout   5
    default   0
    color light-blue/black light-cyan/blue

    # boot sections follow
    # each is implicitly numbered from 0 in the order of appearance below
    #
    # TIP: If you want a 1024x768 framebuffer, add "vga=773" to your kernel line.
    #
    #-*

    # (0) Arch Linux
    title  Arch Linux
    root   (hd0,0)
    kernel /vmlinuz-linux root=/dev/sda3 ro
    initrd /initramfs-linux.img

    # (1) Windows
    #title Windows
    #rootnoverify (hd0,0)
    #makeactive
    #chainloader +1

### Trovare la root di GRUB

GRUB deve conoscere dove si trovano i suoi file nel sistema, dal momento che potrebbero esistere più istanze (ad esempio, in ambienti multi-boot). I file di GRUB risiedono sempre sotto `/boot`, che potrebbe trovarsi su una partizione dedicata.

Note: GRUB definisce i dispositivi d'archiviazione in maniera diversa da come lo fa il kernel.

- Gli Hard disk sono definiti come (hdX), questo si riferisce anche a qualsiasi dispositivo d'archiviazione USB.
- La numerazione dei dispositivi e delle partizioni comincia da zero. Ad esempio, il primo hard disk riconosciuto dal BIOS sarà definito come (hd0). Il secondo dispositivo sarà chiamato (hd1). Ciò viene applicato anche alle partizioni. Quindi, la seconda partizione nel primo hard disk sarà definita come (hd0,1).

Se non si è sicuri della posizione di `/boot`, si usi il comando della shell di GRUB `find` per individuare i file di GRUB. Si entri nella shell di GRUB da root con:

    # grub

L'esempio seguente è per sistemi "senza" una partizione separata di `/boot`, dove `/boot` è semplicemente una cartella sotto `/`:

    grub> find /boot/grub/stage1

L'esempio seguente è per sistemi "con" una partizione di `/boot` separata:

    grub> find /grub/stage1

GRUB troverà i file, ed indicherà la corretta posizione del file `stage1`. Ad esempio:

    grub> find /grub/stage1

     (hd0,0)

Questo valore deve essere inserito nella linea `root` nel proprio file di configurazione. Si digiti `quit` per uscire dalla shell.

### Dual booting con Windows

Si aggiunga ciò che segue alla fine del file `/boot/grub/menu.lst` (presupponendo che la partizione di Windows si trovi sulla prima partizione del primo dispositivo d'archiviazione):

    /boot/grub/menu.lst

     title Windows
     rootnoverify (hd0,0)
     makeactive chainloader +1

Nota: Se sul proprio computer si ha in dual-boot ArchLinux e Windows 7, si dovrà commentare la linea `makeactive`
Note: Windows 2000 e le versioni successive NON hanno bisogno di trovarsi nella prima partizione per essere avviate (contrariamente alla credenza popolare). Se la partizione di Windows dovesse cambiare (ad esempio se si aggiunge una partizione prima di quella di Windows), sarà necessario editare il file di Windows `boot.ini` per indicarne il cambiamento (si veda questo articolo per i dettagli su come farlo).

Nel caso in cui Windows si trovi su un'altro hard disk, occorre usare il comando `map`. Ciò farà si che l'installatore di Windows pensi di trovarsi sul primo dispositivo. Supponendo che la partizione di Windows si trovi sulla prima partizione del secondo dispositivo d'archiviazione:

    /boot/grub/menu.lst

     title Windows
     map (hd0) (hd1)
     map (hd1) (hd0)
     rootnoverify (hd1,0)
     makeactive
     chainloader +1

Nota: Se sul proprio computer si ha in dual-boot ArchLinux e Windows 7, si dovrà commentare la linea `makeactive`

### Dual booting con GNU/Linux

Ciò può essere fatto nella stessa maniera in cui viene definita un'installazione di Arch Linux. Ad esempio:

    /boot/grub/menu.lst

     title Other Linux
     root (hd0,2)
     kernel /path/to/kernel root=/dev/sda3 ro
     initrd /path/to/initrd

Note: Comunque, potrebbero esserci altre opzioni necessarie, e potrebbe non essere usato un iniziale RAM disk. Si analizzi il `/boot/grub/menu.lst` delle altre distribuzioni per aggiungerne le opzioni d'avvio, o si veda #chainloader e configfile (raccomandato).

### `chainloader` e `configfile`

Per facilitare la manutenzione del sistema, il comando `chainloader` o `configfile` dovrebbe essere usato per avviare un'altra distribuzione Linux che fornisce un meccanismo di configurazione GRUB "automatico" (ad esempio Debian, Ubuntu, openSUSE). Ciò permette alla distribuzione di mantenere il proprio `menu.lst` e le opzioni di boot.

- Il comando `chainloader` avvierà un altro bootloader (piuttosto che un'immagine kernel); utile se un'altro bootloader è installato in un settore di boot di una partizione (GRUB, ad esempio). Ciò permette di installare un'istanza "principale" di GRUB nel MBR e istanze di GRUB specifiche delle distribuzioni in ogni settore boot di partizione (PBR).

- Il comando `configfile` avvisa l'istanza corrente di GRUB di caricare il file di configurazione specificato. Ciò può essere usato per avviare il `menu.lst` di un'altra distribuzione senza un'installazione separata di GRUB. Il problema di quest'approccio è che l'altro `menu.lst` potrebbe non essere compatibile con la versione installata di GRUB; alcune distribuzioni creano infatti pesanti patch alla propria versione di GRUB.

Ad esempio, GRUB deve essere installato nel MBR e qualche altro bootloader (sia esso GRUB o LILO) è già installato nel settore boot di `(hd0,2)`.

    ---------------------------------------------
    |   |           |           |   %           |
    | M |           |           | B %           |
    | B |  (hd0,0)  |  (hd0,1)  | L %  (hd0,2)  |
    | R |           |           |   %           |
    |   |           |           |   %           |
    ---------------------------------------------
      |                           ^
      |       chainloading        |
      -----------------------------

Si può semplicemente includere in `menu.lst`:

    title Altro Linux
    root (hd0,2)
    chainloader +1

O, se il bootloader in `(hd0,2)` è GRUB:

    title Altro Linux
    root (hd0,2)
    configfile /boot/grub/menu.lst

Il comando `chainloader` può anche essere usato per caricare l'MBR di un secondo dispositivo:

    title Altro Disposisitivo
    rootnoverify (hd1)
    chainloader +1

### Dual boot con GNU/Linux (Grub2)

Se l'altra distribuzione Linux utilizza Grub2 (es. Ubuntu 9.10+), e si ha installato il relativo boot loader per la relativa partizione di root, è possibile aggiungere una voce come questa nel `/boot/grub/menu.lst`:

    /boot/grub/menu.lst

     # Altra distribuzione Linux che usa Grub2
     title Ubuntu
     root (hd0,2)
     kernel /boot/grub/core.img

Selezionando questa voce dal menu di avvio verrà caricato il menu di Grub2 dell'altra distribuzione, assumendo che questa sia installata su `/dev/sda3`.

## Installazione del bootloader

### Recupero manuale di GRUB libs

Normalmente i file interessati (`*stage*`) dovrebbero essere in `/boot/grub`, salvo nei casi in cui il bootloader non sia stato installato durante l'installazione del sistema o la partizione/filesystem sia danneggiato, o accidentalmente cancellato.

Copiare manualmente le librerie grub così:

    # cp -a /usr/lib/grub/i386-pc/* /boot/grub

Note: Non dimenticare di installare la partizione di boot del sistema se il programma di installazione utilizza una partizione separata! Quanto sopra presuppone che o la partizione di boot risiede sul filesystem di root o è montata in /boot nel file system di root!

### Note generali di installazione del bootloader

GRUB può essere installato da un supporto separato (ad esempio un live CD), o direttamente da un'installazione di arch in esecuzione. È raramente necessario che il bootloader GRUB debba essere reinstallato, e l'installazione non è necessaria quando:

- Il file di configurazione viene aggiornato.
- Il pacchetto grub è aggiornato.

L'installazione è necessaria quando:

- Un bootloader non è già installato.
- Un altro sistema operativo sovrascrive il bootloader di Linux.
- Il bootloader fallisce per qualche motivo sconosciuto.

Prima di continuare, alcune osservazioni:

- Assicurarsi che la configurazione di GRUB sia corretta (`/boot/grub/menu.lst`) prima di procedere. Fare riferimento a #Trovare la root di GRUB per verificare che i dispositivi siano definiti in modo corretto.
- GRUB deve essere installato nel MBR MBR (primo settore del disco rigido), o la prima partizione della periferica di archiviazione per poter essere riconosciuto dalla maggior parte dei BIOS. Per consentire alle distribuzioni la capacità di gestire i propri menu di GRUB, possono essere utilizzate più istanze di GRUB. Si veda #chainloader e configfile.
- Per installare il bootloader GRUB, può essere necessario intervenire dall'interno di un ambiente `chroot` (cioè da un ambiente installato tramite un supporto separato) per casi come configurazioni RAID o se si è dimenticata o danneggiata l'installazione di GRUB. Sarà necessario eseguire l'operazione di Change root da un LiveCD o da un'altra installazione di Linux per poterlo fare.

In primo luogo, inserire la shell di GRUB:

    # grub

Utilizzare il comando `root` con l'output del comando `find` (consultare #Trovare la root di GRUB) per istruire GRUB su quale partizione contiene lo stage1 (e quindi, `/boot`):

    grub> root (hd1,0)

Tip: La shell di GRUB supporta anche la scheda di completamento. Se si digita "root hd" e si preme due volte Tab si potranno vedere le periferiche di archiviazione disponibili, e lo stesso può essere fatto anche per le partizioni. La tab-completion funziona anche dal menu di avvio di GRUB. Se c'è un errore nel file di configurazione è possibile modificarlo nel menù di avvio, e aiutandosi con la scheda di completamento, trovare i dispositivi e le partizioni. Consultare #Modificare le voci GRUB nel menu di avvio.

### Installazione nel MBR

L'esempio seguente installa GRUB nel MBR del primo disco:

    grub> setup (hd0)

### Installazione su una partizione

L'esempio seguente installa GRUB sulla prima partizione del primo disco:

    grub> setup (hd0,0)

Dopo aver eseguito il programma di installazione `setup`, digitare `quit` per uscire dalla shell. Se si è in ambiente chroot, uscire da chroot e smontare le partizioni. Adesso riavviare per fare un test.

### Metodo alternativo (installazione di grub)

Nota: Questa procedura è nota per essere meno affidabile, il metodo consigliato è quello di utilizzare la shell di GRUB.

Utilizzare il comando `grub-install` seguito dal percorso su cui installare il bootloader. Ad esempio, per installare il bootloader GRUB nel MBR del primo disco:

    # grub-install /dev/sda

GRUB viene indicato se installato correttamente. Se così non fosse, si dovrà utilizzare il metodo shell di GRUB.

## Suggerimenti

Note di configurazione aggiuntive.

### Avvio grafico

Per coloro che desiderano un aspetto grafico esteticamente più rifinito, consultare grub-gfx. GRUB2 offre funzionalità grafiche avanzate, come immagini di sfondo e caratteri bitmap.

### Risoluzione framebuffer

Si può utilizzare la risoluzione fornite nel `menu.lst`, ma si può eventualmente utilizzare il proprio LCD wide-screen a la sua risoluzione nativa. Ecco cosa si può fare per ottenere questo risultato:

Su Wikipedia c'è una lista di risoluzioni framebuffer esteso (cioè oltre quelle standard VBE). Ma, per esempio, quella che si vuole usare per 1440x900 (`vga=867`) non funziona. Questo perché il produttori di schede grafiche sono liberi di scegliere qualsiasi numero desiderano, in quanto questo non fa parte dello standard VBE 3. Questo è il motivo per cui questi codici possono variare da una scheda all'altra (eventualmente anche per il produttore stesso).

Così, invece di usare quella tabella, è possibile utilizzare uno degli strumenti indicati in seguito per ottenere il codice corretto:

#### Valore riconosciuto del GRUB

Questo è un modo semplice per trovare il codice di risoluzione usando solo GRUB.

Sulla riga del kernel, specificare che il kernel richieda quale modalità utilizzare.

    kernel /vmlinuz-linux root=/dev/sda1 ro vga=ask

Adesso riavviare. GRUB presenterà ora un elenco di codici adatti per l'uso, oltre l'opzione per cercarne altri.

Scegliere il codice che si desidera utilizzare (non dimenticarlo, in quanto necessario per il passaggio successivo) e avviare utilizzandolo.

Ora sostituire `ask` nella riga del kernel con quello che si è scelto.

Per esempio la riga del kernel per `[369] 1680x1050x32` sarebbe:

    kernel /vmlinuz-linux root=/dev/sda1 ro vga=0x369

#### hwinfo

1. Installare hwinfo da [community].
2. Eseguire `hwinfo --framebuffer` da root.
3. Utilizzare il codice corrispondente alla risoluzione desiderata.
4. Utilizzare il codice a 6 cifre con prefisso 0x nell'opzione del kernel `vga=` in `menu.lst`. O convertirlo in decimale per evitare l'uso del prefisso 0x.

Esempio dell'output di hwinfo:

    Mode 0x0364: 1440x900 (+1440), 8 bits
    Mode 0x0365: 1440x900 (+5760), 24 bits

E la riga del kernel:

    kernel /vmlinuz-linux root=/dev/sda1 ro vga=0x0365

Note: vbetest dà la modalità VESA a cui si deve aggiungere 512 per ottenere il valore corretto da utilizzare nella riga del kernel, mentre hwinfo dà direttamente il valore corretto necessario al kernel.

#### vbetest

1. Installare il pacchetto lrmiAUR[broken link: archived in aur-mirror] da AUR contenente il tool vbetest (gli utenti x86_64 dovranno utilizzare #hwinfo sotto).
2. Avviare `vbetest` da root
3. Prendere nota del numero in [ ] corrispondente alla risoluzione desiderata.
4. Premere 'q' per uscire dal prompt interattivo di vbetest.
   1. Come opzione, in una console come root, è possibile testare la modalità che appena scelta eseguendo `vbetest -m <yourcode>` e vedere un modello come questo
5. Aggiungere 512 al valore preso in precedenza ed usare il valore complessivo per definire il parametro `vga=` nelle opzioni del kernel di `menu.lst`.
6. Riavviare per godersi il risultato

Esempio di vbetest su un computer:

    [356] 1440x900 (256 color palette)
    [357] 1440x900 (8:8:8)

Quindi, il valore che si desidera è 357. Poi, 357 + 512 = 869, quindi sarà necessario utilizzare vga=869. Aggiungere il valore alla fine della riga del kernel in `menu.lst` come indicato di seguito:

    kernel /vmlinuz-linux root=/dev/sda1 ro vga=869

Note:

- (8:8:8) is for 24-bit color (24bit is 32bit)
- (5:6:5) is for 16-bit color
- (5:5:5) is for 15-bit color

### Nominare le partizioni

#### Per etichetta

Se si altera (o si prevede di modificare) le dimensioni delle partizioni di tanto in tanto, potrebbe essere utile la definizione dei dispositivi e partizioni per mezzo delle etichette. È possibile assegnare delle etichette alle partizioni ext2, ext3, ext4 con:

    e2label </dev/drive|partition> label

Il nome dell'etichetta può essere lungo fino a 16 caratteri, ma non deve avere spazi, altrimenti GRUB potrebbe non riconoscerlo. Infine, definirlo in `menu.lst`:

    kernel /boot/vmlinuz-linux root=/dev/disk/by-label/Arch_Linux ro

#### Per UUID

Gli UUID (Universally Unique IDentifier) di una partizione possono essere scoperti con il comando `blkid` o `ls -l /dev/disk/by-uuid`. Possono essere definiti in `menu.lst` così:

    kernel /boot/vmlinuz-linux root=/dev/disk/by-uuid/<uuid number>

o

    kernel /boot/vmlinuz-linux root=UUID=<uuid number>

### Eseguire il boot come root (single-user mode)

Quando appare il menù di GRUB, selezionare la voce che si desidera e premere il tasto `e`, aggiungere alle opzioni del kernel:

    [...] single init=/bin/bash

ed eseguire il boot. Questo farà partire (solo per questa sessione) il kernel in sigle-user mode (init 1). Alla fine del processo di boot ci si troverà in un prompt di root senza che venga richiesta alcuna password.

Questo procedimento può essere utile ad esempio per cambiare la password di root. Tuttavia è una notevole "falla nella sicurezza" se non si ha impostato una password a GRUB.

### Protezione con password

È possibile abilitare la protezione con password nel file di configurazione di GRUB per i sistemi operativi che si desidera avere protetti. La protezione tramite password al bootloader può essere richiesta se il BIOS non ha tale funzionalità e si ha bisogno di maggiore sicurezza.

In primo luogo, scegliere una password facile da ricordare e poi cifrarla:

    # grub-md5-crypt
    Password:
    Retype password:
    $1$ZOGor$GABXUQ/hnzns/d5JYqqjw

Poi aggiungere la password all'inizio del file di configurazione di GRUB (la password deve essere all'inizio del file di configurazione di GRUB per poter essere riconosciuta):

    # general configuration
    timeout   5
    default   0
    color light-blue/black light-cyan/blue

    password --md5 $1$ZOGor$GABXUQ/hnzns/d5JYqqjw

Nota: Ricordare che grub usa come layout predefinito della tastiera lo standard qwerty.

Poi, per ogni sistema operativo che si desidera proteggere, aggiungere il comando `lock`:

    # (0) Arch Linux
    title  Arch Linux
    lock
    root   (hd0,1)
    kernel /boot/vmlinuz-linux root=/dev/disk/by-label/Arch_Linux ro
    initrd /boot/initramfs-linux.img

Attenzione: Se si disattiva l'avvio da altri dispositivi di avvio (come un disco CD) nelle impostazioni del BIOS, e poi si attivano con password tutte le voci dei sistemi operativi, potrebbe essere difficile riabilitare di nuovo i boot di tali sistemi se le password vengono dimenticate.

È comunque sempre possibile resettare il BIOS del proprio pc. Per farlo si dovrà seguire la documentazione della propria scheda madre (che è specifica del modello usato).

### Riavviare con la scelta nominale di boot

Spesso la necessità di passare ad un altro sistema operativo non-predefinito (ad esempio Windows), dover riavviare e attendere che il menu di GRUB appaia è noioso. GRUB offre un modo per registrare la scelta del sistema operativo al riavvio invece di aspettare il menu, designando un nuovo default temporaneo, che verrà ripristinato non appena usato.

Supponendo una semplice configurazione `menu.lst` come questa:

    /boot/grub/menu.lst

    # general configuration:
    timeout 10
    default 0
    color light-blue/black light-cyan/blue

    # (0) Arch
    title  Arch Linux
    root (hd0,1)
    kernel /boot/vmlinuz-linux root=/dev/disk/by-label/ARCH ro
    initrd /boot/initramfs-linux.img

    # (1) Windows
    title Windows XP
    rootnoverify (hd0,0)
    makeactive
    chainloader +1

Arch è l'impostazione predefinita (0). Si vuole riavviare Windows. Cambiare `default 0` a `default saved`. Questo registra il default corrente in un file di `default` nella directory di GRUB quando è usato il comando savedefault. A questo punto aggiungere la riga `savedefault 0` al fondo della voce di Windows. Ogni volta che Windows viene avviato, sarà reimpostato il valore predefinito di Arch, rendendo quindi provvisorio, il default di Windows.

Ora tutto quello che serve è un modo per cambiare facilmente il default manualmente. Ciò può essere eseguito utilizzando il comando `grub-set-default`. Quindi, per riavviare Windows, eseguire il seguente comando:

    $ sudo grub-set-default 1 && sudo shutdown -r now

Per facilità d'uso, potrebbe essere comodo abilitare "Allow user to shutdown fix" (includendo `/sbin/grub-set-default` tra i comandi sono consentite all'utente le operazioni di spegnimento senza dover fornire la password).

### Interazione LILO e GRUB

Se il pacchetto LILO è installato sul sistema, rimuoverlo con

    # pacman -R lilo

Alcuni tipi di attività (ad esempio, la compilazione del kernel usando `make all`), effettuano una richiamata a LILO, che potrebbe pertanto essere sovrascritto su GRUB. LILO può essere stato incluso nel sistema di base, a seconda della versione dell'installer o se è stato selezionato/deselezionato durante la fase di selezione dei pacchetti.

Note: `pacman-R lilo` potrebbe non rimuovere LILO dal MBR se vi è stato installato, ma si limiterà a rimuovere il pacchetto liloAUR. LILO verrà sovrascritto definitivamente quando sarà reinstallato GRUB (o un altro bootloader).

### GRUB boot disk

In primo luogo, formattare un disco floppy:

     fdformat /dev/fd0
     mke2fs /dev/fd0

Ora montare il disco:

     mount -t ext2 /dev/fd0 /mnt/fl

Installare GRUB sul disco:

     grub-install --root-directory=/mnt/fl '(fd0)'

Copiare il file `menu.lst` sul disco:

     cp /boot/grub/menu.lst /mnt/fl/boot/grub/menu.lst

Infine, smontare il floppy:

     umount /mnt/fl

Ora si dovrebbe essere in grado di riavviare il computer con il disco nel lettore e si dovrebbe avviare GRUB. Assicurarsi ovviamente, che il floppy sia impostato per avere la priorità d'avvio rispetto gli altri dispositivi nel BIOS.

Consultare inoltre: Super GRUB Disk

### Nascondere il menu di GRUB

L'opzione `hiddenmenu` può essere usata per nascondere il menu di default. Nascondendo il menu viene automaticamente selezionata la voce di default appena trascorso il tempo impostato. Per mostrare il menu sarà sufficiente premere `Esc`. Per usare questa caratteristica è sufficiente aggiungere la seguente riga a `/boot/grub/menu.lst`:

    hiddenmenu

## Modalità debug avanzata

L'intera sezione è in Boot debugging (Italiano)

## Risoluzione dei problemi

### GRUB Errore 17

Note: La soluzione qui illustrata funziona anche per il "GRUB Error 15"

Il primo controllo da fare è scollegare qualsiasi unità esterna. Sembra ovvio, ma a volte capita!)

Se la tabella delle partizioni non è ben configurata, uno spiacevole messaggio "GRUB error 17" potrebbe essere l'unica cosa che vi apparirà al seguente riavvio. Ci sono un certo numero di motivi per cui la tabella delle partizioni potrebbe risultare disordinata. Comunemente, gli utenti che manipolano le partizioni con GParted (le unità logiche in particolare) possono invertire l'ordine delle partizioni. Ad esempio, eliminando `/dev/sda6` e ridimensionando `/dev/sda7`, per poi ricreare quello che era `/dev/sda6`, ed ottenendolo tuttavia in fondo alla lista, come `/dev/sda9`. Anche se l'ordine fisico delle partizioni/unità logiche, non è cambiata, lo è l'ordine in cui vengono riconosciute.

La correzione della tabella delle partizioni è un'operazione facile. Basta avviare il sistema dal cd di Arch, eseguire il login come root e modificare adeguatamente la tabella delle partizioni:

    # fdisk /dev/sda

Una volta selezionata la partizione, immettere [x] per la modalità extra/expert, [f] per correggere l'ordine delle partizioni, ed infine [w] per sovrascrivere la tabella delle partizioni e uscire.

È possibile verificare che la tabella delle partizioni è stata correttamente modificata con `fdisk -l`. Ora c'è solo bisogno di verificare GRUB. Consultare la sezione#Installazione del bootloader sopra.

Fondamentalmente si deve istruire GRUB sul percorso corretto del file `/boot` e poi riscrivere GRUB nel MBR del disco.

Per esempio:

    # grub

    grub> root (hd0,6)
    grub> setup (hd0)
    grub> quit

Consultare questa pagina per una sintesi più approfondita di questa sezione.

### /boot/grub/stage1 not read correctly

Se appare messaggio di errore durante il tentativo di setup del grub e non si utilizza una tabella delle partizioni aggiornata, vale la pena eseguire un controllo.

    # fdisk -l /dev/sda

Questo mostrerà la tabella delle partizioni per /dev/sda. Quindi controllare qui, anche se i valori "Id" delle partizioni dovessero essere corretti. La colonna "System" mostrerà la descrizione dei valori "Id".

Se la partizione di avvio è segnata come "HPFS/NTFS", per esempio, allora si deve cambiare con "Linux". Per fare questo, dare il comando fdisk

    # fdisk /dev/sda

cambiare l'Id del sistema di una partizione con [t], selezionare il numero e tipo di partizione nel nuovo id di sistema (Linux = 83). È anche possibile vedere tutti gli ID di sistema disponibili digitando "L" invece di system id.

Se si cambia l'Id di sistema di qualche partizione, bisognerebbe [v]erificare la tabella delle partizioni prima di confermare [w]rite.

Ora si può provare a installare grub di nuovo.

Qui c'è un post nel forum che riporta il problema.

### Installazione accidentale in una partizione Windows

Se accidentalmente si installa GRUB sulla partizione Windows, GRUB scriverà alcune informazioni al settore di avvio della partizione, cancellando il riferimento al bootloader di Windows. (Questo è vero per NTLDR, il bootloader di Windows XP e precedenti, non troppo sicuro per le versioni successive).

Per risolvere questo problema è necessario utilizzare la console di ripristino di Windows per la propria versione. Poiché molti produttori di computer non includono questa funzionalità nel loro prodotto (molti scelgono di utilizzare una partizione di ripristino), Microsoft ne ha reso disponibile il download. Se si utilizza XP, consultare questa pagina per essere in grado di avviare i dischi floppy come un CD di ripristino. Avviare il CD di ripristino (o attivare la modalità di ripristino di Windows) ed eseguire fixboot per riparare il settore di avvio della partizione. Per ultimo, sarà necessario installare nuovamente GRUB (questa volta nel MBR, e non nella partizione di Windows) per avviare Linux.

Consultare ulteriori discussioni qui[broken link: invalid section].

### Modificare le voci GRUB nel menu di avvio

Dopo aver selezionato una voce dal menu di avvio, è possibile modificarla premendo il tasto `e`. Usare la tab-completion (scheda di completamento) se si ha bisogno di rilevare altri dispositivi, quindi `Esc` per uscire. Allora si può provare ad avviare premendo `b`.

Nota: Queste impostazioni non verranno salvate.

### Errore device.map

Se viene generato un errore che riporta `/boot/grub/device.map` durante l'installazione o l'avvio, eseguire:

    # grub-install --recheck /dev/sda

per forzare GRUB a ricontrollare la mappa dei dispositivi, anche se esiste già. Questo può essere necessario dopo il ridimensionamento delle partizioni o l'aggiunta/rimozione di dischi.

### Errore sotto-menu di KDE al riavvio

Se dopo l'apertura di un sotto-menu con l'elenco di tutti i sistemi operativi configurati in GRUB, e la conseguente selezione, al riavvio è nuovamente attivo il sistema operativo predefinito, allora si dovrebbe controllare di avere la riga:

    default saved

in `/boot/grub/menu.lst`.

### GRUB non riesce a trovare o installare qualsiasi virtio /dev/vd* o altri dispositivi non-BIOS

Esempio di problemi all'installazione di GRUB, quando si installa Arch Linux in una macchina KVM virtuale utilizzando un dispositivo virtio per hard disk. Per installare GRUB, procedere come segue: Inserire una console virtuale digitando `Ctrl` + `Alt` + `F2` o qualsiasi altro tasto F per una console virtuale libera. Supponendo che il file system root sia montato nella cartella `/mnt` e il file di avvio del sistema sia montato o memorizzato nella cartella `/mnt/boot`.

1. Verificare che tutti i file di GRUB necessari siano presenti nella directory di avvio (supponendo siano montati nella cartella `/mnt/boot`) con il comando:

    # ls /mnt/boot/grub

2. Se la cartella `/mnt/boot/grub` contiene già tutti i file necessari, saltare al passo 3. In caso contrario, effettuare i seguenti comandi (sostituendo `/mnt`, il `kernel` e l'`initrd` con i percorsi reali e nomi dei file). Si dovrebbe anche avere il file `menu.lst` scritto nella cartella:

    # mkdir -p /mnt/boot/grub                # if the folder is not yet present
    # cp -r /boot/grub/stage1 /boot/grub/stage2 /mnt/boot/grub
    # cp -r your_kernel your_initrd /mnt/boot

3. Avviare la shell di GRUB con il seguente comando:

    # grub --device-map=/dev/null

4. Immettere i seguenti comandi, sostituendo `/dev/vda`, e `(hd0,0)` con il dispositivo corretto e la partizione corrispondente alla propria installazione.

    device (hd0) /dev/vda
    root (hd0,0)
    setup (hd0)
    quit

5. Se GRUB non riporta nessun messaggio di errore, probabilmente l'operazione è andata a buon fine. Potrebbe inoltre essere necessario aggiungere gli opportuni moduli a ramdisk. Per ulteriori informazioni, si prega di consultare la guida KVM su Preparing Arch Linux guest[broken link: invalid section]

## Risorse esterne

- GNU GRUB
- GRUB Grotto
- Guida agli errori di GRUB
- Boot Debug - Debug con GRUB.

Categories:

- Boot loaders (Italiano)
- System recovery (Italiano)

Hidden categories:

- Pages with broken package links
- Pages with broken section links