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