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