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

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

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

הורדת מקורות ופיתוח כלים

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

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

mkdir android-kernel && cd android-kernel

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

repo sync

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

לפרטים לגבי הורדה והידור של ליבות למכשירי Pixel, אפשר לעיין במאמר פיתוח ליבה (Kernel) של Pixel.

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

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

ב-Android 13 נוספו ליבות של בנייה עם Bazel.

כדי לבנות את הליבה של GKI לארכיטקטורת aarch64, הסתעפות ליבה משותפת של Android, לא מוקדמת מ-Android 13 לאחר מכן מריצים את הפקודה הבאה:

tools/bazel build //common:kernel_aarch64_dist

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

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

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

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

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

build/build.sh

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

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

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

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

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

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

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

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

אפשר למצוא פרטים על התמיכה ב-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 ו-Eמולטור):

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

הפעלת הליבה

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

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

מעתיקים את Image.lz4-dtb למיקום הבינארי בקישור ליבה (kernel) המתאים בעץ ה-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

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

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

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

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

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

התאמה אישית של גרסת הליבה של ה-build

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

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

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

משתנה הסביבה	תיאור	דוגמה
BUILD_CONFIG	יצירת קובץ תצורה מהמיקום שבו מאתחלים את סביבת ה-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 כדי להתאים אישית הגדרות ליבה (kernel). לראות תיעוד Kleaf בקטעי defconfig.

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

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

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

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

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

זיהוי גרסאות ליבה (kernel)

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

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

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

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 לא מוטמעת בתמונת האתחול.

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

tools/bazel run //common:kernel_aarch64_dist -- --dist_dir=$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

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

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

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

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.