Operating system Reg no : 23BSA10132

Name : Pavnesh yadav

Exp 1: Study of MS-DOS commands

MS-DOS (Microsoft Disk Operating System) commands are instructions used to

perform tasks on files and directories in the MS-DOS operating system. These
commands are divided into two main categories: internal and external
commands.
Internal Commands
Internal commands are built into the command interpreter (COMMAND.COM)
and are always available in MS-DOS. Some common internal commands
include:
•

• • CLS: Clears the screen.

• plaintext
• C:\> CLS
• • DIR: Displays a list of files and directories in the current directory.
• plaintext
• C:\> DIR
• • COPY: Copies files from one location to another.
• plaintext
• C:\> COPY C:\example.txt D:\
• • DEL: Deletes files.
• plaintext
• C:\> DEL example.txt
• • REN: Renames files.
• plaintext
• C:\> REN oldname.txt newname.txt
• • CD: Changes the current directory.
• plaintext
• C:\> CD \foldername
• • MD: Creates a new directory.
• plaintext
• C:\> MD newfolder
• • RD: Removes an empty directory.
• plaintext
 • C:\> RD emptyfolder

External Commands
External commands are not built into the command interpreter and are stored
as separate executable files on the disk. Some common external commands
include:
•

• FORMAT: Formats a disk.

plaintext

C:\> FORMAT A:

• DISKCOPY: Copies the contents of one disk to another.

plaintext

C:\> DISKCOPY A: B:

• XCOPY: Copies files and directories, including subdirectories.

plaintext

C:\> XCOPY C:\source D:\destination /E

• CHKDSK: Checks the disk for errors and displays a status report.

plaintext

C:\> CHKDSK C:

• DEFRAG: Defragments the disk to improve performance.

plaintext

C:\> DEFRAG C:

• BACKUP: Creates backup copies of files.

plaintext

C:\> BACKUP C:\data D:\backup

• RESTORE: Restores files from a backup.

 plaintext

C:\> RESTORE D:\backup C:\data

These examples illustrate how to use various MS-DOS commands to manage files,
directories, and disks.

Exp 2: C program to create a clone of current process.

Ans: #include <stdio.h>

#include <unistd.h>

