Unit 8: File Management & Device Management

Opening Hook — How IRCTC Handles 30 Million Ticket Records Daily

Learning Outcomes — Bloom's Taxonomy Mapped

Concept Explanation — File Management & Device Management

━━━ PART A: FILE MANAGEMENT ━━━

1. File Concepts — Attributes, Operations & Types

A file is a named collection of related information stored on secondary storage. Think of it as a container — like a file folder in a physical office cabinet. The operating system manages how these files are created, stored, accessed, and deleted.

File Operations

The OS provides a set of system calls to manipulate files:

File Types

File Structure

None (Byte Sequence): File is just a stream of bytes. OS doesn't care about internal structure. Used in Unix/Linux — maximum flexibility.

Simple Record Structure: File is a sequence of fixed-length or variable-length records. Used in old mainframe systems.

Complex Structure (Indexed): File has an internal index for fast searching. Used in databases.

2. Access Methods

How does the OS read data from a file? There are three fundamental methods:

3. Directory Structures

A directory is a special file that contains a list of files and other directories. How we organise directories determines how efficiently we can find, create, and manage files.

3.1 Single-Level Directory

All files in one directory. Simplest possible structure.

┌──────────────────────────────────────────────┐
│  cat.txt  dog.jpg  report.pdf  main.c  a.out │
└──────────────────────────────────────────────┘
        (All files in one flat directory)

✅ Pros: Simple to implement, fast search (small systems).

❌ Cons: Name collision — two users can't have test.txt. No grouping. Unusable for large systems.

3.2 Two-Level Directory

Separate directory for each user. Master File Directory (MFD) → User File Directory (UFD).

              ┌─── MFD ───┐
              │            │
          ┌───┴───┐   ┌───┴───┐
          │ User1 │   │ User2 │
          │  UFD  │   │  UFD  │
          ├───────┤   ├───────┤
          │ f1.txt│   │ f1.txt│  ← Same name, no conflict!
          │ f2.c  │   │ f3.py │
          └───────┘   └───────┘

✅ Pros: Name isolation per user. Different users can have same filename.

❌ Cons: No subdirectories within a user's space. Can't group related files.

3.3 Tree-Structured Directory

Hierarchical structure with unlimited nesting. The most common in modern OS (Linux, Windows, macOS).

                    / (root)
                 /  |   \
              bin  home   etc
                   / \
                 u1    u2
                / \      \
             docs code   pics
             /      \
         report.pdf  main.c

✅ Pros: Hierarchical organisation, scalable, efficient searching, natural grouping.

❌ Cons: No file sharing between directories.

3.4 Acyclic Graph Directory

Like tree, but allows shared files/directories through links (hard links, soft links). Two directory entries can point to the same file.

              / (root)
            /    \
         home     shared
         /  \       |
       u1    u2     |
        \    /      |
         project ←──┘  (shared by u1, u2, and /shared)

✅ Pros: File sharing without duplication.

❌ Cons: Dangling pointer problem — if original file is deleted, links point to nothing. Need reference counting.

3.5 General Graph Directory

Allows cycles (directory A can contain B, and B can contain A). Most flexible but most complex.

✅ Pros: Maximum flexibility.

❌ Cons: Cycles can cause infinite loops during traversal. Needs garbage collection to reclaim space. Most complex to implement.

Directory Structure Comparison

4. File System Mounting & Sharing

Mounting is the process of making a file system accessible at a certain point in the directory tree. When you plug in a USB drive in Linux, it gets "mounted" at a mount point like /mnt/usb.

File Sharing across networks is done through NFS (Network File System) in Linux and SMB/CIFS in Windows. Multiple machines can access the same files over a network.

5. File Protection & Access Control

File protection ensures that only authorised users can access files in specific ways.

Access Control Methods:

1. Access Matrix: A table with rows = users, columns = files, entries = permissions (read, write, execute). Conceptually complete but impractical for large systems.

2. Access Control List (ACL): Each file stores a list of users and their permissions. Column-wise view of access matrix.

