ઉદાહરણો સાથે Linux માં ફાઇલ વર્ણનકર્તા

એકવાર, એક ઇન્ટરવ્યુમાં, મને પૂછવામાં આવ્યું કે જો તમને ડિસ્કની જગ્યા સમાપ્ત થઈ ગઈ હોવાને કારણે તૂટેલી સેવા મળે તો તમે શું કરશો?

અલબત્ત, મેં જવાબ આપ્યો કે હું જોઈશ કે આ જગ્યા શું કરી રહી છે અને જો શક્ય હોય તો, હું તે જગ્યા સાફ કરીશ.
પછી ઇન્ટરવ્યુઅરે પૂછ્યું, જો પાર્ટીશન પર ખાલી જગ્યા ન હોય, પરંતુ તમને એવી ફાઇલો પણ દેખાતી નથી કે જે બધી જગ્યા લેશે?

આ માટે, મેં કહ્યું કે તમે હંમેશા ઓપન ફાઇલ ડિસ્ક્રીપ્ટર્સને જોઈ શકો છો, ઉદાહરણ તરીકે, lsof કમાન્ડથી અને સમજી શકો છો કે કઈ એપ્લિકેશને બધી ઉપલબ્ધ જગ્યા લીધી છે, અને પછી તમે ડેટાની જરૂર છે કે કેમ તેના આધારે સંજોગો અનુસાર કાર્ય કરી શકો છો. .

ઇન્ટરવ્યુઅરે મને છેલ્લા શબ્દમાં અટકાવ્યો, તેના પ્રશ્નમાં ઉમેર્યું: "ધારો કે અમને ડેટાની જરૂર નથી, તે માત્ર એક ડીબગ લોગ છે, પરંતુ એપ્લિકેશન ડાઉન છે કારણ કે તે ડીબગ લખી શકતું નથી"?

"ઠીક," મેં જવાબ આપ્યો, "અમે એપ્લિકેશન રૂપરેખામાં ડીબગીંગને બંધ કરી શકીએ છીએ અને તેને ફરીથી શરૂ કરી શકીએ છીએ."
ઇન્ટરવ્યુઅરે વાંધો ઉઠાવ્યો: "ના, અમે એપ્લિકેશનને ફરીથી શરૂ કરી શકતા નથી, અમારી પાસે હજી પણ મેમરીમાં સંગ્રહિત મહત્વપૂર્ણ ડેટા છે, અને મહત્વપૂર્ણ ક્લાયન્ટ્સ સેવા સાથે જ જોડાયેલા છે, જેને અમે ફરીથી કનેક્ટ કરવા દબાણ કરી શકતા નથી."

"સારું," મેં કહ્યું, "જો આપણે એપ્લીકેશન રીસ્ટાર્ટ ન કરી શકીએ અને ડેટા આપણા માટે મહત્વનો નથી, તો પછી આપણે આ ખુલ્લી ફાઇલને ફાઇલ ડિસ્ક્રીપ્ટર દ્વારા ખાલી કરી શકીએ છીએ, પછી ભલેને આપણે તેને ls આદેશમાં જોતા ન હોય. ફાઇલ સિસ્ટમ."

ઇન્ટરવ્યુ લેનાર સંતુષ્ટ હતો, પણ હું નહોતો.

પછી મેં વિચાર્યું, મારા જ્ઞાનની કસોટી કરનાર વ્યક્તિ કેમ ઊંડો ખોદતો નથી? પરંતુ જો ડેટા બધા પછી મહત્વપૂર્ણ હોય તો શું? જો આપણે પ્રક્રિયાને પુનઃપ્રારંભ ન કરી શકીએ, અને તે જ સમયે આ પ્રક્રિયા ફાઈલ સિસ્ટમને પાર્ટીશન પર લખે છે જેમાં કોઈ ખાલી જગ્યા નથી? જો આપણે ફક્ત પહેલેથી જ લખેલા ડેટાને જ નહીં, પણ આ પ્રક્રિયા જે લખી રહી છે અથવા લખવાનો પ્રયાસ કરી રહી છે તે ડેટા પણ ગુમાવી ન શકીએ તો શું?

તુઝિક

