2.5. kernel-ul–in unix - carment.ase.ro · shell ini ţiaz ăun proces=> bifurca ţia este...

1

Conf.dr.Carmen Timofte Sisteme de operare 1

2.5. Kernel-ul – in UNIX

2.5.1.Structura.Functiile nucleului

2.5.2. Conceptul de proces. Stari. Comenzi

2.5.3. Directivele fork, exec

2.5.4. Sincronizarea proceselor

2.5.5. Comunicarea proceselor

2.5.6. Functiile de gestiune

2.5.7. Initializarea sistemului


Nucleul SO este:

� partea rezidenta a SO, care controleaza alocarea:

� timpului masinii;

� a spatiului de memorie;

� a canalelor de comunicatie intre procesele existente

� alcătuit din aproximativ 10.000 de linii ce constituie codul programului, care, înfuncţie de sistem, se transformă într-un număr mai mare sau mai mic de cuvintemaşină (sau bytes); intre acestea, 5 - 10% din totalul codului programelor (Shell, utilitare, KERNEL şi celelalte) este variabil funcţie de sistemul de calcul şi de setulde utilitare;

� alcătuit din următoarele componente principale

� programul supervizor central (rezident in RAM);

� rutine de servicii: scrierea în memorie, gestiunea ceasului sistem etc.; suntapelate atunci când sunt necesare, se gasesc in zona de tranziente;

2.5.1.Structura. Functiile kernel-ului

2


� care, la randul lor formeaza urmatoarele 4 componente:

1.Interfata cu procesele utilizator – prin system calls (apelurisistem);

2.Subsistemul de control al operatiilor de I/E – prin drivers(subrutine de control al dispozitivelor); cca.1000 linii scrise în limbajul C;

�Controleaza modul de lucru cu dispoz. periferice (in modurilecaracter, bloc, raw);

�Aloca spatiu pt. fisiere;

�Gestioneaza spatiul liber din mem. Secundara;

�controleaza accesul la fisiere;

3.Subsistemul de control al proceselor- contine cca. 7-8000 linii scrise în limbajul C (portabil pe orice sistem); realizeaza:

� planificarea, sincronizarea, comunicarea intre procese

�Gestiunea memoriei

4.Interfata cu hardware-ul – prin intreruperi; este scrisa in lb. de asamblare, are dimensiuni reduse si este delimitata stric.

(*) Structura


(*) Structura

Primitivele de sistem sunt specificefiecărui sistem de calcul, scrise înlimbaj de asamblare- cca.1000 liniicodul si conţin:

- operaţii de intrare/ieşire de bază;

- comutarea execuţiei între procese;

- permiterea sau inhibarea întreruperilorhardware;

- resetarea priorităţilor întreruperilor;

- alte operaţii.

Accesarea primitivelor de sistem se realizează prin apeluri de sistem(directive de sistem sau system calls) din programe în C sau în limbaj de asamblare.

3


(*)

Structura kernel


(*) Functii

Kernel => principala functie este de GESTIUNEA RES.=

1. alocare/dealocare de res.

2. controlul starii res.

3. implementarea unei politici de control a operatiilor de mai sus.

Functiile kernel-ului:

1. Gestiunea proceselor –

� controlul executiei lor prin implementarea unor primitive de creare, terminare, suspendare, comunicare intre procese;

� Planificarea pt. executie conform politicii time-sharing;

2 Gestiunea memoriei - aloca/elibereaza MP pt. procesele aflate in executie,permitandaccesul in anumite situatii, in zone de memorie comuna (spatiul de mem. al nucleului este protejat si nu poate fi accesat decat de el).

3. Gestiunea dispozitivelor perifice – permite procesor un acces controlat la DP.: banda, disc, interfete de retea;

4. Gestiunea fisierelor –

� alocarea/dealocarea mem. secundare (ext.) pt. stocarea si regasireaeficienta a inf.;

� protejarea fis. impotriva acceselor ilegale;

4


2.5.2. Conceptul de proces

� Un SC poate lucra in 2 moduri:

- Utilizator - când execută un program sau proces;

- Sistem (Kernel) - când execută un cod sistem.

� Comutarea între modul utilizator şi KERNEL se realizează prin 3 mecanisme:

- ceasul- care întrerupe orice alt program cu frecvenţa de 60 Hz,

- rutina de ceas permiţe reevaluarea priorităţilor proceselor şi implicit schimbarea procesului;

