Sunteți pe pagina 1din 56

AN II SEM I

UNIVERSITATEA BUCURESTI | Facultatea de Matematica Informatica

Proiect Sisteme de Operare

CUPRINS
Conceptie si utilizare SO: Limbajul Shell Scripting
A.1 Introducere cateva date generale..........................................................2
A.1.2 Prezentarea notiunilor................................................................................................. 2
A.1.2 Context (sistemul folosit)............................................................................................ 3
A.2 Instructiuni............................................................................................. 5
A.2.1 Cateva instructiuni de baza Exemplificate..................................................................5
A.2.2 Un prim program...................................................................................................... 10
A.2.3 Variabile.................................................................................................................... 12
A.3 Structuri de control...............................................................................15
A.3.1 Structuri decizionale.................................................................................................18
A.3.2 Structuri Bucla.......................................................................................................... 22
A.3.3 O aplicatie practica................................................................................................... 25
Conceptie si dezvoltare SO: Nucleul Unix/Linux
B.1 Rol........................................................................................................ 26
B.2 Componente..........................................................................................27
B.3 Administrare sistem de fisiere................................................................29
B.3.1 Fisiere ordinare......................................................................................................... 30
B.3.2 Directoare................................................................................................................. 31
B.3.3 Fisiere speciale......................................................................................................... 34
B.3.4 Fisiere Pipe (FIFO)..................................................................................................... 35
B.3.5 Informatii despre un fisier.........................................................................................36
B.4 Administrare memorie...........................................................................37
B.5 Planificare si executie job-uri.................................................................39
B.6 Comenzi interne shell............................................................................40
B.6.1 Comenzi pentru informare........................................................................................ 41
B.6.2 Comenzi pentru gestiunea directoarelor...................................................................43
B.6.3 Comenzi pentru gestiunea fisierelor.........................................................................43
B.6.4 Comenzi pentru gestiunea proceselor......................................................................48
B.6.5 Comenzi pentru gestiunea volumelor.......................................................................48
B.7 Redirectari............................................................................................48
B.8 Conducte..............................................................................................50
Bibiligrafie

.52
1

CONCEPTIE SI UTILIZARE SO:


LIMBAJUL SHELL SCRIPTING
A.1 INTRODUCERE CATEVA DATE GENERALE
A.1.2 PREZENTAREA NOTIUNILOR

Pentru a intelege mai bine conceptual de Shell Scripting vom incepe prin a
prezenta o schema a legaturii dintre shell, nucleul (kernel), partea de
hardware, aplicatii/programe si interactiunea cu userul:

In partea a doua a acestui proiect, vom reveni asupra notiunii de nucleu si o


vom prezenta pe larg, dar pentru moment, este suficient sa stim ca acesta
nu contine Shell-ul, ci primeste de la Shell comenzile utilizatorului cu
scopul de a executa programe, creea fisiere si multe altele.
Dupa cum stim, in engleza cuvantul Shell inseamna scoica, dar in acest
context ar putea fi tradus mai adecvat ca invelis deoarece joaca rolul de
interfata intre sistem si utilizator.

Practic Shell accepta instructiuni si comanzi de la utilizator (in limba engleza


prin intermediul tastaturii sau a unui fisier) si, daca sunt valide le traduce
nucleului. Astfel, utilizatorul nu este nevoit sa citeasca sau sa scrie in limbaj
binary (0 si 1).
Caracteristici ale Shellului:

Interactiva: primeste si executa comenzi;


Poate fi customizata
Puternica: poate face aproape orice

Exista mai multe tipuri de Shell disponibile pentru sisteme Linux, printre
care:
BASH (Bourne-Again Shell) creeata de Brian Fox si Chet Ramey este cea
mai folosita dintre Shellurile existente.
CSH (C Shell) creeata de Bill Joy are o sintaxa si este folosita intr-un mod
foarte similar cu limbajele de programare C.
KSH (Korn Shell) creeata de David Korn
TCSH este o variant imbunatatita, dar complet compatibila a Berkeley
UNIX C shell (CSH)
In mod normal, shell accepta comenzi direct de la tastatura, dar pentru a
putea da mai multe instructiuni, le putem pune intr-un fisier text, iar shell va
executa direct acest fisier. Aceasta metoda se numeste shell scripting.

A.1.2 CONTEXT (SISTEMUL FOLOSIT)

Pentru realizarea acestui proiect am folosit masina virtuala VMware Player


