kernel26-magellan/patches-2.6.16-r3/0008-2.6.16-sched-generic_optims2.patch

 include/linux/sched.h |    2 
 kernel/sched.c        |  121 ++++++++++++++++++++++++++------------------------
 2 files changed, 64 insertions(+), 59 deletions(-)

Index: linux-2.6.16-ck1/kernel/sched.c
===================================================================
--- linux-2.6.16-ck1.orig/kernel/sched.c	2006-03-20 20:46:48.000000000 +1100
+++ linux-2.6.16-ck1/kernel/sched.c	2006-03-20 20:46:48.000000000 +1100
@@ -194,7 +194,7 @@ for (domain = rcu_dereference(cpu_rq(cpu
 #endif
 
 #ifndef __ARCH_WANT_UNLOCKED_CTXSW
-static inline int task_running(runqueue_t *rq, task_t *p)
+static inline int task_running(const runqueue_t *rq, const task_t *p)
 {
 	return rq->curr == p;
 }
@@ -203,7 +203,7 @@ static inline void prepare_lock_switch(r
 {
 }
 
-static inline void finish_lock_switch(runqueue_t *rq, task_t *prev)
+static inline void finish_lock_switch(runqueue_t *rq, task_t *__unused)
 {
 #ifdef CONFIG_DEBUG_SPINLOCK
 	/* this is a valid case when another task releases the spinlock */
@@ -213,7 +213,7 @@ static inline void finish_lock_switch(ru
 }
 
 #else /* __ARCH_WANT_UNLOCKED_CTXSW */
-static inline int task_running(runqueue_t *rq, task_t *p)
+static inline int task_running(const runqueue_t *rq, const task_t *p)
 {
 #ifdef CONFIG_SMP
 	return p->oncpu;
@@ -239,7 +239,7 @@ static inline void prepare_lock_switch(r
 #endif
 }
 
-static inline void finish_lock_switch(runqueue_t *rq, task_t *prev)
+static inline void finish_lock_switch(runqueue_t *__unused, task_t *prev)
 {
 #ifdef CONFIG_SMP
 	/*
@@ -261,7 +261,7 @@ static inline void finish_lock_switch(ru
  * interrupts.  Note the ordering: we can safely lookup the task_rq without
  * explicitly disabling preemption.
  */
-static inline runqueue_t *task_rq_lock(task_t *p, unsigned long *flags)
+static inline runqueue_t *task_rq_lock(const task_t *p, unsigned long *flags)
 	__acquires(rq->lock)
 {
 	struct runqueue *rq;
@@ -611,7 +611,7 @@ static inline void inc_nr_running(task_t
 	inc_raw_weighted_load(rq, p);
 }
 
-static inline void dec_nr_running(task_t *p, runqueue_t *rq)
+static inline void dec_nr_running(const task_t *p, runqueue_t *rq)
 {
 	rq->nr_running--;
 	dec_raw_weighted_load(rq, p);
@@ -831,7 +831,7 @@ static void fastcall deactivate_task(tas
  * the target CPU.
  */
 #ifdef CONFIG_SMP
-static void resched_task(task_t *p)
+static void fastcall resched_task(task_t *p)
 {
 	int cpu;
 
@@ -888,7 +888,7 @@ typedef struct {
  * The task's runqueue lock must be held.
  * Returns true if you have to wait for migration thread.
  */
-static int migrate_task(task_t *p, int dest_cpu, migration_req_t *req)
+static int migrate_task(task_t *p, const int dest_cpu, migration_req_t *req)
 {
 	runqueue_t *rq = task_rq(p);
 
@@ -951,7 +951,7 @@ repeat:
  * to another CPU then no harm is done and the purpose has been
  * achieved as well.
  */
-void kick_process(task_t *p)
+void kick_process(const task_t *p)
 {
 	int cpu;
 
@@ -1009,7 +1009,7 @@ static inline unsigned long cpu_avg_load
  * domain.
  */
 static struct sched_group *
-find_idlest_group(struct sched_domain *sd, struct task_struct *p, int this_cpu)
+find_idlest_group(struct sched_domain *sd, task_t *p, const int this_cpu)
 {
 	struct sched_group *idlest = NULL, *this = NULL, *group = sd->groups;
 	unsigned long min_load = ULONG_MAX, this_load = 0;
@@ -1063,7 +1063,7 @@ nextgroup:
  * find_idlest_queue - find the idlest runqueue among the cpus in group.
  */
 static int
-find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu)
+find_idlest_cpu(struct sched_group *group, task_t *p, const int this_cpu)
 {
 	cpumask_t tmp;
 	unsigned long load, min_load = ULONG_MAX;
@@ -1096,7 +1096,7 @@ find_idlest_cpu(struct sched_group *grou
  *
  * preempt must be disabled.
  */
-static int sched_balance_self(int cpu, int flag)
+static int sched_balance_self(int cpu, const int flag)
 {
 	struct task_struct *t = current;
 	struct sched_domain *tmp, *sd = NULL;
@@ -1148,7 +1148,7 @@ nextlevel:
  * Returns the CPU we should wake onto.
  */
 #if defined(ARCH_HAS_SCHED_WAKE_IDLE)
-static int wake_idle(int cpu, task_t *p)
+static int wake_idle(const int cpu, const task_t *p)
 {
 	cpumask_t tmp;
 	struct sched_domain *sd;
@@ -1171,7 +1171,7 @@ static int wake_idle(int cpu, task_t *p)
 	return cpu;
 }
 #else
-static inline int wake_idle(int cpu, task_t *p)
+static inline int wake_idle(const int cpu, task_t *__unused)
 {
 	return cpu;
 }
@@ -1211,7 +1211,7 @@ static void fastcall preempt(const task_
  *
  * returns failure only if the task is already active.
  */
-static int try_to_wake_up(task_t *p, unsigned int state, int sync)
+static int try_to_wake_up(task_t *p, unsigned int state, const int sync)
 {
 	int cpu, this_cpu, success = 0;
 	unsigned long flags;
@@ -1369,7 +1369,7 @@ int fastcall wake_up_state(task_t *p, un
  * Perform scheduler related setup for a newly forked process p.
  * p is forked by current.
  */
-void fastcall sched_fork(task_t *p, int clone_flags)
+void fastcall sched_fork(task_t *p, int __unused)
 {
 	int cpu = get_cpu();
 
@@ -1406,7 +1406,7 @@ void fastcall sched_fork(task_t *p, int 
  * that must be done for every newly created context, then puts the task
  * on the runqueue and wakes it.
  */
-void fastcall wake_up_new_task(task_t *p, unsigned long clone_flags)
+void fastcall wake_up_new_task(task_t *p, const unsigned long clone_flags)
 {
 	unsigned long flags;
 	int this_cpu, cpu;
@@ -1690,7 +1690,7 @@ static void double_lock_balance(runqueue
  * allow dest_cpu, which will force the cpu onto dest_cpu.  Then
  * the cpu_allowed mask is restored.
  */
-static void sched_migrate_task(task_t *p, int dest_cpu)
+static void sched_migrate_task(task_t *p, const int dest_cpu)
 {
 	migration_req_t req;
 	runqueue_t *rq;
@@ -1869,8 +1869,8 @@ out:
  * moved to restore balance via the imbalance parameter.
  */
 static struct sched_group *
-find_busiest_group(struct sched_domain *sd, int this_cpu,
-		   unsigned long *imbalance, enum idle_type idle, int *sd_idle)
+find_busiest_group(struct sched_domain *sd, const int this_cpu,
+	unsigned long *imbalance, const enum idle_type idle, int *sd_idle)
 {
 	struct sched_group *busiest = NULL, *this = NULL, *group = sd->groups;
 	unsigned long max_load, avg_load, total_load, this_load, total_pwr;
@@ -2035,7 +2035,7 @@ out_balanced:
  * find_busiest_queue - find the busiest runqueue among the cpus in group.
  */
 static runqueue_t *find_busiest_queue(struct sched_group *group,
-	enum idle_type idle)
+	const enum idle_type idle)
 {
 	unsigned long load, max_load = 0;
 	runqueue_t *busiest = NULL;
@@ -2066,8 +2066,8 @@ static runqueue_t *find_busiest_queue(st
  *
  * Called with this_rq unlocked.
  */
-static int load_balance(int this_cpu, runqueue_t *this_rq,
-			struct sched_domain *sd, enum idle_type idle)
+static int load_balance(const int this_cpu, runqueue_t *this_rq,
+	struct sched_domain *sd, const enum idle_type idle)
 {
 	struct sched_group *group;
 	runqueue_t *busiest;
@@ -2192,7 +2192,7 @@ out_one_pinned:
  * Called from schedule when this_rq is about to become idle (NEWLY_IDLE).
  * this_rq is locked.
  */
-static int load_balance_newidle(int this_cpu, runqueue_t *this_rq,
+static int load_balance_newidle(const int this_cpu, runqueue_t *this_rq,
 				struct sched_domain *sd)
 {
 	struct sched_group *group;
@@ -2252,7 +2252,7 @@ out_balanced:
  * idle_balance is called by schedule() if this_cpu is about to become
  * idle. Attempts to pull tasks from other CPUs.
  */
-static void idle_balance(int this_cpu, runqueue_t *this_rq)
+static void idle_balance(const int this_cpu, runqueue_t *this_rq)
 {
 	struct sched_domain *sd;
 
@@ -2274,7 +2274,7 @@ static void idle_balance(int this_cpu, r
  *
  * Called with busiest_rq locked.
  */
-static void active_load_balance(runqueue_t *busiest_rq, int busiest_cpu)
+static void active_load_balance(runqueue_t *busiest_rq, const int busiest_cpu)
 {
 	struct sched_domain *sd;
 	runqueue_t *target_rq;
@@ -2328,8 +2328,8 @@ out:
 /* Don't have all balancing operations going off at once */
 #define CPU_OFFSET(cpu) (HZ * cpu / NR_CPUS)
 
-static void rebalance_tick(int this_cpu, runqueue_t *this_rq,
-			   enum idle_type idle)
+static void rebalance_tick(const int this_cpu, runqueue_t *this_rq,
+	enum idle_type idle)
 {
 	unsigned long old_load, this_load;
 	unsigned long j = jiffies + CPU_OFFSET(this_cpu);
@@ -2416,8 +2416,8 @@ EXPORT_PER_CPU_SYMBOL(kstat);
  * This is called on clock ticks and on context switches.
  * Bank in p->sched_time the ns elapsed since the last tick or switch.
  */
-static inline void update_cpu_clock(task_t *p, runqueue_t *rq,
-				    unsigned long long now)
+static inline void update_cpu_clock(task_t *p, const runqueue_t *rq,
+	const unsigned long long now)
 {
 	unsigned long long last = max(p->timestamp, rq->timestamp_last_tick);
 	p->sched_time += now - last;
@@ -2602,7 +2602,7 @@ static inline void wakeup_busy_runqueue(
 		resched_task(rq->idle);
 }
 
-static void wake_sleeping_dependent(int this_cpu, runqueue_t *this_rq)
+static void wake_sleeping_dependent(const int this_cpu, runqueue_t *this_rq)
 {
 	struct sched_domain *tmp, *sd = NULL;
 	cpumask_t sibling_map;
@@ -2657,7 +2657,7 @@ static inline unsigned long smt_slice(co
 	return p->slice * (100 - sd->per_cpu_gain) / 100;
 }
 
-static int dependent_sleeper(int this_cpu, runqueue_t *this_rq)
+static int dependent_sleeper(const int this_cpu, runqueue_t *this_rq)
 {
 	struct sched_domain *tmp, *sd = NULL;
 	cpumask_t sibling_map;
@@ -2765,7 +2765,7 @@ static inline int dependent_sleeper(int 
 
 #if defined(CONFIG_PREEMPT) && defined(CONFIG_DEBUG_PREEMPT)
 
-void fastcall add_preempt_count(int val)
+void fastcall add_preempt_count(const int val)
 {
 	/*
 	 * Underflow?
@@ -2779,7 +2779,7 @@ void fastcall add_preempt_count(int val)
 }
 EXPORT_SYMBOL(add_preempt_count);
 
-void fastcall sub_preempt_count(int val)
+void fastcall sub_preempt_count(const int val)
 {
 	/*
 	 * Underflow?
@@ -2813,8 +2813,8 @@ asmlinkage void __sched schedule(void)
 	 * schedule() atomically, we ignore that path for now.
 	 * Otherwise, whine if we are scheduling when we should not be.
 	 */
-	if (likely(!current->exit_state)) {
-		if (unlikely(in_atomic())) {
+	if (unlikely(in_atomic())) {
+		if (!current->exit_state) {
 			printk(KERN_ERR "scheduling while atomic: "
 				"%s/0x%08x/%d\n",
 				current->comm, preempt_count(), current->pid);
@@ -2850,7 +2850,6 @@ need_resched_nonpreemptible:
 	if (unlikely(prev->flags & PF_DEAD))
 		prev->state = EXIT_DEAD;
 
-	switch_count = &prev->nivcsw;
 	if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
 		switch_count = &prev->nvcsw;
 		if (unlikely((prev->state & TASK_INTERRUPTIBLE) &&
@@ -2863,7 +2862,9 @@ need_resched_nonpreemptible:
 			}
 			deactivate_task(prev, rq);
 		}
-	}
+	} else
+		switch_count = &prev->nivcsw;
+
 
 	cpu = smp_processor_id();
 	if (unlikely(!rq->nr_running)) {
@@ -3048,7 +3049,7 @@ EXPORT_SYMBOL(default_wake_function);
  * zero in this (rare) case, and we handle it by continuing to scan the queue.
  */
 static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
-			     int nr_exclusive, int sync, void *key)
+	int nr_exclusive, const int sync, void *key)
 {
 	struct list_head *tmp, *next;
 
@@ -3340,7 +3341,7 @@ long fastcall __sched sleep_on_timeout(w
 
 EXPORT_SYMBOL(sleep_on_timeout);
 
-void set_user_nice(task_t *p, long nice)
+void set_user_nice(task_t *p, const long nice)
 {
 	unsigned long flags;
 	runqueue_t *rq;
@@ -3476,7 +3477,7 @@ EXPORT_SYMBOL_GPL(task_nice);
  * idle_cpu - is a given cpu idle currently?
  * @cpu: the processor in question.
  */
-int idle_cpu(int cpu)
+int idle_cpu(const int cpu)
 {
 	return cpu_curr(cpu) == cpu_rq(cpu)->idle;
 }
@@ -3485,7 +3486,7 @@ int idle_cpu(int cpu)
  * idle_task - return the idle task for a given cpu.
  * @cpu: the processor in question.
  */
-task_t *idle_task(int cpu)
+task_t *idle_task(const int cpu)
 {
 	return cpu_rq(cpu)->idle;
 }
@@ -3494,13 +3495,13 @@ task_t *idle_task(int cpu)
  * find_process_by_pid - find a process with a matching PID value.
  * @pid: the pid in question.
  */
-static inline task_t *find_process_by_pid(pid_t pid)
+static inline task_t *find_process_by_pid(const pid_t pid)
 {
 	return pid ? find_task_by_pid(pid) : current;
 }
 
 /* Actually do priority change: must hold rq lock. */
-static void __setscheduler(struct task_struct *p, int policy, int prio)
+static void __setscheduler(task_t *p, const int policy, const int prio)
 {
 	BUG_ON(task_queued(p));
 	p->policy = policy;
@@ -3608,7 +3609,8 @@ recheck:
 EXPORT_SYMBOL_GPL(sched_setscheduler);
 
 static int
-do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
+do_sched_setscheduler(const pid_t pid, int policy,
+	struct sched_param __user *param)
 {
 	int retval;
 	struct sched_param lparam;
@@ -3635,7 +3637,7 @@ do_sched_setscheduler(pid_t pid, int pol
  * @policy: new policy.
  * @param: structure containing the new RT priority.
  */
-asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,
+asmlinkage long sys_sched_setscheduler(const pid_t pid, int policy,
 				       struct sched_param __user *param)
 {
 	/* negative values for policy are not valid */
@@ -3650,7 +3652,8 @@ asmlinkage long sys_sched_setscheduler(p
  * @pid: the pid in question.
  * @param: structure containing the new RT priority.
  */
-asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param __user *param)
+asmlinkage long sys_sched_setparam(const pid_t pid,
+	struct sched_param __user *param)
 {
 	return do_sched_setscheduler(pid, -1, param);
 }
@@ -3659,7 +3662,7 @@ asmlinkage long sys_sched_setparam(pid_t
  * sys_sched_getscheduler - get the policy (scheduling class) of a thread
  * @pid: the pid in question.
  */
-asmlinkage long sys_sched_getscheduler(pid_t pid)
+asmlinkage long sys_sched_getscheduler(const pid_t pid)
 {
 	int retval = -EINVAL;
 	task_t *p;
@@ -3686,7 +3689,8 @@ out_nounlock:
  * @pid: the pid in question.
  * @param: structure containing the RT priority.
  */
-asmlinkage long sys_sched_getparam(pid_t pid, struct sched_param __user *param)
+asmlinkage long sys_sched_getparam(const pid_t pid,
+	struct sched_param __user *param)
 {
 	struct sched_param lp;
 	int retval = -EINVAL;
@@ -3721,7 +3725,7 @@ out_unlock:
 	return retval;
 }
 
-long sched_setaffinity(pid_t pid, cpumask_t new_mask)
+long sched_setaffinity(const pid_t pid, cpumask_t new_mask)
 {
 	task_t *p;
 	int retval;
@@ -3777,7 +3781,7 @@ static int get_user_cpu_mask(unsigned lo
  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
  * @user_mask_ptr: user-space pointer to the new cpu mask
  */
-asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
+asmlinkage long sys_sched_setaffinity(const pid_t pid, unsigned int len,
 				      unsigned long __user *user_mask_ptr)
 {
 	cpumask_t new_mask;
@@ -3805,7 +3809,7 @@ cpumask_t cpu_online_map __read_mostly =
 cpumask_t cpu_possible_map __read_mostly = CPU_MASK_ALL;
 #endif
 
-long sched_getaffinity(pid_t pid, cpumask_t *mask)
+long sched_getaffinity(const pid_t pid, cpumask_t *mask)
 {
 	int retval;
 	task_t *p;
@@ -3836,7 +3840,7 @@ out_unlock:
  * @len: length in bytes of the bitmask pointed to by user_mask_ptr
  * @user_mask_ptr: user-space pointer to hold the current cpu mask
  */
-asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
+asmlinkage long sys_sched_getaffinity(const pid_t pid, unsigned int len,
 				      unsigned long __user *user_mask_ptr)
 {
 	int ret;
@@ -4017,7 +4021,7 @@ long __sched io_schedule_timeout(long ti
  * this syscall returns the maximum rt_priority that can be used
  * by a given scheduling class.
  */
-asmlinkage long sys_sched_get_priority_max(int policy)
+asmlinkage long sys_sched_get_priority_max(const int policy)
 {
 	int ret = -EINVAL;
 
@@ -4041,7 +4045,7 @@ asmlinkage long sys_sched_get_priority_m
  * this syscall returns the minimum rt_priority that can be used
  * by a given scheduling class.
  */
-asmlinkage long sys_sched_get_priority_min(int policy)
+asmlinkage long sys_sched_get_priority_min(const int policy)
 {
 	int ret = -EINVAL;
 
@@ -4066,7 +4070,8 @@ asmlinkage long sys_sched_get_priority_m
  * into the user-space timespec buffer. A value of '0' means infinity.
  */
 asmlinkage
-long sys_sched_rr_get_interval(pid_t pid, struct timespec __user *interval)
+long sys_sched_rr_get_interval(const pid_t pid,
+	struct timespec __user *interval)
 {
 	int retval = -EINVAL;
 	struct timespec t;
@@ -4203,7 +4208,7 @@ void show_state(void)
  * NOTE: this function does not set the idle thread's NEED_RESCHED
  * flag, to make booting more robust.
  */
-void __devinit init_idle(task_t *idle, int cpu)
+void __devinit init_idle(task_t *idle, const int cpu)
 {
 	runqueue_t *rq = cpu_rq(cpu);
 	unsigned long flags;
@@ -4306,7 +4311,7 @@ EXPORT_SYMBOL_GPL(set_cpus_allowed);
  * So we race with normal scheduler movements, but that's OK, as long
  * as the task is no longer on this CPU.
  */
-static void __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
+static void __migrate_task(task_t *p, const int src_cpu, const int dest_cpu)
 {
 	runqueue_t *rq_dest, *rq_src;
 
Index: linux-2.6.16-ck1/include/linux/sched.h
===================================================================
--- linux-2.6.16-ck1.orig/include/linux/sched.h	2006-03-20 20:46:48.000000000 +1100
+++ linux-2.6.16-ck1/include/linux/sched.h	2006-03-20 20:46:48.000000000 +1100
@@ -1064,7 +1064,7 @@ extern int FASTCALL(wake_up_process(stru
 extern void FASTCALL(wake_up_new_task(struct task_struct * tsk,
 						unsigned long clone_flags));
 #ifdef CONFIG_SMP
- extern void kick_process(struct task_struct *tsk);
+ extern void kick_process(const task_t *p);
 #else
  static inline void kick_process(struct task_struct *tsk) { }
 #endif
1	niro	70	include/linux/sched.h \| 2
2			kernel/sched.c \| 121 ++++++++++++++++++++++++++------------------------
3			2 files changed, 64 insertions(+), 59 deletions(-)
4
5			Index: linux-2.6.16-ck1/kernel/sched.c
6			===================================================================
7			--- linux-2.6.16-ck1.orig/kernel/sched.c 2006-03-20 20:46:48.000000000 +1100
8			+++ linux-2.6.16-ck1/kernel/sched.c 2006-03-20 20:46:48.000000000 +1100
9			@@ -194,7 +194,7 @@ for (domain = rcu_dereference(cpu_rq(cpu
10			#endif
11
12			#ifndef __ARCH_WANT_UNLOCKED_CTXSW
13			-static inline int task_running(runqueue_t rq, task_t p)
14			+static inline int task_running(const runqueue_t rq, const task_t p)
15			{
16			return rq->curr == p;
17			}
18			@@ -203,7 +203,7 @@ static inline void prepare_lock_switch(r
19			{
20			}
21
22			-static inline void finish_lock_switch(runqueue_t rq, task_t prev)
23			+static inline void finish_lock_switch(runqueue_t rq, task_t __unused)
24			{
25			#ifdef CONFIG_DEBUG_SPINLOCK
26			/* this is a valid case when another task releases the spinlock */
27			@@ -213,7 +213,7 @@ static inline void finish_lock_switch(ru
28			}
29
30			#else /* __ARCH_WANT_UNLOCKED_CTXSW */
31			-static inline int task_running(runqueue_t rq, task_t p)
32			+static inline int task_running(const runqueue_t rq, const task_t p)
33			{
34			#ifdef CONFIG_SMP
35			return p->oncpu;
36			@@ -239,7 +239,7 @@ static inline void prepare_lock_switch(r
37			#endif
38			}
39
40			-static inline void finish_lock_switch(runqueue_t rq, task_t prev)
41			+static inline void finish_lock_switch(runqueue_t __unused, task_t prev)
42			{
43			#ifdef CONFIG_SMP
44			/*
45			@@ -261,7 +261,7 @@ static inline void finish_lock_switch(ru
46			* interrupts. Note the ordering: we can safely lookup the task_rq without
47			* explicitly disabling preemption.
48			*/
49			-static inline runqueue_t task_rq_lock(task_t p, unsigned long *flags)
50			+static inline runqueue_t task_rq_lock(const task_t p, unsigned long *flags)
51			__acquires(rq->lock)
52			{
53			struct runqueue *rq;
54			@@ -611,7 +611,7 @@ static inline void inc_nr_running(task_t
55			inc_raw_weighted_load(rq, p);
56			}
57
58			-static inline void dec_nr_running(task_t p, runqueue_t rq)
59			+static inline void dec_nr_running(const task_t p, runqueue_t rq)
60			{
61			rq->nr_running--;
62			dec_raw_weighted_load(rq, p);
63			@@ -831,7 +831,7 @@ static void fastcall deactivate_task(tas
64			* the target CPU.
65			*/
66			#ifdef CONFIG_SMP
67			-static void resched_task(task_t *p)
68			+static void fastcall resched_task(task_t *p)
69			{
70			int cpu;
71
72			@@ -888,7 +888,7 @@ typedef struct {
73			* The task's runqueue lock must be held.
74			* Returns true if you have to wait for migration thread.
75			*/
76			-static int migrate_task(task_t p, int dest_cpu, migration_req_t req)
77			+static int migrate_task(task_t p, const int dest_cpu, migration_req_t req)
78			{
79			runqueue_t *rq = task_rq(p);
80
81			@@ -951,7 +951,7 @@ repeat:
82			* to another CPU then no harm is done and the purpose has been
83			* achieved as well.
84			*/
85			-void kick_process(task_t *p)
86			+void kick_process(const task_t *p)
87			{
88			int cpu;
89
90			@@ -1009,7 +1009,7 @@ static inline unsigned long cpu_avg_load
91			* domain.
92			*/
93			static struct sched_group *
94			-find_idlest_group(struct sched_domain sd, struct task_struct p, int this_cpu)
95			+find_idlest_group(struct sched_domain sd, task_t p, const int this_cpu)
96			{
97			struct sched_group idlest = NULL, this = NULL, *group = sd->groups;
98			unsigned long min_load = ULONG_MAX, this_load = 0;
99			@@ -1063,7 +1063,7 @@ nextgroup:
100			* find_idlest_queue - find the idlest runqueue among the cpus in group.
101			*/
102			static int
103			-find_idlest_cpu(struct sched_group group, struct task_struct p, int this_cpu)
104			+find_idlest_cpu(struct sched_group group, task_t p, const int this_cpu)
105			{
106			cpumask_t tmp;
107			unsigned long load, min_load = ULONG_MAX;
108			@@ -1096,7 +1096,7 @@ find_idlest_cpu(struct sched_group *grou
109			*
110			* preempt must be disabled.
111			*/
112			-static int sched_balance_self(int cpu, int flag)
113			+static int sched_balance_self(int cpu, const int flag)
114			{
115			struct task_struct *t = current;
116			struct sched_domain tmp, sd = NULL;
117			@@ -1148,7 +1148,7 @@ nextlevel:
118			* Returns the CPU we should wake onto.
119			*/
120			#if defined(ARCH_HAS_SCHED_WAKE_IDLE)
121			-static int wake_idle(int cpu, task_t *p)
122			+static int wake_idle(const int cpu, const task_t *p)
123			{
124			cpumask_t tmp;
125			struct sched_domain *sd;
126			@@ -1171,7 +1171,7 @@ static int wake_idle(int cpu, task_t *p)
127			return cpu;
128			}
129			#else
130			-static inline int wake_idle(int cpu, task_t *p)
131			+static inline int wake_idle(const int cpu, task_t *__unused)
132			{
133			return cpu;
134			}
135			@@ -1211,7 +1211,7 @@ static void fastcall preempt(const task_
136			*
137			* returns failure only if the task is already active.
138			*/
139			-static int try_to_wake_up(task_t *p, unsigned int state, int sync)
140			+static int try_to_wake_up(task_t *p, unsigned int state, const int sync)
141			{
142			int cpu, this_cpu, success = 0;
143			unsigned long flags;
144			@@ -1369,7 +1369,7 @@ int fastcall wake_up_state(task_t *p, un
145			* Perform scheduler related setup for a newly forked process p.
146			* p is forked by current.
147			*/
148			-void fastcall sched_fork(task_t *p, int clone_flags)
149			+void fastcall sched_fork(task_t *p, int __unused)
150			{
151			int cpu = get_cpu();
152
153			@@ -1406,7 +1406,7 @@ void fastcall sched_fork(task_t *p, int
154			* that must be done for every newly created context, then puts the task
155			* on the runqueue and wakes it.
156			*/
157			-void fastcall wake_up_new_task(task_t *p, unsigned long clone_flags)
158			+void fastcall wake_up_new_task(task_t *p, const unsigned long clone_flags)
159			{
160			unsigned long flags;
161			int this_cpu, cpu;
162			@@ -1690,7 +1690,7 @@ static void double_lock_balance(runqueue
163			* allow dest_cpu, which will force the cpu onto dest_cpu. Then
164			* the cpu_allowed mask is restored.
165			*/
166			-static void sched_migrate_task(task_t *p, int dest_cpu)
167			+static void sched_migrate_task(task_t *p, const int dest_cpu)
168			{
169			migration_req_t req;
170			runqueue_t *rq;
171			@@ -1869,8 +1869,8 @@ out:
172			* moved to restore balance via the imbalance parameter.
173			*/
174			static struct sched_group *
175			-find_busiest_group(struct sched_domain *sd, int this_cpu,
176			- unsigned long imbalance, enum idle_type idle, int sd_idle)
177			+find_busiest_group(struct sched_domain *sd, const int this_cpu,
178			+ unsigned long imbalance, const enum idle_type idle, int sd_idle)
179			{
180			struct sched_group busiest = NULL, this = NULL, *group = sd->groups;
181			unsigned long max_load, avg_load, total_load, this_load, total_pwr;
182			@@ -2035,7 +2035,7 @@ out_balanced:
183			* find_busiest_queue - find the busiest runqueue among the cpus in group.
184			*/
185			static runqueue_t find_busiest_queue(struct sched_group group,
186			- enum idle_type idle)
187			+ const enum idle_type idle)
188			{
189			unsigned long load, max_load = 0;
190			runqueue_t *busiest = NULL;
191			@@ -2066,8 +2066,8 @@ static runqueue_t *find_busiest_queue(st
192			*
193			* Called with this_rq unlocked.
194			*/
195			-static int load_balance(int this_cpu, runqueue_t *this_rq,
196			- struct sched_domain *sd, enum idle_type idle)
197			+static int load_balance(const int this_cpu, runqueue_t *this_rq,
198			+ struct sched_domain *sd, const enum idle_type idle)
199			{
200			struct sched_group *group;
201			runqueue_t *busiest;
202			@@ -2192,7 +2192,7 @@ out_one_pinned:
203			* Called from schedule when this_rq is about to become idle (NEWLY_IDLE).
204			* this_rq is locked.
205			*/
206			-static int load_balance_newidle(int this_cpu, runqueue_t *this_rq,
207			+static int load_balance_newidle(const int this_cpu, runqueue_t *this_rq,
208			struct sched_domain *sd)
209			{
210			struct sched_group *group;
211			@@ -2252,7 +2252,7 @@ out_balanced:
212			* idle_balance is called by schedule() if this_cpu is about to become
213			* idle. Attempts to pull tasks from other CPUs.
214			*/
215			-static void idle_balance(int this_cpu, runqueue_t *this_rq)
216			+static void idle_balance(const int this_cpu, runqueue_t *this_rq)
217			{
218			struct sched_domain *sd;
219
220			@@ -2274,7 +2274,7 @@ static void idle_balance(int this_cpu, r
221			*
222			* Called with busiest_rq locked.
223			*/
224			-static void active_load_balance(runqueue_t *busiest_rq, int busiest_cpu)
225			+static void active_load_balance(runqueue_t *busiest_rq, const int busiest_cpu)
226			{
227			struct sched_domain *sd;
228			runqueue_t *target_rq;
229			@@ -2328,8 +2328,8 @@ out:
230			/* Don't have all balancing operations going off at once */
231			#define CPU_OFFSET(cpu) (HZ * cpu / NR_CPUS)
232
233			-static void rebalance_tick(int this_cpu, runqueue_t *this_rq,
234			- enum idle_type idle)
235			+static void rebalance_tick(const int this_cpu, runqueue_t *this_rq,
236			+ enum idle_type idle)
237			{
238			unsigned long old_load, this_load;
239			unsigned long j = jiffies + CPU_OFFSET(this_cpu);
240			@@ -2416,8 +2416,8 @@ EXPORT_PER_CPU_SYMBOL(kstat);
241			* This is called on clock ticks and on context switches.
242			* Bank in p->sched_time the ns elapsed since the last tick or switch.
243			*/
244			-static inline void update_cpu_clock(task_t p, runqueue_t rq,
245			- unsigned long long now)
246			+static inline void update_cpu_clock(task_t p, const runqueue_t rq,
247			+ const unsigned long long now)
248			{
249			unsigned long long last = max(p->timestamp, rq->timestamp_last_tick);
250			p->sched_time += now - last;
251			@@ -2602,7 +2602,7 @@ static inline void wakeup_busy_runqueue(
252			resched_task(rq->idle);
253			}
254
255			-static void wake_sleeping_dependent(int this_cpu, runqueue_t *this_rq)
256			+static void wake_sleeping_dependent(const int this_cpu, runqueue_t *this_rq)
257			{
258			struct sched_domain tmp, sd = NULL;
259			cpumask_t sibling_map;
260			@@ -2657,7 +2657,7 @@ static inline unsigned long smt_slice(co
261			return p->slice * (100 - sd->per_cpu_gain) / 100;
262			}
263
264			-static int dependent_sleeper(int this_cpu, runqueue_t *this_rq)
265			+static int dependent_sleeper(const int this_cpu, runqueue_t *this_rq)
266			{
267			struct sched_domain tmp, sd = NULL;
268			cpumask_t sibling_map;
269			@@ -2765,7 +2765,7 @@ static inline int dependent_sleeper(int
270
271			#if defined(CONFIG_PREEMPT) && defined(CONFIG_DEBUG_PREEMPT)
272
273			-void fastcall add_preempt_count(int val)
274			+void fastcall add_preempt_count(const int val)
275			{
276			/*
277			* Underflow?
278			@@ -2779,7 +2779,7 @@ void fastcall add_preempt_count(int val)
279			}
280			EXPORT_SYMBOL(add_preempt_count);
281
282			-void fastcall sub_preempt_count(int val)
283			+void fastcall sub_preempt_count(const int val)
284			{
285			/*
286			* Underflow?
287			@@ -2813,8 +2813,8 @@ asmlinkage void __sched schedule(void)
288			* schedule() atomically, we ignore that path for now.
289			* Otherwise, whine if we are scheduling when we should not be.
290			*/
291			- if (likely(!current->exit_state)) {
292			- if (unlikely(in_atomic())) {
293			+ if (unlikely(in_atomic())) {
294			+ if (!current->exit_state) {
295			printk(KERN_ERR "scheduling while atomic: "
296			"%s/0x%08x/%d\n",
297			current->comm, preempt_count(), current->pid);
298			@@ -2850,7 +2850,6 @@ need_resched_nonpreemptible:
299			if (unlikely(prev->flags & PF_DEAD))
300			prev->state = EXIT_DEAD;
301
302			- switch_count = &prev->nivcsw;
303			if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) {
304			switch_count = &prev->nvcsw;
305			if (unlikely((prev->state & TASK_INTERRUPTIBLE) &&
306			@@ -2863,7 +2862,9 @@ need_resched_nonpreemptible:
307			}
308			deactivate_task(prev, rq);
309			}
310			- }
311			+ } else
312			+ switch_count = &prev->nivcsw;
313			+
314
315			cpu = smp_processor_id();
316			if (unlikely(!rq->nr_running)) {
317			@@ -3048,7 +3049,7 @@ EXPORT_SYMBOL(default_wake_function);
318			* zero in this (rare) case, and we handle it by continuing to scan the queue.
319			*/
320			static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
321			- int nr_exclusive, int sync, void *key)
322			+ int nr_exclusive, const int sync, void *key)
323			{
324			struct list_head tmp, next;
325
326			@@ -3340,7 +3341,7 @@ long fastcall __sched sleep_on_timeout(w
327
328			EXPORT_SYMBOL(sleep_on_timeout);
329
330			-void set_user_nice(task_t *p, long nice)
331			+void set_user_nice(task_t *p, const long nice)
332			{
333			unsigned long flags;
334			runqueue_t *rq;
335			@@ -3476,7 +3477,7 @@ EXPORT_SYMBOL_GPL(task_nice);
336			* idle_cpu - is a given cpu idle currently?
337			* @cpu: the processor in question.
338			*/
339			-int idle_cpu(int cpu)
340			+int idle_cpu(const int cpu)
341			{
342			return cpu_curr(cpu) == cpu_rq(cpu)->idle;
343			}
344			@@ -3485,7 +3486,7 @@ int idle_cpu(int cpu)
345			* idle_task - return the idle task for a given cpu.
346			* @cpu: the processor in question.
347			*/
348			-task_t *idle_task(int cpu)
349			+task_t *idle_task(const int cpu)
350			{
351			return cpu_rq(cpu)->idle;
352			}
353			@@ -3494,13 +3495,13 @@ task_t *idle_task(int cpu)
354			* find_process_by_pid - find a process with a matching PID value.
355			* @pid: the pid in question.
356			*/
357			-static inline task_t *find_process_by_pid(pid_t pid)
358			+static inline task_t *find_process_by_pid(const pid_t pid)
359			{
360			return pid ? find_task_by_pid(pid) : current;
361			}
362
363			/* Actually do priority change: must hold rq lock. */
364			-static void __setscheduler(struct task_struct *p, int policy, int prio)
365			+static void __setscheduler(task_t *p, const int policy, const int prio)
366			{
367			BUG_ON(task_queued(p));
368			p->policy = policy;
369			@@ -3608,7 +3609,8 @@ recheck:
370			EXPORT_SYMBOL_GPL(sched_setscheduler);
371
372			static int
373			-do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
374			+do_sched_setscheduler(const pid_t pid, int policy,
375			+ struct sched_param __user *param)
376			{
377			int retval;
378			struct sched_param lparam;
379			@@ -3635,7 +3637,7 @@ do_sched_setscheduler(pid_t pid, int pol
380			* @policy: new policy.
381			* @param: structure containing the new RT priority.
382			*/
383			-asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,
384			+asmlinkage long sys_sched_setscheduler(const pid_t pid, int policy,
385			struct sched_param __user *param)
386			{
387			/* negative values for policy are not valid */
388			@@ -3650,7 +3652,8 @@ asmlinkage long sys_sched_setscheduler(p
389			* @pid: the pid in question.
390			* @param: structure containing the new RT priority.
391			*/
392			-asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param __user *param)
393			+asmlinkage long sys_sched_setparam(const pid_t pid,
394			+ struct sched_param __user *param)
395			{
396			return do_sched_setscheduler(pid, -1, param);
397			}
398			@@ -3659,7 +3662,7 @@ asmlinkage long sys_sched_setparam(pid_t
399			* sys_sched_getscheduler - get the policy (scheduling class) of a thread
400			* @pid: the pid in question.
401			*/
402			-asmlinkage long sys_sched_getscheduler(pid_t pid)
403			+asmlinkage long sys_sched_getscheduler(const pid_t pid)
404			{
405			int retval = -EINVAL;
406			task_t *p;
407			@@ -3686,7 +3689,8 @@ out_nounlock:
408			* @pid: the pid in question.
409			* @param: structure containing the RT priority.
410			*/
411			-asmlinkage long sys_sched_getparam(pid_t pid, struct sched_param __user *param)
412			+asmlinkage long sys_sched_getparam(const pid_t pid,
413			+ struct sched_param __user *param)
414			{
415			struct sched_param lp;
416			int retval = -EINVAL;
417			@@ -3721,7 +3725,7 @@ out_unlock:
418			return retval;
419			}
420
421			-long sched_setaffinity(pid_t pid, cpumask_t new_mask)
422			+long sched_setaffinity(const pid_t pid, cpumask_t new_mask)
423			{
424			task_t *p;
425			int retval;
426			@@ -3777,7 +3781,7 @@ static int get_user_cpu_mask(unsigned lo
427			* @len: length in bytes of the bitmask pointed to by user_mask_ptr
428			* @user_mask_ptr: user-space pointer to the new cpu mask
429			*/
430			-asmlinkage long sys_sched_setaffinity(pid_t pid, unsigned int len,
431			+asmlinkage long sys_sched_setaffinity(const pid_t pid, unsigned int len,
432			unsigned long __user *user_mask_ptr)
433			{
434			cpumask_t new_mask;
435			@@ -3805,7 +3809,7 @@ cpumask_t cpu_online_map __read_mostly =
436			cpumask_t cpu_possible_map __read_mostly = CPU_MASK_ALL;
437			#endif
438
439			-long sched_getaffinity(pid_t pid, cpumask_t *mask)
440			+long sched_getaffinity(const pid_t pid, cpumask_t *mask)
441			{
442			int retval;
443			task_t *p;
444			@@ -3836,7 +3840,7 @@ out_unlock:
445			* @len: length in bytes of the bitmask pointed to by user_mask_ptr
446			* @user_mask_ptr: user-space pointer to hold the current cpu mask
447			*/
448			-asmlinkage long sys_sched_getaffinity(pid_t pid, unsigned int len,
449			+asmlinkage long sys_sched_getaffinity(const pid_t pid, unsigned int len,
450			unsigned long __user *user_mask_ptr)
451			{
452			int ret;
453			@@ -4017,7 +4021,7 @@ long __sched io_schedule_timeout(long ti
454			* this syscall returns the maximum rt_priority that can be used
455			* by a given scheduling class.
456			*/
457			-asmlinkage long sys_sched_get_priority_max(int policy)
458			+asmlinkage long sys_sched_get_priority_max(const int policy)
459			{
460			int ret = -EINVAL;
461
462			@@ -4041,7 +4045,7 @@ asmlinkage long sys_sched_get_priority_m
463			* this syscall returns the minimum rt_priority that can be used
464			* by a given scheduling class.
465			*/
466			-asmlinkage long sys_sched_get_priority_min(int policy)
467			+asmlinkage long sys_sched_get_priority_min(const int policy)
468			{
469			int ret = -EINVAL;
470
471			@@ -4066,7 +4070,8 @@ asmlinkage long sys_sched_get_priority_m
472			* into the user-space timespec buffer. A value of '0' means infinity.
473			*/
474			asmlinkage
475			-long sys_sched_rr_get_interval(pid_t pid, struct timespec __user *interval)
476			+long sys_sched_rr_get_interval(const pid_t pid,
477			+ struct timespec __user *interval)
478			{
479			int retval = -EINVAL;
480			struct timespec t;
481			@@ -4203,7 +4208,7 @@ void show_state(void)
482			* NOTE: this function does not set the idle thread's NEED_RESCHED
483			* flag, to make booting more robust.
484			*/
485			-void __devinit init_idle(task_t *idle, int cpu)
486			+void __devinit init_idle(task_t *idle, const int cpu)
487			{
488			runqueue_t *rq = cpu_rq(cpu);
489			unsigned long flags;
490			@@ -4306,7 +4311,7 @@ EXPORT_SYMBOL_GPL(set_cpus_allowed);
491			* So we race with normal scheduler movements, but that's OK, as long
492			* as the task is no longer on this CPU.
493			*/
494			-static void __migrate_task(struct task_struct *p, int src_cpu, int dest_cpu)
495			+static void __migrate_task(task_t *p, const int src_cpu, const int dest_cpu)
496			{
497			runqueue_t rq_dest, rq_src;
498
499			Index: linux-2.6.16-ck1/include/linux/sched.h
500			===================================================================
501			--- linux-2.6.16-ck1.orig/include/linux/sched.h 2006-03-20 20:46:48.000000000 +1100
502			+++ linux-2.6.16-ck1/include/linux/sched.h 2006-03-20 20:46:48.000000000 +1100
503			@@ -1064,7 +1064,7 @@ extern int FASTCALL(wake_up_process(stru
504			extern void FASTCALL(wake_up_new_task(struct task_struct * tsk,
505			unsigned long clone_flags));
506			#ifdef CONFIG_SMP
507			- extern void kick_process(struct task_struct *tsk);
508			+ extern void kick_process(const task_t *p);
509			#else
510			static inline void kick_process(struct task_struct *tsk) { }
511			#endif