Executia pas cu pas a proceselor - UNIX

Executia pas cu pas a proceselor - UNIX

Sistemul de operare UNIX pune la dispozitie o modalitate rudimentara de comunicare intre procese in scopul executarii pas cu pas a acestora, facilitate utila in depanarea programelor. Un proces depanator (debugger process), cum ar fi sdb, creeaza un proces pe care il executa pas cu pas si ii controleaza executia cu ajutorul apelului sistem ptrace, stabilind si anuland puncte de intrerupere (breakpoints) si scriind (citind) date in (din) spatiul sau virtual de adrese. In consecinta, executia pas cu pas a unui proces consta in sincronizarea executiei procesului depanator cu cea a procesului depanat si in controlul executiei celui de-al doilea.

Figura 10.1. Structura unui proces de depanare

Pseudocodul din figura 10.1. pune in evidenta o structura caracteristica pentru un program de depanare. Procesul depanator creeaza un proces fiu, care invoca apelul sistem ptrace al carui rezultat este pozitionarea pe 1 a bitului de executie pas cu pas in intrarea corespunzatoare procesului fiu, din tabela de procese. Procesul fiu executa, prin apelul sistem exec, programul care urmeaza sa fie depanat. De exemplu, daca utilizatorul doreste sa depaneze programul a.out , atunci argumentul transmis apelului sistem exec va fi sirul de caractere a.out si procesul fiu va executa acest program. Nucleul va executa apelul sistem exec ca de obicei, dar la sfarsit va observa faptul ca bitul de executie pas cu pas este pozitionat pe 1 si, in consecinta, va trimite procesului fiu un semnal trap. La intoarcerea din apelul sistem exec, nucleul verifica daca s-au trimis semnale -asa cum o face, de altfel, la intoarcerea din orice alt apel sistem- gaseste semnalul "trap" pe care, chiar el, tocmai l-a trimis si executa pas cu pas codul procesului fiu, intocmai ca pe o secventa speciala de tratare a semnalelor. Observand pozitionarea pe 1 a bitului de executie pas cu pas din propria intrare in tabela de procese, procesul fiu trezeste procesul parinte din starea de asteptare in care intrase prin executarea apelului sistem wait (dupa cum se va vedea mai tarziu), intra intr-o stare speciala de executie pas cu pas (trace), care nu este evidentiata in diagrama starilor proceselor si face o comutare de context.

In mod obisnuit, procesul parinte este deja intrat intr-un ciclu, asteptand sa fie trezit de catre procesul fiu care se executa pas cu pas. Cand procesul fiu trezeste procesul parinte, acesta incheie executia apelului sistem wait, citeste comenzile de la intrare ale utilizatorului si le converteste intr-o serie de apeluri ptrace in scopul controlarii executiei procesului fiu.

Sintaxa apelului sistem ptrace este urmatoarea

ptrace( cmd, pid, addr, data)

unde cmd specifica diverse comenzi cum ar fi citirea sau scrierea datelor, ori reluarea executiei, pid reprezinta identificatorul de proces al procesului care se executa pas cu pas, addr reprezinta adresa virtuala, din cadrul procesului fiu, la (de la) care se va scrie (citi) si data reprezinta o valoare de tip intreg care va fi scrisa. La executarea apelului sistem ptrace, nucleul verifica daca procesul depanator are vreun proces fiu al carui identificator este egal cu valoarea parametrului pid si daca acest proces fiu se afla in starea "executie pas cu pas", utilizind apoi o structura de date globala, dedicata executiei pas cu pas, pentru realizarea transferului de date intre cele doua procese. Nucleul blocheaza accesul la structura de date globala amintita, pentru a impiedica scrierea de catre alte procese aflate in executie pas cu pas, copiaza valorile parametrilor cmd, addr si data in structura de date, trezeste procesul fiu si-l trece in starea "gata de executie", punandu-se apoi in asteptare pina la sosirea raspunsului de la procesul fiu. Cand procesul fiu isi reia executia (in modul nucleu), el executa comanda prevazuta in parametrul cmd, scrie rezultatul executarii comenzii in structura de date globala dedicata executiei pas cu pas si apoi trezeste procesul depanator. In functie de comanda precizata prin parametrul cmd, procesul fiu poate sa reintre in starea "executie pas cu pas" asteptand o noua comanda, sau poate incheia tratarea semnalului reluandu-si executia. Cand procesul depanator isi reia executia, nucleul memoreaza valoarea de retur furnizata de procesul executat pas cu pas, deblocheaza accesul la structura de date globala corespunzatoare si reda controlul utilizatorului.

Daca, in momentul intrarii procesului fiu in starea "executie pas cu pas", procesul depanator nu se afla in asteptare in apelul sistem wait, el nu va putea determina care este procesul fiu ce se va executa pas cu pas, decat in momentul invocarii apelului sistem wait, moment in care se va termina imediat si va proceda asa cum tocmai a fost descris mai sus.

Figura 10.2. Programul trace -- un proces executat pas cu pas

Sa luam in consideratie cele doua programe, denumite trace si debug, prezentate in figurile 10.2 si respectiv 10.3. Ruland programul trace la terminal, valorile vectorului data vor fi egale cu zero procesul afiseaza adresa vectorului data si isi incheie executia. Ruland acum programul debug , avand ca parametru o valoare egala cu cea afisata de catre programul trace, acesta salveaza valoarea parametrului ce i s-a transmis in variabila addr , creeaza un proces fiu care invoca apelul sistem ptrace pentru a putea executa pas cu pas si un alt proces executa programul trace.

#define TR_SETUP 0

#define TR_WRITE 5

#define TR_RESUME 7

int addr;

main(argc,argv)

int argc;

