The Process

CIS 370, Fall 2013

Umass Dartmouth

The notion of a process

In UNIX a process is an instance of a program in execution

A job or a taskEach process has program code, data

segment, program stack etc.The shell (or any command interpreter)

starts a process for each command submitted.

Process examples

$ cat file1 file2results in the shell creating a process

specifically for running this command

$ ls | wcresults in the shell creating two processes where

the output of ls is sent (via the pipe) as in input to wc

Processes are different from programs a single program may create several processes.

How to create a process

UNIX provides several mechanisms for creating processes.fork - creates a new process by duplicating the

calling process.exec - perform the transformation of a process

by overlaying its memory space with a new program.

wait - provides the ability for a process to be halted while a related process finishes.

exit - used to terminate a process.

The fork system call

Usage :#include <sys/types.h>

#include <unistd.h>

pid_t fork(void);

A successful call will result in the creation of a new process that is more or less identical to the calling process.

The Process

The newly created process is called the child process and the process that made the call is called the parent process.

After the system call is made successfully both processes begin execution at the statement after the call to fork.

Both processes will have identical data and code segments. All the variables will have the same values as before the fork call.

printf(“one\n”);pid = fork();printf(“two\n”);

printf(“one\n”);pid = fork();printf(“two\n”);

printf(“one\n”);pid = fork();printf(“two\n”);

Before

After

$ one

OUTPUT

$ two$ two

PC

fork()

PCPC

PC

Process IDs

fork() returns two values, unlike most system calls.

fork() returns the process id of the newly created process to the parent.

fork() returns a 0 to the newly created process.

Since all the variables are common, this can be used to synchronize and distinguish the child process from the parent process.

The exec family of calls • Unlike fork, exec will replace the calling

process.

• fork replicates the calling process, exec will create a new process and destroys the called process. The new process will inherit the process id of the called process.

• What is the point? What is interesting about simply the same process over and over again?

Before

After

exec

printf (…)

execl(“bin/ls”,…)

1st line of ls

PC

PC

PC

Data and File Sharing in fork

• In fork(), an identical copy of the parent process is made.

• All the variables are identical and all files open in the parent will remain open in the child process.

• Since the child process occupies a different memory location, modifications are local.

• Open files are however different. The read-write pointer is maintained by the OS.

Data and File Sharing in exec

• Open file descriptors are also passed across exec calls.

• The read-write pointer remains in the same position as in the process that called exec.

• What about variables and their values?

• The system call fcntl can be used to set the close-on-exec flag. When this flag is set the file is closed when the exec calls is made.

#include<fcntl.h>

int fd;

fd = open(“file”, O_RDONLY);

.

/* set close-on-exec flag on */

fcntl(fd, F_SETFD, 1);

/*set close-on-exec flag off */

fcntl (fd, F_SETFD, 0);

/* the value can be obtained as follows */

res = fcntl(fd, F_GETFD, 0);

Terminating a process - exit

• Usage

#include < stdlib.h>

void exit(int status);

Synchronizing Processes - the wait system call

• Usage

#include<sys/types.h>

#include<sys/wait.h>

pid_t wait (int *status);

wait() temporarily suspends the process until its child process finishes execution.

More on wait

• The call to wait returns the process id of the child process that exits

• The argument to wait is an integer pointer that contains the exit code of the exiting child process.

• If there are n child processes, n wait statements would be needed if the parent is to continue after all the child processes have exited.

Waiting for a specific child

• Usage#include<sys/types.h>

#include<sys/wait.h>

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

• The first argument specifies the id of the process the parent is waiting for (if this is set to -1 and the options to 0, this call behaves exactly like wait() ).

waitpid system call

• The second argument contains the exit status of the child.

• The final argument options can take a variety of values defined in <sys/wait.h>

• The most useful is the option WNOHANG

• This allows waitpid to sit in a loop, without blocking.

• waitpid returns the process id of the child process once terminated.

Zombies and Orphans

• A child process becomes a zombie when it exits before the parent process issues a wait. This results in the process occupying space in the system’s process table but nothing else.

• If a parent process exits before a child process is done, that process is “orphaned” and is “adopted” by the OS (and killed!).