ഉബുണ്ടു ലിനക്സ് സിസ്റ്റത്തിന്റെ ആഴത്തിലുള്ള സ്ഥിതിവിവരക്കണക്കുകൾ - നമ്മൾ ഇത് കാണുന്നുണ്ടോ?

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

ഈ ലേഖനം നിങ്ങളെ Ubuntu OS ന്റെ ആന്തരികതകളിലേക്ക് അൽപ്പം ആഴത്തിൽ കൊണ്ടുപോകും, അത് വളരെ രസകരവും ഒരു തുടക്കക്കാരനെ അതിന്റെ പ്രവർത്തനത്തെക്കുറിച്ച് പൂർണ്ണമായി മനസ്സിലാക്കാൻ സഹായിക്കും.

സിസ്റ്റത്തിന്റെ താഴെയിടുക

ലിനക്സിന് അതിന്റെ പ്രവർത്തനത്തിന് ഒരു പ്രോസസ് ഉണ്ട്, പവർ മാനേജ്മെന്റ്, ബൂട്ട് അപ്പ്, സിസ്റ്റം ക്രാഷ് ഹാൻഡ്ലിംഗ് എന്നിവയുൾപ്പെടെ ഓരോ സിസ്റ്റം സേവനവും \/etc/init എന്നതിൽ ഇവന്റ് വിവരിക്കുന്ന ഒരു കോൺഫിഗറേഷൻ ഫയലുള്ള ഒരു പ്രക്രിയയാണ്. അത് എക്സിക്യൂട്ട് ചെയ്യുന്നതും അതിന്റെ നിർവ്വഹണം നിർത്തുന്നതുമായ അനുബന്ധ സംഭവങ്ങൾ, അതോടൊപ്പം സിസ്റ്റത്തിന്റെ \/etc/ ഡയറക്uടറിയിൽ അതിന്റെ റൺ-ടൈം സ്വഭാവം വിവരിക്കുന്ന മറ്റ് കോൺഫിഗറേഷൻ ഫയലുകളും ഇത് പരിപാലിക്കുന്നു. സിസ്റ്റത്തെ ഇവന്റ് പ്രേരിതമാക്കുന്നു.

ഇവന്റുകൾ ജനറേറ്റുചെയ്യുകയാണെങ്കിൽ, അവരെ പിടികൂടാനും അവ നടപ്പിലാക്കാനും ആരെങ്കിലും ഉണ്ടായിരിക്കണമോ ?? വ്യക്തമായും, പ്രോസസ് ഐഡി 1 അതായത് init ഉള്ള എല്ലാ പ്രക്രിയകളുടെയും രക്ഷിതാവായി നിലനിൽക്കുന്ന ഞങ്ങളുടെ പ്രധാന പ്രക്രിയയാണ് കൺട്രോളർ. സിസ്റ്റം സ്റ്റാർട്ടപ്പ് മുതൽ ആരംഭിക്കുന്ന പ്രക്രിയയാണിത്, ഒരിക്കലും നിർത്തുന്നില്ല. init-ന്റെ പാരന്റ് ആരെന്ന പ്രക്രിയ ഇല്ലാത്തതിനാൽ സിസ്റ്റം പവർ ഡൗണായാൽ മാത്രമേ ഈ പ്രക്രിയ മരിക്കുകയുള്ളൂ.

6.10-ന് മുമ്പുള്ള Ubuntu-ന്റെ മുൻ പതിപ്പുകളിൽ \/etc/rcx.d< എന്നതിൽ സ്ക്രിപ്റ്റുകൾ പ്രവർത്തിപ്പിക്കാൻ ഉപയോഗിച്ചിരുന്ന പഴയ ശൈലി sysvinit ഉൾപ്പെടുന്നു.” സിസ്റ്റത്തിന്റെ എല്ലാ സ്റ്റാർട്ടപ്പിലും ഷട്ട്uഡൗണിലും ഡയറക്uടറി. പക്ഷേ, അതിനു ശേഷം upstart സിസ്റ്റം പഴയ രീതിയിലുള്ള sysvinit സിസ്റ്റം മാറ്റി, പക്ഷേ ഇപ്പോഴും അതിന് ബാക്ക്uവേർഡ് കോംപാറ്റിബിളിറ്റി നൽകുന്നു.

ഏറ്റവും പുതിയ ഉബുണ്ടു പതിപ്പുകൾക്ക് ഈ അപ്uസ്റ്റാർട്ട് സിസ്റ്റം ഉണ്ട്, എന്നാൽ ഉബുണ്ടു 6.10-ൽ നിന്ന് പരിണമിച്ചതിനുശേഷം, 2014 സെപ്തംബർ 4-ന് ഇത് നിലവിലുള്ള പതിപ്പ് 1.13.2 ആയി മാറി. ഏറ്റവും പുതിയ അപ്uസ്റ്റാർട്ട് സിസ്റ്റം 2 init പ്രോസസ്സുകൾ ഉണ്ട്, ഒന്ന് സിസ്റ്റം പ്രോസസ്സുകൾക്കും മറ്റൊന്ന് നിലവിലുള്ള ലോഗിൻ ചെയ്ത ഉപയോക്തൃ സെഷൻ നിയന്ത്രിക്കുന്നതും ഉപയോക്താവ് ലോഗിൻ ചെയ്യുന്നത് വരെ മാത്രമേ നിലനിൽക്കൂ, ഇതിനെ x-session init എന്നും വിളിക്കുന്നു. .

മുഴുവൻ സിസ്റ്റവും ഒരു ശ്രേണിപരമായ ഒന്നായി നിർവചിക്കപ്പെട്ടിരിക്കുന്നു, സിസ്റ്റത്തിന്റെ പവർ ഡൗൺ വരെയുള്ള ശക്തിയിലുടനീളം പൂർവ്വിക-ശിശു ബന്ധം അടങ്ങിയിരിക്കുന്നു.

ഉദാഹരണത്തിന്: രണ്ട് init പ്രക്രിയകളും തമ്മിലുള്ള ഒരു ചെറിയ ശ്രേണിപരമായ ബന്ധം ഇതാണ്: system init(1) -> display manager(kernel space) -> display manager(user space) -> user init(or x- സെഷൻ init).

സിസ്റ്റം init നിയന്ത്രിക്കുന്ന പ്രക്രിയകൾക്കായുള്ള കോൺഫിഗറേഷൻ ഫയലുകൾ \/etc/init എന്നതിലും സെഷൻ init നിയന്ത്രിക്കുന്നവയ്ക്ക് \/usr/share/upstart” എന്നതിലും വസിക്കുന്നു. (1.12-ന് മുകളിലുള്ള നിലവിലെ അപ്uസ്റ്റാർട്ട് പതിപ്പുകൾ പ്രകാരം) കൂടാതെ ഈ ലേഖനത്തിൽ വിവരിച്ചിരിക്കുന്നതുപോലെ, പ്രക്രിയകളെക്കുറിച്ചുള്ള പല രഹസ്യങ്ങളും ഈ കോൺഫിഗറേഷൻ ഫയലുകളാണ്.

ശ്രേണിയിലേക്ക് കൂടുതൽ ആഴത്തിൽ എത്തുന്നു

ഉബുണ്ടു രണ്ട് തരം പ്രക്രിയകൾ തിരിച്ചറിയുന്നു:

1. ഹ്രസ്വകാല ജോലികൾ (അല്ലെങ്കിൽ ജോലി ചെയ്ത് മരിക്കുന്ന ജോലികൾ).
2. ദീർഘായുസ്സുള്ള ജോലികൾ (അല്ലെങ്കിൽ താമസിച്ച് ജോലി ചെയ്യുന്ന ജോലികൾ).

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

