Gestión y Comunicación de procesos

Transcripción

1 1 Resumen Gestión y Comunicación de procesos Material de apoyo para la asignatura de Taller de Sistemas Operativos 1 Preparado por Gabriel Astudillo Muñoz Escuela de Ingeniería Civil Informática Universidad de Valparaíso Este documento tiene como objetivo ser un material de apoyo para la asignaturas de Sistemas Operativos, Taller de Sistemas Operativos y Redes de Computadores. Se describen algunas funciones del API de C relacionadas con gestión de procesos y comunicación entre procesos. Todas las funciones son relativas al kernel 3.0 de Linux. Las herramienta de compilación son: gcc 4.7.3, GNU Make Todos los códigos están disponibles en una máquina virtual 2 que contiene todas las herramientas para implentar los códigos. 2 Generalidades para programar en Unix 2.1 Conceptos básicos Al ejecutar un programa, éste se transforma en un proceso, que, en general, disponde de ciertos descriptores para recibir y enviar información desde y hacia otros procesos, tal como se muestra en la Figura 1. Estos descriptores básicos se listan en la Tabla 1. Para un uso adecuado de estos descriptores, es preferible utilizar las macros o el descriptor de los flujos determinado a través de la función fileno(). Descriptor Nombre descriptivo Macro definida en Relación con los (int) unistd.h flujos 0 Standard Input STDIN_FILENO fileno(stdin) 1 Standard Output STDOUT_FILENO fileno(stdout) 2 Standard Error STDERR_FILENO fileno(stderr) Tabla 1 stdin Descriptor Flujo (FILE*) 0 stdout 1 Figura Estructura básica de un programa para el Taller de Sistemas Operativos La estructura (esqueleto) de un programa en C será la siguiente: #include <stdio.h> //otras bibliotecas stderr int main(int argc, char *argv[]){ //Su codigo return(exit_success); En el Taller, se privilegiará el uso de macros. Para esto, se utilizará, en primera instancia, algunas definidas en la biblioteca stdlib.h 3. Macro Descripción EXIT_SUCCESS Terminación exitosa del proceso. 0 EXIT_FAILURE Terminación errónea del proceso. NULL Puntero a nulo. Tabla Última versión: Disponible en

2 2.3 Estructura básica del entorno de desarrollo El desarrollo de programas en el Taller se realizará en base a un editor de texto simple, un archivo de texto para el código fuente y para el archivo Makefile. El esquema de archivos se muestra en la Figura 2. Directorio de trabajo ejemplo.c Makefile #include <stdio.h> int main(int argc, char *argv[]){ printf( Hola Mundo!\n ); return(exit_success); # # Seccion 1 # # Esta seccion se puede modificar segun # los requerimientos de su proyecto CC=gcc OBJ=ejemplo.o BIN=ejemplo # # Seccion 2 (NO MODIFICAR!!!) # default: $(BIN) $(BIN): $(OBJ) $(CC) $^ -o $(BIN) %.o: %.c $(CC) -c -o $@ $< clean: rm -f $(OBJ) rm -f *~ rm -f $(BIN) 2.4 Estructura del Makefile Figura 2 La estructura del makefile a utilizar será similar a la que se muestra en la Figura 3. Usted sólo debería modificar la sección 1 de dicho archivo. # # Seccion 1 # # Esta seccion se puede modificar segun # los requerimientos de su proyecto CC=gcc OBJ=ejemplo.o BIN=ejemplo # # Seccion 2 (NO MODIFICAR!!!) # default: $(BIN) $(BIN): $(OBJ) $(CC) $^ -o $(BIN) Compilador a utilizar (por omisión, gcc) Códigos objeto de su proyecto Nombre del ejecutable de su proyecto %.o: %.c $(CC) -c -o $@ $< clean: rm -f $(OBJ) rm -f *~ rm -f $(BIN) Figura 3 Para mayor información acerca de Makefile, visita la página oficial de GNU Make Manejo de errores Cada operación que puede resultar errónea, debe ser manejada correctamente y ser enviada al standard error, no al standard output. Por ejemplo, se se quiere abrir el archivo conexiones.txt, el siguiente código está incompleto, ya que puede ocurrir un error al abrir el archivo solicitado y no le envía un aviso al usuario

3 #include <stdio.h> int main(int argc, char *argv[]){ FILE *archivo; archivo = fopen( conexiones.txt, r ); // Seccion que procesa el archivo return(exit_success); El código que se muesta a continuación, a pesar que le envía un aviso al usuario, está erróneo ya que el mensaje lo imprime en el standard output, a través de la función printf(). Además, no se sabe que es lo que realmente pasó (puedo no existir, no tener los permisos suficientes, etc)... if( (archivo = fopen("conexiones.txt", "r")) == NULL ){ printf("error al abrir el archivo.");... El código de más abajo, es mucho mejor que el anterior, ya que ahora si envía el mensaje expresamente al standard error. Pero no hay mayor información sobre qué error pudo suceder.... if( (archivo = fopen("conexiones.txt", "r")) == NULL ){ fprintf(stderr, "Error al abrir el archivo\n");... Para que el programa envié un mensaje de error apropiado, se debe utilizar la función perror(), disponible en stdio.h. Esta función envía el mensaje al estándar output. #include <stdio.h> int main(int argc, char *argv[]){ FILE *archivo; if( (archivo = fopen("conexiones.txt", "r")) == NULL ){ perror("error al abrir el archivo"); // Seccion que procesa el archivo return(exit_success); Si el archivo no existe, la salida del programa es (el ejecutable se llama ejemplo_error): #./ejemplo_error Error al abrir el archivo: No such file or directory # Si el archivo existe, pero no se tienen los permisos suficientes: #./ejemplo_error Error al abrir el archivo: Permission denied # 3

4 3 s en Unix 3.1 Jerarquía de procesos En la Figura 4 se visualiza un proceso inicial, denominado init, que, mediante una llamada al sistema determinada, puede generar uno o varios procesos. Cada proceso creado puede crear más subprocesos. Despues de un tiempo, se puede obtener una Jerarquía de s similar a la mostrada (Silberschatz, Galvin, & Gagne, 2003). init pid=1 pid=2 pid=3 pid=20 sshd udevd login ssh root@notty sftp server subsystem udevd --deamon /bin/bash pid=50 pid=52 pid=60 pid=100 joe tarea1.c pid=101 gcc tarea1.c pid=102 Figura API de s en C Creación de s Para crear procesos en sistemas operativos UNIX se debe utilizar la llamada al sistema de la función fork(). El proceso que realiza esta llamada es denomido padre y el nuevo proceso creado, hijo. pid_t fork(); Las consecuencias del proceso de creación son: La llamada fork() retorna valores distinto para el proceso padre y para el proceso hijo. El proceso hijo es una copia exacta del proceso padre. Ambos procesos siguen ejecutándose independientemente. pid = fork() SÍ pid<0 Error en el fork() Hijo Código proceso hijo SÍ pid==0 Padre Código proceso padre Figura 5 Al momento que se invoca la llamada fork(), el Kernel debe realizar las siguientes tareas: Reserva un espacio en la tabla de procesos para el nuevo proceso. Asigna un PID único al nuevo proceso. Realiza una copia del contexto del proceso padre. Copia los descriptores de archivos del proceso padre al hijo. La función fork() retorna: El PID del hijo en el proceso padre y 0 en el proceso hijo, si la llamada es exitosa. -1, en caso de error, 4

5 Ejemplo de uso: int main(int argc, char *argv[]) { pid_t pid; pid = fork(); if( pid < 0){ perror( Error en fork() ); else if( pid == 0 ) { //Código del hijo else if(pid>0){ //Padre //Código del padre Funciones asociadas a la creación de procesos getpid() La función getpid() retorna el identificador (PID) del proceso llamador. getppid() pid_t getpid(); La función getppid() retorna el identificador (PID) del proceso padre. pid_t getppid(); Término de un proceso Existen dos formas para que un proceso termine. Estas formas son: a) Normal Retorno de la función main(). Llamar a la función exit(int status). Efectúa una limpieza (llama funciones de término previamente registradas con atexit()) y retorna al kernel. El parámetro status puede tomar los valores EXIT_SUCCESS o EXIT_FAILURE (0 ó 1). Llamar a la función _exit(int). Retorna al kernel inmediatamente. void exit( int status); void _exit(init status); int atexit(void (*func) (void));// retorna 0 si es OK, //distinto de 0 en otro caso. b) Anormal Llamar a abort() : esta función genera la señal SIGABRT, por lo tanto es un caso particular de terminar por una señal. Término por una señal. Esto se tratará en la sección 4. 5

6 Ejemplo uso atexit() #include <stdio.h> void limpiar(); int main(){ if(atexit(limpiar)!= 0) { perror("error en atexit:"); printf("ultima instruccion...\n"); exit(exit_success); void limpiar(void){ printf("aca va el codigo final final\n"); Funciones de sincronización Algunas veces se necesita que el proceso padre, quede esperando la finalización de sus procesos hijos, debido, por ejemplo, a que los procesos hijos entregarán cierta información que después el proceso padre utilizará en el resto del programa. Las funciones que se utilizan para este fin son wait() y waitpid(). La Figura 6 muestra esta situación. wait() La función wait() forzará a un proceso padre para que espere a un proceso hijo que se detenga o termine. La función regresa el PID del hijo o -1 en caso de error. El estado de la salida hijo es regresado en la variable &statloc. waitpid() #include <sys/wait.h> pid_t wait (int *statloc); La función waitpid() es similar a wait(), salvo que explícitamente espera por un determinado proceso, especificado por pid. #include <sys/wait.h> pid_t waitpid( pid_t pid, int *statloc, int options); El valor del argumento pid puede ser: < -1 : Espera a que cualquier proceso hijo cuyo ID grupal es igual al valor absoluto de pid. = -1 : Espera por cualquier proceso hijo. Este es el mismo comportamiento que tiene wait. = 0 : Espera por cualquier proceso hijo cuyo ID grupal es igual al del proceso padre. > 0 : Espera por el proceso hijo cuyo ID es igual al valor de pid (por un proceso determinado). El valor del argumento options puede ser: WNOHANG: retorno inmediatamente si ningún hijo a terminado. WUNTRACED: también retorna si un hijo se a detenido. Alcance: la función wait(&status) es equivalente a waitpid(-1, &status, 0). 6

7 pid = fork() SÍ pid<0 Padre Hijo Error en el fork() Código del hijo Hijo SÍ pid==0 wait() Padre fork() wait() Resto del programa exit() exit() Resto del programa Figura Familia de funciones EXEC La familia de funciones exec*() se utlizan para ejecutar otro programa. En particular, se pueden usar para que un proceso hijo pueda ejecutar un programa específico, tal como se muestra en la Figura 7. Existen seis variantes de la función exec. En que el momento que cualquiera de ellas sea llamada, el proceso completo es reemplazado por un nuevo programa. El nuevo programa parte en su función main() y NO cambia el PID del proceso hijo. int execl( const char *path, const char *arg,...); int execlp( const char *file, const char *arg,...); int execle( const char * path, const char *arg,..., char * const envp[]); int execv( const char * path, char *const argv[]); int execvp( const char *file, char *const argv[]); int execve(const char *filename, char *const argv [], char *const envp[]) El primer argumento es el archivo ejecutable que se quiere llamar. Las funciones que contienen puntos suspensivos en su prototipo, los parámetros del ejecutable se incluyen ahí, en argumentos separados. Las funciones terminadas en "e" (execle() y execve()) reciben un último argumento que es un puntero a las variables de entorno. pid = fork() SÍ pid<0 Padre Hijo Sistema Operativo Error en el fork() Hijo exec( programa ) SÍ pid==0 wait() Padre fork() wait() Resto del programa exec("comando") exit() programa exit() Resto del programa Figura 7 Ejemplo: Se requiere que un proceso ejecute el comando /bin/ls la /. Esto se puede realizar como se indica en la Figura 8. 7

8 execl("/bin/ls", "ls", "-la", "/", 0); Comando a ejecutar Argumentos Nombre lógico Figura 8 Indica fin de los argumentos Función system Permite ejecutar un programa externo, desligado completamente del proceso que lo ejecuta. Esta función es internamente implementada llamando a las funciones fork(), exec(), y waitpid(). En la Figura 9 se muestra un esquema que permite ver la diferencia con la función exec(). int system(const char * prgstring); Sistema Operativo system( programa ) Resto del programa Resto del programa system( programa ) programa Figura 9 8

9 3.3 Programas de ejemplo a) Programa que crea dos procesos. El proceso hijo duerme por 5 segundos, imprime su PID, el de su padre y termina. El padre, imprime los PID de él, su hijo y su padre. Luego, termina. Compile el programa y vea el resultado. Trate de explicar lo que sucede. #include <stdio.h> int main(int argc, char *argv[]) { pid_t pid; if( (pid=fork()) == 0 ) { //Hijo sleep(5); printf("soy el Hijo: PID=%d\n", getpid()); printf("\tmi padre es: PID=%d\n", getppid()); exit(exit_success); else if(pid>0){ //Padre printf("soy el Padre: PID=%d\n", getpid()); printf("mi hijo es %d\n", pid); printf("mi padre es %d\n", getppid()); return(exit_success); b) Modificación del programa anterior. Explique lo se sucede al colocar la función waitpid(). Prueba también con wait(). Vea lo que pasa cuando la función waitpid() se coloca justo antes de return(exit_success). Explique lo que sucede. #include <stdio.h> int main(int argc, char *argv[]) { pid_t pid; int status; if( (pid=fork()) == 0 ) { //Hijo sleep(5); printf("soy el Hijo: PID=%d\n", getpid()); printf("\tmi padre es: PID=%d\n", getppid()); exit(exit_success); else if(pid>0){ //Padre waitpid(pid, &status, 0); printf("soy el Padre: PID=%d\n", getpid()); printf("mi hijo es %d\n", pid); printf("mi padre es %d\n", getppid()); return(exit_success); 9

10 c) Programa que ejecuta comandos ingresados por el usuario, a través del intérprete bash. #include <stdio.h> #include <string.h> #include <sys/wait.h> #define AVISO "Escriba un comando, ^d para terminar" #define PROMPT "$ " int main(){ char comando[100]; int pid, status; puts(aviso); printf(prompt); while( fgets(comando,100,stdin) ){ comando[strlen(comando)-1]=0; if( (pid=fork()) < 0 ){ puts("error en fork()."); else if( pid == 0 ) { execl( /bin/bash, bash, -c, comando, 0); exit(exit_success); else{ waitpid(pid,&status, 0); printf("pid= %d\n", pid); puts(aviso); printf(prompt); //fin if del fork // fin while return(exit_success); d) Realice un programa utilizando la función execl() para listar los procesos activos en el momento de ejecución. #include <sys/wait.h> #include <stdio.h> #include <errno.h> int main(){ printf ("Lista de procesos\n"); if(execl ("/bin/ps", "ps", "-aux", 0) < 0){ fprintf(stderr, "Error en exec %d\n", errno); puts("fin de la lista de procesos\n"); exit(exit_success); 10

11 4 Señales Las señales permiten generar interrupciones asincrónicos entre distintos procesos. En el proceso que recibe la señal, se genera una interrupción de software, que es atendida por una función que previamente se relacionó con la señal, tal como se muestar en la Figura 10. Curso normal de ejecución función de atención de Interrupción Señal entrante El proceso sigue dónde quedó Figura 10 Hay diversos tipos de señales y cada una de ellas tiene un identificador entero, que se encuentra definido la biblioteca signal.h 5. Existen diversas formas de generar señales. Entre las más comunes se encuentran: Eventos del teclado (^c, ^z, etc) 6. Excepciones aritméticas. Por ejemplo, división por cero. Referencias de memoria inválida. Mediante la función kill() o el comando kill. Condiciones de software. Por ejemplo, por una señal de alarma que expire, error entre la comunicación de procesos. Al momento en que un proceso recibe una señal, éste tiene tres formas distinta de tratarlas. Ignorar la señal, con lo cual no se produce efecto alguno. Existen señal que no se pueden ignorar. Invocando a una función que es aportada por el Kernel y normalmente tiene como fin terminar el proceso. Invocando a una rutina que se encarga de tratar la señal, generalmente creada por el programador. Esta rutina establece un mecanismo de comunicación entre procesos o modificar el curso normal del proceso. 4.1 Señales en Unix A continuación, se presentan la descripción de algunas señales. Cada nombre está asociado a un número entero. Señal Descripción Acción por omisión SIGINT Es enviada cuando en medio de un proceso se Termina la ejecución pulsa las teclas de interrupción (^c). del proceso que SIGQUIT Similar a SIGINT, pero es generada al pulsa la tecla de salida (^\). SIGKILL Esta señal provoca irremediablemente la terminación del proceso. No puede ser ignorada. SIGBUS Es enviada a un proceso cuando intenta acceder a datos que se encuentran fuera de su segmento de datos (Segmentation Fault). recibe la señal. Generar un archivo core y terminar el proceso. Terminar el proceso Terminar el proceso 5 Por lo general, esta biblioteca se encuentra en /usr/include. Específicamente, las definiciones de las macros de los nombres de las señales se encuentran en /usr/include/bits/signum.h. 6 La notación ^(tecla) es equivalente a la CTRL+TECLA 11

12 SIGPIPE SIGALRM SIGTERM SIGUSR1, SIGUSR2 SIGCLD Intento de escritura en una pipeline de la que no hay nadie leyendo. Evita que se pierdan datos. Cada proceso tiene asignados un conjunto de temporizadores. Si se ha activado alguno de ellos y este llega a cero, se envía esta señal al proceso Es la señal utilizada para indicarle a un proceso que debe terminar su ejecución. Esta señal no es tajante como SIGKILL y puede ser ignorada. Esta señal está reservada para el usuario. Su interpretación dependerá del código desarrollado por el programador. Es enviada al proceso padre cuando alguno de sus procesos hijos termina. Tabla 3 Terminar el proceso Terminar el proceso. 4.2 Envío de señales La función kill() envía una señal a un proceso. Análogamente, raise() envía señales al mismo proceso. #include <signal.h> int kill (pid_t pid, int signo); int raise(int signo); 4.3 Tratamiento de señales Para permitir que una señal (o su interrupción) sea correctamente tratada, hay que relacionar la interrupción generada por la señal con una función determinada. Esto se realiza a través de signal(). #include <signal.h> typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler); Esta función retorna retorna el valor previo del manejador de la señal o SIG_ERR en caso de error Ejemplo 1 Se quiere implementar un proceso que tenga un ciclo infinito y que cada 1 segundo imprima en pantalla Nada todavia. Cuando el usuario genere una señal SIGINT a través de la secuencia ^c, el programa deberá avisar que el proceso se va a acabar. #include <stdio.h> #include <signal.h> void func_sigint(int senal){ //Funcion que maneja la interrupcion // SIGINT (CTRL+c) printf("se termino el proceso\n"); printf("numero de senal: %d", senal); exit(exit_success); int main(int argc, char *argv[]){ signal(sigint, func_sigint); while(1){ puts("nada todavia"); sleep(1); return(exit_success); 12

13 4.3.2 Ejemplo 2 Programa que cuando reciba las siguientes señales, responda de la siguiente manera: o o o o Al recibir una señal SIGUSR1 muestre el mensaje "He recibido la señal SIGUSR1". Al recibir una señal SIGUSR2 muestre el mensaje "He recibido la señal SIGUSR2". Al recibir una señal SIGTERM muestre el mensaje "Fin de Ejecución" y termine su ejecución de forma exitosa. Al recibir una señal SIGINT, la ignore. #include <stdio.h> #include <signal.h> void manejador(int signum){ switch (signum){ case SIGUSR1: printf("he recibido la senal SIGUSR1\n"); break; case SIGUSR2: printf("he recibido la senal SIGUSR2\n"); break; case SIGTERM: printf("fin de Ejecucion\n"); exit(exit_success); int main(int argc, char *argv[]) { if (signal(sigusr1, manejador) == SIG_ERR) { perror("error en la senal SIGUSR1"); if (signal(sigusr2, manejador) == SIG_ERR) { perror("error en la senal SIGUSR2"); if (signal(sigterm, manejador) == SIG_ERR) { perror("error en SIGTERM"); if (signal(sigint, SIG_IGN) == SIG_ERR) { perror("error en SIGINT"); 4.4 Otras funciones while (1){ puts( Programa ejemplo senales\n ); pause(); alarm(): La función alarm() permite especificar un timer que expira en un tiempo determinado. Cuando expira, se genera una señal SIGALRM hacia el proceso que configuró el temporizador. unsigned int alarm(unsigned int seconds) Si seconds es 0, la alarma se desactiva y retorna la cantidad de segundos que faltan para cumplirse el plazo. 13

14 pause(): La función pause() suspende un proceso llamador hasta que llegue una señal. int pause(void); /* retorna -1 con errno en EINTR */ sleep(): La función sleep() duerme al proceso llamador por la cantidad de segundos indicada o hasta que reciba una señal que está implementada. Retorna 0 ó el tiempo que le falta por dormir, respectivamente Ejemplo 3 unsiged int sleep (unsigned int seconds); unsiged int usleep(unsigned int microseconds); #include <time.h> int nanosleep(const struct timespec *req, struct timespec *rem); Implementar un programa que acepte la entrada de una cadena de caracteres antes que se cumpla cierto tiempo. Cuando el tiempo se cumpla, el sistema debe avisar al usuario que el tiempo expiró y terminar. #include <signal.h> #include <stdio.h> #include <errno.h> static void sig_alrm(int); #define MAXLINE 200 #define TIMEOUT 5 int main(void) { int n; char line[maxline]; if (signal(sigalrm, sig_alrm) == SIG_ERR) perror("signal(sigalrm) error"); printf("ingrese un string antes de 5 segundos: "); fflush(stdout); alarm(timeout); //Configure el timer por TIMEOUT segundos. //terminado ese tiempo, se genera una //interrupcion del tipo SIGALRM if ( (n = read(stdin_fileno, line, MAXLINE)) < 0) if (errno!=eintr) perror("read error"); alarm(0); //Desactivar timer printf("lo que ingreso es: "); fflush(stdout); write(stdout_fileno, line, n); exit(exit_success); static void sig_alrm(int signo){ printf("\npaso la alarma!!!\n"); exit(exit_success); 14

15 5 Comunicación entre procesos mediante PIPES Los pipes o tuberías son un método de comunicación unidireccional entre procesos. Gráficamente, se dibuja como se indica en la Figura 11. Una pipe es simplemente un método de conexión que une la salida de un proceso a la entrada de otro. Para realizar la conexión de los procesos involucrados se utilizan descriptores de archivos, que son estructuras de datos que contienen y manejan la información de estado de archivos. Por ejemplo, se tiene un archivo de texto, denomindo conexiones.txt, que contiene las conexiones hacia un servicio determinado, tal como se muestra en la Tabla ;connected ;offline ;connected ;offline Tabla 4 Figura 11 Debido a un requerimiento externo, se desea mostrar en pantalla (standard Output) sólo las líneas que contengan la palabra connected. Esto se realiza con el siguiente comando: #cat conexiones.txt grep connected ;connected ;connected # El símbolo es la representación de una pipe en la línea de comandos de Unix. En este ejemplo, la salida estándar del proceso cat conexiones.txt es ingresada como entrada estándar al proceso grep. Esta situación se muestra en la Figura 12. READ stdin stdout stderr cat Flujo de Datos WRITE stdin stdout stderr grep Figura 12 Existen dos formas de programas pipes: con la función popen() y pipe(). 5.1 Creación de PIPES simples La función popen() crea una pipe para leer desde un comando o escribir a otro comando. Por otro lado, pclose()la cierra. El modo de uso es: #include <stdio.h> FILE *popen (const char *command, const char *type); int pclose(file * stream); El argumento command es el comando a ejecutar y type puede ser r (lectura) o w (escritura). Este función crea un nuevo proceso y ejecuta el comando. Luego crea una pipe desde la entrada o salida estándar de este proceso dependiendo de cómo se abrió. Esta situación se ilustra en la Figura

16 Transparente para el programador popen() se utiliza la pipe Resto del programa Hijo exec("comando") exit() Sistema Operativo comando Figura 13 Nótese que popen() retorna un puntero del tipo FILE*, por lo que, para leer y escribir hacia y desde una pipe, se utilizan las mismas funciones de lectura y escritura para un archivo Ejemplo Mostrar en pantalla la fecha y hora actual, con la función popen(). #include <stdio.h> #include <string.h> #include <sys/wait.h> int main(){ FILE *pf; char line[1024]; if( (pf = popen("date", "r")) == NULL ){ perror("error en popen()"); if (fgets(line, sizeof(line), pf) == NULL) { fprintf(stderr, "No hay salida del comando ejecutado\n"); printf("salida:%s\n", line); return(exit_success); 5.2 Creación de PIPES avanzadas Una pipe puede ser creada con la función pipe(): int pipe (int name[2]); Se crean dos descriptores de archivo, uno para lectura (name[0]) y otro para escritura (name[1]). Lo que se escribe por name[1] se puede leer por name[0]. Gráficamente, se tiene lo que se muestra en la Figura

17 stdin name[0] READ stdout name stderr name[1] WRITE Figura 14 Condiciones especiales: Si el extremo escritor cierra la pipa, el lector puede continuar hasta que los datos terminan y luego recibe EOF (end-of-file). Si el extremo lector cierra la pipe, un intento por escribir en la pipe genera la señal SIGPIPE. Ahora bien, el poder real de esta función, es permitir la comunicación entre un proceso padre y sus procesos hijos, debido a que la función fork() copia todos los descriptores de archivos (y una pipe es un tipo de descriptor), tal como se muestra en la Figura 15. pipe(int name[2]) fork(); stdin name[0] READ stdin name[0] READ name[0] stdin stdout name stdout Padre name Hijo stdout stderr name[1] WRITE stderr name[1] WRITE name[1] stderr Figura 15 Luego, una comunicación entre ambos procesos se logrará cuando ambos procesos cierren adecuadamente sus descriptores. 5.3 Duplicación de descriptores Un problema que nace en este tipo de comunicación es cómo copiar los datos de los descriptores básicos de un proceso (stdin, stdout y stderr). Por ejemplo, si el proceso hijo genera un resultado por su stdout, éste podría ser utilizado por el proceso padre. Para esto, el stdout debería copiarse (duplicarse) al descriptor name[1] de la pipe. Para la duplicación de descriptores, exiten las funciones dup() y dup2(), cuya sintaxis es: int dup (int file_descrip); int dup2(int file_descrip_source, int file_descrip_dest); dup() retorna un nuevo descriptor de archivo que referencia el mismo que file_descrip. dup2() causa que el descriptor de archivo file_descrip_dest se refiera al mismo contenido que file_descrip_source. El problema que se mencionó, se soluciona utilizando la función dup2() Ejemplo Se tiene un archivo de texto, denomindo conexiones.txt, que contiene las conexiones hacia un servicio determinado, tal como se muestra en la Tabla 4. Se quiere hacer un programa que muestre en 17

18 pantalla el contenido de dicho archivo, a través de la creación de un proceso y comunicación entre el hijo y el padre. El proceso hijo revisa el archivo y envía el contenido al padre. En el diseño de la solución, se debe visualizar la situación de la Figura 16, que representa el instante en que se realiza el fork() y la lógica de funcionamiento del padre y del proceso hijo. stdout stderr stdin fd[0] Padre imprime en pantalla el contenido del archivo fd[1] READ fd WRITE fd[0] Hijo cat conexiones.txt fd[1] stdin stdout stderr Figura 16 Claramente, no hay una comunicación entre ambos procesos, ya que el proceso hijo envía el contenido a su stdoout (pantalla) y éste no está conectado con nada. Bajo este diseño, el esqueleto de la solución sería: int main(){ //inicializaciones varias pid = fork(); if( pid == 0 ){ execl("/bin/cat", "cat", "conexiones.txt", 0); exit(exit_success); else if( pid > 0 ) { while (read(fd[0], line, 10) > 0) write(stdout_fileno, line, 10); //fin if del fork return(exit_success); Para lograr la comunicación, se debe programar el sistema que se muestra en la Figura 17. Para lograr que el stdout se copie en fd[1], se debe utilizar la función dup2(). stdout stderr stdin fd[0] Padre imprime en pantalla el contenido del archivo fd[1] READ fd WRITE fd[0] Hijo cat conexiones.txt fd[1] stdin stdout stderr Figura 17 Además, para forzar un funcionamiento sincrónico, es necesario que el sistema funcione como se indica en la Figura 18. Esto se logra con la función waitpid(). 18

19 Hijo Sistema Operativo fork() Resto del programa exit() exec( cat ) comando Figura 18 La segunda versión del código se muestra a continuación, resaltando las líneas que se agregaron. int main(){ //inicializaciones varias pid = fork(); if( pid == 0 ){ dup2(fd[1], STDOUT_FILENO); close(fd[0]); execl("/bin/cat", "cat", "conexiones.txt", 0); exit(exit_success); else if( pid > 0 ) { close(fd[1]); waitpid(pid, &status, 0); while (read(fd[0], line, 10) > 0) write(stdout_fileno, line, 10); //fin if del fork return(exit_success); A pesar de que este código funciona, al ejecutarlo se envían datos con ruido al padre: #./ejemplo ;connected ;offline ;connected ;offline [??`u? # La manera de leer los datos a través de una pipe, es crear un flujo de datos (parecido a un archivo) con la función fdopen()y fclose():... FILE* input;... int main() {... input = fdopen(fd[0],"r"); while( fgets(line, 100, input) ){ printf("%s", line); fclose(input);... Finalmente, el código final es: 19

20 #include <stdio.h> #include <string.h> #include <sys/wait.h> int main(){ int pid, status; char line[100]; int fd[2]; FILE* input; pipe(fd); pid = fork(); if( pid == 0 ){ dup2(fd[1], STDOUT_FILENO); close(fd[0]); execl("/bin/cat", "cat", "conexiones.txt", 0); exit(exit_success); else if( pid > 0 ) { close(fd[1]); waitpid(pid, &status, 0); input = fdopen(fd[0],"r"); while( fgets(line, 100, input) ){ printf("%s", line); fclose(input); //fin if del fork return(exit_success); 20

21 6 Comunicación entre procesos mediante FIFOS FIFO (First In First Out) se conoce también como una pipe con nombre. Es un archivo especial, donde múltiples procesos pueden abrir, leer y escribir sobre él. Es muy similar a un pipe, pero la comunicación no está confinada a procesos relacionados (padre-hijo). Para crear un FIFO, se debe utlizar la función mkfifo(), cuya sintaxis es: #include <sys/stat.h> int mkfifo (const char *path, mode_t mode);, donde path es el nombre de la FIFO a ser creada en el sistema de archivo, la cual no debe existir previamente. El parámetro mode corresponde a los permisos a nivel de sistema operativo 7. Normalmente, basta con que tengan permisos de lectura y escritura para el usuario, por lo que mode=600. Esta función retorna 0 si la operación fue exitosa, -1 en caso contrario. Al crear un FIFO, éste se bloquea por omisión. En otras palabras, si se crea un FIFO para escritura, se bloqueará hasta que cualquier otro proceso lo abra para escritura, y viceversa. Para desactivar la opción de bloqueo se puede usar la bandera O_NONBLOCK en la llamada open() Ejemplo 1 Se requiere implementar el sistema de la Figura 19. El proceso servidor espera datos que provienen de un canal de datos implementado a través de un FIFO de nombre CANAL y los imprime en pantalla. Luego, el proceso termina. El FIFO debe ser creado y eliminado por este proceso. La información enviada al canal de datos es el contenido de un archivo. Usuario envía contenido de un archivo Canal de datos Servidor Imprime contenido en pantalla Figura 19 Primero se debe crear una estructura de la solución y luego plantear el código fuente. Estructura de la solución La estructura de la solución podría ser la que se muestra en la Figura 20: Consola del sistema recibefd stdin # cat conexiones.txt > CANAL CANAL (fifo) Servidor Imprime datos del CANAL (fifo) en pantalla stdout stderr Figura 20 El ámbito del proceso servidor es el sistema bajo el rectángulo. Para implementarlo, debe cumplir con los siguientes requerimientos: