projects/linux·blob v6.19-rc6 · refs

1188 lines · 28.7 KiB

1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * sysctl.c: General linux system control interface
4 */
5
6#include <linux/sysctl.h>
7#include <linux/bitmap.h>
8#include <linux/proc_fs.h>
9#include <linux/ctype.h>
10#include <linux/init.h>
11#include <linux/kernel.h>
12#include <linux/kobject.h>
13#include <linux/highuid.h>
14#include <linux/writeback.h>
15#include <linux/initrd.h>
16#include <linux/limits.h>
17#include <linux/syscalls.h>
18#include <linux/capability.h>
19
20#include "../lib/kstrtox.h"
21
22#include <linux/uaccess.h>
23#include <asm/processor.h>
24
25/* shared constants to be used in various sysctls */
26const int sysctl_vals[] = { 0, 1, 2, 3, 4, 100, 200, 1000, 3000, INT_MAX, 65535, -1 };
27EXPORT_SYMBOL(sysctl_vals);
28
29const unsigned long sysctl_long_vals[] = { 0, 1, LONG_MAX };
30EXPORT_SYMBOL_GPL(sysctl_long_vals);
31
32#if defined(CONFIG_SYSCTL)
33
34/* Constants used for minimum and maximum */
35static const int ngroups_max = NGROUPS_MAX;
36static const int cap_last_cap = CAP_LAST_CAP;
37
38#ifdef CONFIG_PROC_SYSCTL
39
40/**
41 * enum sysctl_writes_mode - supported sysctl write modes
42 *
43 * @SYSCTL_WRITES_LEGACY: each write syscall must fully contain the sysctl value
44 * to be written, and multiple writes on the same sysctl file descriptor
45 * will rewrite the sysctl value, regardless of file position. No warning
46 * is issued when the initial position is not 0.
47 * @SYSCTL_WRITES_WARN: same as above but warn when the initial file position is
48 * not 0.
49 * @SYSCTL_WRITES_STRICT: writes to numeric sysctl entries must always be at
50 * file position 0 and the value must be fully contained in the buffer
51 * sent to the write syscall. If dealing with strings respect the file
52 * position, but restrict this to the max length of the buffer, anything
53 * passed the max length will be ignored. Multiple writes will append
54 * to the buffer.
55 *
56 * These write modes control how current file position affects the behavior of
57 * updating internal kernel (SYSCTL_USER_TO_KERN) sysctl values through the proc
58 * interface on each write.
59 */
60enum sysctl_writes_mode {
61 SYSCTL_WRITES_LEGACY = -1,
62 SYSCTL_WRITES_WARN = 0,
63 SYSCTL_WRITES_STRICT = 1,
64};
65
66static enum sysctl_writes_mode sysctl_writes_strict = SYSCTL_WRITES_STRICT;
67#endif /* CONFIG_PROC_SYSCTL */
68#endif /* CONFIG_SYSCTL */
69
70/*
71 * /proc/sys support
72 */
73
74#ifdef CONFIG_PROC_SYSCTL
75
76static int _proc_do_string(char *data, int maxlen, int dir,
77 char *buffer, size_t *lenp, loff_t *ppos)
78{
79 size_t len;
80 char c, *p;
81
82 if (!data || !maxlen || !*lenp) {
83 *lenp = 0;
84 return 0;
85 }
86
87 if (SYSCTL_USER_TO_KERN(dir)) {
88 if (sysctl_writes_strict == SYSCTL_WRITES_STRICT) {
89 /* Only continue writes not past the end of buffer. */
90 len = strlen(data);
91 if (len > maxlen - 1)
92 len = maxlen - 1;
93
94 if (*ppos > len)
95 return 0;
96 len = *ppos;
97 } else {
98 /* Start writing from beginning of buffer. */
99 len = 0;
100 }
101
102 *ppos += *lenp;
103 p = buffer;
104 while ((p - buffer) < *lenp && len < maxlen - 1) {
105 c = *(p++);
106 if (c == 0 || c == '\n')
107 break;
108 data[len++] = c;
109 }
110 data[len] = 0;
111 } else {
112 len = strlen(data);
113 if (len > maxlen)
114 len = maxlen;
115
116 if (*ppos > len) {
117 *lenp = 0;
118 return 0;
119 }
120
121 data += *ppos;
122 len -= *ppos;
123
124 if (len > *lenp)
125 len = *lenp;
126 if (len)
127 memcpy(buffer, data, len);
128 if (len < *lenp) {
129 buffer[len] = '\n';
130 len++;
131 }
132 *lenp = len;
133 *ppos += len;
134 }
135 return 0;
136}
137
138static void warn_sysctl_write(const struct ctl_table *table)
139{
140 pr_warn_once("%s wrote to %s when file position was not 0!\n"
141 "This will not be supported in the future. To silence this\n"
142 "warning, set kernel.sysctl_writes_strict = -1\n",
143 current->comm, table->procname);
144}
145
146/**
147 * proc_first_pos_non_zero_ignore - check if first position is allowed
148 * @ppos: file position
149 * @table: the sysctl table
150 *
151 * Returns true if the first position is non-zero and the sysctl_writes_strict
152 * mode indicates this is not allowed for numeric input types. String proc
153 * handlers can ignore the return value.
154 */
155static bool proc_first_pos_non_zero_ignore(loff_t *ppos,
156 const struct ctl_table *table)
157{
158 if (!*ppos)
159 return false;
160
161 switch (sysctl_writes_strict) {
162 case SYSCTL_WRITES_STRICT:
163 return true;
164 case SYSCTL_WRITES_WARN:
165 warn_sysctl_write(table);
166 return false;
167 default:
168 return false;
169 }
170}
171
172/**
173 * proc_dostring - read a string sysctl
174 * @table: the sysctl table
175 * @dir: %TRUE if this is a write to the sysctl file
176 * @buffer: the user buffer
177 * @lenp: the size of the user buffer
178 * @ppos: file position
179 *
180 * Reads/writes a string from/to the user buffer. If the kernel
181 * buffer provided is not large enough to hold the string, the
182 * string is truncated. The copied string is %NULL-terminated.
183 * If the string is being read by the user process, it is copied
184 * and a newline '\n' is added. It is truncated if the buffer is
185 * not large enough.
186 *
187 * Returns 0 on success.
188 */
189int proc_dostring(const struct ctl_table *table, int dir,
190 void *buffer, size_t *lenp, loff_t *ppos)
191{
192 if (SYSCTL_USER_TO_KERN(dir))
193 proc_first_pos_non_zero_ignore(ppos, table);
194
195 return _proc_do_string(table->data, table->maxlen, dir, buffer, lenp,
196 ppos);
197}
198
199static void proc_skip_spaces(char **buf, size_t *size)
200{
201 while (*size) {
202 if (!isspace(**buf))
203 break;
204 (*size)--;
205 (*buf)++;
206 }
207}
208
209static void proc_skip_char(char **buf, size_t *size, const char v)
210{
211 while (*size) {
212 if (**buf != v)
213 break;
214 (*size)--;
215 (*buf)++;
216 }
217}
218
219/**
220 * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
221 * fail on overflow
222 *
223 * @cp: kernel buffer containing the string to parse
224 * @endp: pointer to store the trailing characters
225 * @base: the base to use
226 * @res: where the parsed integer will be stored
227 *
228 * In case of success 0 is returned and @res will contain the parsed integer,
229 * @endp will hold any trailing characters.
230 * This function will fail the parse on overflow. If there wasn't an overflow
231 * the function will defer the decision what characters count as invalid to the
232 * caller.
233 */
234static int strtoul_lenient(const char *cp, char **endp, unsigned int base,
235 unsigned long *res)
236{
237 unsigned long long result;
238 unsigned int rv;
239
240 cp = _parse_integer_fixup_radix(cp, &base);
241 rv = _parse_integer(cp, base, &result);
242 if ((rv & KSTRTOX_OVERFLOW) || (result != (unsigned long)result))
243 return -ERANGE;
244
245 cp += rv;
246
247 if (endp)
248 *endp = (char *)cp;
249
250 *res = (unsigned long)result;
251 return 0;
252}
253
254#define TMPBUFLEN 22
255/**
256 * proc_get_long - reads an ASCII formatted integer from a user buffer
257 *
258 * @buf: a kernel buffer
259 * @size: size of the kernel buffer
260 * @val: this is where the number will be stored
261 * @neg: set to %TRUE if number is negative
262 * @perm_tr: a vector which contains the allowed trailers
263 * @perm_tr_len: size of the perm_tr vector
264 * @tr: pointer to store the trailer character
265 *
266 * In case of success %0 is returned and @buf and @size are updated with
267 * the amount of bytes read. If @tr is non-NULL and a trailing
268 * character exists (size is non-zero after returning from this
269 * function), @tr is updated with the trailing character.
270 */
271static int proc_get_long(char **buf, size_t *size,
272 unsigned long *val, bool *neg,
273 const char *perm_tr, unsigned perm_tr_len, char *tr)
274{
275 char *p, tmp[TMPBUFLEN];
276 ssize_t len = *size;
277
278 if (len <= 0)
279 return -EINVAL;
280
281 if (len > TMPBUFLEN - 1)
282 len = TMPBUFLEN - 1;
283
284 memcpy(tmp, *buf, len);
285
286 tmp[len] = 0;
287 p = tmp;
288 if (*p == '-' && *size > 1) {
289 *neg = true;
290 p++;
291 } else
292 *neg = false;
293 if (!isdigit(*p))
294 return -EINVAL;
295
296 if (strtoul_lenient(p, &p, 0, val))
297 return -EINVAL;
298
299 len = p - tmp;
300
301 /* We don't know if the next char is whitespace thus we may accept
302 * invalid integers (e.g. 1234...a) or two integers instead of one
303 * (e.g. 123...1). So lets not allow such large numbers. */
304 if (len == TMPBUFLEN - 1)
305 return -EINVAL;
306
307 if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
308 return -EINVAL;
309
310 if (tr && (len < *size))
311 *tr = *p;
312
313 *buf += len;
314 *size -= len;
315
316 return 0;
317}
318
319/**
320 * proc_put_long - converts an integer to a decimal ASCII formatted string
321 *
322 * @buf: the user buffer
323 * @size: the size of the user buffer
324 * @val: the integer to be converted
325 * @neg: sign of the number, %TRUE for negative
326 *
327 * In case of success @buf and @size are updated with the amount of bytes
328 * written.
329 */
330static void proc_put_long(void **buf, size_t *size, unsigned long val, bool neg)
331{
332 int len;
333 char tmp[TMPBUFLEN], *p = tmp;
334
335 sprintf(p, "%s%lu", neg ? "-" : "", val);
336 len = strlen(tmp);
337 if (len > *size)
338 len = *size;
339 memcpy(*buf, tmp, len);
340 *size -= len;
341 *buf += len;
342}
343#undef TMPBUFLEN
344
345static void proc_put_char(void **buf, size_t *size, char c)
346{
347 if (*size) {
348 char **buffer = (char **)buf;
349 **buffer = c;
350
351 (*size)--;
352 (*buffer)++;
353 *buf = *buffer;
354 }
355}
356
357static SYSCTL_USER_TO_KERN_INT_CONV(, SYSCTL_CONV_IDENTITY)
358static SYSCTL_KERN_TO_USER_INT_CONV(, SYSCTL_CONV_IDENTITY)
359
360static SYSCTL_INT_CONV_CUSTOM(, sysctl_user_to_kern_int_conv,
361 sysctl_kern_to_user_int_conv, false)
362static SYSCTL_INT_CONV_CUSTOM(_minmax, sysctl_user_to_kern_int_conv,
363 sysctl_kern_to_user_int_conv, true)
364
365
366static SYSCTL_USER_TO_KERN_UINT_CONV(, SYSCTL_CONV_IDENTITY)
367
368int sysctl_kern_to_user_uint_conv(unsigned long *u_ptr,
369 const unsigned int *k_ptr)
370{
371 unsigned int val = READ_ONCE(*k_ptr);
372 *u_ptr = (unsigned long)val;
373 return 0;
374}
375
376static SYSCTL_UINT_CONV_CUSTOM(, sysctl_user_to_kern_uint_conv,
377 sysctl_kern_to_user_uint_conv, false)
378static SYSCTL_UINT_CONV_CUSTOM(_minmax, sysctl_user_to_kern_uint_conv,
379 sysctl_kern_to_user_uint_conv, true)
380
381static const char proc_wspace_sep[] = { ' ', '\t', '\n' };
382
383static int do_proc_dointvec(const struct ctl_table *table, int dir,
384 void *buffer, size_t *lenp, loff_t *ppos,
385 int (*conv)(bool *negp, unsigned long *u_ptr, int *k_ptr,
386 int dir, const struct ctl_table *table))
387{
388 int *i, vleft, first = 1, err = 0;
389 size_t left;
390 char *p;
391
392 if (!table->data || !table->maxlen || !*lenp ||
393 (*ppos && SYSCTL_KERN_TO_USER(dir))) {
394 *lenp = 0;
395 return 0;
396 }
397
398 i = (int *) table->data;
399 vleft = table->maxlen / sizeof(*i);
400 left = *lenp;
401
402 if (!conv)
403 conv = do_proc_int_conv;
404
405 if (SYSCTL_USER_TO_KERN(dir)) {
406 if (proc_first_pos_non_zero_ignore(ppos, table))
407 goto out;
408
409 if (left > PAGE_SIZE - 1)
410 left = PAGE_SIZE - 1;
411 p = buffer;
412 }
413
414 for (; left && vleft--; i++, first=0) {
415 unsigned long lval;
416 bool neg;
417
418 if (SYSCTL_USER_TO_KERN(dir)) {
419 proc_skip_spaces(&p, &left);
420
421 if (!left)
422 break;
423 err = proc_get_long(&p, &left, &lval, &neg,
424 proc_wspace_sep,
425 sizeof(proc_wspace_sep), NULL);
426 if (err)
427 break;
428 if (conv(&neg, &lval, i, 1, table)) {
429 err = -EINVAL;
430 break;
431 }
432 } else {
433 if (conv(&neg, &lval, i, 0, table)) {
434 err = -EINVAL;
435 break;
436 }
437 if (!first)
438 proc_put_char(&buffer, &left, '\t');
439 proc_put_long(&buffer, &left, lval, neg);
440 }
441 }
442
443 if (SYSCTL_KERN_TO_USER(dir) && !first && left && !err)
444 proc_put_char(&buffer, &left, '\n');
445 if (SYSCTL_USER_TO_KERN(dir) && !err && left)
446 proc_skip_spaces(&p, &left);
447 if (SYSCTL_USER_TO_KERN(dir) && first)
448 return err ? : -EINVAL;
449 *lenp -= left;
450out:
451 *ppos += *lenp;
452 return err;
453}
454
455static int do_proc_douintvec_w(const struct ctl_table *table, void *buffer,
456 size_t *lenp, loff_t *ppos,
457 int (*conv)(unsigned long *u_ptr,
458 unsigned int *k_ptr, int dir,
459 const struct ctl_table *table))
460{
461 unsigned long lval;
462 int err = 0;
463 size_t left;
464 bool neg;
465 char *p = buffer;
466
467 left = *lenp;
468
469 if (proc_first_pos_non_zero_ignore(ppos, table))
470 goto bail_early;
471
472 if (left > PAGE_SIZE - 1)
473 left = PAGE_SIZE - 1;
474
475 proc_skip_spaces(&p, &left);
476 if (!left) {
477 err = -EINVAL;
478 goto out_free;
479 }
480
481 err = proc_get_long(&p, &left, &lval, &neg,
482 proc_wspace_sep,
483 sizeof(proc_wspace_sep), NULL);
484 if (err || neg) {
485 err = -EINVAL;
486 goto out_free;
487 }
488
489 if (conv(&lval, (unsigned int *) table->data, 1, table)) {
490 err = -EINVAL;
491 goto out_free;
492 }
493
494 if (!err && left)
495 proc_skip_spaces(&p, &left);
496
497out_free:
498 if (err)
499 return -EINVAL;
500
501 return 0;
502
503bail_early:
504 *ppos += *lenp;
505 return err;
506}
507
508static int do_proc_douintvec_r(const struct ctl_table *table, void *buffer,
509 size_t *lenp, loff_t *ppos,
510 int (*conv)(unsigned long *u_ptr,
511 unsigned int *k_ptr, int dir,
512 const struct ctl_table *table))
513{
514 unsigned long lval;
515 int err = 0;
516 size_t left;
517
518 left = *lenp;
519
520 if (conv(&lval, (unsigned int *) table->data, 0, table)) {
521 err = -EINVAL;
522 goto out;
523 }
524
525 proc_put_long(&buffer, &left, lval, false);
526 if (!left)
527 goto out;
528
529 proc_put_char(&buffer, &left, '\n');
530
531out:
532 *lenp -= left;
533 *ppos += *lenp;
534
535 return err;
536}
537
538static int do_proc_douintvec(const struct ctl_table *table, int dir,
539 void *buffer, size_t *lenp, loff_t *ppos,
540 int (*conv)(unsigned long *u_ptr,
541 unsigned int *k_ptr, int dir,
542 const struct ctl_table *table))
543{
544 unsigned int vleft;
545
546 if (!table->data || !table->maxlen || !*lenp ||
547 (*ppos && SYSCTL_KERN_TO_USER(dir))) {
548 *lenp = 0;
549 return 0;
550 }
551
552 vleft = table->maxlen / sizeof(unsigned int);
553
554 /*
555 * Arrays are not supported, keep this simple. *Do not* add
556 * support for them.
557 */
558 if (vleft != 1) {
559 *lenp = 0;
560 return -EINVAL;
561 }
562
563 if (!conv)
564 conv = do_proc_uint_conv;
565
566 if (SYSCTL_USER_TO_KERN(dir))
567 return do_proc_douintvec_w(table, buffer, lenp, ppos, conv);
568 return do_proc_douintvec_r(table, buffer, lenp, ppos, conv);
569}
570
571int proc_douintvec_conv(const struct ctl_table *table, int dir, void *buffer,
572 size_t *lenp, loff_t *ppos,
573 int (*conv)(unsigned long *u_ptr, unsigned int *k_ptr,
574 int dir, const struct ctl_table *table))
575{
576 return do_proc_douintvec(table, dir, buffer, lenp, ppos, conv);
577}
578
579
580/**
581 * proc_dobool - read/write a bool
582 * @table: the sysctl table
583 * @dir: %TRUE if this is a write to the sysctl file
584 * @buffer: the user buffer
585 * @lenp: the size of the user buffer
586 * @ppos: file position
587 *
588 * Reads/writes one integer value from/to the user buffer,
589 * treated as an ASCII string.
590 *
591 * table->data must point to a bool variable and table->maxlen must
592 * be sizeof(bool).
593 *
594 * Returns 0 on success.
595 */
596int proc_dobool(const struct ctl_table *table, int dir, void *buffer,
597 size_t *lenp, loff_t *ppos)
598{
599 struct ctl_table tmp;
600 bool *data = table->data;
601 int res, val;
602
603 /* Do not support arrays yet. */
604 if (table->maxlen != sizeof(bool))
605 return -EINVAL;
606
607 tmp = *table;
608 tmp.maxlen = sizeof(val);
609 tmp.data = &val;
610
611 val = READ_ONCE(*data);
612 res = proc_dointvec(&tmp, dir, buffer, lenp, ppos);
613 if (res)
614 return res;
615 if (SYSCTL_USER_TO_KERN(dir))
616 WRITE_ONCE(*data, val);
617 return 0;
618}
619
620/**
621 * proc_dointvec - read a vector of integers
622 * @table: the sysctl table
623 * @dir: %TRUE if this is a write to the sysctl file
624 * @buffer: the user buffer
625 * @lenp: the size of the user buffer
626 * @ppos: file position
627 *
628 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
629 * values from/to the user buffer, treated as an ASCII string.
630 *
631 * Returns 0 on success.
632 */
633int proc_dointvec(const struct ctl_table *table, int dir, void *buffer,
634 size_t *lenp, loff_t *ppos)
635{
636 return do_proc_dointvec(table, dir, buffer, lenp, ppos, NULL);
637}
638
639/**
640 * proc_douintvec - read a vector of unsigned integers
641 * @table: the sysctl table
642 * @dir: %TRUE if this is a write to the sysctl file
643 * @buffer: the user buffer
644 * @lenp: the size of the user buffer
645 * @ppos: file position
646 *
647 * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
648 * values from/to the user buffer, treated as an ASCII string.
649 *
650 * Returns 0 on success.
651 */
652int proc_douintvec(const struct ctl_table *table, int dir, void *buffer,
653 size_t *lenp, loff_t *ppos)
654{
655 return do_proc_douintvec(table, dir, buffer, lenp, ppos,
656 do_proc_uint_conv);
657}
658
659/**
660 * proc_dointvec_minmax - read a vector of integers with min/max values
661 * @table: the sysctl table
662 * @dir: %TRUE if this is a write to the sysctl file
663 * @buffer: the user buffer
664 * @lenp: the size of the user buffer
665 * @ppos: file position
666 *
667 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
668 * values from/to the user buffer, treated as an ASCII string.
669 *
670 * This routine will ensure the values are within the range specified by
671 * table->extra1 (min) and table->extra2 (max).
672 *
673 * Returns 0 on success or -EINVAL when the range check fails and
674 * SYSCTL_USER_TO_KERN(dir) == true
675 */
676int proc_dointvec_minmax(const struct ctl_table *table, int dir,
677 void *buffer, size_t *lenp, loff_t *ppos)
678{
679 return do_proc_dointvec(table, dir, buffer, lenp, ppos,
680 do_proc_int_conv_minmax);
681}
682
683/**
684 * proc_douintvec_minmax - read a vector of unsigned ints with min/max values
685 * @table: the sysctl table
686 * @dir: %TRUE if this is a write to the sysctl file
687 * @buffer: the user buffer
688 * @lenp: the size of the user buffer
689 * @ppos: file position
690 *
691 * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
692 * values from/to the user buffer, treated as an ASCII string. Negative
693 * strings are not allowed.
694 *
695 * This routine will ensure the values are within the range specified by
696 * table->extra1 (min) and table->extra2 (max). There is a final sanity
697 * check for UINT_MAX to avoid having to support wrap around uses from
698 * userspace.
699 *
700 * Returns 0 on success or -ERANGE when range check failes and
701 * SYSCTL_USER_TO_KERN(dir) == true
702 */
703int proc_douintvec_minmax(const struct ctl_table *table, int dir,
704 void *buffer, size_t *lenp, loff_t *ppos)
705{
706 return do_proc_douintvec(table, dir, buffer, lenp, ppos,
707 do_proc_uint_conv_minmax);
708}
709
710/**
711 * proc_dou8vec_minmax - read a vector of unsigned chars with min/max values
712 * @table: the sysctl table
713 * @dir: %TRUE if this is a write to the sysctl file
714 * @buffer: the user buffer
715 * @lenp: the size of the user buffer
716 * @ppos: file position
717 *
718 * Reads/writes up to table->maxlen/sizeof(u8) unsigned chars
719 * values from/to the user buffer, treated as an ASCII string. Negative
720 * strings are not allowed.
721 *
722 * This routine will ensure the values are within the range specified by
723 * table->extra1 (min) and table->extra2 (max).
724 *
725 * Returns 0 on success or an error on SYSCTL_USER_TO_KERN(dir) == true
726 * and the range check fails.
727 */
728int proc_dou8vec_minmax(const struct ctl_table *table, int dir,
729 void *buffer, size_t *lenp, loff_t *ppos)
730{
731 struct ctl_table tmp;
732 unsigned int min = 0, max = 255U, val;
733 u8 *data = table->data;
734 int res;
735
736 /* Do not support arrays yet. */
737 if (table->maxlen != sizeof(u8))
738 return -EINVAL;
739
740 tmp = *table;
741
742 tmp.maxlen = sizeof(val);
743 tmp.data = &val;
744 if (!tmp.extra1)
745 tmp.extra1 = (unsigned int *) &min;
746 if (!tmp.extra2)
747 tmp.extra2 = (unsigned int *) &max;
748
749 val = READ_ONCE(*data);
750 res = do_proc_douintvec(&tmp, dir, buffer, lenp, ppos,
751 do_proc_uint_conv_minmax);
752 if (res)
753 return res;
754 if (SYSCTL_USER_TO_KERN(dir))
755 WRITE_ONCE(*data, val);
756 return 0;
757}
758EXPORT_SYMBOL_GPL(proc_dou8vec_minmax);
759
760static int do_proc_doulongvec_minmax(const struct ctl_table *table, int dir,
761 void *buffer, size_t *lenp, loff_t *ppos,
762 unsigned long convmul,
763 unsigned long convdiv)
764{
765 unsigned long *i, *min, *max;
766 int vleft, first = 1, err = 0;
767 size_t left;
768 char *p;
769
770 if (!table->data || !table->maxlen || !*lenp ||
771 (*ppos && SYSCTL_KERN_TO_USER(dir))) {
772 *lenp = 0;
773 return 0;
774 }
775
776 i = table->data;
777 min = table->extra1;
778 max = table->extra2;
779 vleft = table->maxlen / sizeof(unsigned long);
780 left = *lenp;
781
782 if (SYSCTL_USER_TO_KERN(dir)) {
783 if (proc_first_pos_non_zero_ignore(ppos, table))
784 goto out;
785
786 if (left > PAGE_SIZE - 1)
787 left = PAGE_SIZE - 1;
788 p = buffer;
789 }
790
791 for (; left && vleft--; i++, first = 0) {
792 unsigned long val;
793
794 if (SYSCTL_USER_TO_KERN(dir)) {
795 bool neg;
796
797 proc_skip_spaces(&p, &left);
798 if (!left)
799 break;
800
801 err = proc_get_long(&p, &left, &val, &neg,
802 proc_wspace_sep,
803 sizeof(proc_wspace_sep), NULL);
804 if (err || neg) {
805 err = -EINVAL;
806 break;
807 }
808
809 val = convmul * val / convdiv;
810 if ((min && val < *min) || (max && val > *max)) {
811 err = -EINVAL;
812 break;
813 }
814 WRITE_ONCE(*i, val);
815 } else {
816 val = convdiv * READ_ONCE(*i) / convmul;
817 if (!first)
818 proc_put_char(&buffer, &left, '\t');
819 proc_put_long(&buffer, &left, val, false);
820 }
821 }
822
823 if (SYSCTL_KERN_TO_USER(dir) && !first && left && !err)
824 proc_put_char(&buffer, &left, '\n');
825 if (SYSCTL_USER_TO_KERN(dir) && !err)
826 proc_skip_spaces(&p, &left);
827 if (SYSCTL_USER_TO_KERN(dir) && first)
828 return err ? : -EINVAL;
829 *lenp -= left;
830out:
831 *ppos += *lenp;
832 return err;
833}
834
835int proc_doulongvec_minmax_conv(const struct ctl_table *table, int dir,
836 void *buffer, size_t *lenp, loff_t *ppos,
837 unsigned long convmul, unsigned long convdiv)
838{
839 return do_proc_doulongvec_minmax(table, dir, buffer, lenp, ppos,
840 convmul, convdiv);
841}
842
843/**
844 * proc_doulongvec_minmax - read a vector of long integers with min/max values
845 * @table: the sysctl table
846 * @dir: %TRUE if this is a write to the sysctl file
847 * @buffer: the user buffer
848 * @lenp: the size of the user buffer
849 * @ppos: file position
850 *
851 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
852 * values from/to the user buffer, treated as an ASCII string.
853 *
854 * This routine will ensure the values are within the range specified by
855 * table->extra1 (min) and table->extra2 (max).
856 *
857 * Returns 0 on success.
858 */
859int proc_doulongvec_minmax(const struct ctl_table *table, int dir,
860 void *buffer, size_t *lenp, loff_t *ppos)
861{
862 return proc_doulongvec_minmax_conv(table, dir, buffer, lenp, ppos, 1l, 1l);
863}
864
865int proc_dointvec_conv(const struct ctl_table *table, int dir, void *buffer,
866 size_t *lenp, loff_t *ppos,
867 int (*conv)(bool *negp, unsigned long *u_ptr, int *k_ptr,
868 int dir, const struct ctl_table *table))
869{
870 return do_proc_dointvec(table, dir, buffer, lenp, ppos, conv);
871}
872
873/**
874 * proc_do_large_bitmap - read/write from/to a large bitmap
875 * @table: the sysctl table
876 * @dir: %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 * The bitmap is stored at table->data and the bitmap length (in bits)
882 * in table->maxlen.
883 *
884 * We use a range comma separated format (e.g. 1,3-4,10-10) so that
885 * large bitmaps may be represented in a compact manner. Writing into
886 * the file will clear the bitmap then update it with the given input.
887 *
888 * Returns 0 on success.
889 */
890int proc_do_large_bitmap(const struct ctl_table *table, int dir,
891 void *buffer, size_t *lenp, loff_t *ppos)
892{
893 int err = 0;
894 size_t left = *lenp;
895 unsigned long bitmap_len = table->maxlen;
896 unsigned long *bitmap = *(unsigned long **) table->data;
897 unsigned long *tmp_bitmap = NULL;
898 char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
899
900 if (!bitmap || !bitmap_len || !left || (*ppos && SYSCTL_KERN_TO_USER(dir))) {
901 *lenp = 0;
902 return 0;
903 }
904
905 if (SYSCTL_USER_TO_KERN(dir)) {
906 char *p = buffer;
907 size_t skipped = 0;
908
909 if (left > PAGE_SIZE - 1) {
910 left = PAGE_SIZE - 1;
911 /* How much of the buffer we'll skip this pass */
912 skipped = *lenp - left;
913 }
914
915 tmp_bitmap = bitmap_zalloc(bitmap_len, GFP_KERNEL);
916 if (!tmp_bitmap)
917 return -ENOMEM;
918 proc_skip_char(&p, &left, '\n');
919 while (!err && left) {
920 unsigned long val_a, val_b;
921 bool neg;
922 size_t saved_left;
923
924 /* In case we stop parsing mid-number, we can reset */
925 saved_left = left;
926 err = proc_get_long(&p, &left, &val_a, &neg, tr_a,
927 sizeof(tr_a), &c);
928 /*
929 * If we consumed the entirety of a truncated buffer or
930 * only one char is left (may be a "-"), then stop here,
931 * reset, & come back for more.
932 */
933 if ((left <= 1) && skipped) {
934 left = saved_left;
935 break;
936 }
937
938 if (err)
939 break;
940 if (val_a >= bitmap_len || neg) {
941 err = -EINVAL;
942 break;
943 }
944
945 val_b = val_a;
946 if (left) {
947 p++;
948 left--;
949 }
950
951 if (c == '-') {
952 err = proc_get_long(&p, &left, &val_b,
953 &neg, tr_b, sizeof(tr_b),
954 &c);
955 /*
956 * If we consumed all of a truncated buffer or
957 * then stop here, reset, & come back for more.
958 */
959 if (!left && skipped) {
960 left = saved_left;
961 break;
962 }
963
964 if (err)
965 break;
966 if (val_b >= bitmap_len || neg ||
967 val_a > val_b) {
968 err = -EINVAL;
969 break;
970 }
971 if (left) {
972 p++;
973 left--;
974 }
975 }
976
977 bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
978 proc_skip_char(&p, &left, '\n');
979 }
980 left += skipped;
981 } else {
982 unsigned long bit_a, bit_b = 0;
983 bool first = 1;
984
985 while (left) {
986 bit_a = find_next_bit(bitmap, bitmap_len, bit_b);
987 if (bit_a >= bitmap_len)
988 break;
989 bit_b = find_next_zero_bit(bitmap, bitmap_len,
990 bit_a + 1) - 1;
991
992 if (!first)
993 proc_put_char(&buffer, &left, ',');
994 proc_put_long(&buffer, &left, bit_a, false);
995 if (bit_a != bit_b) {
996 proc_put_char(&buffer, &left, '-');
997 proc_put_long(&buffer, &left, bit_b, false);
998 }
999
1000 first = 0; bit_b++;
1001 }
1002 proc_put_char(&buffer, &left, '\n');
1003 }
1004
1005 if (!err) {
1006 if (SYSCTL_USER_TO_KERN(dir)) {
1007 if (*ppos)
1008 bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len);
1009 else
1010 bitmap_copy(bitmap, tmp_bitmap, bitmap_len);
1011 }
1012 *lenp -= left;
1013 *ppos += *lenp;
1014 }
1015
1016 bitmap_free(tmp_bitmap);
1017 return err;
1018}
1019
1020#else /* CONFIG_PROC_SYSCTL */
1021
1022int proc_dostring(const struct ctl_table *table, int dir,
1023 void *buffer, size_t *lenp, loff_t *ppos)
1024{
1025 return -ENOSYS;
1026}
1027
1028int proc_dobool(const struct ctl_table *table, int dir,
1029 void *buffer, size_t *lenp, loff_t *ppos)
1030{
1031 return -ENOSYS;
1032}
1033
1034int proc_dointvec(const struct ctl_table *table, int dir,
1035 void *buffer, size_t *lenp, loff_t *ppos)
1036{
1037 return -ENOSYS;
1038}
1039
1040int proc_douintvec(const struct ctl_table *table, int dir,
1041 void *buffer, size_t *lenp, loff_t *ppos)
1042{
1043 return -ENOSYS;
1044}
1045
1046int proc_dointvec_minmax(const struct ctl_table *table, int dir,
1047 void *buffer, size_t *lenp, loff_t *ppos)
1048{
1049 return -ENOSYS;
1050}
1051
1052int proc_douintvec_minmax(const struct ctl_table *table, int dir,
1053 void *buffer, size_t *lenp, loff_t *ppos)
1054{
1055 return -ENOSYS;
1056}
1057
1058int proc_dou8vec_minmax(const struct ctl_table *table, int dir,
1059 void *buffer, size_t *lenp, loff_t *ppos)
1060{
1061 return -ENOSYS;
1062}
1063
1064int proc_doulongvec_minmax(const struct ctl_table *table, int dir,
1065 void *buffer, size_t *lenp, loff_t *ppos)
1066{
1067 return -ENOSYS;
1068}
1069
1070int proc_doulongvec_minmax_conv(const struct ctl_table *table, int dir,
1071 void *buffer, size_t *lenp, loff_t *ppos,
1072 unsigned long convmul, unsigned long convdiv)
1073{
1074 return -ENOSYS;
1075}
1076
1077int proc_dointvec_conv(const struct ctl_table *table, int dir, void *buffer,
1078 size_t *lenp, loff_t *ppos,
1079 int (*conv)(bool *negp, unsigned long *u_ptr, int *k_ptr,
1080 int dir, const struct ctl_table *table))
1081{
1082 return -ENOSYS;
1083}
1084
1085int proc_do_large_bitmap(const struct ctl_table *table, int dir,
1086 void *buffer, size_t *lenp, loff_t *ppos)
1087{
1088 return -ENOSYS;
1089}
1090
1091#endif /* CONFIG_PROC_SYSCTL */
1092
1093#if defined(CONFIG_SYSCTL)
1094int proc_do_static_key(const struct ctl_table *table, int dir,
1095 void *buffer, size_t *lenp, loff_t *ppos)
1096{
1097 struct static_key *key = (struct static_key *)table->data;
1098 static DEFINE_MUTEX(static_key_mutex);
1099 int val, ret;
1100 struct ctl_table tmp = {
1101 .data = &val,
1102 .maxlen = sizeof(val),
1103 .mode = table->mode,
1104 .extra1 = SYSCTL_ZERO,
1105 .extra2 = SYSCTL_ONE,
1106 };
1107
1108 if (SYSCTL_USER_TO_KERN(dir) && !capable(CAP_SYS_ADMIN))
1109 return -EPERM;
1110
1111 mutex_lock(&static_key_mutex);
1112 val = static_key_enabled(key);
1113 ret = proc_dointvec_minmax(&tmp, dir, buffer, lenp, ppos);
1114 if (SYSCTL_USER_TO_KERN(dir) && !ret) {
1115 if (val)
1116 static_key_enable(key);
1117 else
1118 static_key_disable(key);
1119 }
1120 mutex_unlock(&static_key_mutex);
1121 return ret;
1122}
1123
1124static const struct ctl_table sysctl_subsys_table[] = {
1125#ifdef CONFIG_PROC_SYSCTL
1126 {
1127 .procname = "sysctl_writes_strict",
1128 .data = &sysctl_writes_strict,
1129 .maxlen = sizeof(int),
1130 .mode = 0644,
1131 .proc_handler = proc_dointvec_minmax,
1132 .extra1 = SYSCTL_NEG_ONE,
1133 .extra2 = SYSCTL_ONE,
1134 },
1135#endif
1136 {
1137 .procname = "ngroups_max",
1138 .data = (void *)&ngroups_max,
1139 .maxlen = sizeof (int),
1140 .mode = 0444,
1141 .proc_handler = proc_dointvec,
1142 },
1143 {
1144 .procname = "cap_last_cap",
1145 .data = (void *)&cap_last_cap,
1146 .maxlen = sizeof(int),
1147 .mode = 0444,
1148 .proc_handler = proc_dointvec,
1149 },
1150#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_ALLOW
1151 {
1152 .procname = "unaligned-trap",
1153 .data = &unaligned_enabled,
1154 .maxlen = sizeof(int),
1155 .mode = 0644,
1156 .proc_handler = proc_dointvec,
1157 },
1158#endif
1159#ifdef CONFIG_SYSCTL_ARCH_UNALIGN_NO_WARN
1160 {
1161 .procname = "ignore-unaligned-usertrap",
1162 .data = &no_unaligned_warning,
1163 .maxlen = sizeof (int),
1164 .mode = 0644,
1165 .proc_handler = proc_dointvec,
1166 },
1167#endif
1168};
1169
1170int __init sysctl_init_bases(void)
1171{
1172 register_sysctl_init("kernel", sysctl_subsys_table);
1173
1174 return 0;
1175}
1176#endif /* CONFIG_SYSCTL */
1177/*
1178 * No sense putting this after each symbol definition, twice,
1179 * exception granted :-)
1180 */
1181EXPORT_SYMBOL(proc_dobool);
1182EXPORT_SYMBOL(proc_dointvec);
1183EXPORT_SYMBOL(proc_douintvec);
1184EXPORT_SYMBOL(proc_dointvec_minmax);
1185EXPORT_SYMBOL_GPL(proc_douintvec_minmax);
1186EXPORT_SYMBOL(proc_dostring);
1187EXPORT_SYMBOL(proc_doulongvec_minmax);
1188EXPORT_SYMBOL(proc_do_large_bitmap);