Programmation systeme en C et les signaux

**souviron34** · 05/02/2007, 17h34

Montre-nous un peu comment tu affiches ton "J'ai reçu SIGKILL".

Facile....

Je ne mettrais ni le code complet (2 modules de 20 000 lignes), ni la création/ouverture des sockets, juste ce qu'il faut...

Tu fais une routine :

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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
 
 
/*
*  Parametres : 
*       <requete>        : numero du descripteur de fichier 
*       <fonction>       : fonction appelee lors de la reception du signal systeme
*
*
*   Retour : 0 si tout va bien
*            < 0 il y a eu erreur
*            > 0 : il y a deja des caracteres a lire sur le socket.  Dans ce
*	          cas, on retourne le nobre de caracteres disponibles sans 
*		  passer en mode asynchrone.
*/
 
int InitialiserSocketAsynchrone(int requete,void (*fonction)()  )
{
   pid_t pid;
   int retour;
   int bidon;
 
 
   /*
    *On passe en asynchrone
    *Obtenir le numero de ce processus pour pouvoir le refiler
    *a ioctl afin d'etre avise de tout changement sur le socket
    */
 
   pid =getpid();
 
   bidon = (int) pid;
#ifndef LINUX
   retour = ioctl(requete,SIOCSPGRP,&bidon);
#else
   retour = fcntl(requete,F_SETOWN,(long)bidon);
#endif
   if ( retour < 0 )
     return retour ;
 
   /*
    *Initialiser l'option asynchrone pour le socket
    */
 
#ifndef LINUX
   bidon = 1;
   retour = ioctl(requete,FIOASYNC,&bidon);
#else
   bidon = O_ASYNC ;
   retour = fcntl(requete,F_SETFL,(long)bidon);
#endif
 
   if ( retour < 0 )
       return retour ;
   else
     {
       signal(SIGIO,fonction);
       return (0);
     }
}

Dans une bibliothèque c'est mieux :-)

Et ensuite, ET dans le client ET dans le serveur tu mets :

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
33
34
35
36
37
38
39
40
41
42
 
 
{
.....
int iret, canal_in ;
 
....
 
/* A l'endroit ou on va écouter le socket et attendre les évènements */
 
     iret = InitialiserSocketAsynchrone( Canal_in, &Received_New_Request );
.......
 
}
 
 
/*
 * R e c e i v e d _ N e w _ R e q u e s t
 *
 */
static void  Received_New_Request ( int sig )
{
   /* Si dans serveur */
      fprintf (stderr, "\n\nInterrupt %d received from client",sig);
 
    /* Si dans client */
      fprintf (stderr, "\n\nInterrupt %d received from server",sig);
 
 
/*
--- Go get the number of the server concerned by this signal
*/
   /* --- If interrupt provoked by temination of either ends, exits ---*/
   if ( (sig == SIGKILL) || (sig == SIGTERM) || (sig == SIGQUIT)  || 
        (sig == SIGPIPE) || (sig == SIGSTOP) || (NumServer == -9999) )
     {
       if ( DEBUG )
	 fprintf(stderr,"ONE TERMINATION SIGNAL WAS RECEIVED \n");
 
       End_Of_Session(2);
     }
}

Fait un kill sur l'un ou l'autre (kill -9) et regarde le numéro de signal reçu par l'autre....

**Médinoc** · 05/02/2007, 17h52

Le signal intercepté n'est donc pas SIGKILL, mais SIGIO.

Il est possible qu'il soit ENSUITE traduit en un autre signal par un mécanisme sous-jacent, mais le vrai signal reste SIGIO.

**souviron34** · 05/02/2007, 18h29

je ne comprend pas ce que tu veux dire..

Tu fais kill -9 sur l'un et tu obtiens sig=9 sur l'autre.....

et ioctl et sockets utilisent tout deux les défnitions de signal.....

**Médinoc** · 05/02/2007, 21h15

signal() est sur SIGIO.

C'est le mécanisme sous-jacent à ioctl() qui traduit le SIGIO en un autre signal entre le moment où le signal est reçu par le process et celui où le handler est appelé.
La traduction peut être "le signal qui a fait finir le process" ou bien "SIGKILL si le process a été tué, autre chose dans d'autre cas", ou que sais-je.
Toujours est-il que ton process qui surveille ne reçoit pas véritablement un SIGKILL, mais un SIGIO traduit par la suite.

N'oublie pas, les faits sont là : signal() intercepte SIGIO, et le vrai SIGKILL n'est pas interceptable de toute façon.

**souviron34** · 06/02/2007, 01h34

Toujours est-il que ton process qui surveille ne reçoit pas véritablement un SIGKILL, mais un SIGIO traduit par la suite.

Explique-moi alors comment il se fait que dans tous les autres cas de communications (sauf bien sûr ctrl-c et SIGHUP) celui qui restera vivant reçoit toujours SIGIO (code 22 sur mon linux, mais 29 sur d'autres Unix, ou une autre valeur > 20 en général), et reçoit systématiquement 9 (SIGKILL) quand tu tues l'autre , quel que soit le système ?
(dans la routine Received_New_Request ci-dessus, donc DIRECTEMENT la routine appelée par signal)

Si le sigkill n'est interceptable par AUCUN process, c'est donc que même ioctl ne peut l'intercepter... Et donc comment, si on suit ton raisonnement, pourrait-t-il le transformer (puisqu'alors il détecterait SIGIO et par quel miracle en déduirait-il SIGKILL...) ?

Il n'est pas interceptable par le processus AUQUEL c'est destiné ça d'accord...

Dans l'exemple présenté ci-dessus :

les 2 (client et serveur) partagent le même socket. L'un est tué et ne peut rien faire , mais l'autre reçoit SIGKILL... Donnes-moi une explication convaincante

**Médinoc** · 06/02/2007, 07h21

Les ioctl ne font partie d'aucun process, mais du kernel.

À mon avis, elles surveillent le process lui-même, et quand le process surveillé tombe, elles envoient (et non détectent) un SIGIO au process surveillant, interceptent le signal handler et lui passent la valeur traduite...

Donc, ce n'est pas le process surveillant qui reçoit SIGKILL, mais seulement le handler dans le process.

**zooro** · 06/02/2007, 09h16

Envoyé par souviron34

Donnes-moi une explication convaincante

Quand un processus reçoit un SIGKILL, il meurt immédiatement. A priori, il n'y a pas d'exception.
Donc, le processus survivant ne PEUT PAS avoir reçu le signal SIGKILL (sinon, il n'aurait pas survécu). Il a reçu un autre signal (SIGIO), et ta fonction a obtenu l'INFORMATION que le processus lié est mort suite à la réception d'un signal SIGKILL.

**souviron34** · 06/02/2007, 10h32

Entièrement d'accord avec toi, Médinoc, mais cela signifie en clair que pour un programmeur moyen (qui ne s'intéresse pas au kernel) IL EST POSSIBLE d'imprimer "Reçu SIGKILL" ........ ce qui était le début de notre aparté...

Le mécanisme par lequel ça se fait est ce qu'il est, mais le résultat net est que l'on peut (et doit dans un certains nombre de cas, dont les architectures client-serveur) tenir compte du SIGKILL......

CQFD...

Programmation systeme en C et les signaux

Réseau C

Discussions similaires

Partager

Partager