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