1 概述

进程冻结是当系统hibernate或者suspend时，对进程进行暂停挂起的一种机制，后面主要以hibernate为例进行介绍。那么为什么要在hibernate或者suspend时需要把进程冻结呢？主要是出于如下的原因：

1. 防止文件系统被修改后无法恢复。假设没有进程冻结操作，那么在hibernate时，进程可能会在hibernation image镜像生成后依然修改文件系统，这就导致当系统从hibernate镜像resume时这部分的修改丢失，更严重的可能导致无法从hibernate image恢复文件系统数据。
2. hibernation image生成需要足够的内存空间，为了保证内存回收后不被其他进程再申请走，因此需要先对进程进行冻结，然后在生成hibernation image。
3. 防止进程在系统suspend或者hibernate之后继续访问已经休眠的设备
4. 防止用户空间进程需要针对suspend或者hibernate状态做相应的处理，有了进程冻结之后，suspend和hibernate对于用户空间进程来说完全是透明的，不用特殊做处理。

2 相关变量和接口

有3个 per-task 的 flag 用于描述进程冻结状态：
PF_NOFREEZE：如果置位表示该进程不会被冻结，为0表示进程需要在suspend或者hibernate时被冻结
PF_FROZEN：表示进程已经处于冻结状态
PF_FREEZER_SKIP：附加备用状态

3个重要的全局变量：
system_freezing_cnt：大于 0 表示系统进入了冻结状态
pm_freezing： true 表示用户进程被冻结
pm_nosig_freezing： true 表示内核进程和 workqueue 被冻结

重要的函数API：

freeze_processes():
-冻结用户态进程，内部会调用try_to_freeze_tasks(true)。freeze_kernel_threads():
-冻结内核线程，内核会调用try_to_freeze_tasks(false)（实际上是冻结所有进程，因为也会扫描用户态进程）thaw_kernel_threads():-解冻内核线程thaw_processes():-解冻所有进程（包括内核线程和用户态进程）

3 如何请求冻结一个进程 try_to_freeze_tasks()【核心】

freeze_processes 和 freeze_kernel_threads 最终都会调用到一个关键函数 try_to_freeze_tasks

static int try_to_freeze_tasks(bool user_only)
{struct task_struct *g, *p;unsigned long end_time;unsigned int todo;bool wq_busy = false;ktime_t start, end, elapsed;unsigned int elapsed_msecs;bool wakeup = false;int sleep_usecs = USEC_PER_MSEC;
#ifdef CONFIG_PM_SLEEPchar suspend_abort[MAX_SUSPEND_ABORT_LEN];
#endifstart = ktime_get_boottime();end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs);if (!user_only)  //根据传入的参数判断是否只冻结用户态进程freeze_workqueues_begin();  //如果为false，则冻结WQ_FREEZABLE类型的workqueuewhile (true) {todo = 0;read_lock(&tasklist_lock);for_each_process_thread(g, p) { //遍历系统中所有进程if (p == current || !freeze_task(p)) //对非本进程的进程尝试冻结，冻结成功执行continue下一个continue;if (!freezer_should_skip(p)) //运行到这里说明尝试冻结失败了，如果该进程不能跳过冻结，todo需要+1todo++;}read_unlock(&tasklist_lock);if (!user_only) { //尝试对内核workqueue进行冻结wq_busy = freeze_workqueues_busy();todo += wq_busy;}if (!todo || time_after(jiffies, end_time)) //判断冻结操作是否完成，完成了就break退出循环，如果超时也会break，当做冻结失败break;if (pm_wakeup_pending()) {
#ifdef CONFIG_PM_SLEEPpm_get_active_wakeup_sources(suspend_abort,MAX_SUSPEND_ABORT_LEN);log_suspend_abort_reason(suspend_abort);
#endifwakeup = true;break;}/** We need to retry, but first give the freezing tasks some* time to enter the refrigerator.  Start with an initial* 1 ms sleep followed by exponential backoff until 8 ms.*/usleep_range(sleep_usecs / 2, sleep_usecs); //等待一段时间后重新尝试冻结操作if (sleep_usecs < 8 * USEC_PER_MSEC)sleep_usecs *= 2;} //end of whileend = ktime_get_boottime();elapsed = ktime_sub(end, start);elapsed_msecs = ktime_to_ms(elapsed);if (wakeup) { //是否是被打断pr_cont("\n");pr_err("Freezing of tasks aborted after %d.%03d seconds",elapsed_msecs / 1000, elapsed_msecs % 1000);} else if (todo) { //超时退出时会到这里，此时todo大于0，还有进程未冻结，冻结失败pr_cont("\n");pr_err("Freezing of tasks failed after %d.%03d seconds"" (%d tasks refusing to freeze, wq_busy=%d):\n",elapsed_msecs / 1000, elapsed_msecs % 1000,todo - wq_busy, wq_busy);if (wq_busy)show_workqueue_state();read_lock(&tasklist_lock);for_each_process_thread(g, p) {if (p != current && !freezer_should_skip(p)&& freezing(p) && !frozen(p))sched_show_task(p);}read_unlock(&tasklist_lock);} else {  //冻结成功pr_cont("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000,elapsed_msecs % 1000);}return todo ? -EBUSY : 0;
}

