X-Git-Url: https://gapil.gnulinux.it/gitweb/?a=blobdiff_plain;f=signal.tex;h=f7bae08adb1e6ff6dff15e03bcdf1a872670aa8a;hb=76c2def510b553794baef8313e00d64b75652c3c;hp=bda0f3a48e82c6e8e75ea8c992c7b238b050e54c;hpb=dae47fe5a867149bb13d3b69126d92b8498b607b;p=gapil.git diff --git a/signal.tex b/signal.tex index bda0f3a..f7bae08 100644 --- a/signal.tex +++ b/signal.tex @@ -52,20 +52,22 @@ dei segnali (dette semantiche) che vengono chiamate rispettivamente Nella semantica \textit{unreliable} la routine di gestione del segnale specificata dall'utente non resta installata una volta chiamata; è perciò a carico dell'utente stesso ripetere l'installazione all'interno della routine -stessa in tutti i casi in cui si vuole che il signal handler esterno resti -attivo. - -Per questo motivo è possibile una race-condition in cui il segnale arriva -prima che il suo manipolatore sia installato, nel qual caso il segnale può -essere perso o causare il comportamento originale (in genere la terminazione -del processo). Questa è la ragione per cui detti segnali sono chiamati -\textit{inaffidabili}, in quanto la ricezione del segnale e la reinstallazione -del suo manipolatore non sono operazioni atomiche. - -In caso di implementazione inaffidabile le chiamate di sistema non sono fatte -ripartire automaticamente quando sono interrotte da un segnale, per questo il -programma deve controllare lo stato di uscita della chiamata al sistema e -riperterla nel caso l'errore riportato da \texttt{errno} sia \texttt{EINTR}. +di gestione stessa in tutti i casi in cui si vuole che il signal handler +esterno resti attivo. + +Per questo motivo è possibile una race-condition in cui un secondo segnale +arriva prima che il manipolatore abbia eseguito la re-installazione di se +stesso, nel qual caso il segnale può essere perso o causare il comportamento +originale assegnato al segnale (in genere la terminazione del processo). +Questa è la ragione per cui detti segnali sono chiamati \textit{inaffidabili}, +in quanto la ricezione del segnale e la reinstallazione del suo manipolatore +non sono operazioni atomiche. + +Nel caso di implementazione inaffidabile le chiamate di sistema non +sono fatte ripartire automaticamente quando sono interrotte da un segnale, per +questo il programma deve controllare lo stato di uscita della chiamata al +sistema e riperterla nel caso l'errore riportato da \texttt{errno} sia +\texttt{EINTR}. Inoltre in questo caso non esiste una modalità semplice per ottenere una operazione di pausa atomica (cioè mandare in sleep un processo fino all'arrivo @@ -82,7 +84,6 @@ ottenere un'operazione di pausa atomica (usando la funzione POSIX \subsubsection{Tipi di segnali} \label{sec:sig_types} - In generale gli eventi che generano i segnali si possono dividere in tre categorie principali: errori, eventi e richieste esplicite. @@ -159,7 +160,7 @@ diversa azione per lo stesso segnale. Se arriva un segnale per il quale non è stato specificata un'azione viene utilizzata l'azione standard. Questa è diversa da segnale a segnale (come -vedremo in \ref{sec:sig_standard}) ma per la maggior parte essa comporta la +vedremo in \secref{sec:sig_standard}) ma per la maggior parte essa comporta la terminazione del processo, per alcuni che invece rappresentano eventi innocui l'azione standard è di non fare nulla. @@ -194,41 +195,116 @@ segnali sono definiti nell'header di sistema \texttt{signal.h}. Il numero totale di segnali presenti è dato dalla macro \texttt{NSIG}, e dato che i numeri dei segnali sono allocati progressivamente, essa corrisponde -anche al successivo del valore numerico assegnato all'ultimo segnale definito. +anche al successivo del valore numerico assegnato all'ultimo segnale definito, +in \ntab\ si è riportato l'elenco completo dei segnali definiti in Linux, +comparati con quelli definiti in vari standard. + +\begin{table}[htb] + \centering + \begin{tabular}[c]{|l|c|c|c||c|l|} + \hline + Segnale & POSIX.1 & SUSv2 & Linux &Azione & Descrizione \\ + \hline + \hline + SIGHUP &$\bullet$&&$\bullet$& A & Hangup \\ + SIGINT &$\bullet$&&$\bullet$& A & Interrupt from keyboard \\ + SIGQUIT &$\bullet$&&$\bullet$& C & Quit from keyboard \\ + SIGILL &$\bullet$&&$\bullet$& C & Illegal Instruction \\ + SIGABRT &$\bullet$&&$\bullet$& C & Abort signal from abort(3) \\ + SIGFPE &$\bullet$&&$\bullet$& C & Floating point exception \\ + SIGKILL &$\bullet$&&$\bullet$& AEF & Kill signal \\ + SIGSEGV &$\bullet$&&$\bullet$& C & Invalid memory reference \\ + SIGPIPE &$\bullet$&&$\bullet$& A & Broken pipe \\ + SIGALRM &$\bullet$&&$\bullet$& A & Timer signal from alarm(2) \\ + SIGTERM &$\bullet$&&$\bullet$& A & Termination signal \\ + SIGUSR1 &$\bullet$&&$\bullet$& A & User-defined signal 1 \\ + SIGUSR2 &$\bullet$&&$\bullet$& A & User-defined signal 2 \\ + SIGCHLD &$\bullet$&&$\bullet$& B & Child stopped or terminated \\ + SIGCONT &$\bullet$&&$\bullet$& & Continue if stopped \\ + SIGSTOP &$\bullet$&&$\bullet$& DEF & Stop process \\ + SIGTSTP &$\bullet$&&$\bullet$& D & Stop typed at tty \\ + SIGTTIN &$\bullet$&&$\bullet$& D & tty input for background process \\ + SIGTTOU &$\bullet$&&$\bullet$& D & tty output for background process \\ + SIGBUS &&$\bullet$&$\bullet$& C & Bus error (bad memory access) \\ + SIGPOLL &&$\bullet$&$\bullet$& A & Pollable event (Sys V). Synonym of SIGIO\\ + SIGPROF &&$\bullet$&$\bullet$& A & Profiling timer expired \\ + SIGSYS &&$\bullet$&$\bullet$& C & Bad argument to routine (SVID) \\ + SIGTRAP &&$\bullet$&$\bullet$& C & Trace/breakpoint trap \\ + SIGURG &&$\bullet$&$\bullet$& B & Urgent condition on socket (4.2 BSD) \\ + SIGVTALRM &&$\bullet$&$\bullet$& A & Virtual alarm clock (4.2 BSD) \\ + SIGXCPU &&$\bullet$&$\bullet$& C & CPU time limit exceeded (4.2 BSD) \\ + SIGXFSZ &&$\bullet$&$\bullet$& C & File size limit exceeded (4.2 BSD) \\ + SIGIOT &&&$\bullet$& C & IOT trap. A synonym for SIGABRT \\ + SIGEMT &&&$\bullet$& & \\ + SIGSTKFLT &&&$\bullet$& A & Stack fault on coprocessor \\ + SIGIO &&&$\bullet$& A & I/O now possible (4.2 BSD) \\ + SIGCLD &&&$\bullet$& & A synonym for SIGCHLD \\ + SIGPWR &&&$\bullet$& A & Power failure (System V) \\ + SIGINFO &&&$\bullet$& & A synonym for SIGPWR \\ + SIGLOST &&&$\bullet$& A & File lock lost \\ + SIGWINCH &&&$\bullet$& B & Window resize signal (4.3 BSD, Sun) \\ + SIGUNUSED &&&$\bullet$& A & Unused signal (will be SIGSYS) \\ + \hline + \end{tabular} + \caption{Lista dei segnali in Linux} + \label{tab:sign_signal_list} +\end{table} \subsubsection{Segnali di errore di programma} -Questi segnali sono generati quando c'è un grave errore nel programma rilevato -dal sistema o dallo stesso hardware. In generale indicano che il programma ha -dei gravi problemi e l'esecuzione non può essere proseguita. - -Alcuni programmi usano questi segnali per riordinare le cose prima di uscire. -Ad esempio ripristinare i settaggi della console, o eliminare i file di lock. -In questo caso il manipolatore deve concludersi ripristinando l'azione di -default e rialzando il segnale, così che il programma possa concludersi come -se il manipolatore non ci fosse mai stato. - -L'azione di default per tutti questi segnali è causare la terminazione del +Questi segnali sono generati quando il sistema, o in certi casi direttamente +l'hardware (come per i page fault non validi) rileva un qualche errore +insanabile nel programma in esecuzione. In generale la generazione di questi +segnali significa che il programma ha dei gravi problemi (ad esempio ha +dereferenziato un puntatore non valido o ha eseguito una operazione aritmetica +proibita) e l'esecuzione non può essere proseguita. + +In genere si intercettano questi segnali per permettere al programma di +terminare in maniera pulita, ad esempio per ripristinare i settaggi della +console o eliminare i file di lock prima dell'uscita. In questo caso il +manipolatore deve concludersi ripristinando l'azione di default e rialzando il +segnale, in questo modo il programma si concluderà senza effetti spiacevoli, +ma riportando lo stesso stato di uscita che avrebbe avuto se il manipolatore +non ci fosse stato. + +L'azione di default per tutti questi segnali è causare la terminazione del processo che li ha causati. In genere oltre a questo il segnale provoca pure la registrazione su disco di un \textit{core dump file} che viene scritto in un file \texttt{core} nella directory corrente del processo al momento -dell'errore. +dell'errore. Questi segnali sono: \begin{itemize} \item \texttt{SIGFPE} Riporta un errore aritmetico fatale. Benché il nome derivi da \textit{floating point exception} si applica a tutti gli errori - aritmetici compresa la divisione per zero e l'overflow. + aritmetici compresa la divisione per zero e l'overflow. % Per questo segnale le cose sono complicate dal fatto che possono esserci % molte diverse eccezioni che \texttt{SIGFPE} non distingue, mentre lo % standard IEEE per le operazioni in virgola mobile definisce vaire eccezioni % aritmetiche e richiede che esse siano notificate. -\item \texttt{SIGFPE} Il nome deriva da \textit{illegal instruction} -\item \texttt{SIGILL} -\item \texttt{SIGSEGV} +\item \texttt{SIGILL} Il nome deriva da \textit{illegal instruction}, + significa che il programma sta cercando di eseguire una istruzione + privilegiata o inesistente, in generale del codice illegale. Poiché il + compilatore del C genera del codice valido si ottiene questo segnale se il + file eseguibile è corrotto o si stanno cercando di eseguire dei dati. + Quest'ultimo caso può accadere quando si passa un puntatore sbagliato al + posto di un puntatore a funzione, o si eccede la scrittura di un vettore di + una variabile locale, andando a corrompere lo stack. Lo stesso segnale viene + generato in caso di overflow dello stack o di problemi nell'esecuzione di di + un signal handler. + +\item \texttt{SIGSEGV} Il nome deriva da \textit{segment violation}, e + significa che il programma sta cercando di leggere o scrivere in una zona di + memoria protetta al di fuori di quella che gli è stata riservata dal + sistema. In genere è il meccanismo della protezione della memoria che si + accorge dell'errore ed il kernel genera il segnale. + + È tipico ottenere questo segnale dereferenziando un puntatore nullo o non + inizializzato leggendo al di la della fine di un vettore. + \item \texttt{SIGBUS} \item \texttt{SIGABRT} \item \texttt{SIGTRAP}