Sukkur Institute of Business Administration University

Department of Electrical Engineering

CSE-311: Operating Systems, Fall 2023

Lab # 05:

Processes in Linux/Unix
Instructor: Dr Mumtaz Ali Kaloi

Submission Profile

Name: Submission Date:

Enrolment ID: Receiving Authority Name and Signature:

Comments: ______________________________________________________________________
 Objectives:

 System call for overwriting a process image

Introduction:
Variable Length Argument in C:

Variable length argument is a feature that allows a function to receive any number of arguments. There
are situations where we want a function to handle variable number of arguments according to
requirement. 1) Sum of given numbers. 2) Minimum of given numbers. and many more. Variable number
of arguments are represented by three dotes (…) Below is an example, to find minimum of given set of
integers.

// C program to demonstrate use of variable

// number of arguments.

#include <stdarg.h>

#include <stdio.h>

// this function returns minimum of integer

// numbers passed. First argument is count

// of numbers.

int min(int arg_count, ...)

int i;

int min, a;

// va_list is a type to hold information about

// variable arguments

va_list ap;
 // va_start must be called before accessing

// variable argument list

va_start(ap, arg_count);

// Now arguments can be accessed one by one

// using va_arg macro. Initialize min as first

// argument in list

min = va_arg(ap, int);

// traverse rest of the arguments to find out minimum

for (i = 2; i <= arg_count; i++)

if ((a = va_arg(ap, int)) < min)

min = a;

// va_end should be executed before the function

// returns whenever va_start has been previously

// used in that function

va_end(ap);

return min;

// Driver code
int main()

int count = 5;

printf("Minimum value is %d", min(count, 12, 67, 6, 7, 100));

return 0;

Examle2

// C program to demonstrate working of

// variable arguments to find average

// of multiple numbers.

#include <stdarg.h>

#include <stdio.h>

int average(int num, ...)

va_list valist;

int sum = 0, i;

va_start(valist, num);

for (i = 0; i < num; i++)

sum += va_arg(valist, int);

 va_end(valist);

return sum / num;

// Driver code

int main()

printf("Average of {3, 4} = %d\n", average(2, 3, 4));

printf("Average of {5, 10, 15} = %d\n", average(3, 5, 10, 15));

return 0;

Replacing a Process Image:

There is a whole family of related functions grouped under the exec heading. They differ in the way that
they start processes and present program arguments. An exec function replaces the current process with a
new process specified by the path or file argument. You can use exec functions to “hand off” execution
of your program to another. For example, you could check the user’s credentials before starting another
application that has a restricted usage policy. The exec functions are more efficient than system because
the original program will no longer be running after the new one is stated.

#include <unistd.h>
char **environ;
int execl(const char *path, const char *arg0, ..., (char *)0);
int execlp(const char *file, const char *arg0, ..., (char *)0);
int execle(const char *path, const char *arg0, ..., (char *)0, char *const
envp[]);
int execv(const char *path, char *const argv[]);
 int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char *const envp[]);
These functions belong to two types. execl, execlp, and execle take a variable number of arguments
ending with a null pointer. execv and execvp have as their second argument an array of strings. In both
cases, the new program starts with the given arguments appearing in the argv array passed to main. These
functions are usually implemented using execve, though there is no requirement for it to be done this way.
The functions with names suffixed with a p differ in that they will search the PATH environment variable
to find the new program executable file. If the executable isn’t on the path, an absolute filename,
including directories, will need to be passed to the function as a parameter. The global variable environ is
available to pass a value for the new program environment. Alternatively, an additional argument to the
functions execle and execve is available for passing an array of strings to be used as the new program
environment. If you want to use an exec function to start the ps program, you can choose from among the
six exec family functions, as shown in the calls in the code fragment that follows:

#include <unistd.h>
/* Example of an argument list */
/* Note that we need a program name for argv[0] */
char *const ps_argv[] =
{“ps”, “ax”, 0};
/* Example environment, not terribly useful */
char *const ps_envp[] =
{“PATH=/bin:/usr/bin”, “TERM=console”, 0};
/* Possible calls to exec functions */
execl(“/bin/ps”, “ps”, “ax”, 0); /* assumes ps is in /bin */
execlp(“ps”, “ps”, “ax”, 0); /* assumes /bin is in PATH */
execle(“/bin/ps”, “ps”, “ax”, 0, ps_envp); /* passes own environment */
execv(“/bin/ps”, ps_argv);
execvp(“ps”, ps_argv);
execve(“/bin/ps”, ps_argv, ps_envp);

execlp call:

Example# 1

Let’s modify the example to use an execlp call:

#include <unistd.h>
 #include <stdio.h>
