ലിനക്സ് കുറിപ്പുകൾ/പ്രോഗ്രാമും പ്രോസസുകളും

ഏതൊരു വിവിധോപയോഗ ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റത്തിലെയും സുപ്രധാനമായ ഭാഗമാണ് പ്രോസസ് മാനേജ്‌‌മെന്റ്. യൂണിക്സ്/ലിനക്സ് സിസ്റ്റങ്ങൾ ഇത് എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്ന് ഈ അദ്ധ്യായത്തിൽ ചർച്ചചെയ്യാം.

പ്രോഗ്രാം, പ്രോസസ്, ത്രെഡ്[തിരുത്തുക]

ആദ്യം തന്നെ പ്രോഗ്രാം, പ്രോസസ്സ്, ത്രെഡ് ഇവയൊക്കെ എന്താണെന്ന് നോക്കാം. ഒരു പ്രോഗ്രാം എന്നത് എക്സിക്യൂട്ട് ചെയ്യാൻ അല്ലെങ്കിൽ പ്രവർത്തിപ്പിക്കാൻ സാധിക്കുന്ന ഒരു ഫയൽ ആണ്. യന്ത്രഭാഷയിലുള്ള നിർദ്ദേശങ്ങൾ അടങ്ങിയിരിക്കുന്ന ഈ ഫയലുകളിൽ വിവരങ്ങൾ ക്രമീകരിക്കുന്നതിന് പ്രത്യേക രീതികൾ അവലംബിക്കുന്നു. ഓരോ ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റവും ഓരോ തരത്തിലാണ് എക്സിക്യൂട്ടബിൾ ഫയലുകൾ രേഖപ്പെടുത്തുന്നത്. വിൻഡോസിൽ പോർട്ടബിൽ എക്സിക്യൂട്ടബിൾ ഫോർമാറ്റ് (PE), യൂണിക്സ്/ലിനക്സ് സിസ്റ്റങ്ങളിൽ എക്സിക്യൂട്ടബിൾ ലിങ്കബിൾ ഫോർമാറ്റ് (ELF) എന്നിവയാണ് പൊതുവേ ഉപയോഗിച്ച് വരുന്നത്. ഇതിനു പുറമേ a.out, COFF, HEX തുടങ്ങിയ നിരവധി ക്രമീകരണ രീതികളും ഉപയോഗത്തിലുണ്ട്.

പ്രോസസ്സ് എന്ന് പറയുന്നത് പ്രവർത്തനസജ്ജമായ അല്ലെങ്കിൽ പ്രവർത്തിച്ചുകൊണ്ടിരിക്കുന്ന പ്രോഗ്രാമുകളെ ആണ്. ഇതിനായി ഡിസ്കിൽ നിന്ന് പ്രോഗ്രാമുകളെ മൊത്തമായോ ഭാഗികമായോ പ്രധാന മെമ്മറിയിലേക്ക് (RAM) കൊണ്ടുവരേണ്ടതുണ്ട്. ഇവിടെയാണ് വിർച്ച്വൽ മെമ്മറി, സെഗ്‌‌മെന്റേഷൻ, സ്വാപ്പിങ്ങ് തുടങ്ങിയവയൊക്കെ വരുന്നത്.

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

പ്രോസസ് ഷെഡ്യൂളിങ്[തിരുത്തുക]

ഒരു പ്രോസസറിന് ഒരു സമയത്ത് ഒരു പ്രോഗ്രാം മാത്രമേ പ്രവർത്തിപ്പിക്കാൻ സാധിക്കുകയുള്ളു. എന്നാലും നമ്മളൊക്കെ ഒന്നിൽ കൂടുതൽ പ്രോഗ്രാമുകൾ ഒരേ സമയത്ത് പ്രവർത്തിപ്പിക്കാറുണ്ട്. ടൈപ്പ് ചെയ്തുകൊണ്ടിരിക്കുമ്പോൾ പാട്ട് കേൾക്കുന്നതുപോലെ. ഒരേ സമയത്ത് പ്രവർത്തിച്ചുകൊണ്ടിരിക്കുന്ന വിവിധ പ്രോഗ്രാമുകളെ വേഗത്തിൽ മാറ്റിക്കൊണ്ടിരിക്കുകയാണ് ഇവിടെയൊക്കെ ചെയ്യുന്നത്. ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം ഓരോ പ്രോസസ്സിനെയും ഒരു നിശ്‌‌ചിത സമയത്തേക്ക് പ്രവർത്തിക്കാൻ അനുവദിക്കുന്നു. അതിനു ശേഷം അടുത്ത പ്രോസസ്സിന് സി പി യു വിട്ടുകൊടുക്കുന്നു. ഇത് വളരെ വേഗത്തിൽ സംഭവിക്കുന്നതിനാൽ പ്രോഗ്രാമുകളൊക്കെ ഒരേ സമയം പ്രവർത്തിക്കുന്നു എന്ന തോന്നൽ ഉപയോക്താവിന് ഉണ്ടാകുന്നു. ഷെഡ്യൂളിങ്ങ് എന്നാണ് ഈ പ്രക്രിയയുടെ പേര്. ഇതിന് വിവിധ രീതികൾ അവലംബിക്കാറൂണ്ട്. പ്രവർത്തിപ്പിക്കേണ്ട പ്രോഗ്രാമുകളുടെ വലിപ്പം, പ്രാധാന്യം എന്നിവക്കൊക്കെ അനുസരിച്ച് ഓരോ പ്രോഗ്രാമിനും പ്രവർത്തിക്കാനനുവദിക്കപ്പെടുന്ന സമയത്തിൽ മാറ്റമുണ്ടാകാം.

ഇതിനോടൊപ്പം തന്നെ റിയൽ ടൈം ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളുടെ കാര്യം കൂടി പ്രതിപാദിക്കുന്നു. നാം സാധാരണയായി ഉപയോഗിക്കുന്ന ലിനക്സും വിൻഡോസുമൊക്കെ ജെനറൽ പർപ്പസ് ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങൾ (ജിപിഒഎസ്) എന്ന വിഭാഗത്തിലുള്ളവയാണ്. ഇവയെല്ലാം പൊതുവായ കാര്യങ്ങൾക്ക് വേണ്ടി ഉപയോഗിക്കപ്പെടുന്നു. എല്ലാ ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളുടെയും അടിസ്ഥാന പ്രവർത്തന രീതി പുറമേ നിന്നുണ്ടാകുന്ന സംഭവങ്ങളോട് (ഈവന്റുകൾ) പ്രതികരിക്കുക എന്നതാണ്. ഉദാഹരണത്തിന് ഉപഭോക്താവ് ഒരു ഫയലിനു മുകളിൽ മൗസ് ഉപയോഗിച്ച് ക്ലിക്ക് ചെയ്യുന്നു എന്ന് കരുതുക. ആ ഫയലിനെ പ്രവർത്തിപ്പിക്കാൻ ആവശ്യമായ പ്രോഗ്രാം തുറക്കേണ്ടതുണ്ട്. ഇതിനായി ആകെ വേണ്ടിവരുന്ന സമയത്തെ പ്രതികരണ സമയം എന്ന് വിളിക്കാം (Response time). ഈ പ്രതികരണ സമയം സാധാരണ രീതിയിൽ അത്ര പ്രധാനമല്ല. ഇപ്പോൾ ഞാൻ ഒരു എംപി3 ഫയലിനെ തുറക്കുമ്പോൾ മൗസ് ക്ലിക്ക് ചെയ്യുന്ന സമയം മുതൽ ആ പാട്ട് പാടിത്തുടങ്ങുന്നത് വരെയുള്ള ഇടവേള അല്പം കൂടുതൽ ആണെങ്കിൽ പോലും പ്രശ്നങ്ങൾ ഒന്നും ഉണ്ടാകുന്നില്ല. എന്നാൽ വിമാനങ്ങളിലോ മിസ്സൈൽ നിയന്ത്രണ സംവിധാനങ്ങളിലോ, വാഹനങ്ങളുടെ ബ്രേക്ക്, ഇന്ധന നിയന്ത്രണ സംവിധാനങ്ങളിലോ ഒക്കെ ഒരു ഈവന്റിനോടുള്ള പ്രതികരണം അല്പം താമസിച്ച് പോയാൽ ഉള്ള അവസ്ഥ ഒന്ന് ആലോചിച്ച് നോക്കൂ. ഇങ്ങനെയുള്ള സാഹചര്യങ്ങളിൽ പ്രതികരണത്തിനായി എടുക്കുന്ന ഇടവേള വളരെ കുറവായിരിക്കണം. വേറൊരു രീതിയിൽ പറഞ്ഞാൽ ഒരു നിശ്ചിത സമയത്തിനുള്ളിൽ ഒരു സംഭവത്തോടുള്ള പ്രതികരണം ഉണ്ടായില്ലെങ്കിൽ ആ സിസ്റ്റം തന്നെ നശിച്ച് പോകുന്ന അവസ്ഥ ഉണ്ടായേക്കും. ഈ ഇടവേള വളരെ കുറവായ/കുറവായിരിക്കേണ്ട സാഹചര്യങ്ങളിൽ ഉപയോഗിക്കുന്നവയാണ് റിയൽ ടൈം ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം (ആർറ്റിഒഎസ്). ഇതിൽ തന്നെ ഹാർഡ് ആർറ്റിഒഎസ്സുകളും സോഫ്റ്റ് ആർറ്റിഒഎസ്സുകളും ഉണ്ട്. ഒരു സംഭവത്തോടുള്ള പ്രതികരണം നിശ്ചിത സമയത്തിൽ തന്നെ ഉണ്ടായില്ലെങ്കിൽ കൂടി ചില സാഹചര്യങ്ങളിൽ അത് പരാജയപ്പെട്ടു എന്ന് പറയാൻ സാധിക്കില്ല. ഇങ്ങനെയുള്ളവയാണ് സോഫ്റ്റ് ആർറ്റിഒസ്സുകൾ. നിശ്ചിത സമയത്തിനുള്ളിൽ പ്രതികരണം ഉണ്ടായില്ലെങ്കിൽ അതിനെ പൂർണ്ണ പരാജയം എന്ന് വിളിക്കുന്നവയാണ് ഹാർഡ് ആർറ്റിഒഎസ്സുകൾ. ഈ സമയനിഷ്ഠ നഷ്ടമായാൽ ഉണ്ടാകുന്ന നഷ്ടങ്ങളും വലുതായിരിക്കും.

