I segnali. First the signals described in the original POSIX standard.

Transcript

1 I segnali Prof.ssa Sara Michelangeli I segnali sono interruzioni inviate ai processi dal kernel, da un altro processo utente, oppure da un processo a se' stesso. Possono essere utilizzati dal sistema operativo per inviare una comunicazione ad un programma in esecuzione per il verificarsi di alcuni eventi hardware o software nel sistema, come ad esempio situazioni di errore, operazioni di I/O, richiesta di chiusura di un processo, scadenza di time slice ecc. oppure possono essere usati anche come meccanismi di comunicazioni tra processi. Ad esempio un processo padre puo' inviare al figlio un segnale di esecuzione forzata di un certo codice o una terminazione. In ogni caso, l'invio del segnale passa per il kernel. Se il processo si trova in running, il kernel lo "passa" subito. Se invece il processo si trova in attesa il segnale verrà passato quando il processo andrà in esecuzione. Il processo che riceve il segnale puo avere diversi comportamenti: puo' eseguire un'azione di default, predefinita dal sistema operativo, per ogni segnale,oppure se il tipo di segnale lo consente, eseguire le istruzioni implementate dal programmatore in una funzione handler, o, ignorare il segnale senza avere alcuna reazione. Tra i segnali che non possono essere gestiti esplicitamente dai processi ci sono SIGKILL, per terminare un processo e SIGSTOP, per sospendere un processo: quando un processo li riceve deve eseguire l azione di default, non può bloccarli, fermarli o ignorarli. La lista completa dei segnali standard su un sistema Unix è visibile con il comando man 7 signal. Eccone alcuni: First the signals described in the original POSIX standard. Signal Value Action Comment SIGHUP 1 Term Hangup detected on controlling terminal or death of controlling process SIGINT 2 Term Interrupt from keyboard SIGQUIT 3 Core Quit from keyboard SIGILL 4 Core Illegal Instruction SIGABRT 6 Core Abort signal from abort SIGFPE 8 Core Floating point exception SIGKILL 9 Term Kill signal SIGSEGV 11 Core Invalid memory reference SIGPIPE 13 Term Broken pipe: write to pipe with no readers SIGALRM 14 Term Timer signal from alarm(2) SIGTERM 15 Term Termination signal SIGUSR1 30,10,16 Term User-defined signal 1 SIGUSR2 31,12,17 Term User-defined signal 2 SIGCHLD 20,17,18 Ign Child stopped or terminated SIGCONT 19,18,25 Cont Continue if stopped SIGSTOP 17,19,23 Stop Stop process SIGTSTP 18,20,24 Stop Stop typed at tty SIGTTIN 21,21,26 Stop tty input for background process SIGTTOU 22,22,27 Stop tty output for background process The signals SIGKILL and SIGSTOP cannot be caught, blocked, or ignored.

2 L'associazione tra gli identificatori simbolici e i numeri interi è specifica per ogni O.S. ed è contenuta nel file signal.h, per utilizzare le primitive di gestione dei segnali si deve effettuare l'include della libreria signal.h Oltre a SIGKILL e SIGSTOP già esaminati, approfondiamo altri segnali: SIGTERM : è il segnale generico per chiedere a un processo di terminare, che, a differenza di SIGKILL può essere ignorato o gestito dal programma che lo riceve. SIGALRM : viene usato per segnalare a un processo che un timer collegato all orologio di sistema ha terminato il tempo ad esso assegnato. SIGCONT : riavvia un processo fermato. int SIGPIPE : segnala che un pipe o un FIFO è interrotto, ciò accade se un processo apre un pipe in lettura prima che un altro inizi a scrivere. SIGUSR1, int SIGUSR2 : sono due segnali gestiti dall utente, in genere per essi viene scritta una funzione di gestione che permette la sincronizzazione tra due processi La chiamata di sistema per catturare un segnale è la signal, vi sono poi la funzione alarm, con cui un processo invia un segnale a se stesso e la funzione kill, utilizzata per l'invio di segnali tra processi. Signal Con la funzione "signal" e' possibile catturare i segnali che arrivano ad un processo e gestire con una funzione le azioni da eseguire al verificarsi del segnale, individuato attraverso il suo numero. Il prototipo della funzione signal secondo la sintassi GNU è sighandler_t signal(int sig, sighandler_t handler) sig è l intero (o il nome simbolico) che individua il segnale da gestire, handler ( gestore) è la funzione di gestione da eseguirsi al verificarsi del segnale, o in alternativa SIG_IGN(nel caso di segnale ignorato) o SIG_DFL(nel caso di azione di default) La funzione restituisce SIG_ERR (-1) in caso di errore. Questa sintassi è da preferire allo standard ANSI void (*signal(int signum, void (*handler)(int)))int) di più difficile lettura. Kill La primitiva kill() è la funzione con cui un processo può inviare un segnale ad un altro. Ha come primo parametro il PID del processo che deve ricevere il segnale, come secondo il segnale da inviare. Essa non causa necessariamente la terminazione del processo come farebbe pensare il suo nome. Infatti invia un SIGTERM a un processo, terminandolo, se è specificato solo il primo argomento, cioè il pid. Può anche mandare un segnale differente, se viene specificato il secondo argomento e puo' essere usata per vari scopi, come la sincronizzazione tra processi. Il valore ritornato è 0 se l'inoltro ha successo, altrimenti ritorna 1. Alarm Con la funzione "alarm" viene inviato un segnale al processo stesso che la invoca. Piu' precisamente, "alarm" permette l'invio del segnale "SIGALRM" dopo un certo tempo t (specificato come parametro). PID=-1 significa che il segnale e' inviato a tutti i processi (eccetto quelli numero "0=init" e "1=init)