pentru Windows (disponibila la aceasta adresa:
https://my.vmware.com/web/vmware/free#desktop_end_user_computing/vm
ware_player/6_0) si pe ea am instalat sistemul de operare Ubuntu 12.04.3 pe
64-bit (disponibil aici: http://www.ubuntu.com/download/desktop )
Procesul de instalare in imagini:

A.2 INSTRUCTIUNI
A.2.1 CATEVA INSTRUCTIUNI DE BAZA EXEMPLIFICATE

Am discutat in subcapitolul precedent despre existenta mai multor variante


de Shell, de aceea vom prezenta ca o prima instructiune, ceea care ne
permite sa vedem ce astfel de limbaj foloseste varianta de Linux pe care o
utilizam.
$ echo $SHELL
Exemplu:

Observam ca timpul de Shell utilizat in sistemul nostru este BASH.


Presupunand ca shellul nostrum ar fi fost altul si totusi am fi vrut sa ne
folosim de BASH, atunci ar fi fost suficient ca la inceputul unui fisier
executabil sa pune linia: #!/bin/bash astfel, instructiunea va fi data
shellului bash.
Mai departe vom vedea mai multe instructiuni.
~$ ls prin folosirea acestei instructiuni putem sa vedem o lista cu
continutul directorului in care ne aflam
O alta instructiune utila este: ~$ man numele_unei_instructiuni si
ofera informatii despre instructiunea in cauza. Mai jos exemple pentru cele
doua instructiuni:

Sa testam in continuare cateva instructiuni legate de directoare:

In primul rand am folosit instructiunea ls pentru a vedea o lista cu continutul


directorului curent, apoi am ales dintre ele un alt director si l-am facut pe el
directorul curent (asa cum se poate vedea pe linia a 4-a, iar pe linia a 5-a
apare rezultatul). Deci comanda cd inseamna change directory si schimba
directorul curent. Folosind din nou comanda ls am constatat ca este gol si am
decis sa face un nou director in directorul curent (Music) tastand comanda
mkdir insotita de numele directorului dorit. Pentru a verifica am listat din
nou si vedem ca intr-adevar a fost creat. Apoi, folosind comanda cd ~ ne
intoarcem in Home.
O alta comanda utila este cd / pentru a ajunge in root.
7

Se observa ca lista a fost schimbata fata de home. In continuare, daca am fi


in home si am vrea sa mergem direct in unul dintre folderele din root, iata
cum am proceda:

Pentru a naviga un director in sus, exista o alta comanda:


Se poate vedea ca a functionat.
Pentru a economisi timp, atunci cand avem de scris o adresa mai lunga
putem scrie primele litere si apoi apasa tab se va autocomplete, iar daca
sunt mai multe optiuni acestea ne vor fi indicate.

In continuare vom folosi un editor de text. Am incercat sa accesam vim

dar observam ca el nu este instalat.

Dupa cum vedem este foarte simplu de instalat si nu necesita cunostinte


prealabile din partea noastra.
8

Dupa instalare, reluam:

Pentru a deschide un fisier cu vim:

Si rezultatul:

10

Se foloseste pentru iesire.


Va afisa un tutorial pentru acest
editor.
A.2.2 UN PRIM PROGRAM

La invatarea oricarui nou limbaj, primul program pe care il folosim deobicei


este afisarea traditionalului Hello, world!. In primul rand, intr-un fisier text
scriem instructiunea de afisare:

Observam ca linia incepand cu #


este un comentariu. Pentru a rula acest fisier executabil vom urma pasii
exemplificati mai jos:
11

Pentru ca la inceput nu eram in directorul corespunzator, instructiunea nu a


putut fi executata. Am ajuns in directorul in care gasim fisierul, apoi ii
acordam acestuia permisiunea de executie, dupa care il executam.
Observam ca intr-adevar textul din comentariu nu se afiseaza, in schimb linia
de dupa comanda echo apare pe ecran. Am rulat primul program!
Mai multe optiuni de afisare:
-n Nu trece la linia urmatoare
-e Permite interpretarea urmatoarelor caractere in stringuri:
\a alert (bell)
\b backspace
\c suppress trailing new line
\n new line
\r carriage return
\t horizontal tab
\\ backslash
Exemplu:

12

Utilizarea ghilimelelor:
se elimina semnificatia (in afara de $ si de \)
ramane neschimbat
` - executa linia dintre aceste caractere ca o comanda
A.2.3 VARIABILE

Nomenclatura: Ca si in alte limbaje de programare, numele variabilelor


trebuie sa inceapa cu un caracter alfanumeric sau _, iar in continuare pot fi
utilizate caractere alfanumerice, cifre sau _. Alte caractere nu sunt premise
(de exemplu ? sau ! etc). Limbajul este case-sensitive.
Pentru atribuire se utilizeaza semnul =. Sintaxa atribuirii este
variabila=valoareaDorita. Punerea de spatii inainte sau dupa semnul de
atribuire (=) este gresita.
Vom exemplifica:

Ca si in alte limbaje, se foloseste simbolul $nume_variabila pentru a afisa

13

direct valoarea acesteia.

Instructiunea exit: exit 0 este folosit pentru a indica executia cu success a


programului. In cazul in care ar aparea erori, programul ar intoarce un numar
diferit de 0 pentru a indica aceste erori. Exemplu:

Pentru a efectua operatii matematice cu variabilele avem nevoie de o


sintaxa speciala:
expr var1 operator var 2
operatorul poate fi: +; -; /; %(pentru restul impartirii); \* (inmultire).

14

Se remarca
semnele de `, care permit transmiterea unei comenzi. Aceasta este o
importanta si puternica caracterisitica a limbajului.
Citirea de variabile read

Instructiuni folosind caractere generale


ls *
ls a*
ls *.c
ls va*.c
ls ?
ls va?

ls [abc]

arata toate fisierele


arata toate fisierele care incep cu
a
arata toate fisierele cu extensia .c
arata toate fisierele cu extensia.c si
incepand cu va (de exemplu)
arata toate fisierele cu numele de
lungime un caracter
arata toate fisierele care incep cu
va si mai contin un caracter in
nume
arata toate fisierele care incep cu
abc

15

La sfarsit am introdus si comanda clear aceasta curata ecranul:

A.3 STRUCTURI DE CONTROL

Operatori de comparatie

16

Inainte de a putea folosi structurile de control trebuie sa avem cateva notiuni


legate de operatorii de comparatie ai limbajului.
In primul rand vom accesa programul de calculare al Linuxului pentru a lucre
cu niste operatori familiari si a observa rezultatul.

Se poate observa ca pentru a comunica utilizatorului ca expresia respectiva


este adevarata, programul intoarce valoarea 1, iar pentru fals intoarce
valoarea 0. Trebuie retinut faptul ca limbajul Shell se comporta total opus,
intorcand 0 pentru adevarat si o valoare diferita de zero pentru a indica
faptul ca expresia evaluate este falsa. Ne-am confruntat cu aceasta diferenta
si mai devreme, in momentul in care am studiat instructiunea exit.
Nu numai ca rezultatul este diferit, dar si operatorii de comparatie pentru
numere sunt diferiti in limbajul Shell. Pentru a vedea, vom utiliza
instructiunea test:

17

Observam ca in loc de test putem folosi [ ] ; mai observam ca pentru numere


nu functioneaza operatorii clasici, ci sunt folositi urmatorii operatori:
C
C
C
C
C
C

-eq (egal)
-ne (not egal)
-le (less or egal)
-lt (less than)
-gt (greater than)
-ge (greater sau egal)

Operatorul == functioneaza in schimb pentru stringuri.


Teste pentru fisiere:

18

-d - testeaza daca este director


-f testeaza daca e fisier
-e / -a testeaza daca exista
-r - testeaza daca putem sa-l citim
-w testeaza daca putem sa scriem in el
-s testeaza daca nu este gol
Pentru o pereche de fisiere putem testa daca primul e mai vechi decat al
doilea prin ot sau mai nou: -nt.

Operatorii logici: ! expresie; expresie1 a expr2; expr1 o expr2 (not,


and, respective or)

19

A.3.1 STRUCTURI DECIZIONALE

Avand o baza in ceea ce priveste operatorii de comparatie si metodele de


testare, putem in sfarsit sa studiem structura if.
Sintaxa sa este urmatoarea:
if conditie
then
instructiune1
fi
Cu alte cuvinte, daca este indeplinita conditia (este adevarata) sau iesirea ei
este 0, atunci se executa instructiunea. Observam ca structura if se incheie
cu fi care nu e altceva decat oglinditul cuvantului.
Sintaza pentru if..else:
if conditie
then
instructiune1
else
instructiune2
fi
In cazul in care conditia nu e adevarata, instructiunea 1 nu se executa si se
executa instr2.
Exemplu:

20

Sintaxa pt if pe mai multe niveluri:


if conditie
then instructiune
elif conditieA
then instructiune
elif conditieB
then instructiune
else instructiune
21

fi
Pe exemplu precedent:

Acest exemplu poate fi modificat folosind structura case


Sintaxa:
case $nume_variabila in
tip1) instructiune
..
Instructiune;;
22

