Cursuri So Actuale PDF

Sisteme de operare Curs 1
Pagina 1
Curs 1.
Definiie. Scurt istoric

Logic 1:

10 studenti au rspuns la 5 ntrebri cu rspuns multiplu (A, B, C, D sau E) i la 5 ntrebri
logice (cu rspuns T sau F). Nu sunt doi studeni care au rspuns corect la acelai numr de
ntrebri.
Care student a raspuns corect la toate ntrebrile ?
Chestionarul de rspunsuri este urmtorul:
Student P1 P2 P3 P4 P5 P6 P7 P8 P9 P10
a C C B D D T F F F F
b A C D E A F T F F F
c A B E C B T F T T T
d C D A E B T F F F F
e C C E D A F T F F F
f C E A C E F F T T T
g A B A C E T F F T T
h B B D C A T F F F F
i E E C C B T T T T T
j A B C C D F F F T T

Bibliografie curs (principalele titluri):

1. Andrew S. Tanenbaum Modern Operating Systems, Prentice Hall, 2001
2. William Stallings Operating Systems. Internals and Design Principles, Prentice hall
2005;
3. Abraham Silberschatz, Peter Galvin, Greg Gagne Operating System Concepts, John
Wiley & Sons, 2005;
4. Daniel Bovet, M. Cesati Understanding the Linux Kernel, OReilly, 2003

1.1 Definiii

Exist mai multe posibiliti pentru definirea unui sistem de operare. Tanenbaum
propune definirea sistemelor de operare din dou puncte de vedere: cel al sistemului de
operare ca administrator de resurse respectiv cel de extensie funcional a calculatorului.
Silberschatz propune o definire a sistemelor de operare din punct de vedere al
utilizatorului respectiv al calculatorului. Astfel, din punctul de vedere al utilizatorului, un
sistem de operare constituie o unealt ct mai simplu de utilizat pornind de la nite
performane minimale n cazul calculatoarelor personale n timp ce n cazul staiilor de tip
mainframe, accesate de mai muli utilizatori la un moment dat, un sistem de operare este vzut
n principal ca un maximizator i gestionar al utilizrii resurselor. Din punct de vedere al
Pagina 2
calculatorului, dac putem privi lucrurile i din aceast perspectiv, un sistem de operare este
vzut ca un gestionar de resurse.
Burgess definete un sistem de operare ca fiind un nivel al software-ului care trateaz
aspectele tehnice n timpul unei operri a unui calculator. Sistemul de operare funcioneaz n
acest caz ca o protecie a utilizatorului vizavi de operaiunile calculatorului de pe nivelul de
jos.
Stallings definete sistemul de operare ca fiind o aplicaie care controleaz execuia
celorlalte programe i acioneaz ca o interfa ntre utilizator i resursele hardware ale
calculatorului. Tot el definete i obiectivele unui sistem de operare ca fiind:
- uurin n utilizare sau convenabilitatea- se refer la faptul c faciliteaz o utilizare mai
uoar a calculatorului;
- eficien permite o utilizare mai eficient a resurselor calculatorului;
- abilitate de a evolua un sistem de operare trebuie s fie astfel construit nct s permit o
dezvoltare, testare i introducere de noi funcii sistem;
In figura 1.1. am reprezentat structura ierarhizat a unui sistem de calcul:

Figura 1.1. Structura ierarhizat a unui sistem de calcul

Practic, utilizatorul nu are legtura cu arhitectura calculatorului dect prin intermediul
anumitor straturi. De fapt vedem calculatorul prin intermediul unei aplicaii. Aplicaia este
dezvoltat de un programator ntr-un anumit limbaj de programare. Pentru dezvoltarea acestor
programe trebuie s avem la dispoziie un set de utilitare: compilatoare, editoare de text,
interpretoare. Ultimele 2 nivele constituie de fapt nivelul hardware, urmtoarele 2 l constituie
nivelul sistemului de operare. Acesta include i un set de utilitare. Pe lng acestea pot fi
instalate i alte utilitare pe sistem. Sistemul de operare acioneaz ca un mediator ntre
programator respectiv aplicaie i resursele sistemului.
Pagina 3
Sistemele de operare asigur urmtoarele servicii:
- dezvoltarea programelor: sunt oferite o varietate de faciliti legate de editoare sau
depanatoare de programe pentru asistarea programatorului n munca sa. In mod normal
acestea apar ca programe utilitare, deci nu fac parte din sistemul de operare dar sunt accesibile
prin intermediul acestuia;
- execuia programelor: pentru execuia programelor trebuie s fie realizate o serie de
taskuri: datele i instruciunile trebuie ncrcate n memorie, dispozitivele de I/O trebuie
iniializate, trebuie pregtite o serie de resurse. Sistemul de operare le ndeplinete pe toate
acestea;
- asigur access la dispozitivele de I/O: sistemele de operare fac astfel ca programatorul s
poat lucra direct cu dispozitivele de I/O, prin intermediul funciilor de read sau write, fr a
fi nevoit s le programeze n detaliu;
- acces controlat la fiiere: n cazul mai multor utilizatori poate asigura un acces separat n
funcie de drepturile pe care le au asupra fiierelor; pe lng faptul c reprezint dispozitive de
I/O trebuie avut n vedere i formatul acestora;
- accesul la sistem: n cazul unui sistem partajat, sistemul de operare trebuie s asigure
accesul difereniat la resurse, protejarea acestora de un acces neautorizat;
O mulime de erori pot aparea n timpul rulrii unui program pe un calculator. Acestea
includ erorile de hardware cum ar fi cea de memorie sau de cdere a unui dispozitiv sau cele
de software i aici putem face referire la eroarea de overflow sau la imposibilitatea sistemului
de operare de a satisface o cerere a unei aplicaii. Rspunsul sistemului poate varia de la a
nchide programul care produce eroarea la o simpl notificare a acesteia.
Un calculator reprezint un set de resurse pentru manevrarea, depozitarea i procesarea
datelor precum i pentru controlul acestor funcii. Sistemul de operare este responsabil pentru
managementul resurselor. Sistemul de operare se ocup i de controlul acestor operaii cu 2
observaii:
funcioneaz ca i un software obinuit, un program executat de procesor;
de multe ori pierde controlul i depinde de procesor pentru a-l reprimi.
Ca i alte programe de calculator i sistemul de operare furnizeaz instruciuni pentru
procesor cu deosebirea c direcioneaz procesorul pentru utilizarea altor resurse i executarea
altor programe.
In figura 1.2 sunt reprezentate principalele resurse conduse de ctre un sistem de
operare. Astfel, o parte a sistemului de operare se afl n memoria principal. Aceasta include
kernelul sau nucleul care conine funciile cele mai utilizate. Restul memoriei principale
conine date i programe. Aceasta este controlat de ctre sistemul de operare i hardware-ul
aferent managementului memoriei (paginare, segmentare etc). Procesorul n sine este o
resurs i sistemul de operare decide ct din timpul acestuia i este alocat unui anume
program. In cazul sistemelor multiprocesor decizia trebuie luat cu privire la toate
procesoarele. Nu n ultimul rnd, sistemul de operare decide cnd un program aflat n execuie
poate avea control asupra unui dispozitiv de I/O.

Pagina 4

Figura 1.2. Principalele resurse conduse de catre un sistem de operare

Unul dintre dispozitivele de I/O este hard discul. In acest caz putem avea o partiionare a
acestuia ca i n cazul memoriei principale: sistemul de operare deine o partiie mai mic iar
aplicaiile i datele pot acoperi restul mediului de stocare.
Un sistem de operare este necesar s evolueze in timp din urmtoarele motive:
noi tipuri de hardware sau upgrade la cele existente: n cazul UNIX sau OS/2 nu era
folosit mecanismul paginrii deoarece harware-ul nu avea nevoie de acest lucru. Un alt
exemplu este cel dat de ctre folosirea mai multor ferestre de lucru (n sisteme gen
Windows), lucru care a dus la un suport mai sofisticat pe partea de sistem de operare;
noi servicii care trebuie asigurate: datorit cererii formulate de ctre utilizatori sau de
ctre administratorii de sistem, sistemul de operare va trebui s ofere tot timpul
servicii noi;
variante mbuntite funcional: de-a lungul timpului apar o serie de probleme n
funcionare, probleme care nu au fost eliminate la testarea unui nou sistem (sau a unei
variante mbuntite a acestuia). Evident c acestea vor fi eliminate pe msur ce
apar.

1.2 Istoric

Pentru a nelege mai bine cum funcioneaz sistemele de operare este util o prezentare a
evoluiei acestora n timp.
Momentul 0 poate fi numit motorul analitic construit de Charles Babbage n sec.
XIX. Avnd n vedere c era o construcie pur mecanic, nu avea cum s funcioneze. Pn la
mijlocul secolului XX nu mai putem consemna alte ncercri n ceea ce privete construirea
unui sistem de calcul. In perioada celui de al doilea rzboi mondial, diverse colective de
cercettori din Germania dar mai ales din USA au construit maini de calcul pornind de la
releee mecanice nlocuite apoi de tuburi cu vid, odat cu apariia acestora. Persoanele care se
ocupau de aceste maini de calcul fceau toate joburile: designer de sistem, programator,
Pagina 5
service. Programarea consta n realizarea unei plci de conexiuni. Apariia cartelelor perforate
dup anii 50 a schimbat doar modul de programare, acestea nlocuind plcile de conexiune.
Primele sisteme de operare au avut o procesare serial. Programatorul interaciona direct cu
hardware-ul neexistnd practic un sistem de operare. Aceste calculatoare funcionau prin
intermediul unei console, informaia era introdus cu ajutorul unui dispozitiv (de genul celor
pentru cartele de ex.) i era afiat la o imprimant. Problemele care apreau era cele legate de
mprirea timpului de acces deoarece un utilizator avea la dispoziie o anumit durat pentru
rezolvarea unei probleme, dac o rezolva mai repede se pierdea restul de timp iar dac
depea timpul alocat era forat s se opreasc nainte de a rezolva problema, i respectiv de
timpul irosit cu pregtirea rulrii, timp dat de ncrcarea programului surs, a compilatorului,
compilarea acestuia i salvarea n memorie a programului compilat,rencrcarea acestuia,
dup care era executat. Toate aceste operaiuni nsemnau montarea sau demontarea unor
dispozitive iar dac aprea o eroare totul era reluat de la capt.
Introducerea tranzistorului n anii 55 a contribuit la dezvoltarea sistemelor de calcul.
Apar i specializrile n ceea ce privete personalul care se ocupa de calculatoare. Apar i
primele limbaje de programare cum ar fi cel de asamblare sau Fortran.
Pentru a fi evitai timpii de ateptare foarte mari datorai lucrului cu dispozitivele
periferice, perioade n care procesoarele nu aveau de lucru, au fost introduse sistemele cu
prelucrare n loturi. Un sistem cu prelucrare in loturi pornea de la existena n spatele su a
unui program de tip monitor. Prin utilizarea acestuia, utilizatorul nu mai intra n contact direct
cu sistemul. Utilizatorii introduceau joburile prin carduri sau band iar acestea erau puse
mpreun la dispozitivul de intrare al monitorului. Fiecare program reda controlul monitorului
la terminarea sa astfel ca monitorul s poat procesa un nou job. Pentru a vedea mai bine cum
funciona totul ne putem inchipui 2 puncte de vedere: cel al monitorului si cel al procesorului.
O parte a monitorului trebuia s se afle n memoria principal, gata de execuie. Aveam astfel
un program de tip monitor rezident n memoria sistemului. Restul de utilitare i alte funcii
erau incarcate n memoria principala odat cu programele. Monitorul citea una cte una
joburile de la cititorul de cartele sau de band. Pe msur ce un job era accesat de ctre
programul monitor, acesta trecea la realizarea lui dup care se pregatea pentru preluarea
jobului urmator. Rezultatele erau afiate pentru informarea utilizatorului. Din punct de vedere
al procesorului, la un anumit moment de timp, acesta executa instruciuni din zona de
memorie corespunztoare programului monitor. Acestea cauzeaza citirea unui nou job n alt
poriune din memoria principal. O dat ce a fost citit noul job, procesorul va intlni n
monitor o instructiune care i spune s proceseze acest nou job. Procesorul va executa
instruciunile din programul utilizator pn la terminarea acestuia sau pn la ntlnirea unei
erori. Limbajul de control al joburilor era utilizat pentru furnizarea de instruciuni pentru
programul monitor. Era vorba de exemplu despre ce compilator trebuie utilizat respectiv
despre ce tip de date va fi manipulat.
Practic am observat c monitorul este un simplu program de calculator. Este abilitatea
procesorului de a aduce instruciuni din diferite zone ale memoriei. Sunt dezirabile alte
caracteristici hardware cum ar fi:
Pagina 6
protejarea memoriei: in timpul executiei programului monitor trebuie evitata alterarea
locaiilor de memorie care conin programul monitor; n caz contrar, hardware-ul
trebuie s detecteze acest lucru i s transfere controlul programului monitor;
timer: un timer este folosit pentru a evita monopolizarea procesorului de ctre un
singur job;
instruciuni privilegiate: cteva instruciuni sunt considerate privilegiate i trebuie
luate n considerare doar de ctre monitor. Dac procesorul ntlnete astfel de
instruciuni la executarea unui program utilizator trebuie s-i ntrerup execuia i s
genereze o ntrerupere. In cazul n care un program utilizator vrea s execute o
operaie de citire sau scriere la un dispozitiv de I/O trebuie s se adreseze
procesorului;
ntreruperi: modelele mai vechi nu aveau prevzute ntreruperi dar duc la creterea
flexibilitii monitorului.
Urmtorul pas n evoluia calculatoarelor i implicit al sistemelor de operare l-a
constituit apariia circuitelor integrate. Odat cu evoluia sistemelor de operare au aprut
conceptele de multiprogramare sau multitasking. Primul sistem de operare care a ncercat s
trateze problemele at n cazul sistemelor mari de calcul ct i a calculatoarelor mai puin
performante a fost 360/OS.
Cu toate ca multiprogramarea este eficient, este nevoie de obinerea unui mod de
lucru pentru o interaciune mai bun a utilizatorului cu calculatorul. Din acest motiv a fost
necesar apariia sistemelor cu time-sharing (timp distribuit). In aceste cazuri timpul
procesorului este distribuit ntre mai muli utilizatori. In astfel de sisteme mai muli utilizatori
acceseaz sistemul prin intermediul mai multor terminale.
Diferenele ntre cele 2 sisteme prezentate constau n faptul c obiectivul principal l
const maximizarea timpului de utilizare al procesorului pentru sistemele de multiprogramare
n loturi i minimizarea timpului de rspuns pentru cele cu time-sharing. In ceea ce privete
modul de obinere al instruciunilor de ctre sistemul de operare, n primul caz apare limbajul
de control al joburilor iar n cel de al doilea sunt introduse comenzi de la terminal.
n partea a doua a anilor 80 microcalculatoarele cunosc o dezvoltare extraordinar. Se
disting 2 evoluii principale n ceea ce privete sistemele de operare. Pornind de la sistemul de
operare DOS, pe care l achiziioneaz de la firma care l-a dezvoltat, Bill Gates dezvolt MS-
DOS, sistem de operare distribuit mpreun cu calculatoarele IBM. Inspirndu-se probabil din
interfaa Apple Macintosh, Microsoft scoate o interfat Windows 3.1 pentru sistemul de
operare DOS iar apoi Windows 95 care vroia s fie un sistem de operare chiar dac pornea din
MS-DOS. Modificri uoare au condus la Windows 98. Un sistem de operare care lucra pe 32
de bii a fost Windows NT, cu versiunea ulterioar denumit comercial Windows 2000.
Evoluiile ulterioare au nsemnat Windows XP respectiv recent, Vista.
Cealalt abordare are ca punct de pornire sistemul de operare Multics i are ca rezultat
UNIX. Datorit faputlui c era disponibil codul acestuia, unele companii i-au dezvoltat
propriile versiuni fiind necesar astfel apariia unui standard, i anume POSIX. Linus Torvalds
va porni de la o variant redus de UNIX i va scrie ceea ce va deveni Linux. Diferite
Pagina 7
distribuii de Linux au evoluat i sunt prezente pe pia ca o alternativ la produsele oferite de
Microsoft.
Pagina 1
Curs 2 Shell scripting (1)

2.1. Structura de fiiere
Una dintre cele mai importante caracteristici Linux este modul n care trateaz fiierele. n Linux
totul este organizat sub form de, adic programele pot utiliza fiiere de pe discuri, porturile seriale,
imprimantele i alte dispozitive n acelai mod n care utilizeaz fiierele. Acest fapt faciliteaz
programarea, deoarece nu mai trebuie avut grij dac se lucreaz cu un terminal, fiier pe disc sau cu
o imprimant.
Sistemul de operare Linux utilizeaz trei tipuri de fiiere:
Fiiere obinuite sunt doar colecii de octei asupra crora sistemul nu impune nici o
structur particular. Acestea sunt utilizate pentru fiierele text, fiierele de date pentru programe
i chiar pentru fiierele executabile ale programelor.
Cataloage un catalog este un mecanism care permite seturilor de fiiere s fie grupate
mpreun. Conceptual reprezint un container n care pot fi plasate alte fiiere i cataloage. De
fapt catalogul conine doar numele fiierelor i informaii despre locaia acestora. Deoarece un
catalog poate conine sub cataloage avem de-a face cu o structur ierarhic.
Dispozitive aceast categorie este alctuit din anumite tipuri de fiiere, cum ar fi cele
asociate comunicaiei ntre procese sau cele asociate comunicaiei cu diverse dispozitive hardware
ca terminale, CD-ROM, modem, etc.
Toate aceste fiiere sunt organizate ntr-o structur ierarhic arborescent, avnd ca i vrf un
singur catalog care poart numele de rdcin, el fiind reprezentat prin urmtorul simbol /. Acest
catalog rdcin conine o serie de alte cataloage ce au destinaii speciale. Aceste destinaii sunt
doar convenii i nu sunt obligatorii.
Semnificaia acestor cataloage:
/bin executabilele comenzilor
/dev fiierele speciale
/etc fiierele de configurare
/home cataloagele utilizatorilor
/lib bibliotecile standard
/mnt se vor mount-a alte sisteme de fiiere(partiii)
/sbin comenzi de administrare
/tmp fiiere temporare
/usr date disponibile utilizatorilor
/var fiiere mari n cazuri speciale

Pagina 2

Este posibil ca dou fiiere s aib acelai nume atta timp ct sunt n cataloage diferite,
referirea acestor fiiere fcndu-se prin intermediul numelui de cale. Acesta poate fi:
- absolut ca punct de referin se ia catalogul rdcin, ex:
/home/user/a
/home/dev/a
- relativ punctul de referin este reprezentat de un catalog arbitrar:
/user/a
/user/b
La fiecare schimbare a catalogului noul catalog devine catalogul curent de lucru. Acest lucru
este foarte important deoarece pentru fiecare program executat n Linux va rezulta un proces care va
avea ca parte a strii lui interne i catalogul curent de lucru. Acesta fiind catalogul utilizat ulterior
pentru referiri bazate pe calea relativ. Dac procesul nu face aranjamente specifice pentru a utiliza
un alt catalog de lucru, atunci implicit va utiliza catalogul n care a fost utilizatorul cnd programul a
fost pornit.
Fiecrui fiier, stocat pe disc, indiferent de tipul su i este asociat un numr numit inode care
reprezint de fapt un index al unei intrri ntr-un ir stocat pe disc. Fiecare element al irului este un
inode care stocheaz in formaii specifice unui anumit fiier (cnd a fost creat, cine este proprietarul
bin dev etc home lib sbin tmp usr var
X11 adm bin lib local man src
linux src lib bin
mnt
Fig 2.1. Ierarhia de cataloage sistem
Fig. 2.2 Fiiere organizare fizic
Pagina 3
i unde sunt stocate blocurile de date pentru fiierul respectiv). Un catalog conine pe lng numele
fiierului i numrul de inode asociat acestuia. Fiecare pereche nume inode dintr-un catalog poart
numele de legtur sau link. n acest fel este posibil ca acelai nume de inode s apar n unul sau mai
multe link-uri. Aceasta ar nsemna ca un fiier poate avea unul sau mai multe nume de cale valide.
2.2. Comenzi uzuale
Imediat dup intrarea n sistem, implicit utilizatorul va fi plasat ntr-un catalog asociat cu numele
de login numit home. Acesta va fi catalogul curent de lucru iniial.
pwd - present working directory(catalog de lucru prezent). Afieaz calea absolut pentru
catalogul curent.
cd change directory.
ls Lista cu intrrile din catalogul curent. n funcie de opiuni lista afiat se poate modifica.
Comenzi pentru lucrul cu directoare:
mkdir creeaz un nou director
rmdir terge directorul/directoarele primite ca i argument.
Comezi pentru lucrul cu fiiere:
cp comanda de copiere.
touch actualizeaz timpul de acces al fiierului primit ca i argument. Daca fiierul nu exist
atunci va fi creeat.
rm comanda de tergere.
cat poate avea mai multe obiective: afieaz, creeaz, concateneaz fiierele primite ca i
argument.
Grep - permite cutarea unui nume sau a unui format de nume n fiierul primit ca i argument.
Va deschide fiierul respectiv i va afia fiecare linie din fiier n care se gsete cuvntul
cutat.

Interpretorul de comenzi

