היסטוריית ה-Linux kernel: החלטות שעיצבו את המערכת
סקירה של התפתחות ה-Linux kernel מגרסה 0.01 ועד 7.x. ננתח את המעבר ל-GPL, את הוויכוח על ה-microkernel, את יצירת ה-git ואת מודל ה-LTS והשפעתם הישירה על ניהול שרתים כיום.
גרסה מקוצרת של היסטוריית ה-Linux kernel
ההיסטוריה של ה-Linux kernel מתחילה בגרסה 0.01 בספטמבר 1991 ומגיעה עד לסדרת ה-7.x שרצה על שרתים כיום. רשימת הגרסאות היא החלק הפחות מעניין בסיפור. מספר מצומצם של החלטות עיצב את פני המערכת, ולכל אחת מהן יש עדיין השלכות על מכונה שתשכרו היום אחר הצהריים. הסיבה לכך שהיה צורך ב-kernel חדש ב-1991 שייכת ל-סיפור הארוך יותר של Unix, הרישוי של AT&T והתביעה המשפטית שבלמה את BSD.
התאריכים ומספרי הגרסאות כאן מבוססים על kernel.org ועל היסטוריית הגרסאות שהוא מפרסם. המצב הנוכחי, נכון ל-13 בנובמבר 2026: גרסה 7.0 הגיעה ב-12 באפריל 2026, גרסה 7.1 ב-14 ביוני 2026, גרסה 7.2 באמצע אוגוסט 2026, וגרסה 7.3 ב-18 באוקטובר 2026. האתר kernel.org מציג את 7.4-rc2 כגרסת ה-mainline ואת 7.3.4 כגרסה היציבה (stable) הנוכחית. ענף 7.2 הגיע לסוף חייו (end of life) עם גרסה 7.2.15 ב-1 בנובמבר 2026.
מדוע הבחירה ב-GPL בשנת 1992 עדיין רלוונטית
גרסה 0.01 פורסמה ב-17 בספטמבר 1991 תחת רישיון שטורבאלדס כתב בעצמו. הרישיון דרש הפצה של קוד המקור, והוסיף שורה שהייתה משמעותית יותר: "אין להפיץ זאת תמורת תשלום, אפילו לא עבור עלויות 'טיפול'". בשנת 1991 תוכנה הופצה על גבי תקליטונים, ופעולות של העתקה ושליחה בדואר עלו כסף. סעיף זה הפך הפצה מסחרית של Linux לבלתי אפשרית.
הוא שינה זאת. המעבר לרישיון GNU General Public License (GPL) הוכרז בהערות השחרור של גרסה 0.12 בינואר 1992 ונכנס לתוקף ב-1 בפברואר 1992. גרסה 0.95, במרץ 1992, הייתה השחרור הראשון שפורסם תחת רישיון זה. כל עסק שנבנה מאוחר יותר על בסיס Linux נשען על שינוי זה.
הליבה (kernel) מופצת תחת GPL גרסה 2 בלבד, והיא מעולם לא עברה לגרסה 3. טורבאלדס סירב לכך בשנת 2007, בעיקר בשל הכלל נגד "tivoisation" ב-GPLv3, הדורש מידע התקנה עבור גרסאות שעברו שינוי של קוד המכוסה ברישיון כאשר הוא מופץ עם מכשיר צרכני, אלא אם כן לא הספק ולא אף צד שלישי יכולים להתקין קוד שעבר שינוי, כפי שקורה עם קוד המותקן ב-ROM. הוא התייחס לחומרה נעולה כעניינו הפרטי של היצרן. בשנת 2017 פרסמו מפתחי הליבה את ה-Kernel Enforcement Statement, המאמץ בכל זאת חלק אחד מ-GPLv3: מי שמקבל התראה ראשונה על הפרה מבעל זכויות יוצרים ומתקן אותה בתוך 30 יום, מקבל את הרישיון שלו בחזרה לצמיתות, במקום לאבד אותו כבר בהפרה הראשונה.
לכך יש שתי השלכות על שרת. קובץ ה-binary של הליבה שאתם מאתחלים נושא עמו זכות לקבל את קוד המקור התואם, כך שאף אחד לא יכול לספק לכם ליבת Linux שאינכם רשאים לבחון או לבנות מחדש. כמו כן, הודעת זכויות היוצרים על הליבה מציינת שהרישיון אינו מכסה תוכניות משתמש המשתמשות בשירותי הליבה באמצעות קריאות מערכת (system calls) רגילות, וזו הסיבה שמסדי נתונים קנייניים וסוכני ניטור מופצים עבור Linux מבלי להפר דבר. רישיון מתירני (permissive) יוצר לחץ הפוך, וכדאי להבין את ההבדל הזה לפני שבוחרים פלטפורמה: ראו Linux ו-FreeBSD כפלטפורמות שרת.
מדוע הליבה המונוליטית ניצחה בפועל
ב־29 בינואר 1992, פרסם Andrew Tanenbaum הודעה תחת הכותרת "LINUX is obsolete" בקבוצת הדיון comp.os.minix. הוא העלה שתי טענות. הראשונה, שליבות מונוליטיות, שבהן מנהלי התקנים (drivers) ומערכות קבצים רצים בתוך מרחב כתובות מורשה אחד, הן תכנון משנות ה־70, בעוד שמיקרו-ליבות (microkernels), שבהן חלקים אלו רצים כתהליכים רגילים, הן העתיד. השנייה, ש־Linux רתוקה ל־Intel 386, ולכן לעולם לא תהיה ניידת.
הטענה לגבי הניידות נענתה באמצעות ביצוע פורטים (porting). כאשר גרסה 1.2 שוחררה במרץ 1995, פורטים עבור DEC Alpha, MIPS, SPARC ומשפחת Motorola 68000 היו עדיין בתהליך. גרסה 2.0 ביוני 1996 הייתה המהדורה היציבה הראשונה שתמכה ב־Alpha בעלת 64 סיביות לצד ה־386, ובתחילת 1997 הצטרפה אליהן SPARC כפורט משולב.
הטענה לגבי התכנון נענתה באמצעות פשרה. Linux מעולם לא הפכה למיקרו-ליבה. היא קיבלה מודולי ליבה הניתנים לטעינה (loadable kernel modules): קובצי אובייקט שניתן להזריק לתוך ליבה רצה ולהסירם שוב, כך שמנהל התקן משוחרר בנפרד מהקובץ הבינארי של הליבה.
lsmod | head
modinfo virtio_net | head -5lsmod מציג את מה שטעון כרגע. modinfo מדפיס את הקובץ שממנו הגיע המודול ואת הפרמטרים שהוא מקבל. בשרת וירטואלי, רוב נתיב הדיסק והרשת מורכב ממודולים, וזו הסיבה שדמות ליבה אחת עולה על חומרה שהיא מעולם לא פגשה. הליבה רק מדווחת על חומרה חדשה, ודמון במרחב המשתמש (user space) מחליט איזה מודול לטעון ואיך לקרוא להתקן; כך ניהול ההתקנים עבר לתוך מערכת ה־init, וזהו חלק מהסיבה ש־systemd הפכה לקשה להימנעות.
מודולים קנו את הגמישות הזו ללא העלות שנשא תכנון המיקרו-ליבה. בידוד מנהל התקן בתהליך משלו משמעותו תשלום עבור החלפת הקשר (context switch) והעברת הודעה בכל קריאה, ובשנת 1992 עלות זו הייתה גבוהה.
העלות ש־Linux שמרה עליה היא זו שיש לתכנן לפיה: מודול רץ עם הרשאות ליבה מלאות, כך שמודול פגום עלול להפיל את המכונה כולה במקום רק תהליך אחד. מודולים מחוץ לעץ הליבה (out-of-tree) הם המקום שבו זה מורגש. מנהל התקן של ספק שאינו נמצא ב־mainline חייב לעבור הידור מחדש מול כל ליבה חדשה, וזה מה ש־DKMS עושה במהלך שדרוג; כאשר הידור זה נכשל, ההתקן פשוט חסר לאחר ה־reboot.
מדוע לקח ל-SMP חמש-עשרה שנים להסתיים
Linux 2.0 ביוני 1996 הייתה הליבה היציבה הראשונה שתמכה ב-symmetric multiprocessing (SMP), כלומר יותר ממעבד אחד שמריץ ליבה אחת. המימוש הראשון השתמש בנעילה יחידה, ה-big kernel lock (BKL), כך שרק מעבד אחד יכול היה להיות בתוך קוד הליבה בכל רגע נתון. מעבד שני עזר לכן לעומס עבודה שמבצע חישובים ב-user space, אך עזר מעט מאוד לעומס עבודה של קריאות מערכת (system calls), כיוון שאלו עמדו בתור מאחורי אותה נעילה.
הסרת הנעילה הזו ארכה חמש-עשרה שנים. המשתמשים הנותרים הועברו לנעילה עדינה (fine-grained locking), בעיקר על ידי ארנד ברגמן, וה-BKL נמחק בגרסה 2.6.39, ששוחררה ב-18 במאי 2011. מתזמן המשימות (scheduler) נע באותו קצב איטי: מתזמן ה-O(1) ב-2.6.0, ה-Completely Fair Scheduler (CFS) מגרסה 2.6.23 ב-2007, ו-EEVDF, שהחליף את CFS בגרסה 6.6 באוקטובר 2023.
העבודה הזו היא הסיבה לכך שתוכנית של 4 vCPU היא עניין שבשגרה כיום. היא גם מסמנת גבול שכדאי להכיר. בשרת וירטואלי משותף, הליבה שלכם מתזמנת את ה-threads שלכם, וה-hypervisor מתזמן את הליבה שלכם. הריצו את top וקראו את השדה %st. זמן גניבה (steal time) הוא זמן מעבד שהליבה שלכם הייתה מוכנה להשתמש בו, אך המארח נתן אותו לאורח אחר, לכן שום כוונון בתוך הליבה שלכם לא יחזיר אותו.
מדוע סדרת 2.6 שינתה את אופן בניית ה-kernel
לפני גרסה 2.6, מספרי הגרסאות הופיעו בזוגות. מספר שני זוגי ציין סדרה יציבה (2.4), ומספר אי-זוגי ציין סדרת פיתוח (2.5). גרסה 2.4 שוחררה ב-4 בינואר 2001 וגרסה 2.6 ב-17 בדצמבר 2003, כך שמשתמשים המתינו כמעט שלוש שנים לסדרה היציבה הבאה. הפצות לא יכלו להמתין, ולכן הן ביצעו backport. שני ספקים שסיפקו שניהם "2.4" הפיצו גרסאות kernel שהפרידו ביניהן אלפי תיקונים.
הפיצול בוטל לאחר 2.6. ה-mainline פותח כעת חלון מיזוג (merge window) של כשבועיים, מקבל עבודה חדשה, ולאחר מכן מריץ release candidates עד לרגיעה, ומשחרר גרסה כל 9 עד 10 שבועות; זהו הקצב ש-kernel.org עדיין מתעד. החצי השני של המודל הגיע ב-4 במרץ 2005 עם השחרור הראשון של ה-stable tree, עדכון תיקונים בלבד ל-2.6.11, שתוחזק על ידי Greg Kroah-Hartman ו-Chris Wright. ה-stable tree מקבל תיקונים ומסרב להוסיף פיצ'רים.
תופעת לוואי אחת: מספר הגרסה חדל מלהיות הבטחה. 3.0, 4.0, 5.0 ו-7.0 אינן כתיבה מחדש של הקוד. Torvalds מעלה את המספר הראשון כאשר השני גדל מספיק כדי להציק לו, וזו הסיבה ש-7.0 הגיעה אחרי 6.19 באפריל 2026. מה שחשוב עבור שרת הוא באיזה ענף ההפצה שלכם עוקבת, והאם ענף זה עדיין מקבל תיקונים.
כיצד השבר ב-BitKeeper הוליד את git באפריל 2005
החל מפברואר 2002 פותח ה-kernel באמצעות BitKeeper, מערכת ניהול גרסאות מבוזרת וקניינית מבית חברת BitMover של Larry McVoy, החל מסדרת 2.5. חברת BitMover העניקה למפתחי ה-kernel רישיון חינמי בתנאים מגבילים: אסור היה לעבוד על כלי מתחרה לניהול גרסאות, ואסור היה לבצע הנדסה לאחור ל-BitKeeper. מפתחים רבים הסתייגו מבניית kernel חופשי באמצעות כלי שאין להם רשות לבחון את תוכנו.
הקשר נותק באפריל 2005, לאחר ש-Andrew Tridgell הציג תוכנית שמתקשרת עם מאגרי BitKeeper. ב-BitMover הגדירו זאת כהנדסה לאחור וביטלו את הרישיון החינמי. ה-kernel נותר ללא מערכת ניהול גרסאות באמצע מחזור פיתוח.
העבודה על git החלה באפריל 2005. Torvalds הכריז על הפרידה מ-BitKeeper ב-6 באפריל. ב-7 באפריל git כבר אירח את עצמו, כלומר ההיסטוריה של git נשמרה בתוך git. Torvalds הכריז על ה-merge המוצלח הראשון ב-17 באפריל. ביוני 2005, git ניהל את ה-release של 2.6.12. זמן קצר לאחר מכן העביר Torvalds את התחזוקה ל-Junio Hamano וחזר לעבוד על ה-kernel.
התכנון נבע ישירות מהצורך: אלפי תורמים, ומתחזקים שמושכים קוד זה מזה דרך רשת שאף אחד לא סומך עליה. כל אובייקט מזוהה לפי ה-hash של תוכנו, כך ששינוי של בייט אחד בהיסטוריה הישנה משנה את השם של כל commit שבא אחריה. זו הסיבה ש-clone הוא עדות ולא רק טענה. כל pipeline של פריסה, כל מאגר תצורה, מארח הקוד שרוב הצוותים דוחפים אליו ו-שרת ה-git שניתן להריץ באופן עצמאי צמחו מתוך ויכוח על רישוי סביב ה-kernel.
מה מודל ה-LTS מבטיח, ומה לא
גרסת ה-mainline אינה הגרסה שאתם מריצים. גרסת mainline מוחלפת בתוך 9 עד 10 שבועות. עץ ה-stable כולל תיקונים עד לגרסת ה-mainline הבאה, אלא אם ענף מסוים מוגדר כ-longterm. ענפי longterm, המכונים בדרך כלל LTS, כוללים תיקונים למשך שנים, ואלו הם הענפים שעליהם מתבססות הפצות רבות.
הגרסה 2.6.32, ששוחררה בדצמבר 2009, היא המקום שבו המודל הוכיח את עצמו. RHEL 6, Debian 6, SUSE Linux Enterprise 11 SP1 ו-Ubuntu 10.04 LTS כולן הפיצו אותה, והענף תוחזק עד מרץ 2016, יותר משש שנים לאחר הופעתו. Red Hat הרחיקה לכת עוד יותר ותמכה בקרנל מבוסס 2.6.32 באמצעות backports משלה עד ש-RHEL 6 סיימה את שלב התחזוקה שלה ב-2020, והיא עדיין מוכרת תיקוני אבטחה ותיקוני באגים דחופים עבור RHEL 6 דרך תוסף Long-Life בתשלום עם תנאים שנתיים הנמשכים עד סוף 2030. שכפול אותו עשור של תמיכה בחינם הוא הסיבה המלאה לכך ש-CentOS הייתה קיימת ו-Rocky Linux ו-AlmaLinux החליפו אותה.
ההבטחה השתנתה יותר מפעם אחת. היא עמדה על שנתיים, ולאחר מכן על שש שנים עבור ענפים מסוימים. בשנת 2023 קיצצו מתחזקי ה-stable את ברירת המחדל חזרה לשנתיים, כיוון שביצוע backport לעצים ישנים גוזל זמן מהמתחזקים וענפים ישנים זוכים למעט בדיקות בפועל. ב-25 בפברואר 2026 פרסם Greg Kroah-Hartman תחזיות ארוכות יותר שוב, לאחר דיון עם החברות התלויות בענפים אלו, אך קרנלים חדשים מסוג longterm עדיין מתחילים בדרך כלל עם תחזית סוף חיים של שנתיים.
הנתונים שמאחורי התרשים
[
{
"kernel": "5.10",
"released": "2020-12-13",
"eol_projected": "Dec 2026",
"maintained_for": 6.0
},
{
"kernel": "5.15",
"released": "2021-10-31",
"eol_projected": "Dec 2026",
"maintained_for": 5.1
},
{
"kernel": "6.1",
"released": "2022-12-11",
"eol_projected": "Dec 2027",
"maintained_for": 5.0
},
{
"kernel": "6.6",
"released": "2023-10-29",
"eol_projected": "Dec 2027",
"maintained_for": 4.2
},
{
"kernel": "6.12",
"released": "2024-11-17",
"eol_projected": "Dec 2028",
"maintained_for": 4.1
},
{
"kernel": "6.18",
"released": "2025-11-30",
"eol_projected": "Dec 2028",
"maintained_for": 3.1
}
]אתר kernel.org מציג 6 ענפי longterm נכון לאוקטובר 2026. הענף הוותיק ביותר, 5.10, יכלול תיקונים במשך 6.0 שנים כאשר יסתיים ב-Dec 2026. הענף החדש ביותר, 6.18, צפוי לפעול עד Dec 2028, שהם 3.1 שנים של תיקונים.
התייחסו לתאריכים אלו כאל תחזיות ולא כאל חוזה. התחזיות עבור 6.6 ו-6.12 שתיהן זזו קדימה בפברואר 2026, וענף שאף אחד לא משתמש בו עלול להיות מופסק במקום זאת. ההפצה שלכם בדרך כלל מבצעת את הבחירה עבורכם: Debian 13 מפיצה את 6.12, ו-Ubuntu 26.04 LTS מפיצה את 7.0. הפער הזה הוא התוכן המעשי של השאלה על LTS מול גרסת ביניים בשרת, וזה מה שבאמת משתנה מתחת לפני השטח כאשר אתם משדרגים מ-Ubuntu 24.04 ל-26.04.
מלכודת אחת נובעת מכך. uname -r ב-Ubuntu 24.04 מדפיס משהו כמו 6.8.0-51-generic. זהו בסיס upstream בתוספת ה-backports של ההפצה עצמה, לכן המספר מציין היכן הענף התחיל ולא אילו תיקונים כלולים בו. סורקים ששופטים קרנל לפי מחרוזת הגרסה שלו מעלים התראות שווא נגד קרנלים של הפצות בדיוק מהסיבה הזו.
על מה הליבה (kernel) מתווכחת כרגע
שני ויכוחים מתנהלים כעת, ושניהם עוסקים בשאלה מי מבצע את העבודה.
השפה Rust הוטמעה כתשתית בגרסה 6.1 בדצמבר 2022. בגרסה 7.0 הוסרה תווית הניסיוניות, כך ששפות הליבה של ה-kernel הן כעת C, assembly ו-Rust. בנייה עם מהדר Rust יציב נתמכה כבר ב-6.1: ה-Makefile שלה מגדיר את RUSTC_BOOTSTRAP=1 כדי לאפשר תכונות לא יציבות במהדרים יציבים. המחלוקת נסובה סביב התחזוקה. מתחזק C שמשנה ממשק עלול לשבור קישורי Rust שאינו קורא, והוויכוח הוא על מי מוטלת האחריות לתקן אותם.
הוויכוח השני עוסק בתרומות של בינה מלאכותית (AI). סשה לוין הציע מדיניות ביולי 2025, לאחר שנפח הולך וגדל של טלאים (patches) שנוצרו בסיוע מכונה הגיע לרשימות התפוצה. המסמך אושר ב-6 בינואר 2026 והוא נמצא כעת בתיעוד התהליכים של ה-kernel בכתובת docs.kernel.org/process/coding-assistants.html. סוכן AI אינו רשאי להוסיף תגית Signed-off-by, כיוון ששורה זו מאשרת את ה-Developer Certificate of Origin (DCO) ורק אדם יכול לאשר זאת. תיעוד ה-kernel הנוכחי אינו דורש עוד תגית Assisted-by ובמקום זאת מפנה את התורמים להנחיות בנושא תוכן שנוצר על ידי כלים. עדיין מצופה מהתורמים להסביר את השימוש בכלים במכתבי הלוואי (cover letters) וביומני השינויים (changelogs). קוד שנוצר חייב להיות תואם ל-GPL-2.0-only. האדם ששולח את הטלאי בוחן אותו ונושא באחריות עליו.
הלחץ מאחורי המדיניות נובע מזמן הבדיקה. יצירת טלאי לוקחת שניות, בעוד שבדיקתו גוזלת ממתחזק אחר צהריים שלם. תגית אינה פותרת חוסר איזון זה. אישור אנושי שומר על המקוריות: ההיסטוריה ממשיכה לתעד מי חתם על כל שינוי, וזהו המאפיין שה-DCO נועד להגן עליו בשנת 2004.
מה המשמעות של היסטוריה זו עבור השרת ששכרת
- הרישיון הוא הסיבה לכך שבאפשרותך לקרוא ולבנות מחדש את ה-kernel שהספק שלך טוען, והסיבה לכך שתוכנה קניינית עדיין פועלת עליו.
- התכנון המונוליטי הוא הסיבה לכך שבאג בדרייבר יחיד יכול להפיל את המכונה כולה, והסיבה לכך שחובה לבנות מחדש מודול out-of-tree בכל שדרוג של ה-kernel.
- מודל ה-release הוא הסיבה לכך שמספר הגרסה אינו מעיד על הרבה, בעוד שה-branch ותאריך ה-end-of-life שלו מעידים על כמעט הכל.
- סוג ה-virtualisation קובע מה מותר לך לעשות בכלל: ב-KVM באפשרותך להריץ kernel משלך ולטעון מודולים, בעוד שב-container virtualisation שמשתף את ה-kernel של המארח,
uname -rמציג את הגרסה של המארח, וההרשאה להשתמש ב-modprobeאו לשנות sysctls תלויה בהרשאות ובתצורה שהמארח מעניק.
FAQ
מדוע ליבת Linux עדיין מופצת תחת רישיון GPLv2 ולא GPLv3?
Linus Torvalds החליט נגד המעבר ל-GPLv3 בשנת 2007, בעיקר בשל דרישת ה-anti-tivoisation שבה. דרישה זו מחייבת לספק מידע התקנה עבור גרסאות שעברו שינוי בקוד המוגן, אלא אם כן לא הספק ולא צד שלישי יכולים להתקין קוד שעבר שינוי (כמו במקרה של קוד הצרוב ב-ROM). הוא רואה בחומרה נעולה עניין עסקי של היצרן. בנוסף, שינוי רישיון הוא כמעט בלתי אפשרי בפועל, כיוון שזכויות היוצרים על הליבה מוחזקות על ידי אלפי תורמים ואין הסכם העברת זכויות שאפשר להסתמך עליו. הליבה מופצת תחת GPL-2.0-only, ולכן לא ניתן למזג לתוכה קוד שמוצע תחת GPLv3 בלבד.
האם ליבת Linux היא ליבה מונוליטית או מיקרו-ליבה?
מונוליטית, עם מודולים הניתנים לטעינה. מנהלי התקנים (drivers) ומערכות קבצים רצים בתוך מרחב הכתובות של הליבה, והפקודה lsmod מציגה את אלו שטעונים כרגע. התוצאה היא מהירות מצד אחד, אך "רדיוס פגיעה" גדול מצד שני: מודול תקול עלול לגרום ל-panic בכל המכונה, בעוד שבמיקרו-ליבה היה אובד רק תהליך אחד. התמונה התרככה מאז 1992 באמצעות מערכות קבצים מסוג FUSE במרחב המשתמש ותוכניות eBPF שהליבה מאמתת לפני הרצתן.
מה ההבדל בין גרסאות mainline, stable ו-longterm של הליבה?
Mainline הוא עץ הפיתוח של Torvalds, שמשתחרר כל 9 עד 10 שבועות, ושם נוחתות תכונות חדשות לראשונה. גרסת Stable לוקחת גרסת mainline ומקבלת תיקוני באגים עד לשחרור ה-mainline הבא, אלא אם הענף מתוחזק כ-longterm. ענפי Longterm ממשיכים לקבל תיקונים במשך שנים, והפצות רבות בונות את הליבות שלהן על בסיסם. האתר kernel.org מפרט את ענפי ה-longterm הנוכחיים עם תאריך סיום תמיכה משוער לכל אחד מהם.
האם ליבת Linux מקבלת קוד שנכתב על ידי בינה מלאכותית?
כן, תחת מדיניות שנכנסה לתוקף בינואר 2026. תיעוד הליבה הנוכחי כבר לא מחייב תגית Assisted-by; מצופה מהתורמים להסביר את מקור התוכן שנוצר על ידי כלים במכתבי הליווי (cover letters) וביומני השינויים (changelogs). סוכן AI אינו רשאי להוסיף שורת Signed-off-by, וקוד שנוצר חייב להיות תואם ל-GPL-2.0-only. המגיש האנושי חותם על הקוד (sign-off), מה שאומר שהוא סקר את ה-patch ולוקח עליו אחריות תחת ה-Developer Certificate of Origin.
באיזו גרסת ליבה כדאי להשתמש בשרת?
ברוב המוחלט של המקרים, בגרסה שההפצה שלך מתחזקת. ליבה של הפצה היא ענף upstream בתוספת תיקונים שבוצעו backport ובדיקות של הספק, וזה מה שהדימויים (images) של ספק הענן שלך והסכמי התמיכה שלך מניחים. בנה ליבת mainline חדשה רק כאשר אתה זקוק למנהל התקן או לתכונה ספציפית, ובדוק את תאריך סיום התמיכה של הענף שאליו אתה עובר לפני שתתחייב אליו.