[linux.git] / lib / kstrtox.c

/*
 * 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 <asm/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.
 * 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(const char *s, unsigned int base, unsigned long long *p)
{
	unsigned long long res;
	unsigned int rv;

	res = 0;
	rv = 0;
	while (*s) {
		unsigned int val;

		if ('0' <= *s && *s <= '9')
			val = *s - '0';
		else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
			val = _tolower(*s) - '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;
}

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