【文章福利】小编推荐自己的Linux内核技术交流群：【977878001】整理一些个人觉得比较好得学习书籍、视频资料共享在群文件里面，有需要的可以自行添加哦！！！前100进群领取，额外赠送一份价值699的内核资料包（含视频教程、电子书、实战项目及代码）

内核资料直通车：Linux内核源码技术学习路线+视频教程代码资料

学习直通车：Linux内核源码/内存调优/文件系统/进程管理/设备驱动/网络协议栈

3.1 发送冻结信号 freeze_task()

freeze_task 是用来对一个进程进行freeze操作的函数，冻结进程的行为实际上只能由被冻结进程本身进行处理，而此函数只是向被冻结进程发送一个信号。

bool freeze_task(struct task_struct *p)
{unsigned long flags;/** This check can race with freezer_do_not_count, but worst case that* will result in an extra wakeup being sent to the task.  It does not* race with freezer_count(), the barriers in freezer_count() and* freezer_should_skip() ensure that either freezer_count() sees* freezing == true in try_to_freeze() and freezes, or* freezer_should_skip() sees !PF_FREEZE_SKIP and freezes the task* normally.*/if (freezer_should_skip(p))  // ----------- step 1return false;spin_lock_irqsave(&freezer_lock, flags);if (!freezing(p) || frozen(p)) {  // --------step 2spin_unlock_irqrestore(&freezer_lock, flags);return false;}if (!(p->flags & PF_KTHREAD))fake_signal_wake_up(p);  // --------- step 3elsewake_up_state(p, TASK_INTERRUPTIBLE); // -------- step 4spin_unlock_irqrestore(&freezer_lock, flags);return true;
}

1. 使用freezer_should_skip函数来判断该进程是否属于PF_FREEZER_SKIP类型，是否需要跳过冻结操作
2. 使用freezing来判断是否要对该进程进行冻结，其中会判断pm_freezing和pm_nosig_freezing全局变量来判断对于内核进程是否也要执行冻结操作，frozen函数用来判断该进程是否是已经处于冻结状态了，如果已经冻结自然不需要重复发送冻结信号。
3. 运行到这里，说明经过前面的条件判断，确定需要对该进程发送冻结请求，PF_KTHREAD 用来区分是否是内核线程，如果不是内核线程，那么表示该进程为用户态进程，此时发送一个虚假的信号去唤醒该进程，借助于进程的信号处理机制来处理进程冻结操作。
4. 如果当前进程是内核线程，此时需要使用 TASK_INTERRUPTIBLE 唤醒该内核线程，在需要冻结的内核线程中，需要调用 try_to_freeze、wait_event_freezable、wait_event_freezable_timeout 来处理进程冻结。

4 用户态进程冻结 fake_signal_wake_up()

前面介绍到当对一个用户态的进程进行冻结请求时，会发送一个虚假的信号 fake_signal_wake_up 来唤醒用户态进程处理信号。那么这个流程是怎样的呢？

 static void fake_signal_wake_up(struct task_struct *p)
{unsigned long flags;if (lock_task_sighand(p, &flags)) {signal_wake_up(p, 0);unlock_task_sighand(p, &flags);}
}

4.1 signal_wake_up() / signal_wake_up_state()

