1. מערכות הפעלה תרגול 10 – זיכרון וירטואלי ב- Linux

2. מערכות הפעלה - תרגול 102 (c) ארז חדד 2003 תוכן התרגול מבוא לזיכרון וירטואלי ב-Linux זיכרון וירטואלי ב-IA32  סגמנטציה  דפדוף (Paging)  TLB ניהול זיכרון וירטואלי ב-Linux  שימוש מנוון בסגמנטציה  מודל אחיד לטבלת דפים  מיקום מרחב הזיכרון של הגרעין  טיפול ב-TLB

3. מערכות הפעלה - תרגול 103 (c) ארז חדד 2003 מבוא לזיכרון וירטואלי ב-Linux (1) במחשב יש בד"כ זיכרון פיזי ראשי (אלקטרוני) קטן בהרבה מהזיכרון הפיזי המשני (דיסק)  הבדל של 3 סדרי גודל: MB לעומת GB מטרת מנגנון הזיכרון הוירטואלי היא לאפשר לכל תהליך מרחב זיכרון פרטי שאינו מוגבל בגודל הזיכרון הראשי של המחשב  ב-Linux – מרחב זיכרון וירטואלי לכל תהליך בגודל 2 32 = 4GB כדי להשיג מטרה זו, מנצל מנגנון הזיכרון הוירטואלי את הזיכרון המשני כהרחבה של הזיכרון הראשי  הרעיון: לפנות לדיסק את אותם חלקים מהזיכרון הוירטואלי של כל תהליך שאינם בשימוש כרגע יעילותו של מנגנון הזיכרון הוירטואלי נובעת מעקרון הלוקליות: על- פני פרקי זמן קצרים, תהליך ניגש בד"כ רק לחלק קטן מאוד ממרחב הזיכרון העומד לרשותו

4. מערכות הפעלה - תרגול 104 (c) ארז חדד 2003 מבוא לזיכרון וירטואלי ב-Linux (2) ע"י אחסון רק החלק ה"פעיל" של מרחב הזיכרון של תהליך:  ניתן להריץ יישום שדרישות הזיכרון שלו גדולות בהרבה מהזיכרון הפיזי  ניתן להריץ מספר רב של יישומים כנ"ל באותו מחשב עם זיכרון פיזי קטן יחסית החסרון של השיטה: הגדלה משמעותית של זמן הביצוע של תהליך, כתוצאה מהצורך לבצע תחלופה של קטעי זיכרון בין הזיכרון הראשי והדיסק מנגנון זיכרון וירטואלי דורש תמיכה של החומרה  תרגום בין כתובת לוגית לכתובת פיזית  זיהוי גישה לזיכרון וירטואלי שאינו מצוי בזיכרון הראשי

5. מערכות הפעלה - תרגול 105 (c) ארז חדד 2003 ניהול זיכרון ב-IA32 (1) כזכור מתרגולים קודמים, על-מנת לגשת לזיכרון יש לספק כתובת לוגית בפורמט segment:offset  segment: מספר בן 16 ביט המזהה "איזור זיכרון" של התהליך  offset: מספר בן 32 ביט המזהה תא זיכרון מסוים באיזור הזיכרון המבוקש כתובת לוגית זו עוברת תרגום בחומרה לכתובת פיזית: כתובת תא בזיכרון הראשי (האלקטרוני) של המחשב מנגנון סגמנטציה מנגנון דפים כתובת לוגית segment:offset כתובת ליניארית (32 ביט) כתובת פיזית (32/36 ביט)

6. מערכות הפעלה - תרגול 106 (c) ארז חדד 2003 ניהול זיכרון ב-IA32 (2) מודל הזיכרון הוא כדלקמן:  מוגדר מרחב זיכרון ליניארי - "שטוח" - במיעון 32 ביט, כלומר בגודל עד 4GB הכתובת הליניארית היא כתובת תא במרחב זיכרון זה מנגנון הדפים ממפה את המרחב הליניארי לאוסף דפים נפרד לכל תהליך – כך מושגת ההפרדה בין איזורי הזיכרון של התהליכים  מעל מרחב זיכרון זה מוגדרת חלוקה לסגמנטים, שהם "איזורי הזיכרון" שלמדנו עד כה תיתכן חפיפה חלקית או מלאה בין סגמנטים לא נשתמש יותר במושג "איזור זיכרון" אלא במושג סגמנט, כדי לא לבלבל עם מושג איזור הזיכרון של Linux שנפגוש בהמשך

7. מערכות הפעלה - תרגול 107 (c) ארז חדד 2003 סגמנטציה ב-IA32 (1) לכל סגמנט יש רשומה הקרויה מתאר הסגמנט (segment descriptor) ומכילה:  כתובת הבסיס (הליניארית) של הסגמנט  גודל הסגמנט (בדפים או בבתים)  סוג הסגמנט, לקביעת הרשאות הגישה לדוגמה: בסגמנט של קוד מותר לקרוא ולהריץ נתונים בלבד. בסגמנט נתונים מותר לקרוא ולכתוב נתונים בלבד סוגים קיימים: קוד, נתונים, TSS (מתרגול החלפת הקשר..) ועוד  DPL – ערך CPL מקסימלי לגישה לסגמנט הגבלת הגישה לקוד תהליכי משתמש לסגמנטים של הגרעין ניהול זיכרון ב-IA32

8. מערכות הפעלה - תרגול 108 (c) ארז חדד 2003 סגמנטציה ב-IA32 (2) כל מתארי הסגמנטים מאוחסנים בטבלה הקרויה GDT (Global Descriptor Table) המוצבעת מרגיסטר מיוחד הקרוי gdtr ערכו של רגיסטר סגמנט (cs, ds, …) נקרא segment selector ומכיל שדה של אינדקס מתאר הסגמנט ב-GDT התרגום מכתובת לוגית לליניארית הינו, לפיכך, פשוט ביותר: המעבד שולף את כתובת הבסיס ממתאר הסגמנט המוצבע מרגיסטר הסגמנט ומוסיף לה את ערך ה-offset  פעולה זו כרוכה בבדיקת הרשאות לפי סוג הפעולה וה-CPL, ובבדיקת אי-גלישה מהסגמנט ניהול זיכרון ב-IA32

9. מערכות הפעלה - תרגול 109 (c) ארז חדד 2003 סגמנטציה ב-IA32 (3) DPLסוגגודלכתובת בסיס כניסה 3קוד0x30x10000x5 זיכרון ליניארי GDT *נניח שגודל הסגמנט כתוב בכפולות של 4K (גודל דף) 0x1000 0x3fff 0x152 : index=0x5 segment selectoroffset 0x1152 + ניהול זיכרון ב-IA32

10. מערכות הפעלה - תרגול 1010 (c) ארז חדד 2003 ניהול דפים ב-IA32 (1) מנגנון ניהול הדפים ב-IA32 הוא זה המאפשר:  יצירת מרחבי זיכרון שונים ובלתי תלויים זה בזה  אי הגבלת הזיכרון הוירטואלי בגודל הזיכרון הראשי  טעינת קטעים מזכרון התהליך לפי הצורך (page fault) מרחב הזיכרון הוירטואלי של תהליך מחולק לדפים – קטעי זיכרון עוקבים בעלי גודל קבוע  בד"כ 4KB כל דף יכול להמצא בזיכרון או במאגר דפדוף (swap) בדיסק ניהול זיכרון ב-IA32

11. מערכות הפעלה - תרגול 1011 (c) ארז חדד 2003 ניהול דפים ב-IA32 (2) הזיכרון הראשי (הפיזי) של המחשב מחולק למסגרות בגודל דף כאשר דף נמצא בזיכרון הראשי, הוא משובץ למסגרת כלשהי עבור כל תהליך מוחזק, לפי הצורך, רק חלק מהדפים שלו בזיכרון הראשי בכל זמן נתון  רק הדפים שנמצאים בשימוש התהליך "לאחרונה"  כך מושג אפקט הוירטואליות: הרצת מספר תהליכים עם דרישת זיכרון כוללת או בנפרד גדולה מהזיכרון הראשי טבלת הדפים (page table) של כל תהליך מנהלת את הדפים של התהליך  האם הדף נמצא בזיכרון ובאיזו מסגרת ניהול זיכרון ב-IA32

12. מערכות הפעלה - תרגול 1012 (c) ארז חדד 2003 ניהול דפים ב-IA32 (3) בתרגום כתובת ליניארית לכתובת פיזית:  המעבד מחשב תחילה באיזה דף נמצאת הכתובת הליניארית ואת מרחקה מתחילת הדף (offset)  המעבד בודק בטבלת הדפים באיזה מסגרת נמצא הדף  הכתובת הפיזית היא כתובת תחילת המסגרת + offset אם הדף המכיל את הכתובת אינו נמצא בזיכרון, נוצרת חריגה מסוג page fault הגורמת לגרעין מערכת ההפעלה להביא את הדף לזיכרון  בסיום הטיפול בפסיקה מבוצעת מחדש ההוראה שגרמה לפסיקה ניהול זיכרון ב-IA32

