Discussion :

[damien77]

Bonjour,

J'aimerais apprendre à gérer les signaux mais je ne trouve aucun bon tutotial ( si possible en français ). Sur internet je suis tombé sur le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
/* signal example */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
 
char tmpfilename [L_tmpnam];
 
void terminate (int param)
{
  printf ("Terminating program...\n");
  remove (tmpfilename);
  exit(1);
}
 
int main ()
{
  void (*prev_fn)(int);
 
  prev_fn = signal (SIGTERM,terminate);
  if (prev_fn==SIG_IGN) signal (SIGTERM,SIG_IGN);
 
  tmpnam (tmpfilename);
 
  /* code here */
 
  return 0;
}

Si j'ai bien compris. Nous créer une fonction terminate.
Nous envoyons un signal qui contient la fonction.
Nous regardons si la fonction a été prise en compte...

Pouvez-vous m'aider ?
Merci de votre aide.

[Arnaud F.]

Salut,

voici un exemple simple d'utilisation de signaux.
Tu lances le chronomètre, l'alarm étant d'une seconde, le signal SIGALRM est lancé toute les secondes, on l'intercepte donc (signal numéro 14) et lance la fonction seconde à chaque fois que le signal est intercepté.
Si on tape CTRL+C, on lance le signal SIGINT (numéro 2) et lance la fonction qui permet d'afficher le nombre de secondes écoulées.
Pour quitter le chronomètre, il faut envoyer le SIGQUIT qui peut être émis grâce à la combinaison CTRL+\

C'est un petit programme simple mais qui explique bien le fonctionnement global des signaux.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
 
static int nb_sec= 0;
 
void seconde() {
    printf("coucou\n");
    nb_sec += 1;
    alarm(1); // On relance l'alarme
}
 
void interrupt() {
    printf("%d secondes écoulées\n", nb_sec);
}
 
void arret() {
    printf("%d secondes écoulées\n", nb_sec);
    printf("Fin du chronomètre\n");
    exit(1);
}
 
int main() {
    printf("Début du processus n°%d\n", getpid());
    alarm(1);
    signal(14, seconde); // Signal quand ALARM est écoulé
    signal(2, interrupt); // Signal CTRL+C , affiche le nombre de secondes
    signal(3, arret); // Signal CTRL+\ , affiche le nombre de secondes écoulées et quitte
 
    while(1); // Permet l'émission de l'ALARM
}

[Sve@r]

Sur internet je suis tombé sur le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
/* signal example */
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
 
char tmpfilename [L_tmpnam];
 
void terminate (int param)
{
  printf ("Terminating program...\n");
  remove (tmpfilename);
  exit(1);
}
 
int main ()
{
  void (*prev_fn)(int);
 
  prev_fn = signal (SIGTERM,terminate);
  if (prev_fn==SIG_IGN) signal (SIGTERM,SIG_IGN);
 
  tmpnam (tmpfilename);
 
  /* code here */
 
  return 0;
}

Si j'ai bien compris. Nous créer une fonction terminate.
Nous envoyons un signal qui contient la fonction.
Nous regardons si la fonction a été prise en compte...

Non

Tu prépares ton programme à recevoir le signal "SIGTERM". A ce signal tu associes l'appel de la fonction "terminate()" qui doit être impérativement de type "void fct(int)". Donc à ce niveau, la fonction n'est pas appelée. C'est juste que dans l'espace processus de ton programme, il y a quelque part un truc qui dit "SIGTERM => terminate"

Maintenant ton programme s'exécutera normalement. Mais si, à un moment donné, il reçoit un signal "SIGTERM" il ira alors exécuter terminate() puis il reviendra là où il en était. C'est tout. Sauf que je ne vois pas trop à quoi sert le "if (prev_fn==SIG_IGN) signal (SIGTERM,SIG_IGN);"...

[damien77]

Merci d'avance.


Sinon quand je veux compiler le code, il ne trouve pas le code de alarm.

[Arnaud F.]

Merci d'avance.

Je vais lire ton tutos. Il est pour linux mais est-il valable windows ?
Sinon quand je veux compiler le code, il ne trouve pas le code de alarm.

Pour linux, c'est sûr, pour Windows, je n'ai jamais essayé

As-tu bien inclus unistd.h ?

[damien77]

J'ai fait un copier coller de ton code.

[Sve@r]

Salut,

