Pileus Git - ~andy/linux/blob - 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         bool                    build_ids;
  27         bool                    sched_stat;
  28         const char              *input_name;
  29         struct perf_data_file   output;
  30         u64                     bytes_written;
  31         struct list_head        samples;
  32 };
  33
  34 struct event_entry {
  35         struct list_head node;
  36         u32              tid;
  37         union perf_event event[0];
  38 };
  39
  40 static int perf_event__repipe_synth(struct perf_tool *tool,
  41                                     union perf_event *event)
  42 {
  43         struct perf_inject *inject = container_of(tool, struct perf_inject, tool);
  44         ssize_t size;
  45
  46         size = perf_data_file__write(&inject->output, event,
  47                                      event->header.size);
  48         if (size < 0)
  49                 return -errno;
  50
  51         inject->bytes_written += size;
  52         return 0;
  53 }
  54
  55 static int perf_event__repipe_op2_synth(struct perf_tool *tool,
  56                                         union perf_event *event,
  57                                         struct perf_session *session
  58                                         __maybe_unused)
  59 {
  60         return perf_event__repipe_synth(tool, event);
  61 }
  62
  63 static int perf_event__repipe_attr(struct perf_tool *tool,
  64                                    union perf_event *event,
  65                                    struct perf_evlist **pevlist)
  66 {
  67         struct perf_inject *inject = container_of(tool, struct perf_inject,
  68                                                   tool);
  69         int ret;
  70
  71         ret = perf_event__process_attr(tool, event, pevlist);
  72         if (ret)
  73                 return ret;
  74
  75         if (&inject->output.is_pipe)
  76                 return 0;
  77
  78         return perf_event__repipe_synth(tool, event);
  79 }
  80
  81 static int perf_event__repipe(struct perf_tool *tool,
  82                               union perf_event *event,
  83                               struct perf_sample *sample __maybe_unused,
  84                               struct machine *machine __maybe_unused)
  85 {
  86         return perf_event__repipe_synth(tool, event);
  87 }
  88
  89 typedef int (*inject_handler)(struct perf_tool *tool,
  90                               union perf_event *event,
  91                               struct perf_sample *sample,
  92                               struct perf_evsel *evsel,
  93                               struct machine *machine);
  94
  95 static int perf_event__repipe_sample(struct perf_tool *tool,
  96                                      union perf_event *event,
  97                                      struct perf_sample *sample,
  98                                      struct perf_evsel *evsel,
  99                                      struct machine *machine)
 100 {
 101         if (evsel->handler) {
 102                 inject_handler f = evsel->handler;
 103                 return f(tool, event, sample, evsel, machine);
 104         }
 105
 106         build_id__mark_dso_hit(tool, event, sample, evsel, machine);
 107
 108         return perf_event__repipe_synth(tool, event);
 109 }
 110
 111 static int perf_event__repipe_mmap(struct perf_tool *tool,
 112                                    union perf_event *event,
 113                                    struct perf_sample *sample,
 114                                    struct machine *machine)
 115 {
 116         int err;
 117
 118         err = perf_event__process_mmap(tool, event, sample, machine);
 119         perf_event__repipe(tool, event, sample, machine);
 120
 121         return err;
 122 }
 123
 124 static int perf_event__repipe_mmap2(struct perf_tool *tool,
 125                                    union perf_event *event,
 126                                    struct perf_sample *sample,
 127                                    struct machine *machine)
 128 {
 129         int err;
 130
 131         err = perf_event__process_mmap2(tool, event, sample, machine);
 132         perf_event__repipe(tool, event, sample, machine);
 133
 134         return err;
 135 }
 136
 137 static int perf_event__repipe_fork(struct perf_tool *tool,
 138                                    union perf_event *event,
 139                                    struct perf_sample *sample,
 140                                    struct machine *machine)
 141 {
 142         int err;
 143
 144         err = perf_event__process_fork(tool, event, sample, machine);
 145         perf_event__repipe(tool, event, sample, machine);
 146
 147         return err;
 148 }
 149
 150 static int perf_event__repipe_tracing_data(struct perf_tool *tool,
 151                                            union perf_event *event,
 152                                            struct perf_session *session)
 153 {
 154         int err;
 155
 156         perf_event__repipe_synth(tool, event);
 157         err = perf_event__process_tracing_data(tool, event, session);
 158
 159         return err;
 160 }
 161
 162 static int dso__read_build_id(struct dso *dso)
 163 {
 164         if (dso->has_build_id)
 165                 return 0;
 166
 167         if (filename__read_build_id(dso->long_name, dso->build_id,
 168                                     sizeof(dso->build_id)) > 0) {
 169                 dso->has_build_id = true;
 170                 return 0;
 171         }
 172
 173         return -1;
 174 }
 175
 176 static int dso__inject_build_id(struct dso *dso, struct perf_tool *tool,
 177                                 struct machine *machine)
 178 {
 179         u16 misc = PERF_RECORD_MISC_USER;
 180         int err;
 181
 182         if (dso__read_build_id(dso) < 0) {
 183                 pr_debug("no build_id found for %s\n", dso->long_name);
 184                 return -1;
 185         }
 186
 187         if (dso->kernel)
 188                 misc = PERF_RECORD_MISC_KERNEL;
 189
 190         err = perf_event__synthesize_build_id(tool, dso, misc, perf_event__repipe,
 191                                               machine);
 192         if (err) {
 193                 pr_err("Can't synthesize build_id event for %s\n", dso->long_name);
 194                 return -1;
 195         }
 196
 197         return 0;
 198 }
 199
 200 static int perf_event__inject_buildid(struct perf_tool *tool,
 201                                       union perf_event *event,
 202                                       struct perf_sample *sample,
 203                                       struct perf_evsel *evsel __maybe_unused,
 204                                       struct machine *machine)
 205 {
 206         struct addr_location al;
 207         struct thread *thread;
 208         u8 cpumode;
 209
 210         cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 211
 212         thread = machine__findnew_thread(machine, sample->pid, sample->pid);
 213         if (thread == NULL) {
 214                 pr_err("problem processing %d event, skipping it.\n",
 215                        event->header.type);
 216                 goto repipe;
 217         }
 218
 219         thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
 220                               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.sample_regs_user,
 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         struct perf_session *session;
 345         int ret = -EINVAL;
 346         struct perf_data_file file = {
 347                 .path = inject->input_name,
 348                 .mode = PERF_DATA_MODE_READ,
 349         };
 350         struct perf_data_file *file_out = &inject->output;
 351
 352         signal(SIGINT, sig_handler);
 353
 354         if (inject->build_ids || inject->sched_stat) {
 355                 inject->tool.mmap         = perf_event__repipe_mmap;
 356                 inject->tool.mmap2        = perf_event__repipe_mmap2;
 357                 inject->tool.fork         = perf_event__repipe_fork;
 358                 inject->tool.tracing_data = perf_event__repipe_tracing_data;
 359         }
 360
 361         session = perf_session__new(&file, true, &inject->tool);
 362         if (session == NULL)
 363                 return -ENOMEM;
 364
 365         if (inject->build_ids) {
 366                 inject->tool.sample = perf_event__inject_buildid;
 367         } else if (inject->sched_stat) {
 368                 struct perf_evsel *evsel;
 369
 370                 inject->tool.ordered_samples = true;
 371
 372                 evlist__for_each(session->evlist, evsel) {
 373                         const char *name = perf_evsel__name(evsel);
 374
 375                         if (!strcmp(name, "sched:sched_switch")) {
 376                                 if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID"))
 377                                         return -EINVAL;
 378
 379                                 evsel->handler = perf_inject__sched_switch;
 380                         } else if (!strcmp(name, "sched:sched_process_exit"))
 381                                 evsel->handler = perf_inject__sched_process_exit;
 382                         else if (!strncmp(name, "sched:sched_stat_", 17))
 383                                 evsel->handler = perf_inject__sched_stat;
 384                 }
 385         }
 386
 387         if (!file_out->is_pipe)
 388                 lseek(file_out->fd, session->header.data_offset, SEEK_SET);
 389
 390         ret = perf_session__process_events(session, &inject->tool);
 391
 392         if (!file_out->is_pipe) {
 393                 session->header.data_size = inject->bytes_written;
 394                 perf_session__write_header(session, session->evlist, file_out->fd, true);
 395         }
 396
 397         perf_session__delete(session);
 398
 399         return ret;
 400 }
 401
 402 int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused)
 403 {
 404         struct perf_inject inject = {
 405                 .tool = {
 406                         .sample         = perf_event__repipe_sample,
 407                         .mmap           = perf_event__repipe,
 408                         .mmap2          = perf_event__repipe,
 409                         .comm           = perf_event__repipe,
 410                         .fork           = perf_event__repipe,
 411                         .exit           = perf_event__repipe,
 412                         .lost           = perf_event__repipe,
 413                         .read           = perf_event__repipe_sample,
 414                         .throttle       = perf_event__repipe,
 415                         .unthrottle     = perf_event__repipe,
 416                         .attr           = perf_event__repipe_attr,
 417                         .tracing_data   = perf_event__repipe_op2_synth,
 418                         .finished_round = perf_event__repipe_op2_synth,
 419                         .build_id       = perf_event__repipe_op2_synth,
 420                 },
 421                 .input_name  = "-",
 422                 .samples = LIST_HEAD_INIT(inject.samples),
 423                 .output = {
 424                         .path = "-",
 425                         .mode = PERF_DATA_MODE_WRITE,
 426                 },
 427         };
 428         const struct option options[] = {
 429                 OPT_BOOLEAN('b', "build-ids", &inject.build_ids,
 430                             "Inject build-ids into the output stream"),
 431                 OPT_STRING('i', "input", &inject.input_name, "file",
 432                            "input file name"),
 433                 OPT_STRING('o', "output", &inject.output.path, "file",
 434                            "output file name"),
 435                 OPT_BOOLEAN('s', "sched-stat", &inject.sched_stat,
 436                             "Merge sched-stat and sched-switch for getting events "
 437                             "where and how long tasks slept"),
 438                 OPT_INCR('v', "verbose", &verbose,
 439                          "be more verbose (show build ids, etc)"),
 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         if (symbol__init() < 0)
 461                 return -1;
 462
 463         return __cmd_inject(&inject);
 464 }