PR 01 09 10

SO2 Sistemes operatius II
Sistemes Operatius II
curs 2009-2010
Pràctica 1: microshell
Equip de Sistemes Operatius

DISCA /DSIC
Universitat Politè
Politècnica de Valè
València
Calendari de pràctiques
Un grup de pràctiques:
– Dilluns de 19:30 a 21:30
Sistemes operatius II
Calendari de pràctiques:
– 22/02: Introducció.
– 01/03: Inici Bloc I.
– 08/03
– 15/03
– 22/03
– 29/03: Fi Bloc I. ENTREGA DE LA MICROSHELL.
– 26/04: Inici Bloc II.
– 03/05
S02
– 10/05
– 17/05: Fi Bloc II.
Tema: Presentació microshell 2
1
Pràctica 1: Microshell
Índex:
– Introducció.
– Característiques d’un shell.
– Sintaxis del microshell.

– Descripció modular.
– A nnex 1: Punters i vectors en C.
– Annex 2: Eina make.
Bibliografia:
– Kay A. Robbins, Steven Robbins: "UNIX Programación Práctica. Guía para la
concurrencia, la comunicación y los multihilos", Ed. Prentice-Hall
Hispanoamericana, México, 1997, 674 pàg., ISBN 968-880-959-4
– B. W. Kernighan, R. Pike, “ El entorno de programación UNIX”, Prentice Hall.
Ed. en castellano, 1987.
S02
Webs amb informació de l’assignatura

– http://www.upv.es/poliformat
– http://hpurcell.alc.upv.es/pub/so2
– màquina disponible per a connexions remotes: aludisca.alc.upv.es
Introducció.
Característiques d’un shell
Sintaxi del microshell

Descripció modular
Annex 1: punters i vectors en C
Annex 2: eina make
S02
2
1. Introducció
Objectius
– Programació d’un shell utilitzant cridades al sistema
– Es pretén obtenir experiència pràctica en :
gestió de processos
readreçaments i tubs
senyals
Planificació (6 sessions)
setmana 1 Introducció a la pràctica (22/02)
setmana 2 Realització del bucle principal (01/03)
setmana 3 Implementació del readreçament i tubs (08/03)
setmana 4 Mòdul d’execució d’ordres (15/03)
S02
setmana 5 Completar mòdul d’execució i tractament de senyals (22/03)

setmana 6 Ampliacions i revisió de treballs (29/03)
Introducció.

Descripció modular
Annex 2: eina make
S02
3
2. Característiques d’un shell
Concepte
– És la interfície primària entre l’usuari i el sistema operatiu (en mode caràcter)
– És un programa que llig una ordre (o un fitxer amb múltiples ordres),
l’analitza i l’executa
– Realitza les cridades al sistema que són necessàries per a executar una ordre.
Interfície usuari
Entorn de finestres
Shell Programes
(KDE, Gnome)
Interfície cridades al sistema
Protocols
Fitxers
Processos xarxa
S02
Mem.
Programes de control (drivers)
virtual
Interfície maquinari-programari
CPU Memòria E/S Xarxa
Ordres internes i externes

– Internes: estan implementades al mateix shell:
$ PATH=/usr/bin:/bin
$ cd ..
$ cd $HOME
– Externes: estan implementades en programes independents
el shell s’encarrega de buscar el programa i executar-lo passant els arguments
corresponents.
$ ls -la
$ ps
S02
$ mv fic.txt fich2.txt
$ grep hola f1
4
Readreçaments
$ cat f1 > f2
$ ls -la >> fitxers

$ wc < fitxers
Tubs (pipes)
$ ls -la | more
$ ls -la | grep old | wc -l > resultado
Execució en background
S02
$ gcc programa.c &

Variables
$ NOMBRE=pepe
$ PATH=$PATH:$HOME/bin
$ unset NOMBRE
$ export PATH
$ echo $PATH
Control de flux
$ for k in *
> do
> cp $k $k.bak
S02
> echo Còpia creada de $k

> done
5
Introducció.

Descripció modular
Annex 2: eina make
S02
3. Sintaxis de la microshell
Sintaxi de les característiques mínimes requerides en la pràctica

– <ordre> ::= programa { argument }
– <línia> ::= ordre [< fitxer] {¦ ordre } [>|>> fitxer] [&]
Exemples vàlids
$ ls –la
$ cat f1 > f2
$ ls -la > fitxers
$ wc < fitxers
$ ls -la | sort
$ ls -la | grep old | wc -l > resultat
S02
$ tail -3 < sortida.dat | sort >> resultat &

