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
 58static cpumask_t mask_empty;
 59static cpumask_t mask_all;
 60static cpumask_t mask_tmp;
 61
 62static 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
 73static 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
 83static 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
 91static 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
103static 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
117static 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
130static int test_cpumask_init(struct kunit *test)
131{
132	cpumask_clear(&mask_empty);
133	cpumask_setall(&mask_all);
134
135	return 0;
136}
137
138static 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
148static struct kunit_suite test_cpumask_suite = {
149	.name = "cpumask",
150	.init = test_cpumask_init,
151	.test_cases = test_cpumask_cases,
152};
153kunit_test_suite(test_cpumask_suite);
154
155MODULE_LICENSE("GPL");