Manejo De Interbloqueo SO

UNIVERSIDAD CENTRAL DEL ECUADOR

TRABAJO DE SISTEMAS OPERATIVOS

TEMA:

MANEJO DE INTERBLOQUEO EN EL SISTEMA OPERATIVO DEBIAN

NOMBRE:

JONATHAN FABRICIO PAREDES

AULA:

SALA 1

SEMESTRE:

ABRIL-SEPTIEMBRE

Concurrencia Interbloqueo en DEBIAN

DEBIAN proporciona diversos mecanismos de comunicación y sincronización entre procesos. En esta parte, se revisarán los más importantes:

• TUBERÍAS (PIPES).

CONCEPTOS GENERALES.

Descriptor de fichero:

Número entero positivo usado por un proceso para identificar un fichero abierto. Esta traducción se realiza mediante una tabla de descriptores de fichero, ubicado en la zona de datos del proceso.

Descriptores reservados:

• 0: entrada normal (stdin).

• 1: salida normal (stdout).

• 2: salida de error (stderr).

Redirección:

Establecer copias del descriptor de ficheros de un archivo para encauzar las operaciones de E/S hacia otro fichero.

Tubería:

Mecanismo de intercomunicación entre procesos que permite que 2 o más procesos envíen información a cualquier otro.

Tubería sin nombre:

Enlace de comunicación unidireccional, capaz de almacenar su entrada (hasta 4 KB en BSD o hasta 40 KB en System V).

Tuberías nombradas (FIFO):

Permiten una comunicación menos restringida, ya que las colas FIFO existen en el sistema de archivos hasta que son borradas.

Características:

• Permite comunicar procesos no emparentados.

• Tiene una entrada en el sistema de archivos.

• Usa una política de colas "primero en llegar, primero en servirse".

• Sólo disponible en Debian y Unix

Redirección.

Subrutinas dup y dup2:

- Descripción:

Duplica un descriptor de fichero.

- Formatos:

#include <unistd.h>

#include <fcntl.h>

#include <sys/types>

int dup (desc_abierto)

int desc_abierto;

int dup2 (desc_abierto, desc_nuevo)

int desc_abierto, desc_nuevo;

- Parámetros:

desc_abierto: Descriptor de fichero abierto.

desc_nuevo: Nuevo descriptor de fichero devuelto por dup2.

- Devuelve:

dup devuelve el menor descriptor de fichero que esté libre.

dup2 devuelve el valor de desc_nuevo.

Ambas subrutinas devuelven el valor -1 en caso de error.

Subrutina fcntl:

- Descripción:

Realiza operaciones de control sobre ficheros abiertos, tales como:

• duplicar el descriptor,

• poner o leer características del descriptor,

• poner o leer estado del fichero,

• gestionar bloqueos de registros,

• gestionar la propiedad de la E/S asíncrona,

• cerrar varios ficheros.

- Formato:

#include <unistd.h>

#include <fcntl.h>

#include <sys/types>

int fcntl (descriptor, comando, argumento)

int descriptor, comando, argumento);

- Parámetros:

descriptor: Descriptor del fichero.

comando: Operación ha realizar.

argumento: Parámetro del comando.

- Devuelve:

Valor devuelto por el comando; -1, en caso de error.

- Operaciones:

F_DUPFD: Obtener el menor descriptor de fichero disponible que sea mayor que el parámetro descriptor. Mantiene el mismo puntero y las mismas características del fichero original.

F_GETFD: Obtener características del descriptor.

F_SETFD: Poner características del descriptor.

F_GETFL: Obtener estado del fichero.

F_SETFL: Poner estado del fichero.

F_GETLK: Obtener información de bloqueo.

F_SETLK: Poner bloqueo.

F_SETLKW: Poner bloqueo en una zona bloqueada.

F_GETOWN: Obtener PID (>0) o PGID (<0) del proceso que recibe las señales SIGIO o SIGURG.

F_SETOWN: Poner PID (>0) o PGID (<0) del proceso gestor de la E/S asíncrona.

F_CLOSEM: Cierra todos los descriptores desde descriptor hasta el valor máximo (OPEN_MAX).

- Características del descriptor de ficheros:

FD_CLOEXEC: Indica si el descriptor se cerrará ante una función exec.

- Estados del modo de acceso al fichero:

O_RDONLY: Abierto sólo para lectura.

O_RDWR: Abierto para lectura y escritura.

O_WRONLY: Abierto sólo para escritura.

- Bloqueos:

F_RDLCK: Bloqueo de lectura (compartido).

