Provided by: manpages-it_2.80-3_all bug

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 e di terminare il processo.

       Ign    L'azione di default e di ignorare il segnale.

       Core   L'azione di default e di terminare il processo e  fare  un  dump
              core (vedere core(5)).

       Stop   L'azione di default e di arrestare il processo.

       Cont   L'azione  di  default  e  di  continuare  il  processo se esso e
              attualmente fermo.

       Un  processo  puo  cambiare  la  disposizione  di  un  segnale   usando
       sigaction(2)  o  (meno portabile) signal(2).  Usando queste chiamate di
       sistema, un processo puo 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  e automaticamente invocata quando il
       segnale e recapitato.

       La  disposizione  del  segnale  e  un  attributo   per   processo:   in
       un'applicazione   multithreaded,  la  disposizione  di  un  particolare
       segnale e la stessa per tutti i thread.

   Maschera segnale e segnali pendenti
       Un segnale puo essere  bloccato,  che  significa  che  esso  non  verra
       recapitato  fino  a  quando  non  verra  sbloccato.   Un  segnale viene
       definito pendente nel periodo di tempo che passa  tra  quando  e  stato
       generato e quando e 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   puo   manipolare   la   sua   maschera   segnale   usando
       pthread_sigmask(3).  In un'applicazione tradizionale a thread  singolo,
       sigprocmask(2) puo essere usato per manipolare la maschera segnale.

       Un  segnale puo essere generato (e quindi pendente) per un processo nel
       suo insieme (per esempio quando e 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  e  diretta  al thread, come lo sono i segnali
       indirizzati a uno specifico thread usando pthread_kill(3)).  Un segnale
       diretto  al  processo  puo essere recapitato a uno qualunque dei thread
       che attualmente non hanno il segnale  bloccato.   Se  piu  di  uno  dei
       thread  ha  il  segnale  sbloccato,  allora il kernel sceglie un thread
       arbitrario a cui recapitare il segnale.

       Un thread puo ottenere l'insieme di segnali che attualmente ha pendenze
       usando  sigpending(2).   Questo  insieme consistera 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 e normalmente valido
       per alpha e sparc, quello in mezzo per i386, ppc e sh, e  l'ultimo  per
       mips.   A  -  denota  che  un  segnale  e  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 e stata
                                     agganciata o il processo che ha il controllo e 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 e di
       terminare il processo senza  eseguire  un  core  dump.)   Linux  2.4  e
       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 (diventera SIGSYS)

       (Il segnale 29 e SIGINFO / SIGPWR su alpha ma SIGLOST su sparc.)

       SIGEMT non e specificato in  POSIX.1-2001,  tuttavia  appare  in  molti
       altri  sistemi  Unix,  dove  la sua azione predefinita e tipicamente di
       terminare il processo con un core dump.

       SIGPWR (non specificato in POSIX.1-2001) e tipicamente ignorato in  via
       predefinita in questi altri Unix dove appare.

       SIGIO  (non  specificato in POSIX.1-2001) e 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  e  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 puo avvenire al run-time  in  accordo  con  kernel  e
       glibc  disponibili),  e poiche 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)  perche SIGRTMIN+n non ecceda
       SIGRTMAX.

       Diversamente dai segnali predefiniti, i  segnali  real-time  non  hanno
       significati  predefiniti:  l'intero  insieme  dei segnali real-time puo
       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 e 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 e bloccato, allora viene  accodata
           solo un'istanza.

       2.  Se   il   segnale  e  inviato  usando  sigqueue(2),  un  valore  di
           accompagnamento (che sia un  intero  o  un  puntatore)  puo  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  puo 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 piu basso.  (Cioe i segnali con
           i numeri bassi hanno la priorita 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  da  priorita  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  puo essere visto e
       cambiato (con privilegi) attraverso il file  /proc/sys/kernel/rtsig-max
       .   Un  file correlato, /proc/sys/kernel/rtsig-nr, puo 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,  poiche  qualunque  processo  puo
       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  e
       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 e 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 puo 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    puo    fare    riferimento    a
       http://www.pluto.it/ildp/collaborare/