Procese Si Fire de Executie-Tema5

ETTI-SO
PROCESE SI
FIRE DE
EXECUTIE
Proiect SO
Autori:
Dobroiu Madalina 431A;Fratila Dragos Sorin 433A;Petrache Victor
431A;Petrescu Mihai
Cristian 433A;Ra Bogdan 431A; Stoian Adriana 431A
11
Cuprins
Capitolul 1: Concepte fundamentale- Rata Bogdan(431A)
1.1.Notiuni introductive.............................................................................................. 4
1.2.Fire de executie.............................................................................................. 4
1.3.Functionalitatea unui fir de executie..........................................................................6
1.4.Starile proceselor................................................................................................. 7
1.5.Comunicarea intre procese..................................................................................... 7
1.6.Semofarizare si monitorizare................................................................................... 8
1.7.Modelele de threading suportate de sistemele win32.....................................................8
1.8.Calculul performantelor......................................................................................... 9
Capitolul 2 Apelurile de sistem de gestiune a proceselor n Linux- Petrescu Mihai Cristian
(433A) 10
2.1.Sistemul de operare Linux.................................................................................... 10
2.1.1.Nucleul...................................................................................................... 10
2.1.2.Shell-ul...................................................................................................... 14
2.1.3.Sistemul de fisiere........................................................................................ 14
2.1.4.Gestiunea proceselor..................................................................................... 15
2.1.5.Crearea unui proces...................................................................................... 16
2.1.6.Comenzi pentru gestiunea proceselor UNIX Linux................................................17
Capitolul 3: Apelurile API pentru gestionarea job-urilor si ale proceselor - Victor Petrache
(431A) 19
3.1 Ce este un API?................................................................................................. 19
3.2 WINDOWS API................................................................................................ 19
3.3 LINUX Kernell API........................................................................................... 20
Capitolul 4: Comparatie intre implementarea proceselor si firelor de executie la Linux si
Windows- Madalina Dobroiu(431A) 22
4.1.Procese n Linux................................................................................................ 22
4.1.1 Implementarea in Linux.................................................................................22
4.1.2.Crearea proceselor :...................................................................................... 24
4.1.3.Rularea unui program executabil......................................................................26
4.1.4.Afia unui copac de procese............................................................................ 26
4.1.5. nlocuirea imaginii unui proces.......................................................................27
4.1.6.Ateptarea terminrii unui proces......................................................................27
4.1.7.Terminarea unui proces..................................................................................29
4.1.8.Copierea descriptorilor de fiier........................................................................29
4.1.9.Motenirea descriptorilor de fiier dup operaii fork/exec.......................................29
4.1.10. Variabile de mediu..................................................................................... 30
4.1.11. Depanarea unui proces................................................................................30

4.2
Procese n Windows....................................................................................... 31
4.2.1.Implementarea in Windows............................................................................. 31
4.2.2.Crearea unui proces :..................................................................................... 32
4.2.3.Ateptarea terminrii unui proces......................................................................34
4.2.4.Terminarea unui proces..................................................................................35
4.2.5.Variabile de mediu........................................................................................ 36
Capitolul 5. Emularea programelor MS DOS- Adriana Stoian(431A)
37
5.1 Notiuni DOS.................................................................................................... 37

5.2 Definitie emulatoare........................................................................................... 37
5.3 Emulatoare MS-DOS.......................................................................................... 38
5.4 Exemple de emulatoare MS-DOS...........................................................................38
1. DOSBox........................................................................................................ 38
2. RealSpec v0.96.16............................................................................................ 39
Capitolul 6 : Procesul de bootare a sistemului de operare: comparatie Windows si Linux- Fratila
Dragos Sorin( 433 A) 41
6.1.Bootarea sistemului de operare Linux......................................................................41
6.1.1.Procesul de initializare [INIT Process]...............................................................42
6.1.2.Fisierele de initializare din /etc/inittab................................................................42
6.1.3.Fisierele din /etc/rc.d/rc.sysinit.........................................................................42
6.1.4.Directorul /etc/rc.d/init.d................................................................................43
6.1.5.Nivelele de executie ale Linux-ului...................................................................44
6.1.6.Modificarea nivelelor de executie.....................................................................44
6.1.7.Directoarele nivelelor de executie.....................................................................44
6.1.8.Schimbarea nivelului curent de executie.............................................................45
6.1.9.Eliminarea unui serviciu dintr-un nivel de executie................................................46
6.1.10.Adaugarea de servicii unui nivel de executie......................................................46
6.2. Procesul de bootare Windows............................................................................... 46
6.2.1.Windows 1.x/2.x.......................................................................................... 46
6.2.2.Windows 3.x/9x........................................................................................... 46
6.2.3.Windows NT/2000/XP/Server 2003..................................................................47
6.2.4.Windows Vista/Server 2008/Windows 7.............................................................48
Capitolul 1: Concepte fundamentale- Rata Bogdan(431A)

1.1.Notiuni introductive
Firele de executie fac trecerea de la programarea secventiala la programarea
concurenta. Un program secvential reprezinta modelul clasic de program: are un inceput, o
secventa de executie a instructiunilor sale si un sfarsit. Cu alte cuvinte, la un moment dat
programul are un singur punct de executie. Un program aflat in executie se numeste proces.
Un sistem de operare monotasking, cum ar fi fi MS-DOS, nu este capabil sa execute decat un
singur process la un moment dat, in timp ce un sistem de operare multitasking, cum ar fi
UNIX sau Windows, poate rula oricate procese in acelasi timp (concurent), folosind diverse
strategii de alocare a procesorului fiecaruia dintre acestea. Am reamintit acest lucru deoarece
notiunea de fir de executie nu are sens decat in cadrul unui sistem de operare multitasking. Un
fir de executie este similar unui proces secvential, in sensul ca are un inceput, o secventa de
executie si un sfarsit. Diferenta dintre un fir de executie si un proces
consta in faptul ca un fir de executie nu poate rula independent ci
trebuie sa ruleze in cadrul unui proces.
Un program isi poate defini insa nu doar un fir de executie ci
oricate, ceea ce inseamna ca in cadrul unui proces se pot executa
simultan mai multe fire de executie, permitand efectuarea concurenta
a sarcinilor independente ale acelui program.
Un fir de executie poate fi asemanat cu o versiune redusa a
unui proces, ambele ruland simultan si independent pe o structura
secventiala formata de instructiunile lor. De asemenea, executia
simultana a firelor in cadrul unui proces este similara cu executia
concurenta a proceselor: sistemul de operare va aloca procesorul
dupa o anumita strategie fiecarui fir de executie pana la terminarea
lor. Din acest motiv firele de executie mai sunt numite si procese
usoare.
Care ar fi insa deosebirile intre un fir de executie si un
proces ? In primul, rand deosebirea majora consta in faptul ca firele
de executie nu pot rula decat in cadrul unui proces. O alta deosebire
rezulta din faptul ca fiecare process are propria sa memorie (propriul sau spatiu de adrese) iar
la crearea unui nou proces (fork) este realizata o copie exacta a procesului parinte: cod si date,
in timp ce la crearea unui fir nu este copiat decat codul procesului parinte, toate firele de
executie avand acces la aceleasi date, datele procesului original. Asadar, un fir mai poate fi
privit si ca un context de executie in cadrul unui proces.
1.2.Fire de executie
Firele de executie sunt niste fluxuri de instructiuni care se executa in interiorul unui
proces si pot fi vazute ca un program ce nu are spatiu de adresa propriu desi se afla in
executie. Ele ruleaza in cadrul unui proces si ii partajeaza spatiu de adresa al acestuia. Fiecare
proces are cel putin un fir de executie care ruleaza in interiorul sau. Uneori exista mai multe
fire de executie in interiorul aceluiasi proces cand apare nevoia de lucru in paralel asupra
acelorasi date. Desi firele de executie partajeaza spatiul de adresa al aceluiasi proces, ele au
nevoie de resurse individuale cum ar fi stiva, registrii si contorul program care permit mai
multor fire de executie din cadrul aceluiasi proces sa urmeze cai diferite de instructiuni sunt
utile in multe privinte, insa uzual ele sunt folosite pentru executarea unor operatii
consumatoare de timp fara a bloca procesul principal: calcule matematice, asteptarea eliberarii
unei resurse, desenarea componentelor unei aplicatii GUI, etc. De multe ori ori, firele isi
desfasoara activitatea in fundal insa, evident, acest lucru nu este obligatoriu.
In Linux procesul init este parintele
tuturor proceselor ce ruleaza pe acel sistem.
Toate procesele care au rezultat dintr-un
parinte se numesc procese fiu.
Fiecare proces din sistem are un
proces care l-a creat, numit proces parinte
(sau tata) si de la care "mosteneste" un
anumit ansamblu de caracteristici (cum ar fi
proprietarul, drepturile de acces, s.a.), si
poate crea, la randul lui, unul sau mai multe
procese fii.
Fiecare proces are asignat un PID
(process identification), ce este un numar
intreg pozitiv si care este unic pe durata
vietii acelui proces (In orice moment, nu
exista In sistem doua procese cu acelasi
PID).
In UNIX pentru a afla PID-ul unui
proces fiu utilizata functia fork() care ii este adresata procesului parinte.
In programe, de regula parinte, PID-ul poate fi folosit ca atribut de catre functii de
control (waitpid() sau kill()) pentru a executa anumite actiuni asupra procesului specificat.
Daca sistemul de operare are implementat suport pentru procfs, atunci in fisierul /proc/pid se
gasesc informatii despre procese.
In Linux procesul idle denota ca un process nu se mai termina niciodata avand un PID
0 iar init process nu va mai face nimic asteptand terminarea procesului fiu sa i se dea KILL
avand un PID 1 din acest process se trag toate procesele din acel sistem. In Windows folosim
procese echivalente numite System Idle Process si System.
Un aspect foarte important al proceselor este ca acestea au intotdeauna spatii de adresa
distincte, fiecare dintre ele ruland ca si cum toata memoria ar fi a sa. Din aceasta rezulta ca
procesele sunt izolate intre ele si nu se pot accesa unul pe celalalt in mod direct. Totusi exista
comunicare intre ele prin mecanisme IPC (Inter-Process Communication) precum: memorie
partajata, socketuri, coada de mesaje sau semafoare.
Pentru a se folosii eficient un procesor, acesta trebuie sa execute concomitent mai
multe procese. Deoarece un procesor nu poate sa execute la un moment dat decat un singur
proces, fiecarui proces activ in acel moment ii este alocata o bucata de timp (time slice) prin
intermediul unui planificator (scheduler). Daca un proces, de exemplu, foloseste o operatie
I/O pentru o perioada indelungata si nu pune procesorul in mod idle intr-un anumit interval, se
porneste un cronometru care, atunci cand expira, intrerupe procesul consumator de resurse si
aloca resursele unui nou proces. Astfel este asigurat faptul ca un proces nu poate sa detina
monopol asupra procesorului.
Din ce am zis mai sus rezulta doua idei fundamentale despre procese:
Ruleaza independent pentru ca au zone de cod, stiva si date distinct
Trebuie sa fie planificate la executie astfel ca ele sa ruleze in paralel la nivelul
aplicatiei
1.3.Functionalitatea unui fir de executie

Procesul are in componenta sa mai multe fire de executie care sunt executate in
paralalel avand in comun toate resursele caracterisiticile si resursele principale a procesului,
fire de executie ruleaza in paralel si au acces la aceasi zona de date dar executa portiuni
diferite de cod. Aceasta punere in comun a zonei de date are ca si consecinta faptul ca firele
de executie vad toate variabile procesului si odata cu modificarea unui fir fiind vazuta si de
celelante fire.
Firele de executie in comparatie cu programarea modularizata duce la o programare
flexibila si aduce o imbunatatire in timp, prin incapsulare se reduce accesul utilizatorului
direct la varibile(aflandu-se la in spatii de adrese diferite) si odata cu acestea are loc o
securitatea mai buna. In timp ce firele de executie au un dezavantaj deoare acestea folosesc
bucati de cod si memori comune, o eroare poate duce la propagarea in mai multe directi si
odata cu acestea o vulnerabilitate in sistem. Un avantaj net superior al firelor de executie in
fata proceselor este paralelismul. Acest avantaj consta in posibilitatea de folosire mult mai
eficienta a resurselor sistemului pentru o prelucrare mult mai rapida a datelor.
Process switching este operatia prin care trebuie comutate toate resursele care apartin
proceselor, salvalvarea registrului procesorului si se face o remaparea a zonelor de memorie
care apartin noului proces.
La nivelul sistemului de operare, executia in paralel a firelor de executie este obtinuta
in mod asemanator cu cea a proceselor, realizandu-se o comutare intre fire, conform unui
algoritm de planificare. Spre deosebire de cazul proceselor, insa, aici comutarea poate fi
facuta mult mai rapid, deoarece informatiile memorate de catre sistem pentru fiecare fir de
executie sunt mult mai putine decat in cazul proceselor, datorita faptului ca firele de executie
au foarte putine resurse proprii. Practic, un fir de executie poate fi vazut ca un numarator de
program, o stiva si un set de registri, toate celelalte resurse (zona de date, identificatori de
fisier etc) apartinand procesului in care ruleaza si fiind exploatate in comun.
Kernel este mediatorul intre programe si hardware, locul unde sunt depozitate
driverele. Kernel-ul ofera suport pentru filtrarea pachetelor ce trec prin retea si gestioneaza
procesele ce ruleaza in memorie. Functiile kernel-ului sunt foarte ample, iar scopul acestui
turorial este sa trateze in linii mari subiectul. Exista mai multe tipuri de kernel: monolitice,
hibride, microkerneluri, nanokerneluri si exokerneluri.
Kernel-ul Linux-ului este modular. Asta inseamna ca unele drivere pot fi compilate
sub forma de module. Avantajul obtinut astfel consta in faptul ca driverul va sta in memorie
numai cand este necesar. Asta inseamna o functionare mai rapida a sistemului si o boot-are
mai rapida. De aceea, este bine sa folositi module pentru driverul de placa de retea, placa de
sunet, partitii vfat, dos, NTFS, smbfs, iptables si multe alte drivere care ofera posibilitatea de
a fi compilate ca modul. Datorita utilitarului kerneld, introdus odata cu versiunea 1.3 a kernelului, modulele sunt incarcate in mod automat cand sunt solicitate de un program, asta
insemnand ca nu mai e nevoie de comanzi ca insmod si modprobe.
Kernelul stocheaza lista de procese intr-o lista circulara dublu inlantuita numita task
list (lista de procese). Fiecare element din task list este un descriptor al fiecarui proces si
contine toate informatiile despre respectivul proces. Descriptorul de proces este de tipul struct
task_struck care este definit in linux/sched.h. [1]
Fiecare proces este reprezentat in memorie printr-un context= descriptor de
procescare contine:
Starea procesului
Adresa instructiunii urmatoare
Starea registrilorCPU
Inf relative la planficare: prioritatea.
Informatii relative la paginile de memorie alocate.

Informatii legate de contabilizarea res. Utilizate
Caracteristici I/O lista fisierelor deschise.
Un descriptor de fisiere este un index pentru intrarile dintr-o structura de date ce este
rezidenta in kernel si contine detalii despre toate fisierele deschise de catre sistem. Acest
descriptor este necesar pentru ca in acelasi moment doua aplicatii sa nu acceseze acelasi fisier
si astfel sa se ajunga la coruperi de fisiere sau la pierderi de date.
Exista trei valori pentru descriptorul de fisiere:
#0 Standard input (stdin);
#1 Standard output (stdout);
#2 Standard error (stderr).
1.4.Starile proceselor
1. Ready (Pregatit pentru executie)
2. Running (In executie) Procesul este pregatit pentru executie daca, cu toate ca
instructiunile sale sunt gata pentru a fi executate, este lasat intr-o coada de asteptare din cauza
ca un alt proces este in executie la momentul respectiv de timp.
3. Waiting/Blocked (asteapta/este blocat) Un proces poate fi blocat deoarece in setul sau
de instructiuni exista instructiunea de suspendare a executiei sau pentru ca efectueaza o
operatie in afara procesorului (adresare memorie, etc) care este foarte consumatoare de timp.
4. Dead (Kill) are loc atuncea cand utilizatorul/programul are o eroare in executie si este
nevoita intreruperea firului de exectie. Acesta stare nu este reversibila fata de celelante 3 stari
enumeratate mai sus
Procesele care se gasesc in Starile Ready si Blocked sunt introduse in cozi de procese:
procesele Ready sunt introduse in coada Ready, procesele Blocked sunt introduse in coada
Blocked care sunt cozi de I/O.
Procesele Ready si Running, Blocked poate fi reflexive adica se poate produce o
trecere Ready->Running sau Ready->Blocked si vice versa, iar executia lor poate fi
planificata.
1.5.Comunicarea intre procese
Comunicarea intre procese se poate face folosind pipe-uri (conducte). Conducta
este o cale de legatura care poate fi stabilita intre doua procese inrudite. Ea, bineinteles, are
doua apete: unul in care se pot scrie date si altul prin care datele pot fi citite. Pipe-urile permit
o comunicare unidirectionala. Sistemul de operare permite conectarea a unuia sau mai multor
procese la fiecare din capetele unui pipe, deci este posibil sa existe mai multe procese care
scriu, respectiv mai multe procese care citesc din pipe. Astfel se formeaza comunicarea intre
procesele care scriu si procesele care citesc din pipe-uri.
Comunicarea intre procese se poate realiza si folosind semnalele (o exprimare a
evenimentelor care apar asincron in sistem). Un proces este capabil de a genera sau a primi
semnale. In cazul in care un proces primeste un semnal, el poate alege sa reactioneze la
semnalul receptionat intr-unul dintre urmatoarele moduri:
1. sa execute actiunea implicita la primirea unui semnal.
2. sa capteze semnalul si sa-l trateze (signal handler)
3. sa ignore semnalul respectiv
Semnalele pot fi de mai multe tipuri, care corespund in general unor actiuni specifice.
Fiecare semnal are asociat un numar, iar acestor numere le corespund unele constante
simbolice definite in bibliotecile sistemului de operare. Standardul POSIX.1 defineste cateva

semnale care trebuie sa existe in orice sistem UNIX.
1.6.Semofarizare si monitorizare
Definitie: Situatiile in care rezultatul executiei unui sistem format din mai multe procese
(fire de executie) depinde de viteza lor relativa de executie se numesc conditii de cursa (in
engleza: race conditions).
Pentru a evita ca la iesirea din functia go() [in cazul windows] sau pthread_exit (linux)
toate thread-urile sa-si termine executia setului de instructiuni in acelasi timp, trebuie
implementat un algoritm de sincronizare si planificare.
Problema sincronizarii nu se pune numai la thread-uri, ci si la procese. In cazul in care
mai multe procese/fire de executie folosesc resurse comune, rezultatul final al executiei lor
poate sa nu fie foarte stabil deoarece conteaza ordinea in care procesele /firele de executie
returneaza rezultatele executarii seturilor de instructiuni.
Conditiile de cursa apar atunci cand trebuiesc executate/modificate parti din program
care sunt puse la comun (sunt folosite si de alte procese/thread-uri). Aceste portiuni care
acceseaza parti din program puse la comun se numesc zone (sectiuni critice critical
sections). Daca ne asiguram ca threadurile care ruleaza nu executa cod in acelasi timp in
zonele critice, problema sincronizarii este rezolvata. Acest procedeu poarta denumirea de
excluziune mutuala.
O alta metoda de sincronizare este metoda Semafoarelor. Semaforul este un tip de
date abstract ce poate avea o valoare intreaga nenegativa si asupra caruia se pot efectua
operatiile: init, up si down. Init initializeaza semaforul, down realizeaza o operatie de
decrementare, daca valoarea este pozitiva. Dacavaloarea este nula, procesul se blocheaza.
Operatia up incrementeaza valoarea semaforului, daca nu exista un process blocat pe acel
semafor. Daca exista, valoarea semaforului ramane zero iar unul dintre procese care este
blocat va fi deblocat.
Ca si metode de sincronizare mai avem mecanisme System sau VIPC. Semafoarele si
memoria partajata fac parte din mecanismele de comunicare si sincronizare a proceselor
cunoscute ca System VIPC. Prin mecanismul de memorie partajata doua sau mai multe
procese pot pune in comun o zona de memorie. Fiind o resursa pusa la comun, accesul la zona
de memorie partajata trebuie sa fie sincronizat.
1.7.Modelele de threading suportate de sistemele win32
1. Modelul thread-ului unic (Single Thread Model). Acest tip de thread presupune
rularea unui singur thread la un moment dat. Restul thread-urilor trebuie sa astepte.
Principalul dezavantaj al acestui tip de thread il reprezinta timpii lungi de executie pentru
sarcini mici. Corespunde din punct de vedere conceptual
prelucrarii pe loturi (batch processing).
2. Modelul Apartment Thread (Single Thread Apartment Model STA). In acest
model, pot exista mai multe thread-uri care se executa in cadrul aplicatiei. In STA, fiecare
thread este izolat Intr-un apartament separat In cadrul procesului. Fiecare proces poate avea
mai multe apartamente, care pot partaja date Intre ele. In acest caz, aplicatia este
raspunzatoare pentru stabilirea duratei fiecarui thread din cadrul fiecarui apartament. Toate
cererile sunt ordonate folosind Windows Message Queue, astfel Incat un singur apartament
poate fi accesat la un moment dat. Avantajul acestui model fata de modelul thread-ului unic
este ca se pot procesa simultan mai multe cereri ale utilizatorului. Totusi, nu este atinsa Inca
eficienta maxima, deoarece sarcinile se vor executa una dupa alta. Corespunde din punct de
vedere conceptual multiprogramarii.
3. Modelul Multithread Apartment (Free Thread Apartment Model FTA). Modelul
Multithread Apartment presupune existenta unui singur apartament. Nu este nevoie de
ordonare, deoarece toate thread-urile apartin aceluiasi apartament si pot partaje resursele.
Aceste aplicatii se executa mai rapid decat cele care implementeaza modelul unic sau STA,
deoarece sistemul este mai putin solicitat si poate fi optimizat sa elimine timpii morti.
Corespunde din punct de vedere conceptual diviziunii In timp (time sharing).Aceste tipuri de
aplicatii sunt foarte complexe, deoarece trebuie sa se asigure ca thread-urile nu acceseaza
simultan aceleasi resurse (principiul pipeline). Este, astfel, absolut necesar sa se furnizeze un
sistem de blocare a resurselor. Acesta trebuie implementat cu atentie, deoarece poate conduce
la blocarea totala a sistemului.
1.8.Calculul performantelor
Utilizand de n ori mai multe resurse In paralel, un algoritm nu va rula de n ori mai
repede, datorita fenomenului de timp suplimentar (overhead), indus prin aplicarea
paralelismului. Acest timp suplimentar apare din urmatoarele cauze:
interactiunea Intre procese (transmiterea rezultatelor intermediare sau partiale) si
sincronizarea proceselor;
inactivitatea temporara (idling), care Inseamna ca exista procese inactive pe anumite
perioade de timp, datorita Incarcarii inegale si a asteptarii sincronizarii;
calculele suplimentare, care nu apar In formularea seriala a algoritmului.
Parametrii de intrare care contribuie la calculul performantelor sunt:
timpul de executie secvential sau serial, TS (timpul masurat de la Inceputul si pana la
sfarsitul executiei algoritmului pe un calculator secvential);
timpul de executie paralel, TP (timpul masurat de la Inceputul executiei si pana la
terminarea ultimului subtask paralel);
numarul de procesoare, p.
Cu ajutorul acestora, se pot calcula urmatorii parametri de iesire:
suprasarcina, TO (Total Parallel Overhead) = diferenta dintre timpul total de lucru
Insumat al tuturor procesoarelor si timpul necesar celui mai rapid algoritm secvential;
accelerarea, S (Speedup) = raportul dintre timpul necesar rezolvarii unei probleme pe
un procesor si timpul necesar rezolvarii aceleiasi problem In paralel pe p procesoare
identice;
eficienta utilizarii calculatorului paralel, E = S / p;
costul, C = TP *p, care reflecta timpul total de lucru Insumat al procesoarelor.
Capitolul 2 Apelurile de sistem de gestiune a proceselor

n Linux- Petrescu Mihai Cristian (433A)
2.1.Sistemul de operare Linux
Sistemul de operare Linux cuprinde in principal 3 componente majore:

a) Nucleul (Kernel)
b) Sistemul de fisiere
c) Shell-ul
Kernel-ul administreaza operatiile computerului. Shell-ul asigura o interfata pentru
interactiunea dintre utilizator si calculator iar sistemul de fisiere asigura un mijloc de
organizare si gestionare a informatiilor pe discurile hard ale calculatorului. In continuare voi
detalia cele 3 componente.1
2.1.1.Nucleul
Nucleul este partea centrala a sistemului de operare, care asigura servicii catre programele
de aplicatii pentru realizarea gestiunii proceselor, a memoriei, a intrarilor, a iesirilor si a
timpului. Kernel-ul se afla cel mai aproape de CPU si hardware. Este un fisier executabil care
se incarca atunci cand porneste calculatorul. Nucleul (Kernel) este un intermediar intre
interfata furnizata de apelurile sistem si echipamentele fizice din sistemul de calcul.Nucleul
(Kernel) este componenta care asigura servicii de sistem pentru programele de aplicatii
asigurand gestiunea proceselor, a memoriei, a intrarilor/iesirilor si a timpului.2
Kernelul este inima sistemului de operare. El se ocupa cu gestionarea fisierelor de pe disk,
porneste programele si le ruleaza concurent, aloca memorie sau alte resurse diferitelor
procese, primeste si trimite packete de date din respectiv la alte calculatoare.Kernelul face
foarte putine el insusi dar pune la dispozitie unelte cu care pot fi construite diferite servicii.
De asemenea nu permite accesarea directa a harware-ului, fortand folosirea uneltelor pe care
le pune la dispozitie. Astfel kernelul furnizeaza o anumitaprotectie pentru useri. Uneltele puse
la dispozitie de kernel sunt utilizate prin intermediul apelurilor sistem. Programele de sisteme,
si celelalte programe ruleaza deasupra kernelului.
Kernelul este compus din cateva parti importante: managementul
proceselor,managementul memoriei, drivele pentru componentele hardware, drivele pentru
sistemul de fisiere, managementul retelei, si altele.
1
2
Modern operating systems,Andrew S. Tanenbaum,third edition;

Functiile Kernel-ului sunt:3

1. gestiunea proceselor, efectuand controlul executiei acestora prin implementarea unor
comenzi de creare, terminare, suspendare si comunicatie intre procese si planificarea
pentru executie a proceselor conform unei politici de tip partajat.
2. gestionarea fisierelor prin alocarea sau eliberarea memoriei externe pentru stocarea si
regasirea eficienta a informatiei
3. gestionarea dispozitivelor periferice
4. gestionarea memoriei prin alocarea si eliberarea memoriei principale pentru procesele
aflate in executie.
5. Administreaza functii precum: spatiul Swap, Demoni, si Sistemele de Fisiere.
Spatiul Swap Este o parte rezervata de pe hard disk pentru kernel, acesta utilizand-o in
timpul procesarii. Portiuni de programe care ruleaza pot fi aruncate hard disk-ului si apoi,
la nevoie, aduse inapoi. Acest spatiu swap se afla in realitate pe hard disk, insa seamana cu o
memorie aditionala sau RAM additional, uneori fiind numit memorie virtuala.
Demonii - Programe sau procese care realizeaza o sarcina particulara sau monitorizeaza
discurile sau executia programelor. Demonii sunt procese speciale care pornesc dupa ce se
3
4

http://www.scribd.com/doc/11400920/sisteme-de-operare
incarca sistemul de operare. Demonii asteapta apoi sa faca ceva in sprijinul SO. Pot fi porniti
sau opriti daca este necesar. Un exemplu este cel al demonului imprimantei, lpsched (line
printer scheduler). Acesta se lanseaza cand sistemul porneste si apoi asteapta in fundal pana
cand cineva are nevoie sa tipareasca ceva. Demonii din lumea Linuxului sunt similari cu
Serviciile din Windows NT/2000 sau cu NetWare Loadable Modules (NLMs) din Novell
NetWar.5
Nucleul este alcatuit din urmatoarele componente:6
1. interfata cu procesele utilizator - care se realizeaza exclusiv prin intermediul apelurilor
de sistem;
2. subsistemul de control al operatiilor de intrare iesire - care controleaza modul de lucru
cu dispozitivele periferice, aloca spatiu pentru fisiere, gestioneaza spatiul liber din
memoria externa, etc.
3. subsistemul de control al proceselor - care realizeaza planificarea, sincronizarea si
comunicarea intre procese, precum si gestionarea memoriei;
4. interfata cu hardware-ul realizeaza tratarea intreruperilor si comunicarea directa cu
componentele fizice ale sistemului electronic de calcul.
Un proces sub sistemul Linux este caracterizat de toate operatiile ce trebuie sa se
desfasoare in timp pentru a satisface cerintele unui program ce a fost lansat in executie. In
cazul unui program aflat in executie, la un moment dat pot exista mai multe procese. Ele se
numesc instante ale acestui program.
Sistemul de operare Linux foloseste un sistem de procese numit multitasking pentru a
aloca timpul de lucru al procesorului mai multor utilizatori in acelasi timp. In realitate nu este
vorba de procese care se ruleaza in acelasi timp ci unele dupa altele la intervale de timp de
ordinul milisecundelor. Sistemul de operare aloca timpul in asa fel incat sa lase impresia de
continuitate pentru fiecare utilizator. In timp ce unul dintre acestia lucreaza la terminalul
sau,el imparte cu ceilalti resursele de calcul.
Intr-un sistem de operare multiutilizator, se pot executa mai multe programe
simultan.Existand o singura CPU, in realitate un singur program se executa efectiv la un
moment dat, iar celelalte se vor executa atunci cand CPU le va acorda cuante de timp. In
timpul executiei unui program, celelalte programe sunt rezidente in RAM, cu conditia ca nici
unul sa nu solicite toata memoria. De aici decurg 2 sarcini ale nucleului :7
planificarea proceselor ;
impartirea in cuante de timp intre procese;
gestiunea memoriei;
atribuirea de zone de memorie libera la procese si eventuala evacuare sau incarcare a
unui proces in/din disc.
Linux este un sistem foarte dinamic. Procesele pot fi de scurta durata (executarea unei
comenzi de la linia de comanda) sau de lunga durata (un serviciu de retea). Din acest motiv, in
general managementul proceselor si programarea lor este foarte importanta. Practic,
5
6
7

