1/*
   2 * sysctl.c: General linux system control interface
   3 *
   4 * Begun 24 March 1995, Stephen Tweedie
   5 * Added /proc support, Dec 1995
   6 * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
   7 * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
   8 * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
   9 * Dynamic registration fixes, Stephen Tweedie.
  10 * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
  11 * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
  12 *  Horn.
  13 * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
  14 * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
  15 * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
  16 *  Wendling.
  17 * The list_for_each() macro wasn't appropriate for the sysctl loop.
  18 *  Removed it and replaced it with older style, 03/23/00, Bill Wendling
  19 */
  20
  21#include <linux/module.h>
  22#include <linux/aio.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/printk.h>
  30#include <linux/proc_fs.h>
  31#include <linux/security.h>
  32#include <linux/ctype.h>
  33#include <linux/kmemcheck.h>
  34#include <linux/kmemleak.h>
  35#include <linux/fs.h>
  36#include <linux/init.h>
  37#include <linux/kernel.h>
  38#include <linux/kobject.h>
  39#include <linux/net.h>
  40#include <linux/sysrq.h>
  41#include <linux/highuid.h>
  42#include <linux/writeback.h>
  43#include <linux/ratelimit.h>
  44#include <linux/compaction.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/dnotify.h>
  52#include <linux/syscalls.h>
  53#include <linux/vmstat.h>
  54#include <linux/nfs_fs.h>
  55#include <linux/acpi.h>
  56#include <linux/reboot.h>
  57#include <linux/ftrace.h>
  58#include <linux/perf_event.h>
  59#include <linux/kprobes.h>
  60#include <linux/pipe_fs_i.h>
  61#include <linux/oom.h>
  62#include <linux/kmod.h>
  63#include <linux/capability.h>
  64#include <linux/binfmts.h>
  65#include <linux/sched/sysctl.h>
  66#include <linux/kexec.h>
  67#include <linux/bpf.h>
 
  68
  69#include <asm/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_BSD_PROCESS_ACCT
  81#include <linux/acct.h>
  82#endif
  83#ifdef CONFIG_RT_MUTEXES
  84#include <linux/rtmutex.h>
  85#endif
  86#if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
  87#include <linux/lockdep.h>
  88#endif
  89#ifdef CONFIG_CHR_DEV_SG
  90#include <scsi/sg.h>
  91#endif
  92
  93#ifdef CONFIG_LOCKUP_DETECTOR
  94#include <linux/nmi.h>
  95#endif
  96
  97#if defined(CONFIG_SYSCTL)
  98
  99/* External variables not in a header file. */
 100extern int suid_dumpable;
 101#ifdef CONFIG_COREDUMP
 102extern int core_uses_pid;
 103extern char core_pattern[];
 104extern unsigned int core_pipe_limit;
 105#endif
 106extern int pid_max;
 107extern int pid_max_min, pid_max_max;
 108extern int percpu_pagelist_fraction;
 109extern int compat_log;
 110extern int latencytop_enabled;
 111extern int sysctl_nr_open_min, sysctl_nr_open_max;
 112#ifndef CONFIG_MMU
 113extern int sysctl_nr_trim_pages;
 114#endif
 115
 116/* Constants used for minimum and  maximum */
 117#ifdef CONFIG_LOCKUP_DETECTOR
 118static int sixty = 60;
 119#endif
 120
 121static int __maybe_unused neg_one = -1;
 122
 123static int zero;
 124static int __maybe_unused one = 1;
 125static int __maybe_unused two = 2;
 126static int __maybe_unused four = 4;
 127static unsigned long one_ul = 1;
 128static int one_hundred = 100;
 129static int one_thousand = 1000;
 130#ifdef CONFIG_PRINTK
 131static int ten_thousand = 10000;
 132#endif
 
 
 
 133
 134/* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
 135static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
 136
 137/* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
 138static int maxolduid = 65535;
 139static int minolduid;
 140
 141static int ngroups_max = NGROUPS_MAX;
 142static const int cap_last_cap = CAP_LAST_CAP;
 143
 144/*this is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs */
 145#ifdef CONFIG_DETECT_HUNG_TASK
 146static unsigned long hung_task_timeout_max = (LONG_MAX/HZ);
 147#endif
 148
 149#ifdef CONFIG_INOTIFY_USER
 150#include <linux/inotify.h>
 151#endif
 152#ifdef CONFIG_SPARC
 153#endif
 154
 155#ifdef __hppa__
 156extern int pwrsw_enabled;
 157#endif
 158
 159#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
 160extern int unaligned_enabled;
 161#endif
 162
 163#ifdef CONFIG_IA64
 164extern int unaligned_dump_stack;
 165#endif
 166
 167#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
 168extern int no_unaligned_warning;
 169#endif
 170
 171#ifdef CONFIG_PROC_SYSCTL
 172
 173#define SYSCTL_WRITES_LEGACY	-1
 174#define SYSCTL_WRITES_WARN	 0
 175#define SYSCTL_WRITES_STRICT	 1
 176
 177static int sysctl_writes_strict = SYSCTL_WRITES_STRICT;
 178
 179static int proc_do_cad_pid(struct ctl_table *table, int write,
 180		  void __user *buffer, size_t *lenp, loff_t *ppos);
 181static int proc_taint(struct ctl_table *table, int write,
 182			       void __user *buffer, size_t *lenp, loff_t *ppos);
 183#endif
 184
 185#ifdef CONFIG_PRINTK
 186static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
 187				void __user *buffer, size_t *lenp, loff_t *ppos);
 188#endif
 189
 190static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
 191		void __user *buffer, size_t *lenp, loff_t *ppos);
 192#ifdef CONFIG_COREDUMP
 193static int proc_dostring_coredump(struct ctl_table *table, int write,
 194		void __user *buffer, size_t *lenp, loff_t *ppos);
 195#endif
 196
 197#ifdef CONFIG_MAGIC_SYSRQ
 198/* Note: sysrq code uses it's own private copy */
 199static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
 200
 201static int sysrq_sysctl_handler(struct ctl_table *table, int write,
 202				void __user *buffer, size_t *lenp,
 203				loff_t *ppos)
 204{
 205	int error;
 206
 207	error = proc_dointvec(table, write, buffer, lenp, ppos);
 208	if (error)
 209		return error;
 210
 211	if (write)
 212		sysrq_toggle_support(__sysrq_enabled);
 213
 214	return 0;
 215}
 216
 217#endif
 218
 219static struct ctl_table kern_table[];
 220static struct ctl_table vm_table[];
 221static struct ctl_table fs_table[];
 222static struct ctl_table debug_table[];
 223static struct ctl_table dev_table[];
 224extern struct ctl_table random_table[];
 225#ifdef CONFIG_EPOLL
 226extern struct ctl_table epoll_table[];
 227#endif
 228
 229#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
 230int sysctl_legacy_va_layout;
 231#endif
 232
 233/* The default sysctl tables: */
 234
 235static struct ctl_table sysctl_base_table[] = {
 236	{
 237		.procname	= "kernel",
 238		.mode		= 0555,
 239		.child		= kern_table,
 240	},
 241	{
 242		.procname	= "vm",
 243		.mode		= 0555,
 244		.child		= vm_table,
 245	},
 246	{
 247		.procname	= "fs",
 248		.mode		= 0555,
 249		.child		= fs_table,
 250	},
 251	{
 252		.procname	= "debug",
 253		.mode		= 0555,
 254		.child		= debug_table,
 255	},
 256	{
 257		.procname	= "dev",
 258		.mode		= 0555,
 259		.child		= dev_table,
 260	},
 261	{ }
 262};
 263
 264#ifdef CONFIG_SCHED_DEBUG
 265static int min_sched_granularity_ns = 100000;		/* 100 usecs */
 266static int max_sched_granularity_ns = NSEC_PER_SEC;	/* 1 second */
 267static int min_wakeup_granularity_ns;			/* 0 usecs */
 268static int max_wakeup_granularity_ns = NSEC_PER_SEC;	/* 1 second */
 269#ifdef CONFIG_SMP
 270static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
 271static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
 272#endif /* CONFIG_SMP */
 273#endif /* CONFIG_SCHED_DEBUG */
 274
 275#ifdef CONFIG_COMPACTION
 276static int min_extfrag_threshold;
 277static int max_extfrag_threshold = 1000;
 278#endif
 279
 280static struct ctl_table kern_table[] = {
 281	{
 282		.procname	= "sched_child_runs_first",
 283		.data		= &sysctl_sched_child_runs_first,
 284		.maxlen		= sizeof(unsigned int),
 285		.mode		= 0644,
 286		.proc_handler	= proc_dointvec,
 287	},
 288#ifdef CONFIG_SCHED_DEBUG
 289	{
 290		.procname	= "sched_min_granularity_ns",
 291		.data		= &sysctl_sched_min_granularity,
 292		.maxlen		= sizeof(unsigned int),
 293		.mode		= 0644,
 294		.proc_handler	= sched_proc_update_handler,
 295		.extra1		= &min_sched_granularity_ns,
 296		.extra2		= &max_sched_granularity_ns,
 297	},
 298	{
 299		.procname	= "sched_latency_ns",
 300		.data		= &sysctl_sched_latency,
 301		.maxlen		= sizeof(unsigned int),
 302		.mode		= 0644,
 303		.proc_handler	= sched_proc_update_handler,
 304		.extra1		= &min_sched_granularity_ns,
 305		.extra2		= &max_sched_granularity_ns,
 306	},
 307	{
 308		.procname	= "sched_wakeup_granularity_ns",
 309		.data		= &sysctl_sched_wakeup_granularity,
 310		.maxlen		= sizeof(unsigned int),
 311		.mode		= 0644,
 312		.proc_handler	= sched_proc_update_handler,
 313		.extra1		= &min_wakeup_granularity_ns,
 314		.extra2		= &max_wakeup_granularity_ns,
 315	},
 316#ifdef CONFIG_SMP
 317	{
 318		.procname	= "sched_tunable_scaling",
 319		.data		= &sysctl_sched_tunable_scaling,
 320		.maxlen		= sizeof(enum sched_tunable_scaling),
 321		.mode		= 0644,
 322		.proc_handler	= sched_proc_update_handler,
 323		.extra1		= &min_sched_tunable_scaling,
 324		.extra2		= &max_sched_tunable_scaling,
 325	},
 326	{
 327		.procname	= "sched_migration_cost_ns",
 328		.data		= &sysctl_sched_migration_cost,
 329		.maxlen		= sizeof(unsigned int),
 330		.mode		= 0644,
 331		.proc_handler	= proc_dointvec,
 332	},
 333	{
 334		.procname	= "sched_nr_migrate",
 335		.data		= &sysctl_sched_nr_migrate,
 336		.maxlen		= sizeof(unsigned int),
 337		.mode		= 0644,
 338		.proc_handler	= proc_dointvec,
 339	},
 340	{
 341		.procname	= "sched_time_avg_ms",
 342		.data		= &sysctl_sched_time_avg,
 343		.maxlen		= sizeof(unsigned int),
 344		.mode		= 0644,
 345		.proc_handler	= proc_dointvec,
 346	},
 347	{
 348		.procname	= "sched_shares_window_ns",
 349		.data		= &sysctl_sched_shares_window,
 350		.maxlen		= sizeof(unsigned int),
 351		.mode		= 0644,
 352		.proc_handler	= proc_dointvec,
 353	},
 354#ifdef CONFIG_SCHEDSTATS
 355	{
 356		.procname	= "sched_schedstats",
 357		.data		= NULL,
 358		.maxlen		= sizeof(unsigned int),
 359		.mode		= 0644,
 360		.proc_handler	= sysctl_schedstats,
 361		.extra1		= &zero,
 362		.extra2		= &one,
 363	},
 364#endif /* CONFIG_SCHEDSTATS */
 365#endif /* CONFIG_SMP */
 366#ifdef CONFIG_NUMA_BALANCING
 367	{
 368		.procname	= "numa_balancing_scan_delay_ms",
 369		.data		= &sysctl_numa_balancing_scan_delay,
 370		.maxlen		= sizeof(unsigned int),
 371		.mode		= 0644,
 372		.proc_handler	= proc_dointvec,
 373	},
 374	{
 375		.procname	= "numa_balancing_scan_period_min_ms",
 376		.data		= &sysctl_numa_balancing_scan_period_min,
 377		.maxlen		= sizeof(unsigned int),
 378		.mode		= 0644,
 379		.proc_handler	= proc_dointvec,
 380	},
 381	{
 382		.procname	= "numa_balancing_scan_period_max_ms",
 383		.data		= &sysctl_numa_balancing_scan_period_max,
 384		.maxlen		= sizeof(unsigned int),
 385		.mode		= 0644,
 386		.proc_handler	= proc_dointvec,
 387	},
 388	{
 389		.procname	= "numa_balancing_scan_size_mb",
 390		.data		= &sysctl_numa_balancing_scan_size,
 391		.maxlen		= sizeof(unsigned int),
 392		.mode		= 0644,
 393		.proc_handler	= proc_dointvec_minmax,
 394		.extra1		= &one,
 395	},
 396	{
 397		.procname	= "numa_balancing",
 398		.data		= NULL, /* filled in by handler */
 399		.maxlen		= sizeof(unsigned int),
 400		.mode		= 0644,
 401		.proc_handler	= sysctl_numa_balancing,
 402		.extra1		= &zero,
 403		.extra2		= &one,
 404	},
 405#endif /* CONFIG_NUMA_BALANCING */
 406#endif /* CONFIG_SCHED_DEBUG */
 407	{
 408		.procname	= "sched_rt_period_us",
 409		.data		= &sysctl_sched_rt_period,
 410		.maxlen		= sizeof(unsigned int),
 411		.mode		= 0644,
 412		.proc_handler	= sched_rt_handler,
 413	},
 414	{
 415		.procname	= "sched_rt_runtime_us",
 416		.data		= &sysctl_sched_rt_runtime,
 417		.maxlen		= sizeof(int),
 418		.mode		= 0644,
 419		.proc_handler	= sched_rt_handler,
 420	},
 421	{
 422		.procname	= "sched_rr_timeslice_ms",
 423		.data		= &sched_rr_timeslice,
 424		.maxlen		= sizeof(int),
 425		.mode		= 0644,
 426		.proc_handler	= sched_rr_handler,
 427	},
 428#ifdef CONFIG_SCHED_AUTOGROUP
 429	{
 430		.procname	= "sched_autogroup_enabled",
 431		.data		= &sysctl_sched_autogroup_enabled,
 432		.maxlen		= sizeof(unsigned int),
 433		.mode		= 0644,
 434		.proc_handler	= proc_dointvec_minmax,
 435		.extra1		= &zero,
 436		.extra2		= &one,
 437	},
 438#endif
 439#ifdef CONFIG_CFS_BANDWIDTH
 440	{
 441		.procname	= "sched_cfs_bandwidth_slice_us",
 442		.data		= &sysctl_sched_cfs_bandwidth_slice,
 443		.maxlen		= sizeof(unsigned int),
 444		.mode		= 0644,
 445		.proc_handler	= proc_dointvec_minmax,
 446		.extra1		= &one,
 447	},
 448#endif
 449#ifdef CONFIG_PROVE_LOCKING
 450	{
 451		.procname	= "prove_locking",
 452		.data		= &prove_locking,
 453		.maxlen		= sizeof(int),
 454		.mode		= 0644,
 455		.proc_handler	= proc_dointvec,
 456	},
 457#endif
 458#ifdef CONFIG_LOCK_STAT
 459	{
 460		.procname	= "lock_stat",
 461		.data		= &lock_stat,
 462		.maxlen		= sizeof(int),
 463		.mode		= 0644,
 464		.proc_handler	= proc_dointvec,
 465	},
 466#endif
 467	{
 468		.procname	= "panic",
 469		.data		= &panic_timeout,
 470		.maxlen		= sizeof(int),
 471		.mode		= 0644,
 472		.proc_handler	= proc_dointvec,
 473	},
 474#ifdef CONFIG_COREDUMP
 475	{
 476		.procname	= "core_uses_pid",
 477		.data		= &core_uses_pid,
 478		.maxlen		= sizeof(int),
 479		.mode		= 0644,
 480		.proc_handler	= proc_dointvec,
 481	},
 482	{
 483		.procname	= "core_pattern",
 484		.data		= core_pattern,
 485		.maxlen		= CORENAME_MAX_SIZE,
 486		.mode		= 0644,
 487		.proc_handler	= proc_dostring_coredump,
 488	},
 489	{
 490		.procname	= "core_pipe_limit",
 491		.data		= &core_pipe_limit,
 492		.maxlen		= sizeof(unsigned int),
 493		.mode		= 0644,
 494		.proc_handler	= proc_dointvec,
 495	},
 496#endif
 497#ifdef CONFIG_PROC_SYSCTL
 498	{
 499		.procname	= "tainted",
 500		.maxlen 	= sizeof(long),
 501		.mode		= 0644,
 502		.proc_handler	= proc_taint,
 503	},
 504	{
 505		.procname	= "sysctl_writes_strict",
 506		.data		= &sysctl_writes_strict,
 507		.maxlen		= sizeof(int),
 508		.mode		= 0644,
 509		.proc_handler	= proc_dointvec_minmax,
 510		.extra1		= &neg_one,
 511		.extra2		= &one,
 512	},
 513#endif
 514#ifdef CONFIG_LATENCYTOP
 515	{
 516		.procname	= "latencytop",
 517		.data		= &latencytop_enabled,
 518		.maxlen		= sizeof(int),
 519		.mode		= 0644,
 520		.proc_handler	= sysctl_latencytop,
 521	},
 522#endif
 523#ifdef CONFIG_BLK_DEV_INITRD
 524	{
 525		.procname	= "real-root-dev",
 526		.data		= &real_root_dev,
 527		.maxlen		= sizeof(int),
 528		.mode		= 0644,
 529		.proc_handler	= proc_dointvec,
 530	},
 531#endif
 532	{
 533		.procname	= "print-fatal-signals",
 534		.data		= &print_fatal_signals,
 535		.maxlen		= sizeof(int),
 536		.mode		= 0644,
 537		.proc_handler	= proc_dointvec,
 538	},
 539#ifdef CONFIG_SPARC
 540	{
 541		.procname	= "reboot-cmd",
 542		.data		= reboot_command,
 543		.maxlen		= 256,
 544		.mode		= 0644,
 545		.proc_handler	= proc_dostring,
 546	},
 547	{
 548		.procname	= "stop-a",
 549		.data		= &stop_a_enabled,
 550		.maxlen		= sizeof (int),
 551		.mode		= 0644,
 552		.proc_handler	= proc_dointvec,
 553	},
 554	{
 555		.procname	= "scons-poweroff",
 556		.data		= &scons_pwroff,
 557		.maxlen		= sizeof (int),
 558		.mode		= 0644,
 559		.proc_handler	= proc_dointvec,
 560	},
 561#endif
 562#ifdef CONFIG_SPARC64
 563	{
 564		.procname	= "tsb-ratio",
 565		.data		= &sysctl_tsb_ratio,
 566		.maxlen		= sizeof (int),
 567		.mode		= 0644,
 568		.proc_handler	= proc_dointvec,
 569	},
 570#endif
 571#ifdef __hppa__
 572	{
 573		.procname	= "soft-power",
 574		.data		= &pwrsw_enabled,
 575		.maxlen		= sizeof (int),
 576	 	.mode		= 0644,
 577		.proc_handler	= proc_dointvec,
 578	},
 579#endif
 580#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
 581	{
 582		.procname	= "unaligned-trap",
 583		.data		= &unaligned_enabled,
 584		.maxlen		= sizeof (int),
 585		.mode		= 0644,
 586		.proc_handler	= proc_dointvec,
 587	},
 588#endif
 589	{
 590		.procname	= "ctrl-alt-del",
 591		.data		= &C_A_D,
 592		.maxlen		= sizeof(int),
 593		.mode		= 0644,
 594		.proc_handler	= proc_dointvec,
 595	},
 596#ifdef CONFIG_FUNCTION_TRACER
 597	{
 598		.procname	= "ftrace_enabled",
 599		.data		= &ftrace_enabled,
 600		.maxlen		= sizeof(int),
 601		.mode		= 0644,
 602		.proc_handler	= ftrace_enable_sysctl,
 603	},
 604#endif
 605#ifdef CONFIG_STACK_TRACER
 606	{
 607		.procname	= "stack_tracer_enabled",
 608		.data		= &stack_tracer_enabled,
 609		.maxlen		= sizeof(int),
 610		.mode		= 0644,
 611		.proc_handler	= stack_trace_sysctl,
 612	},
 613#endif
 614#ifdef CONFIG_TRACING
 615	{
 616		.procname	= "ftrace_dump_on_oops",
 617		.data		= &ftrace_dump_on_oops,
 618		.maxlen		= sizeof(int),
 619		.mode		= 0644,
 620		.proc_handler	= proc_dointvec,
 621	},
 622	{
 623		.procname	= "traceoff_on_warning",
 624		.data		= &__disable_trace_on_warning,
 625		.maxlen		= sizeof(__disable_trace_on_warning),
 626		.mode		= 0644,
 627		.proc_handler	= proc_dointvec,
 628	},
 629	{
 630		.procname	= "tracepoint_printk",
 631		.data		= &tracepoint_printk,
 632		.maxlen		= sizeof(tracepoint_printk),
 633		.mode		= 0644,
 634		.proc_handler	= proc_dointvec,
 635	},
 636#endif
 637#ifdef CONFIG_KEXEC_CORE
 638	{
 639		.procname	= "kexec_load_disabled",
 640		.data		= &kexec_load_disabled,
 641		.maxlen		= sizeof(int),
 642		.mode		= 0644,
 643		/* only handle a transition from default "0" to "1" */
 644		.proc_handler	= proc_dointvec_minmax,
 645		.extra1		= &one,
 646		.extra2		= &one,
 647	},
 648#endif
 649#ifdef CONFIG_MODULES
 650	{
 651		.procname	= "modprobe",
 652		.data		= &modprobe_path,
 653		.maxlen		= KMOD_PATH_LEN,
 654		.mode		= 0644,
 655		.proc_handler	= proc_dostring,
 656	},
 657	{
 658		.procname	= "modules_disabled",
 659		.data		= &modules_disabled,
 660		.maxlen		= sizeof(int),
 661		.mode		= 0644,
 662		/* only handle a transition from default "0" to "1" */
 663		.proc_handler	= proc_dointvec_minmax,
 664		.extra1		= &one,
 665		.extra2		= &one,
 666	},
 667#endif
 668#ifdef CONFIG_UEVENT_HELPER
 669	{
 670		.procname	= "hotplug",
 671		.data		= &uevent_helper,
 672		.maxlen		= UEVENT_HELPER_PATH_LEN,
 673		.mode		= 0644,
 674		.proc_handler	= proc_dostring,
 675	},
 676#endif
 677#ifdef CONFIG_CHR_DEV_SG
 678	{
 679		.procname	= "sg-big-buff",
 680		.data		= &sg_big_buff,
 681		.maxlen		= sizeof (int),
 682		.mode		= 0444,
 683		.proc_handler	= proc_dointvec,
 684	},
 685#endif
 686#ifdef CONFIG_BSD_PROCESS_ACCT
 687	{
 688		.procname	= "acct",
 689		.data		= &acct_parm,
 690		.maxlen		= 3*sizeof(int),
 691		.mode		= 0644,
 692		.proc_handler	= proc_dointvec,
 693	},
 694#endif
 695#ifdef CONFIG_MAGIC_SYSRQ
 696	{
 697		.procname	= "sysrq",
 698		.data		= &__sysrq_enabled,
 699		.maxlen		= sizeof (int),
 700		.mode		= 0644,
 701		.proc_handler	= sysrq_sysctl_handler,
 702	},
 703#endif
 704#ifdef CONFIG_PROC_SYSCTL
 705	{
 706		.procname	= "cad_pid",
 707		.data		= NULL,
 708		.maxlen		= sizeof (int),
 709		.mode		= 0600,
 710		.proc_handler	= proc_do_cad_pid,
 711	},
 712#endif
 713	{
 714		.procname	= "threads-max",
 715		.data		= NULL,
 716		.maxlen		= sizeof(int),
 717		.mode		= 0644,
 718		.proc_handler	= sysctl_max_threads,
 719	},
 720	{
 721		.procname	= "random",
 722		.mode		= 0555,
 723		.child		= random_table,
 724	},
 725	{
 726		.procname	= "usermodehelper",
 727		.mode		= 0555,
 728		.child		= usermodehelper_table,
 729	},
 730	{
 731		.procname	= "overflowuid",
 732		.data		= &overflowuid,
 733		.maxlen		= sizeof(int),
 734		.mode		= 0644,
 735		.proc_handler	= proc_dointvec_minmax,
 736		.extra1		= &minolduid,
 737		.extra2		= &maxolduid,
 738	},
 739	{
 740		.procname	= "overflowgid",
 741		.data		= &overflowgid,
 742		.maxlen		= sizeof(int),
 743		.mode		= 0644,
 744		.proc_handler	= proc_dointvec_minmax,
 745		.extra1		= &minolduid,
 746		.extra2		= &maxolduid,
 747	},
 748#ifdef CONFIG_S390
 749#ifdef CONFIG_MATHEMU
 750	{
 751		.procname	= "ieee_emulation_warnings",
 752		.data		= &sysctl_ieee_emulation_warnings,
 753		.maxlen		= sizeof(int),
 754		.mode		= 0644,
 755		.proc_handler	= proc_dointvec,
 756	},
 757#endif
 758	{
 759		.procname	= "userprocess_debug",
 760		.data		= &show_unhandled_signals,
 761		.maxlen		= sizeof(int),
 762		.mode		= 0644,
 763		.proc_handler	= proc_dointvec,
 764	},
 765#endif
 766	{
 767		.procname	= "pid_max",
 768		.data		= &pid_max,
 769		.maxlen		= sizeof (int),
 770		.mode		= 0644,
 771		.proc_handler	= proc_dointvec_minmax,
 772		.extra1		= &pid_max_min,
 773		.extra2		= &pid_max_max,
 774	},
 775	{
 776		.procname	= "panic_on_oops",
 777		.data		= &panic_on_oops,
 778		.maxlen		= sizeof(int),
 779		.mode		= 0644,
 780		.proc_handler	= proc_dointvec,
 781	},
 782#if defined CONFIG_PRINTK
 783	{
 784		.procname	= "printk",
 785		.data		= &console_loglevel,
 786		.maxlen		= 4*sizeof(int),
 787		.mode		= 0644,
 788		.proc_handler	= proc_dointvec,
 789	},
 790	{
 791		.procname	= "printk_ratelimit",
 792		.data		= &printk_ratelimit_state.interval,
 793		.maxlen		= sizeof(int),
 794		.mode		= 0644,
 795		.proc_handler	= proc_dointvec_jiffies,
 796	},
 797	{
 798		.procname	= "printk_ratelimit_burst",
 799		.data		= &printk_ratelimit_state.burst,
 800		.maxlen		= sizeof(int),
 801		.mode		= 0644,
 802		.proc_handler	= proc_dointvec,
 803	},
 804	{
 805		.procname	= "printk_delay",
 806		.data		= &printk_delay_msec,
 807		.maxlen		= sizeof(int),
 808		.mode		= 0644,
 809		.proc_handler	= proc_dointvec_minmax,
 810		.extra1		= &zero,
 811		.extra2		= &ten_thousand,
 812	},
 813	{
 
 
 
 
 
 
 
 814		.procname	= "dmesg_restrict",
 815		.data		= &dmesg_restrict,
 816		.maxlen		= sizeof(int),
 817		.mode		= 0644,
 818		.proc_handler	= proc_dointvec_minmax_sysadmin,
 819		.extra1		= &zero,
 820		.extra2		= &one,
 821	},
 822	{
 823		.procname	= "kptr_restrict",
 824		.data		= &kptr_restrict,
 825		.maxlen		= sizeof(int),
 826		.mode		= 0644,
 827		.proc_handler	= proc_dointvec_minmax_sysadmin,
 828		.extra1		= &zero,
 829		.extra2		= &two,
 830	},
 831#endif
 832	{
 833		.procname	= "ngroups_max",
 834		.data		= &ngroups_max,
 835		.maxlen		= sizeof (int),
 836		.mode		= 0444,
 837		.proc_handler	= proc_dointvec,
 838	},
 839	{
 840		.procname	= "cap_last_cap",
 841		.data		= (void *)&cap_last_cap,
 842		.maxlen		= sizeof(int),
 843		.mode		= 0444,
 844		.proc_handler	= proc_dointvec,
 845	},
 846#if defined(CONFIG_LOCKUP_DETECTOR)
 847	{
 848		.procname       = "watchdog",
 849		.data           = &watchdog_user_enabled,
 850		.maxlen         = sizeof (int),
 851		.mode           = 0644,
 852		.proc_handler   = proc_watchdog,
 853		.extra1		= &zero,
 854		.extra2		= &one,
 855	},
 856	{
 857		.procname	= "watchdog_thresh",
 858		.data		= &watchdog_thresh,
 859		.maxlen		= sizeof(int),
 860		.mode		= 0644,
 861		.proc_handler	= proc_watchdog_thresh,
 862		.extra1		= &zero,
 863		.extra2		= &sixty,
 864	},
 865	{
 866		.procname       = "nmi_watchdog",
 867		.data           = &nmi_watchdog_enabled,
 868		.maxlen         = sizeof (int),
 869		.mode           = 0644,
 870		.proc_handler   = proc_nmi_watchdog,
 871		.extra1		= &zero,
 872#if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
 873		.extra2		= &one,
 874#else
 875		.extra2		= &zero,
 876#endif
 877	},
 878	{
 879		.procname       = "soft_watchdog",
 880		.data           = &soft_watchdog_enabled,
 881		.maxlen         = sizeof (int),
 882		.mode           = 0644,
 883		.proc_handler   = proc_soft_watchdog,
 884		.extra1		= &zero,
 885		.extra2		= &one,
 886	},
 887	{
 888		.procname	= "watchdog_cpumask",
 889		.data		= &watchdog_cpumask_bits,
 890		.maxlen		= NR_CPUS,
 891		.mode		= 0644,
 892		.proc_handler	= proc_watchdog_cpumask,
 893	},
 894	{
 895		.procname	= "softlockup_panic",
 896		.data		= &softlockup_panic,
 897		.maxlen		= sizeof(int),
 898		.mode		= 0644,
 899		.proc_handler	= proc_dointvec_minmax,
 900		.extra1		= &zero,
 901		.extra2		= &one,
 902	},
 903#ifdef CONFIG_HARDLOCKUP_DETECTOR
 904	{
 905		.procname	= "hardlockup_panic",
 906		.data		= &hardlockup_panic,
 907		.maxlen		= sizeof(int),
 908		.mode		= 0644,
 909		.proc_handler	= proc_dointvec_minmax,
 910		.extra1		= &zero,
 911		.extra2		= &one,
 912	},
 913#endif
 914#ifdef CONFIG_SMP
 915	{
 916		.procname	= "softlockup_all_cpu_backtrace",
 917		.data		= &sysctl_softlockup_all_cpu_backtrace,
 918		.maxlen		= sizeof(int),
 919		.mode		= 0644,
 920		.proc_handler	= proc_dointvec_minmax,
 921		.extra1		= &zero,
 922		.extra2		= &one,
 923	},
 924	{
 925		.procname	= "hardlockup_all_cpu_backtrace",
 926		.data		= &sysctl_hardlockup_all_cpu_backtrace,
 927		.maxlen		= sizeof(int),
 928		.mode		= 0644,
 929		.proc_handler	= proc_dointvec_minmax,
 930		.extra1		= &zero,
 931		.extra2		= &one,
 932	},
 933#endif /* CONFIG_SMP */
 934#endif
 935#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
 936	{
 937		.procname       = "unknown_nmi_panic",
 938		.data           = &unknown_nmi_panic,
 939		.maxlen         = sizeof (int),
 940		.mode           = 0644,
 941		.proc_handler   = proc_dointvec,
 942	},
 943#endif
 944#if defined(CONFIG_X86)
 945	{
 946		.procname	= "panic_on_unrecovered_nmi",
 947		.data		= &panic_on_unrecovered_nmi,
 948		.maxlen		= sizeof(int),
 949		.mode		= 0644,
 950		.proc_handler	= proc_dointvec,
 951	},
 952	{
 953		.procname	= "panic_on_io_nmi",
 954		.data		= &panic_on_io_nmi,
 955		.maxlen		= sizeof(int),
 956		.mode		= 0644,
 957		.proc_handler	= proc_dointvec,
 958	},
 959#ifdef CONFIG_DEBUG_STACKOVERFLOW
 960	{
 961		.procname	= "panic_on_stackoverflow",
 962		.data		= &sysctl_panic_on_stackoverflow,
 963		.maxlen		= sizeof(int),
 964		.mode		= 0644,
 965		.proc_handler	= proc_dointvec,
 966	},
 967#endif
 968	{
 969		.procname	= "bootloader_type",
 970		.data		= &bootloader_type,
 971		.maxlen		= sizeof (int),
 972		.mode		= 0444,
 973		.proc_handler	= proc_dointvec,
 974	},
 975	{
 976		.procname	= "bootloader_version",
 977		.data		= &bootloader_version,
 978		.maxlen		= sizeof (int),
 979		.mode		= 0444,
 980		.proc_handler	= proc_dointvec,
 981	},
 982	{
 983		.procname	= "kstack_depth_to_print",
 984		.data		= &kstack_depth_to_print,
 985		.maxlen		= sizeof(int),
 986		.mode		= 0644,
 987		.proc_handler	= proc_dointvec,
 988	},
 989	{
 990		.procname	= "io_delay_type",
 991		.data		= &io_delay_type,
 992		.maxlen		= sizeof(int),
 993		.mode		= 0644,
 994		.proc_handler	= proc_dointvec,
 995	},
 996#endif
 997#if defined(CONFIG_MMU)
 998	{
 999		.procname	= "randomize_va_space",
1000		.data		= &randomize_va_space,
1001		.maxlen		= sizeof(int),
1002		.mode		= 0644,
1003		.proc_handler	= proc_dointvec,
1004	},
1005#endif
1006#if defined(CONFIG_S390) && defined(CONFIG_SMP)
1007	{
1008		.procname	= "spin_retry",
1009		.data		= &spin_retry,
1010		.maxlen		= sizeof (int),
1011		.mode		= 0644,
1012		.proc_handler	= proc_dointvec,
1013	},
1014#endif
1015#if	defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
1016	{
1017		.procname	= "acpi_video_flags",
1018		.data		= &acpi_realmode_flags,
1019		.maxlen		= sizeof (unsigned long),
1020		.mode		= 0644,
1021		.proc_handler	= proc_doulongvec_minmax,
1022	},
1023#endif
1024#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1025	{
1026		.procname	= "ignore-unaligned-usertrap",
1027		.data		= &no_unaligned_warning,
1028		.maxlen		= sizeof (int),
1029	 	.mode		= 0644,
1030		.proc_handler	= proc_dointvec,
1031	},
1032#endif
1033#ifdef CONFIG_IA64
1034	{
1035		.procname	= "unaligned-dump-stack",
1036		.data		= &unaligned_dump_stack,
1037		.maxlen		= sizeof (int),
1038		.mode		= 0644,
1039		.proc_handler	= proc_dointvec,
1040	},
1041#endif
1042#ifdef CONFIG_DETECT_HUNG_TASK
1043	{
1044		.procname	= "hung_task_panic",
1045		.data		= &sysctl_hung_task_panic,
1046		.maxlen		= sizeof(int),
1047		.mode		= 0644,
1048		.proc_handler	= proc_dointvec_minmax,
1049		.extra1		= &zero,
1050		.extra2		= &one,
1051	},
1052	{
1053		.procname	= "hung_task_check_count",
1054		.data		= &sysctl_hung_task_check_count,
1055		.maxlen		= sizeof(int),
1056		.mode		= 0644,
1057		.proc_handler	= proc_dointvec_minmax,
1058		.extra1		= &zero,
1059	},
1060	{
1061		.procname	= "hung_task_timeout_secs",
1062		.data		= &sysctl_hung_task_timeout_secs,
1063		.maxlen		= sizeof(unsigned long),
1064		.mode		= 0644,
1065		.proc_handler	= proc_dohung_task_timeout_secs,
1066		.extra2		= &hung_task_timeout_max,
1067	},
1068	{
1069		.procname	= "hung_task_warnings",
1070		.data		= &sysctl_hung_task_warnings,
1071		.maxlen		= sizeof(int),
1072		.mode		= 0644,
1073		.proc_handler	= proc_dointvec_minmax,
1074		.extra1		= &neg_one,
1075	},
1076#endif
1077#ifdef CONFIG_COMPAT
1078	{
1079		.procname	= "compat-log",
1080		.data		= &compat_log,
1081		.maxlen		= sizeof (int),
1082	 	.mode		= 0644,
1083		.proc_handler	= proc_dointvec,
1084	},
1085#endif
1086#ifdef CONFIG_RT_MUTEXES
1087	{
1088		.procname	= "max_lock_depth",
1089		.data		= &max_lock_depth,
1090		.maxlen		= sizeof(int),
1091		.mode		= 0644,
1092		.proc_handler	= proc_dointvec,
1093	},
1094#endif
1095	{
1096		.procname	= "poweroff_cmd",
1097		.data		= &poweroff_cmd,
1098		.maxlen		= POWEROFF_CMD_PATH_LEN,
1099		.mode		= 0644,
1100		.proc_handler	= proc_dostring,
1101	},
1102#ifdef CONFIG_KEYS
1103	{
1104		.procname	= "keys",
1105		.mode		= 0555,
1106		.child		= key_sysctls,
1107	},
1108#endif
1109#ifdef CONFIG_PERF_EVENTS
1110	/*
1111	 * User-space scripts rely on the existence of this file
1112	 * as a feature check for perf_events being enabled.
1113	 *
1114	 * So it's an ABI, do not remove!
1115	 */
1116	{
1117		.procname	= "perf_event_paranoid",
1118		.data		= &sysctl_perf_event_paranoid,
1119		.maxlen		= sizeof(sysctl_perf_event_paranoid),
1120		.mode		= 0644,
1121		.proc_handler	= proc_dointvec,
1122	},
1123	{
1124		.procname	= "perf_event_mlock_kb",
1125		.data		= &sysctl_perf_event_mlock,
1126		.maxlen		= sizeof(sysctl_perf_event_mlock),
1127		.mode		= 0644,
1128		.proc_handler	= proc_dointvec,
1129	},
1130	{
1131		.procname	= "perf_event_max_sample_rate",
1132		.data		= &sysctl_perf_event_sample_rate,
1133		.maxlen		= sizeof(sysctl_perf_event_sample_rate),
1134		.mode		= 0644,
1135		.proc_handler	= perf_proc_update_handler,
1136		.extra1		= &one,
1137	},
1138	{
1139		.procname	= "perf_cpu_time_max_percent",
1140		.data		= &sysctl_perf_cpu_time_max_percent,
1141		.maxlen		= sizeof(sysctl_perf_cpu_time_max_percent),
1142		.mode		= 0644,
1143		.proc_handler	= perf_cpu_time_max_percent_handler,
1144		.extra1		= &zero,
1145		.extra2		= &one_hundred,
1146	},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1147#endif
1148#ifdef CONFIG_KMEMCHECK
1149	{
1150		.procname	= "kmemcheck",
1151		.data		= &kmemcheck_enabled,
1152		.maxlen		= sizeof(int),
1153		.mode		= 0644,
1154		.proc_handler	= proc_dointvec,
1155	},
1156#endif
1157	{
1158		.procname	= "panic_on_warn",
1159		.data		= &panic_on_warn,
1160		.maxlen		= sizeof(int),
1161		.mode		= 0644,
1162		.proc_handler	= proc_dointvec_minmax,
1163		.extra1		= &zero,
1164		.extra2		= &one,
1165	},
1166#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
1167	{
1168		.procname	= "timer_migration",
1169		.data		= &sysctl_timer_migration,
1170		.maxlen		= sizeof(unsigned int),
1171		.mode		= 0644,
1172		.proc_handler	= timer_migration_handler,
1173	},
1174#endif
1175#ifdef CONFIG_BPF_SYSCALL
1176	{
1177		.procname	= "unprivileged_bpf_disabled",
1178		.data		= &sysctl_unprivileged_bpf_disabled,
1179		.maxlen		= sizeof(sysctl_unprivileged_bpf_disabled),
1180		.mode		= 0644,
1181		/* only handle a transition from default "0" to "1" */
1182		.proc_handler	= proc_dointvec_minmax,
1183		.extra1		= &one,
1184		.extra2		= &one,
1185	},
1186#endif
 
 
 
 
 
 
 
 
 
 
 
