kernel26-magellan/patches-2.6.21-r7/0004-2.6.21-sched-iso-5.4.patch

Add the SCHED_ISO policy (isochronous) which is a starvation free soft
realtime policy available to unprivileged users. The amount of cpu that
SCHED_ISO tasks will run as realtime is configurable by the tunable in

/proc/sys/kernel/iso_cpu

and is set to 80% by default.

The duration over which its cpu usage is averaged is controlled by the
tunable

/proc/sys/kernel/iso_period

and is set to 5 (seconds) by default.

Signed-off-by: Con Kolivas <kernel@kolivas.org>

 Documentation/sysctl/kernel.txt |   21 +++++++
 include/linux/sched.h           |    8 ++
 kernel/sched.c                  |  115 +++++++++++++++++++++++++++++++++++++---
 kernel/sysctl.c                 |   24 ++++++++
 4 files changed, 160 insertions(+), 8 deletions(-)

Index: linux-2.6.21-ck2/include/linux/sched.h
===================================================================
--- linux-2.6.21-ck2.orig/include/linux/sched.h	2007-05-14 19:30:30.000000000 +1000
+++ linux-2.6.21-ck2/include/linux/sched.h	2007-05-14 19:30:31.000000000 +1000
@@ -34,10 +34,11 @@
 #define SCHED_FIFO		1
 #define SCHED_RR		2
 #define SCHED_BATCH		3
+#define SCHED_ISO		4
 
 #ifdef __KERNEL__
 
