ലിനക്സിലെ വെർച്വൽ ഫയൽ സിസ്റ്റങ്ങൾ: എന്തുകൊണ്ട് അവ ആവശ്യമാണ്, അവ എങ്ങനെ പ്രവർത്തിക്കുന്നു? ഭാഗം 2

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

eBPF, bcc ടൂളുകൾ ഉപയോഗിച്ച് VFS എങ്ങനെ നിരീക്ഷിക്കാം

ഫയലുകളിൽ കേർണൽ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസ്സിലാക്കാനുള്ള എളുപ്പവഴി sysfs ഇത് പ്രായോഗികമായി കാണുക എന്നതാണ്, ARM64 കാണാനുള്ള ഏറ്റവും എളുപ്പ മാർഗം eBPF ഉപയോഗിക്കുക എന്നതാണ്. eBPF (ബെർക്ക്‌ലി പാക്കറ്റ് ഫിൽട്ടറിന്റെ ചുരുക്കം) ഒരു വെർച്വൽ മെഷീൻ പ്രവർത്തിക്കുന്നു കാമ്പ്, ഏത് പ്രത്യേക ഉപയോക്താക്കൾക്ക് അഭ്യർത്ഥിക്കാം (query) കമാൻഡ് ലൈനിൽ നിന്ന്. കേർണലിന് എന്തുചെയ്യാൻ കഴിയുമെന്ന് കേർണൽ ഉറവിടങ്ങൾ വായനക്കാരോട് പറയുന്നു; ഒരു ലോഡ് ചെയ്ത സിസ്റ്റത്തിൽ eBPF ടൂളുകൾ പ്രവർത്തിപ്പിക്കുന്നത് കേർണൽ യഥാർത്ഥത്തിൽ എന്താണ് ചെയ്യുന്നതെന്ന് കാണിക്കുന്നു.

ഭാഗ്യവശാൽ, ടൂളുകളുടെ സഹായത്തോടെ eBPF ഉപയോഗിക്കാൻ തുടങ്ങുന്നത് വളരെ എളുപ്പമാണ് ബിസിസി, പൊതുവായ വിതരണത്തിൽ നിന്ന് പാക്കേജുകളായി ലഭ്യമാണ് ലിനക്സ് വിശദമായി രേഖപ്പെടുത്തുകയും ചെയ്തു ബെർണാഡ് ഗ്രെഗ്. ഉപകരണങ്ങൾ bcc സി കോഡിന്റെ ചെറിയ ഉൾപ്പെടുത്തലുകളുള്ള പൈത്തൺ സ്ക്രിപ്റ്റുകളാണ്, അതായത് രണ്ട് ഭാഷകളും പരിചയമുള്ള ആർക്കും അവ എളുപ്പത്തിൽ പരിഷ്കരിക്കാനാകും. IN bcc/tools 80 പൈത്തൺ സ്ക്രിപ്റ്റുകൾ ഉണ്ട്, അതിനർത്ഥം മിക്കവാറും ഒരു ഡവലപ്പർ അല്ലെങ്കിൽ സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർക്ക് പ്രശ്നം പരിഹരിക്കുന്നതിന് അനുയോജ്യമായ എന്തെങ്കിലും തിരഞ്ഞെടുക്കാൻ കഴിയും എന്നാണ്.
ഒരു റണ്ണിംഗ് സിസ്റ്റത്തിൽ VFS-കൾ എന്തുചെയ്യുന്നു എന്നതിന്റെ ഉപരിപ്ലവമായ ഒരു ആശയമെങ്കിലും ലഭിക്കാൻ, ശ്രമിക്കുക vfscount അഥവാ vfsstat. ഇത് ഡസൻ കണക്കിന് കോളുകൾ കാണിക്കും vfs_open() കൂടാതെ "അവന്റെ സുഹൃത്തുക്കൾ" അക്ഷരാർത്ഥത്തിൽ ഓരോ സെക്കൻഡിലും സംഭവിക്കുന്നു.

vfsstat.py വിഎഫ്എസ് ഫംഗ്‌ഷൻ കോളുകൾ കണക്കാക്കുന്ന സി കോഡ് ഉൾപ്പെടുത്തലുകളുള്ള ഒരു പൈത്തൺ സ്‌ക്രിപ്റ്റാണ്.

നമുക്ക് കൂടുതൽ നിസ്സാരമായ ഒരു ഉദാഹരണം നൽകുകയും കമ്പ്യൂട്ടറിലേക്ക് USB ഫ്ലാഷ് ഡ്രൈവ് തിരുകുകയും സിസ്റ്റം അത് കണ്ടെത്തുകയും ചെയ്യുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് നോക്കാം.

eBPF ഉപയോഗിച്ച് നിങ്ങൾക്ക് എന്താണ് സംഭവിക്കുന്നതെന്ന് കാണാൻ കഴിയും /sysഒരു USB ഫ്ലാഷ് ഡ്രൈവ് ചേർക്കുമ്പോൾ. ലളിതവും സങ്കീർണ്ണവുമായ ഒരു ഉദാഹരണം ഇവിടെ കാണിച്ചിരിക്കുന്നു.

മുകളിൽ കാണിച്ചിരിക്കുന്ന ഉദാഹരണത്തിൽ, bcc ഉപകരണം trace.py കമാൻഡ് പ്രവർത്തിപ്പിക്കുമ്പോൾ ഒരു സന്ദേശം പ്രിന്റ് ചെയ്യുന്നു sysfs_create_files(). ഞങ്ങൾ അത് കാണുന്നു sysfs_create_files() ഉപയോഗിച്ച് വിക്ഷേപിച്ചു kworker ഫ്ലാഷ് ഡ്രൈവ് ചേർത്തു എന്നതിന്റെ പ്രതികരണമായി സ്ട്രീം ചെയ്യുക, എന്നാൽ ഏത് ഫയൽ സൃഷ്ടിച്ചു? രണ്ടാമത്തെ ഉദാഹരണം ഇബിപിഎഫിന്റെ ശക്തി കാണിക്കുന്നു. ഇവിടെ trace.py ഒരു കേർണൽ ബാക്ക്ട്രെയിസും (-K ഓപ്ഷൻ) സൃഷ്ടിച്ച ഫയലിന്റെ പേരും പ്രിന്റ് ചെയ്യുന്നു sysfs_create_files(). LLVM പ്രവർത്തിപ്പിക്കുന്ന പൈത്തൺ സ്ക്രിപ്റ്റ് നൽകുന്ന എളുപ്പത്തിൽ തിരിച്ചറിയാവുന്ന ഫോർമാറ്റ് സ്ട്രിംഗ് ഉൾപ്പെടുന്ന സി കോഡാണ് സിംഗിൾ സ്റ്റേറ്റ്മെന്റ് ഇൻസേർഷൻ ജസ്റ്റ്-ഇൻ-ടൈം കംപൈലർ. ഇത് ഈ ലൈൻ കംപൈൽ ചെയ്യുകയും കേർണലിനുള്ളിലെ ഒരു വെർച്വൽ മെഷീനിൽ എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു. പൂർണ്ണമായ പ്രവർത്തന ഒപ്പ് sysfs_create_files () രണ്ടാമത്തെ കമാൻഡിൽ പുനർനിർമ്മിക്കണം, അങ്ങനെ ഫോർമാറ്റ് സ്ട്രിംഗിന് പരാമീറ്ററുകളിലൊന്ന് സൂചിപ്പിക്കാൻ കഴിയും. ഈ സി കോഡിലെ പിശകുകൾ സി കമ്പൈലറിൽ നിന്ന് തിരിച്ചറിയാവുന്ന പിശകുകൾക്ക് കാരണമാകുന്നു. ഉദാഹരണത്തിന്, -l പാരാമീറ്റർ ഒഴിവാക്കിയാൽ, "BPF ടെക്സ്റ്റ് കംപൈൽ ചെയ്യുന്നതിൽ പരാജയപ്പെട്ടു" എന്ന് നിങ്ങൾ കാണും. സി, പൈത്തൺ എന്നിവയുമായി പരിചയമുള്ള ഡെവലപ്പർമാർ ഉപകരണങ്ങൾ കണ്ടെത്തും bcc വികസിപ്പിക്കാനും മാറ്റാനും എളുപ്പമാണ്.

USB ഡ്രൈവ് ചേർക്കുമ്പോൾ, PID 7711 ഒരു ത്രെഡ് ആണെന്ന് കേർണൽ ബാക്ക്ട്രെയിസ് കാണിക്കും. kworkerഫയൽ സൃഷ്ടിച്ചത് «events» в sysfs. അതനുസരിച്ച്, നിന്നുള്ള വിളി sysfs_remove_files() ഡ്രൈവ് നീക്കംചെയ്യുന്നത് ഫയൽ ഇല്ലാതാക്കാൻ ഇടയാക്കി എന്ന് കാണിക്കും events, ഇത് റഫറൻസ് കൗണ്ടിംഗിന്റെ പൊതു ആശയവുമായി യോജിക്കുന്നു. അതേ സമയം, കാണുന്നത് sysfs_create_link () eBPF ഉപയോഗിച്ച് USB ഡ്രൈവ് ചേർക്കുമ്പോൾ കുറഞ്ഞത് 48 പ്രതീകാത്മക ലിങ്കുകളെങ്കിലും സൃഷ്‌ടിച്ചതായി കാണിക്കും.

അപ്പോൾ ഇവന്റ് ഫയലിന്റെ പ്രയോജനം എന്താണ്? ഉപയോഗം cscope തിരയലിനായി __device_add_disk(), അത് എന്താണ് കാരണമാകുന്നതെന്ന് കാണിക്കുന്നു disk_add_events (), കൂടാതെ ഒന്നുകിൽ "media_change", അല്ലെങ്കിൽ "eject_request" ഒരു ഇവന്റ് ഫയലിൽ രേഖപ്പെടുത്താം. ഇവിടെ കേർണൽ ബ്ലോക്ക് ലെയർ ഒരു "ഡിസ്ക്" പ്രത്യക്ഷപ്പെടുകയും ഇജക്റ്റ് ചെയ്യുകയും ചെയ്തതായി ഉപയോക്തൃസ്പേസിനെ അറിയിക്കുന്നു. ഉറവിടത്തിൽ നിന്ന് കാര്യങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് കണ്ടുപിടിക്കാൻ ശ്രമിക്കുന്നതിനെ അപേക്ഷിച്ച്, യുഎസ്ബി ഡ്രൈവ് തിരുകുന്നതിലൂടെ ഈ ഗവേഷണ രീതി എത്രമാത്രം വിജ്ഞാനപ്രദമാണെന്ന് ശ്രദ്ധിക്കുക.

റീഡ്-ഒൺലി റൂട്ട് ഫയൽ സിസ്റ്റങ്ങൾ എംബഡഡ് ഡിവൈസുകൾ പ്രവർത്തനക്ഷമമാക്കുന്നു

തീർച്ചയായും, സോക്കറ്റിൽ നിന്ന് പ്ലഗ് വലിച്ചുകൊണ്ട് ആരും സെർവറോ അവരുടെ കമ്പ്യൂട്ടറോ ഓഫ് ചെയ്യില്ല. പക്ഷെ എന്തുകൊണ്ട്? കാരണം, ഫിസിക്കൽ സ്റ്റോറേജ് ഡിവൈസുകളിൽ മൌണ്ട് ചെയ്ത ഫയൽ സിസ്റ്റങ്ങൾ റൈറ്റുകളെ പിന്നിലാക്കിയിരിക്കാം, കൂടാതെ അവയുടെ അവസ്ഥ രേഖപ്പെടുത്തുന്ന ഡാറ്റാ ഘടനകൾ സ്റ്റോറേജിലേക്കുള്ള റൈറ്റുകളുമായി സമന്വയിപ്പിക്കപ്പെടില്ല. ഇത് സംഭവിക്കുമ്പോൾ, യൂട്ടിലിറ്റി സമാരംഭിക്കുന്നതിന് സിസ്റ്റം ഉടമകൾ അടുത്ത ബൂട്ട് വരെ കാത്തിരിക്കണം. fsck filesystem-recovery കൂടാതെ, ഏറ്റവും മോശമായ സാഹചര്യത്തിൽ, ഡാറ്റ നഷ്‌ടപ്പെടുന്നു.

