ഫീഡ്ബാക്ക് ടൈം, ഭാവി പരിപാടികൾ

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

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

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

ഗൂഗിൾ പ്ലസ് പ്രൊഫൈൽ: https://plus.google.com/u/0/106314097353629534444/posts

ഇ-മെയിൽ വിലാസം: ptsubin അറ്റ് gmail ഡോട്ട് com

ലിനക്സ് ഡിസ്ട്രിബ്യൂഷൻ

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

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

ഒരു ലിനക്സ് ഡിസ്ട്രിബ്യൂഷൻ എന്നത് അല്പ്പം കൂടി വിശാലമായ ഒരു ആശയമാണ്. ലിനക്സ് കെർണൽ അടിസ്ഥാനമാക്കിയ ഒരു സമ്പൂർണ്ണ കമ്പ്യൂട്ടർ ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം ആയിരിക്കും ഓരോ ലിനക്സ് ഡിസ്ട്രിബ്യൂഷനും. ഒരു ലിനക്സ് ഡിസ്ട്രിബ്യൂഷനിൽ ഒഴിച്ച്കൂടാൻ കഴിയാത്ത ഭാഗങ്ങൾ ഏതൊക്കെ ആണെന്ന് നോക്കാം.

1. ലിനക്സ് കെർണൽ - ലിനക്സ് അധിഷ്ഠിത സിസ്റ്റം ആയതിനാൽ ഇത് ഇല്ല്ലാതെ സാധിക്കില്ല.

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

ഇവക്കു പുറമേ വിവിധ ഡിസ്ട്രിബ്യൂഷനുകൾ കമ്പ്യൂട്ടറിലെ ഉപകരണങ്ങളുടെ ക്രമീകരണങ്ങളും മറ്റും എളുപ്പമാക്കുന്നതിനായി വിവിധ സൗകര്യങ്ങളും ലഭ്യമാക്കുന്നു. ലിനക്സ് കെർണൽ അധിഷ്ഠിതമായ സിസ്റ്റങ്ങളുടെ സജ്ജീകരണവും ഉപയോഗവും എളുപ്പമാക്കുക എന്നതാണ് ഡിസ്ട്രിബ്യൂഷനുകളുടെ പ്രധാന ലക്ഷ്യം. ലിനക്സ് കെ‌‌ർണലും പതിനായിരത്തിൽ പരം പ്രോഗ്രാമുകളും ഏത് രീതിയിൽ വേണമെങ്കിലും മാറ്റങ്ങൾ വരുത്താനുള്ള അനുവാദത്തോടെ സൗജന്യമായി ലഭ്യമായിരിക്കുന്നത് നിരവധി ഡിസ്ട്രിബ്യൂഷനുകൾ പിറവിയെടുക്കുന്നതിലേക്ക് നയിച്ചിട്ടുണ്ട്. ഇന്ന് ലഭ്യമായ മിക്ക ഡിസ്ട്രിബ്യൂഷനുകളും അവ ഉരുത്തിരിഞ്ഞ് മാതൃ ഡിസ്ട്രിബ്യൂഷനുകളും വിവരിക്കുന്ന ഒരു ചിത്രം ഇവിടെ ലഭ്യമാണ്.

വിവിധ മേഖലകളിൽ പ്രവർത്തിക്കുന്ന ആളുകൾക്ക് അനുയോജ്യമായ രീതിയിൽ വിവിധ പ്രവർത്തനങ്ങൾക്ക് യോജിക്കുന്ന അനവധി ലിനക്സ് ഡിസ്ട്രിബ്യൂഷനുകൾ ഇന്ന് ലഭ്യമാണ്. ഇവയുടെ ഒരു പട്ടികയും ചുരുങ്ങിയ വിവരണവും ഇവിടെ ലഭ്യമാണ്.

ബിസിബോക്സും ലിനക്സ് കെർണലും ഉപയോഗിച്ച് ഒരു കൊച്ചു ലിനക്സ് സിസ്റ്റം തയ്യാറാക്കുന്ന രീതി അടുത്ത ഭാഗത്തിൽ.

ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ്

ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസുകൾ കമ്പ്യൂട്ടറുകളുടെ ഉപയോഗത്തെ എളുപ്പമാക്കുന്നതിലും ജനകീയമാക്കുന്നതിലും വളരെ വലിയ പങ്കാണ് വഹിച്ചത്. ഷെല്ലിൽ കമാന്റുകൾ ഉപയോഗിച്ച് കമ്പ്യൂട്ടറുകളെ പ്രവർത്തിപ്പിക്കുന്നതിനു പകരം മൗസും കീബോർഡും മറ്റും ഉപയോഗിച്ച് മെനു, ഐക്കൺ എന്നിവ വഴി കൂടുതൽ എളുപ്പത്തിൽ കമ്പ്യൂട്ടർ പ്രവർത്തിപ്പിക്കാൻ സാധിച്ചതിലൂടെ കമാന്റുകൾ ഓർത്ത് വയ്ക്കേണ്ട ആവശ്യം ഇല്ലാതായി. സിറോക്സ് കമ്പനി ആണ് ആദ്യത്തെ ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ് അവതരിപ്പിച്ചത്. യൂണിക്സ് സിസ്റ്റങ്ങളിൽ ആദ്യമായി ഉപയോഗിച്ച ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ് സ്റ്റാൻഫോർഡ് യൂണിവേഴ്സിറ്റിയിൽ വികസിപ്പിക്കപ്പെട്ട W Window System ആയിരുന്നു. ഇതിൽ നിന്നും പ്രചോദനമുൾക്കൊണ്ട് എംഐറ്റി യിൽ വച്ച് X Windows System വികസിപ്പിക്കപ്പെട്ടു. എക്സ് വിൻഡോസ് സിസ്റ്റത്തെ ഒരു ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ് എന്ന് വിളിക്കാൻ സാധിക്കില്ല. ഇത് ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസുകൾ നിർമ്മിക്കാനാവശ്യമായ അടിസ്ഥാന ഘടകങ്ങളെ ലഭ്യമാക്കുന്ന ഒരു പ്രോഗ്രാമും പ്രോഗ്രാമുകളും എക്സ് സെർവറും തമ്മിലുള്ള ആശയ വിനിമയ രീതി നിർവ്വചിക്കുന്ന ഒരു പ്രോട്ടോക്കോളും ഉൾപ്പെട്ടതാണ്. പ്രോഗ്രാമുകൾക്ക് ജാലകങ്ങൾ ഉണ്ടാക്കാനും അവ സ്ക്രീനിൽ നീക്കാനും, മൗസ് കീബോർഡ് തുടങ്ങിയവ ഉപയോഗിച്ച് അതിനെ നിയന്ത്രികാനും ഉള്ള സൗകര്യങ്ങൾ എക്സ് ഒരുക്കിത്തരുന്നു. പരമ്പരാഗത യൂണിക്സ് സിസ്റ്റങ്ങളുടെ ഉപയോഗ രീതി പരിഗണിച്ച് നെറ്റ്‌‌വർക്ക് വഴി ബന്ധിപ്പിച്ചിരിക്കുന്ന ഗ്രാഫിക്കൽ ടെർമിനലുകളിൽ ഉപയോഗിക്കാൻ അനുയോജ്യമായ രീതിയിൽ ആണ് എക്സ് വികസിപ്പിക്കപ്പെട്ടത്. ഇത് ഗ്രാഫിക്കൽ ഹാർഡ്‌‌വെയറുകളുടെ വിവരങ്ങൾ പ്രോഗ്രാമ്മറിൽ നിന്നും ഉപയോക്താവിൽ നിന്നും മറച്ചുവയ്ക്കുന്ന ഒരു പാളി പോലെ പ്രവർത്തിക്കുന്നു. (Hardware Abstraction Layer). അതിനാൽ തന്നെ ഇതുപയോഗിക്കുന്ന പ്രോഗ്രാമുകൾക്ക് അത് പ്രവർത്തിക്കുന്ന കമ്പ്യൂട്ടറിലെ ഗ്രാഫിക്കൽ ഹാർഡ്‌‌വെയർ ഏതായാലും ഒരേപോലെ പ്രവർത്തിക്കാൻ സാധിക്കും. അല്ലായിരുന്നെങ്കിൽ ഓരോ പ്രോഗ്രാമിനും ഓരോ ഗ്രാഫിക്സ് കാർഡിലും പ്രവർത്തിക്കാനുള്ള പതിപ്പുകൾ വെവ്വേറെ തയ്യാറാക്കണ്ട വരുമായിരുന്നു. എക്സ് വിൻഡോസ് സിസ്റ്റത്തിന്റെ ഘടന വിശദീകരിക്കുന്ന ചിത്രം നോക്കൂ,

