Addis Ababa Institute of Technology

Operating Systems Assignment

Summary of File Management in Operating Systems

Group Members

Abdurahman Mohammed …ATE/8901/13

Amanuel Ayalew...ATE/3871/13
Basliel Selamu .....ATE/6761/13
Bethel Wondwossen......ATE/8712/13
Diborah Dereje......ATE/1712/13
 Table of Contents

1. File-System Structure
2. File-System Implementation
3. Directory Implementation
4. Allocation Methods
5. Free-Space Management
6. Efficiency and Performance
7. Recovery
8. NFS (Network File System)
 1. File-System Structure

The file-system structure is fundamental to how data is organized, stored, and

accessed on a storage device. It encompasses several layers, each with specific
responsibilities, ensuring efficient data management and retrieval. Understanding
these layers helps in grasping how a file system works, from the physical storage
of data to the user-level interactions.

1. Physical Storage Layer

At the base, the physical storage layer deals with the actual hardware
components, such as hard drives, SSDs, or other storage media. This layer
handles the reading and writing of binary data to and from the storage device. It
interacts with device drivers to perform low-level operations, translating high-level
commands into hardware-specific instructions.

2. File Organization Module

Above the physical layer is the file organization module, which manages how
data is logically arranged on the storage medium. This module is responsible for:
File Allocation:Determining how space is allocated to files. Common methods
include contiguous, linked, and indexed allocation.
File Placement: Deciding where to place files on the disk to minimize
fragmentation and optimize access speed.
File Access Methods: Implementing ways to access files, such as sequential or
direct access.

3. Logical File System

The logical file system layer provides the interface through which users and
applications interact with files and directories. It is responsible for:
File Naming: Managing file names and ensuring they are unique within a
directory.
Directory Structure:Organizing files into directories (or folders) to provide a
hierarchical structure. This can be a single-level directory, two-level directory, or
more complex structures like tree-structured directories.
Metadata Management: Maintaining information about files, such as their size,
type, permissions, and timestamps.

4. File Control Block (FCB)

Each file has an associated File Control Block (FCB), which contains metadata
about the file. This includes information such as:
File Permissions* Who can read, write, or execute the file.
File Size:The current size of the file.
File Location:Pointers to the blocks or sectors where the file's data is stored.
Timestamps: Creation, modification, and access times.

5. Layered Approach
The layered approach to file-system structure provides several benefits:
Modularity:Each layer can be developed and modified independently, enhancing
system flexibility and maintainability.
Abstraction:Higher layers can function without needing to know the details of
the lower layers, simplifying development.
Security: Different layers can enforce security policies, such as access controls
and permissions, at multiple points.

6. User Interface
At the top of the structure is the user interface, which includes the commands
and graphical tools users interact with to manage files and directories. This
interface translates user actions (like opening a file or creating a directory) into
operations that the underlying layers of the file system carry out.

2.File-System Implementation
File-system implementation encompasses the practical aspects of constructing
and maintaining a file system, involving various data structures and algorithms to
efficiently manage files and directories. This process includes the design and
operation of file control blocks, inode structures, and the methods for storing and
retrieving data.

1. File Control Blocks (FCBs)

An FCB (or inode in Unix-based systems) is a data structure that contains
detailed information about a file. Each file has an associated FCB that stores:
File Attributes: These include file size, type, ownership, permissions, and
timestamps (creation, modification, and last access times).
File Location:Pointers or addresses indicating where the file's data blocks are
located on the storage medium.
File Status: Information about whether the file is open or closed, and its current
position for read/write operations.

2. Data Structures
Various data structures are used to implement the file system efficiently:
Inodes: Used primarily in Unix-based systems, inodes store metadata about files
without including the file name or its data content directly. Instead, they contain
pointers to data blocks where the file's actual data resides.
Superblocks: A superblock contains information about the file system as a whole,
including its size, the block size, the empty and filled blocks, and the status of the
file system.
Allocation Tables: These tables, like the File Allocation Table (FAT) in FAT file
systems, map the data blocks of the files, helping in locating file fragments
spread across the disk.

3. Allocation Methods
Efficient allocation of disk space to files is crucial for performance and storage
management. Common methods include:
Contiguous Allocation: Allocates consecutive blocks to a file, providing fast
access but can lead to fragmentation.
Linked Allocation: Uses pointers to link blocks scattered throughout the disk,
reducing fragmentation but with slower access times due to pointer traversal.
Indexed Allocation: Uses an index block to keep track of all the file’s data block
pointers, offering a balance between access speed and space efficiency.