static inline void signal_wake_up(struct task_struct *t, bool resume)
{signal_wake_up_state(t, resume ? TASK_WAKEKILL : 0);
}void signal_wake_up_state(struct task_struct *t, unsigned int state)
{set_tsk_thread_flag(t, TIF_SIGPENDING); //设置SIGPENDING标记，这样当进程返回用户空间时会先处理信号/** TASK_WAKEKILL also means wake it up in the stopped/traced/killable* case. We don't check t->state here because there is a race with it* executing another processor and just now entering stopped state.* By using wake_up_state, we ensure the process will wake up and* handle its death signal.*/if (!wake_up_state(t, state | TASK_INTERRUPTIBLE)) //设置进程为TASK_INTERRUPTIBLE状态，并唤醒进程kick_process(t); //让进程陷入内核态处理信号
}

signal_wake_up_state 里面主要做了两件事情:

1. 线程设置TIF_SIGPENDING表示信号来了，这就说明其实信号的处理和进程的调度是采取这样一种类似的机制：当发现一个进程应该被调度的时候，并不直接把它赶下来，而是设置一个标识位TIF_NEED_RESCHED表示等待调度，然后等待系统调用结束或者中断处理结束，从内核态返回用户态的时候，调用schedule函数进行调度。信号也是类似的，当信号来的时候并不直接处理这个信号，而是设置一个标识位TIF_SIGPENDING，来表示已经有信号等待处理，同样等待系统调用结束，或者中断处理结束，从内核态返回用户态的时候，再进行信号的处理。
2. 试图唤醒这个进程或者线程。wake_up_state会调用try_to_wake_up方法，就是将这个进程或者线程设置为 TASK_RUNNING 状态准备被调度，然后放在运行队列中，这个时候随着时钟不断的滴答，迟早会被调用。如果 wake_up_state 返回 0，说明进程或者线程已经是 TASK_RUNNING 状态了，如果它在另外一个 CPU 上运行，则调用 kick_process 发送一个处理器间中断，强制那个进程或者线程重新调度，重新调度完毕后，会返回用户态运行，这是一个时机，会检查 TIF_SIGPENDING 标识位。

4.1.1 发送 cpu 中断 kick_process()

/**** kick_process - kick a running thread to enter/exit the kernel* @p: the to-be-kicked thread* Cause a process which is running on another CPU to enter* kernel-mode, without any delay. (to get signals handled.)
*/
void kick_process(struct task_struct *p)
{int cpu;preempt_disable();cpu = task_cpu(p); //找到该进程要被运行的cpuif ((cpu != smp_processor_id()) && task_curr(p))smp_send_reschedule(cpu);// 发送CPU间的IPI中断请求preempt_enable();
}void smp_send_reschedule(int cpu)
{BUG_ON(cpu_is_offline(cpu));smp_cross_call_common(cpumask_of(cpu), IPI_RESCHEDULE);
}

这里需要注意为什么最后要发送一个IPI中断给到需要运行该进程的CPU，因为需要冻结用户态进程，因为该中断会使得用户进程陷入到内核态，处理中断，中断处理完成后都会调用ret_to_user返回用户态继续运行，而在ret_to_user中，也就会返回用户态前会判断是否有pending signal要被处理，这时就可以处理进程冻结了。

->ret_to_user
-->do_notify_resume
--->do_signal
---->get_signal
------>try_to_freeze //执行线程具体眠动作

5 内核线程冻结

对于一个需要睡眠的内核线程，一般的处理流程如下：

set_freezable();
do {hub_events();wait_event_freezable(khubd_wait,!list_empty(&hub_event_list) ||kthread_should_stop());
} while (!kthread_should_stop() || !list_empty(&hub_event_list));

et_freezable 会清除本进程的 PF_NOFREEZE 标志，也就意味着该内核进程可以被冻结。或者：

set_freezable();
while (!kthread_should_stop()) {try_to_freeze();
......
}

while循环在每次运行到 try_to_freeze 时都会检测调用 freezing 函数检测一下本进程是否可以被冻结，如果可以就直接进行冻结操作。

5.1 执行休眠动作 try_to_freeze()

static inline bool try_to_freeze(void)
{if (!(current->flags & PF_NOFREEZE))debug_check_no_locks_held();return try_to_freeze_unsafe();
}static inline bool try_to_freeze_unsafe(void)
{might_sleep();if (likely(!freezing(current)))return false;return __refrigerator(false);//冻结存储
}

如果我们想要创建一个需要冻结的内核线程，就需要遵守上面的要求来实现它，否则会导致系统 freeze 失败从而无法休眠。