വെർച്വൽ മെമ്മറി[തിരുത്തുക]

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

ഈ മെമ്മറി പ്രശ്നം പരിഹരിക്കാൻ വിർച്ച്വൽ മെമ്മറി എന്ന സംവിധാനം ഉപയോഗിക്കുന്നു. വിർച്ച്വൽ എന്നാൽ അക്ഷരാർത്ഥത്തിൽ ശരിക്ക് ഇല്ലാത്തതും എന്നാൽ ഉണ്ടന്ന് തോന്നിപ്പിക്കുന്നതും ആയ ഒരു മെമ്മറി എന്നാണ്. ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളിലെ മെമ്മറി മാനേജ്മെന്റ് യൂണിറ്റ് ആണ് ഈ സംവിധാനത്തെ പ്രവർത്തിപ്പിക്കുന്നത്. ശരിക്കും വിർച്ച്വൽ മെമ്മറി പ്രോസസറിന് ഒരു അധിക ഭാരമാണ്. എന്നാൽ ഇതില്ലാതെ പ്രവർത്തിക്കുക വിഷമവും ആണ്. വളരെ വേഗത ആവശ്യമായ ആർറ്റിഒഎസ്സുകളിൽ പൊതുവെ വിർച്ച്വൽ മെമ്മറി ഉപയോഗിക്കാറില്ല. ഇന്നുള്ള മിക്കവാറും പ്രോസസറുകളിലും ഈ മെമ്മറി മാനേജ്‌‌മെന്റ് എളുപ്പത്തിലാക്കാനുള്ള സംവിധാനങ്ങൾ ഉണ്ട്. പേജ് ടേബിളുകളും സെഗ്‌‌മന്റ് രെജിസ്റ്ററുകളും ഒക്കെ.

മെമ്മറി മാനേജ്മെന്റിനെക്കുറിച്ച് പറയുമ്പോൾ കാഷ് മെമ്മറി കൂടി പരാമർശിക്കേണ്ടതായുണ്ട്. പ്രോസസറുകളുടെ ഒക്കെ പരസ്യം കാണുമ്പോൾ 2എംബി എൽ2 കാഷ് എന്നൊക്കെ എഴുതിയിരിക്കുന്നത് കാണാമല്ലോ. ഇന്നത്തെ പ്രോസസറുകൾ വളരെ വേഗത്തിൽ പ്രവർത്തിക്കുന്നവയാണ്. 1GHz ഒക്കെ വേഗതയുള്ളവ ഇന്ന് സാധാരണമാണല്ലോ. എന്നാൽ റാം ഉൾപ്പെടെയുള്ള മെമ്മറികൾക്ക് ഇത്ര വേഗതയില്ല. മാത്രമല്ല കമ്പ്യൂട്ടറിലെ മദർബോർഡിൽ വിവര കൈമാറ്റത്തിനായുള്ള ബസ്സുകൾക്കും ഇത്ര വേഗതയില്ല. 733MHz ഒക്കെയാണ് ഇന്ന് സാധാരണയായുള്ള ബസ് വേഗത. അതിനാൽത്തന്നെ പ്രോസസ് ചെയ്യാനാവശ്യമായ വിവരങ്ങൾ മെമ്മറിയിൽ നിന്ന് വായിച്ചെടുക്കുന്ന സമയത്ത് പ്രോസസർ ഉപകാരപ്രദമായ കാര്യങ്ങൾ ഒന്നും തന്നെ ചെയ്യുന്നില്ല. മേൽപ്പറഞ്ഞ വേഗതകൾ ഉള്ള സിസ്റ്റങ്ങളിൽ ആകെ സമയത്തിന്റെ പത്തിലൊൻപതും വിവരങ്ങൾക്കായി കാത്തിരിക്കുകയാണ് പ്രോസസർ ചെയ്യുന്നത്. ഈ പ്രശ്നത്തിന് ഒരു ചെറിയ പരിഹാരമാണ് കാഷ് മെമ്മറി. ഇത് പ്രോസസറിനുള്ളിൽ തന്നെ ഉള്ള വേഗത കൂടിയ ഒരു മെമ്മറിയാണ്. കൂടെക്കൂടെ ഉപയോഗിക്കേണ്ടിവരുന്ന പ്രോഗ്രാം ഭാഗങ്ങൾ ഇതിൽ തന്നെ ശേഖരിക്കുന്നു. അത് വഴി പ്രോസസറിന് വേഗത്തിൽ വിവരങ്ങൾ ലഭ്യമാകും. ഈ മെമ്മറി മെയിൻ മെമ്മറിക്കും പ്രോസസറിനും ഇടയിലായി വരുന്നു. ഇതിന്റെ നിർമ്മാണം ചെലവേറിയതായതിനാൽ (ഒരു ബൈറ്റ് ശേഖരിക്കാനാവശ്യമായ സ്ഥലത്തിന്റെ നിർമ്മാണച്ചെലവ്) വലിപ്പമേറിയ കാഷ് മെമ്മറി കമ്പ്യൂട്ടറിന്റെ നിർമ്മാണച്ചെലവ് കൂട്ടുന്നു. കാഷ് മെമ്മറി ലഭ്യമായ കംപ്യൂട്ടറുകളിൽ പ്രോസസർ വിവരങ്ങൾക്കായി ആദ്യം അന്വേഷിക്കുന്നത് കാഷിൽ ആയിരിക്കും. അവിടെ ലഭ്യമല്ലെങ്കിൽ റാമിൽ.

വെർച്വൽ മെമ്മറിയുടെ പ്രവർത്തന രീതികളെക്കുറിച്ച് അൽപം വിശദമായി പറയാം. ഇന്ന് ഡെസ്ക്‌‌ടോപ്പ് കമ്പ്യൂട്ടറുകളിൽ ഏറ്റവുമധികം ഉപയോഗിക്കപ്പെടുന്ന ഇന്റലിന്റെ x86 കുടുംബത്തിലുള്ള പ്രോസസറുകളുടെ പ്രവർത്തന രീതി അടിസ്ഥാനമാക്കിയാണ് തുടർന്നുള്ള വിശദീകരണങ്ങൾ. വിർച്ച്വൽ മെമ്മറിയുടെ പ്രവർത്തനത്തെ കാണിക്കുന്ന ചിത്രം നോക്കൂ,

ലഭ്യമായ റാമും ഹാർഡ് ഡിസ്കും ചേർന്നതാണ് വിർച്ച്വൽ മെമ്മറി. ഇന്നത്തെ മിക്കവാറും ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളും ഓരോ പ്രോസസിനും അതിന്റെ സ്വന്തമായ ഒരു അഡ്രസ് സ്പേസ് അനുവദിക്കുന്നു. ആ പ്രോഗ്രാമും അതിന്റെ അനുബന്ധ ഫയലുകളും ഒക്കെ ലോഡ് ചെയ്യാനുള്ള അഡ്രസ്സുകളുടെ പരിധിയെ ആണ് അഡ്രസ്സ് സ്പേസ് എന്ന് വിളിക്കുന്നത്. ഓരോ പ്രോഗ്രാമിനും അതിനുള്ളിലെ ഫങ്ഷനുകൾ, വേരിയബിളുകൾ തുടങ്ങിയവക്കൊക്കെ കമ്പൈലർ തന്നെ നൽകിയിരിക്കുന്ന അഡ്രസ്സ് ഉണ്ടാകും. ഇതിന്റെ തുടക്കവും ഒടുക്കവുമൊക്കെ എല്ലാ പ്രോഗ്രാമുകളിലും ഒന്നായിരിക്കും. ഈ അഡ്രസ്സുകളെ വിർച്ച്വൽ അഡ്രസ്സ് എന്നാണ് വിളിക്കുന്നത്. ഈ അഡ്രസ്സ് റാമിലെ ശരിക്കുമുള്ള അഡ്രസ്സുമായി ബന്ധമില്ലാത്തതാണ്. എന്ന് മാത്രവുമല്ല കുറച്ച് മാത്രം റാം ഉള്ള കമ്പ്യൂട്ടറുകളിൽ ചിലപ്പോഴൊന്നും ആ അഡ്രസ്സുകൾ ഉണ്ടായിരിക്കുകയുമില്ല. ഒരു 32ബിറ്റ് പ്രോസസറിന് നാല് ജി ബി വരെയുള്ള അഡ്രസ്സുകളെ കൈകാര്യം ചെയ്യാൻ സാധിക്കും. (2^32 = 4294967296). ഇന്നത്തെ മിക്കവാറും കമ്പ്യൂട്ടറുകളിൽ ഇത്രയും തന്നെ റാം ഉണ്ടായിരിക്കുമല്ലോ. അപ്പോൾ വിർച്ച്വൽ മെമ്മറി ശരിക്കും ആവശ്യമാണോ എന്ന സംശയം സ്വാഭാവികമായും ഉണ്ടാകാം. ഈ 4 ജി ബി റാമിൽ തന്നെ ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം, ആ സമയത്ത് പ്രവർത്തിക്കുന്ന വിവിധ പ്രോഗ്രാമുകൾ എന്നിവക്കൊക്കെ സ്ഥലം‌‌ കണ്ടെത്തണം. എക്സിക്യൂട്ടബിൾ ഫയലിന്റെ വലിപ്പമല്ല ഒരു പ്രോഗ്രാമിന് പ്രവർത്തന സമയത്ത് ആവശ്യമായി വരുന്ന മെമ്മറിയുടെ വലിപ്പം എന്ന കാര്യം ഓർക്കേണ്ടതാണ്.