2.3. Prezentare general interpretor de comenzi
Interpretorul de comenzi este un program care realizeaz o interfa ntre utilizator i sistemul de
operare, interfa care preia comenzile utilizatorului i le transmite sistemului de operare spre
execuie. Pentru UNIX i clonele acestuia (Linux) interpretoarele de comenzi sunt independente fa
de sistemul de operare ceea ce a dus la dezvoltarea unui numr mare de astfel de interpretoare.
Primul interpretor de comenzi important, numit Bourne shell, a fost dezvoltat de Steven Bourne
i a fost inclus ntr-o distribuie de UNIX lansat n 1979. Acest interpretor de comenzi este cunoscut
n cadrul sistemului de operare sub numele de sh. Un alt interpetor de comenzi utilizat pe scar larg
este C shell cunoscut i sub numele de csh. Csh a fost scris de Billy Joy ca parte integrant a unei
distribuii de UNIX numit BSD (Berkley System Distribution), i a aprut la civa ani dup sh. Numele
de Csh l-a primit datorit asemnrii sintaxei comenzilor sale cu cea a instruciunilor limbajului C, fapt
ce l face mult mai uor n utilizare celor familiarizai cu limbajul C. Toate aceste interpretoare au fost
iniial dezvoltate pentru Unix dar s-au dezvoltat versiuni ale acestora i pentru Linux.
Pagina 4
Unul dintre cele mai cunoscute interpretoare de comenzi pentru Linux este bash (bourne again
shell).La intrarea n sistem fiecare utilizator primete o copie a interpretorului de comenzi. Acesta
pstreaz un mediu distinct pentru fiecare utilizator din sistem. n multe sisteme Linux comanda
/bin/sh este de multe ori un link ctre interpretorul de comenzi utilizat de ctre sistemul de operare.
Interpretorul de comenzi din Linux dei are unele similitudini cu procesorul de comenzi DOS este un
instrument mult mai puternic oferind utilizatorului o multitudine de faciliti.
2.4. Caracteristici
Expandarea numelor de cale n exemplele de pn acum s-au folosit numai nume de cale
complet precizate. Exist mai multe metode prin care numele de cale s fie abreviate, iar
interpretorul de comenzi va expanda aceste nume nainte de ale transmite comenzilor. Un astfel de
caracter de abreviere este *. De exemplu
$ cp text/* backup
Aici prin * se nelege toate fiierele (cu excepia celor ce ncep cu .) din catalogul text. Sensul
comenzii este toate fiierele din catalogul text vor fi copiate n catalogul backup. Un alt caracter
special utilizat n numele fiierelor pe care interpretorul de comenzi le va expanda este semnul
ntrebrii ?. Rolul acestuia este de a substitui un singur caracter :
$ ls /dev/tty?
/dev/tty0 /dev/tty2 /dev/tty4 /dev/tty6 /dev/tty8
/dev/tty1 /dev/tty3 /dev/tty5 /dev/tty7 /dev/tty9
De asemenea este posibil precizarea unei liste de caractere, i numai caracterele coninute n
aceast list s poat fi expandate. Aceast list este delimitat de paranteze drepte ([]).Ex:
$ ls /dev/tty[pq][235]
/dev/ttyp2 /dev/ttyp3 /dev/ttyp5 /dev/ttyq2
/dev/ttyq3 /dev/ttyq5
O ultim form de expandare pentru numele de cale este prin precizarea unei liste de cuvinte,
cuvintele vor fi separate prin virgul i cuprinse ntre paranteze {}. Ex:
$ mkdir /usr/tmp/{bin,doc}
Toate numele de cale sunt expandate de interpretorul de comenzi nainte a fi transmise ctre
comenzi.n cazul n care se dorete utilizarea caracterelor speciale cu sensul lor iniial se poate utiliza
unul din urmtoarele trei mecanisme de marcare:
- caractere escape(\) caracterul backslash indic interpretorului de comenzi s ignore sensul
special al caracterelor de dup marcaj. Ex: \*.
- ghilimele orice ir de caractere cuprins ntre aceste marcaje i pierde sensul special al
tuturor caracterelor cuprinse n el. Ex: a*?
- ghilimele duble un ir de caractere pierde sensul special al caracterelor cuprinse n el
(este valabil numai pentru caracterele prezentate pn acum) , cu excepia caracterelor $ i \.
Ex:
`cmd`
Executa comanda cmd. De exemplu: $ cale=`pwd` atribuie variabilei cale rezultatul comenzii pwd.
Redirectarea ieirii i a intrrii Filosofia de baz Linux este aceea de ine lucrurile ct mai
simple posibil, prin punerea la dispoziia utilizatorului a unui numr mare de funcii simple. Iar prin
gruparea acestor funcii mpreun se pot obine comenzi mai complexe. Implicit, majoritatea
Pagina 5
comenzilor Linux sunt configurate astfel nct intrarea acestora s o reprezinte tastatura iar datele de
ieire sunt trimise ctre monitor. n unele situaii ar fi util dac intrarea , respectiv ieirea unei comenzi
ar fi altele dect cele implicite. Unele comenzi au aceast facilitate, dar dac pentru fiecare n parte s-
ar prevedea acest lucru dimensiunea executabilelor ar crete, de aceea aceast sarcin i-a asumat-o
sistemul de operare prin intermediul acestui mecanism de redirectare.
Un exemplu clasic este cel de creare a unui nou fiier prin care ieirea standard a comenzii cat este
redirectat ctre fiierul care urmeaz a fi creat:
$ cat > text
Un text de exemplu
Ctrl-d
$
Se observ c n aceast situaie se folosete caracterul >. Acesta are rolul de a indica redirectarea
ieirii standard ctre o alt comand. Dac este urmat de un nume de fiier atunci acest fiier este
creat dac nu exist, iar dac exist atunci va rescris. Un alt simbol utilizat de acest mecanism de
redirectare este >>. n cazul n care ieirea este reprezentat de un fiier datele redirectate vor fi
concatenate la sfritul fiierului. Ex:
$ ls l /usr/bin >>text
Rezultat: toate numele fiierele din /usr/bin, mpreun cu informaiile despre acestea sunt adugate
la fiierul text. Tot la fel cu redirectarea ieirii se poate redirecta i ieirea de eroare:
$ ls /usr/bin 2>text.err
La fel cum se poate realiza redirectarea ieirii standard, la fel se poate redirecta i intrarea standard:
$ wc l < /etc/passwd
12

Pipes sau conectarea proceselor prin redirecionarea ieirii standard a unei comenzi ntr-un fiier,
iar apoi redirecionarea aceluiai fiier ca i intrare standard pentru alt comand se pun practic n
legtur dou procese prin intermediul unui fiier temporar. Acest lucru se poate face implicit de ctre
sistemul de operare prin intermediul unui pipe. Pentru aceasta se folosete operatorul |.
De exemplu seria de comenzi:
$ ls /usr/bin > /tmp/temp.txt
$ wc w </tmp/temp.txt
500
$ rm /tmp/temp.txt
poate fi nlocuit prin:
$ ls /usr/bin | wc w
500

Controlul proceselor Permite ntreruperea unui proces i de asemenea reluarea execuiei acelui
proces la un moment de timp ulterior. ntreruperea execuiei unui proces se poate face direct de la
tastatur prin secvena Ctrl-z, dup care procesul va fi ntrerupt iar utilizatorul reprimete controlul
putnd executa alte comenzi.
Pagina 6
$ cat > file.txt
Ctrl-z
[1]+ Stopped
$
Pentru gestionarea proceselor interpretorul de comenzi are implementate o serie de comenzi:
- fg este comanda prin care este reluat execuia unui proces, aceasta poate primi ca i
parametru numrul de ordine al procesului ntrerupt. Pentru a relua execuia ultimului proces
ntrerupt avem:
$ fg %1
cat >file.txt
- bg se folosete pentru suspendarea unui proces, echivalent cu Ctrl-z
- jobs afieaz procesele suspendate.
Alte faciliti ale interpretorului de comenzi Linux:
- history: posibilitatea de rechemare rapid a ultimilor comenzi executate.
- command complition: afiarea posibilelor comenzi pornind de la primele caractere ale
numelor acestora.
2.5. Sintaxa
Programarea n cazul interpretorului de comenzi se face n acelai mod ca i n cazul altor limbaje
de programare. i n acest caz vom avea variabile care n mod normal nu sunt declarate dect atunci
cnd este nevoie de ele. Implicit variabilele sunt memorate i considerate drept iruri de caractere,
chiar i atunci cnd primesc valori numerice. Variabilele pot fi de mai multe tipuri: variabile predefinite
sau speciale, parametrii poziionali sau variabile utilizator.
Variabile predefinite sau speciale la pornirea sistemului o serie de variabile sunt iniializate cu
valorile implicite mediului de operare. Cele mai importante sunt urmtoarele:
$HOME catalogul gazd a utilizatorului curent
$PATH o list de cataloage n care interpretorul caut pentru fiierul executabil asociat unei comenzi.
$SHELL numele interpretorului de comenzi curent.
$PS1 definete prompterul interpretorului, implicit acesta este $.
$IFS Internal Field Separator utilizat pentru separarea cuvintelor i a liniilor .
$0 numele fiierului de comenzi.
$# numrul de parametri transmii fiierului de comenzi.
$$ numrul de identificare prin care sistemul identific scriptul n momentul execuiei.

Parametrii poziionali Dac la apelarea unui fiier de comenzi (script) sunt folosii parametrii
atunci sunt create cteva variabile suplimentare. Chiar dac nu se folosesc parametrii tot se creeaz
variabila $# dar va avea valoarea 0.Variabile de acest tip sunt:
$1, $2, .. parametrii transmii scriptului.
$* - lista cu parametrii transmii scriptului.

Accesarea coninutului variabilei se face prin prefixarea acesteia cu caracterul $.Ex:
$ salut=Hello
$ echo $salut
Hello
Pagina 7
Pentru ca o variabil s fie cunoscut unui subshell aceast comand trebuie s fie exportat. Aceasta
se realizeaz cu ajutorul comenzii export.
Structuri de control i n acest caz se ntlnesc structuri de control la fel ca i n cazul altor limbaje
de programare.
if testeaz rezultatul unui comenzi i n funcie de rezultatul acesteia se execut una dintre
ramurile de declaraii. Format:
if condiie
then declaraii
[ elif condiie
then declaraii]
[ else declaraii]
fi
Se executa condiie; daca codul returnat este zero se executa declaraiile ce urmeaz primului
then. In caz contrar, se executa condiia de dup elif si daca codul returnat este zero se executa
declaraiile de dup al doilea then. Ex:
if test -f $1
then echo $1 este un fiier obinuit
elif test -d $1
then echo $1 este un catalog
else echo $1 este altceva
fi

for folosit pentru trecerea printr-un anumit numr de valori(pot fi i iruri de caractere). Sintaxa:
for nume [in valori]
do declaraii
done

Variabila nume ia pe rnd valorile din lista ce urmeaz lui in. Pentru fiecare valoare se executa
ciclul for. Daca in valori este omis, ciclul se executa pentru fiecare parametru poziional. Condiia poate
fi si in * , caz in care variabila nume ia pe rnd ca valoare numele intrrilor din directorul curent.
while n cazul n care se dorete trecerea printr-un numr mai mare de valori este util folosirea
acestei structuri de control. Sintax:
while condiie
do declaraii
done

until ciclu identic cu for dar n acest caz testarea condiiilor se face la sfrit. Sintax:
until lista_1
do lista
done

case aceast structur are sintaxa:
case condiie in
ablon_1) declaraii;;
Pagina 8
ablon_2) declaraii;;
...
esac
Se compara condiie cu fiecare din abloanele prezente si se executa lista de comenzi unde se
constata potrivirea.
Proceduri shell reprezint o modalitate de a grupa mai multe comenzi shell la un singur loc n
vederea execuiei lor ulterioare. Forma general a unei astfel de proceduri este:
nume() { lista; }
Unde nume este numele procedurii (sau funciei), iar lista este o list de comenzi ce urmeaz s
fie executate. Ex:
$ lsl() { ls l; }

Cteva comenzi specifice interpretoarelor de comenzi:
Test este folosit pentru a pentru a testa o expresie dac este adevrat atunci test va returna
0, n caz contrar va returna 1. Test poate fi utilizat pentru operaii matematice, cu iruri de caractere
sau fiiere:
Operaii matematice:
-eq egalitate
-ne diferena
-lt mai mic
-le mai mic sau egal
-gt mai mare
-ge mai mare sau egal

Operaii cu iruri de caractere:
ir1 = ir2 egalitate
ir1 != ir2 diferena
-n ir1 diferit de NULL
-z ir1 este NULL

Operaii cu fiiere:
-s test f fiier adevrat dac fiierul nu este gol
-f test f fiier adevrat dac fiierul este unul obinuit
-d test d fiier adevrat dac fiierul este catalog
-w test w fiier adevrat dac fiierul poate fi deschis pentru scriere
-r test r fiier adevrat dac fiierul poate fi deschis doar pentru citire
-x test x fiier adevrat dac fiierul este executabil
-e test e fiier adevrat dac fiierul exist

Operatori logici
! expresie negare
expresie1 a expresie2 logic I
expresie1 o expresie2 logic SAU

Pagina 9
Expr identificator pentru operaii matematice. Ex: $ expr 1 + 3
Export face disponibile variabilele primite ca i argument n subshell-urile viitoare. Implicit
variabilele create ntr-un shell nu sunt disponibile ntr-un shell creat ulterior.
Echo afieaz argumentele la ieirea standard
Eval realizeaz evaluarea i apoi execuia argumentelor
Exit foreaz ntreruperea procesului curent care va returna ca i cod de ieire valoarea primit
ca i argument. Ex: Exit n
Read citete o linie din fiierul standard de intrare.
Break Comanda de prsire a celei mai interioare bucle for, while sau until ce conine break.
Daca n este specificat se iese din n bucle.
Continue comanda permite trecerea la o nou iteraie a buclei for, while sau until.
Return revenirea dintr-o funcie cu valoarea n, unde n este valoarea transmis ca i argument.
Dac aceast valoare nu este precizat atunci codul returnat este cel al ultimei comenzi executate.
Set folosit pentru activarea sau dezactivarea unor opiuni sau pentru poziionarea unor
parametrii poziionali.
Sleep suspend execuia pentru un numr n de secunde primit ca i argument.

Pagina 1
Curs 3 Shell scripting (2)

3.1. Interfaa cu utilizatorul
n cadrul unui program shell script interfaa cu utilizatorul se poate realiza prin dou mecanisme:
- Prin argumente transmise n linia de comand. Aceast metod este de altfel preferat pentru
c permite gruparea ntr-o secven de comenzi nlnuite, ieirea comenzii precedente
devenind intrare pentru comanda urmtoare. La baza acestui mecanism stau comenzile pipe,
i de redirectare a intrrii/ieirii
ls -lR /home/student | grep ".tar.gz" | uniq | wc -l

- Prin comenzi ce permit interaciunea cu terminalul, respectiv cu utilizatorul. Reprezentative
pentru aceast categorie sunt echo i read.
Echo afieaz la ieirea standard mesajul primit ca i argument.
Read citete valoarea primit de la intrarea standard i o salveaz n variabila primit ca i
argument.
echo Nume:
read nume
echo Varsta:
read varsta
calc=`expr $varsta + 1`
echo Anul viitor $nume va avea $calc ani

Mecanismele de interfaare cu utilizatorul, includ, de obicei, metode mai avansate de
interfaare, ce permite crearea de interfee elaborate. In cazul shell script, nu avem la dispoziie astfel
de mecanisme, sigura excepie e comanda dialog. Comand ce poate fi gsit doare pe anumite
distribuii Linux. Mai jos se poate vedea un exemplu simplu de meniu ce permite interaciunea cu
utilizatorul.
while :
do
clear
echo "-------------------------------------"
echo " Main Menu "
echo "-------------------------------------"
echo "[1] Data"
echo "[2] Fisierele din directorul curent"
echo "[3] Calendar"
echo "[4] Start editor"
echo "[5] Exit"
echo "======================="
echo -n "Optiuni [1-5]: "
Pagina 2
read opt
case $opt in
1) echo "Astazi este `date` , apasa o
tasta. . ." ; read ;;
2) echo "Fisiere in `pwd`" ; ls -l ; echo "Apasa
o tasta. . ." ; read ;;
3) cal ; echo "Apasa o tasta. . ." ; read ;;
4) nano ;;
5) exit 0 ;;
*) echo "Ups!!! Alege 1,2,3,4, sau 5"; echo
"Apasa o tasta. . ." ; read ;;
esac
done

3.2. Liste
Aceste tipuri de construcii ofer posibilitatea de rula secvene de comenzi, putnd nlocui structuri
complicate de tipul if/then. Aceste construcii sunt de doua tipuri:
- Liste de tip I: comanda1 && comanda2 && comanda3 && && comanda. Secvena de
comenzi se execut pe rnd daca rezultatul comenzii anterioare ntoarce valoarea true (zero).
La prima valoare de false execuia lanului de comenzi se ntrerupe.
if [ ! -z "$1" ] && echo "Argument #1 = $1" && [ ! -z
"$2" ] && \
echo "Argument #2 = $2"
then
echo "Toate argumentele sunt definite"
else
echo "Mai putin de 2 argumente au fost transmise
scriptului"
fi

- Liste de tip SAU: comanda1 || comanda2 || comanda3 || || comanda. Spre deosebire de
lista i, comenzile din secvena vor fi executate atta timp ct valoarea ntoars este false. La
prima valoare de true, execuia este suspendat.
[ ! -f "$1" ] && echo "File \"$1\" not found."
[ ! -f "$1" ] || (rm -f $1; echo "File \"$1\" deleted.")

3.3. iruri
O facilitate recent introdus sunt irurile uni dimensionale. Elementele irurilor pot fi iniializate
astfel: variabila[index] . Pentru a accesa coninutul unui element al irului se folosete urmtoarea
notaie: ${variabila[index]}
Pagina 3
data[10]=1
data[11]=string
echo ${data[10]} #1
echo ${data[5]} #empty
echo ${data[11]} #string

De asemenea se poate iniializa ntregul ir astfel: sir=( element1 element2 elementN ). Pentru
a realiza operaii asupra tipul de date ir au fost adaptai o serie de operatori specifici Bash
sir=( zero unu doi trei patru cinci )
#accesare continut
echo ${sir[0]} #zero
echo ${sir:0} #zero
echo ${sir[1]:1} #nu

#lungime element
echo ${#sir[0]} #4
echo ${#sir[1]} #3

#lungime sir
echo ${#sir[*]} #6
echo ${#sir[@]} #6

echo ${sir[@]} #zero unu doi trei patru cinci

Aa cum se poate vedea mai sus expresiile ${sir[@]} sau ${sir[*]} se refer la toate elementele din
ir. Pentru a determina lungimea, att pentru ir ct i pentru elemente se folosete operatorul #
${#sir[@]}, respectiv ${#sir[index]}
Spre deosebire de variabilele normale, un ir poate fi declarat prin declare -a, interpretorul de
comenzi considernd variabila astfel definit ca fiind ir
declare -a culori
echo "Introduceti o lista de culori separate prin
spatiu:"
read -a culori
echo "Count ${#culori[@]}"
required=rosu
prezent=0
for i in ${culori[*]}
do
echo $i
if [ $i = $required ]; then
prezent=1
fi
Pagina 4
done
if [ $prezent -eq 0 ]; then
echo "$required lipseste ..."
culori[${#culori[@]}]=$required
fi
echo "${culori[*]}"

3.4. Expresii regulate
Sunt seturi de caractere ce permit identificarea unor modele n cadrul irurilor de caractere. O
expresie regulat conine urmtoarele:
- Un set de caractere definesc secvena cutat. Cea mai simpl form a unei expresii regulate
const dintr-un singur caracter.
- O ancora definete poziia n cadrul liniei de text, unde expresia regulat caut modelul, Ex:
^ - inceputul irului, $ - finalul irului.
- Modificatori extind sau limiteaz aria textului n care expresia regulat caut modelul. Din
aceast categorie fac parte: *, [], \.
Expresiile regulate sunt destinate operaiilor cu iruri de caractere. Ele opernd pe iruri de
caractere de la un caracter pn la parte din ir sau irul complet. Expresiile regulate nu pot fi folosite
direct n operaiile cu iruri de caractere din cadrul bash, ci doar prin intermediul unor comenzi de
tipul grep sau awk.
Operatori:
- * - indic zero sau mai multe repetri ale expresiei precedate. Ex aabb* e corect pentru
aab,aabb,aabb
- . indic un singur caracter. Ex ab. Secvenele text pentru care expresia e corect o s
nceapa cu ab i trebuie s conin cel puin nc un caracter (abb), dar nu e corect pentru ab
simplu.
- ^ - n funcie de context poate avea dou semnificaii: indic nceputul liniei sau neag
semnificaia unui set de caractere in cadrul expresiei regulate
grep ^student /etc/password

- $ - indic finalul liniei:
o xx$ secvena cutat trebuie s apar la finalul liniei
o ^$ caut o linie goal
grep ^$ /etc/password
grep /bin/bash$ /etc/password

- [] definesc lista de caractere ce pot aprea n secvena cutat:
o [xyz] oricare din caracterele x,y,z
o [a-e] oricare caracter de la a la e
o [A-Ea-e] lista include i literele mari
o [0-9] doar cifre
o [^b-d] toate caracterele cu excepia celor de la b la d
Pagina 5
grep [Ss]tudent /etc/password

- \ - are rol de caracter escape caracterele prefixate de \ i pierd sensul special i sunt utilizate
ca simple caractere. Ex \$
- <> - secvena cutat este un cuvnt, delimitat de spaii albe.
cat > text
cuvantul e delimitat de spatii albe
cu <> se poate cauta un cuvant
Ctrl-d

grep \<cu\> text

3.5. Awk
Este o comand externa bash, ce aduce funcionalitate suplimentar n partea de manipulare de
date. Sintaxa generala este:
awk f {program awk} fisier
Un program awk va avea urmtoare structur general:
Model {
Aciune 1
Aciune 2

} END
Awk va citi linie cu linie de la fiierul primit ca i argument (sau de la intrarea standard), va compara
respectiva linie cu modelul (dac un model este definit). Dac modelul potrivete, atunci va aplica
asupra liniei respective aciunile definite.
Model poate fi:
- Expresie regulat folosit pentru filtrarea nregistrrilor
- BEGIN bloc ce definete aciunile ce au loc nainte de procesarea nregistrrilor
END definete aciunile ce au loc dup procesarea nregistrrilor
cat > lista
pop 10
marin 9
dorin 10
dorel 8
ionel 7
Ctrl-d

Pagina 6
awk /do*/'{print $1":"$2}' lista
dorin:10
dorel:8

n exemplul de mai sus fiecare linie reprezint o nregistrare, iar fiecare cuvnt din linie reprezint
un cmp. Un cmp este delimitat print-un spaiu, iar identificarea cmpului se face prin variabile
poziionale speciale $1,$2
Awk are un set de variabile predefinite:
- FILENAME numele fiierului de intrare
- RS separatorul liniei de intrare (Implicit caracterul linie nou)
- OFS separatorul pentru cmpul de ieire
- ORS separatorul liniei de ieire
- NF numrul de cmpuri pe linia curent
- NR numrul nregistrrii
- FS separatorul de cmp (implicit caracterul spaiu sau tab)
cat /etc/passwd | grep 'bash$'| awk
'BEGIN{FS=":" }{print NR": "$1" "$NF}'
1: root /bin/bash
2: mysql /bin/bash
3: b624 /bin/bash
4: student /bin/bash
Awk fiind bazat pe limbajul C ofer posibilitatea de a realiza operaii matematice:
$ls l fisiere
-rw-rw-r--. 1 student student 40 Mar 3 20:25 lista
-rw-rw-r--. 1 student student 305 Mar 3 20:25 sir
-rw-rw-r--. 1 student student 68 Mar 3 20:25 text
$ls -l fisiere | awk 'BEGIN
{total=0}{total+=$5}END{print "Total:"total}'
Total:413
Totodat permite definirea de structuri de control de tipul if, for, while asemntoare ca sintax
limbajului C.
3.6. Subshells i shell-uri restricionate
La lansarea n execuie a unui shell script, interpretorul de comenzi creeaz nu proces nou numit
subshell. n aceeai manier n care o comand este lansat n execuie n cadrul unui proces separat,
un shell script va rula o secven de comenzi dar ntr-un proces copil (subshell) al interpretorului de
comezi. Un shell script poate lansa la rndul lui procese copil, ceea ce permite o execuie paralel a
scriptului.
Definirea explicit a unui subshell se realizeaz prin (). Ex: (comanda1; comanda2; comanda3; ). O
list de astfel de comenzi va rula ntr-un subshell.
var=old
(var=new)
Pagina 7
echo $var

Variabilele definite ntr-un subshell nu sunt vizibile n afara blocului de cod definit de paranteze.
Ele nu sunt accesibile procesului printe, fiind de fapt variabile locale procesului fiu. De asemenea
schimbrile de directoare nu sunt vizibile n cadrul procesului printe.
O posibil utilizare a acestui mecanism const n definirea unui mediu de rulare particularizat
pentru anumite comenzi:
COMANDA1
COMANDA2
COMANDA3
(
IFS=:
PATH=/bin
COMANDA4
COMANDA5
exit 3
)
# Parintele nu a fost modificat.
COMANDA6
COMANDA7

O secven de cod definit in paranteze {} nu lanseaz un nou subshell.
Shellurile restrincionate reprezinta o caracteristic special, ce poate fi utilizat n cazul n care
scriptul urmeaz s fie rulat in medii n care anumite comenzi e necesar s fie dezactivate. Aceast
msur limiteaz privilegiile cu care este rulat scriptul, pentru a minimiza posibilele daune.
Modul de rulare restricionat pentru un script poate fi activat astfel:
- Folosind #!/bin/bash r n antetul scriptului ntreg scriptul ruleaz n modul restricionat
- Folosind comada set r doar secvena de cod ce urmeaz va fi restricionat
Urmtoarele comenzi i aciuni sunt dezactivate:
- Cd posibilitatea de a schimba directorul curent
- Modificarea variabilelor $PATH, $SHELL, $BASH_ENV sau $ENV
- Redirectarea ieirii
- Invocarea comenzilor ce conin /
- Invocarea comenzii exec
- Anularea modului restricionat
set -r
echo "Director curent `pwd`" )
cd ..
echo "Director curent `pwd`" )

Pagina 1
Curs 4 Make, Fiiere

4.1. Make Introducere
Make este una dintre uneltele care mbuntesc eficiena n medii de lucru de genul Linux/UNIX.
n principiu este un generator de comenzi care pe baza unui fiier de descriere creeaz o secven de
comenzi ce trebuie executate de ctre interpretorul de comenzi Linux. Make este o unealt folosit n
general pentru determinarea relaiilor de dependen ntre fiiere. n situaia n care se lucreaz la un
proiect ce implic utilizarea mai multor fiiere surs, dac unul sau mai multe fiiere surs sunt
modificate atunci procesul de recompilare trebuie reluat, dar n general nu este necesar ca acest
proces s fie reluat n ntregime de obicei fiind necesar recompilarea doar a acelor surse ce au fost
modificate. n acest context make este o unealt esenial putnd determina dependene ce pot
aprea ntre diverse fiiere. Ca i concept de programare n ansamblu make este non-procedural, dei
intrrile individuale se execut. Comenzile ce trebuie executate sunt determinate printr-un proces
iterativ de determinare a dependenelor fiierelor ce trebuie prelucrate. Forma general de apelare a
acestui utilitar este:
$make program

Aceast sintax indic faptul c se dorete executarea tuturor operaiilor de determinare a
dependenelor ntre fiiere i de compilare a acestora necesare pentru crearea executabilului
program. n aceast situaie apare noiunea de int care este reprezentat de program, totodat
acesta este construit din una sau mai multe dependene, fiecare dintre acestea putnd avea la rndul
lor inte pentru alte dependene. Caracteristica esenial a acestui utilitar este aceea c fiecare nou
apelare a acestuia va determina evaluarea n lan tuturor dependenelor i prelucrarea n final doar a
celor pentru care s-au constatat modificri. Funcionarea utilitarului make se bazeaz pe structur
ierarhic de tipul surs-obiect i obiect-executabil. Programatorul este responsabil pentru precizarea
unor dependene prin intermediul unui fiier numit makefile, restul fiind determinate pe baza timpului
ultimei modificri i a unui set de reguli.
Fiierul de descriere:
S presupunem c avem un program destinat unor prelucrri de date alctuit din trei fiiere:
main.c, interfata.c, prelucrari.c. O compilare manual a programului arat astfel:
$ gcc main.c
$ gcc interfata.c
$ gcc prelucrare.c
$ gcc o exemplu main.o interfata.o prelucrari.o
/usr/lib/my_lib.a

n acest caz particular ntreaga compilare a programului se poate face ntr-o singura linie de
comand, dar n cazul proiectelor de mari dimensiuni la care lucreaz mai multe persoane acest lucru
este practic imposibil. Pentru a putea utiliza make trebuie creat un fiier de descriere numit makefile
care n acest caz are urmtoare structur:
Pagina 2
exemplu : main.o interfata.o prelucrari.o
/usr/lib/my_lib.a
gcc o exemplu main.o interfata.o prelucrari.o
/usr/lib/my_lib.a
main.o : main.c
gcc c main.c
interfata.o : interfata.c
gcc c interfata.c
prelucrari.o : prelucrari.c
gcc o prelucrari.c

n cazul acestui fiier de descriere se pot observa patru intrri, fiecare intrare constnd din dou
elemente distincte o linie numit linie de dependene i una sau mai multe linii de comenzi. Pentru
acest exemplu intele sunt: exemplu, main.o, interfata.o, prelucrari.o. Liniile de comenzi trebuie s
nceap cu un caracter tab. ntr-un fiier makefile comentariile sunt delimitate de caracterul # i
continu pn la sfritul liniei.
O alt caracteristic este flexibilitatea ntr-un fiier de descriere se pot preciza mai multe
programe executabile care s fie realizate. Astfel la fiierul de descriere anterior se pot aduga
urmtoarele linii:
exemplu_text : main_text.o prelucrari.o
gcc o exemplu_text main_text.o prelucrari.o

main_text.o : main_text.c
gcc c main_text.c

Vom avea dou interfee diferite pentru acelai program. Pentru make exemplu vom avea un
program cu o interfa grafica, pe cnd pentru make exemplu_text, vom avea aceeai aplicaie de
prelucrri de date dar care va opera din linia de comand. Cel mai simplu mod de apelare make este
fr nici un parametru:
$ make

n acest caz se va realiza prima int gsit n fiierul de descriere makefile, bineneles mpreun
cu toate dependenele sale.
O ultim observaie este faptul c putem avea inte fr dependene, iar multe dintre acestea nu
sunt nici mcar fiiere. De exemplu multe fiiere de descriere conin inta clean destinat eliminrii
fiierelor temporare obinute n urma procesului de compilare.
clean :
/bin/rm f *.o

Pagina 3
4.2. Macro (variabile)
n cazul aplicaiilor de dimensiuni mai mari i nu numai la realizarea fiierelor de descriere se poate
observa repetarea unui anumit numr de elemente putndu-se ajunge la dimensiuni relativ mari ale
acestor fiiere. Pentru a preveni aceast situaie se vor utiliza macrouri i sufixe.
Definiiile de macrouri din cadrul fiierelor de descriere vor arta astfel:
nume = sir de caractere.

Iar referirea acestora se va face prin construcii de genul:
$(nume) sau ${nume}

Reguli de sintax:
O definiie macro este o linie care conine semnul egal. Make asociaz numele din stnga
semnului egal cu secvena de caractere care urmeaz n partea dreapt. Pentru ca make s fac
deosebirea ntre o linie de comand i un macro, naintea acestuia nu este permis un caracter tab. De
asemenea pentru a diferenia un macro de o linie de dependene nu este permis apariia caracterului
; naintea semnului egal. Alt caracter cu semnificaie special este \ care indic faptul c linia curent
se continu pe linia urmtoare, acest caracter este nlocuit de ctre make cu un spaiu. Toate spaiile,
tab-urile i linie nou sunt nlocuite cu un singur spaiu.
Prin convenie numele de macrouri se scriu cu caractere mari. n acestea pot aprea orice
combinaie de caractere mari mici dar se recomand evitarea caracterelor speciale n special \ i >.
Pentru referirea unui macro se utilizeaz de obicei notaia n paranteze sau n acolade
precedat de semnul $. Cele a cror nume este alctuit dintr-un singur caracter nu cer utilizarea n
mod obligatoriu a unei paranteze. De exemplu considernd urmtorul macro:
A=cpp
Acesta poate fi referit astfel: $A, $(A), ${A}.
Aceste structuri sunt flexibile permind utilizarea de macro-uri n noi definiii:
ABC = cpp
file = text.$(ABC)
Prin referirea acestui macro $(file) vom avea text.cpp.
Unei definiii macro, care dup semnul egal nu are nici un caracter, i se va atribui irul nul.
O alt caracteristic a acestui utilitar este faptul c nu trebuie inut cont de ordinea n care aceste
macro sunt definite, uurnd definirile imbricate. Ex:
SOURCES = ${MY_SRC} ${SHARED_SRC}
MY_SRC = analizeaza.c prelucreaza.c
SHARED_DIR = /home/proiect/src
SHARED_SRC = ${SHARED_DIR}/depend.c

Pagina 4
Indiferent de ordinea definiiilor de mai sus ${SOURCES} va avea urmtoarea form:
analizeaza.c prelucreaza.c /home/proiect/src/depend.c
Orice definire de macro trebuie s aib loc nainte de linia de dependene n care acesta apare. Aceast
libertate de declarare implic totui o limitare: un macro nu poate definit ntr-o parte a fiierului i
apoi redefinit deoarece make utilizeaz ultima definiie pentru toate referirile acestuia.
Pe lng macrourile definite de ctre utilizatori exist o serie predefinite, cele mai cunoscute sunt
${CC} utilizat pentru a defini compilatorul de C curent i ${LD} indic linker-ul utilizat.
Utilitatea utilizrii unui macro pentru a indica compilatorul de C utilizat pentru proiectul curent se
poate observa n mediile de dezvoltare volatile n care compilatoarele sunt frecvent schimbate. Ex:
CC = cc
HelloWorld.o : HelloWorld.c
${CC} c HelloWorld.c
va avea acelai efect ca i:
HelloWorld.o : HelloWorld.c
cc c HelloWorld.c

n general fiecare macro care definete o comand (Ex CC) necesit nc un macro care s defineasc
opiunile pentru comanda respectiv. Astfel pentru a preciza diverse opiuni pentru compilatorul de
C (CC) vom avea macroul CFLAGS, iar pentru LD vom avea LDFLAGS.
Un alt mod de definire de macro este din linia de comand:
$ make refext DIR=/usr/proj

De asemenea trebuie inut cont de variabilele intrepretorului de comenzi care fac parte din mediul de
lucru, n momentul apelrii make acestea vor fi considerate ca fiind macro-uri din fiierul de descriere
i pot fi utilizate ca atare. Dac considerm urmtoarea secven de comenzi:
$ DIR = /home/student/proiect
$ export DIR
$ make refext

n acest context variabila DIR poate fi utilizat n cadrul fiierului de descriere:
SRC = ${DIR}/src
refext :
cd ${DIR}/src

Dup cum se poate observa un macro poate fi definit n mai multe moduri: prin intermediul
variabilelor mediului de lucru, din linia de comand, n interiorul fiierului de descriere sau pot fi
macrouri predefinite. Pentru un anumit macro pot aprea conflicte ntre definiiile provenite din
diverse surse. n aceast situaie se pune problema unei structuri de prioriti care s fie urmrit n
cazul unor astfel de conflicte. n ordinea prioritilor vom avea:
Pagina 5
Definiii introduse din linia de comand.
Definiiile din fiierul de descriere.
Variabilele de mediu din aferente interpretorului de comenzi.
Definiiile interne (implicite).
Un alt element important ce apare n cadrul definiiilor de macro este substituirea de irurilor de
caractere. S presupunem c avem urmtoarele definiii:
SRCS = def.c cauta.c calc.c
ls ${SRCS:.c=.o}
rezultatul va fi: def.o cauta.o calc.o
Algoritmul utilizat pentru substituie este urmtorul este urmtorul: se evalueaz expresia ${SRCS}
apoi se caut irul de caractere ce urmeaz n definiie dup caracterul : i este nlocuit cu irul de
caractere de dup semnul =. Aceast facilitate este aplicabil grupurilor de fiiere care difer doar
printr-un sufix. Asupra substituirilor irurilor de caractere se aplic o serie de restricii se pot face
doar la sfritul unui macro sau naintea unui spaiu.
4.3. Reguli de adugare a sufixelor
n sistemele Linux(UNIX) fiierele surs C au ntotdeauna extensia .c, o cerin impus de
compilatorul de cc. Similar fiierele surs Fortran au extensia .f cele pentru limbajul de asamblare au
extensia .s, iar compilatoarele de C i Fortran i plaseaz modulele obiect n fiiere cu extensia .o.
Acest tip de convenii fac posibil utilizarea unor reguli de adugare a sufixelor pentru
simplificarea fiierelor de descriere utilizate de make. Primul exemplu va avea urmtoarea form:
CC = gcc
OBJS = main.o interfata.o prelucrari.o
LIB = /usr/lib/my_lib.a

