5.1. Arrancar o Instalador em 32-bit hard-float ARMv7

5.1.1. Formatos de imagens de arranque

Em sistemas baseados em ARM na maioria dos casos é utilizado um de dois formatos de imagens de arranque: a) kernels Linux standard de formato zImage (vmlinuz) em conjunto com os ramdisk iniciais standard de Linux (initrd.gz) ou b) kernels de formato uImage (uImage) em conjunto com os correspondentes ramdisks iniciais (uInitrd).

uImage/uInitrd are image formats designed for the U-Boot firmware that is used on many ARM-based systems (mostly 32-bit ones). Older U-Boot versions can only boot files in uImage/uInitrd format, so these are often used on older armel systems. Newer U-Boot versions can - besides booting uImages/uInitrds - also boot standard Linux kernels and ramdisk images, but the command syntax to do that is slightly different from that for booting uImages.

For systems using a multiplatform kernel, besides kernel and initial ramdisk a so-called device-tree file (or device-tree blob, dtb) is needed. It is specific to each supported system and contains a description of the particular hardware. The dtb should be supplied on the device by the firmware, but in practice a newer one often needs to be loaded.

5.1.2. Console configuration

The netboot tarball (Secção 5.1.3.2, “Pre-built netboot tarball”), and the installer SD-card images (Secção 5.1.5, “Using pre-built SD-card images with the installer”) use the (platform-specific) default console that is defined by U-Boot in the console variable. In most cases that is a serial console, so on those platforms you by default need a serial console cable to use the installer.

On platforms which also support a video console, you can modify the U-Boot console variable accordingly if you would like the installer to start on the video console.

5.1.3. Arrancar por TFTP

Arrancar pela rede requer que tenha uma ligação de rede e um servidor TFTP de arranque por rede (e provavelmente também um servidor de DHCP, RARP ou BOOTP para a configuração automática de rede).

A configuração do servidor para suportar arranque pela rede é descrita em Secção 4.3, “Preparar Ficheiros para Arrancar Através da Rede por TFTP”.

5.1.3.1. Arranque por TFTP em U-Boot

O arranque pela rede em sistemas que utilizam o firmware U-Boot consiste em três passos: a) configurar a rede, b) carregar as imagens (kernel/ramdisk inicial/dtb) para a memória e c) efectivamente executar o código carregado.

Primeiro tem de configurar a rede, quer automaticamente por DHCP ou correndo

setenv autoload no
dhcp

ou manualmente definindo várias variáveis de ambiente

setenv ipaddr <endereço ip do cliente>
setenv netmask <máscara de rede>
setenv serverip <endereço ip do servidor de tftp>
setenv dnsip <endereço ip do servidor de nomes (dns)>
setenv gatewayip <endereço ip da gateway predefinida>

saveenv

Depois tem de carregar as imagens (kernel/ramdisk inicial) para a memória. Isto é feito com o comando tftpboot, ao qual tem de ser passado o endereço a partir de onde é guardada na memória a imagem. Infelizmente o mapa de memória pode variar entre sistemas, por isso não há uma regra genérica com os endereços que possam ser utilizados para isto.

Em alguns sistemas, U-Boot pré-define um conjunto de variáveis de ambiente com endereços de carregamento apropriados: kernel_addr_r, ramdisk_addr_r e fdt_addr_r. Pode verificar se estão definidos ao correr

printenv kernel_addr_r ramdisk_addr_r fdt_addr_r

Se não estiverem definidos, tem que verificar a documentação do seu sistema por valores apropriados e defini-los manualmente. Para sistemas baseados em Allwinner SunXi SOCs (e.g. o Allwinner A10, nome de arquitectura sun4i ou o Allwinner A20, nome de arquitectura sun7i), pode por exemplo utilizar os seguintes valores:

setenv kernel_addr_r 0x46000000
setenv fdt_addr_r 0x47000000
setenv ramdisk_addr_r 0x48000000

Quando estiverem definidos os endereços de carregamento, pode assim carregar as imagens para a memória a partir do servidor tftp anteriormente definido:

tftpboot ${kernel_addr_r} <nome de ficheiro da imagem do kernel>
tftpboot ${fdt_addr_r} <nome de ficheiro de dtb>
tftpboot ${ramdisk_addr_r} <nome de ficheiro da imagem inicial de ramdisk>

A terceira parte é definir a linha de comandos do kernel e executar o código carregado. U-boot passa o conteúdo da variável de ambiente bootargs como linha de comandos do kernel, por isso quaisquer parâmetros para o kernel e instalador - tais como dispositivo de consola (veja Secção 5.3.1, “Consola de arranque”) ou opções de preseeding (seja Secção 5.3.2, “Parâmetros de instalação Debian” e Apêndice B, Automatizar a instalação utilizando 'preseeding') - pode ser definido com um comando como

setenv bootargs console=ttyS0,115200 rootwait panic=10

O comando exato a executar o código carregado anteriormente depende do formato de imagem utilizado. Com uImage/uInitrd o comando é

bootm ${kernel_addr_r} ${ramdisk_addr_r} ${fdt_addr_r}

e com imagens nativas de Linux é

bootz ${kernel_addr_r} ${ramdisk_addr_r}:${filesize} ${fdt_addr_r}

Nota: Quando arrancar imagens standard de linux, é importante carregar a imagem ramdisk inicial após o kernel e o dtb já que U-Boot define a variável de tamanho de ficheiro ao tamanho do último ficheiro carregado e o comando bootz necessita o tamanho da imagem ramdisk para funcionar correctamente. Em caso de arrancar um kernel específico da plataforma, i.e. um kernel sem device-tree, simplesmente omita o parâmetro ${fdt_addr_r}.

