What are the subsystems of the linux kernel?

The Linux kernel has 5 subsystems: 1. Process Scheduling Control System (SCHED); 2. Memory Management System (MM), whose main function is to control multiple processes to safely share the main memory area; 3. Virtual file system (VFS); 4. Network interface (NET); 5. Inter-process communication (IPC).

The operating environment of this tutorial: Ubuntu 16.04 system, Dell G3 computer.

Kernel:

In computer science, it is a computer program used to manage data I/O (input and output) requests issued by software and translate these requests It provides instructions for data processing and is processed by the central processing unit (CPU) and other electronic components in the computer. It is the most basic part of the modern operating system. It is a piece of software that provides secure access to computer hardware for many applications. This access is limited, and the kernel determines when and how long a program can operate on a certain part of the hardware. Operating directly on the hardware is very complex. Therefore, the kernel usually provides a hardware abstraction method to complete these operations. Through inter-process communication mechanisms and system calls, application processes can indirectly control required hardware resources (especially processors and IO devices).

What are the subsystems of the Linux kernel?

The Linux kernel mainly consists of process scheduling (SCHED), memory management (MM), and virtual file system It consists of 5 subsystems (VFS), network interface (NET) and inter-process communication (IPC), as shown in the figure below.

1. Process Scheduling

Many processes in the process scheduling control system The access of a process to the CPU enables multiple processes to be executed "micro-serially and macro-parallelly" in the CPU. Process scheduling is at the center of the system, and other subsystems in the kernel depend on it because each subsystem needs to suspend or resume processes.

As shown in the figure below, the Linux process switches between several states.

Linux process state transition

In device driver programming, when the requested resources cannot be satisfied, the driver will generally schedule other processes to execute and make this process enter In the sleep state, it will not be awakened and enter the ready state until the resource it requested is released. Sleep is divided into interruptible sleep and uninterruptible sleep. The difference between the two is that interruptible sleep will wake up when receiving a signal.

A process that is completely in the TASK_UNINTERRUPTIBLE state cannot even be "killed", so the kernel after Linux 2.6.26 also has a TASK_KILLABLE state, which is equal to "TASK_WAKEKILL|TASK_UNINTERRUPTIBLE" and can respond to fatal signals.

In the Linux kernel, the task_struct structure (include/linux/sched.h) is used to describe the process. This structure contains memory resources, file system resources, file resources, tty resources, and signals that describe the process. Pointers to handle etc. Linux threads are implemented using a lightweight process model. When a thread is created in user space through the pthread_create() API, essentially the kernel just creates a new task_struct and points all resource pointers of the new task_struct to the one that created it. Resource pointer of task_struct.

The vast majority of processes (and multiple threads in the process) are created by user-space applications. When they require access to underlying resources and hardware, they will enter the kernel space through system calls. Sometimes, in kernel programming, if several tasks need to be executed concurrently, kernel threads can be started, and these threads do not have user space. The function to start the kernel thread is: pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);

2. Memory management

The main function of memory management is to control multiple processes to safely share the main memory area. Linux memory management completes the conversion from virtual memory to physical memory for each process when the CPU provides a memory management unit (MMU). Linux 2.6 introduced support for MMU-less CPUs.

As shown in the figure, generally speaking, each process of Linux on a 32-bit processor enjoys 4GB of memory space, 0~3GB belongs to user space, 3~4GB belongs to kernel space, and kernel space has a certain impact on conventional memory. , I/O device memory and high-end memory have different processing methods. The specific boundaries between kernel space and user space can be adjusted. Under the kernel configuration option Kernel Features→Memory split, the boundary can be set to 2GB or 3GB.

Linux process address space

As shown in the figure above, the overall memory management of the Linux kernel is relatively large, including the underlying Buddy algorithm, which is used to manage each page. Occupancy, slab allocator in kernel space and secondary management of C library in user space. In addition, the kernel also provides page cache support, using memory to cache the disk, and the per backing device info flusher thread is used to flush dirty page cache back to the disk. Kswapd (swap process) is the kernel thread used for page recycling (including file-backed pages and anonymous pages) in Linux. It uses the least recently used (LRU) algorithm for memory recycling.

3. Virtual file system

As shown in the figure,

Linux Virtual File System

The Linux virtual file system hides the specific details of various hardware and provides a unified interface for all devices. Moreover, it is independent of each specific file system and is an abstraction of various file systems. It provides unified vfs_read(), vfs_write() and other interfaces for upper-layer applications, and calls member functions of the file_operations structure implemented in the specific underlying file system or device driver.

4. Network interface

The network interface provides access to various network standards and support for various network hardware. As shown in Figure 3.8, the network interface in Linux can be divided into network protocols and network drivers. The network protocol part is responsible for implementing every possible network transmission protocol. The network device driver is responsible for communicating with hardware devices. Every possible Hardware devices have corresponding device drivers.

Linux network architecture

The Linux kernel supports many types of protocol stacks, such as Internet, UNIX, CAN, NFC, Bluetooth, WiMAX, IrDA, etc. The upper layer Applications uniformly use the socket interface.

5. Inter-process communication

Inter-process communication supports communication between processes. Linux supports a variety of communication mechanisms between processes, including semaphores, shared memory, Message queues, pipes, UNIX domain sockets, etc. These mechanisms can assist multiple processes, mutually exclusive access to multiple resources, inter-process synchronization and message delivery. In actual Linux applications, people tend to use UNIX domain sockets rather than message queues and other mechanisms in System V IPC. The Android kernel has added a new Binder inter-process communication method.

The dependencies between the five components of the Linux kernel are as follows:

• The relationship between process scheduling and memory management: these two sub- Systems depend on each other. In a multi-program environment, if a program wants to run, a process must be created for it. The first thing to do when creating a process is to load the program and data into the memory.

• The relationship between inter-process communication and memory management: The inter-process communication subsystem relies on memory management to support a shared memory communication mechanism. This mechanism allows two processes to have their own private space. In addition, you can also access a common memory area.

• The relationship between the virtual file system and the network interface: The virtual file system uses the network interface to support the Network File System (NFS), and also uses memory management to support RAMDISK devices.

• The relationship between memory management and virtual file system: Memory management uses the virtual file system to support swapping, and the swapping process is regularly scheduled by the scheduler. This is why memory management relies on process scheduling. . When the memory map accessed by a process is swapped out, memory management issues a request to the virtual file system and, at the same time, suspends the currently running process.

In addition to these dependencies, all subsystems in the kernel also depend on some common resources. These resources include APIs used by all subsystems, such as functions for allocating and releasing memory space, functions for outputting warning or error messages, and debugging interfaces provided by the system.

Related recommendations: "Linux Video Tutorial"

The above is the detailed content of What are the subsystems of the linux kernel?. For more information, please follow other related articles on the PHP Chinese website!