RHCSA സീരീസ്: RHEL 7-ലെ പ്രോസസ്സ് മാനേജ്മെന്റ്: ബൂട്ട്, ഷട്ട്ഡൗൺ, അതിനിടയിലുള്ള എല്ലാം - ഭാഗം 5

നിങ്ങളുടെ RHEL 7 സെർവർ ഓണാക്കാൻ നിങ്ങൾ പവർ ബട്ടൺ അമർത്തുന്നത് മുതൽ ഒരു കമാൻഡ് ലൈൻ ഇന്റർഫേസിൽ ലോഗിൻ സ്uക്രീൻ അവതരിപ്പിക്കുന്നത് വരെ എന്താണ് സംഭവിക്കുന്നത് എന്നതിന്റെ മൊത്തത്തിലുള്ളതും ഹ്രസ്വവുമായ പുനരവലോകനത്തോടെ ഞങ്ങൾ ഈ ലേഖനം ആരംഭിക്കും.

ദയവായി ശ്രദ്ധിക്കുക:

1. ഇതേ അടിസ്ഥാന തത്ത്വങ്ങൾ, ഒരുപക്ഷേ ചെറിയ മാറ്റങ്ങളോടെ, മറ്റ് ലിനക്സ് വിതരണങ്ങൾക്കും ബാധകമാണ്, കൂടാതെ
2. ഇനിപ്പറയുന്ന വിവരണം ബൂട്ട് പ്രക്രിയയുടെ സമഗ്രമായ വിശദീകരണത്തെ പ്രതിനിധീകരിക്കാൻ ഉദ്ദേശിച്ചുള്ളതല്ല, മറിച്ച് അടിസ്ഥാനകാര്യങ്ങൾ മാത്രമാണ്.

Linux ബൂട്ട് പ്രക്രിയ

1. POST (പവർ ഓൺ സെൽഫ് ടെസ്റ്റ്) ഹാർഡ്uവെയർ പരിശോധനകൾ ആരംഭിക്കുകയും നടത്തുകയും ചെയ്യുന്നു.

2. POST പൂർത്തിയാകുമ്പോൾ, സിസ്റ്റം നിയന്ത്രണം ഒന്നാം ഘട്ട ബൂട്ട് ലോഡറിലേക്ക് കൈമാറുന്നു, അത് ഹാർഡ് ഡിസ്കുകളിൽ ഒന്നിന്റെ ബൂട്ട് സെക്ടറിൽ (ബയോസും MBR ഉം ഉപയോഗിക്കുന്ന പഴയ സിസ്റ്റങ്ങൾക്ക്) അല്ലെങ്കിൽ ഒരു സമർപ്പിത (U)EFI-യിൽ സംഭരിച്ചിരിക്കുന്നു. വിഭജനം.

3. ആദ്യ ഘട്ട ബൂട്ട് ലോഡർ പിന്നീട് രണ്ടാം ഘട്ട ബൂട്ട് ലോഡർ ലോഡ് ചെയ്യുന്നു, സാധാരണയായി GRUB (GRand Unified Boot Loader), അത് /boot-നുള്ളിൽ വസിക്കുന്നു, ഇത് കേർണലും പ്രാരംഭ RAM-അധിഷ്ഠിത ഫയൽ സിസ്റ്റവും (initramfs എന്നും അറിയപ്പെടുന്നു) ലോഡ് ചെയ്യുന്നു. , ആത്യന്തികമായി യഥാർത്ഥ റൂട്ട് ഫയൽസിസ്റ്റം മൗണ്ട് ചെയ്യുന്നതിന് ആവശ്യമായ പ്രവർത്തനങ്ങൾ ചെയ്യുന്ന പ്രോഗ്രാമുകളും ബൈനറി ഫയലുകളും ഇതിൽ അടങ്ങിയിരിക്കുന്നു).

4. ബൂട്ട് ചെയ്യുന്നതിനായി ഒരു ഓപ്പറേറ്റിംഗ് സിസ്റ്റവും കേർണലും തിരഞ്ഞെടുക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്ന ഒരു സ്പ്ലാഷ് സ്uക്രീൻ ഞങ്ങൾക്ക് നൽകിയിരിക്കുന്നു:

5. സിസ്റ്റത്തിൽ ഘടിപ്പിച്ചിട്ടുള്ള ഹാർഡ്uവെയർ കേർണൽ സജ്ജീകരിക്കുന്നു, റൂട്ട് ഫയൽസിസ്റ്റം മൌണ്ട് ചെയ്തുകഴിഞ്ഞാൽ, PID 1 ഉപയോഗിച്ച് പ്രോസസ്സ് സമാരംഭിക്കുന്നു, അത് മറ്റ് പ്രോസസ്സുകൾ ആരംഭിക്കുകയും ഒരു ലോഗിൻ പ്രോംപ്റ്റ് നൽകുകയും ചെയ്യും.