എന്നിരുന്നാലും, പല ഐഒടി ഉപകരണങ്ങളും റൂട്ടറുകളും തെർമോസ്റ്റാറ്റുകളും കാറുകളും ഇപ്പോൾ ലിനക്സ് പ്രവർത്തിപ്പിക്കുന്നുവെന്ന് നമുക്കെല്ലാവർക്കും അറിയാം. ഈ ഉപകരണങ്ങളിൽ പലതിനും ഉപയോക്തൃ ഇന്റർഫേസ് കുറവാണ്, മാത്രമല്ല അവ "വൃത്തിയായി" ഓഫാക്കാനുള്ള മാർഗവുമില്ല. കൺട്രോൾ യൂണിറ്റിലേക്കുള്ള പവർ ഉള്ളപ്പോൾ, ബാറ്ററി നിർജ്ജീവമായ ഒരു കാർ ആരംഭിക്കുന്നത് സങ്കൽപ്പിക്കുക ലിനക്സ് നിരന്തരം മുകളിലേക്കും താഴേക്കും ചാടുന്നു. എങ്ങനെയാണ് സിസ്റ്റം ദീർഘനേരം ബൂട്ട് ചെയ്യുന്നത്? fsckഎഞ്ചിൻ അവസാനം എപ്പോഴാണ് പ്രവർത്തിക്കാൻ തുടങ്ങുന്നത്? ഉത്തരം ലളിതമാണ്. ഉൾച്ചേർത്ത ഉപകരണങ്ങൾ റൂട്ട് ഫയൽ സിസ്റ്റത്തെ ആശ്രയിക്കുന്നു വായനയ്ക്ക് മാത്രം (ചുരുക്കത്തിൽ ro-rootfs (റീഡ്-ഒൺലി റൂട്ട് ഫയൽസിസ്റ്റം)).

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

സൃഷ്ടി rootfs എംബഡഡ് ഡെവലപ്പർമാർക്ക് വായന-മാത്രം ചില അധിക പരിശ്രമം ആവശ്യമാണ്, ഇവിടെയാണ് VFS ചിത്രത്തിൽ വരുന്നത്. ഫയലുകൾ ഉള്ളിലായിരിക്കണമെന്ന് Linux ആവശ്യപ്പെടുന്നു /var എഴുതാവുന്നവയായിരുന്നു, കൂടാതെ, എംബഡഡ് സിസ്റ്റങ്ങൾ പ്രവർത്തിപ്പിക്കുന്ന പല ജനപ്രിയ ആപ്ലിക്കേഷനുകളും കോൺഫിഗറേഷൻ സൃഷ്ടിക്കാൻ ശ്രമിക്കും. dot-files в $HOME. ഹോം ഡയറക്‌ടറിയിലെ കോൺഫിഗറേഷൻ ഫയലുകൾക്കുള്ള ഒരു പരിഹാരം സാധാരണയായി അവ മുൻകൂട്ടി ജനറേറ്റുചെയ്‌ത് നിർമ്മിക്കുക എന്നതാണ് rootfs. വേണ്ടി /var ഒരു പ്രത്യേക റൈറ്റബിൾ പാർട്ടീഷനിൽ മൌണ്ട് ചെയ്യുക എന്നതാണ് സാധ്യമായ ഒരു സമീപനം / മൌണ്ട് ചെയ്ത വായന-മാത്രം. ബൈൻഡ് അല്ലെങ്കിൽ ഓവർലേ മൗണ്ടുകൾ ഉപയോഗിക്കുക എന്നതാണ് മറ്റൊരു ജനപ്രിയ ബദൽ.

ലിങ്ക് ചെയ്യാവുന്നതും അടുക്കിവെക്കാവുന്നതുമായ മൗണ്ടുകൾ, കണ്ടെയ്‌നറുകൾ ഉപയോഗിച്ചുള്ള അവയുടെ ഉപയോഗം

കമാൻഡ് എക്സിക്യൂഷൻ man mount ഡവലപ്പർമാർക്കും സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർമാർക്കും ഒരു ഫയൽ സിസ്റ്റം സൃഷ്ടിക്കാനും പിന്നീട് മറ്റൊരു പാതയിൽ അത് ആപ്ലിക്കേഷനുകളിലേക്ക് തുറന്നുകാട്ടാനുമുള്ള കഴിവ് നൽകുന്ന ബൈൻഡബിൾ, ഓവർലേ ചെയ്യാവുന്ന മൗണ്ടുകളെ കുറിച്ച് പഠിക്കാനുള്ള ഏറ്റവും നല്ല മാർഗമാണിത്. എംബഡഡ് സിസ്റ്റങ്ങൾക്ക്, ഫയലുകൾ സംഭരിക്കാനുള്ള കഴിവ് എന്നാണ് ഇതിനർത്ഥം /var ഒരു റീഡ്-ഒൺലി ഫ്ലാഷ് ഡ്രൈവിൽ, എന്നാൽ ഒരു ഓവർലേ അല്ലെങ്കിൽ ലിങ്ക് ചെയ്യാവുന്ന മൗണ്ട് പാത്ത് tmpfs в /var ലോഡുചെയ്യുമ്പോൾ, അവിടെ കുറിപ്പുകൾ എഴുതാൻ ഇത് അപ്ലിക്കേഷനുകളെ അനുവദിക്കും (സ്‌ക്രാൾ). അടുത്ത തവണ നിങ്ങൾ മാറ്റങ്ങൾ ഓണാക്കുമ്പോൾ /var നഷ്ടപ്പെടും. ഒരു ഓവർലേ മൗണ്ട് തമ്മിൽ ഒരു യൂണിയൻ സൃഷ്ടിക്കുന്നു tmpfs കൂടാതെ അടിസ്ഥാന ഫയൽ സിസ്റ്റവും നിലവിലുള്ള ഫയലുകളിൽ പ്രത്യക്ഷമായ മാറ്റങ്ങൾ വരുത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു ro-tootf ബൈൻഡബിൾ മൗണ്ടിന് പുതിയവ ശൂന്യമാക്കാൻ കഴിയും tmpfs ഫോൾഡറുകൾ എഴുതാവുന്നതുപോലെ ദൃശ്യമാണ് ro-rootfs വഴികൾ. അതേസമയം overlayfs ഇതാണ് ശരിയായത് (proper) ഫയൽ സിസ്റ്റം തരം, ബൈൻഡബിൾ മൗണ്ട് നടപ്പിലാക്കുന്നു VFS നെയിംസ്പേസ്.

ഓവർലേയുടെയും ലിങ്ക് ചെയ്യാവുന്ന മൗണ്ടിന്റെയും വിവരണത്തെ അടിസ്ഥാനമാക്കി, ആരും ആശ്ചര്യപ്പെടുന്നില്ല ലിനക്സ് കണ്ടെയ്നറുകൾ അവ സജീവമായി ഉപയോഗിക്കുന്നു. ഉപയോഗിക്കുമ്പോൾ എന്താണ് സംഭവിക്കുന്നതെന്ന് നോക്കാം systemd-nspawn ഉപകരണം ഉപയോഗിച്ച് കണ്ടെയ്നർ പ്രവർത്തിപ്പിക്കാൻ mountsnoop от bcc.

വെല്ലുവിളി system-nspawn പ്രവർത്തിക്കുമ്പോൾ കണ്ടെയ്നർ ആരംഭിക്കുന്നു mountsnoop.py.

എന്താണ് സംഭവിച്ചതെന്ന് നമുക്ക് നോക്കാം:

സമാരംഭിക്കുക mountsnoop കണ്ടെയ്നർ "ബൂട്ട്" ചെയ്യുമ്പോൾ, കണ്ടെയ്നറിന്റെ റൺടൈം ലിങ്ക് ചെയ്തിരിക്കുന്ന മൗണ്ടിനെ ആശ്രയിച്ചിരിക്കുന്നു എന്ന് കാണിക്കുന്നു (നീണ്ട ഔട്ട്പുട്ടിന്റെ ആരംഭം മാത്രം കാണിക്കുന്നു).

ഇത് systemd-nspawn എന്നതിൽ തിരഞ്ഞെടുത്ത ഫയലുകൾ നൽകുന്നു procfs и sysfs അതിലേക്കുള്ള പാതകളായി കണ്ടെയ്നറിലേക്ക് ഹോസ്റ്റ് ചെയ്യുക rootfs... കൂടാതെ MS_BIND ബൈൻഡിംഗ് മൗണ്ട് സജ്ജീകരിക്കുന്ന ഫ്ലാഗ്, മൗണ്ടിലെ മറ്റ് ചില ഫ്ലാഗുകൾ ഹോസ്റ്റിലെയും കണ്ടെയ്‌നർ നെയിംസ്‌പെയ്‌സിലെയും മാറ്റങ്ങൾ തമ്മിലുള്ള ബന്ധം നിർവ്വചിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു ലിങ്ക് ചെയ്‌ത മൗണ്ടിന് ഒന്നുകിൽ ഇതിലേക്കുള്ള മാറ്റങ്ങൾ ഒഴിവാക്കാനാകും /proc и /sys കണ്ടെയ്നറിലേക്ക്, അല്ലെങ്കിൽ കോളിനെ ആശ്രയിച്ച് അവ മറയ്ക്കുക.

