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