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