From: Ingo Molnar - sched.c style cleanups (no code change) kernel/sched.c | 176 +++++++++++++++++++++++++++++++-------------------------- 1 files changed, 97 insertions(+), 79 deletions(-) diff -puN kernel/sched.c~sched-style-2.6.0-A5 kernel/sched.c --- 25/kernel/sched.c~sched-style-2.6.0-A5 2003-12-30 17:05:41.000000000 -0800 +++ 25-akpm/kernel/sched.c 2003-12-30 17:05:41.000000000 -0800 @@ -79,13 +79,13 @@ */ #define MIN_TIMESLICE ( 10 * HZ / 1000) #define MAX_TIMESLICE (200 * HZ / 1000) -#define ON_RUNQUEUE_WEIGHT 30 -#define CHILD_PENALTY 95 +#define ON_RUNQUEUE_WEIGHT 30 +#define CHILD_PENALTY 95 #define PARENT_PENALTY 100 -#define EXIT_WEIGHT 3 -#define PRIO_BONUS_RATIO 25 +#define EXIT_WEIGHT 3 +#define PRIO_BONUS_RATIO 25 #define MAX_BONUS (MAX_USER_PRIO * PRIO_BONUS_RATIO / 100) -#define INTERACTIVE_DELTA 2 +#define INTERACTIVE_DELTA 2 #define MAX_SLEEP_AVG (AVG_TIMESLICE * MAX_BONUS) #define STARVATION_LIMIT (MAX_SLEEP_AVG) #define NS_MAX_SLEEP_AVG (JIFFIES_TO_NS(MAX_SLEEP_AVG)) @@ -143,7 +143,7 @@ #define TASK_INTERACTIVE(p) \ ((p)->prio <= (p)->static_prio - DELTA(p)) -#define JUST_INTERACTIVE_SLEEP(p) \ +#define INTERACTIVE_SLEEP(p) \ (JIFFIES_TO_NS(MAX_SLEEP_AVG * \ (MAX_BONUS / 2 + DELTA((p)) + 1) / MAX_BONUS - 1)) @@ -168,7 +168,8 @@ */ #define BASE_TIMESLICE(p) (MIN_TIMESLICE + \ - ((MAX_TIMESLICE - MIN_TIMESLICE) * (MAX_PRIO-1-(p)->static_prio)/(MAX_USER_PRIO - 1))) + ((MAX_TIMESLICE - MIN_TIMESLICE) * \ + (MAX_PRIO-1 - (p)->static_prio) / (MAX_USER_PRIO-1))) static inline unsigned int task_timeslice(task_t *p) { @@ -199,7 +200,7 @@ struct prio_array { struct runqueue { spinlock_t lock; unsigned long nr_running, nr_switches, expired_timestamp, - nr_uninterruptible, timestamp_last_tick; + nr_uninterruptible, timestamp_last_tick; task_t *curr, *idle; struct mm_struct *prev_mm; prio_array_t *active, *expired, arrays[2]; @@ -225,7 +226,7 @@ static DEFINE_PER_CPU(struct runqueue, r * Default context-switch locking: */ #ifndef prepare_arch_switch -# define prepare_arch_switch(rq, next) do { } while(0) +# define prepare_arch_switch(rq, next) do { } while (0) # define finish_arch_switch(rq, next) spin_unlock_irq(&(rq)->lock) # define task_running(rq, p) ((rq)->curr == (p)) #endif @@ -269,9 +270,9 @@ __init void node_nr_running_init(void) #else /* !CONFIG_NUMA */ -# define nr_running_init(rq) do { } while (0) -# define nr_running_inc(rq) do { (rq)->nr_running++; } while (0) -# define nr_running_dec(rq) do { (rq)->nr_running--; } while (0) +# define nr_running_init(rq) do { } while (0) +# define nr_running_inc(rq) do { (rq)->nr_running++; } while (0) +# define nr_running_dec(rq) do { (rq)->nr_running--; } while (0) #endif /* CONFIG_NUMA */ @@ -396,7 +397,7 @@ static void recalc_task_prio(task_t *p, * other processes. */ if (p->mm && p->activated != -1 && - sleep_time > JUST_INTERACTIVE_SLEEP(p)){ + sleep_time > INTERACTIVE_SLEEP(p)) { p->sleep_avg = JIFFIES_TO_NS(MAX_SLEEP_AVG - AVG_TIMESLICE); if (!HIGH_CREDIT(p)) @@ -413,37 +414,35 @@ static void recalc_task_prio(task_t *p, * one timeslice worth of sleep avg bonus. */ if (LOW_CREDIT(p) && - sleep_time > JIFFIES_TO_NS(task_timeslice(p))) - sleep_time = - JIFFIES_TO_NS(task_timeslice(p)); + sleep_time > JIFFIES_TO_NS(task_timeslice(p))) + sleep_time = JIFFIES_TO_NS(task_timeslice(p)); /* * Non high_credit tasks waking from uninterruptible * sleep are limited in their sleep_avg rise as they * are likely to be cpu hogs waiting on I/O */ - if (p->activated == -1 && !HIGH_CREDIT(p) && p->mm){ - if (p->sleep_avg >= JUST_INTERACTIVE_SLEEP(p)) + if (p->activated == -1 && !HIGH_CREDIT(p) && p->mm) { + if (p->sleep_avg >= INTERACTIVE_SLEEP(p)) sleep_time = 0; else if (p->sleep_avg + sleep_time >= - JUST_INTERACTIVE_SLEEP(p)){ - p->sleep_avg = - JUST_INTERACTIVE_SLEEP(p); - sleep_time = 0; - } + INTERACTIVE_SLEEP(p)) { + p->sleep_avg = INTERACTIVE_SLEEP(p); + sleep_time = 0; + } } /* * This code gives a bonus to interactive tasks. * * The boost works by updating the 'average sleep time' - * value here, based on ->timestamp. The more time a task - * spends sleeping, the higher the average gets - and the - * higher the priority boost gets as well. + * value here, based on ->timestamp. The more time a + * task spends sleeping, the higher the average gets - + * and the higher the priority boost gets as well. */ p->sleep_avg += sleep_time; - if (p->sleep_avg > NS_MAX_SLEEP_AVG){ + if (p->sleep_avg > NS_MAX_SLEEP_AVG) { p->sleep_avg = NS_MAX_SLEEP_AVG; if (!HIGH_CREDIT(p)) p->interactive_credit++; @@ -470,7 +469,7 @@ static inline void activate_task(task_t * This checks to make sure it's not an uninterruptible task * that is now waking up. */ - if (!p->activated){ + if (!p->activated) { /* * Tasks which were woken up by interrupts (ie. hw events) * are most likely of interactive nature. So we give them @@ -480,13 +479,14 @@ static inline void activate_task(task_t */ if (in_interrupt()) p->activated = 2; - else - /* - * Normal first-time wakeups get a credit too for on-runqueue - * time, but it will be weighted down: - */ + else { + /* + * Normal first-time wakeups get a credit too for + * on-runqueue time, but it will be weighted down: + */ p->activated = 1; } + } p->timestamp = now; __activate_task(p, rq); @@ -632,13 +632,14 @@ repeat_lock_task: */ if (unlikely(sync && !task_running(rq, p) && (task_cpu(p) != smp_processor_id()) && - cpu_isset(smp_processor_id(), p->cpus_allowed))) { + cpu_isset(smp_processor_id(), + p->cpus_allowed))) { set_task_cpu(p, smp_processor_id()); task_rq_unlock(rq, &flags); goto repeat_lock_task; } - if (old_state == TASK_UNINTERRUPTIBLE){ + if (old_state == TASK_UNINTERRUPTIBLE) { rq->nr_uninterruptible--; /* * Tasks on involuntary sleep don't earn @@ -663,7 +664,8 @@ repeat_lock_task: } int wake_up_process(task_t * p) { - return try_to_wake_up(p, TASK_STOPPED | TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE, 0); + return try_to_wake_up(p, TASK_STOPPED | + TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE, 0); } EXPORT_SYMBOL(wake_up_process); @@ -698,7 +700,7 @@ void sched_fork(task_t *p) * resulting in more scheduling fairness. */ local_irq_disable(); - p->time_slice = (current->time_slice + 1) >> 1; + p->time_slice = (current->time_slice + 1) >> 1; /* * The remainder of the first timeslice might be recovered by * the parent if the child exits early enough. @@ -847,7 +849,8 @@ asmlinkage void schedule_tail(task_t *pr * context_switch - switch to the new MM and the new * thread's register state. */ -static inline task_t * context_switch(runqueue_t *rq, task_t *prev, task_t *next) +static inline +task_t * context_switch(runqueue_t *rq, task_t *prev, task_t *next) { struct mm_struct *mm = next->mm; struct mm_struct *oldmm = prev->active_mm; @@ -995,10 +998,10 @@ static int sched_best_cpu(struct task_st minload = 10000000; for_each_node_with_cpus(i) { /* - * Node load is always divided by nr_cpus_node to normalise + * Node load is always divided by nr_cpus_node to normalise * load values in case cpu count differs from node to node. * We first multiply node_nr_running by 10 to get a little - * better resolution. + * better resolution. */ load = 10 * atomic_read(&node_nr_running[i]) / nr_cpus_node(i); if (load < minload) { @@ -1037,7 +1040,7 @@ void sched_balance_exec(void) * load_{t} = load_{t-1}/2 + nr_node_running_{t} * This way sudden load peaks are flattened out a bit. * Node load is divided by nr_cpus_node() in order to compare nodes - * of different cpu count but also [first] multiplied by 10 to + * of different cpu count but also [first] multiplied by 10 to * provide better resolution. */ static int find_busiest_node(int this_node) @@ -1075,8 +1078,10 @@ static int find_busiest_node(int this_no * this_rq is locked already. Recalculate nr_running if we have to * drop the runqueue lock. */ -static inline unsigned int double_lock_balance(runqueue_t *this_rq, - runqueue_t *busiest, int this_cpu, int idle, unsigned int nr_running) +static inline +unsigned int double_lock_balance(runqueue_t *this_rq, runqueue_t *busiest, + int this_cpu, int idle, + unsigned int nr_running) { if (unlikely(!spin_trylock(&busiest->lock))) { if (busiest < this_rq) { @@ -1084,7 +1089,8 @@ static inline unsigned int double_lock_b spin_lock(&busiest->lock); spin_lock(&this_rq->lock); /* Need to recalculate nr_running */ - if (idle || (this_rq->nr_running > this_rq->prev_cpu_load[this_cpu])) + if (idle || (this_rq->nr_running > + this_rq->prev_cpu_load[this_cpu])) nr_running = this_rq->nr_running; else nr_running = this_rq->prev_cpu_load[this_cpu]; @@ -1097,7 +1103,9 @@ static inline unsigned int double_lock_b /* * find_busiest_queue - find the busiest runqueue among the cpus in cpumask. */ -static inline runqueue_t *find_busiest_queue(runqueue_t *this_rq, int this_cpu, int idle, int *imbalance, cpumask_t cpumask) +static inline +runqueue_t *find_busiest_queue(runqueue_t *this_rq, int this_cpu, int idle, + int *imbalance, cpumask_t cpumask) { int nr_running, load, max_load, i; runqueue_t *busiest, *rq_src; @@ -1160,7 +1168,8 @@ static inline runqueue_t *find_busiest_q goto out; } - nr_running = double_lock_balance(this_rq, busiest, this_cpu, idle, nr_running); + nr_running = double_lock_balance(this_rq, busiest, this_cpu, + idle, nr_running); /* * Make sure nothing changed since we checked the * runqueue length. @@ -1177,14 +1186,17 @@ out: * pull_task - move a task from a remote runqueue to the local runqueue. * Both runqueues must be locked. */ -static inline void pull_task(runqueue_t *src_rq, prio_array_t *src_array, task_t *p, runqueue_t *this_rq, int this_cpu) +static inline +void pull_task(runqueue_t *src_rq, prio_array_t *src_array, task_t *p, + runqueue_t *this_rq, int this_cpu) { dequeue_task(p, src_array); nr_running_dec(src_rq); set_task_cpu(p, this_cpu); nr_running_inc(this_rq); enqueue_task(p, this_rq->active); - p->timestamp = sched_clock() - (src_rq->timestamp_last_tick - p->timestamp); + p->timestamp = sched_clock() - + (src_rq->timestamp_last_tick - p->timestamp); /* * Note that idle threads have a prio of MAX_PRIO, for this test * to be always true for them. @@ -1196,8 +1208,8 @@ static inline void pull_task(runqueue_t /* * can_migrate_task - may task p from runqueue rq be migrated to this_cpu? */ -static inline int -can_migrate_task(task_t *tsk, runqueue_t *rq, int this_cpu, int idle) +static inline +int can_migrate_task(task_t *tsk, runqueue_t *rq, int this_cpu, int idle) { unsigned long delta = rq->timestamp_last_tick - tsk->timestamp; @@ -1232,7 +1244,8 @@ static void load_balance(runqueue_t *thi struct list_head *head, *curr; task_t *tmp; - busiest = find_busiest_queue(this_rq, this_cpu, idle, &imbalance, cpumask); + busiest = find_busiest_queue(this_rq, this_cpu, idle, + &imbalance, cpumask); if (!busiest) goto out; @@ -1374,7 +1387,7 @@ static inline void rebalance_tick(runque } #endif -DEFINE_PER_CPU(struct kernel_stat, kstat) = { { 0 } }; +DEFINE_PER_CPU(struct kernel_stat, kstat); EXPORT_PER_CPU_SYMBOL(kstat); @@ -1392,7 +1405,7 @@ EXPORT_PER_CPU_SYMBOL(kstat); ((STARVATION_LIMIT && ((rq)->expired_timestamp && \ (jiffies - (rq)->expired_timestamp >= \ STARVATION_LIMIT * ((rq)->nr_running) + 1))) || \ - ((rq)->curr->static_prio > (rq)->best_expired_prio)) + ((rq)->curr->static_prio > (rq)->best_expired_prio)) /* * This function gets called by the timer code, with HZ frequency. @@ -1623,7 +1636,7 @@ switch_tasks: RCU_qsctr(task_cpu(prev))++; prev->sleep_avg -= run_time; - if ((long)prev->sleep_avg <= 0){ + if ((long)prev->sleep_avg <= 0) { prev->sleep_avg = 0; if (!(HIGH_CREDIT(prev) || LOW_CREDIT(prev))) prev->interactive_credit--; @@ -1700,7 +1713,8 @@ EXPORT_SYMBOL(default_wake_function); * started to run but is not in state TASK_RUNNING. try_to_wake_up() returns * 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) +static void __wake_up_common(wait_queue_head_t *q, unsigned int mode, + int nr_exclusive, int sync) { struct list_head *tmp, *next; @@ -1777,7 +1791,8 @@ void complete(struct completion *x) spin_lock_irqsave(&x->wait.lock, flags); x->done++; - __wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1, 0); + __wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, + 1, 0); spin_unlock_irqrestore(&x->wait.lock, flags); } @@ -1789,7 +1804,8 @@ void complete_all(struct completion *x) spin_lock_irqsave(&x->wait.lock, flags); x->done += UINT_MAX/2; - __wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 0, 0); + __wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, + 0, 0); spin_unlock_irqrestore(&x->wait.lock, flags); } @@ -1816,9 +1832,9 @@ void wait_for_completion(struct completi EXPORT_SYMBOL(wait_for_completion); -#define SLEEP_ON_VAR \ - unsigned long flags; \ - wait_queue_t wait; \ +#define SLEEP_ON_VAR \ + unsigned long flags; \ + wait_queue_t wait; \ init_waitqueue_entry(&wait, current); #define SLEEP_ON_HEAD \ @@ -1826,9 +1842,9 @@ EXPORT_SYMBOL(wait_for_completion); __add_wait_queue(q, &wait); \ spin_unlock(&q->lock); -#define SLEEP_ON_TAIL \ - spin_lock_irq(&q->lock); \ - __remove_wait_queue(q, &wait); \ +#define SLEEP_ON_TAIL \ + spin_lock_irq(&q->lock); \ + __remove_wait_queue(q, &wait); \ spin_unlock_irqrestore(&q->lock, flags); void interruptible_sleep_on(wait_queue_head_t *q) @@ -1960,9 +1976,9 @@ asmlinkage long sys_nice(int increment) long nice; /* - * Setpriority might change our priority at the same moment. - * We don't have to worry. Conceptually one call occurs first - * and we have a single winner. + * Setpriority might change our priority at the same moment. + * We don't have to worry. Conceptually one call occurs first + * and we have a single winner. */ if (increment < 0) { if (!capable(CAP_SYS_NICE)) @@ -2142,7 +2158,7 @@ out_nounlock: * @param: structure containing the new RT priority. */ asmlinkage long sys_sched_setscheduler(pid_t pid, int policy, - struct sched_param __user *param) + struct sched_param __user *param) { return setscheduler(pid, policy, param); } @@ -2449,7 +2465,8 @@ asmlinkage long sys_sched_get_priority_m * this syscall writes the default timeslice value of a given process * 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) +asmlinkage +long sys_sched_rr_get_interval(pid_t pid, struct timespec __user *interval) { int retval = -EINVAL; struct timespec t; @@ -2695,7 +2712,7 @@ static void move_task_away(struct task_s } p->timestamp = rq_dest->timestamp_last_tick; - out: +out: double_rq_unlock(this_rq(), rq_dest); local_irq_restore(flags); } @@ -2764,11 +2781,10 @@ static int migration_thread(void * data) * migration_call - callback that gets triggered when a CPU is added. * Here we can start up the necessary migration thread for the new CPU. */ -static int migration_call(struct notifier_block *nfb, - unsigned long action, +static int migration_call(struct notifier_block *nfb, unsigned long action, void *hcpu) { - long cpu = (long) hcpu; + long cpu = (long)hcpu; migration_startup_t startup; switch (action) { @@ -2797,7 +2813,8 @@ static int migration_call(struct notifie return NOTIFY_OK; } -static struct notifier_block migration_notifier = { &migration_call, NULL, 0 }; +static struct notifier_block migration_notifier + = { .notifier_call = &migration_call }; __init int migration_init(void) { @@ -2833,7 +2850,7 @@ static void kstat_init_cpu(int cpu) } static int __devinit kstat_cpu_notify(struct notifier_block *self, - unsigned long action, void *hcpu) + unsigned long action, void *hcpu) { int cpu = (unsigned long)hcpu; switch(action) { @@ -2847,13 +2864,14 @@ static int __devinit kstat_cpu_notify(st } static struct notifier_block __devinitdata kstat_nb = { - .notifier_call = kstat_cpu_notify, - .next = NULL, + .notifier_call = kstat_cpu_notify, + .next = NULL, }; -__init static void init_kstat(void) { +__init static void init_kstat(void) +{ kstat_cpu_notify(&kstat_nb, (unsigned long)CPU_UP_PREPARE, - (void *)(long)smp_processor_id()); + (void *)(long)smp_processor_id()); register_cpu_notifier(&kstat_nb); } @@ -2919,7 +2937,7 @@ void __might_sleep(char *file, int line) printk(KERN_ERR "Debug: sleeping function called from invalid" " context at %s:%d\n", file, line); printk("in_atomic():%d, irqs_disabled():%d\n", - in_atomic(), irqs_disabled()); + in_atomic(), irqs_disabled()); dump_stack(); } #endif _