lib/cpumask_kunit.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * KUnit tests for cpumask.
   4  *
   5  * Author: Sander Vanheule <sander@svanheule.net>
   6  */
   7
   8 #include <kunit/test.h>
   9 #include <linux/cpu.h>
  10 #include <linux/cpumask.h>
  11
  12 #define MASK_MSG(m) \
  13         "%s contains %sCPUs %*pbl", #m, (cpumask_weight(m) ? "" : "no "), \
  14         nr_cpumask_bits, cpumask_bits(m)
  15
  16 #define EXPECT_FOR_EACH_CPU_EQ(test, mask)                      \
  17         do {                                                    \
  18                 const cpumask_t *m = (mask);                    \
  19                 int mask_weight = cpumask_weight(m);            \
  20                 int cpu, iter = 0;                              \
  21                 for_each_cpu(cpu, m)                            \
  22                         iter++;                                 \
  23                 KUNIT_EXPECT_EQ_MSG((test), mask_weight, iter, MASK_MSG(mask)); \
  24         } while (0)
  25
  26 #define EXPECT_FOR_EACH_CPU_OP_EQ(test, op, mask1, mask2)                       \
  27         do {                                                                    \
  28                 const cpumask_t *m1 = (mask1);                                  \
  29                 const cpumask_t *m2 = (mask2);                                  \
  30                 int weight;                                                     \
  31                 int cpu, iter = 0;                                              \
  32                 cpumask_##op(&mask_tmp, m1, m2);                                \
  33                 weight = cpumask_weight(&mask_tmp);                             \
  34                 for_each_cpu_##op(cpu, mask1, mask2)                            \
  35                         iter++;                                                 \
  36                 KUNIT_EXPECT_EQ((test), weight, iter);                          \
  37         } while (0)
  38
  39 #define EXPECT_FOR_EACH_CPU_WRAP_EQ(test, mask)                 \
  40         do {                                                    \
  41                 const cpumask_t *m = (mask);                    \
  42                 int mask_weight = cpumask_weight(m);            \
  43                 int cpu, iter = 0;                              \
  44                 for_each_cpu_wrap(cpu, m, nr_cpu_ids / 2)       \
  45                         iter++;                                 \
  46                 KUNIT_EXPECT_EQ_MSG((test), mask_weight, iter, MASK_MSG(mask)); \
  47         } while (0)
  48
  49 #define EXPECT_FOR_EACH_CPU_BUILTIN_EQ(test, name)              \
  50         do {                                                    \
  51                 int mask_weight = num_##name##_cpus();          \
  52                 int cpu, iter = 0;                              \
  53                 for_each_##name##_cpu(cpu)                      \
  54                         iter++;                                 \
  55                 KUNIT_EXPECT_EQ_MSG((test), mask_weight, iter, MASK_MSG(cpu_##name##_mask));    \
  56         } while (0)
  57
  58 static cpumask_t mask_empty;
  59 static cpumask_t mask_all;
  60 static cpumask_t mask_tmp;
  61
  62 static void test_cpumask_weight(struct kunit *test)
  63 {
  64         KUNIT_EXPECT_TRUE_MSG(test, cpumask_empty(&mask_empty), MASK_MSG(&mask_empty));
  65         KUNIT_EXPECT_TRUE_MSG(test, cpumask_full(&mask_all), MASK_MSG(&mask_all));
  66
  67         KUNIT_EXPECT_EQ_MSG(test, 0, cpumask_weight(&mask_empty), MASK_MSG(&mask_empty));
  68         KUNIT_EXPECT_EQ_MSG(test, nr_cpu_ids, cpumask_weight(cpu_possible_mask),
  69                             MASK_MSG(cpu_possible_mask));
  70         KUNIT_EXPECT_EQ_MSG(test, nr_cpu_ids, cpumask_weight(&mask_all), MASK_MSG(&mask_all));
  71 }
  72
  73 static void test_cpumask_first(struct kunit *test)
  74 {
  75         KUNIT_EXPECT_LE_MSG(test, nr_cpu_ids, cpumask_first(&mask_empty), MASK_MSG(&mask_empty));
  76         KUNIT_EXPECT_EQ_MSG(test, 0, cpumask_first(cpu_possible_mask), MASK_MSG(cpu_possible_mask));
  77
  78         KUNIT_EXPECT_EQ_MSG(test, 0, cpumask_first_zero(&mask_empty), MASK_MSG(&mask_empty));
  79         KUNIT_EXPECT_LE_MSG(test, nr_cpu_ids, cpumask_first_zero(cpu_possible_mask),
  80                             MASK_MSG(cpu_possible_mask));
  81 }
  82
  83 static void test_cpumask_last(struct kunit *test)
  84 {
  85         KUNIT_EXPECT_LE_MSG(test, nr_cpumask_bits, cpumask_last(&mask_empty),
  86                             MASK_MSG(&mask_empty));
  87         KUNIT_EXPECT_EQ_MSG(test, nr_cpu_ids - 1, cpumask_last(cpu_possible_mask),
  88                             MASK_MSG(cpu_possible_mask));
  89 }
  90
  91 static void test_cpumask_next(struct kunit *test)
  92 {
  93         KUNIT_EXPECT_EQ_MSG(test, 0, cpumask_next_zero(-1, &mask_empty), MASK_MSG(&mask_empty));
  94         KUNIT_EXPECT_LE_MSG(test, nr_cpu_ids, cpumask_next_zero(-1, cpu_possible_mask),
  95                             MASK_MSG(cpu_possible_mask));
  96
  97         KUNIT_EXPECT_LE_MSG(test, nr_cpu_ids, cpumask_next(-1, &mask_empty),
  98                             MASK_MSG(&mask_empty));
  99         KUNIT_EXPECT_EQ_MSG(test, 0, cpumask_next(-1, cpu_possible_mask),
 100                             MASK_MSG(cpu_possible_mask));
 101 }
 102
 103 static void test_cpumask_iterators(struct kunit *test)
 104 {
 105         EXPECT_FOR_EACH_CPU_EQ(test, &mask_empty);
 106         EXPECT_FOR_EACH_CPU_WRAP_EQ(test, &mask_empty);
 107         EXPECT_FOR_EACH_CPU_OP_EQ(test, and, &mask_empty, &mask_empty);
 108         EXPECT_FOR_EACH_CPU_OP_EQ(test, and, cpu_possible_mask, &mask_empty);
 109         EXPECT_FOR_EACH_CPU_OP_EQ(test, andnot, &mask_empty, &mask_empty);
 110
 111         EXPECT_FOR_EACH_CPU_EQ(test, cpu_possible_mask);
 112         EXPECT_FOR_EACH_CPU_WRAP_EQ(test, cpu_possible_mask);
 113         EXPECT_FOR_EACH_CPU_OP_EQ(test, and, cpu_possible_mask, cpu_possible_mask);
 114         EXPECT_FOR_EACH_CPU_OP_EQ(test, andnot, cpu_possible_mask, &mask_empty);
 115 }
 116
 117 static void test_cpumask_iterators_builtin(struct kunit *test)
 118 {
 119         EXPECT_FOR_EACH_CPU_BUILTIN_EQ(test, possible);
 120
 121         /* Ensure the dynamic masks are stable while running the tests */
 122         cpu_hotplug_disable();
 123
 124         EXPECT_FOR_EACH_CPU_BUILTIN_EQ(test, online);
 125         EXPECT_FOR_EACH_CPU_BUILTIN_EQ(test, present);
 126
 127         cpu_hotplug_enable();
 128 }
 129
 130 static int test_cpumask_init(struct kunit *test)
 131 {
 132         cpumask_clear(&mask_empty);
 133         cpumask_setall(&mask_all);
 134
 135         return 0;
 136 }
 137
 138 static struct kunit_case test_cpumask_cases[] = {
 139         KUNIT_CASE(test_cpumask_weight),
 140         KUNIT_CASE(test_cpumask_first),
 141         KUNIT_CASE(test_cpumask_last),
 142         KUNIT_CASE(test_cpumask_next),
 143         KUNIT_CASE(test_cpumask_iterators),
 144         KUNIT_CASE(test_cpumask_iterators_builtin),
 145         {}
 146 };
 147
 148 static struct kunit_suite test_cpumask_suite = {
 149         .name = "cpumask",
 150         .init = test_cpumask_init,
 151         .test_cases = test_cpumask_cases,
 152 };
 153 kunit_test_suite(test_cpumask_suite);
 154
 155 MODULE_DESCRIPTION("KUnit tests for cpumask");
 156 MODULE_LICENSE("GPL");