1.

Readers and Writers Problem

The Readers-Writers Problem addresses the challenge of managing shared memory where
multiple threads may either read or write data. The issue arises because no one should access the
memory while a writer is writing. However, multiple readers can read simultaneously. Here's a
simplified explanation of each problem:
1. First Readers-Writers Problem (Readers Preference):
 Goal: Prioritize readers so they don't wait unnecessarily if the memory is open for reading.
 Issue: If a reader is reading and another reader wants to read, it can join immediately without
waiting. This is efficient for readers but can make writers wait for a long time if there are always
readers requesting access.
 Example: Imagine a library where many readers can read a book simultaneously, but when a
writer wants to update the book, they have to wait until all readers are done. If readers keep
coming, the writer may never get a chance.
2. Second Readers-Writers Problem (Writers Preference):
 Goal: Prioritize writers so they aren't delayed by incoming readers.
 Issue: If a writer is waiting and a new reader arrives, the reader must wait until the writer is
done. This ensures writers get their turn quickly, but readers might have to wait longer.
 Example: In the same library, if a writer wants to update the book, no new readers are allowed
to read until the writer finishes updating. This prevents the writer from waiting endlessly.
3. Third Readers-Writers Problem (Fairness for All):
 Goal: Ensure no thread (reader or writer) waits forever, preventing starvation.
 Issue: Sometimes readers must wait even if reading is allowed, and writers might wait longer
than ideal, but this ensures everyone gets a turn within a reasonable time.
 Example: In the library, if a writer has been waiting for a long time, readers stop accessing the
book to let the writer update. Similarly, if readers have been waiting, the writer waits after their
turn.
Key Idea:
 First problem: Readers are prioritized (Writers may starve).
 Second problem: Writers are prioritized (Readers may starve).
 Third problem: Everyone gets a fair chance, but sometimes both readers and writers may have
to wait.
The goal is to balance the needs of both readers and writers effectively.
2. Explain the concept of an Access Matrix in computer security. Provide an example
scenario where an Access Matrix would be applicable and describe how it helps in
managing access control in that scenario. In operating system?
Access Matrix in Computer Security (Operating Systems)
An Access Matrix in operating systems is a security model used to define and manage access
permissions for various users (subjects) and resources (objects). It ensures that every subject can
perform only the permitted actions on specific objects.
 Subjects: Users, processes, or programs.
 Objects: Files, directories, devices, or any resource in the system.
 Access Rights: Permissions such as read, write, execute, delete, etc.
The Access Matrix is represented as a table:
 Rows correspond to subjects.
 Columns correspond to objects.
 Entries in the matrix specify the permissions a subject has over an object.

Example Scenario: File System in an Operating System

Imagine an operating system managing a shared directory with multiple users: Admin, User1,
and User2.
Access Matrix:
Subjects/ Shared Folder User1 User2 System
Objects File File Logs
Admin Read, Write Read, Read, Read,
Write Write Write
User1 Read, Write Read, None None
Write
User2 Read, Write None Read, None
Write

How It Helps in Managing Access Control

1. Prevents Unauthorized Access:
o The matrix ensures User1 cannot access User2's file or system logs, and vice versa.
o This limits the potential for accidental or malicious actions.
2. Granular Control:
o Admin has full access to all resources, while regular users have access only to their own
files and shared resources.
o This ensures roles are clearly defined.
3. Flexibility and Scalability:
o New users or resources can be easily added to the matrix.
o Permissions can be updated without affecting other users.
4. Improved Security:
o By explicitly defining what each subject can do, the system reduces vulnerabilities, like
data breaches or accidental deletions.

Implementation in Operating Systems

Operating systems like Unix/Linux implement similar access control using file permissions
(e.g., rw-r--r--) for:
 Owner (subject).
 Group.
 Others.
Access Matrices form the theoretical foundation for such permission systems, ensuring secure
and efficient resource management.

3. By using access matrix, how do we secure an os?

Using an Access Matrix, an operating system (OS) can implement a robust security mechanism
to control access to system resources and protect against unauthorized activities. Here's how the
Access Matrix helps secure an OS:

1. Define Clear Access Control Policies

 The Access Matrix explicitly specifies what actions (e.g., read, write, execute) a user or process
(subject) can perform on a resource (object).
 Example: A user can read a file but cannot write or delete it, while another user may have full
