perf tools: Get rid of die() calls in trace-data-read.c
[linux-3.10.git] / tools / perf / util / trace-event-read.c
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
40 static int input_fd;
41
42 int file_bigendian;
43 int host_bigendian;
44 static int long_size;
45
46 static ssize_t calc_data_size;
47 static bool repipe;
48
49 static int __do_read(int fd, void *buf, int size)
50 {
51         int rsize = size;
52
53         while (size) {
54                 int ret = read(fd, buf, size);
55
56                 if (ret <= 0)
57                         return -1;
58
59                 if (repipe) {
60                         int retw = write(STDOUT_FILENO, buf, ret);
61
62                         if (retw <= 0 || retw != ret) {
63                                 pr_debug("repiping input file");
64                                 return -1;
65                         }
66                 }
67
68                 size -= ret;
69                 buf += ret;
70         }
71
72         return rsize;
73 }
74
75 static int do_read(void *data, int size)
76 {
77         int r;
78
79         r = __do_read(input_fd, data, size);
80         if (r <= 0) {
81                 pr_debug("reading input file (size expected=%d received=%d)",
82                          size, r);
83                 return -1;
84         }
85
86         if (calc_data_size)
87                 calc_data_size += r;
88
89         return r;
90 }
91
92 /* If it fails, the next read will report it */
93 static void skip(int size)
94 {
95         char buf[BUFSIZ];
96         int r;
97
98         while (size) {
99                 r = size > BUFSIZ ? BUFSIZ : size;
100                 do_read(buf, r);
101                 size -= r;
102         };
103 }
104
105 static unsigned int read4(struct pevent *pevent)
106 {
107         unsigned int data;
108
109         if (do_read(&data, 4) < 0)
110                 return 0;
111         return __data2host4(pevent, data);
112 }
113
114 static unsigned long long read8(struct pevent *pevent)
115 {
116         unsigned long long data;
117
118         if (do_read(&data, 8) < 0)
119                 return 0;
120         return __data2host8(pevent, data);
121 }
122
123 static char *read_string(void)
124 {
125         char buf[BUFSIZ];
126         char *str = NULL;
127         int size = 0;
128         off_t r;
129         char c;
130
131         for (;;) {
132                 r = read(input_fd, &c, 1);
133                 if (r < 0) {
134                         pr_debug("reading input file");
135                         goto out;
136                 }
137
138                 if (!r) {
139                         pr_debug("no data");
140                         goto out;
141                 }
142
143                 if (repipe) {
144                         int retw = write(STDOUT_FILENO, &c, 1);
145
146                         if (retw <= 0 || retw != r) {
147                                 pr_debug("repiping input file string");
148                                 goto out;
149                         }
150                 }
151
152                 buf[size++] = c;
153
154                 if (!c)
155                         break;
156         }
157
158         if (calc_data_size)
159                 calc_data_size += size;
160
161         str = malloc(size);
162         if (str)
163                 memcpy(str, buf, size);
164 out:
165         return str;
166 }
167
168 static int read_proc_kallsyms(struct pevent *pevent)
169 {
170         unsigned int size;
171         char *buf;
172
173         size = read4(pevent);
174         if (!size)
175                 return 0;
176
177         buf = malloc(size + 1);
178         if (buf == NULL)
179                 return -1;
180
181         if (do_read(buf, size) < 0) {
182                 free(buf);
183                 return -1;
184         }
185         buf[size] = '\0';
186
187         parse_proc_kallsyms(pevent, buf, size);
188
189         free(buf);
190         return 0;
191 }
192
193 static int read_ftrace_printk(struct pevent *pevent)
194 {
195         unsigned int size;
196         char *buf;
197
198         /* it can have 0 size */
199         size = read4(pevent);
200         if (!size)
201                 return 0;
202
203         buf = malloc(size);
204         if (buf == NULL)
205                 return -1;
206
207         if (do_read(buf, size) < 0) {
208                 free(buf);
209                 return -1;
210         }
211
212         parse_ftrace_printk(pevent, buf, size);
213
214         free(buf);
215         return 0;
216 }
217
218 static int read_header_files(struct pevent *pevent)
219 {
220         unsigned long long size;
221         char *header_event;
222         char buf[BUFSIZ];
223         int ret = 0;
224
225         if (do_read(buf, 12) < 0)
226                 return -1;
227
228         if (memcmp(buf, "header_page", 12) != 0) {
229                 pr_debug("did not read header page");
230                 return -1;
231         }
232
233         size = read8(pevent);
234         skip(size);
235
236         /*
237          * The size field in the page is of type long,
238          * use that instead, since it represents the kernel.
239          */
240         long_size = header_page_size_size;
241
242         if (do_read(buf, 13) < 0)
243                 return -1;
244
245         if (memcmp(buf, "header_event", 13) != 0) {
246                 pr_debug("did not read header event");
247                 return -1;
248         }
249
250         size = read8(pevent);
251         header_event = malloc(size);
252         if (header_event == NULL)
253                 return -1;
254
255         if (do_read(header_event, size) < 0)
256                 ret = -1;
257
258         free(header_event);
259         return ret;
260 }
261
262 static int read_ftrace_file(struct pevent *pevent, unsigned long long size)
263 {
264         char *buf;
265
266         buf = malloc(size);
267         if (buf == NULL)
268                 return -1;
269
270         if (do_read(buf, size) < 0) {
271                 free(buf);
272                 return -1;
273         }
274
275         parse_ftrace_file(pevent, buf, size);
276         free(buf);
277         return 0;
278 }
279
280 static int read_event_file(struct pevent *pevent, char *sys,
281                             unsigned long long size)
282 {
283         char *buf;
284
285         buf = malloc(size);
286         if (buf == NULL)
287                 return -1;
288
289         if (do_read(buf, size) < 0) {
290                 free(buf);
291                 return -1;
292         }
293
294         parse_event_file(pevent, buf, size, sys);
295         free(buf);
296         return 0;
297 }
298
299 static int read_ftrace_files(struct pevent *pevent)
300 {
301         unsigned long long size;
302         int count;
303         int i;
304         int ret;
305
306         count = read4(pevent);
307
308         for (i = 0; i < count; i++) {
309                 size = read8(pevent);
310                 ret = read_ftrace_file(pevent, size);
311                 if (ret)
312                         return ret;
313         }
314         return 0;
315 }
316
317 static int read_event_files(struct pevent *pevent)
318 {
319         unsigned long long size;
320         char *sys;
321         int systems;
322         int count;
323         int i,x;
324         int ret;
325
326         systems = read4(pevent);
327
328         for (i = 0; i < systems; i++) {
329                 sys = read_string();
330                 if (sys == NULL)
331                         return -1;
332
333                 count = read4(pevent);
334
335                 for (x=0; x < count; x++) {
336                         size = read8(pevent);
337                         ret = read_event_file(pevent, sys, size);
338                         if (ret)
339                                 return ret;
340                 }
341         }
342         return 0;
343 }
344
345 ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
346 {
347         char buf[BUFSIZ];
348         char test[] = { 23, 8, 68 };
349         char *version;
350         int show_version = 0;
351         int show_funcs = 0;
352         int show_printk = 0;
353         ssize_t size = -1;
354         struct pevent *pevent;
355         int err;
356
357         *ppevent = NULL;
358
359         calc_data_size = 1;
360         repipe = __repipe;
361
362         input_fd = fd;
363
364         if (do_read(buf, 3) < 0)
365                 return -1;
366         if (memcmp(buf, test, 3) != 0) {
367                 pr_debug("no trace data in the file");
368                 return -1;
369         }
370
371         if (do_read(buf, 7) < 0)
372                 return -1;
373         if (memcmp(buf, "tracing", 7) != 0) {
374                 pr_debug("not a trace file (missing 'tracing' tag)");
375                 return -1;
376         }
377
378         version = read_string();
379         if (version == NULL)
380                 return -1;
381         if (show_version)
382                 printf("version = %s\n", version);
383         free(version);
384
385         if (do_read(buf, 1) < 0)
386                 return -1;
387         file_bigendian = buf[0];
388         host_bigendian = bigendian();
389
390         pevent = read_trace_init(file_bigendian, host_bigendian);
391         if (pevent == NULL) {
392                 pr_debug("read_trace_init failed");
393                 goto out;
394         }
395
396         if (do_read(buf, 1) < 0)
397                 goto out;
398         long_size = buf[0];
399
400         page_size = read4(pevent);
401         if (!page_size)
402                 goto out;
403
404         err = read_header_files(pevent);
405         if (err)
406                 goto out;
407         err = read_ftrace_files(pevent);
408         if (err)
409                 goto out;
410         err = read_event_files(pevent);
411         if (err)
412                 goto out;
413         err = read_proc_kallsyms(pevent);
414         if (err)
415                 goto out;
416         err = read_ftrace_printk(pevent);
417         if (err)
418                 goto out;
419
420         size = calc_data_size - 1;
421         calc_data_size = 0;
422         repipe = false;
423
424         if (show_funcs) {
425                 pevent_print_funcs(pevent);
426         } else if (show_printk) {
427                 pevent_print_printk(pevent);
428         }
429
430         *ppevent = pevent;
431         pevent = NULL;
432
433 out:
434         if (pevent)
435                 pevent_free(pevent);
436         return size;
437 }