486 lines · c
1// SPDX-License-Identifier: GPL-2.02#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 830#define DSO_MMAP_RATIO 431 32static unsigned int iterations = 100;33static unsigned int nr_mmaps = 100;34static unsigned int nr_samples = 100; /* samples per mmap */35 36static u64 bench_sample_type;37static u16 bench_id_hdr_size;38 39struct bench_data {40 int pid;41 int input_pipe[2];42 int output_pipe[2];43 pthread_t th;44};45 46struct bench_dso {47 struct list_head list;48 char *name;49 int ino;50};51 52static int nr_dsos;53static struct bench_dso *dsos;54 55extern int cmd_inject(int argc, const char *argv[]);56 57static 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 69static const char *const bench_usage[] = {70 "perf bench internals inject-build-id <options>",71 NULL72};73 74/*75 * Helper for collect_dso that adds the given file as a dso to dso_list76 * if it contains a build-id. Stops after collecting 4 times more than77 * we need (for MMAP2 events).78 */79static 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 105static 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 119static 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 */132static u64 dso_map_addr(struct bench_dso *dso)133{134 return 0x400000ULL + dso->ino * 8192ULL;135}136 137static 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 155static 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 173static 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 219static 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 238static 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 248static 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 276static 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 348static 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 395static 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 450static 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 473int 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 486