Using fork and exec

• The DOS and Windows API contains the spawn family of functions.These functions take as an argument the name of a program to run and create a new process instance of that program.
• Linux doesn't contain a single function that does all this in one step. Instead, Linux provides one function, fork, that makes a child process that is an exact copy of its parent process.
• Linux provides another set of functions, the exec family, that causes a particular process to cease being an instance of one program and to instead become an instance of another program.
• Under Linux, vfork is the same as fork. Under some operating systems, vfork is used when the fork will be immediately followed by an execve, to eliminate unneeded duplication of resources that will be discarded; in order to do this, the parent is suspended until the child calls execve.
• Calling fork
  • When a program calls fork, a duplicate process, called the child process, is created.
  • The parent process continues executing the program from the point that fork was called. The child process, too, executes the same program from the same place.
  • The fork function provides different return values to the parent and child processes
    • one process "goes in" to the fork call, and two processes "come out," with different return values.
    • The return value in the parent process is the process ID of the child.
    • The return value in the child process is zero.

  #include <stdio.h>
  #include <sys/types.h>
  #include <unistd.h>
  
  int main ()
  {
    pid_t child_pid;
  
    printf ("the main program process id is %d\n", (int) getpid ());
  
    child_pid = fork ();
    if (child_pid != 0) {
      printf ("this is the parent process, with id %d\n", (int) getpid ());
      printf ("the child's process id is %d\n", (int) child_pid);
    }
    else 
      printf ("this is the child process, with id %d\n", (int) getpid ());
  
    return 0;
  }
  

• Using the exec Family
  • The exec functions replace the program running in a process with another program.
  • When a program calls an exec function, that process immediately ceases executing that program and begins executing a new program from the beginning, assuming that the exec call doesn't encounter an error.
  • The library functions execl, execlp, execle, execv, and execvp are simply convenience functions that allow specifying the arguments in a different way, use the current environment instead of a new environment, and/or search the current path for the executable.
    • Functions that contain the letter p in their names (execvp and execlp) accept a program name and search for a program by that name in the current execution path; functions that don't contain the p must be given the full path of the program to be executed.
    • Functions that contain the letter v in their names (execv, execvp, and execve) accept the argument list for the new program as a NULL-terminated array of pointers to strings.
    • Functions that contain the letter l (execl, execlp, and execle) accept the argument list using the C language's varargs mechanism.
    • Functions that contain the letter e in their names (execve and execle) accept an additional argument, an array of environment variables. The argument should be a NULL-terminated array of pointers to character strings. Each character string should be of the form "VARIABLE=value".

    #include <unistd.h>
    int execve (const char *filename, char *const argv [],
    char *const envp[]);
    extern char **environ;
    int execl( const char *path, const char *arg, ..., NULL);
    int execlp( const char *file, const char *arg, ..., NULL);
    int execle( const char *path, const char *arg , ..., NULL, 
                char * const envp[]);
    int execv( const char *path, char *const argv[]);
    int execvp( const char *file, char *const argv[]);
    

  • Because exec replaces the calling program with another one, it never returns unless an error occurs.
  • Only rarely will you want to use these routines by themselves. Normally, you will want to execute a fork first to exec the program in a child process.
• Using fork and exec Together
  • Allows the calling program to continue execution in the parent process while the calling program is replaced by the subprogram in the child process.

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

/* Spawn a child process running a new program.  PROGRAM is the name
   of the program to run; the path will be searched for this program.
   ARG_LIST is a NULL-terminated list of character strings to be
   passed as the program's argument list.  Returns the process id of
   the spawned process.  */

int spawn (char* program, char** arg_list)
{
  pid_t child_pid;

  /* Duplicate this process.  */
  child_pid = fork ();
  if (child_pid != 0)
    /* This is the parent process.  */
    return child_pid;
  else {
    /* Now execute PROGRAM, searching for it in the path.  */
    execvp (program, arg_list);
    /* The execvp function returns only if an error occurs.  */
    fprintf (stderr, "an error occurred in execvp\n");
    abort ();
  }
}

int main ()
{
  /* The argument list to pass to the "ls" command.  */
  char* arg_list[] = {
    "ls",     /* argv[0], the name of the program.  */
    "-l", 
    "/",
    NULL      /* The argument list must end with a NULL.  */
  };

  /* Spawn a child process running the "ls" command.  Ignore the
     returned child process id.  */
  spawn ("ls", arg_list); 

  printf ("done with main program\n");

  return 0;
}