Zombie elabora

Question

I'v alcune domande su Zombie processi

• quali sono i benefici dal concetto di processo zombie?
• sanno che il kernel tiene (PID, stato di terminazione, le informazioni sull'utilizzo delle risorse) per il processo zombie
  qual è il significato di "informazioni sull'utilizzo delle risorse"
• come PPID di zombi() = 1 e ancora zombie, (init miete Zombies perché aspetta() per impostazione predefinita)
  è possibile scrivere uno qualsiasi del codice C per rendere uno zombi come genitore è Init?
• gli zombi possono rifiutarsi di rilasciare qualche blocco di memoria ??

grazie in anticipo

Answer 1

- quali sono i vantaggi del concetto di processo zombie?

Un processo di zombi è solo un pid, uno stato di uscita e alcune informazioni contabili che restano in attesa fino a quando un genitore utilizza una delle famiglie di chiamate di sistema della serie wait per ottenere lo stato finale. Fino a quando un genitore chiama lo wait, l'ID del processo del figlio deve rimanere contrassegnato come usato in modo che nessun altro processo possa essere assegnato. Se a un altro processo venisse assegnato un pid riciclato, sarebbe difficile distinguere tra esso e i processi precedenti che avevano lo stesso pid. Una volta che wait viene chiamato dal genitore e restituisce uno stato di uscita finale, si può presumere che nessuno andrà a cercare il bambino in quel pid di nuovo, quindi il pid potrebbe essere riutilizzato. (credo su Linux, se un genitore lascia SIGCHLD come SIG_IGN il kernel non mancherà di tenere gli zombie in tutto, ma che ri-registrazione disposizione di SIGCHLD come SIG_IGN non ha lo stesso effetto)

- sanno che il kernel tiene (PID , stato di terminazione, le informazioni sull'utilizzo delle risorse) per il processo zombie qual è il significato di "informazioni sull'utilizzo delle risorse"

Alcune di queste informazioni è ciò che l'esecuzione di un programma come:

time my_program 

riporterà. Questi valori vengono in genere riportati nella struttura siginfo di SIGCHLD (che non è esattamente una chiamata a wait) ma è anche disponibile da una chiamata al modulo waitid di chiamata systme (su alcuni sistemi). Guarda man sigaction per informazioni su questa struttura.

- come PPID di zombi() = 1 e ancora zombie, (init miete Zombies perché aspettare() per impostazione predefinita)

Uno zombie il cui ppid = 1 non deve rimanere uno zombie per molto tempo a causa init dovrebbe raccoglierlo abbastanza rapidamente. Un processo rimarrà uno zombi da un punto subito dopo la sua morte (tramite exit o da un segnale non gestito che lo uccide) finché il genitore non chiama lo wait e ottiene lo stato finale. Ciò significa che anche se init non fa altro che chiamare init all'infinito, potrebbe esserci una piccola quantità di tempo in cui un processo potrebbe apparire come uno zombie.Se i processi vengono visualizzati come figli di init (0 = ppid) per lunghi periodi di tempo (secondi), allora probabilmente qualcosa non va.

- qualcuno può scrivere un codice C per fare uno zombi è genitore è Init?

Questo non è chiaro, ma penso che si desidera:

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

- può zombie rifiutandosi di rilasciare un po 'di blocco sulla memoria ??

Gli zombi non possono resistere a nulla. Perdono tutte le loro pagine di memoria, aprono handle di file, ecc. Praticamente tutto il sistema operativo può capire come liberarsi dovrebbe essere liberato. Sarebbe un errore non farlo, ma ricorda che il sistema operativo deve sapere che è qualcosa che dovrebbe essere liberato. È molto facile creare risorse nello spazio utente che dovrebbero essere liberate quando un programma muore e il SO non dovrebbe essere liberato.

Answer 2

Un processo zombie è puramente un valore di stato pid e uscire. Il pid non può essere rilasciato perché la risorsa (il pid) "appartiene a" il genitore. Se fosse rilasciato, a un altro processo potrebbe essere assegnato lo stesso pid e quindi il genitore potrebbe finire per inviare segnali a un processo non correlato; anche se il genitore avesse prima aspettato per determinare se il bambino fosse uscito, non ci sarebbe stato modo di evitare le condizioni di gara.

Answer 3

Se siete interessati a vedere il processo di zombie all'interno di una lista dei processi in esecuzione utilizzare questo:

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

è possibile identificare il processo zombie dalla Z + nella lista:

NOTA: è necessario modificare il codice se si utilizza Windows.