Explorați Cărți electronice
Categorii
Explorați Cărți audio
Categorii
Explorați Reviste
Categorii
Explorați Documente
Categorii
SISTEME DE OPERARE
Autor :
prep. ing. Győrödi Robert
1995-1996
Curs de SISTEME DE OPERARE
CUPRINS
1. Introducere.............................................................................................................................5
1.1 Prezentare generală...........................................................................................................5
1.2 Responsabilităţile unui S.O...............................................................................................6
1.3 Dezvoltarea istorică a S.O................................................................................................7
1.3.1 Istoria timpurie a S.O.................................................................................................7
1.3.2 Sisteme cu prelucrare în loturi şi multiprogramare...................................................8
1.3.3 Sisteme cu divizarea timpului....................................................................................8
1.3.4 Sisteme cu memorie virtuală......................................................................................9
1.3.5 S.O. pentru minicalculatoare...................................................................................10
1.3.6 S.O. pentru microprocesoare şi calculatoare personale...........................................10
1.3.7 Reţele de calculatoare şi sisteme distribuite............................................................10
1.3.8 Perspective...............................................................................................................11
2. Structura Sistemelor de Operare..........................................................................................12
2.1 Organizarea memoriei.....................................................................................................12
2.2 Structuri de execuţie.......................................................................................................14
2.3 Interacţiunea componentelor...........................................................................................16
2.4 Adaptabilitatea la configuraţii hardware.........................................................................17
3. Sistemul de Operare MS-DOS. Probleme generale.............................................................18
3.1 Structura S.O. MS-DOS. Încărcarea sistemului.............................................................19
3.2 Utilizarea şi organizarea spaţiului pe discuri..................................................................19
3.3 Hard discuri.....................................................................................................................20
3.3.1 Floppy discuri..........................................................................................................21
3.3.2 Formatarea...............................................................................................................21
3.3.3 Partiţii.......................................................................................................................22
3.3.4 MBR-ul, sectoare boot şi tabele de partiţii..............................................................22
3.3.5 Partiţii extinse şi logice............................................................................................22
3.4 Organizarea spaţiului pe discuri......................................................................................23
3.4.1 Caracteristicile fizice ale discului............................................................................23
3.4.2 Organizarea logică a discurilor................................................................................24
3.4.3 Partiţionarea discurilor fixe.....................................................................................27
3.5 Sistemul de întreruperi în MS-DOS...............................................................................28
3.5.1 Întreruperi hardware................................................................................................29
3.5.2 Întreruperi BIOS......................................................................................................30
3.5.3 Întreruperi DOS.......................................................................................................30
3.6 Formatul fişierelor executabile. Prefixul segmentului de program................................31
3.6.1 Structura fişierelor .COM........................................................................................31
3.6.2 Structura fişierelor .EXE.........................................................................................32
4. Interfaţa MS-DOS cu utilizatorul.........................................................................................35
4.1 Generalităţi......................................................................................................................35
4.2 Servicii oferite de MS-DOS. Serviciile sistem...............................................................38
4.2.1 Funcţii pentru gestionarea fişierelor........................................................................38
4.2.2 Funcţii pentru gestionarea cataloagelor...................................................................41
4.2.3 Funcţii pentru I/E cu dispozitive standard orientate pe caractere............................42
-2-
Curs de SISTEME DE OPERARE
4.2.4 Funcţii pentru gestionarea perifericelor...................................................................43
4.2.5 Funcţii pentru gestionarea memoriei şi a proceselor...............................................45
4.2.6 Alte funcţii sistem....................................................................................................48
4.3 Funcţii de bibliotecă C pentru apelul sistemului MS-DOS............................................49
4.3.1 Funcţii pentru gestionarea fişierelor........................................................................49
4.3.2 Funcţii pentru gestionarea cataloagelor...................................................................50
4.3.3 Funcţii pentru gestionarea perifericelor...................................................................52
4.3.4 Funcţii pentru gestionarea memoriei.......................................................................55
4.3.5 Funcţii pentru gestionarea proceselor......................................................................56
4.3.6 Alte funcţii sistem....................................................................................................62
5. Gestionarea memoriei..........................................................................................................65
5.1 Memoria convenţională..................................................................................................65
5.2 Blocurile din Memoria Superioară (UMB).....................................................................65
5.3 Structuri de date folosite de MS-DOS în gestionarea memoriei....................................66
5.4 Procesarea liniei A20. Memoria înaltă...........................................................................67
6. Sistemul de Operare UNIX. Probleme generale..................................................................69
6.1 Introducere......................................................................................................................69
6.1.1 Cauzele răspândirii sistemului de operare UNIX....................................................69
6.1.2 Considerente de realizare a S.O. UNIX...................................................................70
6.1.3 Caracteristici generale al sistemelor UNIX.............................................................71
6.2 Principii de utilizare ale sistemului UNIX......................................................................71
6.3 Principalele comenzi UNIX............................................................................................73
6.4 Elemente ale limbajului de comandă UNIX (Shell).......................................................77
6.5 Proceduri shell (Shell scripts).........................................................................................80
6.5.1 Crearea şi executarea unui fişier de comenzi...........................................................80
6.5.2 Variabile şi parametri care pot fi prevăzuţi în pseudo-programe shell....................81
6.5.3 Intrarea şi ieşirea standard.......................................................................................82
6.5.4 Structuri de control în proceduri shell.....................................................................82
6.5.5 Comentarii................................................................................................................85
6.5.6 Substituţia comenzilor.............................................................................................85
6.5.7 Ordinea evenimentelor.............................................................................................85
6.5.8 Opţiunile shell-ului..................................................................................................86
6.5.9 Redirectarea întreruperilor.......................................................................................86
6.5.10 Ambianţa sau mediul de lucru...............................................................................86
6.5.11 Lansarea shell-ului din login..................................................................................87
6.5.12 Un exemplu de shell script.....................................................................................88
6.6 Vedere generală asupra sistemului..................................................................................90
6.6.1 Arhitectura sistemului UNIX...................................................................................90
6.6.2 Mediul de procesare.................................................................................................91
6.6.3 Servicii ale sistemelor de operare............................................................................92
6.6.4 Restricţii hardware...................................................................................................92
6.6.5 Întreruperi şi excepţii...............................................................................................93
6.6.6 Nivele de execuţie ale procesorului.........................................................................93
6.6.7 Gestionarea memoriei..............................................................................................93
7. Arhitectura Sistemului de Operare UNIX............................................................................95
7.1 Introducere......................................................................................................................95
7.2 Subsistemul de fişiere.....................................................................................................96
7.3 Subsistemul de procese...................................................................................................99
7.3.1 Contextul unui proces............................................................................................101
7.3.2 Stările şi tranziţiile unui proces.............................................................................102
7.4 Controlul proceselor......................................................................................................105
-3-
Curs de SISTEME DE OPERARE
7.4.1 Crearea proceselor.................................................................................................105
7.4.2 Semnale..................................................................................................................108
7.4.3 Terminarea proceselor...........................................................................................112
7.4.4 Aşteptarea terminării proceselor............................................................................112
7.4.5 Executarea altor programe.....................................................................................113
-4-
Curs de SISTEME DE OPERARE
1. Introducere.
}
Editor de Interpretor
Compilator
texte de comenzi Programe
SISTEM DE sistem
OPERARE
}
Limbaj maşină
Hardware
Echipamente fizice
Fig. 1.1-1
O posibilă definiţie a S.O. : Vom spune că un S.O. este un set de programe care are
două obiective :
• asigură gestionarea resurselor unui sistem de calcul, implementând algoritmi care să
realizeze performanţe cât mai bune;
• realizează o interfaţă între utilizatori şi sistemul de calcul, extinzând dar şi
simplificând setul de operaţii disponibile.
-5-
Curs de SISTEME DE OPERARE
Există cel puţin trei clase de persoane care fac uz de sistemul de calcul :
• utilizatori obişnuiţi - aceştia folosesc programele scrise de alţii, ei nu ştiu să
programeze, dar trebuie să aibe cunoştinţe despre modul de utilizare al sistemului de
calcul.
• programatori de aplicaţie - ei ştiu să programeze, lucrează în limbaje de nivel înalt şi
din aceste limbaje fac apel indirect la o serie de servicii oferite de S.O.
• programatori de sistem - care programează în limbaje de nivel înalt sau în limbaj de
asamblare şi fac uz mai direct de serviciile S.O., folosind un mecanism de
declanşare al serviciilor, diferit de cel aflat la dispoziţia programatorilor de aplicaţii.
a) Interfaţa cu utilizatorul.
Există cel puţin două componente distincte ale interfeţei :
• interfaţa prin comenzi
• interfaţa prin apeluri sistem
b) Gestionarea fişierelor.
Suportul cel mai folosit al fişierelor este discul magnetic, dar există şi alte medii de
stocare (de ex. discuri compacte).
În componenta de S.O. care realizează gestionarea de fişiere sunt prevăzute servicii
pentru crearea, distrugerea, citirea, scrierea, organizarea şi controlul accesului la informaţiile
din fişiere.
c) Gestionarea perifericelor.
Datorită varietăţii echipamentelor periferice care se pot conecta într-un sistem de
calcul se impune ca S.O. să preia detaliile legate de lucrul cu aceste periferice. În modulul de
gestionare a perifericelor sunt incluse toate aspectele specifice pentru fiecare periferic, astfel
-6-
Curs de SISTEME DE OPERARE
încât spre utilizatorii acestui modul funcţionarea tuturor perifericelor să apară standardizată.
De regulă modulul de gestionare a perifericelor funcţionează pe baza unor interacţiuni cu
mecanismul de întreruperi.
d) Gestionarea memoriei.
Din memoria internă o parte este întotdeauna rezervată S.O., iar restul memoriei este
disponibilă pentru unul sau mai mulţi utilizatori. Dacă S.O. permite existenţa mai multor
programe utilizator în memoria internă se pune problema controlului accesului acestor
programe la diverse zone de memorie. În sistemele cu memorie virtuală gestionarea memoriei
include şi o parte a memoriei externe, care serveşte ca suport pentru memoria virtuală.
e) Gestionarea proceselor.
Numim proces un program în execuţie sub controlul unui S.O. Majoritatea S.O.
prevăd posibilitatea existenţei simultane a mai multor procese, de unde rezultă necesitatea de
a controla interacţiunea acestora. Este vorba în primul rând de accesul proceselor la unitatea
centrală dar şi de mecanisme de sincronizare între procese.
f) Tratarea erorilor.
S.O. trebuie să fie pregătit pentru a reacţiona la o mare diversitate de erori cu cauze
atât în hardware cât şi în software. Erorile trebuie detectate şi în măsura posibilului trebuie
asigurată revenirea din erori şi continuarea lucrului.
g) Gestionarea sistemului.
Instalarea unui S.O. pe un nou echipament, culegerea de date statistice despre
comportarea sistemului pentru ajustarea funcţionării sale în viitor şi în special ţinerea
evidenţei resurselor consumate de fiecare utilizator al sistemului.
-7-
Curs de SISTEME DE OPERARE
fiecărui program pentru ca o rutină încărcător din I.O.S. să încarce în memorie următorul
program. Apoi au apărut S.O.S. - IBM 709, mai perfecţionat, includea şi un asamblor şi apoi
sistemul FMS, tot la IBM.
UC în UC
activitate neutilizat Timp
Progr. operaţie aşteptare
A periferică
timp
Progr.
B
Grad de
utilizare
timp
Progr.
C
timp
Fig. 1.3-1
Din punctul de vedere al utilizatorului sistemele cu prelucrare în loturi produc o
separare a utilizatorului de sistemul de calcul şi lungesc timpul dintre predarea (introducerea)
unei lucrări în sistem şi obţinerea rezultatelor.
Memoria Calculator
Imprimantă
externă (UC +memorie)
.....
Terminale
Fig. 1.3-2
Timpul UC este acum distribuit între terminale active în cantităţi egale numite cuante.
Toate programele active la un moment dat pot progresa. Ordinul de mărime al unei cuante era
de 100 ms. Nu toate programele active la un moment dat au loc în memoria operativă. De
aceea, în astfel de sisteme se utilizează şi un mecanism (algoritm) special pentru gestionarea
memoriei numit swapping. Aceasta înseamnă că atunci când UC este luată de la un program
activ în acel moment şi cedată la alt program, dacă programul care primeşte controlul nu este
prezent în memorie, el va fi transferat în memorie în locul unui program care a pierdut
dreptul de utilizare a UC. Acesta este transferat în memoria externă în starea în care e la
momentul respectiv (programele îşi schimbă locul).
De regulă însă algoritmul de swapping este combinat cu multiprogramarea rezultând
o creştere a gradului de utilizare a memoriei şi a UC.
Exemple :
• OS/360 - sistem de operare cu multiprogramare, scris în 1965 pentru IBM 360.
• CTSS - sistem de operare cu divizarea timpului (Compatible Time Sharing System)
pentru IBM 7094 (generaţia a II-a) scris la MIT.
• TSS - Time Sharing System scris de IBM.
• TSO - variantă a lui OS/360 care permite şi o opţiune de divizare a timpului.
• MULTICS
• proiect realizat la MIT
• S.O. bazat pe calculatorul GE635 (General Electric)
• alte concepte exploatate :
• memorie virtuală segmentată
• ierarhie de fişiere
• redirectarea operaţiilor de I/E
• acces protejat la resurse
• interfaţă extinsă cu utilizatorul
• ideea de bază : puterea de calcul să se transforme în utilitate publică
Exemple :
• Atlas - 1961 - conceptul de memorie cu un singur nivel
• IBM 370 :
• OS/MVS - Multiple Virtual Space
-9-
Curs de SISTEME DE OPERARE
• OS/VM - Virtual Machine - face posibilă rularea simultană a mai multor S.O.
În 1971 Intel a produs primul microprocesor pe 4 biţi : 4004. Pentru 8080 a fost scris
S.O. CP/M (Digital Research), care era simplu, monoutilizator şi avea un set redus de
comenzi.
Apariţia microprocesoarelor pe 16 biţi duce la apariţia calculatoarelor personale :
8086 (8088), Motorola 6800.
Pentru familia 8086 apare MS-DOS, scris de Microsoft. Acest sistem împrumută
elemente de la UNIX dar este monoutilizator şi monoprocesor.
La apariţia µP 80286, IBM a introdus familia PS/2, pentru care a elaborat S.O. OS/2.
Baza de aplicaţii a lui OS/2 este mai redusă decât aceea pentru MS-DOS şi astfel este folosit
mai puţin.
Microprocesoarele începând cu 80386 sunt deja suficient de puternice pentru folosirea
S.O. UNIX.
Pe lângă calculatoarele personale se răspândesc staţiile de lucru (workstation), care au
putere de lucru mare, bazate pe procesoare RISC.
- 10 -
Curs de SISTEME DE OPERARE
Project Agency). Fiecare dintre calculatoarele conectate avea sistemul propriu de operare, iar
operaţiile dintre calculatoare erau privite ca operaţii periferice.
Realizarea reţelelor a impus modificări în software şi hardware. Odată cu răspândirea
sistemelor s-a pus problema sistemelor de operare de reţea. Acest deziderat s-a putut realiza
atunci când s-au răspândit calculatoarele interconectate local (LAN - Local Area Networks),
astfel apărând MAN (Metropolitan Area Networks) şi WAN (Wide Area Networks).
Există şi încercări de realizare a unor S.O. care tratează toate resursele dintr-o reţea ca
făcând parte dintr-un sistem unic, deci nu mai lasă vizibilă utilizarea topologiei de reţea.
Acestea se numesc S.O. distribuite.
1.3.8 Perspective.
- 11 -
Curs de SISTEME DE OPERARE
- 12 -
Curs de SISTEME DE OPERARE
În CP/M nu se face distincţie între cele 3 aspecte, deci harta va reprezenta conţinutul
memoriei fizice (Fig. 2.1-1).
64K BIOS - conţine rutinele pentru tratarea la nivel fizic a
BIOS
operaţiilor periferice
BDOS BDOS - conţine elemente necesare pentru construcţia
CCP unui sistemde fişiere
BIOS +BDOS ≈ 10K
Nefolosit CCP - interpretor de comenzi al sistemului (2K), el este
încărcat la cerere. Dacă este necesar, un program
Programede de aplicaţie poate acoperi zona de memorie a CCP.
aplicaţie+date
256 Obs. : Toate programele de aplicaţie sunt generate
considerând că ele se încarcă în memorie de la
zonă comunicaţie
adresa 1000H (4K).
0
Fig. 2.1-1
În MS-DOS deosebim o hartă a memoriei fizice şi una a spaţiului virtual de adrese a
programelor (Fig. 2.1-2 şi Fig. 2.1-3).
1M zona de comunicaţii constă din tabela vectorilor de
BIOS (ROM)
întreruperi (1K) şi zona de transfer cu discul 512 octeţi.
Mem video zona rezident SO se includ rutinele pentru gestiunea
640K
Interpretor c-zi sistemului, rutinele pentru realizarea sistemului de fişiere şi
o parte din interpretorul de comenzi.
Nefolosit memoria video cuprinde zona care se pune în
corespondenţă directă cu zona consolei utilizator.
Programede
aplicaţie+date
~100K
Rezident SO
1536
zonă comunicaţie
0
Fig. 2.1-2
Din punctul de vedere al unui program spaţiul virtual de adrese se compune din 1 ÷ 4
segmente de 64 Kocteţi. În figura Fig. 2.1-3 se prezintă cazul tipic : modelul de memorie
small.
64 K 64 K
stiva aplicaţiei
cod propriuzis
Fig. 2.1-3
- 13 -
Curs de SISTEME DE OPERARE
În UNIX harta fizică a memoriei va depinde de arhitectura calculatorului pe care este
implementat sistemul.
Există o separare totală între spaţiul de adrese al unui program utilizator şi spaţiul de
adrese al unui program sistem (Fig. 2.1-4). Orice comunicare între programele utilizator şi
sistem se face prin apeluri sistem (deci nu prin memorire comună).
Adrese Adrese
MARI STIVA MARI
Neutilizat
Partea rezidentă
Dateiniţiale a S.O.
Cod program
Adrese Adrese
mici mici
Program utilizator Sistemul deOperare
Fig. 2.1-4
Obs.: Comparativ, partea rezidentă a celor trei S.O. prezentate necesită următoarele
cantităţi de memorie :
• CP/M ≈ 10Kb
• MS-DOS ≈ 100Kb
• UNIX ≈ 1Mo
Codul unui S.O. constă din mai multe unităţi executabile, execuţia fiecărei unităţi
fiind declanşată de evenimente specifice.
În organizarea tradiţională S.O. pot fi privite ca o colecţie de rutine, activate fiecare
prin apeluri sistem din programe utilizator, sau ca urmare a unor întreruperi.
apeluri sistem
puncte dispecer Rutine de tratare
de a apelurilor sistem
intrare
intr #1
în
sistem Rutine de tratare
intr #2 specifice
Fig. 2.2-1
Rutinele care servesc ca puncte de întrerupere în S.O. trebuie să fie în partea rezidentă
a sistemului de operare.
- 14 -
Curs de SISTEME DE OPERARE
Obs.: Majoritatea S.O. prevăd un singur punct de intrare în sistem, acesta fiind un
dispecer care va rezolva apelurile.
În timpul execuţiei acestor rutine sau altora pot apare solicitări de încărcare a unor
părţi nerezidente. Aduse în memorie ele vor avea acelaşi nivel de privilegiu cu rutinele
rezidente (există şi excepţii). Un apel sistem apare în programe cu aceeaşi sintaxă ca şi apelul
obişnuit de rutine. Traducerea lor în cod executabil este însă diferită, prevăzându-se operaţiile
necesare pentru schimbarea regimului de execuţie (se trece din regim neprivilegiat, specific
programelor utilizator, în regim privilegiat, specific S.O., adică nu mai sunt aplicate toate
elementele de protecţie aplicate programului utilizator).
Multe din rutinele S.O. revin la programul apelant numai după satisfacerea completă a
serviciilor solicitate.
Există apeluri sistem (şi deci rutine din S.O.) care declanşează activităţi ce se vor
desfăşura simultan cu desfăşurarea activităţilor U.C. fără a avea nevoie de U.C. (de exemplu
operaţiile de I/O). În aceste cazuri, programul care a făcut apelul, e de regulă suspendat până
la terminarea serviciului, iar U.C. poate fi folosit de alte programe (vezi multiprogramarea).
La terminarea unui serviciu de durată, solicitat de un program, se declanşează o întrerupere ce
va face ca U.C. să suspende execuţia programului în curs şi să treacă la execuţia rutinei de
tratare a întreruperii. Ca urmare a execuţiei acestei rutine se vor modifica diferite structuri de
date şi este posibil ca programul care a fost blocat pentru efectuarea serviciului să devină gata
de execuţie. La terminarea rutinei de tratare a întreruperii, o componentă a S.O., numită
planificator decide dacă se reia execuţia programului care a fost suspendat în momentul
apariţiei întreruperii sau se alege un alt program.
În S.O. simple toate serviciile sunt duse până la capăt fără a se reveni la programul de
aplicaţie sau altele.
În S.O. mai complexe, apar activităţi ale S.O. care trebuie să continuie pe o perioadă
mai lungă în paralel cu execuţia proceselor utilizator (tipărirea unor fişiere la imprimantă,
controlul unor linii de telecomunicaţie, o serie de activităţi periodice cum ar fi la UNIX
salvarea tampoanelor din memorie pe disc). Ele sunt organizate ca procese distincte, numite
taskuri sistem şi sunt tratate asemănător cu procesele utilizator, având însă prioritate de
planificare mai mari.
Organizarea unei părţi din S.O. ca procese este o cale de reducere a erorilor în
realizarea S.O. (pentru că trebuie controlat un volum mai mic de cod). Există o parte a
codului de S.O. care rămâne în afara proceselor sistem şi cuprinde servicii esenţiale, între ele
fiind inclusă şi planificarea proceselor, comunicarea între procese, rutine pentru gestionarea
memoriei etc.
- 15 -
Curs de SISTEME DE OPERARE
Într-o structură fără restricţii, orice rutină a unui S.O. ar putea apela orice altă rutină
sau ar putea face acces la orice structuri de date ale sistemului. Un astfel de S.O. ar fi foarte
puţin fiabil pentru că ar fi extrem de dificil să se controleze efectele unei schimbări într-o
rutină sau într-o structură de date. Restricţii asupra interacţiunilor componentelor pot fi
impuse atât în procesul de proiectare a S.O. cât şi în timpul execuţiei rutinelor sistem. La
proiectare restricţiile se pot realiza prin intermediul compilatorului, dacă se foloseşte un
limbaj adecvat pentru implementare. La execuţie este necesar un sprijin din partea hardware-
ului, ceea ce în cele mai multe arhitecturi nu este întâlnit.
Primul S.O. proiectat structurat a fost sistemul T.H.E. (Technische Hocheschool
Eindhard), realizat de un grup condus de Dýkstra. A fost experimental, a apărut înainte de
1968 şi a fost scris pentru minicalculatoarele Philips. Era organizat pe mai multe nivele
(Fig. 2.3-1) :
5. Utilizatori
4. Programe deaplicaţie
3. Periferice
2. Consola utilizator
1. Memoria virtuală
0. Planificarea proceselor,
tratarea întreruperilor
Fig. 2.3-1
Fiecare nivel gestionează o categorie de resurse, vitualizează resursele respective. Se
realizează astfel o secvenţă de maşini abstracte (sau virtuale), fiecare bazată pe maşina de la
nivelul inferior şi fiecare oferind noi funcţii pentru nivelul inferior :
• La nivelul 0 există o colecţie de rutine, ce realizează virtualizarea procesorului.
deasupra acestui nivel este asigurat faptul că fiecare proces are propriul său procesor
virtual.
• La nivelul 1 există un proces sistem care realizează virtualizarea memoriei. În
nivelele următoare fiecare proces are propriul spaţiu de memorie virtuală. Resursele
gestionate la nivelul 1 sunt memoria internă şi un tambur magnetic, care serveşte ca
suport extern al memoriei virtuale (precursorul discului magnetic).
• Nivelul 2 conţine un proces care gestionează consola calculatorului. Prin
virtualizarea acesteia fiecare proces din nivelele superioare are propria consolă
utilizator, la care poate emite mesaje.
• La nivelul 3 se găseşte câte un proces pentru fiecare periferic, altul decât consola
sau tamburul prezent în configuraţia sistemului de calcul.
• Nivelul 4 conţine un număr oarecare de procese care funcţionează ca interpretoare
de comenzi şi deci pot controla execuţia programelor utilizatorilor.
Structurarea pe nivele a S.O. permite ca porţiunile critice ale sistemului să fie izolate
în nivelele inferioare care se construiesc şi se testează cu foarte multă rigurozitate. Numărul
- 16 -
Curs de SISTEME DE OPERARE
de nivele din structura unui sistem nu este fix, depinde de deciziile luate de proiectanţi,
funcţie de domeniul de aplicaţie, de experienţa proiectanţilor etc.
O extindere a modelului este prezentată în figura Fig. 2.3-2.
11 Periferice
10 Sistem defişiere
9 Comunicaţii interprocese
8 Mecanismedeprotecţie
7 Memorievirtuală Capabilităţi
6 Memorie secundarã localã
5 Proceseelementare Calculator
singular
4 Întreruperi
3 Mecanismepentru proceduri
Hardware
2 Setul deinstrucţiuni
1 Circuiteelectronice
Fig. 2.3-2
S.O. depinde în mare măsură de hardware-ul calculatorului, aceasta fiind una din
principalele deosebiri ale S.O. faţă de alte componente software. Este de dorit ca un S.O. să
fie proiectat avându-se în vedere şi portabilitatea. în cazul cel mai simplu este necesar ca un
S.O. să poată fi uşor adaptat la sisteme de calcul cu configuraţii diferite dar din aceeaşi
familie. Adică să se poată uşor specifica un număr diferit de periferice, cantitate diferită de
memorie etc. În cazul extrem pentru adaptarea la o nouă configuraţie ar trebui făcute
modificări în codul sursă al S.O. Modalitatea uzuală întâlnită însă este ca la iniţializarea S.O.
să fie consultată o serie de fişiere de configurare din care se culeg informaţii specifice unui
sistem de calcul dat. La MS-DOS acest fişier este config.sys, în UNIX există mai multe fişiere
de configurare pe mai multe zone funcţionale ale sistemului. Mai trebuie prevăzută şi
modalitatea de a adăuga simplu la sistem porţiuni de program numite drivere care controlează
funcţionarea unor periferice noi adăugate în configuraţia hardware.
- 17 -
Curs de SISTEME DE OPERARE
Sistemul există din 1981. Este primul S.O. pentru microprocesoare pe 16 biţi. În
momentul de faţă se consideră că este cel mai răspândit S.O. din lume, având vândute câteva
zeci de milioane de exemplare. Sistemul de operare constituie baza pentru câteva zeci de mii
de aplicaţii, ceea ce îl situează pe primele locuri în lume.
MS-DOS versiunea 1.0 a apărut în august 1981. Această versiune avea multe
caracteristici în comun cu S.O. CP/M (care a fost folosit ca şi model). Avea sistem de fişiere
cu un singur nivel, ceea ce s-a corectat în martie 1983, la versiunea 2.0, care conţine pentru
prima dată driver pentru discul winchester de 10Mb şi sistem de fişiere ierarhic. În versiunea
2.0 se împrumută de la UNIX modul de realizare a apelurilor sistem pentru lucrul cu fişiere.
În august 1984 apare versiunea 3.0 care este legată de introducerea calculatoarelor AT
cu Intel 80286 şi cu discuri fixe de 20Mb (arhitectura standard I.B.M.) şi discuri flexibile de
1,2Mb. Versiunea 3.0 permite definirea de discuri virtuale în RAM şi introduce posibilitatea
de protecţie a fişierelor (un fişier poate fi considerat read only).
În noiembrie 1984 apare versiunea 3.1 care permite lucrul în reţea şi posibilitatea ca în
aceeaşi reţea să se lucreze cu sisteme de fişiere diferite.
În 1986 s-a introdus versiunea 3.2 cu driver pentru discuri flexibile de 3 1/2 inch şi
câteva comenzi suplimentare între care xcopy. De asemenea introduce un driver special care
permite copierea pe aceeaşi unitate de disc.
În 1987 este lansată versiunea 3.30 care adaugă câteva funcţii cerute de utilizatori, pe
noua familie de calculatoare numită PS/2. Se permit 4 porturi de comunicare, se permit
dischete de 1.44Mb şi se permit pe discuri fixe mai multe (4) partiţii de maximum 32Mb
fiecare.
În 1988 este introdusă versiunea 4.0 care permite lucrul cu discuri fixe cu capacităţi
de până la 2Gb. Permite utilizarea de către programe a memoriei expandate şi introduce o
interfaţă grafică cu utilizatorul, realizată conform specificaţiilor T.B.M. numite C.U.A.
(Common User Access). Versiunea 4.1 lansată spre sfârşitul lui 1988 corectează unele
anomalii găsite la 4.0.
În primăvara lui 1991 apare versiunea 5.0 care extinde interfaţa grafică în sensul unei
apropieri de Windows.
Din 1993 este disponibilă versiunea MS-DOS 6.0 iar din 1994 versiunea 6.2, care
dispun de următoarele facilităţi :
• includerea unui utilitar pentru compresia datelor pe disc ce poate determina chiar
dublarea capacităţii suporţilor magnetici (DoubleSpace);
• incorporarea unui program antivirus (MSAV şi VSAFE);
• înlocuirea comenzilor Backup-Restore cu un produs mai bun şi posibilitatea
eliminării fragmentărilor de pe disc (DEFRAG);
• incorporarea unei modalităţi îmbunătăţite de gestionare a memoriei superioare
(MemMaker);
• determinarea în mod automat a programelor ce se pot executa în memoria
superioară (DOS 6.0 ocupă 200K din totalul de 384K);
• comanda MOVE care permite mutarea unui director cu întreg conţinutul;
• comanda CHOICE, ce permite citiri de la tastatură în timpul execuţiei, inclusă în
limbajul de comenzi al fişierelor batch.
- 18 -
Curs de SISTEME DE OPERARE
3.1 Structura S.O. MS-DOS. Încărcarea sistemului.
Când se instalează , sau se face upgrade la un sistem, o mare parte a lucrului implică
manipularea şi utilizarea discurilor. Pentru ca pe un disc să se poată stoca fişiere, acesta
trebuie pregătit în conformitate cu sistemul utilizat.
Principalii paşi în pregătirea discurilor sunt:
• Formatarea discului. Acest proces implică mai multe operaţii de pregătire, ca de
exemplu căutarea de sectoare defecte. În prezent cele mai multe hard discuri nu
necesită această operaţie, deoarece ele vin deja gata formatate de la producător.
Acest proces mai este cunoscut şi sub numele de Formatare Low Level.
• Partiţionarea hard discului, aceasta în cazul în care se doreşte utilizarea lui pentru
mai multe activităţi care să nu interfere unele cu altele. Un motiv pentru partiţionare
este folosirea unui singur disc pentru mai multe sisteme de operare. Un alt motiv
este de a ţine separat fişierele utilizatorilor de cele de sistem, aceasta simplificând
back-up-urile şi deasemenea ajută la protejarea fişierelor sistem.
• Crearea unui sistem de fişiere (de un tip potrivit) pe fiecare disc sau partiţie. De
obicei discurile, respectiv partiţiile nu se pot utiliza până când nu se creează pe ele
un sistem de fişiere. Acest proces mai este cunoscut şi sub numele de Formatare
High Level.
• Pentru anumite sisteme, pentru ca sistemele de fişiere create să se poată utiliza, ele
trebuiesc montate sau automat sau manual. (UNIX). De obicei sistemele de fişiere
montate manual trebuiesc demontate tot manual.
- 19 -
Curs de SISTEME DE OPERARE
În figura următoare se prezintă schematic părţile importante ale unui hard disc.
Privit de sus :
Sens de rotaţie
Pistă / Track
Sector
Cap de
citire / scriere
Platan (Platter)
Feţe
Cilindru
Fig. 3.3-1
Un hard disc constă dintr-unul sau mai multe platane circulare, care au una sau ambele
feţe acoperite cu o substanţă magnetică, folosită pentru înregistrarea informaţiilorr. (Platanele
sunt de obicei construite dintr-o substanţă mai dură, de ex. aluminiu, ceea ce le dă şi numele
de discuri dure sau de masă - hard disc). Pentru fiecare suprafaţă există un cap de
citire/scriere care examinează sau alterează informaţia înregistrată. Platanele se rotesc pe o
axă comună, cu o viteză tipică de 3600 rotaţii pe minut, deşi discurile de înaltă performanţă
au o viteză de rotaţie mărită. Capetele se deplasează de-a lungul razei platanelor. Această
mişcare combinată cu rotaţia platanelor permite accesarea oricărei părţi a suprafeţei.
Procesorul şi discul comunică printr-un controller de disc. Acesta separând restul
computerului de sarcina de a controla efectiv discul.
- 20 -
Curs de SISTEME DE OPERARE
Suprafeţele, de obicei sunt divizate în inele concentrice, numite piste (tracks), iar
acestea sunt divizate în sectoare (sectors). Această împărţire este folosită pentru specificarea
unei anumite locaţii de pe disc şi pentru alocarea spaţiului pentru fişiere. Astfel pentru a găsi
un anumit loc pe disc se poate specifica : suprafaţa x, pista y, sectorul z. De obicei numărul
de sectoare este acelaşi pentru toate pistele, dar unele hard discuri au mai multe sectoare pe
pistele exterioare şi mai puţine pe pistele interioare. Tipic, un sector va conţine 512 octeţi de
date. Discul nu poate manipula o cantitate mai mică de date decât aceea a unui sector.
Fiecare suprafată este divizată în piste şi sectoare în acelaşi fel. Aceasta înseamnă că
dacă capul pentru o suprafaţă este pe o pistă, capetele pentru celelalte suprafeţe sunt
deasemenea pe pistele corespondente. Toate pistele corespondente luate împreună poartă
denumirea de cilindru. Mutarea capetelor de pe un cilindru pe altul durează un anumit timp,
astfel plasând împreună datele care sunt accesate des, astfel ca să fie situate pe acelaşi
cilindru, nu este necesară operaţia de mutare a capetelor pentru a citi toate aceste date.
Aceasta înbunătăţeşte performanţele. Din păcate nu întotdeauna este posibil să plasăm astfel
fişierele. Fişierele care sunt stocate în mai multe părţi de pe disc se numesc fragmentate.
Numărul feţelor (sau capetelor), cilindrilor şi sectoarelor variază destul de mult.
Specificarea numărului fiecăruia este numită geometria hard discului. Această geometrie de
obicei este memorată într-o memorie specială numită CMOS RAM.
Din păcate BIOS-urile mai vechi au o limitare în implementare, fiind imposibilă
specificarea unui număr de piste mai mare de 1024, în memoria CMOS, aceasta este însă prea
puţin pentru hard discurile mari. Pentru a depăşi această limitare, controllerele de disc
comunică o geometrie falsă şi translatează adresele date de calculator astfel încât să concorde
cu realitatea. De exemplu un hard disc ar putea avea 8 capete, 2048 piste şi 35 sectoare pe
pistă. În acest caz, o posibilă translatare ar fi : 16 capete, 1024 piste şi 35 sectoare pe pistă.
Această translatare ar putea afecta performanţele (vezi discuţia despre fragmentare).
Translatarea este o problemă doar pentru discurile IDE. Discurile SCSI utilizează o
numerotare secvenţială a sectoarelor.
Un disk floppy constă dintr-o membrană flexibilă acoperită pe una sau ambele feţe cu
o substanţă magnetică similară cu cea a hard discurilor. Un disc floppy corespunde unui
platan dintr-un hard disc, dar este îndepărtabil din unitate, pe când hard discurile constituie o
unitate indivizibilă.
Ca şi un hard disc, un floppy este divizat în piste şi sectoare (iar cele două piste
corespondente de pe feţele unui floppy formează un cilindru), dar sunt mult mai puţine decât
pe un hard disc.
O unitate de floppy discuri de obicei poate fi folosită cu mai multe tipuri de discuri,
de exemplu o unitate de 31/2 inch poate fi utilizată atât cu dischete de 720KB cât şi de
1,44MB.
3.3.2 Formatarea
Formatarea este procesul scrierii de marcaje pe mediul magnetic care sunt utilizate la
marcarea pistelor şi sectoarelor. Înainte ca un disc să fie formatat, suprafaţa sa magnetică este
un haos complet de semnale magnetice. Când este formatată, se introduce o anumită ordine în
acest haos, în principal prin ”tragerea” de linii acolo unde vor fi pistele precum şi acolo unde
acestea sunt despărţite în sectoare. Detaliile de implementare nu sunt relevante pentru acest
curs. Ceea ce este însă important, este că un disc nu poate fi folosit până când el nu este
formatat.
- 21 -
Curs de SISTEME DE OPERARE
Pentru discurile IDE şi SCSI în prezent formatarea se face de către producător, astfel
încât aceasta nu mai trebuie făcută. Mai mult s-ar putea ca unele discuri să necesite o
formatare specială, astfel o reformatare ar duce la scăderea performanţelor hard discului.
Dicurile care totuşi au nevoie de formatare necesită programe speciale care de obicei
există în BIOS, sau ca şi programe executabile sub un anumit sistem de operare.
3.3.3 Partiţii
Un hard disc poate fi împărţit în mai multe partiţii. Fiecare partiţie se comportă ca şi
cum ar fi un hard disc separat. Ideea este accea că există doar un singur hard disc şi se doreşte
instalarea a două sisteme de operare, se poate împărţi hard discul în două părţi. Fiecare sistem
de operare folosind partiţia sa cum doreşte şi ne atingându-se de alte partiţii. Fără partiţii ar
trebui ca pentru fiecare sistem de operare să existe un hard disc separat.
Discurile floppy nu sunt partiţionate. Nu există nici un impediment tehnic pentru
aceasta, dar deoarece ele sunt de capacitate relativ mică, partiţiomarea lor nu ar ajuta aproape
la nimic.
Informaţia cu privire la modul în care un hard disc a fost partiţionat este memorată în
primul sector al acestuia (adică în primul sector al primei piste de pe prima faţă). Primul
sector este Master Boot Record-ul discului, acesta este sectorul pe care BIOS-ul îl citeşte şi îl
lansează când sistemul este pornit pentru prima dată. MBR-ul conţine un mic program care
citeşte tabela de partiţii, caută partiţia activă (cea care este marcată ca şi bootable) şi citeşte în
memorie primul sector al acelei partiţii, adică sectorul de boot al partiţiei (MBR-ul este tot un
sector de boot, dar are un statut special). Acest sector de boot conţine un alt program care
citeşte în memorie prima parte a sistemului de operare care există pe acea partiţie şi îi dă
controlul.
Partiţionarea este doar o convenţie urmată de cele mai multe sisteme de operare.
Unele sisteme de operare suportă partiţii, dar ele ocupă o singură partiţie şi folosesc o
partiţionare internă în cadrul acelei partiţii. Aceste tipuri de sisteme de operare pot coexista
cu alte sisteme de operare, dar un sistem de operare care nu suportă partiţii nu poate coexista
pe acelaşi hard disc cu alte sisteme de operare.
Schema originală de partiţionare pentru hard discurile de PC-uri admite doar patru
partiţii. Pentru a depăşi această limitare au fost introduse partiţiile extinse. Aceasta este un
truc pentru a permite partiţionarea unei partiţii primare în subpartiţii. O astfel de partiţie
primară, împărţită în subpartiţii se numeşte partiţie extinsă, iar subpartiţiile sunt partiţii
logice. Acestea din urmă se comportă ca şi partiţiile primare, dar sunt create într-un mod
diferit.
Structura de partiţionare a unui hard disc ar putea arăta ca în următoarea figură. Discul
este divizat în trei partiţii primare, a doua partiţie fiind divizată în două partiţii logice. O parte
a discului nu este partiţionată deloc, deci nu este folosită. Discul ca şi întreg şi fiecare partiţie
primară are câte un sector de boot.
- 22 -
Curs de SISTEME DE OPERARE
MBR
Boot sector
Date area
Primary partition of partition
Boot sector
Unused boot sector
Date area
Logical
Extended partition
Unused boot sector
partition
Date area
Logical
Unused boot sector
partition
Boot sector
- 23 -
Curs de SISTEME DE OPERARE
3.4.2 Organizarea logică a discurilor.
A. Sectorul de încărcare.
Primii trei octeţi ai sectorului de încărcare în MS-DOS conţin un salt necondiţionat la
adresa 2Eh, de la această adresă începe de fapt programul încărcător. Începând cu al patrulea
octet al sectorului este înregistrat aici blocul de parametri BIOS.
La sfârşitul sectorului de încărcare, ultimii doi octeţi, există o informaţie specifică
numită semnătură DOS, 55 AAh.
- 24 -
Curs de SISTEME DE OPERARE
B. Tabela de alocare a fişierelor.
Există două structuri pentru FAT :
• tabele FAT în care intrarea are 12 biţi
• tabele în care intrarea are 16 biţi.
Conţinutul unei intrări în FAT este de fapt un număr de grupă. Alocarea spaţiului
pentru fişiere făcându-se la nivel de grupă de sectoare.
Dimensiunea unei grupe este 18 sectoare (se alege în funcţie de capacitatea discului).
Dacă dimensiunea intrării este 12 biţi ⇒ valoarea maximă 0FFFh (4095) ⇒ 4096 de
valori ⇒ putem descrie discuri cu capacitatea 4096 / 2 Kocteţi ≈ 20 Mocteţi.
Dacă dimensiunea intrării este de 16 biţi ⇒ 0FFFFh ⇒ 65535 valori.
Prin numerele de grupă care se înregistrează prin intrările FAT se formează liste
simplu înlănţuite ale grupelor alocate fiecărui fişier. Începutul fiecărei liste este păstrată în
intrarea de catalog a fişierului.
Există valori rezervate ale intrărilor în FAT :
0 - corespunde unei grupe libere.
F peste tot - sfârşit de listă.
(F)FF7 - marchează zone defecte pe disc.
0 1 2 3 4 5 6 7
200 000 206 000 205 000 208 206 800
208 21A 000 000 000 20D FFF 000 000
210 000 000 000 FFF 000 000 000 000
218 000 000 FFF 0 0 0 0 0
Când se şterge un fişier toate intrările FAT corespunzătoare spaţiului marcat de acel
fişier vor fi marcate ca disponibile. Nu e afectat fişierul în zona sa de date. Spaţiul alocat unui
fişier creşte odată cu creşterea dimensiunii fişierului. La crearea unui fişier nu se alocă spaţiu
peste necesarul din acel moment pentru fişier.
C. Catalogul rădăcină.
Fiecare intrare de catalog are lungimea de 32 octeţi, deci un sector de pe disc conţine
16 intrări de catalog (7 sectoare pentru un catalog ⇒ 112 fişiere). În subcataloage,
dimensiunea nu este limitată. Numărul de intrări din catalogul rădăcină este limitat la 256 (16
sectoare). O intrare are 8 câmpuri. Formatul unei intrări de catalog este :
Numele fişierului, dacă este mai scurt de opt caractere, se completează la dreapta cu
blancuri. Între caractere nu sunt recomandate blancuri. Deasemenea nu se recomandă
utilizarea caracterelor ’*’ şi ’?’ ce au o semnificaţie specială pentru interpretorul de comenzi.
Deasemenea caracterul ’.’.
MS-DOS nu face deosebirea între litere mari şi litere mici. În primul octet al câmpului
de nume dintr-o intrare de catalog pot apărea trei combinaţii binare, care au semnificaţie
specială.
00h - că această intrare de catalog nu a fost folosită;
- 25 -
Curs de SISTEME DE OPERARE
E5h - fişierul respectiv a fost şters.
2Eh - se consideră ca şi cod special: punctul ’.’ pentru intrările speciale, şi ’..’,
care există în fiecare subcatalog, ’.’ descrie catalogul însuşi şi al doilea
catalogul părinte.
Prima intrare a catalogului rădăcină este deasemenea rezevată pentru a înregistra
eticheta de volum (care poate fi un şir de maxim 11 caractere).
Extensia se poate completa la dreapta cu blancuri. Combinaţia care se foloseşte ca
extensie dă o anumită informaţie despre conţinutul fişierului.
Octetul de atribute foloseşte fiecare bit din octet pentru a preciza unele caracteristici
ale fişierelor :
Cod hexa Semnificaţie
01 RO (pentru citire)
02 Atributul de fişier ascuns (Nu îl listează comanda DIR)
04 Fişier sistem
08 Descrie eticheta de volum
10 Intrarea subcatalog (este subdirector)
20 Arhivă
40 Rezervat
80 Rezervat
h h m m x x
y y m m d d
7cb 4cb 5cb
În câmpul pentru an 0 119 lună zi
pentru lună 0 12
pentru zi 0 31
Câmpurile de dată şi timp se pot folosi împreună cu un întreg lung fără semn (4 octeţi)
la operaţii de comparare. Pentru fişierele care au fost create fără a avea spaţiu alocat şi
intrarea care descrie eticheta de volum, pentru acest câmp avem 0.
Câmpul pentru dimensiunea fişerului. Valoarea lui corespunde în mod real cu
dimensiunea fişierului. La fişierele create prin editoare de texte se poate întâmpla ca valoarea
înregistrată aici să depăşească valoarea reală, deoarece acestea salvează câte un buffer odată.
Sfârşitul real al fişierului în acest caz va fi identificat prin codul ^Z (1Ah).
D. Zona de date.
Unitatea de alocare este grupa, de obicei alocarea se face la prima grupă disponibilă,
cu toate că se pot aplica algoritmi de selecţie a grupelor astfel încât spaţiul unui fişier să fie
într-o zonă cât mai restrânsă a discului. Dacă un fişier ajunge să fie fragmentat, adică ajunge
să aibă grupe din zone diferite ale discului, se reduc performanţele de transfer, deoarece
creşte numărul de deplasări ale capetelor de citire-scriere.
- 26 -
Curs de SISTEME DE OPERARE
- 27 -
Curs de SISTEME DE OPERARE
fanioane
CS
IP
SP
Fig. 3.5-1
- 28 -
Curs de SISTEME DE OPERARE
Iniţializarea conţinutului tabelei vectorilor de întrerupere se face la încărcarea
sistemului de operare, parţial de rutinele din BIOS şi parţial de rutinele de iniţializare din
IO.SYS şi MSDOS.SYS.
- 29 -
Curs de SISTEME DE OPERARE
3.5.2 Întreruperi BIOS.
Aceste întreruperi sunt generate prin software, cu ajutorul instrucţiunii INT xx, unde
xx este nivelul întreruperii.
Caracteristic tuturor întreruperilor generate prin software este faptul că sunt generate
sincron cu programul în execuţie. Majoritatea au rolul de a apela servicii de sistem aşa încât
întrerupera trebuie să fie însoţită de informaţii încărcate în registre care să precizeze serviciul
dorit şi eventual infomaţii necesare acelui serviciu.
Utilizarea întreruperilor BIOS este următoarea :
• nivelul 10h - serveşte la apelarea serviciilor de ecran, cum ar fi fixarea modului de
lucru, a formei cursorului, afişarea unui caracter, a unui şir, defilarea ecranului etc.
• nivelul 11h - furnizează informaţii despre configuraţia hardware a sistemului.
• nivelul 12h - serveşte pentru obţinerea dimensiunii memoriei
• nivelul 13h - serveşte pentru apelarea serviciilor de lucru la nivel fizic cu discuri :
iniţializare, citirea stării, poziţionări, citiri, scrieri etc.
• nivelul 14h - este prevăzut pentru apelarea serviciilor de lucru cu interfaţa serială :
iniţializare, emisia sau recepţia unui caracter, fixarea regimului de transmisie etc.
• nivelul 15h - acest nivel se foloseşte pentru comanda altor periferice şi pentru
raportarea evenimentelor de intrare/ieşire.
• nivelul 16h - permite realizarea de operaţii asupra tamponului tastaturii.
• nivelul 17h - permite controlul interfeţei paralele, la care de regulă este conectată o
imprimantă.
• nivelul 18h - întrerupere rezervată, folosită pentru declanşarea interpretorului de
BASIC din ROM.
• nivelul 19h - întreruperea pentru încărcarea la cald.
• nivelul 1Ah - întreruperea pentru citirea şi poziţionarea timpului.
• nivelul 1Bh - întreruperea la care se ataşează rutina de tratare a combinaţiei CTRL-
C.
• nivelul 1Ch - întreruperea care se leagă de nivelul 08h şi dă posibilitatea activării
unui program la momente determinate în timp.
• nivelul 1Dh - nu conţine o adresă de rutină, ci conţine o adresă la care se găsesc
parametri pentru iniţializarea ecranului.
• nivelul 1Eh - conţine adresa unui bloc de parametri pentru lucrul cu discurile.
• nivelul 1Fh - conţine adresa tabelei folosită pentru generatorul de caractere pentru
codurile ASCII extinse.
Întreruperile DOS sunt cele cu nivelele 20h ÷ 3Fh. Şi acestea au evoluat faţă de
primele versiuni ale sistemului DOS, prin concentrarea majorităţii serviciilor oferite pe
nivelul 21h. Pe acest nivel sunt prevăzute şi servicii apelabile prin intermediul întreruperilor
BIOS.
Utilizarea întreruperilor DOS este următoarea (vor fi enumerate doar cele mai
folosite):
• nivelul 20h - este întreruperea pentru terminarea programului curent. Generarea
unui astfel de întreruperi face ca execuţia programului să se termine şi controlul să
revină programului care a lansat acel program.
• nivelul 21h - pe acest nivel sunt concentrate funcţiile MS-DOS.
• nivelul 22h - vectorul de pe acest nivel este adresa rutinei care se apelează la
terminarea programului în curs, după un INT 20h sau INT 27h sau după apelarea
unor funcţii sistem (ca de exemplu : 00h, 4Ch şi 31h).
- 30 -
Curs de SISTEME DE OPERARE
• nivelul 23h - conţine adresa la care se transferă controlul pentru combinaţia de taste
CTRL-Break.
• nivelul 24h - este întreruperea de tratare a erorilor critice de intrare-ieşire.
• nivelul 25h - foloseşte pentru citirea de pe disc, localizarea sectoarelor făcându-se
prin adrese DOS.
• nivelul 26h - foloseşte pentru scrierea pe disc, localizarea sectoarelor făcându-se
prin adrese DOS.
• nivelul 27h - întreruperea TSR (Terminate and Stay Resident), se termină execuţia
programului dar nu se eliberează memoria corespunzătoare lui.
• nivelul 2Fh - întreruperea pentru gestionarea proceselor. Acest serviciu este
disponibil numai de la versiunea 3.0 şi permite ca anumite programe ataşate pe acest
nivel să se desfăşoare în paralel cu programele de aplicaţie (de exemplu comanda
print).
În sistemul de operare MS-DOS există două formate de fişiere executabile care sunt
tratate în mod diferit. Identificarea tipului de format executabil se face prin extensia numelui
de fişier (.COM şi .EXE).
programde
Program aplicaţie
.COM
CS:100
PSP
CS:0
S.O.
Fig. 3.6-1
- 31 -
Curs de SISTEME DE OPERARE
Nr. Depl. Lung. Semnificaţie
câmp
1. 00h 2 INT 20h
2. 02h 2 Dimensiunea memoriei (în paragrafe)
3. 04h 1 nefolosit
4. 05h 5 CALL FAR
5. 0Ah 4 Vector INT 22h
6. 0Eh 4 Vector INT 23h
7. 12h 4 Vector INT 24h
8. 16h 2 CS pentru programul apelant (de ex. COMMAND.COM)
9. 18h 20 rezervat
10. 2Ch 2 Pointer spre ambianţă
11. 2Eh 4 Adresa stivei pentru funcţii DOS
12. 32h 30 rezervat
13. 50h 3 INT 21h urmat de RETF
14. 53h 9 rezervat
15. 5Ch 16 FCB1
16. 6Ch 16 FCB2
17. 7Ch 4 rezervat
18. 80h 128 DTA
Tabelul 3.6-1
În câmpul 1 este prevăzută instrucţiunea INT 20h care constituie unul din modurile de
terminare a execuţiei unui program. În program va apare un salt necondiţionat la locaţia
respectivă. O justificare a acestei soluţii ar fi că dacă într-un program care face referiri
externe rămâne o referinţă nerezolvată aceasta ar apărea ca apel la adesa 0.
Câmpul 2 arată câtă memorie este disponibilă pentru program, precizând adresa de
paragraf a sfârşitului memoriei accesibile programului.
Câmpul 4 se foloseşte la apelarea serviciilor DOS din prima versiune (00h ÷ 24h).
În câmpurile 5, 6, 7 se salvează la începutul execuţiei programului vectorii pentru
nivelele de întreruperi indicate (22h, 23h, 24h). Vectorii vor fi instalaţi la sfârşitul execuţiei.
Este posibil ca pe durata programului acesta să folosească alţi vectori pentru nivelele
respective, fără a perturba funcţionarea altor programe.
Câmpul 10 este adresa de segment care indică spre zona în care apar sub formă de
şiruri de caractere variabilele sistem şi valorile lor.
Câmpul 13 conţine instrucţiuni pentru apelarea funcţiilor sistem mai recente.
Câmpurile 15 şi 16 servesc la prelucrarea fişierelor în stilul CP/M.
Câmpul 18, în timpul execuţiei programului acest câmp serveşte ca tampon pentru
operaţiile cu discuri, dacă programul apelează funcţii care necesită un astfel de tampon şi nu
este prevăzută o zonă corespunzătoare în cadrul programului. Înainte de începerea propriuzisă
a programului, aici se găsesc parametrii din linia de comandă sub forma unui şir de caractere.
Se precizează că între parametri nu se găsesc numele programului şi eventualele informaţii de
redirectare ale intrării sau ieşirii.
Programele care se păstrează în fişiere .EXE pot avea orice dimensiune, dar nu putem
lansa în execuţie un program mai lung decât zona disponibilă de memorie RAM.
- 32 -
Curs de SISTEME DE OPERARE
Un fişier cu extensia .EXE constă din două părţi, prima conţine antetul şi tabela de
relocare iar a doua conţine programul propriu-zis şi datele aferente acestuia. Antetul începe
cu primul octet al fişierului. În antet se găsesc informaţii folosite în procesul de încărcare al
programului în memorie.
- 33 -
Curs de SISTEME DE OPERARE
I_OFF I_SEG
Fig. 3.6-2
- 34 -
Curs de SISTEME DE OPERARE
4.1 Generalităţi.
Exemplificare : pentru funcţia 36h, care furnizează spaţiul liber disponibil pe disc
avem:
AH <- 36h - codul serviciului
DL <- id. disc - numărul discului (0 - disc implicit, 1 - A, 2 - B etc.)
La întoarcerea din apel :
AX - conţine numărul de sectoare/cluster sau FFFFh pentru eroare.
BX - numărul de clustere disponibile.
CX - numarul de octeţi/sector.
DX - numărul total de clustere.
mov AH,36h
mov DL,1 ; discul A
int 21h
cmp AX,0FFFFh
je err_rtn ; salt la rutina de tratare a erorii
mov sec_du,AX ; nr. sectoare/cluster
mov avl_du,BX ; nr. clustere disponibile
mov byt_sec,CX ; nr. octeţi/sector
Pentru ca funcţiile DOS să poată fi apelate din limbajul C, există câteva funcţii de
bibliotecă : bdos, bdosptr, int86, int86x, intdos, intdosx, intr, geninterrupt. Prototipul
acestor funcţii se găseşte în dos.h.
Funcţiile intdos, intdosx apelează servicii DOS prin intermediul lui INT 21h. Mai
generale sunt funcţiile int86, int86x (oferă accesul la regiştrii DS şi ES).
Structurile de date care intervin în aceste apeluri (aceste structuri sunt puse în
corespondenţă cu regiştrii microprocesorului) :
- 35 -
Curs de SISTEME DE OPERARE
};
int int86x(int intno, union REGS *in, union REGS *out, struct SREGS *sregs);
- 36 -
Curs de SISTEME DE OPERARE
EXEMPLU :
Se consideră următorul program, care determină spaţiul disponibil pe disc:
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <dos.h>
inregs.h.ah = 0x36;
inregs.h.dl = drive;
int86(0x21, &inregs, &outregs);
if (argc != 2) {
printf("Utilizare : FREE_SP <drive>\n");
exit(1);
}
drive = (int)(toupper(*argv[1]) - 'A' + 1);
if ((space = free_space(drive)) == -1)
printf("Unitate invalida !\n");
else
printf("Spatiul liber pe discul %c: este %ld octeti.\n",
*argv[1], space);
exit(0);
}
- 37 -
Curs de SISTEME DE OPERARE
Diferenţa dintre 45h şi 46h : funcţia 45h este utilă pentru golirea bufferelor (un fel de
flush) cu indicele duplicat se poate forţa închiderea fişierului, astfel golindu-se bufferele
- 38 -
Curs de SISTEME DE OPERARE
DOS. Secvenţa este mai rapidă decât dacă am face acelaşi lucru cu un singur indice close şi
apoi open. Versiunile mai noi ale DOS au o funcţie specială de golire a bufferelor. Funcţia
46h se foloseşe la redirectarea intrărilor şi ieşirilor.
EXEMPLU :
Pentru a exemplifica folosirea funcţiilor pentru gestionarea fişierelor considerăm
următorul exemplu :
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
regs.h.ah = 0x3D;
regs.h.al = 0x00; /* acces in citire */
regs.x.dx = (unsigned)srs;
int86(0x21, ®s, ®s);
if (regs.x.cflag != 0)
return (-1); /* intoarce un cod de eroare */
idsrs = regs.x.ax; /* memoram indicele fisierului sursa */
/* scrierea */
regs.h.ah = 0x40;
regs.x.bx = iddst;
regs.x.cx = nbytes;
regs.x.dx = (unsigned)buffer;
int86(0x21, ®s, ®s);
} while (nbytes == SIZE);
/* cand s-au citit mai putini octeti decat cati s-au precizat */
/* in apel, ciclul se opreste */
/* inchidere fisiere */
regs.h.ah = 0x3E;
regs.x.bx = idsrs;
int86(0x21, ®s, ®s);
regs.h.ah = 0x3E;
regs.x.bx = iddst;
int86(0x21, ®s, ®s);
/* ca valoare de intoarcere dam valoarea indicatorului CARRY */
/* care ne spune cum s-a inchis fisierul destinatie */
return ((int)regs.x.cflag);
}
- 40 -
Curs de SISTEME DE OPERARE
EXEMPLU :
Programul afişează numele catalogului curent de pe o unitate logică specificată.
Dacă nu se specifică, la apelul programului, unitatea logică, se consideră unitatea
implicită. Se lucrează cu modelul de memorie SMALL.
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <dos.h>
- 41 -
Curs de SISTEME DE OPERARE
Următorul program schimbă catalogul curent. În program se va ilustra şi lucrul cu
pointeri FAR.
#include <stdio.h>
#include <dos.h>
int main(void)
{
char far* nume_cat;
union REGS r;
struct SREGS sr;
printf("Introduceti numele noului catalog : ");
gets(buffer);
nume_cat = buffer;
r.h.ah = 0x3B;
r.x.dx = FP_OFF(nume_cat); /* se preia deplasamentul bufferului */
sr.ds = FP_SEG(nume_cat); /* se preia adresa de segment */
int86x(0x21, &r, &r, &sr);
return (0);
}
Fig. 4.2-1
• 0Bh : verificarea stării intrării. Se determină dacă există sau nu un caracter
disponibil la intrare (AL = 00h <=> nu există, AL = FFh <=> există ).
• 0Ch : ştergerea zonei tampon de intrare şi citire de la tastatură. Se curăţă
zona tampon de intrare după care se apelează una din funcţiile de citire
caractere (01h, 06h, 07h, 08h, 0Ah) al cărui cod este introdus în registrul AL.
- 43 -
Curs de SISTEME DE OPERARE
e) Citire în mod bloc.
f) Scriere în mod bloc.
g) ... alte funcţii.
EXEMPLU :
Program care afişează numele şi lungimea tuturor fişierelor normale din catalogul
curent. Deasemenea se mai afişează lungimea totală a acestor fişiere. O formă simplificată
a comenzii DIR.
/*
In zona DTA se respecta urmatoarea conventie :
00h - 14h - rezervati
15h - atributele fisierului
16h - 17h - ora ultimei modificari
18h - 19h - data ultimei modificari
1Ah - 1Dh - lungimea fisierului
1Eh - 2Bh - numele si extensia fisierului
*/
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <dos.h>
int gata;
char ndta[256];
char *dta;
void main(void)
{
long total = 0L;
long *dim;
set_dta(ndta);
get_dta();
printf(“Adresa DTA este %p\n”, dta);
dim = (long*)(ndta + 0x1A);
gata = find_first(tipar);
while (!gata) {
total += (*dim);
gata = find_next();
}
printf(“Lungimea totala fisiere = %ld\n”, total);
}
int find_next(void)
{
union REGS r;
r.h.ah = 0x4F;
int86(0x21, &r, &r);
printf(“%-20s %ld\n”, (ndta + 0x1E), *(long*)(ndta + 0x1A));
return (r.x.ax == 18);
}
void get_dta(void)
{
union REGS r;
r.h.ah = 0x2F;
int86(0x21, &r, &r);
dta = (char*)r.x.bx;
}
- 45 -
Curs de SISTEME DE OPERARE
• 58h : citirea/poziţionarea strategiei de alocare a memoriei. Se poate face
alocare de tipul First Fit (ceea ce înseamnă prima potrivire), Best Fit (se
examinează toată lista şi se alocă blocul cel mai mic care satisface cerinţele),
Last Fit (se parcurge lista şi se alocă ultima potrivire). Prin conţinutul
registrului AL se alege citirea (00h) sau poziţionarea (01h), iar în BX se va
găsi/transmite strategia (00h, 01h, 02h).
• 4Bh : încărcarea şi executarea unui program. Permite ca programul apelant
să încarce în memorie un alt program (AL = 03h) şi eventual să-l lanseze în
execuţie (AL = 00h). Numele fişierului executabil care conţine programul ce
va fi încărcat se precizează printr-un şir ASCIIZ a cărui adresă se încarcă în
DS:DX. Tot ca parametru de intrare în registrele ES:BX se introduce un
pointer la un bloc de parametri care se vor transmite noului program. Acest
bloc de parametri are o structură diferită după cum se cere lansarea în
execuţie sau numai încărcare.
Pentru încărcare :
- 46 -
Curs de SISTEME DE OPERARE
• 62h : obţinerea adresei PSP. Adresa de segment se întoarce în BX.
• 31h : realizează revenirea în procesul părinte în aşa fel încât programul care
a apelat funcţia să-şi reţină o anumită zonă de memorie. Dimensiunea
memoriei rezidente trebuie introdusă în registrul DX (în paragrafe). Se poate
transmite şi un cod de retur prin AL. Fişierele deschise de program nu se
închid implicit. Spre deosebire de întreruperea 27h, prin această funcţie se
pot reţine zone de memorie de peste 64K.
EXEMPLU :
Utilizarea funcţiilor de gestiune a proceselor şi memoriei se ilustrează printr-un
exemplu care constă din două programe. Primul PARENT.C şi al doilea CHILD.C.
/*
Programul PARENT.C va solicita introducerea de la tastatură a numelui unui fişier
executabil (forma executabilă a lui CHILD.C) pe care îl lansează în execuţie prin
funcţia 4Bh. Programul citeşte şi afişează codul de retur furnizat la terminare de
programul lansat în execuţie.
*/
#include <stdio.h>
#include <dos.h>
void main(void)
{
char far*numefis, far*bloc;
union REGS r;
struct SREGS sr;
printf("Dati numele programului fiu : ");
gets(tampon);
numefis = tampon;
bloc = param;
r.h.ah = 0x4B; /* Lansare in executie a unui proces */
r.h.al = 0x00; /* Incarcare si lansare in executie */
r.x.dx = FP_OFF(numefis);
sr.ds = FP_SEG(numefis);
r.x.bx = FP_OFF(bloc);
sr.es = FP_SEG(bloc);
int86x(0x21, &r, &r, &sr);
if (!r.x.cflag) {
printf("Terminare normala !\n");
- 47 -
Curs de SISTEME DE OPERARE
r.h.ah = 0x4D;
int86(0x21, &r, &r);
printf("Codul de intoarcere este : %X\n", r.h.al);
}
else printf("Terminare anormala, %s !\n",
(r.x.ax <= 11) ? errmsg[r.x.ax] : errmsg[0]);
}
/*
Programul CHILD.C va anunţa intrarea sa în execuţie printr-un mesaj, după care
alocă mai multă memorie, dacă poate, prin 48h şi se termină prin apelul funcţiei exit
(4Ch).
*/
#include <stdio.h>
#include <dos.h>
void main(void)
{
union REGS r;
printf("Hello, I'm the child !\nI need more memory !\n");
r.h.ah = 0x48;
r.x.bx = 200;
int86(0x21, &r, &r);
if (r.x.cflag)
printf("Not enough memory, AX = %x, BX = %x\n", r.x.ax, r.x.bx);
else
printf("The allocated memory starts at : %x\n", r.x.ax);
r.h.ah = 0x4c;
r.h.al = 0x5A;
printf("Tnto thy hands I deliver my soul.\n");
int86(0x21, &r, &r);
}
- 49 -
Curs de SISTEME DE OPERARE
Se pot citi până la 64K printr-o singură operaţie. La revenire funcţia returnează
numărul de octeţi citiţi. Dacă a apărut o eroare se returnează -1.
Pentru fiecare dintre aceste 5 funcţii există şi funcţia fără liniuţă, compatibile UNIX,
diferenţa apare ca şi comportare la open, care corespunzând UNIX-ului permite o comportare
diferită la citire, după cum fişierul este deschis în mod text sau în mod binar. Mai există şi
funcţii de bibliotecă echivalente cu apeluri sistem DOS care nu conţin liniuţa :
- 50 -
Curs de SISTEME DE OPERARE
Returnează 0 pentru succes şi -1 pentru eroare. Ca şi pentru crearea unui fişier, se
presupune că toate numele de cale există, altfel în errno se returnează codul de eroare
corespunzător.
Returnează 0 când este succes. În câmpul ff_name se gaseşte numele fişierului care
satisface acest tipar. La eroare returnează -1, cu semnificaţia ENOFILE (nu s-a găsit nici un
fişier corespunzător tiparului dat).
EXEMPLU :
Dacă folosim funcţii de bibliotecă putem obţine o formă de dir astfel :
#include <stdio.h>
#include <dir.h>
void main(void)
{
long total = 0L;
int gata;
struct ffblk fb;
char *tipar = "*.*";
gata = findfirst(tipar, &fb, 0);
while (!gata)
{
total += fb.ff_size;
printf("%-20s %ld\n", fb.ff_name, fb.ff_fsize);
gata = findnext(&fb);
}
printf("Lungimea totala a fisierelor : %ld\n", total);
}
int getdisk(void);
char* getdta(void);
- 52 -
Curs de SISTEME DE OPERARE
5. Obţinerea informaţiilor despre FAT pentru unitatea curentă (1Bh)
struct fatinfo {
char fi_sclus; /* număr de sectoare pe cluster */
char fi_fatid; /* octetul de identificare FAT */
int fi_nclus; /* număr de clustere al unităţii */
int fi_bysec; /* dimensiunea în octeţi a sectorului */
};
EXEMPLU :
Programul afişează informaţii despre FAT.
#include <stdio.h>
#include <dir.h>
#include <dos.h>
int main(void)
{
struct fatinfo info;
getfatd(&info);
printf("Informatii FAT pentru discul implicit (%c:)\n", 'A' + getdisk());
printf("Sectoare pe cluster : %5d\n", info.fi_sclus);
printf("Identificator FAT : %5X\n", info.fi_fatid);
printf("Numar de clustere : %5u\n", info.fi_nclus);
printf("Octeti pe sector : %5d\n", info.fi_bysec);
return 0;
}
struct dfree {
unsigned df_avail; /* număr de clustere disponibile */
unsigned df_total; /* număr total de clustere */
unsigned df_bsec; /* număr de octeţi / sector */
unsigned df_sclus; /* număr de sectoare / cluster */
};
- 53 -
Curs de SISTEME DE OPERARE
EXEMPLU :
Programul afişează spaţiul liber pe discul curent.
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <dir.h>
int main(void)
{
struct dfree free;
long avail;
int drive;
drive = getdisk();
getdfree(drive+1, &free);
if (free.df_sclus == 0xFFFF)
{
printf("Eroare getdfree()\n");
exit(1);
}
avail = (long)free.df_avail * (long)free.df_sclus * (long)free.df_bsec;
printf("Discul %c: contine %ld octeti disponibili.\n", 'A'+drive, avail);
}
EXEMPLU :
Programul comută modul de lucru al ecranului din stilul RAM (caracterele de
control afişate fără interpretare) în COOKED (se interpretează caracterele de control,
aceasta fiind modul normal de lucru). În modul RAM creşte foarte mult viteza de afişare
pe ecran.
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <io.h>
if (argc < 2) {
printf("Utilizare : RAMCOOK COOKED | RAW\n");
- 54 -
Curs de SISTEME DE OPERARE
exit(1);
}
if (!stricmp(argv[1], "RAW"))
rawmode = 1;
else
if (!stricmp(argv[1], "COOKED"))
rawmode = 0;
else {
printf("Mod necunoscut : %s\n", argv[1]);
exit(2);
}
/* citire informatie */
func = 0;
ioctl(handle, func, &argdx);
if (rawmode)
argdx |= RAW_BIT;
else
argdx &= ~RAW_BIT;
func = 1;
ioctl(handle, func, &argdx);
return 0;
}
EXEMPLU :
Programul demonstrează folosirea funcţiilor amintite. În program se mai foloseşte
funcţia movedata care copiază o zonă de memorie într-o altă zonă de memorie.
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
#include <mem.h>
#define DOS_PRTSTR 9
int main(void)
{
union REGS r;
struct SREGS sr;
char far *stradd;
unsigned segadd, maxsize;
unsigned getpsp(void);
Prototipul funcţiei se găseşte în dos.h. Este util pentru citirea şirurilor de ambianţă (de
exemplu PATH-ul). Valoarea returnată reprezintă adresa de segment al PSP. Trebuie să
cunoaştem deplasamentul pentru a afla datele din PSP.
- 56 -
Curs de SISTEME DE OPERARE
EXEMPLU :
Program care afişează spaţiul ocupat de el însuşi.
#include <stdio.h>
#include <dos.h>
int main(void)
{
unsigned mypsp, lastseg;
long mem_allocated;
mypsp = getpsp();
printf("PSP incepe la %04X:0000\n", mypsp);
lastseg = *((unsigned far*)(MK_FP(mypsp, 2)));
printf("Sfarsitul memoriei alocate este la %04X:0000\n", lastseg);
mem_allocated = 16 * (long) (lastseg - mypsp);
printf("%ld octeti alocati programului.\n", mem_allocated);
return 0;
}
Prototipul funcţiei se găseşte în stdlib.h sau process.h. Închide toate fişierele aferente
programului. La ambele funcţii status este codul de întoarcere pentru procesul părinte.
Prototipul funcţiei se găseşte în stdlib.h sau process.h. cmd reprezintă comanda DOS
care va fi executată. Se citeşte variabila COMSPEC pentru a localiza COMMAND.COM-ul şi
se transmite argumentul cmd. Pentru execuţia acestei comenzi, dacă este nevoie, se
inspectează şi variabila PATH. COMMAND.COM se lansează cu o singură comandă după
execuţia căreia se revine.
Dacă cmd este şirul vid se face doar verificarea faptului că există COMMAND.COM.
Dacă şirul este vid şi nu se găseşte COMMAND.COM atunci se returnează 0, altfel se
- 57 -
Curs de SISTEME DE OPERARE
returnează o valoare diferită de 0. Dacă şirul nu este vid se returnează 0 pentru execuţie
normală şi -1 pentru eşec.
EXEMPLU :
Programul următor lansează în execuţie o comandă.
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int main(void)
{
char command[128];
while (1)
{
printf("Tastati o comanda (\"quit\" pentru iesire) : ");
gets(command);
strlwr(command); /* conversie la litere mici */
if (strcmp(command, "quit") == 0)
exit(0);
if (system(command) == -1)
perror("Eroare system()");
}
}
mode reprezintă modul de execuţie al lui spawn, modul cum trebuie tratat procesul
părinte. Valorile pe care le poate primi acest parametru sunt :
• P_WAIT - procesul părinte rămâne în aşteptare până la terminarea
procesului fiu.
• P_OVERLAY - programul procesului fiu se suprapune peste programul
procesului părinte în memorie.
• P_NOWAIT - procesul părinte îşi continuă execuţia în paralel cu procesul
fiu (această formă nu este implementată în S.O. MS-DOS).
path reprezintă numele de cale al fişierului de executat.
arg0, arg1, ... reprezintă argumentele din linia de comandă pentru procesul fiu (arg0
trebuie să fie identic cu path).
argv[] reprezintă argumentele din linia de comandă pentru procesul fiu.
envp[] reprezintă tabloul cu parametri de mediu.
Obs:
1. Este obligatoriu ca funcţiile spawn să transmită cel puţin un argument
procesului fiu, adică cel puţin numele fişierului care conţine codul procesului.
2. Lungimea combinată a tuturor şirurilor folosite ca argumente în linia
de comandă, dacă este vorba de listă |arg0| + |arg1| + ... + |argn| sau dacă este tablou
|arg[0]| + |arg[1]| + ... + |arg[n]| nu poate depăşi 128 octeţi.
3. Fişierele care au fost deschise în procesul părinte rămân deschise şi
pentru procesul fiu.
4. Valoarea de revenire din procesul fiu are semnificaţie numai dacă
mode este P_WAIT, dacă este P_OVERLAY atunci starea de revenire din procesul
fiu va lua locul stării de revenire a procesului părinte.
În caz că nu se poate lansa în execuţie procesul fiu, atunci se returnează -1, iar pentru
variabila globală errno pot exista următoarele situaţii :
• E2BIG, aceasta însemnând că lungimea totală a argumentelor depăşeşte 128 octeţi,
sau că memoria necesară pentru variabilele de mediu ar depăşi 32K.
• EINVAL, aceasta înseamnă că pentru mode s-a folosit o valoare invalidă (de
exemplu P_NOWAIT).
• ENOENT, arată că nu se poate găsi fişierul cu cod executabil. Fie că nu există acel
fişier, fie că numele de cale este invalid.
• ENOEXEC, arată că fişierul zis de cod nu este de fapt executabil.
• ENOMEM, arată că nu există memorie suficientă pentru încărcarea şi execuţia
procesului fiu (programul este prea mare).
Aceste funcţii sunt utile dacă vrem să lansăm în execuţie, din cadrul unui program, un
alt program, care a fost compilat şi linkeditat separat. Între cele două programe (părinte şi fiu)
se pot folosi în comun zone de memorie, rezultând o funcţionare asemănătoare cu a
programelor rezidente (TSR).
EXEMPLU:
Se ilustrează utilizarea acestor funcţii prin două programe : PARENT.C şi
CHILD.C. Programul PARENT.C lansează în execuţie programul CHILD.C întrebând
utilizatorul care din variantele de spawn doreşte să le folosească. Înainte de lansarea în
execuţie a fiului se pregăteşte în PARENT.C o structură de date care se va transmite
procesului fiu prin codificarea adresei acestei structuri ca şir de caractere ce va figura ca
unul dintre argumentele din linia de comandă. În procesul fiu se vor tipări argumentele
din linia de comandă şi ambianţa transmisă. Se converteşte apoi adresa transmisă ca şir de
caractere şi se face acces la structură. Se modifică în continuare diverse câmpuri ale
structurii şi se termină programul fiu. La revenirea în programul părinte se tipăresc din
nou valorile din structura de date comună pentru a verifica dacă s-au produs modificările
executate în procesul fiu. Cele două programe vor fi în fişiere separate care se compilează
şi se linkeditează separat.
/* Fisierul PARENT.C */
#include <process.h>
#include <string.h>
#include <stdio.h>
- 59 -
Curs de SISTEME DE OPERARE
#include <alloc.h>
/* Construim o ambianta */
char *envp[] = { /* declaram acest tablou de pointeri spre */
/* siruri de caractere in care initializam */
/* o singura variabila de mediu */
"PARENT=SPAWN FUNCTIONS",
NULL
};
void main(void)
{
char *nargv[4]; /* tabloul in care se construiesc argumentele */
char buff[20]; /* tabloul de lucru pentru dialog cu utilizatorii */
char fname[40]; /* si altul pentru conversii */
TEST_DATA *pdata;
/* Fisierul CHILD.C */
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <dos.h>
Prototipurile acestor funcţii se găsesc în fişierul antet process.h. Într-un anumit sens
acestea sunt asemănătoare cu familia de funcţii spawn la care mode este pe P_OVERLAY.
În MS-DOS utilizarea funcţiilor exec este recomandabilă în aplicaţii care presupun
înlănţuirea unor programe. În caz de eşec de lansare în execuţie şi funcţiile exec returnează
-1, iar în variabila globală errno se obţin detalii despre natura erorii. Pot apărea aceleaşi erori
ca şi la spawn, mai puţin EINVAL, care era legat de argumentul mode. În plus mai pote
apărea ENFILE, dacă sunt prea multe fişiere deschise, respectiv EACCESS, dacă un fişier
specificat în PATH este blocat, sau nu este protejabil (la MS-DOS versiunile mai mari decât
3.3).
void abort(void);
Prototipul acestei funcţii se găseşte în fişierul antet stdlib.h sau process.h. Această
funcţie determină afişarea unui mesaj de eroare : "Abnormal program termination", după care
în funcţia respectivă este prevăzut un apel la funcţia exit() şi se dă codul de retur 3.
struct date {
int da_year; /* anul dat în formă binară (deja convertită +1980) */
char da_day; /* ziua 1 ÷ 31 */
char da_month; /* luna 1 ÷ 12 */
};
struct time {
unsigned char ti_min;
unsigned char ti_hour;
unsigned char ti_hund;
unsigned char ti_sec;
};
EXEMPLU :
În continuare se prezintă un program în care se folosesc funcţiile getvect, setvect şi
de asemenea funcţia keep (folosită pentru a realiza programe rezidente). Programul
instalează o rutină de tratare a întreruperii pe nivelul 1Ch, aceasta va incrementa un
contor modulo 10 şi va afişa la fiecare întrerupere de timp valoarea contorului respectiv.
#include <dos.h>
count++;
count %= 10;
screen[0][79] = count + '0' + ATTR;
oldhandler();
}
int main(void)
{
oldhandler = getvect(INTR);
setvect(INTR, handler);
/* se calculeaza dimensiunea pentru programul rezident */
/* _psp - este variabila globala in care se gaseste */
/* adresa prefixului segmentului de program PSP */
/* _SS - corespunde registrului de segment SS */
/* _SP - corespunde registrului pointer de stiva SP */
keep(0, (_SS + (_SP + SAFETY) / 16 - _psp));
return 0;
}
- 64 -
Curs de SISTEME DE OPERARE
5. Gestionarea memoriei
Un bloc din memoria superioară (UMB) este o zonă RAM din memoria superioară
care este disponibilă programelor. Zona de memorie superioară (adresele A000:0000 ÷
FFFF:0000) este rezervată în principal pentru memorii ROM şi dispozitive mapate în
- 65 -
Curs de SISTEME DE OPERARE
memorie, dar MS-DOS poate mapa RAM la orice adresă din această zonă, care nu este
utilizată de ROM sau alte dispozitive.
Un program poate aloca un bloc de memorie superioară utilizând funcţia de alocare a
memoriei. Înainte de a aloca memorie, trebuie ca programul să seteze o strategie de alocare
potrivită şi să facă legătura cu zona de memorie superioară. Ca şi la memoria convenţională,
un program foloseşte pentru funcţia de stabilire a strategiei de alocare funcţia 5801h. O
strategie de alocare ca de exemplu FIRST_FIT_HIGH (0080h) determină ca funcţia de
alocare să caute memoria superioară şi să continue cu căutarea în memoria convenţională,
dacă nu a găsit bloc disponibil.
Funcţia de alocare nu poate căuta în memoria superioară doar dacă aceasta este legată
de restul memoriei sistem. Un program poate stabili legarea memoriei superioare prin
folosirea funcţiei de stabilire a legăturii cu memoria superioară (5803h), sau poate determina
dacă această legătură există folosind citirea stării legăturii cu memoria superioară (Funcţia
5802h).
Obs. Dacă un program schimbă legătura cu memoria superioară el ar trebui să salveze
starea anterioară şi să o refacă înainte de terminare.
Un program poate utiliza funcţia de eliberare a memoriei şi pentru eliberarea
blocurilor din memoria superioară. Deasemenea poate utiliza şi funcţia de redimensionare a
blocurilor pentru a reduce sau mări dimensiunea blocului alocat.
Dacă un program a fost lansat folosind comanda LOADHIGH, sistemul încarcă acel
program în memorie alocată din zona de memorie superioară. Deşi un program poate fi în
memoria superioară, memoria pe care o alocă depinde de strategia de alocare.
Blocurile de memorie superioară nu sunt accesibile prin funcţii MS-DOS doar dacă
comanda dos = umb este inclusă în fişierul CONFIG.SYS şi driverul HIMEM.SYS şi
software-ul de gestionare a memoriei, de ex. EMM386.EXE sunt încărcate. Dacă dos = umb
nu este specificat în CONFIG.SYS, dar software-ul de gestionarea memoriei este încărcat,
programele pot accesa zona de memorie suprioară folosind apeluri directe la software-ul de
gestionare a memoriei.
MS-DOS-ul ţine evidenţa blocurilor de memorie prin crearea unei liste înlănţuite de
structuri ARENA, care definesc dimensiunea şi proprietarul blocurilor de memorie.
ARENA STRUC
arenaSignature db ? ;4dh=valid, 5ah=ultim
arenaOwner dw ? ;proprietarul acestui bloc
arenaSize dw ? ;dimensiunea blocului în paragrafe
arenaReserveddb 3 dup(?) ;rezervat
arenaName db 8 dup(?) ;numele de fişier al proprietarului
ARENA ENDS
Comentarii :
Fiecare structră ARENA este urmată imediat de un bloc continuu de memorie.
Următoarea structură ARENA din listă este în continuarea respectivului bloc. Aceasta
înseamnă că adresa segment a următoarei structuri din listă este egală cu adresa de segment a
blocului de memorie curent plus dimensiunea sa.
MS-DOS-ul completează câmpul arenaName pentru un bloc când încarcă un program
în acest bloc. Structurile ARENA pentru memoria alocată de programe prin funcţia de alocare
nu sunt completate în acelaşi fel.
Pentru calculatoarele bazate pe procesoare 80286, 80386 şi mai recente, cea de-a 21
linie de adresă a procesorului (A20) controlează accesul la un spaţiu suplimentar de 64K,
numit zonă de memorie înaltă (HMA). Producătorii de calculatoare de obicei includ un circuit
pentru a dezactiva linia A20 când procesorul rulează în mod real. Acesta asigură ca mediul de
operare să fie identic cu acela al unui 8086, în care adresele ca şi FFFF:0010 se suprapun
peste începutul memoriei. Când linia A20 este activă, adresele care s-ar repeta (adresele în
intervalul FFFF:0010 ÷ FFFF:FFFF) asigură accesul la HMA.
Dacă un calculator oferă suport RAM pentru HMA, atunci MS-DOS poate activa linia
A20 şi să realoce codul sistem în HMA, astfel eliberând memoria convenţională pentru alte
programe. MS-DOS-ul se relocatează în HMA doar dacă comanda dos=high este în
CONFIG.SYS iar HIMEM.SYS este încărcat. Acest driver conţine codul care permite
activarea şi dezactivarea liniei A20.
Pentru a suporta programele care se aşteaptă ca adresele să se repete, MS-DOS-ul
dezactivează linia A20 întotdeauna când încarcă şi execută un program. În timp ce linia A20
este dezactivată, partea MS-DOS din HMA nu este accesibilă direct, deşi programele pot
totuşi să apeleze funcţii sistem MS-DOS. Pentru a realiza acest lucru, MS-DOS-ul
redirectează toate apelurile sistem la un “stub” din memoria convenţională, care activează
linia A20 şi face salt la funcţia MS-DOS solicitată. Odată activată, linia A20 rămîne activată
chiar după ce se revine din apelul funcţiei sistem.
Programele nu trebuie să folosească HMA dacă MS-DOS-ul a fost realocat aici. Un
program poate determina dacă MS-DOS-ul este sau nu în HMA folosind funcţia care întoarce
- 67 -
Curs de SISTEME DE OPERARE
versiunea MS-DOS-ului. Această funcţie setează bitul 4 din registrul DH dacă MS-DOS-ul
este în HMA.
- 68 -
Curs de SISTEME DE OPERARE
6.1 Introducere.
- 69 -
Curs de SISTEME DE OPERARE
UNIX - 1969
Versiunea 3 -1973
Versiunea 6 -1975
1986 1986
SunOS 4.0 S.O. Mach
1988
1988
NeXT
SystemV Rel. 4.0
multiprocessor
1989
AIX IBM
1990
SCO ODT Rel. 1.1
Fig. 6.1-1
- 70 -
Curs de SISTEME DE OPERARE
• transportabilitatea fişierelor între diverse sisteme de calcul, menţinând identică
structura volumelor şi fişierelor;
• asigurarea unor niveluri superioare de portabilitate a produselor program;
• folosirea unei game largi de arhitecturi de calcul, prin interconectarea
calculatoarelor de tipuri şi puteri diferite, funcţionând sub acelaşi sistem de operare;
• transparenţa produselor software faţă de evoluţia hardware-ului.
Printre caracteristicile generale ale S.O. UNIX care au contribuit la succesul acestui
sistem de operare, putem menţiona :
• UNIX este un sistem de operare de tip time-sharing, multitasking şi multiutilizator;
• Este asigurată protecţia fişierelor şi a modului de execuţie prin existenţa unor parole
şi drepturi de acces;
• S.O. promovează modularitatea;
• Operaţiile de intrare/ieşire sunt integrate în sistemul de fişiere, realizându-se aşa
numitele intrări/ieşiri generalizate;
• Există un sistem de gestiune a proceselor reentrante şi asincrone multiple, care se
pot sincroniza prin intermediul unui sistem de întreruperi logice;
• Gestiunea memoriei se face printr-un mecanism ce permite schimbul de pagini între
memoria RAM şi cea externă, gestionându-se spaţiul afectat execuţiei proceselor şi
controlându-se timpul de acces la procesele în aşteptare;
• S-a realizat o interfaţă simplă prin intermediul componentei SHELL, care nu este
integrată în nucleul (KERNEL) sistemului de operare, asigurându-se totodată o
identitate a sintaxei tuturor comenzilor;
• Prin scrierea S.O. în limbajul C, s-a obţinut o portabilitate atât a sistemului UNIX
propriu-zis, cât şi a software-ului de aplicaţie dezvoltat sub acest sistem, realizându-
se astfel şi premisele dezideratului de sistem deschis. Sub aceste S.O. se pot astfel
dezvolta pachete de programe funcţionale pe o gamă largă de maşini.
- 71 -
Curs de SISTEME DE OPERARE
acesta este singurul proces care nu este creat prin mecanismul uzual de duplicare
(fork()). Controlul este preluat de init, care continuă activităţile legate de lansarea
sistemului. La sfârşitul acestei etape iniţializarea nucleului a luat sfârşit, sistemul
funcţionând normal, unicul proces utilizator prezent fiind init, care rulează cu
privilegiile superutilizatorului.
• init lansează un interpretor de comenzi (/bin/sh de exemplu), căruia îi revine
sarcina citirii şi executării fişierului de comenzi indirecte de configurare /etc/rc,
care conţine comenzi care asigură:
1. verificarea (cu ajutorul comenzii fsck) a corectitudinii sistemului de
fişiere rădăcină, şi eventual corectarea automată a eventualelor erori minore.
Dacă fsck eşuează, atunci un interpretor de comenzi este lansat cu intenţia ca
operatorul să refacă manual consistenţa sistemului de fişiere. În acest timp
sistemul lucrează şi operatorul primeşte privilegiile superutilizatorului;
2. montarea (cu ajutorul comenzii mount) a celorlalte discuri din
configuraţie;
3. iniţializarea altor echipamente periferice (interfeţe de reţea de
exemplu);
4. lansarea în fundal a unui număr de procese (demoni). De exemplu,
sistemele din familia BSD lansează demonul inetd, destinat lansării automate
a proceselor înregistrate ca servicii la distanţă (ftp, rlogin etc.).
• init creează (prin duplicare) câte un proces getty pentru fiecare terminal. Fiecare
getty aşteaptă introducerea unui nume de utilizator la terminalul respectiv, afişând
un prompt (de exemplu login:); această condiţie fiind satisfăcută, getty se
transformă în login, pentru a accepta utilizatorul în sistem.
Uneori ultimele două etape se desfăşoară în paralel; procesele lansate de init în ultima
etapă pot fi sau înscrise în codul binar al lui init, sau listate într-un fişier destinat acestui scop,
în general /etc/inittab. Toate aceste activităţi fiind îndeplinite, init (procesul 1) trece în
aşteptare. Din această stare el va ieşi temporar la semnalarea morţii unui interpretor de
comenzi principal.
Procesul login asociat terminalului în cauză, afişează un al doilea prompt (de exemplu
password:) şi aşteaptă introducerea unei parole. Parola citită este cifrată, apoi login caută
perechea (nume_utilizator, parolă_cifrată) în fişierul /etc/passwd. Dacă este găsită perechea
respectivă, atunci din acelaşi /etc/passwd se citesc :
• numărul de utilizator (uid-ul) utilizatorului şi numărul grupului (gid-ul) din care
face parte. login, care până acum rulase cu privilegiile superutilizatorului, îşi
schimbă apartenenţa, de acum înainte rulând sub uid-ul şi gid-ul utilizatorului în
curs de acceptare.
• catalogul de referinţă al utilizatorului. login schimbă catalogul curent în catalogul de
referinţă al utilizatorului. Dacă schimbarea nu reuşeşte, catalogul curent este stabilit
în catalogul rădăcină.
• numele interpretorului de comenzi (de exemplu /bin/sh sau /bin/bash).
Forma cea mai simplă : $ ls <CR>, $ fiind proptul pentru utilizatori, furnizează o listă
a numelor fişierelor şi cataloagelor din catalogul curent, mai puţin acele cataloage şi fişiere
ale căror nume începe cu caracterul '.', considerate invizibile (. şi .. în primul rând).
Opţiuni :
- 73 -
Curs de SISTEME DE OPERARE
2. Copiere de fişiere.
Efectul acestei comenzi este copierea fişierului sursă (unul) în fişierul destinaţie ($ cp
fis1 fis2) sau copierea mai multor fişiere sursă într-un catalog ($ cp fis1 fis2 fis3 dir)
În unele implementări se admite opţiunea -R pentru o copiere recursivă de cataloage.
4. Transferarea unui fişier dintr-un bloc în altul (echivalent rename din MS-DOS).
Obs.: La cp se alocă noi noduri index şi noi blocuri. La mv se schimbă doar intrarea
de catalog.
rm [-optiuni] fis
6. Ştergerea cataloagelor.
rmdir catalog
Ex:
$ chmod 644 fis.txt
- proprietarul fişierului va avea drepturile rw
- drepturile sunt specificate prin cifre octale, corespunzătoare celor 3 biţi care codifică
drepturile pe categorii.
cd catalog
pwd
mkdir catalog
whoami
- 75 -
Curs de SISTEME DE OPERARE
13. Listarea tuturor utilizatorilor care au momentan sesiuni deschise.
who
date
15. Afişarea spaţiului liber pe fiecare dintre discurile montate sau specifiacte.
df [fisier_special]
Obs.: mount fără nici un argument afişează lista sistemelor de fişiere montate precum
şi locul în care acestea au fost montate.
umount nume
nume poate fi numele fişierului special care conţine un subsistem de fişiere sau
catalogul unde a fost montat acel subsistem de fişiere.
banner text
man comanda
Ex: $ man df
more
- 76 -
Curs de SISTEME DE OPERARE
22. Un alt paginator mai puternic.
less
mail nume
Ex:
$ mail xxxx
Subject : Hello
Textul mesajului
.
$
Obs.: Mesajul se termină cu caracterul '.' singur pe o linie, la începutul liniei.
login nume
Obs.: Dacă utilizatorul nume are parolă se va cere şi parola (Password :).
logout
passwd
Ori de câte ori se dă o comandă din linia de comandă, aceasta este preluată de un
program numit shell, care examinează linia şi decide care program trebuie rulat pentru a
executa comanda şi ce argumente îi vor fi transmise.
Procesorul de comenzi standard este sh (Bourne Shell). Alte procesoare de comenzi :
csh (C Shell), ksh (Khorn Shell), bash (Bourne Again Shell) etc.
Procesorul implicit pentru un utilizator este specificat în descrierea sistem a
utilizatorului, adică în fişierul /etc/passwd având următoarea structură :
Întotdeauna când shell-ul este gata pentru a primi o comandă, el afişează un prompt
care este de obicei de forma : "$ " sau "% ", dar poate fi orice expresie.
În general toate comenzile au ca efect execuţia unor programe. Programele pot fi
programe standard sau pot alte programe. Numele programului care va fi rulat este dat de
primul cuvânt din linia de comandă.
- 77 -
Curs de SISTEME DE OPERARE
Numele programului poate fi specificat cu tot cu cale (/bin/cat) sau doar simplu
numele, în acest caz shell-ul va căuta programul într-o serie de directoare, serie numită
PATH. Pe cele mai multe sisteme PATH-ul va consta din cel puţin trei directoare : directorul
curent("."), şi cele două directoare sistem /bin şi /usr/bin.
Caracterele "*", "?" şi "[...]" sunt caractere care se folosesc pentru construcţia unor
tipare. Când unul din aceste caractere este întâlnit în linia de comandă, este înlocuit cu o listă
de nume de fişiere care se potrivesc cu tiparul din care face parte, urmând următoarele reguli :
* este înlocuit de zero sau mai multe caractere.
? este înlocuit cu un singur caracter.
[sir] se potriveşte cu orice caracter care este prezent în sir. Se permit şi specificarea
unor intervale : [a-z].
Excepţie de la aceste reguli sunt caracterele "/" şi ".", care nu pot fi substituite prin
aceste caractere.
În plus faţă de aceste redirectări simple există şi alte tipuri de redirectare, dintre care
cele mai folosite sunt :
>> fisier - adaugă ieşirea standard la sfârşitul fişierului specificat (dacă fişierul
nu există acesta va creat).
<<terminator - foloseşte următoarele linii ca şi intrare standard, până când se
întâlneşte linia care se potriveşte cu tterminator-ul dat. Aceasta este
folosită în fişiere de comenzi (shell scripts).
2>fisier - redirectează ieşirea de eroare standard în fişierul specificat. Aceasta
este defapt un caz special al cazului general de redirectare a unui
identificator de fişier (stderr == 2).
- 78 -
Curs de SISTEME DE OPERARE
O altă formă de redirectare este folosirea canalelor (pipelines). Într-un canal două sau
mai multe programe sunt executate împreună, ieşirea unuia fiind intrarea următorului. În
multe implementări ale UNIX-ului, programele dintr-un canal sunt executate concurent (în
paralel). Principalul avantaj pentru utilizator este că acesta permite o notaţie concisă a unei
operaţii care pe alte sisteme ar necesita fişiere temporare.
Ex:
$ ls -l > fistemp1
$ grep *.c < fistemp1 > fistemp2
$ wc -l < fistemp2
După cum rezultă din exemplul de mai sus simbolul pentru crearea unui canal este o
bară verticală "|".
Motivul pentru care canalele sunt atât de folositoare este că există multe utilitare
UNIX, cunoscute ca fiind filtre, care primesc un şir la intrare, îl prelucrează şi transmit şirul
rezultat la ieşire (Astfel de utilitare sunt grep - caută apariţia unor expresii în diferite fişiere,
şi wc - care în principiu contorizează caracterele dintr-un fişier).
Din cele prezentate până acum a reieşit faptul că sistemul UNIX este capabil de a
executa concurent mai multe lucrări, el poate gestiona simultan mai mulţi utilizatori, poate
rula mai multe comenzi grupate în canale pentru un utilizator. În plus un utilizator poate rula
explicit mai multe comenzi independente în acelaşi timp. Aceasta este posibil datorită rulării
comenzilor în background, pentru a specifica execuţia în fundal a unei comenzi, aceasta va fi
urmată de caracterul "&". Dacă execuţia este în fundal, tastatura este imediat disponibilă
pentru introducerea unei noi comenzi.
Ex:
$ ls -l /usr/bin &
[524]
$
Numărul [Nr] este identificatorul de proces al comenzii date. Acest identificator poate
fi folosit pentru manipularea acestor procese, de exemplu pentru terminarea forţată a
proceselor.
Ex:
$ kill -9 524
Pentru comenzile care se execută în fundal, trebuie procedat în aşa fel încât ieşirea ,
respectiv intrarea lor să nu fie ecranul respectiv tastatura, pentru aceasta se pot folosi
redirectările.
Ex:
$ ls -l /usr/bin > lista &
[524]
$
În plus pentru manipularea proceselor există câteva utilitare care permit triumiterea
unui proces în background (bg), respectiv aducerea lor în foreground (fg). Pentru a vedea
situaţia proceselor există comanda ps (Process Status).
- 79 -
Curs de SISTEME DE OPERARE
Pentru a putea specifica mai mult de o comandă pe o singură linie acestea se pot
despărţi prin caracterul ";"
Ex:
$ ls -l > lista ; grep *.c < lista
Caracterul ";" forţează execuţia comenzilor într-o ordine secvenţială, adică pentru a se
executa o comandă, trebuie ca toate comenzile precedente să se fi terminat.
Pentru a grupa mai multe comenzi se pot folosi parantezele "(" şi ")".
De exemplu dacă s-ar fi dorit execuţia comenzilor precedente în background atunci :
nu ar avea efectul dorit, deoarece doar cea de a doua comandă s-ar executa în background,
prima s-ar executa tot în foreground. Dar dacă comenzile ar fi grupate astfel :
Un script este creat prin crearea unui fişier conţinând secvenţa dorită de comenzi. El
poate fi executat în două moduri :
• Specificându-l explicit ca şi fişier de intrare pentru shell :
$ sh myscript
sau
$ sh < myscript
• Dând numele fişierului de comenzi exact ca orice altă comandă, în linia de comandă
a shell-ului :
$ myscript
Pentru ca cea de a doua metodă să funcţioneze trebuie ca utilizatorul să aibă dreptul de
execuţie asupra respectivului fişier. Aceasta se poate realiza prin comanda :
Când shell-ul încearcă să execute o comandă el mai întâi verifică dacă utilizatorul are
dreptul de a executa acea comandă, iar dacă da atunci verifică dacă comanda este un program
executabil sau un script (folosind primii doi bytes din fişier, aceşti doi bytes constituind ceea
ce se numeşte număr magic - magic number).
- 80 -
Curs de SISTEME DE OPERARE
6.5.2 Variabile şi parametri care pot fi prevăzuţi în pseudo-programe shell.
$ NAME=chris
$ BIRTHDAY='December 1st'
În exemplul de mai sus s-au definit două variabile NAME şi BIRTHDAY la care li s-au
atribuit şirurile "chris" şi respectiv "December 1st". Pentru a folosi valoarea unei variabile
într-o linie de comană, numele variabilei va fi precedată de caracterul "$". Având cele două
atribuiri de mai sus următoarele două comenzi sunt echivalente :
Shell-ul are mai multe variabile speciale, care sunt setate automat şi au un rol special :
HOME - indică calea către directorul utilizatorului. Acesta este directorul care
devine directorul curent când se dă comanda cd fără parametri.
PATH - conţine o serie de directoare separate prin caracterul ":", acestea sunt
locurile unde shell-ul va căuta după fişierele pentru comenzile care se
doresc a fi executate.
PS1 - conţine promptul shell-ului, de obicei setat iniţial la "$ "
PS2 - este promptul de continuare, dacă comanda se extinde pe mai mult de o
singură linie, iniţial "> ".
$ - este identificatorul de proces al shell-ului curent (nu se poate
schimba !).
! - este identificatorul de proces al comenzii lansate cel mai recent în
background.
? - este starea de ieşire a comenzii precedente.
1-9 - sunt argumentele cu care a fost apelat script-ul. De exemplu :
"$1" va fi înlocuit prin "chris", "$2" prin "staff" şi "$3" prin "December
1st".
0 - este numele prin care a fost apelat script-ul. În exemplul precedent "$0"
ar fi înlocuit prin "myscript".
* - este înlocuit printr-o listă a tuturor argumentelor scriptului. Din
exemplul precedent "$*" ar fi înlocuit prin "chris staff December 1st".
# - reprezintă numărul de argumente din linia de comandă. În exemplul
precedent este 3.
O altă modalitate de a seta o variabilă shell este utilizând comanda shell read care
citeşte o linie de la intrarea standard şi o asignează unei variabile.
Ex:
echo "What program do you want to compile ?"
read NAME
- 81 -
Curs de SISTEME DE OPERARE
cc $NAME
Construcţia if foloseşte starea de ieşire (exit state) a unei comenzi. Fiecare comandă
care se execută întoarce o valoare numerică când se termină. Convenţia este că o valoare de
ieşire de 0 corespunde unei terminări normale, pe când o valoare diferită de 0 corespunde
unei terminări anormale.
Formatul instrucţiunii if este :
if commanda
then
secventa de comenzi
elif comanda
then
secventa de comenzi
...
else
secventa de comenzi
fi
EXEMPLU :
Următorul script va verifica apariţia valorii din variabila NAME într+un fişier
numit namelist şi va afişa mesaje diferite depinzând de faptul dacă s-a găsit sau nu acea
valoare.
- 82 -
Curs de SISTEME DE OPERARE
Următorul script exemplifică folosirea programului test, care poate fi folosit pentru
a testa existenţa unui fişier, dacă acesta poate fi citit sau scris, pentru verificarea egalităţii
a două şiruri sau dacă un număr este mai mare, egal sau mai mic decât un alt număr
ş.a.m.d. Pentru opţiunile permise de programul test se poate consulta manualul online.
Acest script va adăuga conţinutul fişierului messagefile la sfârşitul fişierului summarzfile
şi goleşte fişierul messagefile.
if test -r messagefile
then
if test -w summaryfile -a -w messagefile
then
cat messagefile >> summaryfile
cp /dev/null messagefile
else
echo Cannot write to sumary or message file
fi
else
echo Cannot read messagefile
fi
case word in
pattern11 | pattern12 | ... )
secventa de comenzi1
;;
pattern21 | pattern22 | ... )
secventa de comenzi2
...
esac
Valoarea specificată prin word este testată pe rând cu fiecare tipar şi la prima potrivire
se va executa secvenţa de comenzi corespunzătoare. Ca şi observaţie fiecare secvenţă de
comenzi este terminată prin două caractere punct şi virgulă (';'). Tiparele corespund tiparelor
utilizate de shell pentru nume de fişiere. Se pot specifica tipare alternative pentru aceeaşi
secvenţă de comenzi, acestea se vor separa prin caracterul bară verticală ('|').
EXEMPLU :
Următorul exemplu demonstrează folosirea tiparului '*' ca şi tipar implicit dacă
nici un alt tipar nu se potriveşte, precum şi două moduri diferite pentru a alege o opţiune
indiferent de litere mari sau mici.
case $OPTION in
-p|-P)
print $FILE
;;
-[nN])
nroff $FILE
;;
*)
echo Unknown option $OPTION
;;
esac
- 83 -
Curs de SISTEME DE OPERARE
Cicluri pot fi scrise utilizând un cilcu while (sau until) care execută repetat o
comandă, testează starea de ieşire a acesteia şi dacă este 0 (diferit de 0 pentru until) execută o
secvenţă de comenzi corespunzătoare. Când starea de ieşire devine diferită de 0 (0 pentru
until) shell+ul trece la intrucţiunea de după cilcu. Formatul celor două este :
while comanda
do
secventa de comenzi
done
until comanda
do
secventa de comenzi
done
EXEMPLU :
REPLAY=yes
while test $REPLAY = yes
do
echo "Here we go again !"
echo "Do you want to go round the loop another time ?"
read REPLY
done
Ultima construcţie folosită pentru cicluri este for care are următorul format :
Secvenţa de comenzi este executată odată pentru fiecare cuvânt din lista_de_cuvinte.
Variabila va lua valori succesive din lista de cuvinte. Lista de cuvinte poate fi generată
folosind tipare ca şi acelea folosite pentru nume de fişiere. Deasemenea lista de variabile
poate lipsi, caz în care ca şi listă de variabile va fi considerată lista de argumente cu care a
fost lansat shell-ul (adică $*).
EXEMPLU :
for file in *
do
echo $file
mv $file $file.old
done
for argument
do
cat $argument
done
- 84 -
Curs de SISTEME DE OPERARE
6.5.5 Comentarii.
În script-uri se pot include şi comentarii, prin folosirea comenzii ":", aceasta este o
comandă care nu face nimic, astfel încât argumentele sale pot fi folosite ca şi comentarii. Dar
argumentele acestei comenzi sunt prelucrate la fel ca şi argumentele altor comenzi, deci
trebuie să satisfacă aceeaşi sintaxă ca şi cele pentru comenzile normale. O formă sigură
pentru comentariu este ca acesta să fie pus între apostroafe.
EXEMPLU :
Următorul exemplu pe lângă exemplificarea comentariilor, introduce şi o nouă
comandă exit care determină terminarea execuţiei scriptului.
Este posibilă construcţia unei părţi a unei comenzi prin executarea unei alte comenzi.
Dacă o comandă care este încadrată între caractere '`' (accente grave), este incorporată într-o
linie de comandă, atunci ieşirea sa standard, cu trecerile la linie nouă înlocuite prin spaţii, va
fi introdusă în locul acesteia în linia de comandă. Comanda din interiorul accentelor grave
poate fi orice comandă validă, chiar şi un canal (pipeline).
EXEMPLU :
Următoarea comandă va afişa o listă de fişiere din directorul curent în ordine
inversă.
- 85 -
Curs de SISTEME DE OPERARE
3. Se fac substituţiile numelor de fişiere ("*", "?" şi "[...]"), în afara
cayului când aceste caractere speciale sunt înconjurate cu apostroafe sau ghilimele
sau precedate de "\".
Când shell-ul este lansat explicit prin comanda sh este posibilă transmiterea unor
opţiuni pentru controlarea execuţiei acesteia. Cele mai folositoare opţiuni sunt Ş
-e Determină terminarea execuţiei imediat ce o comandă din script dă greş.
-v Determină tipărirea fiecărei linii pe măsură ce este citită.
-x Tipăreşte comenzile pe măsură ce ele sunt executate.
Opţiunile pot fi setate şi din interiorul unui script folosind comanda set. De exemplu :
set -vx
va determina tipărirea fiecărei linii şi tipărirea comenzilor pe măsură ce ele sunt executate.
EXEMPLU :
Următorul exemplu demonstrează folosirea redirectării întreruperilor în cazul în
care la terminarea unui script este necesară ştergerea unui fişier temporar.
- 86 -
Curs de SISTEME DE OPERARE
Dacă se doreşte includerea de noi variabile în ambianţă aceasta se face explicit prin comanda
export.
$ eval `name`
este echivalentă cu :
$ NAME=chris
având efectul setării variabilei de mediu NAME. Un alt mod este de a determina execuţia unui
script chiar de către shell-ul curent şi nu de către un sub-shell. Acest lucru se poate face
folosind comanda ".".
$ . setup
această comandă va determina raportarea unei erori dacă se va încerca modificarea valorii
acestor variabile.
Când se intră pentru prima oară în lucru în UNIX, sistemul porneşte un shell. Acest
shell înainte de a citi de la terminal, va căuta în directorul de login după un fişier numit
.profile şi dacă acesta există va citi şi executa comenzile din el. Acest lucru permite definirea
unui ambient propriu. Un fişier .profile tipic va arăta astfel :
PATH=$HOME/bin:/etc:/bin:/usr/bin
USER=jim
MAIL=/usr/spool/mail/$USER
export PATH USER MAIL
EXEMPLU :
Script-ul cptree face o copie al unui întreg arbore de directoare, pe multe sisteme
acesta este disponibil ca şi un program standard, cu mult mai multe opţiuni, dar acest
script este destinat doar exemplificării unui script mai mare.
- 88 -
Curs de SISTEME DE OPERARE
fi
: call cptree recursively, passing on VERBOSE option
cptree $VERBOSE $1/$FILE $2/$FILE
done
elif test -r $1
then
: just copy a non-directory
$ECHO cp $1 $2
cp $1 $2
else
echo cptree: cannot read $1
exit 1
fi
- 89 -
Curs de SISTEME DE OPERARE
ALTE PROGRAME
UTILITARE
KERNEL
HARDWARE
DE APLICAŢIE
Fig. 6.6-1
Sistemul oferă anumite facilităţi printre care se află ţi sistemul de fişiere.
Sistemul de fişiere UNIX este caracterizat printr-o structură ierarhică, tratarea
consistentă a datelor din fişiere, posibilitatea de creare şi ştergere a fişierelor, posibilitatea
creşterii dinamice a dimensiunii fişierelor, protejarea datelor din fişiere, tratarea
dispozitivelor periferice ca şi fişiere.
/
… comenzi … … utilizatori …
fd0 fd1 tty0 hda
Fig. 6.6-2
EXEMPLU :
- 90 -
Curs de SISTEME DE OPERARE
char buffer[4096];
if (argc != 3)
{
printf(“Eroare !\n”);
exit(1);
}
fdold = open(argv[1], O_RDONLY);
if (fdold == -1)
{
printf(“Eroare !\n”);
exit(1);
}
fdnew = creat(argv[2], 0666);
if (fdnew == -1)
{
printf(“Eroare !\n”);
exit(1);
}
copy(fdold, fdnew);
exit(0);
}
Un program este un fişier executabil iar un proces este o instanţă a unui program în
execuţie. Se pot executa mai multe procese simultan, nefiind impusă o limită asupra
numărului de procese existente în sistem.
Există mai multe apeluri sistem care permit proceselor crearea de noi procese,
terminarea unor procese, sincronizarea execuţiei unor procese şi efectuarea unor acţiuni la
apariţia unor evenimente.
EXEMPLU :
- 91 -
Curs de SISTEME DE OPERARE
Programul exemplifică folosirea apelului sistem fork - pentru crearea unui nou
proces, precum şi a apelurilor sistem exec - pentru lansarea în execuţie a unui alt program,
wait - pentru aşteptarea terminării unui proces fiu.
pid = fork();
if (pid == 0)
execl(“copy”, “copy”, argv[1], argv[2]);
wpid = wait(&status);
exit(0);
}
Cele mai obşnuite servicii oferite de nucleul sistemului de operare sunt următoarele :
• controlul execuţiei proceselor, permiţând crearea, terminarea, suspendarea şi
comunicarea interproces.
• planificarea corectă a proceselor pentru execuţie. Procesele folosesc acelaşi
procesor, astfel dacă procesorul execută un proces, nucleul suspendă acest proces
atunci când cuanta de timp a acestuia expiră şi planifică un alt proces la execuţie.
• alocarea memoriei pentru execuţia proceselor. Nucleul permite proceselor să pună în
comun porţiuni din spaţiul lor de adrese în anumite condiţii, dar protejează spaţiul
de adrese privat împotriva acceselor nepermise, de asemenea dacă sistemul, la un
moment dat, are la dispoziţie prea puţină memorie liberă, acesta eliberează memorie
prin transferarea temporară a unui proces sau porţiuni ale acestuia în memoria
secundară, care de obicei este un disc şi care se numeşte disc de swap. Există
sisteme UNIX numite sisteme cu SWAPPING şi sisteme cu PAGING. Sistemele
cu SWAPPING transferă un întreg proces din memoria principală în memoria
secundară, iar sistemele cu PAGING transferă la un moment dat doar pagini de
memorie din memoria principală în memoria secundară.
• alocarea eficientă a memoriei secundare pentru depozitarea respectiv regăsirea
eficientă a datelor utilizatorilor. Acest serviciu reprezintă chiar sistemul de fişiere.
• acordarea accesului controlat proceselor la dispozitivele periferice, cum ar fi
terminale, discuri, discuri de reţea sau alte periferice.
Execuţia unui proces utilizator în sistemele UNIX este divizată pe două nivele :
• nivelul utilizator - user
• nivelul de nucleu - kernel
- 92 -
Curs de SISTEME DE OPERARE
Multe arhitecturi de calculatoare suportă mai multe nivele decât cele două menţionate, dar
cele două moduri sunt necesare şi suficiente pentru sistemele UNIX.
- 93 -
Curs de SISTEME DE OPERARE
virtuale generate de compilator nu este necesar să fie identice cu adresele fizice pe care le
ocupă acesta în maşină.
Nucleul în colaborare cu hardware-ul va iniţializa o translatera a adreselor virtuale în
adrese fizice, astefl încât adresele generate de compilator vor indica adresele fizice de pe
maşina respectivă.
- 94 -
Curs de SISTEME DE OPERARE
7.1 Introducere.
User programs
trap
User level
libraries
File
Subsystem
process interprocess
communication
subsystem memory
character block management
device drivers
Fig. 7.1-1
Fig. 1 arată o diagramă bloc a nucleului, ilustrând modulele şi relaţiile dintre acestea.
În particular se reprezintă subsistemul de fişiere la stânga şi subsistemul pentru controlul
proceselor în dreapta. Figura scoate în evidenţă 3 nivele : utilizator, kernel şi hardware.
Apelurile sistem şi interfaţa oferită de librării reprezintă graniţa dintre nivelele
utilizator şi kernel. Figura partiţionează apelurile sistem în cele care interacţionează cu
subsistemul de fişiere şi cele care interacţionează cu subsistemul de control al proceselor.
Subsistemul de fişiere gestionează fişierele, alocând spaţiu acestora, administrând spaţiul
liber, compunând accesele la fişiere şi regăsind datele pentru utilizator.
Procesele interacţionează cu subsistemul de fişiere printr-un set specific de apeluri
sistem, ca şi open, close, read, write, stat(se citesc atributele unui fişier), chown, chmod.
- 95 -
Curs de SISTEME DE OPERARE
Subsistemul de fişiere accesează datele din fişiere folosind un mecanism cu buffere,
care reglează fluxul de date dintre nucleu şi suporturile externe.
Mecanismul cu buffere interacţionează cu driverele de I/E pe bloc pentru a iniţia
transferul de date spre sau dinspre nucleu. Driverele sunt module din nucleu care controlează
funcţionarea dispozitivelor periferice. De asemenea există şi drivere de I/E orientate pe
caractere pentru aşa numite raw devices.
Subsistemul de control al proceselor este responsabil pentru sincronizarea proceselor,
comunicarea interprocese, gestionarea memoriei şi planificarea proceselor.
Cele două subsisteme interacţionează între ele de exemplu la încărcarea unui program
pentru execuţie.
Câteva dintre apelurile sistem pentru controlul proceselor sunt : fork(crează un nou
proces), exec(suprascrie un proces cu imaginea unui program), wait(aşteaptă terminarea unui
proces fiu), brk(controlează dimensiunea memoriei alocate unui proces), signal(controlează
răspunsul unui proces la un semnal).
Modulul de gestiune a memoriei controlează alocarea memoriei. Dacă la un anumit
moment sistemul nu are destulă memorie fizică pentru toate procesele, nucleul va face
transfer între memoria principală şi cea secundară, astfel încât toate procesele să se poată
executa. Modulul planificator alocă CPU proceselor. El planifică un proces la execuţie, acesta
se execută până când renunţă voluntar la CPU, ca urmare a unei aşteptări sau până când îi
expiră cuanta de timp alocată, moment în care nucleul îi ia procesorul. Planificatorul în acest
caz va alege pentru execu_ie procesul disponibil cu cea mai mare prioritate. Procesul original
va fi planificat din nou la execuţie când va ajunge procesul disponibil cu cea mai mare
prioritate.
Există o varietate de forme de comunicare interproces, de la semnalarea asincronă a
unor evenimente şi până la transmiterea de mesaje între procese.
Modulul de control al hardware-ului este responsabil pentru tratarea întreruperilor şi
pentru comunicarea cu maşina. Dispozitive ca discuri sau terminale pot întrerupe procesorul
în timpul execuţiei unui proces. Nucleul poate relua execuţia procesului întrerupt după
tratarea întraruperii. Întreruperile nu sunt tratate de procese speciale ci de funcţii speciale din
nucleu, apelate în contextul procesului curent.
Reprezentarea internă a unui fişier este dată printr-un aşa numit inode (index node),
care conţine o descriere a aşezării fizice a fişierului pe disc şi alte informaţii, ca de exemplu :
proprietarul, atributele de acces, momentul la care a fost accesat. Fiecare fişier are un singur
inode, dar poate avea mai multe nume care toate sunt mapate (indică) la acelaşi inode. Fiecare
nume este o aşa numită legătură (link). Când un proces crează un nou fişier, nucleul îi atribuie
un inode neutilizat. Inodurile sunt în compoziţia sistemului de fişiere fizic, dar nucleul le
citeşte în memorie pentru a avea un acces mai rapid la fişiere. Nucleul conţine în afara
tabelului de inoduri, două alte structuri de date : tabela de fişiere şi tabela de descriptori
pentru fişierele utilizator. Tabela de fişiere este o structură globală a nucleului, iar tabela de
descriptori ai fişierelor utilizator este împărţită pe procese.
- 96 -
Curs de SISTEME DE OPERARE
•
•
•
Fig. 7.2-1
Când un proces deschide sau crează un fişier, nucleul alocă o intrare din fiecare tabelă
corespunzătoare inodului fişierului. Intrările din cele 3 structuri de date conţin informaţii
despre starea fişierului şi permit accesul la el. Tabela de fişiere de obicei con_ine
deplasamentul în fişier unde va avea loc următoarea operaţiune de citire sau scriere, de
asemenea mai conţine şi drepturile de acces admise procesului care a deschis fişierul. Tabela
de descriptori pentru fişierele utilizator conţine date despre toate fişierele deschise de un
anumit proces.
Un sistem de fişiere are următoarea structură :
Fig. 7.2-2
Blocul de boot - ocupă începutul unui sistem de fişiere, de obicei primul sector şi
poate con_ine codul de bootare necesar iniţializării sistemului de operare. Deşi doar un singur
bloc de boot este necesar pentru a iniţializa un sistem, toate sistemele de fişiere au un bloc de
boot.
Superblocul - descrie starea unui sistem de fişiere (dimensiune, câte fişiere poate
conţine, unde se găseşte spaţiul liber, etc.)
Lista de inoduri - urmează superblocului şi dimensiunea acestei liste se specifică la
configurarea sistemului. Nucleul face referire la inoduri prin indecşii acestora. Unul din
aceste inoduri este inodul rădacină al sistemului de fişiere, adică este inodul prin care
structura de directoare a sistemului de fişiere va fi accesibilă după execuţia apelului sistem
mount.
Blocurile de date - de obicei încep la sfârşitul listei de inoduri şi conţin datele
fişierelor şi date administrative. Un bloc alocat poate face parte dintr-un singur fişier din
sistemul de fişiere.
Inodul - se află pe disc şi sunt citite într-o zonă de memorie. Conţin câmpurile :
• identificatorul proprietarului - proprietatea unui fişier e divizată între un singur
proprietar şi grupul proprietar şi defineşte setul de utilizatori care au acces la fişiere.
Superutilizatorul are acces la orice fişier.
• tipul fişierului
• fişiere regulare
• fişiere directoare
• fişiere speciale pe caracter
- 97 -
Curs de SISTEME DE OPERARE
• fişiere speciale pe bloc
• fişiere FIFO
• atributele de acces - sistemul protejează fişierele faţă de 3 clase :
• proprietarul
• grupul proprietarului
• alţii
Fiecare clasă poate avea drepturi de acces pentru citire, scriere şi execuţie;
• timpii de acces la fişier:
• Timpul la care fişierul a fost ultima dată modificat.
• Timpul când a fost ultima oară accesat.
• Timpul când inodul a fost ultima dată modificat;
• numărul de legături la un fişier - reprezintă numărul de nume pe care un fişier le are
în ierarhia de directoare;
• tabela de adrese pentru blocurile de date din fişier;
• dimensiunea fişierului;
Pentru o mai mare flexibilitate, nucleul alocă spaţiu pentru un fişier doar câte un bloc
până când se ajunge la spaţiul necesar, permiţând astfel ca datele dintr-un fişier să fie
împrăştiate în sistemul de fişiere. Această schemă de alocare complică regăsirea datelor.
Tabela cu adresele blocurilor ar putea consta dintr-o listă de numere de blocuri
aparţinând fişierului, dar manipularea unei liste de blocuri este destul de greoaie (consumă
timp). Dacă un bloc logic conţine 1K atunci un fişier de 10K ar necesita un index având 10
numere de blocuri. Pentru a menţine structura unui inod destul de mică dar totuşi pentru a
permite şi fişiere de dimensiuni mari, tabela de adrese dintr-un inod are forma :
Inode Data Blocks
direct 0
1
2
3
4
5
6
7
8
direct 9
single indirect
double indirect
triple indirect
Fig. 7.2-3
- 98 -
Curs de SISTEME DE OPERARE
Un proces este defapt un program care se află în execuţie şi constă dintr-un şir de
octeţi pe care CPU-ul le interpretează ca şi instrucţiuni maşină (numit “text”), date şi stivă.
Mai multe procese sunt executate simultan, pe unele sisteme doar în aparenţă, ordinea
execuţiei depinzând de planificarea acestora de către kernel. Deasemenea mai multe procese
pot fi instanţe ale unui acelaşi program.
Un proces se execută urmând o secvenţă strictă de instrucţiuni, conţinută în proces, şi
nu face salturi la secvenţele altor procese. El îşi citeşte şi scrie secţiunile de date şi stivă, dar
nu poate citi sau scrie datele şi stiva altui proces. Procesele comunică cu alte procese şi cu
lumea înconjurătoare doar prin apeluri sistem.
Practic un proces pe un sistem UNIX este o entitate care este creată prin apelul sistem
fork. Orice proces, cu excepţia procesului 0 este creat când un alt proces execută acest apel
sistem. Procesul care a apelat fork se numeşte proces părinte, iar procesul nou creat se
numeşte procesul fiu. Fiecare proces are doar un singur proces părinte, dar poate avea mai
multe procese fii. Nucleul identifică fiecare proces prin numărul de proces al acestuia, numit
identificator de proces (PID).
Procesul 0 este un proces special care este creat când se iniţializează sistemul, după ce
lansează un proces fiu (procesul 1), procesul 0 devine procesul swapper (cel care gestionează
memoria virtuală). Procesul 1, cunoscut sub numele de init este "strămoşul" tuturor
proceselor din sistem.
Nucleul, ca urmare a unui apel exec încarcă un fişier executabil în memorie. Procesul
încărcat constă din cel puţin trei părţi, numite regiuni : text, date şi stivă. Regiunile text şi
date corespund secţiunilor de text şi dată ale fişierului executabil, dar regiunea de stivă este
creată automat şi dimensiunea acestuia este ajustată dinamic în timpul execuţiei.
Deoarece în sistemul UNIX un proces poate rula în două moduri, kernel sau utilizator,
se folosesc stive separate pentru fiecare mod. Stiva utilizator conţine argumentele, variabilele
locale şi alte date necesare funcţiilor care se execută în mod utilizator. Stiva kernel conţine
datele necesare pentru funcţiile care se execută în mod kernel. Funcţiile şi datele din această
stivă se referă la funcţii şi date din kernel şi nu din programul utilizator. Stiva kernel a unui
proces este vidă când un proces rulează în mod utilizator.
Fiecare proces are alocată o intrare în tabela de procese a nucleului, deasemenea
fiecărui proces îi este alocată o zonă utilizator (u area), care conţine date private manipulate
doar de nucleu. Tabela de procese conţine un pointer spre o tabelă de regiuni ale procesului
care conţine intrări care indică într-o altă tabelă de regiuni, globală, care la rândul lui indică
adresele fizice din memoria fizică, corespunzătoare acelor regiuni. O regiune este o zonă
continuă a spaţiului de adresare a unui proces (de ex. text, date şi stivă). Intrările în tabelele
de regiuni descriu atributele regiunii, adică faptul că această regiune conţine text sau date,
dacă este partajată sau privată şi dacă datele din regiune sunt în memoria principală sau nu.
Cel de-al doilea nivel de indirectare (tabela de regiuni ale unui proces), permite proceselor
independente să partajeze regiuni. Când un proces execută apelul sistem exec, nucleul alocă
regiuni pentru text, date şi stivă după ce a eliberat vechile regiuni ale procesului.
Când un proces executâ apelul fork, nucleul duplică spaţiul de adrese al vechiului
proces, permitând proceselor să partajeze regiunile când este posibil, altfel făcând o copie
fizică. Când un proces apelează exit, nucleul desalocă regiunile pe care procesul le-a deţinut.
- 99 -
Curs de SISTEME DE OPERARE
Figura următoare ilustrează structurile de date relevante ale unui proces aflat în
execuţie:
per process
region table
u area region table
process table
main memory
Fig. 7.3-1
Intrarea în tabela de procese şi zona numită u area conţin informaţii de control şi stare
despre procese. Zona u area este o extensie a intrării în tabela de procese.
Câmpurile cele mai importante din tabela de procese sunt :
• câmp de stare, indicând starea procesului.
• intrarea în tabela de procese conţine câmpuri care permit nucleului localizarea
procesului şi a zonei sale u area, din memoria principală sau secundară. Nucleul
foloseşte aceste informaţii pentru a putea face schimbarea de context, la acel proces,
când acesta trece din starea Ready to Run In Memory în starea Kernel Running sau
din starea Preempted în starea User Running. În plus, nucleul mai foloseşte aceste
informaţii când transferă procesele din sau în memoria principală. Intrarea de tabelă
mai conţine un câmp care dă dimensiunea procesului, astfel încât nucleul să ştie cât
spaţiu să aloce procesului.
• identificatori de utilizatori (UID-uri), care determină diferitele privilegii ale
proceselor. De exemplu, aceste câmpuri determină setul de procese care pot trimite
semnale unele la altele.
• identificatori de procese (PID-uri), care specifică relaţiile dintre diferite procese.
Aceste câmpuri sunt iniţializate când procesul intră în starea Created, în apelul
sistem fork.
• un descriptor de evenimente, setat când procesul este suspendat (starea de somn -
sleep).
• parametrii pentru planificatorul de procese, permit nucleului să determine ordinea în
care procesele trec în stările Kernel Running şi User Running.
• un câmp pentru semnale, care enumeră semnalele trimise procesului ăi care nu au
fost încă tratate.
• mai mulţi contori pentru păstrarea timpului de execuţie, utilizarea resurselor ăi
altele, folosite pentru gestionarea ăi calcularea priorităţii de planificare. Există şi un
câmp contor setabil de utilizator, folosit la transmiterea unui proces a unui semnal
de alarmă.
Zona u area conţine informaţii care descriu procesul, dar care trebuie să fie accesibile
doar când procesul se execută efectiv. Câmpurile cele mai importante sunt :
- 100 -
Curs de SISTEME DE OPERARE
• un pointer către intrarea în tabela de procese a procesului.
• identificatorii reali şi efectivi de utilizator, care determină diferite privilegii acordate
procesului, cum ar fi drepturile de acces la fişiere.
• câmpuri contor care memorează timpul cât procesul şi descendenţii săi au petrecut
în mod utilizator respectiv în mod kernel.
• un tablou indicând modul de răspuns al procesului la diferite semnale.
• un câmp care identifică "terminalul de login" asociat cu procesul (dacă acesta
există).
• câmp de eroare care reţine codurile de eroare dintimpul unui apel sistem.
• câmp care reţine valoarea de întoarcere dintr-un apel sistem.
• parametri de I/O care descriu cantitatea de date care urmează să fie transferate,
adresa tabloului sursă (sau destinaţie), din spaţiul utilizator, deplasamente de fişiere
şi altele.
• directorul curent şi rădăcina curentă, descriu ambianţa sistemului de fişiere pentru
respectivul proces.
• tabela descriptorilor de fişier pentru fiecare fişier deschis.
• dimensiunile maxime ale unui proces şi a fişierelor pe care poate să le creeze.
• un câmp de mască de moduri de acces pentru fişierele care vor fi create de proces.
Contextul unui proces este starea acestuia, cum este ea definita de textul său, de
valorile variabilelor utilizator globale şi structurilor de date, de valorile regiştrilor pe care le
foloseste, de valorile din zona din tabela de procese care îi corespunde precum şi din zona u
area şi conţinutul stivelor utilizator şi kernel. "Text"-ul sistemului de operare şi structurile
sale de date globale, sunt partajate de toate procesele, dar ele nu constituie parte a contextului
unui proces.
Când execută un proces, sistemul se spune că ruleaza în contextul procesului. Când
nucleul decide că ar trebui să execute un alt proces, el face o aşa numită schimbare de context
(context switch), astfel încât sistemul va rula în contextul noului proces. Nucleul permite o
schimbare de context doar în anumite condiţii specifice. Când face o schimbare de context,
nucleul salvează informaţie suficientă pentru a putea relua mai târziu procesul întrerurpt. La
fel când se trece din modul utilizator în kernel, nucleul salvează suficientă informaţie, astfel
încât mai tarziu să se poată întoarce în modul utilizator şi să continue execuţia din punctul în
care a rămas. Schimbarea modului de execuţie din mod utilizator în kernel şi invers NU este o
schimbare de context.
Nucleul tratează întreruperile în contextul procesului întrerupt, chiar dacă acesta nu a
provocat apariţia întreruperii. Procesul întrerupt se putea găsi sau în mod utilizator sau în mod
kernel. Nucleul salvează suficientă informaţie astfel încât mai târziu să poată relua execuţia
procesului întrerupt, după care tratează întreruperea în mod kernel. Nucleul nu lansează sau
planifică un proces special pentru tratarea întreruperilor.
- 101 -
Curs de SISTEME DE OPERARE
Timpul de viată al unui proces poate fi divizat într-un set de stări care descriu
procesul. Un proces poate fi într-una din următoarele stări :
1) Procesul rulează în mod utilizator.
2) Procesul rulează în mod kernel.
3) Procesul nu rulează dar este pregătit pentru execuţie (atunci când nucleul îl
planifică).
4) Procesul este adormit şi se află în memoria principală.
5) Procesul este gata de execuţie, dar swapper-ul trebuie să îl ad