xref: /openbmc/linux/kernel/sysctl.c (revision 1ccd15497869f3ed83b5225d410df53a96e52757)
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>
221da177e4SLinus Torvalds #include <linux/mm.h>
231da177e4SLinus Torvalds #include <linux/swap.h>
241da177e4SLinus Torvalds #include <linux/slab.h>
251da177e4SLinus Torvalds #include <linux/sysctl.h>
261da177e4SLinus Torvalds #include <linux/proc_fs.h>
2772c2d582SAndrew Morgan #include <linux/security.h>
281da177e4SLinus Torvalds #include <linux/ctype.h>
291da177e4SLinus Torvalds #include <linux/utsname.h>
301da177e4SLinus Torvalds #include <linux/smp_lock.h>
3162239ac2SAdrian Bunk #include <linux/fs.h>
321da177e4SLinus Torvalds #include <linux/init.h>
331da177e4SLinus Torvalds #include <linux/kernel.h>
340296b228SKay Sievers #include <linux/kobject.h>
3520380731SArnaldo Carvalho de Melo #include <linux/net.h>
361da177e4SLinus Torvalds #include <linux/sysrq.h>
371da177e4SLinus Torvalds #include <linux/highuid.h>
381da177e4SLinus Torvalds #include <linux/writeback.h>
391da177e4SLinus Torvalds #include <linux/hugetlb.h>
401da177e4SLinus Torvalds #include <linux/initrd.h>
410b77f5bfSDavid Howells #include <linux/key.h>
421da177e4SLinus Torvalds #include <linux/times.h>
431da177e4SLinus Torvalds #include <linux/limits.h>
441da177e4SLinus Torvalds #include <linux/dcache.h>
451da177e4SLinus Torvalds #include <linux/syscalls.h>
46c748e134SAdrian Bunk #include <linux/vmstat.h>
47c255d844SPavel Machek #include <linux/nfs_fs.h>
48c255d844SPavel Machek #include <linux/acpi.h>
4910a0a8d4SJeremy Fitzhardinge #include <linux/reboot.h>
50b0fc494fSSteven Rostedt #include <linux/ftrace.h>
5112e22c5eSDavid Howells #include <linux/slow-work.h>
52*1ccd1549SPeter Zijlstra #include <linux/perf_counter.h>
531da177e4SLinus Torvalds 
541da177e4SLinus Torvalds #include <asm/uaccess.h>
551da177e4SLinus Torvalds #include <asm/processor.h>
561da177e4SLinus Torvalds 
5729cbc78bSAndi Kleen #ifdef CONFIG_X86
5829cbc78bSAndi Kleen #include <asm/nmi.h>
590741f4d2SChuck Ebbert #include <asm/stacktrace.h>
606e7c4025SIngo Molnar #include <asm/io.h>
6129cbc78bSAndi Kleen #endif
6229cbc78bSAndi Kleen 
637058cb02SEric W. Biederman static int deprecated_sysctl_warning(struct __sysctl_args *args);
647058cb02SEric W. Biederman 
651da177e4SLinus Torvalds #if defined(CONFIG_SYSCTL)
661da177e4SLinus Torvalds 
671da177e4SLinus Torvalds /* External variables not in a header file. */
681da177e4SLinus Torvalds extern int C_A_D;
6945807a1dSIngo Molnar extern int print_fatal_signals;
701da177e4SLinus Torvalds extern int sysctl_overcommit_memory;
711da177e4SLinus Torvalds extern int sysctl_overcommit_ratio;
72fadd8fbdSKAMEZAWA Hiroyuki extern int sysctl_panic_on_oom;
73fe071d7eSDavid Rientjes extern int sysctl_oom_kill_allocating_task;
74fef1bdd6SDavid Rientjes extern int sysctl_oom_dump_tasks;
751da177e4SLinus Torvalds extern int max_threads;
761da177e4SLinus Torvalds extern int core_uses_pid;
77d6e71144SAlan Cox extern int suid_dumpable;
781da177e4SLinus Torvalds extern char core_pattern[];
791da177e4SLinus Torvalds extern int pid_max;
801da177e4SLinus Torvalds extern int min_free_kbytes;
811da177e4SLinus Torvalds extern int pid_max_min, pid_max_max;
829d0243bcSAndrew Morton extern int sysctl_drop_caches;
838ad4b1fbSRohit Seth extern int percpu_pagelist_fraction;
84bebfa101SAndi Kleen extern int compat_log;
859745512cSArjan van de Ven extern int latencytop_enabled;
86eceea0b3SAl Viro extern int sysctl_nr_open_min, sysctl_nr_open_max;
87dd8632a1SPaul Mundt #ifndef CONFIG_MMU
88dd8632a1SPaul Mundt extern int sysctl_nr_trim_pages;
89dd8632a1SPaul Mundt #endif
9031a72bceSPaul E. McKenney #ifdef CONFIG_RCU_TORTURE_TEST
9131a72bceSPaul E. McKenney extern int rcutorture_runnable;
9231a72bceSPaul E. McKenney #endif /* #ifdef CONFIG_RCU_TORTURE_TEST */
931da177e4SLinus Torvalds 
94c4f3b63fSRavikiran G Thirumalai /* Constants used for minimum and  maximum */
95195cf453SBron Gondwana #ifdef CONFIG_DETECT_SOFTLOCKUP
96c4f3b63fSRavikiran G Thirumalai static int sixty = 60;
979383d967SDimitri Sivanich static int neg_one = -1;
98c4f3b63fSRavikiran G Thirumalai #endif
99c4f3b63fSRavikiran G Thirumalai 
100c4f3b63fSRavikiran G Thirumalai static int zero;
101cd5f9a4cSLinus Torvalds static int __maybe_unused one = 1;
102cd5f9a4cSLinus Torvalds static int __maybe_unused two = 2;
103fc3501d4SSven Wegener static unsigned long one_ul = 1;
104c4f3b63fSRavikiran G Thirumalai static int one_hundred = 100;
105fafd688eSPeter W Morreale static int one_thousand = 1000;
106c4f3b63fSRavikiran G Thirumalai 
1071da177e4SLinus Torvalds /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
1081da177e4SLinus Torvalds static int maxolduid = 65535;
1091da177e4SLinus Torvalds static int minolduid;
1108ad4b1fbSRohit Seth static int min_percpu_pagelist_fract = 8;
1111da177e4SLinus Torvalds 
1121da177e4SLinus Torvalds static int ngroups_max = NGROUPS_MAX;
1131da177e4SLinus Torvalds 
114a1ef5adbSJohannes Berg #ifdef CONFIG_MODULES
1151da177e4SLinus Torvalds extern char modprobe_path[];
1161da177e4SLinus Torvalds #endif
1171da177e4SLinus Torvalds #ifdef CONFIG_CHR_DEV_SG
1181da177e4SLinus Torvalds extern int sg_big_buff;
1191da177e4SLinus Torvalds #endif
1201da177e4SLinus Torvalds 
12172c57ed5SDavid S. Miller #ifdef CONFIG_SPARC
12217f04fbbSDavid S. Miller #include <asm/system.h>
1231da177e4SLinus Torvalds #endif
1241da177e4SLinus Torvalds 
1250871420fSDavid S. Miller #ifdef CONFIG_SPARC64
1260871420fSDavid S. Miller extern int sysctl_tsb_ratio;
1270871420fSDavid S. Miller #endif
1280871420fSDavid S. Miller 
1291da177e4SLinus Torvalds #ifdef __hppa__
1301da177e4SLinus Torvalds extern int pwrsw_enabled;
1311da177e4SLinus Torvalds extern int unaligned_enabled;
1321da177e4SLinus Torvalds #endif
1331da177e4SLinus Torvalds 
134347a8dc3SMartin Schwidefsky #ifdef CONFIG_S390
1351da177e4SLinus Torvalds #ifdef CONFIG_MATHEMU
1361da177e4SLinus Torvalds extern int sysctl_ieee_emulation_warnings;
1371da177e4SLinus Torvalds #endif
1381da177e4SLinus Torvalds extern int sysctl_userprocess_debug;
139951f22d5SMartin Schwidefsky extern int spin_retry;
1401da177e4SLinus Torvalds #endif
1411da177e4SLinus Torvalds 
1421da177e4SLinus Torvalds #ifdef CONFIG_BSD_PROCESS_ACCT
1431da177e4SLinus Torvalds extern int acct_parm[];
1441da177e4SLinus Torvalds #endif
1451da177e4SLinus Torvalds 
146d2b176edSJes Sorensen #ifdef CONFIG_IA64
147d2b176edSJes Sorensen extern int no_unaligned_warning;
14888fc241fSDoug Chapman extern int unaligned_dump_stack;
149d2b176edSJes Sorensen #endif
150d2b176edSJes Sorensen 
15123f78d4aSIngo Molnar #ifdef CONFIG_RT_MUTEXES
15223f78d4aSIngo Molnar extern int max_lock_depth;
15323f78d4aSIngo Molnar #endif
15423f78d4aSIngo Molnar 
155d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL
156d8217f07SEric W. Biederman static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp,
1579ec52099SCedric Le Goater 		  void __user *buffer, size_t *lenp, loff_t *ppos);
15825ddbb18SAndi Kleen static int proc_taint(struct ctl_table *table, int write, struct file *filp,
15934f5a398STheodore Ts'o 			       void __user *buffer, size_t *lenp, loff_t *ppos);
160d6f8ff73SRandy Dunlap #endif
1619ec52099SCedric Le Goater 
162d8217f07SEric W. Biederman static struct ctl_table root_table[];
163e51b6ba0SEric W. Biederman static struct ctl_table_root sysctl_table_root;
164e51b6ba0SEric W. Biederman static struct ctl_table_header root_table_header = {
165b380b0d4SAl Viro 	.count = 1,
166e51b6ba0SEric W. Biederman 	.ctl_table = root_table,
16773455092SAl Viro 	.ctl_entry = LIST_HEAD_INIT(sysctl_table_root.default_set.list),
168e51b6ba0SEric W. Biederman 	.root = &sysctl_table_root,
16973455092SAl Viro 	.set = &sysctl_table_root.default_set,
170e51b6ba0SEric W. Biederman };
171e51b6ba0SEric W. Biederman static struct ctl_table_root sysctl_table_root = {
172e51b6ba0SEric W. Biederman 	.root_list = LIST_HEAD_INIT(sysctl_table_root.root_list),
17373455092SAl Viro 	.default_set.list = LIST_HEAD_INIT(root_table_header.ctl_entry),
174e51b6ba0SEric W. Biederman };
1751da177e4SLinus Torvalds 
176d8217f07SEric W. Biederman static struct ctl_table kern_table[];
177d8217f07SEric W. Biederman static struct ctl_table vm_table[];
178d8217f07SEric W. Biederman static struct ctl_table fs_table[];
179d8217f07SEric W. Biederman static struct ctl_table debug_table[];
180d8217f07SEric W. Biederman static struct ctl_table dev_table[];
181d8217f07SEric W. Biederman extern struct ctl_table random_table[];
1822d9048e2SAmy Griffis #ifdef CONFIG_INOTIFY_USER
183d8217f07SEric W. Biederman extern struct ctl_table inotify_table[];
1840399cb08SRobert Love #endif
1857ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL
1867ef9964eSDavide Libenzi extern struct ctl_table epoll_table[];
1877ef9964eSDavide Libenzi #endif
1881da177e4SLinus Torvalds 
1891da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1901da177e4SLinus Torvalds int sysctl_legacy_va_layout;
1911da177e4SLinus Torvalds #endif
1921da177e4SLinus Torvalds 
193f20786ffSPeter Zijlstra extern int prove_locking;
194f20786ffSPeter Zijlstra extern int lock_stat;
1959bc9a6bdSEric W. Biederman 
1961da177e4SLinus Torvalds /* The default sysctl tables: */
1971da177e4SLinus Torvalds 
198d8217f07SEric W. Biederman static struct ctl_table root_table[] = {
1991da177e4SLinus Torvalds 	{
2001da177e4SLinus Torvalds 		.ctl_name	= CTL_KERN,
2011da177e4SLinus Torvalds 		.procname	= "kernel",
2021da177e4SLinus Torvalds 		.mode		= 0555,
2031da177e4SLinus Torvalds 		.child		= kern_table,
2041da177e4SLinus Torvalds 	},
2051da177e4SLinus Torvalds 	{
2061da177e4SLinus Torvalds 		.ctl_name	= CTL_VM,
2071da177e4SLinus Torvalds 		.procname	= "vm",
2081da177e4SLinus Torvalds 		.mode		= 0555,
2091da177e4SLinus Torvalds 		.child		= vm_table,
2101da177e4SLinus Torvalds 	},
2111da177e4SLinus Torvalds 	{
2121da177e4SLinus Torvalds 		.ctl_name	= CTL_FS,
2131da177e4SLinus Torvalds 		.procname	= "fs",
2141da177e4SLinus Torvalds 		.mode		= 0555,
2151da177e4SLinus Torvalds 		.child		= fs_table,
2161da177e4SLinus Torvalds 	},
2171da177e4SLinus Torvalds 	{
2181da177e4SLinus Torvalds 		.ctl_name	= CTL_DEBUG,
2191da177e4SLinus Torvalds 		.procname	= "debug",
2201da177e4SLinus Torvalds 		.mode		= 0555,
2211da177e4SLinus Torvalds 		.child		= debug_table,
2221da177e4SLinus Torvalds 	},
2231da177e4SLinus Torvalds 	{
2241da177e4SLinus Torvalds 		.ctl_name	= CTL_DEV,
2251da177e4SLinus Torvalds 		.procname	= "dev",
2261da177e4SLinus Torvalds 		.mode		= 0555,
2271da177e4SLinus Torvalds 		.child		= dev_table,
2281da177e4SLinus Torvalds 	},
2292be7fe07SAndrew Morton /*
2302be7fe07SAndrew Morton  * NOTE: do not add new entries to this table unless you have read
2312be7fe07SAndrew Morton  * Documentation/sysctl/ctl_unnumbered.txt
2322be7fe07SAndrew Morton  */
2331da177e4SLinus Torvalds 	{ .ctl_name = 0 }
2341da177e4SLinus Torvalds };
2351da177e4SLinus Torvalds 
23677e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG
23773c4efd2SEric Dumazet static int min_sched_granularity_ns = 100000;		/* 100 usecs */
23873c4efd2SEric Dumazet static int max_sched_granularity_ns = NSEC_PER_SEC;	/* 1 second */
23973c4efd2SEric Dumazet static int min_wakeup_granularity_ns;			/* 0 usecs */
24073c4efd2SEric Dumazet static int max_wakeup_granularity_ns = NSEC_PER_SEC;	/* 1 second */
24177e54a1fSIngo Molnar #endif
24277e54a1fSIngo Molnar 
243d8217f07SEric W. Biederman static struct ctl_table kern_table[] = {
24477e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG
24577e54a1fSIngo Molnar 	{
24677e54a1fSIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
247b2be5e96SPeter Zijlstra 		.procname	= "sched_min_granularity_ns",
248b2be5e96SPeter Zijlstra 		.data		= &sysctl_sched_min_granularity,
24977e54a1fSIngo Molnar 		.maxlen		= sizeof(unsigned int),
25077e54a1fSIngo Molnar 		.mode		= 0644,
251b2be5e96SPeter Zijlstra 		.proc_handler	= &sched_nr_latency_handler,
252b2be5e96SPeter Zijlstra 		.strategy	= &sysctl_intvec,
253b2be5e96SPeter Zijlstra 		.extra1		= &min_sched_granularity_ns,
254b2be5e96SPeter Zijlstra 		.extra2		= &max_sched_granularity_ns,
25577e54a1fSIngo Molnar 	},
25677e54a1fSIngo Molnar 	{
25777e54a1fSIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
25821805085SPeter Zijlstra 		.procname	= "sched_latency_ns",
25921805085SPeter Zijlstra 		.data		= &sysctl_sched_latency,
26021805085SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
26121805085SPeter Zijlstra 		.mode		= 0644,
262b2be5e96SPeter Zijlstra 		.proc_handler	= &sched_nr_latency_handler,
26321805085SPeter Zijlstra 		.strategy	= &sysctl_intvec,
26421805085SPeter Zijlstra 		.extra1		= &min_sched_granularity_ns,
26521805085SPeter Zijlstra 		.extra2		= &max_sched_granularity_ns,
26621805085SPeter Zijlstra 	},
26721805085SPeter Zijlstra 	{
26821805085SPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
26977e54a1fSIngo Molnar 		.procname	= "sched_wakeup_granularity_ns",
27077e54a1fSIngo Molnar 		.data		= &sysctl_sched_wakeup_granularity,
27177e54a1fSIngo Molnar 		.maxlen		= sizeof(unsigned int),
27277e54a1fSIngo Molnar 		.mode		= 0644,
27377e54a1fSIngo Molnar 		.proc_handler	= &proc_dointvec_minmax,
27477e54a1fSIngo Molnar 		.strategy	= &sysctl_intvec,
27577e54a1fSIngo Molnar 		.extra1		= &min_wakeup_granularity_ns,
27677e54a1fSIngo Molnar 		.extra2		= &max_wakeup_granularity_ns,
27777e54a1fSIngo Molnar 	},
27877e54a1fSIngo Molnar 	{
27977e54a1fSIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
2802398f2c6SPeter Zijlstra 		.procname	= "sched_shares_ratelimit",
2812398f2c6SPeter Zijlstra 		.data		= &sysctl_sched_shares_ratelimit,
2822398f2c6SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
2832398f2c6SPeter Zijlstra 		.mode		= 0644,
2842398f2c6SPeter Zijlstra 		.proc_handler	= &proc_dointvec,
2852398f2c6SPeter Zijlstra 	},
2862398f2c6SPeter Zijlstra 	{
2872398f2c6SPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
288ffda12a1SPeter Zijlstra 		.procname	= "sched_shares_thresh",
289ffda12a1SPeter Zijlstra 		.data		= &sysctl_sched_shares_thresh,
290ffda12a1SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
291ffda12a1SPeter Zijlstra 		.mode		= 0644,
292ffda12a1SPeter Zijlstra 		.proc_handler	= &proc_dointvec_minmax,
293ffda12a1SPeter Zijlstra 		.strategy	= &sysctl_intvec,
294ffda12a1SPeter Zijlstra 		.extra1		= &zero,
295ffda12a1SPeter Zijlstra 	},
296ffda12a1SPeter Zijlstra 	{
297ffda12a1SPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
29877e54a1fSIngo Molnar 		.procname	= "sched_child_runs_first",
29977e54a1fSIngo Molnar 		.data		= &sysctl_sched_child_runs_first,
30077e54a1fSIngo Molnar 		.maxlen		= sizeof(unsigned int),
30177e54a1fSIngo Molnar 		.mode		= 0644,
30277e54a1fSIngo Molnar 		.proc_handler	= &proc_dointvec,
30377e54a1fSIngo Molnar 	},
3041fc84aaaSPeter Zijlstra 	{
3051fc84aaaSPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
3061fc84aaaSPeter Zijlstra 		.procname	= "sched_features",
3071fc84aaaSPeter Zijlstra 		.data		= &sysctl_sched_features,
3081fc84aaaSPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
3091fc84aaaSPeter Zijlstra 		.mode		= 0644,
3101fc84aaaSPeter Zijlstra 		.proc_handler	= &proc_dointvec,
3111fc84aaaSPeter Zijlstra 	},
312da84d961SIngo Molnar 	{
313da84d961SIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
314da84d961SIngo Molnar 		.procname	= "sched_migration_cost",
315da84d961SIngo Molnar 		.data		= &sysctl_sched_migration_cost,
316da84d961SIngo Molnar 		.maxlen		= sizeof(unsigned int),
317da84d961SIngo Molnar 		.mode		= 0644,
318da84d961SIngo Molnar 		.proc_handler	= &proc_dointvec,
319da84d961SIngo Molnar 	},
320b82d9fddSPeter Zijlstra 	{
321b82d9fddSPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
322b82d9fddSPeter Zijlstra 		.procname	= "sched_nr_migrate",
323b82d9fddSPeter Zijlstra 		.data		= &sysctl_sched_nr_migrate,
324b82d9fddSPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
325fa85ae24SPeter Zijlstra 		.mode		= 0644,
326fa85ae24SPeter Zijlstra 		.proc_handler	= &proc_dointvec,
327fa85ae24SPeter Zijlstra 	},
3281fc84aaaSPeter Zijlstra #endif
3291799e35dSIngo Molnar 	{
3301799e35dSIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
3319f0c1e56SPeter Zijlstra 		.procname	= "sched_rt_period_us",
3329f0c1e56SPeter Zijlstra 		.data		= &sysctl_sched_rt_period,
3339f0c1e56SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
3349f0c1e56SPeter Zijlstra 		.mode		= 0644,
335d0b27fa7SPeter Zijlstra 		.proc_handler	= &sched_rt_handler,
3369f0c1e56SPeter Zijlstra 	},
3379f0c1e56SPeter Zijlstra 	{
3389f0c1e56SPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
3399f0c1e56SPeter Zijlstra 		.procname	= "sched_rt_runtime_us",
3409f0c1e56SPeter Zijlstra 		.data		= &sysctl_sched_rt_runtime,
3419f0c1e56SPeter Zijlstra 		.maxlen		= sizeof(int),
3429f0c1e56SPeter Zijlstra 		.mode		= 0644,
343d0b27fa7SPeter Zijlstra 		.proc_handler	= &sched_rt_handler,
3449f0c1e56SPeter Zijlstra 	},
3459f0c1e56SPeter Zijlstra 	{
3469f0c1e56SPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
3471799e35dSIngo Molnar 		.procname	= "sched_compat_yield",
3481799e35dSIngo Molnar 		.data		= &sysctl_sched_compat_yield,
3491799e35dSIngo Molnar 		.maxlen		= sizeof(unsigned int),
3501799e35dSIngo Molnar 		.mode		= 0644,
3511799e35dSIngo Molnar 		.proc_handler	= &proc_dointvec,
3521799e35dSIngo Molnar 	},
353f20786ffSPeter Zijlstra #ifdef CONFIG_PROVE_LOCKING
354f20786ffSPeter Zijlstra 	{
355f20786ffSPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
356f20786ffSPeter Zijlstra 		.procname	= "prove_locking",
357f20786ffSPeter Zijlstra 		.data		= &prove_locking,
358f20786ffSPeter Zijlstra 		.maxlen		= sizeof(int),
359f20786ffSPeter Zijlstra 		.mode		= 0644,
360f20786ffSPeter Zijlstra 		.proc_handler	= &proc_dointvec,
361f20786ffSPeter Zijlstra 	},
362f20786ffSPeter Zijlstra #endif
363f20786ffSPeter Zijlstra #ifdef CONFIG_LOCK_STAT
364f20786ffSPeter Zijlstra 	{
365f20786ffSPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
366f20786ffSPeter Zijlstra 		.procname	= "lock_stat",
367f20786ffSPeter Zijlstra 		.data		= &lock_stat,
368f20786ffSPeter Zijlstra 		.maxlen		= sizeof(int),
369f20786ffSPeter Zijlstra 		.mode		= 0644,
370f20786ffSPeter Zijlstra 		.proc_handler	= &proc_dointvec,
371f20786ffSPeter Zijlstra 	},
372f20786ffSPeter Zijlstra #endif
37377e54a1fSIngo Molnar 	{
3741da177e4SLinus Torvalds 		.ctl_name	= KERN_PANIC,
3751da177e4SLinus Torvalds 		.procname	= "panic",
3761da177e4SLinus Torvalds 		.data		= &panic_timeout,
3771da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
3781da177e4SLinus Torvalds 		.mode		= 0644,
3791da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3801da177e4SLinus Torvalds 	},
3811da177e4SLinus Torvalds 	{
3821da177e4SLinus Torvalds 		.ctl_name	= KERN_CORE_USES_PID,
3831da177e4SLinus Torvalds 		.procname	= "core_uses_pid",
3841da177e4SLinus Torvalds 		.data		= &core_uses_pid,
3851da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
3861da177e4SLinus Torvalds 		.mode		= 0644,
3871da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
3881da177e4SLinus Torvalds 	},
3891da177e4SLinus Torvalds 	{
3901da177e4SLinus Torvalds 		.ctl_name	= KERN_CORE_PATTERN,
3911da177e4SLinus Torvalds 		.procname	= "core_pattern",
3921da177e4SLinus Torvalds 		.data		= core_pattern,
39371ce92f3SDan Aloni 		.maxlen		= CORENAME_MAX_SIZE,
3941da177e4SLinus Torvalds 		.mode		= 0644,
3951da177e4SLinus Torvalds 		.proc_handler	= &proc_dostring,
3961da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
3971da177e4SLinus Torvalds 	},
39834f5a398STheodore Ts'o #ifdef CONFIG_PROC_SYSCTL
3991da177e4SLinus Torvalds 	{
4001da177e4SLinus Torvalds 		.procname	= "tainted",
40125ddbb18SAndi Kleen 		.maxlen 	= sizeof(long),
40234f5a398STheodore Ts'o 		.mode		= 0644,
40325ddbb18SAndi Kleen 		.proc_handler	= &proc_taint,
4041da177e4SLinus Torvalds 	},
40534f5a398STheodore Ts'o #endif
4069745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP
4079745512cSArjan van de Ven 	{
4089745512cSArjan van de Ven 		.procname	= "latencytop",
4099745512cSArjan van de Ven 		.data		= &latencytop_enabled,
4109745512cSArjan van de Ven 		.maxlen		= sizeof(int),
4119745512cSArjan van de Ven 		.mode		= 0644,
4129745512cSArjan van de Ven 		.proc_handler	= &proc_dointvec,
4139745512cSArjan van de Ven 	},
4149745512cSArjan van de Ven #endif
4151da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_INITRD
4161da177e4SLinus Torvalds 	{
4171da177e4SLinus Torvalds 		.ctl_name	= KERN_REALROOTDEV,
4181da177e4SLinus Torvalds 		.procname	= "real-root-dev",
4191da177e4SLinus Torvalds 		.data		= &real_root_dev,
4201da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
4211da177e4SLinus Torvalds 		.mode		= 0644,
4221da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4231da177e4SLinus Torvalds 	},
4241da177e4SLinus Torvalds #endif
42545807a1dSIngo Molnar 	{
42645807a1dSIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
42745807a1dSIngo Molnar 		.procname	= "print-fatal-signals",
42845807a1dSIngo Molnar 		.data		= &print_fatal_signals,
42945807a1dSIngo Molnar 		.maxlen		= sizeof(int),
43045807a1dSIngo Molnar 		.mode		= 0644,
43145807a1dSIngo Molnar 		.proc_handler	= &proc_dointvec,
43245807a1dSIngo Molnar 	},
43372c57ed5SDavid S. Miller #ifdef CONFIG_SPARC
4341da177e4SLinus Torvalds 	{
4351da177e4SLinus Torvalds 		.ctl_name	= KERN_SPARC_REBOOT,
4361da177e4SLinus Torvalds 		.procname	= "reboot-cmd",
4371da177e4SLinus Torvalds 		.data		= reboot_command,
4381da177e4SLinus Torvalds 		.maxlen		= 256,
4391da177e4SLinus Torvalds 		.mode		= 0644,
4401da177e4SLinus Torvalds 		.proc_handler	= &proc_dostring,
4411da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
4421da177e4SLinus Torvalds 	},
4431da177e4SLinus Torvalds 	{
4441da177e4SLinus Torvalds 		.ctl_name	= KERN_SPARC_STOP_A,
4451da177e4SLinus Torvalds 		.procname	= "stop-a",
4461da177e4SLinus Torvalds 		.data		= &stop_a_enabled,
4471da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4481da177e4SLinus Torvalds 		.mode		= 0644,
4491da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4501da177e4SLinus Torvalds 	},
4511da177e4SLinus Torvalds 	{
4521da177e4SLinus Torvalds 		.ctl_name	= KERN_SPARC_SCONS_PWROFF,
4531da177e4SLinus Torvalds 		.procname	= "scons-poweroff",
4541da177e4SLinus Torvalds 		.data		= &scons_pwroff,
4551da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4561da177e4SLinus Torvalds 		.mode		= 0644,
4571da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4581da177e4SLinus Torvalds 	},
4591da177e4SLinus Torvalds #endif
4600871420fSDavid S. Miller #ifdef CONFIG_SPARC64
4610871420fSDavid S. Miller 	{
4620871420fSDavid S. Miller 		.ctl_name	= CTL_UNNUMBERED,
4630871420fSDavid S. Miller 		.procname	= "tsb-ratio",
4640871420fSDavid S. Miller 		.data		= &sysctl_tsb_ratio,
4650871420fSDavid S. Miller 		.maxlen		= sizeof (int),
4660871420fSDavid S. Miller 		.mode		= 0644,
4670871420fSDavid S. Miller 		.proc_handler	= &proc_dointvec,
4680871420fSDavid S. Miller 	},
4690871420fSDavid S. Miller #endif
4701da177e4SLinus Torvalds #ifdef __hppa__
4711da177e4SLinus Torvalds 	{
4721da177e4SLinus Torvalds 		.ctl_name	= KERN_HPPA_PWRSW,
4731da177e4SLinus Torvalds 		.procname	= "soft-power",
4741da177e4SLinus Torvalds 		.data		= &pwrsw_enabled,
4751da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4761da177e4SLinus Torvalds 	 	.mode		= 0644,
4771da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4781da177e4SLinus Torvalds 	},
4791da177e4SLinus Torvalds 	{
4801da177e4SLinus Torvalds 		.ctl_name	= KERN_HPPA_UNALIGNED,
4811da177e4SLinus Torvalds 		.procname	= "unaligned-trap",
4821da177e4SLinus Torvalds 		.data		= &unaligned_enabled,
4831da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
4841da177e4SLinus Torvalds 		.mode		= 0644,
4851da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4861da177e4SLinus Torvalds 	},
4871da177e4SLinus Torvalds #endif
4881da177e4SLinus Torvalds 	{
4891da177e4SLinus Torvalds 		.ctl_name	= KERN_CTLALTDEL,
4901da177e4SLinus Torvalds 		.procname	= "ctrl-alt-del",
4911da177e4SLinus Torvalds 		.data		= &C_A_D,
4921da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
4931da177e4SLinus Torvalds 		.mode		= 0644,
4941da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
4951da177e4SLinus Torvalds 	},
496606576ceSSteven Rostedt #ifdef CONFIG_FUNCTION_TRACER
497b0fc494fSSteven Rostedt 	{
498b0fc494fSSteven Rostedt 		.ctl_name	= CTL_UNNUMBERED,
499b0fc494fSSteven Rostedt 		.procname	= "ftrace_enabled",
500b0fc494fSSteven Rostedt 		.data		= &ftrace_enabled,
501b0fc494fSSteven Rostedt 		.maxlen		= sizeof(int),
502b0fc494fSSteven Rostedt 		.mode		= 0644,
503b0fc494fSSteven Rostedt 		.proc_handler	= &ftrace_enable_sysctl,
504b0fc494fSSteven Rostedt 	},
505b0fc494fSSteven Rostedt #endif
506f38f1d2aSSteven Rostedt #ifdef CONFIG_STACK_TRACER
507f38f1d2aSSteven Rostedt 	{
508f38f1d2aSSteven Rostedt 		.ctl_name	= CTL_UNNUMBERED,
509f38f1d2aSSteven Rostedt 		.procname	= "stack_tracer_enabled",
510f38f1d2aSSteven Rostedt 		.data		= &stack_tracer_enabled,
511f38f1d2aSSteven Rostedt 		.maxlen		= sizeof(int),
512f38f1d2aSSteven Rostedt 		.mode		= 0644,
513f38f1d2aSSteven Rostedt 		.proc_handler	= &stack_trace_sysctl,
514f38f1d2aSSteven Rostedt 	},
515f38f1d2aSSteven Rostedt #endif
516944ac425SSteven Rostedt #ifdef CONFIG_TRACING
517944ac425SSteven Rostedt 	{
518944ac425SSteven Rostedt 		.ctl_name	= CTL_UNNUMBERED,
5193299b4ddSPeter Zijlstra 		.procname	= "ftrace_dump_on_oops",
520944ac425SSteven Rostedt 		.data		= &ftrace_dump_on_oops,
521944ac425SSteven Rostedt 		.maxlen		= sizeof(int),
522944ac425SSteven Rostedt 		.mode		= 0644,
523944ac425SSteven Rostedt 		.proc_handler	= &proc_dointvec,
524944ac425SSteven Rostedt 	},
525944ac425SSteven Rostedt #endif
526a1ef5adbSJohannes Berg #ifdef CONFIG_MODULES
5271da177e4SLinus Torvalds 	{
5281da177e4SLinus Torvalds 		.ctl_name	= KERN_MODPROBE,
5291da177e4SLinus Torvalds 		.procname	= "modprobe",
5301da177e4SLinus Torvalds 		.data		= &modprobe_path,
5311da177e4SLinus Torvalds 		.maxlen		= KMOD_PATH_LEN,
5321da177e4SLinus Torvalds 		.mode		= 0644,
5331da177e4SLinus Torvalds 		.proc_handler	= &proc_dostring,
5341da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
5351da177e4SLinus Torvalds 	},
5361da177e4SLinus Torvalds #endif
53757ae2508SAndrew Morton #if defined(CONFIG_HOTPLUG) && defined(CONFIG_NET)
5381da177e4SLinus Torvalds 	{
5391da177e4SLinus Torvalds 		.ctl_name	= KERN_HOTPLUG,
5401da177e4SLinus Torvalds 		.procname	= "hotplug",
541312c004dSKay Sievers 		.data		= &uevent_helper,
542312c004dSKay Sievers 		.maxlen		= UEVENT_HELPER_PATH_LEN,
5431da177e4SLinus Torvalds 		.mode		= 0644,
5441da177e4SLinus Torvalds 		.proc_handler	= &proc_dostring,
5451da177e4SLinus Torvalds 		.strategy	= &sysctl_string,
5461da177e4SLinus Torvalds 	},
5471da177e4SLinus Torvalds #endif
5481da177e4SLinus Torvalds #ifdef CONFIG_CHR_DEV_SG
5491da177e4SLinus Torvalds 	{
5501da177e4SLinus Torvalds 		.ctl_name	= KERN_SG_BIG_BUFF,
5511da177e4SLinus Torvalds 		.procname	= "sg-big-buff",
5521da177e4SLinus Torvalds 		.data		= &sg_big_buff,
5531da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5541da177e4SLinus Torvalds 		.mode		= 0444,
5551da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
5561da177e4SLinus Torvalds 	},
5571da177e4SLinus Torvalds #endif
5581da177e4SLinus Torvalds #ifdef CONFIG_BSD_PROCESS_ACCT
5591da177e4SLinus Torvalds 	{
5601da177e4SLinus Torvalds 		.ctl_name	= KERN_ACCT,
5611da177e4SLinus Torvalds 		.procname	= "acct",
5621da177e4SLinus Torvalds 		.data		= &acct_parm,
5631da177e4SLinus Torvalds 		.maxlen		= 3*sizeof(int),
5641da177e4SLinus Torvalds 		.mode		= 0644,
5651da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
5661da177e4SLinus Torvalds 	},
5671da177e4SLinus Torvalds #endif
5681da177e4SLinus Torvalds #ifdef CONFIG_MAGIC_SYSRQ
5691da177e4SLinus Torvalds 	{
5701da177e4SLinus Torvalds 		.ctl_name	= KERN_SYSRQ,
5711da177e4SLinus Torvalds 		.procname	= "sysrq",
5725d6f647fSIngo Molnar 		.data		= &__sysrq_enabled,
5731da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5741da177e4SLinus Torvalds 		.mode		= 0644,
5751da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
5761da177e4SLinus Torvalds 	},
5771da177e4SLinus Torvalds #endif
578d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL
5791da177e4SLinus Torvalds 	{
5801da177e4SLinus Torvalds 		.procname	= "cad_pid",
5819ec52099SCedric Le Goater 		.data		= NULL,
5821da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
5831da177e4SLinus Torvalds 		.mode		= 0600,
5849ec52099SCedric Le Goater 		.proc_handler	= &proc_do_cad_pid,
5851da177e4SLinus Torvalds 	},
586d6f8ff73SRandy Dunlap #endif
5871da177e4SLinus Torvalds 	{
5881da177e4SLinus Torvalds 		.ctl_name	= KERN_MAX_THREADS,
5891da177e4SLinus Torvalds 		.procname	= "threads-max",
5901da177e4SLinus Torvalds 		.data		= &max_threads,
5911da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
5921da177e4SLinus Torvalds 		.mode		= 0644,
5931da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
5941da177e4SLinus Torvalds 	},
5951da177e4SLinus Torvalds 	{
5961da177e4SLinus Torvalds 		.ctl_name	= KERN_RANDOM,
5971da177e4SLinus Torvalds 		.procname	= "random",
5981da177e4SLinus Torvalds 		.mode		= 0555,
5991da177e4SLinus Torvalds 		.child		= random_table,
6001da177e4SLinus Torvalds 	},
6011da177e4SLinus Torvalds 	{
6021da177e4SLinus Torvalds 		.ctl_name	= KERN_OVERFLOWUID,
6031da177e4SLinus Torvalds 		.procname	= "overflowuid",
6041da177e4SLinus Torvalds 		.data		= &overflowuid,
6051da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6061da177e4SLinus Torvalds 		.mode		= 0644,
6071da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
6081da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
6091da177e4SLinus Torvalds 		.extra1		= &minolduid,
6101da177e4SLinus Torvalds 		.extra2		= &maxolduid,
6111da177e4SLinus Torvalds 	},
6121da177e4SLinus Torvalds 	{
6131da177e4SLinus Torvalds 		.ctl_name	= KERN_OVERFLOWGID,
6141da177e4SLinus Torvalds 		.procname	= "overflowgid",
6151da177e4SLinus Torvalds 		.data		= &overflowgid,
6161da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6171da177e4SLinus Torvalds 		.mode		= 0644,
6181da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
6191da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
6201da177e4SLinus Torvalds 		.extra1		= &minolduid,
6211da177e4SLinus Torvalds 		.extra2		= &maxolduid,
6221da177e4SLinus Torvalds 	},
623347a8dc3SMartin Schwidefsky #ifdef CONFIG_S390
6241da177e4SLinus Torvalds #ifdef CONFIG_MATHEMU
6251da177e4SLinus Torvalds 	{
6261da177e4SLinus Torvalds 		.ctl_name	= KERN_IEEE_EMULATION_WARNINGS,
6271da177e4SLinus Torvalds 		.procname	= "ieee_emulation_warnings",
6281da177e4SLinus Torvalds 		.data		= &sysctl_ieee_emulation_warnings,
6291da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6301da177e4SLinus Torvalds 		.mode		= 0644,
6311da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6321da177e4SLinus Torvalds 	},
6331da177e4SLinus Torvalds #endif
6341da177e4SLinus Torvalds 	{
6351da177e4SLinus Torvalds 		.ctl_name	= KERN_S390_USER_DEBUG_LOGGING,
6361da177e4SLinus Torvalds 		.procname	= "userprocess_debug",
6371da177e4SLinus Torvalds 		.data		= &sysctl_userprocess_debug,
6381da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6391da177e4SLinus Torvalds 		.mode		= 0644,
6401da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6411da177e4SLinus Torvalds 	},
6421da177e4SLinus Torvalds #endif
6431da177e4SLinus Torvalds 	{
6441da177e4SLinus Torvalds 		.ctl_name	= KERN_PIDMAX,
6451da177e4SLinus Torvalds 		.procname	= "pid_max",
6461da177e4SLinus Torvalds 		.data		= &pid_max,
6471da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
6481da177e4SLinus Torvalds 		.mode		= 0644,
6491da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
6501da177e4SLinus Torvalds 		.strategy	= sysctl_intvec,
6511da177e4SLinus Torvalds 		.extra1		= &pid_max_min,
6521da177e4SLinus Torvalds 		.extra2		= &pid_max_max,
6531da177e4SLinus Torvalds 	},
6541da177e4SLinus Torvalds 	{
6551da177e4SLinus Torvalds 		.ctl_name	= KERN_PANIC_ON_OOPS,
6561da177e4SLinus Torvalds 		.procname	= "panic_on_oops",
6571da177e4SLinus Torvalds 		.data		= &panic_on_oops,
6581da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6591da177e4SLinus Torvalds 		.mode		= 0644,
6601da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6611da177e4SLinus Torvalds 	},
6627ef3d2fdSJoe Perches #if defined CONFIG_PRINTK
6637ef3d2fdSJoe Perches 	{
6647ef3d2fdSJoe Perches 		.ctl_name	= KERN_PRINTK,
6657ef3d2fdSJoe Perches 		.procname	= "printk",
6667ef3d2fdSJoe Perches 		.data		= &console_loglevel,
6677ef3d2fdSJoe Perches 		.maxlen		= 4*sizeof(int),
6687ef3d2fdSJoe Perches 		.mode		= 0644,
6697ef3d2fdSJoe Perches 		.proc_handler	= &proc_dointvec,
6707ef3d2fdSJoe Perches 	},
6711da177e4SLinus Torvalds 	{
6721da177e4SLinus Torvalds 		.ctl_name	= KERN_PRINTK_RATELIMIT,
6731da177e4SLinus Torvalds 		.procname	= "printk_ratelimit",
674717115e1SDave Young 		.data		= &printk_ratelimit_state.interval,
6751da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6761da177e4SLinus Torvalds 		.mode		= 0644,
6771da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_jiffies,
6781da177e4SLinus Torvalds 		.strategy	= &sysctl_jiffies,
6791da177e4SLinus Torvalds 	},
6801da177e4SLinus Torvalds 	{
6811da177e4SLinus Torvalds 		.ctl_name	= KERN_PRINTK_RATELIMIT_BURST,
6821da177e4SLinus Torvalds 		.procname	= "printk_ratelimit_burst",
683717115e1SDave Young 		.data		= &printk_ratelimit_state.burst,
6841da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
6851da177e4SLinus Torvalds 		.mode		= 0644,
6861da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6871da177e4SLinus Torvalds 	},
6887ef3d2fdSJoe Perches #endif
6891da177e4SLinus Torvalds 	{
6901da177e4SLinus Torvalds 		.ctl_name	= KERN_NGROUPS_MAX,
6911da177e4SLinus Torvalds 		.procname	= "ngroups_max",
6921da177e4SLinus Torvalds 		.data		= &ngroups_max,
6931da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
6941da177e4SLinus Torvalds 		.mode		= 0444,
6951da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
6961da177e4SLinus Torvalds 	},
6971da177e4SLinus Torvalds #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
6981da177e4SLinus Torvalds 	{
6991da177e4SLinus Torvalds 		.ctl_name       = KERN_UNKNOWN_NMI_PANIC,
7001da177e4SLinus Torvalds 		.procname       = "unknown_nmi_panic",
7011da177e4SLinus Torvalds 		.data           = &unknown_nmi_panic,
7021da177e4SLinus Torvalds 		.maxlen         = sizeof (int),
7031da177e4SLinus Torvalds 		.mode           = 0644,
7042fbe7b25SDon Zickus 		.proc_handler   = &proc_dointvec,
7051da177e4SLinus Torvalds 	},
706407984f1SDon Zickus 	{
707407984f1SDon Zickus 		.procname       = "nmi_watchdog",
708407984f1SDon Zickus 		.data           = &nmi_watchdog_enabled,
709407984f1SDon Zickus 		.maxlen         = sizeof (int),
710407984f1SDon Zickus 		.mode           = 0644,
711407984f1SDon Zickus 		.proc_handler   = &proc_nmi_enabled,
7121da177e4SLinus Torvalds 	},
7131da177e4SLinus Torvalds #endif
7141da177e4SLinus Torvalds #if defined(CONFIG_X86)
7151da177e4SLinus Torvalds 	{
7168da5addaSDon Zickus 		.ctl_name	= KERN_PANIC_ON_NMI,
7178da5addaSDon Zickus 		.procname	= "panic_on_unrecovered_nmi",
7188da5addaSDon Zickus 		.data		= &panic_on_unrecovered_nmi,
7198da5addaSDon Zickus 		.maxlen		= sizeof(int),
7208da5addaSDon Zickus 		.mode		= 0644,
7218da5addaSDon Zickus 		.proc_handler	= &proc_dointvec,
7228da5addaSDon Zickus 	},
7238da5addaSDon Zickus 	{
7241da177e4SLinus Torvalds 		.ctl_name	= KERN_BOOTLOADER_TYPE,
7251da177e4SLinus Torvalds 		.procname	= "bootloader_type",
7261da177e4SLinus Torvalds 		.data		= &bootloader_type,
7271da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
7281da177e4SLinus Torvalds 		.mode		= 0444,
7291da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
7301da177e4SLinus Torvalds 	},
7310741f4d2SChuck Ebbert 	{
7320741f4d2SChuck Ebbert 		.ctl_name	= CTL_UNNUMBERED,
7330741f4d2SChuck Ebbert 		.procname	= "kstack_depth_to_print",
7340741f4d2SChuck Ebbert 		.data		= &kstack_depth_to_print,
7350741f4d2SChuck Ebbert 		.maxlen		= sizeof(int),
7360741f4d2SChuck Ebbert 		.mode		= 0644,
7370741f4d2SChuck Ebbert 		.proc_handler	= &proc_dointvec,
7380741f4d2SChuck Ebbert 	},
7396e7c4025SIngo Molnar 	{
7406e7c4025SIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
7416e7c4025SIngo Molnar 		.procname	= "io_delay_type",
7426e7c4025SIngo Molnar 		.data		= &io_delay_type,
7436e7c4025SIngo Molnar 		.maxlen		= sizeof(int),
7446e7c4025SIngo Molnar 		.mode		= 0644,
7456e7c4025SIngo Molnar 		.proc_handler	= &proc_dointvec,
7466e7c4025SIngo Molnar 	},
7471da177e4SLinus Torvalds #endif
7487a9166e3SLuke Yang #if defined(CONFIG_MMU)
7491da177e4SLinus Torvalds 	{
7501da177e4SLinus Torvalds 		.ctl_name	= KERN_RANDOMIZE,
7511da177e4SLinus Torvalds 		.procname	= "randomize_va_space",
7521da177e4SLinus Torvalds 		.data		= &randomize_va_space,
7531da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
7541da177e4SLinus Torvalds 		.mode		= 0644,
7551da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
7561da177e4SLinus Torvalds 	},
7577a9166e3SLuke Yang #endif
7580152fb37SMartin Schwidefsky #if defined(CONFIG_S390) && defined(CONFIG_SMP)
759951f22d5SMartin Schwidefsky 	{
760951f22d5SMartin Schwidefsky 		.ctl_name	= KERN_SPIN_RETRY,
761951f22d5SMartin Schwidefsky 		.procname	= "spin_retry",
762951f22d5SMartin Schwidefsky 		.data		= &spin_retry,
763951f22d5SMartin Schwidefsky 		.maxlen		= sizeof (int),
764951f22d5SMartin Schwidefsky 		.mode		= 0644,
765951f22d5SMartin Schwidefsky 		.proc_handler	= &proc_dointvec,
766951f22d5SMartin Schwidefsky 	},
767951f22d5SMartin Schwidefsky #endif
768673d5b43SLen Brown #if	defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
769c255d844SPavel Machek 	{
770c255d844SPavel Machek 		.procname	= "acpi_video_flags",
77177afcf78SPavel Machek 		.data		= &acpi_realmode_flags,
772c255d844SPavel Machek 		.maxlen		= sizeof (unsigned long),
773c255d844SPavel Machek 		.mode		= 0644,
7747f99f06fSStefan Seyfried 		.proc_handler	= &proc_doulongvec_minmax,
775c255d844SPavel Machek 	},
776c255d844SPavel Machek #endif
777d2b176edSJes Sorensen #ifdef CONFIG_IA64
778d2b176edSJes Sorensen 	{
779d2b176edSJes Sorensen 		.ctl_name	= KERN_IA64_UNALIGNED,
780d2b176edSJes Sorensen 		.procname	= "ignore-unaligned-usertrap",
781d2b176edSJes Sorensen 		.data		= &no_unaligned_warning,
782d2b176edSJes Sorensen 		.maxlen		= sizeof (int),
783d2b176edSJes Sorensen 	 	.mode		= 0644,
784d2b176edSJes Sorensen 		.proc_handler	= &proc_dointvec,
785d2b176edSJes Sorensen 	},
78688fc241fSDoug Chapman 	{
78788fc241fSDoug Chapman 		.ctl_name	= CTL_UNNUMBERED,
78888fc241fSDoug Chapman 		.procname	= "unaligned-dump-stack",
78988fc241fSDoug Chapman 		.data		= &unaligned_dump_stack,
79088fc241fSDoug Chapman 		.maxlen		= sizeof (int),
79188fc241fSDoug Chapman 		.mode		= 0644,
79288fc241fSDoug Chapman 		.proc_handler	= &proc_dointvec,
79388fc241fSDoug Chapman 	},
794d2b176edSJes Sorensen #endif
795c4f3b63fSRavikiran G Thirumalai #ifdef CONFIG_DETECT_SOFTLOCKUP
796c4f3b63fSRavikiran G Thirumalai 	{
797c4f3b63fSRavikiran G Thirumalai 		.ctl_name	= CTL_UNNUMBERED,
7989c44bc03SIngo Molnar 		.procname	= "softlockup_panic",
7999c44bc03SIngo Molnar 		.data		= &softlockup_panic,
8009c44bc03SIngo Molnar 		.maxlen		= sizeof(int),
8019c44bc03SIngo Molnar 		.mode		= 0644,
8024dca10a9SHiroshi Shimamoto 		.proc_handler	= &proc_dointvec_minmax,
8039c44bc03SIngo Molnar 		.strategy	= &sysctl_intvec,
8049c44bc03SIngo Molnar 		.extra1		= &zero,
8059c44bc03SIngo Molnar 		.extra2		= &one,
8069c44bc03SIngo Molnar 	},
8079c44bc03SIngo Molnar 	{
8089c44bc03SIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
809c4f3b63fSRavikiran G Thirumalai 		.procname	= "softlockup_thresh",
810c4f3b63fSRavikiran G Thirumalai 		.data		= &softlockup_thresh,
8119383d967SDimitri Sivanich 		.maxlen		= sizeof(int),
812c4f3b63fSRavikiran G Thirumalai 		.mode		= 0644,
813baf48f65SMandeep Singh Baines 		.proc_handler	= &proc_dosoftlockup_thresh,
814c4f3b63fSRavikiran G Thirumalai 		.strategy	= &sysctl_intvec,
8159383d967SDimitri Sivanich 		.extra1		= &neg_one,
816c4f3b63fSRavikiran G Thirumalai 		.extra2		= &sixty,
817c4f3b63fSRavikiran G Thirumalai 	},
818e162b39aSMandeep Singh Baines #endif
819e162b39aSMandeep Singh Baines #ifdef CONFIG_DETECT_HUNG_TASK
820e162b39aSMandeep Singh Baines 	{
821e162b39aSMandeep Singh Baines 		.ctl_name	= CTL_UNNUMBERED,
822e162b39aSMandeep Singh Baines 		.procname	= "hung_task_panic",
823e162b39aSMandeep Singh Baines 		.data		= &sysctl_hung_task_panic,
824e162b39aSMandeep Singh Baines 		.maxlen		= sizeof(int),
825e162b39aSMandeep Singh Baines 		.mode		= 0644,
826e162b39aSMandeep Singh Baines 		.proc_handler	= &proc_dointvec_minmax,
827e162b39aSMandeep Singh Baines 		.strategy	= &sysctl_intvec,
828e162b39aSMandeep Singh Baines 		.extra1		= &zero,
829e162b39aSMandeep Singh Baines 		.extra2		= &one,
830e162b39aSMandeep Singh Baines 	},
83182a1fcb9SIngo Molnar 	{
83282a1fcb9SIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
83382a1fcb9SIngo Molnar 		.procname	= "hung_task_check_count",
83482a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_check_count,
83590739081SIngo Molnar 		.maxlen		= sizeof(unsigned long),
83682a1fcb9SIngo Molnar 		.mode		= 0644,
83790739081SIngo Molnar 		.proc_handler	= &proc_doulongvec_minmax,
83882a1fcb9SIngo Molnar 		.strategy	= &sysctl_intvec,
83982a1fcb9SIngo Molnar 	},
84082a1fcb9SIngo Molnar 	{
84182a1fcb9SIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
84282a1fcb9SIngo Molnar 		.procname	= "hung_task_timeout_secs",
84382a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_timeout_secs,
84490739081SIngo Molnar 		.maxlen		= sizeof(unsigned long),
84582a1fcb9SIngo Molnar 		.mode		= 0644,
846e162b39aSMandeep Singh Baines 		.proc_handler	= &proc_dohung_task_timeout_secs,
84782a1fcb9SIngo Molnar 		.strategy	= &sysctl_intvec,
84882a1fcb9SIngo Molnar 	},
84982a1fcb9SIngo Molnar 	{
85082a1fcb9SIngo Molnar 		.ctl_name	= CTL_UNNUMBERED,
85182a1fcb9SIngo Molnar 		.procname	= "hung_task_warnings",
85282a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_warnings,
85390739081SIngo Molnar 		.maxlen		= sizeof(unsigned long),
85482a1fcb9SIngo Molnar 		.mode		= 0644,
85590739081SIngo Molnar 		.proc_handler	= &proc_doulongvec_minmax,
85682a1fcb9SIngo Molnar 		.strategy	= &sysctl_intvec,
85782a1fcb9SIngo Molnar 	},
858c4f3b63fSRavikiran G Thirumalai #endif
859bebfa101SAndi Kleen #ifdef CONFIG_COMPAT
860bebfa101SAndi Kleen 	{
861bebfa101SAndi Kleen 		.ctl_name	= KERN_COMPAT_LOG,
862bebfa101SAndi Kleen 		.procname	= "compat-log",
863bebfa101SAndi Kleen 		.data		= &compat_log,
864bebfa101SAndi Kleen 		.maxlen		= sizeof (int),
865bebfa101SAndi Kleen 	 	.mode		= 0644,
866bebfa101SAndi Kleen 		.proc_handler	= &proc_dointvec,
867bebfa101SAndi Kleen 	},
868bebfa101SAndi Kleen #endif
86923f78d4aSIngo Molnar #ifdef CONFIG_RT_MUTEXES
87023f78d4aSIngo Molnar 	{
87123f78d4aSIngo Molnar 		.ctl_name	= KERN_MAX_LOCK_DEPTH,
87223f78d4aSIngo Molnar 		.procname	= "max_lock_depth",
87323f78d4aSIngo Molnar 		.data		= &max_lock_depth,
87423f78d4aSIngo Molnar 		.maxlen		= sizeof(int),
87523f78d4aSIngo Molnar 		.mode		= 0644,
87623f78d4aSIngo Molnar 		.proc_handler	= &proc_dointvec,
87723f78d4aSIngo Molnar 	},
87823f78d4aSIngo Molnar #endif
87910a0a8d4SJeremy Fitzhardinge 	{
88010a0a8d4SJeremy Fitzhardinge 		.ctl_name	= CTL_UNNUMBERED,
88110a0a8d4SJeremy Fitzhardinge 		.procname	= "poweroff_cmd",
88210a0a8d4SJeremy Fitzhardinge 		.data		= &poweroff_cmd,
88310a0a8d4SJeremy Fitzhardinge 		.maxlen		= POWEROFF_CMD_PATH_LEN,
88410a0a8d4SJeremy Fitzhardinge 		.mode		= 0644,
88510a0a8d4SJeremy Fitzhardinge 		.proc_handler	= &proc_dostring,
88610a0a8d4SJeremy Fitzhardinge 		.strategy	= &sysctl_string,
88710a0a8d4SJeremy Fitzhardinge 	},
8880b77f5bfSDavid Howells #ifdef CONFIG_KEYS
8890b77f5bfSDavid Howells 	{
8900b77f5bfSDavid Howells 		.ctl_name	= CTL_UNNUMBERED,
8910b77f5bfSDavid Howells 		.procname	= "keys",
8920b77f5bfSDavid Howells 		.mode		= 0555,
8930b77f5bfSDavid Howells 		.child		= key_sysctls,
8940b77f5bfSDavid Howells 	},
8950b77f5bfSDavid Howells #endif
89631a72bceSPaul E. McKenney #ifdef CONFIG_RCU_TORTURE_TEST
89731a72bceSPaul E. McKenney 	{
89831a72bceSPaul E. McKenney 		.ctl_name       = CTL_UNNUMBERED,
89931a72bceSPaul E. McKenney 		.procname       = "rcutorture_runnable",
90031a72bceSPaul E. McKenney 		.data           = &rcutorture_runnable,
90131a72bceSPaul E. McKenney 		.maxlen         = sizeof(int),
90231a72bceSPaul E. McKenney 		.mode           = 0644,
90331a72bceSPaul E. McKenney 		.proc_handler   = &proc_dointvec,
90431a72bceSPaul E. McKenney 	},
90531a72bceSPaul E. McKenney #endif
906af936a16SLee Schermerhorn #ifdef CONFIG_UNEVICTABLE_LRU
907af936a16SLee Schermerhorn 	{
908af936a16SLee Schermerhorn 		.ctl_name	= CTL_UNNUMBERED,
909af936a16SLee Schermerhorn 		.procname	= "scan_unevictable_pages",
910af936a16SLee Schermerhorn 		.data		= &scan_unevictable_pages,
911af936a16SLee Schermerhorn 		.maxlen		= sizeof(scan_unevictable_pages),
912af936a16SLee Schermerhorn 		.mode		= 0644,
913af936a16SLee Schermerhorn 		.proc_handler	= &scan_unevictable_handler,
914af936a16SLee Schermerhorn 	},
915af936a16SLee Schermerhorn #endif
91612e22c5eSDavid Howells #ifdef CONFIG_SLOW_WORK
91712e22c5eSDavid Howells 	{
91812e22c5eSDavid Howells 		.ctl_name	= CTL_UNNUMBERED,
91912e22c5eSDavid Howells 		.procname	= "slow-work",
92012e22c5eSDavid Howells 		.mode		= 0555,
92112e22c5eSDavid Howells 		.child		= slow_work_sysctls,
92212e22c5eSDavid Howells 	},
92312e22c5eSDavid Howells #endif
924*1ccd1549SPeter Zijlstra #ifdef CONFIG_PERF_COUNTERS
925*1ccd1549SPeter Zijlstra 	{
926*1ccd1549SPeter Zijlstra 		.ctl_name	= CTL_UNNUMBERED,
927*1ccd1549SPeter Zijlstra 		.procname	= "perf_counter_privileged",
928*1ccd1549SPeter Zijlstra 		.data		= &sysctl_perf_counter_priv,
929*1ccd1549SPeter Zijlstra 		.maxlen		= sizeof(sysctl_perf_counter_priv),
930*1ccd1549SPeter Zijlstra 		.mode		= 0644,
931*1ccd1549SPeter Zijlstra 		.proc_handler	= &proc_dointvec,
932*1ccd1549SPeter Zijlstra 	},
933*1ccd1549SPeter Zijlstra #endif
934ed2c12f3SAndrew Morton /*
935ed2c12f3SAndrew Morton  * NOTE: do not add new entries to this table unless you have read
936ed2c12f3SAndrew Morton  * Documentation/sysctl/ctl_unnumbered.txt
937ed2c12f3SAndrew Morton  */
9381da177e4SLinus Torvalds 	{ .ctl_name = 0 }
9391da177e4SLinus Torvalds };
9401da177e4SLinus Torvalds 
941d8217f07SEric W. Biederman static struct ctl_table vm_table[] = {
9421da177e4SLinus Torvalds 	{
9431da177e4SLinus Torvalds 		.ctl_name	= VM_OVERCOMMIT_MEMORY,
9441da177e4SLinus Torvalds 		.procname	= "overcommit_memory",
9451da177e4SLinus Torvalds 		.data		= &sysctl_overcommit_memory,
9461da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_overcommit_memory),
9471da177e4SLinus Torvalds 		.mode		= 0644,
9481da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
9491da177e4SLinus Torvalds 	},
9501da177e4SLinus Torvalds 	{
951fadd8fbdSKAMEZAWA Hiroyuki 		.ctl_name	= VM_PANIC_ON_OOM,
952fadd8fbdSKAMEZAWA Hiroyuki 		.procname	= "panic_on_oom",
953fadd8fbdSKAMEZAWA Hiroyuki 		.data		= &sysctl_panic_on_oom,
954fadd8fbdSKAMEZAWA Hiroyuki 		.maxlen		= sizeof(sysctl_panic_on_oom),
955fadd8fbdSKAMEZAWA Hiroyuki 		.mode		= 0644,
956fadd8fbdSKAMEZAWA Hiroyuki 		.proc_handler	= &proc_dointvec,
957fadd8fbdSKAMEZAWA Hiroyuki 	},
958fadd8fbdSKAMEZAWA Hiroyuki 	{
959fe071d7eSDavid Rientjes 		.ctl_name	= CTL_UNNUMBERED,
960fe071d7eSDavid Rientjes 		.procname	= "oom_kill_allocating_task",
961fe071d7eSDavid Rientjes 		.data		= &sysctl_oom_kill_allocating_task,
962fe071d7eSDavid Rientjes 		.maxlen		= sizeof(sysctl_oom_kill_allocating_task),
963fe071d7eSDavid Rientjes 		.mode		= 0644,
964fe071d7eSDavid Rientjes 		.proc_handler	= &proc_dointvec,
965fe071d7eSDavid Rientjes 	},
966fe071d7eSDavid Rientjes 	{
967fef1bdd6SDavid Rientjes 		.ctl_name	= CTL_UNNUMBERED,
968fef1bdd6SDavid Rientjes 		.procname	= "oom_dump_tasks",
969fef1bdd6SDavid Rientjes 		.data		= &sysctl_oom_dump_tasks,
970fef1bdd6SDavid Rientjes 		.maxlen		= sizeof(sysctl_oom_dump_tasks),
971fef1bdd6SDavid Rientjes 		.mode		= 0644,
972fef1bdd6SDavid Rientjes 		.proc_handler	= &proc_dointvec,
973fef1bdd6SDavid Rientjes 	},
974fef1bdd6SDavid Rientjes 	{
9751da177e4SLinus Torvalds 		.ctl_name	= VM_OVERCOMMIT_RATIO,
9761da177e4SLinus Torvalds 		.procname	= "overcommit_ratio",
9771da177e4SLinus Torvalds 		.data		= &sysctl_overcommit_ratio,
9781da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_overcommit_ratio),
9791da177e4SLinus Torvalds 		.mode		= 0644,
9801da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
9811da177e4SLinus Torvalds 	},
9821da177e4SLinus Torvalds 	{
9831da177e4SLinus Torvalds 		.ctl_name	= VM_PAGE_CLUSTER,
9841da177e4SLinus Torvalds 		.procname	= "page-cluster",
9851da177e4SLinus Torvalds 		.data		= &page_cluster,
9861da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
9871da177e4SLinus Torvalds 		.mode		= 0644,
9881da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
9891da177e4SLinus Torvalds 	},
9901da177e4SLinus Torvalds 	{
9911da177e4SLinus Torvalds 		.ctl_name	= VM_DIRTY_BACKGROUND,
9921da177e4SLinus Torvalds 		.procname	= "dirty_background_ratio",
9931da177e4SLinus Torvalds 		.data		= &dirty_background_ratio,
9941da177e4SLinus Torvalds 		.maxlen		= sizeof(dirty_background_ratio),
9951da177e4SLinus Torvalds 		.mode		= 0644,
9962da02997SDavid Rientjes 		.proc_handler	= &dirty_background_ratio_handler,
9971da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
9981da177e4SLinus Torvalds 		.extra1		= &zero,
9991da177e4SLinus Torvalds 		.extra2		= &one_hundred,
10001da177e4SLinus Torvalds 	},
10011da177e4SLinus Torvalds 	{
10022da02997SDavid Rientjes 		.ctl_name	= CTL_UNNUMBERED,
10032da02997SDavid Rientjes 		.procname	= "dirty_background_bytes",
10042da02997SDavid Rientjes 		.data		= &dirty_background_bytes,
10052da02997SDavid Rientjes 		.maxlen		= sizeof(dirty_background_bytes),
10062da02997SDavid Rientjes 		.mode		= 0644,
10072da02997SDavid Rientjes 		.proc_handler	= &dirty_background_bytes_handler,
10082da02997SDavid Rientjes 		.strategy	= &sysctl_intvec,
1009fc3501d4SSven Wegener 		.extra1		= &one_ul,
10102da02997SDavid Rientjes 	},
10112da02997SDavid Rientjes 	{
10121da177e4SLinus Torvalds 		.ctl_name	= VM_DIRTY_RATIO,
10131da177e4SLinus Torvalds 		.procname	= "dirty_ratio",
10141da177e4SLinus Torvalds 		.data		= &vm_dirty_ratio,
10151da177e4SLinus Torvalds 		.maxlen		= sizeof(vm_dirty_ratio),
10161da177e4SLinus Torvalds 		.mode		= 0644,
101704fbfdc1SPeter Zijlstra 		.proc_handler	= &dirty_ratio_handler,
10181da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
10191da177e4SLinus Torvalds 		.extra1		= &zero,
10201da177e4SLinus Torvalds 		.extra2		= &one_hundred,
10211da177e4SLinus Torvalds 	},
10221da177e4SLinus Torvalds 	{
10232da02997SDavid Rientjes 		.ctl_name	= CTL_UNNUMBERED,
10242da02997SDavid Rientjes 		.procname	= "dirty_bytes",
10252da02997SDavid Rientjes 		.data		= &vm_dirty_bytes,
10262da02997SDavid Rientjes 		.maxlen		= sizeof(vm_dirty_bytes),
10272da02997SDavid Rientjes 		.mode		= 0644,
10282da02997SDavid Rientjes 		.proc_handler	= &dirty_bytes_handler,
10292da02997SDavid Rientjes 		.strategy	= &sysctl_intvec,
1030fc3501d4SSven Wegener 		.extra1		= &one_ul,
10312da02997SDavid Rientjes 	},
10322da02997SDavid Rientjes 	{
10331da177e4SLinus Torvalds 		.procname	= "dirty_writeback_centisecs",
1034f6ef9438SBart Samwel 		.data		= &dirty_writeback_interval,
1035f6ef9438SBart Samwel 		.maxlen		= sizeof(dirty_writeback_interval),
10361da177e4SLinus Torvalds 		.mode		= 0644,
10371da177e4SLinus Torvalds 		.proc_handler	= &dirty_writeback_centisecs_handler,
10381da177e4SLinus Torvalds 	},
10391da177e4SLinus Torvalds 	{
10401da177e4SLinus Torvalds 		.procname	= "dirty_expire_centisecs",
1041f6ef9438SBart Samwel 		.data		= &dirty_expire_interval,
1042f6ef9438SBart Samwel 		.maxlen		= sizeof(dirty_expire_interval),
10431da177e4SLinus Torvalds 		.mode		= 0644,
1044704503d8SAlexey Dobriyan 		.proc_handler	= &proc_dointvec,
10451da177e4SLinus Torvalds 	},
10461da177e4SLinus Torvalds 	{
10471da177e4SLinus Torvalds 		.ctl_name	= VM_NR_PDFLUSH_THREADS,
10481da177e4SLinus Torvalds 		.procname	= "nr_pdflush_threads",
10491da177e4SLinus Torvalds 		.data		= &nr_pdflush_threads,
10501da177e4SLinus Torvalds 		.maxlen		= sizeof nr_pdflush_threads,
10511da177e4SLinus Torvalds 		.mode		= 0444 /* read-only*/,
10521da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
10531da177e4SLinus Torvalds 	},
10541da177e4SLinus Torvalds 	{
1055fafd688eSPeter W Morreale 		.ctl_name	= CTL_UNNUMBERED,
1056fafd688eSPeter W Morreale 		.procname	= "nr_pdflush_threads_min",
1057fafd688eSPeter W Morreale 		.data		= &nr_pdflush_threads_min,
1058fafd688eSPeter W Morreale 		.maxlen		= sizeof nr_pdflush_threads_min,
1059fafd688eSPeter W Morreale 		.mode		= 0644 /* read-write */,
1060fafd688eSPeter W Morreale 		.proc_handler	= &proc_dointvec_minmax,
1061fafd688eSPeter W Morreale 		.strategy	= &sysctl_intvec,
1062fafd688eSPeter W Morreale 		.extra1		= &one,
1063fafd688eSPeter W Morreale 		.extra2		= &nr_pdflush_threads_max,
1064fafd688eSPeter W Morreale 	},
1065fafd688eSPeter W Morreale 	{
1066fafd688eSPeter W Morreale 		.ctl_name	= CTL_UNNUMBERED,
1067fafd688eSPeter W Morreale 		.procname	= "nr_pdflush_threads_max",
1068fafd688eSPeter W Morreale 		.data		= &nr_pdflush_threads_max,
1069fafd688eSPeter W Morreale 		.maxlen		= sizeof nr_pdflush_threads_max,
1070fafd688eSPeter W Morreale 		.mode		= 0644 /* read-write */,
1071fafd688eSPeter W Morreale 		.proc_handler	= &proc_dointvec_minmax,
1072fafd688eSPeter W Morreale 		.strategy	= &sysctl_intvec,
1073fafd688eSPeter W Morreale 		.extra1		= &nr_pdflush_threads_min,
1074fafd688eSPeter W Morreale 		.extra2		= &one_thousand,
1075fafd688eSPeter W Morreale 	},
1076fafd688eSPeter W Morreale 	{
10771da177e4SLinus Torvalds 		.ctl_name	= VM_SWAPPINESS,
10781da177e4SLinus Torvalds 		.procname	= "swappiness",
10791da177e4SLinus Torvalds 		.data		= &vm_swappiness,
10801da177e4SLinus Torvalds 		.maxlen		= sizeof(vm_swappiness),
10811da177e4SLinus Torvalds 		.mode		= 0644,
10821da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
10831da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
10841da177e4SLinus Torvalds 		.extra1		= &zero,
10851da177e4SLinus Torvalds 		.extra2		= &one_hundred,
10861da177e4SLinus Torvalds 	},
10871da177e4SLinus Torvalds #ifdef CONFIG_HUGETLB_PAGE
10881da177e4SLinus Torvalds 	 {
10891da177e4SLinus Torvalds 		.procname	= "nr_hugepages",
1090e5ff2159SAndi Kleen 		.data		= NULL,
10911da177e4SLinus Torvalds 		.maxlen		= sizeof(unsigned long),
10921da177e4SLinus Torvalds 		.mode		= 0644,
10931da177e4SLinus Torvalds 		.proc_handler	= &hugetlb_sysctl_handler,
10941da177e4SLinus Torvalds 		.extra1		= (void *)&hugetlb_zero,
10951da177e4SLinus Torvalds 		.extra2		= (void *)&hugetlb_infinity,
10961da177e4SLinus Torvalds 	 },
10971da177e4SLinus Torvalds 	 {
10981da177e4SLinus Torvalds 		.ctl_name	= VM_HUGETLB_GROUP,
10991da177e4SLinus Torvalds 		.procname	= "hugetlb_shm_group",
11001da177e4SLinus Torvalds 		.data		= &sysctl_hugetlb_shm_group,
11011da177e4SLinus Torvalds 		.maxlen		= sizeof(gid_t),
11021da177e4SLinus Torvalds 		.mode		= 0644,
11031da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
11041da177e4SLinus Torvalds 	 },
1105396faf03SMel Gorman 	 {
1106396faf03SMel Gorman 		.ctl_name	= CTL_UNNUMBERED,
1107396faf03SMel Gorman 		.procname	= "hugepages_treat_as_movable",
1108396faf03SMel Gorman 		.data		= &hugepages_treat_as_movable,
1109396faf03SMel Gorman 		.maxlen		= sizeof(int),
1110396faf03SMel Gorman 		.mode		= 0644,
1111396faf03SMel Gorman 		.proc_handler	= &hugetlb_treat_movable_handler,
1112396faf03SMel Gorman 	},
111354f9f80dSAdam Litke 	{
111454f9f80dSAdam Litke 		.ctl_name	= CTL_UNNUMBERED,
1115d1c3fb1fSNishanth Aravamudan 		.procname	= "nr_overcommit_hugepages",
1116e5ff2159SAndi Kleen 		.data		= NULL,
1117e5ff2159SAndi Kleen 		.maxlen		= sizeof(unsigned long),
1118d1c3fb1fSNishanth Aravamudan 		.mode		= 0644,
1119a3d0c6aaSNishanth Aravamudan 		.proc_handler	= &hugetlb_overcommit_handler,
1120e5ff2159SAndi Kleen 		.extra1		= (void *)&hugetlb_zero,
1121e5ff2159SAndi Kleen 		.extra2		= (void *)&hugetlb_infinity,
1122d1c3fb1fSNishanth Aravamudan 	},
11231da177e4SLinus Torvalds #endif
11241da177e4SLinus Torvalds 	{
11251da177e4SLinus Torvalds 		.ctl_name	= VM_LOWMEM_RESERVE_RATIO,
11261da177e4SLinus Torvalds 		.procname	= "lowmem_reserve_ratio",
11271da177e4SLinus Torvalds 		.data		= &sysctl_lowmem_reserve_ratio,
11281da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
11291da177e4SLinus Torvalds 		.mode		= 0644,
11301da177e4SLinus Torvalds 		.proc_handler	= &lowmem_reserve_ratio_sysctl_handler,
11311da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
11321da177e4SLinus Torvalds 	},
11331da177e4SLinus Torvalds 	{
11349d0243bcSAndrew Morton 		.ctl_name	= VM_DROP_PAGECACHE,
11359d0243bcSAndrew Morton 		.procname	= "drop_caches",
11369d0243bcSAndrew Morton 		.data		= &sysctl_drop_caches,
11379d0243bcSAndrew Morton 		.maxlen		= sizeof(int),
11389d0243bcSAndrew Morton 		.mode		= 0644,
11399d0243bcSAndrew Morton 		.proc_handler	= drop_caches_sysctl_handler,
11409d0243bcSAndrew Morton 		.strategy	= &sysctl_intvec,
11419d0243bcSAndrew Morton 	},
11429d0243bcSAndrew Morton 	{
11431da177e4SLinus Torvalds 		.ctl_name	= VM_MIN_FREE_KBYTES,
11441da177e4SLinus Torvalds 		.procname	= "min_free_kbytes",
11451da177e4SLinus Torvalds 		.data		= &min_free_kbytes,
11461da177e4SLinus Torvalds 		.maxlen		= sizeof(min_free_kbytes),
11471da177e4SLinus Torvalds 		.mode		= 0644,
11481da177e4SLinus Torvalds 		.proc_handler	= &min_free_kbytes_sysctl_handler,
11491da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
11501da177e4SLinus Torvalds 		.extra1		= &zero,
11511da177e4SLinus Torvalds 	},
11528ad4b1fbSRohit Seth 	{
11538ad4b1fbSRohit Seth 		.ctl_name	= VM_PERCPU_PAGELIST_FRACTION,
11548ad4b1fbSRohit Seth 		.procname	= "percpu_pagelist_fraction",
11558ad4b1fbSRohit Seth 		.data		= &percpu_pagelist_fraction,
11568ad4b1fbSRohit Seth 		.maxlen		= sizeof(percpu_pagelist_fraction),
11578ad4b1fbSRohit Seth 		.mode		= 0644,
11588ad4b1fbSRohit Seth 		.proc_handler	= &percpu_pagelist_fraction_sysctl_handler,
11598ad4b1fbSRohit Seth 		.strategy	= &sysctl_intvec,
11608ad4b1fbSRohit Seth 		.extra1		= &min_percpu_pagelist_fract,
11618ad4b1fbSRohit Seth 	},
11621da177e4SLinus Torvalds #ifdef CONFIG_MMU
11631da177e4SLinus Torvalds 	{
11641da177e4SLinus Torvalds 		.ctl_name	= VM_MAX_MAP_COUNT,
11651da177e4SLinus Torvalds 		.procname	= "max_map_count",
11661da177e4SLinus Torvalds 		.data		= &sysctl_max_map_count,
11671da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_max_map_count),
11681da177e4SLinus Torvalds 		.mode		= 0644,
11691da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec
11701da177e4SLinus Torvalds 	},
1171dd8632a1SPaul Mundt #else
1172dd8632a1SPaul Mundt 	{
1173dd8632a1SPaul Mundt 		.ctl_name	= CTL_UNNUMBERED,
1174dd8632a1SPaul Mundt 		.procname	= "nr_trim_pages",
1175dd8632a1SPaul Mundt 		.data		= &sysctl_nr_trim_pages,
1176dd8632a1SPaul Mundt 		.maxlen		= sizeof(sysctl_nr_trim_pages),
1177dd8632a1SPaul Mundt 		.mode		= 0644,
1178dd8632a1SPaul Mundt 		.proc_handler	= &proc_dointvec_minmax,
1179dd8632a1SPaul Mundt 		.strategy	= &sysctl_intvec,
1180dd8632a1SPaul Mundt 		.extra1		= &zero,
1181dd8632a1SPaul Mundt 	},
11821da177e4SLinus Torvalds #endif
11831da177e4SLinus Torvalds 	{
11841da177e4SLinus Torvalds 		.ctl_name	= VM_LAPTOP_MODE,
11851da177e4SLinus Torvalds 		.procname	= "laptop_mode",
11861da177e4SLinus Torvalds 		.data		= &laptop_mode,
11871da177e4SLinus Torvalds 		.maxlen		= sizeof(laptop_mode),
11881da177e4SLinus Torvalds 		.mode		= 0644,
1189ed5b43f1SBart Samwel 		.proc_handler	= &proc_dointvec_jiffies,
1190ed5b43f1SBart Samwel 		.strategy	= &sysctl_jiffies,
11911da177e4SLinus Torvalds 	},
11921da177e4SLinus Torvalds 	{
11931da177e4SLinus Torvalds 		.ctl_name	= VM_BLOCK_DUMP,
11941da177e4SLinus Torvalds 		.procname	= "block_dump",
11951da177e4SLinus Torvalds 		.data		= &block_dump,
11961da177e4SLinus Torvalds 		.maxlen		= sizeof(block_dump),
11971da177e4SLinus Torvalds 		.mode		= 0644,
11981da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
11991da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
12001da177e4SLinus Torvalds 		.extra1		= &zero,
12011da177e4SLinus Torvalds 	},
12021da177e4SLinus Torvalds 	{
12031da177e4SLinus Torvalds 		.ctl_name	= VM_VFS_CACHE_PRESSURE,
12041da177e4SLinus Torvalds 		.procname	= "vfs_cache_pressure",
12051da177e4SLinus Torvalds 		.data		= &sysctl_vfs_cache_pressure,
12061da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
12071da177e4SLinus Torvalds 		.mode		= 0644,
12081da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
12091da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
12101da177e4SLinus Torvalds 		.extra1		= &zero,
12111da177e4SLinus Torvalds 	},
12121da177e4SLinus Torvalds #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
12131da177e4SLinus Torvalds 	{
12141da177e4SLinus Torvalds 		.ctl_name	= VM_LEGACY_VA_LAYOUT,
12151da177e4SLinus Torvalds 		.procname	= "legacy_va_layout",
12161da177e4SLinus Torvalds 		.data		= &sysctl_legacy_va_layout,
12171da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_legacy_va_layout),
12181da177e4SLinus Torvalds 		.mode		= 0644,
12191da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
12201da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
12211da177e4SLinus Torvalds 		.extra1		= &zero,
12221da177e4SLinus Torvalds 	},
12231da177e4SLinus Torvalds #endif
12241743660bSChristoph Lameter #ifdef CONFIG_NUMA
12251743660bSChristoph Lameter 	{
12261743660bSChristoph Lameter 		.ctl_name	= VM_ZONE_RECLAIM_MODE,
12271743660bSChristoph Lameter 		.procname	= "zone_reclaim_mode",
12281743660bSChristoph Lameter 		.data		= &zone_reclaim_mode,
12291743660bSChristoph Lameter 		.maxlen		= sizeof(zone_reclaim_mode),
12301743660bSChristoph Lameter 		.mode		= 0644,
12311743660bSChristoph Lameter 		.proc_handler	= &proc_dointvec,
1232c84db23cSChristoph Lameter 		.strategy	= &sysctl_intvec,
1233c84db23cSChristoph Lameter 		.extra1		= &zero,
12341743660bSChristoph Lameter 	},
12359614634fSChristoph Lameter 	{
12369614634fSChristoph Lameter 		.ctl_name	= VM_MIN_UNMAPPED,
12379614634fSChristoph Lameter 		.procname	= "min_unmapped_ratio",
12389614634fSChristoph Lameter 		.data		= &sysctl_min_unmapped_ratio,
12399614634fSChristoph Lameter 		.maxlen		= sizeof(sysctl_min_unmapped_ratio),
12409614634fSChristoph Lameter 		.mode		= 0644,
12419614634fSChristoph Lameter 		.proc_handler	= &sysctl_min_unmapped_ratio_sysctl_handler,
12429614634fSChristoph Lameter 		.strategy	= &sysctl_intvec,
12439614634fSChristoph Lameter 		.extra1		= &zero,
12449614634fSChristoph Lameter 		.extra2		= &one_hundred,
12459614634fSChristoph Lameter 	},
12460ff38490SChristoph Lameter 	{
12470ff38490SChristoph Lameter 		.ctl_name	= VM_MIN_SLAB,
12480ff38490SChristoph Lameter 		.procname	= "min_slab_ratio",
12490ff38490SChristoph Lameter 		.data		= &sysctl_min_slab_ratio,
12500ff38490SChristoph Lameter 		.maxlen		= sizeof(sysctl_min_slab_ratio),
12510ff38490SChristoph Lameter 		.mode		= 0644,
12520ff38490SChristoph Lameter 		.proc_handler	= &sysctl_min_slab_ratio_sysctl_handler,
12530ff38490SChristoph Lameter 		.strategy	= &sysctl_intvec,
12540ff38490SChristoph Lameter 		.extra1		= &zero,
12550ff38490SChristoph Lameter 		.extra2		= &one_hundred,
12560ff38490SChristoph Lameter 	},
12571743660bSChristoph Lameter #endif
125877461ab3SChristoph Lameter #ifdef CONFIG_SMP
125977461ab3SChristoph Lameter 	{
126077461ab3SChristoph Lameter 		.ctl_name	= CTL_UNNUMBERED,
126177461ab3SChristoph Lameter 		.procname	= "stat_interval",
126277461ab3SChristoph Lameter 		.data		= &sysctl_stat_interval,
126377461ab3SChristoph Lameter 		.maxlen		= sizeof(sysctl_stat_interval),
126477461ab3SChristoph Lameter 		.mode		= 0644,
126577461ab3SChristoph Lameter 		.proc_handler	= &proc_dointvec_jiffies,
126677461ab3SChristoph Lameter 		.strategy	= &sysctl_jiffies,
126777461ab3SChristoph Lameter 	},
126877461ab3SChristoph Lameter #endif
1269ed032189SEric Paris #ifdef CONFIG_SECURITY
1270ed032189SEric Paris 	{
1271ed032189SEric Paris 		.ctl_name	= CTL_UNNUMBERED,
1272ed032189SEric Paris 		.procname	= "mmap_min_addr",
1273ed032189SEric Paris 		.data		= &mmap_min_addr,
1274ed032189SEric Paris 		.maxlen         = sizeof(unsigned long),
1275ed032189SEric Paris 		.mode		= 0644,
1276ed032189SEric Paris 		.proc_handler	= &proc_doulongvec_minmax,
1277ed032189SEric Paris 	},
12788daec965SLee Schermerhorn #endif
1279f0c0b2b8SKAMEZAWA Hiroyuki #ifdef CONFIG_NUMA
1280f0c0b2b8SKAMEZAWA Hiroyuki 	{
1281f0c0b2b8SKAMEZAWA Hiroyuki 		.ctl_name	= CTL_UNNUMBERED,
1282f0c0b2b8SKAMEZAWA Hiroyuki 		.procname	= "numa_zonelist_order",
1283f0c0b2b8SKAMEZAWA Hiroyuki 		.data		= &numa_zonelist_order,
1284f0c0b2b8SKAMEZAWA Hiroyuki 		.maxlen		= NUMA_ZONELIST_ORDER_LEN,
1285f0c0b2b8SKAMEZAWA Hiroyuki 		.mode		= 0644,
1286f0c0b2b8SKAMEZAWA Hiroyuki 		.proc_handler	= &numa_zonelist_order_handler,
1287f0c0b2b8SKAMEZAWA Hiroyuki 		.strategy	= &sysctl_string,
1288f0c0b2b8SKAMEZAWA Hiroyuki 	},
1289f0c0b2b8SKAMEZAWA Hiroyuki #endif
12902b8232ceSAl Viro #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
12915c36e657SPaul Mundt    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
1292e6e5494cSIngo Molnar 	{
1293e6e5494cSIngo Molnar 		.ctl_name	= VM_VDSO_ENABLED,
1294e6e5494cSIngo Molnar 		.procname	= "vdso_enabled",
1295e6e5494cSIngo Molnar 		.data		= &vdso_enabled,
1296e6e5494cSIngo Molnar 		.maxlen		= sizeof(vdso_enabled),
1297e6e5494cSIngo Molnar 		.mode		= 0644,
1298e6e5494cSIngo Molnar 		.proc_handler	= &proc_dointvec,
1299e6e5494cSIngo Molnar 		.strategy	= &sysctl_intvec,
1300e6e5494cSIngo Molnar 		.extra1		= &zero,
1301e6e5494cSIngo Molnar 	},
1302e6e5494cSIngo Molnar #endif
1303195cf453SBron Gondwana #ifdef CONFIG_HIGHMEM
1304195cf453SBron Gondwana 	{
1305195cf453SBron Gondwana 		.ctl_name	= CTL_UNNUMBERED,
1306195cf453SBron Gondwana 		.procname	= "highmem_is_dirtyable",
1307195cf453SBron Gondwana 		.data		= &vm_highmem_is_dirtyable,
1308195cf453SBron Gondwana 		.maxlen		= sizeof(vm_highmem_is_dirtyable),
1309195cf453SBron Gondwana 		.mode		= 0644,
1310195cf453SBron Gondwana 		.proc_handler	= &proc_dointvec_minmax,
1311195cf453SBron Gondwana 		.strategy	= &sysctl_intvec,
1312195cf453SBron Gondwana 		.extra1		= &zero,
1313195cf453SBron Gondwana 		.extra2		= &one,
1314195cf453SBron Gondwana 	},
1315195cf453SBron Gondwana #endif
13162be7fe07SAndrew Morton /*
13172be7fe07SAndrew Morton  * NOTE: do not add new entries to this table unless you have read
13182be7fe07SAndrew Morton  * Documentation/sysctl/ctl_unnumbered.txt
13192be7fe07SAndrew Morton  */
13201da177e4SLinus Torvalds 	{ .ctl_name = 0 }
13211da177e4SLinus Torvalds };
13221da177e4SLinus Torvalds 
13232abc26fcSEric W. Biederman #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
1324d8217f07SEric W. Biederman static struct ctl_table binfmt_misc_table[] = {
13252abc26fcSEric W. Biederman 	{ .ctl_name = 0 }
13262abc26fcSEric W. Biederman };
13272abc26fcSEric W. Biederman #endif
13282abc26fcSEric W. Biederman 
1329d8217f07SEric W. Biederman static struct ctl_table fs_table[] = {
13301da177e4SLinus Torvalds 	{
13311da177e4SLinus Torvalds 		.ctl_name	= FS_NRINODE,
13321da177e4SLinus Torvalds 		.procname	= "inode-nr",
13331da177e4SLinus Torvalds 		.data		= &inodes_stat,
13341da177e4SLinus Torvalds 		.maxlen		= 2*sizeof(int),
13351da177e4SLinus Torvalds 		.mode		= 0444,
13361da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
13371da177e4SLinus Torvalds 	},
13381da177e4SLinus Torvalds 	{
13391da177e4SLinus Torvalds 		.ctl_name	= FS_STATINODE,
13401da177e4SLinus Torvalds 		.procname	= "inode-state",
13411da177e4SLinus Torvalds 		.data		= &inodes_stat,
13421da177e4SLinus Torvalds 		.maxlen		= 7*sizeof(int),
13431da177e4SLinus Torvalds 		.mode		= 0444,
13441da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
13451da177e4SLinus Torvalds 	},
13461da177e4SLinus Torvalds 	{
13471da177e4SLinus Torvalds 		.procname	= "file-nr",
13481da177e4SLinus Torvalds 		.data		= &files_stat,
13491da177e4SLinus Torvalds 		.maxlen		= 3*sizeof(int),
13501da177e4SLinus Torvalds 		.mode		= 0444,
1351529bf6beSDipankar Sarma 		.proc_handler	= &proc_nr_files,
13521da177e4SLinus Torvalds 	},
13531da177e4SLinus Torvalds 	{
13541da177e4SLinus Torvalds 		.ctl_name	= FS_MAXFILE,
13551da177e4SLinus Torvalds 		.procname	= "file-max",
13561da177e4SLinus Torvalds 		.data		= &files_stat.max_files,
13571da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
13581da177e4SLinus Torvalds 		.mode		= 0644,
13591da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
13601da177e4SLinus Torvalds 	},
13611da177e4SLinus Torvalds 	{
13629cfe015aSEric Dumazet 		.ctl_name	= CTL_UNNUMBERED,
13639cfe015aSEric Dumazet 		.procname	= "nr_open",
13649cfe015aSEric Dumazet 		.data		= &sysctl_nr_open,
13659cfe015aSEric Dumazet 		.maxlen		= sizeof(int),
13669cfe015aSEric Dumazet 		.mode		= 0644,
1367eceea0b3SAl Viro 		.proc_handler	= &proc_dointvec_minmax,
1368eceea0b3SAl Viro 		.extra1		= &sysctl_nr_open_min,
1369eceea0b3SAl Viro 		.extra2		= &sysctl_nr_open_max,
13709cfe015aSEric Dumazet 	},
13719cfe015aSEric Dumazet 	{
13721da177e4SLinus Torvalds 		.ctl_name	= FS_DENTRY,
13731da177e4SLinus Torvalds 		.procname	= "dentry-state",
13741da177e4SLinus Torvalds 		.data		= &dentry_stat,
13751da177e4SLinus Torvalds 		.maxlen		= 6*sizeof(int),
13761da177e4SLinus Torvalds 		.mode		= 0444,
13771da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
13781da177e4SLinus Torvalds 	},
13791da177e4SLinus Torvalds 	{
13801da177e4SLinus Torvalds 		.ctl_name	= FS_OVERFLOWUID,
13811da177e4SLinus Torvalds 		.procname	= "overflowuid",
13821da177e4SLinus Torvalds 		.data		= &fs_overflowuid,
13831da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
13841da177e4SLinus Torvalds 		.mode		= 0644,
13851da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
13861da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
13871da177e4SLinus Torvalds 		.extra1		= &minolduid,
13881da177e4SLinus Torvalds 		.extra2		= &maxolduid,
13891da177e4SLinus Torvalds 	},
13901da177e4SLinus Torvalds 	{
13911da177e4SLinus Torvalds 		.ctl_name	= FS_OVERFLOWGID,
13921da177e4SLinus Torvalds 		.procname	= "overflowgid",
13931da177e4SLinus Torvalds 		.data		= &fs_overflowgid,
13941da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
13951da177e4SLinus Torvalds 		.mode		= 0644,
13961da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec_minmax,
13971da177e4SLinus Torvalds 		.strategy	= &sysctl_intvec,
13981da177e4SLinus Torvalds 		.extra1		= &minolduid,
13991da177e4SLinus Torvalds 		.extra2		= &maxolduid,
14001da177e4SLinus Torvalds 	},
1401bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING
14021da177e4SLinus Torvalds 	{
14031da177e4SLinus Torvalds 		.ctl_name	= FS_LEASES,
14041da177e4SLinus Torvalds 		.procname	= "leases-enable",
14051da177e4SLinus Torvalds 		.data		= &leases_enable,
14061da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
14071da177e4SLinus Torvalds 		.mode		= 0644,
14081da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
14091da177e4SLinus Torvalds 	},
1410bfcd17a6SThomas Petazzoni #endif
14111da177e4SLinus Torvalds #ifdef CONFIG_DNOTIFY
14121da177e4SLinus Torvalds 	{
14131da177e4SLinus Torvalds 		.ctl_name	= FS_DIR_NOTIFY,
14141da177e4SLinus Torvalds 		.procname	= "dir-notify-enable",
14151da177e4SLinus Torvalds 		.data		= &dir_notify_enable,
14161da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
14171da177e4SLinus Torvalds 		.mode		= 0644,
14181da177e4SLinus Torvalds 		.proc_handler	= &proc_dointvec,
14191da177e4SLinus Torvalds 	},
14201da177e4SLinus Torvalds #endif
14211da177e4SLinus Torvalds #ifdef CONFIG_MMU
1422bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING
14231da177e4SLinus Torvalds 	{
14241da177e4SLinus Torvalds 		.ctl_name	= FS_LEASE_TIME,
14251da177e4SLinus Torvalds 		.procname	= "lease-break-time",
14261da177e4SLinus Torvalds 		.data		= &lease_break_time,
14271da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
14281da177e4SLinus Torvalds 		.mode		= 0644,
14298e654fbaSMatthew Wilcox 		.proc_handler	= &proc_dointvec,
14301da177e4SLinus Torvalds 	},
1431bfcd17a6SThomas Petazzoni #endif
1432ebf3f09cSThomas Petazzoni #ifdef CONFIG_AIO
14331da177e4SLinus Torvalds 	{
14341da177e4SLinus Torvalds 		.procname	= "aio-nr",
14351da177e4SLinus Torvalds 		.data		= &aio_nr,
14361da177e4SLinus Torvalds 		.maxlen		= sizeof(aio_nr),
14371da177e4SLinus Torvalds 		.mode		= 0444,
1438d55b5fdaSZach Brown 		.proc_handler	= &proc_doulongvec_minmax,
14391da177e4SLinus Torvalds 	},
14401da177e4SLinus Torvalds 	{
14411da177e4SLinus Torvalds 		.procname	= "aio-max-nr",
14421da177e4SLinus Torvalds 		.data		= &aio_max_nr,
14431da177e4SLinus Torvalds 		.maxlen		= sizeof(aio_max_nr),
14441da177e4SLinus Torvalds 		.mode		= 0644,
1445d55b5fdaSZach Brown 		.proc_handler	= &proc_doulongvec_minmax,
14461da177e4SLinus Torvalds 	},
1447ebf3f09cSThomas Petazzoni #endif /* CONFIG_AIO */
14482d9048e2SAmy Griffis #ifdef CONFIG_INOTIFY_USER
14490399cb08SRobert Love 	{
14500399cb08SRobert Love 		.ctl_name	= FS_INOTIFY,
14510399cb08SRobert Love 		.procname	= "inotify",
14520399cb08SRobert Love 		.mode		= 0555,
14530399cb08SRobert Love 		.child		= inotify_table,
14540399cb08SRobert Love 	},
14550399cb08SRobert Love #endif
14567ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL
14577ef9964eSDavide Libenzi 	{
14587ef9964eSDavide Libenzi 		.procname	= "epoll",
14597ef9964eSDavide Libenzi 		.mode		= 0555,
14607ef9964eSDavide Libenzi 		.child		= epoll_table,
14617ef9964eSDavide Libenzi 	},
14627ef9964eSDavide Libenzi #endif
14631da177e4SLinus Torvalds #endif
1464d6e71144SAlan Cox 	{
1465d6e71144SAlan Cox 		.ctl_name	= KERN_SETUID_DUMPABLE,
1466d6e71144SAlan Cox 		.procname	= "suid_dumpable",
1467d6e71144SAlan Cox 		.data		= &suid_dumpable,
1468d6e71144SAlan Cox 		.maxlen		= sizeof(int),
1469d6e71144SAlan Cox 		.mode		= 0644,
14708e654fbaSMatthew Wilcox 		.proc_handler	= &proc_dointvec_minmax,
14718e654fbaSMatthew Wilcox 		.strategy	= &sysctl_intvec,
14728e654fbaSMatthew Wilcox 		.extra1		= &zero,
14738e654fbaSMatthew Wilcox 		.extra2		= &two,
1474d6e71144SAlan Cox 	},
14752abc26fcSEric W. Biederman #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
14762abc26fcSEric W. Biederman 	{
14772abc26fcSEric W. Biederman 		.ctl_name	= CTL_UNNUMBERED,
14782abc26fcSEric W. Biederman 		.procname	= "binfmt_misc",
14792abc26fcSEric W. Biederman 		.mode		= 0555,
14802abc26fcSEric W. Biederman 		.child		= binfmt_misc_table,
14812abc26fcSEric W. Biederman 	},
14822abc26fcSEric W. Biederman #endif
14832be7fe07SAndrew Morton /*
14842be7fe07SAndrew Morton  * NOTE: do not add new entries to this table unless you have read
14852be7fe07SAndrew Morton  * Documentation/sysctl/ctl_unnumbered.txt
14862be7fe07SAndrew Morton  */
14871da177e4SLinus Torvalds 	{ .ctl_name = 0 }
14881da177e4SLinus Torvalds };
14891da177e4SLinus Torvalds 
1490d8217f07SEric W. Biederman static struct ctl_table debug_table[] = {
1491d0c3d534SOlof Johansson #if defined(CONFIG_X86) || defined(CONFIG_PPC)
1492abd4f750SMasoud Asgharifard Sharbiani 	{
1493abd4f750SMasoud Asgharifard Sharbiani 		.ctl_name	= CTL_UNNUMBERED,
1494abd4f750SMasoud Asgharifard Sharbiani 		.procname	= "exception-trace",
1495abd4f750SMasoud Asgharifard Sharbiani 		.data		= &show_unhandled_signals,
1496abd4f750SMasoud Asgharifard Sharbiani 		.maxlen		= sizeof(int),
1497abd4f750SMasoud Asgharifard Sharbiani 		.mode		= 0644,
1498abd4f750SMasoud Asgharifard Sharbiani 		.proc_handler	= proc_dointvec
1499abd4f750SMasoud Asgharifard Sharbiani 	},
1500abd4f750SMasoud Asgharifard Sharbiani #endif
15011da177e4SLinus Torvalds 	{ .ctl_name = 0 }
15021da177e4SLinus Torvalds };
15031da177e4SLinus Torvalds 
1504d8217f07SEric W. Biederman static struct ctl_table dev_table[] = {
15051da177e4SLinus Torvalds 	{ .ctl_name = 0 }
15061da177e4SLinus Torvalds };
15071da177e4SLinus Torvalds 
1508330d57fbSAl Viro static DEFINE_SPINLOCK(sysctl_lock);
1509330d57fbSAl Viro 
1510330d57fbSAl Viro /* called under sysctl_lock */
1511330d57fbSAl Viro static int use_table(struct ctl_table_header *p)
1512330d57fbSAl Viro {
1513330d57fbSAl Viro 	if (unlikely(p->unregistering))
1514330d57fbSAl Viro 		return 0;
1515330d57fbSAl Viro 	p->used++;
1516330d57fbSAl Viro 	return 1;
1517330d57fbSAl Viro }
1518330d57fbSAl Viro 
1519330d57fbSAl Viro /* called under sysctl_lock */
1520330d57fbSAl Viro static void unuse_table(struct ctl_table_header *p)
1521330d57fbSAl Viro {
1522330d57fbSAl Viro 	if (!--p->used)
1523330d57fbSAl Viro 		if (unlikely(p->unregistering))
1524330d57fbSAl Viro 			complete(p->unregistering);
1525330d57fbSAl Viro }
1526330d57fbSAl Viro 
1527330d57fbSAl Viro /* called under sysctl_lock, will reacquire if has to wait */
1528330d57fbSAl Viro static void start_unregistering(struct ctl_table_header *p)
1529330d57fbSAl Viro {
1530330d57fbSAl Viro 	/*
1531330d57fbSAl Viro 	 * if p->used is 0, nobody will ever touch that entry again;
1532330d57fbSAl Viro 	 * we'll eliminate all paths to it before dropping sysctl_lock
1533330d57fbSAl Viro 	 */
1534330d57fbSAl Viro 	if (unlikely(p->used)) {
1535330d57fbSAl Viro 		struct completion wait;
1536330d57fbSAl Viro 		init_completion(&wait);
1537330d57fbSAl Viro 		p->unregistering = &wait;
1538330d57fbSAl Viro 		spin_unlock(&sysctl_lock);
1539330d57fbSAl Viro 		wait_for_completion(&wait);
1540330d57fbSAl Viro 		spin_lock(&sysctl_lock);
1541f7e6ced4SAl Viro 	} else {
1542f7e6ced4SAl Viro 		/* anything non-NULL; we'll never dereference it */
1543f7e6ced4SAl Viro 		p->unregistering = ERR_PTR(-EINVAL);
1544330d57fbSAl Viro 	}
1545330d57fbSAl Viro 	/*
1546330d57fbSAl Viro 	 * do not remove from the list until nobody holds it; walking the
1547330d57fbSAl Viro 	 * list in do_sysctl() relies on that.
1548330d57fbSAl Viro 	 */
1549330d57fbSAl Viro 	list_del_init(&p->ctl_entry);
1550330d57fbSAl Viro }
1551330d57fbSAl Viro 
1552f7e6ced4SAl Viro void sysctl_head_get(struct ctl_table_header *head)
1553f7e6ced4SAl Viro {
1554f7e6ced4SAl Viro 	spin_lock(&sysctl_lock);
1555f7e6ced4SAl Viro 	head->count++;
1556f7e6ced4SAl Viro 	spin_unlock(&sysctl_lock);
1557f7e6ced4SAl Viro }
1558f7e6ced4SAl Viro 
1559f7e6ced4SAl Viro void sysctl_head_put(struct ctl_table_header *head)
1560f7e6ced4SAl Viro {
1561f7e6ced4SAl Viro 	spin_lock(&sysctl_lock);
1562f7e6ced4SAl Viro 	if (!--head->count)
1563f7e6ced4SAl Viro 		kfree(head);
1564f7e6ced4SAl Viro 	spin_unlock(&sysctl_lock);
1565f7e6ced4SAl Viro }
1566f7e6ced4SAl Viro 
1567f7e6ced4SAl Viro struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *head)
1568f7e6ced4SAl Viro {
1569f7e6ced4SAl Viro 	if (!head)
1570f7e6ced4SAl Viro 		BUG();
1571f7e6ced4SAl Viro 	spin_lock(&sysctl_lock);
1572f7e6ced4SAl Viro 	if (!use_table(head))
1573f7e6ced4SAl Viro 		head = ERR_PTR(-ENOENT);
1574f7e6ced4SAl Viro 	spin_unlock(&sysctl_lock);
1575f7e6ced4SAl Viro 	return head;
1576f7e6ced4SAl Viro }
1577f7e6ced4SAl Viro 
1578805b5d5eSEric W. Biederman void sysctl_head_finish(struct ctl_table_header *head)
1579805b5d5eSEric W. Biederman {
1580805b5d5eSEric W. Biederman 	if (!head)
1581805b5d5eSEric W. Biederman 		return;
1582805b5d5eSEric W. Biederman 	spin_lock(&sysctl_lock);
1583805b5d5eSEric W. Biederman 	unuse_table(head);
1584805b5d5eSEric W. Biederman 	spin_unlock(&sysctl_lock);
1585805b5d5eSEric W. Biederman }
1586805b5d5eSEric W. Biederman 
158773455092SAl Viro static struct ctl_table_set *
158873455092SAl Viro lookup_header_set(struct ctl_table_root *root, struct nsproxy *namespaces)
158973455092SAl Viro {
159073455092SAl Viro 	struct ctl_table_set *set = &root->default_set;
159173455092SAl Viro 	if (root->lookup)
159273455092SAl Viro 		set = root->lookup(root, namespaces);
159373455092SAl Viro 	return set;
159473455092SAl Viro }
159573455092SAl Viro 
1596e51b6ba0SEric W. Biederman static struct list_head *
1597e51b6ba0SEric W. Biederman lookup_header_list(struct ctl_table_root *root, struct nsproxy *namespaces)
1598805b5d5eSEric W. Biederman {
159973455092SAl Viro 	struct ctl_table_set *set = lookup_header_set(root, namespaces);
160073455092SAl Viro 	return &set->list;
1601e51b6ba0SEric W. Biederman }
1602e51b6ba0SEric W. Biederman 
1603e51b6ba0SEric W. Biederman struct ctl_table_header *__sysctl_head_next(struct nsproxy *namespaces,
1604e51b6ba0SEric W. Biederman 					    struct ctl_table_header *prev)
1605e51b6ba0SEric W. Biederman {
1606e51b6ba0SEric W. Biederman 	struct ctl_table_root *root;
1607e51b6ba0SEric W. Biederman 	struct list_head *header_list;
1608805b5d5eSEric W. Biederman 	struct ctl_table_header *head;
1609805b5d5eSEric W. Biederman 	struct list_head *tmp;
1610e51b6ba0SEric W. Biederman 
1611805b5d5eSEric W. Biederman 	spin_lock(&sysctl_lock);
1612805b5d5eSEric W. Biederman 	if (prev) {
1613e51b6ba0SEric W. Biederman 		head = prev;
1614805b5d5eSEric W. Biederman 		tmp = &prev->ctl_entry;
1615805b5d5eSEric W. Biederman 		unuse_table(prev);
1616805b5d5eSEric W. Biederman 		goto next;
1617805b5d5eSEric W. Biederman 	}
1618805b5d5eSEric W. Biederman 	tmp = &root_table_header.ctl_entry;
1619805b5d5eSEric W. Biederman 	for (;;) {
1620805b5d5eSEric W. Biederman 		head = list_entry(tmp, struct ctl_table_header, ctl_entry);
1621805b5d5eSEric W. Biederman 
1622805b5d5eSEric W. Biederman 		if (!use_table(head))
1623805b5d5eSEric W. Biederman 			goto next;
1624805b5d5eSEric W. Biederman 		spin_unlock(&sysctl_lock);
1625805b5d5eSEric W. Biederman 		return head;
1626805b5d5eSEric W. Biederman 	next:
1627e51b6ba0SEric W. Biederman 		root = head->root;
1628805b5d5eSEric W. Biederman 		tmp = tmp->next;
1629e51b6ba0SEric W. Biederman 		header_list = lookup_header_list(root, namespaces);
1630e51b6ba0SEric W. Biederman 		if (tmp != header_list)
1631e51b6ba0SEric W. Biederman 			continue;
1632e51b6ba0SEric W. Biederman 
1633e51b6ba0SEric W. Biederman 		do {
1634e51b6ba0SEric W. Biederman 			root = list_entry(root->root_list.next,
1635e51b6ba0SEric W. Biederman 					struct ctl_table_root, root_list);
1636e51b6ba0SEric W. Biederman 			if (root == &sysctl_table_root)
1637e51b6ba0SEric W. Biederman 				goto out;
1638e51b6ba0SEric W. Biederman 			header_list = lookup_header_list(root, namespaces);
1639e51b6ba0SEric W. Biederman 		} while (list_empty(header_list));
1640e51b6ba0SEric W. Biederman 		tmp = header_list->next;
1641805b5d5eSEric W. Biederman 	}
1642e51b6ba0SEric W. Biederman out:
1643805b5d5eSEric W. Biederman 	spin_unlock(&sysctl_lock);
1644805b5d5eSEric W. Biederman 	return NULL;
1645805b5d5eSEric W. Biederman }
1646805b5d5eSEric W. Biederman 
1647e51b6ba0SEric W. Biederman struct ctl_table_header *sysctl_head_next(struct ctl_table_header *prev)
1648e51b6ba0SEric W. Biederman {
1649e51b6ba0SEric W. Biederman 	return __sysctl_head_next(current->nsproxy, prev);
1650e51b6ba0SEric W. Biederman }
1651e51b6ba0SEric W. Biederman 
1652e51b6ba0SEric W. Biederman void register_sysctl_root(struct ctl_table_root *root)
1653e51b6ba0SEric W. Biederman {
1654e51b6ba0SEric W. Biederman 	spin_lock(&sysctl_lock);
1655e51b6ba0SEric W. Biederman 	list_add_tail(&root->root_list, &sysctl_table_root.root_list);
1656e51b6ba0SEric W. Biederman 	spin_unlock(&sysctl_lock);
1657e51b6ba0SEric W. Biederman }
1658e51b6ba0SEric W. Biederman 
1659b89a8171SEric W. Biederman #ifdef CONFIG_SYSCTL_SYSCALL
16602c4c7155SPavel Emelyanov /* Perform the actual read/write of a sysctl table entry. */
1661d7321cd6SPavel Emelyanov static int do_sysctl_strategy(struct ctl_table_root *root,
1662d7321cd6SPavel Emelyanov 			struct ctl_table *table,
16632c4c7155SPavel Emelyanov 			void __user *oldval, size_t __user *oldlenp,
16642c4c7155SPavel Emelyanov 			void __user *newval, size_t newlen)
16652c4c7155SPavel Emelyanov {
16662c4c7155SPavel Emelyanov 	int op = 0, rc;
16672c4c7155SPavel Emelyanov 
16682c4c7155SPavel Emelyanov 	if (oldval)
1669e6305c43SAl Viro 		op |= MAY_READ;
16702c4c7155SPavel Emelyanov 	if (newval)
1671e6305c43SAl Viro 		op |= MAY_WRITE;
1672d7321cd6SPavel Emelyanov 	if (sysctl_perm(root, table, op))
16732c4c7155SPavel Emelyanov 		return -EPERM;
16742c4c7155SPavel Emelyanov 
16752c4c7155SPavel Emelyanov 	if (table->strategy) {
1676f221e726SAlexey Dobriyan 		rc = table->strategy(table, oldval, oldlenp, newval, newlen);
16772c4c7155SPavel Emelyanov 		if (rc < 0)
16782c4c7155SPavel Emelyanov 			return rc;
16792c4c7155SPavel Emelyanov 		if (rc > 0)
16802c4c7155SPavel Emelyanov 			return 0;
16812c4c7155SPavel Emelyanov 	}
16822c4c7155SPavel Emelyanov 
16832c4c7155SPavel Emelyanov 	/* If there is no strategy routine, or if the strategy returns
16842c4c7155SPavel Emelyanov 	 * zero, proceed with automatic r/w */
16852c4c7155SPavel Emelyanov 	if (table->data && table->maxlen) {
1686f221e726SAlexey Dobriyan 		rc = sysctl_data(table, oldval, oldlenp, newval, newlen);
16872c4c7155SPavel Emelyanov 		if (rc < 0)
16882c4c7155SPavel Emelyanov 			return rc;
16892c4c7155SPavel Emelyanov 	}
16902c4c7155SPavel Emelyanov 	return 0;
16912c4c7155SPavel Emelyanov }
16922c4c7155SPavel Emelyanov 
16932c4c7155SPavel Emelyanov static int parse_table(int __user *name, int nlen,
16942c4c7155SPavel Emelyanov 		       void __user *oldval, size_t __user *oldlenp,
16952c4c7155SPavel Emelyanov 		       void __user *newval, size_t newlen,
1696d7321cd6SPavel Emelyanov 		       struct ctl_table_root *root,
16972c4c7155SPavel Emelyanov 		       struct ctl_table *table)
16982c4c7155SPavel Emelyanov {
16992c4c7155SPavel Emelyanov 	int n;
17002c4c7155SPavel Emelyanov repeat:
17012c4c7155SPavel Emelyanov 	if (!nlen)
17022c4c7155SPavel Emelyanov 		return -ENOTDIR;
17032c4c7155SPavel Emelyanov 	if (get_user(n, name))
17042c4c7155SPavel Emelyanov 		return -EFAULT;
17052c4c7155SPavel Emelyanov 	for ( ; table->ctl_name || table->procname; table++) {
17062c4c7155SPavel Emelyanov 		if (!table->ctl_name)
17072c4c7155SPavel Emelyanov 			continue;
17082c4c7155SPavel Emelyanov 		if (n == table->ctl_name) {
17092c4c7155SPavel Emelyanov 			int error;
17102c4c7155SPavel Emelyanov 			if (table->child) {
1711e6305c43SAl Viro 				if (sysctl_perm(root, table, MAY_EXEC))
17122c4c7155SPavel Emelyanov 					return -EPERM;
17132c4c7155SPavel Emelyanov 				name++;
17142c4c7155SPavel Emelyanov 				nlen--;
17152c4c7155SPavel Emelyanov 				table = table->child;
17162c4c7155SPavel Emelyanov 				goto repeat;
17172c4c7155SPavel Emelyanov 			}
1718f221e726SAlexey Dobriyan 			error = do_sysctl_strategy(root, table,
17192c4c7155SPavel Emelyanov 						   oldval, oldlenp,
17202c4c7155SPavel Emelyanov 						   newval, newlen);
17212c4c7155SPavel Emelyanov 			return error;
17222c4c7155SPavel Emelyanov 		}
17232c4c7155SPavel Emelyanov 	}
17242c4c7155SPavel Emelyanov 	return -ENOTDIR;
17252c4c7155SPavel Emelyanov }
17262c4c7155SPavel Emelyanov 
17271da177e4SLinus Torvalds int do_sysctl(int __user *name, int nlen, void __user *oldval, size_t __user *oldlenp,
17281da177e4SLinus Torvalds 	       void __user *newval, size_t newlen)
17291da177e4SLinus Torvalds {
1730805b5d5eSEric W. Biederman 	struct ctl_table_header *head;
1731330d57fbSAl Viro 	int error = -ENOTDIR;
17321da177e4SLinus Torvalds 
17331da177e4SLinus Torvalds 	if (nlen <= 0 || nlen >= CTL_MAXNAME)
17341da177e4SLinus Torvalds 		return -ENOTDIR;
17351da177e4SLinus Torvalds 	if (oldval) {
17361da177e4SLinus Torvalds 		int old_len;
17371da177e4SLinus Torvalds 		if (!oldlenp || get_user(old_len, oldlenp))
17381da177e4SLinus Torvalds 			return -EFAULT;
17391da177e4SLinus Torvalds 	}
1740330d57fbSAl Viro 
1741805b5d5eSEric W. Biederman 	for (head = sysctl_head_next(NULL); head;
1742805b5d5eSEric W. Biederman 			head = sysctl_head_next(head)) {
1743330d57fbSAl Viro 		error = parse_table(name, nlen, oldval, oldlenp,
1744d7321cd6SPavel Emelyanov 					newval, newlen,
1745d7321cd6SPavel Emelyanov 					head->root, head->ctl_table);
1746805b5d5eSEric W. Biederman 		if (error != -ENOTDIR) {
1747805b5d5eSEric W. Biederman 			sysctl_head_finish(head);
1748330d57fbSAl Viro 			break;
1749805b5d5eSEric W. Biederman 		}
1750805b5d5eSEric W. Biederman 	}
17511da177e4SLinus Torvalds 	return error;
17521da177e4SLinus Torvalds }
17531da177e4SLinus Torvalds 
17541e7bfb21SHeiko Carstens SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
17551da177e4SLinus Torvalds {
17561da177e4SLinus Torvalds 	struct __sysctl_args tmp;
17571da177e4SLinus Torvalds 	int error;
17581da177e4SLinus Torvalds 
17591da177e4SLinus Torvalds 	if (copy_from_user(&tmp, args, sizeof(tmp)))
17601da177e4SLinus Torvalds 		return -EFAULT;
17611da177e4SLinus Torvalds 
17627058cb02SEric W. Biederman 	error = deprecated_sysctl_warning(&tmp);
17637058cb02SEric W. Biederman 	if (error)
17647058cb02SEric W. Biederman 		goto out;
17657058cb02SEric W. Biederman 
17661da177e4SLinus Torvalds 	lock_kernel();
17671da177e4SLinus Torvalds 	error = do_sysctl(tmp.name, tmp.nlen, tmp.oldval, tmp.oldlenp,
17681da177e4SLinus Torvalds 			  tmp.newval, tmp.newlen);
17691da177e4SLinus Torvalds 	unlock_kernel();
17707058cb02SEric W. Biederman out:
17711da177e4SLinus Torvalds 	return error;
17721da177e4SLinus Torvalds }
1773b89a8171SEric W. Biederman #endif /* CONFIG_SYSCTL_SYSCALL */
17741da177e4SLinus Torvalds 
17751da177e4SLinus Torvalds /*
17761ff007ebSEric W. Biederman  * sysctl_perm does NOT grant the superuser all rights automatically, because
17771da177e4SLinus Torvalds  * some sysctl variables are readonly even to root.
17781da177e4SLinus Torvalds  */
17791da177e4SLinus Torvalds 
17801da177e4SLinus Torvalds static int test_perm(int mode, int op)
17811da177e4SLinus Torvalds {
178276aac0e9SDavid Howells 	if (!current_euid())
17831da177e4SLinus Torvalds 		mode >>= 6;
17841da177e4SLinus Torvalds 	else if (in_egroup_p(0))
17851da177e4SLinus Torvalds 		mode >>= 3;
1786e6305c43SAl Viro 	if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
17871da177e4SLinus Torvalds 		return 0;
17881da177e4SLinus Torvalds 	return -EACCES;
17891da177e4SLinus Torvalds }
17901da177e4SLinus Torvalds 
1791d7321cd6SPavel Emelyanov int sysctl_perm(struct ctl_table_root *root, struct ctl_table *table, int op)
17921da177e4SLinus Torvalds {
17931da177e4SLinus Torvalds 	int error;
1794d7321cd6SPavel Emelyanov 	int mode;
1795d7321cd6SPavel Emelyanov 
1796e6305c43SAl Viro 	error = security_sysctl(table, op & (MAY_READ | MAY_WRITE | MAY_EXEC));
17971da177e4SLinus Torvalds 	if (error)
17981da177e4SLinus Torvalds 		return error;
1799d7321cd6SPavel Emelyanov 
1800d7321cd6SPavel Emelyanov 	if (root->permissions)
1801d7321cd6SPavel Emelyanov 		mode = root->permissions(root, current->nsproxy, table);
1802d7321cd6SPavel Emelyanov 	else
1803d7321cd6SPavel Emelyanov 		mode = table->mode;
1804d7321cd6SPavel Emelyanov 
1805d7321cd6SPavel Emelyanov 	return test_perm(mode, op);
18061da177e4SLinus Torvalds }
18071da177e4SLinus Torvalds 
1808d912b0ccSEric W. Biederman static void sysctl_set_parent(struct ctl_table *parent, struct ctl_table *table)
1809d912b0ccSEric W. Biederman {
1810d912b0ccSEric W. Biederman 	for (; table->ctl_name || table->procname; table++) {
1811d912b0ccSEric W. Biederman 		table->parent = parent;
1812d912b0ccSEric W. Biederman 		if (table->child)
1813d912b0ccSEric W. Biederman 			sysctl_set_parent(table, table->child);
1814d912b0ccSEric W. Biederman 	}
1815d912b0ccSEric W. Biederman }
1816d912b0ccSEric W. Biederman 
1817d912b0ccSEric W. Biederman static __init int sysctl_init(void)
1818d912b0ccSEric W. Biederman {
1819d912b0ccSEric W. Biederman 	sysctl_set_parent(NULL, root_table);
182088f458e4SHolger Schurig #ifdef CONFIG_SYSCTL_SYSCALL_CHECK
182188f458e4SHolger Schurig 	{
182288f458e4SHolger Schurig 		int err;
1823e51b6ba0SEric W. Biederman 		err = sysctl_check_table(current->nsproxy, root_table);
182488f458e4SHolger Schurig 	}
182588f458e4SHolger Schurig #endif
1826d912b0ccSEric W. Biederman 	return 0;
1827d912b0ccSEric W. Biederman }
1828d912b0ccSEric W. Biederman 
1829d912b0ccSEric W. Biederman core_initcall(sysctl_init);
1830d912b0ccSEric W. Biederman 
1831bfbcf034SAl Viro static struct ctl_table *is_branch_in(struct ctl_table *branch,
1832bfbcf034SAl Viro 				      struct ctl_table *table)
1833ae7edeccSAl Viro {
1834ae7edeccSAl Viro 	struct ctl_table *p;
1835ae7edeccSAl Viro 	const char *s = branch->procname;
1836ae7edeccSAl Viro 
1837ae7edeccSAl Viro 	/* branch should have named subdirectory as its first element */
1838ae7edeccSAl Viro 	if (!s || !branch->child)
1839bfbcf034SAl Viro 		return NULL;
1840ae7edeccSAl Viro 
1841ae7edeccSAl Viro 	/* ... and nothing else */
1842ae7edeccSAl Viro 	if (branch[1].procname || branch[1].ctl_name)
1843bfbcf034SAl Viro 		return NULL;
1844ae7edeccSAl Viro 
1845ae7edeccSAl Viro 	/* table should contain subdirectory with the same name */
1846ae7edeccSAl Viro 	for (p = table; p->procname || p->ctl_name; p++) {
1847ae7edeccSAl Viro 		if (!p->child)
1848ae7edeccSAl Viro 			continue;
1849ae7edeccSAl Viro 		if (p->procname && strcmp(p->procname, s) == 0)
1850bfbcf034SAl Viro 			return p;
1851ae7edeccSAl Viro 	}
1852bfbcf034SAl Viro 	return NULL;
1853ae7edeccSAl Viro }
1854ae7edeccSAl Viro 
1855ae7edeccSAl Viro /* see if attaching q to p would be an improvement */
1856ae7edeccSAl Viro static void try_attach(struct ctl_table_header *p, struct ctl_table_header *q)
1857ae7edeccSAl Viro {
1858ae7edeccSAl Viro 	struct ctl_table *to = p->ctl_table, *by = q->ctl_table;
1859bfbcf034SAl Viro 	struct ctl_table *next;
1860ae7edeccSAl Viro 	int is_better = 0;
1861ae7edeccSAl Viro 	int not_in_parent = !p->attached_by;
1862ae7edeccSAl Viro 
1863bfbcf034SAl Viro 	while ((next = is_branch_in(by, to)) != NULL) {
1864ae7edeccSAl Viro 		if (by == q->attached_by)
1865ae7edeccSAl Viro 			is_better = 1;
1866ae7edeccSAl Viro 		if (to == p->attached_by)
1867ae7edeccSAl Viro 			not_in_parent = 1;
1868ae7edeccSAl Viro 		by = by->child;
1869bfbcf034SAl Viro 		to = next->child;
1870ae7edeccSAl Viro 	}
1871ae7edeccSAl Viro 
1872ae7edeccSAl Viro 	if (is_better && not_in_parent) {
1873ae7edeccSAl Viro 		q->attached_by = by;
1874ae7edeccSAl Viro 		q->attached_to = to;
1875ae7edeccSAl Viro 		q->parent = p;
1876ae7edeccSAl Viro 	}
1877ae7edeccSAl Viro }
1878ae7edeccSAl Viro 
18791da177e4SLinus Torvalds /**
1880e51b6ba0SEric W. Biederman  * __register_sysctl_paths - register a sysctl hierarchy
1881e51b6ba0SEric W. Biederman  * @root: List of sysctl headers to register on
1882e51b6ba0SEric W. Biederman  * @namespaces: Data to compute which lists of sysctl entries are visible
188329e796fdSEric W. Biederman  * @path: The path to the directory the sysctl table is in.
18841da177e4SLinus Torvalds  * @table: the top-level table structure
18851da177e4SLinus Torvalds  *
18861da177e4SLinus Torvalds  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
188729e796fdSEric W. Biederman  * array. A completely 0 filled entry terminates the table.
18881da177e4SLinus Torvalds  *
1889d8217f07SEric W. Biederman  * The members of the &struct ctl_table structure are used as follows:
18901da177e4SLinus Torvalds  *
18911da177e4SLinus Torvalds  * ctl_name - This is the numeric sysctl value used by sysctl(2). The number
18921da177e4SLinus Torvalds  *            must be unique within that level of sysctl
18931da177e4SLinus Torvalds  *
18941da177e4SLinus Torvalds  * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
18951da177e4SLinus Torvalds  *            enter a sysctl file
18961da177e4SLinus Torvalds  *
18971da177e4SLinus Torvalds  * data - a pointer to data for use by proc_handler
18981da177e4SLinus Torvalds  *
18991da177e4SLinus Torvalds  * maxlen - the maximum size in bytes of the data
19001da177e4SLinus Torvalds  *
19011da177e4SLinus Torvalds  * mode - the file permissions for the /proc/sys file, and for sysctl(2)
19021da177e4SLinus Torvalds  *
19031da177e4SLinus Torvalds  * child - a pointer to the child sysctl table if this entry is a directory, or
19041da177e4SLinus Torvalds  *         %NULL.
19051da177e4SLinus Torvalds  *
19061da177e4SLinus Torvalds  * proc_handler - the text handler routine (described below)
19071da177e4SLinus Torvalds  *
19081da177e4SLinus Torvalds  * strategy - the strategy routine (described below)
19091da177e4SLinus Torvalds  *
19101da177e4SLinus Torvalds  * de - for internal use by the sysctl routines
19111da177e4SLinus Torvalds  *
19121da177e4SLinus Torvalds  * extra1, extra2 - extra pointers usable by the proc handler routines
19131da177e4SLinus Torvalds  *
19141da177e4SLinus Torvalds  * Leaf nodes in the sysctl tree will be represented by a single file
19151da177e4SLinus Torvalds  * under /proc; non-leaf nodes will be represented by directories.
19161da177e4SLinus Torvalds  *
19171da177e4SLinus Torvalds  * sysctl(2) can automatically manage read and write requests through
19181da177e4SLinus Torvalds  * the sysctl table.  The data and maxlen fields of the ctl_table
19191da177e4SLinus Torvalds  * struct enable minimal validation of the values being written to be
19201da177e4SLinus Torvalds  * performed, and the mode field allows minimal authentication.
19211da177e4SLinus Torvalds  *
19221da177e4SLinus Torvalds  * More sophisticated management can be enabled by the provision of a
19231da177e4SLinus Torvalds  * strategy routine with the table entry.  This will be called before
19241da177e4SLinus Torvalds  * any automatic read or write of the data is performed.
19251da177e4SLinus Torvalds  *
19261da177e4SLinus Torvalds  * The strategy routine may return
19271da177e4SLinus Torvalds  *
19281da177e4SLinus Torvalds  * < 0 - Error occurred (error is passed to user process)
19291da177e4SLinus Torvalds  *
19301da177e4SLinus Torvalds  * 0   - OK - proceed with automatic read or write.
19311da177e4SLinus Torvalds  *
19321da177e4SLinus Torvalds  * > 0 - OK - read or write has been done by the strategy routine, so
19331da177e4SLinus Torvalds  *       return immediately.
19341da177e4SLinus Torvalds  *
19351da177e4SLinus Torvalds  * There must be a proc_handler routine for any terminal nodes
19361da177e4SLinus Torvalds  * mirrored under /proc/sys (non-terminals are handled by a built-in
19371da177e4SLinus Torvalds  * directory handler).  Several default handlers are available to
19381da177e4SLinus Torvalds  * cover common cases -
19391da177e4SLinus Torvalds  *
19401da177e4SLinus Torvalds  * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
19411da177e4SLinus Torvalds  * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
19421da177e4SLinus Torvalds  * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
19431da177e4SLinus Torvalds  *
19441da177e4SLinus Torvalds  * It is the handler's job to read the input buffer from user memory
19451da177e4SLinus Torvalds  * and process it. The handler should return 0 on success.
19461da177e4SLinus Torvalds  *
19471da177e4SLinus Torvalds  * This routine returns %NULL on a failure to register, and a pointer
19481da177e4SLinus Torvalds  * to the table header on success.
19491da177e4SLinus Torvalds  */
1950e51b6ba0SEric W. Biederman struct ctl_table_header *__register_sysctl_paths(
1951e51b6ba0SEric W. Biederman 	struct ctl_table_root *root,
1952e51b6ba0SEric W. Biederman 	struct nsproxy *namespaces,
1953e51b6ba0SEric W. Biederman 	const struct ctl_path *path, struct ctl_table *table)
19541da177e4SLinus Torvalds {
195529e796fdSEric W. Biederman 	struct ctl_table_header *header;
195629e796fdSEric W. Biederman 	struct ctl_table *new, **prevp;
195729e796fdSEric W. Biederman 	unsigned int n, npath;
1958ae7edeccSAl Viro 	struct ctl_table_set *set;
195929e796fdSEric W. Biederman 
196029e796fdSEric W. Biederman 	/* Count the path components */
196129e796fdSEric W. Biederman 	for (npath = 0; path[npath].ctl_name || path[npath].procname; ++npath)
196229e796fdSEric W. Biederman 		;
196329e796fdSEric W. Biederman 
196429e796fdSEric W. Biederman 	/*
196529e796fdSEric W. Biederman 	 * For each path component, allocate a 2-element ctl_table array.
196629e796fdSEric W. Biederman 	 * The first array element will be filled with the sysctl entry
196729e796fdSEric W. Biederman 	 * for this, the second will be the sentinel (ctl_name == 0).
196829e796fdSEric W. Biederman 	 *
196929e796fdSEric W. Biederman 	 * We allocate everything in one go so that we don't have to
197029e796fdSEric W. Biederman 	 * worry about freeing additional memory in unregister_sysctl_table.
197129e796fdSEric W. Biederman 	 */
197229e796fdSEric W. Biederman 	header = kzalloc(sizeof(struct ctl_table_header) +
197329e796fdSEric W. Biederman 			 (2 * npath * sizeof(struct ctl_table)), GFP_KERNEL);
197429e796fdSEric W. Biederman 	if (!header)
19751da177e4SLinus Torvalds 		return NULL;
197629e796fdSEric W. Biederman 
197729e796fdSEric W. Biederman 	new = (struct ctl_table *) (header + 1);
197829e796fdSEric W. Biederman 
197929e796fdSEric W. Biederman 	/* Now connect the dots */
198029e796fdSEric W. Biederman 	prevp = &header->ctl_table;
198129e796fdSEric W. Biederman 	for (n = 0; n < npath; ++n, ++path) {
198229e796fdSEric W. Biederman 		/* Copy the procname */
198329e796fdSEric W. Biederman 		new->procname = path->procname;
198429e796fdSEric W. Biederman 		new->ctl_name = path->ctl_name;
198529e796fdSEric W. Biederman 		new->mode     = 0555;
198629e796fdSEric W. Biederman 
198729e796fdSEric W. Biederman 		*prevp = new;
198829e796fdSEric W. Biederman 		prevp = &new->child;
198929e796fdSEric W. Biederman 
199029e796fdSEric W. Biederman 		new += 2;
199129e796fdSEric W. Biederman 	}
199229e796fdSEric W. Biederman 	*prevp = table;
199323eb06deSEric W. Biederman 	header->ctl_table_arg = table;
199429e796fdSEric W. Biederman 
199529e796fdSEric W. Biederman 	INIT_LIST_HEAD(&header->ctl_entry);
199629e796fdSEric W. Biederman 	header->used = 0;
199729e796fdSEric W. Biederman 	header->unregistering = NULL;
1998e51b6ba0SEric W. Biederman 	header->root = root;
199929e796fdSEric W. Biederman 	sysctl_set_parent(NULL, header->ctl_table);
2000f7e6ced4SAl Viro 	header->count = 1;
200188f458e4SHolger Schurig #ifdef CONFIG_SYSCTL_SYSCALL_CHECK
2002e51b6ba0SEric W. Biederman 	if (sysctl_check_table(namespaces, header->ctl_table)) {
200329e796fdSEric W. Biederman 		kfree(header);
2004fc6cd25bSEric W. Biederman 		return NULL;
2005fc6cd25bSEric W. Biederman 	}
200688f458e4SHolger Schurig #endif
2007330d57fbSAl Viro 	spin_lock(&sysctl_lock);
200873455092SAl Viro 	header->set = lookup_header_set(root, namespaces);
2009ae7edeccSAl Viro 	header->attached_by = header->ctl_table;
2010ae7edeccSAl Viro 	header->attached_to = root_table;
2011ae7edeccSAl Viro 	header->parent = &root_table_header;
2012ae7edeccSAl Viro 	for (set = header->set; set; set = set->parent) {
2013ae7edeccSAl Viro 		struct ctl_table_header *p;
2014ae7edeccSAl Viro 		list_for_each_entry(p, &set->list, ctl_entry) {
2015ae7edeccSAl Viro 			if (p->unregistering)
2016ae7edeccSAl Viro 				continue;
2017ae7edeccSAl Viro 			try_attach(p, header);
2018ae7edeccSAl Viro 		}
2019ae7edeccSAl Viro 	}
2020ae7edeccSAl Viro 	header->parent->count++;
202173455092SAl Viro 	list_add_tail(&header->ctl_entry, &header->set->list);
2022330d57fbSAl Viro 	spin_unlock(&sysctl_lock);
202329e796fdSEric W. Biederman 
202429e796fdSEric W. Biederman 	return header;
202529e796fdSEric W. Biederman }
202629e796fdSEric W. Biederman 
202729e796fdSEric W. Biederman /**
2028e51b6ba0SEric W. Biederman  * register_sysctl_table_path - register a sysctl table hierarchy
2029e51b6ba0SEric W. Biederman  * @path: The path to the directory the sysctl table is in.
2030e51b6ba0SEric W. Biederman  * @table: the top-level table structure
2031e51b6ba0SEric W. Biederman  *
2032e51b6ba0SEric W. Biederman  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
2033e51b6ba0SEric W. Biederman  * array. A completely 0 filled entry terminates the table.
2034e51b6ba0SEric W. Biederman  *
2035e51b6ba0SEric W. Biederman  * See __register_sysctl_paths for more details.
2036e51b6ba0SEric W. Biederman  */
2037e51b6ba0SEric W. Biederman struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
2038e51b6ba0SEric W. Biederman 						struct ctl_table *table)
2039e51b6ba0SEric W. Biederman {
2040e51b6ba0SEric W. Biederman 	return __register_sysctl_paths(&sysctl_table_root, current->nsproxy,
2041e51b6ba0SEric W. Biederman 					path, table);
2042e51b6ba0SEric W. Biederman }
2043e51b6ba0SEric W. Biederman 
2044e51b6ba0SEric W. Biederman /**
204529e796fdSEric W. Biederman  * register_sysctl_table - register a sysctl table hierarchy
204629e796fdSEric W. Biederman  * @table: the top-level table structure
204729e796fdSEric W. Biederman  *
204829e796fdSEric W. Biederman  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
204929e796fdSEric W. Biederman  * array. A completely 0 filled entry terminates the table.
205029e796fdSEric W. Biederman  *
205129e796fdSEric W. Biederman  * See register_sysctl_paths for more details.
205229e796fdSEric W. Biederman  */
205329e796fdSEric W. Biederman struct ctl_table_header *register_sysctl_table(struct ctl_table *table)
205429e796fdSEric W. Biederman {
205529e796fdSEric W. Biederman 	static const struct ctl_path null_path[] = { {} };
205629e796fdSEric W. Biederman 
205729e796fdSEric W. Biederman 	return register_sysctl_paths(null_path, table);
20581da177e4SLinus Torvalds }
20591da177e4SLinus Torvalds 
20601da177e4SLinus Torvalds /**
20611da177e4SLinus Torvalds  * unregister_sysctl_table - unregister a sysctl table hierarchy
20621da177e4SLinus Torvalds  * @header: the header returned from register_sysctl_table
20631da177e4SLinus Torvalds  *
20641da177e4SLinus Torvalds  * Unregisters the sysctl table and all children. proc entries may not
20651da177e4SLinus Torvalds  * actually be removed until they are no longer used by anyone.
20661da177e4SLinus Torvalds  */
20671da177e4SLinus Torvalds void unregister_sysctl_table(struct ctl_table_header * header)
20681da177e4SLinus Torvalds {
2069330d57fbSAl Viro 	might_sleep();
2070f1dad166SPavel Emelyanov 
2071f1dad166SPavel Emelyanov 	if (header == NULL)
2072f1dad166SPavel Emelyanov 		return;
2073f1dad166SPavel Emelyanov 
2074330d57fbSAl Viro 	spin_lock(&sysctl_lock);
2075330d57fbSAl Viro 	start_unregistering(header);
2076ae7edeccSAl Viro 	if (!--header->parent->count) {
2077ae7edeccSAl Viro 		WARN_ON(1);
2078ae7edeccSAl Viro 		kfree(header->parent);
2079ae7edeccSAl Viro 	}
2080f7e6ced4SAl Viro 	if (!--header->count)
20811da177e4SLinus Torvalds 		kfree(header);
2082f7e6ced4SAl Viro 	spin_unlock(&sysctl_lock);
20831da177e4SLinus Torvalds }
20841da177e4SLinus Torvalds 
20859043476fSAl Viro int sysctl_is_seen(struct ctl_table_header *p)
20869043476fSAl Viro {
20879043476fSAl Viro 	struct ctl_table_set *set = p->set;
20889043476fSAl Viro 	int res;
20899043476fSAl Viro 	spin_lock(&sysctl_lock);
20909043476fSAl Viro 	if (p->unregistering)
20919043476fSAl Viro 		res = 0;
20929043476fSAl Viro 	else if (!set->is_seen)
20939043476fSAl Viro 		res = 1;
20949043476fSAl Viro 	else
20959043476fSAl Viro 		res = set->is_seen(set);
20969043476fSAl Viro 	spin_unlock(&sysctl_lock);
20979043476fSAl Viro 	return res;
20989043476fSAl Viro }
20999043476fSAl Viro 
210073455092SAl Viro void setup_sysctl_set(struct ctl_table_set *p,
210173455092SAl Viro 	struct ctl_table_set *parent,
210273455092SAl Viro 	int (*is_seen)(struct ctl_table_set *))
210373455092SAl Viro {
210473455092SAl Viro 	INIT_LIST_HEAD(&p->list);
210573455092SAl Viro 	p->parent = parent ? parent : &sysctl_table_root.default_set;
210673455092SAl Viro 	p->is_seen = is_seen;
210773455092SAl Viro }
210873455092SAl Viro 
2109b89a8171SEric W. Biederman #else /* !CONFIG_SYSCTL */
2110d8217f07SEric W. Biederman struct ctl_table_header *register_sysctl_table(struct ctl_table * table)
2111b89a8171SEric W. Biederman {
2112b89a8171SEric W. Biederman 	return NULL;
2113b89a8171SEric W. Biederman }
2114b89a8171SEric W. Biederman 
211529e796fdSEric W. Biederman struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
211629e796fdSEric W. Biederman 						    struct ctl_table *table)
211729e796fdSEric W. Biederman {
211829e796fdSEric W. Biederman 	return NULL;
211929e796fdSEric W. Biederman }
212029e796fdSEric W. Biederman 
2121b89a8171SEric W. Biederman void unregister_sysctl_table(struct ctl_table_header * table)
2122b89a8171SEric W. Biederman {
2123b89a8171SEric W. Biederman }
2124b89a8171SEric W. Biederman 
212573455092SAl Viro void setup_sysctl_set(struct ctl_table_set *p,
212673455092SAl Viro 	struct ctl_table_set *parent,
212773455092SAl Viro 	int (*is_seen)(struct ctl_table_set *))
212873455092SAl Viro {
212973455092SAl Viro }
213073455092SAl Viro 
2131f7e6ced4SAl Viro void sysctl_head_put(struct ctl_table_header *head)
2132f7e6ced4SAl Viro {
2133f7e6ced4SAl Viro }
2134f7e6ced4SAl Viro 
2135b89a8171SEric W. Biederman #endif /* CONFIG_SYSCTL */
2136b89a8171SEric W. Biederman 
21371da177e4SLinus Torvalds /*
21381da177e4SLinus Torvalds  * /proc/sys support
21391da177e4SLinus Torvalds  */
21401da177e4SLinus Torvalds 
2141b89a8171SEric W. Biederman #ifdef CONFIG_PROC_SYSCTL
21421da177e4SLinus Torvalds 
2143b1ba4dddSAdrian Bunk static int _proc_do_string(void* data, int maxlen, int write,
2144b1ba4dddSAdrian Bunk 			   struct file *filp, void __user *buffer,
2145b1ba4dddSAdrian Bunk 			   size_t *lenp, loff_t *ppos)
2146f5dd3d6fSSam Vilain {
2147f5dd3d6fSSam Vilain 	size_t len;
2148f5dd3d6fSSam Vilain 	char __user *p;
2149f5dd3d6fSSam Vilain 	char c;
2150f5dd3d6fSSam Vilain 
21518d060877SOleg Nesterov 	if (!data || !maxlen || !*lenp) {
2152f5dd3d6fSSam Vilain 		*lenp = 0;
2153f5dd3d6fSSam Vilain 		return 0;
2154f5dd3d6fSSam Vilain 	}
2155f5dd3d6fSSam Vilain 
2156f5dd3d6fSSam Vilain 	if (write) {
2157f5dd3d6fSSam Vilain 		len = 0;
2158f5dd3d6fSSam Vilain 		p = buffer;
2159f5dd3d6fSSam Vilain 		while (len < *lenp) {
2160f5dd3d6fSSam Vilain 			if (get_user(c, p++))
2161f5dd3d6fSSam Vilain 				return -EFAULT;
2162f5dd3d6fSSam Vilain 			if (c == 0 || c == '\n')
2163f5dd3d6fSSam Vilain 				break;
2164f5dd3d6fSSam Vilain 			len++;
2165f5dd3d6fSSam Vilain 		}
2166f5dd3d6fSSam Vilain 		if (len >= maxlen)
2167f5dd3d6fSSam Vilain 			len = maxlen-1;
2168f5dd3d6fSSam Vilain 		if(copy_from_user(data, buffer, len))
2169f5dd3d6fSSam Vilain 			return -EFAULT;
2170f5dd3d6fSSam Vilain 		((char *) data)[len] = 0;
2171f5dd3d6fSSam Vilain 		*ppos += *lenp;
2172f5dd3d6fSSam Vilain 	} else {
2173f5dd3d6fSSam Vilain 		len = strlen(data);
2174f5dd3d6fSSam Vilain 		if (len > maxlen)
2175f5dd3d6fSSam Vilain 			len = maxlen;
21768d060877SOleg Nesterov 
21778d060877SOleg Nesterov 		if (*ppos > len) {
21788d060877SOleg Nesterov 			*lenp = 0;
21798d060877SOleg Nesterov 			return 0;
21808d060877SOleg Nesterov 		}
21818d060877SOleg Nesterov 
21828d060877SOleg Nesterov 		data += *ppos;
21838d060877SOleg Nesterov 		len  -= *ppos;
21848d060877SOleg Nesterov 
2185f5dd3d6fSSam Vilain 		if (len > *lenp)
2186f5dd3d6fSSam Vilain 			len = *lenp;
2187f5dd3d6fSSam Vilain 		if (len)
2188f5dd3d6fSSam Vilain 			if(copy_to_user(buffer, data, len))
2189f5dd3d6fSSam Vilain 				return -EFAULT;
2190f5dd3d6fSSam Vilain 		if (len < *lenp) {
2191f5dd3d6fSSam Vilain 			if(put_user('\n', ((char __user *) buffer) + len))
2192f5dd3d6fSSam Vilain 				return -EFAULT;
2193f5dd3d6fSSam Vilain 			len++;
2194f5dd3d6fSSam Vilain 		}
2195f5dd3d6fSSam Vilain 		*lenp = len;
2196f5dd3d6fSSam Vilain 		*ppos += len;
2197f5dd3d6fSSam Vilain 	}
2198f5dd3d6fSSam Vilain 	return 0;
2199f5dd3d6fSSam Vilain }
2200f5dd3d6fSSam Vilain 
22011da177e4SLinus Torvalds /**
22021da177e4SLinus Torvalds  * proc_dostring - read a string sysctl
22031da177e4SLinus Torvalds  * @table: the sysctl table
22041da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
22051da177e4SLinus Torvalds  * @filp: the file structure
22061da177e4SLinus Torvalds  * @buffer: the user buffer
22071da177e4SLinus Torvalds  * @lenp: the size of the user buffer
22081da177e4SLinus Torvalds  * @ppos: file position
22091da177e4SLinus Torvalds  *
22101da177e4SLinus Torvalds  * Reads/writes a string from/to the user buffer. If the kernel
22111da177e4SLinus Torvalds  * buffer provided is not large enough to hold the string, the
22121da177e4SLinus Torvalds  * string is truncated. The copied string is %NULL-terminated.
22131da177e4SLinus Torvalds  * If the string is being read by the user process, it is copied
22141da177e4SLinus Torvalds  * and a newline '\n' is added. It is truncated if the buffer is
22151da177e4SLinus Torvalds  * not large enough.
22161da177e4SLinus Torvalds  *
22171da177e4SLinus Torvalds  * Returns 0 on success.
22181da177e4SLinus Torvalds  */
2219d8217f07SEric W. Biederman int proc_dostring(struct ctl_table *table, int write, struct file *filp,
22201da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
22211da177e4SLinus Torvalds {
2222f5dd3d6fSSam Vilain 	return _proc_do_string(table->data, table->maxlen, write, filp,
2223f5dd3d6fSSam Vilain 			       buffer, lenp, ppos);
22241da177e4SLinus Torvalds }
22251da177e4SLinus Torvalds 
22261da177e4SLinus Torvalds 
22271da177e4SLinus Torvalds static int do_proc_dointvec_conv(int *negp, unsigned long *lvalp,
22281da177e4SLinus Torvalds 				 int *valp,
22291da177e4SLinus Torvalds 				 int write, void *data)
22301da177e4SLinus Torvalds {
22311da177e4SLinus Torvalds 	if (write) {
22321da177e4SLinus Torvalds 		*valp = *negp ? -*lvalp : *lvalp;
22331da177e4SLinus Torvalds 	} else {
22341da177e4SLinus Torvalds 		int val = *valp;
22351da177e4SLinus Torvalds 		if (val < 0) {
22361da177e4SLinus Torvalds 			*negp = -1;
22371da177e4SLinus Torvalds 			*lvalp = (unsigned long)-val;
22381da177e4SLinus Torvalds 		} else {
22391da177e4SLinus Torvalds 			*negp = 0;
22401da177e4SLinus Torvalds 			*lvalp = (unsigned long)val;
22411da177e4SLinus Torvalds 		}
22421da177e4SLinus Torvalds 	}
22431da177e4SLinus Torvalds 	return 0;
22441da177e4SLinus Torvalds }
22451da177e4SLinus Torvalds 
2246d8217f07SEric W. Biederman static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
2247fcfbd547SKirill Korotaev 		  int write, struct file *filp, void __user *buffer,
2248fcfbd547SKirill Korotaev 		  size_t *lenp, loff_t *ppos,
22491da177e4SLinus Torvalds 		  int (*conv)(int *negp, unsigned long *lvalp, int *valp,
22501da177e4SLinus Torvalds 			      int write, void *data),
22511da177e4SLinus Torvalds 		  void *data)
22521da177e4SLinus Torvalds {
22531da177e4SLinus Torvalds #define TMPBUFLEN 21
22541da177e4SLinus Torvalds 	int *i, vleft, first=1, neg, val;
22551da177e4SLinus Torvalds 	unsigned long lval;
22561da177e4SLinus Torvalds 	size_t left, len;
22571da177e4SLinus Torvalds 
22581da177e4SLinus Torvalds 	char buf[TMPBUFLEN], *p;
22591da177e4SLinus Torvalds 	char __user *s = buffer;
22601da177e4SLinus Torvalds 
2261fcfbd547SKirill Korotaev 	if (!tbl_data || !table->maxlen || !*lenp ||
22621da177e4SLinus Torvalds 	    (*ppos && !write)) {
22631da177e4SLinus Torvalds 		*lenp = 0;
22641da177e4SLinus Torvalds 		return 0;
22651da177e4SLinus Torvalds 	}
22661da177e4SLinus Torvalds 
2267fcfbd547SKirill Korotaev 	i = (int *) tbl_data;
22681da177e4SLinus Torvalds 	vleft = table->maxlen / sizeof(*i);
22691da177e4SLinus Torvalds 	left = *lenp;
22701da177e4SLinus Torvalds 
22711da177e4SLinus Torvalds 	if (!conv)
22721da177e4SLinus Torvalds 		conv = do_proc_dointvec_conv;
22731da177e4SLinus Torvalds 
22741da177e4SLinus Torvalds 	for (; left && vleft--; i++, first=0) {
22751da177e4SLinus Torvalds 		if (write) {
22761da177e4SLinus Torvalds 			while (left) {
22771da177e4SLinus Torvalds 				char c;
22781da177e4SLinus Torvalds 				if (get_user(c, s))
22791da177e4SLinus Torvalds 					return -EFAULT;
22801da177e4SLinus Torvalds 				if (!isspace(c))
22811da177e4SLinus Torvalds 					break;
22821da177e4SLinus Torvalds 				left--;
22831da177e4SLinus Torvalds 				s++;
22841da177e4SLinus Torvalds 			}
22851da177e4SLinus Torvalds 			if (!left)
22861da177e4SLinus Torvalds 				break;
22871da177e4SLinus Torvalds 			neg = 0;
22881da177e4SLinus Torvalds 			len = left;
22891da177e4SLinus Torvalds 			if (len > sizeof(buf) - 1)
22901da177e4SLinus Torvalds 				len = sizeof(buf) - 1;
22911da177e4SLinus Torvalds 			if (copy_from_user(buf, s, len))
22921da177e4SLinus Torvalds 				return -EFAULT;
22931da177e4SLinus Torvalds 			buf[len] = 0;
22941da177e4SLinus Torvalds 			p = buf;
22951da177e4SLinus Torvalds 			if (*p == '-' && left > 1) {
22961da177e4SLinus Torvalds 				neg = 1;
2297bd9b0bacSBP, Praveen 				p++;
22981da177e4SLinus Torvalds 			}
22991da177e4SLinus Torvalds 			if (*p < '0' || *p > '9')
23001da177e4SLinus Torvalds 				break;
23011da177e4SLinus Torvalds 
23021da177e4SLinus Torvalds 			lval = simple_strtoul(p, &p, 0);
23031da177e4SLinus Torvalds 
23041da177e4SLinus Torvalds 			len = p-buf;
23051da177e4SLinus Torvalds 			if ((len < left) && *p && !isspace(*p))
23061da177e4SLinus Torvalds 				break;
23071da177e4SLinus Torvalds 			if (neg)
23081da177e4SLinus Torvalds 				val = -val;
23091da177e4SLinus Torvalds 			s += len;
23101da177e4SLinus Torvalds 			left -= len;
23111da177e4SLinus Torvalds 
23121da177e4SLinus Torvalds 			if (conv(&neg, &lval, i, 1, data))
23131da177e4SLinus Torvalds 				break;
23141da177e4SLinus Torvalds 		} else {
23151da177e4SLinus Torvalds 			p = buf;
23161da177e4SLinus Torvalds 			if (!first)
23171da177e4SLinus Torvalds 				*p++ = '\t';
23181da177e4SLinus Torvalds 
23191da177e4SLinus Torvalds 			if (conv(&neg, &lval, i, 0, data))
23201da177e4SLinus Torvalds 				break;
23211da177e4SLinus Torvalds 
23221da177e4SLinus Torvalds 			sprintf(p, "%s%lu", neg ? "-" : "", lval);
23231da177e4SLinus Torvalds 			len = strlen(buf);
23241da177e4SLinus Torvalds 			if (len > left)
23251da177e4SLinus Torvalds 				len = left;
23261da177e4SLinus Torvalds 			if(copy_to_user(s, buf, len))
23271da177e4SLinus Torvalds 				return -EFAULT;
23281da177e4SLinus Torvalds 			left -= len;
23291da177e4SLinus Torvalds 			s += len;
23301da177e4SLinus Torvalds 		}
23311da177e4SLinus Torvalds 	}
23321da177e4SLinus Torvalds 
23331da177e4SLinus Torvalds 	if (!write && !first && left) {
23341da177e4SLinus Torvalds 		if(put_user('\n', s))
23351da177e4SLinus Torvalds 			return -EFAULT;
23361da177e4SLinus Torvalds 		left--, s++;
23371da177e4SLinus Torvalds 	}
23381da177e4SLinus Torvalds 	if (write) {
23391da177e4SLinus Torvalds 		while (left) {
23401da177e4SLinus Torvalds 			char c;
23411da177e4SLinus Torvalds 			if (get_user(c, s++))
23421da177e4SLinus Torvalds 				return -EFAULT;
23431da177e4SLinus Torvalds 			if (!isspace(c))
23441da177e4SLinus Torvalds 				break;
23451da177e4SLinus Torvalds 			left--;
23461da177e4SLinus Torvalds 		}
23471da177e4SLinus Torvalds 	}
23481da177e4SLinus Torvalds 	if (write && first)
23491da177e4SLinus Torvalds 		return -EINVAL;
23501da177e4SLinus Torvalds 	*lenp -= left;
23511da177e4SLinus Torvalds 	*ppos += *lenp;
23521da177e4SLinus Torvalds 	return 0;
23531da177e4SLinus Torvalds #undef TMPBUFLEN
23541da177e4SLinus Torvalds }
23551da177e4SLinus Torvalds 
2356d8217f07SEric W. Biederman static int do_proc_dointvec(struct ctl_table *table, int write, struct file *filp,
2357fcfbd547SKirill Korotaev 		  void __user *buffer, size_t *lenp, loff_t *ppos,
2358fcfbd547SKirill Korotaev 		  int (*conv)(int *negp, unsigned long *lvalp, int *valp,
2359fcfbd547SKirill Korotaev 			      int write, void *data),
2360fcfbd547SKirill Korotaev 		  void *data)
2361fcfbd547SKirill Korotaev {
2362fcfbd547SKirill Korotaev 	return __do_proc_dointvec(table->data, table, write, filp,
2363fcfbd547SKirill Korotaev 			buffer, lenp, ppos, conv, data);
2364fcfbd547SKirill Korotaev }
2365fcfbd547SKirill Korotaev 
23661da177e4SLinus Torvalds /**
23671da177e4SLinus Torvalds  * proc_dointvec - read a vector of integers
23681da177e4SLinus Torvalds  * @table: the sysctl table
23691da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
23701da177e4SLinus Torvalds  * @filp: the file structure
23711da177e4SLinus Torvalds  * @buffer: the user buffer
23721da177e4SLinus Torvalds  * @lenp: the size of the user buffer
23731da177e4SLinus Torvalds  * @ppos: file position
23741da177e4SLinus Torvalds  *
23751da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
23761da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
23771da177e4SLinus Torvalds  *
23781da177e4SLinus Torvalds  * Returns 0 on success.
23791da177e4SLinus Torvalds  */
2380d8217f07SEric W. Biederman int proc_dointvec(struct ctl_table *table, int write, struct file *filp,
23811da177e4SLinus Torvalds 		     void __user *buffer, size_t *lenp, loff_t *ppos)
23821da177e4SLinus Torvalds {
23831da177e4SLinus Torvalds     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
23841da177e4SLinus Torvalds 		    	    NULL,NULL);
23851da177e4SLinus Torvalds }
23861da177e4SLinus Torvalds 
238734f5a398STheodore Ts'o /*
238834f5a398STheodore Ts'o  * Taint values can only be increased
238925ddbb18SAndi Kleen  * This means we can safely use a temporary.
239034f5a398STheodore Ts'o  */
239125ddbb18SAndi Kleen static int proc_taint(struct ctl_table *table, int write, struct file *filp,
239234f5a398STheodore Ts'o 			       void __user *buffer, size_t *lenp, loff_t *ppos)
239334f5a398STheodore Ts'o {
239425ddbb18SAndi Kleen 	struct ctl_table t;
239525ddbb18SAndi Kleen 	unsigned long tmptaint = get_taint();
239625ddbb18SAndi Kleen 	int err;
239734f5a398STheodore Ts'o 
239891fcd412SBastian Blank 	if (write && !capable(CAP_SYS_ADMIN))
239934f5a398STheodore Ts'o 		return -EPERM;
240034f5a398STheodore Ts'o 
240125ddbb18SAndi Kleen 	t = *table;
240225ddbb18SAndi Kleen 	t.data = &tmptaint;
240325ddbb18SAndi Kleen 	err = proc_doulongvec_minmax(&t, write, filp, buffer, lenp, ppos);
240425ddbb18SAndi Kleen 	if (err < 0)
240525ddbb18SAndi Kleen 		return err;
240625ddbb18SAndi Kleen 
240725ddbb18SAndi Kleen 	if (write) {
240825ddbb18SAndi Kleen 		/*
240925ddbb18SAndi Kleen 		 * Poor man's atomic or. Not worth adding a primitive
241025ddbb18SAndi Kleen 		 * to everyone's atomic.h for this
241125ddbb18SAndi Kleen 		 */
241225ddbb18SAndi Kleen 		int i;
241325ddbb18SAndi Kleen 		for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
241425ddbb18SAndi Kleen 			if ((tmptaint >> i) & 1)
241525ddbb18SAndi Kleen 				add_taint(i);
241625ddbb18SAndi Kleen 		}
241725ddbb18SAndi Kleen 	}
241825ddbb18SAndi Kleen 
241925ddbb18SAndi Kleen 	return err;
242034f5a398STheodore Ts'o }
242134f5a398STheodore Ts'o 
24221da177e4SLinus Torvalds struct do_proc_dointvec_minmax_conv_param {
24231da177e4SLinus Torvalds 	int *min;
24241da177e4SLinus Torvalds 	int *max;
24251da177e4SLinus Torvalds };
24261da177e4SLinus Torvalds 
24271da177e4SLinus Torvalds static int do_proc_dointvec_minmax_conv(int *negp, unsigned long *lvalp,
24281da177e4SLinus Torvalds 					int *valp,
24291da177e4SLinus Torvalds 					int write, void *data)
24301da177e4SLinus Torvalds {
24311da177e4SLinus Torvalds 	struct do_proc_dointvec_minmax_conv_param *param = data;
24321da177e4SLinus Torvalds 	if (write) {
24331da177e4SLinus Torvalds 		int val = *negp ? -*lvalp : *lvalp;
24341da177e4SLinus Torvalds 		if ((param->min && *param->min > val) ||
24351da177e4SLinus Torvalds 		    (param->max && *param->max < val))
24361da177e4SLinus Torvalds 			return -EINVAL;
24371da177e4SLinus Torvalds 		*valp = val;
24381da177e4SLinus Torvalds 	} else {
24391da177e4SLinus Torvalds 		int val = *valp;
24401da177e4SLinus Torvalds 		if (val < 0) {
24411da177e4SLinus Torvalds 			*negp = -1;
24421da177e4SLinus Torvalds 			*lvalp = (unsigned long)-val;
24431da177e4SLinus Torvalds 		} else {
24441da177e4SLinus Torvalds 			*negp = 0;
24451da177e4SLinus Torvalds 			*lvalp = (unsigned long)val;
24461da177e4SLinus Torvalds 		}
24471da177e4SLinus Torvalds 	}
24481da177e4SLinus Torvalds 	return 0;
24491da177e4SLinus Torvalds }
24501da177e4SLinus Torvalds 
24511da177e4SLinus Torvalds /**
24521da177e4SLinus Torvalds  * proc_dointvec_minmax - read a vector of integers with min/max values
24531da177e4SLinus Torvalds  * @table: the sysctl table
24541da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
24551da177e4SLinus Torvalds  * @filp: the file structure
24561da177e4SLinus Torvalds  * @buffer: the user buffer
24571da177e4SLinus Torvalds  * @lenp: the size of the user buffer
24581da177e4SLinus Torvalds  * @ppos: file position
24591da177e4SLinus Torvalds  *
24601da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
24611da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
24621da177e4SLinus Torvalds  *
24631da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
24641da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
24651da177e4SLinus Torvalds  *
24661da177e4SLinus Torvalds  * Returns 0 on success.
24671da177e4SLinus Torvalds  */
2468d8217f07SEric W. Biederman int proc_dointvec_minmax(struct ctl_table *table, int write, struct file *filp,
24691da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
24701da177e4SLinus Torvalds {
24711da177e4SLinus Torvalds 	struct do_proc_dointvec_minmax_conv_param param = {
24721da177e4SLinus Torvalds 		.min = (int *) table->extra1,
24731da177e4SLinus Torvalds 		.max = (int *) table->extra2,
24741da177e4SLinus Torvalds 	};
24751da177e4SLinus Torvalds 	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
24761da177e4SLinus Torvalds 				do_proc_dointvec_minmax_conv, &param);
24771da177e4SLinus Torvalds }
24781da177e4SLinus Torvalds 
2479d8217f07SEric W. Biederman static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table, int write,
24801da177e4SLinus Torvalds 				     struct file *filp,
24811da177e4SLinus Torvalds 				     void __user *buffer,
24821da177e4SLinus Torvalds 				     size_t *lenp, loff_t *ppos,
24831da177e4SLinus Torvalds 				     unsigned long convmul,
24841da177e4SLinus Torvalds 				     unsigned long convdiv)
24851da177e4SLinus Torvalds {
24861da177e4SLinus Torvalds #define TMPBUFLEN 21
24871da177e4SLinus Torvalds 	unsigned long *i, *min, *max, val;
24881da177e4SLinus Torvalds 	int vleft, first=1, neg;
24891da177e4SLinus Torvalds 	size_t len, left;
24901da177e4SLinus Torvalds 	char buf[TMPBUFLEN], *p;
24911da177e4SLinus Torvalds 	char __user *s = buffer;
24921da177e4SLinus Torvalds 
2493fcfbd547SKirill Korotaev 	if (!data || !table->maxlen || !*lenp ||
24941da177e4SLinus Torvalds 	    (*ppos && !write)) {
24951da177e4SLinus Torvalds 		*lenp = 0;
24961da177e4SLinus Torvalds 		return 0;
24971da177e4SLinus Torvalds 	}
24981da177e4SLinus Torvalds 
2499fcfbd547SKirill Korotaev 	i = (unsigned long *) data;
25001da177e4SLinus Torvalds 	min = (unsigned long *) table->extra1;
25011da177e4SLinus Torvalds 	max = (unsigned long *) table->extra2;
25021da177e4SLinus Torvalds 	vleft = table->maxlen / sizeof(unsigned long);
25031da177e4SLinus Torvalds 	left = *lenp;
25041da177e4SLinus Torvalds 
25051da177e4SLinus Torvalds 	for (; left && vleft--; i++, min++, max++, first=0) {
25061da177e4SLinus Torvalds 		if (write) {
25071da177e4SLinus Torvalds 			while (left) {
25081da177e4SLinus Torvalds 				char c;
25091da177e4SLinus Torvalds 				if (get_user(c, s))
25101da177e4SLinus Torvalds 					return -EFAULT;
25111da177e4SLinus Torvalds 				if (!isspace(c))
25121da177e4SLinus Torvalds 					break;
25131da177e4SLinus Torvalds 				left--;
25141da177e4SLinus Torvalds 				s++;
25151da177e4SLinus Torvalds 			}
25161da177e4SLinus Torvalds 			if (!left)
25171da177e4SLinus Torvalds 				break;
25181da177e4SLinus Torvalds 			neg = 0;
25191da177e4SLinus Torvalds 			len = left;
25201da177e4SLinus Torvalds 			if (len > TMPBUFLEN-1)
25211da177e4SLinus Torvalds 				len = TMPBUFLEN-1;
25221da177e4SLinus Torvalds 			if (copy_from_user(buf, s, len))
25231da177e4SLinus Torvalds 				return -EFAULT;
25241da177e4SLinus Torvalds 			buf[len] = 0;
25251da177e4SLinus Torvalds 			p = buf;
25261da177e4SLinus Torvalds 			if (*p == '-' && left > 1) {
25271da177e4SLinus Torvalds 				neg = 1;
2528bd9b0bacSBP, Praveen 				p++;
25291da177e4SLinus Torvalds 			}
25301da177e4SLinus Torvalds 			if (*p < '0' || *p > '9')
25311da177e4SLinus Torvalds 				break;
25321da177e4SLinus Torvalds 			val = simple_strtoul(p, &p, 0) * convmul / convdiv ;
25331da177e4SLinus Torvalds 			len = p-buf;
25341da177e4SLinus Torvalds 			if ((len < left) && *p && !isspace(*p))
25351da177e4SLinus Torvalds 				break;
25361da177e4SLinus Torvalds 			if (neg)
25371da177e4SLinus Torvalds 				val = -val;
25381da177e4SLinus Torvalds 			s += len;
25391da177e4SLinus Torvalds 			left -= len;
25401da177e4SLinus Torvalds 
25411da177e4SLinus Torvalds 			if(neg)
25421da177e4SLinus Torvalds 				continue;
25431da177e4SLinus Torvalds 			if ((min && val < *min) || (max && val > *max))
25441da177e4SLinus Torvalds 				continue;
25451da177e4SLinus Torvalds 			*i = val;
25461da177e4SLinus Torvalds 		} else {
25471da177e4SLinus Torvalds 			p = buf;
25481da177e4SLinus Torvalds 			if (!first)
25491da177e4SLinus Torvalds 				*p++ = '\t';
25501da177e4SLinus Torvalds 			sprintf(p, "%lu", convdiv * (*i) / convmul);
25511da177e4SLinus Torvalds 			len = strlen(buf);
25521da177e4SLinus Torvalds 			if (len > left)
25531da177e4SLinus Torvalds 				len = left;
25541da177e4SLinus Torvalds 			if(copy_to_user(s, buf, len))
25551da177e4SLinus Torvalds 				return -EFAULT;
25561da177e4SLinus Torvalds 			left -= len;
25571da177e4SLinus Torvalds 			s += len;
25581da177e4SLinus Torvalds 		}
25591da177e4SLinus Torvalds 	}
25601da177e4SLinus Torvalds 
25611da177e4SLinus Torvalds 	if (!write && !first && left) {
25621da177e4SLinus Torvalds 		if(put_user('\n', s))
25631da177e4SLinus Torvalds 			return -EFAULT;
25641da177e4SLinus Torvalds 		left--, s++;
25651da177e4SLinus Torvalds 	}
25661da177e4SLinus Torvalds 	if (write) {
25671da177e4SLinus Torvalds 		while (left) {
25681da177e4SLinus Torvalds 			char c;
25691da177e4SLinus Torvalds 			if (get_user(c, s++))
25701da177e4SLinus Torvalds 				return -EFAULT;
25711da177e4SLinus Torvalds 			if (!isspace(c))
25721da177e4SLinus Torvalds 				break;
25731da177e4SLinus Torvalds 			left--;
25741da177e4SLinus Torvalds 		}
25751da177e4SLinus Torvalds 	}
25761da177e4SLinus Torvalds 	if (write && first)
25771da177e4SLinus Torvalds 		return -EINVAL;
25781da177e4SLinus Torvalds 	*lenp -= left;
25791da177e4SLinus Torvalds 	*ppos += *lenp;
25801da177e4SLinus Torvalds 	return 0;
25811da177e4SLinus Torvalds #undef TMPBUFLEN
25821da177e4SLinus Torvalds }
25831da177e4SLinus Torvalds 
2584d8217f07SEric W. Biederman static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
2585fcfbd547SKirill Korotaev 				     struct file *filp,
2586fcfbd547SKirill Korotaev 				     void __user *buffer,
2587fcfbd547SKirill Korotaev 				     size_t *lenp, loff_t *ppos,
2588fcfbd547SKirill Korotaev 				     unsigned long convmul,
2589fcfbd547SKirill Korotaev 				     unsigned long convdiv)
2590fcfbd547SKirill Korotaev {
2591fcfbd547SKirill Korotaev 	return __do_proc_doulongvec_minmax(table->data, table, write,
2592fcfbd547SKirill Korotaev 			filp, buffer, lenp, ppos, convmul, convdiv);
2593fcfbd547SKirill Korotaev }
2594fcfbd547SKirill Korotaev 
25951da177e4SLinus Torvalds /**
25961da177e4SLinus Torvalds  * proc_doulongvec_minmax - read a vector of long integers with min/max values
25971da177e4SLinus Torvalds  * @table: the sysctl table
25981da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
25991da177e4SLinus Torvalds  * @filp: the file structure
26001da177e4SLinus Torvalds  * @buffer: the user buffer
26011da177e4SLinus Torvalds  * @lenp: the size of the user buffer
26021da177e4SLinus Torvalds  * @ppos: file position
26031da177e4SLinus Torvalds  *
26041da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
26051da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
26061da177e4SLinus Torvalds  *
26071da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
26081da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
26091da177e4SLinus Torvalds  *
26101da177e4SLinus Torvalds  * Returns 0 on success.
26111da177e4SLinus Torvalds  */
2612d8217f07SEric W. Biederman int proc_doulongvec_minmax(struct ctl_table *table, int write, struct file *filp,
26131da177e4SLinus Torvalds 			   void __user *buffer, size_t *lenp, loff_t *ppos)
26141da177e4SLinus Torvalds {
26151da177e4SLinus Torvalds     return do_proc_doulongvec_minmax(table, write, filp, buffer, lenp, ppos, 1l, 1l);
26161da177e4SLinus Torvalds }
26171da177e4SLinus Torvalds 
26181da177e4SLinus Torvalds /**
26191da177e4SLinus Torvalds  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
26201da177e4SLinus Torvalds  * @table: the sysctl table
26211da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
26221da177e4SLinus Torvalds  * @filp: the file structure
26231da177e4SLinus Torvalds  * @buffer: the user buffer
26241da177e4SLinus Torvalds  * @lenp: the size of the user buffer
26251da177e4SLinus Torvalds  * @ppos: file position
26261da177e4SLinus Torvalds  *
26271da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
26281da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string. The values
26291da177e4SLinus Torvalds  * are treated as milliseconds, and converted to jiffies when they are stored.
26301da177e4SLinus Torvalds  *
26311da177e4SLinus Torvalds  * This routine will ensure the values are within the range specified by
26321da177e4SLinus Torvalds  * table->extra1 (min) and table->extra2 (max).
26331da177e4SLinus Torvalds  *
26341da177e4SLinus Torvalds  * Returns 0 on success.
26351da177e4SLinus Torvalds  */
2636d8217f07SEric W. Biederman int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
26371da177e4SLinus Torvalds 				      struct file *filp,
26381da177e4SLinus Torvalds 				      void __user *buffer,
26391da177e4SLinus Torvalds 				      size_t *lenp, loff_t *ppos)
26401da177e4SLinus Torvalds {
26411da177e4SLinus Torvalds     return do_proc_doulongvec_minmax(table, write, filp, buffer,
26421da177e4SLinus Torvalds 				     lenp, ppos, HZ, 1000l);
26431da177e4SLinus Torvalds }
26441da177e4SLinus Torvalds 
26451da177e4SLinus Torvalds 
26461da177e4SLinus Torvalds static int do_proc_dointvec_jiffies_conv(int *negp, unsigned long *lvalp,
26471da177e4SLinus Torvalds 					 int *valp,
26481da177e4SLinus Torvalds 					 int write, void *data)
26491da177e4SLinus Torvalds {
26501da177e4SLinus Torvalds 	if (write) {
2651cba9f33dSBart Samwel 		if (*lvalp > LONG_MAX / HZ)
2652cba9f33dSBart Samwel 			return 1;
26531da177e4SLinus Torvalds 		*valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
26541da177e4SLinus Torvalds 	} else {
26551da177e4SLinus Torvalds 		int val = *valp;
26561da177e4SLinus Torvalds 		unsigned long lval;
26571da177e4SLinus Torvalds 		if (val < 0) {
26581da177e4SLinus Torvalds 			*negp = -1;
26591da177e4SLinus Torvalds 			lval = (unsigned long)-val;
26601da177e4SLinus Torvalds 		} else {
26611da177e4SLinus Torvalds 			*negp = 0;
26621da177e4SLinus Torvalds 			lval = (unsigned long)val;
26631da177e4SLinus Torvalds 		}
26641da177e4SLinus Torvalds 		*lvalp = lval / HZ;
26651da177e4SLinus Torvalds 	}
26661da177e4SLinus Torvalds 	return 0;
26671da177e4SLinus Torvalds }
26681da177e4SLinus Torvalds 
26691da177e4SLinus Torvalds static int do_proc_dointvec_userhz_jiffies_conv(int *negp, unsigned long *lvalp,
26701da177e4SLinus Torvalds 						int *valp,
26711da177e4SLinus Torvalds 						int write, void *data)
26721da177e4SLinus Torvalds {
26731da177e4SLinus Torvalds 	if (write) {
2674cba9f33dSBart Samwel 		if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
2675cba9f33dSBart Samwel 			return 1;
26761da177e4SLinus Torvalds 		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
26771da177e4SLinus Torvalds 	} else {
26781da177e4SLinus Torvalds 		int val = *valp;
26791da177e4SLinus Torvalds 		unsigned long lval;
26801da177e4SLinus Torvalds 		if (val < 0) {
26811da177e4SLinus Torvalds 			*negp = -1;
26821da177e4SLinus Torvalds 			lval = (unsigned long)-val;
26831da177e4SLinus Torvalds 		} else {
26841da177e4SLinus Torvalds 			*negp = 0;
26851da177e4SLinus Torvalds 			lval = (unsigned long)val;
26861da177e4SLinus Torvalds 		}
26871da177e4SLinus Torvalds 		*lvalp = jiffies_to_clock_t(lval);
26881da177e4SLinus Torvalds 	}
26891da177e4SLinus Torvalds 	return 0;
26901da177e4SLinus Torvalds }
26911da177e4SLinus Torvalds 
26921da177e4SLinus Torvalds static int do_proc_dointvec_ms_jiffies_conv(int *negp, unsigned long *lvalp,
26931da177e4SLinus Torvalds 					    int *valp,
26941da177e4SLinus Torvalds 					    int write, void *data)
26951da177e4SLinus Torvalds {
26961da177e4SLinus Torvalds 	if (write) {
26971da177e4SLinus Torvalds 		*valp = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
26981da177e4SLinus Torvalds 	} else {
26991da177e4SLinus Torvalds 		int val = *valp;
27001da177e4SLinus Torvalds 		unsigned long lval;
27011da177e4SLinus Torvalds 		if (val < 0) {
27021da177e4SLinus Torvalds 			*negp = -1;
27031da177e4SLinus Torvalds 			lval = (unsigned long)-val;
27041da177e4SLinus Torvalds 		} else {
27051da177e4SLinus Torvalds 			*negp = 0;
27061da177e4SLinus Torvalds 			lval = (unsigned long)val;
27071da177e4SLinus Torvalds 		}
27081da177e4SLinus Torvalds 		*lvalp = jiffies_to_msecs(lval);
27091da177e4SLinus Torvalds 	}
27101da177e4SLinus Torvalds 	return 0;
27111da177e4SLinus Torvalds }
27121da177e4SLinus Torvalds 
27131da177e4SLinus Torvalds /**
27141da177e4SLinus Torvalds  * proc_dointvec_jiffies - read a vector of integers as seconds
27151da177e4SLinus Torvalds  * @table: the sysctl table
27161da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
27171da177e4SLinus Torvalds  * @filp: the file structure
27181da177e4SLinus Torvalds  * @buffer: the user buffer
27191da177e4SLinus Torvalds  * @lenp: the size of the user buffer
27201da177e4SLinus Torvalds  * @ppos: file position
27211da177e4SLinus Torvalds  *
27221da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
27231da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
27241da177e4SLinus Torvalds  * The values read are assumed to be in seconds, and are converted into
27251da177e4SLinus Torvalds  * jiffies.
27261da177e4SLinus Torvalds  *
27271da177e4SLinus Torvalds  * Returns 0 on success.
27281da177e4SLinus Torvalds  */
2729d8217f07SEric W. Biederman int proc_dointvec_jiffies(struct ctl_table *table, int write, struct file *filp,
27301da177e4SLinus Torvalds 			  void __user *buffer, size_t *lenp, loff_t *ppos)
27311da177e4SLinus Torvalds {
27321da177e4SLinus Torvalds     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
27331da177e4SLinus Torvalds 		    	    do_proc_dointvec_jiffies_conv,NULL);
27341da177e4SLinus Torvalds }
27351da177e4SLinus Torvalds 
27361da177e4SLinus Torvalds /**
27371da177e4SLinus Torvalds  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
27381da177e4SLinus Torvalds  * @table: the sysctl table
27391da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
27401da177e4SLinus Torvalds  * @filp: the file structure
27411da177e4SLinus Torvalds  * @buffer: the user buffer
27421da177e4SLinus Torvalds  * @lenp: the size of the user buffer
27431e5d5331SRandy Dunlap  * @ppos: pointer to the file position
27441da177e4SLinus Torvalds  *
27451da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
27461da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
27471da177e4SLinus Torvalds  * The values read are assumed to be in 1/USER_HZ seconds, and
27481da177e4SLinus Torvalds  * are converted into jiffies.
27491da177e4SLinus Torvalds  *
27501da177e4SLinus Torvalds  * Returns 0 on success.
27511da177e4SLinus Torvalds  */
2752d8217f07SEric W. Biederman int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, struct file *filp,
27531da177e4SLinus Torvalds 				 void __user *buffer, size_t *lenp, loff_t *ppos)
27541da177e4SLinus Torvalds {
27551da177e4SLinus Torvalds     return do_proc_dointvec(table,write,filp,buffer,lenp,ppos,
27561da177e4SLinus Torvalds 		    	    do_proc_dointvec_userhz_jiffies_conv,NULL);
27571da177e4SLinus Torvalds }
27581da177e4SLinus Torvalds 
27591da177e4SLinus Torvalds /**
27601da177e4SLinus Torvalds  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
27611da177e4SLinus Torvalds  * @table: the sysctl table
27621da177e4SLinus Torvalds  * @write: %TRUE if this is a write to the sysctl file
27631da177e4SLinus Torvalds  * @filp: the file structure
27641da177e4SLinus Torvalds  * @buffer: the user buffer
27651da177e4SLinus Torvalds  * @lenp: the size of the user buffer
276667be2dd1SMartin Waitz  * @ppos: file position
276767be2dd1SMartin Waitz  * @ppos: the current position in the file
27681da177e4SLinus Torvalds  *
27691da177e4SLinus Torvalds  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
27701da177e4SLinus Torvalds  * values from/to the user buffer, treated as an ASCII string.
27711da177e4SLinus Torvalds  * The values read are assumed to be in 1/1000 seconds, and
27721da177e4SLinus Torvalds  * are converted into jiffies.
27731da177e4SLinus Torvalds  *
27741da177e4SLinus Torvalds  * Returns 0 on success.
27751da177e4SLinus Torvalds  */
2776d8217f07SEric W. Biederman int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, struct file *filp,
27771da177e4SLinus Torvalds 			     void __user *buffer, size_t *lenp, loff_t *ppos)
27781da177e4SLinus Torvalds {
27791da177e4SLinus Torvalds 	return do_proc_dointvec(table, write, filp, buffer, lenp, ppos,
27801da177e4SLinus Torvalds 				do_proc_dointvec_ms_jiffies_conv, NULL);
27811da177e4SLinus Torvalds }
27821da177e4SLinus Torvalds 
2783d8217f07SEric W. Biederman static int proc_do_cad_pid(struct ctl_table *table, int write, struct file *filp,
27849ec52099SCedric Le Goater 			   void __user *buffer, size_t *lenp, loff_t *ppos)
27859ec52099SCedric Le Goater {
27869ec52099SCedric Le Goater 	struct pid *new_pid;
27879ec52099SCedric Le Goater 	pid_t tmp;
27889ec52099SCedric Le Goater 	int r;
27899ec52099SCedric Le Goater 
27906c5f3e7bSPavel Emelyanov 	tmp = pid_vnr(cad_pid);
27919ec52099SCedric Le Goater 
27929ec52099SCedric Le Goater 	r = __do_proc_dointvec(&tmp, table, write, filp, buffer,
27939ec52099SCedric Le Goater 			       lenp, ppos, NULL, NULL);
27949ec52099SCedric Le Goater 	if (r || !write)
27959ec52099SCedric Le Goater 		return r;
27969ec52099SCedric Le Goater 
27979ec52099SCedric Le Goater 	new_pid = find_get_pid(tmp);
27989ec52099SCedric Le Goater 	if (!new_pid)
27999ec52099SCedric Le Goater 		return -ESRCH;
28009ec52099SCedric Le Goater 
28019ec52099SCedric Le Goater 	put_pid(xchg(&cad_pid, new_pid));
28029ec52099SCedric Le Goater 	return 0;
28039ec52099SCedric Le Goater }
28049ec52099SCedric Le Goater 
28051da177e4SLinus Torvalds #else /* CONFIG_PROC_FS */
28061da177e4SLinus Torvalds 
2807d8217f07SEric W. Biederman int proc_dostring(struct ctl_table *table, int write, struct file *filp,
28081da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
28091da177e4SLinus Torvalds {
28101da177e4SLinus Torvalds 	return -ENOSYS;
28111da177e4SLinus Torvalds }
28121da177e4SLinus Torvalds 
2813d8217f07SEric W. Biederman int proc_dointvec(struct ctl_table *table, int write, struct file *filp,
28141da177e4SLinus Torvalds 		  void __user *buffer, size_t *lenp, loff_t *ppos)
28151da177e4SLinus Torvalds {
28161da177e4SLinus Torvalds 	return -ENOSYS;
28171da177e4SLinus Torvalds }
28181da177e4SLinus Torvalds 
2819d8217f07SEric W. Biederman int proc_dointvec_minmax(struct ctl_table *table, int write, struct file *filp,
28201da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
28211da177e4SLinus Torvalds {
28221da177e4SLinus Torvalds 	return -ENOSYS;
28231da177e4SLinus Torvalds }
28241da177e4SLinus Torvalds 
2825d8217f07SEric W. Biederman int proc_dointvec_jiffies(struct ctl_table *table, int write, struct file *filp,
28261da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
28271da177e4SLinus Torvalds {
28281da177e4SLinus Torvalds 	return -ENOSYS;
28291da177e4SLinus Torvalds }
28301da177e4SLinus Torvalds 
2831d8217f07SEric W. Biederman int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write, struct file *filp,
28321da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
28331da177e4SLinus Torvalds {
28341da177e4SLinus Torvalds 	return -ENOSYS;
28351da177e4SLinus Torvalds }
28361da177e4SLinus Torvalds 
2837d8217f07SEric W. Biederman int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, struct file *filp,
28381da177e4SLinus Torvalds 			     void __user *buffer, size_t *lenp, loff_t *ppos)
28391da177e4SLinus Torvalds {
28401da177e4SLinus Torvalds 	return -ENOSYS;
28411da177e4SLinus Torvalds }
28421da177e4SLinus Torvalds 
2843d8217f07SEric W. Biederman int proc_doulongvec_minmax(struct ctl_table *table, int write, struct file *filp,
28441da177e4SLinus Torvalds 		    void __user *buffer, size_t *lenp, loff_t *ppos)
28451da177e4SLinus Torvalds {
28461da177e4SLinus Torvalds 	return -ENOSYS;
28471da177e4SLinus Torvalds }
28481da177e4SLinus Torvalds 
2849d8217f07SEric W. Biederman int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
28501da177e4SLinus Torvalds 				      struct file *filp,
28511da177e4SLinus Torvalds 				      void __user *buffer,
28521da177e4SLinus Torvalds 				      size_t *lenp, loff_t *ppos)
28531da177e4SLinus Torvalds {
28541da177e4SLinus Torvalds     return -ENOSYS;
28551da177e4SLinus Torvalds }
28561da177e4SLinus Torvalds 
28571da177e4SLinus Torvalds 
28581da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */
28591da177e4SLinus Torvalds 
28601da177e4SLinus Torvalds 
2861b89a8171SEric W. Biederman #ifdef CONFIG_SYSCTL_SYSCALL
28621da177e4SLinus Torvalds /*
28631da177e4SLinus Torvalds  * General sysctl support routines
28641da177e4SLinus Torvalds  */
28651da177e4SLinus Torvalds 
286649a0c458SEric W. Biederman /* The generic sysctl data routine (used if no strategy routine supplied) */
2867f221e726SAlexey Dobriyan int sysctl_data(struct ctl_table *table,
286849a0c458SEric W. Biederman 		void __user *oldval, size_t __user *oldlenp,
286949a0c458SEric W. Biederman 		void __user *newval, size_t newlen)
287049a0c458SEric W. Biederman {
287149a0c458SEric W. Biederman 	size_t len;
287249a0c458SEric W. Biederman 
287349a0c458SEric W. Biederman 	/* Get out of I don't have a variable */
287449a0c458SEric W. Biederman 	if (!table->data || !table->maxlen)
287549a0c458SEric W. Biederman 		return -ENOTDIR;
287649a0c458SEric W. Biederman 
287749a0c458SEric W. Biederman 	if (oldval && oldlenp) {
287849a0c458SEric W. Biederman 		if (get_user(len, oldlenp))
287949a0c458SEric W. Biederman 			return -EFAULT;
288049a0c458SEric W. Biederman 		if (len) {
288149a0c458SEric W. Biederman 			if (len > table->maxlen)
288249a0c458SEric W. Biederman 				len = table->maxlen;
288349a0c458SEric W. Biederman 			if (copy_to_user(oldval, table->data, len))
288449a0c458SEric W. Biederman 				return -EFAULT;
288549a0c458SEric W. Biederman 			if (put_user(len, oldlenp))
288649a0c458SEric W. Biederman 				return -EFAULT;
288749a0c458SEric W. Biederman 		}
288849a0c458SEric W. Biederman 	}
288949a0c458SEric W. Biederman 
289049a0c458SEric W. Biederman 	if (newval && newlen) {
289149a0c458SEric W. Biederman 		if (newlen > table->maxlen)
289249a0c458SEric W. Biederman 			newlen = table->maxlen;
289349a0c458SEric W. Biederman 
289449a0c458SEric W. Biederman 		if (copy_from_user(table->data, newval, newlen))
289549a0c458SEric W. Biederman 			return -EFAULT;
289649a0c458SEric W. Biederman 	}
289749a0c458SEric W. Biederman 	return 1;
289849a0c458SEric W. Biederman }
289949a0c458SEric W. Biederman 
29001da177e4SLinus Torvalds /* The generic string strategy routine: */
2901f221e726SAlexey Dobriyan int sysctl_string(struct ctl_table *table,
29021da177e4SLinus Torvalds 		  void __user *oldval, size_t __user *oldlenp,
29031f29bcd7SAlexey Dobriyan 		  void __user *newval, size_t newlen)
29041da177e4SLinus Torvalds {
29051da177e4SLinus Torvalds 	if (!table->data || !table->maxlen)
29061da177e4SLinus Torvalds 		return -ENOTDIR;
29071da177e4SLinus Torvalds 
29081da177e4SLinus Torvalds 	if (oldval && oldlenp) {
2909de9e007dSLinus Torvalds 		size_t bufsize;
2910de9e007dSLinus Torvalds 		if (get_user(bufsize, oldlenp))
29111da177e4SLinus Torvalds 			return -EFAULT;
2912de9e007dSLinus Torvalds 		if (bufsize) {
2913de9e007dSLinus Torvalds 			size_t len = strlen(table->data), copied;
2914de9e007dSLinus Torvalds 
2915de9e007dSLinus Torvalds 			/* This shouldn't trigger for a well-formed sysctl */
2916de9e007dSLinus Torvalds 			if (len > table->maxlen)
29171da177e4SLinus Torvalds 				len = table->maxlen;
2918de9e007dSLinus Torvalds 
2919de9e007dSLinus Torvalds 			/* Copy up to a max of bufsize-1 bytes of the string */
2920de9e007dSLinus Torvalds 			copied = (len >= bufsize) ? bufsize - 1 : len;
2921de9e007dSLinus Torvalds 
2922de9e007dSLinus Torvalds 			if (copy_to_user(oldval, table->data, copied) ||
2923de9e007dSLinus Torvalds 			    put_user(0, (char __user *)(oldval + copied)))
29241da177e4SLinus Torvalds 				return -EFAULT;
29251da177e4SLinus Torvalds 			if (put_user(len, oldlenp))
29261da177e4SLinus Torvalds 				return -EFAULT;
29271da177e4SLinus Torvalds 		}
29281da177e4SLinus Torvalds 	}
29291da177e4SLinus Torvalds 	if (newval && newlen) {
2930de9e007dSLinus Torvalds 		size_t len = newlen;
29311da177e4SLinus Torvalds 		if (len > table->maxlen)
29321da177e4SLinus Torvalds 			len = table->maxlen;
29331da177e4SLinus Torvalds 		if(copy_from_user(table->data, newval, len))
29341da177e4SLinus Torvalds 			return -EFAULT;
29351da177e4SLinus Torvalds 		if (len == table->maxlen)
29361da177e4SLinus Torvalds 			len--;
29371da177e4SLinus Torvalds 		((char *) table->data)[len] = 0;
29381da177e4SLinus Torvalds 	}
293982c9df82SYi Yang 	return 1;
29401da177e4SLinus Torvalds }
29411da177e4SLinus Torvalds 
29421da177e4SLinus Torvalds /*
29431da177e4SLinus Torvalds  * This function makes sure that all of the integers in the vector
29441da177e4SLinus Torvalds  * are between the minimum and maximum values given in the arrays
29451da177e4SLinus Torvalds  * table->extra1 and table->extra2, respectively.
29461da177e4SLinus Torvalds  */
2947f221e726SAlexey Dobriyan int sysctl_intvec(struct ctl_table *table,
29481da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
29491f29bcd7SAlexey Dobriyan 		void __user *newval, size_t newlen)
29501da177e4SLinus Torvalds {
29511da177e4SLinus Torvalds 
29521da177e4SLinus Torvalds 	if (newval && newlen) {
29531da177e4SLinus Torvalds 		int __user *vec = (int __user *) newval;
29541da177e4SLinus Torvalds 		int *min = (int *) table->extra1;
29551da177e4SLinus Torvalds 		int *max = (int *) table->extra2;
29561da177e4SLinus Torvalds 		size_t length;
29571da177e4SLinus Torvalds 		int i;
29581da177e4SLinus Torvalds 
29591da177e4SLinus Torvalds 		if (newlen % sizeof(int) != 0)
29601da177e4SLinus Torvalds 			return -EINVAL;
29611da177e4SLinus Torvalds 
29621da177e4SLinus Torvalds 		if (!table->extra1 && !table->extra2)
29631da177e4SLinus Torvalds 			return 0;
29641da177e4SLinus Torvalds 
29651da177e4SLinus Torvalds 		if (newlen > table->maxlen)
29661da177e4SLinus Torvalds 			newlen = table->maxlen;
29671da177e4SLinus Torvalds 		length = newlen / sizeof(int);
29681da177e4SLinus Torvalds 
29691da177e4SLinus Torvalds 		for (i = 0; i < length; i++) {
29701da177e4SLinus Torvalds 			int value;
29711da177e4SLinus Torvalds 			if (get_user(value, vec + i))
29721da177e4SLinus Torvalds 				return -EFAULT;
29731da177e4SLinus Torvalds 			if (min && value < min[i])
29741da177e4SLinus Torvalds 				return -EINVAL;
29751da177e4SLinus Torvalds 			if (max && value > max[i])
29761da177e4SLinus Torvalds 				return -EINVAL;
29771da177e4SLinus Torvalds 		}
29781da177e4SLinus Torvalds 	}
29791da177e4SLinus Torvalds 	return 0;
29801da177e4SLinus Torvalds }
29811da177e4SLinus Torvalds 
29821da177e4SLinus Torvalds /* Strategy function to convert jiffies to seconds */
2983f221e726SAlexey Dobriyan int sysctl_jiffies(struct ctl_table *table,
29841da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
29851f29bcd7SAlexey Dobriyan 		void __user *newval, size_t newlen)
29861da177e4SLinus Torvalds {
29873ee75ac3SAlexey Dobriyan 	if (oldval && oldlenp) {
29881da177e4SLinus Torvalds 		size_t olen;
29893ee75ac3SAlexey Dobriyan 
29901da177e4SLinus Torvalds 		if (get_user(olen, oldlenp))
29911da177e4SLinus Torvalds 			return -EFAULT;
29923ee75ac3SAlexey Dobriyan 		if (olen) {
29933ee75ac3SAlexey Dobriyan 			int val;
29943ee75ac3SAlexey Dobriyan 
29953ee75ac3SAlexey Dobriyan 			if (olen < sizeof(int))
29961da177e4SLinus Torvalds 				return -EINVAL;
29973ee75ac3SAlexey Dobriyan 
29983ee75ac3SAlexey Dobriyan 			val = *(int *)(table->data) / HZ;
29993ee75ac3SAlexey Dobriyan 			if (put_user(val, (int __user *)oldval))
30001da177e4SLinus Torvalds 				return -EFAULT;
30013ee75ac3SAlexey Dobriyan 			if (put_user(sizeof(int), oldlenp))
30023ee75ac3SAlexey Dobriyan 				return -EFAULT;
30033ee75ac3SAlexey Dobriyan 		}
30041da177e4SLinus Torvalds 	}
30051da177e4SLinus Torvalds 	if (newval && newlen) {
30061da177e4SLinus Torvalds 		int new;
30071da177e4SLinus Torvalds 		if (newlen != sizeof(int))
30081da177e4SLinus Torvalds 			return -EINVAL;
30091da177e4SLinus Torvalds 		if (get_user(new, (int __user *)newval))
30101da177e4SLinus Torvalds 			return -EFAULT;
30111da177e4SLinus Torvalds 		*(int *)(table->data) = new*HZ;
30121da177e4SLinus Torvalds 	}
30131da177e4SLinus Torvalds 	return 1;
30141da177e4SLinus Torvalds }
30151da177e4SLinus Torvalds 
30161da177e4SLinus Torvalds /* Strategy function to convert jiffies to seconds */
3017f221e726SAlexey Dobriyan int sysctl_ms_jiffies(struct ctl_table *table,
30181da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
30191f29bcd7SAlexey Dobriyan 		void __user *newval, size_t newlen)
30201da177e4SLinus Torvalds {
30213ee75ac3SAlexey Dobriyan 	if (oldval && oldlenp) {
30221da177e4SLinus Torvalds 		size_t olen;
30233ee75ac3SAlexey Dobriyan 
30241da177e4SLinus Torvalds 		if (get_user(olen, oldlenp))
30251da177e4SLinus Torvalds 			return -EFAULT;
30263ee75ac3SAlexey Dobriyan 		if (olen) {
30273ee75ac3SAlexey Dobriyan 			int val;
30283ee75ac3SAlexey Dobriyan 
30293ee75ac3SAlexey Dobriyan 			if (olen < sizeof(int))
30301da177e4SLinus Torvalds 				return -EINVAL;
30313ee75ac3SAlexey Dobriyan 
30323ee75ac3SAlexey Dobriyan 			val = jiffies_to_msecs(*(int *)(table->data));
30333ee75ac3SAlexey Dobriyan 			if (put_user(val, (int __user *)oldval))
30341da177e4SLinus Torvalds 				return -EFAULT;
30353ee75ac3SAlexey Dobriyan 			if (put_user(sizeof(int), oldlenp))
30363ee75ac3SAlexey Dobriyan 				return -EFAULT;
30373ee75ac3SAlexey Dobriyan 		}
30381da177e4SLinus Torvalds 	}
30391da177e4SLinus Torvalds 	if (newval && newlen) {
30401da177e4SLinus Torvalds 		int new;
30411da177e4SLinus Torvalds 		if (newlen != sizeof(int))
30421da177e4SLinus Torvalds 			return -EINVAL;
30431da177e4SLinus Torvalds 		if (get_user(new, (int __user *)newval))
30441da177e4SLinus Torvalds 			return -EFAULT;
30451da177e4SLinus Torvalds 		*(int *)(table->data) = msecs_to_jiffies(new);
30461da177e4SLinus Torvalds 	}
30471da177e4SLinus Torvalds 	return 1;
30481da177e4SLinus Torvalds }
30491da177e4SLinus Torvalds 
3050c4b8b769SEric W. Biederman 
3051c4b8b769SEric W. Biederman 
3052b89a8171SEric W. Biederman #else /* CONFIG_SYSCTL_SYSCALL */
30531da177e4SLinus Torvalds 
30541da177e4SLinus Torvalds 
30551e7bfb21SHeiko Carstens SYSCALL_DEFINE1(sysctl, struct __sysctl_args __user *, args)
30561da177e4SLinus Torvalds {
30570e009be8SEric W. Biederman 	struct __sysctl_args tmp;
30587058cb02SEric W. Biederman 	int error;
30590e009be8SEric W. Biederman 
30600e009be8SEric W. Biederman 	if (copy_from_user(&tmp, args, sizeof(tmp)))
30610e009be8SEric W. Biederman 		return -EFAULT;
30620e009be8SEric W. Biederman 
30637058cb02SEric W. Biederman 	error = deprecated_sysctl_warning(&tmp);
3064b89a8171SEric W. Biederman 
30657058cb02SEric W. Biederman 	/* If no error reading the parameters then just -ENOSYS ... */
30667058cb02SEric W. Biederman 	if (!error)
30677058cb02SEric W. Biederman 		error = -ENOSYS;
30687058cb02SEric W. Biederman 
30697058cb02SEric W. Biederman 	return error;
30701da177e4SLinus Torvalds }
30711da177e4SLinus Torvalds 
3072f221e726SAlexey Dobriyan int sysctl_data(struct ctl_table *table,
307349a0c458SEric W. Biederman 		  void __user *oldval, size_t __user *oldlenp,
307449a0c458SEric W. Biederman 		  void __user *newval, size_t newlen)
307549a0c458SEric W. Biederman {
307649a0c458SEric W. Biederman 	return -ENOSYS;
307749a0c458SEric W. Biederman }
307849a0c458SEric W. Biederman 
3079f221e726SAlexey Dobriyan int sysctl_string(struct ctl_table *table,
30801da177e4SLinus Torvalds 		  void __user *oldval, size_t __user *oldlenp,
30811f29bcd7SAlexey Dobriyan 		  void __user *newval, size_t newlen)
30821da177e4SLinus Torvalds {
30831da177e4SLinus Torvalds 	return -ENOSYS;
30841da177e4SLinus Torvalds }
30851da177e4SLinus Torvalds 
3086f221e726SAlexey Dobriyan int sysctl_intvec(struct ctl_table *table,
30871da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
30881f29bcd7SAlexey Dobriyan 		void __user *newval, size_t newlen)
30891da177e4SLinus Torvalds {
30901da177e4SLinus Torvalds 	return -ENOSYS;
30911da177e4SLinus Torvalds }
30921da177e4SLinus Torvalds 
3093f221e726SAlexey Dobriyan int sysctl_jiffies(struct ctl_table *table,
30941da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
30951f29bcd7SAlexey Dobriyan 		void __user *newval, size_t newlen)
30961da177e4SLinus Torvalds {
30971da177e4SLinus Torvalds 	return -ENOSYS;
30981da177e4SLinus Torvalds }
30991da177e4SLinus Torvalds 
3100f221e726SAlexey Dobriyan int sysctl_ms_jiffies(struct ctl_table *table,
31011da177e4SLinus Torvalds 		void __user *oldval, size_t __user *oldlenp,
31021f29bcd7SAlexey Dobriyan 		void __user *newval, size_t newlen)
31031da177e4SLinus Torvalds {
31041da177e4SLinus Torvalds 	return -ENOSYS;
31051da177e4SLinus Torvalds }
31061da177e4SLinus Torvalds 
3107b89a8171SEric W. Biederman #endif /* CONFIG_SYSCTL_SYSCALL */
31081da177e4SLinus Torvalds 
31097058cb02SEric W. Biederman static int deprecated_sysctl_warning(struct __sysctl_args *args)
31107058cb02SEric W. Biederman {
31117058cb02SEric W. Biederman 	static int msg_count;
31127058cb02SEric W. Biederman 	int name[CTL_MAXNAME];
31137058cb02SEric W. Biederman 	int i;
31147058cb02SEric W. Biederman 
31156fc48af8STetsuo Handa 	/* Check args->nlen. */
31166fc48af8STetsuo Handa 	if (args->nlen < 0 || args->nlen > CTL_MAXNAME)
31176fc48af8STetsuo Handa 		return -ENOTDIR;
31186fc48af8STetsuo Handa 
31197058cb02SEric W. Biederman 	/* Read in the sysctl name for better debug message logging */
31207058cb02SEric W. Biederman 	for (i = 0; i < args->nlen; i++)
31217058cb02SEric W. Biederman 		if (get_user(name[i], args->name + i))
31227058cb02SEric W. Biederman 			return -EFAULT;
31237058cb02SEric W. Biederman 
31247058cb02SEric W. Biederman 	/* Ignore accesses to kernel.version */
31257058cb02SEric W. Biederman 	if ((args->nlen == 2) && (name[0] == CTL_KERN) && (name[1] == KERN_VERSION))
31267058cb02SEric W. Biederman 		return 0;
31277058cb02SEric W. Biederman 
31287058cb02SEric W. Biederman 	if (msg_count < 5) {
31297058cb02SEric W. Biederman 		msg_count++;
31307058cb02SEric W. Biederman 		printk(KERN_INFO
31317058cb02SEric W. Biederman 			"warning: process `%s' used the deprecated sysctl "
31327058cb02SEric W. Biederman 			"system call with ", current->comm);
31337058cb02SEric W. Biederman 		for (i = 0; i < args->nlen; i++)
31347058cb02SEric W. Biederman 			printk("%d.", name[i]);
31357058cb02SEric W. Biederman 		printk("\n");
31367058cb02SEric W. Biederman 	}
31377058cb02SEric W. Biederman 	return 0;
31387058cb02SEric W. Biederman }
31397058cb02SEric W. Biederman 
31401da177e4SLinus Torvalds /*
31411da177e4SLinus Torvalds  * No sense putting this after each symbol definition, twice,
31421da177e4SLinus Torvalds  * exception granted :-)
31431da177e4SLinus Torvalds  */
31441da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec);
31451da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_jiffies);
31461da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_minmax);
31471da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
31481da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
31491da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dostring);
31501da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_minmax);
31511da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
31521da177e4SLinus Torvalds EXPORT_SYMBOL(register_sysctl_table);
315329e796fdSEric W. Biederman EXPORT_SYMBOL(register_sysctl_paths);
31541da177e4SLinus Torvalds EXPORT_SYMBOL(sysctl_intvec);
31551da177e4SLinus Torvalds EXPORT_SYMBOL(sysctl_jiffies);
31561da177e4SLinus Torvalds EXPORT_SYMBOL(sysctl_ms_jiffies);
31571da177e4SLinus Torvalds EXPORT_SYMBOL(sysctl_string);
315849a0c458SEric W. Biederman EXPORT_SYMBOL(sysctl_data);
31591da177e4SLinus Torvalds EXPORT_SYMBOL(unregister_sysctl_table);
3160