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, cpumode, MAP__FUNCTION, sample->ip, &al);
 221
 222         if (al.map != NULL) {
 223                 if (!al.map->dso->hit) {
 224                         al.map->dso->hit = 1;
 225                         if (map__load(al.map, NULL) >= 0) {
 226                                 dso__inject_build_id(al.map->dso, tool, machine);
 227                                 /*
 228                                  * If this fails, too bad, let the other side
 229                                  * account this as unresolved.
 230                                  */
 231                         } else {
 232 #ifdef HAVE_LIBELF_SUPPORT
 233                                 pr_warning("no symbols found in %s, maybe "
 234                                            "install a debug package?\n",
 235                                            al.map->dso->long_name);
 236 #endif
 237                         }
 238                 }
 239         }
 240
 241 repipe:
 242         perf_event__repipe(tool, event, sample, machine);
 243         return 0;
 244 }
 245
 246 static int perf_inject__sched_process_exit(struct perf_tool *tool,
 247                                            union perf_event *event __maybe_unused,
 248                                            struct perf_sample *sample,
 249                                            struct perf_evsel *evsel __maybe_unused,
 250                                            struct machine *machine __maybe_unused)
 251 {
 252         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
 253         struct event_entry *ent;
 254
 255         list_for_each_entry(ent, &inject->samples, node) {
 256                 if (sample->tid == ent->tid) {
 257                         list_del_init(&ent->node);
 258                         free(ent);
 259                         break;
 260                 }
 261         }
 262
 263         return 0;
 264 }
 265
 266 static int perf_inject__sched_switch(struct perf_tool *tool,
 267                                      union perf_event *event,
 268                                      struct perf_sample *sample,
 269                                      struct perf_evsel *evsel,
 270                                      struct machine *machine)
 271 {
 272         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
 273         struct event_entry *ent;
 274
 275         perf_inject__sched_process_exit(tool, event, sample, evsel, machine);
 276
 277         ent = malloc(event->header.size + sizeof(struct event_entry));
 278         if (ent == NULL) {
 279                 color_fprintf(stderr, PERF_COLOR_RED,
 280                              "Not enough memory to process sched switch event!");
 281                 return -1;
 282         }
 283
 284         ent->tid = sample->tid;
 285         memcpy(&ent->event, event, event->header.size);
 286         list_add(&ent->node, &inject->samples);
 287         return 0;
 288 }
 289
 290 static int perf_inject__sched_stat(struct perf_tool *tool,
 291                                    union perf_event *event __maybe_unused,
 292                                    struct perf_sample *sample,
 293                                    struct perf_evsel *evsel,
 294                                    struct machine *machine)
 295 {
 296         struct event_entry *ent;
 297         union perf_event *event_sw;
 298         struct perf_sample sample_sw;
 299         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
 300         u32 pid = perf_evsel__intval(evsel, sample, "pid");
 301
 302         list_for_each_entry(ent, &inject->samples, node) {
 303                 if (pid == ent->tid)
 304                         goto found;
 305         }
 306
 307         return 0;
 308 found:
 309         event_sw = &ent->event[0];
 310         perf_evsel__parse_sample(evsel, event_sw, &sample_sw);
 311
 312         sample_sw.period = sample->period;
 313         sample_sw.time   = sample->time;
 314         perf_event__synthesize_sample(event_sw, evsel->attr.sample_type,
 315                                       evsel->attr.read_format, &sample_sw,
 316                                       false);
 317         build_id__mark_dso_hit(tool, event_sw, &sample_sw, evsel, machine);
 318         return perf_event__repipe(tool, event_sw, &sample_sw, machine);
 319 }
 320
 321 static void sig_handler(int sig __maybe_unused)
 322 {
 323         session_done = 1;
 324 }
 325
 326 static int perf_evsel__check_stype(struct perf_evsel *evsel,
 327                                    u64 sample_type, const char *sample_msg)
 328 {
 329         struct perf_event_attr *attr = &evsel->attr;
 330         const char *name = perf_evsel__name(evsel);
 331
 332         if (!(attr->sample_type & sample_type)) {
 333                 pr_err("Samples for %s event do not have %s attribute set.",
 334                         name, sample_msg);
 335                 return -EINVAL;
 336         }
 337
 338         return 0;
 339 }
 340
 341 static int __cmd_inject(struct perf_inject *inject)
 342 {
 343         int ret = -EINVAL;
 344         struct perf_session *session = inject->session;
 345         struct perf_data_file *file_out = &inject->output;
 346         int fd = perf_data_file__fd(file_out);
 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(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, 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                         .id_index       = perf_event__repipe_op2_synth,
 414                 },
 415                 .input_name  = "-",
 416                 .samples = LIST_HEAD_INIT(inject.samples),
 417                 .output = {
 418                         .path = "-",
 419                         .mode = PERF_DATA_MODE_WRITE,
 420                 },
 421         };
 422         struct perf_data_file file = {
 423                 .mode = PERF_DATA_MODE_READ,
 424         };
 425         int ret;
 426
 427         const struct option options[] = {
 428                 OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
 429                             "Inject build-ids into the output stream"),
 430                 OPT_STRING('i', "input", &inject.input_name, "file",
 431                            "input file name"),
 432                 OPT_STRING('o', "output", &inject.output.path, "file",
 433                            "output file name"),
 434                 OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
 435                             "Merge sched-stat and sched-switch for getting events "
 436                             "where and how long tasks slept"),
 437                 OPT_INCR('v', "verbose", &verbose,
 438                          "be more verbose (show build ids, etc)"),
 439                 OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name, "file",
 440                            "kallsyms pathname"),
 441                 OPT_END()
 442         };
 443         const char * const inject_usage[] = {
 444                 "perf inject [<options>]",
 445                 NULL
 446         };
 447
 448         argc = parse_options(argc, argv, options, inject_usage, 0);
 449
 450         /*
 451          * Any (unrecognized) arguments left?
 452          */
 453         if (argc)
 454                 usage_with_options(inject_usage, options);
 455
 456         if (perf_data_file__open(&inject.output)) {
 457                 perror("failed to create output file");
 458                 return -1;
 459         }
 460
 461         file.path = inject.input_name;
 462         inject.session = perf_session__new(&file, true, &inject.tool);
 463         if (inject.session == NULL)
 464                 return -1;
 465
 466         if (symbol__init(&inject.session->header.env) < 0)
 467                 return -1;
 468
 469         ret = __cmd_inject(&inject);
 470
 471         perf_session__delete(inject.session);
 472
 473         return ret;
 474 }