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