xref: /openbmc/linux/kernel/sysctl.c (revision 0ec9dc9bcba0a62b0844e54c1caf6b8b0bf6b5b4)
1457c8996SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds  * sysctl.c: General linux system control interface
41da177e4SLinus Torvalds  *
51da177e4SLinus Torvalds  * Begun 24 March 1995, Stephen Tweedie
61da177e4SLinus Torvalds  * Added /proc support, Dec 1995
71da177e4SLinus Torvalds  * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
81da177e4SLinus Torvalds  * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
91da177e4SLinus Torvalds  * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
101da177e4SLinus Torvalds  * Dynamic registration fixes, Stephen Tweedie.
111da177e4SLinus Torvalds  * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
121da177e4SLinus Torvalds  * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
131da177e4SLinus Torvalds  *  Horn.
141da177e4SLinus Torvalds  * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
151da177e4SLinus Torvalds  * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
161da177e4SLinus Torvalds  * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
171da177e4SLinus Torvalds  *  Wendling.
181da177e4SLinus Torvalds  * The list_for_each() macro wasn't appropriate for the sysctl loop.
191da177e4SLinus Torvalds  *  Removed it and replaced it with older style, 03/23/00, Bill Wendling
201da177e4SLinus Torvalds  */
211da177e4SLinus Torvalds 
221da177e4SLinus Torvalds #include <linux/module.h>
23e2e40f2cSChristoph Hellwig #include <linux/aio.h>
241da177e4SLinus Torvalds #include <linux/mm.h>
251da177e4SLinus Torvalds #include <linux/swap.h>
261da177e4SLinus Torvalds #include <linux/slab.h>
271da177e4SLinus Torvalds #include <linux/sysctl.h>
285a04cca6SAkinobu Mita #include <linux/bitmap.h>
29d33ed52dSDave Young #include <linux/signal.h>
30455cd5abSDan Rosenberg #include <linux/printk.h>
311da177e4SLinus Torvalds #include <linux/proc_fs.h>
3272c2d582SAndrew Morgan #include <linux/security.h>
331da177e4SLinus Torvalds #include <linux/ctype.h>
34fd4b616bSSteven Rostedt #include <linux/kmemleak.h>
3562239ac2SAdrian Bunk #include <linux/fs.h>
361da177e4SLinus Torvalds #include <linux/init.h>
371da177e4SLinus Torvalds #include <linux/kernel.h>
380296b228SKay Sievers #include <linux/kobject.h>
3920380731SArnaldo Carvalho de Melo #include <linux/net.h>
401da177e4SLinus Torvalds #include <linux/sysrq.h>
411da177e4SLinus Torvalds #include <linux/highuid.h>
421da177e4SLinus Torvalds #include <linux/writeback.h>
433fff4c42SIngo Molnar #include <linux/ratelimit.h>
4476ab0f53SMel Gorman #include <linux/compaction.h>
451da177e4SLinus Torvalds #include <linux/hugetlb.h>
461da177e4SLinus Torvalds #include <linux/initrd.h>
470b77f5bfSDavid Howells #include <linux/key.h>
481da177e4SLinus Torvalds #include <linux/times.h>
491da177e4SLinus Torvalds #include <linux/limits.h>
501da177e4SLinus Torvalds #include <linux/dcache.h>
516e006701SAlexey Dobriyan #include <linux/dnotify.h>
521da177e4SLinus Torvalds #include <linux/syscalls.h>
53c748e134SAdrian Bunk #include <linux/vmstat.h>
54c255d844SPavel Machek #include <linux/nfs_fs.h>
55c255d844SPavel Machek #include <linux/acpi.h>
5610a0a8d4SJeremy Fitzhardinge #include <linux/reboot.h>
57b0fc494fSSteven Rostedt #include <linux/ftrace.h>
58cdd6c482SIngo Molnar #include <linux/perf_event.h>
59b2be84dfSMasami Hiramatsu #include <linux/kprobes.h>
60b492e95bSJens Axboe #include <linux/pipe_fs_i.h>
618e4228e1SDavid Rientjes #include <linux/oom.h>
6217f60a7dSEric Paris #include <linux/kmod.h>
6373efc039SDan Ballard #include <linux/capability.h>
6440401530SAl Viro #include <linux/binfmts.h>
65cf4aebc2SClark Williams #include <linux/sched/sysctl.h>
66f7ccbae4SIngo Molnar #include <linux/sched/coredump.h>
677984754bSKees Cook #include <linux/kexec.h>
681be7f75dSAlexei Starovoitov #include <linux/bpf.h>
69d2921684SEric W. Biederman #include <linux/mount.h>
70cefdca0aSPeter Xu #include <linux/userfaultfd_k.h>
712374c09bSChristoph Hellwig #include <linux/coredump.h>
722374c09bSChristoph Hellwig #include <linux/latencytop.h>
732374c09bSChristoph Hellwig #include <linux/pid.h>
741da177e4SLinus Torvalds 
757f2923c4SChristian Brauner #include "../lib/kstrtox.h"
767f2923c4SChristian Brauner 
777c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
781da177e4SLinus Torvalds #include <asm/processor.h>
791da177e4SLinus Torvalds 
8029cbc78bSAndi Kleen #ifdef CONFIG_X86
8129cbc78bSAndi Kleen #include <asm/nmi.h>
820741f4d2SChuck Ebbert #include <asm/stacktrace.h>
836e7c4025SIngo Molnar #include <asm/io.h>
8429cbc78bSAndi Kleen #endif
85d550bbd4SDavid Howells #ifdef CONFIG_SPARC
86d550bbd4SDavid Howells #include <asm/setup.h>
87d550bbd4SDavid Howells #endif
88c55b7c3eSDave Young #ifdef CONFIG_BSD_PROCESS_ACCT
89c55b7c3eSDave Young #include <linux/acct.h>
90c55b7c3eSDave Young #endif
914f0e056fSDave Young #ifdef CONFIG_RT_MUTEXES
924f0e056fSDave Young #include <linux/rtmutex.h>
934f0e056fSDave Young #endif
942edf5e49SDave Young #if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_LOCK_STAT)
952edf5e49SDave Young #include <linux/lockdep.h>
962edf5e49SDave Young #endif
9715485a46SDave Young #ifdef CONFIG_CHR_DEV_SG
9815485a46SDave Young #include <scsi/sg.h>
9915485a46SDave Young #endif
100964c9dffSAlexander Popov #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
101964c9dffSAlexander Popov #include <linux/stackleak.h>
102964c9dffSAlexander Popov #endif
10358687acbSDon Zickus #ifdef CONFIG_LOCKUP_DETECTOR
104504d7cf1SDon Zickus #include <linux/nmi.h>
105504d7cf1SDon Zickus #endif
106504d7cf1SDon Zickus 
1071da177e4SLinus Torvalds #if defined(CONFIG_SYSCTL)
1081da177e4SLinus Torvalds 
109c4f3b63fSRavikiran G Thirumalai /* Constants used for minimum and  maximum */
1102508ce18SDon Zickus #ifdef CONFIG_LOCKUP_DETECTOR
111c4f3b63fSRavikiran G Thirumalai static int sixty = 60;
112c4f3b63fSRavikiran G Thirumalai #endif
113c4f3b63fSRavikiran G Thirumalai 
114270750dbSAaron Tomlin static int __maybe_unused neg_one = -1;
115cd5f9a4cSLinus Torvalds static int __maybe_unused two = 2;
1165509a5d2SDave Hansen static int __maybe_unused four = 4;
1179002b214SWill Deacon static unsigned long zero_ul;
118fc3501d4SSven Wegener static unsigned long one_ul = 1;
11932a5ad9cSChristian Brauner static unsigned long long_max = LONG_MAX;
120c4f3b63fSRavikiran G Thirumalai static int one_hundred = 100;
121c843966cSJohannes Weiner static int two_hundred = 200;
122795ae7a0SJohannes Weiner static int one_thousand = 1000;
123af91322eSDave Young #ifdef CONFIG_PRINTK
124af91322eSDave Young static int ten_thousand = 10000;
125af91322eSDave Young #endif
126c5dfd78eSArnaldo Carvalho de Melo #ifdef CONFIG_PERF_EVENTS
127c5dfd78eSArnaldo Carvalho de Melo static int six_hundred_forty_kb = 640 * 1024;
128c5dfd78eSArnaldo Carvalho de Melo #endif
129c4f3b63fSRavikiran G Thirumalai 
1309e4a5bdaSAndrea Righi /* this is needed for the proc_doulongvec_minmax of vm_dirty_bytes */
1319e4a5bdaSAndrea Righi static unsigned long dirty_bytes_min = 2 * PAGE_SIZE;
1329e4a5bdaSAndrea Righi 
1331da177e4SLinus Torvalds /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID */
1341da177e4SLinus Torvalds static int maxolduid = 65535;
1351da177e4SLinus Torvalds static int minolduid;
1361da177e4SLinus Torvalds 
1371da177e4SLinus Torvalds static int ngroups_max = NGROUPS_MAX;
13873efc039SDan Ballard static const int cap_last_cap = CAP_LAST_CAP;
1391da177e4SLinus Torvalds 
140a2e51445SDmitry Vyukov /*
141a2e51445SDmitry Vyukov  * This is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs
142a2e51445SDmitry Vyukov  * and hung_task_check_interval_secs
143a2e51445SDmitry Vyukov  */
14480df2847SLiu Hua #ifdef CONFIG_DETECT_HUNG_TASK
14580df2847SLiu Hua static unsigned long hung_task_timeout_max = (LONG_MAX/HZ);
14680df2847SLiu Hua #endif
14780df2847SLiu Hua 
148d14f1729SDave Young #ifdef CONFIG_INOTIFY_USER
149d14f1729SDave Young #include <linux/inotify.h>
150d14f1729SDave Young #endif
151b6fca725SVineet Gupta 
152d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL
153f4aacea2SKees Cook 
154a19ac337SLuis R. Rodriguez /**
155a19ac337SLuis R. Rodriguez  * enum sysctl_writes_mode - supported sysctl write modes
156a19ac337SLuis R. Rodriguez  *
157a19ac337SLuis R. Rodriguez  * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
158a19ac337SLuis R. Rodriguez  *	to be written, and multiple writes on the same sysctl file descriptor
159a19ac337SLuis R. Rodriguez  *	will rewrite the sysctl value, regardless of file position. No warning
160a19ac337SLuis R. Rodriguez  *	is issued when the initial position is not 0.
161a19ac337SLuis R. Rodriguez  * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
162a19ac337SLuis R. Rodriguez  *	not 0.
163a19ac337SLuis R. Rodriguez  * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
164a19ac337SLuis R. Rodriguez  *	file position 0 and the value must be fully contained in the buffer
165a19ac337SLuis R. Rodriguez  *	sent to the write syscall. If dealing with strings respect the file
166a19ac337SLuis R. Rodriguez  *	position, but restrict this to the max length of the buffer, anything
16765f50f25SWeitao Hou  *	passed the max length will be ignored. Multiple writes will append
168a19ac337SLuis R. Rodriguez  *	to the buffer.
169a19ac337SLuis R. Rodriguez  *
170a19ac337SLuis R. Rodriguez  * These write modes control how current file position affects the behavior of
171a19ac337SLuis R. Rodriguez  * updating sysctl values through the proc interface on each write.
172a19ac337SLuis R. Rodriguez  */
173a19ac337SLuis R. Rodriguez enum sysctl_writes_mode {
174a19ac337SLuis R. Rodriguez 	SYSCTL_WRITES_LEGACY		= -1,
175a19ac337SLuis R. Rodriguez 	SYSCTL_WRITES_WARN		= 0,
176a19ac337SLuis R. Rodriguez 	SYSCTL_WRITES_STRICT		= 1,
177a19ac337SLuis R. Rodriguez };
178f4aacea2SKees Cook 
179a19ac337SLuis R. Rodriguez static enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT;
180f461d2dcSChristoph Hellwig #endif /* CONFIG_PROC_SYSCTL */
181ceb18132SLuis R. Rodriguez 
18267f3977fSAlexandre Ghiti #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
18367f3977fSAlexandre Ghiti     defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
1841da177e4SLinus Torvalds int sysctl_legacy_va_layout;
1851da177e4SLinus Torvalds #endif
1861da177e4SLinus Torvalds 
18777e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG
18873c4efd2SEric Dumazet static int min_sched_granularity_ns = 100000;		/* 100 usecs */
18973c4efd2SEric Dumazet static int max_sched_granularity_ns = NSEC_PER_SEC;	/* 1 second */
19073c4efd2SEric Dumazet static int min_wakeup_granularity_ns;			/* 0 usecs */
19173c4efd2SEric Dumazet static int max_wakeup_granularity_ns = NSEC_PER_SEC;	/* 1 second */
192cbee9f88SPeter Zijlstra #ifdef CONFIG_SMP
1931983a922SChristian Ehrhardt static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE;
1941983a922SChristian Ehrhardt static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1;
195cbee9f88SPeter Zijlstra #endif /* CONFIG_SMP */
196cbee9f88SPeter Zijlstra #endif /* CONFIG_SCHED_DEBUG */
19777e54a1fSIngo Molnar 
1985e771905SMel Gorman #ifdef CONFIG_COMPACTION
1995e771905SMel Gorman static int min_extfrag_threshold;
2005e771905SMel Gorman static int max_extfrag_threshold = 1000;
2015e771905SMel Gorman #endif
2025e771905SMel Gorman 
203f461d2dcSChristoph Hellwig #endif /* CONFIG_SYSCTL */
204f461d2dcSChristoph Hellwig 
2055447e8e0SArnd Bergmann #if defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_SYSCTL)
206d46edd67SSong Liu static int bpf_stats_handler(struct ctl_table *table, int write,
207d46edd67SSong Liu 			     void __user *buffer, size_t *lenp,
208d46edd67SSong Liu 			     loff_t *ppos)
209d46edd67SSong Liu {
210d46edd67SSong Liu 	struct static_key *key = (struct static_key *)table->data;
211d46edd67SSong Liu 	static int saved_val;
212d46edd67SSong Liu 	int val, ret;
213d46edd67SSong Liu 	struct ctl_table tmp = {
214d46edd67SSong Liu 		.data   = &val,
215d46edd67SSong Liu 		.maxlen = sizeof(val),
216d46edd67SSong Liu 		.mode   = table->mode,
217d46edd67SSong Liu 		.extra1 = SYSCTL_ZERO,
218d46edd67SSong Liu 		.extra2 = SYSCTL_ONE,
219d46edd67SSong Liu 	};
220d46edd67SSong Liu 
221d46edd67SSong Liu 	if (write && !capable(CAP_SYS_ADMIN))
222d46edd67SSong Liu 		return -EPERM;
223d46edd67SSong Liu 
224d46edd67SSong Liu 	mutex_lock(&bpf_stats_enabled_mutex);
225d46edd67SSong Liu 	val = saved_val;
226d46edd67SSong Liu 	ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
227d46edd67SSong Liu 	if (write && !ret && val != saved_val) {
228d46edd67SSong Liu 		if (val)
229d46edd67SSong Liu 			static_key_slow_inc(key);
230d46edd67SSong Liu 		else
231d46edd67SSong Liu 			static_key_slow_dec(key);
232d46edd67SSong Liu 		saved_val = val;
233d46edd67SSong Liu 	}
234d46edd67SSong Liu 	mutex_unlock(&bpf_stats_enabled_mutex);
235d46edd67SSong Liu 	return ret;
236d46edd67SSong Liu }
237d46edd67SSong Liu #endif
238d46edd67SSong Liu 
239f461d2dcSChristoph Hellwig /*
240f461d2dcSChristoph Hellwig  * /proc/sys support
241f461d2dcSChristoph Hellwig  */
242f461d2dcSChristoph Hellwig 
243f461d2dcSChristoph Hellwig #ifdef CONFIG_PROC_SYSCTL
244f461d2dcSChristoph Hellwig 
245f461d2dcSChristoph Hellwig static int _proc_do_string(char *data, int maxlen, int write,
24632927393SChristoph Hellwig 		char *buffer, size_t *lenp, loff_t *ppos)
247f461d2dcSChristoph Hellwig {
248f461d2dcSChristoph Hellwig 	size_t len;
24932927393SChristoph Hellwig 	char c, *p;
250f461d2dcSChristoph Hellwig 
251f461d2dcSChristoph Hellwig 	if (!data || !maxlen || !*lenp) {
252f461d2dcSChristoph Hellwig 		*lenp = 0;
253f461d2dcSChristoph Hellwig 		return 0;
254f461d2dcSChristoph Hellwig 	}
255f461d2dcSChristoph Hellwig 
256f461d2dcSChristoph Hellwig 	if (write) {
257f461d2dcSChristoph Hellwig 		if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
258f461d2dcSChristoph Hellwig 			/* Only continue writes not past the end of buffer. */
259f461d2dcSChristoph Hellwig 			len = strlen(data);
260f461d2dcSChristoph Hellwig 			if (len > maxlen - 1)
261f461d2dcSChristoph Hellwig 				len = maxlen - 1;
262f461d2dcSChristoph Hellwig 
263f461d2dcSChristoph Hellwig 			if (*ppos > len)
264f461d2dcSChristoph Hellwig 				return 0;
265f461d2dcSChristoph Hellwig 			len = *ppos;
266f461d2dcSChristoph Hellwig 		} else {
267f461d2dcSChristoph Hellwig 			/* Start writing from beginning of buffer. */
268f461d2dcSChristoph Hellwig 			len = 0;
269f461d2dcSChristoph Hellwig 		}
270f461d2dcSChristoph Hellwig 
271f461d2dcSChristoph Hellwig 		*ppos += *lenp;
272f461d2dcSChristoph Hellwig 		p = buffer;
273f461d2dcSChristoph Hellwig 		while ((p - buffer) < *lenp && len < maxlen - 1) {
27432927393SChristoph Hellwig 			c = *(p++);
275f461d2dcSChristoph Hellwig 			if (c == 0 || c == '\n')
276f461d2dcSChristoph Hellwig 				break;
277f461d2dcSChristoph Hellwig 			data[len++] = c;
278f461d2dcSChristoph Hellwig 		}
279f461d2dcSChristoph Hellwig 		data[len] = 0;
280f461d2dcSChristoph Hellwig 	} else {
281f461d2dcSChristoph Hellwig 		len = strlen(data);
282f461d2dcSChristoph Hellwig 		if (len > maxlen)
283f461d2dcSChristoph Hellwig 			len = maxlen;
284f461d2dcSChristoph Hellwig 
285f461d2dcSChristoph Hellwig 		if (*ppos > len) {
286f461d2dcSChristoph Hellwig 			*lenp = 0;
287f461d2dcSChristoph Hellwig 			return 0;
288f461d2dcSChristoph Hellwig 		}
289f461d2dcSChristoph Hellwig 
290f461d2dcSChristoph Hellwig 		data += *ppos;
291f461d2dcSChristoph Hellwig 		len  -= *ppos;
292f461d2dcSChristoph Hellwig 
293f461d2dcSChristoph Hellwig 		if (len > *lenp)
294f461d2dcSChristoph Hellwig 			len = *lenp;
295f461d2dcSChristoph Hellwig 		if (len)
29632927393SChristoph Hellwig 			memcpy(buffer, data, len);
297f461d2dcSChristoph Hellwig 		if (len < *lenp) {
29832927393SChristoph Hellwig 			buffer[len] = '\n';
299f461d2dcSChristoph Hellwig 			len++;
300f461d2dcSChristoph Hellwig 		}
301f461d2dcSChristoph Hellwig 		*lenp = len;
302f461d2dcSChristoph Hellwig 		*ppos += len;
303f461d2dcSChristoph Hellwig 	}
304f461d2dcSChristoph Hellwig 	return 0;
305f461d2dcSChristoph Hellwig }
306f461d2dcSChristoph Hellwig 
307f461d2dcSChristoph Hellwig static void warn_sysctl_write(struct ctl_table *table)
308f461d2dcSChristoph Hellwig {
309f461d2dcSChristoph Hellwig 	pr_warn_once("%s wrote to %s when file position was not 0!\n"
310f461d2dcSChristoph Hellwig 		"This will not be supported in the future. To silence this\n"
311f461d2dcSChristoph Hellwig 		"warning, set kernel.sysctl_writes_strict = -1\n",
312f461d2dcSChristoph Hellwig 		current->comm, table->procname);
313f461d2dcSChristoph Hellwig }
314f461d2dcSChristoph Hellwig 
315f461d2dcSChristoph Hellwig /**
316f461d2dcSChristoph Hellwig  * proc_first_pos_non_zero_ignore - check if first position is allowed
317f461d2dcSChristoph Hellwig  * @ppos: file position
318f461d2dcSChristoph Hellwig  * @table: the sysctl table
319f461d2dcSChristoph Hellwig  *
320f461d2dcSChristoph Hellwig  * Returns true if the first position is non-zero and the sysctl_writes_strict
321f461d2dcSChristoph Hellwig  * mode indicates this is not allowed for numeric input types. String proc
322f461d2dcSChristoph Hellwig  * handlers can ignore the return value.
323f461d2dcSChristoph Hellwig  */
324f461d2dcSChristoph Hellwig static bool proc_first_pos_non_zero_ignore(loff_t *ppos,
325f461d2dcSChristoph Hellwig 					   struct ctl_table *table)
326f461d2dcSChristoph Hellwig {
327f461d2dcSChristoph Hellwig 	if (!*ppos)
328f461d2dcSChristoph Hellwig 		return false;
329f461d2dcSChristoph Hellwig 
330f461d2dcSChristoph Hellwig 	switch (sysctl_writes_strict) {
331f461d2dcSChristoph Hellwig 	case SYSCTL_WRITES_STRICT:
332f461d2dcSChristoph Hellwig 		return true;
333f461d2dcSChristoph Hellwig 	case SYSCTL_WRITES_WARN:
334f461d2dcSChristoph Hellwig 		warn_sysctl_write(table);
335f461d2dcSChristoph Hellwig 		return false;
336f461d2dcSChristoph Hellwig 	default:
337f461d2dcSChristoph Hellwig 		return false;
338f461d2dcSChristoph Hellwig 	}
339f461d2dcSChristoph Hellwig }
340f461d2dcSChristoph Hellwig 
341f461d2dcSChristoph Hellwig /**
342f461d2dcSChristoph Hellwig  * proc_dostring - read a string sysctl
343f461d2dcSChristoph Hellwig  * @table: the sysctl table
344f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
345f461d2dcSChristoph Hellwig  * @buffer: the user buffer
346f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
347f461d2dcSChristoph Hellwig  * @ppos: file position
348f461d2dcSChristoph Hellwig  *
349f461d2dcSChristoph Hellwig  * Reads/writes a string from/to the user buffer. If the kernel
350f461d2dcSChristoph Hellwig  * buffer provided is not large enough to hold the string, the
351f461d2dcSChristoph Hellwig  * string is truncated. The copied string is %NULL-terminated.
352f461d2dcSChristoph Hellwig  * If the string is being read by the user process, it is copied
353f461d2dcSChristoph Hellwig  * and a newline '\n' is added. It is truncated if the buffer is
354f461d2dcSChristoph Hellwig  * not large enough.
355f461d2dcSChristoph Hellwig  *
356f461d2dcSChristoph Hellwig  * Returns 0 on success.
357f461d2dcSChristoph Hellwig  */
358f461d2dcSChristoph Hellwig int proc_dostring(struct ctl_table *table, int write,
35932927393SChristoph Hellwig 		  void *buffer, size_t *lenp, loff_t *ppos)
360f461d2dcSChristoph Hellwig {
361f461d2dcSChristoph Hellwig 	if (write)
362f461d2dcSChristoph Hellwig 		proc_first_pos_non_zero_ignore(ppos, table);
363f461d2dcSChristoph Hellwig 
36432927393SChristoph Hellwig 	return _proc_do_string(table->data, table->maxlen, write, buffer, lenp,
36532927393SChristoph Hellwig 			ppos);
366f461d2dcSChristoph Hellwig }
367f461d2dcSChristoph Hellwig 
368f461d2dcSChristoph Hellwig static size_t proc_skip_spaces(char **buf)
369f461d2dcSChristoph Hellwig {
370f461d2dcSChristoph Hellwig 	size_t ret;
371f461d2dcSChristoph Hellwig 	char *tmp = skip_spaces(*buf);
372f461d2dcSChristoph Hellwig 	ret = tmp - *buf;
373f461d2dcSChristoph Hellwig 	*buf = tmp;
374f461d2dcSChristoph Hellwig 	return ret;
375f461d2dcSChristoph Hellwig }
376f461d2dcSChristoph Hellwig 
377f461d2dcSChristoph Hellwig static void proc_skip_char(char **buf, size_t *size, const char v)
378f461d2dcSChristoph Hellwig {
379f461d2dcSChristoph Hellwig 	while (*size) {
380f461d2dcSChristoph Hellwig 		if (**buf != v)
381f461d2dcSChristoph Hellwig 			break;
382f461d2dcSChristoph Hellwig 		(*size)--;
383f461d2dcSChristoph Hellwig 		(*buf)++;
384f461d2dcSChristoph Hellwig 	}
385f461d2dcSChristoph Hellwig }
386f461d2dcSChristoph Hellwig 
387f461d2dcSChristoph Hellwig /**
388f461d2dcSChristoph Hellwig  * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
389f461d2dcSChristoph Hellwig  *                   fail on overflow
390f461d2dcSChristoph Hellwig  *
391f461d2dcSChristoph Hellwig  * @cp: kernel buffer containing the string to parse
392f461d2dcSChristoph Hellwig  * @endp: pointer to store the trailing characters
393f461d2dcSChristoph Hellwig  * @base: the base to use
394f461d2dcSChristoph Hellwig  * @res: where the parsed integer will be stored
395f461d2dcSChristoph Hellwig  *
396f461d2dcSChristoph Hellwig  * In case of success 0 is returned and @res will contain the parsed integer,
397f461d2dcSChristoph Hellwig  * @endp will hold any trailing characters.
398f461d2dcSChristoph Hellwig  * This function will fail the parse on overflow. If there wasn't an overflow
399f461d2dcSChristoph Hellwig  * the function will defer the decision what characters count as invalid to the
400f461d2dcSChristoph Hellwig  * caller.
401f461d2dcSChristoph Hellwig  */
402f461d2dcSChristoph Hellwig static int strtoul_lenient(const char *cp, char **endp, unsigned int base,
403f461d2dcSChristoph Hellwig 			   unsigned long *res)
404f461d2dcSChristoph Hellwig {
405f461d2dcSChristoph Hellwig 	unsigned long long result;
406f461d2dcSChristoph Hellwig 	unsigned int rv;
407f461d2dcSChristoph Hellwig 
408f461d2dcSChristoph Hellwig 	cp = _parse_integer_fixup_radix(cp, &base);
409f461d2dcSChristoph Hellwig 	rv = _parse_integer(cp, base, &result);
410f461d2dcSChristoph Hellwig 	if ((rv & KSTRTOX_OVERFLOW) || (result != (unsigned long)result))
411f461d2dcSChristoph Hellwig 		return -ERANGE;
412f461d2dcSChristoph Hellwig 
413f461d2dcSChristoph Hellwig 	cp += rv;
414f461d2dcSChristoph Hellwig 
415f461d2dcSChristoph Hellwig 	if (endp)
416f461d2dcSChristoph Hellwig 		*endp = (char *)cp;
417f461d2dcSChristoph Hellwig 
418f461d2dcSChristoph Hellwig 	*res = (unsigned long)result;
419f461d2dcSChristoph Hellwig 	return 0;
420f461d2dcSChristoph Hellwig }
421f461d2dcSChristoph Hellwig 
422f461d2dcSChristoph Hellwig #define TMPBUFLEN 22
423f461d2dcSChristoph Hellwig /**
424f461d2dcSChristoph Hellwig  * proc_get_long - reads an ASCII formatted integer from a user buffer
425f461d2dcSChristoph Hellwig  *
426f461d2dcSChristoph Hellwig  * @buf: a kernel buffer
427f461d2dcSChristoph Hellwig  * @size: size of the kernel buffer
428f461d2dcSChristoph Hellwig  * @val: this is where the number will be stored
429f461d2dcSChristoph Hellwig  * @neg: set to %TRUE if number is negative
430f461d2dcSChristoph Hellwig  * @perm_tr: a vector which contains the allowed trailers
431f461d2dcSChristoph Hellwig  * @perm_tr_len: size of the perm_tr vector
432f461d2dcSChristoph Hellwig  * @tr: pointer to store the trailer character
433f461d2dcSChristoph Hellwig  *
434f461d2dcSChristoph Hellwig  * In case of success %0 is returned and @buf and @size are updated with
435f461d2dcSChristoph Hellwig  * the amount of bytes read. If @tr is non-NULL and a trailing
436f461d2dcSChristoph Hellwig  * character exists (size is non-zero after returning from this
437f461d2dcSChristoph Hellwig  * function), @tr is updated with the trailing character.
438f461d2dcSChristoph Hellwig  */
439f461d2dcSChristoph Hellwig static int proc_get_long(char **buf, size_t *size,
440f461d2dcSChristoph Hellwig 			  unsigned long *val, bool *neg,
441f461d2dcSChristoph Hellwig 			  const char *perm_tr, unsigned perm_tr_len, char *tr)
442f461d2dcSChristoph Hellwig {
443f461d2dcSChristoph Hellwig 	int len;
444f461d2dcSChristoph Hellwig 	char *p, tmp[TMPBUFLEN];
445f461d2dcSChristoph Hellwig 
446f461d2dcSChristoph Hellwig 	if (!*size)
447f461d2dcSChristoph Hellwig 		return -EINVAL;
448f461d2dcSChristoph Hellwig 
449f461d2dcSChristoph Hellwig 	len = *size;
450f461d2dcSChristoph Hellwig 	if (len > TMPBUFLEN - 1)
451f461d2dcSChristoph Hellwig 		len = TMPBUFLEN - 1;
452f461d2dcSChristoph Hellwig 
453f461d2dcSChristoph Hellwig 	memcpy(tmp, *buf, len);
454f461d2dcSChristoph Hellwig 
455f461d2dcSChristoph Hellwig 	tmp[len] = 0;
456f461d2dcSChristoph Hellwig 	p = tmp;
457f461d2dcSChristoph Hellwig 	if (*p == '-' && *size > 1) {
458f461d2dcSChristoph Hellwig 		*neg = true;
459f461d2dcSChristoph Hellwig 		p++;
460f461d2dcSChristoph Hellwig 	} else
461f461d2dcSChristoph Hellwig 		*neg = false;
462f461d2dcSChristoph Hellwig 	if (!isdigit(*p))
463f461d2dcSChristoph Hellwig 		return -EINVAL;
464f461d2dcSChristoph Hellwig 
465f461d2dcSChristoph Hellwig 	if (strtoul_lenient(p, &p, 0, val))
466f461d2dcSChristoph Hellwig 		return -EINVAL;
467f461d2dcSChristoph Hellwig 
468f461d2dcSChristoph Hellwig 	len = p - tmp;
469f461d2dcSChristoph Hellwig 
470f461d2dcSChristoph Hellwig 	/* We don't know if the next char is whitespace thus we may accept
471f461d2dcSChristoph Hellwig 	 * invalid integers (e.g. 1234...a) or two integers instead of one
472f461d2dcSChristoph Hellwig 	 * (e.g. 123...1). So lets not allow such large numbers. */
473f461d2dcSChristoph Hellwig 	if (len == TMPBUFLEN - 1)
474f461d2dcSChristoph Hellwig 		return -EINVAL;
475f461d2dcSChristoph Hellwig 
476f461d2dcSChristoph Hellwig 	if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
477f461d2dcSChristoph Hellwig 		return -EINVAL;
478f461d2dcSChristoph Hellwig 
479f461d2dcSChristoph Hellwig 	if (tr && (len < *size))
480f461d2dcSChristoph Hellwig 		*tr = *p;
481f461d2dcSChristoph Hellwig 
482f461d2dcSChristoph Hellwig 	*buf += len;
483f461d2dcSChristoph Hellwig 	*size -= len;
484f461d2dcSChristoph Hellwig 
485f461d2dcSChristoph Hellwig 	return 0;
486f461d2dcSChristoph Hellwig }
487f461d2dcSChristoph Hellwig 
488f461d2dcSChristoph Hellwig /**
489f461d2dcSChristoph Hellwig  * proc_put_long - converts an integer to a decimal ASCII formatted string
490f461d2dcSChristoph Hellwig  *
491f461d2dcSChristoph Hellwig  * @buf: the user buffer
492f461d2dcSChristoph Hellwig  * @size: the size of the user buffer
493f461d2dcSChristoph Hellwig  * @val: the integer to be converted
494f461d2dcSChristoph Hellwig  * @neg: sign of the number, %TRUE for negative
495f461d2dcSChristoph Hellwig  *
49632927393SChristoph Hellwig  * In case of success @buf and @size are updated with the amount of bytes
49732927393SChristoph Hellwig  * written.
498f461d2dcSChristoph Hellwig  */
49932927393SChristoph Hellwig static void proc_put_long(void **buf, size_t *size, unsigned long val, bool neg)
500f461d2dcSChristoph Hellwig {
501f461d2dcSChristoph Hellwig 	int len;
502f461d2dcSChristoph Hellwig 	char tmp[TMPBUFLEN], *p = tmp;
503f461d2dcSChristoph Hellwig 
504f461d2dcSChristoph Hellwig 	sprintf(p, "%s%lu", neg ? "-" : "", val);
505f461d2dcSChristoph Hellwig 	len = strlen(tmp);
506f461d2dcSChristoph Hellwig 	if (len > *size)
507f461d2dcSChristoph Hellwig 		len = *size;
50832927393SChristoph Hellwig 	memcpy(*buf, tmp, len);
509f461d2dcSChristoph Hellwig 	*size -= len;
510f461d2dcSChristoph Hellwig 	*buf += len;
511f461d2dcSChristoph Hellwig }
512f461d2dcSChristoph Hellwig #undef TMPBUFLEN
513f461d2dcSChristoph Hellwig 
51432927393SChristoph Hellwig static void proc_put_char(void **buf, size_t *size, char c)
515f461d2dcSChristoph Hellwig {
516f461d2dcSChristoph Hellwig 	if (*size) {
51732927393SChristoph Hellwig 		char **buffer = (char **)buf;
51832927393SChristoph Hellwig 		**buffer = c;
51932927393SChristoph Hellwig 
52032927393SChristoph Hellwig 		(*size)--;
52132927393SChristoph Hellwig 		(*buffer)++;
522f461d2dcSChristoph Hellwig 		*buf = *buffer;
523f461d2dcSChristoph Hellwig 	}
524f461d2dcSChristoph Hellwig }
525f461d2dcSChristoph Hellwig 
526f461d2dcSChristoph Hellwig static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
527f461d2dcSChristoph Hellwig 				 int *valp,
528f461d2dcSChristoph Hellwig 				 int write, void *data)
529f461d2dcSChristoph Hellwig {
530f461d2dcSChristoph Hellwig 	if (write) {
531f461d2dcSChristoph Hellwig 		if (*negp) {
532f461d2dcSChristoph Hellwig 			if (*lvalp > (unsigned long) INT_MAX + 1)
533f461d2dcSChristoph Hellwig 				return -EINVAL;
534f461d2dcSChristoph Hellwig 			*valp = -*lvalp;
535f461d2dcSChristoph Hellwig 		} else {
536f461d2dcSChristoph Hellwig 			if (*lvalp > (unsigned long) INT_MAX)
537f461d2dcSChristoph Hellwig 				return -EINVAL;
538f461d2dcSChristoph Hellwig 			*valp = *lvalp;
539f461d2dcSChristoph Hellwig 		}
540f461d2dcSChristoph Hellwig 	} else {
541f461d2dcSChristoph Hellwig 		int val = *valp;
542f461d2dcSChristoph Hellwig 		if (val < 0) {
543f461d2dcSChristoph Hellwig 			*negp = true;
544f461d2dcSChristoph Hellwig 			*lvalp = -(unsigned long)val;
545f461d2dcSChristoph Hellwig 		} else {
546f461d2dcSChristoph Hellwig 			*negp = false;
547f461d2dcSChristoph Hellwig 			*lvalp = (unsigned long)val;
548f461d2dcSChristoph Hellwig 		}
549f461d2dcSChristoph Hellwig 	}
550f461d2dcSChristoph Hellwig 	return 0;
551f461d2dcSChristoph Hellwig }
552f461d2dcSChristoph Hellwig 
553f461d2dcSChristoph Hellwig static int do_proc_douintvec_conv(unsigned long *lvalp,
554f461d2dcSChristoph Hellwig 				  unsigned int *valp,
555f461d2dcSChristoph Hellwig 				  int write, void *data)
556f461d2dcSChristoph Hellwig {
557f461d2dcSChristoph Hellwig 	if (write) {
558f461d2dcSChristoph Hellwig 		if (*lvalp > UINT_MAX)
559f461d2dcSChristoph Hellwig 			return -EINVAL;
560f461d2dcSChristoph Hellwig 		*valp = *lvalp;
561f461d2dcSChristoph Hellwig 	} else {
562f461d2dcSChristoph Hellwig 		unsigned int val = *valp;
563f461d2dcSChristoph Hellwig 		*lvalp = (unsigned long)val;
564f461d2dcSChristoph Hellwig 	}
565f461d2dcSChristoph Hellwig 	return 0;
566f461d2dcSChristoph Hellwig }
567f461d2dcSChristoph Hellwig 
568f461d2dcSChristoph Hellwig static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
569f461d2dcSChristoph Hellwig 
570f461d2dcSChristoph Hellwig static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
57132927393SChristoph Hellwig 		  int write, void *buffer,
572f461d2dcSChristoph Hellwig 		  size_t *lenp, loff_t *ppos,
573f461d2dcSChristoph Hellwig 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
574f461d2dcSChristoph Hellwig 			      int write, void *data),
575f461d2dcSChristoph Hellwig 		  void *data)
576f461d2dcSChristoph Hellwig {
577f461d2dcSChristoph Hellwig 	int *i, vleft, first = 1, err = 0;
578f461d2dcSChristoph Hellwig 	size_t left;
57932927393SChristoph Hellwig 	char *p;
580f461d2dcSChristoph Hellwig 
581f461d2dcSChristoph Hellwig 	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
582f461d2dcSChristoph Hellwig 		*lenp = 0;
583f461d2dcSChristoph Hellwig 		return 0;
584f461d2dcSChristoph Hellwig 	}
585f461d2dcSChristoph Hellwig 
586f461d2dcSChristoph Hellwig 	i = (int *) tbl_data;
587f461d2dcSChristoph Hellwig 	vleft = table->maxlen / sizeof(*i);
588f461d2dcSChristoph Hellwig 	left = *lenp;
589f461d2dcSChristoph Hellwig 
590f461d2dcSChristoph Hellwig 	if (!conv)
591f461d2dcSChristoph Hellwig 		conv = do_proc_dointvec_conv;
592f461d2dcSChristoph Hellwig 
593f461d2dcSChristoph Hellwig 	if (write) {
594f461d2dcSChristoph Hellwig 		if (proc_first_pos_non_zero_ignore(ppos, table))
595f461d2dcSChristoph Hellwig 			goto out;
596f461d2dcSChristoph Hellwig 
597f461d2dcSChristoph Hellwig 		if (left > PAGE_SIZE - 1)
598f461d2dcSChristoph Hellwig 			left = PAGE_SIZE - 1;
59932927393SChristoph Hellwig 		p = buffer;
600f461d2dcSChristoph Hellwig 	}
601f461d2dcSChristoph Hellwig 
602f461d2dcSChristoph Hellwig 	for (; left && vleft--; i++, first=0) {
603f461d2dcSChristoph Hellwig 		unsigned long lval;
604f461d2dcSChristoph Hellwig 		bool neg;
605f461d2dcSChristoph Hellwig 
606f461d2dcSChristoph Hellwig 		if (write) {
607f461d2dcSChristoph Hellwig 			left -= proc_skip_spaces(&p);
608f461d2dcSChristoph Hellwig 
609f461d2dcSChristoph Hellwig 			if (!left)
610f461d2dcSChristoph Hellwig 				break;
611f461d2dcSChristoph Hellwig 			err = proc_get_long(&p, &left, &lval, &neg,
612f461d2dcSChristoph Hellwig 					     proc_wspace_sep,
613f461d2dcSChristoph Hellwig 					     sizeof(proc_wspace_sep), NULL);
614f461d2dcSChristoph Hellwig 			if (err)
615f461d2dcSChristoph Hellwig 				break;
616f461d2dcSChristoph Hellwig 			if (conv(&neg, &lval, i, 1, data)) {
617f461d2dcSChristoph Hellwig 				err = -EINVAL;
618f461d2dcSChristoph Hellwig 				break;
619f461d2dcSChristoph Hellwig 			}
620f461d2dcSChristoph Hellwig 		} else {
621f461d2dcSChristoph Hellwig 			if (conv(&neg, &lval, i, 0, data)) {
622f461d2dcSChristoph Hellwig 				err = -EINVAL;
623f461d2dcSChristoph Hellwig 				break;
624f461d2dcSChristoph Hellwig 			}
625f461d2dcSChristoph Hellwig 			if (!first)
62632927393SChristoph Hellwig 				proc_put_char(&buffer, &left, '\t');
62732927393SChristoph Hellwig 			proc_put_long(&buffer, &left, lval, neg);
628f461d2dcSChristoph Hellwig 		}
629f461d2dcSChristoph Hellwig 	}
630f461d2dcSChristoph Hellwig 
631f461d2dcSChristoph Hellwig 	if (!write && !first && left && !err)
63232927393SChristoph Hellwig 		proc_put_char(&buffer, &left, '\n');
633f461d2dcSChristoph Hellwig 	if (write && !err && left)
634f461d2dcSChristoph Hellwig 		left -= proc_skip_spaces(&p);
63532927393SChristoph Hellwig 	if (write && first)
636f461d2dcSChristoph Hellwig 		return err ? : -EINVAL;
637f461d2dcSChristoph Hellwig 	*lenp -= left;
638f461d2dcSChristoph Hellwig out:
639f461d2dcSChristoph Hellwig 	*ppos += *lenp;
640f461d2dcSChristoph Hellwig 	return err;
641f461d2dcSChristoph Hellwig }
642f461d2dcSChristoph Hellwig 
643f461d2dcSChristoph Hellwig static int do_proc_dointvec(struct ctl_table *table, int write,
64432927393SChristoph Hellwig 		  void *buffer, size_t *lenp, loff_t *ppos,
645f461d2dcSChristoph Hellwig 		  int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
646f461d2dcSChristoph Hellwig 			      int write, void *data),
647f461d2dcSChristoph Hellwig 		  void *data)
648f461d2dcSChristoph Hellwig {
649f461d2dcSChristoph Hellwig 	return __do_proc_dointvec(table->data, table, write,
650f461d2dcSChristoph Hellwig 			buffer, lenp, ppos, conv, data);
651f461d2dcSChristoph Hellwig }
652f461d2dcSChristoph Hellwig 
653f461d2dcSChristoph Hellwig static int do_proc_douintvec_w(unsigned int *tbl_data,
654f461d2dcSChristoph Hellwig 			       struct ctl_table *table,
65532927393SChristoph Hellwig 			       void *buffer,
656f461d2dcSChristoph Hellwig 			       size_t *lenp, loff_t *ppos,
657f461d2dcSChristoph Hellwig 			       int (*conv)(unsigned long *lvalp,
658f461d2dcSChristoph Hellwig 					   unsigned int *valp,
659f461d2dcSChristoph Hellwig 					   int write, void *data),
660f461d2dcSChristoph Hellwig 			       void *data)
661f461d2dcSChristoph Hellwig {
662f461d2dcSChristoph Hellwig 	unsigned long lval;
663f461d2dcSChristoph Hellwig 	int err = 0;
664f461d2dcSChristoph Hellwig 	size_t left;
665f461d2dcSChristoph Hellwig 	bool neg;
66632927393SChristoph Hellwig 	char *p = buffer;
667f461d2dcSChristoph Hellwig 
668f461d2dcSChristoph Hellwig 	left = *lenp;
669f461d2dcSChristoph Hellwig 
670f461d2dcSChristoph Hellwig 	if (proc_first_pos_non_zero_ignore(ppos, table))
671f461d2dcSChristoph Hellwig 		goto bail_early;
672f461d2dcSChristoph Hellwig 
673f461d2dcSChristoph Hellwig 	if (left > PAGE_SIZE - 1)
674f461d2dcSChristoph Hellwig 		left = PAGE_SIZE - 1;
675f461d2dcSChristoph Hellwig 
676f461d2dcSChristoph Hellwig 	left -= proc_skip_spaces(&p);
677f461d2dcSChristoph Hellwig 	if (!left) {
678f461d2dcSChristoph Hellwig 		err = -EINVAL;
679f461d2dcSChristoph Hellwig 		goto out_free;
680f461d2dcSChristoph Hellwig 	}
681f461d2dcSChristoph Hellwig 
682f461d2dcSChristoph Hellwig 	err = proc_get_long(&p, &left, &lval, &neg,
683f461d2dcSChristoph Hellwig 			     proc_wspace_sep,
684f461d2dcSChristoph Hellwig 			     sizeof(proc_wspace_sep), NULL);
685f461d2dcSChristoph Hellwig 	if (err || neg) {
686f461d2dcSChristoph Hellwig 		err = -EINVAL;
687f461d2dcSChristoph Hellwig 		goto out_free;
688f461d2dcSChristoph Hellwig 	}
689f461d2dcSChristoph Hellwig 
690f461d2dcSChristoph Hellwig 	if (conv(&lval, tbl_data, 1, data)) {
691f461d2dcSChristoph Hellwig 		err = -EINVAL;
692f461d2dcSChristoph Hellwig 		goto out_free;
693f461d2dcSChristoph Hellwig 	}
694f461d2dcSChristoph Hellwig 
695f461d2dcSChristoph Hellwig 	if (!err && left)
696f461d2dcSChristoph Hellwig 		left -= proc_skip_spaces(&p);
697f461d2dcSChristoph Hellwig 
698f461d2dcSChristoph Hellwig out_free:
699f461d2dcSChristoph Hellwig 	if (err)
700f461d2dcSChristoph Hellwig 		return -EINVAL;
701f461d2dcSChristoph Hellwig 
702f461d2dcSChristoph Hellwig 	return 0;
703f461d2dcSChristoph Hellwig 
704f461d2dcSChristoph Hellwig 	/* This is in keeping with old __do_proc_dointvec() */
705f461d2dcSChristoph Hellwig bail_early:
706f461d2dcSChristoph Hellwig 	*ppos += *lenp;
707f461d2dcSChristoph Hellwig 	return err;
708f461d2dcSChristoph Hellwig }
709f461d2dcSChristoph Hellwig 
71032927393SChristoph Hellwig static int do_proc_douintvec_r(unsigned int *tbl_data, void *buffer,
711f461d2dcSChristoph Hellwig 			       size_t *lenp, loff_t *ppos,
712f461d2dcSChristoph Hellwig 			       int (*conv)(unsigned long *lvalp,
713f461d2dcSChristoph Hellwig 					   unsigned int *valp,
714f461d2dcSChristoph Hellwig 					   int write, void *data),
715f461d2dcSChristoph Hellwig 			       void *data)
716f461d2dcSChristoph Hellwig {
717f461d2dcSChristoph Hellwig 	unsigned long lval;
718f461d2dcSChristoph Hellwig 	int err = 0;
719f461d2dcSChristoph Hellwig 	size_t left;
720f461d2dcSChristoph Hellwig 
721f461d2dcSChristoph Hellwig 	left = *lenp;
722f461d2dcSChristoph Hellwig 
723f461d2dcSChristoph Hellwig 	if (conv(&lval, tbl_data, 0, data)) {
724f461d2dcSChristoph Hellwig 		err = -EINVAL;
725f461d2dcSChristoph Hellwig 		goto out;
726f461d2dcSChristoph Hellwig 	}
727f461d2dcSChristoph Hellwig 
72832927393SChristoph Hellwig 	proc_put_long(&buffer, &left, lval, false);
72932927393SChristoph Hellwig 	if (!left)
730f461d2dcSChristoph Hellwig 		goto out;
731f461d2dcSChristoph Hellwig 
73232927393SChristoph Hellwig 	proc_put_char(&buffer, &left, '\n');
733f461d2dcSChristoph Hellwig 
734f461d2dcSChristoph Hellwig out:
735f461d2dcSChristoph Hellwig 	*lenp -= left;
736f461d2dcSChristoph Hellwig 	*ppos += *lenp;
737f461d2dcSChristoph Hellwig 
738f461d2dcSChristoph Hellwig 	return err;
739f461d2dcSChristoph Hellwig }
740f461d2dcSChristoph Hellwig 
741f461d2dcSChristoph Hellwig static int __do_proc_douintvec(void *tbl_data, struct ctl_table *table,
74232927393SChristoph Hellwig 			       int write, void *buffer,
743f461d2dcSChristoph Hellwig 			       size_t *lenp, loff_t *ppos,
744f461d2dcSChristoph Hellwig 			       int (*conv)(unsigned long *lvalp,
745f461d2dcSChristoph Hellwig 					   unsigned int *valp,
746f461d2dcSChristoph Hellwig 					   int write, void *data),
747f461d2dcSChristoph Hellwig 			       void *data)
748f461d2dcSChristoph Hellwig {
749f461d2dcSChristoph Hellwig 	unsigned int *i, vleft;
750f461d2dcSChristoph Hellwig 
751f461d2dcSChristoph Hellwig 	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
752f461d2dcSChristoph Hellwig 		*lenp = 0;
753f461d2dcSChristoph Hellwig 		return 0;
754f461d2dcSChristoph Hellwig 	}
755f461d2dcSChristoph Hellwig 
756f461d2dcSChristoph Hellwig 	i = (unsigned int *) tbl_data;
757f461d2dcSChristoph Hellwig 	vleft = table->maxlen / sizeof(*i);
758f461d2dcSChristoph Hellwig 
759f461d2dcSChristoph Hellwig 	/*
760f461d2dcSChristoph Hellwig 	 * Arrays are not supported, keep this simple. *Do not* add
761f461d2dcSChristoph Hellwig 	 * support for them.
762f461d2dcSChristoph Hellwig 	 */
763f461d2dcSChristoph Hellwig 	if (vleft != 1) {
764f461d2dcSChristoph Hellwig 		*lenp = 0;
765f461d2dcSChristoph Hellwig 		return -EINVAL;
766f461d2dcSChristoph Hellwig 	}
767f461d2dcSChristoph Hellwig 
768f461d2dcSChristoph Hellwig 	if (!conv)
769f461d2dcSChristoph Hellwig 		conv = do_proc_douintvec_conv;
770f461d2dcSChristoph Hellwig 
771f461d2dcSChristoph Hellwig 	if (write)
772f461d2dcSChristoph Hellwig 		return do_proc_douintvec_w(i, table, buffer, lenp, ppos,
773f461d2dcSChristoph Hellwig 					   conv, data);
774f461d2dcSChristoph Hellwig 	return do_proc_douintvec_r(i, buffer, lenp, ppos, conv, data);
775f461d2dcSChristoph Hellwig }
776f461d2dcSChristoph Hellwig 
777f461d2dcSChristoph Hellwig static int do_proc_douintvec(struct ctl_table *table, int write,
77832927393SChristoph Hellwig 			     void *buffer, size_t *lenp, loff_t *ppos,
779f461d2dcSChristoph Hellwig 			     int (*conv)(unsigned long *lvalp,
780f461d2dcSChristoph Hellwig 					 unsigned int *valp,
781f461d2dcSChristoph Hellwig 					 int write, void *data),
782f461d2dcSChristoph Hellwig 			     void *data)
783f461d2dcSChristoph Hellwig {
784f461d2dcSChristoph Hellwig 	return __do_proc_douintvec(table->data, table, write,
785f461d2dcSChristoph Hellwig 				   buffer, lenp, ppos, conv, data);
786f461d2dcSChristoph Hellwig }
787f461d2dcSChristoph Hellwig 
788f461d2dcSChristoph Hellwig /**
789f461d2dcSChristoph Hellwig  * proc_dointvec - read a vector of integers
790f461d2dcSChristoph Hellwig  * @table: the sysctl table
791f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
792f461d2dcSChristoph Hellwig  * @buffer: the user buffer
793f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
794f461d2dcSChristoph Hellwig  * @ppos: file position
795f461d2dcSChristoph Hellwig  *
796f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
797f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string.
798f461d2dcSChristoph Hellwig  *
799f461d2dcSChristoph Hellwig  * Returns 0 on success.
800f461d2dcSChristoph Hellwig  */
80132927393SChristoph Hellwig int proc_dointvec(struct ctl_table *table, int write, void *buffer,
80232927393SChristoph Hellwig 		  size_t *lenp, loff_t *ppos)
803f461d2dcSChristoph Hellwig {
804f461d2dcSChristoph Hellwig 	return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL);
805f461d2dcSChristoph Hellwig }
806f461d2dcSChristoph Hellwig 
807f461d2dcSChristoph Hellwig #ifdef CONFIG_COMPACTION
808f461d2dcSChristoph Hellwig static int proc_dointvec_minmax_warn_RT_change(struct ctl_table *table,
80932927393SChristoph Hellwig 		int write, void *buffer, size_t *lenp, loff_t *ppos)
810f461d2dcSChristoph Hellwig {
811f461d2dcSChristoph Hellwig 	int ret, old;
812f461d2dcSChristoph Hellwig 
813f461d2dcSChristoph Hellwig 	if (!IS_ENABLED(CONFIG_PREEMPT_RT) || !write)
814f461d2dcSChristoph Hellwig 		return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
815f461d2dcSChristoph Hellwig 
816f461d2dcSChristoph Hellwig 	old = *(int *)table->data;
817f461d2dcSChristoph Hellwig 	ret = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
818f461d2dcSChristoph Hellwig 	if (ret)
819f461d2dcSChristoph Hellwig 		return ret;
820f461d2dcSChristoph Hellwig 	if (old != *(int *)table->data)
821f461d2dcSChristoph Hellwig 		pr_warn_once("sysctl attribute %s changed by %s[%d]\n",
822f461d2dcSChristoph Hellwig 			     table->procname, current->comm,
823f461d2dcSChristoph Hellwig 			     task_pid_nr(current));
824f461d2dcSChristoph Hellwig 	return ret;
825f461d2dcSChristoph Hellwig }
826f461d2dcSChristoph Hellwig #endif
827f461d2dcSChristoph Hellwig 
828f461d2dcSChristoph Hellwig /**
829f461d2dcSChristoph Hellwig  * proc_douintvec - read a vector of unsigned integers
830f461d2dcSChristoph Hellwig  * @table: the sysctl table
831f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
832f461d2dcSChristoph Hellwig  * @buffer: the user buffer
833f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
834f461d2dcSChristoph Hellwig  * @ppos: file position
835f461d2dcSChristoph Hellwig  *
836f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
837f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string.
838f461d2dcSChristoph Hellwig  *
839f461d2dcSChristoph Hellwig  * Returns 0 on success.
840f461d2dcSChristoph Hellwig  */
84132927393SChristoph Hellwig int proc_douintvec(struct ctl_table *table, int write, void *buffer,
84232927393SChristoph Hellwig 		size_t *lenp, loff_t *ppos)
843f461d2dcSChristoph Hellwig {
844f461d2dcSChristoph Hellwig 	return do_proc_douintvec(table, write, buffer, lenp, ppos,
845f461d2dcSChristoph Hellwig 				 do_proc_douintvec_conv, NULL);
846f461d2dcSChristoph Hellwig }
847f461d2dcSChristoph Hellwig 
848f461d2dcSChristoph Hellwig /*
849f461d2dcSChristoph Hellwig  * Taint values can only be increased
850f461d2dcSChristoph Hellwig  * This means we can safely use a temporary.
851f461d2dcSChristoph Hellwig  */
852f461d2dcSChristoph Hellwig static int proc_taint(struct ctl_table *table, int write,
85332927393SChristoph Hellwig 			       void *buffer, size_t *lenp, loff_t *ppos)
854f461d2dcSChristoph Hellwig {
855f461d2dcSChristoph Hellwig 	struct ctl_table t;
856f461d2dcSChristoph Hellwig 	unsigned long tmptaint = get_taint();
857f461d2dcSChristoph Hellwig 	int err;
858f461d2dcSChristoph Hellwig 
859f461d2dcSChristoph Hellwig 	if (write && !capable(CAP_SYS_ADMIN))
860f461d2dcSChristoph Hellwig 		return -EPERM;
861f461d2dcSChristoph Hellwig 
862f461d2dcSChristoph Hellwig 	t = *table;
863f461d2dcSChristoph Hellwig 	t.data = &tmptaint;
864f461d2dcSChristoph Hellwig 	err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
865f461d2dcSChristoph Hellwig 	if (err < 0)
866f461d2dcSChristoph Hellwig 		return err;
867f461d2dcSChristoph Hellwig 
868f461d2dcSChristoph Hellwig 	if (write) {
869db38d5c1SRafael Aquini 		int i;
870db38d5c1SRafael Aquini 
871db38d5c1SRafael Aquini 		/*
872db38d5c1SRafael Aquini 		 * If we are relying on panic_on_taint not producing
873db38d5c1SRafael Aquini 		 * false positives due to userspace input, bail out
874db38d5c1SRafael Aquini 		 * before setting the requested taint flags.
875db38d5c1SRafael Aquini 		 */
876db38d5c1SRafael Aquini 		if (panic_on_taint_nousertaint && (tmptaint & panic_on_taint))
877db38d5c1SRafael Aquini 			return -EINVAL;
878db38d5c1SRafael Aquini 
879f461d2dcSChristoph Hellwig 		/*
880f461d2dcSChristoph Hellwig 		 * Poor man's atomic or. Not worth adding a primitive
881f461d2dcSChristoph Hellwig 		 * to everyone's atomic.h for this
882f461d2dcSChristoph Hellwig 		 */
883f461d2dcSChristoph Hellwig 		for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) {
884f461d2dcSChristoph Hellwig 			if ((tmptaint >> i) & 1)
885f461d2dcSChristoph Hellwig 				add_taint(i, LOCKDEP_STILL_OK);
886f461d2dcSChristoph Hellwig 		}
887f461d2dcSChristoph Hellwig 	}
888f461d2dcSChristoph Hellwig 
889f461d2dcSChristoph Hellwig 	return err;
890f461d2dcSChristoph Hellwig }
891f461d2dcSChristoph Hellwig 
892f461d2dcSChristoph Hellwig #ifdef CONFIG_PRINTK
893f461d2dcSChristoph Hellwig static int proc_dointvec_minmax_sysadmin(struct ctl_table *table, int write,
89432927393SChristoph Hellwig 				void *buffer, size_t *lenp, loff_t *ppos)
895f461d2dcSChristoph Hellwig {
896f461d2dcSChristoph Hellwig 	if (write && !capable(CAP_SYS_ADMIN))
897f461d2dcSChristoph Hellwig 		return -EPERM;
898f461d2dcSChristoph Hellwig 
899f461d2dcSChristoph Hellwig 	return proc_dointvec_minmax(table, write, buffer, lenp, ppos);
900f461d2dcSChristoph Hellwig }
901f461d2dcSChristoph Hellwig #endif
902f461d2dcSChristoph Hellwig 
903f461d2dcSChristoph Hellwig /**
904f461d2dcSChristoph Hellwig  * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
905f461d2dcSChristoph Hellwig  * @min: pointer to minimum allowable value
906f461d2dcSChristoph Hellwig  * @max: pointer to maximum allowable value
907f461d2dcSChristoph Hellwig  *
908f461d2dcSChristoph Hellwig  * The do_proc_dointvec_minmax_conv_param structure provides the
909f461d2dcSChristoph Hellwig  * minimum and maximum values for doing range checking for those sysctl
910f461d2dcSChristoph Hellwig  * parameters that use the proc_dointvec_minmax() handler.
911f461d2dcSChristoph Hellwig  */
912f461d2dcSChristoph Hellwig struct do_proc_dointvec_minmax_conv_param {
913f461d2dcSChristoph Hellwig 	int *min;
914f461d2dcSChristoph Hellwig 	int *max;
915f461d2dcSChristoph Hellwig };
916f461d2dcSChristoph Hellwig 
917f461d2dcSChristoph Hellwig static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
918f461d2dcSChristoph Hellwig 					int *valp,
919f461d2dcSChristoph Hellwig 					int write, void *data)
920f461d2dcSChristoph Hellwig {
921f461d2dcSChristoph Hellwig 	int tmp, ret;
922f461d2dcSChristoph Hellwig 	struct do_proc_dointvec_minmax_conv_param *param = data;
923f461d2dcSChristoph Hellwig 	/*
924f461d2dcSChristoph Hellwig 	 * If writing, first do so via a temporary local int so we can
925f461d2dcSChristoph Hellwig 	 * bounds-check it before touching *valp.
926f461d2dcSChristoph Hellwig 	 */
927f461d2dcSChristoph Hellwig 	int *ip = write ? &tmp : valp;
928f461d2dcSChristoph Hellwig 
929f461d2dcSChristoph Hellwig 	ret = do_proc_dointvec_conv(negp, lvalp, ip, write, data);
930f461d2dcSChristoph Hellwig 	if (ret)
931f461d2dcSChristoph Hellwig 		return ret;
932f461d2dcSChristoph Hellwig 
933f461d2dcSChristoph Hellwig 	if (write) {
934f461d2dcSChristoph Hellwig 		if ((param->min && *param->min > tmp) ||
935f461d2dcSChristoph Hellwig 		    (param->max && *param->max < tmp))
936f461d2dcSChristoph Hellwig 			return -EINVAL;
937f461d2dcSChristoph Hellwig 		*valp = tmp;
938f461d2dcSChristoph Hellwig 	}
939f461d2dcSChristoph Hellwig 
940f461d2dcSChristoph Hellwig 	return 0;
941f461d2dcSChristoph Hellwig }
942f461d2dcSChristoph Hellwig 
943f461d2dcSChristoph Hellwig /**
944f461d2dcSChristoph Hellwig  * proc_dointvec_minmax - read a vector of integers with min/max values
945f461d2dcSChristoph Hellwig  * @table: the sysctl table
946f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
947f461d2dcSChristoph Hellwig  * @buffer: the user buffer
948f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
949f461d2dcSChristoph Hellwig  * @ppos: file position
950f461d2dcSChristoph Hellwig  *
951f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
952f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string.
953f461d2dcSChristoph Hellwig  *
954f461d2dcSChristoph Hellwig  * This routine will ensure the values are within the range specified by
955f461d2dcSChristoph Hellwig  * table->extra1 (min) and table->extra2 (max).
956f461d2dcSChristoph Hellwig  *
957f461d2dcSChristoph Hellwig  * Returns 0 on success or -EINVAL on write when the range check fails.
958f461d2dcSChristoph Hellwig  */
959f461d2dcSChristoph Hellwig int proc_dointvec_minmax(struct ctl_table *table, int write,
96032927393SChristoph Hellwig 		  void *buffer, size_t *lenp, loff_t *ppos)
961f461d2dcSChristoph Hellwig {
962f461d2dcSChristoph Hellwig 	struct do_proc_dointvec_minmax_conv_param param = {
963f461d2dcSChristoph Hellwig 		.min = (int *) table->extra1,
964f461d2dcSChristoph Hellwig 		.max = (int *) table->extra2,
965f461d2dcSChristoph Hellwig 	};
966f461d2dcSChristoph Hellwig 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
967f461d2dcSChristoph Hellwig 				do_proc_dointvec_minmax_conv, &param);
968f461d2dcSChristoph Hellwig }
969f461d2dcSChristoph Hellwig 
970f461d2dcSChristoph Hellwig /**
971f461d2dcSChristoph Hellwig  * struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure
972f461d2dcSChristoph Hellwig  * @min: pointer to minimum allowable value
973f461d2dcSChristoph Hellwig  * @max: pointer to maximum allowable value
974f461d2dcSChristoph Hellwig  *
975f461d2dcSChristoph Hellwig  * The do_proc_douintvec_minmax_conv_param structure provides the
976f461d2dcSChristoph Hellwig  * minimum and maximum values for doing range checking for those sysctl
977f461d2dcSChristoph Hellwig  * parameters that use the proc_douintvec_minmax() handler.
978f461d2dcSChristoph Hellwig  */
979f461d2dcSChristoph Hellwig struct do_proc_douintvec_minmax_conv_param {
980f461d2dcSChristoph Hellwig 	unsigned int *min;
981f461d2dcSChristoph Hellwig 	unsigned int *max;
982f461d2dcSChristoph Hellwig };
983f461d2dcSChristoph Hellwig 
984f461d2dcSChristoph Hellwig static int do_proc_douintvec_minmax_conv(unsigned long *lvalp,
985f461d2dcSChristoph Hellwig 					 unsigned int *valp,
986f461d2dcSChristoph Hellwig 					 int write, void *data)
987f461d2dcSChristoph Hellwig {
988f461d2dcSChristoph Hellwig 	int ret;
989f461d2dcSChristoph Hellwig 	unsigned int tmp;
990f461d2dcSChristoph Hellwig 	struct do_proc_douintvec_minmax_conv_param *param = data;
991f461d2dcSChristoph Hellwig 	/* write via temporary local uint for bounds-checking */
992f461d2dcSChristoph Hellwig 	unsigned int *up = write ? &tmp : valp;
993f461d2dcSChristoph Hellwig 
994f461d2dcSChristoph Hellwig 	ret = do_proc_douintvec_conv(lvalp, up, write, data);
995f461d2dcSChristoph Hellwig 	if (ret)
996f461d2dcSChristoph Hellwig 		return ret;
997f461d2dcSChristoph Hellwig 
998f461d2dcSChristoph Hellwig 	if (write) {
999f461d2dcSChristoph Hellwig 		if ((param->min && *param->min > tmp) ||
1000f461d2dcSChristoph Hellwig 		    (param->max && *param->max < tmp))
1001f461d2dcSChristoph Hellwig 			return -ERANGE;
1002f461d2dcSChristoph Hellwig 
1003f461d2dcSChristoph Hellwig 		*valp = tmp;
1004f461d2dcSChristoph Hellwig 	}
1005f461d2dcSChristoph Hellwig 
1006f461d2dcSChristoph Hellwig 	return 0;
1007f461d2dcSChristoph Hellwig }
1008f461d2dcSChristoph Hellwig 
1009f461d2dcSChristoph Hellwig /**
1010f461d2dcSChristoph Hellwig  * proc_douintvec_minmax - read a vector of unsigned ints with min/max values
1011f461d2dcSChristoph Hellwig  * @table: the sysctl table
1012f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
1013f461d2dcSChristoph Hellwig  * @buffer: the user buffer
1014f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
1015f461d2dcSChristoph Hellwig  * @ppos: file position
1016f461d2dcSChristoph Hellwig  *
1017f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
1018f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string. Negative
1019f461d2dcSChristoph Hellwig  * strings are not allowed.
1020f461d2dcSChristoph Hellwig  *
1021f461d2dcSChristoph Hellwig  * This routine will ensure the values are within the range specified by
1022f461d2dcSChristoph Hellwig  * table->extra1 (min) and table->extra2 (max). There is a final sanity
1023f461d2dcSChristoph Hellwig  * check for UINT_MAX to avoid having to support wrap around uses from
1024f461d2dcSChristoph Hellwig  * userspace.
1025f461d2dcSChristoph Hellwig  *
1026f461d2dcSChristoph Hellwig  * Returns 0 on success or -ERANGE on write when the range check fails.
1027f461d2dcSChristoph Hellwig  */
1028f461d2dcSChristoph Hellwig int proc_douintvec_minmax(struct ctl_table *table, int write,
102932927393SChristoph Hellwig 			  void *buffer, size_t *lenp, loff_t *ppos)
1030f461d2dcSChristoph Hellwig {
1031f461d2dcSChristoph Hellwig 	struct do_proc_douintvec_minmax_conv_param param = {
1032f461d2dcSChristoph Hellwig 		.min = (unsigned int *) table->extra1,
1033f461d2dcSChristoph Hellwig 		.max = (unsigned int *) table->extra2,
1034f461d2dcSChristoph Hellwig 	};
1035f461d2dcSChristoph Hellwig 	return do_proc_douintvec(table, write, buffer, lenp, ppos,
1036f461d2dcSChristoph Hellwig 				 do_proc_douintvec_minmax_conv, &param);
1037f461d2dcSChristoph Hellwig }
1038f461d2dcSChristoph Hellwig 
1039f461d2dcSChristoph Hellwig static int do_proc_dopipe_max_size_conv(unsigned long *lvalp,
1040f461d2dcSChristoph Hellwig 					unsigned int *valp,
1041f461d2dcSChristoph Hellwig 					int write, void *data)
1042f461d2dcSChristoph Hellwig {
1043f461d2dcSChristoph Hellwig 	if (write) {
1044f461d2dcSChristoph Hellwig 		unsigned int val;
1045f461d2dcSChristoph Hellwig 
1046f461d2dcSChristoph Hellwig 		val = round_pipe_size(*lvalp);
1047f461d2dcSChristoph Hellwig 		if (val == 0)
1048f461d2dcSChristoph Hellwig 			return -EINVAL;
1049f461d2dcSChristoph Hellwig 
1050f461d2dcSChristoph Hellwig 		*valp = val;
1051f461d2dcSChristoph Hellwig 	} else {
1052f461d2dcSChristoph Hellwig 		unsigned int val = *valp;
1053f461d2dcSChristoph Hellwig 		*lvalp = (unsigned long) val;
1054f461d2dcSChristoph Hellwig 	}
1055f461d2dcSChristoph Hellwig 
1056f461d2dcSChristoph Hellwig 	return 0;
1057f461d2dcSChristoph Hellwig }
1058f461d2dcSChristoph Hellwig 
1059f461d2dcSChristoph Hellwig static int proc_dopipe_max_size(struct ctl_table *table, int write,
106032927393SChristoph Hellwig 				void *buffer, size_t *lenp, loff_t *ppos)
1061f461d2dcSChristoph Hellwig {
1062f461d2dcSChristoph Hellwig 	return do_proc_douintvec(table, write, buffer, lenp, ppos,
1063f461d2dcSChristoph Hellwig 				 do_proc_dopipe_max_size_conv, NULL);
1064f461d2dcSChristoph Hellwig }
1065f461d2dcSChristoph Hellwig 
1066f461d2dcSChristoph Hellwig static void validate_coredump_safety(void)
1067f461d2dcSChristoph Hellwig {
1068f461d2dcSChristoph Hellwig #ifdef CONFIG_COREDUMP
1069f461d2dcSChristoph Hellwig 	if (suid_dumpable == SUID_DUMP_ROOT &&
1070f461d2dcSChristoph Hellwig 	    core_pattern[0] != '/' && core_pattern[0] != '|') {
1071f461d2dcSChristoph Hellwig 		printk(KERN_WARNING
1072f461d2dcSChristoph Hellwig "Unsafe core_pattern used with fs.suid_dumpable=2.\n"
1073f461d2dcSChristoph Hellwig "Pipe handler or fully qualified core dump path required.\n"
1074f461d2dcSChristoph Hellwig "Set kernel.core_pattern before fs.suid_dumpable.\n"
1075f461d2dcSChristoph Hellwig 		);
1076f461d2dcSChristoph Hellwig 	}
1077f461d2dcSChristoph Hellwig #endif
1078f461d2dcSChristoph Hellwig }
1079f461d2dcSChristoph Hellwig 
1080f461d2dcSChristoph Hellwig static int proc_dointvec_minmax_coredump(struct ctl_table *table, int write,
108132927393SChristoph Hellwig 		void *buffer, size_t *lenp, loff_t *ppos)
1082f461d2dcSChristoph Hellwig {
1083f461d2dcSChristoph Hellwig 	int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);
1084f461d2dcSChristoph Hellwig 	if (!error)
1085f461d2dcSChristoph Hellwig 		validate_coredump_safety();
1086f461d2dcSChristoph Hellwig 	return error;
1087f461d2dcSChristoph Hellwig }
1088f461d2dcSChristoph Hellwig 
1089f461d2dcSChristoph Hellwig #ifdef CONFIG_COREDUMP
1090f461d2dcSChristoph Hellwig static int proc_dostring_coredump(struct ctl_table *table, int write,
109132927393SChristoph Hellwig 		  void *buffer, size_t *lenp, loff_t *ppos)
1092f461d2dcSChristoph Hellwig {
1093f461d2dcSChristoph Hellwig 	int error = proc_dostring(table, write, buffer, lenp, ppos);
1094f461d2dcSChristoph Hellwig 	if (!error)
1095f461d2dcSChristoph Hellwig 		validate_coredump_safety();
1096f461d2dcSChristoph Hellwig 	return error;
1097f461d2dcSChristoph Hellwig }
1098f461d2dcSChristoph Hellwig #endif
1099f461d2dcSChristoph Hellwig 
1100f461d2dcSChristoph Hellwig #ifdef CONFIG_MAGIC_SYSRQ
1101f461d2dcSChristoph Hellwig static int sysrq_sysctl_handler(struct ctl_table *table, int write,
110232927393SChristoph Hellwig 				void *buffer, size_t *lenp, loff_t *ppos)
1103f461d2dcSChristoph Hellwig {
1104f461d2dcSChristoph Hellwig 	int tmp, ret;
1105f461d2dcSChristoph Hellwig 
1106f461d2dcSChristoph Hellwig 	tmp = sysrq_mask();
1107f461d2dcSChristoph Hellwig 
1108f461d2dcSChristoph Hellwig 	ret = __do_proc_dointvec(&tmp, table, write, buffer,
1109f461d2dcSChristoph Hellwig 			       lenp, ppos, NULL, NULL);
1110f461d2dcSChristoph Hellwig 	if (ret || !write)
1111f461d2dcSChristoph Hellwig 		return ret;
1112f461d2dcSChristoph Hellwig 
1113f461d2dcSChristoph Hellwig 	if (write)
1114f461d2dcSChristoph Hellwig 		sysrq_toggle_support(tmp);
1115f461d2dcSChristoph Hellwig 
1116f461d2dcSChristoph Hellwig 	return 0;
1117f461d2dcSChristoph Hellwig }
1118f461d2dcSChristoph Hellwig #endif
1119f461d2dcSChristoph Hellwig 
112032927393SChristoph Hellwig static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table,
112132927393SChristoph Hellwig 		int write, void *buffer, size_t *lenp, loff_t *ppos,
112232927393SChristoph Hellwig 		unsigned long convmul, unsigned long convdiv)
1123f461d2dcSChristoph Hellwig {
1124f461d2dcSChristoph Hellwig 	unsigned long *i, *min, *max;
1125f461d2dcSChristoph Hellwig 	int vleft, first = 1, err = 0;
1126f461d2dcSChristoph Hellwig 	size_t left;
112732927393SChristoph Hellwig 	char *p;
1128f461d2dcSChristoph Hellwig 
1129f461d2dcSChristoph Hellwig 	if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
1130f461d2dcSChristoph Hellwig 		*lenp = 0;
1131f461d2dcSChristoph Hellwig 		return 0;
1132f461d2dcSChristoph Hellwig 	}
1133f461d2dcSChristoph Hellwig 
1134f461d2dcSChristoph Hellwig 	i = (unsigned long *) data;
1135f461d2dcSChristoph Hellwig 	min = (unsigned long *) table->extra1;
1136f461d2dcSChristoph Hellwig 	max = (unsigned long *) table->extra2;
1137f461d2dcSChristoph Hellwig 	vleft = table->maxlen / sizeof(unsigned long);
1138f461d2dcSChristoph Hellwig 	left = *lenp;
1139f461d2dcSChristoph Hellwig 
1140f461d2dcSChristoph Hellwig 	if (write) {
1141f461d2dcSChristoph Hellwig 		if (proc_first_pos_non_zero_ignore(ppos, table))
1142f461d2dcSChristoph Hellwig 			goto out;
1143f461d2dcSChristoph Hellwig 
1144f461d2dcSChristoph Hellwig 		if (left > PAGE_SIZE - 1)
1145f461d2dcSChristoph Hellwig 			left = PAGE_SIZE - 1;
114632927393SChristoph Hellwig 		p = buffer;
1147f461d2dcSChristoph Hellwig 	}
1148f461d2dcSChristoph Hellwig 
1149f461d2dcSChristoph Hellwig 	for (; left && vleft--; i++, first = 0) {
1150f461d2dcSChristoph Hellwig 		unsigned long val;
1151f461d2dcSChristoph Hellwig 
1152f461d2dcSChristoph Hellwig 		if (write) {
1153f461d2dcSChristoph Hellwig 			bool neg;
1154f461d2dcSChristoph Hellwig 
1155f461d2dcSChristoph Hellwig 			left -= proc_skip_spaces(&p);
1156f461d2dcSChristoph Hellwig 			if (!left)
1157f461d2dcSChristoph Hellwig 				break;
1158f461d2dcSChristoph Hellwig 
1159f461d2dcSChristoph Hellwig 			err = proc_get_long(&p, &left, &val, &neg,
1160f461d2dcSChristoph Hellwig 					     proc_wspace_sep,
1161f461d2dcSChristoph Hellwig 					     sizeof(proc_wspace_sep), NULL);
1162f461d2dcSChristoph Hellwig 			if (err)
1163f461d2dcSChristoph Hellwig 				break;
1164f461d2dcSChristoph Hellwig 			if (neg)
1165f461d2dcSChristoph Hellwig 				continue;
1166f461d2dcSChristoph Hellwig 			val = convmul * val / convdiv;
1167f461d2dcSChristoph Hellwig 			if ((min && val < *min) || (max && val > *max)) {
1168f461d2dcSChristoph Hellwig 				err = -EINVAL;
1169f461d2dcSChristoph Hellwig 				break;
1170f461d2dcSChristoph Hellwig 			}
1171f461d2dcSChristoph Hellwig 			*i = val;
1172f461d2dcSChristoph Hellwig 		} else {
1173f461d2dcSChristoph Hellwig 			val = convdiv * (*i) / convmul;
117432927393SChristoph Hellwig 			if (!first)
117532927393SChristoph Hellwig 				proc_put_char(&buffer, &left, '\t');
117632927393SChristoph Hellwig 			proc_put_long(&buffer, &left, val, false);
1177f461d2dcSChristoph Hellwig 		}
1178f461d2dcSChristoph Hellwig 	}
1179f461d2dcSChristoph Hellwig 
1180f461d2dcSChristoph Hellwig 	if (!write && !first && left && !err)
118132927393SChristoph Hellwig 		proc_put_char(&buffer, &left, '\n');
1182f461d2dcSChristoph Hellwig 	if (write && !err)
1183f461d2dcSChristoph Hellwig 		left -= proc_skip_spaces(&p);
118432927393SChristoph Hellwig 	if (write && first)
1185f461d2dcSChristoph Hellwig 		return err ? : -EINVAL;
1186f461d2dcSChristoph Hellwig 	*lenp -= left;
1187f461d2dcSChristoph Hellwig out:
1188f461d2dcSChristoph Hellwig 	*ppos += *lenp;
1189f461d2dcSChristoph Hellwig 	return err;
1190f461d2dcSChristoph Hellwig }
1191f461d2dcSChristoph Hellwig 
1192f461d2dcSChristoph Hellwig static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
119332927393SChristoph Hellwig 		void *buffer, size_t *lenp, loff_t *ppos, unsigned long convmul,
1194f461d2dcSChristoph Hellwig 		unsigned long convdiv)
1195f461d2dcSChristoph Hellwig {
1196f461d2dcSChristoph Hellwig 	return __do_proc_doulongvec_minmax(table->data, table, write,
1197f461d2dcSChristoph Hellwig 			buffer, lenp, ppos, convmul, convdiv);
1198f461d2dcSChristoph Hellwig }
1199f461d2dcSChristoph Hellwig 
1200f461d2dcSChristoph Hellwig /**
1201f461d2dcSChristoph Hellwig  * proc_doulongvec_minmax - read a vector of long integers with min/max values
1202f461d2dcSChristoph Hellwig  * @table: the sysctl table
1203f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
1204f461d2dcSChristoph Hellwig  * @buffer: the user buffer
1205f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
1206f461d2dcSChristoph Hellwig  * @ppos: file position
1207f461d2dcSChristoph Hellwig  *
1208f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1209f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string.
1210f461d2dcSChristoph Hellwig  *
1211f461d2dcSChristoph Hellwig  * This routine will ensure the values are within the range specified by
1212f461d2dcSChristoph Hellwig  * table->extra1 (min) and table->extra2 (max).
1213f461d2dcSChristoph Hellwig  *
1214f461d2dcSChristoph Hellwig  * Returns 0 on success.
1215f461d2dcSChristoph Hellwig  */
1216f461d2dcSChristoph Hellwig int proc_doulongvec_minmax(struct ctl_table *table, int write,
121732927393SChristoph Hellwig 			   void *buffer, size_t *lenp, loff_t *ppos)
1218f461d2dcSChristoph Hellwig {
1219f461d2dcSChristoph Hellwig     return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l);
1220f461d2dcSChristoph Hellwig }
1221f461d2dcSChristoph Hellwig 
1222f461d2dcSChristoph Hellwig /**
1223f461d2dcSChristoph Hellwig  * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
1224f461d2dcSChristoph Hellwig  * @table: the sysctl table
1225f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
1226f461d2dcSChristoph Hellwig  * @buffer: the user buffer
1227f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
1228f461d2dcSChristoph Hellwig  * @ppos: file position
1229f461d2dcSChristoph Hellwig  *
1230f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1231f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string. The values
1232f461d2dcSChristoph Hellwig  * are treated as milliseconds, and converted to jiffies when they are stored.
1233f461d2dcSChristoph Hellwig  *
1234f461d2dcSChristoph Hellwig  * This routine will ensure the values are within the range specified by
1235f461d2dcSChristoph Hellwig  * table->extra1 (min) and table->extra2 (max).
1236f461d2dcSChristoph Hellwig  *
1237f461d2dcSChristoph Hellwig  * Returns 0 on success.
1238f461d2dcSChristoph Hellwig  */
1239f461d2dcSChristoph Hellwig int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
124032927393SChristoph Hellwig 				      void *buffer, size_t *lenp, loff_t *ppos)
1241f461d2dcSChristoph Hellwig {
1242f461d2dcSChristoph Hellwig     return do_proc_doulongvec_minmax(table, write, buffer,
1243f461d2dcSChristoph Hellwig 				     lenp, ppos, HZ, 1000l);
1244f461d2dcSChristoph Hellwig }
1245f461d2dcSChristoph Hellwig 
1246f461d2dcSChristoph Hellwig 
1247f461d2dcSChristoph Hellwig static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
1248f461d2dcSChristoph Hellwig 					 int *valp,
1249f461d2dcSChristoph Hellwig 					 int write, void *data)
1250f461d2dcSChristoph Hellwig {
1251f461d2dcSChristoph Hellwig 	if (write) {
1252f461d2dcSChristoph Hellwig 		if (*lvalp > INT_MAX / HZ)
1253f461d2dcSChristoph Hellwig 			return 1;
1254f461d2dcSChristoph Hellwig 		*valp = *negp ? -(*lvalp*HZ) : (*lvalp*HZ);
1255f461d2dcSChristoph Hellwig 	} else {
1256f461d2dcSChristoph Hellwig 		int val = *valp;
1257f461d2dcSChristoph Hellwig 		unsigned long lval;
1258f461d2dcSChristoph Hellwig 		if (val < 0) {
1259f461d2dcSChristoph Hellwig 			*negp = true;
1260f461d2dcSChristoph Hellwig 			lval = -(unsigned long)val;
1261f461d2dcSChristoph Hellwig 		} else {
1262f461d2dcSChristoph Hellwig 			*negp = false;
1263f461d2dcSChristoph Hellwig 			lval = (unsigned long)val;
1264f461d2dcSChristoph Hellwig 		}
1265f461d2dcSChristoph Hellwig 		*lvalp = lval / HZ;
1266f461d2dcSChristoph Hellwig 	}
1267f461d2dcSChristoph Hellwig 	return 0;
1268f461d2dcSChristoph Hellwig }
1269f461d2dcSChristoph Hellwig 
1270f461d2dcSChristoph Hellwig static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
1271f461d2dcSChristoph Hellwig 						int *valp,
1272f461d2dcSChristoph Hellwig 						int write, void *data)
1273f461d2dcSChristoph Hellwig {
1274f461d2dcSChristoph Hellwig 	if (write) {
1275f461d2dcSChristoph Hellwig 		if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
1276f461d2dcSChristoph Hellwig 			return 1;
1277f461d2dcSChristoph Hellwig 		*valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
1278f461d2dcSChristoph Hellwig 	} else {
1279f461d2dcSChristoph Hellwig 		int val = *valp;
1280f461d2dcSChristoph Hellwig 		unsigned long lval;
1281f461d2dcSChristoph Hellwig 		if (val < 0) {
1282f461d2dcSChristoph Hellwig 			*negp = true;
1283f461d2dcSChristoph Hellwig 			lval = -(unsigned long)val;
1284f461d2dcSChristoph Hellwig 		} else {
1285f461d2dcSChristoph Hellwig 			*negp = false;
1286f461d2dcSChristoph Hellwig 			lval = (unsigned long)val;
1287f461d2dcSChristoph Hellwig 		}
1288f461d2dcSChristoph Hellwig 		*lvalp = jiffies_to_clock_t(lval);
1289f461d2dcSChristoph Hellwig 	}
1290f461d2dcSChristoph Hellwig 	return 0;
1291f461d2dcSChristoph Hellwig }
1292f461d2dcSChristoph Hellwig 
1293f461d2dcSChristoph Hellwig static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
1294f461d2dcSChristoph Hellwig 					    int *valp,
1295f461d2dcSChristoph Hellwig 					    int write, void *data)
1296f461d2dcSChristoph Hellwig {
1297f461d2dcSChristoph Hellwig 	if (write) {
1298f461d2dcSChristoph Hellwig 		unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
1299f461d2dcSChristoph Hellwig 
1300f461d2dcSChristoph Hellwig 		if (jif > INT_MAX)
1301f461d2dcSChristoph Hellwig 			return 1;
1302f461d2dcSChristoph Hellwig 		*valp = (int)jif;
1303f461d2dcSChristoph Hellwig 	} else {
1304f461d2dcSChristoph Hellwig 		int val = *valp;
1305f461d2dcSChristoph Hellwig 		unsigned long lval;
1306f461d2dcSChristoph Hellwig 		if (val < 0) {
1307f461d2dcSChristoph Hellwig 			*negp = true;
1308f461d2dcSChristoph Hellwig 			lval = -(unsigned long)val;
1309f461d2dcSChristoph Hellwig 		} else {
1310f461d2dcSChristoph Hellwig 			*negp = false;
1311f461d2dcSChristoph Hellwig 			lval = (unsigned long)val;
1312f461d2dcSChristoph Hellwig 		}
1313f461d2dcSChristoph Hellwig 		*lvalp = jiffies_to_msecs(lval);
1314f461d2dcSChristoph Hellwig 	}
1315f461d2dcSChristoph Hellwig 	return 0;
1316f461d2dcSChristoph Hellwig }
1317f461d2dcSChristoph Hellwig 
1318f461d2dcSChristoph Hellwig /**
1319f461d2dcSChristoph Hellwig  * proc_dointvec_jiffies - read a vector of integers as seconds
1320f461d2dcSChristoph Hellwig  * @table: the sysctl table
1321f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
1322f461d2dcSChristoph Hellwig  * @buffer: the user buffer
1323f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
1324f461d2dcSChristoph Hellwig  * @ppos: file position
1325f461d2dcSChristoph Hellwig  *
1326f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1327f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string.
1328f461d2dcSChristoph Hellwig  * The values read are assumed to be in seconds, and are converted into
1329f461d2dcSChristoph Hellwig  * jiffies.
1330f461d2dcSChristoph Hellwig  *
1331f461d2dcSChristoph Hellwig  * Returns 0 on success.
1332f461d2dcSChristoph Hellwig  */
1333f461d2dcSChristoph Hellwig int proc_dointvec_jiffies(struct ctl_table *table, int write,
133432927393SChristoph Hellwig 			  void *buffer, size_t *lenp, loff_t *ppos)
1335f461d2dcSChristoph Hellwig {
1336f461d2dcSChristoph Hellwig     return do_proc_dointvec(table,write,buffer,lenp,ppos,
1337f461d2dcSChristoph Hellwig 		    	    do_proc_dointvec_jiffies_conv,NULL);
1338f461d2dcSChristoph Hellwig }
1339f461d2dcSChristoph Hellwig 
1340f461d2dcSChristoph Hellwig /**
1341f461d2dcSChristoph Hellwig  * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
1342f461d2dcSChristoph Hellwig  * @table: the sysctl table
1343f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
1344f461d2dcSChristoph Hellwig  * @buffer: the user buffer
1345f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
1346f461d2dcSChristoph Hellwig  * @ppos: pointer to the file position
1347f461d2dcSChristoph Hellwig  *
1348f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1349f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string.
1350f461d2dcSChristoph Hellwig  * The values read are assumed to be in 1/USER_HZ seconds, and
1351f461d2dcSChristoph Hellwig  * are converted into jiffies.
1352f461d2dcSChristoph Hellwig  *
1353f461d2dcSChristoph Hellwig  * Returns 0 on success.
1354f461d2dcSChristoph Hellwig  */
1355f461d2dcSChristoph Hellwig int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
135632927393SChristoph Hellwig 				 void *buffer, size_t *lenp, loff_t *ppos)
1357f461d2dcSChristoph Hellwig {
1358f461d2dcSChristoph Hellwig     return do_proc_dointvec(table,write,buffer,lenp,ppos,
1359f461d2dcSChristoph Hellwig 		    	    do_proc_dointvec_userhz_jiffies_conv,NULL);
1360f461d2dcSChristoph Hellwig }
1361f461d2dcSChristoph Hellwig 
1362f461d2dcSChristoph Hellwig /**
1363f461d2dcSChristoph Hellwig  * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
1364f461d2dcSChristoph Hellwig  * @table: the sysctl table
1365f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
1366f461d2dcSChristoph Hellwig  * @buffer: the user buffer
1367f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
1368f461d2dcSChristoph Hellwig  * @ppos: file position
1369f461d2dcSChristoph Hellwig  * @ppos: the current position in the file
1370f461d2dcSChristoph Hellwig  *
1371f461d2dcSChristoph Hellwig  * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1372f461d2dcSChristoph Hellwig  * values from/to the user buffer, treated as an ASCII string.
1373f461d2dcSChristoph Hellwig  * The values read are assumed to be in 1/1000 seconds, and
1374f461d2dcSChristoph Hellwig  * are converted into jiffies.
1375f461d2dcSChristoph Hellwig  *
1376f461d2dcSChristoph Hellwig  * Returns 0 on success.
1377f461d2dcSChristoph Hellwig  */
137832927393SChristoph Hellwig int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer,
137932927393SChristoph Hellwig 		size_t *lenp, loff_t *ppos)
1380f461d2dcSChristoph Hellwig {
1381f461d2dcSChristoph Hellwig 	return do_proc_dointvec(table, write, buffer, lenp, ppos,
1382f461d2dcSChristoph Hellwig 				do_proc_dointvec_ms_jiffies_conv, NULL);
1383f461d2dcSChristoph Hellwig }
1384f461d2dcSChristoph Hellwig 
138532927393SChristoph Hellwig static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer,
138632927393SChristoph Hellwig 		size_t *lenp, loff_t *ppos)
1387f461d2dcSChristoph Hellwig {
1388f461d2dcSChristoph Hellwig 	struct pid *new_pid;
1389f461d2dcSChristoph Hellwig 	pid_t tmp;
1390f461d2dcSChristoph Hellwig 	int r;
1391f461d2dcSChristoph Hellwig 
1392f461d2dcSChristoph Hellwig 	tmp = pid_vnr(cad_pid);
1393f461d2dcSChristoph Hellwig 
1394f461d2dcSChristoph Hellwig 	r = __do_proc_dointvec(&tmp, table, write, buffer,
1395f461d2dcSChristoph Hellwig 			       lenp, ppos, NULL, NULL);
1396f461d2dcSChristoph Hellwig 	if (r || !write)
1397f461d2dcSChristoph Hellwig 		return r;
1398f461d2dcSChristoph Hellwig 
1399f461d2dcSChristoph Hellwig 	new_pid = find_get_pid(tmp);
1400f461d2dcSChristoph Hellwig 	if (!new_pid)
1401f461d2dcSChristoph Hellwig 		return -ESRCH;
1402f461d2dcSChristoph Hellwig 
1403f461d2dcSChristoph Hellwig 	put_pid(xchg(&cad_pid, new_pid));
1404f461d2dcSChristoph Hellwig 	return 0;
1405f461d2dcSChristoph Hellwig }
1406f461d2dcSChristoph Hellwig 
1407f461d2dcSChristoph Hellwig /**
1408f461d2dcSChristoph Hellwig  * proc_do_large_bitmap - read/write from/to a large bitmap
1409f461d2dcSChristoph Hellwig  * @table: the sysctl table
1410f461d2dcSChristoph Hellwig  * @write: %TRUE if this is a write to the sysctl file
1411f461d2dcSChristoph Hellwig  * @buffer: the user buffer
1412f461d2dcSChristoph Hellwig  * @lenp: the size of the user buffer
1413f461d2dcSChristoph Hellwig  * @ppos: file position
1414f461d2dcSChristoph Hellwig  *
1415f461d2dcSChristoph Hellwig  * The bitmap is stored at table->data and the bitmap length (in bits)
1416f461d2dcSChristoph Hellwig  * in table->maxlen.
1417f461d2dcSChristoph Hellwig  *
1418f461d2dcSChristoph Hellwig  * We use a range comma separated format (e.g. 1,3-4,10-10) so that
1419f461d2dcSChristoph Hellwig  * large bitmaps may be represented in a compact manner. Writing into
1420f461d2dcSChristoph Hellwig  * the file will clear the bitmap then update it with the given input.
1421f461d2dcSChristoph Hellwig  *
1422f461d2dcSChristoph Hellwig  * Returns 0 on success.
1423f461d2dcSChristoph Hellwig  */
1424f461d2dcSChristoph Hellwig int proc_do_large_bitmap(struct ctl_table *table, int write,
142532927393SChristoph Hellwig 			 void *buffer, size_t *lenp, loff_t *ppos)
1426f461d2dcSChristoph Hellwig {
1427f461d2dcSChristoph Hellwig 	int err = 0;
1428f461d2dcSChristoph Hellwig 	bool first = 1;
1429f461d2dcSChristoph Hellwig 	size_t left = *lenp;
1430f461d2dcSChristoph Hellwig 	unsigned long bitmap_len = table->maxlen;
1431f461d2dcSChristoph Hellwig 	unsigned long *bitmap = *(unsigned long **) table->data;
1432f461d2dcSChristoph Hellwig 	unsigned long *tmp_bitmap = NULL;
1433f461d2dcSChristoph Hellwig 	char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
1434f461d2dcSChristoph Hellwig 
1435f461d2dcSChristoph Hellwig 	if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
1436f461d2dcSChristoph Hellwig 		*lenp = 0;
1437f461d2dcSChristoph Hellwig 		return 0;
1438f461d2dcSChristoph Hellwig 	}
1439f461d2dcSChristoph Hellwig 
1440f461d2dcSChristoph Hellwig 	if (write) {
144132927393SChristoph Hellwig 		char *p = buffer;
1442f461d2dcSChristoph Hellwig 		size_t skipped = 0;
1443f461d2dcSChristoph Hellwig 
1444f461d2dcSChristoph Hellwig 		if (left > PAGE_SIZE - 1) {
1445f461d2dcSChristoph Hellwig 			left = PAGE_SIZE - 1;
1446f461d2dcSChristoph Hellwig 			/* How much of the buffer we'll skip this pass */
1447f461d2dcSChristoph Hellwig 			skipped = *lenp - left;
1448f461d2dcSChristoph Hellwig 		}
1449f461d2dcSChristoph Hellwig 
1450f461d2dcSChristoph Hellwig 		tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL);
145132927393SChristoph Hellwig 		if (!tmp_bitmap)
1452f461d2dcSChristoph Hellwig 			return -ENOMEM;
1453f461d2dcSChristoph Hellwig 		proc_skip_char(&p, &left, '\n');
1454f461d2dcSChristoph Hellwig 		while (!err && left) {
1455f461d2dcSChristoph Hellwig 			unsigned long val_a, val_b;
1456f461d2dcSChristoph Hellwig 			bool neg;
1457f461d2dcSChristoph Hellwig 			size_t saved_left;
1458f461d2dcSChristoph Hellwig 
1459f461d2dcSChristoph Hellwig 			/* In case we stop parsing mid-number, we can reset */
1460f461d2dcSChristoph Hellwig 			saved_left = left;
1461f461d2dcSChristoph Hellwig 			err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
1462f461d2dcSChristoph Hellwig 					     sizeof(tr_a), &c);
1463f461d2dcSChristoph Hellwig 			/*
1464f461d2dcSChristoph Hellwig 			 * If we consumed the entirety of a truncated buffer or
1465f461d2dcSChristoph Hellwig 			 * only one char is left (may be a "-"), then stop here,
1466f461d2dcSChristoph Hellwig 			 * reset, & come back for more.
1467f461d2dcSChristoph Hellwig 			 */
1468f461d2dcSChristoph Hellwig 			if ((left <= 1) && skipped) {
1469f461d2dcSChristoph Hellwig 				left = saved_left;
1470f461d2dcSChristoph Hellwig 				break;
1471f461d2dcSChristoph Hellwig 			}
1472f461d2dcSChristoph Hellwig 
1473f461d2dcSChristoph Hellwig 			if (err)
1474f461d2dcSChristoph Hellwig 				break;
1475f461d2dcSChristoph Hellwig 			if (val_a >= bitmap_len || neg) {
1476f461d2dcSChristoph Hellwig 				err = -EINVAL;
1477f461d2dcSChristoph Hellwig 				break;
1478f461d2dcSChristoph Hellwig 			}
1479f461d2dcSChristoph Hellwig 
1480f461d2dcSChristoph Hellwig 			val_b = val_a;
1481f461d2dcSChristoph Hellwig 			if (left) {
1482f461d2dcSChristoph Hellwig 				p++;
1483f461d2dcSChristoph Hellwig 				left--;
1484f461d2dcSChristoph Hellwig 			}
1485f461d2dcSChristoph Hellwig 
1486f461d2dcSChristoph Hellwig 			if (c == '-') {
1487f461d2dcSChristoph Hellwig 				err = proc_get_long(&p, &left, &val_b,
1488f461d2dcSChristoph Hellwig 						     &neg, tr_b, sizeof(tr_b),
1489f461d2dcSChristoph Hellwig 						     &c);
1490f461d2dcSChristoph Hellwig 				/*
1491f461d2dcSChristoph Hellwig 				 * If we consumed all of a truncated buffer or
1492f461d2dcSChristoph Hellwig 				 * then stop here, reset, & come back for more.
1493f461d2dcSChristoph Hellwig 				 */
1494f461d2dcSChristoph Hellwig 				if (!left && skipped) {
1495f461d2dcSChristoph Hellwig 					left = saved_left;
1496f461d2dcSChristoph Hellwig 					break;
1497f461d2dcSChristoph Hellwig 				}
1498f461d2dcSChristoph Hellwig 
1499f461d2dcSChristoph Hellwig 				if (err)
1500f461d2dcSChristoph Hellwig 					break;
1501f461d2dcSChristoph Hellwig 				if (val_b >= bitmap_len || neg ||
1502f461d2dcSChristoph Hellwig 				    val_a > val_b) {
1503f461d2dcSChristoph Hellwig 					err = -EINVAL;
1504f461d2dcSChristoph Hellwig 					break;
1505f461d2dcSChristoph Hellwig 				}
1506f461d2dcSChristoph Hellwig 				if (left) {
1507f461d2dcSChristoph Hellwig 					p++;
1508f461d2dcSChristoph Hellwig 					left--;
1509f461d2dcSChristoph Hellwig 				}
1510f461d2dcSChristoph Hellwig 			}
1511f461d2dcSChristoph Hellwig 
1512f461d2dcSChristoph Hellwig 			bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
1513f461d2dcSChristoph Hellwig 			first = 0;
1514f461d2dcSChristoph Hellwig 			proc_skip_char(&p, &left, '\n');
1515f461d2dcSChristoph Hellwig 		}
1516f461d2dcSChristoph Hellwig 		left += skipped;
1517f461d2dcSChristoph Hellwig 	} else {
1518f461d2dcSChristoph Hellwig 		unsigned long bit_a, bit_b = 0;
1519f461d2dcSChristoph Hellwig 
1520f461d2dcSChristoph Hellwig 		while (left) {
1521f461d2dcSChristoph Hellwig 			bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
1522f461d2dcSChristoph Hellwig 			if (bit_a >= bitmap_len)
1523f461d2dcSChristoph Hellwig 				break;
1524f461d2dcSChristoph Hellwig 			bit_b = find_next_zero_bit(bitmap, bitmap_len,
1525f461d2dcSChristoph Hellwig 						   bit_a + 1) - 1;
1526f461d2dcSChristoph Hellwig 
152732927393SChristoph Hellwig 			if (!first)
152832927393SChristoph Hellwig 				proc_put_char(&buffer, &left, ',');
152932927393SChristoph Hellwig 			proc_put_long(&buffer, &left, bit_a, false);
1530f461d2dcSChristoph Hellwig 			if (bit_a != bit_b) {
153132927393SChristoph Hellwig 				proc_put_char(&buffer, &left, '-');
153232927393SChristoph Hellwig 				proc_put_long(&buffer, &left, bit_b, false);
1533f461d2dcSChristoph Hellwig 			}
1534f461d2dcSChristoph Hellwig 
1535f461d2dcSChristoph Hellwig 			first = 0; bit_b++;
1536f461d2dcSChristoph Hellwig 		}
153732927393SChristoph Hellwig 		proc_put_char(&buffer, &left, '\n');
1538f461d2dcSChristoph Hellwig 	}
1539f461d2dcSChristoph Hellwig 
1540f461d2dcSChristoph Hellwig 	if (!err) {
1541f461d2dcSChristoph Hellwig 		if (write) {
1542f461d2dcSChristoph Hellwig 			if (*ppos)
1543f461d2dcSChristoph Hellwig 				bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
1544f461d2dcSChristoph Hellwig 			else
1545f461d2dcSChristoph Hellwig 				bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
1546f461d2dcSChristoph Hellwig 		}
1547f461d2dcSChristoph Hellwig 		*lenp -= left;
1548f461d2dcSChristoph Hellwig 		*ppos += *lenp;
1549f461d2dcSChristoph Hellwig 	}
1550f461d2dcSChristoph Hellwig 
1551f461d2dcSChristoph Hellwig 	bitmap_free(tmp_bitmap);
1552f461d2dcSChristoph Hellwig 	return err;
1553f461d2dcSChristoph Hellwig }
1554f461d2dcSChristoph Hellwig 
1555f461d2dcSChristoph Hellwig #else /* CONFIG_PROC_SYSCTL */
1556f461d2dcSChristoph Hellwig 
1557f461d2dcSChristoph Hellwig int proc_dostring(struct ctl_table *table, int write,
155832927393SChristoph Hellwig 		  void *buffer, size_t *lenp, loff_t *ppos)
1559f461d2dcSChristoph Hellwig {
1560f461d2dcSChristoph Hellwig 	return -ENOSYS;
1561f461d2dcSChristoph Hellwig }
1562f461d2dcSChristoph Hellwig 
1563f461d2dcSChristoph Hellwig int proc_dointvec(struct ctl_table *table, int write,
156432927393SChristoph Hellwig 		  void *buffer, size_t *lenp, loff_t *ppos)
1565f461d2dcSChristoph Hellwig {
1566f461d2dcSChristoph Hellwig 	return -ENOSYS;
1567f461d2dcSChristoph Hellwig }
1568f461d2dcSChristoph Hellwig 
1569f461d2dcSChristoph Hellwig int proc_douintvec(struct ctl_table *table, int write,
157032927393SChristoph Hellwig 		  void *buffer, size_t *lenp, loff_t *ppos)
1571f461d2dcSChristoph Hellwig {
1572f461d2dcSChristoph Hellwig 	return -ENOSYS;
1573f461d2dcSChristoph Hellwig }
1574f461d2dcSChristoph Hellwig 
1575f461d2dcSChristoph Hellwig int proc_dointvec_minmax(struct ctl_table *table, int write,
157632927393SChristoph Hellwig 		    void *buffer, size_t *lenp, loff_t *ppos)
1577f461d2dcSChristoph Hellwig {
1578f461d2dcSChristoph Hellwig 	return -ENOSYS;
1579f461d2dcSChristoph Hellwig }
1580f461d2dcSChristoph Hellwig 
1581f461d2dcSChristoph Hellwig int proc_douintvec_minmax(struct ctl_table *table, int write,
158232927393SChristoph Hellwig 			  void *buffer, size_t *lenp, loff_t *ppos)
1583f461d2dcSChristoph Hellwig {
1584f461d2dcSChristoph Hellwig 	return -ENOSYS;
1585f461d2dcSChristoph Hellwig }
1586f461d2dcSChristoph Hellwig 
1587f461d2dcSChristoph Hellwig int proc_dointvec_jiffies(struct ctl_table *table, int write,
158832927393SChristoph Hellwig 		    void *buffer, size_t *lenp, loff_t *ppos)
1589f461d2dcSChristoph Hellwig {
1590f461d2dcSChristoph Hellwig 	return -ENOSYS;
1591f461d2dcSChristoph Hellwig }
1592f461d2dcSChristoph Hellwig 
1593f461d2dcSChristoph Hellwig int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
159432927393SChristoph Hellwig 		    void *buffer, size_t *lenp, loff_t *ppos)
1595f461d2dcSChristoph Hellwig {
1596f461d2dcSChristoph Hellwig 	return -ENOSYS;
1597f461d2dcSChristoph Hellwig }
1598f461d2dcSChristoph Hellwig 
1599f461d2dcSChristoph Hellwig int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
160032927393SChristoph Hellwig 			     void *buffer, size_t *lenp, loff_t *ppos)
1601f461d2dcSChristoph Hellwig {
1602f461d2dcSChristoph Hellwig 	return -ENOSYS;
1603f461d2dcSChristoph Hellwig }
1604f461d2dcSChristoph Hellwig 
1605f461d2dcSChristoph Hellwig int proc_doulongvec_minmax(struct ctl_table *table, int write,
160632927393SChristoph Hellwig 		    void *buffer, size_t *lenp, loff_t *ppos)
1607f461d2dcSChristoph Hellwig {
1608f461d2dcSChristoph Hellwig 	return -ENOSYS;
1609f461d2dcSChristoph Hellwig }
1610f461d2dcSChristoph Hellwig 
1611f461d2dcSChristoph Hellwig int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
161232927393SChristoph Hellwig 				      void *buffer, size_t *lenp, loff_t *ppos)
1613f461d2dcSChristoph Hellwig {
1614f461d2dcSChristoph Hellwig 	return -ENOSYS;
1615f461d2dcSChristoph Hellwig }
1616f461d2dcSChristoph Hellwig 
1617f461d2dcSChristoph Hellwig int proc_do_large_bitmap(struct ctl_table *table, int write,
161832927393SChristoph Hellwig 			 void *buffer, size_t *lenp, loff_t *ppos)
1619f461d2dcSChristoph Hellwig {
1620f461d2dcSChristoph Hellwig 	return -ENOSYS;
1621f461d2dcSChristoph Hellwig }
1622f461d2dcSChristoph Hellwig 
1623f461d2dcSChristoph Hellwig #endif /* CONFIG_PROC_SYSCTL */
1624f461d2dcSChristoph Hellwig 
1625f461d2dcSChristoph Hellwig #if defined(CONFIG_SYSCTL)
1626f461d2dcSChristoph Hellwig int proc_do_static_key(struct ctl_table *table, int write,
162732927393SChristoph Hellwig 		       void *buffer, size_t *lenp, loff_t *ppos)
1628f461d2dcSChristoph Hellwig {
1629f461d2dcSChristoph Hellwig 	struct static_key *key = (struct static_key *)table->data;
1630f461d2dcSChristoph Hellwig 	static DEFINE_MUTEX(static_key_mutex);
1631f461d2dcSChristoph Hellwig 	int val, ret;
1632f461d2dcSChristoph Hellwig 	struct ctl_table tmp = {
1633f461d2dcSChristoph Hellwig 		.data   = &val,
1634f461d2dcSChristoph Hellwig 		.maxlen = sizeof(val),
1635f461d2dcSChristoph Hellwig 		.mode   = table->mode,
1636f461d2dcSChristoph Hellwig 		.extra1 = SYSCTL_ZERO,
1637f461d2dcSChristoph Hellwig 		.extra2 = SYSCTL_ONE,
1638f461d2dcSChristoph Hellwig 	};
1639f461d2dcSChristoph Hellwig 
1640f461d2dcSChristoph Hellwig 	if (write && !capable(CAP_SYS_ADMIN))
1641f461d2dcSChristoph Hellwig 		return -EPERM;
1642f461d2dcSChristoph Hellwig 
1643f461d2dcSChristoph Hellwig 	mutex_lock(&static_key_mutex);
1644f461d2dcSChristoph Hellwig 	val = static_key_enabled(key);
1645f461d2dcSChristoph Hellwig 	ret = proc_dointvec_minmax(&tmp, write, buffer, lenp, ppos);
1646f461d2dcSChristoph Hellwig 	if (write && !ret) {
1647f461d2dcSChristoph Hellwig 		if (val)
1648f461d2dcSChristoph Hellwig 			static_key_enable(key);
1649f461d2dcSChristoph Hellwig 		else
1650f461d2dcSChristoph Hellwig 			static_key_disable(key);
1651f461d2dcSChristoph Hellwig 	}
1652f461d2dcSChristoph Hellwig 	mutex_unlock(&static_key_mutex);
1653f461d2dcSChristoph Hellwig 	return ret;
1654f461d2dcSChristoph Hellwig }
1655f461d2dcSChristoph Hellwig 
1656d8217f07SEric W. Biederman static struct ctl_table kern_table[] = {
16572bba22c5SMike Galbraith 	{
16582bba22c5SMike Galbraith 		.procname	= "sched_child_runs_first",
16592bba22c5SMike Galbraith 		.data		= &sysctl_sched_child_runs_first,
16602bba22c5SMike Galbraith 		.maxlen		= sizeof(unsigned int),
16612bba22c5SMike Galbraith 		.mode		= 0644,
16626d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
16632bba22c5SMike Galbraith 	},
166477e54a1fSIngo Molnar #ifdef CONFIG_SCHED_DEBUG
166577e54a1fSIngo Molnar 	{
1666b2be5e96SPeter Zijlstra 		.procname	= "sched_min_granularity_ns",
1667b2be5e96SPeter Zijlstra 		.data		= &sysctl_sched_min_granularity,
166877e54a1fSIngo Molnar 		.maxlen		= sizeof(unsigned int),
166977e54a1fSIngo Molnar 		.mode		= 0644,
1670702a7c76SLinus Torvalds 		.proc_handler	= sched_proc_update_handler,
1671b2be5e96SPeter Zijlstra 		.extra1		= &min_sched_granularity_ns,
1672b2be5e96SPeter Zijlstra 		.extra2		= &max_sched_granularity_ns,
167377e54a1fSIngo Molnar 	},
167477e54a1fSIngo Molnar 	{
167521805085SPeter Zijlstra 		.procname	= "sched_latency_ns",
167621805085SPeter Zijlstra 		.data		= &sysctl_sched_latency,
167721805085SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
167821805085SPeter Zijlstra 		.mode		= 0644,
1679702a7c76SLinus Torvalds 		.proc_handler	= sched_proc_update_handler,
168021805085SPeter Zijlstra 		.extra1		= &min_sched_granularity_ns,
168121805085SPeter Zijlstra 		.extra2		= &max_sched_granularity_ns,
168221805085SPeter Zijlstra 	},
168321805085SPeter Zijlstra 	{
168477e54a1fSIngo Molnar 		.procname	= "sched_wakeup_granularity_ns",
168577e54a1fSIngo Molnar 		.data		= &sysctl_sched_wakeup_granularity,
168677e54a1fSIngo Molnar 		.maxlen		= sizeof(unsigned int),
168777e54a1fSIngo Molnar 		.mode		= 0644,
1688702a7c76SLinus Torvalds 		.proc_handler	= sched_proc_update_handler,
168977e54a1fSIngo Molnar 		.extra1		= &min_wakeup_granularity_ns,
169077e54a1fSIngo Molnar 		.extra2		= &max_wakeup_granularity_ns,
169177e54a1fSIngo Molnar 	},
1692cbee9f88SPeter Zijlstra #ifdef CONFIG_SMP
169377e54a1fSIngo Molnar 	{
16941983a922SChristian Ehrhardt 		.procname	= "sched_tunable_scaling",
16951983a922SChristian Ehrhardt 		.data		= &sysctl_sched_tunable_scaling,
16961983a922SChristian Ehrhardt 		.maxlen		= sizeof(enum sched_tunable_scaling),
16971983a922SChristian Ehrhardt 		.mode		= 0644,
1698702a7c76SLinus Torvalds 		.proc_handler	= sched_proc_update_handler,
16991983a922SChristian Ehrhardt 		.extra1		= &min_sched_tunable_scaling,
17001983a922SChristian Ehrhardt 		.extra2		= &max_sched_tunable_scaling,
17012398f2c6SPeter Zijlstra 	},
17022398f2c6SPeter Zijlstra 	{
1703d00535dbSNamhyung Kim 		.procname	= "sched_migration_cost_ns",
1704da84d961SIngo Molnar 		.data		= &sysctl_sched_migration_cost,
1705da84d961SIngo Molnar 		.maxlen		= sizeof(unsigned int),
1706da84d961SIngo Molnar 		.mode		= 0644,
17076d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1708da84d961SIngo Molnar 	},
1709b82d9fddSPeter Zijlstra 	{
1710b82d9fddSPeter Zijlstra 		.procname	= "sched_nr_migrate",
1711b82d9fddSPeter Zijlstra 		.data		= &sysctl_sched_nr_migrate,
1712b82d9fddSPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
1713fa85ae24SPeter Zijlstra 		.mode		= 0644,
17146d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1715fa85ae24SPeter Zijlstra 	},
1716cb251765SMel Gorman #ifdef CONFIG_SCHEDSTATS
1717cb251765SMel Gorman 	{
1718cb251765SMel Gorman 		.procname	= "sched_schedstats",
1719cb251765SMel Gorman 		.data		= NULL,
1720cb251765SMel Gorman 		.maxlen		= sizeof(unsigned int),
1721cb251765SMel Gorman 		.mode		= 0644,
1722cb251765SMel Gorman 		.proc_handler	= sysctl_schedstats,
1723eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
1724eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
1725cb251765SMel Gorman 	},
1726cb251765SMel Gorman #endif /* CONFIG_SCHEDSTATS */
1727cbee9f88SPeter Zijlstra #endif /* CONFIG_SMP */
1728cbee9f88SPeter Zijlstra #ifdef CONFIG_NUMA_BALANCING
1729cbee9f88SPeter Zijlstra 	{
17304b96a29bSPeter Zijlstra 		.procname	= "numa_balancing_scan_delay_ms",
17314b96a29bSPeter Zijlstra 		.data		= &sysctl_numa_balancing_scan_delay,
17324b96a29bSPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
17334b96a29bSPeter Zijlstra 		.mode		= 0644,
17344b96a29bSPeter Zijlstra 		.proc_handler	= proc_dointvec,
17354b96a29bSPeter Zijlstra 	},
17364b96a29bSPeter Zijlstra 	{
1737cbee9f88SPeter Zijlstra 		.procname	= "numa_balancing_scan_period_min_ms",
1738cbee9f88SPeter Zijlstra 		.data		= &sysctl_numa_balancing_scan_period_min,
1739cbee9f88SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
1740cbee9f88SPeter Zijlstra 		.mode		= 0644,
1741cbee9f88SPeter Zijlstra 		.proc_handler	= proc_dointvec,
1742cbee9f88SPeter Zijlstra 	},
1743cbee9f88SPeter Zijlstra 	{
1744cbee9f88SPeter Zijlstra 		.procname	= "numa_balancing_scan_period_max_ms",
1745cbee9f88SPeter Zijlstra 		.data		= &sysctl_numa_balancing_scan_period_max,
1746cbee9f88SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
1747cbee9f88SPeter Zijlstra 		.mode		= 0644,
1748cbee9f88SPeter Zijlstra 		.proc_handler	= proc_dointvec,
1749cbee9f88SPeter Zijlstra 	},
17506e5fb223SPeter Zijlstra 	{
17516e5fb223SPeter Zijlstra 		.procname	= "numa_balancing_scan_size_mb",
17526e5fb223SPeter Zijlstra 		.data		= &sysctl_numa_balancing_scan_size,
17536e5fb223SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
17546e5fb223SPeter Zijlstra 		.mode		= 0644,
175564192658SKirill Tkhai 		.proc_handler	= proc_dointvec_minmax,
1756eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
17576e5fb223SPeter Zijlstra 	},
17583a7053b3SMel Gorman 	{
175954a43d54SAndi Kleen 		.procname	= "numa_balancing",
176054a43d54SAndi Kleen 		.data		= NULL, /* filled in by handler */
176154a43d54SAndi Kleen 		.maxlen		= sizeof(unsigned int),
176254a43d54SAndi Kleen 		.mode		= 0644,
176354a43d54SAndi Kleen 		.proc_handler	= sysctl_numa_balancing,
1764eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
1765eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
176654a43d54SAndi Kleen 	},
1767cbee9f88SPeter Zijlstra #endif /* CONFIG_NUMA_BALANCING */
1768cbee9f88SPeter Zijlstra #endif /* CONFIG_SCHED_DEBUG */
17691799e35dSIngo Molnar 	{
17709f0c1e56SPeter Zijlstra 		.procname	= "sched_rt_period_us",
17719f0c1e56SPeter Zijlstra 		.data		= &sysctl_sched_rt_period,
17729f0c1e56SPeter Zijlstra 		.maxlen		= sizeof(unsigned int),
17739f0c1e56SPeter Zijlstra 		.mode		= 0644,
17746d456111SEric W. Biederman 		.proc_handler	= sched_rt_handler,
17759f0c1e56SPeter Zijlstra 	},
17769f0c1e56SPeter Zijlstra 	{
17779f0c1e56SPeter Zijlstra 		.procname	= "sched_rt_runtime_us",
17789f0c1e56SPeter Zijlstra 		.data		= &sysctl_sched_rt_runtime,
17799f0c1e56SPeter Zijlstra 		.maxlen		= sizeof(int),
17809f0c1e56SPeter Zijlstra 		.mode		= 0644,
17816d456111SEric W. Biederman 		.proc_handler	= sched_rt_handler,
17829f0c1e56SPeter Zijlstra 	},
1783ce0dbbbbSClark Williams 	{
1784ce0dbbbbSClark Williams 		.procname	= "sched_rr_timeslice_ms",
1785975e155eSShile Zhang 		.data		= &sysctl_sched_rr_timeslice,
1786ce0dbbbbSClark Williams 		.maxlen		= sizeof(int),
1787ce0dbbbbSClark Williams 		.mode		= 0644,
1788ce0dbbbbSClark Williams 		.proc_handler	= sched_rr_handler,
1789ce0dbbbbSClark Williams 	},
1790e8f14172SPatrick Bellasi #ifdef CONFIG_UCLAMP_TASK
1791e8f14172SPatrick Bellasi 	{
1792e8f14172SPatrick Bellasi 		.procname	= "sched_util_clamp_min",
1793e8f14172SPatrick Bellasi 		.data		= &sysctl_sched_uclamp_util_min,
1794e8f14172SPatrick Bellasi 		.maxlen		= sizeof(unsigned int),
1795e8f14172SPatrick Bellasi 		.mode		= 0644,
1796e8f14172SPatrick Bellasi 		.proc_handler	= sysctl_sched_uclamp_handler,
1797e8f14172SPatrick Bellasi 	},
1798e8f14172SPatrick Bellasi 	{
1799e8f14172SPatrick Bellasi 		.procname	= "sched_util_clamp_max",
1800e8f14172SPatrick Bellasi 		.data		= &sysctl_sched_uclamp_util_max,
1801e8f14172SPatrick Bellasi 		.maxlen		= sizeof(unsigned int),
1802e8f14172SPatrick Bellasi 		.mode		= 0644,
1803e8f14172SPatrick Bellasi 		.proc_handler	= sysctl_sched_uclamp_handler,
1804e8f14172SPatrick Bellasi 	},
1805e8f14172SPatrick Bellasi #endif
18065091faa4SMike Galbraith #ifdef CONFIG_SCHED_AUTOGROUP
18075091faa4SMike Galbraith 	{
18085091faa4SMike Galbraith 		.procname	= "sched_autogroup_enabled",
18095091faa4SMike Galbraith 		.data		= &sysctl_sched_autogroup_enabled,
18105091faa4SMike Galbraith 		.maxlen		= sizeof(unsigned int),
18115091faa4SMike Galbraith 		.mode		= 0644,
18121747b21fSYong Zhang 		.proc_handler	= proc_dointvec_minmax,
1813eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
1814eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
18155091faa4SMike Galbraith 	},
18165091faa4SMike Galbraith #endif
1817ec12cb7fSPaul Turner #ifdef CONFIG_CFS_BANDWIDTH
1818ec12cb7fSPaul Turner 	{
1819ec12cb7fSPaul Turner 		.procname	= "sched_cfs_bandwidth_slice_us",
1820ec12cb7fSPaul Turner 		.data		= &sysctl_sched_cfs_bandwidth_slice,
1821ec12cb7fSPaul Turner 		.maxlen		= sizeof(unsigned int),
1822ec12cb7fSPaul Turner 		.mode		= 0644,
1823ec12cb7fSPaul Turner 		.proc_handler	= proc_dointvec_minmax,
1824eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
1825ec12cb7fSPaul Turner 	},
1826ec12cb7fSPaul Turner #endif
18278d5d0cfbSQuentin Perret #if defined(CONFIG_ENERGY_MODEL) && defined(CONFIG_CPU_FREQ_GOV_SCHEDUTIL)
18288d5d0cfbSQuentin Perret 	{
18298d5d0cfbSQuentin Perret 		.procname	= "sched_energy_aware",
18308d5d0cfbSQuentin Perret 		.data		= &sysctl_sched_energy_aware,
18318d5d0cfbSQuentin Perret 		.maxlen		= sizeof(unsigned int),
18328d5d0cfbSQuentin Perret 		.mode		= 0644,
18338d5d0cfbSQuentin Perret 		.proc_handler	= sched_energy_aware_handler,
1834eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
1835eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
18368d5d0cfbSQuentin Perret 	},
18378d5d0cfbSQuentin Perret #endif
1838f20786ffSPeter Zijlstra #ifdef CONFIG_PROVE_LOCKING
1839f20786ffSPeter Zijlstra 	{
1840f20786ffSPeter Zijlstra 		.procname	= "prove_locking",
1841f20786ffSPeter Zijlstra 		.data		= &prove_locking,
1842f20786ffSPeter Zijlstra 		.maxlen		= sizeof(int),
1843f20786ffSPeter Zijlstra 		.mode		= 0644,
18446d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1845f20786ffSPeter Zijlstra 	},
1846f20786ffSPeter Zijlstra #endif
1847f20786ffSPeter Zijlstra #ifdef CONFIG_LOCK_STAT
1848f20786ffSPeter Zijlstra 	{
1849f20786ffSPeter Zijlstra 		.procname	= "lock_stat",
1850f20786ffSPeter Zijlstra 		.data		= &lock_stat,
1851f20786ffSPeter Zijlstra 		.maxlen		= sizeof(int),
1852f20786ffSPeter Zijlstra 		.mode		= 0644,
18536d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1854f20786ffSPeter Zijlstra 	},
1855f20786ffSPeter Zijlstra #endif
185677e54a1fSIngo Molnar 	{
18571da177e4SLinus Torvalds 		.procname	= "panic",
18581da177e4SLinus Torvalds 		.data		= &panic_timeout,
18591da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
18601da177e4SLinus Torvalds 		.mode		= 0644,
18616d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
18621da177e4SLinus Torvalds 	},
1863046d662fSAlex Kelly #ifdef CONFIG_COREDUMP
18641da177e4SLinus Torvalds 	{
18651da177e4SLinus Torvalds 		.procname	= "core_uses_pid",
18661da177e4SLinus Torvalds 		.data		= &core_uses_pid,
18671da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
18681da177e4SLinus Torvalds 		.mode		= 0644,
18696d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
18701da177e4SLinus Torvalds 	},
18711da177e4SLinus Torvalds 	{
18721da177e4SLinus Torvalds 		.procname	= "core_pattern",
18731da177e4SLinus Torvalds 		.data		= core_pattern,
187471ce92f3SDan Aloni 		.maxlen		= CORENAME_MAX_SIZE,
18751da177e4SLinus Torvalds 		.mode		= 0644,
187654b50199SKees Cook 		.proc_handler	= proc_dostring_coredump,
18771da177e4SLinus Torvalds 	},
1878a293980cSNeil Horman 	{
1879a293980cSNeil Horman 		.procname	= "core_pipe_limit",
1880a293980cSNeil Horman 		.data		= &core_pipe_limit,
1881a293980cSNeil Horman 		.maxlen		= sizeof(unsigned int),
1882a293980cSNeil Horman 		.mode		= 0644,
18836d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
1884a293980cSNeil Horman 	},
1885046d662fSAlex Kelly #endif
188634f5a398STheodore Ts'o #ifdef CONFIG_PROC_SYSCTL
18871da177e4SLinus Torvalds 	{
18881da177e4SLinus Torvalds 		.procname	= "tainted",
188925ddbb18SAndi Kleen 		.maxlen 	= sizeof(long),
189034f5a398STheodore Ts'o 		.mode		= 0644,
18916d456111SEric W. Biederman 		.proc_handler	= proc_taint,
18921da177e4SLinus Torvalds 	},
1893f4aacea2SKees Cook 	{
1894f4aacea2SKees Cook 		.procname	= "sysctl_writes_strict",
1895f4aacea2SKees Cook 		.data		= &sysctl_writes_strict,
1896f4aacea2SKees Cook 		.maxlen		= sizeof(int),
1897f4aacea2SKees Cook 		.mode		= 0644,
1898f4aacea2SKees Cook 		.proc_handler	= proc_dointvec_minmax,
1899f4aacea2SKees Cook 		.extra1		= &neg_one,
1900eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
1901f4aacea2SKees Cook 	},
190234f5a398STheodore Ts'o #endif
19039745512cSArjan van de Ven #ifdef CONFIG_LATENCYTOP
19049745512cSArjan van de Ven 	{
19059745512cSArjan van de Ven 		.procname	= "latencytop",
19069745512cSArjan van de Ven 		.data		= &latencytop_enabled,
19079745512cSArjan van de Ven 		.maxlen		= sizeof(int),
19089745512cSArjan van de Ven 		.mode		= 0644,
1909cb251765SMel Gorman 		.proc_handler	= sysctl_latencytop,
19109745512cSArjan van de Ven 	},
19119745512cSArjan van de Ven #endif
19121da177e4SLinus Torvalds #ifdef CONFIG_BLK_DEV_INITRD
19131da177e4SLinus Torvalds 	{
19141da177e4SLinus Torvalds 		.procname	= "real-root-dev",
19151da177e4SLinus Torvalds 		.data		= &real_root_dev,
19161da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
19171da177e4SLinus Torvalds 		.mode		= 0644,
19186d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
19191da177e4SLinus Torvalds 	},
19201da177e4SLinus Torvalds #endif
192145807a1dSIngo Molnar 	{
192245807a1dSIngo Molnar 		.procname	= "print-fatal-signals",
192345807a1dSIngo Molnar 		.data		= &print_fatal_signals,
192445807a1dSIngo Molnar 		.maxlen		= sizeof(int),
192545807a1dSIngo Molnar 		.mode		= 0644,
19266d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
192745807a1dSIngo Molnar 	},
192872c57ed5SDavid S. Miller #ifdef CONFIG_SPARC
19291da177e4SLinus Torvalds 	{
19301da177e4SLinus Torvalds 		.procname	= "reboot-cmd",
19311da177e4SLinus Torvalds 		.data		= reboot_command,
19321da177e4SLinus Torvalds 		.maxlen		= 256,
19331da177e4SLinus Torvalds 		.mode		= 0644,
19346d456111SEric W. Biederman 		.proc_handler	= proc_dostring,
19351da177e4SLinus Torvalds 	},
19361da177e4SLinus Torvalds 	{
19371da177e4SLinus Torvalds 		.procname	= "stop-a",
19381da177e4SLinus Torvalds 		.data		= &stop_a_enabled,
19391da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
19401da177e4SLinus Torvalds 		.mode		= 0644,
19416d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
19421da177e4SLinus Torvalds 	},
19431da177e4SLinus Torvalds 	{
19441da177e4SLinus Torvalds 		.procname	= "scons-poweroff",
19451da177e4SLinus Torvalds 		.data		= &scons_pwroff,
19461da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
19471da177e4SLinus Torvalds 		.mode		= 0644,
19486d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
19491da177e4SLinus Torvalds 	},
19501da177e4SLinus Torvalds #endif
19510871420fSDavid S. Miller #ifdef CONFIG_SPARC64
19520871420fSDavid S. Miller 	{
19530871420fSDavid S. Miller 		.procname	= "tsb-ratio",
19540871420fSDavid S. Miller 		.data		= &sysctl_tsb_ratio,
19550871420fSDavid S. Miller 		.maxlen		= sizeof (int),
19560871420fSDavid S. Miller 		.mode		= 0644,
19576d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
19580871420fSDavid S. Miller 	},
19590871420fSDavid S. Miller #endif
1960b67114dbSHelge Deller #ifdef CONFIG_PARISC
19611da177e4SLinus Torvalds 	{
19621da177e4SLinus Torvalds 		.procname	= "soft-power",
19631da177e4SLinus Torvalds 		.data		= &pwrsw_enabled,
19641da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
19651da177e4SLinus Torvalds 		.mode		= 0644,
19666d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
19671da177e4SLinus Torvalds 	},
1968bf14e3b9SVineet Gupta #endif
1969bf14e3b9SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
19701da177e4SLinus Torvalds 	{
19711da177e4SLinus Torvalds 		.procname	= "unaligned-trap",
19721da177e4SLinus Torvalds 		.data		= &unaligned_enabled,
19731da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
19741da177e4SLinus Torvalds 		.mode		= 0644,
19756d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
19761da177e4SLinus Torvalds 	},
19771da177e4SLinus Torvalds #endif
19781da177e4SLinus Torvalds 	{
19791da177e4SLinus Torvalds 		.procname	= "ctrl-alt-del",
19801da177e4SLinus Torvalds 		.data		= &C_A_D,
19811da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
19821da177e4SLinus Torvalds 		.mode		= 0644,
19836d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
19841da177e4SLinus Torvalds 	},
1985606576ceSSteven Rostedt #ifdef CONFIG_FUNCTION_TRACER
1986b0fc494fSSteven Rostedt 	{
1987b0fc494fSSteven Rostedt 		.procname	= "ftrace_enabled",
1988b0fc494fSSteven Rostedt 		.data		= &ftrace_enabled,
1989b0fc494fSSteven Rostedt 		.maxlen		= sizeof(int),
1990b0fc494fSSteven Rostedt 		.mode		= 0644,
19916d456111SEric W. Biederman 		.proc_handler	= ftrace_enable_sysctl,
1992b0fc494fSSteven Rostedt 	},
1993b0fc494fSSteven Rostedt #endif
1994f38f1d2aSSteven Rostedt #ifdef CONFIG_STACK_TRACER
1995f38f1d2aSSteven Rostedt 	{
1996f38f1d2aSSteven Rostedt 		.procname	= "stack_tracer_enabled",
1997f38f1d2aSSteven Rostedt 		.data		= &stack_tracer_enabled,
1998f38f1d2aSSteven Rostedt 		.maxlen		= sizeof(int),
1999f38f1d2aSSteven Rostedt 		.mode		= 0644,
20006d456111SEric W. Biederman 		.proc_handler	= stack_trace_sysctl,
2001f38f1d2aSSteven Rostedt 	},
2002f38f1d2aSSteven Rostedt #endif
2003944ac425SSteven Rostedt #ifdef CONFIG_TRACING
2004944ac425SSteven Rostedt 	{
20053299b4ddSPeter Zijlstra 		.procname	= "ftrace_dump_on_oops",
2006944ac425SSteven Rostedt 		.data		= &ftrace_dump_on_oops,
2007944ac425SSteven Rostedt 		.maxlen		= sizeof(int),
2008944ac425SSteven Rostedt 		.mode		= 0644,
20096d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2010944ac425SSteven Rostedt 	},
2011de7edd31SSteven Rostedt (Red Hat) 	{
2012de7edd31SSteven Rostedt (Red Hat) 		.procname	= "traceoff_on_warning",
2013de7edd31SSteven Rostedt (Red Hat) 		.data		= &__disable_trace_on_warning,
2014de7edd31SSteven Rostedt (Red Hat) 		.maxlen		= sizeof(__disable_trace_on_warning),
2015de7edd31SSteven Rostedt (Red Hat) 		.mode		= 0644,
2016de7edd31SSteven Rostedt (Red Hat) 		.proc_handler	= proc_dointvec,
2017de7edd31SSteven Rostedt (Red Hat) 	},
20180daa2302SSteven Rostedt (Red Hat) 	{
20190daa2302SSteven Rostedt (Red Hat) 		.procname	= "tracepoint_printk",
20200daa2302SSteven Rostedt (Red Hat) 		.data		= &tracepoint_printk,
20210daa2302SSteven Rostedt (Red Hat) 		.maxlen		= sizeof(tracepoint_printk),
20220daa2302SSteven Rostedt (Red Hat) 		.mode		= 0644,
202342391745SSteven Rostedt (Red Hat) 		.proc_handler	= tracepoint_printk_sysctl,
20240daa2302SSteven Rostedt (Red Hat) 	},
2025944ac425SSteven Rostedt #endif
20262965faa5SDave Young #ifdef CONFIG_KEXEC_CORE
20277984754bSKees Cook 	{
20287984754bSKees Cook 		.procname	= "kexec_load_disabled",
20297984754bSKees Cook 		.data		= &kexec_load_disabled,
20307984754bSKees Cook 		.maxlen		= sizeof(int),
20317984754bSKees Cook 		.mode		= 0644,
20327984754bSKees Cook 		/* only handle a transition from default "0" to "1" */
20337984754bSKees Cook 		.proc_handler	= proc_dointvec_minmax,
2034eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
2035eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
20367984754bSKees Cook 	},
20377984754bSKees Cook #endif
2038a1ef5adbSJohannes Berg #ifdef CONFIG_MODULES
20391da177e4SLinus Torvalds 	{
20401da177e4SLinus Torvalds 		.procname	= "modprobe",
20411da177e4SLinus Torvalds 		.data		= &modprobe_path,
20421da177e4SLinus Torvalds 		.maxlen		= KMOD_PATH_LEN,
20431da177e4SLinus Torvalds 		.mode		= 0644,
20446d456111SEric W. Biederman 		.proc_handler	= proc_dostring,
20451da177e4SLinus Torvalds 	},
20463d43321bSKees Cook 	{
20473d43321bSKees Cook 		.procname	= "modules_disabled",
20483d43321bSKees Cook 		.data		= &modules_disabled,
20493d43321bSKees Cook 		.maxlen		= sizeof(int),
20503d43321bSKees Cook 		.mode		= 0644,
20513d43321bSKees Cook 		/* only handle a transition from default "0" to "1" */
20526d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
2053eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
2054eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
20553d43321bSKees Cook 	},
20561da177e4SLinus Torvalds #endif
205786d56134SMichael Marineau #ifdef CONFIG_UEVENT_HELPER
20581da177e4SLinus Torvalds 	{
20591da177e4SLinus Torvalds 		.procname	= "hotplug",
2060312c004dSKay Sievers 		.data		= &uevent_helper,
2061312c004dSKay Sievers 		.maxlen		= UEVENT_HELPER_PATH_LEN,
20621da177e4SLinus Torvalds 		.mode		= 0644,
20636d456111SEric W. Biederman 		.proc_handler	= proc_dostring,
20641da177e4SLinus Torvalds 	},
206586d56134SMichael Marineau #endif
20661da177e4SLinus Torvalds #ifdef CONFIG_CHR_DEV_SG
20671da177e4SLinus Torvalds 	{
20681da177e4SLinus Torvalds 		.procname	= "sg-big-buff",
20691da177e4SLinus Torvalds 		.data		= &sg_big_buff,
20701da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
20711da177e4SLinus Torvalds 		.mode		= 0444,
20726d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
20731da177e4SLinus Torvalds 	},
20741da177e4SLinus Torvalds #endif
20751da177e4SLinus Torvalds #ifdef CONFIG_BSD_PROCESS_ACCT
20761da177e4SLinus Torvalds 	{
20771da177e4SLinus Torvalds 		.procname	= "acct",
20781da177e4SLinus Torvalds 		.data		= &acct_parm,
20791da177e4SLinus Torvalds 		.maxlen		= 3*sizeof(int),
20801da177e4SLinus Torvalds 		.mode		= 0644,
20816d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
20821da177e4SLinus Torvalds 	},
20831da177e4SLinus Torvalds #endif
20841da177e4SLinus Torvalds #ifdef CONFIG_MAGIC_SYSRQ
20851da177e4SLinus Torvalds 	{
20861da177e4SLinus Torvalds 		.procname	= "sysrq",
2087eaee4172SDmitry Safonov 		.data		= NULL,
20881da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
20891da177e4SLinus Torvalds 		.mode		= 0644,
209097f5f0cdSDmitry Torokhov 		.proc_handler	= sysrq_sysctl_handler,
20911da177e4SLinus Torvalds 	},
20921da177e4SLinus Torvalds #endif
2093d6f8ff73SRandy Dunlap #ifdef CONFIG_PROC_SYSCTL
20941da177e4SLinus Torvalds 	{
20951da177e4SLinus Torvalds 		.procname	= "cad_pid",
20969ec52099SCedric Le Goater 		.data		= NULL,
20971da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
20981da177e4SLinus Torvalds 		.mode		= 0600,
20996d456111SEric W. Biederman 		.proc_handler	= proc_do_cad_pid,
21001da177e4SLinus Torvalds 	},
2101d6f8ff73SRandy Dunlap #endif
21021da177e4SLinus Torvalds 	{
21031da177e4SLinus Torvalds 		.procname	= "threads-max",
210416db3d3fSHeinrich Schuchardt 		.data		= NULL,
21051da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
21061da177e4SLinus Torvalds 		.mode		= 0644,
210716db3d3fSHeinrich Schuchardt 		.proc_handler	= sysctl_max_threads,
21081da177e4SLinus Torvalds 	},
21091da177e4SLinus Torvalds 	{
21101da177e4SLinus Torvalds 		.procname	= "random",
21111da177e4SLinus Torvalds 		.mode		= 0555,
21121da177e4SLinus Torvalds 		.child		= random_table,
21131da177e4SLinus Torvalds 	},
21141da177e4SLinus Torvalds 	{
211517f60a7dSEric Paris 		.procname	= "usermodehelper",
211617f60a7dSEric Paris 		.mode		= 0555,
211717f60a7dSEric Paris 		.child		= usermodehelper_table,
211817f60a7dSEric Paris 	},
2119ceb18132SLuis R. Rodriguez #ifdef CONFIG_FW_LOADER_USER_HELPER
2120ceb18132SLuis R. Rodriguez 	{
2121ceb18132SLuis R. Rodriguez 		.procname	= "firmware_config",
2122ceb18132SLuis R. Rodriguez 		.mode		= 0555,
2123ceb18132SLuis R. Rodriguez 		.child		= firmware_config_table,
2124ceb18132SLuis R. Rodriguez 	},
2125ceb18132SLuis R. Rodriguez #endif
212617f60a7dSEric Paris 	{
21271da177e4SLinus Torvalds 		.procname	= "overflowuid",
21281da177e4SLinus Torvalds 		.data		= &overflowuid,
21291da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
21301da177e4SLinus Torvalds 		.mode		= 0644,
21316d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
21321da177e4SLinus Torvalds 		.extra1		= &minolduid,
21331da177e4SLinus Torvalds 		.extra2		= &maxolduid,
21341da177e4SLinus Torvalds 	},
21351da177e4SLinus Torvalds 	{
21361da177e4SLinus Torvalds 		.procname	= "overflowgid",
21371da177e4SLinus Torvalds 		.data		= &overflowgid,
21381da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
21391da177e4SLinus Torvalds 		.mode		= 0644,
21406d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
21411da177e4SLinus Torvalds 		.extra1		= &minolduid,
21421da177e4SLinus Torvalds 		.extra2		= &maxolduid,
21431da177e4SLinus Torvalds 	},
2144347a8dc3SMartin Schwidefsky #ifdef CONFIG_S390
21451da177e4SLinus Torvalds 	{
21461da177e4SLinus Torvalds 		.procname	= "userprocess_debug",
2147ab3c68eeSHeiko Carstens 		.data		= &show_unhandled_signals,
21481da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
21491da177e4SLinus Torvalds 		.mode		= 0644,
21506d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
21511da177e4SLinus Torvalds 	},
21521da177e4SLinus Torvalds #endif
21531da177e4SLinus Torvalds 	{
21541da177e4SLinus Torvalds 		.procname	= "pid_max",
21551da177e4SLinus Torvalds 		.data		= &pid_max,
21561da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
21571da177e4SLinus Torvalds 		.mode		= 0644,
21586d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
21591da177e4SLinus Torvalds 		.extra1		= &pid_max_min,
21601da177e4SLinus Torvalds 		.extra2		= &pid_max_max,
21611da177e4SLinus Torvalds 	},
21621da177e4SLinus Torvalds 	{
21631da177e4SLinus Torvalds 		.procname	= "panic_on_oops",
21641da177e4SLinus Torvalds 		.data		= &panic_on_oops,
21651da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
21661da177e4SLinus Torvalds 		.mode		= 0644,
21676d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
21681da177e4SLinus Torvalds 	},
216981c9d43fSFeng Tang 	{
217081c9d43fSFeng Tang 		.procname	= "panic_print",
217181c9d43fSFeng Tang 		.data		= &panic_print,
217281c9d43fSFeng Tang 		.maxlen		= sizeof(unsigned long),
217381c9d43fSFeng Tang 		.mode		= 0644,
217481c9d43fSFeng Tang 		.proc_handler	= proc_doulongvec_minmax,
217581c9d43fSFeng Tang 	},
21767ef3d2fdSJoe Perches #if defined CONFIG_PRINTK
21777ef3d2fdSJoe Perches 	{
21787ef3d2fdSJoe Perches 		.procname	= "printk",
21797ef3d2fdSJoe Perches 		.data		= &console_loglevel,
21807ef3d2fdSJoe Perches 		.maxlen		= 4*sizeof(int),
21817ef3d2fdSJoe Perches 		.mode		= 0644,
21826d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
21837ef3d2fdSJoe Perches 	},
21841da177e4SLinus Torvalds 	{
21851da177e4SLinus Torvalds 		.procname	= "printk_ratelimit",
2186717115e1SDave Young 		.data		= &printk_ratelimit_state.interval,
21871da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
21881da177e4SLinus Torvalds 		.mode		= 0644,
21896d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_jiffies,
21901da177e4SLinus Torvalds 	},
21911da177e4SLinus Torvalds 	{
21921da177e4SLinus Torvalds 		.procname	= "printk_ratelimit_burst",
2193717115e1SDave Young 		.data		= &printk_ratelimit_state.burst,
21941da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
21951da177e4SLinus Torvalds 		.mode		= 0644,
21966d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
21971da177e4SLinus Torvalds 	},
2198af91322eSDave Young 	{
2199af91322eSDave Young 		.procname	= "printk_delay",
2200af91322eSDave Young 		.data		= &printk_delay_msec,
2201af91322eSDave Young 		.maxlen		= sizeof(int),
2202af91322eSDave Young 		.mode		= 0644,
22036d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
2204eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2205af91322eSDave Young 		.extra2		= &ten_thousand,
2206af91322eSDave Young 	},
22071da177e4SLinus Torvalds 	{
2208750afe7bSBorislav Petkov 		.procname	= "printk_devkmsg",
2209750afe7bSBorislav Petkov 		.data		= devkmsg_log_str,
2210750afe7bSBorislav Petkov 		.maxlen		= DEVKMSG_STR_MAX_SIZE,
2211750afe7bSBorislav Petkov 		.mode		= 0644,
2212750afe7bSBorislav Petkov 		.proc_handler	= devkmsg_sysctl_set_loglvl,
2213750afe7bSBorislav Petkov 	},
2214750afe7bSBorislav Petkov 	{
2215eaf06b24SDan Rosenberg 		.procname	= "dmesg_restrict",
2216eaf06b24SDan Rosenberg 		.data		= &dmesg_restrict,
2217eaf06b24SDan Rosenberg 		.maxlen		= sizeof(int),
2218eaf06b24SDan Rosenberg 		.mode		= 0644,
2219620f6e8eSKees Cook 		.proc_handler	= proc_dointvec_minmax_sysadmin,
2220eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2221eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
2222eaf06b24SDan Rosenberg 	},
2223455cd5abSDan Rosenberg 	{
2224455cd5abSDan Rosenberg 		.procname	= "kptr_restrict",
2225455cd5abSDan Rosenberg 		.data		= &kptr_restrict,
2226455cd5abSDan Rosenberg 		.maxlen		= sizeof(int),
2227455cd5abSDan Rosenberg 		.mode		= 0644,
2228620f6e8eSKees Cook 		.proc_handler	= proc_dointvec_minmax_sysadmin,
2229eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2230455cd5abSDan Rosenberg 		.extra2		= &two,
2231455cd5abSDan Rosenberg 	},
2232df6e61d4SJoe Perches #endif
2233eaf06b24SDan Rosenberg 	{
22341da177e4SLinus Torvalds 		.procname	= "ngroups_max",
22351da177e4SLinus Torvalds 		.data		= &ngroups_max,
22361da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
22371da177e4SLinus Torvalds 		.mode		= 0444,
22386d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
22391da177e4SLinus Torvalds 	},
224073efc039SDan Ballard 	{
224173efc039SDan Ballard 		.procname	= "cap_last_cap",
224273efc039SDan Ballard 		.data		= (void *)&cap_last_cap,
224373efc039SDan Ballard 		.maxlen		= sizeof(int),
224473efc039SDan Ballard 		.mode		= 0444,
224573efc039SDan Ballard 		.proc_handler	= proc_dointvec,
224673efc039SDan Ballard 	},
224758687acbSDon Zickus #if defined(CONFIG_LOCKUP_DETECTOR)
2248504d7cf1SDon Zickus 	{
224958687acbSDon Zickus 		.procname       = "watchdog",
22503c00ea82SFrederic Weisbecker 		.data		= &watchdog_user_enabled,
2251504d7cf1SDon Zickus 		.maxlen		= sizeof(int),
2252504d7cf1SDon Zickus 		.mode		= 0644,
2253195daf66SUlrich Obergfell 		.proc_handler   = proc_watchdog,
2254eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2255eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
225658687acbSDon Zickus 	},
225758687acbSDon Zickus 	{
225858687acbSDon Zickus 		.procname	= "watchdog_thresh",
2259586692a5SMandeep Singh Baines 		.data		= &watchdog_thresh,
226058687acbSDon Zickus 		.maxlen		= sizeof(int),
226158687acbSDon Zickus 		.mode		= 0644,
2262195daf66SUlrich Obergfell 		.proc_handler	= proc_watchdog_thresh,
2263eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
226458687acbSDon Zickus 		.extra2		= &sixty,
2265504d7cf1SDon Zickus 	},
22662508ce18SDon Zickus 	{
2267195daf66SUlrich Obergfell 		.procname       = "nmi_watchdog",
22687feeb9cdSThomas Gleixner 		.data		= &nmi_watchdog_user_enabled,
2269195daf66SUlrich Obergfell 		.maxlen		= sizeof(int),
227051d4052bSThomas Gleixner 		.mode		= NMI_WATCHDOG_SYSCTL_PERM,
2271195daf66SUlrich Obergfell 		.proc_handler   = proc_nmi_watchdog,
2272eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2273eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
2274195daf66SUlrich Obergfell 	},
2275195daf66SUlrich Obergfell 	{
227605a4a952SNicholas Piggin 		.procname	= "watchdog_cpumask",
227705a4a952SNicholas Piggin 		.data		= &watchdog_cpumask_bits,
227805a4a952SNicholas Piggin 		.maxlen		= NR_CPUS,
227905a4a952SNicholas Piggin 		.mode		= 0644,
228005a4a952SNicholas Piggin 		.proc_handler	= proc_watchdog_cpumask,
228105a4a952SNicholas Piggin 	},
228205a4a952SNicholas Piggin #ifdef CONFIG_SOFTLOCKUP_DETECTOR
228305a4a952SNicholas Piggin 	{
2284195daf66SUlrich Obergfell 		.procname       = "soft_watchdog",
22857feeb9cdSThomas Gleixner 		.data		= &soft_watchdog_user_enabled,
2286195daf66SUlrich Obergfell 		.maxlen		= sizeof(int),
2287195daf66SUlrich Obergfell 		.mode		= 0644,
2288195daf66SUlrich Obergfell 		.proc_handler   = proc_soft_watchdog,
2289eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2290eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
2291195daf66SUlrich Obergfell 	},
2292195daf66SUlrich Obergfell 	{
22932508ce18SDon Zickus 		.procname	= "softlockup_panic",
22942508ce18SDon Zickus 		.data		= &softlockup_panic,
22952508ce18SDon Zickus 		.maxlen		= sizeof(int),
22962508ce18SDon Zickus 		.mode		= 0644,
22972508ce18SDon Zickus 		.proc_handler	= proc_dointvec_minmax,
2298eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2299eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
23002508ce18SDon Zickus 	},
2301ed235875SAaron Tomlin #ifdef CONFIG_SMP
2302ed235875SAaron Tomlin 	{
2303ed235875SAaron Tomlin 		.procname	= "softlockup_all_cpu_backtrace",
2304ed235875SAaron Tomlin 		.data		= &sysctl_softlockup_all_cpu_backtrace,
2305ed235875SAaron Tomlin 		.maxlen		= sizeof(int),
2306ed235875SAaron Tomlin 		.mode		= 0644,
2307ed235875SAaron Tomlin 		.proc_handler	= proc_dointvec_minmax,
2308eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2309eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
2310ed235875SAaron Tomlin 	},
231105a4a952SNicholas Piggin #endif /* CONFIG_SMP */
231205a4a952SNicholas Piggin #endif
231305a4a952SNicholas Piggin #ifdef CONFIG_HARDLOCKUP_DETECTOR
231405a4a952SNicholas Piggin 	{
231505a4a952SNicholas Piggin 		.procname	= "hardlockup_panic",
231605a4a952SNicholas Piggin 		.data		= &hardlockup_panic,
231705a4a952SNicholas Piggin 		.maxlen		= sizeof(int),
231805a4a952SNicholas Piggin 		.mode		= 0644,
231905a4a952SNicholas Piggin 		.proc_handler	= proc_dointvec_minmax,
2320eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2321eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
232205a4a952SNicholas Piggin 	},
232305a4a952SNicholas Piggin #ifdef CONFIG_SMP
232455537871SJiri Kosina 	{
232555537871SJiri Kosina 		.procname	= "hardlockup_all_cpu_backtrace",
232655537871SJiri Kosina 		.data		= &sysctl_hardlockup_all_cpu_backtrace,
232755537871SJiri Kosina 		.maxlen		= sizeof(int),
232855537871SJiri Kosina 		.mode		= 0644,
232955537871SJiri Kosina 		.proc_handler	= proc_dointvec_minmax,
2330eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2331eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
233255537871SJiri Kosina 	},
2333ed235875SAaron Tomlin #endif /* CONFIG_SMP */
23345dc30558SDon Zickus #endif
233505a4a952SNicholas Piggin #endif
233605a4a952SNicholas Piggin 
23375dc30558SDon Zickus #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
23385dc30558SDon Zickus 	{
23395dc30558SDon Zickus 		.procname       = "unknown_nmi_panic",
23405dc30558SDon Zickus 		.data           = &unknown_nmi_panic,
23415dc30558SDon Zickus 		.maxlen         = sizeof (int),
23425dc30558SDon Zickus 		.mode           = 0644,
23435dc30558SDon Zickus 		.proc_handler   = proc_dointvec,
23445dc30558SDon Zickus 	},
2345504d7cf1SDon Zickus #endif
2346b6522fa4SXiaoming Ni 
2347b6522fa4SXiaoming Ni #if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \
2348b6522fa4SXiaoming Ni 	defined(CONFIG_DEBUG_STACKOVERFLOW)
2349b6522fa4SXiaoming Ni 	{
2350b6522fa4SXiaoming Ni 		.procname	= "panic_on_stackoverflow",
2351b6522fa4SXiaoming Ni 		.data		= &sysctl_panic_on_stackoverflow,
2352b6522fa4SXiaoming Ni 		.maxlen		= sizeof(int),
2353b6522fa4SXiaoming Ni 		.mode		= 0644,
2354b6522fa4SXiaoming Ni 		.proc_handler	= proc_dointvec,
2355b6522fa4SXiaoming Ni 	},
2356b6522fa4SXiaoming Ni #endif
23571da177e4SLinus Torvalds #if defined(CONFIG_X86)
23581da177e4SLinus Torvalds 	{
23598da5addaSDon Zickus 		.procname	= "panic_on_unrecovered_nmi",
23608da5addaSDon Zickus 		.data		= &panic_on_unrecovered_nmi,
23618da5addaSDon Zickus 		.maxlen		= sizeof(int),
23628da5addaSDon Zickus 		.mode		= 0644,
23636d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
23648da5addaSDon Zickus 	},
23658da5addaSDon Zickus 	{
23665211a242SKurt Garloff 		.procname	= "panic_on_io_nmi",
23675211a242SKurt Garloff 		.data		= &panic_on_io_nmi,
23685211a242SKurt Garloff 		.maxlen		= sizeof(int),
23695211a242SKurt Garloff 		.mode		= 0644,
23706d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
23715211a242SKurt Garloff 	},
23725211a242SKurt Garloff 	{
23731da177e4SLinus Torvalds 		.procname	= "bootloader_type",
23741da177e4SLinus Torvalds 		.data		= &bootloader_type,
23751da177e4SLinus Torvalds 		.maxlen		= sizeof (int),
23761da177e4SLinus Torvalds 		.mode		= 0444,
23776d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
23781da177e4SLinus Torvalds 	},
23790741f4d2SChuck Ebbert 	{
23805031296cSH. Peter Anvin 		.procname	= "bootloader_version",
23815031296cSH. Peter Anvin 		.data		= &bootloader_version,
23825031296cSH. Peter Anvin 		.maxlen		= sizeof (int),
23835031296cSH. Peter Anvin 		.mode		= 0444,
23846d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
23855031296cSH. Peter Anvin 	},
23865031296cSH. Peter Anvin 	{
23876e7c4025SIngo Molnar 		.procname	= "io_delay_type",
23886e7c4025SIngo Molnar 		.data		= &io_delay_type,
23896e7c4025SIngo Molnar 		.maxlen		= sizeof(int),
23906e7c4025SIngo Molnar 		.mode		= 0644,
23916d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
23926e7c4025SIngo Molnar 	},
23931da177e4SLinus Torvalds #endif
23947a9166e3SLuke Yang #if defined(CONFIG_MMU)
23951da177e4SLinus Torvalds 	{
23961da177e4SLinus Torvalds 		.procname	= "randomize_va_space",
23971da177e4SLinus Torvalds 		.data		= &randomize_va_space,
23981da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
23991da177e4SLinus Torvalds 		.mode		= 0644,
24006d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
24011da177e4SLinus Torvalds 	},
24027a9166e3SLuke Yang #endif
24030152fb37SMartin Schwidefsky #if defined(CONFIG_S390) && defined(CONFIG_SMP)
2404951f22d5SMartin Schwidefsky 	{
2405951f22d5SMartin Schwidefsky 		.procname	= "spin_retry",
2406951f22d5SMartin Schwidefsky 		.data		= &spin_retry,
2407951f22d5SMartin Schwidefsky 		.maxlen		= sizeof (int),
2408951f22d5SMartin Schwidefsky 		.mode		= 0644,
24096d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2410951f22d5SMartin Schwidefsky 	},
2411951f22d5SMartin Schwidefsky #endif
2412673d5b43SLen Brown #if	defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
2413c255d844SPavel Machek 	{
2414c255d844SPavel Machek 		.procname	= "acpi_video_flags",
241577afcf78SPavel Machek 		.data		= &acpi_realmode_flags,
2416c255d844SPavel Machek 		.maxlen		= sizeof (unsigned long),
2417c255d844SPavel Machek 		.mode		= 0644,
24186d456111SEric W. Biederman 		.proc_handler	= proc_doulongvec_minmax,
2419c255d844SPavel Machek 	},
2420c255d844SPavel Machek #endif
2421b6fca725SVineet Gupta #ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
2422d2b176edSJes Sorensen 	{
2423d2b176edSJes Sorensen 		.procname	= "ignore-unaligned-usertrap",
2424d2b176edSJes Sorensen 		.data		= &no_unaligned_warning,
2425d2b176edSJes Sorensen 		.maxlen		= sizeof (int),
2426d2b176edSJes Sorensen 		.mode		= 0644,
24276d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2428d2b176edSJes Sorensen 	},
2429b6fca725SVineet Gupta #endif
2430b6fca725SVineet Gupta #ifdef CONFIG_IA64
243188fc241fSDoug Chapman 	{
243288fc241fSDoug Chapman 		.procname	= "unaligned-dump-stack",
243388fc241fSDoug Chapman 		.data		= &unaligned_dump_stack,
243488fc241fSDoug Chapman 		.maxlen		= sizeof (int),
243588fc241fSDoug Chapman 		.mode		= 0644,
24366d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
243788fc241fSDoug Chapman 	},
2438d2b176edSJes Sorensen #endif
2439e162b39aSMandeep Singh Baines #ifdef CONFIG_DETECT_HUNG_TASK
2440*0ec9dc9bSGuilherme G. Piccoli #ifdef CONFIG_SMP
2441*0ec9dc9bSGuilherme G. Piccoli 	{
2442*0ec9dc9bSGuilherme G. Piccoli 		.procname	= "hung_task_all_cpu_backtrace",
2443*0ec9dc9bSGuilherme G. Piccoli 		.data		= &sysctl_hung_task_all_cpu_backtrace,
2444*0ec9dc9bSGuilherme G. Piccoli 		.maxlen		= sizeof(int),
2445*0ec9dc9bSGuilherme G. Piccoli 		.mode		= 0644,
2446*0ec9dc9bSGuilherme G. Piccoli 		.proc_handler	= proc_dointvec_minmax,
2447*0ec9dc9bSGuilherme G. Piccoli 		.extra1		= SYSCTL_ZERO,
2448*0ec9dc9bSGuilherme G. Piccoli 		.extra2		= SYSCTL_ONE,
2449*0ec9dc9bSGuilherme G. Piccoli 	},
2450*0ec9dc9bSGuilherme G. Piccoli #endif /* CONFIG_SMP */
2451e162b39aSMandeep Singh Baines 	{
2452e162b39aSMandeep Singh Baines 		.procname	= "hung_task_panic",
2453e162b39aSMandeep Singh Baines 		.data		= &sysctl_hung_task_panic,
2454e162b39aSMandeep Singh Baines 		.maxlen		= sizeof(int),
2455e162b39aSMandeep Singh Baines 		.mode		= 0644,
24566d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
2457eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2458eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
2459e162b39aSMandeep Singh Baines 	},
246082a1fcb9SIngo Molnar 	{
246182a1fcb9SIngo Molnar 		.procname	= "hung_task_check_count",
246282a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_check_count,
2463cd64647fSLi Zefan 		.maxlen		= sizeof(int),
246482a1fcb9SIngo Molnar 		.mode		= 0644,
2465cd64647fSLi Zefan 		.proc_handler	= proc_dointvec_minmax,
2466eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
246782a1fcb9SIngo Molnar 	},
246882a1fcb9SIngo Molnar 	{
246982a1fcb9SIngo Molnar 		.procname	= "hung_task_timeout_secs",
247082a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_timeout_secs,
247190739081SIngo Molnar 		.maxlen		= sizeof(unsigned long),
247282a1fcb9SIngo Molnar 		.mode		= 0644,
24736d456111SEric W. Biederman 		.proc_handler	= proc_dohung_task_timeout_secs,
247480df2847SLiu Hua 		.extra2		= &hung_task_timeout_max,
247582a1fcb9SIngo Molnar 	},
247682a1fcb9SIngo Molnar 	{
2477a2e51445SDmitry Vyukov 		.procname	= "hung_task_check_interval_secs",
2478a2e51445SDmitry Vyukov 		.data		= &sysctl_hung_task_check_interval_secs,
2479a2e51445SDmitry Vyukov 		.maxlen		= sizeof(unsigned long),
2480a2e51445SDmitry Vyukov 		.mode		= 0644,
2481a2e51445SDmitry Vyukov 		.proc_handler	= proc_dohung_task_timeout_secs,
2482a2e51445SDmitry Vyukov 		.extra2		= &hung_task_timeout_max,
2483a2e51445SDmitry Vyukov 	},
2484a2e51445SDmitry Vyukov 	{
248582a1fcb9SIngo Molnar 		.procname	= "hung_task_warnings",
248682a1fcb9SIngo Molnar 		.data		= &sysctl_hung_task_warnings,
2487270750dbSAaron Tomlin 		.maxlen		= sizeof(int),
248882a1fcb9SIngo Molnar 		.mode		= 0644,
2489270750dbSAaron Tomlin 		.proc_handler	= proc_dointvec_minmax,
2490270750dbSAaron Tomlin 		.extra1		= &neg_one,
249182a1fcb9SIngo Molnar 	},
2492c4f3b63fSRavikiran G Thirumalai #endif
249323f78d4aSIngo Molnar #ifdef CONFIG_RT_MUTEXES
249423f78d4aSIngo Molnar 	{
249523f78d4aSIngo Molnar 		.procname	= "max_lock_depth",
249623f78d4aSIngo Molnar 		.data		= &max_lock_depth,
249723f78d4aSIngo Molnar 		.maxlen		= sizeof(int),
249823f78d4aSIngo Molnar 		.mode		= 0644,
24996d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
250023f78d4aSIngo Molnar 	},
250123f78d4aSIngo Molnar #endif
250210a0a8d4SJeremy Fitzhardinge 	{
250310a0a8d4SJeremy Fitzhardinge 		.procname	= "poweroff_cmd",
250410a0a8d4SJeremy Fitzhardinge 		.data		= &poweroff_cmd,
250510a0a8d4SJeremy Fitzhardinge 		.maxlen		= POWEROFF_CMD_PATH_LEN,
250610a0a8d4SJeremy Fitzhardinge 		.mode		= 0644,
25076d456111SEric W. Biederman 		.proc_handler	= proc_dostring,
250810a0a8d4SJeremy Fitzhardinge 	},
25090b77f5bfSDavid Howells #ifdef CONFIG_KEYS
25100b77f5bfSDavid Howells 	{
25110b77f5bfSDavid Howells 		.procname	= "keys",
25120b77f5bfSDavid Howells 		.mode		= 0555,
25130b77f5bfSDavid Howells 		.child		= key_sysctls,
25140b77f5bfSDavid Howells 	},
25150b77f5bfSDavid Howells #endif
2516cdd6c482SIngo Molnar #ifdef CONFIG_PERF_EVENTS
2517aa4a2218SVince Weaver 	/*
2518aa4a2218SVince Weaver 	 * User-space scripts rely on the existence of this file
2519aa4a2218SVince Weaver 	 * as a feature check for perf_events being enabled.
2520aa4a2218SVince Weaver 	 *
2521aa4a2218SVince Weaver 	 * So it's an ABI, do not remove!
2522aa4a2218SVince Weaver 	 */
25231ccd1549SPeter Zijlstra 	{
2524cdd6c482SIngo Molnar 		.procname	= "perf_event_paranoid",
2525cdd6c482SIngo Molnar 		.data		= &sysctl_perf_event_paranoid,
2526cdd6c482SIngo Molnar 		.maxlen		= sizeof(sysctl_perf_event_paranoid),
25271ccd1549SPeter Zijlstra 		.mode		= 0644,
25286d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
25291ccd1549SPeter Zijlstra 	},
2530c5078f78SPeter Zijlstra 	{
2531cdd6c482SIngo Molnar 		.procname	= "perf_event_mlock_kb",
2532cdd6c482SIngo Molnar 		.data		= &sysctl_perf_event_mlock,
2533cdd6c482SIngo Molnar 		.maxlen		= sizeof(sysctl_perf_event_mlock),
2534c5078f78SPeter Zijlstra 		.mode		= 0644,
25356d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2536c5078f78SPeter Zijlstra 	},
2537a78ac325SPeter Zijlstra 	{
2538cdd6c482SIngo Molnar 		.procname	= "perf_event_max_sample_rate",
2539cdd6c482SIngo Molnar 		.data		= &sysctl_perf_event_sample_rate,
2540cdd6c482SIngo Molnar 		.maxlen		= sizeof(sysctl_perf_event_sample_rate),
2541a78ac325SPeter Zijlstra 		.mode		= 0644,
2542163ec435SPeter Zijlstra 		.proc_handler	= perf_proc_update_handler,
2543eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
2544a78ac325SPeter Zijlstra 	},
254514c63f17SDave Hansen 	{
254614c63f17SDave Hansen 		.procname	= "perf_cpu_time_max_percent",
254714c63f17SDave Hansen 		.data		= &sysctl_perf_cpu_time_max_percent,
254814c63f17SDave Hansen 		.maxlen		= sizeof(sysctl_perf_cpu_time_max_percent),
254914c63f17SDave Hansen 		.mode		= 0644,
255014c63f17SDave Hansen 		.proc_handler	= perf_cpu_time_max_percent_handler,
2551eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
255214c63f17SDave Hansen 		.extra2		= &one_hundred,
255314c63f17SDave Hansen 	},
2554c5dfd78eSArnaldo Carvalho de Melo 	{
2555c5dfd78eSArnaldo Carvalho de Melo 		.procname	= "perf_event_max_stack",
2556a831100aSArnaldo Carvalho de Melo 		.data		= &sysctl_perf_event_max_stack,
2557c5dfd78eSArnaldo Carvalho de Melo 		.maxlen		= sizeof(sysctl_perf_event_max_stack),
2558c5dfd78eSArnaldo Carvalho de Melo 		.mode		= 0644,
2559c5dfd78eSArnaldo Carvalho de Melo 		.proc_handler	= perf_event_max_stack_handler,
2560eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2561c5dfd78eSArnaldo Carvalho de Melo 		.extra2		= &six_hundred_forty_kb,
2562c5dfd78eSArnaldo Carvalho de Melo 	},
2563c85b0334SArnaldo Carvalho de Melo 	{
2564c85b0334SArnaldo Carvalho de Melo 		.procname	= "perf_event_max_contexts_per_stack",
2565c85b0334SArnaldo Carvalho de Melo 		.data		= &sysctl_perf_event_max_contexts_per_stack,
2566c85b0334SArnaldo Carvalho de Melo 		.maxlen		= sizeof(sysctl_perf_event_max_contexts_per_stack),
2567c85b0334SArnaldo Carvalho de Melo 		.mode		= 0644,
2568c85b0334SArnaldo Carvalho de Melo 		.proc_handler	= perf_event_max_stack_handler,
2569eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2570c85b0334SArnaldo Carvalho de Melo 		.extra2		= &one_thousand,
2571c85b0334SArnaldo Carvalho de Melo 	},
25721ccd1549SPeter Zijlstra #endif
25739e3961a0SPrarit Bhargava 	{
25749e3961a0SPrarit Bhargava 		.procname	= "panic_on_warn",
25759e3961a0SPrarit Bhargava 		.data		= &panic_on_warn,
25769e3961a0SPrarit Bhargava 		.maxlen		= sizeof(int),
25779e3961a0SPrarit Bhargava 		.mode		= 0644,
25789e3961a0SPrarit Bhargava 		.proc_handler	= proc_dointvec_minmax,
2579eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2580eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
25819e3961a0SPrarit Bhargava 	},
2582bc7a34b8SThomas Gleixner #if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ_COMMON)
2583bc7a34b8SThomas Gleixner 	{
2584bc7a34b8SThomas Gleixner 		.procname	= "timer_migration",
2585bc7a34b8SThomas Gleixner 		.data		= &sysctl_timer_migration,
2586bc7a34b8SThomas Gleixner 		.maxlen		= sizeof(unsigned int),
2587bc7a34b8SThomas Gleixner 		.mode		= 0644,
2588bc7a34b8SThomas Gleixner 		.proc_handler	= timer_migration_handler,
2589eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2590eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
2591bc7a34b8SThomas Gleixner 	},
2592bc7a34b8SThomas Gleixner #endif
25931be7f75dSAlexei Starovoitov #ifdef CONFIG_BPF_SYSCALL
25941be7f75dSAlexei Starovoitov 	{
25951be7f75dSAlexei Starovoitov 		.procname	= "unprivileged_bpf_disabled",
25961be7f75dSAlexei Starovoitov 		.data		= &sysctl_unprivileged_bpf_disabled,
25971be7f75dSAlexei Starovoitov 		.maxlen		= sizeof(sysctl_unprivileged_bpf_disabled),
25981be7f75dSAlexei Starovoitov 		.mode		= 0644,
25991be7f75dSAlexei Starovoitov 		/* only handle a transition from default "0" to "1" */
26001be7f75dSAlexei Starovoitov 		.proc_handler	= proc_dointvec_minmax,
2601eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
2602eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
26031be7f75dSAlexei Starovoitov 	},
2604492ecee8SAlexei Starovoitov 	{
2605492ecee8SAlexei Starovoitov 		.procname	= "bpf_stats_enabled",
2606a8e11e5cSEric Dumazet 		.data		= &bpf_stats_enabled_key.key,
2607a8e11e5cSEric Dumazet 		.maxlen		= sizeof(bpf_stats_enabled_key),
2608492ecee8SAlexei Starovoitov 		.mode		= 0644,
2609d46edd67SSong Liu 		.proc_handler	= bpf_stats_handler,
2610492ecee8SAlexei Starovoitov 	},
26113fcc5530SAlexei Starovoitov #endif
2612b3e627d3SLai Jiangshan #if defined(CONFIG_TREE_RCU)
2613088e9d25SDaniel Bristot de Oliveira 	{
2614088e9d25SDaniel Bristot de Oliveira 		.procname	= "panic_on_rcu_stall",
2615088e9d25SDaniel Bristot de Oliveira 		.data		= &sysctl_panic_on_rcu_stall,
2616088e9d25SDaniel Bristot de Oliveira 		.maxlen		= sizeof(sysctl_panic_on_rcu_stall),
2617088e9d25SDaniel Bristot de Oliveira 		.mode		= 0644,
2618088e9d25SDaniel Bristot de Oliveira 		.proc_handler	= proc_dointvec_minmax,
2619eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2620eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
2621088e9d25SDaniel Bristot de Oliveira 	},
2622088e9d25SDaniel Bristot de Oliveira #endif
2623964c9dffSAlexander Popov #ifdef CONFIG_STACKLEAK_RUNTIME_DISABLE
2624964c9dffSAlexander Popov 	{
2625964c9dffSAlexander Popov 		.procname	= "stack_erasing",
2626964c9dffSAlexander Popov 		.data		= NULL,
2627964c9dffSAlexander Popov 		.maxlen		= sizeof(int),
2628964c9dffSAlexander Popov 		.mode		= 0600,
2629964c9dffSAlexander Popov 		.proc_handler	= stack_erasing_sysctl,
2630eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2631eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
2632964c9dffSAlexander Popov 	},
2633964c9dffSAlexander Popov #endif
26346fce56ecSEric W. Biederman 	{ }
26351da177e4SLinus Torvalds };
26361da177e4SLinus Torvalds 
2637d8217f07SEric W. Biederman static struct ctl_table vm_table[] = {
26381da177e4SLinus Torvalds 	{
26391da177e4SLinus Torvalds 		.procname	= "overcommit_memory",
26401da177e4SLinus Torvalds 		.data		= &sysctl_overcommit_memory,
26411da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_overcommit_memory),
26421da177e4SLinus Torvalds 		.mode		= 0644,
2643cb16e95fSPetr Holasek 		.proc_handler	= proc_dointvec_minmax,
2644eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2645cb16e95fSPetr Holasek 		.extra2		= &two,
26461da177e4SLinus Torvalds 	},
26471da177e4SLinus Torvalds 	{
2648fadd8fbdSKAMEZAWA Hiroyuki 		.procname	= "panic_on_oom",
2649fadd8fbdSKAMEZAWA Hiroyuki 		.data		= &sysctl_panic_on_oom,
2650fadd8fbdSKAMEZAWA Hiroyuki 		.maxlen		= sizeof(sysctl_panic_on_oom),
2651fadd8fbdSKAMEZAWA Hiroyuki 		.mode		= 0644,
2652cb16e95fSPetr Holasek 		.proc_handler	= proc_dointvec_minmax,
2653eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2654cb16e95fSPetr Holasek 		.extra2		= &two,
2655fadd8fbdSKAMEZAWA Hiroyuki 	},
2656fadd8fbdSKAMEZAWA Hiroyuki 	{
2657fe071d7eSDavid Rientjes 		.procname	= "oom_kill_allocating_task",
2658fe071d7eSDavid Rientjes 		.data		= &sysctl_oom_kill_allocating_task,
2659fe071d7eSDavid Rientjes 		.maxlen		= sizeof(sysctl_oom_kill_allocating_task),
2660fe071d7eSDavid Rientjes 		.mode		= 0644,
26616d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2662fe071d7eSDavid Rientjes 	},
2663fe071d7eSDavid Rientjes 	{
2664fef1bdd6SDavid Rientjes 		.procname	= "oom_dump_tasks",
2665fef1bdd6SDavid Rientjes 		.data		= &sysctl_oom_dump_tasks,
2666fef1bdd6SDavid Rientjes 		.maxlen		= sizeof(sysctl_oom_dump_tasks),
2667fef1bdd6SDavid Rientjes 		.mode		= 0644,
26686d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2669fef1bdd6SDavid Rientjes 	},
2670fef1bdd6SDavid Rientjes 	{
26711da177e4SLinus Torvalds 		.procname	= "overcommit_ratio",
26721da177e4SLinus Torvalds 		.data		= &sysctl_overcommit_ratio,
26731da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_overcommit_ratio),
26741da177e4SLinus Torvalds 		.mode		= 0644,
267549f0ce5fSJerome Marchand 		.proc_handler	= overcommit_ratio_handler,
267649f0ce5fSJerome Marchand 	},
267749f0ce5fSJerome Marchand 	{
267849f0ce5fSJerome Marchand 		.procname	= "overcommit_kbytes",
267949f0ce5fSJerome Marchand 		.data		= &sysctl_overcommit_kbytes,
268049f0ce5fSJerome Marchand 		.maxlen		= sizeof(sysctl_overcommit_kbytes),
268149f0ce5fSJerome Marchand 		.mode		= 0644,
268249f0ce5fSJerome Marchand 		.proc_handler	= overcommit_kbytes_handler,
26831da177e4SLinus Torvalds 	},
26841da177e4SLinus Torvalds 	{
26851da177e4SLinus Torvalds 		.procname	= "page-cluster",
26861da177e4SLinus Torvalds 		.data		= &page_cluster,
26871da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
26881da177e4SLinus Torvalds 		.mode		= 0644,
2689cb16e95fSPetr Holasek 		.proc_handler	= proc_dointvec_minmax,
2690eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
26911da177e4SLinus Torvalds 	},
26921da177e4SLinus Torvalds 	{
26931da177e4SLinus Torvalds 		.procname	= "dirty_background_ratio",
26941da177e4SLinus Torvalds 		.data		= &dirty_background_ratio,
26951da177e4SLinus Torvalds 		.maxlen		= sizeof(dirty_background_ratio),
26961da177e4SLinus Torvalds 		.mode		= 0644,
26976d456111SEric W. Biederman 		.proc_handler	= dirty_background_ratio_handler,
2698eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
26991da177e4SLinus Torvalds 		.extra2		= &one_hundred,
27001da177e4SLinus Torvalds 	},
27011da177e4SLinus Torvalds 	{
27022da02997SDavid Rientjes 		.procname	= "dirty_background_bytes",
27032da02997SDavid Rientjes 		.data		= &dirty_background_bytes,
27042da02997SDavid Rientjes 		.maxlen		= sizeof(dirty_background_bytes),
27052da02997SDavid Rientjes 		.mode		= 0644,
27066d456111SEric W. Biederman 		.proc_handler	= dirty_background_bytes_handler,
2707fc3501d4SSven Wegener 		.extra1		= &one_ul,
27082da02997SDavid Rientjes 	},
27092da02997SDavid Rientjes 	{
27101da177e4SLinus Torvalds 		.procname	= "dirty_ratio",
27111da177e4SLinus Torvalds 		.data		= &vm_dirty_ratio,
27121da177e4SLinus Torvalds 		.maxlen		= sizeof(vm_dirty_ratio),
27131da177e4SLinus Torvalds 		.mode		= 0644,
27146d456111SEric W. Biederman 		.proc_handler	= dirty_ratio_handler,
2715eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
27161da177e4SLinus Torvalds 		.extra2		= &one_hundred,
27171da177e4SLinus Torvalds 	},
27181da177e4SLinus Torvalds 	{
27192da02997SDavid Rientjes 		.procname	= "dirty_bytes",
27202da02997SDavid Rientjes 		.data		= &vm_dirty_bytes,
27212da02997SDavid Rientjes 		.maxlen		= sizeof(vm_dirty_bytes),
27222da02997SDavid Rientjes 		.mode		= 0644,
27236d456111SEric W. Biederman 		.proc_handler	= dirty_bytes_handler,
27249e4a5bdaSAndrea Righi 		.extra1		= &dirty_bytes_min,
27252da02997SDavid Rientjes 	},
27262da02997SDavid Rientjes 	{
27271da177e4SLinus Torvalds 		.procname	= "dirty_writeback_centisecs",
2728f6ef9438SBart Samwel 		.data		= &dirty_writeback_interval,
2729f6ef9438SBart Samwel 		.maxlen		= sizeof(dirty_writeback_interval),
27301da177e4SLinus Torvalds 		.mode		= 0644,
27316d456111SEric W. Biederman 		.proc_handler	= dirty_writeback_centisecs_handler,
27321da177e4SLinus Torvalds 	},
27331da177e4SLinus Torvalds 	{
27341da177e4SLinus Torvalds 		.procname	= "dirty_expire_centisecs",
2735f6ef9438SBart Samwel 		.data		= &dirty_expire_interval,
2736f6ef9438SBart Samwel 		.maxlen		= sizeof(dirty_expire_interval),
27371da177e4SLinus Torvalds 		.mode		= 0644,
2738cb16e95fSPetr Holasek 		.proc_handler	= proc_dointvec_minmax,
2739eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
27401da177e4SLinus Torvalds 	},
27411da177e4SLinus Torvalds 	{
27421efff914STheodore Ts'o 		.procname	= "dirtytime_expire_seconds",
27431efff914STheodore Ts'o 		.data		= &dirtytime_expire_interval,
27442d87b309SRandy Dunlap 		.maxlen		= sizeof(dirtytime_expire_interval),
27451efff914STheodore Ts'o 		.mode		= 0644,
27461efff914STheodore Ts'o 		.proc_handler	= dirtytime_interval_handler,
2747eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
27481efff914STheodore Ts'o 	},
27491efff914STheodore Ts'o 	{
27501da177e4SLinus Torvalds 		.procname	= "swappiness",
27511da177e4SLinus Torvalds 		.data		= &vm_swappiness,
27521da177e4SLinus Torvalds 		.maxlen		= sizeof(vm_swappiness),
27531da177e4SLinus Torvalds 		.mode		= 0644,
27546d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
2755eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2756c843966cSJohannes Weiner 		.extra2		= &two_hundred,
27571da177e4SLinus Torvalds 	},
27581da177e4SLinus Torvalds #ifdef CONFIG_HUGETLB_PAGE
27591da177e4SLinus Torvalds 	{
27601da177e4SLinus Torvalds 		.procname	= "nr_hugepages",
2761e5ff2159SAndi Kleen 		.data		= NULL,
27621da177e4SLinus Torvalds 		.maxlen		= sizeof(unsigned long),
27631da177e4SLinus Torvalds 		.mode		= 0644,
27646d456111SEric W. Biederman 		.proc_handler	= hugetlb_sysctl_handler,
27651da177e4SLinus Torvalds 	},
276606808b08SLee Schermerhorn #ifdef CONFIG_NUMA
276706808b08SLee Schermerhorn 	{
276806808b08SLee Schermerhorn 		.procname       = "nr_hugepages_mempolicy",
276906808b08SLee Schermerhorn 		.data           = NULL,
277006808b08SLee Schermerhorn 		.maxlen         = sizeof(unsigned long),
277106808b08SLee Schermerhorn 		.mode           = 0644,
277206808b08SLee Schermerhorn 		.proc_handler   = &hugetlb_mempolicy_sysctl_handler,
277306808b08SLee Schermerhorn 	},
27744518085eSKemi Wang 	{
27754518085eSKemi Wang 		.procname		= "numa_stat",
27764518085eSKemi Wang 		.data			= &sysctl_vm_numa_stat,
27774518085eSKemi Wang 		.maxlen			= sizeof(int),
27784518085eSKemi Wang 		.mode			= 0644,
27794518085eSKemi Wang 		.proc_handler	= sysctl_vm_numa_stat_handler,
2780eec4844fSMatteo Croce 		.extra1			= SYSCTL_ZERO,
2781eec4844fSMatteo Croce 		.extra2			= SYSCTL_ONE,
27824518085eSKemi Wang 	},
278306808b08SLee Schermerhorn #endif
27841da177e4SLinus Torvalds 	 {
27851da177e4SLinus Torvalds 		.procname	= "hugetlb_shm_group",
27861da177e4SLinus Torvalds 		.data		= &sysctl_hugetlb_shm_group,
27871da177e4SLinus Torvalds 		.maxlen		= sizeof(gid_t),
27881da177e4SLinus Torvalds 		.mode		= 0644,
27896d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
27901da177e4SLinus Torvalds 	 },
2791396faf03SMel Gorman 	{
2792d1c3fb1fSNishanth Aravamudan 		.procname	= "nr_overcommit_hugepages",
2793e5ff2159SAndi Kleen 		.data		= NULL,
2794e5ff2159SAndi Kleen 		.maxlen		= sizeof(unsigned long),
2795d1c3fb1fSNishanth Aravamudan 		.mode		= 0644,
27966d456111SEric W. Biederman 		.proc_handler	= hugetlb_overcommit_handler,
2797d1c3fb1fSNishanth Aravamudan 	},
27981da177e4SLinus Torvalds #endif
27991da177e4SLinus Torvalds 	{
28001da177e4SLinus Torvalds 		.procname	= "lowmem_reserve_ratio",
28011da177e4SLinus Torvalds 		.data		= &sysctl_lowmem_reserve_ratio,
28021da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_lowmem_reserve_ratio),
28031da177e4SLinus Torvalds 		.mode		= 0644,
28046d456111SEric W. Biederman 		.proc_handler	= lowmem_reserve_ratio_sysctl_handler,
28051da177e4SLinus Torvalds 	},
28061da177e4SLinus Torvalds 	{
28079d0243bcSAndrew Morton 		.procname	= "drop_caches",
28089d0243bcSAndrew Morton 		.data		= &sysctl_drop_caches,
28099d0243bcSAndrew Morton 		.maxlen		= sizeof(int),
2810204cb79aSJohannes Weiner 		.mode		= 0200,
28119d0243bcSAndrew Morton 		.proc_handler	= drop_caches_sysctl_handler,
2812eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
28135509a5d2SDave Hansen 		.extra2		= &four,
28149d0243bcSAndrew Morton 	},
281576ab0f53SMel Gorman #ifdef CONFIG_COMPACTION
281676ab0f53SMel Gorman 	{
281776ab0f53SMel Gorman 		.procname	= "compact_memory",
281876ab0f53SMel Gorman 		.data		= &sysctl_compact_memory,
281976ab0f53SMel Gorman 		.maxlen		= sizeof(int),
282076ab0f53SMel Gorman 		.mode		= 0200,
282176ab0f53SMel Gorman 		.proc_handler	= sysctl_compaction_handler,
282276ab0f53SMel Gorman 	},
28235e771905SMel Gorman 	{
28245e771905SMel Gorman 		.procname	= "extfrag_threshold",
28255e771905SMel Gorman 		.data		= &sysctl_extfrag_threshold,
28265e771905SMel Gorman 		.maxlen		= sizeof(int),
28275e771905SMel Gorman 		.mode		= 0644,
28286b7e5cadSMatthew Wilcox 		.proc_handler	= proc_dointvec_minmax,
28295e771905SMel Gorman 		.extra1		= &min_extfrag_threshold,
28305e771905SMel Gorman 		.extra2		= &max_extfrag_threshold,
28315e771905SMel Gorman 	},
28325bbe3547SEric B Munson 	{
28335bbe3547SEric B Munson 		.procname	= "compact_unevictable_allowed",
28345bbe3547SEric B Munson 		.data		= &sysctl_compact_unevictable_allowed,
28355bbe3547SEric B Munson 		.maxlen		= sizeof(int),
28365bbe3547SEric B Munson 		.mode		= 0644,
28376923aa0dSSebastian Andrzej Siewior 		.proc_handler	= proc_dointvec_minmax_warn_RT_change,
2838eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2839eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
28405bbe3547SEric B Munson 	},
28415e771905SMel Gorman 
284276ab0f53SMel Gorman #endif /* CONFIG_COMPACTION */
28439d0243bcSAndrew Morton 	{
28441da177e4SLinus Torvalds 		.procname	= "min_free_kbytes",
28451da177e4SLinus Torvalds 		.data		= &min_free_kbytes,
28461da177e4SLinus Torvalds 		.maxlen		= sizeof(min_free_kbytes),
28471da177e4SLinus Torvalds 		.mode		= 0644,
28486d456111SEric W. Biederman 		.proc_handler	= min_free_kbytes_sysctl_handler,
2849eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
28501da177e4SLinus Torvalds 	},
28518ad4b1fbSRohit Seth 	{
28521c30844dSMel Gorman 		.procname	= "watermark_boost_factor",
28531c30844dSMel Gorman 		.data		= &watermark_boost_factor,
28541c30844dSMel Gorman 		.maxlen		= sizeof(watermark_boost_factor),
28551c30844dSMel Gorman 		.mode		= 0644,
285626363af5SChristoph Hellwig 		.proc_handler	= proc_dointvec_minmax,
2857eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
28581c30844dSMel Gorman 	},
28591c30844dSMel Gorman 	{
2860795ae7a0SJohannes Weiner 		.procname	= "watermark_scale_factor",
2861795ae7a0SJohannes Weiner 		.data		= &watermark_scale_factor,
2862795ae7a0SJohannes Weiner 		.maxlen		= sizeof(watermark_scale_factor),
2863795ae7a0SJohannes Weiner 		.mode		= 0644,
2864795ae7a0SJohannes Weiner 		.proc_handler	= watermark_scale_factor_sysctl_handler,
2865eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
2866795ae7a0SJohannes Weiner 		.extra2		= &one_thousand,
2867795ae7a0SJohannes Weiner 	},
2868795ae7a0SJohannes Weiner 	{
28698ad4b1fbSRohit Seth 		.procname	= "percpu_pagelist_fraction",
28708ad4b1fbSRohit Seth 		.data		= &percpu_pagelist_fraction,
28718ad4b1fbSRohit Seth 		.maxlen		= sizeof(percpu_pagelist_fraction),
28728ad4b1fbSRohit Seth 		.mode		= 0644,
28736d456111SEric W. Biederman 		.proc_handler	= percpu_pagelist_fraction_sysctl_handler,
2874eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
28758ad4b1fbSRohit Seth 	},
28761da177e4SLinus Torvalds #ifdef CONFIG_MMU
28771da177e4SLinus Torvalds 	{
28781da177e4SLinus Torvalds 		.procname	= "max_map_count",
28791da177e4SLinus Torvalds 		.data		= &sysctl_max_map_count,
28801da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_max_map_count),
28811da177e4SLinus Torvalds 		.mode		= 0644,
28823e26120cSWANG Cong 		.proc_handler	= proc_dointvec_minmax,
2883eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
28841da177e4SLinus Torvalds 	},
2885dd8632a1SPaul Mundt #else
2886dd8632a1SPaul Mundt 	{
2887dd8632a1SPaul Mundt 		.procname	= "nr_trim_pages",
2888dd8632a1SPaul Mundt 		.data		= &sysctl_nr_trim_pages,
2889dd8632a1SPaul Mundt 		.maxlen		= sizeof(sysctl_nr_trim_pages),
2890dd8632a1SPaul Mundt 		.mode		= 0644,
28916d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
2892eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
2893dd8632a1SPaul Mundt 	},
28941da177e4SLinus Torvalds #endif
28951da177e4SLinus Torvalds 	{
28961da177e4SLinus Torvalds 		.procname	= "laptop_mode",
28971da177e4SLinus Torvalds 		.data		= &laptop_mode,
28981da177e4SLinus Torvalds 		.maxlen		= sizeof(laptop_mode),
28991da177e4SLinus Torvalds 		.mode		= 0644,
29006d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_jiffies,
29011da177e4SLinus Torvalds 	},
29021da177e4SLinus Torvalds 	{
29031da177e4SLinus Torvalds 		.procname	= "block_dump",
29041da177e4SLinus Torvalds 		.data		= &block_dump,
29051da177e4SLinus Torvalds 		.maxlen		= sizeof(block_dump),
29061da177e4SLinus Torvalds 		.mode		= 0644,
29076d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2908eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
29091da177e4SLinus Torvalds 	},
29101da177e4SLinus Torvalds 	{
29111da177e4SLinus Torvalds 		.procname	= "vfs_cache_pressure",
29121da177e4SLinus Torvalds 		.data		= &sysctl_vfs_cache_pressure,
29131da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_vfs_cache_pressure),
29141da177e4SLinus Torvalds 		.mode		= 0644,
29156d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2916eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
29171da177e4SLinus Torvalds 	},
291867f3977fSAlexandre Ghiti #if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
291967f3977fSAlexandre Ghiti     defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
29201da177e4SLinus Torvalds 	{
29211da177e4SLinus Torvalds 		.procname	= "legacy_va_layout",
29221da177e4SLinus Torvalds 		.data		= &sysctl_legacy_va_layout,
29231da177e4SLinus Torvalds 		.maxlen		= sizeof(sysctl_legacy_va_layout),
29241da177e4SLinus Torvalds 		.mode		= 0644,
29256d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2926eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
29271da177e4SLinus Torvalds 	},
29281da177e4SLinus Torvalds #endif
29291743660bSChristoph Lameter #ifdef CONFIG_NUMA
29301743660bSChristoph Lameter 	{
29311743660bSChristoph Lameter 		.procname	= "zone_reclaim_mode",
2932a5f5f91dSMel Gorman 		.data		= &node_reclaim_mode,
2933a5f5f91dSMel Gorman 		.maxlen		= sizeof(node_reclaim_mode),
29341743660bSChristoph Lameter 		.mode		= 0644,
29356d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
2936eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
29371743660bSChristoph Lameter 	},
29389614634fSChristoph Lameter 	{
29399614634fSChristoph Lameter 		.procname	= "min_unmapped_ratio",
29409614634fSChristoph Lameter 		.data		= &sysctl_min_unmapped_ratio,
29419614634fSChristoph Lameter 		.maxlen		= sizeof(sysctl_min_unmapped_ratio),
29429614634fSChristoph Lameter 		.mode		= 0644,
29436d456111SEric W. Biederman 		.proc_handler	= sysctl_min_unmapped_ratio_sysctl_handler,
2944eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
29459614634fSChristoph Lameter 		.extra2		= &one_hundred,
29469614634fSChristoph Lameter 	},
29470ff38490SChristoph Lameter 	{
29480ff38490SChristoph Lameter 		.procname	= "min_slab_ratio",
29490ff38490SChristoph Lameter 		.data		= &sysctl_min_slab_ratio,
29500ff38490SChristoph Lameter 		.maxlen		= sizeof(sysctl_min_slab_ratio),
29510ff38490SChristoph Lameter 		.mode		= 0644,
29526d456111SEric W. Biederman 		.proc_handler	= sysctl_min_slab_ratio_sysctl_handler,
2953eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
29540ff38490SChristoph Lameter 		.extra2		= &one_hundred,
29550ff38490SChristoph Lameter 	},
29561743660bSChristoph Lameter #endif
295777461ab3SChristoph Lameter #ifdef CONFIG_SMP
295877461ab3SChristoph Lameter 	{
295977461ab3SChristoph Lameter 		.procname	= "stat_interval",
296077461ab3SChristoph Lameter 		.data		= &sysctl_stat_interval,
296177461ab3SChristoph Lameter 		.maxlen		= sizeof(sysctl_stat_interval),
296277461ab3SChristoph Lameter 		.mode		= 0644,
29636d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_jiffies,
296477461ab3SChristoph Lameter 	},
296552b6f46bSHugh Dickins 	{
296652b6f46bSHugh Dickins 		.procname	= "stat_refresh",
296752b6f46bSHugh Dickins 		.data		= NULL,
296852b6f46bSHugh Dickins 		.maxlen		= 0,
296952b6f46bSHugh Dickins 		.mode		= 0600,
297052b6f46bSHugh Dickins 		.proc_handler	= vmstat_refresh,
297152b6f46bSHugh Dickins 	},
297277461ab3SChristoph Lameter #endif
29736e141546SDavid Howells #ifdef CONFIG_MMU
2974ed032189SEric Paris 	{
2975ed032189SEric Paris 		.procname	= "mmap_min_addr",
2976788084abSEric Paris 		.data		= &dac_mmap_min_addr,
2977ed032189SEric Paris 		.maxlen		= sizeof(unsigned long),
2978ed032189SEric Paris 		.mode		= 0644,
29796d456111SEric W. Biederman 		.proc_handler	= mmap_min_addr_handler,
2980ed032189SEric Paris 	},
29816e141546SDavid Howells #endif
2982f0c0b2b8SKAMEZAWA Hiroyuki #ifdef CONFIG_NUMA
2983f0c0b2b8SKAMEZAWA Hiroyuki 	{
2984f0c0b2b8SKAMEZAWA Hiroyuki 		.procname	= "numa_zonelist_order",
2985f0c0b2b8SKAMEZAWA Hiroyuki 		.data		= &numa_zonelist_order,
2986f0c0b2b8SKAMEZAWA Hiroyuki 		.maxlen		= NUMA_ZONELIST_ORDER_LEN,
2987f0c0b2b8SKAMEZAWA Hiroyuki 		.mode		= 0644,
29886d456111SEric W. Biederman 		.proc_handler	= numa_zonelist_order_handler,
2989f0c0b2b8SKAMEZAWA Hiroyuki 	},
2990f0c0b2b8SKAMEZAWA Hiroyuki #endif
29912b8232ceSAl Viro #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
29925c36e657SPaul Mundt    (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
2993e6e5494cSIngo Molnar 	{
2994e6e5494cSIngo Molnar 		.procname	= "vdso_enabled",
29953d7ee969SAndy Lutomirski #ifdef CONFIG_X86_32
29963d7ee969SAndy Lutomirski 		.data		= &vdso32_enabled,
29973d7ee969SAndy Lutomirski 		.maxlen		= sizeof(vdso32_enabled),
29983d7ee969SAndy Lutomirski #else
2999e6e5494cSIngo Molnar 		.data		= &vdso_enabled,
3000e6e5494cSIngo Molnar 		.maxlen		= sizeof(vdso_enabled),
30013d7ee969SAndy Lutomirski #endif
3002e6e5494cSIngo Molnar 		.mode		= 0644,
30036d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
3004eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
3005e6e5494cSIngo Molnar 	},
3006e6e5494cSIngo Molnar #endif
3007195cf453SBron Gondwana #ifdef CONFIG_HIGHMEM
3008195cf453SBron Gondwana 	{
3009195cf453SBron Gondwana 		.procname	= "highmem_is_dirtyable",
3010195cf453SBron Gondwana 		.data		= &vm_highmem_is_dirtyable,
3011195cf453SBron Gondwana 		.maxlen		= sizeof(vm_highmem_is_dirtyable),
3012195cf453SBron Gondwana 		.mode		= 0644,
30136d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
3014eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
3015eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
3016195cf453SBron Gondwana 	},
3017195cf453SBron Gondwana #endif
30186a46079cSAndi Kleen #ifdef CONFIG_MEMORY_FAILURE
30196a46079cSAndi Kleen 	{
30206a46079cSAndi Kleen 		.procname	= "memory_failure_early_kill",
30216a46079cSAndi Kleen 		.data		= &sysctl_memory_failure_early_kill,
30226a46079cSAndi Kleen 		.maxlen		= sizeof(sysctl_memory_failure_early_kill),
30236a46079cSAndi Kleen 		.mode		= 0644,
30246d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
3025eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
3026eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
30276a46079cSAndi Kleen 	},
30286a46079cSAndi Kleen 	{
30296a46079cSAndi Kleen 		.procname	= "memory_failure_recovery",
30306a46079cSAndi Kleen 		.data		= &sysctl_memory_failure_recovery,
30316a46079cSAndi Kleen 		.maxlen		= sizeof(sysctl_memory_failure_recovery),
30326a46079cSAndi Kleen 		.mode		= 0644,
30336d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
3034eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
3035eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
30366a46079cSAndi Kleen 	},
30376a46079cSAndi Kleen #endif
3038c9b1d098SAndrew Shewmaker 	{
3039c9b1d098SAndrew Shewmaker 		.procname	= "user_reserve_kbytes",
3040c9b1d098SAndrew Shewmaker 		.data		= &sysctl_user_reserve_kbytes,
3041c9b1d098SAndrew Shewmaker 		.maxlen		= sizeof(sysctl_user_reserve_kbytes),
3042c9b1d098SAndrew Shewmaker 		.mode		= 0644,
3043c9b1d098SAndrew Shewmaker 		.proc_handler	= proc_doulongvec_minmax,
3044c9b1d098SAndrew Shewmaker 	},
30454eeab4f5SAndrew Shewmaker 	{
30464eeab4f5SAndrew Shewmaker 		.procname	= "admin_reserve_kbytes",
30474eeab4f5SAndrew Shewmaker 		.data		= &sysctl_admin_reserve_kbytes,
30484eeab4f5SAndrew Shewmaker 		.maxlen		= sizeof(sysctl_admin_reserve_kbytes),
30494eeab4f5SAndrew Shewmaker 		.mode		= 0644,
30504eeab4f5SAndrew Shewmaker 		.proc_handler	= proc_doulongvec_minmax,
30514eeab4f5SAndrew Shewmaker 	},
3052d07e2259SDaniel Cashman #ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
3053d07e2259SDaniel Cashman 	{
3054d07e2259SDaniel Cashman 		.procname	= "mmap_rnd_bits",
3055d07e2259SDaniel Cashman 		.data		= &mmap_rnd_bits,
3056d07e2259SDaniel Cashman 		.maxlen		= sizeof(mmap_rnd_bits),
3057d07e2259SDaniel Cashman 		.mode		= 0600,
3058d07e2259SDaniel Cashman 		.proc_handler	= proc_dointvec_minmax,
3059d07e2259SDaniel Cashman 		.extra1		= (void *)&mmap_rnd_bits_min,
3060d07e2259SDaniel Cashman 		.extra2		= (void *)&mmap_rnd_bits_max,
3061d07e2259SDaniel Cashman 	},
3062d07e2259SDaniel Cashman #endif
3063d07e2259SDaniel Cashman #ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
3064d07e2259SDaniel Cashman 	{
3065d07e2259SDaniel Cashman 		.procname	= "mmap_rnd_compat_bits",
3066d07e2259SDaniel Cashman 		.data		= &mmap_rnd_compat_bits,
3067d07e2259SDaniel Cashman 		.maxlen		= sizeof(mmap_rnd_compat_bits),
3068d07e2259SDaniel Cashman 		.mode		= 0600,
3069d07e2259SDaniel Cashman 		.proc_handler	= proc_dointvec_minmax,
3070d07e2259SDaniel Cashman 		.extra1		= (void *)&mmap_rnd_compat_bits_min,
3071d07e2259SDaniel Cashman 		.extra2		= (void *)&mmap_rnd_compat_bits_max,
3072d07e2259SDaniel Cashman 	},
3073d07e2259SDaniel Cashman #endif
3074cefdca0aSPeter Xu #ifdef CONFIG_USERFAULTFD
3075cefdca0aSPeter Xu 	{
3076cefdca0aSPeter Xu 		.procname	= "unprivileged_userfaultfd",
3077cefdca0aSPeter Xu 		.data		= &sysctl_unprivileged_userfaultfd,
3078cefdca0aSPeter Xu 		.maxlen		= sizeof(sysctl_unprivileged_userfaultfd),
3079cefdca0aSPeter Xu 		.mode		= 0644,
3080cefdca0aSPeter Xu 		.proc_handler	= proc_dointvec_minmax,
3081eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
3082eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
3083cefdca0aSPeter Xu 	},
3084cefdca0aSPeter Xu #endif
30856fce56ecSEric W. Biederman 	{ }
30861da177e4SLinus Torvalds };
30871da177e4SLinus Torvalds 
3088d8217f07SEric W. Biederman static struct ctl_table fs_table[] = {
30891da177e4SLinus Torvalds 	{
30901da177e4SLinus Torvalds 		.procname	= "inode-nr",
30911da177e4SLinus Torvalds 		.data		= &inodes_stat,
30923942c07cSGlauber Costa 		.maxlen		= 2*sizeof(long),
30931da177e4SLinus Torvalds 		.mode		= 0444,
3094cffbc8aaSDave Chinner 		.proc_handler	= proc_nr_inodes,
30951da177e4SLinus Torvalds 	},
30961da177e4SLinus Torvalds 	{
30971da177e4SLinus Torvalds 		.procname	= "inode-state",
30981da177e4SLinus Torvalds 		.data		= &inodes_stat,
30993942c07cSGlauber Costa 		.maxlen		= 7*sizeof(long),
31001da177e4SLinus Torvalds 		.mode		= 0444,
3101cffbc8aaSDave Chinner 		.proc_handler	= proc_nr_inodes,
31021da177e4SLinus Torvalds 	},
31031da177e4SLinus Torvalds 	{
31041da177e4SLinus Torvalds 		.procname	= "file-nr",
31051da177e4SLinus Torvalds 		.data		= &files_stat,
3106518de9b3SEric Dumazet 		.maxlen		= sizeof(files_stat),
31071da177e4SLinus Torvalds 		.mode		= 0444,
31086d456111SEric W. Biederman 		.proc_handler	= proc_nr_files,
31091da177e4SLinus Torvalds 	},
31101da177e4SLinus Torvalds 	{
31111da177e4SLinus Torvalds 		.procname	= "file-max",
31121da177e4SLinus Torvalds 		.data		= &files_stat.max_files,
3113518de9b3SEric Dumazet 		.maxlen		= sizeof(files_stat.max_files),
31141da177e4SLinus Torvalds 		.mode		= 0644,
3115518de9b3SEric Dumazet 		.proc_handler	= proc_doulongvec_minmax,
31169002b214SWill Deacon 		.extra1		= &zero_ul,
311732a5ad9cSChristian Brauner 		.extra2		= &long_max,
31181da177e4SLinus Torvalds 	},
31191da177e4SLinus Torvalds 	{
31209cfe015aSEric Dumazet 		.procname	= "nr_open",
31219cfe015aSEric Dumazet 		.data		= &sysctl_nr_open,
31229b80a184SAlexey Dobriyan 		.maxlen		= sizeof(unsigned int),
31239cfe015aSEric Dumazet 		.mode		= 0644,
31246d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
3125eceea0b3SAl Viro 		.extra1		= &sysctl_nr_open_min,
3126eceea0b3SAl Viro 		.extra2		= &sysctl_nr_open_max,
31279cfe015aSEric Dumazet 	},
31289cfe015aSEric Dumazet 	{
31291da177e4SLinus Torvalds 		.procname	= "dentry-state",
31301da177e4SLinus Torvalds 		.data		= &dentry_stat,
31313942c07cSGlauber Costa 		.maxlen		= 6*sizeof(long),
31321da177e4SLinus Torvalds 		.mode		= 0444,
3133312d3ca8SChristoph Hellwig 		.proc_handler	= proc_nr_dentry,
31341da177e4SLinus Torvalds 	},
31351da177e4SLinus Torvalds 	{
31361da177e4SLinus Torvalds 		.procname	= "overflowuid",
31371da177e4SLinus Torvalds 		.data		= &fs_overflowuid,
31381da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
31391da177e4SLinus Torvalds 		.mode		= 0644,
31406d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
31411da177e4SLinus Torvalds 		.extra1		= &minolduid,
31421da177e4SLinus Torvalds 		.extra2		= &maxolduid,
31431da177e4SLinus Torvalds 	},
31441da177e4SLinus Torvalds 	{
31451da177e4SLinus Torvalds 		.procname	= "overflowgid",
31461da177e4SLinus Torvalds 		.data		= &fs_overflowgid,
31471da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
31481da177e4SLinus Torvalds 		.mode		= 0644,
31496d456111SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
31501da177e4SLinus Torvalds 		.extra1		= &minolduid,
31511da177e4SLinus Torvalds 		.extra2		= &maxolduid,
31521da177e4SLinus Torvalds 	},
3153bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING
31541da177e4SLinus Torvalds 	{
31551da177e4SLinus Torvalds 		.procname	= "leases-enable",
31561da177e4SLinus Torvalds 		.data		= &leases_enable,
31571da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
31581da177e4SLinus Torvalds 		.mode		= 0644,
31596d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
31601da177e4SLinus Torvalds 	},
3161bfcd17a6SThomas Petazzoni #endif
31621da177e4SLinus Torvalds #ifdef CONFIG_DNOTIFY
31631da177e4SLinus Torvalds 	{
31641da177e4SLinus Torvalds 		.procname	= "dir-notify-enable",
31651da177e4SLinus Torvalds 		.data		= &dir_notify_enable,
31661da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
31671da177e4SLinus Torvalds 		.mode		= 0644,
31686d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
31691da177e4SLinus Torvalds 	},
31701da177e4SLinus Torvalds #endif
31711da177e4SLinus Torvalds #ifdef CONFIG_MMU
3172bfcd17a6SThomas Petazzoni #ifdef CONFIG_FILE_LOCKING
31731da177e4SLinus Torvalds 	{
31741da177e4SLinus Torvalds 		.procname	= "lease-break-time",
31751da177e4SLinus Torvalds 		.data		= &lease_break_time,
31761da177e4SLinus Torvalds 		.maxlen		= sizeof(int),
31771da177e4SLinus Torvalds 		.mode		= 0644,
31786d456111SEric W. Biederman 		.proc_handler	= proc_dointvec,
31791da177e4SLinus Torvalds 	},
3180bfcd17a6SThomas Petazzoni #endif
3181ebf3f09cSThomas Petazzoni #ifdef CONFIG_AIO
31821da177e4SLinus Torvalds 	{
31831da177e4SLinus Torvalds 		.procname	= "aio-nr",
31841da177e4SLinus Torvalds 		.data		= &aio_nr,
31851da177e4SLinus Torvalds 		.maxlen		= sizeof(aio_nr),
31861da177e4SLinus Torvalds 		.mode		= 0444,
31876d456111SEric W. Biederman 		.proc_handler	= proc_doulongvec_minmax,
31881da177e4SLinus Torvalds 	},
31891da177e4SLinus Torvalds 	{
31901da177e4SLinus Torvalds 		.procname	= "aio-max-nr",
31911da177e4SLinus Torvalds 		.data		= &aio_max_nr,
31921da177e4SLinus Torvalds 		.maxlen		= sizeof(aio_max_nr),
31931da177e4SLinus Torvalds 		.mode		= 0644,
31946d456111SEric W. Biederman 		.proc_handler	= proc_doulongvec_minmax,
31951da177e4SLinus Torvalds 	},
3196ebf3f09cSThomas Petazzoni #endif /* CONFIG_AIO */
31972d9048e2SAmy Griffis #ifdef CONFIG_INOTIFY_USER
31980399cb08SRobert Love 	{
31990399cb08SRobert Love 		.procname	= "inotify",
32000399cb08SRobert Love 		.mode		= 0555,
32010399cb08SRobert Love 		.child		= inotify_table,
32020399cb08SRobert Love 	},
32030399cb08SRobert Love #endif
32047ef9964eSDavide Libenzi #ifdef CONFIG_EPOLL
32057ef9964eSDavide Libenzi 	{
32067ef9964eSDavide Libenzi 		.procname	= "epoll",
32077ef9964eSDavide Libenzi 		.mode		= 0555,
32087ef9964eSDavide Libenzi 		.child		= epoll_table,
32097ef9964eSDavide Libenzi 	},
32107ef9964eSDavide Libenzi #endif
32111da177e4SLinus Torvalds #endif
3212d6e71144SAlan Cox 	{
3213800179c9SKees Cook 		.procname	= "protected_symlinks",
3214800179c9SKees Cook 		.data		= &sysctl_protected_symlinks,
3215800179c9SKees Cook 		.maxlen		= sizeof(int),
3216800179c9SKees Cook 		.mode		= 0600,
3217800179c9SKees Cook 		.proc_handler	= proc_dointvec_minmax,
3218eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
3219eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
3220800179c9SKees Cook 	},
3221800179c9SKees Cook 	{
3222800179c9SKees Cook 		.procname	= "protected_hardlinks",
3223800179c9SKees Cook 		.data		= &sysctl_protected_hardlinks,
3224800179c9SKees Cook 		.maxlen		= sizeof(int),
3225800179c9SKees Cook 		.mode		= 0600,
3226800179c9SKees Cook 		.proc_handler	= proc_dointvec_minmax,
3227eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
3228eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
3229800179c9SKees Cook 	},
3230800179c9SKees Cook 	{
323130aba665SSalvatore Mesoraca 		.procname	= "protected_fifos",
323230aba665SSalvatore Mesoraca 		.data		= &sysctl_protected_fifos,
323330aba665SSalvatore Mesoraca 		.maxlen		= sizeof(int),
323430aba665SSalvatore Mesoraca 		.mode		= 0600,
323530aba665SSalvatore Mesoraca 		.proc_handler	= proc_dointvec_minmax,
3236eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
323730aba665SSalvatore Mesoraca 		.extra2		= &two,
323830aba665SSalvatore Mesoraca 	},
323930aba665SSalvatore Mesoraca 	{
324030aba665SSalvatore Mesoraca 		.procname	= "protected_regular",
324130aba665SSalvatore Mesoraca 		.data		= &sysctl_protected_regular,
324230aba665SSalvatore Mesoraca 		.maxlen		= sizeof(int),
324330aba665SSalvatore Mesoraca 		.mode		= 0600,
324430aba665SSalvatore Mesoraca 		.proc_handler	= proc_dointvec_minmax,
3245eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
324630aba665SSalvatore Mesoraca 		.extra2		= &two,
324730aba665SSalvatore Mesoraca 	},
324830aba665SSalvatore Mesoraca 	{
3249d6e71144SAlan Cox 		.procname	= "suid_dumpable",
3250d6e71144SAlan Cox 		.data		= &suid_dumpable,
3251d6e71144SAlan Cox 		.maxlen		= sizeof(int),
3252d6e71144SAlan Cox 		.mode		= 0644,
325354b50199SKees Cook 		.proc_handler	= proc_dointvec_minmax_coredump,
3254eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
32558e654fbaSMatthew Wilcox 		.extra2		= &two,
3256d6e71144SAlan Cox 	},
32572abc26fcSEric W. Biederman #if defined(CONFIG_BINFMT_MISC) || defined(CONFIG_BINFMT_MISC_MODULE)
32582abc26fcSEric W. Biederman 	{
32592abc26fcSEric W. Biederman 		.procname	= "binfmt_misc",
32602abc26fcSEric W. Biederman 		.mode		= 0555,
3261f9bd6733SEric W. Biederman 		.child		= sysctl_mount_point,
32622abc26fcSEric W. Biederman 	},
32632abc26fcSEric W. Biederman #endif
3264b492e95bSJens Axboe 	{
3265ff9da691SJens Axboe 		.procname	= "pipe-max-size",
3266ff9da691SJens Axboe 		.data		= &pipe_max_size,
326798159d97SJoe Lawrence 		.maxlen		= sizeof(pipe_max_size),
3268b492e95bSJens Axboe 		.mode		= 0644,
3269319e0a21SEric Biggers 		.proc_handler	= proc_dopipe_max_size,
3270b492e95bSJens Axboe 	},
3271759c0114SWilly Tarreau 	{
3272759c0114SWilly Tarreau 		.procname	= "pipe-user-pages-hard",
3273759c0114SWilly Tarreau 		.data		= &pipe_user_pages_hard,
3274759c0114SWilly Tarreau 		.maxlen		= sizeof(pipe_user_pages_hard),
3275759c0114SWilly Tarreau 		.mode		= 0644,
3276759c0114SWilly Tarreau 		.proc_handler	= proc_doulongvec_minmax,
3277759c0114SWilly Tarreau 	},
3278759c0114SWilly Tarreau 	{
3279759c0114SWilly Tarreau 		.procname	= "pipe-user-pages-soft",
3280759c0114SWilly Tarreau 		.data		= &pipe_user_pages_soft,
3281759c0114SWilly Tarreau 		.maxlen		= sizeof(pipe_user_pages_soft),
3282759c0114SWilly Tarreau 		.mode		= 0644,
3283759c0114SWilly Tarreau 		.proc_handler	= proc_doulongvec_minmax,
3284759c0114SWilly Tarreau 	},
3285d2921684SEric W. Biederman 	{
3286d2921684SEric W. Biederman 		.procname	= "mount-max",
3287d2921684SEric W. Biederman 		.data		= &sysctl_mount_max,
3288d2921684SEric W. Biederman 		.maxlen		= sizeof(unsigned int),
3289d2921684SEric W. Biederman 		.mode		= 0644,
3290d2921684SEric W. Biederman 		.proc_handler	= proc_dointvec_minmax,
3291eec4844fSMatteo Croce 		.extra1		= SYSCTL_ONE,
3292d2921684SEric W. Biederman 	},
32936fce56ecSEric W. Biederman 	{ }
32941da177e4SLinus Torvalds };
32951da177e4SLinus Torvalds 
3296d8217f07SEric W. Biederman static struct ctl_table debug_table[] = {
32977ac57a89SCatalin Marinas #ifdef CONFIG_SYSCTL_EXCEPTION_TRACE
3298abd4f750SMasoud Asgharifard Sharbiani 	{
3299abd4f750SMasoud Asgharifard Sharbiani 		.procname	= "exception-trace",
3300abd4f750SMasoud Asgharifard Sharbiani 		.data		= &show_unhandled_signals,
3301abd4f750SMasoud Asgharifard Sharbiani 		.maxlen		= sizeof(int),
3302abd4f750SMasoud Asgharifard Sharbiani 		.mode		= 0644,
3303abd4f750SMasoud Asgharifard Sharbiani 		.proc_handler	= proc_dointvec
3304abd4f750SMasoud Asgharifard Sharbiani 	},
3305abd4f750SMasoud Asgharifard Sharbiani #endif
3306b2be84dfSMasami Hiramatsu #if defined(CONFIG_OPTPROBES)
3307b2be84dfSMasami Hiramatsu 	{
3308b2be84dfSMasami Hiramatsu 		.procname	= "kprobes-optimization",
3309b2be84dfSMasami Hiramatsu 		.data		= &sysctl_kprobes_optimization,
3310b2be84dfSMasami Hiramatsu 		.maxlen		= sizeof(int),
3311b2be84dfSMasami Hiramatsu 		.mode		= 0644,
3312b2be84dfSMasami Hiramatsu 		.proc_handler	= proc_kprobes_optimization_handler,
3313eec4844fSMatteo Croce 		.extra1		= SYSCTL_ZERO,
3314eec4844fSMatteo Croce 		.extra2		= SYSCTL_ONE,
3315b2be84dfSMasami Hiramatsu 	},
3316b2be84dfSMasami Hiramatsu #endif
33176fce56ecSEric W. Biederman 	{ }
33181da177e4SLinus Torvalds };
33191da177e4SLinus Torvalds 
3320d8217f07SEric W. Biederman static struct ctl_table dev_table[] = {
33216fce56ecSEric W. Biederman 	{ }
33221da177e4SLinus Torvalds };
33231da177e4SLinus Torvalds 
3324f461d2dcSChristoph Hellwig static struct ctl_table sysctl_base_table[] = {
3325f461d2dcSChristoph Hellwig 	{
3326f461d2dcSChristoph Hellwig 		.procname	= "kernel",
3327f461d2dcSChristoph Hellwig 		.mode		= 0555,
3328f461d2dcSChristoph Hellwig 		.child		= kern_table,
3329f461d2dcSChristoph Hellwig 	},
3330f461d2dcSChristoph Hellwig 	{
3331f461d2dcSChristoph Hellwig 		.procname	= "vm",
3332f461d2dcSChristoph Hellwig 		.mode		= 0555,
3333f461d2dcSChristoph Hellwig 		.child		= vm_table,
3334f461d2dcSChristoph Hellwig 	},
3335f461d2dcSChristoph Hellwig 	{
3336f461d2dcSChristoph Hellwig 		.procname	= "fs",
3337f461d2dcSChristoph Hellwig 		.mode		= 0555,
3338f461d2dcSChristoph Hellwig 		.child		= fs_table,
3339f461d2dcSChristoph Hellwig 	},
3340f461d2dcSChristoph Hellwig 	{
3341f461d2dcSChristoph Hellwig 		.procname	= "debug",
3342f461d2dcSChristoph Hellwig 		.mode		= 0555,
3343f461d2dcSChristoph Hellwig 		.child		= debug_table,
3344f461d2dcSChristoph Hellwig 	},
3345f461d2dcSChristoph Hellwig 	{
3346f461d2dcSChristoph Hellwig 		.procname	= "dev",
3347f461d2dcSChristoph Hellwig 		.mode		= 0555,
3348f461d2dcSChristoph Hellwig 		.child		= dev_table,
3349f461d2dcSChristoph Hellwig 	},
3350f461d2dcSChristoph Hellwig 	{ }
3351f461d2dcSChristoph Hellwig };
3352f461d2dcSChristoph Hellwig 
3353de4e83bdSEric W. Biederman int __init sysctl_init(void)
3354330d57fbSAl Viro {
3355fd4b616bSSteven Rostedt 	struct ctl_table_header *hdr;
3356fd4b616bSSteven Rostedt 
3357fd4b616bSSteven Rostedt 	hdr = register_sysctl_table(sysctl_base_table);
3358fd4b616bSSteven Rostedt 	kmemleak_not_leak(hdr);
3359330d57fbSAl Viro 	return 0;
3360f7e6ced4SAl Viro }
3361b89a8171SEric W. Biederman #endif /* CONFIG_SYSCTL */
33621da177e4SLinus Torvalds /*
33631da177e4SLinus Torvalds  * No sense putting this after each symbol definition, twice,
33641da177e4SLinus Torvalds  * exception granted :-)
33651da177e4SLinus Torvalds  */
33661da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec);
3367e7d316a0SSubash Abhinov Kasiviswanathan EXPORT_SYMBOL(proc_douintvec);
33681da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_jiffies);
33691da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_minmax);
337061d9b56aSLuis R. Rodriguez EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
33711da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
33721da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
33731da177e4SLinus Torvalds EXPORT_SYMBOL(proc_dostring);
33741da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_minmax);
33751da177e4SLinus Torvalds EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
33760bc19985SStephen Suryaputra EXPORT_SYMBOL(proc_do_large_bitmap);
3377