IPC Repaso: Procesos

Transcripción

1 Inter-process Communication (C): Repaso Un repaso al uso de Procesos Estructura de un proceso Creación de procesos Señales Inter-Process Communication (C) Tuberías (pipes) y FIFOs Mecanismos C Semáforos Memoria compartida Colas de mensajes Sockets C Repaso: Procesos Estructura de un proceso Creación de procesos Señales

2 Estructura de un Proceso Programas y Procesos. La estructura de todo programa ejecutable creado por el compilador del lenguaje viene impuesta por el sistema. La estructura general de un programa se compone de las siguientes partes: Una cabecera que describe los atributos del archivo. Un bloque de instrucciones i en lenguaje máquina del programa. Este bloque se conoce en UNIX como texto del programa. Un bloque dedicado a la representación en lenguaje máquina de los datos que deben ser incializados al ejecutarse el programa. Se indica la cantidad de memoria requerida por los datos. Tradicionalmente este bloque se conoce como BSS (Block Started by Symbol). Otras secciones como tablas de símbolos. 3 PC: Repaso Programas y Procesos. Estructura de un Proceso TEXT : Es una copia de la sección TEXT del ejecutable (código) DATA : Contiene las variables globales estáticas ya inicializadas BSS : Contiene las variables globales estáticas no inicializadas TEXT DATA BSS STACK USER AREA 4

3 Programas y Procesos. Estructura de un Proceso STACK: Se crea cuando se ejecuta el programa y el sistema gestiona automáticamente el crecimiento de la pila cuando el proceso realiza llamadas a funciones. En la pila se almacenan : oentorno del proceso (pares nombre : valor) oparámetrosempleadosenlallamdaacadafunción(ymain) ovalores de los registros del procesador antes de cada llamada a función así como los registros de propósito general USER AREA: Esta zona pertenece al espacio de direccionamiento del kernel,luego no es accesible por el proceso. Aquí se almacenan los datos necesarios para la ejecución del proceso. La zona marcada como " " se emplea para la expansión de los segmentos de datos y pila. Con las órdenes brk() y sbrk() puedo hacer crecer el área BSS y DATOS. 5 PC: Repaso Programas y Procesos. Estructura de un Proceso Cuando un programa es cargado en memoria por el kernel para ejecutarse, se convierte en un proceso. Enun proceso no sólo hay una copia del programa, sino que además el kernel le añade información ión adicional ion para poder manejarlo. Programa a.out kernel Proceso 6

4 Estructura de un Proceso Programas y Procesos. Un proceso se compone de tres bloques fundamentales que se conocen como segmentos: Segmento de Texto Segmento de Datos Segmento de Pila 7 PC: Repaso Programas y Procesos. Estructura de un Proceso Debido a que los procesos se ejecutan en dos modos usuario y kernel; el sistema maneja pilas por separado Modo usuario Modo kernel Pila Usuario Pila kernel 8

5 Estructura de un Proceso Modos de operación El sistema operativo tiene dos modos de operación : Modo USER :El procesador ejecutará instruccionesi contenidas en el segmento TEXT del proceso de usuario. No puede acceder nunca a datos del kernel. Modo SYSTEM : Los procesos pueden ejecutar instrucciones privilegiadas y acceder a datos del kernel. Cualquier proceso puede cambiar su modo de operación debido a tres causas englobadas en dos tipos de eventos : Eventos internos al proceso Eventos externos al proceso 9 PC: Repaso Estructura de un Proceso Eventos internos al proceso (síncronos) Traps : Son producidos de forma involuntaria por el proceso que está en ejecución (desbordamiento de pila, violación del segmento...). En estos casos el kernel ejecutará rutinas especiales que pueden provocar que el proceso sea abortado. Todos estos eventos deben ser gestionados en modo system. Llamadas al sistema : Son un caso especial de traps. En este caso el proceso provoca un trap de forma deliberada para obtener una vía de entrada al kernel y ejecutar una determinada funciónenmodosystem(porejemploread() ). Eventos externos al proceso (asíncronos) Interrupciones : Et Este tipo de eventos se pueden producir en cualquier momento no guardando relación con el proceso en ejecución en la mayotía de los casos (por ejemplo la interrupción del reloj...). 1 0

6 Programas y Procesos. Estructura de un Proceso Un proceso en UNIX es una entidad que se crea tras la llamada fork. Todos los procesos, excepto el primero (proceso número 0), son creados mediante una llamada a fork. El proceso que llama a fork se conoce como proceso padre yel proceso creado es el proceso hijo. Todos los procesos tienen un único proceso padre, pero pueden tener varios procesos hijos. El kernel identifica cada proceso por su PID (Process IDentification), que es un número asociado a cada proceso y que no cambia durante el tiempo de vida de este. 1 1 PC: Repaso Estructura de un Proceso Estados básicos de un proceso. 1 Ejecutandose en modo usuario Llamada al sistema o interrupción Ejecutandose en modo kernel dormir 2 retorno interrupción retorno de interrupción orden de ejecución por parte del scheduler durmiendo despertar 4 3 listo para ejecutarse 1 2

