Details of Linux file descriptors, file pointers, and inodes

Linux--File descriptor, file pointer, index node

1. Linux - File Descriptors

1. File descriptor Fd

When a process opens a file or creates a new file, the kernel returns a file descriptor (a non-negative integer) to point to the opened file. All system calls (read, write) that perform I/O operations pass through the file descriptor.

The file descriptor can be understood as the index of the process file description table, or if the file description table is regarded as an array, the file descriptor can be regarded as the subscript of the array. When an I/O operation is required, fd is passed in as a parameter. The entry corresponding to the fd is first searched from the process file descriptor table, and the handle of the corresponding opened file is taken out. According to the file handle pointing to, the inode pointed to by the file is found in the system fd table, thereby locating the actual location of the file and performing the I/O operation.

Features:

• Each file descriptor corresponds to an open file.
• Different file descriptors may refer to the same file.
• The same file can be opened by different processes or multiple times in the same process.
  

The three relevant tables are:

Process-level file descriptor table

struct task_struct {
  //...
  
    struct files_struct *files //Process level file descriptor table//...
    
};

2. System-level file descriptor table

The kernel maintains an打開文件表for all open files in the system. Each item in the table is called打開文件句柄. An open file handle describes all the information of an open file.

• The current file offset (updated when calling read() and write(), or modified directly with lseek())
• The status flags used when opening the file (i.e., the flags parameter of open())
• File access mode (such as read-only mode, write-only mode, or read-write mode set when calling open())
• Signal driver related settings
• A reference to the file's i-node object
• File type (for example, regular file, socket, or FIFO) and access permissions
• A pointer to a list of locks held by the file
• Various properties of the file, including file size and timestamps associated with different types of operations

3. File system inode table

Each file system maintains an inode table for all files stored on it.

The relationship between the file descriptor table, open file table, and inode table:

The file descriptors 1 and 20 of process A point to the same open file handle because the same file is opened by calling open() and other functions multiple times.

The reason why file descriptor 2 of process A and file descriptor 2 of process B point to the same open file handle may be because of the call to fork(). The child process will inherit the open file descriptor table of the parent process, that is, the child process inherits the open file of the parent process. ; or a process passes an open file descriptor to another process through a Unix domain socket; or different processes call the open function independently to open the same file and the file descriptor is allocated the same as the file descriptor opened by other processes.

Descriptor 0 of process A and descriptor 3 of process B point to different open file handles, but these handles all point to the same entry in the i-node table, that is, the same file. This happens because each process has initiated an open() call for the same file. A similar situation occurs when the same process opens the same file twice.

2. File pointer *FILE

The C language uses file pointers instead of file descriptors as I/O handles. The "file pointer" points to a data structure called a FILE structure in the process user area. When operating a file through a file pointer, you need to call the file API (fopen(), fread(), etc.) provided in the C language stdio.h.

File descriptors are directly visible in POSIX system calls, and file pointers are C language wrappers on top of them.

int open(const char *path, int access, int mode)  
FILE *fopen(char *filename, char *mode)

File path to file pointer: filepath --fopen()-->FILE*;
File path to file descriptor: filepath--open()--fd;
File descriptor to file pointer: fd--fdopen()-->FILE*;
File pointer to file descriptor : FILE*--fileno()--->fd;

3. Index Node Inode

Index node is a data structure that stores metadata of objects in the file system in Unix-like systems.

The inode mainly stores the following data:

• Inode number
• File size
• Number of occupied blocks and block size
• File type (regular file, directory, pipe, etc.)
• The device number where the file is stored
• Number of links
• Read, write, and execute permissions
• The user ID and group ID of the owner
• The time when the file was last accessed and the data was last modified
• The time when the inode was last modified

stat command can be used to view metadata, and the df -i command can be used to view the total number of inodes and the number of inodes used for each hard disk partition. All information except the file name is stored in the inode.

Inodes also consume hard disk space, so when the hard disk is formatted, the operating system automatically divides the hard disk into two areas. One is the data area, which stores file data; the other is the inode area (inode table), which stores the information contained in the inode.

The size of each inode node is generally 128字節or 256字節. The total number of inode nodes is given during formatting, and generally one inode is set for every 1KB or every 2KB. Assuming that in a 1GB hard disk, the size of each inode node is 128 bytes, and one inode is set for every 1KB, then the size of the inode table will reach 128MB, accounting for 12.8% of the entire hard disk.

Each file has an inode, so it is possible that the inode has been used up but the hard disk is not full. The Linux system does not use file names but inodes to identify files.

On the surface, users open files by file name. In fact, this process inside the system is divided into three steps: first, the system finds the inode number corresponding to the file name; second, it obtains the inode information through the inode number; finally, based on the inode information, it finds the block where the file data is located and reads the data.

A directory file is a data structure consisting of a series of directory entries, each of which contains two parts: the file name and the inode number.

1. Special role of Inode

• Sometimes, file names contain special characters that cannot be removed normally. At this time, directly deleting the inode node can delete the file.
• Moving or renaming a file only changes the file name and does not affect the inode number.
• After opening a file, the system identifies the file by its inode number and no longer considers its file name. Therefore, in general, the system cannot know the file name from the inode number.
  

Point 3 makes software updates easy, and can be updated without shutting down the software, without the need for a reboot. Because the system identifies running files by inode number, not by file name. When updating, the new version of the file generates a new inode with the same file name, which will not affect the running files. The next time you run the software, the file name will automatically point to the new version of the file, and the inode of the old version of the file will be recycled.

4. Expansion

1. Disk structure

Files are stored on the hard disk, and the smallest storage unit of the hard disk is called a "sector". Each sector stores 512 bytes (equivalent to 0.5KB).

When the operating system reads the hard disk, it does not read it sector by sector, which is too inefficient. Instead, it reads multiple sectors continuously at one time, that is, it reads a "block" at a time. This "block" composed of multiple sectors is the smallest unit of file access. The most common "block" size is 4KB, that is, eight consecutive sectors form a block.

From the above, we can use (柱面號，盤面號，扇區號) to locate any "disk block". We often mention the block number (logical address) where file data is stored in the external memory. This block number can be converted into the address format of (cylinder number, disk surface number, sector number).

A "block" can be read from this address as follows:

① Move the magnetic arm according to the "cylinder number" to make the magnetic head point to the specified cylinder (also called track)

② Activate the head corresponding to the specified disk surface;

③ As the disk rotates, the specified sector will pass under the head, thus completing the reading/writing of the specified sector.

This is the end of this article about the details of Linux file descriptors, file pointers, and index nodes. For more relevant Linux file descriptors, file pointers, and index nodes, please search for previous articles on 123WORDPRESS.COM or continue to browse the related articles below. I hope everyone will support 123WORDPRESS.COM in the future!