Tip2) instructiune
..
Instructiune;;
tipN) instructiune
..
Instructiune;;
*) instructiune
..
Instructiune;;
esac
Pe exemplu anterior:

A.3.2 STRUCTURI BUCL A

Structurile de tip bucla permise de limbajul Shell sunt for si while.


Bucle for
Sintaxa:
for nume_variabila in lista
do
23

instructiune
done
Sa incercam un exemplu:

24

A doua sintaxa pentru for:


for (( expr1; expr2; expr3 ))

25

do
instructiuni
done
Exemplu modificat pe exemplul anterior:

Bucle while
Sintaxa:
while [ conditie ]
do
instr1
instr2
instr3

done
Exemplu:

26

A.3.3 O APLICATIE PRACTICA

Putem folosi limbajul Shell pentru a afla daca un an este bisect sau nu. Se
stie ca anii sunt bisecti daca sunt divizibili cu 4, mai putin cei divizibili cu 100
care sunt bisecti doar daca se divid cu 400. Vom scrie un simplu program
care determina daca un an e bisect sau nu.

Si la rulare functioneaza pe toate cazurile posibile:

27

28

CONCEPTIE SI DEZVOLTARE SO:


NUCLEUL UNIX/LINUX
B.1 ROL

Asa cum am aratat si in prima parte a acestui proiect, Nucleul Linux, in


