מערכות הפעלה

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

תוכן התרגול • הדגמה מעשית: • כיצד לקבל עזרה בעבודה ב-Linux • כתיבת תכנית ראשונה ב-Linux • קריאה לפונקציות ב-Linux • קריאה לשירותי מערכת ב-Linux מערכות הפעלה - תרגול 2

קבלת עזרה בעבודה ב-Linux (1) • הפקודה man מציגה מידע על כל פקודה או פונקצית ספריה בה תרצו להשתמש דוגמה: לקבלת מידע על הפקודה ls הקישו: >man ls • לקבלת מידע על כל הפקודות הקשורות לנושא מסוים הקישו man –k <topic>. דוגמה: לקבלת מידע על כל הפקודות העוסקות בקבצים הקישו: >man –k file מערכות הפעלה - תרגול 2

קבלת עזרה בעבודה ב-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 תחזיר את המידע מהמדריך הנמוך ביותר עם השם המתאים מערכות הפעלה - תרגול 2

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

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

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

עבודה עם קוד גרעין 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) את המסלול היחסי לקובץ המכיל שם זה מערכות הפעלה - תרגול 2

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

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

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

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

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

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

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

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

קריאה לפונקציה ב-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 מערכות הפעלה - תרגול 2

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

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

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

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

קריאת מערכת ב-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) מערכות הפעלה - תרגול 2

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

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

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

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

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

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

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

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

קריאת מערכת ב-Linux (14) • הפעלת פונקצית ביצוע השירות: 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 בסיום השגרה מערכות הפעלה - תרגול 2

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

מערכות הפעלה