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 static int _proc_do_string(char *data, int maxlen, int write, 245 char *buffer, size_t *lenp, loff_t *ppos) 246 { 247 size_t len; 248 char c, *p; 249 250 if (!data || !maxlen || !*lenp) { 251 *lenp = 0; 252 return 0; 253 } 254 255 if (write) { 256 if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) { 257 /* Only continue writes not past the end of buffer. */ 258 len = strlen(data); 259 if (len > maxlen - 1) 260 len = maxlen - 1; 261 262 if (*ppos > len) 263 return 0; 264 len = *ppos; 265 } else { 266 /* Start writing from beginning of buffer. */ 267 len = 0; 268 } 269 270 *ppos += *lenp; 271 p = buffer; 272 while ((p - buffer) < *lenp && len < maxlen - 1) { 273 c = *(p++); 274 if (c == 0 || c == '\n') 275 break; 276 data[len++] = c; 277 } 278 data[len] = 0; 279 } else { 280 len = strlen(data); 281 if (len > maxlen) 282 len = maxlen; 283 284 if (*ppos > len) { 285 *lenp = 0; 286 return 0; 287 } 288 289 data += *ppos; 290 len -= *ppos; 291 292 if (len > *lenp) 293 len = *lenp; 294 if (len) 295 memcpy(buffer, data, len); 296 if (len < *lenp) { 297 buffer[len] = '\n'; 298 len++; 299 } 300 *lenp = len; 301 *ppos += len; 302 } 303 return 0; 304 } 305 306 static void warn_sysctl_write(struct ctl_table *table) 307 { 308 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 } 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 static bool proc_first_pos_non_zero_ignore(loff_t *ppos, 324 struct ctl_table *table) 325 { 326 if (!*ppos) 327 return false; 328 329 switch (sysctl_writes_strict) { 330 case SYSCTL_WRITES_STRICT: 331 return true; 332 case SYSCTL_WRITES_WARN: 333 warn_sysctl_write(table); 334 return false; 335 default: 336 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 int proc_dostring(struct ctl_table *table, int write, 358 void *buffer, size_t *lenp, loff_t *ppos) 359 { 360 if (write) 361 proc_first_pos_non_zero_ignore(ppos, table); 362 363 return _proc_do_string(table->data, table->maxlen, write, buffer, lenp, 364 ppos); 365 } 366 367 static size_t proc_skip_spaces(char **buf) 368 { 369 size_t ret; 370 char *tmp = skip_spaces(*buf); 371 ret = tmp - *buf; 372 *buf = tmp; 373 return ret; 374 } 375 376 static void proc_skip_char(char **buf, size_t *size, const char v) 377 { 378 while (*size) { 379 if (**buf != v) 380 break; 381 (*size)--; 382 (*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 static int strtoul_lenient(const char *cp, char **endp, unsigned int base, 402 unsigned long *res) 403 { 404 unsigned long long result; 405 unsigned int rv; 406 407 cp = _parse_integer_fixup_radix(cp, &base); 408 rv = _parse_integer(cp, base, &result); 409 if ((rv & KSTRTOX_OVERFLOW) || (result != (unsigned long)result)) 410 return -ERANGE; 411 412 cp += rv; 413 414 if (endp) 415 *endp = (char *)cp; 416 417 *res = (unsigned long)result; 418 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 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 int len; 443 char *p, tmp[TMPBUFLEN]; 444 445 if (!*size) 446 return -EINVAL; 447 448 len = *size; 449 if (len > TMPBUFLEN - 1) 450 len = TMPBUFLEN - 1; 451 452 memcpy(tmp, *buf, len); 453 454 tmp[len] = 0; 455 p = tmp; 456 if (*p == '-' && *size > 1) { 457 *neg = true; 458 p++; 459 } else 460 *neg = false; 461 if (!isdigit(*p)) 462 return -EINVAL; 463 464 if (strtoul_lenient(p, &p, 0, val)) 465 return -EINVAL; 466 467 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 if (len == TMPBUFLEN - 1) 473 return -EINVAL; 474 475 if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len)) 476 return -EINVAL; 477 478 if (tr && (len < *size)) 479 *tr = *p; 480 481 *buf += len; 482 *size -= len; 483 484 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 static void proc_put_long(void **buf, size_t *size, unsigned long val, bool neg) 499 { 500 int len; 501 char tmp[TMPBUFLEN], *p = tmp; 502 503 sprintf(p, "%s%lu", neg ? "-" : "", val); 504 len = strlen(tmp); 505 if (len > *size) 506 len = *size; 507 memcpy(*buf, tmp, len); 508 *size -= len; 509 *buf += len; 510 } 511 #undef TMPBUFLEN 512 513 static void proc_put_char(void **buf, size_t *size, char c) 514 { 515 if (*size) { 516 char **buffer = (char **)buf; 517 **buffer = c; 518 519 (*size)--; 520 (*buffer)++; 521 *buf = *buffer; 522 } 523 } 524 525 static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp, 526 int *valp, 527 int write, void *data) 528 { 529 if (write) { 530 if (*negp) { 531 if (*lvalp > (unsigned long) INT_MAX + 1) 532 return -EINVAL; 533 *valp = -*lvalp; 534 } else { 535 if (*lvalp > (unsigned long) INT_MAX) 536 return -EINVAL; 537 *valp = *lvalp; 538 } 539 } else { 540 int val = *valp; 541 if (val < 0) { 542 *negp = true; 543 *lvalp = -(unsigned long)val; 544 } else { 545 *negp = false; 546 *lvalp = (unsigned long)val; 547 } 548 } 549 return 0; 550 } 551 552 static int do_proc_douintvec_conv(unsigned long *lvalp, 553 unsigned int *valp, 554 int write, void *data) 555 { 556 if (write) { 557 if (*lvalp > UINT_MAX) 558 return -EINVAL; 559 *valp = *lvalp; 560 } else { 561 unsigned int val = *valp; 562 *lvalp = (unsigned long)val; 563 } 564 return 0; 565 } 566 567 static const char proc_wspace_sep[] = { ' ', '\t', '\n' }; 568 569 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 int *i, vleft, first = 1, err = 0; 577 size_t left; 578 char *p; 579 580 if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) { 581 *lenp = 0; 582 return 0; 583 } 584 585 i = (int *) tbl_data; 586 vleft = table->maxlen / sizeof(*i); 587 left = *lenp; 588 589 if (!conv) 590 conv = do_proc_dointvec_conv; 591 592 if (write) { 593 if (proc_first_pos_non_zero_ignore(ppos, table)) 594 goto out; 595 596 if (left > PAGE_SIZE - 1) 597 left = PAGE_SIZE - 1; 598 p = buffer; 599 } 600 601 for (; left && vleft--; i++, first=0) { 602 unsigned long lval; 603 bool neg; 604 605 if (write) { 606 left -= proc_skip_spaces(&p); 607 608 if (!left) 609 break; 610 err = proc_get_long(&p, &left, &lval, &neg, 611 proc_wspace_sep, 612 sizeof(proc_wspace_sep), NULL); 613 if (err) 614 break; 615 if (conv(&neg, &lval, i, 1, data)) { 616 err = -EINVAL; 617 break; 618 } 619 } else { 620 if (conv(&neg, &lval, i, 0, data)) { 621 err = -EINVAL; 622 break; 623 } 624 if (!first) 625 proc_put_char(&buffer, &left, '\t'); 626 proc_put_long(&buffer, &left, lval, neg); 627 } 628 } 629 630 if (!write && !first && left && !err) 631 proc_put_char(&buffer, &left, '\n'); 632 if (write && !err && left) 633 left -= proc_skip_spaces(&p); 634 if (write && first) 635 return err ? : -EINVAL; 636 *lenp -= left; 637 out: 638 *ppos += *lenp; 639 return err; 640 } 641 642 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 return __do_proc_dointvec(table->data, table, write, 649 buffer, lenp, ppos, conv, data); 650 } 651 652 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 unsigned long lval; 662 int err = 0; 663 size_t left; 664 bool neg; 665 char *p = buffer; 666 667 left = *lenp; 668 669 if (proc_first_pos_non_zero_ignore(ppos, table)) 670 goto bail_early; 671 672 if (left > PAGE_SIZE - 1) 673 left = PAGE_SIZE - 1; 674 675 left -= proc_skip_spaces(&p); 676 if (!left) { 677 err = -EINVAL; 678 goto out_free; 679 } 680 681 err = proc_get_long(&p, &left, &lval, &neg, 682 proc_wspace_sep, 683 sizeof(proc_wspace_sep), NULL); 684 if (err || neg) { 685 err = -EINVAL; 686 goto out_free; 687 } 688 689 if (conv(&lval, tbl_data, 1, data)) { 690 err = -EINVAL; 691 goto out_free; 692 } 693 694 if (!err && left) 695 left -= proc_skip_spaces(&p); 696 697 out_free: 698 if (err) 699 return -EINVAL; 700 701 return 0; 702 703 /* This is in keeping with old __do_proc_dointvec() */ 704 bail_early: 705 *ppos += *lenp; 706 return err; 707 } 708 709 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 unsigned long lval; 717 int err = 0; 718 size_t left; 719 720 left = *lenp; 721 722 if (conv(&lval, tbl_data, 0, data)) { 723 err = -EINVAL; 724 goto out; 725 } 726 727 proc_put_long(&buffer, &left, lval, false); 728 if (!left) 729 goto out; 730 731 proc_put_char(&buffer, &left, '\n'); 732 733 out: 734 *lenp -= left; 735 *ppos += *lenp; 736 737 return err; 738 } 739 740 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 unsigned int *i, vleft; 749 750 if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) { 751 *lenp = 0; 752 return 0; 753 } 754 755 i = (unsigned int *) tbl_data; 756 vleft = table->maxlen / sizeof(*i); 757 758 /* 759 * Arrays are not supported, keep this simple. *Do not* add 760 * support for them. 761 */ 762 if (vleft != 1) { 763 *lenp = 0; 764 return -EINVAL; 765 } 766 767 if (!conv) 768 conv = do_proc_douintvec_conv; 769 770 if (write) 771 return do_proc_douintvec_w(i, table, buffer, lenp, ppos, 772 conv, data); 773 return do_proc_douintvec_r(i, buffer, lenp, ppos, conv, data); 774 } 775 776 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 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 int proc_dointvec(struct ctl_table *table, int write, void *buffer, 801 size_t *lenp, loff_t *ppos) 802 { 803 return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL); 804 } 805 806 #ifdef CONFIG_COMPACTION 807 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 int ret, old; 811 812 if (!IS_ENABLED(CONFIG_PREEMPT_RT) || !write) 813 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 int proc_douintvec(struct ctl_table *table, int write, void *buffer, 841 size_t *lenp, loff_t *ppos) 842 { 843 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 static int proc_taint(struct ctl_table *table, int write, 852 void *buffer, size_t *lenp, loff_t *ppos) 853 { 854 struct ctl_table t; 855 unsigned long tmptaint = get_taint(); 856 int err; 857 858 if (write && !capable(CAP_SYS_ADMIN)) 859 return -EPERM; 860 861 t = *table; 862 t.data = &tmptaint; 863 err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos); 864 if (err < 0) 865 return err; 866 867 if (write) { 868 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 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 for (i = 0; i < TAINT_FLAGS_COUNT; i++) 883 if ((1UL << i) & tmptaint) 884 add_taint(i, LOCKDEP_STILL_OK); 885 } 886 887 return err; 888 } 889 890 #ifdef CONFIG_PRINTK 891 static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write, 892 void *buffer, size_t *lenp, loff_t *ppos) 893 { 894 if (write && !capable(CAP_SYS_ADMIN)) 895 return -EPERM; 896 897 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 static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp, 916 int *valp, 917 int write, void *data) 918 { 919 int tmp, ret; 920 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 int *ip = write ? &tmp : valp; 926 927 ret = do_proc_dointvec_conv(negp, lvalp, ip, write, data); 928 if (ret) 929 return ret; 930 931 if (write) { 932 if ((param->min && *param->min > tmp) || 933 (param->max && *param->max < tmp)) 934 return -EINVAL; 935 *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 int proc_dointvec_minmax(struct ctl_table *table, int write, 958 void *buffer, size_t *lenp, loff_t *ppos) 959 { 960 struct do_proc_dointvec_minmax_conv_param param = { 961 .min = (int *) table->extra1, 962 .max = (int *) table->extra2, 963 }; 964 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 static int do_proc_douintvec_minmax_conv(unsigned long *lvalp, 983 unsigned int *valp, 984 int write, void *data) 985 { 986 int ret; 987 unsigned int tmp; 988 struct do_proc_douintvec_minmax_conv_param *param = data; 989 /* write via temporary local uint for bounds-checking */ 990 unsigned int *up = write ? &tmp : valp; 991 992 ret = do_proc_douintvec_conv(lvalp, up, write, data); 993 if (ret) 994 return ret; 995 996 if (write) { 997 if ((param->min && *param->min > tmp) || 998 (param->max && *param->max < tmp)) 999 return -ERANGE; 1000 1001 *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 int proc_douintvec_minmax(struct ctl_table *table, int write, 1027 void *buffer, size_t *lenp, loff_t *ppos) 1028 { 1029 struct do_proc_douintvec_minmax_conv_param param = { 1030 .min = (unsigned int *) table->extra1, 1031 .max = (unsigned int *) table->extra2, 1032 }; 1033 return do_proc_douintvec(table, write, buffer, lenp, ppos, 1034 do_proc_douintvec_minmax_conv, ¶m); 1035 } 1036 1037 static int do_proc_dopipe_max_size_conv(unsigned long *lvalp, 1038 unsigned int *valp, 1039 int write, void *data) 1040 { 1041 if (write) { 1042 unsigned int val; 1043 1044 val = round_pipe_size(*lvalp); 1045 if (val == 0) 1046 return -EINVAL; 1047 1048 *valp = val; 1049 } else { 1050 unsigned int val = *valp; 1051 *lvalp = (unsigned long) val; 1052 } 1053 1054 return 0; 1055 } 1056 1057 static int proc_dopipe_max_size(struct ctl_table *table, int write, 1058 void *buffer, size_t *lenp, loff_t *ppos) 1059 { 1060 return do_proc_douintvec(table, write, buffer, lenp, ppos, 1061 do_proc_dopipe_max_size_conv, NULL); 1062 } 1063 1064 static void validate_coredump_safety(void) 1065 { 1066 #ifdef CONFIG_COREDUMP 1067 if (suid_dumpable == SUID_DUMP_ROOT && 1068 core_pattern[0] != '/' && core_pattern[0] != '|') { 1069 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 } 1077 1078 static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write, 1079 void *buffer, size_t *lenp, loff_t *ppos) 1080 { 1081 int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos); 1082 if (!error) 1083 validate_coredump_safety(); 1084 return error; 1085 } 1086 1087 #ifdef CONFIG_COREDUMP 1088 static int proc_dostring_coredump(struct ctl_table *table, int write, 1089 void *buffer, size_t *lenp, loff_t *ppos) 1090 { 1091 int error = proc_dostring(table, write, buffer, lenp, ppos); 1092 if (!error) 1093 validate_coredump_safety(); 1094 return error; 1095 } 1096 #endif 1097 1098 #ifdef CONFIG_MAGIC_SYSRQ 1099 static int sysrq_sysctl_handler(struct ctl_table *table, int write, 1100 void *buffer, size_t *lenp, loff_t *ppos) 1101 { 1102 int tmp, ret; 1103 1104 tmp = sysrq_mask(); 1105 1106 ret = __do_proc_dointvec(&tmp, table, write, buffer, 1107 lenp, ppos, NULL, NULL); 1108 if (ret || !write) 1109 return ret; 1110 1111 if (write) 1112 sysrq_toggle_support(tmp); 1113 1114 return 0; 1115 } 1116 #endif 1117 1118 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 unsigned long *i, *min, *max; 1123 int vleft, first = 1, err = 0; 1124 size_t left; 1125 char *p; 1126 1127 if (!data || !table->maxlen || !*lenp || (*ppos && !write)) { 1128 *lenp = 0; 1129 return 0; 1130 } 1131 1132 i = (unsigned long *) data; 1133 min = (unsigned long *) table->extra1; 1134 max = (unsigned long *) table->extra2; 1135 vleft = table->maxlen / sizeof(unsigned long); 1136 left = *lenp; 1137 1138 if (write) { 1139 if (proc_first_pos_non_zero_ignore(ppos, table)) 1140 goto out; 1141 1142 if (left > PAGE_SIZE - 1) 1143 left = PAGE_SIZE - 1; 1144 p = buffer; 1145 } 1146 1147 for (; left && vleft--; i++, first = 0) { 1148 unsigned long val; 1149 1150 if (write) { 1151 bool neg; 1152 1153 left -= proc_skip_spaces(&p); 1154 if (!left) 1155 break; 1156 1157 err = proc_get_long(&p, &left, &val, &neg, 1158 proc_wspace_sep, 1159 sizeof(proc_wspace_sep), NULL); 1160 if (err) 1161 break; 1162 if (neg) 1163 continue; 1164 val = convmul * val / convdiv; 1165 if ((min && val < *min) || (max && val > *max)) { 1166 err = -EINVAL; 1167 break; 1168 } 1169 *i = val; 1170 } else { 1171 val = convdiv * (*i) / convmul; 1172 if (!first) 1173 proc_put_char(&buffer, &left, '\t'); 1174 proc_put_long(&buffer, &left, val, false); 1175 } 1176 } 1177 1178 if (!write && !first && left && !err) 1179 proc_put_char(&buffer, &left, '\n'); 1180 if (write && !err) 1181 left -= proc_skip_spaces(&p); 1182 if (write && first) 1183 return err ? : -EINVAL; 1184 *lenp -= left; 1185 out: 1186 *ppos += *lenp; 1187 return err; 1188 } 1189 1190 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 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 int proc_doulongvec_minmax(struct ctl_table *table, int write, 1215 void *buffer, size_t *lenp, loff_t *ppos) 1216 { 1217 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 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, 1238 void *buffer, size_t *lenp, loff_t *ppos) 1239 { 1240 return do_proc_doulongvec_minmax(table, write, buffer, 1241 lenp, ppos, HZ, 1000l); 1242 } 1243 1244 1245 static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp, 1246 int *valp, 1247 int write, void *data) 1248 { 1249 if (write) { 1250 if (*lvalp > INT_MAX / HZ) 1251 return 1; 1252 *valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ); 1253 } else { 1254 int val = *valp; 1255 unsigned long lval; 1256 if (val < 0) { 1257 *negp = true; 1258 lval = -(unsigned long)val; 1259 } else { 1260 *negp = false; 1261 lval = (unsigned long)val; 1262 } 1263 *lvalp = lval / HZ; 1264 } 1265 return 0; 1266 } 1267 1268 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp, 1269 int *valp, 1270 int write, void *data) 1271 { 1272 if (write) { 1273 if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ) 1274 return 1; 1275 *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp); 1276 } else { 1277 int val = *valp; 1278 unsigned long lval; 1279 if (val < 0) { 1280 *negp = true; 1281 lval = -(unsigned long)val; 1282 } else { 1283 *negp = false; 1284 lval = (unsigned long)val; 1285 } 1286 *lvalp = jiffies_to_clock_t(lval); 1287 } 1288 return 0; 1289 } 1290 1291 static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp, 1292 int *valp, 1293 int write, void *data) 1294 { 1295 if (write) { 1296 unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp); 1297 1298 if (jif > INT_MAX) 1299 return 1; 1300 *valp = (int)jif; 1301 } else { 1302 int val = *valp; 1303 unsigned long lval; 1304 if (val < 0) { 1305 *negp = true; 1306 lval = -(unsigned long)val; 1307 } else { 1308 *negp = false; 1309 lval = (unsigned long)val; 1310 } 1311 *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 int proc_dointvec_jiffies(struct ctl_table *table, int write, 1332 void *buffer, size_t *lenp, loff_t *ppos) 1333 { 1334 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 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 1354 void *buffer, size_t *lenp, loff_t *ppos) 1355 { 1356 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 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer, 1377 size_t *lenp, loff_t *ppos) 1378 { 1379 return do_proc_dointvec(table, write, buffer, lenp, ppos, 1380 do_proc_dointvec_ms_jiffies_conv, NULL); 1381 } 1382 1383 static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer, 1384 size_t *lenp, loff_t *ppos) 1385 { 1386 struct pid *new_pid; 1387 pid_t tmp; 1388 int r; 1389 1390 tmp = pid_vnr(cad_pid); 1391 1392 r = __do_proc_dointvec(&tmp, table, write, buffer, 1393 lenp, ppos, NULL, NULL); 1394 if (r || !write) 1395 return r; 1396 1397 new_pid = find_get_pid(tmp); 1398 if (!new_pid) 1399 return -ESRCH; 1400 1401 put_pid(xchg(&cad_pid, new_pid)); 1402 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 int proc_do_large_bitmap(struct ctl_table *table, int write, 1423 void *buffer, size_t *lenp, loff_t *ppos) 1424 { 1425 int err = 0; 1426 bool first = 1; 1427 size_t left = *lenp; 1428 unsigned long bitmap_len = table->maxlen; 1429 unsigned long *bitmap = *(unsigned long **) table->data; 1430 unsigned long *tmp_bitmap = NULL; 1431 char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c; 1432 1433 if (!bitmap || !bitmap_len || !left || (*ppos && !write)) { 1434 *lenp = 0; 1435 return 0; 1436 } 1437 1438 if (write) { 1439 char *p = buffer; 1440 size_t skipped = 0; 1441 1442 if (left > PAGE_SIZE - 1) { 1443 left = PAGE_SIZE - 1; 1444 /* How much of the buffer we'll skip this pass */ 1445 skipped = *lenp - left; 1446 } 1447 1448 tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL); 1449 if (!tmp_bitmap) 1450 return -ENOMEM; 1451 proc_skip_char(&p, &left, '\n'); 1452 while (!err && left) { 1453 unsigned long val_a, val_b; 1454 bool neg; 1455 size_t saved_left; 1456 1457 /* In case we stop parsing mid-number, we can reset */ 1458 saved_left = left; 1459 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 if ((left <= 1) && skipped) { 1467 left = saved_left; 1468 break; 1469 } 1470 1471 if (err) 1472 break; 1473 if (val_a >= bitmap_len || neg) { 1474 err = -EINVAL; 1475 break; 1476 } 1477 1478 val_b = val_a; 1479 if (left) { 1480 p++; 1481 left--; 1482 } 1483 1484 if (c == '-') { 1485 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 if (!left && skipped) { 1493 left = saved_left; 1494 break; 1495 } 1496 1497 if (err) 1498 break; 1499 if (val_b >= bitmap_len || neg || 1500 val_a > val_b) { 1501 err = -EINVAL; 1502 break; 1503 } 1504 if (left) { 1505 p++; 1506 left--; 1507 } 1508 } 1509 1510 bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1); 1511 first = 0; 1512 proc_skip_char(&p, &left, '\n'); 1513 } 1514 left += skipped; 1515 } else { 1516 unsigned long bit_a, bit_b = 0; 1517 1518 while (left) { 1519 bit_a = find_next_bit(bitmap, bitmap_len, bit_b); 1520 if (bit_a >= bitmap_len) 1521 break; 1522 bit_b = find_next_zero_bit(bitmap, bitmap_len, 1523 bit_a + 1) - 1; 1524 1525 if (!first) 1526 proc_put_char(&buffer, &left, ','); 1527 proc_put_long(&buffer, &left, bit_a, false); 1528 if (bit_a != bit_b) { 1529 proc_put_char(&buffer, &left, '-'); 1530 proc_put_long(&buffer, &left, bit_b, false); 1531 } 1532 1533 first = 0; bit_b++; 1534 } 1535 proc_put_char(&buffer, &left, '\n'); 1536 } 1537 1538 if (!err) { 1539 if (write) { 1540 if (*ppos) 1541 bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len); 1542 else 1543 bitmap_copy(bitmap, tmp_bitmap, bitmap_len); 1544 } 1545 *lenp -= left; 1546 *ppos += *lenp; 1547 } 1548 1549 bitmap_free(tmp_bitmap); 1550 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 int proc_do_static_key(struct ctl_table *table, int write, 1625 void *buffer, size_t *lenp, loff_t *ppos) 1626 { 1627 struct static_key *key = (struct static_key *)table->data; 1628 static DEFINE_MUTEX(static_key_mutex); 1629 int val, ret; 1630 struct ctl_table tmp = { 1631 .data = &val, 1632 .maxlen = sizeof(val), 1633 .mode = table->mode, 1634 .extra1 = SYSCTL_ZERO, 1635 .extra2 = SYSCTL_ONE, 1636 }; 1637 1638 if (write && !capable(CAP_SYS_ADMIN)) 1639 return -EPERM; 1640 1641 mutex_lock(&static_key_mutex); 1642 val = static_key_enabled(key); 1643 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 1644 if (write && !ret) { 1645 if (val) 1646 static_key_enable(key); 1647 else 1648 static_key_disable(key); 1649 } 1650 mutex_unlock(&static_key_mutex); 1651 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 #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE 2654 { 2655 .procname = "stack_erasing", 2656 .data = NULL, 2657 .maxlen = sizeof(int), 2658 .mode = 0600, 2659 .proc_handler = stack_erasing_sysctl, 2660 .extra1 = SYSCTL_ZERO, 2661 .extra2 = SYSCTL_ONE, 2662 }, 2663 #endif 2664 { } 2665 }; 2666 2667 static struct ctl_table vm_table[] = { 2668 { 2669 .procname = "overcommit_memory", 2670 .data = &sysctl_overcommit_memory, 2671 .maxlen = sizeof(sysctl_overcommit_memory), 2672 .mode = 0644, 2673 .proc_handler = overcommit_policy_handler, 2674 .extra1 = SYSCTL_ZERO, 2675 .extra2 = &two, 2676 }, 2677 { 2678 .procname = "panic_on_oom", 2679 .data = &sysctl_panic_on_oom, 2680 .maxlen = sizeof(sysctl_panic_on_oom), 2681 .mode = 0644, 2682 .proc_handler = proc_dointvec_minmax, 2683 .extra1 = SYSCTL_ZERO, 2684 .extra2 = &two, 2685 }, 2686 { 2687 .procname = "oom_kill_allocating_task", 2688 .data = &sysctl_oom_kill_allocating_task, 2689 .maxlen = sizeof(sysctl_oom_kill_allocating_task), 2690 .mode = 0644, 2691 .proc_handler = proc_dointvec, 2692 }, 2693 { 2694 .procname = "oom_dump_tasks", 2695 .data = &sysctl_oom_dump_tasks, 2696 .maxlen = sizeof(sysctl_oom_dump_tasks), 2697 .mode = 0644, 2698 .proc_handler = proc_dointvec, 2699 }, 2700 { 2701 .procname = "overcommit_ratio", 2702 .data = &sysctl_overcommit_ratio, 2703 .maxlen = sizeof(sysctl_overcommit_ratio), 2704 .mode = 0644, 2705 .proc_handler = overcommit_ratio_handler, 2706 }, 2707 { 2708 .procname = "overcommit_kbytes", 2709 .data = &sysctl_overcommit_kbytes, 2710 .maxlen = sizeof(sysctl_overcommit_kbytes), 2711 .mode = 0644, 2712 .proc_handler = overcommit_kbytes_handler, 2713 }, 2714 { 2715 .procname = "page-cluster", 2716 .data = &page_cluster, 2717 .maxlen = sizeof(int), 2718 .mode = 0644, 2719 .proc_handler = proc_dointvec_minmax, 2720 .extra1 = SYSCTL_ZERO, 2721 }, 2722 { 2723 .procname = "dirty_background_ratio", 2724 .data = &dirty_background_ratio, 2725 .maxlen = sizeof(dirty_background_ratio), 2726 .mode = 0644, 2727 .proc_handler = dirty_background_ratio_handler, 2728 .extra1 = SYSCTL_ZERO, 2729 .extra2 = &one_hundred, 2730 }, 2731 { 2732 .procname = "dirty_background_bytes", 2733 .data = &dirty_background_bytes, 2734 .maxlen = sizeof(dirty_background_bytes), 2735 .mode = 0644, 2736 .proc_handler = dirty_background_bytes_handler, 2737 .extra1 = &one_ul, 2738 }, 2739 { 2740 .procname = "dirty_ratio", 2741 .data = &vm_dirty_ratio, 2742 .maxlen = sizeof(vm_dirty_ratio), 2743 .mode = 0644, 2744 .proc_handler = dirty_ratio_handler, 2745 .extra1 = SYSCTL_ZERO, 2746 .extra2 = &one_hundred, 2747 }, 2748 { 2749 .procname = "dirty_bytes", 2750 .data = &vm_dirty_bytes, 2751 .maxlen = sizeof(vm_dirty_bytes), 2752 .mode = 0644, 2753 .proc_handler = dirty_bytes_handler, 2754 .extra1 = &dirty_bytes_min, 2755 }, 2756 { 2757 .procname = "dirty_writeback_centisecs", 2758 .data = &dirty_writeback_interval, 2759 .maxlen = sizeof(dirty_writeback_interval), 2760 .mode = 0644, 2761 .proc_handler = dirty_writeback_centisecs_handler, 2762 }, 2763 { 2764 .procname = "dirty_expire_centisecs", 2765 .data = &dirty_expire_interval, 2766 .maxlen = sizeof(dirty_expire_interval), 2767 .mode = 0644, 2768 .proc_handler = proc_dointvec_minmax, 2769 .extra1 = SYSCTL_ZERO, 2770 }, 2771 { 2772 .procname = "dirtytime_expire_seconds", 2773 .data = &dirtytime_expire_interval, 2774 .maxlen = sizeof(dirtytime_expire_interval), 2775 .mode = 0644, 2776 .proc_handler = dirtytime_interval_handler, 2777 .extra1 = SYSCTL_ZERO, 2778 }, 2779 { 2780 .procname = "swappiness", 2781 .data = &vm_swappiness, 2782 .maxlen = sizeof(vm_swappiness), 2783 .mode = 0644, 2784 .proc_handler = proc_dointvec_minmax, 2785 .extra1 = SYSCTL_ZERO, 2786 .extra2 = &two_hundred, 2787 }, 2788 #ifdef CONFIG_HUGETLB_PAGE 2789 { 2790 .procname = "nr_hugepages", 2791 .data = NULL, 2792 .maxlen = sizeof(unsigned long), 2793 .mode = 0644, 2794 .proc_handler = hugetlb_sysctl_handler, 2795 }, 2796 #ifdef CONFIG_NUMA 2797 { 2798 .procname = "nr_hugepages_mempolicy", 2799 .data = NULL, 2800 .maxlen = sizeof(unsigned long), 2801 .mode = 0644, 2802 .proc_handler = &hugetlb_mempolicy_sysctl_handler, 2803 }, 2804 { 2805 .procname = "numa_stat", 2806 .data = &sysctl_vm_numa_stat, 2807 .maxlen = sizeof(int), 2808 .mode = 0644, 2809 .proc_handler = sysctl_vm_numa_stat_handler, 2810 .extra1 = SYSCTL_ZERO, 2811 .extra2 = SYSCTL_ONE, 2812 }, 2813 #endif 2814 { 2815 .procname = "hugetlb_shm_group", 2816 .data = &sysctl_hugetlb_shm_group, 2817 .maxlen = sizeof(gid_t), 2818 .mode = 0644, 2819 .proc_handler = proc_dointvec, 2820 }, 2821 { 2822 .procname = "nr_overcommit_hugepages", 2823 .data = NULL, 2824 .maxlen = sizeof(unsigned long), 2825 .mode = 0644, 2826 .proc_handler = hugetlb_overcommit_handler, 2827 }, 2828 #endif 2829 { 2830 .procname = "lowmem_reserve_ratio", 2831 .data = &sysctl_lowmem_reserve_ratio, 2832 .maxlen = sizeof(sysctl_lowmem_reserve_ratio), 2833 .mode = 0644, 2834 .proc_handler = lowmem_reserve_ratio_sysctl_handler, 2835 }, 2836 { 2837 .procname = "drop_caches", 2838 .data = &sysctl_drop_caches, 2839 .maxlen = sizeof(int), 2840 .mode = 0200, 2841 .proc_handler = drop_caches_sysctl_handler, 2842 .extra1 = SYSCTL_ONE, 2843 .extra2 = &four, 2844 }, 2845 #ifdef CONFIG_COMPACTION 2846 { 2847 .procname = "compact_memory", 2848 .data = &sysctl_compact_memory, 2849 .maxlen = sizeof(int), 2850 .mode = 0200, 2851 .proc_handler = sysctl_compaction_handler, 2852 }, 2853 { 2854 .procname = "compaction_proactiveness", 2855 .data = &sysctl_compaction_proactiveness, 2856 .maxlen = sizeof(sysctl_compaction_proactiveness), 2857 .mode = 0644, 2858 .proc_handler = proc_dointvec_minmax, 2859 .extra1 = SYSCTL_ZERO, 2860 .extra2 = &one_hundred, 2861 }, 2862 { 2863 .procname = "extfrag_threshold", 2864 .data = &sysctl_extfrag_threshold, 2865 .maxlen = sizeof(int), 2866 .mode = 0644, 2867 .proc_handler = proc_dointvec_minmax, 2868 .extra1 = &min_extfrag_threshold, 2869 .extra2 = &max_extfrag_threshold, 2870 }, 2871 { 2872 .procname = "compact_unevictable_allowed", 2873 .data = &sysctl_compact_unevictable_allowed, 2874 .maxlen = sizeof(int), 2875 .mode = 0644, 2876 .proc_handler = proc_dointvec_minmax_warn_RT_change, 2877 .extra1 = SYSCTL_ZERO, 2878 .extra2 = SYSCTL_ONE, 2879 }, 2880 2881 #endif /* CONFIG_COMPACTION */ 2882 { 2883 .procname = "min_free_kbytes", 2884 .data = &min_free_kbytes, 2885 .maxlen = sizeof(min_free_kbytes), 2886 .mode = 0644, 2887 .proc_handler = min_free_kbytes_sysctl_handler, 2888 .extra1 = SYSCTL_ZERO, 2889 }, 2890 { 2891 .procname = "watermark_boost_factor", 2892 .data = &watermark_boost_factor, 2893 .maxlen = sizeof(watermark_boost_factor), 2894 .mode = 0644, 2895 .proc_handler = proc_dointvec_minmax, 2896 .extra1 = SYSCTL_ZERO, 2897 }, 2898 { 2899 .procname = "watermark_scale_factor", 2900 .data = &watermark_scale_factor, 2901 .maxlen = sizeof(watermark_scale_factor), 2902 .mode = 0644, 2903 .proc_handler = watermark_scale_factor_sysctl_handler, 2904 .extra1 = SYSCTL_ONE, 2905 .extra2 = &one_thousand, 2906 }, 2907 { 2908 .procname = "percpu_pagelist_fraction", 2909 .data = &percpu_pagelist_fraction, 2910 .maxlen = sizeof(percpu_pagelist_fraction), 2911 .mode = 0644, 2912 .proc_handler = percpu_pagelist_fraction_sysctl_handler, 2913 .extra1 = SYSCTL_ZERO, 2914 }, 2915 #ifdef CONFIG_MMU 2916 { 2917 .procname = "max_map_count", 2918 .data = &sysctl_max_map_count, 2919 .maxlen = sizeof(sysctl_max_map_count), 2920 .mode = 0644, 2921 .proc_handler = proc_dointvec_minmax, 2922 .extra1 = SYSCTL_ZERO, 2923 }, 2924 #else 2925 { 2926 .procname = "nr_trim_pages", 2927 .data = &sysctl_nr_trim_pages, 2928 .maxlen = sizeof(sysctl_nr_trim_pages), 2929 .mode = 0644, 2930 .proc_handler = proc_dointvec_minmax, 2931 .extra1 = SYSCTL_ZERO, 2932 }, 2933 #endif 2934 { 2935 .procname = "laptop_mode", 2936 .data = &laptop_mode, 2937 .maxlen = sizeof(laptop_mode), 2938 .mode = 0644, 2939 .proc_handler = proc_dointvec_jiffies, 2940 }, 2941 { 2942 .procname = "block_dump", 2943 .data = &block_dump, 2944 .maxlen = sizeof(block_dump), 2945 .mode = 0644, 2946 .proc_handler = proc_dointvec, 2947 .extra1 = SYSCTL_ZERO, 2948 }, 2949 { 2950 .procname = "vfs_cache_pressure", 2951 .data = &sysctl_vfs_cache_pressure, 2952 .maxlen = sizeof(sysctl_vfs_cache_pressure), 2953 .mode = 0644, 2954 .proc_handler = proc_dointvec, 2955 .extra1 = SYSCTL_ZERO, 2956 }, 2957 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \ 2958 defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT) 2959 { 2960 .procname = "legacy_va_layout", 2961 .data = &sysctl_legacy_va_layout, 2962 .maxlen = sizeof(sysctl_legacy_va_layout), 2963 .mode = 0644, 2964 .proc_handler = proc_dointvec, 2965 .extra1 = SYSCTL_ZERO, 2966 }, 2967 #endif 2968 #ifdef CONFIG_NUMA 2969 { 2970 .procname = "zone_reclaim_mode", 2971 .data = &node_reclaim_mode, 2972 .maxlen = sizeof(node_reclaim_mode), 2973 .mode = 0644, 2974 .proc_handler = proc_dointvec, 2975 .extra1 = SYSCTL_ZERO, 2976 }, 2977 { 2978 .procname = "min_unmapped_ratio", 2979 .data = &sysctl_min_unmapped_ratio, 2980 .maxlen = sizeof(sysctl_min_unmapped_ratio), 2981 .mode = 0644, 2982 .proc_handler = sysctl_min_unmapped_ratio_sysctl_handler, 2983 .extra1 = SYSCTL_ZERO, 2984 .extra2 = &one_hundred, 2985 }, 2986 { 2987 .procname = "min_slab_ratio", 2988 .data = &sysctl_min_slab_ratio, 2989 .maxlen = sizeof(sysctl_min_slab_ratio), 2990 .mode = 0644, 2991 .proc_handler = sysctl_min_slab_ratio_sysctl_handler, 2992 .extra1 = SYSCTL_ZERO, 2993 .extra2 = &one_hundred, 2994 }, 2995 #endif 2996 #ifdef CONFIG_SMP 2997 { 2998 .procname = "stat_interval", 2999 .data = &sysctl_stat_interval, 3000 .maxlen = sizeof(sysctl_stat_interval), 3001 .mode = 0644, 3002 .proc_handler = proc_dointvec_jiffies, 3003 }, 3004 { 3005 .procname = "stat_refresh", 3006 .data = NULL, 3007 .maxlen = 0, 3008 .mode = 0600, 3009 .proc_handler = vmstat_refresh, 3010 }, 3011 #endif 3012 #ifdef CONFIG_MMU 3013 { 3014 .procname = "mmap_min_addr", 3015 .data = &dac_mmap_min_addr, 3016 .maxlen = sizeof(unsigned long), 3017 .mode = 0644, 3018 .proc_handler = mmap_min_addr_handler, 3019 }, 3020 #endif 3021 #ifdef CONFIG_NUMA 3022 { 3023 .procname = "numa_zonelist_order", 3024 .data = &numa_zonelist_order, 3025 .maxlen = NUMA_ZONELIST_ORDER_LEN, 3026 .mode = 0644, 3027 .proc_handler = numa_zonelist_order_handler, 3028 }, 3029 #endif 3030 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \ 3031 (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL)) 3032 { 3033 .procname = "vdso_enabled", 3034 #ifdef CONFIG_X86_32 3035 .data = &vdso32_enabled, 3036 .maxlen = sizeof(vdso32_enabled), 3037 #else 3038 .data = &vdso_enabled, 3039 .maxlen = sizeof(vdso_enabled), 3040 #endif 3041 .mode = 0644, 3042 .proc_handler = proc_dointvec, 3043 .extra1 = SYSCTL_ZERO, 3044 }, 3045 #endif 3046 #ifdef CONFIG_HIGHMEM 3047 { 3048 .procname = "highmem_is_dirtyable", 3049 .data = &vm_highmem_is_dirtyable, 3050 .maxlen = sizeof(vm_highmem_is_dirtyable), 3051 .mode = 0644, 3052 .proc_handler = proc_dointvec_minmax, 3053 .extra1 = SYSCTL_ZERO, 3054 .extra2 = SYSCTL_ONE, 3055 }, 3056 #endif 3057 #ifdef CONFIG_MEMORY_FAILURE 3058 { 3059 .procname = "memory_failure_early_kill", 3060 .data = &sysctl_memory_failure_early_kill, 3061 .maxlen = sizeof(sysctl_memory_failure_early_kill), 3062 .mode = 0644, 3063 .proc_handler = proc_dointvec_minmax, 3064 .extra1 = SYSCTL_ZERO, 3065 .extra2 = SYSCTL_ONE, 3066 }, 3067 { 3068 .procname = "memory_failure_recovery", 3069 .data = &sysctl_memory_failure_recovery, 3070 .maxlen = sizeof(sysctl_memory_failure_recovery), 3071 .mode = 0644, 3072 .proc_handler = proc_dointvec_minmax, 3073 .extra1 = SYSCTL_ZERO, 3074 .extra2 = SYSCTL_ONE, 3075 }, 3076 #endif 3077 { 3078 .procname = "user_reserve_kbytes", 3079 .data = &sysctl_user_reserve_kbytes, 3080 .maxlen = sizeof(sysctl_user_reserve_kbytes), 3081 .mode = 0644, 3082 .proc_handler = proc_doulongvec_minmax, 3083 }, 3084 { 3085 .procname = "admin_reserve_kbytes", 3086 .data = &sysctl_admin_reserve_kbytes, 3087 .maxlen = sizeof(sysctl_admin_reserve_kbytes), 3088 .mode = 0644, 3089 .proc_handler = proc_doulongvec_minmax, 3090 }, 3091 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS 3092 { 3093 .procname = "mmap_rnd_bits", 3094 .data = &mmap_rnd_bits, 3095 .maxlen = sizeof(mmap_rnd_bits), 3096 .mode = 0600, 3097 .proc_handler = proc_dointvec_minmax, 3098 .extra1 = (void *)&mmap_rnd_bits_min, 3099 .extra2 = (void *)&mmap_rnd_bits_max, 3100 }, 3101 #endif 3102 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS 3103 { 3104 .procname = "mmap_rnd_compat_bits", 3105 .data = &mmap_rnd_compat_bits, 3106 .maxlen = sizeof(mmap_rnd_compat_bits), 3107 .mode = 0600, 3108 .proc_handler = proc_dointvec_minmax, 3109 .extra1 = (void *)&mmap_rnd_compat_bits_min, 3110 .extra2 = (void *)&mmap_rnd_compat_bits_max, 3111 }, 3112 #endif 3113 #ifdef CONFIG_USERFAULTFD 3114 { 3115 .procname = "unprivileged_userfaultfd", 3116 .data = &sysctl_unprivileged_userfaultfd, 3117 .maxlen = sizeof(sysctl_unprivileged_userfaultfd), 3118 .mode = 0644, 3119 .proc_handler = proc_dointvec_minmax, 3120 .extra1 = SYSCTL_ZERO, 3121 .extra2 = SYSCTL_ONE, 3122 }, 3123 #endif 3124 { } 3125 }; 3126 3127 static struct ctl_table fs_table[] = { 3128 { 3129 .procname = "inode-nr", 3130 .data = &inodes_stat, 3131 .maxlen = 2*sizeof(long), 3132 .mode = 0444, 3133 .proc_handler = proc_nr_inodes, 3134 }, 3135 { 3136 .procname = "inode-state", 3137 .data = &inodes_stat, 3138 .maxlen = 7*sizeof(long), 3139 .mode = 0444, 3140 .proc_handler = proc_nr_inodes, 3141 }, 3142 { 3143 .procname = "file-nr", 3144 .data = &files_stat, 3145 .maxlen = sizeof(files_stat), 3146 .mode = 0444, 3147 .proc_handler = proc_nr_files, 3148 }, 3149 { 3150 .procname = "file-max", 3151 .data = &files_stat.max_files, 3152 .maxlen = sizeof(files_stat.max_files), 3153 .mode = 0644, 3154 .proc_handler = proc_doulongvec_minmax, 3155 .extra1 = &zero_ul, 3156 .extra2 = &long_max, 3157 }, 3158 { 3159 .procname = "nr_open", 3160 .data = &sysctl_nr_open, 3161 .maxlen = sizeof(unsigned int), 3162 .mode = 0644, 3163 .proc_handler = proc_dointvec_minmax, 3164 .extra1 = &sysctl_nr_open_min, 3165 .extra2 = &sysctl_nr_open_max, 3166 }, 3167 { 3168 .procname = "dentry-state", 3169 .data = &dentry_stat, 3170 .maxlen = 6*sizeof(long), 3171 .mode = 0444, 3172 .proc_handler = proc_nr_dentry, 3173 }, 3174 { 3175 .procname = "overflowuid", 3176 .data = &fs_overflowuid, 3177 .maxlen = sizeof(int), 3178 .mode = 0644, 3179 .proc_handler = proc_dointvec_minmax, 3180 .extra1 = &minolduid, 3181 .extra2 = &maxolduid, 3182 }, 3183 { 3184 .procname = "overflowgid", 3185 .data = &fs_overflowgid, 3186 .maxlen = sizeof(int), 3187 .mode = 0644, 3188 .proc_handler = proc_dointvec_minmax, 3189 .extra1 = &minolduid, 3190 .extra2 = &maxolduid, 3191 }, 3192 #ifdef CONFIG_FILE_LOCKING 3193 { 3194 .procname = "leases-enable", 3195 .data = &leases_enable, 3196 .maxlen = sizeof(int), 3197 .mode = 0644, 3198 .proc_handler = proc_dointvec, 3199 }, 3200 #endif 3201 #ifdef CONFIG_DNOTIFY 3202 { 3203 .procname = "dir-notify-enable", 3204 .data = &dir_notify_enable, 3205 .maxlen = sizeof(int), 3206 .mode = 0644, 3207 .proc_handler = proc_dointvec, 3208 }, 3209 #endif 3210 #ifdef CONFIG_MMU 3211 #ifdef CONFIG_FILE_LOCKING 3212 { 3213 .procname = "lease-break-time", 3214 .data = &lease_break_time, 3215 .maxlen = sizeof(int), 3216 .mode = 0644, 3217 .proc_handler = proc_dointvec, 3218 }, 3219 #endif 3220 #ifdef CONFIG_AIO 3221 { 3222 .procname = "aio-nr", 3223 .data = &aio_nr, 3224 .maxlen = sizeof(aio_nr), 3225 .mode = 0444, 3226 .proc_handler = proc_doulongvec_minmax, 3227 }, 3228 { 3229 .procname = "aio-max-nr", 3230 .data = &aio_max_nr, 3231 .maxlen = sizeof(aio_max_nr), 3232 .mode = 0644, 3233 .proc_handler = proc_doulongvec_minmax, 3234 }, 3235 #endif /* CONFIG_AIO */ 3236 #ifdef CONFIG_INOTIFY_USER 3237 { 3238 .procname = "inotify", 3239 .mode = 0555, 3240 .child = inotify_table, 3241 }, 3242 #endif 3243 #ifdef CONFIG_EPOLL 3244 { 3245 .procname = "epoll", 3246 .mode = 0555, 3247 .child = epoll_table, 3248 }, 3249 #endif 3250 #endif 3251 { 3252 .procname = "protected_symlinks", 3253 .data = &sysctl_protected_symlinks, 3254 .maxlen = sizeof(int), 3255 .mode = 0600, 3256 .proc_handler = proc_dointvec_minmax, 3257 .extra1 = SYSCTL_ZERO, 3258 .extra2 = SYSCTL_ONE, 3259 }, 3260 { 3261 .procname = "protected_hardlinks", 3262 .data = &sysctl_protected_hardlinks, 3263 .maxlen = sizeof(int), 3264 .mode = 0600, 3265 .proc_handler = proc_dointvec_minmax, 3266 .extra1 = SYSCTL_ZERO, 3267 .extra2 = SYSCTL_ONE, 3268 }, 3269 { 3270 .procname = "protected_fifos", 3271 .data = &sysctl_protected_fifos, 3272 .maxlen = sizeof(int), 3273 .mode = 0600, 3274 .proc_handler = proc_dointvec_minmax, 3275 .extra1 = SYSCTL_ZERO, 3276 .extra2 = &two, 3277 }, 3278 { 3279 .procname = "protected_regular", 3280 .data = &sysctl_protected_regular, 3281 .maxlen = sizeof(int), 3282 .mode = 0600, 3283 .proc_handler = proc_dointvec_minmax, 3284 .extra1 = SYSCTL_ZERO, 3285 .extra2 = &two, 3286 }, 3287 { 3288 .procname = "suid_dumpable", 3289 .data = &suid_dumpable, 3290 .maxlen = sizeof(int), 3291 .mode = 0644, 3292 .proc_handler = proc_dointvec_minmax_coredump, 3293 .extra1 = SYSCTL_ZERO, 3294 .extra2 = &two, 3295 }, 3296 #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE) 3297 { 3298 .procname = "binfmt_misc", 3299 .mode = 0555, 3300 .child = sysctl_mount_point, 3301 }, 3302 #endif 3303 { 3304 .procname = "pipe-max-size", 3305 .data = &pipe_max_size, 3306 .maxlen = sizeof(pipe_max_size), 3307 .mode = 0644, 3308 .proc_handler = proc_dopipe_max_size, 3309 }, 3310 { 3311 .procname = "pipe-user-pages-hard", 3312 .data = &pipe_user_pages_hard, 3313 .maxlen = sizeof(pipe_user_pages_hard), 3314 .mode = 0644, 3315 .proc_handler = proc_doulongvec_minmax, 3316 }, 3317 { 3318 .procname = "pipe-user-pages-soft", 3319 .data = &pipe_user_pages_soft, 3320 .maxlen = sizeof(pipe_user_pages_soft), 3321 .mode = 0644, 3322 .proc_handler = proc_doulongvec_minmax, 3323 }, 3324 { 3325 .procname = "mount-max", 3326 .data = &sysctl_mount_max, 3327 .maxlen = sizeof(unsigned int), 3328 .mode = 0644, 3329 .proc_handler = proc_dointvec_minmax, 3330 .extra1 = SYSCTL_ONE, 3331 }, 3332 { } 3333 }; 3334 3335 static struct ctl_table debug_table[] = { 3336 #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE 3337 { 3338 .procname = "exception-trace", 3339 .data = &show_unhandled_signals, 3340 .maxlen = sizeof(int), 3341 .mode = 0644, 3342 .proc_handler = proc_dointvec 3343 }, 3344 #endif 3345 #if defined(CONFIG_OPTPROBES) 3346 { 3347 .procname = "kprobes-optimization", 3348 .data = &sysctl_kprobes_optimization, 3349 .maxlen = sizeof(int), 3350 .mode = 0644, 3351 .proc_handler = proc_kprobes_optimization_handler, 3352 .extra1 = SYSCTL_ZERO, 3353 .extra2 = SYSCTL_ONE, 3354 }, 3355 #endif 3356 { } 3357 }; 3358 3359 static struct ctl_table dev_table[] = { 3360 { } 3361 }; 3362 3363 static struct ctl_table sysctl_base_table[] = { 3364 { 3365 .procname = "kernel", 3366 .mode = 0555, 3367 .child = kern_table, 3368 }, 3369 { 3370 .procname = "vm", 3371 .mode = 0555, 3372 .child = vm_table, 3373 }, 3374 { 3375 .procname = "fs", 3376 .mode = 0555, 3377 .child = fs_table, 3378 }, 3379 { 3380 .procname = "debug", 3381 .mode = 0555, 3382 .child = debug_table, 3383 }, 3384 { 3385 .procname = "dev", 3386 .mode = 0555, 3387 .child = dev_table, 3388 }, 3389 { } 3390 }; 3391 3392 int __init sysctl_init(void) 3393 { 3394 struct ctl_table_header *hdr; 3395 3396 hdr = register_sysctl_table(sysctl_base_table); 3397 kmemleak_not_leak(hdr); 3398 return 0; 3399 } 3400 #endif /* CONFIG_SYSCTL */ 3401 /* 3402 * No sense putting this after each symbol definition, twice, 3403 * exception granted :-) 3404 */ 3405 EXPORT_SYMBOL(proc_dointvec); 3406 EXPORT_SYMBOL(proc_douintvec); 3407 EXPORT_SYMBOL(proc_dointvec_jiffies); 3408 EXPORT_SYMBOL(proc_dointvec_minmax); 3409 EXPORT_SYMBOL_GPL(proc_douintvec_minmax); 3410 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies); 3411 EXPORT_SYMBOL(proc_dointvec_ms_jiffies); 3412 EXPORT_SYMBOL(proc_dostring); 3413 EXPORT_SYMBOL(proc_doulongvec_minmax); 3414 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax); 3415 EXPORT_SYMBOL(proc_do_large_bitmap); 3416