Final OSL Labmanual 2017-18

314454::OPERATING SYSTEM LABORATORY
TEIT (2015 Course)

Semester - II
Teaching Scheme Examination Scheme

Practical : 4 Hrs. / Week Term work : 50 Marks
Practical 50 Marks
LABORATORY MANUAL V 4.0
DEPARTMENT OF INFORMATION TECHNOLOGY

NBN Sinhgad School of Engineering
2017-2018
Department of Information Technology Page 1 of 85

VISION
To provide excellent Information Technology education by building strong teaching and research environment.
MISSION
1) To transform the students into innovative, competent and high quality IT professionals to meet
the growing global challenges.
2) To achieve and impart quality education with an emphasis on practical skills and social
relevance.
3) To endeavor for continuous up-gradation of technical expertise of students to cater to the
needs of the society.
4) To achieve an effective interaction with industry for mutual benefits.

PROGRAM EDUCATIONAL OBJECTIVES
The students of Information Technology course after passing out will
1) Graduates of the program will possess strong fundamental concepts in mathematics, science,
engineering and Technology to address technological challenges.
2) Possess knowledge and skills in the field of Computer Science & Engineering and Information
Technology for analyzing, designing and implementing complex engineering problems of any
domain with innovative approaches.
3) Possess an attitude and aptitude for research, entrepreneurship and higher studies in the field
of Computer Science & Engineering and Information Technology.
4) Have commitment to ethical practices, societal contributions through communities and life-
long learning.
5) Possess better communication, presentation, time management and team work skills leading
to responsible & competent professionals and will be able to address challenges in the field of
IT at global level.

PROGRAM OUTCOMES
The students in the Information Technology course will attain:
a. an ability to apply knowledge of computing, mathematics including discrete mathematics as

well as probability and statistics, science, and engineering and technology;
b. an ability to define a problem and provide a systematic solution with the help of conducting
experiments, as well as analyzing and interpreting the data;
c. an ability to design, implement, and evaluate a software or a software/hardware system,
component, or process to meet desired needs within realistic constraints;
d. an ability to identify, formulate, and provide systematic solutions to complex engineering
problems;
e. an ability to use the techniques, skills, and modern engineering technologies tools, standard
processes necessary for practice as a IT professional;
f. an ability to apply mathematical foundations, algorithmic principles, and computer science
theory in the modeling and design of computer-based systems with necessary constraints and
assumptions;
g. an ability to analyze the local and global impact of computing on individuals, organizations and
society;
h. an ability to understand professional, ethical, legal, security and social issues and
responsibilities;
i. an ability to function effectively as an individual or as a team member to accomplish a desired
goal(s);
j. an ability to engage in life-long learning and continuing professional development to cope up
with fast changes in the technologies/tools with the help of electives, professional
organizations and extra-curricular activities;
k. an ability to communicate effectively in engineering community at large by means of effective
presentations, report writing, paper publications, demonstrations;
l. an ability to understand engineering, management, financial aspects, performance,
optimizations and time complexity necessary for professional practice;
m. an ability to apply design and development principles in the construction of software systems
of varying complexity.

Compliance
Document Control
Reference Code
Version No 4.0
Compliance Status Complete
Revision Date 07 June 2017
Security Classification Department Specific
Document Status Definitive
Review Period Yearly
Document History
Revision
Revision Date Reason For Change
No.
1.0 15 Dec 2014 University Syllabus Modification - Course 2012
2.0 20 Nov 2015 Revision in Contents
3.0 18 Nov 2016 Minor modifications
4.0 07 June 2017 University Syllabus Modification - Course 2015
Summary of Changes to Operating System Laboratory Manual
Sr. No Changes Change type

01 Detailed Conceptual elaboration of each assignment
02 Contents Modification
03 Minor changes
04 Assignment addition & content modification

Syllabus
314447 : SOFTWARE LABORATORY – II
Teaching Scheme: Credit: 02

Practical : 4 Hours/Week
Examination Scheme:
Term Work : 25 Marks
Practical : 50 Marks
Prerequisites:
1. C programming.
2. Fundamental of Data Structures.
Course Objectives:
1. To introduce and learn Linux commands required for administration.
2. To learn shell programming concepts and applications.
3. To demonstrate the functioning of OS basic building blocks like processes, threads under the LINUX.
4. To demonstrate the functioning of OS concepts in user space like concurrency control (process
Synchronization, mutual exclusion & deadlock) and file handling in LINUX.
5. To aware Linux kernel source code details.
6. To demonstrate the functioning of OS concepts in kernel space like embedding the system call in any
LINUX kernel.
Course Outcomes:
1. To understand the basics of Linux commands and program the shell of Linux.
2. To develop various system programs for the functioning of operating system.
3. To implement basic building blocks like processes, threads under the Linux.
4. To develop various system programs for the functioning of OS concepts in user space like
Concurrency control and file handling in Linux.
5. To design and implement Linux Kernel Source Code.
6. To develop the system program for the functioning of OS concepts in kernel space like embedding
the system call in any Linux kernel.
Laboratory Assignments
Assignment No. 1: Shell programming

Write a program to implement an address book with options given below:
a) Create address book. b) View address book. c) Insert a record. d) Delete a record.
e) Modify a record. f) Exit.
Assignment No. 2: Process control system calls: The demonstration of FORK, EXECVE and WAIT system
calls along with zombie and orphan states.

a. Implement the C program in which main program accepts the integers to be sorted. Main
program uses the FORK system call to create a new process called a child process. Parent process
sorts the integers using sorting algorithm and waits for child process using WAIT system call to
sort the integers using any sorting algorithm. Also demonstrate zombie and orphan states.
b. Implement the C program in which main program accepts an integer array. Main program uses
theFORK system call to create a new process called a child process. Parent process sorts an
integer array and passes the sorted array to child process through the command line arguments
ofEXECVE system call. The child process uses EXECVE system call to load new program that uses
this sorted array for performing the binary search to search the particular item in the array.
Assignment No. 3: Implement multithreading for Matrix Multiplication using pthreads.
Assignment No. 4: Thread synchronization using counting semaphores. Application to demonstrate:

Producer-consumer problem with counting semaphores and mutex.
Assignment No. 5: Thread synchronization and mutual exclusion using mutex. Application to
demonstrate: Reader-Writer problem with reader priority.
Assignment No. 6: Deadlock Avoidance Using Semaphores: Implement the deadlock-free solution to
Dining Philosophers problem to illustrate the problem of deadlock and/or starvation that can occur
when manysynchronized threads are competing for limited resources.
Assignment No. 7: Inter process communication in Linux using following.
a. Pipes: Full duplex communication between parent and child processes. Parent process writes a
pathname of a file (the contents of the file are desired) on one pipe to be read by child process
and child process writes the contents of the file on second pipe to be read by parent process and
displays on standard output.
b. FIFOs: Full duplex communication between two independent processes. First process accepts
sentences and writes on one pipe to be read by second process and second process counts
number of characters, number of words and number of lines in accepted sentences, writes this
output in a text file and writes the contents of the file on second pipe to be read by first process
and displays on standard output.
Assignment No. 8: Inter-process Communication using Shared Memory using System V. Application to
demonstrate: Client and Server Programs in which server process creates a shared memory segment
and writes the message to the shared memory segment. Client process reads the message from the
sharedmemory segment and displays it to the screen.
Assignment No. 9: Implement an assignment using File Handling System Calls (Low level system calls
like open, read, write, etc).
Assignment No. 10: Implement a new system call in the kernel space, add this new system call in the
Linuxkernel by the compilation of this kernel (any kernel source, any architecture and any Linux kernel
distribution) and demonstrate the use of this embedded system call using C program in user space.

Links for Laboratory Assignments
http://homes.cs.washington.edu/~tom/nachos/
http://web.cecs.pdx.edu/~walpole/class/cse513/project/syscall.html
http://web.cecs.pdx.edu/~walpole/class/cse513/project/syscall.html

INDEX
Sr. No. Title Page No.

Shell programming
Write a program to implement an address book with options given
1 below:
a) Create address book. b) View address book. c) Insert a record. d)
Delete a record.e) Modify a record. f) Exit.
Process control system calls
2 a. Demonstration of fork, wait, zombie & orphan state
b. Demonstration of execve
3 Matrix multiplication using multithreading 27
Producer consumer problem with counting semaphores and

4 39
mutex
5 Reader-Writer problem with reader priority using mutex
6 Dining Philosophers problem Using Semaphores 48
Inter process communication in Linux using following

a. Pipe: Full duplex communication between parent and child
7 processes 52
b. Fifo: Full duplex communication between two independent
processes
8 Inter-process Communication using Shared Memory using System V. 65
9 Implement an assignment using File Handling System Calls 70
Implementation and addition of a new system call in the Linux

10 83
kernel

SCHEDULE
No. of
Sr. No. Title Week
Hrs.
Shell programming
Write a program to implement an address book with
1 options given below: 4 1
a) Create address book. b) View address book. c) Insert a
record. d) Delete a record.e) Modify a record. f) Exit.
Process control system calls
2 c. Demonstration of fork, wait, zombie & orphan state 4 2,3
d. Demonstration of execve
3 Matrix multiplication using multithreading 4 4
Producer consumer problem with counting

4 4 5
semaphores and mutex
Reader-Writer problem with reader priority using
5 4 6
mutex
6 Dining Philosophers problem Using Semaphores 4 7
Inter process communication in Linux using following