#include <stdlib.h>
int main() {
printf(“Running ps with execlp\n”);
execlp(“ps”, “ps”, “ax”, 0);
printf(“Done.\n”);
exit(0); }
When you run this program, pexec.c, you get the usual ps output, but no Done. message at all. Note also
that there is no reference to a process called pexec in the output.
$ ./pexec
Running ps with execlp
PID TTY STAT TIME COMMAND
1 ? S 0:03 init [5]
...
1262 pts/1 Ss 0:00 /bin/bash
1273 pts/2 S 0:00 su -
1274 pts/2 S+ 0:00 -bash
1463 pts/1 SN 0:00 oclock
1465 pts/1 S 0:01 emacs Makefile
1514 pts/1 R+ 0:00 ps ax

Duplicating a Process Image:

To use processes to perform more than one function at a time, you can either use threads, or create an
entirely separate process from within a program, as init does, rather than replace the current thread of
execution, as in the exec case. You can create a new process by calling fork. This system call duplicates
the current process, creating a new entry in the process table with many of the same attributes as the
current process. The new process is almost identical to the original, executing the same code but with its
own data space, environment, and file descriptors. Combined with the exec functions, fork is all you need
to create new processes.

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);
As you can see in Figure 1-1, the call to fork in the parent returns the PID of the new child process. The
new process continues to execute just like the original, with the exception that in the child process the call
to fork returns 0. This allows both the parent and child to determine which is which. If fork fails, it returns
-1. This is commonly due to a limit on the number of child processes that a parent may have
(CHILD_MAX), in which case errno will be set to EAGAIN. If there is not enough space for an entry in
the process table, or not enough virtual memory, the errno variable will be set to ENOMEM.

A typical code fragment using fork is:

Pid_t new_pid;
New_pid = fork ()
Switch (new_pid) {
Case -1: /* Error*/
Break;
Case 0: /* We are child */
Break;
Default: /*We are parent*/
Break;
}

Figure 1-1

Example# 2
Fork

Let’s look at a simple example, fork1.c:

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
pid_t pid;
char *message;
int n;
printf(“fork program starting\n”);
pid = fork();
switch(pid) {
case -1:
perror(“fork failed”);
exit(1);
case 0:
message = “This is the child”;
n = 5;
break;
default:
message = “This is the parent”;
n = 3;
break;
for(; n > 0; n--) {
puts(message);
sleep(1);
}
exit(0);
}
This program runs as two processes. A child is created and prints a message five times. The original
process (the parent) prints a message only three times. The parent process finishes before the child has
printed all of its messages, so the next shell prompt appears mixed in with the output.
$ ./fork1
fork program starting
This is the child
This is the parent
This is the parent
This is the child
This is the parent
This is the child
$This is the child
This is the child
How it works:
When fork is called, this program divides into two separate processes. The parent process is identified by
a nonzero return from fork and is used to set a number of messages to print, each separated by one
second.

Waiting for a Process:

When you start a child process with fork, it takes on a life of its own and runs independently. Sometimes,
you would like to find out when a child process has finished. For example, in the previous program, the
parent finishes ahead of the child and you get some messy output as the child continues to run. You can
arrange for the parent process to wait until the child finishes before continuing by calling wait.
#include <sys/types.h>
#include <sys/wait.h>
pid_t wait(int *stat_loc);

The wait system call causes a parent process to pause until one of its child processes is stopped. The call
returns the PID of the child process. This will normally be a child process that has terminated. The status
information allows the parent process to determine the exit status of the child process, that is, the value
returned from main or passed to exit. If stat_loc is not a null pointer, the status information will be written
to the location to which it points.
Wait:

You modify the program slightly so you can wait for and examine the child process exit status. Call the
new program wait.c.

Example# 3

#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int main() {
pid_t pid;
char *message;
int n;
int exit_code;
printf(“fork program starting\n”);
pid = fork();
switch(pid){
case -1:
perror(“fork failed”);
exit(1);
case 0:
message = “This is the child”;
n = 5;
exit_code = 37;
break;
default:
message = “This is the parent”;
n = 3;
exit_code = 0;
break;
}
for(; n > 0; n--) {
puts(message);
sleep(1);
}

This section of the program waits for the child process to finish.

if (pid != 0) {
int stat_val;
pid_t child_pid;
child_pid = wait(&stat_val);
printf(“Child has finished: PID = %d\n”, child_pid);
if(WIFEXITED(stat_val))
printf(“Child exited with code %d\n”, WEXITSTATUS(stat_val));
else
printf(“Child terminated abnormally\n”);
}
exit(exit_code);
}

When you run this program, you see the parent wait for the child.
$ ./wait
fork program starting
This is the child
This is the parent
This is the paren
tThis is the child
This is the parent
This is the child
This is the child
This is the child
Child has finished: PID = 1582
Child exited with code 37
$
How it works:
The parent process, which got a nonzero return from the fork call, uses the wait system call to suspend its
own execution until status information becomes available for a child process. This happens when the
child calls exit; we gave it an exit code of 37. The parent then continues, determines that the child
terminated normally by testing the return value of the wait call, and extracts the exit code from the status
information.

Lab Exercise:
Q1. What is role of functions execl(), execle(), execv(), execvp(), and execve()
Q2. Why we use fork() function