הליבה מחברת את יישומי התוכנה לחומרת המחשב.
במחשבים, **ליבה** (באנגלית: **Kernel**) היא הרכיב המרכזי של מרבית מערכות ההפעלה; זהו הגשר שבין תוכניות המחשב לבין עיבוד הנתונים עצמו שמבוצע ברמת החומרה. אחד התפקידים העיקריים של הליבה הוא ניהול משאבי המערכת (התקשורת שבין רכיבי החומרה והתוכנה). בדרך כלל, בתור הרכיב הבסיסי של מערכת הפעלה, הליבה יכולה לספק את שכבת האבסטרקציה ברמה הנמוכה ביותר עבור המשאבים (בייחוד עבור מעבדים והתקני קלט-פלט) שהתוכניות צריכות לשלוט עליהם על מנת לבצע את תפקידן. בדרך כלל הליבה הופכת שירותים כאלה לזמינים עבור תהליכים של תוכניות באמצעות מנגנוני תקשורת בין תהליכים (inter-process communication) וקריאות מערכת.

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

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

תפקידיה הבסיסיים של ליבה
------------------------

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

* יחידת העיבוד המרכזית (המעבד). זהו החלק המרכזי ביותר במערכת מחשב, האחראי לריצה או ביצוע של תוכניות על גביו. בכל רגע נתון, באחריות הליבה לקבוע עבור איזו מהתוכניות הרבות שרצות יש להקצות את המעבד או המעבדים (שכל אחד מהם בדרך כלל יכול להריץ רק תוכנית אחת בו זמנית).
* זיכרון המחשב. הזיכרון משמש הן לאחסון של הוראות של תוכניות והן לאחסון של נתונים. בדרך כלל גם על ההוראות וגם על הנתונים להיות מאוחסנים בזיכרון לצורך ביצועהּ של התוכנית. בדרך כלל תוכניות רבות יבקשו גישה לזיכרון, ולעיתים קרובות ידרשו יותר זיכרון מהזיכרון הזמין שיש במחשב. באחריות הליבה לקבוע באיזה חלק מהזיכרון כל תהליך רשאי להשתמש, ולקבוע מה יש לעשות כאשר אין מספיק זיכרון זמין.
* התקני קלט-פלט (I/O) שמחוברים אל המחשב, כגון מקלדת, עכבר, כונני דיסקים, מדפסות, צגים וכולי. הליבה מעבירה בקשות לביצוע קלט/פלט מהתוכניות אל ההתקן המתאים (או לחלקים מההתקן, במקרה של קבצים על דיסק או חלונות על גבי צג), ומספקת דרכים נוחות לשימוש בהתקן (בדרך כלל תוך ביצוע הפשטה עד לרמה בה התוכנית לא צריכה לדעת את פרטי המימוש של ההתקן).

הגורמים העיקריים הדרושים לניהול משאבים הם הגדרה של מרחב כתובות (execution domain) ומנגנון הגנה שמשמש לתיווך הגישה אל המשאבים בתוך הדומיין.
בדרך כלל ליבות מספקות גם אמצעים לסנכרון ולתקשורת בין תהליכים. ליבה יכולה לממש רכיבים אלה בעצמה, או שהיא יכולה להסתמך על תהליכים מסוימים שהיא מריצה על מנת לספק שירותים אלה עבור תהליכים אחרים, אם כי במקרה כזה על הליבה לספק אמצעי כלשהו לתקשורת בין תהליכים על מנת לאפשר לתהליכים לגשת לשירותים שהם מספקים זה לזה. ולבסוף, על הליבה לספק לתוכניות הרצות אמצעי להגיש בקשות לקבלת שירותים אלה.

### ניהול תהליכים

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

כדי להריץ תוכנית, בדרך כלל הליבה מגדירה עבורה מרחב כתובות, טוענת לזיכרון את הקובץ שמכיל את הקוד של התוכנית, יוצרת מחסנית קריאות, מצביעה למיקום מסוים בתוך התוכנית ובכך מתחילה את הביצוע שלה.

ליבות התומכות בריבוי משימות מסוגלות ליצור אשליה עבור המשתמש, כאילו מספר התהליכים שרצים בו זמנית על גבי המחשב הוא גדול יותר מהמספר המקסימלי של תהליכים שהמחשב פיזית יכול להריץ בו זמנית. בדרך כלל מספר התהליכים שמערכת יכולה להריץ בו זמנית שווה למספר המעבדים שמותקנים במחשב (עם זאת, המצב יכול להיות שונה אם המעבדים תומכים בריבוי תהליכונים בו-זמנית (simultaneous multithreading).

במערכת המבוססת על ריבוי משימות מוסדר (preemptive multitasking), הליבה תיתן לכל תוכנית פרוסת זמן ותבצע מיתוג (switch) מתהליך לתהליך במהירות כזאת עד שהדבר יראה למשתמש כאילו תהליכים אלה מורצים בו זמנית. הליבה משתמשת באלגוריתמי תזמון על מנת לקבוע מה יהיה התהליך הבא שירוץ וכמה זמן יוקצה לו. האלגוריתם הנבחר יכול לאפשר לחלק מהתהליכים להיות בעלי קדימות גבוהה יותר מזו של אחרים. הליבה בדרך כלל גם מספקת לתהליכים אלה אמצעי כלשהו להתקשר; דבר זה ידוע בתור תקשורת בין תהליכים (IPC), והשיטות העיקריות לצורך כך הן זיכרון משותף, העברת מסרים והפעלת פרוצדורות מרחוק (ראו: מחשוב מקבילי).

מערכות אחרות (בייחוד על גבי מחשבים קטנים ופחות עוצמתיים) יכולות להיות מבוססות על ריבוי משימות שיתופי (cooperative multitasking), שבו כל תהליך מורשה לרוץ ללא פסיקות ("ללא הפרעה"), עד שהוא מגיש בקשה שאומרת לליבה שהיא יכולה לבצע מיתוג לתהליך אחר. בקשות כאלה נקראות yielding (ויתור), בדרך כלל הן מתרחשות בתגובה לבקשות לתקשורת בין תהליכים, או כאשר מחכים לאירוע שיתרחש. גרסאות ישנות יותר של Windows ו-Mac OS השתמשו בריבוי משימות שיתופי, אבל שתיהן עברו לעבוד בשיטת ריבוי משימות מוסדר ככל שגדלה עוצמת המחשבים שעבורם תוכננו.

מערכת ההפעלה עשויה לתמוך גם בריבוי עיבודים (multiprocessing), בארכיטקטורת ריבוי עיבודים סימטרי (Symmetric multiprocessing) או גישה לא אחידה לזיכרון (Non-Uniform Memory Access). במקרה זה, תוכניות ותהליכונים שונים יכולים לרוץ על מעבדים שונים. הליבה עבור מערכת כזאת צריכה להיות מתוכננת כך שתוכל בו זמנית להריץ בבטחה שני חלקים שונים של הקוד שלה. בדרך כלל המשמעות של כך היא שיש לספק מנגנוני סנכרון (כדוגמת spinlock) על מנת להבטיח שלא יקרה מצב בו שני מעבדים מנסים לשנות את אותם הנתונים באותו זמן.

### ניהול זיכרון

לליבה יש גישה מלאה לזיכרון המערכת ותפקידה לאפשר לתהליכים לגשת לזיכרון זה בצורה בטוחה בהתאם לדרישותיהם. בדרך כלל השלב הראשון לצורך כך הוא מיעון וירטואלי (virtual addressing), המושג בדרך כלל באמצעות דפדוף או סגמנטציה. מיעון וירטואלי מאפשר לליבה לגרום לכתובת פיזית בזיכרון להופיע בתור כתובת שונה, הכתובת הווירטואלית. מרחבי כתובות וירטואליים עשויים להיות שונים עבור תהליכים שונים; הזיכרון אליו ניגש תהליך אחד בכתובת (וירטואלית) מסוימת עשוי להיות זיכרון שונה מהזיכרון שאליו ניגש תהליך אחר באותה הכתובת. זה מאפשר לכל תוכנית להתנהג כאילו היא התוכנית היחידה (חוץ מהליבה) שרצה, ובכך מונעת מתוכניות להפיל אחת את השנייה.

במערכות רבות, הכתובת הווירטואלית של תוכנית עשויה להצביע לנתונים שלא נמצאים כרגע בזיכרון. שכבה נוספת זו של פעילות עקיפה המסופקת על ידי מיעון וירטואלי מאפשרת למערכת ההפעלה להשתמש באמצעי אחסון אחרים, כגון דיסק קשיח, על מנת לאחסן נתונים שאחרת היו חייבים להישאר בזיכרון הראשי (RAM). כתוצאה מכך, מערכות הפעלה יכולות לאפשר לתוכניות להשתמש ביותר זיכרון מהזיכרון הפיזי הפנוי במערכת. כאשר תוכנית זקוקה לנתונים שלא מאוחסנים כרגע בזיכרון ה-RAM, המעבד מאותת לליבה על כך שהדבר התרחש, והליבה מגיבה על ידי כתיבה לדיסק של התוכן של בלוק בזיכרון שלא נמצא כרגע בשימוש (אם הדבר נדרש) ואז מחליפה תוכן זה בנתונים שהתבקשו על ידי התוכנית. לאחר מכן התוכנית יכולה להמשיך לרוץ מהנקודה שבה היא נעצרה. שיטה זו ידועה כדפדוף לדרישה (demand paging).

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

### ניהול התקנים

כדי לעשות פעילות מועילה כלשהי, לתהליכים צריכה להיות גישה לציוד ההיקפי (peripherals) שמחובר למחשב. ציוד היקפי זה נשלט על ידי הליבה באמצעות מנהלי התקנים (device drivers). מנהל התקנים (דרייבר) הוא תוכנת מחשב המאפשרת למערכת ההפעלה ליצור אינטראקציה עם התקן חומרה כלשהו. מנהל ההתקנים מספק למערכת ההפעלה מידע כיצד לשלוט על יחידת חומרה מסוימת ואיך לתקשר איתה. לדרייבר חשיבות מכרעת עבור תוכנית יישומים. המטרה בתכנון מנהל התקנים היא ליצור אבסטרקציה על ידי תרגום קריאות של פונקציות (function/programming calls) היוצאות ממערכת ההפעלה, לקריאות הספציפיות עבור התקן מסוים. עקרונית, התקן אמור לעבוד באופן תקין עם מנהל ההתקנים המתאים עבורו. בדרך כלל מהנדסים כותבים את הקוד עבור מנהלי התקנים. הם פועלים על: כרטיסי מסך, כרטיסי קול, מדפסות, סורקים, מודמים, כרטיסי רשת, ועוד.

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

על הליבה להחזיק ברשימה של כל ההתקנים הזמינים. רשימה זו יכולה להיות ידועה מראש (למשל במערכת משובצת מחשב שבה הליבה תיכתב מחדש אם החומרה תשתנה); יכולה להיות מוגדרת על ידי המשתמש (טיפוסי למחשבים אישיים ישנים ובמערכות שלא מיועדות לשימוש אישי); או שהיא מזוהה על ידי מערכת ההפעלה בזמן ריצה - הכנס-הפעל (plug and play). במערכת הכנס-הפעל, מנהל ההתקנים תחילה מבצע סריקה על אפיקי חומרה שונים, כגון PCI ו-USB על מנת לזהות התקנים מותקנים, ואז מחפש אחר הדרייברים המתאימים.

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

### קריאות מערכת

קריאת מערכת (system call) היא מנגנון המשמש תוכניות לצורך בקשת שירות ממערכת ההפעלה. הן משתמשות בהוראות בשפת מכונה אשר גורמות למעבד לשנות מצב. דוגמה לכך יכולה להיות מעבר בין המצבים supervisor mode ל-protected mode. כאן מערכת ההפעלה מבצעת פעולות כמו גישה להתקני חומרה או ליחידת ניהול הזיכרון (MMU). בדרך כלל מערכת ההפעלה מספקת ספרייה שיושבת בינה לבין התוכניות הרגילות. בדרך כלל זוהי ספרייה בשפת C כמו glibc או Windows API. הספרייה מטפלת בפרטים ברמה הנמוכה (low level) של העברת מידע אל הליבה ומעבר למצב משגוח (supervisor mode). קריאות מערכת נפוצות הן: close, open, read, write.

כדי לעשות פעילות מועילה כלשהי, על התהליך להיות מסוגל לגשת לשירותים שמספקת הליבה. דבר זה ממומש באופן שונה על ידי כל ליבה, אבל רובן מספקות ספרייה - C standard library, או ממשק תכנות יישומים (API), שבתורם קוראים לפונקציות של הליבה.

סוגי ליבות
----------

### ליבה מונוליטית

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

ליבות מונוליתיות, אשר באופן מסורתי שימשו במערכות הפעלה דמויות-יוניקס, מכילות את כל פונקציות הליבה של מערכת ההפעלה ואת מנהלי ההתקנים (תוכניות קטנות שמאפשרות למערכת ההפעלה לתקשר עם התקני חומרה כגון כונני דיסקים, כרטיסים גרפיים ומדפסות). זהו העיצוב המסורתי של מערכות UNIX. ליבה מונוליטית היא תוכנה אחת שמכילה את כל הקוד הדרוש לביצוע כל המשימות שקשורות לליבה. כל חלק שלא ניתן לגשת אליו על ידי רוב התוכניות ושלא ניתן להכניסו לתוך ספרייה יימצא במרחב הליבה: מנהלי התקנים, מתזמנים, ניהול זיכרון, מערכות קבצים, מחסניות רשת, ועוד. קריאות מערכת רבות מסופקות לתוכניות על מנת לאפשר להן גישה לכל השירותים הנ"ל. אף על פי שתחילה ליבות מונוליטית היו עמוסות בתתי-מערכות שאולי לא היה בהן צורך, ניתן היה לכוונן אותן לרמה בה הן פועלות באותה המהירות או אף מהר יותר מליבה שתוכננה ספציפית עבור חומרה מסוימת. ליבות מונוליתיות מודרניות כגון הליבות של לינוקס ו-FreeBSD (שתי מערכות הפעלה הנכנסות לקטגוריית מערכות הפעלה דמויות-יוניקס), כוללות את היכולת לטעון מודולים בזמן ריצה, ובכך מאפשרות הרחבה פשוטה של יכולות הליבה בהתאם לדרישה, ועוזרות להקטין את כמות הקוד שרץ במרחב הליבה. מהיתרונות שנזקפים לטובת הליבות המונוליטיות:

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

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

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

* תכנות במרחב הליבה הוא קשה מאחר שלא ניתן להשתמש בספריות המקובלות (כמו libc על כל שירותיה). דיבוּג הוא קשה אף יותר (קשה להשתמש במנפה שגיאות ברמת הקוד כמו GDB). אתחול של המחשב נדרש לעיתים קרובות. זוהי איננה רק בעיית נוחיות עבור המפתחים. ניפוי השגיאות קשה יותר, וככל שהקשיים נעשים רציניים יותר, כך גם עולה הסבירות שהקוד יכיל יותר באגים.
* לבאגים בחלק מסוים בליבה יכולות להיות תופעות לוואי חמורות. מאחר שלכל פונקציה בליבה יש את כל ההרשאות, באג בפונקציה כלשהי יכול לפגוע במבנה נתונים בחלק אחר ובכלל לא קשור של הליבה, או בכל תוכנית אחרת שרצה.
* לעיתים קרובות ליבות הופכות לענקיות וקשות מאוד לתחזוקה.
* אפילו אם קיימת חלוקה למודולים נפרדים, האינטגרציה של הקוד יכולה להיות קשה לביצוע.
* מכיוון שהמודולים רצים באותו מרחב כתובות, באג באחד מהם עלול להפיל את המערכת כולה.
* עוד חיסרון של ליבות מונוליתיות הוא בכך שהן לא יבילות. כלומר יש לשכתב אותן עבור כל ארכיטקטורה שמערכת ההפעלה תפעל עליה.

### מיקרו ליבה

מיקרו-ליבה
מיקרו-ליבה (microkernel, µK) הוא מונח המתאר גישה לתכנון מערכות הפעלה, בה הפונקציונליות של המערכת מועברת החוצה מה"ליבה" המסורתית, אל קבוצה של "שרתים" אשר מתקשרים דרך ליבה "מינימלית", ובכך משאירה כמה שניתן פחות ב"מרחב המערכת" וכמה שיותר ב"מרחב המשתמש". מיקרו-ליבה אשר מתוכננת עבור פלטפורמה או מכשיר ספציפי, תמיד תכיל אך ורק את הדרוש לה על מנת לפעול. תפישת המיקרו-ליבה כוללת הגדרה של אבסטרקציה פשוטה של החומרה, ביחד עם קבוצה של פרימיטיבים או קריאות מערכת כדי לממש שירותי מערכת הפעלה מינימליים כגון ניהול זיכרון, ריבוי משימות ותקשורת בין תהליכים. שירותים אחרים, כולל אלו שבדרך כלל מסופקים על ידי הליבה, כמו רישות (networking), ממומשים בתוכניות שרצות במרחב המשתמש, המכונות שרתים. מיקרו-ליבות הן פשוטות יותר לתחזוקה לעומת ליבות מונוליתיות, אבל המספר הגדול של קריאות מערכת והחלפות הקשר עלול להאט את המערכת מכיוון שהן בדרך כלל דורשות יותר משאבים לעומת קריאות פשוטות של פונקציות.

רק החלקים שבאמת חייבים לעבוד במצב עם הרשאות מלאות (privileged mode) נמצאים במרחב הליבה: תקשורת בין תהליכים (IPC), המתזמן הבסיסי או פרימיטיבים של תזמון, ניהול זיכרון בסיסי, פרימיטיבים בסיסיים לקלט/פלט. במקרה זה חלקים קריטיים רבים רצים במרחב המשתמש: המתזמן המלא, ניהול זיכרון, מערכות קבצים ומחסניות רשת. מיקרו-ליבות הומצאו בתגובה לעיצוב ה"מונוליטי" של ליבות, שבו כל הפונקציונליות של המערכת הוכנסה לתוך תוכנה סטטית אחת, אשר רצה במצב "מערכת" מיוחד של המעבד. במיקרו-ליבה מתבצעות רק המשימות הבסיסיות ביותר, כמו היכולת לגשת לחלק מרכיבי החומרה (לא בהכרח אל כולם), ניהול זיכרון, וניהול העברת מסרים בין תהליכים. מהיתרונות של מיקרו-ליבות:

* בדרך כלל התחזוקה פשוטה יותר.
* ניתן לבחון תיקונים חדשים ביחידה נפרדת, ולאחר מכן להכניס אותם במקום יחידה קודמת במערכת שכבר נמצאת בייצור (production).
* זמן פיתוח מהיר יותר.
* במערכות הפעלה רבות יש קוד ליבה מודולרי שאפשר להוריד ולטעון ללא צורך באתחול הליבה.
* עמידות גבוהה יותר בתקלות (שרידות; persistence). ניתן להריץ יותר מיחידה אחת ובמקביל, ואם אחת משתבשת, להפעיל את השנייה.

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

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

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

* צריכת זיכרון גבוהה.
* נדרשות יותר תוכנות להתממשקות, מה שיכול להוביל לירידה בביצועים.
* באגים בהעברת מסרים יכולים להיות קשים יותר לתיקון בגלל המסלול הארוך יותר שעל המסרים לעבור לעומת המצב של עותק יחיד בליבה מונוליטית.
* ניהול תהליכים עשוי להיות מאוד מסובך.

מיקרו-ליבה מאפשרת לממש את יתר מערכת ההפעלה כתוכנית יישומים רגילה, הנכתבת בשפה עילית. כמו כן ניתן להריץ מערכות הפעלה שונות על גבי אותה הליבה שאיננה משתנה. ניתן להחליף דינאמית בין מערכות הפעלה ושתהיה יותר ממערכת אחת פעילה בו זמנית.

הגישה של מיקרו-ליבות הייתה נפוצה מאוד בחוגי האקדמיה בשנות השמונים והתשעים של המאה העשרים[דרוש מקור], בשנים שבהן תוכננו רבות ממערכות ההפעלה שמשתמשים בהן היום. כתוצאה מכך הן מערכת ההפעלה Windows NT (שממנה נוצרו כל הגרסאות השולחניות המודרניות של מערכת חלונות) והן מערכת Mac OS X שנמצאת במחשבי מקינטוש מודרניים, תוכננו במקור כמערכות מיקרו-ליבה[דרוש מקור]. אולם בהמשך נזנחה הגישה הזו ובשתי המערכות הללו יש בפועל ליבה מונוליטית[דרוש מקור: נקודה שנויה במחלוקת, בפרט לגבי OSX, שם המצב מסובך קצת יותר].

דוגמאות למערכות הפעלה שבנויות מעל מיקרו-ליבה:

* QNX - משמשת בעיקר במערכות מבוזרות, אך גם בכמה טלפוני בלקברי.‏
* HURD - הייתה אמורה להיות מערכת ההפעלה של פרויקט גנו. בפועל ירשה גנו/לינוקס את מקומה. המערכת עדיין בפיתוח אולם אין לה כמעט שימוש. במערכת HURD משתמשים במיקרו-ליבה Mach שמספקת רק מיפוי כתובות והעברת הודעות.
* מיניקס.

ראו גם
------

* מעטפת
* dmesg

קישורים חיצוניים
----------------

ויקישיתוף מדיה וקבצים בנושא **ליבה** בוויקישיתוף

|  |  |
| --- | --- |
| בקרת זהויות עריכת הנתון בוויקינתונים | 
* GND: 4338679-9
* NKC: ph667013

 |