7 Estados de un proceso. Estructura de un Proceso 1 3 PC: Repaso Estructura de un Proceso Tabla de Procesos y Area de Usuario. Todo proceso tiene asociadas una entrada en la tabla de procesos y un área de usuario (uarea). Estas son dos estructuras que describen el estado del proceso permitiendo al kernel el control del proceso. Las áreas de usuario se reservan cuando se crea un proceso. Los campos de la tabla de procesos son los siguientes: Campo de estado del proceso. Campo para localizar el proceso y su área de usuario. Algunos identificadores de usuario (UIDs). Identificadores de proceso (PIDs). Descriptores de eventos. Parámetros de planificación. Un campo de señales. Algunos temporizadores. 1 4

8 Estructura de un Proceso Tabla de procesos y área de usuario. El área de usuario contiene información que se utiliza cuando el proceso se está ejecutando, algunos de los campos son los siguientes: Puntero a la entrada de la tabla de procesos Los identificadores de usuario real y efectivo (UID). Temporizadores. Un array que indica cómo va a responder el proceso a las señales que recibe. El terminal de login asociado al proceso. Un registro de errores. Uncampodevalorderetorno. Parámetros de entrada/salida. El directoriod e trabajo actual (CWD) y el directorio raíz asociado al proceso. La tabla de descriptores de archivos. Campos de límite que restringen el tamaño del proceso y de algún archivo. Una máscara de permiso. 1 5 PC: Repaso Estructura de un Proceso Contexto de un Proceso. El contexto de un proceso es su estado, definido por su código, los valores de sus variables de usuario globales y sus estructuras de datos, el valor de los registros de la CPU, los valores almacenados en su entrada de la tabla de procesos y en su área de usuario, y el valor de sus pilas de usuario y de kernel. Cuando el kernel decide que debe ejecutar otro proceso, realiza un cambio de contexto, lo que da lugar a que el kernel guarde la información ió necesaria parapoder reanudar la ejecución del proceso en el punto donde la dejo. El cambio de modo usuario a kernel y viceversa no se considera un cambio de contexto. 1 6

9 Contexto de un Proceso. Estructura de un Proceso Desde un punto de vista formal el contexto de un proceso es la unión de su contexto de nivel de usuario, su contexto de registro y su contexto de nivel de sistema. Contexto de nivel de usuario Contexto de registro Contexto de nivel de sistema 1 7 C Repaso: Procesos Estructura de un proceso Creación de procesos Señales

10 Creación de Procesos Ejecución de programas mediante EXEC. El resultado que se obtiene con estas funciones es cargar un programa en la zona de memoria del proceso que ejecuta la llamada, sobre-escribiendo los segmentos del programa antiguo con los del nuevo. El contenido del contexto del nivel de usuario del proceso que llama a exec deja de ser accesible y es reemplazado con el del nuevo programa. Es decir, el programa viejo es sustituido por el nuevo y nunca retornaremos a él para proseguir su ejecución, ya que es el programa nuevo el que pasa a ejecutarse. 1 9 PC: Repaso Creación de Procesos Ejecución de programas mediante EXEC. En cualquiera de sus formatos, una llamada a exec superpone la imagen del proceso nuevo sobre la del antiguo. Exec sustituye el segmento de código del proceso original con el del nuevo y crea un nuevo segmento de datos. Los descriptores de ficheros abiertos por el programa inicial permanecen abiertos en el nuevo, con la excepción de aquellos que tengan activo el bit close_on_exec. on exec Las zonas de memoria compartidas del programa antiguo no se conectan al nuevo programa. 2 0

11 Creación de Procesos Ejecución de programas mediante EXEC. La diferencia entre las distintas llamadas a exec está en : o Formato de su argumentos o Entorno de trabajo o La variable PATH Las funciones son (<unistd.h>) : o int execv (const char *path, const char *argv[]) o int execl (const char *path, const char *arg0,..., const char *argn) o int execve (const char *path, const char *argv[], const char *env[]) o int execle (const char *path, const char *arg0,...,const char *argn,const char *env[]) o int execvp (const char *fich, const char *argv[]) o int execlp (const char *fich, const char *arg0,..., const char argn) El programa llamado con exec heredará el user area del proceso que realiza la llamada por lo tanto recibirá: el PID, PGID y TGID (terminal group id). 2 1 PC: Repaso Creación de Procesos Creación de procesos mediante FORK. La única forma de crear un proceso en UNIX es mediante la llamada a fork. El proceso que invoca a fork se llama proceso padre y el proceso creado es el proceso hijo. #include <sys/types.h> yp pid_t fork(); La llamada a fork hace que el proceso que lo invoca se duplique. A la salida de fork los dos procesos tienen una copia idéntica del contexto de nivel de usuario excepto el valor del PID, queparael proceso padre toma el valor del PID del proceso hijo y para el proceso hijo toma el valor de