13. מערכות הפעלה - תרגול 1013 (c) ארז חדד 2003 טבלת הדפים ב-IA32 (1) טבלת הדפים של תהליך מוצבעת מרגיסטר מיוחד בשם cr3 הטבלה אמורה להכיל כניסה בגודל 4 בתים עבור כל דף במרחב הזיכרון של התהליך  כניסה של דף שלא הוקצה לשימוש מכילה ערך NULL (כל הביטים 0) כדי למפות 4GB בדפים של 4KB צריך מיליון כניסות – גודל הטבלה יכול להגיע ל-4MB לכל תהליך עם זאת, תהליך מנצל בדרך-כלל רק חלק מזערי ממרחב הזיכרון הוירטואלי – לא כדאי להחזיק את הטבלה כולה  הפתרון: להחזיק שתי רמות היררכיה (או יותר) בטבלה  אם מוקצה דף חדש לשימוש התהליך, צריך להקצות, לפי הצורך, דפים נוספים לטבלאות ביניים בהיררכיה עד (לא כולל) השורש  מבנה טיפוסי: שתי רמות היררכיה, כמוצג בשקף הבא ניהול זיכרון ב-IA32

14. מערכות הפעלה - תרגול 1014 (c) ארז חדד 2003 31222112110 cr3 Page Directory Page DIRECTORYTABLEOFFSET + + Page Table +

15. מערכות הפעלה - תרגול 1015 (c) ארז חדד 2003 טבלת הדפים ב-IA32 (3) כל כניסה של דף בטבלת הדפים (בכל רמת היררכיה) מכילה:  ביט present: מציין האם הדף נמצא בזיכרון מקביל לביט valid מההרצאה  מספר המסגרת בה מאוחסן הדף אם הוא בזיכרון (20 ביטים כאשר הזיכרון הפיזי ממען 32 ביט)  ביט accessed: מודלק ע"י החומרה בכל פעם שמתבצעת גישה לכתובת בדף מקביל לביט reference מההרצאה  ביט dirty: מודלק ע"י החומרה בכל פעם שמתבצעת כתיבה לנתון בדף מקביל לביט modified מההרצאה  ביט read/write: הרשאת גישה. 0 = קריאה בלבד. 1 = קריאה וכתיבה  ביט user/supervisor: גישה מיוחסת. 0 = גישה אם CPL < 3. 1 = גישה בכל ערך CPL  ועוד ניהול זיכרון ב-IA32

16. מערכות הפעלה - תרגול 1016 (c) ארז חדד 2003 TLB ב-IA32 כמקובל בארכיטקטורות חומרה רבות התומכות ב- paging, גם ב-IA32 ממומש Translation Lookaside Buffer (TLB) זהו מטמון (cache) של כניסות בטבלת הדפים הצמוד לכל מעבד, שמטרתו לחסוך תרגומים חוזרים של אותה כתובת ליניארית לפיזית  חוסך את הגישה לזיכרון (כפול מספר רמות ההיררכיה) לצורך חישוב בכל החלפת הקשר (למעשה, בכל טעינת ערך חדש ל- cr3) מבוצעת פסילה (invalidation) אוטומטית של תוכן ה-TLB של המעבד ניהול זיכרון ב-IA32

17. מערכות הפעלה - תרגול 1017 (c) ארז חדד 2003 ניהול זיכרון ב-Linux (1) Linux מנצלת את מנגנון הדפים למימוש זיכרון וירטואלי, אך נמנעת משימוש בסגמנטציה  משתמשת רק במינימום ההכרחי על-פי הגדרות החומרה: כל ה- segment registers בכל התהליכים מצביעים לאותם סגמנטים המכסים כולם אותו תחום – כל התחום הליניארי  סיבה 1: אי-תלות בחומרה: Linux רצה גם בארכיטקטורות חומרה אחרות שתומכות בדפים אבל לא בסגמנטציה  סיבה 2: פשטות: מימוש מנגנון שאינו מצריך עדכון segment registers בהחלפת הקשר או בגישה ממרחב הזיכרון של הגרעין לזה של תהליך

18. מערכות הפעלה - תרגול 1018 (c) ארז חדד 2003 ניהול זיכרון ב-Linux (2) למעשה, Linux מגדירה רק 4 סגמנטים:  סגמנט קוד וסגמנט נתונים עבור הגרעין (DPL=0)  סגמנט קוד וסגמנט נתונים עבור כל תהליכי המשתמש (DPL=3)  ההחלפה בין הסגמנטים (ברגיסטרים cs לקוד ו-ds, es, ss לנתונים) מתבצעת במעבר בין kernel mode ו-user mode כל הסגמנטים, כאמור, מכסים את כל התחום הוירטואלי (כתובת בסיס = 0x0, גודל בדפים = 0xfffff)  כתובת לוגית (offset בלבד) = כתובת ליניארית כמו כן, מוגדר סגמנט TSS עבור כל אחד מהמעבדים כפי שראינו בתרגול על החלפת הקשר

19. מערכות הפעלה - תרגול 1019 (c) ארז חדד 2003 ניהול זיכרון ב-Linux (3) כאמור, מערכת הזיכרון הוירטואלי של Linux מבוססת על דפים Linux מגדירה היררכיה כללית של 3 רמות של טבלת דפים, הניתנת להתאמה לכל ארכיטקטורת חומרה קיימת  הרמה הגבוהה ביותר נקראת Page Global Directory (PGD). יש טבלה כזו לכל תהליך  הרמה האמצעית נקראת Page Middle Directory (PMD)  הרמה התחתונה נקראת Page Table Entry (PTE)  טבלאות נוספות בשתי הרמות הנמוכות מוקצות לפי הצורך יחד עם הקצאת דפים חדשים לתהליך

20. מערכות הפעלה - תרגול 1020 (c) ארז חדד 2003 GLOBALDIRMIDDLEDIRTABLE OFFSET + + + + base register Page Global Directory Page Middle Directory Page Table Page

21. מערכות הפעלה - תרגול 1021 (c) ארז חדד 2003 ניהול זיכרון ב-Linux (5) כיצד מתמפה היררכית 3 רמות של Linux להיררכית 2 רמות טיפוסית של IA32 שראינו קודם?  ה-PGD מתמפה ל-Directory (10 ביטים עליונים)  ה-PMD מוגדרת כמכסה 0 ביטים: טבלה ברמת PMD מוגדרת כמכילה כניסה אחת שנמצאת בזיכרון באותו מקום כמו הכניסה ב-PGD שמצביעה עליה  ה-PTE מתמפה ל-Table (10 ביטים אמצעיים)  גודל דף מוגדר כ-4KB (12 ביטים נמוכים משמשים כ- offset)

22. מערכות הפעלה - תרגול 1022 (c) ארז חדד 2003 מרחב הזיכרון של הגרעין (1) הזיכרון שבשימוש גרעין Linux לעולם אינו מפונה לדיסק (swapped)  זיכרון זה כולל את טבלאות הדפים של התהליכים מרחב הזיכרון של הגרעין ממופה לקטע קבוע של הזיכרון הוירטואלי של כל תהליך  באופן זה, הכתובת (הלוגית) של כל אוביקט בגרעין נשארת קבועה בכל מרחבי הזיכרון של תהליכי המשתמש  מסיבה זו ומפני שאין הפרדה באמצעות סגמנטים, ניתן להעביר לגרעין פרמטרים מסוג מצביע המכילים offset (32 ביט) בלבד – ללא סגמנט  קטע הזיכרון הליניארי המשמש את הגרעין הוא מהכתובת 0xc0000000 ומעלה ("הג'יגהבייט הרביעי"), המוגדרת בקבועים PAGE_OFFSET ו- TASK_SIZE קבועים אלו מוגדרים בקבצי הגרעין include/asm-i386/page.h ו- include/asm-i386/processor.h בהתאמה ניהול זיכרון ב-Linux

23. מערכות הפעלה - תרגול 1023 (c) ארז חדד 2003 מרחב הזיכרון של הגרעין (2)  לפיכך, לרשות תהליך המשתמש עומדים 3GB זיכרון וירטואלי להקצאה לשימוש הגרעין מחזיק טבלת דפים משלו הקרויה Kernel Master Page Global Directory  טבלה זו מתעדכנת בכל פעם שהגרעין מקצה ומשחרר דפים לשימוש עצמו בלבד  אף תהליך לא משתמש בטבלה זו – תפקידה הוא לשמש כמקור ממנו מתעדכנות טבלאות הדפים של תהליכי המשתמש בכל הנוגע לדפים שבשימוש הגרעין  על עדכון טבלאות הדפים של תהליכי המשתמש מתוך טבלת הדפים של הגרעין נלמד בהמשך ניהול זיכרון ב-Linux

24. מערכות הפעלה - תרגול 1024 (c) ארז חדד 2003 טיפול ב-TLB ב-Linux ישנם מצבים בהם גרעין Linux מצליח להימנע מפסילת כל תוכן ה- TLB בעת ביצוע החלפת הקשר:  כאשר התהליך הבא לביצוע חולק את אותו מרחב זיכרון (אותן טבלאות דפים) יחד עם התהליך הקודם..כלומר, כאשר מדובר בשני חוטים של אותו יישום  כאשר התהליך הבא לביצוע הוא חוט גרעין (kernel thread) כמו init או ksoftirq_CPUn לתהליכי/חוטי גרעין אלו אין מרחב זיכרון משלהם – הם פועלים על מרחב הזיכרון של הגרעין. עם זאת, חוט גרעין מנצל את טבלאות הדפים של תהליך המשתמש שרץ לפניו, מפני שאין לו טבלאות דפים משלו מאידך, ישנם מצבים בהם גרעין Linux חייב לפסול בעצמו כניסות ב-TLB:  כאשר מתבצע עדכון של רשומה בטבלת הדפים המופיעה גם ב-TLB, כמו למשל בטעינת דף או בפינוי דף ניהול זיכרון ב-Linux