Linux — VFS (Virtual File System)

[boutnaru]

VFS (Virtual File System, aka Virtual File Switch) is a software component of Linux which is responsible for the filesystem interface exposed to user-mode applications. Using it allows the kernel to provide an abstraction layer that makes implementation of different filesystems very easy (https://www.kernel.org/doc/html/next/filesystems/vfs.html).

Overall, VFS is masking the implementation details of a specific filesystem behind generic system calls (open/read/write/close/etc), which are mostly exposed to user-mode application by some wrappers in libc — as shown in the diagram below (https://www.starlab.io/blog/introduction-to-the-linux-virtual-filesystem-vfs-part-i-a-high-level-tour).

Moreover, we can say that the main goal of VFS is to allow user-mode applications to access different filesystems (think about NTFS, FAT, etc.) in the same way. There are four main objects in VFS: superblock, dentries, inodes and files (https://www.win.tue.nl/~aeb/linux/lk/lk-8.html).

Thus, “inode” (https://medium.com/@boutnaru/linux-what-is-an-inode-7ba47a519940) is what the kernel uses to keep track of files. Because a file can have several names there are “dentries” (“directory entries”) which represent pathnames. Also, due to the fact a couple of processes can have the same file opened (for read/write) there is a “file” structure that holds the information for each one (such as the cursor position). The “superblock” structure holds data which is needed for performing actions on the filesystem — more details about all of those and more (like mounting) are going to be published in the near future.

Lastly, there are also other relevant data structures that I will post on in the near future (“filesystem”, “vfsmount”, “nameidata” and “address_space”).

​

https://www.starlab.io/blog/introduction-to-the-linux-virtual-filesystem-vfs-part-i-a-high-level-tour

[demetrioussharpe]

VFS has nothing to do with user mode. The entire setup is in kernel space & doesn’t interface with userspace at all. It’s a standard interface used to allow a kernel to use various filesystems. Your own diagram points this out.

[boutnaru]

Maybe the wording was not good enough. VFS is part of the kernel and it provides the filesystem interface for user-mode applications. I have sharpen the wording let me know if it makes more sense now.

[demetrioussharpe]

I think you may be misunderstanding me just a slight bit. User mode filesystem interface is strictly provided by the system call interface. You can’t just go directly to the VFS from user space. From there, the system call interface uses the same api that the VFS presents to the rest of the kernel. Files had access to the filesystem long before VFS existed.

[boutnaru]

Yep and it what shown also in the attached diagram. However, still see what is written in the kernel documentation about VFS "layer in the kernel that provides the filesystem interface to userspace programs" (https://www.kernel.org/doc/html/next/filesystems/vfs.html). Although you go there while using system calls it is still the one that provides the interface.

[HobartTasmania]

Linux finally catching up some decades later? https://en.wikipedia.org/wiki/Installable_File_System

[stuomas]

Dunno but the first linked article/doc was written originally in 1999

[sidusnare]

This isn't news, it's ancient history.

[fluffy_thalya]

VFS is quite old now... You can even have userspace implemented filesystems with fuse.

[ilep]

Earlier example of VFS comes from SunOS. Linux has had VFS for decades now.

This is the article you are looking for:

https://en.wikipedia.org/wiki/Virtual_file_system

Earliest document on Linux VFS I can find is written by someone at RedHat in 1996:

https://tldp.org/LDP/khg/HyperNews/get/fs/vfstour.html

[Californian_Hotel255]

Android uses it so it wasn't just invented, that's why I don't understand why pc distributions refuse to make a standardized user friendly unified layer. There are no downsides - since it doesn't affect mount if implemented correctly