control over it.
How It Secures the OS:
This prevents accidental or malicious access, ensuring users only interact with resources as
intended.

2. Prevent Unauthorized Access

 The Access Matrix ensures that unauthorized users or processes cannot access resources.
 For instance:
o A regular user cannot access system logs or kernel files.
o A guest user cannot modify application settings.
How It Secures the OS:
Limits the attack surface by ensuring only authorized entities can interact with critical system
components.

3. Isolate Processes and Users

 Each process or user operates within a defined boundary of permissions.
 This isolation ensures that one user's actions do not interfere with others' data or processes.
How It Secures the OS:
Prevents data leaks, tampering, or accidental modifications to resources used by other users.

4. Dynamic Permission Updates

 The Access Matrix allows administrators to dynamically update permissions for users or
processes.
 Example:
o Temporarily grant a user write access to a file and revoke it later.
o Assign higher permissions to a process only during installation or updates.
 How It Secures the OS:
Ensures minimal access is granted only when necessary, reducing vulnerabilities.

5. Auditing and Monitoring

 The Access Matrix structure enables efficient logging and monitoring of access attempts.
 Failed attempts to access restricted resources can trigger alerts.
How It Secures the OS:
Helps detect and respond to potential security threats, such as intrusion attempts.

6. Mitigate Security Risks (Starvation and Deadlock)

 By using advanced versions of the Access Matrix (like capabilities lists or access control lists),
the OS ensures fair access to resources without causing starvation or deadlocks.
 Example: Writers and readers in a shared memory area are managed fairly.
How It Secures the OS:
Prevents resource hoarding or denial of service to critical system operations.

7. Role-Based Access Control (RBAC)

 The Access Matrix forms the foundation for implementing RBAC, where permissions are
granted based on roles rather than individual users.
 Example:
o A "Manager" role has higher access than a "Staff" role.
o System services have elevated permissions compared to user processes.
How It Secures the OS:
Simplifies permission management and reduces human error in granting access.

8. Practical Use in OS Security

Operating systems like Unix/Linux and Windows use principles of the Access Matrix to
implement file permissions and access control mechanisms:
 Unix/Linux: rw-r--r-- permissions define read/write access for owner, group, and others.
 Windows: NTFS uses Access Control Lists (ACLs) derived from the Access Matrix.
By systematically enforcing these rules, the OS ensures secure and efficient resource
management.

4. briefly describe the implementation of access matrix.

The implementation of an Access Matrix involves storing and managing the access control
information in practical data structures. Since a full matrix can be large and sparse, efficient
representations are used:

1. Global Table
 A single table contains all access rights, listing the subject, object, and the permissions.
 Example:
 mathematica
Copy code
Subject Object Access Rights
User1 File1 Read, Write
User2 File2 Read
 Pros: Simple to implement.
 Cons: Hard to manage for large systems, as it can become a bottleneck.

2. Access Control Lists (ACLs)

 Each object (e.g., file, folder) maintains a list of subjects and their access rights.
 Example for File1: File1: User1 - Read, Write; User2 - Read
 Pros: Easy to check permissions for an object.
 Cons: Difficult to see all permissions for a subject.

3. Capability Lists
 Each subject maintains a list of objects it can access and the corresponding rights.
 Example for User1: User1: File1 - Read, Write; File3 - Read
 Pros: Easy to check permissions for a subject.
 Cons: Difficult to view all access rights for an object.

4. Hybrid Approach
 Combines ACLs and Capability Lists to balance the trade-offs.
 Example: ACLs for frequently accessed objects and Capability Lists for active subjects.

5. Using Bitmaps or Sparse Matrices

 A compact representation for permissions, especially when the number of subjects and objects is
large but sparse.
 Each permission can be represented as a bit in a bitmap.

Key Considerations:
 Efficiency: Choose data structures that minimize lookup and storage overhead.
 Scalability: Ensure the system can handle a growing number of users and resources.
 Security: Protect access control data from unauthorized modifications.
These methods ensure the Access Matrix is implemented efficiently while maintaining security
and usability.

5. Explain types of virtual machine and their implementations.

Types of Virtual Machines and Their Implementations
Virtual Machines (VMs) are categorized into two types based on their functionality and scope:

1. System Virtual Machine:

 Definition:
o Provides a complete system platform to simulate an entire operating system (OS).
o Allows users to install and run an OS as if it were on actual hardware.
 Features:
o Creates a full virtualization environment for an OS.
o Simulates hardware components, enabling multiple OS instances to run on a single
physical machine.
o Hardware is distributed and managed by a Virtual Machine Monitor (VMM) or
hypervisor.
 Implementation:
o Examples include VirtualBox, VMware, Hyper-V.
o Used in scenarios like:
 Running multiple OSs on the same physical system.
 Testing or developing software in different environments.
 Server virtualization to optimize resource utilization.

2. Process Virtual Machine:

 Definition:
o Designed to run a single application or process in a virtualized environment.
o Does not simulate a full operating system but creates a temporary virtual environment for
specific processes.
 Features:
o The virtual environment is created when the application starts and destroyed when it exits.
o Provides compatibility for applications requiring different operating systems or
environments.
 Implementation:
o Examples include:
 Java Virtual Machine (JVM): Allows Java programs to run on any device with a
JVM installed.
 Wine (Linux): Enables Windows applications to run on Linux systems.
 Docker Containers: Isolate applications while sharing the same OS kernel.
o Commonly used for:
 Cross-platform application compatibility.
 Running lightweight, isolated applications.
Key Differences
Feature System Virtual Machine Process Virtual Machine
Scope Full OS virtualization Single process or application
Persistence Long-term environment Temporary, exits with process
Examples VirtualBox, VMware, Hyper-V JVM, Wine, Docker
 Use Cases Running multiple OSs, testing OS App portability, cross-platform

Both types of virtual machines have unique advantages and are implemented in scenarios that
optimize hardware usage or enhance application compatibility.

6. Benefits of Virtual Machines

1. Save Hardware Costs: Use one machine to run multiple operating systems.
2. Efficient Resource Use: Fully utilize CPU, memory, and storage.
3. Safe Testing: Run untrusted software without affecting the main system.
4. Quick Backups: Easily restore systems using snapshots.
5. Flexible: Move VMs between computers or servers easily.
6. Easy Scalability: Add new VMs as needed without extra hardware.
7. Cross-Platform Use: Run apps from different operating systems on one machine.
8. Secure Isolation: Problems in one VM don’t affect others or the host system.
9. Training Tool: Create controlled environments for learning or experiments.
10.Disaster Recovery: Restore operations quickly during failures.
7. Thrashing (prevention)
Thrashing occurs when the system spends more time handling page faults than executing processes,
degrading performance.
Key Points:
1. Cause:
o Happens when memory is over-committed due to multitasking.
o Frequently accessed pages are swapped out, causing repeated page faults.
o Excessive swapping leads to performance overhead.
2. Relation:
o Directly related to the degree of multiprogramming (number of active processes).
3. Effects:
o Reduces system efficiency.
o Causes unnecessary CPU and memory overhead.
Methods to Handle Thrashing(preventing and handling thrashing):
 1. Suspend Processes:
o Reduces the degree of multiprogramming to free up memory for running processes.
o Helps the system recover by prioritizing essential processes.
2. Optimize Page Replacement Algorithm:
o Ensures efficient management of memory by reducing unnecessary page faults.
o Example: Algorithms like Least Recently Used (LRU) or Optimal Page Replacement.
3. Local Page Replacement:
o Limits the impact of one process on another by swapping pages only within a process’s
allocated frames.
4. Working Set Model:
o Prevents thrashing by ensuring processes have enough frames to handle their active page
set.
o Dynamically adjusts memory allocation based on process needs.
These methods not only help handle ongoing thrashing but also prevent it from occurring in the first
place. These methods aim to minimize swapping and maintain system performance.
Or
Prevention of Thrashing
1. Reduce Degree of Multiprogramming: Limit the number of active processes to reduce
memory over-commitment.
2. Use Local Page Replacement: Allocate and manage frames locally for each process to avoid
interference between processes.
3. Adopt Working Set Model: Allocate frames based on the "working set" of a process (the set of
pages it is actively using).
4. Monitor and Adjust CPU Utilization: If CPU utilization drops due to thrashing, reduce the
number of running processes.
5. Increase Physical Memory: Add more memory to the system to accommodate more processes.
6. Implement Efficient Page Replacement Algorithms: Use algorithms like Least Recently Used
(LRU) to minimize page faults.
7. Explain difference between protection and security.
Protection Security
 Controls access to system resources. Safeguards the system from threats.