c. Pipe: Full duplex communication between parent
7 and child processes 4 8,9
d. Fifo: Full duplex communication between two
independent processes
Inter-process Communication using Shared Memory using
8 4 10
System V.
9 Implement an assignment using File Handling System Calls 4 11
Implementation and addition of a new system call in

10 4 12
the Linux kernel

Assignment No. : 1
Shell programming

ASSIGNMENTNO. 1
SHELL PROGRAMMING
AIM : Write a program to implement an address book with options given

below:
a) Create address book. b) View address book. c) Insert a record.
d) Delete a record. e) Modify a record. f) Exit.
OBJECTIVES : To study
1. Basic Shell commands
2. Shell script
THEORY :
Shell Script: Normally shells are interactive. It means shell accept command from you (via
keyboard) and execute them. But if you use command one by one (sequence of 'n' number of
commands) , the you can store this sequence of command to text file and tell the shell to
execute this text file instead of entering the commands. This is known as shell script. Shell
Script is series of command written in plain text file. This manual is meant as a brief
introduction to features found in Bash.
Exit Status:
By default in Linux if particular command/shell script is executed, it return two type of
values which is used to see whether command or shell script executed is successful or not.
(1) If return value is zero (0), command is successful.
(2) If return value is nonzero, command is not successful or some sort of error executing
command/shell script.
This value is known as Exit Status.But how to find out exit status of command or shell script?
Simple, to determine this exit Status you can use $? special variable of shell.
For e.g. (This example assumes that unknow1file doest not exist on your hard drive)
$ rm unknow1file
It will show error as follows
rm: cannot remove `unkowm1file': No such file or directory
and after that if you give command
$ echo $?

it will print nonzero value to indicate error.
User defined variables (UDV)

To define UDV use following syntax
Syntax:
variable name=value
'value' is assigned to given 'variable name' and Value must be on right side = sign.
Example:
To define variable called n having value 10
$ n=10
To print or access UDV use following syntax
Syntax:
$variablename
$ n=10
To print contains of variable 'n' type command as follows
$ echo $n
About Quotes
There are three types of quotes
Quotes Name Meaning
Double "Double Quotes" - Anything enclose in double quotes removed meaning

"
Quotes of that characters (except \ and $).
Single
' 'Single quotes' - Enclosed in single quotes remains unchanged.
quotes
` Back quote
`Back quote` - To execute command
Example:
$ echo "Today is date"
Can't print message with today's date.
$ echo "Today is `date`".

Rules for Naming variable name (Both UDV and System Variable)
(1) Variable name must begin with Alphanumeric character or underscore character (_),
followed by one or more Alphanumeric character. For e.g. Valid shell variable are as follows
HOME
SYSTEM_VERSION
(2) Don't put spaces on either side of the equal sign when assigning value to variable. For e.g.
In following variable declaration there will be no error
$ no=10
But there will be problem for any of the following variable declaration:
$ no =10
$ no= 10
$ no = 10
(3) Variables are case-sensitive, just like filename in Linux.
(4) You can define NULL variable as follows (NULL variable is variable which has no value at the
time of definition) For e.g.
$ vech=
$ vech=""
Try to print it's value by issuing following command
$ echo $vech
Nothing will be shown because variable has no value i.e. NULL variable.
(5) Do not use ?,* etc, to name your variable names.
Shell Arithmetic
Use to perform arithmetic operations.
Syntax:
expr op1 math-operator op2
Examples:
$ expr 1 + 3
$ expr 2 - 1
$ expr 10 / 2

$ expr 20 % 3
$ expr 10 \* 3
$ echo `expr 6 + 3`
Note:
expr 20 %3 - Remainder read as 20 mod 3 and remainder is 2.
expr 10 \* 3 - Multiplication use \* and not * since its wild card.
The read Statement
Use to get input (data from user) from keyboard and store (data) to variable.
Syntax:
read variable1, variable2,...variableN
Following script first ask user, name and then waits to enter name from the user via
keyboard. Then user enters name from keyboard (after giving name you have to press ENTER
key) and entered name through keyboard is stored (assigned) to variable fname.
$ vi sayH
#
#Script to read your name from key-board
#
echo "Your first name please:"
read fname
echo "Hello $fname, Lets be friend!"
Variables in Shell
To process our data/information, data must be kept in computers RAM memory. RAM
memory is divided into small locations, and each location had unique number called memory
location/address, which is used to hold our data. Programmer can give a unique name to this
memory location/address called memory variable or variable (Its a named storage location
that may take different values, but only one at a time).
In Linux (Shell), there are two types of variable:
(1) System variables - Created and maintained by Linux itself. This type of variable defined in

CAPITAL LETTERS.
(2) User defined variables (UDV) - Created and maintained by user. This type of variable
defined in lower letters.
You can see system variables by giving command like $ set, some of the important System
variables are:
System Variable Meaning
BASH=/bin/bash Our shell name
BASH_VERSION=1.14.7(1) Our shell version name
HOME=/home/vivek Our home directory
LOGNAME=students students Our logging name
OSTYPE=Linux Our Os type
PATH=/usr/bin:/sbin:/bin:/usr/sbin Our path settings
PWD=/home/students/Common Our current working directory
SHELL=/bin/bash Our shell name
You can print any of the above variables contains as follows:

$ echo $HOME
test command or [ expr ]
test command or [ expr ] is used to see if an expression is true, and if it is true it return zero(0),
otherwise returns nonzero for false.
Syntax:
test expression OR [ expression ]
Example:
Following script determine whether given argument number is positive.
if test $1 -gt 0
then
echo "$1 number is positive"
fi

test or [ expr ] works with
1.Integer ( Number without decimal point)
2.File types
3.Character strings
For Mathematics, use following operator in Shell Script
Mathematical Normal Arithmetical/

Operator in Shell Meaning Mathematical But in Shell
Script Statements
For test For [ expr ]

statement with statement with if
if command command
-eq is equal to 5 == 6 if test 5 -eq 6 if [ 5 -eq 6 ]
is not equal
-ne 5 != 6 if test 5 -ne 6 if [ 5 -ne 6 ]
to
-lt is less than 5<6 if test 5 -lt 6 if [ 5 -lt 6 ]
is less than
-le 5 <= 6 if test 5 -le 6 if [ 5 -le 6 ]
or equal to
is greater
-gt 5>6 if test 5 -gt 6 if [ 5 -gt 6 ]
than
is greater
-ge than or 5 >= 6 if test 5 -ge 6 if [ 5 -ge 6 ]
equal to
NOTE: == is equal, != is not equal.

For string Comparisons use
Operator Meaning
string1 =
string1 is equal to string2
string2

string1 !=
string1 is NOT equal to string2
string2
string1 string1 is NOT NULL or not defined
-n string1 string1 is NOT NULL and does exist
-z string1 string1 is NULL and does exist
Shell also test for file and directory types
Meaning
-s file Non empty file
-f file Is File exist or normal file and not a directory
-d dir Is Directory exist and not a file
-w file Is writeable file
-r file Is read-only file
-x file Is file is executable
Logical Operators:
Logical operators are used to combine two or more condition at a time
Operator Meaning
! expression Logical NOT
expression1 -a expression2 Logical AND
expression1 -o expression2 Logical OR
if condition
if condition which is used for decision making in shell script, If given condition is true then
command1 is executed.
Syntax:
if condition
then
command1 if condition is true or if exit status
of condition is 0 (zero)

…
…
fi
Condition is defined as:
“Condition is nothing but comparison between two values.”
For compression you can use test or [ expr ] statements or even exist status can be also used.
Loops in Shell Scripts
Bash supports:
1) for loop
2) while loop
while :
The syntax of the while is:
while test-commands
do
commands
done
Execute commands as long as test-commands has an exit status of zero.
for :
The syntax of the for is:
for variable in list
do
commands
done
Each white space-separated word in list is assinged to variable in turn and commands
executed until list is exhausted.
The case Statement
The case statement is good alternative to Multilevel if-then-else-fi statement. It enable you
to match several values against one variable. Its easier to read and write.

Syntax:
case $variable-name in
pattern1) command
...
..
command;;
pattern2) command
...
..
command;;
patternN) command
...
..
command;;
*) command
...
..
command;;
esac
The $variable-name is compared against the patterns until a match is found. The
shell then executes all the statements up to the two semicolons that are next to each other.
The default is *) and its executed if no match is found.
Conclusion: Thus in shell script we can write series of commands and execute
as a single program.

Answer the following questions.
1. What are different types of shell & differentiate them.
2. Explain Exit status of a command.
3. Explain a) User define variables.
4. System variables.
5. What is man command?
6. Explain test command.
7. Explain how shell program get executed.
8. Explain syntax of if-else, for, while, case.
9. Explain use of functions in shell and show it practically.
10. Write a menu driven shell script to execute different commands with options.
11. Execute same assignment in another shell.

Assignment No. : 2
Process Control System Calls

ASSIGNMENTNO. 2
PROCESS CONTROL SYSTEM CALLS
AIM : The demonstration of fork, execve and wait system calls along
with zombie and orphan states.
1. Implement the C program in which main program accepts the
integers to be sorted. Main program uses the fork system call
to create a new process called a child process. Parent process
sorts the integers using merge sort and waits for child process
using wait system call to sort the integers using quick sort. Also
demonstrate zombie and orphan states.
2. Implement the C program in which main program accepts an
integer array. Main program uses the fork system call to create
a new process called a child process. Parent process sorts an
integer array and passes the sorted array to child process
through the command line arguments of execve system call.
The child process uses execve system call to load new program
that uses this sorted array for performing the binary search to
search the particular item in the array.
3. Process control
4. Zombie and orphan processes
5. System calls : fork, execv
THEORY :
Process
A process is the basic active entity in most operating-system models. A process is a program in
execution in memory or in other words, an instance of a program in memory. Any program
executed creates a process. A program can be a command, a shell script, or any binary
executable or any application.

Process IDs
Each process in a Linux system is identified by its unique process ID, sometimes referred to as
pid. Process IDs are 16-bit numbers that are assigned sequentially by Linux as new processes
are created.
When referring to process IDs in a C or C++ program, always use the pid_ttypedef, which is
defined in <sys/types.h>.A program can obtain the process ID of the process it’s running in
with the getpid() system call, and it can obtain the process ID of its parent process with the
getppid() system call.
Creating Process
Two common techniques are used for creating a new process.

1. using system() function
2. using fork() system calls
1. system() function
The system function in the standard C library provides an easy way to execute a command
from within a program, much as if the command had been typed into a shell. In fact, system
creates a subprocess running the standard Bourne shell (/bin/sh) and hands the command to
that shell for execution.
The system function returns the exit status of the shell command. If the shell itself cannot be
run, system returns 127; if another error occurs, system returns –1.
2.fork system call
A process can create a new process by calling fork. The calling process becomes the parent,
and the created process is called the child. The fork function copies the parent's memory image
so that the new process receives a copy of the address space of the parent. Both processes
continue at the instruction after the fork statement (executing in their respective memory
images).
Synopsis
#include <unistd.h>
pid_t fork(void);

The fork function returns 0 to the child and returns the child's process ID to the parent. When
fork fails, it returns –1.
Wait Function
When a process creates a child, both parent and child proceed with execution from the point
of the fork. The parent can execute wait to block until the child finishes. The wait function
causes the caller to suspend execution until a child's status becomes available or until the
caller receives a signal.
Synopsis
#include <sys/wait.h>
pid_t wait(int *status);
If wait returns because the status of a child is reported, these functions return the process ID
of that child. If an error occurs, these functions return –1.
Example:
pid_tchildpid;
childpid = wait(NULL);
if (childpid != -1)
printf("Waited for child with pid %ld\n", childpid);
Status values
The status argument of wait is a pointer to an integer variable. If it is not NULL, this function
stores the return status of the child in this location. The child returns its status by calling exit,
_exit or return from main.
A zero return value indicates EXIT_SUCCESS; any other value indicates EXIT_FAILURE.
POSIX specifies six macros for testing the child's return status. Each takes the status value
returned by a child to wait as a parameter. Following are the two such macros:
Synopsis
WIFEXITED(intstat_val)
WEXITSTATUS(intstat_val)

Exec system call
Used for new program execution within the existing process. The fork function creates a copy
of the calling process, but many applications require the child process to execute code that is
different from that of the parent. The exec family of functions provides a facility for overlaying
the process image of the calling process with a new image. The traditional way to use the fork–
exec combination is for the child to execute (with an exec function) the new program while the
parent continues to execute the original code. The exec system call is used after a fork system
call by one of the two processes to replace the memory space with a new program. The exec
system call loads a binary file into memory (destroying image of the program containing the
exec system call) and go their separate ways. Within the exec family there are functions that
vary slightly in their capabilities.
Synopsis
#include <unistd.h>
extern char **environ;
Exec family
1. intexecl(const char *path, const char *arg0, ... /*, char *(0) */);
2. intexecle (const char *path, const char *arg0, ... /*, char *(0), char *constenvp[] */);
3. intexeclp (const char *file, const char *arg0, ... /*, char *(0) */);
4. intexecv(const char *path, char *constargv[]);
5. intexecve (const char *path, char *constargv[], char *constenvp[]);
6. intexecvp (const char *file, char *constargv[]);
1. Execl() and execlp():
execl()
It permits us to pass a list of command line arguments to the program to be executed.
The list of arguments is terminated by NULL.
e.g. execl("/bin/ls", "ls", "-l", NULL);
execlp()
It does same job except that it will use environment variable PATH to determine which
executable to process. Thus a fully qualified path name would not have to be used. It
can also take the fully qualified name as it also resolves explicitly.
e.g. execlp("ls", "ls", "-l", NULL);

2. Execv() and execvp()
execv()
It does same job as execl() except that command line arguments can be passed to it in
the form of an array of pointers to string.
e.g. char *argv[] = ("ls", "-l", NULL);
execv("/bin/ls", argv);
execvp()
It does same job expect that it will use environment variable PATH to determine which
executable to process. Thus a fully qualified path name would not have to be used.
e.g. execvp("ls", argv);
3. execve( )
It executes the program pointed to by filename.
intexecve(const char *filename, char *constargv[ ], char *constenvp[ ]);
Filename must be either a binary executable, or a script starting with a line of the form:
argv is an array of argument strings passed to the new program. By convention, the
first of these strings should contain the filename associated with the file being
executed. envp is an array of strings, conventionally of the form key=value, which are
passed as environment to the new program. Both argv and envp must be terminated
by a NULL pointer. The argument vector and environment can be accessed by the
called program's main function, when it is defined as:
int main(intargc, char *argv[ ] , char *envp[ ])]
execve() does not return on success, and the text, data, bss, and stack of the calling
process are overwritten by that of the program loaded.
All exec functions return –1 if unsuccessful. In case of success these functions never return to
the calling function.
Process Termination
Normally, a process terminates in one of two ways. Either the executing program calls the

exitfunction, or the program’s main functionreturns. Each process has an exit code: anumber
that the process returns to its parent. The exit code is the argument passed to the exit
function, or the value returned from main.
Zombie Processes
If a child process terminates while its parent is calling a wait function, the child process
vanishes and its termination status is passed to its parent via the wait call. But what happens,
when a child process terminates and the parent is not calling wait? Does it simply vanish? No,
because then information about its termination—such as whether it exited normally and, if so,
what its exit status is—would be lost. Instead, when a child process terminates, it becomes a
zombie process.
A zombie process is a process that has terminated but has not been cleaned up yet. It is the
responsibility of the parent process to clean up its zombie children. The wait functions do this,
too, so it’s not necessary to track whether your child process is still executing before waiting
for it. Suppose, for instance, that a program forks a child process, performs some other
computations, and then calls wait. If the child process has not terminated at that point, the
parent process will block in the wait call until the child process finishes. If the child process
finishes before the parent process calls wait, the child process becomes a zombie. When the
parent process calls wait, the zombie child’s termination status is extracted, the child process
is deleted, and the wait call returns immediately.
Orphan Process
Orphan process is the process whose parent process is dead. That is, parent process is
terminated, killed or exited but the child process is still alive.
In Linux/Unix like operating systems, as soon as parents of any process are dead, re-parenting
occurs, automatically. Re-parenting means orphaned process is immediately adopted by
special process. Thing to notice here is that even after re-parenting, the process still remains
Orphan as the parent which created the process is dead.
A process can be orphaned either intentionally or unintentionally. Sometimes a parent process
exits/terminates or crashes leaving the child process still running, and then they become
orphans. Also, a process can be intentionally orphaned just to keep it running. For example

when you need to run a job in the background which need any manual intervention and going
to take long time, then you detach it from user session and leave it there. Same way, when you
need to run a process in the background for infinite time, you need to do the same thing.
Processes running in the background like this are known as daemon process.
Finding a Orphan Process
It is very easy to spot a Orphan process. Orphan process is a user process, which is having init
process (process id 1) as parent. You can use this command in linux to find the orphan
processes.
# ps -elf | head -1; ps -elf | awk '{if ($5 == 1 && $3 != "root") {print $0}}' | head
This will show you all the orphan processes running in your system. The output from this
command confirms that they are orphan processes but does not mean that they are all
useless.
Killing a Orphan Process
As orphan processes waste server resources, it is not advised to have lots of orphan processes
running into the system. To kill a orphan process is same as killing a normal process.
# kill -15 <PID>
If that does not work then simply use
# kill -9 <PID>
Daemon Process
It is a process that runs in the background, rather than under the direct control of a user. They
are usually initiated as background processes.
vfork
It is alternative of fork. Creates a new process when exec a new program.
Comparison with fork
1. Creates new process without fully copying the address space of the parent.
2. vfork guarantees that the child runs first, until the child calls exec or exit.
3. When child calls either of these two functions (exit, exec), the parent resumes.
Input

1. An integer array with specified size.
2. An integer array with specified size and number to search.
Output
1. Sorted array.
2. Status of number to be searched.
FAQS
 Is Orphan process different from a Zombie process?
 Are Orphan processes harmful for system?
 Is it bad to have Zombie processes on your system?
 How to find an Orphan Process?
 How to find a Zombie Process?
 What is common shared data between parent and child process?
 What are the contents of Process Control Block?
Practice Assignments
Example 1
Printing the Process ID
#include <stdio.h>
#include <unistd.h>
int main()
{
printf(“The process ID is %d\n”, (int) getpid());
printf(“The parent process ID is %d\n”, (int) getppid());
return 0;
}
Example 2
Using the system call

#include <stdlib.h>
int main()
{
intreturn_value;
return_value=system(“ls –l /”);
return return_value;
}
Example 3
Using fork to duplicate a program’s process
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
pid_tchild_pid;
printf(“The main program process ID is %d\n”, (int) getpid());
child_pid=fork();
if(child_pid!=0)
{
printf(“This is the parent process ID, with id %d\n”, (int)
getpid());
printf(“The child process ID is %d\n”, (int) child_pid);
}
else
printf(“This is the child process ID, with id %d\n”, (int) getpid());
return 0;
}