- în absenţa altor întreruperi, ceasul realizează divizarea timpului, => sistemul este împărţit întremai mulţi utilizatori;

- apeluri de sistem - prin care utilizatorul solicită diverse servicii oferite de SO; cele care realizeazăoperaţii de intrare/ieşire duc la suspendarea procesului apelator pe durata transmiterii datelor;

- cereri de serviciu ale perifericelor de intrare/ieşire.


–

(*)

Procesul este concept fundamental de organizare a SO UNIX.

Proces = un program în execuţie, care contine imaginea fis exec. in mem (zonade cod, date, stiva.) + res. din mom. executiei (registrii, fis. deschise etc.)

Pentru un program activ, pot exista mai multe procese active- numite instanţe.

Firele de executie multiple pot exista printr-un task sau proces.

Executie proceselor – pe 2 niveluri:

- Utilizator (user ) – procesele isi pot accesa doar propriile zone de cod si date;

- Nucleu (kernel) –procesele pot accesa si spatiul de adresa al nucleului;

- anumite instructiuni masina sunt privilegiate si nu pot fi executate decatin mod nucleu.

Mecanismul de trecere de la:

- user -> nucleu -se face prin apeluri sistem,

- nucleu -> user –se face prin intoarcerea din apelul sistem

5


(*)


(*) Starile unui proces

Starile de baza ale unui proces:

1. Nou – procesul a fost creat;

2. In asteptare – Aşteaptă apariţia unui eveniment (echipament hardware, intervenţia utilizatorului sau a altui proces; un proces intra in aceasta stare singur, de exp. cand asteapta terminarea unei op. de I/E ; un proces se poateafla in asteptare pe disc (swapped) sau in memorie;

3. Gata de executie– procesul are toate resursele, asteptand sa intre in executie; in acesta stare se pot gasi mai multe procese simultan, plasate de nucleu intr-ocoada de asteptare, in functie de prioritati;

4. In executie in mod kernel sau user;

5. Suspendat- un alt proces a “ordonat” ca acest proces să intre în starea suspendat (“go to sleep”). Procesul aflat în starea suspendat va fi “trezit” de către alt proces

6. Zombie - sunt trecute toate procesele in mom. terminarii lor; (nu se elib. intrarea in tabela de procese, acest lucru realizandu-se de catre parinteleprocesului, in urma primirii de la nucleu unui semnal de terminare a fiului.)

7. Terminat - Procesul şi-a încheiat execuţia.

6


(*)Starile unui proces


(*) comenzi de lucru cu procese

cron Execută comenzile specificate în fişierul crontab (root)

kill [-sig_id] id_proces kill 92345

Se trimite semnalul sig_id procesului cu numărul id_proces. Trimite semnalul 15 (de terminare) procesului 92345

ps [–efl] Arată procesele care rulează şi starea lor

sleep sec sleep 10; date&

Suspendă execuţia curentă pentru nr. secunde specificat Lansează în execuţie programul date după 10 secunde

nice [-incr] comanda [argument] nice –12 date nice --12 date

Schimbă prioritatea unui proces (root) Date va rula la prioritatea +12 (mai mică) Date va rula la prioritatea –12 (mai mare)

Comenzi de lucru cu procese: cron , kill, ps, sleep, nice, at, fg, bg

7


(*)

Informaţiile necesare procesului sunt memorate în:

a) tabela proceselor (proc area)– este alocata static de nucleu;

- este constituită în memorie,

- conţine o intrare pentru fiecare proces, detaliind starea acestuia:

• localizarea procesului;

• adresa de memorie şi adresa de evacuare;

• mărimea procesului;

• numărul de identificare;

• identificatorul utilizat;

b) tabela utilizator – zona user (u area)- contine datele cu care opereaza nucleul, atuncicand procesul este in executie;

- este parte a regiunii de date a procesului;

- este eliberata atunci cand este evacuat procesului pe disc;

- este o extensie a tabelei de procese si contine:• Adresa din tabela de procese asociata;

• Descriptorii fisierelor deschise de proces;

• Directorul curent si cel radacina asociat procesului;

• Numerele de identificare ale user-ului si grupului => pt. det. drepturilor de acces la fis.


2.5.3. Directivele fork si exec

� proces3 are acces la toate fişierele deschise de proceseleanterioare, în timp ce invers nu se permite accesul => fişierelesunt accesibile de pe nivelurile situate la periferia ierarhiei.

� Shell iniţiază un proces=> bifurcaţia este aranjată astfel încâtShell să aştepte terminarea procesului (executat înforeground).

