Lines Matching +full:min +full:- +full:len
1 // SPDX-License-Identifier: GPL-2.0-only
7 * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas.
9 * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver.
11 * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn.
68 const int sysctl_vals[] = { 0, 1, 2, 3, 4, 100, 200, 1000, 3000, INT_MAX, 65535, -1 };
83 * enum sysctl_writes_mode - supported sysctl write modes
102 SYSCTL_WRITES_LEGACY = -1,
120 size_t len;
131 len = strlen(data);
132 if (len > maxlen - 1)
133 len = maxlen - 1;
135 if (*ppos > len)
137 len = *ppos;
140 len = 0;
145 while ((p - buffer) < *lenp && len < maxlen - 1) {
149 data[len++] = c;
151 data[len] = 0;
153 len = strlen(data);
154 if (len > maxlen)
155 len = maxlen;
157 if (*ppos > len) {
163 len -= *ppos;
165 if (len > *lenp)
166 len = *lenp;
167 if (len)
168 memcpy(buffer, data, len);
169 if (len < *lenp) {
170 buffer[len] = '\n';
171 len++;
173 *lenp = len;
174 *ppos += len;
183 "warning, set kernel.sysctl_writes_strict = -1\n",
184 current->comm, table->procname);
188 * proc_first_pos_non_zero_ignore - check if first position is allowed
192 * Returns true if the first position is non-zero and the sysctl_writes_strict
214 * proc_dostring - read a string sysctl
223 * string is truncated. The copied string is %NULL-terminated.
236 return _proc_do_string(table->data, table->maxlen, write, buffer, lenp,
245 (*size)--;
255 (*size)--;
261 * strtoul_lenient - parse an ASCII formatted integer from a buffer and only
284 return -ERANGE;
297 * proc_get_long - reads an ASCII formatted integer from a user buffer
308 * the amount of bytes read. If @tr is non-NULL and a trailing
309 * character exists (size is non-zero after returning from this
317 ssize_t len = *size;
319 if (len <= 0)
320 return -EINVAL;
322 if (len > TMPBUFLEN - 1)
323 len = TMPBUFLEN - 1;
325 memcpy(tmp, *buf, len);
327 tmp[len] = 0;
329 if (*p == '-' && *size > 1) {
335 return -EINVAL;
338 return -EINVAL;
340 len = p - tmp;
345 if (len == TMPBUFLEN - 1)
346 return -EINVAL;
348 if (len < *size && perm_tr_len && !memchr(perm_tr, *p, perm_tr_len))
349 return -EINVAL;
351 if (tr && (len < *size))
354 *buf += len;
355 *size -= len;
361 * proc_put_long - converts an integer to a decimal ASCII formatted string
373 int len;
376 sprintf(p, "%s%lu", neg ? "-" : "", val);
377 len = strlen(tmp);
378 if (len > *size)
379 len = *size;
380 memcpy(*buf, tmp, len);
381 *size -= len;
382 *buf += len;
392 (*size)--;
405 return -EINVAL;
406 WRITE_ONCE(*valp, -*lvalp);
409 return -EINVAL;
416 *lvalp = -(unsigned long)val;
431 return -EINVAL;
453 if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
459 vleft = table->maxlen / sizeof(*i);
469 if (left > PAGE_SIZE - 1)
470 left = PAGE_SIZE - 1;
474 for (; left && vleft--; i++, first=0) {
489 err = -EINVAL;
494 err = -EINVAL;
508 return err ? : -EINVAL;
509 *lenp -= left;
521 return __do_proc_dointvec(table->data, table, write,
545 if (left > PAGE_SIZE - 1)
546 left = PAGE_SIZE - 1;
550 err = -EINVAL;
558 err = -EINVAL;
563 err = -EINVAL;
572 return -EINVAL;
596 err = -EINVAL;
607 *lenp -= left;
623 if (!tbl_data || !table->maxlen || !*lenp || (*ppos && !write)) {
629 vleft = table->maxlen / sizeof(*i);
637 return -EINVAL;
656 return __do_proc_douintvec(table->data, table, write,
661 * proc_dobool - read/write a bool
671 * table->data must point to a bool variable and table->maxlen must
680 bool *data = table->data;
684 if (table->maxlen != sizeof(bool))
685 return -EINVAL;
701 * proc_dointvec - read a vector of integers
708 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
720 * proc_douintvec - read a vector of unsigned integers
727 * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
751 return -EPERM;
768 return -EINVAL;
783 * struct do_proc_dointvec_minmax_conv_param - proc_dointvec_minmax() range checking structure
784 * @min: pointer to minimum allowable value
792 int *min;
804 * bounds-check it before touching *valp.
813 if ((param->min && *param->min > tmp) ||
814 (param->max && *param->max < tmp))
815 return -EINVAL;
823 * proc_dointvec_minmax - read a vector of integers with min/max values
830 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
834 * table->extra1 (min) and table->extra2 (max).
836 * Returns 0 on success or -EINVAL on write when the range check fails.
842 .min = (int *) table->extra1,
843 .max = (int *) table->extra2,
850 * struct do_proc_douintvec_minmax_conv_param - proc_douintvec_minmax() range checking structure
851 * @min: pointer to minimum allowable value
859 unsigned int *min;
870 /* write via temporary local uint for bounds-checking */
878 if ((param->min && *param->min > tmp) ||
879 (param->max && *param->max < tmp))
880 return -ERANGE;
889 * proc_douintvec_minmax - read a vector of unsigned ints with min/max values
896 * Reads/writes up to table->maxlen/sizeof(unsigned int) unsigned integer
901 * table->extra1 (min) and table->extra2 (max). There is a final sanity
905 * Returns 0 on success or -ERANGE on write when the range check fails.
911 .min = (unsigned int *) table->extra1,
912 .max = (unsigned int *) table->extra2,
919 * proc_dou8vec_minmax - read a vector of unsigned chars with min/max values
926 * Reads/writes up to table->maxlen/sizeof(u8) unsigned chars
931 * table->extra1 (min) and table->extra2 (max).
939 unsigned int min = 0, max = 255U, val;
940 u8 *data = table->data;
942 .min = &min,
948 if (table->maxlen != sizeof(u8))
949 return -EINVAL;
951 if (table->extra1)
952 min = *(unsigned int *) table->extra1;
953 if (table->extra2)
954 max = *(unsigned int *) table->extra2;
996 unsigned long *i, *min, *max;
1001 if (!data || !table->maxlen || !*lenp || (*ppos && !write)) {
1007 min = table->extra1;
1008 max = table->extra2;
1009 vleft = table->maxlen / sizeof(unsigned long);
1016 if (left > PAGE_SIZE - 1)
1017 left = PAGE_SIZE - 1;
1021 for (; left && vleft--; i++, first = 0) {
1035 err = -EINVAL;
1040 if ((min && val < *min) || (max && val > *max)) {
1041 err = -EINVAL;
1058 return err ? : -EINVAL;
1059 *lenp -= left;
1069 return __do_proc_doulongvec_minmax(table->data, table, write,
1074 * proc_doulongvec_minmax - read a vector of long integers with min/max values
1081 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1085 * table->extra1 (min) and table->extra2 (max).
1096 * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values
1103 * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long
1108 * table->extra1 (min) and table->extra2 (max).
1128 WRITE_ONCE(*valp, -*lvalp * HZ);
1136 lval = -(unsigned long)val;
1153 *valp = clock_t_to_jiffies(*negp ? -*lvalp : *lvalp);
1159 lval = -(unsigned long)val;
1174 unsigned long jif = msecs_to_jiffies(*negp ? -*lvalp : *lvalp);
1184 lval = -(unsigned long)val;
1201 * bounds-check it before touching *valp.
1210 if ((param->min && *param->min > tmp) ||
1211 (param->max && *param->max < tmp))
1212 return -EINVAL;
1219 * proc_dointvec_jiffies - read a vector of integers as seconds
1226 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1244 .min = (int *) table->extra1,
1245 .max = (int *) table->extra2,
1252 * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds
1259 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1274 * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds
1281 * Reads/writes up to table->maxlen/sizeof(unsigned int) integer
1311 return -ESRCH;
1318 * proc_do_large_bitmap - read/write from/to a large bitmap
1325 * The bitmap is stored at table->data and the bitmap length (in bits)
1326 * in table->maxlen.
1328 * We use a range comma separated format (e.g. 1,3-4,10-10) so that
1339 unsigned long bitmap_len = table->maxlen;
1340 unsigned long *bitmap = *(unsigned long **) table->data;
1342 char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c;
1353 if (left > PAGE_SIZE - 1) {
1354 left = PAGE_SIZE - 1;
1356 skipped = *lenp - left;
1361 return -ENOMEM;
1368 /* In case we stop parsing mid-number, we can reset */
1374 * only one char is left (may be a "-"), then stop here,
1385 err = -EINVAL;
1392 left--;
1395 if (c == '-') {
1412 err = -EINVAL;
1417 left--;
1421 bitmap_set(tmp_bitmap, val_a, val_b - val_a + 1);
1434 bit_a + 1) - 1;
1440 proc_put_char(&buffer, &left, '-');
1456 *lenp -= left;
1469 return -ENOSYS;
1475 return -ENOSYS;
1481 return -ENOSYS;
1487 return -ENOSYS;
1493 return -ENOSYS;
1499 return -ENOSYS;
1505 return -ENOSYS;
1511 return -ENOSYS;
1517 return -ENOSYS;
1523 return -ENOSYS;
1529 return -ENOSYS;
1535 return -ENOSYS;
1541 return -ENOSYS;
1547 return -ENOSYS;
1556 struct static_key *key = (struct static_key *)table->data;
1562 .mode = table->mode,
1568 return -EPERM;
1603 .procname = "soft-power",
1612 .procname = "unaligned-trap",
1666 .procname = "threads-max",
1725 .procname = "ignore-unaligned-usertrap",
1772 * exception granted :-)