ETTI-SO

11

PROCESE SI FIRE DE EXECUTIE

Proiect SOAutori: Dobroiu Madalina 431A;Fratila Dragos Sorin 433A;Petrache Victor 431A;Petrescu Mihai Cristian 433A;Rață Bogdan 431A; Stoian Adriana 431A

Cuprins

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

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.Afişa unui copac de procese................................................................................................26

4.1.5. Înlocuirea imaginii unui proces..........................................................................................27

4.1.6.Aşteptarea terminării unui proces........................................................................................27

4.1.7.Terminarea unui proces.......................................................................................................29

4.1.8.Copierea descriptorilor de fişier...........................................................................................29

4.1.9.Moştenirea descriptorilor de fişier după operaţii 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.Aşteptarea terminării 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 kernel-ului, 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 conceptualprelucrarii 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 fisierec) 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 „Modern operating systems”,Andrew S. Tanenbaum,third edition;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 periferice4. gestionarea memoriei prin alocarea si eliberarea memoriei principale pentru procesele

aflate in executie.5. Administreaza functii precum: spatiul Swap, Demoni, si Sistemele de Fisiere.

4

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 „Modern operating systems”,Andrew S. Tanenbaum,third edition;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, procesorul executa un timp instructiunile unuia dintre procese, apoi sistemul de operare va 5 „Modern operating systems”,Andrew S. Tanenbaum,third edition;6 „Modern operating systems”,Andrew S. Tanenbaum,third edition;7 „Modern operating systems”,Andrew S. Tanenbaum,third edition;

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

sistemul de gestiune a fisierelor; sistemul de gestiune a proceselor.

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

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

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

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 unui dulap. Sistemul de fisiere este dulapul, directoarele sunt asemenea sertarelor, subdirectoarele asemenea dosarelor isr fisierele pot fi asemanate u foile prinse in dosar.

11 „Modern operating systems”,Andrew S. Tanenbaum,third edition;

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 parcursul timpului (pina la oprirea calculatorului). Celelalte procese sunt create cu ajutorul functiei sistem fork.14

12 „Modern operating systems”,Andrew S. Tanenbaum,third edition;13 http://www.scribd.com/doc/11400920/sisteme-de-operare14 http://www.scribd.com/doc/11400920/sisteme-de-operare

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.

15 http://tldp.org/LDP/intro-linux/html/sect_04_03.html16 http://polishlinux.org/console/managing-processes-in-linux/

17 http://polishlinux.org/console/managing-processes-in-linux/

18 http://polishlinux.org/console/managing-processes-in-linux/

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 http://www.scribd.com/doc/11400920/sisteme-de-operare20 http://articles.techrepublic.com.com/5100-10878_11-5025322.html21 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 http://articles.techrepublic.com.com/5100-10878_11-5025322.html23 http://www.scribd.com/doc/11400920/sisteme-de-operare

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 API-urile 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:

EnumProcesses – aceasta functie completeaza un vector de valori DWORD cu identificatorii tuturor proceselor din sistem, pe scurt face enumerarea tuturor proceselor active din sistem.

24 http://en.wikipedia.org/wiki/Application_programming_interface25 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 :

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 execve – executa un proces intr-un mediu asignat

26 http://msdn.microsoft.com/en-us/library/ms684847%28v=VS.85%29.aspx#process_functions

Datorita faptului ca LINUX este un sistem aflat in continua dezvoltare, aceasta lista de API-uri 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 Windows- Madalina Dobroiu(431A)

Toate sistemele de operate moderne se bazează pe nişte concepte de bază precum procesele, memoria, fişierele 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 aplicaţii cât mai eficiente, care utilizează corect toate resursele sistemului de calcul, de preferinţă portabile de pe un sistem de operare pe altul.

Cea mai simpla definiţie a unui proces este: Un proces este un program aflat în curs de execuţie.

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 situaţiile de impas etc. Pentru a realiza aplicaţii, programatorul se va folosii de aceste funcţii ale sistemului de operare. Problema este ca sistemele de operare abordează diferit aceste funcţii, fiecare abordare având 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. Părerile despre aceste două feluri de sisteme diferă, unii spunând 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 alţii pretind că sistemele Windows au un avantaj deoarece sunt mai uşor de folosit. În timp diferenţele între aceste două sisteme s-au micşorat.

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-on-write).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.

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