exemplu : ${OBJS} ${LIB}
${CC} o $@ ${OBJS} ${LIB}
unde prin $@ se specific inta curent pentru make. Un alt macro des utilizat este $?, are rolul de a
determina dependenele ce au fost actualizate n urma intei curente.
Pentru a obine executabilul exemplu utilitarul make verific mai nti dac main.o este up to
date(actual). Realizeaz acest lucru verificnd dac sunt actuale toate fiierele care conform fiierului
de descriere sunt folosite pentru compilarea lui main.o. Dac descoper de exemplu c fiierul main.c
a fost modificat va apela compilatorul de C pentru acel fiier, dac descoper un fiier main.f mai
recent dect main.o atunci va apela compilatorul de Fortran. Dac regulile de adugare a sufixelor nu
sunt precizate, atunci make va utiliza regulile de adugare implicite. Pentru exemplu precizat acestea
sunt:
.SUFFIXES : .o .c .s
.c.o :
$(CC) $(CFLAGS) c $<
.s.o :
$(AS) $(ASFLAGS) c $@ $<

Pagina 6
Linia ce conine .SUFFIXES are forma unei linii de precizare a dependenelor, dar apare o diferen.
irurile coninute n aceast linie sunt sufixele care vor fi considerate de make ca fiind semnificative.
Dac o dependen se termin cu un astfel de sufix, i nu are nici o comand definit n mod explicit
de ctre utilizator, make va cuta o regul ce poate fi aplicat dependenei respective. S considerm
exemplul anterior. La construirea executabilului, make va urma paii:
Va cuta fiecare fiier dependen dat de expresiile ${OBJS} i ${LIB}, care va deveni la
rndul lui int. Aceste operaii sunt realizate pentru a se stabili care fiier trebuie
recompilat nainte de a realiza executabilul final.
Executabilul exemplu depinde printre alte fiiere i de prelucrari.o. Cnd make va cuta
dependenele pentru prelucrari.o va verifica prima dat sunt definiii date de utilizator
care prelucrari.o ca i int. Negsind niciuna va nota ca sufixul semnificativ este .o i va
cuta un alt fiier din directorul curent care s poat fi folosit pentru a construi fiierul
prelucrari.o. Acest fiier trebuie:
o s aib acelai nume(n afar de sufix) cu prelucrari.o.
o s aib un sufix semnificant.
o s poat fi folosit la construcia lui prelucrari.o pe baza unei reguli de adugare a
sufixelor existent.
n cazul exemplului de mai sus toate aceste reguli sunt satisfcute de fiierul prelucrari.c. Regula care
va fi folosit este:
.c.o :
$(CC) $(CFLAGS) c $<

Unde $< are un sens nrudit cu $? dar este valabil doar n cazul regulilor de generare a sufixelor.
Evalueaz care dependen a determinat utilizarea acelei reguli i este fiierul prelucrari.c. Fiierul
cu extensia .o poate fi considerat inta acestei reguli, iar fiierul cu extensia .o dependena.
n continuare make va aplica regula de creare a fiierului prelucrari.o numai dac:
o numai sunt alte dependene care trebuie s fie verificate nainte.
o prelucrari.o este anterior lui prelucrari.c
n final dup ce s-a realizat acest proces pentru fiecare fiier din ${OBJS} i ${LIB}, make
va executa comanda ld pentru a crea fiierul exemplu dac n ierarhia de dependene
exist cel puin un fiier cu o dat de modificare mai recent dect exemplu.
n lista de sufixe ce urmeaz dup .SUFFIXES trebuie s fie cte un spaiu i trebuie s lipseasc
dintre cele dou sufixe care ncep o regul de adugare de sufixe.
CC = gcc
CFLAGS = -g
LD = $(CC)
LDFLAGS =
RM = rm

EXE = exemplu
SRCS = main.c interfata.c prelucrari.c
OBJS = ${SRCS:.c=.o}

Pagina 7
# clear
.SUFFIXES:
# define
.SUFFIXES: .o .c

# regula pentru .c -> .o
.c.o :
$(CC) $(CFLAGS) -c $<

# tinta implicita "all"
all : $(EXE)

$(EXE) : $(OBJS)
$(LD) -o $@ $(OBJS)

$(OBJS) : exemplu.h

clean :
-$(RM) -f $(EXE) $(OBJS)

ntr-un fiier de descriere se pot preciza i comenzi ale sistemului de operare, iar make le va trata
identic cu interpretorul de comenzi. Astfel fiierului de descriere va avea acces la toate caracteristicile
interpretorului de comenzi ca de exemplu redirectarea ieirii sau expandarea numelor de cale. Singura
restricie este ca toat secvena de comenzi s fie ntr-o singur linie. Astfel secvena de comenzi:
cd tmp
rm *
nu va funciona, dar puse pe o singur linie vom obine rezultatul dorit:
cd tmp; rm *
pentru secvene mai mari de comenzi se poate utiliza caracterul \ care permite comenzilor s
aparin teoretic unei singure linii.
Make, pe lng intele obinuite(fiiere) mai poate avea i inte simple, nume de convenien, pentru
diverse activiti, numite inte vide. Putem avea astfel de inte n momemtul n care se dorete
utilizarea lui make ca i unealt de instalare a unor programe:
INSTALLDIR = /usr/local/exemplu

install : disp trac plot
cp f disp ${INSTALLDIR}
cp f trac ${INSTALLDIR}
cp f plot ${INSTALLDIR}
cd ${INSTALDIR};\
chmod 755 disp trac plot

Pagina 8
Practic aceste inte vide sunt n afara lanului normal de dependene ntre fiiere i foreaz
ntr-un fel realizarea unei aciuni. Dac pentru fiierele reale verific timpul ultimei modificri pentru
aceste tipuri de inte se utilizeaz alte reguli:
O int vid este tot timpul out of date, astfel comenzile asociate ei se execut tot
timpul.
O dependen vid este tot timpul mai actual dect inta ei provocnd tot timpul
reconstruirea intei.
Dac se utilizeaz ca i dependen un nume vid, acesta trebuie s apar ca i int altfel make se va
opri cu eroare.

Pagina 1
Curs 5 Fiiere

5.1. Sistemul de fiiere Linux considerente generale
Sistemul de fiiere din UNIX este caracterizat prin:
o structur ierarhic
tratare consistent a fiierelor de date
protejarea fiierelor
n cazul sistemului de fiiere din Linux se urmresc aceleai principii de baz ca i n cazul UNIX,
adic se ncearc ca intrarea i ieirea pentru diverse dispozitive ca discuri, terminale, imprimate s se
realizeze la fel ca i lucrul cu fiiere obinuite.
Fiecare fiier este reprezentat de o structur numit inode (Fig. 1). Fiecare inode conine
descrierea fiierului: tipul fiierului, drepturile de acces, proprietarul, informaii referitoare la dat,
dimensiune, referine ctre blocurile de date. Adresele blocurilor de date alocate fiierului sunt de
asemenea stocate n cadrul inode-ului. Cnd un utilizator solicit o operaie de intrare/ieire asupra
fiierului, kernel-ul sistemului de operare convertete indexul curent ntr-un numr de bloc i
utilizeaz acest numr ca i index n tabela adreselor de bloc i scrie sau citete un bloc.
Fig. 1 Sistemul de fiiere
5.2. Accesul la fiiere
n Linux fiierele sunt accesate prin intermediul unor descriptori de fiiere. Fiecare proces putnd
avea deschise un anumit numr maxim de fiiere la acelai moment de timp, implicit acest numr este
256. Prin convenie descriptorii 0, 1 i 2 sunt alocai de ctre sistem la pornire:
descriptorul 0 este utilizat ca i intrare standard
descriptorul 1 este ieire standard
descriptorul 2 este ieirea standard de eroare.
Fiecare descriptor de fiiere alocat este asociat cu un descriptor de fiiere deschis. Un descriptor
de fiiere conine informaii referitoare la un anumit fiier, un index care precizeaz unde va avea loc
urmtorul acces n fiier, modul de acces la fiier, i alte informaii legate de acesta.
Pagina 2
Este posibil ca mai muli descriptori de fiiere, chiar i aparinnd unor procese separate s indice
n acelai timp spre acelai descriptor de fiier deschis, adic informaia dintr-o structur de decriptor
deschis va fi utilizat simultan de mai muli descriptori de fiiere.
Exist cinci apeluri care genereaz descriptori de fiiere: creat, open, fcntl, dup i pipe. n
continuare vor fi descrise primele dou iar restul vor fi prezentate n capitolele urmtoare.
Apelul sistem open:
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);

Rezultat: descriptorul de fiier sau -1 in caz de eroare.
Numrul de argumente al acestei funcii poate fi doi sau trei. Argumentul al treilea este folosit
doar la crearea de fiiere noi. Apelul cu doua argumente este folosit pentru citirea i scrierea fiierelor
existente. Funcia returneaz cel mai mic descriptor de fiier disponibil. Acesta poate fi utilizat in
apelurile sistem: read, write, lseek i close. IDU efectiv sau GIDU efectiv al procesului care execut
apelul trebuie s aib drepturi de citire/scriere, funcie de valoarea argumentului flags.
Pointerul din fiier este poziionat pe primul octet din fiier.
Argumentul flags se formeaz printr-un SAU pe bii intre constantele:
O_RDONLY - Fiierul este deschis in citire.
O_WRONLY - Fiierul este deschis in scriere.
O_RDWR - Fiierul este deschis n adugare (citire+scriere).
Acestea sunt definite in fiierul antet fcntl.h.
Urmtoarele constante simbolice sunt opionale:
O_APPEND - Scrierile succesive se produc la sfritul fiierului.
O_CREAT - Dac fiierul nu exist el este creat.
O_EXCL - Dac fiierul exist si O_CREAT este poziionat, apelul open eueaz.
O_NDELAY - La fiiere pipe i cele speciale pe bloc sau caracter cauzeaz trecerea n modul
fr blocare att pentru apelul open ct i pentru operaiile viitoare de I/E. In versiunile
noi System V nlocuit cu O_NONBLOCK.
O_TRUNC Dac fiierul exist ii terge coninutul.
O_SYNC Foreaz scrierea efectiv pe disc prin write. ntrzie mult ntregul sistem, dar e
eficace n cazuri critice.
Argumentul al treilea (mode) poate fi o combinaie de SAU pe bii ntre constantele simbolice:
S_IRUSR, S_IWUSR, S_IXUSR User: read, write, execute
S_IRGRP, S_IWGRP, S_IXGRP Group: read, write, execute
S_IROTH, S_IWOTH, S_IXOTH Other: read, write, execute
Pagina 3
Acestea definesc drepturile de acces asupra unui fiier i sunt definite n fiierul antet sys/stat.h.
Apelul sistem creat:
#include <fcntl.h>

int creat( const char *path, mode_t mod);
ntoarce: descriptorul de fiier sau -1 in caz de eroare.
Apelul este echivalent cu:
open( path, O_WRONLY | O_CREAT | O_TRUNC, mod);

Argumentul path specific numele fiierului, iar mod drepturile de acces.
Dac fiierul creat nu exist, este alocat un nou inode si o legtur spre el este plasat n directorul
unde acesta a fost creat. Proprietarul (IDU efectiv si GIDU efectiv) procesului care execut acest apel
trebuie s aib permisiunea de scriere in director. Fiierul deschis va avea drepturile de acces
specificate de argumentul al doilea din apel. Apelul ntoarce cel mai mic descriptor de fiier disponibil.
Fiierul este deschis n scriere iar dimensiunea sa iniiala este 0. Timpii de acces si modificare din inode
sunt actualizai.
Dac fiierul exist (este nevoie de permisiunea de cutare n director) coninutul lui este pierdut
i el este deschis n scriere. Nu se modific proprietarul sau drepturile de acces ale fiierului.
Argumentul al doilea este ignorat.
Apelul sistem read:
Pentru a citi un numr de octei dintr-un fiier, de la poziia curent, se folosete apelul read.
Sintaxa este:
#include <unistd.h>

ssize_t read( int fd, void *buf, size_t noct);
noarce: numrul de octei citii efectiv, 0 la EOF, -1 in caz de eroare.
Citete n oct octei din fiierul deschis referit de fd si i depune n tamponul referit de buf. Pointerul
n fiier este incrementat automat dup o operaie de citire cu numrul de octei citii. Procesul care
execut o operaie de citire ateapt pan cnd kernel-ul depune datele de pe disc in bufferele cache.
In mod uzual, kernel-ul ncearc s accelereze operaiile de citire citind n avans blocuri de disc
consecutive pentru a anticipa eventualele cereri viitoare.
Apelul sistem write
Pentru a scrie un numr de octei ntr-un fiier, de la poziia curent, se folosete apelul write.
Sintaxa este:
#include <unistd.h>

ssize_t write( int fd, const void *buf, size_t noct);
Pagina 4
ntoarce: numrul de octei scrii i -1 n caz de eroare.
Apelul scrie noct octei din tamponul buf n fiierul a crui descriptor este fd.
Interesant de semnalat la acest apel este faptul c scrierea fizic pe disc este ntrziat. Ea se
efectueaz la iniiativa nucleului fr ca utilizatorul s fie informat. Dac procesul care a efectuat
apelul, sau un alt proces, citete datele care nc nu au fost scrise pe disc, kernel-ul le citete napoi
din bufferele cache. Scrierea ntrziat este mai rapid, dar are trei dezavantaje:
eroare disc sau cderea kernelului produce pierderea datelor;
un proces care a iniiat o operaie de scriere nu poate fi informat n cazul apariiei unei
erori de scriere;
ordinea scrierilor fizice nu poate fi controlat.
Pentru a elimina aceste dezavantaje, n anumite cazuri, se folosete fanionul O_SYNC. Dar cum
aceasta scade viteza sistemului si avnd n vedere fiabilitatea sistemelor UNIX de astzi se prefer
mecanismul de lucru cu tampoane cache.
Apelul sistem close
Pentru a disponibiliza descriptorul ataat unui fiier n vederea unei noi utilizri se folosete apelul
close.
#include <unistd.h>

int close( int fd);
ntoarce: 0 in caz de succes si -1 in caz de eroare.
Apelul nu golete bufferele kernel-ului i deoarece fiierul este oricum nchis la terminarea
procesului apelul se consider a fi redundant.
Apelul sistem lseek
Pentru poziionarea absolut sau relativ a pointerului de fiier pentru un apel read sau write se
folosete apelul lseek.
#include <unistd.h>

off_t lseek( int fd, off_t offset, int interp);
ntoarce: : un deplasament n fiier sau -1 n caz de eroare.
Nu se efectueaz nici o operaie de I/O i nu se trimite nici o comand controlerului de disc. Dac
interp este SEEK_SET poziionarea este fa de nceputul fiierului (primul octet din fiier este la
deplasament zero). Dac interp este SEEK_CUR poziionarea este relativ la poziia curent. Dac
interp este SEEK_END poziionarea este fa de sfritul fiierului.
Apelurile open, creat, write i read execut implicit lseek. Daca un fiier este deschis folosind
constanta simbolica O_APPEND se efectueaz un apel lseek la sfritul fiierului naintea unei operaii
de scriere.
Programul urmtor realizeaz copierea unui fiier:
#include <stdio.h>
Pagina 5
#include <stdlib.h>
#include <fcntl.h>

int main(int argc,char*argv[]){
struct stat buf;
int fdr,fdw,rv;
char buff[256];

if((argv[1] == NULL)||(argv[2] == NULL)){
printf("Utilizare: %s sursa destinatie\n",
argv[0]);
exit(0);
}

stat(argv[1],&buf);
if(!S_ISREG(buf.st_mode)){
perror(argv[1]);
exit(0);
}

fdr = open(argv[1], O_RDONLY);
fdw = open(argv[2], O_CREAT|O_WRONLY,
S_IREAD|S_IWRITE);
while(rv = read(fdr, &buff, 128)){
write(fdw, &buff, rv);
}

return 0;
}
Pentru compilarea programului se folosete urmtoarea sintax:
$gcc o copiere copiere.c
Exemplul de mai sus presupune c numele fiierului ce conine codul surs este copiere.c, numele
executabilului va fi copiere. Pentru a lansa n execuie programul vom scrie:
$./copiere fisier1 fisier2

5.3. Gestionarea directoarelor
Citirea unui director se poate face de oricine are drept de citire asupra directorului respectiv.
Scrierea unui director poate fi fcut numai de ctre kernel.Pentru obinerea de informaii despre
fiierele nedeschise se folosesc apelurile sistem stat, fstat i lstat:
Pagina 6
#include <unistd.h>

int stat(const char *path, struct stat *buf);
int fstat(int filedes, struct stat *buf);
int lstat(const char *path, struct stat *buf);
ntoarce: 0 in caz de reuit si -1 in caz contrar.
Pentru fiierul specificat prin path sau filedes se completeaz o structur de informaii care poate
fi accesat prin intermediul lui buf. Cele trei funcii produc acelai rezultat deosebirea constnd n
modul de specificare a fiierului la care se refer. Astfel stat primete ca i argument calea ctre fiierul
respectiv, fstat un descriptor de fiier, iar lstat se refer la un link.
Structura prin care se obin informaii referitoare la fiiere are urmtoarea form:
struct stat {
dev_t st_dev; /* numr de dispozitiv */
ino_t st_ino; /* inode */
mode_t st_mode; /* tip fiier-drepturi */
nlink_t st_nlink; /* numr de legturi */
uid_t st_uid; /* ID proprietar*/
gid_t st_gid; /* ID grup*/
dev_t st_rdev; /* tip dispozitiv fiiere speciale */
off_t st_size; /* dimensiune fiier*/
unsigned long st_blksize; /* dimensiunea blocului pentru I/E */
unsigned long st_blocks; /* numrul de blocuri alocate */
time_t st_atime; /* data ultimului acces*/
time_t st_mtime; /* data ultimei modificri */
time_t st_ctime; /* data ultimei modificri a strii */
};

Tipul de fiier codificat in cmpul st_mode poate fi determinat folosind macrourile:
S_ISREG() Fiier obinuit (REGular file).
S_ISDIR() Fiier director.
S_ISCHR() Dispozitiv special in mod caracter.
S_ISBLK() Dispozitiv special in mod bloc.
S_ISFIFO() Fiier pipe sau fifo.
S_ISLNK() Legtura simbolica.
S_ISSOCK() socket?
Apelul sistem opendir
#include <dirent.h>

DIR *opendir( const char *pathname);
ntoarce: pointer dac operaia s-a ncheiat cu succes, NULL n caz de eroare.
struct dirent *readdir( DIR *dp);
Pagina 7
ntoarce: pointer dac operaia s-a ncheiat cu succes, NULL n caz de eroare.
int closedir( DIR *dp);
ntoarce -1 n caz de eroare.
Structura dirent definit in fiierul antet dirent.h este dependenta de implementare. SVR4 si
4.3+BSD definesc structura astfel nct ea conine cel puin doi membri:
struct dirent {
ino_t d_ino;
char d_name[NAME_MAX +1];
}
Structura DIR este o structur intern folosit de aceste patru funcii pentru a pstra informaii
despre directorul citit. Primul apel readdir citete prima intrare dintr-un director. Ordinea intrrilor
dintr-un director este dependent de implementare. De regul nu este alfabetic.
Apelul sistem link
Pentru a aduga o nou legtura la un director se folosete apelul:
#include <unistd.h>

int link(const char *oldpath, const char newpath);
ntoarce: 0 in caz de reuit si -1 in caz contrar.
Argumentul oldpath trebuie s fie o legtur existent, ea furnizeaz numrul inode-ului.
Dac legturile . i .. din fiecare director sunt ignorate structura sistemului de fiiere este
arborescent. Programe care parcurg structura ierarhica (de exemplu, comanda find) pot fi uor
implementate fr probleme de traversare multipl sau bucla infinit. Pentru a respecta aceast
cerin doar superuser-ul are dreptul sa stabileasc o nou legtura la un director. Crearea celei de a
doua legturi la un director este util pentru a-l putea muta n alt parte a arborelui sau pentru a-l
putea redenumi.
Apelul sistem unlink
Pentru a terge o legtur (cale) dintr-un director se folosete apelul:
#include <unistd.h>

int unlink( const char *path);
ntoarce: 0 n caz de reuit i -1 n caz contrar.
Apelul decrementeaz contorul de legturi din inode i terge intrarea director. Dac acesta
devine 0 spaiul ocupat de fiierul n cauz devine disponibil pentru o alt utilizare, la fel i inode-ul.
Doar superuser-ul poate s tearg un director.
Programul urmtor listeaz coninutul unui catalog(director):
#include <stdio.h>
#include <stdlib.h>
Pagina 8
#include <unistd.h>
#include <dirent.h>

int main(int argc,char*argv[]){
struct stat buf;
struct dirent *entry;
DIR *dr;

if(argv[1] == NULL){
printf("Utilizare: %s director\n " , argv[0]);
exit(0);
}

stat(argv[1],&buf);
if(!S_ISDIR(buf.st_mode)){
perror(argv[1]);
exit(0);
}
dr = opendir(argv[1]);
while(entry = readdir(dr)){
printf("%s\n",entry->d_name);
}

return 0;
}

5.4. Atributele fiierelor
Pentru o gestionare eficient a fiierelor este necesar nu numai cunoaterea unui numr ct mai
mare de date referitoare la acestea dar i posibilitatea modificrii acestor date. n paragraful urmtor
vor fi prezentate o serie de funcii folosite pentru modificarea atributelor fiierelor.
Una dintre caracteristicile eseniale ale sistemului de operare Linux este securitatea.
Implementarea acesteia la nivel de structur de fiiere se face prin precizarea pentru fiecare fiier n
parte a drepturilor de citire, scriere i execuie pentru proprietarul fiierului, pentru grupul
proprietarului i pentru toate celelalte clase de utilizatori. Aceste drepturi pot fi modificate cu ajutorul
apelurilor sistem chmod i fchmod:

int chmod(const char *path, mode_t mode);
int fchmod(int fildes, mode_t mode);
ntoarce: 0 in caz de succes i -1 n caz contrar.
Pagina 9
Pentru a modifica drepturile de acces la fiiere este necesar ca procesul s aib cel puin UID(user
id) efectiv efectiv egal cu al proprietarului fiierului, dac nu drept de superuser.
Parametrii mode pot fi precizai att n form octal ct si sub forma unor constante simbolice de
forma:
S_ISUID suid la execuie (04000)
S_ISGID sgid la execuie (02000)
S_ISVTX bitul sticky (01000)
S_IRUSR, S_IWUSR, S_IXUSR drepturile de citire, scriere i execuie pentru proprietarul
fiierului.
S_IRGRP, S_IWGRP, S_IXGRP pentru grupul utilizatorului.
S_IRO, S_IWO, S_IXO pentru toi ceilali utilizatori.
Un alt element de securitate n ceea ce privete sistemul de fiiere este apelul sistem umask:

mode_t umask(mode_t mask);

n momentul n care se ncearc modificarea drepturilor de acces asupra unui fiier automat
se ine cont i de valoarea atributului mask al funciei umask dup formula mode & ~(mask). Ex.:
int fd;
umask(0222);
if((fd=creat("tmp",0666)==-1)) printf("creat error");
system("ls -l tmp");
Rezultat: -r--r--r-- 1 student user 0 Mar 18 11:05 tmp
Drepturile de acces la fiierul tmp precizate prin intermediul apelului sistem creat erau 0666(r
w - r w - r w - ) dar prin luarea n considerare a mtii s-a obinut ca i rezultat 0222(r - - r - - r - -).
Fiecare utilizator primete la intrarea n sistem o masc, valoarea implicit a acesteia este 022, dar
interpretorul de comenzi permite modificarea acesteia prin intermediul comenzii umask.
Apelul sistem chown:
#include <unistd.h>

int chown(const char *path, uid_t owner, gid_t group);
ntoarc: 0 n caz de succes 1 n caz contrar.
Efecte vizibile la aplicarea acestui apel sistem se pot obine numai dac utilizatorul are drepturi de
superuser, sau este proprietarul fiierului dar n acest caz poate modifica doar grupul cu unul din care
face parte.
Pagina 1
Curs 6 Procese

Linux este unul din sistemele de operare multi-tasking. Procesele reprezint o parte fundamental
a acestui sistem de operare, practic ele controleaz toate activitile care se desfoar n sistem.
UNIX, sistemul iniial din care a derivat Linux, definea un proces ca i un spaiu de adrese cu unul
sau mai multe fire de execuie care se execut n cadrul acelui spaiu de adrese i care solicit resurse
sistem pentru acele fire de execuie. Firele de execuie vor fi tratate n capitolele urmtoare.
Un sistem de operare multi-tasking este un sistem de operare care permite execuia simultan a
mai multor procese. Fiecare instan a unui program n execuie constitue un proces.
Ca i sistem de operare multi-user, Linux permite accesul simultan al mai multor utilizatori. Fiecare
utilizator poate rula mai multe programe sau mai multe instane ale aceluiai program, toate la acelai
moment de timp. Simultan sistemul de operare ruleaz alte programe de gestionare a resurselor
sistemul i de control a accesului utilizatorilor la sistem.
Un program, sau un proces, care ruleaz este constituit din urmtoarele elemente: codul program,
date, variabile, fiiere deschise si mediul de rulare. De obicei un sistem Linux va avea biblioteci si coduri
surs mprite ntre mai multe procese, deci la un orice moment de timp pentru aceste resurse
utilizate n comun va exista o singur copie n memoria sistem.
6.1. Mecanismul de identificare al procesului - PID
Fiecare proces ce ruleaz sub Linux are asociat un identificator de proces unic numit PID (Process
Identity Numbers) prin care este cunoscut n sistem. Fiecare proces din sistem ncepnd cu procesul
1, numit init, are un printe a crui PID i este cunoscut i l poate accesa.
Fiecare proces aparine unui grup de procese, fiecare grup avnd la rndul lui un numr de
identificare care este de fapt identificatorul de proces(PID-ul) procesului printe al grupului.
Cnd se pune problema drepturilor de acces a proceselor la diverse fiiere se folosete un set de
patru numere de identificare. Aceste sunt cunoscute sub numele de utilizatorul real i identificatorul
de grup, i utilizatorul efectiv i identificatorul lui de grup. Identificatorul real al unui proces este de
fapt UID(user ID) i GID(group ID) ale utilizatorului care ruleaz procesul. Identificatorul efectiv este
de obicei acelai cu cel al utilizatorului real cu excepia cazului n care sunt setate opiunile setuid i
setgid. Dac una sau amndou opiunile sunt activate atunci UID sau GID efectiv al procesului vor
primi valorile UID sau GID asociate fiierului din care ruleaz procesul.
S presupunem c avem un utilizator cu UID 200 i GID 20 care dorete s ruleze programul
/usr/bin/passwd. Acest program are UID 0 (root) i GID 1 i are de asemenea set bitul setiud. Cnd
este rulat programul procesul asociat va avea ID-ul utilizatorului real 200, ID-ul grupului real la 20, ID-
ul utilizatorului efectiv 0, iar ID-ul grupului efectiv 20.
Id-ul real est folosit pentru a identifica utilizatorul pentru care este rulat un proces. ID-urile
efective sunt folosite pentru a putea realiza o sortare a permisiunilor i privilegiilor pe care procesele
le au la accesarea unui fiier. Acest lucru se realizeaz pe baza urmtorului algoritm:
Dac ID-ul utilizatorului efectiv al procesului este 0 (root) atunci procesului nu i se aplic
nici o restricie, n caz contrar treci la pasul urmtor.
Pagina 2
Dac ID-ul utilizatorului efectiv al procesului este acelai cu ID-ul utilizator al fiierului
atunci procesului i se acord accesul la fiier n conformitate cu drepturile de acces ale
proprietarului acelui fiier. Dac nu treci la pasul urmtor.
Dac ID-ul grupului efectiv al procesului este acelai cu ID-ul de grup al fiierului atunci
procesului i se acord accesul la fiier n conformitate cu drepturile de acces ale grupului
fiierului. Dac nu treci la pasul urmtor.
Accesul la fiier este acordat pe baza drepturilor de acces ale celorlali utilizatori (others).
Toate aceste numere de identificare se pot obine cu ajutorul urmtoarelor funcii:
uid_t getuid(void) // obine ID-ul utilizatorului real
uid_t getgid(void) // obine ID-ul grupului real
uid_t geteuid(void) // obine ID-ul utilizatorului efectiv
uid_t getegid(void) // obine ID-ul grupului efectiv
uid_t getpid(void) // obine ID-ul procesului
uid_t getppid(void) // obine ID-ul procesului printe
uid_t getpgrp(void)// obine ID-ul de grup al procesului

6.2. Creearea proceselor utiliznd fork
Vom considera c un proces este construit din trei pri separate conform figurii urmtoare(Fig.
1):

Fig.1 Structura proces
Segmentul de text conine instruciunile n cod main care urmeaz s fie executate. Acest
segment poate fi accesat numai pentru citire(deci codul surs din aceast parte nu poate fi modificat),
ceea ce permite utilizarea acestui segment de ctre dou sau mai multe procese din sistem care

Program

Segmentul de
text

Segmentul cu
date utilizator

