OPERATING SYSTEMS
Module 4 & Module 5
Complete Exam-Oriented Answers (Questions 1–25)
Applications run without directly controlling hardware, yet they still get work done
efficiently. Which operating system operations make this possible, and how does
switching between different modes of execution ensure safety?
(6 Marks)
Module: UNIT-3
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Dual-Mode Operation, System Calls
Pages: ~35–38 (Chapter 1)
Diagram: Yes — Transition from User Mode to Kernel Mode
Answer
In an operating system, user applications are not allowed to directly control hardware such
as the CPU, memory, disks, or I/O devices. Even though applications cannot access
hardware directly, they still perform all required tasks efficiently through operating
system services and controlled mode switching.
The operating system provides a well-defined interface called system calls, which allow
user programs to request services from the operating system. Common operations such as
file access, memory allocation, process creation, and input/output are all performed using
system calls. When an application needs to read a file or write to a device, it does not
execute hardware instructions directly. Instead, it issues a system call, which safely
transfers control to the operating system.
To ensure safety and protection, modern computer systems use dual-mode operation. At
any time, the system runs either in user mode or kernel mode, controlled by a hardware
mode bit. When a user application is executing, the system is in user mode. In this mode,
the application cannot execute privileged instructions such as direct I/O operations,
interrupt control, or memory management instructions.
When a user program makes a system call, a trap occurs, and the hardware automatically
switches the system from user mode to kernel mode. In kernel mode, the operating system
executes with full access to hardware resources. The kernel verifies the request, performs
the required operation safely, and then switches the system back to user mode before
returning control to the application.
This controlled switching between modes ensures that:
User programs cannot damage the operating system
Hardware resources are protected from misuse
Errors in one program do not affect other programs
Thus, system calls combined with dual-mode execution allow applications to work
efficiently while maintaining system security and stability.
Diagram Mention
📌 Diagram to draw:
“Transition from User Mode to Kernel Mode”
User mode → system call → kernel mode → return to user mode
----------------------------------------------------------------
Explain the common methods for deadlock recovery in operating systems. Give a
brief description of how each method works.
(6 Marks)
Module: UNIT-3 (Deadlocks)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Deadlock Recovery
Pages: ~270–274 (Chapter on Deadlocks)
4d55f6b3-52e5-4c5b-9ab5-ee3a946…
Diagram: Not mandatory (flow explanation sufficient)
Answer
Deadlock recovery techniques are applied after a deadlock has already occurred in the
system. Once the operating system detects a deadlock, it must take corrective action to
break the deadlock and allow the system to continue functioning. The main goal of deadlock
recovery is to eliminate at least one of the deadlock conditions.
One common method of deadlock recovery is process termination. In this approach, the
operating system aborts one or more processes involved in the deadlock. Deadlock can be
eliminated either by terminating all deadlocked processes at once, which is simple but
expensive, or by terminating processes one at a time until the deadlock cycle is broken.
When selecting a process to terminate, the operating system considers factors such as
process priority, amount of work completed, resources used, and cost of restarting the
process.
Another important method is resource preemption. In this approach, the operating system
temporarily takes resources away from one or more deadlocked processes and assigns
them to other processes to break the deadlock. Resource preemption requires three steps.
First, a victim process is selected whose resources can be safely taken away. Second, the
system rolls back the victim process to a safe state so that it can restart later. Finally, the
system ensures that the same process is not always selected as the victim, preventing
starvation.
A third recovery approach involves rollback and checkpointing. In systems that support
checkpointing, the operating system periodically saves the state of a process. If a deadlock
occurs, affected processes can be rolled back to a previously saved safe state, releasing the
resources they were holding. This allows the system to recover without permanently
terminating processes.
Each deadlock recovery method involves trade-offs between system overhead, complexity,
and performance. The operating system chooses an appropriate recovery technique based
on system requirements and the criticality of running processes.
----------------------------------------------------------------
Write a C program to implement the Producer–Consumer Problem.
(4 Marks)
Module: UNIT-3 (Process Synchronization)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Topic: Producer–Consumer Problem using Semaphores
Diagram: Not required (code-based question)
The Producer–Consumer Problem is a classical synchronization problem where one or
more producer processes produce items and place them into a shared buffer, while one or
more consumer processes remove items from the buffer. The key issue is to ensure mutual
exclusion and proper synchronization, so that the producer does not add data to a full
buffer and the consumer does not remove data from an empty buffer.
Semaphores are used to solve this problem by controlling access to the shared buffer. Three
semaphores are commonly used:
mutex for mutual exclusion
empty to count empty slots in the buffer
full to count filled slots in the buffer
Below is a simple C program using semaphores that demonstrates the producer–consumer
solution.
In this program, the producer waits on the empty semaphore before inserting an item into
the buffer, ensuring that the buffer is not full. The mutex semaphore ensures that only one
thread accesses the buffer at a time. After producing an item, the producer signals the full
semaphore. Similarly, the consumer waits on the full semaphore before removing an item
and signals the empty semaphore after consumption. This guarantees correct
synchronization and prevents race conditions
----------------------------------------------------------------
UNIT-3 — QUESTION 4
Deadlock cannot occur unless certain requirements are satisfied. Identify and explain
these requirements. What fundamental conditions make it possible for processes to
enter into a deadlock state?
(4 Marks)
Module: UNIT-3 (Deadlocks)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Necessary Conditions for Deadlock
Pages: ~261–264 (Deadlocks chapter)
Diagram: Optional (Resource Allocation Graph can be used)
Answer
A deadlock is a situation in which a set of processes are permanently blocked because each
process is waiting for a resource that is currently held by another process in the set.
According to the operating system theory, deadlock cannot occur arbitrarily. It can occur
only if four necessary conditions hold simultaneously. These are known as the
fundamental conditions for deadlock.
The first condition is mutual exclusion. This condition states that at least one resource
must be non-sharable. That is, only one process can use the resource at a time. If another
process requests that resource, it must wait until the resource is released. Examples include
printers, tapes, or critical sections of code.
The second condition is hold and wait. Under this condition, a process is holding at least
one resource while waiting to acquire additional resources that are currently being held by
other processes. This situation increases the possibility of deadlock because processes keep
resources while requesting new ones.
The third condition is no preemption. This means that resources cannot be forcibly taken
away from a process. A resource can be released only voluntarily by the process holding it,
after the process has completed its task. Because the operating system cannot preempt the
resource, other waiting processes remain blocked.
The fourth and final condition is circular wait. This condition exists when a set of processes
are waiting for resources in a circular chain. For example, process P1 is waiting for a
resource held by P2, P2 is waiting for a resource held by P3, and P3 is waiting for a resource
held by P1. This circular dependency causes a deadlock.
Deadlock occurs only when all four of these conditions hold at the same time. If any one
of these conditions is eliminated, deadlock cannot occur. Therefore, these conditions form
the theoretical foundation for deadlock prevention and avoidance techniques.
Diagram Mention
📌 Diagram (if drawn):
Resource Allocation Graph showing circular wait among processes and resources.
----------------------------------------------------------------
UNIT-3 — QUESTION 5
Define Semaphore. Explain how semaphores are used to solve the critical section
problem with the help of the atomic operations wait() and signal().
(7 Marks)
Module: UNIT-3 (Process Synchronization)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Semaphores
Pages: ~230–236
Diagram: Optional (Critical section control using semaphore)
Answer
A semaphore is a synchronization tool used by the operating system to control access to
shared resources in a concurrent system. It is an integer variable that is accessed and
modified only through two atomic operations, namely wait() and signal(). Semaphores are
widely used to solve the critical section problem, ensuring mutual exclusion and proper
synchronization among processes.
There are two main types of semaphores: counting semaphores and binary semaphores.
A counting semaphore can take any non-negative integer value and is used to manage
multiple instances of a resource. A binary semaphore can take only the values 0 and 1 and is
functionally similar to a mutex lock.
The wait() operation is used when a process wants to enter the critical section. When
wait(S) is executed, the semaphore value is decremented. If the resulting value is negative,
the process is blocked and placed in a waiting queue associated with the semaphore. The
signal() operation is used when a process exits the critical section. It increments the
semaphore value, and if there are waiting processes, one of them is awakened.
To solve the critical section problem, a semaphore is initialized to 1, indicating that the
critical section is free. Before entering the critical section, a process executes the wait()
operation. If the semaphore value becomes 0, other processes attempting to enter the
critical section will be blocked. After completing execution in the critical section, the process
executes the signal() operation, allowing another waiting process to enter.
Because the wait() and signal() operations are atomic, they prevent race conditions and
ensure that only one process can execute the critical section at a time. Thus, semaphores
provide a reliable mechanism for achieving mutual exclusion, progress, and bounded
waiting.
Pseudo-code Illustration
semaphore mutex = 1;
do {
wait(mutex);
// critical section
signal(mutex);
// remainder section
} while (true);
Diagram Mention
📌 Diagram (if drawn):
Processes competing for a critical section controlled by a semaphore.
----------------------------------------------------------------
UNIT-3 — QUESTION 6
Briefly describe the data structures used in the implementation of Banker’s
Algorithm for deadlock avoidance.
(3 Marks)
Module: UNIT-3 (Deadlock Avoidance)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Banker’s Algorithm
Pages: ~285–288
Diagram: Not required (table-based explanation)
Answer
The Banker’s Algorithm is a deadlock avoidance algorithm that requires the operating
system to maintain information about the resources currently allocated to processes and
the resources that processes may request in the future. To make decisions about safe and
unsafe states, the algorithm uses several important data structures.
The first data structure is the Available vector. This vector represents the number of
available instances of each resource type in the system. It indicates how many resources are
currently free and can be allocated to processes.
The second data structure is the Max matrix. This matrix defines the maximum number of
instances of each resource type that each process may request during its execution. This
information is declared in advance by the processes and is essential for deadlock avoidance.
The Allocation matrix stores the number of resources of each type that are currently
allocated to each process. It represents the current resource usage in the system.
Another important data structure is the Need matrix. This matrix indicates the remaining
resource needs of each process. It is calculated as:
Need = Max − Allocation
The Need matrix helps the system determine whether a process can complete with the
currently available resources.
Together, these data structures allow the operating system to check whether the system is
in a safe state before granting resource requests, thereby avoiding deadlock.
----------------------------------------------------------------
UNIT-3 — QUESTION 7
A system designer wants to ensure that deadlock never occurs. What deadlock
prevention techniques can be adopted to achieve this?
(10 Marks)
Module: UNIT-3 (Deadlock Handling)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Deadlock Prevention
Pages: ~264–270 (Deadlocks chapter)
Diagram: Optional — resource allocation order illustration
Answer
Deadlock prevention is a strategy used by operating systems to ensure that deadlock never
occurs by structurally preventing one or more of the necessary conditions for deadlock
from holding. Since deadlock can occur only when all four necessary conditions are satisfied
simultaneously, deadlock prevention works by negating at least one of these conditions.
The first prevention technique targets the mutual exclusion condition. Mutual exclusion
requires that at least one resource must be non-sharable. To prevent deadlock, the
operating system can make resources sharable wherever possible. For example, read-only
files can be shared by multiple processes simultaneously. However, this technique cannot
be applied to all resources, since some resources such as printers and critical sections are
inherently non-sharable. Therefore, eliminating mutual exclusion is not always practical.
The second technique addresses the hold and wait condition. Deadlock can be prevented
by ensuring that processes do not hold resources while waiting for others. One method is to
require each process to request all required resources at once before execution begins. If
all resources are available, the process proceeds; otherwise, it waits without holding any
resource. Another approach is to allow a process to request resources only when it is
holding none. Although this method prevents deadlock, it may lead to low resource
utilization and possible starvation.
The third prevention technique eliminates the no preemption condition. This can be done
by allowing the operating system to preempt resources from a process. If a process
holding certain resources requests another resource that cannot be immediately allocated,
the system forces the process to release its currently held resources. These resources are
later reallocated when the process restarts. This method is effective for resources whose
state can be easily saved and restored, such as CPU registers and memory, but it is not
suitable for all resource types.
The fourth and most widely used prevention technique eliminates the circular wait
condition. This is achieved by imposing a total ordering on all resource types. Each
resource type is assigned a unique number, and processes are required to request resources
in strictly increasing order of their assigned numbers. By enforcing this ordering, circular
waiting is impossible, because a process holding a higher-numbered resource can never
request a lower-numbered one.
Deadlock prevention techniques guarantee freedom from deadlock, but they often reduce
system performance and resource utilization. Therefore, operating systems must carefully
balance safety and efficiency when choosing a deadlock handling strategy.
Diagram Mention
📌 Diagram (if drawn):
Resource ordering diagram showing processes requesting resources in increasing order to
avoid circular wait.
----------------------------------------------------------------
UNIT-3 — QUESTION 8
Discuss how the critical section arises in the bounded buffer problem and how it can
be handled. Write pseudo-code using semaphores.
(10 Marks)
Module: UNIT-3 (Process Synchronization)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Bounded-Buffer (Producer–Consumer) Problem
Pages: ~233–240
Diagram: Yes — Bounded buffer with producer and consumer accessing shared buffer
Answer
The bounded buffer problem is a classic synchronization problem that illustrates how a
critical section arises when multiple processes access shared data concurrently. In this
problem, a fixed-size buffer is shared between producer processes, which generate data
items and place them into the buffer, and consumer processes, which remove and use
these data items.
A critical section arises because both the producer and the consumer access and modify
shared variables, such as the buffer itself and the indices that indicate the next insertion or
removal position. If multiple producers or consumers operate simultaneously without
synchronization, race conditions may occur. For example, two producers might try to
insert data into the same buffer position, or a consumer might try to remove data from an
empty buffer. Such situations lead to inconsistent data and incorrect program behavior.
To handle the critical section problem in the bounded buffer scenario, the operating system
uses semaphores to enforce synchronization and mutual exclusion. Three semaphores are
commonly used:
A binary semaphore mutex to ensure mutual exclusion while accessing the shared
buffer.
A counting semaphore empty to keep track of the number of empty slots in the
buffer.
A counting semaphore full to keep track of the number of filled slots in the buffer.
The semaphore mutex ensures that only one process at a time can enter the critical section
where the buffer is accessed. The empty semaphore prevents producers from inserting
items when the buffer is full, while the full semaphore prevents consumers from removing
items when the buffer is empty. The atomic operations wait() and signal() are used to
decrement and increment semaphore values safely.
By using these semaphores, the bounded buffer problem can be solved in a way that
guarantees mutual exclusion, progress, and bounded waiting, which are the essential
requirements of a correct solution to the critical section problem.
Pseudo-code Using Semaphores
semaphore mutex = 1;
semaphore empty = N; // N = buffer size
semaphore full = 0;
Producer:
do {
produce_item();
wait(empty);
wait(mutex);
insert_item();
signal(mutex);
signal(full);
} while (true);
Consumer:
do {
wait(full);
wait(mutex);
remove_item();
signal(mutex);
signal(empty);
consume_item();
} while (true);
Diagram Mention
📌 Diagram to draw:
Bounded buffer showing:
Producer inserting items
Consumer removing items
Shared buffer protected by semaphores
UNIT-3 — QUESTION 9
Using semaphores, explain the algorithm (pseudo-code) to implement a solution for
the Reader’s–Writer’s Problem where multiple readers are allowed to read
simultaneously and writers require exclusive access to the shared resource.
(7 Marks)
Module: UNIT-3 (Process Synchronization)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Readers–Writers Problem
Pages: ~245–250
Diagram: Optional — readers and writers accessing a shared database
Answer
The Readers–Writers Problem is a classical synchronization problem that models
situations where a shared data structure, such as a database or file, is accessed by two types
of processes: readers and writers. The key requirement of this problem is that multiple
readers should be allowed to read the shared resource simultaneously, while writers
must have exclusive access to the resource.
A critical synchronization issue arises because readers do not modify the data and can
safely access it together, whereas writers modify the data and must not be interrupted by
either other writers or readers. If proper synchronization is not enforced, data
inconsistency may occur.
To solve this problem using semaphores, the operating system uses:
A binary semaphore wrt to control access to the shared resource.
A binary semaphore mutex to protect the shared variable readcount.
An integer variable readcount to keep track of the number of active readers.
The idea behind the solution is that the first reader locks the shared resource by acquiring
the wrt semaphore, preventing writers from entering. Subsequent readers are allowed to
enter without blocking each other. When the last reader finishes, it releases the wrt
semaphore, allowing writers to access the resource. Writers must acquire the wrt
semaphore before writing, ensuring exclusive access.
This solution allows high concurrency for readers while ensuring correctness and mutual
exclusion for writers.
Pseudo-code Using Semaphores
semaphore mutex = 1;
semaphore wrt = 1;
int readcount = 0;
Reader:
do {
wait(mutex);
readcount++;
if (readcount == 1)
wait(wrt);
signal(mutex);
// reading is performed
wait(mutex);
readcount--;
if (readcount == 0)
signal(wrt);
signal(mutex);
} while (true);
Writer:
do {
wait(wrt);
// writing is performed
signal(wrt);
} while (true);
Diagram Mention
📌 Diagram (if drawn):
Shared database accessed by multiple readers simultaneously, with writers having
exclusive access controlled by semaphores.
----------------------------------------------------------------
UNIT-3 — QUESTION 10
Explain the requirements of a solution to the critical section problem with its general
structure.
(3 Marks)
Module: UNIT-3 (Process Synchronization)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Critical Section Problem
Pages: ~200–204
Diagram: Optional — general structure of a process showing critical section
Answer
The critical section problem arises in a concurrent system when multiple processes share
common data or resources, and each process has a segment of code called the critical
section where shared data is accessed or modified. A correct solution to the critical section
problem must satisfy certain essential requirements to ensure safe and efficient execution.
The first requirement is mutual exclusion. This condition states that only one process at
a time can be allowed to execute its critical section. If one process is executing in its critical
section, no other process should be permitted to enter its own critical section. This
requirement prevents race conditions and ensures data consistency.
The second requirement is progress. Progress ensures that if no process is currently
executing in its critical section and some processes wish to enter their critical sections, the
decision of which process enters next cannot be postponed indefinitely. Only processes
that are not in their remainder sections should participate in the decision, ensuring forward
movement of execution.
The third requirement is bounded waiting. This condition ensures that there exists a
bound on the number of times other processes are allowed to enter their critical sections
after a process has requested entry. In other words, a process should not wait indefinitely to
enter its critical section, preventing starvation.
General Structure of a Process
do {
// entry section
// critical section
// exit section
// remainder section
} while (true);
Diagram Mention
📌 Diagram (if drawn):
Process structure showing entry section → critical section → exit section → remainder
section.
----------------------------------------------------------------
UNIT-3 — QUESTION 11
**Define Resource Allocation Graph (RAG). List its components with neat
illustrations. Explain the following scenarios:
(a) RAG with Deadlock
(b) RAG with Cycle but No Deadlock**
(10 Marks)
Module: UNIT-3 (Deadlocks)
Textbook: Operating System Concepts – Silberschatz, Galvin, Gagne
Relevant Section: Resource Allocation Graph
Pages: ~257–261 (Deadlocks chapter)
Diagram: Yes (VERY IMPORTANT) — RAG diagrams
Answer
A Resource Allocation Graph (RAG) is a directed graph used by the operating system to
represent the state of resource allocation in a system. It is mainly used to model deadlocks
and to analyze whether a deadlock has occurred or may occur in the future. The graph
provides a visual representation of how processes and resources are related.
In a Resource Allocation Graph, processes and resources are represented as nodes, and
the relationships between them are represented as directed edges.
Components of a Resource Allocation Graph
A RAG consists of the following components:
A process node is represented by a circle. Each process in the system is shown as a
separate process node (P₁, P₂, P₃, etc.).
A resource node is represented by a rectangle. Each resource type (R₁, R₂, etc.) is shown
with dots inside the rectangle to indicate the number of instances of that resource.
A request edge is a directed edge drawn from a process node to a resource node. It
indicates that the process has requested an instance of that resource and is waiting for it.
An assignment edge is a directed edge drawn from a resource node to a process node. It
indicates that an instance of the resource has been allocated to that process.
(a) Resource Allocation Graph with Deadlock
A deadlock occurs in a Resource Allocation Graph when a cycle exists and each resource
has only one instance. In this situation, every process in the cycle is holding one resource
and waiting for another resource held by the next process in the cycle. Since none of the
processes can proceed, the system enters a deadlock state.
For example, consider two processes P₁ and P₂ and two resources R₁ and R₂, each having
one instance. If P₁ holds R₁ and requests R₂, while P₂ holds R₂ and requests R₁, a circular
wait is formed. This circular dependency creates a deadlock, and none of the processes can
continue execution.
Thus, a cycle in the RAG is a sufficient condition for deadlock when each resource has
a single instance.
(b) Resource Allocation Graph with Cycle but No Deadlock
A cycle in a Resource Allocation Graph does not always indicate a deadlock. When
resources have multiple instances, a cycle may exist, but deadlock may not occur.
For example, consider a resource R₁ with two instances and two processes P₁ and P₂. Even if
both processes request the resource, the operating system can allocate the second instance
to one of the waiting processes, allowing it to proceed. As a result, the cycle is broken and
the system continues execution without deadlock.
In this case, the presence of a cycle is only a necessary condition, not a sufficient condition,
for deadlock.
Diagram Mention (VERY IMPORTANT FOR EXAM)
📌 Diagram 1:
RAG showing deadlock
Circular wait
Single instance of each resource
📌 Diagram 2:
RAG showing cycle but no deadlock
Multiple instances of a resource
One process can proceed
Key Exam Conclusion (You can write this line)
If a Resource Allocation Graph contains no cycle, deadlock cannot occur.
If a cycle exists, deadlock may or may not occur depending on the number of resource
instances.
Why this answer gets full marks
✔ Proper definition of RAG
✔ All components clearly explained
✔ Both scenarios explained separately
✔ Correct deadlock logic (necessary vs sufficient)
✔ Diagram emphasis (exam-friendly)
END OF DOCUMENT