കമ്പ്യൂട്ടറിന്റെ അടിസ്ഥാന പ്രമാണങ്ങളിൽ ഒന്നാണ് കൈകാര്യം ചെയ്യപ്പെടണ്ട വിവരങ്ങൾ നിർബന്ധമായും മെമ്മറിയിൽ ഉണ്ടായിരിക്കണം എന്നത്. 800x600 റെസല്യൂഷൻ ഉള്ള ഒരു ചിത്രം കൈകാര്യം ചെയ്യുന്ന ഒരു പ്രോഗ്രാമിന് ഈ ചിത്രത്തിന്റെ വിവരങ്ങൾ മുഴുവൻ മെമ്മറിയിൽ സൂക്ഷിക്കണമെങ്കിൽ, 8ബിറ്റ് ആർജി‌‌ബി ചിത്രമാണെങ്കിൽ 800x600x8x3 ബൈറ്റുകൾ ആവശ്യമായി വരും. ആകെ 11520000 ബൈറ്റുകൾ (10.986328125എംബി). ഈ പത്ത് എംബി ഈ പ്രോഗ്രാമിന്റെ എക്സിക്യൂട്ടബിൾ ഫയലിൽ ഉൾപ്പെടുന്നില്ല. ആ ഫയലിന്റെ വലിപ്പം ഇതിലും കുറവായിരിക്കുകയും ചെയ്യാം. എന്നാൽ ആ ഫയലിന്റെ അകത്ത് രേഖപ്പെടുത്തിയിരിക്കുന്ന അഡ്രസ്സുകളിൽ ഈ ഭാഗം കൂടി ഉണ്ടായിരിക്കും. മെമ്മറിയിൽ ലോഡ് ചെയ്യപ്പെടുന്ന അവസരത്തിൽ അതിന് ഈ അഡ്രസ്സുകൾ കൂടി നൽകേണ്ടതുണ്ട്. ഒരു പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ സിസ്റ്റം മോണിറ്റർ/ടാസ്ക് മാനേജർ തുറന്ന് ആ പ്രോഗ്രാം ഉപയോഗിക്കുന്ന മെമ്മറിയുടെ അളവ് നോക്കൂ, പിന്നെആ പ്രോഗ്രാമിന്റെ എക്സിക്യൂട്ടബിൾ ഫയലിന്റെ വലിപ്പവും. അപ്പോൾഈ വ്യത്യാസം മനസ്സിലാകും. ചിലപ്പോളൊക്കെ ആ പ്രോഗ്രാം മറ്റ് പ്രോഗ്രാമുകളെ പ്രവർത്തിപ്പിക്കുന്നുണ്ടാകും. അതിനാൽ ആദ്യത്തെ പ്രോഗ്രാം തന്നെയാണ് ആ മെമ്മറി മുഴുവൻ ഉപയോഗിക്കുന്നത് എന്ന് കരുതരുത്.

വിർച്ച്വൽ മെമ്മറി സെഗ്‌‌മെന്റഡ് വിർച്ച്വൽ മെമ്മറി, പേജ്‌‌ഡ് വിർച്ച്വൽ മെമ്മറി എന്നിങ്ങനെ രണ്ട് തരത്തിൽ ഉണ്ട്. പേജ്ഡ് വിർച്ച്വൽ മെമ്മറിയിൽ ആകെയുള്ള വിർച്ച്വൽ അഡ്രസ്സുകളെ ഒരേ വലിപ്പമുള്ള വിവിധ പേജുകളാക്കി വിഭജിക്കുന്നു. ഈ പേജുകളെ കുറിച്ചുള്ള വിവരങ്ങൾ ഉൾപ്പെടുന്ന പട്ടികയാണ് പേജ് ടേബിൾ. ഓരോ പ്രോഗ്രാമും മെമ്മറിയിൽ ലോഡ് ചെയ്യപ്പെടുമ്പോൾ ആപ്രോഗ്രാമിലെ പേജുകളുടെ വിവരം ഈ പട്ടികയിൽ ചേർക്കപ്പെടുന്നു. ഒരു സമയത്ത് ആ പേജ് റാമിൽ ഉണ്ടോ എന്ന കാര്യം ഒക്കെ ഈ പട്ടികയിൽ രേഖപ്പെടുത്തിയിരിക്കും. ഇതിനോട് സമാനമാണ് സെഗ്‌‌മന്റഡ് വിർച്ച്വൽ മെമ്മറിയും. ഇതിൽ അഡ്രസ്സുകളെ വിവിധ പേജുകളായി തിരിക്കുന്നതിന് പകരം വിവിധ വലിപ്പമുള്ള സെഗ്‌‌മന്റുകൾ ആയി വിഭജിക്കുന്നു. ഇന്ന് ഇവ രണ്ടും ചേർന്ന ഒരു രൂപമാണ് ഉപയോഗത്തിൽ ഉള്ളത്. അതായത് ഒരു പ്രോഗ്രാമിന് ആകെ ആവശ്യമായ അഡ്രസ്സുകളെ ആദ്യം വിവിധ സെഗ്‌‌മന്റുകൾ ആയി വിഭജിക്കുന്നു. ഇതിൽ ഓരോ സെഗ്മന്റിനും ഓരോ ഉദ്ദേശ്യമുണ്ട്. പിന്നീട് ഓരോ സെഗ്മന്റിനെയും വിവിധ പേജുകൾ ആയി വിഭജിക്കുന്നു. ഈ പേജുകളുടെ എല്ലാം വലിപ്പം ഒന്നുതന്നെയായിരിക്കും.

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

പ്രോഗ്രാമുകളിൽ ഉപയോഗിക്കുന്നത് വിർച്ച്വൽ അഡ്രസ്സുകൾ ആണെന്ന് നേരത്തേ‌ പറഞ്ഞു. ചില പ്രോസസറുകൾ ഈ വിർച്ച്വൽ അഡ്രസ് തന്നെ ഉപയോഗിക്കും. മിക്കവാറും അത് പ്രോസസർ പ്രവർത്തിക്കുന്ന മോഡിനെ അടിസ്ഥാനമാക്കിയിരിക്കും. ഉദാഹരണത്തിന് ഇന്റൽ പ്രോസസറുകൾ പ്രവർത്തിച്ച് തുടങ്ങുമ്പോൾ റിയൽ മോഡിൽ ആണ് ഉണ്ടാവുക. അവയ്ക്ക് ആ സമയത്ത് 16 ബിറ്റ് അഡ്രസ്സുകൾ മാത്രമേ കൈകാര്യം ചെയ്യാൻ സാധിക്കുകയുള്ളു. ഈ അഡ്രസ്സുകൾ റാമിലുള്ള ഫിസിക്കൽ അഡ്രസ്സുകൾ ആയിരിക്കും. ഇതിനെ പിന്നീട് ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം പ്രൊട്ടക്റ്റഡ് മോഡിലേക്ക് മാറ്റും. അതിനു ശേഷം അവ വിർച്ച്വൽ അഡ്രസ്സുകൾ ആയിരിക്കും ഉപയോഗിക്കുന്നത്. പ്രോസസർ വിർച്ച്വൽ അഡ്രസ്സ് ഉപയോഗിച്ചാലും ആ അഡ്രസ്സിൽ ഉള്ള വിവരങ്ങൾ റാമിൽ ആയിരിക്കുമല്ലോ ഉണ്ടാകുന്നത്. പ്രോസസറിനാവശ്യമായ വിവരങ്ങൾ റാമിൽ നിന്ന് എത്തിച്ചുകൊടുക്കുന്ന ഭാഗത്തിന് ആ അഡ്രസ്സുമായി ബന്ധപ്പെട്ട റാമിലെ ഫിസിക്കൽ അഡ്രസ് അറിയേണ്ടതുണ്ട്. ഇത് ചെയ്യുന്നത് മെമ്മറി മാനേജ്‌‌മെന്റ് യൂണിറ്റ് (mmu) ആണ്. ചില പ്രോസസറുകൾക്കുള്ളിൽ തന്നെ ഈ ഭാഗം ഉണ്ടായിരിക്കും. ഇത് പ്രത്യേകം ചിപ്പിൽ പ്രോസസറിന് പുറത്തും ആകാം. പ്രോസസർ ഉപയോഗിക്കുന്ന വിർച്ച്വൽ അഡ്രസ്സിൽ (പ്രോസസറിന്റെ കാര്യത്തിൽ ഇതിനെ ലോജിക്കൽ അഡ്രസ്സ് എന്ന് പറയാറുണ്ട്) ഒരു ഭാഗം പേജിന്റെ അഡ്രസ്സും (ബേസ് അഡ്രസ്സ്) ബാക്കിഭാഗം ആ പേജിനുള്ളിലെ ഒരു സ്ഥാനവും (ഓഫ്‌‌സെറ്റ് - അതായത് വേണ്ട വിവരം ആ പേജിന്റെ തുടക്കത്തിൽ നിന്ന് എത്ര ബൈറ്റ് മാറിയാണ് എന്നത്) ആയിരിക്കും. എംഎംയു പേജുകളുടെ റാമിലുള്ള അഡ്രസ് ഉൾപ്പെടുന്ന ഒരു പട്ടിക സൂക്ഷിച്ചിരിക്കുന്നു. ഇതിനെ ടി എൽ ബി (TLB - Translation Look-aside Buffer) എന്ന് പറയുന്നു. ടി എൽ ബിയിലെ ഓരോ വിവരത്തെയും പേജ് ടേബിൾ എൻട്രി (PTE - Page Table Entry) എന്ന് പറയുന്നു. ഇതിൽ ഓരോ പേജിന്റെയും റാമിലെ ശരിക്കുള്ള അഡ്രസ്സ്, ആ പേജിന് മെമ്മറിയിൽ എത്തിയതിനു ശേഷം മാറ്റം സംഭവിച്ചിട്ടുണ്ടോ, ഏതൊക്കെ പ്രോസസുകൾക്ക് ആ പേജ് വായിക്കാനോ മാറ്റം വരുത്താനോ അനുവാദമുണ്ട് എന്ന വിവരങ്ങൾ ഒക്കെ ഉണ്ടാകും. ഈ ചിത്രം നോക്കൂ,

