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