#include <stdio.h> /* pipetest.c */ main() { int pfd[2], nread; char s[100];

Documenti analoghi
Chiamate di sistema per la Inter Process Communication (IPC) in POSIX. E.Mumolo, DEEI

Lab. di Sistemi Operativi - Esercitazione n 9- -Thread-

Chiamate di sistema. Pipe Flus s i di I/O

case 0: /* child 1 - writing end */ close(fd[0]); // close read end write(fd[1], string, (strlen(string)+1));/* +1 is termination \0 */ return (0);

Sistemi Operativi (M. Cesati)

Sistemi di Calcolo - Secondo modulo (SC2) Programmazione dei Sistemi di Calcolo Multi-Nodo

Chiamate di sistema. Pipe Flussi di I/O

Sistemi Operativi (M. Cesati)

Sistemi Operativi Teledidattico

SC per Inter Process Comminication. Pipe senza nome e con nome (FIFO)

SC per Inter Process Communication. Pipe senza nome e con nome (FIFO)

Comunicazione tra processi: pipe Le pipe sono un meccanismo UNIX di Inter Process Communication (IPC)

Esercitazione 4. Gestione dei file in Unix

Crea un nuovo processo. Al processo padre ritorna il PID del figlio. Al processo figlio ritorna 0

Programmazione di sistema in Linux: System Call per le IPC (InterProcessCommunication) E. Mumolo

Laboratorio di Sistemi Operativi Marzo-Giugno 2008 Matricole congrue 0 mod 3

Laboratorio di Sistemi Operativi primavera 2009

Lezione 21. #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <sys/types.h> #include <sys/wait.

SmallShell Piccolo processore comandi

Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.

Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.

Sistemi Operativi 1. Mattia Monga. a.a. 2015/16. Dip. di Informatica Università degli Studi di Milano, Italia

Sistemi Operativi. Bruschi Monga Re. Shell Esercizi Shell programming Esercizi I/O. Sistemi Operativi. Bruschi Monga Re

Interprocess Communication (IPC)

Lab. di Sistemi Operativi - Esercitazione n 7- -Gestione dei processi Unix-

Sistemi Operativi (M. Cesati)

Addendum alle chiamate di sistema per la gestione processi. E Mumolo

Programmazione di sistema in Linux: System Call per il controllo processi. E. Mumolo, DIA

PIPE. M. Guarracino - PIPE 1

ESERCIZI RISOLTI IN C LANGUAGE (programmazione avanzata)

La Comunicazione tra Processi in Unix

Qualche esercizio. E. Mumolo

Esercitazione: Utilizzo delle Pipe

CORSO DI SISTEMI OPERATIVI A - ESERCITAZIONE 4

Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.

Sistemi Operativi (M. Cesati)

Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.

I files (archivi) Il C definisce in stdio.h tre file aperti automaticamente: stdin, stdout e stderr.! Sono ad accesso sequenziale diretto

Sistemi Operativi 1. Mattia Monga. a.a. 2018/19. Dip. di Informatica Università degli Studi di Milano, Italia

Laboratorio di. Reti Informatiche. Corso di Laurea Triennale in Ingegneria Informatica A.A. 2016/2017. Ing. Niccolò Iardella

