‫ﺑﺴﻢ ﷲ ﺍﻟﺮﺣﻤﻦ ﺍﻟﺮﺣﻴﻢ‬

EE 463 : Operating Systems

Faculty Of Engineering LAB #7
King Abdulaziz University
Department Of Electrical and Computer Engineering

Concurrent Process Creation and Execution

Multi-Processing

Objective:
Some application programs may have several possible execution sequences, which may be independent,
or may depend on each other. Such programs can be made more responsive if the different sequences of
execution are written as separate units that can compete for the CPU together with other program units in
the system. Such units can be made as part of the same process, (i.e. have the same PCB and share same
address space), called Threads; or can have their own Processes (i.e. with different PCBs and different
address spaces).

Modern operating systems support multi-threading and multi-processing in user programs, through
numerous data structures and functions provided in high-level programming language libraries.

In this lab you will learn how a program in Linux can create, terminate, and control child processes, and
how it can replace its own code with that of another executable file. There are three distinct main
operations involved:
• Creating a new child process,
• Causing the new process to execute a program, and
• Coordinating the completion of the child process with the original program.

You can skip the discussions and go directly to the numbered instructions written in RED

Process Creation Concepts:

Processes are the primitive units for allocation of system resources. Each process has a unique process ID
number, which is given to it by the operating system when it is created, its own address space and
(usually) one thread of control. A process executes a program. We can have multiple processes executing
the same program, but each process has its own copy of the program within its own address space and
executes it independently of the other copies.

Processes are organized hierarchically. Each process has a parent process, which explicitly created it.
The processes created by a given parent are called its child processes. A child process inherits many of
its attributes from the parent process.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 1 of 16

Processes are created with the fork() system call function; this operation is referred to as forking a
process. A child process created by the fork system call is an exact copy of the original parent process,
except that it has its own process ID and its own address space.

After forking a child process, both the parent and child processes continue to execute normally. The new
child process continues to execute the same program as its parent process, starting at the point after the
fork system call. We can tell whether the program is running in the parent process or the child process by
examining the return value from the fork system call: The parent receives the child’s Process ID, while
the child receives a zero.

If a program needs to wait for a child process to finish execution, or terminate, before continuing, it must
specify this explicitly after the forking operation, by calling the wait() or waitpid() system calls.
When a child process terminates, its parent is informed through one of these two functions so that the
parent may take some appropriate action. The two wait functions give limited information about why the
child process has terminated by passing its returned exit status code.

The lifetime of a process ends when it terminates and its termination is reported to its parent process. At
that time, all of the process resources, including its process ID, will be freed. A terminating process that is
waiting for its parent to accept its return code is called a zombie process. If a parent terminates before
its child, the child is called an orphan process, and it is adopted automatically by the original (great
grandparent) “init” process whose PID is 1.

Process Monitoring:
To monitor the state of your processes under Linux, use the ps command.

ps [-option]

This command, if used without any options, produces a list of all the processes owned by the current user
and associated with the current user’s terminal. The information displayed by the ps command varies
according to which command option(s) used and the type of Linux under which it is used. These are some
of the column headings displayed by the different versions of this command:
PID SZ(size in Kb) TTY(controlling terminal) TIME(used by CPU) CMD(program name)

Examples:

1. To display a short list of the current user’s processes running in the current terminal, type:

$ ps

2. To display a long list of the current user’s processes running in the current terminal, type:

$ ps -ly

3. To display information about all processes running for user ‘mohammad’, type:

$ ps -u mohammad

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 2 of 16

Creating Multiple Processes:
The Linux operating system kernel supports multi-processing and provide many ways to create them. We
will examine two ways in which multiple processes can be created in Linux:

A. Using the Shell:

As you learned from Lab#2, a Linux shell provides a command line interface to the Linux kernel. Every
time a command is typed, the shell creates a new process (task) that it uses to run that command. In
Linux, the processes that are run from the shell may be in one of three states:

Foreground Processes:
Foreground processes are processes created by the shell when you run a command (or a program)
and they do not give you access to the shell’s command prompt until they terminate or you exit out of
the process.

