Jump to content

# systemd-boot (Português)

6 languages

- Deutsch
- English
- Español
- 日本語
- Русский
- 中文（简体）

From ArchWiki

Status de tradução: Esse artigo é uma tradução de Systemd-boot. Data da última tradução: 2022-11-15. 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 do 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).

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

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

    # bootctl install

on a x64 architecture system `/usr/lib/systemd/boot/efi/systemd-bootx64.efi` will be copied to `esp/EFI/systemd/systemd-bootx64.efi` and `esp/EFI/BOOT/BOOTX64.EFI`, and systemd-boot will be set as the default EFI application.

Isto vai copiar o gerenciador de boot systemd-boot para a ESP: em um sistema com arquitetura x64 `/usr/lib/systemd/boot/efi/systemd-bootx64.efi` será copiado para `esp/EFI/systemd/systemd-bootx64.efi` and `esp/EFI/BOOT/BOOTX64.EFI`, e systemd-boot será definido como a aplicação EFI padrão.

Nota:

- Ao executar `bootctl install`, systemd-boot tentará localizar a ESP em `/efi`, `/boot` e `/ boot/efi`. Definir `esp` para um local diferente requer passar a opção `--esp-path=esp`. (Veja bootctl(1) § OPTIONS para detalhes.)
- Instalar systemd-boot sobrescreverá qualquer arquivo existente em `esp/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" (XBOOTLDR) pode ser criada para manter o kernel e initramfs separados da ESP. Isso é particularmente útil para fazer dual boot com Windows com uma ESP existente que é muito pequena.

Prepare uma ESP como de costume e crie outra partição para XBOOTLDR na mesma unidade física. A partição XBOOTLDR deve ter um GUID de tipo de partição de `bc13c2ff-59e6-4262-a352-b275fd6f7172` [1]. O tamanho da partição XBOOTLDR deve ser grande o suficiente 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 qualquer sistema de arquivos que sua implementação UEFI possa ler.
- 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; neste caso, desabilite o modo "fast boot";
- A partição XBOOTLDR deve estar no mesmo disco físico que a ESP para que o systemd-boot seja reconhecido.

Durante a instalação, monte a ESP em `/mnt/efi` e a partição XBOOTLDR em `/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 EFI pode ser opcionalmente reinstalado pelo usuário. Isto pode ser feito manualmente ou automaticamente. As duas abordagens são descritas a seguir.

Nota: O gerenciador de boot EFI é 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 atualizar o systemd-boot de qualquer maneira.

#### Atualização manual

Use bootctl para atualizar o systemd-boot:

    # bootctl update

Nota: Como com `bootctl install`, systemd-boot tentará localizar a ESP em `/efi`, `/boot` e `/boot/efi`. Definir `esp` para um local diferente requer passar a opção `--esp-path=esp`.

#### Atualização automática

Para atualizar o systemd-boot automaticamente, use um serviço do systemd ou um hook do pacman. Os dois métodos são descritos abaixo.

##### Serviço do systemd

A partir da versão 250, systemd vem com `systemd-boot-update.service`. Habilitar este serviço atualizará o bootloader na próxima inicialização.

Atenção: Se você tiver Secure Boot ativado, você precisa assinar seu bootloader após a atualização. Veja #hook do pacman abaixo para um exemplo de como fazer isso.

##### hook do pacman

O pacote systemd-boot-pacman-hookAUR adiciona um hook do pacman que é executado toda vez que o systemd é atualizado.

Em vez de instalar systemd-boot-pacman-hook, você pode preferir colocar manualmente o seguinte arquivo em `/etc/pacman.d/hooks/`:

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

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

    [Action]
    Description = Gracefully upgrading systemd-boot...
    When = PostTransaction
    Exec = /usr/bin/systemctl restart systemd-boot-update.service

Se você tem Secure Boot habilitado, você pode querer adicionar um hook do pacman para automaticamente reassinar o kernel e o bootloader a cada atualização dos respectivos pacotes:

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

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

    [Action]
    Description = Assinar o Kernel para Secure Boot
    When = PostTransaction
    Exec = /usr/bin/find /boot -type f ( -name vmlinuz-* -o -name systemd* ) -exec /usr/bin/sh -c 'if ! /usr/bin/sbverify --list {} 2>/dev/null | /usr/bin/grep -q "signature certificates"; then /usr/bin/sbsign --key arquivo-de-chave --cert arquivo-de-certificado --output "$1" "$1"; fi' _ {} ;
    Depends = sbsigntools
    Depends = findutils
    Depends = grep

Certifique-se de que os parâmetros `--key arquivo-de-chave --cert arquivo-de-certificado` apontam para sua chave de assinatura e certificado. Para melhor compreensão deste hook, consulte sbverify(1) e sbsign(1).

## Configuração

### Configuração do carregador

A configuração do carregador é armazenada no arquivo `esp/loader/loader.conf`. Veja loader.conf(5) § OPTIONS para detalhes.

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 tabulações como indentação, use espaços.
- `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 ""` e `bootctl set-timeout ""` pode ser usado para limpar as variáveis EFI sobrescrevendo as opções `default` e `timeout`, respectivamente.
- 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. Observe que as entradas em `esp` só podem usar arquivos (por exemplo, kernels, initramfs, imagens, etc.) dentro de `esp`. Da mesma forma, entradas em `boot` só podem usar arquivos em `boot`.

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 separadas por vírgula para 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` ou `initrd` seguido por um caminho relativo dos arquivos correspondentes na ESP (p. ex., `/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 Imagem de kernel unificada#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.

Um exemplo de arquivos de carregador iniciando o Arch a partir de um volume rotulado `arch_os` e carregando o microcódigo 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

    esp/loader/entries/arch-fallback.conf

    title   Arch Linux (fallback initramfs)
    linux   /vmlinuz-linux
    initrd  /intel-ucode.img
    initrd  /initramfs-linux-fallback.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 do UEFI `/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.

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

No caso você ter instalado shells EFI com o pacote edk2-shell, systemd-boot vai detectar automaticamente e cirar uma nova entrada se o arquivo EFI for colocado em `esp/shellx64.efi`. Para fazer isso e para exemplo de comando após instalar o pacote seria:

    # cp /usr/share/edk2-shell/x64/Shell.efi /boot/shellx64.efi

Por outro lado, caso você tenha instalado outros aplicativos EFI na ESP, você pode usar os seguintes trechos.

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.

    esp/loader/entries/fwupd.conf

    title  Firmware updator
    efi     /EFI/tools/fwupdx64.efi

    esp/loader/entries/gdisk.conf

    title  GPT fdisk (gdisk)
    efi     /EFI/tools/gdisk_x64.efi

#### Inicializar a partir de outro disco

systemd-boot não pode iniciar binários de partições que não sejam a partição ESP ou XBOOTLDR, mas pode executar um script externo para fazê-lo.

Primeiro precisamos instalar o edk2-shell (será o interpretador a ser usado) e usando o shell EFI (como explicado acima) podemos usar o comando map para anotar o FS alias (ex: HD0a66666a2) e o caminho completo do arquivo EFI de destino (ex: EFI\Microsoft\Boot\Bootmgfw.efi).

Em seguida, usando o comando exit, podemos inicializar novamente no Linux, onde podemos criar a nova entrada. Para isso precisamos primeiro criar na raiz do ponto de montagem esp um nome de arquivo .nsh com o alias FS, dois pontos e o caminho EFI, aqui um exemplo:

    esp/windows.nsh

    HD0a66666a2:EFI\Microsoft\Boot\Bootmgfw.efi

Uma vez que criamos este arquivo, podemos continuar criando a entrada do carregador para executar o script:

    esp/loader/entries/windows.conf

    title  Windows
    efi     /shellx64.efi
    options -nointerrupt -noconsolein -noconsoleout windows.nsh

É importante que o caminho efi corresponda onde o edk2-shell foi copiado na partição esp, e o último argumento das opções corresponda ao nome do arquivo .nsh na raiz da partição esp. Observe também que o arquivo EFI edk2-shell pode ser movido para evitar a criação automática de entrada de systemd-boot.

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

systemd-boot adicionará automaticamente uma entrada para inicializar na configuração do firmware UEFI se o firmware do seu dispositivo suportar a reinicialização na configuração do sistema operacional.

### Suporte a hibernação

Veja Suspensão e hibernação.

### 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.

## Dicas e truques

### Teclas dentro do menu de inicialização

Veja systemd-boot(7) § KEY BINDINGS para as associações de teclas disponíveis dentro do menu de inicialização.

### 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

### Imagens de kernel unificadas

Imagens de kernel unificadas em `esp/EFI/Linux/` são originadas automaticamente pelo systemd-boot e não precisam de uma entrada em `esp/loader/entries`. (Observe que as imagens de kernel unificadas devem ter uma extensão `.efi` para serem identificadas por systemd-boot.)

Dica: Arquivos em `esp/loader/entries` serão inicializados primeiro se nenhum `default` estiver definido em `esp/loader/loader.conf`. Remova essas entradas ou defina o padrão com o nome completo do arquivo, ou seja, `default archlinux-linux.efi`

### Grml na ESP

Nota: As seguintes instruções não são exclusivas para Grml. Com leves ajustes, instalar outro software (p. ex., SystemRescueCD) é possível.
Dica: Um `PKGBUILD` está disponível: grml-systemd-bootAUR.

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

Nota: 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`.

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" --unicode

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 defini-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://systemd.io/BOOT/
- https://github.com/systemd/systemd/tree/master/src/boot/efi
- https://bbs.archlinux.org/viewtopic.php?id=254374
- https://uapi-group.org/specifications/specs/boot_loader_specification/

Category:

- Boot loaders (Português)