SISTEME DE OPERARE

Conf.univ.dr. GENGE BÉLA

LABORATOR 5
Procese.
 Procese
• Un proces reprezintă un program alcătuit dintr-o secvență
de instrucțiuni, cu o stivă proprie și un numărător de
program propriu.
• Proces este, din punctul de vedere al SO, unitatea
fundamentală de organizare a programelor.
• Procesele facilitează izolarea codului ce rulează,
administrarea distinctă, respectiv execuția paralelă a
programelor.
• Orice proces este creat de către un alt proces (excepție
procesul init – creat la lansare SO).
• Procesul creator: părinte.
• Procesul creat: fiu.
• Fiecare proces are un identificator unic: PID.
 Comenzi specifice proceselor
• Comanda ps.
• pid și ppid.
• Comanda: ps –A –f

• Comanda: pstree
• Comanda: pstree -a

• Variabile speciale:
• $$ - pid
• $PPID – ppid
 Exerciții
• Exercițiul 1:
• Să se creeze un script care lansează N procese (script-
uri).
• Fiecare proces fiu va afișa pe linii diferite:
• Index-ul procesului (din cele N lansate)
• pid
• ppid
• numele utilizatorului cu care a fost lansat
• ID-ul utilizatorului (comanda “id –u <utilizator>”)
• Fiecare proces fiu va returna un număr diferit (vezi
comanda exit).
• Procesul părinte va aștepta terminarea execuției fiecărui
proces fiu și va afișa valoarea returnată.
Crearea proceselor fiu în limbajul C
• Crearea unui proces fiu din C:
• Funcția: pid_t fork()
• Se crează o copie a procesului părinte, cu PID propriu, stivă,
numărător de program și variabile proprii.
• Fiul va avea inițial variabilele și valorile acestora identice cu
cele din procesul părinte.
• Orice modificare făcută în fiu va fi vizibilă doar în
procesul fiu.
• Se moștenesc și descriptorii de fișiere!
• Din punctul de vedere al SO părintele și fiul sunt procese
distincte.
 Distincția dintre codul fiu și părinte
• Distincția dintre codul fiu și părinte prin valoarea returnată de funcția fork():
• -1: eroare.
• 0: în codul fiului.
• pid: în codul părintelui, unde pid este identificatorul de proces al fiului.

• Exercițiul 2: Să se demonstreze aplicarea funcției fork() pentru crearea unui

proces fiu. Să se afișeze pid pentru procesele fiu și părinte.
 Alte funcții/comenzi utile
• Funcții de așteptare:
• pid_t wait(int* status)
• pid_t wait(pid_t pid, int* status, int flags)

• Funcții de interogare:
• pid_t getpid()
• pid_t getppid()
• uid_t getuid()
• gid_t getgid()

• Comenzi de administrare (afișare/terminare):

• ps
• kill –semnal id_proces (ex: kill -9 pid)
• killall –semnal nume (ex: killall -9 nume)
 Alte aspecte utile
• Apelul funcției wait() pentru fiecare proces este
obligatorie!
• Dacă pentru un proces nu s-a apelat wait() de către
părinte, procesul devine zombie.
• Procesele zombie ocupă loc în tabelul de procese ale
kernelului, iar umplerea tabelului va duce la imposibilitatea
creării altor procese!
• Dacă procesul părinte se termină fără apelul wait() către fii,
aceștia sunt adoptați automat de către procesul init, care
apelează wait() pentru fiecare fiu.

• Pentru mai multe detalii a se consulta manualul wait() –

vezi exemplul de cod pentru utilizarea wait()!!!.
 Exerciții
• Exercițiul 3:
• Elaborați un program C care crează N procese fiu.
Fiecare proces fiu așteaptă 2 secunde, după care
afișează următoarele informații pe o singură linie:
• pid
• ppid
• uid
• guid
• După afișarea informațiilor de mai sus, fiecare proces
se va termina cu un cod diferit.
• Procesul părinte va aștepta fiecare proces fiu și va afișa
codul returnat de către fiecare proces fiu.
 Exerciții
• Exercițiul 4:
• Să se modifice procesele de la punctul 3 astfel încât
procesele părinte/fiu să nu se termine.
• Să se termine toate cele N+1 procese utilizând
comenzile kill și killall.