execve(2) is the system call. The other members of the exec family do some processing prior to making the system call. Usually execlp(2) or execvp(2) is used.

The child is an exact copy of the parent process except it has a different PID, PPID and its accumulated usages are zero. It has its own text, data and system data segments. This implies that a malloc( ) in the child does not affect the parent's malloc arena. The child has its own file descriptors but the descriptor refers to the same open file table entry. This is very useful for pipes. However, since read's or write's are done via the same file pointer in the open file table, the child's and parent's read's or write's on the same descriptor will be mixed or interleaved unless these processes reopen the descriptors on new files.

For stdio functions, the child and parent have separate buffers (in their separate malloc arenas) and the input or output blocks will be mixed when the buffers are flushed. Obviously, stdio buffers should be flushed before a fork( ) which would be the parent's responsibility. Otherwise, both the child and the parent will have buffers with a copy of the unflushed data, which could result in duplicate copies on the I/O device. Alternately make sure the child does no I/O before it exec's; if it fails to exec use _exit( ) not exit( ) to prevent flushing. In any case, the parent and child should make sure that active file descriptors which are not used for communication are closed or reopened on other files.

    pid_t pid;

    pid = fork();
    if (pid == -1) { 
	/* fork error - cannot create child */
	perror("Demo program");
	exit(1);
	}
    else if (pid == 0) {
        /* code for child */
	/* probably a few statements then an execvp() */ 
	_exit(1);  /* the execvp() failed - a failed child
                      should not flush parent files */
	}
    else { /* code for parent */ 
        printf("Pid of latest child is %d\n", pid);
            /* more code */
	exit(0);
        }

Usually the child will do a few things and then execvp( ). Making a copy of a process only to have it replaced shortly seemed wasteful so BSD Unix introduced a kludge, vfork( ), which makes the parent wait until the child does an exec, and in the meantime the child uses the parent's space. Most modern UNIX's have paging systems which make vfork( ) unnecessary. Pages are marked Copy-On-Write and since the child will write few or no pages before the exec, fork( ) achieves most of the savings but without the kludge.

One implementation for pipes is as a circular buffer with a read and a write pointer that cannot cross. On SYS V (but not BSD) pipes are implemented as ``streams'' so they are bidirectional, so you can read and write on each end and could interchange 0 and 1.

• close(fildes) deletes fildes and closes the underlying file if this is the last reference to the file (and if the device driver allows it).
• newfildes = dup(fildes) duplicate fildes entry at lowest available entry: newfildes.
• newfildes = fcntl(fildes, F_DUPFD,min) is like dup but newfildes is greater than or equal min.
• dup2(fildes,newfildes) closes newfildes if not equal to fildes, then duplicates fildes entry at newfildes.

To illustrate pipes we implement cat a | /usr/bin/wc making /usr/bin/wc the parent.

    if (pipe(pfildes) == -1)    {perror("demo"); exit(1);}
    if ((pid = fork()) == -1)   {perror("demo"); exit(1);}
    else if (pid == 0) {        /* child:  "cat a"                      */
          close(pfildes[0]);    /* close read end of pipe               */
          dup2(pfildes[1],1);   /* make 1 same as write-to end of pipe  */
          close(pfildes[1]);    /* close excess fildes                  */
          execlp("cat","cat","a",NULL);
          perror("demo");       /* still around?  exec failed           */
          _exit(1);             /* no flush                             */ 
        }
    else {                      /* parent:  "/usr/bin/wc"               */
          close(pfildes[1]);    /* close write end of pipe              */
          dup2(pfildes[0],0);   /* make 0 same as read-from end of pipe */
          close(pfildes[0]);    /* close excess fildes                  */
          execlp("/usr/bin/wc","wc",NULL);
          perror("demo");       /* still around?  exec failed           */
          exit(1);	        /* parent flushes                       */
        }

fileno(FILE *fp) returns the file descriptor associated to fopen'ed fp. fopen( ) creates an I/O buffer and FILE structure after calling:

    fildes = open("outfile", O_WRONLY|O_CREAT|O_APPEND, 0666);
    if (fildes == -1) { /* bad file name */ perror("demo"); exit(1);}
    dup2(fildes,1);   /* copy fildes to 1 */
    close(fildes);    /* conserve file descriptors by closing excess one */

Race: The outcome depends on who gets there first, that is, which process gets the most CPU cycles. Consider the following innocent looking code:

    ppid = getpid(); /* ppid is the parent id */
    if (fork() > 0)  /* parent */ exit(0);
    else { /* child */ 
           if (ppid == getppid()) 
                printf("parent alive");  /* if child gets CPU */
           else printf("parent dead");   /* if parent gets CPU */
         }

1. A job can be stopped, for possible later restart.
2. A job can be restarted in the background; the job runs until I/O with the terminal is required, at which point it is automatically stopped.
3. A job can be restarted in the foreground; the job runs with I/O passing freely to the terminal.

Process groups are organized into sessions (basically logins) which are capable of having controlling terminals. Session IDs are used. A process may get or become the session leader subject to restrictions by using: getsid( ), setsid( ).

Although the terminal is a (device) file and not a process, a terminal has an associated PGID. A process is allowed to read or write to the terminal only if its process group is the same as the terminal's PGID. First open a file descriptor for the terminal:

The shell maintains a table of jobs. Before every prompt for a command, the shell does a