ऑपरेटिंग सिस्टमची ओळख

अहो हाब्र! मी तुमच्या लक्षात आणून देऊ इच्छितो लेखांची मालिका-माझ्या मते एका मनोरंजक साहित्याचे भाषांतर - OSTEP. ही सामग्री युनिक्स सारख्या ऑपरेटिंग सिस्टीमच्या कार्याची सखोल चर्चा करते, म्हणजे, प्रक्रियांसह कार्य, विविध शेड्यूलर, मेमरी आणि आधुनिक OS बनविणारे इतर समान घटक. आपण येथे सर्व सामग्रीचे मूळ पाहू शकता येथे. कृपया लक्षात ठेवा की भाषांतर अव्यावसायिकपणे केले गेले आहे (अगदी मुक्तपणे), परंतु मला आशा आहे की मी सामान्य अर्थ राखला आहे.

या विषयावरील प्रयोगशाळेतील कार्य येथे आढळू शकते:

• मूळ
• मूळ
• माझे वैयक्तिक रुपांतर

इतर भाग:

• भाग 1: परिचय
• भाग 2: अमूर्तता: प्रक्रिया
• भाग 3: प्रक्रिया API चा परिचय

तुम्ही माझे चॅनल येथे देखील पाहू शकता तार =)

गजर! या व्याख्यानासाठी प्रयोगशाळा आहे! दिसत github

प्रक्रिया API

युनिक्स प्रणालीमध्ये प्रक्रिया तयार करण्याचे उदाहरण पाहू. हे दोन सिस्टम कॉलद्वारे होते काटा () и exec().

कॉल फोर्क()

फोर्क() कॉल करणाऱ्या प्रोग्रामचा विचार करा. त्याच्या अंमलबजावणीचा परिणाम खालीलप्रमाणे असेल.

सर्व प्रथम, आपण main() फंक्शन प्रविष्ट करतो आणि स्ट्रिंग स्क्रीनवर प्रिंट करतो. ओळीत प्रक्रिया अभिज्ञापक आहे ज्याला मूळ म्हणतात पी आय डी किंवा प्रक्रिया अभिज्ञापक. हा अभिज्ञापक UNIX मध्ये प्रक्रियेचा संदर्भ देण्यासाठी वापरला जातो. पुढील कमांड फोर्क () कॉल करेल. या टप्प्यावर, प्रक्रियेची जवळजवळ अचूक प्रत तयार केली जाते. OS साठी, असे दिसते की सिस्टमवर समान प्रोग्रामच्या 2 प्रती चालू आहेत, ज्यामुळे फोर्क() फंक्शनमधून बाहेर पडेल. नवीन तयार केलेली चाइल्ड प्रक्रिया (ती तयार केलेल्या पालक प्रक्रियेच्या संबंधात) यापुढे मुख्य() फंक्शनपासून सुरू होणारी कार्यान्वित केली जाणार नाही. हे लक्षात ठेवले पाहिजे की मूल प्रक्रिया ही पालक प्रक्रियेची अचूक प्रत नाही; विशेषतः, तिचे स्वतःचे पत्त्याचे स्थान, स्वतःचे रजिस्टर्स, स्वतःचे एक्झिक्युटेबल सूचनांचे सूचक आणि इतर गोष्टी आहेत. अशा प्रकारे, फोर्क() फंक्शनच्या कॉलरला परत केलेले मूल्य वेगळे असेल. विशेषतः, पालक प्रक्रियेला मुलाच्या प्रक्रियेचे पीआयडी मूल्य परतावा म्हणून प्राप्त होईल, आणि मुलाला 0 च्या बरोबरीचे मूल्य प्राप्त होईल. या रिटर्न कोड्सचा वापर करून, तुम्ही नंतर प्रक्रिया विभक्त करू शकता आणि प्रत्येकाला स्वतःचे काम करण्यास भाग पाडू शकता. . तथापि, या कार्यक्रमाची अंमलबजावणी कठोरपणे परिभाषित केलेली नाही. 2 प्रक्रियांमध्ये विभागल्यानंतर, OS त्यांचे निरीक्षण करण्यास सुरुवात करते, तसेच त्यांच्या कामाची योजना देखील करते. सिंगल-कोर प्रोसेसरवर कार्यान्वित केल्यास, प्रक्रियांपैकी एक, या प्रकरणात, पालक, कार्य करणे सुरू ठेवेल, आणि नंतर बाल प्रक्रिया नियंत्रण प्राप्त करेल. रीस्टार्ट करताना, परिस्थिती वेगळी असू शकते.

कॉल प्रतीक्षा ()