കടപ്പാട്: വിക്കിപീഡിയ

ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസിനാവശ്യമായ ഘടകങ്ങൾ ലഭ്യമാക്കുക എന്നതിനപ്പുറം മെനു, ബട്ടണുകൾ, വിൻഡോകൾ ഒക്കെ എങ്ങനെ ദൃശ്യമാകണമെന്നതിനെപ്പറ്റി എക്സ് ഒരു നിർബന്ധവും വയ്ക്കുന്നില്ല. ഇത് സാധാരണയായി ചെയ്യുന്നത് എക്സ് ഉപയോഗിക്കുന്ന പ്രോഗ്രാമുകൾ ആണ്. അതിനാൽ തന്നെ എക്സ് ഉപയോഗിക്കുന്ന ജിയുഐ കൾ എല്ലാം ഒരുപോലെ ആയിരിക്കില്ല. ഇന്നത്തെ ലിനക്സ് അധിഷ്ഠിത കമ്പ്യൂട്ടറുകളിൽ ഇത് ചെയ്യുന്നത് ഡെസ്ക്ടോപ്പ് എൻവയോൺമെന്റിലെ വിൻഡോ മാനേജർ ആണ്. ഒരു ഡെക്സ്ടോപ്പ് എൻവയോൺമെന്റ് എന്നത് ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ്, ഐക്കണുകൾ, വിവിധ പ്രോഗ്രാമുകൾ എന്നിവയുടെ ഒരു കൂട്ടമാണ്. ഗ്നോം‌‌, കെഡി‌‌ഇ, Xfce, LXDE എന്നിവയൊക്കെ ഇന്ന് യൂണിക്സ് രീതിയിലുള്ള ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളിൽ വളരെയധികം ഉപയോഗിക്കപ്പെടുന്ന ഡെസ്ക്ടോപ്പ് എൻവയോൺമെന്റുകൾ ആണ്. ഇവ ലിനക്സിൽ മാത്രമല്ല പ്രവർത്തിക്കുന്നത്. ഒരു ഡെസ്ക്ടോപ്പ് എൻവയോൺമെന്റിൽ കമ്പ്യൂട്ടർ പ്രവർത്തിപ്പിക്കാൻ ആവശ്യമായ പ്രോഗ്രാമുകളും ഉൾപ്പെടുത്തിയിരിക്കുന്നു. കുറഞ്ഞത് ഒരു വെബ്‌‌ ബ്രൗസർ, ഫയൽ മാനേജർ, മീഡിയ പ്ലെയർ, ടെർമിനൽ ഇമുലേറ്റർ, ടെക്സ്റ്റ് എഡിയർ എന്നിവ ഇതിൽ ഉൾപ്പെട്ടിരിക്കും. ഇതിനു പുറമെ വിവിധ ഡെസ്ക്ടോപ്പുകൾ ക്രമീകരിക്കാനും ഉപയോഗിക്കാനും ആവശ്യമായ ക്രമീകരണങ്ങൾ, വിവിധ ഉപകരണങ്ങൾ ക്രമീകരിക്കാനുള്ള സംവിധാനങ്ങൾ, മൗസ് പോയിന്ററുകൾ, തീമുകൾ, ഐക്കണുകൾ, വാൾ പേപ്പറുകൾ ഒക്കെ ഇതിൽ ഉൾപ്പെടുന്നു. വിവിധ പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാനും അവയെ നിയന്ത്രിക്കാനും ഉള്ള സൗകര്യം ആണ് ഇവയിലെ അടിസ്ഥാന ഘടകം. പ്രോഗ്രാമുകളുടെ ഐക്കണുകളിൽ മൗസ് ഉപയോഗിച്ച് അമർത്തുമ്പോൾ അവയെ പ്രവർത്തിപ്പിക്കുകയും ക്ലോസ് ബട്ടൺ അമർത്തുമ്പോൾ അവയുടെ പ്രവർത്തനം അവസാനിപ്പിക്കുകയും ഒക്കെ ഇതിന്റെ കടമകളിൽ ഉൾപ്പെടുന്നു. ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസുകളുടെ വരവോടെ കമാന്റ് ലൈൻ ഇന്റർഫേസുകളുടെ കാലം അവസാനിച്ചില്ല. വിദഗ്ധരായ ഉപയോക്താക്കൾക്ക് പലപ്പോളും ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസുകളിലേതിനെക്കാൾ എളുപ്പത്തിലും സൗകര്യപ്രദമായും കമാൻഡ് ലൈനിൽ ചില കാര്യങ്ങൾ ചെയ്യാൻ സാധിക്കും. അതിനാൽ തന്നെ ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസിനുള്ളിൽ കമാന്റ് ലൈൻ ഇന്റർഫേസുകൾ ലഭ്യമാക്കുന്ന ടെർമിനൽ ഇമുലേറ്ററുകൾ ഡെസ്ക്ടോപ്പ് എൻവയോൺമെന്റുകളിലെ അവിഭാജ്യ ഘടകം തന്നെയാണ്.

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

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

ലിനക്സ് ഡിസ്ട്രിബ്യൂഷനുകളെക്കുറിച്ച് അടുത്ത പോസ്റ്റ്.

ടെർമിനൽ

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

പരമ്പരാഗത യൂണിക്സ് സിസ്റ്റങ്ങളെ താഴെക്കൊടുത്തിരിക്കുന്ന രീതിയിൽ കാണാവുന്നതാണ്

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

ഒരു ഉപയോക്താവ് കമ്പ്യൂട്ടറുമായി ടെർമിനൽ ഉപകരണം ഘടിപ്പിക്കുമ്പോൾ കമ്പ്യൂട്ടറിൽ getty (get teletype) പ്രോഗ്രാം അത് കണ്ടെത്തുകയും ഉഅയോക്താവിനോട് യൂസർ നെയിം, പാസ്‌‌വേർഡ് ഇവ എന്റർ ചെയ്യാൻ ആവശ്യപ്പെടുകയും ചെയ്യുന്നു. അതിനു ശേഷം ഉപയോക്താവിന് ഒരു കമാന്റ് ലൈൻ ഇന്റർഫേസ് (ഷെൽ) ലഭിക്കുന്നു. അതുവഴി ഉപയോക്താവിന് പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കാൻ സാധിക്കുന്നു. ഓരോ യൂണിക്സ് പ്രോഗ്രാമും ഓരോ‌ കണ്ട്രോളിങ്ങ് ടെർമിനലുമായി ബന്ധിപ്പിക്കപ്പെട്ടിരിക്കും. പ്രോഗ്രാമിന്റെ ഇൻപുട്ട്, ഔട്ട്പുട്ട് തുടങ്ങിയവ ഈ ടെർമിനലിൽ നിന്നും ടെർമിനലിലേക്കും ആയിരിക്കും. എന്നാൽ ഡെമോൺ പ്രോസസ്സുകൾ (സർവ്വീസുകൾ) ടെർമിനലുകളുമായി ബന്ധിക്കപ്പെട്ടിരിക്കില്ല. ഈ പ്രോസസ്സുകൾ തുടങ്ങുമ്പോൾ അവ ടെർമിനലുമായി ബന്ധിപ്പിക്കപ്പെട്ടിരിക്കുമെങ്കിലും അവ അവയുടെ ഇൻപുട്ട് ഔട്ട്പുട്ട് സ്ട്രീമുകളുടെ ഫയൽ ഡിസ്ക്രിപ്റ്റർ ക്ലോസ് ചെയ്ത് ടെർമിനലുകളിൽ നിന്ന് സ്വയം വിച്ഛേദിക്കുന്നു.

ഇന്നത്തെ ഡെസ്ക്ടോപ്പ് കമ്പ്യൂട്ടറുകളിൽ ടെർമിനൽ ഉപകരണങ്ങൾ ഉപയോഗിക്കാറില്ലെങ്കിലും ഇതേ രീതി തന്നെയാണ് പിൻതുടരുന്നത്. ടെർമിനൽ ഉപകരണങ്ങൾക്ക് പകരമായി ടെർമിനൽ ഇമുലേറ്റർ പ്രോഗ്രാമുകൾ ഇന്ന് ഉപയോഗിക്കപ്പെടുന്നു. PuTTY, Konsole, Gnome Terminal, Xterm തുടങ്ങി അനവധി ടെർമിനൽ ഇമുലേറ്റർ പ്രോഗ്രാമുകൾ ലഭ്യമാണ്. Telnet, SSH, rlogin തുടങ്ങിയ വിവിധ പ്രോട്ടോക്കോളുകൾ അടിസ്ഥാനമാക്കി ആണ് ഇവ പ്രവർത്തിക്കുന്നത്. ഗ്രാഫിക്കൽ ടെർമിനലുകൾക്കായി X Window System (X11) ഉപയോഗിക്കുന്നു. ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസുകൾ ലഭ്യമാക്കാനുള്ള പ്രോട്ടോക്കോൾ ആണിത്. ഇതിനെ അടിസ്ഥാനമാക്കി ആണ് വിവിധ ഡെസ്ക്ടോപ്പ് എൻവയോൺമെന്റുകൾ (Gnome, KDE, Xfce, LXDE) തുടങ്ങിയവ പ്രവർത്തിക്കുന്നത്. ഒരു ക്ലയന്റ് - സെർവർ സംവിധാനമാണിത്. ഒരു ടെർമിനൽ ഇമുലേറ്റർ ഉപയോഗിക്കുമ്പോൾ ലഭിക്കുന്ന ടെർമിനലിനെ വിർച്ച്വൽ ടെർമിനൽ എന്ന് വിളിക്കുന്നു.

ഡെസ്ക്ടോപ്പ് കമ്പ്യൂട്ടറുകളിലും ടെർമിനലുകൾ ലഭ്യമാണ്. CTRL+ALT+F1 - F12 കീകൾ ഉപയോഗിച്ച് ഓരോ ടെർമിനലുകളും ലഭ്യമാക്കാം. ഇതിൽ ഒന്നുമുതൽ ആറുവരെയുള്ള ടെർമിനലുകൾ ടെക്സ്റ്റ് ടെർമിനലുകളും അതിനു ശേഷമുള്ളവ ഗ്രാഫിക്കൽ ടെർമിനലുകളും ആണ്. tty1, tty2 ... എന്നിങ്ങനെ ഇവക്ക് പേരുകൾ നൽകിയിരിക്കുന്നു. CTRL+ALT+F1 അമർത്തി tty1 ലേക്ക് പോകാം. അവിടെ യൂസർ നെയിമും പാസ്‌‌വേർഡും ടൈപ്പ് ചെയ്താൽ ഷെൽ ലഭിക്കും. തിരികെ ഗ്രാഫിക്കൽ ഇന്റർഫേസിലേക്ക് മടങ്ങി വരാൻ CTRL+ALT+F7 ഉപയോഗിക്കാം. ആദ്യത്തെ ഗ്രാഫിക്കൽ ടെർമിനൽ  ആയ tty7 ഇൽ ആണ് X സാധാരണയായി ആരംഭിക്കുന്നത്. നിങ്ങളുടെ മോണിറ്റർ ഈ ടെർമിനലുമായി ഘടിപ്പിക്കപ്പെട്ടിരിക്കുന്ന ഒരു ഗ്രാഫിക്കൽ ടെർമിനൽ ഉപകരണമായി കണക്കാക്കാവുന്നതാണ്. സിസ്റ്റം സ്റ്റാർട്ടപ്പിൽ X സെർവർ പ്രവർത്തനമാരംഭിക്കുകയും അത് tty7 ഉമായി ബന്ധിപ്പിക്കപ്പെടുകയും ചെയ്യുന്നു. 

ടെർമിനൽ ഇമുലേറ്ററുകൾ വഴി ലഭിക്കുന്ന വിർച്ച്വൽ ടെർമിനലുകൾ ബന്ധിപ്പിക്കപ്പെട്ടിരിക്കുക സ്യൂഡോ ടെർമിനലുകളുമായി (Pseudo terminal) ആയിരിക്കും. ഇവക്ക് പേരുകൾ നൽകുന്നത് pts/0, pts/1 എന്നിങ്ങനെ ആണ്. ഉപയോഗിച്ചുകൊണ്ടിരിക്കുന്ന ഷെൽ ഏത് ടെർമിനലുമായി ബന്ധിക്കപ്പെട്ടിരിക്കുന്നു എന്നറിയാൻ tty എന്ന കമാന്റ് ഉപയോഗിക്കാം. ഇത് ഓരോ ടെർമിനലുകളിൽ പരീക്ഷിച്ച് നോക്കൂ. കമ്പ്യൂട്ടറിൽ ഒരു സമയത്ത് ലോഗിൻ ചെയ്തിരിക്കുന്ന ആളുകളുടെ വിവരങ്ങൾ കാണാനും അവർ ഉപയോഗിക്കുന്ന ടെർമിനൽ ഏതെന്നറിയാനും w കമാൻഡോ who കമാൻഡോ ഉപയോഗിക്കാം. ps -e കമാൻഡ് ഉപയോഗിച്ച് കമ്പ്യൂട്ടറിൽ പ്രവർത്തിച്ചുകൊണ്ടിരിക്കുന്ന പ്രോസസ്സുകളും അവയുടെ കണ്ട്രോളിങ്ങ് ടെർമിനലും കാണാൻ സാധിക്കും. ഇതിൽ നിരവധി പ്രോസസ്സുകളുടെ TTY എന്ന കോളത്തിൽ ? എന്ന് മാത്രമേ കാണൂ. അവ ഒരു ടെർമിനലുമായും ബന്ധിക്കപ്പെട്ടിട്ടില്ല എന്നതാണ് ഇത് സൂചിപ്പിക്കുന്നത്. അവ ഏത് തരം പ്രോസസ്സ് ആയിരിക്കും എന്ന് ഊഹിക്കാമല്ലോ..

