Linux LPI 102.2: Instalando o gerenciador de inicialização GRUB

Aqui está uma tabela com a definição dos termos que mencionaremos nesse post:

Termo	Definição
menu.lst, grub.cfg, grub.conf	Arquivos de configuração usados pelo GRUB (GRand Unified Bootloader). `menu.lst` e `grub.conf` são usados pelo GRUB Legacy, enquanto `grub.cfg` é usado pelo GRUB 2. Esses arquivos contêm as entradas de boot e as configurações do carregador de inicialização.
grub-install	Comando utilizado para instalar o GRUB no MBR (Master Boot Record) ou em uma partição específica de um disco. Ele configura o GRUB como o bootloader para o sistema.
grub-mkconfig	Comando usado no GRUB 2 para gerar automaticamente o arquivo de configuração `grub.cfg` com base nos sistemas operacionais detectados no sistema.
MBR (Master Boot Record)	O MBR é a primeira seção de um disco rígido, contendo o código necessário para inicializar o sistema operacional (bootloader) e a tabela de partições. Ele ocupa os primeiros 512 bytes do disco e é essencial para o processo de boot dos sistemas mais antigos.
GPT(GUID Partition Table)	é um esquema de particionamento de disco usado em sistemas Linux (e outros sistemas operacionais) que suporta discos maiores que 2 TB, permite até 128 partições, e oferece mais segurança e redundância em comparação ao antigo esquema MBR (Master Boot Record).
GRUB Legacy	Antiga versão do GRUB, utilizada para inicializar e gerenciar múltiplos sistemas operacionais. Configuração via arquivo `menu.lst`.
GRUB 2	Versão mais recente do GRUB com recursos aprimorados. Suporte a sistemas de arquivos modernos e configuração via `grub.cfg`.
LILO	Gerenciador de inicialização antigo que utiliza o arquivo `lilo.conf` para configuração. Menos utilizado atualmente devido ao suporte limitado para novos sistemas de arquivos.

Linux Boot

Quando ligamos o primeiro software a ser executado é o gerenciador de inicialização, no caso do Linux é o GRUB. Ele tem a função de iniciar o kernel. O kernel então carrega os drivers necessários, inicializa o hardware e, em seguida, carrega o restante do sistema operacional.

Ligamos o computador

Gerenciador de Inicialização (GRUB)

Kernel do Linux

Carrega Drivers e Inicializa Hardware

Carrega Sistema Operacional

Qual a relação entre GRUB, MBR e GPT?

MBR e GPT são esquemas de particionamento de disco que organizam como os dados são armazenados e gerenciados. O GRUB, como gerenciador de inicialização, depende desses esquemas para localizar e carregar o sistema operacional. Com MBR, o GRUB é instalado no primeiro setor do disco (o MBR), enquanto com GPT, ele pode ser instalado em uma partição especial chamada “EFI System Partition” (ESP) em sistemas UEFI ou pode ainda usar uma área de inicialização dedicada em sistemas BIOS.

GRUB Legacy e GRUB 2

O GRUB pode carregar o kernel do Linux ou outros sistemas operacionais, como o Windows, além de lidar com diversas imagens e parâmetros do kernel como entradas de menu separadas.

GRUB (Grand Unified Bootloader) foi desenvolvida em 1995 como parte do projeto GNU Hurd, substituindo outros, como o LILO. O GRUB Legacy não está mais em desenvolvimento ativo, a última versão foi a 0.97, em 2005. Mas é bom saber como usá-lo e em que ele difere do GRUB 2.

O GRUB 2 é uma versão melhorada, mais limpa e completa do GRUB; Possui mais comandos e instruções condicionais, como um script. Também tem menus gráficos de inicialização com telas de abertura, inicializar ISOs LiveCD diretamente a partir do disco rígido.

Setor de inicialização

Ordem correta dos eventos de inicialização:

O primeiro setor de 512 bytes do disco é chamado de Master Boot Record (MBR) e contém uma tabela de partições e um código de inicialização chamado gerenciador de inicialização.
Quando o computador é ligado, o código mínimo do gerenciador de inicialização, localizado no MBR, é carregado e executado.
Esse código transfere o controle para um carregador de inicialização secundário no disco, geralmente localizado em um espaço de 32 KB entre o MBR e a primeira partição.
O carregador de inicialização secundário carrega o(s) sistema(s) operacional(is).
Em um disco particionado em MBR, o código de inicialização do GRUB é instalado no MBR.
O GRUB, a partir do MBR, carrega e transfere o controle para uma imagem “núcleo” instalada entre o MBR e a primeira partição.
A partir desse ponto, o GRUB é capaz de carregar o restante dos recursos necessários, como definições de menu, arquivos de configuração e módulos extras, do disco.

Em sistemas onde o espaço no MBR (Master Boot Record) é limitado, o gerenciador de inicialização primário(geralmente GRUB) carrega apenas um código mínimo que transfere o controle para um carregador de inicialização secundário.

Essencialmente, o gerenciador de inicialização é o ponto de partida para o processo de boot, enquanto o carregador de inicialização secundário é uma etapa subsequente que assume o controle para continuar o processo de carregar e iniciar o sistema operacional.

Principais limitações do MBR (Master Boot Record):

Suporte a Partições Limitado: MBR suporta apenas até 4 partições primárias por disco. Para criar mais partições, é necessário converter uma das partições primárias em uma partição estendida que pode conter partições lógicas.
Capacidade Máxima de Disco: MBR só pode gerenciar discos com tamanho máximo de 2 TB. Discos maiores precisam ser particionados usando GPT (GUID Partition Table).
Código de Inicialização Pequeno: O código de inicialização no MBR é limitado a 446 bytes, restringindo as funcionalidades que podem ser implementadas diretamente no MBR.
Falha Única: Como o MBR ocupa apenas o primeiro setor do disco, uma corrupção nesse setor pode tornar o disco inteiro inoperável.
Compatibilidade: MBR é uma tecnologia antiga e pode não ser compatível com novos sistemas ou firmwares, como UEFI, que utiliza GPT em vez de MBR.

Particionamentos em GPT podem ser usados tanto com BIOS quanto com UEFI. Quando o GPT é usado com BIOS a segunda parte do GRUB é armazenada em uma partição especial de inicialização da BIOS. Quando com UEFI, o GRUB é carregado pelo firmware a partir dos arquivos grubia32.efi (para sistemas de 32 bits) ou grubx64.efi (para sistemas de 64 bits) em uma partição chamada de ESP (EFI System Partition).

Diferença na inicialização entre MBR e GPT

Diferenças entre MBR e GPT em relação ao processo de inicialização com GRUB:

Aspecto	MBR	GPT
Suporte de Firmware	BIOS (antigo)	UEFI (moderno) ou BIOS
Localização do Código de Inicialização	Master Boot Record (MBR), primeiros 512 bytes do disco	EFI System Partition (ESP) para UEFI ou área de inicialização dedicada para BIOS
Número de Partições	Até 4 partições primárias (ou 3 primárias + 1 estendida)	Suporta até 128 partições primárias
Capacidade Máxima de Disco	Até 2 TB	Suporta discos maiores que 2 TB
Armazenamento do GRUB	Instalado no MBR e em uma partição específica ou na área logo após o MBR	Armazenado na ESP (em sistemas UEFI) ou em uma partição de inicialização dedicada (em sistemas BIOS)
Redundância e Recuperação	Sem redundância embutida	Tabela de partições redundante e CRC para verificação de integridade
Suporte a Inicialização Segura	Não compatível	Compatível com Secure Boot (em UEFI)
Método de Carregamento do GRUB	BIOS carrega o código de inicialização diretamente do MBR	UEFI carrega o GRUB a partir da ESP; BIOS usa área de inicialização dedicada

MBR e GPT

/boot

Arquivos de inicialização geralmente são armazenados em uma partição de inicialização montada no sistema de arquivos raiz e chamada /boot.

Para garantir uma compatibilidade máxima, a partição /boot geralmente está localizada no início do disco e termina antes do cilindro 1024 (528 MB), garantindo que a máquina sempre possa carregar o kernel. O tamanho recomendado para essa partição em uma máquina atual é de 300 MB.

Veja o conteúdo do diretório /boon executando ls -l /boot

elder@debian12:~$ ls -l /boot/
total 76772
-rw-r--r-- 1 root root   259453 fev  1  2024 config-6.1.0-18-amd64
-rw-r--r-- 1 root root   259525 abr 11 18:17 config-6.1.0-20-amd64
drwxr-xr-x 5 root root     4096 mai  4 12:47 grub
-rw-r--r-- 1 root root 30827458 mai  4 12:49 initrd.img-6.1.0-18-amd64
-rw-r--r-- 1 root root 30919405 mai  4 12:50 initrd.img-6.1.0-20-amd64
-rw-r--r-- 1 root root       83 fev  1  2024 System.map-6.1.0-18-amd64
-rw-r--r-- 1 root root       83 abr 11 18:17 System.map-6.1.0-20-amd64
-rw-r--r-- 1 root root  8152768 fev  1  2024 vmlinuz-6.1.0-18-amd64
-rw-r--r-- 1 root root  8167616 abr 11 18:17 vmlinuz-6.1.0-20-amd64

Ter /boot montada em uma partição não é obrigatário, porém é uma recomendação, pois:

separa os arquivos necessários ao processo de inicialização do restante do sistema de arquivos.
se a partição raiz do sistema (/) for criptografada ou compactada GRUB 2 poderá não ser capaz de lê-la
Se a partição / estiver formatada com um sistema de arquivos que ele não reconheça

Temos o seguinte conteúdo dentro de /boot

Arquivo de Configuração: Esse arquivo, geralmente chamado de config-VERSÃO (como no exemplo acima config-6.1.0-18-amd64), guarda as configurações usadas pelo kernel do Linux. Ele é criado automaticamente quando um novo kernel é compilado ou instalado e não deve ser alterado manualmente pelo usuário.

Mapa do Sistema: O arquivo System.map-VERSÃO funciona como uma tabela que associa nomes de funções ou variáveis do sistema à sua localização na memória. Isso é útil para identificar o que estava sendo executado quando ocorreu um “kernel panic” (um erro grave no sistema). Esse arquivo é importante para ajudar a diagnosticar falhas.

Kernel do Linux: Esse é o coração do sistema operacional Linux. O arquivo do kernel geralmente é chamado de vmlinux-VERSÃO (como vmlinux-4.15.0-65-generic). Às vezes, o nome é vmlinuz em vez de vmlinux, onde o “z” indica que o arquivo está compactado.

Disco RAM Inicial: Chamado normalmente de initrd.img-VERSÃO, esse arquivo contém um sistema de arquivos básico, carregado na memória RAM, que inclui os utilitários e módulos necessários para que o kernel consiga montar o sistema de arquivos principal.

Arquivos Relacionados ao Gerenciador de Inicialização: Em sistemas que utilizam o GRUB como gerenciador de inicialização, esses arquivos estão geralmente localizados em /boot/grub. Eles incluem o arquivo de configuração (/boot/grub/grub.cfg para o GRUB 2 ou /boot/grub/menu.lst para o GRUB Legacy), módulos, arquivos de tradução e fontes do GRUB.

/boot/grub

O GRUB 2 pode ser instalado usando o utilitário grub-install.

Se seu sistema não inicia, poderá proceder da seguinte forma:

#1 você pode inicializá-lo usando um Live CD ou um disco de recuperação. Após executar o disco da Live CD descobra qual é a partição de inicialização do seu sistema, montá-la e executar o utilitário. Geralmente, o dispositivo de inicialização é o primeiro disco e o primeiro disco geralmente é /dev/sda. Se precisar confirmar pode usar o comando fdisk -l.

elder@debian12:~$ sudo fdisk -l 
[sudo] senha para elder: 
Disco /dev/sda: 40 GiB, 42949672960 bytes, 83886080 setores
Modelo de disco: VBOX HARDDISK   
Unidades: setor de 1 * 512 = 512 bytes
Tamanho de setor (lógico/físico): 512 bytes / 512 bytes
Tamanho E/S (mínimo/ótimo): 512 bytes / 512 bytes
Tipo de rótulo do disco: dos
Identificador do disco: 0x63820f01

Dispositivo Inicializar   Início      Fim  Setores Tamanho Id Tipo
/dev/sda1   *               2048 81885183 81883136     39G 83 Linux
/dev/sda2               81887230 83884031  1996802    975M  5 Estendida
/dev/sda3               83884032 83886079     2048      1M 83 Linux
/dev/sda5               81887232 83884031  1996800    975M 82 Linux swap / Solaris