voici un exemple simple d'utilisation de signaux.
Tu lances le chronomètre, l'alarm étant d'une seconde, le signal SIGALRM est lancé toute les secondes, on l'intercepte donc (signal numéro 14) et lance la fonction seconde à chaque fois que le signal est intercepté.
Si on tape CTRL+C, on lance le signal SIGINT (numéro 2) et lance la fonction qui permet d'afficher le nombre de secondes écoulées.
Pour quitter le chronomètre, il faut envoyer le SIGQUIT qui peut être émis grâce à la combinaison CTRL+\

C'est un petit programme simple mais qui explique bien le fonctionnement global des signaux.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include <signal.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
 
static int nb_sec= 0;
 
void seconde() {
    printf("coucou\n");
    nb_sec += 1;
    alarm(1); // On relance l'alarme
}
 
void interrupt() {
    printf("%d secondes écoulées\n", nb_sec);
}
 
void arret() {
    printf("%d secondes écoulées\n", nb_sec);
    printf("Fin du chronomètre\n");
    exit(1);
}
 
int main() {
    printf("Début du processus n°%d\n", getpid());
    alarm(1);
    signal(14, seconde); // Signal quand ALARM est écoulé
    signal(2, interrupt); // Signal CTRL+C , affiche le nombre de secondes
    signal(3, arret); // Signal CTRL+\ , affiche le nombre de secondes écoulées et quitte
 
    while(1); // Permet l'émission de l'ALARM
}

Mis à part que tes fonctions arret() et interrupt() n'ont pas la signature prévue, ça marche en POSIX mais ça ne marchera pas en SYSTEM V car l'appel d'une fonction désactive son déroutement pour la suite => pour ça qu'il faut, si on veut conserver un mouvement perpétuel, réarmer le signal dans la fonction elle-même

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
void seconde(int sig) {
    // La fonction se réarme elle-même
    signal(sig, seconde);
    printf("coucou\n");
    nb_sec += 1;
    alarm(1); // On relance l'alarme
}
 
void interrupt(int sig) {
    // La fonction se réarme elle-même
    signal(sig, interrupt);
    printf("%d secondes écoulées\n", nb_sec);
}

Par ailleurs je pense qu'il vaut mieux éventuellement préparer le déroutement avant de lancer l'alarm()...

Je vais lire ton tutos. Il est pour linux mais est-il valable windows ?

Certainement pas !!! La gestion des processus zindow est radicalement différente de celle d'Unix !!! Même si les fonctions signal() et kill() fonctionnent sous zindow (ce dont je ne suis pas sûr), ce ne sera qu'une émulation du comportement d'Unix donc t'es même pas certain que tout fonctionne correctement...

[corrector]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <stdio.h>
 
static int nb_sec= 0;
 
void seconde() {
    printf("coucou\n");
    nb_sec += 1;
    alarm(1); // On relance l'alarme
}
 
void interrupt() {
    printf("%d secondes écoulées\n", nb_sec);
}
 
void arret() {
    printf("%d secondes écoulées\n", nb_sec);
    printf("Fin du chronomètre\n");
    exit(1);
}
 
int main() {
    printf("Début du processus n°%d\n", getpid());
    alarm(1);
    signal(14, seconde); // Signal quand ALARM est écoulé
    signal(2, interrupt); // Signal CTRL+C , affiche le nombre de secondes
    signal(3, arret); // Signal CTRL+\ , affiche le nombre de secondes écoulées et quitte
 
    while(1); // Permet l'émission de l'ALARM
}

Je suis assez étonné d'apprendre que printf, et les fonctions de <stdio.h> en général, sont async-signal safe (utilisables dans les gestionnaires de signaux).

Je suis aussi surpris que les valeurs numériques des numéros de signaux soient normalisées, ou portables d'un Un*x à l'autre, ou que de les écrire explicitement soit considéré comme un bon style de programmation.

Par ailleurs, j'apprends que l'on peut manipuler des variables statiques non-volatiles dans les gestionnaires de signaux.

[Sve@r]

Je suis assez étonné d'apprendre que printf, et les fonctions de <stdio.h> en général, sont async-signal safe (utilisables dans les gestionnaires de signaux).

Le printf() vide son buffer au '\n' donc en l'occurrence, immédiatement

Je suis aussi surpris que les valeurs numériques des numéros de signaux soient normalisées, ou portables d'un Un*x à l'autre, ou que de les écrire explicitement soit considéré comme un bon style de programmation.

C'est vrai qu'il aurait mieux valu utiliser les constantes SIG_TERM et SIG_ALRM mais on va mettre ça sur le coup du "petit programme illustratif vite fait" et donc qui ne présume en rien de la façon de coder de son auteur dans le cas de programmes plus "officiels"...

