mkinitcpio (Português) - ArchWiki

Jump to content

# mkinitcpio (Português)

6 languages

- Deutsch
- English
- Français
- 日本語
- Русский
- 中文（简体）

From ArchWiki

Status de tradução: Esse artigo é uma tradução de Mkinitcpio. Data da última tradução: 2020-05-23. Você pode ajudar a sincronizar a tradução, se houver alterações na versão em inglês.

Artigos relacionados

- Booster
- Depuração de inicialização
- dracut (Português)
- Módulos de kernel
- Minimal initramfs
- systemd (Português)

mkinitcpio é um script bash usado para criar um ambiente disco RAM inicial (initial ramdisk, initrd). Da página man do mkinitcpio(8) (traduzido):

  o disco RAM inicial é em essência um ambiente muito pequeno (early userspace) que carrega vários módulos do kernel e configura coisas necessárias antes de passar o controle para `init`. Isto faz possível ter, por exemplo, sistemas de arquivos raiz criptografados e no arranjo RAID de software. mkinitcpio permite uma extensão simples com hooks customizados, têm autodetecção na execução, e muitas outras funcionalidades.

Tradicionalmente, o kernel era responsável por toda detecção de hardware e inicialização de tarefas iniciais no processo de inicialização antes de montar o sistema de arquivos raiz e passar o controle para `init`. No entanto, com avanços da tecnologia, estas tarefas se tornaram cada vez mais complexas.

Atualmente, o sistema de arquivos raiz pode estar em uma ampla gama de hardware, como por exemplo: SCSI, SATA e dispositivos USB, controlados por uma variedade de controladores de drivers de diferentes fabricantes. Adicionalmente, o sistema de arquivos raiz pode estar criptografado ou compresso; dentro de um arranjo RAID de software ou um grupo de volumes lógico. A maneira simples de lidar com essa complexidade é passar o gerenciamento para o userspace: um disco RAM inicial. Veja também: /dev/brain0 » Blog Archive » Early Userspace in Arch Linux.

mkinitcpio foi desenvolvido pelos desenvolvedores do Arch Linux e de contribuições da comunidade. Veja o repositório Git público.

## Instalação

Instale o pacote mkinitcpio, que é uma dependência do pacote linux, então a maioria dos usuários têm ele instalado.

Usuários avançados podem querer instalar a versão de desenvolvimento mais recente do mkinitcpio do Git com o pacote mkinitcpio-gitAUR.

## Criação e ativação de imagem

### Geração automatizada

Toda vez que um kernel é instalado ou atualizado, um pacman hook gera automaticamente um arquivo de .preset salvo em `/etc/mkinitcpio.d/`. Por exemplo, `linux.preset` para o pacote estável oficial linux. Um preset é simplesmente uma lista de informações necessárias para criar imagens de ramdisk iniciais, em vez de especificar manualmente os vários parâmetros e a localização dos arquivos de saída. Por padrão, contém as instruções para criar duas imagens:

1. a imagem padrão do ramdisk criada seguindo as diretivas especificadas na configuração do mkinitcpio e
2. a imagem fallback do ramdisk, igual à anterior exceto que pula o hook autodetect durante a criação, incluindo assim uma gama completa de módulos que suportam a maioria dos sistemas.

Depois de criar o preset, o hook do pacman chama o script mkinitcpio que gera as duas imagens, usando as informações fornecidas no preset.

Nota: Os arquivos .preset são usados para gerar automaticamente o initramfs após uma atualização do kernel; tenha cuidado ao editá-los.

### Geração manual

Para executar manualmente o script, consulte a página de manual mkinitcpio(8) para instruções. Em particular, para (re)gerar o preset fornecido por um pacote de kernel, use a opção `-p`/`--preset` seguido pelo preset a ser utilizado. Por exemplo, para o pacote linux, use o comando:

    # mkinitcpio -p linux

Para (re)gerar todos os presets existentes, use a opção `-P`/`--allpresets`. Isso é normalmente usado para regenerar todas as imagens initramfs após uma alteração da configuração global:

    # mkinitcpio -P