$ cat < fitxers | grep old | sort > resultat &
6
3. Sintaxis de la microshell
Característiques opcionals a implementar:

– Ordres internes.
$ cd /etc/usr/PEPE
$ cd ..
$ exit
– Versió no interactiva (permet executar l’ordre directament)
$ ush -c ls -la
$ ush -c gcc programa.c –o programa
S02
Introducció.

Descripció modular
Annex 2: eina make
S02
7
4. Descripció modular
analizador.h/.c
int analizar(char *s);
Descomposició modular
Funcions Consulta {
num_ordenes, get_ordenes,
defines.h num_argumentos, get_argumentos,
fich_salida, fich_entrada,
MACROS (màxims, etc.) es_append, es_background }

char *error_sintactico();
redireccion.h/.c
ush.c int pipeline(...);
int redirigir_entrada(int i);
int redirigir_salida(int i);
int main(...) { int cerrar_fd(void);
}
ejecucion.h/.c
S02
int ejecutar (paràmetres...);
ush.c
Bucle principal
int main(...) {
…
while (TRUE) {
Llegir línia del teclat int leerLinea(...)
Analitzar línia int Analizar(char * Linea)
Readreçar E/S tubs int pipeline(...)
Executar int Ejecutar(...)

S02
}
…
}
8
Funcions mòdul analitzador (I)

– void analizador_ini(void);
Inicialitza l’analitzador
– int analizar (char *s);

Analitza una ordre segons la sintaxi descrita.
Retorna OK si és sintàcticament correcta o ERROR si hi ha error.
– int num_ordenes (void);
Nombre d’ordres analitzades en l’ordre analizar
– char **get_ordenes (void);
Torna un vector amb les ordres analitzades en l’ordre analizar
– int *num_argumentos (void);
Torna un vector d’enters amb el nombre d’arguments de cada ordre
– char ***get_argumentos (void);
S02
Matriu de cadenes amb els arguments
Funcions mòdul analitzador (II)

– char *fich_salida (void); char *fich_entrada (void);
Tornen el fitxer d’eixida i entrada respectivament.
– int es_append (void);

Indica si l’eixida ha de ser afegida al fitxer (>>)
– int es_background (void);
Indica si les ordres analitzades s’han llançat en background (&)
– char *error_sintactico (void);
Torna una descripció de l’error sintàctic produït en analitzar
S02
9
Funcions mòdul readreçament
– void redireccion_ini(void);
Inicialitza el readreçament.
– int pipeline (int ncmd, char * infile, char * outfile, int append, int bgnd);
Crea els tubs necessaris (n-1) per a executar n ordres en tub i readreça la
STD_INPUT i STD_OUTPUT d’un procés. Han d’especificar-se
readreçaments d’entrada, d’eixida i background.
Paràmetres
– ncmd: nombre d’ordres del pipe.
– infile: fitxer on es readreça la STD_INPUT.
– outfile: fitxer on es readreça la STD_OUTPUT.
– append: (TRUE o FALSE) indica si, al fitxer al qual es readreça l’eixida
estàndard, se li afegeix l’eixida al final o ha de ser sobreescrit.
– bgnd: (TRUE o FALSE) indica si la instrucció s’executa en mode background.
– int redirigir_entrada(int i);
Readreça STD_INPUT del procés i al descriptor fd del tub/fitxer
corresponent del tub.
S02
– int redirigir_salida(int i);

Redirigeix la STD_OUTPUT del procés i al descriptor fd del tub/fitxer
corresponent del tub.
– cerrar_fd(void);
Tanca els descriptors fd dels tubs creats amb pipeline.
Funcions mòdul executar

– int ejecutar (int nordenes , int *nargs , char **ordenes , char
***args , int bgnd);
Crea els processos per a executar l’argument especificat en

"ordenes".
Paràmetres
– nordenes: nombre d’ordres del tub que es vol executar.

– nargs: vector amb el nombre d’arguments de cada ordre.
– ordenes: vector de cadenes amb el nom de les ordres.
– args: matriu de cadenes amb els arguments de cada ordre,
és a dir, en la posició (i,0) es troba l’ordre i-èsima, i en la
posició (i,n) amb n>0 es troba l’argument n de la posició i-
èsima.
– bgnd: (TRUE o FALSE) indica si la instrucció s’executa en
S02
mode backgroung.
Retorna OK si s’ha executat correctament.
10
Introducció.
Sintaxis del microshell

