ფაილის აღმწერი Linux-ში მაგალითებით

ერთხელ, ინტერვიუს დროს მკითხეს, რას მოიმოქმედებთ, თუ აღმოაჩენთ, რომ სერვისი არ მუშაობს იმის გამო, რომ დისკს ადგილი ამოეწურა?

რათქმაუნდა ვუპასუხე, რომ ვნახავდი ამ ადგილს და თუ შეიძლება, მოვასუფთავებდი ადგილს.
შემდეგ ინტერვიუერმა ჰკითხა, რა მოხდება, თუ არ არის თავისუფალი ადგილი დანაყოფზე, მაგრამ ასევე ვერ ხედავთ ფაილებს, რომლებიც მთელ ადგილს დაიკავებენ?

ამაზე მე ვთქვი, რომ თქვენ ყოველთვის შეგიძლიათ შეხედოთ ღია ფაილის აღწერებს, მაგალითად, lsof ბრძანებით, და გაიგოთ, რომელმა აპლიკაციამ დაიკავა მთელი არსებული სივრცე, შემდეგ კი შეგიძლიათ იმოქმედოთ გარემოებების მიხედვით, იმის მიხედვით, საჭიროა თუ არა მონაცემები. .

ინტერვიუერმა ბოლო სიტყვაზე შემაწყვეტინა და დაუმატა თავის შეკითხვას: „დავუშვათ, რომ ჩვენ არ გვჭირდება მონაცემები, ეს მხოლოდ გამართვის ჟურნალია, მაგრამ აპლიკაცია არ მუშაობს, რადგან მას არ შეუძლია გამართვის დაწერა“?

”კარგი,” ვუპასუხე მე, ”ჩვენ შეგვიძლია გამორთოთ გამართვა პროგრამის კონფიგურაციაში და გადატვირთოთ იგი.”
ინტერვიუერმა გააპროტესტა: „არა, ჩვენ არ შეგვიძლია აპლიკაციის გადატვირთვა, ჩვენ ჯერ კიდევ გვაქვს მეხსიერებაში შენახული მნიშვნელოვანი მონაცემები და მნიშვნელოვანი კლიენტები დაკავშირებულია თავად სერვისთან, რომელსაც ჩვენ ვერ ვაიძულებთ ხელახლა დაკავშირებას“.

”კარგი,” ვუთხარი მე, ”თუ ჩვენ არ შეგვიძლია გადატვირთოთ აპლიკაცია და მონაცემები ჩვენთვის არ არის მნიშვნელოვანი, მაშინ ჩვენ შეგვიძლია უბრალოდ გავწმინდოთ ეს ღია ფაილი ფაილის აღწერის საშუალებით, თუნდაც ის ვერ დავინახოთ ls ბრძანებაში. ფაილურ სისტემაზე“.

ინტერვიუერი კმაყოფილი იყო, მე კი არა.

შემდეგ ვიფიქრე, რატომ არ იჭრება ის, ვინც ჩემს ცოდნას ამოწმებს? მაგრამ რა მოხდება, თუ მონაცემები მნიშვნელოვანია? რა მოხდება, თუ ჩვენ ვერ გადავტვირთავთ პროცესს და პროცესი ჩაწერს ფაილურ სისტემას დანაყოფზე, რომელსაც თავისუფალი ადგილი არ აქვს? რა მოხდება, თუ ჩვენ ვერ დავკარგავთ არა მხოლოდ უკვე დაწერილ მონაცემებს, არამედ იმ მონაცემებსაც, რომლებსაც ეს პროცესი წერს ან ცდილობს დაწეროს?

ტუზიკი

ჩემი კარიერის დასაწყისში ვცდილობდი შემექმნა პატარა აპლიკაცია, რომელიც საჭიროებდა მომხმარებლის ინფორმაციის შესანახად. შემდეგ ვიფიქრე, როგორ დავამთხვიო მომხმარებელი მის მონაცემებთან. მაგალითად, მე მყავს ივანოვი ივან ივანოვიჩი და მას აქვს გარკვეული ინფორმაცია, მაგრამ როგორ შემიძლია მათთან დამეგობრება? პირდაპირ შემიძლია აღვნიშნო, რომ ძაღლი სახელად "ტუზიკი" სწორედ ამ ივანეს ეკუთვნის. მაგრამ რა მოხდება, თუ ის შეცვლის სახელს და ივანეს ნაცვლად ხდება, მაგალითად, ოლია? მერე გამოვა, რომ ჩვენს ოლია ივანოვნა ივანოვას ძაღლი აღარ ეყოლება და ჩვენი ტუზიკი მაინც არარსებულ ივანეს ეკუთვნით. მონაცემთა ბაზა, რომელიც თითოეულ მომხმარებელს აძლევდა უნიკალურ იდენტიფიკატორს (ID) დაეხმარა ამ პრობლემის მოგვარებას და ჩემი Tuzik მიბმული იყო ამ ID-თან, რომელიც, ფაქტობრივად, მხოლოდ სერიული ნომერი იყო. ამრიგად, ტუზის მფლობელს ჰქონდა პირადობის მოწმობის ნომერი 2 და რაღაც მომენტში ივანე იყო ამ პირადობის მოწმობის ქვეშ, შემდეგ კი ოლია გახდა იგივე პირადობის მოწმობის ქვეშ. კაცობრიობისა და მეცხოველეობის პრობლემა პრაქტიკულად მოგვარდა.

