Comunicación entre procesos en Linux

Recursos disponibles Memoria compartida Semáforos Colas de Mensajes

Obtención de una clave (key) key_t  ftok (char * nom_arch, int Numero ) nom_arch: Nombre de archivo, asegurarse que exista, por ejemplo “/bin/ls” Numero: cualquier entero Todos los programas que usen el mismo nombre de archivo y el mismo número obtendrán la misma clave

Ejemplo #include <sys/shm.h> #include <stdio.h> #include <unistd.h> #define NUM 33 int main(void) { key_t  miclave; miclave=ftok (“/bin/ls”, NUM); }

Memoria compartida: creación de un espacio de memoria compartida int shmget (key_t clave, int tamanio, int flags) clave: la obtenida con ftok tamanio: en bytes flags: permisos de escritura/lectura (como en los archivos) flags de control (IPC_CREAT) Ejemplo: int mem_id; mem_id=shmget (miclave, 1024, 0777|IPC_CREAT);

Memoria compartida: asociación de un puntero char * shmat (int mem_id, char * addr, int flags) mem_id es el identificador obtenido antes con shmget() addr permite indicar a que direccion se debe asociar, es mejor pasar un NULL y dejar que el SO asigne solo flags permite elegir entre R/W o Read Only entre otras cosas, conviene pasar NULL, (R/W) Ejemplo: int *arreglo arreglo = (int *) shmat(mem_id, NULL,NULL);

Memoria compartida: desasociar el puntero int shmdt (char * puntero) puntero es el puntero que queremos desasociar en el programa, esta llamada debe hacerse en cada programa que utilice la memoria compartida. Ejemplo: shmdt((char *)arreglo);

Memoria compartida: borrar la zona de memoria compartida shmctl (int mem_id, int flags, struct shmid_ds * ds) mem_id: es el identificador obtenido antes con shmget() flags: IPC_RMID para borrarla ds: puede ser NULL Ejemplo: shmctl(mem_id,IPC_RMID,NULL)

Estructura shmid_ds Es una estructura asociada al segmento de memoria compartida que contiene información sobre la misma. Algunos de sus campos son: shm_atime toma el valor de la hora actual. shm_lpid toma el valor del PID del proceso llamador. shm_nattch se incrementa o decrementa en uno cada vez que un proceso asocia o desasocia la memoria respectivamente

Semáforos: Un semáforo es un mecanismo del sistema para evitar la colisión cuando dos o más procesos necesitan un recurso. Son variables enteras con operaciones atómicas de inicialización, incremento y decremento con bloqueo. Cada semáforo es un contador que se inicializa a un determinado valor. Cuando un proceso hace uso del recurso asignado a ese semáforo, el contador se decrementa una unidad. Cuando ese proceso libera el recurso, el contador del semáforo se incrementa. El contador de un semáforo siempre registra el número de procesos que pueden utilizar el recurso actualmente. El contador puede tener valores negativos, si el número de procesos que precisan el recurso es mayor al número de procesos que pueden ser atendidos simultáneamente por el recurso.

Semáforos: Es muy importante la característica de atomicidad de las operaciones sobre un semáforo. Para evitar errores provocados por condiciones de carrera (“race conditions”), los semáforos protegen su contador, asegurando que todas las operaciones sobre esa variable entera (lectura, incremento, decremento) son atómicas, es decir, no serán interrumpidas a la mitad de su ejecución. Recordamos que estamos en un entorno multiprogramado en el que ningún proceso se asegura que vaya a ser ejecutado de principio a fin sin interrupción. Las actualizaciones y consultas de la variable contador de un semáforo IPC son la excepción a este hecho: una vez iniciadas, no son interrumpidas.

Semáforos: obtención de un semáforo int semget (key_t clave, int cantidad, int flags) clave: la obtenida con ftok cantidad: la cantidad de semáforos que deseo obtener flags: permisos de escritura/lectura (como en los archivos) flags de control (IPC_CREAT) Ejemplo: int Id_Sem; Id_Sem = semget (miclave, 10, 0600|IPC_CREAT);

