Process control in UNIX, pipes, signals - Chapter 12

fork()

creates a child process

#include <sys/types.h>
#include <unistd.h>
 
pid_t fork(void);

PID - process identification, a unique non-negative integer
on success, returns the PID of the child process in the parent's thread of execution, and 0 in the child's thread of execution

Example

create a single child process

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

int main(void)
{ 
  int value = fork();                   /* new process */
  printf("In main: value = %d\n", value);
  return 0;
}

Output

In main: value = 17219
In main: value = 0

Example

create more child processes

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

int main(void)
{ 
  int value1, value2;
  
  value1 = fork();                   /* new process */
  value2 = fork();
  printf("In main: value = %d\n", value);
  return 0;
}

Output

In main: value = 26164
In main: value = 0
In main: value = 0
In main: value = 0
In main: value = 26165
In main: value = 26166
In main: value = 26164
In main: value = 0

Another Example

Compute Fibonacci numbers and print time asynchronously

#include <stdio.h>
#include <time.h>

int fib(int);
int fork(void);
void sleep(unsigned);

int main(void)
{
  int begin = time(NULL), i;

  if (fork() == 0)                              /* child */
    for (i = 0; i < 30; ++i)
      printf("fib(%2d) = %d\n", i, fib(i));
  else                                          /* parent */
    for (i = 0; i < 30; ++i) {
      sleep(2);
      printf("elapsed time = %d\n", time(NULL) - begin);
    }
  return 0;
}

int fib(int n)
{
  if (n <= 1)
    return n;
  else
    return (fib(n - 1) + fib(n - 2));
}

The exec() family

the exec family of functions replaces the current process image with a new process image
the first parameter is the name of the file to be executed, then list of 'command line' arguments, terminated by NULL (slight variations in some of the functions, do "man execl")

return -1 on error

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

execl example

Execute a program out of 2

/* file pgm-exec.c */
#include <stdio.h>
#include <unistd.h>

int main(void)
{
  int choice = 0;

  printf("%s\n%s\n%s",
         "The parent process will be overlaid.",
         "You have a choice.",
         "Input 1 or 2: ");
  scanf("%d", &choice);
  putchar('\n');
  if (choice == 1)
    execl("pgm1", "pgm1", "a", "b", "c", 0);
  if (choice == 2)
    execl("pgm2", "pgm2", "1", "2", "3", "go", 0);
  printf("ERROR: You did not input 1 or 2.\n");
  return 0;
}

pgm1.c
pgm2.c
pgm_exec.c

Processes and their (P)ID

PID = 0,1 or 2: standard processes typically scheduler, init-process, and pagedaemon (0 and 2 are system processes, and 1 is a user process with system privileges, it is the parent of all orphan processes)
on fork the entire process is duplicated including open file descriptors which refer in the parent and the child to the same files (and hence have the same offset)
pid_t getpid(void);
- returns the process ID of the current process, -1 on error
pid_t waitpid(pid_t pid, int *status, int options);
- many modes of activation and many options; in principle suspends execution of the current process until a child as specified by the pid argument has exited
- returns the PID of the child which exited, -1 on error
- if status is not NULL, wait or waitpid store status information in the location pointed to by status; this information can be read with ready-made macros

Shell Example

