Laboratorio di Sistemi Operativi LAB6 System call per gestione IPC (Inter Process Communication) 2002/2003 Pagani Trentini Slide 1 Agenda Linux gestione segnali ; kill ; alarm ; pause ; read ; write ; close ; pipe ; fifo (cenni) Windows messages (cenni) ; anonymous pipe ; ReadFile ; WriteFile ; named pipe (cenni) 2002/2003 Pagani Trentini Slide 2
Linux 2002/2003 Pagani Trentini Slide 3 gestione dei segnali UNIX rende possibile mandare dei messaggi asincroni ai processi, per la notifica di eventi possono essere generati dal sistema in maniera automatica (e.g. per segnalare la morte di un processo figlio) generati dal sistema ma su richiesta dell utente (allarmi temporizzati) scambiati tra processi utente per notificare eventi 2002/2003 Pagani Trentini Slide 4
gestione dei segnali predefiniti tipi di segnali, e azioni di default da compiere per gestirli un proc puo mandare segnali solo ad altri procs con lo stesso UID; root puo mandare segnali a qualunque proc per alcuni segnali, un proc puo (anticipatamente) indicare una routine (handler) diversa da quella di default per la loro gestione 2002/2003 Pagani Trentini Slide 5 SIGHUP SIGINT SIGKILL SIGALRM SIGTERM SIGSTOP SIGTSTP SIGCONT SIGCHLD tipi di segnali segnale di reset di linea (forza la rilettura di una configurazione) terminazione del processo terminazione del processo segnalazione temporizzata real time terminazione software del processo sospensione del job sospensione del job il job riprende ad essere eseguito lo stato di un processo figlio cambiato gestibile? SI NO SI SI SI SI NO NO SI SIGUSR1/2 non gestiti da sistema, sono a disposizione del programmatore SI 2002/2003 Pagani Trentini Slide 6
void (*signal(int signum, void (*handler)(int)))(int); serve per indicare a s.o. qual e la funzione handler del segnale specificato, in sostituzione dello handler di default memorizza info in u area eventualmente indica segnale da ignorare (SIG_IGN) NON serve per mandare segnali il proc NON si blocca in attesa del segnale torna 0 se ha successo, 1 altrimenti 2002/2003 Pagani Trentini Slide 7 #include <signal.h> #include <sys/types.h> int handler() int retcode; printf("signal received\n"); signal(sigusr1, handler); main(int argc, char ** argv) printf("my pid is %d\n", getpid()); signal(sigusr1, handler); signal(sigusr2, SIG_IGN); while(1) sleep(60); File signal.c // ATTENZIONE! Handler da ripristinare! N.B. per provare questo esempio, mandarlo in esecuzione in background e inviare quindi segnali di USR1, USR2 o terminazione con la kill. Esempio: kill USR1 <PID processo> Il PID viene stampato a inizio esecuzione. 2002/2003 Pagani Trentini Slide 8
int kill(pid_t pid, int sig) serve per inviare il segnale indicato al proc con PID indicato se pid = 0 : segnale inviato a tutti i procs nello stesso gruppo del chiamante se pid = 1 e invocata da superuser: segnale inviato a tutti i processi se pid = 1 e non invocata da superuser: segnale inviato a tutti i procs con UID uguale a EUID chiamante torna 0 se ha successo e 1 altrimenti 2002/2003 Pagani Trentini Slide 9 #include <stdio.h> #include <signal.h> #include <sys/types.h> #include <sys/wait.h> File kill1.c int handler(void) int retcode; printf("signal received\n"); signal(sigusr1, (sig_t) handler); main(int argc, char **argv) int retcode; int pid; pid = fork(); 2002/2003 Pagani Trentini Slide 10
if (!pid) printf("child pid is %d\n", getpid()); signal(sigusr1, (sig_t) handler); signal(sigusr2, (sig_t) SIG_IGN); while(1) sleep(60); sleep(1); printf("father pid is %d\n", getpid()); while(1) sleep(10); kill(pid, SIGUSR1); 2002/2003 Pagani Trentini Slide 11 unsigned int alarm(unsigned int seconds) serve per mandare al processo stesso un segnale SIGALRM dopo il tempo indicato e una sorta di timer sovrascrive allarmi precedenti torna il #sec che mancava allo scadere dell allarme precedente (o 0) se ha successo, 1 altrimenti alarm(0) annulla gli allarmi creati in precedenza 2002/2003 Pagani Trentini Slide 12
#include <stdio.h> #include <signal.h> #include <unistd.h> typedef void (*sig_t) (int); int handler(void) static int counter = 0; counter += 1; printf("%d seconds passed\n", counter); signal(sigalrm, (sig_t) handler); alarm(1); main(int argc, char **argv) signal(sigalrm, (sig_t) handler); alarm(1); while(1) sleep(60); File alarm.c 2002/2003 Pagani Trentini Slide 13 int pause(void) sospende il chiamante in attesa dell arrivo di un segnale qualsiasi quando segnale e ricevuto, il controllo passa al relativo signal handler, e poi all istruzione successiva a pause() torna sempre 1 puo servire per sincronizzazione tra processi o gestione timer in proc (con alarm() ) 2002/2003 Pagani Trentini Slide 14
#include <stdio.h> #include <signal.h> #include <unistd.h> int handler() static int counter = 0; File pause.c counter += 1; printf("%d seconds passed\n", counter); signal(sigalrm, handler); main(int argc, char **argv) signal(sigalrm, handler); while(1) alarm(1); pause(); 2002/2003 Pagani Trentini Slide 15 pid_t wait(int *status) a terminazione proc, s.o. invia SIGCLD a padre padre puo definire handler (asynch), oppure sospendersi in attesa della terminazione del figlio "The wait() function suspends execution of its calling process until status information is available for a terminated child process, or a signal is received. On return from a successful wait() call, the status area contains termination information about the process that exited." torna pid del figlio, o 1 in caso di errore anche waitpid() per attesa terminazione specifico figlio 2002/2003 Pagani Trentini Slide 16
#include <stdio.h> #include <sys/types.h> File wait.c #include <sys/wait.h> main(int argc,char ** argv) int retcode, pid; if (!fork()) printf("child pid is %d\n", getpid()); sleep(10); exit(8); sleep(1); printf("father pid is %d\n", getpid()); pid = wait(&retcode); if (pid == 1) perror("wait"); printf("signal received\n Child pid was %d\n", pid); printf("exit code was %d\n", WEXITSTATUS(retcode)); 2002/2003 Pagani Trentini Slide 17 pipe una pipe e un canale di comunicazione FIFO unidirezionale tra processi imparentati un proc scrive ad una estremita del canale; l altro processo legge dall altra estremita comunicazione asincrona: buffer associato alla pipe e implementato come un file senza nome le due estremita accedute tramite due descrittori di file letture e scritture sono eseguite con le stesse syscall usate per i file 2002/2003 Pagani Trentini Slide 18
int pipe(int filedes[2]) inizializza i due descrittori associati alla pipe la creazione va fatta prima di generare i discendenti che condividono la pipe dato che e file anonimo, condivisione possibile solo attraverso eredita descrittori... [recall fork()] parametro e array di due descrittori per convenzione: descrittore [0] per input (lettura); descrittore [1] per output (scrittura) torna 0 se ha successo e 1 altrimenti 2002/2003 Pagani Trentini Slide 19 ssize_t read(int fd, void *buf, size_t count) legge caratteri dal file descriptor fd in numero di count, e li mette nell array allocato all indirizzo *buf rende il numero di caratteri effettivamente letti, oppure 1 in caso di errore se e arrivato a EOF, torna 0 se legge da pipe e non ci sono caratteri, si blocca in attesa 2002/2003 Pagani Trentini Slide 20
ssize_t write(int fd, const void *buf, size_t count) scrive sul file indicato dal descrittore fd dei caratteri contenuti nell array allocato all indirizzo *buf, in numero di count rende il numero di caratteri effettivamente scritti o 1 in caso di errore se scrive su pipe e non c e piu spazio buffer, si arresta in attesa di disponibilita se proc reader e terminato, il chiamante termina con errore di Broken pipe 2002/2003 Pagani Trentini Slide 21 int close(int fd) chiude il descrittore e rilascia strutture dati torna 0 se ha successo e 1 altrimenti NB: chiusura descrittori inutili e buona pratica di programmazione evita condivisione indesiderata tra procs imparentati libera spazio nelle tabelle (file descriptor table, file table) per l allocazione di nuovi descrittori 2002/2003 Pagani Trentini Slide 22
#include <stdio.h> #include <unistd.h> File pipe.c main(int argc, char **argv) int pipestub[2]; int counter; char buffer[10]; if (pipe(pipestub) == 1) perror("pipe"); 2002/2003 Pagani Trentini Slide 23 if (!fork()) close(pipestub[1]); while(1) read(pipestub[0], buffer, 1); printf("%c(%x):", *buffer, *buffer); else close(pipestub[0]); while (1) counter = read(0, buffer, 10); write(pipestub[1], buffer, counter); 2002/2003 Pagani Trentini Slide 24
Windows 2002/2003 Pagani Trentini Slide 25 Strumenti di IPC thread nello stesso proc possono facilmente scambiare info, poiche accedono alle medesime risorse per thread in processi differenti: messaggi: specialmente per applic. grafiche pipe anonime: simili a Unix pipe pipe con nome: anche per comunicazione in rete 2002/2003 Pagani Trentini Slide 26
messaggi sono diretti a una window, piuttosto che ad uno specifico thread (ricevuto dal thread che ha creato la window) gestiti via struttura THREADINFO che include code di messaggi PostMessage: messaggio e aggiunto in coda e controllo torna immediatamente a chiamante (asincrono) SendMessage: msg e aggiunto in coda, ma chiamante e bloccato finche msg non e prelevato dalla coda (sincrono) ReplyMessage: usato per notificare ricezione msg al sender (e.g. se receiver prevede di essere lento a gestirlo) 2002/2003 Pagani Trentini Slide 27 pipe anonime passaggio info tra gli spazi di indirizzamento di processi diverse, implementato via shared memory canali anonimi unidirezionali per comunicazione tra procs (in genere imparentati) sullo stesso host procs leggono da/scrivono su pipe come da/su file usando relativi handle pipe distrutta quando tutti gli handle sono stati chiusi (CloseHandle) 2002/2003 Pagani Trentini Slide 28
CreatePipe BOOL CreatePipe( PHANDLE hreadpipe, // ptr a handle per lettura PHANDLE hwritepipe, // ptr a handle per scrittura LPSECURITY_ATTRIBUTES lppipeattributes, DWORD nsize // #bytes = taglia buffer associato ); se nsize=0 e usata taglia di default torna 0 se fallisce, non zero altrimenti 2002/2003 Pagani Trentini Slide 29 ReadFile BOOL ReadFile ( HANDLE hfile, // handle a file da leggere LPVOID lpbuffer, // ptr a buffer in cui porre dati letti DWORD nnumberofbytestoread, // #bytes da leggere LPDWORD lpnumberofbytesread, // ptr a #bytes letti LPOVERLAPPED lpoverlapped // per pipe deve essere NULL ); torna quando qualcuno ha scritto o se tutti i write handle sono stati chiusi torna 0 se fallisce, non zero altrimenti 2002/2003 Pagani Trentini Slide 30
WriteFile BOOL WriteFile ( HANDLE hfile, // handle a file da scrivere LPCVOID lpbuffer, // ptr a buffer da cui prendere dati DWORD nnumberofbytestowrite, // #bytes da scrivere LPDWORD lpnumberofbyteswritten, // ptr a #bytes scritti LPOVERLAPPED lpoverlapped // per pipe deve essere NULL ); se buffer pipe pieno, Write termina quando si crea spazio a sufficienza in seguito a una Read torna 0 se fallisce, non zero altrimenti 2002/2003 Pagani Trentini Slide 31 condivisione handle a pipe dato che pipe e anonima, tutti i procs che vogliono usarla devono conoscerne gli handle generalmente ottenuto via inheritance. ES: padre crea la pipe padre crea figlio I rendendo lo handle di scrittura ereditabile e redireziona stdout figlio su pipe padre crea figlio II rendendo lo handle di lettura ereditabile e redireziona stdin figlio da pipe I P II stdin stdout pipe stdin stdout 2002/2003 Pagani Trentini Slide 32
esempio uso pipe in Win struttura sistema e step: padre crea pipe anonima padre crea figlio che eredita Read Handle della pipe padre legge da stdin e scrive su pipe; figlio legge da pipe e scrive su stdout funzioni principali CreateChildProcess : crea figlio che eredita gli handle del padre WriteToPipe: legge da stdin e scrive su pipe, con opportuno controllo errori ErrorExit: stampa errore e termina processo 2002/2003 Pagani Trentini Slide 33 API e strutture usate nell esempio SECURITY_ATTRIBUTES: contiene info di sicurezza per l accesso a un oggetto e specifica se lo handle ottenuto specificando questo oggetto e ereditabile GetStdHandle: recupera handle per stdin, stdout o stderr SetStdHandle: fa set handle per stdin, stdout o stderr DuplicateHandle: duplica handle proc sorgente in handle proc destinatario, specificando se e inheritable ZeroMemory: riempie un blocco di memoria di 0 2002/2003 Pagani Trentini Slide 34
#include "stdafx.h" #include <stdio.h> #include <windows.h> File WpipePadre.cpp #define BUFSIZE 10 HANDLE hchildstdinrd, hchildstdinwr, hchildstdinwrdup, hchildstdoutrd, hchildstdoutwr, hchildstdoutrddup, hinputfile, hsavestdin, hsavestdout; BOOL CreateChildProcess(VOID); VOID WriteToPipe(VOID); VOID ErrorExit(LPTSTR); int main(int argc, char *argv[]) SECURITY_ATTRIBUTES saattr; BOOL fsuccess; // Save the handle to the current STDIN. hsavestdin = GetStdHandle(STD_INPUT_HANDLE); 2002/2003 Pagani Trentini Slide 35 // Set the binherithandle flag so pipe handles are inherited. saattr.nlength = sizeof(security_attributes); saattr.binherithandle = TRUE; saattr.lpsecuritydescriptor = NULL; // Create a pipe for the child process s STDIN. if (! CreatePipe(&hChildStdinRd, &hchildstdinwr, &saattr, 0)) ErrorExit("Stdin pipe creation failed\n"); // Set a read handle to the pipe to be STDIN. if (! SetStdHandle(STD_INPUT_HANDLE, hchildstdinrd)) ErrorExit("Redirecting Stdin failed"); // Duplicate the write handle to the pipe so it is not inherited. fsuccess = DuplicateHandle(GetCurrentProcess(), hchildstdinwr, GetCurrentProcess(), &hchildstdinwrdup, 0, FALSE, // not inherited DUPLICATE_SAME_ACCESS); if (! fsuccess) ErrorExit("DuplicateHandle failed"); CloseHandle(hChildStdinWr); 2002/2003 Pagani Trentini Slide 36
// Now create the child process. fsuccess = CreateChildProcess(); if (! fsuccess) ErrorExit("Create process failed"); // After process creation, restore the saved STDIN if (! SetStdHandle(STD_INPUT_HANDLE, hsavestdin)) ErrorExit("Re redirecting Stdin failed\n"); hinputfile = hsavestdin; if (hinputfile == INVALID_HANDLE_VALUE) ErrorExit("no input file\n"); // Write to pipe that is the standard input for a child process. WriteToPipe(); return 0; 2002/2003 Pagani Trentini Slide 37 BOOL CreateChildProcess() PROCESS_INFORMATION piprocinfo; STARTUPINFO sistartinfo; BOOL bfuncretn = FALSE; // reset PROCESS_INFORMATION and STARTUPINFO structures ZeroMemory( &piprocinfo, sizeof(process_information) ); ZeroMemory( &sistartinfo, sizeof(startupinfo) ); sistartinfo.cb = sizeof(startupinfo); // Create the child process. bfuncretn = CreateProcess(NULL, "figlio", // command line NULL, // process security attributes NULL, // primary thread security attributes TRUE, // handles are inherited 0, // creation flags NULL, // use parent s environment NULL, // use parent s current directory &sistartinfo, // STARTUPINFO pointer &piprocinfo); // receives PROCESS_INFORMATION 2002/2003 Pagani Trentini Slide 38
if (bfuncretn == 0) ErrorExit("CreateProcess failed\n"); return 0; else CloseHandle(piProcInfo.hProcess); CloseHandle(piProcInfo.hThread); return bfuncretn; printf("padre in Create Child: ho fatto\n"); // end CreateChildProcess VOID ErrorExit (LPTSTR lpszmessage) fprintf(stderr, "%s\n", lpszmessage); ExitProcess(0); 2002/2003 Pagani Trentini Slide 39 VOID WriteToPipe(VOID) DWORD dwread, dwwritten; CHAR chbuf[bufsize]; // Read from a file and write its contents to a pipe. for (;;) if (! ReadFile(hInputFile, chbuf, BUFSIZE, &dwread, NULL) dwread == 0) break; printf("padre: letto da stdin %d char, ora scrivo su pipe\n",dwread); if (! WriteFile(hChildStdinWrDup, chbuf, dwread, &dwwritten, NULL)) break; // Close the pipe handle so the child process stops reading. if (! CloseHandle(hChildStdinWrDup)) ErrorExit("Close pipe failed\n"); 2002/2003 Pagani Trentini Slide 40
#include "stdafx.h" #include <windows.h> #define BUFSIZE 10 File WpipeFiglio.cpp int main(int argc, char* argv[]) CHAR chbuf[bufsize]; DWORD dwread, dwwritten; HANDLE hstdin, hstdout; BOOL fsuccess; hstdout = GetStdHandle(STD_OUTPUT_HANDLE); hstdin = GetStdHandle(STD_INPUT_HANDLE); if ((hstdout == INVALID_HANDLE_VALUE) (hstdin == INVALID_HANDLE_VALUE)) ExitProcess(1); 2002/2003 Pagani Trentini Slide 41 for (;;) // Read from standard input. fsuccess = ReadFile(hStdin, chbuf, BUFSIZE, &dwread, NULL); if (! fsuccess dwread == 0) break; printf("figlio: letto da pipe %d char, ora scrivo \n", dwread); // Write to standard output. fsuccess = WriteFile(hStdout, chbuf, dwread, &dwwritten, NULL); if (! fsuccess) break; return 0; 2002/2003 Pagani Trentini Slide 42
pipe con nome Unix: come le pipe anonime, ma consentono comunicazione (unidirezionale) tra processi non imparentati (residenti sullo stesso host) fifo, generate con mkfifo() che crea un file speciale Win: a differenza delle pipe anonime, consentono comunicazione bidirezionale anche tra processi residenti su macchine diverse (via rete) usano API differenti da pipe anonime (e.g. CreateNamedPipe, WaitNamedPipe, CallNamedPipe...) 2002/2003 Pagani Trentini Slide 43