പ്രവർത്തനത്തിന് കൂടുതൽ പേജുകൾ ആവശ്യമായി വരികയും റാമിൽ അവയെ ഉൾക്കൊള്ളാനുള്ള സ്ഥലം ഇല്ലാതിരിക്കുകയും ചെയ്യുമ്പോൾ അവയെ ഹാർഡ് ഡിസ്കിലേക്ക് താൽക്കാലികമായി മാറ്റുന്നു. സ്വാപ്പിങ്ങ് എന്നാണ് ഈ പ്രക്രിയയെ വിളിക്കുന്നത്. മിക്കവാറും യൂണിക്സ്/ലിനക്സ് സിസ്റ്റങ്ങളിൽ ഇതിനായി ഒരു പ്രത്യേക ഡിസ്ക് പാർട്ടീഷ്യൻ തന്നെ കാണുമല്ലോ. ഹാർഡ് ഡിസ്കിലേക്ക് വിവരങ്ങൾ എഴുതുന്നത് അധികം സമയം വേണ്ട പ്രക്രിയ ആയതിനാൽ സ്വാപ്പിങ്ങ് കമ്പ്യൂട്ടറിന്റെ വേഗതയെ ബാധിക്കും. ചിലപ്പോളൊക്കെ ആവശ്യമായ പേജ് ഡിസ്കിൽ നിന്ന് മെമ്മറിയിൽ എത്തിക്കാൻ മെമ്മറിയിൽ ഉള്ള പേജുകളെ നീക്കം ചെയ്യേണ്ടിവരും. അപ്പോൾ നീക്കം ചെയ്ത പേജ് ഉടനെ തന്നെ ആവശ്യമായി വന്നാൽ വേറൊരു പേജിനെ നീക്കം ചെയ്ത ശേഷം ആ പേജിനെ മെമ്മറിയിലേക്ക് കൊണ്ടുവരേണ്ടിവരും. ഇത് തുടർന്നുകൊണ്ടിരുന്നാൽ കമ്പ്യൂട്ടർ ആകെ മന്ദഗതിയിൽ ആവുകയും പ്രോഗ്രാമുകൾ പ്രവർത്തിക്കാത്തതുപോലെ തോന്നുകയും ചെയ്യും. ട്രാഷിങ്ങ് (Trashing) എന്നാണ് ഈ അവസ്ഥയുടെ പേര്. ഇത് അത്ര സാധാരണയായ ഒരു അവസ്ഥയുമല്ല.

ഒരേ പ്രോഗ്രാമിന്റെ തന്നെ വിവിധ പേജുകൾ മെമ്മറിയിൽ തുടർച്ചയായ സ്ഥലങ്ങളിൽ അല്ലായിരിക്കാം. ഇത് ഫ്രാഗ്മെന്റേഷൻ എന്നറിയപ്പെടുന്നു. എന്നാൽ ഇതൊന്നും ഒരിക്കലും പ്രവർത്തിച്ചുകൊണ്ടിരിക്കുന്ന പ്രോഗ്രാം അറിയുന്നില്ല. പ്രോഗ്രാമിന്റെ നോട്ടത്തിൽ അതിന് തുടർച്ചയായ, വളരെ വിശാലമായ ഒരു മെമ്മറി സ്പേസ് ഉള്ളതായാണ് തോന്നുക. ഇത് തന്നെയാണ് വിർച്ച്വൽ മെമ്മറിയുടെ ഉദ്ദേശ്യവും.

പ്രോഗ്രാം പ്രോസസ് ആയി മാറുന്നു[തിരുത്തുക]

പ്രോസസ് എന്നത് മെമ്മറിയിൽ ലോഡ് ചെയ്യപ്പെട്ട പ്രോഗ്രാം ആണെന്ന് നേരത്തേ‌ പറഞ്ഞു. പ്രോസസ്സുകൾ ആയി മാറുന്ന പ്രോഗ്രാമുകളെക്കുറിച്ചൽപ്പം പറയാം.

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

subin@subin:~/Pictures/Tux$ file 100px-NewTux.png
100px-NewTux.png: PNG image data, 100 x 120, 8-bit/color RGBA, non-interlaced

subin@subin:/bin$ file bash
bash: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.24, stripped

subin@subin:/lib$ file libfuse.so.2.8.6
libfuse.so.2.8.6: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, stripped

ഈ പ്രോഗ്രാം, ഫയലിന്റെ പേരോ എക്സ്റ്റൻഷനോ അടിസ്ഥാനമാക്കിയല്ല ഫയലിന്റെ തരം തീരുമാനിക്കുന്നത്. മിക്കവാറും ബൈനറി വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്ന ഫയലുകൾക്കൊക്കെ ഒരു ക്രമീകരണരീതി ഉണ്ടാകും. ആ ഫയലിലെ ആദ്യത്തെ ഏതാനും ബൈറ്റുകളിൽ ഒരു മാജിക് നമ്പർ അടങ്ങിയിരിക്കും. ഈ മാജിക് നമ്പർ ഓരോ തരത്തിലുള്ള ഫയലിനും ഓരോന്നായിരിക്കും. മുകളിലെ ഉദാഹരണങ്ങളിൽ രണ്ടാമതും മൂന്നാമതും ഉള്ള ഫയലുകൾ ELF എന്ന തരത്തിൽ പെട്ടവയാണ്. ലിനക്സിലെ എക്സിക്യൂട്ടബിൾ ഫയലിന്റെ ക്രമീകരണരീതികളിൽ ഒന്നാണ് ELF. എക്സിക്യൂട്ടബിൾ ആൻഡ്‌ ലിങ്കബിൾ ഫോർമാറ്റ് എന്നതിന്റെ ചുരുക്കമാണിത്. ഇത് കൂടാതെ ഷെൽ സ്ക്രിപ്റ്റുകൾ, പൈത്തൺ, പേൾ പ്രോഗ്രാമുകൾ എന്നിവയെയൊക്കെ എക്സിക്യൂട്ടബിളുകൾ ആയി പരിഗണിക്കും. എന്നാൽ ELF ഫയലുകൾ പോലെയല്ല അവ കൈകാര്യം ചെയ്യപ്പെടുന്നത്. അവയെ പ്രവർത്തിപ്പിക്കാനാവശ്യമായ പ്രോഗ്രാമുകളുടെ വിവരം ആ ഫയലുകളുടെ ആദ്യം രേഖപ്പെടുത്തിയിരിക്കും. ഷെൽ സ്ക്രിപ്റ്റുകളുടെ ഒക്കെ ഫയലിലെ ആദ്യത്തെ വരി മിക്കവാറും #!/bin/bash എന്നായിരിക്കും. /bin/bash എന്ന പ്രോഗ്രാമുപയോഗിച്ചാണ് ആ ഫയലിനെ പ്രവർത്തിപ്പിക്കേണ്ടത് എന്നർഥം. എന്നാൽ ELF ഫയലുകളെ കെർണൽ നേരിട്ട് പ്രവർത്തിപ്പിക്കുകയാണ് ചെയ്യുന്നത്. ELF ഫയലുകളിലെ വിവരങ്ങൾ വിവിധ വിഭാഗങ്ങളിൽ ആയാണ് ക്രമീകരിച്ചിരിക്കുക. മുകളിലെ ഉദാഹരണത്തിൽ രണ്ടാമത് കാണുന്നത് ഒരു എക്സിക്യൂട്ടബിൾ ഫയലും മൂന്നാമത്തേത് ഒരു ഷെയേർഡ്‌ ലൈബ്രറിയും ആണ്. ഇവയെക്കുറിച്ച് പിന്നീട് പറയാം. ഈ ഫയലുകളിൽ ഒക്കെ ഉണ്ടാകുന്ന വിവിധ ഭാഗങ്ങൾ (സെഗ്‌‌മെന്റ്) ചുവടെ (ഇത് ഒരു സി കമ്പൈലർ ഉണ്ടാക്കുന്ന എക്സിക്യൂട്ടബിളിനെ അടിഥാനമാക്കിയാണ്),

.text: പ്രോഗ്രാമിലെ നിർദ്ദേശങ്ങൾ. ഇവക്കനുസരിച്ചാണ് പ്രോഗ്രാം പ്രവർത്തിക്കുന്നത്.
.data: ഒരു സി പ്രോഗ്രാമിലെ മൂല്യം തീരുമാനിക്കപ്പെട്ട ഗ്ലോബൽ വേരിയബിളുകൾ, സ്റ്റാറ്റിക് വേരിയബിളുകൾ എന്നിവയൊക്കെ.
.bss: മൂല്യം തീരുമാനിക്കപ്പെട്ടിട്ടില്ലാത്ത ഗ്ലോബൽ വേരിയബിളുകൾ.
.stack: പ്രോഗ്രാമിലെ വിവിധ ഫങ്ഷനുകൾക്ക് പ്രവർത്തിക്കാനാവശ്യമായ വിവരങ്ങൾ. പ്രോഗ്രാമിന്റെ ആരംഭത്തിൽ ഇതിൽ മെയിൻ ഫങ്ങ്ഷനിലെ ലോക്കൽ/ഓട്ടോമാറ്റിക് വേരിയബിളുകൾ, റിട്ടേൺ അഡ്രസ്സ്, കമാന്റ് ലൈൻ ആർഗ്യുമെന്റുകൾ, എൻവയോൺമെന്റ് വേരിയബിളുകൾ എന്നിവയായിരിക്കും ഉണ്ടാവുക. മറ്റൊരു ഫങ്ങ്ഷൻ വിളിക്കപ്പെടുമ്പോൾ ആ ഫങ്ങ്‌‌ഷന്റെ ലോക്കൽ വേരിയബിളുകൾ, അതിന്റെ ആർഗ്യുമെന്റുകൾ, അതിന്റെ റിട്ടേൺ അഡ്രസ് തുടങ്ങിയ വിവരങ്ങൾ ഉൾക്കൊള്ളിച്ച് ഒരു പുതിയ ഉപ ഭാഗം ഇതിനുള്ളിൽ സൃഷ്ടിക്കപ്പെടുന്നു.
.heap: പ്രോഗ്രാം പ്രവർത്തിക്കുന്ന സമയത്ത് അതിന് കൂടുതൽ മെമ്മറി ആവശ്യമായി വന്നാൽ അത് അനുവദിക്കാനുള്ള സ്ഥലം.

