University of Central Punjab

FOIT (Operating Systems)  

GL- 4 
 

Topic to be covered 
● Monitoring Processes 
○ ps 
○ pstree 
 

● Process Identification: 
○ getpid() 
○ getppid() 
 
● Process Creation 
○ fork () 
 
● Process Completion 
○ wait (int *) 
○ exit (int) 

● Orphan Process 
● Zombie Process 
● Process Binary Replacement 
○ exec () 

Objectives 
● Students are able to create new process in linux. 
● Students are able to load different programs binaries in current 
process 
● Students are able to handle the termination of the process.   
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 

Monitoring Processes 
To monitor the state of your processes under Linux use the p
​ s​ ​command. 

ps 

This option list all the processes owned by you and associated with 
your terminal. 
The information displayed by the “​ps​”​ ​command varies according 
to which command option(s) you use and the type of UNIX that you 
are using. 

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) COMMAND 

Exercise: 

1.​ T
​ o display information about your processes that are currently running. 

ps 

2.​ T
​ o display tree structure of your processes.

​pstree 

Process Identification: 
The ​pid_t​ ​data type represents process IDs which is basically a signed integer type (​int​). You can get 
the process ID of a process 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 file ‘​unistd.h​’ and ‘​sys/types.h​’ to use these functions. 
 
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 
pid_t getpid() 

The ​getpid()​function returns the process ID of the current process. 

 
Pid_t getppid() 

The ​getppid()​function returns the process ID of the parent of the current process. 

Process Creation: 
The fork​ ​function creates a new process. 
 
pid_t fork()  
 

● On Success
○ Return a value 0​ ​ i​ n the child process  
○ Return the c
​ hild's process ID​ ​in the parent process. 

● On Failure
○ Returns a value -​ 1 i​ n the parent process and no child is created. 

Graded Task 1: (2 Marks) 

#include <stdio.h> 

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

int main(void) 

{ 

printf("Hello World!\n"); 

pid_t result = fork( ); 

printf("I am after forking\n"); 

printf("\t I am process %d.\n", getpid( )); 

return 0; 

}
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 
 

Output: 

Graded Task 2: (2 Marks) 

#include <stdio.h> 
#include <unistd.h> /* contains fork prototype */ 
int main(void) 
{ 
pid_t pid; 
printf("Hello World!\n"); 
printf("I’m the parent process & pid is:%d.\n",getpid());  
printf("Here I am before use of forking\n"); 
pid = fork(); 
printf("Here I am just after forking\n"); 
if (pid == 0) 
{ 
printf("I am the child process and pid is:%d.\n",getpid()); 
} 
else if(pid>0) 
{ 
printf("I am the parent process and pid is: %d .\n",getpid()); 
} 
  else 
{ 
  printf(“Error fork failed\n”); 
} 
return 0; 
} 

Output: 

 
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 

Process Completion: 
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​". 
 
pid_t wait (int * status) 
 
wait() ​will force a parent process to wait for a child process to stop or terminate. w
​ ait() ​return the pid 
of the child or ​-1 ​for an error. The exit status of the child is returned to ​status​. 
 
void exit (int status) 
 
exit() ​terminates  the  process  which  calls  this  function  and  returns  the  exit  status  value.  Both 
UNIX and C (forked) programs can read the status value. 

Graded Task 3: (2 Marks) 

#include <stdio.h> 
#include <sys/wait.h> /* contains prototype for wait*/  
#include <stdlib.h>  
#include <unistd.h> /* contains fork prototype */ 
int main(void) 
{ 
pid_t pid;  
int status; 
printf("Hello World!\n");  
pid = fork( ); 
if (pid <0) /* check for error in fork */ 
{ 
perror("bad fork"); 
exit(1); 
} 
if (pid == 0) 
{ 
printf("I am the child process.\n"); 
} 
else 
{ 
wait(&status); /* parent waits for child to finish */  
printf("I am the parent process.\n"); 
} 
} 
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 

Output: 

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

Graded Task 4: (2 Marks)

#include <stdio.h> 
#include <sys/wait.h> /* contains prototype for wait*/  
#include <stdlib.h>  
#include <unistd.h> /* contains fork prototype */ 
 
int main() 
{ 
pid_t pid ; 
printf("I am the original process with PID %d and PPID %d.\n", getpid(), getppid()) ; 
pid = fork ( ) ;  
if ( pid > 0 )  
{ 
printf("I'am the parent with PID %d and PPID %d.\n",getpid(), getppid()) ; 
printf("My child's PID is %d\n", pid ) ; 
} 
else if (pid==0)  
{ 
  sleep(4); 
printf("I'm the child with PID %d and PPID %d.\n", getpid(), getppid()) ;  
} 
printf ("PID %d terminates.\n", getpid()) ; 
} 

Output: 

 
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 

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​. 
 

Graded Task 5: (2 Marks) 

#include <stdio.h> 
#include <stdlib.h>  
#include <unistd.h> /* contains fork prototype */ 
int main ( ) 
{ 
pid_t pid ; 
pid = fork();  
if ( pid > 0 )  /* pid is non-zero, so I must be the parent */ 
{ 
While (1){ 
sleep(100); 
} 
} 
else if(pid==0)   
{ 
exit (0) ;   
} 
} 

Output: 

   
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 

Process Binary Replacement:

Forking provides a way for an existing process to start a new one, but what about the case where the 
new process is not part of the same program as parent process? This is the case in the shell; when a 
user starts a command it needs to run in a new process, but it is unrelated to the shell. 

This is where the ​exec​ system call comes into play exec will replace the contents of the currently 
running process with the information from a program binary. The following code replaces the child 
process with the binary created for hello.c 
 

Step 1:​ Create a file “hello.c” and type following source code
#include <stdio.h> 
int main() 
{ 
printf("Hello World\n"); 
} 
 

Step 2:​ Compile and make a binary file named hello.out

Step3:​ Create another file “parent.c”. Type following code.

#include <stdio.h> 
#include <unistd.h> /* contains fork prototype */ 
int main(void) 
{ 
pid_t pid; 
printf("I am the parent process and pid is : %d.\n",getpid()); 
printf("Here I am before use of forking\n");  
pid = fork(); //new process is created 
printf("Here I am just after forking\n"); //Child process will start execution from this line 
if (pid == 0) 
{ 
printf("I am the child process and pid is :%d.\n",getpid()); 
printf(“I am loading „hello‟ process\n”); 
execv(“hello.out”,”hello.out”,NULL); 
} 
else 
printf("I am the parent process and pid is: %d.\n",getpid()); 
} 
   
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 
 

Graded Task 6: (11 +2+2+2+3=20 Marks) 

You have to create a file having name ​Math.c​ and implement functions of the following prototypes in it. 
  
void sum(int a , int b); 
void subtract(int a , int b); 
void multiply(int a , int b); 
void divide(int a , int b); 
void fib(int a) 
void fact(int a) 
void even(int a) 
void odd(int a) 
void prime(int a) 
void square(int a) 
void cube(int a) 
  
Write driver code in it as well. Now create an executable file with name ​math.out 
 

Create another file name parent.c parent.c received command line argument (containing relevant 
inputs and function name which you have created in math.c) and pass to child process, then child 
process load the binary math.out and execute that particular function. 

Sample Output 1: 

./parent.out 2 3 sum 

Math.out loaded 

sum=5 

Sample Output 2: 

./parent.out 3 prime 

Math.out loaded 

3 is a prime number 

 
 University of Central Punjab
FOIT (Operating Systems)  
GL- 4 
 
 
 

Graded Task 7: (2 +2+1+5=10 Marks) 

The Collatz conjecture concerns what happens when we take any positive integer n and apply the 
following algorithm: 
 
N = N/2 if n is even 
N = 3 X N+1 if n is odd 
 
The conjecture states that when this algorithm is continually applied, all positive integers will eventually 
reach 1.  
For example, if n = 35, the 
sequence is 
35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1 
Write a C program using the fork() system call that generates this sequence in the child process. The 
starting number will be provided from the command line. For example, if 8 is passed as a parameter on 
the command line, the child process will output 8, 4, 2, 1. Because the parent and child processes have 
their own copies of the data, it will be necessary for the child to output the sequence. Have the parents 
invoke the wait() call to wait for the child process to complete before exiting the program. Perform 
necessary error checking to ensure that a positive integer is passed on the command line