Eric Lee / linux-smarc-t335x-v3.2

1
Download as
Browse Code ยป

Commit 33ee3b2e2eb9b4b6c64dcf9ed66e2ac3124e748c

Authored by Alexey Dobriyan
Committed by Linus Torvalds
1 parent 8a5700cd67
Exists in master and in 4 other branches v3.2_AM335xPSP_04.06.00.11, v3.2_NEWT335xPSP_04.06.00.11, v3.2_SBC_SMARTMEN, v3.2_SMARCT335xPSP_04.06.00.11

kstrto*: converting strings to integers done (hopefully) right 

1. simple_strto*() do not contain overflow checks and crufty,
   libc way to indicate failure.
2. strict_strto*() also do not have overflow checks but the name and
   comments pretend they do.
3. Both families have only "long long" and "long" variants,
   but users want strtou8()
4. Both "simple" and "strict" prefixes are wrong:
   Simple doesn't exactly say what's so simple, strict should not exist
   because conversion should be strict by default.

The solution is to use "k" prefix and add convertors for more types.
Enter
	kstrtoull()
	kstrtoll()
	kstrtoul()
	kstrtol()
	kstrtouint()
	kstrtoint()

	kstrtou64()
	kstrtos64()
	kstrtou32()
	kstrtos32()
	kstrtou16()
	kstrtos16()
	kstrtou8()
	kstrtos8()

Include runtime testsuite (somewhat incomplete) as well.

strict_strto*() become deprecated, stubbed to kstrto*() and
eventually will be removed altogether.

Use kstrto*() in code today!

Note: on some archs _kstrtoul() and _kstrtol() are left in tree, even if
      they'll be unused at runtime. This is temporarily solution,
      because I don't want to hardcode list of archs where these
      functions aren't needed. Current solution with sizeof() and
      __alignof__ at least always works.

Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 8 changed files with 1039 additions and 150 deletions Side-by-side Diff

drivers/video/via/viafbdev.h
Diff comments   View file @ 33ee3b2
... ... @@ -94,9 +94,6 @@
94 94 extern int viafb_DVI_ON;
95 95 extern int viafb_hotplug;
96 96  
97   -extern int strict_strtoul(const char *cp, unsigned int base,
98   - unsigned long *res);
99   -
100 97 u8 viafb_gpio_i2c_read_lvds(struct lvds_setting_information
101 98 *plvds_setting_info, struct lvds_chip_information
102 99 *plvds_chip_info, u8 index);
include/linux/kernel.h
Diff comments   View file @ 33ee3b2
... ... @@ -187,14 +187,76 @@
187 187 ATTRIB_NORET;
188 188 NORET_TYPE void complete_and_exit(struct completion *, long)
189 189 ATTRIB_NORET;
  190 +
  191 +/* Internal, do not use. */
  192 +int __must_check _kstrtoul(const char *s, unsigned int base, unsigned long *res);
  193 +int __must_check _kstrtol(const char *s, unsigned int base, long *res);
  194 +
  195 +int __must_check kstrtoull(const char *s, unsigned int base, unsigned long long *res);
  196 +int __must_check kstrtoll(const char *s, unsigned int base, long long *res);
  197 +static inline int __must_check kstrtoul(const char *s, unsigned int base, unsigned long *res)
  198 +{
  199 + /*
  200 + * We want to shortcut function call, but
  201 + * __builtin_types_compatible_p(unsigned long, unsigned long long) = 0.
  202 + */
  203 + if (sizeof(unsigned long) == sizeof(unsigned long long) &&
  204 + __alignof__(unsigned long) == __alignof__(unsigned long long))
  205 + return kstrtoull(s, base, (unsigned long long *)res);
  206 + else
  207 + return _kstrtoul(s, base, res);
  208 +}
  209 +
  210 +static inline int __must_check kstrtol(const char *s, unsigned int base, long *res)
  211 +{
  212 + /*
  213 + * We want to shortcut function call, but
  214 + * __builtin_types_compatible_p(long, long long) = 0.
  215 + */
  216 + if (sizeof(long) == sizeof(long long) &&
  217 + __alignof__(long) == __alignof__(long long))
  218 + return kstrtoll(s, base, (long long *)res);
  219 + else
  220 + return _kstrtol(s, base, res);
  221 +}
  222 +
  223 +int __must_check kstrtouint(const char *s, unsigned int base, unsigned int *res);
  224 +int __must_check kstrtoint(const char *s, unsigned int base, int *res);
  225 +
  226 +static inline int __must_check kstrtou64(const char *s, unsigned int base, u64 *res)
  227 +{
  228 + return kstrtoull(s, base, res);
  229 +}
  230 +
  231 +static inline int __must_check kstrtos64(const char *s, unsigned int base, s64 *res)
  232 +{
  233 + return kstrtoll(s, base, res);
  234 +}
  235 +
  236 +static inline int __must_check kstrtou32(const char *s, unsigned int base, u32 *res)
  237 +{
  238 + return kstrtouint(s, base, res);
  239 +}
  240 +
  241 +static inline int __must_check kstrtos32(const char *s, unsigned int base, s32 *res)
  242 +{
  243 + return kstrtoint(s, base, res);
  244 +}
  245 +
  246 +int __must_check kstrtou16(const char *s, unsigned int base, u16 *res);
  247 +int __must_check kstrtos16(const char *s, unsigned int base, s16 *res);
  248 +int __must_check kstrtou8(const char *s, unsigned int base, u8 *res);
  249 +int __must_check kstrtos8(const char *s, unsigned int base, s8 *res);
  250 +
190 251 extern unsigned long simple_strtoul(const char *,char **,unsigned int);
191 252 extern long simple_strtol(const char *,char **,unsigned int);
192 253 extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
193 254 extern long long simple_strtoll(const char *,char **,unsigned int);
194   -extern int __must_check strict_strtoul(const char *, unsigned int, unsigned long *);
195   -extern int __must_check strict_strtol(const char *, unsigned int, long *);
196   -extern int __must_check strict_strtoull(const char *, unsigned int, unsigned long long *);
197   -extern int __must_check strict_strtoll(const char *, unsigned int, long long *);
  255 +#define strict_strtoul kstrtoul
  256 +#define strict_strtol kstrtol
  257 +#define strict_strtoull kstrtoull
  258 +#define strict_strtoll kstrtoll
  259 +