4. Directory Implementation
Directories are implemented to organize files hierarchically, allowing efficient file
naming, searching, and access. Implementation methods include:
Linear List: A simple list of file names with pointers to their corresponding FCBs.
This method is easy to implement but slow for searching.
Hash Table:A hash table speeds up search operations by hashing file names
and using hash values as indices to find files quickly.
Tree Structures:B-trees and other balanced trees provide efficient insertion,
deletion, and searching, making them suitable for large directories.

5. Free-Space Management
Free-space management techniques ensure efficient utilization of disk space and
quick allocation of free blocks:
Bitmaps: Use a bit array where each bit represents a block. A '0' bit indicates a
free block, while a '1' bit indicates an occupied block.
Linked Lists: Free blocks are linked together, forming a list. The head of the list
points to the first free block, which in turn points to the next free block, and so on.
Grouping: Groups of free blocks are managed together, with each group
containing pointers to several free blocks, reducing the overhead of managing
individual free blocks.

6. Efficiency and Performance

Optimizing file-system implementation focuses on reducing access time and
increasing throughput:
Disk Scheduling Algorithms: Algorithms like First-Come, First-Served (FCFS),
Shortest Seek Time First (SSTF), and Elevator (SCAN) are used to order disk I/O
requests for optimal performance.
Caching: Frequently accessed data is stored in memory caches to reduce disk
access times.
Prefetching: Anticipating future requests and loading data into cache ahead of
time to improve read performance.
 3 Directory Implementation

Directory implementation is a crucial aspect of file system design, as directories

are responsible for organizing files and providing a structure for their
management. A directory contains information about files, including their names,
types, locations, and attributes. Efficient directory implementation ensures quick
file retrieval, ease of navigation, and effective storage management.

1. Linear List
A linear list is the simplest method for implementing a directory. It involves
maintaining a list of file names with pointers to their respective File Control
Blocks (FCBs) or inodes.

Advantages:
- Simple to implement and understand.
- No additional data structures are required.
Disadvantages:
- Slow search times, as the list must be traversed linearly.
- Insertion and deletion operations are inefficient for large directories.

2. Hash Table
A hash table improves search efficiency by using a hash function to compute an
index into a table based on the file name. Each entry in the table points to a list of
files with the same hash value (collision handling).

Advantages:
- Faster search times compared to a linear list, typically O(1) on average.
- Efficient insertion and deletion operations.
Disadvantages:
- Additional overhead of maintaining the hash table.
- Potential for collisions, requiring collision resolution techniques like chaining or
open addressing.

3. Tree Structures
Tree structures, such as B-trees and B+ trees, provide an organized way to
implement directories, allowing for efficient searching, insertion, and deletion.
B-Trees:
- A balanced tree structure where each node can contain multiple keys and
children.
- Ensures that the tree remains balanced, providing O(log n) search, insertion,
and deletion times.
- Useful for large directories where efficient operations are critical.
B+ Trees:
- A variant of B-trees where all values (file pointers) are stored at the leaf level,
and internal nodes only store keys.
- Provides efficient range queries, as leaf nodes are linked, allowing for
sequential access.
Advantages
- Efficient and balanced, maintaining optimal performance for large directories.
- Supports sorted order traversal, useful for listing files in a directory.
Disadvantages
- More complex to implement compared to linear lists and hash tables.
- Requires additional memory for maintaining the tree structure.

4. Trie
A trie (prefix tree) is another efficient structure for directory implementation,
especially useful for managing hierarchical names, such as domain names or file
paths.

Advantages
- Provides efficient search times, typically O(m) where m is the length of the
search string.
- Naturally supports alphabetical ordering of keys.
- Efficiently handles common prefixes, saving space.
Disadvantages
- Can be memory-intensive due to the need to store multiple pointers for each
node.
- More complex to implement compared to simpler structures like lists or hash
tables.

5. Directory Structure and Path Names

Directories can be structured in various ways, depending on the file system's
requirements:
Single-Level Directory
- All files are contained in a single directory.
- Simple to implement but impractical for large systems with many files.
- No support for file organization.
Two-Level Directory
- Separate directories for each user.
- Provides some level of organization and prevents name collisions between
users.
- Limited scalability for large numbers of users and files.
Tree-Structured Directory
- Hierarchical directory structure, allowing for subdirectories.
- Provides a flexible and scalable way to organize files.
- Users can create their own directory hierarchy, making file management
intuitive.
Acyclic-Graph Directory:
- Allows directories to share subdirectories and files.
- Supports shared files across different directories, useful for collaboration.
- Requires mechanisms to handle multiple references to the same file, such as
reference counting.
General Graph Directory:
- The most flexible structure, supporting arbitrary links between directories and
files.
- Requires complex algorithms to prevent cycles and manage references.