ფაილის აღმწერი

ფაილის და პროგრამის პრობლემა, რომელიც მუშაობს ამ ფაილთან, დაახლოებით იგივეა, რაც ჩვენი ძაღლისა და ადამიანის პრობლემა. დავუშვათ, გავხსენი ფაილი სახელად 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-ის მიერ და არა დაკავშირებული ბიბლიოთეკის მიერ.

ახლა სამივე აღწერის ფაილი ასოცირდება ფსევდო ტერმინალურ მოწყობილობასთან /dev/pts, მაგრამ მაინც შეგვიძლია მათი მანიპულირება, მაგალითად, მეორე კონსოლში გაშვება

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

და პირველ კონსოლში დავინახავთ

[user@localhost ]$ hello world

გადამისამართება და მილები

თქვენ შეგიძლიათ მარტივად გადააცილოთ ეს 3 აღწერის ფაილი ნებისმიერ პროცესში, მათ შორის bash-ში, მაგალითად, მილის მეშვეობით, რომელიც აკავშირებს ორ პროცესს, იხ.

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

ამ ბრძანების გაშვება თავად შეგიძლიათ ზოლი -ფ და ნახეთ რა ხდება შიგნით, მაგრამ მოკლედ გეტყვით.

ჩვენი მშობელი bash პროცესი 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.

პირველი ბავშვის ბაშის პროცესში PID 9004, სისტემური ზარი dup2, ცვლის ჩვენი STDOUT ფაილის აღმწერი ნომერი 1 ფაილის აღწერით, რომელიც მიუთითებს მილზე, ჩვენს შემთხვევაში ეს არის ნომერი 3. ამრიგად, ყველაფერი, რასაც პირველი შვილი ამუშავებს PID 9004-ით STDOUT-ზე წერს, ავტომატურად დასრულდება მილის ბუფერში.

მეორე შვილის პროცესში PID 9005-ით, bash იყენებს dup2 ფაილის აღწერის STDIN ნომრის შესაცვლელად. ახლა ყველაფერი, რასაც ჩვენი მეორე bash PID 0-ით წაიკითხავს, ​​წაიკითხება მილიდან.

ამის შემდეგ, 3 და 4 ნომრიანი ფაილის აღწერები ასევე იხურება ბავშვის პროცესებში, რადგან ისინი აღარ გამოიყენება.

მე განზრახ უგულებელყოფ ფაილის აღწერს 255; ის გამოიყენება შიდა მიზნებისთვის ბაშის მიერ და ასევე დაიხურება შვილობილი პროცესებში.

შემდეგი, PID 9004-ით პირველი შვილის პროცესში, bash იწყებს სისტემური ზარის გამოყენებას აღმასრულებელი შესრულებადი ფაილი, რომელიც ჩვენ დავაზუსტეთ ბრძანების ხაზზე, ჩვენს შემთხვევაში ეს არის /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

როგორც ხედავთ, ჩვენი მილის უნიკალური რაოდენობა ორივე პროცესში ერთნაირია. ამრიგად, ჩვენ გვაქვს კავშირი ორ განსხვავებულ პროცესს შორის ერთსა და იმავე მშობელთან.

მათთვის, ვინც არ იცნობს სისტემურ ზარებს, რომლებსაც bash იყენებს, უაღრესად გირჩევთ გაუშვათ ბრძანებები strace-ში და ნახოთ რა ხდება შიგნით, მაგალითად, ასე:

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-ის შემდეგ trunk-ში მხოლოდ იმ შემთხვევაში, თუ გავხსნით ფაილს დამატებითი ჩაწერისთვის, რაც ნიშნავს ჩვენს კოდში.

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

უნდა დავაყენოთ

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

შემოწმება "w" დროშით

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

და "ა" დროშით

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

უკვე გაშვებული პროცესის დაპროგრამება