Example 4
Determining the exit status of a child
#include <stdio.h>
void show_return_status(void)
{
pid_tchildpid;
int status;
childpid = wait(&status); if (childpid == -1)
perror("Failed to wait for child");
else if (WIFEXITED(status))
printf("Child %ld terminated with return status %d\n", (long)childpid,
WEXITSTATUS(status));
}
Example 5
A program that creates a child process to run ls -l
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main(void)
{
pid_tchildpid;
childpid = fork();
if (childpid == -1) {
perror("Failed to fork");
return 1;
}

if (childpid == 0) {
/* child code */
execl("/bin/ls", "ls", "-l", NULL);
perror("Child failed to exec ls"); return 1;
}
if (childpid != wait(NULL)) {
/* parent code */
perror("Parent failed to wait due to signal or error"); return 1;
}
return 0;
}
Example 6
Making a zombie process
#include <stdlib.h>
#include <unistd.h>
int main()
{
pid_tchild_pid;
//create a child process
child_pid=fork();
if(child_pid>0) {
//This is a parent process. Sleep for a minute
sleep(60)
}
else
{
//This is a child process. Exit immediately.
exit(0);
}

return 0;
}
Example 7
Demonstration of fork system call
#include<stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
pid_tpid;
char *msg;
int n;
printf(“Program starts\n”);
pid=fork();
switch(pid)
{
case -1:
printf(“Fork error\n”);
exit(-1);
case 0:
msg=”This is the child process”;
n=5;
break;
default:
msg=”This is the parent process”;
n=3;
break;
}
while(n>0)

{
puts(msg);
sleep(1);
n--;
}
return 0;
}
Example 8
Demo of multiprocess application using fork()system call
#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#define SIZE 1024
void do_child_proc(intpfd[2]);
void do_parent_proc(intpfd[2]);
int main()
{
intpfd[2];
intret_val,nread;
pid_tpid;
ret_val=pipe(pfd);
if(ret_val==-1)
{
perror(“pipe error\n”);
exit(ret_val);
}
pid=fork();

switch(pid)
{
case -1:
printf(“Fork error\n”);
exit(pid);
case 0:
do_child_proc(pfd);
exit(0);
default:
do_parent_proc(pfd);
exit(pid);
}
wait(NULL);
return 0;
}
void do_child_proc(intpfd[2])
{
intnread;
char *buf=NULL;
printf(“5\n”);
close(pfd[1]);
while(nread=(read(pfd[0],buf,size))!=0)
printf(“Child Read=%s\n”,buf);
close(pfd[0]);
exit(0);
}
void do_parent_proc(intpfd[2])
{
char ch;
char *buf=NULL;
close(pfd[0]);
while(ch=getchar()!=’\n’) {

printf(“7\n”);
*buf=ch;
buff+;
}
*buf=’\0’;
write(pfd[1],buf,strlen(buf)+1);
close(pfd[1]);
}

Assignment No. : 3
Thread Management using pthread Library

ASSIGNMENT NO. 3
THREAD MANAGEMENT USING PTHREAD LIBRARY
AIM : Implement matrix multiplication using multithreading.

Application should have pthread_create, pthread_join,
pthread_exit. In the program, every thread must return the value
and must be collected in pthread_join in the main function. Final
sum of row-column multiplication must be done by main thread
(main function).
 Process vs Thread
 Pthread library
THEORY :
Thread
A thread is a semi-process that has its own stack, and executes a given piece of code. Unlike a
real process, the thread normally shares its memory with other threads (where as for
processes we usually have a different memory area for each one of them). A Thread Group is a
set of threads all executing inside the same process. They all share the same memory, and thus
can access the same global variables, same heap memory, same set of file descriptors, etc. All
these threads execute in parallel (i.e. using time slices, or if the system has several processors,
then really in parallel).
Threads in the same process share:
 Process instructions
 Most data
 open files (descriptors)
 signals and signal handlers
 current working directory
 User and group id
Each thread has a unique:

 Thread ID
 set of registers, stack pointer
 stack for local variables, return addresses
 signal mask
 priority
 Return value: errno
POSIX Threads (pthreads)

Historically, hardware vendors have implemented their own proprietary versions of threads.
These implementations differed substantially from each other making it difficult for
programmers to develop portable threaded applications. The Portable Operating System
Interface (POSIX) is a family of standards specified by the IEEE Computer Society for
maintaining compatibility between operating systems. POSIX defines the application
programming interface (API), along with command line shells and utility interfaces, for
software compatibility with variants of Unix and other operating systems.
POSIX Threads, usually referred to as Pthreads, is an execution model that exists
independently from a language, as well as a parallel execution model. It allows a program to
control multiple different flows of work that overlap in time. Each flow of work is referred to
as a thread, and creation and control over these flows is achieved by making calls to the POSIX
Threads.
Threads vs process
The primary motivation for using threads is to realize potential program performance gains.
 Compared to the cost of creating and managing a process, a thread can be created with
much less operating system overhead. Managing threads requires fewer system
resources than managing processes.
 All threads within a process share the same address space. Inter-thread communication
is more efficient and in many cases, easier to use than inter-process communication.

 Threaded applications offer potential performance gains and practical advantages over
non-threaded applications in several other ways:
a. Overlapping CPU work with I/O: For example, a program may have sections
where it is performing a long I/O operation. While one thread is waiting for an
I/O system call to complete, other threads can perform CPU intensive work.
b. Priority/real-time scheduling: tasks, which are more important, can be
scheduled to supersede or interrupt lower priority tasks.
c. Asynchronous event handling: tasks, which service events of indeterminate
frequency and duration, can be interleaved. For example, a web server can both
transfer data from previous requests and manage the arrival of new requests.
 Multi-threaded applications will work on a uniprocessor system; yet naturally take
advantage of a multiprocessor system, without recompiling.
 In a multiprocessor environment, the most important reason for using threads is to take
advantage of potential parallelism. This will be the focus of the remainder of this
session.
pthreads API
The subroutines which comprise the Pthreads API can be informally grouped into three major
classes:
1. Thread management: The first class of functions work directly on threads - creating,
detaching, joining, etc. They include functions to set/query thread attributes (joinable,
scheduling etc.)
2. Mutex: The second class of functions deals with a coarse type of synchronization,
called a "mutex", which is an abbreviation for "mutual exclusion". Mutex functions
provide for creating, destroying, locking and unlocking mutex. They are also
supplemented by mutex attribute functions that set or modify attributes associated
with mutex.
3. Condition variables: The third class of functions deal with a finer type of
synchronization - based upon programmer specified conditions. This class includes

functions to create, destroy, wait and signal based upon specified variable values.
Functions to set/query condition variable attributes are also included.
Naming conventions: All identifiers in the threads library begin with pthread_
pthread_ Threads themselves and miscellaneous subroutines

pthread_t Thread objects
pthread_attr Thread attributes objects
pthread_mutex Mutexes
pthread_mutexattr Mutex attributes objects.
pthread_cond Condition variables
pthread_condattr Condition attributes objects
pthread_key Thread-specific data keys
Thread Management Functions

The function pthread_create is used to create a new thread, and a thread to terminate itself
uses the function pthread_exit. A thread to wait for termination of another thread uses the
function pthread_join.
pthread_create
The pthread_create() function starts a new thread in the calling process. The new
thread starts execution by invoking start_routine.
Function: intpthread_create ( pthread_t * thread, /* Thread handle returned by reference

*/pthread_attr_t *attr, /* Special Attribute for starting thread, may be
NULL */
void *(*start_routine)(void *), /* Main Function which thread executes */
void *arg/* An extra argument passed as a pointer */
);
Info: Request the PThread library for creation of a new thread. The return value is 0 on
success. The return value is negative on failure. The pthread_t is an abstract datatype
that is used as a handle to reference the thread.
Arguments
 Thread - returns the thread id. (unsigned long int defined in
bits/pthreadtypes.h)
 attr - Set to NULL if default thread attributes are used. (else define members of

the structpthread_attr_t defined in bits/pthreadtypes.h) Attributes include:
o Detach state :
 Default: PTHREAD_CREATE_JOINABLE
 Other option : PTHREAD_CREATE_DETACHED
o Scheduling policy
 Default :real-time : PTHREAD_INHERIT_SCHED,
PTHREAD_EXPLICIT_SCHED, SCHED_OTHER)
o scheduling parameter
o inheritsched attribute (Default: PTHREAD_EXPLICIT_SCHED Inherit from
parent thread: PTHREAD_INHERIT_SCHED)
o scope (Kernel threads: PTHREAD_SCOPE_SYSTEM User threads:
PTHREAD_SCOPE_PROCESS Pick one or the other not both.)
o guard size
o stack address (See unistd.h and bits/posix_opt.h
_POSIX_THREAD_ATTR_STACKADDR)
o stack size (default minimum PTHREAD_STACK_SIZE set in pthread.h),
 void * (*start_routine) - pointer to the function to be threaded. Function has a
single argument: pointer to void.
 *arg - pointer to argument of function. To pass multiple arguments, send a
pointer to a structure.
pthread_exit
The pthread_exit() function terminates the calling thread and returns a value via retval
that (if the thread is joinable) is available to another thread in the same process that
calls pthread_join().
Function: void pthread_exit

(
void *retval /* return value passed as a pointer */
);

