systemd-boot (Português) - ArchWiki

Jump to content

# systemd-boot (Português)

From ArchWiki

Status de tradução: Esse artigo é uma tradução de Systemd-boot. Data da última tradução: 2021-02-17. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

- Processo de inicialização do Arch
- Secure Boot
- Unified Extensible Firmware Interface

systemd-boot, antigamente chamado de gummiboot (Alemão para: 'bote de borracha'), é um simples gerenciador de boot UEFI que executa imagens EFI configuradas. A entrada padrão é selecionada por um padrão (glob) definido ou um menu navegável na tela por meio das setas. Vêm com o systemd, que é instalado em um sistema Arch por padrão.

É simples de configurar mas pode somente iniciar executáveis EFI como o EFISTUB do kernel Linux, shell UEFI, GRUB ou o gerenciador de boot do Windows.

## Instalação

### Instalando o gerenciador de boot EFI

Para instalar o gerenciador de boot EFI systemd-boot, primeiro tenha certeza que o sistema inicializou no modo UEFI e que as variáveis UEFI são acessíveis. Isto pode ser verificado ao executar o comando `efivar --list` ou, se efivar não está instalado, ao executar `ls /sys/firmware/efi/efivars` (se o diretório existe, o sistema foi inicializado no modo UEFI).

`esp` será usada nesta página para indicar o ponto de montagem ESP, ex. `/boot`, `/boot/efi`, ou `/efi`. Isto assume que você executou `chroot` no ponto de montagem do seu sistema.

Com a ESP montada em `esp`, use bootctl para instalar systemd-boot na partição de sistema EFI ao executar:

    # bootctl install

Isto vai copiar o gerenciador de boot systemd-boot para a partição EFI: em um sistema com arquitetura x64 os dois binários idênticos `esp/EFI/systemd/systemd-bootx64.efi` e `esp/EFI/BOOT/BOOTX64.EFI` vão ser transferidos para a ESP. Isto vai definir systemd-boot como a aplicação EFI (entrada de boot padrão) carregada pelo gerenciador de boot EFI.

Nota: Instalar systemd-boot sobrescreverá qualquer arquivo existente em `/EFI/BOOT/BOOTX64.EFI`, por exemplo, a versão da Microsoft deste arquivo.

Para concluir a instalação, configure o systemd-boot.

### Instalação usando XBOOTLDR

Uma partição `boot` separada do tipo `"Linux extended boot"` pode ser criada para manter o kernel e initramfs separados da partição `esp`. XBOOTLDR [1] deve ter o tipo de partição GUID `"bc13c2ff-59e6-4262-a352-b275fd6f7172"`.

Isto é particularmente útil para dual boot com Windows com uma partição de sistema EFI que é muito pequena. Caso contrário, crie uma partição `esp` normal e depois crie outra partição para `boot` no mesmo dispositivo de armazenamento físico. O tamanho do `boot` deve ser o bastante para acomodar todos os kernels que você vai instalar.

Nota:

- systemd-boot não faz verificação de tipo do sistema de arquivos para a ESP. Então, é possível usar outros sistemas de arquivos mas somente se sua implementação UEFI pode ler durante a inicialização.
- Um firmware UEFI pode pular o carregamento de outras partições que não são a ESP quando o modo "fast boot" está habilitado. Isto pode levar ao "systemd-boot" falhando em encontrar entradas na partição XBOOTLDR. Você pode querer desabilitar o "fast boot" para o XBOOTLDR funcionar.

Durante a instalação monte a `esp` para `/mnt/efi` e `boot` para `/mnt/boot`.

Uma vez no ambiente chroot use o comando:

    # bootctl --esp-path=/efi --boot-path=/boot install

Para concluir a instalação, configure o systemd-boot.

### Atualizando o gerenciador de boot EFI

