102.2:Instale um gerenciador de boot

Apresentando GRUB, o GRUB 2.

Saiba como escolher e configurar um gerenciador de boot para seu sistema Linux®. Você pode usar o material neste tutorial para estudar para o exame LPI 101 para certificação de administrador de sistema Linux, ou para aprender para se divertir.

Visão geral

Neste tutorial, aprenda a escolher, instalar e configurar um gerenciador de inicialização para um sistema Linux. Aprenda a:

  • Fornecer locais de arranque alternativas e opções de inicialização de backup
  • Instalar e configurar um gerenciador de inicialização como o GRUB Legacy
  • Realizar mudanças de configuração básica para o GRUB 2
  • Interagir com o gerenciador de inicialização
Gestores de arranque

Um carregador de inicialização ou gerenciador de inicialização é a peça intermediária de código que ajuda o hardware e firmware de seu sistema de carregar um sistema operacional para você. Este tutorial discute o processo de inicialização do PC e os três principais gerenciadores de inicialização que são usados ​​em Linux: o GRUB, o GRUB 2, e LILO com discos MBR formatado. O GRUB original, agora chamado GRUB-Legacy, não está mais em desenvolvimento ativo e tem sido amplamente substituído pelo GRUB 2. Mesmo distribuições comerciais, como Red Hat Enterprise Linux e SUSE Linux Enterprise Server mudou para GRUB 2 em 2014. Desenvolvimento de Lilo está programado para cessar no final de 2015.

Este tutorial ajuda você a preparar para o Objetivo 102.2 no Tópico 102 do Linux Professional Server exame (LPIC-1) 101. O objetivo tem um peso de 2. LILO não é mais necessário para LPIC-1. Ele é incluído aqui para que você saiba algo sobre isso.

Pré-requisitos

Para obter o máximo a partir dos tutoriais nesta série, você deve ter um conhecimento básico de Linux e um sistema Linux funcional em que seja possível praticar os comandos abordados. Você também deve estar familiarizado com layout de disco rígido conforme discutido no tutorial “Aprenda Linux 101:. Layout do disco rígido” Às vezes, versões diferentes de determinado programa formatem a saída de modo diferente, para que seus resultados nem sempre exatamente iguais às listas e figuras exibidas aqui.

Note: As imagens neste tutorial são capturas de tela tomadas desde o início do processo de inicialização. Se você está lendo este tutorial usando um leitor de tela, você pode achar que é vantajoso ter os arquivos de configuração correspondentes disponíveis para referência; baixá-los a partir da seção Download, mais adiante neste tutorial.

Visão geral do processo de inicialização

Antes de eu entrar em carregadores de inicialização específicos, vamos rever como um PC tradicional começa ou botas. Código chamado de BIOS (Basic Input Serviço para Output) é armazenado na memória não-volátil, como uma ROM, EEPROM, ou memória flash. Quando o PC é ligado ou reiniciado, esse código é executado. Normalmente, ele executa um auto-teste power-on (POST) para verificar a máquina. Finalmente, ele carrega o primeiro setor a partir do registro mestre de inicialização (MBR) na unidade de inicialização.

Conforme discutido no tutorial “Aprenda Linux 101: Layout do disco rígido“, o MBR também contém a tabela de partição, por isso a quantidade de código executável no MBR é menor que 512 bytes, que não é muito código. Cada disco, até um disquete, contém código executável em seu MBR, mesmo que o código é apenas o suficiente para colocar para fora uma mensagem como “disco não-inicializável na unidade A:”. Este código que é carregado pelo BIOS a partir deste primeiro setor é chamado o primeiro carregador de inicialização estágio ou o estágio 1 carregador de boot.

O MBR disco rígido padrão utilizado pelo MS DOS, PC DOS e Windows sistemas operacionais verifica a tabela de partição para encontrar uma partição primária na unidade de inicialização que está marcado como ativo, carrega o primeiro setor a partir dessa partição, e passa o controle para o início do código carregado. Este novo pedaço de código também é conhecido como o registro de inicialização de partição. O registro de inicialização de partição é, na verdade, mais uma etapa 1 carregador de inicialização, mas esta tem inteligência suficiente para carregar um conjunto de blocos a partir da partição. O código neste novo conjunto de blocos é chamado o estágio 2 do carregador de inicialização. Como usado pelo MS-DOS e PC-DOS, o carregador de fase 2 procede diretamente para carregar o resto do sistema operacional. Esta é a forma como o seu sistema operacional puxa-se para cima por suas bootstraps até que ele esteja pronto e funcionando.

Isso funciona bem para um sistema com um único sistema operacional. O que acontece se você quiser vários sistemas operacionais, dizer / 2, Windows XP e três distribuições Linux diferentes sistemas operacionais? Você pode usar algum programa (como o programa DOS FDISK) para alterar a partição ativa e reinicie. Isto é complicado. Além disso, um disco pode ter apenas quatro partições primárias, eo padrão MBR pode ter apenas uma partição primária ativa; ele não pode iniciar a partir de uma partição lógica. Mas o nosso exemplo hipotético citou cinco sistemas operacionais, cada uma das quais precisa de uma partição. Ops!

A solução reside na utilização de um código especial que permite ao usuário escolher qual sistema operacional para arrancar. Os exemplos incluem:

Loadlin
Um programa executável DOS que é chamado a partir de um sistema DOS correndo para inicializar uma partição Linux. Este era popular quando a criação de um sistema de inicialização múltipla foi um processo complexo e arriscado.
OS/2 Boot Manager
Um programa que é instalado em uma pequena partição dedicada. A partição é marcada como ativa, eo processo de boot padrão MBR inicia o Gerenciador de OS / 2 Boot, que apresenta um menu onde você pode escolher qual sistema operacional para inicializar.
Um carregador de inicialização inteligente
Um programa que pode residir em uma partição do sistema operacional e é invocado quer pelo registro de inicialização de partição de uma partição ativa ou pelo registro mestre de inicialização. Os exemplos incluem:

  • BootMagic, parte de Norton PartitionMagic
  • LILO, o LInux LOader
  • GRUB, o Grand Unified Boot Loader (agora referido como GRUB Legacy)
  • GRUB 2, um carregador de inicialização mais recente que agora é usado em muitas distribuições comuns
  • Syslinux, um grupo de carregadores leves de boot para sistemas de arquivos MS-DOS FAT (SYSLINUX), inicialização via rede (PXELINUX), arranque “El Torito” CD-ROMs (Isolinux), e Linux ext2 / ext3 / ext4 ou btrfs sistemas de arquivos (EXTLINUX)

Evidentemente, se você pode passar o controle do sistema de algum programa que tenha mais de 512 bytes de código para realizar sua tarefa, então não é muito difícil para permitir a inicialização a partir de partições lógicas, ou arrancar a partir de partições que não estão na inicialização conduzir. Todas essas soluções permitem que essas possibilidades, seja porque eles podem carregar um registro de inicialização de uma partição arbitrária, ou porque eles têm alguma compreensão do que arquivo ou arquivos para carregar para iniciar o processo de inicialização.

Corrente de carga

Quando um gerenciador de inicialização obtém controle, uma coisa que ele pode carregar é outro gerenciador de boot. Isso é chamado de carregamento em cadeia, e mais frequentemente ocorre quando o gerenciador de inicialização que está localizado no registro mestre de inicialização (MBR) carrega o carregador de inicialização que está em um registro de inicialização de partição. Isso é quase sempre feito quando um carregador de boot do Linux é convidado a iniciar uma partição de Windows ou DOS, mas também pode ser feito quando o carregador de boot do Linux para um sistema Linux (dizer Fedora) é configurado para carregar o gerenciador de inicialização para outro sistema Linux (dizer Ubuntu). Por exemplo, você pode usar o GRUB em uma partição para iniciar o GRUB no registo de arranque de outra partição para iniciar o sistema Linux nessa partição. Este não é comum, mas que ilustra as possibilidades.

 Carregadores de inicialização do Linux

Este tutorial se concentra em GRUB, o GRUB 2, e LILO, porque estes são o boot carregadeiras incluído na maioria das distribuições Linux. LILO tem sido em torno de algum tempo. GRUB é mais recente. O original do GRUB, tornou-se agora o GRUB Legacy e GRUB 2 está sendo desenvolvido sob os auspícios da Fundação do Software Livre (consulte Recursos para obter detalhes). Este tutorial discute o GRUB em primeiro lugar, e, em seguida, o GRUB 2, de modo que você tem alguma idéia das principais diferenças e como GRUB e GRUB 2 podem coexistir. Para o restante deste tutorial, assumimos GRUB significa GRUB Legacy, a menos que o contexto implica especificamente GRUB 2. Uma nova versão do LILO chamado ELILO (que é projetado para sistemas que usam da Intel Extensible Firmware Interface, ou EFI boot, ao invés de BIOS) é também disponível. Consulte Recursos para obter informações adicionais sobre ELILO.

Como observado anteriormente, GRUB Legacy não está mais em desenvolvimento ativo e desenvolvimento LILO está programado para terminar no final de 2015. A maioria dos sistemas Linux em 2015 estão enviando com GRUB 2 como padrão, ou por vezes, apenas carregador de boot.

O processo de instalação para a sua distribuição pode dar-lhe uma escolha de qual carregador de inicialização para configurar. GRUB, o GRUB 2, e LILO todos os trabalhos com a maioria dos discos modernos, apesar de algumas distribuições, nomeadamente Fedora, não mais enviar o LILO ou GRUB Legacy. Lembre-se que a tecnologia de disco tem avançado rapidamente, assim que você deve sempre se certificar de que o seu carregador de inicialização escolhido, bem como a sua distribuição Linux escolhido (ou outro sistema operacional), bem como o BIOS do sistema, irá trabalhar com o seu novo disco brilhante. Não fazer isso pode resultar em perda de dados. Da mesma forma, se você está adicionando uma nova distribuição para um sistema existente, você pode precisar para se certificar de que você tem a última LILO, GRUB, ou GRUB 2 no seu MBR. Você também precisa de uma versão relativamente recente de seu gerenciador de inicialização se você pretende iniciar a partir de um disco LVM e RAID.

Com o estágio 2 carregadoras usados ​​em LILO e o GRUB, você pode escolher entre vários sistemas operacionais ou versões para carregar. No entanto, o LILO e o GRUB diferem significativamente em que uma mudança para o sistema exige que você use um comando para recriar a configuração de inicialização do LILO sempre que você atualizar um kernel ou fazer algumas outras mudanças no seu sistema, enquanto o GRUB pode fazer isso através de um arquivo de texto de configuração que você pode editar. GRUB 2 também requer uma reconstrução a partir de um arquivo de configuração que é normalmente armazenado em / etc.

