Provided by:
manpages-it_2.80-3_all 
NOME
signal - elenco dei segnali disponibili
DESCRIZIONE
Linux supporta sia i segnali POSIX affidabili (d’ora in avanti "segnali
predefiniti") 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 specificano la
disposizione predefinita del segnale, come segue:
Term L’azione di default è di terminare il processo.
Ign L’azione di default è di ignorare il segnale.
Core L’azione di default è di terminare il processo e fare un dump
core (vedere core(5)).
Stop L’azione di default è di arrestare il processo.
Cont L’azione di default è di continuare il processo se esso è
attualmente fermo.
Un processo può cambiare la disposizione di un segnale usando
sigaction(2) o (meno portabile) signal(2). Usando queste chiamate di
sistema, un processo può assumere uno dei seguenti comportamenti al
recapito del segnale: eseguire l’azione predefinita; ignorare il
segnale; o intercettare il segnale con un signal handler, una funzione
definita dal programmatore che è automaticamente invocata quando il
segnale è recapitato.
La disposizione del segnale è un attributo per processo: in
un’applicazione multithreaded, la disposizione di un particolare
segnale è la stessa per tutti i thread.
Maschera segnale e segnali pendenti
Un segnale può essere bloccato, che significa che esso 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,
sigprocmask(2) può essere usato per manipolare la maschera segnale.
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 è diretta 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 pendenze
usando sigpending(2). Questo insieme consisterà nell’unione del set
dei segnali diretti ai processi pendenti e il set di segnali pendenti
per il thread chiamante.
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 i386, ppc e sh, e l’ultimo per
mips. 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 di 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 da tty
SIGTTIN 21,21,26 Stop Input da tty per un processo in background
SIGTTOU 22,22,27 Stop Output da tty per un processo in background
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 erroneo alla memoria)
SIGPOLL Term Evento suscettibile di polling (Sys V). Sinonimo di SIGIO
SIGPROF 27,27,29 Term Timer del profiler scaduto
SIGSYS 12,-,12 Core Argomento sbagliato alla routine (SVr4)
SIGTRAP 5 Core Trappola per trace/breakpoint
SIGURG 16,23,21 Ign Condizione urgente sul socket (4.2 BSD)
SIGVTALRM 26,26,28 Term Allarme virtuale (4.2 BSD)
SIGXCPU 24,24,30 Core Ecceduto tempo limite di CPU (4.2 BSD)
SIGXFSZ 25,25,31 Core Limite dimensione file superato (4.2 BSD)
Fino a Linux 2.2 incluso, il comportamento predefinito per SIGSYS,
SIGXCPU, SIGXFSZ, e (su architetture diverse da SPARC e MIPS) SIGBUS
era di terminare il processo (senza eseguire un core dump). (In alcuni
altri sistemi Unix l’azione di default per SIGXCPU e SIGXFSZ è di
terminare il processo senza eseguire un core dump.) Linux 2.4 è
conforme ai requisiti di POSIX 1003.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
SIGWINCH 28,28,20 Ign Dimensioni finestra cambiate (4.3 BSD, Sun)
SIGUNUSED -,31,- Term Segnale inutilizzato (diventerà 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.
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 .
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 sistemare 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 riferirsi ai
segnali real-time usando numeri prefissati. Dovrebbero invece sempre
fare riferimento ai segnali real-time usando la notazione SIGRTMIN+n, e
includendo controlli adatti (run-time) perché SIGRTMIN+n non ecceda
SIGRTMAX.
Diversamente dai segnali predefiniti, i segnali real-time non hanno
significati predefiniti: l’intero insieme dei segnali real-time può
essere usato per scopi definiti dall’applicazione. (Si noti, tuttavia,
che l’implementazione LinuxThreads usa i primi tre segnali real-time).
L’azione predefinita per i segnali real-time non gestiti è di terminare
il processo ricevente.
I segnali real-time sono distinti dal seguente:
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(2), 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
differenti 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).
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 i
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 routine di manipolazione dei segnali stabilita da sigaction(2) o
signal(2) 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-2003 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()
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()
CONFORME A
POSIX.1
BUG
SIGIO e SIGLOST hanno lo stesso valore. L’ultimo è commentato nel
sorgente del kernel, ma il processo di costruzione di alcuni software
pensa ancora che il segnale 29 sia SIGLOST.
VEDERE ANCHE
kill(1), kill(2), killpg(2), setitimer(2), setrlimit(2), sgetmask(2),
sigaction(2), signal(2), signalfd(2), sigpending(2), sigprocmask(2),
sigqueue(2), sigsuspend(2), sigwaitinfo(2), bsd_signal(3), raise(3),
sigvec(3), sigset(3), strsignal(3), sysv_signal(3), core(5), proc(5),
pthreads(7)
COLOPHON
Questa pagina fa parte del rilascio 2.78 del progetto man-pages di
Linux. Si può trovare una descrizione del progetto, e informazioni su
come riportare bachi, presso http://www.kernel.org/doc/man-pages/. Per
la traduzione in italiano si può fare riferimento a
http://www.pluto.it/ildp/collaborare/