Processes

1
 Users, Programs,
Processes
 Users have accounts on the
system
 Users launch programs
 Many users may launch same
program
 One user may launch many instances
of the same program
 Processes:
 an executing program (the unit of 2
 Process States

 Possible process states (simplified view):

 Running (occupy CPU)
 Blocked
 Ready (does not occupy CPU)

3
 Linux: 5 State Process
Model
 Add states for creating and deleting
process
 Add transitions Timeout, Dispatch,
Event Occurs

4
How to List all Processes?
 On Windows: run Windows task
manager
 Hit Control+ALT+delete
 Click on the “processes” tab
 On UNIX
 $ ps –e
 Try “man ps” to understand more
about its usage.

5
 Process Identification
 UNIX identifies processes via a unique Process ID
 Each process also knows its parent process ID since each
process is created from a parent process.
 Root process is the ‘init’ process
 ‘getpid’ and ‘getppid’ – functions to return process ID (PID)
and parent process ID (PPID)

 Example 1
#include <stdio.h>
#include <unistd.h>
int main (void) {
printf(“I am process %ld\n”, (long)getpid());
printf(“My parent id is %ld\n”, (long)getppid());
return 0;
} 6
 Creating a Process – fork()
 pid_t fork() creates a duplicate of the calling
process:
 Both processes continue with return from fork()
 Child gets exact copy of code, stack, file
descriptors, heap, globals, and program counter

 fork() returns
 -1 if fork fails
 0 in child process
 child’s PID in parent process 7
 Creating a child Process –
fork()
 fork() creates a new process by duplicating the
calling process. The new process, referred to as the
child, is an exact duplicate of the calling process,
referred to as the parent, except for the following
points:

 The child has its own unique process ID

 The child does not inherit its parent’s memory locks (e.g.,
mlock(2)).
 Process resource utilizations and CPU time counters are reset
to zero in the child.
 The child’s set of pending signals is initially empty.
 The child does not inherit record locks from its parent
(fcntl(2)).
8
 The child does not inherit timers from its parent.
 Creating a child Process –
fork()

 The entire virtual address space of the parent is

replicated in the child, including the states of mutexes,
etc.

 The child inherits copies of the parent’s set of open file

descriptors. Each file descriptor in the child refers to
the same open file description (see open(2)) as the
corresponding file descriptor in the parent. This
means that the two descriptors share open file status
flags, and current file offset.

9
 Creating a Process in Unix
Example 2

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

int main(void) {
pid_t x;
x = fork();
if (x == 0)
printf(“In child: fork() returned %ld\n”, (long) x);
else
printf(“In parent: fork() returned %ld\n", (long) x);
}

What does this print?

10
 Chain and Fan
What is the difference between these two
segments of code?

pid_t childpid = 0; pid_t childpid = 0;

for (i=1;i<n;i++) for (i=1;i<n;i++)
if (childpid = fork()) if ((childpid = fork()) <=0)
break; break;

11
 Chain and Fan
Fan

Chain pid_t childpid = 0;

for (i=1;i<n;i++)
if ((childpid = fork()) <=0)
pid_t childpid = 0; break;
for (i=1;i<n;i++)
if (childpid = fork())
break; Parent

… …
Parent Child Child Child Child

12
 Process Operations:
Creation
 A new process needs resources such as CPU,
memory, file descriptors
 Child can get resources from OS or from parent
 Child address space is a duplicate of parent
process
 Child process is given a subset of parent
resources

Prevents too many processes from overloading system
 Execution possibilities are

Parent continues concurrently with child

Parent waits until child has terminated

13
 Process Termination
 Normal exit (voluntary)
 Returning zero from main()
 exit(0)
 Error exit (voluntary)
 exit(1)
 Fatal error (involuntary)
 Divide by 0, seg fault, exceeded
resources
 Killed by another process 14
 Process Operations:
Termination
 When a child process terminates:
 Open files are flushed and closed
 tmp files are deleted
 Child’s resources are de-allocated

File descriptors, memory, semaphores, file
locks, …
 Parent process is notified via signal
SIGCHLD
 Exit status is available to parent via wait()

15
 Process Hierarchies
 Parent creates a child process, a child
process can create its own child
processes
 Forms a hierarchy
 UNIX calls this a "process group"
 Windows has no concept of process
hierarchy
 all processes are created equal
16
 wait(), waitpid() System
Calls
pid_t wait(int *status); errno Cause
ECHILD Caller has no
unwaited-for
 wait() causes parent children
process to wait (block)
until some child EINTR Function was
interrupted by
finishes signal
 wait() returns child’s EINVAL Options
pid and exit status to parameter of
parent waitpid was
invalid
 waitpid() waits for a
specific child 17
 wait(), waitpid() System
Calls
pid_t wait(int *status);

 In the case of a terminated child, performing a wait

allows the system to release the resources associated
with the child; if a wait is not performed, then the
terminated child remains in a "zombie“ state.

 If a child has already terminated, then the call returns

immediately. Otherwise it blocks until either a child
terminates or a signal handler interrupts the call. A
child that has terminated and which has not yet been
waited upon by this system call (or waitpid) is termed
waitable. 18
 wait(), waitpid() System
Calls
 If status is not NULL, wait() stores status information in
the int to which it points. This integer can be
inspected with specific macros (see man pages):

 WIFEXITED(status)
 returns true if the child terminated normally, that is, by calling
exit, or by returning from main().

 WEXITSTATUS(status)
 returns the exit status of the child. This consists of the
least significant 8 bits of the status argument that the child
specified in a call to exit or as the argument for a return
statement in main(). This macro should only be employed if
WIFEXITED returned true. 19
 wait() & “zombie”
 A child that terminates, but has not been waited for becomes a
"zombie". The kernel maintains a minimal set of information
about the zombie process (PID, termination status, resource
usage information) in order to allow the parent to later perform
a wait to obtain information about the child.

 As long as a zombie is not removed from the system via a wait,

it will consume a slot in the kernel process table, and if this table
fills, it will not be possible to create further processes.

 If a parent process terminates, then its "zombie" children (if any)

are adopted by init(8), which automatically performs a wait to
remove the zombies.

20
 Waiting for a child to finish
(Try “man –s 2 wait”)

#include <errno.h>
#include <sys/wait.h>

pid_t childpid;

childpid = wait(NULL);
if (childpid != -1)
printf(“waited for child with pid %ld\n”, childpid);

21