struct inode {
    // File type and permissions
    mode_t      mode;       // rwxrwxrwx, file type
    
    // Ownership
    uid_t       uid;        // User ID
    gid_t       gid;        // Group ID
    
    // Size and timestamps
    off_t       size;       // File size in bytes
    time_t      atime;      // Last access time
    time_t      mtime;      // Last modification time
    time_t      ctime;      // Last status change time
    
    // Link count
    nlink_t     nlink;      // Number of hard links
    
    // Block pointers
    block_t     direct[12];      // Direct block pointers
    block_t     indirect;        // Single indirect
    block_t     double_indirect; // Double indirect
    block_t     triple_indirect; // Triple indirect
};

Resolving /home/user/file.txt:

1. Start at root inode (usually 2)
2. Read root directory data block
3. Find "home" → inode 15
4. Read inode 15's data block (home directory)
5. Find "user" → inode 100
6. Read inode 100's data block (user directory)
7. Find "file.txt" → inode 200
8. Return inode 200

Each "/" component = directory lookup = potential disk read

Writing a file requires multiple disk operations:
1. Update inode (size, block pointers)
2. Update data bitmap (mark blocks used)
3. Write data blocks
4. Update directory entry

Crash in the middle → inconsistent state!

On mount after crash:

1. Scan journal for committed entries
2. For each committed entry:
   - Replay writes to final locations
3. For uncommitted entries:
   - Discard (operation was incomplete)
4. Clear journal
5. Mount complete — consistent state

Recovery is O(journal_size), not O(filesystem_size)

struct inode {
    umode_t                 i_mode;     // Permissions + type
    uid_t                   i_uid;      // Owner
    gid_t                   i_gid;      // Group
    loff_t                  i_size;     // File size
    struct timespec         i_atime;    // Access time
    struct timespec         i_mtime;    // Modify time
    const struct inode_operations *i_op;
    const struct file_operations  *i_fop;
    struct address_space    *i_mapping; // Page cache
};

struct dentry {
    struct inode            *d_inode;   // Associated inode
    struct dentry           *d_parent;  // Parent directory
    struct qstr              d_name;    // Name component
    struct list_head         d_subdirs; // Child dentries
    // Used for path caching
};

struct file {
    struct path              f_path;    // Dentry + mount
    const struct file_operations *f_op;
    loff_t                   f_pos;     // Current position
    unsigned int             f_flags;   // Open flags
};

Application → VFS → File System → Block Layer → Device

Block Layer I/O Schedulers:
┌─────────────────────────────────────────────────────────────────┐
│                                                                  │
│  NONE (noop):     Pass requests directly to device             │
│                   Best for: NVMe, VMs with host scheduling     │
│                                                                  │
│  mq-deadline:     Deadline-based, prevents starvation          │
│                   Best for: HDDs, predictable latency needs    │
│                                                                  │
│  BFQ:             Budget Fair Queuing                          │
│                   Best for: Desktop, interactive workloads     │
│                                                                  │
│  kyber:           Multi-queue, low-latency target              │
│                   Best for: Fast SSDs                          │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Check/set: /sys/block/sda/queue/scheduler