מבוא למערכות הפעלה

היי הבר! ברצוני להביא לידיעתכם סדרת מאמרים-תרגום של ספרות מעניינת אחת לדעתי - OSTEP. חומר זה דן באופן די עמוק בעבודה של מערכות הפעלה דמויות יוניקס, כלומר עבודה עם תהליכים, מתזמנים שונים, זיכרון ורכיבים דומים אחרים המרכיבים מערכת הפעלה מודרנית. אתה יכול לראות את המקור של כל החומרים כאן כאן. שימו לב שהתרגום נעשה בצורה לא מקצועית (די חופשי), אבל אני מקווה ששמרתי על המשמעות הכללית.

ניתן למצוא עבודת מעבדה בנושא זה כאן:

• מקורי
• מקורי
• ההתאמה האישית שלי

חלקים אחרים:

• חלק 1: מבוא
• חלק 2: הפשטה: התהליך
• חלק 3: מבוא ל- Process API

אתה יכול גם לבדוק את הערוץ שלי בכתובת מִברָק =)

אזעקה! יש מעבדה להרצאה הזו! תראה github

תהליך API

בואו נסתכל על דוגמה ליצירת תהליך במערכת UNIX. זה קורה באמצעות שתי שיחות מערכת מזלג() и exec ().

Call fork()

שקול תוכנית שמבצעת קריאת fork() . התוצאה של ביצועו תהיה כדלקמן.

קודם כל, אנחנו נכנסים לפונקציה main() ומדפיסים את המחרוזת למסך. השורה מכילה את מזהה התהליך שבמקור נקרא מח"ש או מזהה תהליך. מזהה זה משמש ב-UNIX כדי להתייחס לתהליך. הפקודה הבאה תקרא fork(). בשלב זה נוצר עותק כמעט מדויק של התהליך. עבור מערכת ההפעלה, נראה שפועלים במערכת 2 עותקים של אותה תוכנית, שבתורה תצא מפונקציית fork() . תהליך הילד החדש שנוצר (ביחס לתהליך האב שיצר אותו) לא יבוצע עוד, החל מהפונקציה main() . יש לזכור שתהליך צאצא אינו העתק מדויק של תהליך האב; בפרט, יש לו מרחב כתובות משלו, אוגרים משלו, מצביע משלו להוראות ניתנות להפעלה וכדומה. לפיכך, הערך המוחזר למתקשר של הפונקציה fork() יהיה שונה. בפרט, תהליך האב יקבל את ערך ה-PID של תהליך הילד כהחזרה, והילד יקבל ערך השווה ל-0. באמצעות קודי ההחזרה הללו, תוכל לאחר מכן להפריד תהליכים ולאלץ כל אחד מהם לעשות את העבודה שלו. . עם זאת, הביצוע של תוכנית זו אינו מוגדר בקפדנות. לאחר חלוקה ל-2 תהליכים, מערכת ההפעלה מתחילה לנטר אותם, כמו גם לתכנן את עבודתם. אם יבוצע על מעבד ליבה אחת, אחד התהליכים, במקרה זה ההורה, ימשיך לעבוד, ואז תהליך הצאצא יקבל שליטה. בעת הפעלה מחדש, המצב עשוי להיות שונה.

שיחה המתן()

שקול את התוכנית הבאה. בתוכנית זו, עקב נוכחות שיחה לַחֲכוֹת() תהליך ההורה תמיד ימתין לסיום תהליך הילד. במקרה זה, נקבל פלט טקסט מוגדר בקפדנות על המסך

exec() קריאה

קחו בחשבון את האתגר exec (). קריאת מערכת זו שימושית כאשר אנו רוצים להפעיל תוכנית שונה לחלוטין. כאן נתקשר execvp() להפעיל את תוכנית wc שהיא תוכנית לספירת מילים. מה קורה כשנקרא exec()? קריאה זו מועברת בשם קובץ ההפעלה וכמה פרמטרים כארגומנטים. לאחר מכן נטענים הקוד והנתונים הסטטיים מקובץ ההפעלה הזה והקטע שלו עם הקוד מוחלף. אזורי הזיכרון הנותרים, כגון הערימה והערימה, מאתחלים מחדש. לאחר מכן מערכת ההפעלה פשוט מפעילה את התוכנית, ומעבירה לה קבוצה של ארגומנטים. אז לא יצרנו תהליך חדש, פשוט הפכנו את התוכנית הפועלת כעת לתוכנית פועלת אחרת. לאחר ביצוע הקריאה exec() בצאצא, נראה כאילו התוכנית המקורית לא רצה כלל.

סיבוך הפעלה זה נורמלי לחלוטין עבור מעטפת יוניקס, ומאפשר למעטפת זו לבצע קוד לאחר קריאה מזלג(), אבל לפני השיחה exec (). דוגמה לקוד כזה תהיה התאמת סביבת המעטפת לצרכי התוכנית המופעלת, לפני השקתה.

פָּגָז - רק תוכנית משתמש. היא מראה לך את שורת ההזמנה ומחכה שתכתוב בו משהו. ברוב המקרים, אם תכתוב שם את שם התוכנית, המעטפת תמצא את מיקומה, תקרא למתודה fork() ולאחר מכן תקרא סוג כלשהו של exec() כדי ליצור תהליך חדש ולחכות לסיומו באמצעות wait() call. כאשר תהליך הילד יוצא, המעטפת תחזור מהקריאה wait() ותדפיס שוב את ההנחיה ותמתין להזנת הפקודה הבאה.

הפיצול fork() & exec() מאפשר למעטפת לבצע את הדברים הבאים, למשל:
wc file > new_file.

בדוגמה זו, הפלט של תוכנית wc מנותב לקובץ. הדרך בה המעטפת משיגה זאת היא די פשוטה - על ידי יצירת תהליך ילד לפני ההתקשרות exec (), המעטפת סוגרת פלט סטנדרטי ופותחת את הקובץ קובץ חדש, לפיכך, כל הפלט מהתוכנית הפועלת בהמשך wc יופנה לקובץ במקום למסך.

צינור יוניקס מיושמים בצורה דומה, עם ההבדל שהם משתמשים ב-pipe() call. במקרה זה, זרם הפלט של התהליך יחובר לתור צינור הממוקם בקרנל, אליו יחובר זרם הקלט של תהליך אחר.

מקור: www.habr.com