ऑपरेटिंग सिस्टम का परिचय

हे हबर! मैं आपकी राय में एक दिलचस्प साहित्य - OSTEP के लेखों-अनुवादों की एक श्रृंखला पर आपका ध्यान आकर्षित करना चाहता हूं। यह सामग्री यूनिक्स जैसे ऑपरेटिंग सिस्टम के काम पर काफी गहराई से चर्चा करती है, अर्थात् प्रक्रियाओं, विभिन्न अनुसूचकों, मेमोरी और अन्य समान घटकों के साथ काम करती है जो एक आधुनिक ओएस बनाते हैं। आप यहां सभी सामग्रियों का मूल देख सकते हैं यहां. कृपया ध्यान दें कि अनुवाद अव्यवसायिक रूप से (काफी स्वतंत्र रूप से) किया गया था, लेकिन मुझे आशा है कि मैंने सामान्य अर्थ बनाए रखा है।

इस विषय पर लैब का काम यहां पाया जा सकता है:

• मूल
• मूल
• मेरा व्यक्तिगत अनुकूलन

अन्य भागों:

• भाग 1: परिचय
• भाग 2: अमूर्तन: प्रक्रिया
• भाग 3: प्रक्रिया एपीआई का परिचय

आप मेरा चैनल पर भी देख सकते हैं तार =)

खतरे की घंटी! इस व्याख्यान के लिए एक प्रयोगशाला है! देखना GitHub

प्रक्रिया एपीआई

आइए UNIX प्रणाली में एक प्रक्रिया बनाने का एक उदाहरण देखें। यह दो सिस्टम कॉल के माध्यम से होता है कांटा() и कार्यकारी ().

कॉल कांटा()

एक प्रोग्राम पर विचार करें जो फोर्क() कॉल करता है। इसके क्रियान्वयन का परिणाम इस प्रकार होगा.

सबसे पहले, हम मुख्य() फ़ंक्शन दर्ज करते हैं और स्ट्रिंग को स्क्रीन पर प्रिंट करते हैं। पंक्ति में प्रक्रिया पहचानकर्ता होता है जिसे मूल में कहा जाता है पीआईडी या प्रक्रिया पहचानकर्ता. इस पहचानकर्ता का उपयोग UNIX में किसी प्रक्रिया को संदर्भित करने के लिए किया जाता है। अगला कमांड फोर्क() को कॉल करेगा। इस बिंदु पर, प्रक्रिया की लगभग एक सटीक प्रतिलिपि बनाई जाती है। ओएस के लिए, ऐसा लगता है कि सिस्टम पर एक ही प्रोग्राम की 2 प्रतियां चल रही हैं, जो बदले में फोर्क() फ़ंक्शन से बाहर निकल जाएंगी। नव निर्मित चाइल्ड प्रक्रिया (उस मूल प्रक्रिया के संबंध में जिसने इसे बनाया है) को अब मुख्य() फ़ंक्शन से शुरू करके निष्पादित नहीं किया जाएगा। यह याद रखना चाहिए कि एक चाइल्ड प्रक्रिया मूल प्रक्रिया की सटीक प्रतिलिपि नहीं है; विशेष रूप से, इसका अपना पता स्थान, अपने स्वयं के रजिस्टर, निष्पादन योग्य निर्देशों के लिए अपना स्वयं का सूचक और इसी तरह की चीजें होती हैं। इस प्रकार, फोर्क() फ़ंक्शन के कॉलर को लौटाया गया मान भिन्न होगा। विशेष रूप से, मूल प्रक्रिया को रिटर्न के रूप में चाइल्ड प्रक्रिया का पीआईडी ​​मान प्राप्त होगा, और बच्चे को 0 के बराबर मान प्राप्त होगा। इन रिटर्न कोड का उपयोग करके, आप फिर प्रक्रियाओं को अलग कर सकते हैं और उनमें से प्रत्येक को अपना काम करने के लिए मजबूर कर सकते हैं . हालाँकि, इस कार्यक्रम के निष्पादन को कड़ाई से परिभाषित नहीं किया गया है। 2 प्रक्रियाओं में विभाजित होने के बाद, ओएस उनकी निगरानी करना शुरू कर देता है, साथ ही उनके काम की योजना भी बनाता है। यदि सिंगल-कोर प्रोसेसर पर निष्पादित किया जाता है, तो प्रक्रियाओं में से एक, इस मामले में मूल, काम करना जारी रखेगी, और फिर चाइल्ड प्रक्रिया को नियंत्रण प्राप्त होगा। पुनः प्रारंभ करने पर स्थिति भिन्न हो सकती है.

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

