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

This article is to share with you what the file types under Linux have. The editor thought it was very practical, so I shared it with you as a reference. Let's follow the editor and have a look.

On Linux, there are seven types of file types:

Ordinary file (-)

Directory (d)

Soft link (character link L)

Socket file (S)

Character device (S)

Block device (B)

Pipe file (named pipe P)

Ordinary files, directories and soft links do not need to be explained. Let's take a look at pipe files, socket files, character devices, block device types.

Pipe file

Pipes are divided into anonymous pipes and named pipes. Pipes are written at one end and read at the other, they are unidirectional data transmission, their data are transferred directly in memory, pipe is a way of inter-process communication, such as parent process write, child process read.

In shell, anonymous pipe is a pipe symbol "|", such as ls | grep xxx, where the process corresponding to ls is the parent process in this independent process group, and the process corresponding to grep is the child process, and the parent process is written to read by the child process.

In programming languages, anonymous pipes are implemented by creating two file handles or file descriptors (such as A, B), one of which is used to write data (for example, An on the writing side, where data is automatically pushed into B). The other file handle is used to read the data (that is, B).

For named pipes, that is, named pipes, named pipes keep files in the file system, which is also known as FIFO, or first in first out. Although the named pipe file is retained in the file system, this file is only an entrance to the named pipe and is still in memory when using the named pipe to transfer data. in other words, it is not inefficient to name the pipe because it is retained on the file system.

In shell, you can use the mknod command or the mkfifo command to create named pipes, which are useful when writing shell scripts for some special requirements. In fact, the function of co-programming (using coproc commands) has been supported since Bash 4 (ksh and zsh have supported co-programs for a long time), but the requirements of co-programs can be achieved through named pipes.

The general pipeline is one-way communication, can not achieve the function of two-way communication, that is, can only write while reading, not both sides can read and write. If you want to achieve two-way communication, you can create two pipes (so that you have four file handles, two readers, and two writers), or use a more convenient socket.

Socket (Socket)

The socket is used to realize the communication between the two ends, and as analyzed above, it can realize the interprocess communication function of the two-way pipeline. Not only that, sockets can also achieve inter-process communication across hosts through the network.

Sockets need to be paired to make sense, that is, they are divided into two ends, and each end has a file descriptor (or file handle) for reading and writing, which is equivalent to two two-way communication pipes.

Sockets are divided into two main categories according to the manner of the protocol family: network sockets (AF_INET type, inet4 and inet6 according to ipv4 and ipv6) and Unix Domain sockets (AF_UNIX type). Of course, from the protocol family down, sockets can be subdivided into many types, such as INET sockets can be divided into TCP sockets, UDP sockets, link layer sockets, Raw sockets, and so on. Among them, network socket is the foundation and core of network programming.

Unix Domain socket

For stand-alone inter-process communication, using Unix Domain sockets is better than Inet sockets, because Unix Domain sockets have no network communication components, that is, a lot of network functions are missing, and it is more lightweight. In fact, the pipeline function implemented by some languages on some operating system platforms is realized through Unix Domain, and its high efficiency can be imagined.

Unix Domain sockets have two file handles (such as An and B), both of which are simultaneously readable and writable handles. Process 1 writes data to An and will automatically push to B, process 2 can read data written from A from B, process 2 will automatically push data written to B to A, and process 1 can read data written from B from A. As follows:

Process 1, process 2, talk, BB, talk, talk, talk.

In programming languages, creating a Unix Domain Socket naturally has a corresponding function that can be easily created (but man socketpair). For bash shell, you can create it with the nc command (NetCat), or simply use two named pipes to achieve the corresponding functionality. If necessary, learn for yourself how to use Unix Domain sockets in bash shell.

Network socket

For interprocess communication across networks, you need to use network sockets. Each network socket consists of five parts, which are called 5 tuples of sockets. The format is as follows:

{protocol, src_addr, src_port, dest_addr, dest_port}

That is, protocol, source address, source port, destination address, destination port.

Each end socket has two buffer in kernel space (that is, a pair of socket has four buffer), with recv buffer and send buffer at each end. Process 1 writes data to the send buffer of its own socket, which is sent to the peer's recv buffer, and then peer process 2 can read data from the recv buffer, and vice versa.

But before you can actually read and write network sockets, network sockets need some settings. After the creation of the server socket (socket () function), there will be a file handle or file descriptor for reading and writing), and then bind the address (through the bind () function) and the listening port (through the listen () function). The client only needs to create the socket and directly use the connect () function to initiate a connection request to the server socket.

For TCP sockets, the client initiates a connection request that means a three-way handshake with the server (kernel completion, independent of the user space process). Each of these three-way handshakes is subdivided, and the first time the client sends a SYN request, after the server receives the SYN, the kernel puts the connection into syn queue and sets the status to syn-recv, and then sends ack+syn to the client. When receiving the client reply to ack, the kernel moves the connection from syn queue to established queue (or accept queue) and marks the status of the connection as established. Finally, wait for the user-space process to initiate the accept () system call to have the kernel remove it from the accept queue. The connection after accept () indicates that the connection has been established, which can really realize the data transmission between the processes at both ends.

For more information about the principles of TCP sockets, see my other article: the socket and TCP connection process that you must not know.

Block devices and character devices

Block devices are hardware devices that are distinguished by random (not necessarily sequential) access to fixed-size blocks (chunk). A fixed-size chunk is called a block. The most common block devices are hard drives, but there are also many other block devices, such as floppy disk drives, Blu-ray readers, and flash memory. Note that these are devices that mount the file system, which is like the lingua franca of block devices.

Character devices are accessed through continuous stream data, byte after byte. Typical character devices are terminals (terminals are divided into multiple, physical and virtual ones) and keyboards.

The easiest way to distinguish between block devices and character devices is to look at the way data is accessed. It is the block device that can randomly access the data, and the character device that must be accessed in byte order.

If you can read a little data here, read a little data there, and finally string into a whole piece of continuous data, then this is a block device, just like the data on the hard disk is discontinuous, and you may need to obtain a piece of data by random access. For example, for a slightly larger file on disk, the first 10k data may be continuous data blocks or in continuous sectors, and the next 10k data may be far away from it or even on different cylinders.

If each byte in a piece of data is the same as the byte order at the time of access, that is, the byte order is exactly the same from the time of access acquisition to the final processing of the data, then this is a character device. In other words, a character device can be thought of as a streaming device. Just like keyboard input data, two word keys are tapped successively, and the byte data corresponding to these two keys must be typed first in front and then in the back when being received. In the same way, the terminal equipment is the same. When the program outputs the data to the terminal, the program outputs the letter a first and then the number 3, so it must be a before and 3 after when displayed on the terminal.

Thank you for reading! What about the file types under Linux to share here, I hope the above content can be of some help to you, so that you can learn more knowledge. If you think the article is good, you can share it and let more people see it.

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.