ഒരു ലിനക്സ് കമ്പ്യൂട്ടറിൽ നെറ്റ്‌‌വർക്ക് വഴി ssh പ്രോഗ്രാം ഉപയോഗിച്ച് ലോഗിൻ ചെയ്ത് നിരവധി ആളുകൾക്ക് ഒരേ സമയത്ത് ആ കമ്പ്യൂട്ടറിനെ ഉപയോഗിക്കാൻ സാധിക്കും. ssh -Y ഓപ്ഷൻ ഉപയോഗിച്ചാൽ ഗ്രാഫിക്കൽ ഇന്റർഫേസ് ഉപയോഗിക്കുന്ന പ്രോഗ്രാമുകളെയും പ്രവർത്തിപ്പിക്കാൻ സാധിക്കും.

ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ്, ഡെസ്ക്ടോപ്പ് എൻവയോൺമെന്റ് എന്നിവയെപ്പറ്റി അടുത്ത പോസ്റ്റ്..

ലിനക്സ് സിസ്റ്റം സ്റ്റാർട്ടപ്പ് - 3

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

വിവിധ യൂണിക്സ് സിസ്റ്റങ്ങളിൽ വിവിധ ഇനിറ്റ് പ്രോഗ്രാമുകൾ ആയിരിക്കും ഉണ്ടായിരിക്കുക. ലിനക്സ് ഡിസ്ട്രിബ്യൂഷനുകൾ ഉപയോഗിക്കുന്ന ചില ഇനിറ്റ് പ്രോഗ്രാമുകൾ താഴെ കൊടുക്കുന്നു.

1. സിസ്‌‌ വി ഇനിറ്റ് (SysV Init)

യൂണിക്സ് സിസ്റ്റങ്ങളിൽ പരമ്പരാഗതമായി ഉപയോഗിച്ച് വന്നിരുന്ന ഇനിറ്റ് പ്രോഗ്രാമാണിത്. ഈ പ്രോഗ്രാമിന്റെ പ്രവർത്തനം /etc/inittab എന്ന ക്രമീകരണ ഫയലിനെ അടിസ്ഥാനമാക്കി ആണ്. /etc/init.d/ എന്ന ഡയറക്റ്ററിയിൽ ആണ് വിവിധ സർവ്വീസുകൾ നിർവചിച്ചിരിക്കുന്ന ഫയലുകൾ ഉണ്ടായിരിക്കുക. ഇത് സർവ്വീസുകളെ ഒന്നിനു ശേഷം ഒന്നായി ആരംഭിക്കുന്നു.

2. സിസ്റ്റംഡി (Systemd)

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

3. അപ്‌‌സ്റ്റാർട്ട് (Upstart)

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

4. ആൻഡ്രോയിഡ് ഇനിറ്റ്

ആൻഡ്രോയിഡ് ഒരു ലിനക്സ് കെർണൽ അധിഷ്ഠിത ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം ആണെന്നറിയാമല്ലോ. ആൻഡ്രോയിഡിനും സ്വന്തമായി ഒരു ഇനിറ്റ് പ്രോഗ്രാം ഉണ്ട്. പരമ്പരാഗത രീതി തന്നെ ആണ് ഈ ഇനിറ്റ് പ്രോഗ്രാമും പിൻതുടരുന്നത്.

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

യൂണിക്സ് സിസ്റ്റങ്ങളിൽ അവയുടെ ഓരോ സമയത്തെ പ്രവർത്തന സ്ഥിതിയെ റൺലെവൽ എന്ന് വിളിക്കുന്നു. ലിനക്സ് സിസ്റ്റങ്ങളിൽ 6 വ്യത്യസ്ത റൺ ലെവലുകൾ ഉണ്ട്. 

റൺലെവൽ 0 - സിസ്റ്റം ഹാൾട്ട് (ഓഫ് ആയിരിക്കുന്ന അവസ്ഥ)

റൺലെവൽ 1 - സിങ്കിൽ യൂസർ മോഡ് (ഒരൊറ്റ ഉപയോക്താവ് മാത്രം. അഡ്മിനിസ്ട്രേറ്റർ യൂസറിന്റെ അനുവാദങ്ങളോടെ ഉള്ള അറ്റകുറ്റപ്പണികൾക്കായി ഉപയോഗിക്കപ്പെടുന്നു)

റൺലെവൽ 2 - നെറ്റ്‌‌വർക്കിങ്ങ് ഇല്ലാത്ത ഒന്നിലധികം ഉപയോക്താക്കളെ പിൻതുണക്കുന്ന അവസ്ഥ.

റൺലെവൽ 3 - നെറ്റ്‌‌വർക്കിങ്ങ് പിൻതുണ അടക്കം ഒന്നിലധികം ഉപയോക്താക്കളെ പിൻതുണക്കുന്ന അവസ്ഥ

റൺലെവൽ 4 - ഉപയോഗത്തിൽ ഇല്ല.

റൺലെവൽ 5 - നെറ്റ്‌‌വർക്കിങ്ങ് പിൻതുണ, ഒന്നിലധികം ഉപയോക്താക്കൾക്കുള്ള പിൻതുണ, ഗ്രാഫിക്കൽ യൂസർ ഇന്റർഫേസ്

റൺലെവൽ 6 - സിസ്റ്റം റീസ്റ്റാർട്ട്

ഇനിറ്റ് കമാന്റ് ഉപയോഗിച്ച് റൺലെവലുകൾ മാറ്റാൻ സാധിക്കും. init 6 എന്ന കമാന്റ് കമ്പ്യൂട്ടർ റീസ്റ്റാർട്ട് ചെയ്യാൻ ഉപയോഗിക്കാം. (ഇതൊരു സുരക്ഷിതമായ മാർഗ്ഗമല്ല).

ലിനക്സിലെ മൾട്ടി യൂസർ പിൻതുണ, ടെർമിനലുകൾ, ഗ്രാഫിക്കൽ ഇന്റർഫേസ് എന്നിവയെപ്പറ്റി അടുത്ത പോസ്റ്റ്.

ലിനക്സ് സിസ്റ്റം സ്റ്റാർട്ടപ്പ് - 2

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

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

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

ഡീ കമ്പ്രസ്സിങ്ങ്, പ്രത്യേക ക്രമീകരണങ്ങൾ എന്നീ ഘട്ടങ്ങൾ ഓരോ ഉപകരണത്തിലും ഓരോ രീതിയിൽ ആണെങ്കിലും ശേഷമുള്ള മൂന്നാം ഭാഗം എല്ലാ ഉപകരണങ്ങളിലും ഒരുപോലെ ആണ്. ഇതിനെ ഹാർഡ്‌വെയർ ഇൻഡിപ്പൻഡന്റ് എന്ന് പറയാം. ഈ ഭാഗത്ത് കെർണൽ ആദ്യം ചെയ്യുന്നത് പ്രോസസ്സുകൾ ആരംഭിക്കാൻ ആവശ്യമായ ക്രമീകരണങ്ങൾ നടത്തുകയാണ്. ഈ ഘട്ടത്തിൽ എത്തുമ്പോൾ കമ്പ്യൂട്ടറിൽ ഒരു പ്രോസസ്സ് മാത്രമേ ഉണ്ടാവുകയുള്ളു. ഇതിന്റെ പി ഐ ഡി 0 ആയിരിക്കും. ഇത് ലിനക്സ് കെർണൽ പ്രോസസ്സ് ആണ്. ഇതിനെ സ്വാപ്പർ (Swapper) എന്നും വിളിക്കാറുണ്ട്. പ്രോസസ്സ് ടേബിൾ, ഷെഡ്യൂളിങ്ങിനാവശ്യമായ വിവരങ്ങൾ എന്നിവ ക്രമീകരിച്ച ശേഷം ലിനക്സ് കെർണൽ ആദ്യത്തെ യൂസർ പ്രോസസ്സ് ആരംഭിക്കുന്നു. ഇതാണ് ഇനിറ്റ് പ്രോസസ്സ്. ഇനിറ്റ് പ്രോസസ്സിന്റെ പി ഐ ഡി 1 ആയിരിക്കും. ഇനിറ്റ് ആരംഭിക്കുന്ന പ്രോസസ്സുകളുടെയും പേരന്റ് പ്രോസസ്സ് പ്രവർത്തനം അവസാനിപ്പിച്ച ചൈൽഡ് പ്രോസസ്സുകളുടെയും പേരന്റ് പ്രോസസ്സ് ഇനിറ്റ് ആണ്. ലിനക്സ് കെർണൽ നേരിട്ട് സൃഷ്ടിക്കുന്ന ഒരു പ്രത്യേക പ്രോസസ്സ് ആണിത്. ഇനിറ്റ് പ്രോസസ്സിന്റെ യൂസർ ഐഡി 0 (റൂട്ട്) ആയിരിക്കും. ഇനിറ്റ് പ്രോസസ്സിന്റെ എക്സിക്യൂട്ടബിൾ സാധാരണയായി /sbin/init ആണ്. മറ്റേതെങ്കിലും എക്സിക്യൂട്ടബിൾ ഇനിറ്റ് ആയി ഉപയോഗിക്കണമെങ്കിൽ ബൂട്ട് ലോഡറിന്റെ കമാന്റ് ലൈൻ ആർഗ്യുമെന്റ് ലിസ്റ്റിൽ init=<ഇനിറ്റ് പ്രോഗ്രാമിന്റെ പാത്ത്> എന്ന് ചേർക്കാവുന്നതാണ്.

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

ഇനിറ്റ് പ്രോസസ്സിനെക്കുറിച്ച് വിശദമായി അടുത്ത പോസ്റ്റ്.

ലിനക്സ് സിസ്റ്റം സ്റ്റാർട്ടപ്പ് - 1

പഴയ പോസ്റ്റുകളിൽ നിന്നും ഫയൽ സിസ്റ്റം, പ്രോസസ്സ് മാനേജ്മെന്റ് എന്നിവയെക്കുറിച്ച് ഒരു ധാരണ ലഭിച്ചിട്ടുണ്ടാകും എന്ന് കരുതുന്നു. ഒരു ലിനക്സ് സിസ്റ്റം പ്രവർത്തനമാരംഭിക്കുന്ന പ്രക്രിയ ആണ് ഈ പോസ്റ്റിൽ വിശദീകരിക്കാൻ ശ്രമിക്കുന്നത്. പ്രധാനമായും ഇന്റൽ x86 പ്രോസസ്സർ അടിസ്ഥാനമാക്കിയുള്ള ഒരു പിസിയിലും ARM പ്രോസസ്സർ അധിഷ്ഠിത സിസ്റ്റത്തിലും എങ്ങനെ ഒരു ലിനക്സ് സിസ്റ്റം ബൂട്ട് ചെയ്യുന്നു എന്ന് നോക്കാം.

