tools/perf/builtin-inject.c

   1 /*
   2  * builtin-inject.c
   3  *
   4  * Builtin inject command: Examine the live mode (stdin) event stream
   5  * and repipe it to stdout while optionally injecting additional
   6  * events into it.
   7  */
   8 #include "builtin.h"
   9
  10 #include "perf.h"
  11 #include "util/color.h"
  12 #include "util/evlist.h"
  13 #include "util/evsel.h"
  14 #include "util/session.h"
  15 #include "util/tool.h"
  16 #include "util/debug.h"
  17 #include "util/build-id.h"
  18 #include "util/data.h"
  19
  20 #include "util/parse-options.h"
  21
  22 #include <linux/list.h>
  23
  24 struct perf_inject {
  25         struct perf_tool        tool;
  26         struct perf_session     *session;
  27         bool                    build_ids;
  28         bool                    sched_stat;
  29         const char              *input_name;
  30         struct perf_data_file   output;
  31         u64                     bytes_written;
  32         struct list_head        samples;
  33 };
  34
  35 struct event_entry {
  36         struct list_head node;
  37         u32              tid;
  38         union perf_event event[0];
  39 };
  40
  41 static int perf_event__repipe_synth(struct perf_tool *tool,
  42                                     union perf_event *event)
  43 {
  44         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
  45         ssize_t size;
  46
  47         size = perf_data_file__write(&inject->output, event,
  48                                      event->header.size);
  49         if (size < 0)
  50                 return -errno;
  51
  52         inject->bytes_written += size;
  53         return 0;
  54 }
  55
  56 static int perf_event__repipe_op2_synth(struct perf_tool *tool,
  57                                         union perf_event *event,
  58                                         struct perf_session *session
  59                                         __maybe_unused)
  60 {
  61         return perf_event__repipe_synth(tool, event);
  62 }
  63
  64 static int perf_event__repipe_attr(struct perf_tool *tool,
  65                                    union perf_event *event,
  66                                    struct perf_evlist **pevlist)
  67 {
  68         struct perf_inject *inject = container_of(tool, struct perf_inject,
  69                                                   tool);
  70         int ret;
  71
  72         ret = perf_event__process_attr(tool, event, pevlist);
  73         if (ret)
  74                 return ret;
  75
  76         if (!inject->output.is_pipe)
  77                 return 0;
  78
  79         return perf_event__repipe_synth(tool, event);
  80 }
  81
  82 static int perf_event__repipe(struct perf_tool *tool,
  83                               union perf_event *event,
  84                               struct perf_sample *sample __maybe_unused,
  85                               struct machine *machine __maybe_unused)
  86 {
  87         return perf_event__repipe_synth(tool, event);
  88 }
  89
  90 typedef int (*inject_handler)(struct perf_tool *tool,
  91                               union perf_event *event,
  92                               struct perf_sample *sample,
  93                               struct perf_evsel *evsel,
  94                               struct machine *machine);
  95
  96 static int perf_event__repipe_sample(struct perf_tool *tool,
  97                                      union perf_event *event,
  98                                      struct perf_sample *sample,
  99                                      struct perf_evsel *evsel,
 100                                      struct machine *machine)
 101 {
 102         if (evsel->handler) {
 103                 inject_handler f = evsel->handler;
 104                 return f(tool, event, sample, evsel, machine);
 105         }
 106
 107         build_id__mark_dso_hit(tool, event, sample, evsel, machine);
 108
 109         return perf_event__repipe_synth(tool, event);
 110 }
 111
 112 static int perf_event__repipe_mmap(struct perf_tool *tool,
 113                                    union perf_event *event,
 114                                    struct perf_sample *sample,
 115                                    struct machine *machine)
 116 {
 117         int err;
 118
 119         err = perf_event__process_mmap(tool, event, sample, machine);
 120         perf_event__repipe(tool, event, sample, machine);
 121
 122         return err;
 123 }
 124
 125 static int perf_event__repipe_mmap2(struct perf_tool *tool,
 126                                    union perf_event *event,
 127                                    struct perf_sample *sample,
 128                                    struct machine *machine)
 129 {
 130         int err;
 131
 132         err = perf_event__process_mmap2(tool, event, sample, machine);
 133         perf_event__repipe(tool, event, sample, machine);
 134
 135         return err;
 136 }
 137
 138 static int perf_event__repipe_fork(struct perf_tool *tool,
 139                                    union perf_event *event,
 140                                    struct perf_sample *sample,
 141                                    struct machine *machine)
 142 {
 143         int err;
 144
 145         err = perf_event__process_fork(tool, event, sample, machine);
 146         perf_event__repipe(tool, event, sample, machine);
 147
 148         return err;
 149 }
 150
 151 static int perf_event__repipe_tracing_data(struct perf_tool *tool,
 152                                            union perf_event *event,
 153                                            struct perf_session *session)
 154 {
 155         int err;
 156
 157         perf_event__repipe_synth(tool, event);
 158         err = perf_event__process_tracing_data(tool, event, session);
 159
 160         return err;
 161 }
 162
 163 static int dso__read_build_id(struct dso *dso)
 164 {
 165         if (dso->has_build_id)
 166                 return 0;
 167
 168         if (filename__read_build_id(dso->long_name, dso->build_id,
 169                                     sizeof(dso->build_id)) > 0) {
 170                 dso->has_build_id = true;
 171                 return 0;
 172         }
 173
 174         return -1;
 175 }
 176
 177 static int dso__inject_build_id(struct dso *dso, struct perf_tool *tool,
 178                                 struct machine *machine)
 179 {
 180         u16 misc = PERF_RECORD_MISC_USER;
 181         int err;
 182
 183         if (dso__read_build_id(dso) < 0) {
 184                 pr_debug("no build_id found for %s\n", dso->long_name);
 185                 return -1;
 186         }
 187
 188         if (dso->kernel)
 189                 misc = PERF_RECORD_MISC_KERNEL;
 190
 191         err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe,
 192                                               machine);
 193         if (err) {
 194                 pr_err("Can't synthesize build_id event for %s\n", dso->long_name);
 195                 return -1;
 196         }
 197
 198         return 0;
 199 }
 200
 201 static int perf_event__inject_buildid(struct perf_tool *tool,
 202                                       union perf_event *event,
 203                                       struct perf_sample *sample,
 204                                       struct perf_evsel *evsel __maybe_unused,
 205                                       struct machine *machine)
 206 {
 207         struct addr_location al;
 208         struct thread *thread;
 209         u8 cpumode;
 210
 211         cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 212
 213         thread = machine__findnew_thread(machine, sample->pid, sample->tid);
 214         if (thread == NULL) {
 215                 pr_err("problem processing %d event, skipping it.\n",
 216                        event->header.type);
 217                 goto repipe;
 218         }
 219
 220         thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
 221                               sample->ip, &al);
 222
 223         if (al.map != NULL) {
 224                 if (!al.map->dso->hit) {
 225                         al.map->dso->hit = 1;
 226                         if (map__load(al.map, NULL) >= 0) {
 227                                 dso__inject_build_id(al.map->dso, tool, machine);
 228                                 /*
 229                                  * If this fails, too bad, let the other side
 230                                  * account this as unresolved.
 231                                  */
 232                         } else {
 233 #ifdef HAVE_LIBELF_SUPPORT
 234                                 pr_warning("no symbols found in %s, maybe "
 235                                            "install a debug package?\n",
 236                                            al.map->dso->long_name);
 237 #endif
 238                         }
 239                 }
 240         }
 241
 242 repipe:
 243         perf_event__repipe(tool, event, sample, machine);
 244         return 0;
 245 }
 246
 247 static int perf_inject__sched_process_exit(struct perf_tool *tool,
 248                                            union perf_event *event __maybe_unused,
 249                                            struct perf_sample *sample,
 250                                            struct perf_evsel *evsel __maybe_unused,
 251                                            struct machine *machine __maybe_unused)
 252 {
 253         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
 254         struct event_entry *ent;
 255
 256         list_for_each_entry(ent, &inject->samples, node) {
 257                 if (sample->tid == ent->tid) {
 258                         list_del_init(&ent->node);
 259                         free(ent);
 260                         break;
 261                 }
 262         }
 263
 264         return 0;
 265 }
 266
 267 static int perf_inject__sched_switch(struct perf_tool *tool,
 268                                      union perf_event *event,
 269                                      struct perf_sample *sample,
 270                                      struct perf_evsel *evsel,
 271                                      struct machine *machine)
 272 {
 273         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
 274         struct event_entry *ent;
 275
 276         perf_inject__sched_process_exit(tool, event, sample, evsel, machine);
 277
 278         ent = malloc(event->header.size + sizeof(struct event_entry));
 279         if (ent == NULL) {
 280                 color_fprintf(stderr, PERF_COLOR_RED,
 281                              "Not enough memory to process sched switch event!");
 282                 return -1;
 283         }
 284
 285         ent->tid = sample->tid;
 286         memcpy(&ent->event, event, event->header.size);
 287         list_add(&ent->node, &inject->samples);
 288         return 0;
 289 }
 290
 291 static int perf_inject__sched_stat(struct perf_tool *tool,
 292                                    union perf_event *event __maybe_unused,
 293                                    struct perf_sample *sample,
 294                                    struct perf_evsel *evsel,
 295                                    struct machine *machine)
 296 {
 297         struct event_entry *ent;
 298         union perf_event *event_sw;
 299         struct perf_sample sample_sw;
 300         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
 301         u32 pid = perf_evsel__intval(evsel, sample, "pid");
 302
 303         list_for_each_entry(ent, &inject->samples, node) {
 304                 if (pid == ent->tid)
 305                         goto found;
 306         }
 307
 308         return 0;
 309 found:
 310         event_sw = &ent->event[0];
 311         perf_evsel__parse_sample(evsel, event_sw, &sample_sw);
 312
 313         sample_sw.period = sample->period;
 314         sample_sw.time   = sample->time;
 315         perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
 316                                       evsel->attr.read_format, &sample_sw,
 317                                       false);
 318         build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
 319         return perf_event__repipe(tool, event_sw, &sample_sw, machine);
 320 }
 321
 322 static void sig_handler(int sig __maybe_unused)
 323 {
 324         session_done = 1;
 325 }
 326
 327 static int perf_evsel__check_stype(struct perf_evsel *evsel,
 328                                    u64 sample_type, const char *sample_msg)
 329 {
 330         struct perf_event_attr *attr = &evsel->attr;
 331         const char *name = perf_evsel__name(evsel);
 332
 333         if (!(attr->sample_type & sample_type)) {
 334                 pr_err("Samples for %s event do not have %s attribute set.",
 335                         name, sample_msg);
 336                 return -EINVAL;
 337         }
 338
 339         return 0;
 340 }
 341
 342 static int __cmd_inject(struct perf_inject *inject)
 343 {
 344         int ret = -EINVAL;
 345         struct perf_session *session = inject->session;
 346         struct perf_data_file *file_out = &inject->output;
 347
 348         signal(SIGINT, sig_handler);
 349
 350         if (inject->build_ids || inject->sched_stat) {
 351                 inject->tool.mmap         = perf_event__repipe_mmap;
 352                 inject->tool.mmap2        = perf_event__repipe_mmap2;
 353                 inject->tool.fork         = perf_event__repipe_fork;
 354                 inject->tool.tracing_data = perf_event__repipe_tracing_data;
 355         }
 356
 357         if (inject->build_ids) {
 358                 inject->tool.sample = perf_event__inject_buildid;
 359         } else if (inject->sched_stat) {
 360                 struct perf_evsel *evsel;
 361
 362                 inject->tool.ordered_events = true;
 363
 364                 evlist__for_each(session->evlist, evsel) {
 365                         const char *name = perf_evsel__name(evsel);
 366
 367                         if (!strcmp(name, "sched:sched_switch")) {
 368                                 if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID"))
 369                                         return -EINVAL;
 370
 371                                 evsel->handler = perf_inject__sched_switch;
 372                         } else if (!strcmp(name, "sched:sched_process_exit"))
 373                                 evsel->handler = perf_inject__sched_process_exit;
 374                         else if (!strncmp(name, "sched:sched_stat_", 17))
 375                                 evsel->handler = perf_inject__sched_stat;
 376                 }
 377         }
 378
 379         if (!file_out->is_pipe)
 380                 lseek(file_out->fd, session->header.data_offset, SEEK_SET);
 381
 382         ret = perf_session__process_events(session, &inject->tool);
 383
 384         if (!file_out->is_pipe) {
 385                 if (inject->build_ids)
 386                         perf_header__set_feat(&session->header,
 387                                               HEADER_BUILD_ID);
 388                 session->header.data_size = inject->bytes_written;
 389                 perf_session__write_header(session, session->evlist, file_out->fd, true);
 390         }
 391
 392         return ret;
 393 }
 394
 395 int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
 396 {
 397         struct perf_inject inject = {
 398                 .tool = {
 399                         .sample         = perf_event__repipe_sample,
 400                         .mmap           = perf_event__repipe,
 401                         .mmap2          = perf_event__repipe,
 402                         .comm           = perf_event__repipe,
 403                         .fork           = perf_event__repipe,
 404                         .exit           = perf_event__repipe,
 405                         .lost           = perf_event__repipe,
 406                         .read           = perf_event__repipe_sample,
 407                         .throttle       = perf_event__repipe,
 408                         .unthrottle     = perf_event__repipe,
 409                         .attr           = perf_event__repipe_attr,
 410                         .tracing_data   = perf_event__repipe_op2_synth,
 411                         .finished_round = perf_event__repipe_op2_synth,
 412                         .build_id       = perf_event__repipe_op2_synth,
 413                 },
 414                 .input_name  = "-",
 415                 .samples = LIST_HEAD_INIT(inject.samples),
 416                 .output = {
 417                         .path = "-",
 418                         .mode = PERF_DATA_MODE_WRITE,
 419                 },
 420         };
 421         struct perf_data_file file = {
 422                 .mode = PERF_DATA_MODE_READ,
 423         };
 424         int ret;
 425
 426         const struct option options[] = {
 427                 OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
 428                             "Inject build-ids into the output stream"),
 429                 OPT_STRING('i', "input", &inject.input_name, "file",
 430                            "input file name"),
 431                 OPT_STRING('o', "output", &inject.output.path, "file",
 432                            "output file name"),
 433                 OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
 434                             "Merge sched-stat and sched-switch for getting events "
 435                             "where and how long tasks slept"),
 436                 OPT_INCR('v', "verbose", &verbose,
 437                          "be more verbose (show build ids, etc)"),
 438                 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file",
 439                            "kallsyms pathname"),
 440                 OPT_END()
 441         };
 442         const char * const inject_usage[] = {
 443                 "perf inject [<options>]",
 444                 NULL
 445         };
 446
 447         argc = parse_options(argc, argv, options, inject_usage, 0);
 448
 449         /*
 450          * Any (unrecognized) arguments left?
 451          */
 452         if (argc)
 453                 usage_with_options(inject_usage, options);
 454
 455         if (perf_data_file__open(&inject.output)) {
 456                 perror("failed to create output file");
 457                 return -1;
 458         }
 459
 460         file.path = inject.input_name;
 461         inject.session = perf_session__new(&file, true, &inject.tool);
 462         if (inject.session == NULL)
 463                 return -ENOMEM;
 464
 465         if (symbol__init(&inject.session->header.env) < 0)
 466                 return -1;
 467
 468         ret = __cmd_inject(&inject);
 469
 470         perf_session__delete(inject.session);
 471
 472         return ret;
 473 }