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