3 pause(): il processo che chiama questa funzione rimane in attesa finchè viene ricevuto un segnale che lo termina o che attiva una funzione di analisi dei segnali. Ecco un primo programma di esempio Il padre genera un processo figlio con la fork, e tenta di terminarlo con l'uso dei segnali tramite la funzione kill. Invia il segnale SIGTERM che viene ignorato dal figlio che ha mascherato tale comando con una chiamata di signal con azione nulla. Il padre termina il figlio con l'invio di SIGKILL che non può essere ignorato. int main() int pid,i; pid=fork(); if(pid == 0) // Figlio signal(sigterm, SIG_IGN); // azione nulla al segnale SIGTERM printf("\n sono il figlio: %d e non sono stato terminato", getpid()); for(i=0; i<100; i++) // stampa 100 valori printf("numero: %d\n", i); else // Padre sleep(1); kill(pid, SIGTERM); // Invia al figlio il segnale SIGTERM che viene ignorato printf("\n Pid del figlio: %d - Tentativo di terminare il figlio fallito.\n", pid); kill(pid, SIGKILL); // Invia al figlio il segnale SIGKILL printf("figlio terminato con SIGKILL.\n\n");

4 Ecco un secondo programma di esempio. Il padre genera un processo figlio con la fork, e gli invia un segnale. Il figlio intercetta il segnale e gli risponde. void handlerfiglio(int sig) printf ("Ricevuto segnale dal padre con successo \n"); printf ("ciao papà ti rispondo \n"); fflush(stdout); kill(getppid(),sigusr2); void handlerpadre(int sig) printf ("Ricevuto segnale dal figlio con successo \n"); printf ("ciao figlio ho ricevuto la risposta \n"); int main() int pid; printf ("esercizio sincronizzazione con signal \n"); //installazione segnali pid=fork(); if (pid==0) pause(); //exit(0); else if (pid>0) // Padre //invia il segnale SIGUSR1 al figlio e rimane in attesa della risposta kill(pid,sigusr1); pause(); //ricevo il segnale SIGUSR2 dal figlio //exit(0);

5 Questo programma mostra l'uso dei segnali per la comunicazione tra due processi padre e figlio. Il programma crea un cronometro che conta fino a 59 minuti e 59 secondi. Il padre si occupa di aggiornare lo schermo con il tempo corrente. Il figlio avvisa il padre ogni secondo tramite il segnale SIGUSR1. int min=0, sec=0; void ora() signal(sigusr1, ora); //rimascherare il segnale è necessario su alcuni sistemi //fflush(stdout); // Forza la scrittura dei dati sullo schermo sec=sec+1; if(sec==60) // Se ci sono 60 sec, li azzera e incrementa i minuti. sec = 0; min++; if(min==60) min=0; //Azzera i minuti quando il cronometro arriva a 60 printf("min: %d sec %d\r", min, sec); fflush(stdout); // Forza la scrittura dei dati sullo schermo int main(void) int PID; //attivazione segnale signal(sigusr1, ora); PID=fork(); if (PID==0 ) // processo figlio while(1) sleep(1); kill(getppid(), SIGUSR1); // il figlio invia al padre il segnale SIGUSR1 per aggiornare l'orario else // processo padre while (1) signal(sigusr1, ora); //il padre intercetta il segnale e chiama l'handler ora