tools/testing/selftests/perf_events/sigtrap_threads.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Test for perf events with SIGTRAP across all threads.
   4  *
   5  * Copyright (C) 2021, Google LLC.
   6  */
   7
   8 #define _GNU_SOURCE
   9
  10 /* We need the latest siginfo from the kernel repo. */
  11 #include <sys/types.h>
  12 #include <asm/siginfo.h>
  13 #define __have_siginfo_t 1
  14 #define __have_sigval_t 1
  15 #define __have_sigevent_t 1
  16 #define __siginfo_t_defined
  17 #define __sigval_t_defined
  18 #define __sigevent_t_defined
  19 #define _BITS_SIGINFO_CONSTS_H 1
  20 #define _BITS_SIGEVENT_CONSTS_H 1
  21
  22 #include <stdbool.h>
  23 #include <stddef.h>
  24 #include <stdint.h>
  25 #include <stdio.h>
  26 #include <linux/hw_breakpoint.h>
  27 #include <linux/perf_event.h>
  28 #include <pthread.h>
  29 #include <signal.h>
  30 #include <sys/ioctl.h>
  31 #include <sys/syscall.h>
  32 #include <unistd.h>
  33
  34 #include "../kselftest_harness.h"
  35
  36 #define NUM_THREADS 5
  37
  38 /* Data shared between test body, threads, and signal handler. */
  39 static struct {
  40         int tids_want_signal;           /* Which threads still want a signal. */
  41         int signal_count;               /* Sanity check number of signals received. */
  42         volatile int iterate_on;        /* Variable to set breakpoint on. */
  43         siginfo_t first_siginfo;        /* First observed siginfo_t. */
  44 } ctx;
  45
  46 /* Unique value to check si_perf_data is correctly set from perf_event_attr::sig_data. */
  47 #define TEST_SIG_DATA(addr, id) (~(unsigned long)(addr) + id)
  48
  49 static struct perf_event_attr make_event_attr(bool enabled, volatile void *addr,
  50                                               unsigned long id)
  51 {
  52         struct perf_event_attr attr = {
  53                 .type           = PERF_TYPE_BREAKPOINT,
  54                 .size           = sizeof(attr),
  55                 .sample_period  = 1,
  56                 .disabled       = !enabled,
  57                 .bp_addr        = (unsigned long)addr,
  58                 .bp_type        = HW_BREAKPOINT_RW,
  59                 .bp_len         = HW_BREAKPOINT_LEN_1,
  60                 .inherit        = 1, /* Children inherit events ... */
  61                 .inherit_thread = 1, /* ... but only cloned with CLONE_THREAD. */
  62                 .remove_on_exec = 1, /* Required by sigtrap. */
  63                 .sigtrap        = 1, /* Request synchronous SIGTRAP on event. */
  64                 .sig_data       = TEST_SIG_DATA(addr, id),
  65                 .exclude_kernel = 1, /* To allow */
  66                 .exclude_hv     = 1, /* running as !root */
  67         };
  68         return attr;
  69 }
  70
  71 static void sigtrap_handler(int signum, siginfo_t *info, void *ucontext)
  72 {
  73         if (info->si_code != TRAP_PERF) {
  74                 fprintf(stderr, "%s: unexpected si_code %d\n", __func__, info->si_code);
  75                 return;
  76         }
  77
  78         /*
  79          * The data in siginfo_t we're interested in should all be the same
  80          * across threads.
  81          */
  82         if (!__atomic_fetch_add(&ctx.signal_count, 1, __ATOMIC_RELAXED))
  83                 ctx.first_siginfo = *info;
  84         __atomic_fetch_sub(&ctx.tids_want_signal, syscall(__NR_gettid), __ATOMIC_RELAXED);
  85 }
  86
  87 static void *test_thread(void *arg)
  88 {
  89         pthread_barrier_t *barrier = (pthread_barrier_t *)arg;
  90         pid_t tid = syscall(__NR_gettid);
  91         int iter;
  92         int i;
  93
  94         pthread_barrier_wait(barrier);
  95
  96         __atomic_fetch_add(&ctx.tids_want_signal, tid, __ATOMIC_RELAXED);
  97         iter = ctx.iterate_on; /* read */
  98         if (iter >= 0) {
  99                 for (i = 0; i < iter - 1; i++) {
 100                         __atomic_fetch_add(&ctx.tids_want_signal, tid, __ATOMIC_RELAXED);
 101                         ctx.iterate_on = iter; /* idempotent write */
 102                 }
 103         } else {
 104                 while (ctx.iterate_on);
 105         }
 106
 107         return NULL;
 108 }
 109
 110 FIXTURE(sigtrap_threads)
 111 {
 112         struct sigaction oldact;
 113         pthread_t threads[NUM_THREADS];
 114         pthread_barrier_t barrier;
 115         int fd;
 116 };
 117
 118 FIXTURE_SETUP(sigtrap_threads)
 119 {
 120         struct perf_event_attr attr = make_event_attr(false, &ctx.iterate_on, 0);
 121         struct sigaction action = {};
 122         int i;
 123
 124         memset(&ctx, 0, sizeof(ctx));
 125
 126         /* Initialize sigtrap handler. */
 127         action.sa_flags = SA_SIGINFO | SA_NODEFER;
 128         action.sa_sigaction = sigtrap_handler;
 129         sigemptyset(&action.sa_mask);
 130         ASSERT_EQ(sigaction(SIGTRAP, &action, &self->oldact), 0);
 131
 132         /* Initialize perf event. */
 133         self->fd = syscall(__NR_perf_event_open, &attr, 0, -1, -1, PERF_FLAG_FD_CLOEXEC);
 134         ASSERT_NE(self->fd, -1);
 135
 136         /* Spawn threads inheriting perf event. */
 137         pthread_barrier_init(&self->barrier, NULL, NUM_THREADS + 1);
 138         for (i = 0; i < NUM_THREADS; i++)
 139                 ASSERT_EQ(pthread_create(&self->threads[i], NULL, test_thread, &self->barrier), 0);
 140 }
 141
 142 FIXTURE_TEARDOWN(sigtrap_threads)
 143 {
 144         pthread_barrier_destroy(&self->barrier);
 145         close(self->fd);
 146         sigaction(SIGTRAP, &self->oldact, NULL);
 147 }
 148
 149 static void run_test_threads(struct __test_metadata *_metadata,
 150                              FIXTURE_DATA(sigtrap_threads) *self)
 151 {
 152         int i;
 153
 154         pthread_barrier_wait(&self->barrier);
 155         for (i = 0; i < NUM_THREADS; i++)
 156                 ASSERT_EQ(pthread_join(self->threads[i], NULL), 0);
 157 }
 158
 159 TEST_F(sigtrap_threads, remain_disabled)
 160 {
 161         run_test_threads(_metadata, self);
 162         EXPECT_EQ(ctx.signal_count, 0);
 163         EXPECT_NE(ctx.tids_want_signal, 0);
 164 }
 165
 166 TEST_F(sigtrap_threads, enable_event)
 167 {
 168         EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_ENABLE, 0), 0);
 169         run_test_threads(_metadata, self);
 170
 171         EXPECT_EQ(ctx.signal_count, NUM_THREADS);
 172         EXPECT_EQ(ctx.tids_want_signal, 0);
 173         EXPECT_EQ(ctx.first_siginfo.si_addr, &ctx.iterate_on);
 174         EXPECT_EQ(ctx.first_siginfo.si_perf_type, PERF_TYPE_BREAKPOINT);
 175         EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on, 0));
 176
 177         /* Check enabled for parent. */
 178         ctx.iterate_on = 0;
 179         EXPECT_EQ(ctx.signal_count, NUM_THREADS + 1);
 180 }
 181
 182 /* Test that modification propagates to all inherited events. */
 183 TEST_F(sigtrap_threads, modify_and_enable_event)
 184 {
 185         struct perf_event_attr new_attr = make_event_attr(true, &ctx.iterate_on, 42);
 186
 187         EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_MODIFY_ATTRIBUTES, &new_attr), 0);
 188         run_test_threads(_metadata, self);
 189
 190         EXPECT_EQ(ctx.signal_count, NUM_THREADS);
 191         EXPECT_EQ(ctx.tids_want_signal, 0);
 192         EXPECT_EQ(ctx.first_siginfo.si_addr, &ctx.iterate_on);
 193         EXPECT_EQ(ctx.first_siginfo.si_perf_type, PERF_TYPE_BREAKPOINT);
 194         EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on, 42));
 195
 196         /* Check enabled for parent. */
 197         ctx.iterate_on = 0;
 198         EXPECT_EQ(ctx.signal_count, NUM_THREADS + 1);
 199 }
 200
 201 /* Stress test event + signal handling. */
 202 TEST_F(sigtrap_threads, signal_stress)
 203 {
 204         ctx.iterate_on = 3000;
 205
 206         EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_ENABLE, 0), 0);
 207         run_test_threads(_metadata, self);
 208         EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_DISABLE, 0), 0);
 209
 210         EXPECT_EQ(ctx.signal_count, NUM_THREADS * ctx.iterate_on);
 211         EXPECT_EQ(ctx.tids_want_signal, 0);
 212         EXPECT_EQ(ctx.first_siginfo.si_addr, &ctx.iterate_on);
 213         EXPECT_EQ(ctx.first_siginfo.si_perf_type, PERF_TYPE_BREAKPOINT);
 214         EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on, 0));
 215 }
 216
 217 TEST_F(sigtrap_threads, signal_stress_with_disable)
 218 {
 219         const int target_count = NUM_THREADS * 3000;
 220         int i;
 221
 222         ctx.iterate_on = -1;
 223
 224         EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_ENABLE, 0), 0);
 225         pthread_barrier_wait(&self->barrier);
 226         while (__atomic_load_n(&ctx.signal_count, __ATOMIC_RELAXED) < target_count) {
 227                 EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_DISABLE, 0), 0);
 228                 EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_ENABLE, 0), 0);
 229         }
 230         ctx.iterate_on = 0;
 231         for (i = 0; i < NUM_THREADS; i++)
 232                 ASSERT_EQ(pthread_join(self->threads[i], NULL), 0);
 233         EXPECT_EQ(ioctl(self->fd, PERF_EVENT_IOC_DISABLE, 0), 0);
 234
 235         EXPECT_EQ(ctx.first_siginfo.si_addr, &ctx.iterate_on);
 236         EXPECT_EQ(ctx.first_siginfo.si_perf_type, PERF_TYPE_BREAKPOINT);
 237         EXPECT_EQ(ctx.first_siginfo.si_perf_data, TEST_SIG_DATA(&ctx.iterate_on, 0));
 238 }
 239
 240 TEST_HARNESS_MAIN