1. מערכות הפעלה תרגול 2 - הכרת Linux

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

3. מערכות הפעלה - תרגול 23 (c) ארז חדד 2003 קבלת עזרה בעבודה ב-Linux (1) הפקודה man מציגה מידע על כל פקודה או פונקצית ספריה בה תרצו להשתמש דוגמה: לקבלת מידע על הפקודה ls הקישו: >man ls לקבלת מידע על כל הפקודות הקשורות לנושא מסוים הקישו man –k. דוגמה: לקבלת מידע על כל הפקודות העוסקות בקבצים הקישו: >man –k file

4. מערכות הפעלה - תרגול 24 (c) ארז חדד 2003 קבלת עזרה בעבודה ב-Linux (2) ה-shell שבו תעבדו ב-Linux יהיה בדרך-כלל bash חלק מהפקודות שתחפשו הן פקודות של ה-shell ולכן מופיעות בתוך "man bash"  דוגמא לפקודות כאלו: history, alias, fg דפי ה-man מחולקים למספר חלקים (sections). למשל, פקודות שימושיות (כמו ls ו-ps) נמצאות בחלק 1. פונקציות מערכת (כמו open(), close()) נמצאות בחלק 2. לעיתים אותו שם יכול להופיע בשני חלקים של המדריך. למשל, kill נמצאת הן בחלק 1 של המדריך (הפקודה kill) והן בחלק 2 (הפונקציה kill()). במקרה שכזה, man kill תחזיר את המידע מהמדריך הנמוך ביותר עם השם המתאים

5. מערכות הפעלה - תרגול 25 (c) ארז חדד 2003 קבלת עזרה בעבודה ב-Linux (3) כדי לקבל את המידע על פקודה ספציפית מחלק מסוים (למשל 2) הקישו (לדוגמה): man 2 kill כדי לקבל מידע על כל המצוי בחלק מסוים (למשל 2) הקישו: man 2 intro דפי מידע ארוכים מוצגים תוך שימוש ב-less, שהיא תוכנה לגלילה מבוקרת של קבצי טקסט על המסך. ניתן לנוע בין העמודים בחופשיות באמצעות מקשי החיצים וה-pgup/pgdn. יציאה מ-less באמצעות ‘q’. קבלת עזרה על מקשי less באמצעות ‘h’. מקור נוסף לקבלת מידע על פקודות ומילות מפתח: >info פקודה זו מביאה את המידע מאורגן בצורת hypertext עם מעט יותר הסבר ידידותי לגבי השימוש בה.

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

7. מערכות הפעלה - תרגול 27 (c) ארז חדד 2003 תכנית Linux ראשונה (2) נקליד את התוכנית באמצעות תכנית עריכה כלשהי (למשל emacs) נעביר את התכנית קומפילציה: >gcc –g –o hello hello.c נריץ את התכנית >./hello Hello World! > ניתן (ורצוי) לבנות קובץ עבור make בשם Makefile (הקפידו על אותיות גדולות וקטנות) בתוך ספרית העבודה שלכם. הקומפילציה תתבצע על-ידי הפקודה: >make ניתן לבצע debugging אינטראקטיבי של תכנית באמצעות gdb. לדוגמה: gdb hello מי שמשתמש בסביבה גרפית יכול להשתמש למטרה זו ב-ddd באותו אופן.

8. מערכות הפעלה - תרגול 28 (c) ארז חדד 2003 עבודה עם קוד גרעין Linux קוד המקור של גרעין Linux נמצא בדרך כלל בספרייה /usr/src/linux-2.4 במחשב בו אתם עובדים  ייתכנו שינויים בהתאם למסגרת העבודה – נודיע לכם מראש בתרגולים הבאים נתבונן בדוגמאות קוד שונות הלקוחות מקוד הגרעין לכל דוגמת קוד נציין מהו הקובץ ממנו לקוחה הדוגמה, במסלול יחסי לספרית השורש המצוינת לעיל  למשל, אם ציינו שהפונקציה sys_open() נמצאת בקובץ גרעין fs/open.c, הרי שהמסלול המלא לקובץ הוא: /usr/src/linux-2.4/fs/open.c בסוף ספר הלימוד "Understanding the Linux Kernel" יש מפתח המכיל עבור כל שם (כמו sys_open) את המסלול היחסי לקובץ המכיל שם זה

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

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

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

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

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

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

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

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

17. מערכות הפעלה - תרגול 217 (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 (note: ds = ss) movl 12(%ebp),%eax; load the second parameter addl %ebx,%eax; result is in eax popl %ebx popl %edi popl %esi popl %ebp ret

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

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

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

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

22. מערכות הפעלה - תרגול 222 (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)

23. מערכות הפעלה - תרגול 223 (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

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

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

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

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

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

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

30. מערכות הפעלה - תרגול 230 (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 במחסנית וקפיצה לסוף השגרה

31. מערכות הפעלה - תרגול 231 (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 בסיום השגרה

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