लिनक्समध्ये उदाहरणांसह फाइल वर्णनकर्ता

एकदा, एका मुलाखतीदरम्यान, मला विचारले गेले की, डिस्कमध्ये जागा संपल्यामुळे एखादी सेवा कार्य करत नसेल तर तुम्ही काय कराल?

अर्थात, मी उत्तर दिले की या जागेवर काय व्यापले आहे ते मी पाहीन आणि शक्य असल्यास मी ती जागा स्वच्छ करेन.
मग मुलाखतकाराने विचारले, जर विभाजनावर मोकळी जागा नसेल, परंतु तुम्हाला सर्व जागा घेणाऱ्या कोणत्याही फाइल्स दिसत नाहीत तर?

यावर मी म्हणालो की तुम्ही नेहमी ओपन फाइल डिस्क्रिप्टर्स पाहू शकता, उदाहरणार्थ lsof कमांडसह, आणि कोणत्या ऍप्लिकेशनने सर्व उपलब्ध जागा घेतल्या आहेत हे समजून घेऊ शकता आणि नंतर डेटा आवश्यक आहे की नाही यावर अवलंबून तुम्ही परिस्थितीनुसार कार्य करू शकता. .

मुलाखतकाराने शेवटच्या शब्दावर मला व्यत्यय आणला, त्याच्या प्रश्नात जोडले: "समजा आम्हाला डेटाची आवश्यकता नाही, तो फक्त एक डीबग लॉग आहे, परंतु अनुप्रयोग कार्य करत नाही कारण तो डीबग लिहू शकत नाही"?

“ठीक आहे,” मी उत्तर दिले, “आम्ही ऍप्लिकेशन कॉन्फिगरेशनमधील डीबग बंद करू शकतो आणि ते रीस्टार्ट करू शकतो.”
मुलाखतकाराने आक्षेप घेतला: "नाही, आम्ही ऍप्लिकेशन रीस्टार्ट करू शकत नाही, आमच्याकडे अजूनही महत्त्वाचा डेटा मेमरीमध्ये संग्रहित आहे आणि महत्त्वाचे क्लायंट सेवेशीच जोडलेले आहेत, ज्यांना आम्ही पुन्हा कनेक्ट करण्यास भाग पाडू शकत नाही."

“ठीक आहे,” मी म्हणालो, “जर आपण ऍप्लिकेशन रीस्टार्ट करू शकत नसलो आणि डेटा आपल्यासाठी महत्त्वाचा नसेल, तर आपण ही उघडलेली फाईल फाईल डिस्क्रिप्टरद्वारे साफ करू शकतो, जरी आपल्याला ती ls कमांडमध्ये दिसत नसली तरीही. फाइल सिस्टमवर.

मुलाखत घेणारा खूश झाला, पण मी नाही.

मग मी विचार केला, माझ्या ज्ञानाची चाचणी घेणारी व्यक्ती अधिक खोल का करत नाही? पण शेवटी डेटा महत्त्वाचा असेल तर? जर आपण प्रक्रिया रीस्टार्ट करू शकत नाही, आणि प्रक्रिया फाईल सिस्टीमला विभाजनावर लिहिते ज्यामध्ये मोकळी जागा नाही? जर आपण केवळ आधीच लिहिलेला डेटाच गमावू शकत नाही तर ही प्रक्रिया लिहितो किंवा लिहिण्याचा प्रयत्न करतो तो डेटा देखील गमावू शकत नाही?

तुझिक

माझ्या कारकिर्दीच्या सुरुवातीच्या काळात, मी एक लहान ऍप्लिकेशन तयार करण्याचा प्रयत्न केला जो वापरकर्त्याची माहिती संग्रहित करण्यासाठी आवश्यक होता. आणि मग मी विचार केला, मी वापरकर्त्याला त्याच्या डेटाशी कसे जुळवू शकतो. उदाहरणार्थ, माझ्याकडे इवानोव्ह इव्हान इव्हानोविच आहे, आणि त्याच्याकडे काही माहिती आहे, परंतु मी त्यांच्याशी मैत्री कशी करू शकतो? मी थेट निदर्शनास आणू शकतो की "तुझिक" नावाचा कुत्रा याच इव्हानचा आहे. पण जर त्याने त्याचे नाव बदलले आणि इव्हानऐवजी ओल्या झाला तर? मग असे दिसून येईल की आमच्या ओल्या इव्हानोव्हना इव्हानोव्हाकडे यापुढे कुत्रा राहणार नाही आणि आमचा तुझिक अजूनही अस्तित्वात नसलेल्या इव्हानचा असेल. प्रत्येक वापरकर्त्याला एक अद्वितीय ओळखकर्ता (आयडी) देणारा डेटाबेस या समस्येचे निराकरण करण्यात मदत करतो आणि माझे तुझिक या आयडीशी जोडले गेले होते, जे खरं तर फक्त एक अनुक्रमांक होता. अशा प्रकारे, एक्काच्या मालकाचा आयडी क्रमांक 2 होता आणि काही वेळा इव्हान या आयडीखाली होता आणि नंतर ओल्या त्याच आयडीखाली आला. मानवता आणि पशुपालनाचा प्रश्न व्यावहारिकरित्या सोडवला गेला.

