/* * 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;	int overflow; 	res = 0;	rv = 0;	overflow = 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))				overflow = 1;		}		res = res * base + val;		rv++;		s++;	}	*p = res;	if (overflow)		rv |= KSTRTOX_OVERFLOW;	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;	rv &= ~KSTRTOX_OVERFLOW;	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); #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);