procesorul executa un timp instructiunile unuia dintre procese, apoi sistemul de operare va
impune ca procesorul sa execute pentru un timp instructiunile altui proces si asa mai departe.
Acest mod de executie a proceselor, care simuleaza paralelismul, se numeste executie
concurenta. In implementarea concurentei trebuie rezolvate urmatoarele probleme:8
un proces ale carui instructiuni sunt executate de procesor sa poata fi eliminat din
aceasta pozitie privilegiata si inlocuit cu altul;
procesul astfel eliminat sa poata fi executat din nou, la un moment ulterior, fara ca
intreruperea executiei sale sa-l afecteze in vreun fel;
sa se decida, pentru fiecare proces, cat timp vor fi executate instructiunile acestuia;
sa se asigure accesul tuturor proceselor la resursele comune puse la dispozitie de
calculator.
Fiecare proces se afla, in orice moment, intr-una din urmatoarele stari:
running - instructiunile sale sunt executate de catre procesor in momentul respectiv;

ready - este in asteptarea momentului in care instructiunile sala vor fi executate;
waiting - asteapta efectuarea unui apel sistem pe care l-a solicitat.
Orice sistem de operare pune la dispozitia programatorilor o serie de servicii prin
intermediul carora acestora li se ofera acces la resursele hardware si software gestionate de
sistem: lucrul cu tastatura, cu discurile, cu dispozitivul de afisare, gestionarea fisierelor si
directoarelor etc. Aceste servicii se numesc apeluri sistem. De cele mai multe ori, operatiile pe
care ele le pot face asupra resurselor gestionate sunt operatii simple, cu destul de putine
facilitati. De aceea, frecvent, se pot intalni in bibliotecile specifice limbajelor de programare
colectii de functii mai complicate care gestioneaza resursele respective, dar oferind
programatorului niveluri suplimentare de abstractizare a operatiilor efectuate, precum si
importante facilitati in plus. Acestea sunt functiile de biblioteca. Trebuie subliniat faptul ca
functiile de biblioteca cu ajutorul carora se poate gestiona o anumita resursa sunt
implementate folosind chiar functiile sistem corespunzatoare, specifice sistemului de operare.
Procesele se executa, atat in mod utilizator, cat si in mod nucleu, de aceea acestora li se
asociaza o stiva nucleu ce va contine informatiile necesare functiilor de acces la nucleu.
Procesul trece din modul utilizator in modul nucleu atunci cand apeleaza o functie de sistem
sau cand este generata o intrerupere de sistem (procese privilegiate).9
Un apel de sistem este o interfata intre utilizator-un spatiu in aplicare si un serviciu care
este oferit de nucleu.Apelurile de sistem puse la dispozitie de Linux pentru gestionarea
proceselor sunt: fork si exec pentru crearea unui proces si respectiv modificarea imaginii unui
proces, wait si waitpid pentru asteptarea terminarii unui proces si exit pentru terminarea unui
proces. Pentru copierea descriptorilor de fisier Linux pune la dispozitie apelurile de sistem
dup si dup2.
In concluzie nucleul (Kernel) este constituit din doua componente principale:10
8
Primii pasi in Linux,Sabin Buraga, Dragos Acostachioaie, Marius Marusteri;
10
sistemul de gestiune a fisierelor;

sistemul de gestiune a proceselor.
Functiile generale ale unui sistemului de gestiune a fisierelor sunt:operatii cu fisiere
(creare, citire, scriere, copiere, stergere, concatenare,etc.); alocare de spatiu dinamic pentru
fisiere pe HD sau FD; accesul la fisiere; administrarea spatiului liber pe HD sau FD;
schimbarea structurii sistemului de fisiere.
Functiile generale ale sistemului de gestiune a proceselor sunt: trecerea proceselor prin
diverse stari (creare, asteptare, executie, terminare); planificarea proceselor pentru a avea
acces la procesor; comunicarea intre procese; sincronizarea proceselor.
2.1.2.Shell-ul
Shell-ul reprezinta interpretorul de comenzi al sistemului de operare care are rolul de a
interpreta comenzile date de utilizator, realizand o interfata intre acesta si sistemul de operare
si de asemenea ofera facilitati de programare intr-un limbaj propriu avand caracteristicile
asemanatoare cu ale limbajelor de nivel inalt, permitand scrierea si utilizarea de programe.In
concluzie,un shell este o interfata intre utilizator si kernel. Actioneaza ca un interpretor sau ca
un translator. Cu alte cuvinte, shell-ul accepta comenzi scrise de utilizator, le interpreteaza, si
apoi executa programele corespunzatoare. Shell-urile pot fi linie de comanda sau grafice.
Pentru a verifica ce shell utilizezi la un moment dat se poate folosi comanda ps (process
status).11
Shell-ul citeste si interpreteaza cererile introduse de utilizator. Apoi comunica instructiuni
kernel-ului care duce la indeplinire cererile formulate de utilizator. Shell-ul este deci legatura
directa, interfata directa a utilizatorului cu sistemul de operare. De obicei, cele mai multe
cereri sunt pentru a rula programe.
2.1.3.Sistemul de fisiere
Sistemul de fisiere cuprinde ansamblul fisierelor memorate sub forma de comenzi,
programe traducatoare, programe utilitare, sisteme pentru lucrul cu colectii dedate, programe
aplicative, precum si fisiere de date asociate organizate intr-o structura standard de directoare
si subdirectoare.
Sistemul de fisiere asigura o modalitate de a separa si de a organiza informatia pe un hard
disk. Structura de fisiere a sistemului Linux este o ierarhie de directoare, subdirectoare si
fisiere care sunt grupate in functie de anumite scopuri. Sistemul de fisiere este integrat cu
Kernel-ul in scopul asigurarii unei structuri organizatorice pentru software-ul si pentru datele
utilizatorilor. Structura de fisiere subdivide hard disk-urile, facandu-le mai usor de administrat
si usurandu-ne localizarea fisierelor. Hard disk-urile pot fi divizate in sisteme de fisiere,
directoare, subdirectoare si fisiere. Sistemul de fisiere organizeaza datele intr-un mod similar
11
unui dulap. Sistemul de fisiere este dulapul, directoarele sunt asemenea sertarelor,
subdirectoarele asemenea dosarelor isr fisierele pot fi asemanate u foile prinse in dosar.
Un fisier este o colectie de informatii (date, o aplicatie, sau documente). In Linux un fisier
poate cuprinde orice. Cand se creeaza un fisier, Linux-ul ii atribuie acestuia un numar de
identificare intern unic. Acest numar de index este utilizat pentru a putea localiza fisierul pe
hard disk.12
Deci, un sistem de fisiere este un ansamblu de fisiere si directoare. Sistemele de fisiere
sunt dependente de dimensiunea si structura discului, precum si de structura interna a
Linuxului. Intr-un sistem multiuser (multi utilizator), poate exista la un moment dat un numar
mare de fisiere stocate. Din aceasta cauza, utilizatorii au nevoie de un sistem care sa le
permita identificarea rapida si simpla a fisierelor.
De obicei, directoarele si fisierele utilizatorilor se afla stocate pe un alt sistem de fisiere
decat cel pe care se afla directoarele si fisierele sistemului de operare. Daca exista un numar
mare de utilizatori atunci fisierele utilizatorilor se pot intinde pe mai mult de un sistem de
fisiere.
Sistemul de fisiere se refera la modul in care Linuxul implementeaza fisierele si
directoarele.
2.1.4.Gestiunea proceselor
Un proces se desfasoara in timp si are un caracter dinamic. Initierea unui proces poate fi
efectuata numai de catre un alt proces activ. Cand este conectat primul utilizator, Kernel-ul
asigura o copie a Shell-ului ce se ruleaza doar pentru el, ivindu-se existenta unei alte structuri
ierarhice de procese create printr-un mecanism numit bifurcatie (fork) prin care Kernel
inlocuieste un proces existent prin 2 procese:13
procesul initial(parinte);
procesul initiat de procesul initial (fiu) care imparte(partajeaza) toate fisierele cu
procesul parinte. Dupa bifurcatie, ambele procese se executa independent
(exceptie:cand solicitam explicit ca procesul parinte sa astepte terminarea procesului
fiu prin directiva WAIT, in continuare procesul fiu poate general la randul lui o noua
bifurcatie).
Explicand mai pe larg,fiecare proces din sistem are un proces care l-a creat, numit proces
parinte, (sau tata) si de la care "mosteneste" un anumit ansamblu de caracteristici (cum ar fi
proprietarul
sau
drepturile
de
acces).
Fiecare proces are asignat un PID (process identification=identificator de proces), ce este
un numar intreg pozitiv si care este unic pe durata vietii acelui proces (in orice moment, nu
exista in sistem doua procese cu acelasi PID). Aceste numere sunt alocate proceselor in mod
crescator, incepand cu 0 in momentul cand se creeaza procesul.Exista un proces special, cel
cu PID = 0, care este creat atunci cind este initializat (boot-at) sistemul pe calculatorul
respectiv. Acesta nu are proces tata, fiind radacina arborelui de procese ce se vor crea pe
12
13

parcursul timpului (pina la oprirea calculatorului). Celelalte procese sunt create cu ajutorul
functiei sistem fork.14
Un program executabil este incarcat in memorie prin functia de sistem exec. In termenii
kernel-ului Linux, un proces este reprezentat de o structura destul de mare,numita
task_struct.Aceasta structura contine toate datele necesare pentru a reprezenta un proces si de
a intretine relatii cu alte procese (parinti si copii).
De la user-space, procesele sunt reprezentate prin procesul de identificare (PIDs). Din
perspectiva utilizatorului, un PID este o valoare numerica, care identifica in mod unic un
proces. PIDs pot fi refolosite, dupa ce un proces moare. In spatiul de utilizator, puteti creea
procese in mai multe moduri.Puteti executa un program (care duce la crearea unui nou proces)
sau, puteti invoca un fork sau exec sistem de apel. Un apel exec inlocuieste procesul actual cu
noul program.15
2.1.5.Crearea unui proces

Modul cel mai simplu prin care se poate crea un nou proces este prin folosirea functiei de
biblioteca system:16
int system(const char *command);
Apelul acestei functii are ca efect executia ca o comanda shell a comenzii reprezentate prin
sirul de caractere command. In UNIX singura modalitate de creare a unui proces este prin
apelul de sistem fork:17
pid_t fork(void);
Efectul este crearea unui nou proces - procesul copil, copie a celui care a apelat fork procesul parinte. Copilul primeste un nou PID de la sistemul de operare.
Asteptarea terminarii unui proces este realizata de familia de functii wait care suspenda
executia procesului apelant pana cand procesul (procesele) specificate in argumente fie s-au
terminat fie au fost oprite (SIGSTOP).18
pid_t waitpid(pid_t pid, int *status, int options);
Valoarile uzuale ale argumentului pid sunt identificatorul unui proces copil (spre exemplu,
returnat de fork) sau -1, in cazul in care se doreste asteptarea oricarui proces copil.
14
http://tldp.org/LDP/intro-linux/html/sect_04_03.html
16
http://polishlinux.org/console/managing-processes-in-linux/
15
17
18
19
2.1.6.Comenzi pentru gestiunea proceselor UNIX Linux

1. ps
Ofera informatii despre procesele active in acel moment, despre programele care ruleaza.
Aceste informatii pot include identificatorul procesului (PID), identificatorul parintelui(PPID)
, terminalul de control al procesului (TT), starea procesului (STAT- secventa de 5 litere,
fiecare precizand un anumit aspect relativ la proces-starea executiei, daca imaginea procesului
se afla in memorie, prioritate), durata procesului (TIME). Starea procesului poate fi in
executie, w-in asteptare, s-suspendat, t-oprit, z-terminat, o-inexistent. Aceste date pot fi
valoroase atunci cand aveti nevoie pentru a opri manual un program sau daca trebuie doar
pentru
a
determina
ce
program
incetineste
sistemul.20
2. kill
functia:"omoara" un proces in curs de executie
sintaxa:kill [optiuni] (pid)
Distruge procesul cu identificatorul (pid). Semnalul de distrugere sigura se da prin
folosirea optiunii -9, altfel nefiind sigur ca distrugerea se va realiza. Optiunea -9 se va folosi
doar cand prima forma a comenzii nu da rezultate.21
19
20
21
http://articles.techrepublic.com.com/5100-10878_11-5025322.html
3. sleep
functia:suspenda temporar executia unui proces
sintaxa:sleep (timp)
Timpul este dat in secunde
4. time
functia:furnizeaza timpul de executi al unei comenzi
sintaxa:time (comanda)
Se lanseaza in executie (comanda), iar la sfirsitul executiei se afiseaza timpul de executie
si timpul sistem, in secunde.22
5. sh
functia: lanseaza in executie interpretorul Shell
sintaxa: sh (fisier)
Executa un fisier de comenzi Shell.
22
23
Capitolul 3: Apelurile API pentru gestionarea job-urilor si

ale proceselor - Victor Petrache (431A)
3.1 Ce este un API?

API (application programming interface) reprezinta un set de reguli si specificatii
utilizate de programele software pentru a comunica intre ele. Acestea au rolul de a facilita
interactiunea programelor intre ele, similar cu felul in care interfetele vizuale ajuta la
interactiunea intre om si calculator.
Un API poate fi creat pentru aplicatii, librarii, sisteme de operare etc. ca un mod de a
define vocabularul acestora si conventiile pentru cereri de resurse. Acestea pot contine
specificatii pentru rutine, structuri de date, clase de obiecte si protocoale folosite pentru
comunicarea dintre programul folosit de catre utilizator si programul ce implementeza API-ul.
API-urile pot fi:
Generale - un set complet de API, care este ncorporat in bibliotecile unui limbaj
de programare, de exemplu: Standard Template Library in C++ sau Java API
Specifice - menite sa abordeze o problema specifica, de exemplu Google Maps
API sau API Java pentru Servicii Web XML.
Dependente de limbaj - ceea ce inseamna ca este disponibil doar prin utilizarea
elementelor de sintaxa ale unui anumit limbaj, ceea ce face API-ul mai usor de
utilizat.
Independente de limbaj scris, astfel incat sa poata fi apelat din mai multe
limbaje de programare diferite. Aceasta este o caracteristica de dorit pentru APIurile orientate pe servicii care nu sunt legate de un process specific sau de sistem si
pot fi furnizate ca apeluri de procedura la distanta sau ca servicii web.24
3.2 WINDOWS API

Windows API (fostul Win32 API) reprezinta setul de API-uri disponibile in sistemele
de operare Microsoft Windows . 25
Apelurile de sistem ale sistemului de operare windows pentru gestionarea proceselor
de sistem sunt:
24
25
EnumProcesses aceasta functie completeaza un vector de valori DWORD

