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