5.1.3.2. Pre-built netboot tarball

Debian provides a pre-built tarball ( .../images/netboot/netboot.tar.gz ) that can simply be unpacked on your tftp server and contains all files necessary for netbooting. It also includes a boot script that automates all steps to load the installer. Modern U-Boot versions contain a tftp autoboot feature that becomes active if there is no bootable local storage device (MMC/SD, USB, IDE/SATA/SCSI) and then loads this boot script from the tftp server. Prerequisite for using this feature is that you have a dhcp server in your network which provides the client with the address of the tftp server.

If you would like to trigger the tftp autoboot feature from the U-Boot commandline, you can use the follwing command:

run bootcmd_dhcp

To manually load the bootscript provided by the tarball, you can alternatively issue the following commands at the U-Boot prompt:

setenv autoload no
dhcp
tftpboot ${scriptaddr} /debian-installer/armhf/tftpboot.scr
source ${scriptaddr}

5.1.4. Arrancar a partir de uma 'pen' USB em U-Boot

Muitas versões modernas do U-Boot suportam USB e permitem arrancar através de dispositivos de armazenamento USB tais como pens USB. Infelizmente os passos exactos necessários para o fazer poderão variar bastante de dispositivo para dispositivo.

U-Boot v2014.10 introduziu uma framework comum para lidar com linha de comandos e autoboot. Isto permite compilar imagens de arranque genéricas para funcionar em qualquer sistema que implemente esta framework. O debian-installer suporta a instalação a partir de uma pen USB em tais sistemas, mas infelizmente nem todas as plataformas adoptaram já esta framework.

Para compilar uma pen USB de arranque para instalar Debian, desempacote o tarball hd-media (veja Secção 4.2.1, “Onde Encontrar Imagens de Instalação”) numa pen USB formatada com um sistema de ficheiros suportado pela versão do U-Boot no seu dispositivo. Para versões do U-Boot modernas, qualquer dos FAT16 / FAT32 / ext2 / ext3 / ext4 normalmente funciona. Depois copie o ficheiro da imagem ISO do primeiro CD ou DVD Debian de instalação para a pen.

A framework autoboot nas versões modernas do U-Boot funciona de forma similar às opções de ordem de arranque numa BIOS de PC, i.e. verifica numa lista de dispositivos de arranque possíveis por uma imagem de arranque e inicia a primeira que encontrar. Se não houver um sistema operativo instalado, ligar a pen USB e ligar o sistema deve resultar no inicio do instalador. Pode também iniciar o processo USB-boot em qualquer altura a partir da linha de comandos do U-Boot ao introduzir o comando run bootcmd_usb0.

Um problema que pode surgir ao arrancar a partir de uma pen USB enquanto utiliza uma consola série pode ser o baudrate da consola errado. Se a variável console for definida no U-Boot, o script de arranque do debian-installer passa-a automaticamente ao kernel para definir a consola primária e, se aplicável, o baudrate da consola. Infelizmente a forma de lidar com a variável da consola varia de plataforma para plataforma - em algumas plataformas, a variável console inclui o baudrate (com em console=ttyS0,115200), enquanto que noutras plataformas a variável console contém apenas o dispositivo (como em console=ttyS0). O último caso leva a uma saída da consola errada quando o baudrate predefinido difere entre o U-Boot e o kernel. As versões modernas do U-Boot vulgarmente utilizam 115200 baud enquanto que o kernel ainda está predefinido para os tradicionais 9600 baud. Se isto acontecer, deve definir manualmente a variável console para conter o baudrate correcto para o seu sistema e depois iniciar o instalador com o comando run bootcmd_usb0.

5.1.5. Using pre-built SD-card images with the installer

For a number of systems, Debian provides SD card images that contain both U-Boot and the debian-installer. These images are provided in two variants - one for downloading the software packages over the network (available at .../images/netboot/SD-card-images/ ) and one for offline installations using a Debian CD/DVD (available at .../images/hd-media/SD-card-images/ ). To save space and network bandwidth, the images consist of two parts - a system-dependent part named firmware.<system-type>.img.gz, and a system-independent part named partition.img.gz.

To create a complete image from the two parts on Linux systems, you can use zcat as follows:

zcat firmware.<system-type>.img.gz partition.img.gz > complete_image.img

On Windows systems, you have to first decompress the two parts separately, which can be done e.g. by using 7-Zip, and then concatenate the decompressed parts together by running the command

copy /b firmware.<system-type>.img + partition.img complete_image.img

in a Windows CMD.exe window.

Write the resulting image onto an SD card, e.g. by running the following command on a Linux system:

cat complete_image.img > /dev/SD_CARD_DEVICE

After plugging the SD card into the target system and powering the system up, the installer is loaded from the SD card. If you use the hd-media variant for offline installations, you must provide the installer with access to the first Debian CD/DVD on a separate medium, which can e.g. be a CD/DVD ISO image on a USB stick.

When you come to the partitioning step in the installer (see Secção 6.3.3, “Particionar e Escolher os Pontos de Montagem”), you can delete or replace any previous partitions on the card. Once the installer is started, it runs completely in the system's main memory and does not need to access the SD card anymore, so you can use the full card for installing Debian. The easiest way to create a proper partition layout on the SD card is to let the installer automatically create one for you (see Secção 6.3.3.2, “Particionamento Guiado”).