ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ ആമുഖം

ഹേ ഹബർ! എന്റെ അഭിപ്രായത്തിൽ രസകരമായ ഒരു സാഹിത്യത്തിന്റെ വിവർത്തനങ്ങൾ - OSTEP - ലേഖനങ്ങളുടെ ഒരു പരമ്പര നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഈ മെറ്റീരിയൽ യുണിക്സ് പോലുള്ള ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ പ്രവർത്തനത്തെക്കുറിച്ച് വളരെ ആഴത്തിൽ ചർച്ചചെയ്യുന്നു, അതായത്, പ്രോസസ്സുകൾ, വിവിധ ഷെഡ്യൂളറുകൾ, മെമ്മറി, കൂടാതെ ഒരു ആധുനിക OS നിർമ്മിക്കുന്ന മറ്റ് സമാന ഘടകങ്ങൾ എന്നിവയുമായി പ്രവർത്തിക്കുക. എല്ലാ മെറ്റീരിയലുകളുടെയും ഒറിജിനൽ നിങ്ങൾക്ക് ഇവിടെ കാണാം ഇവിടെ. വിവർത്തനം പ്രൊഫഷണലായിട്ടല്ല (തീർച്ചയായും സ്വതന്ത്രമായി) നിർമ്മിച്ചിരിക്കുന്നത് എന്നത് ദയവായി ശ്രദ്ധിക്കുക, എന്നാൽ പൊതുവായ അർത്ഥം ഞാൻ നിലനിർത്തിയെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

ഈ വിഷയത്തെക്കുറിച്ചുള്ള ലാബ് വർക്ക് ഇവിടെ കാണാം:

• യഥാർത്ഥമായത്
• യഥാർത്ഥമായത്
• എന്റെ വ്യക്തിപരമായ പൊരുത്തപ്പെടുത്തൽ

മറ്റ് ഭാഗങ്ങൾ:

• ഭാഗം 1: ആമുഖം
• ഭാഗം 2: അമൂർത്തീകരണം: പ്രക്രിയ
• ഭാഗം 3: പ്രോസസ്സ് API-യുടെ ആമുഖം

നിങ്ങൾക്ക് എന്റെ ചാനൽ പരിശോധിക്കാനും കഴിയും ടെലഗ്രാം =)

അലാറം! ഈ പ്രഭാഷണത്തിനായി ഒരു ലാബ് ഉണ്ട്! നോക്കൂ ഗിത്തബ്

പ്രോസസ്സ് API

UNIX സിസ്റ്റത്തിൽ ഒരു പ്രക്രിയ സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം നോക്കാം. രണ്ട് സിസ്റ്റം കോളുകളിലൂടെയാണ് ഇത് സംഭവിക്കുന്നത് ഫോർക്ക് () и എക്സിക്().

കോൾ ഫോർക്ക്()

ഫോർക്ക്() കോൾ ചെയ്യുന്ന ഒരു പ്രോഗ്രാം പരിഗണിക്കുക. അതിന്റെ നിർവ്വഹണത്തിന്റെ ഫലം ഇനിപ്പറയുന്നതായിരിക്കും.