Init എന്നത് സിസ്റ്റത്തിൽ പവർ ചെയ്യുന്നതിൽ ആരംഭിക്കുന്ന ആദ്യത്തെ പ്രക്രിയയാണ്, അത് ഒരിക്കലും നശിപ്പിക്കപ്പെടാത്തതിനാൽ, init കൊല്ലപ്പെടുന്ന സമയം മാത്രമേ ഓൺ ആകുന്നുള്ളൂ എന്നതിനാൽ ജോലിയും താമസവും ജോലിയുടെ കീഴിൽ വർഗ്ഗീകരിച്ചിരിക്കുന്നു. പവർ ഡൗൺ, അതായത് init മരിക്കുന്നു, അതും ഒരു സെഷനിൽ ഒരിക്കൽ, അത് പവർ ഡൗണിലാണ്. പവർ അപ്പ് ചെയ്യുമ്പോൾ, സിസ്റ്റത്തിലെ ആദ്യത്തെ ഇവന്റ്, അതായത് സ്റ്റാർട്ടപ്പ് ഇവന്റ്, init സൃഷ്ടിക്കുന്നു. \/etc/init ലെ ഓരോ കോൺഫിഗറേഷൻ ഫയലിനും രണ്ട് വരികളുണ്ട്, അത് പ്രക്രിയ ആരംഭിക്കുന്നതിനും നിർത്തുന്നതിനും കാരണമാകുന്ന ഇവന്റിനെ നിർവചിക്കുന്നു. ആ വരികൾ ചുവടെയുള്ള ചിത്രത്തിൽ ഹൈലൈറ്റ് ചെയ്തിരിക്കുന്നു:

ഇത് ഒരു പ്രോസസിന്റെ ഒരു കോൺഫിഗറേഷൻ ഫയലാണ് failsafe-x, ഇവ ആരംഭിക്കുന്നതും വ്യവസ്ഥകളിൽ നിർത്തുന്നതും പ്രക്രിയ ആരംഭിക്കുന്ന ഇവന്റിനെ വിവരിക്കുന്നു. സ്റ്റാർട്ടപ്പ് ഇവന്റിന്റെ ജനറേഷൻ ബൈ init പ്രോസസ്സ് ചെയ്യുമ്പോൾ, സ്റ്റാർട്ടപ്പ് സ്റ്റാർട്ടപ്പ് ഉള്ള പ്രോസസ്സുകൾ സമാന്തരമായി നടപ്പിലാക്കുന്നു, ഇത് ശ്രേണിയെ മാത്രമേ നിർവചിക്കുന്നുള്ളൂ, കൂടാതെ സ്റ്റാർട്ടപ്പിൽ എക്സിക്യൂട്ട് ചെയ്യുന്ന എല്ലാ പ്രക്രിയകളും init-ന്റെ കുട്ടികളാണ്.

സ്റ്റാർട്ടപ്പിൽ ആരംഭിക്കുന്ന പ്രക്രിയകൾ ചുവടെ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു, ഇവയെല്ലാം വർക്ക് ആൻഡ് ഡൈ ജോലികളാണ്:

1. hostname – ഇത് /etc/hostname ഫയലിൽ നിർവചിച്ചിരിക്കുന്ന അതിന്റെ ഹോസ്റ്റ്നാമം സിസ്റ്റത്തോട് പറയുന്ന ഒരു പ്രക്രിയയാണ്.

2. kmod – കേർണൽ മൊഡ്യൂളുകൾ അതായത് /etc/modules ഫയലിൽ നിന്ന് എല്ലാ ഡ്രൈവറുകളും ലോഡ് ചെയ്യുന്നു.

3. mountall - ഈ പ്രക്രിയ ധാരാളം ഇവന്റുകൾ സൃഷ്ടിക്കുന്നു, കൂടാതെ ലോക്കൽ ഫയൽ സിസ്റ്റങ്ങളും റിമോട്ട് ഫയൽ സിസ്റ്റങ്ങളും ഉൾപ്പെടെ ബൂട്ടിലെ എല്ലാ ഫയൽ സിസ്റ്റങ്ങളും മൗൺ ചെയ്യുന്നതിനുള്ള ഉത്തരവാദിത്തമാണ് ഇത്.

/proc ഫയലും ഈ പ്രക്രിയയിലൂടെയാണ് മൗണ്ടുചെയ്യുന്നത്, എല്ലാ മൗണ്ടിംഗ് വർക്കുകൾക്കും ശേഷം അത് സൃഷ്ടിച്ച അവസാന ഇവന്റ് ഫയൽസിസ്റ്റംസ് ഇവന്റാണ്, ഇത് ശ്രേണിയെ കൂടുതൽ മുന്നോട്ട് കൊണ്ടുപോകുന്നു.

4. plymouth - ഈ പ്രക്രിയ മൗണ്ടൽ ആരംഭിക്കുമ്പോൾ നിർവ്വഹിക്കുന്നു കൂടാതെ സിസ്റ്റം സ്റ്റാർട്ടപ്പിൽ കാണുന്ന ബ്ലാക്ക് സ്uക്രീൻ താഴെ കാണിക്കുന്നത് പോലെ കാണിക്കുന്നതിന് ഉത്തരവാദിയാണ്:

