1 System Call per Comunicazione tra Processi Pipe.

Slides:



Advertisements
Presentazioni simili
Meccanismi di IPC Problemi classici di IPC
Advertisements

1 Introduzione ai calcolatori Parte II Software di base.
Programmazione con socket
File System Cos’è un File System File e Directory
Algoritmi e Programmazione
Informatica Generale Marzia Buscemi
1 Informatica Generale Susanna Pelagatti Ricevimento: Mercoledì ore presso Dipartimento di Informatica, Via Buonarroti,
Gestione del processore
1 Processi e Thread Meccanismi di IPC, Inter Process Communication (1)
1 Processi e Thread Meccanismi di IPC (1). 2 Comunicazioni fra processi/thread Processi/thread eseguiti concorrentemente hanno bisogno di interagire per.
SC che operano su processi
File system Casi di studio (3).
Mappare file in memoria
SC che operano su file (1)
Interfaccia del file system
Programmazione Procedurale in Linguaggio C++
File.
Laboratorio di Linguaggi P R I M O C O M P I T I N O Marco Tarini Università dellInsubria Facoltà di Scienze Matematiche, Fisiche e Naturali di Varese.
1 Corso di Informatica (Programmazione) Lezione 10 (12 novembre 2008) Programmazione in Java: espressioni booleane e controllo del flusso (selezione)
1 Corso di Informatica (Programmazione) Lezione 13 (21 novembre 2008) Programmazione in Java: stringhe e array.
1 Corso di Laurea in Biotecnologie Informatica (Programmazione) Le stringhe di caratteri in Java Anno Accademico 2009/2010.
1 Il file system di Unix Caratteristiche generali dei FS comunemente usati da Unix/Linux.
Il linguaggio Fortran 90: 4. Array: Vettori e Matrici
Il linguaggio Fortran 90: 5. Formato di I/O e Files
Istruzioni di selezione in Java Programmazione Corso di laurea in Informatica.
Approfondimento delle classi
nome: sequenza di caratteri usata per denotare un oggetto
memoria gestita staticamente:
Organizzazione della Memoria (Unix) Text contiene le istruzioni in linguaggio macchina del codice eseguibile, può essere condiviso in caso di processi.
Esercizio: Copiare un file in un nuovo file mediante le funzioni read e write.
1 File System ed Input/Output UNIX Implementazione del File System Caratteristiche del File System Unix/Linux System Call relative al File System Linput/output.
1 LINUX: struttura generale The layers of a UNIX system. User Interface.
Esercizi Puntatori, struct con campi puntatore, puntatori a struct, rapporto tra array e puntatori. FUNZIONI Passaggio di parametri per indirizzo, passaggio.
File di testo, file binari
I File.
Sistemi Operativi - Introduzione 1 Il sistema operativo UNIX Dettagli e comandi avanzati Niccolò Battezzati Politecnico di Torino Dip. Automatica e Informatica.
Modulo 13: System call relative al File System
GESTIONE DEI FILE Per poter mantenere disponibili i dati tra le diverse esecuzioni di un programma (persi-stenza dei dati) è necessario poterli archi-viare.
CODIFICA Da flow-chart a C++.
1 Scheduling in Windows 2000 Un thread entra in modalità kernel e chiama lo scheduler quando: Si blocca su un oggetto di sincronizzazione (semaforo, mutex,
1 Gestione dei File. 2 Perché i file? Sono strutture dati persistenti Sono solitamente memorizzati sui dischi –Si usano dall'interno dei programmi Realizzano.
File system distribuito transazionale con replicazione
BIOINFO3 - Lezione 211 INPUT La lettura di un input dallo standard input (tastiera) si effettua utilizzando lespressione. Quando il programma incontra.
Fopndamenti di programmazione. 2 La classe String Una stringa è una sequenza di caratteri La classe String è utilizzata per memorizzare caratteri La classe.
Costruzione di una semplice Agenda telefonica Elettronica Esercizio sull'uso delle principali system call Unix.
1 I segnali. 2 Prima un po’ di teoria…... 3 Stati dei processi in UNIX Idle Sleeping Zombified Runnable Running Fork iniziata waitpid Fork terminata.
1 Implementazione del File System nel Sistema Operativo Unix (Bach: the Design of the Unix Operating System (cap: 4, da 5.1 a 5.7, 5.12)
1 Il Buffer Cache Unix (Bach: the Design of the Unix Operating System (cap: 3)
Il linguaggio Fortran 90: 3. Procedure e Funzioni
T. MottaGenerazione e terminazione processi1 Creazione e terminazione dei processi Tommaso Motta
1 Il file system di Unix Caratteristiche generali dei FS comunemente usati da Unix/Linux.
1 Esercitazione Sistemi distribuiti: sistemi che risisedono su più calcolatori interconnessi da una rete di comunicazione Algoritmi distribuiti: programmi.
1 Il file system di Unix Caratteristiche generali dei FS comunemente usati da Unix/Linux.
File binari Accesso a file con record di lunghezza costante Struct Persona { Int id; Char nome[50];// nome e cognome Double stipendio; }; Persona dipendente;
Politecnico di Milano © Domenico Barretta Processi concorrenti in Unix Docente Domenico Barretta Politecnico di Milano
1 SC che operano su processi Getpid, fork, exec, wait, waitpid, exit, dup, dup2.
1 File System Concetti e tecniche generali. 2 Il file system Il file system è la parte del SO che si occupa di mantenere i dati/programmi in modo persistente.
1 Il linguaggio C Precisazioni sull’esperienza in laboratorio.
1 Chiamate di sistema Introduzione Errori : perror() Chiamate che lavorano su file.
1 File System ed Input/Output UNIX Caratteristiche del FS Unix Implementazione Il file system di Linux Organizzazione dell’ I/O.
1 Informatica Generale Alessandra Di Pierro Ricevimento: Giovedì ore presso Dipartimento di Informatica, Via Buonarroti,
1 Chiamate di sistema Chiamate che lavorano su file.
1 SC per IPC Pipe. 2 Pipe : file speciali utilizzati per connettere due processi con un canale di comunicazione Se B cerca di leggere da una pipe vuota.
1.1 Corso di Sistemi Operativi: Programmazione di Sistema Corso di Laurea in Informatica, Università di Firenze Anno accademico 2010/2011 Prof. Luca Ferrari.
1 Processi e Thread Processi Thread Meccanismi di comunicazione fra processi (IPC) Problemi classici di IPC Scheduling Processi e thread in Unix Processi.
1 System Call che operano su processi Getpid, fork, exec, wait, waitpid, exit, dup, dup2.
10/10/20021 Ingresso e uscita in Java F. Bombi 10 ottobre 2002.
1 System Call che operano su processi Getpid, fork, exec, wait, waitpid, exit, dup, dup2.
Compitino di Sistemi Operativi corsi A -C 19 Maggio 2003.
SC per IPC Pipe.
Transcript della presentazione:

1 System Call per Comunicazione tra Processi Pipe

2 Pipe : file speciali utilizzati per connettere due processi con un canale di comunicazione Se B cerca di leggere da una pipe vuota si blocca Quando la pipe è piena A viene automaticamente sospeso Lampiezza della pipe dipende dal sistema (in Linux 4K) A B pipe

3 Pipe con nome e senza nome –pipe senza nome (unnamed) file senza un nome visibile, che viene utilizzato per comunicazioni fra processi che condividono puntatori alla tabella dei file aperti (es. padre figlio, nonno nipote etc) –pipe con nome (named) file speciale (p) con nome visibile a tutti gli altri processi sulla stessa macchina –in entrambi i casi lettura/scrittura dalla pipe viene effettuata con le system call read() e write() utilizzate anche per gli altri file

4 Creazione di pipe senza nome: pipe() int pipe(int filedes[2]); –crea un file speciale di tipo pipe –restituisce due file descriptor: filedes[1] per la scrittura sul pipe e filedes[0] per la lettura dal pipe –restituisce 0 in caso di successo –restituisce -1 in caso di fallimento es. il processo sta usando troppi file descriptor...

5 Creazione di pipe senza nome (2) /* frammento che crea un nuovo pipe */ int fd[2]; /* per i descrittori */ … IFERROR( pipe(fd),creazione pipe); /* fd[1] puo essere usato per la scrittura fd[0] per la lettura */

6 Uso di una pipe senza nome Processo scrittore : –usa le write() –può scrivere solo se il file descriptor per la lettura ( fd[0] ) non è stato ancora chiuso altrimenti riceve un segnale SIGPIPE che per default termina il processo –la scrittura è atomica

7 Uso di una pipe senza nome (2) Processo lettore : –usa la read() –se il file descriptor per la scrittura ( fd[1] ) è stato chiuso la read restituisce 0 (che indica la fine dellinput dalla pipe) –se la pipe è vuota ma fd[1] non è stato ancora chiuso la read si blocca in attesa di dati sul pipe –se si cerca di leggere più byte di quelli presenti nel pipe la read ha successo ma il numero di byte letti restituito è minore del valore del terzo parametro

8 Uso di una pipe senza nome (3) Nota: non serve usare lseek per il posizionamento in un file di tipo pipe Pipe senza nome solo per processi discendenti –si passano i file descriptor attraverso la condivisione dei puntatori alla tabella dei file aperti Si usa per comunicazione unidirezionale Non esiste il concetto di messaggio –byte non strutturati –i processi comunicanti devono stabilire un protocollo esplicito per scambiarsi messaggi di una certa lunghezza o messaggi di lunghezza variabile

9 Uso di una pipe senza nome (4) Sequenza tipica di utilizzo di una pipe senza nome: –il padre crea il canale di comunicazione (pipe) –il padre si duplica con una fork() i file descriptor del padre sono copiati nella file descriptor table del figlio –il processo scrittore (padre o figlio) chiude fd[0] mentre il processo lettore chiude fd[1] –i processo comunicano con read/write –quando la comunicazione è finita ognuno chiude la propria estremità del canale di comunicazione

10 Uso di una pipe senza nome (5) int fd[2]; /* per i descrittori */ char msg[100]; /* msg di lunghezza 100*/ IFERROR( pipe(fd),creazione pipe); IFERROR( pid=fork(),creazione figlio); if ( pid ) { /* siamo nel padre=lettore */ close(fd[1]); /* chiude scrittura */ read(fd[0],msg,100); WRITELN(msg); /* scrive il msg letto*/ } else { /* siamo nel figlio=scrittore */ close(fd[0]); /* chiude lettura */ sprintf(msg,Da %d: Hi!!\n,getpid()); write(fd[1],msg,100); close(fd[1]);}

11 Messaggi di lunghezza variabile Possibile protocollo: – ogni messaggio logico è implementato da due messaggi fisici sul canale –il primo messaggio (di lunghezza nota), specifica la lunghezza lung –il secondo messaggio (di lunghezza lung ) codifica il messaggio vero e proprio vediamo un frammento di possibile implementazione

12 Messaggi di lunghezza variabile (2) … } else { /* siamo nel figlio */ int lung; /* per la lunghezza*/ close(fd[0]); /* chiude lettura */ sprintf(msg,Da %d: Hi!!\n,getpid()); lung = strlen(msg) + 1; /* terminatore */ /* primo messaggio*/ write(fd[1], &lung,sizeof(int)); /* secondo messaggio */ write(fd[1],msg,lung); close(fd[1]); }

13 Messaggi di lunghezza variabile (3) … if ( pid ) { /* siamo nel padre */ int l,lung; /* per la lunghezza */ char* msg; /* per il messaggio*/ close(fd[1]); /* chiude scrittura */ IFERROR(l=read(fd[0],&lung,sizeof(int)), lettura); msg = malloc(lung); IFERROR(l=read(fd[0],&msg,lung), lettura); WRITELN(msg); /* scrive il msg letto*/ free(msg); /* se non serve piu */ close(fd[0]); }

14 Creazione di pipe con nome: mkfifo int mkfifo(const char * pathname, mode_t mode); –crea un file speciale di tipo pipe con il nome e la posizione specificati in pathname ed i diritti di accesso specificati da mode –restituisce 0 se ha avuto successo e -1 altrimenti se il file esiste già da errore –attenzione ai diritti! I diritti del file creato non sono direttamente 0644 ma vengono modificati a seconda del valore di una variabile della shell ( umask ) vale ogni volta che creiamo un file (es. open …)

15 Shell : umask es. se create un file con open(ff,O_CREAT|O_RDWR,0666) probabilmente i diritti del file ff dopo lesecuzione deall SC saranno r w - r - - r - - e non, come specificato dal terzo parametro r w - r w - r w ?????????

16 Shell : umask (2) umask è una maschera che fornisce una restrizione ai diritti di accesso (modo) di un file al momento della creazione il modo del file viene calcolato come (modo&~(umask)) Tipicamente umask = 022 quindi : (modo 0666) (umask) (~umask) (modo & (~umask)) r w - r - - r - -

17 Shell : umask (3) Si può modificare il valore di umask con il comando umask –$umask fornisce il valore corrente della maschera –$umask valore_ottale setta umask al valore_ottale specificato

18 Creazione di pipe con nome: mkfifo (2) Es: mkfifo(pippo, 0664); –se i diritti del file non sono quelli desiderati: > ls -l pippo prw-r--r-- 1 susanna …… pippo possiamo cambiarli con chmod() es chmod(pippo, 0664); adesso … > ls -l pippo prw-rw-r-- 1 susanna …… pippo

19 Creazione di pipe con nome (3) /* frammento che crea un nuovo pipe con nome */ … IFERROR( mkfifo(ff,0664),creazione pipe); IFERROR( chmod(ff,0664),diritti pipe);

20 Uso di una pipe con nome Prima di iniziare a scrivere/leggere la pipe deve essere aperta contemporaneamente da un lettore e da uno scrittore: Apertura da parte di un processo scrittore : –usa le open() –se nessun lettore ha ancora invocato la open() si blocca in attesa del primo lettore –usando le opzioni O_NONBLOCK, O_NDELAY se non ci sono lettori la open termina subito con fallimento

21 Uso di una pipe con nome (2) Apertura da parte di un processo lettore : –usa le open() –se nessun scrittore ha ancora invocato la open() si blocca in attesa dello scrittore –usando le opzioni O_NONBLOCK, O_NDELAY se non ci sono scrittori la open termina subito con successo

22 Uso di una pipe con nome (3) Tipico uso : più client e un server –il server crea la pipe e la apre in lettura –i client aprono in scrittura la stessa pipe La capienza è 40K

23 Rimozione di una pipe: unlink() int unlink(const char*patname); –decrementa il conto degli hard link del file indicato da pathname –se il numero degli hard link si è azzerato e nessun processo ha il file aperto si elimina il file dal file system –se un processo ha ancora il file aperto, un file regolare continua ad esistere finche lultimo descrittore è chiuso un pipe con nome può essere usato solo da chi lo ha già aperto (viene rimosso il nome) –ritorna 0 (successo) o -1 (fallimanto)