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