സാധാരണ ഇന്റൽ പ്രോസസ്സർ (ഇത് നിർമ്മിക്കുന്നത് ഇന്റൽ തന്നെ ആകണമെന്നില്ല. ഇന്റൽ x86, x86_64 ഒരു ആർക്കിട്ടെക്ചർ ആണ്. എഎംഡി യും ഇതേ ആർക്കിട്ടെക്ചറിൽ പ്രോസസ്സറുകൾ നിർമ്മിക്കുന്നുണ്ട്) അധിഷ്ഠിതമായ പേഴ്സണൽ കമ്പ്യൂട്ടറുകൾ ഒക്കെ ഐബിഎം പിസി മാനദണ്ഡങ്ങൾ പാലിക്കുന്നവ ആണ്. ഇതിൽ ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റത്തിന്റെ ലോഡിങ്ങ്, ബൂട്ടിങ്ങ് ഒക്കെ പ്രതിപാദിച്ചിട്ടുണ്ട്. എന്നാൽ ആം പ്രോസസ്സറുകൾ ഉപയോഗിക്കുന്ന കമ്പ്യൂട്ടറുകൾക്ക് ഇതുപോലെ വ്യക്തമായ ഒരു മാനദണ്ഡം ഒന്നുമില്ല. ഓരോന്നിലും ഓരോ രീതിയിൽ ആയിരിക്കും ബൂട്ടിങ്ങ്. ഈ വ്യത്യാസങ്ങൾ ഒക്കെ ലിനക്സ് കെർണൽ/മറ്റേതെങ്കിലും ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം ലോഡ് ചെയ്യുന്നത് വരെ മാത്രമേ കാണുകയുള്ളു. അതിനാൽ തന്നെ ലിനക്സിന്റെ സ്റ്റാർട്ടപ്പ് എല്ലാ സിസ്റ്റങ്ങളിലും ഒരുപോലെ തന്നെ ആയിരിക്കും.

ഒരു പിസി ഓൺ ചെയ്യുമ്പോൾ ആദ്യമായി പ്രവർത്തിച്ചുതുടങ്ങുക അതിലെ ബയോസ് (BIOS) ആണ്. ബയോസ് ആ കമ്പ്യൂട്ടറിൽ ഘടിപ്പിച്ചിരിക്കുന്ന ഉപകരണങ്ങളെ പ്രവർത്തിപ്പിക്കാൻ ആരംഭിക്കുകയും അവയുടെ പ്രവർത്തനത്തെ സംബന്ധിച്ച ചില അടിസ്ഥാന പരിശോധനകൾ നടത്തുകയും ചെയ്യുന്നു. ഇതിനെ പവർ ഓൺ സെൽഫ് ടെസ്റ്റ് (POST) എന്ന് വിളിക്കുന്നു. പോസ്റ്റിനു ശേഷം ബയോസ് സിസ്റ്റത്തിൽ ഘടിപ്പിച്ചിരിക്കുന്ന ഡിസ്കുകൾ പരിശോധിക്കുന്നു. അവയിലേതെങ്കിലും ഒരു ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റം ഉൾക്കൊള്ളുന്നുണ്ടോ എന്നറിയാനാണ് ഈ പരിശോധന. അങ്ങനെ ഉള്ള ഡിസ്കുകളുടെ മാസ്റ്റർ ബൂട്ട് റെക്കോഡിൽ (MBR) ബൂട്ടബിൾ എന്ന് രേഖപ്പെടുത്തിയിരിക്കും. ഏതൊക്കെ ഡിസ്ക് ഡ്രൈവുകൾ ഏത് ക്രമത്തിൽ പരിശോധിക്കണം എന്ന് ക്രമീകരിക്കാനുള്ള സൗകര്യങ്ങൾ ആധുനിക ബയോസുകൾ എല്ലാം നൽകുന്നുണ്ട്. ബൂട്ടബിൾ ആയ ഡിസ്കുകളുടെ മാസ്റ്റർ ബൂട്ട് റെക്കോഡിൽ അതിലുള്ള ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റത്തെ മെമ്മറിയിലേക്ക് കൊണ്ടുവരാനുള്ള പ്രോഗ്രാം ഉണ്ടായിരിക്കും. കൂടുതൽ വിശദീകരണം ഇവിടെ. ബയോസ് ഈ പ്രോഗ്രാമിനെ ഡിസ്കിൽ നിന്ന് വായിച്ച് കമ്പ്യൂട്ടറിന്റെ റാമിൽ മുൻകൂട്ടി നിശ്ചയിക്കപ്പെട്ട ഒരു മെമ്മറി വിലാസത്തിലേക്ക് പകർത്തുന്നു. അതിനുശേഷം ആ വിലാസത്തിലുള്ള നിർദ്ദേശങ്ങൾ പാലിക്കാൻ പ്രോസസ്സറിനോട് ആവശ്യപ്പെടുന്നു. ഇത്രയുമാണ് ബൂട്ടിങ്ങ് സമയത്തെ ബയോസിന്റെ കടമകൾ. റാമിൽ പകർത്തപ്പെട്ട ഈ പ്രോഗ്രാം ബൂട്ട് ലോഡർ എന്നറിയപ്പെടുന്നു. ഇന്ന് ബൂട്ട് ലോഡറുകൾ പല ഘട്ടങ്ങളായി ആണ് പ്രവർത്തിക്കുക. അതിനാൽ ബയോസ് ലോഡ് ചെയ്യുന്ന ഈ ചെറിയ ഭാഗത്തെ ബൂട്ട് ലോഡറിന്റെ ഒന്നാം ഘട്ടം എന്ന് വിളിക്കാം. ഈ ഒന്നാം ഭാഗത്തിന്റെ ജോലി ഡിസ്കിൽ നിന്ന് അല്പം കൂടി വലിപ്പമുള്ള രണ്ടാം ഘട്ട പ്രോഗ്രാമിനെ റാമിലേക്ക് പകർത്തൽ ആണ്. പിസി മാനദണ്ഡങ്ങൾ അടിസ്ഥാനമാക്കി പ്രവർത്തിക്കുന്ന ബയോസ് ആദ്യഘട്ടത്തിൽ ഡിസ്കിന്റെ എംബിആറിൽ നിന്ന് 512 ബൈറ്റുകൾ മാത്രമേ വായിക്കൂ എന്നതിനാലാണ് ഈ രീതി ആവശ്യമായി വരുന്നത്.

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

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

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

ബൂട്ട് ലോഡർ ലിനക്സ് കെർണലിനെ മെമ്മറിയിൽ ക്രമീകരിച്ചതിനു ശേഷം നിയന്ത്രണം കെർണലിനു കൈമാറുന്നു. ഇവിടെ നിന്ന് സിസ്റ്റത്തിന്റെ പൂർണ്ണ നിയന്ത്രണം കെർണലിനായിരിക്കും. കെർണലിന്റെ സ്റ്റാർട്ടപ്പ് വിശദമായി അടുത്ത ഭാഗത്തിൽ.

ഇന്റര്‍ പ്രോസസ്സ് കമ്യൂണിക്കേഷന്‍ - 2 : പൈപ്പുകള്‍

ഒന്നിലധികം പ്രോസസ്സുകള്‍ക്ക് ഒരു കുഴലിലൂടെ എന്നവണ്ണം വിവരങ്ങള്‍ കൈമാറാന്‍ സാധിക്കുന്ന ഒരുപാധിയാണ് പൈപ്പുകള്‍. ഇവക്ക് രണ്ട് അറ്റങ്ങള്‍ ഉണ്ടാകും. ഒരറ്റത്ത് എഴുതപ്പെടുന്ന വിവരങ്ങള്‍ അടുത്ത അറ്റത്തുനിന്ന് വായിച്ചെടുക്കാം. പൈപ്പുകള്‍ കമാന്റ്‌‌ ലൈന്‍ ഇന്റര്‍ഫേസുകളില്‍ നല്കുന്ന സൗകര്യങ്ങള്‍ ചില്ലറയല്ല. ഒരു കമാന്റിന്റെ ഔട്ട്പുട്ട് മറ്റൊരു കമാന്റിന്റെ ഇന്‍പുട്ടായി നല്‍കാന്‍ സാധിക്കുന്നത് വഴി ഒന്നിലധികം ലളിതമായ കമാന്റുകള്‍ ഉപയോഗിച്ച് ഒരു സങ്കീര്‍ണ്ണമായ ജോലി ചെയ്യാന്‍ സാധിക്കുമല്ലോ.

ഒരു പൈപ്പിന്റെ എഴുതാനുള്ള അറ്റത്ത് എഴുതപ്പെടുന്ന കാര്യങ്ങള്‍ മറ്റേ അറ്റത്തുനിന്ന് വായിക്കപ്പെടുന്നത് വരെ കെര്‍ണല്‍ അതിന്റെ മെമ്മറിയില്‍ സൂക്ഷിച്ചു വയ്ക്കുന്നു. ഇങ്ങനെ സൂക്ഷിക്കപ്പെടാന്‍ സാധിക്കുന്ന വിവരങ്ങളുടെ അളവ് സംബന്ധിച്ച് ചില നിബന്ധനകളോ നിയന്ത്രണങ്ങളോ ഉണ്ടെങ്കിലും വിവിധ സിസ്റ്റങ്ങളില്‍ അവ വ്യത്യസ്തമായിരിക്കും. പോസിക്സ് മാനദണ്ഡമനുസരിച്ച് ഇതിന്റെ വലിപ്പം കുറഞ്ഞത് 512 ബൈറ്റുകള്‍ ആയിരിക്കണം എന്നതാണ്. മെമ്മറിയുടെ ലഭ്യത അനുസരിച്ച് കൂടിയ വലിപ്പം എത്രവേണമെങ്കിലും ആകാം. ലിനക്സില്‍ ഇത് 4096 ബൈറ്റുകള്‍ ആണ്. അതായത് ലിനക്സിലെ ഒരു പൈപ്പിന് സംഭരിക്കാന്‍ സാധിക്കുന്ന ഡാറ്റയുടെ പരമാവധി വലിപ്പം 4096 ബൈറ്റുകള്‍ ആണ്. ഇതില്‍ കൂടുതല്‍ ഡാറ്റ കൈമാറ്റം ചെയ്യേണ്ടത് ആവശ്യമാണെങ്കില്‍ എഴുതുന്ന പ്രോസസ്സിന് തുടര്‍ച്ചയായി എഴുതുന്നതില്‍ നിയന്ത്രണങ്ങള്‍ ഒന്നും ഇല്ല. എന്നാല്‍ പൈപ്പ് ഒരിക്കല്‍ നിറഞ്ഞ് കഴിഞ്ഞാല്‍ മറ്റൊരു പ്രോസസ്സ് അതില്‍ നിന്ന് ഡാറ്റ വായിക്കുന്നത് വരെ ഈ എഴുത്തിന് തുടരാന്‍ സാധിക്കുകയില്ല. വായിക്കേണ്ട അറ്റത്ത് നിന്നും ഒരു പ്രോസസ്സ് ഡാറ്റ വായിച്ചെടുത്ത് കഴിഞ്ഞാല്‍ ആ വായിച്ച അത്ര വിവരങ്ങള്‍ പൈപ്പില്‍ നിന്ന് നീക്കം ചെയ്യപ്പെടുന്നു. കൂടുതല്‍ വിവരങ്ങള്‍ എഴുതാന്‍ പ്രോസസ്സ് കാത്തുനില്‍ക്കുന്നുണ്ടെങ്കില്‍ അതിന് ഈ കാലിലായ സ്ഥലം നിറയുന്നത് വരെ വീണ്ടും എഴുതാവുന്നതാണ്.

