Prepare(): a new API proposal for process creation

UNIX famously uses fork+exec to create processes, a simple API that is nevertheless quite tricky to use correctly and that comes with a bunch of problems. The alternative, spawn, as used by VMS, Windows NT and recently POSIX, fixes many of these issues but it overly complex and makes it hard to add new features.

prepare() is a proposed API to simplify process creation. When calling prepare(), the current thread enters “preparation state.” That means, a nascent process is created and the current thread is moved to the context of this process, but without changing memory maps (this is similar to how vfork() works). Inside the nascent process, you can configure the environment as desired and then call prep_execve() to execute a new program. On success, prep_execve() leaves preparation state, moving the current thread back to the parent's process context and returns (!) the pid of the now grownup child. You can also use prep_exit() to abort the child without executing a new process, it similarly returns the pid of the now zombified child.

Here's an example for executing a child with stdout redirected to /dev/null:

int stfu(char prog, char argv[]) { if (prepare(NULL) == -1) return (-1);

    int fd = open("/dev/null", O_WRONLY);
    if (fd == -1) {
        return (prep_exit(1));
    }

    dup2(fd, 1);
    close(fd);

    int pid = prep_execve(prog, argv, environ);
    if (pid == -1) {
        return (prep_exit(1));
    }

    return (pid);

}

The key advantage of this API is that it has completely linear control flow like spawn, while preserving the flexible builder-pattern provided by fork+exec. No double-return shenanigans like with fork and execve. And because the nascent process shares memory with the parent, it's possible to communicate failure to execute and similar stuff using simple variables.