Info: This Function is used by a thread to terminate. The return value is passed as a pointer. This
pointer value can be anything so long as it does not exceed the size of (void *). Be careful,
this is system dependent. You may wish to return an address of a structure, if the returned
data is very large.
pthread_join
Function: intpthread_join
(
pthread_tth, /* Pass threadhandle */
void **returnvalue/* Return value is returned by ref. */
);
Info: Return 0 on success, and negative on failure. The returned value is a pointer returned by
reference. If you do not care about the return value, you can pass NULL for the second
argument.
Arguments:
 th - thread suspended until the thread identified by th terminates, either by
calling pthread_exit() or by being cancelled.
 returnvalue - If thread_return is not NULL, the return value of th is stored in the
location pointed to by thread_return.
Thread Initialization
Include the pthread.hlibrary :

#include <pthread.h>
Declare a variable of type pthread_t :
pthread_t thread;
When you compile, add -lpthread to the linker flags :
cc or gccthreads.c -o threads -lpthread
Initially, threads are created from within a process. Once created, threads are peers, and may

create other threads. Note that an "initial thread" exists by default and is the thread, which
runs main.
Terminating Thread Execution
intpthread_cancel (pthread_t thread )
pthread_cancel sends a cancellation request to the thread denoted by the thread argument. If
there is no such thread, pthread_cancel fails. Otherwise it returns 0.
A cancel is a mechanism by which a calling thread informs either itself or the called thread to
terminate as quickly as possible. Issuing a cancel does not guarantee that the canceled thread
receives or handles the cancel. The canceled thread can delay processing the cancel after
receiving it. For instance, if a cancel arrives during an important operation, the canceled
thread can continue if what it is doing cannot be interrupted at the point where the cancel is
requested.
The programmer may specify a termination status, which is stored as a void pointer for any
thread that may join the calling thread.
There are several ways in which a Pthread may be terminated:
 The thread returns from its starting routine (the main routine for the initial thread). By
default, the Pthreads library will reclaim any system resources used by the thread. This
is similar to a process terminating when it reaches the end of main.
 The thread makes a call to the pthread_exitsubroutine.
 The thread is canceled by another thread via the pthread_cancel routine (not covered
here).
 The thread receives a signal that terminates it. The entire process is terminated due to
a call to either the exec or exit subroutines.
Thread Attributes
Threads have a number of attributes that may be set at creation time. This is done by filling a
thread attribute object attr of type pthread_attr_t, then passing it as second argument to
pthread_create. Passing NULL is equivalent to passing a thread attribute object with all
attributes set to their default values. Attribute objects are consulted only when creating a new
thread. The same attribute object can be used for creating several threads. Modifying an

attribute object after a call to pthread_create does not change the attributes of the thread
previously created.
intpthread_attr_init (pthread_attr_t *attr)
pthread_attr_init initializes the thread attribute object attr and fills it with default values for
the attributes. Each attribute attrname can be individually set using the function
pthread_attr_setattrname and retrieved using the function pthread_attr_getattrname.
intpthread_attr_destroy (pthread_attr_t *attr)
pthread_attr_destroy destroys the attribute object pointed to by attr releasing any resources
associated with it. attr is left in an undefined state, and you must not use it again in a call to
any pthreads function until it has been reinitialized.
intpthread_attr_setattr (pthread_attr_t *obj, int value)
Set attribute attr to value in the attribute object pointed to by obj. See below for a list of
possible attributes and the values they can take. On success, these functions return 0.
intpthread_attr_getattr (constpthread_attr_t *obj, int *value)
Store the current setting of attr in obj into the variable pointed to by value. These functions
always return 0.
Steps
 Accept the matrices in the main program
 Create a thread using pthread_create(). Thread function multiplies two matrix
elements.
 The result of multiplication is returned to calling thread using pthread_exit().
 Use pthread_join() function in main program to block till the thread terminates and
catch the result returned by pthread_exit().
 Add the above result to get the elements of resultant matrix.
 Display the resultant matrix.
Input : two matrices for multiplication

Output: multiplication matrix
FAQ
1. What is thread? Explain the concept of multithreading.
2. What is the difference between thread & process?
3. How threads are created using pthread?
4. What is the use of pthread_join() and pthread_exit() function?
Example 1
Pthread Creation and Termination
#include <stdio.h>
#include <pthread.h>
void *kidfunc(void *p)
{
printf ("Kid ID is ---> %d\n", getpid( ));
}
main ( )
{
pthread_t kid ;
pthread_create (&kid, NULL, kidfunc, NULL) ;
printf ("Parent ID is ---> %d\n", getpid( )) ;
pthread_join (kid, NULL) ;
printf ("No more kid!\n") ;
}
Example 2
Multithreaded C Program Using the Pthread API
#include<pthread.h>
#include<stdio.h>
int sum; /*This data is shared by the thread(s) */

void *runner(void *param); /* the thread */
main(intargc, char *argv[])
{
pthread_ttid; /* the thread identifier */
pthread_attr_tattr; /* set of thread attributes */
if(argc != 2)
{
fprintf(stderr,"usage: a.out<integer value>\n");
exit();
}
if(atoi(argv[1]) < 0)
{
fprintf(stderr, "%d must be >= 0 \n", atoi(argv[1]));
exit();
}
/* get the default attributes */
pthread_attr_init(&attr);
/*create the thread */
pthread_create(&tid,&attr,runner,argv[1]);
/* Now wait for the thread to exit */
pthread_join(tid,NULL);
printf("sum = %d\n",sum);
}
/*The thread will begin control in this function */
void *runner(void *param)
{
int upper = atoi(param);
inti;
sum=0;
if(upper > 0)
{
for(i=1; i<= upper;i++)

sum += i;
}
pthread_exit(0);
}
Above Program creates a separate thread that determines the summation of a non-negative
integer. In a thread program, separate thread begins execution in a specified function. In
above program it is the runner function. When this program begins, a single thread of control
begins in main. After some initialization, main creates a second thread that begins control in
the summer function. All Pthread programs must include the pthread.h header file. The
pthread_attr_tattr declaration represents the attributes for the thread. Because we did not
explicitly set any attributes, we will use the default attribute provided. A separate thread is
created with the pthread_create function call. In addition to passing the thread identifier and
the attributes for the thread, we also pass the name of the function where the new thread will
execution, in this case runner function. Lastly, we pass the integer parameter that was
provided on the command line, argv[1].
At this point, the program has two threads: the initial thread in main and the thread
performing the summation in the runner function. After creating the second thread, the main
thread will wait for the runner thread to complete by calling the pthread_join function. The
runner thread will complete when it calls the function pthread_exit.

Assignment No. : 4
Thread Synchronization

ASSIGNMENTNO: 4
THREAD SYNCHRONIZATION
AIM : Thread synchronization using counting semaphores and mutual

exclusion using mutex. Application to demonstrate: Producer
Consumer problem with counting semaphores and
mutex.
 Semaphores
 Mutex
 Producer Consumer Problem
THEORY :
Semaphores:
Semaphore is an integer value used for signaling among processes. Only three operations may
be performed on a semaphore, all of which are atomic: initialize, decrement, and increment.
The decrement operation may result in the blocking of a process, and the increment operation
may result in the unblocking of a process. It is known as a countingsemaphore or a general
semaphore. Semaphores are the OS tools for synchronization.
Two types:
1. Binary Semaphore.
2. Counting Semaphore
Binary semaphore
Semaphores which are restricted to the values 0 and 1 (or locked/unlocked, unavailable /
available) are called binary semaphores and are used to implement locks.
It is a means of suspending active processes which are later to be reactivated at such time
conditions are right for it to continue. A binary semaphore is a pointer which when held by a

process grants them exclusive use to their critical section. It is a (sort of) integer variable
which can take the values 0 or 1 and be operated upon only by two commands termed in
English wait and signal.
Counting semaphore
Semaphores which allow an arbitrary resource count are called counting semaphores.
A counting semaphore comprises:
An integer variable, initialized to a value K (K>=0). During operation it can assume any
value <= K, a pointer to a process queue. The queue will hold the PCBs of all those
processes, waiting to enter their critical sections. The queue is implemented as a FCFS,
so that the waiting processes are served in a FCFS order.
A counting semaphore can be implemented as follows:

 Initialize – initialize to non negative integer
 Decrement (semWait)
o Process executes this to receive a signal via semaphore.
o If signal is not transmitted, process is suspended.
o Decrements semaphore value
o If value becomes negative , process is blocked
o Otherwise it continues execution.
 Increment (semSignal)
o Process executes it to transmit a signal via semaphore.
o Increments semaphore value
o If value is less than or equal to zero, process blocked by semWait is unblocked

Value of semaphore
 Positive
Indicates number of processes that can issue wait & immediately continue to execute.
 Zero
By initialization or because number of processes equal to initial semaphore value have
issued a wait Next process to issue a wait is blocked.
 Negative
Indicates number of processes waiting to be unblocked
Each signal unblocks one waiting process.
The Producer/Consumer Problem

There are one or more producers generating some type of data (records, characters) and
placing these in a buffer. There is a single consumer that is taking items out of the buffer one
at a time. The system is to be constrained to prevent the overlap of buffer operations. That is,
only one agent (producer or consumer) may access the buffer at any one time. The problem is

