File Systems and IPC

🗄️ Operating Systems: File Systems & IPC

The Library of Your Computer

Imagine your computer is a giant library. Every book, every picture, every song you save is stored in this library. But how does the library know where everything is? How do the librarians (programs) talk to each other when they need help? That’s what we’ll discover today!

📚 What is a File System?

Think of a file system as the organizing system for your library. Without it, books would be scattered everywhere—on the floor, on tables, in random piles. Nobody could find anything!

The Three Big Jobs of a File System

1. Names things — Every file gets a name, like “birthday_photo.jpg”
2. Remembers where things are — Tracks exactly which shelf (disk location) holds each file
3. Keeps things safe — Makes sure nobody erases your homework by accident!

┌─────────────────────────────┐
│     YOUR COMPUTER           │
│  ┌─────────────────────┐    │
│  │   FILE SYSTEM       │    │
│  │  ┌───┐ ┌───┐ ┌───┐ │    │
│  │  │📄│ │🖼️│ │🎵│  │    │
│  │  └───┘ └───┘ └───┘  │    │
│  │  Names + Locations   │    │
│  └─────────────────────┘    │
└─────────────────────────────┘

Real Life Example:

• When you save a game, the file system picks a spot on your hard drive
• It writes down: “Game save is at location 1234”
• Later, when you load the game, it looks up location 1234 instantly!

🔧 File Operations: What Can You Do With Files?

Just like you can do things with library books, you can do things with files!

The Six Magic Actions

How Opening a File Works

graph TD
    A["You click 'Open'"] --> B["OS finds file location"]
    B --> C["OS reads from disk"]
    C --> D["Data loaded into memory"]
    D --> E["You see your file!"]

Example: Opening a photo

1. You double-click “vacation.jpg”
2. File system looks up: “vacation.jpg is at disk sector 5678”
3. It reads that sector into your computer’s fast memory
4. Photo app displays your picture!

🌳 Directory Structure: Folders Inside Folders

A directory is just a fancy word for folder. And folders can contain other folders—like Russian nesting dolls! 🪆

The Tree Shape

Your computer’s files form a tree shape, starting from one main folder called the root.

/  (root - the very top)
├── 📁 Users
│   ├── 📁 Alice
│   │   ├── 📄 homework.doc
│   │   └── 📁 Photos
│   │       └── 🖼️ cat.jpg
│   └── 📁 Bob
│       └── 🎵 song.mp3
├── 📁 Programs
│   └── 📱 games
└── 📁 System

Absolute vs Relative Paths

Think of paths like addresses:

Simple Example:

• Absolute path: “123 Main Street, New York, USA”
• Relative path: “Go two blocks left, then turn right”

💾 File Allocation Methods: Where Do Files Live?

When you save a file, the computer needs to find empty space on the disk. There are three main ways to do this!

1. Contiguous Allocation (All Together)

Like reserving seats next to each other at a movie theater. 🎬

Disk: [FILE A][FILE A][FILE A][empty][empty][FILE B][FILE B]
       ↑─────────────────────↑
       File A lives in seats 0-2

✅ Good: Super fast to read (everything’s together!) ❌ Bad: Hard to grow files, creates gaps (fragmentation)

2. Linked Allocation (Follow the Chain)

Each piece points to the next piece, like a treasure hunt! 🗺️

Block 5: [Data] → points to Block 12
Block 12: [Data] → points to Block 3
Block 3: [Data] → END

✅ Good: Files can be anywhere, easy to grow ❌ Bad: Slow (must follow each link), one broken link = lost file!

3. Indexed Allocation (The Master List)

One special block holds a list of all locations—like a table of contents! 📋

┌─────────────────┐
│  INDEX BLOCK    │
│  Block 0: loc 5 │
│  Block 1: loc 12│
│  Block 2: loc 3 │
└─────────────────┘

✅ Good: Fast random access, no wasted pointers ❌ Bad: Index block takes space, big files need multiple index blocks

graph TD
    subgraph Contiguous
    A1["Block 1"] --> A2["Block 2"] --> A3["Block 3"]
    end

    subgraph Linked
    B1["Block 5"] -.-> B2["Block 12"] -.-> B3["Block 3"]
    end

    subgraph Indexed
    C0["Index"] --> C1["Block 5"]
    C0 --> C2["Block 12"]
    C0 --> C3["Block 3"]
    end

🎡 Disk Scheduling: Who Gets the Disk Next?

Your hard disk has a read/write head that moves across the disk like a record player needle. 💿

When multiple programs want to read/write at the same time, who goes first?

The Problem

Imagine the read head is at track 50. Three programs want:

• Program A: Track 20
• Program B: Track 100
• Program C: Track 30

Scheduling Algorithms

1. FCFS (First Come, First Served)

Serve requests in the order they arrive. Simple but not efficient!

Head at 50 → 20 → 100 → 30
Movement: 30 + 80 + 70 = 180 tracks total 😓

2. SSTF (Shortest Seek Time First)

Go to the closest request next. Greedy but faster!

Head at 50 → 30 → 20 → 100
Movement: 20 + 10 + 80 = 110 tracks total 😊

3. SCAN (The Elevator)

Move in one direction until the end, then reverse. Like an elevator!

Head at 50 → goes right to 100 → then left to 30 → 20

4. C-SCAN (Circular SCAN)

Go one direction, jump back to start, repeat. Always moving forward!

50 → 100 → [jump to 0] → 20 → 30

graph LR
    subgraph FCFS
    F1["50"] --> F2["20"] --> F3["100"] --> F4["30"]
    end

    subgraph SSTF
    S1["50"] --> S2["30"] --> S3["20"] --> S4["100"]
    end

Real Life: Think of SCAN like an elevator—it doesn’t go up, down, up, down randomly. It goes all the way up, then all the way down!

🗣️ Inter-Process Communication (IPC): Programs Talking to Each Other

When two programs need to share information, they use IPC. It’s like how people communicate!

Why Do Programs Need to Talk?

• A web browser asks the download manager to fetch a file
• Your music player tells the volume control to go louder
• A game’s graphics engine talks to the physics engine

The Six Ways Programs Communicate

1. Pipes (One-Way Tunnel) 🚇

Data flows in one direction only, like water in a pipe.

[Program A] ──data──► [Program B]
   Writer              Reader

Example: ls | grep "txt" — the output of ls flows INTO grep

2. Named Pipes (FIFO) 📬

Like a pipe, but with a name—any program that knows the name can use it!

[Any Program] ──► /tmp/my_pipe ──► [Any Program]

3. Shared Memory 📦

Two programs share the same chunk of memory—the fastest method!

┌─────────────────────────────┐
│      SHARED MEMORY          │
│   ┌─────┐      ┌─────┐     │
│   │Prog │ ←──► │Prog │     │
│   │  A  │      │  B  │     │
│   └─────┘      └─────┘     │
└─────────────────────────────┘

⚡ Super fast! But need to be careful—both writing at once = chaos!

4. Message Queues 📨

Programs leave messages in a mailbox for others to pick up.

Program A drops message → [QUEUE: msg1, msg2] → Program B reads

Like: Leaving sticky notes on someone’s desk

5. Semaphores 🚦

A traffic light for programs. Controls who can access shared things.

Green (1): Go ahead and use the resource
Red (0): Wait, someone else is using it

Example: Only one program prints at a time, so pages don’t get mixed up!

6. Sockets 🔌

Communication across the network—even between different computers!

[Your Computer] ←─internet─→ [Server Computer]
     Client                      Server

Example: Your browser (client) talks to google.com (server) using sockets!

🎯 Quick Comparison Table

🎉 You Did It!

Now you understand how your computer:

1. Organizes files in a tree structure
2. Stores files using allocation methods
3. Schedules disk access efficiently
4. Lets programs talk to each other

Think of your computer as a busy library with chatty librarians—and now you know exactly how they keep everything running smoothly! 📚✨

🧠 Key Takeaways

• File System = The organizing system that names, locates, and protects your files
• File Operations = CREATE, OPEN, READ, WRITE, CLOSE, DELETE
• Directory Structure = Tree of folders starting from root (/)
• Allocation Methods = Contiguous (fast), Linked (flexible), Indexed (balanced)
• Disk Scheduling = FCFS, SSTF, SCAN, C-SCAN (like elevator algorithms)
• IPC = How programs communicate: pipes, shared memory, sockets, and more!