� Dacă nu aşteaptă, înseamnă că Shell a dat naştere altorprocese mai puţin prioritare (procese executate înbackground, adăugând după comanda corespunzătoaresemnul &).

Planificarea proceselor

� Iniţierea unui proces poate fi efectuată numai de către un alt proces activ.

� Când este conectat primul utilizator, Kernel-ul asigură o copie a Shell-ului care rulează doar pentru el, => structura ierarhica de procese creata printr-un mecanism numit bifurcaţie (fork), prin care Kernel înlocuieşte un proces existent, prin două procese:

- procesul iniţial (părinte);

- procesul iniţiat de procesul iniţial (fiu), care împarte (partajează) toate fişierele cu procesul părinte.

� După bifurcaţie, ambele procese se execută independent;

excepţie: când se solicită explicit ca procesul părinte să aştepte terminarea procesului fiu prin directiva WAIT;

� procesul fiu poate genera o nouă bifurcaţie

8


(*)

- Procesele în Unix se află în relaţia părinte-copil, adică un proces părinte poate lansa în execuţie alt proces (copil)

- Există 2 moduri de a realiza acest lucru: o Directiva fork (pid_t fork())

� Creează un nou proces incrementând cu1 numărul total de procese din sistem, noul proces având propria imagine în memorie;

� Directiva întoarce către părinte identificatorul de proces al fiului şi 0 către procesul fiu; (procesele fiu şi părinte se execută în paralel în exemplul următor)

int i;

pid_t child;

if((child=fork()) = = 0)

{

proces copil

}

proces părinte

� Copilul moşteneşte de la părinte, printre altele, câte o copie pentru fiecare variabilă alocată static sau dinamic de către părinte, toţi descriptorii de fişiere ai părintelui;


(*)

o Familiei de directive exec � Prin acest set de directive, imaginea noului proces se suprapune

peste imaginea vechiului proces, care încetează să mai existe; � Numărul total de procese din sistem rămâne constant

int execl(char * path, char * argv0, char *

argv1, ...., 0)

sau execv(int argc, char * argv[])

� Exp: execl(”bin/ls”, ”ls”, 0);

� Procesul din care s-a lansat comanda se termină şi peste el se suprapune imaginea procesului vechi care începe să se execute

� Directiva întoarce 0 –dacă s-a lansat corect, sau ≠0 – în caz contrar

9


(*)

- Directiva exit – termină un proces exit(int cod)

o Întoarce 0 dacă procesul s-a terminat corect, sau întoarce codul de eroare în caz contrar

- Directiva wait – permite părintelui aşteptarea terminării copilului

pid_t wait(int * status)

o Întoarce către părinte identificatorul copilului care s-a terminat, sau –1 dacă nu are nici un copil

- Directiva dup – copiază descriptorul de fişier df (dat ca parametru), în prima intrare

liberă din tabela de descriere a fişierelor din zona user, şi întoarce noul descriptor de fişier

int dup(df)

int df

- Directiva pipe – creează un canal de comunicaţie între 2 procese

int pipe(int file_descr[2])

o Directiva întoarce 2 descriptori de fişier memoraţi în 2 întregi, care reprezintă cele 2 părţi ale conductei

o file_descr[0]- partea din pipe pentru citire o file_descr[1]- partea din pipe pentru scriere o Comunicarea se face cu read/write ca la orice fişier normal o Exp (who|lpr) –ex7.c


main()

{

int p[2],i,j;

pipe(p);

if(fork()==0)

{

close(0);

dup(p[0]);

close(p[1]);

execl("/bin/who","/bin/who",0);

}

else

{

close(1);

dup(p[1]);

close(p[0]);

execl("/bin/lpr","/bin/lpr",0);

}

}

- Exemple: ex1.c, ex2.c, ex3.c, ex4.c, ex5.c, ex6.c, ex7.c, ex8.c, ex9.c,

(*)

gcc –o nume_fis_iesire nume_fis_intrare.c

10


2.5.4. Sincronizarea proceselor

- Controlata de SO – prin pipe = conducta de comunicatie

- Controlata de user – prin evenimente si semafoare

- Sincronizarea prin intermediul evenimentelor o Evenimentul:

� reprezintă modalitatea de precizare a momentului în care un proces blocat poate trece în starea gata de rulare;

� este reprezentat printr-un număr întreg, ales prin convenţie, cunoscut de kernel;

� nu permite transmiterea altor informaţii, neavând asociată memorie;

