Spostare fastboot nello spazio utente

Fastboot è il nome di un modulo e di una modalità del bootloader. Android 10 e versioni successive supportano le partizioni ridimensionabili spostando l'implementazione di Fastboot dal bootloader allo spazio utente. Questo spostamento consente di trasferire il codice di flashing in una posizione comune gestibile e testabile con solo le parti specifiche del fornitore di fastboot implementate da un livello di astrazione hardware (HAL). Inoltre, Android 12 e versioni successive supportano il flashing dei ramdisk tramite un comando fastboot aggiunto.

Unifica fastboot e recovery

Poiché fastboot e recovery userspace sono simili, puoi unirli in una partizione o in un binario. Ciò offre vantaggi come l'utilizzo di meno spazio, un numero inferiore di partizioni complessive e la condivisione del kernel e delle librerie tra fastboot e recovery.

Fastbootd è il nome di un demone e di una modalità userspace. Per supportare fastbootd, il bootloader deve implementare un nuovo comando del blocco di controllo dell'avvio (BCB) di boot-fastboot. Per attivare la modalità fastbootd, il bootloader scrive boot-fastboot nel campo del comando del messaggio BCB e lascia il campo recovery di BCB invariato (per consentire il riavvio di eventuali attività di ripristino interrotte). Anche i campi status, stage e reserved rimangono invariati. Il bootloader carica e avvia l'immagine di ripristino quando vede boot-fastboot nel campo del comando BCB. Il recupero analizza quindi il messaggio BCB e passa alla modalità fastbootd.

Comandi ADB

Questa sezione descrive il comando adb per l'integrazione di fastbootd. Il comando ha risultati diversi a seconda che venga eseguito dal sistema o dal ripristino.

Comandi Fastboot

Questa sezione descrive i comandi fastboot per l'integrazione di fastbootd, inclusi i nuovi comandi per il flashing e la gestione delle partizioni logiche. Alcuni comandi hanno risultati diversi a seconda che siano stati eseguiti da bootloader o da fastbootd.

Fastboot e bootloader

Il bootloader esegue il flashing delle partizioni bootloader, radio e boot/recovery, dopodiché il dispositivo si avvia in fastboot (spazio utente) ed esegue il flashing di tutte le altre partizioni. Il bootloader deve supportare i seguenti comandi.

Partizioni dinamiche

Il bootloader non deve consentire il flashing o l'eliminazione delle partizioni dinamiche e deve restituire un errore se vengono tentate queste operazioni. Per i dispositivi con partizione dinamica modificata, lo strumento fastboot (e il bootloader) supporta una modalità forzata per flashare direttamente una partizione dinamica in modalità bootloader. Ad esempio, se system è una partizione dinamica sul dispositivo modificato, l'utilizzo del comando fastboot --force flash system consente al bootloader (anziché a fastbootd) di eseguire il flashing della partizione.

Ricarica in modalità Off

Se un dispositivo supporta la ricarica in modalità spenta o si avvia automaticamente in una modalità speciale quando viene applicata l'alimentazione, un'implementazione del comando fastboot oem off-mode-charge 0 deve ignorare queste modalità speciali, in modo che il dispositivo si avvii come se l'utente avesse premuto il pulsante di accensione.

HAL OEM Fastboot

Per sostituire completamente il bootloader fastboot, fastboot deve gestire tutti i comandi fastboot esistenti. Molti di questi comandi provengono dagli OEM e sono documentati, ma richiedono un'implementazione personalizzata. Molti comandi specifici per OEM non sono documentati. Per gestire questi comandi, l'HAL fastboot specifica i comandi OEM richiesti. Gli OEM possono anche implementare i propri comandi.

La definizione di fastboot HAL è la seguente:

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);

};

Attiva fastbootd

Per attivare fastbootd su un dispositivo:

1. Aggiungi fastbootd a PRODUCT_PACKAGES in device.mk: PRODUCT_PACKAGES += fastbootd.

2. Assicurati che HAL fastboot, HAL di controllo dell'avvio e HAL di integrità siano inclusi nell'immagine di ripristino.

3. Aggiungi eventuali autorizzazioni SEPolicy specifiche del dispositivo richieste da fastbootd. Ad esempio, fastbootd richiede l'accesso in scrittura a una partizione specifica del dispositivo per eseguire il flashing di questa partizione. Inoltre, l'implementazione di fastboot HAL potrebbe richiedere anche autorizzazioni specifiche per il dispositivo.

Per convalidare fastboot userspace, esegui la Vendor Test Suite (VTS).

Ramdisk del fornitore del flash

Android 12 e versioni successive supportano il flashing dei ramdisk con un comando fastboot aggiunto che estrae l'immagine vendor_boot completa da un dispositivo. Il comando richiede allo strumento fastboot lato host di leggere l'intestazione di avvio del fornitore, ricreare l'immagine e installare la nuova immagine.

