פיתוח ליבות

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

אפשר להשיג מקורות ליבה עדכניים יותר באמצעות Repo; לפתח אותם בלי צורך על ידי הרצת build/build.sh מהרמה הבסיסית (root) של התשלום המקורי.

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

לליבות מהזמן האחרון, צריך להשתמש ב-repo כדי להוריד את המקורות, 'צרור הכלים' וליצור סקריפטים. לחלק מהליבות (לדוגמה, הליבה של Pixel 3) נדרשים מקורות מכמה gt מאגרים אחרים (לדוגמה, הליבה המשותפת) דורש רק מקור. השימוש בגישה repo מבטיח שהספרייה של המקור מוגדרת בצורה נכונה.

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

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

בקישור הבא מופיעה רשימה של ההסתעפויות ב-repo (BRANCH) שאפשר להשתמש בהן עם הפקודה הקודמת '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, יוצג הפלט של הפקודה למיקום של פריטי המידע שנוצרו בתהליך הפיתוח (Artifact). פרטים נוספים זמינים מסמכי התיעוד ב-AOSP.

פיתוח גרסה build באמצעות build.sh (קודמת)

להסתעפויות ב-Android 12 או פחות, או הסתעפויות ללא קלף: 

build/build.sh

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

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

ב-Android 13 נוספו ליבות של בנייה עם Bazel (Kleaf), מחליף את build.sh.

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

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

לפרטים נוספים על בניית ליבות (kernel) של Android באמצעות Bazel, ראו: Kleaf - בניית ליבה (kernel) של Android בעזרת Bazel.

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

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

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

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

השקנו את Android 11 GKI, שמפריד את הליבה (kernel) לתמונה ליבה (kernel) ש-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

הרצת הליבה

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

הטמעה ב-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

ליבות של Flash ואתחול באמצעות אתחול מהיר (fastboot)

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

כדי להפעיל את הליבה בלי להבהב:

adb reboot bootloader
fastboot boot Image.lz4-dtb

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

מריצים ליבות בדיונון

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

כדי לאתחל מכשיר דיונון עם קבוצה מסוימת של ליבה (kernel) מסוימת ארטיפקטים, מריצים את הפקודה cvd create עם פריטי מידע מהליבה (kernel) של היעד כ- . הפקודה בדוגמה הבאה משתמשת בפריטי ליבה (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. צריך להגדיר את המיקום ביחס לרמה הבסיסית (root) של המאגר ברירת המחדל היא 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

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

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

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

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

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

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

דוגמה נפוצה היא השבתת אופטימיזציה בזמן קישור (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

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

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

בניית תמונת אתחול עבור מכשירים עם 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, אתה צריך קובץ בינארי של RAM, שניתן להשיג באמצעות הורדת תמונת אתחול של 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

הקובץ הזה נמצא בספריית פריטי המידע שנוצרו בתהליך הפיתוח (Artifact) $KERNEL_ROOT/out/$KERNEL_VERSION/dist

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