1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * KUnit test for hw_breakpoint constraints accounting logic.
4  *
5  * Copyright (C) 2022, Google LLC.
6  */
7 
8 #include <kunit/test.h>
9 #include <linux/cpumask.h>
10 #include <linux/hw_breakpoint.h>
11 #include <linux/kthread.h>
12 #include <linux/perf_event.h>
13 #include <asm/hw_breakpoint.h>
14 
15 #define TEST_REQUIRES_BP_SLOTS(test, slots)						\
16 	do {										\
17 		if ((slots) > get_test_bp_slots()) {					\
18 			kunit_skip((test), "Requires breakpoint slots: %d > %d", slots,	\
19 				   get_test_bp_slots());				\
20 		}									\
21 	} while (0)
22 
23 #define TEST_EXPECT_NOSPC(expr) KUNIT_EXPECT_EQ(test, -ENOSPC, PTR_ERR(expr))
24 
25 #define MAX_TEST_BREAKPOINTS 512
26 
27 static char break_vars[MAX_TEST_BREAKPOINTS];
28 static struct perf_event *test_bps[MAX_TEST_BREAKPOINTS];
29 static struct task_struct *__other_task;
30 
register_test_bp(int cpu,struct task_struct * tsk,int idx)31 static struct perf_event *register_test_bp(int cpu, struct task_struct *tsk, int idx)
32 {
33 	struct perf_event_attr attr = {};
34 
35 	if (WARN_ON(idx < 0 || idx >= MAX_TEST_BREAKPOINTS))
36 		return NULL;
37 
38 	hw_breakpoint_init(&attr);
39 	attr.bp_addr = (unsigned long)&break_vars[idx];
40 	attr.bp_len = HW_BREAKPOINT_LEN_1;
41 	attr.bp_type = HW_BREAKPOINT_RW;
42 	return perf_event_create_kernel_counter(&attr, cpu, tsk, NULL, NULL);
43 }
44 
unregister_test_bp(struct perf_event ** bp)45 static void unregister_test_bp(struct perf_event **bp)
46 {
47 	if (WARN_ON(IS_ERR(*bp)))
48 		return;
49 	if (WARN_ON(!*bp))
50 		return;
51 	unregister_hw_breakpoint(*bp);
52 	*bp = NULL;
53 }
54 
get_test_bp_slots(void)55 static int get_test_bp_slots(void)
56 {
57 	static int slots;
58 
59 	if (!slots)
60 		slots = hw_breakpoint_slots(TYPE_DATA);
61 
62 	return slots;
63 }
64 
fill_one_bp_slot(struct kunit * test,int * id,int cpu,struct task_struct * tsk)65 static void fill_one_bp_slot(struct kunit *test, int *id, int cpu, struct task_struct *tsk)
66 {
67 	struct perf_event *bp = register_test_bp(cpu, tsk, *id);
68 
69 	KUNIT_ASSERT_NOT_NULL(test, bp);
70 	KUNIT_ASSERT_FALSE(test, IS_ERR(bp));
71 	KUNIT_ASSERT_NULL(test, test_bps[*id]);
72 	test_bps[(*id)++] = bp;
73 }
74 
75 /*
76  * Fills up the given @cpu/@tsk with breakpoints, only leaving @skip slots free.
77  *
78  * Returns true if this can be called again, continuing at @id.
79  */
fill_bp_slots(struct kunit * test,int * id,int cpu,struct task_struct * tsk,int skip)80 static bool fill_bp_slots(struct kunit *test, int *id, int cpu, struct task_struct *tsk, int skip)
81 {
82 	for (int i = 0; i < get_test_bp_slots() - skip; ++i)
83 		fill_one_bp_slot(test, id, cpu, tsk);
84 
85 	return *id + get_test_bp_slots() <= MAX_TEST_BREAKPOINTS;
86 }
87 
dummy_kthread(void * arg)88 static int dummy_kthread(void *arg)
89 {
90 	return 0;
91 }
92 
get_other_task(struct kunit * test)93 static struct task_struct *get_other_task(struct kunit *test)
94 {
95 	struct task_struct *tsk;
96 
97 	if (__other_task)
98 		return __other_task;
99 
100 	tsk = kthread_create(dummy_kthread, NULL, "hw_breakpoint_dummy_task");
101 	KUNIT_ASSERT_FALSE(test, IS_ERR(tsk));
102 	__other_task = tsk;
103 	return __other_task;
104 }
105 
get_test_cpu(int num)106 static int get_test_cpu(int num)
107 {
108 	int cpu;
109 
110 	WARN_ON(num < 0);
111 
112 	for_each_online_cpu(cpu) {
113 		if (num-- <= 0)
114 			break;
115 	}
116 
117 	return cpu;
118 }
119 
120 /* ===== Test cases ===== */
121 
test_one_cpu(struct kunit * test)122 static void test_one_cpu(struct kunit *test)
123 {
124 	int idx = 0;
125 
126 	fill_bp_slots(test, &idx, get_test_cpu(0), NULL, 0);
127 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
128 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
129 }
130 
test_many_cpus(struct kunit * test)131 static void test_many_cpus(struct kunit *test)
132 {
133 	int idx = 0;
134 	int cpu;
135 
136 	/* Test that CPUs are independent. */
137 	for_each_online_cpu(cpu) {
138 		bool do_continue = fill_bp_slots(test, &idx, cpu, NULL, 0);
139 
140 		TEST_EXPECT_NOSPC(register_test_bp(cpu, NULL, idx));
141 		if (!do_continue)
142 			break;
143 	}
144 }
145 
test_one_task_on_all_cpus(struct kunit * test)146 static void test_one_task_on_all_cpus(struct kunit *test)
147 {
148 	int idx = 0;
149 
150 	fill_bp_slots(test, &idx, -1, current, 0);
151 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
152 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
153 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
154 	/* Remove one and adding back CPU-target should work. */
155 	unregister_test_bp(&test_bps[0]);
156 	fill_one_bp_slot(test, &idx, get_test_cpu(0), NULL);
157 }
158 
test_two_tasks_on_all_cpus(struct kunit * test)159 static void test_two_tasks_on_all_cpus(struct kunit *test)
160 {
161 	int idx = 0;
162 
163 	/* Test that tasks are independent. */
164 	fill_bp_slots(test, &idx, -1, current, 0);
165 	fill_bp_slots(test, &idx, -1, get_other_task(test), 0);
166 
167 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
168 	TEST_EXPECT_NOSPC(register_test_bp(-1, get_other_task(test), idx));
169 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
170 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), get_other_task(test), idx));
171 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
172 	/* Remove one from first task and adding back CPU-target should not work. */
173 	unregister_test_bp(&test_bps[0]);
174 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
175 }
176 
test_one_task_on_one_cpu(struct kunit * test)177 static void test_one_task_on_one_cpu(struct kunit *test)
178 {
179 	int idx = 0;
180 
181 	fill_bp_slots(test, &idx, get_test_cpu(0), current, 0);
182 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
183 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
184 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
185 	/*
186 	 * Remove one and adding back CPU-target should work; this case is
187 	 * special vs. above because the task's constraints are CPU-dependent.
188 	 */
189 	unregister_test_bp(&test_bps[0]);
190 	fill_one_bp_slot(test, &idx, get_test_cpu(0), NULL);
191 }
192 
test_one_task_mixed(struct kunit * test)193 static void test_one_task_mixed(struct kunit *test)
194 {
195 	int idx = 0;
196 
197 	TEST_REQUIRES_BP_SLOTS(test, 3);
198 
199 	fill_one_bp_slot(test, &idx, get_test_cpu(0), current);
200 	fill_bp_slots(test, &idx, -1, current, 1);
201 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
202 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
203 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
204 
205 	/* Transition from CPU-dependent pinned count to CPU-independent. */
206 	unregister_test_bp(&test_bps[0]);
207 	unregister_test_bp(&test_bps[1]);
208 	fill_one_bp_slot(test, &idx, get_test_cpu(0), NULL);
209 	fill_one_bp_slot(test, &idx, get_test_cpu(0), NULL);
210 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
211 }
212 
test_two_tasks_on_one_cpu(struct kunit * test)213 static void test_two_tasks_on_one_cpu(struct kunit *test)
214 {
215 	int idx = 0;
216 
217 	fill_bp_slots(test, &idx, get_test_cpu(0), current, 0);
218 	fill_bp_slots(test, &idx, get_test_cpu(0), get_other_task(test), 0);
219 
220 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
221 	TEST_EXPECT_NOSPC(register_test_bp(-1, get_other_task(test), idx));
222 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
223 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), get_other_task(test), idx));
224 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
225 	/* Can still create breakpoints on some other CPU. */
226 	fill_bp_slots(test, &idx, get_test_cpu(1), NULL, 0);
227 }
228 
test_two_tasks_on_one_all_cpus(struct kunit * test)229 static void test_two_tasks_on_one_all_cpus(struct kunit *test)
230 {
231 	int idx = 0;
232 
233 	fill_bp_slots(test, &idx, get_test_cpu(0), current, 0);
234 	fill_bp_slots(test, &idx, -1, get_other_task(test), 0);
235 
236 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
237 	TEST_EXPECT_NOSPC(register_test_bp(-1, get_other_task(test), idx));
238 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
239 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), get_other_task(test), idx));
240 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
241 	/* Cannot create breakpoints on some other CPU either. */
242 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(1), NULL, idx));
243 }
244 
test_task_on_all_and_one_cpu(struct kunit * test)245 static void test_task_on_all_and_one_cpu(struct kunit *test)
246 {
247 	int tsk_on_cpu_idx, cpu_idx;
248 	int idx = 0;
249 
250 	TEST_REQUIRES_BP_SLOTS(test, 3);
251 
252 	fill_bp_slots(test, &idx, -1, current, 2);
253 	/* Transitioning from only all CPU breakpoints to mixed. */
254 	tsk_on_cpu_idx = idx;
255 	fill_one_bp_slot(test, &idx, get_test_cpu(0), current);
256 	fill_one_bp_slot(test, &idx, -1, current);
257 
258 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
259 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
260 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
261 
262 	/* We should still be able to use up another CPU's slots. */
263 	cpu_idx = idx;
264 	fill_one_bp_slot(test, &idx, get_test_cpu(1), NULL);
265 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(1), NULL, idx));
266 
267 	/* Transitioning back to task target on all CPUs. */
268 	unregister_test_bp(&test_bps[tsk_on_cpu_idx]);
269 	/* Still have a CPU target breakpoint in get_test_cpu(1). */
270 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
271 	/* Remove it and try again. */
272 	unregister_test_bp(&test_bps[cpu_idx]);
273 	fill_one_bp_slot(test, &idx, -1, current);
274 
275 	TEST_EXPECT_NOSPC(register_test_bp(-1, current, idx));
276 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), current, idx));
277 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(0), NULL, idx));
278 	TEST_EXPECT_NOSPC(register_test_bp(get_test_cpu(1), NULL, idx));
279 }
280 
281 static struct kunit_case hw_breakpoint_test_cases[] = {
282 	KUNIT_CASE(test_one_cpu),
283 	KUNIT_CASE(test_many_cpus),
284 	KUNIT_CASE(test_one_task_on_all_cpus),
285 	KUNIT_CASE(test_two_tasks_on_all_cpus),
286 	KUNIT_CASE(test_one_task_on_one_cpu),
287 	KUNIT_CASE(test_one_task_mixed),
288 	KUNIT_CASE(test_two_tasks_on_one_cpu),
289 	KUNIT_CASE(test_two_tasks_on_one_all_cpus),
290 	KUNIT_CASE(test_task_on_all_and_one_cpu),
291 	{},
292 };
293 
test_init(struct kunit * test)294 static int test_init(struct kunit *test)
295 {
296 	/* Most test cases want 2 distinct CPUs. */
297 	if (num_online_cpus() < 2)
298 		kunit_skip(test, "not enough cpus");
299 
300 	/* Want the system to not use breakpoints elsewhere. */
301 	if (hw_breakpoint_is_used())
302 		kunit_skip(test, "hw breakpoint already in use");
303 
304 	return 0;
305 }
306 
test_exit(struct kunit * test)307 static void test_exit(struct kunit *test)
308 {
309 	for (int i = 0; i < MAX_TEST_BREAKPOINTS; ++i) {
310 		if (test_bps[i])
311 			unregister_test_bp(&test_bps[i]);
312 	}
313 
314 	if (__other_task) {
315 		kthread_stop(__other_task);
316 		__other_task = NULL;
317 	}
318 
319 	/* Verify that internal state agrees that no breakpoints are in use. */
320 	KUNIT_EXPECT_FALSE(test, hw_breakpoint_is_used());
321 }
322 
323 static struct kunit_suite hw_breakpoint_test_suite = {
324 	.name = "hw_breakpoint",
325 	.test_cases = hw_breakpoint_test_cases,
326 	.init = test_init,
327 	.exit = test_exit,
328 };
329 
330 kunit_test_suites(&hw_breakpoint_test_suite);
331 
332 MODULE_AUTHOR("Marco Elver <elver@google.com>");
333