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
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
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 */
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 */
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
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
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 */
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 */
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 */
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
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
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
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
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
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
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
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
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
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 */
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 */
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 */
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 */
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
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 */
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, ¶m);
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
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 */
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, ¶m);
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 */
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, ¶m);
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
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
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
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 */
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 */
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
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
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
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
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 */
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
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, ¶m);
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 */
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 */
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
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 */
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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)
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 "" 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
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
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.