പൈപ്പിലേക്ക് വിവരങ്ങള്‍ എഴുതുകയോ പൈപ്പില്‍ നിന്ന് വായിക്കുകയോ ചെയ്യുന്ന സമയത്ത് എഴുതാന്‍ സ്ഥലമില്ലാതെ വരിക/വായിക്കാന്‍ പൈപ്പില്‍ വിവരങ്ങള്‍ ഇല്ലാതെ വരിക എന്ന രണ്ട് സാഹചര്യങ്ങള്‍ ഉണ്ടാകാം. ഈ അവസരങ്ങളില്‍ അതിനായി ശ്രമിക്കുന്ന പ്രോസസ്സ് എങ്ങനെ പെരുമാറും എന്നതിന്റെ അടിസ്ഥാനത്തില്‍ ഇന്‍പുട്ട്/ഔട്ട്പുട്ട് പ്രക്രിയകള്‍ രണ്ട് തരത്തില്‍ ആകാം. (ഇവ ബാക്കി ഫയൽ ഇൻപുട്ട്/ഔട്ട്പുട്ടുകൾക്കും ബാധകമാണ്)

1. ബ്ലോക്കിങ്ങ് ഐഒ: പൈപ്പിലേക്ക്/ഫയലിലേക്ക് എഴുതാനോ അവയിൽ നിന്ന് വായിക്കാനോ ശ്രമിക്കുമ്പോൾ വിവരം/സ്ഥലം ലഭ്യമല്ലെങ്കിൽ കെർണൽ ആ പ്രോസസ്സിനെ താൽക്കാലികമായി സസ്പെൻഡ് ചെയ്യുന്നു. പ്രോസസ്സ് വെയിറ്റ് അവസ്ഥയിലേക്ക് പോകും. വിവരങ്ങൾ ലഭ്യമാകുമ്പോൾ പഴയ നിലയിലേക്ക് തിരിച്ച് വരികയും പ്രവർത്തനം തുടരുകയും ചെയ്യും. ശരിക്കും ഈ അവസ്ഥാ മാറ്റങ്ങളൊക്കെ പ്രോസസ്സിന്റെ അറിവോടെ അല്ല നടക്കുന്നത്.

2. നോൺ ബ്ലോക്കിങ്ങ് ഐഒ: ഈ രീതിയിലാണെങ്കിൽ വിവരങ്ങൾ/സ്ഥലം ലഭ്യമല്ലാതെ വരുമ്പോൾ ആ റൈറ്റ്/റീഡ് പ്രോസസ്സ് താൽക്കാലികമായി ആ പ്രവർത്തനം സാധ്യമല്ല എന്ന എറർ കോഡോടെ അവസാനിപ്പിക്കപ്പെടുന്നു. ഇവിടെ പ്രോസസ്സ് വിവര/സ്ഥല ലഭ്യതക്കായി കാത്തു നിൽക്കുന്നില്ല.

ആദ്യമേ‌ തന്നെ സൂചിപ്പിച്ചതുപോലെ പൈപ്പുകള്‍ രണ്ട് വിധത്തിലുണ്ട്. പേരുള്ളവയും ഇല്ലാത്തവയും. ആദ്യം പേരില്ലാത്ത പൈപ്പുകളെക്കുറിച്ച് വിശദീകരിക്കാം.

പേരില്ലാത്ത പൈപ്പുകള്‍ (Unnamed Pipes)

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

 /* Creating an unnamed pipe */  
 #include <unistd.h>  
 #include <stdio.h>  
   
 int main(void)  
 {  
     int fd[2];  
     pid_t pid;  
   
     char hello[] = "Hello child";  
     char reply[] = "Got it parent..";  
     char buffer[100];  
   
     if (pipe(fd) == -1) {  
         perror("pipe");  
         return;  
     }  
   
     pid = fork();  
     if (pid < 0) {  
         perror("fork");  
         return;  
     }  
   
     if (pid != 0) {  
         printf("\nParent: writing hello to pipe\n");  
         printf("Wrote %d bytes\n",write(fd[1],hello,sizeof(hello)));  
         sleep(2);  
         printf("\nParent: Reading pipe\n");  
         printf("Read %d bytes\n",read(fd[0],buffer,sizeof(buffer)));  
         printf("Data: %s\n\n",buffer);  
         return;  
     } else {  
         sleep(1);  
         printf("\nChild: Reading pipe\n");  
         printf("Read %d bytes\n",read(fd[0],buffer,sizeof(buffer)));  
         printf("Data: %s\n",buffer);  
         printf("\nChild: writing reply to pipe\n");  
         printf("Wrote %d bytes\n",write(fd[1],reply,sizeof(reply)));  
         return;  
     }  
   
     return 0;  
 }  
   

പേരില്ലാത്ത പൈപ്പുകള്‍ സൃഷ്ടിക്കാന്‍ pipe() സിസ്റ്റം  കോളാണ് ഉപയോഗിക്കുന്നത്. ഇതിന്റെ ആര്‍ഗ്യുമെന്റായി നല്‍കുന്നത് രണ്ട് ഫയല്‍ ഡിസ്ക്രിപ്റ്ററുകള്‍ ഉള്ള ഒരു അറേ ആണ്. ഇതില്‍ ഒരെണ്ണം  ആ പൈപ്പിന്റെ റീഡ് എന്‍ഡും  മറ്റേത് റൈറ്റ് എന്‍ഡും  ആണ്. fd[0] പൈപ്പില്‍ നിന്ന് വായിക്കാനും  fd[1] പൈപ്പിലേക്ക് എഴുതാനും  ഉപയോഗിക്കുന്നു. ഒരു ചൈല്‍ഡ് പ്രോസസ്സിന് അതിന്റെ പേരന്റ് പ്രോസസ്സില്‍ തുറക്കപ്പെട്ട എല്ലാ ഫയല്‍ ഡിസ്ക്രിപ്റ്ററുകളും  ലഭ്യമാകും. അതിനാല്‍ പൈപ്പ് സൃഷ്ടിക്കപ്പെടുന്നത് fork നടക്കുന്നതിന്റെ മുന്‍പ് ആയിരിക്കണം. പ്രോഗ്രാമിലെ fork ഉപയോഗത്തെ പറ്റി സംശയമുണ്ടെങ്കില്‍ പ്രോസസ്സ് മാനേജ്മെന്റ് പോസ്റ്റിലെ ഫോര്‍ക്കിന്റെ ഉപയോഗം  പരാമര്‍ശിച്ചിരിക്കുന്ന ലേഖനം  വായിക്കൂ.

പേരുള്ള പൈപ്പുകൾ (Named Pipes) ഈ പൈപ്പുകൾ ഫയൽ സിസ്റ്റത്തിൽ സാധാരണ ഫയലുകളെ പോലെ തന്നെ പ്രവർത്തിക്കുന്നു. അതിനാൽ ഈ ഫയലുകളുടെ പേരറിയുന്ന ഏത് പ്രോസസ്സിനും അതറിയാവുന്ന മറ്റ് പ്രോസസ്സുകളുമായുള്ള ആശയവിനിമയത്തിന് ഈ പൈപ്പ് ഉപയോഗിക്കാം. പേരുള്ള പൈപ്പുകള്‍ സൃഷ്ടിക്കാന്‍ ഉപയോഗിക്കുന്ന സിസ്റ്റം  കോള്‍ mkfifo ആണ്. ഇതിന്റെ ഉപയോഗം  താഴെപ്പറയുന്നത് പോലെ ആണ്,

int mkfifo(const char *pathname, mode_t mode);

ആദ്യത്തെ പരാമീറ്റര്‍ പൈപ്പിന്റെ പാത്ത് ആണ്. ഫയല്‍ സിസ്റ്റത്തിലെ ഏത് പാത്ത് വേണമെങ്കിലും  നല്കാവുന്നതാണ്. ഒരു സാധാരണ ഫയല്‍ നിര്‍മ്മിക്കപ്പെടുമ്പോളുള്ള പരിമിതികള്‍ ഒക്കെ ഇവിടെയും ബാധകമായിരിക്കും. രണ്ടാമത്തെ പരാമീറ്റര്‍ ആ പൈപ്പിന്റെ അനുമതികള്‍ നിര്‍ണ്ണയിക്കുന്നു. (ഫയല്‍ അനുമതികളെക്കുറിച്ചുള്ള പോസ്റ്റ് കാണുക). വിജയകരമായി ഒരു പൈപ്പ് നിര്‍മ്മിക്കപ്പെട്ടാല്‍ ഈ സിസ്റ്റം  കോള്‍ 0 റിട്ടേണ്‍ ചെയ്യുന്നു. വിജയകരമല്ലെങ്കില്‍ -1. ഉദാഹരണത്തിന്

mkfifo("myfifo", 0644);

എന്ന രീതിയില്‍ ഉപയോഗിച്ചാല്‍ അപ്പോളത്തെ വര്‍ക്കിങ്ങ് ഡയറക്ടറിയില്‍ myfifo എന്ന പേരില്‍ ഈ പൈപ്പ് സൃഷ്ടിക്കപ്പെടും. ഉപഭോക്താവിന് വായിക്കാനും  എഴുതാനും  ബാക്കിയുള്ളവര്‍ക്ക് എഴുതാന്‍ മാത്രവും  ഉള്ള അനുമതികളായിരിക്കും  ഇതിന് നല്‍കപ്പെടുക. സൃഷ്ടിക്കപ്പെട്ടതിന് ശേഷം  open, read, write, close സിസ്റ്റം  കോളൂകളുപയോഗിച്ച് മറ്റ് ഫയലുകളെ കൈകാര്യം  ചെയ്യുന്നത് പോലെ തന്നെ ഇവയേയും  കൈകാര്യം  ചെയ്യാവുന്നതാണ്.

