Communication inter-processus et pause()

Bonjour à tous,

J'ai deux processus qui communiquent ensemble. Au cours de l'execution du premier, celui se met en pause puis doit se réactiver dès qu'il recoit un signal du second processus.

Attention, il faut noter que le premier processus est executé dans un thread.

Voici mon code pour le premier processus :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

void treatSignal(int numero, siginfo_t* info, void* inutile) { printf("signal received from:%d !! \n", info -> si_pid); }   void test(void) { struct sigaction action; action.sa_sigaction = treatSignal; sigemptyset(& action.sa_mask); action.sa_flags = SA_SIGINFO; sigaction(SIGUSR1, & action, NULL); int status = pause(); printf("WAKE UP\n"); }

---

Le second processus envoi simplement un signal SIGUSR1 au premier. Le signal est bien intercepté mais la fonction pause ne rend jamais la main comme ça devrait être le cas quand un signal est intercepté et que la fonction d'interception finit son traitement.

Quelqu'un pourrait-t'il m'éclairer?

Citation:

---

Envoyé par jsebfranck

Attention, il faut noter que le premier processus est executé dans un thread.

---

non un processus ne s'execute pas dans un thread. Un process c'est un espace d'adressage, un thread c'est une entité d'execution tu en as au moins 1 par processus, le thread primaire.

est-ce que cela veut dire que tu crées thread secondaire (avec pthread_create par exemple) dans ton premier processus pour gérer le signal ? si oui cela t'es imposé ou c'est un choix que tu as fais ?

Effectivement, le traitement s'effectue dans un nouveau thread. Ceci m'est imposé pour des raisons complètement différentes.

Citation:

---

Envoyé par jsebfranck

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

void treatSignal(int numero, siginfo_t* info, void* inutile) { printf("signal received from:%d !! \n", info -> si_pid); }   void test(void) { struct sigaction action; action.sa_sigaction = treatSignal; sigemptyset(& action.sa_mask); action.sa_flags = SA_SIGINFO; sigaction(SIGUSR1, & action, NULL); int status = pause(); printf("WAKE UP\n"); }

---

---

pour le handler du signal il faut faire

Code:

---

action.sa_handler=treatSignal

---

C'est peut-être du à cela que tu ne sors pas de l'appel à pause

Ensuite pour les signaux temps réels tu peux utiliser la primitive sigwaitinfo pour un appel bloquant et sigtimedwait pur gérer un timeout (donc non bloquant) cela te permettra de récupérer les paramètres contrairement à pause()

Le signal est une valeur entière comprise entre SIGRTMIN et SIGRTMAX (voir la différence avec SIGUSR1 car on n'utilise pas ces constantes là normalement)

normalement ces fonctions sont POSIX voir si la constante _POSIX_REALTIME_SIGNALS est définie.

Si la valeur de sa_flags est à SA_SIGINFO, c'est le pointeur de fonction de sa_sigaction qui est pris en compte et non sa_handler. Le problème ne vient donc pas de là.

Je vais essayer les fonctions sigwaitinfo et sigtimedwait à la place de pause pour voir si ça peut résoudre mon problème.

J'ai mis en place le sigwaitinfo. Ca ne résoud pas mon problème mais son utilisation est effectivement beaucoup plus intéressante que la simple fonction pause. Tout est paramétrable et on peut récupérer les infos sur le signal reçu.

Code:

---

1 2 3 4 5

sigset_t sigset; siginfo_t info; sigaddset(&sigset, SIGUSR1); sigwaitinfo(&sigset, &info);

---

D'autres idées pour ce problème?

utilise

Code:

---

int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec timeout);

---

tu envois comment le signal au processus depuis une invite de commande/korn shell ou tu as également un programme ?

tu es sûr que SIGUSR1 est compris entre SIGRTMIN/SIGRTMAX ?

Pourquoi devrai-je utiliser sigtimedwait? cette fonction a le même comportement que sigwaitinfo sauf qu'elle rend la main après un temps donné, ce que je ne souhaite pas pour mon programme.

Mon signal sigusr1 est envoyé dans un autre programme à partir de la primitive kill. Je suis sur qu'il est bien réceptionné par le programme "cible" car ma fonction treatSignal est bien lancé. Pour rappel :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

void treatSignal(int numero, siginfo_t* info, void* inutile) { printf("signal received from:%d !! \n", info -> si_pid); }   void test(void) { struct sigaction action; action.sa_sigaction = treatSignal; [...] sigaction(SIGUSR1, & action, NULL); [...] }

---

J'ai fait un printf de SIGRTMIN, SIGRTMAX et SIGUSR1. J'obtiens 34, 64 et 10. SIGUSR1 n'est donc pas compris entre SIGRTMIN et SIGRTMAX. Qu'est-ce que cela veut-t'il dire?

cela veux dire que ce n'est pas un signal tant réel du coup ton flag SA_SIGINFO n'a aucun sens

soit tu définis ce flag et tu envois un signal compris dans les valeurs définis ou alors c'est un comportement indeterminé

pour envoyer un signal TR il existe d'autres primitives que kill sig_queue par exemple

Citation:

---

Si la valeur de sa_flags est à SA_SIGINFO, c'est le pointeur de fonction de sa_sigaction qui est pris en compte et non sa_handler. Le problème ne vient donc pas de là.

---

tu es sûr de ta source parce que moi justement dans ce cas c'est sa_handler

Je vais essayer les signaux temps-réels avec sig_queue.

Pour sa_siginfo, ma source est tout simplement le manpage de sigaction : ;)

"If SA_SIGINFO is specified in sa_flags, then sa_sigaction (instead of sa_handler) specifies the signal-handling function for signum."

Merci pour les infos.

Ca marche ! Voici le code pour attendre un signal SIGRTMIN :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

struct sigaction action; action.sa_sigaction = treatSignal; sigemptyset(& action.sa_mask); action.sa_flags = SA_SIGINFO; sigaction(SIGRTMIN, & action, NULL);   siginfo_t info; sigset_t sigset; sigaddset(&sigset, SIGRTMIN); sigwaitinfo(&sigset, &info);

---

et le code pour envoyé le signal :

Code:

---

1 2 3 4 5 6

union sigval sigVal; sigVal.sival_int = 0; if(sigqueue(args -> pid, SIGRTMIN, sigVal) != 0) { perror("sigqueue error"); }

---

Merci pour ton aide hegros !