12 Creación de procesos mediante FORK. Creación de Procesos La llamada a fork realiza las siguientes operaciones: 1. Busca una entrada libre en la tabla de procesos y la reserva para el proceso hijo. 2. Asigna un identificador de proceso para el proceso hijo. 3. Realiza una copia del contexto t del nivel deusuario del proceso padre para el proceso hijo. 4. Las tablas de control de archivos locales al proceso se copian también del proceso padre al hijo, ya que forman parte del contexto de nivel de usuario. 5. Retorna al proceso padre el PID del proceso hijo, y al proceso hijo le devuelve el valor de PC: Repaso El proceso hijo hereda: o o o o o o o o Creación de Procesos Los id real y efectivo de usuario y grupo El entorno del proceso (las variables que hayan sido exportadas) Los valores para la manipulación de señales La clase del proceso Los segmentos de memoria compartida El directorio root y el actual La máscara de creación de ficheros Los límites de recursos y el terminal de control asociado. El proceso hijo difiere en: o o o o El hijo tiene un ID de proceso único Dispone de una copia privada de los descriptores de archivos abiertos por el padre El conjunto de señales pendientes del proceso hijo es vaciado El hijo no hereda los bloqueos de ficheros establecidos por el padre 2 4

13 Creación de Procesos Terminación de un proceso EXIT y WAIT. Un proceso puede terminar su ejecución mediante una llamada a exit() o al recibir una señal o al finalizar su función main(). El formato de exit() es el siguiente : #include <stdlib.h> void exit (int status) Finaliza el proceso liberando los recursos que estaba utilizando : libera áreas de memoria, cierra los ficheros y se autoelimina de la tabla de procesos. El valor de status es pasado a la llamada wait() del proceso padre y los valores pueden ser: 0 Todo es correcto Indican códigos de error definidos por el usuario 2 5 PC: Repaso Terminación de un proceso EXIT y WAIT. Creación de Procesos La llamada a exit termina la ejecución de un proceso y le devuelve el valor de status al sistema. La llamada a exit tiene las siguientes consecuencias: El contexto t del proceso es descargadod de memoria. Sielprocesopadredelqueejecutalallamadaaexitestáejecutando una llamada a wait, se le notifica la terminación de su proceso hijo y se le envían los 8 bits menos significativos de status. Si el proceso padre no está ejecutando una llamada a wait, el proceso hijosetrasformaenunprocesozombi.tieneunaentradaenlatablade procesos y su contexto es descargado de memoria. 2 6

14 Creación de Procesos Terminación de un proceso EXIT y WAIT. La declaración de wait es la siguiente: #include <sys/types.h> pid_t wait(stat_loc); i( int *stat_loc; La llamada a wait suspende la ejecución del proceso que la invoca hasta que alguno de sus procesos hijo termina. 2 7 PC: Repaso Terminación de un proceso EXIT y WAIT. Creación de Procesos Exit y wait se utilizan para conseguir que el proceso padre espere a la terminación del rpoceso hijo. int pid, estado; if ((pid=fork())==-1) /*Error en la creación del proceso*/ perror("error en la llamada a fork"); else if(pid == 0){ } else{ } /*Código del proceso hijo*/ exit(10); /*Código del proceso padre*/ pid=wait(&estado); 2 8

15 C Repaso: Procesos Estructura de un proceso Creación de procesos Señales PC: Repaso Señales Una señal es un mensaje de un proceso a otro con relación de parentesco. Estas señales software se envían en un instante determinado pero el proceso no sabe cuando le llega, ni quien se la envía, pero si sabe que interrupción le llega. El Unix SVR4 pone a disposición del usuario 31 interrupciones (la int. 32 está a disposición de cada fabricante). Las interrupciones 16 y 17 son de usuario y los procesos las pueden utilizar para comunicarse. Se agrupan en cinco categorías: Condiciones hardware Condiciones software Notificaciones de E/S Control de Procesos Control de recursos 3 0

16 Señales Condiciones hardware :Enviadasporelsistemacuando se produce un error durante la ejecución de un proceso. SIGSEV :Será enviada a un proceso cuando acceda a direcciones que están fuera de su espacio de direccionamiento o a zonas de memoria protegidas. SIGBUS : Cuando se intenta realizar un acceso a un hardware sobre el que no tengo privilegio. SIGILL : Ejecución de una instrucción ilegal. 3 1 PC: Repaso Señales Condiciones software: Señales generadas por un requerimiento del usuario. SIGINT : Generada cuando se pulsa ctrl-c c (es enmascarable). SIGQUIT : Generada cuando se pulsa ctrl-esc SIGTERM : La envía un usuario a un proceso con la orden kill. El procesomorirásinoestáenmodosistema.siloestáseesperaráa que termine. SIGHUP : Indica un corte en la línea de comunicaciones (apagas el terminal). SIGKILL : Indica muerte imperativa. No es enmascarable. SIGUSR1 : Definibles por el usuario. SIGALRM : Es enviada a un proceso cuando alguno de sus temporizadores descendientes llega cero. 3 2

