~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/trace-event-read.c

Version: ~ [ linux-5.3-rc4 ] ~ [ linux-5.2.8 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.66 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.138 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.71 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 
 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 
 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 */
 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 
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 
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 
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 
162 static 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 
187 static 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 
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 
263 static 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 
281 static 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 
300 static 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 
318 static 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 
346 ssize_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 
440 out:
441         if (pevent)
442                 trace_event__cleanup(tevent);
443         return size;
444 }
445 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp