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