Os usuários podem criar qualquer número de imagens initramfs com uma variedade de configurações diferentes. A imagem desejada deve ser especificada no respectivo arquivo de configuração do gerenciador de boot.

### Geração customizada

Usuários podem gerar uma imagem usando um arquivo de configuração alternativo. Por exemplo, o seguinte vai gerar uma imagem ramdisk inicial de acordo com as direções em `/etc/mkinitcpio-custom.conf` e salvar isso como `/boot/initramfs-custom.img`.

     # mkinitcpio --config /etc/mkinitcpio-custom.conf --generate /boot/initramfs-custom.img

Se estiver gerando uma imagem para um kernel diferente daquele em execução no momento, adicione a versão de lançamento do kernel à linha de comando. As versões de kernel instaladas podem ser encontrada em `/usr/lib/modules/`, a sintaxe é consistente com a saída do comando `uname -r` para cada kernel.

     # mkinitcpio --generate /boot/initramfs-custom2.img --kernel 5.7.12-arch1-1

### Imagens de kernel unificadas

A partir da versão 31, o mkinitcpio também pode criar imagens de kernel unificadas.

## Configuração

O arquivo de configuração primário do mkinitcpio é o `/etc/mkinitcpio.conf`. Adicionalmente, definições de preset são providos pelos pacotes de kernel no diretório `/etc/mkinitcpio.d` (e.x. `/etc/mkinitcpio.d/linux.preset`).

Atenção: lvm2, mdadm, e encrypt NÃO são habilitados por padrão. Leia esta seção cuidadosamente para instruções se precisar deles.
Nota:

- Usuários com múltiplos controladores de discos de hardware que usam o mesmo nome de nó mas diferentes módulos de kernel (e.x. dois SCSI/SATA ou dois controladores IDE) devem usar nomeação persistente de dispositivo de bloco para garantir que os dispositivos certos são montados. Senão, a localização do dispositivo raiz pode mudar entre inicializações, resultando em falhas do kernel.
- Usuários de teclado PS/2: para conseguir resposta do teclado durante o init inicial, se ainda não ter, adicione o hook keyboard para o `HOOKS`. Em algumas placas-mãe (majoritariamente as mais antigas, mas também algumas novas), o controlador i8042 não pode ser automaticamente detectado. É raro, mas algumas pessoas vão ainda estar sem o teclado. Você pode detectar esta situação antecipadamente. Se você tem uma porta PS/2 e receber a mensagem `i8042: PNP: No PS/2 controller found. Probing ports directly`, adicione atkbd para o `MODULES`.

Usuários podem modificar seis variáveis dentro do arquivo de configuração:

`MODULES`
  módulos de kernel a serem carregados antes de que qualquer hooks de inicialização são executados.
`BINARIES`
  Binários adicionais a serem incluídos na imagem initramfs.
`FILES`
  Arquivos adicionais a serem incluídos na imagem initramfs.
`HOOKS`
  Hooks são scripts executados no disco RAM inicial.
`COMPRESSION`
  Usado para compactar a imagem initramfs.
`COMPRESSION_OPTIONS`
  Argumentos extras para passar para o programa `COMPRESSION`. O uso desta configuração é fortemente desencorajado. mkinitcpio vai cuidar de necessidades especiais para os compressores (ex., passar `--check=crc32` para xz), e mau uso pode facilmente levar a um sistema não inicializável.

### MODULES

O vetor `MODULES` é usado para especificar módulos a serem carregados antes que qualquer coisa seja feita.

Módulos sufixados com um `?` não vão retornar erros se não forem encontrados. Isto pode ser útil para kernels customizados que compilam com módulos que são listados explicitamente em um hook ou arquivo de configuração.

Nota:

- Se usar reiser4, ele deve ser adicionado para a lista de módulos.
- Se precisar de qualquer sistema de arquivos durante o processo de inicialização que não está em execução quando o mkinitcpio é executado —  por exemplo, se seu keyfile do LUKS está em um sistema de arquivos ext2 mas nenhum dispositivo desse tipo está montado quando o mkinitcpio é executado, o módulo do sistema de arquivos deve também ser adicionado para a lista MODULES. Veja Dm-crypt/Configuração do sistema#cryptkey para mais detalhes.

