Procese

Linux este un sistem de operare multi-tasking, iar un sistem multi-tasking este un sistem de operare care permite executia
simultana a mai multor procese.

Fiecare instanta a unui program reprezinta un proces. Fiecare proces ce ruleaza sub Linux are asociat un identificator de
proces unic numit PID ( process identity number).

Pornind de la procesul 1 (init) fiecare proces are un parinte a carui PID ii este cunoscut.

De cele mai multe ori, procesele sunt utilizate atunci cand avem un task pe care dorim sa il impartim in mai multe procese.

De exemplu, un caz clasic ar fi cand avem o parte de UI si un background worker care executa anumite calcule.

UI-ul reprezinta procesul principal in acest caz. In UI, va aparea o iconita de loading. Ea apare atunci cand nu vrem
sa blocam thread-ul principal si totusi sa indicam ca intr-un alt proces se efectueaza calcule sau operatii.

Notiunea de Not responding la programe indica un management prost al proceselor.

Pentru a crea noi procese se foloseste apelul sistem fork care are urmatoarea semnatura:

Daca rezultatul functiei fork este <0 inseamna ca a avut loc o eroare la crearea noului proces.

Noul proces creat in urma apelului poarta numele de proces fiu, iar procesul care a apelat fork devine proces parinte al
noului proces creat.

In momentul apelarii functiei fork, se creaza o copie a programului curent in memoria sistemului de operare. Deasemenea
toate variabilele respectiv descriptorii de fisier din program sunt copiate in noul proces.

In momentul apelarii functiei folk, cele 2 procese difera prin PID, care este unic pentru fiecare proces.

PID-ul se pastreaza intr-o variabila de tip pid_t (pid type_) si in esenta este un numar.
Urmatoarele doua programe, creeeaza un process fiu, si afiseaza PID-ul procesului

Sau alternativa:

Pentru a obtine PID-ul unui proces utilizam functia getpid().

In parinte, fork va returna PID-ul noului proces creat, in timp ce procesului fiu va returna 0.

De obicei, se observa ca pid-ul procesului fiu este pid-ul procesului parinte +1.

OBS: Atunci cand veti rula programul, in functie de compilatoare si de cum sunt gestionate procesele, puteti ajunge la o
situatie in care procesul fiu se incheie dupa procesul parinte. Acest lucru se datoreaza faptului ca nu se poate controla
ordinea in care se executa liniile de cod din procese. Este o chestiune gestionata de sistemul de operare. Pentru a fixa acest
lucru adaugati un sleep de 1 secunda (sleep(1)) inainte de printf-ul din parinte.

Apelul sistem exec

Functiile din familia exec inlocuiesc programul curent cu un alt program in cadrul aceluiasi proces. Programul curent este
oprit, iar programul inlocuitor este pornit, imaginea procesului initial fiind inlocuita cu cea noua.

Daca se doreste rularea de comenzi pe care in primul capitol le trasmiteam interpretorului de comenzi, se pot folosi functii
precum execl ( sau oricare alta functie din familia exec).
Primul parametru al functiei este calea catre programul care se doreste sa fie rulat iar in continuare se precizeaza numele
comenzii si eventualii parametri. Ultimul parametru trebuie neaparat sa fie 0 sau NULL pentru a indica functiei execl ca s-
a ajuns la capatul argumentelor.

De exemplu comanda ls: Executabilele comnzilor se afla in folderul /bin.

Orice cod scris dupa o comanda exec nu se mai executa. Daca se doreste cod executat dupa execl, se poate pune comanda
execl intr-un proces fiu, iar codul ce se doreste rulat dup ava fi scris in procesul parinte.

Daca se doreste ca procesul parinte sa astepte terminarea executiei unui proces fiu, in procesul parinte se va executa
apelul sistem wait.

Atunci cand rezultatul apelului wait este <0 inseamna ca a avut loc o eroare.

Apelul sistem wait returneaza PID-ul procesului fiu ce si-a incheiat executia.

Parametrul ce il primeste wait este o referinta catre o locatie care va primi valoarea starii de terminare a procesului fiu.

Cand un proces isi termina executia el va apela apelul sistem exit.

Acest apel sistem primeste ca si argument un parametru de stare care va fi transmis procesului parinte prin intermediul
locatiei referita de parametrul apelului wait.

Acest statusinfo este encoded si contine mai multe informatii referitoare la starea procesului fiu la terminare.

Pentru a extrage statusul se foloseste macroul WEXITSTATUS.

Daca sunt mai multe procese fiu, este nevoie de mai multe apeluri wait.

Waitpid functioneaza similar cu wait: suspenda executia programului din care s-a apelat pana cand un copil cu pid-ul
trasmis ca si argument isi schimba starea.

Avantajul este ca la waitpid comportamentul este modificabil.

Daca se vrea sa se astepte dupa orice proces, primul parametru va fi -1.

Referitor la optiuni, un exemplu ar fi WNOHANG care va da raspuns pe loc, iar daca niciun proces fiu nu a terminat da pe
loc rezultatul 0.

waitpid(-1,&statusinfo,WNOHANG)

Daca se vrea asteptarea ca si in cazul lui wait, dar dupa un anumit proces se poate folosi waitpid dar fara optiuni:

waitpid(pid,&statusinfo,0)