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");
156