ശ്രദ്ധിക്കുക: പിന്നീടൊരിക്കൽ ഞങ്ങൾ അങ്ങനെ ചെയ്യാൻ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, dmesg കമാൻഡ് ഉപയോഗിച്ച് ഈ പ്രക്രിയയുടെ പ്രത്യേകതകൾ പരിശോധിക്കാനും ഈ പരമ്പരയിലെ മുൻ ലേഖനങ്ങളിൽ ഞങ്ങൾ വിശദീകരിച്ച ടൂളുകൾ ഉപയോഗിച്ച് അതിന്റെ ഔട്ട്പുട്ട് ഫിൽട്ടർ ചെയ്യാനും കഴിയും.

മുകളിലെ ഉദാഹരണത്തിൽ, നിലവിലുള്ള പ്രക്രിയകളുടെ ഒരു ലിസ്റ്റ് പ്രദർശിപ്പിക്കുന്നതിന് ഞങ്ങൾ അറിയപ്പെടുന്ന ps കമാൻഡ് ഉപയോഗിച്ചു, അതിന്റെ പാരന്റ് പ്രോസസ് (അല്ലെങ്കിൽ മറ്റൊരു രീതിയിൽ പറഞ്ഞാൽ, അവ ആരംഭിച്ച പ്രക്രിയ) systemd (മിക്ക ആധുനിക ലിനക്സ് വിതരണങ്ങളും മാറിയിട്ടുള്ള സിസ്റ്റവും സേവന മാനേജറും ആണ്. വരെ) സിസ്റ്റം സ്റ്റാർട്ടപ്പ് സമയത്ത്:

# ps -o ppid,pid,uname,comm --ppid=1

man ps-ലെ സ്റ്റാൻഡേർഡ് ഫോർമാറ്റ് സ്uപെസിഫയേഴ്uസ് വിഭാഗത്തിൽ വ്യക്തമാക്കിയ കീവേഡുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ ആവശ്യങ്ങൾക്കനുസരിച്ച് ഇഷ്uടാനുസൃതമാക്കിയ ഫോർമാറ്റിൽ ps-ന്റെ ഔട്ട്uപുട്ട് അവതരിപ്പിക്കാൻ -o ഫ്ലാഗ് (-ഫോർമാറ്റിന്റെ ചുരുക്കം) നിങ്ങളെ അനുവദിക്കുന്നുവെന്ന് ഓർമ്മിക്കുക.

ഡിഫോൾട്ടിലേക്ക് പോകുന്നതിനുപകരം ps-ന്റെ ഔട്ട്പുട്ട് നിർവചിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്ന മറ്റൊരു സന്ദർഭം, നിങ്ങൾക്ക് കാര്യമായ CPU കൂടാതെ/അല്ലെങ്കിൽ മെമ്മറി ലോഡിന് കാരണമാകുന്ന പ്രക്രിയകൾ കണ്ടെത്തുകയും അതിനനുസരിച്ച് അവയെ അടുക്കുകയും വേണം:

# ps aux --sort=+pcpu              # Sort by %CPU (ascending)
# ps aux --sort=-pcpu              # Sort by %CPU (descending)
# ps aux --sort=+pmem              # Sort by %MEM (ascending)
# ps aux --sort=-pmem              # Sort by %MEM (descending)
# ps aux --sort=+pcpu,-pmem        # Combine sort by %CPU (ascending) and %MEM (descending)

SystemD യിലേക്കുള്ള ഒരു ആമുഖം

പ്രധാന ലിനക്സ് വിതരണങ്ങൾ systemd സ്വീകരിച്ചതിനെക്കാൾ കൂടുതൽ വിവാദങ്ങൾക്ക് Linux ലോകത്തിലെ ചില തീരുമാനങ്ങൾ കാരണമായിട്ടുണ്ട്. Systemd-ന്റെ വക്താക്കൾ അതിന്റെ പ്രധാന നേട്ടങ്ങളായി ഇനിപ്പറയുന്ന വസ്തുതകൾ പറയുന്നു:

ഇതും വായിക്കുക: 'init', 'systemd' എന്നിവയ്ക്ക് പിന്നിലെ കഥ

