xref: /openbmc/linux/kernel/sysctl.c (revision 4f89e4b8)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * sysctl.c: General linux system control interface
4  *
5  * Begun 24 March 1995, Stephen Tweedie
6  * Added /proc support, Dec 1995
7  * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
8  * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
9  * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
10  * Dynamic registration fixes, Stephen Tweedie.
11  * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
12  * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
13  *  Horn.
14  * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
15  * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
16  * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
17  *  Wendling.
18  * The list_for_each() macro wasn't appropriate for the sysctl loop.
19  *  Removed it and replaced it with older style, 03/23/00, Bill Wendling
20  */
21 
22 #include <linux/module.h>
23 #include <linux/aio.h>
24 #include <linux/mm.h>
25 #include <linux/swap.h>
26 #include <linux/slab.h>
27 #include <linux/sysctl.h>
28 #include <linux/bitmap.h>
29 #include <linux/signal.h>
30 #include <linux/printk.h>
31 #include <linux/proc_fs.h>
32 #include <linux/security.h>
33 #include <linux/ctype.h>
34 #include <linux/kmemleak.h>
35 #include <linux/fs.h>
36 #include <linux/init.h>
37 #include <linux/kernel.h>
38 #include <linux/kobject.h>
39 #include <linux/net.h>
40 #include <linux/sysrq.h>
41 #include <linux/highuid.h>
42 #include <linux/writeback.h>
43 #include <linux/ratelimit.h>
44 #include <linux/compaction.h>
45 #include <linux/hugetlb.h>
46 #include <linux/initrd.h>
47 #include <linux/key.h>
48 #include <linux/times.h>
49 #include <linux/limits.h>
50 #include <linux/dcache.h>
51 #include <linux/dnotify.h>
52 #include <linux/syscalls.h>
53 #include <linux/vmstat.h>
54 #include <linux/nfs_fs.h>
55 #include <linux/acpi.h>
56 #include <linux/reboot.h>
57 #include <linux/ftrace.h>
58 #include <linux/perf_event.h>
59 #include <linux/kprobes.h>
60 #include <linux/pipe_fs_i.h>
61 #include <linux/oom.h>
62 #include <linux/kmod.h>
63 #include <linux/capability.h>
64 #include <linux/binfmts.h>
65 #include <linux/sched/sysctl.h>
66 #include <linux/sched/coredump.h>
67 #include <linux/kexec.h>
68 #include <linux/bpf.h>
69 #include <linux/mount.h>
70 #include <linux/userfaultfd_k.h>
71 
72 #include "../lib/kstrtox.h"
73 
74 #include <linux/uaccess.h>
75 #include <asm/processor.h>
76 
77 #ifdef CONFIG_X86
78 #include <asm/nmi.h>
79 #include <asm/stacktrace.h>
80 #include <asm/io.h>
81 #endif
82 #ifdef CONFIG_SPARC
83 #include <asm/setup.h>
84 #endif
85 #ifdef CONFIG_BSD_PROCESS_ACCT
86 #include <linux/acct.h>
87 #endif
88 #ifdef CONFIG_RT_MUTEXES
89 #include <linux/rtmutex.h>
90 #endif
91 #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
92 #include <linux/lockdep.h>
93 #endif
94 #ifdef CONFIG_CHR_DEV_SG
95 #include <scsi/sg.h>
96 #endif
97 #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
98 #include <linux/stackleak.h>
99 #endif
100 #ifdef CONFIG_LOCKUP_DETECTOR
101 #include <linux/nmi.h>
102 #endif
103 
104 #if defined(CONFIG_SYSCTL)
105 
106 /* External variables not in a header file. */
107 extern int suid_dumpable;
108 #ifdef CONFIG_COREDUMP
109 extern int core_uses_pid;
110 extern char core_pattern[];
111 extern unsigned int core_pipe_limit;
112 #endif
113 extern int pid_max;
114 extern int pid_max_min, pid_max_max;
115 extern int percpu_pagelist_fraction;
116 extern int latencytop_enabled;
117 extern unsigned int sysctl_nr_open_min, sysctl_nr_open_max;
118 #ifndef CONFIG_MMU
119 extern int sysctl_nr_trim_pages;
120 #endif
121 
122 /* Constants used for minimum and  maximum */
123 #ifdef CONFIG_LOCKUP_DETECTOR
124 static int sixty = 60;
125 #endif
126 
127 static int __maybe_unused neg_one = -1;
128 static int __maybe_unused two = 2;
129 static int __maybe_unused four = 4;
130 static unsigned long zero_ul;
131 static unsigned long one_ul = 1;
132 static unsigned long long_max = LONG_MAX;
133 static int one_hundred = 100;
134 static int one_thousand = 1000;
135 #ifdef CONFIG_PRINTK
136 static int ten_thousand = 10000;
137 #endif
138 #ifdef CONFIG_PERF_EVENTS
139 static int six_hundred_forty_kb = 640 * 1024;
140 #endif
141 
142 /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
143 static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
144 
145 /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
146 static int maxolduid = 65535;
147 static int minolduid;
148 
149 static int ngroups_max = NGROUPS_MAX;
150 static const int cap_last_cap = CAP_LAST_CAP;
151 
152 /*
153  * This is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs
154  * and hung_task_check_interval_secs
155  */
156 #ifdef CONFIG_DETECT_HUNG_TASK
157 static unsigned long hung_task_timeout_max = (LONG_MAX/HZ);
158 #endif
159 
160 #ifdef CONFIG_INOTIFY_USER
161 #include <linux/inotify.h>
162 #endif
163 #ifdef CONFIG_SPARC
164 #endif
165 
166 #ifdef __hppa__
167 extern int pwrsw_enabled;
168 #endif
169 
170 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
171 extern int unaligned_enabled;
172 #endif
173 
174 #ifdef CONFIG_IA64
175 extern int unaligned_dump_stack;
176 #endif
177 
178 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
179 extern int no_unaligned_warning;
180 #endif
181 
182 #ifdef CONFIG_PROC_SYSCTL
183 
184 /**
185  * enum sysctl_writes_mode - supported sysctl write modes
186  *
187  * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
188  *	to be written, and multiple writes on the same sysctl file descriptor
189  *	will rewrite the sysctl value, regardless of file position. No warning
190  *	is issued when the initial position is not 0.
191  * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
192  *	not 0.
193  * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
194  *	file position 0 and the value must be fully contained in the buffer
195  *	sent to the write syscall. If dealing with strings respect the file
196  *	position, but restrict this to the max length of the buffer, anything
197  *	passed the max length will be ignored. Multiple writes will append
198  *	to the buffer.
199  *
200  * These write modes control how current file position affects the behavior of
201  * updating sysctl values through the proc interface on each write.
202  */
203 enum sysctl_writes_mode {
204 	SYSCTL_WRITES_LEGACY		= -1,
205 	SYSCTL_WRITES_WARN		= 0,
206 	SYSCTL_WRITES_STRICT		= 1,
207 };
208 
209 static enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT;
210 
211 static int proc_do_cad_pid(struct ctl_table *table, int write,
212 		  void __user *buffer, size_t *lenp, loff_t *ppos);
213 static int proc_taint(struct ctl_table *table, int write,
214 			       void __user *buffer, size_t *lenp, loff_t *ppos);
215 #endif
216 
217 #ifdef CONFIG_PRINTK
218 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
219 				void __user *buffer, size_t *lenp, loff_t *ppos);
220 #endif
221 
222 static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
223 		void __user *buffer, size_t *lenp, loff_t *ppos);
224 #ifdef CONFIG_COREDUMP
225 static int proc_dostring_coredump(struct ctl_table *table, int write,
226 		void __user *buffer, size_t *lenp, loff_t *ppos);
227 #endif
228 static int proc_dopipe_max_size(struct ctl_table *table, int write,
229 		void __user *buffer, size_t *lenp, loff_t *ppos);
230 
231 #ifdef CONFIG_MAGIC_SYSRQ
232 /* Note: sysrq code uses its own private copy */
233 static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
234 
235 static int sysrq_sysctl_handler(struct ctl_table *table, int write,
236 				void __user *buffer, size_t *lenp,
237 				loff_t *ppos)
238 {
239 	int error;
240 
241 	error = proc_dointvec(table, write, buffer, lenp, ppos);
242 	if (error)
243 		return error;
244 
245 	if (write)
246 		sysrq_toggle_support(__sysrq_enabled);
247 
248 	return 0;
249 }
250 
251 #endif
252 
253 static struct ctl_table kern_table[];
254 static struct ctl_table vm_table[];
255 static struct ctl_table fs_table[];
256 static struct ctl_table debug_table[];
257 static struct ctl_table dev_table[];
258 extern struct ctl_table random_table[];
259 #ifdef CONFIG_EPOLL
260 extern struct ctl_table epoll_table[];
261 #endif
262 
263 #ifdef CONFIG_FW_LOADER_USER_HELPER
264 extern struct ctl_table firmware_config_table[];
265 #endif
266 
267 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
268 int sysctl_legacy_va_layout;
269 #endif
270 
271 /* The default sysctl tables: */
272 
273 static struct ctl_table sysctl_base_table[] = {
274 	{
275 		.procname	= "kernel",
276 		.mode		= 0555,
277 		.child		= kern_table,
278 	},
279 	{
280 		.procname	= "vm",
281 		.mode		= 0555,
282 		.child		= vm_table,
283 	},
284 	{
285 		.procname	= "fs",
286 		.mode		= 0555,
287 		.child		= fs_table,
288 	},
289 	{
290 		.procname	= "debug",
291 		.mode		= 0555,
292 		.child		= debug_table,
293 	},
294 	{
295 		.procname	= "dev",
296 		.mode		= 0555,
297 		.child		= dev_table,
298 	},
299 	{ }
300 };
301 
302 #ifdef CONFIG_SCHED_DEBUG
303 static int min_sched_granularity_ns = 100000;		/* 100 usecs */
304 static int max_sched_granularity_ns = NSEC_PER_SEC;	/* 1 second */
305 static int min_wakeup_granularity_ns;			/* 0 usecs */
306 static int max_wakeup_granularity_ns = NSEC_PER_SEC;	/* 1 second */
307 #ifdef CONFIG_SMP
308 static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
309 static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
310 #endif /* CONFIG_SMP */
311 #endif /* CONFIG_SCHED_DEBUG */
312 
313 #ifdef CONFIG_COMPACTION
314 static int min_extfrag_threshold;
315 static int max_extfrag_threshold = 1000;
316 #endif
317 
318 static struct ctl_table kern_table[] = {
319 	{
320 		.procname	= "sched_child_runs_first",
321 		.data		= &sysctl_sched_child_runs_first,
322 		.maxlen		= sizeof(unsigned int),
323 		.mode		= 0644,
324 		.proc_handler	= proc_dointvec,
325 	},
326 #ifdef CONFIG_SCHED_DEBUG
327 	{
328 		.procname	= "sched_min_granularity_ns",
329 		.data		= &sysctl_sched_min_granularity,
330 		.maxlen		= sizeof(unsigned int),
331 		.mode		= 0644,
332 		.proc_handler	= sched_proc_update_handler,
333 		.extra1		= &min_sched_granularity_ns,
334 		.extra2		= &max_sched_granularity_ns,
335 	},
336 	{
337 		.procname	= "sched_latency_ns",
338 		.data		= &sysctl_sched_latency,
339 		.maxlen		= sizeof(unsigned int),
340 		.mode		= 0644,
341 		.proc_handler	= sched_proc_update_handler,
342 		.extra1		= &min_sched_granularity_ns,
343 		.extra2		= &max_sched_granularity_ns,
344 	},
345 	{
346 		.procname	= "sched_wakeup_granularity_ns",
347 		.data		= &sysctl_sched_wakeup_granularity,
348 		.maxlen		= sizeof(unsigned int),
349 		.mode		= 0644,
350 		.proc_handler	= sched_proc_update_handler,
351 		.extra1		= &min_wakeup_granularity_ns,
352 		.extra2		= &max_wakeup_granularity_ns,
353 	},
354 #ifdef CONFIG_SMP
355 	{
356 		.procname	= "sched_tunable_scaling",
357 		.data		= &sysctl_sched_tunable_scaling,
358 		.maxlen		= sizeof(enum sched_tunable_scaling),
359 		.mode		= 0644,
360 		.proc_handler	= sched_proc_update_handler,
361 		.extra1		= &min_sched_tunable_scaling,
362 		.extra2		= &max_sched_tunable_scaling,
363 	},
364 	{
365 		.procname	= "sched_migration_cost_ns",
366 		.data		= &sysctl_sched_migration_cost,
367 		.maxlen		= sizeof(unsigned int),
368 		.mode		= 0644,
369 		.proc_handler	= proc_dointvec,
370 	},
371 	{
372 		.procname	= "sched_nr_migrate",
373 		.data		= &sysctl_sched_nr_migrate,
374 		.maxlen		= sizeof(unsigned int),
375 		.mode		= 0644,
376 		.proc_handler	= proc_dointvec,
377 	},
378 #ifdef CONFIG_SCHEDSTATS
379 	{
380 		.procname	= "sched_schedstats",
381 		.data		= NULL,
382 		.maxlen		= sizeof(unsigned int),
383 		.mode		= 0644,
384 		.proc_handler	= sysctl_schedstats,
385 		.extra1		= SYSCTL_ZERO,
386 		.extra2		= SYSCTL_ONE,
387 	},
388 #endif /* CONFIG_SCHEDSTATS */
389 #endif /* CONFIG_SMP */
390 #ifdef CONFIG_NUMA_BALANCING
391 	{
392 		.procname	= "numa_balancing_scan_delay_ms",
393 		.data		= &sysctl_numa_balancing_scan_delay,
394 		.maxlen		= sizeof(unsigned int),
395 		.mode		= 0644,
396 		.proc_handler	= proc_dointvec,
397 	},
398 	{
399 		.procname	= "numa_balancing_scan_period_min_ms",
400 		.data		= &sysctl_numa_balancing_scan_period_min,
401 		.maxlen		= sizeof(unsigned int),
402 		.mode		= 0644,
403 		.proc_handler	= proc_dointvec,
404 	},
405 	{
406 		.procname	= "numa_balancing_scan_period_max_ms",
407 		.data		= &sysctl_numa_balancing_scan_period_max,
408 		.maxlen		= sizeof(unsigned int),
409 		.mode		= 0644,
410 		.proc_handler	= proc_dointvec,
411 	},
412 	{
413 		.procname	= "numa_balancing_scan_size_mb",
414 		.data		= &sysctl_numa_balancing_scan_size,
415 		.maxlen		= sizeof(unsigned int),
416 		.mode		= 0644,
417 		.proc_handler	= proc_dointvec_minmax,
418 		.extra1		= SYSCTL_ONE,
419 	},
420 	{
421 		.procname	= "numa_balancing",
422 		.data		= NULL, /* filled in by handler */
423 		.maxlen		= sizeof(unsigned int),
424 		.mode		= 0644,
425 		.proc_handler	= sysctl_numa_balancing,
426 		.extra1		= SYSCTL_ZERO,
427 		.extra2		= SYSCTL_ONE,
428 	},
429 #endif /* CONFIG_NUMA_BALANCING */
430 #endif /* CONFIG_SCHED_DEBUG */
431 	{
432 		.procname	= "sched_rt_period_us",
433 		.data		= &sysctl_sched_rt_period,
434 		.maxlen		= sizeof(unsigned int),
435 		.mode		= 0644,
436 		.proc_handler	= sched_rt_handler,
437 	},
438 	{
439 		.procname	= "sched_rt_runtime_us",
440 		.data		= &sysctl_sched_rt_runtime,
441 		.maxlen		= sizeof(int),
442 		.mode		= 0644,
443 		.proc_handler	= sched_rt_handler,
444 	},
445 	{
446 		.procname	= "sched_rr_timeslice_ms",
447 		.data		= &sysctl_sched_rr_timeslice,
448 		.maxlen		= sizeof(int),
449 		.mode		= 0644,
450 		.proc_handler	= sched_rr_handler,
451 	},
452 #ifdef CONFIG_UCLAMP_TASK
453 	{
454 		.procname	= "sched_util_clamp_min",
455 		.data		= &sysctl_sched_uclamp_util_min,
456 		.maxlen		= sizeof(unsigned int),
457 		.mode		= 0644,
458 		.proc_handler	= sysctl_sched_uclamp_handler,
459 	},
460 	{
461 		.procname	= "sched_util_clamp_max",
462 		.data		= &sysctl_sched_uclamp_util_max,
463 		.maxlen		= sizeof(unsigned int),
464 		.mode		= 0644,
465 		.proc_handler	= sysctl_sched_uclamp_handler,
466 	},
467 #endif
468 #ifdef CONFIG_SCHED_AUTOGROUP
469 	{
470 		.procname	= "sched_autogroup_enabled",
471 		.data		= &sysctl_sched_autogroup_enabled,
472 		.maxlen		= sizeof(unsigned int),
473 		.mode		= 0644,
474 		.proc_handler	= proc_dointvec_minmax,
475 		.extra1		= SYSCTL_ZERO,
476 		.extra2		= SYSCTL_ONE,
477 	},
478 #endif
479 #ifdef CONFIG_CFS_BANDWIDTH
480 	{
481 		.procname	= "sched_cfs_bandwidth_slice_us",
482 		.data		= &sysctl_sched_cfs_bandwidth_slice,
483 		.maxlen		= sizeof(unsigned int),
484 		.mode		= 0644,
485 		.proc_handler	= proc_dointvec_minmax,
486 		.extra1		= SYSCTL_ONE,
487 	},
488 #endif
489 #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
490 	{
491 		.procname	= "sched_energy_aware",
492 		.data		= &sysctl_sched_energy_aware,
493 		.maxlen		= sizeof(unsigned int),
494 		.mode		= 0644,
495 		.proc_handler	= sched_energy_aware_handler,
496 		.extra1		= SYSCTL_ZERO,
497 		.extra2		= SYSCTL_ONE,
498 	},
499 #endif
500 #ifdef CONFIG_PROVE_LOCKING
501 	{
502 		.procname	= "prove_locking",
503 		.data		= &prove_locking,
504 		.maxlen		= sizeof(int),
505 		.mode		= 0644,
506 		.proc_handler	= proc_dointvec,
507 	},
508 #endif
509 #ifdef CONFIG_LOCK_STAT
510 	{
511 		.procname	= "lock_stat",
512 		.data		= &lock_stat,
513 		.maxlen		= sizeof(int),
514 		.mode		= 0644,
515 		.proc_handler	= proc_dointvec,
516 	},
517 #endif
518 	{
519 		.procname	= "panic",
520 		.data		= &panic_timeout,
521 		.maxlen		= sizeof(int),
522 		.mode		= 0644,
523 		.proc_handler	= proc_dointvec,
524 	},
525 #ifdef CONFIG_COREDUMP
526 	{
527 		.procname	= "core_uses_pid",
528 		.data		= &core_uses_pid,
529 		.maxlen		= sizeof(int),
530 		.mode		= 0644,
531 		.proc_handler	= proc_dointvec,
532 	},
533 	{
534 		.procname	= "core_pattern",
535 		.data		= core_pattern,
536 		.maxlen		= CORENAME_MAX_SIZE,
537 		.mode		= 0644,
538 		.proc_handler	= proc_dostring_coredump,
539 	},
540 	{
541 		.procname	= "core_pipe_limit",
542 		.data		= &core_pipe_limit,
543 		.maxlen		= sizeof(unsigned int),
544 		.mode		= 0644,
545 		.proc_handler	= proc_dointvec,
546 	},
547 #endif
548 #ifdef CONFIG_PROC_SYSCTL
549 	{
550 		.procname	= "tainted",
551 		.maxlen 	= sizeof(long),
552 		.mode		= 0644,
553 		.proc_handler	= proc_taint,
554 	},
555 	{
556 		.procname	= "sysctl_writes_strict",
557 		.data		= &sysctl_writes_strict,
558 		.maxlen		= sizeof(int),
559 		.mode		= 0644,
560 		.proc_handler	= proc_dointvec_minmax,
561 		.extra1		= &neg_one,
562 		.extra2		= SYSCTL_ONE,
563 	},
564 #endif
565 #ifdef CONFIG_LATENCYTOP
566 	{
567 		.procname	= "latencytop",
568 		.data		= &latencytop_enabled,
569 		.maxlen		= sizeof(int),
570 		.mode		= 0644,
571 		.proc_handler	= sysctl_latencytop,
572 	},
573 #endif
574 #ifdef CONFIG_BLK_DEV_INITRD
575 	{
576 		.procname	= "real-root-dev",
577 		.data		= &real_root_dev,
578 		.maxlen		= sizeof(int),
579 		.mode		= 0644,
580 		.proc_handler	= proc_dointvec,
581 	},
582 #endif
583 	{
584 		.procname	= "print-fatal-signals",
585 		.data		= &print_fatal_signals,
586 		.maxlen		= sizeof(int),
587 		.mode		= 0644,
588 		.proc_handler	= proc_dointvec,
589 	},
590 #ifdef CONFIG_SPARC
591 	{
592 		.procname	= "reboot-cmd",
593 		.data		= reboot_command,
594 		.maxlen		= 256,
595 		.mode		= 0644,
596 		.proc_handler	= proc_dostring,
597 	},
598 	{
599 		.procname	= "stop-a",
600 		.data		= &stop_a_enabled,
601 		.maxlen		= sizeof (int),
602 		.mode		= 0644,
603 		.proc_handler	= proc_dointvec,
604 	},
605 	{
606 		.procname	= "scons-poweroff",
607 		.data		= &scons_pwroff,
608 		.maxlen		= sizeof (int),
609 		.mode		= 0644,
610 		.proc_handler	= proc_dointvec,
611 	},
612 #endif
613 #ifdef CONFIG_SPARC64
614 	{
615 		.procname	= "tsb-ratio",
616 		.data		= &sysctl_tsb_ratio,
617 		.maxlen		= sizeof (int),
618 		.mode		= 0644,
619 		.proc_handler	= proc_dointvec,
620 	},
621 #endif
622 #ifdef __hppa__
623 	{
624 		.procname	= "soft-power",
625 		.data		= &pwrsw_enabled,
626 		.maxlen		= sizeof (int),
627 	 	.mode		= 0644,
628 		.proc_handler	= proc_dointvec,
629 	},
630 #endif
631 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
632 	{
633 		.procname	= "unaligned-trap",
634 		.data		= &unaligned_enabled,
635 		.maxlen		= sizeof (int),
636 		.mode		= 0644,
637 		.proc_handler	= proc_dointvec,
638 	},
639 #endif
640 	{
641 		.procname	= "ctrl-alt-del",
642 		.data		= &C_A_D,
643 		.maxlen		= sizeof(int),
644 		.mode		= 0644,
645 		.proc_handler	= proc_dointvec,
646 	},
647 #ifdef CONFIG_FUNCTION_TRACER
648 	{
649 		.procname	= "ftrace_enabled",
650 		.data		= &ftrace_enabled,
651 		.maxlen		= sizeof(int),
652 		.mode		= 0644,
653 		.proc_handler	= ftrace_enable_sysctl,
654 	},
655 #endif
656 #ifdef CONFIG_STACK_TRACER
657 	{
658 		.procname	= "stack_tracer_enabled",
659 		.data		= &stack_tracer_enabled,
660 		.maxlen		= sizeof(int),
661 		.mode		= 0644,
662 		.proc_handler	= stack_trace_sysctl,
663 	},
664 #endif
665 #ifdef CONFIG_TRACING
666 	{
667 		.procname	= "ftrace_dump_on_oops",
668 		.data		= &ftrace_dump_on_oops,
669 		.maxlen		= sizeof(int),
670 		.mode		= 0644,
671 		.proc_handler	= proc_dointvec,
672 	},
673 	{
674 		.procname	= "traceoff_on_warning",
675 		.data		= &__disable_trace_on_warning,
676 		.maxlen		= sizeof(__disable_trace_on_warning),
677 		.mode		= 0644,
678 		.proc_handler	= proc_dointvec,
679 	},
680 	{
681 		.procname	= "tracepoint_printk",
682 		.data		= &tracepoint_printk,
683 		.maxlen		= sizeof(tracepoint_printk),
684 		.mode		= 0644,
685 		.proc_handler	= tracepoint_printk_sysctl,
686 	},
687 #endif
688 #ifdef CONFIG_KEXEC_CORE
689 	{
690 		.procname	= "kexec_load_disabled",
691 		.data		= &kexec_load_disabled,
692 		.maxlen		= sizeof(int),
693 		.mode		= 0644,
694 		/* only handle a transition from default "0" to "1" */
695 		.proc_handler	= proc_dointvec_minmax,
696 		.extra1		= SYSCTL_ONE,
697 		.extra2		= SYSCTL_ONE,
698 	},
699 #endif
700 #ifdef CONFIG_MODULES
701 	{
702 		.procname	= "modprobe",
703 		.data		= &modprobe_path,
704 		.maxlen		= KMOD_PATH_LEN,
705 		.mode		= 0644,
706 		.proc_handler	= proc_dostring,
707 	},
708 	{
709 		.procname	= "modules_disabled",
710 		.data		= &modules_disabled,
711 		.maxlen		= sizeof(int),
712 		.mode		= 0644,
713 		/* only handle a transition from default "0" to "1" */
714 		.proc_handler	= proc_dointvec_minmax,
715 		.extra1		= SYSCTL_ONE,
716 		.extra2		= SYSCTL_ONE,
717 	},
718 #endif
719 #ifdef CONFIG_UEVENT_HELPER
720 	{
721 		.procname	= "hotplug",
722 		.data		= &uevent_helper,
723 		.maxlen		= UEVENT_HELPER_PATH_LEN,
724 		.mode		= 0644,
725 		.proc_handler	= proc_dostring,
726 	},
727 #endif
728 #ifdef CONFIG_CHR_DEV_SG
729 	{
730 		.procname	= "sg-big-buff",
731 		.data		= &sg_big_buff,
732 		.maxlen		= sizeof (int),
733 		.mode		= 0444,
734 		.proc_handler	= proc_dointvec,
735 	},
736 #endif
737 #ifdef CONFIG_BSD_PROCESS_ACCT
738 	{
739 		.procname	= "acct",
740 		.data		= &acct_parm,
741 		.maxlen		= 3*sizeof(int),
742 		.mode		= 0644,
743 		.proc_handler	= proc_dointvec,
744 	},
745 #endif
746 #ifdef CONFIG_MAGIC_SYSRQ
747 	{
748 		.procname	= "sysrq",
749 		.data		= &__sysrq_enabled,
750 		.maxlen		= sizeof (int),
751 		.mode		= 0644,
752 		.proc_handler	= sysrq_sysctl_handler,
753 	},
754 #endif
755 #ifdef CONFIG_PROC_SYSCTL
756 	{
757 		.procname	= "cad_pid",
758 		.data		= NULL,
759 		.maxlen		= sizeof (int),
760 		.mode		= 0600,
761 		.proc_handler	= proc_do_cad_pid,
762 	},
763 #endif
764 	{
765 		.procname	= "threads-max",
766 		.data		= NULL,
767 		.maxlen		= sizeof(int),
768 		.mode		= 0644,
769 		.proc_handler	= sysctl_max_threads,
770 	},
771 	{
772 		.procname	= "random",
773 		.mode		= 0555,
774 		.child		= random_table,
775 	},
776 	{
777 		.procname	= "usermodehelper",
778 		.mode		= 0555,
779 		.child		= usermodehelper_table,
780 	},
781 #ifdef CONFIG_FW_LOADER_USER_HELPER
782 	{
783 		.procname	= "firmware_config",
784 		.mode		= 0555,
785 		.child		= firmware_config_table,
786 	},
787 #endif
788 	{
789 		.procname	= "overflowuid",
790 		.data		= &overflowuid,
791 		.maxlen		= sizeof(int),
792 		.mode		= 0644,
793 		.proc_handler	= proc_dointvec_minmax,
794 		.extra1		= &minolduid,
795 		.extra2		= &maxolduid,
796 	},
797 	{
798 		.procname	= "overflowgid",
799 		.data		= &overflowgid,
800 		.maxlen		= sizeof(int),
801 		.mode		= 0644,
802 		.proc_handler	= proc_dointvec_minmax,
803 		.extra1		= &minolduid,
804 		.extra2		= &maxolduid,
805 	},
806 #ifdef CONFIG_S390
807 #ifdef CONFIG_MATHEMU
808 	{
809 		.procname	= "ieee_emulation_warnings",
810 		.data		= &sysctl_ieee_emulation_warnings,
811 		.maxlen		= sizeof(int),
812 		.mode		= 0644,
813 		.proc_handler	= proc_dointvec,
814 	},
815 #endif
816 	{
817 		.procname	= "userprocess_debug",
818 		.data		= &show_unhandled_signals,
819 		.maxlen		= sizeof(int),
820 		.mode		= 0644,
821 		.proc_handler	= proc_dointvec,
822 	},
823 #endif
824 	{
825 		.procname	= "pid_max",
826 		.data		= &pid_max,
827 		.maxlen		= sizeof (int),
828 		.mode		= 0644,
829 		.proc_handler	= proc_dointvec_minmax,
830 		.extra1		= &pid_max_min,
831 		.extra2		= &pid_max_max,
832 	},
833 	{
834 		.procname	= "panic_on_oops",
835 		.data		= &panic_on_oops,
836 		.maxlen		= sizeof(int),
837 		.mode		= 0644,
838 		.proc_handler	= proc_dointvec,
839 	},
840 	{
841 		.procname	= "panic_print",
842 		.data		= &panic_print,
843 		.maxlen		= sizeof(unsigned long),
844 		.mode		= 0644,
845 		.proc_handler	= proc_doulongvec_minmax,
846 	},
847 #if defined CONFIG_PRINTK
848 	{
849 		.procname	= "printk",
850 		.data		= &console_loglevel,
851 		.maxlen		= 4*sizeof(int),
852 		.mode		= 0644,
853 		.proc_handler	= proc_dointvec,
854 	},
855 	{
856 		.procname	= "printk_ratelimit",
857 		.data		= &printk_ratelimit_state.interval,
858 		.maxlen		= sizeof(int),
859 		.mode		= 0644,
860 		.proc_handler	= proc_dointvec_jiffies,
861 	},
862 	{
863 		.procname	= "printk_ratelimit_burst",
864 		.data		= &printk_ratelimit_state.burst,
865 		.maxlen		= sizeof(int),
866 		.mode		= 0644,
867 		.proc_handler	= proc_dointvec,
868 	},
869 	{
870 		.procname	= "printk_delay",
871 		.data		= &printk_delay_msec,
872 		.maxlen		= sizeof(int),
873 		.mode		= 0644,
874 		.proc_handler	= proc_dointvec_minmax,
875 		.extra1		= SYSCTL_ZERO,
876 		.extra2		= &ten_thousand,
877 	},
878 	{
879 		.procname	= "printk_devkmsg",
880 		.data		= devkmsg_log_str,
881 		.maxlen		= DEVKMSG_STR_MAX_SIZE,
882 		.mode		= 0644,
883 		.proc_handler	= devkmsg_sysctl_set_loglvl,
884 	},
885 	{
886 		.procname	= "dmesg_restrict",
887 		.data		= &dmesg_restrict,
888 		.maxlen		= sizeof(int),
889 		.mode		= 0644,
890 		.proc_handler	= proc_dointvec_minmax_sysadmin,
891 		.extra1		= SYSCTL_ZERO,
892 		.extra2		= SYSCTL_ONE,
893 	},
894 	{
895 		.procname	= "kptr_restrict",
896 		.data		= &kptr_restrict,
897 		.maxlen		= sizeof(int),
898 		.mode		= 0644,
899 		.proc_handler	= proc_dointvec_minmax_sysadmin,
900 		.extra1		= SYSCTL_ZERO,
901 		.extra2		= &two,
902 	},
903 #endif
904 	{
905 		.procname	= "ngroups_max",
906 		.data		= &ngroups_max,
907 		.maxlen		= sizeof (int),
908 		.mode		= 0444,
909 		.proc_handler	= proc_dointvec,
910 	},
911 	{
912 		.procname	= "cap_last_cap",
913 		.data		= (void *)&cap_last_cap,
914 		.maxlen		= sizeof(int),
915 		.mode		= 0444,
916 		.proc_handler	= proc_dointvec,
917 	},
918 #if defined(CONFIG_LOCKUP_DETECTOR)
919 	{
920 		.procname       = "watchdog",
921 		.data		= &watchdog_user_enabled,
922 		.maxlen		= sizeof(int),
923 		.mode		= 0644,
924 		.proc_handler   = proc_watchdog,
925 		.extra1		= SYSCTL_ZERO,
926 		.extra2		= SYSCTL_ONE,
927 	},
928 	{
929 		.procname	= "watchdog_thresh",
930 		.data		= &watchdog_thresh,
931 		.maxlen		= sizeof(int),
932 		.mode		= 0644,
933 		.proc_handler	= proc_watchdog_thresh,
934 		.extra1		= SYSCTL_ZERO,
935 		.extra2		= &sixty,
936 	},
937 	{
938 		.procname       = "nmi_watchdog",
939 		.data		= &nmi_watchdog_user_enabled,
940 		.maxlen		= sizeof(int),
941 		.mode		= NMI_WATCHDOG_SYSCTL_PERM,
942 		.proc_handler   = proc_nmi_watchdog,
943 		.extra1		= SYSCTL_ZERO,
944 		.extra2		= SYSCTL_ONE,
945 	},
946 	{
947 		.procname	= "watchdog_cpumask",
948 		.data		= &watchdog_cpumask_bits,
949 		.maxlen		= NR_CPUS,
950 		.mode		= 0644,
951 		.proc_handler	= proc_watchdog_cpumask,
952 	},
953 #ifdef CONFIG_SOFTLOCKUP_DETECTOR
954 	{
955 		.procname       = "soft_watchdog",
956 		.data		= &soft_watchdog_user_enabled,
957 		.maxlen		= sizeof(int),
958 		.mode		= 0644,
959 		.proc_handler   = proc_soft_watchdog,
960 		.extra1		= SYSCTL_ZERO,
961 		.extra2		= SYSCTL_ONE,
962 	},
963 	{
964 		.procname	= "softlockup_panic",
965 		.data		= &softlockup_panic,
966 		.maxlen		= sizeof(int),
967 		.mode		= 0644,
968 		.proc_handler	= proc_dointvec_minmax,
969 		.extra1		= SYSCTL_ZERO,
970 		.extra2		= SYSCTL_ONE,
971 	},
972 #ifdef CONFIG_SMP
973 	{
974 		.procname	= "softlockup_all_cpu_backtrace",
975 		.data		= &sysctl_softlockup_all_cpu_backtrace,
976 		.maxlen		= sizeof(int),
977 		.mode		= 0644,
978 		.proc_handler	= proc_dointvec_minmax,
979 		.extra1		= SYSCTL_ZERO,
980 		.extra2		= SYSCTL_ONE,
981 	},
982 #endif /* CONFIG_SMP */
983 #endif
984 #ifdef CONFIG_HARDLOCKUP_DETECTOR
985 	{
986 		.procname	= "hardlockup_panic",
987 		.data		= &hardlockup_panic,
988 		.maxlen		= sizeof(int),
989 		.mode		= 0644,
990 		.proc_handler	= proc_dointvec_minmax,
991 		.extra1		= SYSCTL_ZERO,
992 		.extra2		= SYSCTL_ONE,
993 	},
994 #ifdef CONFIG_SMP
995 	{
996 		.procname	= "hardlockup_all_cpu_backtrace",
997 		.data		= &sysctl_hardlockup_all_cpu_backtrace,
998 		.maxlen		= sizeof(int),
999 		.mode		= 0644,
1000 		.proc_handler	= proc_dointvec_minmax,
1001 		.extra1		= SYSCTL_ZERO,
1002 		.extra2		= SYSCTL_ONE,
1003 	},
1004 #endif /* CONFIG_SMP */
1005 #endif
1006 #endif
1007 
1008 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
1009 	{
1010 		.procname       = "unknown_nmi_panic",
1011 		.data           = &unknown_nmi_panic,
1012 		.maxlen         = sizeof (int),
1013 		.mode           = 0644,
1014 		.proc_handler   = proc_dointvec,
1015 	},
1016 #endif
1017 #if defined(CONFIG_X86)
1018 	{
1019 		.procname	= "panic_on_unrecovered_nmi",
1020 		.data		= &panic_on_unrecovered_nmi,
1021 		.maxlen		= sizeof(int),
1022 		.mode		= 0644,
1023 		.proc_handler	= proc_dointvec,
1024 	},
1025 	{
1026 		.procname	= "panic_on_io_nmi",
1027 		.data		= &panic_on_io_nmi,
1028 		.maxlen		= sizeof(int),
1029 		.mode		= 0644,
1030 		.proc_handler	= proc_dointvec,
1031 	},
1032 #ifdef CONFIG_DEBUG_STACKOVERFLOW
1033 	{
1034 		.procname	= "panic_on_stackoverflow",
1035 		.data		= &sysctl_panic_on_stackoverflow,
1036 		.maxlen		= sizeof(int),
1037 		.mode		= 0644,
1038 		.proc_handler	= proc_dointvec,
1039 	},
1040 #endif
1041 	{
1042 		.procname	= "bootloader_type",
1043 		.data		= &bootloader_type,
1044 		.maxlen		= sizeof (int),
1045 		.mode		= 0444,
1046 		.proc_handler	= proc_dointvec,
1047 	},
1048 	{
1049 		.procname	= "bootloader_version",
1050 		.data		= &bootloader_version,
1051 		.maxlen		= sizeof (int),
1052 		.mode		= 0444,
1053 		.proc_handler	= proc_dointvec,
1054 	},
1055 	{
1056 		.procname	= "io_delay_type",
1057 		.data		= &io_delay_type,
1058 		.maxlen		= sizeof(int),
1059 		.mode		= 0644,
1060 		.proc_handler	= proc_dointvec,
1061 	},
1062 #endif
1063 #if defined(CONFIG_MMU)
1064 	{
1065 		.procname	= "randomize_va_space",
1066 		.data		= &randomize_va_space,
1067 		.maxlen		= sizeof(int),
1068 		.mode		= 0644,
1069 		.proc_handler	= proc_dointvec,
1070 	},
1071 #endif
1072 #if defined(CONFIG_S390) && defined(CONFIG_SMP)
1073 	{
1074 		.procname	= "spin_retry",
1075 		.data		= &spin_retry,
1076 		.maxlen		= sizeof (int),
1077 		.mode		= 0644,
1078 		.proc_handler	= proc_dointvec,
1079 	},
1080 #endif
1081 #if	defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
1082 	{
1083 		.procname	= "acpi_video_flags",
1084 		.data		= &acpi_realmode_flags,
1085 		.maxlen		= sizeof (unsigned long),
1086 		.mode		= 0644,
1087 		.proc_handler	= proc_doulongvec_minmax,
1088 	},
1089 #endif
1090 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1091 	{
1092 		.procname	= "ignore-unaligned-usertrap",
1093 		.data		= &no_unaligned_warning,
1094 		.maxlen		= sizeof (int),
1095 	 	.mode		= 0644,
1096 		.proc_handler	= proc_dointvec,
1097 	},
1098 #endif
1099 #ifdef CONFIG_IA64
1100 	{
1101 		.procname	= "unaligned-dump-stack",
1102 		.data		= &unaligned_dump_stack,
1103 		.maxlen		= sizeof (int),
1104 		.mode		= 0644,
1105 		.proc_handler	= proc_dointvec,
1106 	},
1107 #endif
1108 #ifdef CONFIG_DETECT_HUNG_TASK
1109 	{
1110 		.procname	= "hung_task_panic",
1111 		.data		= &sysctl_hung_task_panic,
1112 		.maxlen		= sizeof(int),
1113 		.mode		= 0644,
1114 		.proc_handler	= proc_dointvec_minmax,
1115 		.extra1		= SYSCTL_ZERO,
1116 		.extra2		= SYSCTL_ONE,
1117 	},
1118 	{
1119 		.procname	= "hung_task_check_count",
1120 		.data		= &sysctl_hung_task_check_count,
1121 		.maxlen		= sizeof(int),
1122 		.mode		= 0644,
1123 		.proc_handler	= proc_dointvec_minmax,
1124 		.extra1		= SYSCTL_ZERO,
1125 	},
1126 	{
1127 		.procname	= "hung_task_timeout_secs",
1128 		.data		= &sysctl_hung_task_timeout_secs,
1129 		.maxlen		= sizeof(unsigned long),
1130 		.mode		= 0644,
1131 		.proc_handler	= proc_dohung_task_timeout_secs,
1132 		.extra2		= &hung_task_timeout_max,
1133 	},
1134 	{
1135 		.procname	= "hung_task_check_interval_secs",
1136 		.data		= &sysctl_hung_task_check_interval_secs,
1137 		.maxlen		= sizeof(unsigned long),
1138 		.mode		= 0644,
1139 		.proc_handler	= proc_dohung_task_timeout_secs,
1140 		.extra2		= &hung_task_timeout_max,
1141 	},
1142 	{
1143 		.procname	= "hung_task_warnings",
1144 		.data		= &sysctl_hung_task_warnings,
1145 		.maxlen		= sizeof(int),
1146 		.mode		= 0644,
1147 		.proc_handler	= proc_dointvec_minmax,
1148 		.extra1		= &neg_one,
1149 	},
1150 #endif
1151 #ifdef CONFIG_RT_MUTEXES
1152 	{
1153 		.procname	= "max_lock_depth",
1154 		.data		= &max_lock_depth,
1155 		.maxlen		= sizeof(int),
1156 		.mode		= 0644,
1157 		.proc_handler	= proc_dointvec,
1158 	},
1159 #endif
1160 	{
1161 		.procname	= "poweroff_cmd",
1162 		.data		= &poweroff_cmd,
1163 		.maxlen		= POWEROFF_CMD_PATH_LEN,
1164 		.mode		= 0644,
1165 		.proc_handler	= proc_dostring,
1166 	},
1167 #ifdef CONFIG_KEYS
1168 	{
1169 		.procname	= "keys",
1170 		.mode		= 0555,
1171 		.child		= key_sysctls,
1172 	},
1173 #endif
1174 #ifdef CONFIG_PERF_EVENTS
1175 	/*
1176 	 * User-space scripts rely on the existence of this file
1177 	 * as a feature check for perf_events being enabled.
1178 	 *
1179 	 * So it's an ABI, do not remove!
1180 	 */
1181 	{
1182 		.procname	= "perf_event_paranoid",
1183 		.data		= &sysctl_perf_event_paranoid,
1184 		.maxlen		= sizeof(sysctl_perf_event_paranoid),
1185 		.mode		= 0644,
1186 		.proc_handler	= proc_dointvec,
1187 	},
1188 	{
1189 		.procname	= "perf_event_mlock_kb",
1190 		.data		= &sysctl_perf_event_mlock,
1191 		.maxlen		= sizeof(sysctl_perf_event_mlock),
1192 		.mode		= 0644,
1193 		.proc_handler	= proc_dointvec,
1194 	},
1195 	{
1196 		.procname	= "perf_event_max_sample_rate",
1197 		.data		= &sysctl_perf_event_sample_rate,
1198 		.maxlen		= sizeof(sysctl_perf_event_sample_rate),
1199 		.mode		= 0644,
1200 		.proc_handler	= perf_proc_update_handler,
1201 		.extra1		= SYSCTL_ONE,
1202 	},
1203 	{
1204 		.procname	= "perf_cpu_time_max_percent",
1205 		.data		= &sysctl_perf_cpu_time_max_percent,
1206 		.maxlen		= sizeof(sysctl_perf_cpu_time_max_percent),
1207 		.mode		= 0644,
1208 		.proc_handler	= perf_cpu_time_max_percent_handler,
1209 		.extra1		= SYSCTL_ZERO,
1210 		.extra2		= &one_hundred,
1211 	},
1212 	{
1213 		.procname	= "perf_event_max_stack",
1214 		.data		= &sysctl_perf_event_max_stack,
1215 		.maxlen		= sizeof(sysctl_perf_event_max_stack),
1216 		.mode		= 0644,
1217 		.proc_handler	= perf_event_max_stack_handler,
1218 		.extra1		= SYSCTL_ZERO,
1219 		.extra2		= &six_hundred_forty_kb,
1220 	},
1221 	{
1222 		.procname	= "perf_event_max_contexts_per_stack",
1223 		.data		= &sysctl_perf_event_max_contexts_per_stack,
1224 		.maxlen		= sizeof(sysctl_perf_event_max_contexts_per_stack),
1225 		.mode		= 0644,
1226 		.proc_handler	= perf_event_max_stack_handler,
1227 		.extra1		= SYSCTL_ZERO,
1228 		.extra2		= &one_thousand,
1229 	},
1230 #endif
1231 	{
1232 		.procname	= "panic_on_warn",
1233 		.data		= &panic_on_warn,
1234 		.maxlen		= sizeof(int),
1235 		.mode		= 0644,
1236 		.proc_handler	= proc_dointvec_minmax,
1237 		.extra1		= SYSCTL_ZERO,
1238 		.extra2		= SYSCTL_ONE,
1239 	},
1240 #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
1241 	{
1242 		.procname	= "timer_migration",
1243 		.data		= &sysctl_timer_migration,
1244 		.maxlen		= sizeof(unsigned int),
1245 		.mode		= 0644,
1246 		.proc_handler	= timer_migration_handler,
1247 		.extra1		= SYSCTL_ZERO,
1248 		.extra2		= SYSCTL_ONE,
1249 	},
1250 #endif
1251 #ifdef CONFIG_BPF_SYSCALL
1252 	{
1253 		.procname	= "unprivileged_bpf_disabled",
1254 		.data		= &sysctl_unprivileged_bpf_disabled,
1255 		.maxlen		= sizeof(sysctl_unprivileged_bpf_disabled),
1256 		.mode		= 0644,
1257 		/* only handle a transition from default "0" to "1" */
1258 		.proc_handler	= proc_dointvec_minmax,
1259 		.extra1		= SYSCTL_ONE,
1260 		.extra2		= SYSCTL_ONE,
1261 	},
1262 	{
1263 		.procname	= "bpf_stats_enabled",
1264 		.data		= &bpf_stats_enabled_key.key,
1265 		.maxlen		= sizeof(bpf_stats_enabled_key),
1266 		.mode		= 0644,
1267 		.proc_handler	= proc_do_static_key,
1268 	},
1269 #endif
1270 #if defined(CONFIG_TREE_RCU) || defined(CONFIG_PREEMPT_RCU)
1271 	{
1272 		.procname	= "panic_on_rcu_stall",
1273 		.data		= &sysctl_panic_on_rcu_stall,
1274 		.maxlen		= sizeof(sysctl_panic_on_rcu_stall),
1275 		.mode		= 0644,
1276 		.proc_handler	= proc_dointvec_minmax,
1277 		.extra1		= SYSCTL_ZERO,
1278 		.extra2		= SYSCTL_ONE,
1279 	},
1280 #endif
1281 #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
1282 	{
1283 		.procname	= "stack_erasing",
1284 		.data		= NULL,
1285 		.maxlen		= sizeof(int),
1286 		.mode		= 0600,
1287 		.proc_handler	= stack_erasing_sysctl,
1288 		.extra1		= SYSCTL_ZERO,
1289 		.extra2		= SYSCTL_ONE,
1290 	},
1291 #endif
1292 	{ }
1293 };
1294 
1295 static struct ctl_table vm_table[] = {
1296 	{
1297 		.procname	= "overcommit_memory",
1298 		.data		= &sysctl_overcommit_memory,
1299 		.maxlen		= sizeof(sysctl_overcommit_memory),
1300 		.mode		= 0644,
1301 		.proc_handler	= proc_dointvec_minmax,
1302 		.extra1		= SYSCTL_ZERO,
1303 		.extra2		= &two,
1304 	},
1305 	{
1306 		.procname	= "panic_on_oom",
1307 		.data		= &sysctl_panic_on_oom,
1308 		.maxlen		= sizeof(sysctl_panic_on_oom),
1309 		.mode		= 0644,
1310 		.proc_handler	= proc_dointvec_minmax,
1311 		.extra1		= SYSCTL_ZERO,
1312 		.extra2		= &two,
1313 	},
1314 	{
1315 		.procname	= "oom_kill_allocating_task",
1316 		.data		= &sysctl_oom_kill_allocating_task,
1317 		.maxlen		= sizeof(sysctl_oom_kill_allocating_task),
1318 		.mode		= 0644,
1319 		.proc_handler	= proc_dointvec,
1320 	},
1321 	{
1322 		.procname	= "oom_dump_tasks",
1323 		.data		= &sysctl_oom_dump_tasks,
1324 		.maxlen		= sizeof(sysctl_oom_dump_tasks),
1325 		.mode		= 0644,
1326 		.proc_handler	= proc_dointvec,
1327 	},
1328 	{
1329 		.procname	= "overcommit_ratio",
1330 		.data		= &sysctl_overcommit_ratio,
1331 		.maxlen		= sizeof(sysctl_overcommit_ratio),
1332 		.mode		= 0644,
1333 		.proc_handler	= overcommit_ratio_handler,
1334 	},
1335 	{
1336 		.procname	= "overcommit_kbytes",
1337 		.data		= &sysctl_overcommit_kbytes,
1338 		.maxlen		= sizeof(sysctl_overcommit_kbytes),
1339 		.mode		= 0644,
1340 		.proc_handler	= overcommit_kbytes_handler,
1341 	},
1342 	{
1343 		.procname	= "page-cluster",
1344 		.data		= &page_cluster,
1345 		.maxlen		= sizeof(int),
1346 		.mode		= 0644,
1347 		.proc_handler	= proc_dointvec_minmax,
1348 		.extra1		= SYSCTL_ZERO,
1349 	},
1350 	{
1351 		.procname	= "dirty_background_ratio",
1352 		.data		= &dirty_background_ratio,
1353 		.maxlen		= sizeof(dirty_background_ratio),
1354 		.mode		= 0644,
1355 		.proc_handler	= dirty_background_ratio_handler,
1356 		.extra1		= SYSCTL_ZERO,
1357 		.extra2		= &one_hundred,
1358 	},
1359 	{
1360 		.procname	= "dirty_background_bytes",
1361 		.data		= &dirty_background_bytes,
1362 		.maxlen		= sizeof(dirty_background_bytes),
1363 		.mode		= 0644,
1364 		.proc_handler	= dirty_background_bytes_handler,
1365 		.extra1		= &one_ul,
1366 	},
1367 	{
1368 		.procname	= "dirty_ratio",
1369 		.data		= &vm_dirty_ratio,
1370 		.maxlen		= sizeof(vm_dirty_ratio),
1371 		.mode		= 0644,
1372 		.proc_handler	= dirty_ratio_handler,
1373 		.extra1		= SYSCTL_ZERO,
1374 		.extra2		= &one_hundred,
1375 	},
1376 	{
1377 		.procname	= "dirty_bytes",
1378 		.data		= &vm_dirty_bytes,
1379 		.maxlen		= sizeof(vm_dirty_bytes),
1380 		.mode		= 0644,
1381 		.proc_handler	= dirty_bytes_handler,
1382 		.extra1		= &dirty_bytes_min,
1383 	},
1384 	{
1385 		.procname	= "dirty_writeback_centisecs",
1386 		.data		= &dirty_writeback_interval,
1387 		.maxlen		= sizeof(dirty_writeback_interval),
1388 		.mode		= 0644,
1389 		.proc_handler	= dirty_writeback_centisecs_handler,
1390 	},
1391 	{
1392 		.procname	= "dirty_expire_centisecs",
1393 		.data		= &dirty_expire_interval,
1394 		.maxlen		= sizeof(dirty_expire_interval),
1395 		.mode		= 0644,
1396 		.proc_handler	= proc_dointvec_minmax,
1397 		.extra1		= SYSCTL_ZERO,
1398 	},
1399 	{
1400 		.procname	= "dirtytime_expire_seconds",
1401 		.data		= &dirtytime_expire_interval,
1402 		.maxlen		= sizeof(dirtytime_expire_interval),
1403 		.mode		= 0644,
1404 		.proc_handler	= dirtytime_interval_handler,
1405 		.extra1		= SYSCTL_ZERO,
1406 	},
1407 	{
1408 		.procname	= "swappiness",
1409 		.data		= &vm_swappiness,
1410 		.maxlen		= sizeof(vm_swappiness),
1411 		.mode		= 0644,
1412 		.proc_handler	= proc_dointvec_minmax,
1413 		.extra1		= SYSCTL_ZERO,
1414 		.extra2		= &one_hundred,
1415 	},
1416 #ifdef CONFIG_HUGETLB_PAGE
1417 	{
1418 		.procname	= "nr_hugepages",
1419 		.data		= NULL,
1420 		.maxlen		= sizeof(unsigned long),
1421 		.mode		= 0644,
1422 		.proc_handler	= hugetlb_sysctl_handler,
1423 	},
1424 #ifdef CONFIG_NUMA
1425 	{
1426 		.procname       = "nr_hugepages_mempolicy",
1427 		.data           = NULL,
1428 		.maxlen         = sizeof(unsigned long),
1429 		.mode           = 0644,
1430 		.proc_handler   = &hugetlb_mempolicy_sysctl_handler,
1431 	},
1432 	{
1433 		.procname		= "numa_stat",
1434 		.data			= &sysctl_vm_numa_stat,
1435 		.maxlen			= sizeof(int),
1436 		.mode			= 0644,
1437 		.proc_handler	= sysctl_vm_numa_stat_handler,
1438 		.extra1			= SYSCTL_ZERO,
1439 		.extra2			= SYSCTL_ONE,
1440 	},
1441 #endif
1442 	 {
1443 		.procname	= "hugetlb_shm_group",
1444 		.data		= &sysctl_hugetlb_shm_group,
1445 		.maxlen		= sizeof(gid_t),
1446 		.mode		= 0644,
1447 		.proc_handler	= proc_dointvec,
1448 	 },
1449 	{
1450 		.procname	= "nr_overcommit_hugepages",
1451 		.data		= NULL,
1452 		.maxlen		= sizeof(unsigned long),
1453 		.mode		= 0644,
1454 		.proc_handler	= hugetlb_overcommit_handler,
1455 	},
1456 #endif
1457 	{
1458 		.procname	= "lowmem_reserve_ratio",
1459 		.data		= &sysctl_lowmem_reserve_ratio,
1460 		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
1461 		.mode		= 0644,
1462 		.proc_handler	= lowmem_reserve_ratio_sysctl_handler,
1463 	},
1464 	{
1465 		.procname	= "drop_caches",
1466 		.data		= &sysctl_drop_caches,
1467 		.maxlen		= sizeof(int),
1468 		.mode		= 0644,
1469 		.proc_handler	= drop_caches_sysctl_handler,
1470 		.extra1		= SYSCTL_ONE,
1471 		.extra2		= &four,
1472 	},
1473 #ifdef CONFIG_COMPACTION
1474 	{
1475 		.procname	= "compact_memory",
1476 		.data		= &sysctl_compact_memory,
1477 		.maxlen		= sizeof(int),
1478 		.mode		= 0200,
1479 		.proc_handler	= sysctl_compaction_handler,
1480 	},
1481 	{
1482 		.procname	= "extfrag_threshold",
1483 		.data		= &sysctl_extfrag_threshold,
1484 		.maxlen		= sizeof(int),
1485 		.mode		= 0644,
1486 		.proc_handler	= proc_dointvec_minmax,
1487 		.extra1		= &min_extfrag_threshold,
1488 		.extra2		= &max_extfrag_threshold,
1489 	},
1490 	{
1491 		.procname	= "compact_unevictable_allowed",
1492 		.data		= &sysctl_compact_unevictable_allowed,
1493 		.maxlen		= sizeof(int),
1494 		.mode		= 0644,
1495 		.proc_handler	= proc_dointvec,
1496 		.extra1		= SYSCTL_ZERO,
1497 		.extra2		= SYSCTL_ONE,
1498 	},
1499 
1500 #endif /* CONFIG_COMPACTION */
1501 	{
1502 		.procname	= "min_free_kbytes",
1503 		.data		= &min_free_kbytes,
1504 		.maxlen		= sizeof(min_free_kbytes),
1505 		.mode		= 0644,
1506 		.proc_handler	= min_free_kbytes_sysctl_handler,
1507 		.extra1		= SYSCTL_ZERO,
1508 	},
1509 	{
1510 		.procname	= "watermark_boost_factor",
1511 		.data		= &watermark_boost_factor,
1512 		.maxlen		= sizeof(watermark_boost_factor),
1513 		.mode		= 0644,
1514 		.proc_handler	= watermark_boost_factor_sysctl_handler,
1515 		.extra1		= SYSCTL_ZERO,
1516 	},
1517 	{
1518 		.procname	= "watermark_scale_factor",
1519 		.data		= &watermark_scale_factor,
1520 		.maxlen		= sizeof(watermark_scale_factor),
1521 		.mode		= 0644,
1522 		.proc_handler	= watermark_scale_factor_sysctl_handler,
1523 		.extra1		= SYSCTL_ONE,
1524 		.extra2		= &one_thousand,
1525 	},
1526 	{
1527 		.procname	= "percpu_pagelist_fraction",
1528 		.data		= &percpu_pagelist_fraction,
1529 		.maxlen		= sizeof(percpu_pagelist_fraction),
1530 		.mode		= 0644,
1531 		.proc_handler	= percpu_pagelist_fraction_sysctl_handler,
1532 		.extra1		= SYSCTL_ZERO,
1533 	},
1534 #ifdef CONFIG_MMU
1535 	{
1536 		.procname	= "max_map_count",
1537 		.data		= &sysctl_max_map_count,
1538 		.maxlen		= sizeof(sysctl_max_map_count),
1539 		.mode		= 0644,
1540 		.proc_handler	= proc_dointvec_minmax,
1541 		.extra1		= SYSCTL_ZERO,
1542 	},
1543 #else
1544 	{
1545 		.procname	= "nr_trim_pages",
1546 		.data		= &sysctl_nr_trim_pages,
1547 		.maxlen		= sizeof(sysctl_nr_trim_pages),
1548 		.mode		= 0644,
1549 		.proc_handler	= proc_dointvec_minmax,
1550 		.extra1		= SYSCTL_ZERO,
1551 	},
1552 #endif
1553 	{
1554 		.procname	= "laptop_mode",
1555 		.data		= &laptop_mode,
1556 		.maxlen		= sizeof(laptop_mode),
1557 		.mode		= 0644,
1558 		.proc_handler	= proc_dointvec_jiffies,
1559 	},
1560 	{
1561 		.procname	= "block_dump",
1562 		.data		= &block_dump,
1563 		.maxlen		= sizeof(block_dump),
1564 		.mode		= 0644,
1565 		.proc_handler	= proc_dointvec,
1566 		.extra1		= SYSCTL_ZERO,
1567 	},
1568 	{
1569 		.procname	= "vfs_cache_pressure",
1570 		.data		= &sysctl_vfs_cache_pressure,
1571 		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
1572 		.mode		= 0644,
1573 		.proc_handler	= proc_dointvec,
1574 		.extra1		= SYSCTL_ZERO,
1575 	},
1576 #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1577 	{
1578 		.procname	= "legacy_va_layout",
1579 		.data		= &sysctl_legacy_va_layout,
1580 		.maxlen		= sizeof(sysctl_legacy_va_layout),
1581 		.mode		= 0644,
1582 		.proc_handler	= proc_dointvec,
1583 		.extra1		= SYSCTL_ZERO,
1584 	},
1585 #endif
1586 #ifdef CONFIG_NUMA
1587 	{
1588 		.procname	= "zone_reclaim_mode",
1589 		.data		= &node_reclaim_mode,
1590 		.maxlen		= sizeof(node_reclaim_mode),
1591 		.mode		= 0644,
1592 		.proc_handler	= proc_dointvec,
1593 		.extra1		= SYSCTL_ZERO,
1594 	},
1595 	{
1596 		.procname	= "min_unmapped_ratio",
1597 		.data		= &sysctl_min_unmapped_ratio,
1598 		.maxlen		= sizeof(sysctl_min_unmapped_ratio),
1599 		.mode		= 0644,
1600 		.proc_handler	= sysctl_min_unmapped_ratio_sysctl_handler,
1601 		.extra1		= SYSCTL_ZERO,
1602 		.extra2		= &one_hundred,
1603 	},
1604 	{
1605 		.procname	= "min_slab_ratio",
1606 		.data		= &sysctl_min_slab_ratio,
1607 		.maxlen		= sizeof(sysctl_min_slab_ratio),
1608 		.mode		= 0644,
1609 		.proc_handler	= sysctl_min_slab_ratio_sysctl_handler,
1610 		.extra1		= SYSCTL_ZERO,
1611 		.extra2		= &one_hundred,
1612 	},
1613 #endif
1614 #ifdef CONFIG_SMP
1615 	{
1616 		.procname	= "stat_interval",
1617 		.data		= &sysctl_stat_interval,
1618 		.maxlen		= sizeof(sysctl_stat_interval),
1619 		.mode		= 0644,
1620 		.proc_handler	= proc_dointvec_jiffies,
1621 	},
1622 	{
1623 		.procname	= "stat_refresh",
1624 		.data		= NULL,
1625 		.maxlen		= 0,
1626 		.mode		= 0600,
1627 		.proc_handler	= vmstat_refresh,
1628 	},
1629 #endif
1630 #ifdef CONFIG_MMU
1631 	{
1632 		.procname	= "mmap_min_addr",
1633 		.data		= &dac_mmap_min_addr,
1634 		.maxlen		= sizeof(unsigned long),
1635 		.mode		= 0644,
1636 		.proc_handler	= mmap_min_addr_handler,
1637 	},
1638 #endif
1639 #ifdef CONFIG_NUMA
1640 	{
1641 		.procname	= "numa_zonelist_order",
1642 		.data		= &numa_zonelist_order,
1643 		.maxlen		= NUMA_ZONELIST_ORDER_LEN,
1644 		.mode		= 0644,
1645 		.proc_handler	= numa_zonelist_order_handler,
1646 	},
1647 #endif
1648 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
1649    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
1650 	{
1651 		.procname	= "vdso_enabled",
1652 #ifdef CONFIG_X86_32
1653 		.data		= &vdso32_enabled,
1654 		.maxlen		= sizeof(vdso32_enabled),
1655 #else
1656 		.data		= &vdso_enabled,
1657 		.maxlen		= sizeof(vdso_enabled),
1658 #endif
1659 		.mode		= 0644,
1660 		.proc_handler	= proc_dointvec,
1661 		.extra1		= SYSCTL_ZERO,
1662 	},
1663 #endif
1664 #ifdef CONFIG_HIGHMEM
1665 	{
1666 		.procname	= "highmem_is_dirtyable",
1667 		.data		= &vm_highmem_is_dirtyable,
1668 		.maxlen		= sizeof(vm_highmem_is_dirtyable),
1669 		.mode		= 0644,
1670 		.proc_handler	= proc_dointvec_minmax,
1671 		.extra1		= SYSCTL_ZERO,
1672 		.extra2		= SYSCTL_ONE,
1673 	},
1674 #endif
1675 #ifdef CONFIG_MEMORY_FAILURE
1676 	{
1677 		.procname	= "memory_failure_early_kill",
1678 		.data		= &sysctl_memory_failure_early_kill,
1679 		.maxlen		= sizeof(sysctl_memory_failure_early_kill),
1680 		.mode		= 0644,
1681 		.proc_handler	= proc_dointvec_minmax,
1682 		.extra1		= SYSCTL_ZERO,
1683 		.extra2		= SYSCTL_ONE,
1684 	},
1685 	{
1686 		.procname	= "memory_failure_recovery",
1687 		.data		= &sysctl_memory_failure_recovery,
1688 		.maxlen		= sizeof(sysctl_memory_failure_recovery),
1689 		.mode		= 0644,
1690 		.proc_handler	= proc_dointvec_minmax,
1691 		.extra1		= SYSCTL_ZERO,
1692 		.extra2		= SYSCTL_ONE,
1693 	},
1694 #endif
1695 	{
1696 		.procname	= "user_reserve_kbytes",
1697 		.data		= &sysctl_user_reserve_kbytes,
1698 		.maxlen		= sizeof(sysctl_user_reserve_kbytes),
1699 		.mode		= 0644,
1700 		.proc_handler	= proc_doulongvec_minmax,
1701 	},
1702 	{
1703 		.procname	= "admin_reserve_kbytes",
1704 		.data		= &sysctl_admin_reserve_kbytes,
1705 		.maxlen		= sizeof(sysctl_admin_reserve_kbytes),
1706 		.mode		= 0644,
1707 		.proc_handler	= proc_doulongvec_minmax,
1708 	},
1709 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
1710 	{
1711 		.procname	= "mmap_rnd_bits",
1712 		.data		= &mmap_rnd_bits,
1713 		.maxlen		= sizeof(mmap_rnd_bits),
1714 		.mode		= 0600,
1715 		.proc_handler	= proc_dointvec_minmax,
1716 		.extra1		= (void *)&mmap_rnd_bits_min,
1717 		.extra2		= (void *)&mmap_rnd_bits_max,
1718 	},
1719 #endif
1720 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
1721 	{
1722 		.procname	= "mmap_rnd_compat_bits",
1723 		.data		= &mmap_rnd_compat_bits,
1724 		.maxlen		= sizeof(mmap_rnd_compat_bits),
1725 		.mode		= 0600,
1726 		.proc_handler	= proc_dointvec_minmax,
1727 		.extra1		= (void *)&mmap_rnd_compat_bits_min,
1728 		.extra2		= (void *)&mmap_rnd_compat_bits_max,
1729 	},
1730 #endif
1731 #ifdef CONFIG_USERFAULTFD
1732 	{
1733 		.procname	= "unprivileged_userfaultfd",
1734 		.data		= &sysctl_unprivileged_userfaultfd,
1735 		.maxlen		= sizeof(sysctl_unprivileged_userfaultfd),
1736 		.mode		= 0644,
1737 		.proc_handler	= proc_dointvec_minmax,
1738 		.extra1		= SYSCTL_ZERO,
1739 		.extra2		= SYSCTL_ONE,
1740 	},
1741 #endif
1742 	{ }
1743 };
1744 
1745 static struct ctl_table fs_table[] = {
1746 	{
1747 		.procname	= "inode-nr",
1748 		.data		= &inodes_stat,
1749 		.maxlen		= 2*sizeof(long),
1750 		.mode		= 0444,
1751 		.proc_handler	= proc_nr_inodes,
1752 	},
1753 	{
1754 		.procname	= "inode-state",
1755 		.data		= &inodes_stat,
1756 		.maxlen		= 7*sizeof(long),
1757 		.mode		= 0444,
1758 		.proc_handler	= proc_nr_inodes,
1759 	},
1760 	{
1761 		.procname	= "file-nr",
1762 		.data		= &files_stat,
1763 		.maxlen		= sizeof(files_stat),
1764 		.mode		= 0444,
1765 		.proc_handler	= proc_nr_files,
1766 	},
1767 	{
1768 		.procname	= "file-max",
1769 		.data		= &files_stat.max_files,
1770 		.maxlen		= sizeof(files_stat.max_files),
1771 		.mode		= 0644,
1772 		.proc_handler	= proc_doulongvec_minmax,
1773 		.extra1		= &zero_ul,
1774 		.extra2		= &long_max,
1775 	},
1776 	{
1777 		.procname	= "nr_open",
1778 		.data		= &sysctl_nr_open,
1779 		.maxlen		= sizeof(unsigned int),
1780 		.mode		= 0644,
1781 		.proc_handler	= proc_dointvec_minmax,
1782 		.extra1		= &sysctl_nr_open_min,
1783 		.extra2		= &sysctl_nr_open_max,
1784 	},
1785 	{
1786 		.procname	= "dentry-state",
1787 		.data		= &dentry_stat,
1788 		.maxlen		= 6*sizeof(long),
1789 		.mode		= 0444,
1790 		.proc_handler	= proc_nr_dentry,
1791 	},
1792 	{
1793 		.procname	= "overflowuid",
1794 		.data		= &fs_overflowuid,
1795 		.maxlen		= sizeof(int),
1796 		.mode		= 0644,
1797 		.proc_handler	= proc_dointvec_minmax,
1798 		.extra1		= &minolduid,
1799 		.extra2		= &maxolduid,
1800 	},
1801 	{
1802 		.procname	= "overflowgid",
1803 		.data		= &fs_overflowgid,
1804 		.maxlen		= sizeof(int),
1805 		.mode		= 0644,
1806 		.proc_handler	= proc_dointvec_minmax,
1807 		.extra1		= &minolduid,
1808 		.extra2		= &maxolduid,
1809 	},
1810 #ifdef CONFIG_FILE_LOCKING
1811 	{
1812 		.procname	= "leases-enable",
1813 		.data		= &leases_enable,
1814 		.maxlen		= sizeof(int),
1815 		.mode		= 0644,
1816 		.proc_handler	= proc_dointvec,
1817 	},
1818 #endif
1819 #ifdef CONFIG_DNOTIFY
1820 	{
1821 		.procname	= "dir-notify-enable",
1822 		.data		= &dir_notify_enable,
1823 		.maxlen		= sizeof(int),
1824 		.mode		= 0644,
1825 		.proc_handler	= proc_dointvec,
1826 	},
1827 #endif
1828 #ifdef CONFIG_MMU
1829 #ifdef CONFIG_FILE_LOCKING
1830 	{
1831 		.procname	= "lease-break-time",
1832 		.data		= &lease_break_time,
1833 		.maxlen		= sizeof(int),
1834 		.mode		= 0644,
1835 		.proc_handler	= proc_dointvec,
1836 	},
1837 #endif
1838 #ifdef CONFIG_AIO
1839 	{
1840 		.procname	= "aio-nr",
1841 		.data		= &aio_nr,
1842 		.maxlen		= sizeof(aio_nr),
1843 		.mode		= 0444,
1844 		.proc_handler	= proc_doulongvec_minmax,
1845 	},
1846 	{
1847 		.procname	= "aio-max-nr",
1848 		.data		= &aio_max_nr,
1849 		.maxlen		= sizeof(aio_max_nr),
1850 		.mode		= 0644,
1851 		.proc_handler	= proc_doulongvec_minmax,
1852 	},
1853 #endif /* CONFIG_AIO */
1854 #ifdef CONFIG_INOTIFY_USER
1855 	{
1856 		.procname	= "inotify",
1857 		.mode		= 0555,
1858 		.child		= inotify_table,
1859 	},
1860 #endif
1861 #ifdef CONFIG_EPOLL
1862 	{
1863 		.procname	= "epoll",
1864 		.mode		= 0555,
1865 		.child		= epoll_table,
1866 	},
1867 #endif
1868 #endif
1869 	{
1870 		.procname	= "protected_symlinks",
1871 		.data		= &sysctl_protected_symlinks,
1872 		.maxlen		= sizeof(int),
1873 		.mode		= 0600,
1874 		.proc_handler	= proc_dointvec_minmax,
1875 		.extra1		= SYSCTL_ZERO,
1876 		.extra2		= SYSCTL_ONE,
1877 	},
1878 	{
1879 		.procname	= "protected_hardlinks",
1880 		.data		= &sysctl_protected_hardlinks,
1881 		.maxlen		= sizeof(int),
1882 		.mode		= 0600,
1883 		.proc_handler	= proc_dointvec_minmax,
1884 		.extra1		= SYSCTL_ZERO,
1885 		.extra2		= SYSCTL_ONE,
1886 	},
1887 	{
1888 		.procname	= "protected_fifos",
1889 		.data		= &sysctl_protected_fifos,
1890 		.maxlen		= sizeof(int),
1891 		.mode		= 0600,
1892 		.proc_handler	= proc_dointvec_minmax,
1893 		.extra1		= SYSCTL_ZERO,
1894 		.extra2		= &two,
1895 	},
1896 	{
1897 		.procname	= "protected_regular",
1898 		.data		= &sysctl_protected_regular,
1899 		.maxlen		= sizeof(int),
1900 		.mode		= 0600,
1901 		.proc_handler	= proc_dointvec_minmax,
1902 		.extra1		= SYSCTL_ZERO,
1903 		.extra2		= &two,
1904 	},
1905 	{
1906 		.procname	= "suid_dumpable",
1907 		.data		= &suid_dumpable,
1908 		.maxlen		= sizeof(int),
1909 		.mode		= 0644,
1910 		.proc_handler	= proc_dointvec_minmax_coredump,
1911 		.extra1		= SYSCTL_ZERO,
1912 		.extra2		= &two,
1913 	},
1914 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1915 	{
1916 		.procname	= "binfmt_misc",
1917 		.mode		= 0555,
1918 		.child		= sysctl_mount_point,
1919 	},
1920 #endif
1921 	{
1922 		.procname	= "pipe-max-size",
1923 		.data		= &pipe_max_size,
1924 		.maxlen		= sizeof(pipe_max_size),
1925 		.mode		= 0644,
1926 		.proc_handler	= proc_dopipe_max_size,
1927 	},
1928 	{
1929 		.procname	= "pipe-user-pages-hard",
1930 		.data		= &pipe_user_pages_hard,
1931 		.maxlen		= sizeof(pipe_user_pages_hard),
1932 		.mode		= 0644,
1933 		.proc_handler	= proc_doulongvec_minmax,
1934 	},
1935 	{
1936 		.procname	= "pipe-user-pages-soft",
1937 		.data		= &pipe_user_pages_soft,
1938 		.maxlen		= sizeof(pipe_user_pages_soft),
1939 		.mode		= 0644,
1940 		.proc_handler	= proc_doulongvec_minmax,
1941 	},
1942 	{
1943 		.procname	= "mount-max",
1944 		.data		= &sysctl_mount_max,
1945 		.maxlen		= sizeof(unsigned int),
1946 		.mode		= 0644,
1947 		.proc_handler	= proc_dointvec_minmax,
1948 		.extra1		= SYSCTL_ONE,
1949 	},
1950 	{ }
1951 };
1952 
1953 static struct ctl_table debug_table[] = {
1954 #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
1955 	{
1956 		.procname	= "exception-trace",
1957 		.data		= &show_unhandled_signals,
1958 		.maxlen		= sizeof(int),
1959 		.mode		= 0644,
1960 		.proc_handler	= proc_dointvec
1961 	},
1962 #endif
1963 #if defined(CONFIG_OPTPROBES)
1964 	{
1965 		.procname	= "kprobes-optimization",
1966 		.data		= &sysctl_kprobes_optimization,
1967 		.maxlen		= sizeof(int),
1968 		.mode		= 0644,
1969 		.proc_handler	= proc_kprobes_optimization_handler,
1970 		.extra1		= SYSCTL_ZERO,
1971 		.extra2		= SYSCTL_ONE,
1972 	},
1973 #endif
1974 	{ }
1975 };
1976 
1977 static struct ctl_table dev_table[] = {
1978 	{ }
1979 };
1980 
1981 int __init sysctl_init(void)
1982 {
1983 	struct ctl_table_header *hdr;
1984 
1985 	hdr = register_sysctl_table(sysctl_base_table);
1986 	kmemleak_not_leak(hdr);
1987 	return 0;
1988 }
1989 
1990 #endif /* CONFIG_SYSCTL */
1991 
1992 /*
1993  * /proc/sys support
1994  */
1995 
1996 #ifdef CONFIG_PROC_SYSCTL
1997 
1998 static int _proc_do_string(char *data, int maxlen, int write,
1999 			   char __user *buffer,
2000 			   size_t *lenp, loff_t *ppos)
2001 {
2002 	size_t len;
2003 	char __user *p;
2004 	char c;
2005 
2006 	if (!data || !maxlen || !*lenp) {
2007 		*lenp = 0;
2008 		return 0;
2009 	}
2010 
2011 	if (write) {
2012 		if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
2013 			/* Only continue writes not past the end of buffer. */
2014 			len = strlen(data);
2015 			if (len > maxlen - 1)
2016 				len = maxlen - 1;
2017 
2018 			if (*ppos > len)
2019 				return 0;
2020 			len = *ppos;
2021 		} else {
2022 			/* Start writing from beginning of buffer. */
2023 			len = 0;
2024 		}
2025 
2026 		*ppos += *lenp;
2027 		p = buffer;
2028 		while ((p - buffer) < *lenp && len < maxlen - 1) {
2029 			if (get_user(c, p++))
2030 				return -EFAULT;
2031 			if (c == 0 || c == '\n')
2032 				break;
2033 			data[len++] = c;
2034 		}
2035 		data[len] = 0;
2036 	} else {
2037 		len = strlen(data);
2038 		if (len > maxlen)
2039 			len = maxlen;
2040 
2041 		if (*ppos > len) {
2042 			*lenp = 0;
2043 			return 0;
2044 		}
2045 
2046 		data += *ppos;
2047 		len  -= *ppos;
2048 
2049 		if (len > *lenp)
2050 			len = *lenp;
2051 		if (len)
2052 			if (copy_to_user(buffer, data, len))
2053 				return -EFAULT;
2054 		if (len < *lenp) {
2055 			if (put_user('\n', buffer + len))
2056 				return -EFAULT;
2057 			len++;
2058 		}
2059 		*lenp = len;
2060 		*ppos += len;
2061 	}
2062 	return 0;
2063 }
2064 
2065 static void warn_sysctl_write(struct ctl_table *table)
2066 {
2067 	pr_warn_once("%s wrote to %s when file position was not 0!\n"
2068 		"This will not be supported in the future. To silence this\n"
2069 		"warning, set kernel.sysctl_writes_strict = -1\n",
2070 		current->comm, table->procname);
2071 }
2072 
2073 /**
2074  * proc_first_pos_non_zero_ignore - check if first position is allowed
2075  * @ppos: file position
2076  * @table: the sysctl table
2077  *
2078  * Returns true if the first position is non-zero and the sysctl_writes_strict
2079  * mode indicates this is not allowed for numeric input types. String proc
2080  * handlers can ignore the return value.
2081  */
2082 static bool proc_first_pos_non_zero_ignore(loff_t *ppos,
2083 					   struct ctl_table *table)
2084 {
2085 	if (!*ppos)
2086 		return false;
2087 
2088 	switch (sysctl_writes_strict) {
2089 	case SYSCTL_WRITES_STRICT:
2090 		return true;
2091 	case SYSCTL_WRITES_WARN:
2092 		warn_sysctl_write(table);
2093 		return false;
2094 	default:
2095 		return false;
2096 	}
2097 }
2098 
2099 /**
2100  * proc_dostring - read a string sysctl
2101  * @table: the sysctl table
2102  * @write: %TRUE if this is a write to the sysctl file
2103  * @buffer: the user buffer
2104  * @lenp: the size of the user buffer
2105  * @ppos: file position
2106  *
2107  * Reads/writes a string from/to the user buffer. If the kernel
2108  * buffer provided is not large enough to hold the string, the
2109  * string is truncated. The copied string is %NULL-terminated.
2110  * If the string is being read by the user process, it is copied
2111  * and a newline '\n' is added. It is truncated if the buffer is
2112  * not large enough.
2113  *
2114  * Returns 0 on success.
2115  */
2116 int proc_dostring(struct ctl_table *table, int write,
2117 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2118 {
2119 	if (write)
2120 		proc_first_pos_non_zero_ignore(ppos, table);
2121 
2122 	return _proc_do_string((char *)(table->data), table->maxlen, write,
2123 			       (char __user *)buffer, lenp, ppos);
2124 }
2125 
2126 static size_t proc_skip_spaces(char **buf)
2127 {
2128 	size_t ret;
2129 	char *tmp = skip_spaces(*buf);
2130 	ret = tmp - *buf;
2131 	*buf = tmp;
2132 	return ret;
2133 }
2134 
2135 static void proc_skip_char(char **buf, size_t *size, const char v)
2136 {
2137 	while (*size) {
2138 		if (**buf != v)
2139 			break;
2140 		(*size)--;
2141 		(*buf)++;
2142 	}
2143 }
2144 
2145 /**
2146  * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
2147  *                   fail on overflow
2148  *
2149  * @cp: kernel buffer containing the string to parse
2150  * @endp: pointer to store the trailing characters
2151  * @base: the base to use
2152  * @res: where the parsed integer will be stored
2153  *
2154  * In case of success 0 is returned and @res will contain the parsed integer,
2155  * @endp will hold any trailing characters.
2156  * This function will fail the parse on overflow. If there wasn't an overflow
2157  * the function will defer the decision what characters count as invalid to the
2158  * caller.
2159  */
2160 static int strtoul_lenient(const char *cp, char **endp, unsigned int base,
2161 			   unsigned long *res)
2162 {
2163 	unsigned long long result;
2164 	unsigned int rv;
2165 
2166 	cp = _parse_integer_fixup_radix(cp, &base);
2167 	rv = _parse_integer(cp, base, &result);
2168 	if ((rv & KSTRTOX_OVERFLOW) || (result != (unsigned long)result))
2169 		return -ERANGE;
2170 
2171 	cp += rv;
2172 
2173 	if (endp)
2174 		*endp = (char *)cp;
2175 
2176 	*res = (unsigned long)result;
2177 	return 0;
2178 }
2179 
2180 #define TMPBUFLEN 22
2181 /**
2182  * proc_get_long - reads an ASCII formatted integer from a user buffer
2183  *
2184  * @buf: a kernel buffer
2185  * @size: size of the kernel buffer
2186  * @val: this is where the number will be stored
2187  * @neg: set to %TRUE if number is negative
2188  * @perm_tr: a vector which contains the allowed trailers
2189  * @perm_tr_len: size of the perm_tr vector
2190  * @tr: pointer to store the trailer character
2191  *
2192  * In case of success %0 is returned and @buf and @size are updated with
2193  * the amount of bytes read. If @tr is non-NULL and a trailing
2194  * character exists (size is non-zero after returning from this
2195  * function), @tr is updated with the trailing character.
2196  */
2197 static int proc_get_long(char **buf, size_t *size,
2198 			  unsigned long *val, bool *neg,
2199 			  const char *perm_tr, unsigned perm_tr_len, char *tr)
2200 {
2201 	int len;
2202 	char *p, tmp[TMPBUFLEN];
2203 
2204 	if (!*size)
2205 		return -EINVAL;
2206 
2207 	len = *size;
2208 	if (len > TMPBUFLEN - 1)
2209 		len = TMPBUFLEN - 1;
2210 
2211 	memcpy(tmp, *buf, len);
2212 
2213 	tmp[len] = 0;
2214 	p = tmp;
2215 	if (*p == '-' && *size > 1) {
2216 		*neg = true;
2217 		p++;
2218 	} else
2219 		*neg = false;
2220 	if (!isdigit(*p))
2221 		return -EINVAL;
2222 
2223 	if (strtoul_lenient(p, &p, 0, val))
2224 		return -EINVAL;
2225 
2226 	len = p - tmp;
2227 
2228 	/* We don't know if the next char is whitespace thus we may accept
2229 	 * invalid integers (e.g. 1234...a) or two integers instead of one
2230 	 * (e.g. 123...1). So lets not allow such large numbers. */
2231 	if (len == TMPBUFLEN - 1)
2232 		return -EINVAL;
2233 
2234 	if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
2235 		return -EINVAL;
2236 
2237 	if (tr && (len < *size))
2238 		*tr = *p;
2239 
2240 	*buf += len;
2241 	*size -= len;
2242 
2243 	return 0;
2244 }
2245 
2246 /**
2247  * proc_put_long - converts an integer to a decimal ASCII formatted string
2248  *
2249  * @buf: the user buffer
2250  * @size: the size of the user buffer
2251  * @val: the integer to be converted
2252  * @neg: sign of the number, %TRUE for negative
2253  *
2254  * In case of success %0 is returned and @buf and @size are updated with
2255  * the amount of bytes written.
2256  */
2257 static int proc_put_long(void __user **buf, size_t *size, unsigned long val,
2258 			  bool neg)
2259 {
2260 	int len;
2261 	char tmp[TMPBUFLEN], *p = tmp;
2262 
2263 	sprintf(p, "%s%lu", neg ? "-" : "", val);
2264 	len = strlen(tmp);
2265 	if (len > *size)
2266 		len = *size;
2267 	if (copy_to_user(*buf, tmp, len))
2268 		return -EFAULT;
2269 	*size -= len;
2270 	*buf += len;
2271 	return 0;
2272 }
2273 #undef TMPBUFLEN
2274 
2275 static int proc_put_char(void __user **buf, size_t *size, char c)
2276 {
2277 	if (*size) {
2278 		char __user **buffer = (char __user **)buf;
2279 		if (put_user(c, *buffer))
2280 			return -EFAULT;
2281 		(*size)--, (*buffer)++;
2282 		*buf = *buffer;
2283 	}
2284 	return 0;
2285 }
2286 
2287 static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
2288 				 int *valp,
2289 				 int write, void *data)
2290 {
2291 	if (write) {
2292 		if (*negp) {
2293 			if (*lvalp > (unsigned long) INT_MAX + 1)
2294 				return -EINVAL;
2295 			*valp = -*lvalp;
2296 		} else {
2297 			if (*lvalp > (unsigned long) INT_MAX)
2298 				return -EINVAL;
2299 			*valp = *lvalp;
2300 		}
2301 	} else {
2302 		int val = *valp;
2303 		if (val < 0) {
2304 			*negp = true;
2305 			*lvalp = -(unsigned long)val;
2306 		} else {
2307 			*negp = false;
2308 			*lvalp = (unsigned long)val;
2309 		}
2310 	}
2311 	return 0;
2312 }
2313 
2314 static int do_proc_douintvec_conv(unsigned long *lvalp,
2315 				  unsigned int *valp,
2316 				  int write, void *data)
2317 {
2318 	if (write) {
2319 		if (*lvalp > UINT_MAX)
2320 			return -EINVAL;
2321 		*valp = *lvalp;
2322 	} else {
2323 		unsigned int val = *valp;
2324 		*lvalp = (unsigned long)val;
2325 	}
2326 	return 0;
2327 }
2328 
2329 static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
2330 
2331 static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
2332 		  int write, void __user *buffer,
2333 		  size_t *lenp, loff_t *ppos,
2334 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
2335 			      int write, void *data),
2336 		  void *data)
2337 {
2338 	int *i, vleft, first = 1, err = 0;
2339 	size_t left;
2340 	char *kbuf = NULL, *p;
2341 
2342 	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
2343 		*lenp = 0;
2344 		return 0;
2345 	}
2346 
2347 	i = (int *) tbl_data;
2348 	vleft = table->maxlen / sizeof(*i);
2349 	left = *lenp;
2350 
2351 	if (!conv)
2352 		conv = do_proc_dointvec_conv;
2353 
2354 	if (write) {
2355 		if (proc_first_pos_non_zero_ignore(ppos, table))
2356 			goto out;
2357 
2358 		if (left > PAGE_SIZE - 1)
2359 			left = PAGE_SIZE - 1;
2360 		p = kbuf = memdup_user_nul(buffer, left);
2361 		if (IS_ERR(kbuf))
2362 			return PTR_ERR(kbuf);
2363 	}
2364 
2365 	for (; left && vleft--; i++, first=0) {
2366 		unsigned long lval;
2367 		bool neg;
2368 
2369 		if (write) {
2370 			left -= proc_skip_spaces(&p);
2371 
2372 			if (!left)
2373 				break;
2374 			err = proc_get_long(&p, &left, &lval, &neg,
2375 					     proc_wspace_sep,
2376 					     sizeof(proc_wspace_sep), NULL);
2377 			if (err)
2378 				break;
2379 			if (conv(&neg, &lval, i, 1, data)) {
2380 				err = -EINVAL;
2381 				break;
2382 			}
2383 		} else {
2384 			if (conv(&neg, &lval, i, 0, data)) {
2385 				err = -EINVAL;
2386 				break;
2387 			}
2388 			if (!first)
2389 				err = proc_put_char(&buffer, &left, '\t');
2390 			if (err)
2391 				break;
2392 			err = proc_put_long(&buffer, &left, lval, neg);
2393 			if (err)
2394 				break;
2395 		}
2396 	}
2397 
2398 	if (!write && !first && left && !err)
2399 		err = proc_put_char(&buffer, &left, '\n');
2400 	if (write && !err && left)
2401 		left -= proc_skip_spaces(&p);
2402 	if (write) {
2403 		kfree(kbuf);
2404 		if (first)
2405 			return err ? : -EINVAL;
2406 	}
2407 	*lenp -= left;
2408 out:
2409 	*ppos += *lenp;
2410 	return err;
2411 }
2412 
2413 static int do_proc_dointvec(struct ctl_table *table, int write,
2414 		  void __user *buffer, size_t *lenp, loff_t *ppos,
2415 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
2416 			      int write, void *data),
2417 		  void *data)
2418 {
2419 	return __do_proc_dointvec(table->data, table, write,
2420 			buffer, lenp, ppos, conv, data);
2421 }
2422 
2423 static int do_proc_douintvec_w(unsigned int *tbl_data,
2424 			       struct ctl_table *table,
2425 			       void __user *buffer,
2426 			       size_t *lenp, loff_t *ppos,
2427 			       int (*conv)(unsigned long *lvalp,
2428 					   unsigned int *valp,
2429 					   int write, void *data),
2430 			       void *data)
2431 {
2432 	unsigned long lval;
2433 	int err = 0;
2434 	size_t left;
2435 	bool neg;
2436 	char *kbuf = NULL, *p;
2437 
2438 	left = *lenp;
2439 
2440 	if (proc_first_pos_non_zero_ignore(ppos, table))
2441 		goto bail_early;
2442 
2443 	if (left > PAGE_SIZE - 1)
2444 		left = PAGE_SIZE - 1;
2445 
2446 	p = kbuf = memdup_user_nul(buffer, left);
2447 	if (IS_ERR(kbuf))
2448 		return -EINVAL;
2449 
2450 	left -= proc_skip_spaces(&p);
2451 	if (!left) {
2452 		err = -EINVAL;
2453 		goto out_free;
2454 	}
2455 
2456 	err = proc_get_long(&p, &left, &lval, &neg,
2457 			     proc_wspace_sep,
2458 			     sizeof(proc_wspace_sep), NULL);
2459 	if (err || neg) {
2460 		err = -EINVAL;
2461 		goto out_free;
2462 	}
2463 
2464 	if (conv(&lval, tbl_data, 1, data)) {
2465 		err = -EINVAL;
2466 		goto out_free;
2467 	}
2468 
2469 	if (!err && left)
2470 		left -= proc_skip_spaces(&p);
2471 
2472 out_free:
2473 	kfree(kbuf);
2474 	if (err)
2475 		return -EINVAL;
2476 
2477 	return 0;
2478 
2479 	/* This is in keeping with old __do_proc_dointvec() */
2480 bail_early:
2481 	*ppos += *lenp;
2482 	return err;
2483 }
2484 
2485 static int do_proc_douintvec_r(unsigned int *tbl_data, void __user *buffer,
2486 			       size_t *lenp, loff_t *ppos,
2487 			       int (*conv)(unsigned long *lvalp,
2488 					   unsigned int *valp,
2489 					   int write, void *data),
2490 			       void *data)
2491 {
2492 	unsigned long lval;
2493 	int err = 0;
2494 	size_t left;
2495 
2496 	left = *lenp;
2497 
2498 	if (conv(&lval, tbl_data, 0, data)) {
2499 		err = -EINVAL;
2500 		goto out;
2501 	}
2502 
2503 	err = proc_put_long(&buffer, &left, lval, false);
2504 	if (err || !left)
2505 		goto out;
2506 
2507 	err = proc_put_char(&buffer, &left, '\n');
2508 
2509 out:
2510 	*lenp -= left;
2511 	*ppos += *lenp;
2512 
2513 	return err;
2514 }
2515 
2516 static int __do_proc_douintvec(void *tbl_data, struct ctl_table *table,
2517 			       int write, void __user *buffer,
2518 			       size_t *lenp, loff_t *ppos,
2519 			       int (*conv)(unsigned long *lvalp,
2520 					   unsigned int *valp,
2521 					   int write, void *data),
2522 			       void *data)
2523 {
2524 	unsigned int *i, vleft;
2525 
2526 	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
2527 		*lenp = 0;
2528 		return 0;
2529 	}
2530 
2531 	i = (unsigned int *) tbl_data;
2532 	vleft = table->maxlen / sizeof(*i);
2533 
2534 	/*
2535 	 * Arrays are not supported, keep this simple. *Do not* add
2536 	 * support for them.
2537 	 */
2538 	if (vleft != 1) {
2539 		*lenp = 0;
2540 		return -EINVAL;
2541 	}
2542 
2543 	if (!conv)
2544 		conv = do_proc_douintvec_conv;
2545 
2546 	if (write)
2547 		return do_proc_douintvec_w(i, table, buffer, lenp, ppos,
2548 					   conv, data);
2549 	return do_proc_douintvec_r(i, buffer, lenp, ppos, conv, data);
2550 }
2551 
2552 static int do_proc_douintvec(struct ctl_table *table, int write,
2553 			     void __user *buffer, size_t *lenp, loff_t *ppos,
2554 			     int (*conv)(unsigned long *lvalp,
2555 					 unsigned int *valp,
2556 					 int write, void *data),
2557 			     void *data)
2558 {
2559 	return __do_proc_douintvec(table->data, table, write,
2560 				   buffer, lenp, ppos, conv, data);
2561 }
2562 
2563 /**
2564  * proc_dointvec - read a vector of integers
2565  * @table: the sysctl table
2566  * @write: %TRUE if this is a write to the sysctl file
2567  * @buffer: the user buffer
2568  * @lenp: the size of the user buffer
2569  * @ppos: file position
2570  *
2571  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2572  * values from/to the user buffer, treated as an ASCII string.
2573  *
2574  * Returns 0 on success.
2575  */
2576 int proc_dointvec(struct ctl_table *table, int write,
2577 		     void __user *buffer, size_t *lenp, loff_t *ppos)
2578 {
2579 	return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL);
2580 }
2581 
2582 /**
2583  * proc_douintvec - read a vector of unsigned integers
2584  * @table: the sysctl table
2585  * @write: %TRUE if this is a write to the sysctl file
2586  * @buffer: the user buffer
2587  * @lenp: the size of the user buffer
2588  * @ppos: file position
2589  *
2590  * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
2591  * values from/to the user buffer, treated as an ASCII string.
2592  *
2593  * Returns 0 on success.
2594  */
2595 int proc_douintvec(struct ctl_table *table, int write,
2596 		     void __user *buffer, size_t *lenp, loff_t *ppos)
2597 {
2598 	return do_proc_douintvec(table, write, buffer, lenp, ppos,
2599 				 do_proc_douintvec_conv, NULL);
2600 }
2601 
2602 /*
2603  * Taint values can only be increased
2604  * This means we can safely use a temporary.
2605  */
2606 static int proc_taint(struct ctl_table *table, int write,
2607 			       void __user *buffer, size_t *lenp, loff_t *ppos)
2608 {
2609 	struct ctl_table t;
2610 	unsigned long tmptaint = get_taint();
2611 	int err;
2612 
2613 	if (write && !capable(CAP_SYS_ADMIN))
2614 		return -EPERM;
2615 
2616 	t = *table;
2617 	t.data = &tmptaint;
2618 	err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
2619 	if (err < 0)
2620 		return err;
2621 
2622 	if (write) {
2623 		/*
2624 		 * Poor man's atomic or. Not worth adding a primitive
2625 		 * to everyone's atomic.h for this
2626 		 */
2627 		int i;
2628 		for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
2629 			if ((tmptaint >> i) & 1)
2630 				add_taint(i, LOCKDEP_STILL_OK);
2631 		}
2632 	}
2633 
2634 	return err;
2635 }
2636 
2637 #ifdef CONFIG_PRINTK
2638 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
2639 				void __user *buffer, size_t *lenp, loff_t *ppos)
2640 {
2641 	if (write && !capable(CAP_SYS_ADMIN))
2642 		return -EPERM;
2643 
2644 	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2645 }
2646 #endif
2647 
2648 /**
2649  * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
2650  * @min: pointer to minimum allowable value
2651  * @max: pointer to maximum allowable value
2652  *
2653  * The do_proc_dointvec_minmax_conv_param structure provides the
2654  * minimum and maximum values for doing range checking for those sysctl
2655  * parameters that use the proc_dointvec_minmax() handler.
2656  */
2657 struct do_proc_dointvec_minmax_conv_param {
2658 	int *min;
2659 	int *max;
2660 };
2661 
2662 static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
2663 					int *valp,
2664 					int write, void *data)
2665 {
2666 	int tmp, ret;
2667 	struct do_proc_dointvec_minmax_conv_param *param = data;
2668 	/*
2669 	 * If writing, first do so via a temporary local int so we can
2670 	 * bounds-check it before touching *valp.
2671 	 */
2672 	int *ip = write ? &tmp : valp;
2673 
2674 	ret = do_proc_dointvec_conv(negp, lvalp, ip, write, data);
2675 	if (ret)
2676 		return ret;
2677 
2678 	if (write) {
2679 		if ((param->min && *param->min > tmp) ||
2680 		    (param->max && *param->max < tmp))
2681 			return -EINVAL;
2682 		*valp = tmp;
2683 	}
2684 
2685 	return 0;
2686 }
2687 
2688 /**
2689  * proc_dointvec_minmax - read a vector of integers with min/max values
2690  * @table: the sysctl table
2691  * @write: %TRUE if this is a write to the sysctl file
2692  * @buffer: the user buffer
2693  * @lenp: the size of the user buffer
2694  * @ppos: file position
2695  *
2696  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2697  * values from/to the user buffer, treated as an ASCII string.
2698  *
2699  * This routine will ensure the values are within the range specified by
2700  * table->extra1 (min) and table->extra2 (max).
2701  *
2702  * Returns 0 on success or -EINVAL on write when the range check fails.
2703  */
2704 int proc_dointvec_minmax(struct ctl_table *table, int write,
2705 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2706 {
2707 	struct do_proc_dointvec_minmax_conv_param param = {
2708 		.min = (int *) table->extra1,
2709 		.max = (int *) table->extra2,
2710 	};
2711 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
2712 				do_proc_dointvec_minmax_conv, &param);
2713 }
2714 
2715 /**
2716  * struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure
2717  * @min: pointer to minimum allowable value
2718  * @max: pointer to maximum allowable value
2719  *
2720  * The do_proc_douintvec_minmax_conv_param structure provides the
2721  * minimum and maximum values for doing range checking for those sysctl
2722  * parameters that use the proc_douintvec_minmax() handler.
2723  */
2724 struct do_proc_douintvec_minmax_conv_param {
2725 	unsigned int *min;
2726 	unsigned int *max;
2727 };
2728 
2729 static int do_proc_douintvec_minmax_conv(unsigned long *lvalp,
2730 					 unsigned int *valp,
2731 					 int write, void *data)
2732 {
2733 	int ret;
2734 	unsigned int tmp;
2735 	struct do_proc_douintvec_minmax_conv_param *param = data;
2736 	/* write via temporary local uint for bounds-checking */
2737 	unsigned int *up = write ? &tmp : valp;
2738 
2739 	ret = do_proc_douintvec_conv(lvalp, up, write, data);
2740 	if (ret)
2741 		return ret;
2742 
2743 	if (write) {
2744 		if ((param->min && *param->min > tmp) ||
2745 		    (param->max && *param->max < tmp))
2746 			return -ERANGE;
2747 
2748 		*valp = tmp;
2749 	}
2750 
2751 	return 0;
2752 }
2753 
2754 /**
2755  * proc_douintvec_minmax - read a vector of unsigned ints with min/max values
2756  * @table: the sysctl table
2757  * @write: %TRUE if this is a write to the sysctl file
2758  * @buffer: the user buffer
2759  * @lenp: the size of the user buffer
2760  * @ppos: file position
2761  *
2762  * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
2763  * values from/to the user buffer, treated as an ASCII string. Negative
2764  * strings are not allowed.
2765  *
2766  * This routine will ensure the values are within the range specified by
2767  * table->extra1 (min) and table->extra2 (max). There is a final sanity
2768  * check for UINT_MAX to avoid having to support wrap around uses from
2769  * userspace.
2770  *
2771  * Returns 0 on success or -ERANGE on write when the range check fails.
2772  */
2773 int proc_douintvec_minmax(struct ctl_table *table, int write,
2774 			  void __user *buffer, size_t *lenp, loff_t *ppos)
2775 {
2776 	struct do_proc_douintvec_minmax_conv_param param = {
2777 		.min = (unsigned int *) table->extra1,
2778 		.max = (unsigned int *) table->extra2,
2779 	};
2780 	return do_proc_douintvec(table, write, buffer, lenp, ppos,
2781 				 do_proc_douintvec_minmax_conv, &param);
2782 }
2783 
2784 static int do_proc_dopipe_max_size_conv(unsigned long *lvalp,
2785 					unsigned int *valp,
2786 					int write, void *data)
2787 {
2788 	if (write) {
2789 		unsigned int val;
2790 
2791 		val = round_pipe_size(*lvalp);
2792 		if (val == 0)
2793 			return -EINVAL;
2794 
2795 		*valp = val;
2796 	} else {
2797 		unsigned int val = *valp;
2798 		*lvalp = (unsigned long) val;
2799 	}
2800 
2801 	return 0;
2802 }
2803 
2804 static int proc_dopipe_max_size(struct ctl_table *table, int write,
2805 				void __user *buffer, size_t *lenp, loff_t *ppos)
2806 {
2807 	return do_proc_douintvec(table, write, buffer, lenp, ppos,
2808 				 do_proc_dopipe_max_size_conv, NULL);
2809 }
2810 
2811 static void validate_coredump_safety(void)
2812 {
2813 #ifdef CONFIG_COREDUMP
2814 	if (suid_dumpable == SUID_DUMP_ROOT &&
2815 	    core_pattern[0] != '/' && core_pattern[0] != '|') {
2816 		printk(KERN_WARNING
2817 "Unsafe core_pattern used with fs.suid_dumpable=2.\n"
2818 "Pipe handler or fully qualified core dump path required.\n"
2819 "Set kernel.core_pattern before fs.suid_dumpable.\n"
2820 		);
2821 	}
2822 #endif
2823 }
2824 
2825 static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
2826 		void __user *buffer, size_t *lenp, loff_t *ppos)
2827 {
2828 	int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2829 	if (!error)
2830 		validate_coredump_safety();
2831 	return error;
2832 }
2833 
2834 #ifdef CONFIG_COREDUMP
2835 static int proc_dostring_coredump(struct ctl_table *table, int write,
2836 		  void __user *buffer, size_t *lenp, loff_t *ppos)
2837 {
2838 	int error = proc_dostring(table, write, buffer, lenp, ppos);
2839 	if (!error)
2840 		validate_coredump_safety();
2841 	return error;
2842 }
2843 #endif
2844 
2845 static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
2846 				     void __user *buffer,
2847 				     size_t *lenp, loff_t *ppos,
2848 				     unsigned long convmul,
2849 				     unsigned long convdiv)
2850 {
2851 	unsigned long *i, *min, *max;
2852 	int vleft, first = 1, err = 0;
2853 	size_t left;
2854 	char *kbuf = NULL, *p;
2855 
2856 	if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
2857 		*lenp = 0;
2858 		return 0;
2859 	}
2860 
2861 	i = (unsigned long *) data;
2862 	min = (unsigned long *) table->extra1;
2863 	max = (unsigned long *) table->extra2;
2864 	vleft = table->maxlen / sizeof(unsigned long);
2865 	left = *lenp;
2866 
2867 	if (write) {
2868 		if (proc_first_pos_non_zero_ignore(ppos, table))
2869 			goto out;
2870 
2871 		if (left > PAGE_SIZE - 1)
2872 			left = PAGE_SIZE - 1;
2873 		p = kbuf = memdup_user_nul(buffer, left);
2874 		if (IS_ERR(kbuf))
2875 			return PTR_ERR(kbuf);
2876 	}
2877 
2878 	for (; left && vleft--; i++, first = 0) {
2879 		unsigned long val;
2880 
2881 		if (write) {
2882 			bool neg;
2883 
2884 			left -= proc_skip_spaces(&p);
2885 			if (!left)
2886 				break;
2887 
2888 			err = proc_get_long(&p, &left, &val, &neg,
2889 					     proc_wspace_sep,
2890 					     sizeof(proc_wspace_sep), NULL);
2891 			if (err)
2892 				break;
2893 			if (neg)
2894 				continue;
2895 			val = convmul * val / convdiv;
2896 			if ((min && val < *min) || (max && val > *max)) {
2897 				err = -EINVAL;
2898 				break;
2899 			}
2900 			*i = val;
2901 		} else {
2902 			val = convdiv * (*i) / convmul;
2903 			if (!first) {
2904 				err = proc_put_char(&buffer, &left, '\t');
2905 				if (err)
2906 					break;
2907 			}
2908 			err = proc_put_long(&buffer, &left, val, false);
2909 			if (err)
2910 				break;
2911 		}
2912 	}
2913 
2914 	if (!write && !first && left && !err)
2915 		err = proc_put_char(&buffer, &left, '\n');
2916 	if (write && !err)
2917 		left -= proc_skip_spaces(&p);
2918 	if (write) {
2919 		kfree(kbuf);
2920 		if (first)
2921 			return err ? : -EINVAL;
2922 	}
2923 	*lenp -= left;
2924 out:
2925 	*ppos += *lenp;
2926 	return err;
2927 }
2928 
2929 static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
2930 				     void __user *buffer,
2931 				     size_t *lenp, loff_t *ppos,
2932 				     unsigned long convmul,
2933 				     unsigned long convdiv)
2934 {
2935 	return __do_proc_doulongvec_minmax(table->data, table, write,
2936 			buffer, lenp, ppos, convmul, convdiv);
2937 }
2938 
2939 /**
2940  * proc_doulongvec_minmax - read a vector of long integers with min/max values
2941  * @table: the sysctl table
2942  * @write: %TRUE if this is a write to the sysctl file
2943  * @buffer: the user buffer
2944  * @lenp: the size of the user buffer
2945  * @ppos: file position
2946  *
2947  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2948  * values from/to the user buffer, treated as an ASCII string.
2949  *
2950  * This routine will ensure the values are within the range specified by
2951  * table->extra1 (min) and table->extra2 (max).
2952  *
2953  * Returns 0 on success.
2954  */
2955 int proc_doulongvec_minmax(struct ctl_table *table, int write,
2956 			   void __user *buffer, size_t *lenp, loff_t *ppos)
2957 {
2958     return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
2959 }
2960 
2961 /**
2962  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
2963  * @table: the sysctl table
2964  * @write: %TRUE if this is a write to the sysctl file
2965  * @buffer: the user buffer
2966  * @lenp: the size of the user buffer
2967  * @ppos: file position
2968  *
2969  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2970  * values from/to the user buffer, treated as an ASCII string. The values
2971  * are treated as milliseconds, and converted to jiffies when they are stored.
2972  *
2973  * This routine will ensure the values are within the range specified by
2974  * table->extra1 (min) and table->extra2 (max).
2975  *
2976  * Returns 0 on success.
2977  */
2978 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2979 				      void __user *buffer,
2980 				      size_t *lenp, loff_t *ppos)
2981 {
2982     return do_proc_doulongvec_minmax(table, write, buffer,
2983 				     lenp, ppos, HZ, 1000l);
2984 }
2985 
2986 
2987 static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
2988 					 int *valp,
2989 					 int write, void *data)
2990 {
2991 	if (write) {
2992 		if (*lvalp > INT_MAX / HZ)
2993 			return 1;
2994 		*valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
2995 	} else {
2996 		int val = *valp;
2997 		unsigned long lval;
2998 		if (val < 0) {
2999 			*negp = true;
3000 			lval = -(unsigned long)val;
3001 		} else {
3002 			*negp = false;
3003 			lval = (unsigned long)val;
3004 		}
3005 		*lvalp = lval / HZ;
3006 	}
3007 	return 0;
3008 }
3009 
3010 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
3011 						int *valp,
3012 						int write, void *data)
3013 {
3014 	if (write) {
3015 		if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
3016 			return 1;
3017 		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
3018 	} else {
3019 		int val = *valp;
3020 		unsigned long lval;
3021 		if (val < 0) {
3022 			*negp = true;
3023 			lval = -(unsigned long)val;
3024 		} else {
3025 			*negp = false;
3026 			lval = (unsigned long)val;
3027 		}
3028 		*lvalp = jiffies_to_clock_t(lval);
3029 	}
3030 	return 0;
3031 }
3032 
3033 static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
3034 					    int *valp,
3035 					    int write, void *data)
3036 {
3037 	if (write) {
3038 		unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
3039 
3040 		if (jif > INT_MAX)
3041 			return 1;
3042 		*valp = (int)jif;
3043 	} else {
3044 		int val = *valp;
3045 		unsigned long lval;
3046 		if (val < 0) {
3047 			*negp = true;
3048 			lval = -(unsigned long)val;
3049 		} else {
3050 			*negp = false;
3051 			lval = (unsigned long)val;
3052 		}
3053 		*lvalp = jiffies_to_msecs(lval);
3054 	}
3055 	return 0;
3056 }
3057 
3058 /**
3059  * proc_dointvec_jiffies - read a vector of integers as seconds
3060  * @table: the sysctl table
3061  * @write: %TRUE if this is a write to the sysctl file
3062  * @buffer: the user buffer
3063  * @lenp: the size of the user buffer
3064  * @ppos: file position
3065  *
3066  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
3067  * values from/to the user buffer, treated as an ASCII string.
3068  * The values read are assumed to be in seconds, and are converted into
3069  * jiffies.
3070  *
3071  * Returns 0 on success.
3072  */
3073 int proc_dointvec_jiffies(struct ctl_table *table, int write,
3074 			  void __user *buffer, size_t *lenp, loff_t *ppos)
3075 {
3076     return do_proc_dointvec(table,write,buffer,lenp,ppos,
3077 		    	    do_proc_dointvec_jiffies_conv,NULL);
3078 }
3079 
3080 /**
3081  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
3082  * @table: the sysctl table
3083  * @write: %TRUE if this is a write to the sysctl file
3084  * @buffer: the user buffer
3085  * @lenp: the size of the user buffer
3086  * @ppos: pointer to the file position
3087  *
3088  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
3089  * values from/to the user buffer, treated as an ASCII string.
3090  * The values read are assumed to be in 1/USER_HZ seconds, and
3091  * are converted into jiffies.
3092  *
3093  * Returns 0 on success.
3094  */
3095 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
3096 				 void __user *buffer, size_t *lenp, loff_t *ppos)
3097 {
3098     return do_proc_dointvec(table,write,buffer,lenp,ppos,
3099 		    	    do_proc_dointvec_userhz_jiffies_conv,NULL);
3100 }
3101 
3102 /**
3103  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
3104  * @table: the sysctl table
3105  * @write: %TRUE if this is a write to the sysctl file
3106  * @buffer: the user buffer
3107  * @lenp: the size of the user buffer
3108  * @ppos: file position
3109  * @ppos: the current position in the file
3110  *
3111  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
3112  * values from/to the user buffer, treated as an ASCII string.
3113  * The values read are assumed to be in 1/1000 seconds, and
3114  * are converted into jiffies.
3115  *
3116  * Returns 0 on success.
3117  */
3118 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
3119 			     void __user *buffer, size_t *lenp, loff_t *ppos)
3120 {
3121 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
3122 				do_proc_dointvec_ms_jiffies_conv, NULL);
3123 }
3124 
3125 static int proc_do_cad_pid(struct ctl_table *table, int write,
3126 			   void __user *buffer, size_t *lenp, loff_t *ppos)
3127 {
3128 	struct pid *new_pid;
3129 	pid_t tmp;
3130 	int r;
3131 
3132 	tmp = pid_vnr(cad_pid);
3133 
3134 	r = __do_proc_dointvec(&tmp, table, write, buffer,
3135 			       lenp, ppos, NULL, NULL);
3136 	if (r || !write)
3137 		return r;
3138 
3139 	new_pid = find_get_pid(tmp);
3140 	if (!new_pid)
3141 		return -ESRCH;
3142 
3143 	put_pid(xchg(&cad_pid, new_pid));
3144 	return 0;
3145 }
3146 
3147 /**
3148  * proc_do_large_bitmap - read/write from/to a large bitmap
3149  * @table: the sysctl table
3150  * @write: %TRUE if this is a write to the sysctl file
3151  * @buffer: the user buffer
3152  * @lenp: the size of the user buffer
3153  * @ppos: file position
3154  *
3155  * The bitmap is stored at table->data and the bitmap length (in bits)
3156  * in table->maxlen.
3157  *
3158  * We use a range comma separated format (e.g. 1,3-4,10-10) so that
3159  * large bitmaps may be represented in a compact manner. Writing into
3160  * the file will clear the bitmap then update it with the given input.
3161  *
3162  * Returns 0 on success.
3163  */
3164 int proc_do_large_bitmap(struct ctl_table *table, int write,
3165 			 void __user *buffer, size_t *lenp, loff_t *ppos)
3166 {
3167 	int err = 0;
3168 	bool first = 1;
3169 	size_t left = *lenp;
3170 	unsigned long bitmap_len = table->maxlen;
3171 	unsigned long *bitmap = *(unsigned long **) table->data;
3172 	unsigned long *tmp_bitmap = NULL;
3173 	char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
3174 
3175 	if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
3176 		*lenp = 0;
3177 		return 0;
3178 	}
3179 
3180 	if (write) {
3181 		char *kbuf, *p;
3182 		size_t skipped = 0;
3183 
3184 		if (left > PAGE_SIZE - 1) {
3185 			left = PAGE_SIZE - 1;
3186 			/* How much of the buffer we'll skip this pass */
3187 			skipped = *lenp - left;
3188 		}
3189 
3190 		p = kbuf = memdup_user_nul(buffer, left);
3191 		if (IS_ERR(kbuf))
3192 			return PTR_ERR(kbuf);
3193 
3194 		tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL);
3195 		if (!tmp_bitmap) {
3196 			kfree(kbuf);
3197 			return -ENOMEM;
3198 		}
3199 		proc_skip_char(&p, &left, '\n');
3200 		while (!err && left) {
3201 			unsigned long val_a, val_b;
3202 			bool neg;
3203 			size_t saved_left;
3204 
3205 			/* In case we stop parsing mid-number, we can reset */
3206 			saved_left = left;
3207 			err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
3208 					     sizeof(tr_a), &c);
3209 			/*
3210 			 * If we consumed the entirety of a truncated buffer or
3211 			 * only one char is left (may be a "-"), then stop here,
3212 			 * reset, & come back for more.
3213 			 */
3214 			if ((left <= 1) && skipped) {
3215 				left = saved_left;
3216 				break;
3217 			}
3218 
3219 			if (err)
3220 				break;
3221 			if (val_a >= bitmap_len || neg) {
3222 				err = -EINVAL;
3223 				break;
3224 			}
3225 
3226 			val_b = val_a;
3227 			if (left) {
3228 				p++;
3229 				left--;
3230 			}
3231 
3232 			if (c == '-') {
3233 				err = proc_get_long(&p, &left, &val_b,
3234 						     &neg, tr_b, sizeof(tr_b),
3235 						     &c);
3236 				/*
3237 				 * If we consumed all of a truncated buffer or
3238 				 * then stop here, reset, & come back for more.
3239 				 */
3240 				if (!left && skipped) {
3241 					left = saved_left;
3242 					break;
3243 				}
3244 
3245 				if (err)
3246 					break;
3247 				if (val_b >= bitmap_len || neg ||
3248 				    val_a > val_b) {
3249 					err = -EINVAL;
3250 					break;
3251 				}
3252 				if (left) {
3253 					p++;
3254 					left--;
3255 				}
3256 			}
3257 
3258 			bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
3259 			first = 0;
3260 			proc_skip_char(&p, &left, '\n');
3261 		}
3262 		kfree(kbuf);
3263 		left += skipped;
3264 	} else {
3265 		unsigned long bit_a, bit_b = 0;
3266 
3267 		while (left) {
3268 			bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
3269 			if (bit_a >= bitmap_len)
3270 				break;
3271 			bit_b = find_next_zero_bit(bitmap, bitmap_len,
3272 						   bit_a + 1) - 1;
3273 
3274 			if (!first) {
3275 				err = proc_put_char(&buffer, &left, ',');
3276 				if (err)
3277 					break;
3278 			}
3279 			err = proc_put_long(&buffer, &left, bit_a, false);
3280 			if (err)
3281 				break;
3282 			if (bit_a != bit_b) {
3283 				err = proc_put_char(&buffer, &left, '-');
3284 				if (err)
3285 					break;
3286 				err = proc_put_long(&buffer, &left, bit_b, false);
3287 				if (err)
3288 					break;
3289 			}
3290 
3291 			first = 0; bit_b++;
3292 		}
3293 		if (!err)
3294 			err = proc_put_char(&buffer, &left, '\n');
3295 	}
3296 
3297 	if (!err) {
3298 		if (write) {
3299 			if (*ppos)
3300 				bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
3301 			else
3302 				bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
3303 		}
3304 		*lenp -= left;
3305 		*ppos += *lenp;
3306 	}
3307 
3308 	bitmap_free(tmp_bitmap);
3309 	return err;
3310 }
3311 
3312 #else /* CONFIG_PROC_SYSCTL */
3313 
3314 int proc_dostring(struct ctl_table *table, int write,
3315 		  void __user *buffer, size_t *lenp, loff_t *ppos)
3316 {
3317 	return -ENOSYS;
3318 }
3319 
3320 int proc_dointvec(struct ctl_table *table, int write,
3321 		  void __user *buffer, size_t *lenp, loff_t *ppos)
3322 {
3323 	return -ENOSYS;
3324 }
3325 
3326 int proc_douintvec(struct ctl_table *table, int write,
3327 		  void __user *buffer, size_t *lenp, loff_t *ppos)
3328 {
3329 	return -ENOSYS;
3330 }
3331 
3332 int proc_dointvec_minmax(struct ctl_table *table, int write,
3333 		    void __user *buffer, size_t *lenp, loff_t *ppos)
3334 {
3335 	return -ENOSYS;
3336 }
3337 
3338 int proc_douintvec_minmax(struct ctl_table *table, int write,
3339 			  void __user *buffer, size_t *lenp, loff_t *ppos)
3340 {
3341 	return -ENOSYS;
3342 }
3343 
3344 int proc_dointvec_jiffies(struct ctl_table *table, int write,
3345 		    void __user *buffer, size_t *lenp, loff_t *ppos)
3346 {
3347 	return -ENOSYS;
3348 }
3349 
3350 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
3351 		    void __user *buffer, size_t *lenp, loff_t *ppos)
3352 {
3353 	return -ENOSYS;
3354 }
3355 
3356 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
3357 			     void __user *buffer, size_t *lenp, loff_t *ppos)
3358 {
3359 	return -ENOSYS;
3360 }
3361 
3362 int proc_doulongvec_minmax(struct ctl_table *table, int write,
3363 		    void __user *buffer, size_t *lenp, loff_t *ppos)
3364 {
3365 	return -ENOSYS;
3366 }
3367 
3368 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
3369 				      void __user *buffer,
3370 				      size_t *lenp, loff_t *ppos)
3371 {
3372     return -ENOSYS;
3373 }
3374 
3375 int proc_do_large_bitmap(struct ctl_table *table, int write,
3376 			 void __user *buffer, size_t *lenp, loff_t *ppos)
3377 {
3378 	return -ENOSYS;
3379 }
3380 
3381 #endif /* CONFIG_PROC_SYSCTL */
3382 
3383 #if defined(CONFIG_SYSCTL)
3384 int proc_do_static_key(struct ctl_table *table, int write,
3385 		       void __user *buffer, size_t *lenp,
3386 		       loff_t *ppos)
3387 {
3388 	struct static_key *key = (struct static_key *)table->data;
3389 	static DEFINE_MUTEX(static_key_mutex);
3390 	int val, ret;
3391 	struct ctl_table tmp = {
3392 		.data   = &val,
3393 		.maxlen = sizeof(val),
3394 		.mode   = table->mode,
3395 		.extra1 = SYSCTL_ZERO,
3396 		.extra2 = SYSCTL_ONE,
3397 	};
3398 
3399 	if (write && !capable(CAP_SYS_ADMIN))
3400 		return -EPERM;
3401 
3402 	mutex_lock(&static_key_mutex);
3403 	val = static_key_enabled(key);
3404 	ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
3405 	if (write && !ret) {
3406 		if (val)
3407 			static_key_enable(key);
3408 		else
3409 			static_key_disable(key);
3410 	}
3411 	mutex_unlock(&static_key_mutex);
3412 	return ret;
3413 }
3414 #endif
3415 /*
3416  * No sense putting this after each symbol definition, twice,
3417  * exception granted :-)
3418  */
3419 EXPORT_SYMBOL(proc_dointvec);
3420 EXPORT_SYMBOL(proc_douintvec);
3421 EXPORT_SYMBOL(proc_dointvec_jiffies);
3422 EXPORT_SYMBOL(proc_dointvec_minmax);
3423 EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
3424 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
3425 EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
3426 EXPORT_SYMBOL(proc_dostring);
3427 EXPORT_SYMBOL(proc_doulongvec_minmax);
3428 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
3429 EXPORT_SYMBOL(proc_do_large_bitmap);
3430