COMP309/509 - Parallel and Distributed Computing

Lecture 3 - Process Control

By Mitchell Welch

University of New England

Reading

• Chapter 3, Finish Chapter 8 and start chapter 15 from Advanced Programming in the UNIX environment
• Assignment 1 Description

Summary

• Final points on fork()
• Process Termination
• Process Control Using wait()
• Executing New Programs with exec()
• Files and File Descriptors

Final points on fork()

• There is one variation on the fork() - vfork()
• vfork() was intended to create a new process for the purpose of executing a new program
• i.e. The only thing the child process should do is make an exec() to copy another program into the processes memory space for execution.
• vfork() Creates the new process without copying the parent processes address space. The child runs within the same address space of the parent until the exec() or exit() call is made.
• vfork works this way to improve efficiency by eliminating unnecessary memory operations

Final points on fork()

• An example that displays the shared memory space

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
int     globvar = 6;        /* external variable in initialized data */

int main(void)s{
    int     var;        /* automatic variable on the stack */
    pid_t   pid;

    var = 88;
    printf("before vfork\n");   /* we don't flush stdio */
    if ((pid = vfork()) < 0) {
        perror("vfork error");
    } else if (pid == 0) {      /* child */
        globvar++;              /* modify parent's variables */
        var++;
        _exit(0);               /* child terminates */
    }

    /* parent continues here */
    printf("pid = %ld, glob = %d, var = %d\n", (long)getpid(), globvar,
      var);
    exit(0);
}

Final points on fork()

• While developing multi-process software, you can create some quite interesting rogue programs.
• The semester won’t be complete without someone letting one go…
• Typical rogue programs:
  • A Bomb: While (fork()>0)
  • A comet: while(fork() == 0);
• Comets are harder to stop than bombs. why?
• killall can work but it usually isn’t fast enough to stop the comment.

Final points on fork()

• Norms' Approach: Use a fork bomb to starve the comet!
  1. Start a fork() bomb as the owner of the comet
  2. The owners fork()s will start to fail (i.e. killing the comet)
  3. Send the owner process the stop signal to stop the bomb
  4. Send the owner the kill signal to kill all remaining open processes
• It’s good to understand bombs and comets as they form the basis of many Denial of service attacks (DOS)

Final points on fork()

• In general we will fork children and expect them to do something useful but different from what their parent is doing.
• Otherwise the whole exercise becomes pointless.
• The exec family of system calls comes to the rescue here.

Process Termination

• Processes can terminate normally in one of five ways:
  1. Executing a return from the main() function (this is the equivalent of calling exit())
  2. Calling the exit() function. This function is defined in ISO C and ensure that exist handlers are called correctly.
  3. Calling the _exit() function. This function is defined in ISO C and does not call the exit handlers
  4. Executing a return from the start routine of the last thread in the process.
  5. Calling pthread_exit() from the last thread in the process - more on threads down the track

Process Termination

• There are three forms of abnormal termination:

  1. Calling abort, which generates a SIGABRT (this is a special case of the following situation)
  2. Receiving a signal generated by itself or an external process
  3. The last thread responds to a cancelation request.

• Regardless of how a process terminates, the same kernel function is called to close all file descriptors and de-allocate memory

Process Termination

• Process termination function calls

.center[]

Process Termination

• the atexit() function can be used to register up to 32 different functions that are automatically called when a call to exit() is made by a process

#include <stdlib.h>

int atexit( void (*func)(void));

//Returns 0 of the function is called correctly and nonzero on error

• func is a function pointer that must be declared within your source.

Process Termination

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

static void my_exit1(void);
static void my_exit2(void);

int main(void){
    if (atexit(my_exit2) != 0)
        perror("can't register my_exit2");
    if (atexit(my_exit1) != 0)
        perror("can't register my_exit1");
    if (atexit(my_exit1) != 0)
        perror("can't register my_exit1");
    printf("main is done\n");
    return(0);
}

static void my_exit1(void){
    printf("first exit handler\n");
}

static void my_exit2(void){
    printf("second exit handler\n");
}

Process Termination

