מערכות הפעלה תרגול 3 – תהליכים ב-linux (1). מערכות הפעלה -...

מערכות הפעלה

Linux (1)- – תהליכים ב3תרגול

מערכות הפעלה - תרגול 3 2(c) 2003 ארז חדד

תוכן התרגול

-מבוא לתהליכים בLinuxAPIלעבודה עם תהליכים מבוא לניהול תהליכים בתוך הגרעין

) מתאר התהליךprocess descriptor() רשימת התהליכיםprocess list(("הטווח הקצר") מאגר התהליכים המוכנים לריצה("הטווח הבינוני / ארוך") תורי המתנה


Linux (1)מבוא לתהליכים ב-) תהליךprocess הוא ביצוע סדרתי של משימה, המוגדרת (

)programעל-ידי תכנית () תהליך = מופעinstanceשל ביצוע תכנית ( תהליך נקרא גםtaskבמקומות שונים

מספר תהליכים מתבצעים "בו זמנית" על המעבד במחשב למעשה – המעבד "ממתג" בין התהליכים בתדירות גבוהה באמצעות

מנגנון החלפת הקשר. פרטים בתרגול הבא עבור מערכת ההפעלה, תהליך הינו יישות עצמאית הצורכת

משאבים'זיכרון, זמן מעבד, שטח דיסק וכו

-לכל תהליך בLinux יש מזהה הקרוי PID – Process IDentifier

32 ביט ייחודי לתהליך (עד 32מספר שלם בןK תהליכים מטעמי תאימות הסטורית)

-ערכי הpidממוחזרים מתהליכים שסיימו לתהליכים חדשים שנוצרים


Linux (2)מבוא לתהליכים ב-

באיתחולLinux גרעין מערכת ההפעלה יוצר שני תהליכים בלבד

swapper (pid=0)משמש לניהול זיכרון – init (pid=1) ממנו נוצרים כל שאר התהליכים במערכת –

-כל תהליך נוסף נוצר בLinuxכעותק של תהליך קיים (או הורה) התהליך המקורי נקרא תהליך אבהתהליך החדש נקרא תהליך בן תהליך הבן נוצר בעקבות ביצוע קריאת מערכת כדוגמת

fork()על-ידי תהליך האב תהליך אב יכול ליצור יותר מתהליך בן אחד


Linux (3)מבוא לתהליכים ב-

תהליך יכול לאחר היווצרו לבצע משימה שונה מאביו על-ידי הסתעפות בקוד התכנית הקיימת, לאחר ההתפצלות

מהאבעל-ידי טעינת משימה חדשה (תכנית חדשה) לביצוע

למשל, על-ידי קריאת המערכתexecv()

תהליך אב יכול לבדוק סיום של כל תהליך בן שלואך לא של "נכדים", "נינים", "אחים" וכדומהאב יכול להמתין לסיום בן לפני המשך פעולתו

למשל, על-ידי קריאת המערכתwait()


Linux (4)מבוא לתהליכים ב- כדי לאפשר לאב לקבל מידע על סיום הבן, לאחר

שתהליך מסיים את פעולתו הוא עובר למצב מיוחד – zombie שבו התהליך קיים כרשומת נתונים בלבד –

ללא שום ביצוע משימה הרשומה נמחקת לאחר שהאב קיבל את המידע על סיום

הבן) "מה קורה לתהליך שהופך ל"יתוםorphan לאחר (

שאביו כבר סיים? התהליך הופך להיות בן שלinit

התהליךinit ממשיך להתקיים לאורך כל פעולתה של מערכת ההפעלה

אחד מתפקידיו העיקריים - המתנה לכל בניו, כדי לפנותאת נתוניהם לאחר סיום


API-לתהליכים ב Linux (1) קריאת המערכתfork()

:תחבירpid_t fork();

פעולה: מעתיקה את תהליך האב לתהליך הבן וחוזרת בשניהתהליכים

(ומיקום בקוד) קוד זהה (משתנים וערכיהם, חוצצים) זיכרון זהה ,סביבה זהה (קבצים פתוחיםfile descriptors ספרית עבודה ,

נוכחית)פרמטרים: אין :ערך מוחזר

:לאב (אין בן)1-במקרה של כישלון ולאב מוחזר ה-0במקרה של הצלחה: לבן מוחזר pidשל הבן


API-לתהליכים ב Linux (2)

לאחר פעולתfork() מוצלחת, אמנם יש לאב ולבן את אותם בעותקים נפרדיםמשתנים בזיכרון, אך

כלומר, שינוי ערכי המשתנים אצל האב לא ייראה אצל הבן, וההיפך .כמו כן, תהליך הבן הוא תהליך נפרד מתהליך האב לכל דבר

משלוpidבפרט, יש לו ?מה מדפיס הקוד הבא

main() {fork();printf(“hello”);

}



-תשובות אפשריות (בהנחה שfork():(הצליחה hellohello

hheellollo

הסיבה: שני תהליכים כותבים פלט בצורה לא מתואמת-מבנה תכנית אופייני המשתמש בfork():

status = fork();

if (status < 0)

// fork() failed – handle error (e.g. message & exit)

if (status == 0)

// son process – do son code

else

// father process – do father code


API-לתהליכים ב Linux (4) קריאת המערכתexecv()

:תחבירint execv(const char *filename, char *const argv[]);

פעולה: טוענת תכנית חדשה לביצוע על-ידי התהליך הקורא :פרמטרים

filenameמסלול אל הקובץ המכיל את התכנית לטעינה – argv מערך מצביעים למחרוזות המכיל את הפרמטרים עבור –

או רק מכיל argv[0] == filenameהתכנית. האיבר הראשון מקיים NULLאת שם קובץ התכנית. האיבר שאחרי הפרמטר האחרון מכיל

:ערך מוחזר :1-במקרה של כישלון במקרה של הצלחה: הקריאה אינה חוזרת. איזורי הזיכרון של התהליך

מאותחלים לתכנית החדשה שמתחילה להתבצע מההתחלה.



?מה ידפיס הקוד הבאmain() {char *argv[] = {“date”, NULL};execv(“/bin/date”, argv);printf(“hello”);

}:התשובה

אםexecv()מצליחה: את התאריך והשעה אםexecv() :נכשלת hello



דוגמה אופיינית לשילובfork() עם execv():pid = fork();if (pid < 0) {handle fork() error

}if (pid > 0) // do father code

elseexecv(“son_prog”, argv_son);


API-לתהליכים ב Linux (7) קריאת המערכתexit()

:תחבירvoid exit(int status);

פעולה: מסיימת את ביצוע התהליך הקורא ומשחררת את עד zombieכל המשאבים שברשותו. התהליך עובר למצב

שתהליך האב יבקש לבדוק את סיומו ואז יפונה לחלוטין :פרמטרים

statusערך סיום המוחזר לאב אם יבדוק את סיום התהליך –

ערך מוחזר: הקריאה אינה חוזרת


API-לתהליכים ב Linux (8) קריאת המערכתwait()

:תחבירpid_t wait(int *status);

פעולה: גורמת לתהליך הקורא להמתין עד אשר אחדמתהליכי הבן שלו יסיים

:פרמטריםstatusמצביע למשתנה בו יאוחסן סטטוס הבן שסיים –

:ערך מוחזר אם אין בנים, או שכל הבנים כבר סיימו וכבר בוצע להםwait() -

1-חזרה מיד עם ערך אם יש בן שסיים ועדיין לא בוצע לוwait() (zombie) חזרה מייד –

של הבן הנ"ל ועם סטטוס הסיום שלו. מאקרו-ים שונים pidעם ה-מאפשרים לקבל מתוך הסטטוס מידע על הבן. למשל

WEXITSTATUS (status) יתן את ערך הסיום של בן שסיים (הערך ).()exitשהעביר כארגומנט ל-

אחרת – המתנה עד שבן כלשהו יסיים


API-לתהליכים ב Linux (9) דוגמת קוד אופיינית בה האב מחכה לסיום כל תהליכי

הבן:while (wait(&status) != -1);

:קריאה שימושית נוספתwaitpid() המתנה לסיום בן – מסוים

pid_t waitpid(pid_t pid, int *status, int options);

ניתן למשל, באמצעותoptions לבחור רק לבדוק אם ,) או להמתין לסיום הבן WNOHANGהבן סיים (ערך

)0(ערך


API-לתהליכים ב Linux (10) קריאת המערכתgetpid()

:תחבירpid_t getpid()

-פעולה: מחזירה לתהליך הקורא את הpidשל עצמו פרמטרים: אין-ערך מוחזר: הpidשל התהליך הקורא

:קריאה שימושית דומהgetppid()-מחזירה את ה pid של התהליך הקוראתהליך האבשל

מה המשמעות שלgetppid() == 1 עבור תהליך משתמש טיפוסי?

תשובה: תהליך האב שיצר את התהליך הנוכחי סיים


Linuxאתחול תהליכים ב-

-משתמשים מתחברים לעבודה בLinuxדרך מסופים (מקומי או מרוחק) מסוף = מסך + מקלדת

התהליךinit יוצר עבור כל מסוף של Linux תהליך בן הטוען ומבצע את המשימות הבאות לפי הסדר:

איתחול של המסוף בתכניתgetty תכניתloginהמאפשרת למשתמש להיכנס למערכת לאחר שאושרה כניסת המשתמש: תכנית shell כמו)tcsh

) המאפשרת למשתמש להעביר פקודות למערכת bashאו ההפעלה

-כאשר הshell מקבל פקודה, הוא מייצר תהליך בן שמבצע אותה, ממתין לסיום הבן ואז קורא את

הפקודה הבאה


Linux (2)אתחול תהליכים ב-init fork() fork() fork() wait()

exec(getty) exec(getty) exec(getty)

exec(login) exec(login)

exec(shell)

exit()

fork()shell

exec(command) exit()

wait()

Pid=7223 Pid=30498

Pid=1

Pid=8837

Pid=5562


)1ניהול תהליכים בגרעין (-לכל תהליך בLinux מתאר תהליך קיים בגרעין

)process descriptor( שהוא רשומה מסוג ,task_struct קובץ גרעין) include/linux/sched.h (

המכילה:מצב התהליךעדיפות התהליך) מזהה התהליךpid(מצביע לטבלת איזורי הזיכרון של התהליךמצביע לטבלת הקבצים הפתוחים של התהליך(רשימה מקושרת) מצביעים למתארי תהליכים נוספים מצביעים למתאר תהליך האב ו"קרובי משפחה" נוספיםמסוף איתו התהליך מתקשר..ועוד


)2ניהול תהליכים בגרעין (

מצב התהליך נמצא בשדהstate, שהוא משתנה ביט המתפקד כמערך ביטים32בגודל

-בכל זמן שהוא, בדיוק אחד מהביטים בstate דלוק בהתאם למצב התהליך באותו זמן

Linux:מגדירה את המצבים הבאים לכל תהליך TASK_RUNNING התהליך רץ או מוכן לריצה, כלומר –

נמצא בטווח הקצרTASK_INTERRUPTIBLE התהליך ממתין לאירוע –

כלשהו (טווח בינוני/ארוך) אך ניתן להפסיק את המתנת באמצעות TASK_RUNNINGהתהליך ולהחזירו למצב

שליחת אות כלשהו לתהליך. זהו מצב ההמתנה הנפוץ.


)3ניהול תהליכים בגרעין (TASK_UNINTERRUPTIBLE התהליך ממתין לאירוע –

) אך פרט TASK_INTERRUPTIBLEכלשהו (בדומה ל- לאירוע לו הוא ממתין, לא ניתן ל"העיר" את התהליך

מצב המתנה נדיר לשימוש – למשל כאשר התהליך מבקש לגשתלחומרה ומערכת ההפעלה צריכה לסרוק אחר החומרה ללא הפרעה

TASK_STOPPED ריצת התהליך נעצרה בצורה מבוקרת – )tracer או debuggerעל-ידי תהליך אחר (בדרך-כלל

TASK_ZOMBIE ריצת התהליך הסתיימה, אך תהליך האב – של התהליך שסיים עדיין לא ביקש מידע על סיום התהליך

. התהליך קיים כמתאר ()waitבאמצעות קריאה כדוגמת בלבד

את ערך השדהstate ניתן לשנות בהצבה ישירה או set_current_state או set_task_stateעל-ידי המאקרו

)include/linux/sched.h(קובץ גרעין


)4ניהול תהליכים בגרעין ( לכל תהליך יש מחסנית נוספת הקרויהkernel mode stack ,

כלומר "מחסנית גרעין" מחסנית זו משמשת את גרעין מערכת ההפעלה בטיפול

באירועים במהלך ריצת התהליךפסיקות בכללקריאות מערכת בפרט

מחסנית הגרעין של כל תהליך מאוחסנת באיזור הזיכרון שלהגרעין

כאשר במהלך ריצת התהליך מתבצע מעבר ביןuser mode ss, מתבצעת החלפת מחסניות (שינוי ערכי kernel modeו-) בין המחסנית הרגילה של התהליך ומחסנית הגרעיןespו-

ערכיss:esp המצביעים למחסנית הרגילה נשמרים על-ידי המעבד ומשוחזרים במעבר kernel modeבמחסנית הגרעין מיד עם המעבר ל-

user modeהחוזר ל-


)5ניהול תהליכים בגרעין (

מחסנית הגרעין מאוחסנת יחד עם מתאר, 8KBהתהליך בקטע זיכרון אחד בגודל

8KB (213)המתחיל בכתובת שהיא כפולה של

Kernel Mode Stack

Process Descriptor

esp

current 0x015fa000

0x015fa3cb

0x015fa878

0x015fbfffunion task_union { struct task_struct task; unsigned long stack[2048];};

המחסנית לא דורסת את מתארהתהליך מפני שאיננה גדלה

בתים, וגודל מתאר7200מעבר ל- בתים1000התהליך קטן מ-


)6ניהול תהליכים בגרעין ( מצורת האחסון הנ"ל נובעת דרך פשוטה "לשלוף" את כתובת

:kernel mode כאשר המעבד ב-espמתאר התהליך מתוך esp הביטים הנמוכים של 13לאפס את

:בהתאם לדוגמה בשקף הקודםesp = 0x15fa878esp & 0xffffe000 = 0x15fa000 – כתובת מתאר התהליך

המאקרוcurrent קובץ גרעין) include/asm-i386/current.h (משתמש בשיטה זו על מנת לאחסן את כתובת מתאר התהליך

:pבערך מוחזר movl $0xffffe000, %ecxmovl %esp, pandl %ecx, p


)1רשימת התהליכים ( מתארי כל התהליכים מחוברים ברשימה מקושרת

processרשימת התהליכים (כפולה מעגלית הקרויה list( באמצעות השדות prev_task-ו next_task רשימה זו מקבילה ל"טבלת התהליכים" הקיימת במערכות

ההפעלה אחרות ראש הרשימה הוא המתאר של התהליךswapper

prev_task

init_task

next_task prev_task prev_tasknext_task

ניהול תהליכים בגרעין

next_task


)2רשימת התהליכים (

המאקרוSET_LINKS-ו REMOVE_LINKS קובץ) ) משמשים להוספה include/linux/sched.hגרעין

והסרה של מתאר תהליך ברשימת התהליכים מטפלים גם ב"קשרי משפחה" בין תהליכים. פרטים

בהמשך

המאקרוfor_each_task (אותו קובץ גרעין) מאפשר לעבור על כל התהליכים ברשימה בסריקה דרך השדה

next_task:#define for_each_task(p)

for (p = &init_task; (p = p->next_task) != &init_task; )



)1 למתאר תהליך (PIDמיפוי אמנם קריאות מערכת המתייחסות לתהליך מציינות את

של התהליך, אך הגרעין עובד עם מתאר התהליךpidה- לפיכך, הוגדר בגרעין מנגנון המאתר את מתאר התהליך

של התהליךpidלפי ה- המנגנון מבוסס עלhash-table בגודל PIDHASH_SZ

) כניסות1024(בד"כ -32בדרך-כלל מספר התהליכים במערכת קטן בהרבה מK

האפשרייםpidולכן אין צורך להחזיק כניסות עבור כל ה--התנגשויות בפונקצית הhash נפתרות על-ידי קישור

מתארי התהליך, המתמפים לאותה כניסה בטבלה, pidhash_nextברשימה מקושרת כפולה דרך השדות

pidhash_pprevו-



)2 למתאר התהליך (PIDמיפוי

הפונקציותhash_pid()-ו unhash_pid() מאפשרות להוסיף ולהסיר מתאר תהליך לטבלה

הפונקציהfind_task_by_pid() מבצעת את איתור הנתוןpidמתאר התהליך לפי ה-


pidhash

0

199

216

1023

……

…

PID199

PID26799

PID26800 pidhash_next

pidhash_pprev


)1ניהול קשרי משפחה בגרעין ( קשרי המשפחה" בין תהליכים מיוצגים בגרעין"

באמצעות מצביעים בין מתארי תהליכים מתאר תהליך אב מצביע למתאר תהליך הבן הצעיר ביותר

במתאר p_cptrשלו (שנוצר אחרון) באמצעות שדה התהליך

מתאר תהליך מצביע למתאר תהליך האב שלו באמצעותp_opptrהשדה

במתאר התהליך קיים שדה מצביע נוסף הקרויp_pptr המצביע למתאר תהליך האב בפועל. ערך זה שונה מתהליך האב כאשר

tracer או debuggerהתהליך נמצא בריצה מבוקרת ע"י ) "מתאר תהליך מצביע למתאר תהליך ה"אח הבוגרolder

sibling כלומר מתאר התהליך שאביו יצר לפניו, באמצעות ,(p_osptrהשדה

"מתאר תהליך מצביע למתאר תהליך ה"אח הצעיר )younger sibling כלומר מתאר התהליך שאביו יצר ,(

p_ysptrאחריו, באמצעות השדה



)2ניהול קשרי משפחה בגרעין (

"באמצעות "קשרי המשפחהתהליך יכול לאתר את אביו

למשל, עבורgetppid() תהליך יכול לאתר את בניו לפי סדר יצירתם

למשל, עבורwait()P0

P3P2P1

P4

p_(o)pptr

p_ysptr

p_osptr

p_cptr



)1רשימות מקושרות בגרעין ( לצורך ניהול תורים ומבני נתונים אחרים הגרעין משתמש ברשימות מקושרות

כפולות מעגליות הגדרת מבנה הרשימה בקובץ הגרעיןinclude/linux/list.h

כל איבר ברשימה הוא מסוגlist_tstruct list_head {

struct list_head *next, *prev;};typedef struct list_head list_t;


list_head

next next next next

prev prev prev prev

data structure 1 data structure 2 data structure 3


)2רשימות מקושרות בגרעין (

האיברים ברשימה הם שדות המוכלים ברשומות מבני נתונים מבני הנתונים המכילים את אברי הרשימה מקושרים זה לזה באמצעות

הרשימה :הפעולות על הרשימה כוללות, בין השאר

:יצירת (ראש) הרשימהLIST_HEAD) הוספת איבר במקום נתוןlist_add) ובסוף הרשימה (list_add_tail () הסרת איבר נתוןlist_del() בדיקה האם הרשימה ריקהlist_empty() גישה לרשומה המכילה איבר נתוןlist_entry(

#define list_entry(ptr, type, member) \

((type *)((char *)(ptr) – (unsigned long)(&((type *)0)->member))) ) לולאת מעבר על איברים ברשימהlist_for_each(



)1הטווח הקצר (

-מתארי התהליכים המוכנים לריצה בLinux מצב) TASK_RUNNING נגישים מתוך מבנה נתונים הקרוי (

runqueue קובץ גרעין) kernel/sched.c( לכל מעבד ישrunqueueמשלו כלrunqueue ,מכיל מספר תורים של מתארי תהליכים

אחד לכל עדיפות של תהליך כל תור ממומש כרשימה מעגלית כפולה שתוארה קודם השדהrun_list במתאר התהליך הוא איבר הקישור

)list_headברשימה (מסוג



)2הטווח הקצר (

הפונקציותenqueue_task()-ו dequeue_task() runqueueמכניסות ומוציאות [מתאר] תהליך ב-

הפונקציהwake_up_process() הופכת תהליך ), מוסיפה TASK_RUNNINGממתין למוכן לריצה (

באמצעות runqueueאת התהליך ל-enqueue_task() ומסמנת צורך בהחלפת הקשר

אם התהליך החדש מועדף לריצה על-פני האחרים



)1הטווח הבינוני/ארוך ( תהליך שצריך להמתין לאירוע כלשהו לפני המשך ריצתו

)TASK_(UN)INTERRUPTIBLEתור המתנה ) נכנס ל)wait queue(

-כמו כן, התהליך יוצא מהrunqueueומוותר על המעבד כל תור המתנה משויך לאירוע או סוג אירוע כלשהו, כגון

פסיקת חומרה, למשל דיסק או שעון התפנות משאב מערכת לשימוש. לדוגמה: ערוץ תקשורת

שהתפנה וניתן לשלוח דרכו נתוניםאירועים אחרים כלשהם, כמו סיום תהליך

כאשר קורה האירוע אליו מקושר תור ההמתנה, מערכתההפעלה "מעירה" תהליכים מתוך התור, כלומר מחזירה

)TASK_RUNNINGאותם למצב ריצה (



)2הטווח הבינוני/ארוך (

:תהליך ממתין בתור יכול להיות באחד משני מצביםexclusive (בלעדי) – כאשר האירוע המעורר קורה, מעירים

אחד מהתהליכים שממתינים עם סימון "בלעדי". למשל: כאשר האירוע הוא שחרור של משאב שניתן לשימוש רק

על-ידי תהליך יחיד ב-זמניתnon-execlusive ,(משותף) – כאשר האירוע המעורר קורה

מעירים את כל התהליכים שממתינים עם סימון "משותף". למשל: כאשר האירוע הוא פסיקת שעון שיכולה לסמן סוף המתנה עבור תהליכים שונים הממתינים למשך זמן קצוב

בדרך-כלל אין באותו תור המתנה ממתינים בלעדייםומשותפים יחד



)3הטווח הבינוני/ארוך ( תור המתנה ממומש כרשימה מקושרת כפולה מעגלית

)include/linux/wait.hשתוארה קודם (קובץ גרעין struct __wait_queue_head {

spinlock_t lock;struct list_head task_list;

};typedef __wait_queue_head wait_queue_head_t;

:כל תהליך בתור מוצבע מאיבר ברשימה המוגדר כדלהלןstruct __wait_queue {

unsigned int flags;struct task_struct *task;struct list_head task_list;

};typedef struct __wait_queue wait_queue_t;

מיועד להגן על lockהשדה התור מפני גישה במקביל על-ידי

שני תהליכים או יותר

מציין האם flagsהשדה או exclusive (1)ההמתנה היא

non-exclusive (0)



)4הטווח הבינוני/ארוך ( - פונקציה להכנסת תהליך להמתנה בתורsleep_on()

void sleep_on(wait_queue_head_t *q) {unsigned long flags;wait_queue_t wait;wait.flags = 0;wait.task = current;current->state = TASK_UNINTERRUPTIBLE;add_wait_queue(q, &wait);schedule();remove_wait_queue(q, &wait);

}

()add_wait_queue[_exclusive]הפונקציות מכניסות ומוציאות תהליך מהתור()remove_wait_queueו-



)5הטווח הבינוני/ארוך (

פונקציות נוספות מאפשרות הכנסת תהליך לתור ו/או כשהממתין interruptibleכשהוא ממתין במצב

בלעדי :במקביל, פונקציות המשמשות "להעיר" תהליכים

wake_up מעירה את כל הממתינים המשותפים ואחד מהבלעדיים

גרסאות נוספות שלwake_up : להעיר מספר מוגבל של תהליכים ממתינים להעיר רק ממתינים שהםinterruptible לבצע החלפת הקשר אם התהליך המועדף לריצה משתנה לאחר

שמעירים תהליכים


מערכות הפעלה תרגול 3 – תהליכים ב-linux (1). מערכות הפעלה -...

Documents