xref: /linux/tools/perf/util/trace-event-read.c (revision 0be3ff0c) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>
4  */
5 #include <dirent.h>
6 #include <stdio.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <stdarg.h>
10 #include <sys/types.h>
11 #include <sys/stat.h>
12 #include <sys/wait.h>
13 #include <sys/mman.h>
14 #include <fcntl.h>
15 #include <unistd.h>
16 #include <errno.h>
17 
18 #include "trace-event.h"
19 #include "debug.h"
20 
21 static int input_fd;
22 
23 static ssize_t trace_data_size;
24 static bool repipe;
25 
26 static int __do_read(int fd, void *buf, int size)
27 {
28 	int rsize = size;
29 
30 	while (size) {
31 		int ret = read(fd, buf, size);
32 
33 		if (ret <= 0)
34 			return -1;
35 
36 		if (repipe) {
37 			int retw = write(STDOUT_FILENO, buf, ret);
38 
39 			if (retw <= 0 || retw != ret) {
40 				pr_debug("repiping input file");
41 				return -1;
42 			}
43 		}
44 
45 		size -= ret;
46 		buf += ret;
47 	}
48 
49 	return rsize;
50 }
51 
52 static int do_read(void *data, int size)
53 {
54 	int r;
55 
56 	r = __do_read(input_fd, data, size);
57 	if (r <= 0) {
58 		pr_debug("reading input file (size expected=%d received=%d)",
59 			 size, r);
60 		return -1;
61 	}
62 
63 	trace_data_size += r;
64 
65 	return r;
66 }
67 
68 /* If it fails, the next read will report it */
69 static void skip(int size)
70 {
71 	char buf[BUFSIZ];
72 	int r;
73 
74 	while (size) {
75 		r = size > BUFSIZ ? BUFSIZ : size;
76 		do_read(buf, r);
77 		size -= r;
78 	}
79 }
80 
81 static unsigned int read4(struct tep_handle *pevent)
82 {
83 	unsigned int data;
84 
85 	if (do_read(&data, 4) < 0)
86 		return 0;
87 	return tep_read_number(pevent, &data, 4);
88 }
89 
90 static unsigned long long read8(struct tep_handle *pevent)
91 {
92 	unsigned long long data;
93 
94 	if (do_read(&data, 8) < 0)
95 		return 0;
96 	return tep_read_number(pevent, &data, 8);
97 }
98 
99 static char *read_string(void)
100 {
101 	char buf[BUFSIZ];
102 	char *str = NULL;
103 	int size = 0;
104 	off_t r;
105 	char c;
106 
107 	for (;;) {
108 		r = read(input_fd, &c, 1);
109 		if (r < 0) {
110 			pr_debug("reading input file");
111 			goto out;
112 		}
113 
114 		if (!r) {
115 			pr_debug("no data");
116 			goto out;
117 		}
118 
119 		if (repipe) {
120 			int retw = write(STDOUT_FILENO, &c, 1);
121 
122 			if (retw <= 0 || retw != r) {
123 				pr_debug("repiping input file string");
124 				goto out;
125 			}
126 		}
127 
128 		buf[size++] = c;
129 
130 		if (!c)
131 			break;
132 	}
133 
134 	trace_data_size += size;
135 
136 	str = malloc(size);
137 	if (str)
138 		memcpy(str, buf, size);
139 out:
140 	return str;
141 }
142 
143 static int read_proc_kallsyms(struct tep_handle *pevent)
144 {
145 	unsigned int size;
146 
147 	size = read4(pevent);
148 	if (!size)
149 		return 0;
150 	/*
151 	 * Just skip it, now that we configure libtraceevent to use the
152 	 * tools/perf/ symbol resolver.
153 	 *
154 	 * We need to skip it so that we can continue parsing old perf.data
155 	 * files, that contains this /proc/kallsyms payload.
156 	 *
157 	 * Newer perf.data files will have just the 4-bytes zeros "kallsyms
158 	 * payload", so that older tools can continue reading it and interpret
159 	 * it as "no kallsyms payload is present".
160 	 */
161 	lseek(input_fd, size, SEEK_CUR);
162 	trace_data_size += size;
163 	return 0;
164 }
165 
166 static int read_ftrace_printk(struct tep_handle *pevent)
167 {
168 	unsigned int size;
169 	char *buf;
170 
171 	/* it can have 0 size */
172 	size = read4(pevent);
173 	if (!size)
174 		return 0;
175 
176 	buf = malloc(size + 1);
177 	if (buf == NULL)
178 		return -1;
179 
180 	if (do_read(buf, size) < 0) {
181 		free(buf);
182 		return -1;
183 	}
184 
185 	buf[size] = '\0';
186 
187 	parse_ftrace_printk(pevent, buf, size);
188 
189 	free(buf);
190 	return 0;
191 }
192 
193 static int read_header_files(struct tep_handle *pevent)
194 {
195 	unsigned long long size;
196 	char *header_page;
197 	char buf[BUFSIZ];
198 	int ret = 0;
199 
200 	if (do_read(buf, 12) < 0)
201 		return -1;
202 
203 	if (memcmp(buf, "header_page", 12) != 0) {
204 		pr_debug("did not read header page");
205 		return -1;
206 	}
207 
208 	size = read8(pevent);
209 
210 	header_page = malloc(size);
211 	if (header_page == NULL)
212 		return -1;
213 
214 	if (do_read(header_page, size) < 0) {
215 		pr_debug("did not read header page");
216 		free(header_page);
217 		return -1;
218 	}
219 
220 	if (!tep_parse_header_page(pevent, header_page, size,
221 				   tep_get_long_size(pevent))) {
222 		/*
223 		 * The commit field in the page is of type long,
224 		 * use that instead, since it represents the kernel.
225 		 */
226 		tep_set_long_size(pevent, tep_get_header_page_size(pevent));
227 	}
228 	free(header_page);
229 
230 	if (do_read(buf, 13) < 0)
231 		return -1;
232 
233 	if (memcmp(buf, "header_event", 13) != 0) {
234 		pr_debug("did not read header event");
235 		return -1;
236 	}
237 
238 	size = read8(pevent);
239 	skip(size);
240 
241 	return ret;
242 }
243 
244 static int read_ftrace_file(struct tep_handle *pevent, unsigned long long size)
245 {
246 	int ret;
247 	char *buf;
248 
249 	buf = malloc(size);
250 	if (buf == NULL) {
251 		pr_debug("memory allocation failure\n");
252 		return -1;
253 	}
254 
255 	ret = do_read(buf, size);
256 	if (ret < 0) {
257 		pr_debug("error reading ftrace file.\n");
258 		goto out;
259 	}
260 
261 	ret = parse_ftrace_file(pevent, buf, size);
262 	if (ret < 0)
263 		pr_debug("error parsing ftrace file.\n");
264 out:
265 	free(buf);
266 	return ret;
267 }
268 
269 static int read_event_file(struct tep_handle *pevent, char *sys,
270 			   unsigned long long size)
271 {
272 	int ret;
273 	char *buf;
274 
275 	buf = malloc(size);
276 	if (buf == NULL) {
277 		pr_debug("memory allocation failure\n");
278 		return -1;
279 	}
280 
281 	ret = do_read(buf, size);
282 	if (ret < 0)
283 		goto out;
284 
285 	ret = parse_event_file(pevent, buf, size, sys);
286 	if (ret < 0)
287 		pr_debug("error parsing event file.\n");
288 out:
289 	free(buf);
290 	return ret;
291 }
292 
293 static int read_ftrace_files(struct tep_handle *pevent)
294 {
295 	unsigned long long size;
296 	int count;
297 	int i;
298 	int ret;
299 
300 	count = read4(pevent);
301 
302 	for (i = 0; i < count; i++) {
303 		size = read8(pevent);
304 		ret = read_ftrace_file(pevent, size);
305 		if (ret)
306 			return ret;
307 	}
308 	return 0;
309 }
310 
311 static int read_event_files(struct tep_handle *pevent)
312 {
313 	unsigned long long size;
314 	char *sys;
315 	int systems;
316 	int count;
317 	int i,x;
318 	int ret;
319 
320 	systems = read4(pevent);
321 
322 	for (i = 0; i < systems; i++) {
323 		sys = read_string();
324 		if (sys == NULL)
325 			return -1;
326 
327 		count = read4(pevent);
328 
329 		for (x=0; x < count; x++) {
330 			size = read8(pevent);
331 			ret = read_event_file(pevent, sys, size);
332 			if (ret) {
333 				free(sys);
334 				return ret;
335 			}
336 		}
337 		free(sys);
338 	}
339 	return 0;
340 }
341 
342 static int read_saved_cmdline(struct tep_handle *pevent)
343 {
344 	unsigned long long size;
345 	char *buf;
346 	int ret;
347 
348 	/* it can have 0 size */
349 	size = read8(pevent);
350 	if (!size)
351 		return 0;
352 
353 	buf = malloc(size + 1);
354 	if (buf == NULL) {
355 		pr_debug("memory allocation failure\n");
356 		return -1;
357 	}
358 
359 	ret = do_read(buf, size);
360 	if (ret < 0) {
361 		pr_debug("error reading saved cmdlines\n");
362 		goto out;
363 	}
364 	buf[ret] = '\0';
365 
366 	parse_saved_cmdline(pevent, buf, size);
367 	ret = 0;
368 out:
369 	free(buf);
370 	return ret;
371 }
372 
373 ssize_t trace_report(int fd, struct trace_event *tevent, bool __repipe)
374 {
375 	char buf[BUFSIZ];
376 	char test[] = { 23, 8, 68 };
377 	char *version;
378 	int show_version = 0;
379 	int show_funcs = 0;
380 	int show_printk = 0;
381 	ssize_t size = -1;
382 	int file_bigendian;
383 	int host_bigendian;
384 	int file_long_size;
385 	int file_page_size;
386 	struct tep_handle *pevent = NULL;
387 	int err;
388 
389 	repipe = __repipe;
390 	input_fd = fd;
391 
392 	if (do_read(buf, 3) < 0)
393 		return -1;
394 	if (memcmp(buf, test, 3) != 0) {
395 		pr_debug("no trace data in the file");
396 		return -1;
397 	}
398 
399 	if (do_read(buf, 7) < 0)
400 		return -1;
401 	if (memcmp(buf, "tracing", 7) != 0) {
402 		pr_debug("not a trace file (missing 'tracing' tag)");
403 		return -1;
404 	}
405 
406 	version = read_string();
407 	if (version == NULL)
408 		return -1;
409 	if (show_version)
410 		printf("version = %s\n", version);
411 
412 	if (do_read(buf, 1) < 0) {
413 		free(version);
414 		return -1;
415 	}
416 	file_bigendian = buf[0];
417 	host_bigendian = bigendian();
418 
419 	if (trace_event__init(tevent)) {
420 		pr_debug("trace_event__init failed");
421 		goto out;
422 	}
423 
424 	pevent = tevent->pevent;
425 
426 	tep_set_flag(pevent, TEP_NSEC_OUTPUT);
427 	tep_set_file_bigendian(pevent, file_bigendian);
428 	tep_set_local_bigendian(pevent, host_bigendian);
429 
430 	if (do_read(buf, 1) < 0)
431 		goto out;
432 	file_long_size = buf[0];
433 
434 	file_page_size = read4(pevent);
435 	if (!file_page_size)
436 		goto out;
437 
438 	tep_set_long_size(pevent, file_long_size);
439 	tep_set_page_size(pevent, file_page_size);
440 
441 	err = read_header_files(pevent);
442 	if (err)
443 		goto out;
444 	err = read_ftrace_files(pevent);
445 	if (err)
446 		goto out;
447 	err = read_event_files(pevent);
448 	if (err)
449 		goto out;
450 	err = read_proc_kallsyms(pevent);
451 	if (err)
452 		goto out;
453 	err = read_ftrace_printk(pevent);
454 	if (err)
455 		goto out;
456 	if (atof(version) >= 0.6) {
457 		err = read_saved_cmdline(pevent);
458 		if (err)
459 			goto out;
460 	}
461 
462 	size = trace_data_size;
463 	repipe = false;
464 
465 	if (show_funcs) {
466 		tep_print_funcs(pevent);
467 	} else if (show_printk) {
468 		tep_print_printk(pevent);
469 	}
470 
471 	pevent = NULL;
472 
473 out:
474 	if (pevent)
475 		trace_event__cleanup(tevent);
476 	free(version);
477 	return size;
478 }
479