Manpages - posix_spawn.3

Since glibc 2.24, the posix_spawn*() function commences by calling *clone*(2) with *CLONE_VM and CLONE_VFORK flags. Older implementations use *fork*(2), or possibly *vfork*(2) (see below).

The PID of the new child process is placed in *pid. The *posix_spawn*() function then returns control to the parent process.

Subsequently, the parent can use one of the system calls described in *wait*(2) to check the status of the child process. If the child fails in any of the housekeeping steps described below, or fails to execute the desired file, it exits with a status of 127.

Before glibc 2.24, the child process is created using *vfork*(2) instead of *fork*(2) when either of the following is true:

• the spawn-flags element of the attributes object pointed to by attrp contains the GNU-specific flag POSIX_SPAWN_USEVFORK; or
• file_actions is NULL and the spawn-flags element of the attributes object pointed to by attrp does not contain POSIX_SPAWN_SETSIGMASK, POSIX_SPAWN_SETSIGDEF, POSIX_SPAWN_SETSCHEDPARAM, POSIX_SPAWN_SETSCHEDULER, POSIX_SPAWN_SETPGROUP, or POSIX_SPAWN_RESETIDS.

In other words, *vfork*(2) is used if the caller requests it, or if there is no cleanup expected in the child before it *exec*(3)s the requested file.

In between the fork() and the exec() steps, a child process may need to perform a set of housekeeping actions. The *posix_spawn*() and *posix_spawnp*() functions support a small, well-defined set of system tasks that the child process can accomplish before it executes the executable file. These operations are controlled by the attributes object pointed to by attrp and the file actions object pointed to by file_actions. In the child, processing is done in the following sequence:

1. Process attribute actions: signal mask, signal default handlers, scheduling algorithm and parameters, process group, and effective user and group IDs are changed as specified by the attributes object pointed to by attrp.
2. File actions, as specified in the file_actions argument, are performed in the order that they were specified using calls to the *posix_spawn_file_actions_add**() functions.
3. File descriptors with the FD_CLOEXEC flag set are closed.

All process attributes in the child, other than those affected by attributes specified in the object pointed to by attrp and the file actions in the object pointed to by file_actions, will be affected as though the child was created with *fork*(2) and it executed the program with *execve*(2).

The process attributes actions are defined by the attributes object pointed to by attrp. The spawn-flags attribute (set using *posix_spawnattr_setflags*(3)) controls the general actions that occur, and other attributes in the object specify values to be used during those actions.

The effects of the flags that may be specified in spawn-flags are as follows:

POSIX_SPAWN_SETSIGMASK

Set the signal mask to the signal set specified in the spawn-sigmask attribute of the object pointed to by attrp. If the POSIX_SPAWN_SETSIGMASK flag is not set, then the child inherits the parent’s signal mask.

POSIX_SPAWN_SETSIGDEF

Reset the disposition of all signals in the set specified in the spawn-sigdefault attribute of the object pointed to by attrp to the default. For the treatment of the dispositions of signals not specified in the spawn-sigdefault attribute, or the treatment when POSIX_SPAWN_SETSIGDEF is not specified, see *execve*(2).

POSIX_SPAWN_SETSCHEDPARAM

If this flag is set, and the POSIX_SPAWN_SETSCHEDULER flag is not set, then set the scheduling parameters to the parameters specified in the spawn-schedparam attribute of the object pointed to by attrp.

POSIX_SPAWN_SETSCHEDULER

Set the scheduling policy algorithm and parameters of the child, as follows:

• The scheduling policy is set to the value specified in the spawn-schedpolicy attribute of the object pointed to by attrp.
• The scheduling parameters are set to the value specified in the spawn-schedparam attribute of the object pointed to by attrp (but see BUGS).

If the POSIX_SPAWN_SETSCHEDPARAM and POSIX_SPAWN_SETSCHEDPOLICY flags are not specified, the child inherits the corresponding scheduling attributes from the parent.

POSIX_SPAWN_RESETIDS

If this flag is set, reset the effective UID and GID to the real UID and GID of the parent process. If this flag is not set, then the child retains the effective UID and GID of the parent. In either case, if the set-user-ID and set-group-ID permission bits are enabled on the executable file, their effect will override the setting of the effective UID and GID (se *execve*(2)).

POSIX_SPAWN_SETPGROUP

Set the process group to the value specified in the spawn-pgroup attribute of the object pointed to by attrp. If the spawn-pgroup attribute has the value 0, the child’s process group ID is made the same as its process ID. If the POSIX_SPAWN_SETPGROUP flag is not set, the child inherits the parent’s process group ID.

POSIX_SPAWN_USEVFORK

Since glibc 2.24, this flag has no effect. On older implementations, setting this flag forces the fork() step to use vfork*(2) instead of *fork*(2). The *_GNU_SOURCE feature test macro must be defined to obtain the definition of this constant.

POSIX_SPAWN_SETSID (since glibc 2.26)

If this flag is set, the child process shall create a new session and become the session leader. The child process shall also become the process group leader of the new process group in the session (see setsid*(2)). The *_GNU_SOURCE feature test macro must be defined to obtain the definition of this constant.