Example:
1) Run the following command from the shell:

$ ping localhost > /dev/null

The ping process will become a foreground job and will not return you to the command prompt until
you stop it or kill it.

You can exit out of the ping process (or kill it) by pressing ctrl+c. This signals the foreground
process to terminate by sending it the SIGINT (Signal Interrupt) signal. You will learn about signals
in a future lab.

Background Processes:
Background processes run exactly as if they were in the foreground except that they do not receive
user input from the shell. If a command produces output and is put in the background, it will still
produce the output.

There are a number of reasons why we may want to put a process in the background, and they will
become clear in the examples below.

Stopped Processes:
Stopped Processes are those processes that are neither in the foreground nor in the background, and
yet they are not terminated. They are technically in a third state, called stopped state.

Like background processes, stopped processes do not receive user input. Unlike background
processes, stopped processes do not produce output. As a matter of fact, they don’t do anything. They
have essentially been put on hold and won’t do any processing until they are resumed or killed.

Stopping and Resuming Processes:

It may seem like stopped jobs are not so useful, but they are actually the key to getting started with
multiprocessing on the Linux shell. Imagine that you are in your favorite shell text editor working on a
program or modifying config files, and you can’t remember what the IP address you need is, but you
could easily look it up with dig. You could easily open up another shell connection and run the
command, but it would be quicker to simply stop the editor, run the command quickly, copy the text, and
bring your editor to the foreground. The following example uses ifconfig because dig isn’t installed.

Example:
2) While your ping process is still running in the foreground, do the following sequence of inputs in
your shell:

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 3 of 16

 ctrl+z You will see: [1]+ Stopped ping localhost > /dev/null
$ ifconfig You will see some table as a response
$ fg %1 You will be back in your ping command.

The key to stopping a running process is to press ctrl+z. This sends the SIGTSTP (Signal Tty Stop)
signal to the foreground process. When the running process receives the signal, it will be stopped and you
will be returned to the command prompt.

The number appearing in square brackets when the process was stopped (e.g., [1]+) is called a job
number, used to identify the stopped process(s) in case you have multiple jobs in stopped states. At any
time, you can run the jobs command to get a list of the current jobs. In our example we used the number
1 to get our ping job back to the foreground by the command fg %1.

Running Processes in the Background:

We learned how to stop a process for as long as we need while we returned to the command prompt, but
what if we want to be returned to the command prompt while still allowing the process to continue
running? Sending a process to the background will do exactly that. This will allow us to run a program
that takes a long time to finish (like backup) while we work on other programs. The way to do that
follows:

After stopping a process you can continue running it in the background by the bg command followed by
its job number.

Example:
3) While your ping process is still running in the foreground, do the following sequence of inputs in
your shell:

ctrl+z You will see: [1]+ Stopped ping localhost > /dev/null
$ bg %1 You will see: [1]+ ping localhost > /dev/null &
$ Your ping command is now executing in the background. Shell is free.

When a process that is running in the background finishes, you will receive a message the next time your
command prompt refreshes. The prompt refreshes when you run another command or simply hit Enter to
get a new prompt.

The message will look like the following:

$
[1]+ Done ping localhost > /dev/null
$

As with all the other job-related output, you will be notified of the job number and the command.

Starting Processes in the Background

We can always run a shell command with the ampersand (&) at the end to automatically put the job in the
background to begin with. The ampersand means that the job is running in the background.

Example:
4) At the shell command prompt, enter the following command:

$ ping localhost > /dev/null & You will see something like: [2] 3353
$

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 4 of 16

The output when sending the job directly to the background is different than running bg. Instead of telling
you the command, it tells you the actual process ID. Every program that runs in Linux is a process and
has a process ID. You can use these process IDs to kill a specific process, change the process’s execution
priority, and isolate the resource utilization by that process.

Even though you’ve put a task in the background, you can still bring it to the foreground using the fg
command. In the previous example, you can pull the background process to the foreground by running:

$ fg %1.

Terminating Processes:
Sometimes a process goes rogue and either won’t respond to input, is consuming massive amounts of
resources, or both. At times like this, it’s very important to know how to terminate a process which will
cease the program’s execution and free up its used resources.

