intéressant

# intéressant

Posté par neologix le 21 mars 2013 à 14:39. En réponse au journal wait4: attendre la fin d’un ou plusieurs processus quelconques. Évalué à 10.
Intéressant !

Quelques remarques :

Ca ne fonctionnait pas sur ma bécanne, voilà un patch :
```
--- src/wait4pid.c.orig 2013年03月21日 14:20:12.000000000 +0100
+++ src/wait4pid.c 2013年03月21日 14:33:13.129854021 +0100
@@ -43,6 +43,8 @@
 } *payload;
 char buf[NLMSG_SPACE(sizeof(struct payload_t))];
+ memset(buf, 0, sizeof(buf));
+
 hdr = (struct nlmsghdr *)buf;
 hdr->nlmsg_type = NLMSG_DONE;
 hdr->nlmsg_flags = NLM_F_REQUEST;
@@ -52,6 +54,7 @@
 payload = (struct payload_t *) NLMSG_DATA(hdr);
 payload->msg.id.idx = CN_IDX_PROC;
 payload->msg.id.val = CN_VAL_PROC;
+ payload->msg.len = sizeof(payload->op);
 payload->op = enable ? PROC_CN_MCAST_LISTEN : PROC_CN_MCAST_IGNORE;
 return send(sock, hdr, NLMSG_SPACE(sizeof(*payload)), 0);
```
Il y a un problème dans le cas où netlink n'est pas supporté et on passe le PID d'un process auquel on ne peut pas envoyer de signal: EPERM est retourné par kill(), et wait4 ne va jamais retourner.
```
static void
on_alarm(int sig)
{
 exit(EXIT_SUCCESS);
}
```
Un signal handler doit être async-signal safe, en gros réentrant.
Et exit() ne l'est pas, contrairement à _exit(), notamment puisqu'il appelle les callbacks enregistrés avec atexit().

Là tu n'as pas vraiment de risque de deadlock/crash normalement, mais écrire du code exécutant dans le contexte d'un signal handler est subtil, par exemple :
```
static void
wait4pid_close(void)
{
if ( listener_set ) {
set_proc_listen(sock, 0);
listener_set = 0;
}
```
if ( sock ) {
 close(sock);
 sock = 0;
}
```
}
```

Les variables listener_set et sock devraient être volatile (elles pourraient aussi être static).

La façon propre de faire serait d'utiliser select() sur ton socket, pour sortir lorsque le timeout est atteint.

Enfin c'est un détail.

Sinon :
ec = payload->evt.event_data.exit.exit_code / 256;

Tu peux utiliser WEXITSTATUS().

Dans set_proc_listen, tu ne retry pas sur EINTR (peu probable).

# intéressant