No more fear of process deadlock - solution to Linux process freezing

When using Linux systems for development or operation and maintenance, we often encounter process deadlock problems. When a process deadlocks, the response speed of the entire system will be significantly reduced, or even cause the system to crash. However, as a Linux enthusiast, we no longer have to be afraid of process deadlock. Because the Linux system provides a powerful tool - process freezing, which can effectively solve the process deadlock problem. This article will introduce in detail the principle and application method of Linux process freezing.

1 What is process freezing

Process freezing technology (freezing of tasks) refers to placing user processes and some kernel threads in a "controllable" pause state when the system hibernates or suspends.

2 Why freezing technology is needed

Assuming there is no freezing technology, the process can be suspended at any schedulable point, and will not be suspended and migrated until cpu_down. This can cause a lot of problems for the system:

(1) It is possible to damage the file system. If there are processes still modifying the contents of the file system between the system creating the hibernate image and the CPU down, this will result in the file system being unable to be fully restored after the system is restored;

(2) It may cause the creation of hibernation image to fail. Creating a hibernation image requires sufficient memory space, but if there are still processes applying for memory during this period, the creation may fail;

(3) It may interfere with the device's suspend and resume. Before CPU down, during device suspend, if the process is still accessing the device, especially accessing competing resources, it may cause device suspend exception;

(4) It may cause the process to sense system sleep. The ideal state of system hibernation is that all tasks are unaware of the hibernation process and automatically resume work after waking up. However, some processes, such as a certain process, require all CPUs to be online to work properly. If the process does not freeze, it will Work abnormally.

3 Code implementation framework

The frozen objects are entities in the kernel that can be scheduled for execution, including user processes, kernel threads and work_queue. User processes can be frozen by default, which is implemented by borrowing the signal processing mechanism; kernel threads and work_queue cannot be frozen by default. A few kernel threads and work_queue specify the freezeable flag when they are created. These tasks need to judge the freeze status. When the system When entering freezing, the operation is automatically suspended.

Kernel threads can determine the freezing status by calling kthread_freezable_should_stop, and actively call __refrigerator to enter freezing; work_queue determines the max_active attribute. If max_active=0, new work cannot be queued, and all work is delayed.

There are three important global variables that mark the system freeze status: pm_freezing, system_freezing_cnt and pm_nosig_freezing. If all are 0, it means that the system has not entered freezing; system_freezing_cnt》0 means that the system has entered freezing, pm_freezing=true means freezing user processes, pm_nosig_freezing= true means freezing kernel threads and workqueue. They will be set in freeze_processes and freeze_kernel_threads, and cleared in thaw_processes and thaw_kernel_threads.

The fake_signal_wake_up function cleverly makes use of the signal processing mechanism. It only sets the TIF_SIGPENDING bit of the task, but does not pass any signal, and then wakes up the task; in this way, the task will enter the signal processing process when returning to user mode, check the freeze status of the system, and Deal with it accordingly.

The code for the task to actively call try_to_freeze is as follows:

static inline bool try_to_freeze_unsafe（void）

{

if （likely（！freezing（current））） //检查系统是否处于freezing状态

return false;

return __refrigerator（false）; //主动进入冻结

}

static inline bool freezing（struct task_struct *p）

{

if （likely（！atomic_read（&system_freezing_cnt））） //系统总体进入freezing

return false;

return freezing_slow_path（p）;

}

bool freezing_slow_path（struct task_struct *p）

{

if （p-》flags & PF_NOFREEZE） //当前进程是否允许冻结

return false;

if （pm_nosig_freezing || cgroup_freezing（p）） //系统冻结kernel threads

return true;

if （pm_freezing && ！（p-》flags & PF_KTHREAD）） //系统冻结用户进程

return true;

return false;

}
进入冻结状态直到恢复的主要函数：bool __refrigerator（bool check_kthr_stop）
{

。..

for （;;） {
set_current_state（TASK_UNINTERRUPTIBLE）; //设置进程为UNINTERRUPTIBLE状态
spin_lock_irq（&freezer_lock）;

current-》flags |= PF_FROZEN; //设置已冻结状态

if （！freezing（current） ||

（check_kthr_stop && kthread_should_stop（））） //判断系统是否还处于冻结

current-》flags &= ~PF_FROZEN; //如果系统已解冻，则取消冻结状态

spin_unlock_irq（&freezer_lock）;

if （！（current-》flags & PF_FROZEN）） //如果已取消冻结，跳出循环，恢复执行

break;

was_frozen = true;

schedule（）;

}

。..。..

}

Through this article's introduction to the Linux process freezing tool, we learned its principles and usage, and mastered how to effectively solve the process deadlock problem. The process freezing tool solves common operating system problems for us and provides us with a more efficient and stable working environment. When we encounter a process deadlock, there is no need to panic. We can easily solve the problem through process freezing tools.

The above is the detailed content of No more fear of process deadlock - solution to Linux process freezing. For more information, please follow other related articles on the PHP Chinese website!