17 3 3 Notificaciones de operaciones de E/S Señales SIGPOLL : La revive un proceso cuando se está produciendo una e/s por un stream que está siendo gestionado por una interrupción poll. Control de procesos SIGSTOP : Saca a un proceso de la zona de swapping (ól (sólo en SVR4). Señal de parada de un proceso. SIGCONT : Lleva al proceso a background. Continua la ejecución del proceso. SIGCLD : El hijo la envía la padre cuando cambia de estado. Control de recursos SIGXCPU : Exceso de consumo de CPU o de memoria por parte del proceso. SIGXFSZ : El proceso ha sobrepasado el tamaño máximo para un archivo. PC: Repaso Señales Tratamiento de las señales recibidas por un proceso Kernel Señal Señal Señal Proceso Inicio Fin Ignora la señal Tratamiento Fin Tratamiento por defecto Fin Volcado de memoria Fin 3 4

18 C Repaso La comunicación puede ser: Local o remota Entre cualquier proceso o con procesos hijos de un mismo padre C=Inter-processI communication = Comunicación ió entre procesos Repasaremos en breve el uso de: Tuberías (pipes) y FIFOs Mecanismos C Semáforosos Memoria compartida Colas de mensajes Sockets PC: Repaso 3 6 C Repaso Se entiende como Inter-process communication (C) alconjuntode técnicas para el intercambio de datos entre múltiples hilos en uno o más procesos Los procesos pudieran estar ejecutándose en una o más computadoras as conectadas via una red. Las técnicas de C están dividas por diferentes métodos: paso de mensajes, sincronización, memoria compartida, y llamadas a procedimientos remotos (RPC). El método C que se utilice puede variar con base en el ancho de banda y la latencia de la comunicación entre los hilos de ejecución, así como el tipo de dato a ser comunicado. Existen varias razones para proporcionar un ambiente que permita la cooperación entre procesos: Compartición ió de información ió Aceleración al momento de ejecutar una tarea Modularidad Conveniencia Separación de privilegios C pudiera ser referido también como inter-thread communication e inter-application communication.

19 C:Razones Necesitamos que los procesos se comuniquen y sincronicen La sincronización puede ser imprescindible Los procesos en UNIX no comparten memoria, ni siquiera entre padres e hijos (aunque los hijos heredan los descriptores de archivo del padre) Con señales podríamos comunicar procesos, pero la información que se envía es solo un número 3 7 PC: Repaso La forma más antigua de C Unix. Está presente en todo sistema Unix Limitaciones: Son half-duplex Tuberías (pipes) Solo pueden ser usadas entre procesos que tienen un padre común 3 8

20 #include <unistd.h> int pipe(int filedes[2]); Tuberías (pipes) pipe pp crea una tubería: filedes[1] es un descriptor de fichero de escritua filedes[0] es un descriptor de lectura Lo que se escribe en filedes[1] se lee en filedes[0] 3 9 PC: Repaso Tuberías (pipes) Normalmente, un proceso crea un pipe y luego hace un fork Si se quiere comunicación de padre a hijo, se cierra el descriptor de lectura del padre y el lde escritura del lhijo Si se quiere comunicación de hijo a padre, se cierra el descriptor de escritura del padre y el de lectura del hijo 4 0

21 Tuberías (pipes) padre fd[0] fd[1] hijo fd[0] fd[1] 4 1 PC: Repaso int n, fd[2]; pid_t pid; char line[maxline]; Tuberías (pipes) if (pipe(fd) < 0) if ((pid=fork()) < 0)... else if (pid>0) { close(fd[0]); write(fd[1], hola hijo\n,10); } else { close(fd[1]); n=read(fd[0],line,maxline); write(stdout_fileno, line, n); }

22 Tuberías (pipes) El pipe usa un buffer Cuando el buffer está lleno, write(fd[1]...) se bloquea Cuando el buffer está vacío, read(fd[0]...) se bloquea Si se intenta escribir cuando el extremo lector ha cerrado se genera SIGPE Cuando se cierra el extremo escritor, se recibe un end-of-file tras la recepción de los últimos datos 4 3 PC: Repaso Tuberías (pipes) Para comunicación full-duplex tendríamos que usar dos pipes Otra posibilidad útil: el hijo hace un exec para ejecutar un programa. Pero antes el hijo conecta fd[0] a stdin, con lo que el padre puede enviar datos a la entrada estándar del programa Ejemplo

23 Tuberías (pipes) #include <stdio.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> int main () { int fds[2]; pid_t pid; /* Create a pipe. File descriptors for the two ends of the pipe are placed in fds. */ pipe (fds); /* Fork a child process. */ pid = fork (); if (pid == (pid_t) 0) { } /* This is the child process. Close our copy of the write end of the file descriptor. */ close (fds[1]); /* Connect the read end of the pipe to standard input. */ dup2 (fds[0], STDIN_FILENO); /* Replace the child process with the sort program. */ execlp ( sort sort, sort, 0); 4 5 PC: Repaso Tuberías (pipes) else { /* This is the parent process. */ FILE* stream; /* Close our copy of the read end of the file descriptor. */ close (fds[0]); /* Convert the write file descriptor to a FILE object, and write to it. */ stream = fdopen (fds[1], w ); fprintf (stream, This is a test.\n ); t fprintf (stream, Hello, world.\n ); fprintf (stream, My dog has fleas.\n ); fprintf (stream, This program is great.\n ); fprintf (stream, One fish, two fish.\n ); fflush (stream); close (fds[1]); /* Wait for the child process to finish. */ waitpid (pid, NULL, 0); } return 0; } 4 6

24 FIFOs También llamados pipes con nombre (named pipes) Funcionan usando el sistema de archivos; una FIFO es un tipo especial de fichero Permiten comunicación entre dos procesos cualesquiera 4 7 PC: Repaso FIFOs Desde el shell, podemos crear una con el comando mkfifo command. Por ejemplo: % mkfifo /tmp/fifo/fif % ls -l /tmp/fifo prw-rw-rw- 1 vjsosa users 0 Jan 24 14:04 /tmp/fifo En una ventana leemos de la FIFO: % cat < /tmp/fifo En otra ventana, escribimos a la FIFO: % cat > /tmp/fifo Tecleamos algunas líneas de texto. Cada vez que se pulsa ENTER la línea es enviada por la FIFO, y aparece en la primera ventana Cerramos la FIFO pulsando Ctrl+D en la segunda ventana. Eliminados la FIFO con: % rm /tmp/fifo 4 8

25 #include <sys/types.h> #include <sys/stat.h> int mkfifo(const char *name, mode_t mode); FIFOs mode indica permisos de acceso de propietario, grupo y otros, y otros flags de acceso Pueden usarse llamadas a sistema de E/S ó funciones de E/S de librería C estándar: int fd = open (fifo_path, O_WRONLY); write (fd, data, data_length); close (fd); FILE* fifo = fopen (fifo_path, r ); r); fscanf (fifo, %s, buffer); fclose (fifo); 4 9 PC: Repaso FIFOs Una FIFO debe tener al menos un lector y un escritor. Puede haber muchos lectores y escritores, pero hay que tener en cuenta los posibles solapes en las escrituras La constante PE_BUF define el número máximo de caracteres que se pueden escribir en una FIFO atómicamente Funcionamiento depende del flag O_NONBLOCK: Si no se especifica, un open de solo lectura se bloquea hasta que otro proceso abra el FIFO para escritura, y viceversa Si se especifica, un open de solo lectura retorna inmediatamente. Un open de solo escritura retorna un error si ningún proceso tiene la FIFO abierta para lectura 5 0

26 FIFOs Ejemplo de aplicación: Un servidor y varios clientes que se comunican con aquel mediante una FIFO de nombre conocido Los clientes escriben sus peticiones en la FIFO. Las peticiones deben tener longitud inferior a PE_BUF, para que no haya solape Pero, cómo responde el servidor a los clientes? 5 1 PC: Repaso FIFOs Una solución es que cada cliente envíe su PID en la petición. El servidor crea entonces una FIFO específica por cada cliente, con un nombre basado en su PID El servidor escribe la respuesta en esta FIFO. El lector, que conoce su nombre, lee la respuesta 5 2

27 C de Unix System V Las estructuras C (semáforos, colas de mensajes y segmentos de memoria compartida) están en el núcleo, como los pipes, y no en el sistema de archivos, como las FIFO Nos referimos a cada objeto C a través de un identificador, un entero positivo único Cada estructura C se crea con una función get: semget para semáforos msgget para colas de mensajes shmget para memoria compartida Al crear una estructura C hay que especificar una clave de tipo key_t (def. ensys/types.h) yp ) que el núcleo utilizará para generar el identificador. key_t es un entero Posteriores llamadas a la función get utilizando la misma clave no crean una estructura, sino que devuelven el identificador asociado a la existente Esto permite que dos o más procesos llamen a una función get con la misma clave para establecer comunicación mediante C 5 3 PC: Repaso C de Unix System V cómo asegurar que todos los procesos que quieran usar la misma estructura C utilicen la misma clave? Una posibilidad es pasar a la función get la clave C_PRIVATE. Esto creará una nueva estructura, y nos devuelve un identificador Luego podemos os guardar ese identificador en un fichero eo accesible a los otros procesos. O en el caso de que el padre haga un fork y el hijo un exec, se puede pasar el identificador mediante un parámetro al exec Otro método: poner la clave en un archivo cabecera (.h) común. Pero: Unprocesonosabeenprincipiosiestácreandounaestructurao usando una que ya creó otro proceso El valor de la clave podría ya estar en uso por otro programa no relacionado 5 4