� Devantaj- sincronizarea nu se poate face în funcţie de o anumită cantitate de informaţie

o Blocarea proceselor – se face prin funcţia internă sleep (diferită de funcţia de bibliotecă sleep)

o Deblocarea proceselor – nucleul trece toate procesele care aşteaptă o anumită condiţie în starea „gata de rulare”, prin wakeup;

o Sincronizarea prin evenimente se poate realiza prin 3 moduri: prin semnale, între procesul tată şi fiii săi, prin intermediul unor funcţii sistem.


(*)

� Sincronizarea prin semnale - Semnal = o modalitate de semnalare a evenimentelor în

sistem (alt mod fiind prin funcţia wakeup) - Este implementat cu ajutorul unor biţi, setaţi:

o de nucleu (la evenimente hardware), o de utilizator (prin apelul directivei kill)

- tratarea semnalului se face în contextul procesului care-l primeşte;

- există mai multe tipuri de semnale, care diferă de la versiune la versiune de Unix, cum ar fi: pt. terminarea procesului, pt. excepţii, pt. trasare execuţie proces, venite de la utilizator (prin directiva kill sau alarm) etc.

- Acţiunea implică asociată unui semnal este de terminare a procesului, dar există şi posibilitatea de a executa anumite acţiuni prin funcţia signal(nrsig, f), unde nrsig= nr. semnal, iar f = numele rutinei care tratează semnalul şi care va trebui def. de utilizator.

Kill –l sau man signal sau cat /usr/include/sys/signal.h => semnale + nr. asociate

Semnal – un mecanismsoftware ce informeazaprocesul de aparitiaunui evenimentasincron. Un semnaleste similar cu o intrerupere hardware dar nu implica prioritati(toate semnalele suntconsiderate egale). Semnalele care apar in acelasi timp suntprezentate unui procespe rand, fara a se stabili o ordine bazatape prioritati.

11



(*)

� Sincronizarea între proces tată şi fiii săi - Se realizează prin funcţia sistem wait – permite părintelui

aşteptarea terminării copilului pid_t wait(& status)

- Întoarce către părinte identificatorul copilului care s-a terminat, sau –1 dacă nu are nici un copil

- Dacă tatăl doreşte sincronizarea cu un anumit fiu, se foloseşte secvenţa:

while(wait(&status)!=pid);

care repetă blocarea tatălui, până când se termină fiul cu identificatorul pid;

12


(*)

� Sincronizarea prin intermediul unor funcţii sistem - Există un număr de funcţii care permit sincronizarea

controlată de utilizator, cum ar fi: kill,alarm, pause, sleep;

o kill(pid, sig)

� funcţie directivă care transmite semnalul sig procesului identificat prin pid; procesul emiţător şi cel receptor al semnalului trebuie să aibe acelaşi user-ID; dacă pid=0, atunci semnalul este transmis tuturor proceselor din acelaşi grup cu emiţătorul

o alarm(seconds)

� funcţie directivă care trimite semnalul SIGALARM către procesul apelant, într-un număr de secunde dat ca argument

o pause()

� funcţie directivă care cedează controlul de la programul apelant; se poate părăsi această stare în urma receptării unui semnal prin kill sau alarm.

o sleep(sec)

� funcţie de bibliotecă care suspendă execuţia procesului curent pentru un timp specificat (sec)


- Sincronizarea prin intermediul semafoarelor o Alături de mecanismele de sincronizare clasice, versiunea SystemV a

adăugat un pachet de primitive care implementează conceptele de: � Semafor (sem) � Regiune de memorie partajată (shm) � Coadă de mesaje (msg)

o Aceste primitive sunt grupate într-un pachet de funcţii numit IPC (Inter Process Communication Package), care cuprinde 3 clase principale de funcţii, identificate prin prefixele get, op, ctl:

� Familia get – creează structuri de date specifice unui anumit mecanism de sincronizare;

- Conţine semget, shmget, msgget; - Primesc ca parametrii:

o O cheie numerică – care identifică unic structura de date (trebuie să fie aceeaşi pentru procesele care o utilizează); cheia poate fi aleasă sau generată de o funcţie de bibliotecă:

int ftok(nume_fis, caracter)

întoarce o cheie numerică sau –1, în caz de eroare; o Un mod –asemănător cu modul de acces la fişiere

- Întorc o valoare numerică, întreagă, care va fi folosită de operaţia următoare pentru a identifica structura de date

� Familia op – realizează operaţii specifice de sincronizare şi/sau comunicare

