最近调试的时候碰到一个问题，每次设备进入睡眠的时候，有个进程总是会打印出-512的错误，经查这个是因为daemon被wake_up后，condition不满足但是daemon收到了signal导致的。
具体问题如下：
daemon通过系统调用ioctl进入内核空间，然后调用wait_event_interruptible函数让自身休眠，注意这个wait_event_interruptible是可以被signal打断的。
wait_event_interruptible的具体代码如下，其只是对__wait_event_interruptible的封装，所以直接看封装前的代码，如下：
#define __wait_event_interruptible(wq, condition, ret) \
do { \
DEFINE_WAIT(__wait); \
\
for (;;) { \
prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE); \
if (condition) \
break; \
if (!signal_pending(current)) { \
schedule(); \
continue; \
} \
ret = -ERESTARTSYS; \
break; \
} \
finish_wait(&wq, &__wait); \
} while (0)从上面就可以清楚的看到，
1.醒来后会去先检查condition，如果满足直接break去执行后续代码。
2.如果condition不满足则判断下当前进程获取的signal状态，如果没有signal处于pending状态，则通过schedule把自身调度出去进入睡眠。
3.如果进程此时有signa则后返回ERESTARTSYS，即512，也会break，进程醒来执行后续代码。
我当时碰到的问题就是，进程被wake_up，condition不满足，但是进程的标志位被置为TIF_SIGPENDING，导致这里的signal_pending条件为真返回的是-512，同时把进程唤醒了。
经过研究发现这里是和内核中电源管理中的freeze有关，下面分析。
睡眠的函数调用大致如下，网上有很多文章，这里只列出主要的函数调用。
state_store->pm_suspend->enter_state->suspend_prepare->suspend_freeze_processes。
当调用到suspend_freeze_processes时就是我们需要关心的了，这里面会做很多进程相关的操作。
函数源码如下：
[baseline\kernel\power\power.h]
static inline int suspend_freeze_processes(void)
{
int error;
error = freeze_processes();
/*
* freeze_processes() automatically thaws every task if freezing
* fails. So we need not do anything extra upon error.
*/
if (error)
return error;
error = freeze_kernel_threads();
/*
* freeze_kernel_threads() thaws only kernel threads upon freezing
* failure. So we have to thaw the userspace tasks ourselves.
*/
if (error)
thaw_processes();
return error;
}
可以看见它针对普通进程和内核进程分别调用了对应函数来进行freeze操作。我们先看freeze_processes。
[baseline\kernel\power\process.c]
int freeze_processes(void)
{
int error;
error = __usermodehelper_disable(UMH_FREEZING);
if (error)
return error;
if (!pm_freezing)
atomic_inc(&system_freezing_cnt);
printk("Freezing user space processes ... ");
pm_freezing = true;
error = try_to_freeze_tasks(true);
if (!error) {
printk("done.");
__usermodehelper_set_disable_depth(UMH_DISABLED);
oom_killer_disable();
}
printk("\n");
BUG_ON(in_atomic());
if (error)
thaw_processes();
return error;
}我们这边主要关心try_to_freeze_tasks函数，其它暂时不关心。
[baseline\kernel\power\power.c]
static int try_to_freeze_tasks(bool user_only)
{
... ...
while (true) {
todo = 0;
read_lock(&tasklist_lock);
do_each_thread(g, p) {
if (p == current || !freeze_task(p)) -->freeze_task
continue;
/*
* Now that we've done set_freeze_flag, don't
* perturb a task in TASK_STOPPED or TASK_TRACED.
* It is "frozen enough". If the task does wake
* up, it will immediately call try_to_freeze.
*
* Because freeze_task() goes through p's scheduler lock, it's
* guaranteed that TASK_STOPPED/TRACED -> TASK_RUNNING
* transition can't race with task state testing here.
*/
if (!task_is_stopped_or_traced(p) &&
!freezer_should_skip(p))
todo++;
} while_each_thread(g, p);
read_unlock(&tasklist_lock);
if (!user_only) {
wq_busy = freeze_workqueues_busy();
todo += wq_busy;
}
if (!todo || time_after(jiffies, end_time))
break;
if (pm_wakeup_pending()) {
wakeup = 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;
}
do_gettimeofday(&end);
elapsed_msecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
do_div(elapsed_msecs64, NSEC_PER_MSEC);
elapsed_msecs = elapsed_msecs64;
if (todo) {
printk("\n");
printk(KERN_ERR "Freezing of tasks %s after %d.%03d seconds "
"(%d tasks refusing to freeze, wq_busy=%d):\n",
wakeup ? "aborted" : "failed",
elapsed_msecs / 1000, elapsed_msecs % 1000,
todo - wq_busy, wq_busy);
if (!wakeup) {
read_lock(&tasklist_lock);
do_each_thread(g, p) {
if (p != current && !freezer_should_skip(p)
&& freezing(p) && !frozen(p))
sched_show_task(p);
} while_each_thread(g, p);
read_unlock(&tasklist_lock);
}
} else {
printk("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000,
elapsed_msecs % 1000);
}
return todo ? -EBUSY : 0;
}
[baseline\kernel\freezer.c]
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))
return false;
spin_lock_irqsave(&freezer_lock, flags);
if (!freezing(p) || frozen(p)) {
spin_unlock_irqrestore(&freezer_lock, flags);
return false;
}
if (!(p->flags & PF_KTHREAD)) {
fake_signal_wake_up(p);
/*
* fake_signal_wake_up() goes through p's scheduler
* lock and guarantees that TASK_STOPPED/TRACED ->
* TASK_RUNNING transition can't race with task state
* testing in try_to_freeze_tasks().
*/
} else {
wake_up_state(p, TASK_INTERRUPTIBLE);
}
spin_unlock_irqrestore(&freezer_lock, flags);
return true;
}然后判断p->flags，检测进程是普通进程还是内核进程。这里普通进程要比内核进程多一些处理，就是发送fake的signal
这里所谓的fake signal就是将进程中的标志位置为TIF_SIGPENDING，这样进程在返回用户空间时候检查标志位，如果有signal处于pending状态便调用do_notify_resume来处理以达到欺骗的目的，所以其实这里没有发送真实的signal。最终普通进程或者内核进程都会调用到try_to_wake_up来唤醒相应的进程。
freeze_task的目的就是先把进行设置为TIF_SIGPENDING，然后将其设置为TASK_RUNNING将其唤醒，然后我们再回到try_to_freeze_tasks接着往下看。
如果当前的进程不是TASK_STOP和TASK_TRACED，且没有被设置为PF_FREEZER_SKIP。也就是说当前的进程free
if (!task_is_stopped_or_traced(p) &&
!freezer_should_skip(p))
todo++;当前进程通过freeze机制进一步处理的，则todo会增加。
当所有进程都没扫描处理过后，函数退出do...while循环执行后续代码，我们这里的user_only为true，所以这里函数一次调用如下代码：
if (!todo || time_after(jiffies, end_time))
break;在我碰到的情况中，这个todo是有数值的，所以这里time_after还是会执行计算下是否超时。
接着执行pm_wakeup_pending，用来判断当前的的power transition是否应该终止。正常情况下这里不应该终止，这个函数以后有空再分析。
if (pm_wakeup_pending()) {
wakeup = true;
break;
}接着执行如下代码：
usleep_range(sleep_usecs / 2, sleep_usecs);
if (sleep_usecs < 8 * USEC_PER_MSEC)
sleep_usecs *= 2;到这里需要让出CPU，让本进程睡眠一下，以便刚才唤醒的进程有机会执行。当调度回来后还是在此while(true)循环中，这是个死循环，所以继续从头开始执行。
那么执行到什么时候结束呢？肯定是把所有该freeze的进程都freeze后才回退出，比如：最后一次进入while(true)后，如下这个if应该已经不会进入了。所以todo=false
if (!task_is_stopped_or_traced(p) &&
!freezer_should_skip(p))
todo++;todo是false之后，那么如下这个判断的break就会执行，这个while(true)就退出了。
if (!todo || time_after(jiffies, end_time))
break;
退出while(true)后，后续代码：
if (todo) {
printk("\n");
printk(KERN_ERR "Freezing of tasks %s after %d.%03d seconds "
"(%d tasks refusing to freeze, wq_busy=%d):\n",
wakeup ? "aborted" : "failed",
elapsed_msecs / 1000, elapsed_msecs % 1000,
todo - wq_busy, wq_busy);
if (!wakeup) {
read_lock(&tasklist_lock);
do_each_thread(g, p) {
if (p != current && !freezer_should_skip(p)
&& freezing(p) && !frozen(p))
sched_show_task(p);
} while_each_thread(g, p);
read_unlock(&tasklist_lock);
}
} else {
printk("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000,
elapsed_msecs % 1000);
}此时正常情况下todo应该是0，所以执行else的语句。
到此我们freeze用户进程的流程分析完了，内核空间的过程也是类似的。
所以，freeze的过程就是1.将用户进程的flag设置为TIF_SIGPENDING，然后将其wake_up。2.wake_up内核空间workqueue和进程。
这里将用户空间进程的flag设置为TIF_SIGPENDING后，会将进程设置为TASK_UNINTERRUPTIABLE进入睡眠，我们在其他文章中再分析。