Descripció modular
Annex 2: eina make
S02
A1: Punters i vectors en C
Vectors (arrays)
– Un vector és una variable indexable que conté molts objectes (anomenats
elements) d’un mateix tipus que s’emmagatzemen consecutivament en
memòria.
– Els elements estan indexats des de 0 fins n-1
int B[10];
int N[5] = { 5, 25, 12, 2, 8 } 500 504 508 512 516
int a,b;
a = N[2]; // a és 12 5 25 12 2 8 ... ...
N[2] = 4; // Es modifica 3r element 4
N[0] N[1] N[2] N[3] N[4]
b = N[3]*N[3]; // b val 4
b = N[10]; // Error!!! en execució
– Vectors multidimensionals
S02
300 308 316 324 332 34O 348

float v[2][3] ={1, 2, 3, 4, 5, 6 };
char c2[2][3]; 1 2 3 4 5 6 ...
float v12 = v[1][2]; // v12 val 6.0 v[0][0] v[0][1] v[0][2] v[1][0] v[1][1] v[1][2]
11
Punters
– Un punter és una variable que conté l’adreça d’un altre objecte.
– Es defineix com a tipus *nom
– L’operador & obté l’adreça d’una variable.

– Es denomina indirecció tornar la dada apuntada pel punter (operador *)
– La declaració int N[] és equivalent a int *N;
– Exemple: (Compilador assigna memòria a partir pos. 500)
int b; Adreça variable x (&x) = 504.

int x = 12; Contingut variable x=12.
Dirección (ìnt=4 bytes)
int *p;
int N[3] = { 1, 2, 3 }; 500 504 508 512
char *p c; // Punter a caràcter ... ... 12 10 ... 1 2 3
S02
p = &x; // p val 504 (apunta

p apunta a xa (direcció
x) 504)
b = *p; // Indirecció: b Es
= modifica
12 a 10 b x *p N
*p = 10; // Modifica contingut de x
p = N; // p apunta a N

Cadenes (strings)
– Una cadena és un array de caràcters, l’últim element del qual conté el
caràcter nul ‘\0’.
– Per a treballar amb cadenes s’usen les funcions de strings (strcpy, strlen,
etc.).
– Exemples
char *Nombre = “PEPITO PEREZ”;
char Nombre2[20]; Nombre[2]
char c;
Nombre
char *p;
c = Nombre[2]; // c vale ‘P’
p = Nombre // p apunta a Nombre
c = p[4]; // c vale ‘T’ P E P I T O P E R E Z \0
strcpy(Nombre2, Nombre);
S02
p[4]
p
12
Aritmètica de punters
– C permet realitzar diverses operacions amb variables punters
– Operadors increment/decrement (++/--).
– Suma i resta (desplaçament de la posició)

– El desplaçament és sempre del tipus al que apunta la variable
– Exemples:
int Datos[5] = {1,2,3,4,5};
int *p;
Datos+2
int i;
int b; Datos
p = Datos; // p apunta a Datos (500)
p = Datos+2; // p apunta al 3r element (508) 500 504 508 512 516
for (i = 0; i < sizeof(Datos); i++) { 1 2 3 4 5 ... ...
S02
printf(“Datos[%u]=%u”, i, Datos[i]);
printf(“Datos[%u]=%u”, i, *p++);
}
p
Una altra classe de punters

– Punter genèrics: el seu tipus és void i poden apuntar a qualsevol tipus de
dades
– Punter nul: és una variable punter, el valor de la qual és 0 (s’usa NULL)

El valor NULL s’usa per a indicar que s’ha produït algun error o,
El punter no apunta a cap dada.
– Exemples:
void *v;
int i[10];
int a;
v = i;
a = (int)v; // S’ha de fer càsting
v = malloc(100000000); // Segurament dóna error
S02
if (v == NULL) exit(-1);
13
Vectors de punters a cadenes

– És un vector els elements del qual són punters a cadenes
– Les cadenes apuntades han d’existir o bé cal crear espai per a aquestes.
Estàticament (definint variables ) o dinàmicament (per exemple amb malloc)
char *cad[5] = { NULL, NULL, NULL, Nombre1

NULL, NULL}; Nombre2
char Nombre1[] = “Pepito”;
char Nombre2[] = “Pablo”; 0 P E P I T O \0
cad[0]
char *p;
cad[0] = Nombre1;. . 0
cad[2] = Nombre2; . cad[2] 0 P A B L O \0
p = malloc(10); 0
strcpy (p, “David”); cad[4]
S02
cad[4] = p; 0 D A V I D \0
p

