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: the current position in the file 1309 * 1310 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer 1311 * values from/to the user buffer, treated as an ASCII string. 1312 * The values read are assumed to be in 1/1000 seconds, and 1313 * are converted into jiffies. 1314 * 1315 * Returns 0 on success. 1316 */ 1317 int proc_dointvec_ms_jiffies(const struct ctl_table *table, int write, void *buffer, 1318 size_t *lenp, loff_t *ppos) 1319 { 1320 return do_proc_dointvec(table, write, buffer, lenp, ppos, 1321 do_proc_dointvec_ms_jiffies_conv, NULL); 1322 } 1323 1324 static int proc_do_cad_pid(const struct ctl_table *table, int write, void *buffer, 1325 size_t *lenp, loff_t *ppos) 1326 { 1327 struct pid *new_pid; 1328 pid_t tmp; 1329 int r; 1330 1331 tmp = pid_vnr(cad_pid); 1332 1333 r = __do_proc_dointvec(&tmp, table, write, buffer, 1334 lenp, ppos, NULL, NULL); 1335 if (r || !write) 1336 return r; 1337 1338 new_pid = find_get_pid(tmp); 1339 if (!new_pid) 1340 return -ESRCH; 1341 1342 put_pid(xchg(&cad_pid, new_pid)); 1343 return 0; 1344 } 1345 1346 /** 1347 * proc_do_large_bitmap - read/write from/to a large bitmap 1348 * @table: the sysctl table 1349 * @write: %TRUE if this is a write to the sysctl file 1350 * @buffer: the user buffer 1351 * @lenp: the size of the user buffer 1352 * @ppos: file position 1353 * 1354 * The bitmap is stored at table->data and the bitmap length (in bits) 1355 * in table->maxlen. 1356 * 1357 * We use a range comma separated format (e.g. 1,3-4,10-10) so that 1358 * large bitmaps may be represented in a compact manner. Writing into 1359 * the file will clear the bitmap then update it with the given input. 1360 * 1361 * Returns 0 on success. 1362 */ 1363 int proc_do_large_bitmap(const struct ctl_table *table, int write, 1364 void *buffer, size_t *lenp, loff_t *ppos) 1365 { 1366 int err = 0; 1367 size_t left = *lenp; 1368 unsigned long bitmap_len = table->maxlen; 1369 unsigned long *bitmap = *(unsigned long **) table->data; 1370 unsigned long *tmp_bitmap = NULL; 1371 char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c; 1372 1373 if (!bitmap || !bitmap_len || !left || (*ppos && !write)) { 1374 *lenp = 0; 1375 return 0; 1376 } 1377 1378 if (write) { 1379 char *p = buffer; 1380 size_t skipped = 0; 1381 1382 if (left > PAGE_SIZE - 1) { 1383 left = PAGE_SIZE - 1; 1384 /* How much of the buffer we'll skip this pass */ 1385 skipped = *lenp - left; 1386 } 1387 1388 tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL); 1389 if (!tmp_bitmap) 1390 return -ENOMEM; 1391 proc_skip_char(&p, &left, '\n'); 1392 while (!err && left) { 1393 unsigned long val_a, val_b; 1394 bool neg; 1395 size_t saved_left; 1396 1397 /* In case we stop parsing mid-number, we can reset */ 1398 saved_left = left; 1399 err = proc_get_long(&p, &left, &val_a, &neg, tr_a, 1400 sizeof(tr_a), &c); 1401 /* 1402 * If we consumed the entirety of a truncated buffer or 1403 * only one char is left (may be a "-"), then stop here, 1404 * reset, & come back for more. 1405 */ 1406 if ((left <= 1) && skipped) { 1407 left = saved_left; 1408 break; 1409 } 1410 1411 if (err) 1412 break; 1413 if (val_a >= bitmap_len || neg) { 1414 err = -EINVAL; 1415 break; 1416 } 1417 1418 val_b = val_a; 1419 if (left) { 1420 p++; 1421 left--; 1422 } 1423 1424 if (c == '-') { 1425 err = proc_get_long(&p, &left, &val_b, 1426 &neg, tr_b, sizeof(tr_b), 1427 &c); 1428 /* 1429 * If we consumed all of a truncated buffer or 1430 * then stop here, reset, & come back for more. 1431 */ 1432 if (!left && skipped) { 1433 left = saved_left; 1434 break; 1435 } 1436 1437 if (err) 1438 break; 1439 if (val_b >= bitmap_len || neg || 1440 val_a > val_b) { 1441 err = -EINVAL; 1442 break; 1443 } 1444 if (left) { 1445 p++; 1446 left--; 1447 } 1448 } 1449 1450 bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1); 1451 proc_skip_char(&p, &left, '\n'); 1452 } 1453 left += skipped; 1454 } else { 1455 unsigned long bit_a, bit_b = 0; 1456 bool first = 1; 1457 1458 while (left) { 1459 bit_a = find_next_bit(bitmap, bitmap_len, bit_b); 1460 if (bit_a >= bitmap_len) 1461 break; 1462 bit_b = find_next_zero_bit(bitmap, bitmap_len, 1463 bit_a + 1) - 1; 1464 1465 if (!first) 1466 proc_put_char(&buffer, &left, ','); 1467 proc_put_long(&buffer, &left, bit_a, false); 1468 if (bit_a != bit_b) { 1469 proc_put_char(&buffer, &left, '-'); 1470 proc_put_long(&buffer, &left, bit_b, false); 1471 } 1472 1473 first = 0; bit_b++; 1474 } 1475 proc_put_char(&buffer, &left, '\n'); 1476 } 1477 1478 if (!err) { 1479 if (write) { 1480 if (*ppos) 1481 bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len); 1482 else 1483 bitmap_copy(bitmap, tmp_bitmap, bitmap_len); 1484 } 1485 *lenp -= left; 1486 *ppos += *lenp; 1487 } 1488 1489 bitmap_free(tmp_bitmap); 1490 return err; 1491 } 1492 1493 #else /* CONFIG_PROC_SYSCTL */ 1494 1495 int proc_dostring(const struct ctl_table *table, int write, 1496 void *buffer, size_t *lenp, loff_t *ppos) 1497 { 1498 return -ENOSYS; 1499 } 1500 1501 int proc_dobool(const struct ctl_table *table, int write, 1502 void *buffer, size_t *lenp, loff_t *ppos) 1503 { 1504 return -ENOSYS; 1505 } 1506 1507 int proc_dointvec(const struct ctl_table *table, int write, 1508 void *buffer, size_t *lenp, loff_t *ppos) 1509 { 1510 return -ENOSYS; 1511 } 1512 1513 int proc_douintvec(const struct ctl_table *table, int write, 1514 void *buffer, size_t *lenp, loff_t *ppos) 1515 { 1516 return -ENOSYS; 1517 } 1518 1519 int proc_dointvec_minmax(const struct ctl_table *table, int write, 1520 void *buffer, size_t *lenp, loff_t *ppos) 1521 { 1522 return -ENOSYS; 1523 } 1524 1525 int proc_douintvec_minmax(const struct ctl_table *table, int write, 1526 void *buffer, size_t *lenp, loff_t *ppos) 1527 { 1528 return -ENOSYS; 1529 } 1530 1531 int proc_dou8vec_minmax(const struct ctl_table *table, int write, 1532 void *buffer, size_t *lenp, loff_t *ppos) 1533 { 1534 return -ENOSYS; 1535 } 1536 1537 int proc_dointvec_jiffies(const struct ctl_table *table, int write, 1538 void *buffer, size_t *lenp, loff_t *ppos) 1539 { 1540 return -ENOSYS; 1541 } 1542 1543 int proc_dointvec_ms_jiffies_minmax(const struct ctl_table *table, int write, 1544 void *buffer, size_t *lenp, loff_t *ppos) 1545 { 1546 return -ENOSYS; 1547 } 1548 1549 int proc_dointvec_userhz_jiffies(const struct ctl_table *table, int write, 1550 void *buffer, size_t *lenp, loff_t *ppos) 1551 { 1552 return -ENOSYS; 1553 } 1554 1555 int proc_dointvec_ms_jiffies(const struct ctl_table *table, int write, 1556 void *buffer, size_t *lenp, loff_t *ppos) 1557 { 1558 return -ENOSYS; 1559 } 1560 1561 int proc_doulongvec_minmax(const struct ctl_table *table, int write, 1562 void *buffer, size_t *lenp, loff_t *ppos) 1563 { 1564 return -ENOSYS; 1565 } 1566 1567 int proc_doulongvec_ms_jiffies_minmax(const struct ctl_table *table, int write, 1568 void *buffer, size_t *lenp, loff_t *ppos) 1569 { 1570 return -ENOSYS; 1571 } 1572 1573 int proc_do_large_bitmap(const struct ctl_table *table, int write, 1574 void *buffer, size_t *lenp, loff_t *ppos) 1575 { 1576 return -ENOSYS; 1577 } 1578 1579 #endif /* CONFIG_PROC_SYSCTL */ 1580 1581 #if defined(CONFIG_SYSCTL) 1582 int proc_do_static_key(const struct ctl_table *table, int write, 1583 void *buffer, size_t *lenp, loff_t *ppos) 1584 { 1585 struct static_key *key = (struct static_key *)table->data; 1586 static DEFINE_MUTEX(static_key_mutex); 1587 int val, ret; 1588 struct ctl_table tmp = { 1589 .data = &val, 1590 .maxlen = sizeof(val), 1591 .mode = table->mode, 1592 .extra1 = SYSCTL_ZERO, 1593 .extra2 = SYSCTL_ONE, 1594 }; 1595 1596 if (write && !capable(CAP_SYS_ADMIN)) 1597 return -EPERM; 1598 1599 mutex_lock(&static_key_mutex); 1600 val = static_key_enabled(key); 1601 ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos); 1602 if (write && !ret) { 1603 if (val) 1604 static_key_enable(key); 1605 else 1606 static_key_disable(key); 1607 } 1608 mutex_unlock(&static_key_mutex); 1609 return ret; 1610 } 1611 1612 static struct ctl_table kern_table[] = { 1613 { 1614 .procname = "panic", 1615 .data = &panic_timeout, 1616 .maxlen = sizeof(int), 1617 .mode = 0644, 1618 .proc_handler = proc_dointvec, 1619 }, 1620 #ifdef CONFIG_PROC_SYSCTL 1621 { 1622 .procname = "tainted", 1623 .maxlen = sizeof(long), 1624 .mode = 0644, 1625 .proc_handler = proc_taint, 1626 }, 1627 { 1628 .procname = "sysctl_writes_strict", 1629 .data = &sysctl_writes_strict, 1630 .maxlen = sizeof(int), 1631 .mode = 0644, 1632 .proc_handler = proc_dointvec_minmax, 1633 .extra1 = SYSCTL_NEG_ONE, 1634 .extra2 = SYSCTL_ONE, 1635 }, 1636 #endif 1637 { 1638 .procname = "print-fatal-signals", 1639 .data = &print_fatal_signals, 1640 .maxlen = sizeof(int), 1641 .mode = 0644, 1642 .proc_handler = proc_dointvec, 1643 }, 1644 #ifdef CONFIG_SPARC 1645 { 1646 .procname = "reboot-cmd", 1647 .data = reboot_command, 1648 .maxlen = 256, 1649 .mode = 0644, 1650 .proc_handler = proc_dostring, 1651 }, 1652 { 1653 .procname = "stop-a", 1654 .data = &stop_a_enabled, 1655 .maxlen = sizeof (int), 1656 .mode = 0644, 1657 .proc_handler = proc_dointvec, 1658 }, 1659 { 1660 .procname = "scons-poweroff", 1661 .data = &scons_pwroff, 1662 .maxlen = sizeof (int), 1663 .mode = 0644, 1664 .proc_handler = proc_dointvec, 1665 }, 1666 #endif 1667 #ifdef CONFIG_SPARC64 1668 { 1669 .procname = "tsb-ratio", 1670 .data = &sysctl_tsb_ratio, 1671 .maxlen = sizeof (int), 1672 .mode = 0644, 1673 .proc_handler = proc_dointvec, 1674 }, 1675 #endif 1676 #ifdef CONFIG_PARISC 1677 { 1678 .procname = "soft-power", 1679 .data = &pwrsw_enabled, 1680 .maxlen = sizeof (int), 1681 .mode = 0644, 1682 .proc_handler = proc_dointvec, 1683 }, 1684 #endif 1685 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW 1686 { 1687 .procname = "unaligned-trap", 1688 .data = &unaligned_enabled, 1689 .maxlen = sizeof (int), 1690 .mode = 0644, 1691 .proc_handler = proc_dointvec, 1692 }, 1693 #endif 1694 #ifdef CONFIG_STACK_TRACER 1695 { 1696 .procname = "stack_tracer_enabled", 1697 .data = &stack_tracer_enabled, 1698 .maxlen = sizeof(int), 1699 .mode = 0644, 1700 .proc_handler = stack_trace_sysctl, 1701 }, 1702 #endif 1703 #ifdef CONFIG_TRACING 1704 { 1705 .procname = "ftrace_dump_on_oops", 1706 .data = &ftrace_dump_on_oops, 1707 .maxlen = MAX_TRACER_SIZE, 1708 .mode = 0644, 1709 .proc_handler = proc_dostring, 1710 }, 1711 { 1712 .procname = "traceoff_on_warning", 1713 .data = &__disable_trace_on_warning, 1714 .maxlen = sizeof(__disable_trace_on_warning), 1715 .mode = 0644, 1716 .proc_handler = proc_dointvec, 1717 }, 1718 { 1719 .procname = "tracepoint_printk", 1720 .data = &tracepoint_printk, 1721 .maxlen = sizeof(tracepoint_printk), 1722 .mode = 0644, 1723 .proc_handler = tracepoint_printk_sysctl, 1724 }, 1725 #endif 1726 #ifdef CONFIG_MODULES 1727 { 1728 .procname = "modprobe", 1729 .data = &modprobe_path, 1730 .maxlen = KMOD_PATH_LEN, 1731 .mode = 0644, 1732 .proc_handler = proc_dostring, 1733 }, 1734 { 1735 .procname = "modules_disabled", 1736 .data = &modules_disabled, 1737 .maxlen = sizeof(int), 1738 .mode = 0644, 1739 /* only handle a transition from default "0" to "1" */ 1740 .proc_handler = proc_dointvec_minmax, 1741 .extra1 = SYSCTL_ONE, 1742 .extra2 = SYSCTL_ONE, 1743 }, 1744 #endif 1745 #ifdef CONFIG_UEVENT_HELPER 1746 { 1747 .procname = "hotplug", 1748 .data = &uevent_helper, 1749 .maxlen = UEVENT_HELPER_PATH_LEN, 1750 .mode = 0644, 1751 .proc_handler = proc_dostring, 1752 }, 1753 #endif 1754 #ifdef CONFIG_MAGIC_SYSRQ 1755 { 1756 .procname = "sysrq", 1757 .data = NULL, 1758 .maxlen = sizeof (int), 1759 .mode = 0644, 1760 .proc_handler = sysrq_sysctl_handler, 1761 }, 1762 #endif 1763 #ifdef CONFIG_PROC_SYSCTL 1764 { 1765 .procname = "cad_pid", 1766 .data = NULL, 1767 .maxlen = sizeof (int), 1768 .mode = 0600, 1769 .proc_handler = proc_do_cad_pid, 1770 }, 1771 #endif 1772 { 1773 .procname = "threads-max", 1774 .data = NULL, 1775 .maxlen = sizeof(int), 1776 .mode = 0644, 1777 .proc_handler = sysctl_max_threads, 1778 }, 1779 { 1780 .procname = "overflowuid", 1781 .data = &overflowuid, 1782 .maxlen = sizeof(int), 1783 .mode = 0644, 1784 .proc_handler = proc_dointvec_minmax, 1785 .extra1 = SYSCTL_ZERO, 1786 .extra2 = SYSCTL_MAXOLDUID, 1787 }, 1788 { 1789 .procname = "overflowgid", 1790 .data = &overflowgid, 1791 .maxlen = sizeof(int), 1792 .mode = 0644, 1793 .proc_handler = proc_dointvec_minmax, 1794 .extra1 = SYSCTL_ZERO, 1795 .extra2 = SYSCTL_MAXOLDUID, 1796 }, 1797 #ifdef CONFIG_S390 1798 { 1799 .procname = "userprocess_debug", 1800 .data = &show_unhandled_signals, 1801 .maxlen = sizeof(int), 1802 .mode = 0644, 1803 .proc_handler = proc_dointvec, 1804 }, 1805 #endif 1806 { 1807 .procname = "pid_max", 1808 .data = &pid_max, 1809 .maxlen = sizeof (int), 1810 .mode = 0644, 1811 .proc_handler = proc_dointvec_minmax, 1812 .extra1 = &pid_max_min, 1813 .extra2 = &pid_max_max, 1814 }, 1815 { 1816 .procname = "panic_on_oops", 1817 .data = &panic_on_oops, 1818 .maxlen = sizeof(int), 1819 .mode = 0644, 1820 .proc_handler = proc_dointvec, 1821 }, 1822 { 1823 .procname = "panic_print", 1824 .data = &panic_print, 1825 .maxlen = sizeof(unsigned long), 1826 .mode = 0644, 1827 .proc_handler = proc_doulongvec_minmax, 1828 }, 1829 { 1830 .procname = "ngroups_max", 1831 .data = (void *)&ngroups_max, 1832 .maxlen = sizeof (int), 1833 .mode = 0444, 1834 .proc_handler = proc_dointvec, 1835 }, 1836 { 1837 .procname = "cap_last_cap", 1838 .data = (void *)&cap_last_cap, 1839 .maxlen = sizeof(int), 1840 .mode = 0444, 1841 .proc_handler = proc_dointvec, 1842 }, 1843 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) 1844 { 1845 .procname = "unknown_nmi_panic", 1846 .data = &unknown_nmi_panic, 1847 .maxlen = sizeof (int), 1848 .mode = 0644, 1849 .proc_handler = proc_dointvec, 1850 }, 1851 #endif 1852 1853 #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \ 1854 defined(CONFIG_DEBUG_STACKOVERFLOW) 1855 { 1856 .procname = "panic_on_stackoverflow", 1857 .data = &sysctl_panic_on_stackoverflow, 1858 .maxlen = sizeof(int), 1859 .mode = 0644, 1860 .proc_handler = proc_dointvec, 1861 }, 1862 #endif 1863 #if defined(CONFIG_X86) 1864 { 1865 .procname = "panic_on_unrecovered_nmi", 1866 .data = &panic_on_unrecovered_nmi, 1867 .maxlen = sizeof(int), 1868 .mode = 0644, 1869 .proc_handler = proc_dointvec, 1870 }, 1871 { 1872 .procname = "panic_on_io_nmi", 1873 .data = &panic_on_io_nmi, 1874 .maxlen = sizeof(int), 1875 .mode = 0644, 1876 .proc_handler = proc_dointvec, 1877 }, 1878 { 1879 .procname = "bootloader_type", 1880 .data = &bootloader_type, 1881 .maxlen = sizeof (int), 1882 .mode = 0444, 1883 .proc_handler = proc_dointvec, 1884 }, 1885 { 1886 .procname = "bootloader_version", 1887 .data = &bootloader_version, 1888 .maxlen = sizeof (int), 1889 .mode = 0444, 1890 .proc_handler = proc_dointvec, 1891 }, 1892 { 1893 .procname = "io_delay_type", 1894 .data = &io_delay_type, 1895 .maxlen = sizeof(int), 1896 .mode = 0644, 1897 .proc_handler = proc_dointvec, 1898 }, 1899 #endif 1900 #if defined(CONFIG_MMU) 1901 { 1902 .procname = "randomize_va_space", 1903 .data = &randomize_va_space, 1904 .maxlen = sizeof(int), 1905 .mode = 0644, 1906 .proc_handler = proc_dointvec, 1907 }, 1908 #endif 1909 #if defined(CONFIG_S390) && defined(CONFIG_SMP) 1910 { 1911 .procname = "spin_retry", 1912 .data = &spin_retry, 1913 .maxlen = sizeof (int), 1914 .mode = 0644, 1915 .proc_handler = proc_dointvec, 1916 }, 1917 #endif 1918 #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86) 1919 { 1920 .procname = "acpi_video_flags", 1921 .data = &acpi_realmode_flags, 1922 .maxlen = sizeof (unsigned long), 1923 .mode = 0644, 1924 .proc_handler = proc_doulongvec_minmax, 1925 }, 1926 #endif 1927 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN 1928 { 1929 .procname = "ignore-unaligned-usertrap", 1930 .data = &no_unaligned_warning, 1931 .maxlen = sizeof (int), 1932 .mode = 0644, 1933 .proc_handler = proc_dointvec, 1934 }, 1935 #endif 1936 #ifdef CONFIG_RT_MUTEXES 1937 { 1938 .procname = "max_lock_depth", 1939 .data = &max_lock_depth, 1940 .maxlen = sizeof(int), 1941 .mode = 0644, 1942 .proc_handler = proc_dointvec, 1943 }, 1944 #endif 1945 #ifdef CONFIG_PERF_EVENTS 1946 /* 1947 * User-space scripts rely on the existence of this file 1948 * as a feature check for perf_events being enabled. 1949 * 1950 * So it's an ABI, do not remove! 1951 */ 1952 { 1953 .procname = "perf_event_paranoid", 1954 .data = &sysctl_perf_event_paranoid, 1955 .maxlen = sizeof(sysctl_perf_event_paranoid), 1956 .mode = 0644, 1957 .proc_handler = proc_dointvec, 1958 }, 1959 { 1960 .procname = "perf_event_mlock_kb", 1961 .data = &sysctl_perf_event_mlock, 1962 .maxlen = sizeof(sysctl_perf_event_mlock), 1963 .mode = 0644, 1964 .proc_handler = proc_dointvec, 1965 }, 1966 { 1967 .procname = "perf_event_max_sample_rate", 1968 .data = &sysctl_perf_event_sample_rate, 1969 .maxlen = sizeof(sysctl_perf_event_sample_rate), 1970 .mode = 0644, 1971 .proc_handler = perf_event_max_sample_rate_handler, 1972 .extra1 = SYSCTL_ONE, 1973 }, 1974 { 1975 .procname = "perf_cpu_time_max_percent", 1976 .data = &sysctl_perf_cpu_time_max_percent, 1977 .maxlen = sizeof(sysctl_perf_cpu_time_max_percent), 1978 .mode = 0644, 1979 .proc_handler = perf_cpu_time_max_percent_handler, 1980 .extra1 = SYSCTL_ZERO, 1981 .extra2 = SYSCTL_ONE_HUNDRED, 1982 }, 1983 { 1984 .procname = "perf_event_max_stack", 1985 .data = &sysctl_perf_event_max_stack, 1986 .maxlen = sizeof(sysctl_perf_event_max_stack), 1987 .mode = 0644, 1988 .proc_handler = perf_event_max_stack_handler, 1989 .extra1 = SYSCTL_ZERO, 1990 .extra2 = (void *)&six_hundred_forty_kb, 1991 }, 1992 { 1993 .procname = "perf_event_max_contexts_per_stack", 1994 .data = &sysctl_perf_event_max_contexts_per_stack, 1995 .maxlen = sizeof(sysctl_perf_event_max_contexts_per_stack), 1996 .mode = 0644, 1997 .proc_handler = perf_event_max_stack_handler, 1998 .extra1 = SYSCTL_ZERO, 1999 .extra2 = SYSCTL_ONE_THOUSAND, 2000 }, 2001 #endif 2002 { 2003 .procname = "panic_on_warn", 2004 .data = &panic_on_warn, 2005 .maxlen = sizeof(int), 2006 .mode = 0644, 2007 .proc_handler = proc_dointvec_minmax, 2008 .extra1 = SYSCTL_ZERO, 2009 .extra2 = SYSCTL_ONE, 2010 }, 2011 #ifdef CONFIG_TREE_RCU 2012 { 2013 .procname = "panic_on_rcu_stall", 2014 .data = &sysctl_panic_on_rcu_stall, 2015 .maxlen = sizeof(sysctl_panic_on_rcu_stall), 2016 .mode = 0644, 2017 .proc_handler = proc_dointvec_minmax, 2018 .extra1 = SYSCTL_ZERO, 2019 .extra2 = SYSCTL_ONE, 2020 }, 2021 { 2022 .procname = "max_rcu_stall_to_panic", 2023 .data = &sysctl_max_rcu_stall_to_panic, 2024 .maxlen = sizeof(sysctl_max_rcu_stall_to_panic), 2025 .mode = 0644, 2026 .proc_handler = proc_dointvec_minmax, 2027 .extra1 = SYSCTL_ONE, 2028 .extra2 = SYSCTL_INT_MAX, 2029 }, 2030 #endif 2031 }; 2032 2033 static struct ctl_table vm_table[] = { 2034 { 2035 .procname = "overcommit_memory", 2036 .data = &sysctl_overcommit_memory, 2037 .maxlen = sizeof(sysctl_overcommit_memory), 2038 .mode = 0644, 2039 .proc_handler = overcommit_policy_handler, 2040 .extra1 = SYSCTL_ZERO, 2041 .extra2 = SYSCTL_TWO, 2042 }, 2043 { 2044 .procname = "overcommit_ratio", 2045 .data = &sysctl_overcommit_ratio, 2046 .maxlen = sizeof(sysctl_overcommit_ratio), 2047 .mode = 0644, 2048 .proc_handler = overcommit_ratio_handler, 2049 }, 2050 { 2051 .procname = "overcommit_kbytes", 2052 .data = &sysctl_overcommit_kbytes, 2053 .maxlen = sizeof(sysctl_overcommit_kbytes), 2054 .mode = 0644, 2055 .proc_handler = overcommit_kbytes_handler, 2056 }, 2057 { 2058 .procname = "page-cluster", 2059 .data = &page_cluster, 2060 .maxlen = sizeof(int), 2061 .mode = 0644, 2062 .proc_handler = proc_dointvec_minmax, 2063 .extra1 = SYSCTL_ZERO, 2064 .extra2 = (void *)&page_cluster_max, 2065 }, 2066 { 2067 .procname = "dirtytime_expire_seconds", 2068 .data = &dirtytime_expire_interval, 2069 .maxlen = sizeof(dirtytime_expire_interval), 2070 .mode = 0644, 2071 .proc_handler = dirtytime_interval_handler, 2072 .extra1 = SYSCTL_ZERO, 2073 }, 2074 { 2075 .procname = "swappiness", 2076 .data = &vm_swappiness, 2077 .maxlen = sizeof(vm_swappiness), 2078 .mode = 0644, 2079 .proc_handler = proc_dointvec_minmax, 2080 .extra1 = SYSCTL_ZERO, 2081 .extra2 = SYSCTL_TWO_HUNDRED, 2082 }, 2083 #ifdef CONFIG_NUMA 2084 { 2085 .procname = "numa_stat", 2086 .data = &sysctl_vm_numa_stat, 2087 .maxlen = sizeof(int), 2088 .mode = 0644, 2089 .proc_handler = sysctl_vm_numa_stat_handler, 2090 .extra1 = SYSCTL_ZERO, 2091 .extra2 = SYSCTL_ONE, 2092 }, 2093 #endif 2094 { 2095 .procname = "drop_caches", 2096 .data = &sysctl_drop_caches, 2097 .maxlen = sizeof(int), 2098 .mode = 0200, 2099 .proc_handler = drop_caches_sysctl_handler, 2100 .extra1 = SYSCTL_ONE, 2101 .extra2 = SYSCTL_FOUR, 2102 }, 2103 { 2104 .procname = "page_lock_unfairness", 2105 .data = &sysctl_page_lock_unfairness, 2106 .maxlen = sizeof(sysctl_page_lock_unfairness), 2107 .mode = 0644, 2108 .proc_handler = proc_dointvec_minmax, 2109 .extra1 = SYSCTL_ZERO, 2110 }, 2111 #ifdef CONFIG_MMU 2112 { 2113 .procname = "max_map_count", 2114 .data = &sysctl_max_map_count, 2115 .maxlen = sizeof(sysctl_max_map_count), 2116 .mode = 0644, 2117 .proc_handler = proc_dointvec_minmax, 2118 .extra1 = SYSCTL_ZERO, 2119 }, 2120 #else 2121 { 2122 .procname = "nr_trim_pages", 2123 .data = &sysctl_nr_trim_pages, 2124 .maxlen = sizeof(sysctl_nr_trim_pages), 2125 .mode = 0644, 2126 .proc_handler = proc_dointvec_minmax, 2127 .extra1 = SYSCTL_ZERO, 2128 }, 2129 #endif 2130 { 2131 .procname = "vfs_cache_pressure", 2132 .data = &sysctl_vfs_cache_pressure, 2133 .maxlen = sizeof(sysctl_vfs_cache_pressure), 2134 .mode = 0644, 2135 .proc_handler = proc_dointvec_minmax, 2136 .extra1 = SYSCTL_ZERO, 2137 }, 2138 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \ 2139 defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT) 2140 { 2141 .procname = "legacy_va_layout", 2142 .data = &sysctl_legacy_va_layout, 2143 .maxlen = sizeof(sysctl_legacy_va_layout), 2144 .mode = 0644, 2145 .proc_handler = proc_dointvec_minmax, 2146 .extra1 = SYSCTL_ZERO, 2147 }, 2148 #endif 2149 #ifdef CONFIG_NUMA 2150 { 2151 .procname = "zone_reclaim_mode", 2152 .data = &node_reclaim_mode, 2153 .maxlen = sizeof(node_reclaim_mode), 2154 .mode = 0644, 2155 .proc_handler = proc_dointvec_minmax, 2156 .extra1 = SYSCTL_ZERO, 2157 }, 2158 #endif 2159 #ifdef CONFIG_SMP 2160 { 2161 .procname = "stat_interval", 2162 .data = &sysctl_stat_interval, 2163 .maxlen = sizeof(sysctl_stat_interval), 2164 .mode = 0644, 2165 .proc_handler = proc_dointvec_jiffies, 2166 }, 2167 { 2168 .procname = "stat_refresh", 2169 .data = NULL, 2170 .maxlen = 0, 2171 .mode = 0600, 2172 .proc_handler = vmstat_refresh, 2173 }, 2174 #endif 2175 #ifdef CONFIG_MMU 2176 { 2177 .procname = "mmap_min_addr", 2178 .data = &dac_mmap_min_addr, 2179 .maxlen = sizeof(unsigned long), 2180 .mode = 0644, 2181 .proc_handler = mmap_min_addr_handler, 2182 }, 2183 #endif 2184 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \ 2185 (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL)) 2186 { 2187 .procname = "vdso_enabled", 2188 #ifdef CONFIG_X86_32 2189 .data = &vdso32_enabled, 2190 .maxlen = sizeof(vdso32_enabled), 2191 #else 2192 .data = &vdso_enabled, 2193 .maxlen = sizeof(vdso_enabled), 2194 #endif 2195 .mode = 0644, 2196 .proc_handler = proc_dointvec, 2197 .extra1 = SYSCTL_ZERO, 2198 }, 2199 #endif 2200 { 2201 .procname = "user_reserve_kbytes", 2202 .data = &sysctl_user_reserve_kbytes, 2203 .maxlen = sizeof(sysctl_user_reserve_kbytes), 2204 .mode = 0644, 2205 .proc_handler = proc_doulongvec_minmax, 2206 }, 2207 { 2208 .procname = "admin_reserve_kbytes", 2209 .data = &sysctl_admin_reserve_kbytes, 2210 .maxlen = sizeof(sysctl_admin_reserve_kbytes), 2211 .mode = 0644, 2212 .proc_handler = proc_doulongvec_minmax, 2213 }, 2214 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS 2215 { 2216 .procname = "mmap_rnd_bits", 2217 .data = &mmap_rnd_bits, 2218 .maxlen = sizeof(mmap_rnd_bits), 2219 .mode = 0600, 2220 .proc_handler = proc_dointvec_minmax, 2221 .extra1 = (void *)&mmap_rnd_bits_min, 2222 .extra2 = (void *)&mmap_rnd_bits_max, 2223 }, 2224 #endif 2225 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS 2226 { 2227 .procname = "mmap_rnd_compat_bits", 2228 .data = &mmap_rnd_compat_bits, 2229 .maxlen = sizeof(mmap_rnd_compat_bits), 2230 .mode = 0600, 2231 .proc_handler = proc_dointvec_minmax, 2232 .extra1 = (void *)&mmap_rnd_compat_bits_min, 2233 .extra2 = (void *)&mmap_rnd_compat_bits_max, 2234 }, 2235 #endif 2236 }; 2237 2238 int __init sysctl_init_bases(void) 2239 { 2240 register_sysctl_init("kernel", kern_table); 2241 register_sysctl_init("vm", vm_table); 2242 2243 return 0; 2244 } 2245 #endif /* CONFIG_SYSCTL */ 2246 /* 2247 * No sense putting this after each symbol definition, twice, 2248 * exception granted :-) 2249 */ 2250 EXPORT_SYMBOL(proc_dobool); 2251 EXPORT_SYMBOL(proc_dointvec); 2252 EXPORT_SYMBOL(proc_douintvec); 2253 EXPORT_SYMBOL(proc_dointvec_jiffies); 2254 EXPORT_SYMBOL(proc_dointvec_minmax); 2255 EXPORT_SYMBOL_GPL(proc_douintvec_minmax); 2256 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies); 2257 EXPORT_SYMBOL(proc_dointvec_ms_jiffies); 2258 EXPORT_SYMBOL(proc_dostring); 2259 EXPORT_SYMBOL(proc_doulongvec_minmax); 2260 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax); 2261 EXPORT_SYMBOL(proc_do_large_bitmap); 2262