xref: /openbmc/linux/kernel/sysctl.c (revision 55537871ef666b4153fd1ef8782e4a13fee142cc)
11da177e4SLinus Torvalds /*
21da177e4SLinus Torvalds  * sysctl.c: General linux system control interface
31da177e4SLinus Torvalds  *
41da177e4SLinus Torvalds  * Begun 24 March 1995, Stephen Tweedie
51da177e4SLinus Torvalds  * Added /proc support, Dec 1995
61da177e4SLinus Torvalds  * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
71da177e4SLinus Torvalds  * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
81da177e4SLinus Torvalds  * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
91da177e4SLinus Torvalds  * Dynamic registration fixes, Stephen Tweedie.
101da177e4SLinus Torvalds  * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
111da177e4SLinus Torvalds  * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
121da177e4SLinus Torvalds  *  Horn.
131da177e4SLinus Torvalds  * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
141da177e4SLinus Torvalds  * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
151da177e4SLinus Torvalds  * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
161da177e4SLinus Torvalds  *  Wendling.
171da177e4SLinus Torvalds  * The list_for_each() macro wasn't appropriate for the sysctl loop.
181da177e4SLinus Torvalds  *  Removed it and replaced it with older style, 03/23/00, Bill Wendling
191da177e4SLinus Torvalds  */
201da177e4SLinus Torvalds 
211da177e4SLinus Torvalds #include <linux/module.h>
22e2e40f2cSChristoph Hellwig #include <linux/aio.h>
231da177e4SLinus Torvalds #include <linux/mm.h>
241da177e4SLinus Torvalds #include <linux/swap.h>
251da177e4SLinus Torvalds #include <linux/slab.h>
261da177e4SLinus Torvalds #include <linux/sysctl.h>
275a04cca6SAkinobu Mita #include <linux/bitmap.h>
28d33ed52dSDave Young #include <linux/signal.h>
29455cd5abSDan Rosenberg #include <linux/printk.h>
301da177e4SLinus Torvalds #include <linux/proc_fs.h>
3172c2d582SAndrew Morgan #include <linux/security.h>
321da177e4SLinus Torvalds #include <linux/ctype.h>
33dfec072eSVegard Nossum #include <linux/kmemcheck.h>
34fd4b616bSSteven Rostedt #include <linux/kmemleak.h>
3562239ac2SAdrian Bunk #include <linux/fs.h>
361da177e4SLinus Torvalds #include <linux/init.h>
371da177e4SLinus Torvalds #include <linux/kernel.h>
380296b228SKay Sievers #include <linux/kobject.h>
3920380731SArnaldo Carvalho de Melo #include <linux/net.h>
401da177e4SLinus Torvalds #include <linux/sysrq.h>
411da177e4SLinus Torvalds #include <linux/highuid.h>
421da177e4SLinus Torvalds #include <linux/writeback.h>
433fff4c42SIngo Molnar #include <linux/ratelimit.h>
4476ab0f53SMel Gorman #include <linux/compaction.h>
451da177e4SLinus Torvalds #include <linux/hugetlb.h>
461da177e4SLinus Torvalds #include <linux/initrd.h>
470b77f5bfSDavid Howells #include <linux/key.h>
481da177e4SLinus Torvalds #include <linux/times.h>
491da177e4SLinus Torvalds #include <linux/limits.h>
501da177e4SLinus Torvalds #include <linux/dcache.h>
516e006701SAlexey Dobriyan #include <linux/dnotify.h>
521da177e4SLinus Torvalds #include <linux/syscalls.h>
53c748e134SAdrian Bunk #include <linux/vmstat.h>
54c255d844SPavel Machek #include <linux/nfs_fs.h>
55c255d844SPavel Machek #include <linux/acpi.h>
5610a0a8d4SJeremy Fitzhardinge #include <linux/reboot.h>
57b0fc494fSSteven Rostedt #include <linux/ftrace.h>
58cdd6c482SIngo Molnar #include <linux/perf_event.h>
59b2be84dfSMasami Hiramatsu #include <linux/kprobes.h>
60b492e95bSJens Axboe #include <linux/pipe_fs_i.h>
618e4228e1SDavid Rientjes #include <linux/oom.h>
6217f60a7dSEric Paris #include <linux/kmod.h>
6373efc039SDan Ballard #include <linux/capability.h>
6440401530SAl Viro #include <linux/binfmts.h>
65cf4aebc2SClark Williams #include <linux/sched/sysctl.h>
667984754bSKees Cook #include <linux/kexec.h>
671be7f75dSAlexei Starovoitov #include <linux/bpf.h>
681da177e4SLinus Torvalds 
691da177e4SLinus Torvalds #include <asm/uaccess.h>
701da177e4SLinus Torvalds #include <asm/processor.h>
711da177e4SLinus Torvalds 
7229cbc78bSAndi Kleen #ifdef CONFIG_X86
7329cbc78bSAndi Kleen #include <asm/nmi.h>
740741f4d2SChuck Ebbert #include <asm/stacktrace.h>
756e7c4025SIngo Molnar #include <asm/io.h>
7629cbc78bSAndi Kleen #endif
77d550bbd4SDavid Howells #ifdef CONFIG_SPARC
78d550bbd4SDavid Howells #include <asm/setup.h>
79d550bbd4SDavid Howells #endif
80c55b7c3eSDave Young #ifdef CONFIG_BSD_PROCESS_ACCT
81c55b7c3eSDave Young #include <linux/acct.h>
82c55b7c3eSDave Young #endif
834f0e056fSDave Young #ifdef CONFIG_RT_MUTEXES
844f0e056fSDave Young #include <linux/rtmutex.h>
854f0e056fSDave Young #endif
862edf5e49SDave Young #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
872edf5e49SDave Young #include <linux/lockdep.h>
882edf5e49SDave Young #endif
8915485a46SDave Young #ifdef CONFIG_CHR_DEV_SG
9015485a46SDave Young #include <scsi/sg.h>
9115485a46SDave Young #endif
9229cbc78bSAndi Kleen 
9358687acbSDon Zickus #ifdef CONFIG_LOCKUP_DETECTOR
94504d7cf1SDon Zickus #include <linux/nmi.h>
95504d7cf1SDon Zickus #endif
96504d7cf1SDon Zickus 
971da177e4SLinus Torvalds #if defined(CONFIG_SYSCTL)
981da177e4SLinus Torvalds 
991da177e4SLinus Torvalds /* External variables not in a header file. */
100d6e71144SAlan Cox extern int suid_dumpable;
101046d662fSAlex Kelly #ifdef CONFIG_COREDUMP
102046d662fSAlex Kelly extern int core_uses_pid;
1031da177e4SLinus Torvalds extern char core_pattern[];
104a293980cSNeil Horman extern unsigned int core_pipe_limit;
105046d662fSAlex Kelly #endif
1061da177e4SLinus Torvalds extern int pid_max;
1071da177e4SLinus Torvalds extern int pid_max_min, pid_max_max;
1088ad4b1fbSRohit Seth extern int percpu_pagelist_fraction;
109bebfa101SAndi Kleen extern int compat_log;
1109745512cSArjan van de Ven extern int latencytop_enabled;
111eceea0b3SAl Viro extern int sysctl_nr_open_min, sysctl_nr_open_max;
112dd8632a1SPaul Mundt #ifndef CONFIG_MMU
113dd8632a1SPaul Mundt extern int sysctl_nr_trim_pages;
114dd8632a1SPaul Mundt #endif
1151da177e4SLinus Torvalds 
116c4f3b63fSRavikiran G Thirumalai /* Constants used for minimum and  maximum */
1172508ce18SDon Zickus #ifdef CONFIG_LOCKUP_DETECTOR
118c4f3b63fSRavikiran G Thirumalai static int sixty = 60;
119c4f3b63fSRavikiran G Thirumalai #endif
120c4f3b63fSRavikiran G Thirumalai 
121270750dbSAaron Tomlin static int __maybe_unused neg_one = -1;
122270750dbSAaron Tomlin 
123c4f3b63fSRavikiran G Thirumalai static int zero;
124cd5f9a4cSLinus Torvalds static int __maybe_unused one = 1;
125cd5f9a4cSLinus Torvalds static int __maybe_unused two = 2;
1265509a5d2SDave Hansen static int __maybe_unused four = 4;
127fc3501d4SSven Wegener static unsigned long one_ul = 1;
128c4f3b63fSRavikiran G Thirumalai static int one_hundred = 100;
129af91322eSDave Young #ifdef CONFIG_PRINTK
130af91322eSDave Young static int ten_thousand = 10000;
131af91322eSDave Young #endif
132c4f3b63fSRavikiran G Thirumalai 
1339e4a5bdaSAndrea Righi /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
1349e4a5bdaSAndrea Righi static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
1359e4a5bdaSAndrea Righi 
1361da177e4SLinus Torvalds /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
1371da177e4SLinus Torvalds static int maxolduid = 65535;
1381da177e4SLinus Torvalds static int minolduid;
1391da177e4SLinus Torvalds 
1401da177e4SLinus Torvalds static int ngroups_max = NGROUPS_MAX;
14173efc039SDan Ballard static const int cap_last_cap = CAP_LAST_CAP;
1421da177e4SLinus Torvalds 
14380df2847SLiu Hua /*this is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs */
14480df2847SLiu Hua #ifdef CONFIG_DETECT_HUNG_TASK
14580df2847SLiu Hua static unsigned long hung_task_timeout_max = (LONG_MAX/HZ);
14680df2847SLiu Hua #endif
14780df2847SLiu Hua 
148d14f1729SDave Young #ifdef CONFIG_INOTIFY_USER
149d14f1729SDave Young #include <linux/inotify.h>
150d14f1729SDave Young #endif
15172c57ed5SDavid S. Miller #ifdef CONFIG_SPARC
1521da177e4SLinus Torvalds #endif
1531da177e4SLinus Torvalds 
1541da177e4SLinus Torvalds #ifdef __hppa__
1551da177e4SLinus Torvalds extern int pwrsw_enabled;
156bf14e3b9SVineet Gupta #endif
157bf14e3b9SVineet Gupta 
158bf14e3b9SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1591da177e4SLinus Torvalds extern int unaligned_enabled;
1601da177e4SLinus Torvalds #endif
1611da177e4SLinus Torvalds 
162d2b176edSJes Sorensen #ifdef CONFIG_IA64
16388fc241fSDoug Chapman extern int unaligned_dump_stack;
164d2b176edSJes Sorensen #endif
165d2b176edSJes Sorensen 
166b6fca725SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
167b6fca725SVineet Gupta extern int no_unaligned_warning;
168b6fca725SVineet Gupta #endif
169b6fca725SVineet Gupta 
170d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL
171f4aacea2SKees Cook 
172f4aacea2SKees Cook #define SYSCTL_WRITES_LEGACY	-1
173f4aacea2SKees Cook #define SYSCTL_WRITES_WARN	 0
174f4aacea2SKees Cook #define SYSCTL_WRITES_STRICT	 1
175f4aacea2SKees Cook 
176f4aacea2SKees Cook static int sysctl_writes_strict = SYSCTL_WRITES_WARN;
177f4aacea2SKees Cook 
1788d65af78SAlexey Dobriyan static int proc_do_cad_pid(struct ctl_table *table, int write,
1799ec52099SCedric Le Goater 		  void __user *buffer, size_t *lenp, loff_t *ppos);
1808d65af78SAlexey Dobriyan static int proc_taint(struct ctl_table *table, int write,
18134f5a398STheodore Ts'o 			       void __user *buffer, size_t *lenp, loff_t *ppos);
182d6f8ff73SRandy Dunlap #endif
1839ec52099SCedric Le Goater 
184bfdc0b49SRichard Weinberger #ifdef CONFIG_PRINTK
185620f6e8eSKees Cook static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
186bfdc0b49SRichard Weinberger 				void __user *buffer, size_t *lenp, loff_t *ppos);
187bfdc0b49SRichard Weinberger #endif
188bfdc0b49SRichard Weinberger 
18954b50199SKees Cook static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
19054b50199SKees Cook 		void __user *buffer, size_t *lenp, loff_t *ppos);
191046d662fSAlex Kelly #ifdef CONFIG_COREDUMP
19254b50199SKees Cook static int proc_dostring_coredump(struct ctl_table *table, int write,
19354b50199SKees Cook 		void __user *buffer, size_t *lenp, loff_t *ppos);
194046d662fSAlex Kelly #endif
19554b50199SKees Cook 
19697f5f0cdSDmitry Torokhov #ifdef CONFIG_MAGIC_SYSRQ
1978c6a98b2SAndy Whitcroft /* Note: sysrq code uses it's own private copy */
1988eaede49SBen Hutchings static int __sysrq_enabled = CONFIG_MAGIC_SYSRQ_DEFAULT_ENABLE;
19997f5f0cdSDmitry Torokhov 
2006f8fd1d7SJoe Perches static int sysrq_sysctl_handler(struct ctl_table *table, int write,
20197f5f0cdSDmitry Torokhov 				void __user *buffer, size_t *lenp,
20297f5f0cdSDmitry Torokhov 				loff_t *ppos)
20397f5f0cdSDmitry Torokhov {
20497f5f0cdSDmitry Torokhov 	int error;
20597f5f0cdSDmitry Torokhov 
20697f5f0cdSDmitry Torokhov 	error = proc_dointvec(table, write, buffer, lenp, ppos);
20797f5f0cdSDmitry Torokhov 	if (error)
20897f5f0cdSDmitry Torokhov 		return error;
20997f5f0cdSDmitry Torokhov 
21097f5f0cdSDmitry Torokhov 	if (write)
21197f5f0cdSDmitry Torokhov 		sysrq_toggle_support(__sysrq_enabled);
21297f5f0cdSDmitry Torokhov 
21397f5f0cdSDmitry Torokhov 	return 0;
21497f5f0cdSDmitry Torokhov }
21597f5f0cdSDmitry Torokhov 
21697f5f0cdSDmitry Torokhov #endif
21797f5f0cdSDmitry Torokhov 
218d8217f07SEric W. Biederman static struct ctl_table kern_table[];
219d8217f07SEric W. Biederman static struct ctl_table vm_table[];
220d8217f07SEric W. Biederman static struct ctl_table fs_table[];
221d8217f07SEric W. Biederman static struct ctl_table debug_table[];
222d8217f07SEric W. Biederman static struct ctl_table dev_table[];
223d8217f07SEric W. Biederman extern struct ctl_table random_table[];
2247ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL
2257ef9964eSDavide Libenzi extern struct ctl_table epoll_table[];
2267ef9964eSDavide Libenzi #endif
2271da177e4SLinus Torvalds 
2281da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
2291da177e4SLinus Torvalds int sysctl_legacy_va_layout;
2301da177e4SLinus Torvalds #endif
2311da177e4SLinus Torvalds 
2321da177e4SLinus Torvalds /* The default sysctl tables: */
2331da177e4SLinus Torvalds 
234de4e83bdSEric W. Biederman static struct ctl_table sysctl_base_table[] = {
2351da177e4SLinus Torvalds 	{
2361da177e4SLinus Torvalds 		.procname	= "kernel",
2371da177e4SLinus Torvalds 		.mode		= 0555,
2381da177e4SLinus Torvalds 		.child		= kern_table,
2391da177e4SLinus Torvalds 	},
2401da177e4SLinus Torvalds 	{
2411da177e4SLinus Torvalds 		.procname	= "vm",
2421da177e4SLinus Torvalds 		.mode		= 0555,
2431da177e4SLinus Torvalds 		.child		= vm_table,
2441da177e4SLinus Torvalds 	},
2451da177e4SLinus Torvalds 	{
2461da177e4SLinus Torvalds 		.procname	= "fs",
2471da177e4SLinus Torvalds 		.mode		= 0555,
2481da177e4SLinus Torvalds 		.child		= fs_table,
2491da177e4SLinus Torvalds 	},
2501da177e4SLinus Torvalds 	{
2511da177e4SLinus Torvalds 		.procname	= "debug",
2521da177e4SLinus Torvalds 		.mode		= 0555,
2531da177e4SLinus Torvalds 		.child		= debug_table,
2541da177e4SLinus Torvalds 	},
2551da177e4SLinus Torvalds 	{
2561da177e4SLinus Torvalds 		.procname	= "dev",
2571da177e4SLinus Torvalds 		.mode		= 0555,
2581da177e4SLinus Torvalds 		.child		= dev_table,
2591da177e4SLinus Torvalds 	},
2606fce56ecSEric W. Biederman 	{ }
2611da177e4SLinus Torvalds };
2621da177e4SLinus Torvalds 
26377e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG
26473c4efd2SEric Dumazet static int min_sched_granularity_ns = 100000;		/* 100 usecs */
26573c4efd2SEric Dumazet static int max_sched_granularity_ns = NSEC_PER_SEC;	/* 1 second */
26673c4efd2SEric Dumazet static int min_wakeup_granularity_ns;			/* 0 usecs */
26773c4efd2SEric Dumazet static int max_wakeup_granularity_ns = NSEC_PER_SEC;	/* 1 second */
268cbee9f88SPeter Zijlstra #ifdef CONFIG_SMP
2691983a922SChristian Ehrhardt static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
2701983a922SChristian Ehrhardt static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
271cbee9f88SPeter Zijlstra #endif /* CONFIG_SMP */
272cbee9f88SPeter Zijlstra #endif /* CONFIG_SCHED_DEBUG */
27377e54a1fSIngo Molnar 
2745e771905SMel Gorman #ifdef CONFIG_COMPACTION
2755e771905SMel Gorman static int min_extfrag_threshold;
2765e771905SMel Gorman static int max_extfrag_threshold = 1000;
2775e771905SMel Gorman #endif
2785e771905SMel Gorman 
279d8217f07SEric W. Biederman static struct ctl_table kern_table[] = {
2802bba22c5SMike Galbraith 	{
2812bba22c5SMike Galbraith 		.procname	= "sched_child_runs_first",
2822bba22c5SMike Galbraith 		.data		= &sysctl_sched_child_runs_first,
2832bba22c5SMike Galbraith 		.maxlen		= sizeof(unsigned int),
2842bba22c5SMike Galbraith 		.mode		= 0644,
2856d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2862bba22c5SMike Galbraith 	},
28777e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG
28877e54a1fSIngo Molnar 	{
289b2be5e96SPeter Zijlstra 		.procname	= "sched_min_granularity_ns",
290b2be5e96SPeter Zijlstra 		.data		= &sysctl_sched_min_granularity,
29177e54a1fSIngo Molnar 		.maxlen		= sizeof(unsigned int),
29277e54a1fSIngo Molnar 		.mode		= 0644,
293702a7c76SLinus Torvalds 		.proc_handler	= sched_proc_update_handler,
294b2be5e96SPeter Zijlstra 		.extra1		= &min_sched_granularity_ns,
295b2be5e96SPeter Zijlstra 		.extra2		= &max_sched_granularity_ns,
29677e54a1fSIngo Molnar 	},
29777e54a1fSIngo Molnar 	{
29821805085SPeter Zijlstra 		.procname	= "sched_latency_ns",
29921805085SPeter Zijlstra 		.data		= &sysctl_sched_latency,
30021805085SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
30121805085SPeter Zijlstra 		.mode		= 0644,
302702a7c76SLinus Torvalds 		.proc_handler	= sched_proc_update_handler,
30321805085SPeter Zijlstra 		.extra1		= &min_sched_granularity_ns,
30421805085SPeter Zijlstra 		.extra2		= &max_sched_granularity_ns,
30521805085SPeter Zijlstra 	},
30621805085SPeter Zijlstra 	{
30777e54a1fSIngo Molnar 		.procname	= "sched_wakeup_granularity_ns",
30877e54a1fSIngo Molnar 		.data		= &sysctl_sched_wakeup_granularity,
30977e54a1fSIngo Molnar 		.maxlen		= sizeof(unsigned int),
31077e54a1fSIngo Molnar 		.mode		= 0644,
311702a7c76SLinus Torvalds 		.proc_handler	= sched_proc_update_handler,
31277e54a1fSIngo Molnar 		.extra1		= &min_wakeup_granularity_ns,
31377e54a1fSIngo Molnar 		.extra2		= &max_wakeup_granularity_ns,
31477e54a1fSIngo Molnar 	},
315cbee9f88SPeter Zijlstra #ifdef CONFIG_SMP
31677e54a1fSIngo Molnar 	{
3171983a922SChristian Ehrhardt 		.procname	= "sched_tunable_scaling",
3181983a922SChristian Ehrhardt 		.data		= &sysctl_sched_tunable_scaling,
3191983a922SChristian Ehrhardt 		.maxlen		= sizeof(enum sched_tunable_scaling),
3201983a922SChristian Ehrhardt 		.mode		= 0644,
321702a7c76SLinus Torvalds 		.proc_handler	= sched_proc_update_handler,
3221983a922SChristian Ehrhardt 		.extra1		= &min_sched_tunable_scaling,
3231983a922SChristian Ehrhardt 		.extra2		= &max_sched_tunable_scaling,
3242398f2c6SPeter Zijlstra 	},
3252398f2c6SPeter Zijlstra 	{
326d00535dbSNamhyung Kim 		.procname	= "sched_migration_cost_ns",
327da84d961SIngo Molnar 		.data		= &sysctl_sched_migration_cost,
328da84d961SIngo Molnar 		.maxlen		= sizeof(unsigned int),
329da84d961SIngo Molnar 		.mode		= 0644,
3306d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
331da84d961SIngo Molnar 	},
332b82d9fddSPeter Zijlstra 	{
333b82d9fddSPeter Zijlstra 		.procname	= "sched_nr_migrate",
334b82d9fddSPeter Zijlstra 		.data		= &sysctl_sched_nr_migrate,
335b82d9fddSPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
336fa85ae24SPeter Zijlstra 		.mode		= 0644,
3376d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
338fa85ae24SPeter Zijlstra 	},
339cd1bb94bSArun R Bharadwaj 	{
340d00535dbSNamhyung Kim 		.procname	= "sched_time_avg_ms",
341e9e9250bSPeter Zijlstra 		.data		= &sysctl_sched_time_avg,
342e9e9250bSPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
343e9e9250bSPeter Zijlstra 		.mode		= 0644,
3446d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
345e9e9250bSPeter Zijlstra 	},
346e9e9250bSPeter Zijlstra 	{
347d00535dbSNamhyung Kim 		.procname	= "sched_shares_window_ns",
348a7a4f8a7SPaul Turner 		.data		= &sysctl_sched_shares_window,
349a7a4f8a7SPaul Turner 		.maxlen		= sizeof(unsigned int),
350a7a4f8a7SPaul Turner 		.mode		= 0644,
351a7a4f8a7SPaul Turner 		.proc_handler	= proc_dointvec,
352a7a4f8a7SPaul Turner 	},
353cbee9f88SPeter Zijlstra #endif /* CONFIG_SMP */
354cbee9f88SPeter Zijlstra #ifdef CONFIG_NUMA_BALANCING
355cbee9f88SPeter Zijlstra 	{
3564b96a29bSPeter Zijlstra 		.procname	= "numa_balancing_scan_delay_ms",
3574b96a29bSPeter Zijlstra 		.data		= &sysctl_numa_balancing_scan_delay,
3584b96a29bSPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
3594b96a29bSPeter Zijlstra 		.mode		= 0644,
3604b96a29bSPeter Zijlstra 		.proc_handler	= proc_dointvec,
3614b96a29bSPeter Zijlstra 	},
3624b96a29bSPeter Zijlstra 	{
363cbee9f88SPeter Zijlstra 		.procname	= "numa_balancing_scan_period_min_ms",
364cbee9f88SPeter Zijlstra 		.data		= &sysctl_numa_balancing_scan_period_min,
365cbee9f88SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
366cbee9f88SPeter Zijlstra 		.mode		= 0644,
367cbee9f88SPeter Zijlstra 		.proc_handler	= proc_dointvec,
368cbee9f88SPeter Zijlstra 	},
369cbee9f88SPeter Zijlstra 	{
370cbee9f88SPeter Zijlstra 		.procname	= "numa_balancing_scan_period_max_ms",
371cbee9f88SPeter Zijlstra 		.data		= &sysctl_numa_balancing_scan_period_max,
372cbee9f88SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
373cbee9f88SPeter Zijlstra 		.mode		= 0644,
374cbee9f88SPeter Zijlstra 		.proc_handler	= proc_dointvec,
375cbee9f88SPeter Zijlstra 	},
3766e5fb223SPeter Zijlstra 	{
3776e5fb223SPeter Zijlstra 		.procname	= "numa_balancing_scan_size_mb",
3786e5fb223SPeter Zijlstra 		.data		= &sysctl_numa_balancing_scan_size,
3796e5fb223SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
3806e5fb223SPeter Zijlstra 		.mode		= 0644,
38164192658SKirill Tkhai 		.proc_handler	= proc_dointvec_minmax,
38264192658SKirill Tkhai 		.extra1		= &one,
3836e5fb223SPeter Zijlstra 	},
3843a7053b3SMel Gorman 	{
38554a43d54SAndi Kleen 		.procname	= "numa_balancing",
38654a43d54SAndi Kleen 		.data		= NULL, /* filled in by handler */
38754a43d54SAndi Kleen 		.maxlen		= sizeof(unsigned int),
38854a43d54SAndi Kleen 		.mode		= 0644,
38954a43d54SAndi Kleen 		.proc_handler	= sysctl_numa_balancing,
39054a43d54SAndi Kleen 		.extra1		= &zero,
39154a43d54SAndi Kleen 		.extra2		= &one,
39254a43d54SAndi Kleen 	},
393cbee9f88SPeter Zijlstra #endif /* CONFIG_NUMA_BALANCING */
394cbee9f88SPeter Zijlstra #endif /* CONFIG_SCHED_DEBUG */
3951799e35dSIngo Molnar 	{
3969f0c1e56SPeter Zijlstra 		.procname	= "sched_rt_period_us",
3979f0c1e56SPeter Zijlstra 		.data		= &sysctl_sched_rt_period,
3989f0c1e56SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
3999f0c1e56SPeter Zijlstra 		.mode		= 0644,
4006d456111SEric W. Biederman 		.proc_handler	= sched_rt_handler,
4019f0c1e56SPeter Zijlstra 	},
4029f0c1e56SPeter Zijlstra 	{
4039f0c1e56SPeter Zijlstra 		.procname	= "sched_rt_runtime_us",
4049f0c1e56SPeter Zijlstra 		.data		= &sysctl_sched_rt_runtime,
4059f0c1e56SPeter Zijlstra 		.maxlen		= sizeof(int),
4069f0c1e56SPeter Zijlstra 		.mode		= 0644,
4076d456111SEric W. Biederman 		.proc_handler	= sched_rt_handler,
4089f0c1e56SPeter Zijlstra 	},
409ce0dbbbbSClark Williams 	{
410ce0dbbbbSClark Williams 		.procname	= "sched_rr_timeslice_ms",
411ce0dbbbbSClark Williams 		.data		= &sched_rr_timeslice,
412ce0dbbbbSClark Williams 		.maxlen		= sizeof(int),
413ce0dbbbbSClark Williams 		.mode		= 0644,
414ce0dbbbbSClark Williams 		.proc_handler	= sched_rr_handler,
415ce0dbbbbSClark Williams 	},
4165091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP
4175091faa4SMike Galbraith 	{
4185091faa4SMike Galbraith 		.procname	= "sched_autogroup_enabled",
4195091faa4SMike Galbraith 		.data		= &sysctl_sched_autogroup_enabled,
4205091faa4SMike Galbraith 		.maxlen		= sizeof(unsigned int),
4215091faa4SMike Galbraith 		.mode		= 0644,
4221747b21fSYong Zhang 		.proc_handler	= proc_dointvec_minmax,
4235091faa4SMike Galbraith 		.extra1		= &zero,
4245091faa4SMike Galbraith 		.extra2		= &one,
4255091faa4SMike Galbraith 	},
4265091faa4SMike Galbraith #endif
427ec12cb7fSPaul Turner #ifdef CONFIG_CFS_BANDWIDTH
428ec12cb7fSPaul Turner 	{
429ec12cb7fSPaul Turner 		.procname	= "sched_cfs_bandwidth_slice_us",
430ec12cb7fSPaul Turner 		.data		= &sysctl_sched_cfs_bandwidth_slice,
431ec12cb7fSPaul Turner 		.maxlen		= sizeof(unsigned int),
432ec12cb7fSPaul Turner 		.mode		= 0644,
433ec12cb7fSPaul Turner 		.proc_handler	= proc_dointvec_minmax,
434ec12cb7fSPaul Turner 		.extra1		= &one,
435ec12cb7fSPaul Turner 	},
436ec12cb7fSPaul Turner #endif
437f20786ffSPeter Zijlstra #ifdef CONFIG_PROVE_LOCKING
438f20786ffSPeter Zijlstra 	{
439f20786ffSPeter Zijlstra 		.procname	= "prove_locking",
440f20786ffSPeter Zijlstra 		.data		= &prove_locking,
441f20786ffSPeter Zijlstra 		.maxlen		= sizeof(int),
442f20786ffSPeter Zijlstra 		.mode		= 0644,
4436d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
444f20786ffSPeter Zijlstra 	},
445f20786ffSPeter Zijlstra #endif
446f20786ffSPeter Zijlstra #ifdef CONFIG_LOCK_STAT
447f20786ffSPeter Zijlstra 	{
448f20786ffSPeter Zijlstra 		.procname	= "lock_stat",
449f20786ffSPeter Zijlstra 		.data		= &lock_stat,
450f20786ffSPeter Zijlstra 		.maxlen		= sizeof(int),
451f20786ffSPeter Zijlstra 		.mode		= 0644,
4526d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
453f20786ffSPeter Zijlstra 	},
454f20786ffSPeter Zijlstra #endif
45577e54a1fSIngo Molnar 	{
4561da177e4SLinus Torvalds 		.procname	= "panic",
4571da177e4SLinus Torvalds 		.data		= &panic_timeout,
4581da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
4591da177e4SLinus Torvalds 		.mode		= 0644,
4606d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
4611da177e4SLinus Torvalds 	},
462046d662fSAlex Kelly #ifdef CONFIG_COREDUMP
4631da177e4SLinus Torvalds 	{
4641da177e4SLinus Torvalds 		.procname	= "core_uses_pid",
4651da177e4SLinus Torvalds 		.data		= &core_uses_pid,
4661da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
4671da177e4SLinus Torvalds 		.mode		= 0644,
4686d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
4691da177e4SLinus Torvalds 	},
4701da177e4SLinus Torvalds 	{
4711da177e4SLinus Torvalds 		.procname	= "core_pattern",
4721da177e4SLinus Torvalds 		.data		= core_pattern,
47371ce92f3SDan Aloni 		.maxlen		= CORENAME_MAX_SIZE,
4741da177e4SLinus Torvalds 		.mode		= 0644,
47554b50199SKees Cook 		.proc_handler	= proc_dostring_coredump,
4761da177e4SLinus Torvalds 	},
477a293980cSNeil Horman 	{
478a293980cSNeil Horman 		.procname	= "core_pipe_limit",
479a293980cSNeil Horman 		.data		= &core_pipe_limit,
480a293980cSNeil Horman 		.maxlen		= sizeof(unsigned int),
481a293980cSNeil Horman 		.mode		= 0644,
4826d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
483a293980cSNeil Horman 	},
484046d662fSAlex Kelly #endif
48534f5a398STheodore Ts'o #ifdef CONFIG_PROC_SYSCTL
4861da177e4SLinus Torvalds 	{
4871da177e4SLinus Torvalds 		.procname	= "tainted",
48825ddbb18SAndi Kleen 		.maxlen 	= sizeof(long),
48934f5a398STheodore Ts'o 		.mode		= 0644,
4906d456111SEric W. Biederman 		.proc_handler	= proc_taint,
4911da177e4SLinus Torvalds 	},
492f4aacea2SKees Cook 	{
493f4aacea2SKees Cook 		.procname	= "sysctl_writes_strict",
494f4aacea2SKees Cook 		.data		= &sysctl_writes_strict,
495f4aacea2SKees Cook 		.maxlen		= sizeof(int),
496f4aacea2SKees Cook 		.mode		= 0644,
497f4aacea2SKees Cook 		.proc_handler	= proc_dointvec_minmax,
498f4aacea2SKees Cook 		.extra1		= &neg_one,
499f4aacea2SKees Cook 		.extra2		= &one,
500f4aacea2SKees Cook 	},
50134f5a398STheodore Ts'o #endif
5029745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP
5039745512cSArjan van de Ven 	{
5049745512cSArjan van de Ven 		.procname	= "latencytop",
5059745512cSArjan van de Ven 		.data		= &latencytop_enabled,
5069745512cSArjan van de Ven 		.maxlen		= sizeof(int),
5079745512cSArjan van de Ven 		.mode		= 0644,
5086d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
5099745512cSArjan van de Ven 	},
5109745512cSArjan van de Ven #endif
5111da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_INITRD
5121da177e4SLinus Torvalds 	{
5131da177e4SLinus Torvalds 		.procname	= "real-root-dev",
5141da177e4SLinus Torvalds 		.data		= &real_root_dev,
5151da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5161da177e4SLinus Torvalds 		.mode		= 0644,
5176d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
5181da177e4SLinus Torvalds 	},
5191da177e4SLinus Torvalds #endif
52045807a1dSIngo Molnar 	{
52145807a1dSIngo Molnar 		.procname	= "print-fatal-signals",
52245807a1dSIngo Molnar 		.data		= &print_fatal_signals,
52345807a1dSIngo Molnar 		.maxlen		= sizeof(int),
52445807a1dSIngo Molnar 		.mode		= 0644,
5256d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
52645807a1dSIngo Molnar 	},
52772c57ed5SDavid S. Miller #ifdef CONFIG_SPARC
5281da177e4SLinus Torvalds 	{
5291da177e4SLinus Torvalds 		.procname	= "reboot-cmd",
5301da177e4SLinus Torvalds 		.data		= reboot_command,
5311da177e4SLinus Torvalds 		.maxlen		= 256,
5321da177e4SLinus Torvalds 		.mode		= 0644,
5336d456111SEric W. Biederman 		.proc_handler	= proc_dostring,
5341da177e4SLinus Torvalds 	},
5351da177e4SLinus Torvalds 	{
5361da177e4SLinus Torvalds 		.procname	= "stop-a",
5371da177e4SLinus Torvalds 		.data		= &stop_a_enabled,
5381da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5391da177e4SLinus Torvalds 		.mode		= 0644,
5406d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
5411da177e4SLinus Torvalds 	},
5421da177e4SLinus Torvalds 	{
5431da177e4SLinus Torvalds 		.procname	= "scons-poweroff",
5441da177e4SLinus Torvalds 		.data		= &scons_pwroff,
5451da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5461da177e4SLinus Torvalds 		.mode		= 0644,
5476d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
5481da177e4SLinus Torvalds 	},
5491da177e4SLinus Torvalds #endif
5500871420fSDavid S. Miller #ifdef CONFIG_SPARC64
5510871420fSDavid S. Miller 	{
5520871420fSDavid S. Miller 		.procname	= "tsb-ratio",
5530871420fSDavid S. Miller 		.data		= &sysctl_tsb_ratio,
5540871420fSDavid S. Miller 		.maxlen		= sizeof (int),
5550871420fSDavid S. Miller 		.mode		= 0644,
5566d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
5570871420fSDavid S. Miller 	},
5580871420fSDavid S. Miller #endif
5591da177e4SLinus Torvalds #ifdef __hppa__
5601da177e4SLinus Torvalds 	{
5611da177e4SLinus Torvalds 		.procname	= "soft-power",
5621da177e4SLinus Torvalds 		.data		= &pwrsw_enabled,
5631da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5641da177e4SLinus Torvalds 	 	.mode		= 0644,
5656d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
5661da177e4SLinus Torvalds 	},
567bf14e3b9SVineet Gupta #endif
568bf14e3b9SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
5691da177e4SLinus Torvalds 	{
5701da177e4SLinus Torvalds 		.procname	= "unaligned-trap",
5711da177e4SLinus Torvalds 		.data		= &unaligned_enabled,
5721da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5731da177e4SLinus Torvalds 		.mode		= 0644,
5746d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
5751da177e4SLinus Torvalds 	},
5761da177e4SLinus Torvalds #endif
5771da177e4SLinus Torvalds 	{
5781da177e4SLinus Torvalds 		.procname	= "ctrl-alt-del",
5791da177e4SLinus Torvalds 		.data		= &C_A_D,
5801da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5811da177e4SLinus Torvalds 		.mode		= 0644,
5826d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
5831da177e4SLinus Torvalds 	},
584606576ceSSteven Rostedt #ifdef CONFIG_FUNCTION_TRACER
585b0fc494fSSteven Rostedt 	{
586b0fc494fSSteven Rostedt 		.procname	= "ftrace_enabled",
587b0fc494fSSteven Rostedt 		.data		= &ftrace_enabled,
588b0fc494fSSteven Rostedt 		.maxlen		= sizeof(int),
589b0fc494fSSteven Rostedt 		.mode		= 0644,
5906d456111SEric W. Biederman 		.proc_handler	= ftrace_enable_sysctl,
591b0fc494fSSteven Rostedt 	},
592b0fc494fSSteven Rostedt #endif
593f38f1d2aSSteven Rostedt #ifdef CONFIG_STACK_TRACER
594f38f1d2aSSteven Rostedt 	{
595f38f1d2aSSteven Rostedt 		.procname	= "stack_tracer_enabled",
596f38f1d2aSSteven Rostedt 		.data		= &stack_tracer_enabled,
597f38f1d2aSSteven Rostedt 		.maxlen		= sizeof(int),
598f38f1d2aSSteven Rostedt 		.mode		= 0644,
5996d456111SEric W. Biederman 		.proc_handler	= stack_trace_sysctl,
600f38f1d2aSSteven Rostedt 	},
601f38f1d2aSSteven Rostedt #endif
602944ac425SSteven Rostedt #ifdef CONFIG_TRACING
603944ac425SSteven Rostedt 	{
6043299b4ddSPeter Zijlstra 		.procname	= "ftrace_dump_on_oops",
605944ac425SSteven Rostedt 		.data		= &ftrace_dump_on_oops,
606944ac425SSteven Rostedt 		.maxlen		= sizeof(int),
607944ac425SSteven Rostedt 		.mode		= 0644,
6086d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
609944ac425SSteven Rostedt 	},
610de7edd31SSteven Rostedt (Red Hat) 	{
611de7edd31SSteven Rostedt (Red Hat) 		.procname	= "traceoff_on_warning",
612de7edd31SSteven Rostedt (Red Hat) 		.data		= &__disable_trace_on_warning,
613de7edd31SSteven Rostedt (Red Hat) 		.maxlen		= sizeof(__disable_trace_on_warning),
614de7edd31SSteven Rostedt (Red Hat) 		.mode		= 0644,
615de7edd31SSteven Rostedt (Red Hat) 		.proc_handler	= proc_dointvec,
616de7edd31SSteven Rostedt (Red Hat) 	},
6170daa2302SSteven Rostedt (Red Hat) 	{
6180daa2302SSteven Rostedt (Red Hat) 		.procname	= "tracepoint_printk",
6190daa2302SSteven Rostedt (Red Hat) 		.data		= &tracepoint_printk,
6200daa2302SSteven Rostedt (Red Hat) 		.maxlen		= sizeof(tracepoint_printk),
6210daa2302SSteven Rostedt (Red Hat) 		.mode		= 0644,
6220daa2302SSteven Rostedt (Red Hat) 		.proc_handler	= proc_dointvec,
6230daa2302SSteven Rostedt (Red Hat) 	},
624944ac425SSteven Rostedt #endif
6252965faa5SDave Young #ifdef CONFIG_KEXEC_CORE
6267984754bSKees Cook 	{
6277984754bSKees Cook 		.procname	= "kexec_load_disabled",
6287984754bSKees Cook 		.data		= &kexec_load_disabled,
6297984754bSKees Cook 		.maxlen		= sizeof(int),
6307984754bSKees Cook 		.mode		= 0644,
6317984754bSKees Cook 		/* only handle a transition from default "0" to "1" */
6327984754bSKees Cook 		.proc_handler	= proc_dointvec_minmax,
6337984754bSKees Cook 		.extra1		= &one,
6347984754bSKees Cook 		.extra2		= &one,
6357984754bSKees Cook 	},
6367984754bSKees Cook #endif
637a1ef5adbSJohannes Berg #ifdef CONFIG_MODULES
6381da177e4SLinus Torvalds 	{
6391da177e4SLinus Torvalds 		.procname	= "modprobe",
6401da177e4SLinus Torvalds 		.data		= &modprobe_path,
6411da177e4SLinus Torvalds 		.maxlen		= KMOD_PATH_LEN,
6421da177e4SLinus Torvalds 		.mode		= 0644,
6436d456111SEric W. Biederman 		.proc_handler	= proc_dostring,
6441da177e4SLinus Torvalds 	},
6453d43321bSKees Cook 	{
6463d43321bSKees Cook 		.procname	= "modules_disabled",
6473d43321bSKees Cook 		.data		= &modules_disabled,
6483d43321bSKees Cook 		.maxlen		= sizeof(int),
6493d43321bSKees Cook 		.mode		= 0644,
6503d43321bSKees Cook 		/* only handle a transition from default "0" to "1" */
6516d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
6523d43321bSKees Cook 		.extra1		= &one,
6533d43321bSKees Cook 		.extra2		= &one,
6543d43321bSKees Cook 	},
6551da177e4SLinus Torvalds #endif
65686d56134SMichael Marineau #ifdef CONFIG_UEVENT_HELPER
6571da177e4SLinus Torvalds 	{
6581da177e4SLinus Torvalds 		.procname	= "hotplug",
659312c004dSKay Sievers 		.data		= &uevent_helper,
660312c004dSKay Sievers 		.maxlen		= UEVENT_HELPER_PATH_LEN,
6611da177e4SLinus Torvalds 		.mode		= 0644,
6626d456111SEric W. Biederman 		.proc_handler	= proc_dostring,
6631da177e4SLinus Torvalds 	},
66486d56134SMichael Marineau #endif
6651da177e4SLinus Torvalds #ifdef CONFIG_CHR_DEV_SG
6661da177e4SLinus Torvalds 	{
6671da177e4SLinus Torvalds 		.procname	= "sg-big-buff",
6681da177e4SLinus Torvalds 		.data		= &sg_big_buff,
6691da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
6701da177e4SLinus Torvalds 		.mode		= 0444,
6716d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
6721da177e4SLinus Torvalds 	},
6731da177e4SLinus Torvalds #endif
6741da177e4SLinus Torvalds #ifdef CONFIG_BSD_PROCESS_ACCT
6751da177e4SLinus Torvalds 	{
6761da177e4SLinus Torvalds 		.procname	= "acct",
6771da177e4SLinus Torvalds 		.data		= &acct_parm,
6781da177e4SLinus Torvalds 		.maxlen		= 3*sizeof(int),
6791da177e4SLinus Torvalds 		.mode		= 0644,
6806d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
6811da177e4SLinus Torvalds 	},
6821da177e4SLinus Torvalds #endif
6831da177e4SLinus Torvalds #ifdef CONFIG_MAGIC_SYSRQ
6841da177e4SLinus Torvalds 	{
6851da177e4SLinus Torvalds 		.procname	= "sysrq",
6865d6f647fSIngo Molnar 		.data		= &__sysrq_enabled,
6871da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
6881da177e4SLinus Torvalds 		.mode		= 0644,
68997f5f0cdSDmitry Torokhov 		.proc_handler	= sysrq_sysctl_handler,
6901da177e4SLinus Torvalds 	},
6911da177e4SLinus Torvalds #endif
692d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL
6931da177e4SLinus Torvalds 	{
6941da177e4SLinus Torvalds 		.procname	= "cad_pid",
6959ec52099SCedric Le Goater 		.data		= NULL,
6961da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
6971da177e4SLinus Torvalds 		.mode		= 0600,
6986d456111SEric W. Biederman 		.proc_handler	= proc_do_cad_pid,
6991da177e4SLinus Torvalds 	},
700d6f8ff73SRandy Dunlap #endif
7011da177e4SLinus Torvalds 	{
7021da177e4SLinus Torvalds 		.procname	= "threads-max",
70316db3d3fSHeinrich Schuchardt 		.data		= NULL,
7041da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7051da177e4SLinus Torvalds 		.mode		= 0644,
70616db3d3fSHeinrich Schuchardt 		.proc_handler	= sysctl_max_threads,
7071da177e4SLinus Torvalds 	},
7081da177e4SLinus Torvalds 	{
7091da177e4SLinus Torvalds 		.procname	= "random",
7101da177e4SLinus Torvalds 		.mode		= 0555,
7111da177e4SLinus Torvalds 		.child		= random_table,
7121da177e4SLinus Torvalds 	},
7131da177e4SLinus Torvalds 	{
71417f60a7dSEric Paris 		.procname	= "usermodehelper",
71517f60a7dSEric Paris 		.mode		= 0555,
71617f60a7dSEric Paris 		.child		= usermodehelper_table,
71717f60a7dSEric Paris 	},
71817f60a7dSEric Paris 	{
7191da177e4SLinus Torvalds 		.procname	= "overflowuid",
7201da177e4SLinus Torvalds 		.data		= &overflowuid,
7211da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7221da177e4SLinus Torvalds 		.mode		= 0644,
7236d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
7241da177e4SLinus Torvalds 		.extra1		= &minolduid,
7251da177e4SLinus Torvalds 		.extra2		= &maxolduid,
7261da177e4SLinus Torvalds 	},
7271da177e4SLinus Torvalds 	{
7281da177e4SLinus Torvalds 		.procname	= "overflowgid",
7291da177e4SLinus Torvalds 		.data		= &overflowgid,
7301da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7311da177e4SLinus Torvalds 		.mode		= 0644,
7326d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
7331da177e4SLinus Torvalds 		.extra1		= &minolduid,
7341da177e4SLinus Torvalds 		.extra2		= &maxolduid,
7351da177e4SLinus Torvalds 	},
736347a8dc3SMartin Schwidefsky #ifdef CONFIG_S390
7371da177e4SLinus Torvalds #ifdef CONFIG_MATHEMU
7381da177e4SLinus Torvalds 	{
7391da177e4SLinus Torvalds 		.procname	= "ieee_emulation_warnings",
7401da177e4SLinus Torvalds 		.data		= &sysctl_ieee_emulation_warnings,
7411da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7421da177e4SLinus Torvalds 		.mode		= 0644,
7436d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
7441da177e4SLinus Torvalds 	},
7451da177e4SLinus Torvalds #endif
7461da177e4SLinus Torvalds 	{
7471da177e4SLinus Torvalds 		.procname	= "userprocess_debug",
748ab3c68eeSHeiko Carstens 		.data		= &show_unhandled_signals,
7491da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7501da177e4SLinus Torvalds 		.mode		= 0644,
7516d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
7521da177e4SLinus Torvalds 	},
7531da177e4SLinus Torvalds #endif
7541da177e4SLinus Torvalds 	{
7551da177e4SLinus Torvalds 		.procname	= "pid_max",
7561da177e4SLinus Torvalds 		.data		= &pid_max,
7571da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
7581da177e4SLinus Torvalds 		.mode		= 0644,
7596d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
7601da177e4SLinus Torvalds 		.extra1		= &pid_max_min,
7611da177e4SLinus Torvalds 		.extra2		= &pid_max_max,
7621da177e4SLinus Torvalds 	},
7631da177e4SLinus Torvalds 	{
7641da177e4SLinus Torvalds 		.procname	= "panic_on_oops",
7651da177e4SLinus Torvalds 		.data		= &panic_on_oops,
7661da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7671da177e4SLinus Torvalds 		.mode		= 0644,
7686d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
7691da177e4SLinus Torvalds 	},
7707ef3d2fdSJoe Perches #if defined CONFIG_PRINTK
7717ef3d2fdSJoe Perches 	{
7727ef3d2fdSJoe Perches 		.procname	= "printk",
7737ef3d2fdSJoe Perches 		.data		= &console_loglevel,
7747ef3d2fdSJoe Perches 		.maxlen		= 4*sizeof(int),
7757ef3d2fdSJoe Perches 		.mode		= 0644,
7766d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
7777ef3d2fdSJoe Perches 	},
7781da177e4SLinus Torvalds 	{
7791da177e4SLinus Torvalds 		.procname	= "printk_ratelimit",
780717115e1SDave Young 		.data		= &printk_ratelimit_state.interval,
7811da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7821da177e4SLinus Torvalds 		.mode		= 0644,
7836d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_jiffies,
7841da177e4SLinus Torvalds 	},
7851da177e4SLinus Torvalds 	{
7861da177e4SLinus Torvalds 		.procname	= "printk_ratelimit_burst",
787717115e1SDave Young 		.data		= &printk_ratelimit_state.burst,
7881da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7891da177e4SLinus Torvalds 		.mode		= 0644,
7906d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
7911da177e4SLinus Torvalds 	},
792af91322eSDave Young 	{
793af91322eSDave Young 		.procname	= "printk_delay",
794af91322eSDave Young 		.data		= &printk_delay_msec,
795af91322eSDave Young 		.maxlen		= sizeof(int),
796af91322eSDave Young 		.mode		= 0644,
7976d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
798af91322eSDave Young 		.extra1		= &zero,
799af91322eSDave Young 		.extra2		= &ten_thousand,
800af91322eSDave Young 	},
8011da177e4SLinus Torvalds 	{
802eaf06b24SDan Rosenberg 		.procname	= "dmesg_restrict",
803eaf06b24SDan Rosenberg 		.data		= &dmesg_restrict,
804eaf06b24SDan Rosenberg 		.maxlen		= sizeof(int),
805eaf06b24SDan Rosenberg 		.mode		= 0644,
806620f6e8eSKees Cook 		.proc_handler	= proc_dointvec_minmax_sysadmin,
807eaf06b24SDan Rosenberg 		.extra1		= &zero,
808eaf06b24SDan Rosenberg 		.extra2		= &one,
809eaf06b24SDan Rosenberg 	},
810455cd5abSDan Rosenberg 	{
811455cd5abSDan Rosenberg 		.procname	= "kptr_restrict",
812455cd5abSDan Rosenberg 		.data		= &kptr_restrict,
813455cd5abSDan Rosenberg 		.maxlen		= sizeof(int),
814455cd5abSDan Rosenberg 		.mode		= 0644,
815620f6e8eSKees Cook 		.proc_handler	= proc_dointvec_minmax_sysadmin,
816455cd5abSDan Rosenberg 		.extra1		= &zero,
817455cd5abSDan Rosenberg 		.extra2		= &two,
818455cd5abSDan Rosenberg 	},
819df6e61d4SJoe Perches #endif
820eaf06b24SDan Rosenberg 	{
8211da177e4SLinus Torvalds 		.procname	= "ngroups_max",
8221da177e4SLinus Torvalds 		.data		= &ngroups_max,
8231da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
8241da177e4SLinus Torvalds 		.mode		= 0444,
8256d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
8261da177e4SLinus Torvalds 	},
82773efc039SDan Ballard 	{
82873efc039SDan Ballard 		.procname	= "cap_last_cap",
82973efc039SDan Ballard 		.data		= (void *)&cap_last_cap,
83073efc039SDan Ballard 		.maxlen		= sizeof(int),
83173efc039SDan Ballard 		.mode		= 0444,
83273efc039SDan Ballard 		.proc_handler	= proc_dointvec,
83373efc039SDan Ballard 	},
83458687acbSDon Zickus #if defined(CONFIG_LOCKUP_DETECTOR)
835504d7cf1SDon Zickus 	{
83658687acbSDon Zickus 		.procname       = "watchdog",
8373c00ea82SFrederic Weisbecker 		.data           = &watchdog_user_enabled,
838504d7cf1SDon Zickus 		.maxlen         = sizeof (int),
839504d7cf1SDon Zickus 		.mode           = 0644,
840195daf66SUlrich Obergfell 		.proc_handler   = proc_watchdog,
841586692a5SMandeep Singh Baines 		.extra1		= &zero,
842586692a5SMandeep Singh Baines 		.extra2		= &one,
84358687acbSDon Zickus 	},
84458687acbSDon Zickus 	{
84558687acbSDon Zickus 		.procname	= "watchdog_thresh",
846586692a5SMandeep Singh Baines 		.data		= &watchdog_thresh,
84758687acbSDon Zickus 		.maxlen		= sizeof(int),
84858687acbSDon Zickus 		.mode		= 0644,
849195daf66SUlrich Obergfell 		.proc_handler	= proc_watchdog_thresh,
850a6572f84SLi Zefan 		.extra1		= &zero,
85158687acbSDon Zickus 		.extra2		= &sixty,
852504d7cf1SDon Zickus 	},
8532508ce18SDon Zickus 	{
854195daf66SUlrich Obergfell 		.procname       = "nmi_watchdog",
855195daf66SUlrich Obergfell 		.data           = &nmi_watchdog_enabled,
856195daf66SUlrich Obergfell 		.maxlen         = sizeof (int),
857195daf66SUlrich Obergfell 		.mode           = 0644,
858195daf66SUlrich Obergfell 		.proc_handler   = proc_nmi_watchdog,
859195daf66SUlrich Obergfell 		.extra1		= &zero,
860195daf66SUlrich Obergfell #if defined(CONFIG_HAVE_NMI_WATCHDOG) || defined(CONFIG_HARDLOCKUP_DETECTOR)
861195daf66SUlrich Obergfell 		.extra2		= &one,
862195daf66SUlrich Obergfell #else
863195daf66SUlrich Obergfell 		.extra2		= &zero,
864195daf66SUlrich Obergfell #endif
865195daf66SUlrich Obergfell 	},
866195daf66SUlrich Obergfell 	{
867195daf66SUlrich Obergfell 		.procname       = "soft_watchdog",
868195daf66SUlrich Obergfell 		.data           = &soft_watchdog_enabled,
869195daf66SUlrich Obergfell 		.maxlen         = sizeof (int),
870195daf66SUlrich Obergfell 		.mode           = 0644,
871195daf66SUlrich Obergfell 		.proc_handler   = proc_soft_watchdog,
872195daf66SUlrich Obergfell 		.extra1		= &zero,
873195daf66SUlrich Obergfell 		.extra2		= &one,
874195daf66SUlrich Obergfell 	},
875195daf66SUlrich Obergfell 	{
876fe4ba3c3SChris Metcalf 		.procname	= "watchdog_cpumask",
877fe4ba3c3SChris Metcalf 		.data		= &watchdog_cpumask_bits,
878fe4ba3c3SChris Metcalf 		.maxlen		= NR_CPUS,
879fe4ba3c3SChris Metcalf 		.mode		= 0644,
880fe4ba3c3SChris Metcalf 		.proc_handler	= proc_watchdog_cpumask,
881fe4ba3c3SChris Metcalf 	},
882fe4ba3c3SChris Metcalf 	{
8832508ce18SDon Zickus 		.procname	= "softlockup_panic",
8842508ce18SDon Zickus 		.data		= &softlockup_panic,
8852508ce18SDon Zickus 		.maxlen		= sizeof(int),
8862508ce18SDon Zickus 		.mode		= 0644,
8872508ce18SDon Zickus 		.proc_handler	= proc_dointvec_minmax,
8882508ce18SDon Zickus 		.extra1		= &zero,
8892508ce18SDon Zickus 		.extra2		= &one,
8902508ce18SDon Zickus 	},
891ed235875SAaron Tomlin #ifdef CONFIG_SMP
892ed235875SAaron Tomlin 	{
893ed235875SAaron Tomlin 		.procname	= "softlockup_all_cpu_backtrace",
894ed235875SAaron Tomlin 		.data		= &sysctl_softlockup_all_cpu_backtrace,
895ed235875SAaron Tomlin 		.maxlen		= sizeof(int),
896ed235875SAaron Tomlin 		.mode		= 0644,
897ed235875SAaron Tomlin 		.proc_handler	= proc_dointvec_minmax,
898ed235875SAaron Tomlin 		.extra1		= &zero,
899ed235875SAaron Tomlin 		.extra2		= &one,
900ed235875SAaron Tomlin 	},
901*55537871SJiri Kosina 	{
902*55537871SJiri Kosina 		.procname	= "hardlockup_all_cpu_backtrace",
903*55537871SJiri Kosina 		.data		= &sysctl_hardlockup_all_cpu_backtrace,
904*55537871SJiri Kosina 		.maxlen		= sizeof(int),
905*55537871SJiri Kosina 		.mode		= 0644,
906*55537871SJiri Kosina 		.proc_handler	= proc_dointvec_minmax,
907*55537871SJiri Kosina 		.extra1		= &zero,
908*55537871SJiri Kosina 		.extra2		= &one,
909*55537871SJiri Kosina 	},
910ed235875SAaron Tomlin #endif /* CONFIG_SMP */
9115dc30558SDon Zickus #endif
9125dc30558SDon Zickus #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
9135dc30558SDon Zickus 	{
9145dc30558SDon Zickus 		.procname       = "unknown_nmi_panic",
9155dc30558SDon Zickus 		.data           = &unknown_nmi_panic,
9165dc30558SDon Zickus 		.maxlen         = sizeof (int),
9175dc30558SDon Zickus 		.mode           = 0644,
9185dc30558SDon Zickus 		.proc_handler   = proc_dointvec,
9195dc30558SDon Zickus 	},
920504d7cf1SDon Zickus #endif
9211da177e4SLinus Torvalds #if defined(CONFIG_X86)
9221da177e4SLinus Torvalds 	{
9238da5addaSDon Zickus 		.procname	= "panic_on_unrecovered_nmi",
9248da5addaSDon Zickus 		.data		= &panic_on_unrecovered_nmi,
9258da5addaSDon Zickus 		.maxlen		= sizeof(int),
9268da5addaSDon Zickus 		.mode		= 0644,
9276d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
9288da5addaSDon Zickus 	},
9298da5addaSDon Zickus 	{
9305211a242SKurt Garloff 		.procname	= "panic_on_io_nmi",
9315211a242SKurt Garloff 		.data		= &panic_on_io_nmi,
9325211a242SKurt Garloff 		.maxlen		= sizeof(int),
9335211a242SKurt Garloff 		.mode		= 0644,
9346d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
9355211a242SKurt Garloff 	},
93655af7796SMitsuo Hayasaka #ifdef CONFIG_DEBUG_STACKOVERFLOW
93755af7796SMitsuo Hayasaka 	{
93855af7796SMitsuo Hayasaka 		.procname	= "panic_on_stackoverflow",
93955af7796SMitsuo Hayasaka 		.data		= &sysctl_panic_on_stackoverflow,
94055af7796SMitsuo Hayasaka 		.maxlen		= sizeof(int),
94155af7796SMitsuo Hayasaka 		.mode		= 0644,
94255af7796SMitsuo Hayasaka 		.proc_handler	= proc_dointvec,
94355af7796SMitsuo Hayasaka 	},
94455af7796SMitsuo Hayasaka #endif
9455211a242SKurt Garloff 	{
9461da177e4SLinus Torvalds 		.procname	= "bootloader_type",
9471da177e4SLinus Torvalds 		.data		= &bootloader_type,
9481da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
9491da177e4SLinus Torvalds 		.mode		= 0444,
9506d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
9511da177e4SLinus Torvalds 	},
9520741f4d2SChuck Ebbert 	{
9535031296cSH. Peter Anvin 		.procname	= "bootloader_version",
9545031296cSH. Peter Anvin 		.data		= &bootloader_version,
9555031296cSH. Peter Anvin 		.maxlen		= sizeof (int),
9565031296cSH. Peter Anvin 		.mode		= 0444,
9576d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
9585031296cSH. Peter Anvin 	},
9595031296cSH. Peter Anvin 	{
9600741f4d2SChuck Ebbert 		.procname	= "kstack_depth_to_print",
9610741f4d2SChuck Ebbert 		.data		= &kstack_depth_to_print,
9620741f4d2SChuck Ebbert 		.maxlen		= sizeof(int),
9630741f4d2SChuck Ebbert 		.mode		= 0644,
9646d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
9650741f4d2SChuck Ebbert 	},
9666e7c4025SIngo Molnar 	{
9676e7c4025SIngo Molnar 		.procname	= "io_delay_type",
9686e7c4025SIngo Molnar 		.data		= &io_delay_type,
9696e7c4025SIngo Molnar 		.maxlen		= sizeof(int),
9706e7c4025SIngo Molnar 		.mode		= 0644,
9716d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
9726e7c4025SIngo Molnar 	},
9731da177e4SLinus Torvalds #endif
9747a9166e3SLuke Yang #if defined(CONFIG_MMU)
9751da177e4SLinus Torvalds 	{
9761da177e4SLinus Torvalds 		.procname	= "randomize_va_space",
9771da177e4SLinus Torvalds 		.data		= &randomize_va_space,
9781da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
9791da177e4SLinus Torvalds 		.mode		= 0644,
9806d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
9811da177e4SLinus Torvalds 	},
9827a9166e3SLuke Yang #endif
9830152fb37SMartin Schwidefsky #if defined(CONFIG_S390) && defined(CONFIG_SMP)
984951f22d5SMartin Schwidefsky 	{
985951f22d5SMartin Schwidefsky 		.procname	= "spin_retry",
986951f22d5SMartin Schwidefsky 		.data		= &spin_retry,
987951f22d5SMartin Schwidefsky 		.maxlen		= sizeof (int),
988951f22d5SMartin Schwidefsky 		.mode		= 0644,
9896d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
990951f22d5SMartin Schwidefsky 	},
991951f22d5SMartin Schwidefsky #endif
992673d5b43SLen Brown #if	defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
993c255d844SPavel Machek 	{
994c255d844SPavel Machek 		.procname	= "acpi_video_flags",
99577afcf78SPavel Machek 		.data		= &acpi_realmode_flags,
996c255d844SPavel Machek 		.maxlen		= sizeof (unsigned long),
997c255d844SPavel Machek 		.mode		= 0644,
9986d456111SEric W. Biederman 		.proc_handler	= proc_doulongvec_minmax,
999c255d844SPavel Machek 	},
1000c255d844SPavel Machek #endif
1001b6fca725SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1002d2b176edSJes Sorensen 	{
1003d2b176edSJes Sorensen 		.procname	= "ignore-unaligned-usertrap",
1004d2b176edSJes Sorensen 		.data		= &no_unaligned_warning,
1005d2b176edSJes Sorensen 		.maxlen		= sizeof (int),
1006d2b176edSJes Sorensen 	 	.mode		= 0644,
10076d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1008d2b176edSJes Sorensen 	},
1009b6fca725SVineet Gupta #endif
1010b6fca725SVineet Gupta #ifdef CONFIG_IA64
101188fc241fSDoug Chapman 	{
101288fc241fSDoug Chapman 		.procname	= "unaligned-dump-stack",
101388fc241fSDoug Chapman 		.data		= &unaligned_dump_stack,
101488fc241fSDoug Chapman 		.maxlen		= sizeof (int),
101588fc241fSDoug Chapman 		.mode		= 0644,
10166d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
101788fc241fSDoug Chapman 	},
1018d2b176edSJes Sorensen #endif
1019e162b39aSMandeep Singh Baines #ifdef CONFIG_DETECT_HUNG_TASK
1020e162b39aSMandeep Singh Baines 	{
1021e162b39aSMandeep Singh Baines 		.procname	= "hung_task_panic",
1022e162b39aSMandeep Singh Baines 		.data		= &sysctl_hung_task_panic,
1023e162b39aSMandeep Singh Baines 		.maxlen		= sizeof(int),
1024e162b39aSMandeep Singh Baines 		.mode		= 0644,
10256d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
1026e162b39aSMandeep Singh Baines 		.extra1		= &zero,
1027e162b39aSMandeep Singh Baines 		.extra2		= &one,
1028e162b39aSMandeep Singh Baines 	},
102982a1fcb9SIngo Molnar 	{
103082a1fcb9SIngo Molnar 		.procname	= "hung_task_check_count",
103182a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_check_count,
1032cd64647fSLi Zefan 		.maxlen		= sizeof(int),
103382a1fcb9SIngo Molnar 		.mode		= 0644,
1034cd64647fSLi Zefan 		.proc_handler	= proc_dointvec_minmax,
1035cd64647fSLi Zefan 		.extra1		= &zero,
103682a1fcb9SIngo Molnar 	},
103782a1fcb9SIngo Molnar 	{
103882a1fcb9SIngo Molnar 		.procname	= "hung_task_timeout_secs",
103982a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_timeout_secs,
104090739081SIngo Molnar 		.maxlen		= sizeof(unsigned long),
104182a1fcb9SIngo Molnar 		.mode		= 0644,
10426d456111SEric W. Biederman 		.proc_handler	= proc_dohung_task_timeout_secs,
104380df2847SLiu Hua 		.extra2		= &hung_task_timeout_max,
104482a1fcb9SIngo Molnar 	},
104582a1fcb9SIngo Molnar 	{
104682a1fcb9SIngo Molnar 		.procname	= "hung_task_warnings",
104782a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_warnings,
1048270750dbSAaron Tomlin 		.maxlen		= sizeof(int),
104982a1fcb9SIngo Molnar 		.mode		= 0644,
1050270750dbSAaron Tomlin 		.proc_handler	= proc_dointvec_minmax,
1051270750dbSAaron Tomlin 		.extra1		= &neg_one,
105282a1fcb9SIngo Molnar 	},
1053c4f3b63fSRavikiran G Thirumalai #endif
1054bebfa101SAndi Kleen #ifdef CONFIG_COMPAT
1055bebfa101SAndi Kleen 	{
1056bebfa101SAndi Kleen 		.procname	= "compat-log",
1057bebfa101SAndi Kleen 		.data		= &compat_log,
1058bebfa101SAndi Kleen 		.maxlen		= sizeof (int),
1059bebfa101SAndi Kleen 	 	.mode		= 0644,
10606d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1061bebfa101SAndi Kleen 	},
1062bebfa101SAndi Kleen #endif
106323f78d4aSIngo Molnar #ifdef CONFIG_RT_MUTEXES
106423f78d4aSIngo Molnar 	{
106523f78d4aSIngo Molnar 		.procname	= "max_lock_depth",
106623f78d4aSIngo Molnar 		.data		= &max_lock_depth,
106723f78d4aSIngo Molnar 		.maxlen		= sizeof(int),
106823f78d4aSIngo Molnar 		.mode		= 0644,
10696d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
107023f78d4aSIngo Molnar 	},
107123f78d4aSIngo Molnar #endif
107210a0a8d4SJeremy Fitzhardinge 	{
107310a0a8d4SJeremy Fitzhardinge 		.procname	= "poweroff_cmd",
107410a0a8d4SJeremy Fitzhardinge 		.data		= &poweroff_cmd,
107510a0a8d4SJeremy Fitzhardinge 		.maxlen		= POWEROFF_CMD_PATH_LEN,
107610a0a8d4SJeremy Fitzhardinge 		.mode		= 0644,
10776d456111SEric W. Biederman 		.proc_handler	= proc_dostring,
107810a0a8d4SJeremy Fitzhardinge 	},
10790b77f5bfSDavid Howells #ifdef CONFIG_KEYS
10800b77f5bfSDavid Howells 	{
10810b77f5bfSDavid Howells 		.procname	= "keys",
10820b77f5bfSDavid Howells 		.mode		= 0555,
10830b77f5bfSDavid Howells 		.child		= key_sysctls,
10840b77f5bfSDavid Howells 	},
10850b77f5bfSDavid Howells #endif
1086cdd6c482SIngo Molnar #ifdef CONFIG_PERF_EVENTS
1087aa4a2218SVince Weaver 	/*
1088aa4a2218SVince Weaver 	 * User-space scripts rely on the existence of this file
1089aa4a2218SVince Weaver 	 * as a feature check for perf_events being enabled.
1090aa4a2218SVince Weaver 	 *
1091aa4a2218SVince Weaver 	 * So it's an ABI, do not remove!
1092aa4a2218SVince Weaver 	 */
10931ccd1549SPeter Zijlstra 	{
1094cdd6c482SIngo Molnar 		.procname	= "perf_event_paranoid",
1095cdd6c482SIngo Molnar 		.data		= &sysctl_perf_event_paranoid,
1096cdd6c482SIngo Molnar 		.maxlen		= sizeof(sysctl_perf_event_paranoid),
10971ccd1549SPeter Zijlstra 		.mode		= 0644,
10986d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
10991ccd1549SPeter Zijlstra 	},
1100c5078f78SPeter Zijlstra 	{
1101cdd6c482SIngo Molnar 		.procname	= "perf_event_mlock_kb",
1102cdd6c482SIngo Molnar 		.data		= &sysctl_perf_event_mlock,
1103cdd6c482SIngo Molnar 		.maxlen		= sizeof(sysctl_perf_event_mlock),
1104c5078f78SPeter Zijlstra 		.mode		= 0644,
11056d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1106c5078f78SPeter Zijlstra 	},
1107a78ac325SPeter Zijlstra 	{
1108cdd6c482SIngo Molnar 		.procname	= "perf_event_max_sample_rate",
1109cdd6c482SIngo Molnar 		.data		= &sysctl_perf_event_sample_rate,
1110cdd6c482SIngo Molnar 		.maxlen		= sizeof(sysctl_perf_event_sample_rate),
1111a78ac325SPeter Zijlstra 		.mode		= 0644,
1112163ec435SPeter Zijlstra 		.proc_handler	= perf_proc_update_handler,
1113723478c8SKnut Petersen 		.extra1		= &one,
1114a78ac325SPeter Zijlstra 	},
111514c63f17SDave Hansen 	{
111614c63f17SDave Hansen 		.procname	= "perf_cpu_time_max_percent",
111714c63f17SDave Hansen 		.data		= &sysctl_perf_cpu_time_max_percent,
111814c63f17SDave Hansen 		.maxlen		= sizeof(sysctl_perf_cpu_time_max_percent),
111914c63f17SDave Hansen 		.mode		= 0644,
112014c63f17SDave Hansen 		.proc_handler	= perf_cpu_time_max_percent_handler,
112114c63f17SDave Hansen 		.extra1		= &zero,
112214c63f17SDave Hansen 		.extra2		= &one_hundred,
112314c63f17SDave Hansen 	},
11241ccd1549SPeter Zijlstra #endif
1125dfec072eSVegard Nossum #ifdef CONFIG_KMEMCHECK
1126dfec072eSVegard Nossum 	{
1127dfec072eSVegard Nossum 		.procname	= "kmemcheck",
1128dfec072eSVegard Nossum 		.data		= &kmemcheck_enabled,
1129dfec072eSVegard Nossum 		.maxlen		= sizeof(int),
1130dfec072eSVegard Nossum 		.mode		= 0644,
11316d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1132dfec072eSVegard Nossum 	},
1133dfec072eSVegard Nossum #endif
11349e3961a0SPrarit Bhargava 	{
11359e3961a0SPrarit Bhargava 		.procname	= "panic_on_warn",
11369e3961a0SPrarit Bhargava 		.data		= &panic_on_warn,
11379e3961a0SPrarit Bhargava 		.maxlen		= sizeof(int),
11389e3961a0SPrarit Bhargava 		.mode		= 0644,
11399e3961a0SPrarit Bhargava 		.proc_handler	= proc_dointvec_minmax,
11409e3961a0SPrarit Bhargava 		.extra1		= &zero,
11419e3961a0SPrarit Bhargava 		.extra2		= &one,
11429e3961a0SPrarit Bhargava 	},
1143bc7a34b8SThomas Gleixner #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
1144bc7a34b8SThomas Gleixner 	{
1145bc7a34b8SThomas Gleixner 		.procname	= "timer_migration",
1146bc7a34b8SThomas Gleixner 		.data		= &sysctl_timer_migration,
1147bc7a34b8SThomas Gleixner 		.maxlen		= sizeof(unsigned int),
1148bc7a34b8SThomas Gleixner 		.mode		= 0644,
1149bc7a34b8SThomas Gleixner 		.proc_handler	= timer_migration_handler,
1150bc7a34b8SThomas Gleixner 	},
1151bc7a34b8SThomas Gleixner #endif
11521be7f75dSAlexei Starovoitov #ifdef CONFIG_BPF_SYSCALL
11531be7f75dSAlexei Starovoitov 	{
11541be7f75dSAlexei Starovoitov 		.procname	= "unprivileged_bpf_disabled",
11551be7f75dSAlexei Starovoitov 		.data		= &sysctl_unprivileged_bpf_disabled,
11561be7f75dSAlexei Starovoitov 		.maxlen		= sizeof(sysctl_unprivileged_bpf_disabled),
11571be7f75dSAlexei Starovoitov 		.mode		= 0644,
11581be7f75dSAlexei Starovoitov 		/* only handle a transition from default "0" to "1" */
11591be7f75dSAlexei Starovoitov 		.proc_handler	= proc_dointvec_minmax,
11601be7f75dSAlexei Starovoitov 		.extra1		= &one,
11611be7f75dSAlexei Starovoitov 		.extra2		= &one,
11621be7f75dSAlexei Starovoitov 	},
11631be7f75dSAlexei Starovoitov #endif
11646fce56ecSEric W. Biederman 	{ }
11651da177e4SLinus Torvalds };
11661da177e4SLinus Torvalds 
1167d8217f07SEric W. Biederman static struct ctl_table vm_table[] = {
11681da177e4SLinus Torvalds 	{
11691da177e4SLinus Torvalds 		.procname	= "overcommit_memory",
11701da177e4SLinus Torvalds 		.data		= &sysctl_overcommit_memory,
11711da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_overcommit_memory),
11721da177e4SLinus Torvalds 		.mode		= 0644,
1173cb16e95fSPetr Holasek 		.proc_handler	= proc_dointvec_minmax,
1174cb16e95fSPetr Holasek 		.extra1		= &zero,
1175cb16e95fSPetr Holasek 		.extra2		= &two,
11761da177e4SLinus Torvalds 	},
11771da177e4SLinus Torvalds 	{
1178fadd8fbdSKAMEZAWA Hiroyuki 		.procname	= "panic_on_oom",
1179fadd8fbdSKAMEZAWA Hiroyuki 		.data		= &sysctl_panic_on_oom,
1180fadd8fbdSKAMEZAWA Hiroyuki 		.maxlen		= sizeof(sysctl_panic_on_oom),
1181fadd8fbdSKAMEZAWA Hiroyuki 		.mode		= 0644,
1182cb16e95fSPetr Holasek 		.proc_handler	= proc_dointvec_minmax,
1183cb16e95fSPetr Holasek 		.extra1		= &zero,
1184cb16e95fSPetr Holasek 		.extra2		= &two,
1185fadd8fbdSKAMEZAWA Hiroyuki 	},
1186fadd8fbdSKAMEZAWA Hiroyuki 	{
1187fe071d7eSDavid Rientjes 		.procname	= "oom_kill_allocating_task",
1188fe071d7eSDavid Rientjes 		.data		= &sysctl_oom_kill_allocating_task,
1189fe071d7eSDavid Rientjes 		.maxlen		= sizeof(sysctl_oom_kill_allocating_task),
1190fe071d7eSDavid Rientjes 		.mode		= 0644,
11916d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1192fe071d7eSDavid Rientjes 	},
1193fe071d7eSDavid Rientjes 	{
1194fef1bdd6SDavid Rientjes 		.procname	= "oom_dump_tasks",
1195fef1bdd6SDavid Rientjes 		.data		= &sysctl_oom_dump_tasks,
1196fef1bdd6SDavid Rientjes 		.maxlen		= sizeof(sysctl_oom_dump_tasks),
1197fef1bdd6SDavid Rientjes 		.mode		= 0644,
11986d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1199fef1bdd6SDavid Rientjes 	},
1200fef1bdd6SDavid Rientjes 	{
12011da177e4SLinus Torvalds 		.procname	= "overcommit_ratio",
12021da177e4SLinus Torvalds 		.data		= &sysctl_overcommit_ratio,
12031da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_overcommit_ratio),
12041da177e4SLinus Torvalds 		.mode		= 0644,
120549f0ce5fSJerome Marchand 		.proc_handler	= overcommit_ratio_handler,
120649f0ce5fSJerome Marchand 	},
120749f0ce5fSJerome Marchand 	{
120849f0ce5fSJerome Marchand 		.procname	= "overcommit_kbytes",
120949f0ce5fSJerome Marchand 		.data		= &sysctl_overcommit_kbytes,
121049f0ce5fSJerome Marchand 		.maxlen		= sizeof(sysctl_overcommit_kbytes),
121149f0ce5fSJerome Marchand 		.mode		= 0644,
121249f0ce5fSJerome Marchand 		.proc_handler	= overcommit_kbytes_handler,
12131da177e4SLinus Torvalds 	},
12141da177e4SLinus Torvalds 	{
12151da177e4SLinus Torvalds 		.procname	= "page-cluster",
12161da177e4SLinus Torvalds 		.data		= &page_cluster,
12171da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
12181da177e4SLinus Torvalds 		.mode		= 0644,
1219cb16e95fSPetr Holasek 		.proc_handler	= proc_dointvec_minmax,
1220cb16e95fSPetr Holasek 		.extra1		= &zero,
12211da177e4SLinus Torvalds 	},
12221da177e4SLinus Torvalds 	{
12231da177e4SLinus Torvalds 		.procname	= "dirty_background_ratio",
12241da177e4SLinus Torvalds 		.data		= &dirty_background_ratio,
12251da177e4SLinus Torvalds 		.maxlen		= sizeof(dirty_background_ratio),
12261da177e4SLinus Torvalds 		.mode		= 0644,
12276d456111SEric W. Biederman 		.proc_handler	= dirty_background_ratio_handler,
12281da177e4SLinus Torvalds 		.extra1		= &zero,
12291da177e4SLinus Torvalds 		.extra2		= &one_hundred,
12301da177e4SLinus Torvalds 	},
12311da177e4SLinus Torvalds 	{
12322da02997SDavid Rientjes 		.procname	= "dirty_background_bytes",
12332da02997SDavid Rientjes 		.data		= &dirty_background_bytes,
12342da02997SDavid Rientjes 		.maxlen		= sizeof(dirty_background_bytes),
12352da02997SDavid Rientjes 		.mode		= 0644,
12366d456111SEric W. Biederman 		.proc_handler	= dirty_background_bytes_handler,
1237fc3501d4SSven Wegener 		.extra1		= &one_ul,
12382da02997SDavid Rientjes 	},
12392da02997SDavid Rientjes 	{
12401da177e4SLinus Torvalds 		.procname	= "dirty_ratio",
12411da177e4SLinus Torvalds 		.data		= &vm_dirty_ratio,
12421da177e4SLinus Torvalds 		.maxlen		= sizeof(vm_dirty_ratio),
12431da177e4SLinus Torvalds 		.mode		= 0644,
12446d456111SEric W. Biederman 		.proc_handler	= dirty_ratio_handler,
12451da177e4SLinus Torvalds 		.extra1		= &zero,
12461da177e4SLinus Torvalds 		.extra2		= &one_hundred,
12471da177e4SLinus Torvalds 	},
12481da177e4SLinus Torvalds 	{
12492da02997SDavid Rientjes 		.procname	= "dirty_bytes",
12502da02997SDavid Rientjes 		.data		= &vm_dirty_bytes,
12512da02997SDavid Rientjes 		.maxlen		= sizeof(vm_dirty_bytes),
12522da02997SDavid Rientjes 		.mode		= 0644,
12536d456111SEric W. Biederman 		.proc_handler	= dirty_bytes_handler,
12549e4a5bdaSAndrea Righi 		.extra1		= &dirty_bytes_min,
12552da02997SDavid Rientjes 	},
12562da02997SDavid Rientjes 	{
12571da177e4SLinus Torvalds 		.procname	= "dirty_writeback_centisecs",
1258f6ef9438SBart Samwel 		.data		= &dirty_writeback_interval,
1259f6ef9438SBart Samwel 		.maxlen		= sizeof(dirty_writeback_interval),
12601da177e4SLinus Torvalds 		.mode		= 0644,
12616d456111SEric W. Biederman 		.proc_handler	= dirty_writeback_centisecs_handler,
12621da177e4SLinus Torvalds 	},
12631da177e4SLinus Torvalds 	{
12641da177e4SLinus Torvalds 		.procname	= "dirty_expire_centisecs",
1265f6ef9438SBart Samwel 		.data		= &dirty_expire_interval,
1266f6ef9438SBart Samwel 		.maxlen		= sizeof(dirty_expire_interval),
12671da177e4SLinus Torvalds 		.mode		= 0644,
1268cb16e95fSPetr Holasek 		.proc_handler	= proc_dointvec_minmax,
1269cb16e95fSPetr Holasek 		.extra1		= &zero,
12701da177e4SLinus Torvalds 	},
12711da177e4SLinus Torvalds 	{
12721efff914STheodore Ts'o 		.procname	= "dirtytime_expire_seconds",
12731efff914STheodore Ts'o 		.data		= &dirtytime_expire_interval,
12741efff914STheodore Ts'o 		.maxlen		= sizeof(dirty_expire_interval),
12751efff914STheodore Ts'o 		.mode		= 0644,
12761efff914STheodore Ts'o 		.proc_handler	= dirtytime_interval_handler,
12771efff914STheodore Ts'o 		.extra1		= &zero,
12781efff914STheodore Ts'o 	},
12791efff914STheodore Ts'o 	{
12801da177e4SLinus Torvalds 		.procname       = "nr_pdflush_threads",
12811da177e4SLinus Torvalds 		.mode           = 0444 /* read-only */,
12823965c9aeSWanpeng Li 		.proc_handler   = pdflush_proc_obsolete,
12831da177e4SLinus Torvalds 	},
12841da177e4SLinus Torvalds 	{
12851da177e4SLinus Torvalds 		.procname	= "swappiness",
12861da177e4SLinus Torvalds 		.data		= &vm_swappiness,
12871da177e4SLinus Torvalds 		.maxlen		= sizeof(vm_swappiness),
12881da177e4SLinus Torvalds 		.mode		= 0644,
12896d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
12901da177e4SLinus Torvalds 		.extra1		= &zero,
12911da177e4SLinus Torvalds 		.extra2		= &one_hundred,
12921da177e4SLinus Torvalds 	},
12931da177e4SLinus Torvalds #ifdef CONFIG_HUGETLB_PAGE
12941da177e4SLinus Torvalds 	{
12951da177e4SLinus Torvalds 		.procname	= "nr_hugepages",
1296e5ff2159SAndi Kleen 		.data		= NULL,
12971da177e4SLinus Torvalds 		.maxlen		= sizeof(unsigned long),
12981da177e4SLinus Torvalds 		.mode		= 0644,
12996d456111SEric W. Biederman 		.proc_handler	= hugetlb_sysctl_handler,
13001da177e4SLinus Torvalds 	},
130106808b08SLee Schermerhorn #ifdef CONFIG_NUMA
130206808b08SLee Schermerhorn 	{
130306808b08SLee Schermerhorn 		.procname       = "nr_hugepages_mempolicy",
130406808b08SLee Schermerhorn 		.data           = NULL,
130506808b08SLee Schermerhorn 		.maxlen         = sizeof(unsigned long),
130606808b08SLee Schermerhorn 		.mode           = 0644,
130706808b08SLee Schermerhorn 		.proc_handler   = &hugetlb_mempolicy_sysctl_handler,
130806808b08SLee Schermerhorn 	},
130906808b08SLee Schermerhorn #endif
13101da177e4SLinus Torvalds 	 {
13111da177e4SLinus Torvalds 		.procname	= "hugetlb_shm_group",
13121da177e4SLinus Torvalds 		.data		= &sysctl_hugetlb_shm_group,
13131da177e4SLinus Torvalds 		.maxlen		= sizeof(gid_t),
13141da177e4SLinus Torvalds 		.mode		= 0644,
13156d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
13161da177e4SLinus Torvalds 	 },
1317396faf03SMel Gorman 	 {
1318396faf03SMel Gorman 		.procname	= "hugepages_treat_as_movable",
1319396faf03SMel Gorman 		.data		= &hugepages_treat_as_movable,
1320396faf03SMel Gorman 		.maxlen		= sizeof(int),
1321396faf03SMel Gorman 		.mode		= 0644,
132286cdb465SNaoya Horiguchi 		.proc_handler	= proc_dointvec,
1323396faf03SMel Gorman 	},
132454f9f80dSAdam Litke 	{
1325d1c3fb1fSNishanth Aravamudan 		.procname	= "nr_overcommit_hugepages",
1326e5ff2159SAndi Kleen 		.data		= NULL,
1327e5ff2159SAndi Kleen 		.maxlen		= sizeof(unsigned long),
1328d1c3fb1fSNishanth Aravamudan 		.mode		= 0644,
13296d456111SEric W. Biederman 		.proc_handler	= hugetlb_overcommit_handler,
1330d1c3fb1fSNishanth Aravamudan 	},
13311da177e4SLinus Torvalds #endif
13321da177e4SLinus Torvalds 	{
13331da177e4SLinus Torvalds 		.procname	= "lowmem_reserve_ratio",
13341da177e4SLinus Torvalds 		.data		= &sysctl_lowmem_reserve_ratio,
13351da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
13361da177e4SLinus Torvalds 		.mode		= 0644,
13376d456111SEric W. Biederman 		.proc_handler	= lowmem_reserve_ratio_sysctl_handler,
13381da177e4SLinus Torvalds 	},
13391da177e4SLinus Torvalds 	{
13409d0243bcSAndrew Morton 		.procname	= "drop_caches",
13419d0243bcSAndrew Morton 		.data		= &sysctl_drop_caches,
13429d0243bcSAndrew Morton 		.maxlen		= sizeof(int),
13439d0243bcSAndrew Morton 		.mode		= 0644,
13449d0243bcSAndrew Morton 		.proc_handler	= drop_caches_sysctl_handler,
1345cb16e95fSPetr Holasek 		.extra1		= &one,
13465509a5d2SDave Hansen 		.extra2		= &four,
13479d0243bcSAndrew Morton 	},
134876ab0f53SMel Gorman #ifdef CONFIG_COMPACTION
134976ab0f53SMel Gorman 	{
135076ab0f53SMel Gorman 		.procname	= "compact_memory",
135176ab0f53SMel Gorman 		.data		= &sysctl_compact_memory,
135276ab0f53SMel Gorman 		.maxlen		= sizeof(int),
135376ab0f53SMel Gorman 		.mode		= 0200,
135476ab0f53SMel Gorman 		.proc_handler	= sysctl_compaction_handler,
135576ab0f53SMel Gorman 	},
13565e771905SMel Gorman 	{
13575e771905SMel Gorman 		.procname	= "extfrag_threshold",
13585e771905SMel Gorman 		.data		= &sysctl_extfrag_threshold,
13595e771905SMel Gorman 		.maxlen		= sizeof(int),
13605e771905SMel Gorman 		.mode		= 0644,
13615e771905SMel Gorman 		.proc_handler	= sysctl_extfrag_handler,
13625e771905SMel Gorman 		.extra1		= &min_extfrag_threshold,
13635e771905SMel Gorman 		.extra2		= &max_extfrag_threshold,
13645e771905SMel Gorman 	},
13655bbe3547SEric B Munson 	{
13665bbe3547SEric B Munson 		.procname	= "compact_unevictable_allowed",
13675bbe3547SEric B Munson 		.data		= &sysctl_compact_unevictable_allowed,
13685bbe3547SEric B Munson 		.maxlen		= sizeof(int),
13695bbe3547SEric B Munson 		.mode		= 0644,
13705bbe3547SEric B Munson 		.proc_handler	= proc_dointvec,
13715bbe3547SEric B Munson 		.extra1		= &zero,
13725bbe3547SEric B Munson 		.extra2		= &one,
13735bbe3547SEric B Munson 	},
13745e771905SMel Gorman 
137576ab0f53SMel Gorman #endif /* CONFIG_COMPACTION */
13769d0243bcSAndrew Morton 	{
13771da177e4SLinus Torvalds 		.procname	= "min_free_kbytes",
13781da177e4SLinus Torvalds 		.data		= &min_free_kbytes,
13791da177e4SLinus Torvalds 		.maxlen		= sizeof(min_free_kbytes),
13801da177e4SLinus Torvalds 		.mode		= 0644,
13816d456111SEric W. Biederman 		.proc_handler	= min_free_kbytes_sysctl_handler,
13821da177e4SLinus Torvalds 		.extra1		= &zero,
13831da177e4SLinus Torvalds 	},
13848ad4b1fbSRohit Seth 	{
13858ad4b1fbSRohit Seth 		.procname	= "percpu_pagelist_fraction",
13868ad4b1fbSRohit Seth 		.data		= &percpu_pagelist_fraction,
13878ad4b1fbSRohit Seth 		.maxlen		= sizeof(percpu_pagelist_fraction),
13888ad4b1fbSRohit Seth 		.mode		= 0644,
13896d456111SEric W. Biederman 		.proc_handler	= percpu_pagelist_fraction_sysctl_handler,
13907cd2b0a3SDavid Rientjes 		.extra1		= &zero,
13918ad4b1fbSRohit Seth 	},
13921da177e4SLinus Torvalds #ifdef CONFIG_MMU
13931da177e4SLinus Torvalds 	{
13941da177e4SLinus Torvalds 		.procname	= "max_map_count",
13951da177e4SLinus Torvalds 		.data		= &sysctl_max_map_count,
13961da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_max_map_count),
13971da177e4SLinus Torvalds 		.mode		= 0644,
13983e26120cSWANG Cong 		.proc_handler	= proc_dointvec_minmax,
139970da2340SAmerigo Wang 		.extra1		= &zero,
14001da177e4SLinus Torvalds 	},
1401dd8632a1SPaul Mundt #else
1402dd8632a1SPaul Mundt 	{
1403dd8632a1SPaul Mundt 		.procname	= "nr_trim_pages",
1404dd8632a1SPaul Mundt 		.data		= &sysctl_nr_trim_pages,
1405dd8632a1SPaul Mundt 		.maxlen		= sizeof(sysctl_nr_trim_pages),
1406dd8632a1SPaul Mundt 		.mode		= 0644,
14076d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
1408dd8632a1SPaul Mundt 		.extra1		= &zero,
1409dd8632a1SPaul Mundt 	},
14101da177e4SLinus Torvalds #endif
14111da177e4SLinus Torvalds 	{
14121da177e4SLinus Torvalds 		.procname	= "laptop_mode",
14131da177e4SLinus Torvalds 		.data		= &laptop_mode,
14141da177e4SLinus Torvalds 		.maxlen		= sizeof(laptop_mode),
14151da177e4SLinus Torvalds 		.mode		= 0644,
14166d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_jiffies,
14171da177e4SLinus Torvalds 	},
14181da177e4SLinus Torvalds 	{
14191da177e4SLinus Torvalds 		.procname	= "block_dump",
14201da177e4SLinus Torvalds 		.data		= &block_dump,
14211da177e4SLinus Torvalds 		.maxlen		= sizeof(block_dump),
14221da177e4SLinus Torvalds 		.mode		= 0644,
14236d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
14241da177e4SLinus Torvalds 		.extra1		= &zero,
14251da177e4SLinus Torvalds 	},
14261da177e4SLinus Torvalds 	{
14271da177e4SLinus Torvalds 		.procname	= "vfs_cache_pressure",
14281da177e4SLinus Torvalds 		.data		= &sysctl_vfs_cache_pressure,
14291da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
14301da177e4SLinus Torvalds 		.mode		= 0644,
14316d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
14321da177e4SLinus Torvalds 		.extra1		= &zero,
14331da177e4SLinus Torvalds 	},
14341da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
14351da177e4SLinus Torvalds 	{
14361da177e4SLinus Torvalds 		.procname	= "legacy_va_layout",
14371da177e4SLinus Torvalds 		.data		= &sysctl_legacy_va_layout,
14381da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_legacy_va_layout),
14391da177e4SLinus Torvalds 		.mode		= 0644,
14406d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
14411da177e4SLinus Torvalds 		.extra1		= &zero,
14421da177e4SLinus Torvalds 	},
14431da177e4SLinus Torvalds #endif
14441743660bSChristoph Lameter #ifdef CONFIG_NUMA
14451743660bSChristoph Lameter 	{
14461743660bSChristoph Lameter 		.procname	= "zone_reclaim_mode",
14471743660bSChristoph Lameter 		.data		= &zone_reclaim_mode,
14481743660bSChristoph Lameter 		.maxlen		= sizeof(zone_reclaim_mode),
14491743660bSChristoph Lameter 		.mode		= 0644,
14506d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1451c84db23cSChristoph Lameter 		.extra1		= &zero,
14521743660bSChristoph Lameter 	},
14539614634fSChristoph Lameter 	{
14549614634fSChristoph Lameter 		.procname	= "min_unmapped_ratio",
14559614634fSChristoph Lameter 		.data		= &sysctl_min_unmapped_ratio,
14569614634fSChristoph Lameter 		.maxlen		= sizeof(sysctl_min_unmapped_ratio),
14579614634fSChristoph Lameter 		.mode		= 0644,
14586d456111SEric W. Biederman 		.proc_handler	= sysctl_min_unmapped_ratio_sysctl_handler,
14599614634fSChristoph Lameter 		.extra1		= &zero,
14609614634fSChristoph Lameter 		.extra2		= &one_hundred,
14619614634fSChristoph Lameter 	},
14620ff38490SChristoph Lameter 	{
14630ff38490SChristoph Lameter 		.procname	= "min_slab_ratio",
14640ff38490SChristoph Lameter 		.data		= &sysctl_min_slab_ratio,
14650ff38490SChristoph Lameter 		.maxlen		= sizeof(sysctl_min_slab_ratio),
14660ff38490SChristoph Lameter 		.mode		= 0644,
14676d456111SEric W. Biederman 		.proc_handler	= sysctl_min_slab_ratio_sysctl_handler,
14680ff38490SChristoph Lameter 		.extra1		= &zero,
14690ff38490SChristoph Lameter 		.extra2		= &one_hundred,
14700ff38490SChristoph Lameter 	},
14711743660bSChristoph Lameter #endif
147277461ab3SChristoph Lameter #ifdef CONFIG_SMP
147377461ab3SChristoph Lameter 	{
147477461ab3SChristoph Lameter 		.procname	= "stat_interval",
147577461ab3SChristoph Lameter 		.data		= &sysctl_stat_interval,
147677461ab3SChristoph Lameter 		.maxlen		= sizeof(sysctl_stat_interval),
147777461ab3SChristoph Lameter 		.mode		= 0644,
14786d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_jiffies,
147977461ab3SChristoph Lameter 	},
148077461ab3SChristoph Lameter #endif
14816e141546SDavid Howells #ifdef CONFIG_MMU
1482ed032189SEric Paris 	{
1483ed032189SEric Paris 		.procname	= "mmap_min_addr",
1484788084abSEric Paris 		.data		= &dac_mmap_min_addr,
1485ed032189SEric Paris 		.maxlen		= sizeof(unsigned long),
1486ed032189SEric Paris 		.mode		= 0644,
14876d456111SEric W. Biederman 		.proc_handler	= mmap_min_addr_handler,
1488ed032189SEric Paris 	},
14896e141546SDavid Howells #endif
1490f0c0b2b8SKAMEZAWA Hiroyuki #ifdef CONFIG_NUMA
1491f0c0b2b8SKAMEZAWA Hiroyuki 	{
1492f0c0b2b8SKAMEZAWA Hiroyuki 		.procname	= "numa_zonelist_order",
1493f0c0b2b8SKAMEZAWA Hiroyuki 		.data		= &numa_zonelist_order,
1494f0c0b2b8SKAMEZAWA Hiroyuki 		.maxlen		= NUMA_ZONELIST_ORDER_LEN,
1495f0c0b2b8SKAMEZAWA Hiroyuki 		.mode		= 0644,
14966d456111SEric W. Biederman 		.proc_handler	= numa_zonelist_order_handler,
1497f0c0b2b8SKAMEZAWA Hiroyuki 	},
1498f0c0b2b8SKAMEZAWA Hiroyuki #endif
14992b8232ceSAl Viro #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
15005c36e657SPaul Mundt    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
1501e6e5494cSIngo Molnar 	{
1502e6e5494cSIngo Molnar 		.procname	= "vdso_enabled",
15033d7ee969SAndy Lutomirski #ifdef CONFIG_X86_32
15043d7ee969SAndy Lutomirski 		.data		= &vdso32_enabled,
15053d7ee969SAndy Lutomirski 		.maxlen		= sizeof(vdso32_enabled),
15063d7ee969SAndy Lutomirski #else
1507e6e5494cSIngo Molnar 		.data		= &vdso_enabled,
1508e6e5494cSIngo Molnar 		.maxlen		= sizeof(vdso_enabled),
15093d7ee969SAndy Lutomirski #endif
1510e6e5494cSIngo Molnar 		.mode		= 0644,
15116d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1512e6e5494cSIngo Molnar 		.extra1		= &zero,
1513e6e5494cSIngo Molnar 	},
1514e6e5494cSIngo Molnar #endif
1515195cf453SBron Gondwana #ifdef CONFIG_HIGHMEM
1516195cf453SBron Gondwana 	{
1517195cf453SBron Gondwana 		.procname	= "highmem_is_dirtyable",
1518195cf453SBron Gondwana 		.data		= &vm_highmem_is_dirtyable,
1519195cf453SBron Gondwana 		.maxlen		= sizeof(vm_highmem_is_dirtyable),
1520195cf453SBron Gondwana 		.mode		= 0644,
15216d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
1522195cf453SBron Gondwana 		.extra1		= &zero,
1523195cf453SBron Gondwana 		.extra2		= &one,
1524195cf453SBron Gondwana 	},
1525195cf453SBron Gondwana #endif
15266a46079cSAndi Kleen #ifdef CONFIG_MEMORY_FAILURE
15276a46079cSAndi Kleen 	{
15286a46079cSAndi Kleen 		.procname	= "memory_failure_early_kill",
15296a46079cSAndi Kleen 		.data		= &sysctl_memory_failure_early_kill,
15306a46079cSAndi Kleen 		.maxlen		= sizeof(sysctl_memory_failure_early_kill),
15316a46079cSAndi Kleen 		.mode		= 0644,
15326d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
15336a46079cSAndi Kleen 		.extra1		= &zero,
15346a46079cSAndi Kleen 		.extra2		= &one,
15356a46079cSAndi Kleen 	},
15366a46079cSAndi Kleen 	{
15376a46079cSAndi Kleen 		.procname	= "memory_failure_recovery",
15386a46079cSAndi Kleen 		.data		= &sysctl_memory_failure_recovery,
15396a46079cSAndi Kleen 		.maxlen		= sizeof(sysctl_memory_failure_recovery),
15406a46079cSAndi Kleen 		.mode		= 0644,
15416d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
15426a46079cSAndi Kleen 		.extra1		= &zero,
15436a46079cSAndi Kleen 		.extra2		= &one,
15446a46079cSAndi Kleen 	},
15456a46079cSAndi Kleen #endif
1546c9b1d098SAndrew Shewmaker 	{
1547c9b1d098SAndrew Shewmaker 		.procname	= "user_reserve_kbytes",
1548c9b1d098SAndrew Shewmaker 		.data		= &sysctl_user_reserve_kbytes,
1549c9b1d098SAndrew Shewmaker 		.maxlen		= sizeof(sysctl_user_reserve_kbytes),
1550c9b1d098SAndrew Shewmaker 		.mode		= 0644,
1551c9b1d098SAndrew Shewmaker 		.proc_handler	= proc_doulongvec_minmax,
1552c9b1d098SAndrew Shewmaker 	},
15534eeab4f5SAndrew Shewmaker 	{
15544eeab4f5SAndrew Shewmaker 		.procname	= "admin_reserve_kbytes",
15554eeab4f5SAndrew Shewmaker 		.data		= &sysctl_admin_reserve_kbytes,
15564eeab4f5SAndrew Shewmaker 		.maxlen		= sizeof(sysctl_admin_reserve_kbytes),
15574eeab4f5SAndrew Shewmaker 		.mode		= 0644,
15584eeab4f5SAndrew Shewmaker 		.proc_handler	= proc_doulongvec_minmax,
15594eeab4f5SAndrew Shewmaker 	},
15606fce56ecSEric W. Biederman 	{ }
15611da177e4SLinus Torvalds };
15621da177e4SLinus Torvalds 
1563d8217f07SEric W. Biederman static struct ctl_table fs_table[] = {
15641da177e4SLinus Torvalds 	{
15651da177e4SLinus Torvalds 		.procname	= "inode-nr",
15661da177e4SLinus Torvalds 		.data		= &inodes_stat,
15673942c07cSGlauber Costa 		.maxlen		= 2*sizeof(long),
15681da177e4SLinus Torvalds 		.mode		= 0444,
1569cffbc8aaSDave Chinner 		.proc_handler	= proc_nr_inodes,
15701da177e4SLinus Torvalds 	},
15711da177e4SLinus Torvalds 	{
15721da177e4SLinus Torvalds 		.procname	= "inode-state",
15731da177e4SLinus Torvalds 		.data		= &inodes_stat,
15743942c07cSGlauber Costa 		.maxlen		= 7*sizeof(long),
15751da177e4SLinus Torvalds 		.mode		= 0444,
1576cffbc8aaSDave Chinner 		.proc_handler	= proc_nr_inodes,
15771da177e4SLinus Torvalds 	},
15781da177e4SLinus Torvalds 	{
15791da177e4SLinus Torvalds 		.procname	= "file-nr",
15801da177e4SLinus Torvalds 		.data		= &files_stat,
1581518de9b3SEric Dumazet 		.maxlen		= sizeof(files_stat),
15821da177e4SLinus Torvalds 		.mode		= 0444,
15836d456111SEric W. Biederman 		.proc_handler	= proc_nr_files,
15841da177e4SLinus Torvalds 	},
15851da177e4SLinus Torvalds 	{
15861da177e4SLinus Torvalds 		.procname	= "file-max",
15871da177e4SLinus Torvalds 		.data		= &files_stat.max_files,
1588518de9b3SEric Dumazet 		.maxlen		= sizeof(files_stat.max_files),
15891da177e4SLinus Torvalds 		.mode		= 0644,
1590518de9b3SEric Dumazet 		.proc_handler	= proc_doulongvec_minmax,
15911da177e4SLinus Torvalds 	},
15921da177e4SLinus Torvalds 	{
15939cfe015aSEric Dumazet 		.procname	= "nr_open",
15949cfe015aSEric Dumazet 		.data		= &sysctl_nr_open,
15959cfe015aSEric Dumazet 		.maxlen		= sizeof(int),
15969cfe015aSEric Dumazet 		.mode		= 0644,
15976d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
1598eceea0b3SAl Viro 		.extra1		= &sysctl_nr_open_min,
1599eceea0b3SAl Viro 		.extra2		= &sysctl_nr_open_max,
16009cfe015aSEric Dumazet 	},
16019cfe015aSEric Dumazet 	{
16021da177e4SLinus Torvalds 		.procname	= "dentry-state",
16031da177e4SLinus Torvalds 		.data		= &dentry_stat,
16043942c07cSGlauber Costa 		.maxlen		= 6*sizeof(long),
16051da177e4SLinus Torvalds 		.mode		= 0444,
1606312d3ca8SChristoph Hellwig 		.proc_handler	= proc_nr_dentry,
16071da177e4SLinus Torvalds 	},
16081da177e4SLinus Torvalds 	{
16091da177e4SLinus Torvalds 		.procname	= "overflowuid",
16101da177e4SLinus Torvalds 		.data		= &fs_overflowuid,
16111da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
16121da177e4SLinus Torvalds 		.mode		= 0644,
16136d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
16141da177e4SLinus Torvalds 		.extra1		= &minolduid,
16151da177e4SLinus Torvalds 		.extra2		= &maxolduid,
16161da177e4SLinus Torvalds 	},
16171da177e4SLinus Torvalds 	{
16181da177e4SLinus Torvalds 		.procname	= "overflowgid",
16191da177e4SLinus Torvalds 		.data		= &fs_overflowgid,
16201da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
16211da177e4SLinus Torvalds 		.mode		= 0644,
16226d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
16231da177e4SLinus Torvalds 		.extra1		= &minolduid,
16241da177e4SLinus Torvalds 		.extra2		= &maxolduid,
16251da177e4SLinus Torvalds 	},
1626bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING
16271da177e4SLinus Torvalds 	{
16281da177e4SLinus Torvalds 		.procname	= "leases-enable",
16291da177e4SLinus Torvalds 		.data		= &leases_enable,
16301da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
16311da177e4SLinus Torvalds 		.mode		= 0644,
16326d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
16331da177e4SLinus Torvalds 	},
1634bfcd17a6SThomas Petazzoni #endif
16351da177e4SLinus Torvalds #ifdef CONFIG_DNOTIFY
16361da177e4SLinus Torvalds 	{
16371da177e4SLinus Torvalds 		.procname	= "dir-notify-enable",
16381da177e4SLinus Torvalds 		.data		= &dir_notify_enable,
16391da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
16401da177e4SLinus Torvalds 		.mode		= 0644,
16416d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
16421da177e4SLinus Torvalds 	},
16431da177e4SLinus Torvalds #endif
16441da177e4SLinus Torvalds #ifdef CONFIG_MMU
1645bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING
16461da177e4SLinus Torvalds 	{
16471da177e4SLinus Torvalds 		.procname	= "lease-break-time",
16481da177e4SLinus Torvalds 		.data		= &lease_break_time,
16491da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
16501da177e4SLinus Torvalds 		.mode		= 0644,
16516d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
16521da177e4SLinus Torvalds 	},
1653bfcd17a6SThomas Petazzoni #endif
1654ebf3f09cSThomas Petazzoni #ifdef CONFIG_AIO
16551da177e4SLinus Torvalds 	{
16561da177e4SLinus Torvalds 		.procname	= "aio-nr",
16571da177e4SLinus Torvalds 		.data		= &aio_nr,
16581da177e4SLinus Torvalds 		.maxlen		= sizeof(aio_nr),
16591da177e4SLinus Torvalds 		.mode		= 0444,
16606d456111SEric W. Biederman 		.proc_handler	= proc_doulongvec_minmax,
16611da177e4SLinus Torvalds 	},
16621da177e4SLinus Torvalds 	{
16631da177e4SLinus Torvalds 		.procname	= "aio-max-nr",
16641da177e4SLinus Torvalds 		.data		= &aio_max_nr,
16651da177e4SLinus Torvalds 		.maxlen		= sizeof(aio_max_nr),
16661da177e4SLinus Torvalds 		.mode		= 0644,
16676d456111SEric W. Biederman 		.proc_handler	= proc_doulongvec_minmax,
16681da177e4SLinus Torvalds 	},
1669ebf3f09cSThomas Petazzoni #endif /* CONFIG_AIO */
16702d9048e2SAmy Griffis #ifdef CONFIG_INOTIFY_USER
16710399cb08SRobert Love 	{
16720399cb08SRobert Love 		.procname	= "inotify",
16730399cb08SRobert Love 		.mode		= 0555,
16740399cb08SRobert Love 		.child		= inotify_table,
16750399cb08SRobert Love 	},
16760399cb08SRobert Love #endif
16777ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL
16787ef9964eSDavide Libenzi 	{
16797ef9964eSDavide Libenzi 		.procname	= "epoll",
16807ef9964eSDavide Libenzi 		.mode		= 0555,
16817ef9964eSDavide Libenzi 		.child		= epoll_table,
16827ef9964eSDavide Libenzi 	},
16837ef9964eSDavide Libenzi #endif
16841da177e4SLinus Torvalds #endif
1685d6e71144SAlan Cox 	{
1686800179c9SKees Cook 		.procname	= "protected_symlinks",
1687800179c9SKees Cook 		.data		= &sysctl_protected_symlinks,
1688800179c9SKees Cook 		.maxlen		= sizeof(int),
1689800179c9SKees Cook 		.mode		= 0600,
1690800179c9SKees Cook 		.proc_handler	= proc_dointvec_minmax,
1691800179c9SKees Cook 		.extra1		= &zero,
1692800179c9SKees Cook 		.extra2		= &one,
1693800179c9SKees Cook 	},
1694800179c9SKees Cook 	{
1695800179c9SKees Cook 		.procname	= "protected_hardlinks",
1696800179c9SKees Cook 		.data		= &sysctl_protected_hardlinks,
1697800179c9SKees Cook 		.maxlen		= sizeof(int),
1698800179c9SKees Cook 		.mode		= 0600,
1699800179c9SKees Cook 		.proc_handler	= proc_dointvec_minmax,
1700800179c9SKees Cook 		.extra1		= &zero,
1701800179c9SKees Cook 		.extra2		= &one,
1702800179c9SKees Cook 	},
1703800179c9SKees Cook 	{
1704d6e71144SAlan Cox 		.procname	= "suid_dumpable",
1705d6e71144SAlan Cox 		.data		= &suid_dumpable,
1706d6e71144SAlan Cox 		.maxlen		= sizeof(int),
1707d6e71144SAlan Cox 		.mode		= 0644,
170854b50199SKees Cook 		.proc_handler	= proc_dointvec_minmax_coredump,
17098e654fbaSMatthew Wilcox 		.extra1		= &zero,
17108e654fbaSMatthew Wilcox 		.extra2		= &two,
1711d6e71144SAlan Cox 	},
17122abc26fcSEric W. Biederman #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
17132abc26fcSEric W. Biederman 	{
17142abc26fcSEric W. Biederman 		.procname	= "binfmt_misc",
17152abc26fcSEric W. Biederman 		.mode		= 0555,
1716f9bd6733SEric W. Biederman 		.child		= sysctl_mount_point,
17172abc26fcSEric W. Biederman 	},
17182abc26fcSEric W. Biederman #endif
1719b492e95bSJens Axboe 	{
1720ff9da691SJens Axboe 		.procname	= "pipe-max-size",
1721ff9da691SJens Axboe 		.data		= &pipe_max_size,
1722b492e95bSJens Axboe 		.maxlen		= sizeof(int),
1723b492e95bSJens Axboe 		.mode		= 0644,
1724ff9da691SJens Axboe 		.proc_handler	= &pipe_proc_fn,
1725ff9da691SJens Axboe 		.extra1		= &pipe_min_size,
1726b492e95bSJens Axboe 	},
17276fce56ecSEric W. Biederman 	{ }
17281da177e4SLinus Torvalds };
17291da177e4SLinus Torvalds 
1730d8217f07SEric W. Biederman static struct ctl_table debug_table[] = {
17317ac57a89SCatalin Marinas #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
1732abd4f750SMasoud Asgharifard Sharbiani 	{
1733abd4f750SMasoud Asgharifard Sharbiani 		.procname	= "exception-trace",
1734abd4f750SMasoud Asgharifard Sharbiani 		.data		= &show_unhandled_signals,
1735abd4f750SMasoud Asgharifard Sharbiani 		.maxlen		= sizeof(int),
1736abd4f750SMasoud Asgharifard Sharbiani 		.mode		= 0644,
1737abd4f750SMasoud Asgharifard Sharbiani 		.proc_handler	= proc_dointvec
1738abd4f750SMasoud Asgharifard Sharbiani 	},
1739abd4f750SMasoud Asgharifard Sharbiani #endif
1740b2be84dfSMasami Hiramatsu #if defined(CONFIG_OPTPROBES)
1741b2be84dfSMasami Hiramatsu 	{
1742b2be84dfSMasami Hiramatsu 		.procname	= "kprobes-optimization",
1743b2be84dfSMasami Hiramatsu 		.data		= &sysctl_kprobes_optimization,
1744b2be84dfSMasami Hiramatsu 		.maxlen		= sizeof(int),
1745b2be84dfSMasami Hiramatsu 		.mode		= 0644,
1746b2be84dfSMasami Hiramatsu 		.proc_handler	= proc_kprobes_optimization_handler,
1747b2be84dfSMasami Hiramatsu 		.extra1		= &zero,
1748b2be84dfSMasami Hiramatsu 		.extra2		= &one,
1749b2be84dfSMasami Hiramatsu 	},
1750b2be84dfSMasami Hiramatsu #endif
17516fce56ecSEric W. Biederman 	{ }
17521da177e4SLinus Torvalds };
17531da177e4SLinus Torvalds 
1754d8217f07SEric W. Biederman static struct ctl_table dev_table[] = {
17556fce56ecSEric W. Biederman 	{ }
17561da177e4SLinus Torvalds };
17571da177e4SLinus Torvalds 
1758de4e83bdSEric W. Biederman int __init sysctl_init(void)
1759330d57fbSAl Viro {
1760fd4b616bSSteven Rostedt 	struct ctl_table_header *hdr;
1761fd4b616bSSteven Rostedt 
1762fd4b616bSSteven Rostedt 	hdr = register_sysctl_table(sysctl_base_table);
1763fd4b616bSSteven Rostedt 	kmemleak_not_leak(hdr);
1764330d57fbSAl Viro 	return 0;
1765f7e6ced4SAl Viro }
1766f7e6ced4SAl Viro 
1767b89a8171SEric W. Biederman #endif /* CONFIG_SYSCTL */
1768b89a8171SEric W. Biederman 
17691da177e4SLinus Torvalds /*
17701da177e4SLinus Torvalds  * /proc/sys support
17711da177e4SLinus Torvalds  */
17721da177e4SLinus Torvalds 
1773b89a8171SEric W. Biederman #ifdef CONFIG_PROC_SYSCTL
17741da177e4SLinus Torvalds 
1775f8808300SKees Cook static int _proc_do_string(char *data, int maxlen, int write,
1776f8808300SKees Cook 			   char __user *buffer,
1777b1ba4dddSAdrian Bunk 			   size_t *lenp, loff_t *ppos)
1778f5dd3d6fSSam Vilain {
1779f5dd3d6fSSam Vilain 	size_t len;
1780f5dd3d6fSSam Vilain 	char __user *p;
1781f5dd3d6fSSam Vilain 	char c;
1782f5dd3d6fSSam Vilain 
17838d060877SOleg Nesterov 	if (!data || !maxlen || !*lenp) {
1784f5dd3d6fSSam Vilain 		*lenp = 0;
1785f5dd3d6fSSam Vilain 		return 0;
1786f5dd3d6fSSam Vilain 	}
1787f5dd3d6fSSam Vilain 
1788f5dd3d6fSSam Vilain 	if (write) {
1789f4aacea2SKees Cook 		if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
1790f4aacea2SKees Cook 			/* Only continue writes not past the end of buffer. */
1791f4aacea2SKees Cook 			len = strlen(data);
1792f4aacea2SKees Cook 			if (len > maxlen - 1)
1793f4aacea2SKees Cook 				len = maxlen - 1;
1794f4aacea2SKees Cook 
1795f4aacea2SKees Cook 			if (*ppos > len)
1796f4aacea2SKees Cook 				return 0;
1797f4aacea2SKees Cook 			len = *ppos;
1798f4aacea2SKees Cook 		} else {
17992ca9bb45SKees Cook 			/* Start writing from beginning of buffer. */
1800f5dd3d6fSSam Vilain 			len = 0;
1801f4aacea2SKees Cook 		}
1802f4aacea2SKees Cook 
18032ca9bb45SKees Cook 		*ppos += *lenp;
1804f5dd3d6fSSam Vilain 		p = buffer;
18052ca9bb45SKees Cook 		while ((p - buffer) < *lenp && len < maxlen - 1) {
1806f5dd3d6fSSam Vilain 			if (get_user(c, p++))
1807f5dd3d6fSSam Vilain 				return -EFAULT;
1808f5dd3d6fSSam Vilain 			if (c == 0 || c == '\n')
1809f5dd3d6fSSam Vilain 				break;
18102ca9bb45SKees Cook 			data[len++] = c;
1811f5dd3d6fSSam Vilain 		}
1812f8808300SKees Cook 		data[len] = 0;
1813f5dd3d6fSSam Vilain 	} else {
1814f5dd3d6fSSam Vilain 		len = strlen(data);
1815f5dd3d6fSSam Vilain 		if (len > maxlen)
1816f5dd3d6fSSam Vilain 			len = maxlen;
18178d060877SOleg Nesterov 
18188d060877SOleg Nesterov 		if (*ppos > len) {
18198d060877SOleg Nesterov 			*lenp = 0;
18208d060877SOleg Nesterov 			return 0;
18218d060877SOleg Nesterov 		}
18228d060877SOleg Nesterov 
18238d060877SOleg Nesterov 		data += *ppos;
18248d060877SOleg Nesterov 		len  -= *ppos;
18258d060877SOleg Nesterov 
1826f5dd3d6fSSam Vilain 		if (len > *lenp)
1827f5dd3d6fSSam Vilain 			len = *lenp;
1828f5dd3d6fSSam Vilain 		if (len)
1829f5dd3d6fSSam Vilain 			if (copy_to_user(buffer, data, len))
1830f5dd3d6fSSam Vilain 				return -EFAULT;
1831f5dd3d6fSSam Vilain 		if (len < *lenp) {
1832f8808300SKees Cook 			if (put_user('\n', buffer + len))
1833f5dd3d6fSSam Vilain 				return -EFAULT;
1834f5dd3d6fSSam Vilain 			len++;
1835f5dd3d6fSSam Vilain 		}
1836f5dd3d6fSSam Vilain 		*lenp = len;
1837f5dd3d6fSSam Vilain 		*ppos += len;
1838f5dd3d6fSSam Vilain 	}
1839f5dd3d6fSSam Vilain 	return 0;
1840f5dd3d6fSSam Vilain }
1841f5dd3d6fSSam Vilain 
1842f4aacea2SKees Cook static void warn_sysctl_write(struct ctl_table *table)
1843f4aacea2SKees Cook {
1844f4aacea2SKees Cook 	pr_warn_once("%s wrote to %s when file position was not 0!\n"
1845f4aacea2SKees Cook 		"This will not be supported in the future. To silence this\n"
1846f4aacea2SKees Cook 		"warning, set kernel.sysctl_writes_strict = -1\n",
1847f4aacea2SKees Cook 		current->comm, table->procname);
1848f4aacea2SKees Cook }
1849f4aacea2SKees Cook 
18501da177e4SLinus Torvalds /**
18511da177e4SLinus Torvalds  * proc_dostring - read a string sysctl
18521da177e4SLinus Torvalds  * @table: the sysctl table
18531da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
18541da177e4SLinus Torvalds  * @buffer: the user buffer
18551da177e4SLinus Torvalds  * @lenp: the size of the user buffer
18561da177e4SLinus Torvalds  * @ppos: file position
18571da177e4SLinus Torvalds  *
18581da177e4SLinus Torvalds  * Reads/writes a string from/to the user buffer. If the kernel
18591da177e4SLinus Torvalds  * buffer provided is not large enough to hold the string, the
18601da177e4SLinus Torvalds  * string is truncated. The copied string is %NULL-terminated.
18611da177e4SLinus Torvalds  * If the string is being read by the user process, it is copied
18621da177e4SLinus Torvalds  * and a newline '\n' is added. It is truncated if the buffer is
18631da177e4SLinus Torvalds  * not large enough.
18641da177e4SLinus Torvalds  *
18651da177e4SLinus Torvalds  * Returns 0 on success.
18661da177e4SLinus Torvalds  */
18678d65af78SAlexey Dobriyan int proc_dostring(struct ctl_table *table, int write,
18681da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
18691da177e4SLinus Torvalds {
1870f4aacea2SKees Cook 	if (write && *ppos && sysctl_writes_strict == SYSCTL_WRITES_WARN)
1871f4aacea2SKees Cook 		warn_sysctl_write(table);
1872f4aacea2SKees Cook 
1873f8808300SKees Cook 	return _proc_do_string((char *)(table->data), table->maxlen, write,
1874f8808300SKees Cook 			       (char __user *)buffer, lenp, ppos);
18751da177e4SLinus Torvalds }
18761da177e4SLinus Torvalds 
187700b7c339SAmerigo Wang static size_t proc_skip_spaces(char **buf)
187800b7c339SAmerigo Wang {
187900b7c339SAmerigo Wang 	size_t ret;
188000b7c339SAmerigo Wang 	char *tmp = skip_spaces(*buf);
188100b7c339SAmerigo Wang 	ret = tmp - *buf;
188200b7c339SAmerigo Wang 	*buf = tmp;
188300b7c339SAmerigo Wang 	return ret;
188400b7c339SAmerigo Wang }
18851da177e4SLinus Torvalds 
18869f977fb7SOctavian Purdila static void proc_skip_char(char **buf, size_t *size, const char v)
18879f977fb7SOctavian Purdila {
18889f977fb7SOctavian Purdila 	while (*size) {
18899f977fb7SOctavian Purdila 		if (**buf != v)
18909f977fb7SOctavian Purdila 			break;
18919f977fb7SOctavian Purdila 		(*size)--;
18929f977fb7SOctavian Purdila 		(*buf)++;
18939f977fb7SOctavian Purdila 	}
18949f977fb7SOctavian Purdila }
18959f977fb7SOctavian Purdila 
189600b7c339SAmerigo Wang #define TMPBUFLEN 22
189700b7c339SAmerigo Wang /**
18980fc377bdSRandy Dunlap  * proc_get_long - reads an ASCII formatted integer from a user buffer
189900b7c339SAmerigo Wang  *
19000fc377bdSRandy Dunlap  * @buf: a kernel buffer
19010fc377bdSRandy Dunlap  * @size: size of the kernel buffer
19020fc377bdSRandy Dunlap  * @val: this is where the number will be stored
19030fc377bdSRandy Dunlap  * @neg: set to %TRUE if number is negative
19040fc377bdSRandy Dunlap  * @perm_tr: a vector which contains the allowed trailers
19050fc377bdSRandy Dunlap  * @perm_tr_len: size of the perm_tr vector
19060fc377bdSRandy Dunlap  * @tr: pointer to store the trailer character
190700b7c339SAmerigo Wang  *
19080fc377bdSRandy Dunlap  * In case of success %0 is returned and @buf and @size are updated with
19090fc377bdSRandy Dunlap  * the amount of bytes read. If @tr is non-NULL and a trailing
19100fc377bdSRandy Dunlap  * character exists (size is non-zero after returning from this
19110fc377bdSRandy Dunlap  * function), @tr is updated with the trailing character.
191200b7c339SAmerigo Wang  */
191300b7c339SAmerigo Wang static int proc_get_long(char **buf, size_t *size,
191400b7c339SAmerigo Wang 			  unsigned long *val, bool *neg,
191500b7c339SAmerigo Wang 			  const char *perm_tr, unsigned perm_tr_len, char *tr)
191600b7c339SAmerigo Wang {
191700b7c339SAmerigo Wang 	int len;
191800b7c339SAmerigo Wang 	char *p, tmp[TMPBUFLEN];
191900b7c339SAmerigo Wang 
192000b7c339SAmerigo Wang 	if (!*size)
192100b7c339SAmerigo Wang 		return -EINVAL;
192200b7c339SAmerigo Wang 
192300b7c339SAmerigo Wang 	len = *size;
192400b7c339SAmerigo Wang 	if (len > TMPBUFLEN - 1)
192500b7c339SAmerigo Wang 		len = TMPBUFLEN - 1;
192600b7c339SAmerigo Wang 
192700b7c339SAmerigo Wang 	memcpy(tmp, *buf, len);
192800b7c339SAmerigo Wang 
192900b7c339SAmerigo Wang 	tmp[len] = 0;
193000b7c339SAmerigo Wang 	p = tmp;
193100b7c339SAmerigo Wang 	if (*p == '-' && *size > 1) {
193200b7c339SAmerigo Wang 		*neg = true;
193300b7c339SAmerigo Wang 		p++;
193400b7c339SAmerigo Wang 	} else
193500b7c339SAmerigo Wang 		*neg = false;
193600b7c339SAmerigo Wang 	if (!isdigit(*p))
193700b7c339SAmerigo Wang 		return -EINVAL;
193800b7c339SAmerigo Wang 
193900b7c339SAmerigo Wang 	*val = simple_strtoul(p, &p, 0);
194000b7c339SAmerigo Wang 
194100b7c339SAmerigo Wang 	len = p - tmp;
194200b7c339SAmerigo Wang 
194300b7c339SAmerigo Wang 	/* We don't know if the next char is whitespace thus we may accept
194400b7c339SAmerigo Wang 	 * invalid integers (e.g. 1234...a) or two integers instead of one
194500b7c339SAmerigo Wang 	 * (e.g. 123...1). So lets not allow such large numbers. */
194600b7c339SAmerigo Wang 	if (len == TMPBUFLEN - 1)
194700b7c339SAmerigo Wang 		return -EINVAL;
194800b7c339SAmerigo Wang 
194900b7c339SAmerigo Wang 	if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
195000b7c339SAmerigo Wang 		return -EINVAL;
195100b7c339SAmerigo Wang 
195200b7c339SAmerigo Wang 	if (tr && (len < *size))
195300b7c339SAmerigo Wang 		*tr = *p;
195400b7c339SAmerigo Wang 
195500b7c339SAmerigo Wang 	*buf += len;
195600b7c339SAmerigo Wang 	*size -= len;
195700b7c339SAmerigo Wang 
195800b7c339SAmerigo Wang 	return 0;
195900b7c339SAmerigo Wang }
196000b7c339SAmerigo Wang 
196100b7c339SAmerigo Wang /**
19620fc377bdSRandy Dunlap  * proc_put_long - converts an integer to a decimal ASCII formatted string
196300b7c339SAmerigo Wang  *
19640fc377bdSRandy Dunlap  * @buf: the user buffer
19650fc377bdSRandy Dunlap  * @size: the size of the user buffer
19660fc377bdSRandy Dunlap  * @val: the integer to be converted
19670fc377bdSRandy Dunlap  * @neg: sign of the number, %TRUE for negative
196800b7c339SAmerigo Wang  *
19690fc377bdSRandy Dunlap  * In case of success %0 is returned and @buf and @size are updated with
19700fc377bdSRandy Dunlap  * the amount of bytes written.
197100b7c339SAmerigo Wang  */
197200b7c339SAmerigo Wang static int proc_put_long(void __user **buf, size_t *size, unsigned long val,
197300b7c339SAmerigo Wang 			  bool neg)
197400b7c339SAmerigo Wang {
197500b7c339SAmerigo Wang 	int len;
197600b7c339SAmerigo Wang 	char tmp[TMPBUFLEN], *p = tmp;
197700b7c339SAmerigo Wang 
197800b7c339SAmerigo Wang 	sprintf(p, "%s%lu", neg ? "-" : "", val);
197900b7c339SAmerigo Wang 	len = strlen(tmp);
198000b7c339SAmerigo Wang 	if (len > *size)
198100b7c339SAmerigo Wang 		len = *size;
198200b7c339SAmerigo Wang 	if (copy_to_user(*buf, tmp, len))
198300b7c339SAmerigo Wang 		return -EFAULT;
198400b7c339SAmerigo Wang 	*size -= len;
198500b7c339SAmerigo Wang 	*buf += len;
198600b7c339SAmerigo Wang 	return 0;
198700b7c339SAmerigo Wang }
198800b7c339SAmerigo Wang #undef TMPBUFLEN
198900b7c339SAmerigo Wang 
199000b7c339SAmerigo Wang static int proc_put_char(void __user **buf, size_t *size, char c)
199100b7c339SAmerigo Wang {
199200b7c339SAmerigo Wang 	if (*size) {
199300b7c339SAmerigo Wang 		char __user **buffer = (char __user **)buf;
199400b7c339SAmerigo Wang 		if (put_user(c, *buffer))
199500b7c339SAmerigo Wang 			return -EFAULT;
199600b7c339SAmerigo Wang 		(*size)--, (*buffer)++;
199700b7c339SAmerigo Wang 		*buf = *buffer;
199800b7c339SAmerigo Wang 	}
199900b7c339SAmerigo Wang 	return 0;
200000b7c339SAmerigo Wang }
200100b7c339SAmerigo Wang 
200200b7c339SAmerigo Wang static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
20031da177e4SLinus Torvalds 				 int *valp,
20041da177e4SLinus Torvalds 				 int write, void *data)
20051da177e4SLinus Torvalds {
20061da177e4SLinus Torvalds 	if (write) {
2007230633d1SHeinrich Schuchardt 		if (*negp) {
2008230633d1SHeinrich Schuchardt 			if (*lvalp > (unsigned long) INT_MAX + 1)
2009230633d1SHeinrich Schuchardt 				return -EINVAL;
2010230633d1SHeinrich Schuchardt 			*valp = -*lvalp;
2011230633d1SHeinrich Schuchardt 		} else {
2012230633d1SHeinrich Schuchardt 			if (*lvalp > (unsigned long) INT_MAX)
2013230633d1SHeinrich Schuchardt 				return -EINVAL;
2014230633d1SHeinrich Schuchardt 			*valp = *lvalp;
2015230633d1SHeinrich Schuchardt 		}
20161da177e4SLinus Torvalds 	} else {
20171da177e4SLinus Torvalds 		int val = *valp;
20181da177e4SLinus Torvalds 		if (val < 0) {
201900b7c339SAmerigo Wang 			*negp = true;
20209a5bc726SIlya Dryomov 			*lvalp = -(unsigned long)val;
20211da177e4SLinus Torvalds 		} else {
202200b7c339SAmerigo Wang 			*negp = false;
20231da177e4SLinus Torvalds 			*lvalp = (unsigned long)val;
20241da177e4SLinus Torvalds 		}
20251da177e4SLinus Torvalds 	}
20261da177e4SLinus Torvalds 	return 0;
20271da177e4SLinus Torvalds }
20281da177e4SLinus Torvalds 
202900b7c339SAmerigo Wang static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
203000b7c339SAmerigo Wang 
2031d8217f07SEric W. Biederman static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
20328d65af78SAlexey Dobriyan 		  int write, void __user *buffer,
2033fcfbd547SKirill Korotaev 		  size_t *lenp, loff_t *ppos,
203400b7c339SAmerigo Wang 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
20351da177e4SLinus Torvalds 			      int write, void *data),
20361da177e4SLinus Torvalds 		  void *data)
20371da177e4SLinus Torvalds {
203800b7c339SAmerigo Wang 	int *i, vleft, first = 1, err = 0;
203900b7c339SAmerigo Wang 	unsigned long page = 0;
204000b7c339SAmerigo Wang 	size_t left;
204100b7c339SAmerigo Wang 	char *kbuf;
20421da177e4SLinus Torvalds 
204300b7c339SAmerigo Wang 	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
20441da177e4SLinus Torvalds 		*lenp = 0;
20451da177e4SLinus Torvalds 		return 0;
20461da177e4SLinus Torvalds 	}
20471da177e4SLinus Torvalds 
2048fcfbd547SKirill Korotaev 	i = (int *) tbl_data;
20491da177e4SLinus Torvalds 	vleft = table->maxlen / sizeof(*i);
20501da177e4SLinus Torvalds 	left = *lenp;
20511da177e4SLinus Torvalds 
20521da177e4SLinus Torvalds 	if (!conv)
20531da177e4SLinus Torvalds 		conv = do_proc_dointvec_conv;
20541da177e4SLinus Torvalds 
205500b7c339SAmerigo Wang 	if (write) {
2056f4aacea2SKees Cook 		if (*ppos) {
2057f4aacea2SKees Cook 			switch (sysctl_writes_strict) {
2058f4aacea2SKees Cook 			case SYSCTL_WRITES_STRICT:
2059f4aacea2SKees Cook 				goto out;
2060f4aacea2SKees Cook 			case SYSCTL_WRITES_WARN:
2061f4aacea2SKees Cook 				warn_sysctl_write(table);
2062f4aacea2SKees Cook 				break;
2063f4aacea2SKees Cook 			default:
2064f4aacea2SKees Cook 				break;
2065f4aacea2SKees Cook 			}
2066f4aacea2SKees Cook 		}
2067f4aacea2SKees Cook 
206800b7c339SAmerigo Wang 		if (left > PAGE_SIZE - 1)
206900b7c339SAmerigo Wang 			left = PAGE_SIZE - 1;
207000b7c339SAmerigo Wang 		page = __get_free_page(GFP_TEMPORARY);
207100b7c339SAmerigo Wang 		kbuf = (char *) page;
207200b7c339SAmerigo Wang 		if (!kbuf)
207300b7c339SAmerigo Wang 			return -ENOMEM;
207400b7c339SAmerigo Wang 		if (copy_from_user(kbuf, buffer, left)) {
207500b7c339SAmerigo Wang 			err = -EFAULT;
207600b7c339SAmerigo Wang 			goto free;
207700b7c339SAmerigo Wang 		}
207800b7c339SAmerigo Wang 		kbuf[left] = 0;
207900b7c339SAmerigo Wang 	}
208000b7c339SAmerigo Wang 
20811da177e4SLinus Torvalds 	for (; left && vleft--; i++, first=0) {
208200b7c339SAmerigo Wang 		unsigned long lval;
208300b7c339SAmerigo Wang 		bool neg;
208400b7c339SAmerigo Wang 
20851da177e4SLinus Torvalds 		if (write) {
208600b7c339SAmerigo Wang 			left -= proc_skip_spaces(&kbuf);
208700b7c339SAmerigo Wang 
2088563b0467SJ. R. Okajima 			if (!left)
2089563b0467SJ. R. Okajima 				break;
209000b7c339SAmerigo Wang 			err = proc_get_long(&kbuf, &left, &lval, &neg,
209100b7c339SAmerigo Wang 					     proc_wspace_sep,
209200b7c339SAmerigo Wang 					     sizeof(proc_wspace_sep), NULL);
209300b7c339SAmerigo Wang 			if (err)
20941da177e4SLinus Torvalds 				break;
209500b7c339SAmerigo Wang 			if (conv(&neg, &lval, i, 1, data)) {
209600b7c339SAmerigo Wang 				err = -EINVAL;
209700b7c339SAmerigo Wang 				break;
20981da177e4SLinus Torvalds 			}
20991da177e4SLinus Torvalds 		} else {
210000b7c339SAmerigo Wang 			if (conv(&neg, &lval, i, 0, data)) {
210100b7c339SAmerigo Wang 				err = -EINVAL;
210200b7c339SAmerigo Wang 				break;
210300b7c339SAmerigo Wang 			}
21041da177e4SLinus Torvalds 			if (!first)
210500b7c339SAmerigo Wang 				err = proc_put_char(&buffer, &left, '\t');
210600b7c339SAmerigo Wang 			if (err)
21071da177e4SLinus Torvalds 				break;
210800b7c339SAmerigo Wang 			err = proc_put_long(&buffer, &left, lval, neg);
210900b7c339SAmerigo Wang 			if (err)
211000b7c339SAmerigo Wang 				break;
21111da177e4SLinus Torvalds 		}
21121da177e4SLinus Torvalds 	}
21131da177e4SLinus Torvalds 
211400b7c339SAmerigo Wang 	if (!write && !first && left && !err)
211500b7c339SAmerigo Wang 		err = proc_put_char(&buffer, &left, '\n');
2116563b0467SJ. R. Okajima 	if (write && !err && left)
211700b7c339SAmerigo Wang 		left -= proc_skip_spaces(&kbuf);
211800b7c339SAmerigo Wang free:
21191da177e4SLinus Torvalds 	if (write) {
212000b7c339SAmerigo Wang 		free_page(page);
212100b7c339SAmerigo Wang 		if (first)
212200b7c339SAmerigo Wang 			return err ? : -EINVAL;
21231da177e4SLinus Torvalds 	}
21241da177e4SLinus Torvalds 	*lenp -= left;
2125f4aacea2SKees Cook out:
21261da177e4SLinus Torvalds 	*ppos += *lenp;
212700b7c339SAmerigo Wang 	return err;
21281da177e4SLinus Torvalds }
21291da177e4SLinus Torvalds 
21308d65af78SAlexey Dobriyan static int do_proc_dointvec(struct ctl_table *table, int write,
2131fcfbd547SKirill Korotaev 		  void __user *buffer, size_t *lenp, loff_t *ppos,
213200b7c339SAmerigo Wang 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
2133fcfbd547SKirill Korotaev 			      int write, void *data),
2134fcfbd547SKirill Korotaev 		  void *data)
2135fcfbd547SKirill Korotaev {
21368d65af78SAlexey Dobriyan 	return __do_proc_dointvec(table->data, table, write,
2137fcfbd547SKirill Korotaev 			buffer, lenp, ppos, conv, data);
2138fcfbd547SKirill Korotaev }
2139fcfbd547SKirill Korotaev 
21401da177e4SLinus Torvalds /**
21411da177e4SLinus Torvalds  * proc_dointvec - read a vector of integers
21421da177e4SLinus Torvalds  * @table: the sysctl table
21431da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
21441da177e4SLinus Torvalds  * @buffer: the user buffer
21451da177e4SLinus Torvalds  * @lenp: the size of the user buffer
21461da177e4SLinus Torvalds  * @ppos: file position
21471da177e4SLinus Torvalds  *
21481da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
21491da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
21501da177e4SLinus Torvalds  *
21511da177e4SLinus Torvalds  * Returns 0 on success.
21521da177e4SLinus Torvalds  */
21538d65af78SAlexey Dobriyan int proc_dointvec(struct ctl_table *table, int write,
21541da177e4SLinus Torvalds 		     void __user *buffer, size_t *lenp, loff_t *ppos)
21551da177e4SLinus Torvalds {
21568d65af78SAlexey Dobriyan     return do_proc_dointvec(table,write,buffer,lenp,ppos,
21571da177e4SLinus Torvalds 		    	    NULL,NULL);
21581da177e4SLinus Torvalds }
21591da177e4SLinus Torvalds 
216034f5a398STheodore Ts'o /*
216134f5a398STheodore Ts'o  * Taint values can only be increased
216225ddbb18SAndi Kleen  * This means we can safely use a temporary.
216334f5a398STheodore Ts'o  */
21648d65af78SAlexey Dobriyan static int proc_taint(struct ctl_table *table, int write,
216534f5a398STheodore Ts'o 			       void __user *buffer, size_t *lenp, loff_t *ppos)
216634f5a398STheodore Ts'o {
216725ddbb18SAndi Kleen 	struct ctl_table t;
216825ddbb18SAndi Kleen 	unsigned long tmptaint = get_taint();
216925ddbb18SAndi Kleen 	int err;
217034f5a398STheodore Ts'o 
217191fcd412SBastian Blank 	if (write && !capable(CAP_SYS_ADMIN))
217234f5a398STheodore Ts'o 		return -EPERM;
217334f5a398STheodore Ts'o 
217425ddbb18SAndi Kleen 	t = *table;
217525ddbb18SAndi Kleen 	t.data = &tmptaint;
21768d65af78SAlexey Dobriyan 	err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
217725ddbb18SAndi Kleen 	if (err < 0)
217825ddbb18SAndi Kleen 		return err;
217925ddbb18SAndi Kleen 
218025ddbb18SAndi Kleen 	if (write) {
218125ddbb18SAndi Kleen 		/*
218225ddbb18SAndi Kleen 		 * Poor man's atomic or. Not worth adding a primitive
218325ddbb18SAndi Kleen 		 * to everyone's atomic.h for this
218425ddbb18SAndi Kleen 		 */
218525ddbb18SAndi Kleen 		int i;
218625ddbb18SAndi Kleen 		for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
218725ddbb18SAndi Kleen 			if ((tmptaint >> i) & 1)
2188373d4d09SRusty Russell 				add_taint(i, LOCKDEP_STILL_OK);
218925ddbb18SAndi Kleen 		}
219025ddbb18SAndi Kleen 	}
219125ddbb18SAndi Kleen 
219225ddbb18SAndi Kleen 	return err;
219334f5a398STheodore Ts'o }
219434f5a398STheodore Ts'o 
2195bfdc0b49SRichard Weinberger #ifdef CONFIG_PRINTK
2196620f6e8eSKees Cook static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
2197bfdc0b49SRichard Weinberger 				void __user *buffer, size_t *lenp, loff_t *ppos)
2198bfdc0b49SRichard Weinberger {
2199bfdc0b49SRichard Weinberger 	if (write && !capable(CAP_SYS_ADMIN))
2200bfdc0b49SRichard Weinberger 		return -EPERM;
2201bfdc0b49SRichard Weinberger 
2202bfdc0b49SRichard Weinberger 	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
2203bfdc0b49SRichard Weinberger }
2204bfdc0b49SRichard Weinberger #endif
2205bfdc0b49SRichard Weinberger 
22061da177e4SLinus Torvalds struct do_proc_dointvec_minmax_conv_param {
22071da177e4SLinus Torvalds 	int *min;
22081da177e4SLinus Torvalds 	int *max;
22091da177e4SLinus Torvalds };
22101da177e4SLinus Torvalds 
221100b7c339SAmerigo Wang static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
22121da177e4SLinus Torvalds 					int *valp,
22131da177e4SLinus Torvalds 					int write, void *data)
22141da177e4SLinus Torvalds {
22151da177e4SLinus Torvalds 	struct do_proc_dointvec_minmax_conv_param *param = data;
22161da177e4SLinus Torvalds 	if (write) {
22171da177e4SLinus Torvalds 		int val = *negp ? -*lvalp : *lvalp;
22181da177e4SLinus Torvalds 		if ((param->min && *param->min > val) ||
22191da177e4SLinus Torvalds 		    (param->max && *param->max < val))
22201da177e4SLinus Torvalds 			return -EINVAL;
22211da177e4SLinus Torvalds 		*valp = val;
22221da177e4SLinus Torvalds 	} else {
22231da177e4SLinus Torvalds 		int val = *valp;
22241da177e4SLinus Torvalds 		if (val < 0) {
222500b7c339SAmerigo Wang 			*negp = true;
22269a5bc726SIlya Dryomov 			*lvalp = -(unsigned long)val;
22271da177e4SLinus Torvalds 		} else {
222800b7c339SAmerigo Wang 			*negp = false;
22291da177e4SLinus Torvalds 			*lvalp = (unsigned long)val;
22301da177e4SLinus Torvalds 		}
22311da177e4SLinus Torvalds 	}
22321da177e4SLinus Torvalds 	return 0;
22331da177e4SLinus Torvalds }
22341da177e4SLinus Torvalds 
22351da177e4SLinus Torvalds /**
22361da177e4SLinus Torvalds  * proc_dointvec_minmax - read a vector of integers with min/max values
22371da177e4SLinus Torvalds  * @table: the sysctl table
22381da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
22391da177e4SLinus Torvalds  * @buffer: the user buffer
22401da177e4SLinus Torvalds  * @lenp: the size of the user buffer
22411da177e4SLinus Torvalds  * @ppos: file position
22421da177e4SLinus Torvalds  *
22431da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
22441da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
22451da177e4SLinus Torvalds  *
22461da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
22471da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
22481da177e4SLinus Torvalds  *
22491da177e4SLinus Torvalds  * Returns 0 on success.
22501da177e4SLinus Torvalds  */
22518d65af78SAlexey Dobriyan int proc_dointvec_minmax(struct ctl_table *table, int write,
22521da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
22531da177e4SLinus Torvalds {
22541da177e4SLinus Torvalds 	struct do_proc_dointvec_minmax_conv_param param = {
22551da177e4SLinus Torvalds 		.min = (int *) table->extra1,
22561da177e4SLinus Torvalds 		.max = (int *) table->extra2,
22571da177e4SLinus Torvalds 	};
22588d65af78SAlexey Dobriyan 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
22591da177e4SLinus Torvalds 				do_proc_dointvec_minmax_conv, &param);
22601da177e4SLinus Torvalds }
22611da177e4SLinus Torvalds 
226254b50199SKees Cook static void validate_coredump_safety(void)
226354b50199SKees Cook {
2264046d662fSAlex Kelly #ifdef CONFIG_COREDUMP
2265e579d2c2SKees Cook 	if (suid_dumpable == SUID_DUMP_ROOT &&
226654b50199SKees Cook 	    core_pattern[0] != '/' && core_pattern[0] != '|') {
226754b50199SKees Cook 		printk(KERN_WARNING "Unsafe core_pattern used with "\
226854b50199SKees Cook 			"suid_dumpable=2. Pipe handler or fully qualified "\
226954b50199SKees Cook 			"core dump path required.\n");
227054b50199SKees Cook 	}
2271046d662fSAlex Kelly #endif
227254b50199SKees Cook }
227354b50199SKees Cook 
227454b50199SKees Cook static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
227554b50199SKees Cook 		void __user *buffer, size_t *lenp, loff_t *ppos)
227654b50199SKees Cook {
227754b50199SKees Cook 	int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
227854b50199SKees Cook 	if (!error)
227954b50199SKees Cook 		validate_coredump_safety();
228054b50199SKees Cook 	return error;
228154b50199SKees Cook }
228254b50199SKees Cook 
2283046d662fSAlex Kelly #ifdef CONFIG_COREDUMP
228454b50199SKees Cook static int proc_dostring_coredump(struct ctl_table *table, int write,
228554b50199SKees Cook 		  void __user *buffer, size_t *lenp, loff_t *ppos)
228654b50199SKees Cook {
228754b50199SKees Cook 	int error = proc_dostring(table, write, buffer, lenp, ppos);
228854b50199SKees Cook 	if (!error)
228954b50199SKees Cook 		validate_coredump_safety();
229054b50199SKees Cook 	return error;
229154b50199SKees Cook }
2292046d662fSAlex Kelly #endif
229354b50199SKees Cook 
2294d8217f07SEric W. Biederman static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
22951da177e4SLinus Torvalds 				     void __user *buffer,
22961da177e4SLinus Torvalds 				     size_t *lenp, loff_t *ppos,
22971da177e4SLinus Torvalds 				     unsigned long convmul,
22981da177e4SLinus Torvalds 				     unsigned long convdiv)
22991da177e4SLinus Torvalds {
230000b7c339SAmerigo Wang 	unsigned long *i, *min, *max;
230100b7c339SAmerigo Wang 	int vleft, first = 1, err = 0;
230200b7c339SAmerigo Wang 	unsigned long page = 0;
230300b7c339SAmerigo Wang 	size_t left;
230400b7c339SAmerigo Wang 	char *kbuf;
23051da177e4SLinus Torvalds 
230600b7c339SAmerigo Wang 	if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
23071da177e4SLinus Torvalds 		*lenp = 0;
23081da177e4SLinus Torvalds 		return 0;
23091da177e4SLinus Torvalds 	}
23101da177e4SLinus Torvalds 
2311fcfbd547SKirill Korotaev 	i = (unsigned long *) data;
23121da177e4SLinus Torvalds 	min = (unsigned long *) table->extra1;
23131da177e4SLinus Torvalds 	max = (unsigned long *) table->extra2;
23141da177e4SLinus Torvalds 	vleft = table->maxlen / sizeof(unsigned long);
23151da177e4SLinus Torvalds 	left = *lenp;
23161da177e4SLinus Torvalds 
23171da177e4SLinus Torvalds 	if (write) {
2318f4aacea2SKees Cook 		if (*ppos) {
2319f4aacea2SKees Cook 			switch (sysctl_writes_strict) {
2320f4aacea2SKees Cook 			case SYSCTL_WRITES_STRICT:
2321f4aacea2SKees Cook 				goto out;
2322f4aacea2SKees Cook 			case SYSCTL_WRITES_WARN:
2323f4aacea2SKees Cook 				warn_sysctl_write(table);
2324f4aacea2SKees Cook 				break;
2325f4aacea2SKees Cook 			default:
2326f4aacea2SKees Cook 				break;
2327f4aacea2SKees Cook 			}
2328f4aacea2SKees Cook 		}
2329f4aacea2SKees Cook 
233000b7c339SAmerigo Wang 		if (left > PAGE_SIZE - 1)
233100b7c339SAmerigo Wang 			left = PAGE_SIZE - 1;
233200b7c339SAmerigo Wang 		page = __get_free_page(GFP_TEMPORARY);
233300b7c339SAmerigo Wang 		kbuf = (char *) page;
233400b7c339SAmerigo Wang 		if (!kbuf)
233500b7c339SAmerigo Wang 			return -ENOMEM;
233600b7c339SAmerigo Wang 		if (copy_from_user(kbuf, buffer, left)) {
233700b7c339SAmerigo Wang 			err = -EFAULT;
233800b7c339SAmerigo Wang 			goto free;
23391da177e4SLinus Torvalds 		}
234000b7c339SAmerigo Wang 		kbuf[left] = 0;
23411da177e4SLinus Torvalds 	}
23421da177e4SLinus Torvalds 
234327b3d80aSEric Dumazet 	for (; left && vleft--; i++, first = 0) {
234400b7c339SAmerigo Wang 		unsigned long val;
234500b7c339SAmerigo Wang 
234600b7c339SAmerigo Wang 		if (write) {
234700b7c339SAmerigo Wang 			bool neg;
234800b7c339SAmerigo Wang 
234900b7c339SAmerigo Wang 			left -= proc_skip_spaces(&kbuf);
235000b7c339SAmerigo Wang 
235100b7c339SAmerigo Wang 			err = proc_get_long(&kbuf, &left, &val, &neg,
235200b7c339SAmerigo Wang 					     proc_wspace_sep,
235300b7c339SAmerigo Wang 					     sizeof(proc_wspace_sep), NULL);
235400b7c339SAmerigo Wang 			if (err)
235500b7c339SAmerigo Wang 				break;
23561da177e4SLinus Torvalds 			if (neg)
23571da177e4SLinus Torvalds 				continue;
23581da177e4SLinus Torvalds 			if ((min && val < *min) || (max && val > *max))
23591da177e4SLinus Torvalds 				continue;
23601da177e4SLinus Torvalds 			*i = val;
23611da177e4SLinus Torvalds 		} else {
236200b7c339SAmerigo Wang 			val = convdiv * (*i) / convmul;
23637833819dSChen Gang 			if (!first) {
236400b7c339SAmerigo Wang 				err = proc_put_char(&buffer, &left, '\t');
23657833819dSChen Gang 				if (err)
23667833819dSChen Gang 					break;
23677833819dSChen Gang 			}
236800b7c339SAmerigo Wang 			err = proc_put_long(&buffer, &left, val, false);
236900b7c339SAmerigo Wang 			if (err)
237000b7c339SAmerigo Wang 				break;
23711da177e4SLinus Torvalds 		}
23721da177e4SLinus Torvalds 	}
23731da177e4SLinus Torvalds 
237400b7c339SAmerigo Wang 	if (!write && !first && left && !err)
237500b7c339SAmerigo Wang 		err = proc_put_char(&buffer, &left, '\n');
237600b7c339SAmerigo Wang 	if (write && !err)
237700b7c339SAmerigo Wang 		left -= proc_skip_spaces(&kbuf);
237800b7c339SAmerigo Wang free:
23791da177e4SLinus Torvalds 	if (write) {
238000b7c339SAmerigo Wang 		free_page(page);
238100b7c339SAmerigo Wang 		if (first)
238200b7c339SAmerigo Wang 			return err ? : -EINVAL;
23831da177e4SLinus Torvalds 	}
23841da177e4SLinus Torvalds 	*lenp -= left;
2385f4aacea2SKees Cook out:
23861da177e4SLinus Torvalds 	*ppos += *lenp;
238700b7c339SAmerigo Wang 	return err;
23881da177e4SLinus Torvalds }
23891da177e4SLinus Torvalds 
2390d8217f07SEric W. Biederman static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
2391fcfbd547SKirill Korotaev 				     void __user *buffer,
2392fcfbd547SKirill Korotaev 				     size_t *lenp, loff_t *ppos,
2393fcfbd547SKirill Korotaev 				     unsigned long convmul,
2394fcfbd547SKirill Korotaev 				     unsigned long convdiv)
2395fcfbd547SKirill Korotaev {
2396fcfbd547SKirill Korotaev 	return __do_proc_doulongvec_minmax(table->data, table, write,
23978d65af78SAlexey Dobriyan 			buffer, lenp, ppos, convmul, convdiv);
2398fcfbd547SKirill Korotaev }
2399fcfbd547SKirill Korotaev 
24001da177e4SLinus Torvalds /**
24011da177e4SLinus Torvalds  * proc_doulongvec_minmax - read a vector of long integers with min/max values
24021da177e4SLinus Torvalds  * @table: the sysctl table
24031da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
24041da177e4SLinus Torvalds  * @buffer: the user buffer
24051da177e4SLinus Torvalds  * @lenp: the size of the user buffer
24061da177e4SLinus Torvalds  * @ppos: file position
24071da177e4SLinus Torvalds  *
24081da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
24091da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
24101da177e4SLinus Torvalds  *
24111da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
24121da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
24131da177e4SLinus Torvalds  *
24141da177e4SLinus Torvalds  * Returns 0 on success.
24151da177e4SLinus Torvalds  */
24168d65af78SAlexey Dobriyan int proc_doulongvec_minmax(struct ctl_table *table, int write,
24171da177e4SLinus Torvalds 			   void __user *buffer, size_t *lenp, loff_t *ppos)
24181da177e4SLinus Torvalds {
24198d65af78SAlexey Dobriyan     return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
24201da177e4SLinus Torvalds }
24211da177e4SLinus Torvalds 
24221da177e4SLinus Torvalds /**
24231da177e4SLinus Torvalds  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
24241da177e4SLinus Torvalds  * @table: the sysctl table
24251da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
24261da177e4SLinus Torvalds  * @buffer: the user buffer
24271da177e4SLinus Torvalds  * @lenp: the size of the user buffer
24281da177e4SLinus Torvalds  * @ppos: file position
24291da177e4SLinus Torvalds  *
24301da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
24311da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string. The values
24321da177e4SLinus Torvalds  * are treated as milliseconds, and converted to jiffies when they are stored.
24331da177e4SLinus Torvalds  *
24341da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
24351da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
24361da177e4SLinus Torvalds  *
24371da177e4SLinus Torvalds  * Returns 0 on success.
24381da177e4SLinus Torvalds  */
2439d8217f07SEric W. Biederman int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
24401da177e4SLinus Torvalds 				      void __user *buffer,
24411da177e4SLinus Torvalds 				      size_t *lenp, loff_t *ppos)
24421da177e4SLinus Torvalds {
24438d65af78SAlexey Dobriyan     return do_proc_doulongvec_minmax(table, write, buffer,
24441da177e4SLinus Torvalds 				     lenp, ppos, HZ, 1000l);
24451da177e4SLinus Torvalds }
24461da177e4SLinus Torvalds 
24471da177e4SLinus Torvalds 
244800b7c339SAmerigo Wang static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
24491da177e4SLinus Torvalds 					 int *valp,
24501da177e4SLinus Torvalds 					 int write, void *data)
24511da177e4SLinus Torvalds {
24521da177e4SLinus Torvalds 	if (write) {
2453cba9f33dSBart Samwel 		if (*lvalp > LONG_MAX / HZ)
2454cba9f33dSBart Samwel 			return 1;
24551da177e4SLinus Torvalds 		*valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
24561da177e4SLinus Torvalds 	} else {
24571da177e4SLinus Torvalds 		int val = *valp;
24581da177e4SLinus Torvalds 		unsigned long lval;
24591da177e4SLinus Torvalds 		if (val < 0) {
246000b7c339SAmerigo Wang 			*negp = true;
24619a5bc726SIlya Dryomov 			lval = -(unsigned long)val;
24621da177e4SLinus Torvalds 		} else {
246300b7c339SAmerigo Wang 			*negp = false;
24641da177e4SLinus Torvalds 			lval = (unsigned long)val;
24651da177e4SLinus Torvalds 		}
24661da177e4SLinus Torvalds 		*lvalp = lval / HZ;
24671da177e4SLinus Torvalds 	}
24681da177e4SLinus Torvalds 	return 0;
24691da177e4SLinus Torvalds }
24701da177e4SLinus Torvalds 
247100b7c339SAmerigo Wang static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
24721da177e4SLinus Torvalds 						int *valp,
24731da177e4SLinus Torvalds 						int write, void *data)
24741da177e4SLinus Torvalds {
24751da177e4SLinus Torvalds 	if (write) {
2476cba9f33dSBart Samwel 		if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
2477cba9f33dSBart Samwel 			return 1;
24781da177e4SLinus Torvalds 		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
24791da177e4SLinus Torvalds 	} else {
24801da177e4SLinus Torvalds 		int val = *valp;
24811da177e4SLinus Torvalds 		unsigned long lval;
24821da177e4SLinus Torvalds 		if (val < 0) {
248300b7c339SAmerigo Wang 			*negp = true;
24849a5bc726SIlya Dryomov 			lval = -(unsigned long)val;
24851da177e4SLinus Torvalds 		} else {
248600b7c339SAmerigo Wang 			*negp = false;
24871da177e4SLinus Torvalds 			lval = (unsigned long)val;
24881da177e4SLinus Torvalds 		}
24891da177e4SLinus Torvalds 		*lvalp = jiffies_to_clock_t(lval);
24901da177e4SLinus Torvalds 	}
24911da177e4SLinus Torvalds 	return 0;
24921da177e4SLinus Torvalds }
24931da177e4SLinus Torvalds 
249400b7c339SAmerigo Wang static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
24951da177e4SLinus Torvalds 					    int *valp,
24961da177e4SLinus Torvalds 					    int write, void *data)
24971da177e4SLinus Torvalds {
24981da177e4SLinus Torvalds 	if (write) {
2499d738ce8fSFrancesco Fusco 		unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
2500d738ce8fSFrancesco Fusco 
2501d738ce8fSFrancesco Fusco 		if (jif > INT_MAX)
2502d738ce8fSFrancesco Fusco 			return 1;
2503d738ce8fSFrancesco Fusco 		*valp = (int)jif;
25041da177e4SLinus Torvalds 	} else {
25051da177e4SLinus Torvalds 		int val = *valp;
25061da177e4SLinus Torvalds 		unsigned long lval;
25071da177e4SLinus Torvalds 		if (val < 0) {
250800b7c339SAmerigo Wang 			*negp = true;
25099a5bc726SIlya Dryomov 			lval = -(unsigned long)val;
25101da177e4SLinus Torvalds 		} else {
251100b7c339SAmerigo Wang 			*negp = false;
25121da177e4SLinus Torvalds 			lval = (unsigned long)val;
25131da177e4SLinus Torvalds 		}
25141da177e4SLinus Torvalds 		*lvalp = jiffies_to_msecs(lval);
25151da177e4SLinus Torvalds 	}
25161da177e4SLinus Torvalds 	return 0;
25171da177e4SLinus Torvalds }
25181da177e4SLinus Torvalds 
25191da177e4SLinus Torvalds /**
25201da177e4SLinus Torvalds  * proc_dointvec_jiffies - read a vector of integers as seconds
25211da177e4SLinus Torvalds  * @table: the sysctl table
25221da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
25231da177e4SLinus Torvalds  * @buffer: the user buffer
25241da177e4SLinus Torvalds  * @lenp: the size of the user buffer
25251da177e4SLinus Torvalds  * @ppos: file position
25261da177e4SLinus Torvalds  *
25271da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
25281da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
25291da177e4SLinus Torvalds  * The values read are assumed to be in seconds, and are converted into
25301da177e4SLinus Torvalds  * jiffies.
25311da177e4SLinus Torvalds  *
25321da177e4SLinus Torvalds  * Returns 0 on success.
25331da177e4SLinus Torvalds  */
25348d65af78SAlexey Dobriyan int proc_dointvec_jiffies(struct ctl_table *table, int write,
25351da177e4SLinus Torvalds 			  void __user *buffer, size_t *lenp, loff_t *ppos)
25361da177e4SLinus Torvalds {
25378d65af78SAlexey Dobriyan     return do_proc_dointvec(table,write,buffer,lenp,ppos,
25381da177e4SLinus Torvalds 		    	    do_proc_dointvec_jiffies_conv,NULL);
25391da177e4SLinus Torvalds }
25401da177e4SLinus Torvalds 
25411da177e4SLinus Torvalds /**
25421da177e4SLinus Torvalds  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
25431da177e4SLinus Torvalds  * @table: the sysctl table
25441da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
25451da177e4SLinus Torvalds  * @buffer: the user buffer
25461da177e4SLinus Torvalds  * @lenp: the size of the user buffer
25471e5d5331SRandy Dunlap  * @ppos: pointer to the file position
25481da177e4SLinus Torvalds  *
25491da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
25501da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
25511da177e4SLinus Torvalds  * The values read are assumed to be in 1/USER_HZ seconds, and
25521da177e4SLinus Torvalds  * are converted into jiffies.
25531da177e4SLinus Torvalds  *
25541da177e4SLinus Torvalds  * Returns 0 on success.
25551da177e4SLinus Torvalds  */
25568d65af78SAlexey Dobriyan int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
25571da177e4SLinus Torvalds 				 void __user *buffer, size_t *lenp, loff_t *ppos)
25581da177e4SLinus Torvalds {
25598d65af78SAlexey Dobriyan     return do_proc_dointvec(table,write,buffer,lenp,ppos,
25601da177e4SLinus Torvalds 		    	    do_proc_dointvec_userhz_jiffies_conv,NULL);
25611da177e4SLinus Torvalds }
25621da177e4SLinus Torvalds 
25631da177e4SLinus Torvalds /**
25641da177e4SLinus Torvalds  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
25651da177e4SLinus Torvalds  * @table: the sysctl table
25661da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
25671da177e4SLinus Torvalds  * @buffer: the user buffer
25681da177e4SLinus Torvalds  * @lenp: the size of the user buffer
256967be2dd1SMartin Waitz  * @ppos: file position
257067be2dd1SMartin Waitz  * @ppos: the current position in the file
25711da177e4SLinus Torvalds  *
25721da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
25731da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
25741da177e4SLinus Torvalds  * The values read are assumed to be in 1/1000 seconds, and
25751da177e4SLinus Torvalds  * are converted into jiffies.
25761da177e4SLinus Torvalds  *
25771da177e4SLinus Torvalds  * Returns 0 on success.
25781da177e4SLinus Torvalds  */
25798d65af78SAlexey Dobriyan int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
25801da177e4SLinus Torvalds 			     void __user *buffer, size_t *lenp, loff_t *ppos)
25811da177e4SLinus Torvalds {
25828d65af78SAlexey Dobriyan 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
25831da177e4SLinus Torvalds 				do_proc_dointvec_ms_jiffies_conv, NULL);
25841da177e4SLinus Torvalds }
25851da177e4SLinus Torvalds 
25868d65af78SAlexey Dobriyan static int proc_do_cad_pid(struct ctl_table *table, int write,
25879ec52099SCedric Le Goater 			   void __user *buffer, size_t *lenp, loff_t *ppos)
25889ec52099SCedric Le Goater {
25899ec52099SCedric Le Goater 	struct pid *new_pid;
25909ec52099SCedric Le Goater 	pid_t tmp;
25919ec52099SCedric Le Goater 	int r;
25929ec52099SCedric Le Goater 
25936c5f3e7bSPavel Emelyanov 	tmp = pid_vnr(cad_pid);
25949ec52099SCedric Le Goater 
25958d65af78SAlexey Dobriyan 	r = __do_proc_dointvec(&tmp, table, write, buffer,
25969ec52099SCedric Le Goater 			       lenp, ppos, NULL, NULL);
25979ec52099SCedric Le Goater 	if (r || !write)
25989ec52099SCedric Le Goater 		return r;
25999ec52099SCedric Le Goater 
26009ec52099SCedric Le Goater 	new_pid = find_get_pid(tmp);
26019ec52099SCedric Le Goater 	if (!new_pid)
26029ec52099SCedric Le Goater 		return -ESRCH;
26039ec52099SCedric Le Goater 
26049ec52099SCedric Le Goater 	put_pid(xchg(&cad_pid, new_pid));
26059ec52099SCedric Le Goater 	return 0;
26069ec52099SCedric Le Goater }
26079ec52099SCedric Le Goater 
26089f977fb7SOctavian Purdila /**
26099f977fb7SOctavian Purdila  * proc_do_large_bitmap - read/write from/to a large bitmap
26109f977fb7SOctavian Purdila  * @table: the sysctl table
26119f977fb7SOctavian Purdila  * @write: %TRUE if this is a write to the sysctl file
26129f977fb7SOctavian Purdila  * @buffer: the user buffer
26139f977fb7SOctavian Purdila  * @lenp: the size of the user buffer
26149f977fb7SOctavian Purdila  * @ppos: file position
26159f977fb7SOctavian Purdila  *
26169f977fb7SOctavian Purdila  * The bitmap is stored at table->data and the bitmap length (in bits)
26179f977fb7SOctavian Purdila  * in table->maxlen.
26189f977fb7SOctavian Purdila  *
26199f977fb7SOctavian Purdila  * We use a range comma separated format (e.g. 1,3-4,10-10) so that
26209f977fb7SOctavian Purdila  * large bitmaps may be represented in a compact manner. Writing into
26219f977fb7SOctavian Purdila  * the file will clear the bitmap then update it with the given input.
26229f977fb7SOctavian Purdila  *
26239f977fb7SOctavian Purdila  * Returns 0 on success.
26249f977fb7SOctavian Purdila  */
26259f977fb7SOctavian Purdila int proc_do_large_bitmap(struct ctl_table *table, int write,
26269f977fb7SOctavian Purdila 			 void __user *buffer, size_t *lenp, loff_t *ppos)
26279f977fb7SOctavian Purdila {
26289f977fb7SOctavian Purdila 	int err = 0;
26299f977fb7SOctavian Purdila 	bool first = 1;
26309f977fb7SOctavian Purdila 	size_t left = *lenp;
26319f977fb7SOctavian Purdila 	unsigned long bitmap_len = table->maxlen;
2632122ff243SWANG Cong 	unsigned long *bitmap = *(unsigned long **) table->data;
26339f977fb7SOctavian Purdila 	unsigned long *tmp_bitmap = NULL;
26349f977fb7SOctavian Purdila 	char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
26359f977fb7SOctavian Purdila 
2636122ff243SWANG Cong 	if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
26379f977fb7SOctavian Purdila 		*lenp = 0;
26389f977fb7SOctavian Purdila 		return 0;
26399f977fb7SOctavian Purdila 	}
26409f977fb7SOctavian Purdila 
26419f977fb7SOctavian Purdila 	if (write) {
26429f977fb7SOctavian Purdila 		unsigned long page = 0;
26439f977fb7SOctavian Purdila 		char *kbuf;
26449f977fb7SOctavian Purdila 
26459f977fb7SOctavian Purdila 		if (left > PAGE_SIZE - 1)
26469f977fb7SOctavian Purdila 			left = PAGE_SIZE - 1;
26479f977fb7SOctavian Purdila 
26489f977fb7SOctavian Purdila 		page = __get_free_page(GFP_TEMPORARY);
26499f977fb7SOctavian Purdila 		kbuf = (char *) page;
26509f977fb7SOctavian Purdila 		if (!kbuf)
26519f977fb7SOctavian Purdila 			return -ENOMEM;
26529f977fb7SOctavian Purdila 		if (copy_from_user(kbuf, buffer, left)) {
26539f977fb7SOctavian Purdila 			free_page(page);
26549f977fb7SOctavian Purdila 			return -EFAULT;
26559f977fb7SOctavian Purdila                 }
26569f977fb7SOctavian Purdila 		kbuf[left] = 0;
26579f977fb7SOctavian Purdila 
26589f977fb7SOctavian Purdila 		tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) * sizeof(unsigned long),
26599f977fb7SOctavian Purdila 				     GFP_KERNEL);
26609f977fb7SOctavian Purdila 		if (!tmp_bitmap) {
26619f977fb7SOctavian Purdila 			free_page(page);
26629f977fb7SOctavian Purdila 			return -ENOMEM;
26639f977fb7SOctavian Purdila 		}
26649f977fb7SOctavian Purdila 		proc_skip_char(&kbuf, &left, '\n');
26659f977fb7SOctavian Purdila 		while (!err && left) {
26669f977fb7SOctavian Purdila 			unsigned long val_a, val_b;
26679f977fb7SOctavian Purdila 			bool neg;
26689f977fb7SOctavian Purdila 
26699f977fb7SOctavian Purdila 			err = proc_get_long(&kbuf, &left, &val_a, &neg, tr_a,
26709f977fb7SOctavian Purdila 					     sizeof(tr_a), &c);
26719f977fb7SOctavian Purdila 			if (err)
26729f977fb7SOctavian Purdila 				break;
26739f977fb7SOctavian Purdila 			if (val_a >= bitmap_len || neg) {
26749f977fb7SOctavian Purdila 				err = -EINVAL;
26759f977fb7SOctavian Purdila 				break;
26769f977fb7SOctavian Purdila 			}
26779f977fb7SOctavian Purdila 
26789f977fb7SOctavian Purdila 			val_b = val_a;
26799f977fb7SOctavian Purdila 			if (left) {
26809f977fb7SOctavian Purdila 				kbuf++;
26819f977fb7SOctavian Purdila 				left--;
26829f977fb7SOctavian Purdila 			}
26839f977fb7SOctavian Purdila 
26849f977fb7SOctavian Purdila 			if (c == '-') {
26859f977fb7SOctavian Purdila 				err = proc_get_long(&kbuf, &left, &val_b,
26869f977fb7SOctavian Purdila 						     &neg, tr_b, sizeof(tr_b),
26879f977fb7SOctavian Purdila 						     &c);
26889f977fb7SOctavian Purdila 				if (err)
26899f977fb7SOctavian Purdila 					break;
26909f977fb7SOctavian Purdila 				if (val_b >= bitmap_len || neg ||
26919f977fb7SOctavian Purdila 				    val_a > val_b) {
26929f977fb7SOctavian Purdila 					err = -EINVAL;
26939f977fb7SOctavian Purdila 					break;
26949f977fb7SOctavian Purdila 				}
26959f977fb7SOctavian Purdila 				if (left) {
26969f977fb7SOctavian Purdila 					kbuf++;
26979f977fb7SOctavian Purdila 					left--;
26989f977fb7SOctavian Purdila 				}
26999f977fb7SOctavian Purdila 			}
27009f977fb7SOctavian Purdila 
27015a04cca6SAkinobu Mita 			bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
27029f977fb7SOctavian Purdila 			first = 0;
27039f977fb7SOctavian Purdila 			proc_skip_char(&kbuf, &left, '\n');
27049f977fb7SOctavian Purdila 		}
27059f977fb7SOctavian Purdila 		free_page(page);
27069f977fb7SOctavian Purdila 	} else {
27079f977fb7SOctavian Purdila 		unsigned long bit_a, bit_b = 0;
27089f977fb7SOctavian Purdila 
27099f977fb7SOctavian Purdila 		while (left) {
27109f977fb7SOctavian Purdila 			bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
27119f977fb7SOctavian Purdila 			if (bit_a >= bitmap_len)
27129f977fb7SOctavian Purdila 				break;
27139f977fb7SOctavian Purdila 			bit_b = find_next_zero_bit(bitmap, bitmap_len,
27149f977fb7SOctavian Purdila 						   bit_a + 1) - 1;
27159f977fb7SOctavian Purdila 
27169f977fb7SOctavian Purdila 			if (!first) {
27179f977fb7SOctavian Purdila 				err = proc_put_char(&buffer, &left, ',');
27189f977fb7SOctavian Purdila 				if (err)
27199f977fb7SOctavian Purdila 					break;
27209f977fb7SOctavian Purdila 			}
27219f977fb7SOctavian Purdila 			err = proc_put_long(&buffer, &left, bit_a, false);
27229f977fb7SOctavian Purdila 			if (err)
27239f977fb7SOctavian Purdila 				break;
27249f977fb7SOctavian Purdila 			if (bit_a != bit_b) {
27259f977fb7SOctavian Purdila 				err = proc_put_char(&buffer, &left, '-');
27269f977fb7SOctavian Purdila 				if (err)
27279f977fb7SOctavian Purdila 					break;
27289f977fb7SOctavian Purdila 				err = proc_put_long(&buffer, &left, bit_b, false);
27299f977fb7SOctavian Purdila 				if (err)
27309f977fb7SOctavian Purdila 					break;
27319f977fb7SOctavian Purdila 			}
27329f977fb7SOctavian Purdila 
27339f977fb7SOctavian Purdila 			first = 0; bit_b++;
27349f977fb7SOctavian Purdila 		}
27359f977fb7SOctavian Purdila 		if (!err)
27369f977fb7SOctavian Purdila 			err = proc_put_char(&buffer, &left, '\n');
27379f977fb7SOctavian Purdila 	}
27389f977fb7SOctavian Purdila 
27399f977fb7SOctavian Purdila 	if (!err) {
27409f977fb7SOctavian Purdila 		if (write) {
27419f977fb7SOctavian Purdila 			if (*ppos)
27429f977fb7SOctavian Purdila 				bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
27439f977fb7SOctavian Purdila 			else
27445a04cca6SAkinobu Mita 				bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
27459f977fb7SOctavian Purdila 		}
27469f977fb7SOctavian Purdila 		kfree(tmp_bitmap);
27479f977fb7SOctavian Purdila 		*lenp -= left;
27489f977fb7SOctavian Purdila 		*ppos += *lenp;
27499f977fb7SOctavian Purdila 		return 0;
27509f977fb7SOctavian Purdila 	} else {
27519f977fb7SOctavian Purdila 		kfree(tmp_bitmap);
27529f977fb7SOctavian Purdila 		return err;
27539f977fb7SOctavian Purdila 	}
27549f977fb7SOctavian Purdila }
27559f977fb7SOctavian Purdila 
275655610500SJovi Zhang #else /* CONFIG_PROC_SYSCTL */
27571da177e4SLinus Torvalds 
27588d65af78SAlexey Dobriyan int proc_dostring(struct ctl_table *table, int write,
27591da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
27601da177e4SLinus Torvalds {
27611da177e4SLinus Torvalds 	return -ENOSYS;
27621da177e4SLinus Torvalds }
27631da177e4SLinus Torvalds 
27648d65af78SAlexey Dobriyan int proc_dointvec(struct ctl_table *table, int write,
27651da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
27661da177e4SLinus Torvalds {
27671da177e4SLinus Torvalds 	return -ENOSYS;
27681da177e4SLinus Torvalds }
27691da177e4SLinus Torvalds 
27708d65af78SAlexey Dobriyan int proc_dointvec_minmax(struct ctl_table *table, int write,
27711da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
27721da177e4SLinus Torvalds {
27731da177e4SLinus Torvalds 	return -ENOSYS;
27741da177e4SLinus Torvalds }
27751da177e4SLinus Torvalds 
27768d65af78SAlexey Dobriyan int proc_dointvec_jiffies(struct ctl_table *table, int write,
27771da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
27781da177e4SLinus Torvalds {
27791da177e4SLinus Torvalds 	return -ENOSYS;
27801da177e4SLinus Torvalds }
27811da177e4SLinus Torvalds 
27828d65af78SAlexey Dobriyan int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
27831da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
27841da177e4SLinus Torvalds {
27851da177e4SLinus Torvalds 	return -ENOSYS;
27861da177e4SLinus Torvalds }
27871da177e4SLinus Torvalds 
27888d65af78SAlexey Dobriyan int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
27891da177e4SLinus Torvalds 			     void __user *buffer, size_t *lenp, loff_t *ppos)
27901da177e4SLinus Torvalds {
27911da177e4SLinus Torvalds 	return -ENOSYS;
27921da177e4SLinus Torvalds }
27931da177e4SLinus Torvalds 
27948d65af78SAlexey Dobriyan int proc_doulongvec_minmax(struct ctl_table *table, int write,
27951da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
27961da177e4SLinus Torvalds {
27971da177e4SLinus Torvalds 	return -ENOSYS;
27981da177e4SLinus Torvalds }
27991da177e4SLinus Torvalds 
2800d8217f07SEric W. Biederman int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
28011da177e4SLinus Torvalds 				      void __user *buffer,
28021da177e4SLinus Torvalds 				      size_t *lenp, loff_t *ppos)
28031da177e4SLinus Torvalds {
28041da177e4SLinus Torvalds     return -ENOSYS;
28051da177e4SLinus Torvalds }
28061da177e4SLinus Torvalds 
28071da177e4SLinus Torvalds 
280855610500SJovi Zhang #endif /* CONFIG_PROC_SYSCTL */
28091da177e4SLinus Torvalds 
28101da177e4SLinus Torvalds /*
28111da177e4SLinus Torvalds  * No sense putting this after each symbol definition, twice,
28121da177e4SLinus Torvalds  * exception granted :-)
28131da177e4SLinus Torvalds  */
28141da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec);
28151da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_jiffies);
28161da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_minmax);
28171da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
28181da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
28191da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dostring);
28201da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_minmax);
28211da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
2822