Per eseguire il pull dell'immagine vendor_boot completa, il comando fetch:vendor_boot è stato aggiunto sia al protocollo fastboot sia all'implementazione fastbootd del protocollo in Android 12. Tieni presente che fastbootd implementa questa funzionalità, ma il bootloader stesso potrebbe non farlo. Gli OEM possono aggiungere il comando fetch:vendor_boot all'implementazione del bootloader del protocollo. Tuttavia, se il comando non viene riconosciuto in modalità bootloader, il flashing di singoli ramdisk del fornitore in modalità bootloader non è un'opzione supportata dal fornitore.

Modifiche al bootloader

I comandi getvar:max-fetch-size e fetch:name sono implementati in fastbootd. Per supportare il flashing dei ramdisk del fornitore nel bootloader, devi implementare questi due comandi.

Modifiche a fastbootd

getvar:max-fetch-size è simile a max-download-size. Specifica la dimensione massima che il dispositivo può inviare in una risposta DATA. Il driver non deve recuperare una dimensione maggiore di questo valore.

fetch:name[:offset[:size]] esegue una serie di controlli sul dispositivo. Se tutte le seguenti condizioni sono vere, il comando fetch:name[:offset[:size]] restituisce i dati:

• Sul dispositivo è in esecuzione una build sottoponibile a debug.
• Il dispositivo è sbloccato (stato di avvio arancione).
• Il nome della partizione recuperata è vendor_boot.
• Il valore di size rientra nell'intervallo 0 < size <= max-fetch-size.

Una volta verificati, fetch:name[:offset[:size]] restituisce le dimensioni e l'offset della partizione. Nota:

• fetch:name è equivalente a fetch:name:0, che è equivalente a fetch:name:0:partition_size.
• fetch:name:offset è equivalente a fetch:name:offset:(partition_size - offset)

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

Quando offset o partition_size (o entrambi) non sono specificati, vengono utilizzati i valori predefiniti, ovvero 0 per offset e il valore calcolato di partition_size - offset per size.

• Offset specificato, dimensioni non specificate: size = partition_size - offset
• Nessuno specificato: vengono utilizzati i valori predefiniti per entrambi, size = partition_size - 0.

Ad esempio, fetch:foo recupera l'intera partizione foo all'offset 0.

Modifiche al conducente

Sono stati aggiunti comandi allo strumento fastboot per implementare le modifiche ai driver. Ciascuno è collegato alla sua definizione completa nella tabella dei comandi Fastboot.

• fastboot fetch vendor_boot out.img

  • Chiama getvar max-fetch-size per determinare la dimensione del blocco.
  • Chiamate getvar partition-size:vendor_boot[_a] per determinare le dimensioni dell'intera partizione.
  • Chiamate fastboot fetch vendor_boot[_a]:offset:size per ogni blocco. (La dimensione del blocco è maggiore della dimensione vendor_boot, quindi normalmente c'è un solo blocco.)
  • Unisce i dati per out.img.

• fastboot flash vendor_boot:default vendor-ramdisk.img

  Si tratta di una variante speciale del comando flash. Recupera l'immagine vendor_boot, come se fosse stato chiamato fastboot fetch.

  • Se l'avvio del fornitore è l'intestazione versione 3, esegue le seguenti operazioni:
    • Sostituisce il ramdisk del fornitore con l'immagine specificata.
    • Mostra la nuova immagine vendor_boot.
  • Se l'intestazione di avvio del fornitore è versione 4, esegue le seguenti operazioni:
    • Sostituisce l'intero ramdisk del fornitore con l'immagine specificata, in modo che l'immagine specificata diventi l'unico frammento del ramdisk del fornitore nell'immagine vendor_boot.
    • Ricalcola le dimensioni e l'offset nella tabella ramdisk del fornitore.
    • Mostra la nuova immagine vendor_boot.

• fastboot flash vendor_boot:foo vendor-ramdisk.img

  Recupera vendor_boot image, come se fosse stato chiamato fastboot fetch.

  • Se l'intestazione di avvio del fornitore è la versione 3, viene restituito un errore.

  • Se l'intestazione di avvio del fornitore è la versione 4, esegue le seguenti operazioni:

    • Trova il frammento ramdisk del fornitore con il nome ramdisk_<var>&lt;foo></var>. Se non viene trovato o se ci sono più corrispondenze, viene restituito un errore.
    • Sostituisce il frammento ramdisk del fornitore con l'immagine specificata.
    • Ricalcola ogni dimensione e offset nella tabella ramdisk del fornitore.
    • Mostra la nuova immagine vendor_boot.

  • Se <foo> non è specificato, il sistema tenta di trovare ramdisk_.

mkbootimg

Il nome default è riservato per la denominazione dei frammenti ramdisk del fornitore in Android 12 e versioni successive. Sebbene la semantica di fastboot flash vendor_boot:default rimanga invariata, non devi denominare i frammenti ramdisk come default.

Modifiche a SELinux

È stata apportata una modifica in fastbootd.te per supportare i ramdisk del fornitore.