198 260 extern int sprintf(char * buf, const char * fmt, ...)
199 261 __attribute__ ((format (printf, 2, 3)));
200 262 extern int vsprintf(char *buf, const char *, va_list)
... ... @@ -1250,4 +1250,7 @@
1250 1250 source "lib/Kconfig.kgdb"
1251 1251  
1252 1252 source "lib/Kconfig.kmemcheck"
  1253 +
  1254 +config TEST_KSTRTOX
  1255 + tristate "Test kstrto*() family of functions at runtime"
... ... @@ -22,6 +22,8 @@
22 22 obj-y += bcd.o div64.o sort.o parser.o halfmd4.o debug_locks.o random32.o \
23 23 bust_spinlocks.o hexdump.o kasprintf.o bitmap.o scatterlist.o \
24 24 string_helpers.o gcd.o lcm.o list_sort.o uuid.o flex_array.o
  25 +obj-y += kstrtox.o
  26 +obj-$(CONFIG_TEST_KSTRTOX) += test-kstrtox.o
25 27  
26 28 ifeq ($(CONFIG_DEBUG_KOBJECT),y)
27 29 CFLAGS_kobject.o += -DDEBUG
  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>
  18 +#include <linux/module.h>
  19 +#include <linux/types.h>
  20 +
  21 +static inline char _tolower(const char c)
  22 +{
  23 + return c | 0x20;
  24 +}
  25 +
  26 +static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
  27 +{
  28 + unsigned long long acc;
  29 + int ok;
  30 +
  31 + if (base == 0) {
  32 + if (s[0] == '0') {
  33 + if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
  34 + base = 16;
  35 + else
  36 + base = 8;
  37 + } else
  38 + base = 10;
  39 + }
  40 + if (base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
  41 + s += 2;
  42 +
  43 + acc = 0;
  44 + ok = 0;
  45 + while (*s) {
  46 + unsigned int val;
  47 +
  48 + if ('0' <= *s && *s <= '9')
  49 + val = *s - '0';
  50 + else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
  51 + val = _tolower(*s) - 'a' + 10;
  52 + else if (*s == '\n') {
  53 + if (*(s + 1) == '\0')
  54 + break;
  55 + else
  56 + return -EINVAL;
  57 + } else
  58 + return -EINVAL;
  59 +
  60 + if (val >= base)
  61 + return -EINVAL;
  62 + if (acc > div_u64(ULLONG_MAX - val, base))
  63 + return -ERANGE;
  64 + acc = acc * base + val;
  65 + ok = 1;
  66 +
  67 + s++;
  68 + }
  69 + if (!ok)
  70 + return -EINVAL;
  71 + *res = acc;
  72 + return 0;
  73 +}
  74 +
  75 +int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
  76 +{
  77 + if (s[0] == '+')
  78 + s++;
  79 + return _kstrtoull(s, base, res);
  80 +}
  81 +EXPORT_SYMBOL(kstrtoull);
  82 +
  83 +int kstrtoll(const char *s, unsigned int base, long long *res)
  84 +{
  85 + unsigned long long tmp;
  86 + int rv;
  87 +
  88 + if (s[0] == '-') {
  89 + rv = _kstrtoull(s + 1, base, &tmp);
  90 + if (rv < 0)
  91 + return rv;
  92 + if ((long long)(-tmp) >= 0)
  93 + return -ERANGE;
  94 + *res = -tmp;
  95 + } else {
  96 + rv = kstrtoull(s, base, &tmp);
  97 + if (rv < 0)
  98 + return rv;
  99 + if ((long long)tmp < 0)
  100 + return -ERANGE;
  101 + *res = tmp;
  102 + }
  103 + return 0;
  104 +}
  105 +EXPORT_SYMBOL(kstrtoll);
  106 +
  107 +/* Internal, do not use. */
  108 +int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
  109 +{
  110 + unsigned long long tmp;
  111 + int rv;
  112 +
  113 + rv = kstrtoull(s, base, &tmp);
  114 + if (rv < 0)
  115 + return rv;
  116 + if (tmp != (unsigned long long)(unsigned long)tmp)
  117 + return -ERANGE;
  118 + *res = tmp;
  119 + return 0;
  120 +}
  121 +EXPORT_SYMBOL(_kstrtoul);
  122 +
  123 +/* Internal, do not use. */
  124 +int _kstrtol(const char *s, unsigned int base, long *res)
  125 +{
  126 + long long tmp;
  127 + int rv;
  128 +
  129 + rv = kstrtoll(s, base, &tmp);
  130 + if (rv < 0)
  131 + return rv;
  132 + if (tmp != (long long)(long)tmp)
  133 + return -ERANGE;
  134 + *res = tmp;
  135 + return 0;
  136 +}
  137 +EXPORT_SYMBOL(_kstrtol);
  138 +
  139 +int kstrtouint(const char *s, unsigned int base, unsigned int *res)
  140 +{
  141 + unsigned long long tmp;
  142 + int rv;
  143 +
  144 + rv = kstrtoull(s, base, &tmp);
  145 + if (rv < 0)
  146 + return rv;
  147 + if (tmp != (unsigned long long)(unsigned int)tmp)
  148 + return -ERANGE;
  149 + *res = tmp;
  150 + return 0;
  151 +}
  152 +EXPORT_SYMBOL(kstrtouint);
  153 +
  154 +int kstrtoint(const char *s, unsigned int base, int *res)
  155 +{
  156 + long long tmp;
  157 + int rv;
  158 +
  159 + rv = kstrtoll(s, base, &tmp);
  160 + if (rv < 0)
  161 + return rv;
  162 + if (tmp != (long long)(int)tmp)
  163 + return -ERANGE;
  164 + *res = tmp;
  165 + return 0;
  166 +}
  167 +EXPORT_SYMBOL(kstrtoint);
  168 +
  169 +int kstrtou16(const char *s, unsigned int base, u16 *res)
  170 +{
  171 + unsigned long long tmp;
  172 + int rv;
  173 +
  174 + rv = kstrtoull(s, base, &tmp);
  175 + if (rv < 0)
  176 + return rv;
  177 + if (tmp != (unsigned long long)(u16)tmp)
  178 + return -ERANGE;
  179 + *res = tmp;
  180 + return 0;
  181 +}
  182 +EXPORT_SYMBOL(kstrtou16);
  183 +
  184 +int kstrtos16(const char *s, unsigned int base, s16 *res)
  185 +{
  186 + long long tmp;
  187 + int rv;
  188 +
  189 + rv = kstrtoll(s, base, &tmp);
  190 + if (rv < 0)
  191 + return rv;
  192 + if (tmp != (long long)(s16)tmp)
  193 + return -ERANGE;
  194 + *res = tmp;
  195 + return 0;
  196 +}
  197 +EXPORT_SYMBOL(kstrtos16);
  198 +
  199 +int kstrtou8(const char *s, unsigned int base, u8 *res)
  200 +{
  201 + unsigned long long tmp;
  202 + int rv;
  203 +
  204 + rv = kstrtoull(s, base, &tmp);
  205 + if (rv < 0)
  206 + return rv;
  207 + if (tmp != (unsigned long long)(u8)tmp)
  208 + return -ERANGE;
  209 + *res = tmp;
  210 + return 0;
  211 +}
  212 +EXPORT_SYMBOL(kstrtou8);
  213 +
  214 +int kstrtos8(const char *s, unsigned int base, s8 *res)
  215 +{
  216 + long long tmp;
  217 + int rv;
  218 +
  219 + rv = kstrtoll(s, base, &tmp);
  220 + if (rv < 0)
  221 + return rv;
  222 + if (tmp != (long long)(s8)tmp)
  223 + return -ERANGE;
  224 + *res = tmp;
  225 + return 0;
  226 +}
  227 +EXPORT_SYMBOL(kstrtos8);
  1 +#include <linux/init.h>
  2 +#include <linux/kernel.h>
  3 +#include <linux/module.h>
  4 +
  5 +#define for_each_test(i, test) \
  6 + for (i = 0; i < sizeof(test) / sizeof(test[0]); i++)
  7 +
  8 +struct test_fail {
  9 + const char *str;
  10 + unsigned int base;
  11 +};
  12 +
  13 +#define DEFINE_TEST_FAIL(test) \
  14 + const struct test_fail test[] __initdata
  15 +
  16 +#define DECLARE_TEST_OK(type, test_type) \
  17 + test_type { \
  18 + const char *str; \
  19 + unsigned int base; \
  20 + type expected_res; \
  21 + }
  22 +
  23 +#define DEFINE_TEST_OK(type, test) \
  24 + const type test[] __initdata
  25 +
  26 +#define TEST_FAIL(fn, type, fmt, test) \
  27 +{ \
  28 + unsigned int i; \
  29 + \
  30 + for_each_test(i, test) { \
  31 + const struct test_fail *t = &test[i]; \
  32 + type tmp; \
  33 + int rv; \
  34 + \
  35 + tmp = 0; \
  36 + rv = fn(t->str, t->base, &tmp); \
  37 + if (rv >= 0) { \
  38 + WARN(1, "str '%s', base %u, expected -E, got %d/" fmt "\n", \
  39 + t->str, t->base, rv, tmp); \
  40 + continue; \
  41 + } \
  42 + } \
  43 +}
  44 +
  45 +#define TEST_OK(fn, type, fmt, test) \
  46 +{ \
  47 + unsigned int i; \
  48 + \
  49 + for_each_test(i, test) { \
  50 + const typeof(test[0]) *t = &test[i]; \
  51 + type res; \
  52 + int rv; \
  53 + \
  54 + rv = fn(t->str, t->base, &res); \
  55 + if (rv != 0) { \
  56 + WARN(1, "str '%s', base %u, expected 0/" fmt ", got %d\n", \
  57 + t->str, t->base, t->expected_res, rv); \
  58 + continue; \
  59 + } \
  60 + if (res != t->expected_res) { \
  61 + WARN(1, "str '%s', base %u, expected " fmt ", got " fmt "\n", \
  62 + t->str, t->base, t->expected_res, res); \
  63 + continue; \
  64 + } \
  65 + } \
  66 +}
  67 +
  68 +static void __init test_kstrtoull_ok(void)
  69 +{
  70 + DECLARE_TEST_OK(unsigned long long, struct test_ull);
  71 + static DEFINE_TEST_OK(struct test_ull, test_ull_ok) = {
  72 + {"0", 10, 0ULL},
  73 + {"1", 10, 1ULL},
  74 + {"127", 10, 127ULL},
  75 + {"128", 10, 128ULL},
  76 + {"129", 10, 129ULL},
  77 + {"255", 10, 255ULL},
  78 + {"256", 10, 256ULL},
  79 + {"257", 10, 257ULL},
  80 + {"32767", 10, 32767ULL},
  81 + {"32768", 10, 32768ULL},
  82 + {"32769", 10, 32769ULL},
  83 + {"65535", 10, 65535ULL},
  84 + {"65536", 10, 65536ULL},
  85 + {"65537", 10, 65537ULL},
  86 + {"2147483647", 10, 2147483647ULL},
  87 + {"2147483648", 10, 2147483648ULL},
  88 + {"2147483649", 10, 2147483649ULL},
  89 + {"4294967295", 10, 4294967295ULL},
  90 + {"4294967296", 10, 4294967296ULL},
  91 + {"4294967297", 10, 4294967297ULL},
  92 + {"9223372036854775807", 10, 9223372036854775807ULL},
  93 + {"9223372036854775808", 10, 9223372036854775808ULL},
  94 + {"9223372036854775809", 10, 9223372036854775809ULL},
  95 + {"18446744073709551614", 10, 18446744073709551614ULL},
  96 + {"18446744073709551615", 10, 18446744073709551615ULL},
  97 +
  98 + {"00", 8, 00ULL},
  99 + {"01", 8, 01ULL},
  100 + {"0177", 8, 0177ULL},
  101 + {"0200", 8, 0200ULL},
  102 + {"0201", 8, 0201ULL},
  103 + {"0377", 8, 0377ULL},
  104 + {"0400", 8, 0400ULL},
  105 + {"0401", 8, 0401ULL},
  106 + {"077777", 8, 077777ULL},
  107 + {"0100000", 8, 0100000ULL},
  108 + {"0100001", 8, 0100001ULL},
  109 + {"0177777", 8, 0177777ULL},
  110 + {"0200000", 8, 0200000ULL},
  111 + {"0200001", 8, 0200001ULL},
  112 + {"017777777777", 8, 017777777777ULL},
  113 + {"020000000000", 8, 020000000000ULL},
  114 + {"020000000001", 8, 020000000001ULL},
  115 + {"037777777777", 8, 037777777777ULL},
  116 + {"040000000000", 8, 040000000000ULL},
  117 + {"040000000001", 8, 040000000001ULL},
  118 + {"0777777777777777777777", 8, 0777777777777777777777ULL},
  119 + {"01000000000000000000000", 8, 01000000000000000000000ULL},
  120 + {"01000000000000000000001", 8, 01000000000000000000001ULL},
  121 + {"01777777777777777777776", 8, 01777777777777777777776ULL},
  122 + {"01777777777777777777777", 8, 01777777777777777777777ULL},
  123 +
  124 + {"0x0", 16, 0x0ULL},
  125 + {"0x1", 16, 0x1ULL},
  126 + {"0x7f", 16, 0x7fULL},
  127 + {"0x80", 16, 0x80ULL},
  128 + {"0x81", 16, 0x81ULL},
  129 + {"0xff", 16, 0xffULL},
  130 + {"0x100", 16, 0x100ULL},
  131 + {"0x101", 16, 0x101ULL},
  132 + {"0x7fff", 16, 0x7fffULL},
  133 + {"0x8000", 16, 0x8000ULL},
  134 + {"0x8001", 16, 0x8001ULL},
  135 + {"0xffff", 16, 0xffffULL},
  136 + {"0x10000", 16, 0x10000ULL},
  137 + {"0x10001", 16, 0x10001ULL},
  138 + {"0x7fffffff", 16, 0x7fffffffULL},
  139 + {"0x80000000", 16, 0x80000000ULL},
  140 + {"0x80000001", 16, 0x80000001ULL},
  141 + {"0xffffffff", 16, 0xffffffffULL},
  142 + {"0x100000000", 16, 0x100000000ULL},
  143 + {"0x100000001", 16, 0x100000001ULL},
  144 + {"0x7fffffffffffffff", 16, 0x7fffffffffffffffULL},
  145 + {"0x8000000000000000", 16, 0x8000000000000000ULL},
  146 + {"0x8000000000000001", 16, 0x8000000000000001ULL},
  147 + {"0xfffffffffffffffe", 16, 0xfffffffffffffffeULL},
  148 + {"0xffffffffffffffff", 16, 0xffffffffffffffffULL},
  149 +
  150 + {"0\n", 0, 0ULL},
  151 + };
  152 + TEST_OK(kstrtoull, unsigned long long, "%llu", test_ull_ok);
  153 +}
  154 +
  155 +static void __init test_kstrtoull_fail(void)
  156 +{
  157 + static DEFINE_TEST_FAIL(test_ull_fail) = {
  158 + {"", 0},
  159 + {"", 8},
  160 + {"", 10},
  161 + {"", 16},
  162 + {"\n", 0},
  163 + {"\n", 8},
  164 + {"\n", 10},
  165 + {"\n", 16},
  166 + {"\n0", 0},
  167 + {"\n0", 8},
  168 + {"\n0", 10},
  169 + {"\n0", 16},
  170 + {"+", 0},
  171 + {"+", 8},
  172 + {"+", 10},
  173 + {"+", 16},
  174 + {"-", 0},
  175 + {"-", 8},
  176 + {"-", 10},
  177 + {"-", 16},
  178 + {"0x", 0},
  179 + {"0x", 16},
  180 + {"0X", 0},
  181 + {"0X", 16},
  182 + {"0 ", 0},
  183 + {"1+", 0},
  184 + {"1-", 0},
  185 + {" 2", 0},
  186 + /* base autodetection */
  187 + {"0x0z", 0},
  188 + {"0z", 0},
  189 + {"a", 0},
  190 + /* digit >= base */
  191 + {"2", 2},
  192 + {"8", 8},
  193 + {"a", 10},
  194 + {"A", 10},
  195 + {"g", 16},
  196 + {"G", 16},
  197 + /* overflow */
  198 + {"10000000000000000000000000000000000000000000000000000000000000000", 2},
  199 + {"2000000000000000000000", 8},
  200 + {"18446744073709551616", 10},
  201 + {"10000000000000000", 16},
  202 + /* negative */
  203 + {"-0", 0},
  204 + {"-0", 8},
  205 + {"-0", 10},
  206 + {"-0", 16},
  207 + {"-1", 0},
  208 + {"-1", 8},
  209 + {"-1", 10},
  210 + {"-1", 16},
  211 + /* sign is first character if any */
  212 + {"-+1", 0},
  213 + {"-+1", 8},
  214 + {"-+1", 10},
  215 + {"-+1", 16},
  216 + /* nothing after \n */
  217 + {"0\n0", 0},
  218 + {"0\n0", 8},
  219 + {"0\n0", 10},
  220 + {"0\n0", 16},
  221 + {"0\n+", 0},
  222 + {"0\n+", 8},
  223 + {"0\n+", 10},
  224 + {"0\n+", 16},
  225 + {"0\n-", 0},
  226 + {"0\n-", 8},
  227 + {"0\n-", 10},
  228 + {"0\n-", 16},
  229 + {"0\n ", 0},
  230 + {"0\n ", 8},
  231 + {"0\n ", 10},
  232 + {"0\n ", 16},
  233 + };
  234 + TEST_FAIL(kstrtoull, unsigned long long, "%llu", test_ull_fail);
  235 +}
  236 +
  237 +static void __init test_kstrtoll_ok(void)
  238 +{
  239 + DECLARE_TEST_OK(long long, struct test_ll);
  240 + static DEFINE_TEST_OK(struct test_ll, test_ll_ok) = {
  241 + {"0", 10, 0LL},
  242 + {"1", 10, 1LL},
  243 + {"127", 10, 127LL},
  244 + {"128", 10, 128LL},
  245 + {"129", 10, 129LL},
  246 + {"255", 10, 255LL},
  247 + {"256", 10, 256LL},
  248 + {"257", 10, 257LL},
  249 + {"32767", 10, 32767LL},
  250 + {"32768", 10, 32768LL},
  251 + {"32769", 10, 32769LL},
  252 + {"65535", 10, 65535LL},
  253 + {"65536", 10, 65536LL},
  254 + {"65537", 10, 65537LL},
  255 + {"2147483647", 10, 2147483647LL},
  256 + {"2147483648", 10, 2147483648LL},
  257 + {"2147483649", 10, 2147483649LL},
  258 + {"4294967295", 10, 4294967295LL},
  259 + {"4294967296", 10, 4294967296LL},
  260 + {"4294967297", 10, 4294967297LL},
  261 + {"9223372036854775807", 10, 9223372036854775807LL},
  262 +
  263 + {"-1", 10, -1LL},
  264 + {"-2", 10, -2LL},
  265 + {"-9223372036854775808", 10, LLONG_MIN},
  266 + };
  267 + TEST_OK(kstrtoll, long long, "%lld", test_ll_ok);
  268 +}
  269 +
  270 +static void __init test_kstrtoll_fail(void)
  271 +{
  272 + static DEFINE_TEST_FAIL(test_ll_fail) = {
  273 + {"9223372036854775808", 10},
  274 + {"9223372036854775809", 10},
  275 + {"18446744073709551614", 10},
  276 + {"18446744073709551615", 10},
  277 + {"-9223372036854775809", 10},
  278 + {"-18446744073709551614", 10},
  279 + {"-18446744073709551615", 10},
  280 + /* negative zero isn't an integer in Linux */
  281 + {"-0", 0},
  282 + {"-0", 8},
  283 + {"-0", 10},
  284 + {"-0", 16},
  285 + /* sign is first character if any */
  286 + {"-+1", 0},
  287 + {"-+1", 8},
  288 + {"-+1", 10},
  289 + {"-+1", 16},
  290 + };
  291 + TEST_FAIL(kstrtoll, long long, "%lld", test_ll_fail);
  292 +}
  293 +
  294 +static void __init test_kstrtou64_ok(void)
  295 +{
  296 + DECLARE_TEST_OK(u64, struct test_u64);
  297 + static DEFINE_TEST_OK(struct test_u64, test_u64_ok) = {
  298 + {"0", 10, 0},
  299 + {"1", 10, 1},
  300 + {"126", 10, 126},
  301 + {"127", 10, 127},
  302 + {"128", 10, 128},
  303 + {"129", 10, 129},
  304 + {"254", 10, 254},
  305 + {"255", 10, 255},
  306 + {"256", 10, 256},
  307 + {"257", 10, 257},
  308 + {"32766", 10, 32766},
  309 + {"32767", 10, 32767},
  310 + {"32768", 10, 32768},
  311 + {"32769", 10, 32769},
  312 + {"65534", 10, 65534},
  313 + {"65535", 10, 65535},
  314 + {"65536", 10, 65536},
  315 + {"65537", 10, 65537},
  316 + {"2147483646", 10, 2147483646},
  317 + {"2147483647", 10, 2147483647},
  318 + {"2147483648", 10, 2147483648},
  319 + {"2147483649", 10, 2147483649},
  320 + {"4294967294", 10, 4294967294},
  321 + {"4294967295", 10, 4294967295},
  322 + {"4294967296", 10, 4294967296},
  323 + {"4294967297", 10, 4294967297},
  324 + {"9223372036854775806", 10, 9223372036854775806ULL},
  325 + {"9223372036854775807", 10, 9223372036854775807ULL},
  326 + {"9223372036854775808", 10, 9223372036854775808ULL},
  327 + {"9223372036854775809", 10, 9223372036854775809ULL},
  328 + {"18446744073709551614", 10, 18446744073709551614ULL},
  329 + {"18446744073709551615", 10, 18446744073709551615ULL},
  330 + };
  331 + TEST_OK(kstrtou64, u64, "%llu", test_u64_ok);
  332 +}
  333 +
  334 +static void __init test_kstrtou64_fail(void)
  335 +{
  336 + static DEFINE_TEST_FAIL(test_u64_fail) = {
  337 + {"-2", 10},
  338 + {"-1", 10},
  339 + {"18446744073709551616", 10},
  340 + {"18446744073709551617", 10},
  341 + };
  342 + TEST_FAIL(kstrtou64, u64, "%llu", test_u64_fail);
  343 +}
  344 +
  345 +static void __init test_kstrtos64_ok(void)
  346 +{
  347 + DECLARE_TEST_OK(s64, struct test_s64);
  348 + static DEFINE_TEST_OK(struct test_s64, test_s64_ok) = {
  349 + {"-128", 10, -128},
  350 + {"-127", 10, -127},
  351 + {"-1", 10, -1},
  352 + {"0", 10, 0},
  353 + {"1", 10, 1},
  354 + {"126", 10, 126},
  355 + {"127", 10, 127},
  356 + {"128", 10, 128},
  357 + {"129", 10, 129},
  358 + {"254", 10, 254},
  359 + {"255", 10, 255},
  360 + {"256", 10, 256},
  361 + {"257", 10, 257},
  362 + {"32766", 10, 32766},
  363 + {"32767", 10, 32767},
  364 + {"32768", 10, 32768},
  365 + {"32769", 10, 32769},
  366 + {"65534", 10, 65534},
  367 + {"65535", 10, 65535},
  368 + {"65536", 10, 65536},
  369 + {"65537", 10, 65537},
  370 + {"2147483646", 10, 2147483646},
  371 + {"2147483647", 10, 2147483647},
  372 + {"2147483648", 10, 2147483648},
  373 + {"2147483649", 10, 2147483649},
  374 + {"4294967294", 10, 4294967294},
  375 + {"4294967295", 10, 4294967295},
  376 + {"4294967296", 10, 4294967296},
  377 + {"4294967297", 10, 4294967297},
  378 + {"9223372036854775806", 10, 9223372036854775806LL},
  379 + {"9223372036854775807", 10, 9223372036854775807LL},
  380 + };
  381 + TEST_OK(kstrtos64, s64, "%lld", test_s64_ok);
  382 +}
  383 +
  384 +static void __init test_kstrtos64_fail(void)
  385 +{
  386 + static DEFINE_TEST_FAIL(test_s64_fail) = {
  387 + {"9223372036854775808", 10},
  388 + {"9223372036854775809", 10},
  389 + {"18446744073709551614", 10},
  390 + {"18446744073709551615", 10},
  391 + {"18446744073709551616", 10},
  392 + {"18446744073709551617", 10},
  393 + };
  394 + TEST_FAIL(kstrtos64, s64, "%lld", test_s64_fail);
  395 +}
  396 +
  397 +static void __init test_kstrtou32_ok(void)
  398 +{
  399 + DECLARE_TEST_OK(u32, struct test_u32);
  400 + static DEFINE_TEST_OK(struct test_u32, test_u32_ok) = {
  401 + {"0", 10, 0},
  402 + {"1", 10, 1},
  403 + {"126", 10, 126},
  404 + {"127", 10, 127},
  405 + {"128", 10, 128},
  406 + {"129", 10, 129},
  407 + {"254", 10, 254},
  408 + {"255", 10, 255},
  409 + {"256", 10, 256},
  410 + {"257", 10, 257},
  411 + {"32766", 10, 32766},
  412 + {"32767", 10, 32767},
  413 + {"32768", 10, 32768},
  414 + {"32769", 10, 32769},
  415 + {"65534", 10, 65534},
  416 + {"65535", 10, 65535},
  417 + {"65536", 10, 65536},
  418 + {"65537", 10, 65537},
  419 + {"2147483646", 10, 2147483646},
  420 + {"2147483647", 10, 2147483647},
  421 + {"2147483648", 10, 2147483648},
  422 + {"2147483649", 10, 2147483649},
  423 + {"4294967294", 10, 4294967294},
  424 + {"4294967295", 10, 4294967295},
  425 + };
  426 + TEST_OK(kstrtou32, u32, "%u", test_u32_ok);
  427 +}
  428 +
  429 +static void __init test_kstrtou32_fail(void)
  430 +{
  431 + static DEFINE_TEST_FAIL(test_u32_fail) = {
  432 + {"-2", 10},
  433 + {"-1", 10},
  434 + {"4294967296", 10},
  435 + {"4294967297", 10},
  436 + {"9223372036854775806", 10},
  437 + {"9223372036854775807", 10},
  438 + {"9223372036854775808", 10},
  439 + {"9223372036854775809", 10},
  440 + {"18446744073709551614", 10},
  441 + {"18446744073709551615", 10},
  442 + {"18446744073709551616", 10},
  443 + {"18446744073709551617", 10},
  444 + };
  445 + TEST_FAIL(kstrtou32, u32, "%u", test_u32_fail);
  446 +}
  447 +
  448 +static void __init test_kstrtos32_ok(void)
  449 +{
  450 + DECLARE_TEST_OK(s32, struct test_s32);
  451 + static DEFINE_TEST_OK(struct test_s32, test_s32_ok) = {
  452 + {"-128", 10, -128},
  453 + {"-127", 10, -127},
  454 + {"-1", 10, -1},
  455 + {"0", 10, 0},
  456 + {"1", 10, 1},
  457 + {"126", 10, 126},
  458 + {"127", 10, 127},
  459 + {"128", 10, 128},
  460 + {"129", 10, 129},
  461 + {"254", 10, 254},
  462 + {"255", 10, 255},
  463 + {"256", 10, 256},
  464 + {"257", 10, 257},
  465 + {"32766", 10, 32766},
  466 + {"32767", 10, 32767},
  467 + {"32768", 10, 32768},
  468 + {"32769", 10, 32769},
  469 + {"65534", 10, 65534},
  470 + {"65535", 10, 65535},
  471 + {"65536", 10, 65536},
  472 + {"65537", 10, 65537},
  473 + {"2147483646", 10, 2147483646},
  474 + {"2147483647", 10, 2147483647},
  475 + };
  476 + TEST_OK(kstrtos32, s32, "%d", test_s32_ok);
  477 +}
  478 +
  479 +static void __init test_kstrtos32_fail(void)
  480 +{
  481 + static DEFINE_TEST_FAIL(test_s32_fail) = {
  482 + {"2147483648", 10},
  483 + {"2147483649", 10},
  484 + {"4294967294", 10},
  485 + {"4294967295", 10},
  486 + {"4294967296", 10},
  487 + {"4294967297", 10},
  488 + {"9223372036854775806", 10},
  489 + {"9223372036854775807", 10},
  490 + {"9223372036854775808", 10},
  491 + {"9223372036854775809", 10},
  492 + {"18446744073709551614", 10},
  493 + {"18446744073709551615", 10},
  494 + {"18446744073709551616", 10},
  495 + {"18446744073709551617", 10},
  496 + };
  497 + TEST_FAIL(kstrtos32, s32, "%d", test_s32_fail);
  498 +}
  499 +
  500 +static void __init test_kstrtou16_ok(void)
  501 +{
  502 + DECLARE_TEST_OK(u16, struct test_u16);
  503 + static DEFINE_TEST_OK(struct test_u16, test_u16_ok) = {
  504 + {"0", 10, 0},
  505 + {"1", 10, 1},
  506 + {"126", 10, 126},
  507 + {"127", 10, 127},
  508 + {"128", 10, 128},
  509 + {"129", 10, 129},
  510 + {"254", 10, 254},
  511 + {"255", 10, 255},
  512 + {"256", 10, 256},
  513 + {"257", 10, 257},
  514 + {"32766", 10, 32766},
  515 + {"32767", 10, 32767},
  516 + {"32768", 10, 32768},
  517 + {"32769", 10, 32769},
  518 + {"65534", 10, 65534},
  519 + {"65535", 10, 65535},
  520 + };
  521 + TEST_OK(kstrtou16, u16, "%hu", test_u16_ok);
  522 +}
  523 +
  524 +static void __init test_kstrtou16_fail(void)
  525 +{
  526 + static DEFINE_TEST_FAIL(test_u16_fail) = {
  527 + {"-2", 10},
  528 + {"-1", 10},
  529 + {"65536", 10},
  530 + {"65537", 10},
  531 + {"2147483646", 10},
  532 + {"2147483647", 10},
  533 + {"2147483648", 10},
  534 + {"2147483649", 10},
  535 + {"4294967294", 10},
  536 + {"4294967295", 10},
  537 + {"4294967296", 10},
  538 + {"4294967297", 10},
  539 + {"9223372036854775806", 10},
  540 + {"9223372036854775807", 10},
  541 + {"9223372036854775808", 10},
  542 + {"9223372036854775809", 10},
  543 + {"18446744073709551614", 10},
  544 + {"18446744073709551615", 10},
  545 + {"18446744073709551616", 10},
  546 + {"18446744073709551617", 10},
  547 + };
  548 + TEST_FAIL(kstrtou16, u16, "%hu", test_u16_fail);
  549 +}
  550 +
  551 +static void __init test_kstrtos16_ok(void)
  552 +{
  553 + DECLARE_TEST_OK(s16, struct test_s16);
  554 + static DEFINE_TEST_OK(struct test_s16, test_s16_ok) = {
  555 + {"-130", 10, -130},
  556 + {"-129", 10, -129},
  557 + {"-128", 10, -128},
  558 + {"-127", 10, -127},
  559 + {"-1", 10, -1},
  560 + {"0", 10, 0},
  561 + {"1", 10, 1},
  562 + {"126", 10, 126},
  563 + {"127", 10, 127},
  564 + {"128", 10, 128},
  565 + {"129", 10, 129},
  566 + {"254", 10, 254},
  567 + {"255", 10, 255},
  568 + {"256", 10, 256},
  569 + {"257", 10, 257},
  570 + {"32766", 10, 32766},
  571 + {"32767", 10, 32767},
  572 + };
  573 + TEST_OK(kstrtos16, s16, "%hd", test_s16_ok);
  574 +}
  575 +
  576 +static void __init test_kstrtos16_fail(void)
  577 +{
  578 + static DEFINE_TEST_FAIL(test_s16_fail) = {
  579 + {"32768", 10},
  580 + {"32769", 10},
  581 + {"65534", 10},
  582 + {"65535", 10},
  583 + {"65536", 10},
  584 + {"65537", 10},
  585 + {"2147483646", 10},
  586 + {"2147483647", 10},
  587 + {"2147483648", 10},
  588 + {"2147483649", 10},
  589 + {"4294967294", 10},
  590 + {"4294967295", 10},
  591 + {"4294967296", 10},
  592 + {"4294967297", 10},
  593 + {"9223372036854775806", 10},
  594 + {"9223372036854775807", 10},
  595 + {"9223372036854775808", 10},
  596 + {"9223372036854775809", 10},
  597 + {"18446744073709551614", 10},
  598 + {"18446744073709551615", 10},
  599 + {"18446744073709551616", 10},
  600 + {"18446744073709551617", 10},
  601 + };
  602 + TEST_FAIL(kstrtos16, s16, "%hd", test_s16_fail);
  603 +}
  604 +
  605 +static void __init test_kstrtou8_ok(void)
  606 +{
  607 + DECLARE_TEST_OK(u8, struct test_u8);
  608 + static DEFINE_TEST_OK(struct test_u8, test_u8_ok) = {
  609 + {"0", 10, 0},
  610 + {"1", 10, 1},
  611 + {"126", 10, 126},
  612 + {"127", 10, 127},
  613 + {"128", 10, 128},
  614 + {"129", 10, 129},
  615 + {"254", 10, 254},
  616 + {"255", 10, 255},
  617 + };
  618 + TEST_OK(kstrtou8, u8, "%hhu", test_u8_ok);
  619 +}
  620 +
  621 +static void __init test_kstrtou8_fail(void)
  622 +{
  623 + static DEFINE_TEST_FAIL(test_u8_fail) = {
  624 + {"-2", 10},
  625 + {"-1", 10},
  626 + {"256", 10},
  627 + {"257", 10},
  628 + {"32766", 10},
  629 + {"32767", 10},
  630 + {"32768", 10},
  631 + {"32769", 10},
  632 + {"65534", 10},
  633 + {"65535", 10},
  634 + {"65536", 10},
  635 + {"65537", 10},
  636 + {"2147483646", 10},
  637 + {"2147483647", 10},
  638 + {"2147483648", 10},
  639 + {"2147483649", 10},
  640 + {"4294967294", 10},
  641 + {"4294967295", 10},
  642 + {"4294967296", 10},
  643 + {"4294967297", 10},
  644 + {"9223372036854775806", 10},
  645 + {"9223372036854775807", 10},
  646 + {"9223372036854775808", 10},
  647 + {"9223372036854775809", 10},
  648 + {"18446744073709551614", 10},
  649 + {"18446744073709551615", 10},
  650 + {"18446744073709551616", 10},
  651 + {"18446744073709551617", 10},
  652 + };
  653 + TEST_FAIL(kstrtou8, u8, "%hhu", test_u8_fail);
  654 +}
  655 +
  656 +static void __init test_kstrtos8_ok(void)
  657 +{
  658 + DECLARE_TEST_OK(s8, struct test_s8);
  659 + static DEFINE_TEST_OK(struct test_s8, test_s8_ok) = {
  660 + {"-128", 10, -128},
  661 + {"-127", 10, -127},
  662 + {"-1", 10, -1},
  663 + {"0", 10, 0},
  664 + {"1", 10, 1},
  665 + {"126", 10, 126},
  666 + {"127", 10, 127},
  667 + };
  668 + TEST_OK(kstrtos8, s8, "%hhd", test_s8_ok);
  669 +}
  670 +
  671 +static void __init test_kstrtos8_fail(void)
  672 +{
  673 + static DEFINE_TEST_FAIL(test_s8_fail) = {
  674 + {"-130", 10},
  675 + {"-129", 10},
  676 + {"128", 10},
  677 + {"129", 10},
  678 + {"254", 10},
  679 + {"255", 10},
  680 + {"256", 10},
  681 + {"257", 10},
  682 + {"32766", 10},
  683 + {"32767", 10},
  684 + {"32768", 10},
  685 + {"32769", 10},
  686 + {"65534", 10},
  687 + {"65535", 10},
  688 + {"65536", 10},
  689 + {"65537", 10},
  690 + {"2147483646", 10},
  691 + {"2147483647", 10},
  692 + {"2147483648", 10},
  693 + {"2147483649", 10},
  694 + {"4294967294", 10},
  695 + {"4294967295", 10},
  696 + {"4294967296", 10},
  697 + {"4294967297", 10},
  698 + {"9223372036854775806", 10},
  699 + {"9223372036854775807", 10},
  700 + {"9223372036854775808", 10},
  701 + {"9223372036854775809", 10},
  702 + {"18446744073709551614", 10},
  703 + {"18446744073709551615", 10},
  704 + {"18446744073709551616", 10},
  705 + {"18446744073709551617", 10},
  706 + };
  707 + TEST_FAIL(kstrtos8, s8, "%hhd", test_s8_fail);
  708 +}
  709 +
  710 +static int __init test_kstrtox_init(void)
  711 +{
  712 + test_kstrtoull_ok();
  713 + test_kstrtoull_fail();
  714 + test_kstrtoll_ok();
  715 + test_kstrtoll_fail();
  716 +
  717 + test_kstrtou64_ok();
  718 + test_kstrtou64_fail();
  719 + test_kstrtos64_ok();
  720 + test_kstrtos64_fail();
  721 +
  722 + test_kstrtou32_ok();
  723 + test_kstrtou32_fail();
  724 + test_kstrtos32_ok();
  725 + test_kstrtos32_fail();
  726 +
  727 + test_kstrtou16_ok();
  728 + test_kstrtou16_fail();
  729 + test_kstrtos16_ok();
  730 + test_kstrtos16_fail();
  731 +
  732 + test_kstrtou8_ok();
  733 + test_kstrtou8_fail();
  734 + test_kstrtos8_ok();
  735 + test_kstrtos8_fail();
  736 + return -EINVAL;
  737 +}
  738 +module_init(test_kstrtox_init);
  739 +MODULE_LICENSE("Dual BSD/GPL");
... ... @@ -120,147 +120,6 @@
120 120 }
121 121 EXPORT_SYMBOL(simple_strtoll);
122 122  
123   -/**
124   - * strict_strtoul - convert a string to an unsigned long strictly
125   - * @cp: The string to be converted
126   - * @base: The number base to use
127   - * @res: The converted result value
128   - *
129   - * strict_strtoul converts a string to an unsigned long only if the
130   - * string is really an unsigned long string, any string containing
131   - * any invalid char at the tail will be rejected and -EINVAL is returned,
132   - * only a newline char at the tail is acceptible because people generally
133   - * change a module parameter in the following way:
134   - *
135   - * echo 1024 > /sys/module/e1000/parameters/copybreak
136   - *
137   - * echo will append a newline to the tail.
138   - *
139   - * It returns 0 if conversion is successful and *res is set to the converted
140   - * value, otherwise it returns -EINVAL and *res is set to 0.
141   - *
142   - * simple_strtoul just ignores the successive invalid characters and
143   - * return the converted value of prefix part of the string.
144   - */
145   -int strict_strtoul(const char *cp, unsigned int base, unsigned long *res)
146   -{
147   - char *tail;
148   - unsigned long val;
149   -
150   - *res = 0;
151   - if (!*cp)
152   - return -EINVAL;
153   -
154   - val = simple_strtoul(cp, &tail, base);
155   - if (tail == cp)
156   - return -EINVAL;
157   -
158   - if ((tail[0] == '\0') || (tail[0] == '\n' && tail[1] == '\0')) {
159   - *res = val;
160   - return 0;
161   - }
162   -
163   - return -EINVAL;
164   -}
165   -EXPORT_SYMBOL(strict_strtoul);
166   -
167   -/**
168   - * strict_strtol - convert a string to a long strictly
169   - * @cp: The string to be converted
170   - * @base: The number base to use
171   - * @res: The converted result value
172   - *
173   - * strict_strtol is similiar to strict_strtoul, but it allows the first
174   - * character of a string is '-'.
175   - *
176   - * It returns 0 if conversion is successful and *res is set to the converted
177   - * value, otherwise it returns -EINVAL and *res is set to 0.
178   - */
179   -int strict_strtol(const char *cp, unsigned int base, long *res)
180   -{
181   - int ret;
182   - if (*cp == '-') {
183   - ret = strict_strtoul(cp + 1, base, (unsigned long *)res);
184   - if (!ret)
185   - *res = -(*res);
186   - } else {
187   - ret = strict_strtoul(cp, base, (unsigned long *)res);
188   - }
189   -
190   - return ret;
191   -}
192   -EXPORT_SYMBOL(strict_strtol);
193   -
194   -/**
195   - * strict_strtoull - convert a string to an unsigned long long strictly
196   - * @cp: The string to be converted
197   - * @base: The number base to use
198   - * @res: The converted result value
199   - *
200   - * strict_strtoull converts a string to an unsigned long long only if the
201   - * string is really an unsigned long long string, any string containing
202   - * any invalid char at the tail will be rejected and -EINVAL is returned,
203   - * only a newline char at the tail is acceptible because people generally
204   - * change a module parameter in the following way:
205   - *
206   - * echo 1024 > /sys/module/e1000/parameters/copybreak
207   - *
208   - * echo will append a newline to the tail of the string.
209   - *
210   - * It returns 0 if conversion is successful and *res is set to the converted
211   - * value, otherwise it returns -EINVAL and *res is set to 0.
212   - *
213   - * simple_strtoull just ignores the successive invalid characters and
214   - * return the converted value of prefix part of the string.
215   - */
216   -int strict_strtoull(const char *cp, unsigned int base, unsigned long long *res)
217   -{
218   - char *tail;
219   - unsigned long long val;
220   -
221   - *res = 0;
222   - if (!*cp)
223   - return -EINVAL;
224   -
225   - val = simple_strtoull(cp, &tail, base);
226   - if (tail == cp)
227   - return -EINVAL;
228   - if ((tail[0] == '\0') || (tail[0] == '\n' && tail[1] == '\0')) {
229   - *res = val;
230   - return 0;
231   - }
232   -
233   - return -EINVAL;
234   -}
235   -EXPORT_SYMBOL(strict_strtoull);
236   -
237   -/**
238   - * strict_strtoll - convert a string to a long long strictly
239   - * @cp: The string to be converted
240   - * @base: The number base to use
241   - * @res: The converted result value
242   - *
243   - * strict_strtoll is similiar to strict_strtoull, but it allows the first
244   - * character of a string is '-'.
245   - *
246   - * It returns 0 if conversion is successful and *res is set to the converted
247   - * value, otherwise it returns -EINVAL and *res is set to 0.
248   - */
249   -int strict_strtoll(const char *cp, unsigned int base, long long *res)
250   -{
251   - int ret;
252   - if (*cp == '-') {
253   - ret = strict_strtoull(cp + 1, base, (unsigned long long *)res);
254   - if (!ret)
255   - *res = -(*res);
256   - } else {
257   - ret = strict_strtoull(cp, base, (unsigned long long *)res);
258   - }
259   -
260   - return ret;
261   -}
262   -EXPORT_SYMBOL(strict_strtoll);
263   -
264 123 static noinline_for_stack
265 124 int skip_atoi(const char **s)
266 125 {
scripts/checkpatch.pl
Diff comments   View file @ 33ee3b2
... ... @@ -2804,9 +2804,9 @@
2804 2804 WARN("consider using a completion\n" . $herecurr);
2805 2805  
2806 2806 }
2807   -# recommend strict_strto* over simple_strto*
  2807 +# recommend kstrto* over simple_strto*
2808 2808 if ($line =~ /\bsimple_(strto.*?)\s*\(/) {
2809   - WARN("consider using strict_$1 in preference to simple_$1\n" . $herecurr);
  2809 + WARN("consider using kstrto* in preference to simple_$1\n" . $herecurr);
2810 2810 }
2811 2811 # check for __initcall(), use device_initcall() explicitly please
2812 2812 if ($line =~ /^.\s*__initcall\s*\(/) {