� Familia ctl – realizează operaţii de control asupra structurilor de date asociate primitivelor IPC, cum ar fi: ştergere, afişare valori, afişare stare, etc.

o Structura de date asociată SEMAFOR: o Drepturi de acces la semafoare o Sintaxa funcţiilor pentru lucru cu semafoare (COMPLETATI !!!)

� semget, � semop, � semctl

o Exemplu: semafor.c

Semafoare – reprezinta o generalizarea a primitivelor de sistemwait si signal. Kernelulface toate operatiileuna cate una si nici un proces nu poateaccesa semaforul panacand toate operatiile

nu sunt indeplinite.

13


2.5.5. Comunicarea intre procese

Se poate realiza prin: 1. fişiere obişnuite (sinc_bloc_fis.c) 2. fişiere tip conductă (pipe.c) 3. zone de memorie comună (semafor.c) 4. cozi de mesaje (cozim_transm.c, cozim_recep.c)

1. Comunicarea prin intermediul fişierelor

- este cea mai simplă şi mai directă metodă - este cea mai ineficientă, pt. ca nu oferă un mecanism de control automat al accesului

concurent, acesta căzând în sarcina utilizatorul; - se poate implementa în 2 moduri:

o prin simularea unei regiuni critice – cu funcţia creat, fără drepturi de scriere

