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