Provided by: manpages-it_3.73-2_all 
NOME
signal - panoramica sui segnali
DESCRIZIONE
Linux supporta sia i segnali POSIX affidabili (d'ora in avanti "segnali standard") che i
segnali real-time POSIX.
Disposizioni dei segnali
Ciascun segnale ha una disposizione attuale, che determina come si comporta il processo
quando il segnale viene recapitato.
Le voci nella colonna "Azione" della tabella qui sotto specificano la disposizione
predefinita di ogni segnale, come segue:
Term L'azione predefinita è terminare il processo.
Ign L'azione predefinita è ignorare il segnale.
Core L'azione predefinita è terminare il processo ed eseguire un core dump (vedere
core(5)).
Stop L'azione predefinita è arrestare il processo.
Cont L'azione predefinita è far continuare il processo se esso è attualmente fermo.
Un processo può cambiare la disposizione di un segnale usando sigaction(2) o signal(2)
(l'ultimo è meno portabile quando si crea un gestore di segnale; si veda signal(2) per i
dettagli). Usando queste chiamate di sistema, un processo può assumere uno dei seguenti
comportamenti al recapito del segnale: eseguire l'azione predefinita; ignorare il segnale;
intercettare il segnale con un gestore di segnale, una funzione definita dal programmatore
che è automaticamente invocata quando il segnale è recapitato (il gestore di segnale viene
chiamato, in modo predefinito, nel normale stack del processo. È possibile fare in modo
che il gestore di segnale usi uno stack alternativo: vedere sigaltstack(2) per una
discussione su come farlo e quando può essere utile).
La disposizione del segnale è un attributo per processo: in un'applicazione multithread,
la disposizione di un particolare segnale è la stessa per tutti i thread.
Un processo figlio creato tramite fork(2) eredita una copia della disposizione dei segnali
del genitore. Durante un execve(2), la disposizione dei segnali gestiti viene
inizializzata ai valori predefiniti; la disposizione dei segnali ignorati viene lasciata
com'è.
Inviare un segnale
Le seguenti chiamate di sistema e funzioni di libreria permettono al chiamante di inviare
un segnale:
raise(3) Invia un segnale al thread chiamante.
kill(2) invia un segnale al processo specificato, a tutti i membri del processo di
gruppo specificato o a tutti i processi nel sistema.
killpg(2) Invia un segnale a tutti i membri del processo di gruppo specificato.
pthread_kill(3) Invia un segnale al thread POSIX specificato nello stesso processo del
chiamante.
tgkill(2) Invia un segnale ad un processo specificato all'interno di un processo ben
preciso (è la chiamata di sistema usata per implementare pthread_kill(3)).
sigqueue(3) Invia un segnale real-time insieme a dati di accompagnamento al processo
specificato.
Attendere che un segnale venga intercettato
Le seguenti chiamate di sistema sospendono l'esecuzione del processo chiamante o del
thread finché non viene intercettato un segnale (o finché un segnale non gestito fa
terminare il processo):
pause(2) Sospende l'esecuzione finché non viene intercettato un segnale qualunque.
sigsuspend(2) Cambia temporaneamente la maschera del segnale (vedere sotto) e sospende
l'esecuzione finché viene intercettato uno dei segnali senza maschera.
Accettare in modo sincrono un segnale
Anziché intercettare un segnale in modo asincrono tramite un gestore di segnale, è
possibile accettare il segnale in modo sincrono, cioé bloccare l'esecuzione finché il
segnale viene consegnato: a questo punto il kernel restituirà informazioni sul segnale al
chiamante. Ci sono in generale due modi per farlo:
* sigwaitinfo(2), sigtimedwait(2), e sigwait(3) sospendono l'esecuzione finché viene
consegnato uno dei segnali contenuti in un insieme specifico. Ognuna di queste chiamate
restituisce informazioni sul segnale consegnato.
* signalfd(2) restituisce un descrittore di file che può essere usato per leggere
informazioni sui segnali consegnati al chiamante. Ogni read(2) da questo descrittore di
file blocca il chiamante finché uno dei segnali nell'insieme specificato dalla chiamata
signalfd(2) viene consegnato al chiamante stesso. Il buffer restituito da read(2)
contiene una struttura che descrive il segnale.
Maschera segnale e segnali pendenti
Un segnale può essere bloccato, cioé non verrà recapitato fino a quando non verrà
sbloccato. Un segnale viene definito pendente nel periodo di tempo che passa tra quando è
stato generato e quando è recapitato.
Ciascun thread in un processo ha una maschera segnale indipendente, che indica l'insieme
di segnali che il thread attualmente sta bloccando. Un thread può manipolare la sua
maschera segnale usando pthread_sigmask(3). In un'applicazione tradizionale a thread
singolo, si può usare sigprocmask(2) per manipolare la maschera segnale.
Un processo figlio creato tramite fork(2) eredita una copia della maschera di segnale del
processo genitore: la maschera di segnale viene preservata attraverso execve(2).
Un segnale può essere generato (e quindi pendente) per un processo nel suo insieme (per
esempio quando è inviato usando kill(2)) o per uno specifico thread (per esempio certi
segnali, come SIGSEGV e SIGFPE, generati come conseguenza dell'esecuzione di una
istruzione specifica in linguaggio macchina sono diretti al thread, come lo sono i segnali
indirizzati a uno specifico thread usando pthread_kill(3)). Un segnale diretto al
processo può essere recapitato a uno qualunque dei thread che attualmente non hanno il
segnale bloccato. Se più di uno dei thread ha il segnale sbloccato, allora il kernel
sceglie un thread arbitrario a cui recapitare il segnale.
Un thread può ottenere l'insieme di segnali che attualmente ha pendenti usando
sigpending(2). Questo insieme consisterà nell'unione dell'insieme dei segnali diretti ai
processi pendenti e l'insieme di segnali pendenti per il thread chiamante.
L'insieme di segnali pendenti di un processo figlio creato tramite fork(2) inizialmente è
vuoto: l'insieme di segnali pendenti è preservato attraverso execve(2).
Segnali standard
Linux supporta i segnali standard elencati di seguito. Molti numeri di segnale dipendono
dall'architettura, come indicato nella colonna "Valore" (dove sono indicati tre valori, il
primo è normalmente valido per alpha e sparc, quello in mezzo per x86, arm e la maggior
parte delle altre architetture, e l'ultimo per mips (i valori per parisc non vengono
mostrati; si vedano i sorgenti del kernel Linux per la numerazione dei segnali su questa
architettura). A - denota che un segnale è assente sulla corrispondente architettura).
Prima i segnali descritti nello standard POSIX.1-1990 originale.
Segnale Valore Azione Commento
───────────────────────────────────────────────────────────────────────────────────
SIGHUP 1 Term La linea sul terminale che ha il controllo è stata
agganciata o il processo che ha il controllo è morto
SIGINT 2 Term Interrupt da tastiera
SIGQUIT 3 Core Segnale d'uscita della tastiera
SIGILL 4 Core Istruzione illegale
SIGABRT 6 Core Segnale d'abbandono di abort(3)
SIGFPE 8 Core Eccezione in virgola mobile
SIGKILL 9 Term Termina il processo
SIGSEGV 11 Core Riferimento di memoria non valido
SIGPIPE 13 Term Pipe rotta: scrittura su una pipe priva di
lettori
SIGALRM 14 Term Segnale del timer da alarm(2)
SIGTERM 15 Term Segnale di termine
SIGUSR1 30,10,16 Term Segnale 1 definito dall'utente
SIGUSR2 31,12,17 Term Segnale 2 definito dall'utente
SIGCHLD 20,17,18 Ign Figlio fermato o terminato
SIGCONT 19,18,25 Cont Continua se fermato
SIGSTOP 17,19,23 Stop Ferma il processo
SIGTSTP 18,20,24 Stop Stop digitato dal terminale
SIGTTIN 21,21,26 Stop Input da terminale per un processo sullo sfondo
SIGTTOU 22,22,27 Stop Output da terminale per un processo sullo sfondo
I segnali SIGKILL e SIGSTOP non possono essere intercettati, bloccati o ignorati.
Seguono i segnali che non sono nello standard POSIX.1-1990 ma sono descritti in SUSv2 e
POSIX.1-2001.
Segnale Valore Azione Commento
─────────────────────────────────────────────────────────────────────────────
SIGBUS 10,7,10 Core Errore sul bus (accesso errato alla memoria)
SIGPOLL Term Evento suscettibile di polling (Sys V).
Sinonimo di SIGIO
SIGPROF 27,27,29 Term Timer del profiler scaduto
SIGSYS 12,31,12 Core Argomento errato alla routine (SVr4)
SIGTRAP 5 Core Trappola per trace/breakpoint
SIGURG 16,23,21 Ign Condizione urgente sul socket (4.2BSD)
SIGVTALRM 26,26,28 Term Allarme virtuale (4.2BSD)
SIGXCPU 24,24,30 Core Superato tempo limite di CPU (4.2BSD)
SIGXFSZ 25,25,31 Core Limite dimensione file superato (4.2BSD)
Fino a Linux 2.2 incluso, il comportamento predefinito per SIGSYS, SIGXCPU, SIGXFSZ, e (su
architetture diverse da SPARC e MIPS) SIGBUS era terminare il processo (senza eseguire un
core dump). (In alcuni altri sistemi UNIX l'azione predefinita per SIGXCPU e SIGXFSZ è
terminare il processo senza eseguire un core dump.) Linux 2.4 è conforme ai requisiti di
POSIX.1-2001 per questi segnali, terminando il processo con un core dump.
E ora altri vari segnali.
Segnale Valore Azione Commento
───────────────────────────────────────────────────────────────────────────────────
SIGIOT 6 Core Trappola IOT. Sinonimo di SIGABRT
SIGEMT 7,-,7 Term
SIGSTKFLT -,16,- Term Errore dello stack del coprocessore (inutilizzato)
SIGIO 23,29,22 Term I/O ora possibile (4.2 BSD)
SIGCLD -,-,18 Ign Sinonimo di SIGCHLD
SIGPWR 29,30,19 Term Mancanza di corrente (System V)
SIGINFO 29,-,- Sinonimo di SIGPWR
SIGLOST -,-,- Term Perso il lock del file (non usato)
SIGWINCH 28,28,20 Ign Dimensioni finestra cambiate (4.3BSD, Sun)
SIGUNUSED -,31,- Core Sinonimo di SIGSYS)
(Il segnale 29 è SIGINFO / SIGPWR su alpha ma SIGLOST su sparc.)
SIGEMT non è specificato in POSIX.1-2001, tuttavia appare in molti altri sistemi UNIX,
dove la sua azione predefinita è tipicamente di terminare il processo con un core dump.
SIGPWR (non specificato in POSIX.1-2001) è tipicamente ignorato in via predefinita in
questi altri UNIX dove appare.
SIGIO (non specificato in POSIX.1-2001) è ignorato in via predefinita in molti altri
sistemi UNIX.
Dove definito, SIGUNUSED è sinonimo di SIGSYS sulla maggior parte delle architetture.
Segnali Real-time
Linux supporta i segnali real-time come originariamente definiti nelle estensioni real-
time di POSIX.1b (e ora incluse in POSIX.1-2001). L'intervallo di segnali real-time
supportati è definito dalle macro SIGRTMIN e SIGRTMAX. POSIX.1-2001 richiede che
un'implementazione supporti almeno i segnali real-time _POSIX_RTSIG_MAX(8) .
Il kernel Linux supporta un intervallo di 32 diversi segnali real-time, numerati da 33 a
64. Comunque, l'implementazione di glibc POSIX dei thread usa internamente due (per NTPL)
o tre (per LinuxThreads) segnali real-time (vedere pthreads(7)), e sistema il valore di
SIGRTMIN in modo adatto (a 34 o 35). Dato che l'intervallo di segnali real-time
disponibili varia a seconda dell'implementazione dei thread di glibc (e questa variazione
può avvenire al run-time in accordo con kernel e glibc disponibili), e poiché l'intervallo
dei segnali real-time varia tra i vari sistemi UNIX, i programmi non dovrebbero mai
riferirsi ai segnali real-time usando numeri prefissati. Dovrebbero invece sempre fare
riferimento ai segnali real-time usando la notazione SIGRTMIN+n, e includere controlli
adatti (run-time) perché SIGRTMIN+n non ecceda SIGRTMAX.
Diversamente dai segnali standard, i segnali real-time non hanno significati predefiniti:
l'intero insieme dei segnali real-time può essere usato per scopi definiti
dall'applicazione.
L'azione predefinita per i segnali real-time non gestiti è di terminare il processo
ricevente.
I segnali real-time si distinguono da quanto segue:
1. Istanze multiple di segnali real-time possono essere accodate. Viceversa, se istanze
multiple di un segnale predefinito sono consegnate mentre questo segnale è bloccato,
allora viene accodata solo un'istanza.
2. Se il segnale è inviato usando sigqueue(3), un valore di accompagnamento (che sia un
intero o un puntatore) può essere inviato con il segnale. Se il processo ricevente
stabilisce un gestore per questo segnale usando il flag SA_SIGINFO a sigaction(2)
allora esso può ottenere questo dato attraverso il campo si_value della struttura
siginfo_t passata come secondo argomento al gestore. Inoltre i campi si_pid e si_uid
di questa struttura possono essere usati per ottenere PID e ID di un utente reale del
processo che invia il segnale.
3. I segnali real-time sono recapitati in un ordine garantito. I segnali real-time
multipli dello stesso tipo sono recapitati nell'ordine in cui vengono inviati. Se
segnali real-time diversi sono inviati ad un processo, essi sono consegnati partendo
dal segnale con il numero più basso (cioè i segnali con i numeri bassi hanno la
priorità maggiore). Al contrario, se segnali standard multipli sono in sospeso per un
processo, essi verranno recapitati in un ordine non specificato.
Se sia i segnali predefinit che quelli real-time sono in attesa di un processo, POSIX non
specifica quale consegnare per primo. Linux, come molte altre implementazioni, in questo
caso dà priorità ai segnali predefiniti.
Conformemente a POSIX, un'implementazione deve permettere che almeno (32) segnali
real-time _POSIX_SIGQUEUE_MAX vengano accodati a un processo. Tuttavia Linux fa le cose
diversamente. Nei kernel fino a e incluso il 2.6.7, Linux impone un limite globale al
numero di segnali real-time accodati per tutti i processi. Questo limite può essere visto
e cambiato (con privilegi) attraverso il file /proc/sys/kernel/rtsig-max. Un file
correlato, /proc/sys/kernel/rtsig-nr, può essere usato per trovare quanti segnali
real-time sono attualmente accodati. In Linux 2.6.8, queste interfacce /proc sono
sostituite dal limite di risorsa RLIMIT_SIGPENDING che specifica un limite per utente per
i segnali accodati. Vedere setrlimit(2) per ulteriori dettagli.
Funzioni async-signal-safe
Una funzione di manipolazione dei segnali deve fare molta attenzione, poiché qualunque
processo può essere interrotto in un punto arbitrario durante l'esecuzione del programma.
POSIX ha il concetto di "funzione sicura". Se un segnale interrompe l'esecuzione di una
funzione non sicura, e handler chiama una funzione non sicura, allora il comportamento del
programma non è definito.
POSIX.1-2004 (già conosciuto come POSIX.1-2001 Technical Corrigendum 2) richiede
all'implementazione di garantire che le seguenti funzioni possano essere chiamate in
sicurezza in un gestore di segnali:
_Exit()
_exit()
abort()
accept()
access()
aio_error()
aio_return()
aio_suspend()
alarm()
bind()
cfgetispeed()
cfgetospeed()
cfsetispeed()
cfsetospeed()
chdir()
chmod()
chown()
clock_gettime()
close()
connect()
creat()
dup()
dup2()
execle()
execve()
fchmod()
fchown()
fcntl()
fdatasync()
fork()
fpathconf()
fstat()
fsync()
ftruncate()
getegid()
geteuid()
getgid()
getgroups()
getpeername()
getpgrp()
getpid()
getppid()
getsockname()
getsockopt()
getuid()
kill()
link()
listen()
lseek()
lstat()
mkdir()
mkfifo()
open()
pathconf()
pause()
pipe()
poll()
posix_trace_event()
pselect()
raise()
read()
readlink()
recv()
recvfrom()
recvmsg()
rename()
rmdir()
select()
sem_post()
send()
sendmsg()
sendto()
setgid()
setpgid()
setsid()
setsockopt()
setuid()
shutdown()
sigaction()
sigaddset()
sigdelset()
sigemptyset()
sigfillset()
sigismember()
signal()
sigpause()
sigpending()
sigprocmask()
sigqueue()
sigset()
sigsuspend()
sleep()
sockatmark()
socket()
socketpair()
stat()
symlink()
sysconf()
tcdrain()
tcflow()
tcflush()
tcgetattr()
tcgetpgrp()
tcsendbreak()
tcsetattr()
tcsetpgrp()
time()
timer_getoverrun()
timer_gettime()
timer_settime()
times()
umask()
uname()
unlink()
utime()
wait()
waitpid()
write()
POSIX.1-2008 rimuove fpathconf(), pathconf(), e sysconf() dall'elenco precedente, e
aggiunge le seguenti funzioni:
execl()
execv()
faccessat()
fchmodat()
fchownat()
fexecve()
fstatat()
futimens()
linkat()
mkdirat()
mkfifoat()
mknod()
mknodat()
openat()
readlinkat()
renameat()
symlinkat()
unlinkat()
utimensat()
utimes()
Interruzione delle chiamate di sistema e funzioni di libreria da parte di gestori di segnale
Se viene chiamato un gestore di segnale mentre una chiamata di sistema o una funzione di
libreria sono bloccate, può succedere:
* che la chiamata venga automaticamente riavviata dopo il ritorno del gestore di segnale;
o
* che la chiamata fallisca con l'errore EINTR.
Il verificarsi di uno di questi due comportamenti dipende dall'interfaccia e dall'uso o
meno del flag SA_RESTART alla creazione del gestore di segnale (vedere sigaction(2)). I
dettagli variano tra i sistemi UNIX: seguono quelli per Linux.
Se un gestore di segnale interrompe una chiamata bloccata verso una delle seguenti
interfacce, la chiamata verrà automaticamente riavviata dopo il ritorno del gestore di
segnale, se è stato usato il flag SA_RESTART, altrimenti la chiamata fallirà con l'errore
EINTR: chiamate
* read(2), readv(2), write(2), writev(2), e ioctl(2) su dispositivi "lenti". Un
dispositivo è "lento" quando le chiamate I/O possono bloccarsi per un tempo
indeterminato, per esempio un terminale, una pipe o un socket (un disco non è un
dispositivo lento, stando a quanto dice la sua definizione). Se una chiamata I/O su
un dispositivo lento ha già trasferito alcuni dati al momento dell'interruzione da
parte del gestore di segnale, la chiamata restituirà uno stato di successo (di
solito il numero di byte trasferiti).
* open(2), se si può bloccare (per esempio nell'aprire un FIFO: vedere fifo(7)).
* wait(2), wait3(2), wait4(2), waitid(2), e waitpid(2).
* Interfacce socket: accept(2), connect(2), recv(2), recvfrom(2), recvmmsg(2),
recvmsg(2), send(2), sendto(2), e sendmsg(2), a meno che venga impostato un timeout
sul socket (vedere sotto).
* Interfacce che bloccano i file: flock(2) e fcntl(2) F_SETLKW.
* Interfacce per messaggi POSIX in coda: mq_receive(3), mq_timedreceive(3),
mq_send(3), e mq_timedsend(3).
* futex(2) FUTEX_WAIT (a partire da Linux 2.6.22; prima falliva sempre con EINTR).
* Interfacce semaforo POSIX: sem_wait(3) e sem_timedwait(3) (a partire da Linux
2.6.22; prima falliva sempre con EINTR).
Le seguenti interfacce non vengono mai riavviate dopo l'interruzione da parte di un
gestore di segnale, senza curarsi dell'uso di SA_RESTART; falliscono sempre con l'errore
EINTR quando vengono interrotte da un gestore di segnale:
* Interfacce socket in "input", quando è stato impostato un timeout (SO_RCVTIMEO) sul
socket usando setsockopt(2): accept(2), recv(2), recvfrom(2), recvmmsg(2) (anche con
un argomento imeout non NULLO) e recvmsg(2).
* Interfacce socket in "output", quando è stato impostato un timeout (SO_RCVTIMEO) sul
socket usando setsockopt(2): connect(2), send(2), sendto(2), e sendmsg(2).
* Interfacce usate per aspettare segnali: pause(2), sigsuspend(2), sigtimedwait(2), e
sigwaitinfo(2).
* Interfacce condivise per descrittori di file epoll_wait(2), epoll_pwait(2), poll(2),
ppoll(2), select(2), e pselect(2).
* Interfacce IPV System V: msgrcv(2), msgsnd(2), semop(2), e semtimedop(2).
* Interfacce sleep: clock_nanosleep(2), nanosleep(2), e usleep(3).
* read(2) da un descrittore di file inotify(7).
* io_getevents(2).
La funzione sleep(3) non viene mai riavviata anche quando viene interrotta da un gestore,
ma restituisce uno stato di successo: il numero di secondi rimanenti.
Interruzione di chiamate di sistema e funzioni di libreria da parte di segnali di stop
Su Linux, anche in assenza di gestori di segnale alcune interfacce di blocco possono
fallire con l'errore EINTR dopo che il processo è stato fermato da un segnale di stop, e
poi riavviato tramite SIGCONT. Questo comportamento non è sanzionato da POSIX.1, e non
avviene su altri sistemi.
Le interfacce Linux che si comportano in questo modo sono:
* Interfacce socket in "input", quando è stato impostato un timeout (SO_RCVTIMEO)
sul socket usando setsockopt(2): accept(2), recv(2), recvfrom(2), recvmmsg(2)
(anche con un argomento timeout non NULL), e recvmsg(2).
* Interfacce socket in "output", quando è stato impostato un timeout (SO_RCVTIMEO) sul
socket usando setsockopt(2): connect(2), send(2), sendto(2), e sendmsg(2), se è
stato impostato un timeout in invio (SO_SNDTIMEO).
* epoll_wait(2), epoll_pwait(2).
* semop(2), semtimedop(2).
* sigtimedwait(2), sigwaitinfo(2).
* read(2) da un descrittore di file inotify(7).
* Linux 2.6.21 e precedenti: futex(2) FUTEX_WAIT, sem_timedwait(3), sem_wait(3).
* Linux 2.6.8 e precedenti: msgrcv(2), msgsnd(2).
* Linux 2.4 e precedenti: nanosleep(2).
CONFORME A
POSIX.1, tranne dove indicato.
VEDERE ANCHE
kill(1), getrlimit(2), kill(2), killpg(2), restart_syscall(2), rt_sigqueueinfo(2),
setitimer(2), setrlimit(2), sgetmask(2), sigaction(2), sigaltstack(2), signal(2),
signalfd(2), sigpending(2), sigprocmask(2), sigsuspend(2), sigwaitinfo(2), abort(3),
bsd_signal(3), longjmp(3), raise(3), pthread_sigqueue(3), sigqueue(3), sigset(3),
sigsetops(3), sigvec(3), sigwait(3), strsignal(3), sysv_signal(3), core(5), proc(5),
pthreads(7), sigevent(7)
COLOPHON
Questa pagina fa parte del rilascio 3.73 del progetto Linux man-pages. Una descrizione
del progetto, le istruzioni per la segnalazione degli errori, e l'ultima versione di
questa pagina si trova su http://www.kernel.org/doc/man-pages/.
La versione italiana fa parte del pacchetto man-pages-it v. 3.73, a cura di: ILDP "Italian
Linux Documentation Project" http://www.pluto.it/ildp
Per la traduzione in italiano si può fare riferimento a
http://www.pluto.it/ildp/collaborare/
Segnalare eventuali errori di traduzione a ildp@pluto.it