Signaux

Introduction

Les signaux sont liés à l’interruption du déroulement d’un programme. Une interruption consiste en l’arrêt du flot d’exécution afin de lancer le code approprié. Les signaux sont à l’origine de ces interruptions qui provoquent en général l’arrêt du programme, et souvent après l’écriture d’un fichier core sur le disque.

Un signal peut être généré de plusieurs manières. Sur les systèmes POSIX, les plus connus sont probablement SIGTERM et SIGKILL qui sont lancés afin de demander au programme de s’arrêter pour le premier, et afin de l’arrêter de force pour le second. Un autre que nous connaissons par ses effets est celui issu d’une faute de segmentation. Les signaux POSIX sont les suivants :

Tableau des signaux POSIX

Mettre en place un gestionnaire de signaux

Problème

Vous voulez gérer vous-même les signaux.

Solution

Mettez en place un gestionnaire de signaux avec sigaction().

Discussion

Un gestionnaire de signaux consiste en une structure, de type struct sigaction, et en une fonction à appeler en cas d’interruption. La structure contient un pointeur sur cette fonction, ainsi que des options et un masque de signaux empêchant l’apparition d’autres signaux pendant la gestion de l’interruption. 

La mise en place du gestionnaire de signaux passe donc par l’écriture d’une fonction comme celle-ci :

void 
signal_handler (int signal_id) 
{ 
  /* Votre code ici */ 
}
 

Puis nous créons la structure qui décrit le gestionnaire de signaux et nous appelons sigaction() avec cette structure pour gérer un signal, ici SIGINT :

  struct sigaction sa; 
  memset (&sa, 0, sizeof *sa); 
  sa.sa_handler = signal_handler; 
  sa.sa_flags = 0; 
  sigemptyset (&(sa.sa_mask)); 
  if (sigaction (SIGINT, &sa, NULL) != 0) 
    { 
      fprintf (stderr, "Problème avec sigaction()\n"); 
      exit (EXIT_FAILURE); 
    }
 

Les arguments de sigaction() sont donc l’identifiant du signal, suivi d’un pointeur sur une struct sigaction qui décrit le gestionnaire de signaux. Le dernier argument est un pointeur vers une autre struct sigaction, mais vide cette fois, qui contiendra après l’appel à sigaction() la description du précédent gestionnaire de signaux. NULL signifie que nous ne souhaitons pas connaître la valeur du précédent gestionnaire de signaux. C’est cet argument que nous exploitons dans la recette "Sauvegarder un gestionnaire de signaux et le restaurer par la suite".

La structure sigaction n’est pas la même sur tous les systèmes, mais vous pouvez la trouver définie ainsi, tant que tous les champs ci-dessous sont disponibles :

struct sigaction 
{ 
  void (*sa_handler) (int); 
  void (*sa_sigaction) (int, siginfo_t *, void *); 
  sigset_t sa_mask; 
  int sa_flags; 
  void (*sa_restorer) (void); 
}
 

C’est donc dans le champ sa_handler que nous précisons la fonction qui sera appelée lors de l’interruption. Vous pouvez également...

Bloquer des signaux

Problème

Vous souhaitez bloquer des signaux pour les traiter plus tard.

Solution

Créez un masque de signaux avec sigemptyset(), sigfillset(), sigaddset() et sigdelset(), puis appelez sigprocmask().

Discussion

La création d’un masque de signaux commence par l’initialisation de ce masque avec sigemptyset() ou sigfillset() suivant que nous voulons partir d’un jeu de signaux vide ou plein. Puis pour chaque signal que nous voulons respectivement ajouter ou supprimer du masque, nous appelons sigaddset() ou sigdelset(). Voici quelques exemples :

sigset_t masque; 
 
/* Création d'un masque ne contenant que les signaux INT et TERM */ 
sigemptyset (&masque); 
setaddset (&masque, SIGINT); 
setaddset (&masque, SIGTERM); 
 
/* Création d'un masque contenant tous les signaux sauf FPE et BUS */ 
sigfillset (&masque); 
setdelset (&masque, SIGFPE); 
setdelset (&masque, SIGBUS);
 