GRUB

GRUB, ou o Grand Unified Boot Loader, foi durante muito tempo um dos carregadores de inicialização mais comuns do Linux. Você pode instalar o GRUB no MBR de seu disco de boot ou no registro de inicialização de partição de uma partição. Você também pode instalá-lo em dispositivos removíveis, como disquetes, CDs ou chaves USB. É uma boa ideia para a prática em uma chave USB de disquete ou disco se você não estiver familiarizado com o GRUB. Os exemplos neste tutorial mostrar-lhe como.

Nota: A maioria dos exemplos do GRUB neste tutorial usa CentOS 6.

Durante a instalação do Linux, muitas vezes você especificar sua escolha de gerenciador de inicialização. Se você escolher o LILO, então você não pode ter o GRUB instalado. Se você não tem o GRUB instalado e está disponível para a sua distribuição, então você precisa instalar o pacote para ele. Este tutorial assume que você já tem o pacote GRUB instalado. Veja o roteiro da série para os tutoriais sobre gerenciamento de pacotes, se você precisar de ajuda com isso.

GRUB (Legado) tem um arquivo de configuração que normalmente é armazenado em /boot/grub/grub.conf. Se o seu sistema de arquivos suporta links simbólicos, como a maioria dos sistemas de arquivos Linux faz, você provavelmente já /boot/grub/menu.lst como um link simbólico para /boot/grub/grub.conf.

O comando grub (/ sbin / grub, ou, em alguns sistemas, / usr / sbin / grub) é uma concha pequena, mas razoavelmente poderoso que aceita vários comandos para instalar o GRUB, sistemas de inicialização, localizar e visualizar arquivos de configuração e tarefas semelhantes. Este partes do escudo muito código com a segunda fase GRUB boot loader, por isso é útil para aprender sobre o GRUB, sem ter que arrancar para um ambiente segunda etapa GRUB. O estágio GRUB 2 é executado em modo de menu, de modo que você pode escolher um sistema operacional a partir de um menu, ou no modo de comando, onde você especificar comandos individuais para carregar um sistema. Há também vários outros comandos, como o grub-install que usam o shell grub e ajudam a automatizar tarefas como instalação de GRUB.

A Listagem 1 mostra um arquivo de configuração do GRUB bastante complexo. Como você olhar através dele, lembro de uma coisa importante: o GRUB, pelo menos GRUB Legacy, conta discos, partições e as coisas que precisam ser contadas, começando em 0 em vez de 1. A segunda entrada para o CentOS tem uma linha kernel que é muito grandes. A Listagem 1 mostra-o com uma barra invertida (\) que indica onde ele foi quebrado para publicação.

Listagem 1. /boot/grub/menu.lst exemplo de configuração do GRUB
# grub.conf generated by anaconda
#
# You do not have to rerun grub after making changes to this file
# NOTICE:  You do not have a /boot partition.  This means that
#          all kernel and initrd paths are relative to /, eg.
#          root (hd0,5)
#          kernel /boot/vmlinuz-version ro root=/dev/hda6
#          initrd /boot/initrd-version.img
#boot=/dev/hda
default=0
timeout=60
splashimage=(hd0,0)/boot/grub/splash.xpm.gz
#password --md5 $1$y.uQRs1W$Sqs30hDB3GtE957PoiDWO.

title Fedora 22 64-bit (sda5)
	root (hd0,4)
        kernel /boot/grub2/i386-pc/core.img

title Fedora 18 64-bit (sda7)
	root (hd0,6)
        kernel /boot/grub2/i386-pc/core.img

title CentOS 6 64-bit (sda11)
        root (hd0,10)
        configfile /boot/grub/menu.lst

title CentOS (2.6.32-504.23.4.el6.x86_64)
	root (hd0,10)
	kernel /boot/vmlinuz-2.6.32-504.23.4.el6.x86_64 ro \
           root=UUID=2f60a3b4-ef6c-4d4c-9ef4-50d7f75124a2 rd_NO_LUKS rd_NO_LVM \
           LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun16 crashkernel=128M \
           KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet
	initrd /boot/initramfs-2.6.32-504.23.4.el6.x86_64.img

title Fedora 20 64-bit (sda10)
	root (hd0,9)
        configfile /boot/grub/menu.lst

title Ubuntu 12.04-LTS 64-bit (sda9)
	root (hd0,8)
        kernel /boot/grub/core.img

title Ubuntu 14.04 32-bit (sda12)
	root (hd0,11)
        kernel /boot/grub/core.img

title Slackware 13.37 64-bit (sda6)
	root (hd0,5)
        chainloader +1
        boot
	
title Open SUSE 11.4 64-bit (sda8)
	root (hd0,7)
        configfile /boot/grub/menu.lst

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

O primeiro conjunto de opções na Listagem 1 de controle como o GRUB funciona. Para GRUB, estes são chamados de comandos de menu, e eles devem aparecer antes de outros comandos. As restantes secções dar opções por imagem para os sistemas operacionais que você deseja permitir o GRUB para inicializar. “Título” é considerado um comando de menu. Cada instância do título é seguida por um ou mais comandos gerais ou do menu de entrada.

Os comandos de menu que se aplicam a todas as outras seções na Listagem 1 são:

#
Qualquer linha que começa com uma
default
Especifica que o sistema para carregar se o usuário não faz uma escolha dentro de um tempo limite. Na Listagem 1, padrão = 0 significa para carregar a primeira entrada. Lembre-se que a contagem do GRUB a partir de 0 ao invés de 1. Se não for especificado, o padrão é para arrancar a primeira entrada, entrada de número 0.
timeout
Especifica um tempo limite em segundos antes de inicializar a entrada padrão. Note-se que o LILO usa décimos de segundo para o tempo limite, enquanto o GRUB utiliza segundos inteiros.
splashimage
Especifica o fundo, ou respingo, imagem a ser exibida com o menu de inicialização. GRUB Legacy refere-se ao primeiro disco rígido como (hd0) ea primeira partição neste disco como (hd0,0), de modo a especificação de splashimage = (hd0,0) /boot/grub/splash.xpm.gz significa usar /boot/grub/splash.xpm.gz o arquivo localizado na partição 1 do primeiro disco rígido. Lembre-se de contar a partir de 0. A imagem é um arquivo XPM compactado com gzip. Suporte para splashimage é um patch que pode ou não ser incluído na sua distribuição.
password
Especifica uma senha que você deve digitar antes que você possa desbloquear o menu e quer editar uma linha de configuração ou entrar comandos do GRUB. A senha pode ser em texto claro. GRUB também permite que as senhas sejam armazenadas como um MD5, como no exemplo comentado na Listagem 1. Isso é um pouco mais seguro, ea maioria dos administradores de definir uma senha. Sem uma senha, você tem acesso completo à linha de comando do GRUB.

A Listagem 1 mostra um kernel CentOS, /boot/vmlinuz-2.6.32-504.23.4.el6.x86_64, em / dev / sda11 (hd0,10), além de vários sistemas que estão configurados para carga cadeia. Listagem 1 também tem exemplos de carregamento GRUB 2 via /boot/grub2/i386-pc/core.img e um exemplo de uma entrada de corrente de carregamento típico Windows XP, embora este sistema realmente não têm o Windows instalado. Os comandos usados ​​nestas seções são:

title
É um título descritivo que é apresentado como o item de menu quando o GRUB. Você usa as teclas de setas para mover para cima e para baixo através da lista de títulos e, em seguida, pressione Enter para selecionar uma entrada específica.
root
Especifica a partição que será inicializada. Tal como acontece com splashimage, lembre-se que a contagem começa em 0, de modo que o primeiro sistema Red Hat que é especificado como root (hd0,6) é, na verdade, na partição 7 da primeira unidade de disco rígido (/ dev / hda7 neste caso), enquanto o primeiro sistema Ubuntu, que é especificado como root (hd1,10), está no segundo disco rígido (/ dev / hdb11). GRUB tenta montar esta partição para verificá-lo e fornecer valores para o sistema operacional inicializado em alguns casos.
kernel
Especifica a imagem do kernel a ser carregado e todos os parâmetros do kernel necessários. Um valor do kernel como /boot/grub2/i386-pc/core.img geralmente significa carregar um carregador de boot GRUB 2 a partir da partição raiz nomeado.
initrd
É o nome do disco RAM inicial, que contém módulos necessários ao kernel antes de seus sistemas de arquivos são montados.
savedefault
Não é utilizado neste exemplo. Se o comando de menu default=saved é especificado e o comando  savedefault é especificado para um sistema operacional, em seguida, que a inicialização do sistema operacional faz com que ele se torne o padrão até que outro sistema operacional com savedefault especificado é inicializado. Na Listagem 1, a especificação do defaut=0 substitui qualquer salvou padrão.
boot
É um parâmetro opcional que instrui o GRUB para inicializar o sistema operacional selecionado. Esta é a ação padrão quando todos os comandos para uma seleção foram processadas.
lock
Não é usado na Listagem 1. Isso não inicializa a entrada especificada até que uma senha seja digitada. Se você usar isso, então você também deve especificar uma senha nas opções iniciais; Caso contrário, um usuário pode editar a sua opção de bloqueio e inicializar o sistema ou adicionar “single” para uma das outras entradas. É possível especificar uma senha diferente para entradas individuais, se quiser.
rootnoverify
É semelhante a raiz, exceto que o GRUB não tenta montar o sistema de arquivos ou verificar seus parâmetros. Isso geralmente é usado para sistemas de arquivos, como NTFS que não são suportados pelo GRUB. Você também pode usar este se você quer o GRUB para carregar o registro mestre de inicialização em um disco rígido (por exemplo, para acessar um arquivo de configuração diferente ou para recarregar seu carregador de inicialização anterior).
chainloader
Especifica que outro arquivo será carregado como um arquivo de estágio 1. O valor “1” é equivalente a 1 0, o que significa que para carregar um sector inicial no setor 0; ou seja, carregar o primeiro setor do dispositivo especificado pela raiz ou rootnoverify.
configfile
Especifica que a cópia em execução do GRUB substitui seu arquivo de configuração com um carregado a partir do local de destino. Para que isso funcione, é aconselhável que a versão do GRUB que está carregando o novo configfile é tão atual quanto a versão que o construiu.

Agora você tem alguma ideia do que você pode encontrar em um arquivo /boot/grub/grub.conf típico (ou /boot/grub/menu.lst). Há muitos outros comandos do GRUB para fornecer amplo controle sobre o processo de inicialização, bem como ajudar com a instalação do GRUB e outras tarefas. Você pode aprender mais sobre estes no manual do GRUB, que deverá estar disponível no seu sistema através do comando info grub.

