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