GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-07-11 09:02:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

sched: Restructure ttwu() some more

Browse source 
Factor our helper functions to make the inner workings of try_to_wake_up()
more obvious, this also allows for adding remote queues.

Reviewed-by: Frank Rowand <frank.rowand@am.sony.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Nick Piggin <npiggin@kernel.dk>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
Link: http://lkml.kernel.org/r/20110405152729.475848012@chello.nl
This commit is contained in:
Peter Zijlstra 2011-04-05 17:23:57 +02:00 • committed by Ingo Molnar
parent 23f41eeb42
commit c05fbafba1
1 changed files with 58 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

91
kernel/sched.c
View file

@ -2483,6 +2483,48 @@ ttwu_do_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
#endif #endif
} }
static void
ttwu_do_activate(struct rq *rq, struct task_struct *p, int wake_flags)
{
#ifdef CONFIG_SMP
if (p->sched_contributes_to_load)
rq->nr_uninterruptible--;
#endif
ttwu_activate(rq, p, ENQUEUE_WAKEUP | ENQUEUE_WAKING);
ttwu_do_wakeup(rq, p, wake_flags);
}
/*
* Called in case the task @p isn't fully descheduled from its runqueue,
* in this case we must do a remote wakeup. Its a 'light' wakeup though,
* since all we need to do is flip p->state to TASK_RUNNING, since
* the task is still ->on_rq.
*/
static int ttwu_remote(struct task_struct *p, int wake_flags)
{
struct rq *rq;
int ret = 0;
rq = __task_rq_lock(p);
if (p->on_rq) {
ttwu_do_wakeup(rq, p, wake_flags);
ret = 1;
}
__task_rq_unlock(rq);
return ret;
}
static void ttwu_queue(struct task_struct *p, int cpu)
{
struct rq *rq = cpu_rq(cpu);
raw_spin_lock(&rq->lock);
ttwu_do_activate(rq, p, 0);
raw_spin_unlock(&rq->lock);
}
/** /**
* try_to_wake_up - wake up a thread * try_to_wake_up - wake up a thread
* @p: the thread to be awakened * @p: the thread to be awakened
@ -2501,27 +2543,25 @@ ttwu_do_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
static int static int
try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags) try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
{ {
int cpu, this_cpu, success = 0;
unsigned long flags; unsigned long flags;
struct rq *rq; int cpu, success = 0;
this_cpu = get_cpu();
smp_wmb(); smp_wmb();
raw_spin_lock_irqsave(&p->pi_lock, flags); raw_spin_lock_irqsave(&p->pi_lock, flags);
if (!(p->state & state)) if (!(p->state & state))
goto out; goto out;
success = 1; /* we're going to change ->state */
cpu = task_cpu(p); cpu = task_cpu(p);
if (p->on_rq) { if (p->on_rq && ttwu_remote(p, wake_flags))
rq = __task_rq_lock(p); goto stat;
if (p->on_rq)
goto out_running;
__task_rq_unlock(rq);
}
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
/*
* If the owning (remote) cpu is still in the middle of schedule() with
* this task as prev, wait until its done referencing the task.
*/
while (p->on_cpu) { while (p->on_cpu) {
#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
/* /*
@ -2530,8 +2570,10 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
* to spin on ->on_cpu if p is current, since that would * to spin on ->on_cpu if p is current, since that would
* deadlock. * deadlock.
*/ */
if (p == current) if (p == current) {
goto out_activate; ttwu_queue(p, cpu);
goto stat;
}
#endif #endif
cpu_relax(); cpu_relax();
} }
@ -2547,32 +2589,15 @@ try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
p->sched_class->task_waking(p); p->sched_class->task_waking(p);
cpu = select_task_rq(p, SD_BALANCE_WAKE, wake_flags); cpu = select_task_rq(p, SD_BALANCE_WAKE, wake_flags);
#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW if (task_cpu(p) != cpu)
out_activate: set_task_cpu(p, cpu);
#endif
#endif /* CONFIG_SMP */ #endif /* CONFIG_SMP */
rq = cpu_rq(cpu); ttwu_queue(p, cpu);
raw_spin_lock(&rq->lock); stat:
#ifdef CONFIG_SMP
if (cpu != task_cpu(p))
set_task_cpu(p, cpu);
if (p->sched_contributes_to_load)
rq->nr_uninterruptible--;
#endif
ttwu_activate(rq, p, ENQUEUE_WAKEUP | ENQUEUE_WAKING);
out_running:
ttwu_do_wakeup(rq, p, wake_flags);
success = 1;
__task_rq_unlock(rq);
ttwu_stat(p, cpu, wake_flags); ttwu_stat(p, cpu, wake_flags);
out: out:
raw_spin_unlock_irqrestore(&p->pi_lock, flags); raw_spin_unlock_irqrestore(&p->pi_lock, flags);
put_cpu();
return success; return success;
} }