מערכות הפעלה תרגול 5 – תהליכים ב-Linux (3)

מערכות הפעלה - תרגול 52 (c) ארז חדד 2003 תוכן התרגול החלפת הקשר (context switch) ב-Linux יצירת תהליך חדש ב-Linux סיום ביצוע תהליך ב-Linux

מערכות הפעלה - תרגול 53 (c) ארז חדד 2003 מהי החלפת הקשר? מעבד מריץ מספר תהליכים "בו-זמנית"  המעבד מריץ תהליך אחד לפרק זמן כלשהו ואז משעה את ביצועו ועובר להמשיך להריץ תהליך אחר – "מיתוג" בין התהליכים המתבצעים לכל תהליך יש "הקשר ביצוע" (execution context) המכיל את כל המידע הדרוש לביצוע התהליך  מחסניות, רגיסטרים, דגלים, תכולת זיכרון, קבצים פתוחים פעולת המיתוג שומרת את הקשר התהליך הנוכחי וטוענת למעבד את הקשר הביצוע של התהליך הבא  הקשר התהליך הנוכחי מתחלף – מכאן שם הפעולה "החלפת הקשר"

מערכות הפעלה - תרגול 54 (c) ארז חדד 2003 החלפת הקשר ב-Linux ב Linux לא ניתן לבצע החלפת הקשר כפויה לתהליך שנמצא ב kernel mode. אם בעקבות פסיקה נוצר צורך לבצע החלפת הקשר, היא תתבצע לאחר שהתהליך יסיים את הפעולה בkernel mode, לפני חזרתו ל-user mode. בגלל שהkernel של Linux הוא non-preemptive, קיימים שני אירועים נפרדים:  גילוי הצורך ב-context switch  ביצוע של context switch

מערכות הפעלה - תרגול 55 (c) ארז חדד 2003 גילוי הצורך בהחלפת הקשר 1. פסיקת שעון שבה מתגלה שנגמר ה time slice של התהליך הנוכחי. (פונקצית scheduler_tick() ראה בהמשך) 2. פסיקה שבה משתחרר מהמתנה תהליך בעל עדיפות טובה יותר ( משאר התהליכים המוכנים לריצה כולל התהליך הרץ כרגע) 3. ויתור של תהליך על המעבד מרצונו. גורם גם לקריאה ישירה ל scheduler.  שני המצבים הראשונים גורמים להדלקת דגל need_resched של התהליך. הדגל נבדק לפי החזרה ל user mode.  ישנם שלושה מצבים לגילוי הצורך ב context switch

מערכות הפעלה - תרגול 56 (c) ארז חדד 2003 הפונקציה scheduler_tick() (1) פונקציה זו מופעלת בכל פסיקת שעון ומעדכנת נתוני זימון של תהליכים.  מופעלת כשהפסיקות חסומות כדי למנוע שיבוש נתונים ע"י הפעלת הפונקציה במקביל.  מזהה צורך בהחלפת הקשר בעקבות סיום time slice של התהליך הנוכחי ומעדכנת את הדגל need_resched.  משתמשת בפונקציות enqueue_task() ו-dequeue_task() להוצאה והכנסה של תהליך לאחד ממערכי התורים (active או expired) task_t *p = current; runqueue_t *rq = this_rq();.. if (p->sleep_avg) p->sleep_avg--; עדכון ה-sleep_avg של התהליך הנוכחי

מערכות הפעלה - תרגול 57 (c) ארז חדד 2003 הפונקציה scheduler_tick() (2) if (!--p->time_slice) { dequeue_task(p, rq->active); set_tsk_need_resched(p); p->prio = effective_prio(p); p->time_slice = TASK_TIMESLICE(p); if (!TASK_INTERACTIVE(p) || EXPIRED_STARVING(rq)) { if (!rq->expired_timestamp) rq->expired_timestamp = jiffies; enqueue_task(p, rq->expired); } else enqueue_task(p, rq->active); אם התהליך הנוכחי כילה את ה-time slice של עצמו, הוא מוצא מה-active, העדיפות הדינמית וה-time slice הבא שלו מחושבים מחדש, ויבוצע לו schedule() בהמשך כאשר התהליך הראשון בתקופה הנוכחית שעובר ל- expired, מעודכן expired_timestamp תהליך אינטראקטיבי מוחזר ל-active לרוץ time slice נוסף בתקופה הנוכחית כאשר אין הרעבה

מערכות הפעלה - תרגול 58 (c) ארז חדד 2003 ביצוע החלפת הקשר ב-Linux, פונקצית schedule(). schedule() היא הפונקציה היחידה המפעילה את החלפת ההקשר. הפונקציה schedule() בוחרת מי יהיה התהליך הבא לזימון למעבד, כפי שראינו בתרגול הקודם, ואז קוראת לפונקציה בשם context_switch() המבצעת את החלפת ההקשר. כזכור מתרגול קודם, schedule() והחלפת ההקשר מתבצעים בפסיקות חסומות על-מנת למנוע הפעלה רקורסיבית של הזמן והחלפת ההקשר, דבר העלול לגרום לשיבוש פעולת מערכת ההפעלה

מערכות הפעלה - תרגול 59 (c) ארז חדד 2003 ביצוע החלפת הקשר ב-Linux, סדר הפעולות. החלפת הקשר היא בקירוב רצף הביצוע הבא: 1. שמירת נתוני הקשר התהליך הנוכחי. 2. מעבר למחסנית הגרעין של התהליך הבא (שהופך להיות התהליך הנוכחי החדש). 3. טעינת נתוני הקשר התהליך הנוכחי החדש. 4. קפיצה לכתובת הבאה לביצוע של התהליך הנוכחי החדש.

מערכות הפעלה - תרגול 510 (c) ארז חדד 2003 החלפת הקשר ב-Linux מרבית ההקשר של תהליך ב-Linux מאוחסן במתאר התהליך ולכן אין צורך "לשמור" ו"לטעון" אותו מחדש בכל החלפת הקשר.  נשמרים ונטענים בעיקר הרגיסטרים והדגלים  השמירה והטעינה – במחסנית הגרעין של התהליך ובמתאר התהליך בשדה thread פעולת החלפת ההקשר כוללת גם החלפת אזורי הזיכרון אליהם המעבד ניגש ב-User Mode: מאילו של התהליך הנוכחי לאילו של התהליך הבא  עם זאת, פעולת החלפת ההקשר מתבצעת באזור הזיכרון של הגרעין, שאינו מתחלף  במהלך החלפת הקשר לא משנים את ערכי הרגיסטרים של הסגמנטים (cs, ds, ss, es), למרות שאזור הזיכרון של התהליך אכן מוחלף. הסבר בתרגול על הזיכרון הוירטואלי

מערכות הפעלה - תרגול 511 (c) ארז חדד 2003 Task State Segment (1) אזור Task State Segment – TSS הוא אזור זיכרון בגרעין, המכיל מידע מתוך הקשר התהליך הנוכחי המתבצע במעבד. לכל מעבד ב-Linux יש אזור TSS משלו. קיומו של אזור זה הוא אילוץ של החומרה (IA32)  המעבד קורא את כתובת מחסנית הגרעין של התהליך הנוכחי משדה ב-TSS בעת מעבר ל-Kernel Mode  ה-TSS משמש בחומרה לפעולות נוספות כגון בקרת גישה בפעולות I/O ה-TSS של כל המעבדים מוכלים במערך init_tss. בעת ביצוע החלפת הקשר, מעדכנים שדות ב-TSS. החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 512 (c) ארז חדד 2003 Task State Segment (2) ההגדרות נמצאות בקובץ הגרעין include/asm/processor.h struct tss_struct {.. unsigned long esp0;.. }; struct tss_struct init_tss[NR_CPUS]; מצביע לבסיס מחסנית הגרעין של התהליך הנוכחי במעבד (ערך esp בכניסה ל-kernel mode) החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 513 (c) ארז חדד 2003 שדה thread במתאר התהליך שדה זה משמש לשמירת חלק מהקשר התהליך שדה זה הוא מסוג thread_struct המוגדר בקובץ הגרעין include/asm/processor.h: struct thread_struct { unsigned long esp0; unsigned long eip; unsigned long esp; unsigned long fs; unsigned long gs;.. union i387_union i387;.. }; מצביע לכתובת הבסיס של מחסנית הגרעין של התהליך מאחסן את המצביע לכתובת הבאה לביצוע לאחר החלפת הקשר מאחסן את המצביע לראש המחסנית (בגרעין) בהחלפת הקשר מאחסן את רגיסטרי הסגמנטים fs ו-gs מאחסן את הרגיסטרים של היחידה המתימטית החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 514 (c) ארז חדד 2003 הפונקציה context_switch() הפונקציה המבצעת את החלפת ההקשר נקראת context_switch()  קובץ גרעין kernel/sched.c  פונקציה זו מבצעת את החלפת איזורי הזיכרון ואז קוראת למאקרו switch_to המבצע את פעולות הטעינה והשמירה  הפונקציה context_switch() היא חלק מאלגוריתם הזימון החדש. בגרסה הסטנדרטית של הגרעין 2.4.X קיים רק switch_to inline task_t *context_switch(task_t *prev, task_t *next) {..קוד החלפת איזורי הזיכרון switch_to(prev, next, prev); return prev; } החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 515 (c) ארז חדד 2003 המאקרו switch_to (1) המאקרו מוגדר בקובץ הגרעין include/asm/system.h הקריאה למאקרו: switch_to(prev, next, last)  prev מצביע למתאר התהליך הנוכחי, שמוותר על המעבד  next מצביע למתאר התהליך הבא, שמקבל את המעבד  last הוא פרמטר שכבר אינו בשימוש באלגוריתם הזימון החדש. בגרסת 2.4.X הסטנדרטית, פרמטר זה מצביע לאחר החזרה מ-switch_to על מתאר התהליך ממנו בוצע switch_to אל התהליך הנוכחי movl prev, %eax movl next, %edx pushl %esi pushl %edi pushl %ebp הקומפיילר (gcc) מניח שרגיסטרים אלו אינם משתנים עד סוף switch_to ולכן יש לשמור אותם ולשחזר אותם בהמשך הרצת התהליך החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 516 (c) ארז חדד 2003 המאקרו switch_to (2) movl %esp, prev->thread.esp movl next->thread.esp, %esp movl $1f, prev->thread.eip pushl next->thread.eip jmp __switch_to 1: popl %ebp popl %edi popl %esi החלפת מחסניות הגרעין מזו של prev לזו של next – זו למעשה נקודת החלפת ההקשר התהליך prev ימשיך מהכתובת של התוית "1" כשיחזור לרוץ התהליך next ימשיך לרוץ מכתובת זו בסיום __switch_to שחזור הרגיסטרים ממחסנית הגרעין של next לפני סיום switch_to קפיצה לפונקציה __switch_to החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 517 (c) ארז חדד 2003 הפונקציה __switch_to() (1) פונקציה זו משלימה את רצף הפעולות במסגרת החלפת ההקשר  קובץ גרעין arch/i386/kernel/process.c הפונקציה מוגדרת באופן מיוחד: void FASTCALL(__switch_to(struct task_struct *prev_p, struct task_struct *next_p)); ההגדרה FASTCALL פירושה שהפונקציה מקבלת פרמטרים ברגיסטרים ולא במחסנית  הגדרה ייחודית ל-GCC: #define FASTCALL __attribute__(regparm(3))  עד 3 פרמטרים מועברים ברגיסטרים eax, edx, ecx (משמאל לימין) לכן, prev_p מועבר בתוך eax ו-next_p בתוך edx החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 518 (c) ארז חדד 2003 הפונקציה __switch_to() (2) פונקציה זו מופעלת באמצעות קפיצה מתוך המאקרו switch_to (למעשה, מתוך הפונקציה context_switch()) כאשר הפרמטרים כבר ברגיסטרים. jmp __switch_to מכיוון ש-__switch_to() מוגדרת כפונקציה, הקוד שלה מסתיים בפקודת ret ששולפת כתובת חזרה מהמחסנית וקופצת אליה.  המחסנית היא מחסנית הגרעין של התהליך הנוכחי החדש.  כתובת החזרה היא next->thread.eip כפי שהוכנסה בקוד של המאקרו switch_to. ברוב המקרים, זוהי כתובת התוית '1' של המשך ביצוע המאקרו switch_to בתוך הפונקציה context_switch().  אם next הוא תהליך שרץ פעם ראשונה, הכתובת היא אחרת כפי שנראה בהמשך. החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 519 (c) ארז חדד 2003 הפונקציה __switch_to() (3) struct thread_struct *prev = &prev_p->thread, *next = &next_p->thread; struct tss_struct *tss = init_tss + smp_processor_id(); unlazy_fpu(prev_p); tss->esp0 = next->esp0;.. movl %fs, prev->fs movl %gs, prev->gs if (prev->fs | prev->gs | next->fs | next->gs) {.. movl next->fs, %fs movl next->gs, %gs.. } /* load debug registers */ /* load IO permission bitmap */ return; שמירה ושחזור של fs ו-gs שמירה ושחזור של הרגיסטרים של היחידה המתימטית עדכון מצביע מחסנית הגרעין של התהליך הנוכחי ב-TSS החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 520 (c) ארז חדד 2003 שאלה.... למה context switch מורכב שלושה קטעי קוד נפרדים ?  context_switch() - פונקצית C כללית הנמצאת בספריה של kernel.  switch_to – מאקרו באסמבלר, ספציפי למעבד, מופיעה בספריה מיוחדת למעבד i386.  __switch_to – פונקצית C, ספציפית למעבד.

(c) ארז חדד 2003מערכות הפעלה - תרגול 521 context_switch: ret eip המשך הביצוע של next $1f ebp edi esi מסגרת של context_switch() …… switch_to: movl $1f, prev->thread.eip pushl next->thread.eip 1: switch_to:__ ……… $1f prev task_struct thread.eip thread.esp מחסנית הגרעין של התהליך prev ebp edi esi מסגרת של context_switch() next task_struct esp מחסנית הגרעין של התהליך next thread.eip $1f thread.esp $1f ebp edi esi מסגרת של context_switch()

מערכות הפעלה - תרגול 522 (c) ארז חדד 2003 שמירת ערכי הרגיסטרים (1) שם רגיסטרמה מכילאיפה נשמרמתי נשמר ss:esp מצביע למחסנית רגילה ע"י חומרה במחסנית הגרעין מייד עם תחילת המעבר לkernel mode eflags נשמר באופן אוטומטי במחסנית הגרעין בעת קפיצה לטיפול בפסיקה cs:eip כתובת החזרהנשמר באופן אוטומטי במחסנית הגרעין אחרי eflags בעת קפיצה לטיפול בפסיקה es,ds,eax, ebp,edi,esi,edx, ecx,ebx נשמרים במחסנית הגרעין דרך SAVE_ALL בתחילת שגרת הטיפול בפסיקה מרבית הרגיסטרים שבהם התהליך משתמש ב-User Mode נשמרים במעבר ל-Kernel Mode (ראינו דוגמה חלקית בתרגול 2)

מערכות הפעלה - תרגול 523 (c) ארז חדד 2003 שמירת ערכי הרגיסטרים (2) ומה לגבי שמירת הקשר הביצוע בתוך הגרעין?  המאקרו switch_to אינו משפיע מבחינת ערכי רגיסטרים על context_switch(), משום שהוא מופעל ממש לפני החזרה מהפונקציה  בין הפונקציה schedule() לפונקציה context_switch() מתקיימים יחסי caller- callee (פונקציה קוראת / פונקציה נקראת, כפי שראינו בתרגול 2), לכן בפונקציה schedule() לא מניחים שערכי הרגיסטרים פרט ל-ebx, ebp, esi, edi משתמרים  ebp, esi, edi נשמרים במחסנית במאקרו switch_to. ב-schedule() וב-context_switch(), ערך ebx מלפני הקריאה ל-switch_to אינו בשימוש לאחר הקריאה  esp ו-eip נשמרים בתוך מתאר התהליך לפני ביצוע החלפת ההקשר במאקרו switch_to.  הרגיסטרים של הסגמנטים אינם משתנים בהחלפת הקשר ולכן אינם נשמרים. למעט fs ו-gs, שלפעמים נמצאים בשימוש מיוחד ע"י תהליכים ולכן נשמרים החלפת הקשר ב-Linux

מערכות הפעלה - תרגול 524 (c) ארז חדד 2003 יצירת תהליך חדש ב-Linux (1) קריאות המערכת המשמשות ליצירת תהליכים חדשים (כדוגמת fork()) משתמשות בפונקציה פנימית של הגרעין הקרויה do_fork() לבניית ההקשר של התהליך החדש  קובץ גרעין kernel/fork.c הפונקציה do_fork() מעתיקה את מרבית הנתונים ממתאר תהליך האב למתאר חדש של תהליך הבן שהיא יוצרת  קבצים פתוחים (file descriptors), בעלות משותפת על משאבי מערכת  העתקת תכולת הזיכרון מתבצעת בשיטה מיוחדת – פרטים בתרגולים הבאים

מערכות הפעלה - תרגול 525 (c) ארז חדד 2003 יצירת תהליך חדש ב-Linux (2) הפונקציה do_fork() בונה מחסנית גרעין לתהליך הבן ע"י קריאה לפונקציה copy_thread() מתאר תהליך הבן מקושר לרשימת התהליכים ו"בני משפחתו" ע"י המאקרו SET_LINKS הקישור בין ה-pid של תהליך הבן למתאר תהליך הבן מופעל ע"י קריאה ל-hash_pid() תהליך הבן מועבר למצב TASK_RUNNING ומוכנס ל- runqueue ע"י קריאה ל-wake_up_process() לסיום, הפונקציה do_fork() מחזירה את ה-pid של תהליך הבן, וערך זה מוחזר לבסוף לתהליך האב

מערכות הפעלה - תרגול 526 (c) ארז חדד 2003 הפונקציה copy_thread() (1) פונקציה זו (קובץ גרעין arch/i386/kernel/process.c) מאתחלת את תכולת מחסנית הגרעין של תהליך הבן ואת שדה thread במתאר תהליך הבן. להלן תיאור של עיקר הקוד  p מצביע למתאר תהליך הבן  regs מצביע לרגיסטרים שאוחסנו במחסנית הגרעין של האב באמצעות הקפיצה לפסיקה ו- SAVE_ALL במהלך המעבר ל-kernel mode  struct pt_regs הוא רשומה המכילה את ערכי הרגיסטרים בדיוק בסדר בו הם מאוחסנים במחסנית באמצעות הקפיצה לפסיקה ו- SAVE_ALL struct pt_regs* childregs; childregs מצביע על תחילת המקום בו מאוחסנים הרגיסטרים במחסנית childregs = ((struct pt_regs *)( (unsigned long) p)) – 1; העתקת הרגיסטרים ממחסנית הגרעין של האב למחסנית הגרעין של הבן struct_cpy(childregs, regs); כזכור מתרגול 2, לתהליך הבן מוחזר ערך 0 מביצוע fork() childregs->eax = 0; יצירת תהליך חדש ב-Linux

מערכות הפעלה - תרגול 527 (c) ארז חדד 2003 הפונקציה copy_thread() (2) p->thread.esp צריך להצביע על ראש מחסנית הגרעין בתחילת הביצוע p->thread.esp = (unsigned long) childregs; p->thread.esp0 צריך להצביע על בסיס מחסנית הגרעין p->thread.esp0 = (unsigned long) (childregs + 1); בתחילת הביצוע תהליך הבן יריץ את ret_from_fork p->thread.eip = (unsigned long) ret_from_fork; זו הכתובת ש switch_to ידחוף למחסנית בפקודה pushl next->thread.eip ושאותה יוציא מהמחסנית __switch_to. (ראה שקף 16). /* save fs and gs registers in thread field */ /* copy saved math regs in thread field from father to son */

מערכות הפעלה - תרגול 528 (c) ארז חדד 2003 הפונקציה ret_from_fork() פונקציה זו מופעלת כאשר תהליך הבן מזומן לראשונה למעבד לאחר החלפת הקשר הפונקציה מוגדרת בקובץ הגרעין arch/i386/kernel/entry.S ret_from_fork:.. jmp ret_from_syscall כפי שראינו בתרגול 2, ביצוע ret_from_syscall ייגרום לתהליך הבן לחזור ל-user mode לאחר שנשלפו כל הרגיסטרים מהמחסנית למעשה, ביצוע הקוד ב-ret_from_fork ייגרום לסיום הקריאה fork() בתהליך הבן עם ערך מוחזר 0

מערכות הפעלה - תרגול 529 (c) ארז חדד 2003 ss esp eflags cs eip orig_eax es ds eax=0 ebp edi esi edx ecx ebx נשמר על ידיSAVE_ALL ערך eax נשמר בכל תחילת טיפול בפסיקה נשמר על ידי הקפיצה לפסיקה מצביע למחסנית התהליך ב- user mode ret_from_fork struct pt_regs task_struct thread.esp0 thread.eip thread.esp p

מערכות הפעלה - תרגול 530 (c) ארז חדד 2003 סיום ביצוע תהליך (1) תהליך מסיים את ביצוע הקוד ע"י קריאת המערכת exit() אם קוד התהליך לא קורא במפורש ל-exit(), מתבצעת קריאה אוטומטית ל-exit() לאחר שהפונקציה main() חוזרת, מתוך הספריה libc  מתוך פונקצית הספריה __libc_start_main() שקוראת ל- main() בתחילת ביצוע התכנית ביצוע קוד תהליך יכול גם להיקטע בעקבות אירועים נוספים  תקלה לא מטופלת במהלך ביצוע הקוד, כגון גישה לא חוקית לזיכרון או חלוקה ב-0  הריגת תהליך אחד על-ידי תהליך אחר

מערכות הפעלה - תרגול 531 (c) ארז חדד 2003 סיום ביצוע תהליך (2) הפונקציה do_exit() מופעלת בכל מקרה של סיום ביצוע התהליך  קובץ גרעין kernel/exit.c בין השאר, פונקציה זו מבצעת את הפעולות הבאות:  משחררת את המשאבים שבשימוש התהליך  מעדכנת שדה exit_code במתאר התהליך להכיל את הערך המוחזר ע"י exit()  מעדכנת קשרי משפחה: כל בניו של התהליך שסיים הופכים להיות בנים של init  מעבירה את מצב התהליך ל-TASK_ZOMBIE  קוראת ל-schedule(), שמוציאה את התהליך מה-runqueue ומזמנת תהליך אחר לביצוע במעבד. ביצוע התהליך מסתיים סופית בביצוע switch_to

מערכות הפעלה - תרגול 532 (c) ארז חדד 2003 סיום ביצוע תהליך (3) מתאר התהליך מפונה רק כאשר תהליך האב מקבל חיווי על סיום התהליך, באמצעות קריאה כדוגמת wait() פינוי מתאר התהליך מבוצע ע"י הפונקציה release_task()  קובץ גרעין kernel/exit.c פונקציה זו, בין השאר, מנתקת את התהליך מרשימת התהליכים (REMOVE_LINKS) וממנגנון הקישור ל-pid (unhash_pid()), ומפנה את השטח המוקצה למתאר התהליך ומחסנית הגרעין