3. Capability List: Each user stores a list of files they can access. Row-wise view of access matrix.

Linux Permission System (chmod):

Shell
# Permission format: rwx r-x r--
#                   Owner Group Others

chmod 755 myfile.txt    # Owner=rwx, Group=r-x, Others=r-x
chmod 644 readme.md     # Owner=rw-, Group=r--, Others=r--
chmod u+x script.sh     # Add execute permission for owner
ls -la myfile.txt       # View permissions
# Output: -rwxr-xr-x 1 student staff 4096 Jan 15 10:30 myfile.txt

6. File Allocation Methods

When a file is stored on disk, the OS must decide which blocks on the disk to use. This is the file allocation problem. There are three major methods:

6.1 Contiguous Allocation

Each file occupies a set of contiguous (adjacent) blocks on disk. The directory entry stores the starting block and the length.

Block:   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14
       ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
       │ A │ A │ A │ A │ A │ B │ B │ B │ B │   │   │   │ C │ C │ C │
       └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
File A: start=0, length=5        ↑ gap (external fragmentation)
File B: start=5, length=4
File C: start=12, length=3

✅ Pros: Fast sequential access (blocks are adjacent). Fast direct access (start + offset). Simple directory entry (just start + length).

❌ Cons: External fragmentation (gaps between files after deletions). File size must be known at creation. Files cannot grow easily.

6.2 Linked Allocation

Each file is a linked list of disk blocks. Each block contains a pointer to the next block. Blocks can be scattered anywhere on disk.

Directory:  File A → start: block 9

Block 9    Block 16    Block 1    Block 10    Block 25
┌──────┐   ┌──────┐   ┌──────┐   ┌──────┐   ┌──────┐
│ data │──→│ data │──→│ data │──→│ data │──→│ data │──→ null
│ →16  │   │ →1   │   │ →10  │   │ →25  │   │ →nil │
└──────┘   └──────┘   └──────┘   └──────┘   └──────┘

FAT (File Allocation Table): A centralised table that stores all the "next pointers" in one place, rather than inside each data block. Used in FAT12, FAT16, FAT32 (pen drives, SD cards).

✅ Pros: No external fragmentation. Files can grow dynamically — just add a new block anywhere and link it.

❌ Cons: No direct access — must traverse from start to reach block N (slow for random access). Pointer overhead in each block. If one pointer is corrupted, rest of file is lost.

6.3 Indexed Allocation

An index block stores all the pointers to data blocks. The directory points to the index block. Like a table of contents for the file.

Directory:  File A → index block: 14

Index Block [14]:        Data Blocks:
┌──────────────┐         ┌─────┐
│  0 → block 9 │ ──────→ │  9  │
│  1 → block 16│ ──────→ │ 16  │
│  2 → block 1 │ ──────→ │  1  │
│  3 → block 10│ ──────→ │ 10  │
│  4 → block 25│ ──────→ │ 25  │
│  5 → -1 (end)│
└──────────────┘

✅ Pros: Supports direct access (go to index, find block number, read). No external fragmentation.

❌ Cons: Index block overhead — wastes space for small files. Limited file size per index block (solved with multilevel/linked index schemes in Unix i-nodes).

Allocation Methods — Comparison Table

7. Free-Space Management

When files are deleted, blocks become free. The OS must track which blocks are free so they can be allocated to new files. Four methods:

7.1 Bit Vector (Bitmap)

Each block is represented by one bit: 0 = free, 1 = occupied (convention varies).

Block:     0  1  2  3  4  5  6  7
Bitmap:    0  0  1  1  1  1  0  0
           ↑  ↑                ↑  ↑
         free free           free free

Free blocks: 0, 1, 6, 7 → 4 free blocks

✅ Pros: Simple, efficient for finding contiguous free blocks (just scan for consecutive 0s). Fast with hardware support.

❌ Cons: Requires extra space. A 1TB disk with 4KB blocks = 256 million bits = 32 MB bitmap.

7.2 Linked List