ഇന്റര്‍ പ്രോസസ്സ് കമ്യൂണിക്കേഷന്‍ - 1 : സിഗ്നല്‍

സിഗ്നലുകള്‍ ഇന്റര്‍ പ്രോസസ്സ് കമ്മ്യൂണിക്കേഷനില്‍ വളരെ പ്രധാനപ്പെട്ടവയാണെങ്കിലും അവയുടെ സാധ്യതകള്‍ പരിമിതമാണ്. എന്നാല്‍ സിസ്റ്റത്തില്‍ നടക്കുന്ന വിവിധ സംഭവങ്ങളെക്കുറിച്ചുള്ള അറിയിപ്പുകള്‍ വിവിധ പ്രോസസ്സുകള്‍ക്ക് നല്‍കാനും പ്രോസസ്സുകളുടെ പ്രവര്‍ത്തനത്തെ നിയന്ത്രിക്കാനും സിഗ്നലുകള്‍ ഉപയോഗിക്കാന്‍ സാധിക്കും. ഓരോ സിഗ്നലുകള്‍ക്കും ഓരോ അര്‍ഥമാണുള്ളത്. ഈ സിഗ്നലുകളെ തിരിച്ചറിയാന്‍ പോസിക്സ് മാനദണ്ഡത്തില്‍ ഓരോ സംഖ്യകള്‍ അവക്ക് നല്‍കപ്പെട്ടിരിക്കുന്നു. kill സിസ്റ്റം കോള്‍, അല്ലെങ്കില്‍ kill കമാന്റ് തുടങ്ങിയവ വഴി വിവിധ പ്രോസസ്സുകളിലേക്ക് സിഗ്നലുകള്‍ അയക്കാന്‍ സാധിക്കും. പോസിക്സ് നിര്‍വ്വചിച്ചിരിക്കുന്നതില്‍ കൂടുതല്‍ സിഗ്നലുകള്‍ പല സിസ്റ്റങ്ങളിലും ലഭ്യമാണ്. ലഭ്യമായ സിഗ്നലുകളുടെ പട്ടിക കാണുന്നതിന് kill -l എന്ന കമാന്റ് ഉപയോഗിക്കാവുന്നതാണ്.

സിസ്റ്റത്തിലെ ഓരോ പ്രോസസ്സിനും കെര്‍ണലിന്റെ പ്രോസസ്സ് ടേബിളില്‍ ഒരു എന്‍ട്രി ഉണ്ടായിരിക്കും എന്ന് പറഞ്ഞിരുന്നല്ലോ. ഓരോ പ്രോസസ്സിലേക്കും അയക്കപ്പെടുന്ന സിഗ്നലുകള്‍ ഇതില്‍ രേഖപ്പെടുത്തിയിരിക്കുന്നു. ഒരു പ്രോസസ്സിന്റെ പ്രോസസ്സ് ടേബിള്‍ എന്‍ട്രിയില്‍ ഒരു സിഗ്നലിനെ സൂചിപ്പിക്കാന്‍ ഒരു ബിറ്റ് എന്ന കണക്കിലാണ് മെമ്മറി അനുവദിച്ചിരിക്കുക. അതിനാല്‍ത്തന്നെ ഒരേ സിഗ്നല്‍ എത്ര തവണ ഒരു പ്രോസസ്സിലേക്ക് അയക്കപ്പെട്ടു എന്ന് അറീയാന്‍ സാധ്യമല്ല. എന്നാല്‍ ആ പ്രോസസ്സിലേക്ക് ഏതൊക്കെ സിഗ്നല്‍ അയക്കപ്പെട്ടിട്ടുണ്ട് എന്നറിയാന്‍ സാധിക്കും.

ഒരു പ്രോസസ്സ് ഒരു സിഗ്നല്‍ സ്വീകരിച്ച് കഴിഞ്ഞാല്‍ ആ സിഗ്നലിനോട് മൂന്നുതരത്തിലുള്ള പ്രതികരണങ്ങളാണ് സാധ്യമാകുക. ആ സിഗ്നല്‍ കണ്ടില്ലെന്ന് നടിക്കുക (Ignore), ആ സിഗ്നലിനെ കൈകാര്യം ചെയ്യുക (Handle), പ്രോസസ്സ് അവസാനിപ്പിക്കുക (Terminate) എന്നിവയാണ് അവ. എല്ലാ സിഗ്നലുകളെയും കണ്ടില്ലെന്ന് നടിക്കാന്‍ സാധിക്കുകയില്ല. എല്ലാ സിഗ്നലുകളെയും കൈകാര്യം ചെയ്യാനും സാധിക്കില്ല. ഒരു സിഗ്നലിനോട് നാമെഴുതുന്ന ഒരു പ്രോഗ്രാം എങ്ങനെ പ്രതികരിക്കണമെന്ന് നാം പരാമര്‍ശിക്കുന്നില്ലെങ്കില്‍ കെര്‍ണല്‍ മുന്‍കൂട്ടി നിശ്ചയിച്ചിരിക്കുന്ന രീതിയിലുള്ള ഒരു നടപടി എടുക്കുന്നു. ഓരോ സിഗ്നലുകള്‍ക്കും ഈ നടപടി വ്യത്യസ്തമായിരിക്കും. ഒരു സിഗ്നലിലെ നമ്മുടെ പ്രോഗ്രാമില്‍ കൈകാര്യം ചെയ്യുന്നതിനായി ഒരു സിഗ്നല്‍ ഹാന്‍ഡ്‌‌ലര്‍ ഫങ്‌‌ഷന്‍ എഴുതുകയും അതിനെ ആ സിഗ്നലുമായി ബന്ധിപ്പിക്കുകയും ചെയ്യണം. നമ്മുടെ പ്രോഗ്രാം  പിന്നീട് ആ സിഗ്നല്‍ സ്വീകരിക്കുകയാണെങ്കില്‍ ബന്ധപ്പെട്ട ഫങ്ഷന്‍ പ്രവര്‍ത്തിക്കുന്നതായിരിക്കും. എന്നാല്‍ ഇക്കാര്യങ്ങളൊന്നും തന്നെ നാമെഴുതുന്ന പ്രോഗ്രാമിന്റെ നിയന്ത്രണത്തില്‍ വരുന്ന കാര്യങ്ങളല്ല. ഇതൊക്കെ ചെയ്യുന്നത് കെര്‍ണല്‍ നേരിട്ടാണ്. നമ്മുടെ പ്രോസസ്സിന്റെ യു-ഏരിയയില്‍ ആണ് അത് ഓരോ സിഗ്നലിനോടും  എങ്ങനെ പ്രതികരിക്കുന്നു എന്നും സിഗ്നലുകള്‍ കൈകാര്യം ചെയ്യാനുള്ള ഫങ്ങ്ഷനുകള്‍ ഉണ്ടെങ്കില്‍ അവയുടെ വിലാസം രേഖപ്പെടുത്തിയിരിക്കുന്നതും.

ഒരു പ്രോസസ്സിന് അത് ഏതവസ്ഥയില്‍ ആയിരിക്കുമ്പോളും സിഗ്നലുകള്‍ സ്വീകരിക്കാന്‍ സാധിക്കും. എന്നാല്‍ ആ സിഗ്നല്‍ കൈകാര്യം ചെയ്യപ്പെടുന്നത് ആ പ്രോസസ്സിന്റെ അവസ്ഥയില്‍ മാറ്റങ്ങള്‍ വരുമ്പോളാണ്.

• ഒരു പ്രോസസ്സിന്റെ പ്രവര്‍ത്തനം കെര്‍ണല്‍ സ്പേസില്‍ നിന്ന് യൂസര്‍ സ്പേസിലേക്ക് മാറുക 
• സ്ലീപ്പ് അവസ്ഥയില്‍ നിന്ന് പ്രോസസ്സ് പ്രവര്‍ത്തിക്കുന്ന അവസ്ഥയിലേക്ക് വരിക 
• പ്രോസസ്സ് ഷെഡ്യൂള്‍ ചെയ്യപ്പെടുക

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

ഇതില്‍നിന്ന് മനസ്സിലാക്കാനുള്ള കാര്യം സിഗ്നലുകള്‍ സ്വീകരിക്കുകയോ അവയെ കൈകാര്യം ചെയ്യുകയോ ചെയ്യുന്നത് ഒരു പ്രോസസ്സിന്റെ അധികാര പരിധിയില്‍ ഉള്ള കാര്യമല്ല. അവ നടക്കുന്നത് ആ പ്രോസസ്സ് അറിയുകയും ഇല്ല. ഒരു പ്രോസസ്സ് ഫോര്‍ക്ക് ഉപയോഗിച്ച് അതിന്റെ ചൈല്‍ഡ് പ്രോസസ്സിനെ സൃഷ്ടിക്കുമ്പോള്‍ അത് രെജിസ്റ്റര്‍ ചെയ്തിരുന്ന ഹാന്‍ഡ്‌‌ലര്‍ ഫങ്ങ്ഷനുകള്‍ ഒക്കെ ചൈല്‍ഡ് പ്രോസസ്സിലും അതേ നിലയില്‍ തുടരും. എന്നാല്‍ ചൈല്‍ഡ് പ്രോസസ്സ് സൃഷ്ടിക്കപ്പെടുന്നതിനു മുന്‍പ് പേരന്റ് പ്രോസസ്സ് സ്വീകരിച്ചതും കൈകാര്യം ചെയ്യപ്പെട്ടിട്ടില്ലാത്തതുമായ സിഗ്നലുകള്‍ ഒന്നും ചൈല്‍ഡ് പ്രോസസ്സിന് ബാധകമാകില്ല.

ഒരു പ്രോസസ്സിന് വേറൊരു പ്രോസസ്സിലേക്ക് സിഗ്നല്‍ അയക്കാന്‍ kill() സിസ്റ്റം കോള്‍ ഉപയോഗിക്കാമെന്ന് പറഞ്ഞു. അതേ പ്രോസസ്സിലേക്ക് തന്നെ സിഗ്നല്‍ അയക്കാന്‍ (സ്വയം) ഒരു പ്രോസസ്സിന് raise() എന്ന ഫങ്ങ്ഷന്‍ ഉപയോഗിക്കാവുന്നതാണ്. ഇതല്ലാതെ പ്രത്യേക സാഹചര്യങ്ങളില്‍ പ്രോസസ്സുകള്‍ സിഗ്നലുകള്‍ സ്വീകരിക്കാറുണ്ട്. ഉദാഹരണത്തിന് കമാന്റ് ലൈനില്‍ പ്രവര്‍ത്തിച്ചുകൊണ്ടിരിക്കുന്ന ഒരു പ്രോസസ്സിലേക്ക് ഉപയോക്താവ് കണ്ട്രോള്‍ + സി എന്ന കീബോര്‍ഡ് കോമ്പിനേഷന്‍ ഉപയോഗിക്കുമ്പോള്‍ SIGINT എന്ന സിഗ്നല്‍ അയക്കപ്പെടുന്നു. പ്രോസസ്സ് അതിന്റെ അഡ്രസ്സ് സ്പേസിനു പുറത്തുള്ള ഒരു അഡ്രസ്സിലെ വിവരങ്ങള്‍ വായിക്കാനോ എഴുതാനോ ശ്രമിക്കുമ്പോള്‍ SIGSEGV എന്ന സിഗ്നല്‍, പ്രോസസ്സില്‍ ഒരു സംഖ്യയെ പൂജ്യം കൊണ്ട് ഹരിക്കാന്‍ ശ്രമിച്ചാല്‍ SIGFPE, ഒരു പ്രോസസ്സിന്റെ ചൈല്‍ഡ് പ്രോസസ്സ് പ്രവര്‍ത്തനം  അവസാനിപ്പിച്ചാല്‍ SIGCHILD എന്നിങ്ങനെ. ഇത് കൂടാതെ പോസിക്സ് ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റത്തില്‍ ആപ്ലിക്കേഷന്‍ പ്രോഗ്രാമുകള്‍ക്ക് ലഭ്യമായ ടൈമര്‍/കൗണ്ടര്‍ സര്‍വ്വീസുകള്‍ ഒക്കെ സിഗ്നലുകള്‍ ഉപയോഗപ്പെടുത്തിയാണ് പ്രവര്‍ത്തിക്കുന്നത്.

