Differences

This shows you the differences between two versions of the page.

--- tutoriais:trocando_o_boot_de_bios_para_uefi [2019-03-15 10:03] – external edit 127.0.0.1
+++ tutoriais:trocando_o_boot_de_bios_para_uefi [2019-08-13 16:16] – removed gnann
@@ Line 1: / Line 1: @@
- ======Trocando o boot de BIOS para EFI======
-Para trocar o modo de boot de um sistema Linux (em particular, esse tutorial usa o Debian) de BIOS para EFI, seguiremos os seguintes passos:
-  *[[#Troca do formato de particionamento de MBR para GPT]]
-  *[[#Criando uma partição EFI]]
-  *[[#Alteração do fstab para montar a partição EFI]]
-  *[[#Instalação de um bootloader na partição EFI]]
-  *[[#Instalação de uma entrada para o bootloader na EFI]]
-Para seguir esse tutorial, utilize um Live CD de Linux (ou Ubuntu) com a mesma arquitetura que o sistema a ser modificado (para que seja possível usar o chroot). Se possível, utilize um CD que possa ser inicializado em modo UEFI, do contrário a etapa final de configuração da UEFI irá falhar e esse passo terá de ser realizado manualmente. Serão necessários os seguintes utilitários:
-  *gdisk (para converter a tabela de partição para GPT)
-  *gparted ou equivalente (para criar a partição EFI)
-  *efibootmgr (para adicionar a entrada do bootloader na EFI)
-O tutorial usa como exemplo um sistema Debian. Para outras distribuições podem ser necessário ajustar:
-  *Instalação de pacotes (em particular para o grub-efi)
-  *Ponto de montagem da partição EFI
-=====Troca do formato de particionamento de MBR para GPT=====
-A troca do formato de particionamento pode ser feita com o comando gdisk. O gdisk deve ser executado como root e pede como argumento o caminho do dispositivo onde será feita a alteração, por exemplo
-  gdisk /dev/sda
-Ao executar o programa, ele deve recolhecer a tabela MBR e avisar que fez uma conversão para GPT na memória, para então mostrar um prompt:
-<code>
-***************************************************************
-Found invalid GPT and valid MBR; converting MBR to GPT format
-in memory. THIS OPERATION IS POTENTIALLY DESTRUCTIVE! Exit by
-typing 'q' if you don't want to convert your MBR partitions
-to GPT format!
-***************************************************************
-Command (? for help):
-</code>
-O comando que nos é relevante é o w (write table to disk and exit). Execute-o e confirme a operação.
-<code>
-Command (? for help): w
-Final checks complete. About to write GPT data. THIS WILL OVERWRITE EXISTING
-PARTITIONS!!
-Do you want to proceed? (Y/N): Y
-OK; writing new GUID partition table (GPT) to /dev/sda.
-Warning: The kernel is still using the old partition table.
-The new table will be used at the next reboot or after you
-run partprobe(8) or kpartx(8)
-The operation has completed successfully.
-</code>
-Agora que a tabela foi convertida para gpt, precisamos criar uma partição EFI.
-=====Criando uma partição EFI=====
-No boot pela BIOS, o início do disco era chamado de MBR (Master Boot Record) e era onde se instalava o código para inicialização do sistema operacional (ou bootloader). Com o tempo, o tamanho da MBR passou a ser insuficiente para colocar o bootloader inteiro na MBR, resultando em esquemas que colocam apenas parte do código na MBR e o resto em uma das partições do disco.
-No boot pela EFI, a ideia é que os bootloaders sejam instalados na EFI System Partition (ESP), que precisa seguir alguns padrões para ser reconhecida adequadamente pelo firmware. Precisamos criar essa partição essa partição manualmente.
-Uma vez que o disco já está com a tabela convertida para gpt, podemos abrir o disco no gparted.
-{{:linux:gparted.png?600|}}
-O tamanho da partição depende da necessidade. Macs costumam criar uma de 200 MiB, Windows apenas 100 MiB. Existem máquinas que tem problemas com partições menores que 512MiB. Por esse motivo, e por um detalhe na implementação do mkdosfs no linux, [[http://www.rodsbooks.com/efi-bootloaders/principles.html|essa página]] recomenda um mínimo de 550MiB. Aqui criaremos uma partição de 1GB. Redimencione as partições para liberar o espaço desejado e ao criar a partição. O gparted permite já formatar a partição como FAT32. Aqui temos o mesmo disco com a partição já criada:
-{{:linux:fat32_pronta.png?600|}}
-Para fazer com que a partição criada seja a partição EFI no gparted, clique com o botão direito na partição e selecione a opção Manage Flags. Na janela seguinte, selecione a flag esp, que também irá colocar a flag boot((Essa "flag" é uma peculiaridade do gparted. Uma ESP é caracterizada pelo tipo de partição GUID C12A7328-F81F-11D2-BA4B-00A0C93EC93B, específico para esse fim, e pela flag de boot. A "flag" do gparted na verdade troca o tipo para esse além de marcar a flag de boot.)):
-{{:linux:flags.png}}
-=====Instalando um boot loader=====
-Bootloader é o nome dado para o código que inicia o sistema operacional. Em sistemas que utilizam BIOS, este fica na MBR (Master Boot Record), que é um trecho de 512 bytes no início do disco e que contem tanto código para iniciar o sistema quanto a tabela de partições. No linux em geral é instalado o GRUB como bootloader, que instala um código inicial nesse trecho, que então carrega o resto do código a partir de uma das partições do disco. Em sistemas EFI, como a especificação garante que o firmware é capaz de ler o formato FAT32, podemos instalar bootloaders como arquivos binários  (que seguem o padrão da especificação) nessa partição, e adicionar entradas de boot na EFI que apontam diretamente para esses arquivos.
-Existem diversas opções de bootloaders que podem ser utilizados para iniciar o Linux, como a versão EFI do GRUB, o rEFInd ou mesmo o embutido do kernel linux (Stub Loader). Aqui veremos como instalar o GRUB e usar o Stub Loader do kernel.
-====GRUB EFI====
-Para instalar corretamente o GRUB EFI, precisamos fazer um chroot no sistema. O procedimento é similar a recuperar um grub BIOS, a principal diferença sendo a necessidade de montar a partição EFI.
-Montamos então os caminhos necessários para o chroot:
-<code>
-mkdir /mnt/sda1
-mount /dev/sda1 /mnt/sda1
-mount -o bind /dev/ /mnt/sda1/dev
-mount -o bind /sys/ /mnt/sda1/sys
-mount -t proc /proc/ /mnt/sda1/proc
-</code>
-E montamos a partição EFI (o caminho pode variar para cada distro, /boot/efi é o utilizado no debian):
-  mkdir /mnt/sda1/boot/efi
-  mount /dev/sda2 /mnt/sda1/boot/efi
-Antes de fazer o chroot, já vamos editar o fstab (que neste exemplo pode ser acessado pelo caminho /mnt/sda1/etc/fstab) e adicionar uma linha para a partição efi, como uma partição vfat comum:
-  UUID=9A9E-2FBF	/boot/efi		vfat	defaults	0	0
-O UUID da partição pode ser determinado pelo comando blkid ou listando os symlinks em /dev/disk/by-uuid. Uma linha de comando que já adiciona a linha usando os caminhos dos exemplos acima é:
-  echo -e "UUID=$(blkid /dev/sda2 -s UUID -o value)\t/boot/efi\t\tvfat\tdefaults\t0\t0" >> /mnt/sda1/etc/fstab
-Podemos então fazer o chroot:
-  chroot /mnt/sda1
-Uma vez dentro do sistema, podemos instalar o grub EFI. No debian, instalamos o pacote grub-efi:
-  apt-get install grub-efi
-E instalamos o grub na partição EFI, especificando o caminho para o disco de destino:
-  grub-install /dev/sda
-  Installing for x86_64-efi platform.
-  Installation finished. No error reported.
-Podemos confirmar que o grub se instalou corretamente na partição listando o conteúdo dela:
-<code>
-ls -R /boot/efi/
-/boot/efi/:
-EFI
-/boot/efi/EFI:
-debian
-/boot/efi/EFI/debian:
-grubx64.efi
-</code>
-E podemos verificar que ele se colocou na lista de inicialização da UEFI com o comando efibootmgr. A entrada 0000 agora é debian, e é a primeira da ordem de boot. Note que essa parte falha se a mídia live utilizada não for iniciada em modo EFI:
-<code>
-efibootmgr
-BootCurrent: 0003
-Timeout: 1 seconds
-BootOrder: 0000,0003,0001,0002,0004,0005
-Boot0000* debian
-Boot0001* Hard Drive
-Boot0002* CD/DVD Drive
-Boot0003* UEFI: SanDisk
-Boot0004* UEFI: SanDisk, Partition 1
-Boot0005* USB
-</code>
-====Instalando o kernel diretamente na partição EFi (EFI stub)====
-Atualmente, o kernel linux tem suporte a ser iniciado diretamente como um binário EFI, basta colocá-lo na partição EFI e adicionar a entrada adequada na lista de boot da EFI. No exemplo, o sistema está na partição /dev/sda1 e a partição EFI em /dev/sda2. Primeiramente montamos as partições:
-<code>
-mkdir /mnt/sda1
-mount /dev/sda1 /mnt/sda1
-mkdir /mnt/sda2
-mount /dev/sda2 /mnt/sda2
-</code>
-Criamos então uma pasta para colocar o kernel. O nome é arbitrário, pode ser algo como 'debian', 'arch' ou similar. Em geral a pasta é criada dentro da pasta EFI da partição, mas mesmo isso não é obrigatório. Vamos criar uma pasta chamada 'banana' na raíz para ilustrar:
-  mkdir /mnt/sda2/banana
-Então copiamos o kernel e o initrd do sistema para esta pasta. Aqui mudamos o nome do kernel apenas para vmlinuz e analogamente para a initrd a fim de simplificar a entrada na lista de boot da EFI, e permitir sobrescrever o kernel sem necessidade de refazê-la:
-  cp /mnt/sda1/boot/vmlinuz-3.16.0-4-amd64 /mnt/sda2/banana/vmlinuz
-  cp /mnt/sda1/boot/initrd.img-3.16.0-4-amd64 /mnt/sda2/banana/initrd.img
-Criamos então a entrada na lista da EFI com o comando efibootmgr:
-Adicionamos então a entrada na lista de boot da EFI:
-  efibootmgr -c -d /dev/sda -p 2 -L "Meu Linux sabor banana" -l '\banana\vmlinuz' -u "root=/dev/sda1 ro initrd=\banana\initrd.img"
-A partição do sistema também pode ser especificada pelo UUID:
-  export UUID=$(blkid -s UUID -o value /dev/sda1)
-  efibootmgr -c -d /dev/sda -p 2 -L "Meu Linux sabor banana" -l '\banana\vmlinuz' -u "root=UUID=$UUID ro initrd=\banana\initrd.img"
-Explicando melhor os parâmetros do comando:
-  *-c: Para criar uma entrada nova (já que o efibootmgr permite diversas operações)
-  *-d: O disco onde está a partição EFI a ser modificada.
-  *-p: A partição do disco que corresponde à partição EFI (no exemplo, colocamos 2 correspondendo a /dev/sda2)
-  *-L: O nome a ser exibido na lista de boot
-  *-l: O caminho para o loader. No nosso caso é o caminho direto para o kernel que colocamos na partição EFI (note que a barra precisa ser invertida).
-  *-u: Parâmetros adicionais a serem passados para o kernel. Note que os parâmetros são passados como uma única string, delimitada aqui por " para não causar problema ao usar a variável $UUID.
-A saída mostrará a lista de boot após a modificação. Aqui já havia uma entrada do grub com nome debian, e a entrada nova ficou como 0003:
-<code>
-BootCurrent: 0001
-Timeout: 1 seconds
-BootOrder: 0003,0000,0001,0002
-Boot0000* debian
-Boot0001* UEFI: SanDisk
-Boot0002* UEFI: SanDisk, Partition 1
-Boot0003* Meu Linux sabor banana
-</code>
-===Manutenção do EFI stub===
-O procedimento acima coloca uma cópia do kernel atual na partição EFI e adiciona a entrada adequada para iniciar esse kernel. Quando o kernel é atualizado, essa cópia também precisa ser atualizada para iniciar o kernel novo. Existem vários várias formas de automatizar o processo ((A wiki do arch tem alguns exemplos: https://wiki.archlinux.org/index.php/EFISTUB)). Aqui utilizaremos o método da wiki do Debian((https://wiki.debian.org/EFIStub)), que consiste basicamente de criar um script no /etc/kernel/postinst.d que realiza o procedimento:
-  touch /etc/kernel/postinst.d/zz-update-efistub
-  chmod +x /etc/kernel/postinst.d/zz-update-efistub
-No exemplo, o nome do arquivo começa com zz para que seja executado após os outros scripts (a ordem de execução dos scripts da pasta é alfabética). O conteúdo do arquivo (assumindo que o kernel e o initrd estão em /boot/efi/EFI/debian, sendo /boot/efi o ponto de montagem da partição EFI) é:
-  #!/bin/sh
-  cp /vmlinuz /initrd.img /boot/efi/EFI/debian/
-Podemos extender o script para criar uma cópia do kernel atual por garantia:
-<code>
-#!/bin/sh
-cp /boot/efi/EFI/debian/vmlinuz /boot/efi/EFI/debian/vmlinuz.old
-cp /boot/efi/EFI/debian/initrd.img /boot/efi/EFI/debian/initrd.img.old
-cp /vmlinuz /initrd.img /boot/efi/EFI/debian
-</code>
-Também podemos criar uma entrada para essa versão anterior do kernel, similar ao exemplo anterior:
-  export UUID=$(blkid -s UUID -o value /dev/sda1)
-  efibootmgr -c -d /dev/sda -p 2 -L "Debian (EFI stub) - previous kernel" -l '\EFI\debian\vmlinuz.old' -u "root=UUID=$UUID ro initrd=\EFI\debian\initrd.img.old"
-====Links Relevantes====
-  *[[http://www.rodsbooks.com/efi-bootloaders/]]
-  *[[https://www.happyassassin.net/2014/01/25/uefi-boot-how-does-that-actually-work-then/]]
-  *[[http://www.uefi.org/specs/download]]
-  *[[https://wiki.debian.org/EFIStub]]
-  *[[https://wiki.archlinux.org/index.php/EFISTUB]]