• What happens when a child process terminates, but its parent has not checked for its exit status yet?
• The kernel maintains a small amount of information for each process around after it terminates (including the exit status)
• So when the parent tries to access the child’s exit info, it will be available.
• Child processes in this state are referred to as Zombies
• Processes that have been inherited by init (i.e. the scheduler) do not enter the zombie state as the init process immediately calls one of the wait() functions to receive the exit status

Process Control Using wait()

• In the examples we have looked at thus far, the parent process has not waited for its children processes to finish before exiting itself.
• This has resulted in orphaned processes. This is messy and can result in an unstable program if your are assuming that the parent will execute based upon processing time.

Process Control Using wait()

• The correct approach is to use the one of the wait functions:

#include <sys/wait.h>

pid_t wait(int *staloc);

pid_t waitpid(pid_t pid, int *statloc, int options);

• wait and waitpid both return the process ID of the child process that has terminated
• If the statloc pointer is not null, then the exist status of the child process is stored in the location pointed to by statloc

Process Control Using wait()

• Executing a wait causes:

  1. the caller to pause until a child finishes, or until the caller receives a signal.

• The wait returns immediately if:

  1. the process has no children and the errno flag is set to ECHILD.
  2. a child has already finished prior to the wait being executed.

Process Control Using wait()

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
int main(void){ 
  int i, n = 4, status;
  pid_t childpid;
  for (i = 1; i < n;  ++i)
    if((childpid = fork()) < 0){ 
      /* fork error */
      perror("error in fork"); 
      exit(EXIT_FAILURE); }  
    else if(childpid){ 
      /* parent code */ 
      wait(&status);
      break;
    } else { 
      /* child code  */ 
    }
  /* mutual code */
  printf("This is process %d with parent %d\n",
         getpid(), getppid());
  return 0;
}

Process Control Using wait()

• Here (Previous Slide) the parent process is wait()ing for each child to finish before spinning off a new child
• When a process ends, the kernel notifies the parent by sending it a SIGCHLD signal.
• wait() and waitpid() use these signals to block the parent.
• The wait() function waits for the child that finishes first.
• The waitpid function has a number of options that control which process it actually waits for

Process Control Using wait()

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

int main(void){
    pid_t   pid;
    if ((pid = fork()) < 0) {
        perror("fork error");
    } else if (pid == 0) {      /* first child */
        if ((pid = fork()) < 0)
            perror("fork error");
        else if (pid > 0)
            exit(0);    /* parent from second fork == first child */

        /* We're the second child; our parent becomes init as soon
        *  as our real parent calls exit() in the statement above.
        *  Here's where we'd continue executing, knowing that when
        *  we're done, init will reap our status.*/

        sleep(2);
        printf("second child, parent pid = %ld\n", (long)getppid());
        exit(0);
    }
    if (waitpid(pid, NULL, 0) != pid)   /* wait for first child */
        perror("waitpid error");
    exit(0);
}

Process Control Using wait()

• The previous example shows the usage of waitpit()
• The example illustrates how to create a child process without actually waiting for it and without it becoming a zombie.
• The second child process relies on on init to capture its exit status to avid being a zombie

Process Control Using wait()

• There are a few variants of the wait() and waitpid() functions

#include <sys/wait.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>

int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);

pid_t wait3(int *statloc, int options, struct rusage *rusage);

pid_t wait3(pid_t pid, int *statloc, int options, struct rusage *rusage);

Process Control Using wait()

• The wait3() and wait4() versions include additional information about resources that the process used after it has terminated
• The waitid function allows the porcess to wait for a specific group or all child process to terminate.
• These are not used as often and more information can be seen in section 8.7 from the text.

Executing New Programs with exec()

• The exec family of functions is used to execute a new program within a process that has been created by a call to fork()
• Essentially, the memory image of the process (which will initially be identical to the parent process after a fork() call) is overwritten by a program loaded from storage and the main function is executed.
• There are seven functions in the exec() family:

#include <unistd.h>

extern char **environ;
int execl(const char *path, const char *arg0, ... /*, (char *)0 */);
int execv(const char *path, char *const argv[]);
int execle(const char *path, const char *arg0, ... /*,
       (char *)0, char *const envp[]*/);
