1	// SPDX-License-Identifier: GPL-2.0-only
2	/*
3	* sysctl.c: General linux system control interface
4	*
5	* Begun 24 March 1995, Stephen Tweedie
6	* Added /proc support, Dec 1995
7	* Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
8	* Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver.
9	* Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
10	* Dynamic registration fixes, Stephen Tweedie.
11	* Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
12	* Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris
13	* Horn.
14	* Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer.
15	* Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer.
16	* Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill
17	* Wendling.
18	* The list_for_each() macro wasn't appropriate for the sysctl loop.
19	* Removed it and replaced it with older style, 03/23/00, Bill Wendling
20	*/
21
22	#include <linux/module.h>
23	#include <linux/mm.h>
24	#include <linux/swap.h>
25	#include <linux/slab.h>
26	#include <linux/sysctl.h>
27	#include <linux/bitmap.h>
28	#include <linux/signal.h>
29	#include <linux/panic.h>
30	#include <linux/printk.h>
31	#include <linux/proc_fs.h>
32	#include <linux/security.h>
33	#include <linux/ctype.h>
34	#include <linux/kmemleak.h>
35	#include <linux/filter.h>
36	#include <linux/fs.h>
37	#include <linux/init.h>
38	#include <linux/kernel.h>
39	#include <linux/kobject.h>
40	#include <linux/net.h>
41	#include <linux/sysrq.h>
42	#include <linux/highuid.h>
43	#include <linux/writeback.h>
44	#include <linux/ratelimit.h>
45	#include <linux/hugetlb.h>
46	#include <linux/initrd.h>
47	#include <linux/key.h>
48	#include <linux/times.h>
49	#include <linux/limits.h>
50	#include <linux/dcache.h>
51	#include <linux/syscalls.h>
52	#include <linux/vmstat.h>
53	#include <linux/nfs_fs.h>
54	#include <linux/acpi.h>
55	#include <linux/reboot.h>
56	#include <linux/ftrace.h>
57	#include <linux/perf_event.h>
58	#include <linux/oom.h>
59	#include <linux/kmod.h>
60	#include <linux/capability.h>
61	#include <linux/binfmts.h>
62	#include <linux/sched/sysctl.h>
63	#include <linux/mount.h>
64	#include <linux/userfaultfd_k.h>
65	#include <linux/pid.h>
66
67	#include "../lib/kstrtox.h"
68
69	#include <linux/uaccess.h>
70	#include <asm/processor.h>
71
72	#ifdef CONFIG_X86
73	#include <asm/nmi.h>
74	#include <asm/stacktrace.h>
75	#include <asm/io.h>
76	#endif
77	#ifdef CONFIG_SPARC
78	#include <asm/setup.h>
79	#endif
80	#ifdef CONFIG_RT_MUTEXES
81	#include <linux/rtmutex.h>
82	#endif
83
84	/* shared constants to be used in various sysctls */
85	const int sysctl_vals[] = { 0, 1, 2, 3, 4, 100, 200, 1000, 3000, INT_MAX, 65535, -1 };
86	EXPORT_SYMBOL(sysctl_vals);
87
88	const unsigned long sysctl_long_vals[] = { 0, 1, LONG_MAX };
89	EXPORT_SYMBOL_GPL(sysctl_long_vals);
90
91	#if defined(CONFIG_SYSCTL)
92
93	/* Constants used for minimum and maximum */
94
95	#ifdef CONFIG_PERF_EVENTS
96	static const int six_hundred_forty_kb = 640 * 1024;
97	#endif
98
99
100	static const int ngroups_max = NGROUPS_MAX;
101	static const int cap_last_cap = CAP_LAST_CAP;
102
103	#ifdef CONFIG_PROC_SYSCTL
104
105	/**
106	* enum sysctl_writes_mode - supported sysctl write modes
107	*
108	* @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
109	* to be written, and multiple writes on the same sysctl file descriptor
110	* will rewrite the sysctl value, regardless of file position. No warning
111	* is issued when the initial position is not 0.
112	* @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
113	* not 0.
114	* @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
115	* file position 0 and the value must be fully contained in the buffer
116	* sent to the write syscall. If dealing with strings respect the file
117	* position, but restrict this to the max length of the buffer, anything
118	* passed the max length will be ignored. Multiple writes will append
119	* to the buffer.
120	*
121	* These write modes control how current file position affects the behavior of
122	* updating sysctl values through the proc interface on each write.
123	*/
124	enum sysctl_writes_mode {
125	SYSCTL_WRITES_LEGACY = -1,
126	SYSCTL_WRITES_WARN = 0,
127	SYSCTL_WRITES_STRICT = 1,
128	};
129
130	static enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT;
131	#endif /* CONFIG_PROC_SYSCTL */
132
133	#if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
134	defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
135	int sysctl_legacy_va_layout;
136	#endif
137
138	#endif /* CONFIG_SYSCTL */
139
140	/*
141	* /proc/sys support
142	*/
143
144	#ifdef CONFIG_PROC_SYSCTL
145
146	static int _proc_do_string(char *data, int maxlen, int write,
147	char *buffer, size_t *lenp, loff_t *ppos)
148	{
149	size_t len;
150	char c, *p;
151
152	if (!data || !maxlen || !*lenp) {
153	*lenp = 0;
154	return 0;
155	}
156
157	if (write) {
158	if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
159	/* Only continue writes not past the end of buffer. */
160	len = strlen(data);
161	if (len > maxlen - 1)
162	len = maxlen - 1;
163
164	if (*ppos > len)
165	return 0;
166	len = *ppos;
167	} else {
168	/* Start writing from beginning of buffer. */
169	len = 0;
170	}
171
172	*ppos += *lenp;
173	p = buffer;
174	while ((p - buffer) < *lenp && len < maxlen - 1) {
175	c = *(p++);
176	if (c == 0 || c == '\n')
177	break;
178	data[len++] = c;
179	}
180	data[len] = 0;
181	} else {
182	len = strlen(data);
183	if (len > maxlen)
184	len = maxlen;
185
186	if (*ppos > len) {
187	*lenp = 0;
188	return 0;
189	}
190
191	data += *ppos;
192	len -= *ppos;
193
194	if (len > *lenp)
195	len = *lenp;
196	if (len)
197	memcpy(buffer, data, len);
198	if (len < *lenp) {
199	buffer[len] = '\n';
200	len++;
201	}
202	*lenp = len;
203	*ppos += len;
204	}
205	return 0;
206	}
207
208	static void warn_sysctl_write(struct ctl_table *table)
209	{
210	pr_warn_once("%s wrote to %s when file position was not 0!\n"
211	"This will not be supported in the future. To silence this\n"
212	"warning, set kernel.sysctl_writes_strict = -1\n",
213	current->comm, table->procname);
214	}
215
216	/**
217	* proc_first_pos_non_zero_ignore - check if first position is allowed
218	* @ppos: file position
219	* @table: the sysctl table
220	*
221	* Returns true if the first position is non-zero and the sysctl_writes_strict
222	* mode indicates this is not allowed for numeric input types. String proc
223	* handlers can ignore the return value.
224	*/
225	static bool proc_first_pos_non_zero_ignore(loff_t *ppos,
226	struct ctl_table *table)
227	{
228	if (!*ppos)
229	return false;
230
231	switch (sysctl_writes_strict) {
232	case SYSCTL_WRITES_STRICT:
233	return true;
234	case SYSCTL_WRITES_WARN:
235	warn_sysctl_write(table);
236	return false;
237	default:
238	return false;
239	}
240	}
241
242	/**
243	* proc_dostring - read a string sysctl
244	* @table: the sysctl table
245	* @write: %TRUE if this is a write to the sysctl file
246	* @buffer: the user buffer
247	* @lenp: the size of the user buffer
248	* @ppos: file position
249	*
250	* Reads/writes a string from/to the user buffer. If the kernel
251	* buffer provided is not large enough to hold the string, the
252	* string is truncated. The copied string is %NULL-terminated.
253	* If the string is being read by the user process, it is copied
254	* and a newline '\n' is added. It is truncated if the buffer is
255	* not large enough.
256	*
257	* Returns 0 on success.
258	*/
259	int proc_dostring(struct ctl_table *table, int write,
260	void *buffer, size_t *lenp, loff_t *ppos)
261	{
262	if (write)
263	proc_first_pos_non_zero_ignore(ppos, table);
264
265	return _proc_do_string(data: table->data, maxlen: table->maxlen, write, buffer, lenp,
266	ppos);
267	}
268
269	static void proc_skip_spaces(char **buf, size_t *size)
270	{
271	while (*size) {
272	if (!isspace(**buf))
273	break;
274	(*size)--;
275	(*buf)++;
276	}
277	}
278
279	static void proc_skip_char(char **buf, size_t *size, const char v)
280	{
281	while (*size) {
282	if (**buf != v)
283	break;
284	(*size)--;
285	(*buf)++;
286	}
287	}
288
289	/**
290	* strtoul_lenient - parse an ASCII formatted integer from a buffer and only
291	* fail on overflow
292	*
293	* @cp: kernel buffer containing the string to parse
294	* @endp: pointer to store the trailing characters
295	* @base: the base to use
296	* @res: where the parsed integer will be stored
297	*
298	* In case of success 0 is returned and @res will contain the parsed integer,
299	* @endp will hold any trailing characters.
300	* This function will fail the parse on overflow. If there wasn't an overflow
301	* the function will defer the decision what characters count as invalid to the
302	* caller.
303	*/
304	static int strtoul_lenient(const char *cp, char **endp, unsigned int base,
305	unsigned long *res)
306	{
307	unsigned long long result;
308	unsigned int rv;
309
310	cp = _parse_integer_fixup_radix(s: cp, base: &base);
311	rv = _parse_integer(s: cp, base, res: &result);
312	if ((rv & KSTRTOX_OVERFLOW) || (result != (unsigned long)result))
313	return -ERANGE;
314
315	cp += rv;
316
317	if (endp)
318	*endp = (char *)cp;
319
320	*res = (unsigned long)result;
321	return 0;
322	}
323
324	#define TMPBUFLEN 22
325	/**
326	* proc_get_long - reads an ASCII formatted integer from a user buffer
327	*
328	* @buf: a kernel buffer
329	* @size: size of the kernel buffer
330	* @val: this is where the number will be stored
331	* @neg: set to %TRUE if number is negative
332	* @perm_tr: a vector which contains the allowed trailers
333	* @perm_tr_len: size of the perm_tr vector
334	* @tr: pointer to store the trailer character
335	*
336	* In case of success %0 is returned and @buf and @size are updated with
337	* the amount of bytes read. If @tr is non-NULL and a trailing
338	* character exists (size is non-zero after returning from this
339	* function), @tr is updated with the trailing character.
340	*/
341	static int proc_get_long(char **buf, size_t *size,
342	unsigned long *val, bool *neg,
343	const char *perm_tr, unsigned perm_tr_len, char *tr)
344	{
345	char *p, tmp[TMPBUFLEN];
346	ssize_t len = *size;
347
348	if (len <= 0)
349	return -EINVAL;
350
351	if (len > TMPBUFLEN - 1)
352	len = TMPBUFLEN - 1;
353
354	memcpy(tmp, *buf, len);
355
356	tmp[len] = 0;
357	p = tmp;
358	if (*p == '-' && *size > 1) {
359	*neg = true;
360	p++;
361	} else
362	*neg = false;
363	if (!isdigit(c: *p))
364	return -EINVAL;
365
366	if (strtoul_lenient(cp: p, endp: &p, base: 0, res: val))
367	return -EINVAL;
368
369	len = p - tmp;
370
371	/* We don't know if the next char is whitespace thus we may accept
372	* invalid integers (e.g. 1234...a) or two integers instead of one
373	* (e.g. 123...1). So lets not allow such large numbers. */
374	if (len == TMPBUFLEN - 1)
375	return -EINVAL;
376
377	if (len < *size && perm_tr_len && !memchr(p: perm_tr, c: *p, size: perm_tr_len))
378	return -EINVAL;
379
380	if (tr && (len < *size))
381	*tr = *p;
382
383	*buf += len;
384	*size -= len;
385
386	return 0;
387	}
388
389	/**
390	* proc_put_long - converts an integer to a decimal ASCII formatted string
391	*
392	* @buf: the user buffer
393	* @size: the size of the user buffer
394	* @val: the integer to be converted
395	* @neg: sign of the number, %TRUE for negative
396	*
397	* In case of success @buf and @size are updated with the amount of bytes
398	* written.
399	*/
400	static void proc_put_long(void **buf, size_t *size, unsigned long val, bool neg)
401	{
402	int len;
403	char tmp[TMPBUFLEN], *p = tmp;
404
405	sprintf(buf: p, fmt: "%s%lu", neg ? "-" : "", val);
406	len = strlen(tmp);
407	if (len > *size)
408	len = *size;
409	memcpy(*buf, tmp, len);
410	*size -= len;
411	*buf += len;
412	}
413	#undef TMPBUFLEN
414
415	static void proc_put_char(void **buf, size_t *size, char c)
416	{
417	if (*size) {
418	char **buffer = (char **)buf;
419	**buffer = c;
420
421	(*size)--;
422	(*buffer)++;
423	*buf = *buffer;
424	}
425	}
426
427	static int do_proc_dointvec_conv(bool *negp, unsigned long *lvalp,
428	int *valp,
429	int write, void *data)
430	{
431	if (write) {
432	if (*negp) {
433	if (*lvalp > (unsigned long) INT_MAX + 1)
434	return -EINVAL;
435	WRITE_ONCE(*valp, -*lvalp);
436	} else {
437	if (*lvalp > (unsigned long) INT_MAX)
438	return -EINVAL;
439	WRITE_ONCE(*valp, *lvalp);
440	}
441	} else {
442	int val = READ_ONCE(*valp);
443	if (val < 0) {
444	*negp = true;
445	*lvalp = -(unsigned long)val;
446	} else {
447	*negp = false;
448	*lvalp = (unsigned long)val;
449	}
450	}
451	return 0;
452	}
453
454	static int do_proc_douintvec_conv(unsigned long *lvalp,
455	unsigned int *valp,
456	int write, void *data)
457	{
458	if (write) {
459	if (*lvalp > UINT_MAX)
460	return -EINVAL;
461	WRITE_ONCE(*valp, *lvalp);
462	} else {
463	unsigned int val = READ_ONCE(*valp);
464	*lvalp = (unsigned long)val;
465	}
466	return 0;
467	}
468
469	static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
470
471	static int __do_proc_dointvec(void *tbl_data, struct ctl_table *table,
472	int write, void *buffer,
473	size_t *lenp, loff_t *ppos,
474	int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
475	int write, void *data),
476	void *data)
477	{
478	int *i, vleft, first = 1, err = 0;
479	size_t left;
480	char *p;
481
482	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
483	*lenp = 0;
484	return 0;
485	}
486
487	i = (int *) tbl_data;
488	vleft = table->maxlen / sizeof(*i);
489	left = *lenp;
490
491	if (!conv)
492	conv = do_proc_dointvec_conv;
493
494	if (write) {
495	if (proc_first_pos_non_zero_ignore(ppos, table))
496	goto out;
497
498	if (left > PAGE_SIZE - 1)
499	left = PAGE_SIZE - 1;
500	p = buffer;
501	}
502
503	for (; left && vleft--; i++, first=0) {
504	unsigned long lval;
505	bool neg;
506
507	if (write) {
508	proc_skip_spaces(buf: &p, size: &left);
509
510	if (!left)
511	break;
512	err = proc_get_long(buf: &p, size: &left, val: &lval, neg: &neg,
513	perm_tr: proc_wspace_sep,
514	perm_tr_len: sizeof(proc_wspace_sep), NULL);
515	if (err)
516	break;
517	if (conv(&neg, &lval, i, 1, data)) {
518	err = -EINVAL;
519	break;
520	}
521	} else {
522	if (conv(&neg, &lval, i, 0, data)) {
523	err = -EINVAL;
524	break;
525	}
526	if (!first)
527	proc_put_char(buf: &buffer, size: &left, c: '\t');
528	proc_put_long(buf: &buffer, size: &left, val: lval, neg);
529	}
530	}
531
532	if (!write && !first && left && !err)
533	proc_put_char(buf: &buffer, size: &left, c: '\n');
534	if (write && !err && left)
535	proc_skip_spaces(buf: &p, size: &left);
536	if (write && first)
537	return err ? : -EINVAL;
538	*lenp -= left;
539	out:
540	*ppos += *lenp;
541	return err;
542	}
543
544	static int do_proc_dointvec(struct ctl_table *table, int write,
545	void *buffer, size_t *lenp, loff_t *ppos,
546	int (*conv)(bool *negp, unsigned long *lvalp, int *valp,
547	int write, void *data),
548	void *data)
549	{
550	return __do_proc_dointvec(tbl_data: table->data, table, write,
551	buffer, lenp, ppos, conv, data);
552	}
553
554	static int do_proc_douintvec_w(unsigned int *tbl_data,
555	struct ctl_table *table,
556	void *buffer,
557	size_t *lenp, loff_t *ppos,
558	int (*conv)(unsigned long *lvalp,
559	unsigned int *valp,
560	int write, void *data),
561	void *data)
562	{
563	unsigned long lval;
564	int err = 0;
565	size_t left;
566	bool neg;
567	char *p = buffer;
568
569	left = *lenp;
570
571	if (proc_first_pos_non_zero_ignore(ppos, table))
572	goto bail_early;
573
574	if (left > PAGE_SIZE - 1)
575	left = PAGE_SIZE - 1;
576
577	proc_skip_spaces(buf: &p, size: &left);
578	if (!left) {
579	err = -EINVAL;
580	goto out_free;
581	}
582
583	err = proc_get_long(buf: &p, size: &left, val: &lval, neg: &neg,
584	perm_tr: proc_wspace_sep,
585	perm_tr_len: sizeof(proc_wspace_sep), NULL);
586	if (err || neg) {
587	err = -EINVAL;
588	goto out_free;
589	}
590
591	if (conv(&lval, tbl_data, 1, data)) {
592	err = -EINVAL;
593	goto out_free;
594	}
595
596	if (!err && left)
597	proc_skip_spaces(buf: &p, size: &left);
598
599	out_free:
600	if (err)
601	return -EINVAL;
602
603	return 0;
604
605	/* This is in keeping with old __do_proc_dointvec() */
606	bail_early:
607	*ppos += *lenp;
608	return err;
609	}
610
611	static int do_proc_douintvec_r(unsigned int *tbl_data, void *buffer,
612	size_t *lenp, loff_t *ppos,
613	int (*conv)(unsigned long *lvalp,
614	unsigned int *valp,
615	int write, void *data),
616	void *data)
617	{
618	unsigned long lval;
619	int err = 0;
620	size_t left;
621
622	left = *lenp;
623
624	if (conv(&lval, tbl_data, 0, data)) {
625	err = -EINVAL;
626	goto out;
627	}
628
629	proc_put_long(buf: &buffer, size: &left, val: lval, neg: false);
630	if (!left)
631	goto out;
632
633	proc_put_char(buf: &buffer, size: &left, c: '\n');
634
635	out:
636	*lenp -= left;
637	*ppos += *lenp;
638
639	return err;
640	}
641
642	static int __do_proc_douintvec(void *tbl_data, struct ctl_table *table,
643	int write, void *buffer,
644	size_t *lenp, loff_t *ppos,
645	int (*conv)(unsigned long *lvalp,
646	unsigned int *valp,
647	int write, void *data),
648	void *data)
649	{
650	unsigned int *i, vleft;
651
652	if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
653	*lenp = 0;
654	return 0;
655	}
656
657	i = (unsigned int *) tbl_data;
658	vleft = table->maxlen / sizeof(*i);
659
660	/*
661	* Arrays are not supported, keep this simple. *Do not* add
662	* support for them.
663	*/
664	if (vleft != 1) {
665	*lenp = 0;
666	return -EINVAL;
667	}
668
669	if (!conv)
670	conv = do_proc_douintvec_conv;
671
672	if (write)
673	return do_proc_douintvec_w(tbl_data: i, table, buffer, lenp, ppos,
674	conv, data);
675	return do_proc_douintvec_r(tbl_data: i, buffer, lenp, ppos, conv, data);
676	}
677
678	int do_proc_douintvec(struct ctl_table *table, int write,
679	void *buffer, size_t *lenp, loff_t *ppos,
680	int (*conv)(unsigned long *lvalp,
681	unsigned int *valp,
682	int write, void *data),
683	void *data)
684	{
685	return __do_proc_douintvec(tbl_data: table->data, table, write,
686	buffer, lenp, ppos, conv, data);
687	}
688
689	/**
690	* proc_dobool - read/write a bool
691	* @table: the sysctl table
692	* @write: %TRUE if this is a write to the sysctl file
693	* @buffer: the user buffer
694	* @lenp: the size of the user buffer
695	* @ppos: file position
696	*
697	* Reads/writes one integer value from/to the user buffer,
698	* treated as an ASCII string.
699	*
700	* table->data must point to a bool variable and table->maxlen must
701	* be sizeof(bool).
702	*
703	* Returns 0 on success.
704	*/
705	int proc_dobool(struct ctl_table *table, int write, void *buffer,
706	size_t *lenp, loff_t *ppos)
707	{
708	struct ctl_table tmp;
709	bool *data = table->data;
710	int res, val;
711
712	/* Do not support arrays yet. */
713	if (table->maxlen != sizeof(bool))
714	return -EINVAL;
715
716	tmp = *table;
717	tmp.maxlen = sizeof(val);
718	tmp.data = &val;
719
720	val = READ_ONCE(*data);
721	res = proc_dointvec(&tmp, write, buffer, lenp, ppos);
722	if (res)
723	return res;
724	if (write)
725	WRITE_ONCE(*data, val);
726	return 0;
727	}
728
729	/**
730	* proc_dointvec - read a vector of integers
731	* @table: the sysctl table
732	* @write: %TRUE if this is a write to the sysctl file
733	* @buffer: the user buffer
734	* @lenp: the size of the user buffer
735	* @ppos: file position
736	*
737	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
738	* values from/to the user buffer, treated as an ASCII string.
739	*
740	* Returns 0 on success.
741	*/
742	int proc_dointvec(struct ctl_table *table, int write, void *buffer,
743	size_t *lenp, loff_t *ppos)
744	{
745	return do_proc_dointvec(table, write, buffer, lenp, ppos, NULL, NULL);
746	}
747
748	/**
749	* proc_douintvec - read a vector of unsigned integers
750	* @table: the sysctl table
751	* @write: %TRUE if this is a write to the sysctl file
752	* @buffer: the user buffer
753	* @lenp: the size of the user buffer
754	* @ppos: file position
755	*
756	* Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
757	* values from/to the user buffer, treated as an ASCII string.
758	*
759	* Returns 0 on success.
760	*/
761	int proc_douintvec(struct ctl_table *table, int write, void *buffer,
762	size_t *lenp, loff_t *ppos)
763	{
764	return do_proc_douintvec(table, write, buffer, lenp, ppos,
765	conv: do_proc_douintvec_conv, NULL);
766	}
767
768	/*
769	* Taint values can only be increased
770	* This means we can safely use a temporary.
771	*/
772	static int proc_taint(struct ctl_table *table, int write,
773	void *buffer, size_t *lenp, loff_t *ppos)
774	{
775	struct ctl_table t;
776	unsigned long tmptaint = get_taint();
777	int err;
778
779	if (write && !capable(CAP_SYS_ADMIN))
780	return -EPERM;
781
782	t = *table;
783	t.data = &tmptaint;
784	err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos);
785	if (err < 0)
786	return err;
787
788	if (write) {
789	int i;
790
791	/*
792	* If we are relying on panic_on_taint not producing
793	* false positives due to userspace input, bail out
794	* before setting the requested taint flags.
795	*/
796	if (panic_on_taint_nousertaint && (tmptaint & panic_on_taint))
797	return -EINVAL;
798
799	/*
800	* Poor man's atomic or. Not worth adding a primitive
801	* to everyone's atomic.h for this
802	*/
803	for (i = 0; i < TAINT_FLAGS_COUNT; i++)
804	if ((1UL << i) & tmptaint)
805	add_taint(flag: i, LOCKDEP_STILL_OK);
806	}
807
808	return err;
809	}
810
811	/**
812	* struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
813	* @min: pointer to minimum allowable value
814	* @max: pointer to maximum allowable value
815	*
816	* The do_proc_dointvec_minmax_conv_param structure provides the
817	* minimum and maximum values for doing range checking for those sysctl
818	* parameters that use the proc_dointvec_minmax() handler.
819	*/
820	struct do_proc_dointvec_minmax_conv_param {
821	int *min;
822	int *max;
823	};
824
825	static int do_proc_dointvec_minmax_conv(bool *negp, unsigned long *lvalp,
826	int *valp,
827	int write, void *data)
828	{
829	int tmp, ret;
830	struct do_proc_dointvec_minmax_conv_param *param = data;
831	/*
832	* If writing, first do so via a temporary local int so we can
833	* bounds-check it before touching *valp.
834	*/
835	int *ip = write ? &tmp : valp;
836
837	ret = do_proc_dointvec_conv(negp, lvalp, valp: ip, write, data);
838	if (ret)
839	return ret;
840
841	if (write) {
842	if ((param->min && *param->min > tmp) ||
843	(param->max && *param->max < tmp))
844	return -EINVAL;
845	WRITE_ONCE(*valp, tmp);
846	}
847
848	return 0;
849	}
850
851	/**
852	* proc_dointvec_minmax - read a vector of integers with min/max values
853	* @table: the sysctl table
854	* @write: %TRUE if this is a write to the sysctl file
855	* @buffer: the user buffer
856	* @lenp: the size of the user buffer
857	* @ppos: file position
858	*
859	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
860	* values from/to the user buffer, treated as an ASCII string.
861	*
862	* This routine will ensure the values are within the range specified by
863	* table->extra1 (min) and table->extra2 (max).
864	*
865	* Returns 0 on success or -EINVAL on write when the range check fails.
866	*/
867	int proc_dointvec_minmax(struct ctl_table *table, int write,
868	void *buffer, size_t *lenp, loff_t *ppos)
869	{
870	struct do_proc_dointvec_minmax_conv_param param = {
871	.min = (int *) table->extra1,
872	.max = (int *) table->extra2,
873	};
874	return do_proc_dointvec(table, write, buffer, lenp, ppos,
875	conv: do_proc_dointvec_minmax_conv, data: &param);
876	}
877
878	/**
879	* struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure
880	* @min: pointer to minimum allowable value
881	* @max: pointer to maximum allowable value
882	*
883	* The do_proc_douintvec_minmax_conv_param structure provides the
884	* minimum and maximum values for doing range checking for those sysctl
885	* parameters that use the proc_douintvec_minmax() handler.
886	*/
887	struct do_proc_douintvec_minmax_conv_param {
888	unsigned int *min;
889	unsigned int *max;
890	};
891
892	static int do_proc_douintvec_minmax_conv(unsigned long *lvalp,
893	unsigned int *valp,
894	int write, void *data)
895	{
896	int ret;
897	unsigned int tmp;
898	struct do_proc_douintvec_minmax_conv_param *param = data;
899	/* write via temporary local uint for bounds-checking */
900	unsigned int *up = write ? &tmp : valp;
901
902	ret = do_proc_douintvec_conv(lvalp, valp: up, write, data);
903	if (ret)
904	return ret;
905
906	if (write) {
907	if ((param->min && *param->min > tmp) ||
908	(param->max && *param->max < tmp))
909	return -ERANGE;
910
911	WRITE_ONCE(*valp, tmp);
912	}
913
914	return 0;
915	}
916
917	/**
918	* proc_douintvec_minmax - read a vector of unsigned ints with min/max values
919	* @table: the sysctl table
920	* @write: %TRUE if this is a write to the sysctl file
921	* @buffer: the user buffer
922	* @lenp: the size of the user buffer
923	* @ppos: file position
924	*
925	* Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
926	* values from/to the user buffer, treated as an ASCII string. Negative
927	* strings are not allowed.
928	*
929	* This routine will ensure the values are within the range specified by
930	* table->extra1 (min) and table->extra2 (max). There is a final sanity
931	* check for UINT_MAX to avoid having to support wrap around uses from
932	* userspace.
933	*
934	* Returns 0 on success or -ERANGE on write when the range check fails.
935	*/
936	int proc_douintvec_minmax(struct ctl_table *table, int write,
937	void *buffer, size_t *lenp, loff_t *ppos)
938	{
939	struct do_proc_douintvec_minmax_conv_param param = {
940	.min = (unsigned int *) table->extra1,
941	.max = (unsigned int *) table->extra2,
942	};
943	return do_proc_douintvec(table, write, buffer, lenp, ppos,
944	conv: do_proc_douintvec_minmax_conv, data: &param);
945	}
946
947	/**
948	* proc_dou8vec_minmax - read a vector of unsigned chars with min/max values
949	* @table: the sysctl table
950	* @write: %TRUE if this is a write to the sysctl file
951	* @buffer: the user buffer
952	* @lenp: the size of the user buffer
953	* @ppos: file position
954	*
955	* Reads/writes up to table->maxlen/sizeof(u8) unsigned chars
956	* values from/to the user buffer, treated as an ASCII string. Negative
957	* strings are not allowed.
958	*
959	* This routine will ensure the values are within the range specified by
960	* table->extra1 (min) and table->extra2 (max).
961	*
962	* Returns 0 on success or an error on write when the range check fails.
963	*/
964	int proc_dou8vec_minmax(struct ctl_table *table, int write,
965	void *buffer, size_t *lenp, loff_t *ppos)
966	{
967	struct ctl_table tmp;
968	unsigned int min = 0, max = 255U, val;
969	u8 *data = table->data;
970	struct do_proc_douintvec_minmax_conv_param param = {
971	.min = &min,
972	.max = &max,
973	};
974	int res;
975
976	/* Do not support arrays yet. */
977	if (table->maxlen != sizeof(u8))
978	return -EINVAL;
979
980	if (table->extra1) {
981	min = *(unsigned int *) table->extra1;
982	if (min > 255U)
983	return -EINVAL;
984	}
985	if (table->extra2) {
986	max = *(unsigned int *) table->extra2;
987	if (max > 255U)
988	return -EINVAL;
989	}
990
991	tmp = *table;
992
993	tmp.maxlen = sizeof(val);
994	tmp.data = &val;
995	val = READ_ONCE(*data);
996	res = do_proc_douintvec(table: &tmp, write, buffer, lenp, ppos,
997	conv: do_proc_douintvec_minmax_conv, data: &param);
998	if (res)
999	return res;
1000	if (write)
1001	WRITE_ONCE(*data, val);
1002	return 0;
1003	}
1004	EXPORT_SYMBOL_GPL(proc_dou8vec_minmax);
1005
1006	#ifdef CONFIG_MAGIC_SYSRQ
1007	static int sysrq_sysctl_handler(struct ctl_table *table, int write,
1008	void *buffer, size_t *lenp, loff_t *ppos)
1009	{
1010	int tmp, ret;
1011
1012	tmp = sysrq_mask();
1013
1014	ret = __do_proc_dointvec(tbl_data: &tmp, table, write, buffer,
1015	lenp, ppos, NULL, NULL);
1016	if (ret || !write)
1017	return ret;
1018
1019	if (write)
1020	sysrq_toggle_support(enable_mask: tmp);
1021
1022	return 0;
1023	}
1024	#endif
1025
1026	static int __do_proc_doulongvec_minmax(void *data, struct ctl_table *table,
1027	int write, void *buffer, size_t *lenp, loff_t *ppos,
1028	unsigned long convmul, unsigned long convdiv)
1029	{
1030	unsigned long *i, *min, *max;
1031	int vleft, first = 1, err = 0;
1032	size_t left;
1033	char *p;
1034
1035	if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
1036	*lenp = 0;
1037	return 0;
1038	}
1039
1040	i = data;
1041	min = table->extra1;
1042	max = table->extra2;
1043	vleft = table->maxlen / sizeof(unsigned long);
1044	left = *lenp;
1045
1046	if (write) {
1047	if (proc_first_pos_non_zero_ignore(ppos, table))
1048	goto out;
1049
1050	if (left > PAGE_SIZE - 1)
1051	left = PAGE_SIZE - 1;
1052	p = buffer;
1053	}
1054
1055	for (; left && vleft--; i++, first = 0) {
1056	unsigned long val;
1057
1058	if (write) {
1059	bool neg;
1060
1061	proc_skip_spaces(buf: &p, size: &left);
1062	if (!left)
1063	break;
1064
1065	err = proc_get_long(buf: &p, size: &left, val: &val, neg: &neg,
1066	perm_tr: proc_wspace_sep,
1067	perm_tr_len: sizeof(proc_wspace_sep), NULL);
1068	if (err || neg) {
1069	err = -EINVAL;
1070	break;
1071	}
1072
1073	val = convmul * val / convdiv;
1074	if ((min && val < *min) || (max && val > *max)) {
1075	err = -EINVAL;
1076	break;
1077	}
1078	WRITE_ONCE(*i, val);
1079	} else {
1080	val = convdiv * READ_ONCE(*i) / convmul;
1081	if (!first)
1082	proc_put_char(buf: &buffer, size: &left, c: '\t');
1083	proc_put_long(buf: &buffer, size: &left, val, neg: false);
1084	}
1085	}
1086
1087	if (!write && !first && left && !err)
1088	proc_put_char(buf: &buffer, size: &left, c: '\n');
1089	if (write && !err)
1090	proc_skip_spaces(buf: &p, size: &left);
1091	if (write && first)
1092	return err ? : -EINVAL;
1093	*lenp -= left;
1094	out:
1095	*ppos += *lenp;
1096	return err;
1097	}
1098
1099	static int do_proc_doulongvec_minmax(struct ctl_table *table, int write,
1100	void *buffer, size_t *lenp, loff_t *ppos, unsigned long convmul,
1101	unsigned long convdiv)
1102	{
1103	return __do_proc_doulongvec_minmax(data: table->data, table, write,
1104	buffer, lenp, ppos, convmul, convdiv);
1105	}
1106
1107	/**
1108	* proc_doulongvec_minmax - read a vector of long integers with min/max values
1109	* @table: the sysctl table
1110	* @write: %TRUE if this is a write to the sysctl file
1111	* @buffer: the user buffer
1112	* @lenp: the size of the user buffer
1113	* @ppos: file position
1114	*
1115	* Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1116	* values from/to the user buffer, treated as an ASCII string.
1117	*
1118	* This routine will ensure the values are within the range specified by
1119	* table->extra1 (min) and table->extra2 (max).
1120	*
1121	* Returns 0 on success.
1122	*/
1123	int proc_doulongvec_minmax(struct ctl_table *table, int write,
1124	void *buffer, size_t *lenp, loff_t *ppos)
1125	{
1126	return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, convmul: 1l, convdiv: 1l);
1127	}
1128
1129	/**
1130	* proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
1131	* @table: the sysctl table
1132	* @write: %TRUE if this is a write to the sysctl file
1133	* @buffer: the user buffer
1134	* @lenp: the size of the user buffer
1135	* @ppos: file position
1136	*
1137	* Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1138	* values from/to the user buffer, treated as an ASCII string. The values
1139	* are treated as milliseconds, and converted to jiffies when they are stored.
1140	*
1141	* This routine will ensure the values are within the range specified by
1142	* table->extra1 (min) and table->extra2 (max).
1143	*
1144	* Returns 0 on success.
1145	*/
1146	int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1147	void *buffer, size_t *lenp, loff_t *ppos)
1148	{
1149	return do_proc_doulongvec_minmax(table, write, buffer,
1150	lenp, ppos, HZ, convdiv: 1000l);
1151	}
1152
1153
1154	static int do_proc_dointvec_jiffies_conv(bool *negp, unsigned long *lvalp,
1155	int *valp,
1156	int write, void *data)
1157	{
1158	if (write) {
1159	if (*lvalp > INT_MAX / HZ)
1160	return 1;
1161	if (*negp)
1162	WRITE_ONCE(*valp, -*lvalp * HZ);
1163	else
1164	WRITE_ONCE(*valp, *lvalp * HZ);
1165	} else {
1166	int val = READ_ONCE(*valp);
1167	unsigned long lval;
1168	if (val < 0) {
1169	*negp = true;
1170	lval = -(unsigned long)val;
1171	} else {
1172	*negp = false;
1173	lval = (unsigned long)val;
1174	}
1175	*lvalp = lval / HZ;
1176	}
1177	return 0;
1178	}
1179
1180	static int do_proc_dointvec_userhz_jiffies_conv(bool *negp, unsigned long *lvalp,
1181	int *valp,
1182	int write, void *data)
1183	{
1184	if (write) {
1185	if (USER_HZ < HZ && *lvalp > (LONG_MAX / HZ) * USER_HZ)
1186	return 1;
1187	*valp = clock_t_to_jiffies(x: *negp ? -*lvalp : *lvalp);
1188	} else {
1189	int val = *valp;
1190	unsigned long lval;
1191	if (val < 0) {
1192	*negp = true;
1193	lval = -(unsigned long)val;
1194	} else {
1195	*negp = false;
1196	lval = (unsigned long)val;
1197	}
1198	*lvalp = jiffies_to_clock_t(x: lval);
1199	}
1200	return 0;
1201	}
1202
1203	static int do_proc_dointvec_ms_jiffies_conv(bool *negp, unsigned long *lvalp,
1204	int *valp,
1205	int write, void *data)
1206	{
1207	if (write) {
1208	unsigned long jif = msecs_to_jiffies(m: *negp ? -*lvalp : *lvalp);
1209
1210	if (jif > INT_MAX)
1211	return 1;
1212	WRITE_ONCE(*valp, (int)jif);
1213	} else {
1214	int val = READ_ONCE(*valp);
1215	unsigned long lval;
1216	if (val < 0) {
1217	*negp = true;
1218	lval = -(unsigned long)val;
1219	} else {
1220	*negp = false;
1221	lval = (unsigned long)val;
1222	}
1223	*lvalp = jiffies_to_msecs(j: lval);
1224	}
1225	return 0;
1226	}
1227
1228	static int do_proc_dointvec_ms_jiffies_minmax_conv(bool *negp, unsigned long *lvalp,
1229	int *valp, int write, void *data)
1230	{
1231	int tmp, ret;
1232	struct do_proc_dointvec_minmax_conv_param *param = data;
1233	/*
1234	* If writing, first do so via a temporary local int so we can
1235	* bounds-check it before touching *valp.
1236	*/
1237	int *ip = write ? &tmp : valp;
1238
1239	ret = do_proc_dointvec_ms_jiffies_conv(negp, lvalp, valp: ip, write, data);
1240	if (ret)
1241	return ret;
1242
1243	if (write) {
1244	if ((param->min && *param->min > tmp) ||
1245	(param->max && *param->max < tmp))
1246	return -EINVAL;
1247	*valp = tmp;
1248	}
1249	return 0;
1250	}
1251
1252	/**
1253	* proc_dointvec_jiffies - read a vector of integers as seconds
1254	* @table: the sysctl table
1255	* @write: %TRUE if this is a write to the sysctl file
1256	* @buffer: the user buffer
1257	* @lenp: the size of the user buffer
1258	* @ppos: file position
1259	*
1260	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1261	* values from/to the user buffer, treated as an ASCII string.
1262	* The values read are assumed to be in seconds, and are converted into
1263	* jiffies.
1264	*
1265	* Returns 0 on success.
1266	*/
1267	int proc_dointvec_jiffies(struct ctl_table *table, int write,
1268	void *buffer, size_t *lenp, loff_t *ppos)
1269	{
1270	return do_proc_dointvec(table,write,buffer,lenp,ppos,
1271	conv: do_proc_dointvec_jiffies_conv,NULL);
1272	}
1273
1274	int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1275	void *buffer, size_t *lenp, loff_t *ppos)
1276	{
1277	struct do_proc_dointvec_minmax_conv_param param = {
1278	.min = (int *) table->extra1,
1279	.max = (int *) table->extra2,
1280	};
1281	return do_proc_dointvec(table, write, buffer, lenp, ppos,
1282	conv: do_proc_dointvec_ms_jiffies_minmax_conv, data: &param);
1283	}
1284
1285	/**
1286	* proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
1287	* @table: the sysctl table
1288	* @write: %TRUE if this is a write to the sysctl file
1289	* @buffer: the user buffer
1290	* @lenp: the size of the user buffer
1291	* @ppos: pointer to the file position
1292	*
1293	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1294	* values from/to the user buffer, treated as an ASCII string.
1295	* The values read are assumed to be in 1/USER_HZ seconds, and
1296	* are converted into jiffies.
1297	*
1298	* Returns 0 on success.
1299	*/
1300	int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1301	void *buffer, size_t *lenp, loff_t *ppos)
1302	{
1303	return do_proc_dointvec(table, write, buffer, lenp, ppos,
1304	conv: do_proc_dointvec_userhz_jiffies_conv, NULL);
1305	}
1306
1307	/**
1308	* proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
1309	* @table: the sysctl table
1310	* @write: %TRUE if this is a write to the sysctl file
1311	* @buffer: the user buffer
1312	* @lenp: the size of the user buffer
1313	* @ppos: file position
1314	* @ppos: the current position in the file
1315	*
1316	* Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1317	* values from/to the user buffer, treated as an ASCII string.
1318	* The values read are assumed to be in 1/1000 seconds, and
1319	* are converted into jiffies.
1320	*
1321	* Returns 0 on success.
1322	*/
1323	int proc_dointvec_ms_jiffies(struct ctl_table *table, int write, void *buffer,
1324	size_t *lenp, loff_t *ppos)
1325	{
1326	return do_proc_dointvec(table, write, buffer, lenp, ppos,
1327	conv: do_proc_dointvec_ms_jiffies_conv, NULL);
1328	}
1329
1330	static int proc_do_cad_pid(struct ctl_table *table, int write, void *buffer,
1331	size_t *lenp, loff_t *ppos)
1332	{
1333	struct pid *new_pid;
1334	pid_t tmp;
1335	int r;
1336
1337	tmp = pid_vnr(pid: cad_pid);
1338
1339	r = __do_proc_dointvec(tbl_data: &tmp, table, write, buffer,
1340	lenp, ppos, NULL, NULL);
1341	if (r || !write)
1342	return r;
1343
1344	new_pid = find_get_pid(nr: tmp);
1345	if (!new_pid)
1346	return -ESRCH;
1347
1348	put_pid(xchg(&cad_pid, new_pid));
1349	return 0;
1350	}
1351
1352	/**
1353	* proc_do_large_bitmap - read/write from/to a large bitmap
1354	* @table: the sysctl table
1355	* @write: %TRUE if this is a write to the sysctl file
1356	* @buffer: the user buffer
1357	* @lenp: the size of the user buffer
1358	* @ppos: file position
1359	*
1360	* The bitmap is stored at table->data and the bitmap length (in bits)
1361	* in table->maxlen.
1362	*
1363	* We use a range comma separated format (e.g. 1,3-4,10-10) so that
1364	* large bitmaps may be represented in a compact manner. Writing into
1365	* the file will clear the bitmap then update it with the given input.
1366	*
1367	* Returns 0 on success.
1368	*/
1369	int proc_do_large_bitmap(struct ctl_table *table, int write,
1370	void *buffer, size_t *lenp, loff_t *ppos)
1371	{
1372	int err = 0;
1373	size_t left = *lenp;
1374	unsigned long bitmap_len = table->maxlen;
1375	unsigned long *bitmap = *(unsigned long **) table->data;
1376	unsigned long *tmp_bitmap = NULL;
1377	char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
1378
1379	if (!bitmap || !bitmap_len || !left || (*ppos && !write)) {
1380	*lenp = 0;
1381	return 0;
1382	}
1383
1384	if (write) {
1385	char *p = buffer;
1386	size_t skipped = 0;
1387
1388	if (left > PAGE_SIZE - 1) {
1389	left = PAGE_SIZE - 1;
1390	/* How much of the buffer we'll skip this pass */
1391	skipped = *lenp - left;
1392	}
1393
1394	tmp_bitmap = bitmap_zalloc(nbits: bitmap_len, GFP_KERNEL);
1395	if (!tmp_bitmap)
1396	return -ENOMEM;
1397	proc_skip_char(buf: &p, size: &left, v: '\n');
1398	while (!err && left) {
1399	unsigned long val_a, val_b;
1400	bool neg;
1401	size_t saved_left;
1402
1403	/* In case we stop parsing mid-number, we can reset */
1404	saved_left = left;
1405	err = proc_get_long(buf: &p, size: &left, val: &val_a, neg: &neg, perm_tr: tr_a,
1406	perm_tr_len: sizeof(tr_a), tr: &c);
1407	/*
1408	* If we consumed the entirety of a truncated buffer or
1409	* only one char is left (may be a "-"), then stop here,
1410	* reset, & come back for more.
1411	*/
1412	if ((left <= 1) && skipped) {
1413	left = saved_left;
1414	break;
1415	}
1416
1417	if (err)
1418	break;
1419	if (val_a >= bitmap_len || neg) {
1420	err = -EINVAL;
1421	break;
1422	}
1423
1424	val_b = val_a;
1425	if (left) {
1426	p++;
1427	left--;
1428	}
1429
1430	if (c == '-') {
1431	err = proc_get_long(buf: &p, size: &left, val: &val_b,
1432	neg: &neg, perm_tr: tr_b, perm_tr_len: sizeof(tr_b),
1433	tr: &c);
1434	/*
1435	* If we consumed all of a truncated buffer or
1436	* then stop here, reset, & come back for more.
1437	*/
1438	if (!left && skipped) {
1439	left = saved_left;
1440	break;
1441	}
1442
1443	if (err)
1444	break;
1445	if (val_b >= bitmap_len || neg ||
1446	val_a > val_b) {
1447	err = -EINVAL;
1448	break;
1449	}
1450	if (left) {
1451	p++;
1452	left--;
1453	}
1454	}
1455
1456	bitmap_set(map: tmp_bitmap, start: val_a, nbits: val_b - val_a + 1);
1457	proc_skip_char(buf: &p, size: &left, v: '\n');
1458	}
1459	left += skipped;
1460	} else {
1461	unsigned long bit_a, bit_b = 0;
1462	bool first = 1;
1463
1464	while (left) {
1465	bit_a = find_next_bit(addr: bitmap, size: bitmap_len, offset: bit_b);
1466	if (bit_a >= bitmap_len)
1467	break;
1468	bit_b = find_next_zero_bit(addr: bitmap, size: bitmap_len,
1469	offset: bit_a + 1) - 1;
1470
1471	if (!first)
1472	proc_put_char(buf: &buffer, size: &left, c: ',');
1473	proc_put_long(buf: &buffer, size: &left, val: bit_a, neg: false);
1474	if (bit_a != bit_b) {
1475	proc_put_char(buf: &buffer, size: &left, c: '-');
1476	proc_put_long(buf: &buffer, size: &left, val: bit_b, neg: false);
1477	}
1478
1479	first = 0; bit_b++;
1480	}
1481	proc_put_char(buf: &buffer, size: &left, c: '\n');
1482	}
1483
1484	if (!err) {
1485	if (write) {
1486	if (*ppos)
1487	bitmap_or(dst: bitmap, src1: bitmap, src2: tmp_bitmap, nbits: bitmap_len);
1488	else
1489	bitmap_copy(dst: bitmap, src: tmp_bitmap, nbits: bitmap_len);
1490	}
1491	*lenp -= left;
1492	*ppos += *lenp;
1493	}
1494
1495	bitmap_free(bitmap: tmp_bitmap);
1496	return err;
1497	}
1498
1499	#else /* CONFIG_PROC_SYSCTL */
1500
1501	int proc_dostring(struct ctl_table *table, int write,
1502	void *buffer, size_t *lenp, loff_t *ppos)
1503	{
1504	return -ENOSYS;
1505	}
1506
1507	int proc_dobool(struct ctl_table *table, int write,
1508	void *buffer, size_t *lenp, loff_t *ppos)
1509	{
1510	return -ENOSYS;
1511	}
1512
1513	int proc_dointvec(struct ctl_table *table, int write,
1514	void *buffer, size_t *lenp, loff_t *ppos)
1515	{
1516	return -ENOSYS;
1517	}
1518
1519	int proc_douintvec(struct ctl_table *table, int write,
1520	void *buffer, size_t *lenp, loff_t *ppos)
1521	{
1522	return -ENOSYS;
1523	}
1524
1525	int proc_dointvec_minmax(struct ctl_table *table, int write,
1526	void *buffer, size_t *lenp, loff_t *ppos)
1527	{
1528	return -ENOSYS;
1529	}
1530
1531	int proc_douintvec_minmax(struct ctl_table *table, int write,
1532	void *buffer, size_t *lenp, loff_t *ppos)
1533	{
1534	return -ENOSYS;
1535	}
1536
1537	int proc_dou8vec_minmax(struct ctl_table *table, int write,
1538	void *buffer, size_t *lenp, loff_t *ppos)
1539	{
1540	return -ENOSYS;
1541	}
1542
1543	int proc_dointvec_jiffies(struct ctl_table *table, int write,
1544	void *buffer, size_t *lenp, loff_t *ppos)
1545	{
1546	return -ENOSYS;
1547	}
1548
1549	int proc_dointvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1550	void *buffer, size_t *lenp, loff_t *ppos)
1551	{
1552	return -ENOSYS;
1553	}
1554
1555	int proc_dointvec_userhz_jiffies(struct ctl_table *table, int write,
1556	void *buffer, size_t *lenp, loff_t *ppos)
1557	{
1558	return -ENOSYS;
1559	}
1560
1561	int proc_dointvec_ms_jiffies(struct ctl_table *table, int write,
1562	void *buffer, size_t *lenp, loff_t *ppos)
1563	{
1564	return -ENOSYS;
1565	}
1566
1567	int proc_doulongvec_minmax(struct ctl_table *table, int write,
1568	void *buffer, size_t *lenp, loff_t *ppos)
1569	{
1570	return -ENOSYS;
1571	}
1572
1573	int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int write,
1574	void *buffer, size_t *lenp, loff_t *ppos)
1575	{
1576	return -ENOSYS;
1577	}
1578
1579	int proc_do_large_bitmap(struct ctl_table *table, int write,
1580	void *buffer, size_t *lenp, loff_t *ppos)
1581	{
1582	return -ENOSYS;
1583	}
1584
1585	#endif /* CONFIG_PROC_SYSCTL */
1586
1587	#if defined(CONFIG_SYSCTL)
1588	int proc_do_static_key(struct ctl_table *table, int write,
1589	void *buffer, size_t *lenp, loff_t *ppos)
1590	{
1591	struct static_key *key = (struct static_key *)table->data;
1592	static DEFINE_MUTEX(static_key_mutex);
1593	int val, ret;
1594	struct ctl_table tmp = {
1595	.data = &val,
1596	.maxlen = sizeof(val),
1597	.mode = table->mode,
1598	.extra1 = SYSCTL_ZERO,
1599	.extra2 = SYSCTL_ONE,
1600	};
1601
1602	if (write && !capable(CAP_SYS_ADMIN))
1603	return -EPERM;
1604
1605	mutex_lock(&static_key_mutex);
1606	val = static_key_enabled(key);
1607	ret = proc_dointvec_minmax(table: &tmp, write, buffer, lenp, ppos);
1608	if (write && !ret) {
1609	if (val)
1610	static_key_enable(key);
1611	else
1612	static_key_disable(key);
1613	}
1614	mutex_unlock(lock: &static_key_mutex);
1615	return ret;
1616	}
1617
1618	static struct ctl_table kern_table[] = {
1619	{
1620	.procname = "panic",
1621	.data = &panic_timeout,
1622	.maxlen = sizeof(int),
1623	.mode = 0644,
1624	.proc_handler = proc_dointvec,
1625	},
1626	#ifdef CONFIG_PROC_SYSCTL
1627	{
1628	.procname = "tainted",
1629	.maxlen = sizeof(long),
1630	.mode = 0644,
1631	.proc_handler = proc_taint,
1632	},
1633	{
1634	.procname = "sysctl_writes_strict",
1635	.data = &sysctl_writes_strict,
1636	.maxlen = sizeof(int),
1637	.mode = 0644,
1638	.proc_handler = proc_dointvec_minmax,
1639	.extra1 = SYSCTL_NEG_ONE,
1640	.extra2 = SYSCTL_ONE,
1641	},
1642	#endif
1643	{
1644	.procname = "print-fatal-signals",
1645	.data = &print_fatal_signals,
1646	.maxlen = sizeof(int),
1647	.mode = 0644,
1648	.proc_handler = proc_dointvec,
1649	},
1650	#ifdef CONFIG_SPARC
1651	{
1652	.procname = "reboot-cmd",
1653	.data = reboot_command,
1654	.maxlen = 256,
1655	.mode = 0644,
1656	.proc_handler = proc_dostring,
1657	},
1658	{
1659	.procname = "stop-a",
1660	.data = &stop_a_enabled,
1661	.maxlen = sizeof (int),
1662	.mode = 0644,
1663	.proc_handler = proc_dointvec,
1664	},
1665	{
1666	.procname = "scons-poweroff",
1667	.data = &scons_pwroff,
1668	.maxlen = sizeof (int),
1669	.mode = 0644,
1670	.proc_handler = proc_dointvec,
1671	},
1672	#endif
1673	#ifdef CONFIG_SPARC64
1674	{
1675	.procname = "tsb-ratio",
1676	.data = &sysctl_tsb_ratio,
1677	.maxlen = sizeof (int),
1678	.mode = 0644,
1679	.proc_handler = proc_dointvec,
1680	},
1681	#endif
1682	#ifdef CONFIG_PARISC
1683	{
1684	.procname = "soft-power",
1685	.data = &pwrsw_enabled,
1686	.maxlen = sizeof (int),
1687	.mode = 0644,
1688	.proc_handler = proc_dointvec,
1689	},
1690	#endif
1691	#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1692	{
1693	.procname = "unaligned-trap",
1694	.data = &unaligned_enabled,
1695	.maxlen = sizeof (int),
1696	.mode = 0644,
1697	.proc_handler = proc_dointvec,
1698	},
1699	#endif
1700	#ifdef CONFIG_STACK_TRACER
1701	{
1702	.procname = "stack_tracer_enabled",
1703	.data = &stack_tracer_enabled,
1704	.maxlen = sizeof(int),
1705	.mode = 0644,
1706	.proc_handler = stack_trace_sysctl,
1707	},
1708	#endif
1709	#ifdef CONFIG_TRACING
1710	{
1711	.procname = "ftrace_dump_on_oops",
1712	.data = &ftrace_dump_on_oops,
1713	.maxlen = sizeof(int),
1714	.mode = 0644,
1715	.proc_handler = proc_dointvec,
1716	},
1717	{
1718	.procname = "traceoff_on_warning",
1719	.data = &__disable_trace_on_warning,
1720	.maxlen = sizeof(__disable_trace_on_warning),
1721	.mode = 0644,
1722	.proc_handler = proc_dointvec,
1723	},
1724	{
1725	.procname = "tracepoint_printk",
1726	.data = &tracepoint_printk,
1727	.maxlen = sizeof(tracepoint_printk),
1728	.mode = 0644,
1729	.proc_handler = tracepoint_printk_sysctl,
1730	},
1731	#endif
1732	#ifdef CONFIG_MODULES
1733	{
1734	.procname = "modprobe",
1735	.data = &modprobe_path,
1736	.maxlen = KMOD_PATH_LEN,
1737	.mode = 0644,
1738	.proc_handler = proc_dostring,
1739	},
1740	{
1741	.procname = "modules_disabled",
1742	.data = &modules_disabled,
1743	.maxlen = sizeof(int),
1744	.mode = 0644,
1745	/* only handle a transition from default "0" to "1" */
1746	.proc_handler = proc_dointvec_minmax,
1747	.extra1 = SYSCTL_ONE,
1748	.extra2 = SYSCTL_ONE,
1749	},
1750	#endif
1751	#ifdef CONFIG_UEVENT_HELPER
1752	{
1753	.procname = "hotplug",
1754	.data = &uevent_helper,
1755	.maxlen = UEVENT_HELPER_PATH_LEN,
1756	.mode = 0644,
1757	.proc_handler = proc_dostring,
1758	},
1759	#endif
1760	#ifdef CONFIG_MAGIC_SYSRQ
1761	{
1762	.procname = "sysrq",
1763	.data = NULL,
1764	.maxlen = sizeof (int),
1765	.mode = 0644,
1766	.proc_handler = sysrq_sysctl_handler,
1767	},
1768	#endif
1769	#ifdef CONFIG_PROC_SYSCTL
1770	{
1771	.procname = "cad_pid",
1772	.data = NULL,
1773	.maxlen = sizeof (int),
1774	.mode = 0600,
1775	.proc_handler = proc_do_cad_pid,
1776	},
1777	#endif
1778	{
1779	.procname = "threads-max",
1780	.data = NULL,
1781	.maxlen = sizeof(int),
1782	.mode = 0644,
1783	.proc_handler = sysctl_max_threads,
1784	},
1785	{
1786	.procname = "overflowuid",
1787	.data = &overflowuid,
1788	.maxlen = sizeof(int),
1789	.mode = 0644,
1790	.proc_handler = proc_dointvec_minmax,
1791	.extra1 = SYSCTL_ZERO,
1792	.extra2 = SYSCTL_MAXOLDUID,
1793	},
1794	{
1795	.procname = "overflowgid",
1796	.data = &overflowgid,
1797	.maxlen = sizeof(int),
1798	.mode = 0644,
1799	.proc_handler = proc_dointvec_minmax,
1800	.extra1 = SYSCTL_ZERO,
1801	.extra2 = SYSCTL_MAXOLDUID,
1802	},
1803	#ifdef CONFIG_S390
1804	{
1805	.procname = "userprocess_debug",
1806	.data = &show_unhandled_signals,
1807	.maxlen = sizeof(int),
1808	.mode = 0644,
1809	.proc_handler = proc_dointvec,
1810	},
1811	#endif
1812	{
1813	.procname = "pid_max",
1814	.data = &pid_max,
1815	.maxlen = sizeof (int),
1816	.mode = 0644,
1817	.proc_handler = proc_dointvec_minmax,
1818	.extra1 = &pid_max_min,
1819	.extra2 = &pid_max_max,
1820	},
1821	{
1822	.procname = "panic_on_oops",
1823	.data = &panic_on_oops,
1824	.maxlen = sizeof(int),
1825	.mode = 0644,
1826	.proc_handler = proc_dointvec,
1827	},
1828	{
1829	.procname = "panic_print",
1830	.data = &panic_print,
1831	.maxlen = sizeof(unsigned long),
1832	.mode = 0644,
1833	.proc_handler = proc_doulongvec_minmax,
1834	},
1835	{
1836	.procname = "ngroups_max",
1837	.data = (void *)&ngroups_max,
1838	.maxlen = sizeof (int),
1839	.mode = 0444,
1840	.proc_handler = proc_dointvec,
1841	},
1842	{
1843	.procname = "cap_last_cap",
1844	.data = (void *)&cap_last_cap,
1845	.maxlen = sizeof(int),
1846	.mode = 0444,
1847	.proc_handler = proc_dointvec,
1848	},
1849	#if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86)
1850	{
1851	.procname = "unknown_nmi_panic",
1852	.data = &unknown_nmi_panic,
1853	.maxlen = sizeof (int),
1854	.mode = 0644,
1855	.proc_handler = proc_dointvec,
1856	},
1857	#endif
1858
1859	#if (defined(CONFIG_X86_32) || defined(CONFIG_PARISC)) && \
1860	defined(CONFIG_DEBUG_STACKOVERFLOW)
1861	{
1862	.procname = "panic_on_stackoverflow",
1863	.data = &sysctl_panic_on_stackoverflow,
1864	.maxlen = sizeof(int),
1865	.mode = 0644,
1866	.proc_handler = proc_dointvec,
1867	},
1868	#endif
1869	#if defined(CONFIG_X86)
1870	{
1871	.procname = "panic_on_unrecovered_nmi",
1872	.data = &panic_on_unrecovered_nmi,
1873	.maxlen = sizeof(int),
1874	.mode = 0644,
1875	.proc_handler = proc_dointvec,
1876	},
1877	{
1878	.procname = "panic_on_io_nmi",
1879	.data = &panic_on_io_nmi,
1880	.maxlen = sizeof(int),
1881	.mode = 0644,
1882	.proc_handler = proc_dointvec,
1883	},
1884	{
1885	.procname = "bootloader_type",
1886	.data = &bootloader_type,
1887	.maxlen = sizeof (int),
1888	.mode = 0444,
1889	.proc_handler = proc_dointvec,
1890	},
1891	{
1892	.procname = "bootloader_version",
1893	.data = &bootloader_version,
1894	.maxlen = sizeof (int),
1895	.mode = 0444,
1896	.proc_handler = proc_dointvec,
1897	},
1898	{
1899	.procname = "io_delay_type",
1900	.data = &io_delay_type,
1901	.maxlen = sizeof(int),
1902	.mode = 0644,
1903	.proc_handler = proc_dointvec,
1904	},
1905	#endif
1906	#if defined(CONFIG_MMU)
1907	{
1908	.procname = "randomize_va_space",
1909	.data = &randomize_va_space,
1910	.maxlen = sizeof(int),
1911	.mode = 0644,
1912	.proc_handler = proc_dointvec,
1913	},
1914	#endif
1915	#if defined(CONFIG_S390) && defined(CONFIG_SMP)
1916	{
1917	.procname = "spin_retry",
1918	.data = &spin_retry,
1919	.maxlen = sizeof (int),
1920	.mode = 0644,
1921	.proc_handler = proc_dointvec,
1922	},
1923	#endif
1924	#if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86)
1925	{
1926	.procname = "acpi_video_flags",
1927	.data = &acpi_realmode_flags,
1928	.maxlen = sizeof (unsigned long),
1929	.mode = 0644,
1930	.proc_handler = proc_doulongvec_minmax,
1931	},
1932	#endif
1933	#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1934	{
1935	.procname = "ignore-unaligned-usertrap",
1936	.data = &no_unaligned_warning,
1937	.maxlen = sizeof (int),
1938	.mode = 0644,
1939	.proc_handler = proc_dointvec,
1940	},
1941	#endif
1942	#ifdef CONFIG_RT_MUTEXES
1943	{
1944	.procname = "max_lock_depth",
1945	.data = &max_lock_depth,
1946	.maxlen = sizeof(int),
1947	.mode = 0644,
1948	.proc_handler = proc_dointvec,
1949	},
1950	#endif
1951	#ifdef CONFIG_PERF_EVENTS
1952	/*
1953	* User-space scripts rely on the existence of this file
1954	* as a feature check for perf_events being enabled.
1955	*
1956	* So it's an ABI, do not remove!
1957	*/
1958	{
1959	.procname = "perf_event_paranoid",
1960	.data = &sysctl_perf_event_paranoid,
1961	.maxlen = sizeof(sysctl_perf_event_paranoid),
1962	.mode = 0644,
1963	.proc_handler = proc_dointvec,
1964	},
1965	{
1966	.procname = "perf_event_mlock_kb",
1967	.data = &sysctl_perf_event_mlock,
1968	.maxlen = sizeof(sysctl_perf_event_mlock),
1969	.mode = 0644,
1970	.proc_handler = proc_dointvec,
1971	},
1972	{
1973	.procname = "perf_event_max_sample_rate",
1974	.data = &sysctl_perf_event_sample_rate,
1975	.maxlen = sizeof(sysctl_perf_event_sample_rate),
1976	.mode = 0644,
1977	.proc_handler = perf_event_max_sample_rate_handler,
1978	.extra1 = SYSCTL_ONE,
1979	},
1980	{
1981	.procname = "perf_cpu_time_max_percent",
1982	.data = &sysctl_perf_cpu_time_max_percent,
1983	.maxlen = sizeof(sysctl_perf_cpu_time_max_percent),
1984	.mode = 0644,
1985	.proc_handler = perf_cpu_time_max_percent_handler,
1986	.extra1 = SYSCTL_ZERO,
1987	.extra2 = SYSCTL_ONE_HUNDRED,
1988	},
1989	{
1990	.procname = "perf_event_max_stack",
1991	.data = &sysctl_perf_event_max_stack,
1992	.maxlen = sizeof(sysctl_perf_event_max_stack),
1993	.mode = 0644,
1994	.proc_handler = perf_event_max_stack_handler,
1995	.extra1 = SYSCTL_ZERO,
1996	.extra2 = (void *)&six_hundred_forty_kb,
1997	},
1998	{
1999	.procname = "perf_event_max_contexts_per_stack",
2000	.data = &sysctl_perf_event_max_contexts_per_stack,
2001	.maxlen = sizeof(sysctl_perf_event_max_contexts_per_stack),
2002	.mode = 0644,
2003	.proc_handler = perf_event_max_stack_handler,
2004	.extra1 = SYSCTL_ZERO,
2005	.extra2 = SYSCTL_ONE_THOUSAND,
2006	},
2007	#endif
2008	{
2009	.procname = "panic_on_warn",
2010	.data = &panic_on_warn,
2011	.maxlen = sizeof(int),
2012	.mode = 0644,
2013	.proc_handler = proc_dointvec_minmax,
2014	.extra1 = SYSCTL_ZERO,
2015	.extra2 = SYSCTL_ONE,
2016	},
2017	#ifdef CONFIG_TREE_RCU
2018	{
2019	.procname = "panic_on_rcu_stall",
2020	.data = &sysctl_panic_on_rcu_stall,
2021	.maxlen = sizeof(sysctl_panic_on_rcu_stall),
2022	.mode = 0644,
2023	.proc_handler = proc_dointvec_minmax,
2024	.extra1 = SYSCTL_ZERO,
2025	.extra2 = SYSCTL_ONE,
2026	},
2027	{
2028	.procname = "max_rcu_stall_to_panic",
2029	.data = &sysctl_max_rcu_stall_to_panic,
2030	.maxlen = sizeof(sysctl_max_rcu_stall_to_panic),
2031	.mode = 0644,
2032	.proc_handler = proc_dointvec_minmax,
2033	.extra1 = SYSCTL_ONE,
2034	.extra2 = SYSCTL_INT_MAX,
2035	},
2036	#endif
2037	{ }
2038	};
2039
2040	static struct ctl_table vm_table[] = {
2041	{
2042	.procname = "overcommit_memory",
2043	.data = &sysctl_overcommit_memory,
2044	.maxlen = sizeof(sysctl_overcommit_memory),
2045	.mode = 0644,
2046	.proc_handler = overcommit_policy_handler,
2047	.extra1 = SYSCTL_ZERO,
2048	.extra2 = SYSCTL_TWO,
2049	},
2050	{
2051	.procname = "overcommit_ratio",
2052	.data = &sysctl_overcommit_ratio,
2053	.maxlen = sizeof(sysctl_overcommit_ratio),
2054	.mode = 0644,
2055	.proc_handler = overcommit_ratio_handler,
2056	},
2057	{
2058	.procname = "overcommit_kbytes",
2059	.data = &sysctl_overcommit_kbytes,
2060	.maxlen = sizeof(sysctl_overcommit_kbytes),
2061	.mode = 0644,
2062	.proc_handler = overcommit_kbytes_handler,
2063	},
2064	{
2065	.procname = "page-cluster",
2066	.data = &page_cluster,
2067	.maxlen = sizeof(int),
2068	.mode = 0644,
2069	.proc_handler = proc_dointvec_minmax,
2070	.extra1 = SYSCTL_ZERO,
2071	.extra2 = (void *)&page_cluster_max,
2072	},
2073	{
2074	.procname = "dirtytime_expire_seconds",
2075	.data = &dirtytime_expire_interval,
2076	.maxlen = sizeof(dirtytime_expire_interval),
2077	.mode = 0644,
2078	.proc_handler = dirtytime_interval_handler,
2079	.extra1 = SYSCTL_ZERO,
2080	},
2081	{
2082	.procname = "swappiness",
2083	.data = &vm_swappiness,
2084	.maxlen = sizeof(vm_swappiness),
2085	.mode = 0644,
2086	.proc_handler = proc_dointvec_minmax,
2087	.extra1 = SYSCTL_ZERO,
2088	.extra2 = SYSCTL_TWO_HUNDRED,
2089	},
2090	#ifdef CONFIG_NUMA
2091	{
2092	.procname = "numa_stat",
2093	.data = &sysctl_vm_numa_stat,
2094	.maxlen = sizeof(int),
2095	.mode = 0644,
2096	.proc_handler = sysctl_vm_numa_stat_handler,
2097	.extra1 = SYSCTL_ZERO,
2098	.extra2 = SYSCTL_ONE,
2099	},
2100	#endif
2101	{
2102	.procname = "drop_caches",
2103	.data = &sysctl_drop_caches,
2104	.maxlen = sizeof(int),
2105	.mode = 0200,
2106	.proc_handler = drop_caches_sysctl_handler,
2107	.extra1 = SYSCTL_ONE,
2108	.extra2 = SYSCTL_FOUR,
2109	},
2110	{
2111	.procname = "page_lock_unfairness",
2112	.data = &sysctl_page_lock_unfairness,
2113	.maxlen = sizeof(sysctl_page_lock_unfairness),
2114	.mode = 0644,
2115	.proc_handler = proc_dointvec_minmax,
2116	.extra1 = SYSCTL_ZERO,
2117	},
2118	#ifdef CONFIG_MMU
2119	{
2120	.procname = "max_map_count",
2121	.data = &sysctl_max_map_count,
2122	.maxlen = sizeof(sysctl_max_map_count),
2123	.mode = 0644,
2124	.proc_handler = proc_dointvec_minmax,
2125	.extra1 = SYSCTL_ZERO,
2126	},
2127	#else
2128	{
2129	.procname = "nr_trim_pages",
2130	.data = &sysctl_nr_trim_pages,
2131	.maxlen = sizeof(sysctl_nr_trim_pages),
2132	.mode = 0644,
2133	.proc_handler = proc_dointvec_minmax,
2134	.extra1 = SYSCTL_ZERO,
2135	},
2136	#endif
2137	{
2138	.procname = "vfs_cache_pressure",
2139	.data = &sysctl_vfs_cache_pressure,
2140	.maxlen = sizeof(sysctl_vfs_cache_pressure),
2141	.mode = 0644,
2142	.proc_handler = proc_dointvec_minmax,
2143	.extra1 = SYSCTL_ZERO,
2144	},
2145	#if defined(HAVE_ARCH_PICK_MMAP_LAYOUT) || \
2146	defined(CONFIG_ARCH_WANT_DEFAULT_TOPDOWN_MMAP_LAYOUT)
2147	{
2148	.procname = "legacy_va_layout",
2149	.data = &sysctl_legacy_va_layout,
2150	.maxlen = sizeof(sysctl_legacy_va_layout),
2151	.mode = 0644,
2152	.proc_handler = proc_dointvec_minmax,
2153	.extra1 = SYSCTL_ZERO,
2154	},
2155	#endif
2156	#ifdef CONFIG_NUMA
2157	{
2158	.procname = "zone_reclaim_mode",
2159	.data = &node_reclaim_mode,
2160	.maxlen = sizeof(node_reclaim_mode),
2161	.mode = 0644,
2162	.proc_handler = proc_dointvec_minmax,
2163	.extra1 = SYSCTL_ZERO,
2164	},
2165	#endif
2166	#ifdef CONFIG_SMP
2167	{
2168	.procname = "stat_interval",
2169	.data = &sysctl_stat_interval,
2170	.maxlen = sizeof(sysctl_stat_interval),
2171	.mode = 0644,
2172	.proc_handler = proc_dointvec_jiffies,
2173	},
2174	{
2175	.procname = "stat_refresh",
2176	.data = NULL,
2177	.maxlen = 0,
2178	.mode = 0600,
2179	.proc_handler = vmstat_refresh,
2180	},
2181	#endif
2182	#ifdef CONFIG_MMU
2183	{
2184	.procname = "mmap_min_addr",
2185	.data = &dac_mmap_min_addr,
2186	.maxlen = sizeof(unsigned long),
2187	.mode = 0644,
2188	.proc_handler = mmap_min_addr_handler,
2189	},
2190	#endif
2191	#if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))|| \
2192	(defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL))
2193	{
2194	.procname = "vdso_enabled",
2195	#ifdef CONFIG_X86_32
2196	.data = &vdso32_enabled,
2197	.maxlen = sizeof(vdso32_enabled),
2198	#else
2199	.data = &vdso_enabled,
2200	.maxlen = sizeof(vdso_enabled),
2201	#endif
2202	.mode = 0644,
2203	.proc_handler = proc_dointvec,
2204	.extra1 = SYSCTL_ZERO,
2205	},
2206	#endif
2207	{
2208	.procname = "user_reserve_kbytes",
2209	.data = &sysctl_user_reserve_kbytes,
2210	.maxlen = sizeof(sysctl_user_reserve_kbytes),
2211	.mode = 0644,
2212	.proc_handler = proc_doulongvec_minmax,
2213	},
2214	{
2215	.procname = "admin_reserve_kbytes",
2216	.data = &sysctl_admin_reserve_kbytes,
2217	.maxlen = sizeof(sysctl_admin_reserve_kbytes),
2218	.mode = 0644,
2219	.proc_handler = proc_doulongvec_minmax,
2220	},
2221	#ifdef CONFIG_HAVE_ARCH_MMAP_RND_BITS
2222	{
2223	.procname = "mmap_rnd_bits",
2224	.data = &mmap_rnd_bits,
2225	.maxlen = sizeof(mmap_rnd_bits),
2226	.mode = 0600,
2227	.proc_handler = proc_dointvec_minmax,
2228	.extra1 = (void *)&mmap_rnd_bits_min,
2229	.extra2 = (void *)&mmap_rnd_bits_max,
2230	},
2231	#endif
2232	#ifdef CONFIG_HAVE_ARCH_MMAP_RND_COMPAT_BITS
2233	{
2234	.procname = "mmap_rnd_compat_bits",
2235	.data = &mmap_rnd_compat_bits,
2236	.maxlen = sizeof(mmap_rnd_compat_bits),
2237	.mode = 0600,
2238	.proc_handler = proc_dointvec_minmax,
2239	.extra1 = (void *)&mmap_rnd_compat_bits_min,
2240	.extra2 = (void *)&mmap_rnd_compat_bits_max,
2241	},
2242	#endif
2243	{ }
2244	};
2245
2246	int __init sysctl_init_bases(void)
2247	{
2248	register_sysctl_init("kernel", kern_table);
2249	register_sysctl_init("vm", vm_table);
2250
2251	return 0;
2252	}
2253	#endif /* CONFIG_SYSCTL */
2254	/*
2255	* No sense putting this after each symbol definition, twice,
2256	* exception granted :-)
2257	*/
2258	EXPORT_SYMBOL(proc_dobool);
2259	EXPORT_SYMBOL(proc_dointvec);
2260	EXPORT_SYMBOL(proc_douintvec);
2261	EXPORT_SYMBOL(proc_dointvec_jiffies);
2262	EXPORT_SYMBOL(proc_dointvec_minmax);
2263	EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
2264	EXPORT_SYMBOL(proc_dointvec_userhz_jiffies);
2265	EXPORT_SYMBOL(proc_dointvec_ms_jiffies);
2266	EXPORT_SYMBOL(proc_dostring);
2267	EXPORT_SYMBOL(proc_doulongvec_minmax);
2268	EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
2269	EXPORT_SYMBOL(proc_do_large_bitmap);
2270