ഉദാഹരണങ്ങൾക്കൊപ്പം ലിനക്സിലെ ഫയൽ ഡിസ്ക്രിപ്റ്റർ

ഒരിക്കൽ, ഒരു അഭിമുഖത്തിനിടെ, എന്നോട് ചോദിച്ചു, ഡിസ്കിൽ സ്ഥലമില്ലാതായതിനാൽ പ്രവർത്തിക്കാത്ത ഒരു സേവനം നിങ്ങൾ കണ്ടെത്തിയാൽ നിങ്ങൾ എന്തുചെയ്യും?

തീർച്ചയായും, ഈ സ്ഥലം എന്താണെന്ന് ഞാൻ കാണാമെന്നും, സാധ്യമെങ്കിൽ, ഞാൻ സ്ഥലം വൃത്തിയാക്കുമെന്നും ഞാൻ മറുപടി നൽകി.
അപ്പോൾ ഇന്റർവ്യൂ ചെയ്യുന്നയാൾ ചോദിച്ചു, പാർട്ടീഷനിൽ ശൂന്യമായ ഇടമില്ലെങ്കിലോ, എന്നാൽ മുഴുവൻ സ്ഥലവും എടുക്കുന്ന ഫയലുകളൊന്നും നിങ്ങൾ കാണുന്നില്ലെങ്കിലോ?

ഇതിനോട് ഞാൻ പറഞ്ഞു, നിങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഓപ്പൺ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ നോക്കാം, ഉദാഹരണത്തിന് lsof കമാൻഡ് ഉപയോഗിച്ച്, ലഭ്യമായ എല്ലാ സ്ഥലവും ഏത് ആപ്ലിക്കേഷനാണ് എടുത്തതെന്ന് മനസിലാക്കുക, തുടർന്ന് ഡാറ്റ ആവശ്യമാണോ എന്നതിനെ ആശ്രയിച്ച് നിങ്ങൾക്ക് സാഹചര്യങ്ങൾക്കനുസരിച്ച് പ്രവർത്തിക്കാം. .

അഭിമുഖം നടത്തുന്നയാൾ അവസാന വാക്കിൽ എന്നെ തടസ്സപ്പെടുത്തി, അവന്റെ ചോദ്യത്തോട് ചേർത്തു: "നമുക്ക് ഡാറ്റ ആവശ്യമില്ലെന്ന് കരുതുക, ഇത് ഒരു ഡീബഗ് ലോഗ് മാത്രമാണ്, പക്ഷേ ഒരു ഡീബഗ് എഴുതാൻ കഴിയാത്തതിനാൽ ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുന്നില്ല"?

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

“ശരി,” ഞാൻ പറഞ്ഞു, “നമുക്ക് ആപ്ലിക്കേഷൻ പുനരാരംഭിക്കാൻ കഴിയുന്നില്ലെങ്കിൽ, ഡാറ്റ ഞങ്ങൾക്ക് പ്രധാനമല്ലെങ്കിൽ, ls കമാൻഡിൽ ഇത് കാണുന്നില്ലെങ്കിൽപ്പോലും, ഫയൽ ഡിസ്ക്രിപ്റ്ററിലൂടെ ഈ തുറന്ന ഫയൽ ക്ലിയർ ചെയ്യാം. ഫയൽ സിസ്റ്റത്തിൽ."

അഭിമുഖം നടത്തിയയാൾ സന്തോഷിച്ചു, പക്ഷേ ഞാൻ അങ്ങനെയായിരുന്നില്ല.

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

തുസിക്ക്

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

ഫയൽ ഡിസ്ക്രിപ്റ്റർ

ഈ ഫയലിനൊപ്പം പ്രവർത്തിക്കുന്ന ഫയലിന്റെയും പ്രോഗ്രാമിന്റെയും പ്രശ്‌നം നമ്മുടെ നായയുടെയും മനുഷ്യന്റെയും ഏകദേശം തുല്യമാണ്. ഞാൻ ivan.txt എന്ന ഒരു ഫയൽ തുറന്ന് അതിൽ tuzik എന്ന വാക്ക് എഴുതാൻ തുടങ്ങി, പക്ഷേ ഫയലിൽ "t" എന്ന ആദ്യ അക്ഷരം എഴുതാൻ മാത്രമേ എനിക്ക് കഴിഞ്ഞുള്ളൂ, ഈ ഫയലിനെ ആരെങ്കിലും പുനർനാമകരണം ചെയ്തു, ഉദാഹരണത്തിന്, olya.txt. എന്നാൽ ഫയൽ അതേപടി തുടരുന്നു, എന്റെ എയ്‌സ് ഇപ്പോഴും അതിൽ രേഖപ്പെടുത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഓരോ തവണയും ഒരു സിസ്റ്റം കോൾ വഴി ഒരു ഫയൽ തുറക്കുന്നു തുറക്കുക ഏതൊരു പ്രോഗ്രാമിംഗ് ഭാഷയിലും എനിക്ക് ഒരു ഫയലിലേക്ക് എന്നെ ചൂണ്ടിക്കാണിക്കുന്ന ഒരു അദ്വിതീയ ഐഡി ലഭിക്കുന്നു, ഈ ഐഡിയാണ് ഫയൽ ഡിസ്ക്രിപ്റ്റർ. ഈ ഫയൽ അടുത്തതായി എന്ത് ചെയ്യുന്നു, ആരാണ് ചെയ്യുന്നത് എന്നത് പ്രശ്നമല്ല, ഇത് ഇല്ലാതാക്കാം, പേരുമാറ്റാം, ഉടമയെ മാറ്റാം, അല്ലെങ്കിൽ എഴുതാനും വായിക്കാനുമുള്ള അവകാശങ്ങൾ എടുത്തുകളയാം, എനിക്ക് ഇപ്പോഴും ആക്‌സസ് ഉണ്ടായിരിക്കും അതിലേക്ക്, കാരണം ഫയൽ തുറക്കുന്ന സമയത്ത്, അത് വായിക്കാനും/അല്ലെങ്കിൽ എഴുതാനുമുള്ള അവകാശം എനിക്കുണ്ടായിരുന്നു, അത് ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ എനിക്ക് കഴിഞ്ഞു, അതായത് ഞാൻ അത് തുടരണം.

