1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * perf events self profiling example test case for hw breakpoints.
4  *
5  * This tests perf PERF_TYPE_BREAKPOINT parameters
6  * 1) tests all variants of the break on read/write flags
7  * 2) tests exclude_user == 0 and 1
8  * 3) test array matches (if DAWR is supported))
9  * 4) test different numbers of breakpoints matches
10  *
11  * Configure this breakpoint, then read and write the data a number of
12  * times. Then check the output count from perf is as expected.
13  *
14  * Based on:
15  *   http://ozlabs.org/~anton/junkcode/perf_events_example1.c
16  *
17  * Copyright (C) 2018 Michael Neuling, IBM Corporation.
18  */
19 
20 #include <unistd.h>
21 #include <assert.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <signal.h>
25 #include <string.h>
26 #include <sys/ioctl.h>
27 #include <sys/wait.h>
28 #include <sys/ptrace.h>
29 #include <sys/sysinfo.h>
30 #include <asm/ptrace.h>
31 #include <elf.h>
32 #include <pthread.h>
33 #include <sys/syscall.h>
34 #include <linux/perf_event.h>
35 #include <linux/hw_breakpoint.h>
36 #include "utils.h"
37 
38 #ifndef PPC_DEBUG_FEATURE_DATA_BP_ARCH_31
39 #define PPC_DEBUG_FEATURE_DATA_BP_ARCH_31	0x20
40 #endif
41 
42 #define MAX_LOOPS 10000
43 
44 #define DAWR_LENGTH_MAX ((0x3f + 1) * 8)
45 
46 int nprocs;
47 
48 static volatile int a = 10;
49 static volatile int b = 10;
50 static volatile char c[512 + 8] __attribute__((aligned(512)));
51 
52 static void perf_event_attr_set(struct perf_event_attr *attr,
53 				__u32 type, __u64 addr, __u64 len,
54 				bool exclude_user)
55 {
56 	memset(attr, 0, sizeof(struct perf_event_attr));
57 	attr->type           = PERF_TYPE_BREAKPOINT;
58 	attr->size           = sizeof(struct perf_event_attr);
59 	attr->bp_type        = type;
60 	attr->bp_addr        = addr;
61 	attr->bp_len         = len;
62 	attr->exclude_kernel = 1;
63 	attr->exclude_hv     = 1;
64 	attr->exclude_guest  = 1;
65 	attr->exclude_user   = exclude_user;
66 	attr->disabled       = 1;
67 }
68 
69 static int
70 perf_process_event_open_exclude_user(__u32 type, __u64 addr, __u64 len, bool exclude_user)
71 {
72 	struct perf_event_attr attr;
73 
74 	perf_event_attr_set(&attr, type, addr, len, exclude_user);
75 	return syscall(__NR_perf_event_open, &attr, getpid(), -1, -1, 0);
76 }
77 
78 static int perf_process_event_open(__u32 type, __u64 addr, __u64 len)
79 {
80 	struct perf_event_attr attr;
81 
82 	perf_event_attr_set(&attr, type, addr, len, 0);
83 	return syscall(__NR_perf_event_open, &attr, getpid(), -1, -1, 0);
84 }
85 
86 static int perf_cpu_event_open(long cpu, __u32 type, __u64 addr, __u64 len)
87 {
88 	struct perf_event_attr attr;
89 
90 	perf_event_attr_set(&attr, type, addr, len, 0);
91 	return syscall(__NR_perf_event_open, &attr, -1, cpu, -1, 0);
92 }
93 
94 static void close_fds(int *fd, int n)
95 {
96 	int i;
97 
98 	for (i = 0; i < n; i++)
99 		close(fd[i]);
100 }
101 
102 static unsigned long read_fds(int *fd, int n)
103 {
104 	int i;
105 	unsigned long c = 0;
106 	unsigned long count = 0;
107 	size_t res;
108 
109 	for (i = 0; i < n; i++) {
110 		res = read(fd[i], &c, sizeof(c));
111 		assert(res == sizeof(unsigned long long));
112 		count += c;
113 	}
114 	return count;
115 }
116 
117 static void reset_fds(int *fd, int n)
118 {
119 	int i;
120 
121 	for (i = 0; i < n; i++)
122 		ioctl(fd[i], PERF_EVENT_IOC_RESET);
123 }
124 
125 static void enable_fds(int *fd, int n)
126 {
127 	int i;
128 
129 	for (i = 0; i < n; i++)
130 		ioctl(fd[i], PERF_EVENT_IOC_ENABLE);
131 }
132 
133 static void disable_fds(int *fd, int n)
134 {
135 	int i;
136 
137 	for (i = 0; i < n; i++)
138 		ioctl(fd[i], PERF_EVENT_IOC_DISABLE);
139 }
140 
141 static int perf_systemwide_event_open(int *fd, __u32 type, __u64 addr, __u64 len)
142 {
143 	int i = 0;
144 
145 	/* Assume online processors are 0 to nprocs for simplisity */
146 	for (i = 0; i < nprocs; i++) {
147 		fd[i] = perf_cpu_event_open(i, type, addr, len);
148 		if (fd[i] < 0) {
149 			close_fds(fd, i);
150 			return fd[i];
151 		}
152 	}
153 	return 0;
154 }
155 
156 static inline bool breakpoint_test(int len)
157 {
158 	int fd;
159 
160 	/* bp_addr can point anywhere but needs to be aligned */
161 	fd = perf_process_event_open(HW_BREAKPOINT_R, (__u64)(&fd) & 0xfffffffffffff800, len);
162 	if (fd < 0)
163 		return false;
164 	close(fd);
165 	return true;
166 }
167 
168 static inline bool perf_breakpoint_supported(void)
169 {
170 	return breakpoint_test(4);
171 }
172 
173 static inline bool dawr_supported(void)
174 {
175 	return breakpoint_test(DAWR_LENGTH_MAX);
176 }
177 
178 static int runtestsingle(int readwriteflag, int exclude_user, int arraytest)
179 {
180 	int i,j;
181 	size_t res;
182 	unsigned long long breaks, needed;
183 	int readint;
184 	int readintarraybig[2*DAWR_LENGTH_MAX/sizeof(int)];
185 	int *readintalign;
186 	volatile int *ptr;
187 	int break_fd;
188 	int loop_num = MAX_LOOPS - (rand() % 100); /* provide some variability */
189 	volatile int *k;
190 	__u64 len;
191 
192 	/* align to 0x400 boundary as required by DAWR */
193 	readintalign = (int *)(((unsigned long)readintarraybig + 0x7ff) &
194 			       0xfffffffffffff800);
195 
196 	ptr = &readint;
197 	if (arraytest)
198 		ptr = &readintalign[0];
199 
200 	len = arraytest ? DAWR_LENGTH_MAX : sizeof(int);
201 	break_fd = perf_process_event_open_exclude_user(readwriteflag, (__u64)ptr,
202 							len, exclude_user);
203 	if (break_fd < 0) {
204 		perror("perf_process_event_open_exclude_user");
205 		exit(1);
206 	}
207 
208 	/* start counters */
209 	ioctl(break_fd, PERF_EVENT_IOC_ENABLE);
210 
211 	/* Test a bunch of reads and writes */
212 	k = &readint;
213 	for (i = 0; i < loop_num; i++) {
214 		if (arraytest)
215 			k = &(readintalign[i % (DAWR_LENGTH_MAX/sizeof(int))]);
216 
217 		j = *k;
218 		*k = j;
219 	}
220 
221 	/* stop counters */
222 	ioctl(break_fd, PERF_EVENT_IOC_DISABLE);
223 
224 	/* read and check counters */
225 	res = read(break_fd, &breaks, sizeof(unsigned long long));
226 	assert(res == sizeof(unsigned long long));
227 	/* we read and write each loop, so subtract the ones we are counting */
228 	needed = 0;
229 	if (readwriteflag & HW_BREAKPOINT_R)
230 		needed += loop_num;
231 	if (readwriteflag & HW_BREAKPOINT_W)
232 		needed += loop_num;
233 	needed = needed * (1 - exclude_user);
234 	printf("TESTED: addr:0x%lx brks:% 8lld loops:% 8i rw:%i !user:%i array:%i\n",
235 	       (unsigned long int)ptr, breaks, loop_num, readwriteflag, exclude_user, arraytest);
236 	if (breaks != needed) {
237 		printf("FAILED: 0x%lx brks:%lld needed:%lli %i %i %i\n\n",
238 		       (unsigned long int)ptr, breaks, needed, loop_num, readwriteflag, exclude_user);
239 		return 1;
240 	}
241 	close(break_fd);
242 
243 	return 0;
244 }
245 
246 static int runtest_dar_outside(void)
247 {
248 	void *target;
249 	volatile __u16 temp16;
250 	volatile __u64 temp64;
251 	int break_fd;
252 	unsigned long long breaks;
253 	int fail = 0;
254 	size_t res;
255 
256 	target = malloc(8);
257 	if (!target) {
258 		perror("malloc failed");
259 		exit(EXIT_FAILURE);
260 	}
261 
262 	/* watch middle half of target array */
263 	break_fd = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)(target + 2), 4);
264 	if (break_fd < 0) {
265 		free(target);
266 		perror("perf_process_event_open");
267 		exit(EXIT_FAILURE);
268 	}
269 
270 	/* Shouldn't hit. */
271 	ioctl(break_fd, PERF_EVENT_IOC_RESET);
272 	ioctl(break_fd, PERF_EVENT_IOC_ENABLE);
273 	temp16 = *((__u16 *)target);
274 	*((__u16 *)target) = temp16;
275 	ioctl(break_fd, PERF_EVENT_IOC_DISABLE);
276 	res = read(break_fd, &breaks, sizeof(unsigned long long));
277 	assert(res == sizeof(unsigned long long));
278 	if (breaks == 0) {
279 		printf("TESTED: No overlap\n");
280 	} else {
281 		printf("FAILED: No overlap: %lld != 0\n", breaks);
282 		fail = 1;
283 	}
284 
285 	/* Hit */
286 	ioctl(break_fd, PERF_EVENT_IOC_RESET);
287 	ioctl(break_fd, PERF_EVENT_IOC_ENABLE);
288 	temp16 = *((__u16 *)(target + 1));
289 	*((__u16 *)(target + 1)) = temp16;
290 	ioctl(break_fd, PERF_EVENT_IOC_DISABLE);
291 	res = read(break_fd, &breaks, sizeof(unsigned long long));
292 	assert(res == sizeof(unsigned long long));
293 	if (breaks == 2) {
294 		printf("TESTED: Partial overlap\n");
295 	} else {
296 		printf("FAILED: Partial overlap: %lld != 2\n", breaks);
297 		fail = 1;
298 	}
299 
300 	/* Hit */
301 	ioctl(break_fd, PERF_EVENT_IOC_RESET);
302 	ioctl(break_fd, PERF_EVENT_IOC_ENABLE);
303 	temp16 = *((__u16 *)(target + 5));
304 	*((__u16 *)(target + 5)) = temp16;
305 	ioctl(break_fd, PERF_EVENT_IOC_DISABLE);
306 	res = read(break_fd, &breaks, sizeof(unsigned long long));
307 	assert(res == sizeof(unsigned long long));
308 	if (breaks == 2) {
309 		printf("TESTED: Partial overlap\n");
310 	} else {
311 		printf("FAILED: Partial overlap: %lld != 2\n", breaks);
312 		fail = 1;
313 	}
314 
315 	/* Shouldn't Hit */
316 	ioctl(break_fd, PERF_EVENT_IOC_RESET);
317 	ioctl(break_fd, PERF_EVENT_IOC_ENABLE);
318 	temp16 = *((__u16 *)(target + 6));
319 	*((__u16 *)(target + 6)) = temp16;
320 	ioctl(break_fd, PERF_EVENT_IOC_DISABLE);
321 	res = read(break_fd, &breaks, sizeof(unsigned long long));
322 	assert(res == sizeof(unsigned long long));
323 	if (breaks == 0) {
324 		printf("TESTED: No overlap\n");
325 	} else {
326 		printf("FAILED: No overlap: %lld != 0\n", breaks);
327 		fail = 1;
328 	}
329 
330 	/* Hit */
331 	ioctl(break_fd, PERF_EVENT_IOC_RESET);
332 	ioctl(break_fd, PERF_EVENT_IOC_ENABLE);
333 	temp64 = *((__u64 *)target);
334 	*((__u64 *)target) = temp64;
335 	ioctl(break_fd, PERF_EVENT_IOC_DISABLE);
336 	res = read(break_fd, &breaks, sizeof(unsigned long long));
337 	assert(res == sizeof(unsigned long long));
338 	if (breaks == 2) {
339 		printf("TESTED: Full overlap\n");
340 	} else {
341 		printf("FAILED: Full overlap: %lld != 2\n", breaks);
342 		fail = 1;
343 	}
344 
345 	free(target);
346 	close(break_fd);
347 	return fail;
348 }
349 
350 static void multi_dawr_workload(void)
351 {
352 	a += 10;
353 	b += 10;
354 	c[512 + 1] += 'a';
355 }
356 
357 static int test_process_multi_diff_addr(void)
358 {
359 	unsigned long long breaks1 = 0, breaks2 = 0;
360 	int fd1, fd2;
361 	char *desc = "Process specific, Two events, diff addr";
362 	size_t res;
363 
364 	fd1 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));
365 	if (fd1 < 0) {
366 		perror("perf_process_event_open");
367 		exit(EXIT_FAILURE);
368 	}
369 
370 	fd2 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&b, (__u64)sizeof(b));
371 	if (fd2 < 0) {
372 		close(fd1);
373 		perror("perf_process_event_open");
374 		exit(EXIT_FAILURE);
375 	}
376 
377 	ioctl(fd1, PERF_EVENT_IOC_RESET);
378 	ioctl(fd2, PERF_EVENT_IOC_RESET);
379 	ioctl(fd1, PERF_EVENT_IOC_ENABLE);
380 	ioctl(fd2, PERF_EVENT_IOC_ENABLE);
381 	multi_dawr_workload();
382 	ioctl(fd1, PERF_EVENT_IOC_DISABLE);
383 	ioctl(fd2, PERF_EVENT_IOC_DISABLE);
384 
385 	res = read(fd1, &breaks1, sizeof(breaks1));
386 	assert(res == sizeof(unsigned long long));
387 	res = read(fd2, &breaks2, sizeof(breaks2));
388 	assert(res == sizeof(unsigned long long));
389 
390 	close(fd1);
391 	close(fd2);
392 
393 	if (breaks1 != 2 || breaks2 != 2) {
394 		printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2);
395 		return 1;
396 	}
397 
398 	printf("TESTED: %s\n", desc);
399 	return 0;
400 }
401 
402 static int test_process_multi_same_addr(void)
403 {
404 	unsigned long long breaks1 = 0, breaks2 = 0;
405 	int fd1, fd2;
406 	char *desc = "Process specific, Two events, same addr";
407 	size_t res;
408 
409 	fd1 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));
410 	if (fd1 < 0) {
411 		perror("perf_process_event_open");
412 		exit(EXIT_FAILURE);
413 	}
414 
415 	fd2 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));
416 	if (fd2 < 0) {
417 		close(fd1);
418 		perror("perf_process_event_open");
419 		exit(EXIT_FAILURE);
420 	}
421 
422 	ioctl(fd1, PERF_EVENT_IOC_RESET);
423 	ioctl(fd2, PERF_EVENT_IOC_RESET);
424 	ioctl(fd1, PERF_EVENT_IOC_ENABLE);
425 	ioctl(fd2, PERF_EVENT_IOC_ENABLE);
426 	multi_dawr_workload();
427 	ioctl(fd1, PERF_EVENT_IOC_DISABLE);
428 	ioctl(fd2, PERF_EVENT_IOC_DISABLE);
429 
430 	res = read(fd1, &breaks1, sizeof(breaks1));
431 	assert(res == sizeof(unsigned long long));
432 	res = read(fd2, &breaks2, sizeof(breaks2));
433 	assert(res == sizeof(unsigned long long));
434 
435 	close(fd1);
436 	close(fd2);
437 
438 	if (breaks1 != 2 || breaks2 != 2) {
439 		printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2);
440 		return 1;
441 	}
442 
443 	printf("TESTED: %s\n", desc);
444 	return 0;
445 }
446 
447 static int test_process_multi_diff_addr_ro_wo(void)
448 {
449 	unsigned long long breaks1 = 0, breaks2 = 0;
450 	int fd1, fd2;
451 	char *desc = "Process specific, Two events, diff addr, one is RO, other is WO";
452 	size_t res;
453 
454 	fd1 = perf_process_event_open(HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a));
455 	if (fd1 < 0) {
456 		perror("perf_process_event_open");
457 		exit(EXIT_FAILURE);
458 	}
459 
460 	fd2 = perf_process_event_open(HW_BREAKPOINT_R, (__u64)&b, (__u64)sizeof(b));
461 	if (fd2 < 0) {
462 		close(fd1);
463 		perror("perf_process_event_open");
464 		exit(EXIT_FAILURE);
465 	}
466 
467 	ioctl(fd1, PERF_EVENT_IOC_RESET);
468 	ioctl(fd2, PERF_EVENT_IOC_RESET);
469 	ioctl(fd1, PERF_EVENT_IOC_ENABLE);
470 	ioctl(fd2, PERF_EVENT_IOC_ENABLE);
471 	multi_dawr_workload();
472 	ioctl(fd1, PERF_EVENT_IOC_DISABLE);
473 	ioctl(fd2, PERF_EVENT_IOC_DISABLE);
474 
475 	res = read(fd1, &breaks1, sizeof(breaks1));
476 	assert(res == sizeof(unsigned long long));
477 	res = read(fd2, &breaks2, sizeof(breaks2));
478 	assert(res == sizeof(unsigned long long));
479 
480 	close(fd1);
481 	close(fd2);
482 
483 	if (breaks1 != 1 || breaks2 != 1) {
484 		printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2);
485 		return 1;
486 	}
487 
488 	printf("TESTED: %s\n", desc);
489 	return 0;
490 }
491 
492 static int test_process_multi_same_addr_ro_wo(void)
493 {
494 	unsigned long long breaks1 = 0, breaks2 = 0;
495 	int fd1, fd2;
496 	char *desc = "Process specific, Two events, same addr, one is RO, other is WO";
497 	size_t res;
498 
499 	fd1 = perf_process_event_open(HW_BREAKPOINT_R, (__u64)&a, (__u64)sizeof(a));
500 	if (fd1 < 0) {
501 		perror("perf_process_event_open");
502 		exit(EXIT_FAILURE);
503 	}
504 
505 	fd2 = perf_process_event_open(HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a));
506 	if (fd2 < 0) {
507 		close(fd1);
508 		perror("perf_process_event_open");
509 		exit(EXIT_FAILURE);
510 	}
511 
512 	ioctl(fd1, PERF_EVENT_IOC_RESET);
513 	ioctl(fd2, PERF_EVENT_IOC_RESET);
514 	ioctl(fd1, PERF_EVENT_IOC_ENABLE);
515 	ioctl(fd2, PERF_EVENT_IOC_ENABLE);
516 	multi_dawr_workload();
517 	ioctl(fd1, PERF_EVENT_IOC_DISABLE);
518 	ioctl(fd2, PERF_EVENT_IOC_DISABLE);
519 
520 	res = read(fd1, &breaks1, sizeof(breaks1));
521 	assert(res == sizeof(unsigned long long));
522 	res = read(fd2, &breaks2, sizeof(breaks2));
523 	assert(res == sizeof(unsigned long long));
524 
525 	close(fd1);
526 	close(fd2);
527 
528 	if (breaks1 != 1 || breaks2 != 1) {
529 		printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2);
530 		return 1;
531 	}
532 
533 	printf("TESTED: %s\n", desc);
534 	return 0;
535 }
536 
537 static int test_syswide_multi_diff_addr(void)
538 {
539 	unsigned long long breaks1 = 0, breaks2 = 0;
540 	int *fd1 = malloc(nprocs * sizeof(int));
541 	int *fd2 = malloc(nprocs * sizeof(int));
542 	char *desc = "Systemwide, Two events, diff addr";
543 	int ret;
544 
545 	ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));
546 	if (ret) {
547 		perror("perf_systemwide_event_open");
548 		exit(EXIT_FAILURE);
549 	}
550 
551 	ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_RW, (__u64)&b, (__u64)sizeof(b));
552 	if (ret) {
553 		close_fds(fd1, nprocs);
554 		perror("perf_systemwide_event_open");
555 		exit(EXIT_FAILURE);
556 	}
557 
558 	reset_fds(fd1, nprocs);
559 	reset_fds(fd2, nprocs);
560 	enable_fds(fd1, nprocs);
561 	enable_fds(fd2, nprocs);
562 	multi_dawr_workload();
563 	disable_fds(fd1, nprocs);
564 	disable_fds(fd2, nprocs);
565 
566 	breaks1 = read_fds(fd1, nprocs);
567 	breaks2 = read_fds(fd2, nprocs);
568 
569 	close_fds(fd1, nprocs);
570 	close_fds(fd2, nprocs);
571 
572 	free(fd1);
573 	free(fd2);
574 
575 	if (breaks1 != 2 || breaks2 != 2) {
576 		printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2);
577 		return 1;
578 	}
579 
580 	printf("TESTED: %s\n", desc);
581 	return 0;
582 }
583 
584 static int test_syswide_multi_same_addr(void)
585 {
586 	unsigned long long breaks1 = 0, breaks2 = 0;
587 	int *fd1 = malloc(nprocs * sizeof(int));
588 	int *fd2 = malloc(nprocs * sizeof(int));
589 	char *desc = "Systemwide, Two events, same addr";
590 	int ret;
591 
592 	ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));
593 	if (ret) {
594 		perror("perf_systemwide_event_open");
595 		exit(EXIT_FAILURE);
596 	}
597 
598 	ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a));
599 	if (ret) {
600 		close_fds(fd1, nprocs);
601 		perror("perf_systemwide_event_open");
602 		exit(EXIT_FAILURE);
603 	}
604 
605 	reset_fds(fd1, nprocs);
606 	reset_fds(fd2, nprocs);
607 	enable_fds(fd1, nprocs);
608 	enable_fds(fd2, nprocs);
609 	multi_dawr_workload();
610 	disable_fds(fd1, nprocs);
611 	disable_fds(fd2, nprocs);
612 
613 	breaks1 = read_fds(fd1, nprocs);
614 	breaks2 = read_fds(fd2, nprocs);
615 
616 	close_fds(fd1, nprocs);
617 	close_fds(fd2, nprocs);
618 
619 	free(fd1);
620 	free(fd2);
621 
622 	if (breaks1 != 2 || breaks2 != 2) {
623 		printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2);
624 		return 1;
625 	}
626 
627 	printf("TESTED: %s\n", desc);
628 	return 0;
629 }
630 
631 static int test_syswide_multi_diff_addr_ro_wo(void)
632 {
633 	unsigned long long breaks1 = 0, breaks2 = 0;
634 	int *fd1 = malloc(nprocs * sizeof(int));
635 	int *fd2 = malloc(nprocs * sizeof(int));
636 	char *desc = "Systemwide, Two events, diff addr, one is RO, other is WO";
637 	int ret;
638 
639 	ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a));
640 	if (ret) {
641 		perror("perf_systemwide_event_open");
642 		exit(EXIT_FAILURE);
643 	}
644 
645 	ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_R, (__u64)&b, (__u64)sizeof(b));
646 	if (ret) {
647 		close_fds(fd1, nprocs);
648 		perror("perf_systemwide_event_open");
649 		exit(EXIT_FAILURE);
650 	}
651 
652 	reset_fds(fd1, nprocs);
653 	reset_fds(fd2, nprocs);
654 	enable_fds(fd1, nprocs);
655 	enable_fds(fd2, nprocs);
656 	multi_dawr_workload();
657 	disable_fds(fd1, nprocs);
658 	disable_fds(fd2, nprocs);
659 
660 	breaks1 = read_fds(fd1, nprocs);
661 	breaks2 = read_fds(fd2, nprocs);
662 
663 	close_fds(fd1, nprocs);
664 	close_fds(fd2, nprocs);
665 
666 	free(fd1);
667 	free(fd2);
668 
669 	if (breaks1 != 1 || breaks2 != 1) {
670 		printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2);
671 		return 1;
672 	}
673 
674 	printf("TESTED: %s\n", desc);
675 	return 0;
676 }
677 
678 static int test_syswide_multi_same_addr_ro_wo(void)
679 {
680 	unsigned long long breaks1 = 0, breaks2 = 0;
681 	int *fd1 = malloc(nprocs * sizeof(int));
682 	int *fd2 = malloc(nprocs * sizeof(int));
683 	char *desc = "Systemwide, Two events, same addr, one is RO, other is WO";
684 	int ret;
685 
686 	ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a));
687 	if (ret) {
688 		perror("perf_systemwide_event_open");
689 		exit(EXIT_FAILURE);
690 	}
691 
692 	ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_R, (__u64)&a, (__u64)sizeof(a));
693 	if (ret) {
694 		close_fds(fd1, nprocs);
695 		perror("perf_systemwide_event_open");
696 		exit(EXIT_FAILURE);
697 	}
698 
699 	reset_fds(fd1, nprocs);
700 	reset_fds(fd2, nprocs);
701 	enable_fds(fd1, nprocs);
702 	enable_fds(fd2, nprocs);
703 	multi_dawr_workload();
704 	disable_fds(fd1, nprocs);
705 	disable_fds(fd2, nprocs);
706 
707 	breaks1 = read_fds(fd1, nprocs);
708 	breaks2 = read_fds(fd2, nprocs);
709 
710 	close_fds(fd1, nprocs);
711 	close_fds(fd2, nprocs);
712 
713 	free(fd1);
714 	free(fd2);
715 
716 	if (breaks1 != 1 || breaks2 != 1) {
717 		printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2);
718 		return 1;
719 	}
720 
721 	printf("TESTED: %s\n", desc);
722 	return 0;
723 }
724 
725 static int runtest_multi_dawr(void)
726 {
727 	int ret = 0;
728 
729 	ret |= test_process_multi_diff_addr();
730 	ret |= test_process_multi_same_addr();
731 	ret |= test_process_multi_diff_addr_ro_wo();
732 	ret |= test_process_multi_same_addr_ro_wo();
733 	ret |= test_syswide_multi_diff_addr();
734 	ret |= test_syswide_multi_same_addr();
735 	ret |= test_syswide_multi_diff_addr_ro_wo();
736 	ret |= test_syswide_multi_same_addr_ro_wo();
737 
738 	return ret;
739 }
740 
741 static int runtest_unaligned_512bytes(void)
742 {
743 	unsigned long long breaks = 0;
744 	int fd;
745 	char *desc = "Process specific, 512 bytes, unaligned";
746 	__u64 addr = (__u64)&c + 8;
747 	size_t res;
748 
749 	fd = perf_process_event_open(HW_BREAKPOINT_RW, addr, 512);
750 	if (fd < 0) {
751 		perror("perf_process_event_open");
752 		exit(EXIT_FAILURE);
753 	}
754 
755 	ioctl(fd, PERF_EVENT_IOC_RESET);
756 	ioctl(fd, PERF_EVENT_IOC_ENABLE);
757 	multi_dawr_workload();
758 	ioctl(fd, PERF_EVENT_IOC_DISABLE);
759 
760 	res = read(fd, &breaks, sizeof(breaks));
761 	assert(res == sizeof(unsigned long long));
762 
763 	close(fd);
764 
765 	if (breaks != 2) {
766 		printf("FAILED: %s: %lld != 2\n", desc, breaks);
767 		return 1;
768 	}
769 
770 	printf("TESTED: %s\n", desc);
771 	return 0;
772 }
773 
774 /* There is no perf api to find number of available watchpoints. Use ptrace. */
775 static int get_nr_wps(bool *arch_31)
776 {
777 	struct ppc_debug_info dbginfo;
778 	int child_pid;
779 
780 	child_pid = fork();
781 	if (!child_pid) {
782 		int ret = ptrace(PTRACE_TRACEME, 0, NULL, 0);
783 		if (ret) {
784 			perror("PTRACE_TRACEME failed\n");
785 			exit(EXIT_FAILURE);
786 		}
787 		kill(getpid(), SIGUSR1);
788 
789 		sleep(1);
790 		exit(EXIT_SUCCESS);
791 	}
792 
793 	wait(NULL);
794 	if (ptrace(PPC_PTRACE_GETHWDBGINFO, child_pid, NULL, &dbginfo)) {
795 		perror("Can't get breakpoint info");
796 		exit(EXIT_FAILURE);
797 	}
798 
799 	*arch_31 = !!(dbginfo.features & PPC_DEBUG_FEATURE_DATA_BP_ARCH_31);
800 	return dbginfo.num_data_bps;
801 }
802 
803 static int runtest(void)
804 {
805 	int rwflag;
806 	int exclude_user;
807 	int ret;
808 	bool dawr = dawr_supported();
809 	bool arch_31 = false;
810 	int nr_wps = get_nr_wps(&arch_31);
811 
812 	/*
813 	 * perf defines rwflag as two bits read and write and at least
814 	 * one must be set.  So range 1-3.
815 	 */
816 	for (rwflag = 1 ; rwflag < 4; rwflag++) {
817 		for (exclude_user = 0 ; exclude_user < 2; exclude_user++) {
818 			ret = runtestsingle(rwflag, exclude_user, 0);
819 			if (ret)
820 				return ret;
821 
822 			/* if we have the dawr, we can do an array test */
823 			if (!dawr)
824 				continue;
825 			ret = runtestsingle(rwflag, exclude_user, 1);
826 			if (ret)
827 				return ret;
828 		}
829 	}
830 
831 	ret = runtest_dar_outside();
832 	if (ret)
833 		return ret;
834 
835 	if (dawr && nr_wps > 1) {
836 		nprocs = get_nprocs();
837 		ret = runtest_multi_dawr();
838 		if (ret)
839 			return ret;
840 	}
841 
842 	if (dawr && arch_31)
843 		ret = runtest_unaligned_512bytes();
844 
845 	return ret;
846 }
847 
848 
849 static int perf_hwbreak(void)
850 {
851 	srand ( time(NULL) );
852 
853 	SKIP_IF(!perf_breakpoint_supported());
854 
855 	return runtest();
856 }
857 
858 int main(int argc, char *argv[], char **envp)
859 {
860 	return test_harness(perf_hwbreak, "perf_hwbreak");
861 }
862