tools/perf/bench/inject-buildid.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 #include <stdlib.h>
   3 #include <stddef.h>
   4 #include <ftw.h>
   5 #include <fcntl.h>
   6 #include <errno.h>
   7 #include <unistd.h>
   8 #include <pthread.h>
   9 #include <sys/mman.h>
  10 #include <sys/wait.h>
  11 #include <linux/kernel.h>
  12 #include <linux/time64.h>
  13 #include <linux/list.h>
  14 #include <linux/err.h>
  15 #include <linux/zalloc.h>
  16 #include <internal/lib.h>
  17 #include <subcmd/parse-options.h>
  18
  19 #include "bench.h"
  20 #include "util/data.h"
  21 #include "util/stat.h"
  22 #include "util/debug.h"
  23 #include "util/symbol.h"
  24 #include "util/session.h"
  25 #include "util/build-id.h"
  26 #include "util/sample.h"
  27 #include "util/synthetic-events.h"
  28
  29 #define MMAP_DEV_MAJOR  8
  30 #define DSO_MMAP_RATIO  4
  31
  32 static unsigned int iterations = 100;
  33 static unsigned int nr_mmaps   = 100;
  34 static unsigned int nr_samples = 100;  /* samples per mmap */
  35
  36 static u64 bench_sample_type;
  37 static u16 bench_id_hdr_size;
  38
  39 struct bench_data {
  40         int                     pid;
  41         int                     input_pipe[2];
  42         int                     output_pipe[2];
  43         pthread_t               th;
  44 };
  45
  46 struct bench_dso {
  47         struct list_head        list;
  48         char                    *name;
  49         int                     ino;
  50 };
  51
  52 static int nr_dsos;
  53 static struct bench_dso *dsos;
  54
  55 extern int cmd_inject(int argc, const char *argv[]);
  56
  57 static const struct option options[] = {
  58         OPT_UINTEGER('i', "iterations", &iterations,
  59                      "Number of iterations used to compute average (default: 100)"),
  60         OPT_UINTEGER('m', "nr-mmaps", &nr_mmaps,
  61                      "Number of mmap events for each iteration (default: 100)"),
  62         OPT_UINTEGER('n', "nr-samples", &nr_samples,
  63                      "Number of sample events per mmap event (default: 100)"),
  64         OPT_INCR('v', "verbose", &verbose,
  65                  "be more verbose (show iteration count, DSO name, etc)"),
  66         OPT_END()
  67 };
  68
  69 static const char *const bench_usage[] = {
  70         "perf bench internals inject-build-id <options>",
  71         NULL
  72 };
  73
  74 /*
  75  * Helper for collect_dso that adds the given file as a dso to dso_list
  76  * if it contains a build-id.  Stops after collecting 4 times more than
  77  * we need (for MMAP2 events).
  78  */
  79 static int add_dso(const char *fpath, const struct stat *sb __maybe_unused,
  80                    int typeflag, struct FTW *ftwbuf __maybe_unused)
  81 {
  82         struct bench_dso *dso = &dsos[nr_dsos];
  83         struct build_id bid;
  84
  85         if (typeflag == FTW_D || typeflag == FTW_SL)
  86                 return 0;
  87
  88         if (filename__read_build_id(fpath, &bid) < 0)
  89                 return 0;
  90
  91         dso->name = realpath(fpath, NULL);
  92         if (dso->name == NULL)
  93                 return -1;
  94
  95         dso->ino = nr_dsos++;
  96         pr_debug2("  Adding DSO: %s\n", fpath);
  97
  98         /* stop if we collected enough DSOs */
  99         if ((unsigned int)nr_dsos == DSO_MMAP_RATIO * nr_mmaps)
 100                 return 1;
 101
 102         return 0;
 103 }
 104
 105 static void collect_dso(void)
 106 {
 107         dsos = calloc(nr_mmaps * DSO_MMAP_RATIO, sizeof(*dsos));
 108         if (dsos == NULL) {
 109                 printf("  Memory allocation failed\n");
 110                 exit(1);
 111         }
 112
 113         if (nftw("/usr/lib/", add_dso, 10, FTW_PHYS) < 0)
 114                 return;
 115
 116         pr_debug("  Collected %d DSOs\n", nr_dsos);
 117 }
 118
 119 static void release_dso(void)
 120 {
 121         int i;
 122
 123         for (i = 0; i < nr_dsos; i++) {
 124                 struct bench_dso *dso = &dsos[i];
 125
 126                 zfree(&dso->name);
 127         }
 128         free(dsos);
 129 }
 130
 131 /* Fake address used by mmap and sample events */
 132 static u64 dso_map_addr(struct bench_dso *dso)
 133 {
 134         return 0x400000ULL + dso->ino * 8192ULL;
 135 }
 136
 137 static ssize_t synthesize_attr(struct bench_data *data)
 138 {
 139         union perf_event event;
 140
 141         memset(&event, 0, sizeof(event.attr) + sizeof(u64));
 142
 143         event.header.type = PERF_RECORD_HEADER_ATTR;
 144         event.header.size = sizeof(event.attr) + sizeof(u64);
 145
 146         event.attr.attr.type = PERF_TYPE_SOFTWARE;
 147         event.attr.attr.config = PERF_COUNT_SW_TASK_CLOCK;
 148         event.attr.attr.exclude_kernel = 1;
 149         event.attr.attr.sample_id_all = 1;
 150         event.attr.attr.sample_type = bench_sample_type;
 151
 152         return writen(data->input_pipe[1], &event, event.header.size);
 153 }
 154
 155 static ssize_t synthesize_fork(struct bench_data *data)
 156 {
 157         union perf_event event;
 158
 159         memset(&event, 0, sizeof(event.fork) + bench_id_hdr_size);
 160
 161         event.header.type = PERF_RECORD_FORK;
 162         event.header.misc = PERF_RECORD_MISC_FORK_EXEC;
 163         event.header.size = sizeof(event.fork) + bench_id_hdr_size;
 164
 165         event.fork.ppid = 1;
 166         event.fork.ptid = 1;
 167         event.fork.pid = data->pid;
 168         event.fork.tid = data->pid;
 169
 170         return writen(data->input_pipe[1], &event, event.header.size);
 171 }
 172
 173 static ssize_t synthesize_mmap(struct bench_data *data, struct bench_dso *dso, u64 timestamp)
 174 {
 175         union perf_event event;
 176         size_t len = offsetof(struct perf_record_mmap2, filename);
 177         u64 *id_hdr_ptr = (void *)&event;
 178         int ts_idx;
 179
 180         len += roundup(strlen(dso->name) + 1, 8) + bench_id_hdr_size;
 181
 182         memset(&event, 0, min(len, sizeof(event.mmap2)));
 183
 184         event.header.type = PERF_RECORD_MMAP2;
 185         event.header.misc = PERF_RECORD_MISC_USER;
 186         event.header.size = len;
 187
 188         event.mmap2.pid = data->pid;
 189         event.mmap2.tid = data->pid;
 190         event.mmap2.maj = MMAP_DEV_MAJOR;
 191         event.mmap2.ino = dso->ino;
 192
 193         strcpy(event.mmap2.filename, dso->name);
 194
 195         event.mmap2.start = dso_map_addr(dso);
 196         event.mmap2.len = 4096;
 197         event.mmap2.prot = PROT_EXEC;
 198
 199         if (len > sizeof(event.mmap2)) {
 200                 /* write mmap2 event first */
 201                 if (writen(data->input_pipe[1], &event, len - bench_id_hdr_size) < 0)
 202                         return -1;
 203                 /* zero-fill sample id header */
 204                 memset(id_hdr_ptr, 0, bench_id_hdr_size);
 205                 /* put timestamp in the right position */
 206                 ts_idx = (bench_id_hdr_size / sizeof(u64)) - 2;
 207                 id_hdr_ptr[ts_idx] = timestamp;
 208                 if (writen(data->input_pipe[1], id_hdr_ptr, bench_id_hdr_size) < 0)
 209                         return -1;
 210
 211                 return len;
 212         }
 213
 214         ts_idx = (len / sizeof(u64)) - 2;
 215         id_hdr_ptr[ts_idx] = timestamp;
 216         return writen(data->input_pipe[1], &event, len);
 217 }
 218
 219 static ssize_t synthesize_sample(struct bench_data *data, struct bench_dso *dso, u64 timestamp)
 220 {
 221         union perf_event event;
 222         struct perf_sample sample = {
 223                 .tid = data->pid,
 224                 .pid = data->pid,
 225                 .ip = dso_map_addr(dso),
 226                 .time = timestamp,
 227         };
 228
 229         event.header.type = PERF_RECORD_SAMPLE;
 230         event.header.misc = PERF_RECORD_MISC_USER;
 231         event.header.size = perf_event__sample_event_size(&sample, bench_sample_type, 0);
 232
 233         perf_event__synthesize_sample(&event, bench_sample_type, 0, &sample);
 234
 235         return writen(data->input_pipe[1], &event, event.header.size);
 236 }
 237
 238 static ssize_t synthesize_flush(struct bench_data *data)
 239 {
 240         struct perf_event_header header = {
 241                 .size = sizeof(header),
 242                 .type = PERF_RECORD_FINISHED_ROUND,
 243         };
 244
 245         return writen(data->input_pipe[1], &header, header.size);
 246 }
 247
 248 static void *data_reader(void *arg)
 249 {
 250         struct bench_data *data = arg;
 251         char buf[8192];
 252         int flag;
 253         int n;
 254
 255         flag = fcntl(data->output_pipe[0], F_GETFL);
 256         fcntl(data->output_pipe[0], F_SETFL, flag | O_NONBLOCK);
 257
 258         /* read out data from child */
 259         while (true) {
 260                 n = read(data->output_pipe[0], buf, sizeof(buf));
 261                 if (n > 0)
 262                         continue;
 263                 if (n == 0)
 264                         break;
 265
 266                 if (errno != EINTR && errno != EAGAIN)
 267                         break;
 268
 269                 usleep(100);
 270         }
 271
 272         close(data->output_pipe[0]);
 273         return NULL;
 274 }
 275
 276 static int setup_injection(struct bench_data *data, bool build_id_all)
 277 {
 278         int ready_pipe[2];
 279         int dev_null_fd;
 280         char buf;
 281
 282         if (pipe(ready_pipe) < 0)
 283                 return -1;
 284
 285         if (pipe(data->input_pipe) < 0)
 286                 return -1;
 287
 288         if (pipe(data->output_pipe) < 0)
 289                 return -1;
 290
 291         data->pid = fork();
 292         if (data->pid < 0)
 293                 return -1;
 294
 295         if (data->pid == 0) {
 296                 const char **inject_argv;
 297                 int inject_argc = 2;
 298
 299                 close(data->input_pipe[1]);
 300                 close(data->output_pipe[0]);
 301                 close(ready_pipe[0]);
 302
 303                 dup2(data->input_pipe[0], STDIN_FILENO);
 304                 close(data->input_pipe[0]);
 305                 dup2(data->output_pipe[1], STDOUT_FILENO);
 306                 close(data->output_pipe[1]);
 307
 308                 dev_null_fd = open("/dev/null", O_WRONLY);
 309                 if (dev_null_fd < 0)
 310                         exit(1);
 311
 312                 dup2(dev_null_fd, STDERR_FILENO);
 313
 314                 if (build_id_all)
 315                         inject_argc++;
 316
 317                 inject_argv = calloc(inject_argc + 1, sizeof(*inject_argv));
 318                 if (inject_argv == NULL)
 319                         exit(1);
 320
 321                 inject_argv[0] = strdup("inject");
 322                 inject_argv[1] = strdup("-b");
 323                 if (build_id_all)
 324                         inject_argv[2] = strdup("--buildid-all");
 325
 326                 /* signal that we're ready to go */
 327                 close(ready_pipe[1]);
 328
 329                 cmd_inject(inject_argc, inject_argv);
 330
 331                 exit(0);
 332         }
 333
 334         pthread_create(&data->th, NULL, data_reader, data);
 335
 336         close(ready_pipe[1]);
 337         close(data->input_pipe[0]);
 338         close(data->output_pipe[1]);
 339
 340         /* wait for child ready */
 341         if (read(ready_pipe[0], &buf, 1) < 0)
 342                 return -1;
 343         close(ready_pipe[0]);
 344
 345         return 0;
 346 }
 347
 348 static int inject_build_id(struct bench_data *data, u64 *max_rss)
 349 {
 350         int status;
 351         unsigned int i, k;
 352         struct rusage rusage;
 353
 354         /* this makes the child to run */
 355         if (perf_header__write_pipe(data->input_pipe[1]) < 0)
 356                 return -1;
 357
 358         if (synthesize_attr(data) < 0)
 359                 return -1;
 360
 361         if (synthesize_fork(data) < 0)
 362                 return -1;
 363
 364         for (i = 0; i < nr_mmaps; i++) {
 365                 int idx = rand() % nr_dsos;
 366                 struct bench_dso *dso = &dsos[idx];
 367                 u64 timestamp = rand() % 1000000;
 368
 369                 pr_debug2("   [%d] injecting: %s\n", i+1, dso->name);
 370                 if (synthesize_mmap(data, dso, timestamp) < 0)
 371                         return -1;
 372
 373                 for (k = 0; k < nr_samples; k++) {
 374                         if (synthesize_sample(data, dso, timestamp + k * 1000) < 0)
 375                                 return -1;
 376                 }
 377
 378                 if ((i + 1) % 10 == 0) {
 379                         if (synthesize_flush(data) < 0)
 380                                 return -1;
 381                 }
 382         }
 383
 384         /* this makes the child to finish */
 385         close(data->input_pipe[1]);
 386
 387         wait4(data->pid, &status, 0, &rusage);
 388         *max_rss = rusage.ru_maxrss;
 389
 390         pr_debug("   Child %d exited with %d\n", data->pid, status);
 391
 392         return 0;
 393 }
 394
 395 static void do_inject_loop(struct bench_data *data, bool build_id_all)
 396 {
 397         unsigned int i;
 398         struct stats time_stats, mem_stats;
 399         double time_average, time_stddev;
 400         double mem_average, mem_stddev;
 401
 402         init_stats(&time_stats);
 403         init_stats(&mem_stats);
 404
 405         pr_debug("  Build-id%s injection benchmark\n", build_id_all ? "-all" : "");
 406
 407         for (i = 0; i < iterations; i++) {
 408                 struct timeval start, end, diff;
 409                 u64 runtime_us, max_rss;
 410
 411                 pr_debug("  Iteration #%d\n", i+1);
 412
 413                 if (setup_injection(data, build_id_all) < 0) {
 414                         printf("  Build-id injection setup failed\n");
 415                         break;
 416                 }
 417
 418                 gettimeofday(&start, NULL);
 419                 if (inject_build_id(data, &max_rss) < 0) {
 420                         printf("  Build-id injection failed\n");
 421                         break;
 422                 }
 423
 424                 gettimeofday(&end, NULL);
 425                 timersub(&end, &start, &diff);
 426                 runtime_us = diff.tv_sec * USEC_PER_SEC + diff.tv_usec;
 427                 update_stats(&time_stats, runtime_us);
 428                 update_stats(&mem_stats, max_rss);
 429
 430                 pthread_join(data->th, NULL);
 431         }
 432
 433         time_average = avg_stats(&time_stats) / USEC_PER_MSEC;
 434         time_stddev = stddev_stats(&time_stats) / USEC_PER_MSEC;
 435         printf("  Average build-id%s injection took: %.3f msec (+- %.3f msec)\n",
 436                build_id_all ? "-all" : "", time_average, time_stddev);
 437
 438         /* each iteration, it processes MMAP2 + BUILD_ID + nr_samples * SAMPLE */
 439         time_average = avg_stats(&time_stats) / (nr_mmaps * (nr_samples + 2));
 440         time_stddev = stddev_stats(&time_stats) / (nr_mmaps * (nr_samples + 2));
 441         printf("  Average time per event: %.3f usec (+- %.3f usec)\n",
 442                 time_average, time_stddev);
 443
 444         mem_average = avg_stats(&mem_stats);
 445         mem_stddev = stddev_stats(&mem_stats);
 446         printf("  Average memory usage: %.0f KB (+- %.0f KB)\n",
 447                 mem_average, mem_stddev);
 448 }
 449
 450 static int do_inject_loops(struct bench_data *data)
 451 {
 452
 453         srand(time(NULL));
 454         symbol__init(NULL);
 455
 456         bench_sample_type  = PERF_SAMPLE_IDENTIFIER | PERF_SAMPLE_IP;
 457         bench_sample_type |= PERF_SAMPLE_TID | PERF_SAMPLE_TIME;
 458         bench_id_hdr_size  = 32;
 459
 460         collect_dso();
 461         if (nr_dsos == 0) {
 462                 printf("  Cannot collect DSOs for injection\n");
 463                 return -1;
 464         }
 465
 466         do_inject_loop(data, false);
 467         do_inject_loop(data, true);
 468
 469         release_dso();
 470         return 0;
 471 }
 472
 473 int bench_inject_build_id(int argc, const char **argv)
 474 {
 475         struct bench_data data;
 476
 477         argc = parse_options(argc, argv, options, bench_usage, 0);
 478         if (argc) {
 479                 usage_with_options(bench_usage, options);
 480                 exit(EXIT_FAILURE);
 481         }
 482
 483         return do_inject_loops(&data);
 484 }
 485