Antes de aprender a lidar com tal um grande arquivo de configuração do GRUB, vamos cair de volta para um exemplo menor e mais simples. Eu uso o arquivo que CentOS 6 construído para mim quando eu instalei ele em / dev / sda11. Isso é mostrado na Listagem 2. Mais uma vez, temos usado uma barra invertida (\) para mostrar onde nós quebramos fileiras de grãos longos para a publicação.

 Listagem 2. configuração do GRUB básico construído pela CentOS 6

 

# grub.conf generated by anaconda
#
# You do not have to rerun grub after making changes to this file
# NOTICE:  You do not have a /boot partition.  This means that
#          all kernel and initrd paths are relative to /, eg.
#          root (hd0,10)
#          kernel /boot/vmlinuz-version ro root=/dev/sdd11
#          initrd /boot/initrd-[generic-]version.img
#boot=/dev/sdd11
default=0
timeout=5
splashimage=(hd0,10)/boot/grub/splash.xpm.gz
hiddenmenu
title CentOS (2.6.32-504.23.4.el6.x86_64)
	root (hd0,10)
	kernel /boot/vmlinuz-2.6.32-504.23.4.el6.x86_64 ro \
           root=UUID=2f60a3b4-ef6c-4d4c-9ef4-50d7f75124a2 rd_NO_LUKS rd_NO_LVM \
           LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun16 crashkernel=128M \
           KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet
	initrd /boot/initramfs-2.6.32-504.23.4.el6.x86_64.img
title CentOS 6 (2.6.32-504.el6.x86_64)
	root (hd0,10)
	kernel /boot/vmlinuz-2.6.32-504.el6.x86_64 ro \
           root=UUID=2f60a3b4-ef6c-4d4c-9ef4-50d7f75124a2 rd_NO_LUKS rd_NO_LVM \
           LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun16 crashkernel=128M \
           KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet
	initrd /boot/initramfs-2.6.32-504.el6.x86_64.img
title Other
	rootnoverify (hd0,0)
	chainloader +1

 

Observe o comando hiddenmenu que você não viu antes. Isso faz com que o GRUB para não exibir um menu, mas sim inicializar a entrada padrão assim que o tempo limite expirar. No nosso caso, isso significa que a primeira entrada (default = 0) será inicializado em 5 segundos (tempo limite = 5). Se você pressionar Enter durante este tempo, o menu será exibido.

Uma vez que você tem um arquivo de configuração do GRUB, você precisa instalá-lo, ou, de preferência testá-lo. Eu vou mostrar-lhe como fazer a instalação primeiro e depois mostrar-lhe como testá-lo usando uma unidade de disquete (se você ainda tem um) ou um CD.

Vou instalar o GRUB no registo de arranque da partição contendo o meu distribuição CentOS. Eu uso o comando grub-install e especificar o dispositivo onde o 512-byte stage1 do carregador de inicialização deve ir. No meu exemplo, isso é / dev / sda11 ou (hd0,10) utilizando a notação GRUB. Consulte a Listagem 3. Você precisa ter autoridade root para gravar o registro de inicialização de partição. Se você tiver adicionado ou suprimido dispositivos que você pode ter que remover seu arquivo /boot/grub/device.map e permitir que o grub-install para reconstruir é como mostrado em nosso exemplo. Isso não vai acontecer muitas vezes, mas se o grub-install joga algum erro estranho que você não entende, você pode encontrar o arquivo device.map exclusão útil.

Listagem 3. Instale GRUB Legacy em um registro de inicialização de partição
[root@attic4-cent ~]# rm /boot/grub/device.map 
rm: remove regular file `/boot/grub/device.map'? y
[root@attic4-cent ~]# grub-install /dev/sda11
Probing devices to guess BIOS drives. This might take a long time.
Installation finished. No error reported.
This is the contents of the device map /boot/grub/device.map.
Check if this is correct or not. If any of the lines is incorrect,
fix it and re-run the script `grub-install'.

(fd0)	/dev/fd0
(hd0)	/dev/sda
(hd1)	/dev/sdb
(hd2)	/dev/sdc
(hd3)	/dev/sdd

Como você já aprendeu o padrão MBR DOS não pode inicializar uma partição lógica, então você precisa de algo mais para obter este sistema inicializado. Uma opção seria a de instalar o GRUB no MBR, fazendo o grub-install /dev/sda, o que também instalar o GRUB no MBR do nosso disco (/ dev / sda). Eu também vou mostrar-lhe como fazê-lo com o GRUB 2 em um momento, mas antes de se comprometer com qualquer passo abordagem, você pode querer testar a sua instalação usando um CD de boot GRUB.

Construindo um CD de recuperação inicializável GRUB

Antes de reiniciar seu novo sistema brilhante, pode ser uma boa ideia para construir um CD de boot GRUB. Primeiro, você preparar uma imagem de CD no seu disco rígido. Você precisa de um diretório temporário, dizer grubcd, com subdiretórios de inicialização e boot / grub. Em seguida, você precisa copiar o arquivo stage2_eltorito de seus arquivos de distribuição do GRUB para o subdiretório grub que você acabou de criar. Em seguida, use genisoimage para criar um arquivo de imagem .iso inicializável que você pode gravar em CD com a sua ferramenta de gravação favorita. A Listagem 4 mostra como criar a imagem CD como grubcd.iso. Você não precisa de autoridade root para fazer isso. Nossa stage2_eltorito está em / usr / share / grub / x86_64-redhat. Este local pode ser diferente em outros sistemas, em particular um sistema de 32 bits. Ou, você pode encontrá-lo em / usr / lib / grub. Você pode ser capaz de localizá-lo usando o comando localizar, também ilustrado na Listagem 4.

Listagem 4. Criando uma imagem do CD de boot GRUB
[ian@attic4-cent ~]$ mkdir mkdir -p grubcd/boot/grub
[ian@attic4-cent ~]$ ls /usr/share/grub/
x86_64-redhat
[ian@attic4-cent ~]$ ls /usr/share/grub/x86_64-redhat/stage2_eltorito
/usr/share/grub/x86_64-redhat/stage2_eltorito
[ian@attic4-cent ~]$ locate stage2_eltorito
/usr/share/grub/x86_64-redhat/stage2_eltorito
[ian@attic4-cent ~]$ cp /usr/share/grub/x86_64-redhat/stage2_eltorito grubcd/boot/grub
[ian@attic4-cent ~]$ genisoimage -R -b boot/grub/stage2_eltorito -no-emul-boot \
> -boot-load-size 4 -boot-info-table -o grubcd.iso grubcd
I: -input-charset not specified, using utf-8 (detected in locale settings)
Size of boot image is 4 sectors -> No emulation
Total translation table size: 2048
Total rockridge attributes bytes: 760
Total directory bytes: 4576
Path table size(bytes): 34
Max brk space used 22000
241 extents written (0 MB)

Você pode iniciar este CD em um PC arbitrária; ele não tem que ser um com um sistema Linux nele. Se você inicializar o CD, ele irá carregar o shell do GRUB a partir do CD. Quando você inicializa, você recebe um aviso de boot GRUB. Pressione a tecla Tab ou usar o comando help para ver uma lista de comandos disponíveis para você. Tente help commandname para obter ajuda sobre o comando chamado commandname.

Uma última coisa antes de reiniciar com o CD: Você pode praticar alguns dos comandos do GRUB que estão disponíveis no shell do GRUB a partir de sua linha de comando do Linux. A Listagem 5 ilustra o comando grub e alguns dos comandos disponíveis, incluindo a capacidade de exibir o menu e ver que é o que você quer. Alguns comandos, como encontrar, precisa de autoridade raiz, por isso o meu exemplo usa isso. Observe também que quando você tentar carregar a primeira entrada de configuração pressionando Enter, falhas do GRUB com uma falha de segmentação. Lembre-se que você pode praticar alguns dos comandos shell do GRUB a partir da linha de comando Bash, mas não todos. Cima e para baixo teclas de seta pode não funcionar. Mais uma vez, uma linha kernel longo é dividido usando \.

Listagem 5. A linha de comando do GRUB
[root@attic4-cent ~]# grub
Probing devices to guess BIOS drives. This might take a long time.


    GNU GRUB  version 0.97  (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> help rootnoverify
help rootnoverify
rootnoverify: rootnoverify [DEVICE [HDBIAS]]
    Similar to `root', but don't attempt to mount the partition. This 
    is useful for when an OS is outside of the area of the disk that 
    GRUB can read, but setting the correct root device is still 
    desired. The items mentioned in `root' which derived 
    from attempting the mount will NOT work correctly.
grub> find /boot/grub/menu.lst
find /boot/grub/menu.lst
 (hd0,0)
 (hd0,7)
 (hd0,10)
grub> configfile (hd0,10)/boot/grub/menu.lst
configfile (hd0,10)/boot/grub/menu.lst

Press any key to enter the menu


    GNU GRUB  version 0.97  (640K lower / 3072K upper memory)

-------------------------------------------------------------------
 0: CentOS (2.6.32-504.23.4.el6.x86_64)
 1: CentOS 6 (2.6.32-504.el6.x86_64)
 2: Other
-------------------------------------------------------------------

      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, 'a' to modify the kernel arguments
      before booting, or 'c' for a command-line.

The selected entry is 0     Highlighted entry is 0: 

  Booting 'CentOS (2.6.32-504.23.4.el6.x86_64)'

root (hd0,10)
 Filesystem type is ext2fs, partition type 0x83
kernel /boot/vmlinuz-2.6.32-504.23.4.el6.x86_64 ro \
root=UUID=2f60a3b4-ef6c-4d4c-9ef4-50d7f75124a2 rd_NO_LUKS rd_NO_LVM \
LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun16 crashkernel=128M  \
KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet
   [Linux-bzImage, setup=0x3400, size=0x3f2790]
Segmentation fault (core dumped)

 

Neste exemplo, existem arquivos de configuração do GRUB em três partições diferentes no primeiro disco rígido, incluindo o que se construiu para CentOS em (hd0,10) ou / dev / sda11. Listagem 5 cargas O menu GRUB a partir de (hd0,10) usando o comando configfile.

Você pode explorar esses comandos grub no manual do GRUB. Tente digitar info grub em uma janela de terminal Linux para abrir o manual.

Se você ainda tiver um disquete, você pode instalar o GRUB em um disquete usando um comando como:

grub-install /dev/fd0

onde / dev / fd0 corresponde à sua unidade de disquete. Você deve desmontar o disquete antes de instalar o GRUB nele.

Inicializando com o GRUB legacy

Agora você está pronto para reiniciar o sistema usando o CD GRUB que você acabou de construir. Se o seu BIOS não está configurado para arrancar automaticamente a partir de um CD ou DVD se estiver presente, então você pode precisar pressionar alguns chave específica do sistema (F8 na minha BIOS) para escolher um dispositivo de arranque que não seja a sua unidade de disco rígido. As botas CD para um prompt do GRUB como mostrado na Figura 1.

Figura 1. Iniciando seu CD GRUB

1

 Neste exemplo, eu usei o comando find para encontrar arquivos de configuração do GRUB chamado menu.lst e encontrou 3, incluindo o meu arquivo de configuração do GRUB CentOS no dispositivo (hd0,10) ou / dev / sda11. Então, usei o comando de  root para definir) hd0,10) como a raiz para outras operações de arquivo. Eu instalei o  GRUB no registo de arranque de partição (hd0,10), então eu uso o comando chainloader para dizer o que quer grub para inicializar carregador de inicialização está no primeiro setor (hd0,10). Finalmente, use o boot comando para inicializar esse novo loader (GRUB novamente no nosso caso). O resultado é mostrado na Figura 2