while((f=creat(”fis”, 0111))

14


3. Comunicarea prin zonă de memorie comună (partajată)

- reprezinta cea mai rapidă formă de comunicare între procese; - este o zonă de memorie în care este mapată o porţiune din spaţiul virtual al proceselor

care comunică (un bloc comun de memorie virtuala partajata de mai multe procese). - procesele citesc sau scriu in spatiul comun de memorie folosind aceleasi instructiuni

cu care citesc/scriu alte portiuni de memorie virtuala. - Permisiunile sunt read-only sau read-write pentru fiecare proces in parte. - Excluderea mutuala este asigurata de procesele care folosesc memoria partajata. - implementarea se realizează cu ajutorul primitivelor de comunicare specifice pentru

zone de memorie comune, care fac parte din pachetul IPC, cum ar fi: o shmget o sgmat o shmdt o shmdl

( unde sh= shared, m = memory) Completaţi sintaxa funcţiilor mai sus amintite!

- exemplu: semafor.c


(*)

Doua procese partajeaza un fisier mapat, cu adrese virtualediferite

- Scrierea in acest fisier va fi vizibila instantaneu de ceilalti

15


(*)

4.Comunicarea prin mesaje

Mesaj – este un bloc de text de un anumit tip

� este mecanismul cel mai eficient implementat în pachetul IPC� se comunică printr-o coadă de mesaje circulară, gestionată de SO � Fiecare proces are o coada de mesaje care functioneaza ca o cutie postala.

� transmisia se face cu sincronizare (blocare – deblocare), mesajele având asociat un tip (valoare numerică)

� recepţia de face în funcţie de tipul ales� primitivele de lucru sunt:

msgget

msgctl

msgsndmsgrcv

Completaţi sintaxele!!!

� Exemplu de comunicare prin cozi de mesaje între 2 procese neînrudite prin relaţia tată-fiu: cozim_transm.c, cozim_recep.c

(se lansează primul cozim_transm, apoi cozim_recep)


2.5.6. Functiile de gestiune

Gestiunea proceselor –

� controlul executiei lor prin implementarea unor primitive de creare, terminare, suspendare, comunicare intre procese;

� Planificarea pt. executie conform politicii time-sharing;

16


- procesorul este alocat de către nucleu; - fiecare proces primeşte cuante egale de timp, de durată fixă într-o planificare de tip Round- Robin; => la un moment dat, un

singur proces ocupă UC, fiind în stare de execuţie; - după terminarea cuantei de timp, nucleul scoate procesul din starea “în execuţie” şi va aduce alt proces, reluându-se ulterior

execuţia primului proces; - nucleul asociază fiecărui proces activ o prioritate, calculată dinamic şi asociată direct cu timpul de execuţie consumat de

procesul respectiv; - priorităţile sunt de 2 feluri, separate printr-o valoare de prag:

o priorităţi utilizator; o priorităţi nucleu.

- calculul priorităţii proceselor de către nucleu: o atribuie o prioritate unui proces, înainte de a fi trecut în starea “în aşteptare”, corelând valoarea cu cauza trecerii în

acea stare; o recalculează prioritatea în momentul în care procesul revine în mod utilizator; o rutine de tratare a întreruperilor de ceas ajustează priorităţile din secundă în secundă => recalcularea priorităţilor de

către nucleu, pt. a preveni monopolizarea procesorului de un proces anume; o prioritatea unui proces în mod utilizator este în funcţie de timpul recent de folosire a UC (cel ce a folosit recent UC-

ul are o prioritate mai mică). - selectarea procesului se face de către scheduler în funcţie de prioritatea procesului, selectând procesul cu prioritatea cea

mai mare dintre cele aflate în starea “gata de rulare” şi încărcate în memorie; - cuantele de timp ale procesorului sunt controlate de driver-ul de ceas, care:

o reprogramează ceasul de timp real al maşinii; o programează execuţia unor funcţii interne ale nucleului, în funcţie de valoarea unor time-ri interni; o măsoară timpul sistem; o transmite semnalul SIGALRM către procese, la cererea lor; o activează periodic procesul swapper; o controlează planificarea în execuţie a proceselor.


(*)

Divizarea timpului şi resurselor� În sisteme de operare multitasking, procesele individuale nu sunt executate până la terminare, având

alocate cuante de timp de către procesor într-o planificare de tip Round- Robin; � cuantele de timp nu sunt egale, lungimea depinzând de prioritatea taskului, de accesibilitatea datelor de

intrare solicitate şi a perifericelor de ieşire.� Alocarea se face având în vedere maximizarea utilizării resurselor hardware, cu respectarea priorităţii

taskurilor critice.� Priorităţile sunt periodic reînnoite astfel:

� taskurile cu timp de execuţie mai mare, vor avea prioritate mai scăzută;� taskurile de tip întrebare-răspuns vor avea răspuns instantaneu;� taskurile ce constau în schimbarea de caractere au cea mai scăzută prioritate.

� După expirarea timpului alocat, taskul este evacuat într-un fişier de evacuare pe disc unde va rămâneapână i se dă din nou controlul; în acel moment, imaginea salvată anterior se reîncarcă în RAM; ea vacuprinde:� conţinutul părţii de memorie inscriptibilă;� conţinutul registrelor;� numele directorului curent;� lista fişierelor deschise de procesul considerat.

17


(*)

2. Gestiunea memoriei - aloca/elibereaza MP (RAM) pt. procesele aflate in executie, permitand accesul in anumite situatii, in zone de memorie comuna (spatiul de mem. al nucleului este protejat si nu poate fi accesat decat de el).

Alocarea memoriei

� sistem de operare multitasking => ţine evidenţa taskurilor concurente şi menţine controluldiverselor programe care sunt rezidente în RAM la un moment dat, furnizând şi informaţii privindsuficienţa spaţiului de memorie:

- în mod normal, fiecare program este încărcat în diverse zone de memorie RAM;

- în modul de operare cu divizarea timpului (time-sharing), poate opera fără evacuareaconţinutului memoriei pe disc; fiecare program se execută în cuanta de timp alocată, rămânând în memorie numai programele a căror execuţie nu s-a încheiat

- (practic, numai registrele sistemului sunt divizate între programe, astfel că evacuarea programelorimplică de fapt, numai evacuarea conţinutului registrelor);

- pe durata execuţiei proceselor, UNIX alocă porţiuni distincte de RAM pentru:

• segmentul de cod (instrucţiunile programului) protejat la scriere;

• segmentul de date ce conţine toate datele definite de utilizator: valori, variabile, etc.;

• segmentul de stivă care conţine toate informaţiile de sistem necesare menţinerii intacte a unuiproces, atunci când este evacuat din RAM pe disc sau când este încărcat în RAM de pe disc.


(*)

a) Spatiul virtual al procesul A ; b) Memoria fizica; c) Spatiul virtual al procesul B

BSS= Block Started by Symbol

18


(*)

Această divizare este realizată din două motive:- evacuarea segmentului de cod implică reducerea cantităţii de informaţii necesară a fi

evacuate; fiind de tip read-only, acesta este identic cu imaginea sa din disc, deci nutrebuie rescris când se evacuează;

- Shell este încărcat pentru fiecare utilizator, deci există atâtea copii Shell, câţiutilizatori sunt conectaţi; dacă mai mulţi utilizatori solicită un program (segment de cod), nu este necesară copierea acestuia deoarece el poate fi folosit simultan; estesuficient să se creeze şi când este necesar, să se evacueze un segment de date şiun segment de stivă pentru fiecare utilizator.

