1 // SPDX-License-Identifier: GPL-2.0-only
3 * sysctl.c: General linux system control interface
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
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
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
22 #include <linux/module.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>
37 #include <linux/init.h>
38 #include <linux/kernel.h>
39 #include <linux/kobject.h>
40 #include <linux/net.h>
41 #include <linux/sysrq.h>
42 #include <linux/highuid.h>
43 #include <linux/writeback.h>
44 #include <linux/ratelimit.h>
45 #include <linux/compaction.h>
46 #include <linux/hugetlb.h>
47 #include <linux/initrd.h>
48 #include <linux/key.h>
49 #include <linux/times.h>
50 #include <linux/limits.h>
51 #include <linux/dcache.h>
52 #include <linux/syscalls.h>
53 #include <linux/vmstat.h>
54 #include <linux/nfs_fs.h>
55 #include <linux/acpi.h>
56 #include <linux/reboot.h>
57 #include <linux/ftrace.h>
58 #include <linux/perf_event.h>
59 #include <linux/oom.h>
60 #include <linux/kmod.h>
61 #include <linux/capability.h>
62 #include <linux/binfmts.h>
63 #include <linux/sched/sysctl.h>
64 #include <linux/mount.h>
65 #include <linux/userfaultfd_k.h>
66 #include <linux/pid.h>
68 #include "../lib/kstrtox.h"
70 #include <linux/uaccess.h>
71 #include <asm/processor.h>
75 #include <asm/stacktrace.h>
79 #include <asm/setup.h>
81 #ifdef CONFIG_RT_MUTEXES
82 #include <linux/rtmutex.h>
85 /* shared constants to be used in various sysctls */
86 const int sysctl_vals
[] = { 0, 1, 2, 3, 4, 100, 200, 1000, 3000, INT_MAX
, 65535, -1 };
87 EXPORT_SYMBOL(sysctl_vals
);
89 const unsigned long sysctl_long_vals
[] = { 0, 1, LONG_MAX
};
90 EXPORT_SYMBOL_GPL(sysctl_long_vals
);
92 #if defined(CONFIG_SYSCTL)
94 /* Constants used for minimum and maximum */
96 #ifdef CONFIG_PERF_EVENTS
97 static const int six_hundred_forty_kb
= 640 * 1024;
101 static const int ngroups_max
= NGROUPS_MAX
;
102 static const int cap_last_cap
= CAP_LAST_CAP
;
104 #ifdef CONFIG_PROC_SYSCTL
107 * enum sysctl_writes_mode - supported sysctl write modes
109 * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
110 * to be written, and multiple writes on the same sysctl file descriptor
111 * will rewrite the sysctl value, regardless of file position. No warning
112 * is issued when the initial position is not 0.
113 * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
115 * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
116 * file position 0 and the value must be fully contained in the buffer
117 * sent to the write syscall. If dealing with strings respect the file
118 * position, but restrict this to the max length of the buffer, anything
119 * passed the max length will be ignored. Multiple writes will append
122 * These write modes control how current file position affects the behavior of
123 * updating sysctl values through the proc interface on each write.
125 enum sysctl_writes_mode
{
126 SYSCTL_WRITES_LEGACY
= -1,
127 SYSCTL_WRITES_WARN
= 0,
128 SYSCTL_WRITES_STRICT
= 1,
131 static enum sysctl_writes_mode sysctl_writes_strict
= SYSCTL_WRITES_STRICT
;
132 #endif /* CONFIG_PROC_SYSCTL */
134 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
135 defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
136 int sysctl_legacy_va_layout
;
139 #endif /* CONFIG_SYSCTL */
145 #ifdef CONFIG_PROC_SYSCTL
147 static int _proc_do_string(char *data
, int maxlen
, int write
,
148 char *buffer
, size_t *lenp
, loff_t
*ppos
)
153 if (!data
|| !maxlen
|| !*lenp
) {
159 if (sysctl_writes_strict
== SYSCTL_WRITES_STRICT
) {
160 /* Only continue writes not past the end of buffer. */
162 if (len
> maxlen
- 1)
169 /* Start writing from beginning of buffer. */
175 while ((p
- buffer
) < *lenp
&& len
< maxlen
- 1) {
177 if (c
== 0 || c
== '\n')
198 memcpy(buffer
, data
, len
);
209 static void warn_sysctl_write(struct ctl_table
*table
)
211 pr_warn_once("%s wrote to %s when file position was not 0!\n"
212 "This will not be supported in the future. To silence this\n"
213 "warning, set kernel.sysctl_writes_strict = -1\n",
214 current
->comm
, table
->procname
);
218 * proc_first_pos_non_zero_ignore - check if first position is allowed
219 * @ppos: file position
220 * @table: the sysctl table
222 * Returns true if the first position is non-zero and the sysctl_writes_strict
223 * mode indicates this is not allowed for numeric input types. String proc
224 * handlers can ignore the return value.
226 static bool proc_first_pos_non_zero_ignore(loff_t
*ppos
,
227 struct ctl_table
*table
)
232 switch (sysctl_writes_strict
) {
233 case SYSCTL_WRITES_STRICT
:
235 case SYSCTL_WRITES_WARN
:
236 warn_sysctl_write(table
);
244 * proc_dostring - read a string sysctl
245 * @table: the sysctl table
246 * @write: %TRUE if this is a write to the sysctl file
247 * @buffer: the user buffer
248 * @lenp: the size of the user buffer
249 * @ppos: file position
251 * Reads/writes a string from/to the user buffer. If the kernel
252 * buffer provided is not large enough to hold the string, the
253 * string is truncated. The copied string is %NULL-terminated.
254 * If the string is being read by the user process, it is copied
255 * and a newline '\n' is added. It is truncated if the buffer is
258 * Returns 0 on success.
260 int proc_dostring(struct ctl_table
*table
, int write
,
261 void *buffer
, size_t *lenp
, loff_t
*ppos
)
264 proc_first_pos_non_zero_ignore(ppos
, table
);
266 return _proc_do_string(table
->data
, table
->maxlen
, write
, buffer
, lenp
,
270 static void proc_skip_spaces(char **buf
, size_t *size
)
280 static void proc_skip_char(char **buf
, size_t *size
, const char v
)
291 * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
294 * @cp: kernel buffer containing the string to parse
295 * @endp: pointer to store the trailing characters
296 * @base: the base to use
297 * @res: where the parsed integer will be stored
299 * In case of success 0 is returned and @res will contain the parsed integer,
300 * @endp will hold any trailing characters.
301 * This function will fail the parse on overflow. If there wasn't an overflow
302 * the function will defer the decision what characters count as invalid to the
305 static int strtoul_lenient(const char *cp
, char **endp
, unsigned int base
,
308 unsigned long long result
;
311 cp
= _parse_integer_fixup_radix(cp
, &base
);
312 rv
= _parse_integer(cp
, base
, &result
);
313 if ((rv
& KSTRTOX_OVERFLOW
) || (result
!= (unsigned long)result
))
321 *res
= (unsigned long)result
;
327 * proc_get_long - reads an ASCII formatted integer from a user buffer
329 * @buf: a kernel buffer
330 * @size: size of the kernel buffer
331 * @val: this is where the number will be stored
332 * @neg: set to %TRUE if number is negative
333 * @perm_tr: a vector which contains the allowed trailers
334 * @perm_tr_len: size of the perm_tr vector
335 * @tr: pointer to store the trailer character
337 * In case of success %0 is returned and @buf and @size are updated with
338 * the amount of bytes read. If @tr is non-NULL and a trailing
339 * character exists (size is non-zero after returning from this
340 * function), @tr is updated with the trailing character.
342 static int proc_get_long(char **buf
, size_t *size
,
343 unsigned long *val
, bool *neg
,
344 const char *perm_tr
, unsigned perm_tr_len
, char *tr
)
346 char *p
, tmp
[TMPBUFLEN
];
352 if (len
> TMPBUFLEN
- 1)
355 memcpy(tmp
, *buf
, len
);
359 if (*p
== '-' && *size
> 1) {
367 if (strtoul_lenient(p
, &p
, 0, val
))
372 /* We don't know if the next char is whitespace thus we may accept
373 * invalid integers (e.g. 1234...a) or two integers instead of one
374 * (e.g. 123...1). So lets not allow such large numbers. */
375 if (len
== TMPBUFLEN
- 1)
378 if (len
< *size
&& perm_tr_len
&& !memchr(perm_tr
, *p
, perm_tr_len
))
381 if (tr
&& (len
< *size
))
391 * proc_put_long - converts an integer to a decimal ASCII formatted string
393 * @buf: the user buffer
394 * @size: the size of the user buffer
395 * @val: the integer to be converted
396 * @neg: sign of the number, %TRUE for negative
398 * In case of success @buf and @size are updated with the amount of bytes
401 static void proc_put_long(void **buf
, size_t *size
, unsigned long val
, bool neg
)
404 char tmp
[TMPBUFLEN
], *p
= tmp
;
406 sprintf(p
, "%s%lu", neg
? "-" : "", val
);
410 memcpy(*buf
, tmp
, len
);
416 static void proc_put_char(void **buf
, size_t *size
, char c
)
419 char **buffer
= (char **)buf
;
428 static int do_proc_dobool_conv(bool *negp
, unsigned long *lvalp
,
430 int write
, void *data
)
433 *(bool *)valp
= *lvalp
;
435 int val
= *(bool *)valp
;
437 *lvalp
= (unsigned long)val
;
443 static int do_proc_dointvec_conv(bool *negp
, unsigned long *lvalp
,
445 int write
, void *data
)
449 if (*lvalp
> (unsigned long) INT_MAX
+ 1)
451 WRITE_ONCE(*valp
, -*lvalp
);
453 if (*lvalp
> (unsigned long) INT_MAX
)
455 WRITE_ONCE(*valp
, *lvalp
);
458 int val
= READ_ONCE(*valp
);
461 *lvalp
= -(unsigned long)val
;
464 *lvalp
= (unsigned long)val
;
470 static int do_proc_douintvec_conv(unsigned long *lvalp
,
472 int write
, void *data
)
475 if (*lvalp
> UINT_MAX
)
477 WRITE_ONCE(*valp
, *lvalp
);
479 unsigned int val
= READ_ONCE(*valp
);
480 *lvalp
= (unsigned long)val
;
485 static const char proc_wspace_sep
[] = { ' ', '\t', '\n' };
487 static int __do_proc_dointvec(void *tbl_data
, struct ctl_table
*table
,
488 int write
, void *buffer
,
489 size_t *lenp
, loff_t
*ppos
,
490 int (*conv
)(bool *negp
, unsigned long *lvalp
, int *valp
,
491 int write
, void *data
),
494 int *i
, vleft
, first
= 1, err
= 0;
498 if (!tbl_data
|| !table
->maxlen
|| !*lenp
|| (*ppos
&& !write
)) {
503 i
= (int *) tbl_data
;
504 vleft
= table
->maxlen
/ sizeof(*i
);
508 conv
= do_proc_dointvec_conv
;
511 if (proc_first_pos_non_zero_ignore(ppos
, table
))
514 if (left
> PAGE_SIZE
- 1)
515 left
= PAGE_SIZE
- 1;
519 for (; left
&& vleft
--; i
++, first
=0) {
524 proc_skip_spaces(&p
, &left
);
528 err
= proc_get_long(&p
, &left
, &lval
, &neg
,
530 sizeof(proc_wspace_sep
), NULL
);
533 if (conv(&neg
, &lval
, i
, 1, data
)) {
538 if (conv(&neg
, &lval
, i
, 0, data
)) {
543 proc_put_char(&buffer
, &left
, '\t');
544 proc_put_long(&buffer
, &left
, lval
, neg
);
548 if (!write
&& !first
&& left
&& !err
)
549 proc_put_char(&buffer
, &left
, '\n');
550 if (write
&& !err
&& left
)
551 proc_skip_spaces(&p
, &left
);
553 return err
? : -EINVAL
;
560 static int do_proc_dointvec(struct ctl_table
*table
, int write
,
561 void *buffer
, size_t *lenp
, loff_t
*ppos
,
562 int (*conv
)(bool *negp
, unsigned long *lvalp
, int *valp
,
563 int write
, void *data
),
566 return __do_proc_dointvec(table
->data
, table
, write
,
567 buffer
, lenp
, ppos
, conv
, data
);
570 static int do_proc_douintvec_w(unsigned int *tbl_data
,
571 struct ctl_table
*table
,
573 size_t *lenp
, loff_t
*ppos
,
574 int (*conv
)(unsigned long *lvalp
,
576 int write
, void *data
),
587 if (proc_first_pos_non_zero_ignore(ppos
, table
))
590 if (left
> PAGE_SIZE
- 1)
591 left
= PAGE_SIZE
- 1;
593 proc_skip_spaces(&p
, &left
);
599 err
= proc_get_long(&p
, &left
, &lval
, &neg
,
601 sizeof(proc_wspace_sep
), NULL
);
607 if (conv(&lval
, tbl_data
, 1, data
)) {
613 proc_skip_spaces(&p
, &left
);
621 /* This is in keeping with old __do_proc_dointvec() */
627 static int do_proc_douintvec_r(unsigned int *tbl_data
, void *buffer
,
628 size_t *lenp
, loff_t
*ppos
,
629 int (*conv
)(unsigned long *lvalp
,
631 int write
, void *data
),
640 if (conv(&lval
, tbl_data
, 0, data
)) {
645 proc_put_long(&buffer
, &left
, lval
, false);
649 proc_put_char(&buffer
, &left
, '\n');
658 static int __do_proc_douintvec(void *tbl_data
, struct ctl_table
*table
,
659 int write
, void *buffer
,
660 size_t *lenp
, loff_t
*ppos
,
661 int (*conv
)(unsigned long *lvalp
,
663 int write
, void *data
),
666 unsigned int *i
, vleft
;
668 if (!tbl_data
|| !table
->maxlen
|| !*lenp
|| (*ppos
&& !write
)) {
673 i
= (unsigned int *) tbl_data
;
674 vleft
= table
->maxlen
/ sizeof(*i
);
677 * Arrays are not supported, keep this simple. *Do not* add
686 conv
= do_proc_douintvec_conv
;
689 return do_proc_douintvec_w(i
, table
, buffer
, lenp
, ppos
,
691 return do_proc_douintvec_r(i
, buffer
, lenp
, ppos
, conv
, data
);
694 int do_proc_douintvec(struct ctl_table
*table
, int write
,
695 void *buffer
, size_t *lenp
, loff_t
*ppos
,
696 int (*conv
)(unsigned long *lvalp
,
698 int write
, void *data
),
701 return __do_proc_douintvec(table
->data
, table
, write
,
702 buffer
, lenp
, ppos
, conv
, data
);
706 * proc_dobool - read/write a bool
707 * @table: the sysctl table
708 * @write: %TRUE if this is a write to the sysctl file
709 * @buffer: the user buffer
710 * @lenp: the size of the user buffer
711 * @ppos: file position
713 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
714 * values from/to the user buffer, treated as an ASCII string.
716 * Returns 0 on success.
718 int proc_dobool(struct ctl_table
*table
, int write
, void *buffer
,
719 size_t *lenp
, loff_t
*ppos
)
721 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
722 do_proc_dobool_conv
, NULL
);
726 * proc_dointvec - read a vector of integers
727 * @table: the sysctl table
728 * @write: %TRUE if this is a write to the sysctl file
729 * @buffer: the user buffer
730 * @lenp: the size of the user buffer
731 * @ppos: file position
733 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
734 * values from/to the user buffer, treated as an ASCII string.
736 * Returns 0 on success.
738 int proc_dointvec(struct ctl_table
*table
, int write
, void *buffer
,
739 size_t *lenp
, loff_t
*ppos
)
741 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
, NULL
, NULL
);
744 #ifdef CONFIG_COMPACTION
745 static int proc_dointvec_minmax_warn_RT_change(struct ctl_table
*table
,
746 int write
, void *buffer
, size_t *lenp
, loff_t
*ppos
)
750 if (!IS_ENABLED(CONFIG_PREEMPT_RT
) || !write
)
751 return proc_dointvec_minmax(table
, write
, buffer
, lenp
, ppos
);
753 old
= *(int *)table
->data
;
754 ret
= proc_dointvec_minmax(table
, write
, buffer
, lenp
, ppos
);
757 if (old
!= *(int *)table
->data
)
758 pr_warn_once("sysctl attribute %s changed by %s[%d]\n",
759 table
->procname
, current
->comm
,
760 task_pid_nr(current
));
766 * proc_douintvec - read a vector of unsigned integers
767 * @table: the sysctl table
768 * @write: %TRUE if this is a write to the sysctl file
769 * @buffer: the user buffer
770 * @lenp: the size of the user buffer
771 * @ppos: file position
773 * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
774 * values from/to the user buffer, treated as an ASCII string.
776 * Returns 0 on success.
778 int proc_douintvec(struct ctl_table
*table
, int write
, void *buffer
,
779 size_t *lenp
, loff_t
*ppos
)
781 return do_proc_douintvec(table
, write
, buffer
, lenp
, ppos
,
782 do_proc_douintvec_conv
, NULL
);
786 * Taint values can only be increased
787 * This means we can safely use a temporary.
789 static int proc_taint(struct ctl_table
*table
, int write
,
790 void *buffer
, size_t *lenp
, loff_t
*ppos
)
793 unsigned long tmptaint
= get_taint();
796 if (write
&& !capable(CAP_SYS_ADMIN
))
801 err
= proc_doulongvec_minmax(&t
, write
, buffer
, lenp
, ppos
);
809 * If we are relying on panic_on_taint not producing
810 * false positives due to userspace input, bail out
811 * before setting the requested taint flags.
813 if (panic_on_taint_nousertaint
&& (tmptaint
& panic_on_taint
))
817 * Poor man's atomic or. Not worth adding a primitive
818 * to everyone's atomic.h for this
820 for (i
= 0; i
< TAINT_FLAGS_COUNT
; i
++)
821 if ((1UL << i
) & tmptaint
)
822 add_taint(i
, LOCKDEP_STILL_OK
);
829 * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
830 * @min: pointer to minimum allowable value
831 * @max: pointer to maximum allowable value
833 * The do_proc_dointvec_minmax_conv_param structure provides the
834 * minimum and maximum values for doing range checking for those sysctl
835 * parameters that use the proc_dointvec_minmax() handler.
837 struct do_proc_dointvec_minmax_conv_param
{
842 static int do_proc_dointvec_minmax_conv(bool *negp
, unsigned long *lvalp
,
844 int write
, void *data
)
847 struct do_proc_dointvec_minmax_conv_param
*param
= data
;
849 * If writing, first do so via a temporary local int so we can
850 * bounds-check it before touching *valp.
852 int *ip
= write
? &tmp
: valp
;
854 ret
= do_proc_dointvec_conv(negp
, lvalp
, ip
, write
, data
);
859 if ((param
->min
&& *param
->min
> tmp
) ||
860 (param
->max
&& *param
->max
< tmp
))
862 WRITE_ONCE(*valp
, tmp
);
869 * proc_dointvec_minmax - read a vector of integers with min/max values
870 * @table: the sysctl table
871 * @write: %TRUE if this is a write to the sysctl file
872 * @buffer: the user buffer
873 * @lenp: the size of the user buffer
874 * @ppos: file position
876 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
877 * values from/to the user buffer, treated as an ASCII string.
879 * This routine will ensure the values are within the range specified by
880 * table->extra1 (min) and table->extra2 (max).
882 * Returns 0 on success or -EINVAL on write when the range check fails.
884 int proc_dointvec_minmax(struct ctl_table
*table
, int write
,
885 void *buffer
, size_t *lenp
, loff_t
*ppos
)
887 struct do_proc_dointvec_minmax_conv_param param
= {
888 .min
= (int *) table
->extra1
,
889 .max
= (int *) table
->extra2
,
891 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
892 do_proc_dointvec_minmax_conv
, ¶m
);
896 * struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure
897 * @min: pointer to minimum allowable value
898 * @max: pointer to maximum allowable value
900 * The do_proc_douintvec_minmax_conv_param structure provides the
901 * minimum and maximum values for doing range checking for those sysctl
902 * parameters that use the proc_douintvec_minmax() handler.
904 struct do_proc_douintvec_minmax_conv_param
{
909 static int do_proc_douintvec_minmax_conv(unsigned long *lvalp
,
911 int write
, void *data
)
915 struct do_proc_douintvec_minmax_conv_param
*param
= data
;
916 /* write via temporary local uint for bounds-checking */
917 unsigned int *up
= write
? &tmp
: valp
;
919 ret
= do_proc_douintvec_conv(lvalp
, up
, write
, data
);
924 if ((param
->min
&& *param
->min
> tmp
) ||
925 (param
->max
&& *param
->max
< tmp
))
928 WRITE_ONCE(*valp
, tmp
);
935 * proc_douintvec_minmax - read a vector of unsigned ints with min/max values
936 * @table: the sysctl table
937 * @write: %TRUE if this is a write to the sysctl file
938 * @buffer: the user buffer
939 * @lenp: the size of the user buffer
940 * @ppos: file position
942 * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
943 * values from/to the user buffer, treated as an ASCII string. Negative
944 * strings are not allowed.
946 * This routine will ensure the values are within the range specified by
947 * table->extra1 (min) and table->extra2 (max). There is a final sanity
948 * check for UINT_MAX to avoid having to support wrap around uses from
951 * Returns 0 on success or -ERANGE on write when the range check fails.
953 int proc_douintvec_minmax(struct ctl_table
*table
, int write
,
954 void *buffer
, size_t *lenp
, loff_t
*ppos
)
956 struct do_proc_douintvec_minmax_conv_param param
= {
957 .min
= (unsigned int *) table
->extra1
,
958 .max
= (unsigned int *) table
->extra2
,
960 return do_proc_douintvec(table
, write
, buffer
, lenp
, ppos
,
961 do_proc_douintvec_minmax_conv
, ¶m
);
965 * proc_dou8vec_minmax - read a vector of unsigned chars with min/max values
966 * @table: the sysctl table
967 * @write: %TRUE if this is a write to the sysctl file
968 * @buffer: the user buffer
969 * @lenp: the size of the user buffer
970 * @ppos: file position
972 * Reads/writes up to table->maxlen/sizeof(u8) unsigned chars
973 * values from/to the user buffer, treated as an ASCII string. Negative
974 * strings are not allowed.
976 * This routine will ensure the values are within the range specified by
977 * table->extra1 (min) and table->extra2 (max).
979 * Returns 0 on success or an error on write when the range check fails.
981 int proc_dou8vec_minmax(struct ctl_table
*table
, int write
,
982 void *buffer
, size_t *lenp
, loff_t
*ppos
)
984 struct ctl_table tmp
;
985 unsigned int min
= 0, max
= 255U, val
;
986 u8
*data
= table
->data
;
987 struct do_proc_douintvec_minmax_conv_param param
= {
993 /* Do not support arrays yet. */
994 if (table
->maxlen
!= sizeof(u8
))
998 min
= *(unsigned int *) table
->extra1
;
1002 if (table
->extra2
) {
1003 max
= *(unsigned int *) table
->extra2
;
1010 tmp
.maxlen
= sizeof(val
);
1012 val
= READ_ONCE(*data
);
1013 res
= do_proc_douintvec(&tmp
, write
, buffer
, lenp
, ppos
,
1014 do_proc_douintvec_minmax_conv
, ¶m
);
1018 WRITE_ONCE(*data
, val
);
1021 EXPORT_SYMBOL_GPL(proc_dou8vec_minmax
);
1023 #ifdef CONFIG_MAGIC_SYSRQ
1024 static int sysrq_sysctl_handler(struct ctl_table
*table
, int write
,
1025 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1031 ret
= __do_proc_dointvec(&tmp
, table
, write
, buffer
,
1032 lenp
, ppos
, NULL
, NULL
);
1037 sysrq_toggle_support(tmp
);
1043 static int __do_proc_doulongvec_minmax(void *data
, struct ctl_table
*table
,
1044 int write
, void *buffer
, size_t *lenp
, loff_t
*ppos
,
1045 unsigned long convmul
, unsigned long convdiv
)
1047 unsigned long *i
, *min
, *max
;
1048 int vleft
, first
= 1, err
= 0;
1052 if (!data
|| !table
->maxlen
|| !*lenp
|| (*ppos
&& !write
)) {
1058 min
= table
->extra1
;
1059 max
= table
->extra2
;
1060 vleft
= table
->maxlen
/ sizeof(unsigned long);
1064 if (proc_first_pos_non_zero_ignore(ppos
, table
))
1067 if (left
> PAGE_SIZE
- 1)
1068 left
= PAGE_SIZE
- 1;
1072 for (; left
&& vleft
--; i
++, first
= 0) {
1078 proc_skip_spaces(&p
, &left
);
1082 err
= proc_get_long(&p
, &left
, &val
, &neg
,
1084 sizeof(proc_wspace_sep
), NULL
);
1090 val
= convmul
* val
/ convdiv
;
1091 if ((min
&& val
< *min
) || (max
&& val
> *max
)) {
1095 WRITE_ONCE(*i
, val
);
1097 val
= convdiv
* READ_ONCE(*i
) / convmul
;
1099 proc_put_char(&buffer
, &left
, '\t');
1100 proc_put_long(&buffer
, &left
, val
, false);
1104 if (!write
&& !first
&& left
&& !err
)
1105 proc_put_char(&buffer
, &left
, '\n');
1107 proc_skip_spaces(&p
, &left
);
1109 return err
? : -EINVAL
;
1116 static int do_proc_doulongvec_minmax(struct ctl_table
*table
, int write
,
1117 void *buffer
, size_t *lenp
, loff_t
*ppos
, unsigned long convmul
,
1118 unsigned long convdiv
)
1120 return __do_proc_doulongvec_minmax(table
->data
, table
, write
,
1121 buffer
, lenp
, ppos
, convmul
, convdiv
);
1125 * proc_doulongvec_minmax - read a vector of long integers with min/max values
1126 * @table: the sysctl table
1127 * @write: %TRUE if this is a write to the sysctl file
1128 * @buffer: the user buffer
1129 * @lenp: the size of the user buffer
1130 * @ppos: file position
1132 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1133 * values from/to the user buffer, treated as an ASCII string.
1135 * This routine will ensure the values are within the range specified by
1136 * table->extra1 (min) and table->extra2 (max).
1138 * Returns 0 on success.
1140 int proc_doulongvec_minmax(struct ctl_table
*table
, int write
,
1141 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1143 return do_proc_doulongvec_minmax(table
, write
, buffer
, lenp
, ppos
, 1l, 1l);
1147 * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
1148 * @table: the sysctl table
1149 * @write: %TRUE if this is a write to the sysctl file
1150 * @buffer: the user buffer
1151 * @lenp: the size of the user buffer
1152 * @ppos: file position
1154 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1155 * values from/to the user buffer, treated as an ASCII string. The values
1156 * are treated as milliseconds, and converted to jiffies when they are stored.
1158 * This routine will ensure the values are within the range specified by
1159 * table->extra1 (min) and table->extra2 (max).
1161 * Returns 0 on success.
1163 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table
*table
, int write
,
1164 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1166 return do_proc_doulongvec_minmax(table
, write
, buffer
,
1167 lenp
, ppos
, HZ
, 1000l);
1171 static int do_proc_dointvec_jiffies_conv(bool *negp
, unsigned long *lvalp
,
1173 int write
, void *data
)
1176 if (*lvalp
> INT_MAX
/ HZ
)
1179 WRITE_ONCE(*valp
, -*lvalp
* HZ
);
1181 WRITE_ONCE(*valp
, *lvalp
* HZ
);
1183 int val
= READ_ONCE(*valp
);
1187 lval
= -(unsigned long)val
;
1190 lval
= (unsigned long)val
;
1197 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp
, unsigned long *lvalp
,
1199 int write
, void *data
)
1202 if (USER_HZ
< HZ
&& *lvalp
> (LONG_MAX
/ HZ
) * USER_HZ
)
1204 *valp
= clock_t_to_jiffies(*negp
? -*lvalp
: *lvalp
);
1210 lval
= -(unsigned long)val
;
1213 lval
= (unsigned long)val
;
1215 *lvalp
= jiffies_to_clock_t(lval
);
1220 static int do_proc_dointvec_ms_jiffies_conv(bool *negp
, unsigned long *lvalp
,
1222 int write
, void *data
)
1225 unsigned long jif
= msecs_to_jiffies(*negp
? -*lvalp
: *lvalp
);
1229 WRITE_ONCE(*valp
, (int)jif
);
1231 int val
= READ_ONCE(*valp
);
1235 lval
= -(unsigned long)val
;
1238 lval
= (unsigned long)val
;
1240 *lvalp
= jiffies_to_msecs(lval
);
1245 static int do_proc_dointvec_ms_jiffies_minmax_conv(bool *negp
, unsigned long *lvalp
,
1246 int *valp
, int write
, void *data
)
1249 struct do_proc_dointvec_minmax_conv_param
*param
= data
;
1251 * If writing, first do so via a temporary local int so we can
1252 * bounds-check it before touching *valp.
1254 int *ip
= write
? &tmp
: valp
;
1256 ret
= do_proc_dointvec_ms_jiffies_conv(negp
, lvalp
, ip
, write
, data
);
1261 if ((param
->min
&& *param
->min
> tmp
) ||
1262 (param
->max
&& *param
->max
< tmp
))
1270 * proc_dointvec_jiffies - read a vector of integers as seconds
1271 * @table: the sysctl table
1272 * @write: %TRUE if this is a write to the sysctl file
1273 * @buffer: the user buffer
1274 * @lenp: the size of the user buffer
1275 * @ppos: file position
1277 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1278 * values from/to the user buffer, treated as an ASCII string.
1279 * The values read are assumed to be in seconds, and are converted into
1282 * Returns 0 on success.
1284 int proc_dointvec_jiffies(struct ctl_table
*table
, int write
,
1285 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1287 return do_proc_dointvec(table
,write
,buffer
,lenp
,ppos
,
1288 do_proc_dointvec_jiffies_conv
,NULL
);
1291 int proc_dointvec_ms_jiffies_minmax(struct ctl_table
*table
, int write
,
1292 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1294 struct do_proc_dointvec_minmax_conv_param param
= {
1295 .min
= (int *) table
->extra1
,
1296 .max
= (int *) table
->extra2
,
1298 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
1299 do_proc_dointvec_ms_jiffies_minmax_conv
, ¶m
);
1303 * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
1304 * @table: the sysctl table
1305 * @write: %TRUE if this is a write to the sysctl file
1306 * @buffer: the user buffer
1307 * @lenp: the size of the user buffer
1308 * @ppos: pointer to the file position
1310 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1311 * values from/to the user buffer, treated as an ASCII string.
1312 * The values read are assumed to be in 1/USER_HZ seconds, and
1313 * are converted into jiffies.
1315 * Returns 0 on success.
1317 int proc_dointvec_userhz_jiffies(struct ctl_table
*table
, int write
,
1318 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1320 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
1321 do_proc_dointvec_userhz_jiffies_conv
, NULL
);
1325 * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
1326 * @table: the sysctl table
1327 * @write: %TRUE if this is a write to the sysctl file
1328 * @buffer: the user buffer
1329 * @lenp: the size of the user buffer
1330 * @ppos: file position
1331 * @ppos: the current position in the file
1333 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1334 * values from/to the user buffer, treated as an ASCII string.
1335 * The values read are assumed to be in 1/1000 seconds, and
1336 * are converted into jiffies.
1338 * Returns 0 on success.
1340 int proc_dointvec_ms_jiffies(struct ctl_table
*table
, int write
, void *buffer
,
1341 size_t *lenp
, loff_t
*ppos
)
1343 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
1344 do_proc_dointvec_ms_jiffies_conv
, NULL
);
1347 static int proc_do_cad_pid(struct ctl_table
*table
, int write
, void *buffer
,
1348 size_t *lenp
, loff_t
*ppos
)
1350 struct pid
*new_pid
;
1354 tmp
= pid_vnr(cad_pid
);
1356 r
= __do_proc_dointvec(&tmp
, table
, write
, buffer
,
1357 lenp
, ppos
, NULL
, NULL
);
1361 new_pid
= find_get_pid(tmp
);
1365 put_pid(xchg(&cad_pid
, new_pid
));
1370 * proc_do_large_bitmap - read/write from/to a large bitmap
1371 * @table: the sysctl table
1372 * @write: %TRUE if this is a write to the sysctl file
1373 * @buffer: the user buffer
1374 * @lenp: the size of the user buffer
1375 * @ppos: file position
1377 * The bitmap is stored at table->data and the bitmap length (in bits)
1380 * We use a range comma separated format (e.g. 1,3-4,10-10) so that
1381 * large bitmaps may be represented in a compact manner. Writing into
1382 * the file will clear the bitmap then update it with the given input.
1384 * Returns 0 on success.
1386 int proc_do_large_bitmap(struct ctl_table
*table
, int write
,
1387 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1390 size_t left
= *lenp
;
1391 unsigned long bitmap_len
= table
->maxlen
;
1392 unsigned long *bitmap
= *(unsigned long **) table
->data
;
1393 unsigned long *tmp_bitmap
= NULL
;
1394 char tr_a
[] = { '-', ',', '\n' }, tr_b
[] = { ',', '\n', 0 }, c
;
1396 if (!bitmap
|| !bitmap_len
|| !left
|| (*ppos
&& !write
)) {
1405 if (left
> PAGE_SIZE
- 1) {
1406 left
= PAGE_SIZE
- 1;
1407 /* How much of the buffer we'll skip this pass */
1408 skipped
= *lenp
- left
;
1411 tmp_bitmap
= bitmap_zalloc(bitmap_len
, GFP_KERNEL
);
1414 proc_skip_char(&p
, &left
, '\n');
1415 while (!err
&& left
) {
1416 unsigned long val_a
, val_b
;
1420 /* In case we stop parsing mid-number, we can reset */
1422 err
= proc_get_long(&p
, &left
, &val_a
, &neg
, tr_a
,
1425 * If we consumed the entirety of a truncated buffer or
1426 * only one char is left (may be a "-"), then stop here,
1427 * reset, & come back for more.
1429 if ((left
<= 1) && skipped
) {
1436 if (val_a
>= bitmap_len
|| neg
) {
1448 err
= proc_get_long(&p
, &left
, &val_b
,
1449 &neg
, tr_b
, sizeof(tr_b
),
1452 * If we consumed all of a truncated buffer or
1453 * then stop here, reset, & come back for more.
1455 if (!left
&& skipped
) {
1462 if (val_b
>= bitmap_len
|| neg
||
1473 bitmap_set(tmp_bitmap
, val_a
, val_b
- val_a
+ 1);
1474 proc_skip_char(&p
, &left
, '\n');
1478 unsigned long bit_a
, bit_b
= 0;
1482 bit_a
= find_next_bit(bitmap
, bitmap_len
, bit_b
);
1483 if (bit_a
>= bitmap_len
)
1485 bit_b
= find_next_zero_bit(bitmap
, bitmap_len
,
1489 proc_put_char(&buffer
, &left
, ',');
1490 proc_put_long(&buffer
, &left
, bit_a
, false);
1491 if (bit_a
!= bit_b
) {
1492 proc_put_char(&buffer
, &left
, '-');
1493 proc_put_long(&buffer
, &left
, bit_b
, false);
1498 proc_put_char(&buffer
, &left
, '\n');
1504 bitmap_or(bitmap
, bitmap
, tmp_bitmap
, bitmap_len
);
1506 bitmap_copy(bitmap
, tmp_bitmap
, bitmap_len
);
1512 bitmap_free(tmp_bitmap
);
1516 #else /* CONFIG_PROC_SYSCTL */
1518 int proc_dostring(struct ctl_table
*table
, int write
,
1519 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1524 int proc_dobool(struct ctl_table
*table
, int write
,
1525 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1530 int proc_dointvec(struct ctl_table
*table
, int write
,
1531 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1536 int proc_douintvec(struct ctl_table
*table
, int write
,
1537 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1542 int proc_dointvec_minmax(struct ctl_table
*table
, int write
,
1543 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1548 int proc_douintvec_minmax(struct ctl_table
*table
, int write
,
1549 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1554 int proc_dou8vec_minmax(struct ctl_table
*table
, int write
,
1555 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1560 int proc_dointvec_jiffies(struct ctl_table
*table
, int write
,
1561 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1566 int proc_dointvec_ms_jiffies_minmax(struct ctl_table
*table
, int write
,
1567 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1572 int proc_dointvec_userhz_jiffies(struct ctl_table
*table
, int write
,
1573 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1578 int proc_dointvec_ms_jiffies(struct ctl_table
*table
, int write
,
1579 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1584 int proc_doulongvec_minmax(struct ctl_table
*table
, int write
,
1585 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1590 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table
*table
, int write
,
1591 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1596 int proc_do_large_bitmap(struct ctl_table
*table
, int write
,
1597 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1602 #endif /* CONFIG_PROC_SYSCTL */
1604 #if defined(CONFIG_SYSCTL)
1605 int proc_do_static_key(struct ctl_table
*table
, int write
,
1606 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1608 struct static_key
*key
= (struct static_key
*)table
->data
;
1609 static DEFINE_MUTEX(static_key_mutex
);
1611 struct ctl_table tmp
= {
1613 .maxlen
= sizeof(val
),
1614 .mode
= table
->mode
,
1615 .extra1
= SYSCTL_ZERO
,
1616 .extra2
= SYSCTL_ONE
,
1619 if (write
&& !capable(CAP_SYS_ADMIN
))
1622 mutex_lock(&static_key_mutex
);
1623 val
= static_key_enabled(key
);
1624 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
1625 if (write
&& !ret
) {
1627 static_key_enable(key
);
1629 static_key_disable(key
);
1631 mutex_unlock(&static_key_mutex
);
1635 static struct ctl_table kern_table
[] = {
1637 .procname
= "panic",
1638 .data
= &panic_timeout
,
1639 .maxlen
= sizeof(int),
1641 .proc_handler
= proc_dointvec
,
1643 #ifdef CONFIG_PROC_SYSCTL
1645 .procname
= "tainted",
1646 .maxlen
= sizeof(long),
1648 .proc_handler
= proc_taint
,
1651 .procname
= "sysctl_writes_strict",
1652 .data
= &sysctl_writes_strict
,
1653 .maxlen
= sizeof(int),
1655 .proc_handler
= proc_dointvec_minmax
,
1656 .extra1
= SYSCTL_NEG_ONE
,
1657 .extra2
= SYSCTL_ONE
,
1661 .procname
= "print-fatal-signals",
1662 .data
= &print_fatal_signals
,
1663 .maxlen
= sizeof(int),
1665 .proc_handler
= proc_dointvec
,
1669 .procname
= "reboot-cmd",
1670 .data
= reboot_command
,
1673 .proc_handler
= proc_dostring
,
1676 .procname
= "stop-a",
1677 .data
= &stop_a_enabled
,
1678 .maxlen
= sizeof (int),
1680 .proc_handler
= proc_dointvec
,
1683 .procname
= "scons-poweroff",
1684 .data
= &scons_pwroff
,
1685 .maxlen
= sizeof (int),
1687 .proc_handler
= proc_dointvec
,
1690 #ifdef CONFIG_SPARC64
1692 .procname
= "tsb-ratio",
1693 .data
= &sysctl_tsb_ratio
,
1694 .maxlen
= sizeof (int),
1696 .proc_handler
= proc_dointvec
,
1699 #ifdef CONFIG_PARISC
1701 .procname
= "soft-power",
1702 .data
= &pwrsw_enabled
,
1703 .maxlen
= sizeof (int),
1705 .proc_handler
= proc_dointvec
,
1708 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1710 .procname
= "unaligned-trap",
1711 .data
= &unaligned_enabled
,
1712 .maxlen
= sizeof (int),
1714 .proc_handler
= proc_dointvec
,
1717 #ifdef CONFIG_STACK_TRACER
1719 .procname
= "stack_tracer_enabled",
1720 .data
= &stack_tracer_enabled
,
1721 .maxlen
= sizeof(int),
1723 .proc_handler
= stack_trace_sysctl
,
1726 #ifdef CONFIG_TRACING
1728 .procname
= "ftrace_dump_on_oops",
1729 .data
= &ftrace_dump_on_oops
,
1730 .maxlen
= sizeof(int),
1732 .proc_handler
= proc_dointvec
,
1735 .procname
= "traceoff_on_warning",
1736 .data
= &__disable_trace_on_warning
,
1737 .maxlen
= sizeof(__disable_trace_on_warning
),
1739 .proc_handler
= proc_dointvec
,
1742 .procname
= "tracepoint_printk",
1743 .data
= &tracepoint_printk
,
1744 .maxlen
= sizeof(tracepoint_printk
),
1746 .proc_handler
= tracepoint_printk_sysctl
,
1749 #ifdef CONFIG_MODULES
1751 .procname
= "modprobe",
1752 .data
= &modprobe_path
,
1753 .maxlen
= KMOD_PATH_LEN
,
1755 .proc_handler
= proc_dostring
,
1758 .procname
= "modules_disabled",
1759 .data
= &modules_disabled
,
1760 .maxlen
= sizeof(int),
1762 /* only handle a transition from default "0" to "1" */
1763 .proc_handler
= proc_dointvec_minmax
,
1764 .extra1
= SYSCTL_ONE
,
1765 .extra2
= SYSCTL_ONE
,
1768 #ifdef CONFIG_UEVENT_HELPER
1770 .procname
= "hotplug",
1771 .data
= &uevent_helper
,
1772 .maxlen
= UEVENT_HELPER_PATH_LEN
,
1774 .proc_handler
= proc_dostring
,
1777 #ifdef CONFIG_MAGIC_SYSRQ
1779 .procname
= "sysrq",
1781 .maxlen
= sizeof (int),
1783 .proc_handler
= sysrq_sysctl_handler
,
1786 #ifdef CONFIG_PROC_SYSCTL
1788 .procname
= "cad_pid",
1790 .maxlen
= sizeof (int),
1792 .proc_handler
= proc_do_cad_pid
,
1796 .procname
= "threads-max",
1798 .maxlen
= sizeof(int),
1800 .proc_handler
= sysctl_max_threads
,
1803 .procname
= "usermodehelper",
1805 .child
= usermodehelper_table
,
1808 .procname
= "overflowuid",
1809 .data
= &overflowuid
,
1810 .maxlen
= sizeof(int),
1812 .proc_handler
= proc_dointvec_minmax
,
1813 .extra1
= SYSCTL_ZERO
,
1814 .extra2
= SYSCTL_MAXOLDUID
,
1817 .procname
= "overflowgid",
1818 .data
= &overflowgid
,
1819 .maxlen
= sizeof(int),
1821 .proc_handler
= proc_dointvec_minmax
,
1822 .extra1
= SYSCTL_ZERO
,
1823 .extra2
= SYSCTL_MAXOLDUID
,
1827 .procname
= "userprocess_debug",
1828 .data
= &show_unhandled_signals
,
1829 .maxlen
= sizeof(int),
1831 .proc_handler
= proc_dointvec
,
1835 .procname
= "pid_max",
1837 .maxlen
= sizeof (int),
1839 .proc_handler
= proc_dointvec_minmax
,
1840 .extra1
= &pid_max_min
,
1841 .extra2
= &pid_max_max
,
1844 .procname
= "panic_on_oops",
1845 .data
= &panic_on_oops
,
1846 .maxlen
= sizeof(int),
1848 .proc_handler
= proc_dointvec
,
1851 .procname
= "panic_print",
1852 .data
= &panic_print
,
1853 .maxlen
= sizeof(unsigned long),
1855 .proc_handler
= proc_doulongvec_minmax
,
1858 .procname
= "ngroups_max",
1859 .data
= (void *)&ngroups_max
,
1860 .maxlen
= sizeof (int),
1862 .proc_handler
= proc_dointvec
,
1865 .procname
= "cap_last_cap",
1866 .data
= (void *)&cap_last_cap
,
1867 .maxlen
= sizeof(int),
1869 .proc_handler
= proc_dointvec
,
1871 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
1873 .procname
= "unknown_nmi_panic",
1874 .data
= &unknown_nmi_panic
,
1875 .maxlen
= sizeof (int),
1877 .proc_handler
= proc_dointvec
,
1881 #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \
1882 defined(CONFIG_DEBUG_STACKOVERFLOW)
1884 .procname
= "panic_on_stackoverflow",
1885 .data
= &sysctl_panic_on_stackoverflow
,
1886 .maxlen
= sizeof(int),
1888 .proc_handler
= proc_dointvec
,
1891 #if defined(CONFIG_X86)
1893 .procname
= "panic_on_unrecovered_nmi",
1894 .data
= &panic_on_unrecovered_nmi
,
1895 .maxlen
= sizeof(int),
1897 .proc_handler
= proc_dointvec
,
1900 .procname
= "panic_on_io_nmi",
1901 .data
= &panic_on_io_nmi
,
1902 .maxlen
= sizeof(int),
1904 .proc_handler
= proc_dointvec
,
1907 .procname
= "bootloader_type",
1908 .data
= &bootloader_type
,
1909 .maxlen
= sizeof (int),
1911 .proc_handler
= proc_dointvec
,
1914 .procname
= "bootloader_version",
1915 .data
= &bootloader_version
,
1916 .maxlen
= sizeof (int),
1918 .proc_handler
= proc_dointvec
,
1921 .procname
= "io_delay_type",
1922 .data
= &io_delay_type
,
1923 .maxlen
= sizeof(int),
1925 .proc_handler
= proc_dointvec
,
1928 #if defined(CONFIG_MMU)
1930 .procname
= "randomize_va_space",
1931 .data
= &randomize_va_space
,
1932 .maxlen
= sizeof(int),
1934 .proc_handler
= proc_dointvec
,
1937 #if defined(CONFIG_S390) && defined(CONFIG_SMP)
1939 .procname
= "spin_retry",
1940 .data
= &spin_retry
,
1941 .maxlen
= sizeof (int),
1943 .proc_handler
= proc_dointvec
,
1946 #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
1948 .procname
= "acpi_video_flags",
1949 .data
= &acpi_realmode_flags
,
1950 .maxlen
= sizeof (unsigned long),
1952 .proc_handler
= proc_doulongvec_minmax
,
1955 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1957 .procname
= "ignore-unaligned-usertrap",
1958 .data
= &no_unaligned_warning
,
1959 .maxlen
= sizeof (int),
1961 .proc_handler
= proc_dointvec
,
1966 .procname
= "unaligned-dump-stack",
1967 .data
= &unaligned_dump_stack
,
1968 .maxlen
= sizeof (int),
1970 .proc_handler
= proc_dointvec
,
1973 #ifdef CONFIG_RT_MUTEXES
1975 .procname
= "max_lock_depth",
1976 .data
= &max_lock_depth
,
1977 .maxlen
= sizeof(int),
1979 .proc_handler
= proc_dointvec
,
1986 .child
= key_sysctls
,
1989 #ifdef CONFIG_PERF_EVENTS
1991 * User-space scripts rely on the existence of this file
1992 * as a feature check for perf_events being enabled.
1994 * So it's an ABI, do not remove!
1997 .procname
= "perf_event_paranoid",
1998 .data
= &sysctl_perf_event_paranoid
,
1999 .maxlen
= sizeof(sysctl_perf_event_paranoid
),
2001 .proc_handler
= proc_dointvec
,
2004 .procname
= "perf_event_mlock_kb",
2005 .data
= &sysctl_perf_event_mlock
,
2006 .maxlen
= sizeof(sysctl_perf_event_mlock
),
2008 .proc_handler
= proc_dointvec
,
2011 .procname
= "perf_event_max_sample_rate",
2012 .data
= &sysctl_perf_event_sample_rate
,
2013 .maxlen
= sizeof(sysctl_perf_event_sample_rate
),
2015 .proc_handler
= perf_proc_update_handler
,
2016 .extra1
= SYSCTL_ONE
,
2019 .procname
= "perf_cpu_time_max_percent",
2020 .data
= &sysctl_perf_cpu_time_max_percent
,
2021 .maxlen
= sizeof(sysctl_perf_cpu_time_max_percent
),
2023 .proc_handler
= perf_cpu_time_max_percent_handler
,
2024 .extra1
= SYSCTL_ZERO
,
2025 .extra2
= SYSCTL_ONE_HUNDRED
,
2028 .procname
= "perf_event_max_stack",
2029 .data
= &sysctl_perf_event_max_stack
,
2030 .maxlen
= sizeof(sysctl_perf_event_max_stack
),
2032 .proc_handler
= perf_event_max_stack_handler
,
2033 .extra1
= SYSCTL_ZERO
,
2034 .extra2
= (void *)&six_hundred_forty_kb
,
2037 .procname
= "perf_event_max_contexts_per_stack",
2038 .data
= &sysctl_perf_event_max_contexts_per_stack
,
2039 .maxlen
= sizeof(sysctl_perf_event_max_contexts_per_stack
),
2041 .proc_handler
= perf_event_max_stack_handler
,
2042 .extra1
= SYSCTL_ZERO
,
2043 .extra2
= SYSCTL_ONE_THOUSAND
,
2047 .procname
= "panic_on_warn",
2048 .data
= &panic_on_warn
,
2049 .maxlen
= sizeof(int),
2051 .proc_handler
= proc_dointvec_minmax
,
2052 .extra1
= SYSCTL_ZERO
,
2053 .extra2
= SYSCTL_ONE
,
2055 #ifdef CONFIG_TREE_RCU
2057 .procname
= "panic_on_rcu_stall",
2058 .data
= &sysctl_panic_on_rcu_stall
,
2059 .maxlen
= sizeof(sysctl_panic_on_rcu_stall
),
2061 .proc_handler
= proc_dointvec_minmax
,
2062 .extra1
= SYSCTL_ZERO
,
2063 .extra2
= SYSCTL_ONE
,
2066 .procname
= "max_rcu_stall_to_panic",
2067 .data
= &sysctl_max_rcu_stall_to_panic
,
2068 .maxlen
= sizeof(sysctl_max_rcu_stall_to_panic
),
2070 .proc_handler
= proc_dointvec_minmax
,
2071 .extra1
= SYSCTL_ONE
,
2072 .extra2
= SYSCTL_INT_MAX
,
2078 static struct ctl_table vm_table
[] = {
2080 .procname
= "overcommit_memory",
2081 .data
= &sysctl_overcommit_memory
,
2082 .maxlen
= sizeof(sysctl_overcommit_memory
),
2084 .proc_handler
= overcommit_policy_handler
,
2085 .extra1
= SYSCTL_ZERO
,
2086 .extra2
= SYSCTL_TWO
,
2089 .procname
= "overcommit_ratio",
2090 .data
= &sysctl_overcommit_ratio
,
2091 .maxlen
= sizeof(sysctl_overcommit_ratio
),
2093 .proc_handler
= overcommit_ratio_handler
,
2096 .procname
= "overcommit_kbytes",
2097 .data
= &sysctl_overcommit_kbytes
,
2098 .maxlen
= sizeof(sysctl_overcommit_kbytes
),
2100 .proc_handler
= overcommit_kbytes_handler
,
2103 .procname
= "page-cluster",
2104 .data
= &page_cluster
,
2105 .maxlen
= sizeof(int),
2107 .proc_handler
= proc_dointvec_minmax
,
2108 .extra1
= SYSCTL_ZERO
,
2109 .extra2
= (void *)&page_cluster_max
,
2112 .procname
= "dirtytime_expire_seconds",
2113 .data
= &dirtytime_expire_interval
,
2114 .maxlen
= sizeof(dirtytime_expire_interval
),
2116 .proc_handler
= dirtytime_interval_handler
,
2117 .extra1
= SYSCTL_ZERO
,
2120 .procname
= "swappiness",
2121 .data
= &vm_swappiness
,
2122 .maxlen
= sizeof(vm_swappiness
),
2124 .proc_handler
= proc_dointvec_minmax
,
2125 .extra1
= SYSCTL_ZERO
,
2126 .extra2
= SYSCTL_TWO_HUNDRED
,
2130 .procname
= "numa_stat",
2131 .data
= &sysctl_vm_numa_stat
,
2132 .maxlen
= sizeof(int),
2134 .proc_handler
= sysctl_vm_numa_stat_handler
,
2135 .extra1
= SYSCTL_ZERO
,
2136 .extra2
= SYSCTL_ONE
,
2139 #ifdef CONFIG_HUGETLB_PAGE
2141 .procname
= "nr_hugepages",
2143 .maxlen
= sizeof(unsigned long),
2145 .proc_handler
= hugetlb_sysctl_handler
,
2149 .procname
= "nr_hugepages_mempolicy",
2151 .maxlen
= sizeof(unsigned long),
2153 .proc_handler
= &hugetlb_mempolicy_sysctl_handler
,
2157 .procname
= "hugetlb_shm_group",
2158 .data
= &sysctl_hugetlb_shm_group
,
2159 .maxlen
= sizeof(gid_t
),
2161 .proc_handler
= proc_dointvec
,
2164 .procname
= "nr_overcommit_hugepages",
2166 .maxlen
= sizeof(unsigned long),
2168 .proc_handler
= hugetlb_overcommit_handler
,
2172 .procname
= "lowmem_reserve_ratio",
2173 .data
= &sysctl_lowmem_reserve_ratio
,
2174 .maxlen
= sizeof(sysctl_lowmem_reserve_ratio
),
2176 .proc_handler
= lowmem_reserve_ratio_sysctl_handler
,
2179 .procname
= "drop_caches",
2180 .data
= &sysctl_drop_caches
,
2181 .maxlen
= sizeof(int),
2183 .proc_handler
= drop_caches_sysctl_handler
,
2184 .extra1
= SYSCTL_ONE
,
2185 .extra2
= SYSCTL_FOUR
,
2187 #ifdef CONFIG_COMPACTION
2189 .procname
= "compact_memory",
2191 .maxlen
= sizeof(int),
2193 .proc_handler
= sysctl_compaction_handler
,
2196 .procname
= "compaction_proactiveness",
2197 .data
= &sysctl_compaction_proactiveness
,
2198 .maxlen
= sizeof(sysctl_compaction_proactiveness
),
2200 .proc_handler
= compaction_proactiveness_sysctl_handler
,
2201 .extra1
= SYSCTL_ZERO
,
2202 .extra2
= SYSCTL_ONE_HUNDRED
,
2205 .procname
= "extfrag_threshold",
2206 .data
= &sysctl_extfrag_threshold
,
2207 .maxlen
= sizeof(int),
2209 .proc_handler
= proc_dointvec_minmax
,
2210 .extra1
= SYSCTL_ZERO
,
2211 .extra2
= SYSCTL_ONE_THOUSAND
,
2214 .procname
= "compact_unevictable_allowed",
2215 .data
= &sysctl_compact_unevictable_allowed
,
2216 .maxlen
= sizeof(int),
2218 .proc_handler
= proc_dointvec_minmax_warn_RT_change
,
2219 .extra1
= SYSCTL_ZERO
,
2220 .extra2
= SYSCTL_ONE
,
2223 #endif /* CONFIG_COMPACTION */
2225 .procname
= "min_free_kbytes",
2226 .data
= &min_free_kbytes
,
2227 .maxlen
= sizeof(min_free_kbytes
),
2229 .proc_handler
= min_free_kbytes_sysctl_handler
,
2230 .extra1
= SYSCTL_ZERO
,
2233 .procname
= "watermark_boost_factor",
2234 .data
= &watermark_boost_factor
,
2235 .maxlen
= sizeof(watermark_boost_factor
),
2237 .proc_handler
= proc_dointvec_minmax
,
2238 .extra1
= SYSCTL_ZERO
,
2241 .procname
= "watermark_scale_factor",
2242 .data
= &watermark_scale_factor
,
2243 .maxlen
= sizeof(watermark_scale_factor
),
2245 .proc_handler
= watermark_scale_factor_sysctl_handler
,
2246 .extra1
= SYSCTL_ONE
,
2247 .extra2
= SYSCTL_THREE_THOUSAND
,
2250 .procname
= "percpu_pagelist_high_fraction",
2251 .data
= &percpu_pagelist_high_fraction
,
2252 .maxlen
= sizeof(percpu_pagelist_high_fraction
),
2254 .proc_handler
= percpu_pagelist_high_fraction_sysctl_handler
,
2255 .extra1
= SYSCTL_ZERO
,
2258 .procname
= "page_lock_unfairness",
2259 .data
= &sysctl_page_lock_unfairness
,
2260 .maxlen
= sizeof(sysctl_page_lock_unfairness
),
2262 .proc_handler
= proc_dointvec_minmax
,
2263 .extra1
= SYSCTL_ZERO
,
2267 .procname
= "max_map_count",
2268 .data
= &sysctl_max_map_count
,
2269 .maxlen
= sizeof(sysctl_max_map_count
),
2271 .proc_handler
= proc_dointvec_minmax
,
2272 .extra1
= SYSCTL_ZERO
,
2276 .procname
= "nr_trim_pages",
2277 .data
= &sysctl_nr_trim_pages
,
2278 .maxlen
= sizeof(sysctl_nr_trim_pages
),
2280 .proc_handler
= proc_dointvec_minmax
,
2281 .extra1
= SYSCTL_ZERO
,
2285 .procname
= "vfs_cache_pressure",
2286 .data
= &sysctl_vfs_cache_pressure
,
2287 .maxlen
= sizeof(sysctl_vfs_cache_pressure
),
2289 .proc_handler
= proc_dointvec_minmax
,
2290 .extra1
= SYSCTL_ZERO
,
2292 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
2293 defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
2295 .procname
= "legacy_va_layout",
2296 .data
= &sysctl_legacy_va_layout
,
2297 .maxlen
= sizeof(sysctl_legacy_va_layout
),
2299 .proc_handler
= proc_dointvec_minmax
,
2300 .extra1
= SYSCTL_ZERO
,
2305 .procname
= "zone_reclaim_mode",
2306 .data
= &node_reclaim_mode
,
2307 .maxlen
= sizeof(node_reclaim_mode
),
2309 .proc_handler
= proc_dointvec_minmax
,
2310 .extra1
= SYSCTL_ZERO
,
2313 .procname
= "min_unmapped_ratio",
2314 .data
= &sysctl_min_unmapped_ratio
,
2315 .maxlen
= sizeof(sysctl_min_unmapped_ratio
),
2317 .proc_handler
= sysctl_min_unmapped_ratio_sysctl_handler
,
2318 .extra1
= SYSCTL_ZERO
,
2319 .extra2
= SYSCTL_ONE_HUNDRED
,
2322 .procname
= "min_slab_ratio",
2323 .data
= &sysctl_min_slab_ratio
,
2324 .maxlen
= sizeof(sysctl_min_slab_ratio
),
2326 .proc_handler
= sysctl_min_slab_ratio_sysctl_handler
,
2327 .extra1
= SYSCTL_ZERO
,
2328 .extra2
= SYSCTL_ONE_HUNDRED
,
2333 .procname
= "stat_interval",
2334 .data
= &sysctl_stat_interval
,
2335 .maxlen
= sizeof(sysctl_stat_interval
),
2337 .proc_handler
= proc_dointvec_jiffies
,
2340 .procname
= "stat_refresh",
2344 .proc_handler
= vmstat_refresh
,
2349 .procname
= "mmap_min_addr",
2350 .data
= &dac_mmap_min_addr
,
2351 .maxlen
= sizeof(unsigned long),
2353 .proc_handler
= mmap_min_addr_handler
,
2358 .procname
= "numa_zonelist_order",
2359 .data
= &numa_zonelist_order
,
2360 .maxlen
= NUMA_ZONELIST_ORDER_LEN
,
2362 .proc_handler
= numa_zonelist_order_handler
,
2365 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
2366 (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
2368 .procname
= "vdso_enabled",
2369 #ifdef CONFIG_X86_32
2370 .data
= &vdso32_enabled
,
2371 .maxlen
= sizeof(vdso32_enabled
),
2373 .data
= &vdso_enabled
,
2374 .maxlen
= sizeof(vdso_enabled
),
2377 .proc_handler
= proc_dointvec
,
2378 .extra1
= SYSCTL_ZERO
,
2381 #ifdef CONFIG_MEMORY_FAILURE
2383 .procname
= "memory_failure_early_kill",
2384 .data
= &sysctl_memory_failure_early_kill
,
2385 .maxlen
= sizeof(sysctl_memory_failure_early_kill
),
2387 .proc_handler
= proc_dointvec_minmax
,
2388 .extra1
= SYSCTL_ZERO
,
2389 .extra2
= SYSCTL_ONE
,
2392 .procname
= "memory_failure_recovery",
2393 .data
= &sysctl_memory_failure_recovery
,
2394 .maxlen
= sizeof(sysctl_memory_failure_recovery
),
2396 .proc_handler
= proc_dointvec_minmax
,
2397 .extra1
= SYSCTL_ZERO
,
2398 .extra2
= SYSCTL_ONE
,
2402 .procname
= "user_reserve_kbytes",
2403 .data
= &sysctl_user_reserve_kbytes
,
2404 .maxlen
= sizeof(sysctl_user_reserve_kbytes
),
2406 .proc_handler
= proc_doulongvec_minmax
,
2409 .procname
= "admin_reserve_kbytes",
2410 .data
= &sysctl_admin_reserve_kbytes
,
2411 .maxlen
= sizeof(sysctl_admin_reserve_kbytes
),
2413 .proc_handler
= proc_doulongvec_minmax
,
2415 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
2417 .procname
= "mmap_rnd_bits",
2418 .data
= &mmap_rnd_bits
,
2419 .maxlen
= sizeof(mmap_rnd_bits
),
2421 .proc_handler
= proc_dointvec_minmax
,
2422 .extra1
= (void *)&mmap_rnd_bits_min
,
2423 .extra2
= (void *)&mmap_rnd_bits_max
,
2426 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
2428 .procname
= "mmap_rnd_compat_bits",
2429 .data
= &mmap_rnd_compat_bits
,
2430 .maxlen
= sizeof(mmap_rnd_compat_bits
),
2432 .proc_handler
= proc_dointvec_minmax
,
2433 .extra1
= (void *)&mmap_rnd_compat_bits_min
,
2434 .extra2
= (void *)&mmap_rnd_compat_bits_max
,
2437 #ifdef CONFIG_USERFAULTFD
2439 .procname
= "unprivileged_userfaultfd",
2440 .data
= &sysctl_unprivileged_userfaultfd
,
2441 .maxlen
= sizeof(sysctl_unprivileged_userfaultfd
),
2443 .proc_handler
= proc_dointvec_minmax
,
2444 .extra1
= SYSCTL_ZERO
,
2445 .extra2
= SYSCTL_ONE
,
2451 static struct ctl_table debug_table
[] = {
2452 #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
2454 .procname
= "exception-trace",
2455 .data
= &show_unhandled_signals
,
2456 .maxlen
= sizeof(int),
2458 .proc_handler
= proc_dointvec
2464 static struct ctl_table dev_table
[] = {
2468 DECLARE_SYSCTL_BASE(kernel
, kern_table
);
2469 DECLARE_SYSCTL_BASE(vm
, vm_table
);
2470 DECLARE_SYSCTL_BASE(debug
, debug_table
);
2471 DECLARE_SYSCTL_BASE(dev
, dev_table
);
2473 int __init
sysctl_init_bases(void)
2475 register_sysctl_base(kernel
);
2476 register_sysctl_base(vm
);
2477 register_sysctl_base(debug
);
2478 register_sysctl_base(dev
);
2482 #endif /* CONFIG_SYSCTL */
2484 * No sense putting this after each symbol definition, twice,
2485 * exception granted :-)
2487 EXPORT_SYMBOL(proc_dobool
);
2488 EXPORT_SYMBOL(proc_dointvec
);
2489 EXPORT_SYMBOL(proc_douintvec
);
2490 EXPORT_SYMBOL(proc_dointvec_jiffies
);
2491 EXPORT_SYMBOL(proc_dointvec_minmax
);
2492 EXPORT_SYMBOL_GPL(proc_douintvec_minmax
);
2493 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies
);
2494 EXPORT_SYMBOL(proc_dointvec_ms_jiffies
);
2495 EXPORT_SYMBOL(proc_dostring
);
2496 EXPORT_SYMBOL(proc_doulongvec_minmax
);
2497 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax
);
2498 EXPORT_SYMBOL(proc_do_large_bitmap
);