Posteriormente a consultar con expertos en la materia, programadores de deferentes ramas y profesores hemos dado con la solución a la pregunta y la dejamos plasmada en este post.
Solución:
– ¿Cuáles son los beneficios del concepto de proceso zombie?
Un proceso zombie es solo un pid, un estado de salida y cierta información contable que permanece hasta que un padre usa uno de los wait familia de llamadas al sistema para obtener su estado final. Hasta que un padre llame wait La identificación del proceso del niño debe permanecer marcada como utilizada para que no se le pueda asignar ningún otro proceso. Si a otro proceso se le asignara un pid reciclado, sería difícil diferenciarlo de los procesos anteriores que tenían ese mismo pid. Una vez wait es llamado por el padre y devuelve un estado de salida final. Se puede suponer que nadie irá a buscar al hijo en ese pid de nuevo, por lo que el pid ahora se puede reutilizar. (Creo que en Linux si un padre deja SIGCHLD como SIG_IGN, el kernel no mantendrá a los zombis alrededor, pero volver a registrar la disposición de SIGCHLD como SIG_IGN no tiene el mismo efecto)
– saber que el kernel mantiene (PID, estado de terminación, información de uso de recursos) para el proceso zombie cuál es el significado de “información de uso de recursos”
Parte de esta información es lo que ejecuta un programa como:
time my_program
reportará. Estos valores generalmente se informan en la estructura siginfo para SIGCHLD (que no es exactamente una llamada a wait) pero también disponible desde una llamada al waitid forma de llamada al sistema (en algunos sistemas). Mirar man sigaction para obtener información sobre esta estructura.
– cómo el PPID del zombi () = 1 y sigue siendo zombi, (init cosecha a los zombis porque espera () de forma predeterminada)
Un zombi cuyo ppid = 1 no debería seguir siendo un zombi por mucho tiempo porque en eso debería cosecharlo bastante rápido. Un proceso seguirá siendo un zombi desde un punto poco después de que muera (ya sea a través de exit o por una señal sin mano que lo mata) hasta que su padre llame wait y obtiene su estado final. Esto significa que incluso si init no hace nada más que llamar a init una y otra vez, podría haber una pequeña cantidad de tiempo en la que un proceso puede aparecer como un zombi. Si los procesos aparecen como hijos de en eso (0 = ppid) durante largos períodos de tiempo (segundos), es probable que algo esté mal.
– ¿Alguien puede escribir código C para hacer un zombi cuyo padre es Init?
Esto no está claro, pero creo que quieres:
pid_t f = fork();
if (f > 0)
exit(0); // this is the parent dying, so the child will be an orphan
// and get adopted by init
else if (f == 0)
sleep(100); // This is the child doing something that takes enough time for
// its parent to commit suicide (exit(0)) and then for you to
// observe that it has now been adopted by init
exit(0); // And now it dies as well, so init should reap its status, but
// it may be a zombie for a short amount of time first.
else /* error condition would be handled here */
– ¿Pueden los zombis negarse a liberar algún bloqueo de la memoria?
Los zombis no pueden retener mucho de nada. Pierden todas sus páginas de memoria, abren manejadores de archivos, … etc. Prácticamente todo lo que el sistema operativo puede descubrir cómo liberar debería liberarse. Sería un error no hacerlo, pero recuerde que el sistema operativo tiene que saber que es algo que se supone que debe liberarse. Es muy fácil crear recursos en el espacio del usuario que deberían liberarse cuando un programa muere y el sistema operativo no sabe que se supone que deben liberarse.
Un proceso zombie es puramente un pid y un valor de estado de salida. El pid no se puede liberar porque el recurso (el pid) “pertenece” al padre. Si se liberara, a otro proceso se le podría asignar el mismo pid, y luego el padre podría terminar enviando señales a un proceso no relacionado; incluso si el padre esperaba primero para determinar si el niño había salido, no habría forma de evitar las condiciones de carrera.
Si está interesado en ver el proceso zombie dentro de una lista de procesos en ejecución, use esto:
#include
#include
#include
int main(void)
pid_t p = fork(); // creates child process and stores the returned PID
if (p != 0) // executed by parent process
sleep(1); /* the child process terminates while the parent process sleeps,
the child then becomes a zombie process because the returned status
of the terminated child process isn't checked via a wait() */
system("ps -eo pid,ppid,stat,cmd"); // prints a list of processes in your terminal
else // executed by child process
exit(0); // the child process terminates immediately
return 0;
Puede identificar el proceso zombie por Z + en la lista:
NOTA: tendrá que modificar el código si está utilizando Windows.