System calls: fork, exec और wait
लक्ष्य और model
Kernel से service माँगने और सामान्य function call का अंतर समझें; process creation trace करें; creation, replacement और waiting को अलग रखें। पूर्वज्ञान: प्रकाशित processes/threads पाठ। UNIX-जैसी APIs यहाँ ठोस teaching model हैं; उनके नाम हर OS के लिए अनिवार्य नहीं। जब अलग न कहा हो, सभी operations सफल हैं, programs single-threaded हैं और signals waits को बाधित नहीं करते। printf buffering की जगह स्पष्ट abstract emit operations गिने जाते हैं।
1. सुरक्षित service counter
ऐसी library सोचें जहाँ visitors बंद records room में सीधे नहीं जा सकते। वे counter पर अनुरोध देते हैं और अधिकृत कर्मचारी उसे जाँचकर काम करते हैं। User mode visitor area जैसा और kernel mode सुरक्षित room जैसा है। System call OS service का नियंत्रित अनुरोध है, जैसे file पढ़ना या process बनाना। Hardware-supported entry kernel handler तक control ले जाती है; handler arguments और permissions जाँचकर result या error लौटाता है।
हर request का अर्थ नया कर्मचारी नहीं: kernel में प्रवेश अपने-आप दूसरे process पर switch नहीं है। Mode transition privilege बदलता है; process context switch scheduled execution context बदलता है। तुरंत पूरी हो सकने वाली read उसी process में लौट सकती है। Input की प्रतीक्षा वाली read उसे block कर सकती है, जिससे दूसरा process चले। हर function/library call system call नहीं है। Library user space में गणना कर सकती है, requests buffer कर सकती है या kernel operations को wrap कर सकती है।
2. fork: एक execution से दो
सफल fork एक child बनाता है। Parent और child दोनों उसी fork के बाद से चलते हैं। Child को return value 0 और parent को child का positive PID मिलता है। Failure पर caller को −1 मिलता है और child नहीं बनता। Return values से कौन पहले चलेगा, यह नहीं तय होता।
Child का अलग virtual address space होता है। Private variables के आरंभिक values समान हो सकते हैं, पर बाद का write दूसरे process की private copy नहीं बदलता। Copy-on-write तुरंत physical copying से बचा सकता है; फिर भी logical isolation बना रहता है। इसलिए implementation देखकर private variables को shared न मानें।
हल किया उदाहरण: private x=6 से शुरू करें। एक सफल fork के बाद child x=x+4 और parent x=x−1 करता है। Child का x=10, parent का x=5। कोई एक shared final x नहीं है। Explicitly shared memory का contract अलग है।
3. Source lines नहीं, executions गिनें
हर process लगातार तीन unconditional सफल fork calls करके एक token emit करता है। हर stage के बाद संख्या 1→2→4→8 होती है। आठ tokens निकलेंगे और सात नए children बने होंगे। कुल आठ में मूल process शामिल है। यह doubling तभी सही है जब हर मौजूद process शेष हर fork तक पहुँचे।
Conditional उदाहरण: p=fork(); यदि p==0 हो तो fork(); फिर एक token emit करें। पहला fork parent P और child C देता है। केवल C दूसरा fork करके D बनाता है। P,C,D एक-एक token देते हैं, इसलिए तीन tokens। 2 की power लगाने से पहले branching tree बनाएँ। सफल exec या early exit बाद के code paths हटा सकते हैं।
4. exec: वही process, नया program
सफल exec-family operation caller का program image बदलकर नया program शुरू करता है। नया process नहीं बनता; PID वही रहता है। पुराने program में exec के तुरंत बाद वाला statement सफलता पर नहीं चलता। Exec fail हो तो error लौटता है और पुराना program जारी रहता है; इसलिए failure handling जरूरी है।
हल किया trace: parent एक child fork करता है। Child सफल exec से program B चलाता है, जो B emit करके terminate होता है। Parent उस child की termination का सफल wait करके P emit करता है। कुल दो processes हैं और order B फिर P है। यह order wait देता है, fork अकेला नहीं। Child का आगे का व्यवहार नए program से तय होता है, हटाए गए पुराने code से नहीं।
5. wait: termination जानकारी लेना
किसी निर्दिष्ट child की termination का सफल wait parent को status लेने और child को reap करने देता है। Child पहले समाप्त हो चुका हो तो wait को block नहीं करना पड़ता। Child चल रहा हो तो सामान्य blocking wait parent को suspend कर सकता है। समाप्त पर अभी unreaped child zombie है: वह instructions execute नहीं कर रहा। जिसका parent terminate हो गया वह orphan है। Orphan और zombie अलग स्थितियाँ हैं।
कई children हों तो किसी भी child की प्रतीक्षा और विशेष child की प्रतीक्षा अलग रखें। Child C का सफल wait असंबंधित D का order अपने-आप तय नहीं करता। Errors, signals और nonblocking flags की assumptions स्पष्ट करें।
परीक्षा विधि और भ्रम
हर process का path बनाएँ, सफल creations गिनें और successful exec से हटे code को काटें। Private values हर process के लिए अलग रखें। केवल दी हुई synchronization से ordering edges जोड़ें। Total processes, नए children और output operations में अंतर करें। System call को context switch, exec को fork और zombie को अभी चल रहा blocked program न समझें।
मौलिक अभ्यास: छह single-correct MCQ
हर प्रश्न में ठीक एक विकल्प चुनें। हर प्रश्न की आवश्यक मान्यताएँ उसी में दी गई हैं।
SC01. एक process तीन लगातार unconditional fork करता है। सभी सफल हैं और सभी descendants शेष calls करते हैं। मूल सहित कुल कितने processes होंगे?
A. 3 B. 4 C. 7 D. 8
उत्तर: D
A: तीन source calls की संख्या है।
B: दो stages के बाद चार होते हैं।
C: सात नए children हैं।
D: संख्या 1→2→4→8 होती है।
SC02. एक process से p=fork(); केवल p==0 पर एक और fork(); फिर हर process एक बार emit करता है। सभी किए गए forks सफल हैं। कितने emissions होंगे?
A. 2 B. 3 C. 4 D. 1
उत्तर: B
A: Conditional fork का child छूट गया।
B: मूल parent, पहला child और दूसरा child एक-एक emit करते हैं।
C: Parent conditional fork नहीं करता।
D: सफल creation से और emitting processes बनते हैं।
SC03. एक process दूसरे program का सफल exec करता है। सही कथन कौन सा है?
A. नया child अनिवार्य है B. PID अवश्य बदलता है C. Program image बदलता है, PID वही रहता है D. पुराने program का अगला statement चलता है
उत्तर: C
A: इस model में creation fork करता है।
B: सफल exec process identity रखता है।
C: Replacement और creation अलग हैं।
D: Failed exec ही पुराने continuation में लौटता है।
SC04. सफल fork पर private x=9 logically copy होता है। Child 2 घटाता है; parent 3 जोड़ता है। Shared memory नहीं है। Parent और child values क्या हैं?
A. 10,10 B. 12,7 C. 7,12 D. 12,12
उत्तर: B
A: दोनों updates जोड़ना x को गलत ढंग से shared मानता है।
B: अलग गणनाएँ: parent 9+3=12; child 9−2=7।
C: Parent और child उलटे हैं।
D: Parent update child copy नहीं बदलता।
SC05. Child C, C emit करके समाप्त होता है। Parent उसकी termination का सफल wait करके P emit करता है। Buffering/errors नहीं हैं। निश्चित order क्या है?
A. P फिर C B. C फिर P C. कोई भी order D. P कभी नहीं निकलेगा
उत्तर: B
A: P सफल termination wait के बाद है।
B: C termination से पहले, और termination parent wait पूरा होने से पहले है।
C: दी हुई wait ordering constraint देती है।
D: सफल wait parent को आगे चलने देता है।
SC06. सामान्य protected OS में कौन सा निष्कर्ष सही है?
A. हर system call दूसरे process पर switch करता है B. हर library function kernel में जाता है C. System call controlled entry से kernel service माँगता है D. Zombie child अभी user instructions चला रहा है
उत्तर: C
A: Privilege transition के लिए दूसरा process चलाना जरूरी नहीं।
B: User-space computation kernel में जाए बिना हो सकती है।
C: Controlled entry service boundary है।
D: Zombie समाप्त पर unreaped है।
स्रोत और दायरा
यह मौलिक पाठ GATE 2026 course के मौजूदा OS foundations को आगे बढ़ाता है। इसका संबंध आधिकारिक 2026 syllabus के Section 8 से है; यह पूरे OS या GATE 2027 की पूर्ण तैयारी का दावा नहीं है। अभ्यास मौलिक हैं, पिछले वर्षों के प्रश्न नहीं।
स्रोत जाँचे गए: 2026-10-14।
प्रगति सहेजने के लिए साइन इन करें। साइन इन