The command used to terminate processes is appropriately called kill. It can accept either process IDs
or job numbers (the job number must be preceded by a percent sign, “%”).

Example:
5) With the two ping processes still in the background, get their job numbers by entering:

$ jobs You may see: [1]- Running ping localhost > /dev/null &
$ [2]+ Running ping localhost > /dev/null &

6) To terminate the first job whose number is 1, enter the following command at the shell prompt:

$ kill %1 You will see: [1]- Terminated ping localhost > /dev/null
$

You can also run the kill command on a process ID rather than a job number. At this point you
may still have one ping process running in the background.

7) Enter the ps command to get the process ID of this process:

$ ps You may get: 3353 pts/0 00:00:01 ping

$

8) Enter the following kill command to terminate the ping process, with process ID 3353:

$ kill 3353 You will see: [2]+ Terminated ping localhost > /dev/null
$

By default, the kill command sends a SIGTERM (Signal Terminate) signal to the process; however,
sometimes this is not enough to stop the execution of an out of control process. To shut down these
processes, we need something more powerful such as:

$ kill -9 %1

This may not look much different, but the addition of the “-9” option tells the command that things are
serious now. This option causes a SIGKILL (Signal Kill) signal to be sent to the process. A kill signal
cannot be intercepted by a process and causes the process to immediately terminate without allowing it to
clean up after itself. It’s for this reason that you should only use SIGKILL after first sending the process a
SIGTERM.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 5 of 16

B. Using the C Library:
A more interesting and commonly used method among Linux programmers is to use specialized C
libraries to create and manage multiple processes from within a C program. These functions are described
in this section, with some examples.

Process Identification - getpid() and getppid():

The pid_t data type represents process IDs which is basically a signed integer type. You can get the
current process ID by calling getpid(). The function getppid() returns the process ID of the parent
of the current process (this is also known as the parent process ID). Your program should include the
header files ‘unistd.h’ and ‘sys/types.h’ to use these functions. For more, see: man getpid.

Function Syntax: pid_t getpid(void)

pid_t getppid(void)

Process Creation - fork():

The fork function is the primitive used for creating a process from within a C program. It is defined by
including the header file "unistd.h".

Function Syntax: pid_t fork(void)

When fork is called, it creates a new process. If the operation is successful, there are then both parent
and child processes and both see the fork return, but with different values:
• Returns a value of 0 in the child process, and
• Returns the child's process ID in the parent process.

If process creation failed, fork returns a value of -1 in the parent process and no child is created. When
the fork call is successful, the newly created process will be a copy of its parent process, except for the
following differences:
• The child process has its own unique process ID.
• The getppid()function call within the child process returns its parent process ID.
• The child process gets its own copy of the parent process's open file descriptors. Subsequent
changes of the file descriptors in the parent process won't affect the file descriptors in the child,
and vice versa. However, both processes share the file position associated with each descriptor.
• The elapsed processor times for the child process are set to zero.
• The child doesn't inherit file locks set by the parent process.
• The child doesn't inherit alarms set by the parent process.
• The set of pending signals for the child process is cleared.

Example 1:
/* Hello World */

#include <stdio.h>
#include <unistd.h> /* contains fork prototype */

int main(void) {
printf("Hello World!\n");
fork();
printf("I am after forking\n");
printf("\tI am process %d.\n", getpid());
}

9) Run the above program and observe its output.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 6 of 16

When this program is executed, it first prints Hello World! When the fork is executed, an identical
child process is created. Then both the parent and the child process begin execution at the next statement.
Note the following:
• When a fork is executed, everything in the parent process is copied to the child process. This
includes variable values, code, and file descriptors.
• Following the fork, the child and parent processes are completely independent.
• There is no guarantee which process will execute the statement after the fork first.
• The child process begins execution at the statement immediately after the fork, not at the
beginning of the program.
• A process can execute as many forks as desired. However, be wary of infinite loops of forks
(there is a maximum number of processes allowed for a single user).

Example 2:
/* Parent - Child */

