?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Do not increment pool indexes twice
[pohmelfs.git] / tools / perf / util / header.c
blob14bb035c5fd9254d680b80f66e7da055b5ceb047
1 #define _FILE_OFFSET_BITS 64
2
3 #include "util.h"
4 #include <sys/types.h>
5 #include <byteswap.h>
6 #include <unistd.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <linux/list.h>
10 #include <linux/kernel.h>
11 #include <linux/bitops.h>
12 #include <sys/utsname.h>
13
14 #include "evlist.h"
15 #include "evsel.h"
16 #include "header.h"
17 #include "../perf.h"
18 #include "trace-event.h"
19 #include "session.h"
20 #include "symbol.h"
21 #include "debug.h"
22 #include "cpumap.h"
23
24 static bool no_buildid_cache = false;
25
26 static int event_count;
27 static struct perf_trace_event_type *events;
28
29 static u32 header_argc;
30 static const char **header_argv;
31
32 int perf_header__push_event(u64 id, const char *name)
33 {
34 if (strlen(name) > MAX_EVENT_NAME)
35 pr_warning("Event %s will be truncated\n", name);
36
37 if (!events) {
38 events = malloc(sizeof(struct perf_trace_event_type));
39 if (events == NULL)
40 return -ENOMEM;
41 } else {
42 struct perf_trace_event_type *nevents;
43
44 nevents = realloc(events, (event_count + 1) * sizeof(*events));
45 if (nevents == NULL)
46 return -ENOMEM;
47 events = nevents;
48 }
49 memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
50 events[event_count].event_id = id;
51 strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
52 event_count++;
53 return 0;
54 }
55
56 char *perf_header__find_event(u64 id)
57 {
58 int i;
59 for (i = 0 ; i < event_count; i++) {
60 if (events[i].event_id == id)
61 return events[i].name;
62 }
63 return NULL;
64 }
65
66 static const char *__perf_magic = "PERFFILE";
67
68 #define PERF_MAGIC (*(u64 *)__perf_magic)
69
70 struct perf_file_attr {
71 struct perf_event_attr attr;
72 struct perf_file_section ids;
73 };
74
75 void perf_header__set_feat(struct perf_header *header, int feat)
76 {
77 set_bit(feat, header->adds_features);
78 }
79
80 void perf_header__clear_feat(struct perf_header *header, int feat)
81 {
82 clear_bit(feat, header->adds_features);
83 }
84
85 bool perf_header__has_feat(const struct perf_header *header, int feat)
86 {
87 return test_bit(feat, header->adds_features);
88 }
89
90 static int do_write(int fd, const void *buf, size_t size)
91 {
92 while (size) {
93 int ret = write(fd, buf, size);
94
95 if (ret < 0)
96 return -errno;
97
98 size -= ret;
99 buf += ret;
100 }
101
102 return 0;
103 }
104
105 #define NAME_ALIGN 64
106
107 static int write_padded(int fd, const void *bf, size_t count,
108 size_t count_aligned)
109 {
110 static const char zero_buf[NAME_ALIGN];
111 int err = do_write(fd, bf, count);
112
113 if (!err)
114 err = do_write(fd, zero_buf, count_aligned - count);
115
116 return err;
117 }
118
119 static int do_write_string(int fd, const char *str)
120 {
121 u32 len, olen;
122 int ret;
123
124 olen = strlen(str) + 1;
125 len = ALIGN(olen, NAME_ALIGN);
126
127 /* write len, incl. \0 */
128 ret = do_write(fd, &len, sizeof(len));
129 if (ret < 0)
130 return ret;
131
132 return write_padded(fd, str, olen, len);
133 }
134
135 static char *do_read_string(int fd, struct perf_header *ph)
136 {
137 ssize_t sz, ret;
138 u32 len;
139 char *buf;
140
141 sz = read(fd, &len, sizeof(len));
142 if (sz < (ssize_t)sizeof(len))
143 return NULL;
144
145 if (ph->needs_swap)
146 len = bswap_32(len);
147
148 buf = malloc(len);
149 if (!buf)
150 return NULL;
151
152 ret = read(fd, buf, len);
153 if (ret == (ssize_t)len) {
154 /*
155 * strings are padded by zeroes
156 * thus the actual strlen of buf
157 * may be less than len
158 */
159 return buf;
160 }
161
162 free(buf);
163 return NULL;
164 }
165
166 int
167 perf_header__set_cmdline(int argc, const char **argv)
168 {
169 int i;
170
171 header_argc = (u32)argc;
172
173 /* do not include NULL termination */
174 header_argv = calloc(argc, sizeof(char *));
175 if (!header_argv)
176 return -ENOMEM;
177
178 /*
179 * must copy argv contents because it gets moved
180 * around during option parsing
181 */
182 for (i = 0; i < argc ; i++)
183 header_argv[i] = argv[i];
184
185 return 0;
186 }
187
188 #define dsos__for_each_with_build_id(pos, head) \
189 list_for_each_entry(pos, head, node) \
190 if (!pos->has_build_id) \
191 continue; \
192 else
193
194 static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
195 u16 misc, int fd)
196 {
197 struct dso *pos;
198
199 dsos__for_each_with_build_id(pos, head) {
200 int err;
201 struct build_id_event b;
202 size_t len;
203
204 if (!pos->hit)
205 continue;
206 len = pos->long_name_len + 1;
207 len = ALIGN(len, NAME_ALIGN);
208 memset(&b, 0, sizeof(b));
209 memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
210 b.pid = pid;
211 b.header.misc = misc;
212 b.header.size = sizeof(b) + len;
213 err = do_write(fd, &b, sizeof(b));
214 if (err < 0)
215 return err;
216 err = write_padded(fd, pos->long_name,
217 pos->long_name_len + 1, len);
218 if (err < 0)
219 return err;
220 }
221
222 return 0;
223 }
224
225 static int machine__write_buildid_table(struct machine *machine, int fd)
226 {
227 int err;
228 u16 kmisc = PERF_RECORD_MISC_KERNEL,
229 umisc = PERF_RECORD_MISC_USER;
230
231 if (!machine__is_host(machine)) {
232 kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
233 umisc = PERF_RECORD_MISC_GUEST_USER;
234 }
235
236 err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,
237 kmisc, fd);
238 if (err == 0)
239 err = __dsos__write_buildid_table(&machine->user_dsos,
240 machine->pid, umisc, fd);
241 return err;
242 }
243
244 static int dsos__write_buildid_table(struct perf_header *header, int fd)
245 {
246 struct perf_session *session = container_of(header,
247 struct perf_session, header);
248 struct rb_node *nd;
249 int err = machine__write_buildid_table(&session->host_machine, fd);
250
251 if (err)
252 return err;
253
254 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
255 struct machine *pos = rb_entry(nd, struct machine, rb_node);
256 err = machine__write_buildid_table(pos, fd);
257 if (err)
258 break;
259 }
260 return err;
261 }
262
263 int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
264 const char *name, bool is_kallsyms)
265 {
266 const size_t size = PATH_MAX;
267 char *realname, *filename = zalloc(size),
268 *linkname = zalloc(size), *targetname;
269 int len, err = -1;
270
271 if (is_kallsyms) {
272 if (symbol_conf.kptr_restrict) {
273 pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
274 return 0;
275 }
276 realname = (char *)name;
277 } else
278 realname = realpath(name, NULL);
279
280 if (realname == NULL || filename == NULL || linkname == NULL)
281 goto out_free;
282
283 len = scnprintf(filename, size, "%s%s%s",
284 debugdir, is_kallsyms ? "/" : "", realname);
285 if (mkdir_p(filename, 0755))
286 goto out_free;
287
288 snprintf(filename + len, sizeof(filename) - len, "/%s", sbuild_id);
289
290 if (access(filename, F_OK)) {
291 if (is_kallsyms) {
292 if (copyfile("/proc/kallsyms", filename))
293 goto out_free;
294 } else if (link(realname, filename) && copyfile(name, filename))
295 goto out_free;
296 }
297
298 len = scnprintf(linkname, size, "%s/.build-id/%.2s",
299 debugdir, sbuild_id);
300
301 if (access(linkname, X_OK) && mkdir_p(linkname, 0755))
302 goto out_free;
303
304 snprintf(linkname + len, size - len, "/%s", sbuild_id + 2);
305 targetname = filename + strlen(debugdir) - 5;
306 memcpy(targetname, "../..", 5);
307
308 if (symlink(targetname, linkname) == 0)
309 err = 0;
310 out_free:
311 if (!is_kallsyms)
312 free(realname);
313 free(filename);
314 free(linkname);
315 return err;
316 }
317
318 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
319 const char *name, const char *debugdir,
320 bool is_kallsyms)
321 {
322 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
323
324 build_id__sprintf(build_id, build_id_size, sbuild_id);
325
326 return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
327 }
328
329 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
330 {
331 const size_t size = PATH_MAX;
332 char *filename = zalloc(size),
333 *linkname = zalloc(size);
334 int err = -1;
335
336 if (filename == NULL || linkname == NULL)
337 goto out_free;
338
339 snprintf(linkname, size, "%s/.build-id/%.2s/%s",
340 debugdir, sbuild_id, sbuild_id + 2);
341
342 if (access(linkname, F_OK))
343 goto out_free;
344
345 if (readlink(linkname, filename, size - 1) < 0)
346 goto out_free;
347
348 if (unlink(linkname))
349 goto out_free;
350
351 /*
352 * Since the link is relative, we must make it absolute:
353 */
354 snprintf(linkname, size, "%s/.build-id/%.2s/%s",
355 debugdir, sbuild_id, filename);
356
357 if (unlink(linkname))
358 goto out_free;
359
360 err = 0;
361 out_free:
362 free(filename);
363 free(linkname);
364 return err;
365 }
366
367 static int dso__cache_build_id(struct dso *dso, const char *debugdir)
368 {
369 bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
370
371 return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
372 dso->long_name, debugdir, is_kallsyms);
373 }
374
375 static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
376 {
377 struct dso *pos;
378 int err = 0;
379
380 dsos__for_each_with_build_id(pos, head)
381 if (dso__cache_build_id(pos, debugdir))
382 err = -1;
383
384 return err;
385 }
386
387 static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
388 {
389 int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);
390 ret |= __dsos__cache_build_ids(&machine->user_dsos, debugdir);
391 return ret;
392 }
393
394 static int perf_session__cache_build_ids(struct perf_session *session)
395 {
396 struct rb_node *nd;
397 int ret;
398 char debugdir[PATH_MAX];
399
400 snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
401
402 if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
403 return -1;
404
405 ret = machine__cache_build_ids(&session->host_machine, debugdir);
406
407 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
408 struct machine *pos = rb_entry(nd, struct machine, rb_node);
409 ret |= machine__cache_build_ids(pos, debugdir);
410 }
411 return ret ? -1 : 0;
412 }
413
414 static bool machine__read_build_ids(struct machine *machine, bool with_hits)
415 {
416 bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
417 ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits);
418 return ret;
419 }
420
421 static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
422 {
423 struct rb_node *nd;
424 bool ret = machine__read_build_ids(&session->host_machine, with_hits);
425
426 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
427 struct machine *pos = rb_entry(nd, struct machine, rb_node);
428 ret |= machine__read_build_ids(pos, with_hits);
429 }
430
431 return ret;
432 }
433
434 static int write_trace_info(int fd, struct perf_header *h __used,
435 struct perf_evlist *evlist)
436 {
437 return read_tracing_data(fd, &evlist->entries);
438 }
439
440
441 static int write_build_id(int fd, struct perf_header *h,
442 struct perf_evlist *evlist __used)
443 {
444 struct perf_session *session;
445 int err;
446
447 session = container_of(h, struct perf_session, header);
448
449 if (!perf_session__read_build_ids(session, true))
450 return -1;
451
452 err = dsos__write_buildid_table(h, fd);
453 if (err < 0) {
454 pr_debug("failed to write buildid table\n");
455 return err;
456 }
457 if (!no_buildid_cache)
458 perf_session__cache_build_ids(session);
459
460 return 0;
461 }
462
463 static int write_hostname(int fd, struct perf_header *h __used,
464 struct perf_evlist *evlist __used)
465 {
466 struct utsname uts;
467 int ret;
468
469 ret = uname(&uts);
470 if (ret < 0)
471 return -1;
472
473 return do_write_string(fd, uts.nodename);
474 }
475
476 static int write_osrelease(int fd, struct perf_header *h __used,
477 struct perf_evlist *evlist __used)
478 {
479 struct utsname uts;
480 int ret;
481
482 ret = uname(&uts);
483 if (ret < 0)
484 return -1;
485
486 return do_write_string(fd, uts.release);
487 }
488
489 static int write_arch(int fd, struct perf_header *h __used,
490 struct perf_evlist *evlist __used)
491 {
492 struct utsname uts;
493 int ret;
494
495 ret = uname(&uts);
496 if (ret < 0)
497 return -1;
498
499 return do_write_string(fd, uts.machine);
500 }
501
502 static int write_version(int fd, struct perf_header *h __used,
503 struct perf_evlist *evlist __used)
504 {
505 return do_write_string(fd, perf_version_string);
506 }
507
508 static int write_cpudesc(int fd, struct perf_header *h __used,
509 struct perf_evlist *evlist __used)
510 {
511 #ifndef CPUINFO_PROC
512 #define CPUINFO_PROC NULL
513 #endif
514 FILE *file;
515 char *buf = NULL;
516 char *s, *p;
517 const char *search = CPUINFO_PROC;
518 size_t len = 0;
519 int ret = -1;
520
521 if (!search)
522 return -1;
523
524 file = fopen("/proc/cpuinfo", "r");
525 if (!file)
526 return -1;
527
528 while (getline(&buf, &len, file) > 0) {
529 ret = strncmp(buf, search, strlen(search));
530 if (!ret)
531 break;
532 }
533
534 if (ret)
535 goto done;
536
537 s = buf;
538
539 p = strchr(buf, ':');
540 if (p && *(p+1) == ' ' && *(p+2))
541 s = p + 2;
542 p = strchr(s, '\n');
543 if (p)
544 *p = '\0';
545
546 /* squash extra space characters (branding string) */
547 p = s;
548 while (*p) {
549 if (isspace(*p)) {
550 char *r = p + 1;
551 char *q = r;
552 *p = ' ';
553 while (*q && isspace(*q))
554 q++;
555 if (q != (p+1))
556 while ((*r++ = *q++));
557 }
558 p++;
559 }
560 ret = do_write_string(fd, s);
561 done:
562 free(buf);
563 fclose(file);
564 return ret;
565 }
566
567 static int write_nrcpus(int fd, struct perf_header *h __used,
568 struct perf_evlist *evlist __used)
569 {
570 long nr;
571 u32 nrc, nra;
572 int ret;
573
574 nr = sysconf(_SC_NPROCESSORS_CONF);
575 if (nr < 0)
576 return -1;
577
578 nrc = (u32)(nr & UINT_MAX);
579
580 nr = sysconf(_SC_NPROCESSORS_ONLN);
581 if (nr < 0)
582 return -1;
583
584 nra = (u32)(nr & UINT_MAX);
585
586 ret = do_write(fd, &nrc, sizeof(nrc));
587 if (ret < 0)
588 return ret;
589
590 return do_write(fd, &nra, sizeof(nra));
591 }
592
593 static int write_event_desc(int fd, struct perf_header *h __used,
594 struct perf_evlist *evlist)
595 {
596 struct perf_evsel *attr;
597 u32 nre = 0, nri, sz;
598 int ret;
599
600 list_for_each_entry(attr, &evlist->entries, node)
601 nre++;
602
603 /*
604 * write number of events
605 */
606 ret = do_write(fd, &nre, sizeof(nre));
607 if (ret < 0)
608 return ret;
609
610 /*
611 * size of perf_event_attr struct
612 */
613 sz = (u32)sizeof(attr->attr);
614 ret = do_write(fd, &sz, sizeof(sz));
615 if (ret < 0)
616 return ret;
617
618 list_for_each_entry(attr, &evlist->entries, node) {
619
620 ret = do_write(fd, &attr->attr, sz);
621 if (ret < 0)
622 return ret;
623 /*
624 * write number of unique id per event
625 * there is one id per instance of an event
626 *
627 * copy into an nri to be independent of the
628 * type of ids,
629 */
630 nri = attr->ids;
631 ret = do_write(fd, &nri, sizeof(nri));
632 if (ret < 0)
633 return ret;
634
635 /*
636 * write event string as passed on cmdline
637 */
638 ret = do_write_string(fd, event_name(attr));
639 if (ret < 0)
640 return ret;
641 /*
642 * write unique ids for this event
643 */
644 ret = do_write(fd, attr->id, attr->ids * sizeof(u64));
645 if (ret < 0)
646 return ret;
647 }
648 return 0;
649 }
650
651 static int write_cmdline(int fd, struct perf_header *h __used,
652 struct perf_evlist *evlist __used)
653 {
654 char buf[MAXPATHLEN];
655 char proc[32];
656 u32 i, n;
657 int ret;
658
659 /*
660 * actual atual path to perf binary
661 */
662 sprintf(proc, "/proc/%d/exe", getpid());
663 ret = readlink(proc, buf, sizeof(buf));
664 if (ret <= 0)
665 return -1;
666
667 /* readlink() does not add null termination */
668 buf[ret] = '\0';
669
670 /* account for binary path */
671 n = header_argc + 1;
672
673 ret = do_write(fd, &n, sizeof(n));
674 if (ret < 0)
675 return ret;
676
677 ret = do_write_string(fd, buf);
678 if (ret < 0)
679 return ret;
680
681 for (i = 0 ; i < header_argc; i++) {
682 ret = do_write_string(fd, header_argv[i]);
683 if (ret < 0)
684 return ret;
685 }
686 return 0;
687 }
688
689 #define CORE_SIB_FMT \
690 "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list"
691 #define THRD_SIB_FMT \
692 "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list"
693
694 struct cpu_topo {
695 u32 core_sib;
696 u32 thread_sib;
697 char **core_siblings;
698 char **thread_siblings;
699 };
700
701 static int build_cpu_topo(struct cpu_topo *tp, int cpu)
702 {
703 FILE *fp;
704 char filename[MAXPATHLEN];
705 char *buf = NULL, *p;
706 size_t len = 0;
707 u32 i = 0;
708 int ret = -1;
709
710 sprintf(filename, CORE_SIB_FMT, cpu);
711 fp = fopen(filename, "r");
712 if (!fp)
713 return -1;
714
715 if (getline(&buf, &len, fp) <= 0)
716 goto done;
717
718 fclose(fp);
719
720 p = strchr(buf, '\n');
721 if (p)
722 *p = '\0';
723
724 for (i = 0; i < tp->core_sib; i++) {
725 if (!strcmp(buf, tp->core_siblings[i]))
726 break;
727 }
728 if (i == tp->core_sib) {
729 tp->core_siblings[i] = buf;
730 tp->core_sib++;
731 buf = NULL;
732 len = 0;
733 }
734
735 sprintf(filename, THRD_SIB_FMT, cpu);
736 fp = fopen(filename, "r");
737 if (!fp)
738 goto done;
739
740 if (getline(&buf, &len, fp) <= 0)
741 goto done;
742
743 p = strchr(buf, '\n');
744 if (p)
745 *p = '\0';
746
747 for (i = 0; i < tp->thread_sib; i++) {
748 if (!strcmp(buf, tp->thread_siblings[i]))
749 break;
750 }
751 if (i == tp->thread_sib) {
752 tp->thread_siblings[i] = buf;
753 tp->thread_sib++;
754 buf = NULL;
755 }
756 ret = 0;
757 done:
758 if(fp)
759 fclose(fp);
760 free(buf);
761 return ret;
762 }
763
764 static void free_cpu_topo(struct cpu_topo *tp)
765 {
766 u32 i;
767
768 if (!tp)
769 return;
770
771 for (i = 0 ; i < tp->core_sib; i++)
772 free(tp->core_siblings[i]);
773
774 for (i = 0 ; i < tp->thread_sib; i++)
775 free(tp->thread_siblings[i]);
776
777 free(tp);
778 }
779
780 static struct cpu_topo *build_cpu_topology(void)
781 {
782 struct cpu_topo *tp;
783 void *addr;
784 u32 nr, i;
785 size_t sz;
786 long ncpus;
787 int ret = -1;
788
789 ncpus = sysconf(_SC_NPROCESSORS_CONF);
790 if (ncpus < 0)
791 return NULL;
792
793 nr = (u32)(ncpus & UINT_MAX);
794
795 sz = nr * sizeof(char *);
796
797 addr = calloc(1, sizeof(*tp) + 2 * sz);
798 if (!addr)
799 return NULL;
800
801 tp = addr;
802
803 addr += sizeof(*tp);
804 tp->core_siblings = addr;
805 addr += sz;
806 tp->thread_siblings = addr;
807
808 for (i = 0; i < nr; i++) {
809 ret = build_cpu_topo(tp, i);
810 if (ret < 0)
811 break;
812 }
813 if (ret) {
814 free_cpu_topo(tp);
815 tp = NULL;
816 }
817 return tp;
818 }
819
820 static int write_cpu_topology(int fd, struct perf_header *h __used,
821 struct perf_evlist *evlist __used)
822 {
823 struct cpu_topo *tp;
824 u32 i;
825 int ret;
826
827 tp = build_cpu_topology();
828 if (!tp)
829 return -1;
830
831 ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib));
832 if (ret < 0)
833 goto done;
834
835 for (i = 0; i < tp->core_sib; i++) {
836 ret = do_write_string(fd, tp->core_siblings[i]);
837 if (ret < 0)
838 goto done;
839 }
840 ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib));
841 if (ret < 0)
842 goto done;
843
844 for (i = 0; i < tp->thread_sib; i++) {
845 ret = do_write_string(fd, tp->thread_siblings[i]);
846 if (ret < 0)
847 break;
848 }
849 done:
850 free_cpu_topo(tp);
851 return ret;
852 }
853
854
855
856 static int write_total_mem(int fd, struct perf_header *h __used,
857 struct perf_evlist *evlist __used)
858 {
859 char *buf = NULL;
860 FILE *fp;
861 size_t len = 0;
862 int ret = -1, n;
863 uint64_t mem;
864
865 fp = fopen("/proc/meminfo", "r");
866 if (!fp)
867 return -1;
868
869 while (getline(&buf, &len, fp) > 0) {
870 ret = strncmp(buf, "MemTotal:", 9);
871 if (!ret)
872 break;
873 }
874 if (!ret) {
875 n = sscanf(buf, "%*s %"PRIu64, &mem);
876 if (n == 1)
877 ret = do_write(fd, &mem, sizeof(mem));
878 }
879 free(buf);
880 fclose(fp);
881 return ret;
882 }
883
884 static int write_topo_node(int fd, int node)
885 {
886 char str[MAXPATHLEN];
887 char field[32];
888 char *buf = NULL, *p;
889 size_t len = 0;
890 FILE *fp;
891 u64 mem_total, mem_free, mem;
892 int ret = -1;
893
894 sprintf(str, "/sys/devices/system/node/node%d/meminfo", node);
895 fp = fopen(str, "r");
896 if (!fp)
897 return -1;
898
899 while (getline(&buf, &len, fp) > 0) {
900 /* skip over invalid lines */
901 if (!strchr(buf, ':'))
902 continue;
903 if (sscanf(buf, "%*s %*d %s %"PRIu64, field, &mem) != 2)
904 goto done;
905 if (!strcmp(field, "MemTotal:"))
906 mem_total = mem;
907 if (!strcmp(field, "MemFree:"))
908 mem_free = mem;
909 }
910
911 fclose(fp);
912
913 ret = do_write(fd, &mem_total, sizeof(u64));
914 if (ret)
915 goto done;
916
917 ret = do_write(fd, &mem_free, sizeof(u64));
918 if (ret)
919 goto done;
920
921 ret = -1;
922 sprintf(str, "/sys/devices/system/node/node%d/cpulist", node);
923
924 fp = fopen(str, "r");
925 if (!fp)
926 goto done;
927
928 if (getline(&buf, &len, fp) <= 0)
929 goto done;
930
931 p = strchr(buf, '\n');
932 if (p)
933 *p = '\0';
934
935 ret = do_write_string(fd, buf);
936 done:
937 free(buf);
938 fclose(fp);
939 return ret;
940 }
941
942 static int write_numa_topology(int fd, struct perf_header *h __used,
943 struct perf_evlist *evlist __used)
944 {
945 char *buf = NULL;
946 size_t len = 0;
947 FILE *fp;
948 struct cpu_map *node_map = NULL;
949 char *c;
950 u32 nr, i, j;
951 int ret = -1;
952
953 fp = fopen("/sys/devices/system/node/online", "r");
954 if (!fp)
955 return -1;
956
957 if (getline(&buf, &len, fp) <= 0)
958 goto done;
959
960 c = strchr(buf, '\n');
961 if (c)
962 *c = '\0';
963
964 node_map = cpu_map__new(buf);
965 if (!node_map)
966 goto done;
967
968 nr = (u32)node_map->nr;
969
970 ret = do_write(fd, &nr, sizeof(nr));
971 if (ret < 0)
972 goto done;
973
974 for (i = 0; i < nr; i++) {
975 j = (u32)node_map->map[i];
976 ret = do_write(fd, &j, sizeof(j));
977 if (ret < 0)
978 break;
979
980 ret = write_topo_node(fd, i);
981 if (ret < 0)
982 break;
983 }
984 done:
985 free(buf);
986 fclose(fp);
987 free(node_map);
988 return ret;
989 }
990
991 /*
992 * default get_cpuid(): nothing gets recorded
993 * actual implementation must be in arch/$(ARCH)/util/header.c
994 */
995 int __attribute__((weak)) get_cpuid(char *buffer __used, size_t sz __used)
996 {
997 return -1;
998 }
999
1000 static int write_cpuid(int fd, struct perf_header *h __used,
1001 struct perf_evlist *evlist __used)
1002 {
1003 char buffer[64];
1004 int ret;
1005
1006 ret = get_cpuid(buffer, sizeof(buffer));
1007 if (!ret)
1008 goto write_it;
1009
1010 return -1;
1011 write_it:
1012 return do_write_string(fd, buffer);
1013 }
1014
1015 static void print_hostname(struct perf_header *ph, int fd, FILE *fp)
1016 {
1017 char *str = do_read_string(fd, ph);
1018 fprintf(fp, "# hostname : %s\n", str);
1019 free(str);
1020 }
1021
1022 static void print_osrelease(struct perf_header *ph, int fd, FILE *fp)
1023 {
1024 char *str = do_read_string(fd, ph);
1025 fprintf(fp, "# os release : %s\n", str);
1026 free(str);
1027 }
1028
1029 static void print_arch(struct perf_header *ph, int fd, FILE *fp)
1030 {
1031 char *str = do_read_string(fd, ph);
1032 fprintf(fp, "# arch : %s\n", str);
1033 free(str);
1034 }
1035
1036 static void print_cpudesc(struct perf_header *ph, int fd, FILE *fp)
1037 {
1038 char *str = do_read_string(fd, ph);
1039 fprintf(fp, "# cpudesc : %s\n", str);
1040 free(str);
1041 }
1042
1043 static void print_nrcpus(struct perf_header *ph, int fd, FILE *fp)
1044 {
1045 ssize_t ret;
1046 u32 nr;
1047
1048 ret = read(fd, &nr, sizeof(nr));
1049 if (ret != (ssize_t)sizeof(nr))
1050 nr = -1; /* interpreted as error */
1051
1052 if (ph->needs_swap)
1053 nr = bswap_32(nr);
1054
1055 fprintf(fp, "# nrcpus online : %u\n", nr);
1056
1057 ret = read(fd, &nr, sizeof(nr));
1058 if (ret != (ssize_t)sizeof(nr))
1059 nr = -1; /* interpreted as error */
1060
1061 if (ph->needs_swap)
1062 nr = bswap_32(nr);
1063
1064 fprintf(fp, "# nrcpus avail : %u\n", nr);
1065 }
1066
1067 static void print_version(struct perf_header *ph, int fd, FILE *fp)
1068 {
1069 char *str = do_read_string(fd, ph);
1070 fprintf(fp, "# perf version : %s\n", str);
1071 free(str);
1072 }
1073
1074 static void print_cmdline(struct perf_header *ph, int fd, FILE *fp)
1075 {
1076 ssize_t ret;
1077 char *str;
1078 u32 nr, i;
1079
1080 ret = read(fd, &nr, sizeof(nr));
1081 if (ret != (ssize_t)sizeof(nr))
1082 return;
1083
1084 if (ph->needs_swap)
1085 nr = bswap_32(nr);
1086
1087 fprintf(fp, "# cmdline : ");
1088
1089 for (i = 0; i < nr; i++) {
1090 str = do_read_string(fd, ph);
1091 fprintf(fp, "%s ", str);
1092 free(str);
1093 }
1094 fputc('\n', fp);
1095 }
1096
1097 static void print_cpu_topology(struct perf_header *ph, int fd, FILE *fp)
1098 {
1099 ssize_t ret;
1100 u32 nr, i;
1101 char *str;
1102
1103 ret = read(fd, &nr, sizeof(nr));
1104 if (ret != (ssize_t)sizeof(nr))
1105 return;
1106
1107 if (ph->needs_swap)
1108 nr = bswap_32(nr);
1109
1110 for (i = 0; i < nr; i++) {
1111 str = do_read_string(fd, ph);
1112 fprintf(fp, "# sibling cores : %s\n", str);
1113 free(str);
1114 }
1115
1116 ret = read(fd, &nr, sizeof(nr));
1117 if (ret != (ssize_t)sizeof(nr))
1118 return;
1119
1120 if (ph->needs_swap)
1121 nr = bswap_32(nr);
1122
1123 for (i = 0; i < nr; i++) {
1124 str = do_read_string(fd, ph);
1125 fprintf(fp, "# sibling threads : %s\n", str);
1126 free(str);
1127 }
1128 }
1129
1130 static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
1131 {
1132 struct perf_event_attr attr;
1133 uint64_t id;
1134 void *buf = NULL;
1135 char *str;
1136 u32 nre, sz, nr, i, j, msz;
1137 int ret;
1138
1139 /* number of events */
1140 ret = read(fd, &nre, sizeof(nre));
1141 if (ret != (ssize_t)sizeof(nre))
1142 goto error;
1143
1144 if (ph->needs_swap)
1145 nre = bswap_32(nre);
1146
1147 ret = read(fd, &sz, sizeof(sz));
1148 if (ret != (ssize_t)sizeof(sz))
1149 goto error;
1150
1151 if (ph->needs_swap)
1152 sz = bswap_32(sz);
1153
1154 /*
1155 * ensure it is at least to our ABI rev
1156 */
1157 if (sz < (u32)sizeof(attr))
1158 goto error;
1159
1160 memset(&attr, 0, sizeof(attr));
1161
1162 /* read entire region to sync up to next field */
1163 buf = malloc(sz);
1164 if (!buf)
1165 goto error;
1166
1167 msz = sizeof(attr);
1168 if (sz < msz)
1169 msz = sz;
1170
1171 for (i = 0 ; i < nre; i++) {
1172
1173 ret = read(fd, buf, sz);
1174 if (ret != (ssize_t)sz)
1175 goto error;
1176
1177 if (ph->needs_swap)
1178 perf_event__attr_swap(buf);
1179
1180 memcpy(&attr, buf, msz);
1181
1182 ret = read(fd, &nr, sizeof(nr));
1183 if (ret != (ssize_t)sizeof(nr))
1184 goto error;
1185
1186 if (ph->needs_swap)
1187 nr = bswap_32(nr);
1188
1189 str = do_read_string(fd, ph);
1190 fprintf(fp, "# event : name = %s, ", str);
1191 free(str);
1192
1193 fprintf(fp, "type = %d, config = 0x%"PRIx64
1194 ", config1 = 0x%"PRIx64", config2 = 0x%"PRIx64,
1195 attr.type,
1196 (u64)attr.config,
1197 (u64)attr.config1,
1198 (u64)attr.config2);
1199
1200 fprintf(fp, ", excl_usr = %d, excl_kern = %d",
1201 attr.exclude_user,
1202 attr.exclude_kernel);
1203
1204 if (nr)
1205 fprintf(fp, ", id = {");
1206
1207 for (j = 0 ; j < nr; j++) {
1208 ret = read(fd, &id, sizeof(id));
1209 if (ret != (ssize_t)sizeof(id))
1210 goto error;
1211
1212 if (ph->needs_swap)
1213 id = bswap_64(id);
1214
1215 if (j)
1216 fputc(',', fp);
1217
1218 fprintf(fp, " %"PRIu64, id);
1219 }
1220 if (nr && j == nr)
1221 fprintf(fp, " }");
1222 fputc('\n', fp);
1223 }
1224 free(buf);
1225 return;
1226 error:
1227 fprintf(fp, "# event desc: not available or unable to read\n");
1228 }
1229
1230 static void print_total_mem(struct perf_header *h __used, int fd, FILE *fp)
1231 {
1232 uint64_t mem;
1233 ssize_t ret;
1234
1235 ret = read(fd, &mem, sizeof(mem));
1236 if (ret != sizeof(mem))
1237 goto error;
1238
1239 if (h->needs_swap)
1240 mem = bswap_64(mem);
1241
1242 fprintf(fp, "# total memory : %"PRIu64" kB\n", mem);
1243 return;
1244 error:
1245 fprintf(fp, "# total memory : unknown\n");
1246 }
1247
1248 static void print_numa_topology(struct perf_header *h __used, int fd, FILE *fp)
1249 {
1250 ssize_t ret;
1251 u32 nr, c, i;
1252 char *str;
1253 uint64_t mem_total, mem_free;
1254
1255 /* nr nodes */
1256 ret = read(fd, &nr, sizeof(nr));
1257 if (ret != (ssize_t)sizeof(nr))
1258 goto error;
1259
1260 if (h->needs_swap)
1261 nr = bswap_32(nr);
1262
1263 for (i = 0; i < nr; i++) {
1264
1265 /* node number */
1266 ret = read(fd, &c, sizeof(c));
1267 if (ret != (ssize_t)sizeof(c))
1268 goto error;
1269
1270 if (h->needs_swap)
1271 c = bswap_32(c);
1272
1273 ret = read(fd, &mem_total, sizeof(u64));
1274 if (ret != sizeof(u64))
1275 goto error;
1276
1277 ret = read(fd, &mem_free, sizeof(u64));
1278 if (ret != sizeof(u64))
1279 goto error;
1280
1281 if (h->needs_swap) {
1282 mem_total = bswap_64(mem_total);
1283 mem_free = bswap_64(mem_free);
1284 }
1285
1286 fprintf(fp, "# node%u meminfo : total = %"PRIu64" kB,"
1287 " free = %"PRIu64" kB\n",
1288 c,
1289 mem_total,
1290 mem_free);
1291
1292 str = do_read_string(fd, h);
1293 fprintf(fp, "# node%u cpu list : %s\n", c, str);
1294 free(str);
1295 }
1296 return;
1297 error:
1298 fprintf(fp, "# numa topology : not available\n");
1299 }
1300
1301 static void print_cpuid(struct perf_header *ph, int fd, FILE *fp)
1302 {
1303 char *str = do_read_string(fd, ph);
1304 fprintf(fp, "# cpuid : %s\n", str);
1305 free(str);
1306 }
1307
1308 struct feature_ops {
1309 int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
1310 void (*print)(struct perf_header *h, int fd, FILE *fp);
1311 const char *name;
1312 bool full_only;
1313 };
1314
1315 #define FEAT_OPA(n, func) \
1316 [n] = { .name = #n, .write = write_##func, .print = print_##func }
1317 #define FEAT_OPF(n, func) \
1318 [n] = { .name = #n, .write = write_##func, .print = print_##func, .full_only = true }
1319
1320 /* feature_ops not implemented: */
1321 #define print_trace_info NULL
1322 #define print_build_id NULL
1323
1324 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
1325 FEAT_OPA(HEADER_TRACE_INFO, trace_info),
1326 FEAT_OPA(HEADER_BUILD_ID, build_id),
1327 FEAT_OPA(HEADER_HOSTNAME, hostname),
1328 FEAT_OPA(HEADER_OSRELEASE, osrelease),
1329 FEAT_OPA(HEADER_VERSION, version),
1330 FEAT_OPA(HEADER_ARCH, arch),
1331 FEAT_OPA(HEADER_NRCPUS, nrcpus),
1332 FEAT_OPA(HEADER_CPUDESC, cpudesc),
1333 FEAT_OPA(HEADER_CPUID, cpuid),
1334 FEAT_OPA(HEADER_TOTAL_MEM, total_mem),
1335 FEAT_OPA(HEADER_EVENT_DESC, event_desc),
1336 FEAT_OPA(HEADER_CMDLINE, cmdline),
1337 FEAT_OPF(HEADER_CPU_TOPOLOGY, cpu_topology),
1338 FEAT_OPF(HEADER_NUMA_TOPOLOGY, numa_topology),
1339 };
1340
1341 struct header_print_data {
1342 FILE *fp;
1343 bool full; /* extended list of headers */
1344 };
1345
1346 static int perf_file_section__fprintf_info(struct perf_file_section *section,
1347 struct perf_header *ph,
1348 int feat, int fd, void *data)
1349 {
1350 struct header_print_data *hd = data;
1351
1352 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
1353 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
1354 "%d, continuing...\n", section->offset, feat);
1355 return 0;
1356 }
1357 if (feat >= HEADER_LAST_FEATURE) {
1358 pr_warning("unknown feature %d\n", feat);
1359 return 0;
1360 }
1361 if (!feat_ops[feat].print)
1362 return 0;
1363
1364 if (!feat_ops[feat].full_only || hd->full)
1365 feat_ops[feat].print(ph, fd, hd->fp);
1366 else
1367 fprintf(hd->fp, "# %s info available, use -I to display\n",
1368 feat_ops[feat].name);
1369
1370 return 0;
1371 }
1372
1373 int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
1374 {
1375 struct header_print_data hd;
1376 struct perf_header *header = &session->header;
1377 int fd = session->fd;
1378 hd.fp = fp;
1379 hd.full = full;
1380
1381 perf_header__process_sections(header, fd, &hd,
1382 perf_file_section__fprintf_info);
1383 return 0;
1384 }
1385
1386 static int do_write_feat(int fd, struct perf_header *h, int type,
1387 struct perf_file_section **p,
1388 struct perf_evlist *evlist)
1389 {
1390 int err;
1391 int ret = 0;
1392
1393 if (perf_header__has_feat(h, type)) {
1394 if (!feat_ops[type].write)
1395 return -1;
1396
1397 (*p)->offset = lseek(fd, 0, SEEK_CUR);
1398
1399 err = feat_ops[type].write(fd, h, evlist);
1400 if (err < 0) {
1401 pr_debug("failed to write feature %d\n", type);
1402
1403 /* undo anything written */
1404 lseek(fd, (*p)->offset, SEEK_SET);
1405
1406 return -1;
1407 }
1408 (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
1409 (*p)++;
1410 }
1411 return ret;
1412 }
1413
1414 static int perf_header__adds_write(struct perf_header *header,
1415 struct perf_evlist *evlist, int fd)
1416 {
1417 int nr_sections;
1418 struct perf_file_section *feat_sec, *p;
1419 int sec_size;
1420 u64 sec_start;
1421 int feat;
1422 int err;
1423
1424 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
1425 if (!nr_sections)
1426 return 0;
1427
1428 feat_sec = p = calloc(sizeof(*feat_sec), nr_sections);
1429 if (feat_sec == NULL)
1430 return -ENOMEM;
1431
1432 sec_size = sizeof(*feat_sec) * nr_sections;
1433
1434 sec_start = header->data_offset + header->data_size;
1435 lseek(fd, sec_start + sec_size, SEEK_SET);
1436
1437 for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
1438 if (do_write_feat(fd, header, feat, &p, evlist))
1439 perf_header__clear_feat(header, feat);
1440 }
1441
1442 lseek(fd, sec_start, SEEK_SET);
1443 /*
1444 * may write more than needed due to dropped feature, but
1445 * this is okay, reader will skip the mising entries
1446 */
1447 err = do_write(fd, feat_sec, sec_size);
1448 if (err < 0)
1449 pr_debug("failed to write feature section\n");
1450 free(feat_sec);
1451 return err;
1452 }
1453
1454 int perf_header__write_pipe(int fd)
1455 {
1456 struct perf_pipe_file_header f_header;
1457 int err;
1458
1459 f_header = (struct perf_pipe_file_header){
1460 .magic = PERF_MAGIC,
1461 .size = sizeof(f_header),
1462 };
1463
1464 err = do_write(fd, &f_header, sizeof(f_header));
1465 if (err < 0) {
1466 pr_debug("failed to write perf pipe header\n");
1467 return err;
1468 }
1469
1470 return 0;
1471 }
1472
1473 int perf_session__write_header(struct perf_session *session,
1474 struct perf_evlist *evlist,
1475 int fd, bool at_exit)
1476 {
1477 struct perf_file_header f_header;
1478 struct perf_file_attr f_attr;
1479 struct perf_header *header = &session->header;
1480 struct perf_evsel *attr, *pair = NULL;
1481 int err;
1482
1483 lseek(fd, sizeof(f_header), SEEK_SET);
1484
1485 if (session->evlist != evlist)
1486 pair = list_entry(session->evlist->entries.next, struct perf_evsel, node);
1487
1488 list_for_each_entry(attr, &evlist->entries, node) {
1489 attr->id_offset = lseek(fd, 0, SEEK_CUR);
1490 err = do_write(fd, attr->id, attr->ids * sizeof(u64));
1491 if (err < 0) {
1492 out_err_write:
1493 pr_debug("failed to write perf header\n");
1494 return err;
1495 }
1496 if (session->evlist != evlist) {
1497 err = do_write(fd, pair->id, pair->ids * sizeof(u64));
1498 if (err < 0)
1499 goto out_err_write;
1500 attr->ids += pair->ids;
1501 pair = list_entry(pair->node.next, struct perf_evsel, node);
1502 }
1503 }
1504
1505 header->attr_offset = lseek(fd, 0, SEEK_CUR);
1506
1507 list_for_each_entry(attr, &evlist->entries, node) {
1508 f_attr = (struct perf_file_attr){
1509 .attr = attr->attr,
1510 .ids = {
1511 .offset = attr->id_offset,
1512 .size = attr->ids * sizeof(u64),
1513 }
1514 };
1515 err = do_write(fd, &f_attr, sizeof(f_attr));
1516 if (err < 0) {
1517 pr_debug("failed to write perf header attribute\n");
1518 return err;
1519 }
1520 }
1521
1522 header->event_offset = lseek(fd, 0, SEEK_CUR);
1523 header->event_size = event_count * sizeof(struct perf_trace_event_type);
1524 if (events) {
1525 err = do_write(fd, events, header->event_size);
1526 if (err < 0) {
1527 pr_debug("failed to write perf header events\n");
1528 return err;
1529 }
1530 }
1531
1532 header->data_offset = lseek(fd, 0, SEEK_CUR);
1533
1534 if (at_exit) {
1535 err = perf_header__adds_write(header, evlist, fd);
1536 if (err < 0)
1537 return err;
1538 }
1539
1540 f_header = (struct perf_file_header){
1541 .magic = PERF_MAGIC,
1542 .size = sizeof(f_header),
1543 .attr_size = sizeof(f_attr),
1544 .attrs = {
1545 .offset = header->attr_offset,
1546 .size = evlist->nr_entries * sizeof(f_attr),
1547 },
1548 .data = {
1549 .offset = header->data_offset,
1550 .size = header->data_size,
1551 },
1552 .event_types = {
1553 .offset = header->event_offset,
1554 .size = header->event_size,
1555 },
1556 };
1557
1558 memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
1559
1560 lseek(fd, 0, SEEK_SET);
1561 err = do_write(fd, &f_header, sizeof(f_header));
1562 if (err < 0) {
1563 pr_debug("failed to write perf header\n");
1564 return err;
1565 }
1566 lseek(fd, header->data_offset + header->data_size, SEEK_SET);
1567
1568 header->frozen = 1;
1569 return 0;
1570 }
1571
1572 static int perf_header__getbuffer64(struct perf_header *header,
1573 int fd, void *buf, size_t size)
1574 {
1575 if (readn(fd, buf, size) <= 0)
1576 return -1;
1577
1578 if (header->needs_swap)
1579 mem_bswap_64(buf, size);
1580
1581 return 0;
1582 }
1583
1584 int perf_header__process_sections(struct perf_header *header, int fd,
1585 void *data,
1586 int (*process)(struct perf_file_section *section,
1587 struct perf_header *ph,
1588 int feat, int fd, void *data))
1589 {
1590 struct perf_file_section *feat_sec, *sec;
1591 int nr_sections;
1592 int sec_size;
1593 int feat;
1594 int err;
1595
1596 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
1597 if (!nr_sections)
1598 return 0;
1599
1600 feat_sec = sec = calloc(sizeof(*feat_sec), nr_sections);
1601 if (!feat_sec)
1602 return -1;
1603
1604 sec_size = sizeof(*feat_sec) * nr_sections;
1605
1606 lseek(fd, header->data_offset + header->data_size, SEEK_SET);
1607
1608 err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
1609 if (err < 0)
1610 goto out_free;
1611
1612 for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
1613 err = process(sec++, header, feat, fd, data);
1614 if (err < 0)
1615 goto out_free;
1616 }
1617 err = 0;
1618 out_free:
1619 free(feat_sec);
1620 return err;
1621 }
1622
1623 int perf_file_header__read(struct perf_file_header *header,
1624 struct perf_header *ph, int fd)
1625 {
1626 lseek(fd, 0, SEEK_SET);
1627
1628 if (readn(fd, header, sizeof(*header)) <= 0 ||
1629 memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
1630 return -1;
1631
1632 if (header->attr_size != sizeof(struct perf_file_attr)) {
1633 u64 attr_size = bswap_64(header->attr_size);
1634
1635 if (attr_size != sizeof(struct perf_file_attr))
1636 return -1;
1637
1638 mem_bswap_64(header, offsetof(struct perf_file_header,
1639 adds_features));
1640 ph->needs_swap = true;
1641 }
1642
1643 if (header->size != sizeof(*header)) {
1644 /* Support the previous format */
1645 if (header->size == offsetof(typeof(*header), adds_features))
1646 bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
1647 else
1648 return -1;
1649 } else if (ph->needs_swap) {
1650 unsigned int i;
1651 /*
1652 * feature bitmap is declared as an array of unsigned longs --
1653 * not good since its size can differ between the host that
1654 * generated the data file and the host analyzing the file.
1655 *
1656 * We need to handle endianness, but we don't know the size of
1657 * the unsigned long where the file was generated. Take a best
1658 * guess at determining it: try 64-bit swap first (ie., file
1659 * created on a 64-bit host), and check if the hostname feature
1660 * bit is set (this feature bit is forced on as of fbe96f2).
1661 * If the bit is not, undo the 64-bit swap and try a 32-bit
1662 * swap. If the hostname bit is still not set (e.g., older data
1663 * file), punt and fallback to the original behavior --
1664 * clearing all feature bits and setting buildid.
1665 */
1666 for (i = 0; i < BITS_TO_LONGS(HEADER_FEAT_BITS); ++i)
1667 header->adds_features[i] = bswap_64(header->adds_features[i]);
1668
1669 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
1670 for (i = 0; i < BITS_TO_LONGS(HEADER_FEAT_BITS); ++i) {
1671 header->adds_features[i] = bswap_64(header->adds_features[i]);
1672 header->adds_features[i] = bswap_32(header->adds_features[i]);
1673 }
1674 }
1675
1676 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
1677 bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
1678 set_bit(HEADER_BUILD_ID, header->adds_features);
1679 }
1680 }
1681
1682 memcpy(&ph->adds_features, &header->adds_features,
1683 sizeof(ph->adds_features));
1684
1685 ph->event_offset = header->event_types.offset;
1686 ph->event_size = header->event_types.size;
1687 ph->data_offset = header->data.offset;
1688 ph->data_size = header->data.size;
1689 return 0;
1690 }
1691
1692 static int __event_process_build_id(struct build_id_event *bev,
1693 char *filename,
1694 struct perf_session *session)
1695 {
1696 int err = -1;
1697 struct list_head *head;
1698 struct machine *machine;
1699 u16 misc;
1700 struct dso *dso;
1701 enum dso_kernel_type dso_type;
1702
1703 machine = perf_session__findnew_machine(session, bev->pid);
1704 if (!machine)
1705 goto out;
1706
1707 misc = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
1708
1709 switch (misc) {
1710 case PERF_RECORD_MISC_KERNEL:
1711 dso_type = DSO_TYPE_KERNEL;
1712 head = &machine->kernel_dsos;
1713 break;
1714 case PERF_RECORD_MISC_GUEST_KERNEL:
1715 dso_type = DSO_TYPE_GUEST_KERNEL;
1716 head = &machine->kernel_dsos;
1717 break;
1718 case PERF_RECORD_MISC_USER:
1719 case PERF_RECORD_MISC_GUEST_USER:
1720 dso_type = DSO_TYPE_USER;
1721 head = &machine->user_dsos;
1722 break;
1723 default:
1724 goto out;
1725 }
1726
1727 dso = __dsos__findnew(head, filename);
1728 if (dso != NULL) {
1729 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1730
1731 dso__set_build_id(dso, &bev->build_id);
1732
1733 if (filename[0] == '[')
1734 dso->kernel = dso_type;
1735
1736 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
1737 sbuild_id);
1738 pr_debug("build id event received for %s: %s\n",
1739 dso->long_name, sbuild_id);
1740 }
1741
1742 err = 0;
1743 out:
1744 return err;
1745 }
1746
1747 static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
1748 int input, u64 offset, u64 size)
1749 {
1750 struct perf_session *session = container_of(header, struct perf_session, header);
1751 struct {
1752 struct perf_event_header header;
1753 u8 build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
1754 char filename[0];
1755 } old_bev;
1756 struct build_id_event bev;
1757 char filename[PATH_MAX];
1758 u64 limit = offset + size;
1759
1760 while (offset < limit) {
1761 ssize_t len;
1762
1763 if (read(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
1764 return -1;
1765
1766 if (header->needs_swap)
1767 perf_event_header__bswap(&old_bev.header);
1768
1769 len = old_bev.header.size - sizeof(old_bev);
1770 if (read(input, filename, len) != len)
1771 return -1;
1772
1773 bev.header = old_bev.header;
1774
1775 /*
1776 * As the pid is the missing value, we need to fill
1777 * it properly. The header.misc value give us nice hint.
1778 */
1779 bev.pid = HOST_KERNEL_ID;
1780 if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
1781 bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
1782 bev.pid = DEFAULT_GUEST_KERNEL_ID;
1783
1784 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
1785 __event_process_build_id(&bev, filename, session);
1786
1787 offset += bev.header.size;
1788 }
1789
1790 return 0;
1791 }
1792
1793 static int perf_header__read_build_ids(struct perf_header *header,
1794 int input, u64 offset, u64 size)
1795 {
1796 struct perf_session *session = container_of(header, struct perf_session, header);
1797 struct build_id_event bev;
1798 char filename[PATH_MAX];
1799 u64 limit = offset + size, orig_offset = offset;
1800 int err = -1;
1801
1802 while (offset < limit) {
1803 ssize_t len;
1804
1805 if (read(input, &bev, sizeof(bev)) != sizeof(bev))
1806 goto out;
1807
1808 if (header->needs_swap)
1809 perf_event_header__bswap(&bev.header);
1810
1811 len = bev.header.size - sizeof(bev);
1812 if (read(input, filename, len) != len)
1813 goto out;
1814 /*
1815 * The a1645ce1 changeset:
1816 *
1817 * "perf: 'perf kvm' tool for monitoring guest performance from host"
1818 *
1819 * Added a field to struct build_id_event that broke the file
1820 * format.
1821 *
1822 * Since the kernel build-id is the first entry, process the
1823 * table using the old format if the well known
1824 * '[kernel.kallsyms]' string for the kernel build-id has the
1825 * first 4 characters chopped off (where the pid_t sits).
1826 */
1827 if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
1828 if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
1829 return -1;
1830 return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
1831 }
1832
1833 __event_process_build_id(&bev, filename, session);
1834
1835 offset += bev.header.size;
1836 }
1837 err = 0;
1838 out:
1839 return err;
1840 }
1841
1842 static int perf_file_section__process(struct perf_file_section *section,
1843 struct perf_header *ph,
1844 int feat, int fd, void *data __used)
1845 {
1846 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
1847 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
1848 "%d, continuing...\n", section->offset, feat);
1849 return 0;
1850 }
1851
1852 if (feat >= HEADER_LAST_FEATURE) {
1853 pr_debug("unknown feature %d, continuing...\n", feat);
1854 return 0;
1855 }
1856
1857 switch (feat) {
1858 case HEADER_TRACE_INFO:
1859 trace_report(fd, false);
1860 break;
1861 case HEADER_BUILD_ID:
1862 if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
1863 pr_debug("Failed to read buildids, continuing...\n");
1864 break;
1865 default:
1866 break;
1867 }
1868
1869 return 0;
1870 }
1871
1872 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
1873 struct perf_header *ph, int fd,
1874 bool repipe)
1875 {
1876 if (readn(fd, header, sizeof(*header)) <= 0 ||
1877 memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
1878 return -1;
1879
1880 if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
1881 return -1;
1882
1883 if (header->size != sizeof(*header)) {
1884 u64 size = bswap_64(header->size);
1885
1886 if (size != sizeof(*header))
1887 return -1;
1888
1889 ph->needs_swap = true;
1890 }
1891
1892 return 0;
1893 }
1894
1895 static int perf_header__read_pipe(struct perf_session *session, int fd)
1896 {
1897 struct perf_header *header = &session->header;
1898 struct perf_pipe_file_header f_header;
1899
1900 if (perf_file_header__read_pipe(&f_header, header, fd,
1901 session->repipe) < 0) {
1902 pr_debug("incompatible file format\n");
1903 return -EINVAL;
1904 }
1905
1906 session->fd = fd;
1907
1908 return 0;
1909 }
1910
1911 int perf_session__read_header(struct perf_session *session, int fd)
1912 {
1913 struct perf_header *header = &session->header;
1914 struct perf_file_header f_header;
1915 struct perf_file_attr f_attr;
1916 u64 f_id;
1917 int nr_attrs, nr_ids, i, j;
1918
1919 session->evlist = perf_evlist__new(NULL, NULL);
1920 if (session->evlist == NULL)
1921 return -ENOMEM;
1922
1923 if (session->fd_pipe)
1924 return perf_header__read_pipe(session, fd);
1925
1926 if (perf_file_header__read(&f_header, header, fd) < 0) {
1927 pr_debug("incompatible file format\n");
1928 return -EINVAL;
1929 }
1930
1931 nr_attrs = f_header.attrs.size / sizeof(f_attr);
1932 lseek(fd, f_header.attrs.offset, SEEK_SET);
1933
1934 for (i = 0; i < nr_attrs; i++) {
1935 struct perf_evsel *evsel;
1936 off_t tmp;
1937
1938 if (readn(fd, &f_attr, sizeof(f_attr)) <= 0)
1939 goto out_errno;
1940
1941 if (header->needs_swap)
1942 perf_event__attr_swap(&f_attr.attr);
1943
1944 tmp = lseek(fd, 0, SEEK_CUR);
1945 evsel = perf_evsel__new(&f_attr.attr, i);
1946
1947 if (evsel == NULL)
1948 goto out_delete_evlist;
1949 /*
1950 * Do it before so that if perf_evsel__alloc_id fails, this
1951 * entry gets purged too at perf_evlist__delete().
1952 */
1953 perf_evlist__add(session->evlist, evsel);
1954
1955 nr_ids = f_attr.ids.size / sizeof(u64);
1956 /*
1957 * We don't have the cpu and thread maps on the header, so
1958 * for allocating the perf_sample_id table we fake 1 cpu and
1959 * hattr->ids threads.
1960 */
1961 if (perf_evsel__alloc_id(evsel, 1, nr_ids))
1962 goto out_delete_evlist;
1963
1964 lseek(fd, f_attr.ids.offset, SEEK_SET);
1965
1966 for (j = 0; j < nr_ids; j++) {
1967 if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
1968 goto out_errno;
1969
1970 perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
1971 }
1972
1973 lseek(fd, tmp, SEEK_SET);
1974 }
1975
1976 symbol_conf.nr_events = nr_attrs;
1977
1978 if (f_header.event_types.size) {
1979 lseek(fd, f_header.event_types.offset, SEEK_SET);
1980 events = malloc(f_header.event_types.size);
1981 if (events == NULL)
1982 return -ENOMEM;
1983 if (perf_header__getbuffer64(header, fd, events,
1984 f_header.event_types.size))
1985 goto out_errno;
1986 event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type);
1987 }
1988
1989 perf_header__process_sections(header, fd, NULL,
1990 perf_file_section__process);
1991
1992 lseek(fd, header->data_offset, SEEK_SET);
1993
1994 header->frozen = 1;
1995 return 0;
1996 out_errno:
1997 return -errno;
1998
1999 out_delete_evlist:
2000 perf_evlist__delete(session->evlist);
2001 session->evlist = NULL;
2002 return -ENOMEM;
2003 }
2004
2005 int perf_event__synthesize_attr(struct perf_tool *tool,
2006 struct perf_event_attr *attr, u16 ids, u64 *id,
2007 perf_event__handler_t process)
2008 {
2009 union perf_event *ev;
2010 size_t size;
2011 int err;
2012
2013 size = sizeof(struct perf_event_attr);
2014 size = ALIGN(size, sizeof(u64));
2015 size += sizeof(struct perf_event_header);
2016 size += ids * sizeof(u64);
2017
2018 ev = malloc(size);
2019
2020 if (ev == NULL)
2021 return -ENOMEM;
2022
2023 ev->attr.attr = *attr;
2024 memcpy(ev->attr.id, id, ids * sizeof(u64));
2025
2026 ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
2027 ev->attr.header.size = size;
2028
2029 err = process(tool, ev, NULL, NULL);
2030
2031 free(ev);
2032
2033 return err;
2034 }
2035
2036 int perf_event__synthesize_attrs(struct perf_tool *tool,
2037 struct perf_session *session,
2038 perf_event__handler_t process)
2039 {
2040 struct perf_evsel *attr;
2041 int err = 0;
2042
2043 list_for_each_entry(attr, &session->evlist->entries, node) {
2044 err = perf_event__synthesize_attr(tool, &attr->attr, attr->ids,
2045 attr->id, process);
2046 if (err) {
2047 pr_debug("failed to create perf header attribute\n");
2048 return err;
2049 }
2050 }
2051
2052 return err;
2053 }
2054
2055 int perf_event__process_attr(union perf_event *event,
2056 struct perf_evlist **pevlist)
2057 {
2058 unsigned int i, ids, n_ids;
2059 struct perf_evsel *evsel;
2060 struct perf_evlist *evlist = *pevlist;
2061
2062 if (evlist == NULL) {
2063 *pevlist = evlist = perf_evlist__new(NULL, NULL);
2064 if (evlist == NULL)
2065 return -ENOMEM;
2066 }
2067
2068 evsel = perf_evsel__new(&event->attr.attr, evlist->nr_entries);
2069 if (evsel == NULL)
2070 return -ENOMEM;
2071
2072 perf_evlist__add(evlist, evsel);
2073
2074 ids = event->header.size;
2075 ids -= (void *)&event->attr.id - (void *)event;
2076 n_ids = ids / sizeof(u64);
2077 /*
2078 * We don't have the cpu and thread maps on the header, so
2079 * for allocating the perf_sample_id table we fake 1 cpu and
2080 * hattr->ids threads.
2081 */
2082 if (perf_evsel__alloc_id(evsel, 1, n_ids))
2083 return -ENOMEM;
2084
2085 for (i = 0; i < n_ids; i++) {
2086 perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]);
2087 }
2088
2089 return 0;
2090 }
2091
2092 int perf_event__synthesize_event_type(struct perf_tool *tool,
2093 u64 event_id, char *name,
2094 perf_event__handler_t process,
2095 struct machine *machine)
2096 {
2097 union perf_event ev;
2098 size_t size = 0;
2099 int err = 0;
2100
2101 memset(&ev, 0, sizeof(ev));
2102
2103 ev.event_type.event_type.event_id = event_id;
2104 memset(ev.event_type.event_type.name, 0, MAX_EVENT_NAME);
2105 strncpy(ev.event_type.event_type.name, name, MAX_EVENT_NAME - 1);
2106
2107 ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
2108 size = strlen(ev.event_type.event_type.name);
2109 size = ALIGN(size, sizeof(u64));
2110 ev.event_type.header.size = sizeof(ev.event_type) -
2111 (sizeof(ev.event_type.event_type.name) - size);
2112
2113 err = process(tool, &ev, NULL, machine);
2114
2115 return err;
2116 }
2117
2118 int perf_event__synthesize_event_types(struct perf_tool *tool,
2119 perf_event__handler_t process,
2120 struct machine *machine)
2121 {
2122 struct perf_trace_event_type *type;
2123 int i, err = 0;
2124
2125 for (i = 0; i < event_count; i++) {
2126 type = &events[i];
2127
2128 err = perf_event__synthesize_event_type(tool, type->event_id,
2129 type->name, process,
2130 machine);
2131 if (err) {
2132 pr_debug("failed to create perf header event type\n");
2133 return err;
2134 }
2135 }
2136
2137 return err;
2138 }
2139
2140 int perf_event__process_event_type(struct perf_tool *tool __unused,
2141 union perf_event *event)
2142 {
2143 if (perf_header__push_event(event->event_type.event_type.event_id,
2144 event->event_type.event_type.name) < 0)
2145 return -ENOMEM;
2146
2147 return 0;
2148 }
2149
2150 int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
2151 struct perf_evlist *evlist,
2152 perf_event__handler_t process)
2153 {
2154 union perf_event ev;
2155 struct tracing_data *tdata;
2156 ssize_t size = 0, aligned_size = 0, padding;
2157 int err __used = 0;
2158
2159 /*
2160 * We are going to store the size of the data followed
2161 * by the data contents. Since the fd descriptor is a pipe,
2162 * we cannot seek back to store the size of the data once
2163 * we know it. Instead we:
2164 *
2165 * - write the tracing data to the temp file
2166 * - get/write the data size to pipe
2167 * - write the tracing data from the temp file
2168 * to the pipe
2169 */
2170 tdata = tracing_data_get(&evlist->entries, fd, true);
2171 if (!tdata)
2172 return -1;
2173
2174 memset(&ev, 0, sizeof(ev));
2175
2176 ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
2177 size = tdata->size;
2178 aligned_size = ALIGN(size, sizeof(u64));
2179 padding = aligned_size - size;
2180 ev.tracing_data.header.size = sizeof(ev.tracing_data);
2181 ev.tracing_data.size = aligned_size;
2182
2183 process(tool, &ev, NULL, NULL);
2184
2185 /*
2186 * The put function will copy all the tracing data
2187 * stored in temp file to the pipe.
2188 */
2189 tracing_data_put(tdata);
2190
2191 write_padded(fd, NULL, 0, padding);
2192
2193 return aligned_size;
2194 }
2195
2196 int perf_event__process_tracing_data(union perf_event *event,
2197 struct perf_session *session)
2198 {
2199 ssize_t size_read, padding, size = event->tracing_data.size;
2200 off_t offset = lseek(session->fd, 0, SEEK_CUR);
2201 char buf[BUFSIZ];
2202
2203 /* setup for reading amidst mmap */
2204 lseek(session->fd, offset + sizeof(struct tracing_data_event),
2205 SEEK_SET);
2206
2207 size_read = trace_report(session->fd, session->repipe);
2208
2209 padding = ALIGN(size_read, sizeof(u64)) - size_read;
2210
2211 if (read(session->fd, buf, padding) < 0)
2212 die("reading input file");
2213 if (session->repipe) {
2214 int retw = write(STDOUT_FILENO, buf, padding);
2215 if (retw <= 0 || retw != padding)
2216 die("repiping tracing data padding");
2217 }
2218
2219 if (size_read + padding != size)
2220 die("tracing data size mismatch");
2221
2222 return size_read + padding;
2223 }
2224
2225 int perf_event__synthesize_build_id(struct perf_tool *tool,
2226 struct dso *pos, u16 misc,
2227 perf_event__handler_t process,
2228 struct machine *machine)
2229 {
2230 union perf_event ev;
2231 size_t len;
2232 int err = 0;
2233
2234 if (!pos->hit)
2235 return err;
2236
2237 memset(&ev, 0, sizeof(ev));
2238
2239 len = pos->long_name_len + 1;
2240 len = ALIGN(len, NAME_ALIGN);
2241 memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
2242 ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
2243 ev.build_id.header.misc = misc;
2244 ev.build_id.pid = machine->pid;
2245 ev.build_id.header.size = sizeof(ev.build_id) + len;
2246 memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
2247
2248 err = process(tool, &ev, NULL, machine);
2249
2250 return err;
2251 }
2252
2253 int perf_event__process_build_id(struct perf_tool *tool __used,
2254 union perf_event *event,
2255 struct perf_session *session)
2256 {
2257 __event_process_build_id(&event->build_id,
2258 event->build_id.filename,
2259 session);
2260 return 0;
2261 }
2262
2263 void disable_buildid_cache(void)
2264 {
2265 no_buildid_cache = true;
2266 }