उदाहरण के साथ लिनक्स डिस्क्रिप्टर फ़ाइल

एक बार, एक साक्षात्कार में, उन्होंने मुझसे पूछा कि यदि आप एक ऐसी सेवा पाते हैं जो काम नहीं कर रही है क्योंकि डिस्क स्थान से बाहर चली गई है?

बेशक, मैंने जवाब दिया कि मैं देखूंगा कि यह जगह क्या है और अगर संभव हो तो मैं इस जगह को साफ कर दूंगा।
फिर साक्षात्कारकर्ता ने पूछा, क्या होगा अगर अनुभाग पर कोई खाली स्थान नहीं है, लेकिन आप उन फ़ाइलों को भी नहीं देखेंगे जो पूरी जगह पर कब्जा कर लेंगे?

इस के लिए, मैंने कहा कि आप हमेशा ओपन फाइल डिस्क्रिप्टर देख सकते हैं, उदाहरण के लिए, lsof कमांड के साथ और समझें कि किस एप्लिकेशन ने सभी उपलब्ध स्पेस को लिया, और फिर आप परिस्थितियों के अनुसार आगे बढ़ सकते हैं, इस पर निर्भर करता है कि डेटा की आवश्यकता है या नहीं।

साक्षात्कारकर्ता ने मेरे प्रश्न को जोड़ते हुए मुझे अंतिम शब्द में बाधित किया: "मान लीजिए कि हमें डेटा की आवश्यकता नहीं है, यह सिर्फ डिबग लॉग है, लेकिन एप्लिकेशन काम नहीं करता क्योंकि यह डीबग रिकॉर्ड नहीं कर सकता है"?

"ठीक है," मैंने उत्तर दिया, "हम एप्लिकेशन के कॉन्फ़िगरेशन में डिबग को बंद कर सकते हैं और इसे पुनः आरंभ कर सकते हैं।"
साक्षात्कारकर्ता ने आपत्ति की: "नहीं, हम एप्लिकेशन को पुनः आरंभ नहीं कर सकते, महत्वपूर्ण डेटा अभी भी हमारी मेमोरी में संग्रहीत है, और महत्वपूर्ण क्लाइंट स्वयं सेवा से जुड़े हैं, जिसे हम फिर से कनेक्ट करने के लिए मजबूर नहीं कर सकते हैं"।

"ठीक है," मैंने कहा, "यदि हम एप्लिकेशन को पुनरारंभ नहीं कर सकते हैं और डेटा हमारे लिए महत्वपूर्ण नहीं है, तो हम डिस्क्रिप्टर फ़ाइल के माध्यम से इस खुली फ़ाइल को केवल साफ़ कर सकते हैं, भले ही हम इसे फ़ाइल सिस्टम पर ls कमांड में न देखें।"

साक्षात्कारकर्ता प्रसन्न था, लेकिन मैं नहीं था।

फिर मैंने सोचा, मेरे ज्ञान का परीक्षण करने वाला व्यक्ति गहरी खुदाई क्यों नहीं करता है? लेकिन क्या होगा यदि डेटा अभी भी महत्वपूर्ण है? क्या होगा अगर हम प्रक्रिया को पुनः आरंभ नहीं कर सकते हैं, और एक ही समय में यह प्रक्रिया उस अनुभाग में फ़ाइल सिस्टम को लिखती है जिस पर कोई खाली स्थान नहीं है? क्या होगा यदि हम न केवल पहले से रिकॉर्ड किए गए डेटा को खो सकते हैं, बल्कि यह भी कि यह प्रक्रिया लिखती है या रिकॉर्ड करने की कोशिश करती है?

डोंगी

अपने करियर की शुरुआत में, मैंने एक छोटा अनुप्रयोग बनाने की कोशिश की, जिसमें उपयोगकर्ताओं के बारे में जानकारी संग्रहीत करना आवश्यक था। और फिर मैंने सोचा, मैं उपयोगकर्ता को उसके डेटा को कैसे मैप कर सकता हूं। उदाहरण के लिए, मेरे पास इवान इवानोव इवानिच है, और उसके पास कुछ डेटा है, लेकिन उनसे दोस्ती कैसे करें? मैं सीधे संकेत कर सकता हूं कि "तुज़िक" नाम का कुत्ता इसी इवान का है। लेकिन क्या होगा अगर वह अपना नाम बदलता है और इवान के बजाय, उदाहरण के लिए, ओला? फिर यह पता चला कि हमारे ओलेआ इवानोव्ना इवानोवा के पास अब एक कुत्ता नहीं होगा, और हमारा तुज़िक अभी भी अस्तित्वहीन इवान से संबंधित होगा। इस डेटाबेस में एक डेटाबेस द्वारा मदद की गई थी, जो प्रत्येक उपयोगकर्ता को एक विशिष्ट पहचानकर्ता (आईडी) देता था, और मेरा ट्यूज़िक इस आईडी से जुड़ा हुआ था, जो वास्तव में, केवल एक क्रमिक संख्या थी। इस प्रकार, तुज़िक का मालिक आईडी नंबर 2 के साथ था, और किसी समय में, इवान इस आईडी के तहत था, और फिर ओलेआ उसी आईडी बन गया। मानवता और पशुपालन की समस्या व्यावहारिक रूप से हल हो गई है।

