:Linux process freezing technology: Make your system more stable

Have you ever encountered various problems that occur when the system is hibernating? For example, the file system is damaged, hibernation image creation fails, device suspend is abnormal, etc. These problems can be solved through Linux process freezing technology.

1. 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. Without 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 corrupt the file system. Between the time the system creates the hibernate image and the time the CPU goes down, if there are processes that are still modifying the contents of the file system, 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 is possible to interfere with the device's suspend and resume. Before the CPU is down, during device suspend, if the process is still accessing the device, especially when accessing competing resources, it may cause a device suspend exception;
   4. It may cause the process to sense system hibernation. 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. 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 they are all 0, it means that the system has not entered freezing; system_freezing_cnt>0 means that the system has entered freezing, and pm_freezing=true means Freeze the user process. pm_nosig_freezing=true means freezing the kernel thread 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 handle it accordingly. .
The code for the task to actively call try_to_freeze is as follows:

```

```

1. static inline bool try_to_freeze_unsafe(void)
2. {
3. if (likely(!freezing(current))) //检查系统是否处于freezing状态
4. return false;
5. return __refrigerator(false); //主动进入冻结
6. }
7.  
8. static inline bool freezing(struct task_struct *p)
9. {
10. if (likely(!atomic_read(&system_freezing_cnt))) //系统总体进入freezing
11. return false;
12. return freezing_slow_path(p);
13. }
14.  
15. bool freezing_slow_path(struct task_struct *p)
16. {
17. if (p->flags & PF_NOFREEZE) //当前进程是否允许冻结
18. return false;
19.  
20. if (pm_nosig_freezing || cgroup_freezing(p)) //系统冻结kernel threads
21. return true;
22.  
23. if (pm_freezing && !(p->flags & PF_KTHREAD)) //系统冻结用户进程
24. return true;
25.  
26. return false;
27. }

The main function to enter the frozen state until recovery: bool __refrigerator(bool check_kthr_stop)

1. {
2. ...
3. for (;;) {
4. set_current_state(TASK_UNINTERRUPTIBLE); //设置进程为UNINTERRUPTIBLE状态
5.  
6. spin_lock_irq(&freezer_lock);
7. current->flags |= PF_FROZEN; //设置已冻结状态
8. if (!freezing(current) ||
9. (check_kthr_stop && kthread_should_stop())) //判断系统是否还处于冻结
10. current->flags &= ~PF_FROZEN; //如果系统已解冻，则取消冻结状态
11. spin_unlock_irq(&freezer_lock);
12.  
13. if (!(current->flags & PF_FROZEN)) //如果已取消冻结，跳出循环，恢复执行
14. break;
15. was_frozen = true;
16. schedule();
17. }
18. ......
19. }

In short, Linux process freezing technology is a very useful technology that can help you avoid some potential problems and make your system more stable. If you want to learn more about this technology, check out the resources provided in this article.

The above is the detailed content of :Linux process freezing technology: Make your system more stable. For more information, please follow other related articles on the PHP Chinese website!