ליבות משותפות של AOSP (שנקראות גם ליבות משותפות של Android או ACKs) הן ליבות במורד הזרם של ליבות kernel.org, והן כוללות תיקונים שמעניינים את קהילת Android ושלא מוזגו לליבות הראשיות או לליבות עם תמיכה לטווח ארוך (LTS). התיקונים האלה יכולים לכלול:
- העברות של פונקציונליות מגרסה חדשה יותר לגרסה ישנה יותר (backport) ובחירה של פונקציונליות ספציפית מגרסה חדשה יותר לגרסה ישנה יותר (cherry-pick) שנדרשות לתכונות של Android
- תכונות שמוכנות למכשירי Android אבל עדיין נמצאות בפיתוח ב-upstream
- תכונות של ספקים או יצרני ציוד מקורי (OEM) שימושיות לשותפים אחרים במערכת האקולוגית
ההסתעפות android-mainline
היא ההסתעפות הראשית של הפיתוח לתכונות של Android. Linux
mainline מתמזג עם android-mainline
בכל פעם שלינוס טורוולדס מפרסם גרסה או גרסת קנדידט. לפני 2019, ליבות נפוצות של Android נוצרו על ידי שיבוט של ליבת LTS שהוכרזה לאחרונה והוספה של תיקוני באגים ספציפיים ל-Android. התהליך הזה השתנה בשנת 2019, והחל מגרסה android-mainline
, ליבת Android common החדשה מפוצלת. המודל החדש הזה מאפשר להימנע מהמאמץ המשמעותי שנדרש להעברת תיקונים של Android ולבדיקתם, כי הוא משיג את אותה תוצאה באופן מצטבר. android-mainline
עובר בדיקות משמעותיות באופן רציף, ולכן המודל הזה כולל ליבת מערכת באיכות גבוהה כבר מהיום שבו הוא מתפרסם.
כשמכריזים על גרסת LTS חדשה ב-upstream, הגרעין המשותף המתאים מסתעף מ-android-mainline
. כך השותפים יכולים להתחיל פרויקט לפני ההכרזה על גרסת ה-LTS, על ידי מיזוג מ-android-mainline
. אחרי שיוצרים את הענף החדש של ליבת המערכת המשותפת, השותפים יכולים לשנות את מקור המיזוג לענף החדש בצורה חלקה.
ענפים נפוצים אחרים של ליבת מערכת ההפעלה מקבלים מיזוגים רגילים מליבת ה-LTS המשויכת.
המיזוגים האלה מתבצעים בדרך כלל מיד אחרי פרסום גרסת ה-LTS. לדוגמה, כשגרסה Linux 6.1.75 פורסמה, היא מוזגה לקרנל המשותף 6.1 (android14-6.1
). מומלץ מאוד לשותפים לעדכן את הקרנלים שלהם כדי להישאר מעודכנים בתיקוני באגים ספציפיים ל-LTS ול-Android.
ענף ליבת ACK KMI
לליבות GKI יש Kernel Module Interface יציב. ממשק ה-KMI מזוהה באופן ייחודי על ידי גרסת הליבה וגרסת הפלטפורמה של Android, ולכן שמות הענפים הם ANDROID_RELEASE
-KERNEL_VERSION
.
לדוגמה, ליבת GKI 6.1 ל-Android 14 נקראת android14-6.1
. ב-Android 15, הושק ליבת GKI android15-6.6
.
קרנלים של תכונות והשקות
לפני Android 15, אפשר היה להשתמש בכל אחת משלוש ליבות המערכת האחרונות להפעלת המכשיר. החל מ-Android 15, אפשר להשתמש בשתי הגרסאות העדכניות ביותר של ליבת המערכת להפעלת המכשיר. ליבת ההפעלה של Android 15 היא android15-6.6
ו-android14-6.1
.
מכיוון שלא נדרשים שדרוגים של ליבת המערכת כשמעדכנים את גרסת הפלטפורמה, עדיין אפשר להשתמש בליבות שחסרות בהן התכונות העדכניות ביותר של גרסת הפלטפורמה כדי להפעיל מכשירים. לכן, אפשר להשתמש בקרנלים שתוכננו ל-Android 14, כמו android14-6.1
, במכשירים גם אחרי שמשדרגים את מהדורת הפלטפורמה ל-Android 15.
עדכון לפלטפורמת Android | הפעלת ליבות | ליבות של תכונות |
---|---|---|
Android 16 (2025) |
android16-6.12
android15-6.6
|
android16-6.12
|
Android 15 (2024) |
android15-6.6
android14-6.1
|
android15-6.6
|
Android 14 (2023) |
android14-6.1
android14-5.15
android13-5.15
android13-5.10
android12-5.10
|
android14-6.1
android14-5.15
|
Android 13 (2022) |
android13-5.15
android13-5.10
android12-5.10
android12-5.4
android11-5.4
|
android13-5.15
android13-5.10
|
Android 12 (2021) |
android12-5.10
android12-5.4
android11-5.4
|
android12-5.10
android12-5.4
|
1 יכול להיות שיחולו הגבלות נוספות אם חבילת ה-BSP המשויכת עודכנה עבור גרסת הפלטפורמה. לפרטים נוספים, אפשר לעיין במאמר בנושא Vendor Interface Object - match kernel branches. |
היררכיה נפוצה של ליבות
הסתעפות מ-android-mainline
רמת העל של היררכיית הליבה המשותפת מוצגת באיור 1.
איור 1. יצירת ליבות נפוצות מליבת android-mainline
שימו לב: בשנת 2022 בוצע פיצול של ליבת Android משותפת חדשה android14-6.1
מ-android-mainline
. בשנת 2023, כשהוכרז על גרסת ה-LTS הבאה, android15-6.6
הסתעפה מ-android-mainline
.
כפי שמוצג באיור 1, כל גרסת ליבה יכולה להיות הבסיס לשתי ליבות GKI.
לדוגמה, שני ליבות v5.15 הן android13-5.15
ו-android14-5.15
, ששתיהן ליבות תכונות למהדורות הפלטפורמה שלהן. כך היה גם בגרסה 5.10. הגרסה android12-5.10
נוצרה כשהוכרז על LTS, והגרסה android13-5.10
הסתעפה מ-android12-5.10
באבן הדרך של השלמת התכונות של ליבת המערכת באביב 2021, כדי לאפשר פיתוח של תכונות ל-Android 13. החל מ-Android 15 (2024), יש רק ליבת GKI חדשה אחת לכל גרסת ליבה (אין ליבת android15-6.1
).
מחזור החיים של ענף ACK KMI
איור 2 מציג את מחזור החיים של ענף KMI ב-ACK.
איור 2. 6.6 מחזור החיים של ענף KMI ב-ACK
כדי להבהיר את תהליך הפיתוח ואת מחזור החיים של הענפים, איור 2 מתמקד בענפי ה-KMI של ACK לגרסה 6.6.
כל הסתעפות של ACK KMI עוברת מחזור של שלושה שלבים שמסומנים באיור 2 בצבעים שונים בכל הסתעפות. כפי שמוצג, LTS מתמזג באופן קבוע ללא קשר לשלב.
שלב הפיתוח
כשיוצרים ענף ACK KMI, הוא נכנס לשלב הפיתוח (מסומן כ-dev באיור 2), ופתוח לתרומות של תכונות לגרסת הפלטפורמה הבאה של Android. באיור 2, android15-6.6
נוצר כשגרסה 6.6 הוכרזה כגרסת ליבת LTS חדשה במעלה הזרם.
שלב הייצוב
כשההסתעפות של ACK KMI מוכרזת כהסתעפות עם כל הפיצ'רים, היא נכנסת לשלב הייצוב (מסומן כיציב באיור 2). אנחנו עדיין מקבלים תכונות של שותפים ותיקוני באגים, אבל מעקב אחרי KMI מופעל כדי לזהות שינויים שמשפיעים על הממשק. בשלב הזה, שינויים שעלולים לגרום לכשל ב-KMI מתקבלים והגדרת ה-KMI מתעדכנת במחזור מוגדר מראש (בדרך כלל כל שבועיים). לפרטים על מעקב אחר KMI, אפשר לעיין בסקירה הכללית על GKI.
שלב קפוא של KMI
לפני שדוחפים מהדורת פלטפורמה חדשה ל-AOSP, ענף ה-ACK KMI מוקפא ונשאר מוקפא למשך חיי הענף. המשמעות היא שלא יתקבלו שינויים שגורמים לשבירת KMI, אלא אם תזוהה בעיית אבטחה חמורה שלא ניתן לפתור בלי להשפיע על ה-KMI היציב. כדי למנוע בעיות ב-KMI, יכול להיות שחלק מהתיקונים שמוזגו מ-LTS ישונו או יוסרו אם התיקון לא נדרש למכשירי Android.
כשענף ACK KMI מוקפא, אפשר לקבל תיקוני באגים ותכונות של שותפים כל עוד ליבת ה-KMI הקיימת לא נפגמת. אפשר להרחיב את KMI עם סמלים חדשים שמיוצאים, כל עוד הממשקים שמרכיבים את KMI הנוכחי לא מושפעים. כשממשקים חדשים מתווספים ל-KMI, הם הופכים מיד ליציבים ושינויים עתידיים לא יכולים לשבור אותם.
לדוגמה, שינוי שמוסיף שדה למבנה שמשמש ממשק KMI של ליבת מערכת נפוצה אסור כי הוא משנה את הגדרת הממשק:
struct foo {
int original_field1;
int original_field2;
int new_field; // Not allowed
};
int do_foo(struct foo &myarg)
{
do_stuff(myarg);
}
EXPORT_SYMBOL_GPL(do_foo);
אבל אפשר להוסיף פונקציה חדשה:
struct foo2 {
struct foo orig_foo;
int new_field;
};
int do_foo2(struct foo2 &myarg)
{
do_stuff2(myarg);
}
EXPORT_SYMBOL_GPL(do_foo2);
במהלך מחזור החיים של ליבת GKI, נשמרת תאימות לאחור עם מרחב המשתמשים, כך שאפשר להשתמש בליבה בבטחה לגרסת הפלטפורמה של Android שאיתה הושק המכשיר. בדיקות רציפות עם גרסאות קודמות שומרות על תאימות. לכן, באיור 2, אפשר להשתמש ב-android15-6.6
kernel במכשירי Android מגרסה 15 ומעלה. מכיוון שגרסת הפלטפורמה של Android תואמת גם לגרסאות קודמות, אפשר להשתמש בליבת android14-6.1
במכשירים עם Android 15 גם להפעלה וגם לשדרוג.
מספר הדור של KMI
אם מתבצע מיזוג של LTS במהלך שלב הייצוב, או אם יש בעיית אבטחה או אירוע אחר אחרי השלב הזה שדורש קבלת תיקון שמשנה את KMI, מספר הדור של KMI שמתועד ב-build.config.common
גדל. אפשר למצוא את הדור הנוכחי של KMI באמצעות הפקודה uname
:
$ uname -r
6.6.30-android15-6-g86d10b30f51f
המספר אחרי מהדורת הפלטפורמה הוא דור ה-KMI (6
במקרה הזה).
אם הדור של KMI משתנה, הליבה לא תואמת למודולים של הספק שתואמים לדור הקודם של KMI, ולכן צריך לבנות מחדש את המודולים ולעדכן אותם באופן סינכרוני עם הליבה. אחרי הקפאת ה-KMI, שינויים ביצירת ה-KMI צפויים להיות נדירים מאוד.
תאימות בין ליבות
דרישות התאימות בין ליבות באותה משפחת LTS משתנות החל מליבות GKI החדשות.
ליבות GKI
ליבות GKI שומרות על תאימות לאחור עם כל הגרסאות של פלטפורמת Android שתמכו בגרסת הליבה. בנוסף, הגרסאות של פלטפורמת Android תואמות לאחור לליבות GKI מגרסאות קודמות. כך תוכלו להשתמש בבטחה בליבת android14-6.1
שפותחה עבור Android 14 (2023) במכשירים עם Android 15 (2024). התאימות נבדקת באמצעות בדיקות VTS ו-CTS רציפות של ליבות GKI עם כל הגרסאות הנתמכות.
ממשק ה-KMI יציב, כך שאפשר לעדכן את ליבת המערכת בלי לבנות מחדש את מודולי הליבה בתמונת הספק.
התאימות של KMI לא נשמרת בין ליבות GKI שונות. לכן, לדוגמה, אי אפשר להחליף ליבת android14-6.1
בליבת android15-6.6
בלי לבנות מחדש את כל המודולים.
ליבות GKI נתמכות רק בגרסאות הראשוניות והבאות שלהן.
הן לא נתמכות בגרסאות ישנות יותר. לכן, ליבת android15-6.6
לא נתמכת במכשירים עם Android 14 (2023).
מטריצת תאימות
בטבלה הזו מוצגות גרסאות הליבה שנתמכות ונבדקות בכל מהדורת פלטפורמת Android.
עדכון לפלטפורמת Android | ליבות נתמכות |
---|---|
Android 16 (2025) |
android16-6.12
android15-6.6
android14-6.1
android14-5.15
android13-5.15
android13-5.10
android12-5.10
android12-5.4
android11-5.4
|
Android 15 (2024) |
android15-6.6
android14-6.1
android14-5.15
android13-5.15
android13-5.10
android12-5.10
android12-5.4
android11-5.4
|
Android 14 (2023) |
android14-6.1
android14-5.15
android13-5.15
android13-5.10
android12-5.10
android12-5.4
android11-5.4
|
Android 13 (2022) |
android13-5.15
android13-5.10
android12-5.10
android12-5.4
android11-5.4
|
Android 12 (2021) |
android12-5.10
android12-5.4
android11-5.4
|
תקופות התמיכה ותיקוני האבטחה
ACKs מקבלים מיזוגים של LTS מ-upstream ותיקוני באגים לקוד ספציפי ל-Android. התיקונים האלה כוללים את כל תיקוני האבטחה של ליבת המערכת שמוזכרים בחדשות האבטחה של Android מדי חודש, שרלוונטיים ל-ACK.
יכול להיות שתהיה תמיכה ב-ACK למשך זמן ארוך יותר מאשר בגרסת הליבה היציבה התואמת ב-kernel.org. במקרה כזה, Google מספקת תמיכה מורחבת עד לתאריך סוף חיי המוצר (EOL) שמוצג בקטע הזה. כשגרעיני מערכת מגיעים לסוף החיים שלהם, הם כבר לא נתמכים על ידי Google ומכשירים שפועלים בהם נחשבים לפגיעים.
החל מליבה 6.6, משך התמיכה בליבות יציבות הוא 4 שנים.
בטבלה הזו מוצגים משכי החיים של אישורי הנתונים הנתמכים:
ענף ACK | תאריך ההשקה |
תמיכה לכל משך החיים (שנים) |
EOL |
---|---|---|---|
android11-5.4 | 2019-11-24 | 6 | 2026-01-01 |
android12-5.4 | 2019-11-24 | 6 | 2026-01-01 |
android12-5.10 | 2020-12-13 | 6 | 2027-07-01 |
android13-5.10 | 2020-12-13 | 6 | 2027-07-01 |
android13-5.15 | 2021-10-31 | 6 | 2028-07-01 |
android14-5.15 | 2021-10-31 | 6 | 2028-07-01 |
android14-6.1 | 2022-12-11 | 6 | 2029-07-01 |
android15-6.6 | 2023-10-29 | 4 | 2028-07-01 |
android16-6.12 | 2024-11-17 | 4 | 2029-07-01 |
בדיקות נפוצות של ליבת המערכת
הליבות הנפוצות נבדקות באמצעות כמה מערכות CI, בנוסף לבדיקות במורד הזרם על ידי ספקים.
בדיקה פונקציונלית של ליבת Linux
בדיקה פונקציונלית של ליבת Linux (LKFT): הבדיקות מפעילות חבילות בדיקה שונות, כולל kselftest, LTP, VTS ו-CTS, במערך של מכשירי arm32 ו-arm64 פיזיים. תוצאות הבדיקה האחרונות זמינות בדף android-lkft.
בדיקות KernelCI
בדיקות build-and-boot של KernelCI מופעלות בכל פעם שמתבצעת התחייבות לתיקון חדש בענף ליבה משותף. מאות הגדרות של build נבדקות ומבוצעת בהן אתחול בלוחות שונים. תוצאות עדכניות של ליבות Android אפשר למצוא באתר KernelCL.
בדיקות לפני ואחרי שליחה ב-Android
בדיקות לפני שליחה משמשות כדי למנוע כשלים בקרנלים הנפוצים של Android. סיכום תוצאות הבדיקה נמצא בכרטיסייה Checks (בדיקות) של שינוי הקוד ב-Android common kernel gerrit.
בדיקות לפני שליחה ב-Android מתבצעות בגרסאות חדשות שפורסמו בענפי ליבה משותפים של Android, כשתיקונים חדשים מועברים לענף ליבה משותף של Android בכתובת ci.android.com. אם מזינים aosp_kernel
כשם חלקי של ענף בכתובת ci.android.com, מוצגת רשימה של ענפי ליבה עם תוצאות זמינות. לדוגמה, תוצאות של android-mainline
אפשר למצוא במרכז הבקרה של Android CI (אינטגרציה רציפה של Android). לוחצים על גרסה מסוימת כדי לראות את סטטוס הבדיקה בכרטיסייה Test Results
.
הבדיקות שמוגדרות על ידי test-mapping
עם קבוצת הבדיקות kernel-presubmit
בעץ המקור של פלטפורמת Android מופעלות כבדיקות
לפני שליחה עבור ענפי ליבת Android. לדוגמה, ההגדרה הבאה ב-test/vts/tests/kernel_proc_file_api_test/TEST_MAPPING מאפשרת את vts_kernel_proc_file_api_test
כבדיקה לפני שליחת קוד במאגר המשותף של ליבת Android.
{
"kernel-presubmit": [
{
"name": "vts_kernel_proc_file_api_test"
}
]
}
בדיקה של אפס ימים
בדיקות 0-day מבצעות בדיקות תיקון בכל הענפים של ליבת Android המשותפת, כשמתבצעת התחייבות לתיקונים חדשים. מבוצעות בדיקות שונות של אתחול, פונקציונליות וביצועים. מצטרפים לקבוצה הציבורית cros-kernel-buildreports.
מטריצת בדיקה
Android common kernel | גרסאות של פלטפורמת Android | חבילות בדיקה | |||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
ראשי | 16 | 15 | 14 | 13 | 12 | LKFT | KernelCI | לפני שליחה | אחרי השליחה | 0-day | |
android-mainline
|
✅ | ❌ | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
android16-6.12
|
✅ | ✅ | ❌ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
android15-6.6
|
✅ | ✅ | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
android14-6.1
|
✅ | ✅ | ✅ | ✅ | ❌ | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
android13-5.15
|
✅ | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ | ✅ | ✅ | ✅ | ✅ |
android12-5.10
|
✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
android11-5.4
|
✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
תרומה לליבות נפוצות של Android
בדרך כלל, פיתוח תכונות צריך להתבצע ב-Linux המרכזי ולא בקרנלים משותפים של Android. מומלץ מאוד לבצע פיתוח במעלה הזרם, ואחרי שהפיתוח יאושר שם, אפשר להעביר אותו חזרה אל הענף הספציפי של ACK לפי הצורך. צוות ליבת Android שמח לתמוך במאמצי העברה לגרסה עדכנית יותר לטובת הסביבה העסקית של Android.
שולחים תיקונים ל-Gerrit ומקפידים על ההנחיות האלה לתרומה.