argumentos[0][0] = “ls”;
Exemples de les estructures del sh argumentos[0][1] = “-la”
argumentos[1][0] = “sort”;
– Exemple: ls -la | sort | wc -l > resultado
argumentos[2][0] = “wc”;
argumentos[2][1] = “-l”;
int num_ordenes;
int *num_argumentos; char ls
char **ordenes; *
char sort
*
char ***argumentos; char
* wc
char *fich_entrada, *fich_salida; 2
1
num_ordenes = num_ordenes(); 3 2
..
ordenes = get_ordenes(); char **
. = num_argumentos();
num_argumentos int *
char ls
*
char -la
char **
argumentos = get_argumentos(); char *** *
S02
char **
char sort
char ** *
fich_entrada = fich_entrada(); ““ char wc
fich_salida = fich_salida(); “resultado” * -l
char
*
14
Introducció.
Sintaxis del microshell

Descripció modular
Annex 2: eina make
S02
A2: Eina make
Descripció
– L’eina make ajuda a automatitzar la compilació i el muntatge;
– make comprova l’instant de modificació de cada fitxer, i + els fitxers

necessaris de forma selectiva.
– Per a poder realitzar la funció esmentada, utilitza un fitxer de

configuració anomenat makefile, que descriu l’estructura del
programa (mòduls, dependències entre mòduls i com construir
l’executable final)
S02
15
A2: Eina make
Fitxer de configuració (makefile)

– Sintaxi
REGLA -> objectiu: dependències
(TABULADOR)ordres
– Exemple: Dependències
prog: data.o main.o io.o
gcc data.o main.o io.o -o prog
data.o: data.c data.h
Objectiu gcc -c data.c
main.o: data.h io.h main.c Ordres
gcc -c main.c
io.o: io.h io.c
S02
gcc -c io.c
A2: Eina make
Invocació del make

– Sintaxi:
make [-f makefile][-bBdeiknpqrsSt][macro nombre=valor][nombres]

– Exemples:
make
(usa el fitxer makefile –o Makefile-, construeix el primer objectiu del mateix)
make x
(usa el fitxer makefile, construeix l’objectiu x )
make –f mf
(en lloc d’usar el fitxer makefile, usa el fitxer mf)
make –f mf x
S02
(usa mf en lloc de makefile, construeix l’objectiu x)
16

PR 01 09 10

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

PR 01 09 10

Uploaded by

Copyright:

Available Formats

SO2 Sistemes operatius II

Equip de Sistemes Operatius

Tema: Presentació microshell 2

– Sintaxis del microshell.

Webs amb informació de l’assignatura

Sintaxi del microshell

Tema: Presentació microshell 4

setmana 5 Completar mòdul d’execució i tractament de senyals (22/03)

Tema: Presentació microshell 5

Sintaxi del microshell

Tema: Presentació microshell 6

2. Característiques d’un shell

Ordres internes i externes

$ ls -la >> fitxers

$ gcc programa.c &

Tema: Presentació microshell 9

2. Característiques d’un shell

> echo Còpia creada de $k

Sintaxi del microshell

Tema: Presentació microshell 11

Sintaxi de les característiques mínimes requerides en la pràctica

$ tail -3 < sortida.dat | sort >> resultat &

Tema: Presentació microshell 12

Característiques opcionals a implementar:

Tema: Presentació microshell 13

Sintaxi del microshell

Tema: Presentació microshell 14

MACROS (màxims, etc.) es_append, es_background }

int ejecutar (paràmetres...);

Tema: Presentació microshell 15

Llegir línia del teclat int leerLinea(...)

Analitzar línia int Analizar(char * Linea)

Readreçar E/S tubs int pipeline(...)

Executar int Ejecutar(...)

Tema: Presentació microshell 16

Funcions mòdul analitzador (I)

– int analizar (char *s);

Matriu de cadenes amb els arguments

Tema: Presentació microshell 17

Funcions mòdul analitzador (II)

– int es_append (void);

Tema: Presentació microshell 18

– int redirigir_salida(int i);

Funcions mòdul executar

Crea els processos per a executar l’argument especificat en

– nordenes: nombre d’ordres del tub que es vol executar.

Tema: Presentació microshell 20

Sintaxis del microshell

Tema: Presentació microshell 21

A1: Punters i vectors en C

300 308 316 324 332 34O 348

– L’operador & obté l’adreça d’una variable.

int b; Adreça variable x (&x) = 504.

p = &x; // p val 504 (apunta

A1: Punters i vectors en C

Tema: Presentació microshell 24

– Suma i resta (desplaçament de la posició)

A1: Punters i vectors en C

Una altra classe de punters

– Punter nul: és una variable punter, el valor de la qual és 0 (s’usa NULL)

Tema: Presentació microshell 26

Vectors de punters a cadenes

Estàticament (definint variables ) o dinàmicament (per exemple amb malloc)