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