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/mm.h>
24 #include <linux/swap.h>
25 #include <linux/slab.h>
26 #include <linux/sysctl.h>
27 #include <linux/bitmap.h>
28 #include <linux/signal.h>
29 #include <linux/panic.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/filter.h>
36 #include <linux/fs.h>
37 #include <linux/init.h>
38 #include <linux/kernel.h>
39 #include <linux/kobject.h>
40 #include <linux/net.h>
41 #include <linux/sysrq.h>
42 #include <linux/highuid.h>
43 #include <linux/writeback.h>
44 #include <linux/ratelimit.h>
45 #include <linux/compaction.h>
46 #include <linux/hugetlb.h>
47 #include <linux/initrd.h>
48 #include <linux/key.h>
49 #include <linux/times.h>
50 #include <linux/limits.h>
51 #include <linux/dcache.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/oom.h>
60 #include <linux/kmod.h>
61 #include <linux/capability.h>
62 #include <linux/binfmts.h>
63 #include <linux/sched/sysctl.h>
64 #include <linux/mount.h>
65 #include <linux/userfaultfd_k.h>
66 #include <linux/pid.h>
67 
68 #include "../lib/kstrtox.h"
69 
70 #include <linux/uaccess.h>
71 #include <asm/processor.h>
72 
73 #ifdef CONFIG_X86
74 #include <asm/nmi.h>
75 #include <asm/stacktrace.h>
76 #include <asm/io.h>
77 #endif
78 #ifdef CONFIG_SPARC
79 #include <asm/setup.h>
80 #endif
81 #ifdef CONFIG_RT_MUTEXES
82 #include <linux/rtmutex.h>
83 #endif
84 
85 /* shared constants to be used in various sysctls */
86 const int sysctl_vals[] = { 0, 1, 2, 3, 4, 100, 200, 1000, 3000, INT_MAX, 65535, -1 };
87 EXPORT_SYMBOL(sysctl_vals);
88 
89 const unsigned long sysctl_long_vals[] = { 0, 1, LONG_MAX };
90 EXPORT_SYMBOL_GPL(sysctl_long_vals);
91 
92 #if defined(CONFIG_SYSCTL)
93 
94 /* Constants used for minimum and maximum */
95 
96 #ifdef CONFIG_PERF_EVENTS
97 static const int six_hundred_forty_kb = 640 * 1024;
98 #endif
99 
100 
101 static const int ngroups_max = NGROUPS_MAX;
102 static const int cap_last_cap = CAP_LAST_CAP;
103 
104 #ifdef CONFIG_PROC_SYSCTL
105 
106 /**
107  * enum sysctl_writes_mode - supported sysctl write modes
108  *
109  * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
110  *	to be written, and multiple writes on the same sysctl file descriptor
111  *	will rewrite the sysctl value, regardless of file position. No warning
112  *	is issued when the initial position is not 0.
113  * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
114  *	not 0.
115  * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
116  *	file position 0 and the value must be fully contained in the buffer
117  *	sent to the write syscall. If dealing with strings respect the file
118  *	position, but restrict this to the max length of the buffer, anything
119  *	passed the max length will be ignored. Multiple writes will append
120  *	to the buffer.
121  *
122  * These write modes control how current file position affects the behavior of
123  * updating sysctl values through the proc interface on each write.
124  */
125 enum sysctl_writes_mode {
126 	SYSCTL_WRITES_LEGACY		= -1,
127 	SYSCTL_WRITES_WARN		= 0,
128 	SYSCTL_WRITES_STRICT		= 1,
129 };
130 
131 static enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT;
132 #endif /* CONFIG_PROC_SYSCTL */
133 
134 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
135     defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
136 int sysctl_legacy_va_layout;
137 #endif
138 
139 #endif /* CONFIG_SYSCTL */
140 
141 /*
142  * /proc/sys support
143  */
144 
145 #ifdef CONFIG_PROC_SYSCTL
146 
_proc_do_string(char * data,int maxlen,int write,char * buffer,size_t * lenp,loff_t * ppos)147 static int _proc_do_string(char *data, int maxlen, int write,
148 		char *buffer, size_t *lenp, loff_t *ppos)
149 {
150 	size_t len;
151 	char c, *p;
152 
153 	if (!data || !maxlen || !*lenp) {
154 		*lenp = 0;
155 		return 0;
156 	}
157 
158 	if (write) {
159 		if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
160 			/* Only continue writes not past the end of buffer. */
161 			len = strlen(data);
162 			if (len > maxlen - 1)
163 				len = maxlen - 1;
164 
165 			if (*ppos > len)
166 				return 0;
167 			len = *ppos;
168 		} else {
169 			/* Start writing from beginning of buffer. */
170 			len = 0;
171 		}
172 
173 		*ppos += *lenp;
174 		p = buffer;
175 		while ((p - buffer) < *lenp && len < maxlen - 1) {
176 			c = *(p++);
177 			if (c == 0 || c == '\n')
178 				break;
179 			data[len++] = c;
180 		}
181 		data[len] = 0;
182 	} else {
183 		len = strlen(data);
184 		if (len > maxlen)
185 			len = maxlen;
186 
187 		if (*ppos > len) {
188 			*lenp = 0;
189 			return 0;
190 		}
191 
192 		data += *ppos;
193 		len  -= *ppos;
194 
195 		if (len > *lenp)
196 			len = *lenp;
197 		if (len)
198 			memcpy(buffer, data, len);
199 		if (len < *lenp) {
200 			buffer[len] = '\n';
201 			len++;
202 		}
203 		*lenp = len;
204 		*ppos += len;
205 	}
206 	return 0;
207 }
208 
warn_sysctl_write(struct ctl_table * table)209 static void warn_sysctl_write(struct ctl_table *table)
210 {
211 	pr_warn_once("%s wrote to %s when file position was not 0!\n"
212 		"This will not be supported in the future. To silence this\n"
213 		"warning, set kernel.sysctl_writes_strict = -1\n",
214 		current->comm, table->procname);
215 }
216 
217 /**
218  * proc_first_pos_non_zero_ignore - check if first position is allowed
219  * @ppos: file position
220  * @table: the sysctl table
221  *
222  * Returns true if the first position is non-zero and the sysctl_writes_strict
223  * mode indicates this is not allowed for numeric input types. String proc
224  * handlers can ignore the return value.
225  */
proc_first_pos_non_zero_ignore(loff_t * ppos,struct ctl_table * table)226 static bool proc_first_pos_non_zero_ignore(loff_t *ppos,
227 					   struct ctl_table *table)
228 {
229 	if (!*ppos)
230 		return false;
231 
232 	switch (sysctl_writes_strict) {
233 	case SYSCTL_WRITES_STRICT:
234 		return true;
235 	case SYSCTL_WRITES_WARN:
236 		warn_sysctl_write(table);
237 		return false;
238 	default:
239 		return false;
240 	}
241 }
242 
243 /**
244  * proc_dostring - read a string sysctl
245  * @table: the sysctl table
246  * @write: %TRUE if this is a write to the sysctl file
247  * @buffer: the user buffer
248  * @lenp: the size of the user buffer
249  * @ppos: file position
250  *
251  * Reads/writes a string from/to the user buffer. If the kernel
252  * buffer provided is not large enough to hold the string, the
253  * string is truncated. The copied string is %NULL-terminated.
254  * If the string is being read by the user process, it is copied
255  * and a newline '\n' is added. It is truncated if the buffer is
256  * not large enough.
257  *
258  * Returns 0 on success.
259  */
proc_dostring(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)260 int proc_dostring(struct ctl_table *table, int write,
261 		  void *buffer, size_t *lenp, loff_t *ppos)
262 {
263 	if (write)
264 		proc_first_pos_non_zero_ignore(ppos, table);
265 
266 	return _proc_do_string(table->data, table->maxlen, write, buffer, lenp,
267 			ppos);
268 }
269 
proc_skip_spaces(char ** buf,size_t * size)270 static void proc_skip_spaces(char **buf, size_t *size)
271 {
272 	while (*size) {
273 		if (!isspace(**buf))
274 			break;
275 		(*size)--;
276 		(*buf)++;
277 	}
278 }
279 
proc_skip_char(char ** buf,size_t * size,const char v)280 static void proc_skip_char(char **buf, size_t *size, const char v)
281 {
282 	while (*size) {
283 		if (**buf != v)
284 			break;
285 		(*size)--;
286 		(*buf)++;
287 	}
288 }
289 
290 /**
291  * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
292  *                   fail on overflow
293  *
294  * @cp: kernel buffer containing the string to parse
295  * @endp: pointer to store the trailing characters
296  * @base: the base to use
297  * @res: where the parsed integer will be stored
298  *
299  * In case of success 0 is returned and @res will contain the parsed integer,
300  * @endp will hold any trailing characters.
301  * This function will fail the parse on overflow. If there wasn't an overflow
302  * the function will defer the decision what characters count as invalid to the
303  * caller.
304  */
strtoul_lenient(const char * cp,char ** endp,unsigned int base,unsigned long * res)305 static int strtoul_lenient(const char *cp, char **endp, unsigned int base,
306 			   unsigned long *res)
307 {
308 	unsigned long long result;
309 	unsigned int rv;
310 
311 	cp = _parse_integer_fixup_radix(cp, &base);
312 	rv = _parse_integer(cp, base, &result);
313 	if ((rv & KSTRTOX_OVERFLOW) || (result != (unsigned long)result))
314 		return -ERANGE;
315 
316 	cp += rv;
317 
318 	if (endp)
319 		*endp = (char *)cp;
320 
321 	*res = (unsigned long)result;
322 	return 0;
323 }
324 
325 #define TMPBUFLEN 22
326 /**
327  * proc_get_long - reads an ASCII formatted integer from a user buffer
328  *
329  * @buf: a kernel buffer
330  * @size: size of the kernel buffer
331  * @val: this is where the number will be stored
332  * @neg: set to %TRUE if number is negative
333  * @perm_tr: a vector which contains the allowed trailers
334  * @perm_tr_len: size of the perm_tr vector
335  * @tr: pointer to store the trailer character
336  *
337  * In case of success %0 is returned and @buf and @size are updated with
338  * the amount of bytes read. If @tr is non-NULL and a trailing
339  * character exists (size is non-zero after returning from this
340  * function), @tr is updated with the trailing character.
341  */
proc_get_long(char ** buf,size_t * size,unsigned long * val,bool * neg,const char * perm_tr,unsigned perm_tr_len,char * tr)342 static int proc_get_long(char **buf, size_t *size,
343 			  unsigned long *val, bool *neg,
344 			  const char *perm_tr, unsigned perm_tr_len, char *tr)
345 {
346 	char *p, tmp[TMPBUFLEN];
347 	ssize_t len = *size;
348 
349 	if (len <= 0)
350 		return -EINVAL;
351 
352 	if (len > TMPBUFLEN - 1)
353 		len = TMPBUFLEN - 1;
354 
355 	memcpy(tmp, *buf, len);
356 
357 	tmp[len] = 0;
358 	p = tmp;
359 	if (*p == '-' && *size > 1) {
360 		*neg = true;
361 		p++;
362 	} else
363 		*neg = false;
364 	if (!isdigit(*p))
365 		return -EINVAL;
366 
367 	if (strtoul_lenient(p, &p, 0, val))
368 		return -EINVAL;
369 
370 	len = p - tmp;
371 
372 	/* We don't know if the next char is whitespace thus we may accept
373 	 * invalid integers (e.g. 1234...a) or two integers instead of one
374 	 * (e.g. 123...1). So lets not allow such large numbers. */
375 	if (len == TMPBUFLEN - 1)
376 		return -EINVAL;
377 
378 	if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
379 		return -EINVAL;
380 
381 	if (tr && (len < *size))
382 		*tr = *p;
383 
384 	*buf += len;
385 	*size -= len;
386 
387 	return 0;
388 }
389 
390 /**
391  * proc_put_long - converts an integer to a decimal ASCII formatted string
392  *
393  * @buf: the user buffer
394  * @size: the size of the user buffer
395  * @val: the integer to be converted
396  * @neg: sign of the number, %TRUE for negative
397  *
398  * In case of success @buf and @size are updated with the amount of bytes
399  * written.
400  */
proc_put_long(void ** buf,size_t * size,unsigned long val,bool neg)401 static void proc_put_long(void **buf, size_t *size, unsigned long val, bool neg)
402 {
403 	int len;
404 	char tmp[TMPBUFLEN], *p = tmp;
405 
406 	sprintf(p, "%s%lu", neg ? "-" : "", val);
407 	len = strlen(tmp);
408 	if (len > *size)
409 		len = *size;
410 	memcpy(*buf, tmp, len);
411 	*size -= len;
412 	*buf += len;
413 }
414 #undef TMPBUFLEN
415 
proc_put_char(void ** buf,size_t * size,char c)416 static void proc_put_char(void **buf, size_t *size, char c)
417 {
418 	if (*size) {
419 		char **buffer = (char **)buf;
420 		**buffer = c;
421 
422 		(*size)--;
423 		(*buffer)++;
424 		*buf = *buffer;
425 	}
426 }
427 
do_proc_dobool_conv(bool * negp,unsigned long * lvalp,int * valp,int write,void * data)428 static int do_proc_dobool_conv(bool *negp, unsigned long *lvalp,
429 				int *valp,
430 				int write, void *data)
431 {
432 	if (write) {
433 		*(bool *)valp = *lvalp;
434 	} else {
435 		int val = *(bool *)valp;
436 
437 		*lvalp = (unsigned long)val;
438 		*negp = false;
439 	}
440 	return 0;
441 }
442 
do_proc_dointvec_conv(bool * negp,unsigned long * lvalp,int * valp,int write,void * data)443 static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
444 				 int *valp,
445 				 int write, void *data)
446 {
447 	if (write) {
448 		if (*negp) {
449 			if (*lvalp > (unsigned long) INT_MAX + 1)
450 				return -EINVAL;
451 			WRITE_ONCE(*valp, -*lvalp);
452 		} else {
453 			if (*lvalp > (unsigned long) INT_MAX)
454 				return -EINVAL;
455 			WRITE_ONCE(*valp, *lvalp);
456 		}
457 	} else {
458 		int val = READ_ONCE(*valp);
459 		if (val < 0) {
460 			*negp = true;
461 			*lvalp = -(unsigned long)val;
462 		} else {
463 			*negp = false;
464 			*lvalp = (unsigned long)val;
465 		}
466 	}
467 	return 0;
468 }
469 
do_proc_douintvec_conv(unsigned long * lvalp,unsigned int * valp,int write,void * data)470 static int do_proc_douintvec_conv(unsigned long *lvalp,
471 				  unsigned int *valp,
472 				  int write, void *data)
473 {
474 	if (write) {
475 		if (*lvalp > UINT_MAX)
476 			return -EINVAL;
477 		WRITE_ONCE(*valp, *lvalp);
478 	} else {
479 		unsigned int val = READ_ONCE(*valp);
480 		*lvalp = (unsigned long)val;
481 	}
482 	return 0;
483 }
484 
485 static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
486 
__do_proc_dointvec(void * tbl_data,struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos,int (* conv)(bool * negp,unsigned long * lvalp,int * valp,int write,void * data),void * data)487 static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
488 		  int write, void *buffer,
489 		  size_t *lenp, loff_t *ppos,
490 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
491 			      int write, void *data),
492 		  void *data)
493 {
494 	int *i, vleft, first = 1, err = 0;
495 	size_t left;
496 	char *p;
497 
498 	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
499 		*lenp = 0;
500 		return 0;
501 	}
502 
503 	i = (int *) tbl_data;
504 	vleft = table->maxlen / sizeof(*i);
505 	left = *lenp;
506 
507 	if (!conv)
508 		conv = do_proc_dointvec_conv;
509 
510 	if (write) {
511 		if (proc_first_pos_non_zero_ignore(ppos, table))
512 			goto out;
513 
514 		if (left > PAGE_SIZE - 1)
515 			left = PAGE_SIZE - 1;
516 		p = buffer;
517 	}
518 
519 	for (; left && vleft--; i++, first=0) {
520 		unsigned long lval;
521 		bool neg;
522 
523 		if (write) {
524 			proc_skip_spaces(&p, &left);
525 
526 			if (!left)
527 				break;
528 			err = proc_get_long(&p, &left, &lval, &neg,
529 					     proc_wspace_sep,
530 					     sizeof(proc_wspace_sep), NULL);
531 			if (err)
532 				break;
533 			if (conv(&neg, &lval, i, 1, data)) {
534 				err = -EINVAL;
535 				break;
536 			}
537 		} else {
538 			if (conv(&neg, &lval, i, 0, data)) {
539 				err = -EINVAL;
540 				break;
541 			}
542 			if (!first)
543 				proc_put_char(&buffer, &left, '\t');
544 			proc_put_long(&buffer, &left, lval, neg);
545 		}
546 	}
547 
548 	if (!write && !first && left && !err)
549 		proc_put_char(&buffer, &left, '\n');
550 	if (write && !err && left)
551 		proc_skip_spaces(&p, &left);
552 	if (write && first)
553 		return err ? : -EINVAL;
554 	*lenp -= left;
555 out:
556 	*ppos += *lenp;
557 	return err;
558 }
559 
do_proc_dointvec(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos,int (* conv)(bool * negp,unsigned long * lvalp,int * valp,int write,void * data),void * data)560 static int do_proc_dointvec(struct ctl_table *table, int write,
561 		  void *buffer, size_t *lenp, loff_t *ppos,
562 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
563 			      int write, void *data),
564 		  void *data)
565 {
566 	return __do_proc_dointvec(table->data, table, write,
567 			buffer, lenp, ppos, conv, data);
568 }
569 
do_proc_douintvec_w(unsigned int * tbl_data,struct ctl_table * table,void * buffer,size_t * lenp,loff_t * ppos,int (* conv)(unsigned long * lvalp,unsigned int * valp,int write,void * data),void * data)570 static int do_proc_douintvec_w(unsigned int *tbl_data,
571 			       struct ctl_table *table,
572 			       void *buffer,
573 			       size_t *lenp, loff_t *ppos,
574 			       int (*conv)(unsigned long *lvalp,
575 					   unsigned int *valp,
576 					   int write, void *data),
577 			       void *data)
578 {
579 	unsigned long lval;
580 	int err = 0;
581 	size_t left;
582 	bool neg;
583 	char *p = buffer;
584 
585 	left = *lenp;
586 
587 	if (proc_first_pos_non_zero_ignore(ppos, table))
588 		goto bail_early;
589 
590 	if (left > PAGE_SIZE - 1)
591 		left = PAGE_SIZE - 1;
592 
593 	proc_skip_spaces(&p, &left);
594 	if (!left) {
595 		err = -EINVAL;
596 		goto out_free;
597 	}
598 
599 	err = proc_get_long(&p, &left, &lval, &neg,
600 			     proc_wspace_sep,
601 			     sizeof(proc_wspace_sep), NULL);
602 	if (err || neg) {
603 		err = -EINVAL;
604 		goto out_free;
605 	}
606 
607 	if (conv(&lval, tbl_data, 1, data)) {
608 		err = -EINVAL;
609 		goto out_free;
610 	}
611 
612 	if (!err && left)
613 		proc_skip_spaces(&p, &left);
614 
615 out_free:
616 	if (err)
617 		return -EINVAL;
618 
619 	return 0;
620 
621 	/* This is in keeping with old __do_proc_dointvec() */
622 bail_early:
623 	*ppos += *lenp;
624 	return err;
625 }
626 
do_proc_douintvec_r(unsigned int * tbl_data,void * buffer,size_t * lenp,loff_t * ppos,int (* conv)(unsigned long * lvalp,unsigned int * valp,int write,void * data),void * data)627 static int do_proc_douintvec_r(unsigned int *tbl_data, void *buffer,
628 			       size_t *lenp, loff_t *ppos,
629 			       int (*conv)(unsigned long *lvalp,
630 					   unsigned int *valp,
631 					   int write, void *data),
632 			       void *data)
633 {
634 	unsigned long lval;
635 	int err = 0;
636 	size_t left;
637 
638 	left = *lenp;
639 
640 	if (conv(&lval, tbl_data, 0, data)) {
641 		err = -EINVAL;
642 		goto out;
643 	}
644 
645 	proc_put_long(&buffer, &left, lval, false);
646 	if (!left)
647 		goto out;
648 
649 	proc_put_char(&buffer, &left, '\n');
650 
651 out:
652 	*lenp -= left;
653 	*ppos += *lenp;
654 
655 	return err;
656 }
657 
__do_proc_douintvec(void * tbl_data,struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos,int (* conv)(unsigned long * lvalp,unsigned int * valp,int write,void * data),void * data)658 static int __do_proc_douintvec(void *tbl_data, struct ctl_table *table,
659 			       int write, void *buffer,
660 			       size_t *lenp, loff_t *ppos,
661 			       int (*conv)(unsigned long *lvalp,
662 					   unsigned int *valp,
663 					   int write, void *data),
664 			       void *data)
665 {
666 	unsigned int *i, vleft;
667 
668 	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
669 		*lenp = 0;
670 		return 0;
671 	}
672 
673 	i = (unsigned int *) tbl_data;
674 	vleft = table->maxlen / sizeof(*i);
675 
676 	/*
677 	 * Arrays are not supported, keep this simple. *Do not* add
678 	 * support for them.
679 	 */
680 	if (vleft != 1) {
681 		*lenp = 0;
682 		return -EINVAL;
683 	}
684 
685 	if (!conv)
686 		conv = do_proc_douintvec_conv;
687 
688 	if (write)
689 		return do_proc_douintvec_w(i, table, buffer, lenp, ppos,
690 					   conv, data);
691 	return do_proc_douintvec_r(i, buffer, lenp, ppos, conv, data);
692 }
693 
do_proc_douintvec(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos,int (* conv)(unsigned long * lvalp,unsigned int * valp,int write,void * data),void * data)694 int do_proc_douintvec(struct ctl_table *table, int write,
695 		      void *buffer, size_t *lenp, loff_t *ppos,
696 		      int (*conv)(unsigned long *lvalp,
697 				  unsigned int *valp,
698 				  int write, void *data),
699 		      void *data)
700 {
701 	return __do_proc_douintvec(table->data, table, write,
702 				   buffer, lenp, ppos, conv, data);
703 }
704 
705 /**
706  * proc_dobool - read/write a bool
707  * @table: the sysctl table
708  * @write: %TRUE if this is a write to the sysctl file
709  * @buffer: the user buffer
710  * @lenp: the size of the user buffer
711  * @ppos: file position
712  *
713  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
714  * values from/to the user buffer, treated as an ASCII string.
715  *
716  * Returns 0 on success.
717  */
proc_dobool(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)718 int proc_dobool(struct ctl_table *table, int write, void *buffer,
719 		size_t *lenp, loff_t *ppos)
720 {
721 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
722 				do_proc_dobool_conv, NULL);
723 }
724 
725 /**
726  * proc_dointvec - read a vector of integers
727  * @table: the sysctl table
728  * @write: %TRUE if this is a write to the sysctl file
729  * @buffer: the user buffer
730  * @lenp: the size of the user buffer
731  * @ppos: file position
732  *
733  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
734  * values from/to the user buffer, treated as an ASCII string.
735  *
736  * Returns 0 on success.
737  */
proc_dointvec(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)738 int proc_dointvec(struct ctl_table *table, int write, void *buffer,
739 		  size_t *lenp, loff_t *ppos)
740 {
741 	return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL);
742 }
743 
744 #ifdef CONFIG_COMPACTION
proc_dointvec_minmax_warn_RT_change(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)745 static int proc_dointvec_minmax_warn_RT_change(struct ctl_table *table,
746 		int write, void *buffer, size_t *lenp, loff_t *ppos)
747 {
748 	int ret, old;
749 
750 	if (!IS_ENABLED(CONFIG_PREEMPT_RT) || !write)
751 		return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
752 
753 	old = *(int *)table->data;
754 	ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
755 	if (ret)
756 		return ret;
757 	if (old != *(int *)table->data)
758 		pr_warn_once("sysctl attribute %s changed by %s[%d]\n",
759 			     table->procname, current->comm,
760 			     task_pid_nr(current));
761 	return ret;
762 }
763 #endif
764 
765 /**
766  * proc_douintvec - read a vector of unsigned integers
767  * @table: the sysctl table
768  * @write: %TRUE if this is a write to the sysctl file
769  * @buffer: the user buffer
770  * @lenp: the size of the user buffer
771  * @ppos: file position
772  *
773  * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
774  * values from/to the user buffer, treated as an ASCII string.
775  *
776  * Returns 0 on success.
777  */
proc_douintvec(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)778 int proc_douintvec(struct ctl_table *table, int write, void *buffer,
779 		size_t *lenp, loff_t *ppos)
780 {
781 	return do_proc_douintvec(table, write, buffer, lenp, ppos,
782 				 do_proc_douintvec_conv, NULL);
783 }
784 
785 /*
786  * Taint values can only be increased
787  * This means we can safely use a temporary.
788  */
proc_taint(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)789 static int proc_taint(struct ctl_table *table, int write,
790 			       void *buffer, size_t *lenp, loff_t *ppos)
791 {
792 	struct ctl_table t;
793 	unsigned long tmptaint = get_taint();
794 	int err;
795 
796 	if (write && !capable(CAP_SYS_ADMIN))
797 		return -EPERM;
798 
799 	t = *table;
800 	t.data = &tmptaint;
801 	err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
802 	if (err < 0)
803 		return err;
804 
805 	if (write) {
806 		int i;
807 
808 		/*
809 		 * If we are relying on panic_on_taint not producing
810 		 * false positives due to userspace input, bail out
811 		 * before setting the requested taint flags.
812 		 */
813 		if (panic_on_taint_nousertaint && (tmptaint & panic_on_taint))
814 			return -EINVAL;
815 
816 		/*
817 		 * Poor man's atomic or. Not worth adding a primitive
818 		 * to everyone's atomic.h for this
819 		 */
820 		for (i = 0; i < TAINT_FLAGS_COUNT; i++)
821 			if ((1UL << i) & tmptaint)
822 				add_taint(i, LOCKDEP_STILL_OK);
823 	}
824 
825 	return err;
826 }
827 
828 /**
829  * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
830  * @min: pointer to minimum allowable value
831  * @max: pointer to maximum allowable value
832  *
833  * The do_proc_dointvec_minmax_conv_param structure provides the
834  * minimum and maximum values for doing range checking for those sysctl
835  * parameters that use the proc_dointvec_minmax() handler.
836  */
837 struct do_proc_dointvec_minmax_conv_param {
838 	int *min;
839 	int *max;
840 };
841 
do_proc_dointvec_minmax_conv(bool * negp,unsigned long * lvalp,int * valp,int write,void * data)842 static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
843 					int *valp,
844 					int write, void *data)
845 {
846 	int tmp, ret;
847 	struct do_proc_dointvec_minmax_conv_param *param = data;
848 	/*
849 	 * If writing, first do so via a temporary local int so we can
850 	 * bounds-check it before touching *valp.
851 	 */
852 	int *ip = write ? &tmp : valp;
853 
854 	ret = do_proc_dointvec_conv(negp, lvalp, ip, write, data);
855 	if (ret)
856 		return ret;
857 
858 	if (write) {
859 		if ((param->min && *param->min > tmp) ||
860 		    (param->max && *param->max < tmp))
861 			return -EINVAL;
862 		WRITE_ONCE(*valp, tmp);
863 	}
864 
865 	return 0;
866 }
867 
868 /**
869  * proc_dointvec_minmax - read a vector of integers with min/max values
870  * @table: the sysctl table
871  * @write: %TRUE if this is a write to the sysctl file
872  * @buffer: the user buffer
873  * @lenp: the size of the user buffer
874  * @ppos: file position
875  *
876  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
877  * values from/to the user buffer, treated as an ASCII string.
878  *
879  * This routine will ensure the values are within the range specified by
880  * table->extra1 (min) and table->extra2 (max).
881  *
882  * Returns 0 on success or -EINVAL on write when the range check fails.
883  */
proc_dointvec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)884 int proc_dointvec_minmax(struct ctl_table *table, int write,
885 		  void *buffer, size_t *lenp, loff_t *ppos)
886 {
887 	struct do_proc_dointvec_minmax_conv_param param = {
888 		.min = (int *) table->extra1,
889 		.max = (int *) table->extra2,
890 	};
891 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
892 				do_proc_dointvec_minmax_conv, &param);
893 }
894 
895 /**
896  * struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure
897  * @min: pointer to minimum allowable value
898  * @max: pointer to maximum allowable value
899  *
900  * The do_proc_douintvec_minmax_conv_param structure provides the
901  * minimum and maximum values for doing range checking for those sysctl
902  * parameters that use the proc_douintvec_minmax() handler.
903  */
904 struct do_proc_douintvec_minmax_conv_param {
905 	unsigned int *min;
906 	unsigned int *max;
907 };
908 
do_proc_douintvec_minmax_conv(unsigned long * lvalp,unsigned int * valp,int write,void * data)909 static int do_proc_douintvec_minmax_conv(unsigned long *lvalp,
910 					 unsigned int *valp,
911 					 int write, void *data)
912 {
913 	int ret;
914 	unsigned int tmp;
915 	struct do_proc_douintvec_minmax_conv_param *param = data;
916 	/* write via temporary local uint for bounds-checking */
917 	unsigned int *up = write ? &tmp : valp;
918 
919 	ret = do_proc_douintvec_conv(lvalp, up, write, data);
920 	if (ret)
921 		return ret;
922 
923 	if (write) {
924 		if ((param->min && *param->min > tmp) ||
925 		    (param->max && *param->max < tmp))
926 			return -ERANGE;
927 
928 		WRITE_ONCE(*valp, tmp);
929 	}
930 
931 	return 0;
932 }
933 
934 /**
935  * proc_douintvec_minmax - read a vector of unsigned ints with min/max values
936  * @table: the sysctl table
937  * @write: %TRUE if this is a write to the sysctl file
938  * @buffer: the user buffer
939  * @lenp: the size of the user buffer
940  * @ppos: file position
941  *
942  * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
943  * values from/to the user buffer, treated as an ASCII string. Negative
944  * strings are not allowed.
945  *
946  * This routine will ensure the values are within the range specified by
947  * table->extra1 (min) and table->extra2 (max). There is a final sanity
948  * check for UINT_MAX to avoid having to support wrap around uses from
949  * userspace.
950  *
951  * Returns 0 on success or -ERANGE on write when the range check fails.
952  */
proc_douintvec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)953 int proc_douintvec_minmax(struct ctl_table *table, int write,
954 			  void *buffer, size_t *lenp, loff_t *ppos)
955 {
956 	struct do_proc_douintvec_minmax_conv_param param = {
957 		.min = (unsigned int *) table->extra1,
958 		.max = (unsigned int *) table->extra2,
959 	};
960 	return do_proc_douintvec(table, write, buffer, lenp, ppos,
961 				 do_proc_douintvec_minmax_conv, &param);
962 }
963 
964 /**
965  * proc_dou8vec_minmax - read a vector of unsigned chars with min/max values
966  * @table: the sysctl table
967  * @write: %TRUE if this is a write to the sysctl file
968  * @buffer: the user buffer
969  * @lenp: the size of the user buffer
970  * @ppos: file position
971  *
972  * Reads/writes up to table->maxlen/sizeof(u8) unsigned chars
973  * values from/to the user buffer, treated as an ASCII string. Negative
974  * strings are not allowed.
975  *
976  * This routine will ensure the values are within the range specified by
977  * table->extra1 (min) and table->extra2 (max).
978  *
979  * Returns 0 on success or an error on write when the range check fails.
980  */
proc_dou8vec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)981 int proc_dou8vec_minmax(struct ctl_table *table, int write,
982 			void *buffer, size_t *lenp, loff_t *ppos)
983 {
984 	struct ctl_table tmp;
985 	unsigned int min = 0, max = 255U, val;
986 	u8 *data = table->data;
987 	struct do_proc_douintvec_minmax_conv_param param = {
988 		.min = &min,
989 		.max = &max,
990 	};
991 	int res;
992 
993 	/* Do not support arrays yet. */
994 	if (table->maxlen != sizeof(u8))
995 		return -EINVAL;
996 
997 	if (table->extra1) {
998 		min = *(unsigned int *) table->extra1;
999 		if (min > 255U)
1000 			return -EINVAL;
1001 	}
1002 	if (table->extra2) {
1003 		max = *(unsigned int *) table->extra2;
1004 		if (max > 255U)
1005 			return -EINVAL;
1006 	}
1007 
1008 	tmp = *table;
1009 
1010 	tmp.maxlen = sizeof(val);
1011 	tmp.data = &val;
1012 	val = READ_ONCE(*data);
1013 	res = do_proc_douintvec(&tmp, write, buffer, lenp, ppos,
1014 				do_proc_douintvec_minmax_conv, &param);
1015 	if (res)
1016 		return res;
1017 	if (write)
1018 		WRITE_ONCE(*data, val);
1019 	return 0;
1020 }
1021 EXPORT_SYMBOL_GPL(proc_dou8vec_minmax);
1022 
1023 #ifdef CONFIG_MAGIC_SYSRQ
sysrq_sysctl_handler(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1024 static int sysrq_sysctl_handler(struct ctl_table *table, int write,
1025 				void *buffer, size_t *lenp, loff_t *ppos)
1026 {
1027 	int tmp, ret;
1028 
1029 	tmp = sysrq_mask();
1030 
1031 	ret = __do_proc_dointvec(&tmp, table, write, buffer,
1032 			       lenp, ppos, NULL, NULL);
1033 	if (ret || !write)
1034 		return ret;
1035 
1036 	if (write)
1037 		sysrq_toggle_support(tmp);
1038 
1039 	return 0;
1040 }
1041 #endif
1042 
__do_proc_doulongvec_minmax(void * data,struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos,unsigned long convmul,unsigned long convdiv)1043 static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table,
1044 		int write, void *buffer, size_t *lenp, loff_t *ppos,
1045 		unsigned long convmul, unsigned long convdiv)
1046 {
1047 	unsigned long *i, *min, *max;
1048 	int vleft, first = 1, err = 0;
1049 	size_t left;
1050 	char *p;
1051 
1052 	if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
1053 		*lenp = 0;
1054 		return 0;
1055 	}
1056 
1057 	i = data;
1058 	min = table->extra1;
1059 	max = table->extra2;
1060 	vleft = table->maxlen / sizeof(unsigned long);
1061 	left = *lenp;
1062 
1063 	if (write) {
1064 		if (proc_first_pos_non_zero_ignore(ppos, table))
1065 			goto out;
1066 
1067 		if (left > PAGE_SIZE - 1)
1068 			left = PAGE_SIZE - 1;
1069 		p = buffer;
1070 	}
1071 
1072 	for (; left && vleft--; i++, first = 0) {
1073 		unsigned long val;
1074 
1075 		if (write) {
1076 			bool neg;
1077 
1078 			proc_skip_spaces(&p, &left);
1079 			if (!left)
1080 				break;
1081 
1082 			err = proc_get_long(&p, &left, &val, &neg,
1083 					     proc_wspace_sep,
1084 					     sizeof(proc_wspace_sep), NULL);
1085 			if (err || neg) {
1086 				err = -EINVAL;
1087 				break;
1088 			}
1089 
1090 			val = convmul * val / convdiv;
1091 			if ((min && val < *min) || (max && val > *max)) {
1092 				err = -EINVAL;
1093 				break;
1094 			}
1095 			WRITE_ONCE(*i, val);
1096 		} else {
1097 			val = convdiv * READ_ONCE(*i) / convmul;
1098 			if (!first)
1099 				proc_put_char(&buffer, &left, '\t');
1100 			proc_put_long(&buffer, &left, val, false);
1101 		}
1102 	}
1103 
1104 	if (!write && !first && left && !err)
1105 		proc_put_char(&buffer, &left, '\n');
1106 	if (write && !err)
1107 		proc_skip_spaces(&p, &left);
1108 	if (write && first)
1109 		return err ? : -EINVAL;
1110 	*lenp -= left;
1111 out:
1112 	*ppos += *lenp;
1113 	return err;
1114 }
1115 
do_proc_doulongvec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos,unsigned long convmul,unsigned long convdiv)1116 static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
1117 		void *buffer, size_t *lenp, loff_t *ppos, unsigned long convmul,
1118 		unsigned long convdiv)
1119 {
1120 	return __do_proc_doulongvec_minmax(table->data, table, write,
1121 			buffer, lenp, ppos, convmul, convdiv);
1122 }
1123 
1124 /**
1125  * proc_doulongvec_minmax - read a vector of long integers with min/max values
1126  * @table: the sysctl table
1127  * @write: %TRUE if this is a write to the sysctl file
1128  * @buffer: the user buffer
1129  * @lenp: the size of the user buffer
1130  * @ppos: file position
1131  *
1132  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1133  * values from/to the user buffer, treated as an ASCII string.
1134  *
1135  * This routine will ensure the values are within the range specified by
1136  * table->extra1 (min) and table->extra2 (max).
1137  *
1138  * Returns 0 on success.
1139  */
proc_doulongvec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1140 int proc_doulongvec_minmax(struct ctl_table *table, int write,
1141 			   void *buffer, size_t *lenp, loff_t *ppos)
1142 {
1143     return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
1144 }
1145 
1146 /**
1147  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
1148  * @table: the sysctl table
1149  * @write: %TRUE if this is a write to the sysctl file
1150  * @buffer: the user buffer
1151  * @lenp: the size of the user buffer
1152  * @ppos: file position
1153  *
1154  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1155  * values from/to the user buffer, treated as an ASCII string. The values
1156  * are treated as milliseconds, and converted to jiffies when they are stored.
1157  *
1158  * This routine will ensure the values are within the range specified by
1159  * table->extra1 (min) and table->extra2 (max).
1160  *
1161  * Returns 0 on success.
1162  */
proc_doulongvec_ms_jiffies_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1163 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1164 				      void *buffer, size_t *lenp, loff_t *ppos)
1165 {
1166     return do_proc_doulongvec_minmax(table, write, buffer,
1167 				     lenp, ppos, HZ, 1000l);
1168 }
1169 
1170 
do_proc_dointvec_jiffies_conv(bool * negp,unsigned long * lvalp,int * valp,int write,void * data)1171 static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
1172 					 int *valp,
1173 					 int write, void *data)
1174 {
1175 	if (write) {
1176 		if (*lvalp > INT_MAX / HZ)
1177 			return 1;
1178 		if (*negp)
1179 			WRITE_ONCE(*valp, -*lvalp * HZ);
1180 		else
1181 			WRITE_ONCE(*valp, *lvalp * HZ);
1182 	} else {
1183 		int val = READ_ONCE(*valp);
1184 		unsigned long lval;
1185 		if (val < 0) {
1186 			*negp = true;
1187 			lval = -(unsigned long)val;
1188 		} else {
1189 			*negp = false;
1190 			lval = (unsigned long)val;
1191 		}
1192 		*lvalp = lval / HZ;
1193 	}
1194 	return 0;
1195 }
1196 
do_proc_dointvec_userhz_jiffies_conv(bool * negp,unsigned long * lvalp,int * valp,int write,void * data)1197 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
1198 						int *valp,
1199 						int write, void *data)
1200 {
1201 	if (write) {
1202 		if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
1203 			return 1;
1204 		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
1205 	} else {
1206 		int val = *valp;
1207 		unsigned long lval;
1208 		if (val < 0) {
1209 			*negp = true;
1210 			lval = -(unsigned long)val;
1211 		} else {
1212 			*negp = false;
1213 			lval = (unsigned long)val;
1214 		}
1215 		*lvalp = jiffies_to_clock_t(lval);
1216 	}
1217 	return 0;
1218 }
1219 
do_proc_dointvec_ms_jiffies_conv(bool * negp,unsigned long * lvalp,int * valp,int write,void * data)1220 static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
1221 					    int *valp,
1222 					    int write, void *data)
1223 {
1224 	if (write) {
1225 		unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
1226 
1227 		if (jif > INT_MAX)
1228 			return 1;
1229 		WRITE_ONCE(*valp, (int)jif);
1230 	} else {
1231 		int val = READ_ONCE(*valp);
1232 		unsigned long lval;
1233 		if (val < 0) {
1234 			*negp = true;
1235 			lval = -(unsigned long)val;
1236 		} else {
1237 			*negp = false;
1238 			lval = (unsigned long)val;
1239 		}
1240 		*lvalp = jiffies_to_msecs(lval);
1241 	}
1242 	return 0;
1243 }
1244 
do_proc_dointvec_ms_jiffies_minmax_conv(bool * negp,unsigned long * lvalp,int * valp,int write,void * data)1245 static int do_proc_dointvec_ms_jiffies_minmax_conv(bool *negp, unsigned long *lvalp,
1246 						int *valp, int write, void *data)
1247 {
1248 	int tmp, ret;
1249 	struct do_proc_dointvec_minmax_conv_param *param = data;
1250 	/*
1251 	 * If writing, first do so via a temporary local int so we can
1252 	 * bounds-check it before touching *valp.
1253 	 */
1254 	int *ip = write ? &tmp : valp;
1255 
1256 	ret = do_proc_dointvec_ms_jiffies_conv(negp, lvalp, ip, write, data);
1257 	if (ret)
1258 		return ret;
1259 
1260 	if (write) {
1261 		if ((param->min && *param->min > tmp) ||
1262 				(param->max && *param->max < tmp))
1263 			return -EINVAL;
1264 		*valp = tmp;
1265 	}
1266 	return 0;
1267 }
1268 
1269 /**
1270  * proc_dointvec_jiffies - read a vector of integers as seconds
1271  * @table: the sysctl table
1272  * @write: %TRUE if this is a write to the sysctl file
1273  * @buffer: the user buffer
1274  * @lenp: the size of the user buffer
1275  * @ppos: file position
1276  *
1277  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1278  * values from/to the user buffer, treated as an ASCII string.
1279  * The values read are assumed to be in seconds, and are converted into
1280  * jiffies.
1281  *
1282  * Returns 0 on success.
1283  */
proc_dointvec_jiffies(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1284 int proc_dointvec_jiffies(struct ctl_table *table, int write,
1285 			  void *buffer, size_t *lenp, loff_t *ppos)
1286 {
1287     return do_proc_dointvec(table,write,buffer,lenp,ppos,
1288 		    	    do_proc_dointvec_jiffies_conv,NULL);
1289 }
1290 
proc_dointvec_ms_jiffies_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1291 int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1292 			  void *buffer, size_t *lenp, loff_t *ppos)
1293 {
1294 	struct do_proc_dointvec_minmax_conv_param param = {
1295 		.min = (int *) table->extra1,
1296 		.max = (int *) table->extra2,
1297 	};
1298 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
1299 			do_proc_dointvec_ms_jiffies_minmax_conv, &param);
1300 }
1301 
1302 /**
1303  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
1304  * @table: the sysctl table
1305  * @write: %TRUE if this is a write to the sysctl file
1306  * @buffer: the user buffer
1307  * @lenp: the size of the user buffer
1308  * @ppos: pointer to the file position
1309  *
1310  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1311  * values from/to the user buffer, treated as an ASCII string.
1312  * The values read are assumed to be in 1/USER_HZ seconds, and
1313  * are converted into jiffies.
1314  *
1315  * Returns 0 on success.
1316  */
proc_dointvec_userhz_jiffies(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1317 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1318 				 void *buffer, size_t *lenp, loff_t *ppos)
1319 {
1320 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
1321 				do_proc_dointvec_userhz_jiffies_conv, NULL);
1322 }
1323 
1324 /**
1325  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
1326  * @table: the sysctl table
1327  * @write: %TRUE if this is a write to the sysctl file
1328  * @buffer: the user buffer
1329  * @lenp: the size of the user buffer
1330  * @ppos: file position
1331  * @ppos: the current position in the file
1332  *
1333  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1334  * values from/to the user buffer, treated as an ASCII string.
1335  * The values read are assumed to be in 1/1000 seconds, and
1336  * are converted into jiffies.
1337  *
1338  * Returns 0 on success.
1339  */
proc_dointvec_ms_jiffies(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1340 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer,
1341 		size_t *lenp, loff_t *ppos)
1342 {
1343 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
1344 				do_proc_dointvec_ms_jiffies_conv, NULL);
1345 }
1346 
proc_do_cad_pid(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1347 static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer,
1348 		size_t *lenp, loff_t *ppos)
1349 {
1350 	struct pid *new_pid;
1351 	pid_t tmp;
1352 	int r;
1353 
1354 	tmp = pid_vnr(cad_pid);
1355 
1356 	r = __do_proc_dointvec(&tmp, table, write, buffer,
1357 			       lenp, ppos, NULL, NULL);
1358 	if (r || !write)
1359 		return r;
1360 
1361 	new_pid = find_get_pid(tmp);
1362 	if (!new_pid)
1363 		return -ESRCH;
1364 
1365 	put_pid(xchg(&cad_pid, new_pid));
1366 	return 0;
1367 }
1368 
1369 /**
1370  * proc_do_large_bitmap - read/write from/to a large bitmap
1371  * @table: the sysctl table
1372  * @write: %TRUE if this is a write to the sysctl file
1373  * @buffer: the user buffer
1374  * @lenp: the size of the user buffer
1375  * @ppos: file position
1376  *
1377  * The bitmap is stored at table->data and the bitmap length (in bits)
1378  * in table->maxlen.
1379  *
1380  * We use a range comma separated format (e.g. 1,3-4,10-10) so that
1381  * large bitmaps may be represented in a compact manner. Writing into
1382  * the file will clear the bitmap then update it with the given input.
1383  *
1384  * Returns 0 on success.
1385  */
proc_do_large_bitmap(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1386 int proc_do_large_bitmap(struct ctl_table *table, int write,
1387 			 void *buffer, size_t *lenp, loff_t *ppos)
1388 {
1389 	int err = 0;
1390 	size_t left = *lenp;
1391 	unsigned long bitmap_len = table->maxlen;
1392 	unsigned long *bitmap = *(unsigned long **) table->data;
1393 	unsigned long *tmp_bitmap = NULL;
1394 	char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
1395 
1396 	if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
1397 		*lenp = 0;
1398 		return 0;
1399 	}
1400 
1401 	if (write) {
1402 		char *p = buffer;
1403 		size_t skipped = 0;
1404 
1405 		if (left > PAGE_SIZE - 1) {
1406 			left = PAGE_SIZE - 1;
1407 			/* How much of the buffer we'll skip this pass */
1408 			skipped = *lenp - left;
1409 		}
1410 
1411 		tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL);
1412 		if (!tmp_bitmap)
1413 			return -ENOMEM;
1414 		proc_skip_char(&p, &left, '\n');
1415 		while (!err && left) {
1416 			unsigned long val_a, val_b;
1417 			bool neg;
1418 			size_t saved_left;
1419 
1420 			/* In case we stop parsing mid-number, we can reset */
1421 			saved_left = left;
1422 			err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
1423 					     sizeof(tr_a), &c);
1424 			/*
1425 			 * If we consumed the entirety of a truncated buffer or
1426 			 * only one char is left (may be a "-"), then stop here,
1427 			 * reset, & come back for more.
1428 			 */
1429 			if ((left <= 1) && skipped) {
1430 				left = saved_left;
1431 				break;
1432 			}
1433 
1434 			if (err)
1435 				break;
1436 			if (val_a >= bitmap_len || neg) {
1437 				err = -EINVAL;
1438 				break;
1439 			}
1440 
1441 			val_b = val_a;
1442 			if (left) {
1443 				p++;
1444 				left--;
1445 			}
1446 
1447 			if (c == '-') {
1448 				err = proc_get_long(&p, &left, &val_b,
1449 						     &neg, tr_b, sizeof(tr_b),
1450 						     &c);
1451 				/*
1452 				 * If we consumed all of a truncated buffer or
1453 				 * then stop here, reset, & come back for more.
1454 				 */
1455 				if (!left && skipped) {
1456 					left = saved_left;
1457 					break;
1458 				}
1459 
1460 				if (err)
1461 					break;
1462 				if (val_b >= bitmap_len || neg ||
1463 				    val_a > val_b) {
1464 					err = -EINVAL;
1465 					break;
1466 				}
1467 				if (left) {
1468 					p++;
1469 					left--;
1470 				}
1471 			}
1472 
1473 			bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
1474 			proc_skip_char(&p, &left, '\n');
1475 		}
1476 		left += skipped;
1477 	} else {
1478 		unsigned long bit_a, bit_b = 0;
1479 		bool first = 1;
1480 
1481 		while (left) {
1482 			bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
1483 			if (bit_a >= bitmap_len)
1484 				break;
1485 			bit_b = find_next_zero_bit(bitmap, bitmap_len,
1486 						   bit_a + 1) - 1;
1487 
1488 			if (!first)
1489 				proc_put_char(&buffer, &left, ',');
1490 			proc_put_long(&buffer, &left, bit_a, false);
1491 			if (bit_a != bit_b) {
1492 				proc_put_char(&buffer, &left, '-');
1493 				proc_put_long(&buffer, &left, bit_b, false);
1494 			}
1495 
1496 			first = 0; bit_b++;
1497 		}
1498 		proc_put_char(&buffer, &left, '\n');
1499 	}
1500 
1501 	if (!err) {
1502 		if (write) {
1503 			if (*ppos)
1504 				bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
1505 			else
1506 				bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
1507 		}
1508 		*lenp -= left;
1509 		*ppos += *lenp;
1510 	}
1511 
1512 	bitmap_free(tmp_bitmap);
1513 	return err;
1514 }
1515 
1516 #else /* CONFIG_PROC_SYSCTL */
1517 
proc_dostring(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1518 int proc_dostring(struct ctl_table *table, int write,
1519 		  void *buffer, size_t *lenp, loff_t *ppos)
1520 {
1521 	return -ENOSYS;
1522 }
1523 
proc_dobool(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1524 int proc_dobool(struct ctl_table *table, int write,
1525 		void *buffer, size_t *lenp, loff_t *ppos)
1526 {
1527 	return -ENOSYS;
1528 }
1529 
proc_dointvec(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1530 int proc_dointvec(struct ctl_table *table, int write,
1531 		  void *buffer, size_t *lenp, loff_t *ppos)
1532 {
1533 	return -ENOSYS;
1534 }
1535 
proc_douintvec(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1536 int proc_douintvec(struct ctl_table *table, int write,
1537 		  void *buffer, size_t *lenp, loff_t *ppos)
1538 {
1539 	return -ENOSYS;
1540 }
1541 
proc_dointvec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1542 int proc_dointvec_minmax(struct ctl_table *table, int write,
1543 		    void *buffer, size_t *lenp, loff_t *ppos)
1544 {
1545 	return -ENOSYS;
1546 }
1547 
proc_douintvec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1548 int proc_douintvec_minmax(struct ctl_table *table, int write,
1549 			  void *buffer, size_t *lenp, loff_t *ppos)
1550 {
1551 	return -ENOSYS;
1552 }
1553 
proc_dou8vec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1554 int proc_dou8vec_minmax(struct ctl_table *table, int write,
1555 			void *buffer, size_t *lenp, loff_t *ppos)
1556 {
1557 	return -ENOSYS;
1558 }
1559 
proc_dointvec_jiffies(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1560 int proc_dointvec_jiffies(struct ctl_table *table, int write,
1561 		    void *buffer, size_t *lenp, loff_t *ppos)
1562 {
1563 	return -ENOSYS;
1564 }
1565 
proc_dointvec_ms_jiffies_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1566 int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1567 				    void *buffer, size_t *lenp, loff_t *ppos)
1568 {
1569 	return -ENOSYS;
1570 }
1571 
proc_dointvec_userhz_jiffies(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1572 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1573 		    void *buffer, size_t *lenp, loff_t *ppos)
1574 {
1575 	return -ENOSYS;
1576 }
1577 
proc_dointvec_ms_jiffies(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1578 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
1579 			     void *buffer, size_t *lenp, loff_t *ppos)
1580 {
1581 	return -ENOSYS;
1582 }
1583 
proc_doulongvec_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1584 int proc_doulongvec_minmax(struct ctl_table *table, int write,
1585 		    void *buffer, size_t *lenp, loff_t *ppos)
1586 {
1587 	return -ENOSYS;
1588 }
1589 
proc_doulongvec_ms_jiffies_minmax(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1590 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1591 				      void *buffer, size_t *lenp, loff_t *ppos)
1592 {
1593 	return -ENOSYS;
1594 }
1595 
proc_do_large_bitmap(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1596 int proc_do_large_bitmap(struct ctl_table *table, int write,
1597 			 void *buffer, size_t *lenp, loff_t *ppos)
1598 {
1599 	return -ENOSYS;
1600 }
1601 
1602 #endif /* CONFIG_PROC_SYSCTL */
1603 
1604 #if defined(CONFIG_SYSCTL)
proc_do_static_key(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)1605 int proc_do_static_key(struct ctl_table *table, int write,
1606 		       void *buffer, size_t *lenp, loff_t *ppos)
1607 {
1608 	struct static_key *key = (struct static_key *)table->data;
1609 	static DEFINE_MUTEX(static_key_mutex);
1610 	int val, ret;
1611 	struct ctl_table tmp = {
1612 		.data   = &val,
1613 		.maxlen = sizeof(val),
1614 		.mode   = table->mode,
1615 		.extra1 = SYSCTL_ZERO,
1616 		.extra2 = SYSCTL_ONE,
1617 	};
1618 
1619 	if (write && !capable(CAP_SYS_ADMIN))
1620 		return -EPERM;
1621 
1622 	mutex_lock(&static_key_mutex);
1623 	val = static_key_enabled(key);
1624 	ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
1625 	if (write && !ret) {
1626 		if (val)
1627 			static_key_enable(key);
1628 		else
1629 			static_key_disable(key);
1630 	}
1631 	mutex_unlock(&static_key_mutex);
1632 	return ret;
1633 }
1634 
1635 static struct ctl_table kern_table[] = {
1636 #ifdef CONFIG_NUMA_BALANCING
1637 	{
1638 		.procname	= "numa_balancing",
1639 		.data		= NULL, /* filled in by handler */
1640 		.maxlen		= sizeof(unsigned int),
1641 		.mode		= 0644,
1642 		.proc_handler	= sysctl_numa_balancing,
1643 		.extra1		= SYSCTL_ZERO,
1644 		.extra2		= SYSCTL_FOUR,
1645 	},
1646 	{
1647 		.procname	= "numa_balancing_promote_rate_limit_MBps",
1648 		.data		= &sysctl_numa_balancing_promote_rate_limit,
1649 		.maxlen		= sizeof(unsigned int),
1650 		.mode		= 0644,
1651 		.proc_handler	= proc_dointvec_minmax,
1652 		.extra1		= SYSCTL_ZERO,
1653 	},
1654 #endif /* CONFIG_NUMA_BALANCING */
1655 	{
1656 		.procname	= "panic",
1657 		.data		= &panic_timeout,
1658 		.maxlen		= sizeof(int),
1659 		.mode		= 0644,
1660 		.proc_handler	= proc_dointvec,
1661 	},
1662 #ifdef CONFIG_PROC_SYSCTL
1663 	{
1664 		.procname	= "tainted",
1665 		.maxlen 	= sizeof(long),
1666 		.mode		= 0644,
1667 		.proc_handler	= proc_taint,
1668 	},
1669 	{
1670 		.procname	= "sysctl_writes_strict",
1671 		.data		= &sysctl_writes_strict,
1672 		.maxlen		= sizeof(int),
1673 		.mode		= 0644,
1674 		.proc_handler	= proc_dointvec_minmax,
1675 		.extra1		= SYSCTL_NEG_ONE,
1676 		.extra2		= SYSCTL_ONE,
1677 	},
1678 #endif
1679 	{
1680 		.procname	= "print-fatal-signals",
1681 		.data		= &print_fatal_signals,
1682 		.maxlen		= sizeof(int),
1683 		.mode		= 0644,
1684 		.proc_handler	= proc_dointvec,
1685 	},
1686 #ifdef CONFIG_SPARC
1687 	{
1688 		.procname	= "reboot-cmd",
1689 		.data		= reboot_command,
1690 		.maxlen		= 256,
1691 		.mode		= 0644,
1692 		.proc_handler	= proc_dostring,
1693 	},
1694 	{
1695 		.procname	= "stop-a",
1696 		.data		= &stop_a_enabled,
1697 		.maxlen		= sizeof (int),
1698 		.mode		= 0644,
1699 		.proc_handler	= proc_dointvec,
1700 	},
1701 	{
1702 		.procname	= "scons-poweroff",
1703 		.data		= &scons_pwroff,
1704 		.maxlen		= sizeof (int),
1705 		.mode		= 0644,
1706 		.proc_handler	= proc_dointvec,
1707 	},
1708 #endif
1709 #ifdef CONFIG_SPARC64
1710 	{
1711 		.procname	= "tsb-ratio",
1712 		.data		= &sysctl_tsb_ratio,
1713 		.maxlen		= sizeof (int),
1714 		.mode		= 0644,
1715 		.proc_handler	= proc_dointvec,
1716 	},
1717 #endif
1718 #ifdef CONFIG_PARISC
1719 	{
1720 		.procname	= "soft-power",
1721 		.data		= &pwrsw_enabled,
1722 		.maxlen		= sizeof (int),
1723 		.mode		= 0644,
1724 		.proc_handler	= proc_dointvec,
1725 	},
1726 #endif
1727 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1728 	{
1729 		.procname	= "unaligned-trap",
1730 		.data		= &unaligned_enabled,
1731 		.maxlen		= sizeof (int),
1732 		.mode		= 0644,
1733 		.proc_handler	= proc_dointvec,
1734 	},
1735 #endif
1736 #ifdef CONFIG_STACK_TRACER
1737 	{
1738 		.procname	= "stack_tracer_enabled",
1739 		.data		= &stack_tracer_enabled,
1740 		.maxlen		= sizeof(int),
1741 		.mode		= 0644,
1742 		.proc_handler	= stack_trace_sysctl,
1743 	},
1744 #endif
1745 #ifdef CONFIG_TRACING
1746 	{
1747 		.procname	= "ftrace_dump_on_oops",
1748 		.data		= &ftrace_dump_on_oops,
1749 		.maxlen		= sizeof(int),
1750 		.mode		= 0644,
1751 		.proc_handler	= proc_dointvec,
1752 	},
1753 	{
1754 		.procname	= "traceoff_on_warning",
1755 		.data		= &__disable_trace_on_warning,
1756 		.maxlen		= sizeof(__disable_trace_on_warning),
1757 		.mode		= 0644,
1758 		.proc_handler	= proc_dointvec,
1759 	},
1760 	{
1761 		.procname	= "tracepoint_printk",
1762 		.data		= &tracepoint_printk,
1763 		.maxlen		= sizeof(tracepoint_printk),
1764 		.mode		= 0644,
1765 		.proc_handler	= tracepoint_printk_sysctl,
1766 	},
1767 #endif
1768 #ifdef CONFIG_MODULES
1769 	{
1770 		.procname	= "modprobe",
1771 		.data		= &modprobe_path,
1772 		.maxlen		= KMOD_PATH_LEN,
1773 		.mode		= 0644,
1774 		.proc_handler	= proc_dostring,
1775 	},
1776 	{
1777 		.procname	= "modules_disabled",
1778 		.data		= &modules_disabled,
1779 		.maxlen		= sizeof(int),
1780 		.mode		= 0644,
1781 		/* only handle a transition from default "0" to "1" */
1782 		.proc_handler	= proc_dointvec_minmax,
1783 		.extra1		= SYSCTL_ONE,
1784 		.extra2		= SYSCTL_ONE,
1785 	},
1786 #endif
1787 #ifdef CONFIG_UEVENT_HELPER
1788 	{
1789 		.procname	= "hotplug",
1790 		.data		= &uevent_helper,
1791 		.maxlen		= UEVENT_HELPER_PATH_LEN,
1792 		.mode		= 0644,
1793 		.proc_handler	= proc_dostring,
1794 	},
1795 #endif
1796 #ifdef CONFIG_MAGIC_SYSRQ
1797 	{
1798 		.procname	= "sysrq",
1799 		.data		= NULL,
1800 		.maxlen		= sizeof (int),
1801 		.mode		= 0644,
1802 		.proc_handler	= sysrq_sysctl_handler,
1803 	},
1804 #endif
1805 #ifdef CONFIG_PROC_SYSCTL
1806 	{
1807 		.procname	= "cad_pid",
1808 		.data		= NULL,
1809 		.maxlen		= sizeof (int),
1810 		.mode		= 0600,
1811 		.proc_handler	= proc_do_cad_pid,
1812 	},
1813 #endif
1814 	{
1815 		.procname	= "threads-max",
1816 		.data		= NULL,
1817 		.maxlen		= sizeof(int),
1818 		.mode		= 0644,
1819 		.proc_handler	= sysctl_max_threads,
1820 	},
1821 	{
1822 		.procname	= "usermodehelper",
1823 		.mode		= 0555,
1824 		.child		= usermodehelper_table,
1825 	},
1826 	{
1827 		.procname	= "overflowuid",
1828 		.data		= &overflowuid,
1829 		.maxlen		= sizeof(int),
1830 		.mode		= 0644,
1831 		.proc_handler	= proc_dointvec_minmax,
1832 		.extra1		= SYSCTL_ZERO,
1833 		.extra2		= SYSCTL_MAXOLDUID,
1834 	},
1835 	{
1836 		.procname	= "overflowgid",
1837 		.data		= &overflowgid,
1838 		.maxlen		= sizeof(int),
1839 		.mode		= 0644,
1840 		.proc_handler	= proc_dointvec_minmax,
1841 		.extra1		= SYSCTL_ZERO,
1842 		.extra2		= SYSCTL_MAXOLDUID,
1843 	},
1844 #ifdef CONFIG_S390
1845 	{
1846 		.procname	= "userprocess_debug",
1847 		.data		= &show_unhandled_signals,
1848 		.maxlen		= sizeof(int),
1849 		.mode		= 0644,
1850 		.proc_handler	= proc_dointvec,
1851 	},
1852 #endif
1853 	{
1854 		.procname	= "pid_max",
1855 		.data		= &pid_max,
1856 		.maxlen		= sizeof (int),
1857 		.mode		= 0644,
1858 		.proc_handler	= proc_dointvec_minmax,
1859 		.extra1		= &pid_max_min,
1860 		.extra2		= &pid_max_max,
1861 	},
1862 	{
1863 		.procname	= "panic_on_oops",
1864 		.data		= &panic_on_oops,
1865 		.maxlen		= sizeof(int),
1866 		.mode		= 0644,
1867 		.proc_handler	= proc_dointvec,
1868 	},
1869 	{
1870 		.procname	= "panic_print",
1871 		.data		= &panic_print,
1872 		.maxlen		= sizeof(unsigned long),
1873 		.mode		= 0644,
1874 		.proc_handler	= proc_doulongvec_minmax,
1875 	},
1876 	{
1877 		.procname	= "ngroups_max",
1878 		.data		= (void *)&ngroups_max,
1879 		.maxlen		= sizeof (int),
1880 		.mode		= 0444,
1881 		.proc_handler	= proc_dointvec,
1882 	},
1883 	{
1884 		.procname	= "cap_last_cap",
1885 		.data		= (void *)&cap_last_cap,
1886 		.maxlen		= sizeof(int),
1887 		.mode		= 0444,
1888 		.proc_handler	= proc_dointvec,
1889 	},
1890 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
1891 	{
1892 		.procname       = "unknown_nmi_panic",
1893 		.data           = &unknown_nmi_panic,
1894 		.maxlen         = sizeof (int),
1895 		.mode           = 0644,
1896 		.proc_handler   = proc_dointvec,
1897 	},
1898 #endif
1899 
1900 #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \
1901 	defined(CONFIG_DEBUG_STACKOVERFLOW)
1902 	{
1903 		.procname	= "panic_on_stackoverflow",
1904 		.data		= &sysctl_panic_on_stackoverflow,
1905 		.maxlen		= sizeof(int),
1906 		.mode		= 0644,
1907 		.proc_handler	= proc_dointvec,
1908 	},
1909 #endif
1910 #if defined(CONFIG_X86)
1911 	{
1912 		.procname	= "panic_on_unrecovered_nmi",
1913 		.data		= &panic_on_unrecovered_nmi,
1914 		.maxlen		= sizeof(int),
1915 		.mode		= 0644,
1916 		.proc_handler	= proc_dointvec,
1917 	},
1918 	{
1919 		.procname	= "panic_on_io_nmi",
1920 		.data		= &panic_on_io_nmi,
1921 		.maxlen		= sizeof(int),
1922 		.mode		= 0644,
1923 		.proc_handler	= proc_dointvec,
1924 	},
1925 	{
1926 		.procname	= "bootloader_type",
1927 		.data		= &bootloader_type,
1928 		.maxlen		= sizeof (int),
1929 		.mode		= 0444,
1930 		.proc_handler	= proc_dointvec,
1931 	},
1932 	{
1933 		.procname	= "bootloader_version",
1934 		.data		= &bootloader_version,
1935 		.maxlen		= sizeof (int),
1936 		.mode		= 0444,
1937 		.proc_handler	= proc_dointvec,
1938 	},
1939 	{
1940 		.procname	= "io_delay_type",
1941 		.data		= &io_delay_type,
1942 		.maxlen		= sizeof(int),
1943 		.mode		= 0644,
1944 		.proc_handler	= proc_dointvec,
1945 	},
1946 #endif
1947 #if defined(CONFIG_MMU)
1948 	{
1949 		.procname	= "randomize_va_space",
1950 		.data		= &randomize_va_space,
1951 		.maxlen		= sizeof(int),
1952 		.mode		= 0644,
1953 		.proc_handler	= proc_dointvec,
1954 	},
1955 #endif
1956 #if defined(CONFIG_S390) && defined(CONFIG_SMP)
1957 	{
1958 		.procname	= "spin_retry",
1959 		.data		= &spin_retry,
1960 		.maxlen		= sizeof (int),
1961 		.mode		= 0644,
1962 		.proc_handler	= proc_dointvec,
1963 	},
1964 #endif
1965 #if	defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
1966 	{
1967 		.procname	= "acpi_video_flags",
1968 		.data		= &acpi_realmode_flags,
1969 		.maxlen		= sizeof (unsigned long),
1970 		.mode		= 0644,
1971 		.proc_handler	= proc_doulongvec_minmax,
1972 	},
1973 #endif
1974 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1975 	{
1976 		.procname	= "ignore-unaligned-usertrap",
1977 		.data		= &no_unaligned_warning,
1978 		.maxlen		= sizeof (int),
1979 		.mode		= 0644,
1980 		.proc_handler	= proc_dointvec,
1981 	},
1982 #endif
1983 #ifdef CONFIG_IA64
1984 	{
1985 		.procname	= "unaligned-dump-stack",
1986 		.data		= &unaligned_dump_stack,
1987 		.maxlen		= sizeof (int),
1988 		.mode		= 0644,
1989 		.proc_handler	= proc_dointvec,
1990 	},
1991 #endif
1992 #ifdef CONFIG_RT_MUTEXES
1993 	{
1994 		.procname	= "max_lock_depth",
1995 		.data		= &max_lock_depth,
1996 		.maxlen		= sizeof(int),
1997 		.mode		= 0644,
1998 		.proc_handler	= proc_dointvec,
1999 	},
2000 #endif
2001 #ifdef CONFIG_KEYS
2002 	{
2003 		.procname	= "keys",
2004 		.mode		= 0555,
2005 		.child		= key_sysctls,
2006 	},
2007 #endif
2008 #ifdef CONFIG_PERF_EVENTS
2009 	/*
2010 	 * User-space scripts rely on the existence of this file
2011 	 * as a feature check for perf_events being enabled.
2012 	 *
2013 	 * So it's an ABI, do not remove!
2014 	 */
2015 	{
2016 		.procname	= "perf_event_paranoid",
2017 		.data		= &sysctl_perf_event_paranoid,
2018 		.maxlen		= sizeof(sysctl_perf_event_paranoid),
2019 		.mode		= 0644,
2020 		.proc_handler	= proc_dointvec,
2021 	},
2022 	{
2023 		.procname	= "perf_event_mlock_kb",
2024 		.data		= &sysctl_perf_event_mlock,
2025 		.maxlen		= sizeof(sysctl_perf_event_mlock),
2026 		.mode		= 0644,
2027 		.proc_handler	= proc_dointvec,
2028 	},
2029 	{
2030 		.procname	= "perf_event_max_sample_rate",
2031 		.data		= &sysctl_perf_event_sample_rate,
2032 		.maxlen		= sizeof(sysctl_perf_event_sample_rate),
2033 		.mode		= 0644,
2034 		.proc_handler	= perf_proc_update_handler,
2035 		.extra1		= SYSCTL_ONE,
2036 	},
2037 	{
2038 		.procname	= "perf_cpu_time_max_percent",
2039 		.data		= &sysctl_perf_cpu_time_max_percent,
2040 		.maxlen		= sizeof(sysctl_perf_cpu_time_max_percent),
2041 		.mode		= 0644,
2042 		.proc_handler	= perf_cpu_time_max_percent_handler,
2043 		.extra1		= SYSCTL_ZERO,
2044 		.extra2		= SYSCTL_ONE_HUNDRED,
2045 	},
2046 	{
2047 		.procname	= "perf_event_max_stack",
2048 		.data		= &sysctl_perf_event_max_stack,
2049 		.maxlen		= sizeof(sysctl_perf_event_max_stack),
2050 		.mode		= 0644,
2051 		.proc_handler	= perf_event_max_stack_handler,
2052 		.extra1		= SYSCTL_ZERO,
2053 		.extra2		= (void *)&six_hundred_forty_kb,
2054 	},
2055 	{
2056 		.procname	= "perf_event_max_contexts_per_stack",
2057 		.data		= &sysctl_perf_event_max_contexts_per_stack,
2058 		.maxlen		= sizeof(sysctl_perf_event_max_contexts_per_stack),
2059 		.mode		= 0644,
2060 		.proc_handler	= perf_event_max_stack_handler,
2061 		.extra1		= SYSCTL_ZERO,
2062 		.extra2		= SYSCTL_ONE_THOUSAND,
2063 	},
2064 #endif
2065 	{
2066 		.procname	= "panic_on_warn",
2067 		.data		= &panic_on_warn,
2068 		.maxlen		= sizeof(int),
2069 		.mode		= 0644,
2070 		.proc_handler	= proc_dointvec_minmax,
2071 		.extra1		= SYSCTL_ZERO,
2072 		.extra2		= SYSCTL_ONE,
2073 	},
2074 #ifdef CONFIG_TREE_RCU
2075 	{
2076 		.procname	= "panic_on_rcu_stall",
2077 		.data		= &sysctl_panic_on_rcu_stall,
2078 		.maxlen		= sizeof(sysctl_panic_on_rcu_stall),
2079 		.mode		= 0644,
2080 		.proc_handler	= proc_dointvec_minmax,
2081 		.extra1		= SYSCTL_ZERO,
2082 		.extra2		= SYSCTL_ONE,
2083 	},
2084 	{
2085 		.procname	= "max_rcu_stall_to_panic",
2086 		.data		= &sysctl_max_rcu_stall_to_panic,
2087 		.maxlen		= sizeof(sysctl_max_rcu_stall_to_panic),
2088 		.mode		= 0644,
2089 		.proc_handler	= proc_dointvec_minmax,
2090 		.extra1		= SYSCTL_ONE,
2091 		.extra2		= SYSCTL_INT_MAX,
2092 	},
2093 #endif
2094 	{ }
2095 };
2096 
2097 static struct ctl_table vm_table[] = {
2098 	{
2099 		.procname	= "overcommit_memory",
2100 		.data		= &sysctl_overcommit_memory,
2101 		.maxlen		= sizeof(sysctl_overcommit_memory),
2102 		.mode		= 0644,
2103 		.proc_handler	= overcommit_policy_handler,
2104 		.extra1		= SYSCTL_ZERO,
2105 		.extra2		= SYSCTL_TWO,
2106 	},
2107 	{
2108 		.procname	= "overcommit_ratio",
2109 		.data		= &sysctl_overcommit_ratio,
2110 		.maxlen		= sizeof(sysctl_overcommit_ratio),
2111 		.mode		= 0644,
2112 		.proc_handler	= overcommit_ratio_handler,
2113 	},
2114 	{
2115 		.procname	= "overcommit_kbytes",
2116 		.data		= &sysctl_overcommit_kbytes,
2117 		.maxlen		= sizeof(sysctl_overcommit_kbytes),
2118 		.mode		= 0644,
2119 		.proc_handler	= overcommit_kbytes_handler,
2120 	},
2121 	{
2122 		.procname	= "page-cluster",
2123 		.data		= &page_cluster,
2124 		.maxlen		= sizeof(int),
2125 		.mode		= 0644,
2126 		.proc_handler	= proc_dointvec_minmax,
2127 		.extra1		= SYSCTL_ZERO,
2128 	},
2129 	{
2130 		.procname	= "dirtytime_expire_seconds",
2131 		.data		= &dirtytime_expire_interval,
2132 		.maxlen		= sizeof(dirtytime_expire_interval),
2133 		.mode		= 0644,
2134 		.proc_handler	= dirtytime_interval_handler,
2135 		.extra1		= SYSCTL_ZERO,
2136 	},
2137 	{
2138 		.procname	= "swappiness",
2139 		.data		= &vm_swappiness,
2140 		.maxlen		= sizeof(vm_swappiness),
2141 		.mode		= 0644,
2142 		.proc_handler	= proc_dointvec_minmax,
2143 		.extra1		= SYSCTL_ZERO,
2144 		.extra2		= SYSCTL_TWO_HUNDRED,
2145 	},
2146 #ifdef CONFIG_NUMA
2147 	{
2148 		.procname	= "numa_stat",
2149 		.data		= &sysctl_vm_numa_stat,
2150 		.maxlen		= sizeof(int),
2151 		.mode		= 0644,
2152 		.proc_handler	= sysctl_vm_numa_stat_handler,
2153 		.extra1		= SYSCTL_ZERO,
2154 		.extra2		= SYSCTL_ONE,
2155 	},
2156 #endif
2157 #ifdef CONFIG_HUGETLB_PAGE
2158 	{
2159 		.procname	= "nr_hugepages",
2160 		.data		= NULL,
2161 		.maxlen		= sizeof(unsigned long),
2162 		.mode		= 0644,
2163 		.proc_handler	= hugetlb_sysctl_handler,
2164 	},
2165 #ifdef CONFIG_NUMA
2166 	{
2167 		.procname       = "nr_hugepages_mempolicy",
2168 		.data           = NULL,
2169 		.maxlen         = sizeof(unsigned long),
2170 		.mode           = 0644,
2171 		.proc_handler   = &hugetlb_mempolicy_sysctl_handler,
2172 	},
2173 #endif
2174 	 {
2175 		.procname	= "hugetlb_shm_group",
2176 		.data		= &sysctl_hugetlb_shm_group,
2177 		.maxlen		= sizeof(gid_t),
2178 		.mode		= 0644,
2179 		.proc_handler	= proc_dointvec,
2180 	 },
2181 	{
2182 		.procname	= "nr_overcommit_hugepages",
2183 		.data		= NULL,
2184 		.maxlen		= sizeof(unsigned long),
2185 		.mode		= 0644,
2186 		.proc_handler	= hugetlb_overcommit_handler,
2187 	},
2188 #endif
2189 	{
2190 		.procname	= "lowmem_reserve_ratio",
2191 		.data		= &sysctl_lowmem_reserve_ratio,
2192 		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
2193 		.mode		= 0644,
2194 		.proc_handler	= lowmem_reserve_ratio_sysctl_handler,
2195 	},
2196 	{
2197 		.procname	= "drop_caches",
2198 		.data		= &sysctl_drop_caches,
2199 		.maxlen		= sizeof(int),
2200 		.mode		= 0200,
2201 		.proc_handler	= drop_caches_sysctl_handler,
2202 		.extra1		= SYSCTL_ONE,
2203 		.extra2		= SYSCTL_FOUR,
2204 	},
2205 #ifdef CONFIG_COMPACTION
2206 	{
2207 		.procname	= "compact_memory",
2208 		.data		= NULL,
2209 		.maxlen		= sizeof(int),
2210 		.mode		= 0200,
2211 		.proc_handler	= sysctl_compaction_handler,
2212 	},
2213 	{
2214 		.procname	= "compaction_proactiveness",
2215 		.data		= &sysctl_compaction_proactiveness,
2216 		.maxlen		= sizeof(sysctl_compaction_proactiveness),
2217 		.mode		= 0644,
2218 		.proc_handler	= compaction_proactiveness_sysctl_handler,
2219 		.extra1		= SYSCTL_ZERO,
2220 		.extra2		= SYSCTL_ONE_HUNDRED,
2221 	},
2222 	{
2223 		.procname	= "extfrag_threshold",
2224 		.data		= &sysctl_extfrag_threshold,
2225 		.maxlen		= sizeof(int),
2226 		.mode		= 0644,
2227 		.proc_handler	= proc_dointvec_minmax,
2228 		.extra1		= SYSCTL_ZERO,
2229 		.extra2		= SYSCTL_ONE_THOUSAND,
2230 	},
2231 	{
2232 		.procname	= "compact_unevictable_allowed",
2233 		.data		= &sysctl_compact_unevictable_allowed,
2234 		.maxlen		= sizeof(int),
2235 		.mode		= 0644,
2236 		.proc_handler	= proc_dointvec_minmax_warn_RT_change,
2237 		.extra1		= SYSCTL_ZERO,
2238 		.extra2		= SYSCTL_ONE,
2239 	},
2240 
2241 #endif /* CONFIG_COMPACTION */
2242 	{
2243 		.procname	= "min_free_kbytes",
2244 		.data		= &min_free_kbytes,
2245 		.maxlen		= sizeof(min_free_kbytes),
2246 		.mode		= 0644,
2247 		.proc_handler	= min_free_kbytes_sysctl_handler,
2248 		.extra1		= SYSCTL_ZERO,
2249 	},
2250 	{
2251 		.procname	= "watermark_boost_factor",
2252 		.data		= &watermark_boost_factor,
2253 		.maxlen		= sizeof(watermark_boost_factor),
2254 		.mode		= 0644,
2255 		.proc_handler	= proc_dointvec_minmax,
2256 		.extra1		= SYSCTL_ZERO,
2257 	},
2258 	{
2259 		.procname	= "watermark_scale_factor",
2260 		.data		= &watermark_scale_factor,
2261 		.maxlen		= sizeof(watermark_scale_factor),
2262 		.mode		= 0644,
2263 		.proc_handler	= watermark_scale_factor_sysctl_handler,
2264 		.extra1		= SYSCTL_ONE,
2265 		.extra2		= SYSCTL_THREE_THOUSAND,
2266 	},
2267 	{
2268 		.procname	= "percpu_pagelist_high_fraction",
2269 		.data		= &percpu_pagelist_high_fraction,
2270 		.maxlen		= sizeof(percpu_pagelist_high_fraction),
2271 		.mode		= 0644,
2272 		.proc_handler	= percpu_pagelist_high_fraction_sysctl_handler,
2273 		.extra1		= SYSCTL_ZERO,
2274 	},
2275 	{
2276 		.procname	= "page_lock_unfairness",
2277 		.data		= &sysctl_page_lock_unfairness,
2278 		.maxlen		= sizeof(sysctl_page_lock_unfairness),
2279 		.mode		= 0644,
2280 		.proc_handler	= proc_dointvec_minmax,
2281 		.extra1		= SYSCTL_ZERO,
2282 	},
2283 #ifdef CONFIG_MMU
2284 	{
2285 		.procname	= "max_map_count",
2286 		.data		= &sysctl_max_map_count,
2287 		.maxlen		= sizeof(sysctl_max_map_count),
2288 		.mode		= 0644,
2289 		.proc_handler	= proc_dointvec_minmax,
2290 		.extra1		= SYSCTL_ZERO,
2291 	},
2292 #else
2293 	{
2294 		.procname	= "nr_trim_pages",
2295 		.data		= &sysctl_nr_trim_pages,
2296 		.maxlen		= sizeof(sysctl_nr_trim_pages),
2297 		.mode		= 0644,
2298 		.proc_handler	= proc_dointvec_minmax,
2299 		.extra1		= SYSCTL_ZERO,
2300 	},
2301 #endif
2302 	{
2303 		.procname	= "vfs_cache_pressure",
2304 		.data		= &sysctl_vfs_cache_pressure,
2305 		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
2306 		.mode		= 0644,
2307 		.proc_handler	= proc_dointvec_minmax,
2308 		.extra1		= SYSCTL_ZERO,
2309 	},
2310 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
2311     defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
2312 	{
2313 		.procname	= "legacy_va_layout",
2314 		.data		= &sysctl_legacy_va_layout,
2315 		.maxlen		= sizeof(sysctl_legacy_va_layout),
2316 		.mode		= 0644,
2317 		.proc_handler	= proc_dointvec_minmax,
2318 		.extra1		= SYSCTL_ZERO,
2319 	},
2320 #endif
2321 #ifdef CONFIG_NUMA
2322 	{
2323 		.procname	= "zone_reclaim_mode",
2324 		.data		= &node_reclaim_mode,
2325 		.maxlen		= sizeof(node_reclaim_mode),
2326 		.mode		= 0644,
2327 		.proc_handler	= proc_dointvec_minmax,
2328 		.extra1		= SYSCTL_ZERO,
2329 	},
2330 	{
2331 		.procname	= "min_unmapped_ratio",
2332 		.data		= &sysctl_min_unmapped_ratio,
2333 		.maxlen		= sizeof(sysctl_min_unmapped_ratio),
2334 		.mode		= 0644,
2335 		.proc_handler	= sysctl_min_unmapped_ratio_sysctl_handler,
2336 		.extra1		= SYSCTL_ZERO,
2337 		.extra2		= SYSCTL_ONE_HUNDRED,
2338 	},
2339 	{
2340 		.procname	= "min_slab_ratio",
2341 		.data		= &sysctl_min_slab_ratio,
2342 		.maxlen		= sizeof(sysctl_min_slab_ratio),
2343 		.mode		= 0644,
2344 		.proc_handler	= sysctl_min_slab_ratio_sysctl_handler,
2345 		.extra1		= SYSCTL_ZERO,
2346 		.extra2		= SYSCTL_ONE_HUNDRED,
2347 	},
2348 #endif
2349 #ifdef CONFIG_SMP
2350 	{
2351 		.procname	= "stat_interval",
2352 		.data		= &sysctl_stat_interval,
2353 		.maxlen		= sizeof(sysctl_stat_interval),
2354 		.mode		= 0644,
2355 		.proc_handler	= proc_dointvec_jiffies,
2356 	},
2357 	{
2358 		.procname	= "stat_refresh",
2359 		.data		= NULL,
2360 		.maxlen		= 0,
2361 		.mode		= 0600,
2362 		.proc_handler	= vmstat_refresh,
2363 	},
2364 #endif
2365 #ifdef CONFIG_MMU
2366 	{
2367 		.procname	= "mmap_min_addr",
2368 		.data		= &dac_mmap_min_addr,
2369 		.maxlen		= sizeof(unsigned long),
2370 		.mode		= 0644,
2371 		.proc_handler	= mmap_min_addr_handler,
2372 	},
2373 #endif
2374 #ifdef CONFIG_NUMA
2375 	{
2376 		.procname	= "numa_zonelist_order",
2377 		.data		= &numa_zonelist_order,
2378 		.maxlen		= NUMA_ZONELIST_ORDER_LEN,
2379 		.mode		= 0644,
2380 		.proc_handler	= numa_zonelist_order_handler,
2381 	},
2382 #endif
2383 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
2384    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
2385 	{
2386 		.procname	= "vdso_enabled",
2387 #ifdef CONFIG_X86_32
2388 		.data		= &vdso32_enabled,
2389 		.maxlen		= sizeof(vdso32_enabled),
2390 #else
2391 		.data		= &vdso_enabled,
2392 		.maxlen		= sizeof(vdso_enabled),
2393 #endif
2394 		.mode		= 0644,
2395 		.proc_handler	= proc_dointvec,
2396 		.extra1		= SYSCTL_ZERO,
2397 	},
2398 #endif
2399 #ifdef CONFIG_MEMORY_FAILURE
2400 	{
2401 		.procname	= "memory_failure_early_kill",
2402 		.data		= &sysctl_memory_failure_early_kill,
2403 		.maxlen		= sizeof(sysctl_memory_failure_early_kill),
2404 		.mode		= 0644,
2405 		.proc_handler	= proc_dointvec_minmax,
2406 		.extra1		= SYSCTL_ZERO,
2407 		.extra2		= SYSCTL_ONE,
2408 	},
2409 	{
2410 		.procname	= "memory_failure_recovery",
2411 		.data		= &sysctl_memory_failure_recovery,
2412 		.maxlen		= sizeof(sysctl_memory_failure_recovery),
2413 		.mode		= 0644,
2414 		.proc_handler	= proc_dointvec_minmax,
2415 		.extra1		= SYSCTL_ZERO,
2416 		.extra2		= SYSCTL_ONE,
2417 	},
2418 #endif
2419 	{
2420 		.procname	= "user_reserve_kbytes",
2421 		.data		= &sysctl_user_reserve_kbytes,
2422 		.maxlen		= sizeof(sysctl_user_reserve_kbytes),
2423 		.mode		= 0644,
2424 		.proc_handler	= proc_doulongvec_minmax,
2425 	},
2426 	{
2427 		.procname	= "admin_reserve_kbytes",
2428 		.data		= &sysctl_admin_reserve_kbytes,
2429 		.maxlen		= sizeof(sysctl_admin_reserve_kbytes),
2430 		.mode		= 0644,
2431 		.proc_handler	= proc_doulongvec_minmax,
2432 	},
2433 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
2434 	{
2435 		.procname	= "mmap_rnd_bits",
2436 		.data		= &mmap_rnd_bits,
2437 		.maxlen		= sizeof(mmap_rnd_bits),
2438 		.mode		= 0600,
2439 		.proc_handler	= proc_dointvec_minmax,
2440 		.extra1		= (void *)&mmap_rnd_bits_min,
2441 		.extra2		= (void *)&mmap_rnd_bits_max,
2442 	},
2443 #endif
2444 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
2445 	{
2446 		.procname	= "mmap_rnd_compat_bits",
2447 		.data		= &mmap_rnd_compat_bits,
2448 		.maxlen		= sizeof(mmap_rnd_compat_bits),
2449 		.mode		= 0600,
2450 		.proc_handler	= proc_dointvec_minmax,
2451 		.extra1		= (void *)&mmap_rnd_compat_bits_min,
2452 		.extra2		= (void *)&mmap_rnd_compat_bits_max,
2453 	},
2454 #endif
2455 #ifdef CONFIG_USERFAULTFD
2456 	{
2457 		.procname	= "unprivileged_userfaultfd",
2458 		.data		= &sysctl_unprivileged_userfaultfd,
2459 		.maxlen		= sizeof(sysctl_unprivileged_userfaultfd),
2460 		.mode		= 0644,
2461 		.proc_handler	= proc_dointvec_minmax,
2462 		.extra1		= SYSCTL_ZERO,
2463 		.extra2		= SYSCTL_ONE,
2464 	},
2465 #endif
2466 	{ }
2467 };
2468 
2469 static struct ctl_table debug_table[] = {
2470 #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
2471 	{
2472 		.procname	= "exception-trace",
2473 		.data		= &show_unhandled_signals,
2474 		.maxlen		= sizeof(int),
2475 		.mode		= 0644,
2476 		.proc_handler	= proc_dointvec
2477 	},
2478 #endif
2479 	{ }
2480 };
2481 
2482 static struct ctl_table dev_table[] = {
2483 	{ }
2484 };
2485 
2486 DECLARE_SYSCTL_BASE(kernel, kern_table);
2487 DECLARE_SYSCTL_BASE(vm, vm_table);
2488 DECLARE_SYSCTL_BASE(debug, debug_table);
2489 DECLARE_SYSCTL_BASE(dev, dev_table);
2490 
sysctl_init_bases(void)2491 int __init sysctl_init_bases(void)
2492 {
2493 	register_sysctl_base(kernel);
2494 	register_sysctl_base(vm);
2495 	register_sysctl_base(debug);
2496 	register_sysctl_base(dev);
2497 
2498 	return 0;
2499 }
2500 #endif /* CONFIG_SYSCTL */
2501 /*
2502  * No sense putting this after each symbol definition, twice,
2503  * exception granted :-)
2504  */
2505 EXPORT_SYMBOL(proc_dobool);
2506 EXPORT_SYMBOL(proc_dointvec);
2507 EXPORT_SYMBOL(proc_douintvec);
2508 EXPORT_SYMBOL(proc_dointvec_jiffies);
2509 EXPORT_SYMBOL(proc_dointvec_minmax);
2510 EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
2511 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2512 EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2513 EXPORT_SYMBOL(proc_dostring);
2514 EXPORT_SYMBOL(proc_doulongvec_minmax);
2515 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
2516 EXPORT_SYMBOL(proc_do_large_bitmap);
2517