Focuses on internal threats (misuse by Focuses on both internal and external
users). threats.
Example: File permissions (read, write, Example: Firewalls, encryption, antivirus.
execute).
Enforces access control policies. Prevents unauthorized access or attacks.
Relies on authentication and authorization. Includes techniques like cryptography.
Ensures proper usage of system resources. Protects against data breaches or hacking.
Deals with legitimate users’ behavior. Deals with malicious users and software.
Analogy: Locks on doors or user IDs. Analogy: Security guard or surveillance.

8. Goals of Security
1. Confidentiality
o Ensures that information is accessible only to authorized users.
o Protects sensitive data from being disclosed to unauthorized entities.
o Example: Encrypting messages to prevent interception.
2. Integrity
o Ensures data is accurate and unaltered.
o Protects against unauthorized modifications, whether accidental or malicious.
o Example: Checksums and cryptographic hash functions ensure file integrity.
3. Availability
o Ensures that resources and services are available to authorized users when needed.
o Protects against disruptions caused by attacks like denial-of-service (DoS).
o Example: Backup systems and redundancy mechanisms.
4. Authentication
o Verifies the identity of users or systems accessing resources.
o Ensures that only legitimate entities can gain access.
o Example: Login credentials, biometric scans.
5. Non-repudiation
 o Ensures that parties in a communication cannot deny their actions.
o Provides proof of data origin and receipt.
o Example: Digital signatures in emails.
Principles of Security
1. Least Privilege
o Users and processes should have the minimum level of access necessary to perform their
tasks.
o Reduces the impact of potential breaches.
o Example: A cashier in a bank cannot access the financial database.
2. Defence in Depth
o Employs multiple layers of security controls to protect systems.
o Ensures that if one defense fails, others will still protect the system.
o Example: Using firewalls, intrusion detection systems, and encryption together.
3. Separation of Duties
o Divides responsibilities among multiple people or systems to prevent fraud or misuse.
o Example: In financial systems, the person approving a transaction is not the one who
initiates it.
4. Fail-Safe Defaults
o Systems should deny access by default and grant it only when explicitly authorized.
o Example: File permissions default to "no access" unless specified otherwise.
5. Open Design
o Security mechanisms should not depend on secrecy of design; they should rely on the
strength of the implementation.
o Example: Public cryptographic algorithms are preferred over secret ones.
6. Accountability
o Actions performed within a system should be traceable to the responsible entity.
o Example: Logging user activities in audit trails.
7. Economy of Mechanism
 o Security mechanisms should be as simple and small as possible to reduce complexity and
errors.
o Example: Minimalistic design in firewalls.
These goals and principles form the foundation of designing secure systems and policies.

9. What is a Page Table?

A Page Table is a data structure used by the operating system to manage memory in a virtual
memory system. It maps virtual addresses (used by programs) to physical addresses (locations in
actual RAM).
Functions of Page Table
1. Translates virtual page numbers to physical frame numbers.
2. Maintains metadata like access permissions (read, write, execute).
3. Enables efficient memory management, process isolation, and dynamic memory allocation.
Methods to Implement Page Tables
Method How It Worksd Pros Cons
1. Single-Level A single table maps all virtual pages to Simple to implement. Uses a lot of memory
physical frames. for large address
spaces.
2. Multi-Level Breaks the table into smaller levels. Virtual Saves memory by creating Slower because of
addresses are divided into parts to access smaller tables only for multiple lookups.
these levels. active pages.
3. Inverted Stores one entry per physical frame instead Saves memory for large Slower due to hash
of per virtual page. Uses a hash function to address spaces. lookups and collisions.
find pages.
4. Hashed Uses a hash table to map virtual pages to Efficient for very large Complex to manage
physical frames. address spaces. hash collisions.
5. TLB (with Uses a hardware cache called the Speeds up memory access Needs extra hardware
Page Table) Translation Lookaside Buffer (TLB) to significantly. and management.
store recently used mappings for faster
access.
6. Segmented Combines segments and pages. The Efficient for programs with More complex than
Paging memory is divided into segments, and each logical divisions. simple paging.
segment has its own page table.

Simplified Example:
 Single-Level: Like one big map for all addresses.
 Multi-Level: Like a folder structure with subfolders.
 Inverted: A list for each physical memory block instead of each virtual page.
 Hashed: Uses a formula to quickly find where a page is stored.
 TLB: Keeps frequently used addresses handy, like a shortcut.
 Segmented Paging: Combines folders (segments) with maps (pages).
Each method balances memory efficiency and speed depending on the system's needs!
10.Explain FIFO page replacement algorithm with an example
FIFO Page Replacement Algorithm
The First-In-First-Out (FIFO) page replacement algorithm replaces the page that has been in
memory the longest when a page fault occurs. It uses a queue to manage the pages, where:
 The oldest page is at the front of the queue (to be removed first).
 The new page is added to the rear of the queue.
Steps of FIFO Page Replacement
1. Maintain a queue to store pages currently in memory.
2. On a page fault (when a required page is not in memory):
o If there is space in the memory, load the page.
o If memory is full, remove the oldest page (front of the queue) and load the new page.
3. Update the queue accordingly.
Example: Consider the following sequence of page requests:
Pages: 1, 2, 3, 4, 1, 2, 5, 1, 2, 3, 4, 5
Assume the memory can hold 3 pages at a time.
Step Page Request Memory Page Fault? Explanation
 State
1 1 [1] Yes Page 1 loaded into memory.
2 2 [1, 2] Yes Page 2 added, memory not full yet.
3 3 [1, 2, 3] Yes Page 3 added, memory now full.
4 4 [4, 2, 3] Yes Page 1 (oldest) replaced by page 4.
5 1 [4, 1, 3] Yes Page 2 replaced by page 1.
6 2 [4, 1, 2] Yes Page 3 replaced by page 2.
7 5 [5, 1, 2] Yes Page 4 replaced by page 5.
8 1 [5, 1, 2] No Page 1 already in memory.
9 2 [5, 1, 2] No Page 2 already in memory.
10 3 [3, 1, 2] Yes Page 5 replaced by page 3.
11 4 [4, 1, 2] Yes Page 3 replaced by page 4.
12 5 [5, 1, 2] Yes Page 4 replaced by page 5.

Result
 Total Page Requests: 12
 Total Page Faults: 9
 Page Hits: 3 (requests for pages 1 and 2 after they were already loaded).
Key Points
1. Simple but not always efficient.
2. May replace a page that will be used soon (no future consideration).
3. Suffers from Belady's Anomaly, where increasing memory size can increase page faults.

11.What is a Demand Paging System?

Demand paging is a memory management technique in operating systems where pages of a program
are loaded into memory only when needed (on demand), rather than loading the entire program at
once.
This helps save memory and improves performance, especially for programs that do not use all their
pages frequently.
How Demand Paging Works
1. Program Execution:
o A program's virtual memory is divided into pages.
o Physical memory is divided into frames.
2. Page Table:
o The operating system uses a page table to keep track of which pages are in memory and
which are not.
o A valid/invalid bit in the page table indicates if a page is in memory (valid) or not
(invalid).
3. Page Fault:
o When the program tries to access a page that is not in memory, a page fault occurs.
o The OS retrieves the required page from secondary storage (e.g., disk) and loads it into
memory.
4. Page Replacement (if needed):
o If memory is full, the OS may use a page replacement algorithm (e.g., FIFO, LRU) to
remove an existing page and make space for the new one.
12.Discuss the solution to the two-process critical section problem. Mention the issues in this
solution. what is critical section problem? What is the requirement to solve the problem?
explain the consumer/producer problem. explain mutex softer tools to solve the critical
section problem.

Critical Section Problem

Each process has a section of code, called a critical section in which the process may be
changing common variables, updating a table, writing a file and so on. The important feature of
the system is that when one process is executing its critical section, no other process is to be
allowed to execute in its critical section. Thus, the execution of critical sections by process is
mutually exclusive in time.
Requirements to Solve the Problem:
1. Mutual Exclusion: Only one process can access the critical section at a time.
2. Progress: If no process is in the critical section, any process wanting to enter should eventually
get a chance.
3. Bounded Waiting: A process should not wait indefinitely to enter the critical section.
Solution to the Two-Process Critical Section Problem
Peterson’s Algorithm
Peterson’s Algorithm provides a software-based solution for two processes using:
 Two flags (flag[i] and flag[j]) to indicate whether a process wants to enter the critical section.
 A turn variable to decide which process has priority.
Process i's pseudocode:
flag[i] = true; // Indicate process i wants to enter
turn = j; // Let process j go first if it also wants to enter
while (flag[j] && turn == j) {
// Wait until process j finishes
}
// Critical Section
...
flag[i] = false; // Indicate process i is leaving
Issues with this Solution:
1. Limited to Two Processes: It doesn’t scale to more than two processes.
2. Busy Waiting: Wastes CPU cycles while waiting for the other process.
3. Hardware Dependency: Inefficient on modern architectures with relaxed memory consistency
models.

Producer-Consumer Problem
The Producer-Consumer Problem involves two types of processes:
 Producer: Produces data and places it in a buffer.
 Consumer: Consumes data from the buffer.
Problem:
 If the buffer is full, the producer must wait.
 If the buffer is empty, the consumer must wait.
Solution Using Semaphores:
1. Shared Variables:
 o mutex (binary semaphore): Ensures mutual exclusion during buffer access.
o empty (counting semaphore): Counts the number of empty slots in the buffer.
o full (counting semaphore): Counts the number of filled slots in the buffer.
2. Producer Code:
wait(empty); // Wait if no empty slots
wait(mutex); // Enter critical section
// Add item to buffer
signal(mutex); // Exit critical section
signal(full); // Increment count of filled slots
3. Consumer Code:
wait(full); // Wait if buffer is empty
wait(mutex); // Enter critical section
// Remove item from buffer
signal(mutex); // Exit critical section
signal(empty); // Increment count of empty slots
This ensures mutual exclusion and synchronization between producer and consumer.

Mutex: A Software Tool to Solve the Critical Section Problem

A mutex (mutual exclusion) is a synchronization primitive used to prevent multiple processes from
accessing a shared resource simultaneously.
Key Features:
1. Lock and Unlock Mechanism:
o A process must acquire the mutex (lock) before entering the critical section.
o It releases the mutex (unlock) after leaving the critical section.
2. Blocking:
o If one process holds the mutex, others trying to acquire it are blocked until it is released.
Example:
mutex.lock(); // Acquire lock
// Critical Section
mutex.unlock(); // Release lock
Benefits of Using Mutex:
1. Ensures mutual exclusion.
2. Prevents busy waiting, as processes can be put to sleep while waiting for the mutex.
3. Easy to implement using OS-level primitives.

Summary
 The critical section problem is about managing shared resources safely.
 Requirements include mutual exclusion, progress, and bounded waiting.
 Peterson’s Algorithm solves the problem for two processes but has limitations.
 The producer-consumer problem demonstrates practical synchronization challenges and
solutions using semaphores.
 Mutexes are effective software tools for solving critical section problems in modern systems.

13.Difference between Paging and Segmentation

Sr
No. Paging Segmentation

1 Non-Contiguous memory allocation Non-contiguous memory allocation

2 Paging divides program into fixed size pages. It divides program into variable size segments.

3 OS is responsible Compiler is responsible.

4 Paging is faster than segmentation Segmentation is slower than paging

5 Paging is closer to Operating System Segmentation is closer to User

6 It suffers from internal fragmentation It suffers from external fragmentation

7 There is no external fragmentation Can lead to external fragmentation.

8 Logical address = page number + page offset. Logical address = segment number + segment offset.

9 Page table maintain the page information. Segment Table maintains the segment information

10 Page Table Entry = Frame number + flag bits. Segment Table Entry = Base address + protection bits.
 14.Methods of File Allocation
There are three methods:
1. Contiguous Allocation
2. Linked Allocation
3. Indexed Allocation

1. Contiguous Allocation
 Files are stored in continuous blocks on the disk.
 Access time is fast because blocks are located together.
 Directory stores the starting address and length of the file.
Advantages:
 Easy to implement.
 Minimal seek time and better I/O performance.
Disadvantages:
 Difficult to find continuous free space for large files.
 File size needs to be known in advance.

2. Linked Allocation
 Files are stored as a linked list of disk blocks scattered anywhere on the disk.
 Each block has a pointer to the next block.
 Directory stores pointers to the first and last blocks of the file.
Advantages:
 No external fragmentation.
 File size can grow dynamically as long as free blocks are available.
Disadvantages:
 Works well for sequential access only.
 Additional space is needed for pointers in each block.
3. Indexed Allocation
 Each file has an index block that contains pointers to all the file's disk blocks.
 Directory stores pointers to the index blocks of files.
Advantages:
 Solves problems of contiguous and linked allocation.
 Allows direct access to file blocks.
Disadvantages:
 Requires extra space for index blocks.
 Overhead increases with large files.