പോസിക്സില്‍ നിര്‍വ്വചിക്കപ്പെട്ടിരിക്കുന്ന സിഗ്നലുകളുടെ വിശദാംശങ്ങള്‍ ഈ വിക്കിപീഡിയ ലേഖനത്തില്‍ കാണാം. പ്രോസസ്സിലെ സിഗ്നല്‍ ഹാന്‍ഡ്ലിങ്ങിന്റെ വിശദാംശത്തിനും ഓരോ സിഗ്നലും എങ്ങനെ പെരുമാറുന്നു എന്നുമുള്ള വിശദാംശങ്ങള്‍ക്കായി man 7 signal എന്ന് ടെര്‍മിനലില്‍ ടൈപ്പ് ചെയ്ത് നോക്കുക.

കമാന്റ് ലൈനില്‍ നിന്നയക്കപ്പെടുന്ന SIGINT എങ്ങനെ കൈകാര്യം ചെയ്യാം എന്നൊരു ഉദാഹരണം നോക്കാം

 #include <stdio.h>  
 #include <signal.h>  
 #include <unistd.h>  
   
 volatile sig_atomic_t terminated = 0;  
   
 void sigint_handler(int signum)  
 {  
     printf("\nSignal %d received..\n", signum);  
     terminated = 1;  
 }  
   
 int main(void)  
 {  
     unsigned long counter = 0;  
   
     signal(SIGINT, sigint_handler);  
   
     printf("Entering an infinit loop..\n");  
   
     while (!terminated) {  
         counter++;  
         sleep(1);  
         printf("\r%ld seconds without signal..", counter);  
         fflush(stdout);  
     }  
   
     printf("\nLoop terminated\n");  
   
     return 0;  
 }

ഇവിടെ SIGINT എന്ന സിഗ്നല്‍ ഹാന്‍ഡില്‍ ചെയ്യാന്‍ sigint_handler എന്ന ഫങ്ങ്ഷനെ രെജിസ്റ്റര്‍ ചെയ്യുകയാണ് signal ഫങ്ങ്ഷന്‍ ഉപയോഗിച്ച് ചെയ്യുന്നത്. terminated എന്ന വേരിയബിളിന്റെ മൂല്യം പൂജ്യമല്ലാതാകുന്നത് വരെ മെയിന്‍ ഫങ്ങ്ഷനിനെ while ലൂപ്പ് പ്രവര്‍ത്തിച്ച് കൊണ്ടിരിക്കുന്നു. ഇവിടെ terminated എന്ന വേരിയബിളിന്റെ ഡാറ്റ ടൈപ്പ് ശ്രദ്ധിക്കുക. volatile sig_atomic_t എന്ന പ്രത്യേക ഡാറ്റാ ടൈപ്പ് ആണ് ഉപയോഗിച്ചിരിക്കുന്നത്. ഇതിലെ volatile എന്ന് കീവേര്‍ഡ് ആ ചരത്തിന് ചില പ്രത്യേകതകള്‍ നല്‍കുന്നതാണ്. ആ ചരത്തിന്റെ മൂല്യം പ്രോഗ്രാമില്‍ എവിടെ വേണമെങ്കിലും മാറ്റം വരാവുന്നതാണെന്നും അതിനാല്‍ തന്നെ ഒരു രീതിയിലുള്ള ഓപ്‌‌റ്റിമൈസേഷനും ആ വേരിയബിളിന്റെ മേല്‍ നടത്തരുതെന്നും ആ വേരിയബിള്‍ ആവശ്യമാകുമ്പോളൊക്കെ അതിനെ പ്രത്യേകം വായിക്കണം എന്നും സി കമ്പൈലറിനോട് പറയുന്നതാണത്. സിഗ്നലുകള്‍ റേസ് കണ്ടീഷന്‍സ് എന്ന പ്രശ്നത്തില്‍ നിന്ന് മുക്തമല്ലെന്ന് മാത്രമല്ല ആ പ്രശ്നത്തിന്റെ കാഠിന്യം നന്നായി അനുഭവിക്കുന്നവയും ആണ്. സ്വീകരിക്കപ്പെട്ട ഒരു സിഗ്നല്‍ കൈകാര്യം ചെയ്യപ്പെടുന്ന അവസരത്തില്‍ മറ്റൊരു സിഗ്നല്‍ സ്വീകരിക്കപ്പെട്ടാല്‍ സംഭവിക്കാവുന്ന പല പ്രശ്നങ്ങളും ഉണ്ട്. ഉദാഹരണത്തിന് ഒരു സിഗ്നല്‍ എത്ര തവണ പ്രോഗ്രാം കൈകാര്യം ചെയ്തു എന്നറിയാന്‍ ഒരു കൗണ്ടര്‍ ഉപയോഗിക്കുന്നു എന്ന് കരുതുക. ഓരോ കൈകാര്യം ചെയ്യലിലും അതിന്റെ മൂല്യം ഒന്ന് വീതം വര്‍ദ്ധിക്കുകയും ഒരു പ്രത്യേക മൂല്യം എത്തുമ്പോള്‍ ഒരു കാര്യം ചെയ്യേണ്ടതും ആണെന്ന് കരുതൂ. അതായത് ആ കൗണ്ടറിന്റെ മൂല്യം നാലിന്റെ ഗുണിതങ്ങളാകുമ്പോള്‍ ഒരു സന്ദേശം ഉപയോക്താവിനെ കാണിക്കണം. കൗണ്ടറിലെ മൂല്യം 3 ആയിരിക്കുമ്പോള്‍ പ്രോഗ്രാം സിഗ്നല്‍ സ്വീകരിക്കുകയും അതിന്റെ മൂല്യം 4 ആക്കുകയും ചെയ്തു എന്ന് കരുതുക. അതിന്റെ മൂല്യം നാലിന്റെ ഗുണിതമാണോ എന്ന് പരിശോധിക്കാനുള്ള നിര്‍ദ്ദേശത്തിന്റെ തൊട്ട് മുന്‍പേ കെര്‍ണല്‍ ഷെഡ്യൂളിങ്ങ് നടത്തുകയാണെങ്കില്‍ ആ പ്രോസസ്സ് താല്‍ക്കാലികമായി പ്രവര്‍ത്തനം നിര്‍ത്തും. വീണ്ടും പ്രവര്‍ത്തനം തുടങ്ങുന്നതിനു മുന്‍പേ ഒരിക്കല്‍ കൂടി ആ സിഗ്നല്‍ സ്വീകരിക്കപ്പെട്ടാല്‍ വീണ്ടും ആ നിര്‍ദ്ദേശത്തിലെത്തുമ്പോള്‍ ആ കൗണ്ടറിന്റെ മൂല്യം 5 ആയിട്ടുണ്ടാകും. ഷെഡ്യൂളിങ്ങ് നടന്നില്ലെങ്കില്‍ പോലും മൂല്യം വര്‍ദ്ധിപ്പിക്കുന്ന നിര്‍ദ്ദേശം പ്രവര്‍ത്തിക്കുമ്പോള്‍ അടുത്ത സിഗ്നല്‍ വന്നാലും ഈ പ്രശ്നം ഉണ്ടാകാം. sig_atomic_t ആ ചരത്തിന്റെ ഉപയോഗത്തെ ഒരു ആറ്റോമിക് ഓപ്പറേഷന്‍ ആയി നടത്തണം എന്ന് ജിസിസി കമ്പൈലറിനോട് ആവശ്യപ്പെടും. ഒരു പരിധി വരെ പ്രശ്നങ്ങള്‍ ഇതുവഴി പരിഹരിക്കാം. 

ഇനി SIGINT എന്ന സിഗ്നലിനെ കണ്ടില്ലെന്ന് നടിക്കുന്നതെങ്ങനെ എന്ന് നോക്കാം

 #include <stdio.h>  
 #include <signal.h>  
 #include <unistd.h>  
   
 volatile sig_atomic_t terminated = 0;  
   
 int main(void)  
 {  
     unsigned long counter = 0;  
   
     signal(SIGINT, SIG_IGN);  
   
     printf("Entering an infinit loop..\n");  
   
     while (!terminated) {  
         counter++;  
         sleep(1);  
         printf("\r%ld seconds without signal..", counter);  
         fflush(stdout);  
     }  
   
     printf("\nLoop terminated\n");  
   
     return 0;  
 }  

ഇവിടെ SIG_IGN എന്നതാണ് signal ഫങ്ങ്ഷന്റെ രണ്ടാമത്തെ ആര്‍ഗ്യുമെന്റ്. പരാമര്‍ശിക്കപ്പെട്ട സിഗ്നലിനെ ഇഗ്നോര്‍ ചെയ്യുക എന്നതാണ് ഇതിന്റെ അര്‍ഥം. ഈ പ്രോഗ്രാം പ്രവര്‍ത്തിക്കുമ്പോള്‍ CTRL+C അമര്‍ത്തിയാല്‍ ഒന്നും സംഭവിക്കില്ലെന്ന് കാണാം. എന്നാല്‍ ആദ്യത്തെ പ്രോഗ്രാം അതോടെ ലൂപ്പില്‍ നിന്ന് പുറത്ത് വരുമായിരുന്നു. ഇനി ഈ പ്രോഗ്രാമിന്റെ പ്രവര്‍ത്തനം അവസാനിപ്പിക്കാന്‍ ഒരു പുതിയ ടെര്‍മിനല്‍ തുറന്ന് ps -e കമാന്റ് ഉപയോഗിച്ച് അതിന്റെ പിഐഡി കണ്ടുപിടിക്കുക. അതിന് ശേഷം kill -9 <pid> ഉപയോഗിച്ച് SIGKILL എന്ന സിഗ്നല്‍ അതിലേക്ക് അയക്കാം. അപ്പോള്‍ ആ പ്രോസസ്സ് killed എന്ന് ടെര്‍മിനലില്‍ കാണിക്കും. SIGKILL സിഗ്നലിന്റെ സംഖ്യ 9 ആണ്. kill -l വഴി വിവിധ സിഗ്നലുകളുടെ സംഖ്യകള്‍ കണ്ട് പിടിച്ച് 9 നു പകരം ഉപയോഗിച്ച് എന്ത് സംഭവിക്കുന്നു എന്ന് നോക്കൂ.. 

