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