🧠 Introduction

Every time you:

• open a file 📄

• make an API call 🌐

• connect to a database 🗄️

• chat in an app 💬

👉 Your system is using file descriptors (FDs) behind the scenes.

They are simple, powerful, and critical for system performance and scalability.

This blog explains file descriptors in a way that:

• beginners can understand easily

• developers can apply in real-world systems

---

🍽️ What is a File Descriptor? (Canteen Analogy)

🧩 Simple Analogy — Canteen Token System

Imagine a college/office canteen 🍛

• Food items = files/resources

• Canteen staff = Operating System (OS)

• Token number = file descriptor

---

🎯 How it works:

Instead of saying:

“Give me one masala dosa with extra chutney from counter 2”

You simply say:

“Token #5”

👉 Staff already knows:

• Token #5 → your order

---

🔁 Important detail (same as FDs!)

Once your order is served:

• Token #5 becomes free

• Next person may get token #5 again

👉 Just like file descriptors are reused

---

🧠 One-line definition:

A file descriptor is a small number used by the OS to identify and manage an open resource.

---

🔢 Standard File Descriptors

Every Linux program starts with 3 default FDs:

FD   Name     Purpose
-------------------------
0    stdin    Input (keyboard)
1    stdout   Output (screen)
2    stderr   Error messages

---

📊 Diagram

Program starts:

   [Process]
      |
   ---------
   | 0 | → Keyboard (Input)
   | 1 | → Screen (Output)
   | 2 | → Error Output
   ---------

---

⚙️ How File Descriptors Work

Step-by-step

int fd = open("file.txt", O_RDONLY);

---

🧠 What happens internally:

1. OS receives a request

2. Opens file

3. Finds the lowest free number

4. Assigns FD (e.g., 3)

---

📊 Diagram

Process FD Table:

FD   →   Resource
------------------------
0    →   Keyboard
1    →   Screen
2    →   Error screen
3    →   file.txt

---

🔁 FD Allocation Rule (Very Important)

👉 OS always gives the lowest available FD

---

📊 Example

FDs in use: 0, 1, 2, 4, 5
Free FD: 3

Next open() → FD = 3

---

❌ Not like this:

Highest FD = 5
Next FD ≠ 6

---

🌐 Everything is a File in Linux

👉 File descriptors are not just for files

Resource Type        Example
--------------------------------
File                 file.txt
Socket               network connection
Pipe                 process communication
Device               keyboard, disk

---

🔄 Lifecycle of a File Descriptor

OPEN → USE → CLOSE

---

📊 Diagram

open()      read/write      close()
  |             |              |
  v             v              v
 [FD] ------> [DATA] ------> [FREE]

---

💻 Example

int fd = open("file.txt", O_RDONLY);
read(fd, buffer, size);
close(fd);

---

⚠️ File Descriptor Leak (Silent Killer)

🧠 What is it?

👉 Opening resources but not closing them

---

📉 Example

while True:
    open("file.txt")

---

📊 Diagram

Iteration → FD Count

1 → FD 3
2 → FD 4
3 → FD 5
...
1024 → 💥 Crash

---

❌ Error

Too many open files

---

🧨 Real-world impact

• Server stops accepting users

• Logs stop writing

• Database connections fail

• Random errors appear

---

🧪 How to Check FDs in Linux

🔍 List FDs

lsof -p <pid>

---

📊 Count FDs

ls /proc/<pid>/fd | wc -l

---

📊 FD Limits in Linux

Type        Meaning
--------------------------
Soft        Current usable limit
Hard        Maximum allowed

---

🔍 Check limit

ulimit -n

---

📈 Typical values

• Default → 1024

• Production → 65535+

---

👶 File Descriptors & fork()

When a process creates a child:

👉 Child inherits all FDs

---

📊 Diagram

Before fork:

Parent
  |
 FD 3 → file.txt

----------------------

After fork:

Parent            Child
  |                 |
 FD 3 → file.txt   FD 3 → file.txt

---

👉 Both share the same resource!

---

🔁 FD Duplication

dup2(oldfd, newfd);

---

📊 Diagram

FD 1 → Screen

dup2(3,1)

FD 1 → file.txt

---

👉 Used in:

ls > output.txt

---

⚡ Real-World Use Cases

💬 Chat Applications

1 user = 1 socket = 1 FD
1000 users = 1000 FDs

---

🤖 Backend APIs

1 request:
  → socket FD
  → DB FD
  → log FD

👉 Multiple FDs per request

---

🎙️ Audio/Video Apps

1 user → multiple streams → multiple FDs

👉 Very high FD usage

---

🧠 Hidden Facts (Very Important)

---

🔍 1. FD numbers are reused

close(3)
open() → FD 3 again

---

🧬 2. Child processes share FDs

• Parent closes FD ❌

• The child can still use it ✅

---

⏳ 3. TIME_WAIT state

Sockets stay briefly after closing

---

🔥 4. FD leak is slow

• Works fine initially

• fails later

---

🧠 5. One user ≠ one FD

1 user → 3–5 FDs

---

⚙️ 6. High-performance systems rely on FDs

• epoll

• event loops

---

🧩 Best Practices

---

✅ Always close resources

with open("file.txt") as f:
    data = f.read()

---

✅ Use connection pooling

• reuse DB connections

• reduce FD usage

---

✅ Monitor in production

• track FD count

• set alerts

---

✅ Increase limits

ulimit -n 65535

---

🎯 Final Summary

---

🧠 Key Points

• File descriptor = small number

• Represents an open resource

• Managed by OS

• Reused efficiently

---

📊 Final Diagram

User Action
   |
   v
Open File / Socket
   |
   v
OS assigns FD (e.g., 3)
   |
   v
Program uses FD
   |
   v
Close FD → freed

---

🚀 One-line takeaway

File descriptors are the invisible tokens that allow your program to communicate with files, networks, and the system.

---

💡 Why it matters

Because it directly impacts:

• scalability 📈

• performance ⚡

• system stability 🛠️

---

Good developers don’t just take tokens—they make sure to return them.