int execve(const char *path, char *const argv[], char *const envp[]);
int execlp(const char *file, const char *arg0, ... /*, (char *)0 */);
int execvp(const char *file, char *const argv[]);
int fexecve(int fd, char *const argv[], char *const envp[])

Executing New Programs with exec()

• The base of each is exec (execute), followed by one or more letters:
  1. e – An array of pointers to environment variables is explicitly passed to the new process image.
  2. l – Command-line arguments are passed individually (a list) to the function.
  3. p – Uses the PATH environment variable to find the file named in the path argument to be executed.
  4. v – Command-line arguments are passed to the function as an array (vector) of pointers.

Executing New Programs with exec()

• path - points to a pathname identifying the new process image file.
• file - identifies the new process image file.
• arg - specifies a pointer to a null-terminated string.
• argv - specifies an array of character pointers to null-terminated strings.
• envp - specifies an array of character pointers to null-terminated strings, constituting the environment for the new process.

Executing New Programs with exec()

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
int main(int argc, char *argv[]){
  pid_t childpid, waitreturn;
  int status;
  if ((childpid = fork()) == -1) {
    perror("The fork failed");
    exit(1);
  } else if (childpid == 0) {
    /* child code */
    if (execvp(argv[1], &argv[1]) < 0) {
      perror("The exec of command failed");
      exit(1);
    }
    ...

Executing New Programs with exec()

  ...

  } else
    /* parent code */
    while(childpid != (waitreturn = wait(&status)))
      if ((waitreturn == -1) && (errno != EINTR))
        break;
  exit(0);
}

Executing New Programs with exec()

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include "makeargv.h"
int main(int argc, char *argv[]){
  char **myargv, delim[] = " \t";
  pid_t childpid, waitreturn;
  int status;
  if (argc != 2) {
    fprintf(stderr, "Usage: %s string\n", argv[0]);
    exit(EXIT_FAILURE);
  }
  if ((childpid = fork()) == -1) {
    perror("The fork failed");
    exit(EXIT_FAILURE);
  } else if (childpid == 0) {
    /* child code */
    if (makeargv(argv[1], delim, &myargv) < 0) {
      fprintf(stderr, "Argument array could not be constructed\n");
      exit(EXIT_FAILURE);
    } else if (execvp(myargv[0], &myargv[0]) < 0) {
      perror("The exec of command failed");
      exit(EXIT_FAILURE);
    } 
    ...

Executing New Programs with exec()

   ...

  } else
    /* parent code */
    while(childpid != (waitreturn = wait(&status)))
      if ((waitreturn == -1) && (errno != EINTR))
        break;
  exit(EXIT_SUCCESS);
}

Files and File Descriptors

• Remember from lecture 1, File Descriptors provide access to files by processes.
• A File Descriptor is actually an index for an entry in a kernel-resident array data structure containing the details of open files (hence they are non-negative)
  • When a process opens an existing file or creates a new file, the kernel returns a file descriptor to the process.

Files and File Descriptors

• When we want to read or write a file we use the file descriptor that was returned by the call to open.
• The file descriptor is really an index into the file descriptor table
• The File Descriptor Table is specific to a process and contains an entry for each open file in the process.
• The file descriptor table contains pointers to the system file table.

Files and File Descriptor

.center[]

Files and File Descriptor

• The System File Table is shared by all processes and contains an entry for each active open
• The System File Table maintains entries that consist of the access mode, file offset and the number of File Descriptor Table entries pointing to it.
• Several System File table entries may point to the same physical file on the system (as indicated in the previous figure)
• The i-nodes store the attributes and disk block location(s) of the filesystem object’s data (i.e. the location of that actual data)

Summary

• Final points on fork()
• Process Termination
• Process Control Using wait()
• Executing New Programs with exec()
• Files and File Descriptors

class: middle, center, inverse

Questions?

Reading

• Chapter 3, Finish Chapter 8 and start chapter 15 from Advanced Programming in the UNIX environment
• Assignment 1 Description

Next Lecture

• Inter-process communication with shared files and pipes
• Creating a ring of processes