#include <stdio.h>
#include <unistd.h> /* contains fork prototype */

int main(void)
{
pid_t pid;
printf("Hello World!\n");
printf("I am the parent process, my pid is: %d.\n", getpid());
printf("Here i am before forking\n");
pid = fork();
printf("Here I am just after forking\n");

/* detect which process */

if (pid == 0)
printf("I am the child process, my pid is: %d.\n", getpid());
else
printf("I am the parent process, my pid is: %d.\n", getpid());
}

Example 3:
/* Multiple Forks */

#include <stdio.h>
#include <unistd.h> /* contains fork prototype */

int main(void)
{
printf("Here I am just before first forking statement\n");
fork();
printf("Here I am just after first forking statement\n");
fork();
printf("Here I am just after second forking statement\n");
printf("\t\tHello World from process %d!\n", getpid());
}

10) Run the above two programs and observe their outputs. Why the second program repeats itself ?

Process Completion - wait() and exit():

The functions described in this section are used to wait for a child process to terminate or stop, and
determine its status. These functions are declared in the header file ‘sys/wait.h’.

Function Syntax: pid_t wait(int *status_ptr)

The wait() function will force a parent process to wait for a child process to stop or terminate. It returns
the process ID of the child or -1 for an error. The exit status of the child is returned to status_ptr.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 7 of 16

 Function Syntax: void exit(int status)

The exit() function terminates the process which calls it and returns the exit status value. Both Linux
and C (forked) programs can read the status value.

By convention, a status of 0 means normal termination. Any other value indicates an error or unusual
occurrence. Many standard library calls have errors defined in the ‘sys/stat.h’ header file. We can
easily derive our own conventions.

If the child process must be guaranteed to execute before the parent continues, the wait system call is
used. A call to this function causes the parent process to wait until one of its child processes exits. The
wait call returns the process ID of the child process, which gives the parent the ability to wait for a
particular child process to finish.

Process Suspension - sleep():

A process may suspend itself for a period of time using the sleep system call function.

Function Syntax: unsigned int sleep(unsigned int seconds)

This sleep function suspends the process until the specified number of seconds has elapsed or a signal
arrives which is not ignored. It returns 0 if the requested time has elapsed, or the number of seconds left to
sleep, if the call was interrupted by a signal handler.

Example 4:
/* Guarantees the child process will print
* its message before the parent process
*/

#include <stdio.h>
#include <stdlib.h> /* contains prototype for exit */
#include <sys/wait.h> /* contains prototype for wait */
#include <unistd.h> /* contains prototype for fork */
#include <sys/types.h> /* contains pid_t declaration */

int main(void)
{
pid_t pid;
int status;
printf("Hello World!\n");
pid = fork();
if (pid == -1) { /* check for error in fork */
perror("bad fork");
exit(1);
}
if (pid == 0) /* child will print his message */
printf("I am the child process.\n");
else {
wait(&status); /* parent waits for child to finish */
printf("I am the parent process.\n");
}
}

Orphan processes:
When a parent dies before its child, the child is automatically adopted by the original “init” process
whose Process ID is 1. To illustrate this, insert a sleep statement into the child’s code. This ensures that
the parent process is terminated before its child.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 8 of 16

 Example 5:
/* Guarantees the parent process will
* terminate before its child process
*/

#include <stdio.h>
#include <sys/wait.h> /* contains prototype for wait */
#include <unistd.h> /* contains prototype for fork */
#include <sys/types.h> /* contains pid_t declaration */

int main(void)
{
pid_t pid;
printf("I am the original process with PID %d and PPID %d.\n", getpid(), getppid());

pid = fork(); /* Duplicate. Child and parent continue from here */

if (pid != 0) { /* pid is non-zero, so I must be the parent */

printf("I am the parent with PID %d and PPID %d.\n", getpid(), getppid());
printf("My child's PID is %d\n", pid );
}
else { /* pid is zero, so I must be the child */
sleep(4); /* make sure that the parent terminates first */
printf("I am the child with PID %d and PPID %d.\n", getpid(), getppid());
}
printf("PID %d terminates.\n", getpid());
}

11) Run the above program now.

12) Observe its output:
I am the original process with PID 2500 and PPID 2199.
I am the parent with PID 2500 and PPID 2199.
My child's PID is 2501
PID 2500 terminates. Parent dies
$
I am the child with PID 2501 and PPID 1. Orphaned: parent “init”, pid 1
PID 2501 terminates.

Zombie processes:
A process that terminates cannot leave the system until its parent accepts its return code. If its parent
process is already dead, it’ll already have been adopted by the “init” process, which always accepts its
children’s return codes. However, if a process’s parent is alive but never executes a wait(), the
process’s return code will never be accepted and the process will remain a zombie.

The following program created a zombie process, which was indicated in the output from the ps utility.
When the parent process is killed, the child was adopted by “init” and allowed to rest in peace.

Example 6:
/* Produces a Zombie process */
#include <stdio.h>
#include <stdlib.h> /* contains prototype for exit */
#include <unistd.h> /* contains prototype for fork */
#include <sys/types.h> /* contains pid_t declaration */
int main(void) {
pid_t pid;
pid = fork(); /* Duplicate. Child and parent continue from here */
if (pid != 0) { /* pid is non-zero, so I must be the parent */
while(1) /* never terminates and never executes a wait() */
sleep(100); /* stop executing for 100 seconds */
}
else exit(42); /* pid is zero, so I must be the child, then exit */
}

13) Run the above program in the background and do the following commands shown in blue color.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 9 of 16

 14) Observe the outputs:
$ ./a.out & execute program in the background
[1] 3841
$ ps obtain process status
PID TTY S TIME CMD
2199 pts/0 S 00:00:02 bash the shell
3841 pts/0 S 00:00:00 a.out the parent process
3842 pts/0 Z 00:00:00 a.out <defunct> the zombie child process
4045 pts/0 R 00:00:00 ps
$ kill 3841 kill the parent process
$
[1]+ Terminated ./a.out
$ ps notice that the zombie is gone now
PID TTY S TIME CMD
2199 pts/0 S 00:00:02 bash
4230 pts/0 R 00:00:00 ps
$

Executing a file:
A child process can execute another program by using one of the exec functions. The program that the
process is executing is called its process image. Starting execution of a new program causes the process
to forget all about its previous process image; when the new program exits, the process exits too, instead
of returning to the previous process image. This section describes the exec family of functions, for
executing a file as a process image. You can use these functions to make a child process execute a new
program after it has been forked.

The functions in this family differ in how you specify the arguments, but otherwise they all do the same
thing. They are defined in the header file “unistd.h”.

Function Syntax: int execv(const char *filename, char *const argv[])

int execl(const char *filename, const char *arg0, ...)
int execvp(const char *filename, char *const argv[])
int execlp(const char *filename, const char *arg0, ...)

The execv() function executes the file named by filename as a new process image. The filename
argument may include the full path of the program file to be executed. This new program may require its
own list of arguments, which we can specify as elements of argv. So the argv argument of execv() is
an array of pointers to null-terminated strings that represent the argument list available to the new
program. By convention, the first element of this array is the file name of the program. The last element
of this array must be a NULL pointer. The environment for the new process image is taken from the
environ variable of the current process image.

The execl() function is similar to execv(), but the argv strings are specified individually instead of
as an array. A null pointer must be passed as the last such argument.

The execvp() function is similar to execv(), except that it searches the directories listed in the PATH
environment variable to find an executable matching the specified file name if it does not contain a slash.

The execvp()function is useful for executing system utility programs, because it looks for them in the
places that the user has chosen. Shells use it to run the commands that user’s type.

The execlp()function is like execl(), except that it performs the same file name searching as the
execvp()function.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 10 of 16

These functions normally don't return, since execution of a new program causes the currently executing
program to go away completely. A value of -1 is returned in the event of a failure. If execution of the new
file succeeds, it updates the access time field of the file as if the file had been read.

