进程调度API之wake_up_process

int wake_up_process(struct task_struct *p)
这个函数用于唤醒一个task。
其使用的例程如下：
static void cmtp_reset_ctr(struct capi_ctr *ctrl)
{
struct cmtp_session *session = ctrl->driverdata;

BT_DBG("ctrl %p", ctrl);

capi_ctr_down(ctrl);

atomic_inc(&session->terminate);
wake_up_process(session->task);
}
例如这个例子中就通过wake_up_process 来唤醒session->task
其源码分析如下：
int wake_up_process(struct task_struct *p)
{
return try_to_wake_up(p, TASK_NORMAL, 0);
}
唤醒p到TASK_NORMAL 状态
static int
try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
{
unsigned long flags;
int cpu, success = 0;

/*
* If we are going to wake up a thread waiting for CONDITION we
* need to ensure that CONDITION=1 done by the caller can not be
* reordered with p->state check below. This pairs with mb() in
* set_current_state() the waiting thread does.
*/
smp_mb__before_spinlock();
raw_spin_lock_irqsave(&p->pi_lock, flags);
#如果task的状态已经等于要设的状态了，就退出吧，从这里知道，调用wake_up_process 不一定非得是sleep的task.正常task
#也是可以的，只是不起作用而已，在这里就退出了.
if (!(p->state & state))
goto out;

trace_sched_waking(p);

/* We're going to change ->state: */
success = 1;
#获得要wakeup 的task 原本是运行到哪个cpu上的
cpu = task_cpu(p);

/*
* Ensure we load p->on_rq _after_ p->state, otherwise it would
* be possible to, falsely, observe p->on_rq == 0 and get stuck
* in smp_cond_load_acquire() below.
*
* sched_ttwu_pending()                 try_to_wake_up()
*   [S] p->on_rq = 1;                  [L] P->state
*       UNLOCK rq->lock  -----.
*                              \
*				 +---   RMB
* schedule()                   /
*       LOCK rq->lock    -----'
*       UNLOCK rq->lock
*
* [task p]
*   [S] p->state = UNINTERRUPTIBLE     [L] p->on_rq
*
* Pairs with the UNLOCK+LOCK on rq->lock from the
* last wakeup of our task and the schedule that got our task
* current.
*/
smp_rmb();
#要唤醒的task 不在自己的rq上，也就是要唤醒其他rq上的task，所以这里会做remote wake up.
if (p->on_rq && ttwu_remote(p, wake_flags))
goto stat;

#ifdef CONFIG_SMP
/*
* Ensure we load p->on_cpu _after_ p->on_rq, otherwise it would be
* possible to, falsely, observe p->on_cpu == 0.
*
* One must be running (->on_cpu == 1) in order to remove oneself
* from the runqueue.
*
*  [S] ->on_cpu = 1;	[L] ->on_rq
*      UNLOCK rq->lock
*			RMB
*      LOCK   rq->lock
*  [S] ->on_rq = 0;    [L] ->on_cpu
*
* Pairs with the full barrier implied in the UNLOCK+LOCK on rq->lock
* from the consecutive calls to schedule(); the first switching to our
* task, the second putting it to sleep.
*/
smp_rmb();

/*
* If the owning (remote) CPU is still in the middle of schedule() with
* this task as prev, wait until its done referencing the task.
*
* Pairs with the smp_store_release() in finish_lock_switch().
*
* This ensures that tasks getting woken will be fully ordered against
* their previous state and preserve Program Order.
*/
smp_cond_load_acquire(&p->on_cpu, !VAL);

p->sched_contributes_to_load = !!task_contributes_to_load(p);
#先将task的状态设置为TASK_WAKING
p->state = TASK_WAKING;
#task 如果是在等待io的时候sleep。则先结束这次io 操作？
if (p->in_iowait) {
delayacct_blkio_end();
atomic_dec(&task_rq(p)->nr_iowait);
}
#根据wakup cpu选择要rq要运行到哪个cpu上
cpu = select_task_rq(p, p->wake_cpu, SD_BALANCE_WAKE, wake_flags);
#如果wakeup后的cpu 和之前task 运行的cpu 不相等，则设置需要迁移的flag，方便以后进行迁移工作。并通过set_task_cpu将task
#wakeup 后的cpu保存在task中
if (task_cpu(p) != cpu) {
wake_flags |= WF_MIGRATED;
set_task_cpu(p, cpu);
}

#else /* CONFIG_SMP */

if (p->in_iowait) {
delayacct_blkio_end();
atomic_dec(&task_rq(p)->nr_iowait);
}

#endif /* CONFIG_SMP */
#执行wakeup task 的操作
ttwu_queue(p, cpu, wake_flags);
stat:
#更新rq中相关统计数据
ttwu_stat(p, cpu, wake_flags);
out:
raw_spin_unlock_irqrestore(&p->pi_lock, flags);

return success;
}