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