ലിനക്സിൽ, പ്രവർത്തിക്കുന്ന ഓരോ ആപ്ലിക്കേഷനും (പ്രോസസ്സ്) 3 എന്ന നമ്പറുള്ള 0,1,2 ഡിസ്ക്രിപ്റ്റർ ഫയലുകൾ libc ലൈബ്രറി തുറക്കുന്നു. കൂടുതൽ വിവരങ്ങൾ ലിങ്കുകളിൽ കാണാം മനുഷ്യൻ stdio и മനുഷ്യൻ stdout

• ഫയൽ ഡിസ്ക്രിപ്റ്റർ 0-നെ STDIN എന്ന് വിളിക്കുന്നു, ഇത് ആപ്ലിക്കേഷൻ ഇൻപുട്ടുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു
• ഫയൽ ഡിസ്ക്രിപ്റ്റർ 1-നെ STDOUT എന്ന് വിളിക്കുന്നു, പ്രിന്റ് കമാൻഡുകൾ പോലുള്ള ഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യുന്നതിന് ആപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുന്നു
• ഫയൽ ഡിസ്ക്രിപ്റ്റർ 2-നെ STDERR എന്ന് വിളിക്കുന്നു, പിശക് സന്ദേശങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യാൻ ആപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുന്നു.

നിങ്ങളുടെ പ്രോഗ്രാമിൽ നിങ്ങൾ വായിക്കുന്നതിനോ എഴുതുന്നതിനോ ഏതെങ്കിലും ഫയൽ തുറക്കുകയാണെങ്കിൽ, മിക്കവാറും നിങ്ങൾക്ക് ആദ്യത്തെ സൗജന്യ ഐഡി ലഭിക്കും, അത് നമ്പർ 3 ആയിരിക്കും.

നിങ്ങൾക്ക് അതിന്റെ PID അറിയാമെങ്കിൽ, ഏത് പ്രക്രിയയ്ക്കും ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളുടെ ലിസ്റ്റ് കാണാൻ കഴിയും.

ഉദാഹരണത്തിന്, നമുക്ക് ബാഷ് കൺസോൾ തുറന്ന് നമ്മുടെ പ്രക്രിയയുടെ PID നോക്കാം

[user@localhost ]$ echo $$
15771

രണ്ടാമത്തെ കൺസോളിൽ നമുക്ക് പ്രവർത്തിപ്പിക്കാം

[user@localhost ]$ ls -lah /proc/15771/fd/
total 0
dr-x------ 2 user user  0 Oct  7 15:42 .
dr-xr-xr-x 9 user user  0 Oct  7 15:42 ..
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21

ഈ ലേഖനത്തിന്റെ ഉദ്ദേശ്യങ്ങൾക്കായി നിങ്ങൾക്ക് ഫയൽ ഡിസ്ക്രിപ്റ്റർ നമ്പർ 255 സുരക്ഷിതമായി അവഗണിക്കാം; ഇത് അതിന്റെ ആവശ്യങ്ങൾക്കായി തുറന്നത് ബാഷ് വഴിയാണ്, അല്ലാതെ ലിങ്ക് ചെയ്ത ലൈബ്രറിയല്ല.

ഇപ്പോൾ എല്ലാ 3 ഡിസ്ക്രിപ്റ്റർ ഫയലുകളും സ്യൂഡോ ടെർമിനൽ ഉപകരണവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു /dev/pts, എന്നാൽ നമുക്ക് അവ ഇപ്പോഴും കൈകാര്യം ചെയ്യാൻ കഴിയും, ഉദാഹരണത്തിന്, രണ്ടാമത്തെ കൺസോളിൽ അവ പ്രവർത്തിപ്പിക്കുക

[user@localhost ]$ echo "hello world" > /proc/15771/fd/0

ആദ്യത്തെ കൺസോളിൽ നമുക്ക് കാണാം

[user@localhost ]$ hello world

റീഡയറക്‌ടും പൈപ്പും

ബാഷ് ഉൾപ്പെടെ ഏത് പ്രക്രിയയിലും നിങ്ങൾക്ക് ഈ 3 ഡിസ്ക്രിപ്റ്റർ ഫയലുകൾ എളുപ്പത്തിൽ അസാധുവാക്കാനാകും, ഉദാഹരണത്തിന് രണ്ട് പ്രക്രിയകളെ ബന്ധിപ്പിക്കുന്ന ഒരു പൈപ്പ് വഴി, കാണുക.

[user@localhost ]$ cat /dev/zero | sleep 10000

നിങ്ങൾക്ക് ഈ കമാൻഡ് ഉപയോഗിച്ച് സ്വയം പ്രവർത്തിപ്പിക്കാൻ കഴിയും സ്‌ട്രേസ് -എഫ് അകത്ത് എന്താണ് സംഭവിക്കുന്നതെന്ന് കാണുക, പക്ഷേ ഞാൻ നിങ്ങളോട് ചുരുക്കമായി പറയാം.

