1. מערכות הפעלה תרגול 2 – קריאות מערכת ב-Linux

2. מערכות הפעלה - תרגול 22 (c) ארז חדד 2003 תוכן התרגול קריאה לפונקציות ב-Linux קריאה לשירותי מערכת ב-Linux

3. מערכות הפעלה - תרגול 23 (c) ארז חדד 2003 תזכורת - תכנית Linux ראשונה #include int main() { char *str=“Hello”; printf(“%s World!\n”, str); return 0; } hello.c

4. מערכות הפעלה - תרגול 24 (c) ארז חדד 2003 קריאה לפונקציה ב-Linux (1) כיצד נראית המחסנית בביצוע הקריאה לפונקציה printf() בתכנית hello.c?  תרשים בשקף הבא

5. מערכות הפעלה - תרגול 25 (c) ארז חדד 2003 כתובות גבוהותהתחלת המחסנית.... 4 בתים str 4 בתים מצביע על מחרוזת הפורמט 4 בתים כתובת חזרה מ - printf גידול המחסנית ebp החדש 4 בתים ebp הישן 4 בתים esi הישן 4 בתים edi הישן 4 בתים ebx הישןמסגרת הפונקציה משתנים מקומיים של printf......... כתובות נמוכות

6. מערכות הפעלה - תרגול 26 (c) ארז חדד 2003 קריאה לפונקציה ב-Linux (2) קריאה לפונקציה ב-Linux מבוססת על סגנון הקריאה לפונקציות של שפת C (C Calling Convention)  תחילה הפרמטרים של הפונקציה מוכנסים למחסנית בסדר הפוך (הפרמטר הימני ביותר ראשון)  כעת מתבצעת הוראת המכונה call שדוחפת את כתובת החזרה (ערכו של eip) למחסנית וקופצת לתחילת הפונקציה printf() על-ידי הצבת כתובת תחילת הפונקציה ל-eip near call - קריאה לפונקציה באותו איזור זיכרון – מוכנס למחסנית ה- offset בלבד ומעודכן רק ערכו של eip (ולא cs)

7. מערכות הפעלה - תרגול 27 (c) ארז חדד 2003 קריאה לפונקציה ב-Linux (3)  הקוד של הפונקציה הנקראת (במקרה זה printf()) חייב לשמור את ערכי הרגיסטרים ebp, esi, edi, ebx במקרה שהוא משתמש בהם, ולשחזר את ערכם בסיום ביצוע הפונקציה  הפונקציה הנקראת שומרת תחילה את ebp במחסנית ואז מציבה את ebp להצביע על ראש המחסנית (שמכיל את ערכו הקודם של ebp). לאחר מכן נשמרים שאר הרגיסטרים לפי הצורך  אחרי שמירת הרגיסטרים מוקצה על המחסנית מקום למשתנים המקומיים של הפונקציה הנקראת ע"י הקטנת ערכו של esp בגודל המקום הנדרש. כך מובטח שבחזרה מהפונקציה ישוחררו אוטומטית כל המשתנים המקומיים

8. מערכות הפעלה - תרגול 28 (c) ארז חדד 2003 קריאה לפונקציה ב-Linux (4) לרגיסטר ebp יש תפקיד מיוחד בקריאה לפונקציה: הוא מצביע על בסיס מסגרת הפונקציה, כלומר על המקום במחסנית בו מתחילה שמירת הנתונים של הפונקציה הנקראת  ניתן לראות ריצה של תכנית דרך המחסנית כהרכבה והסרה של מסגרות פונקציה זו על גבי זו ברשימה מקושרת, מעין "מחסנית של מסגרות". ערכו של רגיסטר ebp השמור במחסנית בכל מסגרת מצביע על בסיס המסגרת שלפניה בהתאם לכך, כל מיקומי הפרמטרים והמשתנים המקומיים של הפונקציה נגישים כערכים יחסיים לערכו של ebp  לדוגמה: הפרמטר הראשון (משמאל) של הפונקציה נגיש דרך הכתובת ss:[ebp+8]

9. מערכות הפעלה - תרגול 29 (c) ארז חדד 2003 קריאה לפונקציה ב-Linux (5) לפני סיום ביצוע הפונקציה משוחזרים ערכי הרגיסטרים שנשמרו על-ידי הפונקציה הנקראת בסיום ביצוע הפונקציה מתבצעת פקודת ret ששולפת את כתובת החזרה לקוד הקורא מהמחסנית וקופצת לכתובת זו על-ידי הצבתה ל-eip. באחריות הקוד הקורא לפונקציה לשמור את כל הרגיסטרים שבשימושו ושאינם באחריות הפונקציה הנקראת. רגיסטרים אלו משוחזרים לאחר החזרה מהפונקציה הקוד הקורא אחראי גם לפינוי הפרמטרים ע"י הגדלת esp

10. מערכות הפעלה - תרגול 210 (c) ארז חדד 2003 קריאה לפונקציה ב-Linux (6) הפונקציה מחזירה ערך בסיום (אם יש כזה) לפי הכללים הבאים: ערך בגודל עד 8 ביט – מוחזר ב-al ערך בגודל עד 16 ביט – מוחזר ב-ax ערך בגודל עד 32 ביט – מוחזר ב-eax (זהו המקרה הנפוץ) ערך בגודל עד 64 ביט – מוחזר בצמד edx:eax אם הפונקציה אמורה להחזיר ערך שהוא רשומה מורכבת (struct), אז המקום עבור גודל הערך מוקצה מראש על המחסנית על-ידי הקוד הקורא לפונקציה כפרמטר חבוי, והפונקציה מעדכנת את תוכן הרשומה במחסנית לפני סיום ביצועה ערך מוחזר מסוג floating-point מאוחסן ברגיסטרים מיוחדים של היחידה המתימטית (ALU) של המעבד

11. מערכות הפעלה - תרגול 211 (c) ארז חדד 2003 קריאה לפונקציה ב-Linux (7) נגדיר את הפונקציה my_add() שמבצעת חיבור באופן הבא: int my_add(int x, int y); בשקף הבא מופיע מימוש של פונקציה זו בשפת המכונה של 80386 ב-Linux  המימוש מוצג בפורמט GNU Assembler שימו לב: קומפיילר C מוסיף באופן אוטומטי קו תחתון '_' לפני שם כל פונקציה. לכן, על מנת שהקוד שבמימוש יוכל להתחבר גם לתכנית C, מוסף '_' לפני השם my_add

12. מערכות הפעלה - תרגול 212 (c) ארז חדד 2003 קריאה לפונקציה ב-Linux (8).global _my_add; declare public function _my_add: pushl %ebp movl %esp,%ebp pushl %esi; not necessary (unused register) pushl %edi; not necessary (unused register) pushl %ebx movl 8(%ebp),%ebx; load the first parameter movl 12(%ebp),%eax; load the second parameter addl %ebx,%eax; result is in eax popl %ebx popl %edi popl %esi popl %ebp ret

13. מערכות הפעלה - תרגול 213 (c) ארז חדד 2003 קריאת מערכת ב-Linux (1) המינוח המקובל – System Call (syscall בקיצור) תהליך משתמש מבצע קריאת מערכת על-מנת לבקש מגרעין מערכת ההפעלה לבצע עבורו שירות כלשהו מדוע שירות כלשהו חייב להתבצע דווקא על-ידי גרעין מערכת ההפעלה?  מצריך גישה לחומרה: קלט / פלט למסוף, קבצים, תקשורת ברשת, גרפיקה  מצריך גישה למבני נתונים של מערכת ההפעלה או של תהליכים אחרים: יצירת תהליכים חדשים, תקשורת בין תהליכים, גישה לנתוני משתמשים

14. מערכות הפעלה - תרגול 214 (c) ארז חדד 2003 קריאת מערכת ב-Linux (2) במה שונה קריאת מערכת ב-Linux מקריאה לפונקציה?  ראינו בתירגול 1 – קריאה באמצעות פסיקת תוכנה ועם זאת.. קריאת מערכת נראית כמו קריאה רגילה לפונקציה בקוד התוכנית  לדוגמה: open() ו-sprintf() הן שתי פונקציות סטנדרטיות המהוות חלק מה- API (Application Programming Interface) של Linux וכלולות בספריה libc  sprintf(), המשמשת להדפסת פלט לחוצץ, היא פונקציה רגילה, שאינה פונה לגרעין לצורך עבודתה  אבל: open(), המשמשת לפתיחת קובץ, היא קריאת מערכת  המתכנת, הכותב יישום שמשתמש בספריות מערכת ההפעלה, אינו מבדיל בין קריאת מערכת לבין קריאה רגילה לפונקציה. ההבדל נעוץ במימוש פונקציה לעומת מימוש קריאת מערכת

15. מערכות הפעלה - תרגול 215 (c) ארז חדד 2003 קריאת מערכת ב-Linux (3) כיצד ממומשת קריאת מערכת? התשובה: מעטפת קוד - code wrapper  לדוגמה: הפונקציה open() היא מעטפת קוד, המפעילה באמצעות פסיקת תוכנה את קריאת המערכת שמבצעת את השירות המבוקש של פתיחת הקובץ, ומחזירה את תוצאת ביצוע השירות לקוד שקרא ל-open()  פונקציות המעטפת הן אלו שמקושרות (linking) לתוכנית המשתמשת בהן

16. מערכות הפעלה - תרגול 216 (c) ארז חדד 2003 קריאת מערכת ב-Linux (4) הערך המוחזר על-ידי פונקצית המעטפת במקרה של הצלחת ביצוע השירות תלוי בסוג השירות המבוקש  לדוגמה: open() מחזירה מספר מזהה (descriptor) לקובץ שנפתח. דרך מזהה זה ניתן כעת לקרוא ולכתוב לקובץ במקרה של כישלון, בדרך-כלל מוחזר הערך -1, וסוג השגיאה מוחזר במשתנה גלובלי הקרוי errno  לדוגמה: אם הבקשה בקריאה ל-open() היתה לפתוח לקריאה קובץ שאינו קיים, יוכנס הערך ENOENT למשתנה errno, כאשר ENOENT הוא קבוע שערכו 2  רשימת הקבועים המוחזרים במצבי כישלון עבור קריאת מערכת מסוימת זמינה דרך ה-man page של אותה קריאת מערכת  רשימת ערכי הקבועים נמצאת בקובץ /usr/include/errno.h ובקבצים הכלולים בו

17. מערכות הפעלה - תרגול 217 (c) ארז חדד 2003 קריאת מערכת ב-Linux (5) כל קריאות מערכת ההפעלה ב-Linux מטופלות דרך פסיקת תוכנה אחת, מספר 128 (0x80)  סוג השירות המבוקש נקבע באמצעות מספר שירות המועבר ברגיסטר eax על-ידי פונקצית המעטפת בתגובה לפסיקה המעבד עובר מ-user mode ל-kernel mode ומפעיל בגרעין את שגרת הטיפול בפסיקה הקרויה system_call() (קובץ גרעין: arch/i386/kernel/entry.S) השיגרה system_call() מנתבת את ביצוע הבקשה לפונקציה המתאימה לפי מספר השירות  שם הפונקציה המבצעת את השירות מתאים לשם השירות עם הקידומת "sys_". לדוגמה: open() מבוצעת על-ידי הפונקציה sys_open() (קובץ גרעין: fs/open.c)

18. מערכות הפעלה - תרגול 218 (c) ארז חדד 2003 קריאת מערכת ב-Linux (6) User Mode Kernel Mode open() {. int 0x80. } open() system_call():. sys_open(). iret sys_open() {. } קוד משתמשמעטפת קודשגרת טיפול בפסיקהפונקציה מבצעת פונקצית המעטפת והפונקציה בגרעין המבצעת את בקשת השירות הן פונקציות רגילות המופעלות לפי כללי קריאה לפונקציה שראינו בשקפים קודמים 1 2 3 4 5 6

19. מערכות הפעלה - תרגול 219 (c) ארז חדד 2003 קריאת מערכת ב-Linux (7) system_call(), בהיותה שגרת טיפול בפסיקה, פועלת תחת כללים שונים מכללי קריאה לפונקציה רגילה  קפיצה לשגרת טיפול בפסיקה באיזור זיכרון של הגרעין. פעולת הקפיצה שומרת את eflags, cs, eip (משמאל לימין) במחסנית. החזרה מהשגרה היא בהוראה מיוחדת – iret – המשחזרת רגיסטרים אלו  מסגרת הפונקציה איננה מקושרת למסגרות קודמות  העברת הפרמטרים לשגרה היא באמצעות רגיסטרים בלבד מדוע צריך פרוטוקול קריאה מיוחד עבור system_call() (ושגרות פסיקה בכלל)?  כי במעברים בין user mode ו-kernel mode מתבצעת החלפת מחסניות. פרטים בתרגולים הבאים

20. מערכות הפעלה - תרגול 220 (c) ארז חדד 2003 קריאת מערכת ב-Linux (8) הפרמטרים המועברים ל-system_call() כוללים:  מספר השירות המבוקש, ברגיסטר eax  פרמטרים עבור השירות לפי הצורך, ברגיסטרים הבאים (משמאל לימין): ebx, ecx, edx, esi, edi, ebp פרמטרים הגדולים מ-32 ביט: מועבר מצביע לפרמטר ברגיסטר יחיד אם נדרשים יותר מ-6 פרמטרים עבור השירות: מועבר רגיסטר יחיד המצביע לרשומה בזיכרון של התהליך המכילה את כל הפרמטרים שיטת העברת הפרמטרים מוגדרת בפונקצית המעטפת  שיבוץ פרמטרים ממחסנית הקריאה לרגיסטרים או העברת מצביע לרשומה

21. מערכות הפעלה - תרגול 221 (c) ארז חדד 2003 קריאת מערכת ב-Linux (9) מספר השירות המועבר ל-system_call() הוא למעשה אינדקס בטבלה של מצביעים לפונקציות ביצוע שירות, הקרויה sys_call_table מספר הכניסות בטבלה sys_call_table מוגדר בקבוע NR_syscalls, וערכו בד"כ 256 לא כל הכניסות בטבלה מצביעות על פונקציות שירות פעילות; אילו שאינן פעילות מצביעות על פונקצית הביצוע sys_ni_syscall() (קובץ גרעין: linux/kernel/sys.c) המחזירה ערך שגיאה –ENOSYS שפירושו "שירות שאינו ממומש"

22. מערכות הפעלה - תרגול 222 (c) ארז חדד 2003 קריאת מערכת ב-Linux (10) פונקצית ביצוע השירות כתובה ב-C: int sys_open(const char* pathname, int flags); בתוך פונקצית ביצוע השירות נבדקת התקינות של כל פרמטר  בדיקות ייחודיות בהתאם לפונקציה. למשל, בכתיבה לקובץ בודקים שפרמטר מזהה הקובץ אכן מתאים לקובץ שנפתח לכתיבה ע"י תהליך המשתמש  בדיקות כלליות עבור פרמטרים מסוג מצביעים: האם הזיכרון המוצבע אכן מוכל בזיכרון של תהליך המשתמש. לדוגמה: בפונקציה sys_open נבדק הפרמטר pathname בדיקות מצביעים נערכות גם בכל פעם שפונקצית ביצוע השירות ניגשת לזיכרון תהליך המשתמש