ხშირად პროგრამისტები, პროგრამების შექმნისა და ტესტირებისას, იყენებენ გამართვებს (მაგალითად, GDB) ან აპლიკაციაში შესვლის სხვადასხვა დონეს. Linux იძლევა შესაძლებლობას რეალურად დაწეროთ და შეცვალოთ უკვე გაშვებული პროგრამა, მაგალითად, შეცვალოთ ცვლადების მნიშვნელობები, დააყენოთ წყვეტის წერტილი და ა.შ. და ა.შ.

დავუბრუნდეთ თავდაპირველ კითხვას ფაილის ჩასაწერად დისკზე არასაკმარისი ადგილის შესახებ, შევეცადოთ პრობლემის სიმულაცია.

მოდით შევქმნათ ფაილი ჩვენი დანაყოფისთვის, რომელსაც ცალკე დისკად დავამონტაჟებთ:

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

მოდით შევქმნათ ფაილური სისტემა:

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

დააინსტალირეთ ფაილური სისტემა:

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

ჩვენ ვქმნით დირექტორიას ჩვენს მფლობელთან:

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

მოდით გავხსნათ ფაილი ჩასაწერად მხოლოდ ჩვენს პროგრამაში:

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

გაშვება

[user@localhost ]$ python openforwrite.py 

ველოდებით რამდენიმე წამს

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

ასე რომ, ჩვენ გვაქვს ამ სტატიის დასაწყისში აღწერილი პრობლემა. თავისუფალი ადგილი 0, 100% დაკავებული.

გვახსოვს, რომ დავალების პირობების მიხედვით, ვცდილობთ ჩავწეროთ ძალიან მნიშვნელოვანი მონაცემები, რომელთა დაკარგვაც შეუძლებელია. და ამავდროულად, ჩვენ უნდა დავაფიქსიროთ სერვისი პროცესის გადატვირთვის გარეშე.

ვთქვათ, ჯერ კიდევ გვაქვს ადგილი დისკზე, მაგრამ სხვა დანაყოფში, მაგალითად, /home-ში.

მოდით ვცადოთ ჩვენი კოდის „გადაპროგრამება ფრენაზე“.

მოდით შევხედოთ ჩვენი პროცესის PID-ს, რომელმაც დისკის მთელი ადგილი შეჭამა:

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

დაუკავშირდით პროცესს 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 ბიტი იცვლება რიცხვითი მნიშვნელობით. ამისათვის გახსენით ბირთვის წყაროები, მაგალითად აქ და ნახეთ, რომელი დროშები რაზეა პასუხისმგებელი

#define O_WRONLY 00000001
#define O_CREAT 00000100
#define 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

მონაცემები არ იკარგება, აპლიკაცია მუშაობს, ჟურნალები იწერება ახალ ადგილას.

ცოტა გავართულოთ დავალება

წარმოვიდგინოთ, რომ მონაცემები ჩვენთვის მნიშვნელოვანია, მაგრამ არცერთ დანაყოფში არ გვაქვს დისკის ადგილი და ვერ ვუკავშირდებით დისკს.

რაც შეგვიძლია გავაკეთოთ არის ჩვენი მონაცემების გადამისამართება სადმე, მაგალითად, მილისკენ, და თავის მხრივ მონაცემების გადამისამართება მილიდან ქსელში რაიმე პროგრამის საშუალებით, მაგალითად netcat.
ჩვენ შეგვიძლია შევქმნათ დასახელებული მილი 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

ახლა ჩვენ უნდა როგორმე გადავიტანოთ ყველა მონაცემი, რომელიც შედის ამ მილში, ქსელის საშუალებით სხვა სერვერზე; იგივე netcat შესაფერისია ამისათვის.

სერვერზე remote-server.example.com ჩვენ გავდივართ

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

ჩვენს პრობლემურ სერვერზე ჩვენ ვიშვებთ ცალკე ტერმინალში

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

ახლა ყველა მონაცემი, რომელიც მთავრდება მილში, ავტომატურად გადადის stdin-ზე netcat-ში, რომელიც მას 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

მონაცემები შენახულია, პრობლემა მოგვარებულია.

ვისარგებლებ შემთხვევით და მივესალმები ჩემს კოლეგებს დეჟიროდან.
მოუსმინეთ Radio-T პოდკასტებს.

ყველასათვის კარგი.

როგორც საშინაო დავალება, გირჩევთ დაფიქრდეთ იმაზე, თუ რა იქნება პროცესის ფაილის აღწერები კატა და ძილი, თუ გაუშვით შემდეგი ბრძანება:

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

წყარო: www.habr.com