Allocation Methods

Allocation methods are techniques used to allocate disk space to files in a file
system. Efficient allocation is crucial for optimizing performance, minimizing
fragmentation, and ensuring effective space utilization. The primary methods for
allocating space on a disk include contiguous allocation, linked allocation, and
indexed allocation, each with its own set of advantages and disadvantages.

1.Contiguous Allocation
In contiguous allocation, each file occupies a set of contiguous blocks on the
disk. This method is simple and offers excellent performance for sequential file
access, as the disk head can read the file blocks in one continuous motion.
Advantages:
- Fast sequential access due to minimal disk head movement.
- Simple to implement and manage.
Disadvantages:
- Prone to fragmentation, as files can grow and shrink over time.
- Difficult to find contiguous free blocks for large files.
- Requires periodic defragmentation to maintain performance.

2. Linked Allocation
Linked allocation involves storing the file’s data blocks in a linked list. Each block
contains a pointer to the next block, allowing files to be stored in non-contiguous
blocks scattered across the disk.

Advantages
- Eliminates fragmentation issues inherent in contiguous allocation.
- Simple to implement and flexible, as files can grow dynamically.
Disadvantages
- Sequential access can be slower due to additional overhead from reading
pointers.
- Not suitable for random access, as the list must be traversed from the
beginning to the desired block.
- Pointer overhead reduces effective disk storage capacity.

3. Indexed Allocation
Indexed allocation uses an index block to maintain pointers to all the data blocks
of a file. This method supports both sequential and random access efficiently, as
the index block provides direct access to the data blocks.

Advantages:
- Supports efficient random and sequential access.
- Eliminates external fragmentation issues.
- Can handle growing files by adding new blocks to the index.
Disadvantages:
- Requires additional storage for index blocks, reducing usable disk space.
- Index blocks can become a performance bottleneck if they are large and
require multiple disk accesses.
Allocation Strategies

Different strategies can be employed within these allocation methods to optimize

performance and space utilization:

1. First Fit
Allocates the first available block or set of contiguous blocks that are large
enough for the file. This strategy is simple and fast but can lead to fragmentation
over time.

2. Best Fit
Finds the smallest available block or contiguous set of blocks that can
accommodate the file. Best fit aims to minimize wasted space but can result in
many small gaps, leading to fragmentation.

3. Worst Fit
Allocates the largest available block or set of blocks to the file. While it may leave
large leftover spaces initially, it can sometimes result in better space utilization as
larger gaps are broken down.

Free-Space Management

Efficient free-space management is essential to ensure that disk space is utilized

effectively and that free blocks are quickly and easily allocated to new files:

1. Bitmaps
A bitmap uses a bit array where each bit represents a disk block. A '0' indicates a
free block, and a '1' indicates an allocated block. Bitmaps are efficient for
checking free space but can require significant memory for large disks.

Advantages:
- Easy to find contiguous free blocks.
- Simple to implement and update.
Disadvantages
- Can require significant memory for large disks.
- Finding free blocks can be slow if the bitmap is large.
2. Linked Lists
A linked list maintains a list of free blocks, where each block points to the next
free block. This method is simple but can be inefficient for allocating large
contiguous blocks.

Advantages:
- Simple to implement and manage.
- Efficient for allocating individual blocks.
Disadvantages:
- Inefficient for finding large contiguous free spaces.
- Can result in longer search times for finding free blocks.

3.Grouping
Groups free blocks into clusters, with each cluster containing pointers to several
free blocks. This method reduces the overhead of maintaining individual free
block pointers.

Advantages:
- Reduces the overhead of managing free space.
- Can quickly find free blocks.
Disadvantages:
- Slightly more complex to implement than simple linked lists.
- May still require searching within groups for contiguous space.

4. Counting
Stores the starting address of free blocks and the number of contiguous free
blocks. This method is efficient for managing large contiguous free spaces but
can be complex to maintain.

Advantages:
- Efficient for finding and allocating large contiguous blocks.
- Reduces fragmentation.
Disadvantages:
- More complex to implement and maintain.
- Can require more memory for storing counts.
Efficiency and Performance