If attrp is NULL, then the default behaviors described above for each flag apply.

The file_actions argument specifies a sequence of file operations that are performed in the child process after the general processing described above, and before it performs the exec*(3). If file_actions is NULL, then no special action is taken, and standard *exec*(3) semantics apply—file descriptors open before the exec remain open in the new process, except those for which the *FD_CLOEXEC flag has been set. File locks remain in place.

If file_actions is not NULL, then it contains an ordered set of requests to *open*(2), *close*(2), and *dup2*(2) files. These requests are added to the file_actions by *posix_spawn_file_actions_addopen*(3), *posix_spawn_file_actions_addclose*(3), and *posix_spawn_file_actions_adddup2*(3). The requested operations are performed in the order they were added to file_actions.

If any of the housekeeping actions fails (due to bogus values being passed or other reasons why signal handling, process scheduling, process group ID functions, and file descriptor operations might fail), the child process exits with exit value 127.

Once the child has successfully forked and performed all requested pre-exec steps, the child runs the requested executable.

The child process takes its environment from the envp argument, which is interpreted as if it had been passed to *execve*(2). The arguments to the created process come from the argv argument, which is processed as for *execve*(2).

  #include <spawn.h>
  #include <stdint.h>
  #include <stdio.h>
  #include <unistd.h>
  #include <stdlib.h>
  #include <string.h>
  #include <wait.h>
  #include <errno.h>

  #define errExit(msg)    do { perror(msg); \
                               exit(EXIT_FAILURE); } while (0)

  #define errExitEN(en, msg) \
                          do { errno = en; perror(msg); \
                               exit(EXIT_FAILURE); } while (0)

  char **environ;

  int
  main(int argc, char *argv[])
  {
      pid_t child_pid;
      int s, opt, status;
      sigset_t mask;
      posix_spawnattr_t attr;
      posix_spawnattr_t *attrp;
      posix_spawn_file_actions_t file_actions;
      posix_spawn_file_actions_t *file_actionsp;

      /* Parse command-line options, which can be used to specify an
         attributes object and file actions object for the child. */

      attrp = NULL;
      file_actionsp = NULL;

      while ((opt = getopt(argc, argv, "sc")) != -1) {
          switch (opt) {
          case 'c':       /* -c: close standard output in child */

              /* Create a file actions object and add a "close"
                 action to it. */

              s = posix_spawn_file_actions_init(&file_actions);
              if (s != 0)
                  errExitEN(s, "posix_spawn_file_actions_init");

              s = posix_spawn_file_actions_addclose(&file_actions,
                                                    STDOUT_FILENO);
              if (s != 0)
                  errExitEN(s, "posix_spawn_file_actions_addclose");

              file_actionsp = &file_actions;
              break;

          case 's':       /* -s: block all signals in child */

              /* Create an attributes object and add a "set signal mask"
                 action to it. */

              s = posix_spawnattr_init(&attr);
              if (s != 0)
                  errExitEN(s, "posix_spawnattr_init");
              s = posix_spawnattr_setflags(&attr, POSIX_SPAWN_SETSIGMASK);
              if (s != 0)
                  errExitEN(s, "posix_spawnattr_setflags");

              sigfillset(&mask);
              s = posix_spawnattr_setsigmask(&attr, &mask);
              if (s != 0)
                  errExitEN(s, "posix_spawnattr_setsigmask");

              attrp = &attr;
              break;
          }
      }

      /* Spawn the child. The name of the program to execute and the
         command-line arguments are taken from the command-line arguments
         of this program. The environment of the program execed in the
         child is made the same as the parent's environment. */

      s = posix_spawnp(&child_pid, argv[optind], file_actionsp, attrp,
                       &argv[optind], environ);
      if (s != 0)
          errExitEN(s, "posix_spawn");

      /* Destroy any objects that we created earlier. */

      if (attrp != NULL) {
          s = posix_spawnattr_destroy(attrp);
          if (s != 0)
              errExitEN(s, "posix_spawnattr_destroy");
      }

      if (file_actionsp != NULL) {
          s = posix_spawn_file_actions_destroy(file_actionsp);
          if (s != 0)
              errExitEN(s, "posix_spawn_file_actions_destroy");
      }

      printf("PID of child: %jd\n", (intmax_t) child_pid);

      /* Monitor status of the child until it terminates. */

      do {
          s = waitpid(child_pid, &status, WUNTRACED | WCONTINUED);
          if (s == -1)
              errExit("waitpid");

          printf("Child status: ");
          if (WIFEXITED(status)) {
              printf("exited, status=%d\n", WEXITSTATUS(status));
          } else if (WIFSIGNALED(status)) {
              printf("killed by signal %d\n", WTERMSIG(status));
          } else if (WIFSTOPPED(status)) {
              printf("stopped by signal %d\n", WSTOPSIG(status));
          } else if (WIFCONTINUED(status)) {
              printf("continued\n");
          }
      } while (!WIFEXITED(status) && !WIFSIGNALED(status));

      exit(EXIT_SUCCESS);
  }