Segmentul de
date sistem
Proces
Pagina 3
ruleaz acelai program. De exemplu dac mai muli utilizatori ruleaz aceeai versiune de interpretor
de comenzi (de ex. bash), n memoria principal va fi o singur copie a programului pe care o folosesc
n comun toi utilizatorii.
Segmentul de date utilizator conine toate datele cu care opereaz un proces pe parcursul
execuiei sale, aceste date includ i variabilele ce vor fi utilizate de proces. Datele din acest segment
sunt modificabile i n plus fiecare proces are cte un segment de date unic.
Segmentul de date sistem conine elementele caracteristice mediului de lucru n care ruleaz un
program. Acest segment realizeaz distincia ntre programe i procese. Programul are un caracter
static, este localizat pe disc, i este constituit dintr-un set de instruciuni i date folosite pentru
iniializarea segmentelor text i de date ale proceselor. Procesul are un caracter dinamic iar execuia
sa necesit interaciunea ntre segmentele de date, text i sistem.
Sub Linux, pentru crearea de noi procese se folosete apelul sistem fork:
#include <unistd.h>

pid_t fork(void);
Practic acest apel realizeaz un nou proces, numit proces fiu, iar procesul care a apelat fork devine
proces printe a noului proces creat. Cele dou procese sunt identice n termeni de coninut al
segmentelor lor de date i text i aproape identice n ceea ce privete segmentele sistem. Singurele
diferene ntre astfel de procese apar la nivelul unor atribute care trebuie s fie diferite (cum ar fi PID
care trebuie s fie unic pentru fiecare proces n parte). Odat ce procesul fiu a fost creat, ambele
procese,printe i fiu, i continu execuia din interiorul apelului fork. Adic urmtoarea aciune
pentru fiecare proces n parte este s prseasc fork, fiecare returnnd o valoare diferit (Fig.2).

Fig. 2 Fork
Procesul iniial
fork()
ntoarce
un nou PID
ntoarce 0
Procesul
fiu
Procesul
printe
Pagina 4
Dou procese virtual identice care ruleaz simultan se pot dovedi utile numai n situaia n care
acestea realizeaz aciuni diferite. n aceast situaie este nevoie de un mecanism prin care s se
realizeze diferenierea ntre cele dou procese. Acest lucru se realizeaz relativ simplu prin faptul c
fork returneaz valori diferite celor dou procese. Astfel procesului printe i returneaz PID-ul noului
proces fiu creat, n timp ce procesului fiu i returneaz 0. n mod normal alocarea ID-urilor pentru
procese ncepe cu 1 pentru procesul init. Vom avea n continuare un exemplu de program care creeaz
un nou proces:
#include <unistd.h>
#include <stdio.h>

main(){
pid_t val;
printf("PID inainte de fork: %d\n",(int)getpid());
if(val=fork())
printf("PID parinte: %d\n",(int)getpid());
else
printf("PID fiu: %d\n",(int)getpid());
}

La rularea programului se vor genera trei linii de ieire. Prima va afia valoarea PID-ului
procesului nainte de apelul fork, a doua valoarea PID a procesului printe dup apelul fork, iar a treia
va afia valoarea PID a procesului fiu. Un exemplu de ieire obinut la rularea programului:
PID nainte de fork: 16953
PID printe: 16953
PID fiu: 16954
Dup execuia apelului fork majoritatea atributelor procesului printe sunt disponibile
nemodificate procesului fiu. Principalele atribute sunt:
apartenena la grupul de procese.
terminalul n care ruleaz(dac acesta exist).
UID i GID reale i efective.
directorul de lucru curent.
masca pentru crearea fiierelor(umask).
n plus, toi descriptorii de fiiere, care n procesul printe sunt asociai cu fiiere deschise vor fi
duplicai n procesul fiu. Adic att descriptorii de fiiere ai procesului fiu ct i ai procesului printe
vor indica spre aceeai descriptori de fiiere deschise.
6.3. Apelul sistem exec
Dac se utilizeaz interpretorul de comenzi pentru a rula o comand (ex. ls) pentru rularea ei
acesta va apela la un anumit moment fork. Se pune problema cum se poate ca n procesul fiu n loc de
o copie a interpretorului de comenzi s fie rulat ls.
Pagina 5
Soluia n acest caz este utilizarea apelului sistem exec. De fapt sunt mai multe versiuni ale acestui
apel sistem dar toate realizeaz n esen acelai lucru. Acest apel sistem reprezint de fapt
modalitatea de rulare de programe sub Linux. Acest lucru l realizeaz prin nlocuirea segmentelor de
date i text ale procesului care apeleaz exec cu cele ale programului a crui nume a fost transmis ca
i argument. O alt problem ce ar putea aprea este faptul c majoritatea programelor ce sunt rulate
n mod curent din linia de comand primesc i parametrii sau argumente, deci apelul exec trebuie s
acopere i aceste aspecte. Acest lucru se poate realiza n C prin argumentele argc i argv, deci i exec
trebuie s i le transmit programului ntr-o form asemntoare.
Cea mai simpl versiune de exec este execl. Prototipul acestei funcii este:
#include <unistd.h>
int execl( const char *path, const char *arg, ...);
unde path este calea complet ctre programul care urmeaz s fie executat, acesta este urmat de o
list variabil de argumente ce trebuie transmise programului. Aceast list trebuie terminat cu
NULL(0). n continuare vom avea un exemplu de program care s ruleze comanda ls l:
#include <stdio.h>
#include <unistd.h>

main(){
execl("/bin/ls","ls","-l",0);
printf("terminat cu erori.");
}

Primul parametru pentru execl este calea complet pentru programul ce urmeaz a fi rulat, acesta
este fiierul care va fi rulat, de aici se obin i drepturile de acces la fiier(dac are sau nu drept de
execuie) restul parametrilor sunt folosii pentru lista de argumente argv. n exemplu ls va fi argv[0],
iar l argv[1].
Din apelurile exec nu se revine. Deci mesajul terminat cu erori din exemplu nu va fi afiat. Singura
excepie este cazul n care a aprut o eroare la apelul exec n aceast situaie se revine la vechiul
proces i se returneaz i codul de eroare (n aceast situaie va fi afiat mesajul terminat cu erori).
n plus pentru a face toi aceti parametrii disponibili noului program apelurile exec transmit o
valoare i pentru variabila:
extern char **environ;

Aceast variabil are acelai format ca i variabila argv diferena fiind c prin variabila environ se
transmit valori ale variabilelor aparinnd mediului de lucru ale procesului original.
Acest apel sistem mai conine i alte versiuni singurele diferene constnd n modul de apelare,
funcional toate se comport la fel:
int execlp( const char *file, const char *arg, ...);
int execle( const char *path, const char *arg , ...,
char* const envp[]);
int execv( const char *path, char *const argv[]);
Pagina 6
int execvp( const char *file, char *const argv[]);
int execve (const char *filename, char *const argv
[],char *const envp[]);
n cazul ultimelor trei apeluri argumentele ce trebuie transmise programelor sunt organizate
sub forma unei liste.
Ca i n cazul apelului fork majoritatea atributelor sunt pstrate n urma unui apel exec. Acest
lucru se datoreaz faptului c segmentul sistem rmne intact n urma unui apel exec. Cel mai
important aspect este acela c descriptorii de fiiere asociai cu descriptorii de fiiere deschise rmn
valabile i dup apelul lui exec. Singura excepie este un marcaj (flag) asociat descriptorilor de fiiere
(nu este asociat descriptorilor de fiiere deschise) numit close on exec. Dac acest flag nu este activat
atunci descriptorul de fiier respectiv este valabil i dup apelul exec. Modificarea acestui flag se poate
face prin intermediul apelului sistem fcntl.
6.4. Apelurile sistem wait i exit
Pe parcursul rulrii procesului fiu procesul printe fie ateapt ca acesta s i termine execuia, fie i
continu execuia. n cazul interpretorului de comenzi de exemplu, alegerea rmne la latitudinea
utilizatorului. n mod normal interpretorul de comenzi ateapt, pentru fiecare comand introdus
din linia de comenzi, pn la terminarea execuiei acesteia. Dar utilizatorul are posibilitatea indica
interpretorului de comenzi s nu mai atepte terminarea comenzii i s i reia execuia imediat prin
adugarea caracterului & la sfritul comenzii.
Pentru ca procesul printe s atepte terminarea execuiei unui proces fiu, procesul printe
trebuie s execute apelul sistem wait(). Prototipul acestui apel sistem este urmtorul:
#include <sys/wait.h>
pid_t wait(int *status)

Apelul sistem wait returneaz PID-ul procesului fiu ce i-a ncheiat execuia. Parametrul care
l primete apelul sistem wait este o referin ctre o locaie care va primi valoarea strii de terminare
a procesului fiu.
Cnd un proces i-a terminat execuia el va executa apelul sistem exit fie n mod explicit fie
indirect prin intermediul unei biblioteci. Prototipul apelului sistem exit este urmtorul:
#include <stdlib.h>
void exit(int status)

Acest apel sistem primete ca i argument un parametru de stare care va fi transmis procesului
printe prin intermediul unei locaii referit de parametrul apelului wait. Apelul sistem wait poate
ntoarce mai multe informaii referitoare la starea procesului fiu la terminare prin intermediul valorii
de stare. Pentru extragerea acestor informaii se poate folosi un macro numit WEXITSTATUS. Ex:
int statval, exstat;
pid_t pid;
pid = wait(&statval);
Pagina 7
exstat = WEXITSTAUS(statval);

Schema bloc care descrie funcionarea a dou procese, unul printe care ateapt terminarea
execuiei procesului fiu i a procesului fiu care folosete apelul sistem exec i a crui execuie se
termin cu apelul exit, arat astfel (Fig. 3):

Fig. 3 Proces printe n ateptare
O alt versiune a apelului sistem wait este waitpid cu urmtorul prototip:
pid_t waitpid(pid_t pid, int *status, int options);

Prin parametrul options ofer faciliti suplimentare. De exemplu, n urma unui apel waitpid
procesul printe nu i suspend execuia dac nici un proces fiu nu are disponibil starea de ieire.
Options poate fi o operaie de tip SAU ntre urmtoarele constante:
WNOHANG apelul nu este blocant.
WUNTRACED preia i starea proceselor fiu trecute in starea stop.
fork
exec wait
Noul program
ruleaz
Execuia printelui
este suspendat
exit
Execuia procesului
printe este reluat
Pagina 8
WCONTINUED - preia i starea proceselor fiu trecute in starea continue.
Pentru parametrul pid avem urmtoarele posibiliti:
< -1 ateapt ncheierea execuiei oricrui proces fiu a crui ID de grup este egal cu pid.
-1 comportament identic cu pid.
0 ateapt ncheierea execuiei oricrui proces fiu a crui ID de grup este egal cu ID-ul de grup
al procesului.
> 0 ateapt ncheierea execuiei procesului fiu a crui PID este egal cu pid.
Exist posibilitatea ca un proces fiu s i ncheie execuia nainte ca procesul printe s apeleze wait.
n aceast situaie procesul fiu va intra ntr-o stare numit zombie, n care toate resursele ocupate de
procesul fiu au fost eliberate cu excepia structurii de date care conine starea sa de ieire. Cnd
procesul printe efectueaz apelul wait, starea de ieire este transmis procesului printe iar resursele
ocupate cu structura de date a proces ului fiu pot fi eliberate.

Pagina 1
Curs 7 Comunicarea ntre procese

Fiecare proces opereaz n propriul su spaiu de adrese virtuale, iar de evitarea interferenelor
dintre procese se ocup sistemul de operare. Implicit un proces nu poate comunica cu un alt proces
numai dac face uz de diverse mecanisme de comunicare gestionate de kernel(nucleul sistemului de
operare). Exist totui diverse situaii n care procesele trebuie s coopereze, s mpart resurse
comune sau s i sincronizeze aciunile. Exist mai multe metode de comunicare ntre procese:
fiiere este cel mai simplu mecanism de comunicare interproces. Un proces scrie ntr-un
fiier iar cellalt proces citete din fiier.
semnale sunt utilizate pentru a semnala asincron evenimente ntre procese
pipes un pipe conecteaz ieirea standard a unui proces cu intrarea standard a altuia.
cozi de mesaje este o list legat de spaiul de adresare a kernel-ului
semafoare sunt contoare utilizate pentru a gestiona accesul la resursele utilizat n comun de
mai multe procese Cel mai des sunt folosite ca i mecanism de blocare a unei resurse pentru
a preveni accesul simultan a mai multor procese la o anumit resurs.
Sockets- permit realizarea de conexiuni ntre procese locale sau n reea.

7.1. Semnale
Una dintre cele mai vechi metode de comunicare ntre procese n sistemele de tip UNIX(Linux) se
bazeaz pe semnale. O caracteristic important a acestor semnale este c ele sunt asincrone, adic
un proces poate primi un semnal la orice moment i trebuie s fie pregtit s i rspund. Dac un
semnal survine pe perioada execuiei unui apel sistem, acesta se ncheie prin returnarea unui cod de
eroare(EINTR) i este sarcina procesului s refac apelul ntrerupt. Exist mai multe tipuri semnale i
fiecare putnd fi accesat utiliznd pe baza unui nume simbolic. Fiecare nume unic reprezint o
abreviere ce ncepe cu SIG (de ex. SIGINIT). O list complet a setului de semnale din sistem se poate
obine prin intermediul comenzii kill l. n continuare se prezint o list cu numrul i numele simbolic
a semnalelor folosite n mod uzual:
1) SIGHUP terminal nchis (oprete procesul).
2) SIGINT ntrerupere de la tastatur (oprete procesul).
3) SIGQUIT oprete procesul (oprete procesul i creeaz un fiier core).
4) SIGILL aciune ilegal (oprete procesul i creeaz un fiier core).
5) SIGTRAP 6) SIGIOT 7) SIGBUS 8) SIGFPE
9) SIGKILL termin procesul.
10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM
17) SIGCHLD procesul fiu oprit sau terminat
18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN
22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO
30) SIGPWR

Fiecare tip de semnal are asociat o aciune ce va fi executat de nucleul sistemului de operare
(kernel) asupra procesului cnd procesul primete semnalul respectiv. Implicit un proces poate trata
un semnal n urmtoarele moduri:
Pagina 2
i ncheie execuia
Ignor semnalul dou semnale nu pot fi ignorate: SIGKILL care termin execuia
procesului i SIGSTOP care i oprete execuia.
Reface aciunea implicit a semnalului.
La primirea unui semnal un proces poate alege modul de tratare a acestuia, o alternativ este
s rmn la aciunea implicit, iar tratarea va fi fcut de kernel. De exemplu semnalul SIGSTOP va
modifica starea curent a procesului care l primete n STOPED i apoi va solicita
kernelului(schedulerului) sau ruleze un alt proces. Alternativ, procesul poate specifica pentru un
anumit semnal propria rutin de tratare. Aceast rutin va fi apelat de fiecare dat cnd este generat
semnalul respectiv, iar adresa acestei este reinut n structura sigaction. Apelul acestei rutine va fi
fcut de ctre kernel, deci procesul va rula n mod kernel pe parcursul tratrii semnalului.
Nu orice proces din sistem poate trimite semnal oricrui alt proces, acest lucru este valabil
numai pentru procesele ce aparin kernelului sau superutilizatorului (root). Procesele normale pot
trimite semnale numai proceselor cu acelai UID i GID, sau proceselor din acelai grup.
Generarea unui semnal se realizeaz prin setarea bit-ului corespunztor din structura
task_struct. Dac procesul nu a blocat semnalul i se afl n ateptare dar este ntreruptibil atunci
starea acestuia este modificat n Running, iar procesul este trecut n coada de execuie. n acest fel
procesul va fi luat n calcul ntre procesele care vor primi timp de procesor.
Semnalele nu sunt transmise proceselor imediat ce sunt generate, ele trebuie s atepte pn
n momentul n care procesul ruleaz din nou. De fiecare dat cnd un proces prsete un apel sistem
sunt verificate cmpurile sale signal i blocked, iar dac pentru respectivul proces sunt semnale
neblocate ele pot fi acum transmise procesului.
La nivel de interpretor de comenzi o modalitate de trimitere a semnalelor ctre procese este
prin intermediul comenzii kill. Un exemplu clasic de terminare forat a execuiei unui proces este
urmtorul:
ps | grep processname
kill -9 PID

n cele ce urmeaz se va face o scurt prezentare a celor mai importante apeluri sistem folosite
pentru lucrul cu semnale.
Apelul sistem signal:
n Linux sunt disponibile mai multe apeluri sistem ce pot fi utilizate pentru gestionarea semnalelor.
Apelul sistem signal poate fi ntlnit i la celelalte versiuni de UNIX. Prototipul acestui apel sistem este
urmtorul:
#include <signal.h>
void(*signal(int signum, void (*sighandler) (int)))
(int);

La prima vedere acest prototip pare complicat dar la o analiz mai atent se poate observa c sunt
necesari doar doi parametrii:
signum un numr ntreg care indic semnalul a crui tratare va fi rescris.
Pagina 3
handler o referin ctre o funcie care va fi folosit ca rutin de tratare pentru semnalul
respectiv.
Valoarea returnat de signal() este o referin ctre o funcie care primete ca i parametru
un singur ntreg i nu returneaz nimic (void). Un exemplu de utilizare a acestui apel sistem:
#include <stdio.h>
#include <signal.h>
#include <unistd.h>

void handler(int sig){
printf("CTRL-C\n");
(void)signal(SIGINT,handler);
}

void main(void){
(void)signal(SIGINT,handler);
while(1){
printf("Hello World!\n");
sleep(1);
}
}

Acest segment de cod afieaz la terminal, n bucl infinit, mesajul Hello World!. La orice
tentativ de a opri programul de la tastatur prin secvena CTRL-C semnalul SIGINT va fi prins de
program, ca rutin de tratare a semnalului va fi folosit funcia handler.
Legtura ntre semnal (SIGINT) i rutina de tratare (handler) se realizeaz la apelul din funcia
main. Dup realizarea acestei legturi orice semnal SIGINT primit de proces va determina execuia
rutinei de tratare (handler). Aceast funcie doar afieaz mesajul CTRL-C, totodat reface legtura
ntre semnal i funcie. Aceast refacere a legturii ntre semnal i rutina de tratare este necesar
datorit faptului c dup primirea unui semnal se revine la tratarea implicit (terminarea execuiei
programului)., ceea ce nu este de dorit.
Pentru acest tip de apel sistem apare o problem legat de un scurt interval de timp n care
tratarea semnalului se face n mod implicit, i dac pe parcursul acestui interval de timp survine un
semnal acesta va fi tratat n mod implicit, adic va determina ncheierea execuiei programului.
Apelul sistem sigaction:
Acest apel sistem este conform standardelor POSIX, este mai complex, dar nltur problema
aprut anterior. Conform acestor specificaii fiecare proces are asociat cte o masc, care
precizeaz setul de semnale care nu pot fi livrate procesului la momentul curent. Dac totui procesul
primete un semnal ce aparine acestei liste el va fi pus ntr-o coad de ateptare i va fi transmis
procesului atunci cnd blocajul este nlturat.
Cnd un semnal este generat, el este automat adugat la masca de semnale a procesului int,
astfel nct orice instan viitoare a acestui semnal va fi blocat pn la servirea semnalului curent.
Pagina 4
Prototipul pentru acest apel sistem este urmtorul:
#include <signal.h>
int sigaction(int signum,const struct sigaction *act,
struct sigaction *oldact);

Dup cum se poate observa referina ctre rutina de tratare a fost introdus n aceast
structur. Totodat structura mai conine i un cmp sa_mask acesta funcioneaz ca i o masc de
semnale suplimentar, i este valabil pe parcursul execuiei rutinei de tratare a semnalului. Cmpul
sa_flags se interpreteaz la nivel de bit. Dintre aceste flag-uri cele mai semnificative sunt:
SA_ONESHOT semnalul va fi tratat n mod implicit.
SA_NOMASK - ignor cmpul sa_mask din structura sigaction.
Ambele flag-uri vor fi active dac pentru se folosete apelul signal n loc de sigaction. Pentru
obinerea de informaii adiionale s-a introdus un parametru suplimentar siginfo_t.
Spre deosebire de signal, valoarea returnat de sigaction nu include o referin ctre vechea
rutin de tratare. n schimb primete un nou parametru. Acesta este o alt referin ctre o structur
de tipul sigaction, iar completarea acestei structuri o va face apelul sigaction() bazndu-se pe vechea
structur sigaction.
Apelul sistem kill:
n marea majoritate a cazurilor mai importante semnalele sunt generate de apariia unor
evenimente: erori hardware, modificarea strii unui proces sau intervenia utilizatorului de la consol.
n afar de aceste situaii exist posibilitatea ca un proces s trimit semnale n mod deliberat unui alt
proces, utiliznd apelul sistem kill, dac are permisiunile corespunztoare. Prototipul acestui apel
sistem este urmtorul:
#include <signal.h>
int kill(pid_t pid, int sig);

Unde prin sig se precizeaz semnalul care va fi trimis, iar pid are urmtoarele sensuri:
pid > 0 semnalul sig va fi trimis procesului pentru care PID = pid.
pid = 0 semnalul sig va fi trimis tuturor proceselor cu acelai PID ca i procesul ce a fcut
apelul.
pid = -1 semnalul sig va fi trimis tuturor proceselor din sistem cu excepia procesului init
i a procesului ce a fcut apelul.
pid < -1 trimite semnalul sig tuturor proceselor pentru care GID=pid.
Apelul sistem alarm:
#include <unistd.h>
unsigned int alarm(unsigned int seconds);

Pagina 5
Fiecare proces are asociat un ceas pe care l poate folosi pentru a-i trimite semnale de tipul
SIGALRM dup depirea unui anumit interval de timp. Apelul sistem alarm() primete un singur
parametru care este intervalul de timp, n secunde, dup care se va genera semnalul.

7.2. Pipes
n Linux, majoritatea intrepretoarelor de comenzi accept redirectarea. Un exemplu clasic n acest
sens este secvena de comenzi:
$cat /etc/passwd | wc -l

Rezultatul acestei secvene de comenzi este c ieirea standard a comenzii cat devine intrare
standard pentru comanda wc. Deci un pipe este o metod prin care se poate realiza conectarea ieirii
standard a unui proces cu intrarea standard altuia. Pipe-urile sunt una dintre cele mai vechi metode
utilizate la comunicarea ntre procese. Comunicaia realizat ntre dou procese se poate realiza ntr-
o singur direcie, de unde i denumirea de unidirecionale (half-duplex). Nici unul dintre procesele
implicate nu sunt contiente de aceste redirectri i este sarcina intrepretorului de comenzi s
gestioneze aceste pipe-uri.
Cnd un proces creeaz un pipe, nucleul (kernelul) va genera doi descriptori de fiiere care
urmeaz s fie utilizai mpreun cu pipe-ul. Unul dintre descriptori este folosit pentru a crea o cale de
intrare (scriere) n pipe, iar cellalt pentru a crea o cale de ieire. n acest punct utilizarea unui pipe nu
are o utilitate practic prea mare atta vreme ct procesul poate comunica numai cu el nsui. O
reprezentare a procesului i a kernelului dup ce a fost creat un pipe:

Fig. 1 Comunicare proces nucleu
Din diagrama anterioar se poate observa modul de conectare a descriptorilor de fiiere. Un
proces poate trimite date (scrie) prin fd0, i le poate obine prin fd1. La nivel de pipe transferul datelor
se face n interiorul kernelui, iar pipe-ul este reprezentat prin intermediul unui inode, care la rndul
lui aparine tot kernel-ului i nu este legat de nici un sistem fizic de fiiere. Din ceea ce s-a prezentat
pn acum utilizarea pipe-urilor nu ar avea nici un sens deoarece n aceast situaie un pipe ar fi folosit
doar pentru comunicarea in cadrul unuia i acelai proces. Dar situaia se schimba daca dup crearea
pipe-ului are loc i crearea unui proces prin intermediul apelului sistem fork. n aceast situaie
procesul printe va moteni toi descriptorii de fiiere deschii pentru procesul printe, i bazndu-ne
pe acest mecanism avem bazele comunicrii intreproces (mai precis ntre procese aflate n relaia
printe-fiu).
intrare
Proces
iesire

Nucleu
(kernel)
Pagina 6
Ceea ce s-a prezentat pn acum a fost doar o prezentare de ansamblu, iar exemplul a fost la
nivelul interpretorului de comenzi. Pentru a utiliza facilitile oferite de pipe-uri n cadrul limbajului
de programare C.
Apelul sistem pipe:
Este utilizat pentru crearea unui fiier de tip pipe.
#include<unistd.h>
int pipe(int pfd[2]);

ntoarce 0 n caz de succes i -1 n caz de eroare.
Argumentul pfd este un tablou cu dou elemente care dup execuia funciei va conine:
Descriptorul de fiier pentru citire pfd[0];
Descriptorul de fiier pentru scriere pfd[1];
Rolul acestui apel sistem este de a crea o cale de comunicaie, de citire i scriere, ntre dou
procese. Aceast cale de comunicaie se bazeaz pe cei doi descriptori de fiier care sunt returnai, de
apelul sistem pipe, n tabloul pfd. Astfel din pfd[0]se citesc datele, iar n pfd[1] se scriu datele.
Aa cum s-a mai precizat comunicarea prin intermediul pipe-urilor este specific comunicrii ntre
procese, deci n conjuncie cu apelul sistem fork. Un exemplu clasic este situaia n care se dorete ca
procesul printe s transmit un mesaj procesului fiu. Programul C corespunztor va realiza urmtorii
pai:
Apelul sistem pipe creeaz descriptorii de citire/scriere.
Apelul sistem fork se creeaz procesele printe i fiu, cei doi descriptori se vor regsi n
ambele procese.
Procesul printe va nchide pfd[0] descriptorul de citire.
Procesul fiu va nchide pfd[1] descriptorul de scriere.
Se realizeaz transferul mesajului prin intermediul descriptorilor de fiier rmai deschii.
nchiderea descriptorilor neutilizai este necesar din cauz c descriptorii de fiiere sunt aceeai
att n procesul printe ct i n procesul fiu, situaie datorat apelului sistem fork. Programul C
corespunztor este prezentat n cele ce urmeaz.
#include <stdio.h>
#include <unistd.h>
#include <string.h>

int main(void){

int pfd[2], nr_bytes, status;
pid_t pid_fiu;
char mesaj[] = "Hello world!";
char readbuffer[80];

Pagina 7
pipe(pfd);

if((pid_fiu = fork()) == -1)
{
perror("fork");
_exit(1);
}

if(pid_fiu == 0)
{
//procesul fiu nchide descriptorul de scriere
close(pfd[1]);

//citete mesajul din pipe
nr_bytes=read(pfd[0],readbuffer,sizeof(readbuffer));

//i l afiseaz
printf("Received string: %s\n", readbuffer);

}else{

//procesul printe nchide descritorul de citire
close(pfd[0]);

//trimite mesajul prin descriptorul de scriere
write(pfd[1], mesaj, (strlen(mesaj) + 1));
wait(status);
sleep(1);
_exit(0);
}
return(0);
}

Apelul sistem dup i dup2:
Este utilizat pentru a duplica un descriptor de fiier.
#include <unistd.h>
int dup(int fd);
int dup2(int fd, int nfd);

Returneaz noul descriptor n caz de succes, sau -1 n caz de eroare. Iar cu dup2 vechiul
descriptor este nchis.
Pagina 8
Acest apel sistem creeaz un nou descriptor de fiier pe lng cel existent, descriptorul
(numrul) returnat este cel mai mic disponibil. O utilizare imediat a acestui apel sistem ar fi
posibilitatea redirectrii intrrii/ieirii standard.
Apelul dup dei vechiul i noul descriptor pot fi utilizate pe rnd, de obicei una dintre cile de
comunicare standard sunt nchise.
Dac vom considera:

pid_fiu = fork();

if(pid_fiu == 0)
{
//nchide intrarea standard a procesului fiu
close(0);

//duplic partea de intrare a pipe-ului cu intrarea
standard
dup(pfd[0]);
execlp("sort", "sort", NULL);

}

Deoarece descriptorul de fiier 0 (intrarea standard) a fost nchis, apelul dup foreaz
descriptorul de intrare a pipe-ului ca intrare standard, apoi se realizeaz apelul sistem execlp() care
suprascrie segmentul de cod a procesului fiu cu programul de sortare. Pentru c noul program
executat motenete cile de comunicare ale procesului din care a fost creat, el motenete de fapt,
ca i cale de intrare standard descriptorul de citire din pipe. Astfel tot ce trimite procesul printe iniial
prin pipe ajunge la programul de sortare.
Apelul dup2 acest apel include, att apelul de duplicare a cii de comunicare standard ct
i operaia de nchidere a cii de comunicare standard, ntr-un singur apel sistem. n plus acest apel
sistem este garantat a fi atomic, adic nu va fi acceptat nici o cerere de ntrerupere (semnal) din
partea sistemului pe parcursul execuiei acestui apel. n cazul apelului sistem dup() trebuia realizat
operaia close nainte. Adic aveam dou apeluri sistem, ceea ce crea un anumit grad de
vulnerabilitate, dat de intervalul dintre cele dou apeluri. Dac sosete un semnal ntre cele dou
apeluri operaia de duplicare nu mai are loc.
n acest caz vom avea:

pid_fiu = fork();

if(pid_fiu == 0)
{
//nchide i duplic intrarea standard
dup2(0, pfd[0]);
Pagina 9
execlp("sort", "sort", NULL);

}

Pagina 1
Curs 8 Fire de execuie