PID 15771 ഉള്ള ഞങ്ങളുടെ പാരന്റ് ബാഷ് പ്രോസസ്സ് ഞങ്ങളുടെ കമാൻഡ് പാഴ്‌സ് ചെയ്യുകയും എത്ര കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കണമെന്ന് കൃത്യമായി മനസ്സിലാക്കുകയും ചെയ്യുന്നു, ഞങ്ങളുടെ കാര്യത്തിൽ അവയിൽ രണ്ടെണ്ണം ഉണ്ട്: പൂച്ചയും ഉറക്കവും. രണ്ട് ചൈൽഡ് പ്രോസസ്സുകൾ സൃഷ്ടിക്കേണ്ടതുണ്ടെന്നും അവയെ ഒരു പൈപ്പിലേക്ക് ലയിപ്പിക്കേണ്ടതുണ്ടെന്നും ബാഷിന് അറിയാം. മൊത്തത്തിൽ, ബാഷിന് 2 ചൈൽഡ് പ്രോസസ്സുകളും ഒരു പൈപ്പും ആവശ്യമാണ്.

ചൈൽഡ് പ്രോസസ്സുകൾ സൃഷ്ടിക്കുന്നതിന് മുമ്പ് ബാഷ് ഒരു സിസ്റ്റം കോൾ പ്രവർത്തിപ്പിക്കുന്നു പൈപ്പ് കൂടാതെ താൽക്കാലിക പൈപ്പ് ബഫറിൽ പുതിയ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ സ്വീകരിക്കുന്നു, എന്നാൽ ഈ ബഫർ ഇതുവരെ ഞങ്ങളുടെ രണ്ട് ചൈൽഡ് പ്രോസസുകളെ ബന്ധിപ്പിച്ചിട്ടില്ല.

പാരന്റ് പ്രോസസിനായി, ഇതിനകം ഒരു പൈപ്പ് ഉണ്ടെന്ന് തോന്നുന്നു, പക്ഷേ ഇതുവരെ ചൈൽഡ് പ്രോസസ്സുകളൊന്നുമില്ല:

PID    command
15771  bash
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21

തുടർന്ന് സിസ്റ്റം കോൾ ഉപയോഗിക്കുന്നു ക്ലോൺ ബാഷ് രണ്ട് ചൈൽഡ് പ്രോസസ്സുകൾ സൃഷ്ടിക്കുന്നു, ഞങ്ങളുടെ മൂന്ന് പ്രക്രിയകൾ ഇതുപോലെ കാണപ്പെടും:

PID    command
15771  bash
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21
PID    command
9004  bash
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 255 -> /dev/pts/21
PID    command
9005  bash
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 3 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 4 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 255 -> /dev/pts/21

എല്ലാ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളോടൊപ്പം ക്ലോൺ പ്രക്രിയ ക്ലോൺ ചെയ്യുമെന്ന കാര്യം മറക്കരുത്, അതിനാൽ അവ രക്ഷാകർതൃ പ്രക്രിയയിലും കുട്ടിയിലും സമാനമായിരിക്കും. PID 15771 ഉള്ള പാരന്റ് പ്രോസസിന്റെ ജോലി ചൈൽഡ് പ്രോസസ്സുകൾ നിരീക്ഷിക്കുക എന്നതാണ്, അതിനാൽ ഇത് കുട്ടികളിൽ നിന്നുള്ള പ്രതികരണത്തിനായി കാത്തിരിക്കുന്നു.

അതിനാൽ, ഇതിന് പൈപ്പ് ആവശ്യമില്ല, കൂടാതെ ഇത് 3, 4 നമ്പറുകളുള്ള ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ അടയ്ക്കുന്നു.

PID 9004 ഉപയോഗിച്ചുള്ള ആദ്യ ചൈൽഡ് ബാഷ് പ്രക്രിയയിൽ, സിസ്റ്റം കോൾ ഡ്യൂപ്പ്2, ഞങ്ങളുടെ STDOUT ഫയൽ ഡിസ്ക്രിപ്റ്റർ നമ്പർ 1 പൈപ്പിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്ന ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്ററായി മാറ്റുന്നു, ഞങ്ങളുടെ കാര്യത്തിൽ ഇത് നമ്പർ 3 ആണ്. അങ്ങനെ, PID 9004 ഉപയോഗിച്ച് ആദ്യത്തെ ചൈൽഡ് പ്രോസസ്സ് STDOUT-ലേക്ക് എഴുതുന്നതെല്ലാം പൈപ്പ് ബഫറിൽ സ്വയമേവ അവസാനിക്കും.

PID 9005 ഉള്ള രണ്ടാമത്തെ ചൈൽഡ് പ്രോസസ്സിൽ, ഫയൽ ഡിസ്ക്രിപ്റ്റർ STDIN നമ്പർ 2 മാറ്റാൻ bash dup0 ഉപയോഗിക്കുന്നു. ഇപ്പോൾ PID 9005 ഉള്ള ഞങ്ങളുടെ രണ്ടാമത്തെ ബാഷ് വായിക്കുന്നതെല്ലാം പൈപ്പിൽ നിന്ന് വായിക്കപ്പെടും.

ഇതിനുശേഷം, 3, 4 നമ്പറുകളുള്ള ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളും ചൈൽഡ് പ്രോസസ്സുകളിൽ അടച്ചിരിക്കുന്നു, കാരണം അവ മേലിൽ ഉപയോഗിക്കില്ല.