All free blocks are linked together in a list. First free block is pointed to by a head pointer.

✅ Pros: No wasted space for bitmap.

❌ Cons: Very slow traversal to find free blocks. Finding contiguous free blocks is difficult.

7.3 Grouping

First free block stores addresses of n free blocks. The last of those n blocks stores addresses of the next n free blocks, and so on.

✅ Pros: Faster than linked list — get n free blocks in one read.

❌ Cons: More complex to implement.

7.4 Counting

Store pairs: (starting block, count). If blocks 10–14 are free, store (10, 5). Efficient when free blocks are contiguous.

✅ Pros: Very compact for contiguous free regions.

❌ Cons: Inefficient when free blocks are scattered.

Free-Space Management — Comparison

8. Directory Implementation

━━━ PART B: DEVICE MANAGEMENT ━━━

9. Device Types

10. Serial vs Direct Access Devices

11. Disk Structure

A hard disk drive (HDD) is made up of several physical components:

      Top View of a Disk Platter:

         Track 0 (outermost)
        ╔═══════════════════╗
       ║  Track 1            ║
      ║  ┌─────────────┐     ║
     ║  │  Track 2      │     ║
     ║  │ ┌───────────┐ │     ║
     ║  │ │  Spindle   │ │     ║    ← Platters rotate around spindle
     ║  │ │   (center) │ │     ║
     ║  │ └───────────┘ │     ║
      ║  └─────────────┘     ║
       ║                     ║
        ╚═══════════════════╝

      Each track is divided into SECTORS (smallest unit of data, usually 512 bytes)
      
      ┌────┬────┬────┬────┬────┐
      │ S1 │ S2 │ S3 │ S4 │ S5 │  ← Sectors on one track
      └────┴────┴────┴────┴────┘

      CYLINDER = Same track number across ALL platters

      Platter 1:  Track 5  ──┐
      Platter 2:  Track 5  ──┼── Cylinder 5
      Platter 3:  Track 5  ──┘

12. Disk Scheduling Algorithms — Full Numericals

12.1 FCFS (First Come, First Served)

Algorithm: Process requests in the exact order they arrive in the queue. No reordering.

FCFS Head Movement Diagram:
Position: 0    14   37  53  65 67   98   122 124      183    199
          |     |    |   ↓   | |    |     |   |        |      |
     ①    |     |    |   ●━━━━━━━━━→●     |   |        |      |
     ②    |     |    |   |   | |    ●━━━━━━━━━━━━━━━━━→●      |
     ③    |     |    ●←━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━●      |
     ④    |     |    ●━━━━━━━━━━━━━→●     |   |        |      |
     ⑤    |     ●←━━━━━━━━━━━━━━━━━━━━━━━━●   |        |      |
     ⑥    |     ●━━━━━━━━━━━━━━━━━━━━━━━━━━━━→●        |      |
     ⑦    |     |    |   |   | |    |     |   ●━━━→●   |      |
     ⑧    |     |    |   |   | ●←━━━━━━━━━━━━━━━━━●   |      |
          Wait — let me fix ⑦ and ⑧:
     ⑦    |     |    |   |   ●←━━━━━━━━━━━━━━━━━━━●   |      |
     ⑧    |     |    |   |   ●→●  |     |   |        |      |

12.2 SSTF (Shortest Seek Time First)

Algorithm: From current head position, move to the nearest pending request. Recalculate after each move.

12.3 SCAN (Elevator Algorithm)

Algorithm: The disk arm moves in one direction (like an elevator), serving all requests along the way. When it reaches the end of the disk, it reverses direction and serves remaining requests.

12.4 C-SCAN (Circular SCAN)

Algorithm: Like SCAN, but after reaching the disk end, the head jumps to the other end and scans in the same direction again. It only serves requests in one direction — treating the disk as circular.

12.5 LOOK

Algorithm: Like SCAN, but the head goes only to the last request in each direction, NOT to the disk boundary. It "looks" ahead and reverses when there are no more requests in the current direction.

