Virtual File System (VFS) in Operating Systems

Virtual File System (VFS) in Operating Systems

Description
The Virtual File System (VFS) is an abstraction layer within the operating system kernel. It provides a unified interface for applications to access different types of file systems (such as EXT4, NTFS, FAT32). VFS hides the implementation details of specific file systems, allowing users to use the same system calls (e.g., open, read, write) to operate on files across different storage devices. For example, in Linux, VFS allows mounting an EXT4-formatted hard drive and a FAT32-formatted USB flash drive simultaneously, without applications needing to be aware of the underlying differences.

Why is VFS Needed?

  1. Compatibility: Supports the coexistence of multiple file systems, eliminating the need to develop separate access interfaces for each one.
  2. Simplified Development: Applications only need to interact with VFS, without having to adapt to the specific implementations of underlying file systems.
  3. Extensibility: When a new file system is added, it can be integrated into the system simply by implementing the interfaces defined by VFS.

Core Working Principle of VFS
VFS achieves abstraction by defining a set of common data structures and operation interfaces. Below is a step-by-step explanation of the key components:

1. Four Core Objects of VFS
VFS abstracts the core concepts of a file system into four objects, each containing data attributes and operation methods (function pointers):

  • Superblock: Represents a mounted file system instance (e.g., a disk partition). It stores the file system's metadata (such as block size, file system type, operation methods, etc.).
  • Inode: Represents the metadata of a file (or directory, device, etc.), such as permissions, size, timestamps, and data block locations. Note: An Inode does not contain a filename.
  • Directory Entry (Dentry): Represents an entry within a directory, associating a filename with an Inode. For example, the path /home/user.txt is broken down into multiple Dentry objects (/, home, user.txt), enabling fast path lookup and caching.
  • File Object: Represents the context information when a process opens a file, such as the current read/write position, operation mode (read-only/read-write), etc. Each process opening the same file creates an independent File object.

2. Abstraction of Operation Methods
Each core object is associated with a set of operation functions (function pointers within structures), implemented by the specific file system:

  • Superblock Operations: e.g., alloc_inode (allocate Inode), destroy_inode (release Inode).
  • Inode Operations: e.g., create (create file), lookup (look up directory entry).
  • File Operations: e.g., read, write, llseek (adjust read/write position).
  • Directory Entry Operations: e.g., d_compare (compare filenames), d_delete (delete directory entry).

3. Example: Process of Reading a File
Assume an application executes read(file_fd, buffer, size):

  1. Find the File Object: The kernel locates the File object of the current process using the file descriptor file_fd.
  2. Locate the Inode: The File object is used to find the corresponding Dentry, which in turn is used to find the file's Inode.
  3. Permission Check: VFS verifies whether the process has read permission based on the permission information in the Inode.
  4. Call the Specific File System: Through the Inode's operation function table, call the read method implemented by the underlying file system (e.g., EXT4).
  5. Data Return: The underlying file system reads the data from the disk, which is then returned to the application through VFS.

4. Directory Entry Cache (Dentry Cache)
To accelerate path resolution (e.g., /a/b/c), VFS maintains a directory entry cache:

  • Caches recently accessed path structures in memory to avoid repeated resolution.
  • For example, after the first access to /a/b/c, each directory entry (/, a, b, c) in the path is cached, enabling direct hits on subsequent accesses.

Design Advantages of VFS

  • Unified View: All file systems are presented in a tree-like directory structure, masking the differences in underlying storage structures.
  • Dynamic Mounting: Allows different file systems to be mounted under the same directory tree via the mount system call (e.g., mounting a USB drive to /mnt/usb).
  • Performance Optimization: Caching mechanisms (Inode cache, Dentry cache) reduce disk access.

Summary
Through its abstraction layer and object-oriented design, VFS achieves a balance between the diversity of file systems and the uniformity of upper-layer interfaces. Understanding VFS's four core objects and their interaction processes is key to mastering operating system file management mechanisms.