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