[mirror_ubuntu-jammy-kernel.git] / lib / kstrtox.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Convert integer string representation to an integer.
 * If an integer doesn't fit into specified type, -E is returned.
 *
 * Integer starts with optional sign.
 * kstrtou*() functions do not accept sign "-".
 *
 * Radix 0 means autodetection: leading "0x" implies radix 16,
 * leading "0" implies radix 8, otherwise radix is 10.
 * Autodetection hints work after optional sign, but not before.
 *
 * If -E is returned, result is not touched.
 */
#include <linux/ctype.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/math64.h>
#include <linux/export.h>
#include <linux/types.h>
#include <linux/uaccess.h>
#include "kstrtox.h"

const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
{
	if (*base == 0) {
		if (s[0] == '0') {
			if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
				*base = 16;
			else
				*base = 8;
		} else
			*base = 10;
	}
	if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
		s += 2;
	return s;
}

/*
 * Convert non-negative integer string representation in explicitly given radix
 * to an integer. A maximum of max_chars characters will be converted.
 *
 * Return number of characters consumed maybe or-ed with overflow bit.
 * If overflow occurs, result integer (incorrect) is still returned.
 *
 * Don't you dare use this function.
 */
unsigned int _parse_integer_limit(const char *s, unsigned int base, unsigned long long *p,
				  size_t max_chars)
{
	unsigned long long res;
	unsigned int rv;

	res = 0;
	rv = 0;
	while (max_chars--) {
		unsigned int c = *s;
		unsigned int lc = c | 0x20; /* don't tolower() this line */
		unsigned int val;

		if ('0' <= c && c <= '9')
			val = c - '0';
		else if ('a' <= lc && lc <= 'f')
			val = lc - 'a' + 10;
		else
			break;

		if (val >= base)
			break;
		/*
		 * Check for overflow only if we are within range of
		 * it in the max base we support (16)
		 */
		if (unlikely(res & (~0ull << 60))) {
			if (res > div_u64(ULLONG_MAX - val, base))
				rv |= KSTRTOX_OVERFLOW;
		}
		res = res * base + val;
		rv++;
		s++;
	}
	*p = res;
	return rv;
}

unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *p)
{
	return _parse_integer_limit(s, base, p, INT_MAX);
}

static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
{
	unsigned long long _res;
	unsigned int rv;

	s = _parse_integer_fixup_radix(s, &base);
	rv = _parse_integer(s, base, &_res);
	if (rv & KSTRTOX_OVERFLOW)
		return -ERANGE;
	if (rv == 0)
		return -EINVAL;
	s += rv;
	if (*s == '\n')
		s++;
	if (*s)
		return -EINVAL;
	*res = _res;
	return 0;
}

/**
 * kstrtoull - convert a string to an unsigned long long
 * @s: The start of the string. The string must be null-terminated, and may also
 *  include a single newline before its terminating null. The first character
 *  may also be a plus sign, but not a minus sign.
 * @base: The number base to use. The maximum supported base is 16. If base is
 *  given as 0, then the base of the string is automatically detected with the
 *  conventional semantics - If it begins with 0x the number will be parsed as a
 *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 * @res: Where to write the result of the conversion on success.
 *
 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 * Preferred over simple_strtoull(). Return code must be checked.
 */
int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
{
	if (s[0] == '+')
		s++;
	return _kstrtoull(s, base, res);
}
EXPORT_SYMBOL(kstrtoull);

/**
 * kstrtoll - convert a string to a long long
 * @s: The start of the string. The string must be null-terminated, and may also
 *  include a single newline before its terminating null. The first character
 *  may also be a plus sign or a minus sign.
 * @base: The number base to use. The maximum supported base is 16. If base is
 *  given as 0, then the base of the string is automatically detected with the
 *  conventional semantics - If it begins with 0x the number will be parsed as a
 *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 * @res: Where to write the result of the conversion on success.
 *
 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 * Preferred over simple_strtoll(). Return code must be checked.
 */
int kstrtoll(const char *s, unsigned int base, long long *res)
{
	unsigned long long tmp;
	int rv;

	if (s[0] == '-') {
		rv = _kstrtoull(s + 1, base, &tmp);
		if (rv < 0)
			return rv;
		if ((long long)-tmp > 0)
			return -ERANGE;
		*res = -tmp;
	} else {
		rv = kstrtoull(s, base, &tmp);
		if (rv < 0)
			return rv;
		if ((long long)tmp < 0)
			return -ERANGE;
		*res = tmp;
	}
	return 0;
}
EXPORT_SYMBOL(kstrtoll);