-#define SCHED_MAX		SCHED_BATCH
+#define SCHED_MAX		SCHED_ISO
 #define SCHED_RANGE(policy)	((policy) <= SCHED_MAX)
 
 struct sched_param {
@@ -525,15 +526,17 @@ struct signal_struct {
 #define MAX_USER_RT_PRIO	100
 #define MAX_RT_PRIO		MAX_USER_RT_PRIO
 #define PRIO_RANGE		(40)
+#define ISO_PRIO		(MAX_RT_PRIO - 1)
 
 #define MAX_PRIO		(MAX_RT_PRIO + PRIO_RANGE)
 
-#define rt_prio(prio)		unlikely((prio) < MAX_RT_PRIO)
+#define rt_prio(prio)		unlikely((prio) < ISO_PRIO)
 #define rt_task(p)		rt_prio((p)->prio)
 #define batch_task(p)		(unlikely((p)->policy == SCHED_BATCH))
 #define is_rt_policy(policy)	((policy) == SCHED_FIFO || \
 					(policy) == SCHED_RR)
 #define has_rt_policy(p)	unlikely(is_rt_policy((p)->policy))
+#define iso_task(p)		unlikely((p)->policy == SCHED_ISO)
 
 /*
  * Some day this will be a full-fledged user tracking system..
@@ -1166,6 +1169,7 @@ static inline void put_task_struct(struc
 #define PF_SWAPWRITE	0x00800000	/* Allowed to write to swap */
 #define PF_SPREAD_PAGE	0x01000000	/* Spread page cache over cpuset */
 #define PF_SPREAD_SLAB	0x02000000	/* Spread some slab caches over cpuset */
+#define PF_ISOREF	0x04000000	/* SCHED_ISO task has used up quota */
 #define PF_MEMPOLICY	0x10000000	/* Non-default NUMA mempolicy */
 #define PF_MUTEX_TESTER	0x20000000	/* Thread belongs to the rt mutex tester */
 
Index: linux-2.6.21-ck2/kernel/sched.c
===================================================================
--- linux-2.6.21-ck2.orig/kernel/sched.c	2007-05-14 19:30:30.000000000 +1000
+++ linux-2.6.21-ck2/kernel/sched.c	2007-05-14 19:30:31.000000000 +1000
@@ -104,6 +104,18 @@ int rr_interval __read_mostly = 8;
 int sched_interactive __read_mostly = 1;
 
 /*
+ * sched_iso_cpu - sysctl which determines the cpu percentage SCHED_ISO tasks
+ * are allowed to run (over ISO_PERIOD seconds) as real time tasks.
+ * sched_iso_period - sysctl which determines the number of seconds over
+ * which cpu usage of SCHED_ISO tasks is averaged to determine if they are
+ * exceeding their allowable bandwidth.
+*/
+int sched_iso_cpu __read_mostly = 80;
+int sched_iso_period __read_mostly = 5;
+
+#define ISO_PERIOD	((sched_iso_period * HZ) + 1)
+
+/*
  * This contains a bitmap for each dynamic priority level with empty slots
  * for the valid priorities each different nice level can have. It allows
  * us to stagger the slots where differing priorities run in a way that
@@ -200,6 +212,8 @@ struct rq {
 
 	/* How many times we have rotated the priority queue */
 	unsigned long prio_rotation;
+	unsigned long iso_ticks;
+	unsigned short iso_refractory;
 
 	atomic_t nr_iowait;
 
@@ -790,6 +804,11 @@ static inline void update_if_moved(struc
 }
 #endif
 
+static inline int isoprio_suitable(struct task_struct *p)
+{
+	return !(p->flags & PF_ISOREF);
+}
+
 /*
  * recalc_task_prio determines what priority a non rt_task will be
  * queued at. If the task has already been running during this runqueue's
@@ -806,6 +825,25 @@ static void recalc_task_prio(struct task
 	struct prio_array *array = rq->active;
 	int queue_prio;
 
+	if (iso_task(p)) {
+		if (isoprio_suitable(p)) {
+			/*
+			 * If SCHED_ISO tasks have not used up their real time
+			 * quota they have run just better than highest
+			 * SCHED_NORMAL priority. Otherwise they run as
+			 * SCHED_NORMAL.
+			 */
+			p->prio = p->normal_prio = ISO_PRIO;
+			p->array = rq->active;
+			if (p->time_slice <= 0)
+				p->time_slice = p->quota;
+			return;
+		} else if (p->prio == ISO_PRIO) {
+			/* Just about to be demoted to SCHED_NORMAL */
+			p->time_slice = 0;
+		}
+	}
+
 	update_if_moved(p, rq);
 	if (p->rotation == rq->prio_rotation) {
 		if (p->array == array) {
@@ -3180,18 +3218,65 @@ static void task_expired_entitlement(str
 	p->time_slice += overrun;
 }
 
+/*
+ * Test if SCHED_ISO tasks have run longer than their alloted period as RT
+ * tasks and set the refractory flag if necessary. There is 10% hysteresis
+ * for unsetting the flag.
+ */
+static unsigned int test_ret_isorefractory(struct rq *rq)
+{
+	if (likely(!rq->iso_refractory)) {
+		if (rq->iso_ticks / ISO_PERIOD > sched_iso_cpu)
+			rq->iso_refractory = 1;
+	} else {
+		if (rq->iso_ticks / ISO_PERIOD < (sched_iso_cpu * 90 / 100))
+			rq->iso_refractory = 0;
+	}
+	return rq->iso_refractory;
+}
+
+/* No SCHED_ISO task was running so decrease rq->iso_ticks */
+static inline void no_iso_tick(struct rq *rq)
+{
+	rq->iso_ticks = rq->iso_ticks * (ISO_PERIOD - 1) / ISO_PERIOD;
+}
+
 /* This manages tasks that have run out of timeslice during a scheduler_tick */
 static void task_running_tick(struct rq *rq, struct task_struct *p)
 {
+	/*
+	 * If a SCHED_ISO task is running we increment the iso_ticks. In
+	 * order to prevent SCHED_ISO tasks from causing starvation in the
+	 * presence of true RT tasks we account those as iso_ticks as well.
+	 */
+	if ((rt_task(p) || (iso_task(p) && !rq->iso_refractory))) {
+		if (rq->iso_ticks <= (ISO_PERIOD * 100) - 100)
+			rq->iso_ticks += 100;
+	} else
+		no_iso_tick(rq);
+
+	if (iso_task(p)) {
+		if (unlikely(test_ret_isorefractory(rq))) {
+			if (isoprio_suitable(p)) {
+				/*
+				 * SCHED_ISO task is running as RT and limit
+				 * has been hit. Set the PF_ISOREF flag and
+				 * force it to reschedule as SCHED_NORMAL
+				 * by zeroing its time_slice
+				 */
+				p->flags |= PF_ISOREF;
+				p->time_slice = 0;
+			}
+		} else
+			p->flags &= ~PF_ISOREF;
+	}
 	/* SCHED_FIFO tasks never run out of timeslice. */
 	if (p->time_slice > 0 || p->policy == SCHED_FIFO)
 		return;
 	/* p->time_slice <= 0 */
-	spin_lock(&rq->lock);
+	set_tsk_need_resched(p);
 	if (likely(task_queued(p)))
 		task_expired_entitlement(rq, p);
-	set_tsk_need_resched(p);
-	spin_unlock(&rq->lock);
 }
 
 /*
@@ -3207,8 +3292,12 @@ void scheduler_tick(void)
 
 	update_cpu_clock(p, rq, now, 1);
 
+	spin_lock(&rq->lock);
 	if (p != rq->idle)
 		task_running_tick(rq, p);
+	else
+		no_iso_tick(rq);
+	spin_unlock(&rq->lock);
 #ifdef CONFIG_SMP
 	update_load(rq);
 	if (time_after_eq(jiffies, rq->next_balance))
@@ -3285,7 +3374,8 @@ retry:
 	}
 	queue = array->queue + idx;
 	next = list_entry(queue->next, struct task_struct, run_list);
-	if (unlikely(next->time_slice <= 0)) {
+	if (unlikely(next->time_slice <= 0 && !(iso_task(next) &&
+	    isoprio_suitable(next)))) {
 		/*
 		 * Unlucky enough that this task ran out of time_slice
 		 * before it hit a scheduler_tick so it should have its
@@ -3377,7 +3467,7 @@ need_resched_nonpreemptible:
 	}
 
 	idx = sched_find_first_bit(rq->dyn_bitmap);
-	if (!rt_prio(idx))
+	if (likely(idx > ISO_PRIO))
 		next = next_dynamic_task(rq, idx);
 	else {
 		queue = rq->active->queue + idx;
@@ -4042,12 +4132,22 @@ static void __setscheduler(struct task_s
 int sched_setscheduler(struct task_struct *p, int policy,
 		       struct sched_param *param)
 {
+	struct sched_param zero_param = { .sched_priority = 0 };
 	int queued, retval, oldprio, oldpolicy = -1;
 	unsigned long flags;
 	struct rq *rq;
 
 	/* may grab non-irq protected spin_locks */
 	BUG_ON(in_interrupt());
+	if (is_rt_policy(policy) && !capable(CAP_SYS_NICE)) {
+		/*
+		 * If the caller requested an RT policy without having the
+		 * necessary rights, we downgrade the policy to SCHED_ISO.
+		 * We also set the parameter to zero to pass the checks.
+		 */
+		policy = SCHED_ISO;
+		param = &zero_param;
+	}
 recheck:
 	/* double check policy once rq lock held */
 	if (policy < 0)
@@ -4577,6 +4677,7 @@ asmlinkage long sys_sched_get_priority_m
 		break;
 	case SCHED_NORMAL:
 	case SCHED_BATCH:
+	case SCHED_ISO:
 		ret = 0;
 		break;
 	}
@@ -4601,6 +4702,7 @@ asmlinkage long sys_sched_get_priority_m
 		break;
 	case SCHED_NORMAL:
 	case SCHED_BATCH:
+	case SCHED_ISO:
 		ret = 0;
 	}
 	return ret;
