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/session.h" 12 #include "util/debug.h" 13 14 #include "util/parse-options.h" 15 16 static char const *input_name = "-"; 17 static bool inject_build_ids; 18 19 static int perf_event__repipe_synth(union perf_event *event, 20 struct perf_session *session __used) 21 { 22 uint32_t size; 23 void *buf = event; 24 25 size = event->header.size; 26 27 while (size) { 28 int ret = write(STDOUT_FILENO, buf, size); 29 if (ret < 0) 30 return -errno; 31 32 size -= ret; 33 buf += ret; 34 } 35 36 return 0; 37 } 38 39 static int perf_event__repipe(union perf_event *event, 40 struct perf_sample *sample __used, 41 struct perf_session *session) 42 { 43 return perf_event__repipe_synth(event, session); 44 } 45 46 static int perf_event__repipe_mmap(union perf_event *event, 47 struct perf_sample *sample, 48 struct perf_session *session) 49 { 50 int err; 51 52 err = perf_event__process_mmap(event, sample, session); 53 perf_event__repipe(event, sample, session); 54 55 return err; 56 } 57 58 static int perf_event__repipe_task(union perf_event *event, 59 struct perf_sample *sample, 60 struct perf_session *session) 61 { 62 int err; 63 64 err = perf_event__process_task(event, sample, session); 65 perf_event__repipe(event, sample, session); 66 67 return err; 68 } 69 70 static int perf_event__repipe_tracing_data(union perf_event *event, 71 struct perf_session *session) 72 { 73 int err; 74 75 perf_event__repipe_synth(event, session); 76 err = perf_event__process_tracing_data(event, session); 77 78 return err; 79 } 80 81 static int dso__read_build_id(struct dso *self) 82 { 83 if (self->has_build_id) 84 return 0; 85 86 if (filename__read_build_id(self->long_name, self->build_id, 87 sizeof(self->build_id)) > 0) { 88 self->has_build_id = true; 89 return 0; 90 } 91 92 return -1; 93 } 94 95 static int dso__inject_build_id(struct dso *self, struct perf_session *session) 96 { 97 u16 misc = PERF_RECORD_MISC_USER; 98 struct machine *machine; 99 int err; 100 101 if (dso__read_build_id(self) < 0) { 102 pr_debug("no build_id found for %s\n", self->long_name); 103 return -1; 104 } 105 106 machine = perf_session__find_host_machine(session); 107 if (machine == NULL) { 108 pr_err("Can't find machine for session\n"); 109 return -1; 110 } 111 112 if (self->kernel) 113 misc = PERF_RECORD_MISC_KERNEL; 114 115 err = perf_event__synthesize_build_id(self, misc, perf_event__repipe, 116 machine, session); 117 if (err) { 118 pr_err("Can't synthesize build_id event for %s\n", self->long_name); 119 return -1; 120 } 121 122 return 0; 123 } 124 125 static int perf_event__inject_buildid(union perf_event *event, 126 struct perf_sample *sample, 127 struct perf_session *session) 128 { 129 struct addr_location al; 130 struct thread *thread; 131 u8 cpumode; 132 133 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK; 134 135 thread = perf_session__findnew(session, event->ip.pid); 136 if (thread == NULL) { 137 pr_err("problem processing %d event, skipping it.\n", 138 event->header.type); 139 goto repipe; 140 } 141 142 thread__find_addr_map(thread, session, cpumode, MAP__FUNCTION, 143 event->ip.pid, event->ip.ip, &al); 144 145 if (al.map != NULL) { 146 if (!al.map->dso->hit) { 147 al.map->dso->hit = 1; 148 if (map__load(al.map, NULL) >= 0) { 149 dso__inject_build_id(al.map->dso, session); 150 /* 151 * If this fails, too bad, let the other side 152 * account this as unresolved. 153 */ 154 } else 155 pr_warning("no symbols found in %s, maybe " 156 "install a debug package?\n", 157 al.map->dso->long_name); 158 } 159 } 160 161 repipe: 162 perf_event__repipe(event, sample, session); 163 return 0; 164 } 165 166 struct perf_event_ops inject_ops = { 167 .sample = perf_event__repipe, 168 .mmap = perf_event__repipe, 169 .comm = perf_event__repipe, 170 .fork = perf_event__repipe, 171 .exit = perf_event__repipe, 172 .lost = perf_event__repipe, 173 .read = perf_event__repipe, 174 .throttle = perf_event__repipe, 175 .unthrottle = perf_event__repipe, 176 .attr = perf_event__repipe_synth, 177 .event_type = perf_event__repipe_synth, 178 .tracing_data = perf_event__repipe_synth, 179 .build_id = perf_event__repipe_synth, 180 }; 181 182 extern volatile int session_done; 183 184 static void sig_handler(int sig __attribute__((__unused__))) 185 { 186 session_done = 1; 187 } 188 189 static int __cmd_inject(void) 190 { 191 struct perf_session *session; 192 int ret = -EINVAL; 193 194 signal(SIGINT, sig_handler); 195 196 if (inject_build_ids) { 197 inject_ops.sample = perf_event__inject_buildid; 198 inject_ops.mmap = perf_event__repipe_mmap; 199 inject_ops.fork = perf_event__repipe_task; 200 inject_ops.tracing_data = perf_event__repipe_tracing_data; 201 } 202 203 session = perf_session__new(input_name, O_RDONLY, false, true, &inject_ops); 204 if (session == NULL) 205 return -ENOMEM; 206 207 ret = perf_session__process_events(session, &inject_ops); 208 209 perf_session__delete(session); 210 211 return ret; 212 } 213 214 static const char * const report_usage[] = { 215 "perf inject [<options>]", 216 NULL 217 }; 218 219 static const struct option options[] = { 220 OPT_BOOLEAN('b', "build-ids", &inject_build_ids, 221 "Inject build-ids into the output stream"), 222 OPT_INCR('v', "verbose", &verbose, 223 "be more verbose (show build ids, etc)"), 224 OPT_END() 225 }; 226 227 int cmd_inject(int argc, const char **argv, const char *prefix __used) 228 { 229 argc = parse_options(argc, argv, options, report_usage, 0); 230 231 /* 232 * Any (unrecognized) arguments left? 233 */ 234 if (argc) 235 usage_with_options(report_usage, options); 236 237 if (symbol__init() < 0) 238 return -1; 239 240 return __cmd_inject(); 241 } 242