Primer Certamen ELO321 10/10/2017

Teoría de Sistemas Operativos

Nombre: ...............................Pauta............................... RUT:................................

Parte I (20 puntos)

(Correcta 2 punto, incorrecta -0,5, omitida 0 punto)

1. La interfaz del sistema operativo del usuario:

a) A veces implementado en kernel

b) Se implementan múltiples interpretes que se conocen como – shell
c) Se implementa la mayoría de los comandos a través de una serie de programas de sistema
d) Todas las anteriores

2. Métodos generales utilizados para pasar parámetros al sistema operativo:

a) Parámetros almacenados en un bloque, o tabla, en memoria y parámetros colocados o
empujados en la pila por el programa.
b) Simplest, pasa los parámetros en los registros y parámetros colocados o empujados en la
pila por el programa.
c) Simplest, pasa los parámetros en los registros; parámetros almacenados en un bloque, o
tabla, en memoria y parámetros colocados o empujados en la pila por el programa.
d) Simplest, pasa los parámetros en los registros y parámetros almacenados en un bloque, o
tabla, en memoria.

3. La visión de la mayoría de los usuarios del sistema operativo se define por:

a) La Interfaz del sistema operativo GUI.
b) Los programas del sistema, no las llamadas reales del sistema
c) Las llamadas reales del sistema, no los programas del sistema.
d) La Interfaz del sistema operativo CLI.

4. Cuál de los siguientes estados no corresponde a un estado de un proceso:

a) running
b) new
c) stoping
d) waiting

5. El programa de sistema en lunix que permite visualizar el estado de los socket del equipo
es:
a) ls
b) ps
c) top
d) netstat.
 Primer Certamen ELO321 10/10/2017
Teoría de Sistemas Operativos
Nombre: ...............................Pauta............................... RUT:................................

6. Un socket:

a) Es un punto final para la comunicación.

b) Para la comunicación se utiliza un solo socket.
c) Solo necesita la ip del equipo para establecer la comunicación.
d) Ninguna de las anteriores.

7. El Planificador de procesos:

a) Selecciona entre los procesos disponibles para la siguiente ejecución en la CPU

b) Mantiene una sola cola para todos los procesos.
c) Proporcionar un ambiente conveniente para el desarrollo y ejecución de programas.
d) Muestra la lista de procesos activos.

8. En la creación de un proceso se puede hacer uso de la llamada a sistema fork():

a) Los padres y los hijos ejecutan en forma secuencial.

b) Los padres y los hijos ejecutan simultáneamente.
c) Hijo no es el duplicado del padre.
d) El padre solo puede crear un solo hijo.

9. Las llamadas a sistema:

a) Solo el sistema operativo las puede realizar.

b) El usuario accede en forma directa.
c) selecciona entre los procesos disponibles para la siguiente ejecución en la CPU.
d) Se accede principalmente a los programas a través de una API.

10. Los programas de aplicación:

a) Pertenecen al sistema.
b) Ejecutados por kernel.
c) No suelen considerarse parte del SO.
d) Conocidos como servicios, subsistemas y demonios.
 Primer Certamen ELO321 10/10/2017
Teoría de Sistemas Operativos
Nombre: ...............................Pauta............................... RUT:................................

Verdadero o Falso (10 puntos)

(Correcta 1 punto, incorrecta -1, omitida 0 punto)

1. __F__ Pipes ordinarios (sin nombre) se puede acceder sin una relación padre-hijo.
2. __F__ La comunicación utilizando sockets es unidireccional.
3. __V__ Los sistemas operativos proporcionan un entorno para la ejecución de programas,
servicios a programas y usuarios.
4. __F__ Muchos sistemas ahora incluyen solo interfaces GUI.
5. __F__ Los procesos son iguales a los hilos.
6. __V__ Una llamada a sistema permite el control de los procesos y también la gestión de los
dispositivos.
7. __F__ Proceso se convierte en programa cuando el archivo ejecutable se carga en la
memoria.
8. __V__ Para la comunicación entre procesos los principales problemas son Proporcionar un
mecanismo que permita a los procesos del usuario sincronizar sus acciones cuando tengan
acceso a la memoria compartida.
9. __V__ La creación de hilos es más ligera que los procesos.
10. __V__ Una llamada a sistema accede principalmente a los programas a través de una
Interfaz de Programación de Aplicación (API)

Parte II (10 Puntos)

¿Qué es el Bloque de control de procesos (PCB)? Indique al menos tres datos que se almacenan
en este.

Respuesta:
Bloque de Control de Proceso (PCB) es una estructura de datos bastante grande que
almacena datos de los proceso que se crean.
• Estado del proceso: en ejecución, en espera, etc.

• Contador de programa - ubicación de la instrucción para ejecutar siguiente.

• Registros de la CPU - contenido de todos los registros centrados en el proceso.

• Información de programación de la CPU: prioridades, programación de punteros de cola

• Información de gestión de memoria: memoria asignada al proceso.

• Información de contabilidad - CPU utilizada, tiempo de reloj transcurrido desde el inicio, límites de
tiempo.

• Información de estado de I/O - Dispositivos de I/O asignados al proceso, lista de archivos abiertos.
 Primer Certamen ELO321 10/10/2017
Teoría de Sistemas Operativos
Nombre: ...............................Pauta............................... RUT:................................

Parte III (20 puntos)

Haciendo uso de las llamadas a sistema: fork y waitpid genere el código en C para que el
proceso padre cree dos proceso hijos y espere el término de la ejecución de estos.
Solución:
#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc, char *argv[])

{
pid_t pid1, pid2;
int status1, status2;
pid1=fork();
if (pid1 < 0) { /* se produce un error */
fprintf(stderr, "Error fork\n");
return 1;
}
else if (pid1 == 0 ) { /* hijo */
printf("Soy el primer hijo (%d, hijo de %d)\n", getpid(), getppid());
}
else
{ /* padre */
pid2=fork();
if (pid2 < 0) { /* se produce un error */
fprintf(stderr, "Error fork\n");
return 1;
}
else if (pid2 == 0 ) { /* segundo hijo */
printf("Soy el segundo hijo (%d, hijo de %d)\n", getpid(), getppid());
}
else { /* padre */
/* Esperamos al primer hijo */
waitpid(pid3, &status3, 0);
/* Esperamos al segundo hijo */
waitpid(pid2, &status2, 0);
printf("Soy el padre (%d, hijo de %d)\n", getpid(), getppid());
}
}
return 0;
}
 Primer Certamen ELO321 10/10/2017
Teoría de Sistemas Operativos
Nombre: ...............................Pauta............................... RUT:................................

Parte IV (40 puntos)

Para el código entregado se solicita: #include <stdio.h>

#include <string.h>
a) Completar los bloques de comentarios
(/*…..*/ )que existen en el código. (10 puntos) /* */
#define READ 0
b) Muestra la salida por consola de la ejecución /* */
del código. (5 puntos) #define WRITE 1

c) Agregue frases explicativas en cada printf char *phrase = "Primer Certamen Teoría de
que aparece en el código. (5 puntos) Sistemas Operativos ELO321";

d) Agregue código necesario para realizar una main () {

comunicación bidireccional del string “phrase” /* */
entre padre e hijo. (20 puntos) int fd[2], bytesRead;

/* */
char message [100];

pipe ( fd ); /* */

if ( fork ( ) == 0 ) {
/* */
close (fd[READ]); /* */
/* */
write (fd[WRITE], phrase, strlen ( phrase) +1);
close (fd[WRITE]); /* */
printf("%s\n", phrase); }
else {
/* */
close (fd[WRITE]); /* */
/* */
bytesRead = read ( fd[READ], message, 23);
printf ( "%d : %s\n", bytesRead, message);
close ( fd[READ]); /* */

}
}
 Primer Certamen ELO321 10/10/2017
Teoría de Sistemas Operativos
Nombre: ...............................Pauta............................... RUT:................................

Solución:
b) Primer Certamen Teoría de Sistemas Operativos ELO321
23 : Primer Certamen Teoría

#include <stdio.h>
#include <string.h>

/* Indice de "Lectura" del extremo del pipe */ (a)

#define READ 0

/* Indice de "Escritura" del extremo del pipe */(a)

#define WRITE 1

char *phrase = "Primer Certamen Teoría de Sistemas Operativos ELO321";

main () {
/* Arreglo de dos entero para descriptor del pipe para la comunicación del hijo al padre y variable
para bytes leidos */(a)
int fd[2], bytesRead;
/* Arreglo de dos entero para descriptor pipe del padre al hijo */
int fd1[2]; (d)
char message [100]; /* Parent process message buffer */(a)

pipe ( fd ); /*Se crea el pipe comunica hijo al padre*/(a)

pipe ( fd1 ); /*Se crea el pipe comunica padre al hijo*/(a)

if ( fork ( ) == 0 ) {
/* Proceso hijo */(a)
close (fd[READ]); /* Cierra lectura del pipe*/(a)
write (fd[WRITE], phrase, strlen ( phrase) +1); /* Escribe el mensaje*/(a)
close (fd[WRITE]); /* Cierra escrituta del pipe*/(a)
printf("Mensaje enviado al padre %s\n", phrase);

close (fd1[WRITE]); /* Cierra la escritura del pipe*/(d)

/* Lectura del Mesaje enviado por el padre*/(d)
bytesRead = read ( fd1[READ], message, 100);(d)
printf ( "Cantidad de bytes recibidos: %d ,Mensaje recibido por el hijo: %s\n", bytesRead,
message); (d)
close ( fd1[READ]); /* Cierrea lectura del pipe */ (d)
 Primer Certamen ELO321 10/10/2017
Teoría de Sistemas Operativos
Nombre: ...............................Pauta............................... RUT:................................

} else {

/* Proceso padre */(a)

close (fd[WRITE]); /* Cierra la escritura del pipe*/(a)
/* Lectura del Mesaje enviado por el hijo*/(a)
bytesRead = read ( fd[READ], message, 23);
printf (" Cantidad de bytes recibidos: %d ,Mensaje recibido por el padre : %s\n", bytesRead,
message); (c)
close ( fd[READ]); /* Cierrea lectura del pipe */(a)

close (fd1[READ]); /* Cierra lectura del pipe*/(d)

write (fd1[WRITE], phrase, strlen ( phrase) +1); /* Escribe el mensaje*/(d)
close (fd1[WRITE]); /* Cierra escrituta del pipe*/(d)
printf("Mensaje enviado al hijo %s\n", phrase);(d)

}
}