xref: /linux/tools/perf/builtin-trace.c (revision 08ec212c0f92cbf30e3ecc7349f18151714041d6)
1 #include "builtin.h"
2 #include "util/evlist.h"
3 #include "util/parse-options.h"
4 #include "util/thread_map.h"
5 #include "event-parse.h"
6 
7 #include <libaudit.h>
8 #include <stdlib.h>
9 
10 static struct syscall_fmt {
11 	const char *name;
12 	const char *alias;
13 	bool	   errmsg;
14 	bool	   timeout;
15 } syscall_fmts[] = {
16 	{ .name	    = "arch_prctl", .errmsg = true, .alias = "prctl", },
17 	{ .name	    = "fstat",	    .errmsg = true, .alias = "newfstat", },
18 	{ .name	    = "fstatat",    .errmsg = true, .alias = "newfstatat", },
19 	{ .name	    = "futex",	    .errmsg = true, },
20 	{ .name	    = "poll",	    .errmsg = true, .timeout = true, },
21 	{ .name	    = "ppoll",	    .errmsg = true, .timeout = true, },
22 	{ .name	    = "read",	    .errmsg = true, },
23 	{ .name	    = "recvfrom",   .errmsg = true, },
24 	{ .name	    = "select",	    .errmsg = true, .timeout = true, },
25 	{ .name	    = "stat",	    .errmsg = true, .alias = "newstat", },
26 };
27 
28 static int syscall_fmt__cmp(const void *name, const void *fmtp)
29 {
30 	const struct syscall_fmt *fmt = fmtp;
31 	return strcmp(name, fmt->name);
32 }
33 
34 static struct syscall_fmt *syscall_fmt__find(const char *name)
35 {
36 	const int nmemb = ARRAY_SIZE(syscall_fmts);
37 	return bsearch(name, syscall_fmts, nmemb, sizeof(struct syscall_fmt), syscall_fmt__cmp);
38 }
39 
40 struct syscall {
41 	struct event_format *tp_format;
42 	const char	    *name;
43 	struct syscall_fmt  *fmt;
44 };
45 
46 struct trace {
47 	int			audit_machine;
48 	struct {
49 		int		max;
50 		struct syscall  *table;
51 	} syscalls;
52 	struct perf_record_opts opts;
53 };
54 
55 static int trace__read_syscall_info(struct trace *trace, int id)
56 {
57 	char tp_name[128];
58 	struct syscall *sc;
59 
60 	if (id > trace->syscalls.max) {
61 		struct syscall *nsyscalls = realloc(trace->syscalls.table, (id + 1) * sizeof(*sc));
62 
63 		if (nsyscalls == NULL)
64 			return -1;
65 
66 		if (trace->syscalls.max != -1) {
67 			memset(nsyscalls + trace->syscalls.max + 1, 0,
68 			       (id - trace->syscalls.max) * sizeof(*sc));
69 		} else {
70 			memset(nsyscalls, 0, (id + 1) * sizeof(*sc));
71 		}
72 
73 		trace->syscalls.table = nsyscalls;
74 		trace->syscalls.max   = id;
75 	}
76 
77 	sc = trace->syscalls.table + id;
78 	sc->name = audit_syscall_to_name(id, trace->audit_machine);
79 	if (sc->name == NULL)
80 		return -1;
81 
82 	sc->fmt = syscall_fmt__find(sc->name);
83 
84 	snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->name);
85 	sc->tp_format = event_format__new("syscalls", tp_name);
86 
87 	if (sc->tp_format == NULL && sc->fmt && sc->fmt->alias) {
88 		snprintf(tp_name, sizeof(tp_name), "sys_enter_%s", sc->fmt->alias);
89 		sc->tp_format = event_format__new("syscalls", tp_name);
90 	}
91 
92 	return sc->tp_format != NULL ? 0 : -1;
93 }
94 
95 static size_t syscall__fprintf_args(struct syscall *sc, unsigned long *args, FILE *fp)
96 {
97 	int i = 0;
98 	size_t printed = 0;
99 
100 	if (sc->tp_format != NULL) {
101 		struct format_field *field;
102 
103 		for (field = sc->tp_format->format.fields->next; field; field = field->next) {
104 			printed += fprintf(fp, "%s%s: %ld", printed ? ", " : "",
105 					   field->name, args[i++]);
106 		}
107 	} else {
108 		while (i < 6) {
109 			printed += fprintf(fp, "%sarg%d: %ld", printed ? ", " : "", i, args[i]);
110 			++i;
111 		}
112 	}
113 
114 	return printed;
115 }
116 
117 typedef int (*tracepoint_handler)(struct trace *trace, struct perf_evsel *evsel,
118 				  struct perf_sample *sample);
119 
120 static struct syscall *trace__syscall_info(struct trace *trace,
121 					   struct perf_evsel *evsel,
122 					   struct perf_sample *sample)
123 {
124 	int id = perf_evsel__intval(evsel, sample, "id");
125 
126 	if (id < 0) {
127 		printf("Invalid syscall %d id, skipping...\n", id);
128 		return NULL;
129 	}
130 
131 	if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL) &&
132 	    trace__read_syscall_info(trace, id))
133 		goto out_cant_read;
134 
135 	if ((id > trace->syscalls.max || trace->syscalls.table[id].name == NULL))
136 		goto out_cant_read;
137 
138 	return &trace->syscalls.table[id];
139 
140 out_cant_read:
141 	printf("Problems reading syscall %d information\n", id);
142 	return NULL;
143 }
144 
145 static int trace__sys_enter(struct trace *trace, struct perf_evsel *evsel,
146 			    struct perf_sample *sample)
147 {
148 	void *args;
149 	struct syscall *sc = trace__syscall_info(trace, evsel, sample);
150 
151 	if (sc == NULL)
152 		return -1;
153 
154 	args = perf_evsel__rawptr(evsel, sample, "args");
155 	if (args == NULL) {
156 		printf("Problems reading syscall arguments\n");
157 		return -1;
158 	}
159 
160 	printf("%s(", sc->name);
161 	syscall__fprintf_args(sc, args, stdout);
162 
163 	return 0;
164 }
165 
166 static int trace__sys_exit(struct trace *trace, struct perf_evsel *evsel,
167 			   struct perf_sample *sample)
168 {
169 	int ret;
170 	struct syscall *sc = trace__syscall_info(trace, evsel, sample);
171 
172 	if (sc == NULL)
173 		return -1;
174 
175 	ret = perf_evsel__intval(evsel, sample, "ret");
176 
177 	if (ret < 0 && sc->fmt && sc->fmt->errmsg) {
178 		char bf[256];
179 		const char *emsg = strerror_r(-ret, bf, sizeof(bf)),
180 			   *e = audit_errno_to_name(-ret);
181 
182 		printf(") = -1 %s %s", e, emsg);
183 	} else if (ret == 0 && sc->fmt && sc->fmt->timeout)
184 		printf(") = 0 Timeout");
185 	else
186 		printf(") = %d", ret);
187 
188 	putchar('\n');
189 	return 0;
190 }
191 
192 static int trace__run(struct trace *trace)
193 {
194 	struct perf_evlist *evlist = perf_evlist__new(NULL, NULL);
195 	struct perf_evsel *evsel;
196 	int err = -1, i, nr_events = 0, before;
197 
198 	if (evlist == NULL) {
199 		printf("Not enough memory to run!\n");
200 		goto out;
201 	}
202 
203 	if (perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_enter", trace__sys_enter) ||
204 	    perf_evlist__add_newtp(evlist, "raw_syscalls", "sys_exit", trace__sys_exit)) {
205 		printf("Couldn't read the raw_syscalls tracepoints information!\n");
206 		goto out_delete_evlist;
207 	}
208 
209 	err = perf_evlist__create_maps(evlist, &trace->opts.target);
210 	if (err < 0) {
211 		printf("Problems parsing the target to trace, check your options!\n");
212 		goto out_delete_evlist;
213 	}
214 
215 	perf_evlist__config_attrs(evlist, &trace->opts);
216 
217 	err = perf_evlist__open(evlist);
218 	if (err < 0) {
219 		printf("Couldn't create the events: %s\n", strerror(errno));
220 		goto out_delete_evlist;
221 	}
222 
223 	err = perf_evlist__mmap(evlist, UINT_MAX, false);
224 	if (err < 0) {
225 		printf("Couldn't mmap the events: %s\n", strerror(errno));
226 		goto out_delete_evlist;
227 	}
228 
229 	perf_evlist__enable(evlist);
230 again:
231 	before = nr_events;
232 
233 	for (i = 0; i < evlist->nr_mmaps; i++) {
234 		union perf_event *event;
235 
236 		while ((event = perf_evlist__mmap_read(evlist, i)) != NULL) {
237 			const u32 type = event->header.type;
238 			tracepoint_handler handler;
239 			struct perf_sample sample;
240 
241 			++nr_events;
242 
243 			switch (type) {
244 			case PERF_RECORD_SAMPLE:
245 				break;
246 			case PERF_RECORD_LOST:
247 				printf("LOST %" PRIu64 " events!\n", event->lost.lost);
248 				continue;
249 			default:
250 				printf("Unexpected %s event, skipping...\n",
251 					perf_event__name(type));
252 				continue;
253 			}
254 
255 			err = perf_evlist__parse_sample(evlist, event, &sample);
256 			if (err) {
257 				printf("Can't parse sample, err = %d, skipping...\n", err);
258 				continue;
259 			}
260 
261 			evsel = perf_evlist__id2evsel(evlist, sample.id);
262 			if (evsel == NULL) {
263 				printf("Unknown tp ID %" PRIu64 ", skipping...\n", sample.id);
264 				continue;
265 			}
266 
267 			if (evlist->threads->map[0] == -1 || evlist->threads->nr > 1)
268 				printf("%d ", sample.tid);
269 
270 			handler = evsel->handler.func;
271 			handler(trace, evsel, &sample);
272 		}
273 	}
274 
275 	if (nr_events == before)
276 		poll(evlist->pollfd, evlist->nr_fds, -1);
277 
278 	goto again;
279 
280 out_delete_evlist:
281 	perf_evlist__delete(evlist);
282 out:
283 	return err;
284 }
285 
286 int cmd_trace(int argc, const char **argv, const char *prefix __maybe_unused)
287 {
288 	const char * const trace_usage[] = {
289 		"perf trace [<options>]",
290 		NULL
291 	};
292 	struct trace trace = {
293 		.audit_machine = audit_detect_machine(),
294 		.syscalls = {
295 			. max = -1,
296 		},
297 		.opts = {
298 			.target = {
299 				.uid	   = UINT_MAX,
300 				.uses_mmap = true,
301 			},
302 			.user_freq     = UINT_MAX,
303 			.user_interval = ULLONG_MAX,
304 			.no_delay      = true,
305 			.mmap_pages    = 1024,
306 		},
307 	};
308 	const struct option trace_options[] = {
309 	OPT_STRING('p', "pid", &trace.opts.target.pid, "pid",
310 		    "trace events on existing process id"),
311 	OPT_STRING(0, "tid", &trace.opts.target.tid, "tid",
312 		    "trace events on existing thread id"),
313 	OPT_BOOLEAN(0, "all-cpus", &trace.opts.target.system_wide,
314 		    "system-wide collection from all CPUs"),
315 	OPT_STRING(0, "cpu", &trace.opts.target.cpu_list, "cpu",
316 		    "list of cpus to monitor"),
317 	OPT_BOOLEAN(0, "no-inherit", &trace.opts.no_inherit,
318 		    "child tasks do not inherit counters"),
319 	OPT_UINTEGER(0, "mmap-pages", &trace.opts.mmap_pages,
320 		     "number of mmap data pages"),
321 	OPT_STRING(0, "uid", &trace.opts.target.uid_str, "user",
322 		   "user to profile"),
323 	OPT_END()
324 	};
325 	int err;
326 
327 	argc = parse_options(argc, argv, trace_options, trace_usage, 0);
328 	if (argc)
329 		usage_with_options(trace_usage, trace_options);
330 
331 	err = perf_target__parse_uid(&trace.opts.target);
332 	if (err) {
333 		char bf[BUFSIZ];
334 		perf_target__strerror(&trace.opts.target, err, bf, sizeof(bf));
335 		printf("%s", bf);
336 		return err;
337 	}
338 
339 	return trace__run(&trace);
340 }
341