28 David A Rusling, The Linux Kernel, 1999, carte disponibilă gratuit laadresa: http://tldp.org/LDP/tlk/tlk.html

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 fiintreruptibile(pot fi oprite cu anumite semnale de oprire) si neintreruptibile(functionarea lor esteconditionata 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 http://ebooks.unibuc.ro/informatica/Seiso/4.2_files/text.htm31 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 eroriibreak; 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 funcţiei de bibliotecă system : int system(const char*command); Apelarea acestei funcţii are ca efect execuţia 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 părintele aşteaptă terminarea procesului copil. 32

4.1.4.Afişa unui copac de procese pstree arată procesele care rulează ca un copac. Copacul este înrădăcinată fie la pid sau la iniţializare dacă PID este omis. În cazul în care un nume de utilizator este specificat, toate procesele copaci deţinute de utilizator sunt afişate.

$ pstree

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

4.1.5. Înlocuirea imaginii unui proces

Familia de funcţii exec execută un nou program în care inlocuiesc imaginea procesului curent cu cea dintr-un fişier (executabil). Spaţiul de adrese este înlocuit de unul nou special creat pentru execuţia fişierului. De asemenea, vor fi reinitializaţi regiştrii hardware ai procesorului IP (EIP/RIP) şi SP (ESP/RSP) şi regiştrii generali. Vor fi setate la valorile implicite măstile de semnale ignorate şi blocate, ca şi handler-ele semnalelor. PID-ul şi descriptorii fişierelor ce nu au setat flagul CLOSE_ON_EXEC vor rămâne neschimbaţi (deoarece implicit flagul CLOSE_ON_EXEC nu este setat). 33

int execv(const char *filename, char *const argv[]); EXECV execută programul descris de pointerul către şirul de caractere filename; vectorul argv e format din pointeri către ş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 funcţiei. 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 primeşte 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 primeşte 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 asemănătoare cu execv, dar calea programului nu mai trebuie să fie absolută pentru că va fi căutat în toate directoarele specificate de variabila de mediu PATH. int execlp(const char *filename, const char *arg0, ...); EXECLP este asemănătoare cu execl, dar calea programului nu mai trebuie să fie absolută pentru că va fi căutat în toate directoarele specificate de variabila de mediu PATH. Daca se foloseşte orice funcţie din familia exec, atunci este necesară includerea headerului unistd.h. 34

4.1.6.Aşteptarea terminării unui proces Familia de funcţii wait suspendă execuţia procesului apelant până când 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 Vicki Stanfield, R. Smith – Administrarea Sistemului Linux – Teora 200434 E. Raymond – The Art of Unix Programming – Addison-Wesley, 2003

Procesul apelant va fi blocat până când procesul cu PID-ul pid se va termina sau va fi oprit şi el la rândul 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

careface parte procesul apelant;

-1 (WAIT_ANY) orice proces copil. Parametrul options poate fi setat cu unul sau mai multe din următoarele flaguri (combinate prin SAU pe biţi):

WNOHANG – dacă nici unul din procesele specificate nu este terminat, se va ieşi imediat

din apelul waitpid (procesul care apelase waitpid nu se blochează); WUNTRACED – waitpid se întoarce şi dacă unul dintre procesele specificate s-a

oprit, iarinformaţiile 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 “urmărite” de procesul apelant; informaţiile despre copii “urmăriţi” suntfurnizate chiar dacă acest flag nu este precizat.35

Funcţia va întoarce PID-ul procesului a cărui stare este raportată; informaţiile de stare sunt depuse în locaţia către care indică status. Funcţia 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 puţin atunci când este setat WNOHANG, caz în care funcţia întoarce 0. Atunci când 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 următoarele macrodefiniţii:

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 s-a terminat datorită unui semnal netratat

WTERMSIG(status), dacă WIFSIGNALED(status) e diferit de 0, arată numărul semnalului datorită căruia 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 numărul semnalului care a oprit procesul

ObservaţieAceste macrodefiniţii primesc ca argument buffer-ul în care se află informaţia de stare (adică un int), şi nu un pointer către acest buffer. pid_t wait(int *status);

35 S. Sinchack – Hacking Windows XP – e-book

Varianta simplificată care aşteaptă 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 dispoziţie apelul de sistem exit (al cărui antet este descris în stdlib.h). void exit(int status);Procesul apelant va fi terminat imediat. Toţi descriptorii de fişier ai procesului sunt închişi, copii procesului sunt “infiaţi” de procesul init, iar părintelui procesului îi va fi trimis un semnal SIGCHLD. Procesului părinte îi va fi întoarsă variabila status ca rezultat al unei funcţii de aşteptare (wait sau waitpid).Pentru terminarea unui alt proces din sistem, se va trimite un semnal către procesul respectiv prin intermediul apelului de sistem kill.[4]

4.1.8.Copierea descriptorilor de fişier int dup(int oldfd); Duplică descriptorul de fişier oldfd şi întoarce noul descriptor de fişier sau -1 în caz de eroare. int dup2(int oldfd, int newfd); Duplică descriptorul de fişier oldfd în descriptorul de fişier newfd; dacă newfd există, mai întâi va fi închis fişierul asociat. Întoarce noul descriptor de fişier sau -1 în caz de eroare. Descriptorii de fişier sunt de fapt un index în tabela de fişiere deschise, ce conţine pointeri către o structură ce conţine informaţii despre fişier. Duplicarea unui descriptor de fişier înseamnă duplicarea intrării din tabela de fişiere deschise (adica un pointer). Din acest motiv, toate informaţiile asociate unui fişier (lock-uri, poziţia în fişier, flagurile) sunt partajate de cei doi file descriptori. Ceea ce înseamnă că operaţiile ce modifică aceste informaţii pe unul din file descriptori (de ex. lseek) sunt vizibile şi pentru celălat file descriptor (duplicat) şi invers.

Observatie: Există şi o excepţie: flagul CLOSE_ON_EXEC nu este partajat (acest flag nu este ţinut în structura menţionată mai sus).Pentru a putea folosi dup şi dup2 trebuie inclus header-ul unistd.h. [8]

4.1.9.Moştenirea descriptorilor de fişier după operaţii fork/exec

Descriptorii de fişier ai procesului părinte se moştenesc în procesul copil în urma apelului fork. După un apel exec descriptorii de fişier sunt păstraţi de asemenea, mai puţin aceia dintre ei care au setat flagul CLOSE_ON_EXEC.Pentru a seta flagul CLOSE_ON_EXEC se foloseşte funcţia fcntl cu un apel de genul: fcntl(file_descriptor, F_SETFD, FD_CLOEXEC);

Pentru a putea folosi funcţia fcntl trebuie incluse header-ele unistd.h şi fcntl.h.Trei dintre descriptorii de fişier sunt mai importanţi:

36 A. Tanenbaum – Modern Operating Systems – e-book

STDIN_FILENO toate programele obişnuite conţin 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 obişnuite au acest file descriptor care are valoarea 1; el reprezintă ieşirea standard; toate apelurile de genul printf vor genera output la terminal STDERR_FILENOtoate programele obişnuite au acest file descriptor care are valoarea 2; el reprezintă ieşirea standard de eroare.37

4.1.10. Variabile de mediu char **environ;Un vector de pointeri la şiruri de caractere, ce conţin 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, acţiunea 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 când un proces realizează o operaţie fork(). Atunci când programul este pornit, depanarea are loc exclusiv în procesul iniţial, procesele copii nefiind ataşate debugger-ului. În acest caz, singura soluţie este introducerea unor întârzieri în executia procesului nou creat (de exemplu, prin apelul de sistem sleep()), care să ofere programatorului suficient timp pentru a ataşa manual gdb-ul la respectivul proces, presupunând că i-a aflat PID-ul în prealabil. Pentru a ataşa debugger-ul la un proces deja existent, se foloseşte comanda attach, în felul următor: (gdb) attach PID Această metodă este destul de incomodă şi poate cauza chiar o funcţionare anormală a aplicaţiei depanate, în cazul în care necesităţile de sincronizare între procese sunt stricte (de exemplu operaţii cu time-out). Din fericire, pe un număr 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ă urmărească activitatea proceselor create ulterior, se poate folosi comanda set followfork-mode, în felul următor: (gdb) set follow-fork-mode modeunde mode poate lua valoarea parent, caz în care debugger-ul continuă depanarea procesului părinte, sau valoarea child, şi atunci noul proces creat va fi depanat în continuare. Se poate observa că în această manieră debugger-ul este ataşat la un moment dat doar la un singur proces, neputând urmări mai multe simultan.

37 Vicki Stanfield, R. Smith – Administrarea Sistemului Linux – Teora 200438 S. Sinchack – Hacking Windows XP – e-book

Cu toate acestea, gdb poate ţine evidenţa tuturor proceselor create de către programul depanat, deşi î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 modeunde mode poate fi on, atunci când gdb se va ataşa unui singur proces la un moment dat (comportament implicit), sau off, caz în care gdb se ataşează la toate procesele create în timpul execuţiei, şi le suspendă pe acelea care nu sunt urmărite, în funcţie de valoarea setării followfork-mode. Comanda info forks afişează informaţii legate de toate procesele aflate sub controlul gdb la un moment dat: (gdb) info forksDe asemenea, comanda fork poate fi utilizată pentru a seta unul din procesele din listă drept cel activ (care este urmărit de debugger). (gdb) fork fork-idunde fork-id este identificatorul asociat procesului, aşa cum apare în lista afişată de comanda info forks.Atunci când un anumit proces nu mai trebuie urmărit, el poate fi înlaturat din listă folosind comenzile detach fork şi delete fork: (gdb) detach fork fork-id (gdb) delete fork fork-idDiferenţa 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 ocupând în jur de 73% din piaţa sistemelor de operare. Asta însemnând că şi majoritatea programelor sunt scrise în aşa fel încât 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

Starea curenta a procesorului descrisa de valorile din registri(contextul); Doua stive fiecare petru executia intr-unul din cele doua moduri : utilizator sau nucleu;

39 Wikipedia free on-line encyclopedia – www.wikipedia.com40 Russinovich, M. E. and Solomon, D.A. Microsoft Windows Internals, 4thEdition, Microsoft Press, 2005 (face parte din Windows Research Kernel)

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 procesulparinte).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.

