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

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

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

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