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