engleza Kernel, este centrul sistemului de operare Linux Os. Nucleul
manageriaza resursele sistemului, de exemplu pastrarea de date,
imprimarea lor, memoria, managementul fisierelor. Nucleul este cel care
decide asupra modului de folosire a acestor resurse si a timpului de folosire a
lor.
In schema de mai jos putem observa locul pe care il ocupa Nucleul si modul
in care el are rol de intermediar intre partea de hardware a computerului si a
programelor si aplicatiilor sau a shell:

Pe scurt, functiile nucleului sunt urmatoarele:

Administrarea sistemului de fisiere


Administrarea memoriei
Planificarea si executia proceselor
Administrarea device-urilor
Protectia datelor si programelor
Planificarea unitatii central intre procese

B.2 COMPONENTE
29

Componenetele care intra in arhitectura unui kernel Linux, corespund cu


principalele functii ale sale, asa cum le-am enumerate in subcaptitolul
precedent. Mai jos putem observa o schema a acestor componenete:

System Call Interface (SCI): User space-ul este spatial de memorie in care
ruleaza procesele de user. Acest spatiu este protejat, sistemul impiedicand
procesele de la a interfera unul cu altul, iar singurul tip de procese care pot
accesa un astfel de process sunt cele ale nucleului. SCI pune la dispozitie
posibilitatea de a apela functii din user space in nucleu.
Process Management (PM): Aceasta este una din componentele
fundamentale ale nucleului. Deoarece fiecare process este programat sa
ruleze pe o anumita perioada de timp, kernelul are un important rol de a
crea, gestiona (asteptare, executie) si a sterge procese. In plus, nucleul
asigura sincronizarea proceselor, comunicarea intre ele si planificarea lor.
Memory management (MM): Si aceasta componenta joaca un rol
important in functionarea sistemului. Deoarece memoria fizica este o resursa
limitata, a fost conceputa memoria virtuala pentru a depasi aceasta limitare.
Nucleul gestioneaza atat aceasta resursa de memorie, cat si resursa de
memorie fizica.
Virtual file system (VFS): Alaturi de component de gestiune a proceselor,
aceasta component face parte dintre cele doua component fundamentale din
structura unui nucleu Linux. Aceasta indeplineste mai multe functii de
gestiune a fisierelor, ca de exemplu: accesul la ele, administrarea spatiului
30

liber si alocarea de spatiu dynamic pentru fisiere pe HD si FD, operatii cu


fisiere, (incluzand crearea, citirea, scrierea, stergerea, copierea,
concatenarea ), cat si schimbarea structurii sistemului de fisiere.
Network stack: urmeaza o arhitectura modelata in conformitate cu
protocoalele.
Device drivers (DD): nucleul ascunde partea de hardware de utilizator si
o gestioneaza el insusi. Codul pentru a gestiona fiecare periferic este
continul in nucleul Linux. Deviceurile sunt de mai multe feluri: de caractere
(tastatura, mouse), in bloc (disk), deviceuri network (acestea sunt create de
catre nucleu).
Architecture-dependent code: contine subdirectorii specifici arhitecturii.
Fiecare dintre acesti subdirectori contine altii, concentrate asupra unor
aspect particulare ale nucleului (boot, kernel, gestiunea memorie etc).
B.3 ADMINISTRARE SISTEM DE FISIERE

Intr-un sistem de operare Linux, fisierele sunt organizate intr-o structura


ierarhica, numita arborescenta. Ca si in cazul altor sisteme de operare, avem
de-a face cu directoare si fisiere. Pentru a intelege mai bine notiunea de
arbore, voi cita definitia acestuia:
Definiie. Un arbore este un graf neorientat constituit dintr-o mulime de
noduri din care unul se numete rdcin, iar celelalte se numesc noduri
neterminale sau noduri terminale, i un numr de muchii de legtur ntre
noduri determinnd o structur de organizare a nodurilor pe nivele:

nivelul 0 constituit doar din nodul rdcin;

nivelul 1 constituit din noduri legate de nodul rdcin;

nivelul 2 constituit din noduri legate unic de unele noduri din nivelul 1;

nivelul k > 2 constituit din noduri legate unic de unele noduri din
nivelul (k-1).

Nodurile de pe un nivel k se numesc noduri tat, iar nodurile de pe


nivelul urmtor (k+1) se numesc noduri fiu. Nodurile care nu au nici un
fiu se numesc noduri terminale, iar nodurile care au cel puin un fiu se

31

numesc noduri neterminale. Orice nod fiu are un unic nod tat, iar nodul
rdcina nu are tat, dar are cel puin un fiu.
Si voi insera aici un exemplu de arbore:

Intorcandu-ne la structura fisierelor si directoarelor in sistemul Linux, putem


sa remarcam ca in radacina arborelui se afla directorul radacina (root, notat
\). Plecand de la acesta se conecteaza de el urmatoarele noduri (directoare
si fisiere), iar la fiecare director sunt sau pot fi conectate la randul lor alte
directoare sau fisiere.
Pentru a ajunge in root trebuie sa folosim urmatoarea comanda:

Exista mai multe tipuri de fisiere: ordinare, director, speciale sau pipe.
B.3.1 FISIERE ORDINARE

Primul tip, fisierele ordinare este singurul folosit pentru a memora pe termen
nelimitat informatii, acestea fiind memorate pe un spatiu magnetic si
reprezentand un program sursa (text), o forma de cod executabil (binar),
date necesare executiei programelor.
Pentru denumirea acestor fisiere exista cateva reguli:
- numele este case-sensitive, un fisier cu litere mari este diferit de un fisier
cu acelasi nume, dar scris cu litere mici
- exista anumite caractere care nu sunt permise in numele fisierului: /||!
@#$^&*()
- desi includerea de spatii in numele unui fisier este permisa, acest lucru nu
este rcomandat

32

- se poate folosi punctul pentru a separa intre ele cuvine, extensia fiind
diferita fata de alte sisteme de operare.
Asa cum ne putem da seama, cunoscand definitia arborelui, fisierele ordinare
se afla pe pozitia de frunze ultimul nivel al unei structure arborescente, de
ele nefiind legate alte fisiere sau directoare.
In ceea ce priveste drepturile de acces, acestea pot fi acodate diversor
grupuri: u proprietare; g grup; o restul utilizatorilor si se pot referi la
diverse actiuni: r (citire); w (scriere); x (executie). Am vazut in partea A a
proiectului cum am oferit drept de executie pentru un fisier inainte de a il
executa. Sa exemplificam mai pe larg:

Observam ca cele doua fisiere difera, desi au aceleasi litere in componenta


numelui (datorita case-sensitive). Mai observam ca nu ruleaza inainte de a
primi permisiune si observam ca prin semnul permisiunea poate fi
revocata. In incheiere am revocat permisiunea de scriere pentru unul dintre
fisiere si folosim o comanda de scriere in fisierul respectiv (vom reveni mai
tarziu asupra acestui aspect), pentru a vedea ca intr-adevar nu avem
permisiunea:

33

B.3.2 DIRECTOARE

Definiie. Fiierele director sunt fiiere ce conin liste de directoare i


care asigur structura arborescent ce are un director rdcin (root) notat
prin /.
Directoarele sunt reprezentate ca noduri ale arborelui sistemului de fisiere,
iar la ele pot sa fie conectate alte directoare sau fisiere ordinare. Pentru
fiecare utilizator exista un director propriu in care acesta isi poate salva toate
directoarele si fisierele sale.
Mergand in root si cerand afisarea subdirectoarelor sale putem observa
structura standard a sistemului. In plus, am navigat si catre directorul bin si
am cerut o lista a continutului acestuia:

Sa ne indreptam atentia asupra primului nivel de la radacina (a fiilor sai


directi):
/bin - conine comenzile de baz n format executabil (cd, ls, mkdir, rm,
rmdir)
/dev - conine fiierele speciale de comunicare cu dispozitivele HD,
FD,Printer, terminale, terminal operator
/etc - conine repertoarul unor utilitare speciale de ntreinere, folosite
doar de administratorul de sistem ( fiierul de parole, fiierul de grupuri)
34

/home - pastreaz toate directoarele de reziden ale utilizatorilor


/lib

- conine bibliotecile pentru limbajele de programare (C, PASCAL,)

/sbin - conine toate programele ce trebuie lansate n execuie de UNIX,


precum i unele comenzi folosite doar de administratorul de sistem
/sys - conine textul sursa pentru programele sistemului UNIX
/tmp - conine fiiere temporare
/usr - conine directoare i fiiere pentru utilizatori (man-manuale, doc, )
/var - conine fiiere pentru tiprire i pota electronic (E-mail)

Pentru a identifica un director in structura arborescenta se utilizaza calea


acestuia, adica drumul parcurs prin arbore, plecand de la radacina si
ajungand la directorul dorit. De retinut este faptul ca in arbore exista un
singur drum posibil de la radacina catre un nod oarecare, acest fapt
prezentand un avantaj important al acestei structuri pentru administrarea
sistemului de fisiere.
In continuare voi prezenta doua moduri de acces la un director, printr-un
exemplu practic:

35

La inceput am incercat sa accesez directorul final plecand din home si


parcurgand directorii unul cate unul, pana am ajuns in cel dorit. Atunci cand
se pleaca dintr-un alt director decat radacina, se numeste o specificare in
mod relativ.
Pentru a ne fi mai usor, o data ajunsi in directorul respectiv, putem cere
calea acestuia prin comanda pwd. De aici am incercat al doilea mod de
specificare: absolut si anume, specificarea caii de acces, plecand din
radacina si pana la nodul dorit. Pentru a economisi timp putem scrie prima
litera a unui nod (sau mai multe, atunci cand trebuie evitata confuzia) si
apasa pe tab pentru ca acesta sa se autocompleteze. Se observa ca in cazul
de confuzie primim indicatie cu numele nodurilor din care putem alege.
Pentru a parcurge arborele in jos, este suficient sa specificam comanda cd
urmata de numele directorului dorit, in schimb, la parcurgerea in sens invers
este necesara mentionarea intregii cai de acces. Exemplu:

Crearea si stergerea unui director: In trecut am mai utilizat instructiunea de


creare, dar niciodata pe cea de stergere. Vom exemplifica aceste doua
instructiuni si vom demonstra ca nu se poate sterge un director decat atunci
cand acesta este gol (este frunza in arbore). Se poate observa mai jos cum
directorul a fost creat si, fiind gol a fost permisa stergerea sa. In schimb, un
director plin nu a putut fi sters:

36

B.3.3 FISIERE SPECIALE

Fiecare dintre echipamantele periferice fizice este identificate cu un fisier


special. Prin aceste fisiere speciale se face legatura dintre functiile
programului de comanda si echipamentele periferice asociate fisierului
special in cauza.
Avantajele acestui mod de a identifica echipamentele cu fisiere sunt:
- ele sunt supuse mecanismului de protective similar cu celelalte fisiere;
- aceleasi comenzi ca si in cazul fisierelor obisnuit se pot folosi si pentru a
face schimbul de date cu perfericele.
Aceste fisiere speciale sunt stocare in directorul /dev. Le vom lista:

37

B.3.4 FISIERE PIPE (FIFO)

Fisierele FIFO sau pipe sunt fisiere tranzitorii, in care datele sunt citite in
ordinea stricta a scrierii lor, respectandu-se regula de sincronizare First
Input First Output -primul intrat primul iesit. Memorarea datelor in fisier se
face ca la orice fisier ordinar, utilizand numai blocurile adresate direct. Dupa
ce au fost citite din fisier, datele nu mai pot fi recitite.
B.3.5 INFORMATII DESPRE UN FISIER

Pentru fiecare fisier (sau director) exista un cuvant de 16 biti in care sunt
memorate informatii despre acesta (tipul, drepturile de acces).
38

biii 0-3 (a-d) indic tipul fiierului;

bitul 4 (e)seteaz identificatorul de utilizator;

bitul 5 (f) seteaz identificatorul de grup;

bitul 6 (g) seteaz swapping (citirea n ntregime, nu pe blocuri);

bitii 7-9 indic drepturile (r, w, x) pentru proprietar;

bitii 10-12 indic drepturile (r,w,x) pentru grup;

bitii 13-15 indic drepturile (r,w.x) pentru restul utilizatorilor.

Folosind comanda $ls l putem vizualiza aceste informatii :

Pe fiecare rand putem observa proprietatile unui fisier, codificate in modul


urmator :
39

Primul caracter : d pentru director si pentru fisier ordinar


Urmatoarele trei sunt rwx permisiuni de citire, scriere si executie pentru
proprietare ; repetandu-se si pentru grup si alti utilizatori. Observam ca in
anumite locuri r, w sau x este inlocuit de o linie (-), indicand faptul ca
aceasta permisiune nu este oferita respectivului tip de utilizator.
In continuare sunt listate celelalte informatii despre fisier (proprietar,
dimensiune, data si ora cand a fost crea, numele fisierului).
B.4 ADMINISTRARE MEMORIE

Sistemul de operare Linux este ajutat in tinerea evidentei memoriei de catre


microprocesorul sau 80x86 prin tehnici de segmentare si paginare a
circuitelor, pentru a traduce adresele logice in adrese fizice.
In ceea ce priveste memoria RAM, o parte din aceasta este rezervata
permanent nucleului si rolul ei este de a pastra codul acestuia si structurile
de date statice ale nucleului.
O data ce aceasta parte a memoriei RAM a fost rezervata, restul de memorie
RAM ramas poarta numele de memorie dinamica. Aceasta este o resursa
foarte importanta a sistemului si este folosita pentru procese, dar si pentru
nucleul insusi.
Deoarece performanta sistemului ca intreg depinde de eficienta cu care
memoria dinamica este utilizata si gestionata, toate sistemele de operare
care au capacitatea de a executa mai multe operatii simultan (multitasking)
trebuie sa optimizeze modul de folosire al acestei resurse de memorie.
Aceasta este atribuita doar atat timp cat este necesar si este eliberata
imediat ce este posibil.
Pentru a afla starea memoriei din sistemul nostrum, folosim comanda free:

40

B.5 PLANIFICARE SI EXECUTIE JOB-URI

Un proces sub sistemul Linux este reprezentat de toate operatiile ce


trebuie sa se desfasoare in timp in scopul satisfacerii cerintelor unui program
ce s-a lansat in executie. Pentru un program in executie pot exista la un
moment dat mai multe procese asociate, numite instante ale acestui
program.
Deoarece sistemul de operare este bazat pe principiul impartirii timpului,
fiecare process este programat sa ruleze pe o anumita perioada de timp,
numita si time slice (felie de timp). Nucleul kernel are rolul de a crea,
gestiona si sterge aceste procese.

41

Primul proces, cel creat la initializarea sistemului, este identificat cu 0. Acest


numar, alocat unui proces se numeste identificator de proces sau pid
(process ID). Urmatoarele numere sunt alocate proceselor in mod crescator.
Toate procesele (cu exceptia celui creat la initializarea sistemului (init)) sunt
create ca rezultat al apelului de tip fork. Acest apel imparte procesulul in
doua: parinte si fiu. Prin executia acestei functii, un proces este creat de
catre un alt proces.
Un proces trece prin mai multe stari:

