Corso di Sistemi Operativi Programmazione di Sistema e Concorrente

Transcript

1 Università di Roma La Sapienza Dipartimento di Informatica e Sistemistica Corso di Sistemi Operativi Programmazione di Sistema e Concorrente Lezione VII Code di messaggi PIPE - FIFO

2 Argomenti della lezione Nozioni preliminari sullo scambio di messaggi Code di messaggi Pipe FIFO Corso di Sistemi Operativi - Esercitazioni (Lez.7) 2

3 Messaggi Sono unità di dati che possono essere scambiate tra due o più processi Il deposito (spedizione) e l estrazione (ricezione) dei messaggi avvengono in modo atomico Due o più processi non possono quindi scambiarsi frazioni di un messaggio Non necessariamente i messaggi hanno la stessa taglia Corso di Sistemi Operativi - Esercitazioni (Lez.7) 3

4 Formato di un messaggio Intestazione: contiene i campi tipici (ma non necessari) per applicazioni basate sullo scambio di messaggi la definizione di questi campi come parte del contenuto del messaggio può essere a carico delle applicazioni e non del sistema operativo il tipo e le informazioni di controllo possono determinare l ordine di consegna dei messaggi stessi Intestazione Tipo del messaggio Destinazione Sorgente Lunghezza Informazioni di controllo Contenuto Corso di Sistemi Operativi - Esercitazioni (Lez.7) 4

5 Primitive di spedizione Modello generale: Send(destinazione, messaggio) Modalità Sincrona: processo sospeso fin quando il buffer contenente il messaggio può essere sovrascritto senza arrecare danni al messaggio appena spedito Sincrona rendez-vous: processo sospeso fino a che il messaggio non viene ricevuto (uso di acknowledgment) Asincrona: possibilità di riutilizzo immediato del buffer contenente il messaggio (possibilità di sovrascrittura del messaggio in corso di spedizione) Corso di Sistemi Operativi - Esercitazioni (Lez.7) 5 bloccante e non non bloccante

6 Primitive di ricezione Modello generale: Receive(sorgente, messaggio) Modalità: Bloccante: processo sospeso fino a che non arriva almeno un messaggio dalla sorgente specificata Non-bloccante: il processo non viene sospeso neanche in caso un messaggio dalla sorgente specificata non sia disponibile Nel caso di rendez-vous la ricezione necessita di gestione di ack verso la sorgente del messaggio sincrona e non Corso di Sistemi Operativi - Esercitazioni (Lez.7) 6

7 Tecniche di indirizzamento Diretta: Sorgenti e destinazioni coincidono con identificatori di processi Uso di wild-cards nel caso in cui l identificazione della sorgente non sia rilevante Esempi: Send(P1, message) Receive(*, message) Indiretta: Sorgenti e destinazioni coincidono con identificatori di strutture dati (mailbox) che fungono da deposito per i messaggi stessi Le strutture possono essere associate o meno ad uno specifico processo Effetti sulla distruzione della struttura alla terminazione del processo Possibilità di relazione uno-a-molti e molti-a-molti Corso di Sistemi Operativi - Esercitazioni (Lez.7) 7

8 Buffering In memoria kernel non è necessario che sia impostata una receive all atto dell arrivo del messaggio la capacità di bufferizzazione può essere nulla, limitata o illimitata in caso di capacità nulla un solo messaggio alla volta può essere in transito (tipico del rendez-vous) è possibile definire un timeout per la bufferizzazione di un messaggio, allo scadere del quale il messaggio viene scartato In memoria utente è necessario che sia impostata una receive all atto dell arrivo del messaggio, altrimenti il messaggio in transito viene perso Corso di Sistemi Operativi - Esercitazioni (Lez.7) 8

9 Code di messaggi

10 Generalità Oggetto SystemV IPC: Accesso tramite chiave (key) Primitive set, ctl Strutture permanenti: creazione ed eliminazione esplicita Send sincrona (bloccante e non) Receive bloccante (sincrona) e non bloccante (sincrona) Buffering in memoria kernel ed a capacità limitata Indirizzamento indiretto Il contenuto di un messaggio ha taglia tipicamente variabile, limitata da MSGMAX (= 4056 in msg.h) Il S.O. gestisce il campo TIPO del messaggio (supporto al multiplexing) Il processo che spedisce il messaggio si fa carico di scriverlo all interno del contenuto Corso di Sistemi Operativi - Esercitazioni (Lez.7) 10

