tools/perf/tests/wp.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <stdlib.h>
   3 #include <string.h>
   4 #include <unistd.h>
   5 #include <sys/ioctl.h>
   6 #include <linux/hw_breakpoint.h>
   7 #include <linux/kernel.h>
   8 #include "tests.h"
   9 #include "debug.h"
  10 #include "event.h"
  11 #include "cloexec.h"
  12 #include "../perf-sys.h"
  13
  14 #define WP_TEST_ASSERT_VAL(fd, text, val)       \
  15 do {                                            \
  16         long long count;                        \
  17         wp_read(fd, &count, sizeof(long long)); \
  18         TEST_ASSERT_VAL(text, count == val);    \
  19 } while (0)
  20
  21 volatile u64 data1;
  22 volatile u8 data2[3];
  23
  24 static int wp_read(int fd, long long *count, int size)
  25 {
  26         int ret = read(fd, count, size);
  27
  28         if (ret != size) {
  29                 pr_debug("failed to read: %d\n", ret);
  30                 return -1;
  31         }
  32         return 0;
  33 }
  34
  35 static void get__perf_event_attr(struct perf_event_attr *attr, int wp_type,
  36                                  void *wp_addr, unsigned long wp_len)
  37 {
  38         memset(attr, 0, sizeof(struct perf_event_attr));
  39         attr->type           = PERF_TYPE_BREAKPOINT;
  40         attr->size           = sizeof(struct perf_event_attr);
  41         attr->config         = 0;
  42         attr->bp_type        = wp_type;
  43         attr->bp_addr        = (unsigned long)wp_addr;
  44         attr->bp_len         = wp_len;
  45         attr->sample_period  = 1;
  46         attr->sample_type    = PERF_SAMPLE_IP;
  47         attr->exclude_kernel = 1;
  48         attr->exclude_hv     = 1;
  49 }
  50
  51 static int __event(int wp_type, void *wp_addr, unsigned long wp_len)
  52 {
  53         int fd;
  54         struct perf_event_attr attr;
  55
  56         get__perf_event_attr(&attr, wp_type, wp_addr, wp_len);
  57         fd = sys_perf_event_open(&attr, 0, -1, -1,
  58                                  perf_event_open_cloexec_flag());
  59         if (fd < 0)
  60                 pr_debug("failed opening event %x\n", attr.bp_type);
  61
  62         return fd;
  63 }
  64
  65 static int wp_ro_test(void)
  66 {
  67         int fd;
  68         unsigned long tmp, tmp1 = rand();
  69
  70         fd = __event(HW_BREAKPOINT_R, (void *)&data1, sizeof(data1));
  71         if (fd < 0)
  72                 return -1;
  73
  74         tmp = data1;
  75         WP_TEST_ASSERT_VAL(fd, "RO watchpoint", 1);
  76
  77         data1 = tmp1 + tmp;
  78         WP_TEST_ASSERT_VAL(fd, "RO watchpoint", 1);
  79
  80         close(fd);
  81         return 0;
  82 }
  83
  84 static int wp_wo_test(void)
  85 {
  86         int fd;
  87         unsigned long tmp, tmp1 = rand();
  88
  89         fd = __event(HW_BREAKPOINT_W, (void *)&data1, sizeof(data1));
  90         if (fd < 0)
  91                 return -1;
  92
  93         tmp = data1;
  94         WP_TEST_ASSERT_VAL(fd, "WO watchpoint", 0);
  95
  96         data1 = tmp1 + tmp;
  97         WP_TEST_ASSERT_VAL(fd, "WO watchpoint", 1);
  98
  99         close(fd);
 100         return 0;
 101 }
 102
 103 static int wp_rw_test(void)
 104 {
 105         int fd;
 106         unsigned long tmp, tmp1 = rand();
 107
 108         fd = __event(HW_BREAKPOINT_R | HW_BREAKPOINT_W, (void *)&data1,
 109                      sizeof(data1));
 110         if (fd < 0)
 111                 return -1;
 112
 113         tmp = data1;
 114         WP_TEST_ASSERT_VAL(fd, "RW watchpoint", 1);
 115
 116         data1 = tmp1 + tmp;
 117         WP_TEST_ASSERT_VAL(fd, "RW watchpoint", 2);
 118
 119         close(fd);
 120         return 0;
 121 }
 122
 123 static int wp_modify_test(void)
 124 {
 125         int fd, ret;
 126         unsigned long tmp = rand();
 127         struct perf_event_attr new_attr;
 128
 129         fd = __event(HW_BREAKPOINT_W, (void *)&data1, sizeof(data1));
 130         if (fd < 0)
 131                 return -1;
 132
 133         data1 = tmp;
 134         WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 1);
 135
 136         /* Modify watchpoint with disabled = 1 */
 137         get__perf_event_attr(&new_attr, HW_BREAKPOINT_W, (void *)&data2[0],
 138                              sizeof(u8) * 2);
 139         new_attr.disabled = 1;
 140         ret = ioctl(fd, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, &new_attr);
 141         if (ret < 0) {
 142                 pr_debug("ioctl(PERF_EVENT_IOC_MODIFY_ATTRIBUTES) failed\n");
 143                 close(fd);
 144                 return ret;
 145         }
 146
 147         data2[1] = tmp; /* Not Counted */
 148         WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 1);
 149
 150         /* Enable the event */
 151         ioctl(fd, PERF_EVENT_IOC_ENABLE, 0);
 152         if (ret < 0) {
 153                 pr_debug("Failed to enable event\n");
 154                 close(fd);
 155                 return ret;
 156         }
 157
 158         data2[1] = tmp; /* Counted */
 159         WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 2);
 160
 161         data2[2] = tmp; /* Not Counted */
 162         WP_TEST_ASSERT_VAL(fd, "Modify watchpoint", 2);
 163
 164         close(fd);
 165         return 0;
 166 }
 167
 168 static bool wp_ro_supported(void)
 169 {
 170 #if defined (__x86_64__) || defined (__i386__)
 171         return false;
 172 #else
 173         return true;
 174 #endif
 175 }
 176
 177 static void wp_ro_skip_msg(void)
 178 {
 179 #if defined (__x86_64__) || defined (__i386__)
 180         pr_debug("Hardware does not support read only watchpoints.\n");
 181 #endif
 182 }
 183
 184 static struct {
 185         const char *desc;
 186         int (*target_func)(void);
 187         bool (*is_supported)(void);
 188         void (*skip_msg)(void);
 189 } wp_testcase_table[] = {
 190         {
 191                 .desc = "Read Only Watchpoint",
 192                 .target_func = &wp_ro_test,
 193                 .is_supported = &wp_ro_supported,
 194                 .skip_msg = &wp_ro_skip_msg,
 195         },
 196         {
 197                 .desc = "Write Only Watchpoint",
 198                 .target_func = &wp_wo_test,
 199         },
 200         {
 201                 .desc = "Read / Write Watchpoint",
 202                 .target_func = &wp_rw_test,
 203         },
 204         {
 205                 .desc = "Modify Watchpoint",
 206                 .target_func = &wp_modify_test,
 207         },
 208 };
 209
 210 int test__wp_subtest_get_nr(void)
 211 {
 212         return (int)ARRAY_SIZE(wp_testcase_table);
 213 }
 214
 215 const char *test__wp_subtest_get_desc(int i)
 216 {
 217         if (i < 0 || i >= (int)ARRAY_SIZE(wp_testcase_table))
 218                 return NULL;
 219         return wp_testcase_table[i].desc;
 220 }
 221
 222 int test__wp(struct test *test __maybe_unused, int i)
 223 {
 224         if (i < 0 || i >= (int)ARRAY_SIZE(wp_testcase_table))
 225                 return TEST_FAIL;
 226
 227         if (wp_testcase_table[i].is_supported &&
 228             !wp_testcase_table[i].is_supported()) {
 229                 wp_testcase_table[i].skip_msg();
 230                 return TEST_SKIP;
 231         }
 232
 233         return !wp_testcase_table[i].target_func() ? TEST_OK : TEST_FAIL;
 234 }
 235
 236 /* The s390 so far does not have support for
 237  * instruction breakpoint using the perf_event_open() system call.
 238  */
 239 bool test__wp_is_supported(void)
 240 {
 241 #if defined(__s390x__)
 242         return false;
 243 #else
 244         return true;
 245 #endif
 246 }