(മുകളിലുള്ള സി പ്രോഗ്രാമിങ്ങുമായി ബന്ധപ്പെട്ട പദങ്ങൾ വിശദീകരിക്കാൻ കൂടുതൽ സ്ഥലവും സമയവും വേണ്ടിവരുമെന്നതിനാൽ അവയുടെ വിശദീകരണം ഒഴിവാക്കുന്നു. അവ എന്താണെന്ന് സൂചിപ്പിക്കുന്ന വിക്കി ലേഖനത്തിലേക്ക് കണ്ണികൾ നൽകിയിട്ടുണ്ട്)

ആധുനിക കമ്പൈലറുകൾ ഇവക്ക് പുറമേ മറ്റ് പല ഭാഗങ്ങളും എക്സിക്യൂട്ടബിൾ ഫയലുകളിൽ ഉൾപ്പെടുത്താറുണ്ട്. ജി ഡി ബി പോലെയുള്ള ഡീബഗ്ഗർ പ്രോഗ്രാമുകൾക്കാവശ്യമായ വിവരങ്ങൾ Dwarf എന്ന ക്രമീകരണ രീതി ഉപയോഗിച്ച് ചില എക്സിക്യൂട്ടബിൾ ഫയലുകളിൽ കാണും. (Elf എന്ന പേരിന്റെ കൂടെ നിൽക്കാൻ Dwarf എന്ന് പേരിട്ടതാണ്. ഇവ രണ്ടും മാന്ത്രിക ജീവികളുടെ പേരാണല്ലോ.) മറ്റുള്ള ബൈനറി എക്സിക്യൂട്ടബിൾ ക്രമീകരണ രീതികളിലും ഈ ഭാഗങ്ങൾ ഒക്കെ ഉണ്ടാകും. Elf ഒരു ഉദാഹരണമായി എടുത്തത് യൂണിക്സ്/ലിനക്സ് സിസ്റ്റങ്ങൾ അത് ഉപയോഗിക്കുന്നു എന്നതിനാലാണ്. എക്സിക്യൂട്ടബിൾ ഫയലുകളെ കുറിച്ചുള്ള വിവരങ്ങൾ ലഭിക്കാനും അവയെ അപഗ്രഥിക്കാനും മറ്റുമായി വിവിധ പ്രോഗ്രാമുകൾ ലഭ്യമാണ്. ഉദാഹരണത്തിന്, എക്സിക്യൂട്ടബിൾ ഫയലിലെ വിവിധ സെഗ്മന്റുകളുടെ വലിപ്പം അറിയാൻ size, ഫയലിലെ വിവിധ ചിഹ്നങ്ങളുടെ വിവരങ്ങൾ ലഭിക്കാൻ nm, elf ഫയലുകളിലെ വിവിധ വിവരങ്ങൾക്കായി readelfഎന്നിവ.

കമ്പൈലർ ഒരു എക്സിക്യൂട്ടബിൾ ഫയൽ ഉണ്ടാക്കിക്കഴിഞ്ഞാൽ അതിൽ പ്രവർത്തനസമയത്ത് അത്യാവശ്യമല്ലാത്ത വിവിധ വിവരങ്ങൾ ഉണ്ടായിരിക്കും. സാധാരണ ഉപഭോക്താക്കൾക്ക് ആവശ്യമില്ലാത്ത ഈ വിവരങ്ങൾ ഒഴിവാക്കുന്നത് ഫയലുകളുടെ വലിപ്പം കുറക്കാൻ സഹായിക്കും. ഇങ്ങനെയുള്ള വിവരങ്ങൾ ഒഴിവാക്കുന്ന പ്രക്രിയയെ സ്ട്രിപ്പിങ്ങ് എന്ന് പറയുന്നു. strip എന്ന പ്രോഗ്രാം ഉപയോഗിച്ച് ഇത് ചെയ്യാവുന്നതാണ്. ആദ്യം നൽകിയിരിക്കുന്ന ഫയൽ കമാന്റ് ഉദാഹരണങ്ങളിൽ അവസാനം stripped എന്ന് പരാമർശിച്ചിട്ടുള്ളത് ശ്രദ്ധിക്കൂ.

സിസ്റ്റം കോളുകളും പ്രോസസ് ഐഡിയും[തിരുത്തുക]

ഒരു ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം നൽകുന്ന സേവനങ്ങൾ ഉപയോഗിക്കുന്നത് സിസ്റ്റം കോളുകൾ വഴിയാണ്. സാധാരണ പ്രോഗ്രാമിങ്ങ് ഭാഷകളൊക്കെ സിസ്റ്റം കോളുകൾ ഉപയോഗിക്കാനുള്ള ഫങ്‌‌ഷനുകൾ നൽകാറുണ്ട്. ജാവ പോലെയുള്ള ഇന്റർപ്രിറ്റഡ് പ്രോഗ്രാമിങ്ങ് ഭാഷകളാണെങ്കിൽ ഈ സിസ്റ്റം കോളുകൾ അവയുടെ ഇന്റർപ്രിറ്റർ തന്നെ കൈകാര്യം ചെയ്യും. പ്രോഗ്രാമർക്ക് അവയെക്കുറിച്ചറിയണ്ട കാര്യമില്ല. സി/സി++ ഭാഷകളിൽ ഈ സിസ്റ്റം കോളുകൾ നേരിട്ട് ഉപയോഗിക്കാൻ സാധിക്കും.

യൂണിക്സ്/ലിനക്സ് സിസ്റ്റങ്ങളിൽ ഒരു പുതിയ പ്രോസസ് ഉണ്ടാക്കാനുള്ള സിസ്റ്റം കോൾ ഫോർക്ക് (fork) ആണ്. നിലവിലുള്ള ഒരു പ്രോസസ്, ഫോർക്ക് സിസ്റ്റം കോൾ ഉപയോഗിക്കുമ്പോൾ ആ പ്രോസസിന്റെ മറ്റൊരു പതിപ്പ് സൃഷ്ടിക്കപ്പെടുന്നു. ഈ പതിപ്പിനെ ചൈൽഡ് പ്രോസസ്സ് എന്നും ഫോർക്ക് സിസ്റ്റം കോൾ ഉപയോഗിച്ച പ്രോസസിനെ പേരന്റ് പ്രോസസ്സ് എന്നും വിളിക്കുന്നു. എല്ലാ പ്രോസസുകൾക്കും ഒരു പ്രോസസ്സ് ഐഡി ഉണ്ടായിരിക്കും. പ്രോസസുകളെ കൈകാര്യം ചെയ്യാൻ ഈ പ്രോസസ്സ് ഐഡി ഉപയോഗിക്കാം. ഇതിനെ ചുരുക്കി പിഐഡി (PID) എന്ന് വിളിക്കുന്നു. ലിനക്സ് കെർണൽ അതിന്റെ പ്രാഥമിക ക്രമീകരണങ്ങൾ ഒക്കെ നടത്തിയ ശേഷം ഇനിറ്റ് (init) എന്ന പ്രോസസ്സിനെ സൃഷ്ടിക്കുന്നു. ഈ പ്രോസസ് മാത്രമാണ് ഫോർക്ക് ഉപയോഗിക്കാതെ സൃഷ്ടിക്കപ്പെടുന്ന ഒരേ ഒരെണ്ണം. ഇനിറ്റ് പ്രോസസ്സിന്റെ പിഐഡി 1 ആയിരിക്കും. തുടക്കത്തിൽ ആവശ്യമായ ബാക്കിയുള്ള പ്രോസസുകളെ ഒക്കെ സൃഷ്ടിക്കുന്നത് ഇനിറ്റ് ആണ്. അപ്പോൾ ഇനിറ്റ് ഒഴികെയുള്ള എല്ലാ പ്രോസസ്സുകൾക്കും ഒരു പേരന്റ് പ്രോസസ് ഉണ്ടാകും. ഈ പേരന്റ് പ്രോസസിനെ മനസ്സിലാക്കാൻ പേരന്റ് പ്രോസസ് ഐഡി - പിപിഐഡി (PPID) ഉപയോഗിക്കുന്നു. ഒരു ചൈൽഡ് പ്രോസസ്സിന്റെ പേരന്റ് പ്രോസസ്സ് പ്രവർത്തനം നിർത്തിയാൽ ആ ചൈൽഡ് പ്രോസസ്സിനെ ഓർഫൻ പ്രോസസ്സ് എന്ന് വിളിക്കാം. എല്ലാ ഓർഫൻ പ്രോസസ്സുകളുടെയും പേരന്റ് പ്രോസസ്സ് ഇനിറ്റ് ആയിരിക്കും. കെർണൽ എല്ലാ പ്രോസസ്സുകളുടെയും ഒരു പട്ടിക സൂക്ഷിക്കും. ഇതിനെ പ്രോസസ്സ് ടേബിൾ എന്ന് വിളിക്കുന്നു. എല്ലാ പ്രോസസ്സുകൾക്കും പ്രോസസ്സ് ടേബിളിൽ ഒരു സ്ഥലം അനുവദിച്ചിരിക്കും. ഇതിനെ ആ പ്രോസസ്സിന്റെ പ്രോസസ്സ് ടേബിൾ എൻട്രി എന്ന് വിളിക്കാം. കൂടാതെ ഓരോ പ്രോസസ്സിനും യു-ഏരിയ എന്ന പേരിൽ അതിനെപ്പറ്റിയുള്ള വിവരങ്ങൾ സൂക്ഷിച്ചിരിക്കുന്ന ഒരു സ്ഥലം കൂടിയുണ്ട്. ഒരു പ്രോസസ്സിലെ വിവിധ സെഗ്‌‌മന്റുകളെക്കുറിച്ച് നേരത്തേ പറഞ്ഞിരുന്നല്ലോ. കെർണലിനും ഈ സെഗ്മെന്റുകൾ ഉണ്ടായിരിക്കും. അവയിലാണ് ഈ വിവരങ്ങൾ ശേഖരിക്കപ്പെടുക.