to make sure that the producer won’t try to add data into the buffer if it’s full and that the
consumer won’t try to remove data from an empty buffer. To begin, let us assume that the
buffer is infinite and consists of a linear array of elements. In abstract terms, we can define the
producer and consumer functions as follows:
Figure illustrates the structure of buffer b. The producer can generate items and store them in
the buffer at its own pace. Each time, an index (in) into the buffer is incremented. The
consumer proceeds in a similar fashion but must make sure that it does not attempt to read
from an empty buffer. Hence, the
Figure: Infinite buffer for producer/consumer problem

Solution for bounded buffer using counting semaphore
POSIX Semaphores
POSIX semaphores allow processes and threads to synchronize their actions. A semaphore is
an integer whose value is never allowed to fall below zero. Two operations can be performed
on semaphores: increment the semaphore value by one (sem_post(3)); and decrement the
semaphore value by one (sem_wait(3)). If the value of a semaphore is currently zero, then
a sem_wait(3) operation will block until the value becomes greater than zero.

Semaphore functions:
1. sem_init()
It initializes the unnamed semaphore at the address pointed to by sem. The value
argument specifies the initial value for the semaphore.
intsem_init(sem_t *sem, intpshared, unsigned int value);
2. sem_wait()
It decrements (locks) the semaphore pointed to by sem. If the semaphore's value is
greater than zero, then the decrement proceeds, and the function returns, immediately. If
the semaphore currently has the value zero, then the call blocks until it becomes possible
to perform the decrement.
intsem_wait(sem_t *sem);
3. sem_post()
It increments (unlocks) the semaphore pointed to by sem. If the semaphore's value
consequently becomes greater than zero, then another process or thread blocked in a
sem_wait(3) call will be woken up and proceed to lock the semaphore.
intsem_post(sem_t *sem);
4. sem_unlink
It removes the named semaphore referred to by name. The semaphore name is removed
immediately. The semaphore is destroyed once all other processes that have the
semaphore open close it.
intsem_unlink(const char *name)
All the above functions returns
0 : Success
-1 : Error
Mutex
Mutexes are a method used to be sure two threads, including the parent thread, do not
attempt to access shared resource at the same time. A mutex lock allows only one thread
to enter the part that's locked and the lock is not shared with any other processes.

1. pthread_mutex_init()
The function shall initialize the mutex referenced by mutex with attributes specified by
attr. If attr is NULL, the default mutex attributes are used; the effect shall be the same as
passing the address of a default mutex attributes object. Upon successful initialization, the
state of the mutex becomes initialized and unlocked.
intpthread_mutex_init(pthread_mutex_t *restrict mutex, cons
pthread_mutexattr_t *restrict attr);
2. pthread_mutex_lock()
The mutex object referenced by mutex shall be locked by calling pthread_mutex_lock(). If
the mutex is already locked, the calling thread shall block until the mutex becomes
available. This operation shall return with the mutex object referenced by mutex in the
locked state with the calling thread as its owner.
intpthread_mutex_lock(pthread_mutex_t * mutex);
3. pthread_mutex_unlock()
The function shall release the mutex object referenced by mutex. The manner in which a
mutex is released is dependent upon the mutex's type attribute. If there are threads
blocked on the mutex object referenced by mutex when pthread_mutex_unlock() is called,
resulting in the mutex becoming available, the scheduling policy shall determine which
thread shall acquire the mutex.
intpthread_mutex_unlock(pthread_mutex_t * mutex);
4. pthread_mutex_destroy()
The function shall destroy the mutex object referenced by mutex; the mutex object
becomes, in effect, uninitialized. A destroyed mutex object can be reinitialized using
pthread_mutex_init(); the results of otherwise referencing the object after it has been
destroyed are undefined.
intpthread_mutex_destroy(pthread_mutex_t *mutex);
CONCLUSION:
Thus, we have implemented producer-consumer problem using ‘C’ in Linux.

FAQ
1. Explain the concept of semaphore?
2. Explain wait and signal functions associated with semaphores.
3. What is meant by binary and counting semaphores?

Assignment No. : 5
Thread Synchronization

ASSIGNMENTNO: 5
THREAD SYNCHRONIZATION
AIM : Thread synchronization and mutual exclusion using mutex.

Application to demonstrate:
Reader-Writer problem with reader priority.
 Semaphores
 Mutex
 Producer Consumer Problem
THEORY :
Semaphores:
Semaphore is an integer value used for signaling among processes. Only three operations may
be performed on a semaphore, all of which are atomic: initialize, decrement, and increment.
The decrement operation may result in the blocking of a process, and the increment operation
may result in the unblocking of a process. It is known as a countingsemaphore or a general
semaphore. Semaphores are the OS tools for synchronization.
Two types:
1. Binary Semaphore.
2. Counting Semaphore
Binary semaphore
Semaphores which are restricted to the values 0 and 1 (or locked/unlocked, unavailable /
available) are called binary semaphores and are used to implement locks.
It is a means of suspending active processes which are later to be reactivated at such time
conditions are right for it to continue. A binary semaphore is a pointer which when held by a
process grants them exclusive use to their critical section. It is a (sort of) integer variable
which can take the values 0 or 1 and be operated upon only by two commands termed in
English wait and signal.
Counting semaphore

Semaphores which allow an arbitrary resource count are called counting semaphores.
A counting semaphore comprises:
An integer variable, initialized to a value K (K>=0). During operation it can assume any
value <= K, a pointer to a process queue. The queue will hold the PCBs of all those
processes, waiting to enter their critical sections. The queue is implemented as a FCFS,
so that the waiting processes are served in a FCFS order.
A counting semaphore can be implemented as follows:

 Initialize – initialize to non negative integer
 Decrement (semWait)
o Process executes this to receive a signal via semaphore.
o If signal is not transmitted, process is suspended.
o Decrements semaphore value
o If value becomes negative , process is blocked
o Otherwise it continues execution.
 Increment (semSignal)
o Process executes it to transmit a signal via semaphore.
o Increments semaphore value
o If value is less than or equal to zero, process blocked by semWait is unblocked

Value of semaphore
 Positive
Indicates number of processes that can issue wait & immediately continue to execute.
 Zero
By initialization or because number of processes equal to initial semaphore value have
issued a wait Next process to issue a wait is blocked.
 Negative
Indicates number of processes waiting to be unblocked
Each signal unblocks one waiting process.
The Reader Writer Problem.6 READERS/WRITERS PROBLEM

In dealing with the design of synchronization and concurrency mechanisms, it isuseful to be
able to relate the problem at hand to known problems and to be ableto test any solution in
terms of its ability to solve these known problems. The readers/writers problem is defined as
follows: There is a data area sharedamong a number of processes. The data area could be a

file, a block of main memory,or even a bank of processor registers. There are a number of
processes thatonly read the data area (readers) and a number that only write to the data
area(writers). The conditions that must be satisfied are as follows:
1. Any number of readers may simultaneously read the file.
2. Only one writer at a time may write to the file.
3. If a writer is writing to the file, no reader may read it.
Thus, readers are processes that are not required to exclude one another andwriters are
processes that are required to exclude all other processes, readers andwriters alike.
In the readers/writers problem readers do not also write to the data area, nor do writersread
the data area while writing.
For example, suppose that the shared area is a library catalog.Ordinary users of the library
read the catalog to locate a book. One or more librariansare able to update the catalog. In the
general solution, every access to thecatalog would be treated as a critical section, and users
would be forced to readthe catalog one at a time. This would clearly impose intolerable delays.
At thesame time, it is important to prevent writers from interfering with each other andit is
also required to prevent reading while writing is in progress to prevent the access
of inconsistent information.
Readers Have Priority
Figure is a solution using semaphores, showing one instance each of a readerand a writer; the
solution does not change for multiple readers and writers.The writer process is simple. The
semaphore wsem is used to enforce mutualexclusion. As long as one writer is accessing the
shared data area, no other writersand no readers may access it. The reader process also makes
use of wsem toenforce mutual exclusion. However, to allow multiple readers, we require
that,when there are no readers reading, the first reader that attempts to read shouldwait on
wsem. When there is already at least one reader reading, subsequentreaders need not wait
before entering. The global variable readcount is used tokeep track of the number of readers,
and the semaphore x is used to assure thatreadcount is updated properly.

POSIX Semaphores
POSIX semaphores allow processes and threads to synchronize their actions. A semaphore is
an integer whose value is never allowed to fall below zero. Two operations can be performed
on semaphores: increment the semaphore value by one (sem_post(3)); and decrement the
semaphore value by one (sem_wait(3)). If the value of a semaphore is currently zero, then
a sem_wait(3) operation will block until the value becomes greater than zero.
Semaphore functions:
4. sem_init()
It initializes the unnamed semaphore at the address pointed to by sem. The value
argument specifies the initial value for the semaphore.
intsem_init(sem_t *sem, intpshared, unsigned int value);

5. sem_wait()
It decrements (locks) the semaphore pointed to by sem. If the semaphore's value is
greater than zero, then the decrement proceeds, and the function returns, immediately. If
the semaphore currently has the value zero, then the call blocks until it becomes possible
to perform the decrement.
intsem_wait(sem_t *sem);
6. sem_post()
It increments (unlocks) the semaphore pointed to by sem. If the semaphore's value
consequently becomes greater than zero, then another process or thread blocked in a
sem_wait(3) call will be woken up and proceed to lock the semaphore.
intsem_post(sem_t *sem);
5. sem_unlink
It removes the named semaphore referred to by name. The semaphore name is removed
immediately. The semaphore is destroyed once all other processes that have the
semaphore open close it.
intsem_unlink(const char *name)
All the above functions returns
0 : Success
-1 : Error
Mutex
Mutexes are a method used to be sure two threads, including the parent thread, do not
attempt to access shared resource at the same time. A mutex lock allows only one thread
to enter the part that's locked and the lock is not shared with any other processes.
5. pthread_mutex_init()
The function shall initialize the mutex referenced by mutex with attributes specified by
attr. If attr is NULL, the default mutex attributes are used; the effect shall be the same as
passing the address of a default mutex attributes object. Upon successful initialization, the
state of the mutex becomes initialized and unlocked.