F_WRLCK: Bloqueo de escritura (exclusivo).

F_UNLCK: Sin bloqueo.

Comunicación entre procesos emparentados.

Subrutina pipe

- Descripción:

Crea un canal de comunicación entre procesos emparentados.

- Formato:

#include <unistd.h>

int pipe (descriptores)

int descriptores[2];

- Parámetros:

Tabla que recibirá los descriptores de entrada y de salida de la tubería.

- Devuelve:

0, si se ha completado correctamente; -1, en caso de error.

- Comentarios:

a) descriptores[0] se abre para lectura y descriptores[1], para escritura.

b) La operación de lectura en descriptores[0] accede a los datos escritos en descriptores[1] como en una cola FIFO (primero en llegar, primero en servirse),

Comunicación entre procesos no emparentados.

Subrutina mkfifo:

- Descripción:

Crea un canal FIFO de comunicaciones entre procesos que no necesitan estar emparentados.

- Formato:

#include <sys/mode.h>

int mkfifo (camino, modo)

const char *camino;

int modo;

- Parámetros:

camino: Camino completo del fichero FIFO.

modo: Tipo de fichero y permisos de acceso.

- Devuelve:

0, si se ha completado correctamente; -1, en caso de error.

• MENSAJES.

Una cola de mensajes funciona como una FIFO, pero con algunas diferencias. Generalmente, los mensajes son sacados de la cola en el orden en que se pusieron. Sin embargo, hay maneras de sacar cierto mensaje de la cola antes de que alcance llegar al inicio de la cola.

Un proceso puede crear una nueva cola de mensajes, o se puede conectar a una ya existente. De esta forma, dos procesos pueden compartir información mediante la misma cola de mensajes.

Una vez que se crea una cola de mensajes, esta no desaparece hasta que se destruya. Todos los procesos que alguna vez la usaron pueden finalizar, pero la cola todavía existirá. Una buena costumbre sería usar el comando

ipcs para verificar si existe alguna cola de mensajes que ya no esté en uso y destruirla con el comando ipcrm.

Primero que nada queremos conectarnos a una cola, o crearla si no existe. Para hacer esto se utiliza la llamada al

sistema msgget():

• MEMORIA COMPARTIDA.

La memoria compartida, junto con los semáforos y las colas de mensajes, son los recursos compartidos que pone DEBIAN a disposición de los programas para que puedan intercambiarse información.

En DEBIAN es posible hacer que dos procesos (dos programas) distintos sean capaces de compartir una zona de memoria común y, de esta manera, compartir o comunicarse datos.

• El último paso poder usar la memoria consiste en obtener un puntero que apunte la zona de memoria, para poder escribir o leer en ella. Declaramos en nuestro código un puntero al tipo que sepamos que va a haber en la zona de memoria (una estructura, un array, tipos simples, etc) y utilizamos la función char * shmat (int, char *, int).

o El primer parámetro es el identificador de la memoria obtenido en el paso anterior.

o Los otros dos bastará rellenarlos con ceros.

o El puntero devuelto es de tipo char *. Debemos hacerle un "cast" al tipo que queramos, por ejemplo, (mi_estructura *)shmat (...);

Esta función lo que en realidad hace, además de darnos el puntero, es asociar la memoria compartida a la zona de datos de nuestro programa, por lo que es necesario llamarla sólo una vez en cada proceso. Si queremos más punteros a la zona de memoria, bastará con igualarlos al que ya tenemos.

Hasta ahora se indicado lo mínimo y más básico para poder utilizar memoria compartida. Hay más funciones que permiten hacer más cosas con la memoria compartida. Además, para un uso más "serio" y "correcto", sería necesario añadir algo como semáforos.

Por ejemplo, si los datos que deseamos compartir son muy grandes, es bastante probable que mientras un proceso intenta escribir en la memoria, otro esté leyendo. Si lo intentan de forma totalmente descontrolada y a la vez, los datos que leen pueden ser incoherentes (hay otro que está escribiéndolos en ese momento y todavía no ha terminado).

Para evitar esto existen los semáforos. Se pondría un semáforo para acceder a la memoria, de forma que cuando un proceso lo está haciendo, el semáforo se pone "rojo" y ningún otro proceso puede acceder a ella. Cuando el proceso termina, el semáforo se pone "verde" y ya podría acceder otro proceso.

• SEMÁFOROS.

A veces es necesario que dos o más procesos o hilos (threads) accedan a un recurso común (escribir en un mismo fichero, leer la misma zona de memoria, escribir en la misma pantalla, etc). El problema es que si lo hacen simultáneamente

...