Jednom prilikom, na intervjuu su me pitali šta bi uradio ako otkriješ da usluga ne radi jer je na disku nestalo prostora?
Naravno, odgovorio sam da ću pogledati šta zauzima to mesto i ako je moguće, oslobodiću prostor.
Tada me intervjuera upitao, a šta ako u particiji nema slobodnog prostora, ali ni fajlova koji zauzimaju sve mesto, ti takođe ne vidiš?
Na to sam rekao da uvek možemo pogledati otvorene fajl deskriptore, na primer komandama lsof i shvatiti koja aplikacija zauzima sve dostupno mesto, a zatim možemo delovati u zavisnosti od okolnosti, u zavisnosti od toga da li su podaci potrebni.
Interviewer me prekinuo na poslednjoj reči, dopunjujući svoje pitanje: "Pretpostavimo da podaci nisu potrebni, to je samo debag log, ali aplikacija ne radi jer ne može da zapiše debag"?
"U redu", odgovorio sam, "možemo isključiti debag u konfiguraciji aplikacije i ponovo je pokrenuti."
Interviewer je prigovorio: "Ne, aplikaciju ne možemo ponovo pokrenuti, u memoriji se još uvek čuvaju važni podaci, a samoj usluzi su povezani važni klijenti koje ne možemo primorati da se ponovo povežu."
"Dobro", rekoh, "ako ne možemo ponovo pokrenuti aplikaciju i podaci nam nisu važni, možemo jednostavno očistiti ovaj otvoreni fajl preko fajl deskriptora, čak i ako ga ne vidimo u komandi ls na fajl sistemu."
Interviewer je bio zadovoljan, a ja nisam.
Tada sam pomislio, zašto osoba koja proverava moje znanje ne kopaju dublje? A šta ako su podaci ipak važni? Šta ako ne možemo ponovo pokrenuti proces, a pri tom taj proces piše na fajl sistem u particiju gde nema slobodnog mesta? Šta ako ne možemo izgubiti ne samo već zabeležene podatke, već i podatke koje ovaj proces piše ili pokušava da zapiše?
Tuzik
Na početku svoje karijere pokušao sam stvoriti malu aplikaciju u kojoj je trebalo čuvati informacije o korisnicima. Tada sam razmišljao o tome kako da povežem korisnika sa njegovim podacima. Recimo, imam Ivana Ivanovića i on ima neke podatke, ali kako ih povezati? Mogu direktno navesti da pas po imenu "Tuzik" pripada tom Ivanu. Ali šta ako promeni ime i umesto Ivana postane, na primer, Olya? Tada bi se ispostavilo da naša Olya Ivanovna Ivanova više ne bi imala psa, a naš Tuzik bi i dalje pripadao nepostojećem Ivanu. Ovaj problem rešila je baza podataka koja je svakom korisniku dodelila jedinstveni identifikator (ID), i moj Tuzik je bio povezan sa tim ID-jem, koji je u suštini bio samo redni broj. Tako je vlasnik Tuzika imao ID broj 2, i u nekom trenutku pod tim ID-jem bio je Ivan, a zatim pod tim istim ID-jem postala je Olya. Problem čovečanstva i stočarstva je praktično rešen.
Fajl descriptor
Problem fajla i programa koji radi sa tim fajlom sličan je našem psu i čoveku. Pretpostavimo da sam otvorio fajl pod imenom ivan.txt i počeo u njega upisivati reč tuzik, ali sam uspeo da upišem samo prvo slovo „t“ u fajl, a ovaj fajl je neko preimenovao, na primer, u olya.txt. Ali fajl je ostao isti i još uvek želim da upišem svog Tuzika u njega. Svaki put prilikom otvaranja fajla sistemskim pozivom u bilo kom programskom jeziku dobijam jedinstveni ID koji mi pokazuje na fajl, taj ID i jeste fajl descriptor. I potpuno je nevažno šta i ko dalje radi sa tim fajlom, može ga obrisati, može ga preimenovati, može mu promeniti vlasnika ili oduzeti prava za čitanje i pisanje, i dalje ću imati pristup njemu, jer sam prilikom otvaranja fajla imao prava za njegovo čitanje i/ili pisanje i uspeo sam da počnem da radim s njim, a to znači da moram nastaviti to raditi.
U Linuxu biblioteka libc otvara za svaku pokrenutu aplikaciju (proces) 3 fajl deskriptora, sa brojevima 0, 1, 2. Više informacija možete pronaći na linkovima i
- Fajl descriptor 0 se naziva STDIN i povezan je sa ulazom podataka u aplikaciji
- Datoteka opisa 1 se naziva STDOUT i koristi se od strane aplikacija za ispis podataka, poput komandi print
- Datoteka opisa 2 se naziva STDERR i koristi se od strane aplikacija za ispis podataka koji javljaju greške
Ako u vašem programu otvorite bilo koju datoteku za čitanje ili pisanje, verovatno ćete dobiti prvi slobodan ID, a to će biti broj 3.
Spisak datoteka opisa možete videti kod bilo kojeg procesa, ako znate njegov PID.
Na primer, otvorimo konzolu sa bashom i pogledajmo PID našeg procesa
[user@localhost ]$ echo $$
15771
U drugoj konzoli pokrenimo
[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
Datoteku opisa sa brojem 255 slobodno možete ignorisati u okviru ovog članka, ona je već otvorena za svoje potrebe od strane samog basha, a ne povezane biblioteke.
Sada su sva 3 datoteka opisa povezana sa uređajem pseudoterminala , ali svejedno možemo njima upravljati, na primer, pokrenimo u drugoj konzoli
[user@localhost ]$ echo "hello world" > /proc/15771/fd/0
I u prvoj konzoli ćemo videti
[user@localhost ]$ hello world
Preusmeravanje i Cevi
Možete lako da prepravite ove 3 datoteke opisa u bilo kojem procesu, uključujući i bash, na primer, putem cevi (pipe) koja povezuje dva procesa, pogledajmo
[user@localhost ]$ cat /dev/zero | sleep 10000
Možete sami pokrenuti ovu komandu sa strace -f i videti šta se dešava unutra, ali ću ukratko ispričati.
Naš roditeljski proces bash sa PID 15771 parsira našu komandu i razume koliko tačno komandi želimo pokrenuti, u našem slučaju dve: cat i sleep. Bash zna da treba da kreira dva potomka procesa i poveže ih jednom cevi. U tom slučaju basha su potrebna 2 potomka procesa i jedna cev.
Pre nego što kreira potomke procesa, bash pokreće sistemski poziv i dobija nove datoteke opisa na privremeni bafer cevi, ali ova bafer za sada ne povezuje naša dva potomka procesa.
Za roditeljski proces izgleda kao da cev već postoji, a potomaka procesa još nema:
PID komanda
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
Zatim, koristeći sistemski poziv bash stvara dva potomka, i naša tri procesa će izgledati ovako:
PID komanda
15771 bash
lrwx------ 1 korisnik korisnik 64 Okt 7 15:42 0 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:42 1 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:42 2 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:42 3 -> pipe:[253543032]
lrwx------ 1 korisnik korisnik 64 Okt 7 15:42 4 -> pipe:[253543032]
lrwx------ 1 korisnik korisnik 64 Okt 7 15:42 255 -> /dev/pts/21
PID komanda
9004 bash
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 0 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 1 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 2 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 3 -> pipe:[253543032]
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 4 -> pipe:[253543032]
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 255 -> /dev/pts/21
PID komanda
9005 bash
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 0 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 1 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 2 -> /dev/pts/21
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 3 -> pipe:[253543032]
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 4 -> pipe:[253543032]
lrwx------ 1 korisnik korisnik 64 Okt 7 15:57 255 -> /dev/pts/21
Ne zaboravite, da clone klonira proces zajedno sa svim deskriptorima datoteka, tako da će u roditeljskom procesu i u potomcima biti isti. Zadatak roditeljskog procesa sa PID 15771 je da prati potomke, pa samo čeka odgovor od njih.
Stoga mu pipe nije potreban, i zatvara deskriptore datoteka sa brojevima 3 i 4.
U prvom potomku bash sa PID 9004, sistemskim pozivom , menja naš STDOUT deskriptor datoteka sa brojem 1 na deskriptor datoteka koji ukazuje na pipe, u našem slučaju to je broj 3. Tako će sve što prvi potomak sa PID 9004 napiše u STDOUT, automatski ići u bafer pipe-a.
U drugom potomku sa PID 9005, bash menja pomoću dup2 deskriptor datoteka STDIN sa brojem 0. Sada će sve što naš drugi bash sa PID 9005 bude čitao, čitati iz pipe-a.
Nakon toga, u potomcima se takođe zatvaraju deskriptori datoteka sa brojevima 3 i 4, jer više nisu u upotrebi.
Deskriptor datoteka 255 namerno ignorišem, on se koristi za unutrašnje potrebe samog basha i u potomcima će takođe biti zatvoren.
Zatim, u prvom potomku sa PID 9004 bash pokreće pomoću sistemskog poziva izvršni fajl koji smo naveli u komandnoj liniji, u našem slučaju to je /usr/bin/cat.
U drugom potomku sa PID 9005 bash pokreće drugi izvršni fajl koji smo naveli, u našem slučaju to je /usr/bin/sleep.
Sistemski poziv exec ne zatvara deskriptore datoteka ako nisu otvoreni s oznakom O_CLOEXEC prilikom poziva open. U našem slučaju, nakon pokretanja izvršnih datoteka, svi aktuelni deskriptori datoteka će ostati sačuvani.
Proveravamo u konzoli:
[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
Kao što vidite, jedinstveni broj našeg pipe-a se u oba procesa poklapa. Na taj način imamo vezu između dva različita procesa s jednim roditeljem.
Za one koji nisu upoznati sa sistemskim pozivima koje koristi bash, toplo preporučujem da pokrenete komande kroz strace i pogledate šta se dešava unutra, na primer ovako:
strace -s 1024 -f bash -c "ls | grep hello"
Vratimo se našem problemu sa nedostatkom prostora na disku i pokušajem da sačuvamo podatke bez ponovnog pokretanja procesa. Napišimo mali program koji će pisati na disk približno 1 megabajt u sekundi. U tom slučaju, ako iz bilo kojeg razloga ne budemo mogli da zapišemo podatke na disk, jednostavno ćemo to ignorisati i pokušati ponovo da zapišemo podatke za sekundu. U primeru koristim Python, možete koristiti bilo koji drugi programski jezik.
[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
Pokrenimo program i pogledajmo deskriptore datoteka
[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
Kao što možemo vidjeti, imamo svoja 3 standardna deskriptora datoteka i još jedan, koji smo otvorili. Provjerimo veličinu datoteke:
[user@localhost ]$ ls -lah 123.txt
-rw-rw-r-- 1 user user 117M Oct 7 16:30 123.txt
Podaci se pišu, pokušavamo promijeniti prava na datoteci:
[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
Vidimo da se podaci još uvijek pišu, iako naš korisnik nema pravo pisati u datoteku. Pokušajmo je obrisati:
[user@localhost ]$ sudo rm 123.txt
[user@localhost ]$ ls 123.txt
ls: cannot access 123.txt: No such file or directory
Gdje se podaci pišu? I da li se uopšte pišu? Provjeravamo:
[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)
Da, naš deskriptor datoteke još uvijek postoji, i možemo raditi s tim deskriptorom kao s našom starom datotekom, možemo je čitati, čistiti i kopirati.
Pogledajmo veličinu datoteke:
[user@localhost ]$ lsof | grep 123.txt
python 31083 user 3w REG 8,5 19923457 2621522 /home/user/123.txt
Veličina datoteke je 19923457. Pokušavamo očistiti datoteku:
[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
Kao što vidimo, veličina datoteke se samo povećava i naš truncate nije uspio. Obratit ćemo se dokumentaciji o sistemskom pozivu . Ako pri otvaranju datoteke koristimo oznaku O_APPEND, tada operativni sistem prilikom svake zapisivanja provjerava veličinu datoteke i zapisuje podatke na kraj datoteke, a to radi atomarno. To omogućava više niti ili procesa da pišu u istu datoteku. Međutim, u našem kodu ne koristimo ovu oznaku. Možemo vidjeti drugu veličinu datoteke u lsof nakon truncate samo ako otvorimo datoteku za dopisivanje, a to znači da u našem kodu umjesto
with open("123.txt", "w") as f:
moramo postaviti
with open("123.txt", "a") as f:
Provjeravamo s oznakom „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
i sa „a“ flagom
[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
Programiramo već pokrenut proces
Programeri često koriste debagere (na primjer GDB) ili razne nivoe logiranja prilikom izrade i testiranja programa. Linux omogućava da zapravo pišemo i menjamo već pokrenutu program, na primjer menjanje vrednosti promenljivih, postavljanje breakpoint-a i slično.
Vraćajući se na početno pitanje o nedostatku prostora na disku za zapisivanje fajla, pokušaćemo da simuliramo problem.
Kreiraćemo fajl za našu particiju, koji ćemo podmontirati kao poseban disk:
[user@localhost ~]$ dd if=/dev/zero of=~/tempfile_for_article.dd bs=1M count=10
10+0 zapisa unetih
10+0 zapisa izlaznih
10485760 bajtova (10 MB) kopirano, 0.00525929 s, 2.0 GB/s
[user@localhost ~]$
Kreiraćemo fajlsku sistem:
[user@localhost ~]$ mkfs.ext4 ~/tempfile_for_article.dd
mke2fs 1.42.9 (28-Dec-2013)
/home/user/tempfile_for_article.dd nije blok uređaj.
Da li da nastavite? (y,n) y
...
Pisanje superblokova i informacija o računovodstvu fajlskog sistema: gotovo
[user@localhost ~]$
Podmontiramo fajlsku sistem:
[user@localhost ~]$ sudo mount ~/tempfile_for_article.dd /mnt/
[sudo] lozinka za korisnika:
[user@localhost ~]$ df -h | grep mnt
/dev/loop0 8.7M 172K 7.9M 3% /mnt
Kreiramo direktorijum sa našim vlasnikom:
[user@localhost ~]$ sudo mkdir /mnt/logs
[user@localhost ~]$ sudo chown user: /mnt/logs
Otvorimo fajl samo za pisanje u našoj programu:
with open("/mnt/logs/123.txt", "w") as f:
Pokrećemo
[user@localhost ]$ python openforwrite.py
Čekamo nekoliko sekundi
[user@localhost ~]$ df -h | grep mnt
/dev/loop0 8.7M 8.0M 0 100% /mnt
Dakle, došli smo do problema opisanog na početku ovog članka. Slobodnog prostora 0, zauzetog 100%.
Sećamo se da, prema uslovima zadatka, pokušavamo da zabeležimo veoma važne podatke koje ne možemo izgubiti. A u isto vreme, potrebno je popraviti servis bez restartovanja procesa.
Pretpostavimo da imamo mesta na disku, ali u drugoj particiji, na primer u /home.
Pokušaćemo da 'preprogramiramo u hodu' naš kod.
Gledamo PID našeg procesa koji je ispunio sav prostor na disku:
[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
Povezujemo se na proces kroz gdb
[user@localhost ~]$ gdb -p 10078
...
(gdb)
Gledamo otvorene fajl deskriptore:
(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
Gledamo informacije o fajlskom deskripturu sa brojem 3, koji nas interesuje
(gdb) shell cat /proc/10078/fdinfo/3
pos: 8189952
flags: 0100001
mnt_id: 482
Sjećajući se kog sistemskog poziva Python radi (vidi gore, gdje smo pokrenuli strace i pronašli poziv open), obrađujući naš kod za otvaranje datoteke, radimo isto to sami u ime našeg procesa, ali bitove O_WRONLY|O_CREAT|O_TRUNC trebamo zamijeniti numeričkom vrijednošću. Da bismo to uradili, otvaramo izvorne kodove jezgra, na primjer i gledamo koje zastavice za šta odgovaraju
#define O_WRONLY 00000001
#define O_CREAT 00000100
#define O_TRUNC 00001000
Spajamo sve vrijednosti u jednu, dobijamo 00001101
Pokrećemo naš poziv iz gdb
(gdb) call open("/home/user/123.txt", 00001101,0666)
$1 = 4
Dakle, dobili smo novi deskriptor datoteke sa brojem 4 i novu otvorenu datoteku na drugom dijelu, provjeravamo:
(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
Sjećamo se primjera sa pipe — kako bash mijenja deskriptore datoteka, i već znamo sistemski poziv dup2.
Pokušavamo zamijeniti jedan deskriptor datoteke drugim
(gdb) call dup2(4,3)
$2 = 3
Proveravamo:
(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
Zatvaramo deskriptor datoteke 4, jer nam nije potreban:
(gdb) call close (4)
$1 = 0
I izlazimo iz 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
Provjeravamo novu datoteku:
[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
Kao što vidimo, podaci se upisuju u novu datoteku, provjeravamo staru:
[user@localhost ~]$ ls -lah /mnt/logs/123.txt
-rw-rw-r-- 1 user user 7.9M Oct 8 11:08 /mnt/logs/123.txt
Podaci nisu izgubljeni, aplikacija radi, logovi se upisuju na novo mjesto.
Malo otežavamo zadatak
Zamislimo da su nam podaci važni, ali nemamo prostora na disku u nijednom od dijelova i ne možemo priključiti disk.
Što možemo učiniti, tako je preusmjeriti naše podatke negdje, na primjer u pipe, a podatke iz pipe preusmjeriti u mrežu pomoću nekog programa, na primjer netcat.
Možemo stvoriti imenovani pipe komandnom mkfifo. Ona će stvoriti pseudodatoteku na datotečnom sistemu, čak i ako na njoj nema slobodnog prostora.
Ponovo pokrećemo aplikaciju i proveravamo:
[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
Nema prostora na disku, ali uspešno kreiramo imenovani pipe:
[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
Sada treba na neki način da prebacimo sve podatke koji dolaze u ovaj pipe na drugi server preko mreže, za to može poslužiti netcat.
Na serveru remote-server.example.com pokrećemo
[user@localhost ~]$ nc -l 7777 > 123.txt
Na našem problematičnom serveru pokrećemo u drugom terminalu
[user@localhost ~]$ nc remote-server.example.com 7777 < /mnt/logs/megapipe
Svi podaci koji dođu u pipe automatski idu na stdin u netcat, koji ih šalje na mrežu na port 7777.
Sve što treba da uradimo je da počnemo da pišemo naše podatke u ovaj imenovani pipe.
Već imamo pokrenutu aplikaciju:
[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
Od svih zastavica, potrebna nam je samo O_WRONLY jer fajl već postoji i ne treba da ga čistimo.
[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
Provjeravamo udaljeni server remote-server.example.com
[user@localhost ~]$ ls -lah 123.txt
-rw-rw-r-- 1 user user 38M Oct 8 14:21 123.txt
Podaci dolaze, provjeravamo problematični server
[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
Podaci su sačuvani, problem je rešen.
Iskoristivši priliku, pozdravljam kolege iz kompanije Degiro.
Slušajte podcaste Radio-T.
Svima dobra volja.
Kao domaći zadatak predlažem da razmislite šta će biti u fajlovim deskriptorima procesa cat i sleep ako pokrenete ovu komandu:
[user@localhost ~]$ cat /dev/zero 2>/dev/null| sleep 10000
Izvor: habr.com