intpthread_mutex_init(pthread_mutex_t *restrict mutex, cons
pthread_mutexattr_t *restrict attr);
6. pthread_mutex_lock()
The mutex object referenced by mutex shall be locked by calling pthread_mutex_lock(). If
the mutex is already locked, the calling thread shall block until the mutex becomes
available. This operation shall return with the mutex object referenced by mutex in the
locked state with the calling thread as its owner.
intpthread_mutex_lock(pthread_mutex_t * mutex);
7. pthread_mutex_unlock()
The function shall release the mutex object referenced by mutex. The manner in which a
mutex is released is dependent upon the mutex's type attribute. If there are threads
blocked on the mutex object referenced by mutex when pthread_mutex_unlock() is called,
resulting in the mutex becoming available, the scheduling policy shall determine which
thread shall acquire the mutex.
intpthread_mutex_unlock(pthread_mutex_t * mutex);
8. pthread_mutex_destroy()
The function shall destroy the mutex object referenced by mutex; the mutex object
becomes, in effect, uninitialized. A destroyed mutex object can be reinitialized using
pthread_mutex_init(); the results of otherwise referencing the object after it has been
destroyed are undefined.
intpthread_mutex_destroy(pthread_mutex_t *mutex);
CONCLUSION:
Thus, we have implemented producer-consumer problem using ‘C’ in Linux.
FAQ
4. Explain the concept of semaphore?
5. Explain wait and signal functions associated with semaphores.
6. What is meant by binary and counting semaphores?

Assignment No. : 6
Deadlock avoidance using semaphores

ASSIGNMENT NO: 6
DEADLOCK AVOIDANCE USING SEMAPHORES
AIM : Implement the deadlock free solution to Dining Philosophers

problem to illustrate the problem of deadlock and/or starvation
that can occur when many synchronized threads are competing
for limited resources.
 Deadlock and starvation
 Conditions for Deadlock and its handling
 Dining Philosophers problem
THEORY :
What is Deadlock?
A set of processes is deadlocked if each process in the set is waiting for an event that only
another process in the set can cause. Because all the processes are waiting, none of them will
ever cause any of the events that could wake up any of the other members of the set, and all
the processes continue to wait forever. For this model, we assume that processes have only a
single thread and that there are no interrupts possible to wake up a blocked process. The no
interrupts condition is needed to prevent an otherwise deadlocked process from being awake.

Conditions for Deadlock
Coffman et al. (1971) showed that four conditions must hold for there to be a deadlock:
1. Mutual exclusion condition. Each resource is either currently assigned to exactly one
process or is available.
2. Hold and wait condition. Processes currently holding resources granted earlier can
request new resources.
3. No preemption condition. Resources previously granted cannot be forcibly taken
away from a process. They must be explicitly released by the process holding them.
4. Circular wait condition. There must be a circular chain of two or more processes,
each of which is waiting for a resource held by the next member of the chain.
Dining Philosopher’s Problem

In this problem, there are 5 philosophers present who spend their life in eating and thinking.
Philosophers share a common circular table surrounded by 5 chairs, each belonging to 1
philosopher .In the center of the table. A bowl of slippery food(Noodles or rice) is present and
across each philosopher a pair of chopstick is present. When a philosopher thinks, he does not
interact with his colleague.
Whenever a philosopher gets hungry, he tries to pick up 2 chopsticks that are close to him.
Philosopher may pick up one chopstick at a time. He cannot pick up a chopstick that is already
in the hand of neighbor. When a hungry philosopher has both chopsticks at the same time, he
start eating without releasing his chopstick and starts thinking again .The problem could be
raised when all the philosopher try to keep the chopstick at the same time.
This may lead to deadlock situations. To synchronize all philosophers, semaphore chopsticks
[5] are used as a variable where all the elements are first initialized to 1.The structure of
philosophers is shown below;

Deadlock free Solution using semaphores
CONCLUSION:
Thus, we have implemented dining philosopher’s problem using ‘C’ in Linux.
FAQ:
1. What is dead lock?
2. What are the necessary and sufficient conditions to occur deadlock?
3. What is deadlock avoidance and deadlock prevention techniques?

Assignment No. : 7 (a)
Inter process communication using pipes

ASSIGNMENT NO. 7 (a)
INTER PROCESS COMMUNICATION USING PIPES
AIM : Full duplex communication between parent and child processes.

Parent process writes a pathname of a file (the contents of the
file are desired) on one pipe to be read by child process and child
process writes the contents of the file on second pipe to be read
by parent process and displays on standard output.
 UNIX process control

THEORY :
PIPES:
Pipe provides an inter-process communication channel between related processes. The pipe
interface is intended to look like a file interface. Although a pipe may seem like a file, it is not a
file. Each write to the pipe fills as many blocks as are needed to satisfy it, provided that it does
not exceed the maximum pipe size. Filled blocks are conveyed to the read-end of the pipe,
where they are emptied when they are read. These types of pipes are called unnamed pipes
because they do not exist anywhere in the file system.
Creating a pipe:
#include<unistd.h>
intpipe(intfiledes[2])
The system call pipe(fd), given an integer array filedes of size 2, creates a pair of file
descriptors, filedes[0]and filedes[1], pointing to the "read-end" and "write-end" of a pipe
respectively. If it is successful, it returns a 0, otherwise it returns -1.
Data can be written to the file descriptor fildes[1] and read from the file descriptor fildes[0]. A
read on the file descriptor fildes[0] shall access data written to the file descriptor fildes[1] on a
first-in-first-out basis. If the parent wants to receive data from the child, it should close
fildes[1], and the child should close fildes[0]. If the parent wants to send data to the child, it
should close fildes[0], and the child should close fildes[1]. Since descriptors are shared

between the parent and child, we should always be sure to close the end of pipe we aren’t
concerned with. On a technical note, the EOF will never be returned if the unnecessary ends of
the pipe are not explicitly closed.
Writing to pipe
The pipe has a limited size (64K in some systems) -- cannot write to the pipe infinitely.
ssize_t write(intfd, const void *buf, ssize_t count);
Writes upto count bytes to file referenced by file descriptor fd from buffer starting at buf.
Reading from pipe
ssize_t read(intfd, void *buf, ssize_t count);
Reads upto count bytes from file descriptor fd into buffer starting at buf.
A UNIX pipe provides a half duplex communication.
The pipe(2) system call returns two file descriptors that form a "pipe", a one-way
communication channel with a "read end" and a "write end".
A UNIX pipe provides a Full duplex communication via two pipes.

If we want two way communication generally we create two pipes one for each direction.
Create two separate pipes, say p0 and p1.

Example:
Using a Pipe to Pass Data between a Parent Process and a Child Process. The following
example demonstrates the use of a pipe to transfer data between a parent process and a child
process. Error handling is excluded, but otherwise this code demonstrates good practice when
using pipes: after the fork() the two processes close the unused ends of the pipe before they
commence transferring data.
#include <stdlib.h>
#include <unistd.h>
...
intfildes[2];
constint BSIZE = 100;
char buf[BSIZE];
ssize_tnbytes;
int status;
status = pipe(fildes);
if (status == -1 ) {
/* an error occurred */
...
}
switch (fork())

{
case -1: /* Handle error */
break;
case 0: /* Child - reads from pipe */
close(fildes[1]); /* Write end is unused */
nbytes = read(fildes[0], buf, BSIZE); // Get data from pipe
/* At this point, a further read would see end of file ... */

close(fildes[0]); /* Finished with pipe */
exit(EXIT_SUCCESS);
default: /* Parent - writes to pipe */

close(fildes[0]); /* Read end is unused */
write(fildes[1], "Hello world\n", 12); // Write data on
pipe
close(fildes[1]); /* Child will see EOF */
exit(EXIT_SUCCESS);
}
CONCLUSION:
Thus, we studied inter process communication using pipes.

Assignment No. : 7 (b)
Inter process communication using FIFO

ASSIGNMENT NO. 7 (b)
INTER PROCESS COMMUNICATION USING FIFO
AIM : Full duplex communication between two independent processes.

First process accepts sentences and writes on one pipe to be
read by second process and second process counts number of
characters, number of words and number of lines in accepted
sentences, writes this output in a text file and writes the
contents of the file on second pipe to be read by first process
and displays on standard output.
 FIFO
 FIFO Operations
 Use of FIFO for inter process copmmunication
THEORY :
FIFOs
A FIFO (First In First Out) is a one-way flow of data. FIFOs have a name, so unrelated processes
can share the FIFO. FIFO is a named pipe. Any process can open or close the FIFO. FIFOs are
also called named pipes.
Properties:
1. After a FIFO is created, it can be opened for read or write.

2. Normally, opening a FIFO for read or write, it blocks until another process opens it for
write or read.
3. A read gets as much data as it requests or as much data as the FIFO has, whichever is
less.
4. A write to a FIFO is atomic, as long as the write does not exceed the capacity of the
FIFO.

