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 */
  85const int sysctl_vals[] = { 0, 1, 2, 3, 4, 100, 200, 1000, 3000, INT_MAX, 65535, -1 };
  86EXPORT_SYMBOL(sysctl_vals);
  87
  88const unsigned long sysctl_long_vals[] = { 0, 1, LONG_MAX };
  89EXPORT_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
  96static const int six_hundred_forty_kb = 640 * 1024;
  97#endif
  98
  99
 100static const int ngroups_max = NGROUPS_MAX;
 101static 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 */
 124enum sysctl_writes_mode {
 125	SYSCTL_WRITES_LEGACY		= -1,
 126	SYSCTL_WRITES_WARN		= 0,
 127	SYSCTL_WRITES_STRICT		= 1,
 128};
 129
 130static 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)
 135int 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
 146static 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
 208static 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 */
 225static 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 */
 259int 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
 269static 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
 279static 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 */
 304static 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 */
 341static 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 */
 400static 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
 415static 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
 427static 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
 454static 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
 469static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
 470
 471static 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;
 539out:
 540	*ppos += *lenp;
 541	return err;
 542}
 543
 544static 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
 554static 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
 599out_free:
 600	if (err)
 601		return -EINVAL;
 602
 603	return 0;
 604
 605	/* This is in keeping with old __do_proc_dointvec() */
 606bail_early:
 607	*ppos += *lenp;
 608	return err;
 609}
 610
 611static 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
 635out:
 636	*lenp -= left;
 637	*ppos += *lenp;
 638
 639	return err;
 640}
 641
 642static 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
 678int 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 */
 705int 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 */
 742int 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 */
 761int 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 */
 772static 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 */
 820struct do_proc_dointvec_minmax_conv_param {
 821	int *min;
 822	int *max;
 823};
 824
 825static 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 */
 867int 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, &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 */
 887struct do_proc_douintvec_minmax_conv_param {
 888	unsigned int *min;
 889	unsigned int *max;
 890};
 891
 892static 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 */
 936int 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, &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 */
 964int 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, &param);
 992	if (res)
 993		return res;
 994	if (write)
 995		WRITE_ONCE(*data, val);
 996	return 0;
 997}
 998EXPORT_SYMBOL_GPL(proc_dou8vec_minmax);
 999
1000#ifdef CONFIG_MAGIC_SYSRQ
1001static 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
1020static 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;
1089out:
1090	*ppos += *lenp;
1091	return err;
1092}
1093
1094static 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 */
1118int 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 */
1141int 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
1149static 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
1175static 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
1198static 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
1223static 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 */
1262int 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
1269int 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, &param);
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 */
1295int 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 */
1317int 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
1324static 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 */
1363int 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
1495int proc_dostring(const struct ctl_table *table, int write,
1496		  void *buffer, size_t *lenp, loff_t *ppos)
1497{
1498	return -ENOSYS;
1499}
1500
1501int proc_dobool(const struct ctl_table *table, int write,
1502		void *buffer, size_t *lenp, loff_t *ppos)
1503{
1504	return -ENOSYS;
1505}
1506
1507int proc_dointvec(const struct ctl_table *table, int write,
1508		  void *buffer, size_t *lenp, loff_t *ppos)
1509{
1510	return -ENOSYS;
1511}
1512
1513int proc_douintvec(const struct ctl_table *table, int write,
1514		  void *buffer, size_t *lenp, loff_t *ppos)
1515{
1516	return -ENOSYS;
1517}
1518
1519int 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
1525int 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
1531int 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
1537int 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
1543int 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
1549int 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
1555int 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
1561int 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
1567int 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
1573int 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)
1582int 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
1612static 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
2033static 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
2238int __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 */
2250EXPORT_SYMBOL(proc_dobool);
2251EXPORT_SYMBOL(proc_dointvec);
2252EXPORT_SYMBOL(proc_douintvec);
2253EXPORT_SYMBOL(proc_dointvec_jiffies);
2254EXPORT_SYMBOL(proc_dointvec_minmax);
2255EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
2256EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2257EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2258EXPORT_SYMBOL(proc_dostring);
2259EXPORT_SYMBOL(proc_doulongvec_minmax);
2260EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
2261EXPORT_SYMBOL(proc_do_large_bitmap);