5. പ്ലൈമൗത്ത്-റെഡി – പ്ലൈമൗത്ത് ഉയർന്നതായി സൂചിപ്പിക്കുന്നു.

ഇനിപ്പറയുന്നവ പ്രധാന പ്രക്രിയയാണ്, സ്റ്റാർട്ടപ്പിലും നടപ്പിലാക്കുന്ന മറ്റുള്ളവയിൽ ഉൾപ്പെടുന്നു, udev-fallback-graphics മുതലായവ. ബൂട്ട് ശ്രേണിയിലേക്ക് തിരികെ വരുന്നു, ചുരുക്കത്തിൽ പിന്തുടരുന്ന ഇവന്റുകളും പ്രക്രിയകളും ക്രമത്തിലാണ്:

1. സ്റ്റാർട്ടപ്പ് ഇവന്റിന്റെ ജനറേഷൻ സഹിതം init.

2. മൗണ്ടോൾ മൗണ്ടിംഗ് ഫയൽ സിസ്റ്റങ്ങൾ, സ്പ്ലാഷ് സ്ക്രീൻ പ്രദർശിപ്പിക്കുന്ന പ്ലൈമൗത്ത് (മൗണ്ടോൾ ആരംഭിക്കുന്നതിനൊപ്പം), കെമോഡ് ലോഡിംഗ് കേർണൽ മൊഡ്യൂളുകളും.

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

4. ലോക്കൽ-ഫയൽസിസ്റ്റം, ആരംഭിച്ച dbus, സ്റ്റാറ്റിക്-നെറ്റ്uവർക്ക്-അപ്പ് ഇവന്റ് എന്നിവയ്uക്കൊപ്പം ലോക്കൽ-ഫയൽസിസ്റ്റം ഇവന്റിൽ പ്രവർത്തിക്കുന്ന പ്രോസസ്സ് നെറ്റ്uവർക്ക് മൂലമുണ്ടാകുന്ന സ്റ്റാറ്റിക്-നെറ്റ്uവർക്ക്-അപ്പ് ഇവന്റും നെറ്റ്uവർക്ക് മാനേജർ പ്രവർത്തിപ്പിക്കാൻ കാരണമാകുന്നു.

5. മൗണ്ടാൽ സൃഷ്ടിച്ച വെർച്വൽ-ഫയൽസിസ്റ്റം ഇവന്റ് udev പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകുന്നു. (ഉപകരണങ്ങളുടെ ഹോട്ട് പ്ലഗ്ഗിംഗ് കൈകാര്യം ചെയ്യുന്ന ലിനക്സിനുള്ള ഡിവൈസ് മാനേജറാണ് udev, കൂടാതെ /dev ഡയറക്ടറിയിൽ ഫയലുകൾ സൃഷ്ടിക്കുന്നതിനും അവ കൈകാര്യം ചെയ്യുന്നതിനും ഉത്തരവാദിത്തമുണ്ട്.) udev, വെർച്വൽ മൗണ്ടിംഗ് പൂർത്തിയാക്കിയ മൌണ്ട് ചെയ്തിട്ടുള്ള /dev ഡയറക്ടറിയിൽ ram, rom മുതലായവയ്ക്കുള്ള ഫയലുകൾ സൃഷ്ടിക്കുന്നു. -filesystems കൂടാതെ /dev ഡയറക്ടറിയുടെ മൗണ്ടിംഗ് സൂചിപ്പിക്കുന്ന ഇവന്റ് വെർച്വൽ-ഫയൽസിസ്റ്റം ജനറേറ്റ് ചെയ്തു.

6. udev upstart-udev-bridge പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകുന്നു, ഇത് പ്രാദേശിക നെറ്റ്uവർക്ക് പ്രവർത്തനക്ഷമമാണെന്ന് സൂചിപ്പിക്കുന്നു. മൗണ്ടൽ അവസാനത്തെ ഫയൽസിസ്റ്റം മൗണ്ടുചെയ്യുന്നത് പൂർത്തിയാക്കിയ ശേഷം ഫയൽസിസ്റ്റം ഇവന്റ് ജനറേറ്റ് ചെയ്തു.