procedura apelata la executie seteaza prioritatea firului de executie.Se repeta pasul pentru toate firele de executie.Incepe rualrea codului principal al procesului. 42

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

Sistemul de operare poate crea procese sau poate desfiinţa procese.În timpul execuţiei, un proces poate crea unul sau mai multe procese noi. Procesele create sunt numite ”copii” iar procesul care le creaza este numit ”părinte”. Procesul nou creat are şi el nevoie de resurse, pe care le ia direct de la sistemul de operare sau de la procesul ”părinte”. Procesul ”părinte” poate aloca spre utilizare numai o parte a resurselor, cum ar fi memoria sau fişierele, prevenind astfel supraîncărcarea sistemului din cauza creării prea multor procese ”copii”. 43

Funcţia 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 foloseşte funcţia CreateProcessAsUser sau funcţia 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 aplicaţie 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 spaţiu, la sfârşitul şi la începutuluiargumentului.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 funcţii, “CreateProcessWithLogonW “ poate modifica conţinutul acestui şir.Drept urmare aceşti parametrii nu pot fi pointeri lamemoria “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 moştenit la noul proces provenit din acesta. Dacă acest paramentru este NULL atunci rezultatul returnat de process nu poate fi moştenit.4) lpStartupInfo – un pointer la structura “ Startup Info“.5) “ lpProcessInformation ”- un pointer la structura “ProcessInformation ” care primeşte informaţii identificatoare despre noul process.6) “ lpCurrentDirectory ” Calea către directorul curent pentru proces. Dacă parametrul este NULL atunci noul proces va avea acelaşi director şi drive ca şi procesul apelat.

43 A. Tanenbaum – Modern Operating Systems – e-book

7) “ lpEnvironment” – un pointer către mediul alocat pentru procesul nou format. Daca parametrul este NULL, noul proces foloseşte mediul vechiului proces. Daca funcţia compilează atunci răspunsul va fi o valoare diferită de 0, dacă are eroare atunci întoarce 0. 44

8) lpThereadAttributes– Un pointer către o structură de tipul SECURITY_ATTRIBUTES care determină dacă descriptorul către noul thread poate fi moştenit de procese fiu. Dacă parametrul este NULL descriptorul nu poate fi moştenit.9) bInheritHandles – Dacă parametrul este TRUE orice descriptor care poate fi moştenit va fi moştenit de procesul fiu. Dacă este FALSE descriptorii nu vor fi moşteniţi.10) dwCreationFlags – Acest parametru controlează clasa de priorităţi a procesului şi crearea acestuia.

Funcţia CloseHandle-Închide un descriptor deschis.Sintaxa:BOOL WINAPI CloseHandle(__in HANDLE hObject);Funcţia nu are parametrii. Dacă funcţia compliează, valoarea întoarsă este diferită de 0, dacă nu, este 0. Funcţia CloseHandle închide descriptor către 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.Aşteptarea terminării unui procesFuncţia WaitForInputIdle-Aşteaptă până când procesul specificat aşteaptă iniţializarea userului sau până când intervalul alocat s-a scurs.Sintaxa:DWORD WINAPI WaitForInputIdle(__in HANDLE hProcess,__in DWORD dwMilliseconds);Parametrii: hProcess un descriptor către proces. Dacă procesul este o aplicaţie de consolă sau nu are un mesaj prestabilit atunci funcţia raspunde imediat. Return code/value Description 0 wait s-a terminat cu succesWAIT_TIMEOUT wait s-a terminat deoarece time-slotul s-a terminatWAIT_FAILED o eroare a avut loc. 46

44 Microsoft Developer Network – www.msdn.com45 Microsoft Developer Network – www.msdn.com46 Microsoft Developer Network – www.msdn.com

4.2.4.Terminarea unui proces

Terminarea unui proces poate fi: Terminare normala cand un proces se termină după executarea ultimei sale

instrucţiuni; Terminare forţată când procesul se încheie înainte de parcurgerea tuturor

instrucţiunilor sale. Când ”copilul” a depăşit limita de folosire a resurselor care i-au fost alocate sau nu mai este util din punct de vedere al funcţiei pe care o realiza, procesul ”părinte” poate cere încheierea forţată a execuţiei sale. Un proces independent este un proces a cărui execuţie nu poate afecta sau nu poate fi afectată de execuţia altor procese din sistem.47

Funcţia TerminateProcess-Închide procesul specificat precum şi toate procesele deschise de acesta.Sintaxa:BOOL WINAPI TerminateProcess(__in HANDLE hProcess,__in UINT uExitCode);Parametrii : hProcess un descripor către procesul ce trebuie terminat. Acesta trebuie să aibă accesul corespunzător. uExitCode codul de ieşire ce va fi utilizat de către procesul care va fi închis ca rezultat al acestei comenzi. Foloseşte funcţia GetExitCodeProcess pentru a găsii această valoare. Valoarea returnată este diferită de 0 dacă funcţia compilează, dacă nu ea este 0. [10]

Funcţia GetExitCodeProcess-Întoarce valoarea de sfarşit a procesului terminat.Sintaxa:BOOL WINAPI GetExitCodeProcess(__in HANDLE hProcess,__out LPDWORD lpExitCode);Parametrii: hProcess- un descriptor pentru proces. Acesta trebuie să aibă accesul corespunzator. lpExitCode- Un pointer către o variabilă prin care primeşte valoarea de sfârşit a procesului terminat. Dacă procesul specificat încă nu a fost terminat şi functia compilează, atunci valoare returnată este STILL_ACTIVE. În rest, dacă funcţia compilează valoarea este diferită de 0, daca nu, este 0.48