cu identificatorii tuturor proceselor din sistem, pe scurt face enumerarea
tuturor proceselor active din sistem.
http://en.wikipedia.org/wiki/Application_programming_interface
http://en.wikipedia.org/wiki/Windows_api
OpenProcess folosit pentru a deschide un proces local existent in sistem. Are

ca parametru identificatorul de proces primit dupa utlizarea EnumProcesses
CloseHandle utilizat pentru a incheia utilizarea unui anumite proces.
CreateProcess creaza un nou proces
CreateProcessAsUser creaza un nou process care va fi rulat numai de catre
utilizator specificat ca parametru
GetCurrentProcessId returneaza identificatorul de proces al procesului
apelant
GetEnvironmentVariable returneaza valoarea variabilei specificate din
blocul de mediu al procesului apelant
GetExitCodeProcess returneaza statutul de terminare al procesului
specificat.
GetProcessId returneaza identificatorul unui proces specificat
SetPriorityClass returneaza clasa de prioritate a procesului specificat
SetProcessAffinityMask seteaza afinitatea mastii unui processor pentru
thread-urile unui proces specific.
TerminateProcess inchide procesul specificat si toate thread-urile sale
Acestea reprezinta o parte din API-urile Windows pentru gestionarea proceselor, setul
intreg de functii se poate gasi in cadrul documentatie oferite de catre compania Microsoft
pentru sistemele de operare Windows. 26
3.3 LINUX Kernell API

Kernelul Linux este intr-o continua evolutie, linuxul in sine fiind un sistem de operare
de tipul OPEN-SOURCE, kernelul sau suferind imbunatatiri intr-un mod constant. Aceste
imbunatatiri sunt aduse sub forma unor noi API-uri unele mai stabile, altele mai putin stabile,
neavand un sistem strict de standardizare ca in cazul Windows-ului.
Apelurile API pentru gestionarea proceselor utilizate in cadrul Linux sunt :
26
fork() va crea un nou process subordonat procesului parinte identic cu acesta

dar avand un nou id de process.
vfork () va crea un proces subordonat si va bloca procesul parinte
exit() va inchide procesul curent
clone() creeaza un proces subordonat, care imparte memoria si descriptorii
de fisier cu procesul parinte.
wait / waitpid asteapta incheierea unui proces
setpgid/getpid seteaza grupul unui proces
setsid creeaza o sesiune noua si seteaza id-ului grupului de proces
setgid seteaza indentificatorul unui grup
killpg trimite semnalul de inchidere unui grup de procese
kill trimite semnalul de inchidere catre un anumit proces
execv / execvp utilizate pentru executarea unui proces
http://msdn.microsoft.com/en-us/library/ms684847%28v=VS.85%29.aspx#process_functions
execve executa un proces intr-un mediu asignat
Datorita faptului ca LINUX este un sistem aflat in continua dezvoltare, aceasta lista de APIuri poate fi modificata intr-un mod constant, lucru ce duce la imbunatatirea kernel-lui
sistemului si implicit la imbunatatirea sistemului de operare LINUX. 27
27
http://www.yolinux.com/TUTORIALS/ForkExecProcesses.html
Capitolul 4:
Comparatie intre implementarea
proceselor si firelor de executie la Linux si WindowsMadalina Dobroiu(431A)
Toate sistemele de operate moderne se bazeaz pe nite concepte de baz precum
procesele, memoria, fiierele etc. Nu este necesar ca un utilizator normal a unui sistem de
operare s cunoasc aceste concepte dar un programator ar trebui s le cunoasc pentru a
putea dezvolta aplicaii ct mai eficiente, care utilizeaz corect toate resursele sistemului de
calcul, de preferin portabile de pe un sistem de operare pe altul.
Cea mai simpla definiie a unui proces este: Un proces este un program aflat n curs
de execuie.
Un sistem de operare modern are sarcina de a crea i termina procese, suspenda i
continua procese, sincroniza procese prin metode specifice, asigura comunicarea ntre
procese, rezolva situaiile de impas etc. Pentru a realiza aplicaii, programatorul se va folosii
de aceste funcii ale sistemului de operare. Problema este ca sistemele de operare abordeaz
diferit aceste funcii, fiecare abordare avnd unele avantaje dar i unele dezavantaje.
Cele mai utilizate sisteme de operare n prezent sunt cele bazate pe UNIX i diferitele
versiuni ale sistemelor Windows. Prerile despre aceste dou feluri de sisteme difer, unii
spunnd ca sistemele bazate pe UNIX au un avantaj fa de sistemele Windows pentru c
ofer o flexibilitate, stabilitate i securitate mai mare, pe de alt parte alii pretind c sistemele
Windows au un avantaj deoarece sunt mai uor de folosit. n timp diferenele ntre aceste dou
sisteme s-au micorat.
4.1.Procese n Linux
4.1.1 Implementarea in Linux
In Linux nu exista o diferenta precisa intre procese si fire de executie.Un proces parinte
poate crea mai multe procese copil care acceseaza acelasi spatiu de memorie alocat
procesului parinte.Atunci cand unul dintre copii incearca sa modifice(sa scrie) o zona de
memorie a procesului parinte,este creata o copie a acelei zone de memorie pe care va opera in
continuare procesul copil,nefiind astfel nevoie sa fie creata o copie a intreg spatiului de
memorie al procesului parinte pentru fiecare copil (se folosest emecanismul copy-onwrite).Procesele copil pot fi asemanate cu firele de executie28.
Pentru gestionarea proceselor in Linux,kernelul aloca fiecarui proces o structura de date
numita task_struct(definita in fisierul linux/include/linux/sched.h din codul sursa al
kernelului).Rezulta o colectie de structuri de date task_struct care va fi reprezentata sub doua
forme:
sub forma de vector(tabel de cautare) de structuri task_struct;
sub forma de lista circulara dublu-inlantuita de structuri task_struct.
28
David A Rusling, The Linux Kernel, 1999, carte disponibil gratuit la

adresa: http://tldp.org/LDP/tlk/tlk.html
In reprezentarea sub forma de tabel,fiecarui proces ii este asociat un identificator de

proces(PID).Relatia dintre PID si indexul unei structuri task_struct in vector este
urmatoarea(in versiunea 2.4 a kernelului) : Index = ((((PID) >> 8) ^ (PID)) & (PIDHASH_SZ
1)) ,unde PIDHASH_SZ este dimensiunea tabelului de cautare.
Reprezentarea sub forma de lista circulara dublu-inlantuita este folosita pentru a stabili
ordinea de executie a proceselor. 29
Structura task_struct este foarte complexa insa campurile ei pot fi impartite in urmatoarele
categorii
Stari: Orice proces isi schimba starea in functie de contextul in care se afla.
Putem avea urmatoarele tipuri de stari :
in executie : procesul ruleaza sau este capabil sa ruleze dar asteapta sa fie preluat de
catre
microprocesor;
in asteptare : procesul asteapta un eveniment sau eliberarea unei resurse;procesele in
asteptare pot fi
intreruptibile(pot fi oprite cu anumite semnale de oprire) si neintreruptibile(functionarea lor
este
conditionata de partea hardware si nu pot fi intrerupte folosind semnale);
oprit : procesul a primit un semnal de oprire;
Zombie : sunt procese oprite dar care inca mai au o structura task_struct alocata in
tabelul de cautare.
Informatii utile coordonarii proceselor:in functie de aceste informatii sunt
distribuite resursele si prioritatile de executie proceselor.
Identificatori:ID de utilizator,ID de grup s.a. ; in functie de aceste informatii sunt
stabilite drepturile de acces ale proceselor la sistemul de fisiere.
Comunicare intre procese- sunt suportate diverse mecanisme de comunicare intre
procese : semafoare,semnale,cozi de mesaje,tevi,memorie partajata.
Legaturi : orice proces are un proces parinte.Parintele tuturor proceselor din
Linux este procesul init(1).Structura task_struct contine pointeri catre parintele
procesului respectiv,catre alte procese care au acelasi parinte(frati),catre
procesele copil.
Cronometre : contoare care tin evidenta timpului consumat de fiecare proces in
parte.In functie de aceste contoare procesul isi poate trimite anumite semnale la
anumite momente de timp in executia sa.
29
David A Rusling, The Linux Kernel, 1999
4.1.2.Crearea proceselor :
La pornirea sistemului in modul nucleu,exista un singur proces initial parinte.

Dupa ce sistemul a fost initializat acest proces parinte lanseaza un fir de executie(un
proces copil) numit init dupa care ramane inactiv.Structura task_struct alocata
procesului parinte este singura care nu este alocata dinamic ci este declarata ca
variabila statica in codul sursa al kernelului(se numeste init_task).
Dupa ce a fost lansat in executie,procesul init initializeaza sistemul(initializeaza
consola,monteaza sistemul principal de fisiere) dupa care,in functie de continutul
fisierului /etc/inittab lanseaza in executie alte procese.
Din aceasta faza noi procese pot fi create prin clonarea celor deja existente prin
apelarea unor proceduri de sistem(clone,fork,vfork). 31
Daca dorim sa rezolvam o problema care se preteaza la o implementare cu mai multe

procese, primul lucru pe care ar trebui sa-l stim este cum sa creem un nou proces.In Linux ,
modalitatea de a crea un nou proces este apelul functiei fork() , care se gaseste in bibliotecile
"unistd.h" si "sys/types.h" ,acestea trebuind incluse daca vrem sa utilizam (cu succes) functia
fork.
Prototipul arata cam asa: pid_t fork(void);
Ce se intampla dupa un apel fork
:
-se creaza un nou proces , prin copierea segmentelor de date si de cod ale procesului
apelant;
30
31
http://ebooks.unibuc.ro/informatica/Seiso/4.2_files/text.htm
Andrew S. Tanenbaum, Sisteme de operare moderne, Byblos, 2004;
-functia intoarce in procesul tata PID-ul(process identifier) procesului nou creat;

-functia intoarce in procesul fiu 0;
-intoarce -1 in caz de eroare (adica nu s-a reusit crearea unui nou proces).
Sa urmarim un exemplu ca sa ne dam seama si mai bine ce se intampla. Programul
urmator creaza un proces copil , dupa care fiecare proces isi tipareste PID-ul.
#include
#include
#include
int main()
{ pid_t pid;
int status;
//apelul fork()
pid=fork();
switch(pid)
{ case 0: //aici ne aflam in procesul copil
printf("PID fiu:%d\n",getpid());
return 0;
break;
case -1:
//eroare- ar fi bine daca s-ar face si tratarea erorii
break;
default:
//aici ne aflam in procesul parinte
//asteptam intai sa se termine procesul copil
wait(&status);
//tiparim mesajul
printf("PID parinte:%d\n",getpid());
}
return 0;
}
Observatii:
Se vede ca in switch(pid) , cand ma aflu in procesul copil la sfarsitul sectiunii case
corespunzatoare (case 0) folosesc inainte de break apelul return.Aceasta imi asigura ca dupa
apelul fork procesul copil executa numai ce se afla intre case 0: si apelul return , asigurand
astfel terminarea procesului copil. Din cauza ca se copiaza zona de cod a procesului parinte in
procesul fiu , dupa iesirea din switch() , ambele procese vor executa aceleasi instructiuni. In
exemplul de fata , nu se mai executa decat return , deci s-ar fi putut si fara return la procesul
copil. Daca programul ar contine o bucla in care se face un fork , daca procesul copil nu se
termina , ar putea rezulta ceea ce se numeste un fork-bomb , programul generand la infinit noi
procese , care vor provoca in cele din urma o blocare a sistemului de operare.
S-a folosit functia wait: pid_t wait(int *status); pentru a astepta terminarea procesului
copil. Daca nu se face wait , procesele copil terminate vor fi inca prezente in sistemul de
operare ca defuncte sau zombie. Daca vreti sa vedeti cum se manifesta asta faceti mai multe
procese pe care nu le asteptati cu wait() si urmariti procesele pornite din sistem. Functia wait
asteapta terminarea oricarui proces copil , dupa care in "status" se pot regasi informatii despre
codul de return al procesului fiu si alte
Pentru a intoarce PID-ul procesului parinte avem functia: chestii interesante. Pentru a
astepta terminarea unui anumit proces , se foloseste waitpid: pid_t waitpid(pid_t pid,int
*status,int options); care asteapta terminarea procesului cu PID-ul pid.
Pentru a intoarce PID-ul procesului curent avem functia:
pid_t getpid(void);
pid_t getppid(void);
Observatie:
Din cauza faptului ca dupa apelul fork se copiaza sectiunea de date a procesului parinte in
procesul fiu , orice modificare asupra unei variabile declarata inainte de fork() intr-un proces
nu va fi sesizata in celalalt proces.
4.1.3.Rularea unui program executabil
Cel mai simplu mod prin care se poate rula un proces este prin folosirea funciei de
bibliotec system :
int system(const char*command);
Apelarea acestei funcii are ca efect execuia sub forma unei comenzi shell comanda
reprezentat prin stringul de caractere command.
Implementarea system: este creat un nou process cu fork; procesul copil rezultat execut
prin intermediul exec programul sh cu argumentele c command, timp n care printele
ateapt terminarea procesului copil. 32
4.1.4.Afia unui copac de procese
pstree arat procesele care ruleaz ca un copac. Copacul este nrdcinat fie la pid sau la
iniializare dac PID este omis. n cazul n care un nume de utilizator este specificat, toate
procesele copaci deinute de utilizator sunt afiate.
$ pstree
32
E. Raymond The Art of Unix Programming Addison-Wesley, 2003
4.1.5. nlocuirea imaginii unui proces

Familia de funcii exec execut un nou program n care inlocuiesc imaginea procesului
curent cu cea dintr-un fiier (executabil). Spaiul de adrese este nlocuit de unul nou special
creat pentru execuia fiierului. De asemenea, vor fi reinitializai regitrii hardware ai
procesorului IP (EIP/RIP) i SP (ESP/RSP) i regitrii generali. Vor fi setate la valorile
implicite mstile de semnale ignorate i blocate, ca i handler-ele semnalelor. PID-ul i
descriptorii fiierelor ce nu au setat flagul CLOSE_ON_EXEC vor rmne neschimbai
(deoarece implicit flagul CLOSE_ON_EXEC nu este setat). 33
int execv(const char *filename, char *const argv[]);
EXECV execut programul descris de pointerul ctre irul de caractere filename; vectorul
argv e format din pointeri ctre iruri de caractere ce descriu argumentele cu care programul
reprezentat de filename va fi executat; ultimul element al vectorului trebuie s fie setat pe
NULL. Calea catre program trebuie s fie complet pentru c nu se caut n PATH.
Primulargument este numele programului.
int execl(const char *filename, const char *arg0, ...);
La EXECL argumentele vor fi date ca parametri ai funciei. Ultimul parametru trebuie s
fie NULL, iar primul argument trebuie s fie numele programului.
int execve(const char *filename, char *const argv[], char *const env[]);
EXECVE este la fel ca execv, dar primete un vector de pointeri la iruri de caractere care
descriu variabile de mediu. Ultimul element al vectorului env trebuie s fie setat pe NULL, iar
irurile de caractere trebuie s fie de forma VARIABILA = VALOARE.
int execle(const char *filename, const char *arg0, ..., char *const env[]);
EXECLE este la fel ca execl, dar primete un vector de pointeri la iruri de caractere care
descriu variabile de mediu. Ultimul element al vectorului env trebuie s fie setat pe NULL, iar
irurile de caractere trebuie s fie de forma VARIABILA = VALOARE.
int execvp(const char *filename, char *const argv[]);
EXECVP este asemntoare cu execv, dar calea programului nu mai trebuie s fie absolut
pentru c va fi cutat n toate directoarele specificate de variabila de mediu PATH.
int execlp(const char *filename, const char *arg0, ...);
EXECLP este asemntoare cu execl, dar calea programului nu mai trebuie s fie absolut
pentru c va fi cutat n toate directoarele specificate de variabila de mediu PATH.
Daca se folosete orice funcie din familia exec, atunci este necesar includerea headerului
unistd.h. 34
4.1.6.Ateptarea terminrii unui proces
Familia de funcii wait suspend execuia procesului apelant pn cnd procesul (procesele)
specificate n argumentele acesteia fie s-au terminat, fie au fost oprite (SIGSTOP).
pid_t waitpid(pid_t pid, int *status, int options);
33
34
Vicki Stanfield, R. Smith Administrarea Sistemului Linux Teora 2004