12.6 C-LOOK (Circular LOOK)

Algorithm: Like C-SCAN, but head goes only to the last request in each direction. After serving the last request going left, it jumps to the farthest request on the right and continues left.

Master Comparison Table — All 6 Disk Scheduling Algorithms

13. DASD (Direct Access Storage Devices)

DASD refers to any storage device where data can be accessed directly (randomly) without reading through preceding data.

14. Channels and Control Units

In mainframe systems, I/O devices communicate with the CPU through channels and control units:

Channel: A specialised hardware pathway (independent processor) that manages data transfer between memory and I/O devices, freeing the CPU for other work.

Control Unit: Sits between the channel and the device. Manages device-specific operations and translates channel commands into device commands.

Learn by Doing — 3-Tier Lab Structure

Bash
# List files with inode numbers
ls -i

# Detailed file metadata
stat filename.txt

Bash
# Disk space usage (human-readable)
df -h

# Directory size
du -sh /home
du -sh /var/log

Bash
# List all block devices
lsblk

# Detailed partition info (requires sudo)
sudo fdisk -l

Bash
# Create a file
touch myfile.txt

# Write to file
echo "Hello IRCTC - File Management Lab" > myfile.txt

# Read file contents
cat myfile.txt

# Copy file
cp myfile.txt backup.txt

# Move/rename file
mv backup.txt backup_old.txt

# Delete file
rm backup_old.txt

Bash
# Create nested directories
mkdir -p projects/os/unit8

# List recursively with details
ls -laR projects/

# Tree view (install: sudo apt install tree)
tree projects/

Bash
# Set permissions (rwxr-xr-x)
chmod 755 myfile.txt

# Add execute for owner
chmod u+x myfile.txt

# View permissions
ls -la myfile.txt

Bash
# Detect file type
file myfile.txt

# Count lines
wc -l myfile.txt

# View first/last lines of system files
head -5 /etc/passwd
tail -5 /etc/passwd

Python
def fcfs(head, requests):
    seek = 0
    current = head
    sequence = [current]
    for r in requests:
        seek += abs(current - r)
        current = r
        sequence.append(current)
    return seek, sequence

# Test
head = 53
queue = [98, 183, 37, 122, 14, 124, 65, 67]
total, seq = fcfs(head, queue)
print(f"FCFS: Total Seek = {total}, Sequence = {seq}")

Python
def sstf(head, requests):
    pending = requests.copy()
    seek = 0
    current = head
    sequence = [current]
    while pending:
        # Find nearest request
        nearest = min(pending, key=lambda x: abs(x - current))
        seek += abs(current - nearest)
        current = nearest
        sequence.append(current)
        pending.remove(nearest)
    return seek, sequence

Industry Spotlight — A Day in the Life

Earn With It — Freelance & Income Roadmap

⏱️ Time to First Earning: 3–4 weeks (complete Tier 1 lab + create 2 automation scripts + set up Internshala profile)

MCQ Assessment Bank — 30 Questions (Bloom's Mapped)

Remember / Identify (Q1–Q5)

Understand / Explain (Q6–Q10)

Apply / Calculate (Q11–Q20) — Numerical Problems

Analyze / Compare (Q21–Q25)

Evaluate / Justify (Q26–Q28)

Create / Design (Q29–Q30)

Short Answer Questions (5 Questions)

Q1. Explain the three file allocation methods with one advantage and one disadvantage of each.

Q2. Describe the SCAN disk scheduling algorithm with an example. Why is it called the "elevator algorithm"?

Q3. Compare bitmap and linked list methods of free-space management.

Q4. What is the difference between SCAN and LOOK? Why is LOOK preferred in practice?

Q5. Explain the concept of an acyclic graph directory. What is the dangling pointer problem?

Case Studies

Chapter Summary

Earning Checkpoint

✅ Unit 8 complete. Numerical problems: 8+. MCQs: 30. Ready for Unit 9!

[QR: Link to EduArtha video tutorial — File & Device Management]