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