യൂസർ സ്പേസും കെർണൽ സ്പേസും[തിരുത്തുക]

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

പ്രോസസ്സിന്റെ വിവിധ അവസ്ഥകൾ[തിരുത്തുക]

ഒരു പ്രോസസ്സിന്റെ വിവിധ അവസ്ഥകൾ (Process states) താഴെക്കാണിച്ചിരിക്കുന്നു

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

പ്രോസസ് സൃഷ്ടി[തിരുത്തുക]

യൂണിക്സ്/ലിനക്സ് സിസ്റ്റങ്ങളിൽ ബൂട്ടിങ്ങിന് ശേഷം കെർണൽ സ്വയം നിർമിക്കുന്ന പ്രോസസ്സാണ് ഇനിറ്റ്. ഇനിറ്റ് വരെ സിസ്റ്റം കെർണൽ മോഡിലായിരിക്കും. ഇനിറ്റ് പ്രവർത്തനമാരംഭിക്കുന്നതോടെ സിസ്റ്റം യൂസർമോഡിലേക്ക് മാറുന്നു. ഇനിറ്റിനു ശേഷമുള്ള എല്ലാ പ്രോസസ്സുകളും ഫോർക്ക് സിസ്റ്റം കോൾ ഉപയോഗിച്ച് സൃഷ്ടിക്കപ്പെടുന്നവയാണ്. ഇനിറ്റ് പ്രോസസ്സ് ഷെല്ലുകളോ ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസുകളോ എക്സിക്യൂട്ട് ചെയ്യുന്നു. അപ്പോൾ ഉപഭോക്താവിന് കമ്പ്യൂട്ടർ പ്രവർത്തിപ്പിക്കാനുള്ള ഉപാധികൾ ലഭ്യമാകും. ഉപയോക്താവ് നിർദ്ദേശങ്ങളോ മൗസോ ഉപയോഗിച്ച് ഒരു പുതിയ പ്രോഗ്രാം തുറക്കുമ്പോൾ സംഭവിക്കുന്ന കാര്യങ്ങൾ എന്തൊക്കെയാണെന്ന് നോക്കാം. ഷെല്ലോ ഗ്രാഫിക്കൽ ഇന്റർഫേസോ ആദ്യം ഫോർക്ക് സിസ്റ്റം കോൾ ഉപയോഗിച്ച് അതിന്റെ തന്നെ ഒരു കോപ്പി നിർമ്മിക്കുന്നു. ഈ കോപ്പി നിർമ്മിക്കപ്പെടുന്ന വഴി ഇങ്ങനെയാണ്.

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

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

 #include <stdio.h> 
 #include <stdlib.h> 
 #include <unistd.h> 
 
 int main(void) 
 { 
  int pid; 
 
  pid = fork(); 
  if (pid == -1) { 
   printf("fork failed..\n"); 
   exit(-1); 
  } 
 
  if (pid == 0) { 
   printf("I am the child process. My PID is %d\n", getpid()); 
   exit(0); 
  } else { 
   printf("I am the parent process PID is %d. Child PID is %d\n",getpid(), pid); 
  } 
 
  return 0; 
 }

ഇതിനെ fork.c എന്ന ഫയലിൽ സേവ് ചെയ്യുക. അതിനു ശേഷം ടെർമിനലിൽ താഴെക്കാണുന്ന നിർദ്ദേശം നൽകി പ്രോഗ്രാം കമ്പൈൽ ചെയ്യുക

gcc fork.c -o fork

പ്രവർത്തിപ്പിക്കാൻ ./fork എന്ന് ടൈപ്പ് ചെയ്ത് എന്റർ അമർത്തുക. താഴെക്കാണുന്നതിന് സമാനമായ ഔട്ട്പുട്ട് ലഭിക്കും,

I am the parent process PID is 3691. Child PID is 3692
I am the child process. My PID is 3692

if സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കുമ്പോൾ സാധാരണയായി നിർദ്ദേശത്തിലെ ഒരു ഭാഗം മാത്രം പ്രവർത്തിക്കുന്നിടത്ത് ഇവിടെ രണ്ട് ഭാഗങ്ങളും പ്രവർത്തിക്കുന്നതായി കാണാം. യഥാർത്ഥത്തിൽ ഇത് രണ്ട് വ്യത്യസ്ത പ്രോസസ്സുകളിൽ നിന്നാണ് വരുന്നത്. ആദ്യം ചൈൽഡ്‌ പ്രോസസ് പ്രവർത്തിക്കുമോ പേരന്റ് പ്രോസസ് പ്രവർത്തിക്കുമോ എന്ന് പറയാൻ സാധിക്കുകയില്ല. സിസ്റ്റം കോൾ പൂർത്തിയായ ശേഷം പ്രോസസ്സ് വീണ്ടും യൂസർ മോഡിലേക്ക് തന്നെ മടങ്ങി വരുന്നു.

ഒരു പുതിയ പ്രോസസ്സ് ഇവിടെ സൃഷ്ടിക്കപ്പെട്ടെങ്കിലും അത് ആദ്യത്തെ പ്രോസസ്സിന്റെ തന്നെ പകർപ്പാണെന്ന് മനസ്സിലാക്കിയിരിക്കുമല്ലോ. എന്നാൽ നമുക്കാവശ്യം ഒരു പുതിയ പ്രോഗ്രാമിനെ പ്രവർത്തിപ്പിക്കലാണ്. ഇതിനായി ഉപയോഗിക്കുന്ന സിസ്റ്റം കോൾ ആണ് എക്സെക്ക് (exec). ഈ സിസ്റ്റം കോൾ ചെയ്യുന്നത് അതിനെ ഉപയോഗിച്ച പ്രോസസ്സിന്റെ സെഗ്മന്റുകൾ മാറ്റി അവിടെ ഒരു പുതിയ പ്രോഗ്രാമിൽ നിന്നുള്ള സെഗ്‌‌മന്റുകൾ ചേർക്കുകയാണ്. ഇതുവഴി ഒറിജിനൽ പ്രോസസ്സ് ഇല്ലാതാകുകയും പകരം പുതിയ പ്രോഗ്രാം പ്രോസസ്സായി അവിടെ വരികയും ചെയ്യുന്നു. ഇതിന്റെ പ്രവർത്തനം താഴെപ്പറയുന്നത് പോലെയാണ്.

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

ഇവിടെ ശ്രദ്ധിക്കേണ്ട ഒരു പ്രധാന കാര്യം വിജയകരമായ ഒരു എക്സെക്ക് സിസ്റ്റം കോൾ, ഫോർക്ക് സിസ്റ്റം കോൾ ചെയ്തതുപോലെ മൂല്യങ്ങളൊന്നും മടക്കി നൽകുന്നില്ല. ഒരു ഫങ്ഷൻ റിട്ടേൺ ചെയ്യുന്നത് അതിനെ വിളിച്ച പ്രോസസ്സിലേക്കാണ്. ഇവിടെ എക്സെക്കിനെ വിളിച്ച പ്രോസസ്സ് ബാക്കിയില്ല. അവിടെ പുതിയ പ്രോഗ്രാം പ്രവർത്തനം തുടങ്ങിയിരിക്കുന്നു. അതിനാൽ തന്നെ വിജയകരമായ എക്സെക്കിൽ നിന്ന് റിട്ടേൺ ഇല്ല. മുകളിലെ പ്രോഗ്രാമിനെ അൽപം പരിഷ്കരിച്ച് ls എന്ന പ്രോഗ്രാമിനെ എങ്ങനെ പ്രവർത്തിപ്പിക്കം എന്ന് നോക്കാം. ഷെല്ലുകൾ എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്ന് മനസ്സിലാക്കാൻ ഇത് ഉപകരിക്കും. സി പ്രോഗ്രാമിങ്ങിൽ എക്സെക്ക് നേരിട്ട് ഉപയോഗിക്കാൻ വിഷമമാണ്. അതിനാൽ സി ലൈബ്രറി നൽകുന്ന execl, execlp, execle, execv, execvp, execvpe എന്ന വകഭേദങ്ങളിൽ ഒന്ന് ഉപയോഗിക്കാം. ഇവയൊക്കെ ആന്തരികമായി എക്സെക്ക് സിസ്റ്റം കോൾ തന്നെയാണ് ഉപയോഗപ്പെടുത്തുന്നത്.

 #include <stdio.h> 
 #include <stdlib.h> 
 #include <unistd.h> 
  
 int main(void) 
 { 
   int pid, ret; 
  
   pid = fork(); 
   if (pid == -1) { 
     printf("fork failed..\n"); 
     exit(-1); 
   } 
  
   if (pid == 0) {  
     printf("I am the child process. Now executing ls\n"); 
     ret = execl("/bin/ls", "ls", "/", NULL); 
     if (ret == -1) {  
       printf("exec failed\n"); 
     }  
   } else { 
     printf("I am the parent process PID is %d. Child PID is %d\n",getpid(), pid); 
   } 
  
   return 0; 
 }