फ़ाइल विवरणक

फ़ाइल और इस फ़ाइल के साथ काम करने वाले कार्यक्रम की समस्या लगभग हमारे कुत्ते और व्यक्ति के समान है। मान लीजिए कि मैंने ivan.txt नाम से एक फ़ाइल खोली और उसमें tuzik शब्द लिखना शुरू किया, लेकिन फ़ाइल के लिए केवल पहला अक्षर "t" लिखने में कामयाब रहा, और इस फ़ाइल का नाम बदलकर किसी ने रखा, उदाहरण के लिए, olya.txt। लेकिन फ़ाइल वही रही, और मैं अभी भी उसमें अपना इक्का लिखना चाहता हूं। हर बार जब मैं किसी भी प्रोग्रामिंग भाषा में ओपन सिस्टम कॉल के साथ एक फ़ाइल खोलता हूं, तो मुझे एक अनूठी आईडी मिलती है जो मुझे एक फ़ाइल की ओर इशारा करती है, यह आईडी एक फाइल डिस्क्रिप्टर है। और इससे कोई फर्क नहीं पड़ता कि कोई भी इस फ़ाइल के साथ क्या करता है, वे इसे हटा सकते हैं, वे इसका नाम बदल सकते हैं, वे स्वामी को बदल सकते हैं या पढ़ने और लिखने की अनुमति ले सकते हैं, मेरे पास अभी भी इस तक पहुंच होगी, क्योंकि उस समय फ़ाइल खोली जाती है, मेरे पास इसे पढ़ने और / या लिखने का अधिकार था, और मैं उसके साथ काम करना शुरू करने में कामयाब रहा, जिसका मतलब है कि मुझे ऐसा करना जारी रखना चाहिए।

लिनक्स पर, libc लाइब्रेरी प्रत्येक रनिंग एप्लिकेशन (प्रक्रिया) 3 डिस्क्रिप्टर फाइल के लिए खुलती है, जिसमें 0,1,2 नंबर होते हैं। आप लिंक मैन स्टैडियो और मैन स्टडआउट पर अधिक जानकारी प्राप्त कर सकते हैं

• फ़ाइल डिस्क्रिप्टर 0 को STDIN कहा जाता है और यह एप्लिकेशन से डेटा इनपुट से जुड़ा होता है
• फ़ाइल डिस्क्रिप्टर 1 को STDOUT कहा जाता है और इसका उपयोग आउटपुट डेटा के लिए अनुप्रयोगों द्वारा किया जाता है, उदाहरण के लिए, प्रिंट कमांड
• फ़ाइल डिस्क्रिप्टर 2 को एसटीडीआरआर कहा जाता है और इसका उपयोग अनुप्रयोगों द्वारा आउटपुट त्रुटि रिपोर्टिंग डेटा के लिए किया जाता है।

यदि आपके कार्यक्रम में आप पढ़ने या लिखने के लिए एक फ़ाइल खोलते हैं, तो सबसे अधिक संभावना है कि आपको पहली मुफ्त आईडी मिलेगी और यह नंबर 3 होगा।

यदि आप इसके 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 डिस्क्रिप्टर फाइलें छद्म टर्मिनल डिवाइस / देव / पीटीएस से जुड़ी हैं, लेकिन हम अभी भी उन्हें हेरफेर कर सकते हैं, उदाहरण के लिए, दूसरे कंसोल में चलाएं

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

और पहले कंसोल में हम देखेंगे

 [user@localhost ]$ hello world 

पुनर्निर्देशित और पाइप

आप इन 3 डिस्क्रिप्टर फ़ाइलों को किसी भी प्रक्रिया में आसानी से ओवरराइड कर सकते हैं, जिसमें bash भी शामिल है, उदाहरण के लिए, दो प्रक्रियाओं को जोड़ने वाले पाइप के माध्यम से, देखें

 [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 के साथ पहली बैश चाइल्ड प्रक्रिया में, d22 सिस्टम कॉल, पाइप को इंगित करते हुए नंबर 1 के साथ हमारे STDOUT फाइल डिस्क्रिप्टर को पाइप में बदल देती है, हमारे मामले में यह नंबर 3 है। इस प्रकार, वह सब कुछ जो PID 9004 के लिए पहला चाइल्ड प्रोसेस STDOUT को लिखेगा। स्वचालित रूप से पाइप बफर में गिर जाएगी।

PID 9005 के साथ दूसरी चाइल्ड प्रोसेस में, bash ने फाइल डिस्क्रिप्टर STDIN को 0 नंबर के साथ dup2 का उपयोग करके बदल दिया। अब वह सब कुछ जो PID 9005 के साथ हमारा दूसरा बैश होगा, पाइप से पढ़ेगा।

उसके बाद, संख्या 3 और 4 वाले वर्णक भी बाल प्रक्रियाओं में बंद हो जाते हैं, क्योंकि वे अब उपयोग नहीं किए जाते हैं।

मैं जानबूझकर फ़ाइल डिस्क्रिप्टर 255 को अनदेखा करता हूं, यह आंतरिक आवश्यकताओं के लिए बैश का उपयोग करता है और बाल प्रक्रियाओं में भी बंद हो जाएगा।

इसके अलावा, पीआईडी ​​9004 के साथ पहली बच्चे की प्रक्रिया में, बैश निष्पादन योग्य फ़ाइल को शुरू करता है जिसे हमने कमांड लाइन पर सिस्टम कॉल निष्पादन के साथ निर्दिष्ट किया है, हमारे मामले में यह / usr / bin / cat है।

पीआईडी ​​9005 के साथ दूसरे बच्चे की प्रक्रिया में, बैश दूसरा निष्पादन योग्य फ़ाइल शुरू करता है जिसे हमने निर्दिष्ट किया है, हमारे मामले में यह / usr / बिन / नींद है।

यदि वे खुले कॉल के दौरान 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: 

"डब्ल्यू" ध्वज के साथ जाँच

 [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) या एप्लिकेशन में लॉगिंग के विभिन्न स्तरों का उपयोग करते हैं। लिनक्स वास्तव में पहले से चल रहे प्रोग्राम को लिखने और बदलने की क्षमता प्रदान करता है, उदाहरण के लिए, चर के मूल्यों को बदलना, ब्रेकपॉइंट सेट करना, आदि।

फ़ाइल लिखने के लिए पर्याप्त डिस्क स्थान नहीं के साथ मूल प्रश्न पर लौटते हुए, हम समस्या का अनुकरण करने का प्रयास करेंगे।

हमारे विभाजन के लिए एक फ़ाइल बनाएं, जिसे हम एक अलग डिस्क के रूप में माउंट करेंगे:

 [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% पर कब्जा कर लिया।

हमें याद है कि कार्य की शर्तों के अनुसार, हम बहुत महत्वपूर्ण डेटा रिकॉर्ड करने की कोशिश कर रहे हैं जो खो नहीं सकते। और उसी समय हमें प्रक्रिया को पुनरारंभ किए बिना सेवा को सुधारने की आवश्यकता है।

मान लें कि हमारे पास अभी भी डिस्क स्थान है, लेकिन एक अलग विभाजन में, उदाहरण के लिए / घर में।

चलो हमारे कोड को "मक्खी पर फटकार" की कोशिश करें।

हम अपनी प्रक्रिया के 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 

यह याद रखना कि पायथन कॉल किस तरह का सिस्टम बनाता है (ऊपर देखें, जहां हमने स्ट्रेस चलाया और ओपन कॉल पाया), फ़ाइल को खोलने के लिए हमारे कोड को संसाधित करते हुए, हम अपनी ओर से भी ऐसा ही करते हैं, लेकिन हमें O_WRONLY | O_REREAT | O_TRUNC बिट्स की आवश्यकता होती है एक संख्यात्मक मूल्य के साथ बदलें। ऐसा करने के लिए, कर्नेल स्रोतों को खोलें, उदाहरण के लिए, यहां और देखें कि झंडे किसके लिए जिम्मेदार हैं

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

हमें पाइप उदाहरण याद है - कैसे बैश फ़ाइल डिस्क्रिप्टर को बदलता है, और पहले से ही डुप 2 सिस्टम कॉल सीख चुका है।

हम एक फ़ाइल डिस्क्रिप्टर को दूसरे के साथ बदलने का प्रयास करते हैं

 (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 

अब हमें किसी भी तरह नेटवर्क के माध्यम से इस पाइप में जाने वाले सभी डेटा को किसी अन्य सर्वर पर लपेटने की आवश्यकता है, वही नेटकैट इसके लिए उपयुक्त है।

दूरस्थ-server.example.com सर्वर पर, चलाएँ

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

हमारे समस्या सर्वर पर, एक अलग टर्मिनल में चलाएं

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

अब पाइप में आने वाला सारा डेटा अपने आप नेटकट में स्टड हो जाएगा, जो इसे नेटवर्क पर पोर्ट 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