File System Basics

Analogy categoryAnalogies

Introduction

A file system is the part of the operating system responsible for organizing, storing, naming, and retrieving data on persistent storage devices such as hard disks and SSDs. It provides an abstraction layer so that applications can work with files and directories instead of raw disk blocks. Without a file system, every program would need to know exactly which physical sectors on a disk hold its data, which is impractical and error-prone.

🏏

Cricket analogy: A scoring app lets a fan track "India's innings" without knowing which server or database row holds that data, just as a file system lets a program open "notes.txt" without knowing which physical disk sector holds it.

Explanation

A file is a named collection of related information, typically stored as a sequence of bytes. Each file has attributes maintained by the OS: name, type, size, location on disk, owner, permissions, and timestamps (created, modified, accessed). The OS exposes a set of system calls to manipulate files: create, open, read, write, seek, close, and delete. Internally, the file system maintains metadata structures (such as an inode in Unix-like systems, or a File Control Block, FCB) that map a file's logical name to its physical location on disk. The OS also manages a per-process open file table and a system-wide open file table, tracking the current file offset, access mode, and reference counts so multiple processes can safely share access to the same file.

🏏

Cricket analogy: A player's official profile card tracks name, role, matches played, and last-updated date, just as a file's inode tracks name, size, owner, and timestamps; the scorer's live tracking sheet during a match is like the open file table, tracking the current over and how many officials are watching that innings.

Example

#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(void) {
    const char *msg = "Hello, file systems!\n";

    /* Create (or truncate) a file and open it for writing */
    int fd = open("notes.txt", O_CREAT | O_WRONLY | O_TRUNC, 0644);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    /* Write bytes to the file via the file descriptor */
    ssize_t written = write(fd, msg, strlen(msg));
    if (written == -1) {
        perror("write");
        close(fd);
        return 1;
    }
    close(fd);

    /* Reopen the file for reading and print its contents */
    fd = open("notes.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        return 1;
    }

    char buf[128];
    ssize_t n = read(fd, buf, sizeof(buf) - 1);
    if (n > 0) {
        buf[n] = '\0';
        printf("Read back: %s", buf);
    }
    close(fd);
    return 0;
}

Output

The program above creates notes.txt, writes 21 bytes to it using the write() system call, closes the file descriptor, reopens the file read-only, and reads the bytes back with read(). The output printed is 'Read back: Hello, file systems!'. Each system call (open, write, read, close) crosses into the kernel, which updates the file's inode metadata (size, modification time) and the process's open file table entry (current offset) as a side effect. Notice that a single file descriptor integer is all the process needs to refer to an open file; the kernel hides the details of where the data physically lives on disk.

🏏

Cricket analogy: A scorer opens a fresh scorebook, writes the toss result and first over, closes it at innings break, reopens it later read-only for the commentary team, and reads back "India won the toss" -- the scorebook's page number is all the reader needs, hiding which shelf physically stores it.

Key Takeaways

A file system provides a logical abstraction (files and directories) over raw physical storage blocks.
Metadata structures (inodes/FCBs) store attributes like size, permissions, timestamps, and block locations.
System calls open(), read(), write(), seek(), and close() are the standard interface applications use to access files.
The OS maintains per-process and system-wide open file tables to track file offsets and sharing between processes.
File systems must balance fast access, efficient space usage, and crash consistency (metadata integrity after a crash).

Practice what you learned

1. Which system call is used to associate a file descriptor with a file before reading or writing it in a C program?

2. What metadata structure does a Unix-like file system typically use to store a file's attributes and block pointers?

3. Why does the OS maintain a per-process open file table separate from the system-wide open file table?

4. What does the close() system call primarily do?

Was this page helpful?

File Allocation Methods

Topics covered

#OperatingSystemsStudyNotes#OperatingSystems#FileSystemBasics#File#System#Explanation#Example#StudyNotes#SkillVeris#ExamPrep