8.1. Prezentare general
O caracteristic esenial a unui sistem de operare de tip UNIX/Linux este execuia concurent a
mai multor procese, la fel ca i procesele, firele de execuie par a rula concurent, responsabil de
aceast concuren este nucleul, kernel-ul, sistemului de operare care ntrerupe rularea thread-
urilor la anumite intervale de timp oferind i altora ansa de a fi rulate.
Conceptual, thread-ul este o subdiviziune, el exist doar n cadrul unui proces. La execuia
unui program, sistemul de operare creeaz un nou proces i n cadrul procesului respectiv va crea un
singur thread n care programul apelat se execut secvenial, opional, din thread-ul iniial se pot crea
thread-uri suplimentare, ansamblul acestor thread-uri reprezentnd programul apelat, fiecare thread
executnd pri diferite ale programului la momente diferite de timp.
Dac n cazul crerii unui nou proces, procesul fiu execut programul procesului printe dar
cu resursele printelui, memorie virtual, descriptori de fiiere, etc., copiate procesul fiu putnd
modifica oricare resurs fr a afecta procesul printe, i viceversa, la crearea unui thread nimic nu
este copiat. Ambele thread-uri vor utiliza resursele sistem n comun, dac un thread nchide un
descriptor de fiier, celelalte thread-uri nu vor mai putea efectua operaii asupra acelui descriptor de
fiier. De asemenea datorit faptului ca un proces, respectiv thread-urile asociate unui proces, poate
excuta doar un singur program la un moment dat, dac un thread apeleaz una dintre funciile exec
execuia celorlalte thread-uri este ntrerupt.
Comutarea execuiei ntre dou procese implic un numr relativ mare de operaii. Aceste
operaii sunt necesare pentru a se asigura faptul c nu apar interferene ntre diferitele resurse ale
unor procese diferite, aceast condiie fiind necesar n cadrul unui sistem multiutilizator. n situaia
n care se dorete ca dou sau mai multe procese s coopereze, pentru atingerea unui scop comun,
acest obiectiv se poate realiza prin utilizarea mecanismelor de comunicare interproces. Totui i n
cazul utilizrii acestor mecanisme sunt necesare operaiile de comunicare ntre procese care impun
operaii suplimentare. Dac se dorete eliminarea acestor operaii suplimentare atunci procesele pot
fi nlocuite cu fire de execuie.
Firele de execuie mai sunt numite i procese uoare (light weight procesess LWPs). Un
proces, n general, are mai multe pri componente cod, date, stiv, i de asemenea un anumit timp
de execuie pe procesor. n cazul firelor de execuie vom avea mai multe procese care au alocate
propriile lor intervale de timp de procesor dar folosesc n comun segmentele de cod, date, memoria
i structurile da date.
n acest caz operaiile necesare pentru comutarea ntre dou fire de execuie implic un efort
semnificativ mai mic dect n situaia unor procese. Deoarece firele de execuie au fost proiectate
astfel nct s fie cooperative, nucleu sistemului de operare nu trebuie s ia msuri suplimentare de
protecie a resurselor acestora n cadrul unui proces. Din acest motiv firele de execuie au primit
denumirea de procese uoare. La polul opus se afl procesele ca atare, care comparativ cu firele de
execuie implic un efort de comutare mai mare i ca urmare se mai numesc i procese grele (heavy
weight processes HWPs)
n general procesele pot fi implementate n dou moduri:
Pagina 2
n spaiul nucleului de obicei aceste procese sunt implementate n nucleul sistemului de
operare, implementare ce se bazeaz pe controlul, n nucleu, a tabelelor de semnale
asociate firului de execuie. n acest caz nucleul sistemului de operare este rspunztor
de programarea execuiei fiecrui fir, iar intervalul de timp alocat firului este sczut din
timpul alocat, global, procesului din care face parte firul. Dezavantajul acestei metode de
control al timpului de execuie este dat de apariia unui efort suplimentar la comutarea
utilizator-nucleu-utilizator. Avantajul major este dat de planificarea controlat a firelor de
execuie (la expirarea cuantei de timp de procesor nucleul i va ntrerupe execuia i va
transmite controlul firului urmtor), deci este exclus blocarea procesului datorat unor
operaii de I/E, iar n cazul sistemelor de calcul cu mai multe procesoare performana
poate crete proporional cu numrul de procesoare adugate sistemului.
n spaiul utilizatorului n acest caz este evitat controlul nucleului asupra firului de
execuie pentru o astfel implementare,numit i multitasking cooperativ, se definesc un
set de rutine ce sunt responsabile de comutarea execuiei ntre fire. Tipic un fir de execuie
cedeaz controlul n mod explicit procesorul, prin apelul explicit a unei rutine, trimiterea
unui semnal. O problem major ce poate apare este acapararea de ctre un fir a
ntregului timp de procesor asociat unui proces (ex. dac procesul execut o operaie de
I/E), o posibil rezolvare este utilizarea unui semnal de timp care s determine comutarea
ntre fire.
n paragrafele ce urmeaz discuia se va baza pe fire de execuie POSIX numite i pthreads (firele
ce nu se conformeaz acestui standard se numesc cthreads).
n cadrul unui proces un thread este recunoscut pe baza unui identificator, iar la creare fiecare
thread execut o funcie. Acesta este o funcie obinuit ce conine codul ce trebuie rulat de thread,
iar la ieirea din funcie se termin i execuia thread-ului.
8.2. Apeluri sistem
Apelul sistem de baz pentru crearea de noi thread-uri este pthread_creat.
#include <pthread.h>
int pthread_create(pthread_t *thread, pthread_attr_t
*attr, void * (*start_routine)(void *), void *arg);

Funcia pthread_creat creeaz noi thread-uri i trebuie s i se transmit urmtoarele argumente:
O referin ctre o variabil de tip pthread_h, n care este salvat identificatorul thread-
ului.
O referin ctre un obiect de tip thread attribute. Prin acest argument se controleaz
modul n care thread-ul interacioneaz cu restul programului. Dac argumentul transmis
este NULL atunci se vor folosi setrile implicite.
O referin ctre funcia ce urmeaz a fi executat de thread. Referina ctre funcie
trebuie s fie de tipul: void* (* ) (void *).
Argument ctre thread. Acesta trebuie s fie de tip void *, i este transmis funciei thread-
ului.
La apelul funciei phtread_creat are loc crearea thread-ului, iar revenirea din funcie se face
imediat. Rularea celor dou thread-uri (printe i fiu) are loc asincron, iar execuia unui program nu
trebuie s se bazeze pe o anumit ordine de rulare a thread-rilor.
Pagina 3
Un exemplu clasic de program este Hello World, de aceast dat realizat cu thread-uri:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

//funcia ce va fi executat de thread-uri
void* print_message( void *ptr ){
char *message;
message = (char *) ptr;
printf("%s ", message);
return NULL;
}

int main(){
pthread_t thread1, thread2;
char *message1 = "Hello";
char *message2 = "World\n";

// creearea primului thread tiprete Hello
if (pthread_create( &thread1, NULL, &print_message,
(void*)message1)){
fprintf(stderr,"first thread error\n");
exit(1);
}

// adoarme procesul printe pentru o secund.
sleep(1);

// creearea celui de al doilea thread tiprete World
if(pthread_create( &thread2, NULL, &print_message,
(void*)message2)){
fprintf(stderr,"second thread error\n");
exit(1);
}

sleep(1);
exit(0);
}

Compilarea programului se realizeaz cu urmtoarea comand:
Pagina 4
$ gcc -o hello_thread hello_thread.cc -D_REENTRANT -
lpthread

Opiunea lpthread trebuie specificat la compilarea programului datorit faptului c suportul
pentru thread-uri este adugat sub forma unei biblioteci.
O problem ce suport dou moduri de tratare, n cazul thread-urilor, este cea a terminrii
execuiei i a valorii returnate de thread. O prim modalitate este cea prezentat n exemplul anterior
n care funcia tratat de thread se ncheie prin apelul return, iar valoarea transmis este considerat
ca fiind valoare returnat de thread. O alt modalitate este prin intermediul apelului sistem
pthread_exit.

void pthread_exit(void *retval);

Aceast funcie poate fi apelat direct din funcia thread-ului sau din alt funcie apelat direct
sau indirect din funcia thread-ului. Valoarea primit ca i argument este valoarea ce va fi returnat
de thread.
Tot din exemplul anterior se poate observa c transmiterea parametrilor ctre thread se
realizeaz prin ultimul parametru al apelului pthread_creat. Dac nu se dorete transmiterea unui
parametru funciei thread-ului atunci argmentul respectiv primete valoare NULL. Valoarea acestui
parametru poate fi o referin ctre orice structur de date.
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>

// definirea structurii de date ce va fi transmis ca
argument thread-ului
struct chars {
char val;
int count;
};

// funcia thread-ului
void *char_print(void *ptr){

struct chars* c = (struct chars*)ptr;
for(int i=0;i<c->count;i++) putchar(c->val);
pthread_exit(0);
}

int main(){
Pagina 5
pthread_t thread1, thread2;
struct chars thread1_arg,thread2_arg;

// stabilirea parametrilor pentru thread-uri
thread1_arg.val='a';
thread1_arg.count=100000;

thread2_arg.val='b';
thread2_arg.count=150000;

// creearea thread-urilor

pthread_create(&thread1,NULL,&char_print,&thread1_arg
);

);

// ncheierea execuiei
exit(0);
}

Exemplul de mai sus creeaz dou thread-uri fiecare afind cte un caracter de cte un
anumit numr de ori, totodat este i un exemplu ce ilustreaz modul n care se pot transmite funciei
thread-ului argumente mai complexe. Totui acest program ascunde o problem de funcionare.
Funcia thread-ului primete ca i argumente referine ctre structuri de date definite ca i variabile
locale n thread-ul principal al programului. Datorit faptului c nu exist nici o regul asupra ordinii
de executare a thread-urilor este posibil ca thread-ul principal s i ncheie execuia naintea celor
dou thread-uri de afiare a caracterelor. O consecin este faptul c este dealocat memoria
rezervat structurilor de date transmise ca i parametrii thread-urilor. O rezolvare a acestei probleme
este apelul sistem pthread_join:
int pthread_join(pthread_t th, void **thread_return);

Acest apel sistem suspend execuia thread-ului apelant pn la ncheierea execuiei thread-
ului identificat prin ID-ul th.
Pthread_join primete dou argumente primul este ID-ul thread-ului dup care thread-ul
apelant trebuie s atepte s i ncheie execuia, iar al doilea este o referin ctre o locaie de
memorie n care se va reine valoarea returnat de thread-ul th. Dac valoarea returnat de thread-ul
th nu intereseaz, atunci al doilea argument va fi NULL.
n consecin pentru ca exemplul anterior s fie funcional trebuie completat cu urmtorul cod:

Pagina 6
// crearea thread-urilor
);
);

// thread-ul printe ateapt ncheierea execuiei
thread-urilor fiu.

pthread_join(thread1,NULL);
pthread_join(thread2,NULL);

// ncheierea execuiei
exit(0);
}

Trebuie avut grij ca orice tip de date ce este transmis unui thread prin referin s nu fie
dealocat, de thread-ul printe sau de oricare alt thread.
Uneori este util de determinat care este thread-ul care execut un anumit cod. Pentru a
determina ID-ul unui thread, avem la dispoziie apelul sistem pthread_self, care are ca i rezultat ID-
ul thread-ului care l apeleaz. De asemenea putem compara dou thread-uri pe baza ID-urilor cu
apelul pthread_equal.

pthread_t pthread_self(void);
int pthread_equal(pthread_t thread1, pthread_t
thread2);

De exemplu este o eroare ca un thread s apeleze pthread_join pentru el nsui. Pentru a evita
o astfel de eroare se poate utiliza urmtoarea secven de cod:
if(!pthread_equal(pthread_self(),alt_thread))
pthread_join(alt_thread, NULL);

Un alt aspect important n ceea ce privete crearea i utilizarea thread-urilor este dat
atributele thread-urilor ce pot fi transmise ca i argument funciei pthread_create. De fapt, acest apel
sistem primete ca i argument o referin ctre un obiect de tip thread attribute. Dac referina este
NULL, atunci se vor folosi atributele implicite pentru crearea thread-ului.
Dac se dorete creare unui thread pe baza unor atribute particulare este nevoie de crearea
unui obiect de tip thread attribute.Relativ la acest tip de obiecte sunt definite mai multe apeluri sistem
dintre care cele mai importante sunt: pthread_attr_init - iniializeaz obiectul primit ca i argument
cu valorile implicite, i pthread_attr_destroy dealoc resursele ocupate de obiectul primit ca i
argument.
Pagina 7

int pthread_attr_init(pthread_attr_t *attr);
int pthread_attr_destroy(pthread_attr_t *attr);

Pentru a defini un thread cu atribute particulare se aplic urmtorii pai:
Se creeaz un obiect de tipul thread attribute se declar o variabil de acest tip.
Obiectul creat este transmis ca i parametru funciei pthread_attr_init obiectul este
iniializat cu atributele implicite.
Se modific atributele dorite.
Se crea un thread pe baza apelului pthread_create cruia i se transmite ca i argument nou
creatul thread attribute.
Resursele ocupate de thread attribute trebuie eliberate se folosete pthread_attr_destroy.
Un singur obiect de tip thread attribute poate fi utilizat pentru crearea mai multor thread-uri,
dup care prezena acestui nu mai este necesar i obiectul poate fi dealocat.
# include<pthread.h>

void* thread_function(void *arg){

}

int main(){
pthread_attr_t attr;
pthread_t thread;

pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETA
CHED);
pthread_create(&thread,&attr,&thread_function,NULL);
pthread_attr_destroy(&attr);

exit(0);
}

Pentru majoritatea programelor un singur atribut al thread-ului este important, restul
atributelor se utilizeaz doar n cazul programelor de timp real. Acest atribut este detach state.
Conform acestui atribut un thread poate fi creat fie joinable (implicit), fie detached. n primul caz,
joinable, starea thread-ului nu este preluat de ctre sistemul de operare automat i rmne n sistem,
ca i n cazul proceselor zombie, pn cnd un alt thread apeleaz pthread_join. n cazul n care thread-
ul creat are atributul detached, starea de ieire a thread-ului este automat preluat de sistemul de
operare. Dezavantajul n acest caz este dat de dispariia posibilitii de sincronizare ntre thread-uri
prin intermediul funciei pthread_join.
Pagina 8
Chiar dac un thread a fost creat iniial ca i joinable ulterior poate fi trecut n starea detached
prin intermediul apelului sistem ptheread_detach.
n condiii normale un thread i ncheie execuia fie prin terminarea rulrii funciei thread-
ului returnnd o valoare, fie prin apelul sistem pthread_exit. Mai exist i o a treia posibilitate n care
un thread solicit unui alt thread ncheierea execuiei. n acest caz este folosit apelul sistem
pthread_cancel:
int pthread_cancel(pthread_t thread);

Deseori execuia normal a unui thread implic alocarea unor resurse, utilizarea lor i n final
dealocarea lor. Dac execuia unui thread este anulat n mijlocul unui astfel de proces, resursele
alocate iniial se vor pierde.
n concluzie din acest punct de vedere un thread se poate afla n una din urmtoarele stri:
Asincron anulabil i poate ncheia execuia n orice moment.
Sincron anulabil se poate solicita din exterior ncheierea execuiei, dar nu n orice moment.
Cererile de ncheiere a execuiei vor fi puse ntr-o coad de ateptare i vor fi luate n
considerare doar n anumite momente ale execuiei.
Neanulabil toate cererile de ncheiere a execuiei sunt ignorate.
Implicit toate thread-urile sunt sincron anulabile.
Acest mecanism de terminare a execuiei unui thread pe baza unor cereri externe se bazeaz
pe urmtoarele apeluri sistem:
int pthread_setcancelstate(int state, int *oldstate );
int pthread_setcanceltype(int type, int *oldtype);
void pthread_testcancel(void);

Aa cum am s-a artat anterior unui thread asincron anulabil i se poate solicita n orice
moment s i ncheie execuia, n timp ce un thread sincron anulabil i poate ncheia execuia doar n
anumite momente numite puncte de anulare.
Pentru ca un thread s fie asincron anulabil (implicit este sincron) se folosete apelul
pthread_setcanceltype unde primul argument este PTHREAD_CANCEL_ASYCHRONOUS
(PTHREAD_CANCEL_DEFFERD pentru a reveni la cazul sincron), al doilea argument este o referin
ctre o variabil care conine vechea stare, dac lipsete NULL:
pthread_setcanceltype(PTHREAD_CANCEL_ASYCHRONOUS,
NULL);

Pentru a testa dac un thread este anulabil ntr-un anumit punct se utilizeaz
pthread_testcancel. Utilizarea acestui apel sistem este valabil n cazul threa-urilor asincrone. Se
poate indica din interiorul thread-ului seciunile neanulabile prin apelul pthread_setcancelstate:
Pagina 9

int old_cancel_state;

pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,&old_ca
ncel_state)

pthread_setcancelstate(old_cancel_state, NULL);

Pe baza acestui apel se pot implementa seciuni critice, care fie se execut n ntregime, fie nu
se execut de loc. Dac un thread ncepe execuia unei astfel de seciuni atunci trebuie s o continue
pn la sfritul seciunii fr a fi anulat.
Implementarea thread-urilor POSIX este diferit de implementarea din multe alte sisteme de
operare de tip UNIX. Diferena este dat de faptul c n Linux thread-urile sunt implemntate ca i
procese. Fiecare apel pthread_create creeaz un nou proces ce ruleaz thread-ul nou creat. Oricum
acest proces este diferit de cel creat cu fork, el utilizeaz n comun spaiul de adrese i resursele cu
procesul original.
O problem ce se poate pune n cazul programelor implementate multithread este
gestionarea semnalelor. S presupunem c un astfel de program primete un semnal din exterior, se
pune ntrebarea care thread va apela funcia de tratare a semnalului (handler-ul). n cazul sistemelor
de operare de tip Linux problema este rezolvat chiar de implementarea acestora de tip proces
semnalul va fi tratat de thread-ul ce ruleaz programul principal. De asemenea, n interiorul unui
program multithread este posibil, ca un thread s poat trimite un semnal unui alt thread, pentru
aceasta se folosete apelul sistem pthread_kill.

Sisteme de operare Cursuri 9-14
Pagina 1
Curs 9
Managementul memoriei (1)

Logi c:
O formaie de jazz concerteaza 3 nopti pe saptamana ntr-un club. Ea este format din
cinci artiti care cnt la urmtoarele instrumente: saxofon, pian, chitar, trombon i
tobe. Despre ei circul urmtoarele zvonuri, dintre care numai unul este adevrat:
1. Saxofonista cnt adesea - la cererea publicului - piesa ei preferat "Ritmuri in
noapte";
2. Dan nu cnt la pian i nici la trombon;
3. Chitaristul nu este Andy i nici Paul, care de fapt nu cnt nici la pian;
4. Paul nu cnt la chitar, pian sau trombon;
5. Nici Isabela, Paul sau Vali nu cnt la tobe;
6. Nici Vali i nici Andy nu sunt saxofoniti;
7. Pe baterist l cheam Dan, Paul sau Andy.
La ce instrument cnt fiecare membru al formaiei ?

9. 1. Managementul memori ei

Intr-un sistem monoprocesor, memoria principal este mprit n 2 pri, o parte
pentru sistemul de operare (monitorul rezident, kernel) iar cealalt pentru programul care se
afl n execuie.
Intr-un sistem multiptogram, partea din memorie alocat userilor trebuie s fie
mprit astfel nct s fie atribuit fiecrui proces corespunztor userului respectiv. Taskul
de mprire i gestionare al memoriei poart numele de managementul memoriei.
Managementul memoriei este un task vital sistemelor de operare deoarece n momentul n
care procesele ateapt evenimente de la dispozitivele de I/O sau datorit faptului c
procesorul e ocupat, memoria trebuie s fie foarte bine gestionat pentru a putea ncrca ct
mai multe procese.
In mod normal, programatorul nu cunoate n avans care alte programe vor fi rezidente
n memoria principal n timpul execuiei propriului program. In plus, ne-ar place s putem
face un swap anumitor procese pentru a mri spaiul pentru cele aflate n starea de READY.
Dup ce un proces a fost swapat el va reveni napoi n memoria principal la o alt adres.
Aceasta reprezint relocalizarea. In acest caz, referinele de memorie trebuie translatate n cod
la noile adrese fizice. Datorit acestui fapt apar anumite aspecte tehnice ilustrate n figura
urmtoare. Figura descrie imaginea unui proces. Pentru simplitate vom considera c imaginea
procesului ocup o zona continu n memoria principal. Sistemul de operare trebuie s
cunoasc adresa unde gasete informaia de control a procesului i a stivei ca i punct de
intrare pentru execuia programului corespondent acestui proces. Deoarece sistemul de
operare este responsabil pentru aducerea proceselor n memoria principala, aceste adrese sunt
uor de obinut. In plus, procesorul trebuie s foloseasc referinele de memorie din program.
Din aceast cauz, hardware-ul (dat de procesor) i software-ul (dat de sistemul de operare)
Pagina 2
trebuie s fie capabile s translateze referinele de memorie gsite n program n adrese fizice
reflectnd locaia curent a programului n memoria principal.

Figura 9.1. Imaginea unui proces n memorie

Fiecare proces trebuie protejat mpotriva nedoritelor interferene ale altor procese,
provocate accidental sau intenionat. Astfel, programele reprezentnd alte procese trebuie s
nu fie capabile de a accesa referine de memorie ale altui proces pentru citire sau scriere fr o
permisiune n acest sens. Deoarece localizarea programului n memoria principal este
necunoscut, e imposibil verificarea adreselor absolute pentru asigurarea proteciei. Imaginea
procesului prezentat n figura anterioara ilustreaza cerinele legate de protecie. Normal, un
proces utilizator nu poate accesa o zon a sistemului de operare, program sau date. Apoi un
program al unui proces nu poate fi continuat cu o instruciune a altui proces n mod uzual.
Nici zona de date nu poate fi accesat ntre procese fr a exista un protocol n acest sens.
Fiecare mecanism de protectie trebuie s fie flexibil astfel nct s permit mai multor
procese s acceseze o aceeai zon de memorie. Procesele care coopereaz pentru ndeplinirea
unui task trebuie s dein un acces partajat asupra unei zone comune de date. Sistemul de
management al memorie trebuie s permit un acces partajat la aceeai zon de memorie fr
a nclca protecia datelor.
Programele sunt organizate n module n timp ce memoria are o organizare logic dat
de secvene de bii. O serie de avantaje pot aprea dac sistemul de operare vede programele
i datele organizate sub forma unor module:
modulele pot fi scrise i compilate independent cu toate referinele dintre ele rezolvate
n momentul rulrii;
Pagina 3
pot fi atribuite diverse grade de protecie diferitelor module destul de uor;
se poate realiza o distribuire usoara a modulelor catre mai multi utilizatori.
Memoria calculatorului este organizat n cel puin 2 nivele: memoria principal,
scump dar foarte rapid i memoria secundar, mai ieftin dar nceat. Un task important
pentru managementul memoriei l constituie organizarea memoriei pe cele dou nivele. Una
dintre principalele operaii pentru sistemul de operare este aducerea programelor n memoria
principal pentru a fi executate de ctre procesor. In sistemele moderne aceasta este cunoscut
sub numele de memorie virtual. Memoria virtual se bazeaz pe una din urmatoarele tehnici
de organizare: segmentare sau paginare. In cazul partiiilor de dimensiune egal (partiionare
fix) un proces poate fi ncrcat ntr-o anumit partiie dac dimensiunea lui este mai mic sau
egal cu dimensiunea partiiei. In cazul n care toate partiiile sunt pline, procesul poate fi
swapat. In cazul n care un program nu poate intra ntr-o partiie, acest lucru trebuie specificat.
Practic, sistemul nu este eficient deoarece un program ct de mic va ocupa o ntreag partiie-
duce la fragmentare intern.

Figura 9.2. Exemple de partiionare fix

In figura 9.2. avem 2 exemple pentru partiionare fix. Prima figur ne prezint partiii de
dimensiuni egale n timp ce a doua partiionare are dimensiuni diferite pentru partiiile care o
compun.
Procesul de partiionare fix are multe neajunsuri. Datorit partiiilor fixe nu conteaz
care dintre ele este utilizat. In cazul n care avem partiii de dimensiuni diferite exist 2 ci
Pagina 4
de atribuire a proceselor. Cea mai simpl metod este atribuirea fiecrui proces celei mai mici
partiii n care acesta intr. Apare o coad de ateptare pentru fiecare partiie pentru c la un
moment dat e posibil ca mai multe procese de dimensiuni apropiate s doreasc aceeai
partiie. Avantajele constau n faptul c este minimizat cantitatea de memorie irosit. Dar
aceast modalitate este optim din punct de vedere al unei partiii dar nu i din punctul de
vedere al ntregului sistem.
In figura urmtoare observm cele 2 mecanisme care sunt discutate. Presupunnd c la
un moment dat o zon de memorie de 8 M nu este ocupat de nici un proces dar exist cozi de
ateptare pentru poriuni mai reduse de memorie ne dm seama c acest prim mecanism poate
duce la diverse ntrzieri care ar putea fi evitate dac s-ar permite unui proces mai mic s
foloseasc i zone mai mari de memorie. Astfel, avem o a doua abordare cu o singur coad
de ateptare pentru toate procesele. Pentru un proces va fi aleas cea mai mic partiie pe care
acesta o poate ocupa. In cazul n care toate partiiile sunt ocupate, atunci va fi luat o decizie
de swapare. In acest caz pot fi luai n calcul diferii factori precum prioritatea sau alte criterii.
Figura 9.3. Metode de partiionare a memoriei

Partiionarea prin aceast metod ofer o relativ flexibilitate dar mai apar o serie de
dezavantaje:
numrul de partiii limiteaz numrul de procese active din sistem;
ocuparea partiiilor nu este eficient.
In prezent acest mod de partiionare nu mai este folosit.
In cadrul partiionrii dinamice, partiiile sunt de lungime i numr variabile. Fiecare
proces are alocat exact atta memorie ct are nevoie. In figura 5.4, iniial memoria principal
este goal, n afar de partea ocupat de sistemul de operare. Primele 3 procese sunt ncrcate
ncepnd cu locaia la care se termin sistemul de operare i ocup doar spaiul suficient
pentru fiecare proces. Apoi sistemul de operare face un swap la 2 procese lsnd suficient loc
Pagina 5
pentru altele datorit faptului c la acel moment nici un proces nu e in stare de Ready.
Deoarece procesul 4 este mai mic ca i ocupare n memorie dect procesul 2 apare un spaiu
liber n memorie. Dac se dorete aducerea din nou a procesului 2, nu mai este posibil datorit
faptului c acesta ocup prea mult loc. Pentru a putea fi adus se face un swap la procesul 1.
Aceasta ilustrare ne conduce la apariia unei fragmentri externe datorat apariiei spaiilor
libere n memorie. O metod de mbuntire a situaiei se numete compactare. Din timp n
timp, sistemul de operare face un shift pentru procese astfel ca acestea s ocupe ct mai bine
spaiul de memorie pe care l au la dispoziie.

Figura 9.4. Exemplu de partiionare dinamic

Datorit faptului c procesul de compactare este unul consumator de timp, sistemul de
operare trebuie s tie cum s atribuie procese spaiului de memorie. Trei algoritmi de plasare
pot fi folosii. Primul dintre acetia se numete best-fit i alege blocul care este cel mai
apropiat ca dimensiune de dimensiunea procesului. Algoritmul al doilea poart denumirea de
first-fit i pornete cutarea de la nceputul spaiului de memorie alegnd blocul de memorie
care este suficient de ncptor pentru proces. Ultimul, next-fit scaneaz zona de memorie
ncepnd de la ultimul bloc atribuit pn gsete unul corespunztor pentru proces. In cele 2
reprezentri putem observa diferenele dintre cei trei algoritmi. Astfel, pentru first-fit este
gsita prima zona de memorie liber n care putem pune procesul respectiv, pentru best-fit
este gasit cea mai bun zon iar pentru next-fit zona de memorie ncepnd de la ultima
alocare. Pentru a stabili care dintre cei algoritmi este mai bun trebuie s lum n considerare i
modul de apariie sau de swapare al proceselor n ultimele doua cazuri. In general cel mai
Pagina 6
utilizat este next-fit i pentru c se raporteaz la un spaiu de memorie care a fost ultimul
ocupat. Best-fit este cel mai bun din punct de vedere al ocuprii memoriei dar i cel mai ncet,
n timp ce first-fit este cel mai simplu dar nu cel mai eficient.

Figura 9.5. Comparaie ntre cei 3 algoritmi

Intr-un sistem de operare cu multiprogramare se ajunge la un moment dat n situaia n
care toate procesele din memoria principal sunt n starea blocat i chiar i dup compactare
exist prea puin memorie pentru a asigura spaiul pentru alte procese. Att partiionarea fix
ct i cea dinamic au problemele lor. O partiionare fix limiteaz numrul proceselor i
poate duce la o folosire ineficient a spaiului de memorie n timp ce una dinamica e mai
complicat de realizat i apar probleme la compactare. Un compromis interesant l reprezint
sistemele de tip buddy. Intr-un astfel de sistem, spaiul disponibil pentru alocare este vzut ca
blocuri de dimensiunea 2k unde k poate lua valori ntre l i u obinndu-se astfel blocuri de
mrime maxim sau minim.
Pentru inceput, ntreg spaiul este tratat ca un singur bloc cu dimensiunea 2u. Dac
este facut ocerere mai mic dect aceast valoare, atunci ntregul bloc este alocat. Altfel,
ntregul bloc este mprit n dou de dimensiuni 2u-1. Dac unul dintre cele nemprit la doi
poate conine procesul, atunci acesta este ncrcat. Dac nu, algoritmul continu pn se
ajunge la dimensiunea dorit. La fiecare moment de timp sistemul menine o list de blocuri
de dimensiune inferioar care nu sunt alocate. Un spaiu liber din memorie poate fi mprit n
dou i trecut ntre blocurile de dimensiune corespunztoare care pot fi ocupate cu procese. In
Pagina 7
momentul n care o pereche de blocuri rmn libere, ele pot fi unite i se obine un bloc cu o
dimensiune mai mare.
Figura 9.6. Exemplu sistem de tip buddy

