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
40 static int input_fd;
41
42 static ssize_t trace_data_size;
43 static bool repipe;
44
__do_read(int fd,void * buf,int size)45 static 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
do_read(void * data,int size)71 static 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 */
skip(int size)88 static 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
read4(struct pevent * pevent)100 static 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
read8(struct pevent * pevent)109 static 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
read_string(void)118 static 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);
158 out:
159 return str;
160 }
161
read_proc_kallsyms(struct pevent * pevent)162 static 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
read_ftrace_printk(struct pevent * pevent)185 static 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 + 1);
196 if (buf == NULL)
197 return -1;
198
199 if (do_read(buf, size) < 0) {
200 free(buf);
201 return -1;
202 }
203
204 buf[size] = '\0';
205
206 parse_ftrace_printk(pevent, buf, size);
207
208 free(buf);
209 return 0;
210 }
211
read_header_files(struct pevent * pevent)212 static 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
read_ftrace_file(struct pevent * pevent,unsigned long long size)263 static int read_ftrace_file(struct pevent *pevent, unsigned long long size)
264 {
265 int ret;
266 char *buf;
267
268 buf = malloc(size);
269 if (buf == NULL) {
270 pr_debug("memory allocation failure\n");
271 return -1;
272 }
273
274 ret = do_read(buf, size);
275 if (ret < 0) {
276 pr_debug("error reading ftrace file.\n");
277 goto out;
278 }
279
280 ret = parse_ftrace_file(pevent, buf, size);
281 if (ret < 0)
282 pr_debug("error parsing ftrace file.\n");
283 out:
284 free(buf);
285 return ret;
286 }
287
read_event_file(struct pevent * pevent,char * sys,unsigned long long size)288 static int read_event_file(struct pevent *pevent, char *sys,
289 unsigned long long size)
290 {
291 int ret;
292 char *buf;
293
294 buf = malloc(size);
295 if (buf == NULL) {
296 pr_debug("memory allocation failure\n");
297 return -1;
298 }
299
300 ret = do_read(buf, size);
301 if (ret < 0) {
302 free(buf);
303 goto out;
304 }
305
306 ret = parse_event_file(pevent, buf, size, sys);
307 if (ret < 0)
308 pr_debug("error parsing event file.\n");
309 out:
310 free(buf);
311 return ret;
312 }
313
read_ftrace_files(struct pevent * pevent)314 static int read_ftrace_files(struct pevent *pevent)
315 {
316 unsigned long long size;
317 int count;
318 int i;
319 int ret;
320
321 count = read4(pevent);
322
323 for (i = 0; i < count; i++) {
324 size = read8(pevent);
325 ret = read_ftrace_file(pevent, size);
326 if (ret)
327 return ret;
328 }
329 return 0;
330 }
331
read_event_files(struct pevent * pevent)332 static int read_event_files(struct pevent *pevent)
333 {
334 unsigned long long size;
335 char *sys;
336 int systems;
337 int count;
338 int i,x;
339 int ret;
340
341 systems = read4(pevent);
342
343 for (i = 0; i < systems; i++) {
344 sys = read_string();
345 if (sys == NULL)
346 return -1;
347
348 count = read4(pevent);
349
350 for (x=0; x < count; x++) {
351 size = read8(pevent);
352 ret = read_event_file(pevent, sys, size);
353 if (ret) {
354 free(sys);
355 return ret;
356 }
357 }
358 free(sys);
359 }
360 return 0;
361 }
362
read_saved_cmdline(struct pevent * pevent)363 static int read_saved_cmdline(struct pevent *pevent)
364 {
365 unsigned long long size;
366 char *buf;
367 int ret;
368
369 /* it can have 0 size */
370 size = read8(pevent);
371 if (!size)
372 return 0;
373
374 buf = malloc(size + 1);
375 if (buf == NULL) {
376 pr_debug("memory allocation failure\n");
377 return -1;
378 }
379
380 ret = do_read(buf, size);
381 if (ret < 0) {
382 pr_debug("error reading saved cmdlines\n");
383 goto out;
384 }
385
386 parse_saved_cmdline(pevent, buf, size);
387 ret = 0;
388 out:
389 free(buf);
390 return ret;
391 }
392
trace_report(int fd,struct trace_event * tevent,bool __repipe)393 ssize_t trace_report(int fd, struct trace_event *tevent, bool __repipe)
394 {
395 char buf[BUFSIZ];
396 char test[] = { 23, 8, 68 };
397 char *version;
398 int show_version = 0;
399 int show_funcs = 0;
400 int show_printk = 0;
401 ssize_t size = -1;
402 int file_bigendian;
403 int host_bigendian;
404 int file_long_size;
405 int file_page_size;
406 struct pevent *pevent = NULL;
407 int err;
408
409 repipe = __repipe;
410 input_fd = fd;
411
412 if (do_read(buf, 3) < 0)
413 return -1;
414 if (memcmp(buf, test, 3) != 0) {
415 pr_debug("no trace data in the file");
416 return -1;
417 }
418
419 if (do_read(buf, 7) < 0)
420 return -1;
421 if (memcmp(buf, "tracing", 7) != 0) {
422 pr_debug("not a trace file (missing 'tracing' tag)");
423 return -1;
424 }
425
426 version = read_string();
427 if (version == NULL)
428 return -1;
429 if (show_version)
430 printf("version = %s\n", version);
431
432 if (do_read(buf, 1) < 0) {
433 free(version);
434 return -1;
435 }
436 file_bigendian = buf[0];
437 host_bigendian = bigendian();
438
439 if (trace_event__init(tevent)) {
440 pr_debug("trace_event__init failed");
441 goto out;
442 }
443
444 pevent = tevent->pevent;
445
446 pevent_set_flag(pevent, PEVENT_NSEC_OUTPUT);
447 pevent_set_file_bigendian(pevent, file_bigendian);
448 pevent_set_host_bigendian(pevent, host_bigendian);
449
450 if (do_read(buf, 1) < 0)
451 goto out;
452 file_long_size = buf[0];
453
454 file_page_size = read4(pevent);
455 if (!file_page_size)
456 goto out;
457
458 pevent_set_long_size(pevent, file_long_size);
459 pevent_set_page_size(pevent, file_page_size);
460
461 err = read_header_files(pevent);
462 if (err)
463 goto out;
464 err = read_ftrace_files(pevent);
465 if (err)
466 goto out;
467 err = read_event_files(pevent);
468 if (err)
469 goto out;
470 err = read_proc_kallsyms(pevent);
471 if (err)
472 goto out;
473 err = read_ftrace_printk(pevent);
474 if (err)
475 goto out;
476 if (atof(version) >= 0.6) {
477 err = read_saved_cmdline(pevent);
478 if (err)
479 goto out;
480 }
481
482 size = trace_data_size;
483 repipe = false;
484
485 if (show_funcs) {
486 pevent_print_funcs(pevent);
487 } else if (show_printk) {
488 pevent_print_printk(pevent);
489 }
490
491 pevent = NULL;
492
493 out:
494 if (pevent)
495 trace_event__cleanup(tevent);
496 free(version);
497 return size;
498 }
499