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

В вашем случае родительский процесс должен закрыть конец записи канала сразу после fork. Затем он может читать свои статистические данные до EOF (конца файла), а затем закрывать читающий конец канала.

Первый проход: до того, как стало ясно, что существует цикл с использованием select() и что дети отправили несколько сообщений.

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

Альтернативный механизм использует select() или _ 3_ или связанная функция, которая сообщает, когда операция чтения файлового дескриптора не зависает. Когда он обнаруживает EOF (чтение нулевых байтов) из канала, он знает, что ребенок умер. Однако с этим, вероятно, сложнее иметь дело.

Из вашего вопроса не совсем ясно, есть ли одно сообщение от дочернего процесса при его выходе или есть статистические отчеты «поток сознания», когда ребенок работает. Если есть одно сообщение (меньше размера буфера канала), тогда жизнь проста. Если есть поток сообщений или сообщение длиннее, чем размер буфера канала, вам нужно более тщательно подумать о координации - вы не можете обнаружить сообщения только тогда, когда дочерний элемент умирает.

Второй проход: после того, как стала доступна дополнительная информация.

Если вы уже используете select() в цикле, тогда, когда дочерний элемент умирает, вы получите индикацию «канал готов к чтению» от select(), и вы получите 0 байтов от read(), что указывает на EOF на этом канале. Затем вы должны закрыть этот канал (и дождаться одного или нескольких дочерних элементов с _7 _, вероятно, используя W_NOHANG - должен быть хотя бы один труп, который нужно собрать - чтобы у вас не было зомби, слоняющихся вокруг в течение длительного времени).

Строгий ответ на ваш последний вопрос: когда умирает единственный дочерний элемент с концом записи канала, родитель должен закрыть конец чтения этого канала, чтобы освободить ресурсы для последующего повторного использования.

broken pipe происходит, когда вы пишете в канал, но ни один fd не открыт для чтения из этого канала. Так что это не относится к вашему случаю. В вашем случае, поскольку ваш родитель читает из канала, он должен читать EOF, когда дочерний процесс завершается (если вы правильно закрыли конец записи в родительском процессе, иначе он просто заблокируется, поскольку предполагает, что все еще будут вещи для чтения будущее). Затем вы можете безопасно закрыть читаемый fd в родительском процессе.

В целом

Если родитель пишет, а дочерний читает, вам нужно беспокоиться о broken pipe, когда дочерний элемент закрывает чтение fd, а родитель получает SIGPIPE, продолжая писать в канал. SIGPIPE по умолчанию завершает процесс, поэтому вы можете настроить обработчик сигнала, чтобы он делал все, что вы хотите (если вы не хотите, чтобы он просто завершался).

Давайте посмотрим на случаи по-другому для Родителя, имеющего 1 ребенка и детей.

• Родитель имеет 1 ребенка. Когда дочерний процесс завершается, а родительский процесс ожидает окончания чтения, родительский процесс также завершается. Вот код

//fd[0]     //read end
//fd[1]     //write end

#include <unistd.h>
#include <stdio.h>
#include <errno.h>              //For errno
#include <stdlib.h>              //exit()

void DumpAndExit(char* str){
    perror (str);
    printf ("errno: %d", errono);
    exit(0);  
}

int main(){
  int fd[2], pid = -1;

  if (pipe(fd) < 0)
    DumpAndExit ("pipe");

  if (pid = fork() < 0) {
    DumpAndExit ("fork");
  }
  else if (pid == 0) {                              //Child
    close(fd[0]);                                   //Close read end
    printf("In Child \n");
    sleep(2);
    exit(0);
  } else {                                         //Parent
    close(fd[1]);                                  //close write
    waitpid(-1);                                   //Parent will wait for child
    printf("Parent waiting\n");
    char buf[4] = {};
    read(fd[0], buf, sizeof(buf));                //reads from pipe
    printf ("Read from child: %s", buf);
  }
}

# ./a.out
In child 
Parent waiting
Read from child:
#

Очень простыми словами:

• У каждого процесса есть PCB (struct task_struct), на которой вся информация о процессе. В случае fork () он также будет иметь дочерние контексты. Означает указатели на детскую плату.
• Поскольку канал, т.е. int fd[2], создается в родительском стеке, а затем копируется в дочерний стек. Когда дочерний элемент выходит, его PCB очищается, PCB родительского элемента обновляется, и Parent знает, что на другом конце канала никто не подключен.