Merge branch 'sched-fixes-for-linus' of...

   It puts the scheduling entity (task) into the red-black tree and

   increments the nr_running variable.

 - dequeue_tree(...)

 - dequeue_task(...)

   When a task is no longer runnable, this function is called to keep the

   corresponding scheduling entity out of the red-black tree.  It decrements

   This function is mostly called from time tick functions; it might lead to

   process switch.  This drives the running preemption.

 - task_new(...)

   The core scheduler gives the scheduling module an opportunity to manage new

   task startup.  The CFS scheduling module uses it for group scheduling, while

   the scheduling module for a real-time task does not use it.

struct autogroup;

/*

 * NOTE! "signal_struct" does not have it's own

 * NOTE! "signal_struct" does not have its own

 * locking, because a shared signal_struct always

 * implies a shared sighand_struct, so locking

 * sighand_struct is always a proper superset of

 * yield_to - yield the current processor to another thread in

 * your thread group, or accelerate that thread toward the

 * processor it's on.

 * @p: target task

 * @preempt: whether task preemption is allowed or not

 *

 * It's the caller's job to ensure that the target task struct

 * can't go away on us before we can do any checks.

{

	struct cfs_rq *cfs_rq;

	struct sched_entity *se;

	struct rq *rq;

	int i;

	tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL);

	tg->shares = NICE_0_LOAD;

	for_each_possible_cpu(i) {

		rq = cpu_rq(i);

		cfs_rq = kzalloc_node(sizeof(struct cfs_rq),

				      GFP_KERNEL, cpu_to_node(i));

		if (!cfs_rq)

	.prio_changed		= prio_changed_idle,

	.switched_to		= switched_to_idle,

	/* no .task_new for idle tasks */

};

	.prio_changed		= prio_changed_stop,

	.switched_to		= switched_to_stop,

	/* no .task_new for stop tasks */

};