Executing a new process image completely changes the contents of memory, copying only the argument
and environment strings to new locations. But many other attributes of the process are unchanged:
• The process ID and the parent process ID.
• Session and process group membership.
• Real user ID and group ID, and supplementary group IDs.
• Current working directory and root directory.
• File mode creation mask.
• Process signal mask.
• Pending signals.
• Elapsed processor time associated with the process.

Examples:
The following programs exec the commands "ls -l -a" and "echo hello there" using the four
most-used forms of exec.

15) Enter each of the four programs below, compile, and run them. Observe the output.
/* Using execl */

#include <stdio.h>
#include <unistd.h>
main() {
execl("/bin/ls", /* program to run – we give the full path */
"ls", /* name of program sent to argv[0] */
"-l", /* first parameter (argv[1])*/
"-a", /* second parameter (argv[2]) */
NULL); /* terminate arg list */

/* This will be printed only on error and not otherwise */

printf ("EXEC Failed\n");
}

/* Using execlp */

#include <stdio.h>
#include <unistd.h>
main() {
execlp("ls", /* program to run – PATH will be searched */
"ls", /* name of program sent to argv[0] */
"-l", /* first parameter (argv[1])*/
"-a", /* second parameter (argv[2]) */
NULL); /* terminate arg list */

/* This will be printed only on error and not otherwise */

printf ("EXEC Failed\n");
}

/* Using execv */
/* Run with a message on the command line, this message will be written to the output */

#include <stdio.h>
#include <unistd.h>
main(int argc, char *argv[]) {
execv("/bin/echo", /* program to run – we give the full path */
&argv[0]); /* needs to pass name of the program in argv[0] */

/* This will be printed only on error and not otherwise */

printf ("EXEC Failed\n");
}

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 11 of 16

 /* Using execvp */
/* Run with a message on the command line, this message will be written to the output */

#include <stdio.h>
#include <unistd.h>
main(int argc, char *argv[]) {
execvp("echo", /* program to run – PATH will be searched */
&argv[0]); /* needs to pass name of the program in argv[0] */

/* This will be printed only on error and not otherwise */

printf ("EXEC Failed\n");
}

We can also have the program create a child process to execute a command. The following program
forks a child process to execute the ls command.

16) Run the following program several times.

/* Run the ls command from a child process */

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

main()
{
pid_t forkresult;
printf("%d: I am the parent. Remember my number!\n", getpid());
printf("%d: I am now going to fork ... \n", getpid());

forkresult = fork();

if(forkresult != 0) /* the parent will execute this code */

{
printf("%d: My child's pid is %d\n", getpid(), forkresult);
}
else /* forkresult=0 the child will execute this code */
{
printf("%d: Hi ! I am the child.\n", getpid());
printf("%d: I'm now going to exec ls!\n\n\n", getpid());

execlp("ls", "ls", NULL);

/* At this point, the child is still here! This means that the exec has failed */
printf("%d: AAAAH !! My EXEC failed !!!!\n", getpid());
exit(1);
}

/* From this point on, only the parent can execute the following statements */
printf("%d: I am the parent again.\n", getpid());
}

17) Observe the outputs of the different runs of the above program.

You should be able to get different ordering of the output lines (sometimes the parent finished
before the child, or vice versa). This means that after the fork, the two processes are no longer
synchronized. The following is a sample output:
4790: I am the parent. Remember my number!
4790: I am now going to fork ...
4790: My child's pid is 4791
4790: I am the parent again.
4791: Hi ! I am the child.
4791: I'm now going to exec ls!
$ a.out exec-child.c execl-ls.c execlp-ls.c execv-echo.c
exec-child execl-ls execlp-ls execv-echo
$

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 12 of 16

Process Completion Status:
If the exit status value of the child process is zero, then the status value reported by wait is also zero.
You can test for other kinds of information encoded in the returned status value using the following
macros. These macros are defined in the header file “sys/wait.h”:

Macro Name Syntax Function

