Is brother-brother pipe safer than father-child? - c

Question

In the case of establishing a pipe between two processes, if those two have a brother to brother relationship rather than a father-child, will they be more error prone ?
My question for this arose when I investigated the code example below:
#include <stdlib.h>
#include <stdio.h>
#include <sys/wait.h>
void runpipe();
int
main(int argc, char **argv)
{
int pid, status;
int fd[2];
pipe(fd);
switch (pid = fork())
{
case 0: /* child */
runpipe(fd);
exit(0);
default: /* parent */
while ((pid = wait(&status)) != -1) {
fprintf(stderr, "process %d exits with %d\n", pid, WEXITSTATUS(status));
exit(0);
}
case -1:
perror("fork");
exit(1);
}
exit(0);
}
char *cmd1[] = { "ls", "-al", "/", 0 };
char *cmd2[] = { "tr", "a-z", "A-Z", 0 };
void
runpipe(int pfd[])
{
int pid;
switch (pid = fork())
{
case 0: /* child */
dup2(pfd[0], 0);
close(pfd[1]); /* the child does not need this end of the pipe */
execvp(cmd2[0], cmd2);
perror(cmd2[0]);
default: /* parent */
dup2(pfd[1], 1);
close(pfd[0]); /* the parent does not need this end of the pipe */
execvp(cmd1[0], cmd1);
perror(cmd1[0]);
case -1:
perror("fork");
exit(1);
}
}
In the example above, parent(grandpa) forks a child(parent), which then forks another child(grandchild). Grandpa waits for dad but dad does not wait for grandson because they both execute execvp. What happens if child finishes earlier than dad (zombie) or dad finishes earlier than child (orphan) ? On the other hand if we had two brothers connected with the pipe and one father and waiting for them (total three processes), even if they both brothers executed execvp, ones exit would not harm the other.

Answer 1

In the case of establishing a pipe between two processes, if those two have a brother to brother relationship rather than a father-child, will they be more error prone ?
As far as the pipe is concerned, everything depends on the I/O operations that each performs. If the process at the read end tries to read data that the process at the other end is not prepared to write, then it will block until the writer writes or exits. In the latter case, the read will either report an error or return short data.
What happens if child finishes earlier than dad (zombie) or dad finishes earlier than child (orphan) ?
If the father calls an exec() function after forking a child and before collecting it via wait() or waitpid(), as in the example code, then it is unlikely ever to wait on the child.
Regardless, child and dad each become zombies when they terminate. This is true of the child whether or not it is orphaned first. If dad never collects child (as it won't in your example), then once dad terminates, the child (whether live or zombie) is inherited by process 0 (init), which can be relied upon to clean up all its zombie children. Similarly, if grandpa never collects dad then init eventually will do.
Under certain circumstances it is possible for zombies to build up uncollected. This is a form of resource leak, but it will ultimately be cleaned up when the zombies are inherited by init. That is slightly exacerbated by the grandpa -> parent -> child topology you've set up, but I wouldn't characterize it as "error prone."

Answer 2

What happens if child finishes earlier than dad (zombie)...
It will be a zombie process. Once the parent finishes without waiting on the child, the child will be re-parented to init. init will then wait on the child, retrieving its exit code and allowing it to finally exit.
...or dad finishes earlier than child (orphan) ?
Orphaned processes are re-parented to init. The process will then be the same as above.