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