23. מערכות הפעלה - תרגול 223 (c) ארז חדד 2003 קריאת מערכת ב-Linux (11) הערך המוחזר על-ידי פונקצית ביצוע השירות נמצא תמיד ברגיסטר eax ערך מוחזר זה הינו 0 או חיובי במקרה של הצלחת ביצוע השירות ערך מוחזר שלילי מציין שגיאה או תקלה בביצוע השירות. במקרה זה, קוד השגיאה הוא ערכו המוחלט של הערך המוחזר הערך המוחזר ב-eax מועבר דרך system_call() בחזרה לפונקצית המעטפת במקרה של ערך מוחזר שלילי, פונקצית המעטפת מציבה את הערך המוחלט של הערך המוחזר לתוך errno ומחזירה ערך -1  קוד הגרעין עצמו אינו ניגש כלל ל-errno

24. מערכות הפעלה - תרגול 224 (c) ארז חדד 2003 קריאת מערכת ב-Linux (12) (הערה: כל הסמלים בשקף זה ובשקפים הבאים נמצאים בקובץ הגרעין arch/i386/kernel/entry.S) שלבי הפעולה של system_call(): 1. שמירת כל הרגיסטרים במחסנית: system_call:.. SAVE_ALL  מטרת פעולה זו היא להכין את הפרמטרים בתוך המחסנית כפי שפונקצית ביצוע השירות מצפה להם  SAVE_ALL הוא מאקרו של אסמבלר שבין שאר פעולותיו, מכניס למחסנית את eax ואחריו בסדר הפוך את ששת הרגיסטרים המכילים פרמטרים (ebx מוכנס אחרון)

25. מערכות הפעלה - תרגול 225 (c) ארז חדד 2003 ss esp eflags cs eip orig_eax es ds eax ebp edi esi edx ecx ebx נשמר על ידיSAVE_ALL מספר קריאת המערכת נשמר על ידי הקפיצה לקריאת המערכת מבנה המחסנית בקריאת מערכת

26. מערכות הפעלה - תרגול 226 (c) ארז חדד 2003 קריאת מערכת ב-Linux (13) 2. טעינת מזהה תהליך המשתמש ל-ebx: לצורך גישה לנתוני התהליך מתוך הגרעין 3. בדיקת תקינות מספר השירות: cmpl $(NR_syscalls), %eax jb nobadsys movl $(-ENOSYS), 24(%esp) jmp ret_from_sys_call  מספר השירות נבדק כנגד גודל הטבלה, NR_syscalls. אם מספר השירות חורג מהטבלה, מוחזר ערך –ENOSYS ע"י הכנסתו למקום בו שמור eax במחסנית וקפיצה לסוף השגרה

27. מערכות הפעלה - תרגול 227 (c) ארז חדד 2003 קריאת מערכת ב-Linux (14) 4. הפעלת פונקצית ביצוע השירות: nobadsys: call *sys_call_table(0,%eax,4) movl %eax,24(%esp) jmp ret_from_sys_call  קריאה לפונקצית שירות המוצבעת ע"י הכניסה בטבלה sys_call_table שמספרה ב-eax (כפולה של 4 בתים) כתובת התחלת הפונקציה היא sys_call_table + 4 * eax  הערך המוחזר ברגיסטר eax מפונקצית השירות נשמר במחסנית במקום ממנו ישוחזר ערך eax בסיום השגרה

28. מערכות הפעלה - תרגול 228 (c) ארז חדד 2003 קריאת מערכת ב-Linux (15) 5. סיום השגרה: ret_from_sys_call:.. jmp restore_all restore_all:.. iret  בסיום השגרה מופעל קטע הקוד המסומן restore_all שמבצע שחזור מהמחסנית של כל הרגיסטרים שנשמרו ע"י SAVE_ALL וביניהם eax