The «sh» being launched with execl() becomes a zombie

Question

I am spent whole half a day, but still couldn't figure, why is the dash being launched with execl call just becomes a zombie.

Below is a minimal test case — I'm just fork a child, make a duplicate of std [in,out,err] descriptors, and launch the sh.

#include <cstdio>
#include <fcntl.h>
#include <cstring>
#include <stdlib.h>
#include <cerrno>
#include <unistd.h>

int main() {
    int pipefd[2];
    enum {
        STDOUT_TERM = 0,
        STDIN_TERM  = 1
    };
    if (pipe(pipefd) == -1) { //make a pipe
        perror("pipe");
        return 0;
    }
    pid_t pid = fork();
    if (pid == 0)
    {// Child
        dup2(pipefd[STDIN_TERM], STDIN_FILENO);
        dup2(pipefd[STDOUT_TERM], STDOUT_FILENO);
        dup2(pipefd[STDOUT_TERM], STDERR_FILENO);
        execl("/bin/sh","sh", (char*)NULL);
        // Nothing below this line should be executed by child process. If so, print err
        perror("For creating a shell process");
        exit(1);
    }
    __asm("int3");
    puts("Child launched");
}

When I launch it in a debugger, and at the line with breakpoint (above the puts() call) look at the pid variable, and then look at the according process with ps, I every time getting something like

2794 pts/10   00:00:00 sh <defunct>

I.e. its a zombie

Answer 1

You're leaving a zombie, trivially, because you didn't wait on your child process.

Your shell is immediately exiting because you've set up its STDIN in a nonsensical way. pipe returns a one-way communications channel. You write to pipefd[1] and read it back from pipefd[0]. You did a buch of dup2 calls which lead the shell to attempt to read (STDIN) from the write end of the pipe.

Once you swap the numbers in your enum, you get the shell sitting forever on read. That's probably not what you want either, but it's about all you can expect when you've got a shell piped to itself.

Presuming you're attempting to use the shell from your parent process, you need to call pipe twice (and both in the parent): one of the pipes you write to (and the shell reads from, on stdin) and the other the shell writes to (stdout/stderr) and you read from. Or if you want, use socketpair instead.

Answer 2

You need to catch the SIGCHLD signal, and "reap" the zombie process with a wait() system call. Nearly minimal addition of code to your program to add a signal handler function, and set it as the SIGCHLD handler looks like this:

#include <cstdio>
#include <fcntl.h>
#include <cstring>
#include <stdlib.h>
#include <cerrno>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>

void sighandler(int signal_number);

void sighandler(int signo) {
    if (signo == SIGCHLD) {
            int status;
            (void)wait(&status);
    }
}


int main() {
    int pipefd[2];
    enum {
        STDOUT_TERM = 0,
        STDIN_TERM  = 1
    };
    signal(SIGCHLD, sighandler);
    pid_t pid = fork();

You should almost certainly check the return status of the signal() system call, and look into dealing with the child's exit status (the value of status in the signal handler code.