Lorsque le masque de signaux est créé, nous appelons sigprocmask() avec en premier argument une des constantes suivantes : SIG_SETMASK pour remplacer l’ancien masque ; SIG_BLOCK pour ajouter les signaux du masque à ceux déjà bloqués (le résultat est l’union du masque en place et de celui que nous venons de créer) ; SIG_UNBLOCK pour supprimer les signaux du masque de ceux déjà...

sigset_t vide, masque_actuel; 
sigemptyset (&vide); 
sigprocmask (SIG_BLOCK, &vide, &masque_actuel);
 

#include <signal.h> 
int sigprocmask (int how, const sigset_t *set, sigset_t *oset); 
int sigismember (const sigset_t *set, int signo);
 

sigset_t masque_test; 
sigpending (&masque_test); 
if (1 == sigismember (&masque_test, SIGTERM)) 
  printf ("Le signal TERM est bloqué\n");
 

#include <signal.h> 
int sigpending (sigset_t *set); 
int sigismember (const sigset_t *set, int signo);
 

struct sigaction sa; 
memset (&sa, 0, sizeof *sa); 
sa.sa_sigaction = SIG_IGN; 
sa.sa_flags = 0; 
sigemptyset (&(sa.sa_mask)); 
if (sigaction (SIGINT, &sa, NULL) != 0) 
  { 
    fprintf (stderr, "Erreur sur sigaction"); 
  }
 

Envoyer un signal

Problème

Vous voulez envoyer un signal à un processus.

Solution

Utilisez kill().

Discussion

L’utilisation de kill() est simple : le premier argument est l’identifiant du processus auquel envoyer le signal et le second argument est le signal. Cependant, cela ne fonctionnera que pour un processus appartenant à l’utilisateur qui exécute kill(), à moins d’avoir les privilèges administrateur.

Il est intéressant de savoir que killpg() permet d’envoyer un signal (second argument) à tous les processus du même groupe que celui spécifié en premier argument. Notons que kill() et killpg() sont équivalents si leur premier argument est zéro : le signal est envoyé à tous les processus du même groupe que celui qui envoie le signal. De plus, kill(-1, signal) envoie le signal à tous les processus sauf quelques processus vitaux, à condition qu’il ait les permissions appropriées.

La fonction kill() a par ailleurs la capacité de tester qu’un processus est présent en fonction de son identifiant. Pour cela, donnez la valeur zéro en guise de signal. Aucun signal n’est alors envoyé, mais en cas d’absence...

struct sigaction ancien, nouveau; 
 
/* initialisation du nouveau masque */ 
sigaction (signal, &nouveau, &ancien); 
/* instructions */ 
sigaction (signal, &ancien, NULL);
 

Limiter le temps d’exécution d’une partie d’un programme

Problème

Vous voulez limiter le temps d’exécution d’une partie de programme pour reprendre la main si le processus est trop long.

Solution

Mettez en place un gestionnaire de signaux pour le signal ALRM, puis faites appel à alarm().

Discussion

La mise en place du gestionnaire de signaux s’effectue comme expliqué dans la première recette.

struct sigaction sa; 
memset (&sa, 0, sizeof *sa); 
sa.sa_sigaction = alarm_handler; 
sa.sa_flags = 0; 
sigemptyset (&(sa.sa_mask)); 
if (sigaction (SIGALRM, &sa, NULL) != 0) 
  { 
    fprintf (stderr, "Erreur sur sigaction"); 
  }
 

Lorsque vous souhaitez lancer une opération que vous voulez limiter dans le temps, appelez alarm() avant, pour indiquer le temps maximum autorisé en secondes, et alarm() avec un argument nul pour désactiver l’envoi du signal. Voici un exemple qui limite à 2 minutes le temps d’exécution d’une opération :

alarm (120); 
operation (); 
alarm (0);
 

Le plus délicat dans la limitation du temps d’exécution d’une partie d’un programme est lorsque l’interruption survient. En effet, en fonction de la nature de l’opération, la main ne sera pas rendue au programme de la même manière. Lorsqu’il...