kernel/sysctl.c

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