Optimizing efficiency and performance in file systems involves reducing latency,

increasing throughput, and managing resources effectively through various
methods.

1 Disk Scheduling Algorithms

FCFS (First-Come, First-Served): Simple but can lead to long wait times.
SSTF (Shortest Seek Time First): Minimizes seek time but may cause starvation.
SCAN (Elevator): Moves disk head in one direction, then reverses.
C-SCAN (Circular SCAN): Services requests in one direction, providing uniform
wait times.
LOOK and C-LOOK: Optimized SCAN variants that reduce unnecessary travel.

2. Caching and Buffering

Caching: Stores frequently accessed data in RAM, reducing disk access.

Buffering: Uses memory buffers for temporary data storage during I/O operations.

3. Prefetching
Loads data into memory ahead of time based on anticipated requests, improving
sequential read performance.

4.File System Layout Optimization

Block Size:Balances between wasted space and overhead.
Extent-Based Allocation:Reduces fragmentation and improves performance.
Defragmentation: Periodically reorganizes files to ensure contiguity.

5.Parallelism
Multithreading:Handles I/O operations concurrently.
RAID (Redundant Array of Independent Disks):** Uses multiple disks for
redundancy and performance.
 Recovery

Effective recovery mechanisms restore file system consistency after failures.

1. Consistency Checking
Scans and repairs inconsistencies in inodes, directories, and free space.

2. Log-Based Recovery
Write-Ahead Logging: Logs changes before applying them.
Journaling File Systems: Uses logs to track changes, improving recovery times.

3. Checkpointing
Saves the file system state periodically, enabling rollbacks to the last checkpoint.
Snapshotting:Captures the file system state at specific points in time.

4.Backup and Restore

Full Backup:Copies the entire file system.
Incremental Backup: Copies changes since the last backup.
Differential Backup: Copies changes since the last full backup.

5.RAID for Fault Tolerance

RAID 1 (Mirroring):Duplicates data across disks.
RAID 5 (Striping with Parity):** Distributes data and parity for recovery from a
single disk failure.

NFS (Network File System)

The Network File System (NFS) is a distributed file system protocol originally
developed by Sun Microsystems in 1984. NFS allows users to access files over a
network in a manner similar to accessing local storage. It enables multiple clients
to share files and resources on a network, promoting collaboration and efficient
resource utilization.
1. Architecture
NFS operates on a client-server model:
Client: The system that accesses the shared files.
Server: The system that hosts the shared files.
RPC (Remote Procedure Call):** NFS uses RPC to communicate between the
client and server, enabling requests and responses over the network.

2. Mounting
Mounting is the process of making the server's file systems available to the client.
There are two main types:
Hard Mount: Ensures that the client repeatedly tries to connect to the server if it
becomes unavailable, maintaining consistency but potentially causing delays.
Soft Mount: Returns an error if the server is unavailable, allowing the client to
proceed but potentially leading to data inconsistency.

3.NFS Protocol Versions

NFS has evolved over several versions, with each version introducing
improvements and new features:
NFSv2:The original version uses UDP for transport, limited to 2GB file sizes.
NFSv3: Introduced larger file sizes, TCP support, and better performance.
NFSv4: Added stateful operations, improved security with Kerberos, and better
performance optimizations.

4. Security
NFS provides various security mechanisms to protect data:
Authentication: Uses methods like AUTH_SYS (default, based on UID/GID) and
Kerberos for secure authentication.
Authorization: Controls access to files and directories based on permissions.
Encryption: While not natively supported in early versions, NFS can be used with
encryption tools like IPsec to secure data in transit.

5. Caching
To improve performance, NFS clients use caching:
Attribute Caching: Caches file attributes to reduce the need for frequent server
queries.
Data Caching: Caches file data to improve read/write performance. However, this
introduces challenges for consistency, managed using techniques like
write-through and write-back caching.

6. Locking
NFS provides file locking mechanisms to manage concurrent access:
Advisory Locking: Applications can set locks to prevent other processes from
modifying a file, but it's not enforced by the NFS protocol itself.
NFSv4 Locking: Improved with mandatory locking and lease-based locking to
handle client crashes more gracefully.

7. Performance Considerations
Several factors impact NFS performance:
Network Latency:High latency can degrade performance due to the increased
time for requests and responses.
Server Load: A heavily loaded server can slow down file access for all clients.
Caching Strategies: Effective caching can mitigate performance issues but
requires careful tuning to maintain consistency.