निम्नलिखित कार्यक्रम पर विचार करें. इस कार्यक्रम में, एक कॉल की उपस्थिति के कारण रुको() मूल प्रक्रिया हमेशा चाइल्ड प्रक्रिया के पूरा होने की प्रतीक्षा करेगी। इस मामले में, हमें स्क्रीन पर कड़ाई से परिभाषित टेक्स्ट आउटपुट मिलेगा

कार्यकारी() कॉल

चुनौती पर विचार करें कार्यकारी (). यह सिस्टम कॉल तब उपयोगी होती है जब हम एक पूरी तरह से अलग प्रोग्राम चलाना चाहते हैं। यहां हम कॉल करेंगे कार्यकारी() wc प्रोग्राम को चलाने के लिए जो एक शब्द गणना प्रोग्राम है। क्या होता है जब exec() कहा जाता है? इस कॉल को निष्पादन योग्य फ़ाइल का नाम और कुछ मापदंडों को तर्क के रूप में पारित किया जाता है। जिसके बाद इस निष्पादन योग्य फ़ाइल से कोड और स्थिर डेटा लोड किया जाता है और कोड के साथ इसके स्वयं के खंड को अधिलेखित कर दिया जाता है। शेष मेमोरी क्षेत्र, जैसे स्टैक और हीप, को पुनः प्रारंभ किया जाता है। जिसके बाद ओएस बस प्रोग्राम को निष्पादित करता है, इसे तर्कों का एक सेट पास करता है। इसलिए हमने कोई नई प्रक्रिया नहीं बनाई, हमने बस वर्तमान में चल रहे प्रोग्राम को दूसरे चल रहे प्रोग्राम में बदल दिया। वंशज में exec() कॉल निष्पादित करने के बाद, ऐसा प्रतीत होता है जैसे मूल प्रोग्राम बिल्कुल नहीं चला।

यह स्टार्टअप जटिलता यूनिक्स शेल के लिए पूरी तरह से सामान्य है, और उस शेल को कॉल करने के बाद कोड निष्पादित करने की अनुमति देती है कांटा(), लेकिन कॉल से पहले कार्यकारी (). ऐसे कोड का एक उदाहरण लॉन्च किए जा रहे प्रोग्राम की ज़रूरतों के अनुसार शेल वातावरण को लॉन्च करने से पहले समायोजित करना होगा।

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

कांटा() और कार्यकारी() विभाजन शेल को निम्नलिखित चीजें करने की अनुमति देता है, उदाहरण के लिए:
wc फ़ाइल > new_file.

इस उदाहरण में, wc प्रोग्राम का आउटपुट एक फ़ाइल पर रीडायरेक्ट किया गया है। जिस तरह से शेल इसे प्राप्त करता है वह काफी सरल है - कॉल करने से पहले एक चाइल्ड प्रक्रिया बनाकर कार्यकारी (), शेल मानक आउटपुट को बंद कर देता है और फ़ाइल खोलता है नई फ़ाइल, इस प्रकार, आगे चल रहे प्रोग्राम से सभी आउटपुट wc स्क्रीन के बजाय फ़ाइल पर पुनर्निर्देशित किया जाएगा।

यूनिक्स पाइप समान तरीके से कार्यान्वित किया जाता है, अंतर यह है कि वे पाइप() कॉल का उपयोग करते हैं। इस स्थिति में, प्रक्रिया की आउटपुट स्ट्रीम कर्नेल में स्थित एक पाइप कतार से जुड़ी होगी, जिससे किसी अन्य प्रक्रिया की इनपुट स्ट्रीम जुड़ी होगी।

स्रोत: www.habr.com