11 Struttura dei messaggi Definito in <sys/msg.h>: struct msgbuf { long int mtype; char mtext[1]; }; mtype: tipo del messaggio specificato da un intero long positivo o nullo primi 4 byte del messaggio stesso consente multiplexing mtext: i dati stessi del messaggio può essere qualsiasi tipo di dato Da interpretarsi come template di messaggio In pratica si usa una struct costruita dall utente. Es: struct my_msgbuf { long mtype; long request_id; /* Identificatore richiesta */ struct client_info; /* Informazioni client */ }; Corso di Sistemi Operativi - Esercitazioni (Lez.7) 11

12 Schema del sistema queue id message headers area dati Corso di Sistemi Operativi - Esercitazioni (Lez.7) 12

13 Message headers Il kernel memorizza ogni messaggio nella coda all interno del framework definito dalla struttura: struct msg { struct msg *msg_next; long msg_type; char *msg_spot; short msg_ts; } msg_next: puntatore al successivo messaggio in coda (linked list) msg_type: tipo del messaggio, definito in msgbuf msg_spot: puntatore ai dati del messaggio msg_ts: lunghezza del corpo del messaggio Corso di Sistemi Operativi - Esercitazioni (Lez.7) 13

14 msqid_ds struct msqid_ds { struct ipc_perm msg_perm; /* Permessi */ struct msg *msg_first; /* Primo messaggio in coda */ struct msg *msg_last; /* Ultimo messaggio in coda */ time_t msg_stime; /* Tempo dell ultima send */ time_t msg_rtime; /* Tempo dell ultima receive */ time_t msg_ctime; /* Tempo dell ultima modifica */ struct wait_queue *wwait; /* Puntat. ai processi */ struct wait_queue *rwait; /* in attesa di w/r */ ushort msg_cbytes; /* Numero di byte nella coda */ ushort msg_qnum; /* Numero di messaggi in coda */ ushort msg_qbytes; /* Max numero di bytes in coda */ ushort msg_lspid; /* PID dell ultimo scrittore */ ushort msg_lrpid; /* PID dell ultimo lettore */ }; Il kernel crea e mantiene un struttura per ogni coda nel sistema Corso di Sistemi Operativi - Esercitazioni (Lez.7) 14

15 Creazione di una coda di messaggi int msgget (key_t key, int flag) invoca la creazione una MSG key: chiave per identificare la MSG in maniera univoca nel sistema flag: modalità di creazione (IPC_CREAT, IPC_EXCL, e permessi di accesso) descrittore per l'accesso alla MSG in caso di successo (-1 in caso di fallimento) Corso di Sistemi Operativi - Esercitazioni (Lez.7) 15

16 Controllo su una coda di messaggi int msgctl(int ds_coda, int cmd, struct msquid_ds *buff) invoca l esecuzione di un comando su una MSG ds_coda: descrittore della coda su cui si vuole operare cmd: specifica del comando da eseguire (IPC_RMID, IPC_STAT, IPC_SET) buff: puntatore al buffer con eventuali parametri per il comando -1 in caso di fallimento Corso di Sistemi Operativi - Esercitazioni (Lez.7) 16

17 Invio di messaggi int msgsnd(int ds_coda, const void *buff, size_t nbyte, int flag) invoca la spedizione di un messaggio su una MSG ds_coda: descrittore della coda buff: puntatore al buffer che contiene il messaggio da depositare nbyte: taglia del messaggio, in byte (esclusi i primi 4 byte del tipo) flag: comportamento in caso di MSG satura: 0 (bloccante): il processo viene sospeso fino a quando non viene prelevato un messaggio IPC_NOWAIT (non bloccante): il processo non viene sospeso, ma la syscall fallisce -1 in caso di fallimento Corso di Sistemi Operativi - Esercitazioni (Lez.7) 17

18 Ricezione di messaggi int msgrcv (int ds_coda, const void *buff, size_t nbyte, long type, int flag) invoca la ricezione di un messaggio da una MSG ds_coda: descrittore della coda buff: puntatore al buffer che dovrà contenere il messaggio nbyte: numero massimo di byte del messaggio da ricevere (se il messaggio è più lungo errore) type: tipo del messaggio da ricevere 0: FIFO, si vuole ricevere il più vecchio messaggio in coda X>0: FIFO solo su messaggi di tipo X X<0: FIFO su tipo X, altrimenti X-1,, altrimenti 1 Corso di Sistemi Operativi - Esercitazioni (Lez.7) 18

19 msgrcv() flag: comportamento in caso di assenza di messaggi del tipo richiesto in MSG: 0 (bloccante): il processo viene sospeso fino a quando non arriva un messaggio del tipo richiesto IPC_NOWAIT (non bloccante): il processo non viene sospeso, ma la syscall fallisce MSG_NOERROR: tronca i messaggi più lunghi a nbyte byte senza errore -1 in caso di fallimento Corso di Sistemi Operativi - Esercitazioni (Lez.7) 19