Figura 2. O menu CentOS Grub

2

 Neste caso pressione Enter para ver o menu. Caso contrário, a opção hiddenmenu simplesmente exibe a linha que está sendo inicializado e um temporizador de contagem regressiva.

Edição no shell do GRUB

Agora, eu mostrar-lhe como usar o shell do GRUB para editar a configuração. Para este efeito, você irá arrancar em modo de usuário único, mas você pode alterar qualquer uma das linhas ou até mesmo adicionar ou excluir linhas inteiras de configuração se necessário. Por exemplo, você pode adicionar uma linha completa de raiz se você tinha esquecido. Você pressiona e para editar a configuração, em seguida, usar a seta para baixo para destacar a linha kernel. O resultado é mostrado na Figura 3.

Figura 3. Edição da linha kernel

3

Prima e novamente e digite a palavra single no final da linha, como mostrado na Figura 4.

Figura 4. Edição da linha kernel

4

Por fim, pressione Enter para voltar à tela que você viu na Figura 2, em seguida b para inicializar CentOS em modo de usuário único. Quando o sistema é inicializado, você terá um prompt de root. Você pode usar este modo para fazer reparos de emergência para um sistema que não inicializa normalmente.

Neste ponto, você pode repetir o processo anterior para inicializar no modo gráfico normal ou modo de tudo o que você tinha configurar o seu sistema para inicializar. Se você queria GRUB para controlar toda a inicialização do sistema, você deve fazer agora

grub-install /dev/sda

para instalar o GRUB no MBR de / dev / sda. Você vai ver outras formas de gerir o seu arranque como prosseguir com este tutorial.

GRUB 2

GRUB 2 é o sucessor do GRUB. Ele foi reescrito do zero para torná-lo muito mais modular e portátil. Destina-se às diferentes arquiteturas e métodos de arranque e tem muitas novas funcionalidades, incluindo a capacidade de lidar com firmware UEFI e discos GPT formatado. Consulte Recursos para obter links para mais informações. Se você estiver familiarizado com o GRUB e começar a usar o GRUB 2, você vai achar que é completamente diferente e você provavelmente terá muitas surpresas.

Nota: A maioria do GRUB 2 exemplos deste tutorial usar o Fedora 22 ou 15 Ubuntu.

A primeira coisa que você pode notar sobre o GRUB 2 é que ele não instala como um gerenciador de inicialização partição. Se você disser a um instalador Linux para instalar o GRUB em uma partição, essa partição não é inicializável por carregamento em cadeia. GRUB 2 deve ser reconstruído quando você atualizar seu sistema. A maioria dos processos de atualização do sistema lidar com isso para você, mas se você tiver vários sistemas operacionais em um sistema, você provavelmente tem que fazer algum trabalho sozinho. Agora, eu mostrar-lhe como usar o GRUB 2, isoladamente ou em conjunto com o GRUB Legacy.

Os GRUB 2 pacotes contêm vários programas, normalmente em / usr / bin ou / usr / sbin. O nome do pacote real mudou ao longo do tempo e não é o mesmo para todas as distribuições. Os binários também têm nomes que normalmente começam com grub- ou grub2-. Por exemplo, no Ubuntu 14, você vai encontrar-grub-image fornecida pelo pacote grub-comum, enquanto no Fedora 22, você vai encontrar-grub2-mkimage fornecida pelo pacote grub2-tools. Veja Aprenda Linux, 101: gerenciamento de pacotes Debian e Aprenda Linux, 101: RPM e gerenciamento de pacotes YUM para ajuda em descobrir qual pacote contém um comando particular. A Listagem 6 mostra os binários GRUB em um sistema Ubuntu 14.04. Como de costume, consultar as páginas man ou tente executar os programas com a opção --help para obter mais informações. Você pode precisar pesquisar na Internet para obter ajuda adicional. Esteja preparado para inconsistência na documentação quando as coisas mudam tão rápido.

Listagem 6. GRUB 2 executáveis ​​em / usr / bin e / usr / sbin
ian@attic-u14:~$ which grub-image
/usr/bin/grub-image
ian@attic-u14:~$ dpkg -S /usr/bin/grub-image
grub-common: /usr/bin/grub-image
ian@attic-u14:~$ dpkg -L grub-common | grep "bin/"
/usr/sbin/grub-mkdevicemap
/usr/sbin/grub-mkconfig
/usr/sbin/grub-probe
/usr/sbin/grub-macbless
/usr/bin/grub-glue-efi
/usr/bin/grub-mkfont
/usr/bin/grub-script-check
/usr/bin/grub-fstest
/usr/bin/grub-mkstandalone
/usr/bin/grub-image
/usr/bin/grub-mklayout
/usr/bin/grub-mkrescue
/usr/bin/grub-mkrelpath
/usr/bin/grub-kbdcomp
/usr/bin/grub-render-label
/usr/bin/grub-mount
/usr/bin/grub-file
/usr/bin/grub-menulst2cfg
/usr/bin/grub-editenv
/usr/bin/grub-syslinux2cfg
/usr/bin/grub-mkpasswd-pbkdf2
/usr/bin/grub-mknetdir

O coração do GRUB 2 é um kernel de inicialização múltipla (/boot/grub/core.img), juntamente com um arquivo de configuração (/boot/grub/grub.cfg). Eles serão gerados por você, se você executar o grub-install e definir o destino como seu MBR (por exemplo: grub-install /dev/sda). Execute o grub-install --help como mostrado na Listagem 7 para ter uma idéia dos programas que são chamados a fazer todo o trabalho. Algumas coisas são semelhantes aos Grub Legacy, mas há uma série de novos itens, como --modules, --grub-setup, --grub-image, e assim por diante.