### BINARIES e FILES

Estas opções permitem que usuários adicionem arquivos para a imagem. Ambos `BINARIES` e `FILES` são adicionados antes da execução dos hooks, e podem ser usados para sobrescrever arquivos usados ou providos por um hook. `BINARIES` são localizados automaticamente dentro de um `PATH` padrão e suas dependências são tratadas, isto significa que qualquer biblioteca necessária será adicionada. `FILES` são adicionados do jeito que estão. Por exemplo:

    FILES=(/etc/modprobe.d/modprobe.conf)

    BINARIES=(kexec)

Note que em ambos `BINARIES` e `FILES`, múltiplas entradas podem ser adicionadas delimitadas com espaços.

### HOOKS

O vetor `HOOKS` é a configuração mais importante no arquivo. Hooks são pequenos scripts que descrevem o que será adicionado para a imagem. Para alguns hooks, eles também vão conter componentes executados durante a execução da imagem que oferecem comportamento adicional, tais como iniciar um serviço, ou reunir um dispositivo de bloco empilhado. Hooks são referidos pelo seu nome, e executados na ordem que eles estão organizados no arranjo `HOOKS` do arquivo de configuração.

A configuração padrão do `HOOKS` deve ser suficiente para as configurações mais simples de disco único. Para dispositivos raiz que são empilhados ou de múltiplos dispositivos de bloco tais como LVM, mdadm, ou dm-crypt, veja as páginas respectivas da wiki para mais configurações necessárias.

#### Hooks de compilação

Hooks de compilação são encontrados em `/usr/lib/initcpio/install/`, hooks de compilação customizados podem ser colocados em `/etc/initcpio/install/`. Estes arquivos são executados pelo shell bash durante a execução do mkinitcpio e devem conter duas funções: `build` e `help`. A função `build` descreve os módulos, arquivos e binários que serão adicionados para a imagem. Uma API, documentada pelo mkinitcpio(8), serve para facilitar a adição destes itens. A função `help` mostra a descrição do que o hook faz.

Para uma lista de todos os hooks disponíveis:

    $ mkinitcpio -L

Use a opção `-H`/`--hookhelp` do mkinitcpio para a saída de ajuda de um hook específico, por exemplo:

    $ mkinitcpio -H udev

#### Hooks de tempo de execução

Hooks de tempo de execução são encontrados em `/usr/lib/initcpio/hooks/`, hooks de tempo de execução customizados podem ser colocados em `/etc/initcpio/hooks/`. Para qualquer hook desse tipo, deve sempre ter um hook de compilação com o mesmo nome, que chama `add_runscript` para adicioná-lo à imagem. Estes arquivos são lidos pelo shell ash do busybox durante o early userspace. Com a exceção de hooks de limpeza, eles sempre serão executados na ordem listada na configuração `HOOKS`. Hooks de tempo de execução podem conter algumas funções:

`run_earlyhook`: Funções deste nome serão executados uma vez que a API dos sistemas de arquivos forem montadas e a linha de comando do kernel for tratada. Isto é geralmente onde daemons adicionais, tais como udev, que são necessários para o início do processo de inicialização são iniciados.

`run_hook`: Funções deste nome são executadas logo depois dos hooks anteriores. Este é o ponto mais comum de um hook, e operações tais como a reunião dos dispositivos de bloco devem tomar lugar aqui.

`run_latehook`: Funções deste nome são executadas depois que o dispositivo raiz for montado. Isto deve ser usado, com moderação, para mais configurações do dispositivo raiz, ou para montar outros sistemas de arquivos, tais como `/usr`.

`run_cleanuphook`: Funções deste nome são executadas o mais tarde possível, e na ordem reversa de como eles foram listados em `HOOKS` no arquivo de configuração. Estes hooks devem ser usados para a limpeza de último minuto, tais como desativar qualquer daemon iniciado em um hook anterior.

Nota: Hooks de tempo de execução são somente usados pelo init do busybox. O hook systemd ativa um init baseado no systemd, que não executa nenhum hook de tempo de execução, e ao invés disso, usa units do systemd.

#### Hooks comuns

Uma tabela de hooks comuns e como eles afetam a criação e execução da imagem a seguir. Note que esta tabela não está completa, já que pacotes oferecem hooks customizados.

This article or section needs expansion.

Reason: Adicionar informação sobre `hostdata`, `memdisk`, `sleep` e `strip`, descobrir se `dmraid`, etc. funciona/é necessário para o initramfs baseado no systemd. (Discuss in talk:mkinitcpio#Improvements for the Common hooks table and section about systemd hook)

init do busybox | init do systemd | Hook de compilação | Hook de tempo de execução (init somente do busybox)
--- | --- | --- | ---
base | Configura todos os diretórios iniciais e instala utilitários e bibliotecas básicas. Sempre mantenha este hook como o primeiro a menos que saiba o que está fazendo, já que isto causa um erro crítico no init do busybox quando o hook systemd não é utilizado. Provê um shell de recuperação do busybox quando o hook systemd é usado. | –
udev | systemd | Adiciona udevd, udevadm, e um pequeno subconjunto de regras udev para sua imagem. | Inicia o daemon do udev e processa uevents do kernel; criando nós de dispositivos. Já que simplifica o processo de inicialização ao não precisar que o usuário explicitamente especifique os módulos necessários, usar isto é recomendado.
usr | Adiciona suporte para ter o `/usr` como uma partição separada. Veja #/usr como uma partição separada para detalhes. | Monta a partição `/usr` depois que a raiz for montada.
resume | – | Tenta resumir do estado "suspender para o disco" (suspend to disk). Veja Hibernação para configuração adicional.
btrfs | -- | Define os módulos necessários para habilitar o Btrfs para usar múltiplos dispositivos com Btrfs. Você precisa ter btrfs-progs instalado para usá-lo. Este hook não é necessário para usar o Btrfs em um único dispositivo. | Executa `btrfs device scan` para reunir o sistema de arquivos raiz Btrfs de múltiplos dispositivos quando o hook udev ou systemd não está presente. O pacote btrfs-progs é necessário para este hook.
autodetect | Deixa seu initramfs com um tamanho menor ao criar uma whitelist de módulos por um escaneamento sysfs. Tenha certeza de verificar os módulos incluídos estão corretos e nenhum está faltando. Este hook deve ser executado antes dos hooks de outros subsistemas para tirar vantagem da detecção automática. Qualquer hook colocado antes do 'autodetect' será totalmente instalado. | –
modconf | Inclui arquivos de configuração do modprobe em `/etc/modprobe.d/` e `/usr/lib/modprobe.d/`. | –
block | Adiciona todos os módulos de dispositivos de bloco, antes providos separadamente pelos hooks fw, mmc, pata, sata, scsi, usb e virtio. | –
net | não implementado | Adiciona os módulos necessários para um dispositivo de rede. Você deve ter mkinitcpio-nfs-utils instalado para usá-lo, veja #Usando net para detalhes. | Provê gerenciamento para sistemas de arquivos baseados no NFS.
dmraid | ? | Oferece suporte para dispositivos raiz fakeRAID. Você deve ter dmraid instalado para usar isto. Note que é recomendado usar `mdadm` com o hook mdadm_udev com fakeRAID se seu controlador suporta. Veja #Usando RAID para detalhes. | Localiza e reúne dispositivos de bloco fakeRAID usando `dmraid`.
mdadm | -- | Oferece suporte a reunião de arranjos RAID do `/etc/mdadm.conf`, ou detecção automática durante a inicialização. Você deve ter mdadm instalado para usá-lo. O hook mdadm_udev é recomendado ao invês desse hook. Veja #Usando RAID para detalhes. | Localiza e reune dispositivos de bloco do RAID de software usando `mdassemble`.
mdadm_udev | Oferece suporte a reunião de arranjos RAID pelo udev. Você deve ter mdadm instalado. Se você usa este hook com um arranjo FakeRAID, é recomendado incluir `mdmon` em `BINARIES`. Veja #Usando RAID para detalhes. | Localiza e reune dispositivos de bloco do RAID de software usando `udev` e reunião incremental `mdadm`. Este é o método recomendado de reunião mdadm (mais do que usar o hook mdadm acima).
keyboard | Adiciona os módulos necessários para teclados. Use isto se você tem um teclado USB ou serial e precisa dele no early userspace (para entrar com as senhas da criptografia ou usar em um shell interativo). Como efeito colateral, módulos para dispositivos de entrada que não são teclado podem ser adicionados também, mas não dependa disto. Superconjunto do antigo hook usbinput. Dica: Para sistemas que são inicializados com diferentes configurações de hardware (ex., notebooks com teclado externo vs. interno ou sistemas headless), é útil colocar este hook antes do autodetect para sempre incluir todos os drivers de teclado. Senão, o teclado externo somente funciona no early userspace se ele estava conectado na criação da imagem. | –
keymap | sd-vconsole | Adiciona o keymap(s) especificado(s) em `/etc/vconsole.conf` para o initramfs. Se você usa encriptação de sistema, especialmente encriptação total de disco, tenha certeza de adicioná-la antes do hook `encrypt`. | Carrega o(s) keymap(s) especificado(s) em `/etc/vconsole.conf` durante o early userspace.
consolefont | Adiciona a fonte do console especificada no `/etc/vconsole.conf` para o initramfs. | Carrega a fonte do console especificada no `/etc/vconsole.conf` durante o early userspace.
encrypt | sd-encrypt | Adiciona o módulo do kernel `dm_crypt` e a ferramenta `cryptsetup` para a imagem. Você deve ter cryptsetup instalado para usar isto. | Detecta e abre uma partição raiz criptografada. Veja #Customização do tempo de execução para mais configurações. Para sd-encrypt veja sd-encrypt.
lvm2 | sd-lvm2 | Adiciona o módulo do mapeador de dispositivos do kernel e a ferramenta `lvm` para a imagem. Você deve ter lvm2 instalado para usar isto. | Habilita todos os grupos de volume LVM2. Isto é necessário se tem seu sistema de arquivos raiz no LVM.
fsck | Adiciona o binário fsck e auxiliares de sistemas de arquivos. Se adicionado depois do hook autodetect, somente o auxiliar específico para seu sistema de arquivos raiz será adicionado. O uso deste hook é fortemente recomendado, e é necessário com uma partição `/usr`. | Executa fsck em seu dispositivo raiz (e `/usr` se separado) antes de montar. Necessita que o parâmetro rw esteja definido na linha de comando do kernel (discussão em inglês).
filesystems | Inclui módulos de sistemas de arquivos necessários em sua imagem. Este hook é necessário a menos que você especifique o módulo de seu sistema de arquivos em `MODULES`. | –

### COMPRESSION

O kernel suporta vários formatos de compressão do initramfs: —gzip, bzip2, lzma, xz (também conhecido como lzma2), lzo, e lz4. Para a maioria dos casos, gzip, lzop, e lz4 oferecem o melhor balanço de tamanho de imagem compactada e velocidade de descompressão. A `mkinitcpio.conf` tem várias opções `COMPRESSION` comentadas. Descomente uma para escolher qual formato de compressão você deseja.

Não especificar `COMPRESSION` vai resultar em um arquivo initramfs compactado com gzip. Para criar uma imagem sem compressão, especifique `COMPRESSION=cat` na configuração ou use `-z cat` na linha de comando.

Tenha certeza de ter o utilitário de compressão de arquivos instalado para o método que você deseja usar.

### COMPRESSION_OPTIONS

Estas são as opções adicionais passadas para o programa especificado em `COMPRESSION`, tal como:

    COMPRESSION_OPTIONS=(-9)

Nota: No geral estas opções nunca devem ser necessárias para o mkinitcpio, pois ele já garante que qualquer método de compressão suportado tem as opções necessárias para produzir uma imagem funcional. Adicionalmente, mau uso pode levar a um sistema não inicializável se o kernel não conseguir descompactar o arquivo resultante.

## Customização do tempo de execução

This article or section needs expansion.

Reason: Que opções funcionam com o hook do `systemd` e quais funcionam somente com `base`? (Discuss in talk:mkinitcpio)

Opções de configuração do tempo de execução podem ser passadas para `init` e certos hooks pela linha de comando do kernel. Parâmetros da linha de comando do kernel são geralmente fornecidos pelo gerenciador de boot. As opções discutidas abaixo podem ser adicionadas a linha de comando do kernel para alterar o comportamento padrão. Veja parâmetros do kernel e processo de inicialização do Arch para mais informação.

### init do hook base

`root`
  Este é o parâmetro mais importante especificado na linha de comando do kernel, já que determina que dispositivo será montado como raiz. mkinitcpio é flexível o bastante para permitir uma ampla variedade de formatos, por exemplo:

    root=/dev/sda1                                                # nó /dev
    root=LABEL=CorsairF80                                         # etiqueta
    root=UUID=ea1c4959-406c-45d0-a144-912f4e86b207                # UUID
    root=PARTUUID=14420948-2cea-4de7-b042-40f67c618660            # UUID da partição GPT

Nota: Os seguintes parâmetros de inicialização alteram o comportamento padrão do `init` no ambiente initramfs. Veja `/usr/lib/initcpio/init` para detalhes. Eles não funcionarão quando o hook `systemd` é usado, já que o `init` do hook `base` é substituido.

`break`
  Se `break` ou `break=premount` é especificado, `init` pausa o processo de inicialização (depois de carregar os hooks, mas antes de montar o sistema de arquivos raiz) e lança um shell interativo que pode ser usado para resolução de problemas. Este shell pode ser lançado depois que a raiz for montada ao especificar `break=postmount`. A inicialização normal continua depois de sair do shell.

`disablehooks`
  Desabilita hooks no tempo de execução ao adicionar `disablehooks=hook1[,hook2,...]`. Por exemplo:

      disablehooks=resume

`earlymodules`
  Altera a ordem que os módulos são carregados, ao especificá-los estes serão carregados mais cedo com `earlymodules=mod1[,mod2,...]`. (Isto pode ser usado, por exemplo, para garantir o ordenamento correto de múltiplas interfaces de rede.)

Veja Depuração de inicialização e mkinitcpio(8) para outros parâmetros.

### Usando RAID

Nota: `mdadm` foi descontinuado. Se está usando ele você vai ver `==> WARNING: Hook 'mdadm' is deprecated. Replace it with 'mdadm_udev' in your config` (Hook 'mdadm' está descontinuado. Troque-o por mdadm_udev em sua configuração) quando fazer uma atualização.

Primeiro, adicione o hook `mdadm_udev` ou `mdadm` para o arranjo `HOOKS` e qualquer módulo RAID necessário (e.x. raid456, ext4) para o arranjo `MODULES` no `/etc/mkinitcpio.conf`.

Usando o hook `mdadm`, você não precisa mais configurar seu arranjo RAID nos parâmetros do kernel. o hook `mdadm` vai usar ou seu arquivo `/etc/mdadm.conf` ou vai detectar automaticamente o arranjo(s) durante a fase init da inicialização.

Reunir dispositivos com o udev também é possível usando o hook `mdadm_udev`. Os desenvolvedores preferem este método. `/etc/mdadm.conf` vai ainda ser lida com o propósito de nomear os dispositivos reunidos.

### Usando net

Atenção: NFSv4 não é suportado ainda FS#28287.

Pacotes necessários

`net` precisa do pacote mkinitcpio-nfs-utils.

Parâmetros do kernel

Informação compreensiva e atualizada pode ser encontrada na documentação do kernel.

ip=

Este parâmetro fala para o kernel como configurar os endereços IP dos dispositivos e também como configurar a tabela de roteamento IP. Pode ter 9 argumentos separados por dois pontos: `ip=<ip-do-cliente>:<ip-do-servidor>:<ip-gw>:<máscara de rede>:<nome do host>:<dispositivo>:<autoconf>:<ip-dns0>:<ip-dns1>`.

Se não ter este parâmetro na linha de comando do kernel, todos os campos são assumidos como vazios, e o padrão mencionado na documentação do kernel são aplicadas. Em geral isto significa que o kernel tenta configurar tudo usando autoconfiguração.

O parâmetro `<autoconf>` pode aparecer sozinho, como valor para o parâmetro 'ip' (sem todos os ':' antes). Se o valor é `ip=off` ou `ip=none`, nenhuma autoconfiguração vai executada, de outro modo, ela será executada. A maneira mais comum de usar isto é `ip=dhcp`.

Para explicação dos parâmetros, veja a documentação do kernel.

Exemplos:

     ip=127.0.0.1:::::lo:none  --> Habilita a interface do dispositivo de loop.
     ip=192.168.1.1:::::eth2:none --> Habilita a interface eth2 estática.
     ip=:::::eth0:dhcp --> Habilita o protocolo dhcp para configuração eth0.

Nota: Tenha a certeza de usar os nomes de dispositivo do kernel (e.x. `eth0`) para o parâmetro `<dispositivo>`, os nomes persistentes (e.x. `enp2s0`) não funcionarão. Veja Configuração de rede#Interfaces de rede para detalhes.

BOOTIF=

Se você tem múltiplas placas de rede, este parâmetro pode incluir o endereço MAC da interface que está inicializando. Isto é geralmente útil já que a numeração da interface pode mudar, ou em conjunção com a opção pxelinux IPAPPEND 2 ou IPAPPEND 3. Se não for dado, eth0 será usado.

Exemplo:

     BOOTIF=01-A1-B2-C3-D4-E5-F6  # Note o "01-" prefixado e letras maiúsculas.

nfsroot=

Se o parâmetro `nfsroot` não é dado na linha de comando, o padrão `/tftpboot/%s` será usado.

     nfsroot=[<ip-do-servidor>:]<diretório-raiz>[,<opções-nfs>]

Execute `mkinitcpio -H net` para explicação do parâmetro.

### Usando LVM

Se seu dispositivo raiz está em LVM, veja Instalar Arch Linux no LVM#Adição de hooks do mkinitcpio.

### Usando raiz criptografada

Se você está usando uma raiz criptografada veja Dm-crypt/Configuração do sistema#mkinitcpio para informação detalhada de quais hooks incluir.

### /usr como uma partição separada

Se você mantém o `/usr` como uma partição separada, você deve aderir ao seguintes requisitos:

- Adicionar o hook `fsck`, marcar `/usr` com um `passno` de `2` no `/etc/fstab` para executar a checagem da partição na inicialização. Enquanto recomendado para todo mundo, é mandatório se você quer que o fsck seja executado em sua partição `/usr` durante a inicialização. Sem este hook, fsck nunca será executado no `/usr`.
- Se não está usando o hook do systemd, adicione o hook `usr`. Isto vai montar a partição `/usr` depois da raiz a ser montada.

## Resolução de problemas

### Extraindo a imagem

Se está curioso sobre o que está dentro da imagem initramfs, você pode extrai-la e ver os arquivos dentro dela.

A imagem initramfs é um arquivo CPIO SVR4, gerado pelos comandos `find` e `bsdcpio`, opcionalmente compactados com uma compressão que o kernel entende. Para mais informação sobre a compressão, veja #COMPRESSION.

mkinitcpio inclui um utilitário chamado `lsinitcpio` que listará e/ou extrairá o conteúdo das imagems initramfs.

Você pode listar os arquivos na imagem com:

    $ lsinitcpio /boot/initramfs-linux.img

E para extrair todos eles no diretório atual:

    $ lsinitcpio -x /boot/initramfs-linux.img

Você pode conseguir uma lista das partes importantes na imagem de forma mais legível com:

    $ lsinitcpio -a /boot/initramfs-linux.img

### Comprimindo novamente uma imagem extraída e modificada

Depois de extrair uma imagem como explicado acima, depois de modificá-la, você pode encontrar o comando necessário para comprimí-la. Edite o `/usr/bin/mkinitcpio` e mude a linha como mostrado abaixo (linha 531 no mkinitcpio v20-1.)

    #MKINITCPIO_PROCESS_PRESET=1 "$0" "${preset_cmd[@]}"
    MKINITCPIO_PROCESS_PRESET=1 /usr/bin/bash -x "$0" "${preset_cmd[@]}"

Então execute o `mkinitcpio` com sua opções comuns (tipicamente `mkinitcpio -p linux`), nas últimas 20 linhas ou mais você vai encontrar algo que parece com isto:

    + find -mindepth 1 -printf '%P\0'
    + LANG=C
    + bsdcpio -0 -o -H newc --quiet
    + gzip

Que corresponde ao comando que você precisa executar, que pode ser:

    # find -mindepth 1 -printf '%P\0' | LANG=C bsdcpio -0 -o -H newc --quiet | gzip > /boot/initramfs-linux.img

Atenção: É uma boa ideia renomear o `/boot/initramfs-linux.img` automaticamente gerado antes de sobrescrevé-lo, para você poder facilmente desfazer sua mudanças. Esteja preparado caso realize um erro que impeça seu sistema de inicializar. Se isto acontecer, você vai precisar inicializar pelo fallback, ou inicializar pelo CD, para restaurar seu original, execute mkinitcpio para sobrescrever suas mudanças, ou conserte elas você mesmo e compacte a imagem.

### "/dev must be mounted" quando /dev já está montado

O teste usado pelo mkinitcpio para determinar se `/dev` está montado é verficar se `/dev/fd/` existe. Se todo o resto parecer ok, esse diretório pode ser "criado" manualmente com:

    # ln -s /proc/self/fd /dev/

(Obviamente, `/proc` deve ser montado também. mkinitcpio precisa dele, e esta é a próxima coisa a ser verificada.)

### Possivelmente faltando firmware para módulo XXXX

Quando o initramfs está sendo gerado depois de uma atualização do kernel, você pode receber estes avisos ou similares:

    ==> WARNING: Possibly missing firmware for module: aic94xx
    ==> WARNING: Possibly missing firmware for module: wd719x

Eles aparecem para qualquer usuário do Arch Linux, especialmente para os que não tem instalado estes módulos de firmware. Se não tem hardware que usa eles você pode ignorar esta mensagem.

Os arquivos mais comuns de firmware podem ser adquiridos ao instalar o pacote linux-firmware. Para outros pacotes que oferecem firmware, tente pesquisar pelo nome do módulo nos repositórios oficiais ou AUR.

### Procedimentos de recuperação padrão

Com um disco RAM inicial impróprio um sistema normalmente não é inicializável. Então siga um procedimento de recuperação de sistema como o abaixo:

#### Inicializa com sucesso em uma máquina mas em outra falha

O hook `autodetect` do mkinitcpio filtra módulos de kernel não necessários no escaneamento primário do `/sys` para o initramfs e módulos carregados no tempo de execução. Se transferir seu diretório `/boot` para outra máquina e a sequência de inicialização falhar durante o early userspace, pode ser devido ao novo hardware não detectado por causa da falta de determinados módulos de kernel. Note que USB 2.0 e 3.0 precisam de diferentes módulos de kernel.

Para consertar isto, primeiro tente escolher a imagem de fallback no seu gerenciador de boot, já que esta não é filtrada pelo `autodetect`. Uma vez inicializado o sistema, execute mkinitcpio na nova máquina para gerar novamente a imagem primária com os módulos corretos. Se a imagem de fallback falhar, tente inicializar por um live CD/USB do Arch Linux, execute chroot na instalação, e execute mkinitcpio na nova máquina. Como última alternativa, tente adicionar módulos manualmente para o initramfs.

## Veja também

- Documentação do kernel Linux sobre initramfs "What is rootfs"
- Documentação do kernel Linux sobre initrd (inglês)
- Artigo do Wikipédia sobre initrd (inglês)

Categories:

- Boot process (Português)
- Kernel (Português)
- Arch projects (Português)
- Commands (Português)

Hidden category:

- Pages or sections flagged with Template:Expansion