7. സ്റ്റാറ്റിക്-നെറ്റ്uവർക്ക്-അപ്പ് ഇവന്റിനൊപ്പം ഫയൽസിസ്റ്റം ഇവന്റ് rc-sysinit ജോലി പ്രവർത്തിപ്പിക്കുന്നതിന് കാരണമാകുന്നു. ഇവിടെ, പഴയ sysvinit ഉം upstart ഉം തമ്മിലുള്ള പിന്നോക്ക അനുയോജ്യത വരുന്നു…

9. rc-sysinit സിസ്റ്റം റൺലവൽ പറയുന്ന ടെലിനിറ്റ് കമാൻഡ് പ്രവർത്തിപ്പിക്കുന്നു.

10. റൺലവൽ ലഭിച്ച ശേഷം, ഡയറക്uടറിയിൽ 'S' അല്ലെങ്കിൽ 'K' (പേരിന്റെ തുടക്കത്തിൽ 'S' ഉള്ള ജോലികൾ ആരംഭിക്കുകയും പേരിന്റെ തുടക്കത്തിൽ 'K' ഉള്ളവരെ കൊല്ലുകയും ചെയ്യുന്നു) തുടങ്ങുന്ന സ്ക്രിപ്റ്റുകൾ init എക്സിക്യൂട്ട് ചെയ്യുന്നു/etc/rcX.d (ഇവിടെ 'X' ആണ് നിലവിലെ റൺലവൽ).

ഈ ചെറിയ ഇവന്റുകൾ ഓരോ തവണയും നിങ്ങൾ പവർ ഓണാക്കുന്നതിന് സിസ്റ്റം ആരംഭിക്കുന്നതിന് കാരണമാകുന്നു. കൂടാതെ, ഈ ഇവന്റ് ട്രിഗർ ചെയ്യുന്ന പ്രക്രിയകൾ മാത്രമാണ് ശ്രേണി സൃഷ്ടിക്കുന്നതിനുള്ള ഉത്തരവാദിത്തം.

ഇപ്പോൾ, മുകളിലുള്ള മറ്റൊരു ആഡ്-ഓൺ സംഭവത്തിന്റെ കാരണമാണ്. ഈ വരികളിൽ താഴെ കാണിച്ചിരിക്കുന്നതുപോലെ, പ്രോസസ്സിന്റെ അതേ കോൺഫിഗറേഷൻ ഫയലിൽ ഏത് ഇവന്റും വ്യക്തമാക്കുന്നതാണ് ഏത് പ്രക്രിയയ്ക്ക് കാരണമാകുന്നു:

പ്രോസസ്സ് മൗണ്ടാളിന്റെ കോൺഫിഗറേഷൻ ഫയലിന്റെ ഒരു വിഭാഗമാണ് മുകളിൽ. ഇത് പുറത്തുവിടുന്ന സംഭവങ്ങളെ കാണിക്കുന്നു. ‘ഇവന്റ്’ എന്ന വാക്കിന് ശേഷം വരുന്ന ഒന്നാണ് ഇവന്റിന്റെ പേര്. ഇവന്റ് ഒന്നുകിൽ കോൺഫിഗറേഷൻ ഫയലിൽ മുകളിൽ നിർവചിച്ചിരിക്കുന്ന ഒന്നാകാം അല്ലെങ്കിൽ 'ആരംഭിക്കുക', 'ആരംഭിക്കുക', 'നിർത്തുക' അല്ലെങ്കിൽ 'നിർത്തി' എന്ന പ്രിഫിക്uസിനൊപ്പം പ്രോസസ്സിന്റെ പേര് ആകാം.

അതിനാൽ, ഇവിടെ ഞങ്ങൾ രണ്ട് പദങ്ങൾ നിർവചിക്കുന്നു:

1. ഇവന്റ് ജനറേറ്റർ: കോൺഫിഗറേഷൻ ഫയലിൽ 'എമിറ്റ്uസ് xxx' എന്ന വരിയുള്ള ഒന്ന്, xxx എന്നത് അതിന്റെ ഉടമസ്ഥതയിലുള്ളതോ ജനറേറ്റുചെയ്യുന്നതോ ആയ ഇവന്റിന്റെ പേരാണ്.
2. ഇവന്റ് ക്യാച്ചർ: xxx ആയി സ്റ്റാർട്ട് ഓൺ അല്ലെങ്കിൽ സ്റ്റോപ്പ് കണ്ടീഷൻ ഉള്ളത് അല്ലെങ്കിൽ ഇവന്റ് ജനറേറ്ററുകളിൽ ഒന്ന് ജനറേറ്റ് ചെയ്uത ഇവന്റിൽ ആരംഭിക്കുന്നതോ നിർത്തുന്നതോ ആയ ഒന്ന്.

അങ്ങനെ, ശ്രേണി പിന്തുടരുന്നു, അതിനാൽ പ്രക്രിയകൾ തമ്മിലുള്ള ആശ്രിതത്വം:

Event generator (parent) -> Event catcher (child)

ഒരു ലളിതമായ ബൂട്ട് അപ്പ് മെക്കാനിസത്തിലൂടെ ഇവന്റ് ട്രിഗറിംഗ് മെക്കാനിസം വഴി, പ്രക്രിയകൾക്കിടയിലുള്ള മാതാപിതാക്കൾ-കുട്ടി ആശ്രിതത്വത്തിന്റെ ശ്രേണി എങ്ങനെ സ്ഥാപിക്കപ്പെടുന്നുവെന്ന് ഇതുവരെ നിങ്ങൾ മനസ്സിലാക്കിയിരിക്കണം.

ഇപ്പോൾ, ഈ അധികാരശ്രേണി ഒരിക്കലും ഒരു കുട്ടിക്ക് ഒരു രക്ഷിതാവ് മാത്രമുള്ള ഒരു വ്യക്തി ബന്ധമല്ല. ഈ ശ്രേണിയിൽ നമുക്ക് ഒരു കുട്ടിക്ക് ഒന്നോ അതിലധികമോ മാതാപിതാക്കൾ ഉണ്ടായിരിക്കാം അല്ലെങ്കിൽ ഒന്നിൽ കൂടുതൽ കുട്ടികളുടെ രക്ഷിതാവ് എന്ന പ്രക്രിയ. ഇത് എങ്ങനെയാണ് നിർവ്വഹിക്കുന്നത്?? ശരി, ഉത്തരം കോൺഫിഗറേഷൻ ഫയലുകളിൽ തന്നെയുണ്ട്.

ഈ ലൈനുകൾ പ്രോസസ്സ് - നെറ്റ്uവർക്കിംഗിൽ നിന്ന് എടുത്തതാണ്, ഇവിടെ സ്റ്റാർട്ട് ഓൺ കണ്ടീഷൻ വളരെ സങ്കീർണ്ണമാണെന്ന് തോന്നുന്നു - ലോക്കൽ-ഫയൽസിസ്റ്റംസ്, udevtrigger, കണ്ടെയ്uനർ, റൺലെവൽ, നെറ്റ്uവർക്കിംഗ്.

ലോക്കൽ-ഫയൽസിസ്റ്റംസ് എമിറ്റ് ചെയ്യുന്നത് മൗണ്ടാൽ ആണ്, udevtrigger എന്നത് ജോലിയുടെ പേരാണ്, കണ്ടെയ്uനർ ഇവന്റ് എമിറ്റ് ചെയ്യുന്നത് കണ്ടെയ്uനർ-ഡിറ്റക്റ്റ് ആണ്, റൺലെവൽ ഇവന്റ് പുറപ്പെടുവിക്കുന്നത് rc-sysinit ആണ്, നെറ്റ്uവർക്കിംഗ് വീണ്ടും ഒരു ജോലിയാണ്.

