Movendo Fastboot para o espaço do usuário

O Android 10 e superior oferece suporte a partições redimensionáveis, realocando a implementação fastboot do carregador de inicialização para o espaço do usuário. Essa realocação permite mover o código que está piscando para um local comum que pode ser mantido e testado com apenas as partes específicas do fornecedor do fastboot implementadas por uma camada de abstração de hardware (HAL). Além disso, o Android 12 e superior oferece suporte para flashing ramdisks por meio de um comando fastboot adicionado.

Unificando o fastboot e a recuperação

Como o fastboot e a recuperação do espaço de usuário são semelhantes, você pode mesclá-los em uma partição ou binário. Isso oferece vantagens como usar menos espaço, ter menos partições no geral e fazer com que o fastboot e a recuperação compartilhem o kernel e as bibliotecas.

Para suporte fastbootd , o bootloader deve implementar um comando novo bloco de controle de boot (BCB) de boot-fastboot . Para entrar fastbootd modo, bootloader escreve boot-fastboot no campo da mensagem BCB comando e deixa a recovery campo da BCB inalterada (para permitir reiniciar as tarefas de recuperação interrompidas). O status , stage , e reserved campos permanecem inalterados bem. As cargas bootloader e botas para a imagem de recuperação Ao ver boot-fastboot no campo comando BCB. Recuperação em seguida, analisa a mensagem BCB e muda para fastbootd modo.

Comandos ADB

Esta seção descreve o adb comando para integrar fastbootd . O comando tem resultados diferentes, dependendo se é executado pelo sistema ou por recuperação.

Comandos Fastboot

Esta seção descreve os comandos fastboot para integrar fastbootd , incluindo novos comandos para piscar e gerenciamento de partições lógicas. Alguns comandos têm diferentes resultados, dependendo se eles foram executados por bootloader ou por fastbootd .

Fastboot e bootloader

O bootloader pisca o bootloader , radio , e boot/recovery partições, após o qual o dispositivo é inicializado em fastboot (userspace) e pisca todas as outras partições. O bootloader deve suportar os seguintes comandos.

Partições dinâmicas

O bootloader não deve permitir que o piscar ou apagar das partições dinâmicas e deve retornar um erro se estas operações são tentadas. Para dispositivos de partição dinâmica adaptados, a ferramenta fastboot (e bootloader) oferece suporte a um modo force para atualizar diretamente uma partição dinâmica durante o modo bootloader. Por exemplo, se o system é um partição dinâmica no dispositivo adaptado, usando o fastboot --force flash system de comando permite que o gestor de arranque (em vez de fastbootd ) a piscar a partição.

Carregamento fora do modo

Se um dispositivo suporta off-modo de carregamento ou de outra forma autoboots em um modo especial, quando a energia é aplicada, uma implementação do fastboot oem off-mode-charge 0 comando deve ignorar esses modos especiais, de modo que o dispositivo é inicializado como se o usuário tivesse pressionado o botão liga / desliga.

Fastboot OEM HAL

Para substituir completamente o bootloader fastboot, fastboot deve lidar com todos os comandos fastboot existentes. Muitos desses comandos são de OEMs e estão documentados, mas exigem uma implementação personalizada. Muitos comandos específicos de OEM não são documentados. Para lidar com esses comandos, o fastboot HAL especifica os comandos OEM necessários. Os OEMs também podem implementar seus próprios comandos.

A definição de fastboot HAL é a seguinte:

import IFastbootLogger;

/**
 * IFastboot interface implements vendor specific fastboot commands.
 */
interface IFastboot {
    /**
     * Returns a bool indicating whether the bootloader is enforcing verified
     * boot.
     *
     * @return verifiedBootState True if the bootloader is enforcing verified
     * boot and False otherwise.
     */
    isVerifiedBootEnabled() generates (bool verifiedBootState);

    /**
     * Returns a bool indicating the off-mode-charge setting. If off-mode
     * charging is enabled, the device autoboots into a special mode when
     * power is applied.
     *
     * @return offModeChargeState True if the setting is enabled and False if
     * not.
     */
    isOffModeChargeEnabled() generates (bool offModeChargeState);

    /**
     * Returns the minimum battery voltage required for flashing in mV.
     *
     * @return batteryVoltage Minimum battery voltage (in mV) required for
     * flashing to be successful.
     */
    getBatteryVoltageFlashingThreshold() generates (int32_t batteryVoltage);

    /**
     * Returns the file system type of the partition. This is only required for
     * physical partitions that need to be wiped and reformatted.
     *
     * @return type Can be ext4, f2fs or raw.
     * @return result SUCCESS if the operation is successful,
     * FAILURE_UNKNOWN if the partition is invalid or does not require
     * reformatting.
     */
    getPartitionType(string partitionName) generates (FileSystemType type, Result result);

    /**
     * Executes a fastboot OEM command.
     *
     * @param oemCmd The oem command that is passed to the fastboot HAL.
     * @response result Returns the status SUCCESS if the operation is
     * successful,
     * INVALID_ARGUMENT for bad arguments,
     * FAILURE_UNKNOWN for an invalid/unsupported command.
     */
    doOemCommand(string oemCmd) generates (Result result);

};

Habilitando o fastbootd

Para habilitar fastbootd em um dispositivo:

1. Adicionar fastbootd para PRODUCT_PACKAGES em device.mk : PRODUCT_PACKAGES += fastbootd .

2. Certifique-se de que o HAL do fastboot, o HAL de controle de inicialização e o HAL de integridade estejam empacotados como parte da imagem de recuperação.

