danny block notes

domenica, 14 ottobre 2007

Unix Programming : Pipe e Fifo

Filed under: c,linux,programming — danny @ 4:29 pm
Tags: , , ,
/* PIPE */
// permettono la comunicazione tra processi relazionati (es. padre-figlio)

int pipe(int fd[2])
// Invoca la creazione di una PIPE
// fd: puntatore ad un array di due interi (in fd[0] viene restituito il descrittore di lettura della PIPE,
// in fd[1] viene restituito il descrittore di scrittura della PIPE)
// fd[0] e fd[1] possono essere usati da subito (senza open() ) come normali descrittori di file tramite le chiamate read() e write()
// ­1 in caso di fallimento

/* NOTE:
1. Un processo lettore vede la �fine� della PIPE quando tutti i
processi scrittori hanno chiuso il descrittore fd[1].
2. La chiamata read() effettuata da un lettore restituisce 0 come
notifica dell�evento che tutti gli scrittori hanno terminato il loro lavoro
3. Un processo scrittore che tenti di scrivere sul descrittore fd[1]
quando tutte le copie del descrittore fd[0] sono state chiuse
(cioè non ci sono lettori sulla PIPE) riceve il segnale SIGPIPE
4. NB: Per evitare deadlock è necessario che tutti i processi
chiudano i descrittori di PIPE che non gli servono usando la close().
*/

/* FIFO */
// permettono la comunicazione tra processi relazionati e non

int mkfifo(char* name, int mode)
// Invoca la creazione di una FIFO
// name: puntatore ad una stringa che identifica il nome della FIFO da creare
// mode: intero che specifica la modalità di creazione e permessi di accesso alla FIFO (in genere O_CREATE | 0666)
// ­1 in caso di fallimento, altrimenti un descrittore per lâ��accesso alla FIFO

int unlink (const char * nomefifo)
// elimina dal sistema la fifo.
// NB: con la close chiudo la fifo ma non la elimino
// ­1 in caso di fallimento

int open (const char * nomefifo,int FLAGS)
// NB: è bloccante : un processo che tenta di aprirla in lettura (scrittura) viene bloccato
// fino a quando un altro processo non la apre in scrittura (lettura).
// FLAGS principali : O_RDWR, O_RDONLY, O_WRONLY, O_NONBLOCK (per rendere la open non bloccante)
// ­1 in caso di fallimento, altrimenti un descrittore per lâ��accesso al canale della FIFO

/* NOTE:
1.
2. La chiamata read() effettuata da un lettore restituisce 0 come
notifica dell�evento che tutti gli scrittori hanno terminato il loro lavoro
3. Un processo scrittore che tenti di scrivere sulla fifo
quando non ci sono lettori sulla fifo riceve il segnale SIGPIPE
4. per gestire una chiusura inaspettata del programma che ha creato la pipe
si usa catturare i seguenti segnali (la funz. disconnetti_pipe contiene una unlink)
signal(SIGTERM, disconnetti_pipe);
signal(SIGHUP, disconnetti_pipe);
signal(SIGINT, disconnetti_pipe);
per i processi che invece non haano creato la pipe è sufficiente gestire un SIGPIPE
signal(SIGPIPE, esci_dal programma);
*/
Annunci

Lascia un commento »

Non c'è ancora nessun commento.

RSS feed for comments on this post. TrackBack URI

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...

Blog su WordPress.com.

%d blogger hanno fatto clic su Mi Piace per questo: