Shulou(Shulou.com)06/01 Report--

This article shows you how to understand Linux VFS and Page Cache in depth. The content is concise and easy to understand. It will definitely make your eyes shine. I hope you can gain something from the detailed introduction of this article.

VFS (Virtual File System Layer)

A VFS is a virtual file system layer (an abstraction layer between a process and a file system), and the data structures associated with it exist only in physical memory. The purpose is to shield the differences in the operation of the lower file system and provide a unified interface for the operation of the upper layer. It is precisely because of the existence of VFS that multiple different file systems are allowed to coexist in Linux.

VFS contains a series of data structures converted to physical file system, such as VFS super block, VFS Inode, conversion entry of various operation functions, etc. VFS in Linux relies on four main data structures to describe its structural information: superblocks, index nodes, directory entries, and file objects, most of which correspond to those on disk.

Super Block: A superblock object represents a file system. It stores control information about an installed file system, including file system name (such as Ext2), file system size and state, block device references, and metadata information (such as free list, etc.). Superblocks correspond to superblocks of file systems on disk.

Inode: An inode object stores metadata about a file, such as file size, device identifier, user identifier, user group identifier, and so on. There are two types of inodes: VFS inodes and file system-specific inodes. The former is in memory and the latter is on disk. So every time you actually transfer the Inode in the disk to the Inode in the fill memory, you are using the disk file Inode. When a file is created, it is assigned an Inode. An Inode corresponds to only one actual file, and a file will only have one Inode (a directory is also a file in Unix/Linux systems, and opening a directory is actually opening a directory file.) The structure of a directory file is very simple, just a list of directory entries. Each directory entry consists of two parts: the file name of the file it contains and the inode number corresponding to that file name.

Dentry: The concept of a Dentry object was introduced primarily for the convenience of finding files. Unlike the previous two objects, directory entry objects exist only in memory, and actually correspond to disk directory innode objects. When VFS searches, it finds the corresponding Inode of each directory item according to the directory items at one level, and then operates along the directory items to find the final file.

File object: A file object describes a file that a process has opened. Because a file can be opened by multiple processes, there can be multiple file objects in a file, but the corresponding index nodes and directory entry objects of multiple file objects must be unique. The relationship is as follows:

Since the File object in the process has an independent file offset (current file offset), multiple processes can read and write data in different locations of the file, but it is generally not recommended to play this way, because the system does not guarantee the atomicity of the write in this case, and multiple processes can achieve write protection of the file content through file locks.

PageCache

Page cache improves performance by caching data from disk into memory, thereby reducing disk I/O operations. Also, make sure that data changes in page cache are synchronized to disk, which is called page writeback. An inode corresponds to a page cache object, and a page cache object contains multiple physical pages.

When the kernel initiates a read request (e.g., a process initiates a read() request), it first checks whether the requested data is cached in the page cache, and if so, reads directly from memory without accessing disk, which is called a cache hit. If the requested data is not in cache (cache miss), the data must be read from disk. The kernel then caches the read data into cache so that subsequent read requests can hit cache. Page can cache only a portion of a file, without having to cache the entire file.

When the kernel initiates a write request (for example, the process initiates a write() request), it also writes directly to cache, and at this time it will not immediately synchronize to disk, but will set the written page to dirty page and add it to the dirty list.

Another main task of page cache is to reclaim page to free memory space. At this time, the appropriate page will be selected for release. If it is dirty, the page will be synchronized to disk first and then released. How do I select cache pages? The policy used by Linux is based on the LRU-modified Two-List policy:

The Two-List policy maintains two lists, the active list and the inactive list. Pages on the active list are considered hot and cannot be released. Only pages on the inactive list can be released. Pages of data cached for the first time are added to the inactive list, and pages already on the inactive list are moved to the active list if accessed again. Both lists are maintained using a pseudo-LRU algorithm, with new pages added at the end and removed from the head when removed, just like queues. If the number of pages in the active list is much greater than the inactive list, then the active list header pages are moved into the inactive list, thus balancing the two tables.

When to trigger a dirty page writeback to disk:

user process calls sync() and fsync() system calls;

Free memory is below a certain threshold;

Dirty data resides in memory longer than a certain threshold.

Note that the dirty page write-back mechanism of page cache here can be compared with the dirty page write-back mechanism of mmap. mmap will automatically write back dirty pages to disk after a certain period of time. That is to say, the modified dirty pages in mamp will not be updated back to the file immediately, but there will be a delay for a period of time. You can call msync() to force synchronization, so that the written content can be saved to the file immediately.

The above is how to understand Linux VFS and Page Cache in depth. Have you learned any knowledge or skills? If you want to learn more skills or enrich your knowledge reserves, please pay attention to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.