char *argv[ ]t;

for(i=0;i<32;i++)

/* procesul executat pas cu pas isi reia executia */

ptrace(TR_RESUME,pid,1,0);

}

Figura 10.3 Debug-un proces de executie pas cu pas

La sfarsitul executiei apelului sistem exec, nucleul trimite procesului fiu (sa-l numim procesul trace) un semnal SIGTRAP, iar procesul trace intra in starea "executie pas cu pas", asteptand comenzi de la procesul debug. Daca procesul debug se afla in asteptare in algoritmul wait, acesta se trezeste, gaseste procesul fiu executat pas cu pas si paraseste apelul wait. Apoi, procesul debug invoca apelul sistem ptrace, scrie valoarea variabilei de ciclare i in spatiul de adrese al procesului trace si incrementeaza valoarea din variabila addr in cadrul procesului trace, variabila addr reprezinta adresa unei intrari din vectorul data. Ultima invocare a apelului ptrace de catre procesul debug are ca efect executia procesului trace , iar in acest caz vectorul data contine valorile de la 0 la 31. Un program depanator cum ar fi sdb are acces la tabela de simboluri a procesului executat pas cu pas, din continutul careia determina adresele utilizate ca parametri pentru apelurile procedurii ptrace.

Utilizarea apelului sistem ptrace in scopul executarii pas cu pas a proceselor, este o metoda rudimentara care prezinta mai multe dezavantaje.

Nucleul trebuie sa execute patru comutari de context, pentru a realiza transferul a doi octeti de date intre procesul depanator si procesul executat pas cu pas nucleul executa o comutare de context in cadrul procesului depanator la invocarea apelului sistem ptrace, pana cand procesul executat pas cu pas trimite un raspuns,comuta contextul la si de la procesul executat pas cu pas, si comuta contextul inapoi la procesul depanator impreuna cu raspunsul catre apelul ptrace. Aceste comutari sunt necesare, intrucat un proces depanator nu are alta modalitate de a accesa spatiul virtual de adrese al procesului executat pas cu pas, si in consecinta este un proces lent.

Un proces depanator poate executa pas cu pas mai multe procese fiu simultan, cu toate ca, in practica, aceasta facilitate este rareori exploatata. Un aspect mai critic il reprezinta, insa, faptul ca un proces depanator nu poate executa pas cu pas decat procese fiu. Daca un proces fiu, executat pas cu pas, invoca apelul sistem fork (adica isi creeaza propriul proces fiu), atunci procesul depanator nu are nici un control asupra procesului "nepot" ceea ce reprezinta o restrictie majora in cazul depanarii programelor complexe. Daca un proces executat pas cu pas invoca apelul sistem exec, depanarea se continua si la nivelul imaginilor -ulterioare apelului exec - ale procesului depanat, din cauza apelului ptrace initial, depanatorul neputand, insa, sa stie numele imaginii procesului care a rezultat in urma apelului exec, ceea ce face dificila depanarea simbolica.

Un proces depanator nu poate executa pas cu pas un alt proces care se afla deja in executie, daca acesta din urma nu a invocat, in prealabil, apelul sistem ptrace , pentru a preveni nucleul asupra faptului ca permite executia sa, pas cu pas. Acest lucru este, de asemenea, un dezavantaj, deoarece pentru a executa pas cu pas un anumit proces aflat deja in executie, acesta trebuie in prealabil terminat (cu apelul kill) si relansat in executie, in modul "executie pas cu pas".

Nu este posibila executia pas cu pas a programelor de tip setuid, deoarece utilizatorii ar putea incalca drepturile de acces, avand posibilitatea de a scrie in spatiul virtual de adrese al acestor programe, cu ajutorul apelului sistem ptrace, si de a executa operatiuni nepermise. De exemplu, sa presupunem ca un astfel de program, invoca apelul exec avand ca parametru numele de fisier privatefile. Un utilizator istet s-ar putea folosi de apelul sistem ptrace pentru a modifica parametrul respectiv la valoarea ² bin sh², lansand astfel in executie shell-ul (cu toate programele asociate acestuia) fara a avea permisiunea de a o face. Apelul exec ignora valoarea bitului setuid daca procesul este executat pas cu pas, pentru a evita scrierea de catre un utilizator in cadrul spatiului de adrese al unui astfel de program.

Killian descrie o alta modalitate de executie pas cu pas a proceselor, bazata pe lucrul cu sistemele de fisiere, descris in capitolul 5 . Administratorul de sistem monteaza un sistem de fisiere, proc -utilizatorii identifica procesele pe baza identificatorilor acestora si le trateaza ca fiind fisiere din proc. Nucleul acorda permisiunea de deschidere a fisierelor, in conformitate cu identificatorul utilizatorului si identificatorul de grup. Utilizatorii au posibilitatea de a examina spatiul de adrese al procesului prin citire si de a stabili puncte de intrerupere prin scriere in fisier. Apelul stat furnizeaza diverse informatii de ordin statistic despre procese. Aceasta metoda inlatura trei dintre dezavantajele utilizarii apelului ptrace. Mai intai, aceasta metoda este mai rapida deoarece un proces depanator poate transfera o cantitate mai mare de date la un apel sistem, in comparatie cu apelul ptrace. In al doilea rand, un proces depanator poate executa pas cu pas orice proces, care nu trebuie sa fie neaparat un proces fiu al sau. In sfarsit, un proces depanat nu necesita masuri prealabile pentru a permite executia sa pas cu pas un proces depanator poate executa pas cu pas procese deja in curs de executie. Ca parte a mecanismului obisnuit de protectie a fisierelor, apare faptul ca doar superutilizatorul poate executa pas cu pas procesele de tip setuid pentru fisierele din radacina.