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