फाइल वर्णनकर्ता

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

लिनक्समध्ये, libc लायब्ररी प्रत्येक चालू असलेल्या ऍप्लिकेशनसाठी (प्रोसेस) 3 क्रमांकाच्या 0,1,2 डिस्क्रिप्टर फाइल्स उघडते. अधिक माहिती लिंक्सवर मिळू शकते माणूस 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

तुम्ही ही कमांड स्वतः चालवू शकता strace -f आणि आत काय चालले आहे ते पहा, परंतु मी तुम्हाला थोडक्यात सांगेन.

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

नंतर सिस्टम कॉल वापरून क्लोन 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 क्रमांकाचे फाइल वर्णनक बंद करते.

PID 9004 सह पहिल्या चाइल्ड बॅश प्रक्रियेत, सिस्टम कॉल dup2, आमचा STDOUT फाईल डिस्क्रिप्टर क्रमांक 1 पाईपकडे निर्देशित करणार्‍या फाईल डिस्क्रिप्टरमध्ये बदलतो, आमच्या बाबतीत तो क्रमांक 3 आहे. अशाप्रकारे, PID 9004 सह पहिली चाइल्ड प्रक्रिया STDOUT ला जे काही लिहिते ते सर्व पाईप बफरमध्ये आपोआप संपेल.

PID 9005 सह दुसऱ्या चाइल्ड प्रक्रियेत, bash फाइल वर्णनकर्ता STDIN क्रमांक 2 बदलण्यासाठी dup0 चा वापर करते. आता PID 9005 सह आमची दुसरी बॅश जी वाचेल ती सर्व पाईपमधून वाचली जाईल.

यानंतर, 3 आणि 4 क्रमांकाचे फाइल वर्णनकर्ता देखील चाइल्ड प्रोसेसमध्ये बंद केले जातात, कारण ते यापुढे वापरले जात नाहीत.

मी जाणूनबुजून फाईल डिस्क्रिप्टर 255 दुर्लक्षित करतो; तो बॅशद्वारेच अंतर्गत हेतूंसाठी वापरला जातो आणि चाइल्ड प्रोसेसमध्ये देखील बंद केला जाईल.

पुढे, PID 9004 सह पहिल्या चाइल्ड प्रक्रियेमध्ये, बॅश सिस्टम कॉल वापरण्यास प्रारंभ करते exec आम्ही कमांड लाइनवर निर्दिष्ट केलेली एक्झिक्यूटेबल फाइल, आमच्या बाबतीत ती /usr/bin/cat आहे.

PID 9005 सह दुसऱ्या चाइल्ड प्रक्रियेमध्ये, bash आम्ही निर्दिष्ट केलेले दुसरे एक्झिक्युटेबल चालवते, आमच्या बाबतीत /usr/bin/sleep.

एक्झिक सिस्टम कॉल फाईल हँडल बंद करत नाही जोपर्यंत ते ओ_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 मेगाबाइट प्रति सेकंद लिहितो. शिवाय, जर काही कारणास्तव आम्ही डिस्कवर डेटा लिहू शकलो नाही, तर आम्ही याकडे दुर्लक्ष करू आणि एका सेकंदात पुन्हा डेटा लिहिण्याचा प्रयत्न करू. मी Python वापरत असलेल्या उदाहरणात तुम्ही इतर कोणतीही प्रोग्रामिंग भाषा वापरू शकता.

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

फाईल लिहिण्यासाठी पुरेशी डिस्क स्पेस नसल्याबद्दल मूळ प्रश्नाकडे परत येत, चला समस्येचे अनुकरण करण्याचा प्रयत्न करूया.

चला आमच्या विभाजनासाठी एक फाईल तयार करू, जी आम्ही स्वतंत्र डिस्क म्हणून माउंट करू:

[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

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

आम्हाला पाईपचे उदाहरण आठवते - बॅश फाइल डिस्क्रिप्टर कसे बदलते आणि आम्ही आधीच 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 

आता पाईपमध्ये संपलेला सर्व डेटा आपोआप नेटकॅटमधील 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