Как правильно подсчитать фактическое количество разветвленных дочерних процессов?

Я думаю, что метод сигнала можно исправить, а создание потока заставляет вас выполнять программу для обработки соединения.

Есть несколько проблем:

• Изменения в sproc_counter могут быть потеряны, если процесс создается и завершается одновременно. Чтобы исправить это, либо используйте маски сигналов (например, sigprocmask(), pselect()), чтобы гарантировать, что обработчик не вызывается, пока основной поток манипулирует sproc_counter, либо заставьте обработчик сигналов установить флаг и выполнить waitpid(), манипулирование счетчиком и регистрацию в основном потоке. поток (но не в новом потоке). Обратите внимание, что метод флага по-прежнему требует манипулирования маской сигнала, если вы хотите избежать ожидания для нового соединения или другого завершающего соединения непосредственно после завершающего соединения.

• err_msg(), вероятно, небезопасен для асинхронного сигнала. Я вижу три варианта:

  • use the flag method mentioned above, or
  • убедитесь, что никакие небезопасные функции асинхронного сигнала не вызываются, пока SIGCHLD не замаскировано, или
  • удалить вызов из обработчика сигнала.

• Переопределение signal() может привести к тому, что другой код вызовет вашу версию вместо стандартной версии. Это может привести к странному поведению.

• Обработчик сигнала не сохраняет и не восстанавливает значение errno.

Если у вас есть проблемы из-за того, что сигналы прерывают другие сигналы, для этого предназначено поле sa_mask в sigaction.

сам отвечу.

Есть несколько причин, по которым дочерние процессы не учитываются таким образом. Во-первых, обработчик сигнала может быть прерван другим сигналом. Я не могу найти никакой информации, что на самом деле происходит, когда возникает эта ситуация. Некоторая информация об этом есть на страницах руководства libc и в этом ответе. Но это не может быть проблемой.

Кажется, что операции с переменной volatile sig_atomic_t на самом деле не атомарны и зависят от архитектуры системы. Например, на amd64 скомпилированный код уменьшения значения sproc_counter выглядит так:

movl    sproc_counter(%rip), %eax
subl    $1, %eax
movl    %eax, sproc_counter(%rip)

Как видите, инструкций на ассемблере целых три! Это точно не атомарно, поэтому доступ к sproc_counter приходится синхронизировать.

Хорошо, но почему добавление мьютекса не дало результата? Ответ находится на странице руководства pthread_mutex_lock()/pthread_mutex_unlock():

БЕЗОПАСНОСТЬ АСИНХРОНИЧЕСКОГО СИГНАЛА

Функции мьютекса не безопасны для асинхронных сигналов. Это означает, что их нельзя вызывать из обработчика сигнала. В частности, вызов pthread_mutex_lock или pthread_mutex_unlock из обработчика сигналов может привести к взаимоблокировке вызывающего потока.

Это проясняет. Что еще более важно, вызов функций, которые печатают дату (сообщение журнала), также является плохой идеей - используемый там fputs() не является безопасным для асинхронного сигнала.

Как это сделать правильно?

Имея в виду, что может произойти во время обработки сигнала (т.е. доставки других сигналов), совершенно ясно, что процедура обработки сигнала должна быть как можно более краткой. Намного лучше установить флаг в обработчике и время от времени проверяйте его в основной программе или выделенном потоке. Я выбираю второе решение.

Нет больше слов, давайте посмотрим код.

Обработка сигналов будет выглядеть так:

void sig_chld (int signo __attribute__((__unused__)))
{
  sigchld_notify = 1;
}

Процедура main():

volatile sig_atomic_t sigchld_notify = 0;                /* SIGCHLD notifier */
int sproc_counter = 0;                                   /* forked child process counter */
pthread_mutex_t sproc_mutex = PTHREAD_MUTEX_INITIALIZER; /* mutex for child process counter */

/* S/MIME Gate main function */
int main (int argc, char **argv)
{
    pthread_t guard_id;
    [...]

    /* start child process guard */
    if (0 != pthread_create(&guard_id, NULL, child_process_guard, NULL) )
        err_sys("pthread_create error");

    [...]

    /* SMTP Server's main loop */
    for (;;) {
        [...]

        /* check whether child processes limit is not exceeded */
        if (sproc_counter < MAXSUBPROC) {
            if ( (childpid = Fork()) == 0) { /* child process */
                Close(listenfd);             /* close listening socket */
                smime_gate_service(connfd);  /* process the request */
                exit(0);
            }
            pthread_mutex_lock(&sproc_mutex);
            ++sproc_counter;
            pthread_mutex_unlock(&sproc_mutex);
        }
        else
            err_msg("subprocesses limit exceeded, connection refused");

        Close(connfd); /* parent closes connected socket */
    }
} /* end of main() */

Процедура защиты потока:

extern volatile sig_atomic_t sigchld_notify; /* SIGCHLD notifier */
extern int sproc_counter;                    /* forked child process counter */
extern pthread_mutex_t sproc_mutex;          /* mutex for child process counter */

void* child_process_guard (void* arg __attribute__((__unused__)))
{
    pid_t pid;
    int stat;

    for (;;) {
        if (0 == sigchld_notify) {
            usleep(SIGCHLD_SLEEP);
            continue;
        }

        while ( (pid = waitpid(-1, &stat, WNOHANG)) > 0) {
            pthread_mutex_lock(&sproc_mutex);
            --sproc_counter;
            pthread_mutex_unlock(&sproc_mutex);
            err_msg("child %d terminated", pid);
        }
        sigchld_notify = 0;
    }
    return NULL;
}