1. സിസ്റ്റം സ്റ്റാർട്ടപ്പ് സമയത്ത് സമാന്തരമായി കൂടുതൽ പ്രോസസ്സിംഗ് നടത്താൻ Systemd അനുവദിക്കുന്നു (പഴയ SysVinit-ന് വിപരീതമായി, ഇത് എല്ലായ്uപ്പോഴും മന്ദഗതിയിലായിരിക്കും, കാരണം ഇത് ഓരോന്നായി പ്രോസസ്സുകൾ ആരംഭിക്കുന്നു, ഒന്ന് മറ്റൊന്നിനെ ആശ്രയിക്കുന്നുണ്ടോയെന്ന് പരിശോധിക്കുന്നു, തുടർന്ന് ഡെമണുകൾ സമാരംഭിക്കുന്നതിനായി കാത്തിരിക്കുന്നു. കൂടുതൽ സേവനങ്ങൾ ആരംഭിക്കാം), കൂടാതെ

2. ഇത് ഒരു റണ്ണിംഗ് സിസ്റ്റത്തിൽ ഒരു ഡൈനാമിക് റിസോഴ്സ് മാനേജ്മെന്റ് ആയി പ്രവർത്തിക്കുന്നു. അതിനാൽ, ബൂട്ട് സമയത്ത് ഒരു സാധുവായ കാരണമില്ലാതെ സമാരംഭിക്കുന്നതിനുപകരം ആവശ്യമുള്ളപ്പോൾ സേവനങ്ങൾ ആരംഭിക്കുന്നു (സിസ്റ്റം ഉറവിടങ്ങൾ ഉപയോഗിക്കുന്നില്ലെങ്കിൽ അവ ഉപയോഗിക്കാതിരിക്കാൻ).

3. SysVinit സ്ക്രിപ്റ്റുകളുമായുള്ള ബാക്ക്വേർഡ് കോംപാറ്റിബിളിറ്റി.

Systemctl യൂട്ടിലിറ്റിയാണ് Systemd നിയന്ത്രിക്കുന്നത്. നിങ്ങൾ ഒരു SysVinit പശ്ചാത്തലത്തിൽ നിന്നാണ് വരുന്നതെങ്കിൽ, നിങ്ങൾക്ക് പരിചിതമായിരിക്കാനുള്ള സാധ്യതയുണ്ട്:

1. സേവന ഉപകരണം, -ആ പഴയ സിസ്റ്റങ്ങളിൽ- SysVinit സ്ക്രിപ്റ്റുകൾ കൈകാര്യം ചെയ്യാൻ ഉപയോഗിച്ചു, കൂടാതെ
2. സിസ്റ്റം സേവനങ്ങൾക്കായി റൺലവൽ വിവരങ്ങൾ അപ്uഡേറ്റ് ചെയ്യുന്നതിനും അന്വേഷിക്കുന്നതിനുമുള്ള ഉദ്ദേശ്യം നിറവേറ്റുന്ന chkconfig യൂട്ടിലിറ്റി.
3. ഷട്ട്ഡൗൺ, ഒന്നുകിൽ പ്രവർത്തിക്കുന്ന സിസ്റ്റം പുനരാരംഭിക്കുന്നതിനോ നിർത്തുന്നതിനോ നിങ്ങൾ നിരവധി തവണ ഉപയോഗിച്ചിരിക്കണം.

ഈ ലെഗസി ടൂളുകളുടെ ഉപയോഗവും systemctl ഉം തമ്മിലുള്ള സമാനതകൾ ഇനിപ്പറയുന്ന പട്ടിക കാണിക്കുന്നു:

Systemd യൂണിറ്റുകളുടെ ആശയങ്ങളും (അത് ഒരു സേവനം, ഒരു മൗണ്ട് പോയിന്റ്, ഒരു ഉപകരണം അല്ലെങ്കിൽ ഒരു നെറ്റ്uവർക്ക് സോക്കറ്റ് ആകാം) ടാർഗെറ്റുകളും (ഇങ്ങനെയാണ് systemd ഒരേ സമയം നിരവധി അനുബന്ധ പ്രക്രിയകൾ ആരംഭിക്കുന്നത്, പരിഗണിക്കാം - തുല്യമല്ലെങ്കിലും- SysVinit-അധിഷ്ഠിത സിസ്റ്റങ്ങളിലെ റൺലവലുകൾക്ക് തുല്യമാണ്.

സംഗ്രഹിക്കുന്നു

പ്രോസസ്സ് മാനേജുമെന്റുമായി ബന്ധപ്പെട്ട മറ്റ് ടാസ്ക്കുകളിൽ ഇവ ഉൾപ്പെടുന്നു, എന്നാൽ ഇവയിൽ മാത്രം പരിമിതപ്പെടുത്തിയേക്കില്ല:

ഒന്നോ അതിലധികമോ റണ്ണിംഗ് പ്രോസസുകളുടെ ഷെഡ്യൂളിംഗ് മുൻഗണനയിൽ മാറ്റം വരുത്തുന്ന റെനീസ് യൂട്ടിലിറ്റി വഴിയാണ് ഇത് നടപ്പിലാക്കുന്നത്. ലളിതമായി പറഞ്ഞാൽ, ഷെഡ്യൂളിംഗ് മുൻഗണന എന്നത് ഒരു നിശ്ചിത പ്രക്രിയയുടെ നിയുക്ത എക്uസിക്യൂഷൻ മുൻഗണന (-20 മുതൽ 19 വരെയുള്ള ശ്രേണിയിൽ) സിസ്റ്റം റിസോഴ്uസുകൾ അനുവദിക്കുന്നതിന് കേർണലിനെ (പതിപ്പുകളിൽ => 2.6) അനുവദിക്കുന്ന ഒരു സവിശേഷതയാണ്.

റെനീസിന്റെ അടിസ്ഥാന വാക്യഘടന ഇപ്രകാരമാണ്:

# renice [-n] priority [-gpu] identifier

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

കൂടുതൽ കൃത്യമായി പറഞ്ഞാൽ, ഒരു പ്രക്രിയയെ കൊല്ലുന്നത്, ഒന്നുകിൽ അതിന്റെ നിർവ്വഹണം ഭംഗിയായി പൂർത്തിയാക്കാൻ (SIGTERM=15) അല്ലെങ്കിൽ ഉടൻ (SIGKILL=9) കിൽ അല്ലെങ്കിൽ pkill കമാൻഡുകൾ വഴി ഒരു സിഗ്നൽ അയയ്uക്കാൻ അർഹത നൽകുന്നു.

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

കൂടാതെ, pkill pgrep-നൊപ്പം വരുന്നു, ഇത് pkill ഉപയോഗിക്കേണ്ട PID-കളെ ബാധിക്കും. ഉദാഹരണത്തിന്, പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്:

# pkill -u gacanepa

ഗകനേപയുടെ ഉടമസ്ഥതയിലുള്ള PID-കൾ ഏതൊക്കെയാണെന്ന് ഒറ്റനോട്ടത്തിൽ കാണുന്നത് ഉപയോഗപ്രദമാകും:

# pgrep -l -u gacanepa

ഡിഫോൾട്ടായി, kill, pkill എന്നിവ രണ്ടും പ്രക്രിയയിലേക്ക് SIGTERM സിഗ്നൽ അയയ്ക്കുന്നു. ഞങ്ങൾ മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, ഈ സിഗ്നൽ അവഗണിക്കാവുന്നതാണ് (പ്രോസസ്സ് അതിന്റെ നിർവ്വഹണം പൂർത്തിയാകുമ്പോഴോ അല്ലെങ്കിൽ നല്ലതിനുവേണ്ടിയോ), അതിനാൽ സാധുവായ ഒരു കാരണത്താൽ ഒരു റണ്ണിംഗ് പ്രോസസ് നിങ്ങൾ ഗൗരവമായി നിർത്തേണ്ടിവരുമ്പോൾ, നിങ്ങൾ കമാൻഡ് ലൈനിൽ SIGKILL സിഗ്നൽ വ്യക്തമാക്കേണ്ടതുണ്ട്:

# kill -9 identifier               # Kill a process or a process group
# kill -s SIGNAL identifier        # Idem
# pkill -s SIGNAL identifier       # Kill a process by name or other attributes 

ഉപസംഹാരം

ഈ ലേഖനത്തിൽ ഒരു RHEL 7 സിസ്റ്റത്തിലെ ബൂട്ട് പ്രക്രിയയുടെ അടിസ്ഥാനകാര്യങ്ങൾ ഞങ്ങൾ വിശദീകരിച്ചിട്ടുണ്ട്, കൂടാതെ പൊതുവായ യൂട്ടിലിറ്റികളും systemd-നിർദ്ദിഷ്ട കമാൻഡുകളും ഉപയോഗിച്ച് പ്രോസസ്സുകൾ കൈകാര്യം ചെയ്യാൻ നിങ്ങളെ സഹായിക്കുന്ന ചില ടൂളുകൾ വിശകലനം ചെയ്തു.

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