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