kernel/sysctl.c

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