Memoria este limitata => se extinde pe disc in zona de swap area prin 2 politici de transfer: swapping si demand paging (cerere de paginare)

- Swapping – se realizeaza de catre nucleu atunci cand:

- Se aloca spatiu pt. procesul fiu, in cadrul executie directivei fork;

- Se mareste dinamic zona de date a unui proces, cu directiva brk;

- Se elibereaza spatiul pt. un alt proces, care se afla pe disc.


- swap device – dispozitiv de tip bloc, creat şi configurat la instalarea sistemului; o driver-ul său controlează zona de pe disc în care se transferă procesele; o alocarea spaţiului disponibil se face în grupuri de blocuri continue; o gestiunea acestui spaţiu este diferită de cea a SF; o informaţiile despre spaţiul liber din discul de swap şi a memoriei sunt memorate în

tabele numite swap map şi core map; o algoritmul de alocare al zonei este de tipul first-fit;

- nucleul salvează pe disc doar spaţiul de memorie asignat procesului respectiv; - transferul proceselor de pe disc în RAM se face de către procesul 0 (swapper) - la terminarea procesului de iniţializare, swapper-ul rămâne într-o buclă infinită, realizând

operaţii de transfer în zona de swap la cererea nucleului; - nucleul planifică pt. execuţie swapper-ul ca pe un proces obişnuit, cu prioritatea maximă în

mod nucleu; - procesul 0 examinează coada proceselor „gata de rulare”, care nu sunt în memorie, şi-l

alege pe cel care a petrecut cel mai mult timp pe disc; - dacă nu încape în RAM, swapper-ul transferă mai întâi un proces din memorie pe disc şi

reia algoritmul; - transferul din memorie pe disc => se aleg mai întâi procesele în starea „în aşteptare”, în

funcţie de prioritate şi de timpul petrecut în memorie; - dacă nu există astfel de procese, atunci este ales un proces dintre cele „gata de rulare”, în

funcţie de prioritate (nice) şi de timpul petrecut în memorie.

19


Demand paging (cerere de paginare)

- dimensiunile proceselor nu mai sunt limitate de dimensiunea mem RAM, ci doar de mărimea maximă a unui proces permisă de SO;

- mem. este împărţită în pagini de dimensiune fixă; - alocarea de pagini unui proces se realizează conform algoritmului LRU, din lista de pagini

disponibile; - când procesul accesează o pagină care nu se află în memorie, se generează o întrerupere –

page fault; - nucleul suspendă execuţia procesului până când reuşeşte operaţia de încărcare a paginii

respective, după care reia execuţia procesului; - nucleul utilizează 4 structuri de date pt. implementarea funcţiilor de gestiune a memorie:

o tabele de pagini (page table) – conţine adresa fizică a paginii, timpul petrecut în memorie, biţii de protecţie a paginii ş.a.

o tabela descriptorilor de bloc – descrie blcoul de disc pe care se află o copie a paginii şi conţine numărul logic al dispozitivului de swap, numărul blocului etc.

o Tabela de descriere a paginilor – conţine starea paginii, numărul de procese care utilizează pagina, numărul dispozitivului logic şi al blocului care conţine o copie a paginii, inf. de înlănţuire a paginilor libere etc.

o Tabela de descriere a zonei de swap – conţine inf. despre paginile aflate pe dispozitivul de swap, cum ari fi, nr. de intrări în tabela de pagini care adresează pagina pe dispozitivul de swap

Se folosesc ambele metode.

- Nucleul activează swapper-ul, - întrerupe procesul curent, - îl pune în starea “gata de rulare” pe disc (swapped), - swapper-ul transferă pe disc procese în întregime, până când se eliberează suficientă

memorie;


(*)

20


3. Gestiunea dispozitivelor perifice – permite procesorului un acces controlat la DP.: banda, disc, interfete de retea;

� Toate operaţiile de intrare/ieşire sunt privite ca operaţii cu fişiere, Shell nerecunoscândexistenţa unităţilor periferice, deci Kernel ascunde unităţile fizice reale sub forma unorfişiere aparente.

� Fiecare unitate fizică este înzestrată cu un program special (driver) care translateazăacţiunile solicitate de unităţile virtuale astfel încât utilizatorul poate comunica cu oriceunitate ataşată sistemului fără nicio deosebire, dacă aceasta dispune de driverulcorespunzător.