പോസിക്സ് സിഗ്നലുകളെ വികസിപ്പിച്ചാണ് ജിറ്റികെ പോലെയുള്ള യുഐ ലൈബ്രറികള്‍ ഈവന്റ് മെക്കാനിസം പ്രായോഗികമാക്കിയതെന്ന് പറയപ്പെടുന്നു..

ഇന്റര്‍ പ്രോസസ്സ് കമ്യൂണിക്കേഷന്‍

എല്ലാ മള്‍ട്ടി പ്രോസസ്സ് ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റങ്ങളിലും ഒന്നിലധികം പ്രോസസ്സുകള്‍ ഒരേ സമയത്ത് പ്രവര്‍ത്തിക്കുന്നുണ്ടാകും. ചില അവസരങ്ങളില്‍ ഈ പ്രോസസ്സുകള്‍ക്ക് പരസ്പരം വിവരങ്ങള്‍ കൈമാറേണ്ട ആവശ്യം വരും. ഇങ്ങനെയുള്ള വിവര കൈമാറ്റങ്ങളെ ഇന്റര്‍ പ്രോസസ്സ് കമ്യൂണിക്കേഷന്‍ എന്ന് പറയുന്നു. ഇതിന് വിവിധ മാര്‍ഗ്ഗങ്ങള്‍ ഉണ്ട്. യൂണിക്സ് ഓപ്പറേറ്റിങ്ങ് സിസ്റ്റത്തിന്റെ ആദ്യകാല കമേര്‍ഷ്യല്‍ പതിപ്പുകളില്‍ ഒന്നായ സിസ്റ്റം വി (System V - വായിക്കുന്നത് സിസ്റ്റം ഫൈവ്) ആണ് ഇക്കാര്യത്തില്‍ അടിസ്ഥാന മാനദണ്ഡമായി പരിഗണിക്കപ്പെടുന്നവയില്‍ ഒന്ന്. SysV യില്‍ ഉണ്ടായിരുന്ന ഐ പി സി മെക്കാനിസങ്ങളെ SysV IPC Mechanisms എന്ന് വിളിക്കുന്നു. അതില്‍ ഉണ്ടായിരുന്നതിലധികം  സംവിധാനങ്ങള്‍ ഇന്ന് ലിനക്സിലടക്കം ഉണ്ട്.

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

1. പൈപ്പുകള്‍ (pipe)
1. പേരുള്ളവ (named pipes)
2. പേരില്ലാത്തവ (unnamed pipes)
2. സോക്കറ്റുകള്‍ (socket)
3. സിഗ്നലുകള്‍ (signal)
4. മെസ്സേജ് ക്യൂ (message queue)
5. ഷെയേര്‍ഡ് മെമ്മറി (shared memory)
6. സെമാഫോറുകള്‍ (semaphore)

പൈപ്പുകള്‍

വെള്ളവും മറ്റും  കൊണ്ടുപോകുന്ന പൈപ്പുകള്‍ പോലെ തന്നെയാണ് ഇവയുടെ പ്രവര്‍ത്തനം. ഇവക്ക് രണ്ട് അഗ്രങ്ങള്‍ ഉണ്ടായിരിക്കും. ഒരു വശത്തുകൂടി പോകുന്ന വിവരങ്ങള്‍ മറുവശത്ത് ലഭ്യമാകുന്നു. പേരുള്ള പൈപ്പുകള്‍ ആ പേര് അറിയാവുന്ന പ്രോസസ്സുകള്‍ക്ക് എല്ലാം  ഉപയോഗിക്കാം. എന്നാല്‍ പേരില്ലാത്തവ അതിനെ നിര്‍മ്മിച്ച പ്രോസസ്സിനും അതിന്റെ ചൈല്‍ഡ് പ്രോസസ്സുകള്‍ക്കും  മാത്രമേ ലഭ്യമാവുകയുള്ളു.

സോക്കറ്റുകള്‍

ബിഎസ്‌‌ഡി യൂണിക്സില്‍ ആണ് സോക്കറ്റുകള്‍ ആദ്യമായി വന്നത്. ഇവയൂടെ ഉപയോഗം  കമ്പ്യൂട്ടറുകള്‍ തമ്മില്‍ നെറ്റ്‌‌വര്‍ക്ക് ചെയ്യുന്നതില്‍ ആണ്. ഒരു സോക്കറ്റിനെ വിവിധ വയറുകള്‍ ഘടിപ്പിച്ച് വയ്ക്കാവുന്ന ഒരു പ്ലഗ്ഗുമായി താരതമ്യം ചെയ്യാം. ഒരേ കമ്പ്യൂട്ടറിലെ വിവിധ പ്രോഗ്രാമുകള്‍ക്ക് പരസ്പരം സംവദിക്കാന്‍ സോക്കറ്റുകള്‍ ഉപയോഗിക്കാവുന്നതാണ്. എന്നാല്‍ ഇതിന് കെര്‍ണലിലെ നെറ്റ്‌‌വര്‍ക്കിങ്ങ് ഭാഗത്തിന്റെ പിന്‍തുണ ആവശ്യമാണ്.

സിഗ്നലുകള്‍

സിഗ്നലുകള്‍ വഴി പ്രോസസ്സുകള്‍ക്ക് പരസ്പരം വിവരങ്ങള്‍കൈമാറാന്‍ സാധിക്കുകയില്ല. എന്നാല്‍ വിവിധ സാഹചര്യങ്ങളെക്കുറിച്ച് മറ്റ് പ്രോസസ്സുകള്‍ക്ക് അറിയിപ്പ് കൊടുക്കാന്‍ സിഗ്നലുകള്‍ വഴി സാധിക്കും. ഒരു പ്രോഗ്രാമിന്റെ വിവിധ അവസ്ഥകളെക്കുറിച്ച് ആ പ്രോഗ്രാമിനെ അറിയിക്കാന്‍ കെര്‍ണലിനും സിഗ്നലുകള്‍ വഴി സാധിക്കും.

മെസ്സേജ് ക്യൂ
അധികം വലിപ്പമില്ലാത്ത വിവരങ്ങള്‍ പ്രോസസ്സുകള്‍ക്ക് പരസ്പരം കൈമാറ്റം ചെയ്യാന്‍ മെസ്സേജ് ക്യൂ വഴി സാധിക്കും. പ്രോസസ്സുകള്‍ ക്യൂവിലേക്ക് മെസ്സേജുകള്‍ അയക്കുകയും ക്യൂവില്‍ നിന്ന് മെസ്സേജുകള്‍ സ്വീകരിക്കുകയും ചെയ്യും.

ഷെയേര്‍ഡ് മെമ്മറി
പ്രധാന മെമ്മറിയിലെ ഒരു ഭാഗം ഒന്നോ അതിലധികമോ പ്രോസസ്സുകള്‍ പങ്കിട്ട് ഉപയോഗിക്കുന്ന രീതിയിലാണ് ഇതിന്റെ രൂപകല്‍പ്പന. ഇത് വിവരങ്ങള്‍ പരസ്പരം കൈമാറാന്‍ ഏറ്റവും വേഗതയുള്ള രീതിയാണ്.

സെമാഫോറുകള്‍
ഒരു പൊതുവായ വിഭവം വിവിധ പ്രോസസ്സുകള്‍ക്ക് ഒരേ സമയം ഉപയോഗിക്കേണ്ട അവസ്ഥയുണ്ടായാല്‍ ഒന്നിനു പുറകെ ഒന്നായി അവയ്ക്ക് ആ വിഭവത്തെ ഉപയോഗിക്കാനുള്ള അവസരം കൊടുക്കുന്നതിനുവേണ്ടിയുള്ള ഒരു സംവിധാനമാണിത്. ഉപയോഗിക്കേണ്ടിവരുന്ന ഒരു വിഭവത്തെ മറ്റൊരു പ്രോസസ്സ് ഉപയോഗിക്കുന്നുണ്ടോ എന്ന് പരിശോധിക്കാനും പ്രോസസ്സുകള്‍ക്ക് ഇവ ഉപയോഗിക്കാം. ബൈനറി സെമാഫോര്‍, കൗണ്ടിങ്ങ് സെമാഫോര്‍ എന്ന് രണ്ട്‌ തരത്തിലുള്ള സെമാഫോറുകള്‍ ഉണ്ട്.

ലിനക്സ് അധിഷ്ഠിത സിസ്റ്റങ്ങള്‍ ഉപയോഗിക്കുന്നവര്‍ക്ക്  ipcs കമാന്റ് ഉപയോഗിച്ച് സിസ്റ്റത്തില്‍ വിവിധ പ്രോസസ്സുകള്‍ ഉപയോഗിച്ചുകൊണ്ടിരിക്കുന്ന ഐ പി സി മെക്കാനിസങ്ങളെക്കുറിച്ചുള്ള വിവരങ്ങള്‍ കാണാന്‍ സാധിക്കും. ഈ കമാന്റിന്റെ കൂടുതല്‍ വിവരങ്ങള്‍ക്ക് man ipcs ഉപയോഗിക്കുക.

മുകളില്‍ പരാമര്‍ശിച്ച ഐപിസി മെക്കാനിസങ്ങളില്‍ മെസ്സേജ് ക്യൂ, ഷെയേര്‍ഡ് മെമ്മറി, സെമാഫോറുകള്‍ എന്നിവ സിസ്റ്റം വി ഐപിസി മെക്കാനിസങ്ങളാണ്. സിഗ്നലുകള്‍, പൈപ്പുകള്‍ എന്നിവ പോസിക്സും സോക്കറ്റുകള്‍ ബിഎസ്ഡി സ്റ്റാന്‍ഡേര്‍ഡും ആണ്. ലിനക്സ് പിന്‍തുടരുന്നത് പോസിക്സ് മാനദണ്ഡമാണ്. സിസ്റ്റം വി ഐപിസി മെക്കാനിസങ്ങളെ പൂര്‍ണ്ണമായും പോസിക്സ് നിര്‍വ്വചിക്കുന്നില്ലെങ്കിലും ഇവയെല്ലാം ലിനക്സില്‍ ലഭ്യമാണ്. ഇതില്‍ സോക്കറ്റുകള്‍ വളരെ വിശാലമായ ഒരു വിഷയമായതിനാല്‍ അവയെ മാത്രമായി മറ്റൊരു വിഭാഗത്തില്‍ പരിചയപ്പെടാം.