Sistemas Operativos I Práctica 1. Técnica de procesos múltiples El intérprete de comandos. Diana Rosario Pérez Marín Febrero 2007 EPS-UAM

Transcripción

1 Sistemas Operativos I Práctica 1 Técnica de procesos múltiples El intérprete de comandos Diana Rosario Pérez Marín Febrero 2007 EPS-UAM Introducción La página web de la asignatura es y el coordinador es Francis Gómez (francis.gomez@uam.es). Mi dirección de correo electrónico es diana.perez@uam.es. Mi horario de tutorías son los viernes de 11:00 a 13:00. El objetivo de la asignatura es aproximarse al sistema operativo desde el punto de vista del programador de aplicaciones. Poniendo especial énfasis en la gestión de procesos, comunicación y sincronización, administración de memoria, sistemas de archivos y gestión de entrada/salida. El enunciado de la práctica siguiente, se da el día en que se corrige la práctica anterior, y es cuando se explica. Los grupos deben ser de 2 personas. El sistema de registro se encuentra en: usuario: alumnoeps Password: practicasso1 2 1

2 Planificación Se van a hacer 3 prácticas que no son independientes unas de otras sino que consisten en ir incrementalmente construyendo un intérprete de comandos: La primera práctica es la de procesos que es la que empezamos hoy. La idea global de esta práctica es que no sólo existe la programación secuencial, sino que se puede aprovechar la multitarea del sistema operativo y hacer varias tareas en paralelo. La segunda práctica es de memoria compartida y semáforos. Lo importante de esta práctica es aprender que cuando varios procesos quieren trabajar juntos, y no se quiere depender de un fichero para pasar información entre ellos o un pipe, es necesario reservar una memoria común a la que todos la puedan acceder y ya veremos cómo se hace eso. Además, para proteger a la memoria compartida de accesos concurrentes por parte de varios procesos, se implementarán semáforos. La tercera práctica es de señales y mensajes, para que se puedan sincronizar los procesos y compartir información de forma adicional a la memoria compartida. 3 Evaluación ( I ) Se convalidarán las prácticas del año pasado con calificación >= 5 a aquellos alumnos que se hayan presentado al examen de teoría en la convocatoria de Junio o de Septiembre. Hablar con rosa.carro@uam.es Es necesario obtener más de un 5 en prácticas para aprobar la asignatura. Si esta condición se cumple entonces cuentan un 25% de la nota final de la asignatura. La nota de prácticas se puede obtener de 2 formas : Por evaluación continua. Es la opción que os recomiendo porque : Se tiene en cuenta el esfuerzo que hacéis semana tras semana y el trabajo que realizáis. Además entre las entregas, habrá revisiones para comprobar qué se han ido solucionando los fallos detectados. Importa la asistencia a clase. Este año se va a pasar al principio de todas las clases una hoja de firmas. Acumular más de 1 falta no justificada supone el NO APTO por evaluación continua y tener que presentarse al examen de prácticas. Además la nota no será media aritmética, sino ponderada. Por lo que no hay que desesperarse si no funciona una práctica a la primera. Lo importante es que en la entrega final todo funcione. 4 2

3 Evaluación ( II ) Por examen de prácticas: Para aquellos que suspendan por evaluación continua, habrá un examen de prácticas en la última semana de Mayo. Pero ya os advierto que va a ser bastante duro, por lo que una vez más insisto en que trabajéis durante el cuatrimestre para que no sea necesario que ninguno tenga que hacer este examen. También se pueden presentar los que hayan aprobado por evaluación continua. Pero entonces su nota de prácticas sería la obtenida en el examen de prácticas, incluso aunque esto significase una nota inferior e incluso suspender la asignatura. Si se suspende este examen, entonces el alumno debe realizar una práctica especial y el examen de prácticas de Septiembre. La nota de prácticas de este curso se guarda hasta Septiembre El retraso de la entrega de una práctica es inexcusable y supone una reducción de hasta un 50% dentro de las primeras 24 horas o un 0 si se superase este plazo. No se permite la copia bajo ningún concepto. Si se descubriera que algún grupo ha copiado se suspendería la parte de prácticas en la convocatoria de Junio. 5 Evaluación ( III ) Las prácticas se evaluan en 2 pasos : Se deben entregar via web en Entrega de prácticas, el plazo es hasta una 1 hora antes del día y de la hora de entrega en laboratorio. El nombre del fichero debe ser IDGrupoIDParejaNumPractica.tar.gz, ej 1d05p1.tar.gz. (añadiendo vx para posibles reenvíos). Si el fichero se llamase de otra forma tendría 1 punto menos en la nota de la práctica. Para hacer el tar.gz hay que teclear: tar cvzf nombrearchivo.tar.gz. y para descomprimir tar xvzf nombrearchivo.tar.gz. El contenido del fichero debe ser : Un.txt con los nombre del grupo de prácticas, s, número de grupo, turno y fecha. Una memoria en.doc,.html,.rtf o.txt con descripción funcional del programa implementado, decisiones de diseño, control de errores y pruebas de la verificación de la práctica. El código bien estructurado, los.h,.c y makefile. Comentado, cada función con cabecera y descripción de las estructuras de datos y variables. Entrevista con el profesor, donde se muestra el correcto funcionamiento de la práctica, se entrega la memoria y el código en papel y se demuestra que ambos compañeros han trabajado en la práctica. 6 3

4 Procesos en Linux ( I ) En esta práctica vamos a aprender a crear procesos en Linux, y de esta forma familiarizarnos con la programación concurrente. Recordemos que un proceso es un programa en ejecución y que está identificado mediante un número entero. Con ps -aux podemos ver todos los procesos y con kill idproceso matar un proceso. Cómo se crea? Padre Hijo Llamada a fork 7 Procesos en Linux ( II ) Al crear el nuevo proceso, se le asigna su entrada en la tabla de procesos y su identificador ( en adelante pid ). Se le pone en estado listo para ejecutar. El proceso hijo inicialmente es exactamente igual que el padre : copia su segmento de datos, pila y estructura de usuario. Por lo que la única forma de distinguirle del padre, es mediante el retorno de fork : para el hijo es 0 y para el padre el pid del hijo. A medida que el hijo va ejecutando otro código, su memoria, pila y estructura se va diferenciado del padre. El hijo no termina, hasta que el padre recoge su código de finalización ( devuelto con exit ). El hijo queda zombie, si el padre termina y no ha recogido su código de finalización. El padre debe esperar a sus hijos. El hijo queda huérfano, si el padre muere cuando el hijo aún está en ejecución. 8 4

