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

Archive Download this file



interactive