Semáforos: inicialización int semctl (int Id_Sem, int indice, int cmd, int cmd_opt). Id_Sem: identificador obtenido con semget() indice: cual de los semaforos obtenidos deseo inicializar cmd: operación a realizar sobre el semaforo cmd_opt: parametros para la operación a realizar Ejemplo: semctl(Id_sem, 0,SETVAL,1); /*semaforo 0 en verde*/ semctl(Id_sem, 2,SETVAL,0); /*semaforo 2 en rojo*/

semáforos: utilización int semop (int Id_Sem, struct sembuf *s, size_t n_s) Id_Sem: identificador obtenido con semget() s: estructura con la operación sobre el semáforo n_s: cantidad de elementos en s Ejemplo int valor; struct sembuf s; s.sem_num=0; s.sem_op= -1; s.sem_flg=0; valor=semop(Id_sem,&s,1);

struct sembuf short sem_num índice del array del semáforo sobre el que se quiere actuar. short sem_op valor en el que se quiere decrementar o incrementar el semáforo. (1 o -1) short sem_flg flags que afectan a la operación. Puede usarse NULL

Colas de Mensajes: Mediante las colas de mensajes un proceso puede escribir mensajes que podrán ser leídos por uno o más procesos diferentes. En GNU/Linux este mecanismo está implementado mediante un array de colas de mensajes, msgqueue. Cada posición de este array es una estructura de tipo msgid_ds que gestionará la cola mediante punteros a los mensajes introducidos en ella.

Colas de Mensajes: Las colas controlan cuándo fue la última vez que se escribió en ellas, y tienen dos colas de espera: una para escritura y otra para lectura. Cuando un proceso escribe un mensaje, éste se posiciona al final de la cola de escritura Se verifican los permisos de lectura y escritura de los procesos respecto a la cola Si un proceso desea leer un mensaje de la cola y no existe ningún mensaje del tipo deseado, el proceso se añadirá a la cola de espera de lectura y se cambiará de contexto para que deje de estar activo.(Bloqueo)

Colas de Mensajes: obtención msgget (clave, flags); clave: la obtenida con ftok flags: permisos de escritura/lectura (como en los archivos) flags de control (IPC_CREAT) Ejemplo: int Id_Cola_Mensajes; Id_Cola_Mensajes = msgget (Clave, 0600|IPC_CREAT);

Colas de Mensajes: envío int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg) msqid : identificador obtenido con msgget() msgp : puntero a los datos que se quieren enviar msgsz :tamaño en bytes de los datos a enviar msgflg : flags

Colas de Mensajes: envío II const void *msgp ? typedef struct { long msg_type; char dato[100]; } mi_tipo; mi_tipo mensaje; Strcpy(mensaje,dato,”hola que tal”); Mensaje.msg_type=1; size_t msgsz ? tamaño de la parte de datos: sizeof(Mi_tipo)-sizeof(long)

Colas de Mensajes: recepción ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); msqid : identificador obtenido con msgget() msgp : puntero a una ubicación de memoria donde se recibiran los datos msgsz :tamaño en bytes de los datos a recibir msgtyp: tipo de mensaje a seleccionar msgflg : flags

Colas de Mensajes: eliminación int msgctl(int msqid, int cmd, struct msqid_ds *buf); msqid : identificador obtenido con msgget() cmd: IPC_RMID para borrado, hay otros buf: para el borrado se puede poner NULL con el cast apropiado. Ejemplo: (struct msqid_ds *)NULL

Comandos utiles ipcs nos da un listado de recursos compartidos que están creados en ese momento, es decir, listado de memorias compartidas, de semáforos y de colas. ipcrm nos permite eliminar algunos de estos recursos.