� Deoarece aceste fişiere sunt deosebite de fişierele utilizator, ele sunt referite ca fişierespeciale de tip caracter sau bloc, fiind recunoscute două tipuri de unităţi periferice (disc şiterminal) a căror inod-uri conţin:� numărul major- indică tipul dispozitivului;

� numărul minor- indică numărul unităţii

(*)


(*)

� Accesul la sistemul de fişiere se face la trei nivele:1) prin utilitare - nivelul 1;2) prin funcţii de bibliotecă - nivelul 2 care apelează 3);3) prin apeluri de sistem (directive de I/E) - nivelul 3: open, close, read, write, creat prin

care se gestionează fişierele la cel mai scăzut nivel.

Apelul unei directive de I/E => suspendarea procesului curent pe durata executie operatiei(in acest timp, in UC va fi planificat un alt proces)

� Pentru reducerea numărului operaţiilor de intrare/ieşire la periferice ce lucrează la nivel de bloc, nucleul organizează în memoria internă o zonă de tampone cache (structuri de date software) diferite de memoria cache.

� Tampoanele cache sunt organizate în două liste dublu înlănţuite (unele putând face parte din ambele); lista tampoanelor în uz este organizată conform unei funcţii de dispersie (hashing) ce ţine seama de numărul logic al dispozitivului periferic şi numărul blocului al căruiconţinut se încarcă în zona de date ataşată tamponului. Funcţiile sunt apelate de nivelulinferior al sistemului de gestiune al fişierelor (SGF).

21


4. Gestiunea fisierelor –

� alocarea/dealocarea mem. secundare (ext.) pt. stocarea si regasirea eficienta a inf.;

� protejarea fis. impotriva acceselor ilegale;

(*)


2.5.7. Initializarea sistemului

� Executia procedurilor de testare si initializare hardware (teste memorie, tastaturia, unitati de disc etc.);

� Se incarca in RAM un loader (incarcator), aflat in blocul de boot la SF;

� Loader-ul incarca nucleul SO, aflat in fisierul unix din radacina, pe care-l identifica cu ajutorulinformatiilor din superbloc si i-list;

� Nucleul SO

� Initializeaza structuri de date proprii (imaginea superblocului, a listei de i-nod-uri in memorie, lista buffer-e disc libere, buffer-e pt. cozi de caractere etc.)

� Monteaza SF root in /;

� Construieste procesul 0 (numit scheduler la sisteme cu demand paging, swapper la celelalte), care contine doar o zona de date utilizata de nucleu (imaginea unui procesincomplet);

� Executa un fork intern pt. a crea procesul 1;

� Procesul 1 ruleaza in mod kernel si efectueaza:

• Initializarea structurilor de date proprii;

• Marirea zonei de memorie alocata pt. zona de text;

• Copierea din spatiul de adresa al nucleului un cod care contine apelul directivei exec cu parametrul /etc/init;

� Procesul 1 trece in modul utilizator si va fi programat de executie de catre scheduler, devenindprimul proces complet din sistem

22


(*)

� Procesul 1 este numit init =>va fi parintele oricarui proces aparut ulterior in sistem;

� Procesul init citeste fisierul /etc/inittab, pt. a decide asupra proceselor ce vor fi create;

� Starile procesului init (in functie de versiune, un SO poate functiona in mai multe moduri, specificate in fisierul /etc/inittab):

� 0 –starea premergatoare opririi calculatorului;

� 1- starea monouser ( se lanseaza pe consola sistem un proces shell pt. intretinereasitemului);

� 2- starea multiuser

• lanseaza cate un proces /etc/getty pt. fiecare linie de comunicatie activa;

• Procesul getty asteapta conectarea user-ului;

• seteaza parametrii de comunicatie pt. terminal (din fis. /etc/getydefs);

• Lanseaza in executie prin exec programul login;

• Acesta cere numele si parola, le verifica;

• Lanzeaza prin exec procesul shell, specificat in fisierul /etc/passwd;

• Shell-ul va fi fiul procesului init;

• Terminarea sesiunii de lucru de catre user va fi sesizata de catre init, care va lansa un nou proces getty pe linia respectiva;

� 3- starea multiuser cu acces la SF aflate la distanta;

� Procesul init scaneaza fisierul /etc/rc si starteaza toate procesele daemon descrise in fisier;

� Procese daemon = procese sistem care ruleaza in background pe durata functionarii sistemului; in cazul opririi, se relanseaza in executie doar de catre init.


(*)

2.5. kernel-ul–in unix - carment.ase.ro · shell ini ţiaz ăun proces=> bifurca ţia este...

Documents