¿Existe un límite superior para la cantidad de procesos zombies que puedes tener?

Solía ​​trabajar con un sistema HP-UX y el antiguo administrador me dijo que hay un límite superior en la cantidad de procesos zombies que puedes tener en el sistema, creo 1024.

• ¿Es este un techo de hecho difícil? Creo que podrías tener cualquier cantidad de zombis como si pudieras tener cualquier cantidad de procesos ...?
• ¿Es un valor diferente de distribución a distribución?
• ¿Qué ocurre si alcanzamos el límite superior e intentamos crear otro zombie?

No tengo HP-UX disponible para mí, y nunca he sido un gran fanático de HP-UX.

Parece que en Linux, existe un límite por proceso o quizás por usuario sobre cuántos procesos secundarios existen. Puedes verlo con el limitZsh incorporado (parece ser análogo a ulimit -ubash):

1002 % limit
cputime         unlimited
filesize        unlimited
datasize        unlimited
stacksize       8MB
coredumpsize    0kB
memoryuse       unlimited
maxproc         16136
  ...

Eso está en una computadora portátil Arch Linux.

Escribí un pequeño programa para probar ese límite:

#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;
}

Fue sorprendentemente difícil "recoger" a todos los zombies llamando wait(2)suficientes veces. Además, el número de señales SIGCHLD recibidas nunca es el mismo que el número de procesos secundarios bifurcados: creo que el kernel de Linux a veces envía 1 SIGCHLD para varios procesos secundarios salidos.

De todos modos, en mi computadora portátil Arch Linux, obtengo 16088 procesos secundarios bifurcados, y ese tiene que ser el número de zombis, ya que el programa no hace wait(2)llamadas al sistema en el controlador de señal.

En mi servidor Slackware 12, obtengo 6076 procesos secundarios, que coinciden estrechamente con el valor de maxproc 6079. Mi ID de usuario tiene otros 2 procesos en ejecución, sshdy Zsh. Junto con la primera instancia no zombie del programa anterior que hace 6079.

La fork(2)llamada al sistema falla con el error "Recurso no disponible temporalmente". No veo ninguna otra evidencia de qué recurso no está disponible. Obtengo números algo diferentes si ejecuto mi programa simultáneamente en 2 xterms diferentes, pero suman el mismo número que si lo ejecuto en un xterm. Supongo que es entradas de la tabla de proceso, o intercambio o algún recurso de todo el sistema, y ​​no solo un límite arbitrario.

No tengo nada más en ejecución para probarlo ahora mismo.

No sé cuáles son los límites de HP-UX. Sin embargo, puedo decirle que la implementación lógica es tener una tabla de proceso con un tamaño máximo. El número total de entradas de la tabla de procesos está teóricamente limitado por el rango de ID de proceso, pero la mayoría de las implementaciones tienen un límite de tamaño para la tabla que produce un máximo mucho menor. La mayoría de las variantes de Unix también tienen un límite por usuario en el número de procesos; puedes ver el límite corriendo ulimit -uen bash.

No espero que un sistema Unix tenga un límite separado para zombies, en lugar de la cantidad de ID de proceso (que incluye procesos reales y zombies). Entonces, cuando un proceso muere y se convierte en zombie, eso no afecta el límite: el recurso (la entrada en la tabla de procesos) se asigna cuando un proceso se bifurca y se libera cuando se cosecha el proceso.

Creo que podrías tener cualquier cantidad de zombis como si pudieras tener cualquier cantidad de procesos ...?

Un proceso zombie es finalmente un proceso, en un estado especial, luego los procesos zombie se limitan a la disponibilidad y el tamaño de la tabla de procesos, como en los procesos regulares .

¿Es un valor diferente de distribución a distribución?

Seguramente, como muchos otros parámetros. No debe transmitir en un tamaño específico, o si es lo suficientemente grande como para contener muchos procesos de zombies. Si tienes demasiados zombis, la solución no es una gran mesa, porque eventualmente se llenará. Un proceso zombie no es malo en sí mismo, pero tener demasiados procesos zombie acumulados es una indicación de un programa de "mal comportamiento" que permite tales procesos zombie.

¿Qué ocurre si alcanzamos el límite superior e intentamos crear otro zombie?

Una vez que la tabla de procesos está llena -de procesos regulares y zombies-, no se puede crear un nuevo proceso -regular-, incluso si el sistema tiene suficientes recursos -memoria, procesador, etc.-. El único recurso que falta es solo una entrada en la tabla de procesos. Los programas que ya se están ejecutando, incluso aquellos que se "portaron bien", comenzarán a fallar cuando requieran crear un subproceso. No se pudieron iniciar nuevos programas, e incluso ejecutar comandos individuales fallaría.