🧜🏿 📴 🏿 लिनक्स पर सीखने की प्रक्रिया 🌄 🏼 👩🏻‍🏫

इस लेख में, मैं लिनक्स ओएस परिवार में प्रक्रियाओं के जीवन पथ के बारे में बात करना चाहूंगा। सिद्धांत और उदाहरणों में, मैं देखूंगा कि कैसे प्रक्रियाएं पैदा होती हैं और मर जाती हैं, सिस्टम कॉल और सिग्नल के यांत्रिकी के बारे में थोड़ी बात करते हैं।

यह आलेख सिस्टम प्रोग्रामिंग में शुरुआती लोगों के लिए अधिक लक्षित है और जो लोग लिनक्स में काम करने की प्रक्रिया के बारे में थोड़ा और सीखना चाहते हैं।

नीचे लिखा सब कुछ 4.15.0 कर्नेल के साथ डेबियन लिनक्स पर लागू होता है।

सामग्री

परिचय

सिस्टम सॉफ़्टवेयर विशेष फ़ंक्शन के माध्यम से सिस्टम कोर के साथ इंटरैक्ट करता है - सिस्टम कॉल। दुर्लभ मामलों में, एक वैकल्पिक एपीआई है, उदाहरण के लिए, वर्चुअल फाइल सिस्टम के रूप में तैयार किए गए, खरीद या सफ़्स।

प्रक्रिया विशेषताएँ

कर्नेल में प्रक्रिया को कई क्षेत्रों के साथ एक संरचना के रूप में प्रस्तुत किया जाता है (संरचना की परिभाषा यहां पढ़ी जा सकती है )।
लेकिन चूंकि लेख सिस्टम प्रोग्रामिंग के लिए समर्पित है, और कर्नेल विकास नहीं है, हम कुछ हद तक अमूर्त हैं और बस हमारे लिए प्रक्रिया के महत्वपूर्ण क्षेत्रों पर ध्यान केंद्रित करते हैं:

प्रक्रिया आईडी (पीआईडी)
फ़ाइल विवरणिकाएँ खोलें (fd)
सिग्नल हैंडलर्स
वर्तमान कार्य निर्देशिका (cwd)
पर्यावरण चर (पर्यावरण)
रिटर्न कोड

प्रक्रिया जीवन चक्र

प्रक्रिया जन्म

सिस्टम में केवल एक प्रक्रिया एक विशेष तरीके से पैदा होती है - init - यह सीधे कर्नेल द्वारा उत्पन्न होती है। अन्य सभी प्रक्रियाएं fork(2) सिस्टम कॉल का उपयोग करके वर्तमान प्रक्रिया को डुप्लिकेट करके दिखाई देती हैं। fork(2) निष्पादित होने के बाद, हमें निम्नलिखित बिंदुओं के अपवाद के साथ दो लगभग समान प्रक्रियाएं मिलती हैं:

fork(2) माता-पिता को बच्चे की पीआईडी लौटाता है, 0 बच्चे को वापस कर दिया जाता है;
बच्चा माता-पिता के पीआईडी (पेरेंट प्रोसेस आईडी) को पीआईडी में बदलता है।

fork(2) निष्पादित होने के बाद, बच्चे की प्रक्रिया के सभी संसाधन माता-पिता के संसाधनों की एक प्रति हैं। मेमोरी के सभी आवंटित पृष्ठों के साथ एक प्रक्रिया को कॉपी करना महंगा है, इसलिए लिनक्स कर्नेल कॉपी-ऑन-राइट तकनीक का उपयोग करता है।
माता-पिता की याद में सभी पृष्ठ केवल-पढ़ने के लिए चिह्नित किए जाते हैं और माता-पिता और बच्चे दोनों के लिए उपलब्ध होते हैं। जैसे ही कोई प्रक्रिया किसी विशेष पृष्ठ पर डेटा बदलती है, यह पृष्ठ नहीं बदलता है, लेकिन प्रतिलिपि पहले से ही कॉपी और बदल जाती है। इस मामले में, मूल इस प्रक्रिया से "अप्रकाशित" है। जैसे ही रीड-ओनली ओरिजिनल एक प्रोसेस के लिए "बाउंड" रहता है, पेज को रीड-राइट स्टेटस पर रिजेक्ट किया जाता है।

