kernel26-alx/patches-2.6.20-r5/0005-2.6.20-sched-iso-4.7.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% (over 3 seconds) by default.

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

 Documentation/sysctl/kernel.txt |    9 ++++
 include/linux/sched.h           |   10 +++--
 kernel/sched.c                  |   77 ++++++++++++++++++++++++++++++++++++----
 kernel/sysctl.c                 |   25 +++++++++---
 4 files changed, 106 insertions(+), 15 deletions(-)

Index: linux-2.6.20-ck1/include/linux/sched.h
===================================================================
--- linux-2.6.20-ck1.orig/include/linux/sched.h	2007-02-16 19:01:30.000000000 +1100
+++ linux-2.6.20-ck1/include/linux/sched.h	2007-02-16 19:01:31.000000000 +1100
@@ -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 {
@@ -219,7 +220,7 @@ extern void show_stack(struct task_struc
 
 void io_schedule(void);
 long io_schedule_timeout(long timeout);
-extern int sched_interactive, sched_compute;
+extern int sched_interactive, sched_compute, sched_iso_cpu;
 
 extern void cpu_init (void);
 extern void trap_init(void);
@@ -526,16 +527,18 @@ struct signal_struct {
 
 #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 MIN_USER_PRIO		(MAX_PRIO - 1)
 
-#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..
@@ -1151,6 +1154,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 */
 #define PF_NONSLEEP	0x40000000	/* Waiting on in kernel activity */
Index: linux-2.6.20-ck1/kernel/sched.c
===================================================================
--- linux-2.6.20-ck1.orig/kernel/sched.c	2007-02-16 19:01:30.000000000 +1100
+++ linux-2.6.20-ck1/kernel/sched.c	2007-02-16 19:01:31.000000000 +1100
@@ -65,10 +65,14 @@
  * raise its priority.
  * sched_compute - sysctl which enables long timeslices and delayed preemption
  * for compute server usage.
+ * sched_iso_cpu - sysctl which determines the cpu percentage SCHED_ISO tasks
+ * are allowed to run (over ISO_PERIOD seconds) as real time tasks.
  */
 int sched_interactive __read_mostly = 1;
 int sched_compute __read_mostly;
+int sched_iso_cpu __read_mostly = 80;
 
+#define ISO_PERIOD		(5 * HZ)
 /*
  * CACHE_DELAY is the time preemption is delayed in sched_compute mode
  * and is set to a nominal 10ms.
@@ -143,6 +147,8 @@ struct rq {
 	/* Cached timestamp set by update_cpu_clock() */
 	unsigned long long most_recent_timestamp;
 	unsigned short cache_ticks, preempted;
+	unsigned long iso_ticks;
+	unsigned short iso_refractory;
 	struct task_struct *curr, *idle;
 	unsigned long next_balance;
 	struct mm_struct *prev_mm;
@@ -878,6 +884,17 @@ static inline int __normal_prio(struct t
 	unsigned int full_slice, used_slice = 0;
 	unsigned int best_bonus, rr;
 
+	if (iso_task(p)) {
+		if (likely(!(p->flags & PF_ISOREF)))
+			/*
+			 * 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.
+			 */
+			return ISO_PRIO;
+	}
+
 	full_slice = slice(p);
 	if (full_slice > p->slice)
 		used_slice = full_slice - p->slice;
@@ -2990,6 +3007,23 @@ static void time_slice_expired(struct ta
 	requeue_task(p, rq, effective_prio(p));
 }
 
+/*
+ * 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 inline 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;
+}
+
 static void task_running_tick(struct rq *rq, struct task_struct *p)
 {
 	unsigned long debit;
@@ -2999,11 +3033,29 @@ static void task_running_tick(struct rq 
 		set_tsk_need_resched(p);
 		return;
 	}
-	/* SCHED_FIFO tasks never run out of timeslice. */
-	if (unlikely(p->policy == SCHED_FIFO))
-		return;
 
 	spin_lock(&rq->lock);
+	if (unlikely((rt_task(p) || (iso_task(p) && !rq->iso_refractory)) &&
+	    p->mm)) {
+			if (rq->iso_ticks <= (ISO_PERIOD * 100) - 100)
+				rq->iso_ticks += 100;
+	} else
+		rq->iso_ticks = rq->iso_ticks * (ISO_PERIOD - 1) / ISO_PERIOD;
+
+	if (iso_task(p)) {
+		if (unlikely(test_ret_isorefractory(rq))) {
+			if (!(p->flags & PF_ISOREF)) {
+				set_tsk_need_resched(p);
+				p->flags |= PF_ISOREF;
+			}
+		} else
+			p->flags &= ~PF_ISOREF;
+	} else {
+		/* SCHED_FIFO tasks never run out of timeslice. */
+		if (unlikely(p->policy == SCHED_FIFO))
+			goto out_unlock;
+	}
+
 	debit = ns_diff(rq->most_recent_timestamp, p->timestamp);
 	p->ns_debit += debit;
 	if (p->ns_debit < NSJIFFY)
@@ -3122,7 +3174,7 @@ dependent_sleeper(int this_cpu, struct r
 	int ret = 0, i;
 
 	/* kernel/rt threads do not participate in dependent sleeping */
-	if (!p->mm || rt_task(p))
+	if (!p->mm || rt_task(p) || iso_task(p))
 		return 0;
 
 	for_each_domain(this_cpu, tmp) {
@@ -3159,7 +3211,7 @@ dependent_sleeper(int this_cpu, struct r
 		 * task from using an unfair proportion of the
 		 * physical cpu's resources. -ck
 		 */
-		if (rt_task(smt_curr)) {
+		if (rt_task(smt_curr) || iso_task(smt_curr)) {
 			/*
 			 * With real time tasks we run non-rt tasks only
 			 * per_cpu_gain% of the time.
@@ -3971,12 +4023,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)
@@ -4501,6 +4563,7 @@ asmlinkage long sys_sched_get_priority_m
 		break;
 	case SCHED_NORMAL:
 	case SCHED_BATCH:
+	case SCHED_ISO:
 		ret = 0;
 		break;
 	}
@@ -4525,6 +4588,7 @@ asmlinkage long sys_sched_get_priority_m
 		break;
 	case SCHED_NORMAL:
 	case SCHED_BATCH:
+	case SCHED_ISO:
 		ret = 0;
 	}
 	return ret;
@@ -6647,7 +6711,8 @@ void __init sched_init(void)
 		rq = cpu_rq(i);
 		spin_lock_init(&rq->lock);
 		lockdep_set_class(&rq->lock, &rq->rq_lock_key);
-		rq->nr_running = rq->cache_ticks = rq->preempted = 0;
+		rq->nr_running = rq->cache_ticks = rq->preempted =
+			rq->iso_ticks = 0;
 
 #ifdef CONFIG_SMP
 		rq->sd = NULL;
Index: linux-2.6.20-ck1/kernel/sysctl.c
===================================================================
--- linux-2.6.20-ck1.orig/kernel/sysctl.c	2007-02-16 19:01:30.000000000 +1100
+++ linux-2.6.20-ck1/kernel/sysctl.c	2007-02-16 19:01:31.000000000 +1100
@@ -273,6 +273,14 @@ static ctl_table root_table[] = {
 	{ .ctl_name = 0 }
 };
 
+
+/*
+ * Constants for minimum and maximum testing.
+ * 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,
@@ -692,6 +700,17 @@ 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,
+	},
 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
 	{
 		.ctl_name       = KERN_UNKNOWN_NMI_PANIC,
@@ -800,12 +819,6 @@ static ctl_table kern_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 vm_table[] = {
 	{
 		.ctl_name	= VM_OVERCOMMIT_MEMORY,
Index: linux-2.6.20-ck1/Documentation/sysctl/kernel.txt
===================================================================
--- linux-2.6.20-ck1.orig/Documentation/sysctl/kernel.txt	2007-02-16 19:01:30.000000000 +1100
+++ linux-2.6.20-ck1/Documentation/sysctl/kernel.txt	2007-02-16 19:01:31.000000000 +1100
@@ -27,6 +27,7 @@ show up in /proc/sys/kernel:
 - hostname
 - hotplug
 - interactive
+- iso_cpu
 - java-appletviewer           [ binfmt_java, obsolete ]
 - java-interpreter            [ binfmt_java, obsolete ]
 - kstack_depth_to_print       [ X86 only ]
@@ -185,6 +186,14 @@ are obeyed if this tunable is disabled. 
 
 ==============================================================
 
+iso_cpu:
+
+This sets the percentage cpu that the unprivileged SCHED_ISO tasks can
+run effectively at realtime priority, averaged over a rolling 3 seconds.
+Set to 80% by default.
+
+==============================================================
+
 l2cr: (PPC only)
 
 This flag controls the L2 cache of G3 processor boards. If
1	niro	199	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% (over 3 seconds) by default.
8
9			Signed-off-by: Con Kolivas <kernel@kolivas.org>
10
11			Documentation/sysctl/kernel.txt \| 9 ++++
12			include/linux/sched.h \| 10 +++--
13			kernel/sched.c \| 77 ++++++++++++++++++++++++++++++++++++----
14			kernel/sysctl.c \| 25 +++++++++---
15			4 files changed, 106 insertions(+), 15 deletions(-)
16
17			Index: linux-2.6.20-ck1/include/linux/sched.h
18			===================================================================
19			--- linux-2.6.20-ck1.orig/include/linux/sched.h 2007-02-16 19:01:30.000000000 +1100
20			+++ linux-2.6.20-ck1/include/linux/sched.h 2007-02-16 19:01:31.000000000 +1100
21			@@ -34,10 +34,11 @@
22			#define SCHED_FIFO 1
23			#define SCHED_RR 2
24			#define SCHED_BATCH 3
25			+#define SCHED_ISO 4
26
27			#ifdef __KERNEL__
28
29			-#define SCHED_MAX SCHED_BATCH
30			+#define SCHED_MAX SCHED_ISO
31			#define SCHED_RANGE(policy) ((policy) <= SCHED_MAX)
32
33			struct sched_param {
34			@@ -219,7 +220,7 @@ extern void show_stack(struct task_struc
35
36			void io_schedule(void);
37			long io_schedule_timeout(long timeout);
38			-extern int sched_interactive, sched_compute;
39			+extern int sched_interactive, sched_compute, sched_iso_cpu;
40
41			extern void cpu_init (void);
42			extern void trap_init(void);
43			@@ -526,16 +527,18 @@ struct signal_struct {
44
45			#define MAX_USER_RT_PRIO 100
46			#define MAX_RT_PRIO MAX_USER_RT_PRIO
47			+#define ISO_PRIO (MAX_RT_PRIO - 1)
48
49			#define MAX_PRIO (MAX_RT_PRIO + 40)
50			#define MIN_USER_PRIO (MAX_PRIO - 1)
51
52			-#define rt_prio(prio) unlikely((prio) < MAX_RT_PRIO)
53			+#define rt_prio(prio) unlikely((prio) < ISO_PRIO)
54			#define rt_task(p) rt_prio((p)->prio)
55			#define batch_task(p) (unlikely((p)->policy == SCHED_BATCH))
56			#define is_rt_policy(policy) ((policy) == SCHED_FIFO \|\| \
57			(policy) == SCHED_RR)
58			#define has_rt_policy(p) unlikely(is_rt_policy((p)->policy))
59			+#define iso_task(p) (unlikely((p)->policy == SCHED_ISO))
60
61			/*
62			* Some day this will be a full-fledged user tracking system..
63			@@ -1151,6 +1154,7 @@ static inline void put_task_struct(struc
64			#define PF_SWAPWRITE 0x00800000 /* Allowed to write to swap */
65			#define PF_SPREAD_PAGE 0x01000000 /* Spread page cache over cpuset */
66			#define PF_SPREAD_SLAB 0x02000000 /* Spread some slab caches over cpuset */
67			+#define PF_ISOREF 0x04000000 /* SCHED_ISO task has used up quota */
68			#define PF_MEMPOLICY 0x10000000 /* Non-default NUMA mempolicy */
69			#define PF_MUTEX_TESTER 0x20000000 /* Thread belongs to the rt mutex tester */
70			#define PF_NONSLEEP 0x40000000 /* Waiting on in kernel activity */
71			Index: linux-2.6.20-ck1/kernel/sched.c
72			===================================================================
73			--- linux-2.6.20-ck1.orig/kernel/sched.c 2007-02-16 19:01:30.000000000 +1100
74			+++ linux-2.6.20-ck1/kernel/sched.c 2007-02-16 19:01:31.000000000 +1100
75			@@ -65,10 +65,14 @@
76			* raise its priority.
77			* sched_compute - sysctl which enables long timeslices and delayed preemption
78			* for compute server usage.
79			+ * sched_iso_cpu - sysctl which determines the cpu percentage SCHED_ISO tasks
80			+ * are allowed to run (over ISO_PERIOD seconds) as real time tasks.
81			*/
82			int sched_interactive __read_mostly = 1;
83			int sched_compute __read_mostly;
84			+int sched_iso_cpu __read_mostly = 80;
85
86			+#define ISO_PERIOD (5 * HZ)
87			/*
88			* CACHE_DELAY is the time preemption is delayed in sched_compute mode
89			* and is set to a nominal 10ms.
90			@@ -143,6 +147,8 @@ struct rq {
91			/* Cached timestamp set by update_cpu_clock() */
92			unsigned long long most_recent_timestamp;
93			unsigned short cache_ticks, preempted;
94			+ unsigned long iso_ticks;
95			+ unsigned short iso_refractory;
96			struct task_struct curr, idle;
97			unsigned long next_balance;
98			struct mm_struct *prev_mm;
99			@@ -878,6 +884,17 @@ static inline int __normal_prio(struct t
100			unsigned int full_slice, used_slice = 0;
101			unsigned int best_bonus, rr;
102
103			+ if (iso_task(p)) {
104			+ if (likely(!(p->flags & PF_ISOREF)))
105			+ /*
106			+ * If SCHED_ISO tasks have not used up their real time
107			+ * quota they have run just better than highest
108			+ * SCHED_NORMAL priority. Otherwise they run as
109			+ * SCHED_NORMAL.
110			+ */
111			+ return ISO_PRIO;
112			+ }
113			+
114			full_slice = slice(p);
115			if (full_slice > p->slice)
116			used_slice = full_slice - p->slice;
117			@@ -2990,6 +3007,23 @@ static void time_slice_expired(struct ta
118			requeue_task(p, rq, effective_prio(p));
119			}
120
121			+/*
122			+ * Test if SCHED_ISO tasks have run longer than their alloted period as RT
123			+ * tasks and set the refractory flag if necessary. There is 10% hysteresis
124			+ * for unsetting the flag.
125			+ */
126			+static inline unsigned int test_ret_isorefractory(struct rq *rq)
127			+{
128			+ if (likely(!rq->iso_refractory)) {
129			+ if (rq->iso_ticks / ISO_PERIOD > sched_iso_cpu)
130			+ rq->iso_refractory = 1;
131			+ } else {
132			+ if (rq->iso_ticks / ISO_PERIOD < (sched_iso_cpu * 90 / 100))
133			+ rq->iso_refractory = 0;
134			+ }
135			+ return rq->iso_refractory;
136			+}
137			+
138			static void task_running_tick(struct rq rq, struct task_struct p)
139			{
140			unsigned long debit;
141			@@ -2999,11 +3033,29 @@ static void task_running_tick(struct rq
142			set_tsk_need_resched(p);
143			return;
144			}
145			- /* SCHED_FIFO tasks never run out of timeslice. */
146			- if (unlikely(p->policy == SCHED_FIFO))
147			- return;
148
149			spin_lock(&rq->lock);
150			+ if (unlikely((rt_task(p) \|\| (iso_task(p) && !rq->iso_refractory)) &&
151			+ p->mm)) {
152			+ if (rq->iso_ticks <= (ISO_PERIOD * 100) - 100)
153			+ rq->iso_ticks += 100;
154			+ } else
155			+ rq->iso_ticks = rq->iso_ticks * (ISO_PERIOD - 1) / ISO_PERIOD;
156			+
157			+ if (iso_task(p)) {
158			+ if (unlikely(test_ret_isorefractory(rq))) {
159			+ if (!(p->flags & PF_ISOREF)) {
160			+ set_tsk_need_resched(p);
161			+ p->flags \|= PF_ISOREF;
162			+ }
163			+ } else
164			+ p->flags &= ~PF_ISOREF;
165			+ } else {
166			+ /* SCHED_FIFO tasks never run out of timeslice. */
167			+ if (unlikely(p->policy == SCHED_FIFO))
168			+ goto out_unlock;
169			+ }
170			+
171			debit = ns_diff(rq->most_recent_timestamp, p->timestamp);
172			p->ns_debit += debit;
173			if (p->ns_debit < NSJIFFY)
174			@@ -3122,7 +3174,7 @@ dependent_sleeper(int this_cpu, struct r
175			int ret = 0, i;
176
177			/* kernel/rt threads do not participate in dependent sleeping */
178			- if (!p->mm \|\| rt_task(p))
179			+ if (!p->mm \|\| rt_task(p) \|\| iso_task(p))
180			return 0;
181
182			for_each_domain(this_cpu, tmp) {
183			@@ -3159,7 +3211,7 @@ dependent_sleeper(int this_cpu, struct r
184			* task from using an unfair proportion of the
185			* physical cpu's resources. -ck
186			*/
187			- if (rt_task(smt_curr)) {
188			+ if (rt_task(smt_curr) \|\| iso_task(smt_curr)) {
189			/*
190			* With real time tasks we run non-rt tasks only
191			* per_cpu_gain% of the time.
192			@@ -3971,12 +4023,22 @@ static void __setscheduler(struct task_s
193			int sched_setscheduler(struct task_struct *p, int policy,
194			struct sched_param *param)
195			{
196			+ struct sched_param zero_param = { .sched_priority = 0 };
197			int queued, retval, oldprio, oldpolicy = -1;
198			unsigned long flags;
199			struct rq *rq;
200
201			/* may grab non-irq protected spin_locks */
202			BUG_ON(in_interrupt());
203			+ if (is_rt_policy(policy) && !capable(CAP_SYS_NICE)) {
204			+ /*
205			+ * If the caller requested an RT policy without having the
206			+ * necessary rights, we downgrade the policy to SCHED_ISO.
207			+ * We also set the parameter to zero to pass the checks.
208			+ */
209			+ policy = SCHED_ISO;
210			+ param = &zero_param;
211			+ }
212			recheck:
213			/* double check policy once rq lock held */
214			if (policy < 0)
215			@@ -4501,6 +4563,7 @@ asmlinkage long sys_sched_get_priority_m
216			break;
217			case SCHED_NORMAL:
218			case SCHED_BATCH:
219			+ case SCHED_ISO:
220			ret = 0;
221			break;
222			}
223			@@ -4525,6 +4588,7 @@ asmlinkage long sys_sched_get_priority_m
224			break;
225			case SCHED_NORMAL:
226			case SCHED_BATCH:
227			+ case SCHED_ISO:
228			ret = 0;
229			}
230			return ret;
231			@@ -6647,7 +6711,8 @@ void __init sched_init(void)
232			rq = cpu_rq(i);
233			spin_lock_init(&rq->lock);
234			lockdep_set_class(&rq->lock, &rq->rq_lock_key);
235			- rq->nr_running = rq->cache_ticks = rq->preempted = 0;
236			+ rq->nr_running = rq->cache_ticks = rq->preempted =
237			+ rq->iso_ticks = 0;
238
239			#ifdef CONFIG_SMP
240			rq->sd = NULL;
241			Index: linux-2.6.20-ck1/kernel/sysctl.c
242			===================================================================
243			--- linux-2.6.20-ck1.orig/kernel/sysctl.c 2007-02-16 19:01:30.000000000 +1100
244			+++ linux-2.6.20-ck1/kernel/sysctl.c 2007-02-16 19:01:31.000000000 +1100
245			@@ -273,6 +273,14 @@ static ctl_table root_table[] = {
246			{ .ctl_name = 0 }
247			};
248
249			+
250			+/*
251			+ * Constants for minimum and maximum testing.
252			+ * We use these as one-element integer vectors.
253			+ */
254			+static int zero;
255			+static int one_hundred = 100;
256			+
257			static ctl_table kern_table[] = {
258			{
259			.ctl_name = KERN_OSTYPE,
260			@@ -692,6 +700,17 @@ static ctl_table kern_table[] = {
261			.mode = 0644,
262			.proc_handler = &proc_dointvec,
263			},
264			+ {
265			+ .ctl_name = CTL_UNNUMBERED,
266			+ .procname = "iso_cpu",
267			+ .data = &sched_iso_cpu,
268			+ .maxlen = sizeof (int),
269			+ .mode = 0644,
270			+ .proc_handler = &proc_dointvec_minmax,
271			+ .strategy = &sysctl_intvec,
272			+ .extra1 = &zero,
273			+ .extra2 = &one_hundred,
274			+ },
275			#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
276			{
277			.ctl_name = KERN_UNKNOWN_NMI_PANIC,
278			@@ -800,12 +819,6 @@ static ctl_table kern_table[] = {
279			{ .ctl_name = 0 }
280			};
281
282			-/* Constants for minimum and maximum testing in vm_table.
283			- We use these as one-element integer vectors. */
284			-static int zero;
285			-static int one_hundred = 100;
286			-
287			-
288			static ctl_table vm_table[] = {
289			{
290			.ctl_name = VM_OVERCOMMIT_MEMORY,
291			Index: linux-2.6.20-ck1/Documentation/sysctl/kernel.txt
292			===================================================================
293			--- linux-2.6.20-ck1.orig/Documentation/sysctl/kernel.txt 2007-02-16 19:01:30.000000000 +1100
294			+++ linux-2.6.20-ck1/Documentation/sysctl/kernel.txt 2007-02-16 19:01:31.000000000 +1100
295			@@ -27,6 +27,7 @@ show up in /proc/sys/kernel:
296			- hostname
297			- hotplug
298			- interactive
299			+- iso_cpu
300			- java-appletviewer [ binfmt_java, obsolete ]
301			- java-interpreter [ binfmt_java, obsolete ]
302			- kstack_depth_to_print [ X86 only ]
303			@@ -185,6 +186,14 @@ are obeyed if this tunable is disabled.
304
305			==============================================================
306
307			+iso_cpu:
308			+
309			+This sets the percentage cpu that the unprivileged SCHED_ISO tasks can
310			+run effectively at realtime priority, averaged over a rolling 3 seconds.
311			+Set to 80% by default.
312			+
313			+==============================================================
314			+
315			l2cr: (PPC only)
316
317			This flag controls the L2 cache of G3 processor boards. If