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

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

Version: ~ [ linux-5.1.2 ] ~ [ linux-5.0.16 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.43 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.119 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.176 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.179 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.139 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.67 ] ~ [ 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.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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) 2008,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 "util.h"
 22 #include <dirent.h>
 23 #include <mntent.h>
 24 #include <stdio.h>
 25 #include <stdlib.h>
 26 #include <string.h>
 27 #include <stdarg.h>
 28 #include <sys/types.h>
 29 #include <sys/stat.h>
 30 #include <sys/wait.h>
 31 #include <pthread.h>
 32 #include <fcntl.h>
 33 #include <unistd.h>
 34 #include <errno.h>
 35 #include <stdbool.h>
 36 #include <linux/list.h>
 37 #include <linux/kernel.h>
 38 
 39 #include "../perf.h"
 40 #include "trace-event.h"
 41 #include <api/fs/debugfs.h>
 42 #include "evsel.h"
 43 #include "debug.h"
 44 
 45 #define VERSION "0.5"
 46 
 47 static int output_fd;
 48 
 49 
 50 int bigendian(void)
 51 {
 52         unsigned char str[] = { 0x1, 0x2, 0x3, 0x4, 0x0, 0x0, 0x0, 0x0};
 53         unsigned int *ptr;
 54 
 55         ptr = (unsigned int *)(void *)str;
 56         return *ptr == 0x01020304;
 57 }
 58 
 59 /* unfortunately, you can not stat debugfs or proc files for size */
 60 static int record_file(const char *file, ssize_t hdr_sz)
 61 {
 62         unsigned long long size = 0;
 63         char buf[BUFSIZ], *sizep;
 64         off_t hdr_pos = lseek(output_fd, 0, SEEK_CUR);
 65         int r, fd;
 66         int err = -EIO;
 67 
 68         fd = open(file, O_RDONLY);
 69         if (fd < 0) {
 70                 pr_debug("Can't read '%s'", file);
 71                 return -errno;
 72         }
 73 
 74         /* put in zeros for file size, then fill true size later */
 75         if (hdr_sz) {
 76                 if (write(output_fd, &size, hdr_sz) != hdr_sz)
 77                         goto out;
 78         }
 79 
 80         do {
 81                 r = read(fd, buf, BUFSIZ);
 82                 if (r > 0) {
 83                         size += r;
 84                         if (write(output_fd, buf, r) != r)
 85                                 goto out;
 86                 }
 87         } while (r > 0);
 88 
 89         /* ugh, handle big-endian hdr_size == 4 */
 90         sizep = (char*)&size;
 91         if (bigendian())
 92                 sizep += sizeof(u64) - hdr_sz;
 93 
 94         if (hdr_sz && pwrite(output_fd, sizep, hdr_sz, hdr_pos) < 0) {
 95                 pr_debug("writing file size failed\n");
 96                 goto out;
 97         }
 98 
 99         err = 0;
100 out:
101         close(fd);
102         return err;
103 }
104 
105 static int record_header_files(void)
106 {
107         char *path;
108         struct stat st;
109         int err = -EIO;
110 
111         path = get_tracing_file("events/header_page");
112         if (!path) {
113                 pr_debug("can't get tracing/events/header_page");
114                 return -ENOMEM;
115         }
116 
117         if (stat(path, &st) < 0) {
118                 pr_debug("can't read '%s'", path);
119                 goto out;
120         }
121 
122         if (write(output_fd, "header_page", 12) != 12) {
123                 pr_debug("can't write header_page\n");
124                 goto out;
125         }
126 
127         if (record_file(path, 8) < 0) {
128                 pr_debug("can't record header_page file\n");
129                 goto out;
130         }
131 
132         put_tracing_file(path);
133 
134         path = get_tracing_file("events/header_event");
135         if (!path) {
136                 pr_debug("can't get tracing/events/header_event");
137                 err = -ENOMEM;
138                 goto out;
139         }
140 
141         if (stat(path, &st) < 0) {
142                 pr_debug("can't read '%s'", path);
143                 goto out;
144         }
145 
146         if (write(output_fd, "header_event", 13) != 13) {
147                 pr_debug("can't write header_event\n");
148                 goto out;
149         }
150 
151         if (record_file(path, 8) < 0) {
152                 pr_debug("can't record header_event file\n");
153                 goto out;
154         }
155 
156         err = 0;
157 out:
158         put_tracing_file(path);
159         return err;
160 }
161 
162 static bool name_in_tp_list(char *sys, struct tracepoint_path *tps)
163 {
164         while (tps) {
165                 if (!strcmp(sys, tps->name))
166                         return true;
167                 tps = tps->next;
168         }
169 
170         return false;
171 }
172 
173 static int copy_event_system(const char *sys, struct tracepoint_path *tps)
174 {
175         struct dirent *dent;
176         struct stat st;
177         char *format;
178         DIR *dir;
179         int count = 0;
180         int ret;
181         int err;
182 
183         dir = opendir(sys);
184         if (!dir) {
185                 pr_debug("can't read directory '%s'", sys);
186                 return -errno;
187         }
188 
189         while ((dent = readdir(dir))) {
190                 if (dent->d_type != DT_DIR ||
191                     strcmp(dent->d_name, ".") == 0 ||
192                     strcmp(dent->d_name, "..") == 0 ||
193                     !name_in_tp_list(dent->d_name, tps))
194                         continue;
195                 if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
196                         err = -ENOMEM;
197                         goto out;
198                 }
199                 ret = stat(format, &st);
200                 free(format);
201                 if (ret < 0)
202                         continue;
203                 count++;
204         }
205 
206         if (write(output_fd, &count, 4) != 4) {
207                 err = -EIO;
208                 pr_debug("can't write count\n");
209                 goto out;
210         }
211 
212         rewinddir(dir);
213         while ((dent = readdir(dir))) {
214                 if (dent->d_type != DT_DIR ||
215                     strcmp(dent->d_name, ".") == 0 ||
216                     strcmp(dent->d_name, "..") == 0 ||
217                     !name_in_tp_list(dent->d_name, tps))
218                         continue;
219                 if (asprintf(&format, "%s/%s/format", sys, dent->d_name) < 0) {
220                         err = -ENOMEM;
221                         goto out;
222                 }
223                 ret = stat(format, &st);
224 
225                 if (ret >= 0) {
226                         err = record_file(format, 8);
227                         if (err) {
228                                 free(format);
229                                 goto out;
230                         }
231                 }
232                 free(format);
233         }
234         err = 0;
235 out:
236         closedir(dir);
237         return err;
238 }
239 
240 static int record_ftrace_files(struct tracepoint_path *tps)
241 {
242         char *path;
243         int ret;
244 
245         path = get_tracing_file("events/ftrace");
246         if (!path) {
247                 pr_debug("can't get tracing/events/ftrace");
248                 return -ENOMEM;
249         }
250 
251         ret = copy_event_system(path, tps);
252 
253         put_tracing_file(path);
254 
255         return ret;
256 }
257 
258 static bool system_in_tp_list(char *sys, struct tracepoint_path *tps)
259 {
260         while (tps) {
261                 if (!strcmp(sys, tps->system))
262                         return true;
263                 tps = tps->next;
264         }
265 
266         return false;
267 }
268 
269 static int record_event_files(struct tracepoint_path *tps)
270 {
271         struct dirent *dent;
272         struct stat st;
273         char *path;
274         char *sys;
275         DIR *dir;
276         int count = 0;
277         int ret;
278         int err;
279 
280         path = get_tracing_file("events");
281         if (!path) {
282                 pr_debug("can't get tracing/events");
283                 return -ENOMEM;
284         }
285 
286         dir = opendir(path);
287         if (!dir) {
288                 err = -errno;
289                 pr_debug("can't read directory '%s'", path);
290                 goto out;
291         }
292 
293         while ((dent = readdir(dir))) {
294                 if (dent->d_type != DT_DIR ||
295                     strcmp(dent->d_name, ".") == 0 ||
296                     strcmp(dent->d_name, "..") == 0 ||
297                     strcmp(dent->d_name, "ftrace") == 0 ||
298                     !system_in_tp_list(dent->d_name, tps))
299                         continue;
300                 count++;
301         }
302 
303         if (write(output_fd, &count, 4) != 4) {
304                 err = -EIO;
305                 pr_debug("can't write count\n");
306                 goto out;
307         }
308 
309         rewinddir(dir);
310         while ((dent = readdir(dir))) {
311                 if (dent->d_type != DT_DIR ||
312                     strcmp(dent->d_name, ".") == 0 ||
313                     strcmp(dent->d_name, "..") == 0 ||
314                     strcmp(dent->d_name, "ftrace") == 0 ||
315                     !system_in_tp_list(dent->d_name, tps))
316                         continue;
317                 if (asprintf(&sys, "%s/%s", path, dent->d_name) < 0) {
318                         err = -ENOMEM;
319                         goto out;
320                 }
321                 ret = stat(sys, &st);
322                 if (ret >= 0) {
323                         ssize_t size = strlen(dent->d_name) + 1;
324 
325                         if (write(output_fd, dent->d_name, size) != size ||
326                             copy_event_system(sys, tps) < 0) {
327                                 err = -EIO;
328                                 free(sys);
329                                 goto out;
330                         }
331                 }
332                 free(sys);
333         }
334         err = 0;
335 out:
336         closedir(dir);
337         put_tracing_file(path);
338 
339         return err;
340 }
341 
342 static int record_proc_kallsyms(void)
343 {
344         unsigned int size;
345         const char *path = "/proc/kallsyms";
346         struct stat st;
347         int ret, err = 0;
348 
349         ret = stat(path, &st);
350         if (ret < 0) {
351                 /* not found */
352                 size = 0;
353                 if (write(output_fd, &size, 4) != 4)
354                         err = -EIO;
355                 return err;
356         }
357         return record_file(path, 4);
358 }
359 
360 static int record_ftrace_printk(void)
361 {
362         unsigned int size;
363         char *path;
364         struct stat st;
365         int ret, err = 0;
366 
367         path = get_tracing_file("printk_formats");
368         if (!path) {
369                 pr_debug("can't get tracing/printk_formats");
370                 return -ENOMEM;
371         }
372 
373         ret = stat(path, &st);
374         if (ret < 0) {
375                 /* not found */
376                 size = 0;
377                 if (write(output_fd, &size, 4) != 4)
378                         err = -EIO;
379                 goto out;
380         }
381         err = record_file(path, 4);
382 
383 out:
384         put_tracing_file(path);
385         return err;
386 }
387 
388 static void
389 put_tracepoints_path(struct tracepoint_path *tps)
390 {
391         while (tps) {
392                 struct tracepoint_path *t = tps;
393 
394                 tps = tps->next;
395                 zfree(&t->name);
396                 zfree(&t->system);
397                 free(t);
398         }
399 }
400 
401 static struct tracepoint_path *
402 get_tracepoints_path(struct list_head *pattrs)
403 {
404         struct tracepoint_path path, *ppath = &path;
405         struct perf_evsel *pos;
406         int nr_tracepoints = 0;
407 
408         list_for_each_entry(pos, pattrs, node) {
409                 if (pos->attr.type != PERF_TYPE_TRACEPOINT)
410                         continue;
411                 ++nr_tracepoints;
412 
413                 if (pos->name) {
414                         ppath->next = tracepoint_name_to_path(pos->name);
415                         if (ppath->next)
416                                 goto next;
417 
418                         if (strchr(pos->name, ':') == NULL)
419                                 goto try_id;
420 
421                         goto error;
422                 }
423 
424 try_id:
425                 ppath->next = tracepoint_id_to_path(pos->attr.config);
426                 if (!ppath->next) {
427 error:
428                         pr_debug("No memory to alloc tracepoints list\n");
429                         put_tracepoints_path(&path);
430                         return NULL;
431                 }
432 next:
433                 ppath = ppath->next;
434         }
435 
436         return nr_tracepoints > 0 ? path.next : NULL;
437 }
438 
439 bool have_tracepoints(struct list_head *pattrs)
440 {
441         struct perf_evsel *pos;
442 
443         list_for_each_entry(pos, pattrs, node)
444                 if (pos->attr.type == PERF_TYPE_TRACEPOINT)
445                         return true;
446 
447         return false;
448 }
449 
450 static int tracing_data_header(void)
451 {
452         char buf[20];
453         ssize_t size;
454 
455         /* just guessing this is someone's birthday.. ;) */
456         buf[0] = 23;
457         buf[1] = 8;
458         buf[2] = 68;
459         memcpy(buf + 3, "tracing", 7);
460 
461         if (write(output_fd, buf, 10) != 10)
462                 return -1;
463 
464         size = strlen(VERSION) + 1;
465         if (write(output_fd, VERSION, size) != size)
466                 return -1;
467 
468         /* save endian */
469         if (bigendian())
470                 buf[0] = 1;
471         else
472                 buf[0] = 0;
473 
474         if (write(output_fd, buf, 1) != 1)
475                 return -1;
476 
477         /* save size of long */
478         buf[0] = sizeof(long);
479         if (write(output_fd, buf, 1) != 1)
480                 return -1;
481 
482         /* save page_size */
483         if (write(output_fd, &page_size, 4) != 4)
484                 return -1;
485 
486         return 0;
487 }
488 
489 struct tracing_data *tracing_data_get(struct list_head *pattrs,
490                                       int fd, bool temp)
491 {
492         struct tracepoint_path *tps;
493         struct tracing_data *tdata;
494         int err;
495 
496         output_fd = fd;
497 
498         tps = get_tracepoints_path(pattrs);
499         if (!tps)
500                 return NULL;
501 
502         tdata = malloc(sizeof(*tdata));
503         if (!tdata)
504                 return NULL;
505 
506         tdata->temp = temp;
507         tdata->size = 0;
508 
509         if (temp) {
510                 int temp_fd;
511 
512                 snprintf(tdata->temp_file, sizeof(tdata->temp_file),
513                          "/tmp/perf-XXXXXX");
514                 if (!mkstemp(tdata->temp_file)) {
515                         pr_debug("Can't make temp file");
516                         return NULL;
517                 }
518 
519                 temp_fd = open(tdata->temp_file, O_RDWR);
520                 if (temp_fd < 0) {
521                         pr_debug("Can't read '%s'", tdata->temp_file);
522                         return NULL;
523                 }
524 
525                 /*
526                  * Set the temp file the default output, so all the
527                  * tracing data are stored into it.
528                  */
529                 output_fd = temp_fd;
530         }
531 
532         err = tracing_data_header();
533         if (err)
534                 goto out;
535         err = record_header_files();
536         if (err)
537                 goto out;
538         err = record_ftrace_files(tps);
539         if (err)
540                 goto out;
541         err = record_event_files(tps);
542         if (err)
543                 goto out;
544         err = record_proc_kallsyms();
545         if (err)
546                 goto out;
547         err = record_ftrace_printk();
548 
549 out:
550         /*
551          * All tracing data are stored by now, we can restore
552          * the default output file in case we used temp file.
553          */
554         if (temp) {
555                 tdata->size = lseek(output_fd, 0, SEEK_CUR);
556                 close(output_fd);
557                 output_fd = fd;
558         }
559 
560         if (err)
561                 zfree(&tdata);
562 
563         put_tracepoints_path(tps);
564         return tdata;
565 }
566 
567 int tracing_data_put(struct tracing_data *tdata)
568 {
569         int err = 0;
570 
571         if (tdata->temp) {
572                 err = record_file(tdata->temp_file, 0);
573                 unlink(tdata->temp_file);
574         }
575 
576         free(tdata);
577         return err;
578 }
579 
580 int read_tracing_data(int fd, struct list_head *pattrs)
581 {
582         int err;
583         struct tracing_data *tdata;
584 
585         /*
586          * We work over the real file, so we can write data
587          * directly, no temp file is needed.
588          */
589         tdata = tracing_data_get(pattrs, fd, false);
590         if (!tdata)
591                 return -ENOMEM;
592 
593         err = tracing_data_put(tdata);
594         return err;
595 }
596 

~ [ 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