कांटा के साथ एक सरल बेकार कार्यक्रम का एक उदाहरण (2)

 #include <stdio.h> #include <unistd.h> #include <errno.h> #include <sys/wait.h> #include <sys/types.h> int main() { int pid = fork(); switch(pid) { case -1: perror("fork"); return -1; case 0: // Child printf("my pid = %i, returned pid = %i\n", getpid(), pid); break; default: // Parent printf("my pid = %i, returned pid = %i\n", getpid(), pid); break; } return 0; }

 $ gcc test.c && ./a.out my pid = 15594, returned pid = 15595 my pid = 15595, returned pid = 0

तैयार अवस्था

निष्पादन के तुरंत बाद, fork(2) तैयार अवस्था में प्रवेश करता है।
वास्तव में, प्रक्रिया कतार में होती है और प्रोसेसर पर प्रक्रिया को चलने देने के लिए कर्नेल में अनुसूचक का इंतजार करती है।

स्थिति प्रगति पर है

जैसे ही अनुसूचक ने निष्पादन की प्रक्रिया शुरू की, "चालू" स्थिति शुरू हो गई। प्रक्रिया समय की पूरी प्रस्तावित अवधि (क्वांटम) चला सकती है, या यह sched_yield सिस्टम निर्यात का उपयोग करके अन्य प्रक्रियाओं को रास्ता दे सकती है।

एक अन्य कार्यक्रम में पुनर्जन्म

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

 int execve(const char *filename, char *const argv[], char *const envp[]);

या लाइब्रेरी कॉल execl(3), execlp(3), execle(3), execv(3), execvp(3), execvpe(3) :

 int execl(const char *path, const char *arg, ... /* (char *) NULL */); int execlp(const char *file, const char *arg, ... /* (char *) NULL */); int execle(const char *path, const char *arg, ... /*, (char *) NULL, char * const envp[] */); int execv(const char *path, char *const argv[]); int execvp(const char *file, char *const argv[]); int execvpe(const char *file, char *const argv[], char *const envp[]);

उपरोक्त सभी कॉल प्रोग्राम को निष्पादित करते हैं, जिस पथ को पहले तर्क में इंगित किया गया है। सफल होने पर, नियंत्रण को लोड किए गए प्रोग्राम में स्थानांतरित कर दिया जाता है और मूल पर वापस नहीं किया जाता है। इस स्थिति में, लोड किए गए प्रोग्राम में प्रक्रिया संरचना के सभी क्षेत्र हैं, केवल O_CLOEXEC के रूप में चिह्नित फ़ाइल O_CLOEXEC , वे बंद हो जाएंगे।

कैसे इन सभी चुनौतियों में भ्रमित न हों और सही को चुनें? यह नामकरण तर्क को समझने के लिए पर्याप्त है:

सभी कॉल exec साथ शुरू होते हैं
पाँचवाँ अक्षर तर्क के प्रकार को परिभाषित करता है:
- एल सूची के लिए खड़ा है, सभी मापदंडों को arg1, arg2, ..., NULL
- v वेक्टर के लिए खड़ा है, सभी मापदंडों को एक शून्य-समाप्त सरणी में पारित किया गया है;
पत्र पी , जो पथ के लिए खड़ा है , का पालन कर सकता है। यदि file तर्क "/" के अलावा किसी अन्य वर्ण से शुरू होता है, तो निर्दिष्ट file को PATHIST में सूचीबद्ध निर्देशिकाओं में देखा जाता है
अंतिम अक्षर ई हो सकता है, जो एनिटस को दर्शाता है । इस तरह के कॉल में, अंतिम तर्क फॉर्म key=value - पर्यावरण चर के शून्य-समाप्त स्ट्रिंग्स की एक शून्य-समाप्त सरणी है जो नए कार्यक्रम में पारित हो जाएगा।

उदाहरण के लिए / बिन / बिल्ली --help के माध्यम से कॉल निष्पादित करें

 #define _GNU_SOURCE #include <unistd.h> int main() { char* args[] = { "/bin/cat", "--help", NULL }; execve("/bin/cat", args, environ); // Unreachable return 1; }

 $ gcc test.c && ./a.out Usage: /bin/cat [OPTION]... [FILE]... Concatenate FILE(s) to standard output. * *

