Den Tod eines Kindprozesses verfolgen

Wie könnte ich die Spur der Tod eines Kindes verarbeiten, ohne dass der übergeordnete Prozess warten, bis der Kind-Prozess getötet habe?

Ich versuche ein client-server-Szenario der server akzeptiert die Verbindung von einem client und Gabeln, einen neuen Prozess für jede Verbindung akzeptiert.

Ich Ignoriere SIGCHLD-Signale zu verhindern, dass zombie-Kreation.

signal(SIGCHLD, SIG_IGN);
while(1)
{
  accept();
  clients++;
  if(fork() ==0)
  {
     childfunction();
     clients--;
  }
  else
  {
  }
}

Das problem in dem oben genannten Szenario ist, dass, wenn der Kind-Prozess wird getötet in der childfunction() Funktion die Globale variable clients ist nicht immer erniedrigt.

HINWEIS: ich bin auf der Suche für eine Lösung ohne Verwendung von SIGCHLD-signal ... Wenn möglich

InformationsquelleAutor der Frage codingfreak | 2010-03-04

c client-server linux

In der Regel schreiben Sie einen handler für SIGCHLD fordert waitpid() auf pid -1. Sie können mit der return-Wert aus, um zu bestimmen, welche pid starb. Zum Beispiel:

void my_sigchld_handler(int sig)
{
    pid_t p;
    int status;

    while ((p=waitpid(-1, &status, WNOHANG)) != -1)
    {
       /* Handle the death of pid p */
    }
}

/* It's better to use sigaction() over signal().  You won't run into the
 * issue where BSD signal() acts one way and Linux or SysV acts another. */

struct sigaction sa;

memset(&sa, 0, sizeof(sa));
sa.sa_handler = my_sigchld_handler;

sigaction(SIGCHLD, &sa, NULL);

Alternativ können Sie rufen Sie waitpid(pid, &status, 0) mit dem Kind, Prozess-ID angegeben wird, und synchron zu warten, für es zu sterben. Oder verwenden Sie WNOHANG um dessen status zu überprüfen, ohne zu blockieren.

InformationsquelleAutor der Antwort asveikau

Keiner der Lösungen bisher bieten einen Ansatz ohne Verwendung von SIGCHLD wie die Frage Anfragen. Hier ist eine Implementierung eines alternativen Ansatzes mit Umfrage wie in diese Antwort (was auch erklärt, warum Sie sollten vermeiden Sie die Verwendung von SIGCHLD in Situationen wie dieser):

Stellen Sie sicher, Sie haben ein Rohr zu/von jeder Kind-Prozess Sie erstellen. Es kann entweder Ihre stdin/stdout/stderr oder einfach nur einen zusätzlichen dummy-fd an. Wenn der Kind-Prozess beendet, sein Ende der pipe wird geschlossen, und Ihre Haupt-event-Schleife, erkennt der Aktivität auf, der Datei-Deskriptor. Aus der Tatsache, dass es geschlossen ist, erkennen Sie an, dass der Kind-Prozess ist gestorben, und call waitpid um in den Genuss der zombie.

(Hinweis: ich weggelassen, einige best practices auf, wie Fehler-überprüfung und Reinigung der Datei-Deskriptoren, die für die Kürze)

/**
 * Specifies the maximum number of clients to keep track of.
 */
#define MAX_CLIENT_COUNT 1000

/**
 * Tracks clients by storing their process IDs and pipe file descriptors.
 */
struct process_table {
    pid_t clientpids[MAX_CLIENT_COUNT];
    struct pollfd clientfds[MAX_CLIENT_COUNT];
} PT;

/**
 * Initializes the process table. -1 means the entry in the table is available.
 */
void initialize_table() {
    for (int i = 0; i < MAX_CLIENT_COUNT; i++) {
        PT.clientfds[i].fd = -1;
    }
}

/**
 * Returns the index of the next available entry in the process table.
 */
int get_next_available_entry() {
    for (int i = 0; i < MAX_CLIENT_COUNT; i++) {
        if (PT.clientfds[i].fd == -1) {
            return i;
        }
    }
    return -1;
}

/**
 * Adds information about a new client to the process table.
 */
void add_process_to_table(int i, pid_t pid, int fd) {
    PT.clientpids[i] = pid;
    PT.clientfds[i].fd = fd;
}

/**
 * Removes information about a client from the process table.
 */
void remove_process_from_table(int i) {
    PT.clientfds[i].fd = -1;
}

/**
 * Cleans up any dead child processes from the process table.
 */
void reap_zombie_processes() {
    int p = poll(PT.clientfds, MAX_CLIENT_COUNT, 0);

    if (p > 0) {
        for (int i = 0; i < MAX_CLIENT_COUNT; i++) {
            /* Has the pipe closed? */
            if ((PT.clientfds[i].revents & POLLHUP) != 0) {
                //printf("[%d] done\n", PT.clientpids[i]);
                waitpid(PT.clientpids[i], NULL, 0);
                remove_process_from_table(i);
            }
        }
    }
}

/**
 * Simulates waiting for a new client to connect.
 */
void accept() {
    sleep((rand() % 4) + 1);
}

/**
 * Simulates useful work being done by the child process, then exiting.
 */
void childfunction() {
    sleep((rand() % 10) + 1);
    exit(0);
}

/**
 * Main program
 */
int main() {
    /* Initialize the process table */
    initialize_table();

    while (1) {
        accept();

        /* Create the pipe */
        int p[2];
        pipe(p);

        /* Fork off a child process. */
        pid_t cpid = fork();

        if (cpid == 0) {
            /* Child process */
            close(p[0]);
            childfunction();
        }
        else {
            /* Parent process */
            close(p[1]);
            int i = get_next_available_entry();
            add_process_to_table(i, cpid, p[0]);
            //printf("[%d] started\n", cpid);
            reap_zombie_processes();
        }
    }

    return 0;
}

Ist und hier einige Beispiel-Ausgabe nach der Ausführung des Programms mit der printf Aussagen unkommentiert:

[31066] started
[31067] started
[31068] started
[31069] started
[31066] done
[31070] started
[31067] done
[31068] done
[31071] started
[31069] done
[31072] started
[31070] done
[31073] started
[31074] started
[31072] done
[31075] started
[31071] done
[31074] done
[31081] started
[31075] done

InformationsquelleAutor der Antwort Michael Harvey

Wollen Sie nicht ein zombie. Wenn ein Kindprozess stirbt und der andere Elternteil ist, noch LÄUFT, aber nie Probleme eine wait()/waitpid() rufen zur Ernte der status, den das system keine Freigabe der Ressourcen für das Kind und eine zombie - /außer Kraft gesetzte Prozess ist Links in der proc-Tabelle.

Versuchen Sie Ihr SIGCHLD handler, etwas näher auf die folgenden:


void chld_handler(int sig) {
    pid_t p;
    int status;

    /* loop as long as there are children to process */
    while (1) {

       /* retrieve child process ID (if any) */
       p = waitpid(-1, &status, WNOHANG);

       /* check for conditions causing the loop to terminate */
       if (p == -1) {
           /* continue on interruption (EINTR) */
           if (errno == EINTR) {
               continue;
           }
           /* break on anything else (EINVAL or ECHILD according to manpage) */
           break;
       }
       else if (p == 0) {
           /* no more children to process, so break */
           break;
       }

       /* valid child process ID retrieved, process accordingly */
       ...
    }   
}

Könnten Sie Optional Maske/block zusätzliche SIGCHLD Signale während der Ausführung der Signalhandler mit sigprocmask(). Der gesperrte Maske muss wieder auf seinen ursprünglichen Wert zurück, wenn das signal-handling-routine beendet ist.

Wenn Sie wirklich nicht wollen, zu einem SIGCHLD handler, Sie könnten versuchen, hinzufügen, das Kind verarbeitungsschleife irgendwo, wo es aufgerufen werden würde, regelmäßig und Umfrage für beendet Kinder.

InformationsquelleAutor der Antwort jschmier

0

Die variable 'Kunden' sind in verschiedenen Prozess-Adresse ein Leerzeichen nach dem "fork ()" und wenn Sie verringern Sie die variable in das Kind, das keinen Einfluss auf den Wert in der übergeordneten. Ich glaube, Sie brauchen, um zu behandeln SIGCHLD zu behandeln die richtig zählen.

InformationsquelleAutor der Antwort trojanfoe

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.