פיתוח ליבה (kernel)

בדף הזה מפורט תהליך היצירה של ליבה מותאמת אישית למכשירי Android. ההוראות האלו מנחות אתכם בתהליך בחירת המקורות הנכונים, פיתוח הליבה והטמעה של התוצאות בתמונת מערכת שנוצרה מ-Android Open Source Project (AOSP).

אפשר לקבל מקורות ליבה עדכניים יותר באמצעות Repo, ולבנות אותם בלי הגדרות נוספות על ידי הפעלת build/build.sh מהשורש של ה-checkout של המקור.

הורדת מקורות וכלי build

לליבת לינוקס עדכנית, משתמשים ב-repo כדי להוריד את מקורות הקוד, ערכת הכלים ל-build ואת הסקריפטים ל-build. עבור חלק מהליבות (למשל, הליבה של Pixel 3) נדרשים מקורות ממספר מאגרי git, ואילו עבור אחרות (למשל, הליבות הנפוצות) נדרש מקור אחד בלבד. השימוש בגישה repo מבטיח שהספרייה של המקור מוגדרת בצורה נכונה.

מורידים את המקורות להסתעפות המתאימה:

mkdir android-kernel && cd android-kernel

repo init -u https://android.googlesource.com/kernel/manifest -b BRANCH

repo sync

רשימה של ההסתעפויות (BRANCH) ב-repo שאפשר להשתמש בהן עם הפקודה הקודמת 'repo init' מפורטת במאמר הסתעפויות של הליבה ומערכות ה-build שלהן.

פרטים על הורדה וקמפלקציה של ליבות למכשירי Pixel זמינים במאמר יצירת ליבות Pixel.

פיתוח הליבה

בונים בעזרת Bazel (קלף)

ב-Android 13 נוספו ליבות לפיתוח בעזרת Bazel.

כדי ליצור הפצה של ליבה של GKI לארכיטקטורה aarch64, צריך לבדוק את ההסתעפות של Android Common Kernel שמתאימה ל-Android 13 ואילך, ואז להריץ את הפקודה הבאה:

tools/bazel run //common:kernel_aarch64_dist [-- --destdir=$DIST_DIR]

לאחר מכן, הקובץ הבינארי של הליבה, המודולים והתמונות התואמות נמצאים בספרייה $DIST_DIR. אם לא מציינים את --destdir, מיקום הפריטים שנוצרו בתהליך הפיתוח (artifacts) מופיע בפלט של הפקודה. פרטים נוספים זמינים במסמכי התיעוד של AOSP.

build באמצעות build.sh (מדור קודם)

להסתעפויות ב-Android 12 או מתחת להן, או להסתעפויות ללא Kleaf:

build/build.sh

הקובץ הבינארי של הליבה, המודולים והתמונה התואמת נמצאים בספרייה out/BRANCH/dist.

פיתוח המודולים של הספקים למכשיר הווירטואלי

ב-Android 13 הושק ה-build של הליבות באמצעות Bazel (Kleaf), שמחליף את build.sh.

כדי ליצור התפלגות למודולים של virtual_device, מריצים את הפקודה:

tools/bazel run //common-modules/virtual-device:virtual_device_x86_64_dist [-- --destdir=$DIST_DIR]

פרטים נוספים על פיתוח ליבות Android באמצעות Bazel זמינים במאמר. Kleaf – פיתוח ליבות Android באמצעות Bazel

פרטים על התמיכה של Kleaf בארכיטקטורות ספציפיות מפורטים במאמר תמיכה של Kleaf במכשירים ובליבות.

פיתוח מודולים של ספקים למכשיר הווירטואלי באמצעות build.sh (מדור קודם)

ב-Android 12 Cuttlefish ו-Soldfish מתכנסים, ולכן הם חולקים את אותה ליבה: virtual_device. כדי ליצור את המודולים של הליבה הזו, משתמשים בתצורת ה-build הבאה:

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

ב-Android 11 הושק GKI, שמפריד את הליבה לתמונת ליבה שמנוהלת על ידי Google ולמודולים שמנוהלים על ידי הספק, שנוצרים בנפרד.

בדוגמה הזו מוצגת הגדרה של קובץ אימג' של ליבה:

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

בדוגמה הזו מוצגת הגדרת מודול (Cuttlefish ו-Emulator):

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

הפעלת הליבה

יש כמה דרכים להריץ ליבה בהתאמה אישית. בהמשך מפורטות דרכים מוכרות שמתאימות לתרחישי פיתוח שונים.

הטמעה ב-build של קובץ האימג' של Android

מעתיקים את Image.lz4-dtb למיקום הבינארי של הליבה המתאימה בעץ ה-AOSP ויוצרים מחדש את קובץ האימג' של האתחול.

לחלופין, אפשר להגדיר את המשתנה TARGET_PREBUILT_KERNEL בזמן השימוש ב-make bootimage (או בכל שורת פקודה אחרת של make שמאפשרת ליצור קובץ אימג' להפעלה). המשתנה הזה נתמך בכל המכשירים כי הוא מוגדר דרך device/common/populate-new-device.sh. לדוגמה:

export TARGET_PREBUILT_KERNEL=DIST_DIR/Image.lz4-dtb

איך מאפסים את הליבה ומפעילים אותה באמצעות fastboot

למכשירים העדכניים ביותר יש תוסף של תוכנת אתחול כדי לייעל את התהליך של יצירת קובץ אימג' לאתחול והפעלה שלו.

כדי להפעיל את הליבה בלי הפעלה מחדש (flashing):

adb reboot bootloader
fastboot boot Image.lz4-dtb

בשיטה הזו, הליבה לא מופיעה בפועל, והיא לא תישאר אחרי הפעלה מחדש.

הרצת ליבות ב-Cuttlefish

אפשר להריץ ליבות בארכיטקטורה שבוחרים במכשירי Cuttlefish.

כדי להפעיל מכשיר Cuttlefish עם קבוצה מסוימת של ארטיפקטים של ליבה (kernel), מריצים את הפקודה cvd create עם פריטי מידע מהליבה (kernel) של היעד כפרמטרים. בפקודה לדוגמה הבאה נעשה שימוש בפריטי הליבה של יעד arm64 מהמניפסט של הליבה common-android14-6.1.

cvd create \
    -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

מידע נוסף זמין במאמר פיתוח ליבות ב-Cuttlefish.

התאמה אישית של ה-build של הליבה

כדי להתאים אישית את גרסאות ה-build של הליבה לגרסאות build של Kleaf, קראו את מסמכי התיעוד של Kleaf.

התאמה אישית של build הליבה באמצעות build.sh (קודם)

ב-build/build.sh, תהליך ה-build והתוצאה שלו יכולים להיות מושפעים ממשתני סביבה. רוב ההגדרות הן אופציונליות, וכל הסתעפות של הליבה צריכה להגיע עם הגדרת ברירת מחדל מתאימה. כאן מפורטות האפשרויות הנפוצות ביותר. רשימה מלאה (ועדכנית) זמינה במאמר build/build.sh.

משתנה הסביבה	תיאור	דוגמה
BUILD_CONFIG	קובץ תצורת build מהמקום שבו אתם מאתחלים את סביבת ה-build. צריך להגדיר את המיקום ביחס לספריית השורש של המאגר. ברירת המחדל היא build.config. חובה לליבת ליבה נפוצות.	BUILD_CONFIG=common/build.config.gki.aarch64
CC	שינוי המהדר שבו נעשה שימוש. חוזר למהדר של ברירת המחדל שמוגדר ב-build.config.	CC=clang
DIST_DIR	ספריית הפלט הבסיסית של הפצת הליבה.	DIST_DIR=/path/to/my/dist
OUT_DIR	ספריית הפלט הבסיסית של ה-build של הליבה.	OUT_DIR=/path/to/my/out
SKIP_DEFCONFIG	דילוג make defconfig	SKIP_DEFCONFIG=1
SKIP_MRPROPER	דילוג על make mrproper	SKIP_MRPROPER=1

הגדרת ליבה בהתאמה אישית לגרסאות build מקומיות

ב-Android מגרסה 14 ואילך, אפשר להשתמש בקטעי defconfig כדי להתאים אישית את הגדרות הליבה. אפשר לעיין במסמכי התיעוד של Kleaf בנושא קטעי defconfig.

הגדרת ליבה בהתאמה אישית לגרסאות build מקומיות עם הגדרות build (קודמות)

ב-Android מגרסה 13 ומטה, יש לפעול לפי ההוראות הבאות.

אם צריך לשנות באופן קבוע אפשרות של הגדרת ליבה (kernel), למשל כשעובדים על תכונה, או אם רוצים להגדיר אפשרות למטרות פיתוח, אפשר להשיג את הגמישות הזו על ידי שמירה על שינוי מקומי או עותק של הגדרת ה-build.

מגדירים את המשתנה POST_DEFCONFIG_CMDS לביטוי שאותו מחשבים מיד אחרי השלבים הרגילים של make defconfig. מכיוון שקובצי build.config מובאים לסביבת ה-build, אפשר להפעיל פונקציות שמוגדרות ב-build.config כחלק מהפקודות שלאחר defconfig.

דוגמה נפוצה היא השבתת אופטימיזציה בזמן קישור (LTO) לליבת crosshatch במהלך הפיתוח. אמנם LTO מועיל לליבת ליבה שפורסמה, אבל העלות הנוספת בזמן ה-build יכולה להיות משמעותית. קטע הקוד הבא, שנוסף ל-build.config המקומי, משבית את LTO באופן קבוע כשמשתמשים ב-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)
}

זיהוי גרסאות ליבה

אפשר לזהות את הגרסה הנכונה ל-build משני מקורות: עץ AOSP וקובץ האימג' של המערכת.

גרסת הליבה מהעץ של AOSP

עץ ה-AOSP מכיל גרסאות ליבה (kernel) מוכנות מראש. הגרסה הנכונה מופיעה ביומן של git כחלק מהודעת ה-commit:

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

אם גרסת הליבה לא מופיעה ביומן git, אפשר לקבל אותה מקובץ האימג' של המערכת, כפי שמתואר בהמשך.

גרסת ליבה מתמונת המערכת

כדי לקבוע את גרסת הליבה שמשמשת בתמונת מערכת, מריצים את הפקודה הבאה בקובץ הליבה:

file kernel

בקובצי Image.lz4-dtb, מריצים את:

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

יצירת קובץ אימג' לאתחול

אפשר ליצור קובץ אימג' לאתחול באמצעות סביבת ה-build של הליבה.

יצירת קובץ אימג' לאתחול של מכשירים עם init_boot

במכשירים עם מחיצה init_boot, קובץ האימג' של האתחול נוצר יחד עם הליבה. קובץ האימג' של initramfs לא מוטמע בקובץ האימג' של האתחול.

לדוגמה, אפשר ליצור את קובץ האימג' של GKI באמצעות Kleaf באמצעות:

tools/bazel run //common:kernel_aarch64_dist [-- --destdir=$DIST_DIR]

ב-build/build.sh (קודם), אפשר ליצור את קובץ האימג' של אתחול GKI באמצעות:

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

קובץ האימג' של אתחול GKI נמצא ב-$DIST_DIR.

יצירת תמונת אתחול למכשירים ללא init_boot (מדור קודם)

במכשירים בלי המחיצה init_boot, צריך קובץ בינארי של ramdisk, שאפשר לקבל על ידי הורדת קובץ אימג' של האתחול של GKI ופתיחת האריזה של הקובץ. כל תמונת הפעלה של GKI מגרסת Android המשויכת תפעל.

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

תיקיית היעד היא הספרייה ברמה העליונה של עץ הליבה (ספריית העבודה הנוכחית).

אם אתם מפתחים עם AOSP main, תוכלו להוריד במקום זאת את קובץ הארטיפקט של ה-build של ramdisk-recovery.img מ-build של aosp_arm64 ב-ci.android.com ולהשתמש בו כקובץ הבינארי של ה-ramdisk.

כשיש קובץ בינארי של דיסק RAM ועותקתם אותו לקובץ gki-ramdisk.lz4 בתיקיית השורש של build הליבה, אפשר ליצור קובץ אימג' של אתחול באמצעות הפקודה:

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

אם אתם עובדים עם ארכיטקטורה מבוססת x86, מחליפים את Image ב-bzImage ואת aarch64 ב-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

הקובץ הזה נמצא בספריית הארטיפקטים $KERNEL_ROOT/out/$KERNEL_VERSION/dist.

תמונת האתחול ממוקמת ב-out/<kernel branch>/dist/boot.img.