blocco waitpid quando non dovrebbe

Question

Sto scrivendo un mini-shell (no, non per scuola: P; per il mio divertimento personale) e la maggior parte delle funzionalità di base è stata eseguita ma sono bloccato quando provo a gestire SIGTSTP.

Presumibilmente, quando un utente preme Ctrl+Z, SIGTSTP deve essere inviato al processo Foreground della shell se esiste e Shell dovrebbe continuare normalmente.

Dopo la creazione di ogni processo (se si tratta di un processo in primo piano), il seguente codice attende:

if(waitpid(pid, &processReturnStatus, WUNTRACED)>0){//wait stopped too 
    if(WIFEXITED(processReturnStatus) || WIFSIGNALED(processReturnStatus)) 
     removeFromJobList(pid); 
} 

E io sto gestendo il segnale come segue:

void sigtstpHandler(int signum) 
{ 
    signum++;//Just to remove gcc's warning 
    pid_t pid = findForegroundProcessID(); 
    if(pid > -1){ 
     kill(-pid, SIGTSTP);//Sending to the whole group 
    } 
} 

quello che succede è che quando preme Ctrl+Z, il processo figlio viene effettivamente sospeso (utilizzando ps -all per visualizzare lo stato dei processi) ma la mia shell si blocca a waitpid it neve r restituisce anche se ho passato il flag WUNTRACED che, per quanto ho capito, dovrebbe restituire waitpid anche quando il processo viene interrotto.
Quindi cosa avrei potuto fare di sbagliato? o ho capito male il comportamento di waitpid in modo errato?

Note:
-findForegroundProcessID() restituisce il pid corretto; L'ho ricontrollato.
-I sto cambiando il gruppo di ogni processo, quando subito dopo ho fork
-la gestione Ctrl+C sta lavorando bene
-Se io uso un altro terminale per inviare SIGCONT dopo i miei si blocca di shell, il processo figlio riprende il suo lavoro e il guscio si miete infine.
-Sto catturando SIGTSTP che può essere catturato per quanto ho letto (e testato). -Ho provato ad usare waitid invece di waitpid nel caso in cui il problema persistesse. EDIT:

void sigchldHandler(int signum) 
{ 
    signum++;//Just to remove the warning 
    pid_t pid; 
    while((pid = waitpid(-1, &processReturnStatus, 0)) > 0){  
     removeFromJobList(pid); 
    } 
    if(errno != ECHILD) 
     unixError("kill error"); 
} 

mio gestore di SIGCHLD.

Answer 1

SIGCHLD viene consegnato per i bambini fermati. Il waitpid() chiama nel gestore di segnale - che non specifica WUNTRACED - blocchi per sempre.

Probabilmente non si dovrebbe avere l'elaborazione removeFromJobList() in due posti diversi. Se dovessi indovinare, sembra che tocchi strutture di dati globali e non appartenga a un gestore di segnali.

Answer 2

Waitpid non viene restituito perché non si sta impostando un gestore sigchld (che ti ho inviato in precedenza). Hai processori per bambini che non vengono raccolti. Inoltre, waitpid deve essere in un ciclo while, non un if (anche te inviato).

L'unico segnale che dovresti prendere è SIGCHLD. La ragione è che se i tuoi processi sono biforcati correttamente, il kernel invierà quel segnale al processo in primo piano e lo interromperà o lo fermerà o farà qualsiasi cosa il segnale sia correttamente.

Quando i gruppi di processi non sono impostati correttamente, i segnali verranno inviati al processo sbagliato. Un modo per testare è eseguire un processo in primo piano e premere Ctrl-Z.Se esiste un'intera shell, il segnale Ctrl-Z viene inviato all'intera shell. Ciò significa che non hai impostato il nuovo processo in un nuovo gruppo di processi e gli hai dato un terminale.

Ora ecco cosa devi fare se il segnale Ctrl-Z sta arrestando l'intera shell. Una volta avviato un processo, nel processo figlio: - Imposta il processo nel proprio gruppo utilizzando setpgid. - Dagli un terminale sano bloccando SIGTTOU e assegnandogli il terminale usando tcsetpgrp.

Nel genitore: - Impostare anche il processo figlio utilizzando setpgid. Questo perché non hai idea se il bambino o il genitore verranno eseguiti per primi, quindi questo evita una condizione di competizione. Non fa male impostarlo due volte.