Crearea procesului
Asteptarea pentru executie
Executia procesului
Terminarea sau anularea executiei procesului

Acestor stari le corespund functiile de sistem: fork, wait, exec si respectiv kill.
Odata ce un proces este creat, acesta primeste starea ready (gata de
executie), fiind in asteptare pentru a intra in starea de run (executie).
Principiul folosit pentru a trece procesele in aceasta stare este numit timesharing si consta in partitionarea timpului unitatii central intre procese dupa
prioritati. Prioritatea proceselor este calculate dinamic, dupa urmatoarea
formula:
Prioritatea procesului = Timpul unitatii central acordat procesului/timpul in
memoria interna pentru proces.

B.6 COMENZI INTERNE SHELL

In prima partea a acestui proiect am studiat in detaliu si printr-o abordare


practica interpretorul de comenzi Shell al sistemului de operare Linux. De
aceasta data ne vom uita la acest subiect dintr-o perspectiva mai teoretica,
dar vom trata in continuare si aspect practice mai complexe care nu au fost
acoperite in cadrul primei parti.

42

Nucleul kernel trateaza acest interpretator de comenzi ca pe orice proces


utilizator neprivilegiat. La deschiderea sesiunii de lucru se lanseaza un
proces shell la terminalul la care lucreaza utilizatorul si asteapta comenzi.
Rulam terminalul si, cu instructiunea top vedem procesele.

Prin comenzi interne intelegem comenzi care sunt executate direct de shell si
nu se invoca nici un alt program in acest proces.
Sintaxa generala a unei comenzi shell:
$ <comanda> [<optiuni>] [<parametric>]

43

Cu alte cuvinte, scriem numele comenzii pe care o dorim executata si apoi,


optional putem adauga optiuni sau parametrii.
Optiunile sunt reprezentate printr-o litera, avand in fata ei semnul + sau -.
Atunci cand vrem sa introducem mai multe, le scriem pur si simplu una dupa
alta, dar fiecare trebuie sa aiba semnul respectiv in fata ei.
De exemplu: doua optiuni (asa cum am vazut mai devreme pentru memorie):

Sau folosirea lui + in loc de -:

pentru adaugarea unei


permisiuni.
La parametric scriem nume de fisiere sau siruri de caractere, asa cum in
exemplu de mai sus avem numele unui fisier asupra caruia se acorda
permisiunea.
Din punctul de vedere al functionalitatii, comenzile Shell pot fi clasificate in
urmatoarele categorii:

Comenzi
Comenzi
Comenzi
Comenzi
Comenzi

pentru informare
pentru gestiunea directoarelor
penru gestiunea fisierelor
pentru gestiunea proceselor
pentru gestiunea volumelor

B.6.1 COMENZI PENTRU INFORMARE

- Cateva comenzi pentru timp:

44

- Alte comenzi: comanda $echo pe care nu o vom mai exeplifica acum, dar a
fost folosita de multe ori pe parcursul acestui proiect; comanda $man
[<comanda>] care afiseaza informatii despre comanda in cauza.
-Exemplu si explicatii pentru who si passwd:

$login deschide o sesiune de lucru sic ere numele utilizatorului si parola


45

$mail emitere/receptive email


$write <utilizator> [<terminal>] transmite un mesaj pe terminalul unui
utilizator conectat

Prima comanda afiseaza numele terminalului; a doua afiseaza caracteristicile


terminalului.
B.6.2 COMENZI PENTRU GESTIUNEA DIRECTOARELOR

Am vazut mai devreme pe larg aceste comenzi si exemplu ale utilizarii lor.
Le vom trece doar rapid in revista:
$pwd afiseaza calea catre directorul curent
$cd [<director>] change directory, schimba directorul curent cu cel
specificat
$mkdir <director> - creaza acel director
$rmdir <director> - sterge acel director (doar daca e gol)
$ls [<optiuni>][<specificator>] listeaza continutul directorului curent
B.6.3 COMENZI PENTRU GESTIUNEA FISIERELOR

$cat [<optiuni>][<specificator>][<redirectare>]
afisare/concatenare/creare de fisiere text

46

$pr [<optiuni>]<specificator>[<redirectare>] listeaza prin paginare (antet


si linii) fisiere text

$lpr [<optiuni>]<specificator> - tiparirea la imprimanta a continutului de


fisiere text
$lp [<optiuni>]<specificator> - tiparirea la imprimanta prin paginare a
continutului unor fisiere
$file <fisier> - determina tipul (sursa, obiect, executabil, text, etc) unui fisier
47

$find <director><conditie> - se caut n directoarele specificate i n


toate subdirectoarele lor, pentru a se localiza toate fiierele ce satisfac
<conditie>
$rm [<optiuni>] <fisier> - sterge fisierele specificate din directorul curent

$cp <fisier> [<director>] realizeaza copierea de fisiere (unul in altul sau


intr-un director asa cum vom vedea in urmatorul exemplu)

