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