Zombie traite

Question

I'v quelques questions sur les processus zombie

• ce que les avantages de la conception de processus zombie?
• savent que le noyau conserve (PID, état de cessation d'emploi, informations sur l'utilisation des ressources) pour le processus de zombie
  quel est le sens de "l'information sur l'utilisation des ressources"
• comment PPID de zombie() = 1 et encore zombie, (init moissonne Zombies parce qu'il attend() par défaut)
  quelqu'un peut-il écrire du code C pour faire un zombie c'est parent est Init?
• peut zombies refusant de libérer un verrou sur la mémoire ??

grâce à l'avance

Answer 1

- quels sont les avantages du concept de processus zombie? Un processus zombie est juste un pid, un statut de sortie et certaines informations de comptabilité qui restent jusqu'à ce qu'un parent utilise l'un des wait famille d'appels système pour obtenir son statut final. Jusqu'à ce qu'un parent appelle wait, l'ID de processus de l'enfant doit rester marqué comme étant utilisé afin qu'aucun autre processus ne puisse lui être affecté. Si un autre processus devait recevoir un pid recyclé, il serait difficile de faire la différence entre ce processus et les processus antérieurs qui avaient le même pid. Une fois que wait est appelée par le parent et retourne un statut de sortie final, on peut supposer que personne ne cherchera à nouveau l'enfant à ce pid, donc le pid peut maintenant être réutilisé. (je pense que sur Linux si laisse parent SIGCHLD comme SIG_IGN le noyau ne gardera pas des zombies autour, mais réinscrire la disposition de SIGCHLD comme SIG_IGN n'a pas le même effet)

- savent que le noyau conserve (PID , l'état de cessation d'emploi, informations sur l'utilisation des ressources) pour le processus de zombie, quel est le sens de « l'information sur l'utilisation des ressources »

Certaines de ces informations est ce que l'exécution d'un programme:

time my_program 

fera rapport. Ces valeurs sont généralement reportées dans la structure siginfo pour SIGCHLD (qui n'est pas exactement un appel à wait) mais aussi disponible à partir d'un appel à la forme waitid de systme call (sur certains systèmes). Regardez man sigaction pour plus d'informations sur cette structure.

- comment PPID() de zombie = 1 et encore zombie, (init moissonne zombies parce qu'il attend() par défaut)

Un zombie dont ppid = 1 ne devrait pas rester un zombie très longtemps parce que init devrait le récolter assez rapidement. Un processus restera un zombie à partir d'un point peu après sa mort (soit via exit ou par un signal non manié qui le tue) jusqu'à ce que son parent appelle wait et obtient son statut final. Cela signifie que même si init ne fait rien d'autre qu'appeler init encore et encore, il peut y avoir une petite quantité de temps où un processus peut apparaître comme un zombie.Si les processus apparaissent comme enfants de init (0 = ppid) pendant de longues périodes (secondes) alors quelque chose est probablement faux.

- quelqu'un peut-il écrire du code C pour créer un zombie dont le parent est Init?

Ce n'est pas clair, mais je pense que vous voulez:

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 */ 

- peut zombies refuser de libérer une serrure sur la mémoire ??

Les zombies ne peuvent pas s'accrocher à quoi que ce soit. Ils perdent toutes leurs pages de mémoire, ouvrir les poignées de fichiers, ... etc. À peu près tout ce que le système d'exploitation peut comprendre comment libérer devrait être libéré. Ce serait un bogue de ne pas le faire, mais souvenez-vous que le système d'exploitation doit savoir que c'est quelque chose qui est censé être libéré. Il est très facile de créer des ressources dans l'espace utilisateur qui devraient être libérées lorsqu'un programme meurt et que le système d'exploitation ne sait pas qu'il doit être libéré.

Answer 2

Procédé zombie est purement une valeur d'état et de sortie pid. Le pid ne peut pas être libéré car la ressource (le pid) "appartient" au parent. Si elle était libérée, un autre processus pourrait recevoir le même pid, et le parent pourrait finir par envoyer des signaux à un processus sans rapport; Même si le parent a d'abord attendu pour déterminer si l'enfant avait quitté, il n'y aurait aucun moyen d'éviter les conditions de course.

Answer 3

Si vous êtes intéressé à voir le processus de zombie dans une liste des processus en cours d'exécution utilisent ceci:

#include <stdio.h> 
#include <unistd.h> 
#include <sys/types.h> 

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

Vous pouvez identifier le processus zombie par le Z + dans la liste:

REMARQUE: vous devrez modifier le code si vous utilisez Windows.