48

$mv mutarea (redenumirea) de fisiere (se face in doua feluri: )

49

$chmod <categ_util><operator><drept><fisier> -oferirea sau revocarea de


permisiuni (am studiat indeaproape aceasta comanda mai devreme in acest
proiect)
$diff <optiuni> <fisier1><fisier2> - compara doua fisiere de tip ASCII

$tail [<optiuni>] <fisier> - afiseaza un fragment de la inceputul sau de la


sfarsitul fisierului
$ wc [<optiuni>]<fisier> - afiseaza nr de linii, cuvinte sau caractere din
fisierul specificat

50

B.6.4 COMENZI PENTRU GESTIUNEA PROCESELOR

$ps [<optinui>][<proces>..] afiseaza starile unor procese


$kill [<pid_proces>] terminarea unui proces
$sleep <nr_secunde> - suspenda temporar executia unui proces
$sh <fisier> - lansare in executie a unui fisier de comenzi Shell

$at <timp> [<zi>][+<increment>]<fisier> - lanseaza in executie un


program tinand seama de timpul, ziua specificate
$nice [-n] <comanda>[<argumente>] lanseaza un proces in parallel, cu
prioritate redusa (n e nr de adunat la ordinul de prioritate
51

B.6.5 COMENZI PENTRU GESTIUNEA VOLUMELOR

$df [<fisier_sistem>] indic spaiul liber pe un anumit volum unde este


montat un sistem de fiiere
$du [<optiuni>]<fisier> - afiseaza nr de blocuri alocate pe un volum
B.7 REDIRECTARI

Majoritatea comenzilor trimit output pe ecran sau preiau input de la


tastatura, dar este posibil ca acest output sau input sa fie trimis, respectiv
preluat de pe un fisier.
Pentru a redirectiona catre un fisier se foloseste semnul > inainte de numele
fisierului.
Sintaxa este: Comanda > nume_fisier
Acest tip de comanda nu doar redirectioneaza informatia catre fisier,
concatenand-o la acesta, ci rescrie fisierul cu informatia redirectionata,
originalul fiin pierdut.
Pentru a evita aceasta problema (in cazul in care se doreste), se pot folosi
semnele >>, acestea redirectionand informatia catre sfarsitul fisierului
Sintaxa este similara: comanda >> nume_fisier
Pentru a redirectiona in sens opus, deci pentru a folosi informative preluata
dintr-un fisier folosim semnul invers <
Sintaxa este: comanda < nume_fisier.
Redirectionarile pot fi folosite si simultan. Sa executam cateva exemple:

52

Am adaugat pe rand numele de fructe intr-un fisier, folosind mai intai


rescrierea si apoi concatenarea prin intermediul semnelor >, respectiv >>.
Ulterior, am preluat informatia din primul fisier prin <, am sortat-o prin
comanda sort si am rescris al doilea fisier cu aceasta informative sortata,
totul prin linia $ sort < fi1 > fi2, dovedind ca cele doua tipuri de
redirectionari pot fi executate simultan.

Observam ca functioneaza si in aceasta ordine.


B.8 CONDUCTE

Prin intermediul conductelor putem sa conectam iesirea unui program cu


intrarea unui alt program, fara a folosi un fisier temporar.
53

Pentru a da o definitie: o conducta este doar un loc temporar de stocare, in


care outputul unei comenzi este stocat si apoi transmis ca input unei a doua
comenzi.
Sintaxa
Comanda1 | comanda2
Exemple:

Outputul comenzii ls este dat ca input comenzii more pentru a imprima


outputul pe ecran cate o pagina pe rand.

54

Pentru a printa o lista sortata a userilor, outputul lui who este dat ca input lui
sort. Se poate si redirectiona catre un fisier:

Iesirea lui ls (-l pentru a fi fiecare pe cate o linie) este transmisa ca input
comenzii care Numara numarul de linii, astfel se obtine cate fisiere sunt in
prezent in directorul curent.

BIBLIOGRAFIE

M. Vlada, Sisteme de operare, Universitatea din Bucuresti, tutorial, curs


On line - http://ebooks.unibuc.ro/informatica/Seiso/ (accesat februarie
2014)
Linux Shell Scripting Tutorial v1.05r3 A Beginners handbook (adresa:
http://doc.dev.md/lsst/ - accesat ultima data februarie 2014)
Practical Unix Sam King, Emin Topalovic (adresa:
http://openclassroom.stanford.edu/MainFolder/CoursePage.php?
course=PracticalUnix accesat ultima data februarie 2014)
Linux Kernel Architecture Amir Hossein Payberah
Understanding the Linux Kernel Daniel P. Bovet & Marco Cesati
Anatomy of the Linux Kernel. History and architectural decomposition
M. Tim Jones
Modern Operating Systems (Second Edition) Andrew S. Tanenbaum
Linux Kernel in a Nutshell Greg Kroah-Hartman
Linux Kernel Internals Tigran Aivazian
Understanding The Linux Virtual Memory Manager Mel Gorman

55