अपरेटिङ सिस्टम को परिचय

नमस्ते, Habr! म तपाइँको ध्यान मा लेख को एक श्रृंखला प्रस्तुत गर्न चाहन्छु - एक साहित्य को अनुवाद जुन मेरो विचार मा रोचक छ - OSTEP। यो सामग्रीले युनिक्स-जस्तो अपरेटिङ सिस्टमहरूको कामलाई गहिरो रूपमा जाँच्छ, अर्थात्, प्रक्रियाहरू, विभिन्न शेड्यूलरहरू, मेमोरी र अन्य समान कम्पोनेन्टहरू जसले आधुनिक ओएस बनाउँछ। तपाईं यहाँ सबै सामग्रीको मूल हेर्न सक्नुहुन्छ यहाँ। कृपया ध्यान दिनुहोस् कि अनुवाद अव्यवसायिक रूपमा (धेरै स्वतन्त्र रूपमा) गरिएको थियो, तर मलाई आशा छ कि मैले सामान्य अर्थ राखेको छु।

यस विषयमा प्रयोगशाला काम यहाँ फेला पार्न सकिन्छ:

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

अन्य भागहरू:

• भाग १: परिचय
• भाग २: सार: प्रक्रिया
• भाग ३: प्रक्रिया API को परिचय

तपाईं मेरो च्यानल मा पनि जाँच गर्न सक्नुहुन्छ टेलीग्राम =)

अलार्म! यो व्याख्यान को लागी एक प्रयोगशाला छ! हेर github

प्रक्रिया API

UNIX प्रणालीमा प्रक्रिया सिर्जना गर्ने उदाहरण हेरौं। यो दुई प्रणाली कल मार्फत हुन्छ काँटा() и exec().

कल फोर्क()

फोर्क() कल गर्ने प्रोग्रामलाई विचार गर्नुहोस्। यसको कार्यान्वयनको नतिजा निम्नानुसार हुनेछ।

सबै भन्दा पहिले, हामी main() प्रकार्य प्रविष्ट गर्छौं र स्क्रिनमा स्ट्रिङ प्रिन्ट गर्छौं। रेखाले प्रक्रिया पहिचानकर्ता समावेश गर्दछ जुन मूलमा भनिन्छ पीआईडी वा प्रक्रिया पहिचानकर्ता। यो पहिचानकर्ता UNIX मा प्रक्रियालाई सन्दर्भ गर्न प्रयोग गरिन्छ। अर्को आदेशले फोर्क () लाई कल गर्नेछ। यस बिन्दुमा, प्रक्रियाको लगभग सटीक प्रतिलिपि सिर्जना गरिएको छ। OS को लागि, यस्तो देखिन्छ कि त्यहाँ प्रणालीमा चलिरहेको एउटै प्रोग्रामको 2 प्रतिलिपिहरू छन्, जसले फलस्वरूप फोर्क() प्रकार्यबाट बाहिर निस्कन्छ। नयाँ सिर्जना गरिएको चाइल्ड प्रक्रिया (यसलाई सिर्जना गरेको अभिभावक प्रक्रियाको सम्बन्धमा) अब मुख्य() प्रकार्यबाट सुरु गरी कार्यान्वयन गरिने छैन। यो याद राख्नु पर्छ कि बच्चा प्रक्रिया अभिभावक प्रक्रियाको सही प्रतिलिपि होइन; विशेष गरी, यसको आफ्नै ठेगाना ठाउँ, यसको आफ्नै दर्ताहरू, कार्यान्वयनयोग्य निर्देशनहरूको आफ्नै सूचक, र जस्तै। यसरी, फोर्क() प्रकार्यको कलरमा फर्काइएको मान फरक हुनेछ। विशेष गरी, अभिभावक प्रक्रियाले फिर्ताको रूपमा बाल प्रक्रियाको PID मान प्राप्त गर्नेछ, र बच्चाले ० बराबरको मान प्राप्त गर्नेछ। यी फिर्ती कोडहरू प्रयोग गरेर, तपाइँ त्यसपछि प्रक्रियाहरू अलग गर्न सक्नुहुन्छ र प्रत्येकलाई आफ्नै काम गर्न बाध्य पार्न सक्नुहुन्छ। । यद्यपि, यो कार्यक्रमको कार्यान्वयनलाई कडाइका साथ परिभाषित गरिएको छैन। 0 प्रक्रियाहरूमा विभाजन गरेपछि, OS ले तिनीहरूलाई निगरानी गर्न थाल्छ, साथै तिनीहरूको कामको योजना बनाउँछ। यदि एकल-कोर प्रोसेसरमा कार्यान्वयन गरियो भने, प्रक्रियाहरू मध्ये एउटा, यस अवस्थामा अभिभावकले काम गरिरहनेछ, र त्यसपछि बाल प्रक्रियाले नियन्त्रण प्राप्त गर्नेछ। पुन: सुरु गर्दा, स्थिति फरक हुन सक्छ।

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

निम्न कार्यक्रमलाई विचार गर्नुहोस्। यस कार्यक्रममा कलको उपस्थितिको कारण पर्ख () अभिभावक प्रक्रियाले सधैं बच्चा प्रक्रिया पूरा हुनको लागि पर्खनेछ। यस अवस्थामा, हामीले स्क्रिनमा कडा रूपमा परिभाषित पाठ आउटपुट पाउनेछौं

exec() कल गर्नुहोस्

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

यो स्टार्टअप जटिलता युनिक्स शेलको लागि पूर्ण रूपमा सामान्य छ, र त्यो शेललाई कल गरेपछि कोड कार्यान्वयन गर्न अनुमति दिन्छ। काँटा(), तर कल अघि exec()। यस्तो कोडको एक उदाहरणले यसलाई सुरु गर्नु अघि, कार्यक्रमको आवश्यकता अनुसार शेल वातावरण समायोजन गर्दैछ।

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

फोर्क() र exec() विभाजनले शेललाई निम्न कुराहरू गर्न अनुमति दिन्छ, उदाहरणका लागि:
wc फाइल> new_file।

यस उदाहरणमा, wc कार्यक्रमको आउटपुट फाइलमा रिडिरेक्ट गरिएको छ। शेलले यो प्राप्त गर्ने तरिका एकदम सरल छ - कल गर्नु अघि बच्चा प्रक्रिया सिर्जना गरेर exec(), शेलले मानक आउटपुट बन्द गर्छ र फाइल खोल्छ नयाँ_फाइल, यसरी, थप चलिरहेको कार्यक्रमबाट सबै आउटपुट wc स्क्रिनको सट्टा फाइलमा रिडिरेक्ट गरिनेछ।

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

स्रोत: www.habr.com