kernel/sysctl.c

   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(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                                            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(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, 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(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                                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, 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(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(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(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(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(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(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, &param);
 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(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, &param);
 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(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 (min > 255U)
 983                         return -EINVAL;
 984         }
 985         if (table->extra2) {
 986                 max = *(unsigned int *) table->extra2;
 987                 if (max > 255U)
 988                         return -EINVAL;
 989         }
 990
 991         tmp = *table;
 992
 993         tmp.maxlen = sizeof(val);
 994         tmp.data = &val;
 995         val = READ_ONCE(*data);
 996         res = do_proc_douintvec(&tmp, write, buffer, lenp, ppos,
 997                                 do_proc_douintvec_minmax_conv, &param);
 998         if (res)
 999                 return res;
1000         if (write)
1001                 WRITE_ONCE(*data, val);
1002         return 0;
1003 }
1004 EXPORT_SYMBOL_GPL(proc_dou8vec_minmax);
1005
1006 #ifdef CONFIG_MAGIC_SYSRQ
1007 static int sysrq_sysctl_handler(struct ctl_table *table, int write,
1008                                 void *buffer, size_t *lenp, loff_t *ppos)
1009 {
1010         int tmp, ret;
1011
1012         tmp = sysrq_mask();
1013
1014         ret = __do_proc_dointvec(&tmp, table, write, buffer,
1015                                lenp, ppos, NULL, NULL);
1016         if (ret || !write)
1017                 return ret;
1018
1019         if (write)
1020                 sysrq_toggle_support(tmp);
1021
1022         return 0;
1023 }
1024 #endif
1025
1026 static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table,
1027                 int write, void *buffer, size_t *lenp, loff_t *ppos,
1028                 unsigned long convmul, unsigned long convdiv)
1029 {
1030         unsigned long *i, *min, *max;
1031         int vleft, first = 1, err = 0;
1032         size_t left;
1033         char *p;
1034
1035         if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
1036                 *lenp = 0;
1037                 return 0;
1038         }
1039
1040         i = data;
1041         min = table->extra1;
1042         max = table->extra2;
1043         vleft = table->maxlen / sizeof(unsigned long);
1044         left = *lenp;
1045
1046         if (write) {
1047                 if (proc_first_pos_non_zero_ignore(ppos, table))
1048                         goto out;
1049
1050                 if (left > PAGE_SIZE - 1)
1051                         left = PAGE_SIZE - 1;
1052                 p = buffer;
1053         }
1054
1055         for (; left && vleft--; i++, first = 0) {
1056                 unsigned long val;
1057
1058                 if (write) {
1059                         bool neg;
1060
1061                         proc_skip_spaces(&p, &left);
1062                         if (!left)
1063                                 break;
1064
1065                         err = proc_get_long(&p, &left, &val, &neg,
1066                                              proc_wspace_sep,
1067                                              sizeof(proc_wspace_sep), NULL);
1068                         if (err || neg) {
1069                                 err = -EINVAL;
1070                                 break;
1071                         }
1072
1073                         val = convmul * val / convdiv;
1074                         if ((min && val < *min) || (max && val > *max)) {
1075                                 err = -EINVAL;
1076                                 break;
1077                         }
1078                         WRITE_ONCE(*i, val);
1079                 } else {
1080                         val = convdiv * READ_ONCE(*i) / convmul;
1081                         if (!first)
1082                                 proc_put_char(&buffer, &left, '\t');
1083                         proc_put_long(&buffer, &left, val, false);
1084                 }
1085         }
1086
1087         if (!write && !first && left && !err)
1088                 proc_put_char(&buffer, &left, '\n');
1089         if (write && !err)
1090                 proc_skip_spaces(&p, &left);
1091         if (write && first)
1092                 return err ? : -EINVAL;
1093         *lenp -= left;
1094 out:
1095         *ppos += *lenp;
1096         return err;
1097 }
1098
1099 static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
1100                 void *buffer, size_t *lenp, loff_t *ppos, unsigned long convmul,
1101                 unsigned long convdiv)
1102 {
1103         return __do_proc_doulongvec_minmax(table->data, table, write,
1104                         buffer, lenp, ppos, convmul, convdiv);
1105 }
1106
1107 /**
1108  * proc_doulongvec_minmax - read a vector of long integers with min/max values
1109  * @table: the sysctl table
1110  * @write: %TRUE if this is a write to the sysctl file
1111  * @buffer: the user buffer
1112  * @lenp: the size of the user buffer
1113  * @ppos: file position
1114  *
1115  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1116  * values from/to the user buffer, treated as an ASCII string.
1117  *
1118  * This routine will ensure the values are within the range specified by
1119  * table->extra1 (min) and table->extra2 (max).
1120  *
1121  * Returns 0 on success.
1122  */
1123 int proc_doulongvec_minmax(struct ctl_table *table, int write,
1124                            void *buffer, size_t *lenp, loff_t *ppos)
1125 {
1126     return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
1127 }
1128
1129 /**
1130  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
1131  * @table: the sysctl table
1132  * @write: %TRUE if this is a write to the sysctl file
1133  * @buffer: the user buffer
1134  * @lenp: the size of the user buffer
1135  * @ppos: file position
1136  *
1137  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1138  * values from/to the user buffer, treated as an ASCII string. The values
1139  * are treated as milliseconds, and converted to jiffies when they are stored.
1140  *
1141  * This routine will ensure the values are within the range specified by
1142  * table->extra1 (min) and table->extra2 (max).
1143  *
1144  * Returns 0 on success.
1145  */
1146 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1147                                       void *buffer, size_t *lenp, loff_t *ppos)
1148 {
1149     return do_proc_doulongvec_minmax(table, write, buffer,
1150                                      lenp, ppos, HZ, 1000l);
1151 }
1152
1153
1154 static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
1155                                          int *valp,
1156                                          int write, void *data)
1157 {
1158         if (write) {
1159                 if (*lvalp > INT_MAX / HZ)
1160                         return 1;
1161                 if (*negp)
1162                         WRITE_ONCE(*valp, -*lvalp * HZ);
1163                 else
1164                         WRITE_ONCE(*valp, *lvalp * HZ);
1165         } else {
1166                 int val = READ_ONCE(*valp);
1167                 unsigned long lval;
1168                 if (val < 0) {
1169                         *negp = true;
1170                         lval = -(unsigned long)val;
1171                 } else {
1172                         *negp = false;
1173                         lval = (unsigned long)val;
1174                 }
1175                 *lvalp = lval / HZ;
1176         }
1177         return 0;
1178 }
1179
1180 static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
1181                                                 int *valp,
1182                                                 int write, void *data)
1183 {
1184         if (write) {
1185                 if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
1186                         return 1;
1187                 *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
1188         } else {
1189                 int val = *valp;
1190                 unsigned long lval;
1191                 if (val < 0) {
1192                         *negp = true;
1193                         lval = -(unsigned long)val;
1194                 } else {
1195                         *negp = false;
1196                         lval = (unsigned long)val;
1197                 }
1198                 *lvalp = jiffies_to_clock_t(lval);
1199         }
1200         return 0;
1201 }
1202
1203 static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
1204                                             int *valp,
1205                                             int write, void *data)
1206 {
1207         if (write) {
1208                 unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
1209
1210                 if (jif > INT_MAX)
1211                         return 1;
1212                 WRITE_ONCE(*valp, (int)jif);
1213         } else {
1214                 int val = READ_ONCE(*valp);
1215                 unsigned long lval;
1216                 if (val < 0) {
1217                         *negp = true;
1218                         lval = -(unsigned long)val;
1219                 } else {
1220                         *negp = false;
1221                         lval = (unsigned long)val;
1222                 }
1223                 *lvalp = jiffies_to_msecs(lval);
1224         }
1225         return 0;
1226 }
1227
1228 static int do_proc_dointvec_ms_jiffies_minmax_conv(bool *negp, unsigned long *lvalp,
1229                                                 int *valp, int write, void *data)
1230 {
1231         int tmp, ret;
1232         struct do_proc_dointvec_minmax_conv_param *param = data;
1233         /*
1234          * If writing, first do so via a temporary local int so we can
1235          * bounds-check it before touching *valp.
1236          */
1237         int *ip = write ? &tmp : valp;
1238
1239         ret = do_proc_dointvec_ms_jiffies_conv(negp, lvalp, ip, write, data);
1240         if (ret)
1241                 return ret;
1242
1243         if (write) {
1244                 if ((param->min && *param->min > tmp) ||
1245                                 (param->max && *param->max < tmp))
1246                         return -EINVAL;
1247                 *valp = tmp;
1248         }
1249         return 0;
1250 }
1251
1252 /**
1253  * proc_dointvec_jiffies - read a vector of integers as seconds
1254  * @table: the sysctl table
1255  * @write: %TRUE if this is a write to the sysctl file
1256  * @buffer: the user buffer
1257  * @lenp: the size of the user buffer
1258  * @ppos: file position
1259  *
1260  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1261  * values from/to the user buffer, treated as an ASCII string.
1262  * The values read are assumed to be in seconds, and are converted into
1263  * jiffies.
1264  *
1265  * Returns 0 on success.
1266  */
1267 int proc_dointvec_jiffies(struct ctl_table *table, int write,
1268                           void *buffer, size_t *lenp, loff_t *ppos)
1269 {
1270     return do_proc_dointvec(table,write,buffer,lenp,ppos,
1271                             do_proc_dointvec_jiffies_conv,NULL);
1272 }
1273
1274 int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1275                           void *buffer, size_t *lenp, loff_t *ppos)
1276 {
1277         struct do_proc_dointvec_minmax_conv_param param = {
1278                 .min = (int *) table->extra1,
1279                 .max = (int *) table->extra2,
1280         };
1281         return do_proc_dointvec(table, write, buffer, lenp, ppos,
1282                         do_proc_dointvec_ms_jiffies_minmax_conv, &param);
1283 }
1284
1285 /**
1286  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
1287  * @table: the sysctl table
1288  * @write: %TRUE if this is a write to the sysctl file
1289  * @buffer: the user buffer
1290  * @lenp: the size of the user buffer
1291  * @ppos: pointer to the file position
1292  *
1293  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1294  * values from/to the user buffer, treated as an ASCII string.
1295  * The values read are assumed to be in 1/USER_HZ seconds, and
1296  * are converted into jiffies.
1297  *
1298  * Returns 0 on success.
1299  */
1300 int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1301                                  void *buffer, size_t *lenp, loff_t *ppos)
1302 {
1303         return do_proc_dointvec(table, write, buffer, lenp, ppos,
1304                                 do_proc_dointvec_userhz_jiffies_conv, NULL);
1305 }
1306
1307 /**
1308  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
1309  * @table: the sysctl table
1310  * @write: %TRUE if this is a write to the sysctl file
1311  * @buffer: the user buffer
1312  * @lenp: the size of the user buffer
1313  * @ppos: file position
1314  * @ppos: the current position in the file
1315  *
1316  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1317  * values from/to the user buffer, treated as an ASCII string.
1318  * The values read are assumed to be in 1/1000 seconds, and
1319  * are converted into jiffies.
1320  *
1321  * Returns 0 on success.
1322  */
1323 int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer,
1324                 size_t *lenp, loff_t *ppos)
1325 {
1326         return do_proc_dointvec(table, write, buffer, lenp, ppos,
1327                                 do_proc_dointvec_ms_jiffies_conv, NULL);
1328 }
1329
1330 static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer,
1331                 size_t *lenp, loff_t *ppos)
1332 {
1333         struct pid *new_pid;
1334         pid_t tmp;
1335         int r;
1336
1337         tmp = pid_vnr(cad_pid);
1338
1339         r = __do_proc_dointvec(&tmp, table, write, buffer,
1340                                lenp, ppos, NULL, NULL);
1341         if (r || !write)
1342                 return r;
1343
1344         new_pid = find_get_pid(tmp);
1345         if (!new_pid)
1346                 return -ESRCH;
1347
1348         put_pid(xchg(&cad_pid, new_pid));
1349         return 0;
1350 }
1351
1352 /**
1353  * proc_do_large_bitmap - read/write from/to a large bitmap
1354  * @table: the sysctl table
1355  * @write: %TRUE if this is a write to the sysctl file
1356  * @buffer: the user buffer
1357  * @lenp: the size of the user buffer
1358  * @ppos: file position
1359  *
1360  * The bitmap is stored at table->data and the bitmap length (in bits)
1361  * in table->maxlen.
1362  *
1363  * We use a range comma separated format (e.g. 1,3-4,10-10) so that
1364  * large bitmaps may be represented in a compact manner. Writing into
1365  * the file will clear the bitmap then update it with the given input.
1366  *
1367  * Returns 0 on success.
1368  */
1369 int proc_do_large_bitmap(struct ctl_table *table, int write,
1370                          void *buffer, size_t *lenp, loff_t *ppos)
1371 {
1372         int err = 0;
1373         size_t left = *lenp;
1374         unsigned long bitmap_len = table->maxlen;
1375         unsigned long *bitmap = *(unsigned long **) table->data;
1376         unsigned long *tmp_bitmap = NULL;
1377         char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
1378
1379         if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
1380                 *lenp = 0;
1381                 return 0;
1382         }
1383
1384         if (write) {
1385                 char *p = buffer;
1386                 size_t skipped = 0;
1387
1388                 if (left > PAGE_SIZE - 1) {
1389                         left = PAGE_SIZE - 1;
1390                         /* How much of the buffer we'll skip this pass */
1391                         skipped = *lenp - left;
1392                 }
1393
1394                 tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL);
1395                 if (!tmp_bitmap)
1396                         return -ENOMEM;
1397                 proc_skip_char(&p, &left, '\n');
1398                 while (!err && left) {
1399                         unsigned long val_a, val_b;
1400                         bool neg;
1401                         size_t saved_left;
1402
1403                         /* In case we stop parsing mid-number, we can reset */
1404                         saved_left = left;
1405                         err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
1406                                              sizeof(tr_a), &c);
1407                         /*
1408                          * If we consumed the entirety of a truncated buffer or
1409                          * only one char is left (may be a "-"), then stop here,
1410                          * reset, & come back for more.
1411                          */
1412                         if ((left <= 1) && skipped) {
1413                                 left = saved_left;
1414                                 break;
1415                         }
1416
1417                         if (err)
1418                                 break;
1419                         if (val_a >= bitmap_len || neg) {
1420                                 err = -EINVAL;
1421                                 break;
1422                         }
1423
1424                         val_b = val_a;
1425                         if (left) {
1426                                 p++;
1427                                 left--;
1428                         }
1429
1430                         if (c == '-') {
1431                                 err = proc_get_long(&p, &left, &val_b,
1432                                                      &neg, tr_b, sizeof(tr_b),
1433                                                      &c);
1434                                 /*
1435                                  * If we consumed all of a truncated buffer or
1436                                  * then stop here, reset, & come back for more.
1437                                  */
1438                                 if (!left && skipped) {
1439                                         left = saved_left;
1440                                         break;
1441                                 }
1442
1443                                 if (err)
1444                                         break;
1445                                 if (val_b >= bitmap_len || neg ||
1446                                     val_a > val_b) {
1447                                         err = -EINVAL;
1448                                         break;
1449                                 }
1450                                 if (left) {
1451                                         p++;
1452                                         left--;
1453                                 }
1454                         }
1455
1456                         bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
1457                         proc_skip_char(&p, &left, '\n');
1458                 }
1459                 left += skipped;
1460         } else {
1461                 unsigned long bit_a, bit_b = 0;
1462                 bool first = 1;
1463
1464                 while (left) {
1465                         bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
1466                         if (bit_a >= bitmap_len)
1467                                 break;
1468                         bit_b = find_next_zero_bit(bitmap, bitmap_len,
1469                                                    bit_a + 1) - 1;
1470
1471                         if (!first)
1472                                 proc_put_char(&buffer, &left, ',');
1473                         proc_put_long(&buffer, &left, bit_a, false);
1474                         if (bit_a != bit_b) {
1475                                 proc_put_char(&buffer, &left, '-');
1476                                 proc_put_long(&buffer, &left, bit_b, false);
1477                         }
1478
1479                         first = 0; bit_b++;
1480                 }
1481                 proc_put_char(&buffer, &left, '\n');
1482         }
1483
1484         if (!err) {
1485                 if (write) {
1486                         if (*ppos)
1487                                 bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
1488                         else
1489                                 bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
1490                 }
1491                 *lenp -= left;
1492                 *ppos += *lenp;
1493         }
1494
1495         bitmap_free(tmp_bitmap);
1496         return err;
1497 }
1498
1499 #else /* CONFIG_PROC_SYSCTL */
1500
1501 int proc_dostring(struct ctl_table *table, int write,
1502                   void *buffer, size_t *lenp, loff_t *ppos)
1503 {
1504         return -ENOSYS;
1505 }
1506
1507 int proc_dobool(struct ctl_table *table, int write,
1508                 void *buffer, size_t *lenp, loff_t *ppos)
1509 {
1510         return -ENOSYS;
1511 }
1512
1513 int proc_dointvec(struct ctl_table *table, int write,
1514                   void *buffer, size_t *lenp, loff_t *ppos)
1515 {
1516         return -ENOSYS;
1517 }
1518
1519 int proc_douintvec(struct ctl_table *table, int write,
1520                   void *buffer, size_t *lenp, loff_t *ppos)
1521 {
1522         return -ENOSYS;
1523 }
1524
1525 int proc_dointvec_minmax(struct ctl_table *table, int write,
1526                     void *buffer, size_t *lenp, loff_t *ppos)
1527 {
1528         return -ENOSYS;
1529 }
1530
1531 int proc_douintvec_minmax(struct ctl_table *table, int write,
1532                           void *buffer, size_t *lenp, loff_t *ppos)
1533 {
1534         return -ENOSYS;
1535 }
1536
1537 int proc_dou8vec_minmax(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_jiffies(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_ms_jiffies_minmax(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_userhz_jiffies(struct ctl_table *table, int write,
1556                     void *buffer, size_t *lenp, loff_t *ppos)
1557 {
1558         return -ENOSYS;
1559 }
1560
1561 int proc_dointvec_ms_jiffies(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_minmax(struct ctl_table *table, int write,
1568                     void *buffer, size_t *lenp, loff_t *ppos)
1569 {
1570         return -ENOSYS;
1571 }
1572
1573 int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1574                                       void *buffer, size_t *lenp, loff_t *ppos)
1575 {
1576         return -ENOSYS;
1577 }
1578
1579 int proc_do_large_bitmap(struct ctl_table *table, int write,
1580                          void *buffer, size_t *lenp, loff_t *ppos)
1581 {
1582         return -ENOSYS;
1583 }
1584
1585 #endif /* CONFIG_PROC_SYSCTL */
1586
1587 #if defined(CONFIG_SYSCTL)
1588 int proc_do_static_key(struct ctl_table *table, int write,
1589                        void *buffer, size_t *lenp, loff_t *ppos)
1590 {
1591         struct static_key *key = (struct static_key *)table->data;
1592         static DEFINE_MUTEX(static_key_mutex);
1593         int val, ret;
1594         struct ctl_table tmp = {
1595                 .data   = &val,
1596                 .maxlen = sizeof(val),
1597                 .mode   = table->mode,
1598                 .extra1 = SYSCTL_ZERO,
1599                 .extra2 = SYSCTL_ONE,
1600         };
1601
1602         if (write && !capable(CAP_SYS_ADMIN))
1603                 return -EPERM;
1604
1605         mutex_lock(&static_key_mutex);
1606         val = static_key_enabled(key);
1607         ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
1608         if (write && !ret) {
1609                 if (val)
1610                         static_key_enable(key);
1611                 else
1612                         static_key_disable(key);
1613         }
1614         mutex_unlock(&static_key_mutex);
1615         return ret;
1616 }
1617
1618 static struct ctl_table kern_table[] = {
1619         {
1620                 .procname       = "panic",
1621                 .data           = &panic_timeout,
1622                 .maxlen         = sizeof(int),
1623                 .mode           = 0644,
1624                 .proc_handler   = proc_dointvec,
1625         },
1626 #ifdef CONFIG_PROC_SYSCTL
1627         {
1628                 .procname       = "tainted",
1629                 .maxlen         = sizeof(long),
1630                 .mode           = 0644,
1631                 .proc_handler   = proc_taint,
1632         },
1633         {
1634                 .procname       = "sysctl_writes_strict",
1635                 .data           = &sysctl_writes_strict,
1636                 .maxlen         = sizeof(int),
1637                 .mode           = 0644,
1638                 .proc_handler   = proc_dointvec_minmax,
1639                 .extra1         = SYSCTL_NEG_ONE,
1640                 .extra2         = SYSCTL_ONE,
1641         },
1642 #endif
1643         {
1644                 .procname       = "print-fatal-signals",
1645                 .data           = &print_fatal_signals,
1646                 .maxlen         = sizeof(int),
1647                 .mode           = 0644,
1648                 .proc_handler   = proc_dointvec,
1649         },
1650 #ifdef CONFIG_SPARC
1651         {
1652                 .procname       = "reboot-cmd",
1653                 .data           = reboot_command,
1654                 .maxlen         = 256,
1655                 .mode           = 0644,
1656                 .proc_handler   = proc_dostring,
1657         },
1658         {
1659                 .procname       = "stop-a",
1660                 .data           = &stop_a_enabled,
1661                 .maxlen         = sizeof (int),
1662                 .mode           = 0644,
1663                 .proc_handler   = proc_dointvec,
1664         },
1665         {
1666                 .procname       = "scons-poweroff",
1667                 .data           = &scons_pwroff,
1668                 .maxlen         = sizeof (int),
1669                 .mode           = 0644,
1670                 .proc_handler   = proc_dointvec,
1671         },
1672 #endif
1673 #ifdef CONFIG_SPARC64
1674         {
1675                 .procname       = "tsb-ratio",
1676                 .data           = &sysctl_tsb_ratio,
1677                 .maxlen         = sizeof (int),
1678                 .mode           = 0644,
1679                 .proc_handler   = proc_dointvec,
1680         },
1681 #endif
1682 #ifdef CONFIG_PARISC
1683         {
1684                 .procname       = "soft-power",
1685                 .data           = &pwrsw_enabled,
1686                 .maxlen         = sizeof (int),
1687                 .mode           = 0644,
1688                 .proc_handler   = proc_dointvec,
1689         },
1690 #endif
1691 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1692         {
1693                 .procname       = "unaligned-trap",
1694                 .data           = &unaligned_enabled,
1695                 .maxlen         = sizeof (int),
1696                 .mode           = 0644,
1697                 .proc_handler   = proc_dointvec,
1698         },
1699 #endif
1700 #ifdef CONFIG_STACK_TRACER
1701         {
1702                 .procname       = "stack_tracer_enabled",
1703                 .data           = &stack_tracer_enabled,
1704                 .maxlen         = sizeof(int),
1705                 .mode           = 0644,
1706                 .proc_handler   = stack_trace_sysctl,
1707         },
1708 #endif
1709 #ifdef CONFIG_TRACING
1710         {
1711                 .procname       = "ftrace_dump_on_oops",
1712                 .data           = &ftrace_dump_on_oops,
1713                 .maxlen         = sizeof(int),
1714                 .mode           = 0644,
1715                 .proc_handler   = proc_dointvec,
1716         },
1717         {
1718                 .procname       = "traceoff_on_warning",
1719                 .data           = &__disable_trace_on_warning,
1720                 .maxlen         = sizeof(__disable_trace_on_warning),
1721                 .mode           = 0644,
1722                 .proc_handler   = proc_dointvec,
1723         },
1724         {
1725                 .procname       = "tracepoint_printk",
1726                 .data           = &tracepoint_printk,
1727                 .maxlen         = sizeof(tracepoint_printk),
1728                 .mode           = 0644,
1729                 .proc_handler   = tracepoint_printk_sysctl,
1730         },
1731 #endif
1732 #ifdef CONFIG_MODULES
1733         {
1734                 .procname       = "modprobe",
1735                 .data           = &modprobe_path,
1736                 .maxlen         = KMOD_PATH_LEN,
1737                 .mode           = 0644,
1738                 .proc_handler   = proc_dostring,
1739         },
1740         {
1741                 .procname       = "modules_disabled",
1742                 .data           = &modules_disabled,
1743                 .maxlen         = sizeof(int),
1744                 .mode           = 0644,
1745                 /* only handle a transition from default "0" to "1" */
1746                 .proc_handler   = proc_dointvec_minmax,
1747                 .extra1         = SYSCTL_ONE,
1748                 .extra2         = SYSCTL_ONE,
1749         },
1750 #endif
1751 #ifdef CONFIG_UEVENT_HELPER
1752         {
1753                 .procname       = "hotplug",
1754                 .data           = &uevent_helper,
1755                 .maxlen         = UEVENT_HELPER_PATH_LEN,
1756                 .mode           = 0644,
1757                 .proc_handler   = proc_dostring,
1758         },
1759 #endif
1760 #ifdef CONFIG_MAGIC_SYSRQ
1761         {
1762                 .procname       = "sysrq",
1763                 .data           = NULL,
1764                 .maxlen         = sizeof (int),
1765                 .mode           = 0644,
1766                 .proc_handler   = sysrq_sysctl_handler,
1767         },
1768 #endif
1769 #ifdef CONFIG_PROC_SYSCTL
1770         {
1771                 .procname       = "cad_pid",
1772                 .data           = NULL,
1773                 .maxlen         = sizeof (int),
1774                 .mode           = 0600,
1775                 .proc_handler   = proc_do_cad_pid,
1776         },
1777 #endif
1778         {
1779                 .procname       = "threads-max",
1780                 .data           = NULL,
1781                 .maxlen         = sizeof(int),
1782                 .mode           = 0644,
1783                 .proc_handler   = sysctl_max_threads,
1784         },
1785         {
1786                 .procname       = "overflowuid",
1787                 .data           = &overflowuid,
1788                 .maxlen         = sizeof(int),
1789                 .mode           = 0644,
1790                 .proc_handler   = proc_dointvec_minmax,
1791                 .extra1         = SYSCTL_ZERO,
1792                 .extra2         = SYSCTL_MAXOLDUID,
1793         },
1794         {
1795                 .procname       = "overflowgid",
1796                 .data           = &overflowgid,
1797                 .maxlen         = sizeof(int),
1798                 .mode           = 0644,
1799                 .proc_handler   = proc_dointvec_minmax,
1800                 .extra1         = SYSCTL_ZERO,
1801                 .extra2         = SYSCTL_MAXOLDUID,
1802         },
1803 #ifdef CONFIG_S390
1804         {
1805                 .procname       = "userprocess_debug",
1806                 .data           = &show_unhandled_signals,
1807                 .maxlen         = sizeof(int),
1808                 .mode           = 0644,
1809                 .proc_handler   = proc_dointvec,
1810         },
1811 #endif
1812         {
1813                 .procname       = "pid_max",
1814                 .data           = &pid_max,
1815                 .maxlen         = sizeof (int),
1816                 .mode           = 0644,
1817                 .proc_handler   = proc_dointvec_minmax,
1818                 .extra1         = &pid_max_min,
1819                 .extra2         = &pid_max_max,
1820         },
1821         {
1822                 .procname       = "panic_on_oops",
1823                 .data           = &panic_on_oops,
1824                 .maxlen         = sizeof(int),
1825                 .mode           = 0644,
1826                 .proc_handler   = proc_dointvec,
1827         },
1828         {
1829                 .procname       = "panic_print",
1830                 .data           = &panic_print,
1831                 .maxlen         = sizeof(unsigned long),
1832                 .mode           = 0644,
1833                 .proc_handler   = proc_doulongvec_minmax,
1834         },
1835         {
1836                 .procname       = "ngroups_max",
1837                 .data           = (void *)&ngroups_max,
1838                 .maxlen         = sizeof (int),
1839                 .mode           = 0444,
1840                 .proc_handler   = proc_dointvec,
1841         },
1842         {
1843                 .procname       = "cap_last_cap",
1844                 .data           = (void *)&cap_last_cap,
1845                 .maxlen         = sizeof(int),
1846                 .mode           = 0444,
1847                 .proc_handler   = proc_dointvec,
1848         },
1849 #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
1850         {
1851                 .procname       = "unknown_nmi_panic",
1852                 .data           = &unknown_nmi_panic,
1853                 .maxlen         = sizeof (int),
1854                 .mode           = 0644,
1855                 .proc_handler   = proc_dointvec,
1856         },
1857 #endif
1858
1859 #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \
1860         defined(CONFIG_DEBUG_STACKOVERFLOW)
1861         {
1862                 .procname       = "panic_on_stackoverflow",
1863                 .data           = &sysctl_panic_on_stackoverflow,
1864                 .maxlen         = sizeof(int),
1865                 .mode           = 0644,
1866                 .proc_handler   = proc_dointvec,
1867         },
1868 #endif
1869 #if defined(CONFIG_X86)
1870         {
1871                 .procname       = "panic_on_unrecovered_nmi",
1872                 .data           = &panic_on_unrecovered_nmi,
1873                 .maxlen         = sizeof(int),
1874                 .mode           = 0644,
1875                 .proc_handler   = proc_dointvec,
1876         },
1877         {
1878                 .procname       = "panic_on_io_nmi",
1879                 .data           = &panic_on_io_nmi,
1880                 .maxlen         = sizeof(int),
1881                 .mode           = 0644,
1882                 .proc_handler   = proc_dointvec,
1883         },
1884         {
1885                 .procname       = "bootloader_type",
1886                 .data           = &bootloader_type,
1887                 .maxlen         = sizeof (int),
1888                 .mode           = 0444,
1889                 .proc_handler   = proc_dointvec,
1890         },
1891         {
1892                 .procname       = "bootloader_version",
1893                 .data           = &bootloader_version,
1894                 .maxlen         = sizeof (int),
1895                 .mode           = 0444,
1896                 .proc_handler   = proc_dointvec,
1897         },
1898         {
1899                 .procname       = "io_delay_type",
1900                 .data           = &io_delay_type,
1901                 .maxlen         = sizeof(int),
1902                 .mode           = 0644,
1903                 .proc_handler   = proc_dointvec,
1904         },
1905 #endif
1906 #if defined(CONFIG_MMU)
1907         {
1908                 .procname       = "randomize_va_space",
1909                 .data           = &randomize_va_space,
1910                 .maxlen         = sizeof(int),
1911                 .mode           = 0644,
1912                 .proc_handler   = proc_dointvec,
1913         },
1914 #endif
1915 #if defined(CONFIG_S390) && defined(CONFIG_SMP)
1916         {
1917                 .procname       = "spin_retry",
1918                 .data           = &spin_retry,
1919                 .maxlen         = sizeof (int),
1920                 .mode           = 0644,
1921                 .proc_handler   = proc_dointvec,
1922         },
1923 #endif
1924 #if     defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
1925         {
1926                 .procname       = "acpi_video_flags",
1927                 .data           = &acpi_realmode_flags,
1928                 .maxlen         = sizeof (unsigned long),
1929                 .mode           = 0644,
1930                 .proc_handler   = proc_doulongvec_minmax,
1931         },
1932 #endif
1933 #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1934         {
1935                 .procname       = "ignore-unaligned-usertrap",
1936                 .data           = &no_unaligned_warning,
1937                 .maxlen         = sizeof (int),
1938                 .mode           = 0644,
1939                 .proc_handler   = proc_dointvec,
1940         },
1941 #endif
1942 #ifdef CONFIG_IA64
1943         {
1944                 .procname       = "unaligned-dump-stack",
1945                 .data           = &unaligned_dump_stack,
1946                 .maxlen         = sizeof (int),
1947                 .mode           = 0644,
1948                 .proc_handler   = proc_dointvec,
1949         },
1950 #endif
1951 #ifdef CONFIG_RT_MUTEXES
1952         {
1953                 .procname       = "max_lock_depth",
1954                 .data           = &max_lock_depth,
1955                 .maxlen         = sizeof(int),
1956                 .mode           = 0644,
1957                 .proc_handler   = proc_dointvec,
1958         },
1959 #endif
1960 #ifdef CONFIG_PERF_EVENTS
1961         /*
1962          * User-space scripts rely on the existence of this file
1963          * as a feature check for perf_events being enabled.
1964          *
1965          * So it's an ABI, do not remove!
1966          */
1967         {
1968                 .procname       = "perf_event_paranoid",
1969                 .data           = &sysctl_perf_event_paranoid,
1970                 .maxlen         = sizeof(sysctl_perf_event_paranoid),
1971                 .mode           = 0644,
1972                 .proc_handler   = proc_dointvec,
1973         },
1974         {
1975                 .procname       = "perf_event_mlock_kb",
1976                 .data           = &sysctl_perf_event_mlock,
1977                 .maxlen         = sizeof(sysctl_perf_event_mlock),
1978                 .mode           = 0644,
1979                 .proc_handler   = proc_dointvec,
1980         },
1981         {
1982                 .procname       = "perf_event_max_sample_rate",
1983                 .data           = &sysctl_perf_event_sample_rate,
1984                 .maxlen         = sizeof(sysctl_perf_event_sample_rate),
1985                 .mode           = 0644,
1986                 .proc_handler   = perf_proc_update_handler,
1987                 .extra1         = SYSCTL_ONE,
1988         },
1989         {
1990                 .procname       = "perf_cpu_time_max_percent",
1991                 .data           = &sysctl_perf_cpu_time_max_percent,
1992                 .maxlen         = sizeof(sysctl_perf_cpu_time_max_percent),
1993                 .mode           = 0644,
1994                 .proc_handler   = perf_cpu_time_max_percent_handler,
1995                 .extra1         = SYSCTL_ZERO,
1996                 .extra2         = SYSCTL_ONE_HUNDRED,
1997         },
1998         {
1999                 .procname       = "perf_event_max_stack",
2000                 .data           = &sysctl_perf_event_max_stack,
2001                 .maxlen         = sizeof(sysctl_perf_event_max_stack),
2002                 .mode           = 0644,
2003                 .proc_handler   = perf_event_max_stack_handler,
2004                 .extra1         = SYSCTL_ZERO,
2005                 .extra2         = (void *)&six_hundred_forty_kb,
2006         },
2007         {
2008                 .procname       = "perf_event_max_contexts_per_stack",
2009                 .data           = &sysctl_perf_event_max_contexts_per_stack,
2010                 .maxlen         = sizeof(sysctl_perf_event_max_contexts_per_stack),
2011                 .mode           = 0644,
2012                 .proc_handler   = perf_event_max_stack_handler,
2013                 .extra1         = SYSCTL_ZERO,
2014                 .extra2         = SYSCTL_ONE_THOUSAND,
2015         },
2016 #endif
2017         {
2018                 .procname       = "panic_on_warn",
2019                 .data           = &panic_on_warn,
2020                 .maxlen         = sizeof(int),
2021                 .mode           = 0644,
2022                 .proc_handler   = proc_dointvec_minmax,
2023                 .extra1         = SYSCTL_ZERO,
2024                 .extra2         = SYSCTL_ONE,
2025         },
2026 #ifdef CONFIG_TREE_RCU
2027         {
2028                 .procname       = "panic_on_rcu_stall",
2029                 .data           = &sysctl_panic_on_rcu_stall,
2030                 .maxlen         = sizeof(sysctl_panic_on_rcu_stall),
2031                 .mode           = 0644,
2032                 .proc_handler   = proc_dointvec_minmax,
2033                 .extra1         = SYSCTL_ZERO,
2034                 .extra2         = SYSCTL_ONE,
2035         },
2036         {
2037                 .procname       = "max_rcu_stall_to_panic",
2038                 .data           = &sysctl_max_rcu_stall_to_panic,
2039                 .maxlen         = sizeof(sysctl_max_rcu_stall_to_panic),
2040                 .mode           = 0644,
2041                 .proc_handler   = proc_dointvec_minmax,
2042                 .extra1         = SYSCTL_ONE,
2043                 .extra2         = SYSCTL_INT_MAX,
2044         },
2045 #endif
2046         { }
2047 };
2048
2049 static struct ctl_table vm_table[] = {
2050         {
2051                 .procname       = "overcommit_memory",
2052                 .data           = &sysctl_overcommit_memory,
2053                 .maxlen         = sizeof(sysctl_overcommit_memory),
2054                 .mode           = 0644,
2055                 .proc_handler   = overcommit_policy_handler,
2056                 .extra1         = SYSCTL_ZERO,
2057                 .extra2         = SYSCTL_TWO,
2058         },
2059         {
2060                 .procname       = "overcommit_ratio",
2061                 .data           = &sysctl_overcommit_ratio,
2062                 .maxlen         = sizeof(sysctl_overcommit_ratio),
2063                 .mode           = 0644,
2064                 .proc_handler   = overcommit_ratio_handler,
2065         },
2066         {
2067                 .procname       = "overcommit_kbytes",
2068                 .data           = &sysctl_overcommit_kbytes,
2069                 .maxlen         = sizeof(sysctl_overcommit_kbytes),
2070                 .mode           = 0644,
2071                 .proc_handler   = overcommit_kbytes_handler,
2072         },
2073         {
2074                 .procname       = "page-cluster",
2075                 .data           = &page_cluster,
2076                 .maxlen         = sizeof(int),
2077                 .mode           = 0644,
2078                 .proc_handler   = proc_dointvec_minmax,
2079                 .extra1         = SYSCTL_ZERO,
2080                 .extra2         = (void *)&page_cluster_max,
2081         },
2082         {
2083                 .procname       = "dirtytime_expire_seconds",
2084                 .data           = &dirtytime_expire_interval,
2085                 .maxlen         = sizeof(dirtytime_expire_interval),
2086                 .mode           = 0644,
2087                 .proc_handler   = dirtytime_interval_handler,
2088                 .extra1         = SYSCTL_ZERO,
2089         },
2090         {
2091                 .procname       = "swappiness",
2092                 .data           = &vm_swappiness,
2093                 .maxlen         = sizeof(vm_swappiness),
2094                 .mode           = 0644,
2095                 .proc_handler   = proc_dointvec_minmax,
2096                 .extra1         = SYSCTL_ZERO,
2097                 .extra2         = SYSCTL_TWO_HUNDRED,
2098         },
2099 #ifdef CONFIG_NUMA
2100         {
2101                 .procname       = "numa_stat",
2102                 .data           = &sysctl_vm_numa_stat,
2103                 .maxlen         = sizeof(int),
2104                 .mode           = 0644,
2105                 .proc_handler   = sysctl_vm_numa_stat_handler,
2106                 .extra1         = SYSCTL_ZERO,
2107                 .extra2         = SYSCTL_ONE,
2108         },
2109 #endif
2110         {
2111                 .procname       = "drop_caches",
2112                 .data           = &sysctl_drop_caches,
2113                 .maxlen         = sizeof(int),
2114                 .mode           = 0200,
2115                 .proc_handler   = drop_caches_sysctl_handler,
2116                 .extra1         = SYSCTL_ONE,
2117                 .extra2         = SYSCTL_FOUR,
2118         },
2119         {
2120                 .procname       = "page_lock_unfairness",
2121                 .data           = &sysctl_page_lock_unfairness,
2122                 .maxlen         = sizeof(sysctl_page_lock_unfairness),
2123                 .mode           = 0644,
2124                 .proc_handler   = proc_dointvec_minmax,
2125                 .extra1         = SYSCTL_ZERO,
2126         },
2127 #ifdef CONFIG_MMU
2128         {
2129                 .procname       = "max_map_count",
2130                 .data           = &sysctl_max_map_count,
2131                 .maxlen         = sizeof(sysctl_max_map_count),
2132                 .mode           = 0644,
2133                 .proc_handler   = proc_dointvec_minmax,
2134                 .extra1         = SYSCTL_ZERO,
2135         },
2136 #else
2137         {
2138                 .procname       = "nr_trim_pages",
2139                 .data           = &sysctl_nr_trim_pages,
2140                 .maxlen         = sizeof(sysctl_nr_trim_pages),
2141                 .mode           = 0644,
2142                 .proc_handler   = proc_dointvec_minmax,
2143                 .extra1         = SYSCTL_ZERO,
2144         },
2145 #endif
2146         {
2147                 .procname       = "vfs_cache_pressure",
2148                 .data           = &sysctl_vfs_cache_pressure,
2149                 .maxlen         = sizeof(sysctl_vfs_cache_pressure),
2150                 .mode           = 0644,
2151                 .proc_handler   = proc_dointvec_minmax,
2152                 .extra1         = SYSCTL_ZERO,
2153         },
2154 #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
2155     defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
2156         {
2157                 .procname       = "legacy_va_layout",
2158                 .data           = &sysctl_legacy_va_layout,
2159                 .maxlen         = sizeof(sysctl_legacy_va_layout),
2160                 .mode           = 0644,
2161                 .proc_handler   = proc_dointvec_minmax,
2162                 .extra1         = SYSCTL_ZERO,
2163         },
2164 #endif
2165 #ifdef CONFIG_NUMA
2166         {
2167                 .procname       = "zone_reclaim_mode",
2168                 .data           = &node_reclaim_mode,
2169                 .maxlen         = sizeof(node_reclaim_mode),
2170                 .mode           = 0644,
2171                 .proc_handler   = proc_dointvec_minmax,
2172                 .extra1         = SYSCTL_ZERO,
2173         },
2174 #endif
2175 #ifdef CONFIG_SMP
2176         {
2177                 .procname       = "stat_interval",
2178                 .data           = &sysctl_stat_interval,
2179                 .maxlen         = sizeof(sysctl_stat_interval),
2180                 .mode           = 0644,
2181                 .proc_handler   = proc_dointvec_jiffies,
2182         },
2183         {
2184                 .procname       = "stat_refresh",
2185                 .data           = NULL,
2186                 .maxlen         = 0,
2187                 .mode           = 0600,
2188                 .proc_handler   = vmstat_refresh,
2189         },
2190 #endif
2191 #ifdef CONFIG_MMU
2192         {
2193                 .procname       = "mmap_min_addr",
2194                 .data           = &dac_mmap_min_addr,
2195                 .maxlen         = sizeof(unsigned long),
2196                 .mode           = 0644,
2197                 .proc_handler   = mmap_min_addr_handler,
2198         },
2199 #endif
2200 #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
2201    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
2202         {
2203                 .procname       = "vdso_enabled",
2204 #ifdef CONFIG_X86_32
2205                 .data           = &vdso32_enabled,
2206                 .maxlen         = sizeof(vdso32_enabled),
2207 #else
2208                 .data           = &vdso_enabled,
2209                 .maxlen         = sizeof(vdso_enabled),
2210 #endif
2211                 .mode           = 0644,
2212                 .proc_handler   = proc_dointvec,
2213                 .extra1         = SYSCTL_ZERO,
2214         },
2215 #endif
2216         {
2217                 .procname       = "user_reserve_kbytes",
2218                 .data           = &sysctl_user_reserve_kbytes,
2219                 .maxlen         = sizeof(sysctl_user_reserve_kbytes),
2220                 .mode           = 0644,
2221                 .proc_handler   = proc_doulongvec_minmax,
2222         },
2223         {
2224                 .procname       = "admin_reserve_kbytes",
2225                 .data           = &sysctl_admin_reserve_kbytes,
2226                 .maxlen         = sizeof(sysctl_admin_reserve_kbytes),
2227                 .mode           = 0644,
2228                 .proc_handler   = proc_doulongvec_minmax,
2229         },
2230 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
2231         {
2232                 .procname       = "mmap_rnd_bits",
2233                 .data           = &mmap_rnd_bits,
2234                 .maxlen         = sizeof(mmap_rnd_bits),
2235                 .mode           = 0600,
2236                 .proc_handler   = proc_dointvec_minmax,
2237                 .extra1         = (void *)&mmap_rnd_bits_min,
2238                 .extra2         = (void *)&mmap_rnd_bits_max,
2239         },
2240 #endif
2241 #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
2242         {
2243                 .procname       = "mmap_rnd_compat_bits",
2244                 .data           = &mmap_rnd_compat_bits,
2245                 .maxlen         = sizeof(mmap_rnd_compat_bits),
2246                 .mode           = 0600,
2247                 .proc_handler   = proc_dointvec_minmax,
2248                 .extra1         = (void *)&mmap_rnd_compat_bits_min,
2249                 .extra2         = (void *)&mmap_rnd_compat_bits_max,
2250         },
2251 #endif
2252         { }
2253 };
2254
2255 int __init sysctl_init_bases(void)
2256 {
2257         register_sysctl_init("kernel", kern_table);
2258         register_sysctl_init("vm", vm_table);
2259
2260         return 0;
2261 }
2262 #endif /* CONFIG_SYSCTL */
2263 /*
2264  * No sense putting this after each symbol definition, twice,
2265  * exception granted :-)
2266  */
2267 EXPORT_SYMBOL(proc_dobool);
2268 EXPORT_SYMBOL(proc_dointvec);
2269 EXPORT_SYMBOL(proc_douintvec);
2270 EXPORT_SYMBOL(proc_dointvec_jiffies);
2271 EXPORT_SYMBOL(proc_dointvec_minmax);
2272 EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
2273 EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2274 EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2275 EXPORT_SYMBOL(proc_dostring);
2276 EXPORT_SYMBOL(proc_doulongvec_minmax);
2277 EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
2278 EXPORT_SYMBOL(proc_do_large_bitmap);