ഫയൽ ഡിസ്ക്രിപ്റ്റർ 255 ഞാൻ മനഃപൂർവ്വം അവഗണിക്കുന്നു; ഇത് ബാഷ് മുഖേന തന്നെ ആന്തരിക ആവശ്യങ്ങൾക്കായി ഉപയോഗിക്കുന്നു, ചൈൽഡ് പ്രോസസുകളിലും ഇത് അടച്ചിരിക്കും.

അടുത്തതായി, PID 9004 ഉപയോഗിച്ചുള്ള ആദ്യ ചൈൽഡ് പ്രോസസ്സിൽ, ബാഷ് ഒരു സിസ്റ്റം കോൾ ഉപയോഗിച്ച് തുടങ്ങുന്നു exec കമാൻഡ് ലൈനിൽ ഞങ്ങൾ വ്യക്തമാക്കിയ എക്സിക്യൂട്ടബിൾ ഫയൽ, ഞങ്ങളുടെ കാര്യത്തിൽ അത് /usr/bin/cat ആണ്.

PID 9005 ഉള്ള രണ്ടാമത്തെ ചൈൽഡ് പ്രോസസ്സിൽ, ഞങ്ങളുടെ കാര്യത്തിൽ /usr/bin/sleep-ൽ ഞങ്ങൾ വ്യക്തമാക്കിയ രണ്ടാമത്തെ എക്സിക്യൂട്ടബിൾ ബാഷ് പ്രവർത്തിപ്പിക്കുന്നു.

ഓപ്പൺ കോൾ ചെയ്ത സമയത്ത് O_CLOEXEC ഫ്ലാഗ് ഉപയോഗിച്ച് തുറന്നില്ലെങ്കിൽ എക്‌സിക് സിസ്റ്റം കോൾ ഫയൽ ഹാൻഡിലുകളെ ക്ലോസ് ചെയ്യില്ല. ഞങ്ങളുടെ കാര്യത്തിൽ, എക്സിക്യൂട്ടബിൾ ഫയലുകൾ സമാരംഭിച്ച ശേഷം, നിലവിലുള്ള എല്ലാ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളും സംരക്ഷിക്കപ്പെടും.

കൺസോളിൽ പരിശോധിക്കുക:

[user@localhost ]$ pgrep -P 15771
9004
9005
[user@localhost ]$ ls -lah /proc/15771/fd/
total 0
dr-x------ 2 user user  0 Oct  7 15:42 .
dr-xr-xr-x 9 user user  0 Oct  7 15:42 ..
lrwx------ 1 user user 64 Oct  7 15:42 0 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 2 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:42 255 -> /dev/pts/21
[user@localhost ]$ ls -lah /proc/9004/fd
total 0
dr-x------ 2 user user  0 Oct  7 15:57 .
dr-xr-xr-x 9 user user  0 Oct  7 15:57 ..
lrwx------ 1 user user 64 Oct  7 15:57 0 -> /dev/pts/21
l-wx------ 1 user user 64 Oct  7 15:57 1 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
lr-x------ 1 user user 64 Oct  7 15:57 3 -> /dev/zero
[user@localhost ]$ ls -lah /proc/9005/fd
total 0
dr-x------ 2 user user  0 Oct  7 15:57 .
dr-xr-xr-x 9 user user  0 Oct  7 15:57 ..
lr-x------ 1 user user 64 Oct  7 15:57 0 -> pipe:[253543032]
lrwx------ 1 user user 64 Oct  7 15:57 1 -> /dev/pts/21
lrwx------ 1 user user 64 Oct  7 15:57 2 -> /dev/pts/21
[user@localhost ]$ ps -up 9004
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user  9004  0.0  0.0 107972   620 pts/21   S+   15:57   0:00 cat /dev/zero
[user@localhost ]$ ps -up 9005
USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
user  9005  0.0  0.0 107952   360 pts/21   S+   15:57   0:00 sleep 10000

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, രണ്ട് പ്രക്രിയകളിലും ഞങ്ങളുടെ പൈപ്പിന്റെ അദ്വിതീയ നമ്പർ തുല്യമാണ്. അതിനാൽ ഒരേ രക്ഷകർത്താവുമായി രണ്ട് വ്യത്യസ്ത പ്രക്രിയകൾ തമ്മിൽ നമുക്ക് ബന്ധമുണ്ട്.

ബാഷ് ഉപയോഗിക്കുന്ന സിസ്റ്റം കോളുകൾ പരിചിതമല്ലാത്തവർക്ക്, കമാൻഡുകൾ സ്‌ട്രേസിലൂടെ പ്രവർത്തിപ്പിക്കാനും ആന്തരികമായി എന്താണ് സംഭവിക്കുന്നതെന്ന് കാണാനും ഞാൻ വളരെ ശുപാർശ ചെയ്യുന്നു, ഉദാഹരണത്തിന് ഇതുപോലെ:

strace -s 1024 -f bash -c "ls | grep hello"

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

[user@localhost ]$ cat openforwrite.py 
import datetime
import time

mystr="a"*1024*1024+"n"
with open("123.txt", "w") as f:
    while True:
        try:
            f.write(str(datetime.datetime.now()))
            f.write(mystr)
            f.flush()
            time.sleep(1)
        except:
            pass

നമുക്ക് പ്രോഗ്രാം പ്രവർത്തിപ്പിച്ച് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ നോക്കാം

