xref: /linux/kernel/sysctl.c (revision 1241eb8f136bf3ea409f61590e7663465906d158)
1 /*
2  * sysctl.c: General linux system control interface
3  *
4  * Begun 24 March 1995, Stephen Tweedie
5  * Added /proc support, Dec 1995
6  * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
7  * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
8  * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
9  * Dynamic registration fixes, Stephen Tweedie.
10  * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
11  * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
12  *  Horn.
13  * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
14  * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
15  * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
16  *  Wendling.
17  * The list_for_each() macro wasn't appropriate for the sysctl loop.
18  *  Removed it and replaced it with older style, 03/23/00, Bill Wendling
19  */
20 
21 #include <linux/module.h>
22 #include <linux/mm.h>
23 #include <linux/swap.h>
24 #include <linux/slab.h>
25 #include <linux/sysctl.h>
26 #include <linux/proc_fs.h>
27 #include <linux/security.h>
28 #include <linux/ctype.h>
29 #include <linux/utsname.h>
30 #include <linux/smp_lock.h>
31 #include <linux/fs.h>
32 #include <linux/init.h>
33 #include <linux/kernel.h>
34 #include <linux/kobject.h>
35 #include <linux/net.h>
36 #include <linux/sysrq.h>
37 #include <linux/highuid.h>
38 #include <linux/writeback.h>
39 #include <linux/hugetlb.h>
40 #include <linux/initrd.h>
41 #include <linux/key.h>
42 #include <linux/times.h>
43 #include <linux/limits.h>
44 #include <linux/dcache.h>
45 #include <linux/syscalls.h>
46 #include <linux/vmstat.h>
47 #include <linux/nfs_fs.h>
48 #include <linux/acpi.h>
49 #include <linux/reboot.h>
50 #include <linux/ftrace.h>
51 #include <linux/slow-work.h>
52 #include <linux/perf_counter.h>
53 
54 #include <asm/uaccess.h>
55 #include <asm/processor.h>
56 
57 #ifdef CONFIG_X86
58 #include <asm/nmi.h>
59 #include <asm/stacktrace.h>
60 #include <asm/io.h>
61 #endif
62 
63 static int deprecated_sysctl_warning(struct __sysctl_args *args);
64 
65 #if defined(CONFIG_SYSCTL)
66 
67 /* External variables not in a header file. */
68 extern int C_A_D;
69 extern int print_fatal_signals;
70 extern int sysctl_overcommit_memory;
71 extern int sysctl_overcommit_ratio;
72 extern int sysctl_panic_on_oom;
73 extern int sysctl_oom_kill_allocating_task;
74 extern int sysctl_oom_dump_tasks;
75 extern int max_threads;
76 extern int core_uses_pid;
77 extern int suid_dumpable;
78 extern char core_pattern[];
79 extern int pid_max;
80 extern int min_free_kbytes;
81 extern int pid_max_min, pid_max_max;
82 extern int sysctl_drop_caches;
83 extern int percpu_pagelist_fraction;
84 extern int compat_log;
85 extern int latencytop_enabled;
86 extern int sysctl_nr_open_min, sysctl_nr_open_max;
87 #ifndef CONFIG_MMU
88 extern int sysctl_nr_trim_pages;
89 #endif
90 #ifdef CONFIG_RCU_TORTURE_TEST
91 extern int rcutorture_runnable;
92 #endif /* #ifdef CONFIG_RCU_TORTURE_TEST */
93 
94 /* Constants used for minimum and  maximum */
95 #ifdef CONFIG_DETECT_SOFTLOCKUP
96 static int sixty = 60;
97 static int neg_one = -1;
98 #endif
99 
100 static int zero;
101 static int __maybe_unused one = 1;
102 static int __maybe_unused two = 2;
103 static unsigned long one_ul = 1;
104 static int one_hundred = 100;
105 
106 /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
107 static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
108 
109 /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
110 static int maxolduid = 65535;
111 static int minolduid;
112 static int min_percpu_pagelist_fract = 8;
113 
114 static int ngroups_max = NGROUPS_MAX;
115 
116 #ifdef CONFIG_MODULES
117 extern char modprobe_path[];
118 #endif
119 #ifdef CONFIG_CHR_DEV_SG
120 extern int sg_big_buff;
121 #endif
122 
123 #ifdef CONFIG_SPARC
124 #include <asm/system.h>
125 #endif
126 
127 #ifdef CONFIG_SPARC64
128 extern int sysctl_tsb_ratio;
129 #endif
130 
131 #ifdef __hppa__
132 extern int pwrsw_enabled;
133 extern int unaligned_enabled;
134 #endif
135 
136 #ifdef CONFIG_S390
137 #ifdef CONFIG_MATHEMU
138 extern int sysctl_ieee_emulation_warnings;
139 #endif
140 extern int sysctl_userprocess_debug;
141 extern int spin_retry;
142 #endif
143 
144 #ifdef CONFIG_BSD_PROCESS_ACCT
145 extern int acct_parm[];
146 #endif
147 
148 #ifdef CONFIG_IA64
149 extern int no_unaligned_warning;
150 extern int unaligned_dump_stack;
151 #endif
152 
153 #ifdef CONFIG_RT_MUTEXES
154 extern int max_lock_depth;
155 #endif
156 
157 #ifdef CONFIG_PROC_SYSCTL
158 static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp,
159 		  void __user *buffer, size_t *lenp, loff_t *ppos);
160 static int proc_taint(struct ctl_table *table, int write, struct file *filp,
161 			       void __user *buffer, size_t *lenp, loff_t *ppos);
162 #endif
163 
164 static struct ctl_table root_table[];
165 static struct ctl_table_root sysctl_table_root;
166 static struct ctl_table_header root_table_header = {
167 	.count = 1,
168 	.ctl_table = root_table,
169 	.ctl_entry = LIST_HEAD_INIT(sysctl_table_root.default_set.list),
170 	.root = &sysctl_table_root,
171 	.set = &sysctl_table_root.default_set,
172 };
173 static struct ctl_table_root sysctl_table_root = {
174 	.root_list = LIST_HEAD_INIT(sysctl_table_root.root_list),
175 	.default_set.list = LIST_HEAD_INIT(root_table_header.ctl_entry),
176 };
177 
178 static struct ctl_table kern_table[];
179 static struct ctl_table vm_table[];
180 static struct ctl_table fs_table[];
181 static struct ctl_table debug_table[];
182 static struct ctl_table dev_table[];
183 extern struct ctl_table random_table[];
184 #ifdef CONFIG_INOTIFY_USER
185 extern struct ctl_table inotify_table[];
186 #endif
187 #ifdef CONFIG_EPOLL
188 extern struct ctl_table epoll_table[];
189 #endif
190 
191 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
192 int sysctl_legacy_va_layout;
193 #endif
194 
195 extern int prove_locking;
196 extern int lock_stat;
197 
198 /* The default sysctl tables: */
199 
200 static struct ctl_table root_table[] = {
201 	{
202 		.ctl_name	= CTL_KERN,
203 		.procname	= "kernel",
204 		.mode		= 0555,
205 		.child		= kern_table,
206 	},
207 	{
208 		.ctl_name	= CTL_VM,
209 		.procname	= "vm",
210 		.mode		= 0555,
211 		.child		= vm_table,
212 	},
213 	{
214 		.ctl_name	= CTL_FS,
215 		.procname	= "fs",
216 		.mode		= 0555,
217 		.child		= fs_table,
218 	},
219 	{
220 		.ctl_name	= CTL_DEBUG,
221 		.procname	= "debug",
222 		.mode		= 0555,
223 		.child		= debug_table,
224 	},
225 	{
226 		.ctl_name	= CTL_DEV,
227 		.procname	= "dev",
228 		.mode		= 0555,
229 		.child		= dev_table,
230 	},
231 /*
232  * NOTE: do not add new entries to this table unless you have read
233  * Documentation/sysctl/ctl_unnumbered.txt
234  */
235 	{ .ctl_name = 0 }
236 };
237 
238 #ifdef CONFIG_SCHED_DEBUG
239 static int min_sched_granularity_ns = 100000;		/* 100 usecs */
240 static int max_sched_granularity_ns = NSEC_PER_SEC;	/* 1 second */
241 static int min_wakeup_granularity_ns;			/* 0 usecs */
242 static int max_wakeup_granularity_ns = NSEC_PER_SEC;	/* 1 second */
243 #endif
244 
245 static struct ctl_table kern_table[] = {
246 #ifdef CONFIG_SCHED_DEBUG
247 	{
248 		.ctl_name	= CTL_UNNUMBERED,
249 		.procname	= "sched_min_granularity_ns",
250 		.data		= &sysctl_sched_min_granularity,
251 		.maxlen		= sizeof(unsigned int),
252 		.mode		= 0644,
253 		.proc_handler	= &sched_nr_latency_handler,
254 		.strategy	= &sysctl_intvec,
255 		.extra1		= &min_sched_granularity_ns,
256 		.extra2		= &max_sched_granularity_ns,
257 	},
258 	{
259 		.ctl_name	= CTL_UNNUMBERED,
260 		.procname	= "sched_latency_ns",
261 		.data		= &sysctl_sched_latency,
262 		.maxlen		= sizeof(unsigned int),
263 		.mode		= 0644,
264 		.proc_handler	= &sched_nr_latency_handler,
265 		.strategy	= &sysctl_intvec,
266 		.extra1		= &min_sched_granularity_ns,
267 		.extra2		= &max_sched_granularity_ns,
268 	},
269 	{
270 		.ctl_name	= CTL_UNNUMBERED,
271 		.procname	= "sched_wakeup_granularity_ns",
272 		.data		= &sysctl_sched_wakeup_granularity,
273 		.maxlen		= sizeof(unsigned int),
274 		.mode		= 0644,
275 		.proc_handler	= &proc_dointvec_minmax,
276 		.strategy	= &sysctl_intvec,
277 		.extra1		= &min_wakeup_granularity_ns,
278 		.extra2		= &max_wakeup_granularity_ns,
279 	},
280 	{
281 		.ctl_name	= CTL_UNNUMBERED,
282 		.procname	= "sched_shares_ratelimit",
283 		.data		= &sysctl_sched_shares_ratelimit,
284 		.maxlen		= sizeof(unsigned int),
285 		.mode		= 0644,
286 		.proc_handler	= &proc_dointvec,
287 	},
288 	{
289 		.ctl_name	= CTL_UNNUMBERED,
290 		.procname	= "sched_shares_thresh",
291 		.data		= &sysctl_sched_shares_thresh,
292 		.maxlen		= sizeof(unsigned int),
293 		.mode		= 0644,
294 		.proc_handler	= &proc_dointvec_minmax,
295 		.strategy	= &sysctl_intvec,
296 		.extra1		= &zero,
297 	},
298 	{
299 		.ctl_name	= CTL_UNNUMBERED,
300 		.procname	= "sched_child_runs_first",
301 		.data		= &sysctl_sched_child_runs_first,
302 		.maxlen		= sizeof(unsigned int),
303 		.mode		= 0644,
304 		.proc_handler	= &proc_dointvec,
305 	},
306 	{
307 		.ctl_name	= CTL_UNNUMBERED,
308 		.procname	= "sched_features",
309 		.data		= &sysctl_sched_features,
310 		.maxlen		= sizeof(unsigned int),
311 		.mode		= 0644,
312 		.proc_handler	= &proc_dointvec,
313 	},
314 	{
315 		.ctl_name	= CTL_UNNUMBERED,
316 		.procname	= "sched_migration_cost",
317 		.data		= &sysctl_sched_migration_cost,
318 		.maxlen		= sizeof(unsigned int),
319 		.mode		= 0644,
320 		.proc_handler	= &proc_dointvec,
321 	},
322 	{
323 		.ctl_name	= CTL_UNNUMBERED,
324 		.procname	= "sched_nr_migrate",
325 		.data		= &sysctl_sched_nr_migrate,
326 		.maxlen		= sizeof(unsigned int),
327 		.mode		= 0644,
328 		.proc_handler	= &proc_dointvec,
329 	},
330 #endif
331 	{
332 		.ctl_name	= CTL_UNNUMBERED,
333 		.procname	= "sched_rt_period_us",
334 		.data		= &sysctl_sched_rt_period,
335 		.maxlen		= sizeof(unsigned int),
336 		.mode		= 0644,
337 		.proc_handler	= &sched_rt_handler,
338 	},
339 	{
340 		.ctl_name	= CTL_UNNUMBERED,
341 		.procname	= "sched_rt_runtime_us",
342 		.data		= &sysctl_sched_rt_runtime,
343 		.maxlen		= sizeof(int),
344 		.mode		= 0644,
345 		.proc_handler	= &sched_rt_handler,
346 	},
347 	{
348 		.ctl_name	= CTL_UNNUMBERED,
349 		.procname	= "sched_compat_yield",
350 		.data		= &sysctl_sched_compat_yield,
351 		.maxlen		= sizeof(unsigned int),
352 		.mode		= 0644,
353 		.proc_handler	= &proc_dointvec,
354 	},
355 #ifdef CONFIG_PROVE_LOCKING
356 	{
357 		.ctl_name	= CTL_UNNUMBERED,
358 		.procname	= "prove_locking",
359 		.data		= &prove_locking,
360 		.maxlen		= sizeof(int),
361 		.mode		= 0644,
362 		.proc_handler	= &proc_dointvec,
363 	},
364 #endif
365 #ifdef CONFIG_LOCK_STAT
366 	{
367 		.ctl_name	= CTL_UNNUMBERED,
368 		.procname	= "lock_stat",
369 		.data		= &lock_stat,
370 		.maxlen		= sizeof(int),
371 		.mode		= 0644,
372 		.proc_handler	= &proc_dointvec,
373 	},
374 #endif
375 	{
376 		.ctl_name	= KERN_PANIC,
377 		.procname	= "panic",
378 		.data		= &panic_timeout,
379 		.maxlen		= sizeof(int),
380 		.mode		= 0644,
381 		.proc_handler	= &proc_dointvec,
382 	},
383 	{
384 		.ctl_name	= KERN_CORE_USES_PID,
385 		.procname	= "core_uses_pid",
386 		.data		= &core_uses_pid,
387 		.maxlen		= sizeof(int),
388 		.mode		= 0644,
389 		.proc_handler	= &proc_dointvec,
390 	},
391 	{
392 		.ctl_name	= KERN_CORE_PATTERN,
393 		.procname	= "core_pattern",
394 		.data		= core_pattern,
395 		.maxlen		= CORENAME_MAX_SIZE,
396 		.mode		= 0644,
397 		.proc_handler	= &proc_dostring,
398 		.strategy	= &sysctl_string,
399 	},
400 #ifdef CONFIG_PROC_SYSCTL
401 	{
402 		.procname	= "tainted",
403 		.maxlen 	= sizeof(long),
404 		.mode		= 0644,
405 		.proc_handler	= &proc_taint,
406 	},
407 #endif
408 #ifdef CONFIG_LATENCYTOP
409 	{
410 		.procname	= "latencytop",
411 		.data		= &latencytop_enabled,
412 		.maxlen		= sizeof(int),
413 		.mode		= 0644,
414 		.proc_handler	= &proc_dointvec,
415 	},
416 #endif
417 #ifdef CONFIG_BLK_DEV_INITRD
418 	{
419 		.ctl_name	= KERN_REALROOTDEV,
420 		.procname	= "real-root-dev",
421 		.data		= &real_root_dev,
422 		.maxlen		= sizeof(int),
423 		.mode		= 0644,
424 		.proc_handler	= &proc_dointvec,
425 	},
426 #endif
427 	{
428 		.ctl_name	= CTL_UNNUMBERED,
429 		.procname	= "print-fatal-signals",
430 		.data		= &print_fatal_signals,
431 		.maxlen		= sizeof(int),
432 		.mode		= 0644,
433 		.proc_handler	= &proc_dointvec,
434 	},
435 #ifdef CONFIG_SPARC
436 	{
437 		.ctl_name	= KERN_SPARC_REBOOT,
438 		.procname	= "reboot-cmd",
439 		.data		= reboot_command,
440 		.maxlen		= 256,
441 		.mode		= 0644,
442 		.proc_handler	= &proc_dostring,
443 		.strategy	= &sysctl_string,
444 	},
445 	{
446 		.ctl_name	= KERN_SPARC_STOP_A,
447 		.procname	= "stop-a",
448 		.data		= &stop_a_enabled,
449 		.maxlen		= sizeof (int),
450 		.mode		= 0644,
451 		.proc_handler	= &proc_dointvec,
452 	},
453 	{
454 		.ctl_name	= KERN_SPARC_SCONS_PWROFF,
455 		.procname	= "scons-poweroff",
456 		.data		= &scons_pwroff,
457 		.maxlen		= sizeof (int),
458 		.mode		= 0644,
459 		.proc_handler	= &proc_dointvec,
460 	},
461 #endif
462 #ifdef CONFIG_SPARC64
463 	{
464 		.ctl_name	= CTL_UNNUMBERED,
465 		.procname	= "tsb-ratio",
466 		.data		= &sysctl_tsb_ratio,
467 		.maxlen		= sizeof (int),
468 		.mode		= 0644,
469 		.proc_handler	= &proc_dointvec,
470 	},
471 #endif
472 #ifdef __hppa__
473 	{
474 		.ctl_name	= KERN_HPPA_PWRSW,
475 		.procname	= "soft-power",
476 		.data		= &pwrsw_enabled,
477 		.maxlen		= sizeof (int),
478 	 	.mode		= 0644,
479 		.proc_handler	= &proc_dointvec,
480 	},
481 	{
482 		.ctl_name	= KERN_HPPA_UNALIGNED,
483 		.procname	= "unaligned-trap",
484 		.data		= &unaligned_enabled,
485 		.maxlen		= sizeof (int),
486 		.mode		= 0644,
487 		.proc_handler	= &proc_dointvec,
488 	},
489 #endif
490 	{
491 		.ctl_name	= KERN_CTLALTDEL,
492 		.procname	= "ctrl-alt-del",
493 		.data		= &C_A_D,
494 		.maxlen		= sizeof(int),
495 		.mode		= 0644,
496 		.proc_handler	= &proc_dointvec,
497 	},
498 #ifdef CONFIG_FUNCTION_TRACER
499 	{
500 		.ctl_name	= CTL_UNNUMBERED,
501 		.procname	= "ftrace_enabled",
502 		.data		= &ftrace_enabled,
503 		.maxlen		= sizeof(int),
504 		.mode		= 0644,
505 		.proc_handler	= &ftrace_enable_sysctl,
506 	},
507 #endif
508 #ifdef CONFIG_STACK_TRACER
509 	{
510 		.ctl_name	= CTL_UNNUMBERED,
511 		.procname	= "stack_tracer_enabled",
512 		.data		= &stack_tracer_enabled,
513 		.maxlen		= sizeof(int),
514 		.mode		= 0644,
515 		.proc_handler	= &stack_trace_sysctl,
516 	},
517 #endif
518 #ifdef CONFIG_TRACING
519 	{
520 		.ctl_name	= CTL_UNNUMBERED,
521 		.procname	= "ftrace_dump_on_oops",
522 		.data		= &ftrace_dump_on_oops,
523 		.maxlen		= sizeof(int),
524 		.mode		= 0644,
525 		.proc_handler	= &proc_dointvec,
526 	},
527 #endif
528 #ifdef CONFIG_MODULES
529 	{
530 		.ctl_name	= KERN_MODPROBE,
531 		.procname	= "modprobe",
532 		.data		= &modprobe_path,
533 		.maxlen		= KMOD_PATH_LEN,
534 		.mode		= 0644,
535 		.proc_handler	= &proc_dostring,
536 		.strategy	= &sysctl_string,
537 	},
538 #endif
539 #if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)
540 	{
541 		.ctl_name	= KERN_HOTPLUG,
542 		.procname	= "hotplug",
543 		.data		= &uevent_helper,
544 		.maxlen		= UEVENT_HELPER_PATH_LEN,
545 		.mode		= 0644,
546 		.proc_handler	= &proc_dostring,
547 		.strategy	= &sysctl_string,
548 	},
549 #endif
550 #ifdef CONFIG_CHR_DEV_SG
551 	{
552 		.ctl_name	= KERN_SG_BIG_BUFF,
553 		.procname	= "sg-big-buff",
554 		.data		= &sg_big_buff,
555 		.maxlen		= sizeof (int),
556 		.mode		= 0444,
557 		.proc_handler	= &proc_dointvec,
558 	},
559 #endif
560 #ifdef CONFIG_BSD_PROCESS_ACCT
561 	{
562 		.ctl_name	= KERN_ACCT,
563 		.procname	= "acct",
564 		.data		= &acct_parm,
565 		.maxlen		= 3*sizeof(int),
566 		.mode		= 0644,
567 		.proc_handler	= &proc_dointvec,
568 	},
569 #endif
570 #ifdef CONFIG_MAGIC_SYSRQ
571 	{
572 		.ctl_name	= KERN_SYSRQ,
573 		.procname	= "sysrq",
574 		.data		= &__sysrq_enabled,
575 		.maxlen		= sizeof (int),
576 		.mode		= 0644,
577 		.proc_handler	= &proc_dointvec,
578 	},
579 #endif
580 #ifdef CONFIG_PROC_SYSCTL
581 	{
582 		.procname	= "cad_pid",
583 		.data		= NULL,
584 		.maxlen		= sizeof (int),
585 		.mode		= 0600,
586 		.proc_handler	= &proc_do_cad_pid,
587 	},
588 #endif
589 	{
590 		.ctl_name	= KERN_MAX_THREADS,
591 		.procname	= "threads-max",
592 		.data		= &max_threads,
593 		.maxlen		= sizeof(int),
594 		.mode		= 0644,
595 		.proc_handler	= &proc_dointvec,
596 	},
597 	{
598 		.ctl_name	= KERN_RANDOM,
599 		.procname	= "random",
600 		.mode		= 0555,
601 		.child		= random_table,
602 	},
603 	{
604 		.ctl_name	= KERN_OVERFLOWUID,
605 		.procname	= "overflowuid",
606 		.data		= &overflowuid,
607 		.maxlen		= sizeof(int),
608 		.mode		= 0644,
609 		.proc_handler	= &proc_dointvec_minmax,
610 		.strategy	= &sysctl_intvec,
611 		.extra1		= &minolduid,
612 		.extra2		= &maxolduid,
613 	},
614 	{
615 		.ctl_name	= KERN_OVERFLOWGID,
616 		.procname	= "overflowgid",
617 		.data		= &overflowgid,
618 		.maxlen		= sizeof(int),
619 		.mode		= 0644,
620 		.proc_handler	= &proc_dointvec_minmax,
621 		.strategy	= &sysctl_intvec,
622 		.extra1		= &minolduid,
623 		.extra2		= &maxolduid,
624 	},
625 #ifdef CONFIG_S390
626 #ifdef CONFIG_MATHEMU
627 	{
628 		.ctl_name	= KERN_IEEE_EMULATION_WARNINGS,
629 		.procname	= "ieee_emulation_warnings",
630 		.data		= &sysctl_ieee_emulation_warnings,
631 		.maxlen		= sizeof(int),
632 		.mode		= 0644,
633 		.proc_handler	= &proc_dointvec,
634 	},
635 #endif
636 	{
637 		.ctl_name	= KERN_S390_USER_DEBUG_LOGGING,
638 		.procname	= "userprocess_debug",
639 		.data		= &sysctl_userprocess_debug,
640 		.maxlen		= sizeof(int),
641 		.mode		= 0644,
642 		.proc_handler	= &proc_dointvec,
643 	},
644 #endif
645 	{
646 		.ctl_name	= KERN_PIDMAX,
647 		.procname	= "pid_max",
648 		.data		= &pid_max,
649 		.maxlen		= sizeof (int),
650 		.mode		= 0644,
651 		.proc_handler	= &proc_dointvec_minmax,
652 		.strategy	= sysctl_intvec,
653 		.extra1		= &pid_max_min,
654 		.extra2		= &pid_max_max,
655 	},
656 	{
657 		.ctl_name	= KERN_PANIC_ON_OOPS,
658 		.procname	= "panic_on_oops",
659 		.data		= &panic_on_oops,
660 		.maxlen		= sizeof(int),
661 		.mode		= 0644,
662 		.proc_handler	= &proc_dointvec,
663 	},
664 #if defined CONFIG_PRINTK
665 	{
666 		.ctl_name	= KERN_PRINTK,
667 		.procname	= "printk",
668 		.data		= &console_loglevel,
669 		.maxlen		= 4*sizeof(int),
670 		.mode		= 0644,
671 		.proc_handler	= &proc_dointvec,
672 	},
673 	{
674 		.ctl_name	= KERN_PRINTK_RATELIMIT,
675 		.procname	= "printk_ratelimit",
676 		.data		= &printk_ratelimit_state.interval,
677 		.maxlen		= sizeof(int),
678 		.mode		= 0644,
679 		.proc_handler	= &proc_dointvec_jiffies,
680 		.strategy	= &sysctl_jiffies,
681 	},
682 	{
683 		.ctl_name	= KERN_PRINTK_RATELIMIT_BURST,
684 		.procname	= "printk_ratelimit_burst",
685 		.data		= &printk_ratelimit_state.burst,
686 		.maxlen		= sizeof(int),
687 		.mode		= 0644,
688 		.proc_handler	= &proc_dointvec,
689 	},
690 #endif
691 	{
692 		.ctl_name	= KERN_NGROUPS_MAX,
693 		.procname	= "ngroups_max",
694 		.data		= &ngroups_max,
695 		.maxlen		= sizeof (int),
696 		.mode		= 0444,
697 		.proc_handler	= &proc_dointvec,
698 	},
699 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
700 	{
701 		.ctl_name       = KERN_UNKNOWN_NMI_PANIC,
702 		.procname       = "unknown_nmi_panic",
703 		.data           = &unknown_nmi_panic,
704 		.maxlen         = sizeof (int),
705 		.mode           = 0644,
706 		.proc_handler   = &proc_dointvec,
707 	},
708 	{
709 		.procname       = "nmi_watchdog",
710 		.data           = &nmi_watchdog_enabled,
711 		.maxlen         = sizeof (int),
712 		.mode           = 0644,
713 		.proc_handler   = &proc_nmi_enabled,
714 	},
715 #endif
716 #if defined(CONFIG_X86)
717 	{
718 		.ctl_name	= KERN_PANIC_ON_NMI,
719 		.procname	= "panic_on_unrecovered_nmi",
720 		.data		= &panic_on_unrecovered_nmi,
721 		.maxlen		= sizeof(int),
722 		.mode		= 0644,
723 		.proc_handler	= &proc_dointvec,
724 	},
725 	{
726 		.ctl_name	= KERN_BOOTLOADER_TYPE,
727 		.procname	= "bootloader_type",
728 		.data		= &bootloader_type,
729 		.maxlen		= sizeof (int),
730 		.mode		= 0444,
731 		.proc_handler	= &proc_dointvec,
732 	},
733 	{
734 		.ctl_name	= CTL_UNNUMBERED,
735 		.procname	= "bootloader_version",
736 		.data		= &bootloader_version,
737 		.maxlen		= sizeof (int),
738 		.mode		= 0444,
739 		.proc_handler	= &proc_dointvec,
740 	},
741 	{
742 		.ctl_name	= CTL_UNNUMBERED,
743 		.procname	= "kstack_depth_to_print",
744 		.data		= &kstack_depth_to_print,
745 		.maxlen		= sizeof(int),
746 		.mode		= 0644,
747 		.proc_handler	= &proc_dointvec,
748 	},
749 	{
750 		.ctl_name	= CTL_UNNUMBERED,
751 		.procname	= "io_delay_type",
752 		.data		= &io_delay_type,
753 		.maxlen		= sizeof(int),
754 		.mode		= 0644,
755 		.proc_handler	= &proc_dointvec,
756 	},
757 #endif
758 #if defined(CONFIG_MMU)
759 	{
760 		.ctl_name	= KERN_RANDOMIZE,
761 		.procname	= "randomize_va_space",
762 		.data		= &randomize_va_space,
763 		.maxlen		= sizeof(int),
764 		.mode		= 0644,
765 		.proc_handler	= &proc_dointvec,
766 	},
767 #endif
768 #if defined(CONFIG_S390) && defined(CONFIG_SMP)
769 	{
770 		.ctl_name	= KERN_SPIN_RETRY,
771 		.procname	= "spin_retry",
772 		.data		= &spin_retry,
773 		.maxlen		= sizeof (int),
774 		.mode		= 0644,
775 		.proc_handler	= &proc_dointvec,
776 	},
777 #endif
778 #if	defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
779 	{
780 		.procname	= "acpi_video_flags",
781 		.data		= &acpi_realmode_flags,
782 		.maxlen		= sizeof (unsigned long),
783 		.mode		= 0644,
784 		.proc_handler	= &proc_doulongvec_minmax,
785 	},
786 #endif
787 #ifdef CONFIG_IA64
788 	{
789 		.ctl_name	= KERN_IA64_UNALIGNED,
790 		.procname	= "ignore-unaligned-usertrap",
791 		.data		= &no_unaligned_warning,
792 		.maxlen		= sizeof (int),
793 	 	.mode		= 0644,
794 		.proc_handler	= &proc_dointvec,
795 	},
796 	{
797 		.ctl_name	= CTL_UNNUMBERED,
798 		.procname	= "unaligned-dump-stack",
799 		.data		= &unaligned_dump_stack,
800 		.maxlen		= sizeof (int),
801 		.mode		= 0644,
802 		.proc_handler	= &proc_dointvec,
803 	},
804 #endif
805 #ifdef CONFIG_DETECT_SOFTLOCKUP
806 	{
807 		.ctl_name	= CTL_UNNUMBERED,
808 		.procname	= "softlockup_panic",
809 		.data		= &softlockup_panic,
810 		.maxlen		= sizeof(int),
811 		.mode		= 0644,
812 		.proc_handler	= &proc_dointvec_minmax,
813 		.strategy	= &sysctl_intvec,
814 		.extra1		= &zero,
815 		.extra2		= &one,
816 	},
817 	{
818 		.ctl_name	= CTL_UNNUMBERED,
819 		.procname	= "softlockup_thresh",
820 		.data		= &softlockup_thresh,
821 		.maxlen		= sizeof(int),
822 		.mode		= 0644,
823 		.proc_handler	= &proc_dosoftlockup_thresh,
824 		.strategy	= &sysctl_intvec,
825 		.extra1		= &neg_one,
826 		.extra2		= &sixty,
827 	},
828 #endif
829 #ifdef CONFIG_DETECT_HUNG_TASK
830 	{
831 		.ctl_name	= CTL_UNNUMBERED,
832 		.procname	= "hung_task_panic",
833 		.data		= &sysctl_hung_task_panic,
834 		.maxlen		= sizeof(int),
835 		.mode		= 0644,
836 		.proc_handler	= &proc_dointvec_minmax,
837 		.strategy	= &sysctl_intvec,
838 		.extra1		= &zero,
839 		.extra2		= &one,
840 	},
841 	{
842 		.ctl_name	= CTL_UNNUMBERED,
843 		.procname	= "hung_task_check_count",
844 		.data		= &sysctl_hung_task_check_count,
845 		.maxlen		= sizeof(unsigned long),
846 		.mode		= 0644,
847 		.proc_handler	= &proc_doulongvec_minmax,
848 		.strategy	= &sysctl_intvec,
849 	},
850 	{
851 		.ctl_name	= CTL_UNNUMBERED,
852 		.procname	= "hung_task_timeout_secs",
853 		.data		= &sysctl_hung_task_timeout_secs,
854 		.maxlen		= sizeof(unsigned long),
855 		.mode		= 0644,
856 		.proc_handler	= &proc_dohung_task_timeout_secs,
857 		.strategy	= &sysctl_intvec,
858 	},
859 	{
860 		.ctl_name	= CTL_UNNUMBERED,
861 		.procname	= "hung_task_warnings",
862 		.data		= &sysctl_hung_task_warnings,
863 		.maxlen		= sizeof(unsigned long),
864 		.mode		= 0644,
865 		.proc_handler	= &proc_doulongvec_minmax,
866 		.strategy	= &sysctl_intvec,
867 	},
868 #endif
869 #ifdef CONFIG_COMPAT
870 	{
871 		.ctl_name	= KERN_COMPAT_LOG,
872 		.procname	= "compat-log",
873 		.data		= &compat_log,
874 		.maxlen		= sizeof (int),
875 	 	.mode		= 0644,
876 		.proc_handler	= &proc_dointvec,
877 	},
878 #endif
879 #ifdef CONFIG_RT_MUTEXES
880 	{
881 		.ctl_name	= KERN_MAX_LOCK_DEPTH,
882 		.procname	= "max_lock_depth",
883 		.data		= &max_lock_depth,
884 		.maxlen		= sizeof(int),
885 		.mode		= 0644,
886 		.proc_handler	= &proc_dointvec,
887 	},
888 #endif
889 	{
890 		.ctl_name	= CTL_UNNUMBERED,
891 		.procname	= "poweroff_cmd",
892 		.data		= &poweroff_cmd,
893 		.maxlen		= POWEROFF_CMD_PATH_LEN,
894 		.mode		= 0644,
895 		.proc_handler	= &proc_dostring,
896 		.strategy	= &sysctl_string,
897 	},
898 #ifdef CONFIG_KEYS
899 	{
900 		.ctl_name	= CTL_UNNUMBERED,
901 		.procname	= "keys",
902 		.mode		= 0555,
903 		.child		= key_sysctls,
904 	},
905 #endif
906 #ifdef CONFIG_RCU_TORTURE_TEST
907 	{
908 		.ctl_name       = CTL_UNNUMBERED,
909 		.procname       = "rcutorture_runnable",
910 		.data           = &rcutorture_runnable,
911 		.maxlen         = sizeof(int),
912 		.mode           = 0644,
913 		.proc_handler   = &proc_dointvec,
914 	},
915 #endif
916 #ifdef CONFIG_SLOW_WORK
917 	{
918 		.ctl_name	= CTL_UNNUMBERED,
919 		.procname	= "slow-work",
920 		.mode		= 0555,
921 		.child		= slow_work_sysctls,
922 	},
923 #endif
924 #ifdef CONFIG_PERF_COUNTERS
925 	{
926 		.ctl_name	= CTL_UNNUMBERED,
927 		.procname	= "perf_counter_paranoid",
928 		.data		= &sysctl_perf_counter_paranoid,
929 		.maxlen		= sizeof(sysctl_perf_counter_paranoid),
930 		.mode		= 0644,
931 		.proc_handler	= &proc_dointvec,
932 	},
933 	{
934 		.ctl_name	= CTL_UNNUMBERED,
935 		.procname	= "perf_counter_mlock_kb",
936 		.data		= &sysctl_perf_counter_mlock,
937 		.maxlen		= sizeof(sysctl_perf_counter_mlock),
938 		.mode		= 0644,
939 		.proc_handler	= &proc_dointvec,
940 	},
941 	{
942 		.ctl_name	= CTL_UNNUMBERED,
943 		.procname	= "perf_counter_max_sample_rate",
944 		.data		= &sysctl_perf_counter_sample_rate,
945 		.maxlen		= sizeof(sysctl_perf_counter_sample_rate),
946 		.mode		= 0644,
947 		.proc_handler	= &proc_dointvec,
948 	},
949 #endif
950 /*
951  * NOTE: do not add new entries to this table unless you have read
952  * Documentation/sysctl/ctl_unnumbered.txt
953  */
954 	{ .ctl_name = 0 }
955 };
956 
957 static struct ctl_table vm_table[] = {
958 	{
959 		.ctl_name	= VM_OVERCOMMIT_MEMORY,
960 		.procname	= "overcommit_memory",
961 		.data		= &sysctl_overcommit_memory,
962 		.maxlen		= sizeof(sysctl_overcommit_memory),
963 		.mode		= 0644,
964 		.proc_handler	= &proc_dointvec,
965 	},
966 	{
967 		.ctl_name	= VM_PANIC_ON_OOM,
968 		.procname	= "panic_on_oom",
969 		.data		= &sysctl_panic_on_oom,
970 		.maxlen		= sizeof(sysctl_panic_on_oom),
971 		.mode		= 0644,
972 		.proc_handler	= &proc_dointvec,
973 	},
974 	{
975 		.ctl_name	= CTL_UNNUMBERED,
976 		.procname	= "oom_kill_allocating_task",
977 		.data		= &sysctl_oom_kill_allocating_task,
978 		.maxlen		= sizeof(sysctl_oom_kill_allocating_task),
979 		.mode		= 0644,
980 		.proc_handler	= &proc_dointvec,
981 	},
982 	{
983 		.ctl_name	= CTL_UNNUMBERED,
984 		.procname	= "oom_dump_tasks",
985 		.data		= &sysctl_oom_dump_tasks,
986 		.maxlen		= sizeof(sysctl_oom_dump_tasks),
987 		.mode		= 0644,
988 		.proc_handler	= &proc_dointvec,
989 	},
990 	{
991 		.ctl_name	= VM_OVERCOMMIT_RATIO,
992 		.procname	= "overcommit_ratio",
993 		.data		= &sysctl_overcommit_ratio,
994 		.maxlen		= sizeof(sysctl_overcommit_ratio),
995 		.mode		= 0644,
996 		.proc_handler	= &proc_dointvec,
997 	},
998 	{
999 		.ctl_name	= VM_PAGE_CLUSTER,
1000 		.procname	= "page-cluster",
1001 		.data		= &page_cluster,
1002 		.maxlen		= sizeof(int),
1003 		.mode		= 0644,
1004 		.proc_handler	= &proc_dointvec,
1005 	},
1006 	{
1007 		.ctl_name	= VM_DIRTY_BACKGROUND,
1008 		.procname	= "dirty_background_ratio",
1009 		.data		= &dirty_background_ratio,
1010 		.maxlen		= sizeof(dirty_background_ratio),
1011 		.mode		= 0644,
1012 		.proc_handler	= &dirty_background_ratio_handler,
1013 		.strategy	= &sysctl_intvec,
1014 		.extra1		= &zero,
1015 		.extra2		= &one_hundred,
1016 	},
1017 	{
1018 		.ctl_name	= CTL_UNNUMBERED,
1019 		.procname	= "dirty_background_bytes",
1020 		.data		= &dirty_background_bytes,
1021 		.maxlen		= sizeof(dirty_background_bytes),
1022 		.mode		= 0644,
1023 		.proc_handler	= &dirty_background_bytes_handler,
1024 		.strategy	= &sysctl_intvec,
1025 		.extra1		= &one_ul,
1026 	},
1027 	{
1028 		.ctl_name	= VM_DIRTY_RATIO,
1029 		.procname	= "dirty_ratio",
1030 		.data		= &vm_dirty_ratio,
1031 		.maxlen		= sizeof(vm_dirty_ratio),
1032 		.mode		= 0644,
1033 		.proc_handler	= &dirty_ratio_handler,
1034 		.strategy	= &sysctl_intvec,
1035 		.extra1		= &zero,
1036 		.extra2		= &one_hundred,
1037 	},
1038 	{
1039 		.ctl_name	= CTL_UNNUMBERED,
1040 		.procname	= "dirty_bytes",
1041 		.data		= &vm_dirty_bytes,
1042 		.maxlen		= sizeof(vm_dirty_bytes),
1043 		.mode		= 0644,
1044 		.proc_handler	= &dirty_bytes_handler,
1045 		.strategy	= &sysctl_intvec,
1046 		.extra1		= &dirty_bytes_min,
1047 	},
1048 	{
1049 		.procname	= "dirty_writeback_centisecs",
1050 		.data		= &dirty_writeback_interval,
1051 		.maxlen		= sizeof(dirty_writeback_interval),
1052 		.mode		= 0644,
1053 		.proc_handler	= &dirty_writeback_centisecs_handler,
1054 	},
1055 	{
1056 		.procname	= "dirty_expire_centisecs",
1057 		.data		= &dirty_expire_interval,
1058 		.maxlen		= sizeof(dirty_expire_interval),
1059 		.mode		= 0644,
1060 		.proc_handler	= &proc_dointvec,
1061 	},
1062 	{
1063 		.ctl_name	= VM_NR_PDFLUSH_THREADS,
1064 		.procname	= "nr_pdflush_threads",
1065 		.data		= &nr_pdflush_threads,
1066 		.maxlen		= sizeof nr_pdflush_threads,
1067 		.mode		= 0444 /* read-only*/,
1068 		.proc_handler	= &proc_dointvec,
1069 	},
1070 	{
1071 		.ctl_name	= VM_SWAPPINESS,
1072 		.procname	= "swappiness",
1073 		.data		= &vm_swappiness,
1074 		.maxlen		= sizeof(vm_swappiness),
1075 		.mode		= 0644,
1076 		.proc_handler	= &proc_dointvec_minmax,
1077 		.strategy	= &sysctl_intvec,
1078 		.extra1		= &zero,
1079 		.extra2		= &one_hundred,
1080 	},
1081 #ifdef CONFIG_HUGETLB_PAGE
1082 	 {
1083 		.procname	= "nr_hugepages",
1084 		.data		= NULL,
1085 		.maxlen		= sizeof(unsigned long),
1086 		.mode		= 0644,
1087 		.proc_handler	= &hugetlb_sysctl_handler,
1088 		.extra1		= (void *)&hugetlb_zero,
1089 		.extra2		= (void *)&hugetlb_infinity,
1090 	 },
1091 	 {
1092 		.ctl_name	= VM_HUGETLB_GROUP,
1093 		.procname	= "hugetlb_shm_group",
1094 		.data		= &sysctl_hugetlb_shm_group,
1095 		.maxlen		= sizeof(gid_t),
1096 		.mode		= 0644,
1097 		.proc_handler	= &proc_dointvec,
1098 	 },
1099 	 {
1100 		.ctl_name	= CTL_UNNUMBERED,
1101 		.procname	= "hugepages_treat_as_movable",
1102 		.data		= &hugepages_treat_as_movable,
1103 		.maxlen		= sizeof(int),
1104 		.mode		= 0644,
1105 		.proc_handler	= &hugetlb_treat_movable_handler,
1106 	},
1107 	{
1108 		.ctl_name	= CTL_UNNUMBERED,
1109 		.procname	= "nr_overcommit_hugepages",
1110 		.data		= NULL,
1111 		.maxlen		= sizeof(unsigned long),
1112 		.mode		= 0644,
1113 		.proc_handler	= &hugetlb_overcommit_handler,
1114 		.extra1		= (void *)&hugetlb_zero,
1115 		.extra2		= (void *)&hugetlb_infinity,
1116 	},
1117 #endif
1118 	{
1119 		.ctl_name	= VM_LOWMEM_RESERVE_RATIO,
1120 		.procname	= "lowmem_reserve_ratio",
1121 		.data		= &sysctl_lowmem_reserve_ratio,
1122 		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
1123 		.mode		= 0644,
1124 		.proc_handler	= &lowmem_reserve_ratio_sysctl_handler,
1125 		.strategy	= &sysctl_intvec,
1126 	},
1127 	{
1128 		.ctl_name	= VM_DROP_PAGECACHE,
1129 		.procname	= "drop_caches",
1130 		.data		= &sysctl_drop_caches,
1131 		.maxlen		= sizeof(int),
1132 		.mode		= 0644,
1133 		.proc_handler	= drop_caches_sysctl_handler,
1134 		.strategy	= &sysctl_intvec,
1135 	},
1136 	{
1137 		.ctl_name	= VM_MIN_FREE_KBYTES,
1138 		.procname	= "min_free_kbytes",
1139 		.data		= &min_free_kbytes,
1140 		.maxlen		= sizeof(min_free_kbytes),
1141 		.mode		= 0644,
1142 		.proc_handler	= &min_free_kbytes_sysctl_handler,
1143 		.strategy	= &sysctl_intvec,
1144 		.extra1		= &zero,
1145 	},
1146 	{
1147 		.ctl_name	= VM_PERCPU_PAGELIST_FRACTION,
1148 		.procname	= "percpu_pagelist_fraction",
1149 		.data		= &percpu_pagelist_fraction,
1150 		.maxlen		= sizeof(percpu_pagelist_fraction),
1151 		.mode		= 0644,
1152 		.proc_handler	= &percpu_pagelist_fraction_sysctl_handler,
1153 		.strategy	= &sysctl_intvec,
1154 		.extra1		= &min_percpu_pagelist_fract,
1155 	},
1156 #ifdef CONFIG_MMU
1157 	{
1158 		.ctl_name	= VM_MAX_MAP_COUNT,
1159 		.procname	= "max_map_count",
1160 		.data		= &sysctl_max_map_count,
1161 		.maxlen		= sizeof(sysctl_max_map_count),
1162 		.mode		= 0644,
1163 		.proc_handler	= &proc_dointvec
1164 	},
1165 #else
1166 	{
1167 		.ctl_name	= CTL_UNNUMBERED,
1168 		.procname	= "nr_trim_pages",
1169 		.data		= &sysctl_nr_trim_pages,
1170 		.maxlen		= sizeof(sysctl_nr_trim_pages),
1171 		.mode		= 0644,
1172 		.proc_handler	= &proc_dointvec_minmax,
1173 		.strategy	= &sysctl_intvec,
1174 		.extra1		= &zero,
1175 	},
1176 #endif
1177 	{
1178 		.ctl_name	= VM_LAPTOP_MODE,
1179 		.procname	= "laptop_mode",
1180 		.data		= &laptop_mode,
1181 		.maxlen		= sizeof(laptop_mode),
1182 		.mode		= 0644,
1183 		.proc_handler	= &proc_dointvec_jiffies,
1184 		.strategy	= &sysctl_jiffies,
1185 	},
1186 	{
1187 		.ctl_name	= VM_BLOCK_DUMP,
1188 		.procname	= "block_dump",
1189 		.data		= &block_dump,
1190 		.maxlen		= sizeof(block_dump),
1191 		.mode		= 0644,
1192 		.proc_handler	= &proc_dointvec,
1193 		.strategy	= &sysctl_intvec,
1194 		.extra1		= &zero,
1195 	},
1196 	{
1197 		.ctl_name	= VM_VFS_CACHE_PRESSURE,
1198 		.procname	= "vfs_cache_pressure",
1199 		.data		= &sysctl_vfs_cache_pressure,
1200 		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
1201 		.mode		= 0644,
1202 		.proc_handler	= &proc_dointvec,
1203 		.strategy	= &sysctl_intvec,
1204 		.extra1		= &zero,
1205 	},
1206 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1207 	{
1208 		.ctl_name	= VM_LEGACY_VA_LAYOUT,
1209 		.procname	= "legacy_va_layout",
1210 		.data		= &sysctl_legacy_va_layout,
1211 		.maxlen		= sizeof(sysctl_legacy_va_layout),
1212 		.mode		= 0644,
1213 		.proc_handler	= &proc_dointvec,
1214 		.strategy	= &sysctl_intvec,
1215 		.extra1		= &zero,
1216 	},
1217 #endif
1218 #ifdef CONFIG_NUMA
1219 	{
1220 		.ctl_name	= VM_ZONE_RECLAIM_MODE,
1221 		.procname	= "zone_reclaim_mode",
1222 		.data		= &zone_reclaim_mode,
1223 		.maxlen		= sizeof(zone_reclaim_mode),
1224 		.mode		= 0644,
1225 		.proc_handler	= &proc_dointvec,
1226 		.strategy	= &sysctl_intvec,
1227 		.extra1		= &zero,
1228 	},
1229 	{
1230 		.ctl_name	= VM_MIN_UNMAPPED,
1231 		.procname	= "min_unmapped_ratio",
1232 		.data		= &sysctl_min_unmapped_ratio,
1233 		.maxlen		= sizeof(sysctl_min_unmapped_ratio),
1234 		.mode		= 0644,
1235 		.proc_handler	= &sysctl_min_unmapped_ratio_sysctl_handler,
1236 		.strategy	= &sysctl_intvec,
1237 		.extra1		= &zero,
1238 		.extra2		= &one_hundred,
1239 	},
1240 	{
1241 		.ctl_name	= VM_MIN_SLAB,
1242 		.procname	= "min_slab_ratio",
1243 		.data		= &sysctl_min_slab_ratio,
1244 		.maxlen		= sizeof(sysctl_min_slab_ratio),
1245 		.mode		= 0644,
1246 		.proc_handler	= &sysctl_min_slab_ratio_sysctl_handler,
1247 		.strategy	= &sysctl_intvec,
1248 		.extra1		= &zero,
1249 		.extra2		= &one_hundred,
1250 	},
1251 #endif
1252 #ifdef CONFIG_SMP
1253 	{
1254 		.ctl_name	= CTL_UNNUMBERED,
1255 		.procname	= "stat_interval",
1256 		.data		= &sysctl_stat_interval,
1257 		.maxlen		= sizeof(sysctl_stat_interval),
1258 		.mode		= 0644,
1259 		.proc_handler	= &proc_dointvec_jiffies,
1260 		.strategy	= &sysctl_jiffies,
1261 	},
1262 #endif
1263 #ifdef CONFIG_SECURITY
1264 	{
1265 		.ctl_name	= CTL_UNNUMBERED,
1266 		.procname	= "mmap_min_addr",
1267 		.data		= &mmap_min_addr,
1268 		.maxlen         = sizeof(unsigned long),
1269 		.mode		= 0644,
1270 		.proc_handler	= &proc_doulongvec_minmax,
1271 	},
1272 #endif
1273 #ifdef CONFIG_NUMA
1274 	{
1275 		.ctl_name	= CTL_UNNUMBERED,
1276 		.procname	= "numa_zonelist_order",
1277 		.data		= &numa_zonelist_order,
1278 		.maxlen		= NUMA_ZONELIST_ORDER_LEN,
1279 		.mode		= 0644,
1280 		.proc_handler	= &numa_zonelist_order_handler,
1281 		.strategy	= &sysctl_string,
1282 	},
1283 #endif
1284 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
1285    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
1286 	{
1287 		.ctl_name	= VM_VDSO_ENABLED,
1288 		.procname	= "vdso_enabled",
1289 		.data		= &vdso_enabled,
1290 		.maxlen		= sizeof(vdso_enabled),
1291 		.mode		= 0644,
1292 		.proc_handler	= &proc_dointvec,
1293 		.strategy	= &sysctl_intvec,
1294 		.extra1		= &zero,
1295 	},
1296 #endif
1297 #ifdef CONFIG_HIGHMEM
1298 	{
1299 		.ctl_name	= CTL_UNNUMBERED,
1300 		.procname	= "highmem_is_dirtyable",
1301 		.data		= &vm_highmem_is_dirtyable,
1302 		.maxlen		= sizeof(vm_highmem_is_dirtyable),
1303 		.mode		= 0644,
1304 		.proc_handler	= &proc_dointvec_minmax,
1305 		.strategy	= &sysctl_intvec,
1306 		.extra1		= &zero,
1307 		.extra2		= &one,
1308 	},
1309 #endif
1310 #ifdef CONFIG_UNEVICTABLE_LRU
1311 	{
1312 		.ctl_name	= CTL_UNNUMBERED,
1313 		.procname	= "scan_unevictable_pages",
1314 		.data		= &scan_unevictable_pages,
1315 		.maxlen		= sizeof(scan_unevictable_pages),
1316 		.mode		= 0644,
1317 		.proc_handler	= &scan_unevictable_handler,
1318 	},
1319 #endif
1320 /*
1321  * NOTE: do not add new entries to this table unless you have read
1322  * Documentation/sysctl/ctl_unnumbered.txt
1323  */
1324 	{ .ctl_name = 0 }
1325 };
1326 
1327 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1328 static struct ctl_table binfmt_misc_table[] = {
1329 	{ .ctl_name = 0 }
1330 };
1331 #endif
1332 
1333 static struct ctl_table fs_table[] = {
1334 	{
1335 		.ctl_name	= FS_NRINODE,
1336 		.procname	= "inode-nr",
1337 		.data		= &inodes_stat,
1338 		.maxlen		= 2*sizeof(int),
1339 		.mode		= 0444,
1340 		.proc_handler	= &proc_dointvec,
1341 	},
1342 	{
1343 		.ctl_name	= FS_STATINODE,
1344 		.procname	= "inode-state",
1345 		.data		= &inodes_stat,
1346 		.maxlen		= 7*sizeof(int),
1347 		.mode		= 0444,
1348 		.proc_handler	= &proc_dointvec,
1349 	},
1350 	{
1351 		.procname	= "file-nr",
1352 		.data		= &files_stat,
1353 		.maxlen		= 3*sizeof(int),
1354 		.mode		= 0444,
1355 		.proc_handler	= &proc_nr_files,
1356 	},
1357 	{
1358 		.ctl_name	= FS_MAXFILE,
1359 		.procname	= "file-max",
1360 		.data		= &files_stat.max_files,
1361 		.maxlen		= sizeof(int),
1362 		.mode		= 0644,
1363 		.proc_handler	= &proc_dointvec,
1364 	},
1365 	{
1366 		.ctl_name	= CTL_UNNUMBERED,
1367 		.procname	= "nr_open",
1368 		.data		= &sysctl_nr_open,
1369 		.maxlen		= sizeof(int),
1370 		.mode		= 0644,
1371 		.proc_handler	= &proc_dointvec_minmax,
1372 		.extra1		= &sysctl_nr_open_min,
1373 		.extra2		= &sysctl_nr_open_max,
1374 	},
1375 	{
1376 		.ctl_name	= FS_DENTRY,
1377 		.procname	= "dentry-state",
1378 		.data		= &dentry_stat,
1379 		.maxlen		= 6*sizeof(int),
1380 		.mode		= 0444,
1381 		.proc_handler	= &proc_dointvec,
1382 	},
1383 	{
1384 		.ctl_name	= FS_OVERFLOWUID,
1385 		.procname	= "overflowuid",
1386 		.data		= &fs_overflowuid,
1387 		.maxlen		= sizeof(int),
1388 		.mode		= 0644,
1389 		.proc_handler	= &proc_dointvec_minmax,
1390 		.strategy	= &sysctl_intvec,
1391 		.extra1		= &minolduid,
1392 		.extra2		= &maxolduid,
1393 	},
1394 	{
1395 		.ctl_name	= FS_OVERFLOWGID,
1396 		.procname	= "overflowgid",
1397 		.data		= &fs_overflowgid,
1398 		.maxlen		= sizeof(int),
1399 		.mode		= 0644,
1400 		.proc_handler	= &proc_dointvec_minmax,
1401 		.strategy	= &sysctl_intvec,
1402 		.extra1		= &minolduid,
1403 		.extra2		= &maxolduid,
1404 	},
1405 #ifdef CONFIG_FILE_LOCKING
1406 	{
1407 		.ctl_name	= FS_LEASES,
1408 		.procname	= "leases-enable",
1409 		.data		= &leases_enable,
1410 		.maxlen		= sizeof(int),
1411 		.mode		= 0644,
1412 		.proc_handler	= &proc_dointvec,
1413 	},
1414 #endif
1415 #ifdef CONFIG_DNOTIFY
1416 	{
1417 		.ctl_name	= FS_DIR_NOTIFY,
1418 		.procname	= "dir-notify-enable",
1419 		.data		= &dir_notify_enable,
1420 		.maxlen		= sizeof(int),
1421 		.mode		= 0644,
1422 		.proc_handler	= &proc_dointvec,
1423 	},
1424 #endif
1425 #ifdef CONFIG_MMU
1426 #ifdef CONFIG_FILE_LOCKING
1427 	{
1428 		.ctl_name	= FS_LEASE_TIME,
1429 		.procname	= "lease-break-time",
1430 		.data		= &lease_break_time,
1431 		.maxlen		= sizeof(int),
1432 		.mode		= 0644,
1433 		.proc_handler	= &proc_dointvec,
1434 	},
1435 #endif
1436 #ifdef CONFIG_AIO
1437 	{
1438 		.procname	= "aio-nr",
1439 		.data		= &aio_nr,
1440 		.maxlen		= sizeof(aio_nr),
1441 		.mode		= 0444,
1442 		.proc_handler	= &proc_doulongvec_minmax,
1443 	},
1444 	{
1445 		.procname	= "aio-max-nr",
1446 		.data		= &aio_max_nr,
1447 		.maxlen		= sizeof(aio_max_nr),
1448 		.mode		= 0644,
1449 		.proc_handler	= &proc_doulongvec_minmax,
1450 	},
1451 #endif /* CONFIG_AIO */
1452 #ifdef CONFIG_INOTIFY_USER
1453 	{
1454 		.ctl_name	= FS_INOTIFY,
1455 		.procname	= "inotify",
1456 		.mode		= 0555,
1457 		.child		= inotify_table,
1458 	},
1459 #endif
1460 #ifdef CONFIG_EPOLL
1461 	{
1462 		.procname	= "epoll",
1463 		.mode		= 0555,
1464 		.child		= epoll_table,
1465 	},
1466 #endif
1467 #endif
1468 	{
1469 		.ctl_name	= KERN_SETUID_DUMPABLE,
1470 		.procname	= "suid_dumpable",
1471 		.data		= &suid_dumpable,
1472 		.maxlen		= sizeof(int),
1473 		.mode		= 0644,
1474 		.proc_handler	= &proc_dointvec_minmax,
1475 		.strategy	= &sysctl_intvec,
1476 		.extra1		= &zero,
1477 		.extra2		= &two,
1478 	},
1479 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1480 	{
1481 		.ctl_name	= CTL_UNNUMBERED,
1482 		.procname	= "binfmt_misc",
1483 		.mode		= 0555,
1484 		.child		= binfmt_misc_table,
1485 	},
1486 #endif
1487 /*
1488  * NOTE: do not add new entries to this table unless you have read
1489  * Documentation/sysctl/ctl_unnumbered.txt
1490  */
1491 	{ .ctl_name = 0 }
1492 };
1493 
1494 static struct ctl_table debug_table[] = {
1495 #if defined(CONFIG_X86) || defined(CONFIG_PPC)
1496 	{
1497 		.ctl_name	= CTL_UNNUMBERED,
1498 		.procname	= "exception-trace",
1499 		.data		= &show_unhandled_signals,
1500 		.maxlen		= sizeof(int),
1501 		.mode		= 0644,
1502 		.proc_handler	= proc_dointvec
1503 	},
1504 #endif
1505 	{ .ctl_name = 0 }
1506 };
1507 
1508 static struct ctl_table dev_table[] = {
1509 	{ .ctl_name = 0 }
1510 };
1511 
1512 static DEFINE_SPINLOCK(sysctl_lock);
1513 
1514 /* called under sysctl_lock */
1515 static int use_table(struct ctl_table_header *p)
1516 {
1517 	if (unlikely(p->unregistering))
1518 		return 0;
1519 	p->used++;
1520 	return 1;
1521 }
1522 
1523 /* called under sysctl_lock */
1524 static void unuse_table(struct ctl_table_header *p)
1525 {
1526 	if (!--p->used)
1527 		if (unlikely(p->unregistering))
1528 			complete(p->unregistering);
1529 }
1530 
1531 /* called under sysctl_lock, will reacquire if has to wait */
1532 static void start_unregistering(struct ctl_table_header *p)
1533 {
1534 	/*
1535 	 * if p->used is 0, nobody will ever touch that entry again;
1536 	 * we'll eliminate all paths to it before dropping sysctl_lock
1537 	 */
1538 	if (unlikely(p->used)) {
1539 		struct completion wait;
1540 		init_completion(&wait);
1541 		p->unregistering = &wait;
1542 		spin_unlock(&sysctl_lock);
1543 		wait_for_completion(&wait);
1544 		spin_lock(&sysctl_lock);
1545 	} else {
1546 		/* anything non-NULL; we'll never dereference it */
1547 		p->unregistering = ERR_PTR(-EINVAL);
1548 	}
1549 	/*
1550 	 * do not remove from the list until nobody holds it; walking the
1551 	 * list in do_sysctl() relies on that.
1552 	 */
1553 	list_del_init(&p->ctl_entry);
1554 }
1555 
1556 void sysctl_head_get(struct ctl_table_header *head)
1557 {
1558 	spin_lock(&sysctl_lock);
1559 	head->count++;
1560 	spin_unlock(&sysctl_lock);
1561 }
1562 
1563 void sysctl_head_put(struct ctl_table_header *head)
1564 {
1565 	spin_lock(&sysctl_lock);
1566 	if (!--head->count)
1567 		kfree(head);
1568 	spin_unlock(&sysctl_lock);
1569 }
1570 
1571 struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *head)
1572 {
1573 	if (!head)
1574 		BUG();
1575 	spin_lock(&sysctl_lock);
1576 	if (!use_table(head))
1577 		head = ERR_PTR(-ENOENT);
1578 	spin_unlock(&sysctl_lock);
1579 	return head;
1580 }
1581 
1582 void sysctl_head_finish(struct ctl_table_header *head)
1583 {
1584 	if (!head)
1585 		return;
1586 	spin_lock(&sysctl_lock);
1587 	unuse_table(head);
1588 	spin_unlock(&sysctl_lock);
1589 }
1590 
1591 static struct ctl_table_set *
1592 lookup_header_set(struct ctl_table_root *root, struct nsproxy *namespaces)
1593 {
1594 	struct ctl_table_set *set = &root->default_set;
1595 	if (root->lookup)
1596 		set = root->lookup(root, namespaces);
1597 	return set;
1598 }
1599 
1600 static struct list_head *
1601 lookup_header_list(struct ctl_table_root *root, struct nsproxy *namespaces)
1602 {
1603 	struct ctl_table_set *set = lookup_header_set(root, namespaces);
1604 	return &set->list;
1605 }
1606 
1607 struct ctl_table_header *__sysctl_head_next(struct nsproxy *namespaces,
1608 					    struct ctl_table_header *prev)
1609 {
1610 	struct ctl_table_root *root;
1611 	struct list_head *header_list;
1612 	struct ctl_table_header *head;
1613 	struct list_head *tmp;
1614 
1615 	spin_lock(&sysctl_lock);
1616 	if (prev) {
1617 		head = prev;
1618 		tmp = &prev->ctl_entry;
1619 		unuse_table(prev);
1620 		goto next;
1621 	}
1622 	tmp = &root_table_header.ctl_entry;
1623 	for (;;) {
1624 		head = list_entry(tmp, struct ctl_table_header, ctl_entry);
1625 
1626 		if (!use_table(head))
1627 			goto next;
1628 		spin_unlock(&sysctl_lock);
1629 		return head;
1630 	next:
1631 		root = head->root;
1632 		tmp = tmp->next;
1633 		header_list = lookup_header_list(root, namespaces);
1634 		if (tmp != header_list)
1635 			continue;
1636 
1637 		do {
1638 			root = list_entry(root->root_list.next,
1639 					struct ctl_table_root, root_list);
1640 			if (root == &sysctl_table_root)
1641 				goto out;
1642 			header_list = lookup_header_list(root, namespaces);
1643 		} while (list_empty(header_list));
1644 		tmp = header_list->next;
1645 	}
1646 out:
1647 	spin_unlock(&sysctl_lock);
1648 	return NULL;
1649 }
1650 
1651 struct ctl_table_header *sysctl_head_next(struct ctl_table_header *prev)
1652 {
1653 	return __sysctl_head_next(current->nsproxy, prev);
1654 }
1655 
1656 void register_sysctl_root(struct ctl_table_root *root)
1657 {
1658 	spin_lock(&sysctl_lock);
1659 	list_add_tail(&root->root_list, &sysctl_table_root.root_list);
1660 	spin_unlock(&sysctl_lock);
1661 }
1662 
1663 #ifdef CONFIG_SYSCTL_SYSCALL
1664 /* Perform the actual read/write of a sysctl table entry. */
1665 static int do_sysctl_strategy(struct ctl_table_root *root,
1666 			struct ctl_table *table,
1667 			void __user *oldval, size_t __user *oldlenp,
1668 			void __user *newval, size_t newlen)
1669 {
1670 	int op = 0, rc;
1671 
1672 	if (oldval)
1673 		op |= MAY_READ;
1674 	if (newval)
1675 		op |= MAY_WRITE;
1676 	if (sysctl_perm(root, table, op))
1677 		return -EPERM;
1678 
1679 	if (table->strategy) {
1680 		rc = table->strategy(table, oldval, oldlenp, newval, newlen);
1681 		if (rc < 0)
1682 			return rc;
1683 		if (rc > 0)
1684 			return 0;
1685 	}
1686 
1687 	/* If there is no strategy routine, or if the strategy returns
1688 	 * zero, proceed with automatic r/w */
1689 	if (table->data && table->maxlen) {
1690 		rc = sysctl_data(table, oldval, oldlenp, newval, newlen);
1691 		if (rc < 0)
1692 			return rc;
1693 	}
1694 	return 0;
1695 }
1696 
1697 static int parse_table(int __user *name, int nlen,
1698 		       void __user *oldval, size_t __user *oldlenp,
1699 		       void __user *newval, size_t newlen,
1700 		       struct ctl_table_root *root,
1701 		       struct ctl_table *table)
1702 {
1703 	int n;
1704 repeat:
1705 	if (!nlen)
1706 		return -ENOTDIR;
1707 	if (get_user(n, name))
1708 		return -EFAULT;
1709 	for ( ; table->ctl_name || table->procname; table++) {
1710 		if (!table->ctl_name)
1711 			continue;
1712 		if (n == table->ctl_name) {
1713 			int error;
1714 			if (table->child) {
1715 				if (sysctl_perm(root, table, MAY_EXEC))
1716 					return -EPERM;
1717 				name++;
1718 				nlen--;
1719 				table = table->child;
1720 				goto repeat;
1721 			}
1722 			error = do_sysctl_strategy(root, table,
1723 						   oldval, oldlenp,
1724 						   newval, newlen);
1725 			return error;
1726 		}
1727 	}
1728 	return -ENOTDIR;
1729 }
1730 
1731 int do_sysctl(int __user *name, int nlen, void __user *oldval, size_t __user *oldlenp,
1732 	       void __user *newval, size_t newlen)
1733 {
1734 	struct ctl_table_header *head;
1735 	int error = -ENOTDIR;
1736 
1737 	if (nlen <= 0 || nlen >= CTL_MAXNAME)
1738 		return -ENOTDIR;
1739 	if (oldval) {
1740 		int old_len;
1741 		if (!oldlenp || get_user(old_len, oldlenp))
1742 			return -EFAULT;
1743 	}
1744 
1745 	for (head = sysctl_head_next(NULL); head;
1746 			head = sysctl_head_next(head)) {
1747 		error = parse_table(name, nlen, oldval, oldlenp,
1748 					newval, newlen,
1749 					head->root, head->ctl_table);
1750 		if (error != -ENOTDIR) {
1751 			sysctl_head_finish(head);
1752 			break;
1753 		}
1754 	}
1755 	return error;
1756 }
1757 
1758 SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
1759 {
1760 	struct __sysctl_args tmp;
1761 	int error;
1762 
1763 	if (copy_from_user(&tmp, args, sizeof(tmp)))
1764 		return -EFAULT;
1765 
1766 	error = deprecated_sysctl_warning(&tmp);
1767 	if (error)
1768 		goto out;
1769 
1770 	lock_kernel();
1771 	error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,
1772 			  tmp.newval, tmp.newlen);
1773 	unlock_kernel();
1774 out:
1775 	return error;
1776 }
1777 #endif /* CONFIG_SYSCTL_SYSCALL */
1778 
1779 /*
1780  * sysctl_perm does NOT grant the superuser all rights automatically, because
1781  * some sysctl variables are readonly even to root.
1782  */
1783 
1784 static int test_perm(int mode, int op)
1785 {
1786 	if (!current_euid())
1787 		mode >>= 6;
1788 	else if (in_egroup_p(0))
1789 		mode >>= 3;
1790 	if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
1791 		return 0;
1792 	return -EACCES;
1793 }
1794 
1795 int sysctl_perm(struct ctl_table_root *root, struct ctl_table *table, int op)
1796 {
1797 	int error;
1798 	int mode;
1799 
1800 	error = security_sysctl(table, op & (MAY_READ | MAY_WRITE | MAY_EXEC));
1801 	if (error)
1802 		return error;
1803 
1804 	if (root->permissions)
1805 		mode = root->permissions(root, current->nsproxy, table);
1806 	else
1807 		mode = table->mode;
1808 
1809 	return test_perm(mode, op);
1810 }
1811 
1812 static void sysctl_set_parent(struct ctl_table *parent, struct ctl_table *table)
1813 {
1814 	for (; table->ctl_name || table->procname; table++) {
1815 		table->parent = parent;
1816 		if (table->child)
1817 			sysctl_set_parent(table, table->child);
1818 	}
1819 }
1820 
1821 static __init int sysctl_init(void)
1822 {
1823 	sysctl_set_parent(NULL, root_table);
1824 #ifdef CONFIG_SYSCTL_SYSCALL_CHECK
1825 	{
1826 		int err;
1827 		err = sysctl_check_table(current->nsproxy, root_table);
1828 	}
1829 #endif
1830 	return 0;
1831 }
1832 
1833 core_initcall(sysctl_init);
1834 
1835 static struct ctl_table *is_branch_in(struct ctl_table *branch,
1836 				      struct ctl_table *table)
1837 {
1838 	struct ctl_table *p;
1839 	const char *s = branch->procname;
1840 
1841 	/* branch should have named subdirectory as its first element */
1842 	if (!s || !branch->child)
1843 		return NULL;
1844 
1845 	/* ... and nothing else */
1846 	if (branch[1].procname || branch[1].ctl_name)
1847 		return NULL;
1848 
1849 	/* table should contain subdirectory with the same name */
1850 	for (p = table; p->procname || p->ctl_name; p++) {
1851 		if (!p->child)
1852 			continue;
1853 		if (p->procname && strcmp(p->procname, s) == 0)
1854 			return p;
1855 	}
1856 	return NULL;
1857 }
1858 
1859 /* see if attaching q to p would be an improvement */
1860 static void try_attach(struct ctl_table_header *p, struct ctl_table_header *q)
1861 {
1862 	struct ctl_table *to = p->ctl_table, *by = q->ctl_table;
1863 	struct ctl_table *next;
1864 	int is_better = 0;
1865 	int not_in_parent = !p->attached_by;
1866 
1867 	while ((next = is_branch_in(by, to)) != NULL) {
1868 		if (by == q->attached_by)
1869 			is_better = 1;
1870 		if (to == p->attached_by)
1871 			not_in_parent = 1;
1872 		by = by->child;
1873 		to = next->child;
1874 	}
1875 
1876 	if (is_better && not_in_parent) {
1877 		q->attached_by = by;
1878 		q->attached_to = to;
1879 		q->parent = p;
1880 	}
1881 }
1882 
1883 /**
1884  * __register_sysctl_paths - register a sysctl hierarchy
1885  * @root: List of sysctl headers to register on
1886  * @namespaces: Data to compute which lists of sysctl entries are visible
1887  * @path: The path to the directory the sysctl table is in.
1888  * @table: the top-level table structure
1889  *
1890  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
1891  * array. A completely 0 filled entry terminates the table.
1892  *
1893  * The members of the &struct ctl_table structure are used as follows:
1894  *
1895  * ctl_name - This is the numeric sysctl value used by sysctl(2). The number
1896  *            must be unique within that level of sysctl
1897  *
1898  * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
1899  *            enter a sysctl file
1900  *
1901  * data - a pointer to data for use by proc_handler
1902  *
1903  * maxlen - the maximum size in bytes of the data
1904  *
1905  * mode - the file permissions for the /proc/sys file, and for sysctl(2)
1906  *
1907  * child - a pointer to the child sysctl table if this entry is a directory, or
1908  *         %NULL.
1909  *
1910  * proc_handler - the text handler routine (described below)
1911  *
1912  * strategy - the strategy routine (described below)
1913  *
1914  * de - for internal use by the sysctl routines
1915  *
1916  * extra1, extra2 - extra pointers usable by the proc handler routines
1917  *
1918  * Leaf nodes in the sysctl tree will be represented by a single file
1919  * under /proc; non-leaf nodes will be represented by directories.
1920  *
1921  * sysctl(2) can automatically manage read and write requests through
1922  * the sysctl table.  The data and maxlen fields of the ctl_table
1923  * struct enable minimal validation of the values being written to be
1924  * performed, and the mode field allows minimal authentication.
1925  *
1926  * More sophisticated management can be enabled by the provision of a
1927  * strategy routine with the table entry.  This will be called before
1928  * any automatic read or write of the data is performed.
1929  *
1930  * The strategy routine may return
1931  *
1932  * < 0 - Error occurred (error is passed to user process)
1933  *
1934  * 0   - OK - proceed with automatic read or write.
1935  *
1936  * > 0 - OK - read or write has been done by the strategy routine, so
1937  *       return immediately.
1938  *
1939  * There must be a proc_handler routine for any terminal nodes
1940  * mirrored under /proc/sys (non-terminals are handled by a built-in
1941  * directory handler).  Several default handlers are available to
1942  * cover common cases -
1943  *
1944  * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
1945  * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
1946  * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
1947  *
1948  * It is the handler's job to read the input buffer from user memory
1949  * and process it. The handler should return 0 on success.
1950  *
1951  * This routine returns %NULL on a failure to register, and a pointer
1952  * to the table header on success.
1953  */
1954 struct ctl_table_header *__register_sysctl_paths(
1955 	struct ctl_table_root *root,
1956 	struct nsproxy *namespaces,
1957 	const struct ctl_path *path, struct ctl_table *table)
1958 {
1959 	struct ctl_table_header *header;
1960 	struct ctl_table *new, **prevp;
1961 	unsigned int n, npath;
1962 	struct ctl_table_set *set;
1963 
1964 	/* Count the path components */
1965 	for (npath = 0; path[npath].ctl_name || path[npath].procname; ++npath)
1966 		;
1967 
1968 	/*
1969 	 * For each path component, allocate a 2-element ctl_table array.
1970 	 * The first array element will be filled with the sysctl entry
1971 	 * for this, the second will be the sentinel (ctl_name == 0).
1972 	 *
1973 	 * We allocate everything in one go so that we don't have to
1974 	 * worry about freeing additional memory in unregister_sysctl_table.
1975 	 */
1976 	header = kzalloc(sizeof(struct ctl_table_header) +
1977 			 (2 * npath * sizeof(struct ctl_table)), GFP_KERNEL);
1978 	if (!header)
1979 		return NULL;
1980 
1981 	new = (struct ctl_table *) (header + 1);
1982 
1983 	/* Now connect the dots */
1984 	prevp = &header->ctl_table;
1985 	for (n = 0; n < npath; ++n, ++path) {
1986 		/* Copy the procname */
1987 		new->procname = path->procname;
1988 		new->ctl_name = path->ctl_name;
1989 		new->mode     = 0555;
1990 
1991 		*prevp = new;
1992 		prevp = &new->child;
1993 
1994 		new += 2;
1995 	}
1996 	*prevp = table;
1997 	header->ctl_table_arg = table;
1998 
1999 	INIT_LIST_HEAD(&header->ctl_entry);
2000 	header->used = 0;
2001 	header->unregistering = NULL;
2002 	header->root = root;
2003 	sysctl_set_parent(NULL, header->ctl_table);
2004 	header->count = 1;
2005 #ifdef CONFIG_SYSCTL_SYSCALL_CHECK
2006 	if (sysctl_check_table(namespaces, header->ctl_table)) {
2007 		kfree(header);
2008 		return NULL;
2009 	}
2010 #endif
2011 	spin_lock(&sysctl_lock);
2012 	header->set = lookup_header_set(root, namespaces);
2013 	header->attached_by = header->ctl_table;
2014 	header->attached_to = root_table;
2015 	header->parent = &root_table_header;
2016 	for (set = header->set; set; set = set->parent) {
2017 		struct ctl_table_header *p;
2018 		list_for_each_entry(p, &set->list, ctl_entry) {
2019 			if (p->unregistering)
2020 				continue;
2021 			try_attach(p, header);
2022 		}
2023 	}
2024 	header->parent->count++;
2025 	list_add_tail(&header->ctl_entry, &header->set->list);
2026 	spin_unlock(&sysctl_lock);
2027 
2028 	return header;
2029 }
2030 
2031 /**
2032  * register_sysctl_table_path - register a sysctl table hierarchy
2033  * @path: The path to the directory the sysctl table is in.
2034  * @table: the top-level table structure
2035  *
2036  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
2037  * array. A completely 0 filled entry terminates the table.
2038  *
2039  * See __register_sysctl_paths for more details.
2040  */
2041 struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
2042 						struct ctl_table *table)
2043 {
2044 	return __register_sysctl_paths(&sysctl_table_root, current->nsproxy,
2045 					path, table);
2046 }
2047 
2048 /**
2049  * register_sysctl_table - register a sysctl table hierarchy
2050  * @table: the top-level table structure
2051  *
2052  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
2053  * array. A completely 0 filled entry terminates the table.
2054  *
2055  * See register_sysctl_paths for more details.
2056  */
2057 struct ctl_table_header *register_sysctl_table(struct ctl_table *table)
2058 {
2059 	static const struct ctl_path null_path[] = { {} };
2060 
2061 	return register_sysctl_paths(null_path, table);
2062 }
2063 
2064 /**
2065  * unregister_sysctl_table - unregister a sysctl table hierarchy
2066  * @header: the header returned from register_sysctl_table
2067  *
2068  * Unregisters the sysctl table and all children. proc entries may not
2069  * actually be removed until they are no longer used by anyone.
2070  */
2071 void unregister_sysctl_table(struct ctl_table_header * header)
2072 {
2073 	might_sleep();
2074 
2075 	if (header == NULL)
2076 		return;
2077 
2078 	spin_lock(&sysctl_lock);
2079 	start_unregistering(header);
2080 	if (!--header->parent->count) {
2081 		WARN_ON(1);
2082 		kfree(header->parent);
2083 	}
2084 	if (!--header->count)
2085 		kfree(header);
2086 	spin_unlock(&sysctl_lock);
2087 }
2088 
2089 int sysctl_is_seen(struct ctl_table_header *p)
2090 {
2091 	struct ctl_table_set *set = p->set;
2092 	int res;
2093 	spin_lock(&sysctl_lock);
2094 	if (p->unregistering)
2095 		res = 0;
2096 	else if (!set->is_seen)
2097 		res = 1;
2098 	else
2099 		res = set->is_seen(set);
2100 	spin_unlock(&sysctl_lock);
2101 	return res;
2102 }
2103 
2104 void setup_sysctl_set(struct ctl_table_set *p,
2105 	struct ctl_table_set *parent,
2106 	int (*is_seen)(struct ctl_table_set *))
2107 {
2108 	INIT_LIST_HEAD(&p->list);
2109 	p->parent = parent ? parent : &sysctl_table_root.default_set;
2110 	p->is_seen = is_seen;
2111 }
2112 
2113 #else /* !CONFIG_SYSCTL */
2114 struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
2115 {
2116 	return NULL;
2117 }
2118 
2119 struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
2120 						    struct ctl_table *table)
2121 {
2122 	return NULL;
2123 }
2124 
2125 void unregister_sysctl_table(struct ctl_table_header * table)
2126 {
2127 }
2128 
2129 void setup_sysctl_set(struct ctl_table_set *p,
2130 	struct ctl_table_set *parent,
2131 	int (*is_seen)(struct ctl_table_set *))
2132 {
2133 }
2134 
2135 void sysctl_head_put(struct ctl_table_header *head)
2136 {
2137 }
2138 
2139 #endif /* CONFIG_SYSCTL */
2140 
2141 /*
2142  * /proc/sys support
2143  */
2144 
2145 #ifdef CONFIG_PROC_SYSCTL
2146 
2147 static int _proc_do_string(void* data, int maxlen, int write,
2148 			   struct file *filp, void __user *buffer,
2149 			   size_t *lenp, loff_t *ppos)
2150 {
2151 	size_t len;
2152 	char __user *p;
2153 	char c;
2154 
2155 	if (!data || !maxlen || !*lenp) {
2156 		*lenp = 0;
2157 		return 0;
2158 	}
2159 
2160 	if (write) {
2161 		len = 0;
2162 		p = buffer;
2163 		while (len < *lenp) {
2164 			if (get_user(c, p++))
2165 				return -EFAULT;
2166 			if (c == 0 || c == '\n')
2167 				break;
2168 			len++;
2169 		}
2170 		if (len >= maxlen)
2171 			len = maxlen-1;
2172 		if(copy_from_user(data, buffer, len))
2173 			return -EFAULT;
2174 		((char *) data)[len] = 0;
2175 		*ppos += *lenp;
2176 	} else {
2177 		len = strlen(data);
2178 		if (len > maxlen)
2179 			len = maxlen;
2180 
2181 		if (*ppos > len) {
2182 			*lenp = 0;
2183 			return 0;
2184 		}
2185 
2186 		data += *ppos;
2187 		len  -= *ppos;
2188 
2189 		if (len > *lenp)
2190 			len = *lenp;
2191 		if (len)
2192 			if(copy_to_user(buffer, data, len))
2193 				return -EFAULT;
2194 		if (len < *lenp) {
2195 			if(put_user('\n', ((char __user *) buffer) + len))
2196 				return -EFAULT;
2197 			len++;
2198 		}
2199 		*lenp = len;
2200 		*ppos += len;
2201 	}
2202 	return 0;
2203 }
2204 
2205 /**
2206  * proc_dostring - read a string sysctl
2207  * @table: the sysctl table
2208  * @write: %TRUE if this is a write to the sysctl file
2209  * @filp: the file structure
2210  * @buffer: the user buffer
2211  * @lenp: the size of the user buffer
2212  * @ppos: file position
2213  *
2214  * Reads/writes a string from/to the user buffer. If the kernel
2215  * buffer provided is not large enough to hold the string, the
2216  * string is truncated. The copied string is %NULL-terminated.
2217  * If the string is being read by the user process, it is copied
2218  * and a newline '\n' is added. It is truncated if the buffer is
2219  * not large enough.
2220  *
2221  * Returns 0 on success.
2222  */
2223 int proc_dostring(struct ctl_table *table, int write, struct file *filp,
2224 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2225 {
2226 	return _proc_do_string(table->data, table->maxlen, write, filp,
2227 			       buffer, lenp, ppos);
2228 }
2229 
2230 
2231 static int do_proc_dointvec_conv(int *negp, unsigned long *lvalp,
2232 				 int *valp,
2233 				 int write, void *data)
2234 {
2235 	if (write) {
2236 		*valp = *negp ? -*lvalp : *lvalp;
2237 	} else {
2238 		int val = *valp;
2239 		if (val < 0) {
2240 			*negp = -1;
2241 			*lvalp = (unsigned long)-val;
2242 		} else {
2243 			*negp = 0;
2244 			*lvalp = (unsigned long)val;
2245 		}
2246 	}
2247 	return 0;
2248 }
2249 
2250 static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
2251 		  int write, struct file *filp, void __user *buffer,
2252 		  size_t *lenp, loff_t *ppos,
2253 		  int (*conv)(int *negp, unsigned long *lvalp, int *valp,
2254 			      int write, void *data),
2255 		  void *data)
2256 {
2257 #define TMPBUFLEN 21
2258 	int *i, vleft, first=1, neg, val;
2259 	unsigned long lval;
2260 	size_t left, len;
2261 
2262 	char buf[TMPBUFLEN], *p;
2263 	char __user *s = buffer;
2264 
2265 	if (!tbl_data || !table->maxlen || !*lenp ||
2266 	    (*ppos && !write)) {
2267 		*lenp = 0;
2268 		return 0;
2269 	}
2270 
2271 	i = (int *) tbl_data;
2272 	vleft = table->maxlen / sizeof(*i);
2273 	left = *lenp;
2274 
2275 	if (!conv)
2276 		conv = do_proc_dointvec_conv;
2277 
2278 	for (; left && vleft--; i++, first=0) {
2279 		if (write) {
2280 			while (left) {
2281 				char c;
2282 				if (get_user(c, s))
2283 					return -EFAULT;
2284 				if (!isspace(c))
2285 					break;
2286 				left--;
2287 				s++;
2288 			}
2289 			if (!left)
2290 				break;
2291 			neg = 0;
2292 			len = left;
2293 			if (len > sizeof(buf) - 1)
2294 				len = sizeof(buf) - 1;
2295 			if (copy_from_user(buf, s, len))
2296 				return -EFAULT;
2297 			buf[len] = 0;
2298 			p = buf;
2299 			if (*p == '-' && left > 1) {
2300 				neg = 1;
2301 				p++;
2302 			}
2303 			if (*p < '0' || *p > '9')
2304 				break;
2305 
2306 			lval = simple_strtoul(p, &p, 0);
2307 
2308 			len = p-buf;
2309 			if ((len < left) && *p && !isspace(*p))
2310 				break;
2311 			if (neg)
2312 				val = -val;
2313 			s += len;
2314 			left -= len;
2315 
2316 			if (conv(&neg, &lval, i, 1, data))
2317 				break;
2318 		} else {
2319 			p = buf;
2320 			if (!first)
2321 				*p++ = '\t';
2322 
2323 			if (conv(&neg, &lval, i, 0, data))
2324 				break;
2325 
2326 			sprintf(p, "%s%lu", neg ? "-" : "", lval);
2327 			len = strlen(buf);
2328 			if (len > left)
2329 				len = left;
2330 			if(copy_to_user(s, buf, len))
2331 				return -EFAULT;
2332 			left -= len;
2333 			s += len;
2334 		}
2335 	}
2336 
2337 	if (!write && !first && left) {
2338 		if(put_user('\n', s))
2339 			return -EFAULT;
2340 		left--, s++;
2341 	}
2342 	if (write) {
2343 		while (left) {
2344 			char c;
2345 			if (get_user(c, s++))
2346 				return -EFAULT;
2347 			if (!isspace(c))
2348 				break;
2349 			left--;
2350 		}
2351 	}
2352 	if (write && first)
2353 		return -EINVAL;
2354 	*lenp -= left;
2355 	*ppos += *lenp;
2356 	return 0;
2357 #undef TMPBUFLEN
2358 }
2359 
2360 static int do_proc_dointvec(struct ctl_table *table, int write, struct file *filp,
2361 		  void __user *buffer, size_t *lenp, loff_t *ppos,
2362 		  int (*conv)(int *negp, unsigned long *lvalp, int *valp,
2363 			      int write, void *data),
2364 		  void *data)
2365 {
2366 	return __do_proc_dointvec(table->data, table, write, filp,
2367 			buffer, lenp, ppos, conv, data);
2368 }
2369 
2370 /**
2371  * proc_dointvec - read a vector of integers
2372  * @table: the sysctl table
2373  * @write: %TRUE if this is a write to the sysctl file
2374  * @filp: the file structure
2375  * @buffer: the user buffer
2376  * @lenp: the size of the user buffer
2377  * @ppos: file position
2378  *
2379  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2380  * values from/to the user buffer, treated as an ASCII string.
2381  *
2382  * Returns 0 on success.
2383  */
2384 int proc_dointvec(struct ctl_table *table, int write, struct file *filp,
2385 		     void __user *buffer, size_t *lenp, loff_t *ppos)
2386 {
2387     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
2388 		    	    NULL,NULL);
2389 }
2390 
2391 /*
2392  * Taint values can only be increased
2393  * This means we can safely use a temporary.
2394  */
2395 static int proc_taint(struct ctl_table *table, int write, struct file *filp,
2396 			       void __user *buffer, size_t *lenp, loff_t *ppos)
2397 {
2398 	struct ctl_table t;
2399 	unsigned long tmptaint = get_taint();
2400 	int err;
2401 
2402 	if (write && !capable(CAP_SYS_ADMIN))
2403 		return -EPERM;
2404 
2405 	t = *table;
2406 	t.data = &tmptaint;
2407 	err = proc_doulongvec_minmax(&t, write, filp, buffer, lenp, ppos);
2408 	if (err < 0)
2409 		return err;
2410 
2411 	if (write) {
2412 		/*
2413 		 * Poor man's atomic or. Not worth adding a primitive
2414 		 * to everyone's atomic.h for this
2415 		 */
2416 		int i;
2417 		for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
2418 			if ((tmptaint >> i) & 1)
2419 				add_taint(i);
2420 		}
2421 	}
2422 
2423 	return err;
2424 }
2425 
2426 struct do_proc_dointvec_minmax_conv_param {
2427 	int *min;
2428 	int *max;
2429 };
2430 
2431 static int do_proc_dointvec_minmax_conv(int *negp, unsigned long *lvalp,
2432 					int *valp,
2433 					int write, void *data)
2434 {
2435 	struct do_proc_dointvec_minmax_conv_param *param = data;
2436 	if (write) {
2437 		int val = *negp ? -*lvalp : *lvalp;
2438 		if ((param->min && *param->min > val) ||
2439 		    (param->max && *param->max < val))
2440 			return -EINVAL;
2441 		*valp = val;
2442 	} else {
2443 		int val = *valp;
2444 		if (val < 0) {
2445 			*negp = -1;
2446 			*lvalp = (unsigned long)-val;
2447 		} else {
2448 			*negp = 0;
2449 			*lvalp = (unsigned long)val;
2450 		}
2451 	}
2452 	return 0;
2453 }
2454 
2455 /**
2456  * proc_dointvec_minmax - read a vector of integers with min/max values
2457  * @table: the sysctl table
2458  * @write: %TRUE if this is a write to the sysctl file
2459  * @filp: the file structure
2460  * @buffer: the user buffer
2461  * @lenp: the size of the user buffer
2462  * @ppos: file position
2463  *
2464  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2465  * values from/to the user buffer, treated as an ASCII string.
2466  *
2467  * This routine will ensure the values are within the range specified by
2468  * table->extra1 (min) and table->extra2 (max).
2469  *
2470  * Returns 0 on success.
2471  */
2472 int proc_dointvec_minmax(struct ctl_table *table, int write, struct file *filp,
2473 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2474 {
2475 	struct do_proc_dointvec_minmax_conv_param param = {
2476 		.min = (int *) table->extra1,
2477 		.max = (int *) table->extra2,
2478 	};
2479 	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
2480 				do_proc_dointvec_minmax_conv, &param);
2481 }
2482 
2483 static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
2484 				     struct file *filp,
2485 				     void __user *buffer,
2486 				     size_t *lenp, loff_t *ppos,
2487 				     unsigned long convmul,
2488 				     unsigned long convdiv)
2489 {
2490 #define TMPBUFLEN 21
2491 	unsigned long *i, *min, *max, val;
2492 	int vleft, first=1, neg;
2493 	size_t len, left;
2494 	char buf[TMPBUFLEN], *p;
2495 	char __user *s = buffer;
2496 
2497 	if (!data || !table->maxlen || !*lenp ||
2498 	    (*ppos && !write)) {
2499 		*lenp = 0;
2500 		return 0;
2501 	}
2502 
2503 	i = (unsigned long *) data;
2504 	min = (unsigned long *) table->extra1;
2505 	max = (unsigned long *) table->extra2;
2506 	vleft = table->maxlen / sizeof(unsigned long);
2507 	left = *lenp;
2508 
2509 	for (; left && vleft--; i++, min++, max++, first=0) {
2510 		if (write) {
2511 			while (left) {
2512 				char c;
2513 				if (get_user(c, s))
2514 					return -EFAULT;
2515 				if (!isspace(c))
2516 					break;
2517 				left--;
2518 				s++;
2519 			}
2520 			if (!left)
2521 				break;
2522 			neg = 0;
2523 			len = left;
2524 			if (len > TMPBUFLEN-1)
2525 				len = TMPBUFLEN-1;
2526 			if (copy_from_user(buf, s, len))
2527 				return -EFAULT;
2528 			buf[len] = 0;
2529 			p = buf;
2530 			if (*p == '-' && left > 1) {
2531 				neg = 1;
2532 				p++;
2533 			}
2534 			if (*p < '0' || *p > '9')
2535 				break;
2536 			val = simple_strtoul(p, &p, 0) * convmul / convdiv ;
2537 			len = p-buf;
2538 			if ((len < left) && *p && !isspace(*p))
2539 				break;
2540 			if (neg)
2541 				val = -val;
2542 			s += len;
2543 			left -= len;
2544 
2545 			if(neg)
2546 				continue;
2547 			if ((min && val < *min) || (max && val > *max))
2548 				continue;
2549 			*i = val;
2550 		} else {
2551 			p = buf;
2552 			if (!first)
2553 				*p++ = '\t';
2554 			sprintf(p, "%lu", convdiv * (*i) / convmul);
2555 			len = strlen(buf);
2556 			if (len > left)
2557 				len = left;
2558 			if(copy_to_user(s, buf, len))
2559 				return -EFAULT;
2560 			left -= len;
2561 			s += len;
2562 		}
2563 	}
2564 
2565 	if (!write && !first && left) {
2566 		if(put_user('\n', s))
2567 			return -EFAULT;
2568 		left--, s++;
2569 	}
2570 	if (write) {
2571 		while (left) {
2572 			char c;
2573 			if (get_user(c, s++))
2574 				return -EFAULT;
2575 			if (!isspace(c))
2576 				break;
2577 			left--;
2578 		}
2579 	}
2580 	if (write && first)
2581 		return -EINVAL;
2582 	*lenp -= left;
2583 	*ppos += *lenp;
2584 	return 0;
2585 #undef TMPBUFLEN
2586 }
2587 
2588 static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
2589 				     struct file *filp,
2590 				     void __user *buffer,
2591 				     size_t *lenp, loff_t *ppos,
2592 				     unsigned long convmul,
2593 				     unsigned long convdiv)
2594 {
2595 	return __do_proc_doulongvec_minmax(table->data, table, write,
2596 			filp, buffer, lenp, ppos, convmul, convdiv);
2597 }
2598 
2599 /**
2600  * proc_doulongvec_minmax - read a vector of long integers with min/max values
2601  * @table: the sysctl table
2602  * @write: %TRUE if this is a write to the sysctl file
2603  * @filp: the file structure
2604  * @buffer: the user buffer
2605  * @lenp: the size of the user buffer
2606  * @ppos: file position
2607  *
2608  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2609  * values from/to the user buffer, treated as an ASCII string.
2610  *
2611  * This routine will ensure the values are within the range specified by
2612  * table->extra1 (min) and table->extra2 (max).
2613  *
2614  * Returns 0 on success.
2615  */
2616 int proc_doulongvec_minmax(struct ctl_table *table, int write, struct file *filp,
2617 			   void __user *buffer, size_t *lenp, loff_t *ppos)
2618 {
2619     return do_proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos, 1l, 1l);
2620 }
2621 
2622 /**
2623  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
2624  * @table: the sysctl table
2625  * @write: %TRUE if this is a write to the sysctl file
2626  * @filp: the file structure
2627  * @buffer: the user buffer
2628  * @lenp: the size of the user buffer
2629  * @ppos: file position
2630  *
2631  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2632  * values from/to the user buffer, treated as an ASCII string. The values
2633  * are treated as milliseconds, and converted to jiffies when they are stored.
2634  *
2635  * This routine will ensure the values are within the range specified by
2636  * table->extra1 (min) and table->extra2 (max).
2637  *
2638  * Returns 0 on success.
2639  */
2640 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2641 				      struct file *filp,
2642 				      void __user *buffer,
2643 				      size_t *lenp, loff_t *ppos)
2644 {
2645     return do_proc_doulongvec_minmax(table, write, filp, buffer,
2646 				     lenp, ppos, HZ, 1000l);
2647 }
2648 
2649 
2650 static int do_proc_dointvec_jiffies_conv(int *negp, unsigned long *lvalp,
2651 					 int *valp,
2652 					 int write, void *data)
2653 {
2654 	if (write) {
2655 		if (*lvalp > LONG_MAX / HZ)
2656 			return 1;
2657 		*valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
2658 	} else {
2659 		int val = *valp;
2660 		unsigned long lval;
2661 		if (val < 0) {
2662 			*negp = -1;
2663 			lval = (unsigned long)-val;
2664 		} else {
2665 			*negp = 0;
2666 			lval = (unsigned long)val;
2667 		}
2668 		*lvalp = lval / HZ;
2669 	}
2670 	return 0;
2671 }
2672 
2673 static int do_proc_dointvec_userhz_jiffies_conv(int *negp, unsigned long *lvalp,
2674 						int *valp,
2675 						int write, void *data)
2676 {
2677 	if (write) {
2678 		if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
2679 			return 1;
2680 		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
2681 	} else {
2682 		int val = *valp;
2683 		unsigned long lval;
2684 		if (val < 0) {
2685 			*negp = -1;
2686 			lval = (unsigned long)-val;
2687 		} else {
2688 			*negp = 0;
2689 			lval = (unsigned long)val;
2690 		}
2691 		*lvalp = jiffies_to_clock_t(lval);
2692 	}
2693 	return 0;
2694 }
2695 
2696 static int do_proc_dointvec_ms_jiffies_conv(int *negp, unsigned long *lvalp,
2697 					    int *valp,
2698 					    int write, void *data)
2699 {
2700 	if (write) {
2701 		*valp = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
2702 	} else {
2703 		int val = *valp;
2704 		unsigned long lval;
2705 		if (val < 0) {
2706 			*negp = -1;
2707 			lval = (unsigned long)-val;
2708 		} else {
2709 			*negp = 0;
2710 			lval = (unsigned long)val;
2711 		}
2712 		*lvalp = jiffies_to_msecs(lval);
2713 	}
2714 	return 0;
2715 }
2716 
2717 /**
2718  * proc_dointvec_jiffies - read a vector of integers as seconds
2719  * @table: the sysctl table
2720  * @write: %TRUE if this is a write to the sysctl file
2721  * @filp: the file structure
2722  * @buffer: the user buffer
2723  * @lenp: the size of the user buffer
2724  * @ppos: file position
2725  *
2726  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2727  * values from/to the user buffer, treated as an ASCII string.
2728  * The values read are assumed to be in seconds, and are converted into
2729  * jiffies.
2730  *
2731  * Returns 0 on success.
2732  */
2733 int proc_dointvec_jiffies(struct ctl_table *table, int write, struct file *filp,
2734 			  void __user *buffer, size_t *lenp, loff_t *ppos)
2735 {
2736     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
2737 		    	    do_proc_dointvec_jiffies_conv,NULL);
2738 }
2739 
2740 /**
2741  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
2742  * @table: the sysctl table
2743  * @write: %TRUE if this is a write to the sysctl file
2744  * @filp: the file structure
2745  * @buffer: the user buffer
2746  * @lenp: the size of the user buffer
2747  * @ppos: pointer to the file position
2748  *
2749  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2750  * values from/to the user buffer, treated as an ASCII string.
2751  * The values read are assumed to be in 1/USER_HZ seconds, and
2752  * are converted into jiffies.
2753  *
2754  * Returns 0 on success.
2755  */
2756 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, struct file *filp,
2757 				 void __user *buffer, size_t *lenp, loff_t *ppos)
2758 {
2759     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
2760 		    	    do_proc_dointvec_userhz_jiffies_conv,NULL);
2761 }
2762 
2763 /**
2764  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
2765  * @table: the sysctl table
2766  * @write: %TRUE if this is a write to the sysctl file
2767  * @filp: the file structure
2768  * @buffer: the user buffer
2769  * @lenp: the size of the user buffer
2770  * @ppos: file position
2771  * @ppos: the current position in the file
2772  *
2773  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2774  * values from/to the user buffer, treated as an ASCII string.
2775  * The values read are assumed to be in 1/1000 seconds, and
2776  * are converted into jiffies.
2777  *
2778  * Returns 0 on success.
2779  */
2780 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, struct file *filp,
2781 			     void __user *buffer, size_t *lenp, loff_t *ppos)
2782 {
2783 	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
2784 				do_proc_dointvec_ms_jiffies_conv, NULL);
2785 }
2786 
2787 static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp,
2788 			   void __user *buffer, size_t *lenp, loff_t *ppos)
2789 {
2790 	struct pid *new_pid;
2791 	pid_t tmp;
2792 	int r;
2793 
2794 	tmp = pid_vnr(cad_pid);
2795 
2796 	r = __do_proc_dointvec(&tmp, table, write, filp, buffer,
2797 			       lenp, ppos, NULL, NULL);
2798 	if (r || !write)
2799 		return r;
2800 
2801 	new_pid = find_get_pid(tmp);
2802 	if (!new_pid)
2803 		return -ESRCH;
2804 
2805 	put_pid(xchg(&cad_pid, new_pid));
2806 	return 0;
2807 }
2808 
2809 #else /* CONFIG_PROC_FS */
2810 
2811 int proc_dostring(struct ctl_table *table, int write, struct file *filp,
2812 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2813 {
2814 	return -ENOSYS;
2815 }
2816 
2817 int proc_dointvec(struct ctl_table *table, int write, struct file *filp,
2818 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2819 {
2820 	return -ENOSYS;
2821 }
2822 
2823 int proc_dointvec_minmax(struct ctl_table *table, int write, struct file *filp,
2824 		    void __user *buffer, size_t *lenp, loff_t *ppos)
2825 {
2826 	return -ENOSYS;
2827 }
2828 
2829 int proc_dointvec_jiffies(struct ctl_table *table, int write, struct file *filp,
2830 		    void __user *buffer, size_t *lenp, loff_t *ppos)
2831 {
2832 	return -ENOSYS;
2833 }
2834 
2835 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, struct file *filp,
2836 		    void __user *buffer, size_t *lenp, loff_t *ppos)
2837 {
2838 	return -ENOSYS;
2839 }
2840 
2841 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, struct file *filp,
2842 			     void __user *buffer, size_t *lenp, loff_t *ppos)
2843 {
2844 	return -ENOSYS;
2845 }
2846 
2847 int proc_doulongvec_minmax(struct ctl_table *table, int write, struct file *filp,
2848 		    void __user *buffer, size_t *lenp, loff_t *ppos)
2849 {
2850 	return -ENOSYS;
2851 }
2852 
2853 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2854 				      struct file *filp,
2855 				      void __user *buffer,
2856 				      size_t *lenp, loff_t *ppos)
2857 {
2858     return -ENOSYS;
2859 }
2860 
2861 
2862 #endif /* CONFIG_PROC_FS */
2863 
2864 
2865 #ifdef CONFIG_SYSCTL_SYSCALL
2866 /*
2867  * General sysctl support routines
2868  */
2869 
2870 /* The generic sysctl data routine (used if no strategy routine supplied) */
2871 int sysctl_data(struct ctl_table *table,
2872 		void __user *oldval, size_t __user *oldlenp,
2873 		void __user *newval, size_t newlen)
2874 {
2875 	size_t len;
2876 
2877 	/* Get out of I don't have a variable */
2878 	if (!table->data || !table->maxlen)
2879 		return -ENOTDIR;
2880 
2881 	if (oldval && oldlenp) {
2882 		if (get_user(len, oldlenp))
2883 			return -EFAULT;
2884 		if (len) {
2885 			if (len > table->maxlen)
2886 				len = table->maxlen;
2887 			if (copy_to_user(oldval, table->data, len))
2888 				return -EFAULT;
2889 			if (put_user(len, oldlenp))
2890 				return -EFAULT;
2891 		}
2892 	}
2893 
2894 	if (newval && newlen) {
2895 		if (newlen > table->maxlen)
2896 			newlen = table->maxlen;
2897 
2898 		if (copy_from_user(table->data, newval, newlen))
2899 			return -EFAULT;
2900 	}
2901 	return 1;
2902 }
2903 
2904 /* The generic string strategy routine: */
2905 int sysctl_string(struct ctl_table *table,
2906 		  void __user *oldval, size_t __user *oldlenp,
2907 		  void __user *newval, size_t newlen)
2908 {
2909 	if (!table->data || !table->maxlen)
2910 		return -ENOTDIR;
2911 
2912 	if (oldval && oldlenp) {
2913 		size_t bufsize;
2914 		if (get_user(bufsize, oldlenp))
2915 			return -EFAULT;
2916 		if (bufsize) {
2917 			size_t len = strlen(table->data), copied;
2918 
2919 			/* This shouldn't trigger for a well-formed sysctl */
2920 			if (len > table->maxlen)
2921 				len = table->maxlen;
2922 
2923 			/* Copy up to a max of bufsize-1 bytes of the string */
2924 			copied = (len >= bufsize) ? bufsize - 1 : len;
2925 
2926 			if (copy_to_user(oldval, table->data, copied) ||
2927 			    put_user(0, (char __user *)(oldval + copied)))
2928 				return -EFAULT;
2929 			if (put_user(len, oldlenp))
2930 				return -EFAULT;
2931 		}
2932 	}
2933 	if (newval && newlen) {
2934 		size_t len = newlen;
2935 		if (len > table->maxlen)
2936 			len = table->maxlen;
2937 		if(copy_from_user(table->data, newval, len))
2938 			return -EFAULT;
2939 		if (len == table->maxlen)
2940 			len--;
2941 		((char *) table->data)[len] = 0;
2942 	}
2943 	return 1;
2944 }
2945 
2946 /*
2947  * This function makes sure that all of the integers in the vector
2948  * are between the minimum and maximum values given in the arrays
2949  * table->extra1 and table->extra2, respectively.
2950  */
2951 int sysctl_intvec(struct ctl_table *table,
2952 		void __user *oldval, size_t __user *oldlenp,
2953 		void __user *newval, size_t newlen)
2954 {
2955 
2956 	if (newval && newlen) {
2957 		int __user *vec = (int __user *) newval;
2958 		int *min = (int *) table->extra1;
2959 		int *max = (int *) table->extra2;
2960 		size_t length;
2961 		int i;
2962 
2963 		if (newlen % sizeof(int) != 0)
2964 			return -EINVAL;
2965 
2966 		if (!table->extra1 && !table->extra2)
2967 			return 0;
2968 
2969 		if (newlen > table->maxlen)
2970 			newlen = table->maxlen;
2971 		length = newlen / sizeof(int);
2972 
2973 		for (i = 0; i < length; i++) {
2974 			int value;
2975 			if (get_user(value, vec + i))
2976 				return -EFAULT;
2977 			if (min && value < min[i])
2978 				return -EINVAL;
2979 			if (max && value > max[i])
2980 				return -EINVAL;
2981 		}
2982 	}
2983 	return 0;
2984 }
2985 
2986 /* Strategy function to convert jiffies to seconds */
2987 int sysctl_jiffies(struct ctl_table *table,
2988 		void __user *oldval, size_t __user *oldlenp,
2989 		void __user *newval, size_t newlen)
2990 {
2991 	if (oldval && oldlenp) {
2992 		size_t olen;
2993 
2994 		if (get_user(olen, oldlenp))
2995 			return -EFAULT;
2996 		if (olen) {
2997 			int val;
2998 
2999 			if (olen < sizeof(int))
3000 				return -EINVAL;
3001 
3002 			val = *(int *)(table->data) / HZ;
3003 			if (put_user(val, (int __user *)oldval))
3004 				return -EFAULT;
3005 			if (put_user(sizeof(int), oldlenp))
3006 				return -EFAULT;
3007 		}
3008 	}
3009 	if (newval && newlen) {
3010 		int new;
3011 		if (newlen != sizeof(int))
3012 			return -EINVAL;
3013 		if (get_user(new, (int __user *)newval))
3014 			return -EFAULT;
3015 		*(int *)(table->data) = new*HZ;
3016 	}
3017 	return 1;
3018 }
3019 
3020 /* Strategy function to convert jiffies to seconds */
3021 int sysctl_ms_jiffies(struct ctl_table *table,
3022 		void __user *oldval, size_t __user *oldlenp,
3023 		void __user *newval, size_t newlen)
3024 {
3025 	if (oldval && oldlenp) {
3026 		size_t olen;
3027 
3028 		if (get_user(olen, oldlenp))
3029 			return -EFAULT;
3030 		if (olen) {
3031 			int val;
3032 
3033 			if (olen < sizeof(int))
3034 				return -EINVAL;
3035 
3036 			val = jiffies_to_msecs(*(int *)(table->data));
3037 			if (put_user(val, (int __user *)oldval))
3038 				return -EFAULT;
3039 			if (put_user(sizeof(int), oldlenp))
3040 				return -EFAULT;
3041 		}
3042 	}
3043 	if (newval && newlen) {
3044 		int new;
3045 		if (newlen != sizeof(int))
3046 			return -EINVAL;
3047 		if (get_user(new, (int __user *)newval))
3048 			return -EFAULT;
3049 		*(int *)(table->data) = msecs_to_jiffies(new);
3050 	}
3051 	return 1;
3052 }
3053 
3054 
3055 
3056 #else /* CONFIG_SYSCTL_SYSCALL */
3057 
3058 
3059 SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
3060 {
3061 	struct __sysctl_args tmp;
3062 	int error;
3063 
3064 	if (copy_from_user(&tmp, args, sizeof(tmp)))
3065 		return -EFAULT;
3066 
3067 	error = deprecated_sysctl_warning(&tmp);
3068 
3069 	/* If no error reading the parameters then just -ENOSYS ... */
3070 	if (!error)
3071 		error = -ENOSYS;
3072 
3073 	return error;
3074 }
3075 
3076 int sysctl_data(struct ctl_table *table,
3077 		  void __user *oldval, size_t __user *oldlenp,
3078 		  void __user *newval, size_t newlen)
3079 {
3080 	return -ENOSYS;
3081 }
3082 
3083 int sysctl_string(struct ctl_table *table,
3084 		  void __user *oldval, size_t __user *oldlenp,
3085 		  void __user *newval, size_t newlen)
3086 {
3087 	return -ENOSYS;
3088 }
3089 
3090 int sysctl_intvec(struct ctl_table *table,
3091 		void __user *oldval, size_t __user *oldlenp,
3092 		void __user *newval, size_t newlen)
3093 {
3094 	return -ENOSYS;
3095 }
3096 
3097 int sysctl_jiffies(struct ctl_table *table,
3098 		void __user *oldval, size_t __user *oldlenp,
3099 		void __user *newval, size_t newlen)
3100 {
3101 	return -ENOSYS;
3102 }
3103 
3104 int sysctl_ms_jiffies(struct ctl_table *table,
3105 		void __user *oldval, size_t __user *oldlenp,
3106 		void __user *newval, size_t newlen)
3107 {
3108 	return -ENOSYS;
3109 }
3110 
3111 #endif /* CONFIG_SYSCTL_SYSCALL */
3112 
3113 static int deprecated_sysctl_warning(struct __sysctl_args *args)
3114 {
3115 	static int msg_count;
3116 	int name[CTL_MAXNAME];
3117 	int i;
3118 
3119 	/* Check args->nlen. */
3120 	if (args->nlen < 0 || args->nlen > CTL_MAXNAME)
3121 		return -ENOTDIR;
3122 
3123 	/* Read in the sysctl name for better debug message logging */
3124 	for (i = 0; i < args->nlen; i++)
3125 		if (get_user(name[i], args->name + i))
3126 			return -EFAULT;
3127 
3128 	/* Ignore accesses to kernel.version */
3129 	if ((args->nlen == 2) && (name[0] == CTL_KERN) && (name[1] == KERN_VERSION))
3130 		return 0;
3131 
3132 	if (msg_count < 5) {
3133 		msg_count++;
3134 		printk(KERN_INFO
3135 			"warning: process `%s' used the deprecated sysctl "
3136 			"system call with ", current->comm);
3137 		for (i = 0; i < args->nlen; i++)
3138 			printk("%d.", name[i]);
3139 		printk("\n");
3140 	}
3141 	return 0;
3142 }
3143 
3144 /*
3145  * No sense putting this after each symbol definition, twice,
3146  * exception granted :-)
3147  */
3148 EXPORT_SYMBOL(proc_dointvec);
3149 EXPORT_SYMBOL(proc_dointvec_jiffies);
3150 EXPORT_SYMBOL(proc_dointvec_minmax);
3151 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
3152 EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
3153 EXPORT_SYMBOL(proc_dostring);
3154 EXPORT_SYMBOL(proc_doulongvec_minmax);
3155 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
3156 EXPORT_SYMBOL(register_sysctl_table);
3157 EXPORT_SYMBOL(register_sysctl_paths);
3158 EXPORT_SYMBOL(sysctl_intvec);
3159 EXPORT_SYMBOL(sysctl_jiffies);
3160 EXPORT_SYMBOL(sysctl_ms_jiffies);
3161 EXPORT_SYMBOL(sysctl_string);
3162 EXPORT_SYMBOL(sysctl_data);
3163 EXPORT_SYMBOL(unregister_sysctl_table);
3164