xref: /openbmc/linux/kernel/sysctl.c (revision 161f4089)
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/bitmap.h>
27 #include <linux/signal.h>
28 #include <linux/printk.h>
29 #include <linux/proc_fs.h>
30 #include <linux/security.h>
31 #include <linux/ctype.h>
32 #include <linux/kmemcheck.h>
33 #include <linux/kmemleak.h>
34 #include <linux/fs.h>
35 #include <linux/init.h>
36 #include <linux/kernel.h>
37 #include <linux/kobject.h>
38 #include <linux/net.h>
39 #include <linux/sysrq.h>
40 #include <linux/highuid.h>
41 #include <linux/writeback.h>
42 #include <linux/ratelimit.h>
43 #include <linux/compaction.h>
44 #include <linux/hugetlb.h>
45 #include <linux/initrd.h>
46 #include <linux/key.h>
47 #include <linux/times.h>
48 #include <linux/limits.h>
49 #include <linux/dcache.h>
50 #include <linux/dnotify.h>
51 #include <linux/syscalls.h>
52 #include <linux/vmstat.h>
53 #include <linux/nfs_fs.h>
54 #include <linux/acpi.h>
55 #include <linux/reboot.h>
56 #include <linux/ftrace.h>
57 #include <linux/perf_event.h>
58 #include <linux/kprobes.h>
59 #include <linux/pipe_fs_i.h>
60 #include <linux/oom.h>
61 #include <linux/kmod.h>
62 #include <linux/capability.h>
63 #include <linux/binfmts.h>
64 #include <linux/sched/sysctl.h>
65 
66 #include <asm/uaccess.h>
67 #include <asm/processor.h>
68 
69 #ifdef CONFIG_X86
70 #include <asm/nmi.h>
71 #include <asm/stacktrace.h>
72 #include <asm/io.h>
73 #endif
74 #ifdef CONFIG_SPARC
75 #include <asm/setup.h>
76 #endif
77 #ifdef CONFIG_BSD_PROCESS_ACCT
78 #include <linux/acct.h>
79 #endif
80 #ifdef CONFIG_RT_MUTEXES
81 #include <linux/rtmutex.h>
82 #endif
83 #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
84 #include <linux/lockdep.h>
85 #endif
86 #ifdef CONFIG_CHR_DEV_SG
87 #include <scsi/sg.h>
88 #endif
89 
90 #ifdef CONFIG_LOCKUP_DETECTOR
91 #include <linux/nmi.h>
92 #endif
93 
94 
95 #if defined(CONFIG_SYSCTL)
96 
97 /* External variables not in a header file. */
98 extern int sysctl_overcommit_memory;
99 extern int sysctl_overcommit_ratio;
100 extern int max_threads;
101 extern int suid_dumpable;
102 #ifdef CONFIG_COREDUMP
103 extern int core_uses_pid;
104 extern char core_pattern[];
105 extern unsigned int core_pipe_limit;
106 #endif
107 extern int pid_max;
108 extern int pid_max_min, pid_max_max;
109 extern int percpu_pagelist_fraction;
110 extern int compat_log;
111 extern int latencytop_enabled;
112 extern int sysctl_nr_open_min, sysctl_nr_open_max;
113 #ifndef CONFIG_MMU
114 extern int sysctl_nr_trim_pages;
115 #endif
116 #ifdef CONFIG_BLOCK
117 extern int blk_iopoll_enabled;
118 #endif
119 
120 /* Constants used for minimum and  maximum */
121 #ifdef CONFIG_LOCKUP_DETECTOR
122 static int sixty = 60;
123 #endif
124 
125 static int zero;
126 static int __maybe_unused one = 1;
127 static int __maybe_unused two = 2;
128 static int __maybe_unused three = 3;
129 static unsigned long one_ul = 1;
130 static int one_hundred = 100;
131 #ifdef CONFIG_PRINTK
132 static int ten_thousand = 10000;
133 #endif
134 
135 /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
136 static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
137 
138 /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
139 static int maxolduid = 65535;
140 static int minolduid;
141 static int min_percpu_pagelist_fract = 8;
142 
143 static int ngroups_max = NGROUPS_MAX;
144 static const int cap_last_cap = CAP_LAST_CAP;
145 
146 #ifdef CONFIG_INOTIFY_USER
147 #include <linux/inotify.h>
148 #endif
149 #ifdef CONFIG_SPARC
150 #endif
151 
152 #ifdef CONFIG_SPARC64
153 extern int sysctl_tsb_ratio;
154 #endif
155 
156 #ifdef __hppa__
157 extern int pwrsw_enabled;
158 #endif
159 
160 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
161 extern int unaligned_enabled;
162 #endif
163 
164 #ifdef CONFIG_IA64
165 extern int unaligned_dump_stack;
166 #endif
167 
168 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
169 extern int no_unaligned_warning;
170 #endif
171 
172 #ifdef CONFIG_PROC_SYSCTL
173 static int proc_do_cad_pid(struct ctl_table *table, int write,
174 		  void __user *buffer, size_t *lenp, loff_t *ppos);
175 static int proc_taint(struct ctl_table *table, int write,
176 			       void __user *buffer, size_t *lenp, loff_t *ppos);
177 #endif
178 
179 #ifdef CONFIG_PRINTK
180 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
181 				void __user *buffer, size_t *lenp, loff_t *ppos);
182 #endif
183 
184 static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
185 		void __user *buffer, size_t *lenp, loff_t *ppos);
186 #ifdef CONFIG_COREDUMP
187 static int proc_dostring_coredump(struct ctl_table *table, int write,
188 		void __user *buffer, size_t *lenp, loff_t *ppos);
189 #endif
190 
191 #ifdef CONFIG_MAGIC_SYSRQ
192 /* Note: sysrq code uses it's own private copy */
193 static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
194 
195 static int sysrq_sysctl_handler(ctl_table *table, int write,
196 				void __user *buffer, size_t *lenp,
197 				loff_t *ppos)
198 {
199 	int error;
200 
201 	error = proc_dointvec(table, write, buffer, lenp, ppos);
202 	if (error)
203 		return error;
204 
205 	if (write)
206 		sysrq_toggle_support(__sysrq_enabled);
207 
208 	return 0;
209 }
210 
211 #endif
212 
213 static struct ctl_table kern_table[];
214 static struct ctl_table vm_table[];
215 static struct ctl_table fs_table[];
216 static struct ctl_table debug_table[];
217 static struct ctl_table dev_table[];
218 extern struct ctl_table random_table[];
219 #ifdef CONFIG_EPOLL
220 extern struct ctl_table epoll_table[];
221 #endif
222 
223 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
224 int sysctl_legacy_va_layout;
225 #endif
226 
227 /* The default sysctl tables: */
228 
229 static struct ctl_table sysctl_base_table[] = {
230 	{
231 		.procname	= "kernel",
232 		.mode		= 0555,
233 		.child		= kern_table,
234 	},
235 	{
236 		.procname	= "vm",
237 		.mode		= 0555,
238 		.child		= vm_table,
239 	},
240 	{
241 		.procname	= "fs",
242 		.mode		= 0555,
243 		.child		= fs_table,
244 	},
245 	{
246 		.procname	= "debug",
247 		.mode		= 0555,
248 		.child		= debug_table,
249 	},
250 	{
251 		.procname	= "dev",
252 		.mode		= 0555,
253 		.child		= dev_table,
254 	},
255 	{ }
256 };
257 
258 #ifdef CONFIG_SCHED_DEBUG
259 static int min_sched_granularity_ns = 100000;		/* 100 usecs */
260 static int max_sched_granularity_ns = NSEC_PER_SEC;	/* 1 second */
261 static int min_wakeup_granularity_ns;			/* 0 usecs */
262 static int max_wakeup_granularity_ns = NSEC_PER_SEC;	/* 1 second */
263 #ifdef CONFIG_SMP
264 static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
265 static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
266 #endif /* CONFIG_SMP */
267 #endif /* CONFIG_SCHED_DEBUG */
268 
269 #ifdef CONFIG_COMPACTION
270 static int min_extfrag_threshold;
271 static int max_extfrag_threshold = 1000;
272 #endif
273 
274 static struct ctl_table kern_table[] = {
275 	{
276 		.procname	= "sched_child_runs_first",
277 		.data		= &sysctl_sched_child_runs_first,
278 		.maxlen		= sizeof(unsigned int),
279 		.mode		= 0644,
280 		.proc_handler	= proc_dointvec,
281 	},
282 #ifdef CONFIG_SCHED_DEBUG
283 	{
284 		.procname	= "sched_min_granularity_ns",
285 		.data		= &sysctl_sched_min_granularity,
286 		.maxlen		= sizeof(unsigned int),
287 		.mode		= 0644,
288 		.proc_handler	= sched_proc_update_handler,
289 		.extra1		= &min_sched_granularity_ns,
290 		.extra2		= &max_sched_granularity_ns,
291 	},
292 	{
293 		.procname	= "sched_latency_ns",
294 		.data		= &sysctl_sched_latency,
295 		.maxlen		= sizeof(unsigned int),
296 		.mode		= 0644,
297 		.proc_handler	= sched_proc_update_handler,
298 		.extra1		= &min_sched_granularity_ns,
299 		.extra2		= &max_sched_granularity_ns,
300 	},
301 	{
302 		.procname	= "sched_wakeup_granularity_ns",
303 		.data		= &sysctl_sched_wakeup_granularity,
304 		.maxlen		= sizeof(unsigned int),
305 		.mode		= 0644,
306 		.proc_handler	= sched_proc_update_handler,
307 		.extra1		= &min_wakeup_granularity_ns,
308 		.extra2		= &max_wakeup_granularity_ns,
309 	},
310 #ifdef CONFIG_SMP
311 	{
312 		.procname	= "sched_tunable_scaling",
313 		.data		= &sysctl_sched_tunable_scaling,
314 		.maxlen		= sizeof(enum sched_tunable_scaling),
315 		.mode		= 0644,
316 		.proc_handler	= sched_proc_update_handler,
317 		.extra1		= &min_sched_tunable_scaling,
318 		.extra2		= &max_sched_tunable_scaling,
319 	},
320 	{
321 		.procname	= "sched_migration_cost_ns",
322 		.data		= &sysctl_sched_migration_cost,
323 		.maxlen		= sizeof(unsigned int),
324 		.mode		= 0644,
325 		.proc_handler	= proc_dointvec,
326 	},
327 	{
328 		.procname	= "sched_nr_migrate",
329 		.data		= &sysctl_sched_nr_migrate,
330 		.maxlen		= sizeof(unsigned int),
331 		.mode		= 0644,
332 		.proc_handler	= proc_dointvec,
333 	},
334 	{
335 		.procname	= "sched_time_avg_ms",
336 		.data		= &sysctl_sched_time_avg,
337 		.maxlen		= sizeof(unsigned int),
338 		.mode		= 0644,
339 		.proc_handler	= proc_dointvec,
340 	},
341 	{
342 		.procname	= "sched_shares_window_ns",
343 		.data		= &sysctl_sched_shares_window,
344 		.maxlen		= sizeof(unsigned int),
345 		.mode		= 0644,
346 		.proc_handler	= proc_dointvec,
347 	},
348 	{
349 		.procname	= "timer_migration",
350 		.data		= &sysctl_timer_migration,
351 		.maxlen		= sizeof(unsigned int),
352 		.mode		= 0644,
353 		.proc_handler	= proc_dointvec_minmax,
354 		.extra1		= &zero,
355 		.extra2		= &one,
356 	},
357 #endif /* CONFIG_SMP */
358 #ifdef CONFIG_NUMA_BALANCING
359 	{
360 		.procname	= "numa_balancing_scan_delay_ms",
361 		.data		= &sysctl_numa_balancing_scan_delay,
362 		.maxlen		= sizeof(unsigned int),
363 		.mode		= 0644,
364 		.proc_handler	= proc_dointvec,
365 	},
366 	{
367 		.procname	= "numa_balancing_scan_period_min_ms",
368 		.data		= &sysctl_numa_balancing_scan_period_min,
369 		.maxlen		= sizeof(unsigned int),
370 		.mode		= 0644,
371 		.proc_handler	= proc_dointvec,
372 	},
373 	{
374 		.procname	= "numa_balancing_scan_period_max_ms",
375 		.data		= &sysctl_numa_balancing_scan_period_max,
376 		.maxlen		= sizeof(unsigned int),
377 		.mode		= 0644,
378 		.proc_handler	= proc_dointvec,
379 	},
380 	{
381 		.procname	= "numa_balancing_scan_size_mb",
382 		.data		= &sysctl_numa_balancing_scan_size,
383 		.maxlen		= sizeof(unsigned int),
384 		.mode		= 0644,
385 		.proc_handler	= proc_dointvec,
386 	},
387 	{
388 		.procname       = "numa_balancing_settle_count",
389 		.data           = &sysctl_numa_balancing_settle_count,
390 		.maxlen         = sizeof(unsigned int),
391 		.mode           = 0644,
392 		.proc_handler   = proc_dointvec,
393 	},
394 	{
395 		.procname       = "numa_balancing_migrate_deferred",
396 		.data           = &sysctl_numa_balancing_migrate_deferred,
397 		.maxlen         = sizeof(unsigned int),
398 		.mode           = 0644,
399 		.proc_handler   = proc_dointvec,
400 	},
401 #endif /* CONFIG_NUMA_BALANCING */
402 #endif /* CONFIG_SCHED_DEBUG */
403 	{
404 		.procname	= "sched_rt_period_us",
405 		.data		= &sysctl_sched_rt_period,
406 		.maxlen		= sizeof(unsigned int),
407 		.mode		= 0644,
408 		.proc_handler	= sched_rt_handler,
409 	},
410 	{
411 		.procname	= "sched_rt_runtime_us",
412 		.data		= &sysctl_sched_rt_runtime,
413 		.maxlen		= sizeof(int),
414 		.mode		= 0644,
415 		.proc_handler	= sched_rt_handler,
416 	},
417 	{
418 		.procname	= "sched_rr_timeslice_ms",
419 		.data		= &sched_rr_timeslice,
420 		.maxlen		= sizeof(int),
421 		.mode		= 0644,
422 		.proc_handler	= sched_rr_handler,
423 	},
424 #ifdef CONFIG_SCHED_AUTOGROUP
425 	{
426 		.procname	= "sched_autogroup_enabled",
427 		.data		= &sysctl_sched_autogroup_enabled,
428 		.maxlen		= sizeof(unsigned int),
429 		.mode		= 0644,
430 		.proc_handler	= proc_dointvec_minmax,
431 		.extra1		= &zero,
432 		.extra2		= &one,
433 	},
434 #endif
435 #ifdef CONFIG_CFS_BANDWIDTH
436 	{
437 		.procname	= "sched_cfs_bandwidth_slice_us",
438 		.data		= &sysctl_sched_cfs_bandwidth_slice,
439 		.maxlen		= sizeof(unsigned int),
440 		.mode		= 0644,
441 		.proc_handler	= proc_dointvec_minmax,
442 		.extra1		= &one,
443 	},
444 #endif
445 #ifdef CONFIG_PROVE_LOCKING
446 	{
447 		.procname	= "prove_locking",
448 		.data		= &prove_locking,
449 		.maxlen		= sizeof(int),
450 		.mode		= 0644,
451 		.proc_handler	= proc_dointvec,
452 	},
453 #endif
454 #ifdef CONFIG_LOCK_STAT
455 	{
456 		.procname	= "lock_stat",
457 		.data		= &lock_stat,
458 		.maxlen		= sizeof(int),
459 		.mode		= 0644,
460 		.proc_handler	= proc_dointvec,
461 	},
462 #endif
463 	{
464 		.procname	= "panic",
465 		.data		= &panic_timeout,
466 		.maxlen		= sizeof(int),
467 		.mode		= 0644,
468 		.proc_handler	= proc_dointvec,
469 	},
470 #ifdef CONFIG_COREDUMP
471 	{
472 		.procname	= "core_uses_pid",
473 		.data		= &core_uses_pid,
474 		.maxlen		= sizeof(int),
475 		.mode		= 0644,
476 		.proc_handler	= proc_dointvec,
477 	},
478 	{
479 		.procname	= "core_pattern",
480 		.data		= core_pattern,
481 		.maxlen		= CORENAME_MAX_SIZE,
482 		.mode		= 0644,
483 		.proc_handler	= proc_dostring_coredump,
484 	},
485 	{
486 		.procname	= "core_pipe_limit",
487 		.data		= &core_pipe_limit,
488 		.maxlen		= sizeof(unsigned int),
489 		.mode		= 0644,
490 		.proc_handler	= proc_dointvec,
491 	},
492 #endif
493 #ifdef CONFIG_PROC_SYSCTL
494 	{
495 		.procname	= "tainted",
496 		.maxlen 	= sizeof(long),
497 		.mode		= 0644,
498 		.proc_handler	= proc_taint,
499 	},
500 #endif
501 #ifdef CONFIG_LATENCYTOP
502 	{
503 		.procname	= "latencytop",
504 		.data		= &latencytop_enabled,
505 		.maxlen		= sizeof(int),
506 		.mode		= 0644,
507 		.proc_handler	= proc_dointvec,
508 	},
509 #endif
510 #ifdef CONFIG_BLK_DEV_INITRD
511 	{
512 		.procname	= "real-root-dev",
513 		.data		= &real_root_dev,
514 		.maxlen		= sizeof(int),
515 		.mode		= 0644,
516 		.proc_handler	= proc_dointvec,
517 	},
518 #endif
519 	{
520 		.procname	= "print-fatal-signals",
521 		.data		= &print_fatal_signals,
522 		.maxlen		= sizeof(int),
523 		.mode		= 0644,
524 		.proc_handler	= proc_dointvec,
525 	},
526 #ifdef CONFIG_SPARC
527 	{
528 		.procname	= "reboot-cmd",
529 		.data		= reboot_command,
530 		.maxlen		= 256,
531 		.mode		= 0644,
532 		.proc_handler	= proc_dostring,
533 	},
534 	{
535 		.procname	= "stop-a",
536 		.data		= &stop_a_enabled,
537 		.maxlen		= sizeof (int),
538 		.mode		= 0644,
539 		.proc_handler	= proc_dointvec,
540 	},
541 	{
542 		.procname	= "scons-poweroff",
543 		.data		= &scons_pwroff,
544 		.maxlen		= sizeof (int),
545 		.mode		= 0644,
546 		.proc_handler	= proc_dointvec,
547 	},
548 #endif
549 #ifdef CONFIG_SPARC64
550 	{
551 		.procname	= "tsb-ratio",
552 		.data		= &sysctl_tsb_ratio,
553 		.maxlen		= sizeof (int),
554 		.mode		= 0644,
555 		.proc_handler	= proc_dointvec,
556 	},
557 #endif
558 #ifdef __hppa__
559 	{
560 		.procname	= "soft-power",
561 		.data		= &pwrsw_enabled,
562 		.maxlen		= sizeof (int),
563 	 	.mode		= 0644,
564 		.proc_handler	= proc_dointvec,
565 	},
566 #endif
567 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
568 	{
569 		.procname	= "unaligned-trap",
570 		.data		= &unaligned_enabled,
571 		.maxlen		= sizeof (int),
572 		.mode		= 0644,
573 		.proc_handler	= proc_dointvec,
574 	},
575 #endif
576 	{
577 		.procname	= "ctrl-alt-del",
578 		.data		= &C_A_D,
579 		.maxlen		= sizeof(int),
580 		.mode		= 0644,
581 		.proc_handler	= proc_dointvec,
582 	},
583 #ifdef CONFIG_FUNCTION_TRACER
584 	{
585 		.procname	= "ftrace_enabled",
586 		.data		= &ftrace_enabled,
587 		.maxlen		= sizeof(int),
588 		.mode		= 0644,
589 		.proc_handler	= ftrace_enable_sysctl,
590 	},
591 #endif
592 #ifdef CONFIG_STACK_TRACER
593 	{
594 		.procname	= "stack_tracer_enabled",
595 		.data		= &stack_tracer_enabled,
596 		.maxlen		= sizeof(int),
597 		.mode		= 0644,
598 		.proc_handler	= stack_trace_sysctl,
599 	},
600 #endif
601 #ifdef CONFIG_TRACING
602 	{
603 		.procname	= "ftrace_dump_on_oops",
604 		.data		= &ftrace_dump_on_oops,
605 		.maxlen		= sizeof(int),
606 		.mode		= 0644,
607 		.proc_handler	= proc_dointvec,
608 	},
609 	{
610 		.procname	= "traceoff_on_warning",
611 		.data		= &__disable_trace_on_warning,
612 		.maxlen		= sizeof(__disable_trace_on_warning),
613 		.mode		= 0644,
614 		.proc_handler	= proc_dointvec,
615 	},
616 #endif
617 #ifdef CONFIG_MODULES
618 	{
619 		.procname	= "modprobe",
620 		.data		= &modprobe_path,
621 		.maxlen		= KMOD_PATH_LEN,
622 		.mode		= 0644,
623 		.proc_handler	= proc_dostring,
624 	},
625 	{
626 		.procname	= "modules_disabled",
627 		.data		= &modules_disabled,
628 		.maxlen		= sizeof(int),
629 		.mode		= 0644,
630 		/* only handle a transition from default "0" to "1" */
631 		.proc_handler	= proc_dointvec_minmax,
632 		.extra1		= &one,
633 		.extra2		= &one,
634 	},
635 #endif
636 
637 	{
638 		.procname	= "hotplug",
639 		.data		= &uevent_helper,
640 		.maxlen		= UEVENT_HELPER_PATH_LEN,
641 		.mode		= 0644,
642 		.proc_handler	= proc_dostring,
643 	},
644 
645 #ifdef CONFIG_CHR_DEV_SG
646 	{
647 		.procname	= "sg-big-buff",
648 		.data		= &sg_big_buff,
649 		.maxlen		= sizeof (int),
650 		.mode		= 0444,
651 		.proc_handler	= proc_dointvec,
652 	},
653 #endif
654 #ifdef CONFIG_BSD_PROCESS_ACCT
655 	{
656 		.procname	= "acct",
657 		.data		= &acct_parm,
658 		.maxlen		= 3*sizeof(int),
659 		.mode		= 0644,
660 		.proc_handler	= proc_dointvec,
661 	},
662 #endif
663 #ifdef CONFIG_MAGIC_SYSRQ
664 	{
665 		.procname	= "sysrq",
666 		.data		= &__sysrq_enabled,
667 		.maxlen		= sizeof (int),
668 		.mode		= 0644,
669 		.proc_handler	= sysrq_sysctl_handler,
670 	},
671 #endif
672 #ifdef CONFIG_PROC_SYSCTL
673 	{
674 		.procname	= "cad_pid",
675 		.data		= NULL,
676 		.maxlen		= sizeof (int),
677 		.mode		= 0600,
678 		.proc_handler	= proc_do_cad_pid,
679 	},
680 #endif
681 	{
682 		.procname	= "threads-max",
683 		.data		= &max_threads,
684 		.maxlen		= sizeof(int),
685 		.mode		= 0644,
686 		.proc_handler	= proc_dointvec,
687 	},
688 	{
689 		.procname	= "random",
690 		.mode		= 0555,
691 		.child		= random_table,
692 	},
693 	{
694 		.procname	= "usermodehelper",
695 		.mode		= 0555,
696 		.child		= usermodehelper_table,
697 	},
698 	{
699 		.procname	= "overflowuid",
700 		.data		= &overflowuid,
701 		.maxlen		= sizeof(int),
702 		.mode		= 0644,
703 		.proc_handler	= proc_dointvec_minmax,
704 		.extra1		= &minolduid,
705 		.extra2		= &maxolduid,
706 	},
707 	{
708 		.procname	= "overflowgid",
709 		.data		= &overflowgid,
710 		.maxlen		= sizeof(int),
711 		.mode		= 0644,
712 		.proc_handler	= proc_dointvec_minmax,
713 		.extra1		= &minolduid,
714 		.extra2		= &maxolduid,
715 	},
716 #ifdef CONFIG_S390
717 #ifdef CONFIG_MATHEMU
718 	{
719 		.procname	= "ieee_emulation_warnings",
720 		.data		= &sysctl_ieee_emulation_warnings,
721 		.maxlen		= sizeof(int),
722 		.mode		= 0644,
723 		.proc_handler	= proc_dointvec,
724 	},
725 #endif
726 	{
727 		.procname	= "userprocess_debug",
728 		.data		= &show_unhandled_signals,
729 		.maxlen		= sizeof(int),
730 		.mode		= 0644,
731 		.proc_handler	= proc_dointvec,
732 	},
733 #endif
734 	{
735 		.procname	= "pid_max",
736 		.data		= &pid_max,
737 		.maxlen		= sizeof (int),
738 		.mode		= 0644,
739 		.proc_handler	= proc_dointvec_minmax,
740 		.extra1		= &pid_max_min,
741 		.extra2		= &pid_max_max,
742 	},
743 	{
744 		.procname	= "panic_on_oops",
745 		.data		= &panic_on_oops,
746 		.maxlen		= sizeof(int),
747 		.mode		= 0644,
748 		.proc_handler	= proc_dointvec,
749 	},
750 #if defined CONFIG_PRINTK
751 	{
752 		.procname	= "printk",
753 		.data		= &console_loglevel,
754 		.maxlen		= 4*sizeof(int),
755 		.mode		= 0644,
756 		.proc_handler	= proc_dointvec,
757 	},
758 	{
759 		.procname	= "printk_ratelimit",
760 		.data		= &printk_ratelimit_state.interval,
761 		.maxlen		= sizeof(int),
762 		.mode		= 0644,
763 		.proc_handler	= proc_dointvec_jiffies,
764 	},
765 	{
766 		.procname	= "printk_ratelimit_burst",
767 		.data		= &printk_ratelimit_state.burst,
768 		.maxlen		= sizeof(int),
769 		.mode		= 0644,
770 		.proc_handler	= proc_dointvec,
771 	},
772 	{
773 		.procname	= "printk_delay",
774 		.data		= &printk_delay_msec,
775 		.maxlen		= sizeof(int),
776 		.mode		= 0644,
777 		.proc_handler	= proc_dointvec_minmax,
778 		.extra1		= &zero,
779 		.extra2		= &ten_thousand,
780 	},
781 	{
782 		.procname	= "dmesg_restrict",
783 		.data		= &dmesg_restrict,
784 		.maxlen		= sizeof(int),
785 		.mode		= 0644,
786 		.proc_handler	= proc_dointvec_minmax_sysadmin,
787 		.extra1		= &zero,
788 		.extra2		= &one,
789 	},
790 	{
791 		.procname	= "kptr_restrict",
792 		.data		= &kptr_restrict,
793 		.maxlen		= sizeof(int),
794 		.mode		= 0644,
795 		.proc_handler	= proc_dointvec_minmax_sysadmin,
796 		.extra1		= &zero,
797 		.extra2		= &two,
798 	},
799 #endif
800 	{
801 		.procname	= "ngroups_max",
802 		.data		= &ngroups_max,
803 		.maxlen		= sizeof (int),
804 		.mode		= 0444,
805 		.proc_handler	= proc_dointvec,
806 	},
807 	{
808 		.procname	= "cap_last_cap",
809 		.data		= (void *)&cap_last_cap,
810 		.maxlen		= sizeof(int),
811 		.mode		= 0444,
812 		.proc_handler	= proc_dointvec,
813 	},
814 #if defined(CONFIG_LOCKUP_DETECTOR)
815 	{
816 		.procname       = "watchdog",
817 		.data           = &watchdog_user_enabled,
818 		.maxlen         = sizeof (int),
819 		.mode           = 0644,
820 		.proc_handler   = proc_dowatchdog,
821 		.extra1		= &zero,
822 		.extra2		= &one,
823 	},
824 	{
825 		.procname	= "watchdog_thresh",
826 		.data		= &watchdog_thresh,
827 		.maxlen		= sizeof(int),
828 		.mode		= 0644,
829 		.proc_handler	= proc_dowatchdog,
830 		.extra1		= &zero,
831 		.extra2		= &sixty,
832 	},
833 	{
834 		.procname	= "softlockup_panic",
835 		.data		= &softlockup_panic,
836 		.maxlen		= sizeof(int),
837 		.mode		= 0644,
838 		.proc_handler	= proc_dointvec_minmax,
839 		.extra1		= &zero,
840 		.extra2		= &one,
841 	},
842 	{
843 		.procname       = "nmi_watchdog",
844 		.data           = &watchdog_user_enabled,
845 		.maxlen         = sizeof (int),
846 		.mode           = 0644,
847 		.proc_handler   = proc_dowatchdog,
848 		.extra1		= &zero,
849 		.extra2		= &one,
850 	},
851 #endif
852 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
853 	{
854 		.procname       = "unknown_nmi_panic",
855 		.data           = &unknown_nmi_panic,
856 		.maxlen         = sizeof (int),
857 		.mode           = 0644,
858 		.proc_handler   = proc_dointvec,
859 	},
860 #endif
861 #if defined(CONFIG_X86)
862 	{
863 		.procname	= "panic_on_unrecovered_nmi",
864 		.data		= &panic_on_unrecovered_nmi,
865 		.maxlen		= sizeof(int),
866 		.mode		= 0644,
867 		.proc_handler	= proc_dointvec,
868 	},
869 	{
870 		.procname	= "panic_on_io_nmi",
871 		.data		= &panic_on_io_nmi,
872 		.maxlen		= sizeof(int),
873 		.mode		= 0644,
874 		.proc_handler	= proc_dointvec,
875 	},
876 #ifdef CONFIG_DEBUG_STACKOVERFLOW
877 	{
878 		.procname	= "panic_on_stackoverflow",
879 		.data		= &sysctl_panic_on_stackoverflow,
880 		.maxlen		= sizeof(int),
881 		.mode		= 0644,
882 		.proc_handler	= proc_dointvec,
883 	},
884 #endif
885 	{
886 		.procname	= "bootloader_type",
887 		.data		= &bootloader_type,
888 		.maxlen		= sizeof (int),
889 		.mode		= 0444,
890 		.proc_handler	= proc_dointvec,
891 	},
892 	{
893 		.procname	= "bootloader_version",
894 		.data		= &bootloader_version,
895 		.maxlen		= sizeof (int),
896 		.mode		= 0444,
897 		.proc_handler	= proc_dointvec,
898 	},
899 	{
900 		.procname	= "kstack_depth_to_print",
901 		.data		= &kstack_depth_to_print,
902 		.maxlen		= sizeof(int),
903 		.mode		= 0644,
904 		.proc_handler	= proc_dointvec,
905 	},
906 	{
907 		.procname	= "io_delay_type",
908 		.data		= &io_delay_type,
909 		.maxlen		= sizeof(int),
910 		.mode		= 0644,
911 		.proc_handler	= proc_dointvec,
912 	},
913 #endif
914 #if defined(CONFIG_MMU)
915 	{
916 		.procname	= "randomize_va_space",
917 		.data		= &randomize_va_space,
918 		.maxlen		= sizeof(int),
919 		.mode		= 0644,
920 		.proc_handler	= proc_dointvec,
921 	},
922 #endif
923 #if defined(CONFIG_S390) && defined(CONFIG_SMP)
924 	{
925 		.procname	= "spin_retry",
926 		.data		= &spin_retry,
927 		.maxlen		= sizeof (int),
928 		.mode		= 0644,
929 		.proc_handler	= proc_dointvec,
930 	},
931 #endif
932 #if	defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
933 	{
934 		.procname	= "acpi_video_flags",
935 		.data		= &acpi_realmode_flags,
936 		.maxlen		= sizeof (unsigned long),
937 		.mode		= 0644,
938 		.proc_handler	= proc_doulongvec_minmax,
939 	},
940 #endif
941 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
942 	{
943 		.procname	= "ignore-unaligned-usertrap",
944 		.data		= &no_unaligned_warning,
945 		.maxlen		= sizeof (int),
946 	 	.mode		= 0644,
947 		.proc_handler	= proc_dointvec,
948 	},
949 #endif
950 #ifdef CONFIG_IA64
951 	{
952 		.procname	= "unaligned-dump-stack",
953 		.data		= &unaligned_dump_stack,
954 		.maxlen		= sizeof (int),
955 		.mode		= 0644,
956 		.proc_handler	= proc_dointvec,
957 	},
958 #endif
959 #ifdef CONFIG_DETECT_HUNG_TASK
960 	{
961 		.procname	= "hung_task_panic",
962 		.data		= &sysctl_hung_task_panic,
963 		.maxlen		= sizeof(int),
964 		.mode		= 0644,
965 		.proc_handler	= proc_dointvec_minmax,
966 		.extra1		= &zero,
967 		.extra2		= &one,
968 	},
969 	{
970 		.procname	= "hung_task_check_count",
971 		.data		= &sysctl_hung_task_check_count,
972 		.maxlen		= sizeof(unsigned long),
973 		.mode		= 0644,
974 		.proc_handler	= proc_doulongvec_minmax,
975 	},
976 	{
977 		.procname	= "hung_task_timeout_secs",
978 		.data		= &sysctl_hung_task_timeout_secs,
979 		.maxlen		= sizeof(unsigned long),
980 		.mode		= 0644,
981 		.proc_handler	= proc_dohung_task_timeout_secs,
982 	},
983 	{
984 		.procname	= "hung_task_warnings",
985 		.data		= &sysctl_hung_task_warnings,
986 		.maxlen		= sizeof(unsigned long),
987 		.mode		= 0644,
988 		.proc_handler	= proc_doulongvec_minmax,
989 	},
990 #endif
991 #ifdef CONFIG_COMPAT
992 	{
993 		.procname	= "compat-log",
994 		.data		= &compat_log,
995 		.maxlen		= sizeof (int),
996 	 	.mode		= 0644,
997 		.proc_handler	= proc_dointvec,
998 	},
999 #endif
1000 #ifdef CONFIG_RT_MUTEXES
1001 	{
1002 		.procname	= "max_lock_depth",
1003 		.data		= &max_lock_depth,
1004 		.maxlen		= sizeof(int),
1005 		.mode		= 0644,
1006 		.proc_handler	= proc_dointvec,
1007 	},
1008 #endif
1009 	{
1010 		.procname	= "poweroff_cmd",
1011 		.data		= &poweroff_cmd,
1012 		.maxlen		= POWEROFF_CMD_PATH_LEN,
1013 		.mode		= 0644,
1014 		.proc_handler	= proc_dostring,
1015 	},
1016 #ifdef CONFIG_KEYS
1017 	{
1018 		.procname	= "keys",
1019 		.mode		= 0555,
1020 		.child		= key_sysctls,
1021 	},
1022 #endif
1023 #ifdef CONFIG_RCU_TORTURE_TEST
1024 	{
1025 		.procname       = "rcutorture_runnable",
1026 		.data           = &rcutorture_runnable,
1027 		.maxlen         = sizeof(int),
1028 		.mode           = 0644,
1029 		.proc_handler	= proc_dointvec,
1030 	},
1031 #endif
1032 #ifdef CONFIG_PERF_EVENTS
1033 	/*
1034 	 * User-space scripts rely on the existence of this file
1035 	 * as a feature check for perf_events being enabled.
1036 	 *
1037 	 * So it's an ABI, do not remove!
1038 	 */
1039 	{
1040 		.procname	= "perf_event_paranoid",
1041 		.data		= &sysctl_perf_event_paranoid,
1042 		.maxlen		= sizeof(sysctl_perf_event_paranoid),
1043 		.mode		= 0644,
1044 		.proc_handler	= proc_dointvec,
1045 	},
1046 	{
1047 		.procname	= "perf_event_mlock_kb",
1048 		.data		= &sysctl_perf_event_mlock,
1049 		.maxlen		= sizeof(sysctl_perf_event_mlock),
1050 		.mode		= 0644,
1051 		.proc_handler	= proc_dointvec,
1052 	},
1053 	{
1054 		.procname	= "perf_event_max_sample_rate",
1055 		.data		= &sysctl_perf_event_sample_rate,
1056 		.maxlen		= sizeof(sysctl_perf_event_sample_rate),
1057 		.mode		= 0644,
1058 		.proc_handler	= perf_proc_update_handler,
1059 		.extra1		= &one,
1060 	},
1061 	{
1062 		.procname	= "perf_cpu_time_max_percent",
1063 		.data		= &sysctl_perf_cpu_time_max_percent,
1064 		.maxlen		= sizeof(sysctl_perf_cpu_time_max_percent),
1065 		.mode		= 0644,
1066 		.proc_handler	= perf_cpu_time_max_percent_handler,
1067 		.extra1		= &zero,
1068 		.extra2		= &one_hundred,
1069 	},
1070 #endif
1071 #ifdef CONFIG_KMEMCHECK
1072 	{
1073 		.procname	= "kmemcheck",
1074 		.data		= &kmemcheck_enabled,
1075 		.maxlen		= sizeof(int),
1076 		.mode		= 0644,
1077 		.proc_handler	= proc_dointvec,
1078 	},
1079 #endif
1080 #ifdef CONFIG_BLOCK
1081 	{
1082 		.procname	= "blk_iopoll",
1083 		.data		= &blk_iopoll_enabled,
1084 		.maxlen		= sizeof(int),
1085 		.mode		= 0644,
1086 		.proc_handler	= proc_dointvec,
1087 	},
1088 #endif
1089 	{ }
1090 };
1091 
1092 static struct ctl_table vm_table[] = {
1093 	{
1094 		.procname	= "overcommit_memory",
1095 		.data		= &sysctl_overcommit_memory,
1096 		.maxlen		= sizeof(sysctl_overcommit_memory),
1097 		.mode		= 0644,
1098 		.proc_handler	= proc_dointvec_minmax,
1099 		.extra1		= &zero,
1100 		.extra2		= &two,
1101 	},
1102 	{
1103 		.procname	= "panic_on_oom",
1104 		.data		= &sysctl_panic_on_oom,
1105 		.maxlen		= sizeof(sysctl_panic_on_oom),
1106 		.mode		= 0644,
1107 		.proc_handler	= proc_dointvec_minmax,
1108 		.extra1		= &zero,
1109 		.extra2		= &two,
1110 	},
1111 	{
1112 		.procname	= "oom_kill_allocating_task",
1113 		.data		= &sysctl_oom_kill_allocating_task,
1114 		.maxlen		= sizeof(sysctl_oom_kill_allocating_task),
1115 		.mode		= 0644,
1116 		.proc_handler	= proc_dointvec,
1117 	},
1118 	{
1119 		.procname	= "oom_dump_tasks",
1120 		.data		= &sysctl_oom_dump_tasks,
1121 		.maxlen		= sizeof(sysctl_oom_dump_tasks),
1122 		.mode		= 0644,
1123 		.proc_handler	= proc_dointvec,
1124 	},
1125 	{
1126 		.procname	= "overcommit_ratio",
1127 		.data		= &sysctl_overcommit_ratio,
1128 		.maxlen		= sizeof(sysctl_overcommit_ratio),
1129 		.mode		= 0644,
1130 		.proc_handler	= proc_dointvec,
1131 	},
1132 	{
1133 		.procname	= "page-cluster",
1134 		.data		= &page_cluster,
1135 		.maxlen		= sizeof(int),
1136 		.mode		= 0644,
1137 		.proc_handler	= proc_dointvec_minmax,
1138 		.extra1		= &zero,
1139 	},
1140 	{
1141 		.procname	= "dirty_background_ratio",
1142 		.data		= &dirty_background_ratio,
1143 		.maxlen		= sizeof(dirty_background_ratio),
1144 		.mode		= 0644,
1145 		.proc_handler	= dirty_background_ratio_handler,
1146 		.extra1		= &zero,
1147 		.extra2		= &one_hundred,
1148 	},
1149 	{
1150 		.procname	= "dirty_background_bytes",
1151 		.data		= &dirty_background_bytes,
1152 		.maxlen		= sizeof(dirty_background_bytes),
1153 		.mode		= 0644,
1154 		.proc_handler	= dirty_background_bytes_handler,
1155 		.extra1		= &one_ul,
1156 	},
1157 	{
1158 		.procname	= "dirty_ratio",
1159 		.data		= &vm_dirty_ratio,
1160 		.maxlen		= sizeof(vm_dirty_ratio),
1161 		.mode		= 0644,
1162 		.proc_handler	= dirty_ratio_handler,
1163 		.extra1		= &zero,
1164 		.extra2		= &one_hundred,
1165 	},
1166 	{
1167 		.procname	= "dirty_bytes",
1168 		.data		= &vm_dirty_bytes,
1169 		.maxlen		= sizeof(vm_dirty_bytes),
1170 		.mode		= 0644,
1171 		.proc_handler	= dirty_bytes_handler,
1172 		.extra1		= &dirty_bytes_min,
1173 	},
1174 	{
1175 		.procname	= "dirty_writeback_centisecs",
1176 		.data		= &dirty_writeback_interval,
1177 		.maxlen		= sizeof(dirty_writeback_interval),
1178 		.mode		= 0644,
1179 		.proc_handler	= dirty_writeback_centisecs_handler,
1180 	},
1181 	{
1182 		.procname	= "dirty_expire_centisecs",
1183 		.data		= &dirty_expire_interval,
1184 		.maxlen		= sizeof(dirty_expire_interval),
1185 		.mode		= 0644,
1186 		.proc_handler	= proc_dointvec_minmax,
1187 		.extra1		= &zero,
1188 	},
1189 	{
1190 		.procname       = "nr_pdflush_threads",
1191 		.mode           = 0444 /* read-only */,
1192 		.proc_handler   = pdflush_proc_obsolete,
1193 	},
1194 	{
1195 		.procname	= "swappiness",
1196 		.data		= &vm_swappiness,
1197 		.maxlen		= sizeof(vm_swappiness),
1198 		.mode		= 0644,
1199 		.proc_handler	= proc_dointvec_minmax,
1200 		.extra1		= &zero,
1201 		.extra2		= &one_hundred,
1202 	},
1203 #ifdef CONFIG_HUGETLB_PAGE
1204 	{
1205 		.procname	= "nr_hugepages",
1206 		.data		= NULL,
1207 		.maxlen		= sizeof(unsigned long),
1208 		.mode		= 0644,
1209 		.proc_handler	= hugetlb_sysctl_handler,
1210 		.extra1		= (void *)&hugetlb_zero,
1211 		.extra2		= (void *)&hugetlb_infinity,
1212 	},
1213 #ifdef CONFIG_NUMA
1214 	{
1215 		.procname       = "nr_hugepages_mempolicy",
1216 		.data           = NULL,
1217 		.maxlen         = sizeof(unsigned long),
1218 		.mode           = 0644,
1219 		.proc_handler   = &hugetlb_mempolicy_sysctl_handler,
1220 		.extra1		= (void *)&hugetlb_zero,
1221 		.extra2		= (void *)&hugetlb_infinity,
1222 	},
1223 #endif
1224 	 {
1225 		.procname	= "hugetlb_shm_group",
1226 		.data		= &sysctl_hugetlb_shm_group,
1227 		.maxlen		= sizeof(gid_t),
1228 		.mode		= 0644,
1229 		.proc_handler	= proc_dointvec,
1230 	 },
1231 	 {
1232 		.procname	= "hugepages_treat_as_movable",
1233 		.data		= &hugepages_treat_as_movable,
1234 		.maxlen		= sizeof(int),
1235 		.mode		= 0644,
1236 		.proc_handler	= proc_dointvec,
1237 	},
1238 	{
1239 		.procname	= "nr_overcommit_hugepages",
1240 		.data		= NULL,
1241 		.maxlen		= sizeof(unsigned long),
1242 		.mode		= 0644,
1243 		.proc_handler	= hugetlb_overcommit_handler,
1244 		.extra1		= (void *)&hugetlb_zero,
1245 		.extra2		= (void *)&hugetlb_infinity,
1246 	},
1247 #endif
1248 	{
1249 		.procname	= "lowmem_reserve_ratio",
1250 		.data		= &sysctl_lowmem_reserve_ratio,
1251 		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
1252 		.mode		= 0644,
1253 		.proc_handler	= lowmem_reserve_ratio_sysctl_handler,
1254 	},
1255 	{
1256 		.procname	= "drop_caches",
1257 		.data		= &sysctl_drop_caches,
1258 		.maxlen		= sizeof(int),
1259 		.mode		= 0644,
1260 		.proc_handler	= drop_caches_sysctl_handler,
1261 		.extra1		= &one,
1262 		.extra2		= &three,
1263 	},
1264 #ifdef CONFIG_COMPACTION
1265 	{
1266 		.procname	= "compact_memory",
1267 		.data		= &sysctl_compact_memory,
1268 		.maxlen		= sizeof(int),
1269 		.mode		= 0200,
1270 		.proc_handler	= sysctl_compaction_handler,
1271 	},
1272 	{
1273 		.procname	= "extfrag_threshold",
1274 		.data		= &sysctl_extfrag_threshold,
1275 		.maxlen		= sizeof(int),
1276 		.mode		= 0644,
1277 		.proc_handler	= sysctl_extfrag_handler,
1278 		.extra1		= &min_extfrag_threshold,
1279 		.extra2		= &max_extfrag_threshold,
1280 	},
1281 
1282 #endif /* CONFIG_COMPACTION */
1283 	{
1284 		.procname	= "min_free_kbytes",
1285 		.data		= &min_free_kbytes,
1286 		.maxlen		= sizeof(min_free_kbytes),
1287 		.mode		= 0644,
1288 		.proc_handler	= min_free_kbytes_sysctl_handler,
1289 		.extra1		= &zero,
1290 	},
1291 	{
1292 		.procname	= "percpu_pagelist_fraction",
1293 		.data		= &percpu_pagelist_fraction,
1294 		.maxlen		= sizeof(percpu_pagelist_fraction),
1295 		.mode		= 0644,
1296 		.proc_handler	= percpu_pagelist_fraction_sysctl_handler,
1297 		.extra1		= &min_percpu_pagelist_fract,
1298 	},
1299 #ifdef CONFIG_MMU
1300 	{
1301 		.procname	= "max_map_count",
1302 		.data		= &sysctl_max_map_count,
1303 		.maxlen		= sizeof(sysctl_max_map_count),
1304 		.mode		= 0644,
1305 		.proc_handler	= proc_dointvec_minmax,
1306 		.extra1		= &zero,
1307 	},
1308 #else
1309 	{
1310 		.procname	= "nr_trim_pages",
1311 		.data		= &sysctl_nr_trim_pages,
1312 		.maxlen		= sizeof(sysctl_nr_trim_pages),
1313 		.mode		= 0644,
1314 		.proc_handler	= proc_dointvec_minmax,
1315 		.extra1		= &zero,
1316 	},
1317 #endif
1318 	{
1319 		.procname	= "laptop_mode",
1320 		.data		= &laptop_mode,
1321 		.maxlen		= sizeof(laptop_mode),
1322 		.mode		= 0644,
1323 		.proc_handler	= proc_dointvec_jiffies,
1324 	},
1325 	{
1326 		.procname	= "block_dump",
1327 		.data		= &block_dump,
1328 		.maxlen		= sizeof(block_dump),
1329 		.mode		= 0644,
1330 		.proc_handler	= proc_dointvec,
1331 		.extra1		= &zero,
1332 	},
1333 	{
1334 		.procname	= "vfs_cache_pressure",
1335 		.data		= &sysctl_vfs_cache_pressure,
1336 		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
1337 		.mode		= 0644,
1338 		.proc_handler	= proc_dointvec,
1339 		.extra1		= &zero,
1340 	},
1341 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1342 	{
1343 		.procname	= "legacy_va_layout",
1344 		.data		= &sysctl_legacy_va_layout,
1345 		.maxlen		= sizeof(sysctl_legacy_va_layout),
1346 		.mode		= 0644,
1347 		.proc_handler	= proc_dointvec,
1348 		.extra1		= &zero,
1349 	},
1350 #endif
1351 #ifdef CONFIG_NUMA
1352 	{
1353 		.procname	= "zone_reclaim_mode",
1354 		.data		= &zone_reclaim_mode,
1355 		.maxlen		= sizeof(zone_reclaim_mode),
1356 		.mode		= 0644,
1357 		.proc_handler	= proc_dointvec,
1358 		.extra1		= &zero,
1359 	},
1360 	{
1361 		.procname	= "min_unmapped_ratio",
1362 		.data		= &sysctl_min_unmapped_ratio,
1363 		.maxlen		= sizeof(sysctl_min_unmapped_ratio),
1364 		.mode		= 0644,
1365 		.proc_handler	= sysctl_min_unmapped_ratio_sysctl_handler,
1366 		.extra1		= &zero,
1367 		.extra2		= &one_hundred,
1368 	},
1369 	{
1370 		.procname	= "min_slab_ratio",
1371 		.data		= &sysctl_min_slab_ratio,
1372 		.maxlen		= sizeof(sysctl_min_slab_ratio),
1373 		.mode		= 0644,
1374 		.proc_handler	= sysctl_min_slab_ratio_sysctl_handler,
1375 		.extra1		= &zero,
1376 		.extra2		= &one_hundred,
1377 	},
1378 #endif
1379 #ifdef CONFIG_SMP
1380 	{
1381 		.procname	= "stat_interval",
1382 		.data		= &sysctl_stat_interval,
1383 		.maxlen		= sizeof(sysctl_stat_interval),
1384 		.mode		= 0644,
1385 		.proc_handler	= proc_dointvec_jiffies,
1386 	},
1387 #endif
1388 #ifdef CONFIG_MMU
1389 	{
1390 		.procname	= "mmap_min_addr",
1391 		.data		= &dac_mmap_min_addr,
1392 		.maxlen		= sizeof(unsigned long),
1393 		.mode		= 0644,
1394 		.proc_handler	= mmap_min_addr_handler,
1395 	},
1396 #endif
1397 #ifdef CONFIG_NUMA
1398 	{
1399 		.procname	= "numa_zonelist_order",
1400 		.data		= &numa_zonelist_order,
1401 		.maxlen		= NUMA_ZONELIST_ORDER_LEN,
1402 		.mode		= 0644,
1403 		.proc_handler	= numa_zonelist_order_handler,
1404 	},
1405 #endif
1406 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
1407    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
1408 	{
1409 		.procname	= "vdso_enabled",
1410 		.data		= &vdso_enabled,
1411 		.maxlen		= sizeof(vdso_enabled),
1412 		.mode		= 0644,
1413 		.proc_handler	= proc_dointvec,
1414 		.extra1		= &zero,
1415 	},
1416 #endif
1417 #ifdef CONFIG_HIGHMEM
1418 	{
1419 		.procname	= "highmem_is_dirtyable",
1420 		.data		= &vm_highmem_is_dirtyable,
1421 		.maxlen		= sizeof(vm_highmem_is_dirtyable),
1422 		.mode		= 0644,
1423 		.proc_handler	= proc_dointvec_minmax,
1424 		.extra1		= &zero,
1425 		.extra2		= &one,
1426 	},
1427 #endif
1428 	{
1429 		.procname	= "scan_unevictable_pages",
1430 		.data		= &scan_unevictable_pages,
1431 		.maxlen		= sizeof(scan_unevictable_pages),
1432 		.mode		= 0644,
1433 		.proc_handler	= scan_unevictable_handler,
1434 	},
1435 #ifdef CONFIG_MEMORY_FAILURE
1436 	{
1437 		.procname	= "memory_failure_early_kill",
1438 		.data		= &sysctl_memory_failure_early_kill,
1439 		.maxlen		= sizeof(sysctl_memory_failure_early_kill),
1440 		.mode		= 0644,
1441 		.proc_handler	= proc_dointvec_minmax,
1442 		.extra1		= &zero,
1443 		.extra2		= &one,
1444 	},
1445 	{
1446 		.procname	= "memory_failure_recovery",
1447 		.data		= &sysctl_memory_failure_recovery,
1448 		.maxlen		= sizeof(sysctl_memory_failure_recovery),
1449 		.mode		= 0644,
1450 		.proc_handler	= proc_dointvec_minmax,
1451 		.extra1		= &zero,
1452 		.extra2		= &one,
1453 	},
1454 #endif
1455 	{
1456 		.procname	= "user_reserve_kbytes",
1457 		.data		= &sysctl_user_reserve_kbytes,
1458 		.maxlen		= sizeof(sysctl_user_reserve_kbytes),
1459 		.mode		= 0644,
1460 		.proc_handler	= proc_doulongvec_minmax,
1461 	},
1462 	{
1463 		.procname	= "admin_reserve_kbytes",
1464 		.data		= &sysctl_admin_reserve_kbytes,
1465 		.maxlen		= sizeof(sysctl_admin_reserve_kbytes),
1466 		.mode		= 0644,
1467 		.proc_handler	= proc_doulongvec_minmax,
1468 	},
1469 	{ }
1470 };
1471 
1472 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1473 static struct ctl_table binfmt_misc_table[] = {
1474 	{ }
1475 };
1476 #endif
1477 
1478 static struct ctl_table fs_table[] = {
1479 	{
1480 		.procname	= "inode-nr",
1481 		.data		= &inodes_stat,
1482 		.maxlen		= 2*sizeof(long),
1483 		.mode		= 0444,
1484 		.proc_handler	= proc_nr_inodes,
1485 	},
1486 	{
1487 		.procname	= "inode-state",
1488 		.data		= &inodes_stat,
1489 		.maxlen		= 7*sizeof(long),
1490 		.mode		= 0444,
1491 		.proc_handler	= proc_nr_inodes,
1492 	},
1493 	{
1494 		.procname	= "file-nr",
1495 		.data		= &files_stat,
1496 		.maxlen		= sizeof(files_stat),
1497 		.mode		= 0444,
1498 		.proc_handler	= proc_nr_files,
1499 	},
1500 	{
1501 		.procname	= "file-max",
1502 		.data		= &files_stat.max_files,
1503 		.maxlen		= sizeof(files_stat.max_files),
1504 		.mode		= 0644,
1505 		.proc_handler	= proc_doulongvec_minmax,
1506 	},
1507 	{
1508 		.procname	= "nr_open",
1509 		.data		= &sysctl_nr_open,
1510 		.maxlen		= sizeof(int),
1511 		.mode		= 0644,
1512 		.proc_handler	= proc_dointvec_minmax,
1513 		.extra1		= &sysctl_nr_open_min,
1514 		.extra2		= &sysctl_nr_open_max,
1515 	},
1516 	{
1517 		.procname	= "dentry-state",
1518 		.data		= &dentry_stat,
1519 		.maxlen		= 6*sizeof(long),
1520 		.mode		= 0444,
1521 		.proc_handler	= proc_nr_dentry,
1522 	},
1523 	{
1524 		.procname	= "overflowuid",
1525 		.data		= &fs_overflowuid,
1526 		.maxlen		= sizeof(int),
1527 		.mode		= 0644,
1528 		.proc_handler	= proc_dointvec_minmax,
1529 		.extra1		= &minolduid,
1530 		.extra2		= &maxolduid,
1531 	},
1532 	{
1533 		.procname	= "overflowgid",
1534 		.data		= &fs_overflowgid,
1535 		.maxlen		= sizeof(int),
1536 		.mode		= 0644,
1537 		.proc_handler	= proc_dointvec_minmax,
1538 		.extra1		= &minolduid,
1539 		.extra2		= &maxolduid,
1540 	},
1541 #ifdef CONFIG_FILE_LOCKING
1542 	{
1543 		.procname	= "leases-enable",
1544 		.data		= &leases_enable,
1545 		.maxlen		= sizeof(int),
1546 		.mode		= 0644,
1547 		.proc_handler	= proc_dointvec,
1548 	},
1549 #endif
1550 #ifdef CONFIG_DNOTIFY
1551 	{
1552 		.procname	= "dir-notify-enable",
1553 		.data		= &dir_notify_enable,
1554 		.maxlen		= sizeof(int),
1555 		.mode		= 0644,
1556 		.proc_handler	= proc_dointvec,
1557 	},
1558 #endif
1559 #ifdef CONFIG_MMU
1560 #ifdef CONFIG_FILE_LOCKING
1561 	{
1562 		.procname	= "lease-break-time",
1563 		.data		= &lease_break_time,
1564 		.maxlen		= sizeof(int),
1565 		.mode		= 0644,
1566 		.proc_handler	= proc_dointvec,
1567 	},
1568 #endif
1569 #ifdef CONFIG_AIO
1570 	{
1571 		.procname	= "aio-nr",
1572 		.data		= &aio_nr,
1573 		.maxlen		= sizeof(aio_nr),
1574 		.mode		= 0444,
1575 		.proc_handler	= proc_doulongvec_minmax,
1576 	},
1577 	{
1578 		.procname	= "aio-max-nr",
1579 		.data		= &aio_max_nr,
1580 		.maxlen		= sizeof(aio_max_nr),
1581 		.mode		= 0644,
1582 		.proc_handler	= proc_doulongvec_minmax,
1583 	},
1584 #endif /* CONFIG_AIO */
1585 #ifdef CONFIG_INOTIFY_USER
1586 	{
1587 		.procname	= "inotify",
1588 		.mode		= 0555,
1589 		.child		= inotify_table,
1590 	},
1591 #endif
1592 #ifdef CONFIG_EPOLL
1593 	{
1594 		.procname	= "epoll",
1595 		.mode		= 0555,
1596 		.child		= epoll_table,
1597 	},
1598 #endif
1599 #endif
1600 	{
1601 		.procname	= "protected_symlinks",
1602 		.data		= &sysctl_protected_symlinks,
1603 		.maxlen		= sizeof(int),
1604 		.mode		= 0600,
1605 		.proc_handler	= proc_dointvec_minmax,
1606 		.extra1		= &zero,
1607 		.extra2		= &one,
1608 	},
1609 	{
1610 		.procname	= "protected_hardlinks",
1611 		.data		= &sysctl_protected_hardlinks,
1612 		.maxlen		= sizeof(int),
1613 		.mode		= 0600,
1614 		.proc_handler	= proc_dointvec_minmax,
1615 		.extra1		= &zero,
1616 		.extra2		= &one,
1617 	},
1618 	{
1619 		.procname	= "suid_dumpable",
1620 		.data		= &suid_dumpable,
1621 		.maxlen		= sizeof(int),
1622 		.mode		= 0644,
1623 		.proc_handler	= proc_dointvec_minmax_coredump,
1624 		.extra1		= &zero,
1625 		.extra2		= &two,
1626 	},
1627 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1628 	{
1629 		.procname	= "binfmt_misc",
1630 		.mode		= 0555,
1631 		.child		= binfmt_misc_table,
1632 	},
1633 #endif
1634 	{
1635 		.procname	= "pipe-max-size",
1636 		.data		= &pipe_max_size,
1637 		.maxlen		= sizeof(int),
1638 		.mode		= 0644,
1639 		.proc_handler	= &pipe_proc_fn,
1640 		.extra1		= &pipe_min_size,
1641 	},
1642 	{ }
1643 };
1644 
1645 static struct ctl_table debug_table[] = {
1646 #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
1647 	{
1648 		.procname	= "exception-trace",
1649 		.data		= &show_unhandled_signals,
1650 		.maxlen		= sizeof(int),
1651 		.mode		= 0644,
1652 		.proc_handler	= proc_dointvec
1653 	},
1654 #endif
1655 #if defined(CONFIG_OPTPROBES)
1656 	{
1657 		.procname	= "kprobes-optimization",
1658 		.data		= &sysctl_kprobes_optimization,
1659 		.maxlen		= sizeof(int),
1660 		.mode		= 0644,
1661 		.proc_handler	= proc_kprobes_optimization_handler,
1662 		.extra1		= &zero,
1663 		.extra2		= &one,
1664 	},
1665 #endif
1666 	{ }
1667 };
1668 
1669 static struct ctl_table dev_table[] = {
1670 	{ }
1671 };
1672 
1673 int __init sysctl_init(void)
1674 {
1675 	struct ctl_table_header *hdr;
1676 
1677 	hdr = register_sysctl_table(sysctl_base_table);
1678 	kmemleak_not_leak(hdr);
1679 	return 0;
1680 }
1681 
1682 #endif /* CONFIG_SYSCTL */
1683 
1684 /*
1685  * /proc/sys support
1686  */
1687 
1688 #ifdef CONFIG_PROC_SYSCTL
1689 
1690 static int _proc_do_string(void* data, int maxlen, int write,
1691 			   void __user *buffer,
1692 			   size_t *lenp, loff_t *ppos)
1693 {
1694 	size_t len;
1695 	char __user *p;
1696 	char c;
1697 
1698 	if (!data || !maxlen || !*lenp) {
1699 		*lenp = 0;
1700 		return 0;
1701 	}
1702 
1703 	if (write) {
1704 		len = 0;
1705 		p = buffer;
1706 		while (len < *lenp) {
1707 			if (get_user(c, p++))
1708 				return -EFAULT;
1709 			if (c == 0 || c == '\n')
1710 				break;
1711 			len++;
1712 		}
1713 		if (len >= maxlen)
1714 			len = maxlen-1;
1715 		if(copy_from_user(data, buffer, len))
1716 			return -EFAULT;
1717 		((char *) data)[len] = 0;
1718 		*ppos += *lenp;
1719 	} else {
1720 		len = strlen(data);
1721 		if (len > maxlen)
1722 			len = maxlen;
1723 
1724 		if (*ppos > len) {
1725 			*lenp = 0;
1726 			return 0;
1727 		}
1728 
1729 		data += *ppos;
1730 		len  -= *ppos;
1731 
1732 		if (len > *lenp)
1733 			len = *lenp;
1734 		if (len)
1735 			if(copy_to_user(buffer, data, len))
1736 				return -EFAULT;
1737 		if (len < *lenp) {
1738 			if(put_user('\n', ((char __user *) buffer) + len))
1739 				return -EFAULT;
1740 			len++;
1741 		}
1742 		*lenp = len;
1743 		*ppos += len;
1744 	}
1745 	return 0;
1746 }
1747 
1748 /**
1749  * proc_dostring - read a string sysctl
1750  * @table: the sysctl table
1751  * @write: %TRUE if this is a write to the sysctl file
1752  * @buffer: the user buffer
1753  * @lenp: the size of the user buffer
1754  * @ppos: file position
1755  *
1756  * Reads/writes a string from/to the user buffer. If the kernel
1757  * buffer provided is not large enough to hold the string, the
1758  * string is truncated. The copied string is %NULL-terminated.
1759  * If the string is being read by the user process, it is copied
1760  * and a newline '\n' is added. It is truncated if the buffer is
1761  * not large enough.
1762  *
1763  * Returns 0 on success.
1764  */
1765 int proc_dostring(struct ctl_table *table, int write,
1766 		  void __user *buffer, size_t *lenp, loff_t *ppos)
1767 {
1768 	return _proc_do_string(table->data, table->maxlen, write,
1769 			       buffer, lenp, ppos);
1770 }
1771 
1772 static size_t proc_skip_spaces(char **buf)
1773 {
1774 	size_t ret;
1775 	char *tmp = skip_spaces(*buf);
1776 	ret = tmp - *buf;
1777 	*buf = tmp;
1778 	return ret;
1779 }
1780 
1781 static void proc_skip_char(char **buf, size_t *size, const char v)
1782 {
1783 	while (*size) {
1784 		if (**buf != v)
1785 			break;
1786 		(*size)--;
1787 		(*buf)++;
1788 	}
1789 }
1790 
1791 #define TMPBUFLEN 22
1792 /**
1793  * proc_get_long - reads an ASCII formatted integer from a user buffer
1794  *
1795  * @buf: a kernel buffer
1796  * @size: size of the kernel buffer
1797  * @val: this is where the number will be stored
1798  * @neg: set to %TRUE if number is negative
1799  * @perm_tr: a vector which contains the allowed trailers
1800  * @perm_tr_len: size of the perm_tr vector
1801  * @tr: pointer to store the trailer character
1802  *
1803  * In case of success %0 is returned and @buf and @size are updated with
1804  * the amount of bytes read. If @tr is non-NULL and a trailing
1805  * character exists (size is non-zero after returning from this
1806  * function), @tr is updated with the trailing character.
1807  */
1808 static int proc_get_long(char **buf, size_t *size,
1809 			  unsigned long *val, bool *neg,
1810 			  const char *perm_tr, unsigned perm_tr_len, char *tr)
1811 {
1812 	int len;
1813 	char *p, tmp[TMPBUFLEN];
1814 
1815 	if (!*size)
1816 		return -EINVAL;
1817 
1818 	len = *size;
1819 	if (len > TMPBUFLEN - 1)
1820 		len = TMPBUFLEN - 1;
1821 
1822 	memcpy(tmp, *buf, len);
1823 
1824 	tmp[len] = 0;
1825 	p = tmp;
1826 	if (*p == '-' && *size > 1) {
1827 		*neg = true;
1828 		p++;
1829 	} else
1830 		*neg = false;
1831 	if (!isdigit(*p))
1832 		return -EINVAL;
1833 
1834 	*val = simple_strtoul(p, &p, 0);
1835 
1836 	len = p - tmp;
1837 
1838 	/* We don't know if the next char is whitespace thus we may accept
1839 	 * invalid integers (e.g. 1234...a) or two integers instead of one
1840 	 * (e.g. 123...1). So lets not allow such large numbers. */
1841 	if (len == TMPBUFLEN - 1)
1842 		return -EINVAL;
1843 
1844 	if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
1845 		return -EINVAL;
1846 
1847 	if (tr && (len < *size))
1848 		*tr = *p;
1849 
1850 	*buf += len;
1851 	*size -= len;
1852 
1853 	return 0;
1854 }
1855 
1856 /**
1857  * proc_put_long - converts an integer to a decimal ASCII formatted string
1858  *
1859  * @buf: the user buffer
1860  * @size: the size of the user buffer
1861  * @val: the integer to be converted
1862  * @neg: sign of the number, %TRUE for negative
1863  *
1864  * In case of success %0 is returned and @buf and @size are updated with
1865  * the amount of bytes written.
1866  */
1867 static int proc_put_long(void __user **buf, size_t *size, unsigned long val,
1868 			  bool neg)
1869 {
1870 	int len;
1871 	char tmp[TMPBUFLEN], *p = tmp;
1872 
1873 	sprintf(p, "%s%lu", neg ? "-" : "", val);
1874 	len = strlen(tmp);
1875 	if (len > *size)
1876 		len = *size;
1877 	if (copy_to_user(*buf, tmp, len))
1878 		return -EFAULT;
1879 	*size -= len;
1880 	*buf += len;
1881 	return 0;
1882 }
1883 #undef TMPBUFLEN
1884 
1885 static int proc_put_char(void __user **buf, size_t *size, char c)
1886 {
1887 	if (*size) {
1888 		char __user **buffer = (char __user **)buf;
1889 		if (put_user(c, *buffer))
1890 			return -EFAULT;
1891 		(*size)--, (*buffer)++;
1892 		*buf = *buffer;
1893 	}
1894 	return 0;
1895 }
1896 
1897 static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
1898 				 int *valp,
1899 				 int write, void *data)
1900 {
1901 	if (write) {
1902 		*valp = *negp ? -*lvalp : *lvalp;
1903 	} else {
1904 		int val = *valp;
1905 		if (val < 0) {
1906 			*negp = true;
1907 			*lvalp = (unsigned long)-val;
1908 		} else {
1909 			*negp = false;
1910 			*lvalp = (unsigned long)val;
1911 		}
1912 	}
1913 	return 0;
1914 }
1915 
1916 static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
1917 
1918 static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
1919 		  int write, void __user *buffer,
1920 		  size_t *lenp, loff_t *ppos,
1921 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
1922 			      int write, void *data),
1923 		  void *data)
1924 {
1925 	int *i, vleft, first = 1, err = 0;
1926 	unsigned long page = 0;
1927 	size_t left;
1928 	char *kbuf;
1929 
1930 	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
1931 		*lenp = 0;
1932 		return 0;
1933 	}
1934 
1935 	i = (int *) tbl_data;
1936 	vleft = table->maxlen / sizeof(*i);
1937 	left = *lenp;
1938 
1939 	if (!conv)
1940 		conv = do_proc_dointvec_conv;
1941 
1942 	if (write) {
1943 		if (left > PAGE_SIZE - 1)
1944 			left = PAGE_SIZE - 1;
1945 		page = __get_free_page(GFP_TEMPORARY);
1946 		kbuf = (char *) page;
1947 		if (!kbuf)
1948 			return -ENOMEM;
1949 		if (copy_from_user(kbuf, buffer, left)) {
1950 			err = -EFAULT;
1951 			goto free;
1952 		}
1953 		kbuf[left] = 0;
1954 	}
1955 
1956 	for (; left && vleft--; i++, first=0) {
1957 		unsigned long lval;
1958 		bool neg;
1959 
1960 		if (write) {
1961 			left -= proc_skip_spaces(&kbuf);
1962 
1963 			if (!left)
1964 				break;
1965 			err = proc_get_long(&kbuf, &left, &lval, &neg,
1966 					     proc_wspace_sep,
1967 					     sizeof(proc_wspace_sep), NULL);
1968 			if (err)
1969 				break;
1970 			if (conv(&neg, &lval, i, 1, data)) {
1971 				err = -EINVAL;
1972 				break;
1973 			}
1974 		} else {
1975 			if (conv(&neg, &lval, i, 0, data)) {
1976 				err = -EINVAL;
1977 				break;
1978 			}
1979 			if (!first)
1980 				err = proc_put_char(&buffer, &left, '\t');
1981 			if (err)
1982 				break;
1983 			err = proc_put_long(&buffer, &left, lval, neg);
1984 			if (err)
1985 				break;
1986 		}
1987 	}
1988 
1989 	if (!write && !first && left && !err)
1990 		err = proc_put_char(&buffer, &left, '\n');
1991 	if (write && !err && left)
1992 		left -= proc_skip_spaces(&kbuf);
1993 free:
1994 	if (write) {
1995 		free_page(page);
1996 		if (first)
1997 			return err ? : -EINVAL;
1998 	}
1999 	*lenp -= left;
2000 	*ppos += *lenp;
2001 	return err;
2002 }
2003 
2004 static int do_proc_dointvec(struct ctl_table *table, int write,
2005 		  void __user *buffer, size_t *lenp, loff_t *ppos,
2006 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
2007 			      int write, void *data),
2008 		  void *data)
2009 {
2010 	return __do_proc_dointvec(table->data, table, write,
2011 			buffer, lenp, ppos, conv, data);
2012 }
2013 
2014 /**
2015  * proc_dointvec - read a vector of integers
2016  * @table: the sysctl table
2017  * @write: %TRUE if this is a write to the sysctl file
2018  * @buffer: the user buffer
2019  * @lenp: the size of the user buffer
2020  * @ppos: file position
2021  *
2022  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2023  * values from/to the user buffer, treated as an ASCII string.
2024  *
2025  * Returns 0 on success.
2026  */
2027 int proc_dointvec(struct ctl_table *table, int write,
2028 		     void __user *buffer, size_t *lenp, loff_t *ppos)
2029 {
2030     return do_proc_dointvec(table,write,buffer,lenp,ppos,
2031 		    	    NULL,NULL);
2032 }
2033 
2034 /*
2035  * Taint values can only be increased
2036  * This means we can safely use a temporary.
2037  */
2038 static int proc_taint(struct ctl_table *table, int write,
2039 			       void __user *buffer, size_t *lenp, loff_t *ppos)
2040 {
2041 	struct ctl_table t;
2042 	unsigned long tmptaint = get_taint();
2043 	int err;
2044 
2045 	if (write && !capable(CAP_SYS_ADMIN))
2046 		return -EPERM;
2047 
2048 	t = *table;
2049 	t.data = &tmptaint;
2050 	err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
2051 	if (err < 0)
2052 		return err;
2053 
2054 	if (write) {
2055 		/*
2056 		 * Poor man's atomic or. Not worth adding a primitive
2057 		 * to everyone's atomic.h for this
2058 		 */
2059 		int i;
2060 		for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
2061 			if ((tmptaint >> i) & 1)
2062 				add_taint(i, LOCKDEP_STILL_OK);
2063 		}
2064 	}
2065 
2066 	return err;
2067 }
2068 
2069 #ifdef CONFIG_PRINTK
2070 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
2071 				void __user *buffer, size_t *lenp, loff_t *ppos)
2072 {
2073 	if (write && !capable(CAP_SYS_ADMIN))
2074 		return -EPERM;
2075 
2076 	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2077 }
2078 #endif
2079 
2080 struct do_proc_dointvec_minmax_conv_param {
2081 	int *min;
2082 	int *max;
2083 };
2084 
2085 static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
2086 					int *valp,
2087 					int write, void *data)
2088 {
2089 	struct do_proc_dointvec_minmax_conv_param *param = data;
2090 	if (write) {
2091 		int val = *negp ? -*lvalp : *lvalp;
2092 		if ((param->min && *param->min > val) ||
2093 		    (param->max && *param->max < val))
2094 			return -EINVAL;
2095 		*valp = val;
2096 	} else {
2097 		int val = *valp;
2098 		if (val < 0) {
2099 			*negp = true;
2100 			*lvalp = (unsigned long)-val;
2101 		} else {
2102 			*negp = false;
2103 			*lvalp = (unsigned long)val;
2104 		}
2105 	}
2106 	return 0;
2107 }
2108 
2109 /**
2110  * proc_dointvec_minmax - read a vector of integers with min/max values
2111  * @table: the sysctl table
2112  * @write: %TRUE if this is a write to the sysctl file
2113  * @buffer: the user buffer
2114  * @lenp: the size of the user buffer
2115  * @ppos: file position
2116  *
2117  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2118  * values from/to the user buffer, treated as an ASCII string.
2119  *
2120  * This routine will ensure the values are within the range specified by
2121  * table->extra1 (min) and table->extra2 (max).
2122  *
2123  * Returns 0 on success.
2124  */
2125 int proc_dointvec_minmax(struct ctl_table *table, int write,
2126 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2127 {
2128 	struct do_proc_dointvec_minmax_conv_param param = {
2129 		.min = (int *) table->extra1,
2130 		.max = (int *) table->extra2,
2131 	};
2132 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
2133 				do_proc_dointvec_minmax_conv, &param);
2134 }
2135 
2136 static void validate_coredump_safety(void)
2137 {
2138 #ifdef CONFIG_COREDUMP
2139 	if (suid_dumpable == SUID_DUMP_ROOT &&
2140 	    core_pattern[0] != '/' && core_pattern[0] != '|') {
2141 		printk(KERN_WARNING "Unsafe core_pattern used with "\
2142 			"suid_dumpable=2. Pipe handler or fully qualified "\
2143 			"core dump path required.\n");
2144 	}
2145 #endif
2146 }
2147 
2148 static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
2149 		void __user *buffer, size_t *lenp, loff_t *ppos)
2150 {
2151 	int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2152 	if (!error)
2153 		validate_coredump_safety();
2154 	return error;
2155 }
2156 
2157 #ifdef CONFIG_COREDUMP
2158 static int proc_dostring_coredump(struct ctl_table *table, int write,
2159 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2160 {
2161 	int error = proc_dostring(table, write, buffer, lenp, ppos);
2162 	if (!error)
2163 		validate_coredump_safety();
2164 	return error;
2165 }
2166 #endif
2167 
2168 static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
2169 				     void __user *buffer,
2170 				     size_t *lenp, loff_t *ppos,
2171 				     unsigned long convmul,
2172 				     unsigned long convdiv)
2173 {
2174 	unsigned long *i, *min, *max;
2175 	int vleft, first = 1, err = 0;
2176 	unsigned long page = 0;
2177 	size_t left;
2178 	char *kbuf;
2179 
2180 	if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
2181 		*lenp = 0;
2182 		return 0;
2183 	}
2184 
2185 	i = (unsigned long *) data;
2186 	min = (unsigned long *) table->extra1;
2187 	max = (unsigned long *) table->extra2;
2188 	vleft = table->maxlen / sizeof(unsigned long);
2189 	left = *lenp;
2190 
2191 	if (write) {
2192 		if (left > PAGE_SIZE - 1)
2193 			left = PAGE_SIZE - 1;
2194 		page = __get_free_page(GFP_TEMPORARY);
2195 		kbuf = (char *) page;
2196 		if (!kbuf)
2197 			return -ENOMEM;
2198 		if (copy_from_user(kbuf, buffer, left)) {
2199 			err = -EFAULT;
2200 			goto free;
2201 		}
2202 		kbuf[left] = 0;
2203 	}
2204 
2205 	for (; left && vleft--; i++, first = 0) {
2206 		unsigned long val;
2207 
2208 		if (write) {
2209 			bool neg;
2210 
2211 			left -= proc_skip_spaces(&kbuf);
2212 
2213 			err = proc_get_long(&kbuf, &left, &val, &neg,
2214 					     proc_wspace_sep,
2215 					     sizeof(proc_wspace_sep), NULL);
2216 			if (err)
2217 				break;
2218 			if (neg)
2219 				continue;
2220 			if ((min && val < *min) || (max && val > *max))
2221 				continue;
2222 			*i = val;
2223 		} else {
2224 			val = convdiv * (*i) / convmul;
2225 			if (!first)
2226 				err = proc_put_char(&buffer, &left, '\t');
2227 			err = proc_put_long(&buffer, &left, val, false);
2228 			if (err)
2229 				break;
2230 		}
2231 	}
2232 
2233 	if (!write && !first && left && !err)
2234 		err = proc_put_char(&buffer, &left, '\n');
2235 	if (write && !err)
2236 		left -= proc_skip_spaces(&kbuf);
2237 free:
2238 	if (write) {
2239 		free_page(page);
2240 		if (first)
2241 			return err ? : -EINVAL;
2242 	}
2243 	*lenp -= left;
2244 	*ppos += *lenp;
2245 	return err;
2246 }
2247 
2248 static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
2249 				     void __user *buffer,
2250 				     size_t *lenp, loff_t *ppos,
2251 				     unsigned long convmul,
2252 				     unsigned long convdiv)
2253 {
2254 	return __do_proc_doulongvec_minmax(table->data, table, write,
2255 			buffer, lenp, ppos, convmul, convdiv);
2256 }
2257 
2258 /**
2259  * proc_doulongvec_minmax - read a vector of long integers with min/max values
2260  * @table: the sysctl table
2261  * @write: %TRUE if this is a write to the sysctl file
2262  * @buffer: the user buffer
2263  * @lenp: the size of the user buffer
2264  * @ppos: file position
2265  *
2266  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2267  * values from/to the user buffer, treated as an ASCII string.
2268  *
2269  * This routine will ensure the values are within the range specified by
2270  * table->extra1 (min) and table->extra2 (max).
2271  *
2272  * Returns 0 on success.
2273  */
2274 int proc_doulongvec_minmax(struct ctl_table *table, int write,
2275 			   void __user *buffer, size_t *lenp, loff_t *ppos)
2276 {
2277     return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
2278 }
2279 
2280 /**
2281  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
2282  * @table: the sysctl table
2283  * @write: %TRUE if this is a write to the sysctl file
2284  * @buffer: the user buffer
2285  * @lenp: the size of the user buffer
2286  * @ppos: file position
2287  *
2288  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2289  * values from/to the user buffer, treated as an ASCII string. The values
2290  * are treated as milliseconds, and converted to jiffies when they are stored.
2291  *
2292  * This routine will ensure the values are within the range specified by
2293  * table->extra1 (min) and table->extra2 (max).
2294  *
2295  * Returns 0 on success.
2296  */
2297 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2298 				      void __user *buffer,
2299 				      size_t *lenp, loff_t *ppos)
2300 {
2301     return do_proc_doulongvec_minmax(table, write, buffer,
2302 				     lenp, ppos, HZ, 1000l);
2303 }
2304 
2305 
2306 static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
2307 					 int *valp,
2308 					 int write, void *data)
2309 {
2310 	if (write) {
2311 		if (*lvalp > LONG_MAX / HZ)
2312 			return 1;
2313 		*valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
2314 	} else {
2315 		int val = *valp;
2316 		unsigned long lval;
2317 		if (val < 0) {
2318 			*negp = true;
2319 			lval = (unsigned long)-val;
2320 		} else {
2321 			*negp = false;
2322 			lval = (unsigned long)val;
2323 		}
2324 		*lvalp = lval / HZ;
2325 	}
2326 	return 0;
2327 }
2328 
2329 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
2330 						int *valp,
2331 						int write, void *data)
2332 {
2333 	if (write) {
2334 		if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
2335 			return 1;
2336 		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
2337 	} else {
2338 		int val = *valp;
2339 		unsigned long lval;
2340 		if (val < 0) {
2341 			*negp = true;
2342 			lval = (unsigned long)-val;
2343 		} else {
2344 			*negp = false;
2345 			lval = (unsigned long)val;
2346 		}
2347 		*lvalp = jiffies_to_clock_t(lval);
2348 	}
2349 	return 0;
2350 }
2351 
2352 static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
2353 					    int *valp,
2354 					    int write, void *data)
2355 {
2356 	if (write) {
2357 		unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
2358 
2359 		if (jif > INT_MAX)
2360 			return 1;
2361 		*valp = (int)jif;
2362 	} else {
2363 		int val = *valp;
2364 		unsigned long lval;
2365 		if (val < 0) {
2366 			*negp = true;
2367 			lval = (unsigned long)-val;
2368 		} else {
2369 			*negp = false;
2370 			lval = (unsigned long)val;
2371 		}
2372 		*lvalp = jiffies_to_msecs(lval);
2373 	}
2374 	return 0;
2375 }
2376 
2377 /**
2378  * proc_dointvec_jiffies - read a vector of integers as seconds
2379  * @table: the sysctl table
2380  * @write: %TRUE if this is a write to the sysctl file
2381  * @buffer: the user buffer
2382  * @lenp: the size of the user buffer
2383  * @ppos: file position
2384  *
2385  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2386  * values from/to the user buffer, treated as an ASCII string.
2387  * The values read are assumed to be in seconds, and are converted into
2388  * jiffies.
2389  *
2390  * Returns 0 on success.
2391  */
2392 int proc_dointvec_jiffies(struct ctl_table *table, int write,
2393 			  void __user *buffer, size_t *lenp, loff_t *ppos)
2394 {
2395     return do_proc_dointvec(table,write,buffer,lenp,ppos,
2396 		    	    do_proc_dointvec_jiffies_conv,NULL);
2397 }
2398 
2399 /**
2400  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
2401  * @table: the sysctl table
2402  * @write: %TRUE if this is a write to the sysctl file
2403  * @buffer: the user buffer
2404  * @lenp: the size of the user buffer
2405  * @ppos: pointer to the file position
2406  *
2407  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2408  * values from/to the user buffer, treated as an ASCII string.
2409  * The values read are assumed to be in 1/USER_HZ seconds, and
2410  * are converted into jiffies.
2411  *
2412  * Returns 0 on success.
2413  */
2414 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
2415 				 void __user *buffer, size_t *lenp, loff_t *ppos)
2416 {
2417     return do_proc_dointvec(table,write,buffer,lenp,ppos,
2418 		    	    do_proc_dointvec_userhz_jiffies_conv,NULL);
2419 }
2420 
2421 /**
2422  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
2423  * @table: the sysctl table
2424  * @write: %TRUE if this is a write to the sysctl file
2425  * @buffer: the user buffer
2426  * @lenp: the size of the user buffer
2427  * @ppos: file position
2428  * @ppos: the current position in the file
2429  *
2430  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2431  * values from/to the user buffer, treated as an ASCII string.
2432  * The values read are assumed to be in 1/1000 seconds, and
2433  * are converted into jiffies.
2434  *
2435  * Returns 0 on success.
2436  */
2437 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
2438 			     void __user *buffer, size_t *lenp, loff_t *ppos)
2439 {
2440 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
2441 				do_proc_dointvec_ms_jiffies_conv, NULL);
2442 }
2443 
2444 static int proc_do_cad_pid(struct ctl_table *table, int write,
2445 			   void __user *buffer, size_t *lenp, loff_t *ppos)
2446 {
2447 	struct pid *new_pid;
2448 	pid_t tmp;
2449 	int r;
2450 
2451 	tmp = pid_vnr(cad_pid);
2452 
2453 	r = __do_proc_dointvec(&tmp, table, write, buffer,
2454 			       lenp, ppos, NULL, NULL);
2455 	if (r || !write)
2456 		return r;
2457 
2458 	new_pid = find_get_pid(tmp);
2459 	if (!new_pid)
2460 		return -ESRCH;
2461 
2462 	put_pid(xchg(&cad_pid, new_pid));
2463 	return 0;
2464 }
2465 
2466 /**
2467  * proc_do_large_bitmap - read/write from/to a large bitmap
2468  * @table: the sysctl table
2469  * @write: %TRUE if this is a write to the sysctl file
2470  * @buffer: the user buffer
2471  * @lenp: the size of the user buffer
2472  * @ppos: file position
2473  *
2474  * The bitmap is stored at table->data and the bitmap length (in bits)
2475  * in table->maxlen.
2476  *
2477  * We use a range comma separated format (e.g. 1,3-4,10-10) so that
2478  * large bitmaps may be represented in a compact manner. Writing into
2479  * the file will clear the bitmap then update it with the given input.
2480  *
2481  * Returns 0 on success.
2482  */
2483 int proc_do_large_bitmap(struct ctl_table *table, int write,
2484 			 void __user *buffer, size_t *lenp, loff_t *ppos)
2485 {
2486 	int err = 0;
2487 	bool first = 1;
2488 	size_t left = *lenp;
2489 	unsigned long bitmap_len = table->maxlen;
2490 	unsigned long *bitmap = (unsigned long *) table->data;
2491 	unsigned long *tmp_bitmap = NULL;
2492 	char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
2493 
2494 	if (!bitmap_len || !left || (*ppos && !write)) {
2495 		*lenp = 0;
2496 		return 0;
2497 	}
2498 
2499 	if (write) {
2500 		unsigned long page = 0;
2501 		char *kbuf;
2502 
2503 		if (left > PAGE_SIZE - 1)
2504 			left = PAGE_SIZE - 1;
2505 
2506 		page = __get_free_page(GFP_TEMPORARY);
2507 		kbuf = (char *) page;
2508 		if (!kbuf)
2509 			return -ENOMEM;
2510 		if (copy_from_user(kbuf, buffer, left)) {
2511 			free_page(page);
2512 			return -EFAULT;
2513                 }
2514 		kbuf[left] = 0;
2515 
2516 		tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long),
2517 				     GFP_KERNEL);
2518 		if (!tmp_bitmap) {
2519 			free_page(page);
2520 			return -ENOMEM;
2521 		}
2522 		proc_skip_char(&kbuf, &left, '\n');
2523 		while (!err && left) {
2524 			unsigned long val_a, val_b;
2525 			bool neg;
2526 
2527 			err = proc_get_long(&kbuf, &left, &val_a, &neg, tr_a,
2528 					     sizeof(tr_a), &c);
2529 			if (err)
2530 				break;
2531 			if (val_a >= bitmap_len || neg) {
2532 				err = -EINVAL;
2533 				break;
2534 			}
2535 
2536 			val_b = val_a;
2537 			if (left) {
2538 				kbuf++;
2539 				left--;
2540 			}
2541 
2542 			if (c == '-') {
2543 				err = proc_get_long(&kbuf, &left, &val_b,
2544 						     &neg, tr_b, sizeof(tr_b),
2545 						     &c);
2546 				if (err)
2547 					break;
2548 				if (val_b >= bitmap_len || neg ||
2549 				    val_a > val_b) {
2550 					err = -EINVAL;
2551 					break;
2552 				}
2553 				if (left) {
2554 					kbuf++;
2555 					left--;
2556 				}
2557 			}
2558 
2559 			bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
2560 			first = 0;
2561 			proc_skip_char(&kbuf, &left, '\n');
2562 		}
2563 		free_page(page);
2564 	} else {
2565 		unsigned long bit_a, bit_b = 0;
2566 
2567 		while (left) {
2568 			bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
2569 			if (bit_a >= bitmap_len)
2570 				break;
2571 			bit_b = find_next_zero_bit(bitmap, bitmap_len,
2572 						   bit_a + 1) - 1;
2573 
2574 			if (!first) {
2575 				err = proc_put_char(&buffer, &left, ',');
2576 				if (err)
2577 					break;
2578 			}
2579 			err = proc_put_long(&buffer, &left, bit_a, false);
2580 			if (err)
2581 				break;
2582 			if (bit_a != bit_b) {
2583 				err = proc_put_char(&buffer, &left, '-');
2584 				if (err)
2585 					break;
2586 				err = proc_put_long(&buffer, &left, bit_b, false);
2587 				if (err)
2588 					break;
2589 			}
2590 
2591 			first = 0; bit_b++;
2592 		}
2593 		if (!err)
2594 			err = proc_put_char(&buffer, &left, '\n');
2595 	}
2596 
2597 	if (!err) {
2598 		if (write) {
2599 			if (*ppos)
2600 				bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
2601 			else
2602 				bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
2603 		}
2604 		kfree(tmp_bitmap);
2605 		*lenp -= left;
2606 		*ppos += *lenp;
2607 		return 0;
2608 	} else {
2609 		kfree(tmp_bitmap);
2610 		return err;
2611 	}
2612 }
2613 
2614 #else /* CONFIG_PROC_SYSCTL */
2615 
2616 int proc_dostring(struct ctl_table *table, int write,
2617 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2618 {
2619 	return -ENOSYS;
2620 }
2621 
2622 int proc_dointvec(struct ctl_table *table, int write,
2623 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2624 {
2625 	return -ENOSYS;
2626 }
2627 
2628 int proc_dointvec_minmax(struct ctl_table *table, int write,
2629 		    void __user *buffer, size_t *lenp, loff_t *ppos)
2630 {
2631 	return -ENOSYS;
2632 }
2633 
2634 int proc_dointvec_jiffies(struct ctl_table *table, int write,
2635 		    void __user *buffer, size_t *lenp, loff_t *ppos)
2636 {
2637 	return -ENOSYS;
2638 }
2639 
2640 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
2641 		    void __user *buffer, size_t *lenp, loff_t *ppos)
2642 {
2643 	return -ENOSYS;
2644 }
2645 
2646 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
2647 			     void __user *buffer, size_t *lenp, loff_t *ppos)
2648 {
2649 	return -ENOSYS;
2650 }
2651 
2652 int proc_doulongvec_minmax(struct ctl_table *table, int write,
2653 		    void __user *buffer, size_t *lenp, loff_t *ppos)
2654 {
2655 	return -ENOSYS;
2656 }
2657 
2658 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2659 				      void __user *buffer,
2660 				      size_t *lenp, loff_t *ppos)
2661 {
2662     return -ENOSYS;
2663 }
2664 
2665 
2666 #endif /* CONFIG_PROC_SYSCTL */
2667 
2668 /*
2669  * No sense putting this after each symbol definition, twice,
2670  * exception granted :-)
2671  */
2672 EXPORT_SYMBOL(proc_dointvec);
2673 EXPORT_SYMBOL(proc_dointvec_jiffies);
2674 EXPORT_SYMBOL(proc_dointvec_minmax);
2675 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2676 EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2677 EXPORT_SYMBOL(proc_dostring);
2678 EXPORT_SYMBOL(proc_doulongvec_minmax);
2679 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
2680