Index: linux-2.6.11.7-ISO/include/linux/init_task.h =================================================================== --- linux-2.6.11.7-ISO.orig/include/linux/init_task.h 2005-03-02 18:37:48.000000000 +1100 +++ linux-2.6.11.7-ISO/include/linux/init_task.h 2005-04-17 08:40:55.000000000 +1000 @@ -80,6 +80,7 @@ extern struct group_info init_groups; .mm = NULL, \ .active_mm = &init_mm, \ .run_list = LIST_HEAD_INIT(tsk.run_list), \ + .iso_list = LIST_HEAD_INIT(tsk.iso_list), \ .time_slice = HZ, \ .tasks = LIST_HEAD_INIT(tsk.tasks), \ .ptrace_children= LIST_HEAD_INIT(tsk.ptrace_children), \ Index: linux-2.6.11.7-ISO/include/linux/sched.h =================================================================== --- linux-2.6.11.7-ISO.orig/include/linux/sched.h 2005-03-02 18:37:48.000000000 +1100 +++ linux-2.6.11.7-ISO/include/linux/sched.h 2005-04-17 08:40:55.000000000 +1000 @@ -130,6 +130,26 @@ extern unsigned long nr_iowait(void); #define SCHED_NORMAL 0 #define SCHED_FIFO 1 #define SCHED_RR 2 +/* policy 3 reserved for SCHED_BATCH */ +#define SCHED_ISO_RR 4 +#define SCHED_ISO_FIFO 5 + +extern int iso_cpu, iso_period; + +#define SCHED_RANGE(policy) ((policy) == SCHED_NORMAL || \ + (policy) == SCHED_FIFO || \ + (policy) == SCHED_RR || \ + (policy) == SCHED_ISO_RR || \ + (policy) == SCHED_ISO_FIFO) + +#define SCHED_RT(policy) ((policy) == SCHED_FIFO || \ + (policy) == SCHED_RR) + +#define SCHED_ISO(policy) ((policy) == SCHED_ISO_RR || \ + (policy) == SCHED_ISO_FIFO) + +/* The policies that support a real time priority setting */ +#define SCHED_RT_PRIO(policy) (SCHED_RT(policy) || SCHED_ISO(policy)) struct sched_param { int sched_priority; @@ -351,14 +371,21 @@ struct signal_struct { * user-space. This allows kernel threads to set their * priority to a value higher than any user task. Note: * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO. + * + * SCHED_ISO tasks have a rt priority of the same range as + * real time tasks. They are seen as having either a priority + * of ISO_PRIO if below starvation limits or their underlying + * equivalent SCHED_NORMAL priority if above. */ #define MAX_USER_RT_PRIO 100 #define MAX_RT_PRIO MAX_USER_RT_PRIO +#define ISO_PRIO (MAX_RT_PRIO - 1) #define MAX_PRIO (MAX_RT_PRIO + 40) -#define rt_task(p) (unlikely((p)->prio < MAX_RT_PRIO)) +#define rt_task(p) (unlikely((p)->prio < ISO_PRIO)) +#define iso_task(p) (unlikely(SCHED_ISO((p)->policy))) /* * Some day this will be a full-fledged user tracking system.. @@ -536,6 +563,7 @@ struct task_struct { int prio, static_prio; struct list_head run_list; + struct list_head iso_list; prio_array_t *array; unsigned long sleep_avg; Index: linux-2.6.11.7-ISO/include/linux/sysctl.h =================================================================== --- linux-2.6.11.7-ISO.orig/include/linux/sysctl.h 2005-03-02 18:38:10.000000000 +1100 +++ linux-2.6.11.7-ISO/include/linux/sysctl.h 2005-04-17 08:40:55.000000000 +1000 @@ -135,6 +135,8 @@ enum KERN_HZ_TIMER=65, /* int: hz timer on or off */ KERN_UNKNOWN_NMI_PANIC=66, /* int: unknown nmi panic flag */ KERN_BOOTLOADER_TYPE=67, /* int: boot loader type */ + KERN_ISO_CPU=68, /* int: cpu% allowed by SCHED_ISO class */ + KERN_ISO_PERIOD=69, /* int: seconds over which SCHED_ISO cpu is decayed */ }; Index: linux-2.6.11.7-ISO/kernel/sched.c =================================================================== --- linux-2.6.11.7-ISO.orig/kernel/sched.c 2005-03-02 18:38:19.000000000 +1100 +++ linux-2.6.11.7-ISO/kernel/sched.c 2005-04-17 09:05:22.000000000 +1000 @@ -149,9 +149,6 @@ (JIFFIES_TO_NS(MAX_SLEEP_AVG * \ (MAX_BONUS / 2 + DELTA((p)) + 1) / MAX_BONUS - 1)) -#define TASK_PREEMPTS_CURR(p, rq) \ - ((p)->prio < (rq)->curr->prio) - /* * task_timeslice() scales user-nice values [ -20 ... 0 ... 19 ] * to time slice values: [800ms ... 100ms ... 5ms] @@ -171,6 +168,10 @@ static unsigned int task_timeslice(task_ else return SCALE_PRIO(DEF_TIMESLICE, p->static_prio); } + +int iso_cpu = 70; /* The soft %cpu limit on SCHED_ISO tasks */ +int iso_period = 5; /* The time over which SCHED_ISO cpu decays */ + #define task_hot(p, now, sd) ((long long) ((now) - (p)->last_ran) \ < (long long) (sd)->cache_hot_time) @@ -179,6 +180,8 @@ static unsigned int task_timeslice(task_ */ #define BITMAP_SIZE ((((MAX_PRIO+1+7)/8)+sizeof(long)-1)/sizeof(long)) +#define ISO_BITMAP_SIZE ((((MAX_USER_RT_PRIO+1+7)/8)+sizeof(long)-1)/ \ + sizeof(long)) typedef struct runqueue runqueue_t; @@ -206,6 +209,18 @@ struct runqueue { #ifdef CONFIG_SMP unsigned long cpu_load; #endif + unsigned long iso_ticks; + unsigned long iso_running; + unsigned long iso_bitmap[ISO_BITMAP_SIZE]; + struct list_head iso_queue[MAX_USER_RT_PRIO]; + int iso_refractory; + /* + * Refractory is the flag that we've hit the maximum iso cpu and are + * in the refractory period where SCHED_ISO tasks can only run as + * SCHED_NORMAL until their cpu usage drops to 90% of their iso_cpu + * limit. + */ + unsigned long long nr_switches; /* @@ -297,6 +312,31 @@ static DEFINE_PER_CPU(struct runqueue, r # define task_running(rq, p) ((rq)->curr == (p)) #endif +static int task_preempts_curr(task_t *p, runqueue_t *rq) +{ + int p_prio = p->prio, curr_prio = rq->curr->prio; + + if (!iso_task(p) && !iso_task(rq->curr)) + goto out; + if (likely(!rq->iso_refractory)) { + if (iso_task(p)) { + if (iso_task(rq->curr)) { + p_prio = -(p->rt_priority); + curr_prio = -(rq->curr->rt_priority); + goto out; + } + p_prio = ISO_PRIO; + goto out; + } + if (iso_task(rq->curr)) + curr_prio = ISO_PRIO; + } +out: + if (p_prio < curr_prio) + return 1; + return 0; +} + /* * task_rq_lock - lock the runqueue a given task resides on and disable * interrupts. Note the ordering: we can safely lookup the task_rq without @@ -560,18 +600,48 @@ static inline void sched_info_switch(tas #define sched_info_switch(t, next) do { } while (0) #endif /* CONFIG_SCHEDSTATS */ -/* - * Adding/removing a task to/from a priority array: - */ -static void dequeue_task(struct task_struct *p, prio_array_t *array) +/* We invert the ISO rt_priorities for queueing order */ +#define iso_prio(p) (ISO_PRIO - (p)->rt_priority) + +static void dequeue_iso_task(struct task_struct *p, runqueue_t *rq) +{ + rq->iso_running--; + list_del(&p->iso_list); + if (list_empty(rq->iso_queue + iso_prio(p))) + __clear_bit(iso_prio(p), rq->iso_bitmap); +} + +static inline void __dequeue_task(struct task_struct *p, prio_array_t *array) { array->nr_active--; list_del(&p->run_list); if (list_empty(array->queue + p->prio)) __clear_bit(p->prio, array->bitmap); } + +/* + * Adding/removing a task to/from a priority array: + */ +static void dequeue_task(struct task_struct *p, runqueue_t *rq, prio_array_t *array) +{ + if (iso_task(p)) + dequeue_iso_task(p, rq); + __dequeue_task(p, array); +} -static void enqueue_task(struct task_struct *p, prio_array_t *array) +/* + * SCHED_ISO tasks are queued on both runqueues. Their actual priority is + * either better than SCHED_NORMAL if below starvation limits, or + * their underlying SCHED_NORMAL dynamic priority. + */ +static void enqueue_iso_task(struct task_struct *p, runqueue_t *rq) +{ + list_add_tail(&p->iso_list, rq->iso_queue + iso_prio(p)); + __set_bit(iso_prio(p), rq->iso_bitmap); + rq->iso_running++; +} + +static inline void __enqueue_task(struct task_struct *p, prio_array_t *array) { sched_info_queued(p); list_add_tail(&p->run_list, array->queue + p->prio); @@ -580,13 +650,27 @@ static void enqueue_task(struct task_str p->array = array; } +static void enqueue_task(struct task_struct *p, runqueue_t *rq, prio_array_t *array) +{ + __enqueue_task(p, array); + if (iso_task(p)) + enqueue_iso_task(p, rq); +} + +static void requeue_iso_task(struct task_struct *p, runqueue_t *rq) +{ + list_move_tail(&p->iso_list, rq->iso_queue + iso_prio(p)); +} + /* * Put task to the end of the run list without the overhead of dequeue * followed by enqueue. */ -static void requeue_task(struct task_struct *p, prio_array_t *array) +static void requeue_task(struct task_struct *p, runqueue_t *rq, prio_array_t *array) { list_move_tail(&p->run_list, array->queue + p->prio); + if (iso_task(p)) + requeue_iso_task(p, rq); } static inline void enqueue_task_head(struct task_struct *p, prio_array_t *array) @@ -633,7 +717,7 @@ static int effective_prio(task_t *p) */ static inline void __activate_task(task_t *p, runqueue_t *rq) { - enqueue_task(p, rq->active); + enqueue_task(p, rq, rq->active); rq->nr_running++; } @@ -762,7 +846,7 @@ static void activate_task(task_t *p, run static void deactivate_task(struct task_struct *p, runqueue_t *rq) { rq->nr_running--; - dequeue_task(p, p->array); + dequeue_task(p, rq, p->array); p->array = NULL; } @@ -1107,7 +1191,7 @@ out_activate: */ activate_task(p, rq, cpu == this_cpu); if (!sync || cpu != this_cpu) { - if (TASK_PREEMPTS_CURR(p, rq)) + if (task_preempts_curr(p, rq)) resched_task(rq->curr); } success = 1; @@ -1152,6 +1236,7 @@ void fastcall sched_fork(task_t *p) */ p->state = TASK_RUNNING; INIT_LIST_HEAD(&p->run_list); + INIT_LIST_HEAD(&p->iso_list); p->array = NULL; spin_lock_init(&p->switch_lock); #ifdef CONFIG_SCHEDSTATS @@ -1241,6 +1326,8 @@ void fastcall wake_up_new_task(task_t * p->array = current->array; p->array->nr_active++; rq->nr_running++; + if (iso_task(p)) + enqueue_iso_task(p, rq); } set_need_resched(); } else @@ -1263,7 +1350,7 @@ void fastcall wake_up_new_task(task_t * p->timestamp = (p->timestamp - this_rq->timestamp_last_tick) + rq->timestamp_last_tick; __activate_task(p, rq); - if (TASK_PREEMPTS_CURR(p, rq)) + if (task_preempts_curr(p, rq)) resched_task(rq->curr); schedstat_inc(rq, wunt_moved); @@ -1629,18 +1716,18 @@ static inline void pull_task(runqueue_t *src_rq, prio_array_t *src_array, task_t *p, runqueue_t *this_rq, prio_array_t *this_array, int this_cpu) { - dequeue_task(p, src_array); + dequeue_task(p, src_rq, src_array); src_rq->nr_running--; set_task_cpu(p, this_cpu); this_rq->nr_running++; - enqueue_task(p, this_array); + enqueue_task(p, this_rq, this_array); p->timestamp = (p->timestamp - src_rq->timestamp_last_tick) + this_rq->timestamp_last_tick; /* * Note that idle threads have a prio of MAX_PRIO, for this test * to be always true for them. */ - if (TASK_PREEMPTS_CURR(p, this_rq)) + if (task_preempts_curr(p, this_rq)) resched_task(this_rq->curr); } @@ -2402,6 +2489,25 @@ void account_steal_time(struct task_stru cpustat->steal = cputime64_add(cpustat->steal, tmp); } +static inline void inc_iso_ticks(runqueue_t *rq) +{ + if (rq->iso_ticks < (iso_period * HZ * 100 - 99)) + rq->iso_ticks += 100; + if (unlikely(!rq->iso_refractory && (rq->iso_ticks / + ((iso_period * HZ) + 1) > iso_cpu))) + rq->iso_refractory = 1; +} + +static inline void dec_iso_ticks(runqueue_t *rq) +{ + if (rq->iso_ticks) + rq->iso_ticks = rq->iso_ticks * (iso_period * HZ - 1) / + (iso_period * HZ); + if (unlikely(rq->iso_refractory && (rq->iso_ticks / + ((iso_period * HZ) + 1) < (iso_cpu * 9 / 10)))) + rq->iso_refractory = 0; +} + /* * This function gets called by the timer code, with HZ frequency. * We call it with interrupts disabled. @@ -2418,6 +2524,7 @@ void scheduler_tick(void) rq->timestamp_last_tick = sched_clock(); if (p == rq->idle) { + dec_iso_ticks(rq); if (wake_priority_sleeper(rq)) goto out; rebalance_tick(cpu, rq, SCHED_IDLE); @@ -2430,6 +2537,7 @@ void scheduler_tick(void) goto out; } spin_lock(&rq->lock); + /* * The task was running during this tick - update the * time slice counter. Note: we do not update a thread's @@ -2438,22 +2546,52 @@ void scheduler_tick(void) * to use up their timeslices at their highest priority levels. */ if (rt_task(p)) { - /* - * RR tasks need a special form of timeslice management. - * FIFO tasks have no timeslices. - */ - if ((p->policy == SCHED_RR) && !--p->time_slice) { - p->time_slice = task_timeslice(p); - p->first_time_slice = 0; - set_tsk_need_resched(p); + if (p->policy == SCHED_RR) + goto sched_rr; + goto sched_fifo; + } + if (iso_task(p)) { + if (unlikely(rq->iso_refractory)) + /* + * If we are in the refractory period for SCHED_ISO + * tasks we schedule them as SCHED_NORMAL. Otherwise + * schedule them as their rt equivalents. + */ + goto sched_normal; + if (p->policy == SCHED_ISO_RR) + goto sched_rr; + goto sched_fifo; + } + goto sched_normal; - /* put it at the end of the queue: */ - requeue_task(p, rq->active); - } - goto out_unlock; +sched_rr: + /* + * RR tasks need a special form of timeslice management. + */ + if (!--p->time_slice) { + p->time_slice = task_timeslice(p); + p->first_time_slice = 0; + set_tsk_need_resched(p); + + /* put it at the end of the queue: */ + requeue_task(p, rq, rq->active); } + +sched_fifo: + /* + * The iso_ticks accounting is incremented only when a SCHED_ISO task + * is running in soft rt mode. Running rt_tasks are also accounted + * to make the iso_cpu a proportion of cpu available for SCHED_NORMAL + * tasks only. + */ + inc_iso_ticks(rq); + /* FIFO tasks have no timeslices. */ + goto out_unlock; + +sched_normal: + dec_iso_ticks(rq); if (!--p->time_slice) { - dequeue_task(p, rq->active); + dequeue_task(p, rq, rq->active); set_tsk_need_resched(p); p->prio = effective_prio(p); p->time_slice = task_timeslice(p); @@ -2462,11 +2600,11 @@ void scheduler_tick(void) if (!rq->expired_timestamp) rq->expired_timestamp = jiffies; if (!TASK_INTERACTIVE(p) || EXPIRED_STARVING(rq)) { - enqueue_task(p, rq->expired); + enqueue_task(p, rq, rq->expired); if (p->static_prio < rq->best_expired_prio) rq->best_expired_prio = p->static_prio; } else - enqueue_task(p, rq->active); + enqueue_task(p, rq, rq->active); } else { /* * Prevent a too long timeslice allowing a task to monopolize @@ -2489,7 +2627,7 @@ void scheduler_tick(void) (p->time_slice >= TIMESLICE_GRANULARITY(p)) && (p->array == rq->active)) { - requeue_task(p, rq->active); + requeue_task(p, rq, rq->active); set_tsk_need_resched(p); } } @@ -2499,6 +2637,41 @@ out: rebalance_tick(cpu, rq, NOT_IDLE); } +static inline int iso_ready(runqueue_t *rq) +{ + if (rq->iso_running && !rq->iso_refractory) + return 1; + return 0; +} + +/* + * When a SCHED_ISO task is ready to be scheduled, we ensure it is queued + * on the active array. + */ +static task_t* find_iso(runqueue_t *rq, prio_array_t *array) +{ + prio_array_t *old_array; + task_t *p; + int idx = find_first_bit(rq->iso_bitmap, MAX_USER_RT_PRIO); + + p = list_entry(rq->iso_queue[idx].next, task_t, iso_list); + if (p->array == array) + goto out; + old_array = p->array; + __dequeue_task(p, old_array); + __enqueue_task(p, array); +out: + return p; +} + +static inline task_t* find_next_task(runqueue_t *rq, prio_array_t *array) +{ + int idx = sched_find_first_bit(array->bitmap); + if (unlikely(iso_ready(rq) && idx > ISO_PRIO)) + return find_iso(rq, array); + return list_entry(array->queue[idx].next, task_t, run_list); +} + #ifdef CONFIG_SCHED_SMT static inline void wake_sleeping_dependent(int this_cpu, runqueue_t *this_rq) { @@ -2577,8 +2750,7 @@ static inline int dependent_sleeper(int array = this_rq->expired; BUG_ON(!array->nr_active); - p = list_entry(array->queue[sched_find_first_bit(array->bitmap)].next, - task_t, run_list); + p = find_next_task(this_rq, array); for_each_cpu_mask(i, sibling_map) { runqueue_t *smt_rq = cpu_rq(i); @@ -2594,7 +2766,7 @@ static inline int dependent_sleeper(int */ if (((smt_curr->time_slice * (100 - sd->per_cpu_gain) / 100) > task_timeslice(p) || rt_task(smt_curr)) && - p->mm && smt_curr->mm && !rt_task(p)) + p->mm && smt_curr->mm && !rt_task(p) && !iso_task(p)) ret = 1; /* @@ -2603,9 +2775,10 @@ static inline int dependent_sleeper(int * reasons. */ if ((((p->time_slice * (100 - sd->per_cpu_gain) / 100) > - task_timeslice(smt_curr) || rt_task(p)) && - smt_curr->mm && p->mm && !rt_task(smt_curr)) || - (smt_curr == smt_rq->idle && smt_rq->nr_running)) + task_timeslice(smt_curr) || rt_task(p) || + iso_task(p)) && smt_curr->mm && p->mm && + !rt_task(smt_curr)) || (smt_curr == smt_rq->idle && + smt_rq->nr_running)) resched_task(smt_curr); } out_unlock: @@ -2665,10 +2838,9 @@ asmlinkage void __sched schedule(void) task_t *prev, *next; runqueue_t *rq; prio_array_t *array; - struct list_head *queue; unsigned long long now; unsigned long run_time; - int cpu, idx; + int cpu; /* * Test if we are atomic. Since do_exit() needs to call into @@ -2776,20 +2948,19 @@ go_idle: } else schedstat_inc(rq, sched_noswitch); - idx = sched_find_first_bit(array->bitmap); - queue = array->queue + idx; - next = list_entry(queue->next, task_t, run_list); - - if (!rt_task(next) && next->activated > 0) { - unsigned long long delta = now - next->timestamp; - - if (next->activated == 1) - delta = delta * (ON_RUNQUEUE_WEIGHT * 128 / 100) / 128; - - array = next->array; - dequeue_task(next, array); - recalc_task_prio(next, next->timestamp + delta); - enqueue_task(next, array); + next = find_next_task(rq, array); + + if (!rt_task(next) && !(iso_task(next) && !rq->iso_refractory) && + next->activated > 0) { + unsigned long long delta = now - next->timestamp; + + if (next->activated == 1) + delta = delta * + (ON_RUNQUEUE_WEIGHT * 128 / 100) / 128; + array = next->array; + dequeue_task(next, rq, array); + recalc_task_prio(next, next->timestamp + delta); + enqueue_task(next, rq, array); } next->activated = 0; switch_tasks: @@ -3250,7 +3421,7 @@ void set_user_nice(task_t *p, long nice) } array = p->array; if (array) - dequeue_task(p, array); + dequeue_task(p, rq, array); old_prio = p->prio; new_prio = NICE_TO_PRIO(nice); @@ -3259,7 +3430,7 @@ void set_user_nice(task_t *p, long nice) p->prio += delta; if (array) { - enqueue_task(p, array); + enqueue_task(p, rq, array); /* * If the task increased its priority or is running and * lowered its priority, then reschedule its CPU: @@ -3327,6 +3498,10 @@ asmlinkage long sys_nice(int increment) */ int task_prio(const task_t *p) { + if (iso_task(p)) + return -(p->rt_priority); + if (rt_task(p)) + return -(MAX_RT_PRIO + p->rt_priority); return p->prio - MAX_RT_PRIO; } @@ -3383,7 +3558,7 @@ static void __setscheduler(struct task_s BUG_ON(p->array); p->policy = policy; p->rt_priority = prio; - if (policy != SCHED_NORMAL) + if (SCHED_RT(policy)) p->prio = MAX_USER_RT_PRIO-1 - p->rt_priority; else p->prio = p->static_prio; @@ -3405,25 +3580,36 @@ int sched_setscheduler(struct task_struc runqueue_t *rq; recheck: + if (SCHED_RT(policy) && !capable(CAP_SYS_NICE)) { + /* + * If the caller requested an RT policy without having the + * necessary rights, we downgrade the policy to the + * SCHED_ISO equivalent. + */ + if ((policy) == SCHED_RR) + policy = SCHED_ISO_RR; + else + policy = SCHED_ISO_FIFO; + } + /* double check policy once rq lock held */ if (policy < 0) policy = oldpolicy = p->policy; - else if (policy != SCHED_FIFO && policy != SCHED_RR && - policy != SCHED_NORMAL) - return -EINVAL; + else if (!SCHED_RANGE(policy)) + return -EINVAL; /* - * Valid priorities for SCHED_FIFO and SCHED_RR are + * Valid priorities for SCHED_FIFO, SCHED_RR and SCHED_ISO are * 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_NORMAL is 0. */ if (param->sched_priority < 0 || param->sched_priority > MAX_USER_RT_PRIO-1) return -EINVAL; - if ((policy == SCHED_NORMAL) != (param->sched_priority == 0)) + if (SCHED_RT(policy) && !capable(CAP_SYS_NICE)) + return -EPERM; + + if ((!SCHED_RT_PRIO(policy)) != (param->sched_priority == 0)) return -EINVAL; - if ((policy == SCHED_FIFO || policy == SCHED_RR) && - !capable(CAP_SYS_NICE)) - return -EPERM; if ((current->euid != p->euid) && (current->euid != p->uid) && !capable(CAP_SYS_NICE)) return -EPERM; @@ -3457,7 +3643,7 @@ recheck: if (task_running(rq, p)) { if (p->prio > oldprio) resched_task(rq->curr); - } else if (TASK_PREEMPTS_CURR(p, rq)) + } else if (task_preempts_curr(p, rq)) resched_task(rq->curr); } task_rq_unlock(rq, &flags); @@ -3737,13 +3923,13 @@ asmlinkage long sys_sched_yield(void) schedstat_inc(rq, yld_exp_empty); if (array != target) { - dequeue_task(current, array); - enqueue_task(current, target); + dequeue_task(current, rq, array); + enqueue_task(current, rq, target); } else /* * requeue_task is cheaper so perform that if possible. */ - requeue_task(current, array); + requeue_task(current, rq, array); /* * Since we are going to call schedule() anyway, there's @@ -3881,6 +4067,8 @@ asmlinkage long sys_sched_get_priority_m switch (policy) { case SCHED_FIFO: case SCHED_RR: + case SCHED_ISO_RR: + case SCHED_ISO_FIFO: ret = MAX_USER_RT_PRIO-1; break; case SCHED_NORMAL: @@ -3904,6 +4092,8 @@ asmlinkage long sys_sched_get_priority_m switch (policy) { case SCHED_FIFO: case SCHED_RR: + case SCHED_ISO_RR: + case SCHED_ISO_FIFO: ret = 1; break; case SCHED_NORMAL: @@ -4180,7 +4370,7 @@ static void __migrate_task(struct task_s + rq_dest->timestamp_last_tick; deactivate_task(p, rq_src); activate_task(p, rq_dest, 0); - if (TASK_PREEMPTS_CURR(p, rq_dest)) + if (task_preempts_curr(p, rq_dest)) resched_task(rq_dest->curr); } @@ -4962,6 +5152,7 @@ void __init sched_init(void) rq->active = rq->arrays; rq->expired = rq->arrays + 1; rq->best_expired_prio = MAX_PRIO; + rq->iso_refractory = rq->iso_ticks = rq->iso_running = 0; #ifdef CONFIG_SMP rq->sd = &sched_domain_dummy; @@ -4982,6 +5173,11 @@ void __init sched_init(void) // delimiter for bitsearch __set_bit(MAX_PRIO, array->bitmap); } + for (j = 0; j < MAX_USER_RT_PRIO; j++) { + INIT_LIST_HEAD(rq->iso_queue + j); + __clear_bit(j, rq->iso_bitmap); + } + __set_bit(MAX_USER_RT_PRIO, rq->iso_bitmap); } /* @@ -5031,7 +5227,7 @@ void normalize_rt_tasks(void) read_lock_irq(&tasklist_lock); for_each_process (p) { - if (!rt_task(p)) + if (!rt_task(p) && !iso_task(p)) continue; rq = task_rq_lock(p, &flags); Index: linux-2.6.11.7-ISO/kernel/sysctl.c =================================================================== --- linux-2.6.11.7-ISO.orig/kernel/sysctl.c 2005-03-02 18:37:48.000000000 +1100 +++ linux-2.6.11.7-ISO/kernel/sysctl.c 2005-04-17 08:40:55.000000000 +1000 @@ -218,6 +218,11 @@ static ctl_table root_table[] = { { .ctl_name = 0 } }; +/* Constants for minimum and maximum testing in vm_table. + We use these as one-element integer vectors. */ +static int zero; +static int one_hundred = 100; + static ctl_table kern_table[] = { { .ctl_name = KERN_OSTYPE, @@ -632,15 +637,28 @@ static ctl_table kern_table[] = { .proc_handler = &proc_dointvec, }, #endif + { + .ctl_name = KERN_ISO_CPU, + .procname = "iso_cpu", + .data = &iso_cpu, + .maxlen = sizeof(int), + .mode = 0644, + .proc_handler = &proc_dointvec_minmax, + .strategy = &sysctl_intvec, + .extra1 = &zero, + .extra2 = &one_hundred, + }, + { + .ctl_name = KERN_ISO_PERIOD, + .procname = "iso_period", + .data = &iso_period, + .maxlen = sizeof(int), + .mode = 0644, + .proc_handler = &proc_dointvec, + }, { .ctl_name = 0 } }; -/* Constants for minimum and maximum testing in vm_table. - We use these as one-element integer vectors. */ -static int zero; -static int one_hundred = 100; - - static ctl_table vm_table[] = { { .ctl_name = VM_OVERCOMMIT_MEMORY,