| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * perf events self profiling example test case for hw breakpoints. | |
| * | |
| * This tests perf PERF_TYPE_BREAKPOINT parameters | |
| * 1) tests all variants of the break on read/write flags | |
| * 2) tests exclude_user == 0 and 1 | |
| * 3) test array matches (if DAWR is supported)) | |
| * 4) test different numbers of breakpoints matches | |
| * | |
| * Configure this breakpoint, then read and write the data a number of | |
| * times. Then check the output count from perf is as expected. | |
| * | |
| * Based on: | |
| * http://ozlabs.org/~anton/junkcode/perf_events_example1.c | |
| * | |
| * Copyright (C) 2018 Michael Neuling, IBM Corporation. | |
| */ | |
| #define _GNU_SOURCE | |
| #include <unistd.h> | |
| #include <assert.h> | |
| #include <sched.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <signal.h> | |
| #include <string.h> | |
| #include <sys/ioctl.h> | |
| #include <sys/wait.h> | |
| #include <sys/ptrace.h> | |
| #include <sys/resource.h> | |
| #include <sys/sysinfo.h> | |
| #include <asm/ptrace.h> | |
| #include <elf.h> | |
| #include <pthread.h> | |
| #include <sys/syscall.h> | |
| #include <linux/perf_event.h> | |
| #include <linux/hw_breakpoint.h> | |
| #include "utils.h" | |
| #ifndef PPC_DEBUG_FEATURE_DATA_BP_ARCH_31 | |
| #define PPC_DEBUG_FEATURE_DATA_BP_ARCH_31 0x20 | |
| #endif | |
| #define MAX_LOOPS 10000 | |
| #define DAWR_LENGTH_MAX ((0x3f + 1) * 8) | |
| int nprocs; | |
| static volatile int a = 10; | |
| static volatile int b = 10; | |
| static volatile char c[512 + 8] __attribute__((aligned(512))); | |
| static void perf_event_attr_set(struct perf_event_attr *attr, | |
| __u32 type, __u64 addr, __u64 len, | |
| bool exclude_user) | |
| { | |
| memset(attr, 0, sizeof(struct perf_event_attr)); | |
| attr->type = PERF_TYPE_BREAKPOINT; | |
| attr->size = sizeof(struct perf_event_attr); | |
| attr->bp_type = type; | |
| attr->bp_addr = addr; | |
| attr->bp_len = len; | |
| attr->exclude_kernel = 1; | |
| attr->exclude_hv = 1; | |
| attr->exclude_guest = 1; | |
| attr->exclude_user = exclude_user; | |
| attr->disabled = 1; | |
| } | |
| static int | |
| perf_process_event_open_exclude_user(__u32 type, __u64 addr, __u64 len, bool exclude_user) | |
| { | |
| struct perf_event_attr attr; | |
| perf_event_attr_set(&attr, type, addr, len, exclude_user); | |
| return syscall(__NR_perf_event_open, &attr, getpid(), -1, -1, 0); | |
| } | |
| static int perf_process_event_open(__u32 type, __u64 addr, __u64 len) | |
| { | |
| struct perf_event_attr attr; | |
| perf_event_attr_set(&attr, type, addr, len, 0); | |
| return syscall(__NR_perf_event_open, &attr, getpid(), -1, -1, 0); | |
| } | |
| static int perf_cpu_event_open(long cpu, __u32 type, __u64 addr, __u64 len) | |
| { | |
| struct perf_event_attr attr; | |
| perf_event_attr_set(&attr, type, addr, len, 0); | |
| return syscall(__NR_perf_event_open, &attr, -1, cpu, -1, 0); | |
| } | |
| static void close_fds(int *fd, int n) | |
| { | |
| int i; | |
| for (i = 0; i < n; i++) | |
| close(fd[i]); | |
| } | |
| static unsigned long read_fds(int *fd, int n) | |
| { | |
| int i; | |
| unsigned long c = 0; | |
| unsigned long count = 0; | |
| size_t res; | |
| for (i = 0; i < n; i++) { | |
| res = read(fd[i], &c, sizeof(c)); | |
| assert(res == sizeof(unsigned long long)); | |
| count += c; | |
| } | |
| return count; | |
| } | |
| static void reset_fds(int *fd, int n) | |
| { | |
| int i; | |
| for (i = 0; i < n; i++) | |
| ioctl(fd[i], PERF_EVENT_IOC_RESET); | |
| } | |
| static void enable_fds(int *fd, int n) | |
| { | |
| int i; | |
| for (i = 0; i < n; i++) | |
| ioctl(fd[i], PERF_EVENT_IOC_ENABLE); | |
| } | |
| static void disable_fds(int *fd, int n) | |
| { | |
| int i; | |
| for (i = 0; i < n; i++) | |
| ioctl(fd[i], PERF_EVENT_IOC_DISABLE); | |
| } | |
| static int perf_systemwide_event_open(int *fd, __u32 type, __u64 addr, __u64 len) | |
| { | |
| int i, ncpus, cpu, ret = 0; | |
| struct rlimit rlim; | |
| cpu_set_t *mask; | |
| size_t size; | |
| if (getrlimit(RLIMIT_NOFILE, &rlim)) { | |
| perror("getrlimit"); | |
| return -1; | |
| } | |
| rlim.rlim_cur = 65536; | |
| if (setrlimit(RLIMIT_NOFILE, &rlim)) { | |
| perror("setrlimit"); | |
| return -1; | |
| } | |
| ncpus = get_nprocs_conf(); | |
| size = CPU_ALLOC_SIZE(ncpus); | |
| mask = CPU_ALLOC(ncpus); | |
| if (!mask) { | |
| perror("malloc"); | |
| return -1; | |
| } | |
| CPU_ZERO_S(size, mask); | |
| if (sched_getaffinity(0, size, mask)) { | |
| perror("sched_getaffinity"); | |
| ret = -1; | |
| goto done; | |
| } | |
| for (i = 0, cpu = 0; i < nprocs && cpu < ncpus; cpu++) { | |
| if (!CPU_ISSET_S(cpu, size, mask)) | |
| continue; | |
| fd[i] = perf_cpu_event_open(cpu, type, addr, len); | |
| if (fd[i] < 0) { | |
| perror("perf_systemwide_event_open"); | |
| close_fds(fd, i); | |
| ret = fd[i]; | |
| goto done; | |
| } | |
| i++; | |
| } | |
| if (i < nprocs) { | |
| printf("Error: Number of online cpus reduced since start of test: %d < %d\n", i, nprocs); | |
| close_fds(fd, i); | |
| ret = -1; | |
| } | |
| done: | |
| CPU_FREE(mask); | |
| return ret; | |
| } | |
| static inline bool breakpoint_test(int len) | |
| { | |
| int fd; | |
| /* bp_addr can point anywhere but needs to be aligned */ | |
| fd = perf_process_event_open(HW_BREAKPOINT_R, (__u64)(&fd) & 0xfffffffffffff800, len); | |
| if (fd < 0) | |
| return false; | |
| close(fd); | |
| return true; | |
| } | |
| static inline bool perf_breakpoint_supported(void) | |
| { | |
| return breakpoint_test(4); | |
| } | |
| static inline bool dawr_supported(void) | |
| { | |
| return breakpoint_test(DAWR_LENGTH_MAX); | |
| } | |
| static int runtestsingle(int readwriteflag, int exclude_user, int arraytest) | |
| { | |
| int i,j; | |
| size_t res; | |
| unsigned long long breaks, needed; | |
| int readint; | |
| int readintarraybig[2*DAWR_LENGTH_MAX/sizeof(int)]; | |
| int *readintalign; | |
| volatile int *ptr; | |
| int break_fd; | |
| int loop_num = MAX_LOOPS - (rand() % 100); /* provide some variability */ | |
| volatile int *k; | |
| __u64 len; | |
| /* align to 0x400 boundary as required by DAWR */ | |
| readintalign = (int *)(((unsigned long)readintarraybig + 0x7ff) & | |
| 0xfffffffffffff800); | |
| ptr = &readint; | |
| if (arraytest) | |
| ptr = &readintalign[0]; | |
| len = arraytest ? DAWR_LENGTH_MAX : sizeof(int); | |
| break_fd = perf_process_event_open_exclude_user(readwriteflag, (__u64)ptr, | |
| len, exclude_user); | |
| if (break_fd < 0) { | |
| perror("perf_process_event_open_exclude_user"); | |
| exit(1); | |
| } | |
| /* start counters */ | |
| ioctl(break_fd, PERF_EVENT_IOC_ENABLE); | |
| /* Test a bunch of reads and writes */ | |
| k = &readint; | |
| for (i = 0; i < loop_num; i++) { | |
| if (arraytest) | |
| k = &(readintalign[i % (DAWR_LENGTH_MAX/sizeof(int))]); | |
| j = *k; | |
| *k = j; | |
| } | |
| /* stop counters */ | |
| ioctl(break_fd, PERF_EVENT_IOC_DISABLE); | |
| /* read and check counters */ | |
| res = read(break_fd, &breaks, sizeof(unsigned long long)); | |
| assert(res == sizeof(unsigned long long)); | |
| /* we read and write each loop, so subtract the ones we are counting */ | |
| needed = 0; | |
| if (readwriteflag & HW_BREAKPOINT_R) | |
| needed += loop_num; | |
| if (readwriteflag & HW_BREAKPOINT_W) | |
| needed += loop_num; | |
| needed = needed * (1 - exclude_user); | |
| printf("TESTED: addr:0x%lx brks:% 8lld loops:% 8i rw:%i !user:%i array:%i\n", | |
| (unsigned long int)ptr, breaks, loop_num, readwriteflag, exclude_user, arraytest); | |
| if (breaks != needed) { | |
| printf("FAILED: 0x%lx brks:%lld needed:%lli %i %i %i\n\n", | |
| (unsigned long int)ptr, breaks, needed, loop_num, readwriteflag, exclude_user); | |
| return 1; | |
| } | |
| close(break_fd); | |
| return 0; | |
| } | |
| static int runtest_dar_outside(void) | |
| { | |
| void *target; | |
| volatile __u16 temp16; | |
| volatile __u64 temp64; | |
| int break_fd; | |
| unsigned long long breaks; | |
| int fail = 0; | |
| size_t res; | |
| target = malloc(8); | |
| if (!target) { | |
| perror("malloc failed"); | |
| exit(EXIT_FAILURE); | |
| } | |
| /* watch middle half of target array */ | |
| break_fd = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)(target + 2), 4); | |
| if (break_fd < 0) { | |
| free(target); | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| /* Shouldn't hit. */ | |
| ioctl(break_fd, PERF_EVENT_IOC_RESET); | |
| ioctl(break_fd, PERF_EVENT_IOC_ENABLE); | |
| temp16 = *((__u16 *)target); | |
| *((__u16 *)target) = temp16; | |
| ioctl(break_fd, PERF_EVENT_IOC_DISABLE); | |
| res = read(break_fd, &breaks, sizeof(unsigned long long)); | |
| assert(res == sizeof(unsigned long long)); | |
| if (breaks == 0) { | |
| printf("TESTED: No overlap\n"); | |
| } else { | |
| printf("FAILED: No overlap: %lld != 0\n", breaks); | |
| fail = 1; | |
| } | |
| /* Hit */ | |
| ioctl(break_fd, PERF_EVENT_IOC_RESET); | |
| ioctl(break_fd, PERF_EVENT_IOC_ENABLE); | |
| temp16 = *((__u16 *)(target + 1)); | |
| *((__u16 *)(target + 1)) = temp16; | |
| ioctl(break_fd, PERF_EVENT_IOC_DISABLE); | |
| res = read(break_fd, &breaks, sizeof(unsigned long long)); | |
| assert(res == sizeof(unsigned long long)); | |
| if (breaks == 2) { | |
| printf("TESTED: Partial overlap\n"); | |
| } else { | |
| printf("FAILED: Partial overlap: %lld != 2\n", breaks); | |
| fail = 1; | |
| } | |
| /* Hit */ | |
| ioctl(break_fd, PERF_EVENT_IOC_RESET); | |
| ioctl(break_fd, PERF_EVENT_IOC_ENABLE); | |
| temp16 = *((__u16 *)(target + 5)); | |
| *((__u16 *)(target + 5)) = temp16; | |
| ioctl(break_fd, PERF_EVENT_IOC_DISABLE); | |
| res = read(break_fd, &breaks, sizeof(unsigned long long)); | |
| assert(res == sizeof(unsigned long long)); | |
| if (breaks == 2) { | |
| printf("TESTED: Partial overlap\n"); | |
| } else { | |
| printf("FAILED: Partial overlap: %lld != 2\n", breaks); | |
| fail = 1; | |
| } | |
| /* Shouldn't Hit */ | |
| ioctl(break_fd, PERF_EVENT_IOC_RESET); | |
| ioctl(break_fd, PERF_EVENT_IOC_ENABLE); | |
| temp16 = *((__u16 *)(target + 6)); | |
| *((__u16 *)(target + 6)) = temp16; | |
| ioctl(break_fd, PERF_EVENT_IOC_DISABLE); | |
| res = read(break_fd, &breaks, sizeof(unsigned long long)); | |
| assert(res == sizeof(unsigned long long)); | |
| if (breaks == 0) { | |
| printf("TESTED: No overlap\n"); | |
| } else { | |
| printf("FAILED: No overlap: %lld != 0\n", breaks); | |
| fail = 1; | |
| } | |
| /* Hit */ | |
| ioctl(break_fd, PERF_EVENT_IOC_RESET); | |
| ioctl(break_fd, PERF_EVENT_IOC_ENABLE); | |
| temp64 = *((__u64 *)target); | |
| *((__u64 *)target) = temp64; | |
| ioctl(break_fd, PERF_EVENT_IOC_DISABLE); | |
| res = read(break_fd, &breaks, sizeof(unsigned long long)); | |
| assert(res == sizeof(unsigned long long)); | |
| if (breaks == 2) { | |
| printf("TESTED: Full overlap\n"); | |
| } else { | |
| printf("FAILED: Full overlap: %lld != 2\n", breaks); | |
| fail = 1; | |
| } | |
| free(target); | |
| close(break_fd); | |
| return fail; | |
| } | |
| static void multi_dawr_workload(void) | |
| { | |
| a += 10; | |
| b += 10; | |
| c[512 + 1] += 'a'; | |
| } | |
| static int test_process_multi_diff_addr(void) | |
| { | |
| unsigned long long breaks1 = 0, breaks2 = 0; | |
| int fd1, fd2; | |
| char *desc = "Process specific, Two events, diff addr"; | |
| size_t res; | |
| fd1 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a)); | |
| if (fd1 < 0) { | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| fd2 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&b, (__u64)sizeof(b)); | |
| if (fd2 < 0) { | |
| close(fd1); | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| ioctl(fd1, PERF_EVENT_IOC_RESET); | |
| ioctl(fd2, PERF_EVENT_IOC_RESET); | |
| ioctl(fd1, PERF_EVENT_IOC_ENABLE); | |
| ioctl(fd2, PERF_EVENT_IOC_ENABLE); | |
| multi_dawr_workload(); | |
| ioctl(fd1, PERF_EVENT_IOC_DISABLE); | |
| ioctl(fd2, PERF_EVENT_IOC_DISABLE); | |
| res = read(fd1, &breaks1, sizeof(breaks1)); | |
| assert(res == sizeof(unsigned long long)); | |
| res = read(fd2, &breaks2, sizeof(breaks2)); | |
| assert(res == sizeof(unsigned long long)); | |
| close(fd1); | |
| close(fd2); | |
| if (breaks1 != 2 || breaks2 != 2) { | |
| printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| static int test_process_multi_same_addr(void) | |
| { | |
| unsigned long long breaks1 = 0, breaks2 = 0; | |
| int fd1, fd2; | |
| char *desc = "Process specific, Two events, same addr"; | |
| size_t res; | |
| fd1 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a)); | |
| if (fd1 < 0) { | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| fd2 = perf_process_event_open(HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a)); | |
| if (fd2 < 0) { | |
| close(fd1); | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| ioctl(fd1, PERF_EVENT_IOC_RESET); | |
| ioctl(fd2, PERF_EVENT_IOC_RESET); | |
| ioctl(fd1, PERF_EVENT_IOC_ENABLE); | |
| ioctl(fd2, PERF_EVENT_IOC_ENABLE); | |
| multi_dawr_workload(); | |
| ioctl(fd1, PERF_EVENT_IOC_DISABLE); | |
| ioctl(fd2, PERF_EVENT_IOC_DISABLE); | |
| res = read(fd1, &breaks1, sizeof(breaks1)); | |
| assert(res == sizeof(unsigned long long)); | |
| res = read(fd2, &breaks2, sizeof(breaks2)); | |
| assert(res == sizeof(unsigned long long)); | |
| close(fd1); | |
| close(fd2); | |
| if (breaks1 != 2 || breaks2 != 2) { | |
| printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| static int test_process_multi_diff_addr_ro_wo(void) | |
| { | |
| unsigned long long breaks1 = 0, breaks2 = 0; | |
| int fd1, fd2; | |
| char *desc = "Process specific, Two events, diff addr, one is RO, other is WO"; | |
| size_t res; | |
| fd1 = perf_process_event_open(HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a)); | |
| if (fd1 < 0) { | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| fd2 = perf_process_event_open(HW_BREAKPOINT_R, (__u64)&b, (__u64)sizeof(b)); | |
| if (fd2 < 0) { | |
| close(fd1); | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| ioctl(fd1, PERF_EVENT_IOC_RESET); | |
| ioctl(fd2, PERF_EVENT_IOC_RESET); | |
| ioctl(fd1, PERF_EVENT_IOC_ENABLE); | |
| ioctl(fd2, PERF_EVENT_IOC_ENABLE); | |
| multi_dawr_workload(); | |
| ioctl(fd1, PERF_EVENT_IOC_DISABLE); | |
| ioctl(fd2, PERF_EVENT_IOC_DISABLE); | |
| res = read(fd1, &breaks1, sizeof(breaks1)); | |
| assert(res == sizeof(unsigned long long)); | |
| res = read(fd2, &breaks2, sizeof(breaks2)); | |
| assert(res == sizeof(unsigned long long)); | |
| close(fd1); | |
| close(fd2); | |
| if (breaks1 != 1 || breaks2 != 1) { | |
| printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| static int test_process_multi_same_addr_ro_wo(void) | |
| { | |
| unsigned long long breaks1 = 0, breaks2 = 0; | |
| int fd1, fd2; | |
| char *desc = "Process specific, Two events, same addr, one is RO, other is WO"; | |
| size_t res; | |
| fd1 = perf_process_event_open(HW_BREAKPOINT_R, (__u64)&a, (__u64)sizeof(a)); | |
| if (fd1 < 0) { | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| fd2 = perf_process_event_open(HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a)); | |
| if (fd2 < 0) { | |
| close(fd1); | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| ioctl(fd1, PERF_EVENT_IOC_RESET); | |
| ioctl(fd2, PERF_EVENT_IOC_RESET); | |
| ioctl(fd1, PERF_EVENT_IOC_ENABLE); | |
| ioctl(fd2, PERF_EVENT_IOC_ENABLE); | |
| multi_dawr_workload(); | |
| ioctl(fd1, PERF_EVENT_IOC_DISABLE); | |
| ioctl(fd2, PERF_EVENT_IOC_DISABLE); | |
| res = read(fd1, &breaks1, sizeof(breaks1)); | |
| assert(res == sizeof(unsigned long long)); | |
| res = read(fd2, &breaks2, sizeof(breaks2)); | |
| assert(res == sizeof(unsigned long long)); | |
| close(fd1); | |
| close(fd2); | |
| if (breaks1 != 1 || breaks2 != 1) { | |
| printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| static int test_syswide_multi_diff_addr(void) | |
| { | |
| unsigned long long breaks1 = 0, breaks2 = 0; | |
| int *fd1 = malloc(nprocs * sizeof(int)); | |
| int *fd2 = malloc(nprocs * sizeof(int)); | |
| char *desc = "Systemwide, Two events, diff addr"; | |
| int ret; | |
| ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a)); | |
| if (ret) | |
| exit(EXIT_FAILURE); | |
| ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_RW, (__u64)&b, (__u64)sizeof(b)); | |
| if (ret) { | |
| close_fds(fd1, nprocs); | |
| exit(EXIT_FAILURE); | |
| } | |
| reset_fds(fd1, nprocs); | |
| reset_fds(fd2, nprocs); | |
| enable_fds(fd1, nprocs); | |
| enable_fds(fd2, nprocs); | |
| multi_dawr_workload(); | |
| disable_fds(fd1, nprocs); | |
| disable_fds(fd2, nprocs); | |
| breaks1 = read_fds(fd1, nprocs); | |
| breaks2 = read_fds(fd2, nprocs); | |
| close_fds(fd1, nprocs); | |
| close_fds(fd2, nprocs); | |
| free(fd1); | |
| free(fd2); | |
| if (breaks1 != 2 || breaks2 != 2) { | |
| printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| static int test_syswide_multi_same_addr(void) | |
| { | |
| unsigned long long breaks1 = 0, breaks2 = 0; | |
| int *fd1 = malloc(nprocs * sizeof(int)); | |
| int *fd2 = malloc(nprocs * sizeof(int)); | |
| char *desc = "Systemwide, Two events, same addr"; | |
| int ret; | |
| ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a)); | |
| if (ret) | |
| exit(EXIT_FAILURE); | |
| ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_RW, (__u64)&a, (__u64)sizeof(a)); | |
| if (ret) { | |
| close_fds(fd1, nprocs); | |
| exit(EXIT_FAILURE); | |
| } | |
| reset_fds(fd1, nprocs); | |
| reset_fds(fd2, nprocs); | |
| enable_fds(fd1, nprocs); | |
| enable_fds(fd2, nprocs); | |
| multi_dawr_workload(); | |
| disable_fds(fd1, nprocs); | |
| disable_fds(fd2, nprocs); | |
| breaks1 = read_fds(fd1, nprocs); | |
| breaks2 = read_fds(fd2, nprocs); | |
| close_fds(fd1, nprocs); | |
| close_fds(fd2, nprocs); | |
| free(fd1); | |
| free(fd2); | |
| if (breaks1 != 2 || breaks2 != 2) { | |
| printf("FAILED: %s: %lld != 2 || %lld != 2\n", desc, breaks1, breaks2); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| static int test_syswide_multi_diff_addr_ro_wo(void) | |
| { | |
| unsigned long long breaks1 = 0, breaks2 = 0; | |
| int *fd1 = malloc(nprocs * sizeof(int)); | |
| int *fd2 = malloc(nprocs * sizeof(int)); | |
| char *desc = "Systemwide, Two events, diff addr, one is RO, other is WO"; | |
| int ret; | |
| ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a)); | |
| if (ret) | |
| exit(EXIT_FAILURE); | |
| ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_R, (__u64)&b, (__u64)sizeof(b)); | |
| if (ret) { | |
| close_fds(fd1, nprocs); | |
| exit(EXIT_FAILURE); | |
| } | |
| reset_fds(fd1, nprocs); | |
| reset_fds(fd2, nprocs); | |
| enable_fds(fd1, nprocs); | |
| enable_fds(fd2, nprocs); | |
| multi_dawr_workload(); | |
| disable_fds(fd1, nprocs); | |
| disable_fds(fd2, nprocs); | |
| breaks1 = read_fds(fd1, nprocs); | |
| breaks2 = read_fds(fd2, nprocs); | |
| close_fds(fd1, nprocs); | |
| close_fds(fd2, nprocs); | |
| free(fd1); | |
| free(fd2); | |
| if (breaks1 != 1 || breaks2 != 1) { | |
| printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| static int test_syswide_multi_same_addr_ro_wo(void) | |
| { | |
| unsigned long long breaks1 = 0, breaks2 = 0; | |
| int *fd1 = malloc(nprocs * sizeof(int)); | |
| int *fd2 = malloc(nprocs * sizeof(int)); | |
| char *desc = "Systemwide, Two events, same addr, one is RO, other is WO"; | |
| int ret; | |
| ret = perf_systemwide_event_open(fd1, HW_BREAKPOINT_W, (__u64)&a, (__u64)sizeof(a)); | |
| if (ret) | |
| exit(EXIT_FAILURE); | |
| ret = perf_systemwide_event_open(fd2, HW_BREAKPOINT_R, (__u64)&a, (__u64)sizeof(a)); | |
| if (ret) { | |
| close_fds(fd1, nprocs); | |
| exit(EXIT_FAILURE); | |
| } | |
| reset_fds(fd1, nprocs); | |
| reset_fds(fd2, nprocs); | |
| enable_fds(fd1, nprocs); | |
| enable_fds(fd2, nprocs); | |
| multi_dawr_workload(); | |
| disable_fds(fd1, nprocs); | |
| disable_fds(fd2, nprocs); | |
| breaks1 = read_fds(fd1, nprocs); | |
| breaks2 = read_fds(fd2, nprocs); | |
| close_fds(fd1, nprocs); | |
| close_fds(fd2, nprocs); | |
| free(fd1); | |
| free(fd2); | |
| if (breaks1 != 1 || breaks2 != 1) { | |
| printf("FAILED: %s: %lld != 1 || %lld != 1\n", desc, breaks1, breaks2); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| static int runtest_multi_dawr(void) | |
| { | |
| int ret = 0; | |
| ret |= test_process_multi_diff_addr(); | |
| ret |= test_process_multi_same_addr(); | |
| ret |= test_process_multi_diff_addr_ro_wo(); | |
| ret |= test_process_multi_same_addr_ro_wo(); | |
| ret |= test_syswide_multi_diff_addr(); | |
| ret |= test_syswide_multi_same_addr(); | |
| ret |= test_syswide_multi_diff_addr_ro_wo(); | |
| ret |= test_syswide_multi_same_addr_ro_wo(); | |
| return ret; | |
| } | |
| static int runtest_unaligned_512bytes(void) | |
| { | |
| unsigned long long breaks = 0; | |
| int fd; | |
| char *desc = "Process specific, 512 bytes, unaligned"; | |
| __u64 addr = (__u64)&c + 8; | |
| size_t res; | |
| fd = perf_process_event_open(HW_BREAKPOINT_RW, addr, 512); | |
| if (fd < 0) { | |
| perror("perf_process_event_open"); | |
| exit(EXIT_FAILURE); | |
| } | |
| ioctl(fd, PERF_EVENT_IOC_RESET); | |
| ioctl(fd, PERF_EVENT_IOC_ENABLE); | |
| multi_dawr_workload(); | |
| ioctl(fd, PERF_EVENT_IOC_DISABLE); | |
| res = read(fd, &breaks, sizeof(breaks)); | |
| assert(res == sizeof(unsigned long long)); | |
| close(fd); | |
| if (breaks != 2) { | |
| printf("FAILED: %s: %lld != 2\n", desc, breaks); | |
| return 1; | |
| } | |
| printf("TESTED: %s\n", desc); | |
| return 0; | |
| } | |
| /* There is no perf api to find number of available watchpoints. Use ptrace. */ | |
| static int get_nr_wps(bool *arch_31) | |
| { | |
| struct ppc_debug_info dbginfo; | |
| int child_pid; | |
| child_pid = fork(); | |
| if (!child_pid) { | |
| int ret = ptrace(PTRACE_TRACEME, 0, NULL, 0); | |
| if (ret) { | |
| perror("PTRACE_TRACEME failed\n"); | |
| exit(EXIT_FAILURE); | |
| } | |
| kill(getpid(), SIGUSR1); | |
| sleep(1); | |
| exit(EXIT_SUCCESS); | |
| } | |
| wait(NULL); | |
| if (ptrace(PPC_PTRACE_GETHWDBGINFO, child_pid, NULL, &dbginfo)) { | |
| perror("Can't get breakpoint info"); | |
| exit(EXIT_FAILURE); | |
| } | |
| *arch_31 = !!(dbginfo.features & PPC_DEBUG_FEATURE_DATA_BP_ARCH_31); | |
| return dbginfo.num_data_bps; | |
| } | |
| static int runtest(void) | |
| { | |
| int rwflag; | |
| int exclude_user; | |
| int ret; | |
| bool dawr = dawr_supported(); | |
| bool arch_31 = false; | |
| int nr_wps = get_nr_wps(&arch_31); | |
| /* | |
| * perf defines rwflag as two bits read and write and at least | |
| * one must be set. So range 1-3. | |
| */ | |
| for (rwflag = 1 ; rwflag < 4; rwflag++) { | |
| for (exclude_user = 0 ; exclude_user < 2; exclude_user++) { | |
| ret = runtestsingle(rwflag, exclude_user, 0); | |
| if (ret) | |
| return ret; | |
| /* if we have the dawr, we can do an array test */ | |
| if (!dawr) | |
| continue; | |
| ret = runtestsingle(rwflag, exclude_user, 1); | |
| if (ret) | |
| return ret; | |
| } | |
| } | |
| ret = runtest_dar_outside(); | |
| if (ret) | |
| return ret; | |
| if (dawr && nr_wps > 1) { | |
| nprocs = get_nprocs(); | |
| ret = runtest_multi_dawr(); | |
| if (ret) | |
| return ret; | |
| } | |
| if (dawr && arch_31) | |
| ret = runtest_unaligned_512bytes(); | |
| return ret; | |
| } | |
| static int perf_hwbreak(void) | |
| { | |
| srand ( time(NULL) ); | |
| SKIP_IF_MSG(!perf_breakpoint_supported(), "Perf breakpoints not supported"); | |
| return runtest(); | |
| } | |
| int main(int argc, char *argv[], char **envp) | |
| { | |
| return test_harness(perf_hwbreak, "perf_hwbreak"); | |
| } |