Pipe: Closing file descriptors in an array of pipe - c

Question

I am learning Linux and piping that kind stuff for my system programming course right now, I am having a hard time understanding closing file descriptors in an array of pipes now.
// write the code to loop over the command line arguments (remember to skip the executable name)
for (int i = 1; i < argc; i++) {
// call pipe before we fork
if ((pipe(pipe_fd[i-1])) == -1) {
perror("pipe");
exit(1);
}
// call fork
int result = fork();
if (result < 0) { // case: a system call error
// handle the error
perror("fork");
exit(1);
} else if (result == 0) { // case: a child process
// child does their work here
// child only writes to the pipe so close reading end
if (close(pipe_fd[i-1][0]) == -1) {
perror("close reading end from inside child");
exit(1);
}
// before we forked the parent had open the reading ends to
// all previously forked children -- so close those
int child_no;
for (child_no = 0; child_no < i-1; child_no++) {
if (close(pipe_fd[child_no][0]) == -1) {
perror("close reading ends of previously forked children");
exit(1);
}
}
int len = strlen(argv[i]);
// write len to the pipe as an integer
if (write(pipe_fd[i-1][1], &len, sizeof(int)) != sizeof(int)) {
perror("write from child to pipe");
exit(1);
}
// I'm done with the pipe so close it
if (close(pipe_fd[i-1][1]) == -1) {
perror("close pipe after writing");
exit(1);
}
// exit so I don't fork my own children on next loop iteration
exit(0);
} else {
// in the parent but before doing the next loop iteration
// close the end of the pipe that I don't want open
if (close(pipe_fd[i-1][1]) == -1) {
perror("close writing end of pipe in parent");
exit(1);
}
}
}
I will give a list of what I understand right now:
I understand parent and child process need to close those fds that they don't need to use, in this case child is writing to parent, so parent needs to close writing port and child needs to close reading port.
I understand file descriptors are shared among parent process and children process.
The above code is given from my lecture slide, I feel confused by one thing specifically.
In the loop, I observe that each child is closing its reading port once this child is created by fork, and the code that does this action is:
else if (result == 0) { // case: a child process
// child does their work here
// child only writes to the pipe so close reading end
if (close(pipe_fd[i-1][0]) == -1) {
perror("close reading end from inside child");
exit(1);
}
From what I understand at this point is that, each child is going to close its own reading port after being given birth by fork, and I think the latter children created SHOULD NOT worry about closing previous children's reading port.
But my understanding seems not correct after I read this code:
// before we forked the parent had open the reading ends to
// all previously forked children -- so close those
int child_no;
for (child_no = 0; child_no < i-1; child_no++) {
if (close(pipe_fd[child_no][0]) == -1) {
perror("close reading ends of previously forked children");
exit(1);
}
}
I don't understand why the latter children should go to close previous children's reading port, aren't those reading port already be closed once those children are created?
Thanks for helping me out. :)

Answer 1

A descriptor isn't really closed until all processes that have it open close it. Since each child inherits all the pipe descriptors from the previous process, they should close all the ones they're not using.
The main reason to close reading ports is so that the writing process will get an error or signal if it tries to write to the pipe after the reader has exited. If the other children kept all the reading ports opened, this wouldn't happen until all subsequent children exit.