Examen de Laboratorio de Sistemas Operativos. Primera Convocatoria. 2007/2008. Tercero Ingeniería Informática. Apellidos: 18 de Junio de 2008

Transcripción

1 [Cuestión 1.] Resuelva con una línea de comandos UNIX las siguientes tareas: Apartado a.- Compile y enlace en una única instrucción los archivos de código C principal.c, funciones.c y procesos.c. Como resultado se deberá generar un archivo ejecutable cuyo nombre será programa1. gcc principal.c funciones.c procesos.c o programa1 Apartado b.- Borre el grupo de semáforos cuyo identificador es el ipcrm s 2008 Apartado c.- Obtenga un listado de todos los sockets de tipo UNIX que hay actualmente en el sistema y añádalos al final del fichero sock_un_log.txt. ls lr / grep ^s >> sock_un_log.txt Apartado d.- Liste todos los archivos regulares del directorio actual que tengan al menos permiso de lectura y escritura para el propietario. ls l grep ^-rw Puntuación: 2 ptos. Tiempo estimado: 5 min. 1

2 2

3 [Cuestión 2.] Realice un programa en C, recorrido, que en ejecución resulte en la creación de tres procesos, un proceso padre y dos procesos hijos (procesos A y B). El programa recibirá como argumento la ruta de un directorio que deberá ser recorrido por el proceso hijo A. Para cada entrada de directorio, el proceso A enviará al proceso B la ruta de la entrada de directorio leída. El proceso hijo B, por su parte, deberá comprobar si dicha entrada de directorio es un fichero regular con permiso de escritura para el propietario e informar al proceso A de ello. En concreto, el proceso B enviará al proceso A la señal SIGUSR1 en caso de que la entrada de directorio cumpla los criterios especificados y la señal SIGUSR2 en caso contrario. Note que el proceso A deberá mostrar por pantalla un mensaje informando, para cada entrada de directorio, su ruta y si ésta cumple los criterios especificados. Al finalizar el recorrido del directorio, el proceso A enviará la cadena FIN al proceso B y ambos terminarán. La Figura 1 muestra un esquema del funcionamiento del programa: Padre A B SIGUSR1 SIGUSR2 Figura 1. Esquema de funcionamiento del programa recorrido La Figura 2 muestra un ejemplo del programa en ejecución: murillo>recorrido /tmp /tmp/. : NO ES FICHERO REGULAR CON PERMISO DE ESCRITURA /tmp/.. : NO ES FICHERO REGULAR CON PERMISO DE ESCRITURA /tmp/.x11-unix : NO ES FICHERO REGULAR CON PERMISO DE ESCRITURA /tmp/.x11-pipe : NO ES FICHERO REGULAR CON PERMISO DE ESCRITURA /tmp/ps_data : FICHERO REGULAR CON PERMISO DE ESCRITURA /tmp/.removable : NO ES FICHERO REGULAR CON PERMISO DE ESCRITURA Figura 2. Ejemplo del programa recorrido en ejecución NOTAS: Note que hasta que no se ha comprobado una entrada de directorio no se continúa con la siguiente. No deje procesos huérfanos ni zombis. No se permite el uso de la llamada system. Puntuación: 2 ptos. Tiempo estimado: 30 min. 3

4 #include <stdio.h> #include <unistd.h> #include <dirent.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/file.h> #include <string.h> #include <fcntl.h> #include <stdlib.h> #include <errno.h> #include <signal.h> #define MAX_LONG_RUTA 255 void manejadorsigusr1(int sig); void manejadorsigusr2(int sig); int main(int argc, char * argv[]) int i,nbytes,status; pid_t childpid, childpida; char ruta[max_long_ruta]; int fd[2]; if (argc!=2) fprintf(stderr,"uso %s <ruta_dir>", argv[0]); // Creacion de tuberías if ((pipe(fd) < 0)) perror("ocurrió un error al crear la tubería\n"); for(i=0;i<=2;i++) childpid=fork(); if (childpid < 0) perror("error al hacer fork"); if (i==0) childpida = childpid; if (childpid == 0) if (i==0) /* PROCESO HIJO A */ DIR *dirp; struct dirent *direntp; /* Cerrar descriptores innecesarios */ close(fd[0]); // Manejador para SIGUSR1 if (signal (SIGUSR1, manejadorsigusr1) == SIG_ERR) perror("error en signal"); 4

