Examen Final de SO Grau

Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
Preguntas cortas
1. (0,5 puntos) Asumiendo que ninguna llamada devuelve error, representa las entradas nuevas
de la TFA que aparecerán tras la ejecución del siguiente código:
fork();
mknod(“pipe”, S_IFIFO|0666, 0);
fd0 = open(“pipe”, O_RDONLY);
fd1 = open(“pipe”, O_WRONLY);
2. (0,5 puntos) ¿Puede darse el caso que un proceso no pueda mutar porque el sistema se quede
sin PCBs?
1
Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
3. (0,5 puntos) ¿Qué es la memoria virtual?
4. (0,5 puntos) Tenemos una aplicación formada por dos procesos: uno ejecuta el típico código
del productor de datos y otro el de consumidor de datos. Los dos procesos tienen una región
de memoria compartida para poner las variables que necesitan compartir.
//memoria compartida entre los dos procesos
fd=open(”FUENTE”,O_RDONLY);
while (true) {
read(fd,&data_in,sizeof(data));
while (count == BUFFER_SIZE);
buffer [in] = nextProduced(data_in);
in = (in + 1) % BUFFER_SIZE;
count++;
}
fd=open(“DESTINO”,O_WRONLY|O_CREAT|O_TRUNC, 0600);
while (true) {
while (count == 0) ;
nextConsumed = buffer[out];
data_out=Calcula(nextConsumed);
write(fd,&data_out,sizeof(data));
out = (out + 1) % BUFFER_SIZE;
count--;
}
a) Indica qué problema aparece típicamente cuando utilizamos memoria compartida entre
varios procesos que acceden para lectura y escritura.
2
Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
b) ¿Qué variables haría falta declarar en la zona de memoria compartida? ¿Qué variables
pueden causar los problemas descritos en el apartado anterior?
c) Indica al menos una solución para este tipo de problemas y explica brevemente como
funciona.
3
Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
Problemas
1. (2 puntos) Dado el siguiente código:
main (){
int pid, int i;
int nhijos = 0;
int valor;
char buffer[80);
for (i=0; i<3;i++)
pid=fork();
}
sprintf(buffer, “Valor pid: %d, mi pid: %d\n”, pid, getpid());
write(1,buffer,strlen(buffer));
while (wait(&valor) >0) {
nhijos++;
}
sprintf(buffer, “Hijos acabados: %d\n”, nhijos);
write(1,buffer,strlen(buffer));
}
a) Representa el árbol de procesos que crea. Asigna a cada proceso un identificador
cualquiera para poderlo utilizar en las siguientes preguntas.
4
Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
b) Escribe el/los mensaje/s que mostrará cada proceso en salida estándar indicando el
identificador del proceso que escribe el mensaje y el contenido exacto del mensaje.
Para ello utiliza los identificadores que has asignado en el apartado anterior.
c) ¿Existe algún conflicto en el uso de la variable nhijos? Si en lugar de ser una variable
local fuera global, ¿habría algún conflicto?
5
Examen Final de SO Grau
Nombre alumno:
DNI:
2.
Fila,columna:
(3 puntos) Tenemos el siguiente código en el que dos procesos se comunican mediante una
pipe con nombre llamada “mipipe”:
main (){
int fd,pid_h,ret,valor;
char buffer[80];
char msg[80];
fd=open(“mipipe”,O_RDWR);
if (fd<0){
perror(“Error abriendo la pipe”);
exit(1);
}
pid_h = fork();
if (pid_h < 0) {
perror(“Error creando proceso”);
exit(1);
}
sprintf(buffer,”Hola, soy %d\n”,getpid());
if (pid_h == 0){
ret=read(fd,msg,sizeof(msg));
msg[ret]=’\0’;
write(1, msg, strlen(msg));
write(fd,buffer,strlen(buffer));
exit(0);
}
write(fd,buffer,strlen(buffer));
ret=read(fd,msg,sizeof(msg));
msg[ret]=’\’0’;
write(1,msg,strlen(msg));
wait(&valor);
}
El objetivo es que el proceso padre envíe por la pipe un mensaje con su pid a su hijo y a
continuación reciba por la pipe un mensaje con el pid del hijo. Por su parte el hijo está a la espera
de recibir el mensaje con el pid del padre y a continuación envía el suyo por la pipe. Padre e hijo
mostrarán por salida estándar el mensaje que cada uno ha recibido por la pipe. Podéis suponer
que la pipe está creada con antelación y con los permisos adecuados.
a) ¿Los mensajes enviados a través de las pipes son los que se esperan?
6
Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
b) ¿Se puede garantizar que el resultado será el esperado? ¿Por qué? ¿Qué otro
comportamiento podemos tener? Propón y describe dos soluciones diferentes para
garantizar que el resultado será siempre el descrito en el enunciado.
c) Si en lugar de utilizar una pipe con nombre se utilizara una pipe sin nombre, ¿afectaría de
alguna manera al resultado?
d) Modifica el código para que se utilicen pipes sin nombre y el resultado sea siempre el
descrito en el enunciado.
7
Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
3. (3 puntos) Tenemos la siguiente lista de Inodos y bloques de un sistema de ficheros basado en
UNIX. Los Inodos 9 y 10 están libres, así como el bloque 9.
Inodo
2
3
4
5
6
7
8
Tipo
dir
dir
dat
dat
dir
dir
Link
Bloques
2
3
5
6
7
4
8
#ref
5
2
1
1
2
2
2
9
10
Bloques
2
3
4
5
.
2
.
3
.
7
..
2
..
2
..
2
A
3
a
4
c
8
B
6
b
8
C
7
8
ABCDEFG
HIJKLMN
OPQRSTU
VWXYZ
6
4
2
7
7
8
.
6
..
2
e
5
/B/e
9
Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
a) Dibuja el grafo de directorios.
b) Indica qué actualizaciones se producirán tanto en los Inodos como en los bloques
mostrados en el enunciado si ejecutamos las siguientes líneas de comandos (NOTA:
“wc –c” devuelve por la salida estándar el número de caracteres que lee por la entrada
estándar):
> ls / > /C/d
> cat /A/b | wc –c >> /C/d
Inodo
2
3
4
5
6
7
8
dir
dir
dat
dat
dir
dir
Link
Bloques
2
3
5
6
7
4
8
#ref
5
2
1
1
2
2
2
Tipo
9
10
Bloques
2
9
3
4
5
.
2
.
3
.
7
..
2
..
2
..
2
A
3
a
4
c
8
B
6
b
8
C
7
ABCDEFG
HIJKLMN
OPQRSTU
VWXYZ
6
4
2
7
7
8
.
6
..
2
e
5
/B/e
9
Examen Final de SO Grau
Nombre alumno:
DNI:
Fila,columna:
c) Describe qué accesos a disco se hacen al ejecutar la siguiente secuencia de sentencias,
asumiendo que no hay buffer cache. Puedes asumir que el superbloque está cargado
en memoria y que cada I-nodo tiene el tamaño de un bloque.
main(){
int fd;
int ret;
char c;
fd = open(“/A/b”,O_RDONLY);
ret = read(fd,&c,sizeof(c));
while (ret > 0){
write(1, &c, sizeof(c));
ret = read(fd,&c,sizeof(c));
}
close(fd);
}
10