In figur considerm un bloc iniial de 1 Mbyte. Prima cerere, A este de 100 kbytes pentru
care alocm un bloc de 128 kbytes. Blocul iniial este mprit de 3 ori pentru a obine
segmentul dorit. Urmtoarea cerere, B, ne solicit un bloc de 256K. Acest bloc este deja
disponibil i poate fi alocat fr probleme. Procesul continu. Observm c n momentul n
care se elibereaz blocul de memorie notat cu E acesta este imediat unit cu jumtatea lui,
s.a.m.d. pn la eliberarea ntregului spaiu.

Figura 9.7. Structura arborescent a sistemelor de tip buddy
Pagina 8
Sistemul buddy are o alocare de tip arborescent prezentat n figura 9.7. Frunzele arborelui
corespund partiionrii curente a memoriei. Dac 2 pri de memorie sunt frunze nseamn c
cel puin una trebuie alocat. In caz contrar, ele vor fi unite ntr-un bloc mai mare. Cu toate c
sistemul mbuntete partiionarea fix sau dinamic, n sistemele moderne folosirea
paginrii sau segmentrii la memoria virtual d rezultate mbuntite. Doar Unix-ul mai
folosete o form modificat a acestui algoritm, dar cu tendine de schimbare.

Pagina 9
Curs 10

Logi c:
Pentru un numr N, numim pon(N) numrul de operanzi prin care se poate exprima N
folosind numai numrul 1, precum i operaiile de adunare i nmulire.
In plus, numrul operanzilor (toi egali cu 1) este minim.

Astfel, pon(8) = 6 deoarece 8 = (1 + 1) * (1 + 1) * (1 + 1)
Este posibil i 8 = 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 sau 8 = (1 + 1 + 1) * (1 + 1) + 1 + 1
dar aceste expresii conin opt respectiv apte valori de 1.
Mai mult, nu se poate afla nici o exprimare a lui 8 cu mai puin de ase operanzi.

S se afle pon(N) pentru N = 10, 11,..., 20.

10.1. Paginarea

O modalitate foarte rspndit pentru managementul memoriei este cea de paginare. Prin
aceasta intelegem mprirea n buci mici a memoriei i mprirea fiecrui proces ntr-un
numr de entiti de aceast dimensiune. In cazul procesului, prile lui se numesc pagini iar

Figura 10.1. Exemplu de paginare n cazul celor 4 procese
Pagina 10
cele de memorie se mai numesc frame-uri. Sistemul de operare ntreine un tabel pentru
fiecare proces. Acest tabel conine locaii pentru fiecare pagin a procesului i adrese de
memorie cu numrul paginii i un deplasament n pagin. Odat cu paginarea, convertirea din
adrese logice n adrese fizice este realizat de ctre procesor.
In figura 10.1. am reprezentat un exemplu de ncrcare a proceselor n memorie.
Procesul A conine 4 pagini. Procesul B este ncrcat dup procesul A i are doar 3 pagini.
Apoi este incrcat i procesul C cu 4 pagini. Procesul B este suspendat i swappat din
memoria principal. Procesul D care este adus n memoria principala ocup 5 pagini i va
ocupa locaiile lsate libere de procesul B i nc 2 n plus.
Observm c paginarea simpl nseamn de fapt o mprire fix a memoriei cu diferena c
paginile sunt entiti mici i un proces poate fi mprit n mai multe astfel de entiti.

6.2. Memoria virtual

Memoria virtual este o tehnic ce permite execuia proceselor fr a impune
necesitatea ca ntreg fiierul executabil s fie ncrcat n memorie sau capacitatea de a adresa
un spaiu de memorie mai mare dect este cel din memoria intern a unui calculator.
Utilizarea memoriei virtuale ofer avantajul c poate fi executat un program de dimensiune
orict de mare (mai mare dect dimensiunea memoriei fizice). Spaiul de adrese al procesului
este divizat n pri care pot fi ncrcate n memoria intern atunci cnd execuia procesului
necesit acest lucru i transferate napoi n memoria secundar, cnd nu mai este nevoie de
ele. Spaiul de adrese al unui program se mparte n partea de cod, cea de date i cea de stiv,
identificate att de compilator ct i de mecanismul hardware utilizat pentru relocare.
Partea (segmentul) de cod are evident un numr de componente mai mare, fiind
determinat de fazele de execuie (logic) ale programului. De exemplu, aproape toate
programele conin o faz necesar iniializrii structurilor de date utilizate n program, alta
pentru citirea datelor de intrare, una (sau mai multe) pentru efectuarea unor calcule, altele
pentru descoperirea erorilor i una pentru ieiri. Analog, exist partiii ale segmentului de
date. Aceast caracteristic a programului se numete localizare a referinelor n spaiu i este
foarte important n strategiile utilizate de ctre sistemele de memorie virtual.
Cnd o anumit parte a programului este executat, este utilizat o anumit poriune
din spaiul su de adrese, adic este realizat o localizare a referinelor. Cnd se trece la o alt
faz a calcului, corespunztoare logicii programului, este refereniat o alt parte a spaiului
de adrese i, deci se schimb aceast localizare a referinelor.
Alocarea paginat a aprut la diverse sisteme de calcul pentru a evita fragmentarea
memoriei interne, care apare la metodele anterioare de alocare. Memoria virtual este
mprit n zone de lungime fix numite pagini virtuale. Paginile virtuale se pstreaz n
memoria secundar. Memoria operativ este mprit n zone de lungime fix, numite pagini
fizice. Lungimea unei pagini fizice este fixat prin hard. Paginile virtuale i cele reale (fizice)
au aceeai lungime, lungime care este o putere a lui 2, i care este o constant a sistemului (de
exemplu 1Ko, 2Ko, etc ). S presupunem c G reprezint numrul de locaii de memorie
virtual ale unui fiier executabil, ale cror adrese sunt cuprinse ntre 0 i G-1. De asemenea,
s notm cu H numrul locaiilor din memoria intern, necesare pentru a ncrca coninutul
Pagina 11
fiierului executabil, n timpul execuiei procesului (H<G). De asemenea, cele G-1 locaii
virtuale, corespund la n, cu
g
2 n = pagini virtuale, fiecare pagin fiind de dimensiune c, cu
h
2 c = . Spaiul de adrese din memoria primar poate fi gndit ca o mulime de m pagini
fizice,
j
2 m= , fiecare avnd dimensiunea
h
2 c = , deci cantitatea de memorie intern alocat
procesului va fi
j h
2 H
+
= . La un anumit moment al execuiei, conform principiului localizrii,
numai o parte din paginile virtuale vor fi ncrcate n memoria intern, n pagini fizice.
Problema care se pune este translatarea fiecrei adrese virtuale ntr-o adres fizic.
Translatarea adreselor virtuale. Fie { }
1 n 1 0
d ,.., d , d N

= mulimea paginilor n spaiul de
adrese virtuale i { }
1 m 1 0
b ,.., b , b M

