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