ഒന്നാമതായി, ഞങ്ങൾ പ്രധാന () ഫംഗ്ഷൻ നൽകി സ്ക്രീനിലേക്ക് സ്ട്രിംഗ് പ്രിന്റ് ചെയ്യുന്നു. വരിയിൽ പ്രോസസ് ഐഡന്റിഫയർ അടങ്ങിയിരിക്കുന്നു, അതിനെ ഒറിജിനലിൽ വിളിക്കുന്നു PID അല്ലെങ്കിൽ പ്രോസസ്സ് ഐഡന്റിഫയർ. ഈ ഐഡന്റിഫയർ ഒരു പ്രക്രിയയെ സൂചിപ്പിക്കാൻ UNIX-ൽ ഉപയോഗിക്കുന്നു. അടുത്ത കമാൻഡ് ഫോർക്ക് () എന്ന് വിളിക്കും. ഈ ഘട്ടത്തിൽ, പ്രക്രിയയുടെ ഏതാണ്ട് കൃത്യമായ പകർപ്പ് സൃഷ്ടിക്കപ്പെടുന്നു. OS-ന്, സിസ്റ്റത്തിൽ ഒരേ പ്രോഗ്രാമിന്റെ 2 പകർപ്പുകൾ പ്രവർത്തിക്കുന്നതായി തോന്നുന്നു, അത് ഫോർക്ക്() ഫംഗ്‌ഷനിൽ നിന്ന് പുറത്തുകടക്കും. പുതുതായി സൃഷ്‌ടിച്ച ചൈൽഡ് പ്രോസസ് (അത് സൃഷ്‌ടിച്ച പാരന്റ് പ്രോസസുമായി ബന്ധപ്പെട്ട്) മെയിൻ() ഫംഗ്‌ഷനിൽ നിന്ന് ആരംഭിച്ച് ഇനി എക്‌സിക്യൂട്ട് ചെയ്യില്ല. ഒരു ചൈൽഡ് പ്രോസസ്സ് പാരന്റ് പ്രോസസിന്റെ കൃത്യമായ പകർപ്പല്ലെന്ന് ഓർമ്മിക്കേണ്ടതാണ്; പ്രത്യേകിച്ചും, അതിന് അതിന്റേതായ വിലാസ ഇടം, സ്വന്തം രജിസ്റ്ററുകൾ, എക്സിക്യൂട്ടബിൾ നിർദ്ദേശങ്ങളിലേക്കുള്ള സ്വന്തം പോയിന്റർ എന്നിവയും മറ്റും ഉണ്ട്. അങ്ങനെ, ഫോർക്ക്() ഫംഗ്‌ഷന്റെ കോളറിന് നൽകിയ മൂല്യം വ്യത്യസ്തമായിരിക്കും. പ്രത്യേകിച്ചും, പാരന്റ് പ്രോസസിന് ചൈൽഡ് പ്രോസസിന്റെ PID മൂല്യം റിട്ടേണായി ലഭിക്കും, കൂടാതെ കുട്ടിക്ക് 0 ന് തുല്യമായ ഒരു മൂല്യം ലഭിക്കും. ഈ റിട്ടേൺ കോഡുകൾ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് പ്രോസസ്സുകൾ വേർതിരിക്കുകയും അവ ഓരോന്നും സ്വന്തം ജോലി ചെയ്യാൻ നിർബന്ധിക്കുകയും ചെയ്യാം. . എന്നിരുന്നാലും, ഈ പ്രോഗ്രാമിന്റെ നിർവ്വഹണം കർശനമായി നിർവചിച്ചിട്ടില്ല. 2 പ്രക്രിയകളായി വിഭജിച്ച ശേഷം, OS അവരെ നിരീക്ഷിക്കാനും അവരുടെ ജോലി ആസൂത്രണം ചെയ്യാനും തുടങ്ങുന്നു. ഒരു സിംഗിൾ കോർ പ്രൊസസറിൽ എക്സിക്യൂട്ട് ചെയ്യുകയാണെങ്കിൽ, പ്രക്രിയകളിലൊന്ന്, ഈ സാഹചര്യത്തിൽ, രക്ഷകർത്താവ് പ്രവർത്തിക്കുന്നത് തുടരും, തുടർന്ന് ചൈൽഡ് പ്രോസസ്സിന് നിയന്ത്രണം ലഭിക്കും. പുനരാരംഭിക്കുമ്പോൾ, സ്ഥിതി വ്യത്യസ്തമായിരിക്കാം.

കോൾ വെയിറ്റ്()

ഇനിപ്പറയുന്ന പ്രോഗ്രാം പരിഗണിക്കുക. ഈ പ്രോഗ്രാമിൽ, ഒരു കോളിന്റെ സാന്നിധ്യം കാരണം കാത്തിരിക്കുക() കുട്ടിയുടെ പ്രക്രിയ പൂർത്തിയാകുന്നതുവരെ പാരന്റ് പ്രോസസ് എപ്പോഴും കാത്തിരിക്കും. ഈ സാഹചര്യത്തിൽ, നമുക്ക് സ്ക്രീനിൽ കർശനമായി നിർവചിക്കപ്പെട്ട ടെക്സ്റ്റ് ഔട്ട്പുട്ട് ലഭിക്കും

exec() കോൾ

വെല്ലുവിളി പരിഗണിക്കുക എക്സിക്(). തികച്ചും വ്യത്യസ്തമായ ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കണമെങ്കിൽ ഈ സിസ്റ്റം കോൾ ഉപയോഗപ്രദമാണ്. ഇവിടെ ഞങ്ങൾ വിളിക്കും execvp() വേഡ് കൗണ്ടിംഗ് പ്രോഗ്രാമായ wc ​​പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കാൻ. exec() എന്ന് വിളിക്കുമ്പോൾ എന്ത് സംഭവിക്കും? ഈ കോൾ എക്സിക്യൂട്ടബിൾ ഫയലിന്റെ പേരും ചില പാരാമീറ്ററുകളും ആർഗ്യുമെന്റുകളായി കൈമാറുന്നു. അതിനുശേഷം ഈ എക്സിക്യൂട്ടബിൾ ഫയലിൽ നിന്നുള്ള കോഡും സ്റ്റാറ്റിക് ഡാറ്റയും ലോഡുചെയ്യുകയും കോഡിനൊപ്പം അതിന്റെ സ്വന്തം സെഗ്‌മെന്റ് തിരുത്തിയെഴുതുകയും ചെയ്യുന്നു. സ്റ്റാക്കും കൂമ്പാരവും പോലെ ശേഷിക്കുന്ന മെമ്മറി ഏരിയകൾ പുനരാരംഭിക്കുന്നു. അതിനുശേഷം OS പ്രോഗ്രാം ലളിതമായി എക്സിക്യൂട്ട് ചെയ്യുന്നു, അതിന് ഒരു കൂട്ടം ആർഗ്യുമെന്റുകൾ നൽകുന്നു. അതിനാൽ ഞങ്ങൾ ഒരു പുതിയ പ്രോസസ്സ് സൃഷ്‌ടിച്ചില്ല, നിലവിൽ പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമിനെ മറ്റൊരു റൺ ചെയ്യുന്ന പ്രോഗ്രാമാക്കി മാറ്റി. descendant-ൽ exec() കോൾ എക്സിക്യൂട്ട് ചെയ്‌ത ശേഷം, യഥാർത്ഥ പ്രോഗ്രാം പ്രവർത്തിക്കാത്തതുപോലെ ദൃശ്യമാകുന്നു.