[user@localhost ]$ python openforwrite.py &
[1] 3762
[user@localhost ]$ ps axuf | grep [o]penforwrite
user  3762  0.0  0.0 128600  5744 pts/22   S+   16:28   0:00  |   _ python openforwrite.py
[user@localhost ]$ ls -la /proc/3762/fd
total 0
dr-x------ 2 user user  0 Oct  7 16:29 .
dr-xr-xr-x 9 user user  0 Oct  7 16:29 ..
lrwx------ 1 user user 64 Oct  7 16:29 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  7 16:29 3 -> /home/user/123.txt

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഞങ്ങളുടെ 3 സ്റ്റാൻഡേർഡ് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകളും ഞങ്ങൾ തുറന്ന ഒന്ന് കൂടി ഉണ്ട്. നമുക്ക് ഫയൽ വലുപ്പം പരിശോധിക്കാം:

[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 user user 117M Oct  7 16:30 123.txt

ഡാറ്റ എഴുതുന്നു, ഫയലിലെ അനുമതികൾ മാറ്റാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു:

[user@localhost ]$ sudo chown root: 123.txt
[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 root root 168M Oct  7 16:31 123.txt
[user@localhost ]$ ls -lah 123.txt 
-rw-rw-r-- 1 root root 172M Oct  7 16:31 123.txt

ഫയലിൽ എഴുതാൻ ഞങ്ങളുടെ ഉപയോക്താവിന് അനുമതിയില്ലെങ്കിലും ഡാറ്റ ഇപ്പോഴും എഴുതുന്നത് ഞങ്ങൾ കാണുന്നു. അത് നീക്കം ചെയ്യാൻ ശ്രമിക്കാം:

[user@localhost ]$ sudo rm 123.txt 
[user@localhost ]$ ls 123.txt
ls: cannot access 123.txt: No such file or directory

ഡാറ്റ എവിടെയാണ് എഴുതിയിരിക്കുന്നത്? അവ എഴുതപ്പെട്ടതാണോ? ഞങ്ങൾ പരിശോധിക്കുന്നു:

[user@localhost ]$ ls -la /proc/3762/fd
total 0
dr-x------ 2 user user  0 Oct  7 16:29 .
dr-xr-xr-x 9 user user  0 Oct  7 16:29 ..
lrwx------ 1 user user 64 Oct  7 16:29 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  7 16:29 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  7 16:29 3 -> /home/user/123.txt (deleted)

അതെ, ഞങ്ങളുടെ ഫയൽ ഡിസ്ക്രിപ്റ്റർ ഇപ്പോഴും നിലവിലുണ്ട്, ഞങ്ങൾക്ക് ഈ ഫയൽ ഡിസ്ക്രിപ്റ്ററിനെ ഞങ്ങളുടെ പഴയ ഫയൽ പോലെ പരിഗണിക്കാം, നമുക്ക് ഇത് വായിക്കാനും മായ്‌ക്കാനും പകർത്താനും കഴിയും.

ഫയൽ വലുപ്പം നോക്കാം:

[user@localhost ]$ lsof | grep 123.txt
python    31083             user    3w      REG                8,5   19923457   2621522 /home/user/123.txt

ഫയൽ വലുപ്പം 19923457 ആണ്. ഫയൽ മായ്ക്കാൻ ശ്രമിക്കാം:

[user@localhost ]$ truncate -s 0 /proc/31083/fd/3
[user@localhost ]$ lsof | grep 123.txt
python    31083             user    3w      REG                8,5  136318390   2621522 /home/user/123.txt

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

with open("123.txt", "w") as f:

ഞങ്ങൾ ഇടണം

with open("123.txt", "a") as f:

"w" ഫ്ലാഗ് ഉപയോഗിച്ച് പരിശോധിക്കുന്നു

[user@localhost ]$ strace -e trace=open python openforwrite.py 2>&1| grep 123.txt
open("123.txt", O_WRONLY|O_CREAT|O_TRUNC, 0666) = 3

ഒപ്പം "എ" പതാകയും

[user@localhost ]$ strace -e trace=open python openforwrite.py 2>&1| grep 123.txt
open("123.txt", O_WRONLY|O_CREAT|O_APPEND, 0666) = 3

ഇതിനകം പ്രവർത്തിക്കുന്ന ഒരു പ്രക്രിയ പ്രോഗ്രാമിംഗ്

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

ഒരു ഫയൽ എഴുതാൻ മതിയായ ഡിസ്കിൽ ഇടമില്ല എന്ന യഥാർത്ഥ ചോദ്യത്തിലേക്ക് മടങ്ങുമ്പോൾ, പ്രശ്നം അനുകരിക്കാൻ ശ്രമിക്കാം.

നമ്മുടെ പാർട്ടീഷനായി നമുക്ക് ഒരു ഫയൽ ഉണ്ടാക്കാം, അത് നമ്മൾ ഒരു പ്രത്യേക ഡിസ്കായി മൌണ്ട് ചെയ്യും:

[user@localhost ~]$ dd if=/dev/zero of=~/tempfile_for_article.dd bs=1M count=10
10+0 records in
10+0 records out
10485760 bytes (10 MB) copied, 0.00525929 s, 2.0 GB/s
[user@localhost ~]$

നമുക്ക് ഒരു ഫയൽ സിസ്റ്റം ഉണ്ടാക്കാം:

[user@localhost ~]$ mkfs.ext4 ~/tempfile_for_article.dd
mke2fs 1.42.9 (28-Dec-2013)
/home/user/tempfile_for_article.dd is not a block special device.
Proceed anyway? (y,n) y
...
Writing superblocks and filesystem accounting information: done
[user@localhost ~]$

ഫയൽ സിസ്റ്റം മൌണ്ട് ചെയ്യുക:

[user@localhost ~]$ sudo mount ~/tempfile_for_article.dd /mnt/
[sudo] password for user: 
[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  172K  7.9M   3% /mnt

ഞങ്ങളുടെ ഉടമയുമായി ഞങ്ങൾ ഒരു ഡയറക്ടറി സൃഷ്ടിക്കുന്നു:

[user@localhost ~]$ sudo mkdir /mnt/logs
[user@localhost ~]$ sudo chown user: /mnt/logs

നമ്മുടെ പ്രോഗ്രാമിൽ മാത്രം എഴുതാൻ ഫയൽ തുറക്കാം:

with open("/mnt/logs/123.txt", "w") as f:

ലോഞ്ച്

[user@localhost ]$ python openforwrite.py 

ഞങ്ങൾ കുറച്ച് നിമിഷങ്ങൾ കാത്തിരിക്കുന്നു

[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  8.0M     0 100% /mnt

അതിനാൽ, ഈ ലേഖനത്തിന്റെ തുടക്കത്തിൽ വിവരിച്ച പ്രശ്നം ഞങ്ങൾക്കുണ്ട്. ശൂന്യമായ ഇടം 0, 100% അധിനിവേശം.

ടാസ്ക്കിന്റെ വ്യവസ്ഥകൾക്കനുസൃതമായി, നഷ്‌ടപ്പെടാൻ കഴിയാത്ത വളരെ പ്രധാനപ്പെട്ട ഡാറ്റ രേഖപ്പെടുത്താൻ ഞങ്ങൾ ശ്രമിക്കുന്നുണ്ടെന്ന് ഞങ്ങൾ ഓർക്കുന്നു. അതേ സമയം, പ്രോസസ്സ് പുനരാരംഭിക്കാതെ തന്നെ ഞങ്ങൾ സേവനം ശരിയാക്കേണ്ടതുണ്ട്.

നമുക്ക് ഇപ്പോഴും ഡിസ്ക് സ്പേസ് ഉണ്ടെന്ന് പറയാം, എന്നാൽ മറ്റൊരു പാർട്ടീഷനിൽ, ഉദാഹരണത്തിന് /home ൽ.

നമ്മുടെ കോഡ് "ഈച്ചയിൽ റീപ്രോഗ്രാം" ചെയ്യാൻ ശ്രമിക്കാം.

ഡിസ്കിലെ മുഴുവൻ സ്ഥലവും നശിപ്പിച്ച ഞങ്ങളുടെ പ്രക്രിയയുടെ PID നോക്കാം:

[user@localhost ~]$ ps axuf | grep [o]penfor
user 10078 27.2  0.0 128600  5744 pts/22   R+   11:06   0:02  |   _ python openforwrite.py

ജിഡിബി വഴി പ്രോസസ്സിലേക്ക് കണക്റ്റുചെയ്യുക

[user@localhost ~]$ gdb -p 10078
...
(gdb) 

ഓപ്പൺ ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ നോക്കാം:

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /mnt/logs/123.txt

ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ള ഫയൽ ഡിസ്ക്രിപ്റ്റർ നമ്പർ 3 നെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഞങ്ങൾ നോക്കുന്നു

(gdb) shell cat /proc/10078/fdinfo/3
pos:    8189952
flags:  0100001
mnt_id: 482

പൈത്തൺ എന്ത് സിസ്റ്റം കോൾ ഉണ്ടാക്കുന്നു എന്നത് മനസ്സിൽ വെച്ചുകൊണ്ട് (മുകളിൽ എവിടെയാണ് ഞങ്ങൾ സ്‌ട്രെയിസ് ഓപ്പൺ ചെയ്ത് ഓപ്പൺ കോൾ കണ്ടെത്തിയതെന്ന് കാണുക), ഒരു ഫയൽ തുറക്കാൻ ഞങ്ങളുടെ കോഡ് പ്രോസസ്സ് ചെയ്യുമ്പോൾ, ഞങ്ങളുടെ പ്രോസസിന് വേണ്ടി ഞങ്ങൾ തന്നെ അത് തന്നെ ചെയ്യുന്നു, പക്ഷേ ഞങ്ങൾക്ക് O_WRONLY|O_CREAT| O_TRUNC ബിറ്റുകൾ ഒരു സംഖ്യാ മൂല്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ഇത് ചെയ്യുന്നതിന്, ഉദാഹരണത്തിന്, കേർണൽ ഉറവിടങ്ങൾ തുറക്കുക ഇവിടെ ഏതൊക്കെ പതാകകളാണ് എന്തിന് ഉത്തരവാദികളെന്ന് നോക്കുക

#തെറ്റായ 00000001 നിർവചിക്കുക
#O_CREAT 00000100 നിർവ്വചിക്കുക
#O_TRUNC 00001000 നിർവചിക്കുക

ഞങ്ങൾ എല്ലാ മൂല്യങ്ങളും ഒന്നായി സംയോജിപ്പിക്കുന്നു, ഞങ്ങൾക്ക് 00001101 ലഭിക്കും

ഞങ്ങൾ gdb-യിൽ നിന്ന് ഞങ്ങളുടെ കോൾ പ്രവർത്തിപ്പിക്കുന്നു

(gdb) call open("/home/user/123.txt", 00001101,0666)
$1 = 4

അതിനാൽ ഞങ്ങൾക്ക് നമ്പർ 4 ഉള്ള ഒരു പുതിയ ഫയൽ ഡിസ്ക്രിപ്റ്ററും മറ്റൊരു പാർട്ടീഷനിൽ ഒരു പുതിയ ഓപ്പൺ ഫയലും ലഭിച്ചു, ഞങ്ങൾ പരിശോധിക്കുന്നു:

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /mnt/logs/123.txt
l-wx------ 1 user user 64 Oct  8 11:15 4 -> /home/user/123.txt

പൈപ്പ് ഉപയോഗിച്ചുള്ള ഉദാഹരണം ഞങ്ങൾ ഓർക്കുന്നു - ബാഷ് ഫയൽ ഡിസ്ക്രിപ്റ്ററുകൾ എങ്ങനെ മാറ്റുന്നു, ഞങ്ങൾ ഇതിനകം തന്നെ dup2 സിസ്റ്റം കോൾ പഠിച്ചു.

ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ മറ്റൊന്നുമായി മാറ്റിസ്ഥാപിക്കാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു

(gdb) call dup2(4,3)
$2 = 3

ഞങ്ങൾ പരിശോധിക്കുന്നു:

(gdb) shell ls -lah /proc/10078/fd/
total 0
dr-x------ 2 user user  0 Oct  8 11:06 .
dr-xr-xr-x 9 user user  0 Oct  8 11:06 ..
lrwx------ 1 user user 64 Oct  8 11:09 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:09 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:06 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:09 3 -> /home/user/123.txt
l-wx------ 1 user user 64 Oct  8 11:15 4 -> /home/user/123.txt

ഞങ്ങൾക്ക് ഇത് ആവശ്യമില്ലാത്തതിനാൽ ഞങ്ങൾ ഫയൽ ഡിസ്ക്രിപ്റ്റർ 4 അടയ്ക്കുന്നു:

(gdb) call close (4)
$1 = 0

ഒപ്പം ജിഡിബിയിൽ നിന്ന് പുറത്തുകടക്കുക

(gdb) quit
A debugging session is active.

    Inferior 1 [process 10078] will be detached.

Quit anyway? (y or n) y
Detaching from program: /usr/bin/python2.7, process 10078

പുതിയ ഫയൽ പരിശോധിക്കുന്നു:

[user@localhost ~]$ ls -lah /home/user/123.txt
-rw-rw-r-- 1 user user 5.1M Oct  8 11:18 /home/user/123.txt
[user@localhost ~]$ ls -lah /home/user/123.txt
-rw-rw-r-- 1 user user 7.1M Oct  8 11:18 /home/user/123.txt

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഡാറ്റ ഒരു പുതിയ ഫയലിലേക്ക് എഴുതിയിരിക്കുന്നു, നമുക്ക് പഴയത് പരിശോധിക്കാം:

[user@localhost ~]$ ls -lah /mnt/logs/123.txt 
-rw-rw-r-- 1 user user 7.9M Oct  8 11:08 /mnt/logs/123.txt

ഡാറ്റയൊന്നും നഷ്‌ടപ്പെടുന്നില്ല, ആപ്ലിക്കേഷൻ പ്രവർത്തിക്കുന്നു, ലോഗുകൾ ഒരു പുതിയ സ്ഥലത്തേക്ക് എഴുതുന്നു.

നമുക്ക് ചുമതല അൽപ്പം സങ്കീർണ്ണമാക്കാം

ഡാറ്റ ഞങ്ങൾക്ക് പ്രധാനമാണെന്ന് സങ്കൽപ്പിക്കുക, പക്ഷേ പാർട്ടീഷനുകളിൽ ഞങ്ങൾക്ക് ഡിസ്ക് സ്പേസ് ഇല്ല, ഞങ്ങൾക്ക് ഡിസ്ക് കണക്റ്റുചെയ്യാൻ കഴിയില്ല.

നമുക്ക് ചെയ്യാൻ കഴിയുന്നത് നമ്മുടെ ഡാറ്റ എവിടെയെങ്കിലും റീഡയറക്‌ട് ചെയ്യുകയാണ്, ഉദാഹരണത്തിന് പൈപ്പിലേക്ക്, കൂടാതെ പൈപ്പിൽ നിന്ന് നെറ്റ്‌വർക്കിലേക്ക് ഡാറ്റ റീഡയറക്‌ട് ചെയ്യുക, ഉദാഹരണത്തിന് നെറ്റ്‌കാറ്റ്.
mkfifo കമാൻഡ് ഉപയോഗിച്ച് നമുക്ക് ഒരു പൈപ്പ് സൃഷ്ടിക്കാൻ കഴിയും. ഫയൽ സിസ്റ്റത്തിൽ ശൂന്യമായ ഇടമില്ലെങ്കിലും അത് ഒരു വ്യാജ ഫയൽ സൃഷ്ടിക്കും.

ആപ്ലിക്കേഷൻ പുനരാരംഭിച്ച് പരിശോധിക്കുക:

[user@localhost ]$ python openforwrite.py 
[user@localhost ~]$ ps axuf | grep [o]pen
user  5946 72.9  0.0 128600  5744 pts/22   R+   11:27   0:20  |   _ python openforwrite.py
[user@localhost ~]$ ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt
[user@localhost ~]$ df -h | grep mnt
/dev/loop0      8.7M  8.0M     0 100% /mnt

ഡിസ്ക് സ്പേസ് ഇല്ല, പക്ഷേ ഞങ്ങൾ അവിടെ ഒരു പേരുള്ള പൈപ്പ് വിജയകരമായി സൃഷ്ടിക്കുന്നു:

[user@localhost ~]$ mkfifo /mnt/logs/megapipe
[user@localhost ~]$ ls -lah /mnt/logs/megapipe 
prw-rw-r-- 1 user user 0 Oct  8 11:28 /mnt/logs/megapipe

ഇപ്പോൾ നമുക്ക് ഈ പൈപ്പിലേക്ക് പോകുന്ന എല്ലാ ഡാറ്റയും നെറ്റ്‌വർക്ക് വഴി മറ്റൊരു സെർവറിലേക്ക് പൊതിയേണ്ടതുണ്ട്; അതേ നെറ്റ്‌കാറ്റ് ഇതിന് അനുയോജ്യമാണ്.

remote-server.example.com എന്ന സെർവറിൽ ഞങ്ങൾ സമാരംഭിക്കുന്നു

[user@localhost ~]$ nc -l 7777 > 123.txt 

ഞങ്ങളുടെ പ്രശ്നമുള്ള സെർവറിൽ ഞങ്ങൾ ഒരു പ്രത്യേക ടെർമിനലിൽ സമാരംഭിക്കുന്നു

[user@localhost ~]$ nc remote-server.example.com 7777 < /mnt/logs/megapipe 

ഇപ്പോൾ പൈപ്പിൽ അവസാനിക്കുന്ന എല്ലാ ഡാറ്റയും സ്വയമേവ നെറ്റ്കാറ്റിലെ stdin-ലേക്ക് പോകും, ​​അത് പോർട്ട് 7777-ലെ നെറ്റ്‌വർക്കിലേക്ക് അയയ്ക്കും.

ഈ പേരിട്ടിരിക്കുന്ന പൈപ്പിലേക്ക് നമ്മുടെ ഡാറ്റ എഴുതാൻ തുടങ്ങുക മാത്രമാണ് നമ്മൾ ചെയ്യേണ്ടത്.

ഞങ്ങൾക്ക് ഇതിനകം പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷൻ ഉണ്ട്:

[user@localhost ~]$ ps axuf | grep [o]pen
user  5946 99.8  0.0 128600  5744 pts/22   R+   11:27 169:27  |   _ python openforwrite.py
[user@localhost ~]$ ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt

എല്ലാ ഫ്ലാഗുകളിലും, ഞങ്ങൾക്ക് O_WRONLY മാത്രമേ ആവശ്യമുള്ളൂ, കാരണം ഫയൽ ഇതിനകം നിലവിലുണ്ട്, ഞങ്ങൾക്ക് അത് മായ്‌ക്കേണ്ടതില്ല

[user@localhost ~]$ gdb -p 5946
...
(gdb) call open("/mnt/logs/megapipe", 00000001,0666)
$1 = 4
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/123.txt
l-wx------ 1 user user 64 Oct  8 14:20 4 -> /mnt/logs/megapipe
(gdb) call dup2(4,3)
$2 = 3
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/megapipe
l-wx------ 1 user user 64 Oct  8 14:20 4 -> /mnt/logs/megapipe
(gdb) call close(4)
$3 = 0
(gdb) shell ls -lah /proc/5946/fd
total 0
dr-x------ 2 user user  0 Oct  8 11:27 .
dr-xr-xr-x 9 user user  0 Oct  8 11:27 ..
lrwx------ 1 user user 64 Oct  8 11:28 0 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:28 1 -> /dev/pts/22
lrwx------ 1 user user 64 Oct  8 11:27 2 -> /dev/pts/22
l-wx------ 1 user user 64 Oct  8 11:28 3 -> /mnt/logs/megapipe
(gdb) quit
A debugging session is active.

    Inferior 1 [process 5946] will be detached.

Quit anyway? (y or n) y
Detaching from program: /usr/bin/python2.7, process 5946

റിമോട്ട് സെർവർ remote-server.example.com പരിശോധിക്കുന്നു

[user@localhost ~]$ ls -lah 123.txt 
-rw-rw-r-- 1 user user 38M Oct  8 14:21 123.txt

ഡാറ്റ വരുന്നു, ഞങ്ങൾ പ്രശ്നമുള്ള സെർവർ പരിശോധിക്കുന്നു

[user@localhost ~]$ ls -lah /mnt/logs/
total 7.9M
drwxr-xr-x 2 user user 1.0K Oct  8 11:28 .
drwxr-xr-x 4 root     root     1.0K Oct  8 10:55 ..
-rw-rw-r-- 1 user user 7.9M Oct  8 14:17 123.txt
prw-rw-r-- 1 user user    0 Oct  8 14:22 megapipe

ഡാറ്റ സംരക്ഷിച്ചു, പ്രശ്നം പരിഹരിച്ചു.

ഡെഗിറോയിൽ നിന്നുള്ള എന്റെ സഹപ്രവർത്തകരോട് ഹലോ പറയാൻ ഞാൻ ഈ അവസരം ഉപയോഗിക്കുന്നു.
റേഡിയോ-ടി പോഡ്‌കാസ്റ്റുകൾ ശ്രവിക്കുക.

എല്ലാ ആശംസകളും.

ഗൃഹപാഠമെന്ന നിലയിൽ, നിങ്ങൾ ഇനിപ്പറയുന്ന കമാൻഡ് പ്രവർത്തിപ്പിക്കുകയാണെങ്കിൽ, പൂച്ചയും ഉറക്കവും വിശദീകരിക്കുന്ന പ്രോസസ്സ് ഫയലിൽ എന്തായിരിക്കുമെന്ന് ചിന്തിക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു:

[user@localhost ~]$ cat /dev/zero 2>/dev/null| sleep 10000

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