Un evento, in pratica, e' un fatto accaduto all'interno del sistema. Puo' essere generato dalle periferiche (interrupt, operazioni di I/O), da processi (fra cui quelli di sistema), ecc.
Gli avvenimenti indicati con un evento possono essere vari, completamento di un'operazione i I/O, richiesta di chiusura di un processo, scadenza di periodi di tempo (allarme), ecc.

La generazione di un evento asincrono (cioe' che puo' arrivare in qualsiasi momento) puo' avvenire tramite un segnale rivolto ad un processo.
Quindi, con un segnale, viene indicato il verificarsi di un evento asincrono, oppure la necessita' di compiere una determinata azione associata al segnale stesso. Vengono considerati eventi asincroni perche', il processo destinatario del segnale, lo puo' ricevere solo quando riprende la propria esecuzione (passaggio dello stato di esecuzione da modo kernel a modo utente).

Un segnale puo' essere inviato da un processo ad un altro processo, dal kernel ad un processo oppure da un processo a se' stesso (funzione "alarm"). In ogni caso, l'invio del segnale passa per il kernel. Infatti, il processo non riceve subito il segnale. Se il processo si trova in modalita' utente (esecuzione), il kernel lo "passa" subito. Se, invece, il processo si trova in modo kernel (in attesa di essere scelto per l'esecuzione da pare dello scheduler dei processi), gli  viene "passato" al momento della riattivazione da parte dello scheduler.

Vediamo adesso come si puo' inviare e catturare un segnale.
L'header C contenente le funzioni relative alla gestione dei segnali e' "/usr/include/signal.h".
Il segnale voluto puo' essere mandato con le funzioni "alarm" e "kill" ("kill" non invia necessariamente un segnale di "uccisione"), mentre puo' essere catturato per mezzo della funzione "signal".

Alarm

Come gia' accennato, la funzione "alarm" si usa per far inviare un segnale al processo che la invoca. Piu' precisamente, "alarm" permette l'invio del segnale "SIGALRM" dopo un certo tempo t (specificato come parametro).
Un esempio:

#include <signal.h>
...
unsigned t; //tempo che deve passare
...
//A partire da questo momento, il processo
//ricevera' un segnale di allarme dopo t secondi.
alarm(t);
...

Kill

"Kill" si occupa di inviare un segnale ad un processo di cui si conosca il PID (Process IDentification number), o ad un gruppo di processi con lo stesso PGID (Progress Group IDentification number).
Abbiamo visto che e' comunque il kernel che, alla fine, invia il segnale al processo. Il kernel, per identificare un processo, puo' usare sia il PID che il PGID.
Per la gestione del PID e del PGID, esistono diverse funzioni come "getpgid", "setpgid", ecc. in "/usr/include/unistd.h" (per informazioni "man getpgid", ecc.).

Tenendo conto che un segnale e' identificato da un numero, i parametri accettati da "kill" sono due: il PID del processo che deve ricevere il segnale ed il numero del segnale stesso, entrambi interi.
Un esempio:

#include <signal.h>
...
int errore=0;
...
//invia il segnale e riporta l'eventuale errore.
errore=kill(40,SIGSEGV);
...

Il valore del PID passato alla funzione "alarm" puo' essere anche diverso da un numero positivo: PID=0 significa che il segnale viene inviato a tutti i processi con PGID uguale a quello del mittente; PID=-1 significa che il segnale e' inviato a tutti i processi (eccetto quelli numero "0=init" e "1=scheduler") in ordine decrescente di PID (i PID vengono letti dalla tabella dei processi); PID<-1 significa che il segnale viene inviato a tutti i processi con PGID uguale al valore assoluto del PID (es. PID=-100, PGID=100).

Signal

Con la funzione "signal" e' possibile catturare i segnali che arrivano ad un processo.
Il meccanismo di utilizzo di questa funzione, prevede la conoscenza del numero di segnale e la creazione di una funzione che lo gestisca.
Un esempio:

#include <signal.h>
...
void gestoreKill()
{
  //eseguita quando viene ricevuto un kill
  ...
}
...
int main()
{
  //Inizializza l'azione assegnata al segnale SIGKILL
  signal(SIGKILL, gestoreKill);
  ...
}

#include <signal.h>
...
void gestoreKill()
{
  //eseguita quando viene ricevuto un kill
  signal(SIGKILL, gestoreKill);
  ...
}
...
int main()
{
  //Inizializza l'azione assegnata al segnale SIGKILL
  signal(SIGKILL, gestoreKill);
  ...
}

I segnali in arrivo possono essere anche ignorati. Per ignorare un segnale si puo' usare

signal(segnale,SIG_IGN);

signal(segnale,SIG_DFL);

Il segnale "SIGKILL" non puo' essere ignorato.

La seguente tabella contiene un elenco dei segnali usabili (tratta dal file "/usr/include/bits/signum.h").