ഈ സ്റ്റാർട്ടപ്പ് സങ്കീർണത ഒരു യുണിക്സ് ഷെല്ലിന് തികച്ചും സാധാരണമാണ്, കോളിന് ശേഷം കോഡ് എക്സിക്യൂട്ട് ചെയ്യാൻ ആ ഷെല്ലിനെ അനുവദിക്കുന്നു ഫോർക്ക് (), എന്നാൽ കോളിന് മുമ്പ് എക്സിക്(). അത്തരം കോഡിന്റെ ഒരു ഉദാഹരണം, സമാരംഭിക്കുന്നതിന് മുമ്പ്, സമാരംഭിക്കുന്ന പ്രോഗ്രാമിന്റെ ആവശ്യങ്ങൾക്ക് ഷെൽ എൻവയോൺമെന്റ് ക്രമീകരിക്കുന്നതാണ്.

ഷെൽ - ഒരു ഉപയോക്തൃ പ്രോഗ്രാം. അവൾ നിങ്ങൾക്ക് ക്ഷണരേഖ കാണിക്കുകയും അതിൽ എന്തെങ്കിലും എഴുതാൻ കാത്തിരിക്കുകയും ചെയ്യുന്നു. മിക്ക കേസുകളിലും, നിങ്ങൾ ഒരു പ്രോഗ്രാമിന്റെ പേര് അവിടെ എഴുതുകയാണെങ്കിൽ, ഷെൽ അതിന്റെ സ്ഥാനം കണ്ടെത്തും, ഫോർക്ക്() രീതി വിളിക്കുക, തുടർന്ന് ഒരു പുതിയ പ്രോസസ്സ് സൃഷ്ടിക്കുന്നതിന് ചില തരത്തിലുള്ള എക്‌സിക്()നെ വിളിക്കുകയും ഒരു ഉപയോഗിച്ച് പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കുകയും ചെയ്യും. കാത്തിരിക്കുക () കോൾ. ചൈൽഡ് പ്രോസസ്സ് എക്സിറ്റ് ചെയ്യുമ്പോൾ, ഷെൽ വെയിറ്റ്() കോളിൽ നിന്ന് തിരികെ വരികയും പ്രോംപ്റ്റ് വീണ്ടും പ്രിന്റ് ചെയ്യുകയും അടുത്ത കമാൻഡ് നൽകുന്നതിനായി കാത്തിരിക്കുകയും ചെയ്യും.

ഫോർക്ക്() & എക്സിക്() സ്പ്ലിറ്റ് ഷെല്ലിനെ ഇനിപ്പറയുന്ന കാര്യങ്ങൾ ചെയ്യാൻ അനുവദിക്കുന്നു, ഉദാഹരണത്തിന്:
wc ഫയൽ > new_file.

ഈ ഉദാഹരണത്തിൽ, wc പ്രോഗ്രാമിന്റെ ഔട്ട്പുട്ട് ഒരു ഫയലിലേക്ക് റീഡയറക്‌ട് ചെയ്യുന്നു. ഷെൽ ഇത് നേടുന്ന രീതി വളരെ ലളിതമാണ് - വിളിക്കുന്നതിന് മുമ്പ് ഒരു ചൈൽഡ് പ്രോസസ് സൃഷ്ടിച്ചുകൊണ്ട് എക്സിക്(), ഷെൽ സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ട് അടച്ച് ഫയൽ തുറക്കുന്നു new_file, അങ്ങനെ, കൂടുതൽ പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമിൽ നിന്നുള്ള എല്ലാ ഔട്ട്പുട്ടും wc സ്ക്രീനിന് പകരം ഒരു ഫയലിലേക്ക് റീഡയറക്ട് ചെയ്യും.

യുണിക്സ് പൈപ്പ് പൈപ്പ്() കോൾ ഉപയോഗിക്കുന്ന വ്യത്യാസത്തിൽ സമാനമായ രീതിയിൽ നടപ്പിലാക്കുന്നു. ഈ സാഹചര്യത്തിൽ, പ്രക്രിയയുടെ ഔട്ട്പുട്ട് സ്ട്രീം കേർണലിൽ സ്ഥിതി ചെയ്യുന്ന ഒരു പൈപ്പ് ക്യൂവിലേക്ക് ബന്ധിപ്പിക്കും, അതിലേക്ക് മറ്റൊരു പ്രക്രിയയുടെ ഇൻപുട്ട് സ്ട്രീം ബന്ധിപ്പിക്കും.

അവലംബം: www.habr.com