This macro returns a nonzero value if the child
WIFEXITED int WIFEXITED (int status) process terminated normally with exit() or
_exit().
If WIFEXITED is true of status, this macro
WEXITSTATUS int WEXITSTATUS (int status) returns the low-order 8 bits of the exit status
value from the child process.
This macro returns a nonzero value if the child
WIFSIGNALED int WIFSIGNALED (int status) process terminated because it received a signal
that was not handled.
If WIFSIGNALED is true of status, this macro
WTERMSIG int WTERMSIG (int status) returns the signal number of the signal that
terminated the child process.
This macro returns a nonzero value if the child
WCOREDUMP int WCOREDUMP (int status)
process terminated and produced a core dump.

This macro returns a nonzero value if the child

WIFSTOPPED int WIFSTOPPED (int status)
process is stopped.
If WIFSTOPPED is true of status, this macro
WSTOPSIG int WSTOPSIG (int status) returns the signal number of the signal that
caused the child process to stop.

Example 1:
The following program forks, then the parent process waits for the child, while the child process asks
the user to type in a number from 0 to 255 then exits, returning that number as status.
/* wait-exit status example 1 */
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
main() {
int number=0, statval;
printf("%d: I'm the parent !\n", getpid());
printf("%d: number = %d\n", getpid(), number);
printf("%d: forking ! \n", getpid());
if(fork() == 0) { /* Child */
printf("%d: I'm the child !\n", getpid());
printf("%d: number = %d\n", getpid(), number);
printf("%d: Enter a number : ", getpid());
scanf("%d", &number);
printf("%d: number = %d\n", getpid(), number);
printf("%d: exiting with value %d\n", getpid(), number);
exit(number);
}
printf("%d: number = %d\n", getpid(), number); /* Parent */
printf("%d: waiting for my kid !\n", getpid());
wait(&statval);
if(WIFEXITED(statval))
printf("%d: my kid exited with status %d\n", getpid(), WEXITSTATUS(statval));
else
printf("%d: My kid was killed off !! \n", getpid());
}

18) Run the above program and observe its output, here is a sample:

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 13 of 16

 4996: I'm the parent !
4996: number = 0
4996: forking !
4996: number = 0
4996: waiting for my kid !
4997: I'm the child !
4997: number = 0
4997: Enter a number : 77
4997: number = 77
4997: exiting with value 77
4996: my kid exited with status 77
$

Example 2:
The following program spawns two children, then waits for their completion and behaves differently
according to which one is finished.
/* wait-exit status example 2 */
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
main() {
pid_t whichone, first, second;
int howmany, status;
if((first = fork()) == 0) { /* Parent spawns 1st child */
printf("Hi, I am the first child, and my ID is %d\n", getpid());
sleep(10);
exit(0);
}
else if(first == -1) { /* 1st fork did not succeed */
perror("1st fork: something went wrong\n");
exit(1);
}
else if((second = fork()) == 0) { /* Parent spawns 2nd child */
printf("Hi, I am the second child, and my ID is %d\n", getpid());
sleep(15);
exit(0);
}
else if(second == -1) { /* 2nd fork did not succeed */
perror("2nd fork: something went wrong\n");
exit(1);
}
printf("This is parent\n"); /* Parent */
howmany = 0;
while(howmany < 2) { /* wait twice until a child terminates */
whichone = wait(&status); /* status lower 16-bits is status info. */
howmany++;
if(whichone == first)
printf("First child exited ");
else
printf("Second child exited ");

if((status & 0xffff) == 0) /* test lower 16-bits of status, 0 = ok */

printf("correctly.\n");
else
printf("incorrectly.\n");
}
}

19) Run the above program and observe its output:

This is parent
Hi, I am the first child, and my ID is 4999
Hi, I am the second child, and my ID is 5000
First child exited correctly.
Second child exited correctly.
$

20) Try changing the argument passed to exit() in one of the children in the above program, to a
value other than zero, and run the program again. Observe the new output.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 14 of 16

Process Groups:
Every process in Linux is member of a unique process group, identified by its process group ID. When a
process is created, it becomes a member of the process group of its parent. By convention, the process
group ID of a process group equals the process ID of the first member of the process group, called the
process group leader.

Getting the Process Group - getpgrp() and getpgid():

A process can find the ID of its process group by using the system calls getpgrp(), or getpgid(0). If
you want to find the process group ID for process p, you use the system call, getpgid(p). At the shell,
you can use the command ps j to display a list of processes in the system showing the following column
headings:

PPID(parent process ID) PID(process ID) PGID(process group ID) SID(session ID)

Process Group Creation - setpgrp() and setpgid():

The setpgrp() system call function creates a new process group. When a process calls this function it
becomes the new group’s group leader. The setpgid() system call function adds a process to a process
group. For example, a process pid is put into the process group pgid by:

setpgid(pid, pgid);

If pgid == pid or pgid == 0, then this function call creates a new process group with process group
leader pid. Otherwise, this puts pid into the already existing process group pgid. A zero pid refers to
the current process. The call setpgrp() is equivalent to setpgid(0,0).

The needed headers are:

#include <sys/types.h>
#include <unistd.h>
Function Syntax: pid_t setpgrp(void)
int setpgid(pid_t pid, pid_t pgid)

Signaling and waiting:

One can signal all members of a process group at once by:

killpg(pgrp, sig);

Also, one can wait for children in his own process group by:

waitpid(0, &status, ...);

Or in a specified process group by:

waitpid(-pgrp, &status, ...);

For more about this topic, see the manual pages for both functions.

Example:
The next program forks, the child process changes group and exits, the parent waits for it then exits.

21) Compile and Run the following program to understand the process of process groups creation.
22) Observe the output of the program. A sample output follows:

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 15 of 16

 /* Process group example */
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
main() {
pid_t parent_pid, child_pid, fork_pid, wait_pid;
pid_t parent_grp, child_grp, grpid;
int child_stat, exit_val;
exit_val = 10;
parent_pid = getpid();
parent_grp = getpgrp();
printf("\nParent process: process ID: %ld group ID: %ld\n",(long)parent_pid, (long)parent_grp);
fork_pid = fork();
switch(fork_pid) {
case -1: /* error */
perror("FORK FAILED\n");
errno = 0;
break;
case 0: /* child */
child_pid = getpid();
child_grp = getpgrp();
printf("Child process: process ID: %ld group ID: %ld parent process ID: %ld\n",
(long)child_pid, (long)child_grp, (long)getppid());
grpid = setpgrp(); /* change the group of child */
setpgid(child_pid, grpid); /* does same thing – redundant */
child_grp = getpgrp();
printf("Child process again: process ID: %ld group ID: %ld parent process ID: %ld\n",
(long)child_pid, (long)child_grp, (long)getppid());
printf("Child process: terminate with \"exit\" - value: %d\n", exit_val);
exit(exit_val);
break;
default:
printf("Parent process: child process with ID %ld created.\n", (long)fork_pid);
wait_pid = wait(&child_stat);
if(wait_pid == -1) {
perror("wait");
errno = 0;
}
else
printf("Parent process: child process %ld has terminated.\n", (long)wait_pid);
}
}

The next lines show a sample output of the above program:

Parent process: process ID: 6124 group ID: 6124
Parent process: child process with ID 6125 created.
Child process: process ID: 6125 group ID: 6124 parent process ID: 6124
Child process again: process ID: 6125 group ID: 6125 parent process ID: 6124
Child process: terminate with "exit" - value: 10
Parent process: child process 6125 has terminated.

Important Notes:
1. The Shell acts as the parent process. All processes started by the user are the children of his shell.

2. The status of a Linux process is shown as a column of the process table when viewed by the
execution of the ps command. States may be: R: running, O: orphan, S: sleeping, Z: zombie.

3. The child process is given the time slice before the parent process. This is quite logical. For
example, we do not want the process started by us to wait until its parent, the Linux shell finishes.
This will explain the order in which the print statement is executed by the parent and the children.

4. The call to the wait() function results in a number of actions. A check is first made to see if the
parent process has any children. If it does not, a -1 is returned by wait(). If the parent process
has a zombie child, that child's PID is returned and it is removed from the process table. However
if the parent process has a child that is not terminated, the parent is suspended till it receives a
signal. The signal is received as soon as a child terminates.

Dr. A. M. Al-Qasimi EE463 – Lab 7 Page 16 of 16