BCSCCS505R02 / BICCIC 505 R01 / BITCIT 505 R01

OPERATING SYSTEMS LAB

B.TECH CSE / IT / ICT
SCHOOL OF COMPUTING


2014 -15
Course Objective
To enable the students acquire knowledge
on the various concepts of operating
systems by doing hands on experiments on
process management, concurrency,
synchronization, inter-process
communication, file management,
processor management and memory
management
List of Experiments
Process Creation and Management
1) Creation of a child process using fork system call.
Concurrency and Synchronization
2) Implementing Producer-Consumer system.
3) Implementing Reader-Writer problem.
Deadlock and Starvation
4) Implementing Dining Philosopher problem.
Inter-Process Communication
5) IPC using Shared Memory System Call.
6) Working with Message Queues.
Processor Scheduling
7) Simulate CPU Scheduling algorithms.
File Management
8) Simulate File Allocation strategies.
Memory Partitioning
9) Simulate MVT and MFT.
Deadlock Handling`
10) Simulate Bankers Algorithm for Dead Lock Avoidance.
Disk Scheduling
11) Disk Scheduling Techniques
Paging
12) Simulate Page Replacement algorithms.
13) Simulate Paging technique of Memory Management.
Kernel Level Programming
14) Adding a new system call to Linux kernel


1. Creation of a child process using fork system call
Objective:
Create a child process using fork system call.
Pre-requisite:
Knowledge of parent/child process & fork command
Procedure:
Create the parent process and run the parent code
Parent create child process using fork().
Parent suspended to invoke child
Child process invoked and displays child process Id
Pre-Lab:
Practicing linux commands and Simple C programs on
linux platform
Additional Exercises:
Pipe Concept, File sharing, Multiple child processes
creation
2. Simulating Producer-Consumer problem
Objective:
Implementation of Producer-Consumer system. It is an
example of multi-processes synchronization.
Pre-requisite
Knowledge of Concurrency, Mutual exclusion,
Synchronization and producer-consumer problem
Procedure:
Implement SemWait and SemSignal functions
Implement producer and consumer procedures
Producer fills buffer using append
Consumer consumes buffer content using take
Pre-Lab:
Simple programs using Semaphore functions
Additional Exercise:
Multiple producer and consumer

3. Implementing Reader-Writer problem
Objective:
To write a code to solve the readers writers problem. It is an
Example of concurrency problem.
Pre-requisite
Knowledge of Concurrency, Mutual exclusion, Synchronization
and Reader writer problem
Procedure:
Create a reader process
Create a writer process
Implement SemSignal and SemWait
Implement program giving reader priority
Pre-Lab :
Semaphore, multi-processes
Additional Exercise:
Writer priority based implementation, multiple
readers and writers, Solution based on message passing



4. Implementing Dining Philosopher problem
Objective:
To write a code to solve the Dining philosopher problem.
Prerequisite
Knowledge of Concurrency, Deadlock and Starvation
Procedure
Create philosopher process
Declare semaphore for mutual exclusion and left & right forks
Implement function for obtaining fork - takefork
Implement function for releasing fork - putfork.
Implement function for testing blocked philosophers
Pre-Lab:
Semaphore, multi-processes
Additional Exercise:
Solution using monitors

5. IPC using Shared Memory System Call
Objective:
To implement IPC using shared memory concept
Prerequisite:
Knowledge of IPC, Shared memory, pipe concept
Procedure:
Create the server process and create the shared memory portion using
shmget() function.
Attach the shared memory segment to data space and assign the shared
memory a key value say 1234.
Write some data into the shared memory.
Create the client process.
Obtain the shared memory by passing the corresponding key value 1234.
Attach the shared memory segment using shmat() function.
Read the data put by server in the memory. Alter a character as an
acknowledgement for having read the data.
Pre-Lab
Practicing shmat, shmget.
Additional Exercise:
IPC based on Message passing


6. Working with Message Queues
Objective:
To implement message queues
Prerequisite:
Knowledge of IPC, Message queues
Background:
queue reader reads the messages from the queue prints their
contents to standard output. The "queue_reader" is given a number
on its command line, which is the priority of messages that it should
read.
queue sender creates a message queue, and then starts sending
messages with different priorities onto the queue.
Pre-Lab :
Msgget(), Msgsnd(), Msgrcv()
Additional Exercise:
A server program and two client programs, the server can
communicate privately to each client individually via a single
message queue


7. Simulate CPU Scheduling algorithms
Objective:
Simulation of CPU Scheduling algorithms
Prerequisite:
Knowledge of scheduling algorithms
Procedure:
Input the number of processes (p1, p2, pn)
Input the CPU process time for each of the process.
Calculate the waiting time and the average waiting time of all
the process for the following scheduling types:
First Come First Serve (FCFS)
Shortest Job First (SJF):
Round Robin
Priority based
Pre-Lab:
Waiting Time, Burst Time and Average Waiting Time
calculation
Additional Exercise: SRT, Feedback Queue

8. Simulate File Allocation strategies
Objective:
Simulation of File Allocation strategies.
Prerequisite:
Knowledge File concepts, Allocation methods
Procedure:
Create a Record and store the contents in the file.
Create fixed sized blocks (arrays and structures).
Sequential Allocation:
Records are stored in contiguous blocks.
Linked Allocation:
Records are stored in free blocks and address of next block is
stored at the end of the block.
Pre-Lab:
Prior knowledge of Storage Schema of all File Allocation methods.
File operations fopen(), fseek(), ftell(), rewind(), fscanf(), etc,.
Additional Exercise: Indexed Allocation implementation

9. Simulate MVT and MFT
Objective:
Simulation of Multiprogramming with Variable and Fixed number of
Tasks.
Prerequisite:
Concept multiprogramming, MVT and MFT
Procedure:
Create various Tasks (copying file contents, storing information in
editor and drawing a picture, etc,.).
Execute the Tasks (Threads) at an interval of time to implement
MVT.
Get the opinions to execute notepad, paint application for fixed
number of tasks (MFT).
Pre-Lab:
Multiprocesses, Fork, Pipe
Additional Exercise:
Both MVT and MFT implemented and dynamically chosen one of
them

10. Simulate Bankers Algorithm for Dead Lock Avoidance
Objective:
Simulate Bankers Algorithm for Dead Lock Avoidance
Procedure:
Get the number of processes and resources
Create the following data structures:
Available Number of available resources of each types.
Max Maximum demand of each process.
Allocation Number of resources of each type currently
allocated to each process.
Need Remaining resource need of each process. (Max-
Allocation)
Use Safety algorithm and Resource-Request algorithm.
Pre-Lab:
Prior knowledge of deadlocks and all deadlock avoidance
methods.
Additional Exercise:
Deadlock detection, Deadlock recovery


11. Disk Scheduling Techniques

Objective:
Simulation of disk scheduling techniques.
Prerequisite:
Knowledge of disk scheduling algorithms.
Procedure:
Implement scheduling algorithms listed below:
First-in-First-Out
Shortest Seek Time First
Shortest Service Time First
Scan
Pre-Lab:
Calculation of Seek time, transfer time etc.
Additional Exercise:
C-SCAN, Look

12. Simulate Page Replacement algorithms
Objective:
Simulate Page Replacement algorithms.
Prerequisite:
Knowledge of Paging concepts, replacement algorithms
Procedure:
Create a queue of pages
Select a page to replace based on the following approaches:
Least Frequently Used
Least Recently Used
Optimal page replacement
Pre-Lab :
Paging
Additional Exercise:
FIFO, MRU, LFU, Second-chance


13. Simulate Paging technique of Memory Management
Objective:
Simulation of Paging technique of Memory Management.
Prerequisite:
Knowledge of Paging, Frames, Memory management
Procedure:
Get the range of Physical and Logical addresses.
Get the Page Size.
Get the Page Number of the data.
Construct Page Table by mapping Logical address to Physical
address.
Search Page Number in the Page Table and locate the Base
Address.
Calculate the Physical address of the data.
Pre-Lab:
Paging, Page replacement, Address calculation methods
Additional Exercise:
Simulation of thrashing, Implementation of segmentation


14. Adding a new system call to Linux kernel
Objective:
Adding a our own developed system call to Linux kernel.
Prerequisite:
Knowledge of linux kernel, System calls
Procedure:
1)Download the latest version of the 2.6 Linux kernel from
www.kernel.org.
2)Unzip and untar the kernel directory into /usr/src/.
3)In /usr/src/Linux-x.x.x/kernel/, Create a new file myservice.c to
define your system call.
4) In /usr/src/Linux-x.x.x/include/asm/unistd.h, define an index
for your system call. Your index should be the number after the
last system call defined in the list.
5) Also, you should increment the system call count.
6) In /usr/src/Linux-x.x.x/arch/i386/kernel/entry.S, you should
define a pointer to hold a reference to your system call routine.
.
Add your object after the other kernel objects have been declared.


7) Add your system call to the Makefile in /usr/src/Linux-
x.x.x/kernel/Makefile
8) Make your system from /usr/src/Linux-x.x.x
9) Add a new boot image to Lilo, by editing /etc/lilo.conf. Your
lilo configuration will vary slightly.
10) Making a user test file. You also need to copy your edited
unistd.h from /usr/src/Linux-x.x.x/include/asm/ to
/usr/include/kernel/ because it contains your
system calls index.
11) Reboot into your new kernel and compile your user test
program to try out your system call. You will know if it
worked if you see a kernel message in
/var/log/kernel/warnings announcing that your service is
running.
Pre-Lab:
shell commands





More Additional Experiments
Implementation of real time scheduling
algorithms
Simulation of sleeping barbers problem
Program for the simulation of segmentation
Thank You