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