5 El intérprete de comandos Hay que escribir un programa en C para UNIX. Consistente en un intérprete de comandos (msh) con dos modos de funcionamiento según los valores que se le pasen como argumentos: Por fichero: Si el intérprete se ejecuta como./msh nombrefichero entonces los comandos a ejecutar los lee de este fichero. Interactivo: El intérprete se ejecuta como./msh y se queda esperando a que se teclee el comando o comandos por teclado. El formato de una línea del fichero de comandos o una línea que se le teclee en modo interactivo al intérprete será de la forma: comando [arg1 argn] [&] [;] [comando arg1 argn & ;] Especial atención a los símbolos : & -> Indica que el comando debe ejecutarse en background. Esto es que el intérprete no espera a que haya terminado este comando para ejecutar el siguiente. ; -> Indica nuevo comando. 9 Ejemplo de fichero.msprofile Además, habrá un fichero de configuración.msprofile cuya estructura es la siguiente (es muy importante que respetéis esta estructura puesto que este año se va a pasar una herramienta automática de corrección que no aceptará otros formatos): El. lo hace oculto en Linux pero por lo demás se comprota como cualquier otro fichero MAX_NUM_PROC=10 PROMPT=msh MAX_NUM_VAR=5 ARRAY=uno,dos,tres ls la ; cat fichero.txt avar EJ ejemplo evar date El prompt aquí indicado debe ser el usado por msh NOTA: La primera parte sólo contiene variables (con formato NOMBRE_VARIABLE=valor, mientras que la segunda contiene variables o comandos. La primera línea en blanco es el separador entre las dos partes. 10 5

6 El padre (I) 1. Comprueba los argumentos que ha recibido de línea de comandos y establece el modo de trabajo (FICHERO, INTERACTIVO). 2. Lee el fichero de configuración.msprofile: Recordar que en la segunda parte puede haber también variables y que el orden del fichero no está prefijado. Además, una variable puede ser una cadena o bien un array con N elementos ( uno, dos, tres ). Crea memoria ESTÁTICA para guardar MAX_NUM_VAR variables de entorno contenidas en dicho fichero (ej. PROMPT). Comprobar que no hay más de MAX_NUM_VAR variables, en caso contrario dar error. Saltar línea de separación entre variables y procesos. Crea memoria ESTÁTICA para guardar información (pid, pid del padre, tiempo de ejecución y línea de comando) sobre los MAX_NUM_PROC procesos a ejecutar. Comprobar que no hay más de MAX_NUM_PROC procesos, en caso contrario, dar error. 3. Ejecuta los posibles comandos de inicio contenidos en.msprofile. 11 El padre (II) 4. Mientras haya más comandos que ejecutar (esto es, no se encuentre el comando exit o se llegue al final del fichero script con los comandos): Analiza la línea de comandos para identificar los nombres de los comandos, sus argumentos, si se deben ejecutar o no en background y si hacen acceso a alguna variable de entorno. Identifica si el comando es uno de los propios de msh: exit: Cierra todos los ficheros abiertos, libera la memoria usada y cierra el intérprete de comandos. msps: Lista los procesos que se están ejecutando en este momento en msh informando sobre su pid, el pid del proceso padre, cuánto tiempo lleva ejecutándose (HHMMSS) y la línea de comando con la que fue ejecutado. En cada línea debe haber un proceso, con los campos separados por espacios o tabuladores. evar nombre_variable: Muestra por pantalla 0 si la variable no existe, 1 si es una cadena o el número de elementos que tiene la cadena. avar nombre_variable valor (nombrevariable=valor): Asigna valor a la variable, si la variable no existe, se creará. 12 6

7 El padre (III) bvar nombre_variable: Borra la variable si existiera. rvar nombre_variable: Muestra el valor de la variable si existiera. Si es un array, se mostrará completo separando los campos por comas, a no ser qué se especifiquen algunos valores en concreto que se deben mostrar. Entorno: Muestra todas las variables junto con sus valores en formato nombre_variable=valor donde valor puede ser un array separando los campos por comas. Crea un hijo por comando diferente a los propios de msh usando fork. Esto es importante para proteger a nuestro intérprete, de comandos que pueden no acabar o contener algún error. Esto es tarea de los hijos. Guarda información sobre el proceso. Porque en cualquier momento podemos teclear msps. Espera a los hijos que ejecutan comandos en background. Si el comando no debe ser ejecutado en background se queda esperando a que termine. En caso contrario, pasa a ejecutar el siguiente comando inmediatamente. Por cada proceso que termine y se estuviese ejecutando en background, mostrar un mensaje que lo indique por pantalla. 5. Espera a que los hijos terminen. El intérprete no puede terminar hasta que todos sus hijos lo hayan hecho para que no queden zombies. Informar al usuario de esto. 6. Deja la máquina como estaba, liberando todo los recursos usados (memoria, ficheros,...). 13 Los hijos Cada hijo debe ejecutar un comando. Para ello, debe llamar a la función execve() (u otra relacionada: execv(), execvp() ): int execve (char * path, char *argv[], char *envp[]): Ejecuta el comando que se encuentra en la ruta que se le pasa como primer argumento, con los argumentos guardados en argv[] (argv[0] es el comando y argv[ultimo] = NULL) y según la información de las variables de entorno envp. int execvp (char * path, char *argv[]): Igual que la anterior, con la única diferencia que no necesita que se le pasen variables de entorno. Ej: para ejecutar ls la comando[0] = ls, comando[1] = -l, comando[2] = NULL, entonces execvp(*comando, comando) funciona, usar punteros! Tener en cuenta que estas funciones una vez toman el control ya no regresan a no ser que suceda algún error (entonces devolverían valor -1 e información sobre el error en errno). Pero deben mostrar un mensaje por pantalla cuando hayan terminado en caso de que se estuvieran ejecutando en background. El hijo hereda toda la información del padre. No es necesario volver a crear memoria para las variables de entorno! Por el contrario, es obligatorio liberar la memoria puesto que no se libera hasta que el padre y los hijos (que la han heredado) la liberan. Desde un msh se puede ejecutar como hijo otro msh que heredará todos los valores de las variables de entorno tal y como estén en ese momento pero no la tabla de procesos. No volver a reservar memoria! 14 7

8 >./msh Visión global : Padre e hijos Padre PID 1749 Hijo 1 PID modo = INTERACTIVO ls -la 2º. Lee.msprofile 3º. Espera comandos: msh$ 4º. msh$ ls la & ; cd /home 5º. Analiza la línea de comandos Hijo 2 PID º. Encuentra el primer comando cd /home 7º. Crea el primer hijo [diana@orestes data]$ cd /home 8º. Encuentra el segundo comando [diana@orestes home]$ exit(0) 9º. Crea el segundo hijo 10º. Espera a que los hijos terminen -rw-r--r-- 1 diana users Nov 5 09:52 archivo1 -rw-r--r-- 1 diana users 2122 Nov 5 10:52 archivo2 exit(0) 15 Control de errores MÍNIMO : En la creación y manejo de procesos. Hay que controlar el valor devuelto por fork, wait y exit. Que los hijos mueran de forma ordenada y sin crear zombies. En la creación, lectura, escritura y borrado de ficheros. En la reserva de memoria dinámica. ADICIONAL : En los argumentos y retornos de las funciones. En la lectura de los comandos del fichero. En general, que el programa haga frente a todos los posibles errores que se puedan ir dando y no se quede bloqueado. 16 8

9 Pasos para hacer la práctica En primer lugar, que se pueda leer de teclado una línea de comandos y el programa guarde correctamente los comandos y sus argumentos. En segundo lugar, que se cree un hijo por cada comando de la línea y lo ejecute correctamente (todavía no en background). En tercer lugar, incorporar la posibilidad de ejecutar procesos en background y comprobar la concurrencia del padre y sus hijos. En cuarto lugar, que se pueda proporcionar como argumento el nombre de un fichero del que el intérprete lea los comandos a ejecutar. Añadir un bucle que permita ejecutar todos los comandos del fichero o permanecer en modo interactivo hasta exit. En quinto lugar, programar los comandos internos al msh. En sexto lugar, robustecerlo frente a casos de error. Asegurarse que la máquina se queda como al principio de la ejecución. Quitar la información de depuración o hacer que solo aparezca si una variable debug en el.h vale 1, por ej. if (debug) printf("ahora crea el hijo %d... En séptimo lugar, implementar las mejoras. 17 Información adicional : unistd.h Para poder utilizar fork y wait hay que incluir la librería unistd.h, y para las macros de exit : sys/wait.h y sys/types.h. Veamos a grandes rasgos cada función y luego ya ejemplos de cada (recordar encapsular las llamadas al sistema operativo) : pid_t fork() se encarga de crear un nuevo proceso. Devuelve 0 al hijo y el pid del hijo al padre. 1 si error que se controla con errno. int wait(int * status) la llama el padre para esperar a cualquier hijo que termine. El retorno es el pid del hijo y en status ( retorno exit ). int waitpid( pid_t, int * status, int opcion ). Igual que la anterior, pero para esperar a un proceso concreto ( con pid = -1 igual que wait ). exit( int status ) sirve para devolver status al padre pid_t getpid() para averiguar el pid de un proceso. pid_t getppid() para averiguar el pid del proceso padre. int pipe ( int * ) para crear una tubería de comunicación padre-hijo 18 9

10 #include <stdio.h> #include <unistd.h> int main() int var = 2 ; int id ; Ejemplo de fork id = fork(); switch(id) case -1 : /* error */ break ; case 0 : /* hijo */ var++ ; break ; default : /* padre */ var-- ; break ; printf("var = %d\n", var ) ; 19 Ejemplo de wait, getpid y getppid() main() /* programa wait.exe */ int pid, status, hijopid; printf( Soy el proceso padre y mi Pid es: %d\n,getpid()); pid = fork(); if(pid == -1) exit(-1); if(pid!=0) printf( Soy el proceso padre con PID %d y PPID %d\n, getpid(),getppid()); hijopid= wait(&status); printf( Un hijo con PID %d ha terminado con codigo de salida %d\n, hijopid,wexitstatus(status)); else printf( Soy el hijo con PID %d y PPID %d\n, getpid(),getppid()); exit(42); printf( El proceso de PID %d termina\n, getpid()); 20 10

11 Ejemplo de exit y macros #include <stdio.h> #include <unistd.h> #include <sys/types.h> #include <sys/wait.h> int main() int var, estado, id, control1, control2 ; if ( (id = fork()) == 0 ) // hijo var = 257 ; exit(var); // el padre comprueba el retorno if ( id == wait(&estado)) control1 = WIFEXITED(estado); control2 = WIFSIGNALED(estado); printf( Control1=%d y control2=%d\n, control1, control2); printf("padre recibe = %d\n", WEXITSTATUS(estado) ) ; else exit(-1); 21 Explicación de los ejemplos vistos El resultado del fork puede ser : var= 3, var = 1 o al revés los dos padre e hijo pasan por el printf, con el cambio realizado a var. Otras opciones que tiene el waitpid son : WNOHANG : Espera no bloqueante. WUNTRACED : Información adicional de si el hijo recibe señales. El resultado del ejemplo del wait : Soy el proceso padre y mi Pid es: Soy el hijo con PID y PPID Soy el proceso padre con PID y PPID Un hijo con PID ha terminado con codigo de salida 42 El proceso de PID termina Para obtener los 8 bits menos significativos, donde está guardado el resultado del exit, se utiliza WEXITSTATUS(estado). Para comprobar si es correcto el resultado se tiene que comprobar que WIFEXITED(estado) devuelve un valor distinto de cero y que WIFSIGNALED(estado) es

12 errno #include <stdio.h> #include <errno.h> extern int errno ; int main() FILE * f = NULL ; f = fopen("bla", "r"); if ( f == NULL ) perror("fopen:"); exit(-1) ; fclose(f); exit(0) ; 23 pipe - Los procesos se pueden comunicar mediante tuberías (pipes) que deben ser creadas antes de la ejecución del fork. crear pipe fork proceso padre escribe pipe pipe proceso hijo lee pipe - A los pipes se accede a través de un descriptor de fichero, como cualquier otro fichero. Tienen tamaño variable

13 Ejemplo de pipe ( I ) #include <stdio.h> #include <unistd.h> #include <errno.h> #define LEER 0 #define ESCRIBIR 1 char * frase = "Envia esto a traves de un tubo" ; extern int errno ; int main() int fd[2], bytesleidos ; char mensaje[100] ; int control ; // se crea la tuberia control = pipe(fd) ; if ( control!= 0 ) perror("pipe:"); exit(errno); 25 Ejemplo de pipe ( II ) // se crea el proceso hijo control = fork() ; switch(control) case -1 : // error perror("fork:"); exit(errno); case 0 : // hijo close(fd[leer]); write(fd[escribir], frase, strlen(frase) + 1 ) ; close(fd[escribir]); exit(0); default : // padre close(fd[escribir]); bytesleidos = read(fd[leer], mensaje, 100 ) ; printf("leidos %d bytes : %s\n", bytesleidos, mensaje ) ; close(fd[leer]); exit(0) ; Resultado : Leidos 31 bytes : Envia esto a traves de un tubo 26 13

14 fork y ficheros #include <stdio.h> #include <unistd.h> int main() int pid ; printf("voy a crear el hijo..."); //fflush(stdout); pid = fork(); if ( pid == 0 ) // hijo sleep(10); // asegurar que el padre se ejecuta primero printf("soy el hijo\n"); exit(0); else // padre printf("hijo creado\n"); wait(); exit(0) ; 27 Otras funciones <stdio.h> char * fgets (char * s, int size, FILE * f); fgets(linea, MAX_LINEA, stdin); int sscanf (const char * str, const char * format, ) sscanf(linea, %s=%s, nombre_var, valor_var); <time.h> time_t (time_t * t) <stdlib.h> int atoi (const char * nptr) n = atoi (cadena) char * getenv(const char * name) <string.h> char *strchr (const char * s, int c) If (strchr(cadena, = )!= NULL ) int strcmp ( const char * s1, const char * s1, size_t n ) strcpy, strlen 28 14

15 Consejos Para asegurar que no se quedan zombies: Hacer que el padre lleve un contador de todos los hijos que creó y hasta que no se produzcan todos los wait el padre no termina. Inicializar todos los punteros a NULL. Liberar toda la memoria que habéis reservado. Hacer un código modular y documentado : main.c : Sólo llama a funciones, es muy pequeño func.c : Tiene las funciones, con cabecera func.h : Prototipos y constantes Cada función realiza una tarea!!! 29 Requisitos mínimos MINIMO (para aprobar la práctica, ver nota de la herramienta de test) Funcionamiento correcto en modo interactivo o por fichero, tanto para procesos ejecutándose en background como aquellos que fuerzan una espera bloqueante. Funcionamiento correcto de los comandos internos del msh. Procesos hijos deben terminar correctamente y no generar procesos zombie. Detectar posibles fallos en las funciones. La memoria (hasta 4 puntos a sumar a la nota del código): Análisis de decisiones: estrategia seguida en el diseño, decisiones tomadas hasta llegar a la solución tomada. Análisis funcional: Descripción de cada una de las funciones y las estructuras de datos utilizadas. Control de errores: Qué errores y cómo se han controlado. Pruebas: Las pruebas tanto de casos correctos como incorrectos

16 Mejoras Actualizar la información sobre las variables al fichero.msprofile Implementar la sintaxis alternativa de la $ en la evaluación de variables. Esto es, sustituir $Nombre_variable por su valor y ejecutar el resultado. Así, por ejemplo si la variable var vale hola el comando ls $var se transformará en ls hola y entonces se ejecutará. Si la variable indicada no hubiera sido definida, entonces se transformará por la cadena vacía. Interpretación en la línea de comando de <, > y. Implementar el comando export para notificar a otros msh la modificación de las variables de entornos mediante pipes. Cada vez que se lance un msh se debe abrir un pipe entre él y su padre para comunicarse por ese canal los cambios en las variables de entorno. Implementar bucles for con la sintaxis de la familia sh: for variable in [lista] do comandos done Colocar realmente en el entorno las variables definidas en msh para poder ser usadas por comandos no internos de la shell. 31 Fechas Por último, comentaros que esta práctica hay que entregarla en tres semanas. Para la semana que viene ya se os pide: Un programa ejemplo de fork wait que simplemente cree un proceso hijo que lanze un proceso. Luego el padre lo tiene que esperar y terminar. Un esquema de pseudocódigo de cómo tenéis pensado solucionar la práctica antes de ponernos a escribir el código de la misma. Esta documentación no hay que entregarla por entrega de prácticas, sino simplemente mostrarla al profesor el próximo día de clase. En las próximas semanas estar atentos a la web, dónde aparecerá la herramienta para que podáis probar vuestro msh