E. Raymond The Art of Unix Programming Addison-Wesley, 2003
Procesul apelant va fi blocat pn cnd procesul cu PID-ul pid se va termina sau va fi oprit i
el la rndul lui.
Valoarea argumentului pid poate fi:
>0 atunci cand reprezint PID-ul unui proces;
0 (WAIT_MYGRP) i atunci identific orice proces copil din grupul de procese din
care
face parte procesul apelant;
-1 (WAIT_ANY) orice proces copil.
Parametrul options poate fi setat cu unul sau mai multe din urmtoarele flaguri
(combinate prin SAU pe bii):
WNOHANG dac nici unul din procesele specificate nu este terminat, se va iei
imediat
din apelul waitpid (procesul care apelase waitpid nu se blocheaz);
WUNTRACED waitpid se ntoarce i dac unul dintre procesele specificate s-a
oprit, iarinformaiile despre aceast oprire nu au fost nc raportate; dac acest flag
este setat,waitpid se ntoarce i pentru procesele copil care s-au oprit, dar care nu se
afl ntreprocesele urmrite de procesul apelant; informaiile despre copii urmrii
suntfurnizate chiar dac acest flag nu este precizat.35
Funcia va ntoarce PID-ul procesului a crui stare este raportat; informaiile de stare sunt
depuse n locaia ctre care indic status. Funcia se va bloca dac nici unul din procesele
specificate nu este nc terminat (sau dac nici unul din ele nu este oprit i s-a
setatWUNTRACED), mai puin atunci cnd este setat WNOHANG, caz n care funcia
ntoarce 0.
Atunci cnd este eroare se va ntoarce -1, iar errno este setat pe:
EINTR apelul a fost ntrerupt de un semnal
ECHILD nu s-a specificat un PID de proces copil valid
EINVAL este specificat un flag invalid pentru options
Starea procesului interogat se poate afla prin examinarea statusului cu urmtoarele
macrodefiniii:
WIFEXITED(status) ntoarce o valoare diferit de 0 dac procesul interogat s-a
terminat prin exit
WEXITSTATUS(status), dac WIFEXITED(status) e diferit de 0, arat codul de
terminare a procesului
WIFSIGNALED(status) ntoarce o valoare diferit de 0 dac procesul interogat sa terminat datorit unui semnal netratat
WTERMSIG(status), dac WIFSIGNALED(status) e diferit de 0, arat numrul
semnalului datorit cruia procesul s-a terminat
WCOREDUMP(status) ntoarce o valoare diferit de 0 dac procesul interogat a
generat un core
WIFSTOPPED(status) ntoarce o valoare diferit de 0 dac procesul interogat este
oprit
WSTOPSIG(status), dac WIFSTOPPED(status) e diferit de 0, ntoarce numrul
semnalului care a oprit procesul
Observaie
35
S. Sinchack Hacking Windows XP e-book
Aceste macrodefiniii primesc ca argument buffer-ul n care se afl informaia de stare (adic
un int), i nu un pointer ctre acest buffer.
pid_t wait(int *status);
Varianta simplificat care ateapt orice proces copil s fie terminat. Este echivalent cu:
waitpid(-1, &status, 0);
Pentru a folosi wait sau waitpid trebuie incluse header-ele sys/types.h i sys/wait.h. 36
4.1.7.Terminarea unui proces
Pentru terminarea procesului curent LINUX pune la dispoziie apelul de sistem exit (al crui
antet este descris n stdlib.h).
void exit(int status);
Procesul apelant va fi terminat imediat. Toi descriptorii de fiier ai procesului sunt nchii,
copii procesului sunt infiai de procesul init, iar printelui procesului i va fi trimis un
semnal SIGCHLD. Procesului printe i va fi ntoars variabila status ca rezultat al unei
funcii de ateptare (wait sau waitpid).
Pentru terminarea unui alt proces din sistem, se va trimite un semnal ctre procesul respectiv
prin intermediul apelului de sistem kill.[4]
4.1.8.Copierea descriptorilor de fiier
int dup(int oldfd);
Duplic descriptorul de fiier oldfd i ntoarce noul descriptor de fiier sau -1 n caz de
eroare.
int dup2(int oldfd, int newfd);
Duplic descriptorul de fiier oldfd n descriptorul de fiier newfd; dac newfd exist,
mai nti va fi nchis fiierul asociat. ntoarce noul descriptor de fiier sau -1 n caz de eroare.
Descriptorii de fiier sunt de fapt un index n tabela de fiiere deschise, ce conine
pointeri ctre o structur ce conine informaii despre fiier. Duplicarea unui descriptor de
fiier nseamn duplicarea intrrii din tabela de fiiere deschise (adica un pointer). Din acest
motiv, toate informaiile asociate unui fiier (lock-uri, poziia n fiier, flagurile) sunt partajate
de cei doi file descriptori. Ceea ce nseamn c operaiile ce modific aceste informaii pe
unul din file descriptori (de ex. lseek) sunt vizibile i pentru cellat file descriptor (duplicat) i
invers.
Observatie: Exist i o excepie: flagul CLOSE_ON_EXEC nu este partajat (acest flag nu
este inut n structura menionat mai sus).
Pentru a putea folosi dup i dup2 trebuie inclus header-ul unistd.h. [8]
4.1.9.Motenirea descriptorilor de fiier dup operaii fork/exec
Descriptorii de fiier ai procesului printe se motenesc n procesul copil n urma apelului
fork. Dup un apel exec descriptorii de fiier sunt pstrai de asemenea, mai puin aceia dintre
ei care au setat flagul CLOSE_ON_EXEC.
Pentru a seta flagul CLOSE_ON_EXEC se folosete funcia fcntl cu un apel de genul:
fcntl(file_descriptor, F_SETFD, FD_CLOEXEC);
36
A. Tanenbaum Modern Operating Systems e-book
Pentru a putea folosi funcia fcntl trebuie incluse header-ele unistd.h i fcntl.h.
Trei dintre descriptorii de fiier sunt mai importani:
STDIN_FILENO toate programele obinuite conin acest file descriptor care are valoarea
0; el reprezint intrarea standard; tot ce utilizatorul scrie la terminal, programul va putea citi
din acest file descriptor
STDOUT_FILENO toate programele obinuite au acest file descriptor care are valoarea 1;
el reprezint ieirea standard; toate apelurile de genul printf vor genera output la terminal
STDERR_FILENO
toate programele obinuite au acest file descriptor care are valoarea 2; el reprezint ieirea
standard de eroare.37
4.1.10. Variabile de mediu
char **environ;
Un vector de pointeri la iruri de caractere, ce conin variabilele de mediu i valorile lor.
Vectorul e terminat cu NULL. irurile de caractere sunt de forma
VARIABILA=VALOARE.
char* getenv(const char *name);
ntoarce valoarea variabilei de mediu denumite name, sau NULL dac nu exist o variabil de
mediu denumit astfel.
int setenv(const char *name, const char *value, int replace);
Adaug n mediu variabila cu numele name (dac nu exist deja) i i seteaz valoarea la
value. Dac variabila exist i replace e 0, aciunea de setare a valorii variabilei e ignorat;
dac replace e diferit de 0, valoarea variabilei devine value.
int unsetenv(const char *name);
terge variabila denumit name din mediu. 38
4.1.11. Depanarea unui proces
Pe majoritatea sistemelor de operare pe care a fost portat, gdb nu poate detecta cnd un
proces realizeaz o operaie fork(). Atunci cnd programul este pornit, depanarea are loc
exclusiv n procesul iniial, procesele copii nefiind ataate debugger-ului. n acest caz, singura
soluie este introducerea unor ntrzieri n executia procesului nou creat (de exemplu, prin
apelul de sistem sleep()), care s ofere programatorului suficient timp pentru a ataa manual
gdb-ul la respectivul proces, presupunnd c i-a aflat PID-ul n prealabil. Pentru a ataa
debugger-ul la un proces deja existent, se folosete comanda attach, n felul urmtor:
(gdb) attach PID
Aceast metod este destul de incomod i poate cauza chiar o funcionare anormal a
aplicaiei depanate, n cazul n care necesitile de sincronizare ntre procese sunt stricte (de
exemplu operaii cu time-out).
Din fericire, pe un numr limitat de sisteme, printre care i Linux, gdb permite depanarea
comod a programelor care creeaz mai multe procese prin fork() i vfork(). Pentru ca gdb s
urmreasc activitatea proceselor create ulterior, se poate folosi comanda set followforkmode, n felul urmtor:
(gdb) set follow-fork-mode mode
unde mode poate lua valoarea parent, caz n care debugger-ul continu depanarea procesului
printe, sau valoarea child, i atunci noul proces creat va fi depanat n continuare. Se poate
37
38
Vicki Stanfield, R. Smith Administrarea Sistemului Linux Teora 2004

S. Sinchack Hacking Windows XP e-book
observa c n aceast manier debugger-ul este ataat la un moment dat doar la un singur
proces, neputnd urmri mai multe simultan.
Cu toate acestea, gdb poate ine evidena tuturor proceselor create de ctre programul
depanat, dei n continuare numai un singur proces poate fi rulat prin debugger la un moment
dat. Comanda set detach-on-fork realizeaz acest lucru:
(gdb) set detach-on-fork mode
unde mode poate fi on, atunci cnd gdb se va ataa unui singur proces la un moment dat
(comportament implicit), sau off, caz n care gdb se ataeaz la toate procesele create n
timpul execuiei, i le suspend pe acelea care nu sunt urmrite, n funcie de valoarea setrii
followfork-mode.
Comanda info forks afieaz informaii legate de toate procesele aflate sub controlul gdb
la un moment dat:
(gdb) info forks
De asemenea, comanda fork poate fi utilizat pentru a seta unul din procesele din list drept
cel activ (care este urmrit de debugger).
(gdb) fork fork-id
unde fork-id este identificatorul asociat procesului, aa cum apare n lista afiat de comanda
info forks.
Atunci cnd un anumit proces nu mai trebuie urmrit, el poate fi nlaturat din list folosind
comenzile detach fork i delete fork:
(gdb) detach fork fork-id
(gdb) delete fork fork-id
Diferena dintre cele dou comenzi este c detach fork las procesul s ruleze independent, n
continuare, n timp ce delete fork l ncheie. 39
4.2 Procese n Windows
Cel mai utilizat sistem de operare n prezent este Windows XP ocupnd n jur de 73% din
piaa sistemelor de operare. Asta nsemnnd c i majoritatea programelor sunt scrise n aa
fel nct s poate fi rulate pe acest sistem de operare.
4.2.1.Implementarea in Windows
La cel mai inalt nivel de abstractie,un proces Windows consta in urmatoarele elemente :
Un spatiu virtual de adrese privat(memoria pe care o are procesul la dispozitie);
Un program executabil care contine instructiunile programului si care va fi incarcat in
spatiul virtal de adrese;
lista de legaturi spre resurse de sistem,porturi de comunicatie,fisiere;
Un context de securitate reprezentat de un nume de utilizator,o lista de grupuri din
care face parte utilizatorul,privilegiile de care are parte procesul;
Un identificator de proces unic(intern se mai numeste si identificator de client);
Cel putin un fir de executie .
Un proces Windows mai contine si un pointer catre procesul parinte(din care a fost
lansat).Acest pointer poate fi nul. Firul de executie este componenta fundamentala a unui
proces.Un proces fara fire de executie nu se poate executa.Un fir de executie din Windows
poate fi descris de urmatoarele componente 40
39
40
Wikipedia free on-line encyclopedia www.wikipedia.com

Russinovich, M. E. and Solomon, D.A. Microsoft Windows Internals, 4th
Starea curenta a procesorului descrisa de valorile din registri(contextul);

Doua stive fiecare petru executia intr-unul din cele doua moduri : utilizator sau nucleu;
Un identificator al firului de executie(face parte din acelasi spatiu cu identificatorii de
procese astfell ca
nu va putea exista un proces si un fir de executie cu acelasi identificator);
Uneori firele de executie au si un context de securitate
Formatul contextului unui fir de executie este dependent de arhitectura masinii pe care
ruleaza sistemul de operare.Cu ajutorul metodei GetThreadContext se pot extrage informatii
din contextul firului de executie.
Fibrele sunt niste fire de executie care pot fi lansate in executie manual prin apelul
metodei SwitchToFiber.Spre deosebire de fibre,firele de executie ruleaza automat cu ajutorul
unui mecanism de coordonare bazat pe prioritati.
Ca si in Linux,in Windows exista doua moduri de acces la microprocesor : modul
utilizator si modul nucleu.Diferentierea modurilor de acces este necesara pentru a preveni
accesul utilizatorului la elemente critice ale sistemului de operare.In acest fel un eventual
comportament neobisnuit al unei aplicatii destinate utilizatorului nu va perturba functionarea
intregului sistem de calcul. 41
Pentru gestionarea proceselor in Windows,fiecarui proces ii este alocata o structura
EPROCESS. Pe langa diversi parametri ai procesului,aceasta structura mai contine si pointeri
catre alte structuri cum ar fi structuri de tip ETHREAD care descriu fire de executie sau spre
alte structuri EPROCESS(ex. Spre procesul
parinte).
4.2.2.Crearea unui proces :
Un proces este creat atunci cand un alt proces apeleaza metoda CreateProcess din
biblioteca kernel32.dll.
Crearea procesului se face in urmatorii pasi :
Fisierul executabil este analizat.Daca este un fisier executabil Windows pe 16 biti sau
MS-DOS atunci este creat un mediu special de executie pentru acesta;daca fisierul este
un executabil Windows pe 32 de biti se verifica registrul pentru a vedea daca are vreo
cerinta speciala.Operatiile de la acest pas se fac in modul utilizator.
. Se creeaza un obiect proces gol cu apelul de sistem NtCreateProcess si se adauga in
spatiul de nume al managerului de obiecte. Mai sunt create un obiect nucleu si unul
executiv. Managerul de proiecte creeaza un bloc de control al procesului pentru acest
obiect si il initializeaza cu Idul procesului si cu alte campuri.Este creat un obiect
sectiune pentru a urmari spatiul de adrese al procesului.
kernel32.dll preia controlul,efectueaza apelul de sistem NtCreateThread pentru a crea
un fir de executie initial.Se creeaza stivele utilizator si nucleu.Dimensiunea stivei este
data de antetul fisierului executabil.
kernel32.dll trimite subsistemului de mediu Win32 referintele catre proces si catre
firul de executie care sunt adaugate in niste tabele.
Este apelata o procedura de sistem care termina initializarea iar firul de executie
incepe sa ruleze.
Edition, Microsoft Press, 2005 (face parte din Windows Research Kernel)
41
procedura apelata la executie seteaza prioritatea firului de executie.Se repeta pasul