28 C de Unix System V Problemas del C de Unix System V: Tiene una interfaz de programación compleja No se mantiene contador del nº de procesos que está usando una estructura => no hay un método automático para reclamar estructuras t C abandonadas. Si un proceso crea y usa una estructura y termina sin eliminarla apropiadamente, p la estructura permanece hasta que: Se reinicie el sistema Se elimina específicamente con el comando ipcrm Otro proceso la elimina 5 5 PC: Repaso Semáforos Controlan el acceso a un recurso compartido Un semáforo binario puede tener dos valores: 0=el recurso está siendo usado por un proceso, no deben acceder otros procesos 1=el recurso está libre para ser usado por cualquier proceso Si un proceso intenta usar el recurso pero el semáforo está a cero, se bloquea Cuando el semáforo esté a uno se desbloqueará y podrá acceder al recurso 5 6

29 Creación o acceso a uno existente: #include <sys/ipc.h> #include <sys/sem.h> #include <sys/types.h> int semget(key_t key, int nsems, int flags); Semáforos Se crea un conjunto de nsems semáforos, si key es C_PRIVATE o si key no está ya en uso y flags tiene el bit C_CREAT C activado En flags también puede especificarse permisos de acceso (lectura y alteración, pero no de ejecución), de usuario, grupo y otros semget devuelve un identificador del semáforo Ejemplo: int semid=semget(c_private, 1, C_CREAT 0744); 5 7 PC: Repaso Para control del semáforo: Semáforos #include <sys/ipc.h> #include <sys/sem.h> #include <sys/types.h> int semctl(int semid, int semnum, int cmd, union semun arg); semnum es el nº del semáforo del conjunto en con que se quiere operar (entre 0 y nsems-1) ) cmd indica la operación a realizar. Según el valor de cmd arg contendrá otras opciones 5 8