= mulimea paginilor fizice din memoria primar alocate
procesului. O adres virtual este un ntreg i, unde
h g
2 G i 0
+
= < , deoarece exist
g
2 n =
pagini, fiecare avnd
h
2 cuvinte (locaii) de memorie. O adres fizic, k, este o adres de
memorie, de forma ) 2 V V(0 U2 k
h h
< + = , unde U este numrul pagini fizice. Deci
h
U2
este adresa din memoria primar a primei locaii din pagina fizic, iar V este deplasamentul
din cadrul paginii fizice U. Deorece procesului i sunt alocate
j
2 pagini fizice, vom avea
h j
2 H
+
= locaii de memorie fizic care pot fi utilizate de proces. Corespondena dintre
adresele virtuale i cele fizice are forma
[ ] { } V U, 1 G 0,..., :
t
> < .
Deoarece fiecare pagin are aceeai dimensiune c, adresa virtual i poate fi convertit
ntr-un numr de pagin i un deplasament n cadrul paginii, numrul de pagin fiind I div c,
iar deplasamentul i mod c. Dac considerm reprezentarea binar a adresei, atunci numrul
de pagin poate fi obinut prin deplasare spre dreapta a adresei cu h poziii, iar deplasamentul
prin extragerea primilor g bii cei mai puin semnificativi din adres. Deci fiecare adres
virtual, repectiv adres fizic va fi de forma (p,d), respectiv de forma (f,d), unde p este
numrul paginii virtuale, f este numrul paginii fizice, iar d este adresa (deplasamentul) n
cadrul paginii.
Orice pagin virtual din spaiul de adrese al procesului, poate fi ncrcat n oricare din
paginile fizice din memoria intern alocate acestuia. Acest lucru este realizat printr-o
component hardware numit MMU(Memory Management Unit), care implementeaz funcia
t
(figura 6.1). Dac este refereniat o locaie dintr-o pagin care nu este ncrcat n
memoria intern, MMU oprete activitatea unitii centrale, pentru ca sistemul de operare s
poat executa urmtorii pai:
1. Procesul care cere o pagin nencrcat n memoria intern este suspendat.
2. Administratorul memoriei localizeaz pagina respectiv n memoria secundar.
3. Pagina este ncrcat n memoria intern, eventual n locul altei pagini, dac n
memoria intern nu mai exist pagini fizice libere alocate procesului respectiv i n
acest caz, tabela de pagini este modificat.
4. Execuia procesului se reia din locul n care a fost suspendat.
Pagina 12
Fiecare proces are propria lui tabel de pagini, n care este trecut adresa fizic a paginii
virtuale, dac ea este prezent n memoria operativ. La ncrcarea unei noi pagini virtuale,
aceasta se depune ntr-o pagin fizic liber. Deci, n memoria operativ, paginile fizice sunt
distribuite n general necontinuu, ntre mai multe procese. Spunem c are loc o proiectare a
spatiului virtual peste cel real.

Figura 10.2. Translatarea unei pagini virtuale ntr-una fizic
Acest mecanism are avantajul c folosete mai eficient memoria operativ, fiecare
program ocupnd numai memoria strict necesar la un moment dat. Un alt avantaj este
posibilitatea folosirii n comun, de ctre mai multe programe, a instruciunilor unor proceduri.
O procedur care permite acest lucru se numeste procedur reentrant.
Evidena paginilor virtuale ncrcate n pagini fizice, este relizat printr-o tabel. Dac
prin M[0..m] notm memoria operativ, prin j puterea lui 2 (numrul de bii) care d lungimea
unei pagini, prin TP adresa de start a tabelei de pagini, atunci pe baza adresei virtuale (p,d) se
poate determina locaia de memorie fizic corespunztoare, care este d 2 * p] M[TP
j
+ + , dac
locaia virtual respectiv este ncrcat n memorie.
Formula anterioar este valabil atunci cnd tabela de pagini ocup un spaiu n
memoria operativ. Tabela de pagini poate fi privit ca o funcie, care are ca argument
numrul de pagin virtual i care determin numrul de pagin fizic. Pe baza
deplasamentului se determin locaia din memoria fizic unde se va ncrca locaia virtual
refereniat. Aceast metod ridic dou mari probleme:
tabela de pagini poate avea un numr mare de intrri. Calculatoarele moderne folosesc
adrese virtuale pe cel puin 32 de bii. Dac, de exemplu o pagin are dimensiunea de
4K, atunci numrul intrrilor n tabel este mai mare dect un million. n cazul
adreselor pe 64 de bii numrul intrrilor n tabel va fi, evident mult mai mare.
corespondena dintre locaia de memorie virtual i cea din memoria fizic trebuie s
se realizeze ct mai rapid posibil; la un moment dat, o instruciune cod main poate
referenia una sau chiar dou locaii din memoria virtual.

Adresa virtual Adresa fizic Memoria intern

f

Tabela de pagini
MMU
U
(p d)

f
(f,d
)

d

Pagina 13
Pentru rezolvarea aceastei probleme, s-au ncercat mai multe soluii O prim metod
const n folosirea de regitri ai unitii centrale pentru memorarea intrrilor n tabel, soluie
care asigur un acces rapid dar care este foarte costisitoare. O a doua metod propune ca
tabela de index s fie ncrcat n memoria primar, folosind un registru pentru a memora
adresa de nceput a tabelei. Aceast metod permite ca tabela de index s fie ncrcat n zone
diferite din memorie, prin modificarea coninutului registrului. O metod mult mai eficient,
care nlocuiete cutarea secvenial cu cea arborescent este organizarea tabelei pe mai multe
niveluri. Astfel, o adres virtual pe 32 de bii de exemplu, este un triplet (Pt
1
, Pt
2
, d), primele
dou cmpuri avnd o lungime de 10 bii, iar ultimul de 12 bii. n figura 10.3 este ilustrat o
astfel de tabel de pagini.
Nivelul 2
0
1 Deplasament
Nivelul 1 .
0 .
1 1023
2
.
.
1023

Figura 10.3. Tabele de pagini pe 2 niveluri

Observm c numrul de intrri n tabela de nivel 1 este de 2
10
=1024, iar dimensiunea
unei pagini este de 2
12
=4x2
10
=4K. Fiecare intrare n aceast tabel conine un pointer ctre o
tabel a nivelului 2. Cnd o adres virtual este prezentat MMU, se extrage valoarea
cmpului PT
1
, care este folosit ca index n tabela de la nivelul 1. Pe baza acestuia, se gsete
adresa de nceput a uneia dintre tabelele de la nivelul 2. Cmpul PT
2
va fi un index n tabela
de la nivelul 2 selectat, de unde se va lua numrul de pagin fizic corespunztor numrului
de adres virtual coninut n adresa refereniat. Pe baza acestui numr i a deplasamentului
(d), se determin locaia de memorie fizic n care va fi ncrcat respectiva locaie din
memoria virtual. n condiiile specificate, o tabel de la nivelul 2 va gestiona o zon de
memorie de capacitate 1024 x 4 K=4 M.
Pe lng cmpul care conine numrul de pagin fizic, intrarea respectiv mai conine
i alte cmpuri, dintre care cele mai semnificative sunt:
Bitul prezent/absent indic faptul c pagina respectiv este/ sau nu (setat pe 1/setat pe 0)
ncrcat n memoria fizic.
Biii de protecie specific ce fel de tip de acces este permis. n forma cea mai simpl,
acest cmp este de 1 bit, setat pe 0 pentru permisiune de citire i scriere i 1 numai
pentru citire. Sistemele moderne folosesc 3 bii de protecie, unul setat pentru
permisiunea de citire, unul pentru scriere i unul care specific dreptul de execuie.
Bitul modificat indic dac n pagina respectiv s-a scris sau nu.
Bitul referit indic dac pagina respectiv a fost refereniat sau nu.
Pagina 14
Bitul caching disabled/enabled indic posibilitatea ncrcrii paginii respective n
memoria cache.
Tabela de pagini se poate organiza i pe 3 sau 4 niveluri, n funcie de dimensiunea memoriei
virtuale i a celei fizice. Dac tabela are o dimensiune mare, ea poate fi pstrat(cel puin
parial) i pe un disc rapid.
Exemplu: Fie adresa virtual Ox00403004 (4202996 n zecimal). Dac se face transformarea
n binar se obine valoarea 1 pentru cmpul PT
1
, 3 pentru PT
2
, iar pentru deplasament
valoarea 4. Pe baza valorii lui PT
1
, MMU va gsi c componenta PT
2
a adresei se afl n a
doua tabel de la nivelul 2, care corespunde la adrese ntre 4M i 8M . Folosind PT
2
ca index
n a doua tabel de nivel 2, avnd valoarea 3, se determin c adresa locaiei este cuprins
ntre adresele relative la pagina respectiv de memorie 12292 i 16383, corespunztoare
adreselor absolute 4 202 592 i 4 210 687. Se adug valoarea 4 a deplasamentului i se obine
adresa locaiei, adic 4 202 596. Pe baza valorii bitului present/absent se determin dac
pagina virtual este (sau nu) adus n memoria fizic.
Memoria asociativ. Indiferent de modul de organizare a tabelei de pagini, atunci cnd
este refereniat o locaie dintr-o pagin virtual, n funcie de modul de organizare a tabelei,
precum i de instruciunea cod main respectiv, trebuie s se fac una sau mai multe
referine la diverse locaii de memorie. S-a observat c majoritatea programelor fac un numr
mare de referine la un numr relativ mic de pagini. Astfel, un numr mic de intrri n tabela
de paginare sunt efectiv citite. O soluie pentru rezolvarea acestei probleme, este utilizarea
unei componente hardware care s proiecteze spaiul de adrese virtuale, n cel de adrese
fizice, fr a trece prin tabela de pagini, numit memorie asociativ. Ea face parte din MMU
i const dintr-un numr mic de intrri, 8 n exemplul din figura 10.4, i care de regul nu
depete 32.
Intrare Pagina Modificat Protecie Pagina
valid virtual fizic
1 140 1 RW 31
1 20 0 R X 38
1 130 1 RW 29
1 129 1 RW 62
1 19 0 R X 50
1 21 0 R X 45
1 860 1 RW 14
1 861 1 RW 75
Figura 10.4 Un exemplu de memorie asociativ

Fiecare intrare conine informaii despre o pagin, cum ar fi, de exemplu, numrul de
pagin virtual, bitul de modificare, codul de protecie i numrul de pagin fizic unde se
afl ncrcat pagina virtual respectiv. Aceste cmpuri corespund cu cele corespunztoare
din tabela de pagini. De asemenea, mai exist un cmp de un bit, care indic dac intrarea este
valid, adic este n curs de utilizare sau nu.
n exemplul prezentat, procesul este ntr-o bucl care traverseaz paginile 19, 20 i 21,
deci aceste intrri sunt prezente n memoria asociativ, avnd setat codul de protecie pentru
Pagina 15
citire i execuie. Datele utilizate reprezint un tablou care se afl n paginile 129 i 130.
Pagina 140 conine indicii folosii n calculele efectuate asupra tabloului. Stiva de program
este coninut n paginile 860 i 861.
Cum funcioneaz memoria asociativ? Cnd o adres virtual este prezentat MMU
pentru translatare, componenta hardware verific mai nti dac numrul su de pagin
virtual este prezent n memoria asociativ, lucru care se realizeaz prin compararea lui cu
cele din toate intrrile din tabel. Dac se gsete o astfel de intrare i dac accesarea acesteia
nu violeaz biii de protecie, pagina fizic corespunztoare este luat direct din memoria
asociativ, fr a mai fi necesar nici o referin la tabela de pagini. Dac pagina virtual este
prezent n memoria asociativ dar instruciunea respectiv violeaz drepturile de protecie
(de exemplu s scrie ntr-o pagin setat numai pentru citire), este generat o eroare de
protecie, fiind acelai lucru cu a nu gsi pagina respectiv n memoria asociativ. Cnd
numrul de pagin virtual nu este gsit n memoria asociativ, atunci MMU va detecta lipsa
acesteia, va face o cutare n tabela de pagini, i va aduce pagina gsit ntr-o intrare din
memoria asociativ, dup ce, eventual a evacuat pagina existent n intrarea respectiv.
Alocare segmentat. Din punctual de vedere al utilizatorului, o aplicaie este format
dintr-un program principal i o mulime de subprograme(funcii sau proceduri). Aceste
folosesc diferite structuri de date (tablouri, stive etc), precum i o mulime de simboluri
(variabile locale sau globale). Toate aceste sunt identificate printr-un nume.
Pornind de la aceast divizare logic a unui program, s-a ajuns la o metoda de alocrii
segmentare a memoriei. Spre deosebire de metodele de alocare a memoriei bazate pe
partiionare, unde fiecrui proces trebuie s i se asigure un spaiu contiguu de memorie,
mecanismul de alocare segmentat, permite ca un proces s fie plasat n zone de program
distincte, fiecare dintre ele coninnd o entitate de program, numit segment. Segmentele pot fi
definite explicit prin directive ale limbajului de programare sau implicit prin semantica
programului. De exemplu, un compilator de Pascal poate crea segmente de cod pentru fiecare
procedur sau funcie, segmente pentru variabilele globale, segmente pentru variabilele locale,
precum i segmente de stiv. Deosebire esenial dintre alocarea paginat i cea segmentat
este aceea c segmentele sunt de lungimi diferite.
n mod analog cu alocarea paginat, o adres virtual este o pereche (s,d), unde s este
numrul segmentului iar d este adresa din cadrul segmentului. Adresa real (fizic) este o
adres obisnuit. Transformarea unei adrese virtuale ntr-o adres fizic, se face pe baza unei
tabele de segmente. Fiecare intrare n acest tabel este compus dintr-o adres de
baz(adresa fizic unde este localizat segmentul n memorie) i lungimea segmentului(limit).
n figura 10.5 este ilustrat modul de utilizare a tabelei de segmente.
Componenta s a adresei virtuale, este un indice n tabela de segmente. Valoarea
deplasamentului d trebuie s fie cuprins ntre 0 i lungimea segmentului respectiv(n caz
contrar este lansat o instruciune trap, care genereaz o ntrerupere). Dac valoarea d este
valid, ea este adugat adresei de nceput a segmentului i astfel se obine adresa fizic a
locaiei respective.

Pagina 16

Figura 10.5. Translatarea adreselor segmentate

Avantajele alocrii segmentate, fa de cea bazat pe partiii sunt:
se pot creea segmente reentrante, care pot fi partajate de mai multe procese. Pentru
aceasta este suficient ca toate procesele s aib n tabelele lor aceeai adres pentru
segmentul respectiv.
se poate realiza o bun protecie a memoriei. Fiecare segment n parte poate primi alte
drepturi de acces, drepturi trecute n tabela de segmente. De exemplu, un segment care
conine instruciuni cod main, poate fi declarat read-only sau executabil. La orice
calcul de adres, se verific respectarea modului de acces al locaiilor din segmental
respectiv.
Alocarea segmentat cu paginare. Cele dou metode de alocare a memoriei au avantajele
i dezavantajele lor. n cazul segmentrii poate s apar fenomenul de fragmentare. n cazul
paginrii, se efectueaz o serie de operaii suplimentare de adresare. De asemenea, unele
procesoare folosesc alocarea paginat (Motorola 6800), iar altele folosesc segmentarea (Intel
80x86, Pentium). Ideea segmentrii cu paginare, este aceea c alocarea spaiului pentru
fiecare segment s se fac paginat. Aceast metod este utilizat de sistemele de operare
actuale.
Spaiul de adrese virtuale al fiecrui proces este mprit n dou partiii; prima partiie
este utilizat numai de ctre procesul respectiv, pe cnd cealalt partiie, este partajat
mpreun cu alte procese. Informaiile despre prima partiie, respective a doua partiie sunt
pstrate n descriptorul tabelei locale (LDT Local Descriptor Table), respectiv descriptorul
tabelei globale (GDT Global Descriptor Table). Fiecare intrare n LDT/GDT este

s
limit baz

< da

nu

CPU
s d
Lansare instruciune trap
(Eroare de adresare)
+

Mem-
oria
fizic
Pagina 17
reprezentat pe 8 octei i conine informaii despre un anumit segment, printre care adresa de
nceput i lungimea acelui segment.
Adresa virtual este o pereche (selector, deplasament). Selectorul este reprezentat pe 16
bii i este un triplet (s, g, p) n care s este numrul de segment (13 bii), g specific dac
segmental este din LDT sau GDT i p specific protecia. Deplasamentul este reprezentat pe
32 de bii i specific adresa local a unui octet n cadrul segmentului.
Calculatorul are 6 regitri de segmente, ceea ce permite ca un proces s adreseze 6
segmente n orice moment. De asemenea are 6 regitri pe 8 octei, care pstreaz descriptori
pentru LDT sau GDT. Acest mod de organizare permite accesarea rapid a entitilor
respective.
Translatarea unei adrese virtuale n adres fizic se realizeaz astfel:
registrul de segment conine un pointer ctre intrarea din LDT sau GDT
corespunztoare acelui segment;
de aici se iau adresa de nceput i deplasamentul;
dac adresa respectiv este valid, valoarea deplasamentului este adugat la adresa de
nceput i astfel se obine o adres liniar, care apoi este translatat ntr-o adres fizic.
Aa cum am specificat mai devreme, fiecare segment este mprit n pagini, fiecare
pagin avnd o dimensiune de 4 Ko. Datorit dimensiunii posibile a unui segment, tabelele de
paginii poate avea un numr mare de intrri (pn la 1 000 000). Deoarece fiecare intrare are
o lungime de 4 octei, rezult c o astfel de tabel poate avea o dimensiune de 4 Mo, deci ea
nu poate fi pstrat ca o list liniar n memoria intern. Soluia este de a folosi o tabel pe
dou niveluri. Mecanismul de translatare a adresei este similar cu cel utilizat n cazul alocrii
paginate a memoriei.

Pagina 18
Curs 11

Logic:
Pentru a trece de la calendarul pe stil vechi (iulian) la cel pe stil nou (gregorian) Papa
Gregorie a decretat n 1582 ca dup joi 4 oct (stil vechi) s urmeze vineri 15 octombrie (stil
nou). In calendarul iulian, toi anii divizibili cu 4 sunt ani biseci; n calendarul gregorian anii
divizibili cu 100 nu sunt biseci dect dac sunt divizibili cu 400.
De exemplu, 1996 i 2000 sunt ani biseci n ambele calendare, dar 1900 este an bisect numai
n calendarul iulian (nu i n cel gregorian).
Care este primul an dup 1582 cnd cele dou calendare coincid ?

11.1. Algoritmi de paginare

Conceptul de memorie virtual, permite ca un program n execuie s nu fie
obligatoriu ncrcat integral n memoria intern. O justificare a necesitii acestui aspect,
poate rezulta din urmtoarele exemple:
programele conin pri de cod n care se testeaz anumite condiii de eroare, pentru
care se execut anumite proceduri i care se ntmpl foarte rar;
unor structuri de date declarate n program, li se aloc un spaiu mult mai mare dect
cel utilizat efectiv de ctre procesul respectiv.
Posibilitatea execuiei unui program, care este ncrcat parial n memoria intern,
ofer o serie ntreag de avantaje, printre care:
nu mai exist restricii cu privire la dimensiunea programelor, deoarece cantitatea de
memorie virtual care poate fi alocat proceselor, poate fi orict de mare;
deoarece cantitatea de memorie fizic pe care o folosete efectiv un proces scade,
crete gradul de multiprogramare i, deci gradul de utilizare a CPU;
sunt necesare mai puine operaii de intrare/ieire pentru ncrcarea/evacuarea
programelor de pe/pe disc.
Exist dou tipuri de baz de algoritmi de paginare: statici i dinamici. Algoritmii
statici aloc un numr fix de pagini fizice fiecrui proces n timpul execuiei, pe cnd n cazul
celor dinamici acest numr poate s fie variabil.
Algoritmi statici. Oricare algoritm de paginare este definit trei politici:
politica de extragere (fetch) decide cnd o pagin va fi ncrcat n memoria primar;
politica de nlocuire determin care pagin va fi mutat din memoria intern atunci
cnd toate paginile acesteia sunt pline cu informaii ale proceselor n execuie;
politica de plasare determin unde va fi plasat o pagin extras din memoria intern.
Deoarece numrul paginilor fizice este fixat n cadrul alocrii statice, pagina fizic
unde va fi adus o pagin virtual, va trebui s fie ori o pagin liber, ori una n care se va
nlocui informaia deja existent, care fac parte din spaiul de adrese al procesului respectiv.
Pagina 19
Deci politica de plasare este aceeai, celelate dou politici difereniaz algoritmii statici de
paginare.
Politici de extragere. Politica de extragere utilizat este aducerea unei pagini la
cerere. Deoarece nu se cunoate apriori evoluia unui proces, nu se poate stabili dinainte o
politic de pre-extragere a paginilor. Exist unele sisteme care utilizeaz metode de ncrcare
prin care se aduc pagini n avans. Astfel, odat cu o pagin se aduc i cteva pagini vecine, n
ipoteza c ele vor fi invocate n viitorul apropiat. O eviden statistic a utilizrii paginilor,
poate furniza, cu o anumit probabilitate care vor fi paginile cerute n viitor.
Principiul vecintii afirm c adresele de memorie solicitate de un program nu se
distribuie uniform pe ntreaga memorie folosit, ci se grupeaz n jurul unor centre. Apelurile
din jurul acestor centre sunt mult mai frecvente dect apelurile de la un centru la altul. Acest
principiu sugereaz o politic simpl de ncrcare n avans a unor pagini. Se stabilete o aa
zis memorie de lucru compus din cteva pagini. Atunci cnd se cere aducerea unei pagini
virtuale n memoria executabil, sunt ncrcate cteva pagini vecine acesteia. n conformitate
cu principiul vecintii, este foarte probabil ca urmtoarele referiri s fie fcute n cadrul
memoriei interne.
Algoritmi de nlocuire. Dac considerm =r
1
, r
2
,..., r
i
,...
un ir de referire a paginilor i {S
t
(m)} secvena de stri ale memoriei interne atunci
S
t
(m)= S
t - 1
(m) X
t
Y
t
(3.1)
Relaie n care X
t
i Y
t
au semnificaia urmtoare:
dac la momentul t procesul cere o pagin r
t
care nu se gsete n memoria fizic i y
t

este pagina care va fi nlocuit atunci X
t
= {r
t
} , Y
t
= {y
t
};
dac la momentul t procesul cere o pagin r
t
care se gsete n memoria fizic atunci
X
t
= , Y
t
= .
Problema care se pune, este cum s fie selectat pagina y
t
care va fi nlocuit n memoria
fizic.
nlocuirea aleatoare nseamn c y
t
este aleas cu o probabilitate 1/m dintre oricare
paginile fizice alocate procesului. n practic, s-a dovedit c aceast metod nu este eficient.
Algoritmul optimal al lui Belady. Dac la un moment t, pentru ncrcarea unei pagini r
t
,
pagina fizic y
t
care urmeaz s fie nlocuit, va fi determinat astfel: dintre paginile r
t+1
,
r
t+2
,..., care fac parte din irul de referine, se va alege acea pagin r
k
pentru care diferena k-
t+1, kt+1, considernd primele apariii ale paginilor, este maxim, sau t=max{k/r
k
S
t-1
(m)}
sau cu alte cuvinte se nlocuiete pagina care nu va fi folosit pentru cea mai lung perioad
de timp. Aceast metod nu poate fi aplicat direct, deoarece presupune c se cunoate apriori
care pagini vor fi solicitate de ctre procesul respectiv (imposibil, deoarece evoluia concret
a unui program este determinat de datele concrete asupra cruia opereaz), dar ea poate fi o
surs de inspiraie pentru alte metode.
Exemplu: Presupunem c numrul de pagini fizice alocate unui proces este 3. n figura 11.1
este prezentat un ir de referine de pagini, precum i paginile fizice n care ele se ncarc,
folosind algoritmul lui Belady.
Pagina 20

7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1

7 7 7 2 2 2 2 2 2 2 2 2 2 2 2 0 0 0 0 0
0 0 0 0 0 0 4 4 4 0 0 0 1 1 1 1 1 1 1 pagini fizice
1 1 1 3 3 3 3 3 3 3 3 3 3 3 3 7 7 7

Figura 11.1. ncrcarea paginilor virtuale n pagini fizice, pe baza algoritmului optimal

Primele 3 pagini din irul de referin sunt ncrcate fr probleme n memoria fizic.
Cnd se ajunge la a patra pagin virtual din ir (pagina 2), va fi nlocuit pagina 7, deoarece,
n viitor, ea va fi ultima la care se va face o referin, dintre paginile care sunt ncrcate n
memoria fizic. A cincea pagin virtual din ir este deja ncrcat n memoria intern, deci
nu va mai fi necesar nlocuirea unei pagini .a.m.d.
nlocuirea n ordinea ncrcrii paginilor(FIFO). Se creaz i se ntreine o list a
paginilor n ordinea ncrcrii lor. Aceast list se actualizeaz la fiecare nou ncrcare de
pagin. Atunci cnd se cere nlocuirea, este substituit prima (cea mai veche) pagin din list.
Bitul M, numit bit de modificare, primete valoarea 0 la ncrcarea paginii respective. El este
modificat numai la scriere n pagin, cnd i se d valoarea 1. Bitul M indic dac pagina
trebuie sau nu salvat naintea nlocuirii.
Exemplu: n condiiile aceluiai ir de referine i aceluiai numr de pagini fizice alocate
unui proces, ca n exemplul anterior, n figura 11.2 este prezentat un ir de referine de pagini,
precum i paginile fizice n care ele se ncarc, folosind algoritmul FIFO.

7 0 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1

7 7 2 2 2 2 2 2 2 0 0 0 0 0 0 0 7 7 7
0 0 0 3 3 3 3 3 3 3 2 2 2 2 2 2 0 0 pagini fizice
1 1 1 0 4 4 4 4 4 4 1 1 1 1 1 1 1

Figura 11.2. ncrcarea paginilor virtuale n pagini fizice, pe baza algoritmului FIFO
Prima ncrcare de pagin virtual, cu nlocuirea unei pagini fizice, are loc atunci cnd se
ncarc prima dat pagina 2, pagina nlocuit fiind 7, deoarece este prima dintre paginile din
list care a fost adus n memorie. La urmtoarea nlocuire de pagin, cnd este adus n
memorie pagina virtual 3, este nlocuit pagina 0, deoarece ea este de cel mai mult timp n
memorie .a.m.d.
nlocuirea paginii nesolicitate cel mai mult timp (LRU Least Recently Used) are la
baz urmtoarea observaie: o pagin care a fost solicitat mult de ctre ultimele instruciuni,
va fi solicitat mult i n continuare, i invers. Problema este cum s se in evidena
utilizatorilor.
Numrtorul de accese se implementeaz hard. Exist un registru, numit contor
reprezentat de regul pe 64 de bii. La fiecare acces, valoarea lui este mrit cu o unitate. n
tabela de pagini, exist o locaie pentru a memora valoarea contorului. n momentul accesului
la o pagin, valoarea contorului este memorat n acest spaiu rezervat din tabela de pagini.
Pagina 21
Atunci cnd se impune o nlocuire, este nlocuit pagina care a reinut pagina cea mai mic
valoare a contorului.
Exemplu: n condiiile aceluiai ir de referine i aceluiai numrul de pagini fizice alocate
unui proces, ca n exemplele anterioare, n figura 11.3 este prezentat un ir de referine de
pagini, precum i paginile fizice n care ele se ncarc, folosind algoritmul LRU.
Cnd este adus pentru prima dat n memoria fizic pagina virtual 2, este nlocuit
pagina 7, deoarece ea nu a mai fost utilizat de cel mai mult timp; din acelai motiv, cnd este
refereniat pentru prima dat pagina 3, ea nlocuiete pagina 1 .a.m.d.

7 0 1 2 0 3 0 4 2 3 0 3 2 1 2 0 1 7 0 1

7 7 7 2 2 2 2 4 4 4 0 0 0 1 1 1 1 1 1 1
0 0 0 0 0 0 0 0 3 3 3 3 3 3 0 0 0 0 0 pagini fizice
1 1 1 3 3 3 2 2 2 2 2 2 2 2 2 7 7 7

Figura 11.3. ncrcarea paginilor virtuale n pagini fizice, pe baza algoritmului FIFO
Metoda NRU( Not Recently Used). Fiecare pagin fizic are asociai doi bii, prin
intermediul crora se va decide pagina de nlocuit. Bitul R, numit bit de referire, primete
valoarea 0 la ncrcarea paginii. La fiecare referire a paginii, acest bit este pus pe 1. Periodic
(constant de sistem), bitul este pus iari pe 0. La fiecare valoare a timpului virtual, biii M i
R mpart paginile fizice n patru clase:
clasa 0: pagini nereferite i nemodificate;
clasa 1: pagini nereferite (n intervalul fixat), dar modificate de la ncrcarea lor;
clasa 2: pagini referite dar nemodificate;
clasa 3: pagini referite i modificate.
Atunci cnd o pagin trebuie nlocuit, pagina respectiv se caut mai nti n clasa 0, apoi n
clasa 1, apoi n clasa 2 i n sfrit n clasa 3. Dac pagina de nlocuit este n clasa 1 sau n
clasa 3, coninutul ei va fi salvat pe disc naintea nlocuirii.
Observaie. O prim mbuntire ar fi combinarea algoritmilor NRU i FIFO, n sensul c se
aplic mai nti NRU, iar n cadrul aceleiai clase se aplic FIFO.
O alt mbuntire este cunoscut sub numele de metoda celei de-a doua anse. La
aceast metod, se testeaz bitul R de referin la pagina cea mai veche. Dac acesta este 0,
atunci pagina este nlocuit imediat. Dac este 1, atunci este pus pe 0 i pagina este pus
ultima n list, ca i cum ar fi intrat recent n memorie. Apoi cutarea se reia cu o nou list.
Alocarea cadrelor. n cazul sistemelor care utilizeaz multiprogramarea, fiecrui proces
trebuie s i se asigure un numr de pagini fizice, care nu pot fi utilizate de celelalte procese.
Prin alocare egal se aloc tuturor proceselor acelai numr de pagini fizice. Prin alocarea
proporional se aloc proceselor un numr de pagini fizice direct proporional cu
dimensiunea spaiului de memorie virtual utilizat de procesul respectiv. O alt metod de
alocare ine cont de prioritatea proceselor, n sensul c numrul paginilor fizice alocate unui
proces, s fie direct proporional cu prioritatea procesului. Cele dou criterii de alocare
proporional se pot combina.
Pagina 22
Performanele sistemului de paginare. Atunci cnd un proces refereniaz o pagin
virtual care nu este prezent n memoria fizic, sistemul execut o serie ntreag de operaii,
care au fost amintite n seciunea 3. este evident c timpul de execuie al procesului ntr-un
sistem cu paginare, va fi mai mare dect timpul su de execuie, n cazul n care va avea la
dispoziie un spaiu de memorie suficient, astfel nct s nu se confrunte cu situaia de pagin
lips (pagin refereniat care nu este ncrcat n memoria fizic, i care trebuie adus n
locul unei pagini ncrcate n memoria fizic). Dac apare frecvent situaia c, la un anumit
moment al execuiei, o anumit pagin este evacuat pe disc, dup care, la un interval mic de
timp ea este din nou refereniat, eficiena utilizrii CPU va scade.
Algoritmi dinamici de paginare. Problema care se pune, este gsirea unei strategii prin
care se aduc n memoria fizic acele pagini de care procesul va avea nevoie ntr-un viitor
apropiat. Determinarea numrului de pagini fizice de care va avea nevoie un proces pentru
execuia lui, nu va mai fi o constant; ea va fi modificat n funcie de anumii factori.
Metoda setului de lucru(SL) are la baz modelul localitii. Localitatea este un set de
pagini care sunt utilizate mpreun ntr-un mod activ. Un program este format din mai multe
localiti, iar execuia programului const dintr-o trecere dintr-o localitate n alta. Un exemplu
de localitate este partea de instruciuni cod main care corespund unui subprogam; aceste
instruciunui se afl n pagini vecine, care dup execuia lor(terminarea execuiei subrutinei)
pot fi evacuate din memorie i posibilitatea referirii lor ntr-un viitor apropiat este
improbabil. Cnd un proces trece dintr-o localitate n alta, se modific att paginile cerute de
ctre proces, ct i numrul de pagini fizice necesar procesului. Deci, se pune n mod firesc
problema, de a considera numrul de pagini alocat procesului ca fiind o entitate dinamic, ce
se modific n timpul execuiei procesului.
Algoritmului setului de lucru folosete necesitile curente de memorie fizic ale
procesului, pentru a determina numrul paginilor fizice alocate acestuia, n anumite momente
ale execuiei sale, fiind, deci o metod dinamic de alocare a memoriei interne.
Presupunem c exist n procese care partajeaz memoria fizic a sistemului. Fie m
i
(t)
cantitatea de memorie alocat procesului i la momentul virtual t. Avem m
i
(0)=0 i
=
=
1 n
0 i
i
k (t) m , k fiind dimensiunea memoriei interne. Dac nlocuim n relaia (3.1) pe m cu
m
i
(t) obinem S
t
(m
i
(t))= S
t - 1
(m
i
(t)) X
t
Y
t
, S
0
(m
0
(t))=0. S
t
(m
i
(t)) reprezint starea memoriei
la momentul t pentru procesul p
i
(S
t
(m
i
(0))=). Dac la momentul t procesul cere pagina r
t
i
aceasta este deja ncrcat n memoria fizic, atunci

X
t
=Y
t
=; dac pagina r
t
nu este
ncrcar n memorie, atunci Y
t
= {y
t
} , sau pagina y
t
va fi evacuat din memorie, dac
numrul de referine de la referirea paginii y
t
, pn la cererea paginii curente r
t
este mai mare
sau egal cu o valoare constant, notat cu , ce reprezint dimensiunea unei ferestere logice.
m
i
(t) va reprezenta numrul de pagini fizice alocat procesului p
i
i va fi ajustat astfel:
X
t
i Y
t
= , atunci 1 ) ( ) ( + = 1 - t m t m
i i
(se aloc o pagin fizic);
X
t
= i Y
t
= , atunci ) ( ) ( 1 - t m t m
i i
= ;
X
t
= i Y
t
atunci 1 ) ( ) ( = 1 - t m t m
i i
(una dintre paginile fizice este luat
procesului). S(m
i
(t)) rezultat este numit set de lucru al procesului p
i
la momentul t, relativ la
Pagina 23
dimensiunea ferestrei . Exemplu: Considernd =6, relativ la irul de referine prezentat n
figura 11.4, i la valorile timpului virtual al procesului t
1
i t
2
, SL(t
1
)={1, 2, 3, 4, 5},
SL(t
2
)={6, 7, 8 , 9}

1 2 3 5 4 3 1 6 7 8 7 6 9 7 8 3 6 4 5 2

t
1
t
2

Figura 11.4. Valoarea setului de lucru n funcie de fereastr
La momentul t1, ultimele 6 referiri sunt pagini care formeaz mulimea SL(t
1
), iar la
momentul t
2
, ultimele 6 referiri de pagini formeaz mulimea SL(t
2
).
Observaie.
1. Cele dou seturi de lucru prezentate n ultimul exemplu sunt disjuncte, adic ele corespund
unorlocaliti diferite.
2. Sistemul de operare aloc fiecrui proces un numr de pagini fizice corespunztor
dimensiunii setului de lucru asociat; dac suma dimensiunilor seturilor de lucru
corespunztoare proceselor, este mai mic dect dimensiunea memoriei interne atunci
sistemul mai poate executa nc un proces. Reciproc, dac suma dimensiunilor seturilor de
lucru ale proceselor depete dimensiunea memoriei interne, atunci unul dintre procese va fi
suspendat.
3. Nu exist o metod riguroas prin care s se determine valoarea parametrului . O valoare
prea mic va genera pagini lips, pe cnd o valoare prea mare va genera suprapunerea
localitilor. n prtactic se alege o valoare de 10000 de referiri.

11.2. Memoria cu acces rapid(cache)

Memoria cache conine copii ale unor blocuri din memoria operativ. Cnd CPU ncearc
citirea unui cuvnt din memorie, se verific dac acesta exist n memoria cache. Dac exist,
atunci el este livrat CPU. Dac nu, atunci el este cutat n memoria operativ, este adus n
memoria cache mpreun cu blocul din care face parte, dup care este livrat CPU. Datorit
vitezei mult mai mari de acces la memoria cache, randamentul general al sistemului crete.
Memoria cache este mprit n mai multe pri egale, numite sloturi. Un slot are
dimensiunea unui bloc de memorie, a crui dimensiune este o putere a lui 2. Fiecare slot
conine o zon care conine blocul de memorie operativ depus n slotul respectiv. Problema
care se pune, este modul n care se face corespondena dintre blocurile din memoria operativ
i sloturile din memoria cache, precum i politicile de nlocuire a sloturilor din memoria
cache, cu blocuri din memoria fizic. Spunem c are loc o proiecie a spaiului memoriei
operative n cel al memoriei cache.
Pagina 24
Proiecia direct. Dac c indic numrul total de sloturi din memoria cache, a este o
adres oarecare din memoria operativ, atunci numrul s al slotului n care se proiecteaz
adresa a este s= a mod c. Dezavantajul metodei const n faptul c fiecare bloc are o poziie
fix n memoria cache. Dac, de exemplu se cer accese alternative la dou blocuri care ocup
acelai slot, atunci trebuie efectuate mai multe operaii de nlocuire a coninutului slotului care
corespunde celor dou blocuri.
Proiecia asociativ. Fiecare bloc de memorie este plasat n oricare dintre sloturile de
memorie cache, care sunt libere. nlocuirea coninutului unui slot, cu coninutul altui bloc din
memoria operativ, se face pe baza unuia dintre algoritmii NRU, FIFO sau LRU.
Proiecia set-asociativ combin cele dou metode prezentate anterior. Memoria cache
este mprit n i seturi, un set fiind compus din j sloturi. Avem relaia c=i x j. Dac a este o
adres de memorie, numrul k al setului n care va intra blocul, este dat de:
K=a mod i.
Cunoscnd numrul setului, blocul va ocupa unul dintre sloturile acestui set, pe baza unuia
dintre algoritmii de nlocuire prezentai anterior.

Pagina 25
Curs 12-13
Managementu| s|stemu|u| de f|s|ere

Logic:
Bob: Ma gandesc la un numar intreg intre 10 si 1300.
Alice: Este mai mic decat 500 ?
Bob ii raspunde, dar minte.
Alice: Este un patrat perfect ?
Bob ii raspunde, dar minte.
Alice: Este un cub perfect ?
Bob ii raspunde corect.
Alice: Daca as sti daca a doua cifra din stanga este sau nu 1, as putea ghici numarul ... Este 1
?
Bob ii raspunde corect si Alice ii spune numarul la care crede ca s-a gandit Bob.
Dar a gresit !
La ce numar s-a gandit Bob ?

Logic:
Cinci logicieni sunt angrenai n urmtoarea aciune:
- Sunt 12 butoane numerotate 1,2,..,12, ataate unei cutii negre, n care se afl 12 bile (marcate
cu A,B,..,L);
- Fiecare buton este n coresponden cu o bil i numai cu una;
- La o rund, fiecare logician apas pe un buton. Dup a cincea apsare, din cutie cad cinci
bile (bilele corespunztoare butoanelor acionate);
- Bilele sunt vzute de toat lumea, apoi sunt puse napoi n cutie i logicienii sunt ntrebai
ce bil corespunde fiecruia din cele 12 butoane;
- Dac ei nu pot decide, se ncepe o nou rund;
- Dup 4 runde, logicienii prezint lista corespondenelor dintre cele 12 bile i butoanele
1,2,..,12.
Gsii strategia de apsare a butoanelor folosit de logicieni, care a condus la aflarea acestei
corespondene.

Mananagementul fiierelor este considerat o parte a sistemului de operare. In
majoritatea aplicatiilor, fiierul este elementul central. Cu excepia aplicaiilor de timp real i
a altor aplicaii specializate, intrarea acestora este un fiier iar ieirea este salvat tot ntr-un
fiier pentru o utilizare ulterioar.
Termenii utilizai n mod curent n discuiile referitoare la fiiere sunt:
cmp dat elementar, conine o singur valoare fiind caracterizat prin lungime i
tip;
nregistrare este o colecie de cmpuri nrudite ce pot fi tratate ca i un ntreg;
Pagina 26
fiier o colecie de nregistrri similare, este tratat ca o singur entitate de utilizatori
i aplicatii i este referit prin nume.
Este necesar ca aplicaiile i utilizatorii s poat s fac uz de fiiere. Operaiile tipice ce
trebuie s poat fi efectuate asupra acestora sunt:
obine toate inregistrrile unui fisier;
determin obinerea unei singure nregistrari din fiier;
determin obinerea inregistrrii care este urmtoarea sau anterioar ntr-o
secven logic oarecare dup cea mai recent nregistrare obinut;
inserarea unei noi nregistrari ntr-un fiier, poate fi necesar ca nregistrarea s fie
facut pe o poziie particular;
tergerea unei nregistrri existente;
obinerea unei nregistrri, actualizarea acesteia i rescrierea ei napoi n fiier;
obine un numr de nregistrri;
Un sistem de gestionare a fiierelor este un set de rutine ce ofer servicii utilizatorilor
i aplicaiilor. Uzual, singurul mod n care un utilizator sau o aplicaie poate obine accesul la
un fiier este prin intermediul sistemului de gestionare a fisierelor, ceea ce l degreveaza pe
programator de sarcina de a dezvolta pentru fiecare aplicaie n parte rutine specializate de
acces la fiiere.
Un sistem de gestionare a fisierelor trebuie s urmreasca anumite obiective:
s respecte constrngerile de gestionare a datelor i cerinele utilizatorilor;
s garanteze validitatea datelor din fisiere;
s optimizeze performana din ambele puncte de vedere: sistem i utilizator;
s ofere suport de I/E pentru o gam ct mai larg de dispozitive de stocare;
s minimizeze sau s elimine potenialele pierderi sau distrugeri de date;
s ofere o interfa standardizat pentru rutinele de I/E;
s ofere suport de I/E pentru mai muli utilzatori.
Realizarea obiectivelor anterior propuse depinde de diferitele aplicaii ce trebuie rulate
i de mediul n care va rula sistemul de calcul. Un sistem interactiv de uz general trebuie s
respecte un set minimal de constrngeri:
fiecare utilizator trebuie s fie capabil s creeze, s tearg i s modifice fiiere;
fiecare utilizator trebuie s poat avea acces controlat la fiierele altui utilizator;
fiecare utilizator trebuie s poat controla tipurile de accese permise la fiierele sale;
fiecare utilizator trebuie s fie capabil s i restructureze fiierele conform nevoilor
sale;
fiecare utilizator trebuie s poat s i mute datele ntre fiiere;
fiecare utilizator trebuie s poat s i protejeze i recupereze datele n caz de
distrugere.
fiecare utilizator trebuie s i poat accesa fiierele printr-un nume simbolic.
Organizarea tipic a unui astfel de sistem este urmtoarea:
Pagina 27

Figura 12-13.1 Arhitectura sistemului de fiiere

Pe cel mai de jos nivel ntr-un sistem de gestionare a fiierelor se afl driverele de
dispozitiv. Acestea comunic direct cu perifericele i sunt responsabile cu pornirea operaiilor
de I/E i de ncheierea acestora. Deseori, driverele de dispozitiv sunt considerate ca facnd
parte din sistemul de operare.
Prima interfa ntre mediul nconjurtor i sistemul de calcul este reprezentat de
sistemul de fiiere elementar sau nivelul de I/E fizic. Acest nivel este responsabil pentru
schimburile de date ce au loc cu discurile sau alte medii de stocare, n consecin tot n sarcina
acestui nivel cade i plasarea blocurilor de date pe al doilea mediu de stocare i totodat
aducerea blocurilor de date n memorie n vederea utilizrii lor ulterioare. Nivelul fizic de I/E
este deseori considerat ca facnd parte i el din sistemul de operare.
Nivelul de I/E elementar supervizor este responsabil pentru iniierea i terminarea
tuturor operaiilor de I/E pentru fiiere. La acest nivel structurile de control au rolul de a
gestiona dispozitive de I/E, programarea operaiilor i starea fiierelor. Acest nivel mai este
responsabil i cu selecia dispozitivului cu care va fi realizat o operaie de I/E. Si acest nivel
este considerat ca facnd parte din sistemul de operare.
Nivelul logic de I/E permite utilizatorilor i aplicaiilor s acceseze nregistrri. Dup
cum s-a vzut, la nivelul de jos se afl sistemul de fiiere elementar care gestioneaz blocuri
de date, iar nivelul logic al operaiilor de I/E gestioneaz nregistrrile fiierelor. Acest nivel
ofer nregistrrilor de scop general capabiliti de I/E i gestioneaz informaiile elementare
despre fiiere.
Nivelul sistemului de fisiere cel mai apropiat de utilizator n mod curent este numit
metod de acces. Aceasta ofer o interfa standard ntre aplicaii i sistemul de fiiere precum
i dispozitivele ce conin datele. Metodele de acces diferite reflect structuri de fiiere diferite
i moduri diferite de accesare i procesare a datelor.
Pagina 28
Sistemul de gestionare a fiierelor este resposabil cu ndeplinirea unei serii de funcii
ce vor fi discutate n continuare. Utilizatorii i aplicaiile interacioneaz cu sistemul de fiiere
prin intermediul comenzilor pentru creerea i tergerea fiierelor i pentru realizarea de
operaii asupra acestora. Inainte de realizarea oricrei operaii, sistemul de fiiere trebuie s
identifice i s localizeze fiierele selectate. Pentru aceasta este nevoie de utilizarea unui
catalog (director) care s serveasc la descrierea locaiilor tuturor fiierelor i a atributelor
acestora. In plus, n cazul sistemelor cu mai muli utilizatori este necesar s fie mbuntit
controlul acceselor utilizatorilor la fiiere. Acolo unde utilizatorii i aplicaiile lucreaz cu
nregistrari, nivelul de I/E lucreaz pe baz de blocuri. Astfel, nregistrrile unui fiier trebuie
blocate pentru ieire i deblocate pentru intrare. Pentru a putea efectua aceast blocare
de I/E sunt necesare mai multe funcii. Pentru aceasta este necesar ca mediul de stocare s fie
gestionat implicnd alocarea de blocuri libere fiierelor i gestionarea spaiului liber pentru a
cunoate blocurile disponibile a fi alocate noilor fiiere sau pentru mrirea celor existente. In
plus cererile de I/E pentru blocuri individule trebuie programate.
In continuare vom folosi termenul de organizarea fiierelor care se refer la structura
logic a nregistrrilor i este determinat de organizarea acestora. In alegerea modului de
organizare a fiierelor se urmresc cteva criterii:
acces rapid;
actualizare rapid;
economie de spaiu;
ntreinere simpl;
siguran.
Prioritatea acestor criterii este relativ i depinde de aplicaiile la care vor fi utilizate
fiierele. Numrul de alternative de organizare a fiierelor care au fost implementate sau doar
propuse este extrem de mare. Dintre acestea se vor aminti doar cinci mai reprezentative:
aglomerare;
fiiere secveniale;
fiiere secveniale indexate;
fiiere indexate;
fiiere cu accesare direct.
Cea mai simpl form de organizare a fiierelor este aa-numita aglomerare. Datele
sunt stocate n ordinea n care sosesc. Scopul acestei forme de organizare este s acumuleze
mase mari de date i s le stocheze. Inregistrrile pot avea cmpuri diferite sau similare, n
ordine diferite. Astfel, fiecare cmp trebuie s se autodescrie incluznd numele lui i valoarea.
Lungimea lui trebuie indicat n mod implicit de ctre delimitatori, inclus n mod explicit ca
i subcmp sau cumoscut implicit pentru fiecare cmp de date. Sistemul de fiiere nu este
structurat, accesarea unei nregistrari se face prin cutare exhaustiv. Acest tip de structurare
se poate folosi n situaia n care datele sunt colectate i stocate n mod aleator sau cnd datele
nu sunt uor de organizat. In aceast situaie spaiul este bine
utilizat cnd datele nregistrate variaz n dimensiune
i structur i este ideal pentru cutri exhaustive.

Pagina 29

Figura 12-13.2 Organizarea de tip aglomerare a fiierelor

Cea mai ntlnit form de organizare a fiierelor este cea secvenial. In cazul acestor
tipuri de fiiere se utilizeaz pentru nregistrri un format fix. Toate nregistrrile au aceeai
lungime constnd din acelai numr de cmpuri de lungime fix ntr-o anumit ordine. Din
cauz c lungimea i poziia cmpului sunt cunoscute, numai valorile nregistrarilor trebuie
inregistrate. Numele cmpului i lungimea sunt atributele structurii de fiiere. Un cmp
particular, de obicei primul cmp al inregistrrii, este referit ca i cmpul cheie. Cmpul cheie
identific n mod unic nregistrarea astfel nct valori cheie pentru nregistrari diferite sunt tot
timpul diferite. In continuare nregistrarile sunt stocate ntr-o anumita ordine: alfabetic
pentru cheile text i numeric pentru cele numerice. Fiierele secveniale sunt deobicei
utilizate de mai multe aplicaii i sunt n general otpimizate pentru astfel de aplicaii dac
acestea trebuie s proceseze toate nregistrrile. Pentru aplicaiile care implic cutarea numai
a unor anumite nregistrri, performana las mult de dorit. Tipic, un fiier secvenial este
stocat ntr-o ordonare secvenial simpl a nregistrrilor pe blocuri, astfel nct organizarea
fizic pe disc este identic cu organizarea logica a fiierului. In acest caz procedura standard
este de a plasa noile nregistrri ntr-un nou fisier numit fiier de tranzacii. Periodic se
realizeaz o actualizare a fiierului original de pe disc cu fiierul de tranzacie pentru a
produce un nou fiier cu secvena corect de chei.

Figura 12-13.3. Organizarea secvenial a fiierelor

O abordare care s nlture dezavantajele abordrii secveniale este cea a fiierelor
secveniale indexate. In acest caz se menine caracteristica cheie a fiierelor organizate
secvenial: nregistrrile sunt organizate ntr-o secven bazat pe cmpuri cheie. Au fost
adugate dou caracteristici noi: un index la fiiere pentru a se putea face cutari cu acces
Pagina 30
aleator, i un fisier de depire. In cea mai simpl structur secvenial indexat se utilizeaz
un singur nivel de indexare. Fiecare nregistrare n fisierul indexat const din dou cmpuri:
un cmp cheie care este identic cu cmpul cheie din fiierul principal;
o referin n fiierul principal.
Pentru a gsi un anumit cmp se caut n index pentru a gsi cea mai mare cheie a
crei valoare este egal sau precede cheia cu valoarea dorit. Cutarea este continuat n
fiierul principal la locaia indicat de referin.
Pentru a putea observa diferenele dintre cele dou abordri se prezint n continuare
un scurt exemplu. Se consider un fiier secvenial cu un milion de nregistrri. O cutare
pentru o anumit cheie necesit n medie o jumtate de milion de nregistrri accesate. S
presupunem c este construit un index care conine 1000 de intrri. In aceast situaie este
nevoie n medie de 500 de accese la fiierul de index urmate de alte 500 de accese n fiierul
principal. Astfel, cutarea medie a fost redus de la 500.000 la 1000 de cutari
O alt problem ce trebuie menionat n cazul sistemului de fiiere secvenial
indexate este adugarea de noi nregistrri. Aceast operaie se realizeaz n urmtoarea
manier: fiecare nregistrare din fiierul principal conine un cmp suplimentar care nu este
vizibil aplicaiilor. Cnd o nou nregistrare este adaugat unui fiier, ea este adaugat
fiierului de depire. Inregistrarea din fiierul principal care este imediat precedent noii
nregistrri este modificat s conin o referin ctre noua nregistrare din fiierul de
depire. La fel ca si in cazul fiierelor secveniale, fiierele secveniale indexate sunt
ocazional actualizate cu fiierul de depire pentru a obine fiierul actualizat.

Figura 12-13.4. Organizarea secvenial-indexat a fiierelor

Pentru a crete eficiena acceselor se pot utiliza mai multe nivele de indexare. Astfel,
cel mai de jos nivel de indexare este tratat ca i un fiier secvenial, iar nivelul superior ca i
un index pentru acest fiier.
Fiierele indexate secveniale pstreaz o limitare a fiierelor secveniale: procesarea
efectiv este limitat pentru c se bazeaz doar pe un singur cmp al fiierului. Cnd este
necesar cutarea unei nregistrri pe baza altor atribute dect campul cheie, atunci amndou
formele sunt neadecvate. Pentru a obine flexibilitate este necesar utilizarea unor indexri
multiple, adic pentru fiecare tip de cmp care poate face obiectul unei cutri. In general la
fiierele indexate conceptul de secvenialitate este abandonat, iar nregistrrile sunt accesate
Pagina 31
pe baza indexrilor. Rezultatul este c nu mai exist restricii la plasarea nregistrrilor atta
vreme ct nregistrarea respectiv are o referin la ea, deci nregistrarile pot avea o lungime
variabil. Se utilizeaz dou tipuri de indexari:
o indexare exhaustiv ce conine cte o intrare pentru fiecare nregistrare din fiierul
principal;
o indexare parial care conine intrri numai pentru nregistrrile pentru care cmpul
de interes exist.
In figura 12-13.5 sunt prezentate cele 2 situaii.
Fiierele cu accesare direct utilizeaz capacitatea de accesare direct a oricrui bloc
cu adresa cunoscut de pe disc. In cazurile anterioare era nevoie de o cheie pentru fiecare
inregistrare n parte. Fiierele cu acces direct fac uz de asa-numitul hashing a valorilor
cheie. Fiierele cu acces direct sunt utilizate atunci cnd este nevoie de o accesare rapid a
nregistrrilor.

Figura 12-13.5 Organizarea indexat a fisierelor

Directoarele sunt asociate cu orice sistem de management a fiierelor i cu coleciile
de fiiere. Directoarele conin informaii despre fiiere incluznd atributele, locaia i
proprietarul. Directorul este el nsui un fiier al crui proprietar este sistemul de operare i
este accesibil diverselor rutine ale sistemului de gestionare a fiierelor. Dei unele informaii
din directoare sunt disponibile utilizatorilor, aceasta se realizeaz indirect prin intermediul
rutinelor sistem, astfel nct utilizatorii nu pot accesa direct directoarele nici numai pentru
citire. Din punctul de vedere al utilizatorului, directorul realizeaz o mapare ntre numele
fiierelor, cunoscute utilizatorilor i aplicaiilor, i fiierele propriu-zise. Astfel, fiecare intrare
fiier din director conine i numele fiierului. O categorie important de informaii referitoare
la un fiier este spaiul ocupat cu caracteristicile sale: locaie i dimensiune. In sistemele
multiutilizator se pot preciza informaii suplimentare referitoare la controlul accesului la
fiier. Uzual un utilizator este proprietarul fiierului i poate da altor utilizatori anumite
privilegii.
Pagina 32
Unele informaii pot fi stocate n prima inregistrare asociat cu fiierul: aceasta reduce
spaiul necesar pentru director, restul elementelor trebuie s fie n director: numele, adresa,
dimensiunea i organizarea. Cea mai simpl form a unui director este o list de intrri, cte
una pentru fiecare fiier. Aceast structura poate fi reprezentat printr-un director secvenial
cu numele fiierului servind ca i cheie. Aceast tehnic a fost utilizat n primele sisteme de
gestiune a fiierelor. Pentru a nelege cerinele pentru structura unui director este bine s fie
prezentate tipurile de operaii care trebuie s poat fi executate asupra sa:
cutare: cnd un utilizator sau o aplicaie refer un fiier, intrarea fiierului din
directorul respectiv trebuie cautat.
creare de fiier: cnd un nou fiier este creat trebuie adugat o nou intrare
directorului.
tergere de fiier: cnd un fiier este ters trebuie nlturat intrarea respectiv din
director.
listarea directorului.
Aceast structur de organizare a directorului nu ofer suport utilizatorului n organizarea
fiierelor i l foreaz s nu foloseasc acelai nume pentru dou fiiere diferite.
Un prim pas n rezolvarea problemelor prezentate anterior ar fi utilizarea unei scheme
pe dou nivele. In acest caz exist un director pentru fiecare utilizator i un director principal
care le cuprinde pe toate. Directorul principal are cte o intrare pentru fiecare director
utilizator oferind de asemenea i adresa i informaiile de acces pentru respectivele directoare.
Fiecare director utilizator este o simpl list cu fiierele utilizatorului respectiv. Datorit
acestui aranjament, numele de fiier trebuie s fie unice pentru un utilizator, deci n
continuare nu se ofer suport pentru structurarea coleciilor mari de fiiere.
O soluie mult mai flexibil i general adoptat este structura ierarhic sau structura
arborescent. La fel ca i la modelul anterior prezentat avem un director principal numit i
director rdcina care conine un numr de directoare utilizator. Fiecare director utilizator
poate conine mai multe subdirectoare i fiiere ca i intrri. O reprezentare schematic a
acestui model este urmtoarea:

Pagina 33

Figura 12-13.6 Structura arborescent a directoarelor

Utilizatorii trebuie s poat referi fiierele prin intermediul unor nume simbolice. Deci
fiecare fiier din sistem trebuie s aib un nume unic pentru a nu aprea ambiguiti la
referirea fiierelor. Datorit structurii arborescente orice fiier din sistem poate fi localizat
utiliznd o cale de la rdcin sau directorul principal, mergnd pe diferitele ramuri pn cnd
se atinge fiierul dorit. Seriile de nume de directoare acumulate pe parcurs culminnd cu
numele directorului propriu-zis poart numele de nume de cale (pathname). Din cauz c
numele de cale sunt lungi lucrul cu ele este destul de dificil. De obicei un utilizator sau un
proces este asociat cu directorul curent care poart numele de director de lucru. Fiierele pot fi
referite relativ la directorul curent sau de lucru. Cnd un utilizator intr n sistem directorul de
lucru este directorul asupra cruia are drepturi de proprietate.

Figura 12-13.7 Exemplu de structur arborescent

In sistemele cu mai muli utilizatori exist necesitatea ca anumite fiiere s poat fi fcute
disponibile mai multor utilizatori. In aceasta situaie se pot ridica dou probleme:
Pagina 34
drepturile de acces;
gestionarea acceselor simultane;
Sistemul de fiiere are sarcina s ofere unelte flexibile care s permit distribuirea
fiierelor ntre utilizatori, de asemenea sistemul de fiiere trebuie s ofere utilizatorilor un
numr de opiuni prin care s controleze accesul altor utilizatori la fiiere. Uzual utilizatorii
sau grupurile de utilizatori primesc anumite drepturi de acces la fiier dintre care precizm:
fr nici un drept utilizatorii nu pot nici mcar afla de existena fiierului, cu att mai
puin s l acceseze. Pentru a nspri restricia utilizatorilor nu le este permis accesul n
directorul care conine fisierul;
utilizatorul poate vedea ca fiierul exist i poate determina cine este proprietarul;
execuie utilizatorul poate ncrca i executa un program dar nu l poate copia;
citire utilizatorul poate citi fiierul n orice scop, incluznd copierea i execuia;
adugare utilizatorul poate citi fiierul, poate aduga date, deseori numai la sfrit,
dar nu poate modifica sau terge date din fiier.
actualizare utilizatorul poate modifica, terge i aduga date fiierului. Aceasta
implic n mod normal iniial scrierea fiierului, rescrierea lui complet sau parial i
tergerea toal sau n parte a acestuia;
modificarea proteciei utilizatorul poate schimba drepturile de acces oferite celorlali
utilizatori. Uzual acest lucru l poate face doar proprietarul fiierului;
tergere utilizatorul poate terge fiierul din sistemul de fisiere;
Se poate considera c aceste drepturi constituie o ierarhie, fiecare dintre aceste
drepturi implicndu-le pe toate cele care l preced. Un utilizator este desemnat ca fiind
proprietarul fiierului, de obicei este utilizatorul care a creat fiierul iniial. Proprietarul are
toate drepturile prezentate anterior i poate oferi i altor utilizatori diferite drepturi de acces la
respectivul fisier. Acesul se poate realiza pe diverse clase de utilizatori:
utilizatori specifici: utilizatori individuali care sunt desemnai prin ID-ul lor;
grupuri de utilizatori: set de utilizatori care nu sunt definii individual;
tuturor: tuturor utilizatorilor care au acces la respectivul sistem. Aceste fiiere sunt
publice.
Cnd accesul este oferit pentru adugare sau actualizare, atunci sistemul de operare
sau sistemul de gestionare a fiierelor trebuie s asigure disciplina. O prim abordare a
problemei ar fi s se permit utilizatorului s blocheze accesul altor utilizatori la fiier pe
parcursul actualizrii lui. O abordare mai elegant ar fi s se blocheze doar nregistrrile din
fiier care sunt modificate. Tot n acest context apar i problemele de excludere mutual sau
de blocare n ateptare.
Pentru realizarea operaiilor de I/E este necesar ca nregistrrile s fie organizate pe
blocuri. Se pune problema modului de organizare a informaiei pe blocuri. Se pot considera
mai multe situaii:
blocuri cu nregistrri de lungime fix;
blocuri cu dimensiune variabil extinse;
blocuri cu dimensiune variabil neextinse.
Pagina 35
Blocuri de dimensiune fix sunt alctuite dintr-un numr fix de nregistrri care la
rndul lor au lungimea fix. In acest caz poate ramne spaiu neutilizat la sfritul fiecrui
fiier. Aceste blocuri sunt de obicei utilizate pentru fiierele secveniale, la fel cum este
ilustrat i n figura urmtoare:

Figura 12-13.8 Organizarea pe blocuri
In situaia blocurilor cu dimensiune variabil extinse nu vom avea spaiu nefolosit ca
i n situaia anterioar. Astfel, unele nregistrri trebuie s fie peste dou blocuri, iar al doilea
bloc va fi indicat printr-un pointer. Acest tip de organizare este extrem de eficient din punctul
de vedere al ocuprii spaiului, dar apar probleme n ceea ce privete gestionarea fiierelor. In
aceast situaie se folosesc blocuri de dimensiune variabil dar nu este permis extinderea
nregistrrilor peste mai multe blocuri, ceea ce poate conduce la apariia de spaiu neocupat la
sfritul blocurilor.
Pe mediul de stocare secundar, un fiier este constituit dintr-o colecie de blocuri.
Sistemul de operare sau sistemul de gestionare al fiierelor este resposabil cu alocarea
Pagina 36
blocurilor fiierelor. In aceast situaie, se pot ridica dou probleme de gestionare a spaiului
de stocare:
spaiul de pe mediul de stocare secundar trebuie alocat fiierelor;
este necesar s se in evidena spaiului ce poate fi utilizat pentru alocare.
Alocarea fiierelor implic mai multe probleme. O prim problem este ct spaiu s
se aloce la crearea fiierului. O politic de alocare a spaiului cere ca spaiul maxim ce va fi
ocupat de fiier s fie declarat la creerea fiierului. Dar pentru multe aplicaii este dificil, dac
nu imposibil de estimat dimensiunea maxim a fiierului. In aceste situaii, utilizatorii i
aplicaiile vor tinde s supraestimeze dimensiunea necesar pentru fiier ceea ce va conduce
n final la o risip de spaiu. De aceea ar fi avantajos s se utilizeze o alocare dinamic a
spaiului n care fiierul primete numai cnd are nevoie.
O alt problem ce trebuie luat n considerare este dimensiunea cuantei cu care se
face alocarea de spaiu. In principiu sunt dou alternative:
poriuni contigue mari i variabile: aceasta va conduce la creterea performanei.
Dimensiunea variabil elimin risipa, iar tabelele de alocare a fiierelor sunt mici .
blocuri: poriuni mici de dimensiune fix ce ofer o mai mare flexibilitate. Acestea pot
solicita tabele largi sau structuri complexe pentru alocarea lor. Contiguitatea a fost
abandonat, iar blocurile sunt alocate dup nevoie.
In primul caz, prealocarea fiierului se face n grupuri de blocuri contigue. In aceast situaie
este nevoie numai de o referin ctre primul bloc i de numrul de blocuri alocate, iar tabela
de alocare are nevoie doar de o singur intrare pentru fiecare fiier. Acest tip de alocare este
ideal pentru fiierele secveniale. Singura problem este c poate aprea o fragmentare
extern facnd dificil obinerea spaiului pentru alocarea blocurilor de dimensiuni mari. De
aceea este necesar s se efectueze periodic o operaiune de compactare pentru a elibera spaiu
suplimentar.

Pagina 37

Figura 12-13.9 Alocarea contigu a fiierelor inainte de compactare i dup

La cealalt extrem se afl alocarea nlnuit. In acest caz alocarea se face la nivel de
blocuri individuale. Fiecare bloc conine o referin ctre urmtorul bloc din lan. Si n aceast
situaie este nevoie doar de o intrare pentru fiecare fiier n tabela de alocare a fiierelor. In
acest caz nu se pune problema fragmentrii. Acest tip de organizare este ideal pentru fiierele
secveniale ce se vor procesa secvenial. Problema ce poate aprea este necestitatea de a face
accese n diferite zone ale discului. Pentru a corecta acest problema este necesar s se fac
periodic o compactare a fiierului.

Pagina 38
Figura 12-13.10 Alocarea nlnuit a fiierelor inainte de compactare i dup

In cazul alocrii indexate, tabela de alocare a fiierelor conine un nivel de indexare
separat pentru fiecare fiier: indexul are cte o intrare pentru fiecare poriune de fiier alocat.
Uzual indexrile din fiier nu sunt stocate ca i pri ale tabelei de alocare, ci sunt memorate
n blocuri separate i tabela de alocare conine o referin ctre acel bloc. Alocarea se poate
face pe baz de blocuri cu dimensiune fix sau pe poriuni de dimensiune variabil. In primul
caz se elimin fragmentarea iar n al doilea mbuntete localizarea. In ambele situaii este
nevoie s se efectueze compactarea la anumite intervale de timp.

Figura 12-13.11 Alocarea indexat a fiierelor folosind blocuri fixe sau variabile

In cazul sistemului de operare UNIX toate fiierele sunt tratate de nucleu ca i streams.
Orice organizare logic a structurii este dependent de aplicaie. Sistemul de operare
gestioneaz doar structura fizic a fiierelor. Se pot identifica patru tipuri de fiiere diferite:
obinuite fiiere ce conin date introduse de utilizator, de diverse aplicaii sau de
sistemul de operare.
Pagina 39
directoare conin o list cu numele de fiiere i cte o referin pentru fiecare fiier n
parte. Directoarele sunt organizate ierarhic.
speciale utilizate pentru accesarea perifericelor (terminale, imprimante). Fiecare
dispozitiv de I/E are asociat cte un fiier special.
pipe fiiere speciale folosite la comunicaia ntre fiiere.

Figura 12-13.12 Sistemul de directoare UNIX
Sistemele de operare Windows suport mai multe sisteme de fiiere, incluznd cele de tipul
tabel de alocare a fiierelor (FAT) folosite la sistemele de operare Windows 95, MS-DOS, si
OS/2, dar folosete si un sistem special sistem de fisiere NT (NTFS), care este proiectat s
satisfac cerine ale staiilor de lucru i ale serverelor. Elementele cheie ale acestui sistem de
fiiere sunt:
recuperabilitate: una dintre cele mai importante cerine a fost abilitatea sistemului de
a-i reveni dup cderi ale sale sau ale discului;
securitate: un fiier deschis este implementat ca i un obiect fiier cu un descriptor de
securitate care definete atributele de securitate;
Pagina 40
discuri mari, fiiere mari: suport discuri i fiiere de dimensiuni mari, mult mai
eficient dect alte sisteme de operare;
fluxuri de date multiple: uzual coninutul fiierelor este tratat ca i flux de octei. In
NTFS exist posibilitatea de a defini mai multe fluxuri de date pentru un singur fiier;
facilitate de indexare general: NTFS asociaz o colecie de atribute cu fiecare fiier.
Fiierele sunt descrise n cadrul sistemului de gestiune a fiierelor cu ajutorul unei
baze de date relaionale, astfel fiierele pot fi indexate dup fiecare atribut.

Pagina 41
Curs 14. Managementul dispozitivelor de I/O

Logic :

S-a reluat "Cupa Municipiului Bucuresti" la fotbal, competiie la care s-au inscris 5 echipe
(Steaua, Dinamo, Rapid, F.C. Naional i Sportul Studenesc).
Dup ce fiecare echip a jucat cu celelalte patru, la federaie a ajuns urmtoarea variant de
clasament (nu s-au trecut i numrul de puncte, dar acestea se deduc uor):

Victorii Egaluri Infrangeri Goluri marcate Goluri primite

Steaua 3 1 0 2 1
Dinamo 2 1 1 2 2
Rapid 1 3 0 1 0
National 1 2 1 1 1
Sportul 1 0 3 1 3

Dup o discuie cu observatorii federali, s-a constatat c 3 date numerice din acest tabel sunt
greite. Gsii scorurile meciurilor disputate n acest campionat (i evident - i clasamentul
real).

14.1. DMA

Figura 14.1. Comparatie intre vitezele dispozitivelor I/O
Pagina 42

Dispozitivele de intrare/ieire (I/O) v sunt cunoscute din utilizarea unui calculator i pot fi
mprite pe 3 categorii: dispozitive pentru interfaa uman cum ar fi tastatura, mouse,
imprimant, monitor, dispozitive pentru interfaa cu diferite echipamente (de ex senzori) i
dizpozitive utilizate pentru comunicare (modem).
Dincolo de diferenierea fcut n funcie de interfaarea realizat de un dispozitiv, o
alt caracteristic important n cazul dispozitivelor de I/O este cea referitoare la viteza
acestora. In figura 14.1 avei o reprezentare a vitezelor n cazul diferitelor dispozitive de I/O.
Principala tehnic de lucru cu un dispozitiv de I/O este reprezentat de DMA(Direct
Memory Access) i se refer n principal la controlul schimbului de date ntre memorie i
dispozitivul de I/O. Pentru un transfer de date utiliznd procesorul, fr s folosim un
controler de DMA pot fi realizate foarte uor mici aplicaii n limbaj de asamblare n urma
crora vei putea vedea c viteza de acces la dispozitivul de I/O este total necorespunztoare.
Din aceast cauz s-a ajuns la utilizarea unui controler de DMA. Acesta acceseaz magistrala
de date cerut de la procesor iar ciclul instrucie curent este suspendat urmnd s se transfere
date cu dispozitivul de I/O n cadrul ciclului respectiv. In figurile 14.2 i 14.3 sunt
reprezentate controlerul DMA ca schem bloc i respectiv cum arat un ciclu de instrucie i
unde poate interveni DMA:

Figura 14.2. Logica DMA

Principalele configuraii pentru plasarea controlerului de DMA le avei n figura 10.4. Nu voi
insista asupra lor pentru c informaii detaliate le gsii n cursul de microprocesoare

Pagina 43

Figura 14.3. DMA si ciclul instructie

Figura 14.4. Configuraii alternative pentru DMA

14.2. Structura logic a unei funcii I/O

Vom considera 3 cazuri pentru dispozitivele I/O i variantele structurii logice n toate
cele 3 cazuri. Cazurile sunt reprezentate sub form de diagram n figura 10.5. Primul caz, a),
Pagina 44
cel mai simplu, este cel al unui dispozitiv care comunic printr-o iniruire de bytes cu
sistemul de calcul. Nivelele care ar trebui s apar sunt urmtoarele:
modulul logic I/O : discut cu dispozitivul ca o resurs logic In principal se ocup
de identificarea dispozitivului i operaii simple ca open, close, read write;
dispozitiv I/O : datele i operaiile solicitate sunt convertite n secvene de instrucii
pentru dispozitiv i comenzi pentru controler. Tehnica de buffer poate fi utilizat
pentru mbuntirea utilizrii;
dispecerizare i control: la acest nivel sunt utilizate ntreruperile iar strile
dispozitivului sunt raportate sistemului. Tot aici se interacioneaz efectiv cu partea de
hardware a dispozitivului.
Pentru un dispozitiv folosit la comunicaii am reprezentat diagrama din figura 14.5. b).
Diferena const n faptul c modulul logic este nlocuit de o arhitectura de comunicare, care
poate fi constituit din mai multe straturi (exemplu OSI cu 7 straturi). In ultima figur este
reprezentat cazul managementului unui dispozitiv de stocare secundar. Cele 3 nivele care apar
fa de primul caz sunt:
managementul directoarelor: la acest nivel numele simbolice sunt convertite n
identificatori care refereniaz direct fiiere sau indirect printr-un descriptor sau index;
sistemul de fiiere: lucreaz cu structura logic a fiierelor i cu operaiile care pot fi
specificate de useri cum ar fi: open, close, etc. Drepturile de acces sunt controlate tot
la acest nivel;
organizarea fizic: referinele logice la fiiere sunt convertite la adrese fizice conforme
cu cele folosite de ctre dispozitiv.

