lib/test_cpumask.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 EXPECT_FOR_EACH_CPU_EQ(test, mask)                      \
  13         do {                                                    \
  14                 const cpumask_t *m = (mask);                    \
  15                 int mask_weight = cpumask_weight(m);            \
  16                 int cpu, iter = 0;                              \
  17                 for_each_cpu(cpu, m)                            \
  18                         iter++;                                 \
  19                 KUNIT_EXPECT_EQ((test), mask_weight, iter);     \
  20         } while (0)
  21
  22 #define EXPECT_FOR_EACH_CPU_NOT_EQ(test, mask)                                  \
  23         do {                                                                    \
  24                 const cpumask_t *m = (mask);                                    \
  25                 int mask_weight = cpumask_weight(m);                            \
  26                 int cpu, iter = 0;                                              \
  27                 for_each_cpu_not(cpu, m)                                        \
  28                         iter++;                                                 \
  29                 KUNIT_EXPECT_EQ((test), nr_cpu_ids - mask_weight, iter);        \
  30         } while (0)
  31
  32 #define EXPECT_FOR_EACH_CPU_WRAP_EQ(test, mask)                 \
  33         do {                                                    \
  34                 const cpumask_t *m = (mask);                    \
  35                 int mask_weight = cpumask_weight(m);            \
  36                 int cpu, iter = 0;                              \
  37                 for_each_cpu_wrap(cpu, m, nr_cpu_ids / 2)       \
  38                         iter++;                                 \
  39                 KUNIT_EXPECT_EQ((test), mask_weight, iter);     \
  40         } while (0)
  41
  42 #define EXPECT_FOR_EACH_CPU_BUILTIN_EQ(test, name)              \
  43         do {                                                    \
  44                 int mask_weight = num_##name##_cpus();          \
  45                 int cpu, iter = 0;                              \
  46                 for_each_##name##_cpu(cpu)                      \
  47                         iter++;                                 \
  48                 KUNIT_EXPECT_EQ((test), mask_weight, iter);     \
  49         } while (0)
  50
  51 static cpumask_t mask_empty;
  52 static cpumask_t mask_all;
  53
  54 static void test_cpumask_weight(struct kunit *test)
  55 {
  56         KUNIT_EXPECT_TRUE(test, cpumask_empty(&mask_empty));
  57         KUNIT_EXPECT_TRUE(test, cpumask_full(&mask_all));
  58
  59         KUNIT_EXPECT_EQ(test, 0, cpumask_weight(&mask_empty));
  60         KUNIT_EXPECT_EQ(test, nr_cpu_ids, cpumask_weight(cpu_possible_mask));
  61         KUNIT_EXPECT_EQ(test, nr_cpumask_bits, cpumask_weight(&mask_all));
  62 }
  63
  64 static void test_cpumask_first(struct kunit *test)
  65 {
  66         KUNIT_EXPECT_LE(test, nr_cpu_ids, cpumask_first(&mask_empty));
  67         KUNIT_EXPECT_EQ(test, 0, cpumask_first(cpu_possible_mask));
  68
  69         KUNIT_EXPECT_EQ(test, 0, cpumask_first_zero(&mask_empty));
  70         KUNIT_EXPECT_LE(test, nr_cpu_ids, cpumask_first_zero(cpu_possible_mask));
  71 }
  72
  73 static void test_cpumask_last(struct kunit *test)
  74 {
  75         KUNIT_EXPECT_LE(test, nr_cpumask_bits, cpumask_last(&mask_empty));
  76         KUNIT_EXPECT_EQ(test, nr_cpu_ids - 1, cpumask_last(cpu_possible_mask));
  77 }
  78
  79 static void test_cpumask_next(struct kunit *test)
  80 {
  81         KUNIT_EXPECT_EQ(test, 0, cpumask_next_zero(-1, &mask_empty));
  82         KUNIT_EXPECT_LE(test, nr_cpu_ids, cpumask_next_zero(-1, cpu_possible_mask));
  83
  84         KUNIT_EXPECT_LE(test, nr_cpu_ids, cpumask_next(-1, &mask_empty));
  85         KUNIT_EXPECT_EQ(test, 0, cpumask_next(-1, cpu_possible_mask));
  86 }
  87
  88 static void test_cpumask_iterators(struct kunit *test)
  89 {
  90         EXPECT_FOR_EACH_CPU_EQ(test, &mask_empty);
  91         EXPECT_FOR_EACH_CPU_NOT_EQ(test, &mask_empty);
  92         EXPECT_FOR_EACH_CPU_WRAP_EQ(test, &mask_empty);
  93
  94         EXPECT_FOR_EACH_CPU_EQ(test, cpu_possible_mask);
  95         EXPECT_FOR_EACH_CPU_NOT_EQ(test, cpu_possible_mask);
  96         EXPECT_FOR_EACH_CPU_WRAP_EQ(test, cpu_possible_mask);
  97 }
  98
  99 static void test_cpumask_iterators_builtin(struct kunit *test)
 100 {
 101         EXPECT_FOR_EACH_CPU_BUILTIN_EQ(test, possible);
 102
 103         /* Ensure the dynamic masks are stable while running the tests */
 104         cpu_hotplug_disable();
 105
 106         EXPECT_FOR_EACH_CPU_BUILTIN_EQ(test, online);
 107         EXPECT_FOR_EACH_CPU_BUILTIN_EQ(test, present);
 108
 109         cpu_hotplug_enable();
 110 }
 111
 112 static int test_cpumask_init(struct kunit *test)
 113 {
 114         cpumask_clear(&mask_empty);
 115         cpumask_setall(&mask_all);
 116
 117         return 0;
 118 }
 119
 120 static struct kunit_case test_cpumask_cases[] = {
 121         KUNIT_CASE(test_cpumask_weight),
 122         KUNIT_CASE(test_cpumask_first),
 123         KUNIT_CASE(test_cpumask_last),
 124         KUNIT_CASE(test_cpumask_next),
 125         KUNIT_CASE(test_cpumask_iterators),
 126         KUNIT_CASE(test_cpumask_iterators_builtin),
 127         {}
 128 };
 129
 130 static struct kunit_suite test_cpumask_suite = {
 131         .name = "cpumask",
 132         .init = test_cpumask_init,
 133         .test_cases = test_cpumask_cases,
 134 };
 135 kunit_test_suite(test_cpumask_suite);
 136
 137 MODULE_LICENSE("GPL");