അതിനാൽ, ഒരു ശ്രേണിയിൽ, പ്രോസസ്സ് നെറ്റ്uവർക്കിംഗ് അതിന്റെ പ്രവർത്തനം തുടരാൻ കഴിയാത്തതിനാൽ, മൗണ്ടോൾ, udevtrigger, കണ്ടെയ്uനർ-ഡിറ്റക്റ്റ് എന്നിവയുടെ ചൈൽഡ് ആണ് (പ്രോസസ്സിന്റെ പ്രവർത്തനം എന്നത് പ്രോസസ്സിന്റെ കോൺഫിഗറേഷൻ ഫയലിലെ സ്uക്രിപ്റ്റ് അല്ലെങ്കിൽ എക്uസിക് സെക്ഷനുകൾക്ക് കീഴിൽ നിർവചിച്ചിരിക്കുന്ന എല്ലാ വരികളും ആണ്) മുകളിലുള്ള പ്രക്രിയകൾ അവയുടെ ഇവന്റുകൾ സൃഷ്ടിക്കുന്നത് വരെ.
അതുപോലെ, ഒരു പ്രോസസ്സ് സൃഷ്uടിച്ച ഇവന്റ് പലരും കാഷെ ചെയ്uതാൽ നമുക്ക് ഒരു പ്രോസസ്സ് പലരുടെയും രക്ഷിതാവാകാം.

മുമ്പ് നിർവചിച്ചതുപോലെ, നമുക്ക് ഒന്നുകിൽ ഹ്രസ്വകാല (അല്ലെങ്കിൽ ജോലി-മരണ ജോലികൾ) അല്ലെങ്കിൽ ദീർഘകാല (അല്ലെങ്കിൽ താമസവും ജോലിയും) ജോലികൾ ഉണ്ടായിരിക്കാം, എന്നാൽ എങ്ങനെ വേർതിരിക്കാം അവരെ??

കോൺഫിഗറേഷൻ ഫയലുകളിൽ വ്യക്തമാക്കിയിട്ടുള്ള 'ആരംഭിക്കുക', 'സ്റ്റോപ്പ് ഓൺ' എന്നീ വ്യവസ്ഥകളുള്ള ജോലികൾ, അവയിൽ 'ടാസ്ക്' എന്ന വാക്ക് ഉണ്ട് കോൺഫിഗറേഷൻ ഫയൽ ആണ് work-and-die എന്നത് സൃഷ്uടിച്ച ഇവന്റിൽ ആരംഭിക്കുന്ന ജോലികളാണ്, അവയുടെ സ്uക്രിപ്റ്റ് അല്ലെങ്കിൽ എക്uസിക് സെക്ഷൻ എക്uസിക്യൂട്ട് ചെയ്യുക (എക്uസിക്യൂട്ട് ചെയ്യുമ്പോൾ, അവയ്ക്ക് കാരണമായ ഇവന്റുകൾ തടയുന്നു) തുടർന്ന് അവർ തടഞ്ഞ ഇവന്റുകൾ റിലീസ് ചെയ്uത് മരിക്കും .

കോൺഫിഗറേഷൻ ഫയലിൽ ‘സ്റ്റോപ്പ് ഓൺ’ വ്യവസ്ഥയില്ലാത്ത ജോലികൾ ദീർഘകാലം ജീവിച്ചിരിക്കുന്നതോ താമസിച്ച് ജോലി ചെയ്യുന്നതോ ജോലികളാണ്, അവ ഒരിക്കലും മരിക്കില്ല. ഇപ്പോൾ താമസവും ജോലിയും ചെയ്യുന്ന ജോലികളെ ഇനിപ്പറയുന്നതായി തരംതിരിക്കാം:

1. റെസ്uപോൺ അവസ്ഥയില്ലാത്തതും റൂട്ട് ഉപയോക്താവിന് കൊല്ലപ്പെടാവുന്നതുമായവ.
2. അവരുടെ കോൺഫിഗറേഷൻ ഫയലിൽ റീസ്uപോൺ കണ്ടീഷനുള്ളവ, അതിനാൽ അവരുടെ ജോലി പൂർത്തിയാകാത്ത പക്ഷം അവർ കൊല്ലപ്പെട്ടതിന് ശേഷം പുനരാരംഭിക്കുന്നു.

ഉപസംഹാരം

അതിനാൽ, LINUX-ലെ ഓരോ പ്രക്രിയയും ചിലതിനെ ആശ്രയിച്ചിരിക്കുന്നു, ചില പ്രക്രിയകൾ അതിനെ ആശ്രയിച്ചിരിക്കുന്നു, ഈ ബന്ധം പലതിലും പലതാണ്, കൂടാതെ പ്രക്രിയയുടെ മറ്റ് വിശദാംശങ്ങളോടൊപ്പം അപ്uസ്റ്റാർട്ട് സിസ്റ്റത്തിൽ ഇത് വ്യക്തമാക്കുന്നു.