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 compartidaint 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 compartidashmctl (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.