Questa pagina descrive in dettaglio il processo di creazione di kernel personalizzati per dispositivi Android. Queste istruzioni ti guidano attraverso il processo di selezione delle fonti corrette, creazione del kernel e incorporamento dei risultati in un'immagine di sistema creata dal progetto Android Open Source (AOSP).
Puoi acquisire sorgenti del kernel più recenti utilizzando Repo ; costruiscili senza ulteriore configurazione eseguendo build/build.sh dalla root del tuo checkout sorgente.
Download di sorgenti e strumenti di creazione
Per i kernel recenti, utilizza repo per scaricare i sorgenti, la toolchain e creare script. Alcuni kernel (ad esempio i kernel Pixel 3) richiedono sorgenti da più repository git, mentre altri (ad esempio i kernel comuni) richiedono solo una singola sorgente. L'utilizzo dell'approccio repo garantisce una corretta configurazione della directory di origine.
Scarica i sorgenti per il ramo appropriato:
mkdir android-kernel && cd android-kernel
repo init -u https://android.googlesource.com/kernel/manifest -b BRANCH
repo sync
La tabella seguente elenca i nomi BRANCH per i kernel comuni Android e le schede di sviluppo disponibili tramite questo metodo. Fare riferimento alla sezione Creazione di kernel Pixel per dettagli sul download e la compilazione dei kernel per i dispositivi Pixel.
| Dispositivo | Percorso binario nell'albero AOSP | Rami pronti contro termine |
|---|---|---|
| Hikey960 | dispositivo/linaro/hikey-kernel | Hikey-linaro-android-4.14 Hikey-linaro-android-4.19 comune-android12-5.4 comune-android13-5.10 |
| Beagle x15 | dispositivo/ti/beagle_x15-kernel | omap-beagle-x15-android-4.14 omap-beagle-x15-android-4.19 |
| Kernel comune Android | N / A | comune-android-4.4 comune-android-4.9 comune-android-4.14 comune-android-4.19 common-android-4.19-stabile comune-android11-5.4 comune-android12-5.4 comune-android12-5.10 comune-android13-5.10 comune-android13-5.15 comune-android14-5.15 comune-android14-6.1 common-android-mainline |
Costruire il kernel
Costruire con Bazel (Kleaf)
Android 13 ha introdotto la creazione di kernel con Bazel .
Per creare il kernel GKI per l'architettura aarch64, controlla un ramo Android Common Kernel non prima di Android 13, quindi esegui il comando seguente:
tools/bazel build //common:kernel_aarch64_dist
Per creare una distribuzione, esegui:
tools/bazel run //common:kernel_aarch64_dist -- --dist_dir=$DIST_DIR
Successivamente il binario del kernel, i moduli e le immagini corrispondenti si trovano nella directory $DIST_DIR . Se --dist_dir non è specificato, vedere l'output del comando per la posizione degli artefatti. Per i dettagli, fare riferimento alla documentazione su AOSP .
Costruire con build.sh (legacy)
Per i rami con Android 12 o precedenti o senza Kleaf:
build/build.sh
Il binario del kernel, i moduli e l'immagine corrispondente si trovano nella directory out/ BRANCH /dist .
Creazione dei moduli del fornitore per il dispositivo virtuale
Android 13 ha introdotto la creazione dei kernel con Bazel (Kleaf), sostituendo build.sh .
Per creare i moduli di virtual_device , esegui:
tools/bazel build //common-modules/virtual-device:virtual_device_x86_64_dist
Per creare una distribuzione, esegui:
tools/bazel run //common-modules/virtual-device:virtual_device_x86_64_dist -- --dist_dir=$DIST_DIR
Per maggiori dettagli sulla creazione di kernel Android con Bazel, vedere. Kleaf: creazione di kernel Android con Bazel .
Per dettagli sul supporto Kleaf per le singole architetture, vedere Supporto Kleaf per dispositivi e kernel .
Creazione dei moduli del fornitore per il dispositivo virtuale con build.sh (legacy)
In Android 12 Cuttlefish e Goldfish convergono, quindi condividono lo stesso kernel: virtual_device . Per creare i moduli di quel kernel, usa questa configurazione di build:
BUILD_CONFIG=common-modules/virtual-device/build.config.virtual_device.x86_64 build/build.sh
Android 11 ha introdotto GKI , che separa il kernel in un'immagine del kernel gestita da Google e moduli gestiti dal fornitore, che vengono creati separatamente.
Questo esempio mostra una configurazione dell'immagine del kernel:
BUILD_CONFIG=common/build.config.gki.x86_64 build/build.sh
Questo esempio mostra la configurazione di un modulo (Cuttlefish ed Emulatore):
BUILD_CONFIG=common-modules/virtual-device/build.config.cuttlefish.x86_64 build/build.sh
Supporto Kleaf per dispositivi e kernel
La tabella seguente elenca il supporto Kleaf per i singoli kernel del dispositivo. Per i dispositivi non elencati, contattare il produttore del dispositivo.
| Dispositivo | Rami pronti contro termine | Supporto Kleaf | supporto build/build.sh |
|---|---|---|---|
| Kernel comune Android db845c Dispositivo virtuale (x86_64, arm64) Dispositivo virtuale (i686, braccio) Rockpi4 | comune-android-4.4 comune-android-4.9 comune-android-4.14 comune-android-4.19 common-android-4.19-stabile comune-android11-5.4 comune-android12-5.4 comune-android12-5.10 | ❌ | ✅ |
| Kernel comune Android | comune-android13-5.10 comune-android13-5.15 | ✅ | ✅ (ufficiale) 1 |
| Kernel comune Android | comune-android14-5.15 comune-android14-6.1 comune-android15-6.1 common-android-mainline | ✅ | ❌ |
| db845c | comune-android13-5.10 | ❌ | ✅ |
| db845c | comune-android13-5.15 | ✅ | ✅ (ufficiale) 1 |
| db845c | comune-android14-5.15 comune-android14-6.1 comune-android15-6.1 common-android-mainline | ✅ | ❌ |
| Dispositivo virtuale (x86_64, arm64) | comune-android13-5.10 comune-android13-5.15 | ✅ (ufficiale) 1 | ⚠️ (non mantenuto) 2 |
| Dispositivo virtuale (x86_64, arm64) | comune-android14-5.15 comune-android14-6.1 comune-android15-6.1 common-android-mainline | ✅ | ❌ |
| Dispositivo virtuale (i686, braccio) | comune-android13-5.10 comune-android13-5.15 | ❌ | ✅ |
| Dispositivo virtuale (i686, braccio) | comune-android14-5.15 comune-android14-6.1 comune-android15-6.1 common-android-mainline | ✅ | ❌ |
| Rockpi4 | comune-android13-5.10 comune-android13-5.15 | ❌ | ✅ |
| Rockpi4 | comune-android14-5.15 comune-android14-6.1 comune-android15-6.1 common-android-mainline | ✅ | ❌ |
| Hikey960 | Hikey-linaro-android-4.14 Hikey-linaro-android-4.19 comune-android12-5.4 comune-android13-5.10 | ❌ | ✅ |
| modulo fips140 | comune-android12-5.10 comune-android13-5.10 comune-android13-5.15 | ❌ | ✅ |
| modulo fips140 | comune-android14-5.15 | ✅ | ❌ |
1 "Ufficiale" significa che questo è il modo ufficiale di compilare il kernel, anche se per compilare il kernel potrebbe essere utilizzato anche il modo alternativo. 2 "Non mantenuto" significa che la compilazione del kernel con questo metodo dovrebbe funzionare, ma il metodo di compilazione non viene continuamente testato. Potrebbe smettere di costruire in futuro. Utilizza invece il metodo "ufficiale" per costruire. | |||
Esecuzione del kernel
Esistono diversi modi per eseguire un kernel personalizzato. Di seguito sono riportati i modi noti adatti a vari scenari di sviluppo.
Incorporamento nella build dell'immagine Android
Copia Image.lz4-dtb nella rispettiva posizione binaria del kernel all'interno dell'albero AOSP e ricostruisci l'immagine di avvio.
In alternativa, definire la variabile TARGET_PREBUILT_KERNEL durante l'utilizzo make bootimage (o qualsiasi altra riga di comando make che crea un'immagine di avvio). Questa variabile è supportata da tutti i dispositivi poiché è configurata tramite device/common/populate-new-device.sh . Per esempio:
export TARGET_PREBUILT_KERNEL=DIST_DIR/Image.lz4-dtb
Lampeggiamento e avvio dei kernel con fastboot
I dispositivi più recenti dispongono di un'estensione del bootloader per semplificare il processo di generazione e avvio di un'immagine di avvio.
Per avviare il kernel senza eseguire il flashing:
adb reboot bootloaderfastboot boot Image.lz4-dtb
Utilizzando questo metodo, il kernel non viene effettivamente aggiornato e non persisterà dopo il riavvio.
Esecuzione di kernel su seppie
Puoi eseguire i kernel nell'architettura che preferisci sui dispositivi Cuttlefish .
Per avviare un dispositivo Cuttlefish con un particolare set di artefatti del kernel , esegui il comando cvd start con gli artefatti del kernel di destinazione come parametri. Il comando di esempio seguente utilizza gli artefatti del kernel per una destinazione arm64 dal manifest del kernel common-android14-6.1 .
cvd start \-kernel_path=/$PATH/$TO/common-android14-6.1/out/android14-6.1/dist/Image \-initramfs_path=/$PATH/$TO/common-android14-6.1/out/android14-6.1/dist/initramfs.img
Per ulteriori informazioni, vedere Sviluppare kernel su Cuttlefish .
Personalizzazione della build del kernel
Per personalizzare le build del kernel per le build Kleaf, vedere la documentazione di Kleaf .
Personalizzazione della build del kernel con build.sh (legacy)
Per build/build.sh , il processo di compilazione e il risultato possono essere influenzati da variabili di ambiente. La maggior parte di essi sono facoltativi e ogni ramo del kernel dovrebbe avere una configurazione predefinita adeguata. Quelli utilizzati più frequentemente sono elencati qui. Per un elenco completo (e aggiornato), fare riferimento a build/build.sh .
| Variabile d'ambiente | Descrizione | Esempio |
|---|---|---|
BUILD_CONFIG | Compila il file di configurazione da cui inizializzi l'ambiente di compilazione. La posizione deve essere definita in relazione alla directory root del repository. Il valore predefinito è build.config .Obbligatorio per i kernel comuni. | BUILD_CONFIG=common/build.config.gki.aarch64 |
CC | Sostituisci il compilatore da utilizzare. Ritorna al compilatore predefinito definito da build.config . | CC=clang |
DIST_DIR | Directory di output di base per la distribuzione del kernel. | DIST_DIR=/path/to/my/dist |
OUT_DIR | Directory di output di base per la compilazione del kernel. | OUT_DIR=/path/to/my/out |
SKIP_DEFCONFIG | Salta make defconfig | SKIP_DEFCONFIG=1 |
SKIP_MRPROPER | Salta make mrproper | SKIP_MRPROPER=1 |
Configurazione del kernel personalizzata per build locali
In Android 14 e versioni successive, puoi utilizzare i frammenti defconfig per personalizzare le configurazioni del kernel. vedere la documentazione di Kleaf sui frammenti di defconfig .
Configurazione del kernel personalizzata per build locali con configurazioni di build (legacy)
In Android 13 e versioni precedenti, vedere quanto segue.
Se è necessario cambiare regolarmente un'opzione di configurazione del kernel, ad esempio, quando si lavora su una funzionalità, o se è necessario impostare un'opzione per scopi di sviluppo, è possibile ottenere tale flessibilità mantenendo una modifica locale o una copia della configurazione di build.
Imposta la variabile POST_DEFCONFIG_CMDS su un'istruzione che viene valutata subito dopo l'esecuzione del consueto passaggio make defconfig . Poiché i file build.config vengono originati nell'ambiente di compilazione, le funzioni definite in build.config possono essere chiamate come parte dei comandi post-defconfig.
Un esempio comune è la disabilitazione dell'ottimizzazione del tempo di collegamento (LTO) per i kernel crosshatch durante lo sviluppo. Sebbene LTO sia vantaggioso per i kernel rilasciati, il sovraccarico in fase di compilazione può essere significativo. Il seguente frammento aggiunto al build.config locale disabilita LTO in modo persistente quando si utilizza 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)
}
Identificazione delle versioni del kernel
È possibile identificare la versione corretta da compilare da due fonti: l'albero AOSP e l'immagine di sistema.
Versione del kernel dall'albero AOSP
L'albero AOSP contiene versioni del kernel predefinite. Il log git rivela la versione corretta come parte del messaggio di commit:
cd $AOSP/device/VENDOR/NAMEgit log --max-count=1
Se la versione del kernel non è elencata nel log git, ottienila dall'immagine di sistema, come descritto di seguito.
Versione del kernel dall'immagine di sistema
Per determinare la versione del kernel utilizzata in un'immagine di sistema, eseguire il comando seguente sul file del kernel:
file kernel
Per i file Image.lz4-dtb , esegui:
grep -a 'Linux version' Image.lz4-dtb
Creazione di un'immagine di avvio
È possibile creare un'immagine di avvio utilizzando l'ambiente di compilazione del kernel.
Creazione di un'immagine di avvio per dispositivi con init_boot
Per i dispositivi con la partizione init_boot , l'immagine di avvio viene creata insieme al kernel. L'immagine initramfs non è incorporata nell'immagine di avvio.
Ad esempio, con Kleaf, puoi creare l'immagine di avvio GKI con:
tools/bazel run //common:kernel_aarch64_dist -- --dist_dir=$DIST_DIR
Con build/build.sh (legacy), puoi creare l'immagine di avvio GKI con:
BUILD_CONFIG=common/build.config.gki.aarch64 build/build.sh
L'immagine di avvio GKI si trova in $DIST_DIR .
Creazione di un'immagine di avvio per dispositivi senza init_boot (legacy)
Per i dispositivi senza la partizione init_boot , è necessario un file binario ramdisk, che puoi ottenere scaricando un'immagine di avvio GKI e decomprimendola. Funzionerà qualsiasi immagine di avvio GKI della versione Android associata.
tools/mkbootimg/unpack_bootimg.py --boot_img=boot-5.4-gz.img
mv $KERNEL_ROOT/out/ramdisk gki-ramdisk.lz4
La cartella di destinazione è la directory di livello superiore dell'albero del kernel (la directory di lavoro corrente).
Se stai sviluppando con AOSP main, puoi invece scaricare l'artefatto di build ramdisk-recovery.img da una build aosp_arm64 su ci.android.com e utilizzarlo come binario ramdisk.
Quando hai un binario ramdisk e lo hai copiato su gki-ramdisk.lz4 nella directory root della build del kernel, puoi generare un'immagine di avvio eseguendo:
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
Se stai lavorando con un'architettura basata su x86, sostituisci Image con bzImage e 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
Quel file si trova nella directory degli artefatti $KERNEL_ROOT/out/$KERNEL_VERSION/dist .
L'immagine di avvio si trova in out/<kernel branch>/dist/boot.img .