തീരുമാനം

സി ലൈബ്രറികളിലെ ലിനക്സ് യൂസർ സ്പേസ് ആപ്ലിക്കേഷനുകളും സിസ്റ്റം കോൾ ഇന്റർഫേസുകളും മാറ്റിവച്ച്, കേർണലിൽ തന്നെ ഒരു വലിയ അളവിലുള്ള കോഡ് അടങ്ങിയിരിക്കുന്നതിനാൽ, ലിനക്സിന്റെ ആന്തരിക പ്രവർത്തനങ്ങൾ മനസ്സിലാക്കുന്നത് അസാധ്യമായ കാര്യമായി തോന്നാം. glibc. ഒരു കേർണൽ സബ്സിസ്റ്റത്തിന്റെ സോഴ്സ് കോഡ് വായിക്കുക എന്നതാണ് പുരോഗതി കൈവരിക്കാനുള്ള ഒരു മാർഗ്ഗം, സിസ്റ്റം കോളുകളും യൂസർ-സ്പേസ് ഹെഡറുകളും അതുപോലെ തന്നെ ടേബിൾ പോലുള്ള പ്രധാന ആന്തരിക കേർണൽ ഇന്റർഫേസുകളും മനസ്സിലാക്കുന്നതിൽ ഊന്നൽ നൽകുന്നു. file_operations. ഫയൽ പ്രവർത്തനങ്ങൾ "എല്ലാം ഒരു ഫയലാണ്" എന്ന തത്വം നൽകുന്നു, അവ കൈകാര്യം ചെയ്യുന്നത് പ്രത്യേകിച്ചും ആസ്വാദ്യകരമാക്കുന്നു. സി കേർണൽ സോഴ്സ് ഫയലുകൾ ഉയർന്ന തലത്തിലുള്ള ഡയറക്‌ടറിയിൽ fs/ ജനപ്രിയ ഫയൽ സിസ്റ്റങ്ങളും സ്റ്റോറേജ് ഡിവൈസുകളും തമ്മിൽ വിശാലവും താരതമ്യേന ലളിതവുമായ അനുയോജ്യത പ്രദാനം ചെയ്യുന്ന ഒരു റാപ്പർ ലെയറായ വെർച്വൽ ഫയൽ സിസ്റ്റങ്ങളുടെ ഒരു നടപ്പിലാക്കൽ അവതരിപ്പിക്കുന്നു. ലിനക്‌സ് നെയിംസ്‌പേസുകൾ വഴിയുള്ള ലിങ്കിംഗും ഓവർലേ മൗണ്ടിംഗും VFS-ന്റെ മാന്ത്രികതയാണ്, അത് റീഡ്-ഒൺലി കണ്ടെയ്‌നറുകളും റൂട്ട് ഫയൽ സിസ്റ്റങ്ങളും സൃഷ്ടിക്കുന്നത് സാധ്യമാക്കുന്നു. സോഴ്സ് കോഡ്, eBPF കോർ ടൂൾ, അതിന്റെ ഇന്റർഫേസ് എന്നിവയുടെ പരിശോധനയുമായി സംയോജിപ്പിച്ചിരിക്കുന്നു bcc
പ്രധാന പര്യവേക്ഷണം എന്നത്തേക്കാളും എളുപ്പമാക്കുന്നു.

സുഹൃത്തുക്കളേ, എഴുതൂ, ഈ ലേഖനം നിങ്ങൾക്ക് ഉപയോഗപ്രദമായിരുന്നോ? ഒരുപക്ഷേ നിങ്ങൾക്ക് എന്തെങ്കിലും അഭിപ്രായങ്ങളോ അഭിപ്രായങ്ങളോ ഉണ്ടോ? ഒപ്പം ലിനക്സ് അഡ്മിനിസ്ട്രേറ്റർ കോഴ്സിൽ താല്പര്യമുള്ളവരെ ക്ഷണിക്കുന്നു തുറന്ന ദിവസം, അത് ഏപ്രിൽ 18 ന് നടക്കും.

ആദ്യ ഭാഗം.

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