Cómo mover fastboot al espacio del usuario

Fastboot es el nombre de un módulo y modo de bootloader. Android 10 y versiones posteriores admiten particiones redimensionables reubicando la implementación de fastboot del bootloader al espacio de usuario. Esta reubicación permite mover el código de escritura en la memoria flash a una ubicación común que se pueda mantener y probar, con solo las partes específicas del proveedor de fastboot implementadas por una capa de abstracción de hardware (HAL). Además, Android 12 y versiones posteriores admiten la escritura en la memoria flash de ramdisks a través de un comando fastboot agregado.

Unifica fastboot y recuperación

Debido a que el fastboot y la recuperación del espacio de usuario son similares, puedes combinarlos en una partición o un archivo binario. Esto proporciona ventajas, como usar menos espacio, tener menos particiones en general y que fastboot y recovery compartan su kernel y sus bibliotecas.

Fastbootd es el nombre de un modo y un daemon de espacio de usuario. Para admitir fastbootd, el cargador de arranque debe implementar un nuevo comando de bloque de control de arranque (BCB) de boot-fastboot. Para ingresar al modo fastbootd, el cargador de arranque escribe boot-fastboot en el campo de comando del mensaje BCB y deja el campo recovery de BCB sin cambios (para permitir el reinicio de cualquier tarea de recuperación interrumpida). Los campos status, stage y reserved también permanecen sin cambios. El cargador de arranque carga la imagen de recuperación y arranca en ella cuando ve boot-fastboot en el campo de comando de BCB. Luego, la recuperación analiza el mensaje de BCB y cambia al modo fastbootd.

Comandos de ADB

En esta sección, se describe el comando adb para integrar fastbootd. El comando tiene resultados diferentes, según si lo ejecuta el sistema o la recuperación.

Comandos de fastboot

En esta sección, se describen los comandos de fastboot para integrar fastbootd, incluidos los comandos nuevos para escribir y administrar particiones lógicas. Algunos comandos tienen resultados diferentes según si los ejecutó el cargador de arranque o fastbootd.

Fastboot y bootloader

El bootloader escribe en la memoria flash de las particiones bootloader, radio y boot/recovery, después de lo cual el dispositivo se inicia en fastboot (espacio del usuario) y escribe en la memoria flash de todas las demás particiones. El cargador de arranque debe admitir los siguientes comandos.

Particiones dinámicas

El cargador de arranque no debe permitir la escritura o el borrado de particiones dinámicas y debe mostrar un error si se intentan estas operaciones. En el caso de los dispositivos con particiones dinámicas adaptadas, la herramienta fastboot (y el bootloader) admiten un modo forzado para escribir directamente en la memoria flash una partición dinámica mientras se está en el modo bootloader. Por ejemplo, si system es una partición dinámica en el dispositivo actualizado, usar el comando fastboot --force flash system permite que el cargador de arranque (en lugar de fastbootd) escriba la partición en la memoria flash.

Carga en modo apagado

Si un dispositivo admite la carga en modo apagado o, de lo contrario, se inicia automáticamente en un modo especial cuando se aplica energía, una implementación del comando fastboot oem off-mode-charge 0 debe omitir estos modos especiales para que el dispositivo se inicie como si el usuario hubiera presionado el botón de encendido.

HAL de OEM de Fastboot

Para reemplazar por completo el cargador de arranque fastboot, fastboot debe controlar todos los comandos fastboot existentes. Muchos de estos comandos son de los OEM y están documentados, pero requieren una implementación personalizada. Muchos comandos específicos del OEM no están documentados. Para controlar estos comandos, el HAL de fastboot especifica los comandos del OEM necesarios. Los OEM también pueden implementar sus propios comandos.

La definición del HAL de fastboot es la siguiente:

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

};

Habilita fastbootd

Para habilitar fastbootd en un dispositivo, sigue estos pasos:

1. Se agregó fastbootd a PRODUCT_PACKAGES en device.mk: PRODUCT_PACKAGES += fastbootd.

2. Asegúrate de que el HAL de fastboot, el HAL de control de arranque y el HAL de estado se incluyan como parte de la imagen de recuperación.

3. Agrega los permisos de SEPolicy específicos del dispositivo que requiera fastbootd. Por ejemplo, fastbootd requiere acceso de escritura a una partición específica del dispositivo para escribir en ella. Además, la implementación del HAL de fastboot también puede requerir permisos específicos del dispositivo.

Para validar fastboot en el espacio del usuario, ejecuta el Vendor Test Suite (VTS).

Escritura en la memoria flash de discos RAM del proveedor

Android 12 y versiones posteriores admiten la escritura en la memoria flash de ramdisks con un comando fastboot agregado que extrae la imagen vendor_boot completa de un dispositivo. El comando solicita a la herramienta de fastboot del host que lea el encabezado de inicio del proveedor, vuelva a crear la imagen y escriba en la memoria flash de la imagen nueva.

Para extraer la imagen vendor_boot completa, se agregó el comando fetch:vendor_boot al protocolo fastboot y a la implementación de fastbootd del protocolo en Android 12. Ten en cuenta que fastbootd sí implementa esto, pero es posible que el bootloader no lo haga. Los OEM pueden agregar el comando fetch:vendor_boot a su implementación del cargador de arranque del protocolo. Sin embargo, si el comando no se reconoce en el modo de cargador de arranque, el proceso de escritura de ramdisks individuales del proveedor en el modo de cargador de arranque no es una opción compatible con el proveedor.

Cambios en el bootloader

Los comandos getvar:max-fetch-size y fetch:name se implementan en fastbootd. Para admitir la escritura de ramdisks del proveedor en el bootloader, debes implementar estos dos comandos.

Cambios en fastbootd

getvar:max-fetch-size es similar a max-download-size. Especifica el tamaño máximo que el dispositivo puede enviar en una respuesta DATA. El controlador no debe recuperar un tamaño mayor que este valor.

fetch:name[:offset[:size]] realiza una serie de verificaciones en el dispositivo. El comando fetch:name[:offset[:size]] devuelve datos si se cumplen todas las siguientes condiciones:

• El dispositivo ejecuta una compilación depurable.
• El dispositivo está desbloqueado (el estado de inicio es naranja).
• El nombre de la partición recuperada es vendor_boot.
• El valor de size se encuentra dentro del rango 0 < size <= max-fetch-size.

Cuando se verifican, fetch:name[:offset[:size]] devuelve el tamaño y el desplazamiento de la partición. Ten en cuenta lo siguiente:

• fetch:name es equivalente a fetch:name:0, que es equivalente a fetch:name:0:partition_size.
• fetch:name:offset es equivalente a fetch:name:offset:(partition_size - offset).

Por lo tanto, fetch:name[:offset[:size]] = fetch:name:offset:(partition_size - offset).

Cuando no se especifican offset o partition_size (o ambos), se usan los valores predeterminados, que son 0 para offset y el valor calculado de partition_size - offset para size.

• Desplazamiento especificado, tamaño no especificado: size = partition_size - offset
• No se especificó ninguno: Se usan los valores predeterminados para ambos, size = partition_size - 0.

Por ejemplo, fetch:foo recupera toda la partición foo en el desplazamiento 0.

Cambios de conductor

Se agregaron comandos a la herramienta fastboot para implementar cambios en el controlador. Cada uno está vinculado a su definición completa en la tabla de comandos de fastboot.

• fastboot fetch vendor_boot out.img

  • Llama a getvar max-fetch-size para determinar el tamaño del fragmento.
  • Llama a getvar partition-size:vendor_boot[_a] para determinar el tamaño de toda la partición.
  • Llama a fastboot fetch vendor_boot[_a]:offset:size para cada fragmento. (El tamaño del fragmento es mayor que el tamaño de vendor_boot, por lo que, normalmente, solo hay un fragmento).
  • Une los datos en out.img.

• fastboot flash vendor_boot:default vendor-ramdisk.img

  Esta es una variante especial del comando flash. Recupera la imagen vendor_boot, como si se hubiera llamado a fastboot fetch.

  • Si el encabezado de inicio del proveedor es la versión 3, se realizan las siguientes acciones:
    • Reemplaza el ramdisk del proveedor por la imagen proporcionada.
    • Muestra la nueva imagen de vendor_boot.
  • Si el encabezado de inicio del proveedor es la versión 4, hace lo siguiente:
    • Reemplaza todo el ramdisk del proveedor por la imagen proporcionada, de modo que esta se convierta en el único fragmento del ramdisk del proveedor en la imagen vendor_boot.
    • Vuelve a calcular el tamaño y el desplazamiento en la tabla de ramdisk del proveedor.
    • Muestra la nueva imagen de vendor_boot.

• fastboot flash vendor_boot:foo vendor-ramdisk.img

  Recupera vendor_boot image, como si se hubiera llamado a fastboot fetch.

  • Si el encabezado de inicio del proveedor es de la versión 3, se muestra un error.

  • Si el encabezado de inicio del proveedor es de la versión 4, hace lo siguiente:

    • Busca el fragmento de ramdisk del proveedor con el nombre ramdisk_<var>&lt;foo></var>. Si no se encuentra o si hay varias coincidencias, se muestra un error.
    • Reemplaza el fragmento del ramdisk del proveedor por la imagen proporcionada.
    • Vuelve a calcular cada tamaño y desplazamiento en la tabla de ramdisk del proveedor.
    • Muestra la nueva imagen de vendor_boot.

  • Si no se especifica <foo>, se intenta encontrar ramdisk_.

mkbootimg

El nombre default está reservado para nombrar fragmentos de ramdisk del proveedor en Android 12 y versiones posteriores. Si bien la semántica de fastboot flash vendor_boot:default sigue siendo la misma, no debes nombrar tus fragmentos de ramdisk como default.

Cambios en SELinux

Se realizó un cambio en fastbootd.te para admitir la escritura de ramdisks del proveedor.