Procesos zombie

Tengo algunas preguntas sobre procesos zombie.

  • ¿Cuáles son los beneficios del concepto de proceso zombie?
  • 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”
  • cómo el PPID de zombie () = 1 y todavía es zombi, (init cosecha Zombies porque espera () por defecto)
    ¿Puede alguien escribir algo de código C para hacer que un zombi sea su padre es Init?
  • ¿Pueden los zombies negarse a liberar algún locking en la memoria?

gracias por adelantado

– ¿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 se mantiene hasta que un padre usa una de las llamadas de wait familia del sistema para obtener su estado final. Hasta que un padre llame, 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 distinguir la diferencia entre él y los procesos anteriores que tenían ese mismo pid. Una vez wait el padre llama a la wait y devuelve un estado de salida final, se puede suponer que nadie volverá a buscar al niño en ese pid de nuevo, por lo que ahora se puede reutilizar el pid. (Creo que en Linux, si un padre deja SIGCHLD como SIG_IGN, el kernel no mantendrá a los zombies alrededor, pero eso vuelve a registrar la disposición de SIGCHLD ya que 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 progtwig 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 están disponibles desde una llamada a la forma en espera de la llamada systme (en algunos sistemas). Mira la man sigaction para obtener información sobre esta estructura.

– cómo zombie PPID () = 1 y sigue siendo zombie, (init cosecha Zombies porque espera () por defecto)

Un zombie cuyo ppid = 1 no debería ser un zombie por mucho tiempo porque init debería obtenerlo rápidamente. Un proceso seguirá siendo un zombie desde un punto poco después de su muerte (ya sea a través de la exit o por una señal no administrada que lo mata) hasta que su padre llame, wait y obtenga su estado final. Esto significa que incluso si init no hace nada más que llamar a init una y otra vez, puede haber una pequeña cantidad de tiempo en el que un proceso puede aparecer como un zombie. Si los procesos aparecen como hijos de init (0 = ppid) durante largos períodos de tiempo (segundos), es probable que algo esté mal.

– ¿Puede alguien escribir algo de código C para hacer que un zombi sea su 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 dyes 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 zombies negarse a liberar algún locking de memoria?

Los zombis no pueden aferrarse a mucho de nada. Pierden todas sus páginas de memoria, abre los manejadores de archivos, etc. Prácticamente todo lo que el sistema operativo puede descubrir cómo liberar debe ser liberado. 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 de usuario que deberían liberarse cuando un progtwig muere y el sistema operativo que no sabe se supone que debe liberarse.

Un proceso zombie es puramente un valor de estado pid y exit. El pid no se puede liberar porque el recurso (el pid) “pertenece a” el padre. Si se lanzara, 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 esperó por primera vez para determinar si el niño había salido, no habría manera de evitar las condiciones de la raza.

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

Puedes identificar el proceso zombie por el Z + en la lista:

Captura de pantalla del proceso zombie.

NOTA: tendrá que modificar el código si está usando Windows.

Los procesos Zombie son procesos que han dejado de ejecutarse, pero su entrada de la tabla de procesos todavía existe porque el proceso principal no lo ha recuperado a través del syscall de espera. Técnicamente, cada proceso que termina es un zombie por un período de tiempo muy corto, pero podrían vivir por más tiempo.

Los procesos de zombie más longevos ocurren cuando los procesos principales no llaman a la llamada de espera después de que el proceso secundario haya finalizado. Una situación en la que esto ocurre es cuando el proceso principal está mal escrito y simplemente omite la llamada en espera o cuando el proceso primario muere antes de que el hijo y el nuevo proceso principal no llame a esperar. Cuando el padre de un proceso muere antes que el hijo, el sistema operativo asigna el proceso hijo al proceso “init” o PID 1. es decir, el proceso init “adopta” el proceso hijo y se convierte en su padre. Esto significa que ahora, cuando el proceso secundario sale del nuevo padre (init), debe llamar a wait para obtener su código de salida o su entrada de la tabla de proceso permanece para siempre y se convierte en un zombie