exec* कॉल परिवार आपको निष्पादन अधिकारों के साथ स्क्रिप्ट चलाने और शेबांग (#!) के अनुक्रम से शुरू करने की अनुमति देता है।

एग्जाम्पल का उपयोग करके एक खराब पैथ के साथ स्क्रिप्ट चलाने का एक उदाहरण

 #define _GNU_SOURCE #include <unistd.h> int main() { char* e[] = {"PATH=/habr:/rulez", NULL}; execle("/tmp/test.sh", "test.sh", NULL, e); // Unreachable return 1; }

 $ cat test.sh #!/bin/bash echo $0 echo $PATH $ gcc test.c && ./a.out /tmp/test.sh /habr:/rulez

एक सम्मेलन है जिसका तात्पर्य है कि argv [0] निष्पादन * परिवार में कार्यों के लिए अशक्त तर्कों से मेल खाता है। हालांकि, इसका उल्लंघन किया जा सकता है।

उदाहरण जब बिल्ली कुत्ते का उपयोग करके हो जाती है

 #define _GNU_SOURCE #include <unistd.h> int main() { execlp("cat", "dog", "--help", NULL); // Unreachable return 1; }

 $ gcc test.c && ./a.out Usage: dog [OPTION]... [FILE]... * *

एक जिज्ञासु पाठक यह देख सकता है कि int main(int argc, char* argv[]) फ़ंक्शन int main(int argc, char* argv[]) के हस्ताक्षर में एक संख्या है - तर्कों की संख्या, लेकिन कार्यों के exec* परिवार के लिए इस तरह का कुछ भी पारित नहीं किया जाता है। क्यों? क्योंकि जब कार्यक्रम शुरू होता है, तो नियंत्रण तुरंत मुख्य में स्थानांतरित नहीं किया जाता है। इससे पहले, glibc द्वारा परिभाषित कुछ क्रियाएं की जाती हैं, जिसमें गिनती argc शामिल है।

लंबित अवस्था

कुछ सिस्टम कॉल में एक लंबा समय लग सकता है, जैसे कि I / O। ऐसे मामलों में, प्रक्रिया एक "लंबित" स्थिति में चली जाती है। जैसे ही सिस्टम कॉल पूरा हो जाएगा, कर्नेल प्रक्रिया को "तैयार" स्थिति में डाल देगा।
लिनक्स पर, एक "प्रतीक्षा" स्थिति भी होती है जिसमें प्रक्रिया रुकावट संकेतों का जवाब नहीं देती है। इस स्थिति में, प्रक्रिया "अविनाशी" हो जाती है, और सभी आवक संकेत इस स्थिति को छोड़ने तक कतार में खड़े रहते हैं।
कर्नेल ही चुनता है कि प्रक्रिया को किस राज्य में स्थानांतरित किया जाए। ज्यादातर, I / O अनुरोध करने वाली प्रक्रियाएं "प्रतीक्षा (बिना रुकावट के)" स्थिति में होती हैं। यह बहुत ही तेज़ इंटरनेट के साथ रिमोट डिस्क (NFS) का उपयोग करते समय विशेष रूप से ध्यान देने योग्य है।

स्थिति बंद करो

आप इसे SIGSTOP सिग्नल भेजकर किसी भी समय एक प्रक्रिया रोक सकते हैं। यह प्रक्रिया एक "रुकी हुई" स्थिति में चली जाएगी और तब तक वहां रहेगी जब तक कि उसे काम करना जारी रखने (SIGCONT) या डाई (SIGKILL) का संकेत न मिल जाए। शेष संकेतों को कतारबद्ध किया जाएगा।

प्रक्रिया पूरी हो रही है

कोई भी कार्यक्रम खुद को बंद नहीं कर सकता है। वे केवल _exit सिस्टम कॉल के साथ सिस्टम को इसके लिए पूछ सकते हैं या किसी त्रुटि के कारण सिस्टम द्वारा समाप्त किया जा सकता है। यहां तक कि जब आप main() से एक नंबर लौटाते हैं main() , _exit को अभी भी निहित रूप से कहा जाता है।
हालांकि सिस्टम कॉल का तर्क अंतर है, केवल संख्या का कम बाइट रिटर्न कोड के रूप में लिया जाता है।

"लाश" की स्थिति

प्रक्रिया पूरी होने के तुरंत बाद (कोई फर्क नहीं पड़ता कि यह सही है या नहीं), कर्नेल इस बारे में जानकारी लिखता है कि प्रक्रिया कैसे समाप्त हुई और इसे "ज़ोंबी" स्थिति में डाल दिया। दूसरे शब्दों में, एक ज़ोंबी एक पूर्ण प्रक्रिया है, लेकिन इसकी स्मृति अभी भी कर्नेल में संग्रहीत है।
इसके अलावा, यह दूसरा राज्य है जिसमें प्रक्रिया SIGKILL सिग्नल को सुरक्षित रूप से अनदेखा कर सकती है, क्योंकि यह फिर से मर नहीं सकता है।

बेहोशी

रिटर्न कोड और प्रक्रिया पूरी होने का कारण अभी भी कर्नेल में संग्रहीत है और इसे वहां से लिया जाना चाहिए। ऐसा करने के लिए, आप उपयुक्त सिस्टम कॉल का उपयोग कर सकते हैं:

 pid_t wait(int *wstatus); /*  waitpid(-1, wstatus, 0) */ pid_t waitpid(pid_t pid, int *wstatus, int options);

प्रक्रिया की समाप्ति के बारे में सभी जानकारी इंट डेटा प्रकार में फिट होती है। waitpid(2) मैन पेज में वर्णित मैक्रो का उपयोग रिटर्न कोड और प्रोग्राम समाप्ति के कारण प्राप्त करने के लिए किया जाता है।

सही समापन और वापसी कोड प्राप्त करने का उदाहरण

 #include <stdio.h> #include <unistd.h> #include <errno.h> #include <sys/wait.h> #include <sys/types.h> int main() { int pid = fork(); switch(pid) { case -1: perror("fork"); return -1; case 0: // Child return 13; default: { // Parent int status; waitpid(pid, &status, 0); printf("exit normally? %s\n", (WIFEXITED(status) ? "true" : "false")); printf("child exitcode = %i\n", WEXITSTATUS(status)); break; } } return 0; }

 $ gcc test.c && ./a.out exit normally? true child exitcode = 13

गलत पूरा होने का उदाहरण

किसी दुर्घटना में परिणाम के रूप में argv [0] पास करना।

 #include <stdio.h> #include <unistd.h> #include <errno.h> #include <sys/wait.h> #include <sys/types.h> int main() { int pid = fork(); switch(pid) { case -1: perror("fork"); return -1; case 0: // Child execl("/bin/cat", NULL); return 13; default: { // Parent int status; waitpid(pid, &status, 0); if(WIFEXITED(status)) { printf("Exit normally with code %i\n", WEXITSTATUS(status)); } if(WIFSIGNALED(status)) { printf("killed with signal %i\n", WTERMSIG(status)); } break; } } return 0; }

 $ gcc test.c && ./a.out killed with signal 6

ऐसे समय होते हैं जब एक माता-पिता बच्चे की तुलना में पहले समाप्त हो जाते हैं। ऐसे मामलों में, init बच्चे का माता-पिता बन जाएगा और वह समय आने पर wait(2) कॉल का उपयोग करेगा।

माता-पिता द्वारा बच्चे की मृत्यु के बारे में जानकारी लेने के बाद, कर्नेल बच्चे के बारे में सारी जानकारी मिटा देता है ताकि जल्द ही एक और प्रक्रिया उसकी जगह ले ले।

धन्यवाद

डिजाइन में संपादन और सहायता के लिए साशा "अल" का धन्यवाद;

कठिन सवालों के स्पष्ट जवाब के लिए साशा "रीस" के लिए धन्यवाद।

उन्होंने मुझ पर हमला करने वाली प्रेरणा और मेरे सवालों के बैराज पर हमला किया।

लिनक्स पर सीखने की प्रक्रिया