Figura 14.5. Modelul de organizare pentru dispozitive I/O

Pagina 45
14.3. Tehnica de buffering

S presupunem c un proces utilizator dorete s citeasc blocuri de date de la un
dispozitiv de stocare secundar. Datele trebuie citite ntr-o zon de date a procesului. Cel mai
simplu mod este de a executa o comand ctre dispozitiv i s ateptm ca datele s devin
disponibile. Ar putea apare dou probleme importante n acest caz. Prima e c procesul trece
ntr-o stare de ateptare pentru ca dispozitivul relativ ncet de I/O s furnizeze datele. A doua,
i mai duntoare, este c aceast ateptare poate interfera cu decizia sistemului de operare de
a face un swapping pentru acel proces. Zona de memorie trebuie ns s rmn alocat n
memoria principala pn la realizarea transferului de date. In cazul paginrii doar pagina int
trebuie s rmn n memoria principal. Exist i posibilitatea unui deadlock cnd procesul
este suspendat i mutat, n acest caz el ateptnd dup dispozitivul de I/O iar acesta ateptnd
ca procesul s fie rencrcat n memoria principala. Aceleai consideraii pot fi fcute i n
cazul unei scrieri de date ctre un dispozitiv I/O.
Cele cteva moduri de rezolvare a problemei sunt prezentate n figura 14.6. Inainte de
a le explica precizm c transferul datelor de la/ctre un dispozitiv de I/O se poate face
orientat pe blocuri (cazul harddisk sau alte dispozitive de stocare secundare) sau pe streamuri
(imprimante, porturi, terminale, mouse).

Figura 14.6. Scheme de buffering pentru dispozitivele I/O

Schemele de buffering prezentate sunt urmtoarele:
un singur buffer. In momentul n care un proces utilizator realizeaz o cerere ctre un
dispozitiv I/O, sistemul de operare pregatete un buffer pentru aceast operaie n
memoria principal (practic rezerv o mic poriune de memorie). Pentru cazul
transferurilor orientate pe blocuri, dispozitivul execut transferul ctre buffer iar n
momentul n care transferul e complet, datele sunt mutate n spaiul utilizator i este
solicitat un alt bloc de date. Aceast abordare are ca rezultat o cretere a vitezei n
raport cu cazul lipsei oricrui tip de buffer. Sistemul de operare poate face swap
pentru proces deoarece operaia se execut n memoria principal i nu n memoria
procesului utilizator. Tehnica bineneles complic logica n cadrul sistemului de
Pagina 46
operare pentru c trebuie pstrate date legate de asocierea buffer-proces. In cazul
scrierii de blocuri, consideraiile sunt similare. In cazul transferurilor bazate pe stream
se pot folosi linii de date care se pot termina prin CR i astfel bufferul poate fi utilizat
pentru a stoca o singur linie;
buffer dublu. In figura 14.6. c putei vedea exemplificat aceast tehnic. Astfel,
procesul transfer date dintr-un buffer n timp ce alt bloc de date alimenteaz al doilea
buffer. In cazul transferurilor bazate pe stream acest mod nu aduce mbuntiri
substaniale;
buffer circular. In ultima parte a figurii 14.6. este exemplificat un buffer circular.
Poate fi utilizat cu succes n cazul dispozitivului de I/O cu o vitez foarte ridicat dar
complic uor mecanismul.
Sistemul de buffering este foarte util n cazul sistemelor de operare de tip multitasking n care
avem o varietate de dispozitive I/O i o varietate de procese.

14.4. Managementul discurilor

Pe parcursul dezvoltrii sistemelor de calcul s-a accentuat diferena dintre viteza de
lucru a procesorului i a memoriei i cea a dispozitivelor secundare de memorie cum ar fi
harddisk-urile. In figura 14.7. am prezentat o diagram de timp n cazul lucrului cu un
dispozitiv de stocare secundar de tip harddisk:

Figura 14.7. Diagrama temporal pentru lucrul cu un harddisk

Principalii parametri care sunt luai n considerare n cazul dispozitivelor I/O de tip harddisk
sunt:
timp de cutare. Este timpul necesar pentru mutarea la pista pe care se gsesc stocate
datele. O formula care poate caracteriza acest parametru este: T
s
= m x n + s n care :
T
s
reprezint timpul de cutare estimat, n numrul de piste traversat, m o constant
care depinde de tipul diskului iar s ntarzierea iniial;
ntrzierea rotaional. Este ntrzierea care apare fa de numrul de rotaii pe minut
prevzut;
timp de transfer. T = b/rN n care T reprezint timpul de transfer, b numrul de octei
care este transferat, N, numrul de octei de pe o pist iar r viteza de rotaie;
In continuare vom considera situaia tipic a unui mediu multitasking n care sistemul
de operare ntreine o coad de cereri pentru fiecare dispozitiv I/O. Deci pentru un singur
harddisk vor fi un numr de cereri de la diverse procese aflate n coad. In cazul n care aceste
Pagina 47
procese sunt selectate ntr-o ordine aleatoare, pistele vor fi accesate aleator obinnd astfel cea
mai proast performan.
Cea mai corect abordare este cea de tipul FIFO n care cererile sunt satisfcute n
ordinea n care se gsesc n coada respectiv. Aceasta poate funciona doar n cazul n care
exist puine procese aflate n coada de ateptare. Complementar ei putem meniona LIFO n
care ultimul proces primete controlul. Principala problem n acest caz este c anumite
procese pot rmne foarte mult n coad pna sunt satisfcute cererile dinaintea lor.
O alt tehnic folosit este SSTF (shortest service time first) care se bazeaz pe
selectarea cererii care presupune cea mai mic micare ntre pistele discului implicnd cea
mai mic durat pentru executarea operaiunii. Performanele sunt evident mai bune dect n
celelalte dou cazuri. In cazul n care exist distane egale datorit faptului c o pista se afl la
aceeasi distan fa de alte dou poate fi utilizat un mecanism aleator de selecie.
In cazul prezentat anterior exist posibilitatea ca anumite cereri s nu fie satisfcute
pn cnd coada nu e goal. Pentru a elimina acest inconvenient a fost utilizat algoritmul
SCAN. In acest caz citirea se face ntr-o singur direcie satisfacnd toate cererile pn cnd
ntlnete ultima pist n direcia respectiv sau pn cnd nu mai sunt cereri de rezolvat n
acea direcie. C-SCAN este o derivare a acestuia i cutarea se face ntr-o singura direcie.
Astfel, cnd se ajunge la ultima pist, cutarea este renceput de la prima pist, n aceeai
direcie.

Figura 14.8. Comparaie ntre algoritmi

Pagina 48

In figura 14.8. sunt prezentate rezultatele n cazul celor 4 algoritmi mai importani. Am
considerat un disc cu 200 de piste. Cererile de piste s-au fcut n urmtoarea ordine: 55, 58,
39, 18, 90, 160, 150, 38, 184. Se observ c timpii obinui n cazul algoritmilor SSTF i
SCAN sunt cei mai buni iar cel n cazul FIFO este cel mai slab.
Au mai fost dezvoltai i ali algoritmi pornind de la cei prezentai pentru diverse
optimizri. Acestea se pot face cu complicarea mecanismului de acces la dispozitivul de
stocare. Printre acetia menionm variantele SCAN : FSCAN i N-step-SCAN mai
cunoscute.

Cursuri So Actuale PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Cursuri So Actuale PDF

Uploaded by

Copyright:

Available Formats

Sisteme de operare Curs 1

You might also like