/* Internal, do not use. */
int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
{
	unsigned long long tmp;
	int rv;

	rv = kstrtoull(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (unsigned long)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(_kstrtoul);

/* Internal, do not use. */
int _kstrtol(const char *s, unsigned int base, long *res)
{
	long long tmp;
	int rv;

	rv = kstrtoll(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (long)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(_kstrtol);

/**
 * kstrtouint - convert a string to an unsigned int
 * @s: The start of the string. The string must be null-terminated, and may also
 *  include a single newline before its terminating null. The first character
 *  may also be a plus sign, but not a minus sign.
 * @base: The number base to use. The maximum supported base is 16. If base is
 *  given as 0, then the base of the string is automatically detected with the
 *  conventional semantics - If it begins with 0x the number will be parsed as a
 *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 * @res: Where to write the result of the conversion on success.
 *
 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 * Preferred over simple_strtoul(). Return code must be checked.
 */
int kstrtouint(const char *s, unsigned int base, unsigned int *res)
{
	unsigned long long tmp;
	int rv;

	rv = kstrtoull(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (unsigned int)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtouint);

/**
 * kstrtoint - convert a string to an int
 * @s: The start of the string. The string must be null-terminated, and may also
 *  include a single newline before its terminating null. The first character
 *  may also be a plus sign or a minus sign.
 * @base: The number base to use. The maximum supported base is 16. If base is
 *  given as 0, then the base of the string is automatically detected with the
 *  conventional semantics - If it begins with 0x the number will be parsed as a
 *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 * @res: Where to write the result of the conversion on success.
 *
 * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 * Preferred over simple_strtol(). Return code must be checked.
 */
int kstrtoint(const char *s, unsigned int base, int *res)
{
	long long tmp;
	int rv;

	rv = kstrtoll(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (int)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtoint);

int kstrtou16(const char *s, unsigned int base, u16 *res)
{
	unsigned long long tmp;
	int rv;

	rv = kstrtoull(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (u16)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtou16);

int kstrtos16(const char *s, unsigned int base, s16 *res)
{
	long long tmp;
	int rv;

	rv = kstrtoll(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (s16)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtos16);

int kstrtou8(const char *s, unsigned int base, u8 *res)
{
	unsigned long long tmp;
	int rv;

	rv = kstrtoull(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (u8)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtou8);

int kstrtos8(const char *s, unsigned int base, s8 *res)
{
	long long tmp;
	int rv;

	rv = kstrtoll(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (s8)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtos8);

/**
 * kstrtobool - convert common user inputs into boolean values
 * @s: input string
 * @res: result
 *
 * This routine returns 0 iff the first character is one of 'Yy1Nn0', or
 * [oO][NnFf] for "on" and "off". Otherwise it will return -EINVAL.  Value
 * pointed to by res is updated upon finding a match.
 */
int kstrtobool(const char *s, bool *res)
{
	if (!s)
		return -EINVAL;

	switch (s[0]) {
	case 'y':
	case 'Y':
	case '1':
		*res = true;
		return 0;
	case 'n':
	case 'N':
	case '0':
		*res = false;
		return 0;
	case 'o':
	case 'O':
		switch (s[1]) {
		case 'n':
		case 'N':
			*res = true;
			return 0;
		case 'f':
		case 'F':
			*res = false;
			return 0;
		default:
			break;
		}
		break;
	default:
		break;
	}

	return -EINVAL;
}
EXPORT_SYMBOL(kstrtobool);

/*
 * Since "base" would be a nonsense argument, this open-codes the
 * _from_user helper instead of using the helper macro below.
 */
int kstrtobool_from_user(const char __user *s, size_t count, bool *res)
{
	/* Longest string needed to differentiate, newline, terminator */
	char buf[4];

	count = min(count, sizeof(buf) - 1);
	if (copy_from_user(buf, s, count))
		return -EFAULT;
	buf[count] = '\0';
	return kstrtobool(buf, res);
}
EXPORT_SYMBOL(kstrtobool_from_user);

#define kstrto_from_user(f, g, type)					\
int f(const char __user *s, size_t count, unsigned int base, type *res)	\
{									\
	/* sign, base 2 representation, newline, terminator */		\
	char buf[1 + sizeof(type) * 8 + 1 + 1];				\
									\
	count = min(count, sizeof(buf) - 1);				\
	if (copy_from_user(buf, s, count))				\
		return -EFAULT;						\
	buf[count] = '\0';						\
	return g(buf, base, res);					\
}									\
EXPORT_SYMBOL(f)

kstrto_from_user(kstrtoull_from_user,	kstrtoull,	unsigned long long);
kstrto_from_user(kstrtoll_from_user,	kstrtoll,	long long);
kstrto_from_user(kstrtoul_from_user,	kstrtoul,	unsigned long);
kstrto_from_user(kstrtol_from_user,	kstrtol,	long);
kstrto_from_user(kstrtouint_from_user,	kstrtouint,	unsigned int);
kstrto_from_user(kstrtoint_from_user,	kstrtoint,	int);
kstrto_from_user(kstrtou16_from_user,	kstrtou16,	u16);
kstrto_from_user(kstrtos16_from_user,	kstrtos16,	s16);
kstrto_from_user(kstrtou8_from_user,	kstrtou8,	u8);
kstrto_from_user(kstrtos8_from_user,	kstrtos8,	s8);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
33ee3b2e AD	2	/*
	3	* Convert integer string representation to an integer.
	4	* If an integer doesn't fit into specified type, -E is returned.
	5	*
	6	* Integer starts with optional sign.
	7	* kstrtou*() functions do not accept sign "-".
	8	*
	9	* Radix 0 means autodetection: leading "0x" implies radix 16,
	10	* leading "0" implies radix 8, otherwise radix is 10.
	11	* Autodetection hints work after optional sign, but not before.
	12	*
	13	* If -E is returned, result is not touched.
	14	*/
	15	#include <linux/ctype.h>
	16	#include <linux/errno.h>
	17	#include <linux/kernel.h>
	18	#include <linux/math64.h>
8bc3bcc9	19	#include <linux/export.h>
33ee3b2e	20	#include <linux/types.h>
7c0f6ba6	21	#include <linux/uaccess.h>
1dff46d6	22	#include "kstrtox.h"
33ee3b2e	23
1dff46d6	24	const char _parse_integer_fixup_radix(const char s, unsigned int *base)
33ee3b2e	25	{
1dff46d6	26	if (*base == 0) {
33ee3b2e AD	27	if (s[0] == '0') {
33ee3b2e AD	28	if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
1dff46d6	29	*base = 16;
33ee3b2e	30	else
1dff46d6	31	*base = 8;
33ee3b2e	32	} else
1dff46d6	33	*base = 10;
33ee3b2e	34	}
1dff46d6	35	if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
33ee3b2e	36	s += 2;
1dff46d6 AD	37	return s;
	38	}
	39
	40	/*
	41	* Convert non-negative integer string representation in explicitly given radix
900fdc45 RF	42	* to an integer. A maximum of max_chars characters will be converted.
900fdc45 RF	43	*
1dff46d6 AD	44	* Return number of characters consumed maybe or-ed with overflow bit.
	45	* If overflow occurs, result integer (incorrect) is still returned.
	46	*
	47	* Don't you dare use this function.
	48	*/
900fdc45 RF	49	unsigned int _parse_integer_limit(const char s, unsigned int base, unsigned long long p,
900fdc45 RF	50	size_t max_chars)
1dff46d6	51	{
690d137f	52	unsigned long long res;
1dff46d6	53	unsigned int rv;
33ee3b2e	54
690d137f	55	res = 0;
1dff46d6	56	rv = 0;
900fdc45	57	while (max_chars--) {
be5f3c77 AD	58	unsigned int c = *s;
be5f3c77 AD	59	unsigned int lc = c \| 0x20; /* don't tolower() this line */
33ee3b2e AD	60	unsigned int val;
33ee3b2e AD	61
be5f3c77 AD	62	if ('0' <= c && c <= '9')
	63	val = c - '0';
	64	else if ('a' <= lc && lc <= 'f')
	65	val = lc - 'a' + 10;
78be959e	66	else
1dff46d6	67	break;
33ee3b2e AD	68
33ee3b2e AD	69	if (val >= base)
1dff46d6	70	break;
690d137f DH	71	/*
	72	* Check for overflow only if we are within range of
	73	* it in the max base we support (16)
	74	*/
	75	if (unlikely(res & (~0ull << 60))) {
	76	if (res > div_u64(ULLONG_MAX - val, base))
8cfd56d4	77	rv \|= KSTRTOX_OVERFLOW;
690d137f DH	78	}
690d137f DH	79	res = res * base + val;
1dff46d6	80	rv++;
33ee3b2e AD	81	s++;
33ee3b2e AD	82	}
690d137f	83	*p = res;
1dff46d6 AD	84	return rv;
	85	}
	86
900fdc45 RF	87	unsigned int _parse_integer(const char s, unsigned int base, unsigned long long p)
	88	{
	89	return _parse_integer_limit(s, base, p, INT_MAX);
	90	}
	91
1dff46d6 AD	92	static int _kstrtoull(const char s, unsigned int base, unsigned long long res)
	93	{
	94	unsigned long long _res;
	95	unsigned int rv;
	96
	97	s = _parse_integer_fixup_radix(s, &base);
	98	rv = _parse_integer(s, base, &_res);
	99	if (rv & KSTRTOX_OVERFLOW)
	100	return -ERANGE;
1dff46d6 AD	101	if (rv == 0)
	102	return -EINVAL;
	103	s += rv;
	104	if (*s == '\n')
	105	s++;
	106	if (*s)
33ee3b2e	107	return -EINVAL;
1dff46d6	108	*res = _res;
33ee3b2e AD	109	return 0;
	110	}
	111
4c925d60 EZ	112	/**
	113	* kstrtoull - convert a string to an unsigned long long
	114	* @s: The start of the string. The string must be null-terminated, and may also
	115	* include a single newline before its terminating null. The first character
	116	* may also be a plus sign, but not a minus sign.
	117	* @base: The number base to use. The maximum supported base is 16. If base is
	118	* given as 0, then the base of the string is automatically detected with the
	119	* conventional semantics - If it begins with 0x the number will be parsed as a
	120	* hexadecimal (case insensitive), if it otherwise begins with 0, it will be
	121	* parsed as an octal number. Otherwise it will be parsed as a decimal.
	122	* @res: Where to write the result of the conversion on success.
	123	*
	124	* Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
ef0f2685	125	* Preferred over simple_strtoull(). Return code must be checked.
4c925d60	126	*/
33ee3b2e AD	127	int kstrtoull(const char s, unsigned int base, unsigned long long res)
	128	{
	129	if (s[0] == '+')
	130	s++;
	131	return _kstrtoull(s, base, res);
	132	}
	133	EXPORT_SYMBOL(kstrtoull);
	134
4c925d60 EZ	135	/**
	136	* kstrtoll - convert a string to a long long
	137	* @s: The start of the string. The string must be null-terminated, and may also
	138	* include a single newline before its terminating null. The first character
	139	* may also be a plus sign or a minus sign.
	140	* @base: The number base to use. The maximum supported base is 16. If base is
	141	* given as 0, then the base of the string is automatically detected with the
	142	* conventional semantics - If it begins with 0x the number will be parsed as a
	143	* hexadecimal (case insensitive), if it otherwise begins with 0, it will be
	144	* parsed as an octal number. Otherwise it will be parsed as a decimal.
	145	* @res: Where to write the result of the conversion on success.
	146	*
	147	* Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
ef0f2685	148	* Preferred over simple_strtoll(). Return code must be checked.
4c925d60	149	*/
33ee3b2e AD	150	int kstrtoll(const char s, unsigned int base, long long res)
	151	{
	152	unsigned long long tmp;
	153	int rv;
	154
	155	if (s[0] == '-') {
	156	rv = _kstrtoull(s + 1, base, &tmp);
	157	if (rv < 0)
	158	return rv;
2d2e4715	159	if ((long long)-tmp > 0)
33ee3b2e AD	160	return -ERANGE;
	161	*res = -tmp;
	162	} else {
	163	rv = kstrtoull(s, base, &tmp);
	164	if (rv < 0)
	165	return rv;
	166	if ((long long)tmp < 0)
	167	return -ERANGE;
	168	*res = tmp;
	169	}
	170	return 0;
	171	}
	172	EXPORT_SYMBOL(kstrtoll);
	173
	174	/* Internal, do not use. */
	175	int _kstrtoul(const char s, unsigned int base, unsigned long res)
	176	{
	177	unsigned long long tmp;
	178	int rv;
	179
	180	rv = kstrtoull(s, base, &tmp);
	181	if (rv < 0)
	182	return rv;
048e513d	183	if (tmp != (unsigned long)tmp)
33ee3b2e AD	184	return -ERANGE;
	185	*res = tmp;
	186	return 0;
	187	}
	188	EXPORT_SYMBOL(_kstrtoul);
	189
	190	/* Internal, do not use. */
	191	int _kstrtol(const char s, unsigned int base, long res)
	192	{
	193	long long tmp;
	194	int rv;
	195
	196	rv = kstrtoll(s, base, &tmp);
	197	if (rv < 0)
	198	return rv;
048e513d	199	if (tmp != (long)tmp)
33ee3b2e AD	200	return -ERANGE;
	201	*res = tmp;
	202	return 0;
	203	}
	204	EXPORT_SYMBOL(_kstrtol);
	205
4c925d60 EZ	206	/**
	207	* kstrtouint - convert a string to an unsigned int
	208	* @s: The start of the string. The string must be null-terminated, and may also
	209	* include a single newline before its terminating null. The first character
	210	* may also be a plus sign, but not a minus sign.
	211	* @base: The number base to use. The maximum supported base is 16. If base is
	212	* given as 0, then the base of the string is automatically detected with the
	213	* conventional semantics - If it begins with 0x the number will be parsed as a
	214	* hexadecimal (case insensitive), if it otherwise begins with 0, it will be
	215	* parsed as an octal number. Otherwise it will be parsed as a decimal.
	216	* @res: Where to write the result of the conversion on success.
	217	*
	218	* Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
ef0f2685	219	* Preferred over simple_strtoul(). Return code must be checked.
4c925d60	220	*/
33ee3b2e AD	221	int kstrtouint(const char s, unsigned int base, unsigned int res)
	222	{
	223	unsigned long long tmp;
	224	int rv;
	225
	226	rv = kstrtoull(s, base, &tmp);
	227	if (rv < 0)
	228	return rv;
048e513d	229	if (tmp != (unsigned int)tmp)
33ee3b2e AD	230	return -ERANGE;
	231	*res = tmp;
	232	return 0;
	233	}
	234	EXPORT_SYMBOL(kstrtouint);
	235
4c925d60 EZ	236	/**
	237	* kstrtoint - convert a string to an int
	238	* @s: The start of the string. The string must be null-terminated, and may also
	239	* include a single newline before its terminating null. The first character
	240	* may also be a plus sign or a minus sign.
	241	* @base: The number base to use. The maximum supported base is 16. If base is
	242	* given as 0, then the base of the string is automatically detected with the
	243	* conventional semantics - If it begins with 0x the number will be parsed as a
	244	* hexadecimal (case insensitive), if it otherwise begins with 0, it will be
	245	* parsed as an octal number. Otherwise it will be parsed as a decimal.
	246	* @res: Where to write the result of the conversion on success.
	247	*
	248	* Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
ef0f2685	249	* Preferred over simple_strtol(). Return code must be checked.
4c925d60	250	*/
33ee3b2e AD	251	int kstrtoint(const char s, unsigned int base, int res)
	252	{
	253	long long tmp;
	254	int rv;
	255
	256	rv = kstrtoll(s, base, &tmp);
	257	if (rv < 0)
	258	return rv;
048e513d	259	if (tmp != (int)tmp)
33ee3b2e AD	260	return -ERANGE;
	261	*res = tmp;
	262	return 0;
	263	}
	264	EXPORT_SYMBOL(kstrtoint);
	265
	266	int kstrtou16(const char s, unsigned int base, u16 res)
	267	{
	268	unsigned long long tmp;
	269	int rv;
	270
	271	rv = kstrtoull(s, base, &tmp);
	272	if (rv < 0)
	273	return rv;
048e513d	274	if (tmp != (u16)tmp)
33ee3b2e AD	275	return -ERANGE;
	276	*res = tmp;
	277	return 0;
	278	}
	279	EXPORT_SYMBOL(kstrtou16);
	280
	281	int kstrtos16(const char s, unsigned int base, s16 res)
	282	{
	283	long long tmp;
	284	int rv;
	285
	286	rv = kstrtoll(s, base, &tmp);
	287	if (rv < 0)
	288	return rv;
048e513d	289	if (tmp != (s16)tmp)
33ee3b2e AD	290	return -ERANGE;
	291	*res = tmp;
	292	return 0;
	293	}
	294	EXPORT_SYMBOL(kstrtos16);
	295
	296	int kstrtou8(const char s, unsigned int base, u8 res)
	297	{
	298	unsigned long long tmp;
	299	int rv;
	300
	301	rv = kstrtoull(s, base, &tmp);
	302	if (rv < 0)
	303	return rv;
048e513d	304	if (tmp != (u8)tmp)
33ee3b2e AD	305	return -ERANGE;
	306	*res = tmp;
	307	return 0;
	308	}
	309	EXPORT_SYMBOL(kstrtou8);
	310
	311	int kstrtos8(const char s, unsigned int base, s8 res)
	312	{
	313	long long tmp;
	314	int rv;
	315
	316	rv = kstrtoll(s, base, &tmp);
	317	if (rv < 0)
	318	return rv;
048e513d	319	if (tmp != (s8)tmp)
33ee3b2e AD	320	return -ERANGE;
	321	*res = tmp;
	322	return 0;
	323	}
	324	EXPORT_SYMBOL(kstrtos8);
c196e32a	325
ef951599 KC	326	/**
	327	* kstrtobool - convert common user inputs into boolean values
	328	* @s: input string
	329	* @res: result
	330	*
a81a5a17 KC	331	* This routine returns 0 iff the first character is one of 'Yy1Nn0', or
	332	* [oO][NnFf] for "on" and "off". Otherwise it will return -EINVAL. Value
	333	* pointed to by res is updated upon finding a match.
ef951599 KC	334	*/
	335	int kstrtobool(const char s, bool res)
	336	{
	337	if (!s)
	338	return -EINVAL;
	339
	340	switch (s[0]) {
	341	case 'y':
	342	case 'Y':
	343	case '1':
	344	*res = true;
	345	return 0;
	346	case 'n':
	347	case 'N':
	348	case '0':
	349	*res = false;
	350	return 0;
a81a5a17 KC	351	case 'o':
	352	case 'O':
	353	switch (s[1]) {
	354	case 'n':
	355	case 'N':
	356	*res = true;
	357	return 0;
	358	case 'f':
	359	case 'F':
	360	*res = false;
	361	return 0;
	362	default:
	363	break;
	364	}
36f9ff9e	365	break;
ef951599 KC	366	default:
	367	break;
	368	}
	369
	370	return -EINVAL;
	371	}
	372	EXPORT_SYMBOL(kstrtobool);
	373
	374	/*
	375	* Since "base" would be a nonsense argument, this open-codes the
	376	* _from_user helper instead of using the helper macro below.
	377	*/
	378	int kstrtobool_from_user(const char __user s, size_t count, bool res)
	379	{
	380	/* Longest string needed to differentiate, newline, terminator */
	381	char buf[4];
	382
	383	count = min(count, sizeof(buf) - 1);
	384	if (copy_from_user(buf, s, count))
	385	return -EFAULT;
	386	buf[count] = '\0';
	387	return kstrtobool(buf, res);
	388	}
	389	EXPORT_SYMBOL(kstrtobool_from_user);
	390
c196e32a AD	391	#define kstrto_from_user(f, g, type) \
	392	int f(const char __user s, size_t count, unsigned int base, type res) \
	393	{ \
	394	/* sign, base 2 representation, newline, terminator */ \
	395	char buf[1 + sizeof(type) * 8 + 1 + 1]; \
	396	\
	397	count = min(count, sizeof(buf) - 1); \
	398	if (copy_from_user(buf, s, count)) \
	399	return -EFAULT; \
	400	buf[count] = '\0'; \
	401	return g(buf, base, res); \
	402	} \
	403	EXPORT_SYMBOL(f)
	404
	405	kstrto_from_user(kstrtoull_from_user, kstrtoull, unsigned long long);
	406	kstrto_from_user(kstrtoll_from_user, kstrtoll, long long);
	407	kstrto_from_user(kstrtoul_from_user, kstrtoul, unsigned long);
	408	kstrto_from_user(kstrtol_from_user, kstrtol, long);
	409	kstrto_from_user(kstrtouint_from_user, kstrtouint, unsigned int);
	410	kstrto_from_user(kstrtoint_from_user, kstrtoint, int);
	411	kstrto_from_user(kstrtou16_from_user, kstrtou16, u16);
	412	kstrto_from_user(kstrtos16_from_user, kstrtos16, s16);
	413	kstrto_from_user(kstrtou8_from_user, kstrtou8, u8);
	414	kstrto_from_user(kstrtos8_from_user, kstrtos8, s8);