મારી કારકિર્દીની શરૂઆતમાં, હું એક નાની એપ્લિકેશન બનાવવાનો પ્રયાસ કરી રહ્યો હતો જે વપરાશકર્તાઓ વિશેની માહિતી સંગ્રહિત કરવા માટે જરૂરી છે. અને પછી મેં વિચાર્યું, હું કેવી રીતે વપરાશકર્તાને તેના ડેટા સાથે મેચ કરી શકું. ઉદાહરણ તરીકે, મારી પાસે ઇવાનવ ઇવાન ઇવાનોવિચ છે, અને તેની પાસે થોડો ડેટા છે, પરંતુ તેમની સાથે મિત્રતા કેવી રીતે કરવી? હું સીધો નિર્દેશ કરી શકું છું કે "તુઝિક" નામનો કૂતરો આ જ ઇવાનનો છે. પરંતુ જો તે પોતાનું નામ બદલે અને ઇવાનને બદલે, ઉદાહરણ તરીકે, ઓલ્યા બને તો શું? પછી તે બહાર આવશે કે આપણા ઓલ્યા ઇવાનોવના ઇવાનોવા પાસે હવે કૂતરો રહેશે નહીં, અને આપણો તુઝિક હજી પણ અસ્તિત્વમાં નથી તેવા ઇવાનનો રહેશે. ડેટાબેસે આ સમસ્યાને ઉકેલવામાં મદદ કરી, જેણે દરેક વપરાશકર્તાને અનન્ય ઓળખકર્તા (ID) આપ્યો, અને મારું Tuzik આ ID સાથે જોડાયેલું હતું, જે હકીકતમાં, માત્ર એક સીરીયલ નંબર હતો. આમ, તુઝિકનો માલિક ID નંબર 2 સાથે હતો, અને અમુક સમયે ઇવાન આ ID હેઠળ હતો, અને પછી ઓલ્યા સમાન ID હેઠળ બન્યો. માનવજાત અને પશુપાલનની સમસ્યા વ્યવહારીક રીતે હલ થઈ ગઈ.

ફાઇલ વર્ણનકર્તા

આ ફાઇલ સાથે કામ કરતી ફાઇલ અને પ્રોગ્રામની સમસ્યા આપણા કૂતરા અને માનવ જેવી જ છે. ધારો કે મેં ivan.txt નામની ફાઇલ ખોલી અને તેમાં tuzik શબ્દ લખવાનું શરૂ કર્યું, પરંતુ ફાઇલમાં ફક્ત પ્રથમ અક્ષર “t” જ લખવામાં વ્યવસ્થાપિત થયો, અને આ ફાઇલનું નામ કોઈએ બદલ્યું, ઉદાહરણ તરીકે, olya.txt. પરંતુ ફાઇલ એક જ છે અને હું હજી પણ તેના પર મારો પાસાનો પો લખવા માંગુ છું. દર વખતે જ્યારે તમે સિસ્ટમ કૉલ સાથે ફાઇલ ખોલો છો ઓપન કોઈપણ પ્રોગ્રામિંગ ભાષામાં, મને એક અનન્ય ID મળે છે જે મને ફાઇલ તરફ નિર્દેશ કરે છે, આ ID ફાઇલ વર્ણનકર્તા છે. અને આ ફાઇલ સાથે આગળ શું અને કોણ કરે છે તેનાથી કોઈ ફરક પડતો નથી, તેને કાઢી શકાય છે, તેનું નામ બદલી શકાય છે, તે તેના માલિકને બદલી શકે છે અથવા વાંચવા અને લખવાના અધિકારો છીનવી શકે છે, મારી પાસે હજી પણ તેની ઍક્સેસ હશે, કારણ કે અહીં જ્યારે ફાઇલ ખોલવામાં આવે છે, ત્યારે મારી પાસે તેને વાંચવા અને/અથવા લખવાના અધિકારો હતા અને મેં તેની સાથે કામ કરવાનું શરૂ કર્યું, જેનો અર્થ છે કે મારે તેમ કરવાનું ચાલુ રાખવું જોઈએ.

Linux પર, libc લાઇબ્રેરી દરેક ચાલી રહેલ એપ્લિકેશન (પ્રક્રિયા) માટે 3 નંબરો સાથે 0,1,2 વર્ણનકર્તા ફાઇલો ખોલે છે. વધુ માહિતી તમે લિંક્સ પર મેળવી શકો છો માણસ stdio и માણસ stdout

• ફાઇલ વર્ણનકર્તા 0 ને STDIN કહેવામાં આવે છે અને તે એપ્લિકેશન ઇનપુટ સાથે સંકળાયેલું છે.
• ફાઇલ વર્ણનકર્તા 1 ને STDOUT કહેવામાં આવે છે અને તેનો ઉપયોગ પ્રિન્ટ કમાન્ડ્સ જેવી આઉટપુટ એપ્લિકેશન દ્વારા થાય છે.
• ફાઇલ વર્ણનકર્તા 2 ને STDERR નામ આપવામાં આવ્યું છે અને તેનો ઉપયોગ એપ્લીકેશન દ્વારા ભૂલ સંદેશાઓને આઉટપુટ કરવા માટે થાય છે.

જો તમારા પ્રોગ્રામમાં તમે વાંચવા અથવા લખવા માટે કોઈપણ ફાઇલ ખોલો છો, તો સંભવતઃ તમને પ્રથમ મફત ID મળશે અને તે નંબર 3 હશે.

જો તમે તેની PID જાણતા હોવ તો તમે કોઈપણ પ્રક્રિયા માટે ફાઇલ વર્ણનકર્તાઓની સૂચિ જોઈ શકો છો.

ઉદાહરણ તરીકે, ચાલો bash સાથે કન્સોલ ખોલીએ અને અમારી પ્રક્રિયાની 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 સાથે ફાઇલ વર્ણનકર્તાને સુરક્ષિત રીતે અવગણી શકો છો, તે તમારી જરૂરિયાતો માટે bash દ્વારા ખોલવામાં આવ્યું હતું, અને લિંક કરેલ લાઇબ્રેરી દ્વારા નહીં.

હવે તમામ 3 વર્ણનકર્તા ફાઇલો સ્યુડો-ટર્મિનલ ઉપકરણ સાથે સંકળાયેલી છે /dev/pts, પરંતુ અમે હજી પણ તેમને ચાલાકી કરી શકીએ છીએ, ઉદાહરણ તરીકે, બીજા કન્સોલમાં ચલાવો

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

અને પ્રથમ કન્સોલમાં આપણે જોઈશું

[user@localhost ]$ hello world

રીડાયરેક્ટ અને પાઇપ

તમે બેશ સહિત કોઈપણ પ્રક્રિયામાં આ 3 વર્ણનકર્તા ફાઇલોને સરળતાથી ઓવરરાઇડ કરી શકો છો, ઉદાહરણ તરીકે, બે પ્રક્રિયાઓને જોડતી પાઇપ (પાઇપ) દ્વારા, જુઓ

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

તમે આ આદેશ જાતે ચલાવી શકો છો strace -f અને અંદર શું ચાલી રહ્યું છે તે જુઓ, પરંતુ હું તેને ટૂંકું કરીશ.

PID 15771 સાથેની અમારી પેરેન્ટ બેશ પ્રક્રિયા અમારા આદેશને પાર્સ કરે છે અને બરાબર સમજે છે કે આપણે કેટલા આદેશો ચલાવવા માંગીએ છીએ, અમારા કિસ્સામાં તેમાંથી બે છે: બિલાડી અને ઊંઘ. બાશ જાણે છે કે તેને બે બાળ પ્રક્રિયાઓ બનાવવાની જરૂર છે, અને તેમને એક પાઇપમાં મર્જ કરવાની જરૂર છે. કુલ, બેશને 2 બાળ પ્રક્રિયાઓ અને એક પાઇપની જરૂર પડશે.

બાળ પ્રક્રિયાઓ બનાવતા પહેલા, bash સિસ્ટમ કૉલ ચલાવે છે પાઇપ અને અસ્થાયી પાઇપ બફર પર નવા ફાઇલ વર્ણનકર્તાઓ મેળવે છે, પરંતુ આ બફર હજુ સુધી અમારી બે ચાઇલ્ડ પ્રક્રિયાઓને કોઈપણ રીતે જોડતું નથી.

પિતૃ પ્રક્રિયા માટે, એવું લાગે છે કે પાઇપ પહેલેથી જ છે, પરંતુ હજી સુધી કોઈ બાળ પ્રક્રિયાઓ નથી:

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

પછી સિસ્ટમ કૉલનો ઉપયોગ કરીને ક્લોન bash બે બાળ પ્રક્રિયાઓ બનાવે છે, અને અમારી ત્રણ પ્રક્રિયાઓ આના જેવી દેખાશે:

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 નંબરો સાથે ફાઇલ વર્ણનકર્તાઓને બંધ કરે છે.

પીઆઈડી 9004 સાથે પ્રથમ બેશ ચાઈલ્ડ પ્રક્રિયામાં, સિસ્ટમ કૉલ કરે છે dup2, અમારા STDOUT ફાઇલ ડિસ્ક્રીપ્ટર નંબર 1 ને પાઇપ તરફ નિર્દેશ કરતી ફાઇલ ડિસ્ક્રીપ્ટરમાં બદલે છે, અમારા કિસ્સામાં તે નંબર 3 છે. આમ, PID 9004 સાથે પ્રથમ ચાઇલ્ડ પ્રોસેસ STDOUT ને લખે છે તે બધું આપોઆપ પાઇપ બફરમાં આવી જશે.

PID 9005 સાથેની બીજી ચાઈલ્ડ પ્રક્રિયામાં, bash ફાઇલને STDIN વર્ણનકર્તા નંબર 2 પર dup0 કરે છે. હવે PID 9005 સાથેની અમારી બીજી બેશ જે વાંચશે તે બધું પાઇપમાંથી વાંચશે.

તે પછી, 3 અને 4 નંબરો સાથેના ફાઇલ વર્ણનકર્તાઓ પણ બાળ પ્રક્રિયાઓમાં બંધ છે, કારણ કે તે હવે ઉપયોગમાં લેવાતા નથી.

હું જાણીજોઈને ફાઇલ ડિસ્ક્રીપ્ટર 255 ને અવગણું છું, તે આંતરિક રીતે બેશ દ્વારા ઉપયોગમાં લેવાય છે અને બાળ પ્રક્રિયાઓમાં પણ બંધ કરવામાં આવશે.

આગળ, PID 9004 સાથેની પ્રથમ ચાઇલ્ડ પ્રક્રિયામાં, bash સિસ્ટમ કૉલ સાથે શરૂ થાય છે exec એક્ઝેક્યુટેબલ ફાઇલ કે જે અમે આદેશ વાક્ય પર સ્પષ્ટ કરી છે, અમારા કિસ્સામાં તે /usr/bin/cat છે.

PID 9005 સાથેની બીજી ચાઇલ્ડ પ્રક્રિયામાં, bash એ બીજું એક્ઝિક્યુટેબલ ચલાવે છે જે અમે ઉલ્લેખિત કર્યું છે, અમારા કિસ્સામાં /usr/bin/sleep.

exec સિસ્ટમ કૉલ ફાઇલ વર્ણનકર્તાઓને બંધ કરતું નથી સિવાય કે તે ઓપન કૉલ એક્ઝિક્યુટ કરવામાં આવે તે સમયે 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

અને "a" ધ્વજ સાથે

[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% પર કબજો કર્યો.

અમે યાદ રાખીએ છીએ કે સમસ્યાની પરિસ્થિતિઓ અનુસાર, અમે ખૂબ જ મહત્વપૂર્ણ ડેટા રેકોર્ડ કરવાનો પ્રયાસ કરી રહ્યા છીએ જે ગુમાવી શકાતી નથી. અને આમ કરવાથી, અમારે પ્રક્રિયાને પુનઃપ્રારંભ કર્યા વિના સેવાને ઠીક કરવાની જરૂર છે.

ચાલો કહીએ કે અમારી પાસે હજુ પણ ડિસ્ક જગ્યા છે, પરંતુ એક અલગ પાર્ટીશનમાં, ઉદાહરણ તરીકે, in/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

gdb સાથે પ્રક્રિયા સાથે જોડાઈ રહ્યું છે

[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

Python શું સિસ્ટમ કૉલ કરે છે તે ધ્યાનમાં રાખીને (ઉપર જુઓ જ્યાં અમે સ્ટ્રેસ ચલાવી અને એક ઓપન કૉલ મળ્યો), ફાઇલ ખોલવા માટે અમારા કોડ પર પ્રક્રિયા કરતી વખતે, અમે અમારી પ્રક્રિયા વતી તે જ કરીએ છીએ, પરંતુ અમને O_WRONLY|O_CREAT| O_TRUNC બિટ્સ સંખ્યાત્મક મૂલ્ય સાથે બદલાય છે. આ કરવા માટે, કર્નલ સ્ત્રોતો ખોલો, ઉદાહરણ તરીકે અહીં અને જુઓ કે કયા ધ્વજ કયા માટે જવાબદાર છે

# O_WRONLY 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

અમે પાઇપ સાથેનું ઉદાહરણ યાદ રાખીએ છીએ - કેવી રીતે bash ફાઇલ વર્ણનકર્તાને બદલે છે, અને પહેલેથી જ 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 થી બહાર નીકળો

(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 

હવે તમામ ડેટા જે પાઇપમાં આવશે તે આપમેળે netcat માં 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