Google se compromete a promover la equidad racial para las comunidades negras. Ver cómo.

Kernels de compilación

En esta página, se detalla el proceso de compilación de kernels personalizados para dispositivos Android. Las siguientes instrucciones te guían en el proceso de seleccionar las fuentes correctas, compilar el kernel e incorporar los resultados en una imagen del sistema compilada a partir del Proyecto de código abierto de Android (AOSP).

Puedes adquirir fuentes de kernel más recientes mediante Repo y compilarlas sin configuración adicional. Para ello, ejecuta build/build.sh desde la raíz del resultado de tu fuente.

En el caso de los kernels más antiguos o los que no aparecen en la siguiente lista, consulta las instrucciones sobre cómo compilar kernels heredados.

Cómo descargar fuentes y herramientas de compilación

En el caso de los kernels más recientes, usa repo para descargar las fuentes, la cadena de herramientas y las secuencias de comandos de compilación. Algunos kernels (por ejemplo, los de Pixel 3) requieren fuentes de varios repositorios de Git, mientras que otros (por ejemplo, los comunes) solo requieren una fuente. Puedes usar repo para garantizar una configuración correcta del directorio de la fuente.

Descarga las fuentes de la rama correcta:

mkdir android-kernel && cd android-kernel
repo init -u https://android.googlesource.com/kernel/manifest -b BRANCH
repo sync

En la siguiente tabla, se incluyen los nombres de BRANCH de los kernels disponibles con este método.

Dispositivo Ruta de objeto binario en el árbol de AOSP Ramas del repositorio
Pixel 4 (Flame)
Pixel 4 XL (Coral)
device/google/coral-kernel android-msm-coral-4.14-android10
Pixel 3a (Sargo)
Pixel 3a XL (Bonito)
device/google/bonito-kernel android-msm-bonito-4.9-android10
Pixel 3 (Blueline)
Pixel 3 XL (Crosshatch)
device/google/crosshatch-kernel android-msm-crosshatch-4.9-android10
Pixel 2 (walleye)
Pixel 2 XL (taimen)
device/google/wahoo-kernel android-msm-wahoo-4.4-android10
Pixel (Sailfish)
Pixel XL (Marlin)
device/google/marlin-kernel android-msm-marlin-3.18-pie-qpr2
HiKey 960 device/linaro/hikey-kernel hikey-linaro-android-4.14
hikey-linaro-android-4.19
common-android12-5.4
Beagle x15 device/ti/beagle_x15-kernel omap-beagle-x15-android-4.14
omap-beagle-x15-android-4.19
Kernel común de Android N/A common-android-4.4
common-android-4.9
common-android-4.14
common-android-4.19
common-android-4.19-stable
common-android11-5.4
common-android12-5.4
common-android-mainline

Cómo compilar el kernel

Luego, compila el kernel con lo siguiente:

build/build.sh

El objeto binario, los módulos y la imagen correspondiente del kernel se encuentran en el directorio de out/BRANCH/dist.

Cómo ejecutar el kernel

Hay varias maneras de ejecutar un kernel de compilación personalizada. Lo siguientes son métodos conocidos y apropiados para implementarlos en distintos entornos de desarrollo.

Cómo incorporar en la compilación de imágenes de Android

Copia Image.lz4-dtb en la ubicación correspondiente del objeto binario del kernel en el árbol de AOSP y vuelve a compilar la imagen de inicio.

También puedes definir la variable TARGET_PREBUILT_KERNEL mientras usas make bootimage (o cualquier otra línea de comandos de make que compile una imagen de inicio). Esta variable es compatible con todos los dispositivos, ya que se configura a través de device/common/populate-new-device.sh. Por ejemplo:

export TARGET_PREBUILT_KERNEL=DIST_DIR/Image.lz4-dtb

Cómo instalar e iniciar kernels con el inicio rápido

Los dispositivos más recientes tienen una extensión de bootloader que optimiza el proceso de generación y de inicio de una imagen.

Para iniciar el kernel sin instalarlo, haz lo siguiente:

adb reboot bootloader
fastboot boot Image.lz4-dtb

Mediante este método, el kernel no se instala y no persistirá después de un reinicio.

Cómo personalizar la compilación de kernel

El proceso de compilación y el resultado pueden verse influenciados por variables de entorno. La mayoría son opcionales y cada rama de kernel debería incluir una configuración predeterminada apropiada. Las más utilizadas se incluyen en esta lista. Para ver la lista completa (y actualizada), consulta build/build.sh.

Variable de entorno Descripción Ejemplo
BUILD_CONFIG Archivo de configuración de la compilación a partir del que se inicializa el entorno de compilación. La ubicación se definirá según el directorio raíz del repositorio. La configuración predeterminada es build.config.
Es obligatorio para kernels comunes.
BUILD_CONFIG=common/build.config.gki.aarch64
OUT_DIR Directorio de salida base para la compilación de kernel OUT_DIR=/path/to/my/out
DIST_DIR Directorio de salida base para la distribución de kernel OUT_DIR=/path/to/my/dist
CC Anula el compilador que se utilizará. Recurre al compilador predeterminado definido por build.config. CC=clang
SKIP_MRPROPER Omitir make mrproper SKIP_MRPROPER=1
SKIP_DEFCONFIG Omitir make defconfig SKIP_DEFCONFIG=1

Cómo configurar el kernel de forma personalizada para compilaciones locales

Si necesitas cambiar una opción de la configuración de kernel con frecuencia (por ejemplo, cuando trabajas en una función) o si precisas que se configure una opción con fines de desarrollo, puedes mantener una versión local o copiar la configuración de la compilación para lograr esa flexibilidad.

Establece la variable POST_DEFCONFIG_CMDS en una afirmación que se evalúe una vez que termine el paso make defconfig habitual. Como los archivos build.config se originan en el entorno de compilación, se puede llamar a las funciones definidas en build.config como parte de los comandos posteriores a la desconfiguración.

Un ejemplo común consiste en inhabilitar la optimización del tiempo de vinculación (LTO) para kernels de crosshatch durante el desarrollo. Aunque LTO ofrece ventajas para los kernels lanzados, el tiempo de compilación puede ser considerable. Si agregas el siguiente fragmento al build.config local, se inhabilitará LTO de manera persistente cuando uses build/build.sh.

POST_DEFCONFIG_CMDS="check_defconfig && update_debug_config"
function update_debug_config() {
    ${KERNEL_DIR}/scripts/config --file ${OUT_DIR}/.config \
         -d LTO \
         -d LTO_CLANG \
         -d CFI \
         -d CFI_PERMISSIVE \
         -d CFI_CLANG
    (cd ${OUT_DIR} && \
     make O=${OUT_DIR} $archsubarch CC=${CC} CROSS_COMPILE=${CROSS_COMPILE} olddefconfig)
}

Cómo identificar versiones de kernel

Hay dos maneras de identificar la versión correcta que deseas compilar.

Versión de kernel del árbol de AOSP

El árbol de AOSP incluye versiones de kernel compiladas previamente. La mayoría de las veces, el registro de Git muestra la versión correcta como parte del mensaje de confirmación:

cd $AOSP/device/VENDOR/NAME
git log --max-count=1

Versión de kernel de la imagen del sistema

Para determinar la versión de kernel que se usa en una imagen del sistema, ejecuta el siguiente comando en el archivo de kernel:

file kernel

En el caso de los archivos Image.lz4-dtb, ejecuta lo siguiente:

grep -a 'Linux version' Image.lz4-dtb

Cómo compilar una imagen de arranque

Es posible compilar una imagen de arranque con el entorno de compilación del kernel. Para ello, necesitas un objeto binario de ramdisk, que puedes obtener descargando y descomprimiendo una imagen de arranque de GKI. Cualquier imagen de arranque de GKI de la versión de Android asociada funcionará.

tools/mkbootimg/unpack_bootimg.py --boot_img=boot-5.4-gz.img
mv out/ramdisk gki-ramdisk.lz4

Si estás desarrollando con la rama principal de AOSP, puedes descargar el artefacto de compilación ramdisk-recovery.img de una compilación aosp_arm64 en ci.android.com y usarlo como objeto binario de ramdisk.

Si tienes un objeto binario de ramdisk y lo copias en gki-ramdisk.lz4, en el directorio raíz de la compilación del kernel, puedes generar una imagen de arranque ejecutando lo siguiente:

BUILD_BOOT_IMG=1 SKIP_VENDOR_BOOT=1 KERNEL_BINARY=Image.gz GKI_RAMDISK_PREBUILT_BINARY=gki-ramdisk.lz4 BUILD_CONFIG=common/build.config.gki.aarch64 build/build.sh

La imagen de arranque se encuentra en out/<kernel branch>/dist/boot.img.