Detailed explanation of several ways of communication between Linux user state and kernel state

Due to the limitation of CPU permissions, communication between Linux user state and kernel state is not as simple as imagined using inter-process communication. This article will take a look at the communication methods between Linux user state and kernel state.

When we write code, we usually access kernel space through system call functions in user space. This is the most commonly used way of communication between user space and kernel space. (For more information about Linux user mode and kernel mode, please refer to xx)

In addition, there are four other ways:

• procfs(/proc)
• sysctl (/proc/sys)
• sysfs(/sys)
• Netlink socket

procfs(/proc)

procfs is the abbreviation of process file system. It is essentially a pseudo file system. Why is it called a pseudo file system? Because it does not take up external storage space, but only a small amount of memory, it is usually mounted in the /proc directory.

A file we see in this directory is actually a kernel variable. The kernel uses this directory to display its internal information in the form of files. This is equivalent to the /proc directory building a bridge for interaction between user state and kernel state. User state reads and writes files under /proc , which means reading and writing kernel-related configuration parameters.

For example, the common /proc/cpuinfo , /proc/meminfo and /proc/net provide relevant parameters of CPU, memory and network respectively. In addition, there are many parameters, as shown below:

root@ubuntu:~# ls /proc/
1 1143 1345 1447 2 2292 29 331 393 44 63 70 76 acpi diskstats irq locks sched_debug sysvipc zoneinfo
10 1145 1357 148 20 23 290 332 396 442 64 7019 77 asound dma kallsyms mdstat schedstat thread-self
1042 1149 1361 149 2084 2425 291 34 398 45 65 7029 8 buddyinfo driver kcore meminfo scsi timer_list
1044 1150 1363 15 2087 25 3 3455 413 46 66 7079 83 bus execdomains keys misc self timer_stats
1046 1151 1371 16 2090 256 30 35 418 47 6600 7080 884 cgroups fb key-users modules slabinfo tty
1048 1153 1372 17 21 26 302 36 419 5 67 71 9 cmdline filesystems kmsg mounts softirqs uptime
11 1190 1390 18 22 27 31 37 420 518 6749 72 96 consoles fs kpagecgroup mtrr stat version
1126 12 143 182 2214 28 32 373 421 524 68 73 97 cpuinfo interrupts kpagecount net swaps version_signature
1137 1252 1434 184 2215 280 327 38 422 525 69 74 98 crypto iomem kpageflags pagetypeinfo sys vmallocinfo
1141 13 144 190 2262 281 33 39 425 5940 7 75 985 devices ioports loadavg partitions sysrq-trigger vmstat

As you can see, there are many files represented by numbers. These are actually the process files running in the current system. The numbers represent the process ID (PID). Each file contains all the configuration information of the process, including process status, file descriptors, memory mapping, etc. Let's take a look:

root@ubuntu:~# ls /proc/1/
attr/ cmdline environ io mem ns/ pagemap schedstat stat timers
autogroup comm exe limits mountinfo numa_maps personality sessionid statm uid_map
auxv coredump_filter fd/ loginuid mounts oom_adj projid_map setgroups status wchan
cgroup cpuset fdinfo/ map_files/ mountstats oom_score root/ smaps syscall     
clear_refs cwd/ gid_map maps net/ oom_score_adj sched stack task/

In summary, the kernel exposes its system configuration information through files one by one. Some of these files are read-only, some are writable, and some are dynamically changing. For example, when an application reads a /proc/ file, the kernel will register the file and then call a set of kernel functions to process it, copying the corresponding kernel parameters to the user space, so that the user can obtain the kernel information by reading the file. A rough diagram is shown below:

sysctl

The sysctl we are familiar with is a Linux command. You can see its functions and usage man sysctl . It is mainly used to modify the runtime parameters of the kernel. In other words, it can dynamically modify the kernel parameters while the kernel is running.

It essentially still uses file read and write operations to complete communication between user mode and kernel mode. It uses a subdirectory of /proc /proc/sys . The difference from procfs is:

procfs outputs mainly read-only data, while most of the information output by sysctl is writable.

For example, we usually use cat /proc/sys/net/ipv4/ip_forward to obtain whether the kernel network layer allows forwarding IP packets, and use echo 1 > /proc/sys/net/ipv4/ip_forward or sysctl -w net.ipv4.ip_forward=1 to set the kernel network layer to allow forwarding IP packets.

For the same operation, Linux also provides the file /etc/sysctl.conf for you to make batch modifications.

sysfs

Sysfs is a virtual file system introduced in Linux 2.6. It also uses the file /sys to complete the communication between user mode and kernel. Unlike procfs, sysfs separates some of the devices and drivers that were originally in procfs and presents them to the user in the form of a "device tree".

Sysfs can not only read device and driver information from kernel space, but also configure devices and drivers.

Let's see what's under /sys :

# ls /sys
block bus class dev devices firmware fs hypervisor kernel module power

It can be seen that these files are basically closely related to the computer's devices and drivers. You can find out more about the explanation of these files by yourself, so I won’t go into details here.

netlink

Netlink is the most commonly used method for communication between Linux user mode and kernel mode. Support is only available from Linux kernel 2.6.14. It is essentially a socket, and the standard API used by regular sockets also applies to it. For example, to create a netlink socket, you can call the following socket function:

#include <asm/types.h>
#include <sys/socket.h>
#include <linux/netlink.h>

netlink_socket = socket(AF_NETLINK, socket_type, netlink_family);

Netlink's flexible approach allows it to be used in message passing systems between the kernel and various user processes, such as routing subsystems, firewalls (Netfilter), ipsec security policies, and so on.

Extension:

net-tools tool accesses and changes the kernel network parameter configuration through procfs (/proc) and ioctl system calls, while iproute2 communicates with the kernel through the netlink socket interface. The former has been eliminated, and the latter has gradually become the standard.

Summarize

There are four main ways for Linux user mode and kernel mode to communicate, among which netlink and procfs are the most common ways.

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.