30 Semáforos Las operaciones más interesantes son: GETVAL, retorna el valor actual del semáforo SETVAL, modifica el valor del semáforo (un cuarto parámetro entero especifica el nuevo valor) C_RMID, destruye el semáforo 5 9 PC: Repaso Semáforos La función semop realiza atómicamente un conjunto de operaciones sobre semáforos, pudiendo bloquear al proceso llamador: #include <sys/ipc.h> #include <sys/sem.h> #include <sys/types.h> int semop(int semid, struct sembuf sops[], size_t nsops); sops es un puntero a un vector de operaciones, nsops indica el nº de operaciones solicitadas 6 0

31 struct sembuf { unsigned short sem_num; short sem_op; short sem_flg; SEM_UNDO }; Semáforos // nº del semáforo dentro del conjunto // clase de operación // según sea >0, <0 o ==0 // modificadores, C_NOWAIT, 6 1 PC: Repaso Algoritmo: Semáforos si semop<0 si semval >= semop semval -= semop si semval < semop si semop>0 semval += semop si semop==0 si semval = 0 SK si semval!= 0 si (semflag & C_NOWAIT)!=0 la función semop() retorna si no bloquearse hasta que semval >= semop semval -= semop si (semflag & C_NOWAIT)!=0 la función semop() retorna si no bloquearse hasta que semval == 0 6 2

32 Resumiendo un poco: Semáforos si el campo sem_op de una operación es positivo, se incrementa el valor del semáforo. si sem_op es negativo, se decrementa el valor del semáforo si el resultado no es negativo. En caso contrario el proceso espera a que se dé esa circunstancia. Es decir, sem_op==1 produce una operación V (signal) y sem_op== op==-1, una operación P (wait) 6 3 PC: Repaso #include <sys/types.h> /* para key_t */ /* Crea un semáforo con un valor inicial, dada una clave */ /* Devuelve el identificador (válido o no) del semáforo */ int crea_sem ( key_t clave, int valor_inicial ); /* Operaciones P y V sobre un semáforo */ void sem_p ( int semid ); void sem_v ( int semid ); Semáforos /******** IMPLEMENTACIÓN *******/ #include <sys/ipc.h> #include <sys/sem.h> #define PERMISOS 0644 /* crea_sem: abre o crea un semáforo */ int crea_sem ( key_t clave, int valor_inicial ) { int semid = semget( /* Abre o crea un semáforo... */ clave, /* con una cierta clave */ 1, /* con un solo elemento */ C_CREAT PERMISOS ); if ( semid==-1 ) return -1; /* Da el valor inicial al semáforo */ semctl ( semid, 0, SETVAL, valor_inicial ); return semid; } /* lo crea (C_CREAT) con unos PERMISOS */ 6 4