SISTEMI&OPERATIVI& AA&2013&0&2014& Processi( in(linux( Giorgio&Giacinto&2013& Sistemi&Opera?vi&

Sistemi Operativi (M. Cesati)

Gestione dei file. File di testo e binari

LABORATORIO DI SISTEMI OPERATIVI

Corso di Sistemi Operativi Esercitazioni

Sistemi Operativi (M. Cesati)

Le strutture. Una struttura C è una collezione di variabili di uno o più tipi, raggruppate sotto un nome comune.

Laboratorio reti AA 2007/2008. Dott. Matteo Roffilli Ricevimento in ufficio dopo la lezione

Sistemi Operativi (M. Cesati)

System calls. permettono ai programmi utente di richiedere servizi al Sistema Operativo. servizi come scrittura di file, stampa su video, ecc.

Inter-process communication

Programmazione di sistema in Linux: gestione dei file. E. Mumolo

La sincronizzazione è legata alla implementazione delle pipe: int pipe(int fd[2]);

Laboratorio di Sistemi Operativi

GESTIONE DELLA COMUNICAZIONE LOCALE TRA PROCESSI IN UNIX:

Esercitazione di Lab. di Sistemi Operativi. - I/0 di basso livello

uid_t getuid(void); //real-user-id del chiamante getegid(void); //effective-user-id del chiamante gid_t getgid(void); //real-group-id del chiamante

La gestione dell'errore

Sistemi Operativi. II Semestre - Marzo/Giugno 2012 Matricole congr. 0 mod 3. File & Directory

Comandi. Sistema Operativo

Pipes e named pipes: 1. Nozioni preliminari 2. Pipes e named pipes (FIFO) in sistemi UNIX 3. Pipes e named pipes sistemi Windows

Sistemi Operativi (M. Cesati)

Gestione dei file in C

Laboratorio reti AA 2008/2009. Dott. Matteo Roffilli Ricevimento in ufficio dopo la lezione

Esercitazione di Lab. di Sistemi Operativi 1 a.a. 2011/2012

Capitolo 3 -- Stevens

System call per l accesso a file

Sistemi Operativi (M. Cesati)

Processi. Comunicazione tra processi Stefano Quer Dipartimento di Automatica e Informatica Politecnico di Torino

" &$ () " ) ) $ ' () *) " ) $

Il protocollo applicativo. Esempio di protocollo applicativo

Sistemi Operativi (M. Cesati)

In generale può essere utile che i due processi eseguano del codice diverso

Sistemi Operativi (M. Cesati)

Laboratorio di Sistemi Operativi primavera 2009 open

Laboratorio di Sistemi Operativi

System Call EXEC EXEC P P. fork exec(new_prog) fork. sono_il_padre = fork(); if (!sono_il_padre) {

La Comunicazione tra Processi in Unix

Corso di Laboratorio di Sistemi Operativi A.A

Esercizio sulla gestione di file in Unix. Sistemi Operativi T AA

La creazione di un nuovo processo in UNIX

File. Molto astratta: file ha un nome (ex. Pippo.c), ed altre caratteristiche (dimensione, tipo, etc). Operazioni: copiare, cancellare, eseguire..

Introduzione ai Device Drivers in Linux. E.Mumolo, DEEI

Per operare su un file abbiamo bisogno di aprirlo, scriverlo, leggerlo, chiuderlo:

Università degli Studi di Bologna Scuola di Ingegneria

I files in C. A cura del prof. Ghezzi

La funzione main() La funzione main(), presente in tutti i programmi C, è una funzione come tutte le altre

Introduzione ai socket

Lezione 22: Input/Output e Files

ESERCIZI DI PROGRAMMAZIONE C IN AMBIENTE UNIX

SISTEMI OPERATIVI e LABORATORIO DI SISTEMI OPERATIVI (A.A ) 31 MARZO 2006

Corso di Reti di Calcolatori T

Gestione dei file in C

&& (nessun altro processo ha il file aperto) && (il fd e chiuso) Cancella il file;

Università di Roma Tor Vergata Corso di Laurea triennale in Informatica Sistemi operativi e reti A.A Pietro Frasca.

SISTEMI OPERATIVI. Linguaggio C e Linux. Diffusione dei linguaggi di programmazione IEEE Giorgio Giacinto 2016.

Sistemi Operativi. II Semestre - Marzo/Giugno 2011 Matricole congr. 0 mod 3. File & Directory. Leggere Directory

Scrivere alla fine di un file Vi sono due modi per scrivere alla fine di un file:

Transcript:

/* pipetest.c */ int pfd[2], nread; char s[100]; if(pipe(pfd) == -1) syserr("pipe"); if (write(pfd[1], "hello", 5) == -1) syserr("write"); switch(nread = read(pfd[0], s, sizeof(s))) case -1 : syserr("read"); case 0 : fatal("eof"); default: printf("read %d bytes: %s\n", nread, s); /* pipewrite.c */ int pfd[2]; char fdstr[10]; if (pipe(pfd) == -1) syserr("pipe"); switch (fork()) case -1: syserr("fork"); if(close(pfd[1]) == -1) /* il figlio chiude il writing end */ syserr("close"); sprintf(fdstr,"%d",pfd[0]); execlp("./pread","pread",fdstr,null); syserr("execlp"); if (close(pfd[0]) == -1) /* il padre chiude il reading end */ syserr("close2"); sleep(2); if (write(pfd[1], "hello", 5) == -1) syserr("write"); /* piperead.c */ main(int argc, char **argv) int fd, nread; char s[100]; fd = atoi(argv[1]); printf("sto leggendo il descrittore del file %d\n", fd); switch (nread = read(fd, s, sizeof(s))) case -1: syserr("read"); fatal("eof"); default: printf("ho letto %d bytes dalla pipe: %s\n", nread,s);

/* pipewrite2.c */ int pfd[2]; if (pipe(pfd) == -1) syserr("pipe"); switch (fork()) case -1: syserr("fork"); if(close(0) == -1) syserr("close"); if (dup(pfd[0])!= 0) fatal("dup"); if(close(pfd[0]) == -1 close(pfd[1]) == -1) syserr("close2"); execlp("cat","cat", NULL); syserr("execl"); if (close(pfd[0]) == -1) syserr("close3"); sleep(2); if (write(pfd[1],"questa stringa e stampata da cat\n",37) == -1) syserr("write"); if (close(pfd[1]) == -1) syserr("close4"); /* pipewho_wc.c */ int pfd[2]; if(pipe(pfd) == -1) syserr("pipe"); switch(fork()) case -1: syserr("fork"); if (close(1) == -1) syserr("close"); if (dup(pfd[1])!= 1) fatal("dup"); if (close(pfd[0]) == -1 close(pfd[1]) == -1) syserr("close2"); execlp("who", "who", NULL); syserr("execl"); switch(fork()) case -1: syserr("fork"); if(close(0) == -1) syserr("close3"); if (dup(pfd[0])!= 0) fatal("dup2"); if (close(pfd[0]) == -1 close(pfd[1]) == -1) syserr("close4"); execlp("wc", "wc", NULL); syserr("execl2"); if (close(pfd[0]) == -1 close(pfd[1]) == -1) syserr("close5"); while(wait(null)!= -1) ;

/* pipe3.c */ int pfd[2], pfd1[2]; char cmd[10], cmd1[10], cmd2[10]; printf("mette in pipe tre comandi UNIX.\n"); printf("dare i tre comandi :"); scanf("%s %s %s",cmd,cmd1,cmd2); if(pipe(pfd) == -1) if(pipe(pfd1) == -1) syserr("pipe"); syserr("pipe"); switch(fork()) case -1: syserr("fork"); if (close(0) == -1) syserr("close_wc"); if (dup(pfd1[0])!= 0) fatal("dup_wc"); if ( close(pfd1[0]) == -1 close(pfd1[1]) == -1 close(pfd[0]) == -1 close(pfd[1]) == -1 ) syserr("close2_wc"); execlp(cmd2, cmd2, NULL); syserr("execwc"); switch(fork()) case -1: syserr("fork"); if (close(0) == -1) syserr("close0_sort"); if (dup(pfd[0])!= 0) fatal("dup0_sort"); if (close(1) == -1) syserr("close1_sort"); if (dup(pfd1[1])!= 1) fatal("dup1_sort"); if ( close(pfd1[0]) == -1 close(pfd1[1]) == -1 close(pfd[0]) == -1 close(pfd[1]) == -1 ) syserr("close2_sort"); printf("attivo sort\n"); execlp(cmd1,cmd1, NULL); syserr("execlsort"); switch(fork()) case -1: syserr("fork44"); if (close(1) == -1) syserr("close_ps"); if (dup(pfd[1])!= 1) fatal("dup_ps"); if (close(pfd1[0]) == -1 close(pfd1[1]) == -1) syserr("close1_ps"); execlp(cmd,cmd, NULL); syserr("execlps"); if (close(pfd1[0]) == -1 close(pfd1[1]) == -1 close(pfd[0]) == -1 close(pfd[1]) == -1) syserr("close5"); while(wait(null)!= -1);

/* prova con pipe bidirez. */ /* pipebidir.c */ int pfdout[2], pfdin[2], fd, nread; char buf[512]; pipe(pfdin); pipe(pfdout); switch (fork()) case -1: syserr("fork"); close(0); dup(pfdout[0]); close(1); dup(pfdin[1]); close(pfdout[0]); close(pfdin[1]); close(pfdout[1]); close(pfdin[0]); execlp("sort","sort",null); syserr("execl"); close(pfdout[0]); close(pfdin[1]); if((fd=open("dati",0)) == -1) syserr("open"); while((nread=read(fd,buf,sizeof(buf)))!= 0) if(write(pfdout[1],buf,nread) == -1) syserr("write"); close(fd); close(pfdout[1]); while((nread=read(pfdin[0],buf,sizeof(buf)))!= 0) write(1,buf,nread); close(pfdin[0]);

/************************Coprocessori */ /* add.c */ int int n, int1, int2; char linea[100]; read(0, linea, 100); sscanf(linea, "%d %d", &int1, &int2); sprintf(linea,"%d %d \n", int1+int2, int1*int2); write(1,linea,strlen(linea)); exit(0); /***************************************/ #include <unistd.h> #define MAXLINE 100 /* cop.c */ int main(void) int n, fd1[2], fd2[2]; pid_t pid; char line[maxline]; if (pipe(fd1) < 0 pipe(fd2) < 0) syserr("errore di pipe"); if ( (pid = fork()) < 0) syserr("fork"); else if (pid > 0) /*processo padre */ close(fd1[0]); close(fd2[1]); printf("scrivere due numeri: "); while (fgets(line, MAXLINE, stdin)!= NULL) n = strlen(line); if (write(fd1[1], line, n)!= n) syserr("errore di scrittura in pipe"); if ( (n = read(fd2[0], line, MAXLINE)) < 0) syserr("errore di lettura da pipe"); printf("somma e prodotto ( dalla pipe ): %s\n", line); exit(0); else /* processo figlio */ close(fd1[1]); close(fd2[0]); close(0); dup(fd1[0]); close(1); dup(fd2[1]); close(fd2[1]); close(fd1[0]); execl("./add", "add", (char *) 0); syserr("execl error");

/* CLIFIFO.C */ #include <fcntl.h> #include <string.h> #include <sys/stat.h> #include <sys/errno.h> main(int argc,char *argv[]) char buf[100]; /* stringa che invio sulla FIFO */ int fd; /* descrittore file della FIFO */ int i; int pidpro; /* pid del processo */ pidpro=getpid(); /*aggancio la FIFO, aprendola in scrittura:*/ if((fd=open("ff", O_WRONLY))==-1) syserr("client: open ff"); printf("client %d :agganciata la FIFO\n",pidpro); /* controllo la presenza dei parametri */ chkpar(argc,argv,pidpro); /*preparo il messaggio:*/ printf("argv = %s %s\n", argv[0], argv[1]); switch(argv[1][0]) case c : case m : case r : case v : case s : case q : default : fprintf(stderr,"client %d (E): comando %s errato\n", pidpro,argv[1]); /* non cancello la FIFO: ci pensa il server */ exit(1); /*switch*/ strcpy(buf,argv[1]); strcat(buf," "); i=2; while (argv[i]!= NULL) strcat(buf,argv[i]); strcat(buf," "); i++; /*invio il comando:*/ if(write(fd,buf,strlen(buf))==-1) syserr("write"); close(fd); printf("client %d :inviata richiesta (%s)\n",pidpro,argv[1]); return(0); /*main*/

/*FUNZIONE:controlla presenza parametri*/ chkpar (argc,argv,pidpro) int argc; char *argv[]; int pidpro; if (argc < 2) fprintf (stderr, "Client %d (E): primo argomento assente\n", pidpro); /* non cancello la fifo: ci pensa il server */ exit (1); else char l1; l1 = argv[1][1]; if ( (l1== r l1== v l1== s ) && argc < 3 ) fprintf (stderr, "Client %d (E): secondo argomento assente\n", pidpro); exit (1); if ( (l1 == m l1 == c ) && argc < 4) fprintf (stderr, "Client %d (E): terzo argomento assente\n", exit (1); pidpro); /* chkpar */

/* SERFIFO.C */ #include <fcntl.h> #include <string.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/errno.h> extern int errno; int fd; /* descrittore file della FIFO */ int nread; /* numero byte letti dalla FIFO */ int i; static char buf[100]; /* perche funziona solo con lo static? */ char **varg; /* vettore dei comandi letti dalla FIFO */ char *bufp; /* usato nella strtok */ struct stat sbuf; /* usata nella chiamata di sistema stat */ /*extern char **environ;*/ mknod("ff",s_ififo 0666,0); /* creo la FIFO */ printf("server: creata FIFO \"ff\"\n"); /* apro la FIFO in lettura/scrittura (non in sola lettura altrimenti il server si blocca: */ if((fd=open("ff",o_rdwr))==-1) syserr("open ff"); /*environ[6]=""; PS1= */ /*loop infinito:*/ while(1) printf("\nserver: attendo richieste...\n"); printf("comandi: c file1 file2 (copia)\n"); printf(" m file1 file2 (move)\n"); printf(" r file1 (cancella)\n"); printf(" s file1 (statistica)\n"); printf(" v file1 (vista di un file)\n"); printf(" q (cancella la fifo)\n"); /* Ricevo il messaggio(se non c e nulla attendo) */ while((nread=read(fd,buf,sizeof(buf))) == 0) ; if(nread==-1) syserr("read"); printf("server: ricevo richiesta %s\n",buf); bufp=buf; for(i=0;i<3;i++) if((varg[i]=strtok(bufp," "))==NULL) bufp=null;

switch(varg[0][0]) case c : /*Copia di file*/ switch(fork()) case -1: syserr("fork di cp"); printf("copio \"%s\" in \"%s\"\n",varg[1],varg[2]); execlp("cp","cp",varg[1],varg[2],null); syserr("exec di cp"); default: if(wait(null)==-1) /*il server aspetta la fine*/ syserr("wait"); /*dell operazione di copia*/ case m : /*Spostamento di file*/ switch(fork()) case -1: syserr("fork di mv"); printf("sposto \"%s\" in \"%s\"\n",varg[1],varg[2]); execlp("mv","mv",varg[1],varg[2],null); syserr("exec di mv"); default: if(wait(null)==-1) /*il server aspetta la fine*/ syserr("wait"); /*dello spostamento*/ case r : /*Cancellazione di file*/ switch(fork()) case -1: syserr("fork di rm"); printf("cancello \"%s\"\n",varg[1]); execlp("rm","rm",varg[1],null); syserr("exec di rm"); default: if(wait(null)==-1) /*il server aspetta la fine*/ syserr("wait"); /*della cancellazione*/ case s : /*Statistica di un file*/ if ( stat(varg[1], &sbuf) < 0 ) syserr("stat"); printf("\nstato del file \"%s\" :\n",varg[1]); printf("numero device: %ld\n",sbuf.st_dev); printf("numero inode: %ld\n",sbuf.st_ino); printf("tipo di file e permessi: %#o\n",(int)sbuf.st_mode); printf("numero di hard links: %d\n",(int) sbuf.st_nlink); printf("id utente del proprietario del file: %d\n", sbuf.st_uid); printf("id gruppo del proprietario del file: %d\n", sbuf.st_gid); printf("dimensione in byte del file: %ld\n", (long)sbuf.st_size); printf("ultimo accesso: %s",ctime(&(sbuf.st_atime))); printf("ultima modifica: %s",ctime(&(sbuf.st_mtime))); printf("ora ultimo cambiamento di stato: %s", ctime(&(sbuf.st_ctime))); case v : /*Vista di un file*/ switch(fork()) case -1: syserr("fork di cat"); printf("contenuto di \"%s\"\n",varg[1]); execlp("cat","cat",varg[1],null); syserr("exec di cat"); default: if(wait(null)==-1) /*il server aspetta la

fine*/ syserr("wait"); /*dell operazione di cat*/ case q : /* cancello la FIFO */ close(fd); unlink("ff"); printf("server: FIFO cancellata\n"); exit(0); /*switch*/ for(i=0;i<=30;i++) buf[i]= \0 ; /* fine del while */ return(0); /*main*/