@@ -6708,6 +6810,7 @@ void __init sched_init(void)
 		rq = cpu_rq(i);
 		spin_lock_init(&rq->lock);
 		lockdep_set_class(&rq->lock, &rq->rq_lock_key);
+		rq->iso_ticks = 0;
 		rq->nr_running = 0;
 		rq->prio_rotation = 0;
 		rq->active = rq->arrays;
@@ -6801,7 +6904,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;
 
 		spin_lock_irqsave(&p->pi_lock, flags);
Index: linux-2.6.21-ck2/Documentation/sysctl/kernel.txt
===================================================================
--- linux-2.6.21-ck2.orig/Documentation/sysctl/kernel.txt	2007-05-14 19:30:30.000000000 +1000
+++ linux-2.6.21-ck2/Documentation/sysctl/kernel.txt	2007-05-14 19:30:31.000000000 +1000
@@ -26,6 +26,8 @@ show up in /proc/sys/kernel:
 - hostname
 - hotplug
 - interactive
+- iso_cpu
+- iso_period
 - java-appletviewer           [ binfmt_java, obsolete ]
 - java-interpreter            [ binfmt_java, obsolete ]
 - kstack_depth_to_print       [ X86 only ]
@@ -181,6 +183,25 @@ Default value is 1 (enabled).
 
 ==============================================================
 