20 codamess.h Implementare una libreria che offra funzioni comuni per la gestione di code di messaggi: Creazione Invio messaggi Ricezione messaggi Ricerca di un messaggio di un certo tipo Eliminazione Corso di Sistemi Operativi - Esercitazioni (Lez.7) 20

21 Esempio: trasferimento di stringhe fra processi stdin stdout Scrittore send Coda di messaggi (in memoria kernel) receive Lettore Uso della MSG come buffer Corso di Sistemi Operativi - Esercitazioni (Lez.7) 21

22 PIPE

23 Concetti base La PIPE è un metodo per connettere l output di un processo all input di un altro processo comunicazione one-way (dette anche Halfduplex pipes) comunicazione indiretta (mailbox) Uno dei primi sistemi di IPC su Unix Utilizzate anche da shell: ls sort lp ( direzione dei dati) Corso di Sistemi Operativi - Esercitazioni (Lez.7) 23

24 Concetti di base sulle Pipe In sistemi UNIX l uso della PIPE avviene attraverso la nozione di descrittore Una volta lette, le informazioni spariscono dalla PIPE e non possono più ripresentarsi (a meno di riscritture) A livello di sistema operativo, i PIPE non sono altro che buffer di dimensione più o meno grande (solitamente 4 kb) Un processo viene bloccato se: tenta di scrivere su un PIPE pieno tenta di leggere da un PIPE vuoto I processi che usano un PIPE devono essere relazionati (antenato in comune) Corso di Sistemi Operativi - Esercitazioni (Lez.7) 24

25 I PIPE sono anche usabili per la comunicazione fra più processi (attenzione alla sincronizzazione): uno scrittore, molti lettori; molti scrittori, un lettore; molti scrittori, molti lettori; Per utilizzarle bisogna includere l header <unistd.h> Corso di Sistemi Operativi - Esercitazioni (Lez.7) 25

26 Schema di funzionamento Quando un processo crea una PIPE, il kernel: assegna un inode number (interno) alla PIPE setta 2 descrittori di file (fd[0] e fd[1]) Dopodiché il processo effettua una (o più) fork() Il processo figlio eredita tutti i descrittori di file aperti dal padre eredita anche i descrittori della PIPE Processo fd[0] padre fd[1] kernel fd[0] fd[1] Processo figlio Corso di Sistemi Operativi - Esercitazioni (Lez.7) 26

27 Schema di funzionamento Per poter utilizzare correttamente la PIPE bisogna: decidere la direzione dei dati chiudere i descrittori non utilizzati Per mandare e ricevere dati dalla PIPE si utilizzano le note system call read() e write() Non è possibile compiere operazioni di seek(), per spostarsi avanti e indietro nel flusso dati presente nella PIPE Processo fd[0] padre fd[1] kernel fd[0] fd[1] Processo figlio Corso di Sistemi Operativi - Esercitazioni (Lez.7) 27

28 Pipe nei sistemi Unix int pipe(int int fd[2]) invoca la creazione di una PIPE fd: puntatore ad un array di due interi in fd[0] viene restitutito il descrittore del canale aperto in lettura dalla PIPE in fd[1] viene restituito il descrittore del canale aperto in scrittura sulla PIPE -1 in caso di fallimento Corso di Sistemi Operativi - Esercitazioni (Lez.7) 28

29 Chiusura della PIPE Le PIPE non sono dispositivi fisici, ma logici: come fa un processo a vedere la fine di un file su una PIPE? Per convenzione, ciò avviene quando tutti i processi scrittori hanno chiuso il descrittore fd[1] sulla PIPE in questo caso la chiamata read() effettuata da un lettore restituisce 0 come notifica dell'evento che tutti gli scrittori hanno terminato il loro lavoro Allo stesso modo, un processo scrittore che tenti di scrivere su fd[1] quando tutte le copie del descrittore fd[0] siano state chiuse (non ci sono lettori sulla PIPE), riceve il segnale SIGPIPE (Broken-pipe) possibilità di deadlock! Corso di Sistemi Operativi - Esercitazioni (Lez.7) 29

30 PIPE e deadlock Per fare in modo che non si verifichino situazioni di deadlock è necessario che tutti i processi chiudano i descrittori di PIPE non utilizzati, usando la syscall close(): ogni processo lettore che erediti la coppia (fd[0],fd[1]) deve dichiarare di non essere uno scrittore, chiudendo la propria copia di fd[1] altrimenti, l'evento tutti gli scrittori hanno terminato non potrebbe mai avvenire fintanto che il lettore è impegnato a leggere, e si potrebbe avere un deadlock attesa evento Processo lettore Corso di Sistemi Operativi - Esercitazioni (Lez.7) 30