4.2.5.Variabile de mediu

Funcţia GetEnvironmentStrings-Întoarce variabilele mediului corespunzător pentru procesul curent.

47 A. Tanenbaum – Modern Operating Systems – e-book48 T. Ionescu, Florentina Mocrienco – Structura si Functionarea Sistemelor de Calcul – e-book

Sintaxa:LPTCH WINAPI GetEnvironmentStrings(void);Daca funcţia compilează atunci răspunsul este un pointer către environment block al procesului curet, dacă nu atunci răspunsul este NULL.49

Capitolul 5. Emularea programelor MS – DOS- Adriana Stoian(431A)

5.1 Notiuni DOS

49 Microsoft Developer Network – www.msdn.com

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 utilizării comune, niciunul dintre acestea sisteme nu a fost pur şi simplu numit "DOS". Un număr de sisteme de operare microcalculator non-x86 independente au avut "DOS" în numele lor, şi sunt adesea denumite simplu "DOS" atunci când 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 acelaşi timp multe dintre funcţiile acelaşi 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 eşuează, acesta va avea o influenţă asupra funcţionării computerului şi prin urmare a capacităţilor sale. Aşa cum fiecare dispozitiv hardware în cele din urmă va inceta sa fuctioneze, accesibilitatea la obiectele digitale este în joc. Emularea oferă o soluţie 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 maşină de Linux-nativ virtual pentru rularea programelor DOS la viteza de aproape native.

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

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 câştigă 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 aplicaţii DOS sub Microsoft Virtual PC, care permit o compatibilitate mai bună decât emulatoarele DOS. O versiune legitimă a MS-DOS poate fi instalata, care ar trebui să permită tuturor, cu exceptia aplicaţiilor celor mai încăpăţânate să ruleze.

5.4 Exemple de emulatoare MS-DOS1. 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 (menţionate la frecvent ca "DOS") ar trebui să ruleze în DOSBox dar accentul a fost pus pe obtinerea de rularii jocurilor DOS fără 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 găsesc în MS-DOS dar este suficient pentru instalarea şi rularea celor mai multe jocuri DOS52. Aplicaţia creează fereastra care arata precum consola obişnuită, cu exceptia faptului ca mediul este complet virtualizat.

Acest lucru îi permite sa emuleze o gamă largă de hardware-uri moştenite ş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 conţine sau necesită fişiere reale DOS, astfel încât poate fi utilizat în mod liber, fără licenţă.Ce se întâmplă în interiorul consolei poate fi capturat ca imagine şi înregistrat ca video. Acesta acceptă chiar lucrul în reţea 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

Cerinţe: 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

Fără îndoială cel mai cuprinzator emulator disponibil RealSpec ar fi, de asemenea, considerat de mulţi 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 reţea), Microdrives, interfata

53 http://www.rarst.net/software/dosbox/

disc Beta 128, Mouse Kempston si mai multe interfeţe audio diferite, etc. Fisierele audio sunt bine emulate si pot fi configurate extensiv. În plus, faţă de formatele de fişiere listate, RealSpec poate încărca şi / sau a salva audio video si imagini.

O documentatie extinsa este inclusa, cu informaţii de referinţă suplimentare pentru emulator, hardware-uri şi formate de fişier 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 limitări (fără 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 kernel-ului 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 când 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 Linux-ului.

4) Porneste memoria virtuala a sistemului, activând si montând 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 boot-are.

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 când. Legaturile care încep cu “S” sunt programate sa porneasca ori de câte ori sistemul într-un alt nivel de executie. Pe lânga aceasta, fiecare legatura simbolica are un numar la începutul numelui. În continuare un exemplu de câteva legaturi din /etc/rc.d/rc2.d :

20nfs -> ../init.d/nfsK50inet -> ../init.d/inetS60lpd -> ../init.d/lpdS80sendmail -> ../init.d/sendmail

Când 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:

Când 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(presupunând 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 încât 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 boot-time. 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 Manager-

ul (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 EFI-ului .

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 .