5. FIFO must be opened by two processes; one opens it as reader on one end, the other
opens it as sender on the other end. The first/earlier opener has to wait until the
second/later opener to come. This is somewhat like a hand-shaking.
Creating a FIFO
A FIFO is created by the mkfifo function. Specify the path to the FIFO on the command line. For
example, create a FIFO in /tmp/fifo by invoking this:
#include <sys/stat.h>
intmkfifo(const char *pathname, mode_t mode);
pathname: a UNIX pathname (path and filename). The name of the FIFO
mode: the file permission bits. It specifies the pipe’s owner, group, and world
permissions, and a pipe must have a reader and a writer, the permissions must include
both read and write permissions.
If the pipe cannot be created (for instance, if a file with that name already exists), mkfifo
returns –1.
FIFO can also be created by the mknod system call,

e.g., mknod(“fifo1”, S_IFIFO|0666, 0) is same as mkfifo(“fifo1”, 0666).
Accessing a FIFO
Access a FIFO just like an ordinary file. To communicate through a FIFO, one program must
open it for writing, and another program must open it for reading. Either low-level I/O
functions like open, write, read, close or C library I/O functions (fopen, fprintf, fscanf, fclose,
and soon) may be used.

For example, to write a buffer of data to a FIFO using low-level I/O routines, you could use this
code:
Intfd = open (fifo_path, O_WRONLY);
write (fd, data, data_length);
close (fd);
To read a string from the FIFO using C library I/O functions, you could use this code:
FILE* fifo = fopen (fifo_path, “r”);
fscanf (fifo, “%s”, buffer);
fclose (fifo);
A FIFO can have multiple readers or multiple writers. Bytes from each writer are written
atomically up to a maximum size of PIPE_BUF (4KB on Linux). Chunks from simultaneous
writers can be interleaved. Similar rules apply to simultaneous reads.
Close: To close an open FIFO, use close().
Unlink :To delete a created FIFO, use unlink().
CONCLUSION:
Thus, we studied inter process communication using FIFOs.

Assignment No. : 10
Implementation and addition of new system call
ASSIGNMENT NO: 10

IMPLEMENTATION AND ADDITION OF A NEW SYSTEM CALL
AIM : Implement a new system call in the kernel space, add this new
system call in the Linuxkernel by the compilation of this kernel
(any kernel source, any architecture and any Linux
kerneldistribution) and demonstrate the use of this embedded
system call using C program in user space.
Linux kernel architecture
System call
THEORY :
Steps
Following are the steps to add a new system call in linux.

1. Change to the kernel source directory using,
cd /usr/src/linux-3.17.7/
2. Define a new system call sys_hello()
Create a directory hello in the kernel source directory:-
mkdir hello
Change into this directory
cd hello
3. Create a “hello.c” file in this folder and add the definition of the system call to it as given
below
gedithello.c
Add the following code:
#include<linux/kernel.h>
asmlinkage long sys_hello(void)
{
printk(“Hello world\n”);

return 0;
}
Note that printk prints to the kernel’s log file.
4. Create a “Makefile” in the hello folder and add the given line to it.
geditMakefile
Add the following line to it:-
obj-y:=hello.o
This is to ensure that the hello.c file is compiled and included in the kernel source code.
5. Add the hello directory to the kernel’s Makefile
Change back into the linux-3.17.7 folder and open Makefile
geditMakefile
Go to line number 842 which says:-
“core-y+=kernel/mm/fs/ipc/security/crypto/block/”
Change this to
“core-y+=kernel/mm/fs/ipc/security/crypto/block/hello/”
This is to tell the compiler that the source files of our new system call (sys_hello()) are
present in the hello directory.
6. Add the new system call (sys_hello()) into the system call table (syscall_32.tblfile)
If your system is a 64 bit system, you will need to alter the syscall_64.tblfile.
cd arch/x86/syscalls
gedit syscall_32.tbl
Add the following line at the end of the file:-
354 i386 hello sys_hello
354 : It is the number of the system call .It should be one plus the number of the last system
call.
(it was 354 in my system). This has to be noted down to make the system call in the user space
program.

7. Add the new system call (sys_hello()) in the system call header file.
cd include/linux/
geditsyscalls.h
Add the following line to the end of the file just before the #endif statement at the very
bottom.
asmlinkage long sys_hello(void);
This defines the prototype of the function of our system call. ”asmlinkage” is a keyword used
to indicate that all parameters of the function would be available on the stack.
8. Compile this kernel on your system.
To compile Linux Kernel the following are required to be installed.
1. gcc latest version,
2. ncurses development package
3. system packages should be up-to date
To configure your kernel use the following command:-
sudo make menuconfig
Once the above command is used to configure the Linux kernel, you will get a popup window
with the list of menus and you can select the items for the new configuration. If you run
familiar with the configuration just check for the file systems menu and check whether “ext4”
is chosen or not,if not select it and save the configuration.
If you like to have your existing configuration, then run the below command.
sudo make oldconfig
Now to compile the kernel ;do make.
cd /usr/src/linux-3.17.7/
make
This might take several hours depending on your system (using hypervisors can take a longer
time).
To install /update the kernel.
To install this edited kernel run the following command:-
sudo make modules_install install

The above command will install the Linux Kernel 3.17.7 into your system.It will create some
files under/boot/ directory and it will automatically make a entry in your grub.cfg. To check
whether it made correct entry; check the files under/boot/directory. If you have followed the
steps without any error you will find the following files in it in addition to others.
 System.map-3.16.0
 vmlinuz-3.16.0
 initrd.img-3.16.0
 config-3.16.0
Now to update the kernel in your system reboot the system. You can use the following
command.
shutdown –r now
After rebooting you can verify the kernel version using the following command;
uname -r
To test the system call:
Create a “userspace.c” program in your home folder and type in the following code:
#include<stdio.h>
#include<linux/kernel.h>
#include<sys/syscall.h>
#include<unistd.h>
int main()
{
slongintmycall =syscall(354);
printf(“System call sys_hello returned %ld\n”, mycall);
return0;
}
Now compile this program using the following command.

gccuserspace.c

If all goes well you will not have any errors else, rectify the errors.
Now run the program using the following command.
./a.out
You will see the following line getting printed in the terminal if all the steps were followed
correctly.
“System call sys_hello returned 0“.
Now to check the message of the kernel, you can run the following command.
dmesg
This will display “Hello world” at the end of the kernel’s message.
Say, we wanted to add our own version of the system call getpid(). Let’s call our version
mygetpid(). The implementation of mygetpid() is:
asmlinkage long sys_getpid(void)

{
return current->tgid;
}
NOTE: asmlinkage must appear before every system call.

It tells the compiler to only look on the stack for the functions arguments (aka compiler magic).

Final OSL Labmanual 2017-18

Uploaded by

Copyright:

Available Formats

Final OSL Labmanual 2017-18

Uploaded by

Document Information

Original Description:

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Final OSL Labmanual 2017-18

Uploaded by

Copyright:

Available Formats

314454::OPERATING SYSTEM LABORATORY

TEIT (2015 Course)

Teaching Scheme Examination Scheme

LABORATORY MANUAL V 4.0

DEPARTMENT OF INFORMATION TECHNOLOGY

Department of Information Technology Page 1 of 85

Department of Information Technology Page 2 of 85

The students of Information Technology course after passing out will

Department of Information Technology Page 3 of 85

The students in the Information Technology course will attain:

a. an ability to apply knowledge of computing, mathematics including discrete mathematics as

Department of Information Technology Page 4 of 85

2.0 20 Nov 2015 Revision in Contents

3.0 18 Nov 2016 Minor modifications

4.0 07 June 2017 University Syllabus Modification - Course 2015

Summary of Changes to Operating System Laboratory Manual

Sr. No Changes Change type

Department of Information Technology Page 5 of 85

314447 : SOFTWARE LABORATORY – II

Teaching Scheme: Credit: 02

Assignment No. 1: Shell programming

Department of Information Technology Page 6 of 85

Assignment No. 3: Implement multithreading for Matrix Multiplication using pthreads.

Assignment No. 4: Thread synchronization using counting semaphores. Application to demonstrate:

Assignment No. 7: Inter process communication in Linux using following.

Department of Information Technology Page 7 of 85

Department of Information Technology Page 8 of 85

Sr. No. Title Page No.

3 Matrix multiplication using multithreading 27

Producer consumer problem with counting semaphores and

5 Reader-Writer problem with reader priority using mutex

6 Dining Philosophers problem Using Semaphores 48

Inter process communication in Linux using following

8 Inter-process Communication using Shared Memory using System V. 65

9 Implement an assignment using File Handling System Calls 70

Implementation and addition of a new system call in the Linux

Department of Information Technology Page 9 of 85

3 Matrix multiplication using multithreading 4 4

Producer consumer problem with counting

6 Dining Philosophers problem Using Semaphores 4 7

Inter process communication in Linux using following

9 Implement an assignment using File Handling System Calls 4 11

Implementation and addition of a new system call in

Department of Information Technology Page 10 of 85

Department of Information Technology Page 11 of 85

AIM : Write a program to implement an address book with options given

Department of Information Technology Page 12 of 85

User defined variables (UDV)

Quotes Name Meaning

Double "Double Quotes" - Anything enclose in double quotes removed meaning

Department of Information Technology Page 13 of 85

Department of Information Technology Page 14 of 85

Department of Information Technology Page 15 of 85

System Variable Meaning

BASH=/bin/bash Our shell name

BASH_VERSION=1.14.7(1) Our shell version name

HOME=/home/vivek Our home directory

LOGNAME=students students Our logging name