5 // Manejador para SIGUSR2 if (signal (SIGUSR2, manejadorsigusr2) == SIG_ERR) perror("error en signal"); if ((dirp = opendir(argv[1])) == NULL) fprintf(stderr, "No se puede abrir el directorio %s. Error: %s\n", argv[1], strerror(errno)); return (-2); while ( (direntp = readdir( dirp ))!= NULL ) sprintf(ruta, "%s/%s", argv[1], direntp->d_name); write(fd[1],ruta,strlen(ruta)); printf("%s : ",ruta); fflush(stdout); pause(); // Informamos de que hemos llegado al final del recorrdio write(fd[1],"fin",3); exit(0); else if (i==1)/* PROCESO HIJO B */ struct stat atributos; /* Cerrar descriptores innecesarios */ close(fd[1]); while (1) for(i=0;i<max_long_ruta;i++) ruta[i]=0; /* Leer ruta fichero */ nbytes = read(fd[0],ruta,sizeof(ruta)); if (strcmp(ruta,"fin")==0) exit(0); //sleep(1); if(stat (ruta, &atributos) < 0) fprintf (stderr, "\nerror %d (%s) al hacer stat en %s", errno, strerror(errno), ruta); 5

6 & S_IWUSR)) if ((atributos.st_mode & S_IFREG) && (atributos.st_mode kill(childpida,sigusr1); else kill(childpida,sigusr2); /* PROCESO PADRE */ while (wait(&status)!=-1); return 0; void manejadorsigusr1(int sig) printf("fichero REGULAR CON PERMISO DE ESCRITURA\n"); signal (SIGUSR1, manejadorsigusr1); void manejadorsigusr2(int sig) printf("no ES FICHERO REGULAR CON PERMISO DE ESCRITURA\n"); signal (SIGUSR2, manejadorsigusr2); 6

7 [Cuestión 3.] Un padre tiene tres hijos: Adela, Benito y Cristina. Los domingos salen a pasear llevando al parque la única bicicleta que poseen. Para asegurar un uso equitativo de dicha bicicleta, cada hijo da una vuelta al parque y le deja la bicicleta al siguiente hermano. Primero daría la vuelta Adela que es la menor, luego Benito el segundo hijo, y por último Cristina, la mayor. En cada salida, programan dar un número de vueltas establecido previamente. La segunda y siguientes vueltas se realizan siempre siguiendo el mismo orden, empezando por Adela. Se pide desarrollar en C un programa, paseo, que simule el escenario presentado. Debe crear la estructura de un proceso padre con tres procesos hijos. El primer hijo simulará el paseo de Adela, el segundo el de Benito, y el tercero el de Cristina. El número de vueltas del paseo debe recogerse como argumento. Figura 3. Jerarquía de procesos del programa paseo La sincronización entre los procesos deberá implementarse a través de la biblioteca de semáforos vista en clase. Debe crear e inicializar los semáforos convenientemente. Suponga implementada la siguiente función: - void vuelta (char * cadena): Simula la vuelta en bicicleta realizada por el hijo cuyo nombre se encuentra en la cadena. murillo>./paseo Uso:./paseo <vueltas> murillo>./paseo 3 Vuelta de Adela Vuelta de Benito Vuelta de Cristina Vuelta de Adela Vuelta de Benito Vuelta de Cristina Vuelta de Adela Vuelta de Benito Vuelta de Cristina Figura 4. Ejemplo del programa paseo en ejecución NOTAS: Asegúrese de que los semáforos son eliminados cuando cualquiera de los procesos reciba la señal SIGINT. El acceso a la bicicleta, realizado por la función vuelta debe estar protegido mediante exclusión mutua. No se permite el uso de ningún tipo de variable compartida. No se permite dejar hijos huérfanos ni zombis. Debe tratar correctamente el número de argumentos. Puntuación: 3 ptos. Tiempo estimado: 30 min. 7

8 #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <unistd.h> #include <signal.h> #include <errno.h> #include "Semaph.h" Semaph excmut,a,b,c; void iniciador () excmut = Semaph_Create("excmut", 1); A = Semaph_Create("A", 1); B = Semaph_Create("B", 0); C = Semaph_Create("C", 0); if ((excmut == -1) (A == -1) (B == -1) (C == -1)) perror("error al crear semaforos"); exit(-1); void terminador (int sig) Semaph_Destroy("excmut", excmut); Semaph_Destroy("A", A); Semaph_Destroy("B", B); Semaph_Destroy("C", C); exit(0); void vuelta(char *cadena) printf("vuelta de %s\n",cadena); int main (int argc, char * argv[]) int i,v,vueltas,status,waitreturn; int padre; padre = 1; if(argc!=2) printf("uso: %s <vueltas>\n",argv[0]); exit(1); sscanf(argv[1],"%d",&vueltas); iniciador(); if(signal(sigusr1,terminador)==sig_err) perror("signal\n"); exit(-1); for (i=0; i < 3; i++) if (padre == 1) if (fork() == 0) /* Proceso hijo */ if(i==0) //hijo A for(v=0;v<vueltas;v++) Semaph_Down(A); 8

9 Semaph_Down(excmut); vuelta("adela"); Semaph_Up(excmut); Semaph_Up(B); if(i==1) //hijo B for(v=0;v<vueltas;v++) Semaph_Down(B); Semaph_Down(excmut); vuelta("benito"); Semaph_Up(excmut); Semaph_Up(C); if(i==2) //hijo C for(v=0;v<vueltas;v++) Semaph_Down(C); Semaph_Down(excmut); vuelta("cristina"); Semaph_Up(excmut); Semaph_Up(A); padre = 0; else /* Proceso padre */ padre = 1; //if padre //for while(waitreturn = wait(&status)) if ((waitreturn == -1) && (errno!= EINTR)) break; return 0; 9

10 10

11 [Cuestión 4.] Se desea implementar en C un cliente y un servidor de archivos concurrente que trabajen en modo conectado y que puedan funcionar a través de Internet. La implementación del servidor constará de las siguientes funciones: int crear_conexion_servidor (int puerto) Esta función realiza las siguientes acciones: o Crea el socket que se empleará como socket de escucha. o Une el socket a la dirección IP de la máquina en la que se ejecuta el código y al puerto indicado como parámetro de entrada. o Asigna el tamaño de la cola de espera de acuerdo al valor de la constante TAM_COLA. En caso de error, la función devuelve -1. int aceptar_conexion (int socket_escucha) Toma como argumento el descriptor del socket de escucha y devuelve el descriptor del socket conectado correspondiente a la última conexión. En caso de error, devuelve -1. int procesar_conexion_servidor (int sock_conectado) Toma como parámetro de entrada el descriptor de un socket conectado y procesa la conexión de forma adecuada en función de las órdenes introducidas por el cliente. Si todo va bien devuelve 0, en caso contrario -1. Por su parte, la implementación del cliente constará de las siguientes funciones: int crear_conexion_cliente (char * nombre_maquina, int puerto) Esta función realiza las siguientes acciones: o Crea el socket conectado en el cliente. o Conecta el socket al servidor cuyo nombre y puerto se introducen como parámetros. La función devuelve el descriptor del socket conectado. En caso de error, la función devuelve -1. int procesar_conexion_cliente (int socket_conexion) Esta función procesa la conexión adecuadamente leyendo las órdenes del usuario, transmitiéndolas al servidor y procesando la información que éste devuelve. Si todo va bien devuelve 0, en caso contrario -1. Una vez que el servidor se encuentre en funcionamiento, éste deberá enviar a los clientes la información que éstos soliciten a través de órdenes específicas. En la versión actual del servidor, las órdenes disponibles son: help: Si un cliente envía al servidor la cadena help, el servidor deberá enviar a dicho cliente el contenido del fichero help.txt localizado en el servidor seguido de la cadena <FIN>. El cliente, por su parte, deberá leer la información recibida del servidor y mostrarla por pantalla. La siguiente figura muestra un ejemplo del programa servidor y cliente en ejecución: murillo>servidor 8028 ================================= Servidor murillo Puerto: 8028 ================================= ================================= Cliente: Puerto cliente: ================================= Servidor a la espera de recibir ordenes... Orden "HELP" recibida murillo>cliente murillo 8028 Escriba la orden que desee enviar al servidor: help ============================================ SERVIDOR DE FICHEROS LSO AYUDA DEL SISTEMA ============================================ El servidor de ficheros LSO es un sistema... <FIN> Escriba la orden que desee enviar al servidor: Figura 5. Ejemplo del programa servidor y cliente en ejecución 11

12 Se pide: Apartado a.- Implemente la función crear_conexión_cliente (1,5 ptos.). Apartado b.- Implemente la función procesar_conexión_servidor incluyendo el código necesario para dar soporte a la órden help. Para la implementación deberá hacer uso de alguna de las llamadas exec (1,5 ptos.). NOTAS: Implemente tantas funciones auxiliares como considere necesarias. No se permite el uso de la llamada system. Puntuación: 3 ptos. Tiempo estimado: 40 min Apartado a.- /* Crea un socket de escucha en modo stream en el dominio de Internet */ int crear_conexion_cliente(char * nombre_maquina, int puerto) int s; struct sockaddr_in sin; struct hostent *hp; /* Obtenemos la dirección IP a partir del nombre */ hp = gethostbyname(nombre_maquina); if (hp == NULL) fprintf(stderr, "Error al obtener la dirección IP asociada al nombre de la maquina\n"); return (-1); /* Creamos el socket de conexion */ if ((s = socket(af_inet, SOCK_STREAM,0))<0) perror("error al crear el socket"); return (-1); /* Nos conectamos al servidor */ sin.sin_family = AF_INET; /* Tipo internet */ sin.sin_port = htons(puerto); /* Puerto en Network byte order */ memmove(&sin.sin_addr, hp->h_addr, hp->h_length); /* Obtenemos la dirección IP de Network byte order */ if (connect(s, (struct sockaddr *) &sin, sizeof(sin))<0) perror("error al hacer connect"); return (-1); return s; Apartado b.- /* Comunicación con el cliente */ int procesar_conexion_servidor(int socket_conexion) char mensaje[tam_mensaje]; int n_bytes=0; int i,fin=0; printf("servidor a la espera de recibir ordenes...\n"); while(!fin) for(i=0;i<tam_mensaje;i++) mensaje[i]=0; 12

13 n_bytes=recv(socket_conexion,mensaje, sizeof(mensaje),0); if (n_bytes < 0) fprintf(stderr,"error en recv\n"); return -1; // Fin? if (strcmp(mensaje,"bye\n")==0) fin=1; // Opcion help else if (strcmp(mensaje,"help\n")==0) printf("orden \"HELP\" recibida\n"); mostrar_ayuda(socket_conexion); else // Mostramos el mensaje tal cual printf("%s", mensaje); fflush(stdout); return 0; // Envía al cliente el contenido del fichero de ayuda void mostrar_ayuda(int socket_conexion) long childpid; char ruta[tam_mensaje]; // Creamos la ruta sprintf(ruta,"%s/help.txt",dir_serv); childpid=fork(); if (childpid==-1) // Error fprintf(stderr,"mostrar listado: Error al hacer fork\n"); else if (childpid==0) // Proceso hijo dup2(socket_conexion,1); execlp("cat","cat",ruta,0); fprintf(stderr,"error en exec: %s\n", strerror(errno)); else // Proceso padre sleep(2); send(socket_conexion,"<fin>\n",6,0); 13