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