33 /* abre_sem: Abrir un semáforo que otro proceso ya creó */ int abre_sem (key_t clave) { return semget(clave,1,0); } /* Operaciones P y V */ void sem_p ( int semid ) /* Operación P (wait) */ { struct sembuf op_ P [] = { 0, -1, 0 /* Decrementa semval o bloquea si cero */ }; semop ( semid, op_p, 1 ); } void sem_v ( int semid ) /* Operación V (signal) */ { struct sembuf op_v [] = { 0, 1, 0 /* Incrementa en 1 el semáforo */ }; semop ( semid, op_v, 1 ); } Semáforos 6 5 PC: Repaso Memoria compartida Crear segmentos de memoriaalos que pueden acceder múltiples procesos, pudiendo definirse restricciones de acceso (sólo lectura) Para trabajar con memoria compartida es necesario crear un vínculo (attachment) entrela memoria local del proceso y el segmento compartido El proceso que vincula un segmento de memoria compartida creeestar trabajando conella como si fuera cierta área de memoria local 6 6

34 Memoria compartida Para obtener un segmento de memoria: #include <sys/ipc.h> #include <sys/types.h> #include <sys/shm.h> int shmget( key_t key, size_t size, int shmflg); La función shmget retorna el identificador de memoria compartida asociada a key. 6 7 PC: Repaso #include <sys/ipc.h> #include <sys/types.h> #include <sys/shm.h> char *shmat( int shmid, void *shmaddr, int shmflg ); int shmdt( void*shmaddr ); Memoria compartida shmat asocia el segmento de memoria compartida especificado por shmid al segmento de datos del proceso invocador. shmdaddr es la posición en el espacio de direccciones del proceso donde queremos mapear el segmento compartido Si shmaddr tiene valor cero el segmento se asocia a una posición en memoria seleccionado por el sistema operativo (dentro del espacio de direcciones del proceso) shmaddr podrá tener un valor distinto de cero, pero no usaremos esta posibilidad Un segmento se asocia en modo sólo lectura si shmflg & SHM_RDONLY es verdadero shmdt desasocia del segmento de datos del proceso invocador el segmento de memoria compartida ubicado en la localización de memoria especificada por shmaddr 6 8

35 Memoria compartida #include <sys/shm.h> int smctl(int shmid, int cmd, struct shmid_ds *buff); La función shmctl permite realizar un conjunto de operaciones de control sobre una zona de memoria compartida identificada por shmid. El argumento cmd se usa para codificar la operación solicitada. Los valores interesantes para este parámetro son: C_STAT: lee la estructura de control asociada a shmid y la deposita en la estructura apuntada por buff. C_RMID: elimina el identificador de memoria compartida especificado por shmid del sistema, destruyendo el segmento de memoria compartida y las estructuras de control asociadas. El segmento desaparecerá cuando el último proceso que lo utiliza notifique su desconexión del segmento SHM_LOCK: bloquea la zona de memoria compartida especificada por shmid. Este comando sólo puede ejecutado por el superusuario SHM_UNLOCK: desbloquea la región de memoria compartida especificada por shmid. Solo superusuario 6 9 PC: Repaso Memoria compartida #include <stdio.h> #include <sys/shm.h> #include <sys/stat.h> int main () { int segment_id; char* shared_memory; struct shmid_ds shmbuffer; int segment_size; const int shared_segment_size = 0x6400; /* Allocate a shared memory segment. */ segment_id = shmget (C_PRIVATE, shared_segment_size, C_CREAT C_EXCL S_IRUSR S_IWUSR); 7 0

36 Memoria compartida /* Attach the shared memory segment. */ shared_memory = (char*) shmat (segment_id, 0, 0); printf ( shared memory attached at address %p\n, shared_memory); /* Determine the segment s s size. */ shmctl (segment_id, C_STAT, &shmbuffer); segment_size = shmbuffer.shm_segsz; printf ( segment size: %d\n, segment_size); /* Write a string to the shared memory segment. */ sprintf (shared_memory, Hello, world. ); /* Detach the shared memory segment. */ shmdt (shared_memory); } /* Deallocate the shared memory segment. */ shmctl (segment_id, C_RMID, 0); return 0; 7 1 PC: Repaso Comandos útiles El comando ipcs muestra información sobre las estructuras C del sistema. Ej.: % ipcs -m Shared Memory Segments key shmid owner perms bytes nattch status 0x user Otras opciones: -q, -s El comando ipcrm permite eliminar estructuras C no eliminadas i por los procesos: % ipcrm shm

37 Ejercicios Implementar el esquema cliente-servidor con FIFOs mencionado en la presentación. Usar un servidor y dos clientes. Pueden usar funciones de E/S de librería C estándar Emplear memoria compartida y semáforos para que dos procesos distintos (no padre e hijo) vayan incrementando una variable entera compartida de forma alternativa. Posible salida en pantalla:... proceso X => 7 procesoy=>8 proceso X => 9 proceso Y => NOTA: Et Este ejercicio i seagregará a los asignados al final 7 3 PC: Repaso Colas de mensajes Son listas de mensajes almacenadas en el kernel La comunicación es en la misma máquina Los mensajes tienen este tipo: long char Los mensajes se pueden extraer en orden FIFO, pero también en otro orden 7 4

