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/aio.h>
24 : #include <linux/mm.h>
25 : #include <linux/swap.h>
26 : #include <linux/slab.h>
27 : #include <linux/sysctl.h>
28 : #include <linux/bitmap.h>
29 : #include <linux/signal.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/fs.h>
36 : #include <linux/init.h>
37 : #include <linux/kernel.h>
38 : #include <linux/kobject.h>
39 : #include <linux/net.h>
40 : #include <linux/sysrq.h>
41 : #include <linux/highuid.h>
42 : #include <linux/writeback.h>
43 : #include <linux/ratelimit.h>
44 : #include <linux/compaction.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/dnotify.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/kprobes.h>
60 : #include <linux/pipe_fs_i.h>
61 : #include <linux/oom.h>
62 : #include <linux/kmod.h>
63 : #include <linux/capability.h>
64 : #include <linux/binfmts.h>
65 : #include <linux/sched/sysctl.h>
66 : #include <linux/sched/coredump.h>
67 : #include <linux/kexec.h>
68 : #include <linux/bpf.h>
69 : #include <linux/mount.h>
70 : #include <linux/userfaultfd_k.h>
71 : #include <linux/coredump.h>
72 : #include <linux/latencytop.h>
73 : #include <linux/pid.h>
74 :
75 : #include "../lib/kstrtox.h"
76 :
77 : #include <linux/uaccess.h>
78 : #include <asm/processor.h>
79 :
80 : #ifdef CONFIG_X86
81 : #include <asm/nmi.h>
82 : #include <asm/stacktrace.h>
83 : #include <asm/io.h>
84 : #endif
85 : #ifdef CONFIG_SPARC
86 : #include <asm/setup.h>
87 : #endif
88 : #ifdef CONFIG_BSD_PROCESS_ACCT
89 : #include <linux/acct.h>
90 : #endif
91 : #ifdef CONFIG_RT_MUTEXES
92 : #include <linux/rtmutex.h>
93 : #endif
94 : #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
95 : #include <linux/lockdep.h>
96 : #endif
97 : #ifdef CONFIG_CHR_DEV_SG
98 : #include <scsi/sg.h>
99 : #endif
100 : #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
101 : #include <linux/stackleak.h>
102 : #endif
103 : #ifdef CONFIG_LOCKUP_DETECTOR
104 : #include <linux/nmi.h>
105 : #endif
106 :
107 : #if defined(CONFIG_SYSCTL)
108 :
109 : /* Constants used for minimum and maximum */
110 : #ifdef CONFIG_LOCKUP_DETECTOR
111 : static int sixty = 60;
112 : #endif
113 :
114 : static int __maybe_unused neg_one = -1;
115 : static int __maybe_unused two = 2;
116 : static int __maybe_unused four = 4;
117 : static unsigned long zero_ul;
118 : static unsigned long one_ul = 1;
119 : static unsigned long long_max = LONG_MAX;
120 : static int one_hundred = 100;
121 : static int two_hundred = 200;
122 : static int one_thousand = 1000;
123 : #ifdef CONFIG_PRINTK
124 : static int ten_thousand = 10000;
125 : #endif
126 : #ifdef CONFIG_PERF_EVENTS
127 : static int six_hundred_forty_kb = 640 * 1024;
128 : #endif
129 :
130 : /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
131 : static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
132 :
133 : /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
134 : static int maxolduid = 65535;
135 : static int minolduid;
136 :
137 : static int ngroups_max = NGROUPS_MAX;
138 : static const int cap_last_cap = CAP_LAST_CAP;
139 :
140 : /*
141 : * This is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs
142 : * and hung_task_check_interval_secs
143 : */
144 : #ifdef CONFIG_DETECT_HUNG_TASK
145 : static unsigned long hung_task_timeout_max = (LONG_MAX/HZ);
146 : #endif
147 :
148 : #ifdef CONFIG_INOTIFY_USER
149 : #include <linux/inotify.h>
150 : #endif
151 :
152 : #ifdef CONFIG_PROC_SYSCTL
153 :
154 : /**
155 : * enum sysctl_writes_mode - supported sysctl write modes
156 : *
157 : * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
158 : * to be written, and multiple writes on the same sysctl file descriptor
159 : * will rewrite the sysctl value, regardless of file position. No warning
160 : * is issued when the initial position is not 0.
161 : * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
162 : * not 0.
163 : * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
164 : * file position 0 and the value must be fully contained in the buffer
165 : * sent to the write syscall. If dealing with strings respect the file
166 : * position, but restrict this to the max length of the buffer, anything
167 : * passed the max length will be ignored. Multiple writes will append
168 : * to the buffer.
169 : *
170 : * These write modes control how current file position affects the behavior of
171 : * updating sysctl values through the proc interface on each write.
172 : */
173 : enum sysctl_writes_mode {
174 : SYSCTL_WRITES_LEGACY = -1,
175 : SYSCTL_WRITES_WARN = 0,
176 : SYSCTL_WRITES_STRICT = 1,
177 : };
178 :
179 : static enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT;
180 : #endif /* CONFIG_PROC_SYSCTL */
181 :
182 : #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
183 : defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
184 : int sysctl_legacy_va_layout;
185 : #endif
186 :
187 : #ifdef CONFIG_SCHED_DEBUG
188 : static int min_sched_granularity_ns = 100000; /* 100 usecs */
189 : static int max_sched_granularity_ns = NSEC_PER_SEC; /* 1 second */
190 : static int min_wakeup_granularity_ns; /* 0 usecs */
191 : static int max_wakeup_granularity_ns = NSEC_PER_SEC; /* 1 second */
192 : #ifdef CONFIG_SMP
193 : static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
194 : static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
195 : #endif /* CONFIG_SMP */
196 : #endif /* CONFIG_SCHED_DEBUG */
197 :
198 : #ifdef CONFIG_COMPACTION
199 : static int min_extfrag_threshold;
200 : static int max_extfrag_threshold = 1000;
201 : #endif
202 :
203 : #endif /* CONFIG_SYSCTL */
204 :
205 : #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_SYSCTL)
206 : static int bpf_stats_handler(struct ctl_table *table, int write,
207 : void *buffer, size_t *lenp, loff_t *ppos)
208 : {
209 : struct static_key *key = (struct static_key *)table->data;
210 : static int saved_val;
211 : int val, ret;
212 : struct ctl_table tmp = {
213 : .data = &val,
214 : .maxlen = sizeof(val),
215 : .mode = table->mode,
216 : .extra1 = SYSCTL_ZERO,
217 : .extra2 = SYSCTL_ONE,
218 : };
219 :
220 : if (write && !capable(CAP_SYS_ADMIN))
221 : return -EPERM;
222 :
223 : mutex_lock(&bpf_stats_enabled_mutex);
224 : val = saved_val;
225 : ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
226 : if (write && !ret && val != saved_val) {
227 : if (val)
228 : static_key_slow_inc(key);
229 : else
230 : static_key_slow_dec(key);
231 : saved_val = val;
232 : }
233 : mutex_unlock(&bpf_stats_enabled_mutex);
234 : return ret;
235 : }
236 : #endif
237 :
238 : /*
239 : * /proc/sys support
240 : */
241 :
242 : #ifdef CONFIG_PROC_SYSCTL
243 :
244 16 : static int _proc_do_string(char *data, int maxlen, int write,
245 : char *buffer, size_t *lenp, loff_t *ppos)
246 : {
247 16 : size_t len;
248 16 : char c, *p;
249 :
250 16 : if (!data || !maxlen || !*lenp) {
251 0 : *lenp = 0;
252 0 : return 0;
253 : }
254 :
255 16 : if (write) {
256 0 : if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
257 : /* Only continue writes not past the end of buffer. */
258 0 : len = strlen(data);
259 0 : if (len > maxlen - 1)
260 : len = maxlen - 1;
261 :
262 0 : if (*ppos > len)
263 : return 0;
264 : len = *ppos;
265 : } else {
266 : /* Start writing from beginning of buffer. */
267 : len = 0;
268 : }
269 :
270 0 : *ppos += *lenp;
271 0 : p = buffer;
272 0 : while ((p - buffer) < *lenp && len < maxlen - 1) {
273 0 : c = *(p++);
274 0 : if (c == 0 || c == '\n')
275 : break;
276 0 : data[len++] = c;
277 : }
278 0 : data[len] = 0;
279 : } else {
280 16 : len = strlen(data);
281 16 : if (len > maxlen)
282 : len = maxlen;
283 :
284 16 : if (*ppos > len) {
285 8 : *lenp = 0;
286 8 : return 0;
287 : }
288 :
289 8 : data += *ppos;
290 8 : len -= *ppos;
291 :
292 8 : if (len > *lenp)
293 : len = *lenp;
294 8 : if (len)
295 8 : memcpy(buffer, data, len);
296 8 : if (len < *lenp) {
297 8 : buffer[len] = '\n';
298 8 : len++;
299 : }
300 8 : *lenp = len;
301 8 : *ppos += len;
302 : }
303 : return 0;
304 : }
305 :
306 0 : static void warn_sysctl_write(struct ctl_table *table)
307 : {
308 0 : pr_warn_once("%s wrote to %s when file position was not 0!\n"
309 : "This will not be supported in the future. To silence this\n"
310 : "warning, set kernel.sysctl_writes_strict = -1\n",
311 : current->comm, table->procname);
312 0 : }
313 :
314 : /**
315 : * proc_first_pos_non_zero_ignore - check if first position is allowed
316 : * @ppos: file position
317 : * @table: the sysctl table
318 : *
319 : * Returns true if the first position is non-zero and the sysctl_writes_strict
320 : * mode indicates this is not allowed for numeric input types. String proc
321 : * handlers can ignore the return value.
322 : */
323 4 : static bool proc_first_pos_non_zero_ignore(loff_t *ppos,
324 : struct ctl_table *table)
325 : {
326 4 : if (!*ppos)
327 : return false;
328 :
329 0 : switch (sysctl_writes_strict) {
330 : case SYSCTL_WRITES_STRICT:
331 : return true;
332 0 : case SYSCTL_WRITES_WARN:
333 0 : warn_sysctl_write(table);
334 0 : return false;
335 0 : default:
336 0 : return false;
337 : }
338 : }
339 :
340 : /**
341 : * proc_dostring - read a string sysctl
342 : * @table: the sysctl table
343 : * @write: %TRUE if this is a write to the sysctl file
344 : * @buffer: the user buffer
345 : * @lenp: the size of the user buffer
346 : * @ppos: file position
347 : *
348 : * Reads/writes a string from/to the user buffer. If the kernel
349 : * buffer provided is not large enough to hold the string, the
350 : * string is truncated. The copied string is %NULL-terminated.
351 : * If the string is being read by the user process, it is copied
352 : * and a newline '\n' is added. It is truncated if the buffer is
353 : * not large enough.
354 : *
355 : * Returns 0 on success.
356 : */
357 16 : int proc_dostring(struct ctl_table *table, int write,
358 : void *buffer, size_t *lenp, loff_t *ppos)
359 : {
360 16 : if (write)
361 0 : proc_first_pos_non_zero_ignore(ppos, table);
362 :
363 16 : return _proc_do_string(table->data, table->maxlen, write, buffer, lenp,
364 : ppos);
365 : }
366 :
367 7 : static size_t proc_skip_spaces(char **buf)
368 : {
369 7 : size_t ret;
370 14 : char *tmp = skip_spaces(*buf);
371 7 : ret = tmp - *buf;
372 7 : *buf = tmp;
373 7 : return ret;
374 : }
375 :
376 : static void proc_skip_char(char **buf, size_t *size, const char v)
377 : {
378 0 : while (*size) {
379 0 : if (**buf != v)
380 : break;
381 0 : (*size)--;
382 0 : (*buf)++;
383 : }
384 : }
385 :
386 : /**
387 : * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
388 : * fail on overflow
389 : *
390 : * @cp: kernel buffer containing the string to parse
391 : * @endp: pointer to store the trailing characters
392 : * @base: the base to use
393 : * @res: where the parsed integer will be stored
394 : *
395 : * In case of success 0 is returned and @res will contain the parsed integer,
396 : * @endp will hold any trailing characters.
397 : * This function will fail the parse on overflow. If there wasn't an overflow
398 : * the function will defer the decision what characters count as invalid to the
399 : * caller.
400 : */
401 4 : static int strtoul_lenient(const char *cp, char **endp, unsigned int base,
402 : unsigned long *res)
403 : {
404 4 : unsigned long long result;
405 4 : unsigned int rv;
406 :
407 4 : cp = _parse_integer_fixup_radix(cp, &base);
408 4 : rv = _parse_integer(cp, base, &result);
409 4 : if ((rv & KSTRTOX_OVERFLOW) || (result != (unsigned long)result))
410 : return -ERANGE;
411 :
412 4 : cp += rv;
413 :
414 4 : if (endp)
415 4 : *endp = (char *)cp;
416 :
417 4 : *res = (unsigned long)result;
418 4 : return 0;
419 : }
420 :
421 : #define TMPBUFLEN 22
422 : /**
423 : * proc_get_long - reads an ASCII formatted integer from a user buffer
424 : *
425 : * @buf: a kernel buffer
426 : * @size: size of the kernel buffer
427 : * @val: this is where the number will be stored
428 : * @neg: set to %TRUE if number is negative
429 : * @perm_tr: a vector which contains the allowed trailers
430 : * @perm_tr_len: size of the perm_tr vector
431 : * @tr: pointer to store the trailer character
432 : *
433 : * In case of success %0 is returned and @buf and @size are updated with
434 : * the amount of bytes read. If @tr is non-NULL and a trailing
435 : * character exists (size is non-zero after returning from this
436 : * function), @tr is updated with the trailing character.
437 : */
438 4 : static int proc_get_long(char **buf, size_t *size,
439 : unsigned long *val, bool *neg,
440 : const char *perm_tr, unsigned perm_tr_len, char *tr)
441 : {
442 4 : int len;
443 4 : char *p, tmp[TMPBUFLEN];
444 :
445 4 : if (!*size)
446 : return -EINVAL;
447 :
448 4 : len = *size;
449 4 : if (len > TMPBUFLEN - 1)
450 : len = TMPBUFLEN - 1;
451 :
452 4 : memcpy(tmp, *buf, len);
453 :
454 4 : tmp[len] = 0;
455 4 : p = tmp;
456 4 : if (*p == '-' && *size > 1) {
457 0 : *neg = true;
458 0 : p++;
459 : } else
460 4 : *neg = false;
461 4 : if (!isdigit(*p))
462 : return -EINVAL;
463 :
464 4 : if (strtoul_lenient(p, &p, 0, val))
465 : return -EINVAL;
466 :
467 4 : len = p - tmp;
468 :
469 : /* We don't know if the next char is whitespace thus we may accept
470 : * invalid integers (e.g. 1234...a) or two integers instead of one
471 : * (e.g. 123...1). So lets not allow such large numbers. */
472 4 : if (len == TMPBUFLEN - 1)
473 : return -EINVAL;
474 :
475 4 : if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
476 : return -EINVAL;
477 :
478 4 : if (tr && (len < *size))
479 0 : *tr = *p;
480 :
481 4 : *buf += len;
482 4 : *size -= len;
483 :
484 4 : return 0;
485 : }
486 :
487 : /**
488 : * proc_put_long - converts an integer to a decimal ASCII formatted string
489 : *
490 : * @buf: the user buffer
491 : * @size: the size of the user buffer
492 : * @val: the integer to be converted
493 : * @neg: sign of the number, %TRUE for negative
494 : *
495 : * In case of success @buf and @size are updated with the amount of bytes
496 : * written.
497 : */
498 29 : static void proc_put_long(void **buf, size_t *size, unsigned long val, bool neg)
499 : {
500 29 : int len;
501 29 : char tmp[TMPBUFLEN], *p = tmp;
502 :
503 29 : sprintf(p, "%s%lu", neg ? "-" : "", val);
504 29 : len = strlen(tmp);
505 29 : if (len > *size)
506 0 : len = *size;
507 29 : memcpy(*buf, tmp, len);
508 29 : *size -= len;
509 29 : *buf += len;
510 29 : }
511 : #undef TMPBUFLEN
512 :
513 29 : static void proc_put_char(void **buf, size_t *size, char c)
514 : {
515 29 : if (*size) {
516 29 : char **buffer = (char **)buf;
517 29 : **buffer = c;
518 :
519 29 : (*size)--;
520 29 : (*buffer)++;
521 0 : *buf = *buffer;
522 : }
523 29 : }
524 :
525 32 : static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
526 : int *valp,
527 : int write, void *data)
528 : {
529 32 : if (write) {
530 3 : if (*negp) {
531 0 : if (*lvalp > (unsigned long) INT_MAX + 1)
532 : return -EINVAL;
533 0 : *valp = -*lvalp;
534 : } else {
535 3 : if (*lvalp > (unsigned long) INT_MAX)
536 : return -EINVAL;
537 3 : *valp = *lvalp;
538 : }
539 : } else {
540 29 : int val = *valp;
541 29 : if (val < 0) {
542 0 : *negp = true;
543 0 : *lvalp = -(unsigned long)val;
544 : } else {
545 29 : *negp = false;
546 29 : *lvalp = (unsigned long)val;
547 : }
548 : }
549 : return 0;
550 : }
551 :
552 0 : static int do_proc_douintvec_conv(unsigned long *lvalp,
553 : unsigned int *valp,
554 : int write, void *data)
555 : {
556 0 : if (write) {
557 0 : if (*lvalp > UINT_MAX)
558 : return -EINVAL;
559 0 : *valp = *lvalp;
560 : } else {
561 0 : unsigned int val = *valp;
562 0 : *lvalp = (unsigned long)val;
563 : }
564 : return 0;
565 : }
566 :
567 : static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
568 :
569 46 : static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
570 : int write, void *buffer,
571 : size_t *lenp, loff_t *ppos,
572 : int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
573 : int write, void *data),
574 : void *data)
575 : {
576 46 : int *i, vleft, first = 1, err = 0;
577 46 : size_t left;
578 46 : char *p;
579 :
580 46 : if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
581 14 : *lenp = 0;
582 14 : return 0;
583 : }
584 :
585 32 : i = (int *) tbl_data;
586 32 : vleft = table->maxlen / sizeof(*i);
587 32 : left = *lenp;
588 :
589 32 : if (!conv)
590 18 : conv = do_proc_dointvec_conv;
591 :
592 32 : if (write) {
593 3 : if (proc_first_pos_non_zero_ignore(ppos, table))
594 0 : goto out;
595 :
596 3 : if (left > PAGE_SIZE - 1)
597 0 : left = PAGE_SIZE - 1;
598 3 : p = buffer;
599 : }
600 :
601 64 : for (; left && vleft--; i++, first=0) {
602 32 : unsigned long lval;
603 32 : bool neg;
604 :
605 32 : if (write) {
606 3 : left -= proc_skip_spaces(&p);
607 :
608 3 : if (!left)
609 : break;
610 3 : err = proc_get_long(&p, &left, &lval, &neg,
611 : proc_wspace_sep,
612 : sizeof(proc_wspace_sep), NULL);
613 3 : if (err)
614 : break;
615 3 : if (conv(&neg, &lval, i, 1, data)) {
616 : err = -EINVAL;
617 : break;
618 : }
619 : } else {
620 29 : if (conv(&neg, &lval, i, 0, data)) {
621 : err = -EINVAL;
622 : break;
623 : }
624 29 : if (!first)
625 0 : proc_put_char(&buffer, &left, '\t');
626 29 : proc_put_long(&buffer, &left, lval, neg);
627 : }
628 : }
629 :
630 32 : if (!write && !first && left && !err)
631 29 : proc_put_char(&buffer, &left, '\n');
632 32 : if (write && !err && left)
633 3 : left -= proc_skip_spaces(&p);
634 32 : if (write && first)
635 0 : return err ? : -EINVAL;
636 32 : *lenp -= left;
637 32 : out:
638 32 : *ppos += *lenp;
639 32 : return err;
640 : }
641 :
642 46 : static int do_proc_dointvec(struct ctl_table *table, int write,
643 : void *buffer, size_t *lenp, loff_t *ppos,
644 : int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
645 : int write, void *data),
646 : void *data)
647 : {
648 46 : return __do_proc_dointvec(table->data, table, write,
649 : buffer, lenp, ppos, conv, data);
650 : }
651 :
652 0 : static int do_proc_douintvec_w(unsigned int *tbl_data,
653 : struct ctl_table *table,
654 : void *buffer,
655 : size_t *lenp, loff_t *ppos,
656 : int (*conv)(unsigned long *lvalp,
657 : unsigned int *valp,
658 : int write, void *data),
659 : void *data)
660 : {
661 0 : unsigned long lval;
662 0 : int err = 0;
663 0 : size_t left;
664 0 : bool neg;
665 0 : char *p = buffer;
666 :
667 0 : left = *lenp;
668 :
669 0 : if (proc_first_pos_non_zero_ignore(ppos, table))
670 0 : goto bail_early;
671 :
672 0 : if (left > PAGE_SIZE - 1)
673 0 : left = PAGE_SIZE - 1;
674 :
675 0 : left -= proc_skip_spaces(&p);
676 0 : if (!left) {
677 0 : err = -EINVAL;
678 0 : goto out_free;
679 : }
680 :
681 0 : err = proc_get_long(&p, &left, &lval, &neg,
682 : proc_wspace_sep,
683 : sizeof(proc_wspace_sep), NULL);
684 0 : if (err || neg) {
685 0 : err = -EINVAL;
686 0 : goto out_free;
687 : }
688 :
689 0 : if (conv(&lval, tbl_data, 1, data)) {
690 0 : err = -EINVAL;
691 0 : goto out_free;
692 : }
693 :
694 0 : if (!err && left)
695 0 : left -= proc_skip_spaces(&p);
696 :
697 0 : out_free:
698 0 : if (err)
699 0 : return -EINVAL;
700 :
701 : return 0;
702 :
703 : /* This is in keeping with old __do_proc_dointvec() */
704 0 : bail_early:
705 0 : *ppos += *lenp;
706 0 : return err;
707 : }
708 :
709 0 : static int do_proc_douintvec_r(unsigned int *tbl_data, void *buffer,
710 : size_t *lenp, loff_t *ppos,
711 : int (*conv)(unsigned long *lvalp,
712 : unsigned int *valp,
713 : int write, void *data),
714 : void *data)
715 : {
716 0 : unsigned long lval;
717 0 : int err = 0;
718 0 : size_t left;
719 :
720 0 : left = *lenp;
721 :
722 0 : if (conv(&lval, tbl_data, 0, data)) {
723 0 : err = -EINVAL;
724 0 : goto out;
725 : }
726 :
727 0 : proc_put_long(&buffer, &left, lval, false);
728 0 : if (!left)
729 0 : goto out;
730 :
731 0 : proc_put_char(&buffer, &left, '\n');
732 :
733 0 : out:
734 0 : *lenp -= left;
735 0 : *ppos += *lenp;
736 :
737 0 : return err;
738 : }
739 :
740 0 : static int __do_proc_douintvec(void *tbl_data, struct ctl_table *table,
741 : int write, void *buffer,
742 : size_t *lenp, loff_t *ppos,
743 : int (*conv)(unsigned long *lvalp,
744 : unsigned int *valp,
745 : int write, void *data),
746 : void *data)
747 : {
748 0 : unsigned int *i, vleft;
749 :
750 0 : if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
751 0 : *lenp = 0;
752 0 : return 0;
753 : }
754 :
755 0 : i = (unsigned int *) tbl_data;
756 0 : vleft = table->maxlen / sizeof(*i);
757 :
758 : /*
759 : * Arrays are not supported, keep this simple. *Do not* add
760 : * support for them.
761 : */
762 0 : if (vleft != 1) {
763 0 : *lenp = 0;
764 0 : return -EINVAL;
765 : }
766 :
767 0 : if (!conv)
768 0 : conv = do_proc_douintvec_conv;
769 :
770 0 : if (write)
771 0 : return do_proc_douintvec_w(i, table, buffer, lenp, ppos,
772 : conv, data);
773 0 : return do_proc_douintvec_r(i, buffer, lenp, ppos, conv, data);
774 : }
775 :
776 0 : static int do_proc_douintvec(struct ctl_table *table, int write,
777 : void *buffer, size_t *lenp, loff_t *ppos,
778 : int (*conv)(unsigned long *lvalp,
779 : unsigned int *valp,
780 : int write, void *data),
781 : void *data)
782 : {
783 0 : return __do_proc_douintvec(table->data, table, write,
784 : buffer, lenp, ppos, conv, data);
785 : }
786 :
787 : /**
788 : * proc_dointvec - read a vector of integers
789 : * @table: the sysctl table
790 : * @write: %TRUE if this is a write to the sysctl file
791 : * @buffer: the user buffer
792 : * @lenp: the size of the user buffer
793 : * @ppos: file position
794 : *
795 : * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
796 : * values from/to the user buffer, treated as an ASCII string.
797 : *
798 : * Returns 0 on success.
799 : */
800 20 : int proc_dointvec(struct ctl_table *table, int write, void *buffer,
801 : size_t *lenp, loff_t *ppos)
802 : {
803 20 : return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL);
804 : }
805 :
806 : #ifdef CONFIG_COMPACTION
807 0 : static int proc_dointvec_minmax_warn_RT_change(struct ctl_table *table,
808 : int write, void *buffer, size_t *lenp, loff_t *ppos)
809 : {
810 0 : int ret, old;
811 :
812 0 : if (!IS_ENABLED(CONFIG_PREEMPT_RT) || !write)
813 0 : return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
814 :
815 : old = *(int *)table->data;
816 : ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
817 : if (ret)
818 : return ret;
819 : if (old != *(int *)table->data)
820 : pr_warn_once("sysctl attribute %s changed by %s[%d]\n",
821 : table->procname, current->comm,
822 : task_pid_nr(current));
823 : return ret;
824 : }
825 : #endif
826 :
827 : /**
828 : * proc_douintvec - read a vector of unsigned integers
829 : * @table: the sysctl table
830 : * @write: %TRUE if this is a write to the sysctl file
831 : * @buffer: the user buffer
832 : * @lenp: the size of the user buffer
833 : * @ppos: file position
834 : *
835 : * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
836 : * values from/to the user buffer, treated as an ASCII string.
837 : *
838 : * Returns 0 on success.
839 : */
840 0 : int proc_douintvec(struct ctl_table *table, int write, void *buffer,
841 : size_t *lenp, loff_t *ppos)
842 : {
843 0 : return do_proc_douintvec(table, write, buffer, lenp, ppos,
844 : do_proc_douintvec_conv, NULL);
845 : }
846 :
847 : /*
848 : * Taint values can only be increased
849 : * This means we can safely use a temporary.
850 : */
851 0 : static int proc_taint(struct ctl_table *table, int write,
852 : void *buffer, size_t *lenp, loff_t *ppos)
853 : {
854 0 : struct ctl_table t;
855 0 : unsigned long tmptaint = get_taint();
856 0 : int err;
857 :
858 0 : if (write && !capable(CAP_SYS_ADMIN))
859 : return -EPERM;
860 :
861 0 : t = *table;
862 0 : t.data = &tmptaint;
863 0 : err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
864 0 : if (err < 0)
865 : return err;
866 :
867 0 : if (write) {
868 0 : int i;
869 :
870 : /*
871 : * If we are relying on panic_on_taint not producing
872 : * false positives due to userspace input, bail out
873 : * before setting the requested taint flags.
874 : */
875 0 : if (panic_on_taint_nousertaint && (tmptaint & panic_on_taint))
876 : return -EINVAL;
877 :
878 : /*
879 : * Poor man's atomic or. Not worth adding a primitive
880 : * to everyone's atomic.h for this
881 : */
882 0 : for (i = 0; i < TAINT_FLAGS_COUNT; i++)
883 0 : if ((1UL << i) & tmptaint)
884 0 : add_taint(i, LOCKDEP_STILL_OK);
885 : }
886 :
887 : return err;
888 : }
889 :
890 : #ifdef CONFIG_PRINTK
891 0 : static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
892 : void *buffer, size_t *lenp, loff_t *ppos)
893 : {
894 0 : if (write && !capable(CAP_SYS_ADMIN))
895 : return -EPERM;
896 :
897 0 : return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
898 : }
899 : #endif
900 :
901 : /**
902 : * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
903 : * @min: pointer to minimum allowable value
904 : * @max: pointer to maximum allowable value
905 : *
906 : * The do_proc_dointvec_minmax_conv_param structure provides the
907 : * minimum and maximum values for doing range checking for those sysctl
908 : * parameters that use the proc_dointvec_minmax() handler.
909 : */
910 : struct do_proc_dointvec_minmax_conv_param {
911 : int *min;
912 : int *max;
913 : };
914 :
915 14 : static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
916 : int *valp,
917 : int write, void *data)
918 : {
919 14 : int tmp, ret;
920 14 : struct do_proc_dointvec_minmax_conv_param *param = data;
921 : /*
922 : * If writing, first do so via a temporary local int so we can
923 : * bounds-check it before touching *valp.
924 : */
925 14 : int *ip = write ? &tmp : valp;
926 :
927 14 : ret = do_proc_dointvec_conv(negp, lvalp, ip, write, data);
928 14 : if (ret)
929 : return ret;
930 :
931 14 : if (write) {
932 2 : if ((param->min && *param->min > tmp) ||
933 2 : (param->max && *param->max < tmp))
934 : return -EINVAL;
935 2 : *valp = tmp;
936 : }
937 :
938 : return 0;
939 : }
940 :
941 : /**
942 : * proc_dointvec_minmax - read a vector of integers with min/max values
943 : * @table: the sysctl table
944 : * @write: %TRUE if this is a write to the sysctl file
945 : * @buffer: the user buffer
946 : * @lenp: the size of the user buffer
947 : * @ppos: file position
948 : *
949 : * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
950 : * values from/to the user buffer, treated as an ASCII string.
951 : *
952 : * This routine will ensure the values are within the range specified by
953 : * table->extra1 (min) and table->extra2 (max).
954 : *
955 : * Returns 0 on success or -EINVAL on write when the range check fails.
956 : */
957 26 : int proc_dointvec_minmax(struct ctl_table *table, int write,
958 : void *buffer, size_t *lenp, loff_t *ppos)
959 : {
960 26 : struct do_proc_dointvec_minmax_conv_param param = {
961 26 : .min = (int *) table->extra1,
962 26 : .max = (int *) table->extra2,
963 : };
964 26 : return do_proc_dointvec(table, write, buffer, lenp, ppos,
965 : do_proc_dointvec_minmax_conv, ¶m);
966 : }
967 :
968 : /**
969 : * struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure
970 : * @min: pointer to minimum allowable value
971 : * @max: pointer to maximum allowable value
972 : *
973 : * The do_proc_douintvec_minmax_conv_param structure provides the
974 : * minimum and maximum values for doing range checking for those sysctl
975 : * parameters that use the proc_douintvec_minmax() handler.
976 : */
977 : struct do_proc_douintvec_minmax_conv_param {
978 : unsigned int *min;
979 : unsigned int *max;
980 : };
981 :
982 0 : static int do_proc_douintvec_minmax_conv(unsigned long *lvalp,
983 : unsigned int *valp,
984 : int write, void *data)
985 : {
986 0 : int ret;
987 0 : unsigned int tmp;
988 0 : struct do_proc_douintvec_minmax_conv_param *param = data;
989 : /* write via temporary local uint for bounds-checking */
990 0 : unsigned int *up = write ? &tmp : valp;
991 :
992 0 : ret = do_proc_douintvec_conv(lvalp, up, write, data);
993 0 : if (ret)
994 : return ret;
995 :
996 0 : if (write) {
997 0 : if ((param->min && *param->min > tmp) ||
998 0 : (param->max && *param->max < tmp))
999 : return -ERANGE;
1000 :
1001 0 : *valp = tmp;
1002 : }
1003 :
1004 : return 0;
1005 : }
1006 :
1007 : /**
1008 : * proc_douintvec_minmax - read a vector of unsigned ints with min/max values
1009 : * @table: the sysctl table
1010 : * @write: %TRUE if this is a write to the sysctl file
1011 : * @buffer: the user buffer
1012 : * @lenp: the size of the user buffer
1013 : * @ppos: file position
1014 : *
1015 : * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
1016 : * values from/to the user buffer, treated as an ASCII string. Negative
1017 : * strings are not allowed.
1018 : *
1019 : * This routine will ensure the values are within the range specified by
1020 : * table->extra1 (min) and table->extra2 (max). There is a final sanity
1021 : * check for UINT_MAX to avoid having to support wrap around uses from
1022 : * userspace.
1023 : *
1024 : * Returns 0 on success or -ERANGE on write when the range check fails.
1025 : */
1026 0 : int proc_douintvec_minmax(struct ctl_table *table, int write,
1027 : void *buffer, size_t *lenp, loff_t *ppos)
1028 : {
1029 0 : struct do_proc_douintvec_minmax_conv_param param = {
1030 0 : .min = (unsigned int *) table->extra1,
1031 0 : .max = (unsigned int *) table->extra2,
1032 : };
1033 0 : return do_proc_douintvec(table, write, buffer, lenp, ppos,
1034 : do_proc_douintvec_minmax_conv, ¶m);
1035 : }
1036 :
1037 0 : static int do_proc_dopipe_max_size_conv(unsigned long *lvalp,
1038 : unsigned int *valp,
1039 : int write, void *data)
1040 : {
1041 0 : if (write) {
1042 0 : unsigned int val;
1043 :
1044 0 : val = round_pipe_size(*lvalp);
1045 0 : if (val == 0)
1046 : return -EINVAL;
1047 :
1048 0 : *valp = val;
1049 : } else {
1050 0 : unsigned int val = *valp;
1051 0 : *lvalp = (unsigned long) val;
1052 : }
1053 :
1054 : return 0;
1055 : }
1056 :
1057 0 : static int proc_dopipe_max_size(struct ctl_table *table, int write,
1058 : void *buffer, size_t *lenp, loff_t *ppos)
1059 : {
1060 0 : return do_proc_douintvec(table, write, buffer, lenp, ppos,
1061 : do_proc_dopipe_max_size_conv, NULL);
1062 : }
1063 :
1064 0 : static void validate_coredump_safety(void)
1065 : {
1066 : #ifdef CONFIG_COREDUMP
1067 0 : if (suid_dumpable == SUID_DUMP_ROOT &&
1068 0 : core_pattern[0] != '/' && core_pattern[0] != '|') {
1069 0 : printk(KERN_WARNING
1070 : "Unsafe core_pattern used with fs.suid_dumpable=2.\n"
1071 : "Pipe handler or fully qualified core dump path required.\n"
1072 : "Set kernel.core_pattern before fs.suid_dumpable.\n"
1073 : );
1074 : }
1075 : #endif
1076 0 : }
1077 :
1078 0 : static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
1079 : void *buffer, size_t *lenp, loff_t *ppos)
1080 : {
1081 0 : int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
1082 0 : if (!error)
1083 0 : validate_coredump_safety();
1084 0 : return error;
1085 : }
1086 :
1087 : #ifdef CONFIG_COREDUMP
1088 0 : static int proc_dostring_coredump(struct ctl_table *table, int write,
1089 : void *buffer, size_t *lenp, loff_t *ppos)
1090 : {
1091 0 : int error = proc_dostring(table, write, buffer, lenp, ppos);
1092 0 : if (!error)
1093 0 : validate_coredump_safety();
1094 0 : return error;
1095 : }
1096 : #endif
1097 :
1098 : #ifdef CONFIG_MAGIC_SYSRQ
1099 0 : static int sysrq_sysctl_handler(struct ctl_table *table, int write,
1100 : void *buffer, size_t *lenp, loff_t *ppos)
1101 : {
1102 0 : int tmp, ret;
1103 :
1104 0 : tmp = sysrq_mask();
1105 :
1106 0 : ret = __do_proc_dointvec(&tmp, table, write, buffer,
1107 : lenp, ppos, NULL, NULL);
1108 0 : if (ret || !write)
1109 : return ret;
1110 :
1111 0 : if (write)
1112 0 : sysrq_toggle_support(tmp);
1113 :
1114 0 : return 0;
1115 : }
1116 : #endif
1117 :
1118 1 : static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table,
1119 : int write, void *buffer, size_t *lenp, loff_t *ppos,
1120 : unsigned long convmul, unsigned long convdiv)
1121 : {
1122 1 : unsigned long *i, *min, *max;
1123 1 : int vleft, first = 1, err = 0;
1124 1 : size_t left;
1125 1 : char *p;
1126 :
1127 1 : if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
1128 0 : *lenp = 0;
1129 0 : return 0;
1130 : }
1131 :
1132 1 : i = (unsigned long *) data;
1133 1 : min = (unsigned long *) table->extra1;
1134 1 : max = (unsigned long *) table->extra2;
1135 1 : vleft = table->maxlen / sizeof(unsigned long);
1136 1 : left = *lenp;
1137 :
1138 1 : if (write) {
1139 1 : if (proc_first_pos_non_zero_ignore(ppos, table))
1140 0 : goto out;
1141 :
1142 1 : if (left > PAGE_SIZE - 1)
1143 0 : left = PAGE_SIZE - 1;
1144 1 : p = buffer;
1145 : }
1146 :
1147 1 : for (; left && vleft--; i++, first = 0) {
1148 1 : unsigned long val;
1149 :
1150 1 : if (write) {
1151 1 : bool neg;
1152 :
1153 1 : left -= proc_skip_spaces(&p);
1154 1 : if (!left)
1155 : break;
1156 :
1157 1 : err = proc_get_long(&p, &left, &val, &neg,
1158 : proc_wspace_sep,
1159 : sizeof(proc_wspace_sep), NULL);
1160 1 : if (err)
1161 : break;
1162 1 : if (neg)
1163 0 : continue;
1164 1 : val = convmul * val / convdiv;
1165 1 : if ((min && val < *min) || (max && val > *max)) {
1166 : err = -EINVAL;
1167 : break;
1168 : }
1169 0 : *i = val;
1170 : } else {
1171 0 : val = convdiv * (*i) / convmul;
1172 0 : if (!first)
1173 0 : proc_put_char(&buffer, &left, '\t');
1174 0 : proc_put_long(&buffer, &left, val, false);
1175 : }
1176 : }
1177 :
1178 1 : if (!write && !first && left && !err)
1179 0 : proc_put_char(&buffer, &left, '\n');
1180 1 : if (write && !err)
1181 0 : left -= proc_skip_spaces(&p);
1182 1 : if (write && first)
1183 1 : return err ? : -EINVAL;
1184 0 : *lenp -= left;
1185 0 : out:
1186 0 : *ppos += *lenp;
1187 0 : return err;
1188 : }
1189 :
1190 1 : static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
1191 : void *buffer, size_t *lenp, loff_t *ppos, unsigned long convmul,
1192 : unsigned long convdiv)
1193 : {
1194 1 : return __do_proc_doulongvec_minmax(table->data, table, write,
1195 : buffer, lenp, ppos, convmul, convdiv);
1196 : }
1197 :
1198 : /**
1199 : * proc_doulongvec_minmax - read a vector of long integers with min/max values
1200 : * @table: the sysctl table
1201 : * @write: %TRUE if this is a write to the sysctl file
1202 : * @buffer: the user buffer
1203 : * @lenp: the size of the user buffer
1204 : * @ppos: file position
1205 : *
1206 : * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1207 : * values from/to the user buffer, treated as an ASCII string.
1208 : *
1209 : * This routine will ensure the values are within the range specified by
1210 : * table->extra1 (min) and table->extra2 (max).
1211 : *
1212 : * Returns 0 on success.
1213 : */
1214 1 : int proc_doulongvec_minmax(struct ctl_table *table, int write,
1215 : void *buffer, size_t *lenp, loff_t *ppos)
1216 : {
1217 1 : return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
1218 : }
1219 :
1220 : /**
1221 : * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
1222 : * @table: the sysctl table
1223 : * @write: %TRUE if this is a write to the sysctl file
1224 : * @buffer: the user buffer
1225 : * @lenp: the size of the user buffer
1226 : * @ppos: file position
1227 : *
1228 : * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1229 : * values from/to the user buffer, treated as an ASCII string. The values
1230 : * are treated as milliseconds, and converted to jiffies when they are stored.
1231 : *
1232 : * This routine will ensure the values are within the range specified by
1233 : * table->extra1 (min) and table->extra2 (max).
1234 : *
1235 : * Returns 0 on success.
1236 : */
1237 0 : int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1238 : void *buffer, size_t *lenp, loff_t *ppos)
1239 : {
1240 0 : return do_proc_doulongvec_minmax(table, write, buffer,
1241 : lenp, ppos, HZ, 1000l);
1242 : }
1243 :
1244 :
1245 0 : static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
1246 : int *valp,
1247 : int write, void *data)
1248 : {
1249 0 : if (write) {
1250 0 : if (*lvalp > INT_MAX / HZ)
1251 : return 1;
1252 0 : *valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
1253 : } else {
1254 0 : int val = *valp;
1255 0 : unsigned long lval;
1256 0 : if (val < 0) {
1257 0 : *negp = true;
1258 0 : lval = -(unsigned long)val;
1259 : } else {
1260 0 : *negp = false;
1261 0 : lval = (unsigned long)val;
1262 : }
1263 0 : *lvalp = lval / HZ;
1264 : }
1265 : return 0;
1266 : }
1267 :
1268 0 : static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
1269 : int *valp,
1270 : int write, void *data)
1271 : {
1272 0 : if (write) {
1273 0 : if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
1274 : return 1;
1275 0 : *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
1276 : } else {
1277 0 : int val = *valp;
1278 0 : unsigned long lval;
1279 0 : if (val < 0) {
1280 0 : *negp = true;
1281 0 : lval = -(unsigned long)val;
1282 : } else {
1283 0 : *negp = false;
1284 0 : lval = (unsigned long)val;
1285 : }
1286 0 : *lvalp = jiffies_to_clock_t(lval);
1287 : }
1288 : return 0;
1289 : }
1290 :
1291 0 : static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
1292 : int *valp,
1293 : int write, void *data)
1294 : {
1295 0 : if (write) {
1296 0 : unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
1297 :
1298 0 : if (jif > INT_MAX)
1299 0 : return 1;
1300 0 : *valp = (int)jif;
1301 : } else {
1302 0 : int val = *valp;
1303 0 : unsigned long lval;
1304 0 : if (val < 0) {
1305 0 : *negp = true;
1306 0 : lval = -(unsigned long)val;
1307 : } else {
1308 0 : *negp = false;
1309 0 : lval = (unsigned long)val;
1310 : }
1311 0 : *lvalp = jiffies_to_msecs(lval);
1312 : }
1313 : return 0;
1314 : }
1315 :
1316 : /**
1317 : * proc_dointvec_jiffies - read a vector of integers as seconds
1318 : * @table: the sysctl table
1319 : * @write: %TRUE if this is a write to the sysctl file
1320 : * @buffer: the user buffer
1321 : * @lenp: the size of the user buffer
1322 : * @ppos: file position
1323 : *
1324 : * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1325 : * values from/to the user buffer, treated as an ASCII string.
1326 : * The values read are assumed to be in seconds, and are converted into
1327 : * jiffies.
1328 : *
1329 : * Returns 0 on success.
1330 : */
1331 0 : int proc_dointvec_jiffies(struct ctl_table *table, int write,
1332 : void *buffer, size_t *lenp, loff_t *ppos)
1333 : {
1334 0 : return do_proc_dointvec(table,write,buffer,lenp,ppos,
1335 : do_proc_dointvec_jiffies_conv,NULL);
1336 : }
1337 :
1338 : /**
1339 : * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
1340 : * @table: the sysctl table
1341 : * @write: %TRUE if this is a write to the sysctl file
1342 : * @buffer: the user buffer
1343 : * @lenp: the size of the user buffer
1344 : * @ppos: pointer to the file position
1345 : *
1346 : * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1347 : * values from/to the user buffer, treated as an ASCII string.
1348 : * The values read are assumed to be in 1/USER_HZ seconds, and
1349 : * are converted into jiffies.
1350 : *
1351 : * Returns 0 on success.
1352 : */
1353 0 : int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1354 : void *buffer, size_t *lenp, loff_t *ppos)
1355 : {
1356 0 : return do_proc_dointvec(table,write,buffer,lenp,ppos,
1357 : do_proc_dointvec_userhz_jiffies_conv,NULL);
1358 : }
1359 :
1360 : /**
1361 : * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
1362 : * @table: the sysctl table
1363 : * @write: %TRUE if this is a write to the sysctl file
1364 : * @buffer: the user buffer
1365 : * @lenp: the size of the user buffer
1366 : * @ppos: file position
1367 : * @ppos: the current position in the file
1368 : *
1369 : * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1370 : * values from/to the user buffer, treated as an ASCII string.
1371 : * The values read are assumed to be in 1/1000 seconds, and
1372 : * are converted into jiffies.
1373 : *
1374 : * Returns 0 on success.
1375 : */
1376 0 : int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer,
1377 : size_t *lenp, loff_t *ppos)
1378 : {
1379 0 : return do_proc_dointvec(table, write, buffer, lenp, ppos,
1380 : do_proc_dointvec_ms_jiffies_conv, NULL);
1381 : }
1382 :
1383 0 : static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer,
1384 : size_t *lenp, loff_t *ppos)
1385 : {
1386 0 : struct pid *new_pid;
1387 0 : pid_t tmp;
1388 0 : int r;
1389 :
1390 0 : tmp = pid_vnr(cad_pid);
1391 :
1392 0 : r = __do_proc_dointvec(&tmp, table, write, buffer,
1393 : lenp, ppos, NULL, NULL);
1394 0 : if (r || !write)
1395 : return r;
1396 :
1397 0 : new_pid = find_get_pid(tmp);
1398 0 : if (!new_pid)
1399 : return -ESRCH;
1400 :
1401 0 : put_pid(xchg(&cad_pid, new_pid));
1402 0 : return 0;
1403 : }
1404 :
1405 : /**
1406 : * proc_do_large_bitmap - read/write from/to a large bitmap
1407 : * @table: the sysctl table
1408 : * @write: %TRUE if this is a write to the sysctl file
1409 : * @buffer: the user buffer
1410 : * @lenp: the size of the user buffer
1411 : * @ppos: file position
1412 : *
1413 : * The bitmap is stored at table->data and the bitmap length (in bits)
1414 : * in table->maxlen.
1415 : *
1416 : * We use a range comma separated format (e.g. 1,3-4,10-10) so that
1417 : * large bitmaps may be represented in a compact manner. Writing into
1418 : * the file will clear the bitmap then update it with the given input.
1419 : *
1420 : * Returns 0 on success.
1421 : */
1422 0 : int proc_do_large_bitmap(struct ctl_table *table, int write,
1423 : void *buffer, size_t *lenp, loff_t *ppos)
1424 : {
1425 0 : int err = 0;
1426 0 : bool first = 1;
1427 0 : size_t left = *lenp;
1428 0 : unsigned long bitmap_len = table->maxlen;
1429 0 : unsigned long *bitmap = *(unsigned long **) table->data;
1430 0 : unsigned long *tmp_bitmap = NULL;
1431 0 : char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
1432 :
1433 0 : if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
1434 0 : *lenp = 0;
1435 0 : return 0;
1436 : }
1437 :
1438 0 : if (write) {
1439 0 : char *p = buffer;
1440 0 : size_t skipped = 0;
1441 :
1442 0 : if (left > PAGE_SIZE - 1) {
1443 0 : left = PAGE_SIZE - 1;
1444 : /* How much of the buffer we'll skip this pass */
1445 0 : skipped = *lenp - left;
1446 : }
1447 :
1448 0 : tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL);
1449 0 : if (!tmp_bitmap)
1450 0 : return -ENOMEM;
1451 0 : proc_skip_char(&p, &left, '\n');
1452 0 : while (!err && left) {
1453 0 : unsigned long val_a, val_b;
1454 0 : bool neg;
1455 0 : size_t saved_left;
1456 :
1457 : /* In case we stop parsing mid-number, we can reset */
1458 0 : saved_left = left;
1459 0 : err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
1460 : sizeof(tr_a), &c);
1461 : /*
1462 : * If we consumed the entirety of a truncated buffer or
1463 : * only one char is left (may be a "-"), then stop here,
1464 : * reset, & come back for more.
1465 : */
1466 0 : if ((left <= 1) && skipped) {
1467 0 : left = saved_left;
1468 0 : break;
1469 : }
1470 :
1471 0 : if (err)
1472 : break;
1473 0 : if (val_a >= bitmap_len || neg) {
1474 : err = -EINVAL;
1475 : break;
1476 : }
1477 :
1478 0 : val_b = val_a;
1479 0 : if (left) {
1480 0 : p++;
1481 0 : left--;
1482 : }
1483 :
1484 0 : if (c == '-') {
1485 0 : err = proc_get_long(&p, &left, &val_b,
1486 : &neg, tr_b, sizeof(tr_b),
1487 : &c);
1488 : /*
1489 : * If we consumed all of a truncated buffer or
1490 : * then stop here, reset, & come back for more.
1491 : */
1492 0 : if (!left && skipped) {
1493 0 : left = saved_left;
1494 0 : break;
1495 : }
1496 :
1497 0 : if (err)
1498 : break;
1499 0 : if (val_b >= bitmap_len || neg ||
1500 0 : val_a > val_b) {
1501 : err = -EINVAL;
1502 : break;
1503 : }
1504 0 : if (left) {
1505 0 : p++;
1506 0 : left--;
1507 : }
1508 : }
1509 :
1510 0 : bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
1511 0 : first = 0;
1512 0 : proc_skip_char(&p, &left, '\n');
1513 : }
1514 0 : left += skipped;
1515 : } else {
1516 : unsigned long bit_a, bit_b = 0;
1517 :
1518 0 : while (left) {
1519 0 : bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
1520 0 : if (bit_a >= bitmap_len)
1521 : break;
1522 0 : bit_b = find_next_zero_bit(bitmap, bitmap_len,
1523 : bit_a + 1) - 1;
1524 :
1525 0 : if (!first)
1526 0 : proc_put_char(&buffer, &left, ',');
1527 0 : proc_put_long(&buffer, &left, bit_a, false);
1528 0 : if (bit_a != bit_b) {
1529 0 : proc_put_char(&buffer, &left, '-');
1530 0 : proc_put_long(&buffer, &left, bit_b, false);
1531 : }
1532 :
1533 : first = 0; bit_b++;
1534 : }
1535 0 : proc_put_char(&buffer, &left, '\n');
1536 : }
1537 :
1538 0 : if (!err) {
1539 0 : if (write) {
1540 0 : if (*ppos)
1541 0 : bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
1542 : else
1543 0 : bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
1544 : }
1545 0 : *lenp -= left;
1546 0 : *ppos += *lenp;
1547 : }
1548 :
1549 0 : bitmap_free(tmp_bitmap);
1550 0 : return err;
1551 : }
1552 :
1553 : #else /* CONFIG_PROC_SYSCTL */
1554 :
1555 : int proc_dostring(struct ctl_table *table, int write,
1556 : void *buffer, size_t *lenp, loff_t *ppos)
1557 : {
1558 : return -ENOSYS;
1559 : }
1560 :
1561 : int proc_dointvec(struct ctl_table *table, int write,
1562 : void *buffer, size_t *lenp, loff_t *ppos)
1563 : {
1564 : return -ENOSYS;
1565 : }
1566 :
1567 : int proc_douintvec(struct ctl_table *table, int write,
1568 : void *buffer, size_t *lenp, loff_t *ppos)
1569 : {
1570 : return -ENOSYS;
1571 : }
1572 :
1573 : int proc_dointvec_minmax(struct ctl_table *table, int write,
1574 : void *buffer, size_t *lenp, loff_t *ppos)
1575 : {
1576 : return -ENOSYS;
1577 : }
1578 :
1579 : int proc_douintvec_minmax(struct ctl_table *table, int write,
1580 : void *buffer, size_t *lenp, loff_t *ppos)
1581 : {
1582 : return -ENOSYS;
1583 : }
1584 :
1585 : int proc_dointvec_jiffies(struct ctl_table *table, int write,
1586 : void *buffer, size_t *lenp, loff_t *ppos)
1587 : {
1588 : return -ENOSYS;
1589 : }
1590 :
1591 : int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1592 : void *buffer, size_t *lenp, loff_t *ppos)
1593 : {
1594 : return -ENOSYS;
1595 : }
1596 :
1597 : int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
1598 : void *buffer, size_t *lenp, loff_t *ppos)
1599 : {
1600 : return -ENOSYS;
1601 : }
1602 :
1603 : int proc_doulongvec_minmax(struct ctl_table *table, int write,
1604 : void *buffer, size_t *lenp, loff_t *ppos)
1605 : {
1606 : return -ENOSYS;
1607 : }
1608 :
1609 : int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1610 : void *buffer, size_t *lenp, loff_t *ppos)
1611 : {
1612 : return -ENOSYS;
1613 : }
1614 :
1615 : int proc_do_large_bitmap(struct ctl_table *table, int write,
1616 : void *buffer, size_t *lenp, loff_t *ppos)
1617 : {
1618 : return -ENOSYS;
1619 : }
1620 :
1621 : #endif /* CONFIG_PROC_SYSCTL */
1622 :
1623 : #if defined(CONFIG_SYSCTL)
1624 0 : int proc_do_static_key(struct ctl_table *table, int write,
1625 : void *buffer, size_t *lenp, loff_t *ppos)
1626 : {
1627 0 : struct static_key *key = (struct static_key *)table->data;
1628 0 : static DEFINE_MUTEX(static_key_mutex);
1629 0 : int val, ret;
1630 0 : struct ctl_table tmp = {
1631 : .data = &val,
1632 : .maxlen = sizeof(val),
1633 0 : .mode = table->mode,
1634 : .extra1 = SYSCTL_ZERO,
1635 : .extra2 = SYSCTL_ONE,
1636 : };
1637 :
1638 0 : if (write && !capable(CAP_SYS_ADMIN))
1639 : return -EPERM;
1640 :
1641 0 : mutex_lock(&static_key_mutex);
1642 0 : val = static_key_enabled(key);
1643 0 : ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
1644 0 : if (write && !ret) {
1645 0 : if (val)
1646 0 : static_key_enable(key);
1647 : else
1648 0 : static_key_disable(key);
1649 : }
1650 0 : mutex_unlock(&static_key_mutex);
1651 0 : return ret;
1652 : }
1653 :
1654 : static struct ctl_table kern_table[] = {
1655 : {
1656 : .procname = "sched_child_runs_first",
1657 : .data = &sysctl_sched_child_runs_first,
1658 : .maxlen = sizeof(unsigned int),
1659 : .mode = 0644,
1660 : .proc_handler = proc_dointvec,
1661 : },
1662 : #ifdef CONFIG_SCHED_DEBUG
1663 : {
1664 : .procname = "sched_min_granularity_ns",
1665 : .data = &sysctl_sched_min_granularity,
1666 : .maxlen = sizeof(unsigned int),
1667 : .mode = 0644,
1668 : .proc_handler = sched_proc_update_handler,
1669 : .extra1 = &min_sched_granularity_ns,
1670 : .extra2 = &max_sched_granularity_ns,
1671 : },
1672 : {
1673 : .procname = "sched_latency_ns",
1674 : .data = &sysctl_sched_latency,
1675 : .maxlen = sizeof(unsigned int),
1676 : .mode = 0644,
1677 : .proc_handler = sched_proc_update_handler,
1678 : .extra1 = &min_sched_granularity_ns,
1679 : .extra2 = &max_sched_granularity_ns,
1680 : },
1681 : {
1682 : .procname = "sched_wakeup_granularity_ns",
1683 : .data = &sysctl_sched_wakeup_granularity,
1684 : .maxlen = sizeof(unsigned int),
1685 : .mode = 0644,
1686 : .proc_handler = sched_proc_update_handler,
1687 : .extra1 = &min_wakeup_granularity_ns,
1688 : .extra2 = &max_wakeup_granularity_ns,
1689 : },
1690 : #ifdef CONFIG_SMP
1691 : {
1692 : .procname = "sched_tunable_scaling",
1693 : .data = &sysctl_sched_tunable_scaling,
1694 : .maxlen = sizeof(enum sched_tunable_scaling),
1695 : .mode = 0644,
1696 : .proc_handler = sched_proc_update_handler,
1697 : .extra1 = &min_sched_tunable_scaling,
1698 : .extra2 = &max_sched_tunable_scaling,
1699 : },
1700 : {
1701 : .procname = "sched_migration_cost_ns",
1702 : .data = &sysctl_sched_migration_cost,
1703 : .maxlen = sizeof(unsigned int),
1704 : .mode = 0644,
1705 : .proc_handler = proc_dointvec,
1706 : },
1707 : {
1708 : .procname = "sched_nr_migrate",
1709 : .data = &sysctl_sched_nr_migrate,
1710 : .maxlen = sizeof(unsigned int),
1711 : .mode = 0644,
1712 : .proc_handler = proc_dointvec,
1713 : },
1714 : #ifdef CONFIG_SCHEDSTATS
1715 : {
1716 : .procname = "sched_schedstats",
1717 : .data = NULL,
1718 : .maxlen = sizeof(unsigned int),
1719 : .mode = 0644,
1720 : .proc_handler = sysctl_schedstats,
1721 : .extra1 = SYSCTL_ZERO,
1722 : .extra2 = SYSCTL_ONE,
1723 : },
1724 : #endif /* CONFIG_SCHEDSTATS */
1725 : #endif /* CONFIG_SMP */
1726 : #ifdef CONFIG_NUMA_BALANCING
1727 : {
1728 : .procname = "numa_balancing_scan_delay_ms",
1729 : .data = &sysctl_numa_balancing_scan_delay,
1730 : .maxlen = sizeof(unsigned int),
1731 : .mode = 0644,
1732 : .proc_handler = proc_dointvec,
1733 : },
1734 : {
1735 : .procname = "numa_balancing_scan_period_min_ms",
1736 : .data = &sysctl_numa_balancing_scan_period_min,
1737 : .maxlen = sizeof(unsigned int),
1738 : .mode = 0644,
1739 : .proc_handler = proc_dointvec,
1740 : },
1741 : {
1742 : .procname = "numa_balancing_scan_period_max_ms",
1743 : .data = &sysctl_numa_balancing_scan_period_max,
1744 : .maxlen = sizeof(unsigned int),
1745 : .mode = 0644,
1746 : .proc_handler = proc_dointvec,
1747 : },
1748 : {
1749 : .procname = "numa_balancing_scan_size_mb",
1750 : .data = &sysctl_numa_balancing_scan_size,
1751 : .maxlen = sizeof(unsigned int),
1752 : .mode = 0644,
1753 : .proc_handler = proc_dointvec_minmax,
1754 : .extra1 = SYSCTL_ONE,
1755 : },
1756 : {
1757 : .procname = "numa_balancing",
1758 : .data = NULL, /* filled in by handler */
1759 : .maxlen = sizeof(unsigned int),
1760 : .mode = 0644,
1761 : .proc_handler = sysctl_numa_balancing,
1762 : .extra1 = SYSCTL_ZERO,
1763 : .extra2 = SYSCTL_ONE,
1764 : },
1765 : #endif /* CONFIG_NUMA_BALANCING */
1766 : #endif /* CONFIG_SCHED_DEBUG */
1767 : {
1768 : .procname = "sched_rt_period_us",
1769 : .data = &sysctl_sched_rt_period,
1770 : .maxlen = sizeof(unsigned int),
1771 : .mode = 0644,
1772 : .proc_handler = sched_rt_handler,
1773 : },
1774 : {
1775 : .procname = "sched_rt_runtime_us",
1776 : .data = &sysctl_sched_rt_runtime,
1777 : .maxlen = sizeof(int),
1778 : .mode = 0644,
1779 : .proc_handler = sched_rt_handler,
1780 : },
1781 : {
1782 : .procname = "sched_deadline_period_max_us",
1783 : .data = &sysctl_sched_dl_period_max,
1784 : .maxlen = sizeof(unsigned int),
1785 : .mode = 0644,
1786 : .proc_handler = proc_dointvec,
1787 : },
1788 : {
1789 : .procname = "sched_deadline_period_min_us",
1790 : .data = &sysctl_sched_dl_period_min,
1791 : .maxlen = sizeof(unsigned int),
1792 : .mode = 0644,
1793 : .proc_handler = proc_dointvec,
1794 : },
1795 : {
1796 : .procname = "sched_rr_timeslice_ms",
1797 : .data = &sysctl_sched_rr_timeslice,
1798 : .maxlen = sizeof(int),
1799 : .mode = 0644,
1800 : .proc_handler = sched_rr_handler,
1801 : },
1802 : #ifdef CONFIG_UCLAMP_TASK
1803 : {
1804 : .procname = "sched_util_clamp_min",
1805 : .data = &sysctl_sched_uclamp_util_min,
1806 : .maxlen = sizeof(unsigned int),
1807 : .mode = 0644,
1808 : .proc_handler = sysctl_sched_uclamp_handler,
1809 : },
1810 : {
1811 : .procname = "sched_util_clamp_max",
1812 : .data = &sysctl_sched_uclamp_util_max,
1813 : .maxlen = sizeof(unsigned int),
1814 : .mode = 0644,
1815 : .proc_handler = sysctl_sched_uclamp_handler,
1816 : },
1817 : {
1818 : .procname = "sched_util_clamp_min_rt_default",
1819 : .data = &sysctl_sched_uclamp_util_min_rt_default,
1820 : .maxlen = sizeof(unsigned int),
1821 : .mode = 0644,
1822 : .proc_handler = sysctl_sched_uclamp_handler,
1823 : },
1824 : #endif
1825 : #ifdef CONFIG_SCHED_AUTOGROUP
1826 : {
1827 : .procname = "sched_autogroup_enabled",
1828 : .data = &sysctl_sched_autogroup_enabled,
1829 : .maxlen = sizeof(unsigned int),
1830 : .mode = 0644,
1831 : .proc_handler = proc_dointvec_minmax,
1832 : .extra1 = SYSCTL_ZERO,
1833 : .extra2 = SYSCTL_ONE,
1834 : },
1835 : #endif
1836 : #ifdef CONFIG_CFS_BANDWIDTH
1837 : {
1838 : .procname = "sched_cfs_bandwidth_slice_us",
1839 : .data = &sysctl_sched_cfs_bandwidth_slice,
1840 : .maxlen = sizeof(unsigned int),
1841 : .mode = 0644,
1842 : .proc_handler = proc_dointvec_minmax,
1843 : .extra1 = SYSCTL_ONE,
1844 : },
1845 : #endif
1846 : #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
1847 : {
1848 : .procname = "sched_energy_aware",
1849 : .data = &sysctl_sched_energy_aware,
1850 : .maxlen = sizeof(unsigned int),
1851 : .mode = 0644,
1852 : .proc_handler = sched_energy_aware_handler,
1853 : .extra1 = SYSCTL_ZERO,
1854 : .extra2 = SYSCTL_ONE,
1855 : },
1856 : #endif
1857 : #ifdef CONFIG_PROVE_LOCKING
1858 : {
1859 : .procname = "prove_locking",
1860 : .data = &prove_locking,
1861 : .maxlen = sizeof(int),
1862 : .mode = 0644,
1863 : .proc_handler = proc_dointvec,
1864 : },
1865 : #endif
1866 : #ifdef CONFIG_LOCK_STAT
1867 : {
1868 : .procname = "lock_stat",
1869 : .data = &lock_stat,
1870 : .maxlen = sizeof(int),
1871 : .mode = 0644,
1872 : .proc_handler = proc_dointvec,
1873 : },
1874 : #endif
1875 : {
1876 : .procname = "panic",
1877 : .data = &panic_timeout,
1878 : .maxlen = sizeof(int),
1879 : .mode = 0644,
1880 : .proc_handler = proc_dointvec,
1881 : },
1882 : #ifdef CONFIG_COREDUMP
1883 : {
1884 : .procname = "core_uses_pid",
1885 : .data = &core_uses_pid,
1886 : .maxlen = sizeof(int),
1887 : .mode = 0644,
1888 : .proc_handler = proc_dointvec,
1889 : },
1890 : {
1891 : .procname = "core_pattern",
1892 : .data = core_pattern,
1893 : .maxlen = CORENAME_MAX_SIZE,
1894 : .mode = 0644,
1895 : .proc_handler = proc_dostring_coredump,
1896 : },
1897 : {
1898 : .procname = "core_pipe_limit",
1899 : .data = &core_pipe_limit,
1900 : .maxlen = sizeof(unsigned int),
1901 : .mode = 0644,
1902 : .proc_handler = proc_dointvec,
1903 : },
1904 : #endif
1905 : #ifdef CONFIG_PROC_SYSCTL
1906 : {
1907 : .procname = "tainted",
1908 : .maxlen = sizeof(long),
1909 : .mode = 0644,
1910 : .proc_handler = proc_taint,
1911 : },
1912 : {
1913 : .procname = "sysctl_writes_strict",
1914 : .data = &sysctl_writes_strict,
1915 : .maxlen = sizeof(int),
1916 : .mode = 0644,
1917 : .proc_handler = proc_dointvec_minmax,
1918 : .extra1 = &neg_one,
1919 : .extra2 = SYSCTL_ONE,
1920 : },
1921 : #endif
1922 : #ifdef CONFIG_LATENCYTOP
1923 : {
1924 : .procname = "latencytop",
1925 : .data = &latencytop_enabled,
1926 : .maxlen = sizeof(int),
1927 : .mode = 0644,
1928 : .proc_handler = sysctl_latencytop,
1929 : },
1930 : #endif
1931 : #ifdef CONFIG_BLK_DEV_INITRD
1932 : {
1933 : .procname = "real-root-dev",
1934 : .data = &real_root_dev,
1935 : .maxlen = sizeof(int),
1936 : .mode = 0644,
1937 : .proc_handler = proc_dointvec,
1938 : },
1939 : #endif
1940 : {
1941 : .procname = "print-fatal-signals",
1942 : .data = &print_fatal_signals,
1943 : .maxlen = sizeof(int),
1944 : .mode = 0644,
1945 : .proc_handler = proc_dointvec,
1946 : },
1947 : #ifdef CONFIG_SPARC
1948 : {
1949 : .procname = "reboot-cmd",
1950 : .data = reboot_command,
1951 : .maxlen = 256,
1952 : .mode = 0644,
1953 : .proc_handler = proc_dostring,
1954 : },
1955 : {
1956 : .procname = "stop-a",
1957 : .data = &stop_a_enabled,
1958 : .maxlen = sizeof (int),
1959 : .mode = 0644,
1960 : .proc_handler = proc_dointvec,
1961 : },
1962 : {
1963 : .procname = "scons-poweroff",
1964 : .data = &scons_pwroff,
1965 : .maxlen = sizeof (int),
1966 : .mode = 0644,
1967 : .proc_handler = proc_dointvec,
1968 : },
1969 : #endif
1970 : #ifdef CONFIG_SPARC64
1971 : {
1972 : .procname = "tsb-ratio",
1973 : .data = &sysctl_tsb_ratio,
1974 : .maxlen = sizeof (int),
1975 : .mode = 0644,
1976 : .proc_handler = proc_dointvec,
1977 : },
1978 : #endif
1979 : #ifdef CONFIG_PARISC
1980 : {
1981 : .procname = "soft-power",
1982 : .data = &pwrsw_enabled,
1983 : .maxlen = sizeof (int),
1984 : .mode = 0644,
1985 : .proc_handler = proc_dointvec,
1986 : },
1987 : #endif
1988 : #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1989 : {
1990 : .procname = "unaligned-trap",
1991 : .data = &unaligned_enabled,
1992 : .maxlen = sizeof (int),
1993 : .mode = 0644,
1994 : .proc_handler = proc_dointvec,
1995 : },
1996 : #endif
1997 : {
1998 : .procname = "ctrl-alt-del",
1999 : .data = &C_A_D,
2000 : .maxlen = sizeof(int),
2001 : .mode = 0644,
2002 : .proc_handler = proc_dointvec,
2003 : },
2004 : #ifdef CONFIG_FUNCTION_TRACER
2005 : {
2006 : .procname = "ftrace_enabled",
2007 : .data = &ftrace_enabled,
2008 : .maxlen = sizeof(int),
2009 : .mode = 0644,
2010 : .proc_handler = ftrace_enable_sysctl,
2011 : },
2012 : #endif
2013 : #ifdef CONFIG_STACK_TRACER
2014 : {
2015 : .procname = "stack_tracer_enabled",
2016 : .data = &stack_tracer_enabled,
2017 : .maxlen = sizeof(int),
2018 : .mode = 0644,
2019 : .proc_handler = stack_trace_sysctl,
2020 : },
2021 : #endif
2022 : #ifdef CONFIG_TRACING
2023 : {
2024 : .procname = "ftrace_dump_on_oops",
2025 : .data = &ftrace_dump_on_oops,
2026 : .maxlen = sizeof(int),
2027 : .mode = 0644,
2028 : .proc_handler = proc_dointvec,
2029 : },
2030 : {
2031 : .procname = "traceoff_on_warning",
2032 : .data = &__disable_trace_on_warning,
2033 : .maxlen = sizeof(__disable_trace_on_warning),
2034 : .mode = 0644,
2035 : .proc_handler = proc_dointvec,
2036 : },
2037 : {
2038 : .procname = "tracepoint_printk",
2039 : .data = &tracepoint_printk,
2040 : .maxlen = sizeof(tracepoint_printk),
2041 : .mode = 0644,
2042 : .proc_handler = tracepoint_printk_sysctl,
2043 : },
2044 : #endif
2045 : #ifdef CONFIG_KEXEC_CORE
2046 : {
2047 : .procname = "kexec_load_disabled",
2048 : .data = &kexec_load_disabled,
2049 : .maxlen = sizeof(int),
2050 : .mode = 0644,
2051 : /* only handle a transition from default "0" to "1" */
2052 : .proc_handler = proc_dointvec_minmax,
2053 : .extra1 = SYSCTL_ONE,
2054 : .extra2 = SYSCTL_ONE,
2055 : },
2056 : #endif
2057 : #ifdef CONFIG_MODULES
2058 : {
2059 : .procname = "modprobe",
2060 : .data = &modprobe_path,
2061 : .maxlen = KMOD_PATH_LEN,
2062 : .mode = 0644,
2063 : .proc_handler = proc_dostring,
2064 : },
2065 : {
2066 : .procname = "modules_disabled",
2067 : .data = &modules_disabled,
2068 : .maxlen = sizeof(int),
2069 : .mode = 0644,
2070 : /* only handle a transition from default "0" to "1" */
2071 : .proc_handler = proc_dointvec_minmax,
2072 : .extra1 = SYSCTL_ONE,
2073 : .extra2 = SYSCTL_ONE,
2074 : },
2075 : #endif
2076 : #ifdef CONFIG_UEVENT_HELPER
2077 : {
2078 : .procname = "hotplug",
2079 : .data = &uevent_helper,
2080 : .maxlen = UEVENT_HELPER_PATH_LEN,
2081 : .mode = 0644,
2082 : .proc_handler = proc_dostring,
2083 : },
2084 : #endif
2085 : #ifdef CONFIG_CHR_DEV_SG
2086 : {
2087 : .procname = "sg-big-buff",
2088 : .data = &sg_big_buff,
2089 : .maxlen = sizeof (int),
2090 : .mode = 0444,
2091 : .proc_handler = proc_dointvec,
2092 : },
2093 : #endif
2094 : #ifdef CONFIG_BSD_PROCESS_ACCT
2095 : {
2096 : .procname = "acct",
2097 : .data = &acct_parm,
2098 : .maxlen = 3*sizeof(int),
2099 : .mode = 0644,
2100 : .proc_handler = proc_dointvec,
2101 : },
2102 : #endif
2103 : #ifdef CONFIG_MAGIC_SYSRQ
2104 : {
2105 : .procname = "sysrq",
2106 : .data = NULL,
2107 : .maxlen = sizeof (int),
2108 : .mode = 0644,
2109 : .proc_handler = sysrq_sysctl_handler,
2110 : },
2111 : #endif
2112 : #ifdef CONFIG_PROC_SYSCTL
2113 : {
2114 : .procname = "cad_pid",
2115 : .data = NULL,
2116 : .maxlen = sizeof (int),
2117 : .mode = 0600,
2118 : .proc_handler = proc_do_cad_pid,
2119 : },
2120 : #endif
2121 : {
2122 : .procname = "threads-max",
2123 : .data = NULL,
2124 : .maxlen = sizeof(int),
2125 : .mode = 0644,
2126 : .proc_handler = sysctl_max_threads,
2127 : },
2128 : {
2129 : .procname = "random",
2130 : .mode = 0555,
2131 : .child = random_table,
2132 : },
2133 : {
2134 : .procname = "usermodehelper",
2135 : .mode = 0555,
2136 : .child = usermodehelper_table,
2137 : },
2138 : #ifdef CONFIG_FW_LOADER_USER_HELPER
2139 : {
2140 : .procname = "firmware_config",
2141 : .mode = 0555,
2142 : .child = firmware_config_table,
2143 : },
2144 : #endif
2145 : {
2146 : .procname = "overflowuid",
2147 : .data = &overflowuid,
2148 : .maxlen = sizeof(int),
2149 : .mode = 0644,
2150 : .proc_handler = proc_dointvec_minmax,
2151 : .extra1 = &minolduid,
2152 : .extra2 = &maxolduid,
2153 : },
2154 : {
2155 : .procname = "overflowgid",
2156 : .data = &overflowgid,
2157 : .maxlen = sizeof(int),
2158 : .mode = 0644,
2159 : .proc_handler = proc_dointvec_minmax,
2160 : .extra1 = &minolduid,
2161 : .extra2 = &maxolduid,
2162 : },
2163 : #ifdef CONFIG_S390
2164 : {
2165 : .procname = "userprocess_debug",
2166 : .data = &show_unhandled_signals,
2167 : .maxlen = sizeof(int),
2168 : .mode = 0644,
2169 : .proc_handler = proc_dointvec,
2170 : },
2171 : #endif
2172 : #ifdef CONFIG_SMP
2173 : {
2174 : .procname = "oops_all_cpu_backtrace",
2175 : .data = &sysctl_oops_all_cpu_backtrace,
2176 : .maxlen = sizeof(int),
2177 : .mode = 0644,
2178 : .proc_handler = proc_dointvec_minmax,
2179 : .extra1 = SYSCTL_ZERO,
2180 : .extra2 = SYSCTL_ONE,
2181 : },
2182 : #endif /* CONFIG_SMP */
2183 : {
2184 : .procname = "pid_max",
2185 : .data = &pid_max,
2186 : .maxlen = sizeof (int),
2187 : .mode = 0644,
2188 : .proc_handler = proc_dointvec_minmax,
2189 : .extra1 = &pid_max_min,
2190 : .extra2 = &pid_max_max,
2191 : },
2192 : {
2193 : .procname = "panic_on_oops",
2194 : .data = &panic_on_oops,
2195 : .maxlen = sizeof(int),
2196 : .mode = 0644,
2197 : .proc_handler = proc_dointvec,
2198 : },
2199 : {
2200 : .procname = "panic_print",
2201 : .data = &panic_print,
2202 : .maxlen = sizeof(unsigned long),
2203 : .mode = 0644,
2204 : .proc_handler = proc_doulongvec_minmax,
2205 : },
2206 : #if defined CONFIG_PRINTK
2207 : {
2208 : .procname = "printk",
2209 : .data = &console_loglevel,
2210 : .maxlen = 4*sizeof(int),
2211 : .mode = 0644,
2212 : .proc_handler = proc_dointvec,
2213 : },
2214 : {
2215 : .procname = "printk_ratelimit",
2216 : .data = &printk_ratelimit_state.interval,
2217 : .maxlen = sizeof(int),
2218 : .mode = 0644,
2219 : .proc_handler = proc_dointvec_jiffies,
2220 : },
2221 : {
2222 : .procname = "printk_ratelimit_burst",
2223 : .data = &printk_ratelimit_state.burst,
2224 : .maxlen = sizeof(int),
2225 : .mode = 0644,
2226 : .proc_handler = proc_dointvec,
2227 : },
2228 : {
2229 : .procname = "printk_delay",
2230 : .data = &printk_delay_msec,
2231 : .maxlen = sizeof(int),
2232 : .mode = 0644,
2233 : .proc_handler = proc_dointvec_minmax,
2234 : .extra1 = SYSCTL_ZERO,
2235 : .extra2 = &ten_thousand,
2236 : },
2237 : {
2238 : .procname = "printk_devkmsg",
2239 : .data = devkmsg_log_str,
2240 : .maxlen = DEVKMSG_STR_MAX_SIZE,
2241 : .mode = 0644,
2242 : .proc_handler = devkmsg_sysctl_set_loglvl,
2243 : },
2244 : {
2245 : .procname = "dmesg_restrict",
2246 : .data = &dmesg_restrict,
2247 : .maxlen = sizeof(int),
2248 : .mode = 0644,
2249 : .proc_handler = proc_dointvec_minmax_sysadmin,
2250 : .extra1 = SYSCTL_ZERO,
2251 : .extra2 = SYSCTL_ONE,
2252 : },
2253 : {
2254 : .procname = "kptr_restrict",
2255 : .data = &kptr_restrict,
2256 : .maxlen = sizeof(int),
2257 : .mode = 0644,
2258 : .proc_handler = proc_dointvec_minmax_sysadmin,
2259 : .extra1 = SYSCTL_ZERO,
2260 : .extra2 = &two,
2261 : },
2262 : #endif
2263 : {
2264 : .procname = "ngroups_max",
2265 : .data = &ngroups_max,
2266 : .maxlen = sizeof (int),
2267 : .mode = 0444,
2268 : .proc_handler = proc_dointvec,
2269 : },
2270 : {
2271 : .procname = "cap_last_cap",
2272 : .data = (void *)&cap_last_cap,
2273 : .maxlen = sizeof(int),
2274 : .mode = 0444,
2275 : .proc_handler = proc_dointvec,
2276 : },
2277 : #if defined(CONFIG_LOCKUP_DETECTOR)
2278 : {
2279 : .procname = "watchdog",
2280 : .data = &watchdog_user_enabled,
2281 : .maxlen = sizeof(int),
2282 : .mode = 0644,
2283 : .proc_handler = proc_watchdog,
2284 : .extra1 = SYSCTL_ZERO,
2285 : .extra2 = SYSCTL_ONE,
2286 : },
2287 : {
2288 : .procname = "watchdog_thresh",
2289 : .data = &watchdog_thresh,
2290 : .maxlen = sizeof(int),
2291 : .mode = 0644,
2292 : .proc_handler = proc_watchdog_thresh,
2293 : .extra1 = SYSCTL_ZERO,
2294 : .extra2 = &sixty,
2295 : },
2296 : {
2297 : .procname = "nmi_watchdog",
2298 : .data = &nmi_watchdog_user_enabled,
2299 : .maxlen = sizeof(int),
2300 : .mode = NMI_WATCHDOG_SYSCTL_PERM,
2301 : .proc_handler = proc_nmi_watchdog,
2302 : .extra1 = SYSCTL_ZERO,
2303 : .extra2 = SYSCTL_ONE,
2304 : },
2305 : {
2306 : .procname = "watchdog_cpumask",
2307 : .data = &watchdog_cpumask_bits,
2308 : .maxlen = NR_CPUS,
2309 : .mode = 0644,
2310 : .proc_handler = proc_watchdog_cpumask,
2311 : },
2312 : #ifdef CONFIG_SOFTLOCKUP_DETECTOR
2313 : {
2314 : .procname = "soft_watchdog",
2315 : .data = &soft_watchdog_user_enabled,
2316 : .maxlen = sizeof(int),
2317 : .mode = 0644,
2318 : .proc_handler = proc_soft_watchdog,
2319 : .extra1 = SYSCTL_ZERO,
2320 : .extra2 = SYSCTL_ONE,
2321 : },
2322 : {
2323 : .procname = "softlockup_panic",
2324 : .data = &softlockup_panic,
2325 : .maxlen = sizeof(int),
2326 : .mode = 0644,
2327 : .proc_handler = proc_dointvec_minmax,
2328 : .extra1 = SYSCTL_ZERO,
2329 : .extra2 = SYSCTL_ONE,
2330 : },
2331 : #ifdef CONFIG_SMP
2332 : {
2333 : .procname = "softlockup_all_cpu_backtrace",
2334 : .data = &sysctl_softlockup_all_cpu_backtrace,
2335 : .maxlen = sizeof(int),
2336 : .mode = 0644,
2337 : .proc_handler = proc_dointvec_minmax,
2338 : .extra1 = SYSCTL_ZERO,
2339 : .extra2 = SYSCTL_ONE,
2340 : },
2341 : #endif /* CONFIG_SMP */
2342 : #endif
2343 : #ifdef CONFIG_HARDLOCKUP_DETECTOR
2344 : {
2345 : .procname = "hardlockup_panic",
2346 : .data = &hardlockup_panic,
2347 : .maxlen = sizeof(int),
2348 : .mode = 0644,
2349 : .proc_handler = proc_dointvec_minmax,
2350 : .extra1 = SYSCTL_ZERO,
2351 : .extra2 = SYSCTL_ONE,
2352 : },
2353 : #ifdef CONFIG_SMP
2354 : {
2355 : .procname = "hardlockup_all_cpu_backtrace",
2356 : .data = &sysctl_hardlockup_all_cpu_backtrace,
2357 : .maxlen = sizeof(int),
2358 : .mode = 0644,
2359 : .proc_handler = proc_dointvec_minmax,
2360 : .extra1 = SYSCTL_ZERO,
2361 : .extra2 = SYSCTL_ONE,
2362 : },
2363 : #endif /* CONFIG_SMP */
2364 : #endif
2365 : #endif
2366 :
2367 : #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
2368 : {
2369 : .procname = "unknown_nmi_panic",
2370 : .data = &unknown_nmi_panic,
2371 : .maxlen = sizeof (int),
2372 : .mode = 0644,
2373 : .proc_handler = proc_dointvec,
2374 : },
2375 : #endif
2376 :
2377 : #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \
2378 : defined(CONFIG_DEBUG_STACKOVERFLOW)
2379 : {
2380 : .procname = "panic_on_stackoverflow",
2381 : .data = &sysctl_panic_on_stackoverflow,
2382 : .maxlen = sizeof(int),
2383 : .mode = 0644,
2384 : .proc_handler = proc_dointvec,
2385 : },
2386 : #endif
2387 : #if defined(CONFIG_X86)
2388 : {
2389 : .procname = "panic_on_unrecovered_nmi",
2390 : .data = &panic_on_unrecovered_nmi,
2391 : .maxlen = sizeof(int),
2392 : .mode = 0644,
2393 : .proc_handler = proc_dointvec,
2394 : },
2395 : {
2396 : .procname = "panic_on_io_nmi",
2397 : .data = &panic_on_io_nmi,
2398 : .maxlen = sizeof(int),
2399 : .mode = 0644,
2400 : .proc_handler = proc_dointvec,
2401 : },
2402 : {
2403 : .procname = "bootloader_type",
2404 : .data = &bootloader_type,
2405 : .maxlen = sizeof (int),
2406 : .mode = 0444,
2407 : .proc_handler = proc_dointvec,
2408 : },
2409 : {
2410 : .procname = "bootloader_version",
2411 : .data = &bootloader_version,
2412 : .maxlen = sizeof (int),
2413 : .mode = 0444,
2414 : .proc_handler = proc_dointvec,
2415 : },
2416 : {
2417 : .procname = "io_delay_type",
2418 : .data = &io_delay_type,
2419 : .maxlen = sizeof(int),
2420 : .mode = 0644,
2421 : .proc_handler = proc_dointvec,
2422 : },
2423 : #endif
2424 : #if defined(CONFIG_MMU)
2425 : {
2426 : .procname = "randomize_va_space",
2427 : .data = &randomize_va_space,
2428 : .maxlen = sizeof(int),
2429 : .mode = 0644,
2430 : .proc_handler = proc_dointvec,
2431 : },
2432 : #endif
2433 : #if defined(CONFIG_S390) && defined(CONFIG_SMP)
2434 : {
2435 : .procname = "spin_retry",
2436 : .data = &spin_retry,
2437 : .maxlen = sizeof (int),
2438 : .mode = 0644,
2439 : .proc_handler = proc_dointvec,
2440 : },
2441 : #endif
2442 : #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
2443 : {
2444 : .procname = "acpi_video_flags",
2445 : .data = &acpi_realmode_flags,
2446 : .maxlen = sizeof (unsigned long),
2447 : .mode = 0644,
2448 : .proc_handler = proc_doulongvec_minmax,
2449 : },
2450 : #endif
2451 : #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
2452 : {
2453 : .procname = "ignore-unaligned-usertrap",
2454 : .data = &no_unaligned_warning,
2455 : .maxlen = sizeof (int),
2456 : .mode = 0644,
2457 : .proc_handler = proc_dointvec,
2458 : },
2459 : #endif
2460 : #ifdef CONFIG_IA64
2461 : {
2462 : .procname = "unaligned-dump-stack",
2463 : .data = &unaligned_dump_stack,
2464 : .maxlen = sizeof (int),
2465 : .mode = 0644,
2466 : .proc_handler = proc_dointvec,
2467 : },
2468 : #endif
2469 : #ifdef CONFIG_DETECT_HUNG_TASK
2470 : #ifdef CONFIG_SMP
2471 : {
2472 : .procname = "hung_task_all_cpu_backtrace",
2473 : .data = &sysctl_hung_task_all_cpu_backtrace,
2474 : .maxlen = sizeof(int),
2475 : .mode = 0644,
2476 : .proc_handler = proc_dointvec_minmax,
2477 : .extra1 = SYSCTL_ZERO,
2478 : .extra2 = SYSCTL_ONE,
2479 : },
2480 : #endif /* CONFIG_SMP */
2481 : {
2482 : .procname = "hung_task_panic",
2483 : .data = &sysctl_hung_task_panic,
2484 : .maxlen = sizeof(int),
2485 : .mode = 0644,
2486 : .proc_handler = proc_dointvec_minmax,
2487 : .extra1 = SYSCTL_ZERO,
2488 : .extra2 = SYSCTL_ONE,
2489 : },
2490 : {
2491 : .procname = "hung_task_check_count",
2492 : .data = &sysctl_hung_task_check_count,
2493 : .maxlen = sizeof(int),
2494 : .mode = 0644,
2495 : .proc_handler = proc_dointvec_minmax,
2496 : .extra1 = SYSCTL_ZERO,
2497 : },
2498 : {
2499 : .procname = "hung_task_timeout_secs",
2500 : .data = &sysctl_hung_task_timeout_secs,
2501 : .maxlen = sizeof(unsigned long),
2502 : .mode = 0644,
2503 : .proc_handler = proc_dohung_task_timeout_secs,
2504 : .extra2 = &hung_task_timeout_max,
2505 : },
2506 : {
2507 : .procname = "hung_task_check_interval_secs",
2508 : .data = &sysctl_hung_task_check_interval_secs,
2509 : .maxlen = sizeof(unsigned long),
2510 : .mode = 0644,
2511 : .proc_handler = proc_dohung_task_timeout_secs,
2512 : .extra2 = &hung_task_timeout_max,
2513 : },
2514 : {
2515 : .procname = "hung_task_warnings",
2516 : .data = &sysctl_hung_task_warnings,
2517 : .maxlen = sizeof(int),
2518 : .mode = 0644,
2519 : .proc_handler = proc_dointvec_minmax,
2520 : .extra1 = &neg_one,
2521 : },
2522 : #endif
2523 : #ifdef CONFIG_RT_MUTEXES
2524 : {
2525 : .procname = "max_lock_depth",
2526 : .data = &max_lock_depth,
2527 : .maxlen = sizeof(int),
2528 : .mode = 0644,
2529 : .proc_handler = proc_dointvec,
2530 : },
2531 : #endif
2532 : {
2533 : .procname = "poweroff_cmd",
2534 : .data = &poweroff_cmd,
2535 : .maxlen = POWEROFF_CMD_PATH_LEN,
2536 : .mode = 0644,
2537 : .proc_handler = proc_dostring,
2538 : },
2539 : #ifdef CONFIG_KEYS
2540 : {
2541 : .procname = "keys",
2542 : .mode = 0555,
2543 : .child = key_sysctls,
2544 : },
2545 : #endif
2546 : #ifdef CONFIG_PERF_EVENTS
2547 : /*
2548 : * User-space scripts rely on the existence of this file
2549 : * as a feature check for perf_events being enabled.
2550 : *
2551 : * So it's an ABI, do not remove!
2552 : */
2553 : {
2554 : .procname = "perf_event_paranoid",
2555 : .data = &sysctl_perf_event_paranoid,
2556 : .maxlen = sizeof(sysctl_perf_event_paranoid),
2557 : .mode = 0644,
2558 : .proc_handler = proc_dointvec,
2559 : },
2560 : {
2561 : .procname = "perf_event_mlock_kb",
2562 : .data = &sysctl_perf_event_mlock,
2563 : .maxlen = sizeof(sysctl_perf_event_mlock),
2564 : .mode = 0644,
2565 : .proc_handler = proc_dointvec,
2566 : },
2567 : {
2568 : .procname = "perf_event_max_sample_rate",
2569 : .data = &sysctl_perf_event_sample_rate,
2570 : .maxlen = sizeof(sysctl_perf_event_sample_rate),
2571 : .mode = 0644,
2572 : .proc_handler = perf_proc_update_handler,
2573 : .extra1 = SYSCTL_ONE,
2574 : },
2575 : {
2576 : .procname = "perf_cpu_time_max_percent",
2577 : .data = &sysctl_perf_cpu_time_max_percent,
2578 : .maxlen = sizeof(sysctl_perf_cpu_time_max_percent),
2579 : .mode = 0644,
2580 : .proc_handler = perf_cpu_time_max_percent_handler,
2581 : .extra1 = SYSCTL_ZERO,
2582 : .extra2 = &one_hundred,
2583 : },
2584 : {
2585 : .procname = "perf_event_max_stack",
2586 : .data = &sysctl_perf_event_max_stack,
2587 : .maxlen = sizeof(sysctl_perf_event_max_stack),
2588 : .mode = 0644,
2589 : .proc_handler = perf_event_max_stack_handler,
2590 : .extra1 = SYSCTL_ZERO,
2591 : .extra2 = &six_hundred_forty_kb,
2592 : },
2593 : {
2594 : .procname = "perf_event_max_contexts_per_stack",
2595 : .data = &sysctl_perf_event_max_contexts_per_stack,
2596 : .maxlen = sizeof(sysctl_perf_event_max_contexts_per_stack),
2597 : .mode = 0644,
2598 : .proc_handler = perf_event_max_stack_handler,
2599 : .extra1 = SYSCTL_ZERO,
2600 : .extra2 = &one_thousand,
2601 : },
2602 : #endif
2603 : {
2604 : .procname = "panic_on_warn",
2605 : .data = &panic_on_warn,
2606 : .maxlen = sizeof(int),
2607 : .mode = 0644,
2608 : .proc_handler = proc_dointvec_minmax,
2609 : .extra1 = SYSCTL_ZERO,
2610 : .extra2 = SYSCTL_ONE,
2611 : },
2612 : #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
2613 : {
2614 : .procname = "timer_migration",
2615 : .data = &sysctl_timer_migration,
2616 : .maxlen = sizeof(unsigned int),
2617 : .mode = 0644,
2618 : .proc_handler = timer_migration_handler,
2619 : .extra1 = SYSCTL_ZERO,
2620 : .extra2 = SYSCTL_ONE,
2621 : },
2622 : #endif
2623 : #ifdef CONFIG_BPF_SYSCALL
2624 : {
2625 : .procname = "unprivileged_bpf_disabled",
2626 : .data = &sysctl_unprivileged_bpf_disabled,
2627 : .maxlen = sizeof(sysctl_unprivileged_bpf_disabled),
2628 : .mode = 0644,
2629 : /* only handle a transition from default "0" to "1" */
2630 : .proc_handler = proc_dointvec_minmax,
2631 : .extra1 = SYSCTL_ONE,
2632 : .extra2 = SYSCTL_ONE,
2633 : },
2634 : {
2635 : .procname = "bpf_stats_enabled",
2636 : .data = &bpf_stats_enabled_key.key,
2637 : .maxlen = sizeof(bpf_stats_enabled_key),
2638 : .mode = 0644,
2639 : .proc_handler = bpf_stats_handler,
2640 : },
2641 : #endif
2642 : #if defined(CONFIG_TREE_RCU)
2643 : {
2644 : .procname = "panic_on_rcu_stall",
2645 : .data = &sysctl_panic_on_rcu_stall,
2646 : .maxlen = sizeof(sysctl_panic_on_rcu_stall),
2647 : .mode = 0644,
2648 : .proc_handler = proc_dointvec_minmax,
2649 : .extra1 = SYSCTL_ZERO,
2650 : .extra2 = SYSCTL_ONE,
2651 : },
2652 : #endif
2653 : #if defined(CONFIG_TREE_RCU)
2654 : {
2655 : .procname = "max_rcu_stall_to_panic",
2656 : .data = &sysctl_max_rcu_stall_to_panic,
2657 : .maxlen = sizeof(sysctl_max_rcu_stall_to_panic),
2658 : .mode = 0644,
2659 : .proc_handler = proc_dointvec_minmax,
2660 : .extra1 = SYSCTL_ONE,
2661 : .extra2 = SYSCTL_INT_MAX,
2662 : },
2663 : #endif
2664 : #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
2665 : {
2666 : .procname = "stack_erasing",
2667 : .data = NULL,
2668 : .maxlen = sizeof(int),
2669 : .mode = 0600,
2670 : .proc_handler = stack_erasing_sysctl,
2671 : .extra1 = SYSCTL_ZERO,
2672 : .extra2 = SYSCTL_ONE,
2673 : },
2674 : #endif
2675 : { }
2676 : };
2677 :
2678 : static struct ctl_table vm_table[] = {
2679 : {
2680 : .procname = "overcommit_memory",
2681 : .data = &sysctl_overcommit_memory,
2682 : .maxlen = sizeof(sysctl_overcommit_memory),
2683 : .mode = 0644,
2684 : .proc_handler = overcommit_policy_handler,
2685 : .extra1 = SYSCTL_ZERO,
2686 : .extra2 = &two,
2687 : },
2688 : {
2689 : .procname = "panic_on_oom",
2690 : .data = &sysctl_panic_on_oom,
2691 : .maxlen = sizeof(sysctl_panic_on_oom),
2692 : .mode = 0644,
2693 : .proc_handler = proc_dointvec_minmax,
2694 : .extra1 = SYSCTL_ZERO,
2695 : .extra2 = &two,
2696 : },
2697 : {
2698 : .procname = "oom_kill_allocating_task",
2699 : .data = &sysctl_oom_kill_allocating_task,
2700 : .maxlen = sizeof(sysctl_oom_kill_allocating_task),
2701 : .mode = 0644,
2702 : .proc_handler = proc_dointvec,
2703 : },
2704 : {
2705 : .procname = "oom_dump_tasks",
2706 : .data = &sysctl_oom_dump_tasks,
2707 : .maxlen = sizeof(sysctl_oom_dump_tasks),
2708 : .mode = 0644,
2709 : .proc_handler = proc_dointvec,
2710 : },
2711 : {
2712 : .procname = "overcommit_ratio",
2713 : .data = &sysctl_overcommit_ratio,
2714 : .maxlen = sizeof(sysctl_overcommit_ratio),
2715 : .mode = 0644,
2716 : .proc_handler = overcommit_ratio_handler,
2717 : },
2718 : {
2719 : .procname = "overcommit_kbytes",
2720 : .data = &sysctl_overcommit_kbytes,
2721 : .maxlen = sizeof(sysctl_overcommit_kbytes),
2722 : .mode = 0644,
2723 : .proc_handler = overcommit_kbytes_handler,
2724 : },
2725 : {
2726 : .procname = "page-cluster",
2727 : .data = &page_cluster,
2728 : .maxlen = sizeof(int),
2729 : .mode = 0644,
2730 : .proc_handler = proc_dointvec_minmax,
2731 : .extra1 = SYSCTL_ZERO,
2732 : },
2733 : {
2734 : .procname = "dirty_background_ratio",
2735 : .data = &dirty_background_ratio,
2736 : .maxlen = sizeof(dirty_background_ratio),
2737 : .mode = 0644,
2738 : .proc_handler = dirty_background_ratio_handler,
2739 : .extra1 = SYSCTL_ZERO,
2740 : .extra2 = &one_hundred,
2741 : },
2742 : {
2743 : .procname = "dirty_background_bytes",
2744 : .data = &dirty_background_bytes,
2745 : .maxlen = sizeof(dirty_background_bytes),
2746 : .mode = 0644,
2747 : .proc_handler = dirty_background_bytes_handler,
2748 : .extra1 = &one_ul,
2749 : },
2750 : {
2751 : .procname = "dirty_ratio",
2752 : .data = &vm_dirty_ratio,
2753 : .maxlen = sizeof(vm_dirty_ratio),
2754 : .mode = 0644,
2755 : .proc_handler = dirty_ratio_handler,
2756 : .extra1 = SYSCTL_ZERO,
2757 : .extra2 = &one_hundred,
2758 : },
2759 : {
2760 : .procname = "dirty_bytes",
2761 : .data = &vm_dirty_bytes,
2762 : .maxlen = sizeof(vm_dirty_bytes),
2763 : .mode = 0644,
2764 : .proc_handler = dirty_bytes_handler,
2765 : .extra1 = &dirty_bytes_min,
2766 : },
2767 : {
2768 : .procname = "dirty_writeback_centisecs",
2769 : .data = &dirty_writeback_interval,
2770 : .maxlen = sizeof(dirty_writeback_interval),
2771 : .mode = 0644,
2772 : .proc_handler = dirty_writeback_centisecs_handler,
2773 : },
2774 : {
2775 : .procname = "dirty_expire_centisecs",
2776 : .data = &dirty_expire_interval,
2777 : .maxlen = sizeof(dirty_expire_interval),
2778 : .mode = 0644,
2779 : .proc_handler = proc_dointvec_minmax,
2780 : .extra1 = SYSCTL_ZERO,
2781 : },
2782 : {
2783 : .procname = "dirtytime_expire_seconds",
2784 : .data = &dirtytime_expire_interval,
2785 : .maxlen = sizeof(dirtytime_expire_interval),
2786 : .mode = 0644,
2787 : .proc_handler = dirtytime_interval_handler,
2788 : .extra1 = SYSCTL_ZERO,
2789 : },
2790 : {
2791 : .procname = "swappiness",
2792 : .data = &vm_swappiness,
2793 : .maxlen = sizeof(vm_swappiness),
2794 : .mode = 0644,
2795 : .proc_handler = proc_dointvec_minmax,
2796 : .extra1 = SYSCTL_ZERO,
2797 : .extra2 = &two_hundred,
2798 : },
2799 : #ifdef CONFIG_HUGETLB_PAGE
2800 : {
2801 : .procname = "nr_hugepages",
2802 : .data = NULL,
2803 : .maxlen = sizeof(unsigned long),
2804 : .mode = 0644,
2805 : .proc_handler = hugetlb_sysctl_handler,
2806 : },
2807 : #ifdef CONFIG_NUMA
2808 : {
2809 : .procname = "nr_hugepages_mempolicy",
2810 : .data = NULL,
2811 : .maxlen = sizeof(unsigned long),
2812 : .mode = 0644,
2813 : .proc_handler = &hugetlb_mempolicy_sysctl_handler,
2814 : },
2815 : {
2816 : .procname = "numa_stat",
2817 : .data = &sysctl_vm_numa_stat,
2818 : .maxlen = sizeof(int),
2819 : .mode = 0644,
2820 : .proc_handler = sysctl_vm_numa_stat_handler,
2821 : .extra1 = SYSCTL_ZERO,
2822 : .extra2 = SYSCTL_ONE,
2823 : },
2824 : #endif
2825 : {
2826 : .procname = "hugetlb_shm_group",
2827 : .data = &sysctl_hugetlb_shm_group,
2828 : .maxlen = sizeof(gid_t),
2829 : .mode = 0644,
2830 : .proc_handler = proc_dointvec,
2831 : },
2832 : {
2833 : .procname = "nr_overcommit_hugepages",
2834 : .data = NULL,
2835 : .maxlen = sizeof(unsigned long),
2836 : .mode = 0644,
2837 : .proc_handler = hugetlb_overcommit_handler,
2838 : },
2839 : #endif
2840 : {
2841 : .procname = "lowmem_reserve_ratio",
2842 : .data = &sysctl_lowmem_reserve_ratio,
2843 : .maxlen = sizeof(sysctl_lowmem_reserve_ratio),
2844 : .mode = 0644,
2845 : .proc_handler = lowmem_reserve_ratio_sysctl_handler,
2846 : },
2847 : {
2848 : .procname = "drop_caches",
2849 : .data = &sysctl_drop_caches,
2850 : .maxlen = sizeof(int),
2851 : .mode = 0200,
2852 : .proc_handler = drop_caches_sysctl_handler,
2853 : .extra1 = SYSCTL_ONE,
2854 : .extra2 = &four,
2855 : },
2856 : #ifdef CONFIG_COMPACTION
2857 : {
2858 : .procname = "compact_memory",
2859 : .data = &sysctl_compact_memory,
2860 : .maxlen = sizeof(int),
2861 : .mode = 0200,
2862 : .proc_handler = sysctl_compaction_handler,
2863 : },
2864 : {
2865 : .procname = "compaction_proactiveness",
2866 : .data = &sysctl_compaction_proactiveness,
2867 : .maxlen = sizeof(sysctl_compaction_proactiveness),
2868 : .mode = 0644,
2869 : .proc_handler = proc_dointvec_minmax,
2870 : .extra1 = SYSCTL_ZERO,
2871 : .extra2 = &one_hundred,
2872 : },
2873 : {
2874 : .procname = "extfrag_threshold",
2875 : .data = &sysctl_extfrag_threshold,
2876 : .maxlen = sizeof(int),
2877 : .mode = 0644,
2878 : .proc_handler = proc_dointvec_minmax,
2879 : .extra1 = &min_extfrag_threshold,
2880 : .extra2 = &max_extfrag_threshold,
2881 : },
2882 : {
2883 : .procname = "compact_unevictable_allowed",
2884 : .data = &sysctl_compact_unevictable_allowed,
2885 : .maxlen = sizeof(int),
2886 : .mode = 0644,
2887 : .proc_handler = proc_dointvec_minmax_warn_RT_change,
2888 : .extra1 = SYSCTL_ZERO,
2889 : .extra2 = SYSCTL_ONE,
2890 : },
2891 :
2892 : #endif /* CONFIG_COMPACTION */
2893 : {
2894 : .procname = "min_free_kbytes",
2895 : .data = &min_free_kbytes,
2896 : .maxlen = sizeof(min_free_kbytes),
2897 : .mode = 0644,
2898 : .proc_handler = min_free_kbytes_sysctl_handler,
2899 : .extra1 = SYSCTL_ZERO,
2900 : },
2901 : {
2902 : .procname = "watermark_boost_factor",
2903 : .data = &watermark_boost_factor,
2904 : .maxlen = sizeof(watermark_boost_factor),
2905 : .mode = 0644,
2906 : .proc_handler = proc_dointvec_minmax,
2907 : .extra1 = SYSCTL_ZERO,
2908 : },
2909 : {
2910 : .procname = "watermark_scale_factor",
2911 : .data = &watermark_scale_factor,
2912 : .maxlen = sizeof(watermark_scale_factor),
2913 : .mode = 0644,
2914 : .proc_handler = watermark_scale_factor_sysctl_handler,
2915 : .extra1 = SYSCTL_ONE,
2916 : .extra2 = &one_thousand,
2917 : },
2918 : {
2919 : .procname = "percpu_pagelist_fraction",
2920 : .data = &percpu_pagelist_fraction,
2921 : .maxlen = sizeof(percpu_pagelist_fraction),
2922 : .mode = 0644,
2923 : .proc_handler = percpu_pagelist_fraction_sysctl_handler,
2924 : .extra1 = SYSCTL_ZERO,
2925 : },
2926 : {
2927 : .procname = "page_lock_unfairness",
2928 : .data = &sysctl_page_lock_unfairness,
2929 : .maxlen = sizeof(sysctl_page_lock_unfairness),
2930 : .mode = 0644,
2931 : .proc_handler = proc_dointvec_minmax,
2932 : .extra1 = SYSCTL_ZERO,
2933 : },
2934 : #ifdef CONFIG_MMU
2935 : {
2936 : .procname = "max_map_count",
2937 : .data = &sysctl_max_map_count,
2938 : .maxlen = sizeof(sysctl_max_map_count),
2939 : .mode = 0644,
2940 : .proc_handler = proc_dointvec_minmax,
2941 : .extra1 = SYSCTL_ZERO,
2942 : },
2943 : #else
2944 : {
2945 : .procname = "nr_trim_pages",
2946 : .data = &sysctl_nr_trim_pages,
2947 : .maxlen = sizeof(sysctl_nr_trim_pages),
2948 : .mode = 0644,
2949 : .proc_handler = proc_dointvec_minmax,
2950 : .extra1 = SYSCTL_ZERO,
2951 : },
2952 : #endif
2953 : {
2954 : .procname = "laptop_mode",
2955 : .data = &laptop_mode,
2956 : .maxlen = sizeof(laptop_mode),
2957 : .mode = 0644,
2958 : .proc_handler = proc_dointvec_jiffies,
2959 : },
2960 : {
2961 : .procname = "block_dump",
2962 : .data = &block_dump,
2963 : .maxlen = sizeof(block_dump),
2964 : .mode = 0644,
2965 : .proc_handler = proc_dointvec_minmax,
2966 : .extra1 = SYSCTL_ZERO,
2967 : },
2968 : {
2969 : .procname = "vfs_cache_pressure",
2970 : .data = &sysctl_vfs_cache_pressure,
2971 : .maxlen = sizeof(sysctl_vfs_cache_pressure),
2972 : .mode = 0644,
2973 : .proc_handler = proc_dointvec_minmax,
2974 : .extra1 = SYSCTL_ZERO,
2975 : },
2976 : #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
2977 : defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
2978 : {
2979 : .procname = "legacy_va_layout",
2980 : .data = &sysctl_legacy_va_layout,
2981 : .maxlen = sizeof(sysctl_legacy_va_layout),
2982 : .mode = 0644,
2983 : .proc_handler = proc_dointvec_minmax,
2984 : .extra1 = SYSCTL_ZERO,
2985 : },
2986 : #endif
2987 : #ifdef CONFIG_NUMA
2988 : {
2989 : .procname = "zone_reclaim_mode",
2990 : .data = &node_reclaim_mode,
2991 : .maxlen = sizeof(node_reclaim_mode),
2992 : .mode = 0644,
2993 : .proc_handler = proc_dointvec_minmax,
2994 : .extra1 = SYSCTL_ZERO,
2995 : },
2996 : {
2997 : .procname = "min_unmapped_ratio",
2998 : .data = &sysctl_min_unmapped_ratio,
2999 : .maxlen = sizeof(sysctl_min_unmapped_ratio),
3000 : .mode = 0644,
3001 : .proc_handler = sysctl_min_unmapped_ratio_sysctl_handler,
3002 : .extra1 = SYSCTL_ZERO,
3003 : .extra2 = &one_hundred,
3004 : },
3005 : {
3006 : .procname = "min_slab_ratio",
3007 : .data = &sysctl_min_slab_ratio,
3008 : .maxlen = sizeof(sysctl_min_slab_ratio),
3009 : .mode = 0644,
3010 : .proc_handler = sysctl_min_slab_ratio_sysctl_handler,
3011 : .extra1 = SYSCTL_ZERO,
3012 : .extra2 = &one_hundred,
3013 : },
3014 : #endif
3015 : #ifdef CONFIG_SMP
3016 : {
3017 : .procname = "stat_interval",
3018 : .data = &sysctl_stat_interval,
3019 : .maxlen = sizeof(sysctl_stat_interval),
3020 : .mode = 0644,
3021 : .proc_handler = proc_dointvec_jiffies,
3022 : },
3023 : {
3024 : .procname = "stat_refresh",
3025 : .data = NULL,
3026 : .maxlen = 0,
3027 : .mode = 0600,
3028 : .proc_handler = vmstat_refresh,
3029 : },
3030 : #endif
3031 : #ifdef CONFIG_MMU
3032 : {
3033 : .procname = "mmap_min_addr",
3034 : .data = &dac_mmap_min_addr,
3035 : .maxlen = sizeof(unsigned long),
3036 : .mode = 0644,
3037 : .proc_handler = mmap_min_addr_handler,
3038 : },
3039 : #endif
3040 : #ifdef CONFIG_NUMA
3041 : {
3042 : .procname = "numa_zonelist_order",
3043 : .data = &numa_zonelist_order,
3044 : .maxlen = NUMA_ZONELIST_ORDER_LEN,
3045 : .mode = 0644,
3046 : .proc_handler = numa_zonelist_order_handler,
3047 : },
3048 : #endif
3049 : #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
3050 : (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
3051 : {
3052 : .procname = "vdso_enabled",
3053 : #ifdef CONFIG_X86_32
3054 : .data = &vdso32_enabled,
3055 : .maxlen = sizeof(vdso32_enabled),
3056 : #else
3057 : .data = &vdso_enabled,
3058 : .maxlen = sizeof(vdso_enabled),
3059 : #endif
3060 : .mode = 0644,
3061 : .proc_handler = proc_dointvec,
3062 : .extra1 = SYSCTL_ZERO,
3063 : },
3064 : #endif
3065 : #ifdef CONFIG_HIGHMEM
3066 : {
3067 : .procname = "highmem_is_dirtyable",
3068 : .data = &vm_highmem_is_dirtyable,
3069 : .maxlen = sizeof(vm_highmem_is_dirtyable),
3070 : .mode = 0644,
3071 : .proc_handler = proc_dointvec_minmax,
3072 : .extra1 = SYSCTL_ZERO,
3073 : .extra2 = SYSCTL_ONE,
3074 : },
3075 : #endif
3076 : #ifdef CONFIG_MEMORY_FAILURE
3077 : {
3078 : .procname = "memory_failure_early_kill",
3079 : .data = &sysctl_memory_failure_early_kill,
3080 : .maxlen = sizeof(sysctl_memory_failure_early_kill),
3081 : .mode = 0644,
3082 : .proc_handler = proc_dointvec_minmax,
3083 : .extra1 = SYSCTL_ZERO,
3084 : .extra2 = SYSCTL_ONE,
3085 : },
3086 : {
3087 : .procname = "memory_failure_recovery",
3088 : .data = &sysctl_memory_failure_recovery,
3089 : .maxlen = sizeof(sysctl_memory_failure_recovery),
3090 : .mode = 0644,
3091 : .proc_handler = proc_dointvec_minmax,
3092 : .extra1 = SYSCTL_ZERO,
3093 : .extra2 = SYSCTL_ONE,
3094 : },
3095 : #endif
3096 : {
3097 : .procname = "user_reserve_kbytes",
3098 : .data = &sysctl_user_reserve_kbytes,
3099 : .maxlen = sizeof(sysctl_user_reserve_kbytes),
3100 : .mode = 0644,
3101 : .proc_handler = proc_doulongvec_minmax,
3102 : },
3103 : {
3104 : .procname = "admin_reserve_kbytes",
3105 : .data = &sysctl_admin_reserve_kbytes,
3106 : .maxlen = sizeof(sysctl_admin_reserve_kbytes),
3107 : .mode = 0644,
3108 : .proc_handler = proc_doulongvec_minmax,
3109 : },
3110 : #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
3111 : {
3112 : .procname = "mmap_rnd_bits",
3113 : .data = &mmap_rnd_bits,
3114 : .maxlen = sizeof(mmap_rnd_bits),
3115 : .mode = 0600,
3116 : .proc_handler = proc_dointvec_minmax,
3117 : .extra1 = (void *)&mmap_rnd_bits_min,
3118 : .extra2 = (void *)&mmap_rnd_bits_max,
3119 : },
3120 : #endif
3121 : #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
3122 : {
3123 : .procname = "mmap_rnd_compat_bits",
3124 : .data = &mmap_rnd_compat_bits,
3125 : .maxlen = sizeof(mmap_rnd_compat_bits),
3126 : .mode = 0600,
3127 : .proc_handler = proc_dointvec_minmax,
3128 : .extra1 = (void *)&mmap_rnd_compat_bits_min,
3129 : .extra2 = (void *)&mmap_rnd_compat_bits_max,
3130 : },
3131 : #endif
3132 : #ifdef CONFIG_USERFAULTFD
3133 : {
3134 : .procname = "unprivileged_userfaultfd",
3135 : .data = &sysctl_unprivileged_userfaultfd,
3136 : .maxlen = sizeof(sysctl_unprivileged_userfaultfd),
3137 : .mode = 0644,
3138 : .proc_handler = proc_dointvec_minmax,
3139 : .extra1 = SYSCTL_ZERO,
3140 : .extra2 = SYSCTL_ONE,
3141 : },
3142 : #endif
3143 : { }
3144 : };
3145 :
3146 : static struct ctl_table fs_table[] = {
3147 : {
3148 : .procname = "inode-nr",
3149 : .data = &inodes_stat,
3150 : .maxlen = 2*sizeof(long),
3151 : .mode = 0444,
3152 : .proc_handler = proc_nr_inodes,
3153 : },
3154 : {
3155 : .procname = "inode-state",
3156 : .data = &inodes_stat,
3157 : .maxlen = 7*sizeof(long),
3158 : .mode = 0444,
3159 : .proc_handler = proc_nr_inodes,
3160 : },
3161 : {
3162 : .procname = "file-nr",
3163 : .data = &files_stat,
3164 : .maxlen = sizeof(files_stat),
3165 : .mode = 0444,
3166 : .proc_handler = proc_nr_files,
3167 : },
3168 : {
3169 : .procname = "file-max",
3170 : .data = &files_stat.max_files,
3171 : .maxlen = sizeof(files_stat.max_files),
3172 : .mode = 0644,
3173 : .proc_handler = proc_doulongvec_minmax,
3174 : .extra1 = &zero_ul,
3175 : .extra2 = &long_max,
3176 : },
3177 : {
3178 : .procname = "nr_open",
3179 : .data = &sysctl_nr_open,
3180 : .maxlen = sizeof(unsigned int),
3181 : .mode = 0644,
3182 : .proc_handler = proc_dointvec_minmax,
3183 : .extra1 = &sysctl_nr_open_min,
3184 : .extra2 = &sysctl_nr_open_max,
3185 : },
3186 : {
3187 : .procname = "dentry-state",
3188 : .data = &dentry_stat,
3189 : .maxlen = 6*sizeof(long),
3190 : .mode = 0444,
3191 : .proc_handler = proc_nr_dentry,
3192 : },
3193 : {
3194 : .procname = "overflowuid",
3195 : .data = &fs_overflowuid,
3196 : .maxlen = sizeof(int),
3197 : .mode = 0644,
3198 : .proc_handler = proc_dointvec_minmax,
3199 : .extra1 = &minolduid,
3200 : .extra2 = &maxolduid,
3201 : },
3202 : {
3203 : .procname = "overflowgid",
3204 : .data = &fs_overflowgid,
3205 : .maxlen = sizeof(int),
3206 : .mode = 0644,
3207 : .proc_handler = proc_dointvec_minmax,
3208 : .extra1 = &minolduid,
3209 : .extra2 = &maxolduid,
3210 : },
3211 : #ifdef CONFIG_FILE_LOCKING
3212 : {
3213 : .procname = "leases-enable",
3214 : .data = &leases_enable,
3215 : .maxlen = sizeof(int),
3216 : .mode = 0644,
3217 : .proc_handler = proc_dointvec,
3218 : },
3219 : #endif
3220 : #ifdef CONFIG_DNOTIFY
3221 : {
3222 : .procname = "dir-notify-enable",
3223 : .data = &dir_notify_enable,
3224 : .maxlen = sizeof(int),
3225 : .mode = 0644,
3226 : .proc_handler = proc_dointvec,
3227 : },
3228 : #endif
3229 : #ifdef CONFIG_MMU
3230 : #ifdef CONFIG_FILE_LOCKING
3231 : {
3232 : .procname = "lease-break-time",
3233 : .data = &lease_break_time,
3234 : .maxlen = sizeof(int),
3235 : .mode = 0644,
3236 : .proc_handler = proc_dointvec,
3237 : },
3238 : #endif
3239 : #ifdef CONFIG_AIO
3240 : {
3241 : .procname = "aio-nr",
3242 : .data = &aio_nr,
3243 : .maxlen = sizeof(aio_nr),
3244 : .mode = 0444,
3245 : .proc_handler = proc_doulongvec_minmax,
3246 : },
3247 : {
3248 : .procname = "aio-max-nr",
3249 : .data = &aio_max_nr,
3250 : .maxlen = sizeof(aio_max_nr),
3251 : .mode = 0644,
3252 : .proc_handler = proc_doulongvec_minmax,
3253 : },
3254 : #endif /* CONFIG_AIO */
3255 : #ifdef CONFIG_INOTIFY_USER
3256 : {
3257 : .procname = "inotify",
3258 : .mode = 0555,
3259 : .child = inotify_table,
3260 : },
3261 : #endif
3262 : #ifdef CONFIG_EPOLL
3263 : {
3264 : .procname = "epoll",
3265 : .mode = 0555,
3266 : .child = epoll_table,
3267 : },
3268 : #endif
3269 : #endif
3270 : {
3271 : .procname = "protected_symlinks",
3272 : .data = &sysctl_protected_symlinks,
3273 : .maxlen = sizeof(int),
3274 : .mode = 0600,
3275 : .proc_handler = proc_dointvec_minmax,
3276 : .extra1 = SYSCTL_ZERO,
3277 : .extra2 = SYSCTL_ONE,
3278 : },
3279 : {
3280 : .procname = "protected_hardlinks",
3281 : .data = &sysctl_protected_hardlinks,
3282 : .maxlen = sizeof(int),
3283 : .mode = 0600,
3284 : .proc_handler = proc_dointvec_minmax,
3285 : .extra1 = SYSCTL_ZERO,
3286 : .extra2 = SYSCTL_ONE,
3287 : },
3288 : {
3289 : .procname = "protected_fifos",
3290 : .data = &sysctl_protected_fifos,
3291 : .maxlen = sizeof(int),
3292 : .mode = 0600,
3293 : .proc_handler = proc_dointvec_minmax,
3294 : .extra1 = SYSCTL_ZERO,
3295 : .extra2 = &two,
3296 : },
3297 : {
3298 : .procname = "protected_regular",
3299 : .data = &sysctl_protected_regular,
3300 : .maxlen = sizeof(int),
3301 : .mode = 0600,
3302 : .proc_handler = proc_dointvec_minmax,
3303 : .extra1 = SYSCTL_ZERO,
3304 : .extra2 = &two,
3305 : },
3306 : {
3307 : .procname = "suid_dumpable",
3308 : .data = &suid_dumpable,
3309 : .maxlen = sizeof(int),
3310 : .mode = 0644,
3311 : .proc_handler = proc_dointvec_minmax_coredump,
3312 : .extra1 = SYSCTL_ZERO,
3313 : .extra2 = &two,
3314 : },
3315 : #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
3316 : {
3317 : .procname = "binfmt_misc",
3318 : .mode = 0555,
3319 : .child = sysctl_mount_point,
3320 : },
3321 : #endif
3322 : {
3323 : .procname = "pipe-max-size",
3324 : .data = &pipe_max_size,
3325 : .maxlen = sizeof(pipe_max_size),
3326 : .mode = 0644,
3327 : .proc_handler = proc_dopipe_max_size,
3328 : },
3329 : {
3330 : .procname = "pipe-user-pages-hard",
3331 : .data = &pipe_user_pages_hard,
3332 : .maxlen = sizeof(pipe_user_pages_hard),
3333 : .mode = 0644,
3334 : .proc_handler = proc_doulongvec_minmax,
3335 : },
3336 : {
3337 : .procname = "pipe-user-pages-soft",
3338 : .data = &pipe_user_pages_soft,
3339 : .maxlen = sizeof(pipe_user_pages_soft),
3340 : .mode = 0644,
3341 : .proc_handler = proc_doulongvec_minmax,
3342 : },
3343 : {
3344 : .procname = "mount-max",
3345 : .data = &sysctl_mount_max,
3346 : .maxlen = sizeof(unsigned int),
3347 : .mode = 0644,
3348 : .proc_handler = proc_dointvec_minmax,
3349 : .extra1 = SYSCTL_ONE,
3350 : },
3351 : { }
3352 : };
3353 :
3354 : static struct ctl_table debug_table[] = {
3355 : #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
3356 : {
3357 : .procname = "exception-trace",
3358 : .data = &show_unhandled_signals,
3359 : .maxlen = sizeof(int),
3360 : .mode = 0644,
3361 : .proc_handler = proc_dointvec
3362 : },
3363 : #endif
3364 : #if defined(CONFIG_OPTPROBES)
3365 : {
3366 : .procname = "kprobes-optimization",
3367 : .data = &sysctl_kprobes_optimization,
3368 : .maxlen = sizeof(int),
3369 : .mode = 0644,
3370 : .proc_handler = proc_kprobes_optimization_handler,
3371 : .extra1 = SYSCTL_ZERO,
3372 : .extra2 = SYSCTL_ONE,
3373 : },
3374 : #endif
3375 : { }
3376 : };
3377 :
3378 : static struct ctl_table dev_table[] = {
3379 : { }
3380 : };
3381 :
3382 : static struct ctl_table sysctl_base_table[] = {
3383 : {
3384 : .procname = "kernel",
3385 : .mode = 0555,
3386 : .child = kern_table,
3387 : },
3388 : {
3389 : .procname = "vm",
3390 : .mode = 0555,
3391 : .child = vm_table,
3392 : },
3393 : {
3394 : .procname = "fs",
3395 : .mode = 0555,
3396 : .child = fs_table,
3397 : },
3398 : {
3399 : .procname = "debug",
3400 : .mode = 0555,
3401 : .child = debug_table,
3402 : },
3403 : {
3404 : .procname = "dev",
3405 : .mode = 0555,
3406 : .child = dev_table,
3407 : },
3408 : { }
3409 : };
3410 :
3411 1 : int __init sysctl_init(void)
3412 : {
3413 1 : struct ctl_table_header *hdr;
3414 :
3415 1 : hdr = register_sysctl_table(sysctl_base_table);
3416 1 : kmemleak_not_leak(hdr);
3417 1 : return 0;
3418 : }
3419 : #endif /* CONFIG_SYSCTL */
3420 : /*
3421 : * No sense putting this after each symbol definition, twice,
3422 : * exception granted :-)
3423 : */
3424 : EXPORT_SYMBOL(proc_dointvec);
3425 : EXPORT_SYMBOL(proc_douintvec);
3426 : EXPORT_SYMBOL(proc_dointvec_jiffies);
3427 : EXPORT_SYMBOL(proc_dointvec_minmax);
3428 : EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
3429 : EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
3430 : EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
3431 : EXPORT_SYMBOL(proc_dostring);
3432 : EXPORT_SYMBOL(proc_doulongvec_minmax);
3433 : EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
3434 : EXPORT_SYMBOL(proc_do_large_bitmap);
|