1187	{ }
1188};
1189
1190static struct ctl_table vm_table[] = {
1191	{
1192		.procname	= "overcommit_memory",
1193		.data		= &sysctl_overcommit_memory,
1194		.maxlen		= sizeof(sysctl_overcommit_memory),
1195		.mode		= 0644,
1196		.proc_handler	= proc_dointvec_minmax,
1197		.extra1		= &zero,
1198		.extra2		= &two,
1199	},
1200	{
1201		.procname	= "panic_on_oom",
1202		.data		= &sysctl_panic_on_oom,
1203		.maxlen		= sizeof(sysctl_panic_on_oom),
1204		.mode		= 0644,
1205		.proc_handler	= proc_dointvec_minmax,
1206		.extra1		= &zero,
1207		.extra2		= &two,
1208	},
1209	{
1210		.procname	= "oom_kill_allocating_task",
1211		.data		= &sysctl_oom_kill_allocating_task,
1212		.maxlen		= sizeof(sysctl_oom_kill_allocating_task),
1213		.mode		= 0644,
1214		.proc_handler	= proc_dointvec,
1215	},
1216	{
1217		.procname	= "oom_dump_tasks",
1218		.data		= &sysctl_oom_dump_tasks,
1219		.maxlen		= sizeof(sysctl_oom_dump_tasks),
1220		.mode		= 0644,
1221		.proc_handler	= proc_dointvec,
1222	},
1223	{
1224		.procname	= "overcommit_ratio",
1225		.data		= &sysctl_overcommit_ratio,
1226		.maxlen		= sizeof(sysctl_overcommit_ratio),
1227		.mode		= 0644,
1228		.proc_handler	= overcommit_ratio_handler,
1229	},
1230	{
1231		.procname	= "overcommit_kbytes",
1232		.data		= &sysctl_overcommit_kbytes,
1233		.maxlen		= sizeof(sysctl_overcommit_kbytes),
1234		.mode		= 0644,
1235		.proc_handler	= overcommit_kbytes_handler,
1236	},
1237	{
1238		.procname	= "page-cluster", 
1239		.data		= &page_cluster,
1240		.maxlen		= sizeof(int),
1241		.mode		= 0644,
1242		.proc_handler	= proc_dointvec_minmax,
1243		.extra1		= &zero,
1244	},
1245	{
1246		.procname	= "dirty_background_ratio",
1247		.data		= &dirty_background_ratio,
1248		.maxlen		= sizeof(dirty_background_ratio),
1249		.mode		= 0644,
1250		.proc_handler	= dirty_background_ratio_handler,
1251		.extra1		= &zero,
1252		.extra2		= &one_hundred,
1253	},
1254	{
1255		.procname	= "dirty_background_bytes",
1256		.data		= &dirty_background_bytes,
1257		.maxlen		= sizeof(dirty_background_bytes),
1258		.mode		= 0644,
1259		.proc_handler	= dirty_background_bytes_handler,
1260		.extra1		= &one_ul,
1261	},
1262	{
1263		.procname	= "dirty_ratio",
1264		.data		= &vm_dirty_ratio,
1265		.maxlen		= sizeof(vm_dirty_ratio),
1266		.mode		= 0644,
1267		.proc_handler	= dirty_ratio_handler,
1268		.extra1		= &zero,
1269		.extra2		= &one_hundred,
1270	},
1271	{
1272		.procname	= "dirty_bytes",
1273		.data		= &vm_dirty_bytes,
1274		.maxlen		= sizeof(vm_dirty_bytes),
1275		.mode		= 0644,
1276		.proc_handler	= dirty_bytes_handler,
1277		.extra1		= &dirty_bytes_min,
1278	},
1279	{
1280		.procname	= "dirty_writeback_centisecs",
1281		.data		= &dirty_writeback_interval,
1282		.maxlen		= sizeof(dirty_writeback_interval),
1283		.mode		= 0644,
1284		.proc_handler	= dirty_writeback_centisecs_handler,
1285	},
1286	{
1287		.procname	= "dirty_expire_centisecs",
1288		.data		= &dirty_expire_interval,
1289		.maxlen		= sizeof(dirty_expire_interval),
1290		.mode		= 0644,
1291		.proc_handler	= proc_dointvec_minmax,
1292		.extra1		= &zero,
1293	},
1294	{
1295		.procname	= "dirtytime_expire_seconds",
1296		.data		= &dirtytime_expire_interval,
1297		.maxlen		= sizeof(dirty_expire_interval),
1298		.mode		= 0644,
1299		.proc_handler	= dirtytime_interval_handler,
1300		.extra1		= &zero,
1301	},
1302	{
1303		.procname       = "nr_pdflush_threads",
1304		.mode           = 0444 /* read-only */,
1305		.proc_handler   = pdflush_proc_obsolete,
1306	},
1307	{
1308		.procname	= "swappiness",
1309		.data		= &vm_swappiness,
1310		.maxlen		= sizeof(vm_swappiness),
1311		.mode		= 0644,
1312		.proc_handler	= proc_dointvec_minmax,
1313		.extra1		= &zero,
1314		.extra2		= &one_hundred,
1315	},
1316#ifdef CONFIG_HUGETLB_PAGE
1317	{
1318		.procname	= "nr_hugepages",
1319		.data		= NULL,
1320		.maxlen		= sizeof(unsigned long),
1321		.mode		= 0644,
1322		.proc_handler	= hugetlb_sysctl_handler,
1323	},
1324#ifdef CONFIG_NUMA
1325	{
1326		.procname       = "nr_hugepages_mempolicy",
1327		.data           = NULL,
1328		.maxlen         = sizeof(unsigned long),
1329		.mode           = 0644,
1330		.proc_handler   = &hugetlb_mempolicy_sysctl_handler,
1331	},
1332#endif
1333	 {
1334		.procname	= "hugetlb_shm_group",
1335		.data		= &sysctl_hugetlb_shm_group,
1336		.maxlen		= sizeof(gid_t),
1337		.mode		= 0644,
1338		.proc_handler	= proc_dointvec,
1339	 },
1340	 {
1341		.procname	= "hugepages_treat_as_movable",
1342		.data		= &hugepages_treat_as_movable,
1343		.maxlen		= sizeof(int),
1344		.mode		= 0644,
1345		.proc_handler	= proc_dointvec,
1346	},
1347	{
1348		.procname	= "nr_overcommit_hugepages",
1349		.data		= NULL,
1350		.maxlen		= sizeof(unsigned long),
1351		.mode		= 0644,
1352		.proc_handler	= hugetlb_overcommit_handler,
1353	},
1354#endif
1355	{
1356		.procname	= "lowmem_reserve_ratio",
1357		.data		= &sysctl_lowmem_reserve_ratio,
1358		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
1359		.mode		= 0644,
1360		.proc_handler	= lowmem_reserve_ratio_sysctl_handler,
1361	},
1362	{
1363		.procname	= "drop_caches",
1364		.data		= &sysctl_drop_caches,
1365		.maxlen		= sizeof(int),
1366		.mode		= 0644,
1367		.proc_handler	= drop_caches_sysctl_handler,
1368		.extra1		= &one,
1369		.extra2		= &four,
1370	},
1371#ifdef CONFIG_COMPACTION
1372	{
1373		.procname	= "compact_memory",
1374		.data		= &sysctl_compact_memory,
1375		.maxlen		= sizeof(int),
1376		.mode		= 0200,
1377		.proc_handler	= sysctl_compaction_handler,
1378	},
1379	{
1380		.procname	= "extfrag_threshold",
1381		.data		= &sysctl_extfrag_threshold,
1382		.maxlen		= sizeof(int),
1383		.mode		= 0644,
1384		.proc_handler	= sysctl_extfrag_handler,
1385		.extra1		= &min_extfrag_threshold,
1386		.extra2		= &max_extfrag_threshold,
1387	},
1388	{
1389		.procname	= "compact_unevictable_allowed",
1390		.data		= &sysctl_compact_unevictable_allowed,
1391		.maxlen		= sizeof(int),
1392		.mode		= 0644,
1393		.proc_handler	= proc_dointvec,
1394		.extra1		= &zero,
1395		.extra2		= &one,
1396	},
1397
1398#endif /* CONFIG_COMPACTION */
1399	{
1400		.procname	= "min_free_kbytes",
1401		.data		= &min_free_kbytes,
1402		.maxlen		= sizeof(min_free_kbytes),
1403		.mode		= 0644,
1404		.proc_handler	= min_free_kbytes_sysctl_handler,
1405		.extra1		= &zero,
1406	},
1407	{
1408		.procname	= "watermark_scale_factor",
1409		.data		= &watermark_scale_factor,
1410		.maxlen		= sizeof(watermark_scale_factor),
1411		.mode		= 0644,
1412		.proc_handler	= watermark_scale_factor_sysctl_handler,
1413		.extra1		= &one,
1414		.extra2		= &one_thousand,
1415	},
1416	{
1417		.procname	= "percpu_pagelist_fraction",
1418		.data		= &percpu_pagelist_fraction,
1419		.maxlen		= sizeof(percpu_pagelist_fraction),
1420		.mode		= 0644,
1421		.proc_handler	= percpu_pagelist_fraction_sysctl_handler,
1422		.extra1		= &zero,
1423	},
1424#ifdef CONFIG_MMU
1425	{
1426		.procname	= "max_map_count",
1427		.data		= &sysctl_max_map_count,
1428		.maxlen		= sizeof(sysctl_max_map_count),
1429		.mode		= 0644,
1430		.proc_handler	= proc_dointvec_minmax,
1431		.extra1		= &zero,
1432	},
1433#else
1434	{
1435		.procname	= "nr_trim_pages",
1436		.data		= &sysctl_nr_trim_pages,
1437		.maxlen		= sizeof(sysctl_nr_trim_pages),
1438		.mode		= 0644,
1439		.proc_handler	= proc_dointvec_minmax,
1440		.extra1		= &zero,
1441	},
1442#endif
1443	{
1444		.procname	= "laptop_mode",
1445		.data		= &laptop_mode,
1446		.maxlen		= sizeof(laptop_mode),
1447		.mode		= 0644,
1448		.proc_handler	= proc_dointvec_jiffies,
1449	},
1450	{
1451		.procname	= "block_dump",
1452		.data		= &block_dump,
1453		.maxlen		= sizeof(block_dump),
1454		.mode		= 0644,
1455		.proc_handler	= proc_dointvec,
1456		.extra1		= &zero,
1457	},
1458	{
1459		.procname	= "vfs_cache_pressure",
1460		.data		= &sysctl_vfs_cache_pressure,
1461		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
1462		.mode		= 0644,
1463		.proc_handler	= proc_dointvec,
1464		.extra1		= &zero,
1465	},
1466#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1467	{
1468		.procname	= "legacy_va_layout",
1469		.data		= &sysctl_legacy_va_layout,
1470		.maxlen		= sizeof(sysctl_legacy_va_layout),
1471		.mode		= 0644,
1472		.proc_handler	= proc_dointvec,
1473		.extra1		= &zero,
1474	},
1475#endif
1476#ifdef CONFIG_NUMA
1477	{
1478		.procname	= "zone_reclaim_mode",
1479		.data		= &zone_reclaim_mode,
1480		.maxlen		= sizeof(zone_reclaim_mode),
1481		.mode		= 0644,
1482		.proc_handler	= proc_dointvec,
1483		.extra1		= &zero,
1484	},
1485	{
1486		.procname	= "min_unmapped_ratio",
1487		.data		= &sysctl_min_unmapped_ratio,
1488		.maxlen		= sizeof(sysctl_min_unmapped_ratio),
1489		.mode		= 0644,
1490		.proc_handler	= sysctl_min_unmapped_ratio_sysctl_handler,
1491		.extra1		= &zero,
1492		.extra2		= &one_hundred,
1493	},
1494	{
1495		.procname	= "min_slab_ratio",
1496		.data		= &sysctl_min_slab_ratio,
1497		.maxlen		= sizeof(sysctl_min_slab_ratio),
1498		.mode		= 0644,
1499		.proc_handler	= sysctl_min_slab_ratio_sysctl_handler,
1500		.extra1		= &zero,
1501		.extra2		= &one_hundred,
1502	},
1503#endif
1504#ifdef CONFIG_SMP
1505	{
1506		.procname	= "stat_interval",
1507		.data		= &sysctl_stat_interval,
1508		.maxlen		= sizeof(sysctl_stat_interval),
1509		.mode		= 0644,
1510		.proc_handler	= proc_dointvec_jiffies,
1511	},
 
 
 
 
 
 
 