int main() {

pid_t pid;

// Create a new process

pid = fork();

if (pid < 0) {

// Fork failed

fprintf(stderr, "Fork failed\n");

return 1;

} else if (pid == 0) {

// Child process

printf("This is the child process. PID: %d\n", getpid());

} else {

// Parent process

printf("This is the parent process. PID: %d\n", getpid());

}
 return 0;

Exp 3: Write a C program to create a new process using fork().

#include <stdio.h>
1. #include <stdlib.h>
2. #include <unistd.h>
3. #include <sys/types.h>
#include <sys/wait.h>

int main() {
pid_t pid;

// Create a new process

 pid = fork();

if (pid < 0) {
// Error occurred
fprintf(stderr, "fork() failed\n");
exit(1);
}

if (pid == 0) {
// Child process
printf("Child process ID: %d\n", getpid());
printf("Parent process ID: %d\n", getppid());
sleep(2); // Sleep for 2 seconds
printf("Child process exiting...\n");
exit(0);
}

// Parent process
printf("Parent process ID: %d\n", getpid());
printf("Child process ID: %d\n", pid);
wait(NULL); // Wait for child process to finish
printf("Parent process exiting...\n");
return 0;
}
Output:
Exp 4: Implement the parent-child process relationship and demonstrate process termination.

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

int main() {

pid_t pid;

printf("Before fork()\n");

// Create a new process

pid = fork();

if (pid < 0) {

// Error occurred

fprintf(stderr, "fork() failed\n");

exit(1);
 }

if (pid == 0) {

// Child process

printf("Child process ID: %d\n", getpid());

printf("Parent process ID: %d\n", getppid());

printf("Child process: Hello from child!\n");

sleep(2); // Sleep for 2 seconds

printf("Child process exiting...\n");

exit(0);

// Parent process

printf("Parent process ID: %d\n", getpid());

printf("Child process ID: %d\n", pid);

printf("Parent process: Hello from parent!\n");

wait(NULL); // Wait for child process to finish

printf("Parent process exiting...\n");

return 0;

Output:

}
Exp 5: Write a program to simulate First-Come-First-Served (FCFS) scheduling.

#include <stdio.h>

struct Process {

int pid; // process id

int arrival_time; // arrival time

int burst_time; // burst time

};

void fcfs_scheduling(struct Process p[], int n) {

int i, total_waiting_time = 0;

float average_waiting_time;

printf("PID\tAT\tBT\tWT\tTAT\n");

for (i = 0; i < n; i++) {

int waiting_time = (i == 0) ? 0 : p[i-1].burst_time + p[i-1].arrival_time;

int turn_around_time = waiting_time + p[i].burst_time;

printf("%d\t%d\t%d\t%d\t%d\n", p[i].pid, p[i].arrival_time, p[i].burst_time, waiting_time,

turn_around_time);

total_waiting_time += waiting_time;

average_waiting_time = (float)total_waiting_time / n;

printf("Average Waiting Time: %.2f\n", average_waiting_time);

int main() {

int n;
 printf("Enter the number of processes: ");

scanf("%d", &n);

struct Process p[n];

for (int i = 0; i < n; i++) {

printf("Enter arrival time and burst time for process %d: ", i+1);

scanf("%d %d", &p[i].arrival_time, &p[i].burst_time);

p[i].pid = i+1;

fcfs_scheduling(p, n);

return 0;

Output:

Exp 6; C program to simulate Shortest Job First (SJF) scheduling with and without preemption:

#include <stdio.h>
// Structure to represent a process

struct Process {

int pid; // process id

int arrival_time; // arrival time

int burst_time; // burst time

int remaining_time; // remaining time

};

// Function to implement SJF scheduling without preemption

void sjf_scheduling_non_preemptive(struct Process p[], int n) {

int i, j, total_waiting_time = 0;

float average_waiting_time;

// Sort the processes based on their burst time

for (i = 0; i < n; i++) {

for (j = i + 1; j < n; j++) {

if (p[i].burst_time > p[j].burst_time) {

struct Process temp = p[i];

p[i] = p[j];

p[j] = temp;

printf("PID\tAT\tBT\tWT\tTAT\n");

int current_time = 0;

for (i = 0; i < n; i++) {

if (p[i].arrival_time > current_time) {

current_time = p[i].arrival_time;

int waiting_time = current_time - p[i].arrival_time;

 int turn_around_time = waiting_time + p[i].burst_time;

printf("%d\t%d\t%d\t%d\t%d\n", p[i].pid, p[i].arrival_time, p[i].burst_time, waiting_time,

turn_around_time);

total_waiting_time += waiting_time;

current_time += p[i].burst_time;

average_waiting_time = (float)total_waiting_time / n;

printf("Average Waiting Time: %.2f\n", average_waiting_time);

// Function to implement SJF scheduling with preemption

void sjf_scheduling_preemptive(struct Process p[], int n) {

int i, j, total_waiting_time = 0;

float average_waiting_time;

// Sort the processes based on their arrival time

for (i = 0; i < n; i++) {

for (j = i + 1; j < n; j++) {

if (p[i].arrival_time > p[j].arrival_time) {

struct Process temp = p[i];

p[i] = p[j];

p[j] = temp;

printf("PID\tAT\tBT\tWT\tTAT\n");

int current_time = 0;
 int completed_processes = 0;

while (completed_processes < n) {

int shortest_job = -1;

for (i = 0; i < n; i++) {

if (p[i].arrival_time <= current_time && p[i].remaining_time > 0) {

if (shortest_job == -1 || p[i].remaining_time < p[shortest_job].remaining_time) {

shortest_job = i;

if (shortest_job != -1) {

p[shortest_job].remaining_time--;

current_time++;

if (p[shortest_job].remaining_time == 0) {

int waiting_time = current_time - p[shortest_job].arrival_time - p[shortest_job].burst_time;

int turn_around_time = current_time - p[shortest_job].arrival_time;

printf("%d\t%d\t%d\t%d\t%d\n", p[shortest_job].pid, p[shortest_job].arrival_time,

p[shortest_job].burst_time, waiting_time, turn_around_time);

total_waiting_time += waiting_time;

completed_processes++;

} else {

current_time++;

average_waiting_time = (float)total_waiting_time / n;
 printf("Average Waiting Time: %.2f\n", average_waiting_time);

int main() {

int n;

printf("Enter the number of processes: ");

scanf("%d", &n);

struct Process p[n];

for (int i = 0; i < n; i++) {

printf("Enter arrival time and burst time for process %d: ", i+1);

scanf("%d %d", &p[i].arrival_time, &p[i].burst_time);

p[i].pid = i+1;

p[i].remaining_time = p[i].burst_time;

printf("SJF Scheduling without Preemption:\n");

sjf_scheduling_non_preemptive(p, n);

printf("\nSJF Scheduling with Preemption:\n");

sjf_scheduling_preemptive(p, n);

return 0;

Output:
Exp 7: Write c program to simulate round robin scheduling and calculate turnaround and waiting
times.

#include <stdio.h>

#define MAX_PROCESS 100

#define MAX_BURST 100

void roundRobin(int processes[], int n, int burst_times[], int quantum) {

int i, time = 0, total_turnaround = 0, total_waiting = 0;

int turnaround[MAX_PROCESS], waiting[MAX_PROCESS];

// Calculate Turnaround and Waiting Times

for (i = 0; i < n; i++) {

int temp = quantum;

while (temp < burst_times[i]) {

time += quantum;

temp += quantum;

time += burst_times[i] - temp + quantum;

 turnaround[i] = time;

waiting[i] = turnaround[i] - burst_times[i];

total_turnaround += turnaround[i];

total_waiting += waiting[i];

// Print the results

printf("Process\tBurst Time\tTurnaround Time\tWaiting Time\n");

for (i = 0; i < n; i++) {

printf("P%d\t%d\t\t%d\t\t%d\n", i + 1, burst_times[i], turnaround[i], waiting[i]);

printf("Average Turnaround Time: %.2f\n", (float)total_turnaround / n);

printf("Average Waiting Time: %.2f\n", (float)total_waiting / n);

int main() {

int n, i, quantum;

printf("Enter the number of processes: ");

scanf("%d", &n);

int processes[n], burst_times[n];

printf("Enter the burst times for each process:\n");

for (i = 0; i < n; i++) {

scanf("%d", &burst_times[i]);

printf("Enter the time quantum: ");

scanf("%d", &quantum);

roundRobin(processes, n, burst_times, quantum);

return 0;

}
Output:

#include <stdio.h>

Exp 8:Write a c program Implement Priority Scheduling and test with different sets of priorities with
outout.

#include <stdio.h>

#define MAX_PROCESS 100

// Structure to represent a process

typedef struct {

int pid;

int burst_time;

int priority;

} Process;

// Function to swap two processes

void swap(Process *p1, Process *p2) {

 Process temp = *p1;

*p1 = *p2;

*p2 = temp;

// Function to implement Priority Scheduling

void priorityScheduling(Process processes[], int n) {

int i, j, time = 0, total_turnaround = 0, total_waiting = 0;

int turnaround[MAX_PROCESS], waiting[MAX_PROCESS];

// Sort the processes based on their priorities

for (i = 0; i < n - 1; i++) {

for (j = i + 1; j < n; j++) {

if (processes[i].priority < processes[j].priority) {

swap(&processes[i], &processes[j]);

// Calculate Turnaround and Waiting Times

for (i = 0; i < n; i++) {

time += processes[i].burst_time;

turnaround[i] = time;

waiting[i] = turnaround[i] - processes[i].burst_time;

total_turnaround += turnaround[i];

total_waiting += waiting[i];

// Print the results

printf("Process\tBurst Time\tPriority\tTurnaround Time\tWaiting Time\n");

for (i = 0; i < n; i++) {

 printf("P%d\t%d\t\t%d\t\t%d\t\t%d\n", processes[i].pid, processes[i].burst_time,
processes[i].priority, turnaround[i], waiting[i]);

printf("Average Turnaround Time: %.2f\n", (float)total_turnaround / n);

printf("Average Waiting Time: %.2f\n", (float)total_waiting / n);

int main() {

int n, i;

printf("Enter the number of processes: ");

scanf("%d", &n);

Process processes[n];

printf("Enter the burst times and priorities for each process:\n");

for (i = 0; i < n; i++) {

processes[i].pid = i + 1;

scanf("%d %d", &processes[i].burst_time, &processes[i].priority);

priorityScheduling(processes, n);

return 0;

Output:
Exp9: write a c program to implement producer consumer problem of process
syndronization in operating system .

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

#define MAX 5 // Maximum size of the buffer

int buffer[MAX]; // Shared buffer

int in = 0; // Index for the next produced item
int out = 0; // Index for the next consumed item

sem_t empty; // Semaphore to count empty slots

sem_t full; // Semaphore to count full slots
pthread_mutex_t mutex; // Mutex for critical section

void* producer(void* param) {

for (int i = 0; i < 10; i++) {
// Produce an item
int item = rand() % 100;

// Wait for an empty slot

sem_wait(&empty);

// Lock the critical section

pthread_mutex_lock(&mutex);

// Add the item to the buffer

buffer[in] = item;
printf("Produced: %d\n", item);
in = (in + 1) % MAX;

// Unlock the critical section

pthread_mutex_unlock(&mutex);

// Signal that there is a new full slot

sem_post(&full);

// Sleep for a bit

sleep(1);
 }
return NULL;
}

void* consumer(void* param) {

for (int i = 0; i < 10; i++) {
// Wait for a full slot
sem_wait(&full);

// Lock the critical section

pthread_mutex_lock(&mutex);

// Remove the item from the buffer

int item = buffer[out];
printf("Consumed: %d\n", item);
out = (out + 1) % MAX;

// Unlock the critical section

pthread_mutex_unlock(&mutex);

// Signal that there is a new empty slot

sem_post(&empty);

// Sleep for a bit

sleep(1);
}
 return NULL;
}

int main() {
pthread_t prod, cons;

// Initialize semaphores and mutex

sem_init(&empty, 0, MAX); // Initially, the buffer is empty
sem_init(&full, 0, 0); // Initially, no full slots
pthread_mutex_init(&mutex, NULL);

// Create producer and consumer threads

pthread_create(&prod, NULL, producer, NULL);
pthread_create(&cons, NULL, consumer, NULL);

// Wait for threads to finish

pthread_join(prod, NULL);
pthread_join(cons, NULL);

// Clean up
sem_destroy(&empty);
sem_destroy(&full);
pthread_mutex_destroy(&mutex);

return 0;
}
Output:

Exp10:Write a c program to implement dining philosopher problem in

operating system.
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

#define N 5 // Number of philosophers

sem_t mutex; // Mutex for critical section
sem_t S[N]; // Semaphores for each philosopher's chopstick

void* philosopher(void* param) {

int id = *(int*)param;
int left = id;
int right = (id + 1) % N;

while (1) {
// Think for a bit
printf("Philosopher %d is thinking\n", id);
sleep(1);

// Pick up left chopstick

sem_wait(&S[left]);
printf("Philosopher %d picked up left chopstick %d\n", id, left);

// Check if right chopstick is available

sem_wait(&mutex);
if (sem_trywait(&S[right]) == 0) {
printf("Philosopher %d picked up right chopstick %d\n", id, right);

// Eat for a bit

printf("Philosopher %d is eating\n", id);
sleep(1);
 // Put down right chopstick
sem_post(&S[right]);
printf("Philosopher %d put down right chopstick %d\n", id, right);
}
sem_post(&mutex);

// Put down left chopstick

sem_post(&S[left]);
printf("Philosopher %d put down left chopstick %d\n", id, left);
}
return NULL;
}

int main() {
pthread_t threads[N];
int ids[N];

// Initialize semaphores and mutex

sem_init(&mutex, 0, 1);
for (int i = 0; i < N; i++) {
sem_init(&S[i], 0, 1);
ids[i] = i;
}

// Create philosopher threads

for (int i = 0; i < N; i++) {
 pthread_create(&threads[i], NULL, philosopher, &ids[i]);
}

// Wait for threads to finish

for (int i = 0; i < N; i++) {
pthread_join(threads[i], NULL);
}

// Clean up
sem_destroy(&mutex);
for (int i = 0; i < N; i++) {
sem_destroy(&S[i]);
}

return 0;
}

Output:
Exp11:Write a c program to implement reader writer problemof process
syndronization in operating system.
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>

#define READERS 5
#define WRITERS 2

sem_t read_mutex; // Semaphore for controlling access to read_count

sem_t write_mutex; // Semaphore for controlling access to writing
int read_count = 0; // Number of readers currently reading

void* reader(void* param) {

int id = *(int*)param;

while (1) {
// Start reading
sem_wait(&read_mutex);
read_count++;
if (read_count == 1) {
sem_wait(&write_mutex); // First reader locks the writer
}
sem_post(&read_mutex);

// Reading section
printf("Reader %d is reading\n", id);
sleep(1); // Simulate reading time

// End reading
sem_wait(&read_mutex);
read_count--;
if (read_count == 0) {
sem_post(&write_mutex); // Last reader unlocks the writer
}
sem_post(&read_mutex);
 sleep(1); // Simulate time between reads
}
return NULL;
}

void* writer(void* param) {

int id = *(int*)param;

while (1) {
// Start writing
sem_wait(&write_mutex);

// Writing section
printf("Writer %d is writing\n", id);
sleep(2); // Simulate writing time

// End writing
sem_post(&write_mutex);

sleep(1); // Simulate time between writes

}
return NULL;
}

int main() {
pthread_t readers[READERS], writers[WRITERS];
int reader_ids[READERS], writer_ids[WRITERS];

// Initialize semaphores
sem_init(&read_mutex, 0, 1); // Binary semaphore for read_count
sem_init(&write_mutex, 0, 1); // Binary semaphore for writing

// Create reader threads

for (int i = 0; i < READERS; i++) {
reader_ids[i] = i;
pthread_create(&readers[i], NULL, reader, &reader_ids[i]);
}

// Create writer threads

for (int i = 0; i < WRITERS; i++) {
writer_ids[i] = i;
pthread_create(&writers[i], NULL, writer, &writer_ids[i]);
}

// Wait for threads to finish

for (int i = 0; i < READERS; i++) {
pthread_join(readers[i], NULL);
}
for (int i = 0; i < WRITERS; i++) {
pthread_join(writers[i], NULL);
}
 // Clean up
sem_destroy(&read_mutex);
sem_destroy(&write_mutex);

return 0;
}
Output:

Exp 12 : C program to implement bukers algorithm Deadlock avoidance in

operating system.
Ans : #include <stdio.h>

int main() {
int n, m; // n = number of processes, m = number of resources
int i, j, k;

printf("Enter the number of processes: ");

scanf("%d", &n);
printf("Enter the number of resources: ");
scanf("%d", &m);

int allocation[n][m], maximum[n][m], available[m];

int need[n][m], finished[n], safeSequence[n];

// Input Allocation Matrix

printf("Enter the Allocation Matrix:\n");
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &allocation[i][j]);
}
}

// Input Maximum Matrix

printf("Enter the Maximum Matrix:\n");
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &maximum[i][j]);
}
}

// Input Available Resources

printf("Enter the Available Resources:\n");
for (j = 0; j < m; j++) {
scanf("%d", &available[j]);
}
// Calculate the Need Matrix: Need[i][j] = Maximum[i][j] - Allocation[i][j]
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
need[i][j] = maximum[i][j] - allocation[i][j];
}
}

// Initialize Finished array to 0 (false)

for (i = 0; i < n; i++) {
finished[i] = 0;
}

// Banker's Algorithm
int count = 0; // To count the number of processes in the safe sequence
while (count < n) {
int found = 0; // To track if a process is found to execute

for (i = 0; i < n; i++) {

if (!finished[i]) { // Process is not yet finished
for (j = 0; j < m; j++) {
if (need[i][j] > available[j]) {
break; // Resources are insufficient for this process
}
}
 if (j == m) { // All resources for process i can be allocated
// Update Available Resources
for (k = 0; k < m; k++) {
available[k] += allocation[i][k];
}

safeSequence[count++] = i; // Add process to safe sequence

finished[i] = 1; // Mark process as finished
found = 1;
}
}
}

if (!found) { // No process could be executed

printf("System is in an unsafe state. Deadlock may occur.\n");
return 1;
}
}

// Output Safe Sequence

printf("System is in a safe state.\nSafe Sequence: ");
for (i = 0; i < n; i++) {
printf("P%d ", safeSequence[i]);
}
printf("\n");
 return 0;
}
Output: