test_overflow.c 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614
  1. // SPDX-License-Identifier: GPL-2.0 OR MIT
  2. /*
  3. * Test cases for arithmetic overflow checks.
  4. */
  5. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  6. #include <linux/device.h>
  7. #include <linux/init.h>
  8. #include <linux/kernel.h>
  9. #include <linux/mm.h>
  10. #include <linux/module.h>
  11. #include <linux/overflow.h>
  12. #include <linux/slab.h>
  13. #include <linux/types.h>
  14. #include <linux/vmalloc.h>
  15. #define DEFINE_TEST_ARRAY(t) \
  16. static const struct test_ ## t { \
  17. t a, b; \
  18. t sum, diff, prod; \
  19. bool s_of, d_of, p_of; \
  20. } t ## _tests[] __initconst
  21. DEFINE_TEST_ARRAY(u8) = {
  22. {0, 0, 0, 0, 0, false, false, false},
  23. {1, 1, 2, 0, 1, false, false, false},
  24. {0, 1, 1, U8_MAX, 0, false, true, false},
  25. {1, 0, 1, 1, 0, false, false, false},
  26. {0, U8_MAX, U8_MAX, 1, 0, false, true, false},
  27. {U8_MAX, 0, U8_MAX, U8_MAX, 0, false, false, false},
  28. {1, U8_MAX, 0, 2, U8_MAX, true, true, false},
  29. {U8_MAX, 1, 0, U8_MAX-1, U8_MAX, true, false, false},
  30. {U8_MAX, U8_MAX, U8_MAX-1, 0, 1, true, false, true},
  31. {U8_MAX, U8_MAX-1, U8_MAX-2, 1, 2, true, false, true},
  32. {U8_MAX-1, U8_MAX, U8_MAX-2, U8_MAX, 2, true, true, true},
  33. {1U << 3, 1U << 3, 1U << 4, 0, 1U << 6, false, false, false},
  34. {1U << 4, 1U << 4, 1U << 5, 0, 0, false, false, true},
  35. {1U << 4, 1U << 3, 3*(1U << 3), 1U << 3, 1U << 7, false, false, false},
  36. {1U << 7, 1U << 7, 0, 0, 0, true, false, true},
  37. {48, 32, 80, 16, 0, false, false, true},
  38. {128, 128, 0, 0, 0, true, false, true},
  39. {123, 234, 101, 145, 110, true, true, true},
  40. };
  41. DEFINE_TEST_ARRAY(u16) = {
  42. {0, 0, 0, 0, 0, false, false, false},
  43. {1, 1, 2, 0, 1, false, false, false},
  44. {0, 1, 1, U16_MAX, 0, false, true, false},
  45. {1, 0, 1, 1, 0, false, false, false},
  46. {0, U16_MAX, U16_MAX, 1, 0, false, true, false},
  47. {U16_MAX, 0, U16_MAX, U16_MAX, 0, false, false, false},
  48. {1, U16_MAX, 0, 2, U16_MAX, true, true, false},
  49. {U16_MAX, 1, 0, U16_MAX-1, U16_MAX, true, false, false},
  50. {U16_MAX, U16_MAX, U16_MAX-1, 0, 1, true, false, true},
  51. {U16_MAX, U16_MAX-1, U16_MAX-2, 1, 2, true, false, true},
  52. {U16_MAX-1, U16_MAX, U16_MAX-2, U16_MAX, 2, true, true, true},
  53. {1U << 7, 1U << 7, 1U << 8, 0, 1U << 14, false, false, false},
  54. {1U << 8, 1U << 8, 1U << 9, 0, 0, false, false, true},
  55. {1U << 8, 1U << 7, 3*(1U << 7), 1U << 7, 1U << 15, false, false, false},
  56. {1U << 15, 1U << 15, 0, 0, 0, true, false, true},
  57. {123, 234, 357, 65425, 28782, false, true, false},
  58. {1234, 2345, 3579, 64425, 10146, false, true, true},
  59. };
  60. DEFINE_TEST_ARRAY(u32) = {
  61. {0, 0, 0, 0, 0, false, false, false},
  62. {1, 1, 2, 0, 1, false, false, false},
  63. {0, 1, 1, U32_MAX, 0, false, true, false},
  64. {1, 0, 1, 1, 0, false, false, false},
  65. {0, U32_MAX, U32_MAX, 1, 0, false, true, false},
  66. {U32_MAX, 0, U32_MAX, U32_MAX, 0, false, false, false},
  67. {1, U32_MAX, 0, 2, U32_MAX, true, true, false},
  68. {U32_MAX, 1, 0, U32_MAX-1, U32_MAX, true, false, false},
  69. {U32_MAX, U32_MAX, U32_MAX-1, 0, 1, true, false, true},
  70. {U32_MAX, U32_MAX-1, U32_MAX-2, 1, 2, true, false, true},
  71. {U32_MAX-1, U32_MAX, U32_MAX-2, U32_MAX, 2, true, true, true},
  72. {1U << 15, 1U << 15, 1U << 16, 0, 1U << 30, false, false, false},
  73. {1U << 16, 1U << 16, 1U << 17, 0, 0, false, false, true},
  74. {1U << 16, 1U << 15, 3*(1U << 15), 1U << 15, 1U << 31, false, false, false},
  75. {1U << 31, 1U << 31, 0, 0, 0, true, false, true},
  76. {-2U, 1U, -1U, -3U, -2U, false, false, false},
  77. {-4U, 5U, 1U, -9U, -20U, true, false, true},
  78. };
  79. DEFINE_TEST_ARRAY(u64) = {
  80. {0, 0, 0, 0, 0, false, false, false},
  81. {1, 1, 2, 0, 1, false, false, false},
  82. {0, 1, 1, U64_MAX, 0, false, true, false},
  83. {1, 0, 1, 1, 0, false, false, false},
  84. {0, U64_MAX, U64_MAX, 1, 0, false, true, false},
  85. {U64_MAX, 0, U64_MAX, U64_MAX, 0, false, false, false},
  86. {1, U64_MAX, 0, 2, U64_MAX, true, true, false},
  87. {U64_MAX, 1, 0, U64_MAX-1, U64_MAX, true, false, false},
  88. {U64_MAX, U64_MAX, U64_MAX-1, 0, 1, true, false, true},
  89. {U64_MAX, U64_MAX-1, U64_MAX-2, 1, 2, true, false, true},
  90. {U64_MAX-1, U64_MAX, U64_MAX-2, U64_MAX, 2, true, true, true},
  91. {1ULL << 31, 1ULL << 31, 1ULL << 32, 0, 1ULL << 62, false, false, false},
  92. {1ULL << 32, 1ULL << 32, 1ULL << 33, 0, 0, false, false, true},
  93. {1ULL << 32, 1ULL << 31, 3*(1ULL << 31), 1ULL << 31, 1ULL << 63, false, false, false},
  94. {1ULL << 63, 1ULL << 63, 0, 0, 0, true, false, true},
  95. {1000000000ULL /* 10^9 */, 10000000000ULL /* 10^10 */,
  96. 11000000000ULL, 18446744064709551616ULL, 10000000000000000000ULL,
  97. false, true, false},
  98. {-15ULL, 10ULL, -5ULL, -25ULL, -150ULL, false, false, true},
  99. };
  100. DEFINE_TEST_ARRAY(s8) = {
  101. {0, 0, 0, 0, 0, false, false, false},
  102. {0, S8_MAX, S8_MAX, -S8_MAX, 0, false, false, false},
  103. {S8_MAX, 0, S8_MAX, S8_MAX, 0, false, false, false},
  104. {0, S8_MIN, S8_MIN, S8_MIN, 0, false, true, false},
  105. {S8_MIN, 0, S8_MIN, S8_MIN, 0, false, false, false},
  106. {-1, S8_MIN, S8_MAX, S8_MAX, S8_MIN, true, false, true},
  107. {S8_MIN, -1, S8_MAX, -S8_MAX, S8_MIN, true, false, true},
  108. {-1, S8_MAX, S8_MAX-1, S8_MIN, -S8_MAX, false, false, false},
  109. {S8_MAX, -1, S8_MAX-1, S8_MIN, -S8_MAX, false, true, false},
  110. {-1, -S8_MAX, S8_MIN, S8_MAX-1, S8_MAX, false, false, false},
  111. {-S8_MAX, -1, S8_MIN, S8_MIN+2, S8_MAX, false, false, false},
  112. {1, S8_MIN, -S8_MAX, -S8_MAX, S8_MIN, false, true, false},
  113. {S8_MIN, 1, -S8_MAX, S8_MAX, S8_MIN, false, true, false},
  114. {1, S8_MAX, S8_MIN, S8_MIN+2, S8_MAX, true, false, false},
  115. {S8_MAX, 1, S8_MIN, S8_MAX-1, S8_MAX, true, false, false},
  116. {S8_MIN, S8_MIN, 0, 0, 0, true, false, true},
  117. {S8_MAX, S8_MAX, -2, 0, 1, true, false, true},
  118. {-4, -32, -36, 28, -128, false, false, true},
  119. {-4, 32, 28, -36, -128, false, false, false},
  120. };
  121. DEFINE_TEST_ARRAY(s16) = {
  122. {0, 0, 0, 0, 0, false, false, false},
  123. {0, S16_MAX, S16_MAX, -S16_MAX, 0, false, false, false},
  124. {S16_MAX, 0, S16_MAX, S16_MAX, 0, false, false, false},
  125. {0, S16_MIN, S16_MIN, S16_MIN, 0, false, true, false},
  126. {S16_MIN, 0, S16_MIN, S16_MIN, 0, false, false, false},
  127. {-1, S16_MIN, S16_MAX, S16_MAX, S16_MIN, true, false, true},
  128. {S16_MIN, -1, S16_MAX, -S16_MAX, S16_MIN, true, false, true},
  129. {-1, S16_MAX, S16_MAX-1, S16_MIN, -S16_MAX, false, false, false},
  130. {S16_MAX, -1, S16_MAX-1, S16_MIN, -S16_MAX, false, true, false},
  131. {-1, -S16_MAX, S16_MIN, S16_MAX-1, S16_MAX, false, false, false},
  132. {-S16_MAX, -1, S16_MIN, S16_MIN+2, S16_MAX, false, false, false},
  133. {1, S16_MIN, -S16_MAX, -S16_MAX, S16_MIN, false, true, false},
  134. {S16_MIN, 1, -S16_MAX, S16_MAX, S16_MIN, false, true, false},
  135. {1, S16_MAX, S16_MIN, S16_MIN+2, S16_MAX, true, false, false},
  136. {S16_MAX, 1, S16_MIN, S16_MAX-1, S16_MAX, true, false, false},
  137. {S16_MIN, S16_MIN, 0, 0, 0, true, false, true},
  138. {S16_MAX, S16_MAX, -2, 0, 1, true, false, true},
  139. };
  140. DEFINE_TEST_ARRAY(s32) = {
  141. {0, 0, 0, 0, 0, false, false, false},
  142. {0, S32_MAX, S32_MAX, -S32_MAX, 0, false, false, false},
  143. {S32_MAX, 0, S32_MAX, S32_MAX, 0, false, false, false},
  144. {0, S32_MIN, S32_MIN, S32_MIN, 0, false, true, false},
  145. {S32_MIN, 0, S32_MIN, S32_MIN, 0, false, false, false},
  146. {-1, S32_MIN, S32_MAX, S32_MAX, S32_MIN, true, false, true},
  147. {S32_MIN, -1, S32_MAX, -S32_MAX, S32_MIN, true, false, true},
  148. {-1, S32_MAX, S32_MAX-1, S32_MIN, -S32_MAX, false, false, false},
  149. {S32_MAX, -1, S32_MAX-1, S32_MIN, -S32_MAX, false, true, false},
  150. {-1, -S32_MAX, S32_MIN, S32_MAX-1, S32_MAX, false, false, false},
  151. {-S32_MAX, -1, S32_MIN, S32_MIN+2, S32_MAX, false, false, false},
  152. {1, S32_MIN, -S32_MAX, -S32_MAX, S32_MIN, false, true, false},
  153. {S32_MIN, 1, -S32_MAX, S32_MAX, S32_MIN, false, true, false},
  154. {1, S32_MAX, S32_MIN, S32_MIN+2, S32_MAX, true, false, false},
  155. {S32_MAX, 1, S32_MIN, S32_MAX-1, S32_MAX, true, false, false},
  156. {S32_MIN, S32_MIN, 0, 0, 0, true, false, true},
  157. {S32_MAX, S32_MAX, -2, 0, 1, true, false, true},
  158. };
  159. DEFINE_TEST_ARRAY(s64) = {
  160. {0, 0, 0, 0, 0, false, false, false},
  161. {0, S64_MAX, S64_MAX, -S64_MAX, 0, false, false, false},
  162. {S64_MAX, 0, S64_MAX, S64_MAX, 0, false, false, false},
  163. {0, S64_MIN, S64_MIN, S64_MIN, 0, false, true, false},
  164. {S64_MIN, 0, S64_MIN, S64_MIN, 0, false, false, false},
  165. {-1, S64_MIN, S64_MAX, S64_MAX, S64_MIN, true, false, true},
  166. {S64_MIN, -1, S64_MAX, -S64_MAX, S64_MIN, true, false, true},
  167. {-1, S64_MAX, S64_MAX-1, S64_MIN, -S64_MAX, false, false, false},
  168. {S64_MAX, -1, S64_MAX-1, S64_MIN, -S64_MAX, false, true, false},
  169. {-1, -S64_MAX, S64_MIN, S64_MAX-1, S64_MAX, false, false, false},
  170. {-S64_MAX, -1, S64_MIN, S64_MIN+2, S64_MAX, false, false, false},
  171. {1, S64_MIN, -S64_MAX, -S64_MAX, S64_MIN, false, true, false},
  172. {S64_MIN, 1, -S64_MAX, S64_MAX, S64_MIN, false, true, false},
  173. {1, S64_MAX, S64_MIN, S64_MIN+2, S64_MAX, true, false, false},
  174. {S64_MAX, 1, S64_MIN, S64_MAX-1, S64_MAX, true, false, false},
  175. {S64_MIN, S64_MIN, 0, 0, 0, true, false, true},
  176. {S64_MAX, S64_MAX, -2, 0, 1, true, false, true},
  177. {-1, -1, -2, 0, 1, false, false, false},
  178. {-1, -128, -129, 127, 128, false, false, false},
  179. {-128, -1, -129, -127, 128, false, false, false},
  180. {0, -S64_MAX, -S64_MAX, S64_MAX, 0, false, false, false},
  181. };
  182. #define check_one_op(t, fmt, op, sym, a, b, r, of) do { \
  183. t _r; \
  184. bool _of; \
  185. \
  186. _of = check_ ## op ## _overflow(a, b, &_r); \
  187. if (_of != of) { \
  188. pr_warn("expected "fmt" "sym" "fmt \
  189. " to%s overflow (type %s)\n", \
  190. a, b, of ? "" : " not", #t); \
  191. err = 1; \
  192. } \
  193. if (_r != r) { \
  194. pr_warn("expected "fmt" "sym" "fmt" == " \
  195. fmt", got "fmt" (type %s)\n", \
  196. a, b, r, _r, #t); \
  197. err = 1; \
  198. } \
  199. } while (0)
  200. #define DEFINE_TEST_FUNC(t, fmt) \
  201. static int __init do_test_ ## t(const struct test_ ## t *p) \
  202. { \
  203. int err = 0; \
  204. \
  205. check_one_op(t, fmt, add, "+", p->a, p->b, p->sum, p->s_of); \
  206. check_one_op(t, fmt, add, "+", p->b, p->a, p->sum, p->s_of); \
  207. check_one_op(t, fmt, sub, "-", p->a, p->b, p->diff, p->d_of); \
  208. check_one_op(t, fmt, mul, "*", p->a, p->b, p->prod, p->p_of); \
  209. check_one_op(t, fmt, mul, "*", p->b, p->a, p->prod, p->p_of); \
  210. \
  211. return err; \
  212. } \
  213. \
  214. static int __init test_ ## t ## _overflow(void) { \
  215. int err = 0; \
  216. unsigned i; \
  217. \
  218. pr_info("%-3s: %zu arithmetic tests\n", #t, \
  219. ARRAY_SIZE(t ## _tests)); \
  220. for (i = 0; i < ARRAY_SIZE(t ## _tests); ++i) \
  221. err |= do_test_ ## t(&t ## _tests[i]); \
  222. return err; \
  223. }
  224. DEFINE_TEST_FUNC(u8, "%d");
  225. DEFINE_TEST_FUNC(s8, "%d");
  226. DEFINE_TEST_FUNC(u16, "%d");
  227. DEFINE_TEST_FUNC(s16, "%d");
  228. DEFINE_TEST_FUNC(u32, "%u");
  229. DEFINE_TEST_FUNC(s32, "%d");
  230. #if BITS_PER_LONG == 64
  231. DEFINE_TEST_FUNC(u64, "%llu");
  232. DEFINE_TEST_FUNC(s64, "%lld");
  233. #endif
  234. static int __init test_overflow_calculation(void)
  235. {
  236. int err = 0;
  237. err |= test_u8_overflow();
  238. err |= test_s8_overflow();
  239. err |= test_u16_overflow();
  240. err |= test_s16_overflow();
  241. err |= test_u32_overflow();
  242. err |= test_s32_overflow();
  243. #if BITS_PER_LONG == 64
  244. err |= test_u64_overflow();
  245. err |= test_s64_overflow();
  246. #endif
  247. return err;
  248. }
  249. static int __init test_overflow_shift(void)
  250. {
  251. int err = 0;
  252. /* Args are: value, shift, type, expected result, overflow expected */
  253. #define TEST_ONE_SHIFT(a, s, t, expect, of) ({ \
  254. int __failed = 0; \
  255. typeof(a) __a = (a); \
  256. typeof(s) __s = (s); \
  257. t __e = (expect); \
  258. t __d; \
  259. bool __of = check_shl_overflow(__a, __s, &__d); \
  260. if (__of != of) { \
  261. pr_warn("expected (%s)(%s << %s) to%s overflow\n", \
  262. #t, #a, #s, of ? "" : " not"); \
  263. __failed = 1; \
  264. } else if (!__of && __d != __e) { \
  265. pr_warn("expected (%s)(%s << %s) == %s\n", \
  266. #t, #a, #s, #expect); \
  267. if ((t)-1 < 0) \
  268. pr_warn("got %lld\n", (s64)__d); \
  269. else \
  270. pr_warn("got %llu\n", (u64)__d); \
  271. __failed = 1; \
  272. } \
  273. if (!__failed) \
  274. pr_info("ok: (%s)(%s << %s) == %s\n", #t, #a, #s, \
  275. of ? "overflow" : #expect); \
  276. __failed; \
  277. })
  278. /* Sane shifts. */
  279. err |= TEST_ONE_SHIFT(1, 0, u8, 1 << 0, false);
  280. err |= TEST_ONE_SHIFT(1, 4, u8, 1 << 4, false);
  281. err |= TEST_ONE_SHIFT(1, 7, u8, 1 << 7, false);
  282. err |= TEST_ONE_SHIFT(0xF, 4, u8, 0xF << 4, false);
  283. err |= TEST_ONE_SHIFT(1, 0, u16, 1 << 0, false);
  284. err |= TEST_ONE_SHIFT(1, 10, u16, 1 << 10, false);
  285. err |= TEST_ONE_SHIFT(1, 15, u16, 1 << 15, false);
  286. err |= TEST_ONE_SHIFT(0xFF, 8, u16, 0xFF << 8, false);
  287. err |= TEST_ONE_SHIFT(1, 0, int, 1 << 0, false);
  288. err |= TEST_ONE_SHIFT(1, 16, int, 1 << 16, false);
  289. err |= TEST_ONE_SHIFT(1, 30, int, 1 << 30, false);
  290. err |= TEST_ONE_SHIFT(1, 0, s32, 1 << 0, false);
  291. err |= TEST_ONE_SHIFT(1, 16, s32, 1 << 16, false);
  292. err |= TEST_ONE_SHIFT(1, 30, s32, 1 << 30, false);
  293. err |= TEST_ONE_SHIFT(1, 0, unsigned int, 1U << 0, false);
  294. err |= TEST_ONE_SHIFT(1, 20, unsigned int, 1U << 20, false);
  295. err |= TEST_ONE_SHIFT(1, 31, unsigned int, 1U << 31, false);
  296. err |= TEST_ONE_SHIFT(0xFFFFU, 16, unsigned int, 0xFFFFU << 16, false);
  297. err |= TEST_ONE_SHIFT(1, 0, u32, 1U << 0, false);
  298. err |= TEST_ONE_SHIFT(1, 20, u32, 1U << 20, false);
  299. err |= TEST_ONE_SHIFT(1, 31, u32, 1U << 31, false);
  300. err |= TEST_ONE_SHIFT(0xFFFFU, 16, u32, 0xFFFFU << 16, false);
  301. err |= TEST_ONE_SHIFT(1, 0, u64, 1ULL << 0, false);
  302. err |= TEST_ONE_SHIFT(1, 40, u64, 1ULL << 40, false);
  303. err |= TEST_ONE_SHIFT(1, 63, u64, 1ULL << 63, false);
  304. err |= TEST_ONE_SHIFT(0xFFFFFFFFULL, 32, u64,
  305. 0xFFFFFFFFULL << 32, false);
  306. /* Sane shift: start and end with 0, without a too-wide shift. */
  307. err |= TEST_ONE_SHIFT(0, 7, u8, 0, false);
  308. err |= TEST_ONE_SHIFT(0, 15, u16, 0, false);
  309. err |= TEST_ONE_SHIFT(0, 31, unsigned int, 0, false);
  310. err |= TEST_ONE_SHIFT(0, 31, u32, 0, false);
  311. err |= TEST_ONE_SHIFT(0, 63, u64, 0, false);
  312. /* Sane shift: start and end with 0, without reaching signed bit. */
  313. err |= TEST_ONE_SHIFT(0, 6, s8, 0, false);
  314. err |= TEST_ONE_SHIFT(0, 14, s16, 0, false);
  315. err |= TEST_ONE_SHIFT(0, 30, int, 0, false);
  316. err |= TEST_ONE_SHIFT(0, 30, s32, 0, false);
  317. err |= TEST_ONE_SHIFT(0, 62, s64, 0, false);
  318. /* Overflow: shifted the bit off the end. */
  319. err |= TEST_ONE_SHIFT(1, 8, u8, 0, true);
  320. err |= TEST_ONE_SHIFT(1, 16, u16, 0, true);
  321. err |= TEST_ONE_SHIFT(1, 32, unsigned int, 0, true);
  322. err |= TEST_ONE_SHIFT(1, 32, u32, 0, true);
  323. err |= TEST_ONE_SHIFT(1, 64, u64, 0, true);
  324. /* Overflow: shifted into the signed bit. */
  325. err |= TEST_ONE_SHIFT(1, 7, s8, 0, true);
  326. err |= TEST_ONE_SHIFT(1, 15, s16, 0, true);
  327. err |= TEST_ONE_SHIFT(1, 31, int, 0, true);
  328. err |= TEST_ONE_SHIFT(1, 31, s32, 0, true);
  329. err |= TEST_ONE_SHIFT(1, 63, s64, 0, true);
  330. /* Overflow: high bit falls off unsigned types. */
  331. /* 10010110 */
  332. err |= TEST_ONE_SHIFT(150, 1, u8, 0, true);
  333. /* 1000100010010110 */
  334. err |= TEST_ONE_SHIFT(34966, 1, u16, 0, true);
  335. /* 10000100000010001000100010010110 */
  336. err |= TEST_ONE_SHIFT(2215151766U, 1, u32, 0, true);
  337. err |= TEST_ONE_SHIFT(2215151766U, 1, unsigned int, 0, true);
  338. /* 1000001000010000010000000100000010000100000010001000100010010110 */
  339. err |= TEST_ONE_SHIFT(9372061470395238550ULL, 1, u64, 0, true);
  340. /* Overflow: bit shifted into signed bit on signed types. */
  341. /* 01001011 */
  342. err |= TEST_ONE_SHIFT(75, 1, s8, 0, true);
  343. /* 0100010001001011 */
  344. err |= TEST_ONE_SHIFT(17483, 1, s16, 0, true);
  345. /* 01000010000001000100010001001011 */
  346. err |= TEST_ONE_SHIFT(1107575883, 1, s32, 0, true);
  347. err |= TEST_ONE_SHIFT(1107575883, 1, int, 0, true);
  348. /* 0100000100001000001000000010000001000010000001000100010001001011 */
  349. err |= TEST_ONE_SHIFT(4686030735197619275LL, 1, s64, 0, true);
  350. /* Overflow: bit shifted past signed bit on signed types. */
  351. /* 01001011 */
  352. err |= TEST_ONE_SHIFT(75, 2, s8, 0, true);
  353. /* 0100010001001011 */
  354. err |= TEST_ONE_SHIFT(17483, 2, s16, 0, true);
  355. /* 01000010000001000100010001001011 */
  356. err |= TEST_ONE_SHIFT(1107575883, 2, s32, 0, true);
  357. err |= TEST_ONE_SHIFT(1107575883, 2, int, 0, true);
  358. /* 0100000100001000001000000010000001000010000001000100010001001011 */
  359. err |= TEST_ONE_SHIFT(4686030735197619275LL, 2, s64, 0, true);
  360. /* Overflow: values larger than destination type. */
  361. err |= TEST_ONE_SHIFT(0x100, 0, u8, 0, true);
  362. err |= TEST_ONE_SHIFT(0xFF, 0, s8, 0, true);
  363. err |= TEST_ONE_SHIFT(0x10000U, 0, u16, 0, true);
  364. err |= TEST_ONE_SHIFT(0xFFFFU, 0, s16, 0, true);
  365. err |= TEST_ONE_SHIFT(0x100000000ULL, 0, u32, 0, true);
  366. err |= TEST_ONE_SHIFT(0x100000000ULL, 0, unsigned int, 0, true);
  367. err |= TEST_ONE_SHIFT(0xFFFFFFFFUL, 0, s32, 0, true);
  368. err |= TEST_ONE_SHIFT(0xFFFFFFFFUL, 0, int, 0, true);
  369. err |= TEST_ONE_SHIFT(0xFFFFFFFFFFFFFFFFULL, 0, s64, 0, true);
  370. /* Nonsense: negative initial value. */
  371. err |= TEST_ONE_SHIFT(-1, 0, s8, 0, true);
  372. err |= TEST_ONE_SHIFT(-1, 0, u8, 0, true);
  373. err |= TEST_ONE_SHIFT(-5, 0, s16, 0, true);
  374. err |= TEST_ONE_SHIFT(-5, 0, u16, 0, true);
  375. err |= TEST_ONE_SHIFT(-10, 0, int, 0, true);
  376. err |= TEST_ONE_SHIFT(-10, 0, unsigned int, 0, true);
  377. err |= TEST_ONE_SHIFT(-100, 0, s32, 0, true);
  378. err |= TEST_ONE_SHIFT(-100, 0, u32, 0, true);
  379. err |= TEST_ONE_SHIFT(-10000, 0, s64, 0, true);
  380. err |= TEST_ONE_SHIFT(-10000, 0, u64, 0, true);
  381. /* Nonsense: negative shift values. */
  382. err |= TEST_ONE_SHIFT(0, -5, s8, 0, true);
  383. err |= TEST_ONE_SHIFT(0, -5, u8, 0, true);
  384. err |= TEST_ONE_SHIFT(0, -10, s16, 0, true);
  385. err |= TEST_ONE_SHIFT(0, -10, u16, 0, true);
  386. err |= TEST_ONE_SHIFT(0, -15, int, 0, true);
  387. err |= TEST_ONE_SHIFT(0, -15, unsigned int, 0, true);
  388. err |= TEST_ONE_SHIFT(0, -20, s32, 0, true);
  389. err |= TEST_ONE_SHIFT(0, -20, u32, 0, true);
  390. err |= TEST_ONE_SHIFT(0, -30, s64, 0, true);
  391. err |= TEST_ONE_SHIFT(0, -30, u64, 0, true);
  392. /* Overflow: shifted at or beyond entire type's bit width. */
  393. err |= TEST_ONE_SHIFT(0, 8, u8, 0, true);
  394. err |= TEST_ONE_SHIFT(0, 9, u8, 0, true);
  395. err |= TEST_ONE_SHIFT(0, 8, s8, 0, true);
  396. err |= TEST_ONE_SHIFT(0, 9, s8, 0, true);
  397. err |= TEST_ONE_SHIFT(0, 16, u16, 0, true);
  398. err |= TEST_ONE_SHIFT(0, 17, u16, 0, true);
  399. err |= TEST_ONE_SHIFT(0, 16, s16, 0, true);
  400. err |= TEST_ONE_SHIFT(0, 17, s16, 0, true);
  401. err |= TEST_ONE_SHIFT(0, 32, u32, 0, true);
  402. err |= TEST_ONE_SHIFT(0, 33, u32, 0, true);
  403. err |= TEST_ONE_SHIFT(0, 32, int, 0, true);
  404. err |= TEST_ONE_SHIFT(0, 33, int, 0, true);
  405. err |= TEST_ONE_SHIFT(0, 32, s32, 0, true);
  406. err |= TEST_ONE_SHIFT(0, 33, s32, 0, true);
  407. err |= TEST_ONE_SHIFT(0, 64, u64, 0, true);
  408. err |= TEST_ONE_SHIFT(0, 65, u64, 0, true);
  409. err |= TEST_ONE_SHIFT(0, 64, s64, 0, true);
  410. err |= TEST_ONE_SHIFT(0, 65, s64, 0, true);
  411. /*
  412. * Corner case: for unsigned types, we fail when we've shifted
  413. * through the entire width of bits. For signed types, we might
  414. * want to match this behavior, but that would mean noticing if
  415. * we shift through all but the signed bit, and this is not
  416. * currently detected (but we'll notice an overflow into the
  417. * signed bit). So, for now, we will test this condition but
  418. * mark it as not expected to overflow.
  419. */
  420. err |= TEST_ONE_SHIFT(0, 7, s8, 0, false);
  421. err |= TEST_ONE_SHIFT(0, 15, s16, 0, false);
  422. err |= TEST_ONE_SHIFT(0, 31, int, 0, false);
  423. err |= TEST_ONE_SHIFT(0, 31, s32, 0, false);
  424. err |= TEST_ONE_SHIFT(0, 63, s64, 0, false);
  425. return err;
  426. }
  427. /*
  428. * Deal with the various forms of allocator arguments. See comments above
  429. * the DEFINE_TEST_ALLOC() instances for mapping of the "bits".
  430. */
  431. #define alloc_GFP (GFP_KERNEL | __GFP_NOWARN)
  432. #define alloc010(alloc, arg, sz) alloc(sz, alloc_GFP)
  433. #define alloc011(alloc, arg, sz) alloc(sz, alloc_GFP, NUMA_NO_NODE)
  434. #define alloc000(alloc, arg, sz) alloc(sz)
  435. #define alloc001(alloc, arg, sz) alloc(sz, NUMA_NO_NODE)
  436. #define alloc110(alloc, arg, sz) alloc(arg, sz, alloc_GFP)
  437. #define free0(free, arg, ptr) free(ptr)
  438. #define free1(free, arg, ptr) free(arg, ptr)
  439. /* Wrap around to 16K */
  440. #define TEST_SIZE (5 * 4096)
  441. #define DEFINE_TEST_ALLOC(func, free_func, want_arg, want_gfp, want_node)\
  442. static int __init test_ ## func (void *arg) \
  443. { \
  444. volatile size_t a = TEST_SIZE; \
  445. volatile size_t b = (SIZE_MAX / TEST_SIZE) + 1; \
  446. void *ptr; \
  447. \
  448. /* Tiny allocation test. */ \
  449. ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg, 1);\
  450. if (!ptr) { \
  451. pr_warn(#func " failed regular allocation?!\n"); \
  452. return 1; \
  453. } \
  454. free ## want_arg (free_func, arg, ptr); \
  455. \
  456. /* Wrapped allocation test. */ \
  457. ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg, \
  458. a * b); \
  459. if (!ptr) { \
  460. pr_warn(#func " unexpectedly failed bad wrapping?!\n"); \
  461. return 1; \
  462. } \
  463. free ## want_arg (free_func, arg, ptr); \
  464. \
  465. /* Saturated allocation test. */ \
  466. ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg, \
  467. array_size(a, b)); \
  468. if (ptr) { \
  469. pr_warn(#func " missed saturation!\n"); \
  470. free ## want_arg (free_func, arg, ptr); \
  471. return 1; \
  472. } \
  473. pr_info(#func " detected saturation\n"); \
  474. return 0; \
  475. }
  476. /*
  477. * Allocator uses a trailing node argument --------+ (e.g. kmalloc_node())
  478. * Allocator uses the gfp_t argument -----------+ | (e.g. kmalloc())
  479. * Allocator uses a special leading argument + | | (e.g. devm_kmalloc())
  480. * | | |
  481. */
  482. DEFINE_TEST_ALLOC(kmalloc, kfree, 0, 1, 0);
  483. DEFINE_TEST_ALLOC(kmalloc_node, kfree, 0, 1, 1);
  484. DEFINE_TEST_ALLOC(kzalloc, kfree, 0, 1, 0);
  485. DEFINE_TEST_ALLOC(kzalloc_node, kfree, 0, 1, 1);
  486. DEFINE_TEST_ALLOC(vmalloc, vfree, 0, 0, 0);
  487. DEFINE_TEST_ALLOC(vmalloc_node, vfree, 0, 0, 1);
  488. DEFINE_TEST_ALLOC(vzalloc, vfree, 0, 0, 0);
  489. DEFINE_TEST_ALLOC(vzalloc_node, vfree, 0, 0, 1);
  490. DEFINE_TEST_ALLOC(kvmalloc, kvfree, 0, 1, 0);
  491. DEFINE_TEST_ALLOC(kvmalloc_node, kvfree, 0, 1, 1);
  492. DEFINE_TEST_ALLOC(kvzalloc, kvfree, 0, 1, 0);
  493. DEFINE_TEST_ALLOC(kvzalloc_node, kvfree, 0, 1, 1);
  494. DEFINE_TEST_ALLOC(devm_kmalloc, devm_kfree, 1, 1, 0);
  495. DEFINE_TEST_ALLOC(devm_kzalloc, devm_kfree, 1, 1, 0);
  496. static int __init test_overflow_allocation(void)
  497. {
  498. const char device_name[] = "overflow-test";
  499. struct device *dev;
  500. int err = 0;
  501. /* Create dummy device for devm_kmalloc()-family tests. */
  502. dev = root_device_register(device_name);
  503. if (IS_ERR(dev)) {
  504. pr_warn("Cannot register test device\n");
  505. return 1;
  506. }
  507. err |= test_kmalloc(NULL);
  508. err |= test_kmalloc_node(NULL);
  509. err |= test_kzalloc(NULL);
  510. err |= test_kzalloc_node(NULL);
  511. err |= test_kvmalloc(NULL);
  512. err |= test_kvmalloc_node(NULL);
  513. err |= test_kvzalloc(NULL);
  514. err |= test_kvzalloc_node(NULL);
  515. err |= test_vmalloc(NULL);
  516. err |= test_vmalloc_node(NULL);
  517. err |= test_vzalloc(NULL);
  518. err |= test_vzalloc_node(NULL);
  519. err |= test_devm_kmalloc(dev);
  520. err |= test_devm_kzalloc(dev);
  521. device_unregister(dev);
  522. return err;
  523. }
  524. static int __init test_module_init(void)
  525. {
  526. int err = 0;
  527. err |= test_overflow_calculation();
  528. err |= test_overflow_shift();
  529. err |= test_overflow_allocation();
  530. if (err) {
  531. pr_warn("FAIL!\n");
  532. err = -EINVAL;
  533. } else {
  534. pr_info("all tests passed\n");
  535. }
  536. return err;
  537. }
  538. static void __exit test_module_exit(void)
  539. { }
  540. module_init(test_module_init);
  541. module_exit(test_module_exit);
  542. MODULE_LICENSE("Dual MIT/GPL");