1 / 41

SC per IPC

SC per IPC. Pipe. Pipe. B. A. pipe. 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 L’ampiezza della pipe dipende dal sistema (in Lunux 4K).

naeva
Download Presentation

SC per IPC

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. SC per IPC Pipe

  2. Pipe B A pipe • 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 • L’ampiezza della pipe dipende dal sistema (in Lunux 4K)

  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 SC read() 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 stra 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”); /* da qua fd[1] puo’ essere usato per la scrittura e 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 (a meno di non aver raggiunto la capienza massima del pipe)

  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 dell’input 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) • Non ha senso usare lseek!! • 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 la 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à

  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 */ close(fd[1]); /* chiude scrittura */ read(fd[0],msg,100; WRITELN(msg); /* scrive il msg letto*/ }else { /* siamo nel figlio */ 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 l’esecuzione deall SC saranno r w - r - - r - - e non, come specificato dal terzo parametro r w - r w - r w - 1 1 0 1 1 0 1 1 0 6 6 6 ?????????

  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 : 1 1 0 1 1 0 1 1 0 (modo 0666) 0 0 0 0 1 0 0 1 0 (umask) 1 1 1 1 0 1 1 0 1 (~umask) 1 1 0 1 0 0 1 0 0 (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 • Il valore di umask viene ereditato dal padre e vale fino alla prossima modifica • I file creati con la ridirezione usano la open() con modo 0666, e quindi sono sensibili al valore di umask

  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 uan 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 l’ultimo descrittore è chiuso • un pipe con nome può essere usato solo da chi loha già aperto (viene rimosso il nome) • ritorna 0 (successo) o -1 (fallimanto)

  24. Precisazioni sul funzionamento della shell

  25. Shell • È un interprete di comandi che gira in modo utente • Nella versione base, esegue un ciclo infinito: • accetta un nuovo comando (cmd) • crea un processo P che esegue cmd • si mette in attesa della terminazione di P • Può anche eseguire una serie di comandi salvati su file (script)

  26. Shell (2) • Ci sono vari tipi di shell (Bourne, C) • vedremo delle caratteristiche comuni a tutte • Come si attiva una shell ? • Automaticamente con il login o eseguendo il codice corrispondente (es. sh, csh) • All’attivazione esegue prima di tutto un file di inizializzazione • .bashrc per la Bourne .cshrc per la C-shell • La shell termina quando legge un EOF

  27. Shell: metacaratteri • Sono caratteri che la shell interpreta in modo ‘speciale’ • &, >, >>, <, ~, | , *…. • Forniscono alla shell indicazioni su come comportarsi nella fase di interpretazione del comando • vediamone alcuni ...

  28. Shell: metacaratteri (2) • Wildcard : permettono di scrivere espressioni regolari che denotano un insieme di nomi di file • ‘*’ qualsiasi stringa • es. $ls *.c uno.c g.c h.c • ‘?’ qualsiasi carattere • es. $ls ?.c g.c h.c

  29. Shell: ridirezione • Ogni processo Unix ha dei ‘canali di comunicazione’ predefiniti con il mondo esterno • es. $sort stdout Tipicamente lo schermo P stdin Tipicamente la tastiera stderr Tipicamente lo schermo

  30. Shell: ridirezione (2) • >, <, >>, &>, &>> permettono di ridirigere questi canali • es. $sort > pippo ‘pippo’ Scrive l’output del comando ls nel file ‘pippo’ P stdin Tipicamente la tastiera stderr Tipicamente lo schermo

  31. Shell: ridirezione (3) • >, <, >>, &>, &>> permettono di ridirigere questi canali • es. $sort > pippo < pippuzzo pippo Scrive l’output del comando ls nel file ‘pippo’ P pippuzzo L’input viene letto dal file ‘pippuzzo’ stderr Tipicamente lo schermo

  32. Shell: ridirezione (4) • >, <, >>, &>, &>> permettono di ridirigere questi canali • es. $sort >> pippo < pippuzzo Scrive l’output del comando ls nel file ‘pippo’. Se pippo esiste aggiunge in fondo pippo P pippuzzo L’input viene letto dal file ‘pippuzzo’ stderr Tipicamente lo schermo

  33. Shell: ridirezione (5) • >, <, >>, &>, &>> permettono di ridirigere questi canali • es. $sort &> pippo < pippuzzo Scrive l’output del comando ls nel file ‘pippo’. Se pippo esiste aggiunge in fondo pippo P pippuzzo stderr L’input viene letto dal file ‘pippuzzo’ Anche i messaggi di errore vengono scritti su ‘pippo’

  34. Shell: processi in background • & permette di attivare un processo in background • es. $emacs & $ la shell non invoca la waitpid() immediatamente

  35. Shell: pipelining • |, |& permettono di eseguire in pipeline più processi relativi a comandi diversi • es. $ls *.c | grep ciccio | sort stderr stderr stderr ls sort pipe stdin grep stdout stdout stdin pipe stdout Elimina tutte le linee che non contengono ‘ciccio’

  36. Shell: pipelining • |, |& permettono di eseguire in pipeline più processi relativi a comandi diversi • es. $ls *.c |& grep cic | sort stderr stderr stderr ls sort pipe stdin grep stdout stdout stdin pipe stdout Elimina tutte le linee che non contengono ‘cic’

  37. Shell : environment • Le shell hanno delle variabili di environment che mantengono informazioni sotto forma di stringhe (nome=valore) • Alcune sono predefinite. Es. • $PATH contiene le directory in cui la shell va a cercare un comando • $MANPATH contiene le directory in cui la shell va a cercare i manuali in linea • $HOME pathname della home directory • $SHELL pathname della login shell

  38. Shell : environment (2) • Le variabili di environment si possono leggere e modificare. La sintassi dipende dal tipo di shell usata • es. nella bash $echo $PATH ... valore di PATH PATH=/usr/local/bin:/usr/bin/ $export PATH=$PATH:. $echo $PATH ... valore di PATH PATH=/usr/local/bin:/usr/bin/:.

  39. Shell : umask • es. se create un file con open(“ff”,O_CREAT|O_RDWR,0666) probabilmente i diritti del file ff dopo l’esecuzione saranno r w - r - - r - - e non, come specificato dal terzo parametro r w - r w - r w - 1 1 0 1 1 0 1 1 0 6 6 6 ?????????

  40. 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 : 1 1 0 1 1 0 1 1 0 (modo 0666) 0 0 0 0 1 0 0 1 0 (umask) 1 1 1 1 0 1 1 0 1 (~umask) 1 1 0 1 0 0 1 0 0 (modo & (~umask)) r w - r - - r - -

  41. 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 • Il valore di umask viene ereditato dal padre e vale fino alla prossima modifica • I file creati con la ridirezione usano la open() con modo 0666, e quindi sono sensibili al valore di umask

More Related