A simple shell-like program (Stevens', Program 1.5):

#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <string.h>

#define MAXLINE 100

int main(void)
{
  char buf[MAXLINE];
  pid_t pid;
  int status;

  printf("%% "); /* print prompt (printf requires %% to print %) */
  while (fgets(buf, MAXLINE, stdin) != NULL) {
    buf[strlen(buf) - 1] = 0; /* replace newline with null */
    if ( (pid = fork()) < 0)
      fprintf(stderr,"fork error");
    else if (pid == 0) {		/* child */
      execlp(buf, buf, (char *) 0);
      fprintf(stderr,"couldn't execute: %s\n", buf);
      return 127;
    }

    /* parent */
    if ( (pid = waitpid(pid, &status, 0)) < 0)
      fprintf(stderr,"waitpid error");
    printf("%% ");
  }
  return 0;
}

pipe()

pipe creates a pair of file descriptors, pointing to a pipe inode, and places them in the array pointed to by filedes; filedes[0] is for reading, filedes[1] is for writing

on success, zero is returned, on error, -1

#include <unistd.h>
int pipe(int filedes[2]);

hello pipe

pipe between parent and child

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

#define MAXLINE 100

int main(void)
{
  int n, fd[2];
  pid_t pid;
  char line[MAXLINE];

  int i;
  char c;

  if (pipe(fd) < 0)
    fprintf(stderr, "pipe error \n");

  if ((pid = fork()) < 0)
    fprintf(stderr, "fork error \n");

  else if (pid > 0) {   /* parent */
    close(fd[0]);
    write(fd[1], "\nhello world\n", 13);
  } else {              /* child */
    close(fd[1]);
    n = read(fd[0],line,MAXLINE);
    for (i = 0; i < n; i++) {
      c = toupper(line[i]);
      write(STDOUT_FILENO, &c, 1);
    }
  }

  //fprintf(stderr,"exit from pid = %d\n", getpid());
  return 0;
}

sum pipe

use pipes to sum N rows concurrently

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define N   3

int add_vector(int v[]);
void error_exit(char * s);

int main(void)
{
  int a[N][N] = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
  int i, row_sum, sum = 0;
  int pd[2];                            /* pipe descriptors */

  if (pipe(pd) == -1)                   /* create a pipe */
    error_exit("pipe() failed");
  for (i = 0; i < N; ++i)
    if (fork() == 0) {                  /* child process */
      row_sum = add_vector(a[i]);
      if (write(pd[1], &row_sum, sizeof(int)) == -1) 
        error_exit("write() failed");
      return 0;                         /* return from child */
    }
  for (i = 0; i < N; ++i) {
    if (read(pd[0], &row_sum, sizeof(int)) == -1) 
      error_exit("read() failed");
    sum += row_sum;
  }
  printf("Sum of the array = %d\n", sum);
  return 0;
}

int add_vector(int v[])
{
  int i, vector_sum = 0;

  for (i = 0; i < N; ++i)
    vector_sum += v[i];
  return vector_sum;
}

void error_exit(char *s)
{
  fprintf(stderr, "\nERROR: %s - bye!\n", s);
  exit(1);
}

popen_pager

show the contents of an input file

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

/* environment variable, or default */
#define	PAGER   "${PAGER:-more}"
#define MAXLINE 100

void err_sys(const char * str);

int main(int argc, char * argv[])
{
  char line[MAXLINE];
  FILE * fpin, * fpout;

  if (argc != 2) {	
    fprintf(stderr,"usage: a.out filename\n");
    exit(127);
  }
	
  if ((fpin = fopen(argv[1], "r")) == NULL)
    err_sys("can't open input file for reading");

  if ((fpout = popen(PAGER, "w")) == NULL)
    err_sys("popen error");

  /* copy argv[1] to pager */
  while (fgets(line, MAXLINE, fpin) != NULL) {
    if (fputs(line, fpout) == EOF)
      err_sys("fputs error to pipe");
  }
  if (ferror(fpin))
    err_sys("fgets error");
  if (pclose(fpout) == -1)
    err_sys("pclose error");
  exit(0);
}

/* print error message and quit */
void err_sys(const char *str)
{
  fprintf(stderr," %s\n",str);
  exit(1);
}

signal()

installs a new signal handler for the signal with number signum
returns the previous value of the signal handler, or SIG_ERR on error
void (*signal(int signum, void (*sighandler)(int)))(int);

Signal Handler

Using a signal handler

#include <stdio.h>
#include <signal.h>
#include <stdlib.h>

#define MAXSTRING   100

void cntrl_c_handler(int sig);
int fib(int n);

int main(void)
{
  int i;

  signal(SIGINT, cntrl_c_handler);
  for (i = 0; i < 46; ++i)
    printf("fib(%2d) = %d\n", i, fib(i));
  return 0;
}

void cntrl_c_handler(int sig)
{
  char answer[MAXSTRING];

  printf("\n\n%s%d\n\n%s",
         "Interrupt received!  Signal = ", sig,
         "Do you wish to continue or quit? ");
  scanf("%s", answer);
  if (*answer == 'c')
    signal(SIGINT, cntrl_c_handler);
  else
    exit(1);
}

int fib(int n)
{
  if (n <= 1)
    return n;
  else
    return (fib(n - 1) + fib(n - 2));
}

Signal Handler

// using a signal handler
// segmentation violation---trying to access a place that is not ours
// in bits/signum.h 
// #define	SIGSEGV		11	/* Segmentation violation (ANSI).  */

#include <stdio.h>
#include <signal.h> // this file calls bits/signum.h
#include <stdlib.h>

#define MAXSTRING   100

void segv_handler(int sig);

int main(int argc, char *argv[], char *env[])
{
  int i;

  signal(SIGSEGV, segv_handler);

  fprintf(stderr," writing the contents of argv[-20000] %s\n",argv[-20000]);

  fprintf(stderr," next instruction\n");
}

void segv_handler(int sig)
{
  char   answer[MAXSTRING];

  printf("\n\n%s%d\n\n%s",
    "Interrupt received!  Signal = ", sig,
    "Do you wish to (c)ontinue or (q)uit? ");
  scanf("%s", answer);
  if (*answer == 'c')
    signal(SIGSEGV, segv_handler);
  else
    exit(1);
}

shells and shellscripts, introduction

#include <stdio.hgt;

#define MARKER   ">> "

int main(int argc, char * argv[])
{
  int   val;

  printf("\n");
  printf(MARKER "    Input an integer: ");
  scanf("%d", &val);
  printf(MARKER "Value being returned: %d\n\n", val);
  return val;
}

try_me.c

#!/usr/bin/csh

##
## Experiment with the status.
##

echo ---
echo At the top: status = $status
try_me
echo ---
echo After try_me: status = $status
try_me
set val = $status
echo ---
echo After try_me again: val = $val
echo ""
echo ---
echo To exit from the while loop, input 0.
while ($val)
  try_me
  set val = $status
  echo In the loop: val = $val
end

go_try

Output

---
At the top: status = 0

>>     Input an integer: 3
>> Value being returned: 3

---
After try_me: status = 0

>>     Input an integer: 7
>> Value being returned: 7

---
After try_me again: val = 7

Last modified: August 31 2004.