ആദ്യത്തെ പ്രോഗ്രാമിനെ മുകളിൽ കാണുന്നതുപോലെ മാറ്റുക. ബാക്കി നിർദ്ദേശങ്ങൾ പഴയത് തന്നെ. ഇവിടെ താരതമ്യേന എളുപ്പമുള്ള execl എന്ന രൂപമാണ് ഉപയോഗിച്ചിരിക്കുന്നത്. അതിലെ ആദ്യത്തെ പരാമീറ്റർ എക്സിക്യൂട്ട് ചെയ്യണ്ട പ്രോഗ്രാമിന്റെ പാത്ത് ആണ്. ബാക്കിയുള്ളവ ആ പ്രോഗ്രാമിന് ഉള്ള ആർഗ്യുമെന്റുകളും. യൂണിക്സ് സിസ്റ്റങ്ങളിൽ ഒരു പ്രോഗ്രാമിന്റെ ആദ്യത്തെ ആർഗ്യുമെന്റായി ആ പ്രോഗ്രാമിന്റെ തന്നെ പേര് നൽകുന്നതാണ് കീഴ്‌‌വഴക്കം. വിവിധ പേരുകളിൽ ഉപയോഗിക്കുമ്പോൾ വിവിധ തരത്തിൽ പ്രവർത്തിക്കുന്ന പ്രോഗ്രാമുകൾ തയ്യാറാക്കാൻ ഇതുവഴി സാധിക്കും. അതാണ് രണ്ടാമത്തെ ആർഗ്യുമെന്റായി ls എന്ന് തന്നെ കൊടുത്തിരിക്കുന്നത്. മൂന്നാമത്തെ ആർഗ്യുമെന്റ്‌‌ "/" ആണ്. / എന്ന പാത്തിലെ ഫയലുകളുടെ പട്ടിക നൽകാൻ ls പ്രോഗ്രാമിനോട് ആവശ്യപ്പെടുന്നതിനാണ് ഇത്. അവസാനമായി NULL എന്നത് സെന്റിനൽ ആർഗ്യുമെന്റ് അഥവാ സെന്റിനൽ എന്നറിയപ്പെടുന്നു. വ്യത്യസ്ത എണ്ണത്തിലുള്ള പരാമീറ്ററുകൾ സ്വീകരിക്കുന്ന ഫങ്ങ്ഷനുകളോട് ഇതാണ് അവസാനത്തെ പരാമീറ്റർ എന്ന് സൂചിപ്പിക്കാൻ ഇവ ഉപയോഗിക്കുന്നു. (NULL എന്നത് സെന്റിനൽ അല്ല. അതിന് മറ്റ് ഉപയോഗങ്ങൾ ഉണ്ട്. ഇനി പരാമീറ്ററുകൾ ഇല്ല എന്നത് സൂചിപ്പിക്കാനായി ഉപയോഗിക്കുന്നവയെ ആണ് സെന്റിനൽ എന്ന് വിളിക്കുന്നത്. എക്സെക്ക് പ്രതീക്ഷിക്കുന്ന സെന്റിനൽ NULL ആണ്). ls കമാന്റ് -l എന്ന ആർഗ്യുമെന്റ് സ്വീകരിക്കും. ls -l എന്നുപയോഗിക്കുമ്പോൾ ലഭിക്കുന്ന രീതിയിലുള്ള ഔട്ട്പുട്ട് ലഭിക്കാൻ ret = execl("/bin/ls", "ls", "-l", "/", NULL); എന്നാക്കി ആ വരിയെ മാറ്റിയാൽ മതി.

ഒരു പ്രോസസ്സിലെ തന്നെ സ്വതന്ത്രമായ ഒരു ഭാഗം മറ്റൊരു പ്രോസസ്സ് പോലെ ഷെഡ്യൂൾ ചെയ്യാൻ സാധിക്കുന്ന തരത്തിൽ പ്രവർത്തിപ്പിക്കുക എന്നതാണ് ത്രെഡുകൾ വഴി ചെയ്യുന്നത്. ഒരു പ്രോസസ്സിൽ ചിലപ്പോൾ ത്രെഡുകൾ ഉണ്ടാകാം. ഈ ത്രെഡുകൾക്ക് വ്യത്യസ്ത സ്റ്റാക്ക് സെഗ്‌‌മന്റുകൾ ഉണ്ടായിരിക്കുമെങ്കിലും ടെക്സ്റ്റ്, ഡാറ്റ തുടങ്ങിയ സെഗ്മന്റുകൾ ഒക്കെ ഒന്നുതന്നെ ആയിരിക്കും. ലിനക്സിൽ ഒരു ത്രെഡ് സൃഷ്ടിക്കാൻ ഉപയോഗിക്കുന്ന സിസ്റ്റം കോൾ ക്ലോൺ (clone) ആണ്. ഇത് ഒരു പ്രോഗ്രാമിൽ നേരിട്ട് ഉപയോഗിക്കുന്നതിന് പകരം പി-ത്രെഡ്‌ പോലെ ത്രെഡുകൾ കൈകാര്യം ചെയ്യാനുള്ള ലൈബ്രറികൾ എന്തെങ്കിലും ഉപയോഗിക്കുന്ന രീതിയാണ് ശുപാർശ ചെയ്യപ്പെട്ടിരിക്കുന്നത്.

പ്രോസസ് ടേബിളും യു-ഏരിയയും[തിരുത്തുക]

പ്രോസസ്സുകളെക്കുറിച്ചുള്ള വിവരങ്ങൾ രണ്ട് വിഭാഗങ്ങളിലായി ആണ് സൂക്ഷിക്കപ്പെട്ടിരിക്കുന്നത്. പ്രോസസ്സ് ടേബിളും യു-ഏരിയയും. പ്രോസസ്സിനെക്കുറിച്ച് കെർണലിന് ആവശ്യമുള്ള വിവരങ്ങൾ പ്രോസസ്സ് ടേബിളിൽ സൂക്ഷിച്ചിരിക്കും. പ്രോസസ്സിന് തന്നെ ആവശ്യമുള്ള വിവരങ്ങൾ യു-ഏരിയയിലും സൂക്ഷിച്ചിരിക്കും.

പ്രോസസ്സ് ടേബിൾ എൻട്രി[തിരുത്തുക]

കെർണൽ സൂക്ഷിക്കുന്ന പ്രോസസ്സുകളുടെ പട്ടികയാണ് പ്രോസസ്സ് ടേബിൾ. കെർണൽ എങ്ങനെയാണ് പ്രോസസ്സുകളെ കൈകാര്യം ചെയ്യുന്നത് എന്ന് മനസ്സിലാക്കാൻ പ്രോസസ്സ് ടേബിളിനെക്കുറിച്ചൂള്ള വിവരങ്ങൾ സഹായകമായിരിക്കും.

പ്രോസസ്സ് ടേബിൾ ഒരു സർക്കുലർ ഡബ്ലി ലിങ്ക്ഡ് ലിസ്റ്റ് (Circular Doubly Linked List) ആണ്. ഇതിൽ ഏത് പ്രോസസ്സിന്റെ എൻട്രിയിൽ നിന്ന് ആരംഭിച്ചാലും മുന്നിലേക്കോ പിന്നിലേക്കോ പോയി എല്ലാ പ്രോസസ്സുകളുടെയും എൻട്രികളിലൂടെ പോയി വരാൻ സാധിക്കും. ഒരു പ്രോസസ്സിന്റെ പ്രോസസ്സ് ടേബിൾ എൻട്രിയിൽ ഉള്ള വിവരങ്ങളിൽ ചിലത് താഴെക്കൊടുക്കുന്നു.

പ്രോസസ്സിന്റെ അവസ്ഥ. (യൂണിക്സിലെ വിവിധ പ്രോസസ്സ് അവസ്ഥകൾ വിശദമാക്കുന്ന ചിത്രം കൊടുത്തിരിക്കുന്നു)
പ്രോസസ്സ് ഐഡി
വിവിധ യൂസർ ഐഡികൾ - ഇവ ഉപയോഗിച്ചാണ് ഒരു പ്രോസസ്സിനുള്ള അനുമതികൾ തീരുമാനിക്കപ്പെടുന്നത്.
പ്രോസസ്സിലും ഷെയേർഡ് ലൈബ്രറികളിലുമായി ഉള്ള ടെക്സ്റ്റ് സെഗ്‌‌മെന്റുകളിലേക്കുള്ള പോയിന്ററുകൾ.
മെമ്മറി മാനേജ്‌‌മെന്റ് ആവശ്യങ്ങൾക്കായി പേജ് ടേബിളിലേക്കുള്ള പോയിന്ററുകൾ.
ഷെഡ്യൂളിങ്ങിന് ആവശ്യമായ വിവരങ്ങൾ. ലിനക്സ് സിസ്റ്റങ്ങളിൽ പ്രോസസ്സുകൾക്ക് 'നൈസ് വാല്യു' എന്നറിയപ്പെടുന്ന മൂല്യങ്ങൾ നൽകിയിരിക്കും. പ്രോസസ്സ് ഷെഡ്യൂളിങ്ങിന്റെ സമയത്ത് ഏതൊക്കെ പ്രോസസ്സുകൾക്ക് പ്രാധാന്യം നൽകണം എന്ന് തീരുമാനിക്കപ്പെടുന്നത് ഈ മൂല്യത്തിന്റെ അടിസ്ഥാനത്തിലാണ്.
വിവിധ ടൈമറുകൾ. ഓരോ പ്രോസസ്സിനും പ്രവർത്തിക്കാൻ സി പി യു വിൽ സമയപരിധികൾ തീരുമാനിക്കപ്പെട്ടിരിക്കും. ഈ പരിധികൾ പാലിക്കാനും പ്രോസസ്സ് എത്ര സമയം ഏതൊക്കെ മോഡിൽ പ്രവർത്തിച്ചു എന്നൊക്കെ കണക്കാക്കാനും ഈ ടൈമറുകൾ ഉപയോഗിക്കപ്പെടുന്നു.
പ്രോസസ്സിന്റെ യു-ഏരിയയിലേക്കുള്ള പോയിന്റർ.

യു-ഏരിയ[തിരുത്തുക]

പ്രോസസ്സിന്റെ യു-ഏരിയയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന കാര്യങ്ങൾ ചുവടെ ചേർക്കുന്നു.

