[RFC][PATCH 1/3] sched: rename sched_entity to sched_cfs_entity.

[Dario Faggioli <raistlin@linux.it>]

[-- Attachment #1: Type: text/plain, Size: 78895 bytes --]

Using the name `struct sched_entity' for the scheduling entity
of the fair scheduling class is not fair to the other scheduling
classes, which have to use things like `struct sched_rt_entity'.

Moreover, changing that would make it possible to put all the
`struct sched_*_entity' of all the scheduling classes in a more
general structure (which will also contains all the common fields).
This would make the code easier to understand and, if we manage in
using an union for the class-specific fields, it would also save
some memory.

Therefore, this commit turns `sched_entity' into `sched_cfs_entity',
wherever it is being used.

Signed-off-by: Dario Faggioli <raistlin@linux.it>
---
 fs/proc/base.c            |    2 +-
 include/linux/init_task.h |    4 +-
 include/linux/sched.h     |    6 +-
 kernel/delayacct.c        |    2 +-
 kernel/exit.c             |    2 +-
 kernel/posix-cpu-timers.c |   10 +-
 kernel/sched.c            |  152 ++++++------
 kernel/sched_debug.c      |  117 +++++-----
 kernel/sched_fair.c       |  611 +++++++++++++++++++++++----------------------
 kernel/sched_rt.c         |   26 +-
 kernel/sched_stoptask.c   |    2 +-
 11 files changed, 479 insertions(+), 455 deletions(-)

diff --git a/fs/proc/base.c b/fs/proc/base.c
index 08cba2c..9591d6e 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -356,7 +356,7 @@ static int proc_pid_stack(struct seq_file *m, struct pid_namespace *ns,
 static int proc_pid_schedstat(struct task_struct *task, char *buffer)
 {
 	return sprintf(buffer, "%llu %llu %lu\n",
-			(unsigned long long)task->se.sum_exec_runtime,
+			(unsigned long long)task->cfs.sum_exec_runtime,
 			(unsigned long long)task->sched_info.run_delay,
 			task->sched_info.pcount);
 }
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index caa151f..8baee0b 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -142,8 +142,8 @@ extern struct cred init_cred;
 	.cpus_allowed	= CPU_MASK_ALL,					\
 	.mm		= NULL,						\
 	.active_mm	= &init_mm,					\
-	.se		= {						\
-		.group_node 	= LIST_HEAD_INIT(tsk.se.group_node),	\
+	.cfs		= {						\
+		.group_node 	= LIST_HEAD_INIT(tsk.cfs.group_node),	\
 	},								\
 	.rt		= {						\
 		.run_list	= LIST_HEAD_INIT(tsk.rt.run_list),	\
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 777cd01..55adf37 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1137,7 +1137,7 @@ struct sched_statistics {
 };
 #endif
 
-struct sched_entity {
+struct sched_cfs_entity {
 	struct load_weight	load;		/* for load-balancing */
 	struct rb_node		run_node;
 	struct list_head	group_node;
@@ -1155,7 +1155,7 @@ struct sched_entity {
 #endif
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
-	struct sched_entity	*parent;
+	struct sched_cfs_entity *parent;
 	/* rq on which this entity is (to be) queued: */
 	struct cfs_rq		*cfs_rq;
 	/* rq "owned" by this entity/group: */
@@ -1206,7 +1206,7 @@ struct task_struct {
 	int prio, static_prio, normal_prio;
 	unsigned int rt_priority;
 	const struct sched_class *sched_class;
-	struct sched_entity se;
+	struct sched_cfs_entity cfs;
 	struct sched_rt_entity rt;
 
 #ifdef CONFIG_PREEMPT_NOTIFIERS
diff --git a/kernel/delayacct.c b/kernel/delayacct.c
index ead9b61..f314f56 100644
--- a/kernel/delayacct.c
+++ b/kernel/delayacct.c
@@ -128,7 +128,7 @@ int __delayacct_add_tsk(struct taskstats *d, struct task_struct *tsk)
 	 */
 	t1 = tsk->sched_info.pcount;
 	t2 = tsk->sched_info.run_delay;
-	t3 = tsk->se.sum_exec_runtime;
+	t3 = tsk->cfs.sum_exec_runtime;
 
 	d->cpu_count += t1;
 
diff --git a/kernel/exit.c b/kernel/exit.c
index 676149a..01087fc 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -132,7 +132,7 @@ static void __exit_signal(struct task_struct *tsk)
 		sig->inblock += task_io_get_inblock(tsk);
 		sig->oublock += task_io_get_oublock(tsk);
 		task_io_accounting_add(&sig->ioac, &tsk->ioac);
-		sig->sum_sched_runtime += tsk->se.sum_exec_runtime;
+		sig->sum_sched_runtime += tsk->cfs.sum_exec_runtime;
 	}
 
 	sig->nr_threads--;
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 05bb717..801169c 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -248,7 +248,7 @@ void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times)
 	do {
 		times->utime = cputime_add(times->utime, t->utime);
 		times->stime = cputime_add(times->stime, t->stime);
-		times->sum_exec_runtime += t->se.sum_exec_runtime;
+		times->sum_exec_runtime += t->cfs.sum_exec_runtime;
 	} while_each_thread(tsk, t);
 out:
 	rcu_read_unlock();
@@ -508,7 +508,7 @@ static void cleanup_timers(struct list_head *head,
 void posix_cpu_timers_exit(struct task_struct *tsk)
 {
 	cleanup_timers(tsk->cpu_timers,
-		       tsk->utime, tsk->stime, tsk->se.sum_exec_runtime);
+		       tsk->utime, tsk->stime, tsk->cfs.sum_exec_runtime);
 
 }
 void posix_cpu_timers_exit_group(struct task_struct *tsk)
@@ -518,7 +518,7 @@ void posix_cpu_timers_exit_group(struct task_struct *tsk)
 	cleanup_timers(tsk->signal->cpu_timers,
 		       cputime_add(tsk->utime, sig->utime),
 		       cputime_add(tsk->stime, sig->stime),
-		       tsk->se.sum_exec_runtime + sig->sum_sched_runtime);
+		       tsk->cfs.sum_exec_runtime + sig->sum_sched_runtime);
 }
 
 static void clear_dead_task(struct k_itimer *timer, union cpu_time_count now)
@@ -949,7 +949,7 @@ static void check_thread_timers(struct task_struct *tsk,
 		struct cpu_timer_list *t = list_first_entry(timers,
 						      struct cpu_timer_list,
 						      entry);
-		if (!--maxfire || tsk->se.sum_exec_runtime < t->expires.sched) {
+		if (!--maxfire || tsk->cfs.sum_exec_runtime < t->expires.sched) {
 			tsk->cputime_expires.sched_exp = t->expires.sched;
 			break;
 		}
@@ -1276,7 +1276,7 @@ static inline int fastpath_timer_check(struct task_struct *tsk)
 		struct task_cputime task_sample = {
 			.utime = tsk->utime,
 			.stime = tsk->stime,
-			.sum_exec_runtime = tsk->se.sum_exec_runtime
+			.sum_exec_runtime = tsk->cfs.sum_exec_runtime
 		};
 
 		if (task_cputime_expired(&task_sample, &tsk->cputime_expires))
diff --git a/kernel/sched.c b/kernel/sched.c
index 5ec0615..5d68fb0 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -251,7 +251,7 @@ struct task_group {
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
 	/* schedulable entities of this group on each cpu */
-	struct sched_entity **se;
+	struct sched_cfs_entity **cfs_se;
 	/* runqueue "owned" by this group on each cpu */
 	struct cfs_rq **cfs_rq;
 	unsigned long shares;
@@ -326,7 +326,7 @@ struct cfs_rq {
 	 * 'curr' points to currently running entity on this cfs_rq.
 	 * It is set to NULL otherwise (i.e when none are currently running).
 	 */
-	struct sched_entity *curr, *next, *last;
+	struct sched_cfs_entity *curr, *next, *last;
 
 	unsigned int nr_spread_over;
 
@@ -622,8 +622,8 @@ static inline struct task_group *task_group(struct task_struct *p)
 static inline void set_task_rq(struct task_struct *p, unsigned int cpu)
 {
 #ifdef CONFIG_FAIR_GROUP_SCHED
-	p->se.cfs_rq = task_group(p)->cfs_rq[cpu];
-	p->se.parent = task_group(p)->se[cpu];
+	p->cfs.cfs_rq = task_group(p)->cfs_rq[cpu];
+	p->cfs.parent = task_group(p)->cfs_se[cpu];
 #endif
 
 #ifdef CONFIG_RT_GROUP_SCHED
@@ -1555,7 +1555,7 @@ static int tg_load_down(struct task_group *tg, void *data)
 		load = cpu_rq(cpu)->load.weight;
 	} else {
 		load = tg->parent->cfs_rq[cpu]->h_load;
-		load *= tg->se[cpu]->load.weight;
+		load *= tg->cfs_se[cpu]->load.weight;
 		load /= tg->parent->cfs_rq[cpu]->load.weight + 1;
 	}
 
@@ -1733,13 +1733,13 @@ static void set_load_weight(struct task_struct *p)
 	 * SCHED_IDLE tasks get minimal weight:
 	 */
 	if (p->policy == SCHED_IDLE) {
-		p->se.load.weight = WEIGHT_IDLEPRIO;
-		p->se.load.inv_weight = WMULT_IDLEPRIO;
+		p->cfs.load.weight = WEIGHT_IDLEPRIO;
+		p->cfs.load.inv_weight = WMULT_IDLEPRIO;
 		return;
 	}
 
-	p->se.load.weight = prio_to_weight[p->static_prio - MAX_RT_PRIO];
-	p->se.load.inv_weight = prio_to_wmult[p->static_prio - MAX_RT_PRIO];
+	p->cfs.load.weight = prio_to_weight[p->static_prio - MAX_RT_PRIO];
+	p->cfs.load.inv_weight = prio_to_wmult[p->static_prio - MAX_RT_PRIO];
 }
 
 static void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
@@ -1747,7 +1747,7 @@ static void enqueue_task(struct rq *rq, struct task_struct *p, int flags)
 	update_rq_clock(rq);
 	sched_info_queued(p);
 	p->sched_class->enqueue_task(rq, p, flags);
-	p->se.on_rq = 1;
+	p->cfs.on_rq = 1;
 }
 
 static void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
@@ -1755,7 +1755,7 @@ static void dequeue_task(struct rq *rq, struct task_struct *p, int flags)
 	update_rq_clock(rq);
 	sched_info_dequeued(p);
 	p->sched_class->dequeue_task(rq, p, flags);
-	p->se.on_rq = 0;
+	p->cfs.on_rq = 0;
 }
 
 /*
@@ -2058,7 +2058,7 @@ static void check_preempt_curr(struct rq *rq, struct task_struct *p, int flags)
 	 * A queue event has occurred, and we're going to schedule.  In
 	 * this case, we can save a useless back to back clock update.
 	 */
-	if (rq->curr->se.on_rq && test_tsk_need_resched(rq->curr))
+	if (rq->curr->cfs.on_rq && test_tsk_need_resched(rq->curr))
 		rq->skip_clock_update = 1;
 }
 
@@ -2081,8 +2081,8 @@ task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
 	 * Buddy candidates are cache hot:
 	 */
 	if (sched_feat(CACHE_HOT_BUDDY) && this_rq()->nr_running &&
-			(&p->se == cfs_rq_of(&p->se)->next ||
-			 &p->se == cfs_rq_of(&p->se)->last))
+			(&p->cfs == cfs_rq_of(&p->cfs)->next ||
+			 &p->cfs == cfs_rq_of(&p->cfs)->last))
 		return 1;
 
 	if (sysctl_sched_migration_cost == -1)
@@ -2090,7 +2090,7 @@ task_hot(struct task_struct *p, u64 now, struct sched_domain *sd)
 	if (sysctl_sched_migration_cost == 0)
 		return 0;
 
-	delta = now - p->se.exec_start;
+	delta = now - p->cfs.exec_start;
 
 	return delta < (s64)sysctl_sched_migration_cost;
 }
@@ -2109,7 +2109,7 @@ void set_task_cpu(struct task_struct *p, unsigned int new_cpu)
 	trace_sched_migrate_task(p, new_cpu);
 
 	if (task_cpu(p) != new_cpu) {
-		p->se.nr_migrations++;
+		p->cfs.nr_migrations++;
 		perf_sw_event(PERF_COUNT_SW_CPU_MIGRATIONS, 1, 1, NULL, 0);
 	}
 
@@ -2133,7 +2133,7 @@ static bool migrate_task(struct task_struct *p, struct rq *rq)
 	 * If the task is not on a runqueue (and not running), then
 	 * the next wake-up will properly place the task.
 	 */
-	return p->se.on_rq || task_running(rq, p);
+	return p->cfs.on_rq || task_running(rq, p);
 }
 
 /*
@@ -2193,7 +2193,7 @@ unsigned long wait_task_inactive(struct task_struct *p, long match_state)
 		rq = task_rq_lock(p, &flags);
 		trace_sched_wait_task(p);
 		running = task_running(rq, p);
-		on_rq = p->se.on_rq;
+		on_rq = p->cfs.on_rq;
 		ncsw = 0;
 		if (!match_state || p->state == match_state)
 			ncsw = p->nvcsw | LONG_MIN; /* sets MSB */
@@ -2358,15 +2358,15 @@ static inline void ttwu_activate(struct task_struct *p, struct rq *rq,
 				 bool is_sync, bool is_migrate, bool is_local,
 				 unsigned long en_flags)
 {
-	schedstat_inc(p, se.statistics.nr_wakeups);
+	schedstat_inc(p, cfs.statistics.nr_wakeups);
 	if (is_sync)
-		schedstat_inc(p, se.statistics.nr_wakeups_sync);
+		schedstat_inc(p, cfs.statistics.nr_wakeups_sync);
 	if (is_migrate)
-		schedstat_inc(p, se.statistics.nr_wakeups_migrate);
+		schedstat_inc(p, cfs.statistics.nr_wakeups_migrate);
 	if (is_local)
-		schedstat_inc(p, se.statistics.nr_wakeups_local);
+		schedstat_inc(p, cfs.statistics.nr_wakeups_local);
 	else
-		schedstat_inc(p, se.statistics.nr_wakeups_remote);
+		schedstat_inc(p, cfs.statistics.nr_wakeups_remote);
 
 	activate_task(rq, p, en_flags);
 }
@@ -2428,7 +2428,7 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state,
 	if (!(p->state & state))
 		goto out;
 
-	if (p->se.on_rq)
+	if (p->cfs.on_rq)
 		goto out_running;
 
 	cpu = task_cpu(p);
@@ -2523,7 +2523,7 @@ static void try_to_wake_up_local(struct task_struct *p)
 	if (!(p->state & TASK_NORMAL))
 		return;
 
-	if (!p->se.on_rq) {
+	if (!p->cfs.on_rq) {
 		if (likely(!task_running(rq, p))) {
 			schedstat_inc(rq, ttwu_count);
 			schedstat_inc(rq, ttwu_local);
@@ -2564,18 +2564,18 @@ int wake_up_state(struct task_struct *p, unsigned int state)
  */
 static void __sched_fork(struct task_struct *p)
 {
-	p->se.exec_start		= 0;
-	p->se.sum_exec_runtime		= 0;
-	p->se.prev_sum_exec_runtime	= 0;
-	p->se.nr_migrations		= 0;
+	p->cfs.exec_start		= 0;
+	p->cfs.sum_exec_runtime		= 0;
+	p->cfs.prev_sum_exec_runtime	= 0;
+	p->cfs.nr_migrations		= 0;
 
 #ifdef CONFIG_SCHEDSTATS
-	memset(&p->se.statistics, 0, sizeof(p->se.statistics));
+	memset(&p->cfs.statistics, 0, sizeof(p->cfs.statistics));
 #endif
 
 	INIT_LIST_HEAD(&p->rt.run_list);
-	p->se.on_rq = 0;
-	INIT_LIST_HEAD(&p->se.group_node);
+	p->cfs.on_rq = 0;
+	INIT_LIST_HEAD(&p->cfs.group_node);
 
 #ifdef CONFIG_PREEMPT_NOTIFIERS
 	INIT_HLIST_HEAD(&p->preempt_notifiers);
@@ -3447,7 +3447,7 @@ static u64 do_task_delta_exec(struct task_struct *p, struct rq *rq)
 
 	if (task_current(rq, p)) {
 		update_rq_clock(rq);
-		ns = rq->clock_task - p->se.exec_start;
+		ns = rq->clock_task - p->cfs.exec_start;
 		if ((s64)ns < 0)
 			ns = 0;
 	}
@@ -3480,7 +3480,7 @@ unsigned long long task_sched_runtime(struct task_struct *p)
 	u64 ns = 0;
 
 	rq = task_rq_lock(p, &flags);
-	ns = p->se.sum_exec_runtime + do_task_delta_exec(p, rq);
+	ns = p->cfs.sum_exec_runtime + do_task_delta_exec(p, rq);
 	task_rq_unlock(rq, &flags);
 
 	return ns;
@@ -3709,7 +3709,7 @@ void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st)
 	/*
 	 * Use CFS's precise accounting:
 	 */
-	rtime = nsecs_to_cputime(p->se.sum_exec_runtime);
+	rtime = nsecs_to_cputime(p->cfs.sum_exec_runtime);
 
 	if (total) {
 		u64 temp = rtime;
@@ -3897,7 +3897,7 @@ static inline void schedule_debug(struct task_struct *prev)
 
 static void put_prev_task(struct rq *rq, struct task_struct *prev)
 {
-	if (prev->se.on_rq)
+	if (prev->cfs.on_rq)
 		update_rq_clock(rq);
 	prev->sched_class->put_prev_task(rq, prev);
 }
@@ -4556,7 +4556,7 @@ void rt_mutex_setprio(struct task_struct *p, int prio)
 	trace_sched_pi_setprio(p, prio);
 	oldprio = p->prio;
 	prev_class = p->sched_class;
-	on_rq = p->se.on_rq;
+	on_rq = p->cfs.on_rq;
 	running = task_current(rq, p);
 	if (on_rq)
 		dequeue_task(rq, p, 0);
@@ -4605,7 +4605,7 @@ void set_user_nice(struct task_struct *p, long nice)
 		p->static_prio = NICE_TO_PRIO(nice);
 		goto out_unlock;
 	}
-	on_rq = p->se.on_rq;
+	on_rq = p->cfs.on_rq;
 	if (on_rq)
 		dequeue_task(rq, p, 0);
 
@@ -4739,7 +4739,7 @@ static struct task_struct *find_process_by_pid(pid_t pid)
 static void
 __setscheduler(struct rq *rq, struct task_struct *p, int policy, int prio)
 {
-	BUG_ON(p->se.on_rq);
+	BUG_ON(p->cfs.on_rq);
 
 	p->policy = policy;
 	p->rt_priority = prio;
@@ -4888,7 +4888,7 @@ recheck:
 		raw_spin_unlock_irqrestore(&p->pi_lock, flags);
 		goto recheck;
 	}
-	on_rq = p->se.on_rq;
+	on_rq = p->cfs.on_rq;
 	running = task_current(rq, p);
 	if (on_rq)
 		deactivate_task(rq, p, 0);
@@ -5539,7 +5539,7 @@ void __cpuinit init_idle(struct task_struct *idle, int cpu)
 
 	__sched_fork(idle);
 	idle->state = TASK_RUNNING;
-	idle->se.exec_start = sched_clock();
+	idle->cfs.exec_start = sched_clock();
 
 	cpumask_copy(&idle->cpus_allowed, cpumask_of(cpu));
 	/*
@@ -5747,7 +5747,7 @@ static int __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
 	 * If we're not on a rq, the next wake-up will ensure we're
 	 * placed properly.
 	 */
-	if (p->se.on_rq) {
+	if (p->cfs.on_rq) {
 		deactivate_task(rq_src, p, 0);
 		set_task_cpu(p, dest_cpu);
 		activate_task(rq_dest, p, 0);
@@ -7839,27 +7839,27 @@ static void init_rt_rq(struct rt_rq *rt_rq, struct rq *rq)
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
 static void init_tg_cfs_entry(struct task_group *tg, struct cfs_rq *cfs_rq,
-				struct sched_entity *se, int cpu,
-				struct sched_entity *parent)
+				struct sched_cfs_entity *cfs_se, int cpu,
+				struct sched_cfs_entity *parent)
 {
 	struct rq *rq = cpu_rq(cpu);
 	tg->cfs_rq[cpu] = cfs_rq;
 	init_cfs_rq(cfs_rq, rq);
 	cfs_rq->tg = tg;
 
-	tg->se[cpu] = se;
-	/* se could be NULL for init_task_group */
-	if (!se)
+	tg->cfs_se[cpu] = cfs_se;
+	/* cfs_se could be NULL for init_task_group */
+	if (!cfs_se)
 		return;
 
 	if (!parent)
-		se->cfs_rq = &rq->cfs;
+		cfs_se->cfs_rq = &rq->cfs;
 	else
-		se->cfs_rq = parent->my_q;
+		cfs_se->cfs_rq = parent->my_q;
 
-	se->my_q = cfs_rq;
-	update_load_set(&se->load, 0);
-	se->parent = parent;
+	cfs_se->my_q = cfs_rq;
+	update_load_set(&cfs_se->load, 0);
+	cfs_se->parent = parent;
 }
 #endif
 
@@ -7908,7 +7908,7 @@ void __init sched_init(void)
 		ptr = (unsigned long)kzalloc(alloc_size, GFP_NOWAIT);
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
-		init_task_group.se = (struct sched_entity **)ptr;
+		init_task_group.cfs_se = (struct sched_cfs_entity **)ptr;
 		ptr += nr_cpu_ids * sizeof(void **);
 
 		init_task_group.cfs_rq = (struct cfs_rq **)ptr;
@@ -7980,7 +7980,7 @@ void __init sched_init(void)
 		 *	A0's bandwidth = 1024 / (10*1024 + 1024 + 1024) = 8.33%
 		 *
 		 * We achieve this by letting init_task_group's tasks sit
-		 * directly in rq->cfs (i.e init_task_group->se[] = NULL).
+		 * directly in rq->cfs (i.e init_task_group->cfs_se[] = NULL).
 		 */
 		init_tg_cfs_entry(&init_task_group, &rq->cfs, NULL, i, NULL);
 #endif
@@ -8116,7 +8116,7 @@ static void normalize_task(struct rq *rq, struct task_struct *p)
 {
 	int on_rq;
 
-	on_rq = p->se.on_rq;
+	on_rq = p->cfs.on_rq;
 	if (on_rq)
 		deactivate_task(rq, p, 0);
 	__setscheduler(rq, p, SCHED_NORMAL, 0);
@@ -8140,11 +8140,11 @@ void normalize_rt_tasks(void)
 		if (!p->mm)
 			continue;
 
-		p->se.exec_start		= 0;
+		p->cfs.exec_start		= 0;
 #ifdef CONFIG_SCHEDSTATS
-		p->se.statistics.wait_start	= 0;
-		p->se.statistics.sleep_start	= 0;
-		p->se.statistics.block_start	= 0;
+		p->cfs.statistics.wait_start	= 0;
+		p->cfs.statistics.sleep_start	= 0;
+		p->cfs.statistics.block_start	= 0;
 #endif
 
 		if (!rt_task(p)) {
@@ -8226,27 +8226,27 @@ static void free_fair_sched_group(struct task_group *tg)
 	for_each_possible_cpu(i) {
 		if (tg->cfs_rq)
 			kfree(tg->cfs_rq[i]);
-		if (tg->se)
-			kfree(tg->se[i]);
+		if (tg->cfs_se)
+			kfree(tg->cfs_se[i]);
 	}
 
 	kfree(tg->cfs_rq);
-	kfree(tg->se);
+	kfree(tg->cfs_se);
 }
 
 static
 int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
 {
 	struct cfs_rq *cfs_rq;
-	struct sched_entity *se;
+	struct sched_cfs_entity *cfs_se;
 	struct rq *rq;
 	int i;
 
 	tg->cfs_rq = kzalloc(sizeof(cfs_rq) * nr_cpu_ids, GFP_KERNEL);
 	if (!tg->cfs_rq)
 		goto err;
-	tg->se = kzalloc(sizeof(se) * nr_cpu_ids, GFP_KERNEL);
-	if (!tg->se)
+	tg->cfs_se = kzalloc(sizeof(cfs_se) * nr_cpu_ids, GFP_KERNEL);
+	if (!tg->cfs_se)
 		goto err;
 
 	tg->shares = NICE_0_LOAD;
@@ -8259,12 +8259,12 @@ int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)
 		if (!cfs_rq)
 			goto err;
 
-		se = kzalloc_node(sizeof(struct sched_entity),
-				  GFP_KERNEL, cpu_to_node(i));
-		if (!se)
+		cfs_se = kzalloc_node(sizeof(struct sched_cfs_entity),
+				      GFP_KERNEL, cpu_to_node(i));
+		if (!cfs_se)
 			goto err_free_rq;
 
-		init_tg_cfs_entry(tg, cfs_rq, se, i, parent->se[i]);
+		init_tg_cfs_entry(tg, cfs_rq, cfs_se, i, parent->cfs_se[i]);
 	}
 
 	return 1;
@@ -8447,7 +8447,7 @@ void sched_destroy_group(struct task_group *tg)
 
 /* change task's runqueue when it moves between groups.
  *	The caller of this function should have put the task in its new group
- *	by now. This function just updates tsk->se.cfs_rq and tsk->se.parent to
+ *	by now. This function just updates tsk->cfs.cfs_rq and tsk->cfs.parent to
  *	reflect its new group.
  */
 void sched_move_task(struct task_struct *tsk)
@@ -8459,7 +8459,7 @@ void sched_move_task(struct task_struct *tsk)
 	rq = task_rq_lock(tsk, &flags);
 
 	running = task_current(rq, tsk);
-	on_rq = tsk->se.on_rq;
+	on_rq = tsk->cfs.on_rq;
 
 	if (on_rq)
 		dequeue_task(rq, tsk, 0);
@@ -8493,7 +8493,7 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares)
 	/*
 	 * We can't change the weight of the root cgroup.
 	 */
-	if (!tg->se[0])
+	if (!tg->cfs_se[0])
 		return -EINVAL;
 
 	if (shares < MIN_SHARES)
@@ -8508,13 +8508,13 @@ int sched_group_set_shares(struct task_group *tg, unsigned long shares)
 	tg->shares = shares;
 	for_each_possible_cpu(i) {
 		struct rq *rq = cpu_rq(i);
-		struct sched_entity *se;
+		struct sched_cfs_entity *cfs_se;
 
-		se = tg->se[i];
+		cfs_se = tg->cfs_se[i];
 		/* Propagate contribution to hierarchy */
 		raw_spin_lock_irqsave(&rq->lock, flags);
-		for_each_sched_entity(se)
-			update_cfs_shares(group_cfs_rq(se), 0);
+		for_each_sched_entity(cfs_se)
+			update_cfs_shares(group_cfs_rq(cfs_se), 0);
 		raw_spin_unlock_irqrestore(&rq->lock, flags);
 	}
 
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index 1dfae3d..16d0b10 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -56,8 +56,9 @@ static unsigned long nsec_low(unsigned long long nsec)
 #ifdef CONFIG_FAIR_GROUP_SCHED
 static void print_cfs_group_stats(struct seq_file *m, int cpu, struct task_group *tg)
 {
-	struct sched_entity *se = tg->se[cpu];
-	if (!se)
+	struct sched_cfs_entity *cfs_se = tg->cfs_se[cpu];
+
+	if (!cfs_se)
 		return;
 
 #define P(F) \
@@ -65,22 +66,22 @@ static void print_cfs_group_stats(struct seq_file *m, int cpu, struct task_group
 #define PN(F) \
 	SEQ_printf(m, "  .%-30s: %lld.%06ld\n", #F, SPLIT_NS((long long)F))
 
-	PN(se->exec_start);
-	PN(se->vruntime);
-	PN(se->sum_exec_runtime);
+	PN(cfs_se->exec_start);
+	PN(cfs_se->vruntime);
+	PN(cfs_se->sum_exec_runtime);
 #ifdef CONFIG_SCHEDSTATS
-	PN(se->statistics.wait_start);
-	PN(se->statistics.sleep_start);
-	PN(se->statistics.block_start);
-	PN(se->statistics.sleep_max);
-	PN(se->statistics.block_max);
-	PN(se->statistics.exec_max);
-	PN(se->statistics.slice_max);
-	PN(se->statistics.wait_max);
-	PN(se->statistics.wait_sum);
-	P(se->statistics.wait_count);
+	PN(cfs_se->statistics.wait_start);
+	PN(cfs_se->statistics.sleep_start);
+	PN(cfs_se->statistics.block_start);
+	PN(cfs_se->statistics.sleep_max);
+	PN(cfs_se->statistics.block_max);
+	PN(cfs_se->statistics.exec_max);
+	PN(cfs_se->statistics.slice_max);
+	PN(cfs_se->statistics.wait_max);
+	PN(cfs_se->statistics.wait_sum);
+	P(cfs_se->statistics.wait_count);
 #endif
-	P(se->load.weight);
+	P(cfs_se->load.weight);
 #undef PN
 #undef P
 }
@@ -96,14 +97,14 @@ print_task(struct seq_file *m, struct rq *rq, struct task_struct *p)
 
 	SEQ_printf(m, "%15s %5d %9Ld.%06ld %9Ld %5d ",
 		p->comm, p->pid,
-		SPLIT_NS(p->se.vruntime),
+		SPLIT_NS(p->cfs.vruntime),
 		(long long)(p->nvcsw + p->nivcsw),
 		p->prio);
 #ifdef CONFIG_SCHEDSTATS
 	SEQ_printf(m, "%9Ld.%06ld %9Ld.%06ld %9Ld.%06ld",
-		SPLIT_NS(p->se.vruntime),
-		SPLIT_NS(p->se.sum_exec_runtime),
-		SPLIT_NS(p->se.statistics.sum_sleep_runtime));
+		SPLIT_NS(p->cfs.vruntime),
+		SPLIT_NS(p->cfs.sum_exec_runtime),
+		SPLIT_NS(p->cfs.statistics.sum_sleep_runtime));
 #else
 	SEQ_printf(m, "%15Ld %15Ld %15Ld.%06ld %15Ld.%06ld %15Ld.%06ld",
 		0LL, 0LL, 0LL, 0L, 0LL, 0L, 0LL, 0L);
@@ -127,7 +128,7 @@ static void print_rq(struct seq_file *m, struct rq *rq, int rq_cpu)
 	read_lock_irqsave(&tasklist_lock, flags);
 
 	do_each_thread(g, p) {
-		if (!p->se.on_rq || task_cpu(p) != rq_cpu)
+		if (!p->cfs.on_rq || task_cpu(p) != rq_cpu)
 			continue;
 
 		print_task(m, rq, p);
@@ -141,7 +142,7 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 	s64 MIN_vruntime = -1, min_vruntime, max_vruntime = -1,
 		spread, rq0_min_vruntime, spread0;
 	struct rq *rq = cpu_rq(cpu);
-	struct sched_entity *last;
+	struct sched_cfs_entity *last;
 	unsigned long flags;
 
 	SEQ_printf(m, "\ncfs_rq[%d]:\n", cpu);
@@ -382,55 +383,55 @@ void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
 #define PN(F) \
 	SEQ_printf(m, "%-35s:%14Ld.%06ld\n", #F, SPLIT_NS((long long)p->F))
 
-	PN(se.exec_start);
-	PN(se.vruntime);
-	PN(se.sum_exec_runtime);
+	PN(cfs.exec_start);
+	PN(cfs.vruntime);
+	PN(cfs.sum_exec_runtime);
 
 	nr_switches = p->nvcsw + p->nivcsw;
 
 #ifdef CONFIG_SCHEDSTATS
-	PN(se.statistics.wait_start);
-	PN(se.statistics.sleep_start);
-	PN(se.statistics.block_start);
-	PN(se.statistics.sleep_max);
-	PN(se.statistics.block_max);
-	PN(se.statistics.exec_max);
-	PN(se.statistics.slice_max);
-	PN(se.statistics.wait_max);
-	PN(se.statistics.wait_sum);
-	P(se.statistics.wait_count);
-	PN(se.statistics.iowait_sum);
-	P(se.statistics.iowait_count);
+	PN(cfs.statistics.wait_start);
+	PN(cfs.statistics.sleep_start);
+	PN(cfs.statistics.block_start);
+	PN(cfs.statistics.sleep_max);
+	PN(cfs.statistics.block_max);
+	PN(cfs.statistics.exec_max);
+	PN(cfs.statistics.slice_max);
+	PN(cfs.statistics.wait_max);
+	PN(cfs.statistics.wait_sum);
+	P(cfs.statistics.wait_count);
+	PN(cfs.statistics.iowait_sum);
+	P(cfs.statistics.iowait_count);
 	P(sched_info.bkl_count);
-	P(se.nr_migrations);
-	P(se.statistics.nr_migrations_cold);
-	P(se.statistics.nr_failed_migrations_affine);
-	P(se.statistics.nr_failed_migrations_running);
-	P(se.statistics.nr_failed_migrations_hot);
-	P(se.statistics.nr_forced_migrations);
-	P(se.statistics.nr_wakeups);
-	P(se.statistics.nr_wakeups_sync);
-	P(se.statistics.nr_wakeups_migrate);
-	P(se.statistics.nr_wakeups_local);
-	P(se.statistics.nr_wakeups_remote);
-	P(se.statistics.nr_wakeups_affine);
-	P(se.statistics.nr_wakeups_affine_attempts);
-	P(se.statistics.nr_wakeups_passive);
-	P(se.statistics.nr_wakeups_idle);
+	P(cfs.nr_migrations);
+	P(cfs.statistics.nr_migrations_cold);
+	P(cfs.statistics.nr_failed_migrations_affine);
+	P(cfs.statistics.nr_failed_migrations_running);
+	P(cfs.statistics.nr_failed_migrations_hot);
+	P(cfs.statistics.nr_forced_migrations);
+	P(cfs.statistics.nr_wakeups);
+	P(cfs.statistics.nr_wakeups_sync);
+	P(cfs.statistics.nr_wakeups_migrate);
+	P(cfs.statistics.nr_wakeups_local);
+	P(cfs.statistics.nr_wakeups_remote);
+	P(cfs.statistics.nr_wakeups_affine);
+	P(cfs.statistics.nr_wakeups_affine_attempts);
+	P(cfs.statistics.nr_wakeups_passive);
+	P(cfs.statistics.nr_wakeups_idle);
 
 	{
 		u64 avg_atom, avg_per_cpu;
 
-		avg_atom = p->se.sum_exec_runtime;
+		avg_atom = p->cfs.sum_exec_runtime;
 		if (nr_switches)
 			do_div(avg_atom, nr_switches);
 		else
 			avg_atom = -1LL;
 
-		avg_per_cpu = p->se.sum_exec_runtime;
-		if (p->se.nr_migrations) {
+		avg_per_cpu = p->cfs.sum_exec_runtime;
+		if (p->cfs.nr_migrations) {
 			avg_per_cpu = div64_u64(avg_per_cpu,
-						p->se.nr_migrations);
+						p->cfs.nr_migrations);
 		} else {
 			avg_per_cpu = -1LL;
 		}
@@ -445,7 +446,7 @@ void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
 	SEQ_printf(m, "%-35s:%21Ld\n",
 		   "nr_involuntary_switches", (long long)p->nivcsw);
 
-	P(se.load.weight);
+	P(cfs.load.weight);
 	P(policy);
 	P(prio);
 #undef PN
@@ -467,6 +468,6 @@ void proc_sched_show_task(struct task_struct *p, struct seq_file *m)
 void proc_sched_set_task(struct task_struct *p)
 {
 #ifdef CONFIG_SCHEDSTATS
-	memset(&p->se.statistics, 0, sizeof(p->se.statistics));
+	memset(&p->cfs.statistics, 0, sizeof(p->cfs.statistics));
 #endif
 }
diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
index c62ebae..1ae7a17 100644
--- a/kernel/sched_fair.c
+++ b/kernel/sched_fair.c
@@ -111,33 +111,33 @@ static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
 }
 
 /* An entity is a task if it doesn't "own" a runqueue */
-#define entity_is_task(se)	(!se->my_q)
+#define cfs_entity_is_task(cfs_se)	(!cfs_se->my_q)
 
-static inline struct task_struct *task_of(struct sched_entity *se)
+static inline struct task_struct *cfs_task_of(struct sched_cfs_entity *cfs_se)
 {
 #ifdef CONFIG_SCHED_DEBUG
-	WARN_ON_ONCE(!entity_is_task(se));
+	WARN_ON_ONCE(!cfs_entity_is_task(cfs_se));
 #endif
-	return container_of(se, struct task_struct, se);
+	return container_of(cfs_se, struct task_struct, cfs);
 }
 
 /* Walk up scheduling entities hierarchy */
-#define for_each_sched_entity(se) \
-		for (; se; se = se->parent)
+#define for_each_sched_cfs_entity(cfs_se) \
+		for (; cfs_se; cfs_se = cfs_se->parent)
 
 static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
 {
-	return p->se.cfs_rq;
+	return p->cfs.cfs_rq;
 }
 
 /* runqueue on which this entity is (to be) queued */
-static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
+static inline struct cfs_rq *cfs_rq_of(struct sched_cfs_entity *cfs_se)
 {
-	return se->cfs_rq;
+	return cfs_se->cfs_rq;
 }
 
 /* runqueue "owned" by this group */
-static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
+static inline struct cfs_rq *group_cfs_rq(struct sched_cfs_entity *grp)
 {
 	return grp->my_q;
 }
@@ -186,32 +186,35 @@ static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
 
 /* Do the two (enqueued) entities belong to the same group ? */
 static inline int
-is_same_group(struct sched_entity *se, struct sched_entity *pse)
+is_same_group(struct sched_cfs_entity *cfs_se,
+	      struct sched_cfs_entity *cfs_pse)
 {
-	if (se->cfs_rq == pse->cfs_rq)
+	if (cfs_se->cfs_rq == cfs_pse->cfs_rq)
 		return 1;
 
 	return 0;
 }
 
-static inline struct sched_entity *parent_entity(struct sched_entity *se)
+static inline
+struct sched_cfs_entity *parent_entity(struct sched_cfs_entity *cfs_se)
 {
-	return se->parent;
+	return cfs_se->parent;
 }
 
 /* return depth at which a sched entity is present in the hierarchy */
-static inline int depth_se(struct sched_entity *se)
+static inline int depth_se(struct sched_cfs_entity *cfs_se)
 {
 	int depth = 0;
 
-	for_each_sched_entity(se)
+	for_each_sched_cfs_entity(cfs_se)
 		depth++;
 
 	return depth;
 }
 
 static void
-find_matching_se(struct sched_entity **se, struct sched_entity **pse)
+find_matching_se(struct sched_cfs_entity **cfs_se,
+		 struct sched_cfs_entity **cfs_pse)
 {
 	int se_depth, pse_depth;
 
@@ -223,30 +226,30 @@ find_matching_se(struct sched_entity **se, struct sched_entity **pse)
 	 */
 
 	/* First walk up until both entities are at same depth */
-	se_depth = depth_se(*se);
-	pse_depth = depth_se(*pse);
+	se_depth = depth_se(*cfs_se);
+	pse_depth = depth_se(*cfs_pse);
 
 	while (se_depth > pse_depth) {
 		se_depth--;
-		*se = parent_entity(*se);
+		*cfs_se = parent_entity(*cfs_se);
 	}
 
 	while (pse_depth > se_depth) {
 		pse_depth--;
-		*pse = parent_entity(*pse);
+		*cfs_pse = parent_entity(*cfs_pse);
 	}
 
-	while (!is_same_group(*se, *pse)) {
-		*se = parent_entity(*se);
-		*pse = parent_entity(*pse);
+	while (!is_same_group(*cfs_se, *cfs_pse)) {
+		*cfs_se = parent_entity(*cfs_se);
+		*cfs_pse = parent_entity(*cfs_pse);
 	}
 }
 
 #else	/* !CONFIG_FAIR_GROUP_SCHED */
 
-static inline struct task_struct *task_of(struct sched_entity *se)
+static inline struct task_struct *cfs_task_of(struct sched_cfs_entity *cfs_se)
 {
-	return container_of(se, struct task_struct, se);
+	return container_of(cfs_se, struct task_struct, cfs);
 }
 
 static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
@@ -254,26 +257,26 @@ static inline struct rq *rq_of(struct cfs_rq *cfs_rq)
 	return container_of(cfs_rq, struct rq, cfs);
 }
 
-#define entity_is_task(se)	1
+#define cfs_entity_is_task(cfs_se)	1
 
-#define for_each_sched_entity(se) \
-		for (; se; se = NULL)
+#define for_each_sched_cfs_entity(cfs_se) \
+		for (; cfs_se; cfs_se = NULL)
 
 static inline struct cfs_rq *task_cfs_rq(struct task_struct *p)
 {
 	return &task_rq(p)->cfs;
 }
 
-static inline struct cfs_rq *cfs_rq_of(struct sched_entity *se)
+static inline struct cfs_rq *cfs_rq_of(struct sched_cfs_entity *cfs_se)
 {
-	struct task_struct *p = task_of(se);
+	struct task_struct *p = cfs_task_of(cfs_se);
 	struct rq *rq = task_rq(p);
 
 	return &rq->cfs;
 }
 
 /* runqueue "owned" by this group */
-static inline struct cfs_rq *group_cfs_rq(struct sched_entity *grp)
+static inline struct cfs_rq *group_cfs_rq(struct sched_cfs_entity *grp)
 {
 	return NULL;
 }
@@ -294,19 +297,20 @@ static inline void list_del_leaf_cfs_rq(struct cfs_rq *cfs_rq)
 #define for_each_leaf_cfs_rq(rq, cfs_rq) \
 		for (cfs_rq = &rq->cfs; cfs_rq; cfs_rq = NULL)
 
-static inline int
-is_same_group(struct sched_entity *se, struct sched_entity *pse)
+static inline int is_same_group(struct sched_cfs_entity *cfs_se,
+				struct sched_cfs_entity *cfs_pse)
 {
 	return 1;
 }
 
-static inline struct sched_entity *parent_entity(struct sched_entity *se)
+static inline
+struct sched_cfs_entity *parent_entity(struct sched_cfs_entity *cfs_se)
 {
 	return NULL;
 }
 
-static inline void
-find_matching_se(struct sched_entity **se, struct sched_entity **pse)
+static inline void find_matching_se(struct sched_cfs_entity **cfs_se,
+				    struct sched_cfs_entity **cfs_pse)
 {
 }
 
@@ -335,15 +339,16 @@ static inline u64 min_vruntime(u64 min_vruntime, u64 vruntime)
 	return min_vruntime;
 }
 
-static inline int entity_before(struct sched_entity *a,
-				struct sched_entity *b)
+static inline int entity_before(struct sched_cfs_entity *a,
+				struct sched_cfs_entity *b)
 {
 	return (s64)(a->vruntime - b->vruntime) < 0;
 }
 
-static inline s64 entity_key(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static inline s64
+entity_key(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
-	return se->vruntime - cfs_rq->min_vruntime;
+	return cfs_se->vruntime - cfs_rq->min_vruntime;
 }
 
 static void update_min_vruntime(struct cfs_rq *cfs_rq)
@@ -354,14 +359,14 @@ static void update_min_vruntime(struct cfs_rq *cfs_rq)
 		vruntime = cfs_rq->curr->vruntime;
 
 	if (cfs_rq->rb_leftmost) {
-		struct sched_entity *se = rb_entry(cfs_rq->rb_leftmost,
-						   struct sched_entity,
-						   run_node);
+		struct sched_cfs_entity *cfs_se = rb_entry(cfs_rq->rb_leftmost,
+							struct sched_cfs_entity,
+							run_node);
 
 		if (!cfs_rq->curr)
-			vruntime = se->vruntime;
+			vruntime = cfs_se->vruntime;
 		else
-			vruntime = min_vruntime(vruntime, se->vruntime);
+			vruntime = min_vruntime(vruntime, cfs_se->vruntime);
 	}
 
 	cfs_rq->min_vruntime = max_vruntime(cfs_rq->min_vruntime, vruntime);
@@ -370,12 +375,13 @@ static void update_min_vruntime(struct cfs_rq *cfs_rq)
 /*
  * Enqueue an entity into the rb-tree:
  */
-static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static void
+__enqueue_entity(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
 	struct rb_node **link = &cfs_rq->tasks_timeline.rb_node;
 	struct rb_node *parent = NULL;
-	struct sched_entity *entry;
-	s64 key = entity_key(cfs_rq, se);
+	struct sched_cfs_entity *entry;
+	s64 key = entity_key(cfs_rq, cfs_se);
 	int leftmost = 1;
 
 	/*
@@ -383,7 +389,7 @@ static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
 	 */
 	while (*link) {
 		parent = *link;
-		entry = rb_entry(parent, struct sched_entity, run_node);
+		entry = rb_entry(parent, struct sched_cfs_entity, run_node);
 		/*
 		 * We dont care about collisions. Nodes with
 		 * the same key stay together.
@@ -401,42 +407,43 @@ static void __enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
 	 * used):
 	 */
 	if (leftmost)
-		cfs_rq->rb_leftmost = &se->run_node;
+		cfs_rq->rb_leftmost = &cfs_se->run_node;
 
-	rb_link_node(&se->run_node, parent, link);
-	rb_insert_color(&se->run_node, &cfs_rq->tasks_timeline);
+	rb_link_node(&cfs_se->run_node, parent, link);
+	rb_insert_color(&cfs_se->run_node, &cfs_rq->tasks_timeline);
 }
 
-static void __dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static void
+__dequeue_entity(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
-	if (cfs_rq->rb_leftmost == &se->run_node) {
+	if (cfs_rq->rb_leftmost == &cfs_se->run_node) {
 		struct rb_node *next_node;
 
-		next_node = rb_next(&se->run_node);
+		next_node = rb_next(&cfs_se->run_node);
 		cfs_rq->rb_leftmost = next_node;
 	}
 
-	rb_erase(&se->run_node, &cfs_rq->tasks_timeline);
+	rb_erase(&cfs_se->run_node, &cfs_rq->tasks_timeline);
 }
 
-static struct sched_entity *__pick_next_entity(struct cfs_rq *cfs_rq)
+static struct sched_cfs_entity *__pick_next_entity(struct cfs_rq *cfs_rq)
 {
 	struct rb_node *left = cfs_rq->rb_leftmost;
 
 	if (!left)
 		return NULL;
 
-	return rb_entry(left, struct sched_entity, run_node);
+	return rb_entry(left, struct sched_cfs_entity, run_node);
 }
 
-static struct sched_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
+static struct sched_cfs_entity *__pick_last_entity(struct cfs_rq *cfs_rq)
 {
 	struct rb_node *last = rb_last(&cfs_rq->tasks_timeline);
 
 	if (!last)
 		return NULL;
 
-	return rb_entry(last, struct sched_entity, run_node);
+	return rb_entry(last, struct sched_cfs_entity, run_node);
 }
 
 /**************************************************************
@@ -472,10 +479,10 @@ int sched_proc_update_handler(struct ctl_table *table, int write,
  * delta /= w
  */
 static inline unsigned long
-calc_delta_fair(unsigned long delta, struct sched_entity *se)
+calc_delta_fair(unsigned long delta, struct sched_cfs_entity *cfs_se)
 {
-	if (unlikely(se->load.weight != NICE_0_LOAD))
-		delta = calc_delta_mine(delta, NICE_0_LOAD, &se->load);
+	if (unlikely(cfs_se->load.weight != NICE_0_LOAD))
+		delta = calc_delta_mine(delta, NICE_0_LOAD, &cfs_se->load);
 
 	return delta;
 }
@@ -507,24 +514,24 @@ static u64 __sched_period(unsigned long nr_running)
  *
  * s = p*P[w/rw]
  */
-static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
-	u64 slice = __sched_period(cfs_rq->nr_running + !se->on_rq);
+	u64 slice = __sched_period(cfs_rq->nr_running + !cfs_se->on_rq);
 
-	for_each_sched_entity(se) {
+	for_each_sched_cfs_entity(cfs_se) {
 		struct load_weight *load;
 		struct load_weight lw;
 
-		cfs_rq = cfs_rq_of(se);
+		cfs_rq = cfs_rq_of(cfs_se);
 		load = &cfs_rq->load;
 
-		if (unlikely(!se->on_rq)) {
+		if (unlikely(!cfs_se->on_rq)) {
 			lw = cfs_rq->load;
 
-			update_load_add(&lw, se->load.weight);
+			update_load_add(&lw, cfs_se->load.weight);
 			load = &lw;
 		}
-		slice = calc_delta_mine(slice, se->load.weight, load);
+		slice = calc_delta_mine(slice, cfs_se->load.weight, load);
 	}
 	return slice;
 }
@@ -534,9 +541,10 @@ static u64 sched_slice(struct cfs_rq *cfs_rq, struct sched_entity *se)
  *
  * vs = s/w
  */
-static u64 sched_vslice(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static u64
+sched_vslice(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
-	return calc_delta_fair(sched_slice(cfs_rq, se), se);
+	return calc_delta_fair(sched_slice(cfs_rq, cfs_se), cfs_se);
 }
 
 static void update_cfs_load(struct cfs_rq *cfs_rq, int global_update);
@@ -547,7 +555,7 @@ static void update_cfs_shares(struct cfs_rq *cfs_rq, long weight_delta);
  * are not in our scheduling class.
  */
 static inline void
-__update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr,
+__update_curr(struct cfs_rq *cfs_rq, struct sched_cfs_entity *curr,
 	      unsigned long delta_exec)
 {
 	unsigned long delta_exec_weighted;
@@ -569,7 +577,7 @@ __update_curr(struct cfs_rq *cfs_rq, struct sched_entity *curr,
 
 static void update_curr(struct cfs_rq *cfs_rq)
 {
-	struct sched_entity *curr = cfs_rq->curr;
+	struct sched_cfs_entity *curr = cfs_rq->curr;
 	u64 now = rq_of(cfs_rq)->clock_task;
 	unsigned long delta_exec;
 
@@ -588,8 +596,8 @@ static void update_curr(struct cfs_rq *cfs_rq)
 	__update_curr(cfs_rq, curr, delta_exec);
 	curr->exec_start = now;
 
-	if (entity_is_task(curr)) {
-		struct task_struct *curtask = task_of(curr);
+	if (cfs_entity_is_task(curr)) {
+		struct task_struct *curtask = cfs_task_of(curr);
 
 		trace_sched_stat_runtime(curtask, delta_exec, curr->vruntime);
 		cpuacct_charge(curtask, delta_exec);
@@ -598,62 +606,66 @@ static void update_curr(struct cfs_rq *cfs_rq)
 }
 
 static inline void
-update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
+update_stats_wait_start(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
-	schedstat_set(se->statistics.wait_start, rq_of(cfs_rq)->clock);
+	schedstat_set(cfs_se->statistics.wait_start, rq_of(cfs_rq)->clock);
 }
 
 /*
  * Task is being enqueued - update stats:
  */
-static void update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static void
+update_stats_enqueue(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
 	/*
 	 * Are we enqueueing a waiting task? (for current tasks
 	 * a dequeue/enqueue event is a NOP)
 	 */
-	if (se != cfs_rq->curr)
-		update_stats_wait_start(cfs_rq, se);
+	if (cfs_se != cfs_rq->curr)
+		update_stats_wait_start(cfs_rq, cfs_se);
 }
 
 static void
-update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_entity *se)
-{
-	schedstat_set(se->statistics.wait_max, max(se->statistics.wait_max,
-			rq_of(cfs_rq)->clock - se->statistics.wait_start));
-	schedstat_set(se->statistics.wait_count, se->statistics.wait_count + 1);
-	schedstat_set(se->statistics.wait_sum, se->statistics.wait_sum +
-			rq_of(cfs_rq)->clock - se->statistics.wait_start);
+update_stats_wait_end(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
+{
+	schedstat_set(cfs_se->statistics.wait_max,
+		      max(cfs_se->statistics.wait_max,
+			  rq_of(cfs_rq)->clock-cfs_se->statistics.wait_start));
+	schedstat_set(cfs_se->statistics.wait_count,
+		      cfs_se->statistics.wait_count + 1);
+	schedstat_set(cfs_se->statistics.wait_sum,
+		      cfs_se->statistics.wait_sum + rq_of(cfs_rq)->clock -
+		      cfs_se->statistics.wait_start);
 #ifdef CONFIG_SCHEDSTATS
-	if (entity_is_task(se)) {
-		trace_sched_stat_wait(task_of(se),
-			rq_of(cfs_rq)->clock - se->statistics.wait_start);
+	if (cfs_entity_is_task(cfs_se)) {
+		trace_sched_stat_wait(cfs_task_of(cfs_se),
+			rq_of(cfs_rq)->clock - cfs_se->statistics.wait_start);
 	}
 #endif
-	schedstat_set(se->statistics.wait_start, 0);
+	schedstat_set(cfs_se->statistics.wait_start, 0);
 }
 
 static inline void
-update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
+update_stats_dequeue(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
 	/*
 	 * Mark the end of the wait period if dequeueing a
 	 * waiting task:
 	 */
-	if (se != cfs_rq->curr)
-		update_stats_wait_end(cfs_rq, se);
+	if (cfs_se != cfs_rq->curr)
+		update_stats_wait_end(cfs_rq, cfs_se);
 }
 
 /*
  * We are picking a new current task - update its stats:
  */
 static inline void
-update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_entity *se)
+update_stats_curr_start(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
 	/*
 	 * We are starting a new run period:
 	 */
-	se->exec_start = rq_of(cfs_rq)->clock_task;
+	cfs_se->exec_start = rq_of(cfs_rq)->clock_task;
 }
 
 /**************************************************
@@ -674,27 +686,27 @@ add_cfs_task_weight(struct cfs_rq *cfs_rq, unsigned long weight)
 #endif
 
 static void
-account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_entity *se)
-{
-	update_load_add(&cfs_rq->load, se->load.weight);
-	if (!parent_entity(se))
-		inc_cpu_load(rq_of(cfs_rq), se->load.weight);
-	if (entity_is_task(se)) {
-		add_cfs_task_weight(cfs_rq, se->load.weight);
-		list_add(&se->group_node, &cfs_rq->tasks);
+account_entity_enqueue(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
+{
+	update_load_add(&cfs_rq->load, cfs_se->load.weight);
+	if (!parent_entity(cfs_se))
+		inc_cpu_load(rq_of(cfs_rq), cfs_se->load.weight);
+	if (cfs_entity_is_task(cfs_se)) {
+		add_cfs_task_weight(cfs_rq, cfs_se->load.weight);
+		list_add(&cfs_se->group_node, &cfs_rq->tasks);
 	}
 	cfs_rq->nr_running++;
 }
 
 static void
-account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_entity *se)
-{
-	update_load_sub(&cfs_rq->load, se->load.weight);
-	if (!parent_entity(se))
-		dec_cpu_load(rq_of(cfs_rq), se->load.weight);
-	if (entity_is_task(se)) {
-		add_cfs_task_weight(cfs_rq, -se->load.weight);
-		list_del_init(&se->group_node);
+account_entity_dequeue(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
+{
+	update_load_sub(&cfs_rq->load, cfs_se->load.weight);
+	if (!parent_entity(cfs_se))
+		dec_cpu_load(rq_of(cfs_rq), cfs_se->load.weight);
+	if (cfs_entity_is_task(cfs_se)) {
+		add_cfs_task_weight(cfs_rq, -cfs_se->load.weight);
+		list_del_init(&cfs_se->group_node);
 	}
 	cfs_rq->nr_running--;
 }
@@ -762,34 +774,35 @@ static void update_cfs_load(struct cfs_rq *cfs_rq, int global_update)
 		list_del_leaf_cfs_rq(cfs_rq);
 }
 
-static void reweight_entity(struct cfs_rq *cfs_rq, struct sched_entity *se,
+static void reweight_entity(struct cfs_rq *cfs_rq,
+			    struct sched_cfs_entity *cfs_se,
 			    unsigned long weight)
 {
-	if (se->on_rq) {
+	if (cfs_se->on_rq) {
 		/* commit outstanding execution time */
-		if (cfs_rq->curr == se)
+		if (cfs_rq->curr == cfs_se)
 			update_curr(cfs_rq);
-		account_entity_dequeue(cfs_rq, se);
+		account_entity_dequeue(cfs_rq, cfs_se);
 	}
 
-	update_load_set(&se->load, weight);
+	update_load_set(&cfs_se->load, weight);
 
-	if (se->on_rq)
-		account_entity_enqueue(cfs_rq, se);
+	if (cfs_se->on_rq)
+		account_entity_enqueue(cfs_rq, cfs_se);
 }
 
 static void update_cfs_shares(struct cfs_rq *cfs_rq, long weight_delta)
 {
 	struct task_group *tg;
-	struct sched_entity *se;
+	struct sched_cfs_entity *cfs_se;
 	long load_weight, load, shares;
 
 	if (!cfs_rq)
 		return;
 
 	tg = cfs_rq->tg;
-	se = tg->se[cpu_of(rq_of(cfs_rq))];
-	if (!se)
+	cfs_se = tg->cfs_se[cpu_of(rq_of(cfs_rq))];
+	if (!cfs_se)
 		return;
 
 	load = cfs_rq->load.weight + weight_delta;
@@ -807,7 +820,7 @@ static void update_cfs_shares(struct cfs_rq *cfs_rq, long weight_delta)
 	if (shares > tg->shares)
 		shares = tg->shares;
 
-	reweight_entity(cfs_rq_of(se), se, shares);
+	reweight_entity(cfs_rq_of(cfs_se), cfs_se, shares);
 }
 
 static void update_entity_shares_tick(struct cfs_rq *cfs_rq)
@@ -831,47 +844,48 @@ static inline void update_entity_shares_tick(struct cfs_rq *cfs_rq)
 }
 #endif /* CONFIG_FAIR_GROUP_SCHED */
 
-static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static void
+enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
 #ifdef CONFIG_SCHEDSTATS
 	struct task_struct *tsk = NULL;
 
-	if (entity_is_task(se))
-		tsk = task_of(se);
+	if (cfs_entity_is_task(cfs_se))
+		tsk = cfs_task_of(cfs_se);
 
-	if (se->statistics.sleep_start) {
-		u64 delta = rq_of(cfs_rq)->clock - se->statistics.sleep_start;
+	if (cfs_se->statistics.sleep_start) {
+		u64 delta = rq_of(cfs_rq)->clock - cfs_se->statistics.sleep_start;
 
 		if ((s64)delta < 0)
 			delta = 0;
 
-		if (unlikely(delta > se->statistics.sleep_max))
-			se->statistics.sleep_max = delta;
+		if (unlikely(delta > cfs_se->statistics.sleep_max))
+			cfs_se->statistics.sleep_max = delta;
 
-		se->statistics.sleep_start = 0;
-		se->statistics.sum_sleep_runtime += delta;
+		cfs_se->statistics.sleep_start = 0;
+		cfs_se->statistics.sum_sleep_runtime += delta;
 
 		if (tsk) {
 			account_scheduler_latency(tsk, delta >> 10, 1);
 			trace_sched_stat_sleep(tsk, delta);
 		}
 	}
-	if (se->statistics.block_start) {
-		u64 delta = rq_of(cfs_rq)->clock - se->statistics.block_start;
+	if (cfs_se->statistics.block_start) {
+		u64 delta = rq_of(cfs_rq)->clock - cfs_se->statistics.block_start;
 
 		if ((s64)delta < 0)
 			delta = 0;
 
-		if (unlikely(delta > se->statistics.block_max))
-			se->statistics.block_max = delta;
+		if (unlikely(delta > cfs_se->statistics.block_max))
+			cfs_se->statistics.block_max = delta;
 
-		se->statistics.block_start = 0;
-		se->statistics.sum_sleep_runtime += delta;
+		cfs_se->statistics.block_start = 0;
+		cfs_se->statistics.sum_sleep_runtime += delta;
 
 		if (tsk) {
 			if (tsk->in_iowait) {
-				se->statistics.iowait_sum += delta;
-				se->statistics.iowait_count++;
+				cfs_se->statistics.iowait_sum += delta;
+				cfs_se->statistics.iowait_count++;
 				trace_sched_stat_iowait(tsk, delta);
 			}
 
@@ -891,10 +905,11 @@ static void enqueue_sleeper(struct cfs_rq *cfs_rq, struct sched_entity *se)
 #endif
 }
 
-static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static void
+check_spread(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
 #ifdef CONFIG_SCHED_DEBUG
-	s64 d = se->vruntime - cfs_rq->min_vruntime;
+	s64 d = cfs_se->vruntime - cfs_rq->min_vruntime;
 
 	if (d < 0)
 		d = -d;
@@ -905,7 +920,8 @@ static void check_spread(struct cfs_rq *cfs_rq, struct sched_entity *se)
 }
 
 static void
-place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
+place_entity(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se,
+	     int initial)
 {
 	u64 vruntime = cfs_rq->min_vruntime;
 
@@ -916,7 +932,7 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
 	 * stays open at the end.
 	 */
 	if (initial && sched_feat(START_DEBIT))
-		vruntime += sched_vslice(cfs_rq, se);
+		vruntime += sched_vslice(cfs_rq, cfs_se);
 
 	/* sleeps up to a single latency don't count. */
 	if (!initial) {
@@ -933,88 +949,92 @@ place_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int initial)
 	}
 
 	/* ensure we never gain time by being placed backwards. */
-	vruntime = max_vruntime(se->vruntime, vruntime);
+	vruntime = max_vruntime(cfs_se->vruntime, vruntime);
 
-	se->vruntime = vruntime;
+	cfs_se->vruntime = vruntime;
 }
 
 static void
-enqueue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
+enqueue_entity(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se,
+	       int flags)
 {
 	/*
 	 * Update the normalized vruntime before updating min_vruntime
 	 * through callig update_curr().
 	 */
 	if (!(flags & ENQUEUE_WAKEUP) || (flags & ENQUEUE_WAKING))
-		se->vruntime += cfs_rq->min_vruntime;
+		cfs_se->vruntime += cfs_rq->min_vruntime;
 
 	/*
 	 * Update run-time statistics of the 'current'.
 	 */
 	update_curr(cfs_rq);
 	update_cfs_load(cfs_rq, 0);
-	update_cfs_shares(cfs_rq, se->load.weight);
-	account_entity_enqueue(cfs_rq, se);
+	update_cfs_shares(cfs_rq, cfs_se->load.weight);
+	account_entity_enqueue(cfs_rq, cfs_se);
 
 	if (flags & ENQUEUE_WAKEUP) {
-		place_entity(cfs_rq, se, 0);
-		enqueue_sleeper(cfs_rq, se);
+		place_entity(cfs_rq, cfs_se, 0);
+		enqueue_sleeper(cfs_rq, cfs_se);
 	}
 
-	update_stats_enqueue(cfs_rq, se);
-	check_spread(cfs_rq, se);
-	if (se != cfs_rq->curr)
-		__enqueue_entity(cfs_rq, se);
-	se->on_rq = 1;
+	update_stats_enqueue(cfs_rq, cfs_se);
+	check_spread(cfs_rq, cfs_se);
+	if (cfs_se != cfs_rq->curr)
+		__enqueue_entity(cfs_rq, cfs_se);
+	cfs_se->on_rq = 1;
 
 	if (cfs_rq->nr_running == 1)
 		list_add_leaf_cfs_rq(cfs_rq);
 }
 
-static void __clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static void
+__clear_buddies(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
-	if (!se || cfs_rq->last == se)
+	if (!cfs_se || cfs_rq->last == cfs_se)
 		cfs_rq->last = NULL;
 
-	if (!se || cfs_rq->next == se)
+	if (!cfs_se || cfs_rq->next == cfs_se)
 		cfs_rq->next = NULL;
 }
 
-static void clear_buddies(struct cfs_rq *cfs_rq, struct sched_entity *se)
+static void
+clear_buddies(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
-	for_each_sched_entity(se)
-		__clear_buddies(cfs_rq_of(se), se);
+	for_each_sched_cfs_entity(cfs_se)
+		__clear_buddies(cfs_rq_of(cfs_se), cfs_se);
 }
 
 static void
-dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
+dequeue_entity(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se,
+	       int flags)
 {
 	/*
 	 * Update run-time statistics of the 'current'.
 	 */
 	update_curr(cfs_rq);
 
-	update_stats_dequeue(cfs_rq, se);
+	update_stats_dequeue(cfs_rq, cfs_se);
 	if (flags & DEQUEUE_SLEEP) {
 #ifdef CONFIG_SCHEDSTATS
-		if (entity_is_task(se)) {
-			struct task_struct *tsk = task_of(se);
+		if (cfs_entity_is_task(cfs_se)) {
+			struct task_struct *tsk = cfs_task_of(cfs_se);
 
 			if (tsk->state & TASK_INTERRUPTIBLE)
-				se->statistics.sleep_start = rq_of(cfs_rq)->clock;
+				cfs_se->statistics.sleep_start = rq_of(cfs_rq)->clock;
 			if (tsk->state & TASK_UNINTERRUPTIBLE)
-				se->statistics.block_start = rq_of(cfs_rq)->clock;
+				cfs_se->statistics.block_start = rq_of(cfs_rq)->clock;
 		}
 #endif
 	}
 
-	clear_buddies(cfs_rq, se);
+	clear_buddies(cfs_rq, cfs_se);
 
-	if (se != cfs_rq->curr)
-		__dequeue_entity(cfs_rq, se);
-	se->on_rq = 0;
+	if (cfs_se != cfs_rq->curr)
+		__dequeue_entity(cfs_rq, cfs_se);
+	cfs_se->on_rq = 0;
 	update_cfs_load(cfs_rq, 0);
-	account_entity_dequeue(cfs_rq, se);
+	account_entity_dequeue(cfs_rq, cfs_se);
 	update_min_vruntime(cfs_rq);
 	update_cfs_shares(cfs_rq, 0);
 
@@ -1024,14 +1044,14 @@ dequeue_entity(struct cfs_rq *cfs_rq, struct sched_entity *se, int flags)
 	 * movement in our normalized position.
 	 */
 	if (!(flags & DEQUEUE_SLEEP))
-		se->vruntime -= cfs_rq->min_vruntime;
+		cfs_se->vruntime -= cfs_rq->min_vruntime;
 }
 
 /*
  * Preempt the current task with a newly woken task if needed:
  */
 static void
-check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
+check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_cfs_entity *curr)
 {
 	unsigned long ideal_runtime, delta_exec;
 
@@ -1059,8 +1079,8 @@ check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
 		return;
 
 	if (cfs_rq->nr_running > 1) {
-		struct sched_entity *se = __pick_next_entity(cfs_rq);
-		s64 delta = curr->vruntime - se->vruntime;
+		struct sched_cfs_entity *cfs_se = __pick_next_entity(cfs_rq);
+		s64 delta = curr->vruntime - cfs_se->vruntime;
 
 		if (delta > ideal_runtime)
 			resched_task(rq_of(cfs_rq)->curr);
@@ -1068,58 +1088,59 @@ check_preempt_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr)
 }
 
 static void
-set_next_entity(struct cfs_rq *cfs_rq, struct sched_entity *se)
+set_next_entity(struct cfs_rq *cfs_rq, struct sched_cfs_entity *cfs_se)
 {
 	/* 'current' is not kept within the tree. */
-	if (se->on_rq) {
+	if (cfs_se->on_rq) {
 		/*
 		 * Any task has to be enqueued before it get to execute on
 		 * a CPU. So account for the time it spent waiting on the
 		 * runqueue.
 		 */
-		update_stats_wait_end(cfs_rq, se);
-		__dequeue_entity(cfs_rq, se);
+		update_stats_wait_end(cfs_rq, cfs_se);
+		__dequeue_entity(cfs_rq, cfs_se);
 	}
 
-	update_stats_curr_start(cfs_rq, se);
-	cfs_rq->curr = se;
+	update_stats_curr_start(cfs_rq, cfs_se);
+	cfs_rq->curr = cfs_se;
 #ifdef CONFIG_SCHEDSTATS
 	/*
 	 * Track our maximum slice length, if the CPU's load is at
 	 * least twice that of our own weight (i.e. dont track it
 	 * when there are only lesser-weight tasks around):
 	 */
-	if (rq_of(cfs_rq)->load.weight >= 2*se->load.weight) {
-		se->statistics.slice_max = max(se->statistics.slice_max,
-			se->sum_exec_runtime - se->prev_sum_exec_runtime);
+	if (rq_of(cfs_rq)->load.weight >= 2*cfs_se->load.weight) {
+		cfs_se->statistics.slice_max = max(cfs_se->statistics.slice_max,
+			cfs_se->sum_exec_runtime - cfs_se->prev_sum_exec_runtime);
 	}
 #endif
-	se->prev_sum_exec_runtime = se->sum_exec_runtime;
+	cfs_se->prev_sum_exec_runtime = cfs_se->sum_exec_runtime;
 }
 
-static int
-wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se);
+static int wakeup_preempt_entity(struct sched_cfs_entity *curr,
+				 struct sched_cfs_entity *cfs_se);
 
-static struct sched_entity *pick_next_entity(struct cfs_rq *cfs_rq)
+static struct sched_cfs_entity *pick_next_entity(struct cfs_rq *cfs_rq)
 {
-	struct sched_entity *se = __pick_next_entity(cfs_rq);
-	struct sched_entity *left = se;
+	struct sched_cfs_entity *cfs_se = __pick_next_entity(cfs_rq);
+	struct sched_cfs_entity *left = cfs_se;
 
 	if (cfs_rq->next && wakeup_preempt_entity(cfs_rq->next, left) < 1)
-		se = cfs_rq->next;
+		cfs_se = cfs_rq->next;
 
 	/*
 	 * Prefer last buddy, try to return the CPU to a preempted task.
 	 */
 	if (cfs_rq->last && wakeup_preempt_entity(cfs_rq->last, left) < 1)
-		se = cfs_rq->last;
+		cfs_se = cfs_rq->last;
 
-	clear_buddies(cfs_rq, se);
+	clear_buddies(cfs_rq, cfs_se);
 
-	return se;
+	return cfs_se;
 }
 
-static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev)
+static void
+put_prev_entity(struct cfs_rq *cfs_rq, struct sched_cfs_entity *prev)
 {
 	/*
 	 * If still on the runqueue then deactivate_task()
@@ -1138,7 +1159,7 @@ static void put_prev_entity(struct cfs_rq *cfs_rq, struct sched_entity *prev)
 }
 
 static void
-entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued)
+entity_tick(struct cfs_rq *cfs_rq, struct sched_cfs_entity *curr, int queued)
 {
 	/*
 	 * Update run-time statistics of the 'current'.
@@ -1178,14 +1199,15 @@ entity_tick(struct cfs_rq *cfs_rq, struct sched_entity *curr, int queued)
 #ifdef CONFIG_SCHED_HRTICK
 static void hrtick_start_fair(struct rq *rq, struct task_struct *p)
 {
-	struct sched_entity *se = &p->se;
-	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+	struct sched_cfs_entity *cfs_se = &p->cfs;
+	struct cfs_rq *cfs_rq = cfs_rq_of(cfs_se);
 
 	WARN_ON(task_rq(p) != rq);
 
 	if (hrtick_enabled(rq) && cfs_rq->nr_running > 1) {
-		u64 slice = sched_slice(cfs_rq, se);
-		u64 ran = se->sum_exec_runtime - se->prev_sum_exec_runtime;
+		u64 slice = sched_slice(cfs_rq, cfs_se);
+		u64 ran = cfs_se->sum_exec_runtime -
+				cfs_se->prev_sum_exec_runtime;
 		s64 delta = slice - ran;
 
 		if (delta < 0) {
@@ -1217,7 +1239,7 @@ static void hrtick_update(struct rq *rq)
 	if (curr->sched_class != &fair_sched_class)
 		return;
 
-	if (cfs_rq_of(&curr->se)->nr_running < sched_nr_latency)
+	if (cfs_rq_of(&curr->cfs)->nr_running < sched_nr_latency)
 		hrtick_start_fair(rq, curr);
 }
 #else /* !CONFIG_SCHED_HRTICK */
@@ -1240,18 +1262,18 @@ static void
 enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
 {
 	struct cfs_rq *cfs_rq;
-	struct sched_entity *se = &p->se;
+	struct sched_cfs_entity *cfs_se = &p->cfs;
 
-	for_each_sched_entity(se) {
-		if (se->on_rq)
+	for_each_sched_cfs_entity(cfs_se) {
+		if (cfs_se->on_rq)
 			break;
-		cfs_rq = cfs_rq_of(se);
-		enqueue_entity(cfs_rq, se, flags);
+		cfs_rq = cfs_rq_of(cfs_se);
+		enqueue_entity(cfs_rq, cfs_se, flags);
 		flags = ENQUEUE_WAKEUP;
 	}
 
-	for_each_sched_entity(se) {
-		struct cfs_rq *cfs_rq = cfs_rq_of(se);
+	for_each_sched_cfs_entity(cfs_se) {
+		struct cfs_rq *cfs_rq = cfs_rq_of(cfs_se);
 
 		update_cfs_load(cfs_rq, 0);
 		update_cfs_shares(cfs_rq, 0);
@@ -1268,11 +1290,11 @@ enqueue_task_fair(struct rq *rq, struct task_struct *p, int flags)
 static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags)
 {
 	struct cfs_rq *cfs_rq;
-	struct sched_entity *se = &p->se;
+	struct sched_cfs_entity *cfs_se = &p->cfs;
 
-	for_each_sched_entity(se) {
-		cfs_rq = cfs_rq_of(se);
-		dequeue_entity(cfs_rq, se, flags);
+	for_each_sched_cfs_entity(cfs_se) {
+		cfs_rq = cfs_rq_of(cfs_se);
+		dequeue_entity(cfs_rq, cfs_se, flags);
 
 		/* Don't dequeue parent if it has other entities besides us */
 		if (cfs_rq->load.weight)
@@ -1280,8 +1302,8 @@ static void dequeue_task_fair(struct rq *rq, struct task_struct *p, int flags)
 		flags |= DEQUEUE_SLEEP;
 	}
 
-	for_each_sched_entity(se) {
-		struct cfs_rq *cfs_rq = cfs_rq_of(se);
+	for_each_sched_cfs_entity(cfs_se) {
+		struct cfs_rq *cfs_rq = cfs_rq_of(cfs_se);
 
 		update_cfs_load(cfs_rq, 0);
 		update_cfs_shares(cfs_rq, 0);
@@ -1299,7 +1321,7 @@ static void yield_task_fair(struct rq *rq)
 {
 	struct task_struct *curr = rq->curr;
 	struct cfs_rq *cfs_rq = task_cfs_rq(curr);
-	struct sched_entity *rightmost, *se = &curr->se;
+	struct sched_cfs_entity *rightmost, *cfs_se = &curr->cfs;
 
 	/*
 	 * Are we the only task in the tree?
@@ -1307,7 +1329,7 @@ static void yield_task_fair(struct rq *rq)
 	if (unlikely(cfs_rq->nr_running == 1))
 		return;
 
-	clear_buddies(cfs_rq, se);
+	clear_buddies(cfs_rq, cfs_se);
 
 	if (likely(!sysctl_sched_compat_yield) && curr->policy != SCHED_BATCH) {
 		update_rq_clock(rq);
@@ -1325,7 +1347,7 @@ static void yield_task_fair(struct rq *rq)
 	/*
 	 * Already in the rightmost position?
 	 */
-	if (unlikely(!rightmost || entity_before(rightmost, se)))
+	if (unlikely(!rightmost || entity_before(rightmost, cfs_se)))
 		return;
 
 	/*
@@ -1333,17 +1355,17 @@ static void yield_task_fair(struct rq *rq)
 	 * Upon rescheduling, sched_class::put_prev_task() will place
 	 * 'current' within the tree based on its new key value.
 	 */
-	se->vruntime = rightmost->vruntime + 1;
+	cfs_se->vruntime = rightmost->vruntime + 1;
 }
 
 #ifdef CONFIG_SMP
 
 static void task_waking_fair(struct rq *rq, struct task_struct *p)
 {
-	struct sched_entity *se = &p->se;
-	struct cfs_rq *cfs_rq = cfs_rq_of(se);
+	struct sched_cfs_entity *cfs_se = &p->cfs;
+	struct cfs_rq *cfs_rq = cfs_rq_of(cfs_se);
 
-	se->vruntime -= cfs_rq->min_vruntime;
+	cfs_se->vruntime -= cfs_rq->min_vruntime;
 }
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
@@ -1356,17 +1378,17 @@ static void task_waking_fair(struct rq *rq, struct task_struct *p)
  */
 static long effective_load(struct task_group *tg, int cpu, long wl, long wg)
 {
-	struct sched_entity *se = tg->se[cpu];
+	struct sched_cfs_entity *cfs_se = tg->cfs_se[cpu];
 
 	if (!tg->parent)
 		return wl;
 
-	for_each_sched_entity(se) {
+	for_each_sched_cfs_entity(cfs_se) {
 		long S, rw, s, a, b;
 
-		S = se->my_q->tg->shares;
-		s = se->load.weight;
-		rw = se->my_q->load.weight;
+		S = cfs_se->my_q->tg->shares;
+		s = cfs_se->load.weight;
+		rw = cfs_se->my_q->load.weight;
 
 		a = S*(rw + wl);
 		b = S*rw + s*wg;
@@ -1422,14 +1444,14 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p, int sync)
 	rcu_read_lock();
 	if (sync) {
 		tg = task_group(current);
-		weight = current->se.load.weight;
+		weight = current->cfs.load.weight;
 
 		this_load += effective_load(tg, this_cpu, -weight, -weight);
 		load += effective_load(tg, prev_cpu, 0, -weight);
 	}
 
 	tg = task_group(p);
-	weight = p->se.load.weight;
+	weight = p->cfs.load.weight;
 
 	/*
 	 * In low-load situations, where prev_cpu is idle and this_cpu is idle
@@ -1465,7 +1487,7 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p, int sync)
 	if (sync && balanced)
 		return 1;
 
-	schedstat_inc(p, se.statistics.nr_wakeups_affine_attempts);
+	schedstat_inc(p, cfs.statistics.nr_wakeups_affine_attempts);
 	tl_per_task = cpu_avg_load_per_task(this_cpu);
 
 	if (balanced ||
@@ -1477,7 +1499,7 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p, int sync)
 		 * there is no bad imbalance.
 		 */
 		schedstat_inc(sd, ttwu_move_affine);
-		schedstat_inc(p, se.statistics.nr_wakeups_affine);
+		schedstat_inc(p, cfs.statistics.nr_wakeups_affine);
 
 		return 1;
 	}
@@ -1738,7 +1760,7 @@ select_task_rq_fair(struct rq *rq, struct task_struct *p, int sd_flag, int wake_
 #endif /* CONFIG_SMP */
 
 static unsigned long
-wakeup_gran(struct sched_entity *curr, struct sched_entity *se)
+wakeup_gran(struct sched_cfs_entity *curr, struct sched_cfs_entity *cfs_se)
 {
 	unsigned long gran = sysctl_sched_wakeup_granularity;
 
@@ -1755,8 +1777,8 @@ wakeup_gran(struct sched_entity *curr, struct sched_entity *se)
 	 * This is especially important for buddies when the leftmost
 	 * task is higher priority than the buddy.
 	 */
-	if (unlikely(se->load.weight != NICE_0_LOAD))
-		gran = calc_delta_fair(gran, se);
+	if (unlikely(cfs_se->load.weight != NICE_0_LOAD))
+		gran = calc_delta_fair(gran, cfs_se);
 
 	return gran;
 }
@@ -1775,34 +1797,34 @@ wakeup_gran(struct sched_entity *curr, struct sched_entity *se)
  *  w(c, s3) =  1
  *
  */
-static int
-wakeup_preempt_entity(struct sched_entity *curr, struct sched_entity *se)
+static int wakeup_preempt_entity(struct sched_cfs_entity *curr,
+				 struct sched_cfs_entity *cfs_se)
 {
-	s64 gran, vdiff = curr->vruntime - se->vruntime;
+	s64 gran, vdiff = curr->vruntime - cfs_se->vruntime;
 
 	if (vdiff <= 0)
 		return -1;
 
-	gran = wakeup_gran(curr, se);
+	gran = wakeup_gran(curr, cfs_se);
 	if (vdiff > gran)
 		return 1;
 
 	return 0;
 }
 
-static void set_last_buddy(struct sched_entity *se)
+static void set_last_buddy(struct sched_cfs_entity *cfs_se)
 {
-	if (likely(task_of(se)->policy != SCHED_IDLE)) {
-		for_each_sched_entity(se)
-			cfs_rq_of(se)->last = se;
+	if (likely(cfs_task_of(cfs_se)->policy != SCHED_IDLE)) {
+		for_each_sched_cfs_entity(cfs_se)
+			cfs_rq_of(cfs_se)->last = cfs_se;
 	}
 }
 
-static void set_next_buddy(struct sched_entity *se)
+static void set_next_buddy(struct sched_cfs_entity *cfs_se)
 {
-	if (likely(task_of(se)->policy != SCHED_IDLE)) {
-		for_each_sched_entity(se)
-			cfs_rq_of(se)->next = se;
+	if (likely(cfs_task_of(cfs_se)->policy != SCHED_IDLE)) {
+		for_each_sched_cfs_entity(cfs_se)
+			cfs_rq_of(cfs_se)->next = cfs_se;
 	}
 }
 
@@ -1812,15 +1834,15 @@ static void set_next_buddy(struct sched_entity *se)
 static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_flags)
 {
 	struct task_struct *curr = rq->curr;
-	struct sched_entity *se = &curr->se, *pse = &p->se;
+	struct sched_cfs_entity *cfs_se = &curr->cfs, *cfs_pse = &p->cfs;
 	struct cfs_rq *cfs_rq = task_cfs_rq(curr);
 	int scale = cfs_rq->nr_running >= sched_nr_latency;
 
-	if (unlikely(se == pse))
+	if (unlikely(cfs_se == cfs_pse))
 		return;
 
 	if (sched_feat(NEXT_BUDDY) && scale && !(wake_flags & WF_FORK))
-		set_next_buddy(pse);
+		set_next_buddy(cfs_pse);
 
 	/*
 	 * We can come here with TIF_NEED_RESCHED already set from new task
@@ -1844,9 +1866,9 @@ static void check_preempt_wakeup(struct rq *rq, struct task_struct *p, int wake_
 		return;
 
 	update_curr(cfs_rq);
-	find_matching_se(&se, &pse);
-	BUG_ON(!pse);
-	if (wakeup_preempt_entity(se, pse) == 1)
+	find_matching_se(&cfs_se, &cfs_pse);
+	BUG_ON(!cfs_pse);
+	if (wakeup_preempt_entity(cfs_se, cfs_pse) == 1)
 		goto preempt;
 
 	return;
@@ -1862,29 +1884,29 @@ preempt:
 	 * Also, during early boot the idle thread is in the fair class,
 	 * for obvious reasons its a bad idea to schedule back to it.
 	 */
-	if (unlikely(!se->on_rq || curr == rq->idle))
+	if (unlikely(!cfs_se->on_rq || curr == rq->idle))
 		return;
 
-	if (sched_feat(LAST_BUDDY) && scale && entity_is_task(se))
-		set_last_buddy(se);
+	if (sched_feat(LAST_BUDDY) && scale && cfs_entity_is_task(cfs_se))
+		set_last_buddy(cfs_se);
 }
 
 static struct task_struct *pick_next_task_fair(struct rq *rq)
 {
 	struct task_struct *p;
 	struct cfs_rq *cfs_rq = &rq->cfs;
-	struct sched_entity *se;
+	struct sched_cfs_entity *cfs_se;
 
 	if (!cfs_rq->nr_running)
 		return NULL;
 
 	do {
-		se = pick_next_entity(cfs_rq);
-		set_next_entity(cfs_rq, se);
-		cfs_rq = group_cfs_rq(se);
+		cfs_se = pick_next_entity(cfs_rq);
+		set_next_entity(cfs_rq, cfs_se);
+		cfs_rq = group_cfs_rq(cfs_se);
 	} while (cfs_rq);
 
-	p = task_of(se);
+	p = cfs_task_of(cfs_se);
 	hrtick_start_fair(rq, p);
 
 	return p;
@@ -1895,12 +1917,12 @@ static struct task_struct *pick_next_task_fair(struct rq *rq)
  */
 static void put_prev_task_fair(struct rq *rq, struct task_struct *prev)
 {
-	struct sched_entity *se = &prev->se;
+	struct sched_cfs_entity *cfs_se = &prev->cfs;
 	struct cfs_rq *cfs_rq;
 
-	for_each_sched_entity(se) {
-		cfs_rq = cfs_rq_of(se);
-		put_prev_entity(cfs_rq, se);
+	for_each_sched_cfs_entity(cfs_se) {
+		cfs_rq = cfs_rq_of(cfs_se);
+		put_prev_entity(cfs_rq, cfs_se);
 	}
 }
 
@@ -1938,13 +1960,13 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
 	 * 3) are cache-hot on their current CPU.
 	 */
 	if (!cpumask_test_cpu(this_cpu, &p->cpus_allowed)) {
-		schedstat_inc(p, se.statistics.nr_failed_migrations_affine);
+		schedstat_inc(p, cfs.statistics.nr_failed_migrations_affine);
 		return 0;
 	}
 	*all_pinned = 0;
 
 	if (task_running(rq, p)) {
-		schedstat_inc(p, se.statistics.nr_failed_migrations_running);
+		schedstat_inc(p, cfs.statistics.nr_failed_migrations_running);
 		return 0;
 	}
 
@@ -1960,14 +1982,14 @@ int can_migrate_task(struct task_struct *p, struct rq *rq, int this_cpu,
 #ifdef CONFIG_SCHEDSTATS
 		if (tsk_cache_hot) {
 			schedstat_inc(sd, lb_hot_gained[idle]);
-			schedstat_inc(p, se.statistics.nr_forced_migrations);
+			schedstat_inc(p, cfs.statistics.nr_forced_migrations);
 		}
 #endif
 		return 1;
 	}
 
 	if (tsk_cache_hot) {
-		schedstat_inc(p, se.statistics.nr_failed_migrations_hot);
+		schedstat_inc(p, cfs.statistics.nr_failed_migrations_hot);
 		return 0;
 	}
 	return 1;
@@ -1989,7 +2011,7 @@ move_one_task(struct rq *this_rq, int this_cpu, struct rq *busiest,
 	int pinned = 0;
 
 	for_each_leaf_cfs_rq(busiest, cfs_rq) {
-		list_for_each_entry_safe(p, n, &cfs_rq->tasks, se.group_node) {
+		list_for_each_entry_safe(p, n, &cfs_rq->tasks, cfs.group_node) {
 
 			if (!can_migrate_task(p, busiest, this_cpu,
 						sd, idle, &pinned))
@@ -2024,17 +2046,17 @@ balance_tasks(struct rq *this_rq, int this_cpu, struct rq *busiest,
 
 	pinned = 1;
 
-	list_for_each_entry_safe(p, n, &busiest_cfs_rq->tasks, se.group_node) {
+	list_for_each_entry_safe(p, n, &busiest_cfs_rq->tasks, cfs.group_node) {
 		if (loops++ > sysctl_sched_nr_migrate)
 			break;
 
-		if ((p->se.load.weight >> 1) > rem_load_move ||
+		if ((p->cfs.load.weight >> 1) > rem_load_move ||
 		    !can_migrate_task(p, busiest, this_cpu, sd, idle, &pinned))
 			continue;
 
 		pull_task(busiest, p, this_rq, this_cpu);
 		pulled++;
-		rem_load_move -= p->se.load.weight;
+		rem_load_move -= p->cfs.load.weight;
 
 #ifdef CONFIG_PREEMPT
 		/*
@@ -2080,7 +2102,7 @@ static int update_shares_cpu(struct task_group *tg, int cpu)
 	unsigned long flags;
 	struct rq *rq;
 
-	if (!tg->se[cpu])
+	if (!tg->cfs_se[cpu])
 		return 0;
 
 	rq = cpu_rq(cpu);
@@ -3996,11 +4018,11 @@ static inline void idle_balance(int cpu, struct rq *rq)
 static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
 {
 	struct cfs_rq *cfs_rq;
-	struct sched_entity *se = &curr->se;
+	struct sched_cfs_entity *cfs_se = &curr->cfs;
 
-	for_each_sched_entity(se) {
-		cfs_rq = cfs_rq_of(se);
-		entity_tick(cfs_rq, se, queued);
+	for_each_sched_cfs_entity(cfs_se) {
+		cfs_rq = cfs_rq_of(cfs_se);
+		entity_tick(cfs_rq, cfs_se, queued);
 	}
 }
 
@@ -4012,7 +4034,7 @@ static void task_tick_fair(struct rq *rq, struct task_struct *curr, int queued)
 static void task_fork_fair(struct task_struct *p)
 {
 	struct cfs_rq *cfs_rq = task_cfs_rq(current);
-	struct sched_entity *se = &p->se, *curr = cfs_rq->curr;
+	struct sched_cfs_entity *cfs_se = &p->cfs, *curr = cfs_rq->curr;
 	int this_cpu = smp_processor_id();
 	struct rq *rq = this_rq();
 	unsigned long flags;
@@ -4030,19 +4052,20 @@ static void task_fork_fair(struct task_struct *p)
 	update_curr(cfs_rq);
 
 	if (curr)
-		se->vruntime = curr->vruntime;
-	place_entity(cfs_rq, se, 1);
+		cfs_se->vruntime = curr->vruntime;
+	place_entity(cfs_rq, cfs_se, 1);
 
-	if (sysctl_sched_child_runs_first && curr && entity_before(curr, se)) {
+	if (sysctl_sched_child_runs_first &&
+	    curr && entity_before(curr, cfs_se)) {
 		/*
 		 * Upon rescheduling, sched_class::put_prev_task() will place
 		 * 'current' within the tree based on its new key value.
 		 */
-		swap(curr->vruntime, se->vruntime);
+		swap(curr->vruntime, cfs_se->vruntime);
 		resched_task(rq->curr);
 	}
 
-	se->vruntime -= cfs_rq->min_vruntime;
+	cfs_se->vruntime -= cfs_rq->min_vruntime;
 
 	raw_spin_unlock_irqrestore(&rq->lock, flags);
 }
@@ -4090,10 +4113,10 @@ static void switched_to_fair(struct rq *rq, struct task_struct *p,
  */
 static void set_curr_task_fair(struct rq *rq)
 {
-	struct sched_entity *se = &rq->curr->se;
+	struct sched_cfs_entity *cfs_se = &rq->curr->cfs;
 
-	for_each_sched_entity(se)
-		set_next_entity(cfs_rq_of(se), se);
+	for_each_sched_cfs_entity(cfs_se)
+		set_next_entity(cfs_rq_of(cfs_se), cfs_se);
 }
 
 #ifdef CONFIG_FAIR_GROUP_SCHED
@@ -4113,16 +4136,16 @@ static void task_move_group_fair(struct task_struct *p, int on_rq)
 	 * fair sleeper stuff for the first placement, but who cares.
 	 */
 	if (!on_rq)
-		p->se.vruntime -= cfs_rq_of(&p->se)->min_vruntime;
+		p->cfs.vruntime -= cfs_rq_of(&p->cfs)->min_vruntime;
 	set_task_rq(p, task_cpu(p));
 	if (!on_rq)
-		p->se.vruntime += cfs_rq_of(&p->se)->min_vruntime;
+		p->cfs.vruntime += cfs_rq_of(&p->cfs)->min_vruntime;
 }
 #endif
 
 static unsigned int get_rr_interval_fair(struct rq *rq, struct task_struct *task)
 {
-	struct sched_entity *se = &task->se;
+	struct sched_cfs_entity *cfs_se = &task->cfs;
 	unsigned int rr_interval = 0;
 
 	/*
@@ -4130,7 +4153,7 @@ static unsigned int get_rr_interval_fair(struct rq *rq, struct task_struct *task
 	 * idle runqueue:
 	 */
 	if (rq->cfs.load.weight)
-		rr_interval = NS_TO_JIFFIES(sched_slice(&rq->cfs, se));
+		rr_interval = NS_TO_JIFFIES(sched_slice(&rq->cfs, cfs_se));
 
 	return rr_interval;
 }
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index c914ec7..2bba302 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -628,16 +628,16 @@ static void update_curr_rt(struct rq *rq)
 	if (!task_has_rt_policy(curr))
 		return;
 
-	delta_exec = rq->clock_task - curr->se.exec_start;
+	delta_exec = rq->clock_task - curr->cfs.exec_start;
 	if (unlikely((s64)delta_exec < 0))
 		delta_exec = 0;
 
-	schedstat_set(curr->se.statistics.exec_max, max(curr->se.statistics.exec_max, delta_exec));
+	schedstat_set(curr->cfs.statistics.exec_max, max(curr->cfs.statistics.exec_max, delta_exec));
 
-	curr->se.sum_exec_runtime += delta_exec;
+	curr->cfs.sum_exec_runtime += delta_exec;
 	account_group_exec_runtime(curr, delta_exec);
 
-	curr->se.exec_start = rq->clock_task;
+	curr->cfs.exec_start = rq->clock_task;
 	cpuacct_charge(curr, delta_exec);
 
 	sched_rt_avg_update(rq, delta_exec);
@@ -1099,7 +1099,7 @@ static struct task_struct *_pick_next_task_rt(struct rq *rq)
 	} while (rt_rq);
 
 	p = rt_task_of(rt_se);
-	p->se.exec_start = rq->clock_task;
+	p->cfs.exec_start = rq->clock_task;
 
 	return p;
 }
@@ -1126,13 +1126,13 @@ static struct task_struct *pick_next_task_rt(struct rq *rq)
 static void put_prev_task_rt(struct rq *rq, struct task_struct *p)
 {
 	update_curr_rt(rq);
-	p->se.exec_start = 0;
+	p->cfs.exec_start = 0;
 
 	/*
 	 * The previous task needs to be made eligible for pushing
 	 * if it is still active
 	 */
-	if (p->se.on_rq && p->rt.nr_cpus_allowed > 1)
+	if (p->cfs.on_rq && p->rt.nr_cpus_allowed > 1)
 		enqueue_pushable_task(rq, p);
 }
 
@@ -1283,7 +1283,7 @@ static struct rq *find_lock_lowest_rq(struct task_struct *task, struct rq *rq)
 				     !cpumask_test_cpu(lowest_rq->cpu,
 						       &task->cpus_allowed) ||
 				     task_running(rq, task) ||
-				     !task->se.on_rq)) {
+				     !task->cfs.on_rq)) {
 
 				raw_spin_unlock(&lowest_rq->lock);
 				lowest_rq = NULL;
@@ -1317,7 +1317,7 @@ static struct task_struct *pick_next_pushable_task(struct rq *rq)
 	BUG_ON(task_current(rq, p));
 	BUG_ON(p->rt.nr_cpus_allowed <= 1);
 
-	BUG_ON(!p->se.on_rq);
+	BUG_ON(!p->cfs.on_rq);
 	BUG_ON(!rt_task(p));
 
 	return p;
@@ -1463,7 +1463,7 @@ static int pull_rt_task(struct rq *this_rq)
 		 */
 		if (p && (p->prio < this_rq->rt.highest_prio.curr)) {
 			WARN_ON(p == src_rq->curr);
-			WARN_ON(!p->se.on_rq);
+			WARN_ON(!p->cfs.on_rq);
 
 			/*
 			 * There's a chance that p is higher in priority
@@ -1534,7 +1534,7 @@ static void set_cpus_allowed_rt(struct task_struct *p,
 	 * Update the migration status of the RQ if we have an RT task
 	 * which is running AND changing its weight value.
 	 */
-	if (p->se.on_rq && (weight != p->rt.nr_cpus_allowed)) {
+	if (p->cfs.on_rq && (weight != p->rt.nr_cpus_allowed)) {
 		struct rq *rq = task_rq(p);
 
 		if (!task_current(rq, p)) {
@@ -1701,7 +1701,7 @@ static void watchdog(struct rq *rq, struct task_struct *p)
 		p->rt.timeout++;
 		next = DIV_ROUND_UP(min(soft, hard), USEC_PER_SEC/HZ);
 		if (p->rt.timeout > next)
-			p->cputime_expires.sched_exp = p->se.sum_exec_runtime;
+			p->cputime_expires.sched_exp = p->cfs.sum_exec_runtime;
 	}
 }
 
@@ -1737,7 +1737,7 @@ static void set_curr_task_rt(struct rq *rq)
 {
 	struct task_struct *p = rq->curr;
 
-	p->se.exec_start = rq->clock_task;
+	p->cfs.exec_start = rq->clock_task;
 
 	/* The running task is never eligible for pushing */
 	dequeue_pushable_task(rq, p);
diff --git a/kernel/sched_stoptask.c b/kernel/sched_stoptask.c
index 2bf6b47..763732d 100644
--- a/kernel/sched_stoptask.c
+++ b/kernel/sched_stoptask.c
@@ -26,7 +26,7 @@ static struct task_struct *pick_next_task_stop(struct rq *rq)
 {
 	struct task_struct *stop = rq->stop;
 
-	if (stop && stop->se.on_rq)
+	if (stop && stop->cfs.on_rq)
 		return stop;
 
 	return NULL;
-- 
1.7.2.3

-- 
<<This happens because I choose it to happen!>> (Raistlin Majere)
----------------------------------------------------------------------
Dario Faggioli, ReTiS Lab, Scuola Superiore Sant'Anna, Pisa  (Italy)

http://retis.sssup.it/people/faggioli -- dario.faggioli@jabber.org

[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 198 bytes --]