खालील कार्यक्रमाचा विचार करा. या कार्यक्रमात हाकेच्या बळावर आ प्रतीक्षा करा() मूल प्रक्रिया पूर्ण होण्याची पालक प्रक्रिया नेहमीच प्रतीक्षा करेल. या प्रकरणात, आम्हाला स्क्रीनवर कठोरपणे परिभाषित मजकूर आउटपुट मिळेल

exec() कॉल

आव्हानाचा विचार करा exec(). जेव्हा आम्हाला पूर्णपणे भिन्न प्रोग्राम चालवायचा असेल तेव्हा हा सिस्टम कॉल उपयुक्त आहे. येथे आपण कॉल करू execvp() wc प्रोग्राम चालवण्यासाठी जो शब्द मोजणी कार्यक्रम आहे. exec() म्हणतात तेव्हा काय होते? हा कॉल एक्झिक्युटेबल फाइलचे नाव आणि काही पॅरामीटर्स वितर्क म्हणून पास केला जातो. त्यानंतर या एक्झिक्युटेबल फाइलमधील कोड आणि स्टॅटिक डेटा लोड केला जातो आणि कोडसह त्याचा स्वतःचा सेगमेंट ओव्हरराईट केला जातो. उर्वरित मेमरी क्षेत्रे, जसे की स्टॅक आणि हीप, पुन्हा सुरू केले जातात. ज्यानंतर OS फक्त प्रोग्रॅम कार्यान्वित करते, वितर्कांचा संच पास करते. म्हणून आम्ही नवीन प्रक्रिया तयार केली नाही, आम्ही फक्त सध्या चालू असलेल्या प्रोग्रामला दुसर्‍या चालू असलेल्या प्रोग्राममध्ये रूपांतरित केले. descendant मध्ये exec() कॉल कार्यान्वित केल्यानंतर, असे दिसते की मूळ प्रोग्राम अजिबात चालला नाही.

युनिक्स शेलसाठी ही स्टार्टअप गुंतागुंत पूर्णपणे सामान्य आहे आणि कॉल केल्यानंतर त्या शेलला कोड कार्यान्वित करण्यास अनुमती देते. काटा (), पण कॉल करण्यापूर्वी exec(). अशा कोडचे उदाहरण म्हणजे लॉन्च होण्यापूर्वी, लॉन्च होत असलेल्या प्रोग्रामच्या गरजेनुसार शेल वातावरण समायोजित करणे.

शेल - फक्त एक वापरकर्ता कार्यक्रम. ती तुम्हाला आमंत्रणाची ओळ दाखवते आणि त्यात तुम्ही काहीतरी लिहिण्याची वाट पाहते. बर्‍याच प्रकरणांमध्ये, जर तुम्ही प्रोग्रामचे नाव तेथे लिहिल्यास, शेलला त्याचे स्थान सापडेल, फोर्क() पद्धतीवर कॉल करा आणि नंतर नवीन प्रक्रिया तयार करण्यासाठी काही प्रकारच्या exec() वर कॉल करा आणि ते वापरून पूर्ण होण्याची प्रतीक्षा करा. प्रतीक्षा () कॉल. चाइल्ड प्रोसेस बाहेर पडल्यावर, शेल प्रतीक्षा() कॉलमधून परत येईल आणि प्रॉम्प्ट पुन्हा प्रिंट करेल आणि पुढील कमांड एंटर होण्याची प्रतीक्षा करेल.

fork() आणि exec() स्प्लिट शेलला खालील गोष्टी करू देते, उदाहरणार्थ:
wc फाइल > new_file.

या उदाहरणात, wc प्रोग्रामचे आउटपुट फाइलवर पुनर्निर्देशित केले जाते. शेलने हे साध्य करण्याचा मार्ग अगदी सोपा आहे - कॉल करण्यापूर्वी मूल प्रक्रिया तयार करून exec(), शेल मानक आउटपुट बंद करतो आणि फाइल उघडतो नवीन_फाइल, अशा प्रकारे, पुढील चालू असलेल्या प्रोग्राममधून सर्व आउटपुट wc स्क्रीनऐवजी फाइलवर पुनर्निर्देशित केले जाईल.

युनिक्स पाईप पाईप() कॉल वापरण्याच्या फरकासह, त्याच प्रकारे अंमलात आणले जातात. या प्रकरणात, प्रक्रियेचा आउटपुट प्रवाह कर्नलमध्ये असलेल्या पाईप रांगेशी जोडला जाईल, ज्याला दुसर्या प्रक्रियेचा इनपुट प्रवाह जोडला जाईल.

स्त्रोत: www.habr.com