38 El receptor puede esperar: Colas de mensajes el siguiente mensaje (orden FIFO) el siguiente mensaje con cierto valor en el campo long El S.O. impone límites máximos a: el nº de bytes de un mensaje el nº de bytes en una cola el nº de colas en el sistema el nº de mensajes en el sistema 7 5 PC: Repaso #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgget(key_t t key,int flag); Colas de mensajes Crea o abre una cola existente flags es análogo a los vistos anteriormente t 7 6

39 Colas de mensajes #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgctl(int msqid, int cmd, struct msqid_ds *buf); Operación de control sobre la cola Según cmd: C_STAT = devuelve la estructura de control asociada a la cola de mensajes C_SET = estableces algunos valores en la estructura de control C_RMID = elimina la cola de mensajes del sistema. La eliminación es inmediata. Otros procesos recibirán el error EIDRM en la sgte. operación que intenten con la cola 7 7 PC: Repaso Colas de mensajes #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgsnd(int msqid, const void *ptr, size_t nbytes, int flag); Envia un mensaje a la cola. Párametros: ptr = apunta al mensaje (long+chars) nbytes = nº de bytes en la parte de chars flag : => 7 8

40 Colas de mensajes Si la cola está llena (el nº de mensajes en la cola es igual al límite del sistema o el nº de bytes en la cola es igual al límite del sistema): Si flag tiene activo C_NOWAIT, msgsnd retorna inmediatamente el error EAGAIN Si flag no tiene activo C_NOWAIT, el proceso que llama a msgsnd se bloquea hasta que: haya espacio para el mensaje la cola sea eliminada del sistema. Se devuelve EIDRM se reciba una señal y se vuelva del manejador de señal. Se devuelve EINTR 7 9 PC: Repaso Colas de mensajes #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgrcv(int msqid, void *ptr, size_t nbytes, long type, int flag); Recibe un mensaje de la cola. Parámetros: ptr = sitio para guardar el mensaje nbytes = nº de bytes de la parte de chars del mensaje. Si el mensaje recibido tiene más de esos bytes el mensaje se trunca si MSG_NOERROR está activo en flag. Si no, se devuelve E2BIG y el mensaje se queda en la cola type: = 0 => se devuelve el primer mensaje en la cola > 0 => se devuelve el primer mensaje en la cola con ese tipo < 0 => se devuelve el primer mensaje cuyo tipo sea menor o igual que el valor absoluto de type 8 0

41 Ejemplos de llamadas: Colas de mensajes int id = msgget(mi_clave, C_CREAT 0666); /* MI_CLAVE estará definida en comun.h */ /* cliente y servidor harán esta misma llamada */... struct amsgbuf { long mtype; char mtext[80]; } mq_test_buf; mq_test_buf.mtype = 123; sprintf(mq_test_buf.mtext, test buf.mtext, testtest message ); msgsnd(id, (struct msgbuf *)&mq_test_buf, sizeof( test message ) + 1, 0);... int status = msgrcv(id, (struct msgbuf *)&mq_test_buf, 80, 123, 0);... msgctl(fd0, C_RMID, (struct msqid_ds *)0); 8 1 Inter-process Communication (C): Repaso Un repaso al uso de Procesos Estructura de un proceso Creación de procesos Señales Inter-Process Communication (C) Tuberías (pipes) y FIFOs Mecanismos C Semáforos Memoria compartida Colas de mensajes Sockets (Continuará como tema aparte..)

42 Ejercicios: Tarea02a: Integrar en un programa, en el que se incluya un menú que permita ejecutar los diferentes ejemplos que se proporcionan en el siguiente documento incluido en la página del curso: 3.1 Prácticas de programación: Comunicación entre procesos -Cs, señales, semaforos: El usuario podrá elegir, vía el menú, el ejemplo a ejecutar y, al momento de la ejecución aparecerá en pantalla: primero una breve descripción de lo que hace el ejemplo y después la salida resultante de la ejecución de dicho ejemplo Tarea02b: Con base a la información que se ofrece en el documento que se incluye en la página del curso bajo el tema: 3.2 Prácticas de programación: Uso de Pthreads: Desarrollar un programa con Pthreads que ejemplifique el uso de semáforos. Deberá incluir con su programa, un archivo README que indique: La descripción del mismo, es decir, qué hace? En qué momento y porqué se está utilizando un semáforo? Qué librerías son necesarias, y en caso de que no se incluyan con el compilador, dónde las descargo? Requerimientos del Sistema Operativo e Instrucciones para compilar y ejecutar el ejemplo 8 3