उदाहरणका साथ लिनक्समा फाइल वर्णनकर्ता

एक पटक, एक अन्तर्वार्ताको क्रममा, मलाई सोधिएको थियो, यदि तपाईंले डिस्कको ठाउँ सकिएको तथ्यका कारण सेवाले काम नगरेको पाइयो भने के गर्नुहुन्छ?

निस्सन्देह, मैले जवाफ दिएँ कि म यो ठाउँले के ओगटेको छ भनेर हेर्नेछु र सम्भव भएमा, म ठाउँ सफा गर्नेछु।
त्यसपछि अन्तर्वार्ताकारले सोधे, यदि विभाजनमा खाली ठाउँ छैन, तर तपाईंले सबै ठाउँ ओगट्ने कुनै फाइलहरू पनि देख्नुभएन भने के हुन्छ?

यसमा मैले भनें कि तपाईले जहिले पनि खुला फाइल वर्णनकर्ताहरू हेर्न सक्नुहुन्छ, उदाहरणका लागि lsof आदेशको साथ, र कुन अनुप्रयोगले सबै उपलब्ध ठाउँहरू ओगटेको छ भनेर बुझ्न सक्नुहुन्छ, र त्यसपछि तपाईले परिस्थिति अनुसार कार्य गर्न सक्नुहुन्छ, डाटा आवश्यक छ कि छैन भन्ने आधारमा। ।

अन्तर्वार्ताकारले मलाई अन्तिम शब्दमा बाधा पुर्‍यायो, उसको प्रश्नमा थप्दै: "मानौं हामीलाई डाटा चाहिँदैन, यो केवल एक डिबग लग हो, तर अनुप्रयोगले काम गर्दैन किनकि यसले डिबग लेख्न सक्दैन"?

"ठीक छ," मैले जवाफ दिएँ, "हामी अनुप्रयोग कन्फिगरेसनमा डिबग बन्द गर्न सक्छौं र यसलाई पुन: सुरु गर्न सक्छौं।"
अन्तर्वार्ताकर्ताले आपत्ति जनाए: "होइन, हामी अनुप्रयोग पुन: सुरु गर्न सक्दैनौं, हामीसँग अझै पनि मेमोरीमा भण्डारण गरिएको महत्त्वपूर्ण डेटा छ, र महत्त्वपूर्ण ग्राहकहरू सेवामा जडान भएका छन्, जसलाई हामी पुन: जडान गर्न बाध्य पार्न सक्दैनौं।"

"ठीक छ," मैले भनें, "यदि हामी अनुप्रयोग पुन: सुरु गर्न सक्दैनौं र डाटा हाम्रो लागि महत्त्वपूर्ण छैन भने, हामी केवल फाइल वर्णनकर्ता मार्फत यो खुला फाइल खाली गर्न सक्छौं, हामीले यसलाई ls आदेशमा नदेखे तापनि। फाइल प्रणालीमा।"

साक्षात्कारकर्ता खुसी थिए, तर म थिएन।

त्यसपछि मैले सोचे, मेरो ज्ञानको परिक्षण गर्ने व्यक्तिले किन गहिरो खन्दैन? तर के हुन्छ यदि डाटा सबै पछि महत्त्वपूर्ण छ? के हुन्छ यदि हामीले प्रक्रिया पुन: सुरु गर्न सक्दैनौं, र प्रक्रियाले कुनै खाली ठाउँ नभएको विभाजनमा फाइल प्रणालीमा लेख्छ? के हुन्छ यदि हामीले पहिले नै लेखिएको डाटा मात्र गुमाउन सक्दैनौं, तर यो प्रक्रियाले लेख्ने वा लेख्ने प्रयास गर्ने डाटा पनि?

तुजिक

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

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

यस फाइलसँग काम गर्ने फाइल र प्रोग्रामको समस्या लगभग हाम्रो कुकुर र मानिसको जस्तै छ। मानौं मैले ivan.txt नामक फाइल खोलेको छु र यसमा tuzik शब्द लेख्न थालेको छु, तर फाइलमा पहिलो अक्षर "t" मात्र लेख्न सफल भएको छु, र यो फाइललाई कसैले पुन: नामाकरण गरेको छ, उदाहरणका लागि, olya.txt। तर फाइल उस्तै छ, र म अझै पनि यसमा मेरो इक्का रेकर्ड गर्न चाहन्छु। प्रत्येक पटक प्रणाली कल द्वारा फाइल खोलिएको छ खुला कुनै पनि प्रोग्रामिङ भाषामा मैले एउटा अद्वितीय ID प्राप्त गर्छु जसले मलाई फाइलमा देखाउँछ, यो ID फाइल वर्णनकर्ता हो। र यो कुनै फरक पर्दैन कि यो फाइलको साथ के र कसले गर्छ, यसलाई मेटाउन सकिन्छ, यसलाई पुन: नामाकरण गर्न सकिन्छ, मालिक परिवर्तन गर्न सकिन्छ, वा पढ्न र लेख्ने अधिकार खोस्न सकिन्छ, मसँग अझै पहुँच हुनेछ। यसमा, किनभने फाइल खोल्ने समयमा, मसँग पढ्न र/वा लेख्ने अधिकार थियो र मैले यससँग काम गर्न सुरु गरें, जसको मतलब मैले त्यसो गरिरहनुपर्छ।

लिनक्समा, libc पुस्तकालयले प्रत्येक चलिरहेको अनुप्रयोग (प्रक्रिया) को लागि 3 नम्बरमा 0,1,2 वर्णनकर्ता फाइलहरू खोल्छ। थप जानकारी लिङ्कहरूमा फेला पार्न सकिन्छ मान्छे stdio и मान्छे stdout

• फाइल वर्णनकर्ता ० लाई 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 लाई सुरक्षित रूपमा बेवास्ता गर्न सक्नुहुन्छ; यो यसको आवश्यकताहरूको लागि bash द्वारा खोलिएको थियो, र लिङ्क गरिएको पुस्तकालयद्वारा होइन।

अब सबै 3 वर्णनकर्ता फाइलहरू स्यूडो टर्मिनल उपकरणसँग सम्बन्धित छन् /dev/pts, तर हामी अझै पनि तिनीहरूलाई हेरफेर गर्न सक्छौं, उदाहरणका लागि, तिनीहरूलाई दोस्रो कन्सोलमा चलाउनुहोस्

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

र पहिलो कन्सोलमा हामी देख्नेछौं

[user@localhost ]$ hello world

रिडिरेक्ट र पाइप

तपाईं सजिलैसँग यी 3 वर्णनकर्ता फाइलहरूलाई कुनै पनि प्रक्रियामा ओभरराइड गर्न सक्नुहुन्छ, bash सहित, उदाहरणका लागि दुई प्रक्रियाहरू जडान गर्ने पाइप मार्फत, हेर्नुहोस्

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

तपाईं आफैले यो आदेश चलाउन सक्नुहुन्छ strace -f र भित्र के भइरहेको छ हेर्नुहोस्, तर म तपाईंलाई छोटकरीमा बताउनेछु।

PID 15771 को साथ हाम्रो अभिभावक bash प्रक्रियाले हाम्रो आदेश पार्स गर्दछ र हामी कति कमाण्डहरू चलाउन चाहन्छौं भन्ने कुरा बुझ्छ, हाम्रो केसमा तीमध्ये दुईवटा छन्: बिरालो र निद्रा। Bash लाई थाहा छ कि यसले दुई बच्चा प्रक्रियाहरू सिर्जना गर्न आवश्यक छ, र तिनीहरूलाई एउटा पाइपमा मर्ज गर्नुपर्छ। कुलमा, bash लाई २ चाइल्ड प्रोसेस र एउटा पाइप चाहिन्छ।

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 नम्बर भएका फाइल विवरणहरू बन्द गर्दछ।

PID 9004 सँग पहिलो चाइल्ड ब्यास प्रक्रियामा, प्रणाली कल dup2, हाम्रो STDOUT फाइल डिस्क्रिप्टर नम्बर 1 लाई पाइपलाई पोइन्ट गर्ने फाइल डिस्क्रिप्टरमा परिवर्तन गर्दछ, हाम्रो अवस्थामा यो नम्बर 3 हो। यसरी, PID 9004 सँग पहिलो चाइल्ड प्रक्रियाले STDOUT मा लेख्ने सबै कुरा स्वचालित रूपमा पाइप बफरमा समाप्त हुनेछ।

PID 9005 सँग दोस्रो चाइल्ड प्रक्रियामा, bash ले फाइल वर्णनकर्ता STDIN नम्बर 2 परिवर्तन गर्न dup0 प्रयोग गर्दछ। अब PID 9005 सँग हाम्रो दोस्रो ब्यासले पढ्ने सबै कुरा पाइपबाट पढिनेछ।

यस पछि, 3 र 4 नम्बर भएका फाइल वर्णनकर्ताहरू पनि चाइल्ड प्रक्रियाहरूमा बन्द छन्, किनभने तिनीहरू अब प्रयोग हुँदैनन्।

मैले जानाजानी फाइल वर्णनकर्ता 255 लाई बेवास्ता गर्छु; यो bash द्वारा आन्तरिक उद्देश्यका लागि प्रयोग गरिन्छ र बाल प्रक्रियाहरूमा पनि बन्द हुनेछ।

अर्को, 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

फाइलको साइज १९९२३४५७ हो। फाइल खाली गर्ने प्रयास गरौं:

[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

त्यसोभए, हामीसँग यस लेखको सुरुमा वर्णन गरिएको समस्या छ। खाली ठाउँ ०, १००% ओगटेको छ।

हामी सम्झन्छौं कि कार्यका सर्तहरू अनुसार, हामी हराउन नसकिने धेरै महत्त्वपूर्ण डेटा रेकर्ड गर्ने प्रयास गर्दैछौं। र एकै समयमा, हामीले प्रक्रिया पुन: सुरु नगरी सेवा ठीक गर्न आवश्यक छ।

मानौं हामीसँग अझै पनि डिस्क स्पेस छ, तर फरक विभाजनमा, उदाहरणका लागि /घरमा।

हाम्रो कोड "फ्लाइमा पुन: प्रोग्राम" गर्ने प्रयास गरौं।

हाम्रो प्रक्रियाको 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 

अब पाइपमा समाप्त हुने सबै डाटा स्वचालित रूपमा नेटक्याटमा 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

डाटा बचत हुन्छ, समस्या हल हुन्छ।

म Degiro बाट मेरा सहकर्मीहरूलाई नमस्कार भन्न यो अवसर लिन्छु।
रेडियो-टी पोडकास्टहरू सुन्नुहोस्।

सब ठिक।

गृहकार्यको रूपमा, म सुझाव दिन्छु कि तपाइँ प्रक्रिया फाइल वर्णनकर्ता बिरालो र निद्रामा के हुनेछ यदि तपाइँ निम्न आदेश चलाउनुहुन्छ भने:

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

स्रोत: www.habr.com