1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * Copyright (C) 2011 Red Hat, Inc., Frederic Weisbecker <fweisbec@redhat.com>
  4 *
  5 * Selftests for breakpoints (and more generally the do_debug() path) in x86.
  6 */
  7
  8
  9#include <sys/ptrace.h>
 10#include <unistd.h>
 11#include <stddef.h>
 12#include <sys/user.h>
 13#include <stdio.h>
 14#include <stdlib.h>
 15#include <signal.h>
 16#include <sys/types.h>
 17#include <sys/wait.h>
 18#include <errno.h>
 19#include <string.h>
 20
 21#include "../kselftest.h"
 22
 23#define COUNT_ISN_BPS	4
 24#define COUNT_WPS	4
 25
 26/* Breakpoint access modes */
 27enum {
 28	BP_X = 1,
 29	BP_RW = 2,
 30	BP_W = 4,
 31};
 32
 33static pid_t child_pid;
 34
 35/*
 36 * Ensures the child and parent are always "talking" about
 37 * the same test sequence. (ie: that we haven't forgotten
 38 * to call check_trapped() somewhere).
 39 */
 40static int nr_tests;
 41
 42static void set_breakpoint_addr(void *addr, int n)
 43{
 44	int ret;
 45
 46	ret = ptrace(PTRACE_POKEUSER, child_pid,
 47		     offsetof(struct user, u_debugreg[n]), addr);
 48	if (ret)
 49		ksft_exit_fail_msg("Can't set breakpoint addr: %s\n",
 50			strerror(errno));
 51}
 52
 53static void toggle_breakpoint(int n, int type, int len,
 54			      int local, int global, int set)
 55{
 56	int ret;
 57
 58	int xtype, xlen;
 59	unsigned long vdr7, dr7;
 60
 61	switch (type) {
 62	case BP_X:
 63		xtype = 0;
 64		break;
 65	case BP_W:
 66		xtype = 1;
 67		break;
 68	case BP_RW:
 69		xtype = 3;
 70		break;
 71	}
 72
 73	switch (len) {
 74	case 1:
 75		xlen = 0;
 76		break;
 77	case 2:
 78		xlen = 4;
 79		break;
 80	case 4:
 81		xlen = 0xc;
 82		break;
 83	case 8:
 84		xlen = 8;
 85		break;
 86	}
 87
 88	dr7 = ptrace(PTRACE_PEEKUSER, child_pid,
 89		     offsetof(struct user, u_debugreg[7]), 0);
 90
 91	vdr7 = (xlen | xtype) << 16;
 92	vdr7 <<= 4 * n;
 93
 94	if (local) {
 95		vdr7 |= 1 << (2 * n);
 96		vdr7 |= 1 << 8;
 97	}
 98	if (global) {
 99		vdr7 |= 2 << (2 * n);
100		vdr7 |= 1 << 9;
101	}
102
103	if (set)
104		dr7 |= vdr7;
105	else
106		dr7 &= ~vdr7;
107
108	ret = ptrace(PTRACE_POKEUSER, child_pid,
109		     offsetof(struct user, u_debugreg[7]), dr7);
110	if (ret) {
111		ksft_print_msg("Can't set dr7: %s\n", strerror(errno));
112		exit(-1);
113	}
114}
115
116/* Dummy variables to test read/write accesses */
117static unsigned long long dummy_var[4];
118
119/* Dummy functions to test execution accesses */
120static void dummy_func(void) { }
121static void dummy_func1(void) { }
122static void dummy_func2(void) { }
123static void dummy_func3(void) { }
124
125static void (*dummy_funcs[])(void) = {
126	dummy_func,
127	dummy_func1,
128	dummy_func2,
129	dummy_func3,
130};
131
132static int trapped;
133
134static void check_trapped(void)
135{
136	/*
137	 * If we haven't trapped, wake up the parent
138	 * so that it notices the failure.
139	 */
140	if (!trapped)
141		kill(getpid(), SIGUSR1);
142	trapped = 0;
143
144	nr_tests++;
145}
146
147static void write_var(int len)
148{
149	char *pcval; short *psval; int *pival; long long *plval;
150	int i;
151
152	for (i = 0; i < 4; i++) {
153		switch (len) {
154		case 1:
155			pcval = (char *)&dummy_var[i];
156			*pcval = 0xff;
157			break;
158		case 2:
159			psval = (short *)&dummy_var[i];
160			*psval = 0xffff;
161			break;
162		case 4:
163			pival = (int *)&dummy_var[i];
164			*pival = 0xffffffff;
165			break;
166		case 8:
167			plval = (long long *)&dummy_var[i];
168			*plval = 0xffffffffffffffffLL;
169			break;
170		}
171		check_trapped();
172	}
173}
174
175static void read_var(int len)
176{
177	char cval; short sval; int ival; long long lval;
178	int i;
179
180	for (i = 0; i < 4; i++) {
181		switch (len) {
182		case 1:
183			cval = *(char *)&dummy_var[i];
184			break;
185		case 2:
186			sval = *(short *)&dummy_var[i];
187			break;
188		case 4:
189			ival = *(int *)&dummy_var[i];
190			break;
191		case 8:
192			lval = *(long long *)&dummy_var[i];
193			break;
194		}
195		check_trapped();
196	}
197}
198
199/*
200 * Do the r/w/x accesses to trigger the breakpoints. And run
201 * the usual traps.
202 */
203static void trigger_tests(void)
204{
205	int len, local, global, i;
206	char val;
207	int ret;
208
209	ret = ptrace(PTRACE_TRACEME, 0, NULL, 0);
210	if (ret) {
211		ksft_print_msg("Can't be traced? %s\n", strerror(errno));
212		return;
213	}
214
215	/* Wake up father so that it sets up the first test */
216	kill(getpid(), SIGUSR1);
217
218	/* Test instruction breakpoints */
219	for (local = 0; local < 2; local++) {
220		for (global = 0; global < 2; global++) {
221			if (!local && !global)
222				continue;
223
224			for (i = 0; i < COUNT_ISN_BPS; i++) {
225				dummy_funcs[i]();
226				check_trapped();
227			}
228		}
229	}
230
231	/* Test write watchpoints */
232	for (len = 1; len <= sizeof(long); len <<= 1) {
233		for (local = 0; local < 2; local++) {
234			for (global = 0; global < 2; global++) {
235				if (!local && !global)
236					continue;
237				write_var(len);
238			}
239		}
240	}
241
242	/* Test read/write watchpoints (on read accesses) */
243	for (len = 1; len <= sizeof(long); len <<= 1) {
244		for (local = 0; local < 2; local++) {
245			for (global = 0; global < 2; global++) {
246				if (!local && !global)
247					continue;
248				read_var(len);
249			}
250		}
251	}
252
253	/* Icebp trap */
254	asm(".byte 0xf1\n");
255	check_trapped();
256
257	/* Int 3 trap */
258	asm("int $3\n");
259	check_trapped();
260
261	kill(getpid(), SIGUSR1);
262}
263
264static void check_success(const char *msg)
265{
266	int child_nr_tests;
267	int status;
268	int ret;
269
270	/* Wait for the child to SIGTRAP */
271	wait(&status);
272
273	ret = 0;
274
275	if (WSTOPSIG(status) == SIGTRAP) {
276		child_nr_tests = ptrace(PTRACE_PEEKDATA, child_pid,
277					&nr_tests, 0);
278		if (child_nr_tests == nr_tests)
279			ret = 1;
280		if (ptrace(PTRACE_POKEDATA, child_pid, &trapped, 1))
281			ksft_exit_fail_msg("Can't poke: %s\n", strerror(errno));
282	}
283
284	nr_tests++;
285
286	if (ret)
287		ksft_test_result_pass(msg);
288	else
289		ksft_test_result_fail(msg);
290}
291
292static void launch_instruction_breakpoints(char *buf, int local, int global)
293{
294	int i;
295
296	for (i = 0; i < COUNT_ISN_BPS; i++) {
297		set_breakpoint_addr(dummy_funcs[i], i);
298		toggle_breakpoint(i, BP_X, 1, local, global, 1);
299		ptrace(PTRACE_CONT, child_pid, NULL, 0);
300		sprintf(buf, "Test breakpoint %d with local: %d global: %d\n",
301			i, local, global);
302		check_success(buf);
303		toggle_breakpoint(i, BP_X, 1, local, global, 0);
304	}
305}
306
307static void launch_watchpoints(char *buf, int mode, int len,
308			       int local, int global)
309{
310	const char *mode_str;
311	int i;
312
313	if (mode == BP_W)
314		mode_str = "write";
315	else
316		mode_str = "read";
317
318	for (i = 0; i < COUNT_WPS; i++) {
319		set_breakpoint_addr(&dummy_var[i], i);
320		toggle_breakpoint(i, mode, len, local, global, 1);
321		ptrace(PTRACE_CONT, child_pid, NULL, 0);
322		sprintf(buf,
323			"Test %s watchpoint %d with len: %d local: %d global: %d\n",
324			mode_str, i, len, local, global);
325		check_success(buf);
326		toggle_breakpoint(i, mode, len, local, global, 0);
327	}
328}
329
330/* Set the breakpoints and check the child successfully trigger them */
331static void launch_tests(void)
332{
333	char buf[1024];
334	unsigned int tests = 0;
335	int len, local, global, i;
336
337	tests += 3 * COUNT_ISN_BPS;
338	tests += sizeof(long) / 2 * 3 * COUNT_WPS;
339	tests += sizeof(long) / 2 * 3 * COUNT_WPS;
340	tests += 2;
341	ksft_set_plan(tests);
342
343	/* Instruction breakpoints */
344	for (local = 0; local < 2; local++) {
345		for (global = 0; global < 2; global++) {
346			if (!local && !global)
347				continue;
348			launch_instruction_breakpoints(buf, local, global);
349		}
350	}
351
352	/* Write watchpoint */
353	for (len = 1; len <= sizeof(long); len <<= 1) {
354		for (local = 0; local < 2; local++) {
355			for (global = 0; global < 2; global++) {
356				if (!local && !global)
357					continue;
358				launch_watchpoints(buf, BP_W, len,
359						   local, global);
360			}
361		}
362	}
363
364	/* Read-Write watchpoint */
365	for (len = 1; len <= sizeof(long); len <<= 1) {
366		for (local = 0; local < 2; local++) {
367			for (global = 0; global < 2; global++) {
368				if (!local && !global)
369					continue;
370				launch_watchpoints(buf, BP_RW, len,
371						   local, global);
372			}
373		}
374	}
375
376	/* Icebp traps */
377	ptrace(PTRACE_CONT, child_pid, NULL, 0);
378	check_success("Test icebp\n");
379
380	/* Int 3 traps */
381	ptrace(PTRACE_CONT, child_pid, NULL, 0);
382	check_success("Test int 3 trap\n");
383
384	ptrace(PTRACE_CONT, child_pid, NULL, 0);
385}
386
387int main(int argc, char **argv)
388{
389	pid_t pid;
390	int ret;
391
392	ksft_print_header();
393
394	pid = fork();
395	if (!pid) {
396		trigger_tests();
397		exit(0);
398	}
399
400	child_pid = pid;
401
402	wait(NULL);
403
404	launch_tests();
405
406	wait(NULL);
407
408	ksft_exit_pass();
409}