+iso_cpu:
+
+This sets the percentage cpu that the unprivileged SCHED_ISO tasks can
+run effectively at realtime priority, averaged over a rolling iso_period
+seconds.
+
+Set to 80 (percent) by default.
+
+==============================================================
+
+iso_period:
+
+This sets the number of seconds over which SCHED_ISO cpu usage is averaged
+to see if it exceeds its allocated cpu bandwidth.
+
+Set to 5 (seconds) by default.
+
+==============================================================
+
 l2cr: (PPC only)
 
 This flag controls the L2 cache of G3 processor boards. If
Index: linux-2.6.21-ck2/kernel/sysctl.c
===================================================================
--- linux-2.6.21-ck2.orig/kernel/sysctl.c	2007-05-14 19:30:30.000000000 +1000
+++ linux-2.6.21-ck2/kernel/sysctl.c	2007-05-14 19:30:31.000000000 +1000
@@ -78,6 +78,8 @@ extern int percpu_pagelist_fraction;
 extern int compat_log;
 extern int rr_interval;
 extern int sched_interactive;
+extern int sched_iso_cpu;
+extern int sched_iso_period;
 
 /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
 static int maxolduid = 65535;
@@ -528,6 +530,28 @@ static ctl_table kern_table[] = {
 		.mode		= 0644,
 		.proc_handler	= &proc_dointvec,
 	},
+	{
+		.ctl_name	= CTL_UNNUMBERED,
+		.procname	= "iso_cpu",
+		.data		= &sched_iso_cpu,
+		.maxlen		= sizeof (int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dointvec_minmax,
+		.strategy	= &sysctl_intvec,
+		.extra1		= &zero,
+		.extra2		= &one_hundred,
+	},
+	{
+		.ctl_name	= CTL_UNNUMBERED,
+		.procname	= "iso_period",
+		.data		= &sched_iso_period,
+		.maxlen		= sizeof (int),
+		.mode		= 0644,
+		.proc_handler	= &proc_dointvec_minmax,
+		.strategy	= &sysctl_intvec,
+		.extra1		= &one,
+		.extra2		= &one_hundred,
+	},
 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
 	{
 		.ctl_name       = KERN_UNKNOWN_NMI_PANIC,
1	niro	269	Add the SCHED_ISO policy (isochronous) which is a starvation free soft
2			realtime policy available to unprivileged users. The amount of cpu that
3			SCHED_ISO tasks will run as realtime is configurable by the tunable in
4
5			/proc/sys/kernel/iso_cpu
6
7			and is set to 80% by default.
8
9			The duration over which its cpu usage is averaged is controlled by the
10			tunable
11
12			/proc/sys/kernel/iso_period
13
14			and is set to 5 (seconds) by default.
15
16			Signed-off-by: Con Kolivas <kernel@kolivas.org>
17
18			Documentation/sysctl/kernel.txt \| 21 +++++++
19			include/linux/sched.h \| 8 ++
20			kernel/sched.c \| 115 +++++++++++++++++++++++++++++++++++++---
21			kernel/sysctl.c \| 24 ++++++++
22			4 files changed, 160 insertions(+), 8 deletions(-)
23
24			Index: linux-2.6.21-ck2/include/linux/sched.h
25			===================================================================
26			--- linux-2.6.21-ck2.orig/include/linux/sched.h 2007-05-14 19:30:30.000000000 +1000
27			+++ linux-2.6.21-ck2/include/linux/sched.h 2007-05-14 19:30:31.000000000 +1000
28			@@ -34,10 +34,11 @@
29			#define SCHED_FIFO 1
30			#define SCHED_RR 2
31			#define SCHED_BATCH 3
32			+#define SCHED_ISO 4
33
34			#ifdef __KERNEL__
35
36			-#define SCHED_MAX SCHED_BATCH
37			+#define SCHED_MAX SCHED_ISO
38			#define SCHED_RANGE(policy) ((policy) <= SCHED_MAX)
39
40			struct sched_param {
41			@@ -525,15 +526,17 @@ struct signal_struct {
42			#define MAX_USER_RT_PRIO 100
43			#define MAX_RT_PRIO MAX_USER_RT_PRIO
44			#define PRIO_RANGE (40)
45			+#define ISO_PRIO (MAX_RT_PRIO - 1)
46
47			#define MAX_PRIO (MAX_RT_PRIO + PRIO_RANGE)
48
49			-#define rt_prio(prio) unlikely((prio) < MAX_RT_PRIO)
50			+#define rt_prio(prio) unlikely((prio) < ISO_PRIO)
51			#define rt_task(p) rt_prio((p)->prio)
52			#define batch_task(p) (unlikely((p)->policy == SCHED_BATCH))
53			#define is_rt_policy(policy) ((policy) == SCHED_FIFO \|\| \
54			(policy) == SCHED_RR)
55			#define has_rt_policy(p) unlikely(is_rt_policy((p)->policy))
56			+#define iso_task(p) unlikely((p)->policy == SCHED_ISO)
57
58			/*
59			* Some day this will be a full-fledged user tracking system..
60			@@ -1166,6 +1169,7 @@ static inline void put_task_struct(struc
61			#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
62			#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */
63			#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */
64			+#define PF_ISOREF 0x04000000 /* SCHED_ISO task has used up quota */
65			#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */
66			#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
67
68			Index: linux-2.6.21-ck2/kernel/sched.c
69			===================================================================
70			--- linux-2.6.21-ck2.orig/kernel/sched.c 2007-05-14 19:30:30.000000000 +1000
71			+++ linux-2.6.21-ck2/kernel/sched.c 2007-05-14 19:30:31.000000000 +1000
72			@@ -104,6 +104,18 @@ int rr_interval __read_mostly = 8;
73			int sched_interactive __read_mostly = 1;
74
75			/*
76			+ * sched_iso_cpu - sysctl which determines the cpu percentage SCHED_ISO tasks
77			+ * are allowed to run (over ISO_PERIOD seconds) as real time tasks.
78			+ * sched_iso_period - sysctl which determines the number of seconds over
79			+ * which cpu usage of SCHED_ISO tasks is averaged to determine if they are
80			+ * exceeding their allowable bandwidth.
81			+*/
82			+int sched_iso_cpu __read_mostly = 80;
83			+int sched_iso_period __read_mostly = 5;
84			+
85			+#define ISO_PERIOD ((sched_iso_period * HZ) + 1)
86			+
87			+/*
88			* This contains a bitmap for each dynamic priority level with empty slots
89			* for the valid priorities each different nice level can have. It allows
90			* us to stagger the slots where differing priorities run in a way that
91			@@ -200,6 +212,8 @@ struct rq {
92
93			/* How many times we have rotated the priority queue */
94			unsigned long prio_rotation;
95			+ unsigned long iso_ticks;
96			+ unsigned short iso_refractory;
97
98			atomic_t nr_iowait;
99
100			@@ -790,6 +804,11 @@ static inline void update_if_moved(struc
101			}
102			#endif
103
104			+static inline int isoprio_suitable(struct task_struct *p)
105			+{
106			+ return !(p->flags & PF_ISOREF);
107			+}
108			+
109			/*
110			* recalc_task_prio determines what priority a non rt_task will be
111			* queued at. If the task has already been running during this runqueue's
112			@@ -806,6 +825,25 @@ static void recalc_task_prio(struct task
113			struct prio_array *array = rq->active;
114			int queue_prio;
115
116			+ if (iso_task(p)) {
117			+ if (isoprio_suitable(p)) {
118			+ /*
119			+ * If SCHED_ISO tasks have not used up their real time
120			+ * quota they have run just better than highest
121			+ * SCHED_NORMAL priority. Otherwise they run as
122			+ * SCHED_NORMAL.
123			+ */
124			+ p->prio = p->normal_prio = ISO_PRIO;
125			+ p->array = rq->active;
126			+ if (p->time_slice <= 0)
127			+ p->time_slice = p->quota;
128			+ return;
129			+ } else if (p->prio == ISO_PRIO) {
130			+ /* Just about to be demoted to SCHED_NORMAL */
131			+ p->time_slice = 0;
132			+ }
133			+ }
134			+
135			update_if_moved(p, rq);
136			if (p->rotation == rq->prio_rotation) {
137			if (p->array == array) {
138			@@ -3180,18 +3218,65 @@ static void task_expired_entitlement(str
139			p->time_slice += overrun;
140			}
141
142			+/*
143			+ * Test if SCHED_ISO tasks have run longer than their alloted period as RT
144			+ * tasks and set the refractory flag if necessary. There is 10% hysteresis
145			+ * for unsetting the flag.
146			+ */
147			+static unsigned int test_ret_isorefractory(struct rq *rq)
148			+{
149			+ if (likely(!rq->iso_refractory)) {
150			+ if (rq->iso_ticks / ISO_PERIOD > sched_iso_cpu)
151			+ rq->iso_refractory = 1;
152			+ } else {
153			+ if (rq->iso_ticks / ISO_PERIOD < (sched_iso_cpu * 90 / 100))
154			+ rq->iso_refractory = 0;
155			+ }
156			+ return rq->iso_refractory;
157			+}
158			+
159			+/* No SCHED_ISO task was running so decrease rq->iso_ticks */
160			+static inline void no_iso_tick(struct rq *rq)
161			+{
162			+ rq->iso_ticks = rq->iso_ticks * (ISO_PERIOD - 1) / ISO_PERIOD;
163			+}
164			+
165			/* This manages tasks that have run out of timeslice during a scheduler_tick */
166			static void task_running_tick(struct rq rq, struct task_struct p)
167			{
168			+ /*
169			+ * If a SCHED_ISO task is running we increment the iso_ticks. In
170			+ * order to prevent SCHED_ISO tasks from causing starvation in the
171			+ * presence of true RT tasks we account those as iso_ticks as well.
172			+ */
173			+ if ((rt_task(p) \|\| (iso_task(p) && !rq->iso_refractory))) {
174			+ if (rq->iso_ticks <= (ISO_PERIOD * 100) - 100)
175			+ rq->iso_ticks += 100;
176			+ } else
177			+ no_iso_tick(rq);
178			+
179			+ if (iso_task(p)) {
180			+ if (unlikely(test_ret_isorefractory(rq))) {
181			+ if (isoprio_suitable(p)) {
182			+ /*
183			+ * SCHED_ISO task is running as RT and limit
184			+ * has been hit. Set the PF_ISOREF flag and
185			+ * force it to reschedule as SCHED_NORMAL
186			+ * by zeroing its time_slice
187			+ */
188			+ p->flags \|= PF_ISOREF;
189			+ p->time_slice = 0;
190			+ }
191			+ } else
192			+ p->flags &= ~PF_ISOREF;
193			+ }
194			/* SCHED_FIFO tasks never run out of timeslice. */
195			if (p->time_slice > 0 \|\| p->policy == SCHED_FIFO)
196			return;
197			/* p->time_slice <= 0 */
198			- spin_lock(&rq->lock);
199			+ set_tsk_need_resched(p);
200			if (likely(task_queued(p)))
201			task_expired_entitlement(rq, p);
202			- set_tsk_need_resched(p);
203			- spin_unlock(&rq->lock);
204			}
205
206			/*
207			@@ -3207,8 +3292,12 @@ void scheduler_tick(void)
208
209			update_cpu_clock(p, rq, now, 1);
210
211			+ spin_lock(&rq->lock);
212			if (p != rq->idle)
213			task_running_tick(rq, p);
214			+ else
215			+ no_iso_tick(rq);
216			+ spin_unlock(&rq->lock);
217			#ifdef CONFIG_SMP
218			update_load(rq);
219			if (time_after_eq(jiffies, rq->next_balance))
220			@@ -3285,7 +3374,8 @@ retry:
221			}
222			queue = array->queue + idx;
223			next = list_entry(queue->next, struct task_struct, run_list);
224			- if (unlikely(next->time_slice <= 0)) {
225			+ if (unlikely(next->time_slice <= 0 && !(iso_task(next) &&
226			+ isoprio_suitable(next)))) {
227			/*
228			* Unlucky enough that this task ran out of time_slice
229			* before it hit a scheduler_tick so it should have its
230			@@ -3377,7 +3467,7 @@ need_resched_nonpreemptible:
231			}
232
233			idx = sched_find_first_bit(rq->dyn_bitmap);
234			- if (!rt_prio(idx))
235			+ if (likely(idx > ISO_PRIO))
236			next = next_dynamic_task(rq, idx);
237			else {
238			queue = rq->active->queue + idx;
239			@@ -4042,12 +4132,22 @@ static void __setscheduler(struct task_s
240			int sched_setscheduler(struct task_struct *p, int policy,
241			struct sched_param *param)
242			{
243			+ struct sched_param zero_param = { .sched_priority = 0 };
244			int queued, retval, oldprio, oldpolicy = -1;
245			unsigned long flags;
246			struct rq *rq;
247
248			/* may grab non-irq protected spin_locks */
249			BUG_ON(in_interrupt());
250			+ if (is_rt_policy(policy) && !capable(CAP_SYS_NICE)) {
251			+ /*
252			+ * If the caller requested an RT policy without having the
253			+ * necessary rights, we downgrade the policy to SCHED_ISO.
254			+ * We also set the parameter to zero to pass the checks.
255			+ */
256			+ policy = SCHED_ISO;
257			+ param = &zero_param;
258			+ }
259			recheck:
260			/* double check policy once rq lock held */
261			if (policy < 0)
262			@@ -4577,6 +4677,7 @@ asmlinkage long sys_sched_get_priority_m
263			break;
264			case SCHED_NORMAL:
265			case SCHED_BATCH:
266			+ case SCHED_ISO:
267			ret = 0;
268			break;
269			}
270			@@ -4601,6 +4702,7 @@ asmlinkage long sys_sched_get_priority_m
271			break;
272			case SCHED_NORMAL:
273			case SCHED_BATCH:
274			+ case SCHED_ISO:
275			ret = 0;
276			}
277			return ret;
278			@@ -6708,6 +6810,7 @@ void __init sched_init(void)
279			rq = cpu_rq(i);
280			spin_lock_init(&rq->lock);
281			lockdep_set_class(&rq->lock, &rq->rq_lock_key);
282			+ rq->iso_ticks = 0;
283			rq->nr_running = 0;
284			rq->prio_rotation = 0;
285			rq->active = rq->arrays;
286			@@ -6801,7 +6904,7 @@ void normalize_rt_tasks(void)
287
288			read_lock_irq(&tasklist_lock);
289			for_each_process(p) {
290			- if (!rt_task(p))
291			+ if (!rt_task(p) && !iso_task(p))
292			continue;
293
294			spin_lock_irqsave(&p->pi_lock, flags);
295			Index: linux-2.6.21-ck2/Documentation/sysctl/kernel.txt
296			===================================================================
297			--- linux-2.6.21-ck2.orig/Documentation/sysctl/kernel.txt 2007-05-14 19:30:30.000000000 +1000
298			+++ linux-2.6.21-ck2/Documentation/sysctl/kernel.txt 2007-05-14 19:30:31.000000000 +1000
299			@@ -26,6 +26,8 @@ show up in /proc/sys/kernel:
300			- hostname
301			- hotplug
302			- interactive
303			+- iso_cpu
304			+- iso_period
305			- java-appletviewer [ binfmt_java, obsolete ]
306			- java-interpreter [ binfmt_java, obsolete ]
307			- kstack_depth_to_print [ X86 only ]
308			@@ -181,6 +183,25 @@ Default value is 1 (enabled).
309
310			==============================================================
311
312			+iso_cpu:
313			+
314			+This sets the percentage cpu that the unprivileged SCHED_ISO tasks can
315			+run effectively at realtime priority, averaged over a rolling iso_period
316			+seconds.
317			+
318			+Set to 80 (percent) by default.
319			+
320			+==============================================================
321			+
322			+iso_period:
323			+
324			+This sets the number of seconds over which SCHED_ISO cpu usage is averaged
325			+to see if it exceeds its allocated cpu bandwidth.
326			+
327			+Set to 5 (seconds) by default.
328			+
329			+==============================================================
330			+
331			l2cr: (PPC only)
332
333			This flag controls the L2 cache of G3 processor boards. If
334			Index: linux-2.6.21-ck2/kernel/sysctl.c
335			===================================================================
336			--- linux-2.6.21-ck2.orig/kernel/sysctl.c 2007-05-14 19:30:30.000000000 +1000
337			+++ linux-2.6.21-ck2/kernel/sysctl.c 2007-05-14 19:30:31.000000000 +1000
338			@@ -78,6 +78,8 @@ extern int percpu_pagelist_fraction;
339			extern int compat_log;
340			extern int rr_interval;
341			extern int sched_interactive;
342			+extern int sched_iso_cpu;
343			+extern int sched_iso_period;
344
345			/* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
346			static int maxolduid = 65535;
347			@@ -528,6 +530,28 @@ static ctl_table kern_table[] = {
348			.mode = 0644,
349			.proc_handler = &proc_dointvec,
350			},
351			+ {
352			+ .ctl_name = CTL_UNNUMBERED,
353			+ .procname = "iso_cpu",
354			+ .data = &sched_iso_cpu,
355			+ .maxlen = sizeof (int),
356			+ .mode = 0644,
357			+ .proc_handler = &proc_dointvec_minmax,
358			+ .strategy = &sysctl_intvec,
359			+ .extra1 = &zero,
360			+ .extra2 = &one_hundred,
361			+ },
362			+ {
363			+ .ctl_name = CTL_UNNUMBERED,
364			+ .procname = "iso_period",
365			+ .data = &sched_iso_period,
366			+ .maxlen = sizeof (int),
367			+ .mode = 0644,
368			+ .proc_handler = &proc_dointvec_minmax,
369			+ .strategy = &sysctl_intvec,
370			+ .extra1 = &one,
371			+ .extra2 = &one_hundred,
372			+ },
373			#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
374			{
375			.ctl_name = KERN_UNKNOWN_NMI_PANIC,