Par ailleurs, j'apprends que l'on peut manipuler des variables statiques non-volatiles dans les gestionnaires de signaux.

Une variable statique est de nature non-volatile. Pourquoi ne pourrait-on pas l'utiliser dans les fonctions de déroutement ???
Et comment pourrait-on demander à ces fonctions de traiter des valeurs perso sans passer par des statiques (tout en sachant qu'on ne peut pas non plus leur passer ces valeurs en paramètres) ???

[diogene]

Sve@r :

Une variable statique est de nature non-volatile. Pourquoi ne pourrait-on pas l'utiliser dans les fonctions de déroutement ???

Je ne vois pas comment une variable volatile pourrait être autre chose que statique. Une variable automatique est difficilement accessible de façon non prévisible puisque la plupart du temps elle n'existe pas.
Dans le cas présent, nb_sec est volatile, on ne peut pas déterminer dans le code si et quand elle sera modifiée et il faut l'exclure de toute optimisation.

[corrector]

Le printf() vide son buffer au '\n' donc en l'occurrence, immédiatement

Ce qui ne change rien au fait qu'on ne peut absolument pas l'appeler dans un signal, pour la raison évidente qu'elle va manipuler STDOUT, ce qui n'a absolument aucun rapport avec le mode de buffering.

Et depuis quand on peut s'inventer des excuses pour appeler des fonctions non async-signal safe depuis un gestionnaire de signal?

C'est vrai qu'il aurait mieux valu utiliser les constantes SIG_TERM et SIG_ALRM mais on va mettre ça sur le coup du "petit programme illustratif vite fait" et donc qui ne présume en rien de la façon de coder de son auteur dans le cas de programmes plus "officiels"...

Déjà, je ne vois pas comment ça peut être plus rapide de chercher les numéros dans signal.h que de donner les constantes symboliques. Surtout, les programmes qu'on donne comme exemples ici doivent illustratifs de quoi? Des choses à ne surtout jamais faire? Des mauvaises habitudes à ne pas prendre? Des plus grossières erreurs de programmation qu'on est capable faire?

Et je ne vois pas pourquoi quelqu'un ferait dans un forum le contraire de ce qu'il est capable de faire de façon "officielle". Sauf si forum veut dire poster n'importe quoi avec des exemples de code écrit en dépit du bon sens.

Une variable statique est de nature non-volatile.

Qu'est-ce que c'est que cette nouveauté? C'est sur ça que tu base ton code "officiel" aussi? Dans ton code "officiel", tu fais appelle à stdio dans les gestionnaires de signaux aussi? Si oui, il faudrait prévenir ton employeur/tes clients.

Pourquoi ne pourrait-on pas l'utiliser dans les fonctions de déroutement ???

Comment tu sais quand je compilateur a réellement effectué une affectation à ta variable si elle n'est pas volatile, et qu'elle est lue de façon invisible pour le compilateur?

[corrector]

Sve@r : Je ne vois pas comment une variable volatile pourrait être autre chose que statique. Une variable automatique est difficilement accessible de façon non prévisible puisque la plupart du temps elle n'existe pas.

N'importe quelle variable peut être volatile. Je ne vois vraiment pas le problème.

Et bien sûr, qu'une variable soit volatile ou pas il ne faut tenter d'y accéder quand elle n'existe plus - ça ne change rien.

La qualification volatile et la durée de vie sont deux paramètres "orthogonaux".

[Sve@r]

Sve@r : Je ne vois pas comment une variable volatile pourrait être autre chose que statique. Une variable automatique est difficilement accessible de façon non prévisible puisque la plupart du temps elle n'existe pas.
Dans le cas présent, nb_sec est volatile, on ne peut pas déterminer dans le code si et quand elle sera modifiée et il faut l'exclure de toute optimisation.

nb_sec est globale donc elle est connue de toute fonction et sa durée de vie est celle du programme. Et elle est static donc elle n'est visible que du source dans lequel elle est définie mais ce dernier point est secondaire. Et donc je ne vois pas ce qui l'empêche d'être utilisée dans une fonction lancée à la réception d'un signal. Evidemment qu'on ne sait pas quand elle sera modifiée puisqu'on ne peut pas prévoir si le programme recevra ou ne recevra pas ledit signal (enfin là on peut voir qu'elle sera modifiée à chaque seconde mais je parle dans un cas plus général). Mais cette variable ici n'a qu'un rôle de compteur et sa valeur n'est pas primordiale au bon fonctionnement du code "utile"...