3. Adicione quaisquer permissões SEPolicy específicas de dispositivos exigidos pela fastbootd . Por exemplo, fastbootd requer acesso de escrita para uma partição específica do dispositivo para flash que partição. Além disso, a implementação de fastboot HAL também pode exigir permissões específicas do dispositivo.

Para fastboot validar userspace, execute o Vendor Test Suite (VTS) .

Flashing vendor ramdisks

Android 12 e superior fornece suporte para piscar ramdisks com um comando fastboot adicionou que puxa a cheio vendor_boot imagem a partir de um dispositivo. O comando solicita que a ferramenta fastboot do lado do host leia o cabeçalho de inicialização do fornecedor, refaça a imagem e atualize a nova imagem.

Para puxar a plena vendor_boot imagem, o comando fetch:vendor_boot foi adicionado para o protocolo fastboot, ea implementação fastbootd do protocolo no Android 12. Note que fastbootd não implementar isso, mas o próprio bootloader talvez não. OEMs podem adicionar a fetch:vendor_boot comando para a sua implementação bootloader do protocolo. No entanto, se o comando não for reconhecido no modo bootloader, então flashing ramdisks de fornecedores individuais no modo bootloader não é uma opção com suporte do fornecedor.

Mudanças de bootloader

Os comandos getvar:max-fetch-size e fetch:name são implementados em fastbootd . Para oferecer suporte a flashing vendor ramdisks no bootloader, você deve implementar esses dois comandos.

Mudanças no Fastbootd

getvar:max-fetch-size é semelhante ao max-download-size . Ele especifica o tamanho máximo que o dispositivo pode enviar em uma resposta de DADOS. O driver não deve buscar um tamanho maior que este valor.

fetch:name[:offset[:size]] executa uma série de verificações sobre o dispositivo. Se todos os seguintes forem verdadeiras, a fetch:name[:offset[:size]] dados comando retorna:

• O dispositivo está executando uma compilação depurável.
• O dispositivo está desbloqueado (estado de inicialização laranja).
• O nome da partição é buscada vendor_boot .
• O size valor cai dentro 0 < size <= max-fetch-size .

Quando estes são verificados, fetch:name[:offset[:size]] retorna o tamanho de partição e compensada. Observe o seguinte:

• fetch:name é equivalente a fetch:name:0 , o qual é equivalente a fetch:name:0:partition_size .
• fetch:name:offset é equivalente a fetch:name:offset:(partition_size - offset)

Portanto fetch:name[:offset[:size]] = fetch:name:offset:(partition_size - offset)

Quando offset ou partition_size (ou ambos) são não especificado, os valores por defeito são utilizados, que para offset é 0, e para size é o valor calculado de partition_size - offset .

• Deslocamento especificado, o tamanho não especificado: size = partition_size - offset
• Nem especificado: valores padrão usado para ambos, size = partition_size - 0.

Por exemplo, fetch:foo obtém toda a foo partição no deslocamento 0.

Mudanças de motorista

Comandos foram adicionados à ferramenta fastboot para implementar alterações de driver. Cada um está ligada à sua plena definição na tabela de comandos Fastboot .

• fastboot fetch vendor_boot out.img

  • Chamadas getvar max-fetch-size para determinar o tamanho do bloco.
  • Chama getvar partition-size:vendor_boot[_a] para determinar o tamanho de toda a partição.
  • Chamadas fastboot fetch vendor_boot[_a]:offset:size de cada pedaço. (O tamanho do fragmento é maior do que o vendor_boot tamanho, de modo que não há normalmente apenas um pedaço.)
  • Stitches os dados em conjunto, para out.img .

• fastboot flash vendor_boot:default vendor-ramdisk.img

  Esta é uma variante especial do comando flash. Ele busca o vendor_boot imagem, como se fastboot fetch foi chamado.

  • Se a inicialização fornecedor é cabeçalho versão 3 , ele faz o seguinte:
    • Substitui o ramdisk do fornecedor pela imagem fornecida.
    • Pisca o novo vendor_boot imagem.
  • Se o cabeçalho fornecedor de inicialização é a versão 4 , ele faz o seguinte:
    • Substitui todo o ramdisk fornecedor com a imagem dada para que a imagem dada torna-se o único fragmento fornecedor ramdisk no vendor_boot imagem.
    • Recalcula o tamanho e o deslocamento na tabela de ramdisk do fornecedor.
    • Pisca o novo vendor_boot imagem.

• fastboot flash vendor_boot:foo vendor-ramdisk.img

  Obtém vendor_boot image , como se fastboot fetch foi chamado.

  • Se o cabeçalho de inicialização do fornecedor for a versão 3, ele retornará um erro.

  • Se o cabeçalho de inicialização do fornecedor for a versão 4, ele fará o seguinte:

    • Encontra o fragmento ramdisk fornecedor com o nome foo . Se não for encontrado, ou se houver várias correspondências, retorna um erro.
    • Substitui o fragmento do disco em memória do fornecedor pela imagem fornecida.
    • Recalcula cada tamanho e deslocamento na tabela de ramdisk do fornecedor.
    • Pisca o novo vendor_boot imagem.

mkbootimg

O nome default é reservado para nomear fragmentos fornecedor ramdisk no Android 12 e superior. Enquanto o fastboot flash vendor_boot:default semântica permanecem os mesmos, você não deve nomear seus fragmentos ramdisk como default .

Mudanças SELinux

Uma alteração foi feita no fastbootd.te para apoiar piscando ramdisks fornecedores.