31 Esempio: trasferimento stringhe tramite PIPE Processo padre: genera una PIPE genera un figlio prende le stringhe in ingresso nello stdin e le scrive nella PIPE Processo figlio: legge le stringhe dalla PIPE e le trasferisce sullo stdout Entrambi i processi chiudono i descrittori che non utilizzano (dopo la fork()) Corso di Sistemi Operativi - Esercitazioni (Lez.7) 31

32 Atomicità delle operazioni L atomicità delle operazioni di lettura/scrittura diviene importante quando più di 2 processi hanno accesso alla PIPE Numero massimo di caratteri che possono essere trasferiti senza interruzione: UNIX: standard POSIX in <posix1_lim.h>: #define _POSIX_PIPE_BUF 512 Linux: in <linux/limits.h>: #define PIPE_BUF 4096 Corso di Sistemi Operativi - Esercitazioni (Lez.7) 32

33 Redirezione canali standard 1 close(0); dup2(0, fd[0]); 2 dup(fd[0]); 3 execlp( sort, sort, NULL); Analizziamo questo frammento di codice: 1. Chiude lo stdin attuale 2. Duplica il lato input della pipe sullo stdin 3. Sostituisce il codice con quello del comando sort tutto ciò che viene inviato alla PIPE passa attraverso il comando sort Corso di Sistemi Operativi - Esercitazioni (Lez.7) 33

34 Realizzazione di una pipeline $ cmd1 cmd2 shell fork() produttore pipe(fd); fork(); consumatore dup2(1, fd[1]); dup2(0, fd[0]); exec(cmd1, ); exec(cmd2, ); Corso di Sistemi Operativi - Esercitazioni (Lez.7) 34

35 $ cmd1 cmd2 if ((pid = fork()) == 0) { /* processo figlio */ pipe (fd_pipe); if (fork() == 0) { /* produttore */ dup2(1, fd_pipe[1]); close(fd_pipe[0]); close(fd_pipe[1]); exec(argv[1], argv[1], ); } /* consumatore */ dup2(0, fd_pipe[0]); close(fd_pipe[0]); close(fd_pipe[1]); exec(argv[2], argv[2], ); } Corso di Sistemi Operativi - Esercitazioni (Lez.7) 35

36 popen() FILE *popen (char *command, char *type); Gruppo di azioni: crea una PIPE effettua una fork() lancia la shell bash esegue su di essa un comando command: comando da eseguire type: direzione della PIPE r : lettura dalla PIPE w : scrittura sulla PIPE Stream della PIPE aperta (NULL se errore) Funzione ANSI-C standard library Corso di Sistemi Operativi - Esercitazioni (Lez.7) 36

37 pclose() int pclose (FILE *stream); attende la terminazione del processo aperto con popen() elimina la relativa PIPE stream: lo stream della PIPE, ottenuto da popen() stato di terminazione del processo figlio Corso di Sistemi Operativi - Esercitazioni (Lez.7) 37

38 FIFO

39 Named Pipe (Fifo) - Caratteristiche A differenza delle PIPE, le FIFO sono dei file risiedono nel file system (bit type a p) individuabili tramite pathname ( dopo il nome) possono essere condivise anche tra processi non correlati persistenti: vanno eliminate esplicitamente Stesse operazioni di un file ad accesso sequenziale: apertura, lettura/scrittura, chiusura. Differenza: i dati letti vengono rimossi Corso di Sistemi Operativi - Esercitazioni (Lez.7) 39

40 Creazione FIFO 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 modalità di creazione e permessi di accesso alla FIFO 0 in caso di successo (o -1) corrisponde a: mknod(name, mode S_IFIFO, NULL) il file così creato deve poi essere aperto con open() (system call) o con fopen() (ANSI-C) Corso di Sistemi Operativi - Esercitazioni (Lez.7) 40

41 Note La rimozione di una FIFO dal file system avviene esattamente come per i file: chiamata di sistema: unlink() funzione ANSI C: remove() comando shell: rm Di default l apertura di una FIFO è bloccante: un processo che tenta di aprirla in lettura (o scrittura) viene bloccato fino a quando un altro processo non la apre in scrittura (o lettura) Per evitare il blocco si può aggiungere il flag O_NONBLOCK al valore del parametro mode passato all apertura di una FIFO Ogni FIFO deve avere sia un lettore che uno scrittore: se un processo tenta di scrivere su una FIFO che non ha un lettore esso riceve il segnale SIGPIPE da parte del kernel Corso di Sistemi Operativi - Esercitazioni (Lez.7) 41

42 Esempio: client/server tramite FIFO client serv r.fifo_response Il server accetta richieste su una FIFO di nome serv server risponde ai client su FIFO da essi specificate tramite un nome minuscolo Corso di Sistemi Operativi - Esercitazioni (Lez.7) 42