Toda vez que tiver uma nova versão do systemd-boot, o gerenciador de boot pode ser opcionalmente reinstalado pelo usuário. Isto pode ser feito manualmente ou automaticamente por meio de hooks do pacman. As duas abordagens são descritas a seguir.

Nota: O gerenciador de boot é um executável EFI e qualquer versão pode ser usada para inicializar o sistema (atualizações parciais não são válidas, considerando que pacman somente instala o instalador do systemd-boot, não o systemd-boot). No entanto, novas versões podem adicionar novas funcionalidades ou consertar bugs, então é provavelmente uma boa ideia atualizá-lo de qualquer maneira.

#### Atualização manual

bootctl deve ser usado ao atualizar o systemd-boot.

    # bootctl update

Se a ESP está montada em uma diferente localização, consulte o manual para as opções `--esp-path=` e `--boot-path=`.

Nota: Este comando com estas opções também é usado quando migrar do gummiboot, antes de remover o pacote. Se este pacote já foi removido, então execute `bootctl --esp-path=esp install`.

#### Atualização automática

O pacote systemd-boot-pacman-hookAUR oferece um hook do pacman para automatizar o processo de atualização. Instalar o pacote adicionará um pacote hook que será executado toda vez que o pacote systemd é atualizado. Alternativamente, para replicar o que o pacote systemd-boot-pacman-hook faz sem instalá-lo, adicione o seguinte hook do pacman no diretório `/etc/pacman.d/hooks/`:

    /etc/pacman.d/hooks/100-systemd-boot.hook

    [Trigger]
    Type = Package
    Operation = Upgrade
    Target = systemd

    [Action]
    Description = Updating systemd-boot
    When = PostTransaction
    Exec = /usr/bin/bootctl update

Se você tem Secure Boot habilitado, você pode querer instalar um hook do pacman para automaticamente reassinar o kernel e o systemd-boot quando este for atualizado.

    /etc/pacman.d/hooks/99-secureboot.hook

    [Trigger]
    Operation = Install
    Operation = Upgrade
    Type = Package
    Target = linux
    Target = systemd

    [Action]
    Description = Assinar o Kernel para SecureBoot
    When = PostTransaction
    Exec = /usr/bin/sh -c "/usr/bin/find /boot/ -type f \( -name 'vmlinuz-*' -o -name 'systemd*' \) -exec /usr/bin/sh -c 'if ! /usr/bin/sbverify --list {} 2>/dev/null

O `Target` precisa ser duplicado cada vez que você deseja acrescentar um novo pacote. Com relação à instrução do `find`, como havia uma condição com os nomes de arquivos do hooks do ALPM serem separados por espaços, foi necessário inserir a instrução toda com aspas para que fosse interpretada corretamente. Como o systemd-boot é localizado em subdiretórios, a profundidade precisou ser ajustada também para que fosse removido o argumento `-maxdepth`. Para evitar incômodo, se você não tiver certeza, tente reinstalar o pacote que deseja testar para testar se o hook e o processo de assinatura são executados corretamente. Veja. Veja Pacman (Português)#Hooks ou alpm-hooks(5) para mais informações.

## Configuração

### Configuração do carregador

A configuração do carregador é armazenada no arquivo `esp/loader/loader.conf`. As configurações a seguir podem ser especificada:

- `default` – entrada padrão para selecionar como definido em #Adicionando carregadores; isto pode ser uma expressão como `arch-*.conf`.
- `timeout` – tempo limite do menu em segundos antes que a entrada padrão seja inicializada. Se isto não é definido, o menu somente será mostrado com a tecla `espaço` (a maioria das teclas funciona também) pressionada durante a inicialização.
- `editor` – para habilitar o editor de parâmetros do kernel ou não. `yes` (padrão) é habilitado, `no` é desabilitado; considerando que o usuário pode adicionar `init=/bin/bash` para evitar a senha e ganhar acesso root, é fortemente recomendado definir esta opção para `no` se a máquina pode ser acessada por pessoas não autorizadas.
- `auto-entries` – mostra automaticamente entradas para Windows, shell EFI, e carregador padrão se definido para `1` (padrão), `0` para esconder;
- `auto-firmware` – mostra a entrada para reinicializar nas configurações UEFI de firmware se definido para `1` (padrão), `0` para esconder;
- `console-mode` – muda o modo do console UEFI:
  - `0` para 80x25;
  - `1` para 80x50;
  - `2` e acima para modos não padrão oferecidos pelo firmware do dispositivo, se qualquer;
  - `auto` pega um modo apropriado automaticamente;
  - `max` para o maior modo disponível;
  - `keep` (padrão) para o modo selecionado pelo firmware.
- `random-seed-mode` - controla se vai ler a semente randômica do arquivo `esp/loader/random-seed`. Se definido para `with-system-token` (padrão), carrega a semente do arquivo somente se a variável `LoaderSystemToken` é definida; se definido para `always`, carrega a semente do arquivo até mesmo se a variável EFI não está definida; e se definida para `off`, o arquivo é ignorado.

Para uma explicação detalhada das configurações disponíveis e seus respectivos argumentos veja o manual loader.conf(5). Um exemplo de configuração do carregador é mostrado abaixo:

    esp/loader/loader.conf

    default  arch.conf
    timeout  4
    console-mode max
    editor   no

Dica:

- systemd-boot não aceita `tabs` como indentação, use espaçamentos.
- `default` e `timeout` podem ser mudados no menu de inicialização e as mudanças vão ser salvas como variáveis EFI `LoaderEntryDefault` e `LoaderConfigTimeout`, sobrescrevendo estas opções.
- `bootctl set-default ""` pode ser usado para limpar a variável EFI sobrescrevendo a opção `default`.
- Um arquivo de configuração básico está localizado em `/usr/share/systemd/bootctl/loader.conf`.

### Adicionando carregadores

systemd-boot buscará pelos itens do menu de inicialização em `esp/loader/entries/*.conf` e adicionalmente em `boot/loader/entries/*.conf` se usar XBOOTLDR. As opções possíveis são:

- `title` – nome do sistema operacional. necessário.
- `version` – versão do kernel, mostrado somente quando múltiplas entradas com o mesmo título existe. Opcional.
- `machine-id` – identificador da máquina em `/etc/machine-id`, mostrado somente quando múltiplas entradas com o mesmo título e versão existem. Opcional.
- `efi` – aplicação EFI a iniciar, relativo ao seu ESP (`esp`); ex. `/vmlinuz-linux`. Este parâmetro ou `linux` (veja abaixo) é necessário.
- `options` – opções da linha de comando à passar para o programa EFI ou parâmetros do kernel. Opcional, mas você precisará no mínimo `root=dev` se inicializar o Linux. Este parâmetro pode ser omitido se a partição raiz é atribuída ao tipo Root Partition GUID correto como definido na Discoverable Partitions Specification e se o hook do mkinitcpio do `systemd` está presente.

Para inicializar o Linux, você pode também usar `linux` ao invês de `efi`. Ou `initrd` em adição a `options`. A sintaxe é:

- `linux` e `initrd` seguido por um caminho relativo dos arquivos correspondentes na ESP; e.x. `/vmlinuz-linux`; isto vai ser automaticamente traduzido em `efi caminho` e `options initrd=caminho` – esta sintaxe é somente suportada por conveniência e não há diferenças em função.

Nota: Se `options` está presente na entrada de boot e Secure Boot está desabilitado, o valor de `options` vai sobrescrever qualquer linha `.cmdline` inserida na imagem EFI que está especificada pelo `efi` ou `linux` (veja #Preparando uma imagem de kernel unificada). Com Secure Boot, no entanto, `options` (e quaisquer modificações feitas a linha de comando do kernel na interface do gerenciador de boot) serão ignoradas, e somente as `.cmdline` serão usadas.

This article or section needs expansion.

Reason: Provide an example entry with fallback initramfs. It may not be immediately obvious that you need to create a separate entry file for it, an example would make it clear. (Discuss in Talk:Systemd-boot (Português))

Um exemplo de um arquivo de configuração para inicializar o Arch de uma partição com rótulo arch_os e carregando o microcode da CPU da Intel é:

    esp/loader/entries/arch.conf

    title   Arch Linux
    linux   /vmlinuz-linux
    initrd  /intel-ucode.img
    initrd  /initramfs-linux.img
    options root="LABEL=arch_os" rw

systemd-boot vai automaticamente verificar no tempo de inicialização pelo Gerenciador de Boot do Windows na localização `/EFI/Microsoft/Boot/Bootmgfw.efi`, Shell EFI `/shellx64.efi` e EFI Default Loader (carregador padrão EFI) `/EFI/BOOT/bootx64.efi`, como também arquivos do kernel especialmente preparados em `/EFI/Linux`. Quando detectado, as entradas correspondentes com títulos `auto-windows`, `auto-efi-shell` e `auto-efi-default`, respectivamente, serão geradas. Estas entradas não precisam de configuração manual. No entanto, outras aplicações EFI não são detectadas automaticamente (diferente do rEFInd), então para inicializar o kernel Linux, entradas de boot devem ser criadas manualmente.

Nota:

- Se você tem dual-boot com Windows, é fortemente recomendado desabilitar sua opção padrão inicialização rápida.
- Se você tem uma CPU Intel ou AMD, carregue o microcode com `initrd` antes de outras imagens, um exemplo é fornecido em Microcode#systemd-boot.
- A partição raiz pode ser indentificada com sua `LABEL` (rótulo), `PARTUUID` ou `UUID` (veja Nomeação persistente de dispositivo de bloco). Isto é necessário somente para identificar a partição raiz, não a `esp`.

Dica:

- As entradas de boot disponíveis que foram configuradas podem ser listadas com o comando `bootctl list`.
- Um exemplo de arquivo de entrada está localizado em `/usr/share/systemd/bootctl/arch.conf`.
- Os parâmetros do kernel para cenários como LVM, LUKS ou dm-crypt pode ser encontrado nas páginas relevantes.

#### Shells EFI ou outras aplicações EFI

This article or section needs expansion.

Reason: If the UEFI shell is placed as `/shellx64.efi` in the ESP, it will be autodetected. Using multiple UEFI shell versions is uncommon, so provide a better example with some other EFI application. (Discuss in Talk:Systemd-boot (Português))

Caso você tenha instalado shells EFI e outras aplicações EFI na ESP, você pode usar os seguintes exemplos.

Nota: O parâmetro do caminho do arquivo para a linha `efi` é relativo ao ponto de montagem da sua esp. Se você montou em `/boot` e seus binários EFI estão em `/boot/EFI/xx.efi` e `/boot/yy.efi`, então você deve especificar os parâmetros como `efi /EFI/xx.efi` e `efi /yy.efi` respectivamente.

Exemplos de carregadores de Shells UEFI:

    esp/loader/entries/uefi-shell-v1-x86_64.conf

    title   UEFI Shell x86_64 v1
    efi     /EFI/shellx64_v1.efi

    esp/loader/entries/uefi-shell-v2-x86_64.conf

    title   UEFI Shell x86_64 v2
    efi     /EFI/shellx64_v2.efi

### Inicializando para a configuração de Firmware EFI

A maioria dos firmware configurados para EFI vão adicionar suas próprias entradas efibootmgr para inicializar o firmware de configuração UEFI.

### Supporte a hibernação

Veja Suspend and hibernate.

### Editor de parâmetros do kernel protegido por senha

Alternativamente você pode instalar systemd-boot-passwordAUR que suporta configuração básica da opção `password`. Use `sbpctl generate` para gerar um valor para esta opção.

Instale systemd-boot-password com o seguinte comando:

    # sbpctl install esp

Com o editor habilitado, vai ser solicitado sua senha antes que você possa editar os parâmetros do kernel.

## Teclas dentro do menu de boot

As seguintes teclas são usadas dentro do menu:

- `Up/Down` - seleciona a entrada
- `Enter` - inicializa a entrada selecionada
- `d` - define a entrada padrão a ser inicializada (salvo em uma váriavel EFI não volátil)
- `-/T` - diminue o timeout (salvo em uma váriavel EFI não volátil)
- `+/t` - aumenta o timeout (salvo em uma váriavel EFI não volátil)
- `e` - edita a linha de comando do kernel. Não tem efeito se a opção de configuração `editor` é definida para `0`.
- `v` - mostra a versão atual do systemd-boot e UEFI
- `Q` - sai do menu
- `P` - mostra a configuração atual
- `h/?` - ajuda

Estes atalhos vão, quando pressionado dentro do menu ou antes dele, diretamente inicializar uma entrada específica:

- `l` - Linux
- `w` - Windows
- `a` - OS X
- `s` - Shell EFI
- `1-9` - número da entrada

## Dicas e truques

### Escolhendo a próxima inicialização

O gerenciador de boot é integrado com o comando systemctl, permitindo escolher que opção você quer inicializar depois de reiniciar. Por exemplo, suponha que você tenha compilado um kernel customizado e criou um arquivo de entrada `esp/loader/entries/arch-custom.conf` para inicializar ele, você pode executar

    $ systemctl reboot --boot-loader-entry=arch-custom.conf

e seu sistema irá reiniciar nesta entrada mantendo a opção padrão intacta para inicializações subsequentes. Para ver uma lista de entradas possíveis use a opção `--boot-loader-entry=help`.

Se você quer inicializar no firmware da sua placa-mãe diretamente, você pode usar esse comando:

    $ systemctl reboot --firmware-setup

### Preparando uma imagem de kernel unificada

systemd-boot busca em `esp/EFI/Linux/` por imagens unificadas de kernel, que junta o kernel, o disco RAM inicial (initrd), a linha de comando do kernel, `/etc/os-release`, e uma imagem splash em um único arquivo. Este arquivo pode ser facilmente assinado para Secure Boot.

Coloque a linha de comando do kernel que você quer em um arquivo, e crie o arquivo unificado dessa forma:

    $ objcopy \
        --add-section .osrel="/usr/lib/os-release" --change-section-vma .osrel=0x20000 \
        --add-section .cmdline="linha-de-comando-do-kernel.txt" --change-section-vma .cmdline=0x30000 \
        --add-section .splash="/usr/share/systemd/bootctl/splash-arch.bmp" --change-section-vma .splash=0x40000 \
        --add-section .linux="arquivo-vmlinuz" --change-section-vma .linux=0x2000000 \
        --add-section .initrd="arquivo-initrd" --change-section-vma .initrd=0x3000000 \
        "/usr/lib/systemd/boot/efi/linuxx64.efi.stub" "linux.efi"

Opcionalmente assine o arquivo `linux.efi` produzido acima.

Copie `linux.efi` para `esp/EFI/Linux/`.

### Grml na ESP

Nota: As seguintes instruções não são exclusivas para Grml. Com leves ajustes, instalar outro software (e.x. SystemRescueCD) é possível.

Grml é um pequeno sistema live com uma coleção de software para administração e recuperação do sistema.

Para instalar Grml na ESP, precisamos somente copiar o kernel `vmlinuz`, o initramfs `initrd.img`, e a squashed image (Imagem compactada com sistema de arquivos somente leitura) `grml64-small.squashfs` do arquivo iso para a ESP. Para fazer isso, primeiro baixe a grml64-small.iso e monte o arquivo (o ponto de montagem desse exemplo é mnt); o kernel e initramfs estão localizados em `mnt/boot/grml64small/`, e a squashed image reside em `mnt/live/grml64-small/`.

Depois, crie um diretório para Grml na sua ESP,

    # mkdir -p esp/grml

e copie os arquivos mencionados acima para lá:

    # cp mnt/boot/grml64small/vmlinuz esp/grml
    # cp mnt/boot/grml64small/initrd.img esp/grml
    # cp mnt/live/grml64-small/grml64-small.squashfs esp/grml

no último passo, crie uma entrada para o carregador do systemd-boot: em `esp/loader/entries` crie um arquivo `grml.conf` com o seguinte conteúdo:

    esp/loader/entries/grml.conf

    title   Grml Live Linux
    linux   /grml/vmlinuz
    initrd  /grml/initrd.img
    options apm=power-off boot=live live-media-path=/grml/ nomce net.ifnames=0

Para uma visão geral das opções de boot disponíveis, consulte cheatcode for Grml.

### systemd-boot em sistemas BIOS

Se você precisa de um gerenciador de boot para sistemas BIOS que segue a Boot Loader Specification, o systemd-boot pode funcionar. O gerenciador de boot Clover suporta inicializar de sistemas BIOS e oferece um ambiente EFI simulado.

## Resolução de problemas

### Instalando depois de inicializar no modo BIOS

Atenção: Isto não é recomendado.

Se inicializou no modo BIOS, você ainda pode instalar o systemd-boot, no entanto este processo precisa que você fale ao firmware para lançar o arquivo EFI do systemd-boot na inicialização, normalmente por meio de duas maneiras:

- você tem um Shell EFI funcionando em algum outro lugar.
- sua interface de firmware oferece uma maneira de apropriadamente definir o arquivo EFI que precisa ser carregado na inicialização.

Se você pode fazer isto, a instalação é mais fácil: vai para seu Shell EFI ou a interface de configuração do firmware e mude o arquivo EFI padrão da sua máquina para `esp/EFI/systemd/systemd-bootx64.efi` (ou `systemd-bootia32.efi` se seu sistema de firmware é 32 bits).

Nota: A interface do firmware das máquinas Dell da linha Latitude oferece tudo que você precisa para configurar a inicialização EFI mas o Shell EFI não poderá escrever para a ROM do computador.

### Entrada manual usando efibootmgr

Se o comando `bootctl install` falhou, você pode criar uma entrada de boot EFI manualmente usando efibootmgr:

    # efibootmgr --create --disk /dev/sdX --part Y --loader "\EFI\systemd\systemd-bootx64.efi" --label "Gerenciador de Boot do Linux" --verbose

Onde `/dev/sdXY` é a partição de sistema EFI.

Nota: O caminho para a imagem EFI deve usar a barra invertida (`\`) como o separador

### Entrada manual usando bcdedit do Windows

Se por alguma razão você precisa criar uma entrada de boot EFI pelo Windows, você pode usar os seguintes comandos em um prompt de administrador:

    # bcdedit /copy {bootmgr} /d "Gerenciador de Boot do Linux"
    # bcdedit /set {guid} path \EFI\systemd\systemd-bootx64.efi

Mude `{guid}` para o id retornado pelo primeiro comando. Você pode também definí-lo como a entrada padrão usando

    # bcdedit /default {guid}

### Menu não aparece depois de atualização do Windows

Veja UEFI#Windows changes boot order.

## Veja também

- https://www.freedesktop.org/wiki/Software/systemd/systemd-boot/
- https://github.com/systemd/systemd/tree/master/src/boot/efi
- https://bbs.archlinux.org/viewtopic.php?id=254374
- https://systemd.io/BOOT_LOADER_SPECIFICATION/

Category:

- Boot loaders (Português)

Hidden category:

- Pages or sections flagged with Template:Expansion