Je n'ai pas HP-UX à ma disposition et je n'ai jamais été un grand fan de HP-UX.
Il semble que sous Linux, une limite par processus ou peut-être par utilisateur sur le nombre de processus enfants existe. Vous pouvez le voir avec le limit
Zsh intégré (semble être similaire à ulimit -u
bash):
1002 % limit
cputime unlimited
filesize unlimited
datasize unlimited
stacksize 8MB
coredumpsize 0kB
memoryuse unlimited
maxproc 16136
...
C'est sur un ordinateur portable Arch Linux.
J'ai écrit un petit programme pour tester cette limite:
#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
volatile int sigchld_cnt = 0;
voida
sigchld_hdlr(int signo)
{
++sigchld_cnt;
}
int
main(int ac, char **av)
{
int looping = 1;
int child_cnt = 0;
int status;
signal(SIGCHLD, sigchld_hdlr);
printf("Parent PID %d\n", getpid());
while (looping)
{
switch (fork())
{
case 0:
_exit(0);
break;
case -1:
fprintf(stderr, "Problem with fork(), %d children: %s\n",
child_cnt, strerror(errno));
looping = 0;
break;
default:
++child_cnt;
break;
}
}
fprintf(stderr, "Sleeping, forked %d child processes\n", child_cnt);
fprintf(stderr, "Received %d sigchild\n", sigchld_cnt);
sleep(10);
looping = 1;
do {
int x = wait(&status);
if (x != -1)
--child_cnt;
else if (errno != EINTR) {
fprintf(stderr, "wait() problem %d children left: \%s\n",
child_cnt, strerror(errno));
looping = 0;
}
} while (looping);
printf("%d children left, %d SIGCHLD\n", child_cnt, sigchld_cnt);
return 0;
}
Il était étonnamment difficile de "collecter" tous les zombies en appelant wait(2)
suffisamment de fois. De plus, le nombre de signaux SIGCHLD reçus n'est jamais le même que le nombre de processus enfants bifurqués: je crois que le noyau Linux envoie parfois 1 SIGCHLD pour un certain nombre de processus enfants sortis.
Quoi qu'il en soit, sur mon ordinateur portable Arch linux, je reçois 16088 processus enfants fourchus, et cela doit être le nombre de zombies, car le programme ne fait pas d' wait(2)
appels système dans le gestionnaire de signaux.
Sur mon serveur Slackware 12, j'obtiens 6076 processus enfants, ce qui correspond étroitement à la valeur de maxproc 6079
. Mon ID utilisateur a 2 autres processus en cours d'exécution sshd
et Zsh. Avec la première instance non zombie du programme ci-dessus qui fait 6079.
L' fork(2)
appel système échoue avec une erreur «Ressource temporairement indisponible». Je ne vois aucune autre preuve de quelle ressource n'est pas disponible. J'obtiens des nombres quelque peu différents si j'exécute mon programme simultanément dans 2 xterms différents, mais ils s'additionnent au même nombre que si je l'exécute dans un xterm. Je suppose que ce sont des entrées de table de processus, ou un échange ou une ressource à l'échelle du système, et pas seulement une limite arbitraire.
Je n'ai rien d'autre à faire pour l'essayer en ce moment.