Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0 OR MIT
0002 /*
0003  * Test cases for arithmetic overflow checks. See:
0004  * https://www.kernel.org/doc/html/latest/dev-tools/kunit/kunit-tool.html#configuring-building-and-running-tests
0005  *  ./tools/testing/kunit/kunit.py run overflow [--raw_output]
0006  */
0007 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0008 
0009 #include <kunit/test.h>
0010 #include <linux/device.h>
0011 #include <linux/kernel.h>
0012 #include <linux/mm.h>
0013 #include <linux/module.h>
0014 #include <linux/overflow.h>
0015 #include <linux/slab.h>
0016 #include <linux/types.h>
0017 #include <linux/vmalloc.h>
0018 
0019 #define DEFINE_TEST_ARRAY(t)            \
0020     static const struct test_ ## t {    \
0021         t a, b;             \
0022         t sum, diff, prod;      \
0023         bool s_of, d_of, p_of;      \
0024     } t ## _tests[]
0025 
0026 DEFINE_TEST_ARRAY(u8) = {
0027     {0, 0, 0, 0, 0, false, false, false},
0028     {1, 1, 2, 0, 1, false, false, false},
0029     {0, 1, 1, U8_MAX, 0, false, true, false},
0030     {1, 0, 1, 1, 0, false, false, false},
0031     {0, U8_MAX, U8_MAX, 1, 0, false, true, false},
0032     {U8_MAX, 0, U8_MAX, U8_MAX, 0, false, false, false},
0033     {1, U8_MAX, 0, 2, U8_MAX, true, true, false},
0034     {U8_MAX, 1, 0, U8_MAX-1, U8_MAX, true, false, false},
0035     {U8_MAX, U8_MAX, U8_MAX-1, 0, 1, true, false, true},
0036 
0037     {U8_MAX, U8_MAX-1, U8_MAX-2, 1, 2, true, false, true},
0038     {U8_MAX-1, U8_MAX, U8_MAX-2, U8_MAX, 2, true, true, true},
0039 
0040     {1U << 3, 1U << 3, 1U << 4, 0, 1U << 6, false, false, false},
0041     {1U << 4, 1U << 4, 1U << 5, 0, 0, false, false, true},
0042     {1U << 4, 1U << 3, 3*(1U << 3), 1U << 3, 1U << 7, false, false, false},
0043     {1U << 7, 1U << 7, 0, 0, 0, true, false, true},
0044 
0045     {48, 32, 80, 16, 0, false, false, true},
0046     {128, 128, 0, 0, 0, true, false, true},
0047     {123, 234, 101, 145, 110, true, true, true},
0048 };
0049 DEFINE_TEST_ARRAY(u16) = {
0050     {0, 0, 0, 0, 0, false, false, false},
0051     {1, 1, 2, 0, 1, false, false, false},
0052     {0, 1, 1, U16_MAX, 0, false, true, false},
0053     {1, 0, 1, 1, 0, false, false, false},
0054     {0, U16_MAX, U16_MAX, 1, 0, false, true, false},
0055     {U16_MAX, 0, U16_MAX, U16_MAX, 0, false, false, false},
0056     {1, U16_MAX, 0, 2, U16_MAX, true, true, false},
0057     {U16_MAX, 1, 0, U16_MAX-1, U16_MAX, true, false, false},
0058     {U16_MAX, U16_MAX, U16_MAX-1, 0, 1, true, false, true},
0059 
0060     {U16_MAX, U16_MAX-1, U16_MAX-2, 1, 2, true, false, true},
0061     {U16_MAX-1, U16_MAX, U16_MAX-2, U16_MAX, 2, true, true, true},
0062 
0063     {1U << 7, 1U << 7, 1U << 8, 0, 1U << 14, false, false, false},
0064     {1U << 8, 1U << 8, 1U << 9, 0, 0, false, false, true},
0065     {1U << 8, 1U << 7, 3*(1U << 7), 1U << 7, 1U << 15, false, false, false},
0066     {1U << 15, 1U << 15, 0, 0, 0, true, false, true},
0067 
0068     {123, 234, 357, 65425, 28782, false, true, false},
0069     {1234, 2345, 3579, 64425, 10146, false, true, true},
0070 };
0071 DEFINE_TEST_ARRAY(u32) = {
0072     {0, 0, 0, 0, 0, false, false, false},
0073     {1, 1, 2, 0, 1, false, false, false},
0074     {0, 1, 1, U32_MAX, 0, false, true, false},
0075     {1, 0, 1, 1, 0, false, false, false},
0076     {0, U32_MAX, U32_MAX, 1, 0, false, true, false},
0077     {U32_MAX, 0, U32_MAX, U32_MAX, 0, false, false, false},
0078     {1, U32_MAX, 0, 2, U32_MAX, true, true, false},
0079     {U32_MAX, 1, 0, U32_MAX-1, U32_MAX, true, false, false},
0080     {U32_MAX, U32_MAX, U32_MAX-1, 0, 1, true, false, true},
0081 
0082     {U32_MAX, U32_MAX-1, U32_MAX-2, 1, 2, true, false, true},
0083     {U32_MAX-1, U32_MAX, U32_MAX-2, U32_MAX, 2, true, true, true},
0084 
0085     {1U << 15, 1U << 15, 1U << 16, 0, 1U << 30, false, false, false},
0086     {1U << 16, 1U << 16, 1U << 17, 0, 0, false, false, true},
0087     {1U << 16, 1U << 15, 3*(1U << 15), 1U << 15, 1U << 31, false, false, false},
0088     {1U << 31, 1U << 31, 0, 0, 0, true, false, true},
0089 
0090     {-2U, 1U, -1U, -3U, -2U, false, false, false},
0091     {-4U, 5U, 1U, -9U, -20U, true, false, true},
0092 };
0093 
0094 #if BITS_PER_LONG == 64
0095 DEFINE_TEST_ARRAY(u64) = {
0096     {0, 0, 0, 0, 0, false, false, false},
0097     {1, 1, 2, 0, 1, false, false, false},
0098     {0, 1, 1, U64_MAX, 0, false, true, false},
0099     {1, 0, 1, 1, 0, false, false, false},
0100     {0, U64_MAX, U64_MAX, 1, 0, false, true, false},
0101     {U64_MAX, 0, U64_MAX, U64_MAX, 0, false, false, false},
0102     {1, U64_MAX, 0, 2, U64_MAX, true, true, false},
0103     {U64_MAX, 1, 0, U64_MAX-1, U64_MAX, true, false, false},
0104     {U64_MAX, U64_MAX, U64_MAX-1, 0, 1, true, false, true},
0105 
0106     {U64_MAX, U64_MAX-1, U64_MAX-2, 1, 2, true, false, true},
0107     {U64_MAX-1, U64_MAX, U64_MAX-2, U64_MAX, 2, true, true, true},
0108 
0109     {1ULL << 31, 1ULL << 31, 1ULL << 32, 0, 1ULL << 62, false, false, false},
0110     {1ULL << 32, 1ULL << 32, 1ULL << 33, 0, 0, false, false, true},
0111     {1ULL << 32, 1ULL << 31, 3*(1ULL << 31), 1ULL << 31, 1ULL << 63, false, false, false},
0112     {1ULL << 63, 1ULL << 63, 0, 0, 0, true, false, true},
0113     {1000000000ULL /* 10^9 */, 10000000000ULL /* 10^10 */,
0114      11000000000ULL, 18446744064709551616ULL, 10000000000000000000ULL,
0115      false, true, false},
0116     {-15ULL, 10ULL, -5ULL, -25ULL, -150ULL, false, false, true},
0117 };
0118 #endif
0119 
0120 DEFINE_TEST_ARRAY(s8) = {
0121     {0, 0, 0, 0, 0, false, false, false},
0122 
0123     {0, S8_MAX, S8_MAX, -S8_MAX, 0, false, false, false},
0124     {S8_MAX, 0, S8_MAX, S8_MAX, 0, false, false, false},
0125     {0, S8_MIN, S8_MIN, S8_MIN, 0, false, true, false},
0126     {S8_MIN, 0, S8_MIN, S8_MIN, 0, false, false, false},
0127 
0128     {-1, S8_MIN, S8_MAX, S8_MAX, S8_MIN, true, false, true},
0129     {S8_MIN, -1, S8_MAX, -S8_MAX, S8_MIN, true, false, true},
0130     {-1, S8_MAX, S8_MAX-1, S8_MIN, -S8_MAX, false, false, false},
0131     {S8_MAX, -1, S8_MAX-1, S8_MIN, -S8_MAX, false, true, false},
0132     {-1, -S8_MAX, S8_MIN, S8_MAX-1, S8_MAX, false, false, false},
0133     {-S8_MAX, -1, S8_MIN, S8_MIN+2, S8_MAX, false, false, false},
0134 
0135     {1, S8_MIN, -S8_MAX, -S8_MAX, S8_MIN, false, true, false},
0136     {S8_MIN, 1, -S8_MAX, S8_MAX, S8_MIN, false, true, false},
0137     {1, S8_MAX, S8_MIN, S8_MIN+2, S8_MAX, true, false, false},
0138     {S8_MAX, 1, S8_MIN, S8_MAX-1, S8_MAX, true, false, false},
0139 
0140     {S8_MIN, S8_MIN, 0, 0, 0, true, false, true},
0141     {S8_MAX, S8_MAX, -2, 0, 1, true, false, true},
0142 
0143     {-4, -32, -36, 28, -128, false, false, true},
0144     {-4, 32, 28, -36, -128, false, false, false},
0145 };
0146 
0147 DEFINE_TEST_ARRAY(s16) = {
0148     {0, 0, 0, 0, 0, false, false, false},
0149 
0150     {0, S16_MAX, S16_MAX, -S16_MAX, 0, false, false, false},
0151     {S16_MAX, 0, S16_MAX, S16_MAX, 0, false, false, false},
0152     {0, S16_MIN, S16_MIN, S16_MIN, 0, false, true, false},
0153     {S16_MIN, 0, S16_MIN, S16_MIN, 0, false, false, false},
0154 
0155     {-1, S16_MIN, S16_MAX, S16_MAX, S16_MIN, true, false, true},
0156     {S16_MIN, -1, S16_MAX, -S16_MAX, S16_MIN, true, false, true},
0157     {-1, S16_MAX, S16_MAX-1, S16_MIN, -S16_MAX, false, false, false},
0158     {S16_MAX, -1, S16_MAX-1, S16_MIN, -S16_MAX, false, true, false},
0159     {-1, -S16_MAX, S16_MIN, S16_MAX-1, S16_MAX, false, false, false},
0160     {-S16_MAX, -1, S16_MIN, S16_MIN+2, S16_MAX, false, false, false},
0161 
0162     {1, S16_MIN, -S16_MAX, -S16_MAX, S16_MIN, false, true, false},
0163     {S16_MIN, 1, -S16_MAX, S16_MAX, S16_MIN, false, true, false},
0164     {1, S16_MAX, S16_MIN, S16_MIN+2, S16_MAX, true, false, false},
0165     {S16_MAX, 1, S16_MIN, S16_MAX-1, S16_MAX, true, false, false},
0166 
0167     {S16_MIN, S16_MIN, 0, 0, 0, true, false, true},
0168     {S16_MAX, S16_MAX, -2, 0, 1, true, false, true},
0169 };
0170 DEFINE_TEST_ARRAY(s32) = {
0171     {0, 0, 0, 0, 0, false, false, false},
0172 
0173     {0, S32_MAX, S32_MAX, -S32_MAX, 0, false, false, false},
0174     {S32_MAX, 0, S32_MAX, S32_MAX, 0, false, false, false},
0175     {0, S32_MIN, S32_MIN, S32_MIN, 0, false, true, false},
0176     {S32_MIN, 0, S32_MIN, S32_MIN, 0, false, false, false},
0177 
0178     {-1, S32_MIN, S32_MAX, S32_MAX, S32_MIN, true, false, true},
0179     {S32_MIN, -1, S32_MAX, -S32_MAX, S32_MIN, true, false, true},
0180     {-1, S32_MAX, S32_MAX-1, S32_MIN, -S32_MAX, false, false, false},
0181     {S32_MAX, -1, S32_MAX-1, S32_MIN, -S32_MAX, false, true, false},
0182     {-1, -S32_MAX, S32_MIN, S32_MAX-1, S32_MAX, false, false, false},
0183     {-S32_MAX, -1, S32_MIN, S32_MIN+2, S32_MAX, false, false, false},
0184 
0185     {1, S32_MIN, -S32_MAX, -S32_MAX, S32_MIN, false, true, false},
0186     {S32_MIN, 1, -S32_MAX, S32_MAX, S32_MIN, false, true, false},
0187     {1, S32_MAX, S32_MIN, S32_MIN+2, S32_MAX, true, false, false},
0188     {S32_MAX, 1, S32_MIN, S32_MAX-1, S32_MAX, true, false, false},
0189 
0190     {S32_MIN, S32_MIN, 0, 0, 0, true, false, true},
0191     {S32_MAX, S32_MAX, -2, 0, 1, true, false, true},
0192 };
0193 
0194 #if BITS_PER_LONG == 64
0195 DEFINE_TEST_ARRAY(s64) = {
0196     {0, 0, 0, 0, 0, false, false, false},
0197 
0198     {0, S64_MAX, S64_MAX, -S64_MAX, 0, false, false, false},
0199     {S64_MAX, 0, S64_MAX, S64_MAX, 0, false, false, false},
0200     {0, S64_MIN, S64_MIN, S64_MIN, 0, false, true, false},
0201     {S64_MIN, 0, S64_MIN, S64_MIN, 0, false, false, false},
0202 
0203     {-1, S64_MIN, S64_MAX, S64_MAX, S64_MIN, true, false, true},
0204     {S64_MIN, -1, S64_MAX, -S64_MAX, S64_MIN, true, false, true},
0205     {-1, S64_MAX, S64_MAX-1, S64_MIN, -S64_MAX, false, false, false},
0206     {S64_MAX, -1, S64_MAX-1, S64_MIN, -S64_MAX, false, true, false},
0207     {-1, -S64_MAX, S64_MIN, S64_MAX-1, S64_MAX, false, false, false},
0208     {-S64_MAX, -1, S64_MIN, S64_MIN+2, S64_MAX, false, false, false},
0209 
0210     {1, S64_MIN, -S64_MAX, -S64_MAX, S64_MIN, false, true, false},
0211     {S64_MIN, 1, -S64_MAX, S64_MAX, S64_MIN, false, true, false},
0212     {1, S64_MAX, S64_MIN, S64_MIN+2, S64_MAX, true, false, false},
0213     {S64_MAX, 1, S64_MIN, S64_MAX-1, S64_MAX, true, false, false},
0214 
0215     {S64_MIN, S64_MIN, 0, 0, 0, true, false, true},
0216     {S64_MAX, S64_MAX, -2, 0, 1, true, false, true},
0217 
0218     {-1, -1, -2, 0, 1, false, false, false},
0219     {-1, -128, -129, 127, 128, false, false, false},
0220     {-128, -1, -129, -127, 128, false, false, false},
0221     {0, -S64_MAX, -S64_MAX, S64_MAX, 0, false, false, false},
0222 };
0223 #endif
0224 
0225 #define check_one_op(t, fmt, op, sym, a, b, r, of) do {     \
0226     t _r;                           \
0227     bool _of;                       \
0228                                 \
0229     _of = check_ ## op ## _overflow(a, b, &_r);     \
0230     KUNIT_EXPECT_EQ_MSG(test, _of, of,          \
0231         "expected "fmt" "sym" "fmt" to%s overflow (type %s)\n", \
0232         a, b, of ? "" : " not", #t);            \
0233     KUNIT_EXPECT_EQ_MSG(test, _r, r,            \
0234         "expected "fmt" "sym" "fmt" == "fmt", got "fmt" (type %s)\n", \
0235         a, b, r, _r, #t);               \
0236 } while (0)
0237 
0238 #define DEFINE_TEST_FUNC(t, fmt)                    \
0239 static void do_test_ ## t(struct kunit *test, const struct test_ ## t *p) \
0240 {                                   \
0241     check_one_op(t, fmt, add, "+", p->a, p->b, p->sum, p->s_of);    \
0242     check_one_op(t, fmt, add, "+", p->b, p->a, p->sum, p->s_of);    \
0243     check_one_op(t, fmt, sub, "-", p->a, p->b, p->diff, p->d_of);   \
0244     check_one_op(t, fmt, mul, "*", p->a, p->b, p->prod, p->p_of);   \
0245     check_one_op(t, fmt, mul, "*", p->b, p->a, p->prod, p->p_of);   \
0246 }                                   \
0247                                     \
0248 static void t ## _overflow_test(struct kunit *test) {           \
0249     unsigned i;                         \
0250                                     \
0251     for (i = 0; i < ARRAY_SIZE(t ## _tests); ++i)           \
0252         do_test_ ## t(test, &t ## _tests[i]);           \
0253     kunit_info(test, "%zu %s arithmetic tests finished\n",      \
0254         ARRAY_SIZE(t ## _tests), #t);               \
0255 }
0256 
0257 DEFINE_TEST_FUNC(u8, "%d");
0258 DEFINE_TEST_FUNC(s8, "%d");
0259 DEFINE_TEST_FUNC(u16, "%d");
0260 DEFINE_TEST_FUNC(s16, "%d");
0261 DEFINE_TEST_FUNC(u32, "%u");
0262 DEFINE_TEST_FUNC(s32, "%d");
0263 #if BITS_PER_LONG == 64
0264 DEFINE_TEST_FUNC(u64, "%llu");
0265 DEFINE_TEST_FUNC(s64, "%lld");
0266 #endif
0267 
0268 static void overflow_shift_test(struct kunit *test)
0269 {
0270     int count = 0;
0271 
0272 /* Args are: value, shift, type, expected result, overflow expected */
0273 #define TEST_ONE_SHIFT(a, s, t, expect, of) do {            \
0274     typeof(a) __a = (a);                        \
0275     typeof(s) __s = (s);                        \
0276     t __e = (expect);                       \
0277     t __d;                              \
0278     bool __of = check_shl_overflow(__a, __s, &__d);         \
0279     if (__of != of) {                       \
0280         KUNIT_EXPECT_EQ_MSG(test, __of, of,         \
0281             "expected (%s)(%s << %s) to%s overflow\n",  \
0282             #t, #a, #s, of ? "" : " not");          \
0283     } else if (!__of && __d != __e) {               \
0284         KUNIT_EXPECT_EQ_MSG(test, __d, __e,         \
0285             "expected (%s)(%s << %s) == %s\n",      \
0286             #t, #a, #s, #expect);               \
0287         if ((t)-1 < 0)                      \
0288             kunit_info(test, "got %lld\n", (s64)__d);   \
0289         else                            \
0290             kunit_info(test, "got %llu\n", (u64)__d);   \
0291     }                               \
0292     count++;                            \
0293 } while (0)
0294 
0295     /* Sane shifts. */
0296     TEST_ONE_SHIFT(1, 0, u8, 1 << 0, false);
0297     TEST_ONE_SHIFT(1, 4, u8, 1 << 4, false);
0298     TEST_ONE_SHIFT(1, 7, u8, 1 << 7, false);
0299     TEST_ONE_SHIFT(0xF, 4, u8, 0xF << 4, false);
0300     TEST_ONE_SHIFT(1, 0, u16, 1 << 0, false);
0301     TEST_ONE_SHIFT(1, 10, u16, 1 << 10, false);
0302     TEST_ONE_SHIFT(1, 15, u16, 1 << 15, false);
0303     TEST_ONE_SHIFT(0xFF, 8, u16, 0xFF << 8, false);
0304     TEST_ONE_SHIFT(1, 0, int, 1 << 0, false);
0305     TEST_ONE_SHIFT(1, 16, int, 1 << 16, false);
0306     TEST_ONE_SHIFT(1, 30, int, 1 << 30, false);
0307     TEST_ONE_SHIFT(1, 0, s32, 1 << 0, false);
0308     TEST_ONE_SHIFT(1, 16, s32, 1 << 16, false);
0309     TEST_ONE_SHIFT(1, 30, s32, 1 << 30, false);
0310     TEST_ONE_SHIFT(1, 0, unsigned int, 1U << 0, false);
0311     TEST_ONE_SHIFT(1, 20, unsigned int, 1U << 20, false);
0312     TEST_ONE_SHIFT(1, 31, unsigned int, 1U << 31, false);
0313     TEST_ONE_SHIFT(0xFFFFU, 16, unsigned int, 0xFFFFU << 16, false);
0314     TEST_ONE_SHIFT(1, 0, u32, 1U << 0, false);
0315     TEST_ONE_SHIFT(1, 20, u32, 1U << 20, false);
0316     TEST_ONE_SHIFT(1, 31, u32, 1U << 31, false);
0317     TEST_ONE_SHIFT(0xFFFFU, 16, u32, 0xFFFFU << 16, false);
0318     TEST_ONE_SHIFT(1, 0, u64, 1ULL << 0, false);
0319     TEST_ONE_SHIFT(1, 40, u64, 1ULL << 40, false);
0320     TEST_ONE_SHIFT(1, 63, u64, 1ULL << 63, false);
0321     TEST_ONE_SHIFT(0xFFFFFFFFULL, 32, u64, 0xFFFFFFFFULL << 32, false);
0322 
0323     /* Sane shift: start and end with 0, without a too-wide shift. */
0324     TEST_ONE_SHIFT(0, 7, u8, 0, false);
0325     TEST_ONE_SHIFT(0, 15, u16, 0, false);
0326     TEST_ONE_SHIFT(0, 31, unsigned int, 0, false);
0327     TEST_ONE_SHIFT(0, 31, u32, 0, false);
0328     TEST_ONE_SHIFT(0, 63, u64, 0, false);
0329 
0330     /* Sane shift: start and end with 0, without reaching signed bit. */
0331     TEST_ONE_SHIFT(0, 6, s8, 0, false);
0332     TEST_ONE_SHIFT(0, 14, s16, 0, false);
0333     TEST_ONE_SHIFT(0, 30, int, 0, false);
0334     TEST_ONE_SHIFT(0, 30, s32, 0, false);
0335     TEST_ONE_SHIFT(0, 62, s64, 0, false);
0336 
0337     /* Overflow: shifted the bit off the end. */
0338     TEST_ONE_SHIFT(1, 8, u8, 0, true);
0339     TEST_ONE_SHIFT(1, 16, u16, 0, true);
0340     TEST_ONE_SHIFT(1, 32, unsigned int, 0, true);
0341     TEST_ONE_SHIFT(1, 32, u32, 0, true);
0342     TEST_ONE_SHIFT(1, 64, u64, 0, true);
0343 
0344     /* Overflow: shifted into the signed bit. */
0345     TEST_ONE_SHIFT(1, 7, s8, 0, true);
0346     TEST_ONE_SHIFT(1, 15, s16, 0, true);
0347     TEST_ONE_SHIFT(1, 31, int, 0, true);
0348     TEST_ONE_SHIFT(1, 31, s32, 0, true);
0349     TEST_ONE_SHIFT(1, 63, s64, 0, true);
0350 
0351     /* Overflow: high bit falls off unsigned types. */
0352     /* 10010110 */
0353     TEST_ONE_SHIFT(150, 1, u8, 0, true);
0354     /* 1000100010010110 */
0355     TEST_ONE_SHIFT(34966, 1, u16, 0, true);
0356     /* 10000100000010001000100010010110 */
0357     TEST_ONE_SHIFT(2215151766U, 1, u32, 0, true);
0358     TEST_ONE_SHIFT(2215151766U, 1, unsigned int, 0, true);
0359     /* 1000001000010000010000000100000010000100000010001000100010010110 */
0360     TEST_ONE_SHIFT(9372061470395238550ULL, 1, u64, 0, true);
0361 
0362     /* Overflow: bit shifted into signed bit on signed types. */
0363     /* 01001011 */
0364     TEST_ONE_SHIFT(75, 1, s8, 0, true);
0365     /* 0100010001001011 */
0366     TEST_ONE_SHIFT(17483, 1, s16, 0, true);
0367     /* 01000010000001000100010001001011 */
0368     TEST_ONE_SHIFT(1107575883, 1, s32, 0, true);
0369     TEST_ONE_SHIFT(1107575883, 1, int, 0, true);
0370     /* 0100000100001000001000000010000001000010000001000100010001001011 */
0371     TEST_ONE_SHIFT(4686030735197619275LL, 1, s64, 0, true);
0372 
0373     /* Overflow: bit shifted past signed bit on signed types. */
0374     /* 01001011 */
0375     TEST_ONE_SHIFT(75, 2, s8, 0, true);
0376     /* 0100010001001011 */
0377     TEST_ONE_SHIFT(17483, 2, s16, 0, true);
0378     /* 01000010000001000100010001001011 */
0379     TEST_ONE_SHIFT(1107575883, 2, s32, 0, true);
0380     TEST_ONE_SHIFT(1107575883, 2, int, 0, true);
0381     /* 0100000100001000001000000010000001000010000001000100010001001011 */
0382     TEST_ONE_SHIFT(4686030735197619275LL, 2, s64, 0, true);
0383 
0384     /* Overflow: values larger than destination type. */
0385     TEST_ONE_SHIFT(0x100, 0, u8, 0, true);
0386     TEST_ONE_SHIFT(0xFF, 0, s8, 0, true);
0387     TEST_ONE_SHIFT(0x10000U, 0, u16, 0, true);
0388     TEST_ONE_SHIFT(0xFFFFU, 0, s16, 0, true);
0389     TEST_ONE_SHIFT(0x100000000ULL, 0, u32, 0, true);
0390     TEST_ONE_SHIFT(0x100000000ULL, 0, unsigned int, 0, true);
0391     TEST_ONE_SHIFT(0xFFFFFFFFUL, 0, s32, 0, true);
0392     TEST_ONE_SHIFT(0xFFFFFFFFUL, 0, int, 0, true);
0393     TEST_ONE_SHIFT(0xFFFFFFFFFFFFFFFFULL, 0, s64, 0, true);
0394 
0395     /* Nonsense: negative initial value. */
0396     TEST_ONE_SHIFT(-1, 0, s8, 0, true);
0397     TEST_ONE_SHIFT(-1, 0, u8, 0, true);
0398     TEST_ONE_SHIFT(-5, 0, s16, 0, true);
0399     TEST_ONE_SHIFT(-5, 0, u16, 0, true);
0400     TEST_ONE_SHIFT(-10, 0, int, 0, true);
0401     TEST_ONE_SHIFT(-10, 0, unsigned int, 0, true);
0402     TEST_ONE_SHIFT(-100, 0, s32, 0, true);
0403     TEST_ONE_SHIFT(-100, 0, u32, 0, true);
0404     TEST_ONE_SHIFT(-10000, 0, s64, 0, true);
0405     TEST_ONE_SHIFT(-10000, 0, u64, 0, true);
0406 
0407     /* Nonsense: negative shift values. */
0408     TEST_ONE_SHIFT(0, -5, s8, 0, true);
0409     TEST_ONE_SHIFT(0, -5, u8, 0, true);
0410     TEST_ONE_SHIFT(0, -10, s16, 0, true);
0411     TEST_ONE_SHIFT(0, -10, u16, 0, true);
0412     TEST_ONE_SHIFT(0, -15, int, 0, true);
0413     TEST_ONE_SHIFT(0, -15, unsigned int, 0, true);
0414     TEST_ONE_SHIFT(0, -20, s32, 0, true);
0415     TEST_ONE_SHIFT(0, -20, u32, 0, true);
0416     TEST_ONE_SHIFT(0, -30, s64, 0, true);
0417     TEST_ONE_SHIFT(0, -30, u64, 0, true);
0418 
0419     /* Overflow: shifted at or beyond entire type's bit width. */
0420     TEST_ONE_SHIFT(0, 8, u8, 0, true);
0421     TEST_ONE_SHIFT(0, 9, u8, 0, true);
0422     TEST_ONE_SHIFT(0, 8, s8, 0, true);
0423     TEST_ONE_SHIFT(0, 9, s8, 0, true);
0424     TEST_ONE_SHIFT(0, 16, u16, 0, true);
0425     TEST_ONE_SHIFT(0, 17, u16, 0, true);
0426     TEST_ONE_SHIFT(0, 16, s16, 0, true);
0427     TEST_ONE_SHIFT(0, 17, s16, 0, true);
0428     TEST_ONE_SHIFT(0, 32, u32, 0, true);
0429     TEST_ONE_SHIFT(0, 33, u32, 0, true);
0430     TEST_ONE_SHIFT(0, 32, int, 0, true);
0431     TEST_ONE_SHIFT(0, 33, int, 0, true);
0432     TEST_ONE_SHIFT(0, 32, s32, 0, true);
0433     TEST_ONE_SHIFT(0, 33, s32, 0, true);
0434     TEST_ONE_SHIFT(0, 64, u64, 0, true);
0435     TEST_ONE_SHIFT(0, 65, u64, 0, true);
0436     TEST_ONE_SHIFT(0, 64, s64, 0, true);
0437     TEST_ONE_SHIFT(0, 65, s64, 0, true);
0438 
0439     /*
0440      * Corner case: for unsigned types, we fail when we've shifted
0441      * through the entire width of bits. For signed types, we might
0442      * want to match this behavior, but that would mean noticing if
0443      * we shift through all but the signed bit, and this is not
0444      * currently detected (but we'll notice an overflow into the
0445      * signed bit). So, for now, we will test this condition but
0446      * mark it as not expected to overflow.
0447      */
0448     TEST_ONE_SHIFT(0, 7, s8, 0, false);
0449     TEST_ONE_SHIFT(0, 15, s16, 0, false);
0450     TEST_ONE_SHIFT(0, 31, int, 0, false);
0451     TEST_ONE_SHIFT(0, 31, s32, 0, false);
0452     TEST_ONE_SHIFT(0, 63, s64, 0, false);
0453 
0454     kunit_info(test, "%d shift tests finished\n", count);
0455 #undef TEST_ONE_SHIFT
0456 }
0457 
0458 /*
0459  * Deal with the various forms of allocator arguments. See comments above
0460  * the DEFINE_TEST_ALLOC() instances for mapping of the "bits".
0461  */
0462 #define alloc_GFP        (GFP_KERNEL | __GFP_NOWARN)
0463 #define alloc010(alloc, arg, sz) alloc(sz, alloc_GFP)
0464 #define alloc011(alloc, arg, sz) alloc(sz, alloc_GFP, NUMA_NO_NODE)
0465 #define alloc000(alloc, arg, sz) alloc(sz)
0466 #define alloc001(alloc, arg, sz) alloc(sz, NUMA_NO_NODE)
0467 #define alloc110(alloc, arg, sz) alloc(arg, sz, alloc_GFP)
0468 #define free0(free, arg, ptr)    free(ptr)
0469 #define free1(free, arg, ptr)    free(arg, ptr)
0470 
0471 /* Wrap around to 16K */
0472 #define TEST_SIZE       (5 * 4096)
0473 
0474 #define DEFINE_TEST_ALLOC(func, free_func, want_arg, want_gfp, want_node)\
0475 static void test_ ## func (struct kunit *test, void *arg)       \
0476 {                                   \
0477     volatile size_t a = TEST_SIZE;                  \
0478     volatile size_t b = (SIZE_MAX / TEST_SIZE) + 1;         \
0479     void *ptr;                          \
0480                                     \
0481     /* Tiny allocation test. */                 \
0482     ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg, 1);\
0483     KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG(test, ptr,         \
0484                 #func " failed regular allocation?!\n");    \
0485     free ## want_arg (free_func, arg, ptr);             \
0486                                     \
0487     /* Wrapped allocation test. */                  \
0488     ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg,    \
0489                               a * b);   \
0490     KUNIT_ASSERT_NOT_ERR_OR_NULL_MSG(test, ptr,         \
0491                 #func " unexpectedly failed bad wrapping?!\n"); \
0492     free ## want_arg (free_func, arg, ptr);             \
0493                                     \
0494     /* Saturated allocation test. */                \
0495     ptr = alloc ## want_arg ## want_gfp ## want_node (func, arg,    \
0496                            array_size(a, b));   \
0497     if (ptr) {                          \
0498         KUNIT_FAIL(test, #func " missed saturation!\n");    \
0499         free ## want_arg (free_func, arg, ptr);         \
0500     }                               \
0501 }
0502 
0503 /*
0504  * Allocator uses a trailing node argument --------+  (e.g. kmalloc_node())
0505  * Allocator uses the gfp_t argument -----------+  |  (e.g. kmalloc())
0506  * Allocator uses a special leading argument +  |  |  (e.g. devm_kmalloc())
0507  *                                           |  |  |
0508  */
0509 DEFINE_TEST_ALLOC(kmalloc,   kfree,      0, 1, 0);
0510 DEFINE_TEST_ALLOC(kmalloc_node,  kfree,      0, 1, 1);
0511 DEFINE_TEST_ALLOC(kzalloc,   kfree,      0, 1, 0);
0512 DEFINE_TEST_ALLOC(kzalloc_node,  kfree,      0, 1, 1);
0513 DEFINE_TEST_ALLOC(__vmalloc,     vfree,      0, 1, 0);
0514 DEFINE_TEST_ALLOC(kvmalloc,  kvfree,     0, 1, 0);
0515 DEFINE_TEST_ALLOC(kvmalloc_node, kvfree,     0, 1, 1);
0516 DEFINE_TEST_ALLOC(kvzalloc,  kvfree,     0, 1, 0);
0517 DEFINE_TEST_ALLOC(kvzalloc_node, kvfree,     0, 1, 1);
0518 DEFINE_TEST_ALLOC(devm_kmalloc,  devm_kfree, 1, 1, 0);
0519 DEFINE_TEST_ALLOC(devm_kzalloc,  devm_kfree, 1, 1, 0);
0520 
0521 static void overflow_allocation_test(struct kunit *test)
0522 {
0523     const char device_name[] = "overflow-test";
0524     struct device *dev;
0525     int count = 0;
0526 
0527 #define check_allocation_overflow(alloc)    do {    \
0528     count++;                    \
0529     test_ ## alloc(test, dev);          \
0530 } while (0)
0531 
0532     /* Create dummy device for devm_kmalloc()-family tests. */
0533     dev = root_device_register(device_name);
0534     KUNIT_ASSERT_FALSE_MSG(test, IS_ERR(dev),
0535                    "Cannot register test device\n");
0536 
0537     check_allocation_overflow(kmalloc);
0538     check_allocation_overflow(kmalloc_node);
0539     check_allocation_overflow(kzalloc);
0540     check_allocation_overflow(kzalloc_node);
0541     check_allocation_overflow(__vmalloc);
0542     check_allocation_overflow(kvmalloc);
0543     check_allocation_overflow(kvmalloc_node);
0544     check_allocation_overflow(kvzalloc);
0545     check_allocation_overflow(kvzalloc_node);
0546     check_allocation_overflow(devm_kmalloc);
0547     check_allocation_overflow(devm_kzalloc);
0548 
0549     device_unregister(dev);
0550 
0551     kunit_info(test, "%d allocation overflow tests finished\n", count);
0552 #undef check_allocation_overflow
0553 }
0554 
0555 struct __test_flex_array {
0556     unsigned long flags;
0557     size_t count;
0558     unsigned long data[];
0559 };
0560 
0561 static void overflow_size_helpers_test(struct kunit *test)
0562 {
0563     /* Make sure struct_size() can be used in a constant expression. */
0564     u8 ce_array[struct_size((struct __test_flex_array *)0, data, 55)];
0565     struct __test_flex_array *obj;
0566     int count = 0;
0567     int var;
0568     volatile int unconst = 0;
0569 
0570     /* Verify constant expression against runtime version. */
0571     var = 55;
0572     OPTIMIZER_HIDE_VAR(var);
0573     KUNIT_EXPECT_EQ(test, sizeof(ce_array), struct_size(obj, data, var));
0574 
0575 #define check_one_size_helper(expected, func, args...)  do {    \
0576     size_t _r = func(args);                 \
0577     KUNIT_EXPECT_EQ_MSG(test, _r, expected,         \
0578         "expected " #func "(" #args ") to return %zu but got %zu instead\n", \
0579         (size_t)(expected), _r);            \
0580     count++;                        \
0581 } while (0)
0582 
0583     var = 4;
0584     check_one_size_helper(20,   size_mul, var++, 5);
0585     check_one_size_helper(20,   size_mul, 4, var++);
0586     check_one_size_helper(0,    size_mul, 0, 3);
0587     check_one_size_helper(0,    size_mul, 3, 0);
0588     check_one_size_helper(6,    size_mul, 2, 3);
0589     check_one_size_helper(SIZE_MAX, size_mul, SIZE_MAX,  1);
0590     check_one_size_helper(SIZE_MAX, size_mul, SIZE_MAX,  3);
0591     check_one_size_helper(SIZE_MAX, size_mul, SIZE_MAX, -3);
0592 
0593     var = 4;
0594     check_one_size_helper(9,    size_add, var++, 5);
0595     check_one_size_helper(9,    size_add, 4, var++);
0596     check_one_size_helper(9,    size_add, 9, 0);
0597     check_one_size_helper(9,    size_add, 0, 9);
0598     check_one_size_helper(5,    size_add, 2, 3);
0599     check_one_size_helper(SIZE_MAX, size_add, SIZE_MAX,  1);
0600     check_one_size_helper(SIZE_MAX, size_add, SIZE_MAX,  3);
0601     check_one_size_helper(SIZE_MAX, size_add, SIZE_MAX, -3);
0602 
0603     var = 4;
0604     check_one_size_helper(1,    size_sub, var--, 3);
0605     check_one_size_helper(1,    size_sub, 4, var--);
0606     check_one_size_helper(1,    size_sub, 3, 2);
0607     check_one_size_helper(9,    size_sub, 9, 0);
0608     check_one_size_helper(SIZE_MAX, size_sub, 9, -3);
0609     check_one_size_helper(SIZE_MAX, size_sub, 0, 9);
0610     check_one_size_helper(SIZE_MAX, size_sub, 2, 3);
0611     check_one_size_helper(SIZE_MAX, size_sub, SIZE_MAX,  0);
0612     check_one_size_helper(SIZE_MAX, size_sub, SIZE_MAX, 10);
0613     check_one_size_helper(SIZE_MAX, size_sub, 0,  SIZE_MAX);
0614     check_one_size_helper(SIZE_MAX, size_sub, 14, SIZE_MAX);
0615     check_one_size_helper(SIZE_MAX - 2, size_sub, SIZE_MAX - 1,  1);
0616     check_one_size_helper(SIZE_MAX - 4, size_sub, SIZE_MAX - 1,  3);
0617     check_one_size_helper(1,        size_sub, SIZE_MAX - 1, -3);
0618 
0619     var = 4;
0620     check_one_size_helper(4 * sizeof(*obj->data),
0621                   flex_array_size, obj, data, var++);
0622     check_one_size_helper(5 * sizeof(*obj->data),
0623                   flex_array_size, obj, data, var++);
0624     check_one_size_helper(0, flex_array_size, obj, data, 0 + unconst);
0625     check_one_size_helper(sizeof(*obj->data),
0626                   flex_array_size, obj, data, 1 + unconst);
0627     check_one_size_helper(7 * sizeof(*obj->data),
0628                   flex_array_size, obj, data, 7 + unconst);
0629     check_one_size_helper(SIZE_MAX,
0630                   flex_array_size, obj, data, -1 + unconst);
0631     check_one_size_helper(SIZE_MAX,
0632                   flex_array_size, obj, data, SIZE_MAX - 4 + unconst);
0633 
0634     var = 4;
0635     check_one_size_helper(sizeof(*obj) + (4 * sizeof(*obj->data)),
0636                   struct_size, obj, data, var++);
0637     check_one_size_helper(sizeof(*obj) + (5 * sizeof(*obj->data)),
0638                   struct_size, obj, data, var++);
0639     check_one_size_helper(sizeof(*obj), struct_size, obj, data, 0 + unconst);
0640     check_one_size_helper(sizeof(*obj) + sizeof(*obj->data),
0641                   struct_size, obj, data, 1 + unconst);
0642     check_one_size_helper(SIZE_MAX,
0643                   struct_size, obj, data, -3 + unconst);
0644     check_one_size_helper(SIZE_MAX,
0645                   struct_size, obj, data, SIZE_MAX - 3 + unconst);
0646 
0647     kunit_info(test, "%d overflow size helper tests finished\n", count);
0648 #undef check_one_size_helper
0649 }
0650 
0651 static struct kunit_case overflow_test_cases[] = {
0652     KUNIT_CASE(u8_overflow_test),
0653     KUNIT_CASE(s8_overflow_test),
0654     KUNIT_CASE(u16_overflow_test),
0655     KUNIT_CASE(s16_overflow_test),
0656     KUNIT_CASE(u32_overflow_test),
0657     KUNIT_CASE(s32_overflow_test),
0658 /* Clang 13 and earlier generate unwanted libcalls on 32-bit. */
0659 #if BITS_PER_LONG == 64
0660     KUNIT_CASE(u64_overflow_test),
0661     KUNIT_CASE(s64_overflow_test),
0662 #endif
0663     KUNIT_CASE(overflow_shift_test),
0664     KUNIT_CASE(overflow_allocation_test),
0665     KUNIT_CASE(overflow_size_helpers_test),
0666     {}
0667 };
0668 
0669 static struct kunit_suite overflow_test_suite = {
0670     .name = "overflow",
0671     .test_cases = overflow_test_cases,
0672 };
0673 
0674 kunit_test_suite(overflow_test_suite);
0675 
0676 MODULE_LICENSE("Dual MIT/GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!