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