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