l'exécution du gestionnaire de signal par défaut

J'ai écrit une application où j'ai enregistré le numéro de gestionnaire de signal pour les signaux différents dans linux .
Après le processus reçoit le signal de contrôle est transféré au gestionnaire de signal que j'avais enregistré. Dans ce gestionnaire de signal je fais le travail que je dois faire, et puis je voudrais appeler le signal par défaut virage je.e SIF_DFL ou SIG_IGN .
Cependant, SIG_DFL et SIG_ING sont les deux macros qui l'étendre à des valeurs numériques 0 et 1, respectivement, qui sont fonction non valide adresses.

EST-il possible que je peux appeler des actions par défaut je.e SIG_DFL ou SIG_IGN ?

Afin de réaliser l'effet de SIG_DFL ou SIG_ING j'appelle exit(1) et de ne rien faire , respectivement . Mais pour les signaux comme SIGSEGV je voudrais aussi avoir un core dump .
En général, je voudrais à mon comportement par défaut de même que la SIG_DFL et d'ignorer le comportement même SIG_IGN , la façon dont le système d'Exploitation serait de le faire .

source d'informationauteur app

c handlers linux signals

13

La Bibliothèque C de GNU Manuel de Référence a tout un chapitre expliquant tout sur le traitement du signal.

Vous obtenez toujours définie au préalable gestionnaire de signal (un pointeur de fonction) lorsque vous installez votre propre gestionnaire (voir les pages de manuel de signal() ou sigaction()).
```
previous_handler = signal(SIGINT, myhandler);
```
La règle générale est que vous pouvez toujours rétablir le précédent gestionnaire et raise() nouveau le signal.
```
void myhandler(int sig) {
  /* own stuff .. */
  signal(sig, previous_handler);
  raise(sig);
  /* when it returns here .. set our signal handler again */
  signal(sig, myhandler);
}
```
Il y en a un inconvénient de la règle générale: Matériel d'exceptions qui sont mappés à des signaux sont généralement attribués à une certaine instruction qui a provoqué l'exception. Donc, quand vous élevez un signal de nouveau, l'instruction n'est pas la même qu'à l'origine. Cela peut mais ne doit pas nuire à d'autres gestionnaires de signaux.

Un autre inconvénient est, que chaque soulevées signal provoque beaucoup de temps de traitement. Pour éviter une utilisation excessive de la raise() vous pouvez utiliser les alternatives suivantes:
1. En cas de SIG_DFL le pointeur de fonction des points à l'adresse 0 (ce qui n'est évidemment pas d'adresse valide). Ainsi, vous ont pour réinitialiser le gestionnaire et raise() nouveau le signal.
```
if (previous_handler == SIG_DFL)
{
  signal(sig, SIG_DFL);
  raise(sig);
  signal(sig, myhandler);
} 
```
2. SIG_IGN a de la valeur 1 (également une adresse non valide). Ici, vous pouvez simplement retourner (ne rien faire).
```
else if (previous_handler == SIG_IGN)
{
  return;
} 
```
3. Autrement (ni SIG_IGN ni SIG_DFL) que vous avez reçu valide d'un pointeur de fonction et vous peut l'appel du gestionnaire directement,
```
else
{
  previous_handler(sig);
}
```
Bien sûr, vous avez à prendre en compte les différentes Api (voir les pages de manuel de signal() et sigaction()).
9

Vous pouvez enregistrer le précédent gestionnaire, puis de l'appeler quand le moment est venu.

Installer gestionnaire. Assurez-vous d'enregistrer ancien gestionnaire
```
static struct sigaction new_sa, old_sa;

new_sa.handler = my_handler;
sigemptyset(&new_handler.sa_mask);

if (sigaction(signo, &new_sa, &old_sa) == -1) {
    /* handle sigaction error */
}
```
Dans votre nouveau gestionnaire, appelez l'ancien gestionnaire de
```
(*old_sa.sa_handler)(signo)
```
Vous n'avez pas besoin de soulever de nouveau ou de faire toute résidus encombrants; il suffit d'appeler le vieux maître (bien sûr, puisque vous avez enregistré le sigaction vous avez accès à la vieille de la disposition et ainsi de suite).

L'approche habituelle est de réinitialiser le gestionnaire de signal, puis raise() nouveau le signal:

Voici un exemple SIGINT gestionnaire:

void sigint_handler(int num)
{
    /* handle SIGINT */

    //call default handler
    signal(SIGINT, SIG_DFL);
    raise(SIGINT);
}

2

Donné le signal de gestionnaires sont implémentés dans le noyau, le seul moyen que je vois est à
- réinitialiser le gestionnaire et
- raise() nouveau le signal

Vous devez vous connecter pour publier un commentaire.