1512#endif
1513#ifdef CONFIG_MMU
1514	{
1515		.procname	= "mmap_min_addr",
1516		.data		= &dac_mmap_min_addr,
1517		.maxlen		= sizeof(unsigned long),
1518		.mode		= 0644,
1519		.proc_handler	= mmap_min_addr_handler,
1520	},
1521#endif
1522#ifdef CONFIG_NUMA
1523	{
1524		.procname	= "numa_zonelist_order",
1525		.data		= &numa_zonelist_order,
1526		.maxlen		= NUMA_ZONELIST_ORDER_LEN,
1527		.mode		= 0644,
1528		.proc_handler	= numa_zonelist_order_handler,
1529	},
1530#endif
1531#if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
1532   (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
1533	{
1534		.procname	= "vdso_enabled",
1535#ifdef CONFIG_X86_32
1536		.data		= &vdso32_enabled,
1537		.maxlen		= sizeof(vdso32_enabled),
1538#else
1539		.data		= &vdso_enabled,
1540		.maxlen		= sizeof(vdso_enabled),
1541#endif
1542		.mode		= 0644,
1543		.proc_handler	= proc_dointvec,
1544		.extra1		= &zero,
1545	},
1546#endif
1547#ifdef CONFIG_HIGHMEM
1548	{
1549		.procname	= "highmem_is_dirtyable",
1550		.data		= &vm_highmem_is_dirtyable,
1551		.maxlen		= sizeof(vm_highmem_is_dirtyable),
1552		.mode		= 0644,
1553		.proc_handler	= proc_dointvec_minmax,
1554		.extra1		= &zero,
1555		.extra2		= &one,
1556	},
1557#endif
1558#ifdef CONFIG_MEMORY_FAILURE
1559	{
1560		.procname	= "memory_failure_early_kill",
1561		.data		= &sysctl_memory_failure_early_kill,
1562		.maxlen		= sizeof(sysctl_memory_failure_early_kill),
1563		.mode		= 0644,
1564		.proc_handler	= proc_dointvec_minmax,
1565		.extra1		= &zero,
1566		.extra2		= &one,
1567	},
1568	{
1569		.procname	= "memory_failure_recovery",
1570		.data		= &sysctl_memory_failure_recovery,
1571		.maxlen		= sizeof(sysctl_memory_failure_recovery),
1572		.mode		= 0644,
1573		.proc_handler	= proc_dointvec_minmax,
1574		.extra1		= &zero,
1575		.extra2		= &one,
1576	},
1577#endif
1578	{
1579		.procname	= "user_reserve_kbytes",
1580		.data		= &sysctl_user_reserve_kbytes,
1581		.maxlen		= sizeof(sysctl_user_reserve_kbytes),
1582		.mode		= 0644,
1583		.proc_handler	= proc_doulongvec_minmax,
1584	},
1585	{
1586		.procname	= "admin_reserve_kbytes",
1587		.data		= &sysctl_admin_reserve_kbytes,
1588		.maxlen		= sizeof(sysctl_admin_reserve_kbytes),
1589		.mode		= 0644,
1590		.proc_handler	= proc_doulongvec_minmax,
1591	},
1592#ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
1593	{
1594		.procname	= "mmap_rnd_bits",
1595		.data		= &mmap_rnd_bits,
1596		.maxlen		= sizeof(mmap_rnd_bits),
1597		.mode		= 0600,
1598		.proc_handler	= proc_dointvec_minmax,
1599		.extra1		= (void *)&mmap_rnd_bits_min,
1600		.extra2		= (void *)&mmap_rnd_bits_max,
1601	},
1602#endif
1603#ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
1604	{
1605		.procname	= "mmap_rnd_compat_bits",
1606		.data		= &mmap_rnd_compat_bits,
1607		.maxlen		= sizeof(mmap_rnd_compat_bits),
1608		.mode		= 0600,
1609		.proc_handler	= proc_dointvec_minmax,
1610		.extra1		= (void *)&mmap_rnd_compat_bits_min,
1611		.extra2		= (void *)&mmap_rnd_compat_bits_max,
1612	},
1613#endif
1614	{ }
1615};
1616
1617static struct ctl_table fs_table[] = {
1618	{
1619		.procname	= "inode-nr",
1620		.data		= &inodes_stat,
1621		.maxlen		= 2*sizeof(long),
1622		.mode		= 0444,
1623		.proc_handler	= proc_nr_inodes,
1624	},
1625	{
1626		.procname	= "inode-state",
1627		.data		= &inodes_stat,
1628		.maxlen		= 7*sizeof(long),
1629		.mode		= 0444,
1630		.proc_handler	= proc_nr_inodes,
1631	},
1632	{
1633		.procname	= "file-nr",
1634		.data		= &files_stat,
1635		.maxlen		= sizeof(files_stat),
1636		.mode		= 0444,
1637		.proc_handler	= proc_nr_files,
1638	},
1639	{
1640		.procname	= "file-max",
1641		.data		= &files_stat.max_files,
1642		.maxlen		= sizeof(files_stat.max_files),
1643		.mode		= 0644,
1644		.proc_handler	= proc_doulongvec_minmax,
1645	},
1646	{
1647		.procname	= "nr_open",
1648		.data		= &sysctl_nr_open,
1649		.maxlen		= sizeof(int),
1650		.mode		= 0644,
1651		.proc_handler	= proc_dointvec_minmax,
1652		.extra1		= &sysctl_nr_open_min,
1653		.extra2		= &sysctl_nr_open_max,
1654	},
1655	{
1656		.procname	= "dentry-state",
1657		.data		= &dentry_stat,
1658		.maxlen		= 6*sizeof(long),
1659		.mode		= 0444,
1660		.proc_handler	= proc_nr_dentry,
1661	},
1662	{
1663		.procname	= "overflowuid",
1664		.data		= &fs_overflowuid,
1665		.maxlen		= sizeof(int),
1666		.mode		= 0644,
1667		.proc_handler	= proc_dointvec_minmax,
1668		.extra1		= &minolduid,
1669		.extra2		= &maxolduid,
1670	},
1671	{
1672		.procname	= "overflowgid",
1673		.data		= &fs_overflowgid,
1674		.maxlen		= sizeof(int),
1675		.mode		= 0644,
1676		.proc_handler	= proc_dointvec_minmax,
1677		.extra1		= &minolduid,
1678		.extra2		= &maxolduid,
1679	},
1680#ifdef CONFIG_FILE_LOCKING
1681	{
1682		.procname	= "leases-enable",
1683		.data		= &leases_enable,
1684		.maxlen		= sizeof(int),
1685		.mode		= 0644,
1686		.proc_handler	= proc_dointvec,
1687	},
1688#endif
1689#ifdef CONFIG_DNOTIFY
1690	{
1691		.procname	= "dir-notify-enable",
1692		.data		= &dir_notify_enable,
1693		.maxlen		= sizeof(int),
1694		.mode		= 0644,
1695		.proc_handler	= proc_dointvec,
1696	},
1697#endif
1698#ifdef CONFIG_MMU
1699#ifdef CONFIG_FILE_LOCKING
1700	{
1701		.procname	= "lease-break-time",
1702		.data		= &lease_break_time,
1703		.maxlen		= sizeof(int),
1704		.mode		= 0644,
1705		.proc_handler	= proc_dointvec,
1706	},
1707#endif
1708#ifdef CONFIG_AIO
1709	{
1710		.procname	= "aio-nr",
1711		.data		= &aio_nr,
1712		.maxlen		= sizeof(aio_nr),
1713		.mode		= 0444,
1714		.proc_handler	= proc_doulongvec_minmax,
1715	},
1716	{
1717		.procname	= "aio-max-nr",
1718		.data		= &aio_max_nr,
1719		.maxlen		= sizeof(aio_max_nr),
1720		.mode		= 0644,
1721		.proc_handler	= proc_doulongvec_minmax,
1722	},
1723#endif /* CONFIG_AIO */
1724#ifdef CONFIG_INOTIFY_USER
1725	{
1726		.procname	= "inotify",
1727		.mode		= 0555,
1728		.child		= inotify_table,
1729	},
1730#endif	
1731#ifdef CONFIG_EPOLL
1732	{
1733		.procname	= "epoll",
1734		.mode		= 0555,
1735		.child		= epoll_table,
1736	},
1737#endif
1738#endif
1739	{
1740		.procname	= "protected_symlinks",
1741		.data		= &sysctl_protected_symlinks,
1742		.maxlen		= sizeof(int),
1743		.mode		= 0600,
1744		.proc_handler	= proc_dointvec_minmax,
1745		.extra1		= &zero,
1746		.extra2		= &one,
1747	},
1748	{
1749		.procname	= "protected_hardlinks",
1750		.data		= &sysctl_protected_hardlinks,
1751		.maxlen		= sizeof(int),
1752		.mode		= 0600,
1753		.proc_handler	= proc_dointvec_minmax,
1754		.extra1		= &zero,
1755		.extra2		= &one,
1756	},
1757	{
1758		.procname	= "suid_dumpable",
1759		.data		= &suid_dumpable,
1760		.maxlen		= sizeof(int),
1761		.mode		= 0644,
1762		.proc_handler	= proc_dointvec_minmax_coredump,
1763		.extra1		= &zero,
1764		.extra2		= &two,
1765	},
1766#if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1767	{
1768		.procname	= "binfmt_misc",
1769		.mode		= 0555,
1770		.child		= sysctl_mount_point,
1771	},
1772#endif
1773	{
1774		.procname	= "pipe-max-size",
1775		.data		= &pipe_max_size,
1776		.maxlen		= sizeof(int),
1777		.mode		= 0644,
1778		.proc_handler	= &pipe_proc_fn,
1779		.extra1		= &pipe_min_size,
1780	},
1781	{
1782		.procname	= "pipe-user-pages-hard",
1783		.data		= &pipe_user_pages_hard,
1784		.maxlen		= sizeof(pipe_user_pages_hard),
1785		.mode		= 0644,
1786		.proc_handler	= proc_doulongvec_minmax,
1787	},
1788	{
1789		.procname	= "pipe-user-pages-soft",
1790		.data		= &pipe_user_pages_soft,
1791		.maxlen		= sizeof(pipe_user_pages_soft),
1792		.mode		= 0644,
1793		.proc_handler	= proc_doulongvec_minmax,
1794	},
 
 
 
 
 
 
 
 
1795	{ }
1796};
1797
1798static struct ctl_table debug_table[] = {
1799#ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
1800	{
1801		.procname	= "exception-trace",
1802		.data		= &show_unhandled_signals,
1803		.maxlen		= sizeof(int),
1804		.mode		= 0644,
1805		.proc_handler	= proc_dointvec
1806	},
1807#endif
1808#if defined(CONFIG_OPTPROBES)
1809	{
1810		.procname	= "kprobes-optimization",
1811		.data		= &sysctl_kprobes_optimization,
1812		.maxlen		= sizeof(int),
1813		.mode		= 0644,
1814		.proc_handler	= proc_kprobes_optimization_handler,
1815		.extra1		= &zero,
1816		.extra2		= &one,
1817	},
1818#endif
1819	{ }
1820};
1821
1822static struct ctl_table dev_table[] = {
1823	{ }
1824};
1825
1826int __init sysctl_init(void)
1827{
1828	struct ctl_table_header *hdr;
1829
1830	hdr = register_sysctl_table(sysctl_base_table);
1831	kmemleak_not_leak(hdr);
1832	return 0;
1833}
1834
1835#endif /* CONFIG_SYSCTL */
1836
1837/*
1838 * /proc/sys support
1839 */
1840
1841#ifdef CONFIG_PROC_SYSCTL
1842
1843static int _proc_do_string(char *data, int maxlen, int write,
1844			   char __user *buffer,
1845			   size_t *lenp, loff_t *ppos)
1846{
1847	size_t len;
1848	char __user *p;
1849	char c;
1850
1851	if (!data || !maxlen || !*lenp) {
1852		*lenp = 0;
1853		return 0;
1854	}
1855
1856	if (write) {
1857		if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
1858			/* Only continue writes not past the end of buffer. */
1859			len = strlen(data);
1860			if (len > maxlen - 1)
1861				len = maxlen - 1;
1862
1863			if (*ppos > len)
1864				return 0;
1865			len = *ppos;
1866		} else {
1867			/* Start writing from beginning of buffer. */
1868			len = 0;
1869		}
1870
1871		*ppos += *lenp;
1872		p = buffer;
1873		while ((p - buffer) < *lenp && len < maxlen - 1) {
1874			if (get_user(c, p++))
1875				return -EFAULT;
1876			if (c == 0 || c == '\n')
1877				break;
1878			data[len++] = c;
1879		}
1880		data[len] = 0;
1881	} else {
1882		len = strlen(data);
1883		if (len > maxlen)
1884			len = maxlen;
1885
1886		if (*ppos > len) {
1887			*lenp = 0;
1888			return 0;
1889		}
1890
1891		data += *ppos;
1892		len  -= *ppos;
1893
1894		if (len > *lenp)
1895			len = *lenp;
1896		if (len)
1897			if (copy_to_user(buffer, data, len))
1898				return -EFAULT;
1899		if (len < *lenp) {
1900			if (put_user('\n', buffer + len))
1901				return -EFAULT;
1902			len++;
1903		}
1904		*lenp = len;
1905		*ppos += len;
1906	}
1907	return 0;
1908}
1909
1910static void warn_sysctl_write(struct ctl_table *table)
1911{
1912	pr_warn_once("%s wrote to %s when file position was not 0!\n"
1913		"This will not be supported in the future. To silence this\n"
1914		"warning, set kernel.sysctl_writes_strict = -1\n",
1915		current->comm, table->procname);
1916}
1917
1918/**
1919 * proc_dostring - read a string sysctl
1920 * @table: the sysctl table
1921 * @write: %TRUE if this is a write to the sysctl file
1922 * @buffer: the user buffer
1923 * @lenp: the size of the user buffer
1924 * @ppos: file position
1925 *
1926 * Reads/writes a string from/to the user buffer. If the kernel
1927 * buffer provided is not large enough to hold the string, the
1928 * string is truncated. The copied string is %NULL-terminated.
1929 * If the string is being read by the user process, it is copied
1930 * and a newline '\n' is added. It is truncated if the buffer is
1931 * not large enough.
1932 *
1933 * Returns 0 on success.
1934 */
1935int proc_dostring(struct ctl_table *table, int write,
1936		  void __user *buffer, size_t *lenp, loff_t *ppos)
1937{
1938	if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN)
1939		warn_sysctl_write(table);
1940
1941	return _proc_do_string((char *)(table->data), table->maxlen, write,
1942			       (char __user *)buffer, lenp, ppos);
1943}
1944
1945static size_t proc_skip_spaces(char **buf)
1946{
1947	size_t ret;
1948	char *tmp = skip_spaces(*buf);
1949	ret = tmp - *buf;
1950	*buf = tmp;
1951	return ret;
1952}
1953
1954static void proc_skip_char(char **buf, size_t *size, const char v)
1955{
1956	while (*size) {
1957		if (**buf != v)
1958			break;
1959		(*size)--;
1960		(*buf)++;
1961	}
1962}
1963
1964#define TMPBUFLEN 22
1965/**
1966 * proc_get_long - reads an ASCII formatted integer from a user buffer
1967 *
1968 * @buf: a kernel buffer
1969 * @size: size of the kernel buffer
1970 * @val: this is where the number will be stored
1971 * @neg: set to %TRUE if number is negative
1972 * @perm_tr: a vector which contains the allowed trailers
1973 * @perm_tr_len: size of the perm_tr vector
1974 * @tr: pointer to store the trailer character
1975 *
1976 * In case of success %0 is returned and @buf and @size are updated with
1977 * the amount of bytes read. If @tr is non-NULL and a trailing
1978 * character exists (size is non-zero after returning from this
1979 * function), @tr is updated with the trailing character.
1980 */
1981static int proc_get_long(char **buf, size_t *size,
1982			  unsigned long *val, bool *neg,
1983			  const char *perm_tr, unsigned perm_tr_len, char *tr)
1984{
1985	int len;
1986	char *p, tmp[TMPBUFLEN];
1987
1988	if (!*size)
1989		return -EINVAL;
1990
1991	len = *size;
1992	if (len > TMPBUFLEN - 1)
1993		len = TMPBUFLEN - 1;
1994
1995	memcpy(tmp, *buf, len);
1996
1997	tmp[len] = 0;
1998	p = tmp;
1999	if (*p == '-' && *size > 1) {
2000		*neg = true;
2001		p++;
2002	} else
2003		*neg = false;
2004	if (!isdigit(*p))
2005		return -EINVAL;
2006
2007	*val = simple_strtoul(p, &p, 0);
2008
2009	len = p - tmp;
2010
2011	/* We don't know if the next char is whitespace thus we may accept
2012	 * invalid integers (e.g. 1234...a) or two integers instead of one
2013	 * (e.g. 123...1). So lets not allow such large numbers. */
2014	if (len == TMPBUFLEN - 1)
2015		return -EINVAL;
2016
2017	if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
2018		return -EINVAL;
2019
2020	if (tr && (len < *size))
2021		*tr = *p;
2022
2023	*buf += len;
2024	*size -= len;
2025
2026	return 0;
2027}
2028
2029/**
2030 * proc_put_long - converts an integer to a decimal ASCII formatted string
2031 *
2032 * @buf: the user buffer
2033 * @size: the size of the user buffer
2034 * @val: the integer to be converted
2035 * @neg: sign of the number, %TRUE for negative
2036 *
2037 * In case of success %0 is returned and @buf and @size are updated with
2038 * the amount of bytes written.
2039 */
2040static int proc_put_long(void __user **buf, size_t *size, unsigned long val,
2041			  bool neg)
2042{
2043	int len;
2044	char tmp[TMPBUFLEN], *p = tmp;
2045
2046	sprintf(p, "%s%lu", neg ? "-" : "", val);
2047	len = strlen(tmp);
2048	if (len > *size)
2049		len = *size;
2050	if (copy_to_user(*buf, tmp, len))
2051		return -EFAULT;
2052	*size -= len;
2053	*buf += len;
2054	return 0;
2055}
2056#undef TMPBUFLEN
2057
2058static int proc_put_char(void __user **buf, size_t *size, char c)
2059{
2060	if (*size) {
2061		char __user **buffer = (char __user **)buf;
2062		if (put_user(c, *buffer))
2063			return -EFAULT;
2064		(*size)--, (*buffer)++;
2065		*buf = *buffer;
2066	}
2067	return 0;
2068}
2069
2070static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
2071				 int *valp,
2072				 int write, void *data)
2073{
2074	if (write) {
2075		if (*negp) {
2076			if (*lvalp > (unsigned long) INT_MAX + 1)
2077				return -EINVAL;
2078			*valp = -*lvalp;
2079		} else {
2080			if (*lvalp > (unsigned long) INT_MAX)
2081				return -EINVAL;
2082			*valp = *lvalp;
2083		}
2084	} else {
2085		int val = *valp;
2086		if (val < 0) {
2087			*negp = true;
2088			*lvalp = -(unsigned long)val;
2089		} else {
2090			*negp = false;
2091			*lvalp = (unsigned long)val;
2092		}
2093	}
2094	return 0;
2095}
2096
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2097static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
2098
2099static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
2100		  int write, void __user *buffer,
2101		  size_t *lenp, loff_t *ppos,
2102		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
2103			      int write, void *data),
2104		  void *data)
2105{
2106	int *i, vleft, first = 1, err = 0;
2107	size_t left;
2108	char *kbuf = NULL, *p;
2109	
2110	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
2111		*lenp = 0;
2112		return 0;
2113	}
2114	
2115	i = (int *) tbl_data;
2116	vleft = table->maxlen / sizeof(*i);
2117	left = *lenp;
2118
2119	if (!conv)
2120		conv = do_proc_dointvec_conv;
2121
2122	if (write) {
2123		if (*ppos) {
2124			switch (sysctl_writes_strict) {
2125			case SYSCTL_WRITES_STRICT:
2126				goto out;
2127			case SYSCTL_WRITES_WARN:
2128				warn_sysctl_write(table);
2129				break;
2130			default:
2131				break;
2132			}
2133		}
2134
2135		if (left > PAGE_SIZE - 1)
2136			left = PAGE_SIZE - 1;
2137		p = kbuf = memdup_user_nul(buffer, left);
2138		if (IS_ERR(kbuf))
2139			return PTR_ERR(kbuf);
2140	}
2141
2142	for (; left && vleft--; i++, first=0) {
2143		unsigned long lval;
2144		bool neg;
2145
2146		if (write) {
2147			left -= proc_skip_spaces(&p);
2148
2149			if (!left)
2150				break;
2151			err = proc_get_long(&p, &left, &lval, &neg,
2152					     proc_wspace_sep,
2153					     sizeof(proc_wspace_sep), NULL);
2154			if (err)
2155				break;
2156			if (conv(&neg, &lval, i, 1, data)) {
2157				err = -EINVAL;
2158				break;
2159			}
2160		} else {
2161			if (conv(&neg, &lval, i, 0, data)) {
2162				err = -EINVAL;
2163				break;
2164			}
2165			if (!first)
2166				err = proc_put_char(&buffer, &left, '\t');
2167			if (err)
2168				break;
2169			err = proc_put_long(&buffer, &left, lval, neg);
2170			if (err)
2171				break;
2172		}
2173	}
2174
2175	if (!write && !first && left && !err)
2176		err = proc_put_char(&buffer, &left, '\n');
2177	if (write && !err && left)
2178		left -= proc_skip_spaces(&p);
2179	if (write) {
2180		kfree(kbuf);
2181		if (first)
2182			return err ? : -EINVAL;
2183	}
2184	*lenp -= left;
2185out:
2186	*ppos += *lenp;
2187	return err;
2188}
2189
2190static int do_proc_dointvec(struct ctl_table *table, int write,
2191		  void __user *buffer, size_t *lenp, loff_t *ppos,
2192		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
2193			      int write, void *data),
2194		  void *data)
2195{
2196	return __do_proc_dointvec(table->data, table, write,
2197			buffer, lenp, ppos, conv, data);
2198}
2199
2200/**
2201 * proc_dointvec - read a vector of integers
2202 * @table: the sysctl table
2203 * @write: %TRUE if this is a write to the sysctl file
2204 * @buffer: the user buffer
2205 * @lenp: the size of the user buffer
2206 * @ppos: file position
2207 *
2208 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2209 * values from/to the user buffer, treated as an ASCII string. 
2210 *
2211 * Returns 0 on success.
2212 */
2213int proc_dointvec(struct ctl_table *table, int write,
2214		     void __user *buffer, size_t *lenp, loff_t *ppos)
2215{
2216    return do_proc_dointvec(table,write,buffer,lenp,ppos,
2217		    	    NULL,NULL);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2218}
2219
2220/*
2221 * Taint values can only be increased
2222 * This means we can safely use a temporary.
2223 */
2224static int proc_taint(struct ctl_table *table, int write,
2225			       void __user *buffer, size_t *lenp, loff_t *ppos)
2226{
2227	struct ctl_table t;
2228	unsigned long tmptaint = get_taint();
2229	int err;
2230
2231	if (write && !capable(CAP_SYS_ADMIN))
2232		return -EPERM;
2233
2234	t = *table;
2235	t.data = &tmptaint;
2236	err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
2237	if (err < 0)
2238		return err;
2239
2240	if (write) {
2241		/*
2242		 * Poor man's atomic or. Not worth adding a primitive
2243		 * to everyone's atomic.h for this
2244		 */
2245		int i;
2246		for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
2247			if ((tmptaint >> i) & 1)
2248				add_taint(i, LOCKDEP_STILL_OK);
2249		}
2250	}
2251
2252	return err;
2253}
2254
2255#ifdef CONFIG_PRINTK
2256static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
2257				void __user *buffer, size_t *lenp, loff_t *ppos)
2258{
2259	if (write && !capable(CAP_SYS_ADMIN))
2260		return -EPERM;
2261
2262	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2263}
2264#endif
2265
2266struct do_proc_dointvec_minmax_conv_param {
2267	int *min;
2268	int *max;
2269};
2270
2271static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
2272					int *valp,
2273					int write, void *data)
2274{
2275	struct do_proc_dointvec_minmax_conv_param *param = data;
2276	if (write) {
2277		int val = *negp ? -*lvalp : *lvalp;
2278		if ((param->min && *param->min > val) ||
2279		    (param->max && *param->max < val))
2280			return -EINVAL;
2281		*valp = val;
2282	} else {
2283		int val = *valp;
2284		if (val < 0) {
2285			*negp = true;
2286			*lvalp = -(unsigned long)val;
2287		} else {
2288			*negp = false;
2289			*lvalp = (unsigned long)val;
2290		}
2291	}
2292	return 0;
2293}
2294
2295/**
2296 * proc_dointvec_minmax - read a vector of integers with min/max values
2297 * @table: the sysctl table
2298 * @write: %TRUE if this is a write to the sysctl file
2299 * @buffer: the user buffer
2300 * @lenp: the size of the user buffer
2301 * @ppos: file position
2302 *
2303 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2304 * values from/to the user buffer, treated as an ASCII string.
2305 *
2306 * This routine will ensure the values are within the range specified by
2307 * table->extra1 (min) and table->extra2 (max).
2308 *
2309 * Returns 0 on success.
2310 */
2311int proc_dointvec_minmax(struct ctl_table *table, int write,
2312		  void __user *buffer, size_t *lenp, loff_t *ppos)
2313{
2314	struct do_proc_dointvec_minmax_conv_param param = {
2315		.min = (int *) table->extra1,
2316		.max = (int *) table->extra2,
2317	};
2318	return do_proc_dointvec(table, write, buffer, lenp, ppos,
2319				do_proc_dointvec_minmax_conv, &param);
2320}
2321
2322static void validate_coredump_safety(void)
2323{
2324#ifdef CONFIG_COREDUMP
2325	if (suid_dumpable == SUID_DUMP_ROOT &&
2326	    core_pattern[0] != '/' && core_pattern[0] != '|') {
2327		printk(KERN_WARNING "Unsafe core_pattern used with "\
2328			"suid_dumpable=2. Pipe handler or fully qualified "\
2329			"core dump path required.\n");
 
 
2330	}
2331#endif
2332}
2333
2334static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
2335		void __user *buffer, size_t *lenp, loff_t *ppos)
2336{
2337	int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2338	if (!error)
2339		validate_coredump_safety();
2340	return error;
2341}
2342
2343#ifdef CONFIG_COREDUMP
2344static int proc_dostring_coredump(struct ctl_table *table, int write,
2345		  void __user *buffer, size_t *lenp, loff_t *ppos)
2346{
2347	int error = proc_dostring(table, write, buffer, lenp, ppos);
2348	if (!error)
2349		validate_coredump_safety();
2350	return error;
2351}
2352#endif
2353
2354static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
2355				     void __user *buffer,
2356				     size_t *lenp, loff_t *ppos,
2357				     unsigned long convmul,
2358				     unsigned long convdiv)
2359{
2360	unsigned long *i, *min, *max;
2361	int vleft, first = 1, err = 0;
2362	size_t left;
2363	char *kbuf = NULL, *p;
2364
2365	if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
2366		*lenp = 0;
2367		return 0;
2368	}
2369
2370	i = (unsigned long *) data;
2371	min = (unsigned long *) table->extra1;
2372	max = (unsigned long *) table->extra2;
2373	vleft = table->maxlen / sizeof(unsigned long);
2374	left = *lenp;
2375
2376	if (write) {
2377		if (*ppos) {
2378			switch (sysctl_writes_strict) {
2379			case SYSCTL_WRITES_STRICT:
2380				goto out;
2381			case SYSCTL_WRITES_WARN:
2382				warn_sysctl_write(table);
2383				break;
2384			default:
2385				break;
2386			}
2387		}
2388
2389		if (left > PAGE_SIZE - 1)
2390			left = PAGE_SIZE - 1;
2391		p = kbuf = memdup_user_nul(buffer, left);
2392		if (IS_ERR(kbuf))
2393			return PTR_ERR(kbuf);
2394	}
2395
2396	for (; left && vleft--; i++, first = 0) {
2397		unsigned long val;
2398
2399		if (write) {
2400			bool neg;
2401
2402			left -= proc_skip_spaces(&p);
2403
2404			err = proc_get_long(&p, &left, &val, &neg,
2405					     proc_wspace_sep,
2406					     sizeof(proc_wspace_sep), NULL);
2407			if (err)
2408				break;
2409			if (neg)
2410				continue;
 
2411			if ((min && val < *min) || (max && val > *max))
2412				continue;
2413			*i = val;
2414		} else {
2415			val = convdiv * (*i) / convmul;
2416			if (!first) {
2417				err = proc_put_char(&buffer, &left, '\t');
2418				if (err)
2419					break;
2420			}
2421			err = proc_put_long(&buffer, &left, val, false);
2422			if (err)
2423				break;
2424		}
2425	}
2426
2427	if (!write && !first && left && !err)
2428		err = proc_put_char(&buffer, &left, '\n');
2429	if (write && !err)
2430		left -= proc_skip_spaces(&p);
2431	if (write) {
2432		kfree(kbuf);
2433		if (first)
2434			return err ? : -EINVAL;
2435	}
2436	*lenp -= left;
2437out:
2438	*ppos += *lenp;
2439	return err;
2440}
2441
2442static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
2443				     void __user *buffer,
2444				     size_t *lenp, loff_t *ppos,
2445				     unsigned long convmul,
2446				     unsigned long convdiv)
2447{
2448	return __do_proc_doulongvec_minmax(table->data, table, write,
2449			buffer, lenp, ppos, convmul, convdiv);
2450}
2451
2452/**
2453 * proc_doulongvec_minmax - read a vector of long integers with min/max values
2454 * @table: the sysctl table
2455 * @write: %TRUE if this is a write to the sysctl file
2456 * @buffer: the user buffer
2457 * @lenp: the size of the user buffer
2458 * @ppos: file position
2459 *
2460 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2461 * values from/to the user buffer, treated as an ASCII string.
2462 *
2463 * This routine will ensure the values are within the range specified by
2464 * table->extra1 (min) and table->extra2 (max).
2465 *
2466 * Returns 0 on success.
2467 */
2468int proc_doulongvec_minmax(struct ctl_table *table, int write,
2469			   void __user *buffer, size_t *lenp, loff_t *ppos)
2470{
2471    return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
2472}
2473
2474/**
2475 * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
2476 * @table: the sysctl table
2477 * @write: %TRUE if this is a write to the sysctl file
2478 * @buffer: the user buffer
2479 * @lenp: the size of the user buffer
2480 * @ppos: file position
2481 *
2482 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
2483 * values from/to the user buffer, treated as an ASCII string. The values
2484 * are treated as milliseconds, and converted to jiffies when they are stored.
2485 *
2486 * This routine will ensure the values are within the range specified by
2487 * table->extra1 (min) and table->extra2 (max).
2488 *
2489 * Returns 0 on success.
2490 */
2491int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2492				      void __user *buffer,
2493				      size_t *lenp, loff_t *ppos)
2494{
2495    return do_proc_doulongvec_minmax(table, write, buffer,
2496				     lenp, ppos, HZ, 1000l);
2497}
2498
2499
2500static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
2501					 int *valp,
2502					 int write, void *data)
2503{
2504	if (write) {
2505		if (*lvalp > LONG_MAX / HZ)
2506			return 1;
2507		*valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
2508	} else {
2509		int val = *valp;
2510		unsigned long lval;
2511		if (val < 0) {
2512			*negp = true;
2513			lval = -(unsigned long)val;
2514		} else {
2515			*negp = false;
2516			lval = (unsigned long)val;
2517		}
2518		*lvalp = lval / HZ;
2519	}
2520	return 0;
2521}
2522
2523static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
2524						int *valp,
2525						int write, void *data)
2526{
2527	if (write) {
2528		if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
2529			return 1;
2530		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
2531	} else {
2532		int val = *valp;
2533		unsigned long lval;
2534		if (val < 0) {
2535			*negp = true;
2536			lval = -(unsigned long)val;
2537		} else {
2538			*negp = false;
2539			lval = (unsigned long)val;
2540		}
2541		*lvalp = jiffies_to_clock_t(lval);
2542	}
2543	return 0;
2544}
2545
2546static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
2547					    int *valp,
2548					    int write, void *data)
2549{
2550	if (write) {
2551		unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
2552
2553		if (jif > INT_MAX)
2554			return 1;
2555		*valp = (int)jif;
2556	} else {
2557		int val = *valp;
2558		unsigned long lval;
2559		if (val < 0) {
2560			*negp = true;
2561			lval = -(unsigned long)val;
2562		} else {
2563			*negp = false;
2564			lval = (unsigned long)val;
2565		}
2566		*lvalp = jiffies_to_msecs(lval);
2567	}
2568	return 0;
2569}
2570
2571/**
2572 * proc_dointvec_jiffies - read a vector of integers as seconds
2573 * @table: the sysctl table
2574 * @write: %TRUE if this is a write to the sysctl file
2575 * @buffer: the user buffer
2576 * @lenp: the size of the user buffer
2577 * @ppos: file position
2578 *
2579 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2580 * values from/to the user buffer, treated as an ASCII string. 
2581 * The values read are assumed to be in seconds, and are converted into
2582 * jiffies.
2583 *
2584 * Returns 0 on success.
2585 */
2586int proc_dointvec_jiffies(struct ctl_table *table, int write,
2587			  void __user *buffer, size_t *lenp, loff_t *ppos)
2588{
2589    return do_proc_dointvec(table,write,buffer,lenp,ppos,
2590		    	    do_proc_dointvec_jiffies_conv,NULL);
2591}
2592
2593/**
2594 * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
2595 * @table: the sysctl table
2596 * @write: %TRUE if this is a write to the sysctl file
2597 * @buffer: the user buffer
2598 * @lenp: the size of the user buffer
2599 * @ppos: pointer to the file position
2600 *
2601 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2602 * values from/to the user buffer, treated as an ASCII string. 
2603 * The values read are assumed to be in 1/USER_HZ seconds, and 
2604 * are converted into jiffies.
2605 *
2606 * Returns 0 on success.
2607 */
2608int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
2609				 void __user *buffer, size_t *lenp, loff_t *ppos)
2610{
2611    return do_proc_dointvec(table,write,buffer,lenp,ppos,
2612		    	    do_proc_dointvec_userhz_jiffies_conv,NULL);
2613}
2614
2615/**
2616 * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
2617 * @table: the sysctl table
2618 * @write: %TRUE if this is a write to the sysctl file
2619 * @buffer: the user buffer
2620 * @lenp: the size of the user buffer
2621 * @ppos: file position
2622 * @ppos: the current position in the file
2623 *
2624 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
2625 * values from/to the user buffer, treated as an ASCII string. 
2626 * The values read are assumed to be in 1/1000 seconds, and 
2627 * are converted into jiffies.
2628 *
2629 * Returns 0 on success.
2630 */
2631int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
2632			     void __user *buffer, size_t *lenp, loff_t *ppos)
2633{
2634	return do_proc_dointvec(table, write, buffer, lenp, ppos,
2635				do_proc_dointvec_ms_jiffies_conv, NULL);
2636}
2637
2638static int proc_do_cad_pid(struct ctl_table *table, int write,
2639			   void __user *buffer, size_t *lenp, loff_t *ppos)
2640{
2641	struct pid *new_pid;
2642	pid_t tmp;
2643	int r;
2644
2645	tmp = pid_vnr(cad_pid);
2646
2647	r = __do_proc_dointvec(&tmp, table, write, buffer,
2648			       lenp, ppos, NULL, NULL);
2649	if (r || !write)
2650		return r;
2651
2652	new_pid = find_get_pid(tmp);
2653	if (!new_pid)
2654		return -ESRCH;
2655
2656	put_pid(xchg(&cad_pid, new_pid));
2657	return 0;
2658}
2659
2660/**
2661 * proc_do_large_bitmap - read/write from/to a large bitmap
2662 * @table: the sysctl table
2663 * @write: %TRUE if this is a write to the sysctl file
2664 * @buffer: the user buffer
2665 * @lenp: the size of the user buffer
2666 * @ppos: file position
2667 *
2668 * The bitmap is stored at table->data and the bitmap length (in bits)
2669 * in table->maxlen.
2670 *
2671 * We use a range comma separated format (e.g. 1,3-4,10-10) so that
2672 * large bitmaps may be represented in a compact manner. Writing into
2673 * the file will clear the bitmap then update it with the given input.
2674 *
2675 * Returns 0 on success.
2676 */
2677int proc_do_large_bitmap(struct ctl_table *table, int write,
2678			 void __user *buffer, size_t *lenp, loff_t *ppos)
2679{
2680	int err = 0;
2681	bool first = 1;
2682	size_t left = *lenp;
2683	unsigned long bitmap_len = table->maxlen;
2684	unsigned long *bitmap = *(unsigned long **) table->data;
2685	unsigned long *tmp_bitmap = NULL;
2686	char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
2687
2688	if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
2689		*lenp = 0;
2690		return 0;
2691	}
2692
2693	if (write) {
2694		char *kbuf, *p;
2695
2696		if (left > PAGE_SIZE - 1)
2697			left = PAGE_SIZE - 1;
2698
2699		p = kbuf = memdup_user_nul(buffer, left);
2700		if (IS_ERR(kbuf))
2701			return PTR_ERR(kbuf);
2702
2703		tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long),
2704				     GFP_KERNEL);
2705		if (!tmp_bitmap) {
2706			kfree(kbuf);
2707			return -ENOMEM;
2708		}
2709		proc_skip_char(&p, &left, '\n');
2710		while (!err && left) {
2711			unsigned long val_a, val_b;
2712			bool neg;
2713
2714			err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
2715					     sizeof(tr_a), &c);
2716			if (err)
2717				break;
2718			if (val_a >= bitmap_len || neg) {
2719				err = -EINVAL;
2720				break;
2721			}
2722
2723			val_b = val_a;
2724			if (left) {
2725				p++;
2726				left--;
2727			}
2728
2729			if (c == '-') {
2730				err = proc_get_long(&p, &left, &val_b,
2731						     &neg, tr_b, sizeof(tr_b),
2732						     &c);
2733				if (err)
2734					break;
2735				if (val_b >= bitmap_len || neg ||
2736				    val_a > val_b) {
2737					err = -EINVAL;
2738					break;
2739				}
2740				if (left) {
2741					p++;
2742					left--;
2743				}
2744			}
2745
2746			bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
2747			first = 0;
2748			proc_skip_char(&p, &left, '\n');
2749		}
2750		kfree(kbuf);
2751	} else {
2752		unsigned long bit_a, bit_b = 0;
2753
2754		while (left) {
2755			bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
2756			if (bit_a >= bitmap_len)
2757				break;
2758			bit_b = find_next_zero_bit(bitmap, bitmap_len,
2759						   bit_a + 1) - 1;
2760
2761			if (!first) {
2762				err = proc_put_char(&buffer, &left, ',');
2763				if (err)
2764					break;
2765			}
2766			err = proc_put_long(&buffer, &left, bit_a, false);
2767			if (err)
2768				break;
2769			if (bit_a != bit_b) {
2770				err = proc_put_char(&buffer, &left, '-');
2771				if (err)
2772					break;
2773				err = proc_put_long(&buffer, &left, bit_b, false);
2774				if (err)
2775					break;
2776			}
2777
2778			first = 0; bit_b++;
2779		}
2780		if (!err)
2781			err = proc_put_char(&buffer, &left, '\n');
2782	}
2783
2784	if (!err) {
2785		if (write) {
2786			if (*ppos)
2787				bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
2788			else
2789				bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
2790		}
2791		kfree(tmp_bitmap);
2792		*lenp -= left;
2793		*ppos += *lenp;
2794		return 0;
2795	} else {
2796		kfree(tmp_bitmap);
2797		return err;
2798	}
2799}
2800
2801#else /* CONFIG_PROC_SYSCTL */
2802
2803int proc_dostring(struct ctl_table *table, int write,
2804		  void __user *buffer, size_t *lenp, loff_t *ppos)
2805{
2806	return -ENOSYS;
2807}
2808
2809int proc_dointvec(struct ctl_table *table, int write,
2810		  void __user *buffer, size_t *lenp, loff_t *ppos)
2811{
2812	return -ENOSYS;
2813}
2814
 
 
 
 
 
 
2815int proc_dointvec_minmax(struct ctl_table *table, int write,
2816		    void __user *buffer, size_t *lenp, loff_t *ppos)
2817{
2818	return -ENOSYS;
2819}
2820
2821int proc_dointvec_jiffies(struct ctl_table *table, int write,
2822		    void __user *buffer, size_t *lenp, loff_t *ppos)
2823{
2824	return -ENOSYS;
2825}
2826
2827int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
2828		    void __user *buffer, size_t *lenp, loff_t *ppos)
2829{
2830	return -ENOSYS;
2831}
2832
2833int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
2834			     void __user *buffer, size_t *lenp, loff_t *ppos)
2835{
2836	return -ENOSYS;
2837}
2838
2839int proc_doulongvec_minmax(struct ctl_table *table, int write,
2840		    void __user *buffer, size_t *lenp, loff_t *ppos)
2841{
2842	return -ENOSYS;
2843}
2844
2845int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
2846				      void __user *buffer,
2847				      size_t *lenp, loff_t *ppos)
2848{
2849    return -ENOSYS;
2850}
2851
2852
2853#endif /* CONFIG_PROC_SYSCTL */
2854
2855/*
2856 * No sense putting this after each symbol definition, twice,
2857 * exception granted :-)
2858 */
2859EXPORT_SYMBOL(proc_dointvec);
 
2860EXPORT_SYMBOL(proc_dointvec_jiffies);
2861EXPORT_SYMBOL(proc_dointvec_minmax);
2862EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2863EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2864EXPORT_SYMBOL(proc_dostring);
2865EXPORT_SYMBOL(proc_doulongvec_minmax);
2866EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);