android睡眠过程中对进程的处理

时间：2021-06-06 14:54:46

最近调试的时候碰到一个问题，每次设备进入睡眠的时候，有个进程总是会打印出-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;
}

函数首先是一个while循环，这个循环只能通过内部的break来跳出。我们先分析freeze_task。

[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;
}
可以看见这个函数首先判断下当前进程处于什么状态，是应该skip还是frozen等，并且给相应flag置位。

然后判断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进入睡眠，我们在其他文章中再分析。

标签：

相关文章