Laborator 4 - Procese

• Slide-uri
• lab03-refcard.pdf
• Video Procese

• TLPI - Chapter 6, Processes, Chapter 26 Monitoring Child Processes
• WSP4 - Chapter 6, Process Management

• Crearea unui proces
• Înlocuirea imaginii unui proces
• Așteptarea terminării unui proces
• Terminarea unui proces
• Exemplu (my_system)
• Copierea descriptorilor de fișier
• Moștenirea descriptorilor de fișier după operații fork/exec
• Variabile de mediu în Linux

Un proces este un program în execuție. Procesele sunt unitatea primitivă prin care sistemul de operare alocă resurse utilizatorilor. Orice proces are un spațiu de adrese și unul sau mai multe fire de execuție. Putem avea mai multe procese ce execută același program, dar oricare două procese sunt complet independente.

Informațiile despre procese sunt ținute într-o structură numită Process Control Block (PCB), câte una pentru fiecare proces existent în sistem. Printre cele mai importante informații conținute de PCB regăsim:

• PID - identificatorul procesului
• spațiu de adresă
• registre generale, PC (contor program), SP (indicator stivă)
• tabela de fișiere deschise
• informații referitoare la semnale
  • lista de semnale blocate, ignorate sau care așteaptă să fie trimise procesului
  • handler-ele de semnale
• informațiile referitoare la sistemele de fișiere (directorul rădăcină, directorul curent)

În momentul lansării în execuție a unui program, în sistemul de operare se va crea un proces pentru alocarea resurselor necesare rulării programului respectiv. Fiecare sistem de operare pune la dispoziție apeluri de sistem pentru lucrul cu procese: creare, terminare, așteptarea terminării. Totodată există apeluri pentru duplicarea descriptorilor de resurse între procese, ori închiderea acestor descriptori.

Procesele pot avea o organizare:

• ierarhică - de exemplu pe Linux - există o structură arborescentă în care rădăcina este procesul init (pid = 1).
• neierarhică - de exemplu pe Windows.

În general, un proces rulează într-un mediu specificat printr-un set de variabile de mediu. O variabilă de mediu este o pereche NUME = valoare. Un proces poate să verifice sau să seteze valoarea unei variabile de mediu printr-o serie de apeluri de bibliotecă (Linux, Windows).

Pipe-urile (canalele de comunicație) sunt mecanisme primitive de comunicare între procese. Un pipe poate conține o cantitate limitată de date. Accesul la aceste date este de tip FIFO (datele se scriu la un capăt al pipe-ului pentru a fi citite de la celălalt capăt). Sistemul de operare garantează sincronizarea între operațiile de citire și scriere la cele două capete (Linux, Windows).

Există două tipuri de pipe-uri:

• pipe-uri anonime: pot fi folosite doar de procese înrudite (un proces părinte și un copil sau doi copii), deoarece sunt accesibile doar prin moștenire. Aceste pipe-uri nu mai există după ce procesele și-au terminat execuția.
• pipe-uri cu nume: au suport fizic - există ca fișiere cu drepturi de acces. Prin urmare, ele vor exista independent de procesul care le creează și pot fi folosite de procese neînrudite.

Lansarea în execuție a unui program presupune următorii pași:

• Se creează un nou proces cu fork - procesul copil are o copie a resurselor procesului părinte.
• Dacă se dorește înlocuirea imaginii procesului copil aceasta poate fi schimbată prin apelarea unei funcții din familia exec*.

În UNIX un proces se creează folosind apelul de sistem fork:

pid_t fork(void);

Efectul este crearea unui nou proces (procesul copil), copie a celui care a apelat fork (procesul părinte). Procesul copil primește un nou process id (PID) de la sistemul de operare.

Pentru aflarea PID-ului procesului curent și al procesului părinte se vor apela funcțiile de mai jos.

Funcția getpid întoarce PID-ul procesului apelant:

pid_t getpid(void);

Funcția getppid întoarce PID-ul procesului părinte al procesului apelant:

pid_t getppid(void);

