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 <fcntl.h>
15#include <unistd.h>
16#include <errno.h>
17
18#include "trace-event.h"
19#include "debug.h"
20
21static int input_fd;
22
23static ssize_t trace_data_size;
24static bool repipe;
25
26static 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
52static 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 */
69static 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
81static 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
90static 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
99static 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);
139out:
140 return str;
141}
142
143static 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
166static 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
193static 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
244static 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");
264out:
265 free(buf);
266 return ret;
267}
268
269static 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");
288out:
289 free(buf);
290 return ret;
291}
292
293static 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
311static 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
342static 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
365 parse_saved_cmdline(pevent, buf, size);
366 ret = 0;
367out:
368 free(buf);
369 return ret;
370}
371
372ssize_t trace_report(int fd, struct trace_event *tevent, bool __repipe)
373{
374 char buf[BUFSIZ];
375 char test[] = { 23, 8, 68 };
376 char *version;
377 int show_version = 0;
378 int show_funcs = 0;
379 int show_printk = 0;
380 ssize_t size = -1;
381 int file_bigendian;
382 int host_bigendian;
383 int file_long_size;
384 int file_page_size;
385 struct tep_handle *pevent = NULL;
386 int err;
387
388 repipe = __repipe;
389 input_fd = fd;
390
391 if (do_read(buf, 3) < 0)
392 return -1;
393 if (memcmp(buf, test, 3) != 0) {
394 pr_debug("no trace data in the file");
395 return -1;
396 }
397
398 if (do_read(buf, 7) < 0)
399 return -1;
400 if (memcmp(buf, "tracing", 7) != 0) {
401 pr_debug("not a trace file (missing 'tracing' tag)");
402 return -1;
403 }
404
405 version = read_string();
406 if (version == NULL)
407 return -1;
408 if (show_version)
409 printf("version = %s\n", version);
410
411 if (do_read(buf, 1) < 0) {
412 free(version);
413 return -1;
414 }
415 file_bigendian = buf[0];
416 host_bigendian = bigendian();
417
418 if (trace_event__init(tevent)) {
419 pr_debug("trace_event__init failed");
420 goto out;
421 }
422
423 pevent = tevent->pevent;
424
425 tep_set_flag(pevent, TEP_NSEC_OUTPUT);
426 tep_set_file_bigendian(pevent, file_bigendian);
427 tep_set_local_bigendian(pevent, host_bigendian);
428
429 if (do_read(buf, 1) < 0)
430 goto out;
431 file_long_size = buf[0];
432
433 file_page_size = read4(pevent);
434 if (!file_page_size)
435 goto out;
436
437 tep_set_long_size(pevent, file_long_size);
438 tep_set_page_size(pevent, file_page_size);
439
440 err = read_header_files(pevent);
441 if (err)
442 goto out;
443 err = read_ftrace_files(pevent);
444 if (err)
445 goto out;
446 err = read_event_files(pevent);
447 if (err)
448 goto out;
449 err = read_proc_kallsyms(pevent);
450 if (err)
451 goto out;
452 err = read_ftrace_printk(pevent);
453 if (err)
454 goto out;
455 if (atof(version) >= 0.6) {
456 err = read_saved_cmdline(pevent);
457 if (err)
458 goto out;
459 }
460
461 size = trace_data_size;
462 repipe = false;
463
464 if (show_funcs) {
465 tep_print_funcs(pevent);
466 } else if (show_printk) {
467 tep_print_printk(pevent);
468 }
469
470 pevent = NULL;
471
472out:
473 if (pevent)
474 trace_event__cleanup(tevent);
475 free(version);
476 return size;
477}
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 <getopt.h>
26#include <stdarg.h>
27#include <sys/types.h>
28#include <sys/stat.h>
29#include <sys/wait.h>
30#include <sys/mman.h>
31#include <pthread.h>
32#include <fcntl.h>
33#include <unistd.h>
34#include <errno.h>
35
36#include "../perf.h"
37#include "util.h"
38#include "trace-event.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 char *buf;
166
167 size = read4(pevent);
168 if (!size)
169 return 0;
170
171 buf = malloc(size + 1);
172 if (buf == NULL)
173 return -1;
174
175 if (do_read(buf, size) < 0) {
176 free(buf);
177 return -1;
178 }
179 buf[size] = '\0';
180
181 parse_proc_kallsyms(pevent, buf, size);
182
183 free(buf);
184 return 0;
185}
186
187static int read_ftrace_printk(struct pevent *pevent)
188{
189 unsigned int size;
190 char *buf;
191
192 /* it can have 0 size */
193 size = read4(pevent);
194 if (!size)
195 return 0;
196
197 buf = malloc(size);
198 if (buf == NULL)
199 return -1;
200
201 if (do_read(buf, size) < 0) {
202 free(buf);
203 return -1;
204 }
205
206 parse_ftrace_printk(pevent, buf, size);
207
208 free(buf);
209 return 0;
210}
211
212static int read_header_files(struct pevent *pevent)
213{
214 unsigned long long size;
215 char *header_page;
216 char buf[BUFSIZ];
217 int ret = 0;
218
219 if (do_read(buf, 12) < 0)
220 return -1;
221
222 if (memcmp(buf, "header_page", 12) != 0) {
223 pr_debug("did not read header page");
224 return -1;
225 }
226
227 size = read8(pevent);
228
229 header_page = malloc(size);
230 if (header_page == NULL)
231 return -1;
232
233 if (do_read(header_page, size) < 0) {
234 pr_debug("did not read header page");
235 free(header_page);
236 return -1;
237 }
238
239 if (!pevent_parse_header_page(pevent, header_page, size,
240 pevent_get_long_size(pevent))) {
241 /*
242 * The commit field in the page is of type long,
243 * use that instead, since it represents the kernel.
244 */
245 pevent_set_long_size(pevent, pevent->header_page_size_size);
246 }
247 free(header_page);
248
249 if (do_read(buf, 13) < 0)
250 return -1;
251
252 if (memcmp(buf, "header_event", 13) != 0) {
253 pr_debug("did not read header event");
254 return -1;
255 }
256
257 size = read8(pevent);
258 skip(size);
259
260 return ret;
261}
262
263static int read_ftrace_file(struct pevent *pevent, unsigned long long size)
264{
265 char *buf;
266
267 buf = malloc(size);
268 if (buf == NULL)
269 return -1;
270
271 if (do_read(buf, size) < 0) {
272 free(buf);
273 return -1;
274 }
275
276 parse_ftrace_file(pevent, buf, size);
277 free(buf);
278 return 0;
279}
280
281static int read_event_file(struct pevent *pevent, char *sys,
282 unsigned long long size)
283{
284 char *buf;
285
286 buf = malloc(size);
287 if (buf == NULL)
288 return -1;
289
290 if (do_read(buf, size) < 0) {
291 free(buf);
292 return -1;
293 }
294
295 parse_event_file(pevent, buf, size, sys);
296 free(buf);
297 return 0;
298}
299
300static int read_ftrace_files(struct pevent *pevent)
301{
302 unsigned long long size;
303 int count;
304 int i;
305 int ret;
306
307 count = read4(pevent);
308
309 for (i = 0; i < count; i++) {
310 size = read8(pevent);
311 ret = read_ftrace_file(pevent, size);
312 if (ret)
313 return ret;
314 }
315 return 0;
316}
317
318static int read_event_files(struct pevent *pevent)
319{
320 unsigned long long size;
321 char *sys;
322 int systems;
323 int count;
324 int i,x;
325 int ret;
326
327 systems = read4(pevent);
328
329 for (i = 0; i < systems; i++) {
330 sys = read_string();
331 if (sys == NULL)
332 return -1;
333
334 count = read4(pevent);
335
336 for (x=0; x < count; x++) {
337 size = read8(pevent);
338 ret = read_event_file(pevent, sys, size);
339 if (ret)
340 return ret;
341 }
342 }
343 return 0;
344}
345
346ssize_t trace_report(int fd, struct trace_event *tevent, bool __repipe)
347{
348 char buf[BUFSIZ];
349 char test[] = { 23, 8, 68 };
350 char *version;
351 int show_version = 0;
352 int show_funcs = 0;
353 int show_printk = 0;
354 ssize_t size = -1;
355 int file_bigendian;
356 int host_bigendian;
357 int file_long_size;
358 int file_page_size;
359 struct pevent *pevent = NULL;
360 int err;
361
362 repipe = __repipe;
363 input_fd = fd;
364
365 if (do_read(buf, 3) < 0)
366 return -1;
367 if (memcmp(buf, test, 3) != 0) {
368 pr_debug("no trace data in the file");
369 return -1;
370 }
371
372 if (do_read(buf, 7) < 0)
373 return -1;
374 if (memcmp(buf, "tracing", 7) != 0) {
375 pr_debug("not a trace file (missing 'tracing' tag)");
376 return -1;
377 }
378
379 version = read_string();
380 if (version == NULL)
381 return -1;
382 if (show_version)
383 printf("version = %s\n", version);
384 free(version);
385
386 if (do_read(buf, 1) < 0)
387 return -1;
388 file_bigendian = buf[0];
389 host_bigendian = bigendian();
390
391 if (trace_event__init(tevent)) {
392 pr_debug("trace_event__init failed");
393 goto out;
394 }
395
396 pevent = tevent->pevent;
397
398 pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
399 pevent_set_file_bigendian(pevent, file_bigendian);
400 pevent_set_host_bigendian(pevent, host_bigendian);
401
402 if (do_read(buf, 1) < 0)
403 goto out;
404 file_long_size = buf[0];
405
406 file_page_size = read4(pevent);
407 if (!file_page_size)
408 goto out;
409
410 pevent_set_long_size(pevent, file_long_size);
411 pevent_set_page_size(pevent, file_page_size);
412
413 err = read_header_files(pevent);
414 if (err)
415 goto out;
416 err = read_ftrace_files(pevent);
417 if (err)
418 goto out;
419 err = read_event_files(pevent);
420 if (err)
421 goto out;
422 err = read_proc_kallsyms(pevent);
423 if (err)
424 goto out;
425 err = read_ftrace_printk(pevent);
426 if (err)
427 goto out;
428
429 size = trace_data_size;
430 repipe = false;
431
432 if (show_funcs) {
433 pevent_print_funcs(pevent);
434 } else if (show_printk) {
435 pevent_print_printk(pevent);
436 }
437
438 pevent = NULL;
439
440out:
441 if (pevent)
442 trace_event__cleanup(tevent);
443 return size;
444}