pentru toate firele de executie.Incepe rualrea codului principal al procesului. 42
Sistemul de operare poate crea procese sau poate desfiina procese.n timpul execuiei,
un proces poate crea unul sau mai multe procese noi. Procesele create sunt numite copii iar
procesul care le creaza este numit printe.
Procesul nou creat are i el nevoie de resurse, pe care le ia direct de la sistemul de
operare sau de la procesul printe.
Procesul printe poate aloca spre utilizare numai o parte a resurselor, cum ar fi
memoria sau fiierele, prevenind astfel suprancrcarea sistemului din cauza crerii prea
multor procese copii. 43
Funcia CreateProcess-Creeaz un proces nou.Noul proces ruleaz n contextul de
securitate oferit de procesulapelat. Daca procesul apelat ine loc de un alt user, procesul nou
utilizeaz semnul procesului apelat, nu semnul celui care ine loc userului. Pentru a rula noul
process n contextul de securitate al userului reprezentat de semnul nlocuitor, se folosete
funcia CreateProcessAsUser sau funcia CreateProcessWithLogonW.
Sintaxa:
BOOL WINAPI CreateProcess(
__in_opt LPCTSTR lpApplicationName,
__inout_opt LPTSTR lpCommandLine,
__in_opt LPSECURITY_ATTRIBUTES lpProcessAttributes,
__in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes,
__in BOOL bInheritHandles,
__in DWORD dwCreationFlags,
__in_opt LPVOID lpEnvironment,
__in_opt LPCTSTR lpCurrentDirectory,
__in LPSTARTUPINFO lpStartupInfo,
__out LPPROCESS_INFORMATION lpProcessInformation
);
Parametrii:
1)lpApplicationName Numele modulului care va fi executat.Acest modul poate fi o aplicaie
proprie Windows.Poate fi i alt tip de modul(de exemplu, MS-Dos sau OS/2), dac
subsistemul potrivit este disponibil pe calculator. Parametrul lpApplicationName poate fi
NULL. n acest caz numele modulului trebuie s fie primul semn delimitat de un spaiu, la
sfritul i la nceputului
argumentului.
2) lpCommandLine -Linia de comand poate fi executat. Lungimea maxim a acestui ir este
32 mii caractere. Daca parametrul lpCommandLine este NULL , atunci avem o limitare de
caractere
la
MAX_PATH.
Versiunea
Unicod
a
acestei
funcii,
CreateProcessWithLogonW poate modifica coninutul acestui ir.Drept urmare aceti
parametrii nu pot fi pointeri la
memoria read-only pentru c s-ar realiza o violare a accesului.
3) lpProcessAttributes-Un pointer la structura SECURITY_ATTRIBUTES care determin
daca ceea ce returneaz procesul poate fi motenit la noul proces provenit din acesta. Dac
acest paramentru este NULL atunci rezultatul returnat de process nu poate fi motenit.
42
43

4) lpStartupInfo un pointer la structura Startup Info.

5) lpProcessInformation - un pointer la structura ProcessInformation care primete
informaii identificatoare despre noul process.
6) lpCurrentDirectory Calea ctre directorul curent pentru proces. Dac parametrul este
NULL atunci noul proces va avea acelai director i drive ca i procesul apelat.
7) lpEnvironment un pointer ctre mediul alocat pentru procesul nou format.
Daca parametrul este NULL, noul proces folosete mediul vechiului proces.
Daca funcia compileaz atunci rspunsul va fi o valoare diferit de 0, dac are eroare
atunci ntoarce 0. 44
8) lpThereadAttributes Un pointer ctre o structur de tipul SECURITY_ATTRIBUTES
care determin dac descriptorul ctre noul thread poate fi motenit de procese fiu. Dac
parametrul este NULL descriptorul nu poate fi motenit.
9) bInheritHandles Dac parametrul este TRUE orice descriptor care poate fi motenit va fi
motenit de procesul fiu. Dac este FALSE descriptorii nu vor fi motenii.
10) dwCreationFlags Acest parametru controleaz clasa de prioriti a procesului i crearea
acestuia.
Funcia CloseHandle-nchide un descriptor deschis.
Sintaxa:
BOOL WINAPI CloseHandle(
__in HANDLE hObject
);
Funcia nu are parametrii. Dac funcia complieaz, valoarea ntoars este diferit de 0, dac
nu, este 0. Funcia CloseHandle nchide descriptor ctre urmatoarele obiecte:
Access token;
Communications device;
Console input;
Console screen buffer;
Event;
File;
File mapping;
I/O completion port;
Job;
Mailslot;
Memory resource notification, etc.45
4.2.3.Ateptarea terminrii unui proces
Funcia WaitForInputIdle-Ateapt pn cnd procesul specificat ateapt iniializarea
userului sau pn cnd intervalul alocat s-a scurs.
Sintaxa:
DWORD WINAPI WaitForInputIdle(
__in HANDLE hProcess,
__in DWORD dwMilliseconds
);
Parametrii:
hProcess un descriptor ctre proces. Dac procesul este o aplicaie de consol sau nu are
un mesaj prestabilit atunci funcia raspunde imediat.
44
45
Microsoft Developer Network www.msdn.com

Return code/value Description

0 wait s-a terminat cu succes
WAIT_TIMEOUT wait s-a terminat deoarece time-slotul s-a terminat
WAIT_FAILED o eroare a avut loc. 46
4.2.4.Terminarea unui proces
Terminarea unui proces poate fi:
Terminare normala cand un proces se termin dup executarea ultimei sale
instruciuni;
Terminare forat cnd procesul se ncheie nainte de parcurgerea tuturor
instruciunilor sale.
Cnd copilul a depit limita de folosire a resurselor care i-au fost alocate sau nu mai
este util din punct de vedere al funciei pe care o realiza, procesul printe poate cere
ncheierea forat a execuiei sale.
Un proces independent este un proces a crui execuie nu poate afecta sau nu poate fi
afectat de execuia altor procese din sistem.47
Funcia TerminateProcess-nchide procesul specificat precum i toate procesele deschise de
acesta.
Sintaxa:
BOOL WINAPI TerminateProcess(
__in UINT uExitCode
);
Parametrii :
hProcess un descripor ctre procesul ce trebuie terminat. Acesta trebuie s aib accesul
corespunztor.
uExitCode codul de ieire ce va fi utilizat de ctre procesul care va fi nchis ca rezultat al
acestei comenzi. Folosete funcia GetExitCodeProcess pentru a gsii aceast valoare.
Valoarea returnat este diferit de 0 dac funcia compileaz, dac nu ea este 0. [10]
Funcia GetExitCodeProcess-ntoarce valoarea de sfarit a procesului terminat.
Sintaxa:
BOOL WINAPI GetExitCodeProcess(
__out LPDWORD lpExitCode
);
Parametrii:
hProcess- un descriptor pentru proces. Acesta trebuie s aib accesul corespunzator.
lpExitCode- Un pointer ctre o variabil prin care primete valoarea de sfrit a procesului
terminat. Dac procesul specificat nc nu a fost terminat i functia compileaz, atunci valoare
returnat este STILL_ACTIVE.
n rest, dac funcia compileaz valoarea este diferit de 0, daca nu, este 0.48
46

48
T. Ionescu, Florentina Mocrienco Structura si Functionarea Sistemelor de Calcul e-book
47
4.2.5.Variabile de mediu
Funcia GetEnvironmentStrings-ntoarce variabilele mediului corespunztor pentru procesul
curent.
Sintaxa:
LPTCH WINAPI GetEnvironmentStrings(void);
Daca funcia compileaz atunci rspunsul este un pointer ctre environment block al
procesului curet, dac nu atunci rspunsul este NULL.49
49
Capitolul 5. Emularea programelor MS DOS- Adriana

Stoian(431A)
5.1 Notiuni DOS

DOS, abreviere de la Disk Operating System. este un sistem de operare care ruleaza o singura
aplicatie in acelasi timp, adica un sistem single-tasking, single-user (un singur utilizator
existent) ce este bazat pe linia de comanda, care nu asigura executarea concurenta si nici
impartirea resurselor intre mai multe procese. Sub controlul unui sistem de operare
monotasking, in sistemul de calcul se poate executa un singur program; in acelasi timp; el va
ramane activ din momentul lansarii executiei sale pana in momentul finalizarii; atat timp cat
este in executie, programul are access la toate resursele sistemului de calcul.
Sistemele DOS includ MS-DOS, PC-DOS, DR-DOS, FreeDos, PTS-DOS, ROM-DOS,

Caldera DOS, Novell DOS si multe altele.
n ciuda utilizrii comune, niciunul dintre acestea sisteme nu a fost pur i simplu numit
"DOS". Un numr de sisteme de operare microcalculator non-x86 independente au avut
"DOS" n numele lor, i sunt adesea denumite simplu "DOS" atunci cnd se discut despre
microcalculatorul care le utilizeaz (de exemplu AmigaDOS, AMSDOS, ANDOS, Apple
DOS, Atari DOS, DOS Commodore, CSI-DOS, ProDOS, i TRS-DOS). Oferind n acelai
timp multe dintre funciile acelai sistem de operare pentru sistemul lor informatic, programe
care ruleaz n unul dintre aceste sisteme operare nu ar rula n altele.
5.2 Definitie emulatoare

Un emulator dubleaza functiile unui sistem folosind un sistem diferit, astfel incat al doilea
sistem se comporta identic ca primul sistem. Aceast concentrare pe reproducerea exact a
comportamentului extern este n contrast cu alte forme de simulare pe calculator, care pot
afecta modelul abstract ale sistemului simulat50.
Fiecare computer consta intr-o parte hardware si una software. Prin integrarea acestora, un
calculator poate oferi o gama larga de posibilitati, cum ar fi crearea de documente office,
navigarea pe internet si posibilitatea de a juca diverse jocuri. Dependenta puternica dintre
partea hardware si partea software introduce, de asemenea, un risc. Dac unul dintre acestea
50
"Emulation for Digital Preservation in Practice: The Results." The International Journal of Digital Curation
2.2 (2007): 123-132, van der Hoeven, Jeffrey, Bram Lohman, and Remco Verdegem
eueaz, acesta va avea o influen asupra funcionrii computerului i prin urmare a

capacitilor sale. Aa cum fiecare dispozitiv hardware n cele din urm va inceta sa
fuctioneze, accesibilitatea la obiectele digitale este n joc. Emularea ofer o soluie la aceast
problem.
5.3 Emulatoare MS-DOS

n Linux este posibil s se ruleze copii de DOS i multe dintre clonele sale sub DOSEMU, o
main de Linux-nativ virtual pentru rularea programelor DOS la viteza de aproape native.
Exist o serie de alte emulatoare pentru DOS care ruleaz sub diferite versiuni de UNIX, chiar
i pe platforme non-x86, cum ar fi DOSBox51 .
Emulatoarele DOS ctig popularitate printre utilizatorii Windows XP i Windows Vista,

deoarece aceste sisteme sunt foarte incompatibil cu DOS pur. Ele pot fi folosite pentru a rula
jocuri sau alte programe DOS. Una dintre cele mai cunoscute este DOSBox, proiectat pentru
jocuri vechi (de exemplu, King's Quest, Doom) pe sistemele de operare moderne.
Este posibil a rula aplicaii DOS sub Microsoft Virtual PC, care permit o compatibilitate mai
bun dect emulatoarele DOS. O versiune legitim a MS-DOS poate fi instalata, care ar trebui
s permit tuturor, cu exceptia aplicaiilor celor mai ncpnate s ruleze.
5.4 Exemple de emulatoare MS-DOS

1. DOSBox
DOSBox emuleaz un PC Intel x86 complet cu sunet, grafica, mouse, joystick, modem, etc.
necesare pentru a rula mai multe jocuri vechi de MS-DOS, care pur i simplu nu pot fi rulate
pe PC-uri moderne i sisteme de operare cum ar fi Microsoft Windows XP Windows Vista
Linux si FreeBSD. Cu toate acestea, nu este limitat la a rula doar jocuri. In teorie orice
aplicatie MS-DOS sau PC-DOS (menionate la frecvent ca "DOS") ar trebui s ruleze n
DOSBox dar accentul a fost pus pe obtinerea de rularii jocurilor DOS fr probleme ceea ce
nseamn c suportul de imprimanta, crearea de retele si comunicarea sunt nc n dezvoltare.
DOSBox, de asemenea, vine cu propriile sale linii de comand DOS. Este nc destul de
rudimentar i nu are multe dintre caracteristicile care se gsesc n MS-DOS dar este suficient
pentru instalarea i rularea celor mai multe jocuri DOS52. Aplicaia creeaz fereastra care arata
precum consola obinuit, cu exceptia faptului ca mediul este complet virtualizat.
Acest lucru i permite sa emuleze o gam larg de hardware-uri motenite i s accelereze sau
ncetineasc dup cum este necesar.
51
http://www.dosbox.com/information.php
52
http://www.dosbox.com/wiki/Main_Page
DOSBox nu conine sau necesit fiiere reale DOS, astfel nct poate fi utilizat n mod liber,
fr
licen.
Ce se ntmpl n interiorul consolei poate fi capturat ca imagine i nregistrat ca video.
Acesta accept chiar lucrul n reea pentru a permite multiplayer LAN peste moderne. Setarile
sunt salvate n folderul de profil al utilizatorului53.
2. RealSpec v0.96.16
Emuleaz: 16K / 48k / 128K / 2 / 2 A / 3 Spectrums ZX. Didaktik Pentagon i clone Scorpion.
Formate disc: Z80 (cu extensii Scorpion), .sna, .slt, .sp, .tap, .tzx, .rzx, .wav, .csw, .mgt, .img
(DISCiPLE/+D), .trd, .scl (TR-DOS), .mbd (MB-02+), .opd, .dsk, .d80, .mdr, .wdr, .air, .pok
si .rom
Cerine: 200 MHz Pentium / AMD echivalent. 8MB RAM sau mai mult. MS-DOS Windows
9x Me 2000 sau XP
Creat de: RamSoft
Ultima actualizare: 10 septembrie 2002
Fr ndoial cel mai cuprinzator emulator disponibil RealSpec ar fi, de asemenea, considerat
de muli a fi cel mai exact. Toate caracteristicile nedocumentate procesorului Z80A sunt exact
emulate, cum ar fi comportamentul registrului de fanioane. Modurile video reproduse fidel si
poate fi configurat extensiv.
De asemenea, emuleaz Multiprint, Multiface 1 / 128, MGT DISCIPLE interfa disc, Opus
Discovery, Rotronics Wafadrive, ZX Interface I (cu suport de reea), Microdrives, interfata
53
http://www.rarst.net/software/dosbox/
disc Beta 128, Mouse Kempston si mai multe interfee audio diferite, etc. Fisierele audio sunt
bine emulate si pot fi configurate extensiv. n plus, fa de formatele de fiiere listate,
RealSpec poate ncrca i / sau a salva audio video si imagini.
O documentatie extinsa este inclusa, cu informaii de referin suplimentare pentru emulator,
hardware-uri i formate de fiier acceptate si disponibile pe site-ul RamSoft. Versiuni
adecvate pentru utilizarea cu procesoare AMD sau Intel Pentium sunt disponibile. Versiunea
MS-DOS va rula sub emulare MS-DOS pe Microsoft Windows 2000 / XP platforme cu
limitri (fr sunet)54.
54
http://www.worldofspectrum.org/faq/emulators/msdos.htm
Capitolul 6 : Procesul de bootare a sistemului de

operare: comparatie Windows si Linux- Fratila Dragos
Sorin( 433 A)
6.1.Bootarea sistemului de operare Linux

Primul lucru pe care il face un computer la startup este un test primar (POST Power
On Self Test) prin care se testeaza diversele componente hardware existente in sistem. Astfel,
se testeaza procesorul, memoria, placa video, tastatura, mouse-ul, etc... Tot aici se testeaza
mediul de BOOT (hard disk, unitate floppy, CDROM). Dupa POST, loader-ul din ROM
incarca sectorul de BOOT, care la randul lui incarca sistemul de operare de pe partitia activa.
Blocul de boot se afla intotdeauna la aceeasi locatie track 0, cilindru 0, capul 0 al
device-ului de sistem de pe care se face Bootarea. Acest bloc de boot contine un program
numit loader, in cazul Linux-ului este LILO (Linux LOader) sau Grub, care se ocupa efectiv
de Bootarea sistemului de operare. Aceste loadere din Linux permit, in cazul unei configuratii
multi-boot (mai multe sisteme de operare pe acelasi computer), selectarea sistemului de
operare care sa BOOT-eze. LILO si Grub se instaleaza ori in MBR (Master Boot Record), ori
in primul sector de pe partitia activa.
In continuare vom face referire la LILO ca loader pentru sistemul de operare. Acesta
se instaleaza de obicei in sectorul de boot, numit si MBR. Daca utilizatorul alege sa booteze
Linux, LILO incearca sa incarce kernel-ul sistemului de operare. In continuare sunt prezentati
pasii pe care ii urmeaza LILO pentru a incarca sistemul de operare:
1. In cazul configuratiilor multi-boot, LILO permite utilizatorului selectarea
sistemului de operare pe care sa-l incarce. Setarile pentru LILO se afla in /etc/LILO.conf.
Administratorii de sistem folosesc acest fisier pentru o configurare in detaliu a loader-ului.
Aici se pot stabili manual ce sisteme de operare sunt instalate, precum si modul de incarcare
pentru fiecare in parte. Daca pe un computer exista instalat numai Linux-ul, se poate
configura LILO sa incarce direct kernel-ul si sa sara peste pasul de selectie al sistemului de
operare.
2. Kernelul Linux-ului este instalat comprimat si contine un mic program care-l
decomprima. Imediat dupa pasul 1), are loc decomprimarea kernel-ului si incepe procesul de
incarcare al acestuia
3. Daca kernel-ul recunoaste ca in sistem exista instalata o placa video care suporta
moduri text mai speciale, Linux-ul permite utilizatorului sa selecteze ce mod text sa
foloseasca. Modurile video si alte optiuni pot fi specificate ori in timpul recompilarii kernelului ori prin intermediul lui LILO sau al altui program (rdev de exemplu).
4. Kernel-ul verifica configuratia hardware (hard disk, floppy, adaptoare de retea, etc),
si configureaza driverele de sistem. In tot acest timp sunt afisate mesaje pentru utilizator cu
toate operatiile care se executa.
5. Kernel-ul incearca sa monteze sistemul de fisiere si fisierele de sistem. Locatia

fisierelor de sistem este configurabila la recompilare, sau folosind alte programe LILO sau
rdev. Tipul fisierelor de sistem este detectat automat. Cele mai folosite tipuri de sistem de
fisiere pe Linux sunt ext2 si ext3. Daca montarea fisierelor de sistem esueaza, va fi afisat
mesajul kernel panic si sistemul va ingheta. Fisierele de sistem sunt montate de obicei in
modul read only, pentru a se permite o verificare a acestuia in timpul montarii. Nu este
indicat sa se execute o verificare a fisierelor de sistem daca acestea au fost montate in modul
read write.
6. Dupa acesti pasi, kernel-ul porneste programul init, care devine procesul numarul 1
si care va porni restul sistemului.
6.1.1.Procesul de initializare [INIT Process]
Procesul de initializare INIT Process , este primul proces al Linux-ului si este parintele
tuturor celorlalte procese. Este procesul care ruleaza prima data pe orice sistem Linux sau
UNIX, si este lansat de kernel la bootare. Acest proces, la randul lui, incarca restul sistemului
de operare. ID-ul acestui proces este intotdeauna 0.
6.1.2.Fisierele de initializare din /etc/inittab

Prima data, procesul de initializare (init) examineaza fisierul /etc/inittab pentru a
determina ce procese sa lanseze in continuare. Acest fisier de configurare specifica ce nivel de
executie sa se lanseze si descrie procesele ce trebuie rulate pe fiecare nivel . Apoi
procesul init cauta prima linie cu actiunea sysinit(system initialization) si executa fisierul de
comanda identificat in acea linie, in acest caz/etc/rc.d/rc.sysinit. Dupa executarea script-urilor
din/etc/rc.d/rc.sysinit, init incepe sa execute comenzile asociate cu nivelul de executie initial.
Urmatoarele cateva linii din /etc/inittab sunt specifice diferitelor nivele de executie.
Fiecare linie ruleaza ca un singur script (/etc/rc.d/rc), care ia un numar intre 1 si6 ca argument
pentru specificarea nivelului de executie. Cea mai folosita actiune pentru aceste nivele de
executie specifice intrarilor din /etc/inittab este wait, ceea ce inseamna ca
procesul init executa fisierul de comanda pentru un nivel de executie specific si apoi asteapta
ca acel nivel de executie sa se termine.
6.1.3.Fisierele din /etc/rc.d/rc.sysinit

Comenzile care sunt definite n intrarile de initializare a sistemului din /etc/inittab sunt
executate numai odata si numai de catre procesul init, de fiecare data cnd booteaza sistemul
de operare. n general, aceste scripturi ruleaza ca o succesiune de comenzi care realizeaza
urmatoarele:
1) Determina daca sistemul face parte dintr-o retea, n functie de continutul
fisierului /etc/sysconfig/network.
2) Monteaza /proc, sistem de fisiere folosit intern de Linux pentru a urmari starea
diverselor procese din sistem.
3) Seteaza ceasul sistemului n functie de setarile din BIOS precum si realizeaza alte
setari (setarea timpului, setarea zonei), stabilite si configurate pe parcursul instalarii Linuxului.
4) Porneste memoria virtuala a sistemului, activnd si montnd partitia swap,
identificata n fisierul /etc/fstab (File System table).
5) Seteaza numele de identificare (system's host name) pentru retea si mecanismul de
autentificare al sistemului (system wide authentication), cum ar fi NIS (the Network
Information Service,), NIS + (o versiune mbunatatita de NIS), si asa mai departe.
6) Verifica sistemul de fisiere al root-ului si daca nu sunt probleme, l monteaza.
7) Verifica celelalte sisteme de fisiere identificate n fisierul /etc/fstab.

8) Identifica, daca este cazul, rutine speciale care sunt folosite de sistemul de operare
pentru a recunoaste hardware-ul instalat, pentru a configura device-uri plug and play existente
si pentru a activa alte device-uri primare, cum ar fi placa de sunet de exemplu.
9) Verifica starea disk device-urilor specializate, cum ar fi de exemplu discurile RAID
(Redundant Array of Inexpensive Disks).
10) Monteaza toate sistemele de fisiere identificate n fisierul /etc/fstab.
11) Executa alte task-uri specifice de sistem.
6.1.4.Directorul /etc/rc.d/init.d
Directorul /etc/rc.d/init.d contine toate comenzile care pornesc si opresc serviciile
care sunt asociate cu toate nivelele de executie. Toate fisierele de comenzi din
directorul /etc/rc.d/init.d au un scurt nume care descrie serviciul cu care sunt asociate. De
exemplu, fisierul /etc/rc.d/init.d/amd porneste si opreste demonul automount, care monteaza

gazda
NFS
si
device-uri
ori
de
cate
ori
este
nevoie.
Dupa ce procesul init a executat toate comenzile, fisierele si scipturile, ultimele cateva
procese pe care le starteaza sunt procesele /sbin/mingetty care afiseaza banerul si mesajul de
log-in al distributiei pe care o aveti instalata. Sistemul este incarcat si pregatit pentru ca
utilizatorul sa faca Log-In.
6.1.5.Nivelele de executie ale Linux-ului

Nivelele de executie reprezinta modul in care opereaza computerul. Ele sunt definite
de un set de servicii disponibile intr-un sistem la orice timp dat de rulare.Nivelele de executie
reprezinta modalitati diferite pe care sistemul de operare Linux le foloseste pentru a fi
disponibil dumneavoastra ca utilizator sau ca administrator.
Ca utilizator acestea nu sunt relevante ; nivelul de executie multi-utilizator face (in
mod transparent) disponibile serviciile pe care dumneavoastra asteptati sa va fie puse la
dispozitie in momentul in care folositi Linux intr-o retea. Nivele de executie sunt :
Nivelul 0: Halt (Opreste toate procesele si executa ShutDownpentru sistemul de
operare.)
Nivelul 1: Cunoscut sub numele de "Single user mode,", sistemul ruleaza in acest caz
un set redus de daemoni. Sistemul de fisiere al root-ului este montat read-only. Acest nivel de
executie este folosit cand celelalte nivele de executie esueaza in timpul procesului de bootare.
Nivelul 2: Pe acest nivel ruleaza cele mai multe servicii, cu exceptia serviciilor de
retea (httpd, nfs, named, etc.). Acest nivel de executie este folositor pentru debug-ul serviciilor
de retea, mentinand sistemul de fisiereshared.
Nivelul 3: Mod multi-utilizator complet, cu suport pentru retea.
Nivelul 4: Nefolosit in marea majoritate a distributiilor. Pe Slackware, acest nivel de
executie 4 este echivalent cu nivelul de executie 3, cu logon grafic activat.
Nivelul 5: Mod multi-utilizator complet, cu suport pentru retea si mod grafic.
Nivelul 6: Reboot. Termina toate procesele care ruleaza si reboot-eaza sistemul la
nivelul initial de executie.
6.1.6.Modificarea nivelelor de executie

Cea mai folosita facilitate a procesului init, si poate cea mai confuza, este abilitatea de
a muta de pe un nivel de executie pe altul. Sistemul booteaza pe un nivel de executie
specificat in /etc/inittab , sau intr-un nivel de executie specificat la prompt-ul LILO. Pentru a
schimba nivelul de executie, folositi comanda init. De exemplu, pentru a schimba nivelul de
executie la 3, folositi: init 3. Aceasta oprese majoritatea serviciilor si aduce sistemul in mod
multi-utilizator cu suport pentru retea. Atentie, pentru ca in acest moment se pot inchide fortat
daemoni care sunt folositi in acel moment.
6.1.7.Directoarele nivelelor de executie

Fiecare nivel de executie are un director cu legaturi simbolice care pointeaza
scripturilor corespunzatoare din directorul init.d. Aceste directoare sunt:
/etc/rc.d/rc0.d
/etc/rc.d/rc1.d
/etc/rc.d/rc2.d
/etc/rc.d/rc3.d
/etc/rc.d/rc4.d
/etc/rc.d/rc5.d
/etc/rc.d/rc6.d
Numele legaturii simbolice gasite n aceste directoare este semnificant. El specifica
care serviciu trebuie oprit, pornit si cnd. Legaturile care ncep cu S sunt programate sa
porneasca ori de cte ori sistemul ntr-un alt nivel de executie. Pe lnga aceasta, fiecare
legatura simbolica are un numar la nceputul numelui. n continuare un exemplu de cteva
legaturi din /etc/rc.d/rc2.d :
20nfs -> ../init.d/nfs
K50inet -> ../init.d/inet
S60lpd -> ../init.d/lpd
S80sendmail -> ../init.d/sendmail
Cnd sistemul de operare schimba nivelul de executie, init compara lista cu procesele
terminate (legaturi care ncep cu K) din directorul nivelului curent de executie, cu lista
proceselor catre trebuie startate, cele care ncep cu S, aflate n directorul destinatie. Atfel se
determina care daemoni trebuie porniti sau opriti.
Exemplu:
Cnd sistemul booteaza pe nivelul 3 (run level 3) va executa toate intrarile care ncep
cu "S" n ordinea listata:
/etc/rc.d/rc3.d/S60lpd start
/etc/rc.d/rc3.d/S80sendmail start
(si asa mai departe...)
Daca sistemul se schimba pe nivelul 1 (run level 1) va executa:
/etc/rc.d/rc3.d/K20nfs stop
/etc/rc.d/rc3.d/K50inet stop
(presupunnd ca nfs si inet nu au intrari de start n /etc/rc.d/rc1.d )
Apoi va procesa toate intrarile din /etc/rc.d/rc1.d care n acel moment nu ruleaza. n
acest exemplu este numai una singura:
/etc/rc.d/rc1.d/S00single
6.1.8.Schimbarea nivelului curent de executie

Pentru a schimba nivelul de executie curent de xemplu pe nivelul 3, editati fisierul
/etc/inittab ntr-un editor de texte, si editati urmatoarea linie:
id:3:initdefault:
( Nu stabiliti nivelul de executie initial la 0 sau 6 )
6.1.9.Eliminarea unui serviciu dintr-un nivel de executie

Pentru a dezactiva un serviciu de pe un nivel de executie, puteti simplu sterge sau
modifica legatura sa simbolica din directorul nivelului de executie de care apartine.De
exemplu, pentru a dezactiva pcmcia si a nu mai porni pe nivelul 3 de executie, veti scrie:
rm /etc/rc.d/rc3.d/S45pcmcia
6.1.10.Adaugarea de servicii unui nivel de executie

Pentru a adauga un serviciu unui nivel de executie, este nevoie sa se creeze o legatura
simbolica care sa pointeze catre scripturile de servicii din directorul init.d. n momentul n
care se creaza legatura, aveti grija sa-i asignati un numar astfel nct serviciul sa fie pornit la
timpul potrivit.Pentru a adauga "lpd" la run level 3 (nivelul 3 de executie), veti folosi:
ln -s /etc/rc.d/init.d/lpd /etc/rc.d/rc3.d/S64lpd
6.2. Procesul de bootare Windows