Familia de funcții exec va executa un nou program, înlocuind imaginea procesului curent, cu cea dintr-un fișier (executabil). Acest lucru înseamnă:

• Spațiul de adrese al procesului va fi înlocuit cu unul nou, creat special pentru execuția fișierului.
• Registrele PC (contorul program), SP (indicatorul stivă) și registrele generale vor fi reinițializate.
• Măștile de semnale ignorate și blocate sunt setate la valorile implicite, ca și handler-ele semnalelor.
• PID-ul și descriptorii de fișier care nu au setat flag-ul CLOSE_ON_EXEC rămân neschimbați (implicit, flag-ul CLOSE_ON_EXEC nu este setat).

int execl(const char *path, const char *arg, ...); 
int execv(const char *path, char *const argv[]);
int execlp(const char *file, const char *arg, ...);

Exemplu de folosire a funcțiilor de mai sus:

execl("/bin/ls", "ls", "-la", NULL);
 
char *const argvec[] = {"ls", "-la", NULL};
execv("/bin/ls", argvec);
 
execlp("ls", "ls", "-la", NULL);

execl și execv nu caută programul dat ca parametru în PATH, astfel că acesta trebuie însoțit de calea completă. Versiunile execlp și execvp caută programul și în PATH.

Toate funcțiile exec* sunt implementate prin apelul de sistem execve.

Familia de funcții wait suspendă execuția procesului apelant până când procesul (procesele) specificat în argumente fie s-a terminat, fie a fost oprit (SIGSTOP).

pid_t waitpid(pid_t pid, int *status, int options);

Starea procesului interogat se poate afla examinând status cu macrodefiniții precum WEXITSTATUS, care întoarce codul de eroare cu care s-a încheiat procesul așteptat, evaluând cei mai nesemnificativi 8 biți.

Există o variantă simplificată, care așteaptă orice proces copil să se termine. Următoarele secvențe de cod sunt echivalente:

wait(&status);                   |  waitpid(-1, &status, 0);

În caz că se dorește doar așteptarea terminării procesului copil, nu și examinarea statusului, se poate folosi:

wait(NULL);

Pentru terminarea procesului curent, Linux pune la dispoziție apelul de sistem exit.

void exit(int status);

void _exit(int status);

void _Exit(int status);

Un proces al cărui părinte s-a terminat poartă numele de proces orfan. Acest proces este adoptat automat de către procesul init, dar poartă denumirea de orfan în continuare deoarece procesul care l-a creat inițial nu mai există.

Un proces finalizat al cărui părinte nu a citit (încă) statusul terminării acestuia poartă numele de proces zombie. Procesul intră într-o stare de terminare, iar informația continuă să existe în tabela de procese astfel încât să ofere părintelui posibilitatea de a verifica codul cu care s-a finalizat procesul. În momentul în care părintele apelează funcția wait, informația despre proces dispare. Orice proces copil o să treacă prin starea de proces zombie la terminare.

Pentru terminarea unui alt proces din sistem, se va trimite un semnal către procesul respectiv prin intermediul apelului de sistem kill. Mai multe detalii despre kill și semnale în laboratorul de semnale.

my_system.c

#include <stdlib.h>
#include <stdio.h>
 
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
 
int my_system(const char *command)
{
	pid_t pid;
	int status;
	const char *argv[] = {command, NULL};
 
	pid = fork();
	switch (pid) {
	case -1:
		/* error forking */
		return EXIT_FAILURE;
	case 0:
		/* child process */
		execvp(command, (char *const *) argv);
 
		/* only if exec failed */
		exit(EXIT_FAILURE);
	default:
		/* parent process */
		break;
	}
 
	/* only parent process gets here */
	waitpid(pid, &status, 0);
	if (WIFEXITED(status))
		printf("Child %d terminated normally, with code %d\n",
			pid, WEXITSTATUS(status));
 
	return status;
}
 
int main(void) {
	my_system("ls");
	return 0;
}

dup duplică descriptorul de fișier oldfd și întoarce noul descriptor de fișier, sau -1 în caz de eroare:

int dup(int oldfd);

