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