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 WRITE_ONCE(*valp, -*lvalp); 450 } else { 451 if (*lvalp > (unsigned long) INT_MAX) 452 return -EINVAL; 453 WRITE_ONCE(*valp, *lvalp); 454 } 455 } else { 456 int val = READ_ONCE(*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 WRITE_ONCE(*valp, *lvalp); 476 } else { 477 unsigned int val = READ_ONCE(*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 WRITE_ONCE(*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 WRITE_ONCE(*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 = READ_ONCE(*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 WRITE_ONCE(*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 WRITE_ONCE(*i, val); 1094 } else { 1095 val = convdiv * READ_ONCE(*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 if (*negp) 1177 WRITE_ONCE(*valp, -*lvalp * HZ); 1178 else 1179 WRITE_ONCE(*valp, *lvalp * HZ); 1180 } else { 1181 int val = READ_ONCE(*valp); 1182 unsigned long lval; 1183 if (val < 0) { 1184 *negp = true; 1185 lval = -(unsigned long)val; 1186 } else { 1187 *negp = false; 1188 lval = (unsigned long)val; 1189 } 1190 *lvalp = lval / HZ; 1191 } 1192 return 0; 1193 } 1194 1195 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp, 1196 int *valp, 1197 int write, void *data) 1198 { 1199 if (write) { 1200 if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ) 1201 return 1; 1202 *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp); 1203 } else { 1204 int val = *valp; 1205 unsigned long lval; 1206 if (val < 0) { 1207 *negp = true; 1208 lval = -(unsigned long)val; 1209 } else { 1210 *negp = false; 1211 lval = (unsigned long)val; 1212 } 1213 *lvalp = jiffies_to_clock_t(lval); 1214 } 1215 return 0; 1216 } 1217 1218 static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp, 1219 int *valp, 1220 int write, void *data) 1221 { 1222 if (write) { 1223 unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp); 1224 1225 if (jif > INT_MAX) 1226 return 1; 1227 WRITE_ONCE(*valp, (int)jif); 1228 } else { 1229 int val = READ_ONCE(*valp); 1230 unsigned long lval; 1231 if (val < 0) { 1232 *negp = true; 1233 lval = -(unsigned long)val; 1234 } else { 1235 *negp = false; 1236 lval = (unsigned long)val; 1237 } 1238 *lvalp = jiffies_to_msecs(lval); 1239 } 1240 return 0; 1241 } 1242 1243 static int do_proc_dointvec_ms_jiffies_minmax_conv(bool *negp, unsigned long *lvalp, 1244 int *valp, int write, void *data) 1245 { 1246 int tmp, ret; 1247 struct do_proc_dointvec_minmax_conv_param *param = data; 1248 /* 1249 * If writing, first do so via a temporary local int so we can 1250 * bounds-check it before touching *valp. 1251 */ 1252 int *ip = write ? &tmp : valp; 1253 1254 ret = do_proc_dointvec_ms_jiffies_conv(negp, lvalp, ip, write, data); 1255 if (ret) 1256 return ret; 1257 1258 if (write) { 1259 if ((param->min && *param->min > tmp) || 1260 (param->max && *param->max < tmp)) 1261 return -EINVAL; 1262 *valp = tmp; 1263 } 1264 return 0; 1265 } 1266 1267 /** 1268 * proc_dointvec_jiffies - read a vector of integers as seconds 1269 * @table: the sysctl table 1270 * @write: %TRUE if this is a write to the sysctl file 1271 * @buffer: the user buffer 1272 * @lenp: the size of the user buffer 1273 * @ppos: file position 1274 * 1275 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 1276 * values from/to the user buffer, treated as an ASCII string. 1277 * The values read are assumed to be in seconds, and are converted into 1278 * jiffies. 1279 * 1280 * Returns 0 on success. 1281 */ 1282 int proc_dointvec_jiffies(struct ctl_table *table, int write, 1283 void *buffer, size_t *lenp, loff_t *ppos) 1284 { 1285 return do_proc_dointvec(table,write,buffer,lenp,ppos, 1286 do_proc_dointvec_jiffies_conv,NULL); 1287 } 1288 1289 int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write, 1290 void *buffer, size_t *lenp, loff_t *ppos) 1291 { 1292 struct do_proc_dointvec_minmax_conv_param param = { 1293 .min = (int *) table->extra1, 1294 .max = (int *) table->extra2, 1295 }; 1296 return do_proc_dointvec(table, write, buffer, lenp, ppos, 1297 do_proc_dointvec_ms_jiffies_minmax_conv, ¶m); 1298 } 1299 1300 /** 1301 * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds 1302 * @table: the sysctl table 1303 * @write: %TRUE if this is a write to the sysctl file 1304 * @buffer: the user buffer 1305 * @lenp: the size of the user buffer 1306 * @ppos: pointer to the file position 1307 * 1308 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 1309 * values from/to the user buffer, treated as an ASCII string. 1310 * The values read are assumed to be in 1/USER_HZ seconds, and 1311 * are converted into jiffies. 1312 * 1313 * Returns 0 on success. 1314 */ 1315 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 1316 void *buffer, size_t *lenp, loff_t *ppos) 1317 { 1318 return do_proc_dointvec(table, write, buffer, lenp, ppos, 1319 do_proc_dointvec_userhz_jiffies_conv, NULL); 1320 } 1321 1322 /** 1323 * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds 1324 * @table: the sysctl table 1325 * @write: %TRUE if this is a write to the sysctl file 1326 * @buffer: the user buffer 1327 * @lenp: the size of the user buffer 1328 * @ppos: file position 1329 * @ppos: the current position in the file 1330 * 1331 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 1332 * values from/to the user buffer, treated as an ASCII string. 1333 * The values read are assumed to be in 1/1000 seconds, and 1334 * are converted into jiffies. 1335 * 1336 * Returns 0 on success. 1337 */ 1338 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer, 1339 size_t *lenp, loff_t *ppos) 1340 { 1341 return do_proc_dointvec(table, write, buffer, lenp, ppos, 1342 do_proc_dointvec_ms_jiffies_conv, NULL); 1343 } 1344 1345 static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer, 1346 size_t *lenp, loff_t *ppos) 1347 { 1348 struct pid *new_pid; 1349 pid_t tmp; 1350 int r; 1351 1352 tmp = pid_vnr(cad_pid); 1353 1354 r = __do_proc_dointvec(&tmp, table, write, buffer, 1355 lenp, ppos, NULL, NULL); 1356 if (r || !write) 1357 return r; 1358 1359 new_pid = find_get_pid(tmp); 1360 if (!new_pid) 1361 return -ESRCH; 1362 1363 put_pid(xchg(&cad_pid, new_pid)); 1364 return 0; 1365 } 1366 1367 /** 1368 * proc_do_large_bitmap - read/write from/to a large bitmap 1369 * @table: the sysctl table 1370 * @write: %TRUE if this is a write to the sysctl file 1371 * @buffer: the user buffer 1372 * @lenp: the size of the user buffer 1373 * @ppos: file position 1374 * 1375 * The bitmap is stored at table->data and the bitmap length (in bits) 1376 * in table->maxlen. 1377 * 1378 * We use a range comma separated format (e.g. 1,3-4,10-10) so that 1379 * large bitmaps may be represented in a compact manner. Writing into 1380 * the file will clear the bitmap then update it with the given input. 1381 * 1382 * Returns 0 on success. 1383 */ 1384 int proc_do_large_bitmap(struct ctl_table *table, int write, 1385 void *buffer, size_t *lenp, loff_t *ppos) 1386 { 1387 int err = 0; 1388 size_t left = *lenp; 1389 unsigned long bitmap_len = table->maxlen; 1390 unsigned long *bitmap = *(unsigned long **) table->data; 1391 unsigned long *tmp_bitmap = NULL; 1392 char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c; 1393 1394 if (!bitmap || !bitmap_len || !left || (*ppos && !write)) { 1395 *lenp = 0; 1396 return 0; 1397 } 1398 1399 if (write) { 1400 char *p = buffer; 1401 size_t skipped = 0; 1402 1403 if (left > PAGE_SIZE - 1) { 1404 left = PAGE_SIZE - 1; 1405 /* How much of the buffer we'll skip this pass */ 1406 skipped = *lenp - left; 1407 } 1408 1409 tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL); 1410 if (!tmp_bitmap) 1411 return -ENOMEM; 1412 proc_skip_char(&p, &left, '\n'); 1413 while (!err && left) { 1414 unsigned long val_a, val_b; 1415 bool neg; 1416 size_t saved_left; 1417 1418 /* In case we stop parsing mid-number, we can reset */ 1419 saved_left = left; 1420 err = proc_get_long(&p, &left, &val_a, &neg, tr_a, 1421 sizeof(tr_a), &c); 1422 /* 1423 * If we consumed the entirety of a truncated buffer or 1424 * only one char is left (may be a "-"), then stop here, 1425 * reset, & come back for more. 1426 */ 1427 if ((left <= 1) && skipped) { 1428 left = saved_left; 1429 break; 1430 } 1431 1432 if (err) 1433 break; 1434 if (val_a >= bitmap_len || neg) { 1435 err = -EINVAL; 1436 break; 1437 } 1438 1439 val_b = val_a; 1440 if (left) { 1441 p++; 1442 left--; 1443 } 1444 1445 if (c == '-') { 1446 err = proc_get_long(&p, &left, &val_b, 1447 &neg, tr_b, sizeof(tr_b), 1448 &c); 1449 /* 1450 * If we consumed all of a truncated buffer or 1451 * then stop here, reset, & come back for more. 1452 */ 1453 if (!left && skipped) { 1454 left = saved_left; 1455 break; 1456 } 1457 1458 if (err) 1459 break; 1460 if (val_b >= bitmap_len || neg || 1461 val_a > val_b) { 1462 err = -EINVAL; 1463 break; 1464 } 1465 if (left) { 1466 p++; 1467 left--; 1468 } 1469 } 1470 1471 bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1); 1472 proc_skip_char(&p, &left, '\n'); 1473 } 1474 left += skipped; 1475 } else { 1476 unsigned long bit_a, bit_b = 0; 1477 bool first = 1; 1478 1479 while (left) { 1480 bit_a = find_next_bit(bitmap, bitmap_len, bit_b); 1481 if (bit_a >= bitmap_len) 1482 break; 1483 bit_b = find_next_zero_bit(bitmap, bitmap_len, 1484 bit_a + 1) - 1; 1485 1486 if (!first) 1487 proc_put_char(&buffer, &left, ','); 1488 proc_put_long(&buffer, &left, bit_a, false); 1489 if (bit_a != bit_b) { 1490 proc_put_char(&buffer, &left, '-'); 1491 proc_put_long(&buffer, &left, bit_b, false); 1492 } 1493 1494 first = 0; bit_b++; 1495 } 1496 proc_put_char(&buffer, &left, '\n'); 1497 } 1498 1499 if (!err) { 1500 if (write) { 1501 if (*ppos) 1502 bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len); 1503 else 1504 bitmap_copy(bitmap, tmp_bitmap, bitmap_len); 1505 } 1506 *lenp -= left; 1507 *ppos += *lenp; 1508 } 1509 1510 bitmap_free(tmp_bitmap); 1511 return err; 1512 } 1513 1514 #else /* CONFIG_PROC_SYSCTL */ 1515 1516 int proc_dostring(struct ctl_table *table, int write, 1517 void *buffer, size_t *lenp, loff_t *ppos) 1518 { 1519 return -ENOSYS; 1520 } 1521 1522 int proc_dobool(struct ctl_table *table, int write, 1523 void *buffer, size_t *lenp, loff_t *ppos) 1524 { 1525 return -ENOSYS; 1526 } 1527 1528 int proc_dointvec(struct ctl_table *table, int write, 1529 void *buffer, size_t *lenp, loff_t *ppos) 1530 { 1531 return -ENOSYS; 1532 } 1533 1534 int proc_douintvec(struct ctl_table *table, int write, 1535 void *buffer, size_t *lenp, loff_t *ppos) 1536 { 1537 return -ENOSYS; 1538 } 1539 1540 int proc_dointvec_minmax(struct ctl_table *table, int write, 1541 void *buffer, size_t *lenp, loff_t *ppos) 1542 { 1543 return -ENOSYS; 1544 } 1545 1546 int proc_douintvec_minmax(struct ctl_table *table, int write, 1547 void *buffer, size_t *lenp, loff_t *ppos) 1548 { 1549 return -ENOSYS; 1550 } 1551 1552 int proc_dou8vec_minmax(struct ctl_table *table, int write, 1553 void *buffer, size_t *lenp, loff_t *ppos) 1554 { 1555 return -ENOSYS; 1556 } 1557 1558 int proc_dointvec_jiffies(struct ctl_table *table, int write, 1559 void *buffer, size_t *lenp, loff_t *ppos) 1560 { 1561 return -ENOSYS; 1562 } 1563 1564 int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write, 1565 void *buffer, size_t *lenp, loff_t *ppos) 1566 { 1567 return -ENOSYS; 1568 } 1569 1570 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, 1571 void *buffer, size_t *lenp, loff_t *ppos) 1572 { 1573 return -ENOSYS; 1574 } 1575 1576 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, 1577 void *buffer, size_t *lenp, loff_t *ppos) 1578 { 1579 return -ENOSYS; 1580 } 1581 1582 int proc_doulongvec_minmax(struct ctl_table *table, int write, 1583 void *buffer, size_t *lenp, loff_t *ppos) 1584 { 1585 return -ENOSYS; 1586 } 1587 1588 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write, 1589 void *buffer, size_t *lenp, loff_t *ppos) 1590 { 1591 return -ENOSYS; 1592 } 1593 1594 int proc_do_large_bitmap(struct ctl_table *table, int write, 1595 void *buffer, size_t *lenp, loff_t *ppos) 1596 { 1597 return -ENOSYS; 1598 } 1599 1600 #endif /* CONFIG_PROC_SYSCTL */ 1601 1602 #if defined(CONFIG_SYSCTL) 1603 int proc_do_static_key(struct ctl_table *table, int write, 1604 void *buffer, size_t *lenp, loff_t *ppos) 1605 { 1606 struct static_key *key = (struct static_key *)table->data; 1607 static DEFINE_MUTEX(static_key_mutex); 1608 int val, ret; 1609 struct ctl_table tmp = { 1610 .data = &val, 1611 .maxlen = sizeof(val), 1612 .mode = table->mode, 1613 .extra1 = SYSCTL_ZERO, 1614 .extra2 = SYSCTL_ONE, 1615 }; 1616 1617 if (write && !capable(CAP_SYS_ADMIN)) 1618 return -EPERM; 1619 1620 mutex_lock(&static_key_mutex); 1621 val = static_key_enabled(key); 1622 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 1623 if (write && !ret) { 1624 if (val) 1625 static_key_enable(key); 1626 else 1627 static_key_disable(key); 1628 } 1629 mutex_unlock(&static_key_mutex); 1630 return ret; 1631 } 1632 1633 static struct ctl_table kern_table[] = { 1634 #ifdef CONFIG_NUMA_BALANCING 1635 { 1636 .procname = "numa_balancing", 1637 .data = NULL, /* filled in by handler */ 1638 .maxlen = sizeof(unsigned int), 1639 .mode = 0644, 1640 .proc_handler = sysctl_numa_balancing, 1641 .extra1 = SYSCTL_ZERO, 1642 .extra2 = SYSCTL_FOUR, 1643 }, 1644 #endif /* CONFIG_NUMA_BALANCING */ 1645 { 1646 .procname = "panic", 1647 .data = &panic_timeout, 1648 .maxlen = sizeof(int), 1649 .mode = 0644, 1650 .proc_handler = proc_dointvec, 1651 }, 1652 #ifdef CONFIG_PROC_SYSCTL 1653 { 1654 .procname = "tainted", 1655 .maxlen = sizeof(long), 1656 .mode = 0644, 1657 .proc_handler = proc_taint, 1658 }, 1659 { 1660 .procname = "sysctl_writes_strict", 1661 .data = &sysctl_writes_strict, 1662 .maxlen = sizeof(int), 1663 .mode = 0644, 1664 .proc_handler = proc_dointvec_minmax, 1665 .extra1 = SYSCTL_NEG_ONE, 1666 .extra2 = SYSCTL_ONE, 1667 }, 1668 #endif 1669 { 1670 .procname = "print-fatal-signals", 1671 .data = &print_fatal_signals, 1672 .maxlen = sizeof(int), 1673 .mode = 0644, 1674 .proc_handler = proc_dointvec, 1675 }, 1676 #ifdef CONFIG_SPARC 1677 { 1678 .procname = "reboot-cmd", 1679 .data = reboot_command, 1680 .maxlen = 256, 1681 .mode = 0644, 1682 .proc_handler = proc_dostring, 1683 }, 1684 { 1685 .procname = "stop-a", 1686 .data = &stop_a_enabled, 1687 .maxlen = sizeof (int), 1688 .mode = 0644, 1689 .proc_handler = proc_dointvec, 1690 }, 1691 { 1692 .procname = "scons-poweroff", 1693 .data = &scons_pwroff, 1694 .maxlen = sizeof (int), 1695 .mode = 0644, 1696 .proc_handler = proc_dointvec, 1697 }, 1698 #endif 1699 #ifdef CONFIG_SPARC64 1700 { 1701 .procname = "tsb-ratio", 1702 .data = &sysctl_tsb_ratio, 1703 .maxlen = sizeof (int), 1704 .mode = 0644, 1705 .proc_handler = proc_dointvec, 1706 }, 1707 #endif 1708 #ifdef CONFIG_PARISC 1709 { 1710 .procname = "soft-power", 1711 .data = &pwrsw_enabled, 1712 .maxlen = sizeof (int), 1713 .mode = 0644, 1714 .proc_handler = proc_dointvec, 1715 }, 1716 #endif 1717 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW 1718 { 1719 .procname = "unaligned-trap", 1720 .data = &unaligned_enabled, 1721 .maxlen = sizeof (int), 1722 .mode = 0644, 1723 .proc_handler = proc_dointvec, 1724 }, 1725 #endif 1726 #ifdef CONFIG_STACK_TRACER 1727 { 1728 .procname = "stack_tracer_enabled", 1729 .data = &stack_tracer_enabled, 1730 .maxlen = sizeof(int), 1731 .mode = 0644, 1732 .proc_handler = stack_trace_sysctl, 1733 }, 1734 #endif 1735 #ifdef CONFIG_TRACING 1736 { 1737 .procname = "ftrace_dump_on_oops", 1738 .data = &ftrace_dump_on_oops, 1739 .maxlen = sizeof(int), 1740 .mode = 0644, 1741 .proc_handler = proc_dointvec, 1742 }, 1743 { 1744 .procname = "traceoff_on_warning", 1745 .data = &__disable_trace_on_warning, 1746 .maxlen = sizeof(__disable_trace_on_warning), 1747 .mode = 0644, 1748 .proc_handler = proc_dointvec, 1749 }, 1750 { 1751 .procname = "tracepoint_printk", 1752 .data = &tracepoint_printk, 1753 .maxlen = sizeof(tracepoint_printk), 1754 .mode = 0644, 1755 .proc_handler = tracepoint_printk_sysctl, 1756 }, 1757 #endif 1758 #ifdef CONFIG_MODULES 1759 { 1760 .procname = "modprobe", 1761 .data = &modprobe_path, 1762 .maxlen = KMOD_PATH_LEN, 1763 .mode = 0644, 1764 .proc_handler = proc_dostring, 1765 }, 1766 { 1767 .procname = "modules_disabled", 1768 .data = &modules_disabled, 1769 .maxlen = sizeof(int), 1770 .mode = 0644, 1771 /* only handle a transition from default "0" to "1" */ 1772 .proc_handler = proc_dointvec_minmax, 1773 .extra1 = SYSCTL_ONE, 1774 .extra2 = SYSCTL_ONE, 1775 }, 1776 #endif 1777 #ifdef CONFIG_UEVENT_HELPER 1778 { 1779 .procname = "hotplug", 1780 .data = &uevent_helper, 1781 .maxlen = UEVENT_HELPER_PATH_LEN, 1782 .mode = 0644, 1783 .proc_handler = proc_dostring, 1784 }, 1785 #endif 1786 #ifdef CONFIG_MAGIC_SYSRQ 1787 { 1788 .procname = "sysrq", 1789 .data = NULL, 1790 .maxlen = sizeof (int), 1791 .mode = 0644, 1792 .proc_handler = sysrq_sysctl_handler, 1793 }, 1794 #endif 1795 #ifdef CONFIG_PROC_SYSCTL 1796 { 1797 .procname = "cad_pid", 1798 .data = NULL, 1799 .maxlen = sizeof (int), 1800 .mode = 0600, 1801 .proc_handler = proc_do_cad_pid, 1802 }, 1803 #endif 1804 { 1805 .procname = "threads-max", 1806 .data = NULL, 1807 .maxlen = sizeof(int), 1808 .mode = 0644, 1809 .proc_handler = sysctl_max_threads, 1810 }, 1811 { 1812 .procname = "usermodehelper", 1813 .mode = 0555, 1814 .child = usermodehelper_table, 1815 }, 1816 { 1817 .procname = "overflowuid", 1818 .data = &overflowuid, 1819 .maxlen = sizeof(int), 1820 .mode = 0644, 1821 .proc_handler = proc_dointvec_minmax, 1822 .extra1 = SYSCTL_ZERO, 1823 .extra2 = SYSCTL_MAXOLDUID, 1824 }, 1825 { 1826 .procname = "overflowgid", 1827 .data = &overflowgid, 1828 .maxlen = sizeof(int), 1829 .mode = 0644, 1830 .proc_handler = proc_dointvec_minmax, 1831 .extra1 = SYSCTL_ZERO, 1832 .extra2 = SYSCTL_MAXOLDUID, 1833 }, 1834 #ifdef CONFIG_S390 1835 { 1836 .procname = "userprocess_debug", 1837 .data = &show_unhandled_signals, 1838 .maxlen = sizeof(int), 1839 .mode = 0644, 1840 .proc_handler = proc_dointvec, 1841 }, 1842 #endif 1843 { 1844 .procname = "pid_max", 1845 .data = &pid_max, 1846 .maxlen = sizeof (int), 1847 .mode = 0644, 1848 .proc_handler = proc_dointvec_minmax, 1849 .extra1 = &pid_max_min, 1850 .extra2 = &pid_max_max, 1851 }, 1852 { 1853 .procname = "panic_on_oops", 1854 .data = &panic_on_oops, 1855 .maxlen = sizeof(int), 1856 .mode = 0644, 1857 .proc_handler = proc_dointvec, 1858 }, 1859 { 1860 .procname = "panic_print", 1861 .data = &panic_print, 1862 .maxlen = sizeof(unsigned long), 1863 .mode = 0644, 1864 .proc_handler = proc_doulongvec_minmax, 1865 }, 1866 { 1867 .procname = "ngroups_max", 1868 .data = (void *)&ngroups_max, 1869 .maxlen = sizeof (int), 1870 .mode = 0444, 1871 .proc_handler = proc_dointvec, 1872 }, 1873 { 1874 .procname = "cap_last_cap", 1875 .data = (void *)&cap_last_cap, 1876 .maxlen = sizeof(int), 1877 .mode = 0444, 1878 .proc_handler = proc_dointvec, 1879 }, 1880 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) 1881 { 1882 .procname = "unknown_nmi_panic", 1883 .data = &unknown_nmi_panic, 1884 .maxlen = sizeof (int), 1885 .mode = 0644, 1886 .proc_handler = proc_dointvec, 1887 }, 1888 #endif 1889 1890 #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \ 1891 defined(CONFIG_DEBUG_STACKOVERFLOW) 1892 { 1893 .procname = "panic_on_stackoverflow", 1894 .data = &sysctl_panic_on_stackoverflow, 1895 .maxlen = sizeof(int), 1896 .mode = 0644, 1897 .proc_handler = proc_dointvec, 1898 }, 1899 #endif 1900 #if defined(CONFIG_X86) 1901 { 1902 .procname = "panic_on_unrecovered_nmi", 1903 .data = &panic_on_unrecovered_nmi, 1904 .maxlen = sizeof(int), 1905 .mode = 0644, 1906 .proc_handler = proc_dointvec, 1907 }, 1908 { 1909 .procname = "panic_on_io_nmi", 1910 .data = &panic_on_io_nmi, 1911 .maxlen = sizeof(int), 1912 .mode = 0644, 1913 .proc_handler = proc_dointvec, 1914 }, 1915 { 1916 .procname = "bootloader_type", 1917 .data = &bootloader_type, 1918 .maxlen = sizeof (int), 1919 .mode = 0444, 1920 .proc_handler = proc_dointvec, 1921 }, 1922 { 1923 .procname = "bootloader_version", 1924 .data = &bootloader_version, 1925 .maxlen = sizeof (int), 1926 .mode = 0444, 1927 .proc_handler = proc_dointvec, 1928 }, 1929 { 1930 .procname = "io_delay_type", 1931 .data = &io_delay_type, 1932 .maxlen = sizeof(int), 1933 .mode = 0644, 1934 .proc_handler = proc_dointvec, 1935 }, 1936 #endif 1937 #if defined(CONFIG_MMU) 1938 { 1939 .procname = "randomize_va_space", 1940 .data = &randomize_va_space, 1941 .maxlen = sizeof(int), 1942 .mode = 0644, 1943 .proc_handler = proc_dointvec, 1944 }, 1945 #endif 1946 #if defined(CONFIG_S390) && defined(CONFIG_SMP) 1947 { 1948 .procname = "spin_retry", 1949 .data = &spin_retry, 1950 .maxlen = sizeof (int), 1951 .mode = 0644, 1952 .proc_handler = proc_dointvec, 1953 }, 1954 #endif 1955 #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86) 1956 { 1957 .procname = "acpi_video_flags", 1958 .data = &acpi_realmode_flags, 1959 .maxlen = sizeof (unsigned long), 1960 .mode = 0644, 1961 .proc_handler = proc_doulongvec_minmax, 1962 }, 1963 #endif 1964 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN 1965 { 1966 .procname = "ignore-unaligned-usertrap", 1967 .data = &no_unaligned_warning, 1968 .maxlen = sizeof (int), 1969 .mode = 0644, 1970 .proc_handler = proc_dointvec, 1971 }, 1972 #endif 1973 #ifdef CONFIG_IA64 1974 { 1975 .procname = "unaligned-dump-stack", 1976 .data = &unaligned_dump_stack, 1977 .maxlen = sizeof (int), 1978 .mode = 0644, 1979 .proc_handler = proc_dointvec, 1980 }, 1981 #endif 1982 #ifdef CONFIG_RT_MUTEXES 1983 { 1984 .procname = "max_lock_depth", 1985 .data = &max_lock_depth, 1986 .maxlen = sizeof(int), 1987 .mode = 0644, 1988 .proc_handler = proc_dointvec, 1989 }, 1990 #endif 1991 #ifdef CONFIG_KEYS 1992 { 1993 .procname = "keys", 1994 .mode = 0555, 1995 .child = key_sysctls, 1996 }, 1997 #endif 1998 #ifdef CONFIG_PERF_EVENTS 1999 /* 2000 * User-space scripts rely on the existence of this file 2001 * as a feature check for perf_events being enabled. 2002 * 2003 * So it's an ABI, do not remove! 2004 */ 2005 { 2006 .procname = "perf_event_paranoid", 2007 .data = &sysctl_perf_event_paranoid, 2008 .maxlen = sizeof(sysctl_perf_event_paranoid), 2009 .mode = 0644, 2010 .proc_handler = proc_dointvec, 2011 }, 2012 { 2013 .procname = "perf_event_mlock_kb", 2014 .data = &sysctl_perf_event_mlock, 2015 .maxlen = sizeof(sysctl_perf_event_mlock), 2016 .mode = 0644, 2017 .proc_handler = proc_dointvec, 2018 }, 2019 { 2020 .procname = "perf_event_max_sample_rate", 2021 .data = &sysctl_perf_event_sample_rate, 2022 .maxlen = sizeof(sysctl_perf_event_sample_rate), 2023 .mode = 0644, 2024 .proc_handler = perf_proc_update_handler, 2025 .extra1 = SYSCTL_ONE, 2026 }, 2027 { 2028 .procname = "perf_cpu_time_max_percent", 2029 .data = &sysctl_perf_cpu_time_max_percent, 2030 .maxlen = sizeof(sysctl_perf_cpu_time_max_percent), 2031 .mode = 0644, 2032 .proc_handler = perf_cpu_time_max_percent_handler, 2033 .extra1 = SYSCTL_ZERO, 2034 .extra2 = SYSCTL_ONE_HUNDRED, 2035 }, 2036 { 2037 .procname = "perf_event_max_stack", 2038 .data = &sysctl_perf_event_max_stack, 2039 .maxlen = sizeof(sysctl_perf_event_max_stack), 2040 .mode = 0644, 2041 .proc_handler = perf_event_max_stack_handler, 2042 .extra1 = SYSCTL_ZERO, 2043 .extra2 = (void *)&six_hundred_forty_kb, 2044 }, 2045 { 2046 .procname = "perf_event_max_contexts_per_stack", 2047 .data = &sysctl_perf_event_max_contexts_per_stack, 2048 .maxlen = sizeof(sysctl_perf_event_max_contexts_per_stack), 2049 .mode = 0644, 2050 .proc_handler = perf_event_max_stack_handler, 2051 .extra1 = SYSCTL_ZERO, 2052 .extra2 = SYSCTL_ONE_THOUSAND, 2053 }, 2054 #endif 2055 { 2056 .procname = "panic_on_warn", 2057 .data = &panic_on_warn, 2058 .maxlen = sizeof(int), 2059 .mode = 0644, 2060 .proc_handler = proc_dointvec_minmax, 2061 .extra1 = SYSCTL_ZERO, 2062 .extra2 = SYSCTL_ONE, 2063 }, 2064 #ifdef CONFIG_TREE_RCU 2065 { 2066 .procname = "panic_on_rcu_stall", 2067 .data = &sysctl_panic_on_rcu_stall, 2068 .maxlen = sizeof(sysctl_panic_on_rcu_stall), 2069 .mode = 0644, 2070 .proc_handler = proc_dointvec_minmax, 2071 .extra1 = SYSCTL_ZERO, 2072 .extra2 = SYSCTL_ONE, 2073 }, 2074 { 2075 .procname = "max_rcu_stall_to_panic", 2076 .data = &sysctl_max_rcu_stall_to_panic, 2077 .maxlen = sizeof(sysctl_max_rcu_stall_to_panic), 2078 .mode = 0644, 2079 .proc_handler = proc_dointvec_minmax, 2080 .extra1 = SYSCTL_ONE, 2081 .extra2 = SYSCTL_INT_MAX, 2082 }, 2083 #endif 2084 { } 2085 }; 2086 2087 static struct ctl_table vm_table[] = { 2088 { 2089 .procname = "overcommit_memory", 2090 .data = &sysctl_overcommit_memory, 2091 .maxlen = sizeof(sysctl_overcommit_memory), 2092 .mode = 0644, 2093 .proc_handler = overcommit_policy_handler, 2094 .extra1 = SYSCTL_ZERO, 2095 .extra2 = SYSCTL_TWO, 2096 }, 2097 { 2098 .procname = "overcommit_ratio", 2099 .data = &sysctl_overcommit_ratio, 2100 .maxlen = sizeof(sysctl_overcommit_ratio), 2101 .mode = 0644, 2102 .proc_handler = overcommit_ratio_handler, 2103 }, 2104 { 2105 .procname = "overcommit_kbytes", 2106 .data = &sysctl_overcommit_kbytes, 2107 .maxlen = sizeof(sysctl_overcommit_kbytes), 2108 .mode = 0644, 2109 .proc_handler = overcommit_kbytes_handler, 2110 }, 2111 { 2112 .procname = "page-cluster", 2113 .data = &page_cluster, 2114 .maxlen = sizeof(int), 2115 .mode = 0644, 2116 .proc_handler = proc_dointvec_minmax, 2117 .extra1 = SYSCTL_ZERO, 2118 }, 2119 { 2120 .procname = "dirtytime_expire_seconds", 2121 .data = &dirtytime_expire_interval, 2122 .maxlen = sizeof(dirtytime_expire_interval), 2123 .mode = 0644, 2124 .proc_handler = dirtytime_interval_handler, 2125 .extra1 = SYSCTL_ZERO, 2126 }, 2127 { 2128 .procname = "swappiness", 2129 .data = &vm_swappiness, 2130 .maxlen = sizeof(vm_swappiness), 2131 .mode = 0644, 2132 .proc_handler = proc_dointvec_minmax, 2133 .extra1 = SYSCTL_ZERO, 2134 .extra2 = SYSCTL_TWO_HUNDRED, 2135 }, 2136 #ifdef CONFIG_NUMA 2137 { 2138 .procname = "numa_stat", 2139 .data = &sysctl_vm_numa_stat, 2140 .maxlen = sizeof(int), 2141 .mode = 0644, 2142 .proc_handler = sysctl_vm_numa_stat_handler, 2143 .extra1 = SYSCTL_ZERO, 2144 .extra2 = SYSCTL_ONE, 2145 }, 2146 #endif 2147 #ifdef CONFIG_HUGETLB_PAGE 2148 { 2149 .procname = "nr_hugepages", 2150 .data = NULL, 2151 .maxlen = sizeof(unsigned long), 2152 .mode = 0644, 2153 .proc_handler = hugetlb_sysctl_handler, 2154 }, 2155 #ifdef CONFIG_NUMA 2156 { 2157 .procname = "nr_hugepages_mempolicy", 2158 .data = NULL, 2159 .maxlen = sizeof(unsigned long), 2160 .mode = 0644, 2161 .proc_handler = &hugetlb_mempolicy_sysctl_handler, 2162 }, 2163 #endif 2164 { 2165 .procname = "hugetlb_shm_group", 2166 .data = &sysctl_hugetlb_shm_group, 2167 .maxlen = sizeof(gid_t), 2168 .mode = 0644, 2169 .proc_handler = proc_dointvec, 2170 }, 2171 { 2172 .procname = "nr_overcommit_hugepages", 2173 .data = NULL, 2174 .maxlen = sizeof(unsigned long), 2175 .mode = 0644, 2176 .proc_handler = hugetlb_overcommit_handler, 2177 }, 2178 #endif 2179 { 2180 .procname = "lowmem_reserve_ratio", 2181 .data = &sysctl_lowmem_reserve_ratio, 2182 .maxlen = sizeof(sysctl_lowmem_reserve_ratio), 2183 .mode = 0644, 2184 .proc_handler = lowmem_reserve_ratio_sysctl_handler, 2185 }, 2186 { 2187 .procname = "drop_caches", 2188 .data = &sysctl_drop_caches, 2189 .maxlen = sizeof(int), 2190 .mode = 0200, 2191 .proc_handler = drop_caches_sysctl_handler, 2192 .extra1 = SYSCTL_ONE, 2193 .extra2 = SYSCTL_FOUR, 2194 }, 2195 #ifdef CONFIG_COMPACTION 2196 { 2197 .procname = "compact_memory", 2198 .data = NULL, 2199 .maxlen = sizeof(int), 2200 .mode = 0200, 2201 .proc_handler = sysctl_compaction_handler, 2202 }, 2203 { 2204 .procname = "compaction_proactiveness", 2205 .data = &sysctl_compaction_proactiveness, 2206 .maxlen = sizeof(sysctl_compaction_proactiveness), 2207 .mode = 0644, 2208 .proc_handler = compaction_proactiveness_sysctl_handler, 2209 .extra1 = SYSCTL_ZERO, 2210 .extra2 = SYSCTL_ONE_HUNDRED, 2211 }, 2212 { 2213 .procname = "extfrag_threshold", 2214 .data = &sysctl_extfrag_threshold, 2215 .maxlen = sizeof(int), 2216 .mode = 0644, 2217 .proc_handler = proc_dointvec_minmax, 2218 .extra1 = SYSCTL_ZERO, 2219 .extra2 = (void *)&max_extfrag_threshold, 2220 }, 2221 { 2222 .procname = "compact_unevictable_allowed", 2223 .data = &sysctl_compact_unevictable_allowed, 2224 .maxlen = sizeof(int), 2225 .mode = 0644, 2226 .proc_handler = proc_dointvec_minmax_warn_RT_change, 2227 .extra1 = SYSCTL_ZERO, 2228 .extra2 = SYSCTL_ONE, 2229 }, 2230 2231 #endif /* CONFIG_COMPACTION */ 2232 { 2233 .procname = "min_free_kbytes", 2234 .data = &min_free_kbytes, 2235 .maxlen = sizeof(min_free_kbytes), 2236 .mode = 0644, 2237 .proc_handler = min_free_kbytes_sysctl_handler, 2238 .extra1 = SYSCTL_ZERO, 2239 }, 2240 { 2241 .procname = "watermark_boost_factor", 2242 .data = &watermark_boost_factor, 2243 .maxlen = sizeof(watermark_boost_factor), 2244 .mode = 0644, 2245 .proc_handler = proc_dointvec_minmax, 2246 .extra1 = SYSCTL_ZERO, 2247 }, 2248 { 2249 .procname = "watermark_scale_factor", 2250 .data = &watermark_scale_factor, 2251 .maxlen = sizeof(watermark_scale_factor), 2252 .mode = 0644, 2253 .proc_handler = watermark_scale_factor_sysctl_handler, 2254 .extra1 = SYSCTL_ONE, 2255 .extra2 = SYSCTL_THREE_THOUSAND, 2256 }, 2257 { 2258 .procname = "percpu_pagelist_high_fraction", 2259 .data = &percpu_pagelist_high_fraction, 2260 .maxlen = sizeof(percpu_pagelist_high_fraction), 2261 .mode = 0644, 2262 .proc_handler = percpu_pagelist_high_fraction_sysctl_handler, 2263 .extra1 = SYSCTL_ZERO, 2264 }, 2265 { 2266 .procname = "page_lock_unfairness", 2267 .data = &sysctl_page_lock_unfairness, 2268 .maxlen = sizeof(sysctl_page_lock_unfairness), 2269 .mode = 0644, 2270 .proc_handler = proc_dointvec_minmax, 2271 .extra1 = SYSCTL_ZERO, 2272 }, 2273 #ifdef CONFIG_MMU 2274 { 2275 .procname = "max_map_count", 2276 .data = &sysctl_max_map_count, 2277 .maxlen = sizeof(sysctl_max_map_count), 2278 .mode = 0644, 2279 .proc_handler = proc_dointvec_minmax, 2280 .extra1 = SYSCTL_ZERO, 2281 }, 2282 #else 2283 { 2284 .procname = "nr_trim_pages", 2285 .data = &sysctl_nr_trim_pages, 2286 .maxlen = sizeof(sysctl_nr_trim_pages), 2287 .mode = 0644, 2288 .proc_handler = proc_dointvec_minmax, 2289 .extra1 = SYSCTL_ZERO, 2290 }, 2291 #endif 2292 { 2293 .procname = "vfs_cache_pressure", 2294 .data = &sysctl_vfs_cache_pressure, 2295 .maxlen = sizeof(sysctl_vfs_cache_pressure), 2296 .mode = 0644, 2297 .proc_handler = proc_dointvec_minmax, 2298 .extra1 = SYSCTL_ZERO, 2299 }, 2300 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \ 2301 defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT) 2302 { 2303 .procname = "legacy_va_layout", 2304 .data = &sysctl_legacy_va_layout, 2305 .maxlen = sizeof(sysctl_legacy_va_layout), 2306 .mode = 0644, 2307 .proc_handler = proc_dointvec_minmax, 2308 .extra1 = SYSCTL_ZERO, 2309 }, 2310 #endif 2311 #ifdef CONFIG_NUMA 2312 { 2313 .procname = "zone_reclaim_mode", 2314 .data = &node_reclaim_mode, 2315 .maxlen = sizeof(node_reclaim_mode), 2316 .mode = 0644, 2317 .proc_handler = proc_dointvec_minmax, 2318 .extra1 = SYSCTL_ZERO, 2319 }, 2320 { 2321 .procname = "min_unmapped_ratio", 2322 .data = &sysctl_min_unmapped_ratio, 2323 .maxlen = sizeof(sysctl_min_unmapped_ratio), 2324 .mode = 0644, 2325 .proc_handler = sysctl_min_unmapped_ratio_sysctl_handler, 2326 .extra1 = SYSCTL_ZERO, 2327 .extra2 = SYSCTL_ONE_HUNDRED, 2328 }, 2329 { 2330 .procname = "min_slab_ratio", 2331 .data = &sysctl_min_slab_ratio, 2332 .maxlen = sizeof(sysctl_min_slab_ratio), 2333 .mode = 0644, 2334 .proc_handler = sysctl_min_slab_ratio_sysctl_handler, 2335 .extra1 = SYSCTL_ZERO, 2336 .extra2 = SYSCTL_ONE_HUNDRED, 2337 }, 2338 #endif 2339 #ifdef CONFIG_SMP 2340 { 2341 .procname = "stat_interval", 2342 .data = &sysctl_stat_interval, 2343 .maxlen = sizeof(sysctl_stat_interval), 2344 .mode = 0644, 2345 .proc_handler = proc_dointvec_jiffies, 2346 }, 2347 { 2348 .procname = "stat_refresh", 2349 .data = NULL, 2350 .maxlen = 0, 2351 .mode = 0600, 2352 .proc_handler = vmstat_refresh, 2353 }, 2354 #endif 2355 #ifdef CONFIG_MMU 2356 { 2357 .procname = "mmap_min_addr", 2358 .data = &dac_mmap_min_addr, 2359 .maxlen = sizeof(unsigned long), 2360 .mode = 0644, 2361 .proc_handler = mmap_min_addr_handler, 2362 }, 2363 #endif 2364 #ifdef CONFIG_NUMA 2365 { 2366 .procname = "numa_zonelist_order", 2367 .data = &numa_zonelist_order, 2368 .maxlen = NUMA_ZONELIST_ORDER_LEN, 2369 .mode = 0644, 2370 .proc_handler = numa_zonelist_order_handler, 2371 }, 2372 #endif 2373 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \ 2374 (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL)) 2375 { 2376 .procname = "vdso_enabled", 2377 #ifdef CONFIG_X86_32 2378 .data = &vdso32_enabled, 2379 .maxlen = sizeof(vdso32_enabled), 2380 #else 2381 .data = &vdso_enabled, 2382 .maxlen = sizeof(vdso_enabled), 2383 #endif 2384 .mode = 0644, 2385 .proc_handler = proc_dointvec, 2386 .extra1 = SYSCTL_ZERO, 2387 }, 2388 #endif 2389 #ifdef CONFIG_MEMORY_FAILURE 2390 { 2391 .procname = "memory_failure_early_kill", 2392 .data = &sysctl_memory_failure_early_kill, 2393 .maxlen = sizeof(sysctl_memory_failure_early_kill), 2394 .mode = 0644, 2395 .proc_handler = proc_dointvec_minmax, 2396 .extra1 = SYSCTL_ZERO, 2397 .extra2 = SYSCTL_ONE, 2398 }, 2399 { 2400 .procname = "memory_failure_recovery", 2401 .data = &sysctl_memory_failure_recovery, 2402 .maxlen = sizeof(sysctl_memory_failure_recovery), 2403 .mode = 0644, 2404 .proc_handler = proc_dointvec_minmax, 2405 .extra1 = SYSCTL_ZERO, 2406 .extra2 = SYSCTL_ONE, 2407 }, 2408 #endif 2409 { 2410 .procname = "user_reserve_kbytes", 2411 .data = &sysctl_user_reserve_kbytes, 2412 .maxlen = sizeof(sysctl_user_reserve_kbytes), 2413 .mode = 0644, 2414 .proc_handler = proc_doulongvec_minmax, 2415 }, 2416 { 2417 .procname = "admin_reserve_kbytes", 2418 .data = &sysctl_admin_reserve_kbytes, 2419 .maxlen = sizeof(sysctl_admin_reserve_kbytes), 2420 .mode = 0644, 2421 .proc_handler = proc_doulongvec_minmax, 2422 }, 2423 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS 2424 { 2425 .procname = "mmap_rnd_bits", 2426 .data = &mmap_rnd_bits, 2427 .maxlen = sizeof(mmap_rnd_bits), 2428 .mode = 0600, 2429 .proc_handler = proc_dointvec_minmax, 2430 .extra1 = (void *)&mmap_rnd_bits_min, 2431 .extra2 = (void *)&mmap_rnd_bits_max, 2432 }, 2433 #endif 2434 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS 2435 { 2436 .procname = "mmap_rnd_compat_bits", 2437 .data = &mmap_rnd_compat_bits, 2438 .maxlen = sizeof(mmap_rnd_compat_bits), 2439 .mode = 0600, 2440 .proc_handler = proc_dointvec_minmax, 2441 .extra1 = (void *)&mmap_rnd_compat_bits_min, 2442 .extra2 = (void *)&mmap_rnd_compat_bits_max, 2443 }, 2444 #endif 2445 #ifdef CONFIG_USERFAULTFD 2446 { 2447 .procname = "unprivileged_userfaultfd", 2448 .data = &sysctl_unprivileged_userfaultfd, 2449 .maxlen = sizeof(sysctl_unprivileged_userfaultfd), 2450 .mode = 0644, 2451 .proc_handler = proc_dointvec_minmax, 2452 .extra1 = SYSCTL_ZERO, 2453 .extra2 = SYSCTL_ONE, 2454 }, 2455 #endif 2456 { } 2457 }; 2458 2459 static struct ctl_table debug_table[] = { 2460 #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE 2461 { 2462 .procname = "exception-trace", 2463 .data = &show_unhandled_signals, 2464 .maxlen = sizeof(int), 2465 .mode = 0644, 2466 .proc_handler = proc_dointvec 2467 }, 2468 #endif 2469 { } 2470 }; 2471 2472 static struct ctl_table dev_table[] = { 2473 { } 2474 }; 2475 2476 DECLARE_SYSCTL_BASE(kernel, kern_table); 2477 DECLARE_SYSCTL_BASE(vm, vm_table); 2478 DECLARE_SYSCTL_BASE(debug, debug_table); 2479 DECLARE_SYSCTL_BASE(dev, dev_table); 2480 2481 int __init sysctl_init_bases(void) 2482 { 2483 register_sysctl_base(kernel); 2484 register_sysctl_base(vm); 2485 register_sysctl_base(debug); 2486 register_sysctl_base(dev); 2487 2488 return 0; 2489 } 2490 #endif /* CONFIG_SYSCTL */ 2491 /* 2492 * No sense putting this after each symbol definition, twice, 2493 * exception granted :-) 2494 */ 2495 EXPORT_SYMBOL(proc_dobool); 2496 EXPORT_SYMBOL(proc_dointvec); 2497 EXPORT_SYMBOL(proc_douintvec); 2498 EXPORT_SYMBOL(proc_dointvec_jiffies); 2499 EXPORT_SYMBOL(proc_dointvec_minmax); 2500 EXPORT_SYMBOL_GPL(proc_douintvec_minmax); 2501 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies); 2502 EXPORT_SYMBOL(proc_dointvec_ms_jiffies); 2503 EXPORT_SYMBOL(proc_dostring); 2504 EXPORT_SYMBOL(proc_doulongvec_minmax); 2505 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax); 2506 EXPORT_SYMBOL(proc_do_large_bitmap); 2507