റിയൽ യൂസർ ഐഡി, എഫക്റ്റീവ് യൂസർ ഐഡി.
പ്രോഗ്രാമിന്റെ വർക്കിങ്ങ് ഡയറക്ടറി (ഒരു പ്രോഗ്രാം പ്രവർത്തിക്കുന്നത് ഒരു സമയത്ത് ഫയൽ സിസ്റ്റത്തിലെ ഏതെങ്കിലും ഒരു ഡയറക്ടറിയിൽ ആയിരിക്കും. ഇതിന് പ്രോഗ്രാമുമായി നേരിട്ട് ബന്ധമൊന്നുമില്ലെങ്കിലും ആ ഡയറക്ടറിയിൽ ഉള്ള ഫയലുകൾ ഉപയോഗിക്കാൻ മുഴുവൻ പാത്ത് നൽകാതെ ഫയലിന്റെ പേര് മാത്രം ഉപയോഗിച്ചാൽ മതിയാകും)
യൂസർ മോഡിലും കെർണൽ മോഡിലുമായി പ്രോഗ്രാം ചെലവിട്ട സമയം കണക്കാക്കുന്നതിനായുള്ള ടൈമറുകൾ.
പ്രോഗ്രാം സിഗ്നലുകളോട് എങ്ങനെ പ്രതികരിക്കണം എന്നതിനെ സംബന്ധിച്ച വിവരങ്ങൾ.
പ്രോഗ്രാമുമായി ബന്ധപ്പെട്ടിരിക്കുന്ന കണ്ട്രോളിങ്ങ് ടെർമിനലിനെ സംബന്ധിച്ച വിവരങ്ങൾ.
പ്രോഗ്രാം നടത്തിയ സിസ്റ്റം കോളൂകളെ സംബന്ധിച്ച വിവരങ്ങൾ.
യൂസർ ഫയൽ ഡിസ്ക്രിപ്റ്റർ ടേബിൾ - ഒരു പ്രോഗ്രാം തുറക്കുന്ന ഫയലുകളുടെ ഡിസ്ക്രിപ്റ്ററുകളുടെ പട്ടിക.
ഫയൽ സിസ്റ്റത്തെയും പ്രോസസ്സ് എൻവയോൺമെന്റിനെയും സംബന്ധിച്ച വിവരങ്ങൾയ്

യൂസർ ഐഡികൾ[തിരുത്തുക]

ഫയലുകൾക്ക് ഉള്ളത് പോലെ തന്നെ പ്രോസസ്സുകൾക്കും യൂസറും ഗ്രൂപ്പും ഒക്കെ ഉണ്ട്. ഇത് കൂടാതെ സെഷനും. പ്രോസസ്സുകൾക്കുള്ള വിവിധ യൂസർ/ഗ്രൂപ്പ് ഐഡികൾ എന്നിവ ചുവടെ. സിസ്റ്റത്തിൽ ഉള്ള ഓരോ ഉപയോക്താവിന്റെയും ഗ്രൂപ്പിന്റെയും പേരുകൾ ഒരു യൂസർ ഐഡിയും ഗ്രൂപ്പ് ഐഡിയും ആയി ബന്ധപ്പെട്ടിരിക്കുന്നു. എല്ലാ സമയത്തും മുഴുവൻ പേരും ഉപയോഗിക്കാനുള്ള വിഷമം പരിഗണിച്ചാണ് ഓരോ പേരുകളുമായി ബന്ധപ്പെട്ട് സംഖ്യകൾ നൽകിയിരിക്കുന്നത്. ഇതിനെപ്പറ്റിയുള്ള വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നത് /etc/passwd, /etc/group എന്നീ ഫയലുകളിൽ ആണ് ഉണ്ടായിരിക്കുക.

റിയൽ യൂസർ ഐഡി[തിരുത്തുക]

ഇത് ഒരു പ്രോസസ്സ് തുടങ്ങിവച്ച ഉപയോക്താവിന്റെ ഐഡി ആയിരിക്കും. ഒരു പ്രോസസ്സ് ആരംഭിച്ച ശേഷം സെറ്റ്‌‌യുഐഡി വഴി അതിന്റെ യൂസർ ഐഡി മാറ്റിയേക്കാം. എന്നാലും റിയൽ യൂസർ ഐഡി പഴയത് തന്നെ ആയിരിക്കും. ഈ പ്രോസസ്സ് ഉണ്ടാക്കുന്ന ഫയലുകൾക്കോ പ്രോസസ്സിന്റെ അനുമതികൾക്കോ റിയൽ യൂസർ ഐഡി ഉപയോഗിക്കാറില്ല. എന്നാൽ മറ്റ് പ്രോസസ്സുകൾക്ക് സിഗ്നലുകൾ അയക്കുമ്പോൾ പരിഗണിക്കുന്നത് റിയൽ യൂസർ ഐഡി ആണ്. സൂപ്പർയൂസർ അനുമതികളില്ലാത്ത ഒരു പ്രോസസ്സിന് അതിന്റെ റിയൽ യൂസർ ഐഡി തന്നെയുള്ള പ്രോസസ്സുകൾക്കേ സിഗ്നലുകൾ അയക്കാൻ സാധിക്കുകയുള്ളു.

എഫക്റ്റീവ് യൂസർ ഐഡി[തിരുത്തുക]

ഒരു പ്രോസസ്സ് സൃഷ്ടിക്കപ്പെട്ട ശേഷം സെറ്റ്‌‌യുഐഡി ഉപയോഗിച്ച് ആ പ്രോസസ്സിന്റെ എഫക്റ്റീവ് യൂസർ ഐഡി റിയൽ യൂസർ ഐഡിയിൽ നിന്ന് മാറ്റാൻ സാധിക്കും. ഒരു പ്രോസസ്സ് ഫയലുകൾ നിർമ്മിക്കുകയോ ഏതെങ്കിലും ഒരു റിസോഴ്സ് ഉപയോഗിക്കാൻ ശ്രമിക്കുകയോ ചെയ്യുമ്പോൾ ആ പ്രോസസ്സിന്റെ എഫക്റ്റീവ് യൂസർ ഐഡി ആണ് പരിഗണിക്കപ്പെടുക.

ഗ്രൂപ്പ് ഐഡികളും മേൽപ്പറഞ്ഞത് പോലെ തന്നെ. യൂസറിന് പകരം യൂസർ ഉൾപ്പെടുന്ന ഗ്രൂപ്പിന്റെ ഐഡി ആയിരിക്കും പരിഗണിക്കപ്പെടുക. താഴെക്കൊടുത്തിരിക്കുന്ന പ്രോഗ്രാം പ്രോസസ്സിന്റെ യൂസർ ഐഡി, ഗ്രൂപ്പ് ഐഡി തുടങ്ങിയവ കാണിച്ചു തരും. sudo ഉപയോഗിക്കാതെ റൺ ചെയ്താൽ setuid പ്രവർത്തിക്കില്ല. 65534 nobody എന്ന യൂസറിന്റെ ഐഡി ആണ്. ലഭ്യമായ യൂസർ ഐഡികൾക്കായി /etc/passwd ഫയൽ തുറന്ന് നോക്കുക. സെറ്റ്‌‌യുഐഡി റിയൽ യൂസർ ഐഡി മാറ്റുന്നില്ല എന്ന് ഈ പ്രോഗ്രാം പ്രവർത്തിക്കുമ്പോൾ മനസ്സിലാക്കാം.

#include <stdio.h> 
#include <unistd.h> 
 
int main(void)  
{ 
  printf("The real user of this process has ID %d\n",getuid()); 
  printf("The effective user of this process has ID %d\n",geteuid()); 
  printf("The real user group ID for this process is %d\n",getgid()); 
  printf("The effective user group for this process is %d\n",getegid()); 
 
  setuid(65534); 
 
  printf("The real user of this process has ID %d\n",getuid()); 
  printf("The effective user of this process has ID %d\n",geteuid()); 
  printf("The real user group ID for this process is %d\n",getgid()); 
  printf("The effective user group for this process is %d\n",getegid()); 
 
  return 0; 
}

പ്രോസസ്സ് സെഷൻ[തിരുത്തുക]

എല്ലാ പ്രോസസ്സുകളും ഒരു പ്രോസസ്സ് സെഷന്റെ ഭാഗമായിരിക്കും. മിക്കവാറും സിസ്റ്റം പ്രവർത്തിച്ച് തുടങ്ങുമ്പോൾ ഉള്ള ലോഗിൻ പ്രോസസ്സ് ആയിരിക്കും ഒരു സെഷൻ ആരംഭിക്കുക. അതിന്റെ ചൈൽഡ് പ്രോസസ്സുകൾ ഒക്കെ ആ സെഷനിൽ ആയിരിക്കും. ഒരു സെഷനിലെ ആദ്യത്തെ പ്രോസസ്സ് ആണ് സെഷൻ ലീഡർ എന്നറിയപ്പെടുന്നത്. സെഷൻ ഐഡി സെഷൻ ലീഡറിന്റെ പിഐഡി ആയിരിക്കും. എല്ലാ പ്രോസസ്സ് സെഷനുകൾക്കും ഒരു കണ്ട്രോളിങ്ങ് റ്റിറ്റിവൈ ഉണ്ടായിരിക്കും. ഇതിനെ ടെർമിനൽ എന്ന് വിളിക്കാം. ആദ്യകാലത്ത് ഒരു പ്രധാന കമ്പ്യൂട്ടറുമായി ഘടിപ്പിക്കപ്പെട്ടിരുന്ന ഉപകരണങ്ങളായിരുന്നു ടെർമിനലുകൾ. ഒന്നിലധികം ടെർമിനലുകൾ ഉപയോഗിച്ച് ഒന്നിലധികം ഉപയോക്താക്കൾ ഒരേ കമ്പ്യൂട്ടർ തന്നെ പ്രവർത്തിപ്പിച്ചിരുന്നു. ps -e എന്ന നിർദ്ദേശം ഉപയോഗിച്ച് സിസ്റ്റത്തിലെ പ്രോസസ്സുകളും അവയുടെ TTY ഉം കാണാൻ സാധിക്കും. ചില പ്രോസസ്സുകൾക്ക് കണ്ട്രോളിങ്ങ് ടെർമിനൽ കാണില്ല. അവയെക്കുറിച്ച് പിന്നീട് പറയാം. താഴെക്കൊടുത്തിരിക്കുന്ന പ്രോഗ്രാം അതിന്റെ സെഷൻ ഐഡി കാട്ടിത്തരും. അതിന് ശേഷം ps നിർദ്ദേശം ഉപയോഗിച്ചാൽ ആ പ്രോഗ്രാമിനെ പ്രവർത്തിപ്പിച്ച ഷെല്ലിന്റെ പിഐഡി തന്നെയാണ് സെഷൻ ഐഡി എന്ന് കാണാം. അതിന്റെ കാരണം ഊഹിക്കാമല്ലോ..

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
 
int main(void) 
{ 
  printf("My session id is: %d\n", getsid(getpid())); 
 
  return 0; 
}