perf tools: Remove unused trace_read_data function
[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 #define _FILE_OFFSET_BITS 64
22
23 #include <dirent.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <getopt.h>
28 #include <stdarg.h>
29 #include <sys/types.h>
30 #include <sys/stat.h>
31 #include <sys/wait.h>
32 #include <sys/mman.h>
33 #include <pthread.h>
34 #include <fcntl.h>
35 #include <unistd.h>
36 #include <errno.h>
37
38 #include "../perf.h"
39 #include "util.h"
40 #include "trace-event.h"
41
42 static int input_fd;
43
44 int file_bigendian;
45 int host_bigendian;
46 static int long_size;
47
48 static ssize_t calc_data_size;
49 static bool repipe;
50
51 static void *malloc_or_die(int size)
52 {
53         void *ret;
54
55         ret = malloc(size);
56         if (!ret)
57                 die("malloc");
58         return ret;
59 }
60
61 static int do_read(int fd, void *buf, int size)
62 {
63         int rsize = size;
64
65         while (size) {
66                 int ret = read(fd, buf, size);
67
68                 if (ret <= 0)
69                         return -1;
70
71                 if (repipe) {
72                         int retw = write(STDOUT_FILENO, buf, ret);
73
74                         if (retw <= 0 || retw != ret)
75                                 die("repiping input file");
76                 }
77
78                 size -= ret;
79                 buf += ret;
80         }
81
82         return rsize;
83 }
84
85 static int read_or_die(void *data, int size)
86 {
87         int r;
88
89         r = do_read(input_fd, data, size);
90         if (r <= 0)
91                 die("reading input file (size expected=%d received=%d)",
92                     size, r);
93
94         if (calc_data_size)
95                 calc_data_size += r;
96
97         return r;
98 }
99
100 /* If it fails, the next read will report it */
101 static void skip(int size)
102 {
103         char buf[BUFSIZ];
104         int r;
105
106         while (size) {
107                 r = size > BUFSIZ ? BUFSIZ : size;
108                 read_or_die(buf, r);
109                 size -= r;
110         };
111 }
112
113 static unsigned int read4(struct pevent *pevent)
114 {
115         unsigned int data;
116
117         read_or_die(&data, 4);
118         return __data2host4(pevent, data);
119 }
120
121 static unsigned long long read8(struct pevent *pevent)
122 {
123         unsigned long long data;
124
125         read_or_die(&data, 8);
126         return __data2host8(pevent, data);
127 }
128
129 static char *read_string(void)
130 {
131         char buf[BUFSIZ];
132         char *str = NULL;
133         int size = 0;
134         off_t r;
135         char c;
136
137         for (;;) {
138                 r = read(input_fd, &c, 1);
139                 if (r < 0)
140                         die("reading input file");
141
142                 if (!r)
143                         die("no data");
144
145                 if (repipe) {
146                         int retw = write(STDOUT_FILENO, &c, 1);
147
148                         if (retw <= 0 || retw != r)
149                                 die("repiping input file string");
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_or_die(size);
162         memcpy(str, buf, size);
163
164         return str;
165 }
166
167 static void read_proc_kallsyms(struct pevent *pevent)
168 {
169         unsigned int size;
170         char *buf;
171
172         size = read4(pevent);
173         if (!size)
174                 return;
175
176         buf = malloc_or_die(size + 1);
177         read_or_die(buf, size);
178         buf[size] = '\0';
179
180         parse_proc_kallsyms(pevent, buf, size);
181
182         free(buf);
183 }
184
185 static void read_ftrace_printk(struct pevent *pevent)
186 {
187         unsigned int size;
188         char *buf;
189
190         size = read4(pevent);
191         if (!size)
192                 return;
193
194         buf = malloc_or_die(size);
195         read_or_die(buf, size);
196
197         parse_ftrace_printk(pevent, buf, size);
198
199         free(buf);
200 }
201
202 static void read_header_files(struct pevent *pevent)
203 {
204         unsigned long long size;
205         char *header_event;
206         char buf[BUFSIZ];
207
208         read_or_die(buf, 12);
209
210         if (memcmp(buf, "header_page", 12) != 0)
211                 die("did not read header page");
212
213         size = read8(pevent);
214         skip(size);
215
216         /*
217          * The size field in the page is of type long,
218          * use that instead, since it represents the kernel.
219          */
220         long_size = header_page_size_size;
221
222         read_or_die(buf, 13);
223         if (memcmp(buf, "header_event", 13) != 0)
224                 die("did not read header event");
225
226         size = read8(pevent);
227         header_event = malloc_or_die(size);
228         read_or_die(header_event, size);
229         free(header_event);
230 }
231
232 static void read_ftrace_file(struct pevent *pevent, unsigned long long size)
233 {
234         char *buf;
235
236         buf = malloc_or_die(size);
237         read_or_die(buf, size);
238         parse_ftrace_file(pevent, buf, size);
239         free(buf);
240 }
241
242 static void read_event_file(struct pevent *pevent, char *sys,
243                             unsigned long long size)
244 {
245         char *buf;
246
247         buf = malloc_or_die(size);
248         read_or_die(buf, size);
249         parse_event_file(pevent, buf, size, sys);
250         free(buf);
251 }
252
253 static void read_ftrace_files(struct pevent *pevent)
254 {
255         unsigned long long size;
256         int count;
257         int i;
258
259         count = read4(pevent);
260
261         for (i = 0; i < count; i++) {
262                 size = read8(pevent);
263                 read_ftrace_file(pevent, size);
264         }
265 }
266
267 static void read_event_files(struct pevent *pevent)
268 {
269         unsigned long long size;
270         char *sys;
271         int systems;
272         int count;
273         int i,x;
274
275         systems = read4(pevent);
276
277         for (i = 0; i < systems; i++) {
278                 sys = read_string();
279
280                 count = read4(pevent);
281                 for (x=0; x < count; x++) {
282                         size = read8(pevent);
283                         read_event_file(pevent, sys, size);
284                 }
285         }
286 }
287
288 ssize_t trace_report(int fd, struct pevent **ppevent, bool __repipe)
289 {
290         char buf[BUFSIZ];
291         char test[] = { 23, 8, 68 };
292         char *version;
293         int show_version = 0;
294         int show_funcs = 0;
295         int show_printk = 0;
296         ssize_t size;
297
298         calc_data_size = 1;
299         repipe = __repipe;
300
301         input_fd = fd;
302
303         read_or_die(buf, 3);
304         if (memcmp(buf, test, 3) != 0)
305                 die("no trace data in the file");
306
307         read_or_die(buf, 7);
308         if (memcmp(buf, "tracing", 7) != 0)
309                 die("not a trace file (missing 'tracing' tag)");
310
311         version = read_string();
312         if (show_version)
313                 printf("version = %s\n", version);
314         free(version);
315
316         read_or_die(buf, 1);
317         file_bigendian = buf[0];
318         host_bigendian = bigendian();
319
320         *ppevent = read_trace_init(file_bigendian, host_bigendian);
321         if (*ppevent == NULL)
322                 die("read_trace_init failed");
323
324         read_or_die(buf, 1);
325         long_size = buf[0];
326
327         page_size = read4(*ppevent);
328
329         read_header_files(*ppevent);
330
331         read_ftrace_files(*ppevent);
332         read_event_files(*ppevent);
333         read_proc_kallsyms(*ppevent);
334         read_ftrace_printk(*ppevent);
335
336         size = calc_data_size - 1;
337         calc_data_size = 0;
338         repipe = false;
339
340         if (show_funcs) {
341                 pevent_print_funcs(*ppevent);
342                 return size;
343         }
344         if (show_printk) {
345                 pevent_print_printk(*ppevent);
346                 return size;
347         }
348
349         return size;
350 }