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