6.2.1.Windows 1.x/2.x
Incepand cu versiunea de Windows 1.01 pana la Windows/386 , sistemul de operare
era incarcat atunci cand fisierul WIN.COM era executat . Apoi acesta incarca
win100.bin/win200.bin si win100.ovl/win200.ovl , impreuna cu fisierul de setari WIN.INI .
Modulele GDI.EXE , KERNEL.EXE si USER.EXE , fonturile precum si driverele unor
dispozitive (cum ar fii summ.drv , mouse.drv , keyboard.drv) sunt incorporate in
win100.bin/win200.bin si win100.ovl/win200.ovl .
6.2.2.Windows 3.x/9x
In Windows 3.x si 95/98/ME faza de boot este prelucrata de MS DOS . In timpul
pornirii , fisierele Autoexec.bat si Config.sys sunt executate , impreuna cu fisierele de
configurare WIN.INI si SYSTEM.INI .
Cand toate fisierele de configurare si toate driverele dispozitivelor au fost incarcate ,
modulele de 16 biti krnl386.exe , gdi.exe si user.exe sunt incarcate si apoi sunt incarcate
DLL-urile pe 32 biti (kernel32.dll , gdi32.dll si user32.dll) . Serverul de mesaje pe 32 bit VxD
(Msgsvr32) lanseaza in executie Mprexe.exe care este responsabil cu incarcarea clientului de
login pe retea . Cand un utilizator se logheaza in Windows , sunetul de inceput este lansat ,
Explorer.exe este incarcat din sectiunea de boot a fisierului SYSTEM.INI si elementele de start
sunt incarcate .
In toate versiunile de Windows bazate pe DOS (exceptie face Windows ME) este de
asemenea posibil incarcarea sistemului de operare prin scrierea win intr-un prompt de
DOS . Exista o serie de comenzi care pot fi folosite impreuna cu comanda win cum ar fii :
/d switch (sistemul de operare porneste in modul Safe mode) sau /d:m switch(sistemul de
operare porneste in modul Safe mode folosind putand insa folosi si reteaua) .
6.2.3.Windows NT/2000/XP/Server 2003

Similar cu Linux, Windows face un test primar (POST Power On Self Test) prin care
se testeaza diversele componente hardware existente in sistem. Dupa aceea, sistemul va rula
POST pentru toate componentele care au un BIOS (Basic Input-Output System). Atunci cand
se finalizeaza POST si BIOS-ul este sigur ca totul funcioneaza cum trebuie, BIOS-ul va
incerca sa citeasca din MBR (Master Boot Record).
Acesta este primul sector al primului hard drive (denumit Master sau HD0). Cand
MBR preia controlul inseamna ca sistemul de operare Windows este in control.
MBR cauta in BOOT SECTOR (primul sector al unei partitii active). Aici se
localizeaza NTLDR (BOOT LOADER pentru Windows XP). NTLDR va permite adresarea
memoriei, initializarea sistemului de fisiere (file system), ca citi fisierul boot.ini si va incarca
meniul de boot-are.
Un fisier NTLDR, localizat in directorul radacina al discului de boot, este compus din
2 parti. Prima este modulul de StartUp, urmata imediat de OS loader (osloader.exe), ambele
stocate in acel fisier. Cand NTLDR este incarcat in memorie si controlul este transmis pentru
prima oara modulului de StartUp, procesorul opereaza in modul real. Principala functie a
modulului de StartUp este sa comute procesorul in modul protected, fapt ce faciliteaza accesul
memoriei pe 32 de biti, permitandu-i sa creeze tabelul descriptorilor de intrerupere, tabelul
descriptorilor globali (GDT), tabele de pagini si activarea paginarii. Acestea furnizeaza
mediul de operare de baza pe care sistemul de operare se va construi. Modul StartUp apoi va
incarca si lansa OS loader.
OS loader include functiile de baza pentru a accesa discurile IDE formatate pentru
sistemele NTFS sau FAT, sau CDFS (ISO 9660), ETFS sau UDFS in versiunile noi de sisteme
de operare. Discurile sunt accesate prin sistemul BIOS. Din acest moment, toate apelurile
acestuia sunt facute prin modul 8086 virtual, intrucat BIOS-ul nu poate fi accesat direct in
modul protected. Boot loader-ul citeste apoi continutul fisierului boot.ini pentru a localiza
informatia pe system volume. Daca fisierul respectiv lipseste, boot loader-ul ca incerca sa
localizeze informatia din directorul standard de instalare.
In acest moment, ecranul este eliberat, si in Windows 2000 sau in versiunile mai tarzii
ale lui NTLDR si IA62ldr care suporta system hibernation, default volume din directorul
radacina, asa cum e definit in boot.ini este cautat pentru un fisier de hibernare, hiberfil.sys.
Daca fisierul e gasit si o memorie activa setata este gasita in el, continutul fisierului este
incarcat in memorie iar transferul este transferat catre Windows kernel intr-un punct in care
hibernarea poate fi reluata. Fisierul e apoi imediat marcat ca non-activ.
Daca boot.ini contine mai mult de o intrare a unui sistem de operare, un meniu de boot
este afisat userului, permitand acestuia sa aleaga ce sistem de operare este incarcat. Daca un
sistem de operare care nu e bazat pe NT, cum ar fi Windows 98, este selectat, atunci NTLDR
incarca fisierul boot sector asociat listat in boot.ini si paseaza controlul executiei acestuia.
Daca un SO bazat pe NT este selectat, NTLDR ruleaza ntdetect.com, care aduna informatia de
baza despre componentele computerului raportate de BIOS.
In acest moment, NTLDR elibereaza ecranul si afiseaza o bara de progres (care
deseori nu este vazuta pe sistemele XP sau 2003 datorita vitezei lor de initializare). Daca
utilizatorul apasa F8 in acest moment, este afisat meniul avansat de boot, care contine diferite
moduri speciale de boot, incluzand Safe mode. Dupa ce se selecteaza optiunea dorita,
bootarea continua. Sistemul porneste in modul 16-bit real si apoi trece in modul 32-bit
protected. Daca o versiune x64 de Windows este bootata, procesorul este setat in long mode,
activand adresarea pe 64 de biti. Apoi Windows kernel Ntoskrnl.exe si Hardware Abstraction
Layer hal.dll sunt incarcate in memorie. Daca vreunul din ele nu se poate incarca, va aparea
mesajul message "Windows could not start because the following file was missing or corrupt"
si procesul de bootare se opreste.
Odata ce se incarca kernel in memorie, sunt incarcate driverele dispozitivelor boottime. Aceasta informatie este stocata in portiunea de registru HKLM\SYSTEM, intr-un set de
chei de registru numite colectiv, Control Set. Cand un Control Set e ales, cheia Current se
seteaza dupa caz. Cheia Failed este de asemenea setata precum Current pana la sfarsitul
procesului de bootare. LastKnownGood este de asemenea setata la Current daca procesul de
bootare se termina cu succes.
In scopul bootarii, un driver este fie un driver Boot, care este incarcat de NTLDR
sau IA64ldr inainte de startarea kernel-ului si inceput inainte de driverele de sistem de catre
kernel, fie un driver System, care e incarcat atunci cand porneste ntoskrnl.exe dupa
driverele boot, fie un driver Automatic, care e incarcat mult mai tarziu, cand GUI deja a
inceput. Driverele Boot sunt aporape exclusiv drivere pentru controllere hard-drive si file
systems, cu alte cuvinte, sunt minimul necesar pe care ntoskrnl.exe va fi nevoit sa porneasca
cu incarcarea altor drivere, si restul sistmului de operare. Drivelere System acopera o gama
mai larga de functionalitati nucleu, incluzand driverul de display, suport CD-ROM si stiva
TCP/IP.
In final, controlul este transmis de NTLDR sau IA64ldr catre kernel. In acest moment,
Windows NT afiseaza celebrul ecran albastru ce afiseaza numarul de procesoare si cantitatea
de memoria instalata, in timp ce Windows 2000, XP si 2003 trec intr-un mod de display grafic
pentru a afisa logo-ul Windows, in cazul in care in boot.ini nu sunt prezente /noguiboot sau
/sos. Porneste WINLOGON.EXE care la randul sau porneste LSASS.EXE, acesta este
programul care afiseaza ecranul Logon astfel incat userul se poate loga.
6.2.4.Windows Vista/Server 2008/Windows 7
Secventa de pornire a Windows Vista , Windows Server 2008 sau Windows 7 difera
fata de versiunile anterioare de Windows care folosesc kernel-ul de NT . In prima faza , cand
computerul este aprins , fie BIOS-ul sau EFI-ul sunt incarcate . In cazul unui sistem BIOS ,
MBR-ul boot disk-ului , care pot fie un hard drive sau un dispozitiv de stocare externa este
accesat , urmat de sectorul de boot al drive-ului . Sectorul de boot apoi incarca restul
blocurilor de boot . Pentru Windows Vista , sectoru de boot incarca Windows Boot Managerul (BOOTMGR) care prima data cauta o partitie activa , apoi acceseaza configuratia de date
de boot si foloseste informatia sa incarce ultimul lucru si anume sistem de operare .
Windows Boot Manager-ul (BOOTMGR) citeste configuratia de boot si afiseaza
meniul de selectare a sistemului de operare si este intr-o oarecare masura echivalentul functiei
de selectare a meniu de boot a NTLDR ce se gaseste in cadrul versiunilor de windows bazate
pe kernelul de NT . O schimbare notabila este aceea ca Windows Boot Manager-ul este apelat
prin apasarea space bar-ului in locul taster F8 . Aceasta din urma ramane in continuare
asociata pentru optiunile avansate de boot indata ce apare Windows Boot Manager-ul . Pentru
a mentine o consistenta a procesului de boot in cadrul sistemelor EFI care de asemenea au un
boot manager al lor , Windows Boot Manager-ul , asadar dintre toate sistemele de operare
Windows care pot fi bootate folosindu-l , apar ca o singura aparitie in meniu de boot al EFIului .
Configuratie de pornire (Boot Configuration Data) este o baza de date independenta
de firmware pentru datele din timpul procesului de pornire a sistemului de operare .
Inlocuieste fisierul boot.ini ce era folosit de NTLDR si este folosit si de noul Windows Boot
Manager al Windows-ului . Configuratia de pornire este stocata intr-un fisier care este aflat
fie in partitia de sistem EFI in cadrul masinilor ce folosesc EFI sau in \Boot\Bcd locat in
partitia sistem in cadrul masinilor IBM PC .
Configuratia de boot contine optiunile disponibile ce sunt prezentate de Windows Boot
Manager , la fel cum boot.ini continea optiunile ce erau prezentate de NTLDR . Aceste
optiuni pot contine :
optiunea de bootare a Windows Vista prin apelarea winload.exe

optiunea de revenire a Windows Vista din hibernare prin apelarea
winresume.exe
optiunea de boot-are a unei versiuni anterioare de Windows din familia NT
prin apelarea NTLDR .
In final , Windows Boot Manager-ul apeleaza winload.exe care reprezinta un boot

loader al sistemului de operare , pentru a incarca kernelul sistemului de operare ntoskrnl.exe si
diverele dispozitivelor . In acest fel winload.exe este functional , echivalentul NTLDR-ului
din versiunile anterioare de Windows bazate pe kernelul de NT .

Procese Si Fire de Executie-Tema5

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Procese Si Fire de Executie-Tema5

Încărcat de

Drepturi de autor:

Formate disponibile

ETTI-SO

Capitolul 1: Concepte fundamentale- Rata Bogdan(431A)

4.1.11. Depanarea unui proces................................................................................30

5.1 Notiuni DOS.................................................................................................... 37

Capitolul 1: Concepte fundamentale- Rata Bogdan(431A)

1.3.Functionalitatea unui fir de executie

Informatii relative la paginile de memorie alocate.

simbolice definite in bibliotecile sistemului de operare. Standardul POSIX.1 defineste cateva

Capitolul 2 Apelurile de sistem de gestiune a proceselor

2.1.Sistemul de operare Linux

Sistemul de operare Linux cuprinde in principal 3 componente majore:

Modern operating systems,Andrew S. Tanenbaum,third edition;

Functiile Kernel-ului sunt:3

Modern operating systems,Andrew S. Tanenbaum,third edition;

Modern operating systems,Andrew S. Tanenbaum,third edition;

running - instructiunile sale sunt executate de catre procesor in momentul respectiv;

Primii pasi in Linux,Sabin Buraga, Dragos Acostachioaie, Marius Marusteri;

Primii pasi in Linux,Sabin Buraga, Dragos Acostachioaie, Marius Marusteri;

Primii pasi in Linux,Sabin Buraga, Dragos Acostachioaie, Marius Marusteri;

sistemul de gestiune a fisierelor;

Modern operating systems,Andrew S. Tanenbaum,third edition;

Modern operating systems,Andrew S. Tanenbaum,third edition;

2.1.5.Crearea unui proces

2.1.6.Comenzi pentru gestiunea proceselor UNIX Linux

Capitolul 3: Apelurile API pentru gestionarea job-urilor si

3.1 Ce este un API?

3.2 WINDOWS API

EnumProcesses aceasta functie completeaza un vector de valori DWORD

OpenProcess folosit pentru a deschide un proces local existent in sistem. Are

3.3 LINUX Kernell API

fork() va crea un nou process subordonat procesului parinte identic cu acesta

execve executa un proces intr-un mediu asignat

David A Rusling, The Linux Kernel, 1999, carte disponibil gratuit la

In reprezentarea sub forma de tabel,fiecarui proces ii este asociat un identificator de

David A Rusling, The Linux Kernel, 1999

La pornirea sistemului in modul nucleu,exista un singur proces initial parinte.

Daca dorim sa rezolvam o problema care se preteaza la o implementare cu mai multe

-functia intoarce in procesul tata PID-ul(process identifier) procesului nou creat;

E. Raymond The Art of Unix Programming Addison-Wesley, 2003

4.1.5. nlocuirea imaginii unui proces

Vicki Stanfield, R. Smith Administrarea Sistemului Linux Teora 2004

S. Sinchack Hacking Windows XP e-book

A. Tanenbaum Modern Operating Systems e-book

Vicki Stanfield, R. Smith Administrarea Sistemului Linux Teora 2004

Wikipedia free on-line encyclopedia www.wikipedia.com

Starea curenta a procesorului descrisa de valorile din registri(contextul);

procedura apelata la executie seteaza prioritatea firului de executie.Se repeta pasul

Andrew S. Tanenbaum, Sisteme de operare moderne, Byblos, 2004;

4) lpStartupInfo un pointer la structura Startup Info.

Microsoft Developer Network www.msdn.com

Return code/value Description

Microsoft Developer Network www.msdn.com

Microsoft Developer Network www.msdn.com

Capitolul 5. Emularea programelor MS DOS- Adriana

5.1 Notiuni DOS

Sistemele DOS includ MS-DOS, PC-DOS, DR-DOS, FreeDos, PTS-DOS, ROM-DOS,

5.2 Definitie emulatoare

eueaz, acesta va avea o influen asupra funcionrii computerului i prin urmare a

5.3 Emulatoare MS-DOS

Emulatoarele DOS ctig popularitate printre utilizatorii Windows XP i Windows Vista,

5.4 Exemple de emulatoare MS-DOS

Capitolul 6 : Procesul de bootare a sistemului de

6.1.Bootarea sistemului de operare Linux