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 347 signal(SIGINT, sig_handler); 348 349 if (inject->build_ids || inject->sched_stat) { 350 inject->tool.mmap = perf_event__repipe_mmap; 351 inject->tool.mmap2 = perf_event__repipe_mmap2; 352 inject->tool.fork = perf_event__repipe_fork; 353 inject->tool.tracing_data = perf_event__repipe_tracing_data; 354 } 355 356 if (inject->build_ids) { 357 inject->tool.sample = perf_event__inject_buildid; 358 } else if (inject->sched_stat) { 359 struct perf_evsel *evsel; 360 361 inject->tool.ordered_events = true; 362 363 evlist__for_each(session->evlist, evsel) { 364 const char *name = perf_evsel__name(evsel); 365 366 if (!strcmp(name, "sched:sched_switch")) { 367 if (perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID")) 368 return -EINVAL; 369 370 evsel->handler = perf_inject__sched_switch; 371 } else if (!strcmp(name, "sched:sched_process_exit")) 372 evsel->handler = perf_inject__sched_process_exit; 373 else if (!strncmp(name, "sched:sched_stat_", 17)) 374 evsel->handler = perf_inject__sched_stat; 375 } 376 } 377 378 if (!file_out->is_pipe) 379 lseek(file_out->fd, session->header.data_offset, SEEK_SET); 380 381 ret = perf_session__process_events(session, &inject->tool); 382 383 if (!file_out->is_pipe) { 384 if (inject->build_ids) 385 perf_header__set_feat(&session->header, 386 HEADER_BUILD_ID); 387 session->header.data_size = inject->bytes_written; 388 perf_session__write_header(session, session->evlist, file_out->fd, true); 389 } 390 391 return ret; 392 } 393 394 int cmd_inject(int argc, const char **argv, const char *prefix __maybe_unused) 395 { 396 struct perf_inject inject = { 397 .tool = { 398 .sample = perf_event__repipe_sample, 399 .mmap = perf_event__repipe, 400 .mmap2 = perf_event__repipe, 401 .comm = perf_event__repipe, 402 .fork = perf_event__repipe, 403 .exit = perf_event__repipe, 404 .lost = perf_event__repipe, 405 .read = perf_event__repipe_sample, 406 .throttle = perf_event__repipe, 407 .unthrottle = perf_event__repipe, 408 .attr = perf_event__repipe_attr, 409 .tracing_data = perf_event__repipe_op2_synth, 410 .finished_round = perf_event__repipe_op2_synth, 411 .build_id = perf_event__repipe_op2_synth, 412 .id_index = 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 -1; 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 } 474