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/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>
67 #include "../lib/kstrtox.h"
69 #include <linux/uaccess.h>
70 #include <asm/processor.h>
74 #include <asm/stacktrace.h>
78 #include <asm/setup.h>
80 #ifdef CONFIG_RT_MUTEXES
81 #include <linux/rtmutex.h>
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
);
88 const unsigned long sysctl_long_vals
[] = { 0, 1, LONG_MAX
};
89 EXPORT_SYMBOL_GPL(sysctl_long_vals
);
91 #if defined(CONFIG_SYSCTL)
93 /* Constants used for minimum and maximum */
95 #ifdef CONFIG_PERF_EVENTS
96 static const int six_hundred_forty_kb
= 640 * 1024;
100 static const int ngroups_max
= NGROUPS_MAX
;
101 static const int cap_last_cap
= CAP_LAST_CAP
;
103 #ifdef CONFIG_PROC_SYSCTL
106 * enum sysctl_writes_mode - supported sysctl write modes
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
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
121 * These write modes control how current file position affects the behavior of
122 * updating sysctl values through the proc interface on each write.
124 enum sysctl_writes_mode
{
125 SYSCTL_WRITES_LEGACY
= -1,
126 SYSCTL_WRITES_WARN
= 0,
127 SYSCTL_WRITES_STRICT
= 1,
130 static enum sysctl_writes_mode sysctl_writes_strict
= SYSCTL_WRITES_STRICT
;
131 #endif /* CONFIG_PROC_SYSCTL */
133 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
134 defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
135 int sysctl_legacy_va_layout
;
138 #endif /* CONFIG_SYSCTL */
144 #ifdef CONFIG_PROC_SYSCTL
146 static int _proc_do_string(char *data
, int maxlen
, int write
,
147 char *buffer
, size_t *lenp
, loff_t
*ppos
)
152 if (!data
|| !maxlen
|| !*lenp
) {
158 if (sysctl_writes_strict
== SYSCTL_WRITES_STRICT
) {
159 /* Only continue writes not past the end of buffer. */
161 if (len
> maxlen
- 1)
168 /* Start writing from beginning of buffer. */
174 while ((p
- buffer
) < *lenp
&& len
< maxlen
- 1) {
176 if (c
== 0 || c
== '\n')
197 memcpy(buffer
, data
, len
);
208 static void warn_sysctl_write(struct ctl_table
*table
)
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
);
217 * proc_first_pos_non_zero_ignore - check if first position is allowed
218 * @ppos: file position
219 * @table: the sysctl table
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.
225 static bool proc_first_pos_non_zero_ignore(loff_t
*ppos
,
226 struct ctl_table
*table
)
231 switch (sysctl_writes_strict
) {
232 case SYSCTL_WRITES_STRICT
:
234 case SYSCTL_WRITES_WARN
:
235 warn_sysctl_write(table
);
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
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
257 * Returns 0 on success.
259 int proc_dostring(struct ctl_table
*table
, int write
,
260 void *buffer
, size_t *lenp
, loff_t
*ppos
)
263 proc_first_pos_non_zero_ignore(ppos
, table
);
265 return _proc_do_string(table
->data
, table
->maxlen
, write
, buffer
, lenp
,
269 static void proc_skip_spaces(char **buf
, size_t *size
)
279 static void proc_skip_char(char **buf
, size_t *size
, const char v
)
290 * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
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
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
304 static int strtoul_lenient(const char *cp
, char **endp
, unsigned int base
,
307 unsigned long long result
;
310 cp
= _parse_integer_fixup_radix(cp
, &base
);
311 rv
= _parse_integer(cp
, base
, &result
);
312 if ((rv
& KSTRTOX_OVERFLOW
) || (result
!= (unsigned long)result
))
320 *res
= (unsigned long)result
;
326 * proc_get_long - reads an ASCII formatted integer from a user buffer
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
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.
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
)
345 char *p
, tmp
[TMPBUFLEN
];
351 if (len
> TMPBUFLEN
- 1)
354 memcpy(tmp
, *buf
, len
);
358 if (*p
== '-' && *size
> 1) {
366 if (strtoul_lenient(p
, &p
, 0, val
))
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)
377 if (len
< *size
&& perm_tr_len
&& !memchr(perm_tr
, *p
, perm_tr_len
))
380 if (tr
&& (len
< *size
))
390 * proc_put_long - converts an integer to a decimal ASCII formatted string
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
397 * In case of success @buf and @size are updated with the amount of bytes
400 static void proc_put_long(void **buf
, size_t *size
, unsigned long val
, bool neg
)
403 char tmp
[TMPBUFLEN
], *p
= tmp
;
405 sprintf(p
, "%s%lu", neg
? "-" : "", val
);
409 memcpy(*buf
, tmp
, len
);
415 static void proc_put_char(void **buf
, size_t *size
, char c
)
418 char **buffer
= (char **)buf
;
427 static int do_proc_dointvec_conv(bool *negp
, unsigned long *lvalp
,
429 int write
, void *data
)
433 if (*lvalp
> (unsigned long) INT_MAX
+ 1)
435 WRITE_ONCE(*valp
, -*lvalp
);
437 if (*lvalp
> (unsigned long) INT_MAX
)
439 WRITE_ONCE(*valp
, *lvalp
);
442 int val
= READ_ONCE(*valp
);
445 *lvalp
= -(unsigned long)val
;
448 *lvalp
= (unsigned long)val
;
454 static int do_proc_douintvec_conv(unsigned long *lvalp
,
456 int write
, void *data
)
459 if (*lvalp
> UINT_MAX
)
461 WRITE_ONCE(*valp
, *lvalp
);
463 unsigned int val
= READ_ONCE(*valp
);
464 *lvalp
= (unsigned long)val
;
469 static const char proc_wspace_sep
[] = { ' ', '\t', '\n' };
471 static int __do_proc_dointvec(void *tbl_data
, 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
),
478 int *i
, vleft
, first
= 1, err
= 0;
482 if (!tbl_data
|| !table
->maxlen
|| !*lenp
|| (*ppos
&& !write
)) {
487 i
= (int *) tbl_data
;
488 vleft
= table
->maxlen
/ sizeof(*i
);
492 conv
= do_proc_dointvec_conv
;
495 if (proc_first_pos_non_zero_ignore(ppos
, table
))
498 if (left
> PAGE_SIZE
- 1)
499 left
= PAGE_SIZE
- 1;
503 for (; left
&& vleft
--; i
++, first
=0) {
508 proc_skip_spaces(&p
, &left
);
512 err
= proc_get_long(&p
, &left
, &lval
, &neg
,
514 sizeof(proc_wspace_sep
), NULL
);
517 if (conv(&neg
, &lval
, i
, 1, data
)) {
522 if (conv(&neg
, &lval
, i
, 0, data
)) {
527 proc_put_char(&buffer
, &left
, '\t');
528 proc_put_long(&buffer
, &left
, lval
, neg
);
532 if (!write
&& !first
&& left
&& !err
)
533 proc_put_char(&buffer
, &left
, '\n');
534 if (write
&& !err
&& left
)
535 proc_skip_spaces(&p
, &left
);
537 return err
? : -EINVAL
;
544 static int do_proc_dointvec(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
),
550 return __do_proc_dointvec(table
->data
, table
, write
,
551 buffer
, lenp
, ppos
, conv
, data
);
554 static int do_proc_douintvec_w(unsigned int *tbl_data
,
555 struct ctl_table
*table
,
557 size_t *lenp
, loff_t
*ppos
,
558 int (*conv
)(unsigned long *lvalp
,
560 int write
, void *data
),
571 if (proc_first_pos_non_zero_ignore(ppos
, table
))
574 if (left
> PAGE_SIZE
- 1)
575 left
= PAGE_SIZE
- 1;
577 proc_skip_spaces(&p
, &left
);
583 err
= proc_get_long(&p
, &left
, &lval
, &neg
,
585 sizeof(proc_wspace_sep
), NULL
);
591 if (conv(&lval
, tbl_data
, 1, data
)) {
597 proc_skip_spaces(&p
, &left
);
605 /* This is in keeping with old __do_proc_dointvec() */
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
,
615 int write
, void *data
),
624 if (conv(&lval
, tbl_data
, 0, data
)) {
629 proc_put_long(&buffer
, &left
, lval
, false);
633 proc_put_char(&buffer
, &left
, '\n');
642 static int __do_proc_douintvec(void *tbl_data
, struct ctl_table
*table
,
643 int write
, void *buffer
,
644 size_t *lenp
, loff_t
*ppos
,
645 int (*conv
)(unsigned long *lvalp
,
647 int write
, void *data
),
650 unsigned int *i
, vleft
;
652 if (!tbl_data
|| !table
->maxlen
|| !*lenp
|| (*ppos
&& !write
)) {
657 i
= (unsigned int *) tbl_data
;
658 vleft
= table
->maxlen
/ sizeof(*i
);
661 * Arrays are not supported, keep this simple. *Do not* add
670 conv
= do_proc_douintvec_conv
;
673 return do_proc_douintvec_w(i
, table
, buffer
, lenp
, ppos
,
675 return do_proc_douintvec_r(i
, buffer
, lenp
, ppos
, conv
, data
);
678 int do_proc_douintvec(struct ctl_table
*table
, int write
,
679 void *buffer
, size_t *lenp
, loff_t
*ppos
,
680 int (*conv
)(unsigned long *lvalp
,
682 int write
, void *data
),
685 return __do_proc_douintvec(table
->data
, table
, write
,
686 buffer
, lenp
, ppos
, conv
, data
);
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
697 * Reads/writes one integer value from/to the user buffer,
698 * treated as an ASCII string.
700 * table->data must point to a bool variable and table->maxlen must
703 * Returns 0 on success.
705 int proc_dobool(struct ctl_table
*table
, int write
, void *buffer
,
706 size_t *lenp
, loff_t
*ppos
)
708 struct ctl_table tmp
;
709 bool *data
= table
->data
;
712 /* Do not support arrays yet. */
713 if (table
->maxlen
!= sizeof(bool))
717 tmp
.maxlen
= sizeof(val
);
720 val
= READ_ONCE(*data
);
721 res
= proc_dointvec(&tmp
, write
, buffer
, lenp
, ppos
);
725 WRITE_ONCE(*data
, val
);
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
737 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
738 * values from/to the user buffer, treated as an ASCII string.
740 * Returns 0 on success.
742 int proc_dointvec(struct ctl_table
*table
, int write
, void *buffer
,
743 size_t *lenp
, loff_t
*ppos
)
745 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
, NULL
, NULL
);
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
756 * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
757 * values from/to the user buffer, treated as an ASCII string.
759 * Returns 0 on success.
761 int proc_douintvec(struct ctl_table
*table
, int write
, void *buffer
,
762 size_t *lenp
, loff_t
*ppos
)
764 return do_proc_douintvec(table
, write
, buffer
, lenp
, ppos
,
765 do_proc_douintvec_conv
, NULL
);
769 * Taint values can only be increased
770 * This means we can safely use a temporary.
772 static int proc_taint(struct ctl_table
*table
, int write
,
773 void *buffer
, size_t *lenp
, loff_t
*ppos
)
776 unsigned long tmptaint
= get_taint();
779 if (write
&& !capable(CAP_SYS_ADMIN
))
784 err
= proc_doulongvec_minmax(&t
, write
, buffer
, lenp
, ppos
);
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.
796 if (panic_on_taint_nousertaint
&& (tmptaint
& panic_on_taint
))
800 * Poor man's atomic or. Not worth adding a primitive
801 * to everyone's atomic.h for this
803 for (i
= 0; i
< TAINT_FLAGS_COUNT
; i
++)
804 if ((1UL << i
) & tmptaint
)
805 add_taint(i
, LOCKDEP_STILL_OK
);
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
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.
820 struct do_proc_dointvec_minmax_conv_param
{
825 static int do_proc_dointvec_minmax_conv(bool *negp
, unsigned long *lvalp
,
827 int write
, void *data
)
830 struct do_proc_dointvec_minmax_conv_param
*param
= data
;
832 * If writing, first do so via a temporary local int so we can
833 * bounds-check it before touching *valp.
835 int *ip
= write
? &tmp
: valp
;
837 ret
= do_proc_dointvec_conv(negp
, lvalp
, ip
, write
, data
);
842 if ((param
->min
&& *param
->min
> tmp
) ||
843 (param
->max
&& *param
->max
< tmp
))
845 WRITE_ONCE(*valp
, tmp
);
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
859 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
860 * values from/to the user buffer, treated as an ASCII string.
862 * This routine will ensure the values are within the range specified by
863 * table->extra1 (min) and table->extra2 (max).
865 * Returns 0 on success or -EINVAL on write when the range check fails.
867 int proc_dointvec_minmax(struct ctl_table
*table
, int write
,
868 void *buffer
, size_t *lenp
, loff_t
*ppos
)
870 struct do_proc_dointvec_minmax_conv_param param
= {
871 .min
= (int *) table
->extra1
,
872 .max
= (int *) table
->extra2
,
874 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
875 do_proc_dointvec_minmax_conv
, ¶m
);
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
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.
887 struct do_proc_douintvec_minmax_conv_param
{
892 static int do_proc_douintvec_minmax_conv(unsigned long *lvalp
,
894 int write
, void *data
)
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
;
902 ret
= do_proc_douintvec_conv(lvalp
, up
, write
, data
);
907 if ((param
->min
&& *param
->min
> tmp
) ||
908 (param
->max
&& *param
->max
< tmp
))
911 WRITE_ONCE(*valp
, tmp
);
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
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.
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
934 * Returns 0 on success or -ERANGE on write when the range check fails.
936 int proc_douintvec_minmax(struct ctl_table
*table
, int write
,
937 void *buffer
, size_t *lenp
, loff_t
*ppos
)
939 struct do_proc_douintvec_minmax_conv_param param
= {
940 .min
= (unsigned int *) table
->extra1
,
941 .max
= (unsigned int *) table
->extra2
,
943 return do_proc_douintvec(table
, write
, buffer
, lenp
, ppos
,
944 do_proc_douintvec_minmax_conv
, ¶m
);
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
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.
959 * This routine will ensure the values are within the range specified by
960 * table->extra1 (min) and table->extra2 (max).
962 * Returns 0 on success or an error on write when the range check fails.
964 int proc_dou8vec_minmax(struct ctl_table
*table
, int write
,
965 void *buffer
, size_t *lenp
, loff_t
*ppos
)
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
= {
976 /* Do not support arrays yet. */
977 if (table
->maxlen
!= sizeof(u8
))
981 min
= *(unsigned int *) table
->extra1
;
986 max
= *(unsigned int *) table
->extra2
;
993 tmp
.maxlen
= sizeof(val
);
995 val
= READ_ONCE(*data
);
996 res
= do_proc_douintvec(&tmp
, write
, buffer
, lenp
, ppos
,
997 do_proc_douintvec_minmax_conv
, ¶m
);
1001 WRITE_ONCE(*data
, val
);
1004 EXPORT_SYMBOL_GPL(proc_dou8vec_minmax
);
1006 #ifdef CONFIG_MAGIC_SYSRQ
1007 static int sysrq_sysctl_handler(struct ctl_table
*table
, int write
,
1008 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1014 ret
= __do_proc_dointvec(&tmp
, table
, write
, buffer
,
1015 lenp
, ppos
, NULL
, NULL
);
1020 sysrq_toggle_support(tmp
);
1026 static int __do_proc_doulongvec_minmax(void *data
, struct ctl_table
*table
,
1027 int write
, void *buffer
, size_t *lenp
, loff_t
*ppos
,
1028 unsigned long convmul
, unsigned long convdiv
)
1030 unsigned long *i
, *min
, *max
;
1031 int vleft
, first
= 1, err
= 0;
1035 if (!data
|| !table
->maxlen
|| !*lenp
|| (*ppos
&& !write
)) {
1041 min
= table
->extra1
;
1042 max
= table
->extra2
;
1043 vleft
= table
->maxlen
/ sizeof(unsigned long);
1047 if (proc_first_pos_non_zero_ignore(ppos
, table
))
1050 if (left
> PAGE_SIZE
- 1)
1051 left
= PAGE_SIZE
- 1;
1055 for (; left
&& vleft
--; i
++, first
= 0) {
1061 proc_skip_spaces(&p
, &left
);
1065 err
= proc_get_long(&p
, &left
, &val
, &neg
,
1067 sizeof(proc_wspace_sep
), NULL
);
1073 val
= convmul
* val
/ convdiv
;
1074 if ((min
&& val
< *min
) || (max
&& val
> *max
)) {
1078 WRITE_ONCE(*i
, val
);
1080 val
= convdiv
* READ_ONCE(*i
) / convmul
;
1082 proc_put_char(&buffer
, &left
, '\t');
1083 proc_put_long(&buffer
, &left
, val
, false);
1087 if (!write
&& !first
&& left
&& !err
)
1088 proc_put_char(&buffer
, &left
, '\n');
1090 proc_skip_spaces(&p
, &left
);
1092 return err
? : -EINVAL
;
1099 static int do_proc_doulongvec_minmax(struct ctl_table
*table
, int write
,
1100 void *buffer
, size_t *lenp
, loff_t
*ppos
, unsigned long convmul
,
1101 unsigned long convdiv
)
1103 return __do_proc_doulongvec_minmax(table
->data
, table
, write
,
1104 buffer
, lenp
, ppos
, convmul
, convdiv
);
1108 * proc_doulongvec_minmax - read a vector of long integers with min/max values
1109 * @table: the sysctl table
1110 * @write: %TRUE if this is a write to the sysctl file
1111 * @buffer: the user buffer
1112 * @lenp: the size of the user buffer
1113 * @ppos: file position
1115 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1116 * values from/to the user buffer, treated as an ASCII string.
1118 * This routine will ensure the values are within the range specified by
1119 * table->extra1 (min) and table->extra2 (max).
1121 * Returns 0 on success.
1123 int proc_doulongvec_minmax(struct ctl_table
*table
, int write
,
1124 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1126 return do_proc_doulongvec_minmax(table
, write
, buffer
, lenp
, ppos
, 1l, 1l);
1130 * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
1131 * @table: the sysctl table
1132 * @write: %TRUE if this is a write to the sysctl file
1133 * @buffer: the user buffer
1134 * @lenp: the size of the user buffer
1135 * @ppos: file position
1137 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1138 * values from/to the user buffer, treated as an ASCII string. The values
1139 * are treated as milliseconds, and converted to jiffies when they are stored.
1141 * This routine will ensure the values are within the range specified by
1142 * table->extra1 (min) and table->extra2 (max).
1144 * Returns 0 on success.
1146 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table
*table
, int write
,
1147 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1149 return do_proc_doulongvec_minmax(table
, write
, buffer
,
1150 lenp
, ppos
, HZ
, 1000l);
1154 static int do_proc_dointvec_jiffies_conv(bool *negp
, unsigned long *lvalp
,
1156 int write
, void *data
)
1159 if (*lvalp
> INT_MAX
/ HZ
)
1162 WRITE_ONCE(*valp
, -*lvalp
* HZ
);
1164 WRITE_ONCE(*valp
, *lvalp
* HZ
);
1166 int val
= READ_ONCE(*valp
);
1170 lval
= -(unsigned long)val
;
1173 lval
= (unsigned long)val
;
1180 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp
, unsigned long *lvalp
,
1182 int write
, void *data
)
1185 if (USER_HZ
< HZ
&& *lvalp
> (LONG_MAX
/ HZ
) * USER_HZ
)
1187 *valp
= clock_t_to_jiffies(*negp
? -*lvalp
: *lvalp
);
1193 lval
= -(unsigned long)val
;
1196 lval
= (unsigned long)val
;
1198 *lvalp
= jiffies_to_clock_t(lval
);
1203 static int do_proc_dointvec_ms_jiffies_conv(bool *negp
, unsigned long *lvalp
,
1205 int write
, void *data
)
1208 unsigned long jif
= msecs_to_jiffies(*negp
? -*lvalp
: *lvalp
);
1212 WRITE_ONCE(*valp
, (int)jif
);
1214 int val
= READ_ONCE(*valp
);
1218 lval
= -(unsigned long)val
;
1221 lval
= (unsigned long)val
;
1223 *lvalp
= jiffies_to_msecs(lval
);
1228 static int do_proc_dointvec_ms_jiffies_minmax_conv(bool *negp
, unsigned long *lvalp
,
1229 int *valp
, int write
, void *data
)
1232 struct do_proc_dointvec_minmax_conv_param
*param
= data
;
1234 * If writing, first do so via a temporary local int so we can
1235 * bounds-check it before touching *valp.
1237 int *ip
= write
? &tmp
: valp
;
1239 ret
= do_proc_dointvec_ms_jiffies_conv(negp
, lvalp
, ip
, write
, data
);
1244 if ((param
->min
&& *param
->min
> tmp
) ||
1245 (param
->max
&& *param
->max
< tmp
))
1253 * proc_dointvec_jiffies - read a vector of integers as seconds
1254 * @table: the sysctl table
1255 * @write: %TRUE if this is a write to the sysctl file
1256 * @buffer: the user buffer
1257 * @lenp: the size of the user buffer
1258 * @ppos: file position
1260 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1261 * values from/to the user buffer, treated as an ASCII string.
1262 * The values read are assumed to be in seconds, and are converted into
1265 * Returns 0 on success.
1267 int proc_dointvec_jiffies(struct ctl_table
*table
, int write
,
1268 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1270 return do_proc_dointvec(table
,write
,buffer
,lenp
,ppos
,
1271 do_proc_dointvec_jiffies_conv
,NULL
);
1274 int proc_dointvec_ms_jiffies_minmax(struct ctl_table
*table
, int write
,
1275 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1277 struct do_proc_dointvec_minmax_conv_param param
= {
1278 .min
= (int *) table
->extra1
,
1279 .max
= (int *) table
->extra2
,
1281 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
1282 do_proc_dointvec_ms_jiffies_minmax_conv
, ¶m
);
1286 * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
1287 * @table: the sysctl table
1288 * @write: %TRUE if this is a write to the sysctl file
1289 * @buffer: the user buffer
1290 * @lenp: the size of the user buffer
1291 * @ppos: pointer to the file position
1293 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1294 * values from/to the user buffer, treated as an ASCII string.
1295 * The values read are assumed to be in 1/USER_HZ seconds, and
1296 * are converted into jiffies.
1298 * Returns 0 on success.
1300 int proc_dointvec_userhz_jiffies(struct ctl_table
*table
, int write
,
1301 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1303 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
1304 do_proc_dointvec_userhz_jiffies_conv
, NULL
);
1308 * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
1309 * @table: the sysctl table
1310 * @write: %TRUE if this is a write to the sysctl file
1311 * @buffer: the user buffer
1312 * @lenp: the size of the user buffer
1313 * @ppos: file position
1314 * @ppos: the current position in the file
1316 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1317 * values from/to the user buffer, treated as an ASCII string.
1318 * The values read are assumed to be in 1/1000 seconds, and
1319 * are converted into jiffies.
1321 * Returns 0 on success.
1323 int proc_dointvec_ms_jiffies(struct ctl_table
*table
, int write
, void *buffer
,
1324 size_t *lenp
, loff_t
*ppos
)
1326 return do_proc_dointvec(table
, write
, buffer
, lenp
, ppos
,
1327 do_proc_dointvec_ms_jiffies_conv
, NULL
);
1330 static int proc_do_cad_pid(struct ctl_table
*table
, int write
, void *buffer
,
1331 size_t *lenp
, loff_t
*ppos
)
1333 struct pid
*new_pid
;
1337 tmp
= pid_vnr(cad_pid
);
1339 r
= __do_proc_dointvec(&tmp
, table
, write
, buffer
,
1340 lenp
, ppos
, NULL
, NULL
);
1344 new_pid
= find_get_pid(tmp
);
1348 put_pid(xchg(&cad_pid
, new_pid
));
1353 * proc_do_large_bitmap - read/write from/to a large bitmap
1354 * @table: the sysctl table
1355 * @write: %TRUE if this is a write to the sysctl file
1356 * @buffer: the user buffer
1357 * @lenp: the size of the user buffer
1358 * @ppos: file position
1360 * The bitmap is stored at table->data and the bitmap length (in bits)
1363 * We use a range comma separated format (e.g. 1,3-4,10-10) so that
1364 * large bitmaps may be represented in a compact manner. Writing into
1365 * the file will clear the bitmap then update it with the given input.
1367 * Returns 0 on success.
1369 int proc_do_large_bitmap(struct ctl_table
*table
, int write
,
1370 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1373 size_t left
= *lenp
;
1374 unsigned long bitmap_len
= table
->maxlen
;
1375 unsigned long *bitmap
= *(unsigned long **) table
->data
;
1376 unsigned long *tmp_bitmap
= NULL
;
1377 char tr_a
[] = { '-', ',', '\n' }, tr_b
[] = { ',', '\n', 0 }, c
;
1379 if (!bitmap
|| !bitmap_len
|| !left
|| (*ppos
&& !write
)) {
1388 if (left
> PAGE_SIZE
- 1) {
1389 left
= PAGE_SIZE
- 1;
1390 /* How much of the buffer we'll skip this pass */
1391 skipped
= *lenp
- left
;
1394 tmp_bitmap
= bitmap_zalloc(bitmap_len
, GFP_KERNEL
);
1397 proc_skip_char(&p
, &left
, '\n');
1398 while (!err
&& left
) {
1399 unsigned long val_a
, val_b
;
1403 /* In case we stop parsing mid-number, we can reset */
1405 err
= proc_get_long(&p
, &left
, &val_a
, &neg
, tr_a
,
1408 * If we consumed the entirety of a truncated buffer or
1409 * only one char is left (may be a "-"), then stop here,
1410 * reset, & come back for more.
1412 if ((left
<= 1) && skipped
) {
1419 if (val_a
>= bitmap_len
|| neg
) {
1431 err
= proc_get_long(&p
, &left
, &val_b
,
1432 &neg
, tr_b
, sizeof(tr_b
),
1435 * If we consumed all of a truncated buffer or
1436 * then stop here, reset, & come back for more.
1438 if (!left
&& skipped
) {
1445 if (val_b
>= bitmap_len
|| neg
||
1456 bitmap_set(tmp_bitmap
, val_a
, val_b
- val_a
+ 1);
1457 proc_skip_char(&p
, &left
, '\n');
1461 unsigned long bit_a
, bit_b
= 0;
1465 bit_a
= find_next_bit(bitmap
, bitmap_len
, bit_b
);
1466 if (bit_a
>= bitmap_len
)
1468 bit_b
= find_next_zero_bit(bitmap
, bitmap_len
,
1472 proc_put_char(&buffer
, &left
, ',');
1473 proc_put_long(&buffer
, &left
, bit_a
, false);
1474 if (bit_a
!= bit_b
) {
1475 proc_put_char(&buffer
, &left
, '-');
1476 proc_put_long(&buffer
, &left
, bit_b
, false);
1481 proc_put_char(&buffer
, &left
, '\n');
1487 bitmap_or(bitmap
, bitmap
, tmp_bitmap
, bitmap_len
);
1489 bitmap_copy(bitmap
, tmp_bitmap
, bitmap_len
);
1495 bitmap_free(tmp_bitmap
);
1499 #else /* CONFIG_PROC_SYSCTL */
1501 int proc_dostring(struct ctl_table
*table
, int write
,
1502 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1507 int proc_dobool(struct ctl_table
*table
, int write
,
1508 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1513 int proc_dointvec(struct ctl_table
*table
, int write
,
1514 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1519 int proc_douintvec(struct ctl_table
*table
, int write
,
1520 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1525 int proc_dointvec_minmax(struct ctl_table
*table
, int write
,
1526 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1531 int proc_douintvec_minmax(struct ctl_table
*table
, int write
,
1532 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1537 int proc_dou8vec_minmax(struct ctl_table
*table
, int write
,
1538 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1543 int proc_dointvec_jiffies(struct ctl_table
*table
, int write
,
1544 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1549 int proc_dointvec_ms_jiffies_minmax(struct ctl_table
*table
, int write
,
1550 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1555 int proc_dointvec_userhz_jiffies(struct ctl_table
*table
, int write
,
1556 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1561 int proc_dointvec_ms_jiffies(struct ctl_table
*table
, int write
,
1562 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1567 int proc_doulongvec_minmax(struct ctl_table
*table
, int write
,
1568 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1573 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table
*table
, int write
,
1574 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1579 int proc_do_large_bitmap(struct ctl_table
*table
, int write
,
1580 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1585 #endif /* CONFIG_PROC_SYSCTL */
1587 #if defined(CONFIG_SYSCTL)
1588 int proc_do_static_key(struct ctl_table
*table
, int write
,
1589 void *buffer
, size_t *lenp
, loff_t
*ppos
)
1591 struct static_key
*key
= (struct static_key
*)table
->data
;
1592 static DEFINE_MUTEX(static_key_mutex
);
1594 struct ctl_table tmp
= {
1596 .maxlen
= sizeof(val
),
1597 .mode
= table
->mode
,
1598 .extra1
= SYSCTL_ZERO
,
1599 .extra2
= SYSCTL_ONE
,
1602 if (write
&& !capable(CAP_SYS_ADMIN
))
1605 mutex_lock(&static_key_mutex
);
1606 val
= static_key_enabled(key
);
1607 ret
= proc_dointvec_minmax(&tmp
, write
, buffer
, lenp
, ppos
);
1608 if (write
&& !ret
) {
1610 static_key_enable(key
);
1612 static_key_disable(key
);
1614 mutex_unlock(&static_key_mutex
);
1618 static struct ctl_table kern_table
[] = {
1620 .procname
= "panic",
1621 .data
= &panic_timeout
,
1622 .maxlen
= sizeof(int),
1624 .proc_handler
= proc_dointvec
,
1626 #ifdef CONFIG_PROC_SYSCTL
1628 .procname
= "tainted",
1629 .maxlen
= sizeof(long),
1631 .proc_handler
= proc_taint
,
1634 .procname
= "sysctl_writes_strict",
1635 .data
= &sysctl_writes_strict
,
1636 .maxlen
= sizeof(int),
1638 .proc_handler
= proc_dointvec_minmax
,
1639 .extra1
= SYSCTL_NEG_ONE
,
1640 .extra2
= SYSCTL_ONE
,
1644 .procname
= "print-fatal-signals",
1645 .data
= &print_fatal_signals
,
1646 .maxlen
= sizeof(int),
1648 .proc_handler
= proc_dointvec
,
1652 .procname
= "reboot-cmd",
1653 .data
= reboot_command
,
1656 .proc_handler
= proc_dostring
,
1659 .procname
= "stop-a",
1660 .data
= &stop_a_enabled
,
1661 .maxlen
= sizeof (int),
1663 .proc_handler
= proc_dointvec
,
1666 .procname
= "scons-poweroff",
1667 .data
= &scons_pwroff
,
1668 .maxlen
= sizeof (int),
1670 .proc_handler
= proc_dointvec
,
1673 #ifdef CONFIG_SPARC64
1675 .procname
= "tsb-ratio",
1676 .data
= &sysctl_tsb_ratio
,
1677 .maxlen
= sizeof (int),
1679 .proc_handler
= proc_dointvec
,
1682 #ifdef CONFIG_PARISC
1684 .procname
= "soft-power",
1685 .data
= &pwrsw_enabled
,
1686 .maxlen
= sizeof (int),
1688 .proc_handler
= proc_dointvec
,
1691 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1693 .procname
= "unaligned-trap",
1694 .data
= &unaligned_enabled
,
1695 .maxlen
= sizeof (int),
1697 .proc_handler
= proc_dointvec
,
1700 #ifdef CONFIG_STACK_TRACER
1702 .procname
= "stack_tracer_enabled",
1703 .data
= &stack_tracer_enabled
,
1704 .maxlen
= sizeof(int),
1706 .proc_handler
= stack_trace_sysctl
,
1709 #ifdef CONFIG_TRACING
1711 .procname
= "ftrace_dump_on_oops",
1712 .data
= &ftrace_dump_on_oops
,
1713 .maxlen
= sizeof(int),
1715 .proc_handler
= proc_dointvec
,
1718 .procname
= "traceoff_on_warning",
1719 .data
= &__disable_trace_on_warning
,
1720 .maxlen
= sizeof(__disable_trace_on_warning
),
1722 .proc_handler
= proc_dointvec
,
1725 .procname
= "tracepoint_printk",
1726 .data
= &tracepoint_printk
,
1727 .maxlen
= sizeof(tracepoint_printk
),
1729 .proc_handler
= tracepoint_printk_sysctl
,
1732 #ifdef CONFIG_MODULES
1734 .procname
= "modprobe",
1735 .data
= &modprobe_path
,
1736 .maxlen
= KMOD_PATH_LEN
,
1738 .proc_handler
= proc_dostring
,
1741 .procname
= "modules_disabled",
1742 .data
= &modules_disabled
,
1743 .maxlen
= sizeof(int),
1745 /* only handle a transition from default "0" to "1" */
1746 .proc_handler
= proc_dointvec_minmax
,
1747 .extra1
= SYSCTL_ONE
,
1748 .extra2
= SYSCTL_ONE
,
1751 #ifdef CONFIG_UEVENT_HELPER
1753 .procname
= "hotplug",
1754 .data
= &uevent_helper
,
1755 .maxlen
= UEVENT_HELPER_PATH_LEN
,
1757 .proc_handler
= proc_dostring
,
1760 #ifdef CONFIG_MAGIC_SYSRQ
1762 .procname
= "sysrq",
1764 .maxlen
= sizeof (int),
1766 .proc_handler
= sysrq_sysctl_handler
,
1769 #ifdef CONFIG_PROC_SYSCTL
1771 .procname
= "cad_pid",
1773 .maxlen
= sizeof (int),
1775 .proc_handler
= proc_do_cad_pid
,
1779 .procname
= "threads-max",
1781 .maxlen
= sizeof(int),
1783 .proc_handler
= sysctl_max_threads
,
1786 .procname
= "overflowuid",
1787 .data
= &overflowuid
,
1788 .maxlen
= sizeof(int),
1790 .proc_handler
= proc_dointvec_minmax
,
1791 .extra1
= SYSCTL_ZERO
,
1792 .extra2
= SYSCTL_MAXOLDUID
,
1795 .procname
= "overflowgid",
1796 .data
= &overflowgid
,
1797 .maxlen
= sizeof(int),
1799 .proc_handler
= proc_dointvec_minmax
,
1800 .extra1
= SYSCTL_ZERO
,
1801 .extra2
= SYSCTL_MAXOLDUID
,
1805 .procname
= "userprocess_debug",
1806 .data
= &show_unhandled_signals
,
1807 .maxlen
= sizeof(int),
1809 .proc_handler
= proc_dointvec
,
1813 .procname
= "pid_max",
1815 .maxlen
= sizeof (int),
1817 .proc_handler
= proc_dointvec_minmax
,
1818 .extra1
= &pid_max_min
,
1819 .extra2
= &pid_max_max
,
1822 .procname
= "panic_on_oops",
1823 .data
= &panic_on_oops
,
1824 .maxlen
= sizeof(int),
1826 .proc_handler
= proc_dointvec
,
1829 .procname
= "panic_print",
1830 .data
= &panic_print
,
1831 .maxlen
= sizeof(unsigned long),
1833 .proc_handler
= proc_doulongvec_minmax
,
1836 .procname
= "ngroups_max",
1837 .data
= (void *)&ngroups_max
,
1838 .maxlen
= sizeof (int),
1840 .proc_handler
= proc_dointvec
,
1843 .procname
= "cap_last_cap",
1844 .data
= (void *)&cap_last_cap
,
1845 .maxlen
= sizeof(int),
1847 .proc_handler
= proc_dointvec
,
1849 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
1851 .procname
= "unknown_nmi_panic",
1852 .data
= &unknown_nmi_panic
,
1853 .maxlen
= sizeof (int),
1855 .proc_handler
= proc_dointvec
,
1859 #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \
1860 defined(CONFIG_DEBUG_STACKOVERFLOW)
1862 .procname
= "panic_on_stackoverflow",
1863 .data
= &sysctl_panic_on_stackoverflow
,
1864 .maxlen
= sizeof(int),
1866 .proc_handler
= proc_dointvec
,
1869 #if defined(CONFIG_X86)
1871 .procname
= "panic_on_unrecovered_nmi",
1872 .data
= &panic_on_unrecovered_nmi
,
1873 .maxlen
= sizeof(int),
1875 .proc_handler
= proc_dointvec
,
1878 .procname
= "panic_on_io_nmi",
1879 .data
= &panic_on_io_nmi
,
1880 .maxlen
= sizeof(int),
1882 .proc_handler
= proc_dointvec
,
1885 .procname
= "bootloader_type",
1886 .data
= &bootloader_type
,
1887 .maxlen
= sizeof (int),
1889 .proc_handler
= proc_dointvec
,
1892 .procname
= "bootloader_version",
1893 .data
= &bootloader_version
,
1894 .maxlen
= sizeof (int),
1896 .proc_handler
= proc_dointvec
,
1899 .procname
= "io_delay_type",
1900 .data
= &io_delay_type
,
1901 .maxlen
= sizeof(int),
1903 .proc_handler
= proc_dointvec
,
1906 #if defined(CONFIG_MMU)
1908 .procname
= "randomize_va_space",
1909 .data
= &randomize_va_space
,
1910 .maxlen
= sizeof(int),
1912 .proc_handler
= proc_dointvec
,
1915 #if defined(CONFIG_S390) && defined(CONFIG_SMP)
1917 .procname
= "spin_retry",
1918 .data
= &spin_retry
,
1919 .maxlen
= sizeof (int),
1921 .proc_handler
= proc_dointvec
,
1924 #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
1926 .procname
= "acpi_video_flags",
1927 .data
= &acpi_realmode_flags
,
1928 .maxlen
= sizeof (unsigned long),
1930 .proc_handler
= proc_doulongvec_minmax
,
1933 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1935 .procname
= "ignore-unaligned-usertrap",
1936 .data
= &no_unaligned_warning
,
1937 .maxlen
= sizeof (int),
1939 .proc_handler
= proc_dointvec
,
1942 #ifdef CONFIG_RT_MUTEXES
1944 .procname
= "max_lock_depth",
1945 .data
= &max_lock_depth
,
1946 .maxlen
= sizeof(int),
1948 .proc_handler
= proc_dointvec
,
1951 #ifdef CONFIG_PERF_EVENTS
1953 * User-space scripts rely on the existence of this file
1954 * as a feature check for perf_events being enabled.
1956 * So it's an ABI, do not remove!
1959 .procname
= "perf_event_paranoid",
1960 .data
= &sysctl_perf_event_paranoid
,
1961 .maxlen
= sizeof(sysctl_perf_event_paranoid
),
1963 .proc_handler
= proc_dointvec
,
1966 .procname
= "perf_event_mlock_kb",
1967 .data
= &sysctl_perf_event_mlock
,
1968 .maxlen
= sizeof(sysctl_perf_event_mlock
),
1970 .proc_handler
= proc_dointvec
,
1973 .procname
= "perf_event_max_sample_rate",
1974 .data
= &sysctl_perf_event_sample_rate
,
1975 .maxlen
= sizeof(sysctl_perf_event_sample_rate
),
1977 .proc_handler
= perf_event_max_sample_rate_handler
,
1978 .extra1
= SYSCTL_ONE
,
1981 .procname
= "perf_cpu_time_max_percent",
1982 .data
= &sysctl_perf_cpu_time_max_percent
,
1983 .maxlen
= sizeof(sysctl_perf_cpu_time_max_percent
),
1985 .proc_handler
= perf_cpu_time_max_percent_handler
,
1986 .extra1
= SYSCTL_ZERO
,
1987 .extra2
= SYSCTL_ONE_HUNDRED
,
1990 .procname
= "perf_event_max_stack",
1991 .data
= &sysctl_perf_event_max_stack
,
1992 .maxlen
= sizeof(sysctl_perf_event_max_stack
),
1994 .proc_handler
= perf_event_max_stack_handler
,
1995 .extra1
= SYSCTL_ZERO
,
1996 .extra2
= (void *)&six_hundred_forty_kb
,
1999 .procname
= "perf_event_max_contexts_per_stack",
2000 .data
= &sysctl_perf_event_max_contexts_per_stack
,
2001 .maxlen
= sizeof(sysctl_perf_event_max_contexts_per_stack
),
2003 .proc_handler
= perf_event_max_stack_handler
,
2004 .extra1
= SYSCTL_ZERO
,
2005 .extra2
= SYSCTL_ONE_THOUSAND
,
2009 .procname
= "panic_on_warn",
2010 .data
= &panic_on_warn
,
2011 .maxlen
= sizeof(int),
2013 .proc_handler
= proc_dointvec_minmax
,
2014 .extra1
= SYSCTL_ZERO
,
2015 .extra2
= SYSCTL_ONE
,
2017 #ifdef CONFIG_TREE_RCU
2019 .procname
= "panic_on_rcu_stall",
2020 .data
= &sysctl_panic_on_rcu_stall
,
2021 .maxlen
= sizeof(sysctl_panic_on_rcu_stall
),
2023 .proc_handler
= proc_dointvec_minmax
,
2024 .extra1
= SYSCTL_ZERO
,
2025 .extra2
= SYSCTL_ONE
,
2028 .procname
= "max_rcu_stall_to_panic",
2029 .data
= &sysctl_max_rcu_stall_to_panic
,
2030 .maxlen
= sizeof(sysctl_max_rcu_stall_to_panic
),
2032 .proc_handler
= proc_dointvec_minmax
,
2033 .extra1
= SYSCTL_ONE
,
2034 .extra2
= SYSCTL_INT_MAX
,
2040 static struct ctl_table vm_table
[] = {
2042 .procname
= "overcommit_memory",
2043 .data
= &sysctl_overcommit_memory
,
2044 .maxlen
= sizeof(sysctl_overcommit_memory
),
2046 .proc_handler
= overcommit_policy_handler
,
2047 .extra1
= SYSCTL_ZERO
,
2048 .extra2
= SYSCTL_TWO
,
2051 .procname
= "overcommit_ratio",
2052 .data
= &sysctl_overcommit_ratio
,
2053 .maxlen
= sizeof(sysctl_overcommit_ratio
),
2055 .proc_handler
= overcommit_ratio_handler
,
2058 .procname
= "overcommit_kbytes",
2059 .data
= &sysctl_overcommit_kbytes
,
2060 .maxlen
= sizeof(sysctl_overcommit_kbytes
),
2062 .proc_handler
= overcommit_kbytes_handler
,
2065 .procname
= "page-cluster",
2066 .data
= &page_cluster
,
2067 .maxlen
= sizeof(int),
2069 .proc_handler
= proc_dointvec_minmax
,
2070 .extra1
= SYSCTL_ZERO
,
2071 .extra2
= (void *)&page_cluster_max
,
2074 .procname
= "dirtytime_expire_seconds",
2075 .data
= &dirtytime_expire_interval
,
2076 .maxlen
= sizeof(dirtytime_expire_interval
),
2078 .proc_handler
= dirtytime_interval_handler
,
2079 .extra1
= SYSCTL_ZERO
,
2082 .procname
= "swappiness",
2083 .data
= &vm_swappiness
,
2084 .maxlen
= sizeof(vm_swappiness
),
2086 .proc_handler
= proc_dointvec_minmax
,
2087 .extra1
= SYSCTL_ZERO
,
2088 .extra2
= SYSCTL_TWO_HUNDRED
,
2092 .procname
= "numa_stat",
2093 .data
= &sysctl_vm_numa_stat
,
2094 .maxlen
= sizeof(int),
2096 .proc_handler
= sysctl_vm_numa_stat_handler
,
2097 .extra1
= SYSCTL_ZERO
,
2098 .extra2
= SYSCTL_ONE
,
2102 .procname
= "drop_caches",
2103 .data
= &sysctl_drop_caches
,
2104 .maxlen
= sizeof(int),
2106 .proc_handler
= drop_caches_sysctl_handler
,
2107 .extra1
= SYSCTL_ONE
,
2108 .extra2
= SYSCTL_FOUR
,
2111 .procname
= "page_lock_unfairness",
2112 .data
= &sysctl_page_lock_unfairness
,
2113 .maxlen
= sizeof(sysctl_page_lock_unfairness
),
2115 .proc_handler
= proc_dointvec_minmax
,
2116 .extra1
= SYSCTL_ZERO
,
2120 .procname
= "max_map_count",
2121 .data
= &sysctl_max_map_count
,
2122 .maxlen
= sizeof(sysctl_max_map_count
),
2124 .proc_handler
= proc_dointvec_minmax
,
2125 .extra1
= SYSCTL_ZERO
,
2129 .procname
= "nr_trim_pages",
2130 .data
= &sysctl_nr_trim_pages
,
2131 .maxlen
= sizeof(sysctl_nr_trim_pages
),
2133 .proc_handler
= proc_dointvec_minmax
,
2134 .extra1
= SYSCTL_ZERO
,
2138 .procname
= "vfs_cache_pressure",
2139 .data
= &sysctl_vfs_cache_pressure
,
2140 .maxlen
= sizeof(sysctl_vfs_cache_pressure
),
2142 .proc_handler
= proc_dointvec_minmax
,
2143 .extra1
= SYSCTL_ZERO
,
2145 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
2146 defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
2148 .procname
= "legacy_va_layout",
2149 .data
= &sysctl_legacy_va_layout
,
2150 .maxlen
= sizeof(sysctl_legacy_va_layout
),
2152 .proc_handler
= proc_dointvec_minmax
,
2153 .extra1
= SYSCTL_ZERO
,
2158 .procname
= "zone_reclaim_mode",
2159 .data
= &node_reclaim_mode
,
2160 .maxlen
= sizeof(node_reclaim_mode
),
2162 .proc_handler
= proc_dointvec_minmax
,
2163 .extra1
= SYSCTL_ZERO
,
2168 .procname
= "stat_interval",
2169 .data
= &sysctl_stat_interval
,
2170 .maxlen
= sizeof(sysctl_stat_interval
),
2172 .proc_handler
= proc_dointvec_jiffies
,
2175 .procname
= "stat_refresh",
2179 .proc_handler
= vmstat_refresh
,
2184 .procname
= "mmap_min_addr",
2185 .data
= &dac_mmap_min_addr
,
2186 .maxlen
= sizeof(unsigned long),
2188 .proc_handler
= mmap_min_addr_handler
,
2191 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
2192 (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
2194 .procname
= "vdso_enabled",
2195 #ifdef CONFIG_X86_32
2196 .data
= &vdso32_enabled
,
2197 .maxlen
= sizeof(vdso32_enabled
),
2199 .data
= &vdso_enabled
,
2200 .maxlen
= sizeof(vdso_enabled
),
2203 .proc_handler
= proc_dointvec
,
2204 .extra1
= SYSCTL_ZERO
,
2208 .procname
= "user_reserve_kbytes",
2209 .data
= &sysctl_user_reserve_kbytes
,
2210 .maxlen
= sizeof(sysctl_user_reserve_kbytes
),
2212 .proc_handler
= proc_doulongvec_minmax
,
2215 .procname
= "admin_reserve_kbytes",
2216 .data
= &sysctl_admin_reserve_kbytes
,
2217 .maxlen
= sizeof(sysctl_admin_reserve_kbytes
),
2219 .proc_handler
= proc_doulongvec_minmax
,
2221 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
2223 .procname
= "mmap_rnd_bits",
2224 .data
= &mmap_rnd_bits
,
2225 .maxlen
= sizeof(mmap_rnd_bits
),
2227 .proc_handler
= proc_dointvec_minmax
,
2228 .extra1
= (void *)&mmap_rnd_bits_min
,
2229 .extra2
= (void *)&mmap_rnd_bits_max
,
2232 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
2234 .procname
= "mmap_rnd_compat_bits",
2235 .data
= &mmap_rnd_compat_bits
,
2236 .maxlen
= sizeof(mmap_rnd_compat_bits
),
2238 .proc_handler
= proc_dointvec_minmax
,
2239 .extra1
= (void *)&mmap_rnd_compat_bits_min
,
2240 .extra2
= (void *)&mmap_rnd_compat_bits_max
,
2246 int __init
sysctl_init_bases(void)
2248 register_sysctl_init("kernel", kern_table
);
2249 register_sysctl_init("vm", vm_table
);
2253 #endif /* CONFIG_SYSCTL */
2255 * No sense putting this after each symbol definition, twice,
2256 * exception granted :-)
2258 EXPORT_SYMBOL(proc_dobool
);
2259 EXPORT_SYMBOL(proc_dointvec
);
2260 EXPORT_SYMBOL(proc_douintvec
);
2261 EXPORT_SYMBOL(proc_dointvec_jiffies
);
2262 EXPORT_SYMBOL(proc_dointvec_minmax
);
2263 EXPORT_SYMBOL_GPL(proc_douintvec_minmax
);
2264 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies
);
2265 EXPORT_SYMBOL(proc_dointvec_ms_jiffies
);
2266 EXPORT_SYMBOL(proc_dostring
);
2267 EXPORT_SYMBOL(proc_doulongvec_minmax
);
2268 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax
);
2269 EXPORT_SYMBOL(proc_do_large_bitmap
);