Partições lógicas fora da ordem do disco.


Disco /dev/sdb: 2 GiB, 2147483648 bytes, 4194304 setores
Modelo de disco: VBOX HARDDISK   
Unidades: setor de 1 * 512 = 512 bytes
Tamanho de setor (lógico/físico): 512 bytes / 512 bytes
Tamanho E/S (mínimo/ótimo): 512 bytes / 512 bytes
Tipo de rótulo do disco: dos
Identificador do disco: 0xfb3ed95f

Dispositivo Inicializar  Início     Fim Setores Tamanho Id Tipo
/dev/sdb1                  2048 2099199 2097152      1G 83 Linux
/dev/sdb2               2099200 4194303 2095104   1023M 83 Linux

A partição de inicialização é identificada com o * na coluna boot. no caso acima é o /dev/sda1

#2 vamos montar esse disco. Crie diretório /mnt/tmp

elder@debian12:~$ sudo mkdir /mnt/tmp

#3 monte o /dev/sda1 nessa pasta

elder@debian12:~$ sudo mount /dev/sda1  /mnt/tmp

#4 execute grub-install. Aponte para o diretório e para o dispositivo sda (não sda1 e sim sda apenas)

elder@debian12:~$ sudo grub-install --boot-directory=/mnt/tmm    /dev/sda

Caso esteja em um sistema que tenha apenas /boot faça assim:

elder@debian12:~$ sudo grub-install --boot-directory=/boot    /dev/sda

Configurando GRUB 2

Vejamos o conteúdo da pasta /boot/grub

elder@debian12:~$ ls -l /boot/grub/
total 2372
drwxr-xr-x 2 root root    4096 mai  4 12:47 fonts
-rw------- 1 root root    7563 mai  4 12:47 grub.cfg
-rw-r--r-- 1 root root    1024 mai  4 12:47 grubenv
drwxr-xr-x 2 root root   12288 mai  4 12:47 i386-pc
drwxr-xr-x 2 root root    4096 mai  4 12:47 locale
-rw-r--r-- 1 root root 2392304 mai  4 12:47 unicode.pf2

/boot/grub/grub.cfg é o arquivo padrão de configuração do GRUB 2. Esse arquivo é gerado automaticamente e não é recomendado editá-lo à mão. Para alterar o GRUB 2 edite /etc/default/grub e execute update-grub para gerar um arquivo compatível.

update-grub é um atalho para grub-mkconfig -o /boot/grub/grub.cfg.

Existem algumas opções no arquivo /etc/default/grub mas, antes de falarmos sobre essas opções, saiba o significado do tempo “entrada de menu” se refere à opção do menu de boot que será selecionada. O “menu de boot” no GRUB é a tela que aparece durante a inicialização do sistema e lista todas as opções disponíveis para iniciar o sistema operacional.

Configuração do GRUB em /etc/default/grub:

GRUB_DEFAULT=
- Define qual entrada de menu, ou qual opção, será selecionada por padrão quando o sistema for inicializado.
- Pode ser configurada com um número (0 para a primeira entrada, 1 para a segunda, e assim por diante), com o nome da entrada (como "Ubuntu" ou “Debian”), ou com a palavra-chave "saved" para escolher a última entrada selecionada.
- Exemplo: GRUB_DEFAULT=0 define a primeira entrada como a padrão.
GRUB_SAVEDEFAULT=:
- Quando definido como true e GRUB_DEFAULT= como saved, o GRUB salva a última entrada de menu selecionada e a utiliza como padrão na próxima inicialização.
- Isso é útil para sistemas onde o usuário frequentemente escolhe diferentes sistemas operacionais ou modos de inicialização.
- Exemplo: GRUB_SAVEDEFAULT=true faz com que a última seleção de boot seja lembrada para o próximo boot.
GRUB_TIMEOUT=
- Especifica o tempo (em segundos) que o GRUB espera antes de iniciar a entrada de menu padrão automaticamente.
- Se o valor for 0, o GRUB inicializa imediatamente a entrada padrão sem mostrar o menu.
- Se for -1, o menu de boot é mostrado indefinidamente até que o usuário faça uma escolha.
- Exemplo: GRUB_TIMEOUT=5 faz o GRUB esperar 5 segundos antes de inicializar automaticamente a entrada padrão.
GRUB_CMDLINE_LINUX=
- Permite adicionar parâmetros personalizados à linha de comando do kernel.
- Esses parâmetros são aplicados a todas as entradas de inicialização do Linux e podem ser usados para ajustar o comportamento do kernel durante a inicialização.
- Exemplo: GRUB_CMDLINE_LINUX="quiet splash" adiciona as opções quiet (suprime mensagens de inicialização) e splash (exibe uma tela gráfica durante a inicialização).
GRUB_CMDLINE_LINUX_DEFAULT=
- Semelhante ao GRUB_CMDLINE_LINUX, mas essas opções são aplicadas somente à entrada de inicialização padrão do Linux.
- É comum usar esta variável para configurar parâmetros de inicialização padrão que são adequados para a maioria das inicializações normais, enquanto GRUB_CMDLINE_LINUX é usado para parâmetros que devem ser aplicados em todos os casos.
- Exemplo: GRUB_CMDLINE_LINUX_DEFAULT="quiet splash" adiciona as opções quiet e splash apenas para a entrada padrão.
GRUB_ENABLE_CRYPTODISK=
- Quando definido como y, habilita o suporte do GRUB a discos criptografados.
- Isso é necessário se você estiver usando criptografia de disco completo e deseja que o GRUB seja capaz de acessar e inicializar a partir de uma partição criptografada.
- Exemplo: GRUB_ENABLE_CRYPTODISK=y permite que o GRUB inicialize a partir de discos criptografados.

Esses parâmetros estão em /etc/default/grub. Após alterar esse arquivo execute update-grub para aplicar as alterações.

entradas de menu

Acima expliquei que o termo entrada de menu refere-se às opções do GRUB que são exibidas quando o sistema é iniciado, naquela telinha preta.

Ao executar o comando update-grub o GRUB busca por kernels novos dentro da pasta correspondente e gera as entradas de menu correspondentes no arquivo /boot/grub/grub.cfg. Se não deseja rodar update-grub, poderá adicionar manualmente entradas dentro da pasta /etc/grub.d

Os arquivos dentro de /etc/grub.d devem ser executáveis e são processados em ordem numérica pelo update-grub. Exemplo, 05_debian_theme é processado antes de 10_linux e assim por diante.

Geralmente é usado o arquivo 40_custom para adicionar entradas personalizadas ao menu.

Um exemplo de entrada é:

menuentry "Default OS" {
set root=(hd0,1)
linux /vmlinuz root=/dev/sda1 ro quiet splash
initrd /initrd.img
}

Aqui está a explicação de cada linha dessa entrada de menu no GRUB:

menuentry "Default OS" {:
- Esta linha define uma nova entrada de menu no GRUB com o nome “Default OS”.
- O nome entre aspas é o que será exibido no menu de boot, permitindo ao usuário identificar e selecionar esta opção.
set root=(hd0,1):
- Esta linha define a partição raiz (root) do sistema de arquivos para esta entrada de boot.
- (hd0,1) refere-se à primeira partição do primeiro disco (hd0 é o primeiro disco, e 1 indica a primeira partição). No GRUB, a numeração das partições começa em 1.
- Essa configuração diz ao GRUB onde encontrar os arquivos do kernel e initrd.
linux /vmlinuz root=/dev/sda1 ro quiet splash:
- Esta linha carrega o kernel do Linux (/vmlinuz) e passa parâmetros de inicialização ao kernel.
- root=/dev/sda1 especifica que a partição raiz do sistema Linux está localizada em /dev/sda1 (primeira partição do primeiro disco em sistemas Linux).
- ro significa que a partição raiz deve ser montada como somente leitura durante a inicialização.
- quiet suprime a exibição de mensagens detalhadas de inicialização.
- splash exibe uma tela gráfica (como uma tela de boot com logotipo) durante a inicialização.
initrd /initrd.img:
- Esta linha carrega a imagem de disco RAM inicial (initrd.img), que contém um sistema de arquivos mínimo usado durante o processo de inicialização.
- O initrd é necessário para fornecer os módulos do kernel e outros arquivos essenciais antes que o sistema de arquivos raiz seja montado.

Também podemos usar search –set=root seguido por –label e o rótulo do sistema de arquivos a buscar para pedir que o GRUB 2 busque por um sistema de arquivos com um rótulo ou UUID (Universally Unique Identifier). Podemos usar também –fs-uuid seguido pelo UUID do sistema de arquivos.

Para ver os UUIDS, execute ls -l /dev/disk/by-uuid/

elder@debian12:~$  ls -l /dev/disk/by-uuid/
total 0
lrwxrwxrwx 1 root root 10 ago  1 10:29 74e7a84b-4d88-436f-8c5d-6753910736c7 -> ../../sda3
lrwxrwxrwx 1 root root 10 ago  1 10:29 8a4c9719-5434-4a9f-bb85-1b7ac9168186 -> ../../sda1
lrwxrwxrwx 1 root root 10 ago  1 10:29 baf56afa-3c25-474f-ad4c-9651184e5971 -> ../../sda5

Por exemplo, o UUID de /dev/sda3 é 74e7a84b-4d88-436f-8c5d-6753910736c7. Então, podemos usar

--set=root --fs-uuid 74e7a84b-4d88-436f-8c5d-6753910736c7

Podemos usar –no-floppy para que o GRUB não perca tempo buscando por disquetes.

Mexendo no GRUB 2

Ao ligarmos o computador com Linux, a tela com menu de opções para interagirmos com o grub 2 aparecerá. apenas uma contagem regressiva, mas não um menu, pressione Shift durante a inicialização para aparecer o menu.

Use Setas e Enter para acessar uma das opções.

Para editar tecle e ao invés de Enter. Será exibida uma janela de editor com o conteúdo do menuentry associado à opção. digite Ctrl + X ou F10 para inicializar, ou ainda Esc para retornar.

Tecle c para acessar o shell(interpretador de comandos) do GRUB. Ou ctrl + c. Irá aparecer o prompt de comandos do GRUB:

 grub >

Digite help para ver uma lista de todos os comandos disponíveis ou pressione Esc para sair do shell e retornar à tela do menu.

se GRUB_TIMEOUT estiver com valor 0 em /etc/default/grub este menu não aparecerá.

Usando o shell do GRUB 2 para iniciar o sistema

Caso uma entrada de menu cause uma falha de inicialização, podemos usar o shell do GRUB 2 para inicializar.

#1 descobra onde está a partição de inicialização. Execute ls. Abaixo podemos ver quer há apenas um disco (hd0), com apenas uma partição

grub> ls
(proc) (hd0) (hd0,msdos1)

Os valores poderão ser diferentes em seu Linux. msdos1 aparece porque o disco hd0 tem particionamento MBR. Receberia gpt1 se fosse GPT.

#2 Verifique em (hd0,msdos1) se há um kernel e uma RAM inicial


grub> ls (hd0,msdos1)/
lost+found/ swapfile etc/ media/ bin/ boot/ dev/ home/ lib/ lib64/ mnt/ opt/ proc/ root/
run/ sbin/ srv/ sys/ tmp/ usr/ var/ initrd.img initrd.img.old vmlinuz cdrom/

Vemos que temos o kernel (vmlinuz) e initrd (initrd.img).

Se não encontrar em seu Linux, procure dentro de /boot

 list (hd0,msdos1)/boot/

#3 defina a partição de inicialização

grub> set root=(hd0,msdos1)

#4 Carregue o kernel do Linux

grub> linux /vmlinuz root=/dev/sda1

#5 Carregue o disco RAM inicial com initrd

grub> initrd /initrd.img

Usando o shell de recuperação/resgate

um shell de resgate é uma verão simplificada do shell do GRUB 2. Ele é identificado por grub rescue>

grub rescue>

No entanto, será preciso carregar alguns módulos do GRUB 2 para fazer as coisas funcionarem.

Use set prefix= apontando para o diretório /boot/grub

grub rescue> set prefix=(hd0,msdos1)/boot/grub

carregue os módulos normal e linux com o comando insmod:

grub rescue> insmod normal
grub rescue> insmod linux

defina a partição de inicialização com set root=, carregue o kernel do linux (com linux), o disco RAM inicial (initrd) e tente inicializar com boot.

grub> set root=(hd0,msdos1)

grub> linux /vmlinuz root=/dev/sda1

grub> initrd /initrd.img

GRUB Legacy

Instalando o GRUB Legacy a partir de um sistema em execução

Para instalar o GRUB Legacy O comando básico é grub-install DEVICE

Note que é preciso especificar /dev/sda/, não a partição como em /dev/sda1.

# grub-install /dev/sda

o GRUB copia os arquivos necessários para o diretório /boot no dispositivo que indicamos. Mas podemos usar –boot-directory= para especificar outro diretório.

Instalando o GRUB Legacy a partir de um shell do GRUB

Se você não conseguir inicializar o sistema por algum motivo e precisar reinstalar o GRUB Legacy, poderá fazê-lo no shell do GRUB em um disco de inicialização do GRUB Legacy.

No shell do GRUB, digite:

grub> root (hd0,0)

Para encontrar o diretório /boot faça:

find /boot/grub/stage1

Agora, use o comando setup para instalar o GRUB Legacy no MBR e copiar os arquivos necessários no disco:

grub> setup (hd0)

reinicie o sistema e ele deverá inicializar normalmente.

Parâmetros do GRUB Legacy

Você ainda poderá se deparar com essa versão antiquada do GRUB. Por isso, é importante darmos uma estudada nela.

Os parâmetros do GRUB Legacy ficam em /boot/grub/menu.lst; esse arquivo pode ser editado diretamente em seu editor de texto predileto. As linhas iniciadas com # são consideradas comentários.

Veja exemplo de uma entrada de menu:

# This line is a comment
title My Linux Distribution
root (hd0,0)
kernel /vmlinuz root=/dev/hda1

Aqui vai uma coisa muito importante, ao contrário do GRUB 2, no GRUB Legacy tanto as partições quanto os discos são numerados a partir de zero. Portanto, o comando root (hd0,0) define a partição de inicialização como a primeira partição (0) do primeiro disco (hd0).

“root” pode ser omitido se especificarmos o dispositivo de inicialização antes do caminho no comando kernel.

kernel (hd0,0)/vmlinuz root=dev/hda1

A linha acima é a mesma coisa que

root (hd0,0)
kernel /vmlinuz root=/dev/hda1

Os dois comandos carregam vmlinuz a partir do diretório root (/) da primeira partição do primeiro disco (hd0,0).

root=/dev/hda1 é um parâmetro do kernel do Linux, não um comando do GRUB Legacy.

root=/dev/hda1 é usado ao invés de root=/dev/sda1 porque o sistema, nesse exemplo, está configurado para inicializar a partir de um disco antigo IDE/PATA e não em um sata.

O GRUB Legacy tem arquivos arquivos .mod guardados em /boot/grub/i386-pc que são módulos, ou seja, GRUB Legacy tem formato/design modular, con isso, podem ser carregados para adicionar recursos extras como suporte a hardware incomum, sistemas de arquivos ou novos algoritmos de compactação.

Para carregar esses módulos é usado o comando module caminho/modulo.mod. Esse caminho é relativo ao dispositivo especificado no comando root. Exemplo,

module /boot/grub/i386-pc/915resolution.mod

Carregando outros sistemas operacionais com GRUB Legacy

Podemos usar carregamento em cadeia (chainloading) para carregar outros SOs não suportados, como o Windows.

Exemplo de carregamento em cadeia do Windows:

# Load Windows
title Windows XP
root (hd0,1)
makeactive
chainload +1
boot

(hd0,1) é a segunda partição do primeiro disco.

Vamos à explicação resumida de cada linha:

# Load Windows:
- Comentário que descreve o propósito da configuração (não é executado).
title Windows XP:
- Define o título da entrada de menu, que será exibido no menu do GRUB.
root (hd0,1):
- Especifica a partição onde o Windows XP está instalado. (hd0,1) indica a segunda partição do primeiro disco.
makeactive:
- Marca a partição como ativa, necessária para inicializar alguns sistemas operacionais, incluindo versões do Windows.
chainload +1:
- Transfere o controle de inicialização para o primeiro setor da partição (normalmente onde está o carregador de inicialização do Windows).
boot:
- Inicia o processo de boot na partição especificada.