dup2 duplică descriptorul de fișier oldfd în descriptorul de fișier newfd; dacă newfd există, mai întâi va fi închis. Întoarce noul descriptor de fișier, sau -1 în caz de eroare:

int dup2(int oldfd, int newfd);

Descriptorii de fișier sunt, de fapt, indecși în tabela de fișiere deschise. Tabela este populată cu pointeri către structuri cu informațiile despre fișiere. Duplicarea unui descriptor de fișier înseamnă duplicarea intrării din tabela de fișiere deschise (adică 2 pointeri de la poziții diferite din tabelă vor indica spre aceeași structură din sistem, asociată fișierului). Din acest motiv, toate informațiile asociate unui fișier (lock-uri, cursor, flag-uri) sunt partajate de cei doi file descriptori. Aceasta înseamnă că operațiile ce modifică aceste informații pe unul dintre file descriptori (de ex. lseek) sunt vizibile și pentru celălalt file descriptor (duplicat).

Descriptorii de fișier ai procesului părinte se moștenesc în procesul copil în urma apelului fork. După un apel exec, descriptorii de fișier sunt păstrați, excepție făcând cei care au flag-ul CLOSE_ON_EXEC setat.

fcntl(file_descriptor, F_SETFD, FD_CLOEXEC);

/ * THREAD 1 */                   |/ * THREAD 2 */    
fd = op_creare_fd()               |
                                  | exec(...)
fcntl(fd, F_SETFD, FD_CLOEXEC);   |

int dup3(int oldfd, int newfd, int flags);
int pipe2(int pipefd[2], int flags);
int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags);

În cadrul unui program se pot accesa variabilele de mediu, prin evidențierea celui de-al treilea parametru (opțional) al funcției main, ca în exemplul următor:

int main(int argc, char **argv, char **environ)

Acesta desemnează un vector de pointeri la șiruri de caractere, ce conțin variabilele de mediu și valorile lor. Șirurile de caractere sunt de forma VARIABILA=VALOARE. Vectorul e terminat cu NULL.

getenv întoarce valoarea variabilei de mediu denumite name, sau NULL dacă nu există o variabilă de mediu denumită astfel:

char* getenv(const char *name);

setenv adaugă în mediu variabila cu numele name (dacă nu există deja) și îi setează valoarea la value. Dacă variabila există și replace e 0, acțiunea de setare a valorii variabilei e ignorată; dacă replace e diferit de 0, valoarea variabilei devine value:

int setenv(const char *name, const char *value, int replace);

unsetenv șterge din mediu variabila denumită name:

int unsetenv(const char *name);

Informații suplimentare legate de depanarea unui proces se găsesc aici

Pentru rezolvarea laboratorului, va rugam sa clonati repository-ul. daca il aveti deja, va rugam sa rulati git pull.

Intrați în directorul 1-system. Programul my_system.c execută o comandă transmisă ca parametru, folosind funcția de bibliotecă system. Modul de funcționare al system este următorul:

• se creează un nou proces cu fork
• procesul copil execută, folosind execve, programul sh cu argumentele -c “comanda”, timp în care procesul părinte așteaptă terminarea procesului copil.

Compilați (folosind make) și rulați programul dând ca parametru o comandă.

• Exemplu:

   ./my_system pwd 

Cum procedați pentru a trimite mai mulți parametri unei comenzi? (ex: ls -la)

Pentru a vedea câte apeluri de sistem execve se realizează, rulați:

 strace -e execve,clone -ff -o output ./my_system ls 

• atenție! nu este spațiu după virgulă în argumentul execve,clone
• argumentul -ff însoțit de -o output generează câte un fișier de output pentru fiecare proces.
  • cițiți pagina de manual strace

Revedeți secțiunea Înlocuirea imaginii unui proces în Linux și pagina de manual pentru execve .

Inlocuiti functia system cu execlp. Functia primeste ca parametru o comanda, lista de argumente (despartite de virgule) si apoi NULL (ultimul parametru, este de fapt marcatorul de sfarsit de lista).

Urmariti linia cu TODO 1.

Intrați în directorul 2-parameters.

Compilati programul parameters.c folosind comanda make. Ce face programul parameters.c?

Rezolvati exercitiul in fisierul program.c.

Folositi functia system pentru a rula programul parameters cu cativa parametrii.

Inlocuiti functia system cu execl. De ce nu se afiseaza textul prin printf-ul de dupa execl?

Urmariti liniile cu TODO 2.

Intrați în directorul 3-run.

Folsiti functiile fork si execl pentru a rula comanda ls din programul run.c.

Urmariti liniile cu TODO 1.

Asigurati-va ca textul “ls was run” este afisat dupa inchiderea programului programului ls. (Hint: waitpid)

Urmariti liniile cu TODO 2.

Mutati si modificati linia cu TODO 3 astfel incat sa se afiseaza codul de iesire (exit code) al programului ls. (Hint: WEXITSTATUS)

Compilati programul exitcode.c folosind comanda make. Rulati programul si afisati codul de iesire. Modificati programul exitcode.c astfel incat sa intoarca alt cod de iesire.

Urmariti liniile cu TODO 4.

Intrați în directorul 4-orphan și inspectați sursa orphan.c.

Compilați programul (make) și apoi rulați-l folosind comanda:

​ ./​orphan 

Deschideți alt terminal și rulați comanda:

 watch -d '(ps -al | grep -e orphan -e PID)' 

Observați că pentru procesul indicat de executabilul ​orphan​ (coloana ​CMD​),​ pid-ul procesului părinte (coloana ​PPID​) devine 1, întrucât procesul este adoptat de ​init​ după terminarea procesului său părinte. De ce sunt doua procese orphan?

Intrați în directorul 5-zombie și inspectați sursa zombie.c.

Compilați programul (make) și apoi rulați-l folosind comanda:

​ ./zombie 

Deschideți alt terminal și rulați comanda:

 watch -d '(ps -al | grep -e orphan -e PID)' 

Observați că pentru procesul indicat de executabilul zombie​ coloana ​CMD​ devine zombie <defunct>. Ce se intampla de fapt?

Modificati fisierul zombie.c astfel incat procesul sa nu mai devina un zombie (Hint: waitpid).

Urmariti liniile cu TODO 1.

Intrați în directorul 6-tiny.

Următoarele subpuncte au ca scop implementarea unui shell minimal, care oferă suport pentru execuția unei singure comenzi externe cu argumente multiple și redirectări. Shell-ul trebuie să ofere suport pentru folosirea și setarea variabilelor de mediu.

Observație: Pentru a ieși din tiny shell folosiți exit sau CTRL+D.

Creați un nou proces care să execute o comandă simplă.

Funcția simple_cmd primește ca argument un vector de șiruri ce conține comanda și parametrii acesteia.

Citiți exemplul my_system și urmăriți în cod comentariile cu TODO 1. Pentru testare puteți folosi comenzile:

 ./tiny
> pwd
> ls -al
> exit 

Trebuie să completați funcțiile set_var și expand; acestea sunt apelate deja atunci când se face parsarea liniei de comandă. Verificarea erorilor trebuie făcută în aceaste funcții.

• Urmăriți în cod comentariile cu TODO 2.
• Citiți secțiunea Variabile de mediu in Linux.
• Pentru testare puteți folosi comenzile:

   ./tiny
  > echo $HOME
  > name=Makefile 
  > echo $name  

Completați funcția do_redirect astfel încât tiny-shell trebuie să suporte redirectarea output-ului unei comenzi (stdout) într-un fișier.

Dacă fișierul indicat de filename nu există, va fi creat. Dacă există, trebuie trunchiat.

Citiți secțiunea Copierea descriptorilor de fișier și urmăriți în cod comentariile cu TODO 3. Pentru testare puteți folosi comenzile:

 ./tiny 
> ls -al > out
> cat out
> pwd > out
> cat out

Solutii

1. Fork - Wikipedia
2. About Fork and Exec
3. Fork, Exec and Process Control - YoLinux Tutorial