tools/testing/selftests/user_events/perf_test.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * User Events Perf Events Test Program
   4  *
   5  * Copyright (c) 2021 Beau Belgrave <beaub@linux.microsoft.com>
   6  */
   7
   8 #include <errno.h>
   9 #include <linux/user_events.h>
  10 #include <linux/perf_event.h>
  11 #include <stdio.h>
  12 #include <stdlib.h>
  13 #include <fcntl.h>
  14 #include <sys/ioctl.h>
  15 #include <sys/stat.h>
  16 #include <unistd.h>
  17 #include <asm/unistd.h>
  18
  19 #include "../kselftest_harness.h"
  20 #include "user_events_selftests.h"
  21
  22 const char *data_file = "/sys/kernel/tracing/user_events_data";
  23 const char *id_file = "/sys/kernel/tracing/events/user_events/__test_event/id";
  24 const char *fmt_file = "/sys/kernel/tracing/events/user_events/__test_event/format";
  25
  26 struct event {
  27         __u32 index;
  28         __u32 field1;
  29         __u32 field2;
  30 };
  31
  32 static long perf_event_open(struct perf_event_attr *pe, pid_t pid,
  33                             int cpu, int group_fd, unsigned long flags)
  34 {
  35         return syscall(__NR_perf_event_open, pe, pid, cpu, group_fd, flags);
  36 }
  37
  38 static int get_id(void)
  39 {
  40         FILE *fp = fopen(id_file, "r");
  41         int ret, id = 0;
  42
  43         if (!fp)
  44                 return -1;
  45
  46         ret = fscanf(fp, "%d", &id);
  47         fclose(fp);
  48
  49         if (ret != 1)
  50                 return -1;
  51
  52         return id;
  53 }
  54
  55 static int get_offset(void)
  56 {
  57         FILE *fp = fopen(fmt_file, "r");
  58         int ret, c, last = 0, offset = 0;
  59
  60         if (!fp)
  61                 return -1;
  62
  63         /* Read until empty line */
  64         while (true) {
  65                 c = getc(fp);
  66
  67                 if (c == EOF)
  68                         break;
  69
  70                 if (last == '\n' && c == '\n')
  71                         break;
  72
  73                 last = c;
  74         }
  75
  76         ret = fscanf(fp, "\tfield:u32 field1;\toffset:%d;", &offset);
  77         fclose(fp);
  78
  79         if (ret != 1)
  80                 return -1;
  81
  82         return offset;
  83 }
  84
  85 static int clear(int *check)
  86 {
  87         struct user_unreg unreg = {0};
  88
  89         unreg.size = sizeof(unreg);
  90         unreg.disable_bit = 31;
  91         unreg.disable_addr = (__u64)check;
  92
  93         int fd = open(data_file, O_RDWR);
  94
  95         if (fd == -1)
  96                 return -1;
  97
  98         if (ioctl(fd, DIAG_IOCSUNREG, &unreg) == -1)
  99                 if (errno != ENOENT)
 100                         return -1;
 101
 102         if (ioctl(fd, DIAG_IOCSDEL, "__test_event") == -1)
 103                 if (errno != ENOENT)
 104                         return -1;
 105
 106         close(fd);
 107
 108         return 0;
 109 }
 110
 111 FIXTURE(user) {
 112         int data_fd;
 113         int check;
 114         bool umount;
 115 };
 116
 117 FIXTURE_SETUP(user) {
 118         USER_EVENT_FIXTURE_SETUP(return, self->umount);
 119
 120         self->data_fd = open(data_file, O_RDWR);
 121         ASSERT_NE(-1, self->data_fd);
 122 }
 123
 124 FIXTURE_TEARDOWN(user) {
 125         USER_EVENT_FIXTURE_TEARDOWN(self->umount);
 126
 127         close(self->data_fd);
 128
 129         if (clear(&self->check) != 0)
 130                 printf("WARNING: Clear didn't work!\n");
 131 }
 132
 133 TEST_F(user, perf_write) {
 134         struct perf_event_attr pe = {0};
 135         struct user_reg reg = {0};
 136         struct event event;
 137         struct perf_event_mmap_page *perf_page;
 138         int page_size = sysconf(_SC_PAGESIZE);
 139         int id, fd, offset;
 140         __u32 *val;
 141
 142         reg.size = sizeof(reg);
 143         reg.name_args = (__u64)"__test_event u32 field1; u32 field2";
 144         reg.enable_bit = 31;
 145         reg.enable_addr = (__u64)&self->check;
 146         reg.enable_size = sizeof(self->check);
 147
 148         /* Register should work */
 149         ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, &reg));
 150         ASSERT_EQ(0, reg.write_index);
 151         ASSERT_EQ(0, self->check);
 152
 153         /* Id should be there */
 154         id = get_id();
 155         ASSERT_NE(-1, id);
 156         offset = get_offset();
 157         ASSERT_NE(-1, offset);
 158
 159         pe.type = PERF_TYPE_TRACEPOINT;
 160         pe.size = sizeof(pe);
 161         pe.config = id;
 162         pe.sample_type = PERF_SAMPLE_RAW;
 163         pe.sample_period = 1;
 164         pe.wakeup_events = 1;
 165
 166         /* Tracepoint attach should work */
 167         fd = perf_event_open(&pe, 0, -1, -1, 0);
 168         ASSERT_NE(-1, fd);
 169
 170         perf_page = mmap(NULL, page_size * 2, PROT_READ, MAP_SHARED, fd, 0);
 171         ASSERT_NE(MAP_FAILED, perf_page);
 172
 173         /* Status should be updated */
 174         ASSERT_EQ(1 << reg.enable_bit, self->check);
 175
 176         event.index = reg.write_index;
 177         event.field1 = 0xc001;
 178         event.field2 = 0xc01a;
 179
 180         /* Ensure write shows up at correct offset */
 181         ASSERT_NE(-1, write(self->data_fd, &event, sizeof(event)));
 182         val = (void *)(((char *)perf_page) + perf_page->data_offset);
 183         ASSERT_EQ(PERF_RECORD_SAMPLE, *val);
 184         /* Skip over header and size, move to offset */
 185         val += 3;
 186         val = (void *)((char *)val) + offset;
 187         /* Ensure correct */
 188         ASSERT_EQ(event.field1, *val++);
 189         ASSERT_EQ(event.field2, *val++);
 190
 191         munmap(perf_page, page_size * 2);
 192         close(fd);
 193
 194         /* Status should be updated */
 195         ASSERT_EQ(0, self->check);
 196 }
 197
 198 TEST_F(user, perf_empty_events) {
 199         struct perf_event_attr pe = {0};
 200         struct user_reg reg = {0};
 201         struct perf_event_mmap_page *perf_page;
 202         int page_size = sysconf(_SC_PAGESIZE);
 203         int id, fd;
 204         __u32 *val;
 205
 206         reg.size = sizeof(reg);
 207         reg.name_args = (__u64)"__test_event";
 208         reg.enable_bit = 31;
 209         reg.enable_addr = (__u64)&self->check;
 210         reg.enable_size = sizeof(self->check);
 211
 212         /* Register should work */
 213         ASSERT_EQ(0, ioctl(self->data_fd, DIAG_IOCSREG, &reg));
 214         ASSERT_EQ(0, reg.write_index);
 215         ASSERT_EQ(0, self->check);
 216
 217         /* Id should be there */
 218         id = get_id();
 219         ASSERT_NE(-1, id);
 220
 221         pe.type = PERF_TYPE_TRACEPOINT;
 222         pe.size = sizeof(pe);
 223         pe.config = id;
 224         pe.sample_type = PERF_SAMPLE_RAW;
 225         pe.sample_period = 1;
 226         pe.wakeup_events = 1;
 227
 228         /* Tracepoint attach should work */
 229         fd = perf_event_open(&pe, 0, -1, -1, 0);
 230         ASSERT_NE(-1, fd);
 231
 232         perf_page = mmap(NULL, page_size * 2, PROT_READ, MAP_SHARED, fd, 0);
 233         ASSERT_NE(MAP_FAILED, perf_page);
 234
 235         /* Status should be updated */
 236         ASSERT_EQ(1 << reg.enable_bit, self->check);
 237
 238         /* Ensure write shows up at correct offset */
 239         ASSERT_NE(-1, write(self->data_fd, &reg.write_index,
 240                                         sizeof(reg.write_index)));
 241         val = (void *)(((char *)perf_page) + perf_page->data_offset);
 242         ASSERT_EQ(PERF_RECORD_SAMPLE, *val);
 243
 244         munmap(perf_page, page_size * 2);
 245         close(fd);
 246
 247         /* Status should be updated */
 248         ASSERT_EQ(0, self->check);
 249 }
 250
 251 int main(int argc, char **argv)
 252 {
 253         return test_harness_run(argc, argv);
 254 }