Listagem 7. GRUB 2 ajuda para o grub-install
ian@attic-u14:~$ grub-install --help
Usage: grub-install [OPTION...] [OPTION] [INSTALL_DEVICE]
Install GRUB on your drive.

      --compress[=no,xz,gz,lzo]   compress GRUB files [optional]
  -d, --directory=DIR        use images and modules under DIR
                             [default=/usr/lib/grub/<platform>]
      --fonts=FONTS          install FONTS [default=unicode]
      --install-modules=MODULES   install only MODULES and their dependencies
                             [default=all]
  -k, --pubkey=FILE          embed FILE as public key for signature checking
      --locale-directory=DIR use translations under DIR
                             [default=/usr/share/locale]
      --locales=LOCALES      install only LOCALES [default=all]
      --modules=MODULES      pre-load specified modules MODULES
      --themes=THEMES        install THEMES [default=starfield]
  -v, --verbose              print verbose messages.
      --allow-floppy         make the drive also bootable as floppy (default
                             for fdX devices). May break on some BIOSes.
      --boot-directory=DIR   install GRUB images under the directory DIR/grub
                             instead of the boot/grub directory
      --bootloader-id=ID     the ID of bootloader. This option is only
                             available on EFI and Macs.
      --core-compress=xz|none|auto
                             choose the compression to use for core image
      --disk-module=MODULE   disk module to use (biosdisk or native). This
                             option is only available on BIOS target.
      --efi-directory=DIR    use DIR as the EFI System Partition root.
      --force                install even if problems are detected
      --force-file-id        use identifier file even if UUID is available
      --label-bgcolor=COLOR  use COLOR for label background
      --label-color=COLOR    use COLOR for label
      --label-font=FILE      use FILE as font for label
      --macppc-directory=DIR use DIR for PPC MAC install.
      --no-bootsector        do not install bootsector
      --no-nvram             don't update the `boot-device'/`Boot*' NVRAM
                             variables. This option is only available on EFI
                             and IEEE1275 targets.
      --no-rs-codes          Do not apply any reed-solomon codes when
                             embedding core.img. This option is only available
                             on x86 BIOS targets.
      --no-uefi-secure-boot  do not install an image usable with UEFI Secure
                             Boot, even if the system was currently started
                             using it. This option is only available on EFI.
      --product-version=STRING   use STRING as product version
      --recheck              delete device map if it already exists
      --removable            the installation device is removable. This option
                             is only available on EFI.
  -s, --skip-fs-probe        do not probe for filesystems in DEVICE
      --target=TARGET        install GRUB for TARGET platform
                             [default=i386-pc]
      --uefi-secure-boot     install an image usable with UEFI Secure Boot.
                             This option is only available on EFI and if the
                             grub-efi-amd64-signed package is installed.
  -?, --help                 give this help list
      --usage                give a short usage message
  -V, --version              print program version

Mandatory or optional arguments to long options are also mandatory or optional
for any corresponding short options.

INSTALL_DEVICE must be system device filename.
grub-install copies GRUB images into boot/grub.  On some platforms, it may
also install GRUB into the boot sector.

Report bugs to <bug-grub@gnu.org>.

Se você executar o grub-install /dev/sda, o processo cria um arquivo de imagem de núcleo para você, constrói um arquivo de configuração, e instala o GRUB 2 no seu MBR. Se você não está pronto para se comprometer com GRUB 2 para toda a sua configuração, você pode construir estas peças si mesmo e, em seguida, iniciar a imagem do GRUB 2 núcleo de GRUB Legacy ou LILO.

Construindo o arquivo de configuração do GRUB 2

O arquivo de configuração do GRUB 2 é normalmente /boot/grub/grub.cfg. Ao contrário de GRUB Legacy, você normalmente não deve editar esse arquivo você mesmo, pois ele será substituído na próxima vez que sua instalação GRUB 2 é atualizado. Você deve construí-lo usando grub-mkconfig. Em alguns sistemas, como o Ubuntu, o comando update-grub é um front-end para o grub-mkconfig que salva sua saída em /boot/grub/grub.cfg. Estes comandos olhar para as configurações gerais (como o fundo ou o tempo limite) em / etc / default / grub e, em seguida, executar arquivos executáveis ​​de /etc/grub.d/ para construir várias partes do arquivo de configuração, tais como o cabeçalho, uma seção para o atual distribuição Linux, seções para outros sistemas operacionais, e suas próprias adições feitas sob encomenda. Se você precisa de personalizar o menu GRUB 2, você adicionar as alterações em um arquivo no /etc/grub.d/ como 40_custom, ou adicione seu próprio arquivo. Lembre-se que ele precisa ser executável. Eu mostrar-lhe um exemplo de personalização tarde quando eu mostrar-lhe como carga cadeia GRUB legado do GRUB 2.

Executar grub-mkconfig (ou update-grub se disponível) para gerar um novo arquivo /boot/grub/grub.cfg como mostrado na Listagem 8.

Listagem 8. Construindo um arquivo de configuração do GRUB 2 com grub-mkconfig
ian@attic-u14:~$ sudo grub-mkconfig -o /boot/grub/grub.cfg
Generating grub configuration file ...
Found linux image: /boot/vmlinuz-3.16.0-43-generic
Found initrd image: /boot/initrd.img-3.16.0-43-generic
Found linux image: /boot/vmlinuz-3.16.0-30-generic
Found initrd image: /boot/initrd.img-3.16.0-30-generic
Found memtest86+ image: /boot/memtest86+.elf
Found memtest86+ image: /boot/memtest86+.bin
Found Fedora release 20 (Heisenbug) on /dev/sda10
Found CentOS release 6.6 (Final) on /dev/sda11
Found Fedora release 22 (Twenty Two) on /dev/sda5
Found Slackware Linux (Slackware 13.37.0) on /dev/sda6
Found Fedora release 18 (Spherical Cow) on /dev/sda7
Found openSUSE 11.4 (x86_64) on /dev/sda8
Found Ubuntu 12.04 LTS (12.04) on /dev/sda9
done

A Listagem 9 mostra a parte do cabeçalho do arquivo de configuração resultante, e Listagem 10 mostra as primeiras entradas do menu. Indiquei linhas longas que eu quebrei para publicação usando uma barra invertida (\). Observe que as estrofes menuentry olhar mais como shell scripts do que os comandos simples sem lógica do GRUB Legacy. Outra mudança importante do GRUB Legacy é que a numeração de partição agora começa em 1, embora a numeração de disco ainda começa em 0. Então / dev / sda7 é (hd0,7) no GRUB 2, onde seria (hd0,6) no GRUB Legacy. GRUB 2 também pode usar um nome de partição opcional, bem como um número. Então, (hd0,7) também pode ser referido como (hd0, MSDOS7) para deixar claro que ele está em um disco MBR formatado. Em um disco GPT formatado, você usaria (hd0, gpt7).

Listagem 9. GRUB 2 cabeçalho do arquivo de configuração
#
# DO NOT EDIT THIS FILE
#
# It is automatically generated by grub-mkconfig using templates
# from /etc/grub.d and settings from /etc/default/grub
#

### BEGIN /etc/grub.d/00_header ###
if [ -s $prefix/grubenv ]; then
  set have_grubenv=true
  load_env
fi
if [ "${next_entry}" ] ; then
   set default="${next_entry}"
   set next_entry=
   save_env next_entry
   set boot_once=true
else
   set default="0"
fi

if [ x"${feature_menuentry_id}" = xy ]; then
  menuentry_id_option="--id"
else
  menuentry_id_option=""
fi

export menuentry_id_option

if [ "${prev_saved_entry}" ]; then
  set saved_entry="${prev_saved_entry}"
  save_env saved_entry
  set prev_saved_entry=
  save_env prev_saved_entry
  set boot_once=true
fi

function savedefault {
  if [ -z "${boot_once}" ]; then
    saved_entry="${chosen}"
    save_env saved_entry
  fi
}
function recordfail {
  set recordfail=1
  if [ -n "${have_grubenv}" ]; then if [ -z "${boot_once}" ]; then save_env recordfail; fi; fi
}
function load_video {
  if [ x$feature_all_video_module = xy ]; then
    insmod all_video
  else
    insmod efi_gop
    insmod efi_uga
    insmod ieee1275_fb
    insmod vbe
    insmod vga
    insmod video_bochs
    insmod video_cirrus
  fi
}

if [ x$feature_default_font_path = xy ] ; then
   font=unicode
else
insmod part_msdos
insmod ext2
set root='hd0,msdos12'
if [ x$feature_platform_search_hint = xy ]; then
  search --no-floppy --fs-uuid --set=root --hint-bios=hd0,msdos12 --hint-efi=hd0,msdos12 \
    --hint-baremetal=ahci0,msdos12  943524cc-19a9-4237-ac9e-5c1a61a131e3
else
  search --no-floppy --fs-uuid --set=root 943524cc-19a9-4237-ac9e-5c1a61a131e3
fi
    font="/usr/share/grub/unicode.pf2"
fi

if loadfont $font ; then
  set gfxmode=auto
  load_video
  insmod gfxterm
  set locale_dir=$prefix/locale
  set lang=en_US
  insmod gettext
fi
terminal_output gfxterm
if [ "${recordfail}" = 1 ] ; then
  set timeout=30
else
  if [ x$feature_timeout_style = xy ] ; then
    set timeout_style=menu
    set timeout=60
  # Fallback normal timeout code in case the timeout_style feature is
  # unavailable.
  else
    set timeout=60
  fi
fi
### END /etc/grub.d/00_header ###
Listagem 10. Alguns GRUB 2 entradas do menu de configuração do arquivo
### BEGIN /etc/grub.d/10_linux ###
function gfxmode {
	set gfxpayload="${1}"
	if [ "${1}" = "keep" ]; then
		set vt_handoff=vt.handoff=7
	else
		set vt_handoff=
	fi
}
if [ "${recordfail}" != 1 ]; then
  if [ -e ${prefix}/gfxblacklist.txt ]; then
    if hwmatch ${prefix}/gfxblacklist.txt 3; then
      if [ ${match} = 0 ]; then
        set linux_gfx_mode=keep
      else
        set linux_gfx_mode=text
      fi
    else
      set linux_gfx_mode=text
    fi
  else
    set linux_gfx_mode=keep
  fi
else
  set linux_gfx_mode=text
fi
export linux_gfx_mode
menuentry 'Ubuntu' --class ubuntu --class gnu-linux --class gnu \
    --class os $menuentry_id_option \
    'gnulinux-simple-943524cc-19a9-4237-ac9e-5c1a61a131e3' {
	recordfail
	load_video
	gfxmode $linux_gfx_mode
	insmod gzio
	insmod part_msdos
	insmod ext2
	set root='hd0,msdos12'
	if [ x$feature_platform_search_hint = xy ]; then
	  search --no-floppy --fs-uuid --set=root --hint-bios=hd0,msdos12 \
       --hint-efi=hd0,msdos12 --hint-baremetal=ahci0,msdos12  ]
       943524cc-19a9-4237-ac9e-5c1a61a131e3
	else
	  search --no-floppy --fs-uuid --set=root 943524cc-19a9-4237-ac9e-5c1a61a131e3
	fi
	linux	/boot/vmlinuz-3.16.0-43-generic root=UUID=943524cc-19a9-4237-ac9e-5c1a61a131e3 \
        ro quiet splash $vt_handoff
	initrd	/boot/initrd.img-3.16.0-43-generic
}
submenu 'Advanced options for Ubuntu' $menuentry_id_option \
    'gnulinux-advanced-943524cc-19a9-4237-ac9e-5c1a61a131e3' {
	menuentry 'Ubuntu, with Linux 3.16.0-43-generic' --class ubuntu \
     --class gnu-linux --class gnu --class os $menuentry_id_option \
     'gnulinux-3.16.0-43-generic-advanced-943524cc-19a9-4237-ac9e-5c1a61a131e3' {
		recordfail
		load_video
		gfxmode $linux_gfx_mode
		insmod gzio
		insmod part_msdos
		insmod ext2
		set root='hd0,msdos12'
		if [ x$feature_platform_search_hint = xy ]; then
		  search --no-floppy --fs-uuid --set=root --hint-bios=hd0,msdos12 \
          --hint-efi=hd0,msdos12 --hint-baremetal=ahci0,msdos12  \
          943524cc-19a9-4237-ac9e-5c1a61a131e3
		else
		  search --no-floppy --fs-uuid --set=root 943524cc-19a9-4237-ac9e-5c1a61a131e3
		fi
		echo	'Loading Linux 3.16.0-43-generic ...'
		linux	/boot/vmlinuz-3.16.0-43-generic \
          root=UUID=943524cc-19a9-4237-ac9e-5c1a61a131e3 ro quiet splash $vt_handoff
		echo	'Loading initial ramdisk ...'
		initrd	/boot/initrd.img-3.16.0-43-generic
	}
	menuentry 'Ubuntu, with Linux 3.16.0-43-generic (recovery mode)' --class ubuntu \
     --class gnu-linux --class gnu --class os $menuentry_id_option \
     'gnulinux-3.16.0-43-generic-recovery-943524cc-19a9-4237-ac9e-5c1a61a131e3' {
		recordfail
		load_video
		insmod gzio
		insmod part_msdos
		insmod ext2
		set root='hd0,msdos12'
		if [ x$feature_platform_search_hint = xy ]; then
		  search --no-floppy --fs-uuid --set=root --hint-bios=hd0,msdos12 \
         --hinter=hd0,msdos12--bargain-basement=ahci0,msdos12  \
          943524cc-19a9-4237-ac9e-5c1a61a131e3
		else
		  search--no-floppy--fluidised--set=root 943524cc-19a9-4237-ac9e-5c1a61a131e3
		phi
		echo	'Loading Linux 3.16.0-43-generic..'
		Linux	/boot/vmlinuz-3.16.0-43-generic \
                root=UUID=943524cc-19a9-4237-ac9e-5c1a61a131e3 or \
                recovery Modesto 
		echo	'Loading initial ram disk..'
		initrd	/boot/initrd.img-3.16.0-43-generic
	}
	menu entry 'Ubuntu, with Linux 3.16.0-30-generic'--class Ubuntu \
        --class Linux--class gnu--class OS $menu entry_id_option \
         'gnulinux-3.16.0-30-generic-advanced-943524cc-19a9-4237-ac9e-5c1a61a131e3' {
		record fail
		load_video
		modem $Linux_GIF_mode
		ins mod Zion
		ins mod part_ms dos
		ins mod ext2
		set root='hd0,msdos12'
		if [ x$feature_platform_search_hint = x ]; then
		  search--no-floppy--fluidised--set=root--hint-bios=hd0,msdos12 \
         --hinter=hd0,msdos12--bargain-basement=ahci0,msdos12  \
          943524cc-19a9-4237-ac9e-5c1a61a131e3
		else
		  search--no-floppy--fluidised--set=root 943524cc-19a9-4237-ac9e-5c1a61a131e3
		phi
		echo	'Loading Linux 3.16.0-30-generic..'
		Linux	/boot/vmlinuz-3.16.0-30-generic \
                root=UUID=943524cc-19a9-4237-ac9e-5c1a61a131e3 \
                or quiet splash $VT_hand off
		echo	'Loading initial ram disk..'
		initrd	/boot/initrd.img-3.16.0-30-generic
	}
	menu entry 'Ubuntu, with Linux 3.16.0-30-generic (recovery mode)'--class Ubuntu \
         --class Linux--class gnu--class OS $menu entry_id_option \
          'gnulinux-3.16.0-30-generic-recovery-943524cc-19a9-4237-ac9e-5c1a61a131e3' {
		record fail
		load_video
		ins mod Zion
		ins mod part_ms dos
		ins mod ext2
		set root='hd0,msdos12'
		if [ x$feature_platform_search_hint = x ]; then
		  search--no-floppy--fluidised--set=root--hint-bios=hd0,msdos12 \
         --hinter=hd0,msdos12--bargain-basement=ahci0,msdos12  \
          943524cc-19a9-4237-ac9e-5c1a61a131e3
		else
		  search--no-floppy--fluidised--set=root 943524cc-19a9-4237-ac9e-5c1a61a131e3
		phi
		echo	'Loading Linux 3.16.0-30-generic..'
		Linux	/boot/vmlinuz-3.16.0-30-generic \
                root=UUID=943524cc-19a9-4237-ac9e-5c1a61a131e3 \
                or recovery Modesto 
		echo	'Loading initial ram disk..'
		initrd	/boot/initrd.img-3.16.0-30-generic
	}
}

### END /etc/grub.d/10_Linux ###
Construir a imagem do núcleo 2 do GRUB

A maneira mais fácil de construir um novo arquivo de imagem principal é executar o grub-install (ou grub2-instalar de acordo com seu sistema), mas não atualizar o MBR. Algumas versões do programa de instalação o setor de inicialização usando a opção -grub-setup para indicar qual o programa que faz a verdadeira configuração. Definir isso para / bin / true para não fazer nada e, assim, evitar a atualização do setor de inicialização. Outras versões não têm uma opção -grub-setup, mas tem a opção non-sectária em vez disso. Verifique as páginas man. Eu mostrar dois exemplos diferentes em Listagem 11. I primeiro remover o core.img existente para mostrar que o arquivo é na verdade gerado.

Listagem 11. Construindo a imagem GRUB 2 núcleo com o grub-install ou grub2-install
[root@atticf20 ~]# # Build a core.img file on Fedora 22
[root@atticf20 ~]# grub2-install --recheck --grub-setup=/bin/true /dev/sda
Installing for i386-pc platform.
Installation finished. No error reported.
[root@atticf20 ~]# ls -l /boot/grub2/i386-pc/core.img 
-rw-r--r--. 1 root root 25887 Jul 12 22:56 /boot/grub2/i386-pc/core.img

ian@attic-u14:~$ # Build a core.img file on Ubuntu 14
ian@attic-u14:~$ sudo grub-install --non-sectarian /dev/sda
[sudo] password for ian: 
Installing for i386-pc platform.
Installation finished. No error reported.
ian@attic-u14:~$ ls -l /boot/grub/i386-pc/core.img 
-rw-r--r-- 1 root root 25363 Jul 12 23:15 /boot/grub/i386-pc/core.img
Construir uma GRUB 2 CD de recuperação inicializável

GRUB 2 vem com um grub-mkrescue ou comando  grub2-mkrescue para ajudá-lo a criar uma imagem de CD de recuperação. As versões recentes do grub-mkrescue usar o pacote xorriso ao invés do pacote mkisofs ou pacote genisoimage para criar a imagem ISO, por isso você precisa instalar, se sua primeira tentativa falhar com uma mensagem de erro indicando que Xorriso não for encontrado ou estiver no nível errado . Listagem 12 mostra como criar uma imagem de GRUB 2 salvamento em arquivo rescue.iso. Você não tem que ser root para criar o ISO de resgate.

Listagem 12. Criando uma imagem de resgate um GRUB 2
[root@echidna ~]# /usr/bin/grub2-mkrescue -o rescue.iso
Enabling BIOS support ...
xorriso 1.2.4 : RockRidge filesystem manipulator, libburnia project.

Drive current: -outdev 'stdio:rescue.iso'
Media current: stdio file, overwriteable
Media status : is blank
Media summary: 0 sessions, 0 data blocks, 0 data, 7177m free
Added to ISO image: directory '/'='/tmp/tmp.Dw4KSbpoIx'
xorriso : UPDATE : 196 files added in 1 seconds
xorriso : UPDATE : 196 files added in 1 seconds
xorriso : NOTE : Copying to System Area: 29191 bytes from file '/tmp/tmp.LepCeiJPZM'
ISO image produced: 1094 sectors
Written to medium : 1094 sectors at LBA 0
Writing to 'stdio:rescue.iso' completed successfully.

Depois de ter criado a imagem ISO, você pode gravá-lo em um CD (ou DVD), utilizando sua ferramenta de gravação favorita. Se preferir, você também pode copiá-lo para uma unidade flash USB e boot isto supondo que sua BIOS suporta arrancar a partir desses dispositivos. A Listagem 13 mostra como usar o comando dd para copiar a imagem ISO para a unidade flash USB / dev / sde.

Aviso: Certifique-se de que você copiar a imagem para o dispositivo correto. Copiá-lo para o dispositivo incorreto pode destruir um monte de seus dados.

Listagem 13. Escrevendo uma imagem de resgate GRUB 2 para uma unidade flash USB
ian@attic-u14:~$ # Burn .iso image to USB stick /dev/sde
ian@attic-u14:~$ sudo dd if=rescue.iso of=/dev/sde
9864+0 records in
9864+0 records out
5050368 bytes (5.1 MB) copied, 3.95946 s, 1.3 MB/s

Agora você deve ter um CD ou uma unidade flash USB inicializável que irá arrancar para uma linha de GRUB 2.

Inicializando com o GRUB 2

Você vai arrancar a unidade flash USB para ver como ele funciona. Tal como acontece com o legado GRUB, este botas do disco de recuperação para um prompt do GRUB onde você digita comandos. Eu mostrar-lhe algumas que você pode usar para iniciar o sistema Ubuntu 14 cujo arquivo de configuração que eu construí mais cedo. A Figura 5 mostra a tela após iniciar e digite alguns comandos.

Figura 5. Iniciar a unidade flash 2 resgate GRUB

grub2-rescue-boot

Os comandos introduzidos foram os seguintes:

ls

Sem argumentos, lista os dispositivos que foram encontrados. Isso pode levar algum tempo para ser executado. Drives flash não são normalmente unidades de BIOS, mas se você inicializar a partir de um, ele provavelmente mostra-se como hd0 e desloca outras unidades, causando-lhes para não ser numerados conforme o esperado. Usando um CD ou DVD evita esse problema.

set

Sets variable values. In this case, you set the root variable. Compare with the GRUB legacy root command. You use hd1 instead of hd0, because the previous command told you that hd0 is now the USB flash drive from which you booted.

ls

Com um caminho, exibe arquivos ou diretórios. Use Bash-como a conclusão de tabulação, quer completar o componente de caminho que você está digitando ou para obter uma lista de possíveis conclusões de como você vê aqui (eu pressionei tab depois de entrar / boot / grub / GRU).

configfile

Tal como acontece com GRUB legacy, você pode carregar um arquivo de configuração usando o comando configfile. Você carrega o que você construiu earlier.Once você carregar o arquivo de configuração, o ecrã parece com a Figura 6.

Figure 6. Ubuntu 14 configuration file for GRUB2

ubuntu-grub2

Tal como acontece com GRUB legacy, você pode editar entradas de configuração ou digite os comandos antes de inicializar um sistema.

Você pode explorar os muitos GRUB 2 comandos mais no manual do GRUB. Tente digitar info grub ou info grub2 em uma janela de terminal Linux para abrir o manual.

Iniciando GRUB 2 do GRUB Legacy e vice-versa

Eu mencionei que você não pode corrente de carga GRUB 2 a partir de um registro de inicialização de partição. Uma vez que você construir sua imagem de núcleo e arquivo de configuração, adicione uma entrada para o seu grub.conf GRUB Legacy ou arquivo menu.lst para arrancar a imagem do núcleo GRUB 2, que, em seguida, exibe o menu GRUB 2 que você construiu. A Listagem 14 mostra a entrada que para a instalação do Ubuntu 14 em / dev / sda12 que eu também usei para trás na Listagem 1. Uma vez que este arquivo de configuração é para o GRUB Legacy, especifica a entrada raiz (hd0,11) para / dev / sda12.

Listagem 14. Grub entrada de configuração legado imagem 2 núcleo GRUB para inicializar
title Ubuntu 14.04 32-bit (sda12)
	root (hd0,11)
        kernel /boot/grub/core.img

Da mesma forma, você pode adicionar uma entrada ao seu arquivo de configuração do GRUB 2 a corrente do carregador de boot GRUB Legacy. Atualize o arquivo de modelo, /etc/grub.d/40_custom, em vez de editar o arquivo de configuração diretamente. A Listagem 15 mostra uma entrada típica para fazer isso. Este é de minha instalação do Fedora 22. Ele define a raiz de (hd0,1), que no meu sistema é uma partição de boot especial que eu vou discutir em breve.

Listagem 15. Cadeia de carregamento GRUB GRUB 2 usando /etc/grub.d/40_custom
#!/bin/sh
exec tail -n +3 $0
# This file provides an easy way to add custom menu entries.  Simply type the
# menu entries you want to add after this comment.  Be careful not to change
# the 'exec tail' line above.
menuentry "GRUB-Legacy /dev/sda1" {
	insmod chain
	insmod ext2
	set root=(hd0,1)
	chainloader +1
}

Depois de executar o grub-mkconfig novamente, desta entrada é adicionada à cauda de seu arquivo de configuração e mostra-se pela última vez.

Você verá isso em prática na no Utilizando uma sessão partição de inicialização mais adiante neste tutorial.

 

Atualizações do sistema

A maioria das distribuições oferecem ferramentas para a atualização do sistema. Estas ferramentas são geralmente cientes do carregador de boot em uso e, muitas vezes atualizar seu arquivo de configuração automaticamente. Se você construir o seu próprio kernel personalizado, ou preferem usar um arquivo de configuração com um nome não-padrão ou localização, então você pode precisar atualizar a configuração do arquivo você mesmo.

 

  • Se você usar o GRUB, você pode editar o arquivo /boot/grub/grub.conf para fazer suas alterações, eo carregador de estágio GRUB 2 lê o arquivo quando você reiniciar. Você normalmente não precisa reinstalar o GRUB só porque você adicionar um novo kernel. No entanto, se você mover uma partição, ou adicionar unidades, pode ser necessário reinstalar o GRUB. Lembre-se do estágio 1 carregador é muito pequena, por isso tem uma lista de endereços de blocos para o estágio 2 do carregador. Mover a partição e os endereços de mudar, de modo que a fase 1 já não pode localizar fase 2. Eu vou cobrir algumas estratégias de recuperação e também discutir estágio 1,5 carregadores do GRUB seguinte.
  • Se você usar o GRUB 2, você reconstruir a configuração do GRUB 2, conforme descrito em Construindo o arquivo de configuração do GRUB 2.
  • Se você usar LILO, então você deve executar o comando lilo sempre que você atualizar seu arquivo de configuração ou fazer alterações, como adicionar um disco rígido ou apagar uma partição.
  • Se você executar mais de um sistema Linux em diferentes partições, considere o uso de uma partição de boot.
Recuperação

Agora, vamos olhar algumas coisas que podem dar errado com sua configuração de inicialização cuidadosamente preparado, especialmente quando você instalar e inicializar vários sistemas operacionais. A primeira coisa a lembrar é a de resistir à sua tentação inicial a entrar em pânico. A recuperação é geralmente apenas a poucos passos de distância. Estas estratégias podem ajudá-lo através de muitos tipos de crises.

Qualquer pessoa com acesso físico a uma máquina tem um monte de energia. Da mesma forma, qualquer pessoa com acesso a uma linha de comando do GRUB também tem acesso a arquivos em seu sistema sem o benefício de qualquer propriedade ou outras disposições de segurança fornecidos por um sistema em execução.

Manter estes pontos em mente quando você seleciona o seu gerenciador de inicialização. A escolha entre o LILO, GRUB, ou GRUB 2 é em grande parte uma questão de preferência pessoal, embora o GRUB 2 está se tornando dominante. Escolha o carregador que melhor se adapte às suas necessidades e estilo de trabalho específicas.

Outra instalar destrói seu MBR

Yno a instalar outro sistema operacional e, inadvertidamente, substituir sua MBR. Alguns sistemas, como o DOS e Windows, sempre instalar seu próprio MBR. É geralmente fácil de se recuperar dessa situação. Se você desenvolver um hábito de criar um disquete de recuperação, unidade flash USB, CD ou toda vez que você executar o lilo, reinstalar o GRUB, ou atualizar GRUB 2, você está em casa gratuitamente. Inicie seu novo sistema Linux a partir do disquete e lilo reprise, o grub-install ou grub2-install conforme o caso.

Se você não acontecer de ter sua própria mídia de recuperação, mas você ainda tem praticamente qualquer distribuição Linux ao vivo ou mídia de instalação disponível, você pode usar o modo de recuperação dos meios de distribuição ou a mídia ao vivo para reparar o MBR seja quebrado ou construir media de recuperação como você tem feito neste tutorial.

Você moveu uma partição

Se você moveu uma partição e esqueceu-se sobre a sua configuração de inicialização, você tem um problema temporário. Normalmente, o LILO ou GRUB se recusam a carregar. LILO provavelmente irá imprimir um ‘L’, indicando que a fase 1 foi carregado e, em seguida, parar. GRUB lhe dará uma mensagem de erro. O que aconteceu aqui é que o estágio 1 carregador, que tinha uma lista de setores para carregar para chegar ao carregador de fase 2, talvez possa carregar os sectores a partir dos endereços que ele tem, mas os setores já não têm a assinatura estágio 2. Quanto ao caso da MBR destruído, você precisa reinstalar o boot loader, por isso ou usar o seu CD de recuperação ou uma distribuição Linux como eu descrevi.

Você deve ter notado que os exemplos de configuração utilizados alguns IDs universalmente exclusivo (UUID) para partições (por exemplo, o trecho mostrado na Listagem 17 que você viu na Listagem 1.

Listagem 17. Usando um UUID
title CentOS (2.6.32-504.23.4.el6.x86_64)
	root (hd0,10)
	kernel /boot/vmlinuz-2.6.32-504.23.4.el6.x86_64 ro \
           root=UUID=2f60a3b4-ef6c-4d4c-9ef4-50d7f75124a2 rd_NO_LUKS rd_NO_LVM \
           LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun16 crashkernel=128M \
           KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet
	initrd /boot/initramfs-2.6.32-504.23.4.el6.x86_64.img

Antes do advento da UUIDs, partições MBR também poderia ter um rótulo atribuído usando o comando e2label ou uma ferramenta de particionamento, como o GParted. Estes também fornecer um nível de independência de movimentos de partição.

Costumo usar UUIDs como este para ajudar a evitar problemas quando eu mover partições. Você ainda precisará atualizar o arquivo de configuração do LILO ou GRUB e LILO reprise, mas você não tem que atualizar o / etc / fstab também. Isto é particularmente útil se você criar uma imagem de partição em um sistema e restaurá-lo em um local diferente em outro sistema. Também é útil se você inicializar a partir de uma unidade, como uma unidade USB, que não pode sempre ser anexado no mesmo local.

Você pode usar o comando blkid para exibir os rótulos (se houver) e UUIDs para seus discos como mostrado na Listagem 18. Como você pode ver, algumas das minhas partições utilize etiquetas e outros não.

Listagem 18. Exibindo rótulos e UUIDs para partições
ian@attic-u14:~$ sudo blkid
/dev/sda1: LABEL="/grubfile" UUID="3c3de27e-779a-44d5-ad7a-61c5fd03d9e7" TYPE="ext3" 
/dev/sda2: UUID="158d605e-2591-4749-bf59-5e92e1b1c01d" TYPE="swap" 
/dev/sda3: UUID="ff0b87d2-6929-45df-88e1-d6d3e5cf3d6f" TYPE="ext4" 
/dev/sda5: LABEL="FEDORA22" UUID="7aefe7a0-97d5-45ec-a92e-00a6363fb1e4" TYPE="ext4" 
/dev/sda6: UUID="78a8c7de-cb86-45fe-ac04-be67ef52cb12" TYPE="ext4" 
/dev/sda7: LABEL="FEDORA 18" UUID="1b441a69-63e3-4771-a06b-5efecd1df07e" TYPE="ext4" 
/dev/sda8: LABEL="SUSE13-2" UUID="49d87897-791e-4e48-9efb-704eac447e43" SEC_TYPE="ext2" TYPE="ext3" 
/dev/sda9: UUID="10e82894-186f-4223-95c8-3468eb9b085d" SEC_TYPE="ext2" TYPE="ext3" 
/dev/sda10: LABEL="FEDORA20-64" UUID="8e6e2ebd-20b9-46e8-865f-893dd88c3206" TYPE="ext4" 
/dev/sda11: UUID="2f60a3b4-ef6c-4d4c-9ef4-50d7f75124a2" SEC_TYPE="ext2" TYPE="ext3" 
/dev/sda12: LABEL="UBUNTU-1404" UUID="943524cc-19a9-4237-ac9e-5c1a61a131e3" TYPE="ext4" 
/dev/sdb1: LABEL="GRUB-DATA" UUID="a36a3539-8393-4940-a893-472e9e1c868e" SEC_TYPE="ext2" TYPE="ext3" 
/dev/sdb2: LABEL="DATA-IAN" UUID="4c962b67-c646-467f-96fb-cbbd6de40140" TYPE="ext4" 
/dev/sdb3: LABEL="RESEARCH" UUID="0998d33c-3398-463d-b0e3-7c13ca0c675f" TYPE="ext3" 
/dev/sdb4: UUID="86ad1df3-fea4-47e5-bfdd-fb09f6c2e64a" TYPE="ext4" 
/dev/sdc1: LABEL="PICTURES" UUID="e3be4658-b79b-470d-82fe-bb434bcdcc2f" TYPE="ext4" 
/dev/sr0: LABEL="ISOIMAGE" TYPE="iso9660"

GRUB 2 hoje em dia gera arquivos de configuração que usam os nomes antigos dispositivo como sugestões, mas a raiz é realmente definido com base no UUID (ou rótulo). Consulte o manual do GRUB 2 para mais detalhes. Um trecho de exemplo para o sistema Ubuntu 14 que eu construí uma configuração para anterior é mostrado na Listagem 19. Depois de inicialmente definir a raiz para “hd0, msdos12 ‘, a lógica a seguir usa o comando de pesquisa com algumas dicas para localizar o local real do dispositivo raiz (/ dev / sda12 se nada tivesse mudado).

Listagem 19. Localizando o dispositivo raiz por UUID usando GRUB2
set root='hd0,msdos12'
if [ x$feature_platform_search_hint = xy ]; then
  search --no-floppy --fs-uuid --set=root --hint-bios=hd0,msdos12 --hint-efi=hd0,msdos12 \
    --hint-baremetal=ahci0,msdos12  943524cc-19a9-4237-ac9e-5c1a61a131e3
else
  search --no-floppy --fs-uuid --set=root 943524cc-19a9-4237-ac9e-5c1a61a131e3
fi

Você viu isto em uso quando você iniciou a partir da unidade flash de recuperação mais cedo. Lembre-se que a unidade flash tornou-se (hd0) ea primeira unidade de disco rígido tornou-se (hd1) .Além disso aos métodos e ferramentas mencionadas aqui, existem várias recuperação e inicialização pacotes disponíveis na Internet. Estes geralmente incluem algum nível de sistema de arranque juntamente com uma série de ferramentas de recuperação úteis. Os exemplos incluem pacotes, como o Knoppix eo CD Rescue System (consulte Recursos para obter links, ou pesquisar na Internet por um dos vários excelentes comentários de tais pacotes.

Usando uma partição de boot

Outra abordagem para a recuperação, ou talvez evitá-lo, é usar uma partição separada para a inicialização. Como você acabou de ver, o GRUB 2 tornou-se muito mais resistente a mudanças no sistema. No entanto, para GRUB Legacy e LILO, uma partição de boot pode ser particularmente útil se você tiver um sistema de teste com várias distribuições nele que você pode reconstruir com freqüência. A partição de inicialização não precisa ser muito grande, talvez 100MB ou mais. Coloque esta partição em algum lugar onde é improvável para ser transferida e onde é improvável que tenha o seu número de partição movidos pela adição ou remoção de outra partição. Em um ambiente misto de Windows e Linux, / dev / sda2 (ou / dev / hda2 dependendo de como os discos são rotulados) é frequentemente uma boa escolha para a sua partição de boot. Na verdade, a Listagem 1 que você viu anteriormente mostra as entradas na pequena partição de boot (/ dev / sda1) que eu uso no meu sistema.

Embora eu adicionei uma entrada para o propósito deste tutorial para inicialização diretamente em CentOS, minha estratégia usual é a de manter as entradas simples e usá-los para carga cadeia outro carregador de boot, ou carregar o arquivo core.img GRUB 2. Os exemplos que você viu na seção Inicialização GRUB 2 do GRUB Legacy e utilização vice-versa esta estratégia simples. Se você usar entradas que iniciar diretamente em um kernel especial que você precisa atualizá-los manualmente sempre que você atualizar o sistema de destino. Evite o trabalho extra quando você puder. A figura 8 mostra o meu menu GRUB simples.

Figura 8. Um menu de boot GRUB simples partição

boot-part-grub

Para esta partição, eu uso uma imagem de abertura personalizada que eu fiz de uma foto eu recolhi o parque nacional de Great Sand Dunes em Colorado. Consulte as páginas do manual ou pesquisa on-line para obter mais informações sobre como fazer suas próprias imagens respingo. A Figura 9 mostra a entrada que foi adicionada ao final do meu menu Fedora 22 GRUB 2 usando o arquivo /etc/grub.d/40_custom.

Figura 9. Cadeia entrada loader de GRUB de GRUB 2

grub2-chain-load

Outra razão para ter uma partição de boot surge quando sua partição raiz usa um sistema de arquivos não é suportado pelo seu gerenciador de inicialização. Por exemplo, é comum ter um arranque partição formatada ext2 ou ext3 / quando a partição raiz (/) usa LVM, que não é suportado pelo GRUB Legacy.

Se você tiver várias distribuições em seu sistema, não compartilham a partição / boot entre eles. Lembre-se de configurar o LILO ou GRUB para inicializar a partir da partição que, mais tarde, ser montado como / boot. Lembre-se também que os programas de atualização para uma distribuição normalmente atualizar o GRUB ou LILO configuração para esse sistema. Em um ambiente com vários sistemas, você pode querer manter um com sua própria partição / boot como o principal e atualizar manualmente o arquivo de configuração sempre que uma atualização de um dos seus sistemas exige. Outra abordagem é fazer com que cada sistema instalar um carregador de inicialização em seu próprio registro de inicialização de partição e ter o seu sistema principal simplesmente corrente de carga dos registros de inicialização de partição para os sistemas individuais, dando-lhe um processo de dois estágios de menu como o que eu uso.

Considerações UEFI e GPT

Embora este tutorial se concentra em unidades MBR formatado, muitos dos conceitos ainda se aplicam para GPT discos formatados. Firmware UEFI é bastante diferente do BIOS e muito mais capaz. Isso, é claro, traz novos desafios. Um dos novos recursos é a noção de inicialização segura(Secure boot), que só permite que os binários para arrancar assinado. Muitos sistemas UEFI ainda suportar o arranque modo de legado(Legacy mode), que permite que sistemas mais antigos para inicializar o hardware. Windows 8 exige UEFI e inicialização segura(Secure boot), juntamente com discos GPT formatado, por isso, se você deseja instalar junto com o Windows 8 ou mais tarde, você precisa saber algo sobre UEFI e inicialização segura.

Nota: Secure Boot é uma tecnologia em que os controles de firmware do sistema que o carregador de inicialização do sistema é assinado com uma chave de criptografia autorizado pela base de dados contidos no firmware. Com a verificação adequada assinatura na próxima fase loader (s) de inicialização, kernel, e, potencialmente, o espaço do usuário, é possível impedir a execução de código não assinado.

Algumas distribuições Linux no LiveDVD, como Ubuntu e Fedora, e seus derivados suportam inicialização em um sistema UEFI com inicialização segura(secure boot) habilitado. Os métodos de determinação da cadeia de confiança ter sido um tanto controverso na comunidade de desenvolvimento do kernel Linux. Será mostrado como desembalar a imagem ISO da distribuição Ubuntu 15.04 em uma unidade flash USB para que você possa explorar a configuração.

Para este exercício, foi usado o sistema Ubuntu 14 para formatar um pequeno flash drive USB como GPT e depois criou uma partição de 2 GB como mostrado na Listagem 20. Foi formatado a partição como FAT32 porque o firmware UEFI precisa de alguns arquivos em uma partição FAT32. Tenha cuidado ao usar o dispositivo correto, seu provavelmente não será  /dev / SDF.

Listagem 20. Preparar uma unidade flash USB GPT formatado
ian@attic-u14:~$ sudo parted /dev/sdf
GNU Parted 2.3
Using /dev/sdf
Welcome to GNU Parted! Type 'help' to view a list of commands.
(parted) mklabel gpt
Warning: The existing disk label on /dev/sdf will be destroyed and all data on
this disk will be lost. Do you want to continue?
Yes/No? yes                                                               
(parted) mkpart primary fat32 1MB 2048MB                                  
(parted) toggle 1 boot                                                  
(parted) print                                                            
Model:  USB DISK 2.0 (scsi)
Disk /dev/sdf: 15.5GB
Sector size (logical/physical): 512B/512B
Partition Table  : gpt

Number  Start   End     Size    File system  Name     Flags
 1      1049kB  2048MB  2047MB  fat32        primary  boot

(parted) quit                                                             
Information: You may need to update /etc/fstab.                           

ian@attic-u14:~$ sudo mkfs.fat -F 32 /dev/sdf1
mkfs.fat 3.0.26 (2014-03-07)

Uma vez que a unidade flash está preparado, você precisa para montá-lo. Então, você precisa para descompactar a imagem ISO do Ubuntu 15 a ele. Listagem 21 mostra uma das muitas maneiras possíveis que você pode fazer isso.

Listagem 21. Desembalagem Ubuntu 15 para uma imagem de USB ao vivo
ian@attic-u14:~$ sudo mkdir /mnt/u15iso /mnt/flashdrive
ian@attic-u14:~$ sudo mount ~/Downloads/ubuntu-15.04-desktop-amd64.iso /mnt/u15iso/ -o ro,loop=/dev/loop1
ian@attic-u14:~$ sudo mount /dev/sdf1 /mnt/flashdrive/
ian@attic-u14:~$ sudo rsync -a -H /mnt/u15iso/ /mnt/flashdrive
rsync: symlink "/mnt/flashdrive/ubuntu" -> "." failed: Operation not permitted (1)
rsync: symlink "/mnt/flashdrive/dists/stable" -> "vivid" failed: Operation not permitted (1)
rsync: symlink "/mnt/flashdrive/dists/unstable" -> "vivid" failed: Operation not permitted (1)
rsync error: some files/attrs were not transferred (see previous errors) (code 23) at \
main.c(1183) [sender=3.1.0]
ian@attic-u14:~$ diff -rq /mnt/u15iso/ /mnt/flashdrive
Only in /mnt/u15iso/dists: stable
Only in /mnt/u15iso/dists: unstable
Only in /mnt/u15iso/: ubuntu
i

Antes de desmontar a unidade flash, olhar alguns arquivos nele. Se você listar o diretório raiz, você vê dois diretórios, EFI e boot, entre outros arquivos e diretórios. O diretório de boot é o seu diretório de boot GRUB 2, enquanto o diretório EFI é um diretório que as pesquisas de firmware UEFI para binários assinados para arrancar. Este é o diretório que deve ter um sistema de arquivos FAT (ou ISO 9660 sistema de arquivos em CD). É por isso que foi formatado a partição como FAT32. Listagem 22 ilustra esses arquivos. Agora você pode desmontar e ejetar a unidade flash e tentar arrancar-lo em um sistema que tem tanto inicialização segura (secure boot ) habilitado e inicialização legado (legacy boot) desativado.

Listagem 22. Examinando o diretório raiz da nossa unidade flash
ian@attic-u14:~$ ls /mnt/flashdrive/
autorun.inf  casper  EFI      isolinux    pics  preseed             wubi.exe
boot         dists   install  md5sum.txt  pool  README.diskdefines
ian@attic-u14:~$ ls /mnt/flashdrive/EFI
BOOT
ian@attic-u14:~$ ls /mnt/flashdrive/EFI/BOOT/
BOOTx64.EFI  grubx64.efi
ian@attic-u14:~$ umount /mnt/flashdrive 
umount: /mnt/flashdrive is not in the fstab (and you are not root)
ian@attic-u14:~$ sudo umount /mnt/flashdrive 
ian@attic-u14:~$ sudo eject /dev/sdf
i

Para inicializar em um sistema Windows 8 com inicialização segura (secure boot) e inicialização UEFI(UEFI boot) habilitado, talvez seja necessário desativar a inicialização rápida (fast boot), pois isso faz com que a reinicialização de um modo semi-hibernat3ed. Você também precisa saber como iniciar a partir de um dispositivo, como uma unidade flash USB. Uma maneira de fazer ambas as tarefas é usar o Ambiente de Recuperação do Windows (consulte Recursos). Uma maneira de acessar esta é para iniciar a sequência de desligamento em seu sistema Windows 8 em execução e, em seguida, segure a tecla Shift ao clicar em Reiniciar (Restart). A Figura 10 mostra a tela de um notebook Lenovo Yoga 2.

Figura 10. Reiniciar para uma unidade flash USB no Windows 8.1

use-a-device

Depois que eu selecione Usar um dispositivo (Use a device) no sistema, o próximo prompt permite-me a escolher um dispositivo USB EFI. A partir de um prompt como que você pode inicializar a unidade flash que você acabou de construir.

Após iniciar o seu sistema Ubuntu, você pode montar a partição EFI do seu sistema Windows 8 e inspecioná-lo. No meu caso, é / dev / sda2. Listagem 23 mostra o diretório EFI nesta partição.

Listagem 23. O diretório do Windows 8.1 EFI em / dev / sda2
ubuntu@ubuntu:~$ sudo mkdir /mnt/sda2
ubuntu@ubuntu:~$ sudo mount /dev/sda2 /mnt/sda2/
ubuntu@ubuntu:~$ ls /mnt/sda2
BOM.BAT  BOOT  EFI
ubuntu@ubuntu:~$ ls /mnt/sda2/EFI/
Boot  Microsoft
ubuntu@ubuntu:~$ ls /mnt/sda2/EFI/Boot/
bootx64.efi

 

Mais uma vez, você encontrar um executável BOOTX64.EFI onde o firmware UEFI sabe de olhar para ele.

Fonte: IBM developerWorks

 

 

 

 

 

Anúncios

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google+

Você está comentando utilizando sua conta Google+. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s