Google se compromete a impulsar la igualdad racial para las comunidades afrodescendientes. Obtén información al respecto.

Núcleos de construcción

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Esta página detalla el proceso de creación de kernels personalizados para dispositivos Android. Estas instrucciones lo guían a través del proceso de selección de las fuentes correctas, compilación del kernel e integración de los resultados en una imagen del sistema creada a partir del Proyecto de código abierto de Android (AOSP).

Puede adquirir fuentes de kernel más recientes utilizando Repo ; constrúyalos sin configuración adicional ejecutando build/build.sh desde la raíz de su verificación de código fuente.

Descarga de fuentes y herramientas de compilación

Para kernels recientes, use el repo para descargar las fuentes, la cadena de herramientas y los scripts de compilación. Algunos kernels (por ejemplo, los kernels de Pixel 3) requieren fuentes de varios repositorios de git, mientras que otros (por ejemplo, los kernels comunes) requieren solo una fuente. El uso del enfoque de repo garantiza una configuración correcta del directorio de origen.

Descargue las fuentes para la rama apropiada:

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

La siguiente tabla enumera los nombres de BRANCH para kernels disponibles a través de este método.

Dispositivo Ruta binaria en el árbol AOSP Sucursales reporto
Píxel 7 (pantera)
Pixel 7 Pro (guepardo)
dispositivo/google/pantah-kernel android-gs-pantah-5.10-android13-d1
Pixel 6a (arrendajo azul) dispositivo/google/bluejay-kernel android-gs-bluejay-5.10-android13
Pixel 6 (oropéndola)
Pixel 6 Pro (cuervo)
dispositivo/google/raviole-kernel android-gs-raviole-5.10-android13
Pixel 5a (barbudo) dispositivo/google/barbet-kernel android-msm-barbet-4.19-android13
Pixel 5 (aleta roja)
Pixel 4a (5G) (zarza)
dispositivo/google/redbull-kernel android-msm-redbull-4.19-android13
Pixel 4a (pez luna) dispositivo/google/sunfish-kernel android-msm-sunfish-4.14-android13
Píxel 4 (llama)
Pixel 4 XL (coral)
dispositivo/google/coral-kernel android-msm-coral-4.14-android13
Pixel 3a (sargo)
Pixel 3a XL (bonito)
dispositivo/google/bonito-kernel android-msm-bonito-4.9-android12L
Pixel 3 (línea azul)
Pixel 3 XL (sombreado cruzado)
dispositivo/google/crosshatch-kernel android-msm-crosshatch-4.9-android12
Píxel 2 (luciopercas)
Pixel 2 XL (tamaño)
dispositivo/google/wahoo-kernel android-msm-wahoo-4.4-android10-qpr3
Píxel (pez vela)
Pixel XL (marlín)
dispositivo/google/marlin-kernel android-msm-marlin-3.18-pie-qpr2
Hikey960 dispositivo/linaro/hikey-kernel Hiky-linaro-android-4.14
Hiky-linaro-android-4.19
común-android12-5.4
común-android13-5.10
Beagle x15 dispositivo/ti/beagle_x15-kernel omap-beagle-x15-android-4.14
omap-beagle-x15-android-4.19
Núcleo común de Android N / A común-android-4.4
común-android-4.9
común-android-4.14
común-android-4.19
común-android-4.19-estable
común-android11-5.4
común-android12-5.4
común-android12-5.10
común-android13-5.10
común-android13-5.15
común-android14-5.15
común-android-mainline

Construyendo el núcleo

Luego construye el kernel con esto:

build/build.sh

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

Construyendo con Bazel (Kleaf)

Android 13 introdujo la creación de núcleos con Bazel , en sustitución de build/build.sh .

Para compilar el kernel GKI para la arquitectura aarch64, consulte una rama de Android Common Kernel no anterior a Android 13 y luego ejecute el siguiente comando:

tools/bazel build //common:kernel_aarch64_dist

Para crear una distribución, ejecute:

tools/bazel run //common:kernel_aarch64_dist -- --dist_dir=$DIST_DIR

A partir de entonces, el binario del kernel, los módulos y las imágenes correspondientes se encuentran en el directorio $DIST_DIR . Si no se especifica --dist_dir , consulte el resultado del comando para conocer la ubicación de los artefactos. Para obtener más información, consulte la documentación sobre AOSP .

Creación de los módulos de proveedores para el dispositivo virtual

Android 11 introdujo GKI , que separa el kernel en una imagen de kernel mantenida por Google y módulos mantenidos por el proveedor, que se construyen por separado.

Este ejemplo muestra una configuración de imagen del núcleo:

BUILD_CONFIG=common/build.config.gki.x86_64 build/build.sh

Este ejemplo muestra la configuración de un módulo (Cuttlefish y Emulator):

BUILD_CONFIG=common-modules/virtual-device/build.config.cuttlefish.x86_64 build/build.sh

En Android 12, Cuttlefish y Goldfish convergen, por lo que comparten el mismo kernel: virtual_device . Para compilar los módulos de ese kernel, use esta configuración de compilación:

BUILD_CONFIG=common-modules/virtual-device/build.config.virtual_device.x86_64 build/build.sh

Android 13 introdujo la creación de núcleos con Bazel (Kleaf), en sustitución de build.sh .

Para compilar los módulos de virtual_device , ejecute:

tools/bazel build //common-modules/virtual-device:virtual_device_x86_64_dist

Para crear una distribución, ejecute:

tools/bazel run //common-modules/virtual-device:virtual_device_x86_64_dist -- --dist_dir=$DIST_DIR

Para obtener más detalles sobre la creación de kernels de Android con Bazel, consulte. Kleaf: construcción de núcleos de Android con Bazel .

Para obtener detalles sobre el soporte de Kleaf para arquitecturas individuales, consulte Soporte de Kleaf para dispositivos y núcleos .

Soporte de Kleaf para dispositivos y núcleos

La siguiente tabla enumera el soporte de Kleaf para kernels de dispositivos individuales. Para dispositivos no listados, comuníquese con el fabricante del dispositivo.

Dispositivo Sucursales reporto Soporte Kleaf Compatibilidad con build/build.sh
Núcleo común de Android
db845c
Dispositivo virtual (x86_64, arm64)
Dispositivo virtual (i686, brazo)
rockpi4
común-android-4.4
común-android-4.9
común-android-4.14
común-android-4.19
común-android-4.19-estable
común-android11-5.4
común-android12-5.4
común-android12-5.10
Núcleo común de Android común-android13-5.10
común-android13-5.15
✅ (oficial) 1
Núcleo común de Android común-android14-5.15
común-android-mainline
db845c común-android13-5.10
db845c común-android13-5.15 ✅ (oficial) 1
db845c común-android14-5.15
común-android-mainline
Dispositivo virtual (x86_64, arm64) común-android13-5.10
común-android13-5.15
✅ (oficial) 1 ⚠️ (sin mantenimiento) 2
Dispositivo virtual (x86_64, arm64) común-android14-5.15
común-android-mainline
Dispositivo virtual (i686, brazo) común-android13-5.10
común-android13-5.15
Dispositivo virtual (i686, brazo) común-android14-5.15
común-android-mainline
rockpi4 común-android13-5.10
común-android13-5.15
rockpi4 común-android14-5.15
común-android-mainline
Hikey960 Hiky-linaro-android-4.14
Hiky-linaro-android-4.19
común-android12-5.4
común-android13-5.10
módulo fips140 común-android12-5.10
común-android13-5.10
común-android13-5.15
módulo fips140 común-android14-5.15
común-android-mainline

1 "Oficial" significa que esta es la forma oficial de compilar el kernel, aunque la forma alternativa también podría usarse para compilar el kernel.

2 "Sin mantenimiento" significa que la construcción del kernel con este método debería funcionar, pero el método de construcción no se prueba continuamente. Puede dejar de construirse en el futuro. Use la forma "oficial" de construir en su lugar.

Ejecutando el núcleo

Hay varias formas de ejecutar un kernel personalizado. Las siguientes son formas conocidas adecuadas para varios escenarios de desarrollo.

Incrustación en la compilación de imágenes de Android

Copie Image.lz4-dtb en la ubicación binaria del núcleo correspondiente dentro del árbol AOSP y reconstruya la imagen de arranque.

Alternativamente, defina la variable TARGET_PREBUILT_KERNEL mientras usa make bootimage (o cualquier otra línea de comando make que cree una imagen de arranque). 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

Flasheo y arranque de kernels con fastboot

Los dispositivos más recientes tienen una extensión de cargador de arranque para agilizar el proceso de generación y arranque de una imagen de arranque.

Para arrancar el kernel sin flashear:

adb reboot bootloader
fastboot boot Image.lz4-dtb

Con este método, el kernel no se actualiza y no persistirá durante un reinicio.

Personalización de la compilación del kernel

Para personalizar las compilaciones del kernel para las compilaciones de Kleaf, consulte la documentación de Kleaf .

Para build/build.sh , el proceso de compilación y el resultado pueden verse influenciados por variables de entorno. La mayoría de ellos son opcionales y cada rama del kernel debe venir con una configuración predeterminada adecuada. Los más utilizados se enumeran aquí. Para obtener una lista completa (y actualizada), consulte build/build.sh .

Variable ambiental Descripción Ejemplo
BUILD_CONFIG Cree el archivo de configuración desde donde inicializa el entorno de construcción. La ubicación debe definirse en relación con el directorio raíz de Repo. El valor predeterminado es build.config .
Obligatorio para núcleos comunes.
BUILD_CONFIG=common/build.config.gki.aarch64
CC Anule el compilador que se utilizará. Vuelve al compilador predeterminado definido por build.config . CC=clang
DIST_DIR Directorio de salida base para la distribución del kernel. DIST_DIR=/path/to/my/dist
OUT_DIR Directorio de salida base para la compilación del kernel. OUT_DIR=/path/to/my/out
SKIP_DEFCONFIG Omitir make defconfig SKIP_DEFCONFIG=1
SKIP_MRPROPER Omitir make mrproper SKIP_MRPROPER=1

Configuración de kernel personalizada para compilaciones locales

Si necesita cambiar una opción de configuración del kernel regularmente, por ejemplo, cuando trabaja en una característica, o si necesita configurar una opción para fines de desarrollo, puede lograr esa flexibilidad manteniendo una modificación local o una copia de la configuración de compilación.

Establezca la variable POST_DEFCONFIG_CMDS en una declaración que se evalúe justo después de realizar el paso habitual make defconfig . Dado que los archivos build.config se obtienen en el entorno de compilación, las funciones definidas en build.config se pueden llamar como parte de los comandos posteriores a la configuración.

Un ejemplo común es deshabilitar la optimización del tiempo de enlace (LTO) para kernels cruzados durante el desarrollo. Si bien LTO es beneficioso para los kernels lanzados, la sobrecarga en el momento de la compilación puede ser significativa. El siguiente fragmento agregado al build.config local desactiva LTO de forma persistente cuando se usa 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)
}

Identificación de versiones del núcleo

Puede identificar la versión correcta para compilar a partir de dos fuentes: el árbol AOSP y la imagen del sistema.

Versión del kernel del árbol AOSP

El árbol AOSP contiene versiones de kernel precompiladas. El registro de git revela la versión correcta como parte del mensaje de confirmación:

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

Si la versión del kernel no aparece en el registro de git, obténgala de la imagen del sistema, como se describe a continuación.

Versión del kernel de la imagen del sistema

Para determinar la versión del kernel utilizada en una imagen del sistema, ejecute el siguiente comando en el archivo del kernel:

file kernel

Para archivos Image.lz4-dtb , ejecute:

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

Creación de una imagen de arranque

Es posible construir una imagen de arranque utilizando el entorno de construcción del kernel. Para hacer esto, necesita un binario ramdisk, que puede obtener descargando una imagen de arranque GKI y descomprimiéndola. 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 $KERNEL_ROOT/out/ramdisk gki-ramdisk.lz4

La carpeta de destino es el directorio de nivel superior del árbol del núcleo (el directorio de trabajo actual).

Si está desarrollando con AOSP maestro, puede descargar el artefacto de compilación ramdisk-recovery.img de una compilación aosp_arm64 en ci.android.com y usarlo como su binario ramdisk.

Cuando tenga un binario ramdisk y lo haya copiado en gki-ramdisk.lz4 en el directorio raíz de la compilación del kernel, puede generar una imagen de arranque ejecutando:

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

Si está trabajando con una arquitectura basada en x86, reemplace Image con bzImage y aarch64 con x86_64 :

BUILD_BOOT_IMG=1 SKIP_VENDOR_BOOT=1 KERNEL_BINARY=bzImage GKI_RAMDISK_PREBUILT_BINARY=gki-ramdisk.lz4 BUILD_CONFIG=common/build.config.gki.x86_64 build/build.sh

Ese archivo se encuentra en el directorio de artefactos $KERNEL_ROOT/out/$KERNEL_VERSION/dist .

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