?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / tools / perf / util / header.c
blob3451e542b69a8c603a8a39d02c5afa08ad5cd61e
1 // SPDX-License-Identifier: GPL-2.0
2 #include <errno.h>
3 #include <inttypes.h>
4 #include "string2.h"
5 #include <sys/param.h>
6 #include <sys/types.h>
7 #include <byteswap.h>
8 #include <unistd.h>
9 #include <regex.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <linux/compiler.h>
13 #include <linux/list.h>
14 #include <linux/kernel.h>
15 #include <linux/bitops.h>
16 #include <linux/string.h>
17 #include <linux/stringify.h>
18 #include <linux/zalloc.h>
19 #include <sys/stat.h>
20 #include <sys/utsname.h>
21 #include <linux/time64.h>
22 #include <dirent.h>
23 #ifdef HAVE_LIBBPF_SUPPORT
24 #include <bpf/libbpf.h>
25 #endif
26 #include <perf/cpumap.h>
27 #include <tools/libc_compat.h> // reallocarray
28
29 #include "dso.h"
30 #include "evlist.h"
31 #include "evsel.h"
32 #include "util/evsel_fprintf.h"
33 #include "header.h"
34 #include "memswap.h"
35 #include "trace-event.h"
36 #include "session.h"
37 #include "symbol.h"
38 #include "debug.h"
39 #include "cpumap.h"
40 #include "pmu.h"
41 #include "pmus.h"
42 #include "vdso.h"
43 #include "strbuf.h"
44 #include "build-id.h"
45 #include "data.h"
46 #include <api/fs/fs.h>
47 #include "asm/bug.h"
48 #include "tool.h"
49 #include "time-utils.h"
50 #include "units.h"
51 #include "util/util.h" // perf_exe()
52 #include "cputopo.h"
53 #include "bpf-event.h"
54 #include "bpf-utils.h"
55 #include "clockid.h"
56
57 #include <linux/ctype.h>
58 #include <internal/lib.h>
59
60 #ifdef HAVE_LIBTRACEEVENT
61 #include <event-parse.h>
62 #endif
63
64 /*
65 * magic2 = "PERFILE2"
66 * must be a numerical value to let the endianness
67 * determine the memory layout. That way we are able
68 * to detect endianness when reading the perf.data file
69 * back.
70 *
71 * we check for legacy (PERFFILE) format.
72 */
73 static const char *__perf_magic1 = "PERFFILE";
74 static const u64 __perf_magic2 = 0x32454c4946524550ULL;
75 static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
76
77 #define PERF_MAGIC __perf_magic2
78
79 const char perf_version_string[] = PERF_VERSION;
80
81 struct perf_file_attr {
82 struct perf_event_attr attr;
83 struct perf_file_section ids;
84 };
85
86 void perf_header__set_feat(struct perf_header *header, int feat)
87 {
88 __set_bit(feat, header->adds_features);
89 }
90
91 void perf_header__clear_feat(struct perf_header *header, int feat)
92 {
93 __clear_bit(feat, header->adds_features);
94 }
95
96 bool perf_header__has_feat(const struct perf_header *header, int feat)
97 {
98 return test_bit(feat, header->adds_features);
99 }
100
101 static int __do_write_fd(struct feat_fd *ff, const void *buf, size_t size)
102 {
103 ssize_t ret = writen(ff->fd, buf, size);
104
105 if (ret != (ssize_t)size)
106 return ret < 0 ? (int)ret : -1;
107 return 0;
108 }
109
110 static int __do_write_buf(struct feat_fd *ff, const void *buf, size_t size)
111 {
112 /* struct perf_event_header::size is u16 */
113 const size_t max_size = 0xffff - sizeof(struct perf_event_header);
114 size_t new_size = ff->size;
115 void *addr;
116
117 if (size + ff->offset > max_size)
118 return -E2BIG;
119
120 while (size > (new_size - ff->offset))
121 new_size <<= 1;
122 new_size = min(max_size, new_size);
123
124 if (ff->size < new_size) {
125 addr = realloc(ff->buf, new_size);
126 if (!addr)
127 return -ENOMEM;
128 ff->buf = addr;
129 ff->size = new_size;
130 }
131
132 memcpy(ff->buf + ff->offset, buf, size);
133 ff->offset += size;
134
135 return 0;
136 }
137
138 /* Return: 0 if succeeded, -ERR if failed. */
139 int do_write(struct feat_fd *ff, const void *buf, size_t size)
140 {
141 if (!ff->buf)
142 return __do_write_fd(ff, buf, size);
143 return __do_write_buf(ff, buf, size);
144 }
145
146 /* Return: 0 if succeeded, -ERR if failed. */
147 static int do_write_bitmap(struct feat_fd *ff, unsigned long *set, u64 size)
148 {
149 u64 *p = (u64 *) set;
150 int i, ret;
151
152 ret = do_write(ff, &size, sizeof(size));
153 if (ret < 0)
154 return ret;
155
156 for (i = 0; (u64) i < BITS_TO_U64(size); i++) {
157 ret = do_write(ff, p + i, sizeof(*p));
158 if (ret < 0)
159 return ret;
160 }
161
162 return 0;
163 }
164
165 /* Return: 0 if succeeded, -ERR if failed. */
166 int write_padded(struct feat_fd *ff, const void *bf,
167 size_t count, size_t count_aligned)
168 {
169 static const char zero_buf[NAME_ALIGN];
170 int err = do_write(ff, bf, count);
171
172 if (!err)
173 err = do_write(ff, zero_buf, count_aligned - count);
174
175 return err;
176 }
177
178 #define string_size(str) \
179 (PERF_ALIGN((strlen(str) + 1), NAME_ALIGN) + sizeof(u32))
180
181 /* Return: 0 if succeeded, -ERR if failed. */
182 static int do_write_string(struct feat_fd *ff, const char *str)
183 {
184 u32 len, olen;
185 int ret;
186
187 olen = strlen(str) + 1;
188 len = PERF_ALIGN(olen, NAME_ALIGN);
189
190 /* write len, incl. \0 */
191 ret = do_write(ff, &len, sizeof(len));
192 if (ret < 0)
193 return ret;
194
195 return write_padded(ff, str, olen, len);
196 }
197
198 static int __do_read_fd(struct feat_fd *ff, void *addr, ssize_t size)
199 {
200 ssize_t ret = readn(ff->fd, addr, size);
201
202 if (ret != size)
203 return ret < 0 ? (int)ret : -1;
204 return 0;
205 }
206
207 static int __do_read_buf(struct feat_fd *ff, void *addr, ssize_t size)
208 {
209 if (size > (ssize_t)ff->size - ff->offset)
210 return -1;
211
212 memcpy(addr, ff->buf + ff->offset, size);
213 ff->offset += size;
214
215 return 0;
216
217 }
218
219 static int __do_read(struct feat_fd *ff, void *addr, ssize_t size)
220 {
221 if (!ff->buf)
222 return __do_read_fd(ff, addr, size);
223 return __do_read_buf(ff, addr, size);
224 }
225
226 static int do_read_u32(struct feat_fd *ff, u32 *addr)
227 {
228 int ret;
229
230 ret = __do_read(ff, addr, sizeof(*addr));
231 if (ret)
232 return ret;
233
234 if (ff->ph->needs_swap)
235 *addr = bswap_32(*addr);
236 return 0;
237 }
238
239 static int do_read_u64(struct feat_fd *ff, u64 *addr)
240 {
241 int ret;
242
243 ret = __do_read(ff, addr, sizeof(*addr));
244 if (ret)
245 return ret;
246
247 if (ff->ph->needs_swap)
248 *addr = bswap_64(*addr);
249 return 0;
250 }
251
252 static char *do_read_string(struct feat_fd *ff)
253 {
254 u32 len;
255 char *buf;
256
257 if (do_read_u32(ff, &len))
258 return NULL;
259
260 buf = malloc(len);
261 if (!buf)
262 return NULL;
263
264 if (!__do_read(ff, buf, len)) {
265 /*
266 * strings are padded by zeroes
267 * thus the actual strlen of buf
268 * may be less than len
269 */
270 return buf;
271 }
272
273 free(buf);
274 return NULL;
275 }
276
277 /* Return: 0 if succeeded, -ERR if failed. */
278 static int do_read_bitmap(struct feat_fd *ff, unsigned long **pset, u64 *psize)
279 {
280 unsigned long *set;
281 u64 size, *p;
282 int i, ret;
283
284 ret = do_read_u64(ff, &size);
285 if (ret)
286 return ret;
287
288 set = bitmap_zalloc(size);
289 if (!set)
290 return -ENOMEM;
291
292 p = (u64 *) set;
293
294 for (i = 0; (u64) i < BITS_TO_U64(size); i++) {
295 ret = do_read_u64(ff, p + i);
296 if (ret < 0) {
297 free(set);
298 return ret;
299 }
300 }
301
302 *pset = set;
303 *psize = size;
304 return 0;
305 }
306
307 #ifdef HAVE_LIBTRACEEVENT
308 static int write_tracing_data(struct feat_fd *ff,
309 struct evlist *evlist)
310 {
311 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
312 return -1;
313
314 return read_tracing_data(ff->fd, &evlist->core.entries);
315 }
316 #endif
317
318 static int write_build_id(struct feat_fd *ff,
319 struct evlist *evlist __maybe_unused)
320 {
321 struct perf_session *session;
322 int err;
323
324 session = container_of(ff->ph, struct perf_session, header);
325
326 if (!perf_session__read_build_ids(session, true))
327 return -1;
328
329 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
330 return -1;
331
332 err = perf_session__write_buildid_table(session, ff);
333 if (err < 0) {
334 pr_debug("failed to write buildid table\n");
335 return err;
336 }
337 perf_session__cache_build_ids(session);
338
339 return 0;
340 }
341
342 static int write_hostname(struct feat_fd *ff,
343 struct evlist *evlist __maybe_unused)
344 {
345 struct utsname uts;
346 int ret;
347
348 ret = uname(&uts);
349 if (ret < 0)
350 return -1;
351
352 return do_write_string(ff, uts.nodename);
353 }
354
355 static int write_osrelease(struct feat_fd *ff,
356 struct evlist *evlist __maybe_unused)
357 {
358 struct utsname uts;
359 int ret;
360
361 ret = uname(&uts);
362 if (ret < 0)
363 return -1;
364
365 return do_write_string(ff, uts.release);
366 }
367
368 static int write_arch(struct feat_fd *ff,
369 struct evlist *evlist __maybe_unused)
370 {
371 struct utsname uts;
372 int ret;
373
374 ret = uname(&uts);
375 if (ret < 0)
376 return -1;
377
378 return do_write_string(ff, uts.machine);
379 }
380
381 static int write_version(struct feat_fd *ff,
382 struct evlist *evlist __maybe_unused)
383 {
384 return do_write_string(ff, perf_version_string);
385 }
386
387 static int __write_cpudesc(struct feat_fd *ff, const char *cpuinfo_proc)
388 {
389 FILE *file;
390 char *buf = NULL;
391 char *s, *p;
392 const char *search = cpuinfo_proc;
393 size_t len = 0;
394 int ret = -1;
395
396 if (!search)
397 return -1;
398
399 file = fopen("/proc/cpuinfo", "r");
400 if (!file)
401 return -1;
402
403 while (getline(&buf, &len, file) > 0) {
404 ret = strncmp(buf, search, strlen(search));
405 if (!ret)
406 break;
407 }
408
409 if (ret) {
410 ret = -1;
411 goto done;
412 }
413
414 s = buf;
415
416 p = strchr(buf, ':');
417 if (p && *(p+1) == ' ' && *(p+2))
418 s = p + 2;
419 p = strchr(s, '\n');
420 if (p)
421 *p = '\0';
422
423 /* squash extra space characters (branding string) */
424 p = s;
425 while (*p) {
426 if (isspace(*p)) {
427 char *r = p + 1;
428 char *q = skip_spaces(r);
429 *p = ' ';
430 if (q != (p+1))
431 while ((*r++ = *q++));
432 }
433 p++;
434 }
435 ret = do_write_string(ff, s);
436 done:
437 free(buf);
438 fclose(file);
439 return ret;
440 }
441
442 static int write_cpudesc(struct feat_fd *ff,
443 struct evlist *evlist __maybe_unused)
444 {
445 #if defined(__powerpc__) || defined(__hppa__) || defined(__sparc__)
446 #define CPUINFO_PROC { "cpu", }
447 #elif defined(__s390__)
448 #define CPUINFO_PROC { "vendor_id", }
449 #elif defined(__sh__)
450 #define CPUINFO_PROC { "cpu type", }
451 #elif defined(__alpha__) || defined(__mips__)
452 #define CPUINFO_PROC { "cpu model", }
453 #elif defined(__arm__)
454 #define CPUINFO_PROC { "model name", "Processor", }
455 #elif defined(__arc__)
456 #define CPUINFO_PROC { "Processor", }
457 #elif defined(__xtensa__)
458 #define CPUINFO_PROC { "core ID", }
459 #elif defined(__loongarch__)
460 #define CPUINFO_PROC { "Model Name", }
461 #else
462 #define CPUINFO_PROC { "model name", }
463 #endif
464 const char *cpuinfo_procs[] = CPUINFO_PROC;
465 #undef CPUINFO_PROC
466 unsigned int i;
467
468 for (i = 0; i < ARRAY_SIZE(cpuinfo_procs); i++) {
469 int ret;
470 ret = __write_cpudesc(ff, cpuinfo_procs[i]);
471 if (ret >= 0)
472 return ret;
473 }
474 return -1;
475 }
476
477
478 static int write_nrcpus(struct feat_fd *ff,
479 struct evlist *evlist __maybe_unused)
480 {
481 long nr;
482 u32 nrc, nra;
483 int ret;
484
485 nrc = cpu__max_present_cpu().cpu;
486
487 nr = sysconf(_SC_NPROCESSORS_ONLN);
488 if (nr < 0)
489 return -1;
490
491 nra = (u32)(nr & UINT_MAX);
492
493 ret = do_write(ff, &nrc, sizeof(nrc));
494 if (ret < 0)
495 return ret;
496
497 return do_write(ff, &nra, sizeof(nra));
498 }
499
500 static int write_event_desc(struct feat_fd *ff,
501 struct evlist *evlist)
502 {
503 struct evsel *evsel;
504 u32 nre, nri, sz;
505 int ret;
506
507 nre = evlist->core.nr_entries;
508
509 /*
510 * write number of events
511 */
512 ret = do_write(ff, &nre, sizeof(nre));
513 if (ret < 0)
514 return ret;
515
516 /*
517 * size of perf_event_attr struct
518 */
519 sz = (u32)sizeof(evsel->core.attr);
520 ret = do_write(ff, &sz, sizeof(sz));
521 if (ret < 0)
522 return ret;
523
524 evlist__for_each_entry(evlist, evsel) {
525 ret = do_write(ff, &evsel->core.attr, sz);
526 if (ret < 0)
527 return ret;
528 /*
529 * write number of unique id per event
530 * there is one id per instance of an event
531 *
532 * copy into an nri to be independent of the
533 * type of ids,
534 */
535 nri = evsel->core.ids;
536 ret = do_write(ff, &nri, sizeof(nri));
537 if (ret < 0)
538 return ret;
539
540 /*
541 * write event string as passed on cmdline
542 */
543 ret = do_write_string(ff, evsel__name(evsel));
544 if (ret < 0)
545 return ret;
546 /*
547 * write unique ids for this event
548 */
549 ret = do_write(ff, evsel->core.id, evsel->core.ids * sizeof(u64));
550 if (ret < 0)
551 return ret;
552 }
553 return 0;
554 }
555
556 static int write_cmdline(struct feat_fd *ff,
557 struct evlist *evlist __maybe_unused)
558 {
559 char pbuf[MAXPATHLEN], *buf;
560 int i, ret, n;
561
562 /* actual path to perf binary */
563 buf = perf_exe(pbuf, MAXPATHLEN);
564
565 /* account for binary path */
566 n = perf_env.nr_cmdline + 1;
567
568 ret = do_write(ff, &n, sizeof(n));
569 if (ret < 0)
570 return ret;
571
572 ret = do_write_string(ff, buf);
573 if (ret < 0)
574 return ret;
575
576 for (i = 0 ; i < perf_env.nr_cmdline; i++) {
577 ret = do_write_string(ff, perf_env.cmdline_argv[i]);
578 if (ret < 0)
579 return ret;
580 }
581 return 0;
582 }
583
584
585 static int write_cpu_topology(struct feat_fd *ff,
586 struct evlist *evlist __maybe_unused)
587 {
588 struct cpu_topology *tp;
589 u32 i;
590 int ret, j;
591
592 tp = cpu_topology__new();
593 if (!tp)
594 return -1;
595
596 ret = do_write(ff, &tp->package_cpus_lists, sizeof(tp->package_cpus_lists));
597 if (ret < 0)
598 goto done;
599
600 for (i = 0; i < tp->package_cpus_lists; i++) {
601 ret = do_write_string(ff, tp->package_cpus_list[i]);
602 if (ret < 0)
603 goto done;
604 }
605 ret = do_write(ff, &tp->core_cpus_lists, sizeof(tp->core_cpus_lists));
606 if (ret < 0)
607 goto done;
608
609 for (i = 0; i < tp->core_cpus_lists; i++) {
610 ret = do_write_string(ff, tp->core_cpus_list[i]);
611 if (ret < 0)
612 break;
613 }
614
615 ret = perf_env__read_cpu_topology_map(&perf_env);
616 if (ret < 0)
617 goto done;
618
619 for (j = 0; j < perf_env.nr_cpus_avail; j++) {
620 ret = do_write(ff, &perf_env.cpu[j].core_id,
621 sizeof(perf_env.cpu[j].core_id));
622 if (ret < 0)
623 return ret;
624 ret = do_write(ff, &perf_env.cpu[j].socket_id,
625 sizeof(perf_env.cpu[j].socket_id));
626 if (ret < 0)
627 return ret;
628 }
629
630 if (!tp->die_cpus_lists)
631 goto done;
632
633 ret = do_write(ff, &tp->die_cpus_lists, sizeof(tp->die_cpus_lists));
634 if (ret < 0)
635 goto done;
636
637 for (i = 0; i < tp->die_cpus_lists; i++) {
638 ret = do_write_string(ff, tp->die_cpus_list[i]);
639 if (ret < 0)
640 goto done;
641 }
642
643 for (j = 0; j < perf_env.nr_cpus_avail; j++) {
644 ret = do_write(ff, &perf_env.cpu[j].die_id,
645 sizeof(perf_env.cpu[j].die_id));
646 if (ret < 0)
647 return ret;
648 }
649
650 done:
651 cpu_topology__delete(tp);
652 return ret;
653 }
654
655
656
657 static int write_total_mem(struct feat_fd *ff,
658 struct evlist *evlist __maybe_unused)
659 {
660 char *buf = NULL;
661 FILE *fp;
662 size_t len = 0;
663 int ret = -1, n;
664 uint64_t mem;
665
666 fp = fopen("/proc/meminfo", "r");
667 if (!fp)
668 return -1;
669
670 while (getline(&buf, &len, fp) > 0) {
671 ret = strncmp(buf, "MemTotal:", 9);
672 if (!ret)
673 break;
674 }
675 if (!ret) {
676 n = sscanf(buf, "%*s %"PRIu64, &mem);
677 if (n == 1)
678 ret = do_write(ff, &mem, sizeof(mem));
679 } else
680 ret = -1;
681 free(buf);
682 fclose(fp);
683 return ret;
684 }
685
686 static int write_numa_topology(struct feat_fd *ff,
687 struct evlist *evlist __maybe_unused)
688 {
689 struct numa_topology *tp;
690 int ret = -1;
691 u32 i;
692
693 tp = numa_topology__new();
694 if (!tp)
695 return -ENOMEM;
696
697 ret = do_write(ff, &tp->nr, sizeof(u32));
698 if (ret < 0)
699 goto err;
700
701 for (i = 0; i < tp->nr; i++) {
702 struct numa_topology_node *n = &tp->nodes[i];
703
704 ret = do_write(ff, &n->node, sizeof(u32));
705 if (ret < 0)
706 goto err;
707
708 ret = do_write(ff, &n->mem_total, sizeof(u64));
709 if (ret)
710 goto err;
711
712 ret = do_write(ff, &n->mem_free, sizeof(u64));
713 if (ret)
714 goto err;
715
716 ret = do_write_string(ff, n->cpus);
717 if (ret < 0)
718 goto err;
719 }
720
721 ret = 0;
722
723 err:
724 numa_topology__delete(tp);
725 return ret;
726 }
727
728 /*
729 * File format:
730 *
731 * struct pmu_mappings {
732 * u32 pmu_num;
733 * struct pmu_map {
734 * u32 type;
735 * char name[];
736 * }[pmu_num];
737 * };
738 */
739
740 static int write_pmu_mappings(struct feat_fd *ff,
741 struct evlist *evlist __maybe_unused)
742 {
743 struct perf_pmu *pmu = NULL;
744 u32 pmu_num = 0;
745 int ret;
746
747 /*
748 * Do a first pass to count number of pmu to avoid lseek so this
749 * works in pipe mode as well.
750 */
751 while ((pmu = perf_pmus__scan(pmu)))
752 pmu_num++;
753
754 ret = do_write(ff, &pmu_num, sizeof(pmu_num));
755 if (ret < 0)
756 return ret;
757
758 while ((pmu = perf_pmus__scan(pmu))) {
759 ret = do_write(ff, &pmu->type, sizeof(pmu->type));
760 if (ret < 0)
761 return ret;
762
763 ret = do_write_string(ff, pmu->name);
764 if (ret < 0)
765 return ret;
766 }
767
768 return 0;
769 }
770
771 /*
772 * File format:
773 *
774 * struct group_descs {
775 * u32 nr_groups;
776 * struct group_desc {
777 * char name[];
778 * u32 leader_idx;
779 * u32 nr_members;
780 * }[nr_groups];
781 * };
782 */
783 static int write_group_desc(struct feat_fd *ff,
784 struct evlist *evlist)
785 {
786 u32 nr_groups = evlist__nr_groups(evlist);
787 struct evsel *evsel;
788 int ret;
789
790 ret = do_write(ff, &nr_groups, sizeof(nr_groups));
791 if (ret < 0)
792 return ret;
793
794 evlist__for_each_entry(evlist, evsel) {
795 if (evsel__is_group_leader(evsel) && evsel->core.nr_members > 1) {
796 const char *name = evsel->group_name ?: "{anon_group}";
797 u32 leader_idx = evsel->core.idx;
798 u32 nr_members = evsel->core.nr_members;
799
800 ret = do_write_string(ff, name);
801 if (ret < 0)
802 return ret;
803
804 ret = do_write(ff, &leader_idx, sizeof(leader_idx));
805 if (ret < 0)
806 return ret;
807
808 ret = do_write(ff, &nr_members, sizeof(nr_members));
809 if (ret < 0)
810 return ret;
811 }
812 }
813 return 0;
814 }
815
816 /*
817 * Return the CPU id as a raw string.
818 *
819 * Each architecture should provide a more precise id string that
820 * can be use to match the architecture's "mapfile".
821 */
822 char * __weak get_cpuid_str(struct perf_cpu cpu __maybe_unused)
823 {
824 return NULL;
825 }
826
827 char *get_cpuid_allow_env_override(struct perf_cpu cpu)
828 {
829 char *cpuid;
830 static bool printed;
831
832 cpuid = getenv("PERF_CPUID");
833 if (cpuid)
834 cpuid = strdup(cpuid);
835 if (!cpuid)
836 cpuid = get_cpuid_str(cpu);
837 if (!cpuid)
838 return NULL;
839
840 if (!printed) {
841 pr_debug("Using CPUID %s\n", cpuid);
842 printed = true;
843 }
844 return cpuid;
845 }
846
847 /* Return zero when the cpuid from the mapfile.csv matches the
848 * cpuid string generated on this platform.
849 * Otherwise return non-zero.
850 */
851 int __weak strcmp_cpuid_str(const char *mapcpuid, const char *cpuid)
852 {
853 regex_t re;
854 regmatch_t pmatch[1];
855 int match;
856
857 if (regcomp(&re, mapcpuid, REG_EXTENDED) != 0) {
858 /* Warn unable to generate match particular string. */
859 pr_info("Invalid regular expression %s\n", mapcpuid);
860 return 1;
861 }
862
863 match = !regexec(&re, cpuid, 1, pmatch, 0);
864 regfree(&re);
865 if (match) {
866 size_t match_len = (pmatch[0].rm_eo - pmatch[0].rm_so);
867
868 /* Verify the entire string matched. */
869 if (match_len == strlen(cpuid))
870 return 0;
871 }
872 return 1;
873 }
874
875 /*
876 * default get_cpuid(): nothing gets recorded
877 * actual implementation must be in arch/$(SRCARCH)/util/header.c
878 */
879 int __weak get_cpuid(char *buffer __maybe_unused, size_t sz __maybe_unused,
880 struct perf_cpu cpu __maybe_unused)
881 {
882 return ENOSYS; /* Not implemented */
883 }
884
885 static int write_cpuid(struct feat_fd *ff, struct evlist *evlist)
886 {
887 struct perf_cpu cpu = perf_cpu_map__min(evlist->core.all_cpus);
888 char buffer[64];
889 int ret;
890
891 ret = get_cpuid(buffer, sizeof(buffer), cpu);
892 if (ret)
893 return -1;
894
895 return do_write_string(ff, buffer);
896 }
897
898 static int write_branch_stack(struct feat_fd *ff __maybe_unused,
899 struct evlist *evlist __maybe_unused)
900 {
901 return 0;
902 }
903
904 static int write_auxtrace(struct feat_fd *ff,
905 struct evlist *evlist __maybe_unused)
906 {
907 struct perf_session *session;
908 int err;
909
910 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
911 return -1;
912
913 session = container_of(ff->ph, struct perf_session, header);
914
915 err = auxtrace_index__write(ff->fd, &session->auxtrace_index);
916 if (err < 0)
917 pr_err("Failed to write auxtrace index\n");
918 return err;
919 }
920
921 static int write_clockid(struct feat_fd *ff,
922 struct evlist *evlist __maybe_unused)
923 {
924 return do_write(ff, &ff->ph->env.clock.clockid_res_ns,
925 sizeof(ff->ph->env.clock.clockid_res_ns));
926 }
927
928 static int write_clock_data(struct feat_fd *ff,
929 struct evlist *evlist __maybe_unused)
930 {
931 u64 *data64;
932 u32 data32;
933 int ret;
934
935 /* version */
936 data32 = 1;
937
938 ret = do_write(ff, &data32, sizeof(data32));
939 if (ret < 0)
940 return ret;
941
942 /* clockid */
943 data32 = ff->ph->env.clock.clockid;
944
945 ret = do_write(ff, &data32, sizeof(data32));
946 if (ret < 0)
947 return ret;
948
949 /* TOD ref time */
950 data64 = &ff->ph->env.clock.tod_ns;
951
952 ret = do_write(ff, data64, sizeof(*data64));
953 if (ret < 0)
954 return ret;
955
956 /* clockid ref time */
957 data64 = &ff->ph->env.clock.clockid_ns;
958
959 return do_write(ff, data64, sizeof(*data64));
960 }
961
962 static int write_hybrid_topology(struct feat_fd *ff,
963 struct evlist *evlist __maybe_unused)
964 {
965 struct hybrid_topology *tp;
966 int ret;
967 u32 i;
968
969 tp = hybrid_topology__new();
970 if (!tp)
971 return -ENOENT;
972
973 ret = do_write(ff, &tp->nr, sizeof(u32));
974 if (ret < 0)
975 goto err;
976
977 for (i = 0; i < tp->nr; i++) {
978 struct hybrid_topology_node *n = &tp->nodes[i];
979
980 ret = do_write_string(ff, n->pmu_name);
981 if (ret < 0)
982 goto err;
983
984 ret = do_write_string(ff, n->cpus);
985 if (ret < 0)
986 goto err;
987 }
988
989 ret = 0;
990
991 err:
992 hybrid_topology__delete(tp);
993 return ret;
994 }
995
996 static int write_dir_format(struct feat_fd *ff,
997 struct evlist *evlist __maybe_unused)
998 {
999 struct perf_session *session;
1000 struct perf_data *data;
1001
1002 session = container_of(ff->ph, struct perf_session, header);
1003 data = session->data;
1004
1005 if (WARN_ON(!perf_data__is_dir(data)))
1006 return -1;
1007
1008 return do_write(ff, &data->dir.version, sizeof(data->dir.version));
1009 }
1010
1011 #ifdef HAVE_LIBBPF_SUPPORT
1012 static int write_bpf_prog_info(struct feat_fd *ff,
1013 struct evlist *evlist __maybe_unused)
1014 {
1015 struct perf_env *env = &ff->ph->env;
1016 struct rb_root *root;
1017 struct rb_node *next;
1018 int ret;
1019
1020 down_read(&env->bpf_progs.lock);
1021
1022 ret = do_write(ff, &env->bpf_progs.infos_cnt,
1023 sizeof(env->bpf_progs.infos_cnt));
1024 if (ret < 0)
1025 goto out;
1026
1027 root = &env->bpf_progs.infos;
1028 next = rb_first(root);
1029 while (next) {
1030 struct bpf_prog_info_node *node;
1031 size_t len;
1032
1033 node = rb_entry(next, struct bpf_prog_info_node, rb_node);
1034 next = rb_next(&node->rb_node);
1035 len = sizeof(struct perf_bpil) +
1036 node->info_linear->data_len;
1037
1038 /* before writing to file, translate address to offset */
1039 bpil_addr_to_offs(node->info_linear);
1040 ret = do_write(ff, node->info_linear, len);
1041 /*
1042 * translate back to address even when do_write() fails,
1043 * so that this function never changes the data.
1044 */
1045 bpil_offs_to_addr(node->info_linear);
1046 if (ret < 0)
1047 goto out;
1048 }
1049 out:
1050 up_read(&env->bpf_progs.lock);
1051 return ret;
1052 }
1053
1054 static int write_bpf_btf(struct feat_fd *ff,
1055 struct evlist *evlist __maybe_unused)
1056 {
1057 struct perf_env *env = &ff->ph->env;
1058 struct rb_root *root;
1059 struct rb_node *next;
1060 int ret;
1061
1062 down_read(&env->bpf_progs.lock);
1063
1064 ret = do_write(ff, &env->bpf_progs.btfs_cnt,
1065 sizeof(env->bpf_progs.btfs_cnt));
1066
1067 if (ret < 0)
1068 goto out;
1069
1070 root = &env->bpf_progs.btfs;
1071 next = rb_first(root);
1072 while (next) {
1073 struct btf_node *node;
1074
1075 node = rb_entry(next, struct btf_node, rb_node);
1076 next = rb_next(&node->rb_node);
1077 ret = do_write(ff, &node->id,
1078 sizeof(u32) * 2 + node->data_size);
1079 if (ret < 0)
1080 goto out;
1081 }
1082 out:
1083 up_read(&env->bpf_progs.lock);
1084 return ret;
1085 }
1086 #endif // HAVE_LIBBPF_SUPPORT
1087
1088 static int cpu_cache_level__sort(const void *a, const void *b)
1089 {
1090 struct cpu_cache_level *cache_a = (struct cpu_cache_level *)a;
1091 struct cpu_cache_level *cache_b = (struct cpu_cache_level *)b;
1092
1093 return cache_a->level - cache_b->level;
1094 }
1095
1096 static bool cpu_cache_level__cmp(struct cpu_cache_level *a, struct cpu_cache_level *b)
1097 {
1098 if (a->level != b->level)
1099 return false;
1100
1101 if (a->line_size != b->line_size)
1102 return false;
1103
1104 if (a->sets != b->sets)
1105 return false;
1106
1107 if (a->ways != b->ways)
1108 return false;
1109
1110 if (strcmp(a->type, b->type))
1111 return false;
1112
1113 if (strcmp(a->size, b->size))
1114 return false;
1115
1116 if (strcmp(a->map, b->map))
1117 return false;
1118
1119 return true;
1120 }
1121
1122 static int cpu_cache_level__read(struct cpu_cache_level *cache, u32 cpu, u16 level)
1123 {
1124 char path[PATH_MAX], file[PATH_MAX];
1125 struct stat st;
1126 size_t len;
1127
1128 scnprintf(path, PATH_MAX, "devices/system/cpu/cpu%d/cache/index%d/", cpu, level);
1129 scnprintf(file, PATH_MAX, "%s/%s", sysfs__mountpoint(), path);
1130
1131 if (stat(file, &st))
1132 return 1;
1133
1134 scnprintf(file, PATH_MAX, "%s/level", path);
1135 if (sysfs__read_int(file, (int *) &cache->level))
1136 return -1;
1137
1138 scnprintf(file, PATH_MAX, "%s/coherency_line_size", path);
1139 if (sysfs__read_int(file, (int *) &cache->line_size))
1140 return -1;
1141
1142 scnprintf(file, PATH_MAX, "%s/number_of_sets", path);
1143 if (sysfs__read_int(file, (int *) &cache->sets))
1144 return -1;
1145
1146 scnprintf(file, PATH_MAX, "%s/ways_of_associativity", path);
1147 if (sysfs__read_int(file, (int *) &cache->ways))
1148 return -1;
1149
1150 scnprintf(file, PATH_MAX, "%s/type", path);
1151 if (sysfs__read_str(file, &cache->type, &len))
1152 return -1;
1153
1154 cache->type[len] = 0;
1155 cache->type = strim(cache->type);
1156
1157 scnprintf(file, PATH_MAX, "%s/size", path);
1158 if (sysfs__read_str(file, &cache->size, &len)) {
1159 zfree(&cache->type);
1160 return -1;
1161 }
1162
1163 cache->size[len] = 0;
1164 cache->size = strim(cache->size);
1165
1166 scnprintf(file, PATH_MAX, "%s/shared_cpu_list", path);
1167 if (sysfs__read_str(file, &cache->map, &len)) {
1168 zfree(&cache->size);
1169 zfree(&cache->type);
1170 return -1;
1171 }
1172
1173 cache->map[len] = 0;
1174 cache->map = strim(cache->map);
1175 return 0;
1176 }
1177
1178 static void cpu_cache_level__fprintf(FILE *out, struct cpu_cache_level *c)
1179 {
1180 fprintf(out, "L%d %-15s %8s [%s]\n", c->level, c->type, c->size, c->map);
1181 }
1182
1183 /*
1184 * Build caches levels for a particular CPU from the data in
1185 * /sys/devices/system/cpu/cpu<cpu>/cache/
1186 * The cache level data is stored in caches[] from index at
1187 * *cntp.
1188 */
1189 int build_caches_for_cpu(u32 cpu, struct cpu_cache_level caches[], u32 *cntp)
1190 {
1191 u16 level;
1192
1193 for (level = 0; level < MAX_CACHE_LVL; level++) {
1194 struct cpu_cache_level c;
1195 int err;
1196 u32 i;
1197
1198 err = cpu_cache_level__read(&c, cpu, level);
1199 if (err < 0)
1200 return err;
1201
1202 if (err == 1)
1203 break;
1204
1205 for (i = 0; i < *cntp; i++) {
1206 if (cpu_cache_level__cmp(&c, &caches[i]))
1207 break;
1208 }
1209
1210 if (i == *cntp) {
1211 caches[*cntp] = c;
1212 *cntp = *cntp + 1;
1213 } else
1214 cpu_cache_level__free(&c);
1215 }
1216
1217 return 0;
1218 }
1219
1220 static int build_caches(struct cpu_cache_level caches[], u32 *cntp)
1221 {
1222 u32 nr, cpu, cnt = 0;
1223
1224 nr = cpu__max_cpu().cpu;
1225
1226 for (cpu = 0; cpu < nr; cpu++) {
1227 int ret = build_caches_for_cpu(cpu, caches, &cnt);
1228
1229 if (ret)
1230 return ret;
1231 }
1232 *cntp = cnt;
1233 return 0;
1234 }
1235
1236 static int write_cache(struct feat_fd *ff,
1237 struct evlist *evlist __maybe_unused)
1238 {
1239 u32 max_caches = cpu__max_cpu().cpu * MAX_CACHE_LVL;
1240 struct cpu_cache_level caches[max_caches];
1241 u32 cnt = 0, i, version = 1;
1242 int ret;
1243
1244 ret = build_caches(caches, &cnt);
1245 if (ret)
1246 goto out;
1247
1248 qsort(&caches, cnt, sizeof(struct cpu_cache_level), cpu_cache_level__sort);
1249
1250 ret = do_write(ff, &version, sizeof(u32));
1251 if (ret < 0)
1252 goto out;
1253
1254 ret = do_write(ff, &cnt, sizeof(u32));
1255 if (ret < 0)
1256 goto out;
1257
1258 for (i = 0; i < cnt; i++) {
1259 struct cpu_cache_level *c = &caches[i];
1260
1261 #define _W(v) \
1262 ret = do_write(ff, &c->v, sizeof(u32)); \
1263 if (ret < 0) \
1264 goto out;
1265
1266 _W(level)
1267 _W(line_size)
1268 _W(sets)
1269 _W(ways)
1270 #undef _W
1271
1272 #define _W(v) \
1273 ret = do_write_string(ff, (const char *) c->v); \
1274 if (ret < 0) \
1275 goto out;
1276
1277 _W(type)
1278 _W(size)
1279 _W(map)
1280 #undef _W
1281 }
1282
1283 out:
1284 for (i = 0; i < cnt; i++)
1285 cpu_cache_level__free(&caches[i]);
1286 return ret;
1287 }
1288
1289 static int write_stat(struct feat_fd *ff __maybe_unused,
1290 struct evlist *evlist __maybe_unused)
1291 {
1292 return 0;
1293 }
1294
1295 static int write_sample_time(struct feat_fd *ff,
1296 struct evlist *evlist)
1297 {
1298 int ret;
1299
1300 ret = do_write(ff, &evlist->first_sample_time,
1301 sizeof(evlist->first_sample_time));
1302 if (ret < 0)
1303 return ret;
1304
1305 return do_write(ff, &evlist->last_sample_time,
1306 sizeof(evlist->last_sample_time));
1307 }
1308
1309
1310 static int memory_node__read(struct memory_node *n, unsigned long idx)
1311 {
1312 unsigned int phys, size = 0;
1313 char path[PATH_MAX];
1314 struct dirent *ent;
1315 DIR *dir;
1316
1317 #define for_each_memory(mem, dir) \
1318 while ((ent = readdir(dir))) \
1319 if (strcmp(ent->d_name, ".") && \
1320 strcmp(ent->d_name, "..") && \
1321 sscanf(ent->d_name, "memory%u", &mem) == 1)
1322
1323 scnprintf(path, PATH_MAX,
1324 "%s/devices/system/node/node%lu",
1325 sysfs__mountpoint(), idx);
1326
1327 dir = opendir(path);
1328 if (!dir) {
1329 pr_warning("failed: can't open memory sysfs data\n");
1330 return -1;
1331 }
1332
1333 for_each_memory(phys, dir) {
1334 size = max(phys, size);
1335 }
1336
1337 size++;
1338
1339 n->set = bitmap_zalloc(size);
1340 if (!n->set) {
1341 closedir(dir);
1342 return -ENOMEM;
1343 }
1344
1345 n->node = idx;
1346 n->size = size;
1347
1348 rewinddir(dir);
1349
1350 for_each_memory(phys, dir) {
1351 __set_bit(phys, n->set);
1352 }
1353
1354 closedir(dir);
1355 return 0;
1356 }
1357
1358 static void memory_node__delete_nodes(struct memory_node *nodesp, u64 cnt)
1359 {
1360 for (u64 i = 0; i < cnt; i++)
1361 bitmap_free(nodesp[i].set);
1362
1363 free(nodesp);
1364 }
1365
1366 static int memory_node__sort(const void *a, const void *b)
1367 {
1368 const struct memory_node *na = a;
1369 const struct memory_node *nb = b;
1370
1371 return na->node - nb->node;
1372 }
1373
1374 static int build_mem_topology(struct memory_node **nodesp, u64 *cntp)
1375 {
1376 char path[PATH_MAX];
1377 struct dirent *ent;
1378 DIR *dir;
1379 int ret = 0;
1380 size_t cnt = 0, size = 0;
1381 struct memory_node *nodes = NULL;
1382
1383 scnprintf(path, PATH_MAX, "%s/devices/system/node/",
1384 sysfs__mountpoint());
1385
1386 dir = opendir(path);
1387 if (!dir) {
1388 pr_debug2("%s: couldn't read %s, does this arch have topology information?\n",
1389 __func__, path);
1390 return -1;
1391 }
1392
1393 while (!ret && (ent = readdir(dir))) {
1394 unsigned int idx;
1395 int r;
1396
1397 if (!strcmp(ent->d_name, ".") ||
1398 !strcmp(ent->d_name, ".."))
1399 continue;
1400
1401 r = sscanf(ent->d_name, "node%u", &idx);
1402 if (r != 1)
1403 continue;
1404
1405 if (cnt >= size) {
1406 struct memory_node *new_nodes =
1407 reallocarray(nodes, cnt + 4, sizeof(*nodes));
1408
1409 if (!new_nodes) {
1410 pr_err("Failed to write MEM_TOPOLOGY, size %zd nodes\n", size);
1411 ret = -ENOMEM;
1412 goto out;
1413 }
1414 nodes = new_nodes;
1415 size += 4;
1416 }
1417 ret = memory_node__read(&nodes[cnt], idx);
1418 if (!ret)
1419 cnt += 1;
1420 }
1421 out:
1422 closedir(dir);
1423 if (!ret) {
1424 *cntp = cnt;
1425 *nodesp = nodes;
1426 qsort(nodes, cnt, sizeof(nodes[0]), memory_node__sort);
1427 } else
1428 memory_node__delete_nodes(nodes, cnt);
1429
1430 return ret;
1431 }
1432
1433 /*
1434 * The MEM_TOPOLOGY holds physical memory map for every
1435 * node in system. The format of data is as follows:
1436 *
1437 * 0 - version | for future changes
1438 * 8 - block_size_bytes | /sys/devices/system/memory/block_size_bytes
1439 * 16 - count | number of nodes
1440 *
1441 * For each node we store map of physical indexes for
1442 * each node:
1443 *
1444 * 32 - node id | node index
1445 * 40 - size | size of bitmap
1446 * 48 - bitmap | bitmap of memory indexes that belongs to node
1447 */
1448 static int write_mem_topology(struct feat_fd *ff __maybe_unused,
1449 struct evlist *evlist __maybe_unused)
1450 {
1451 struct memory_node *nodes = NULL;
1452 u64 bsize, version = 1, i, nr = 0;
1453 int ret;
1454
1455 ret = sysfs__read_xll("devices/system/memory/block_size_bytes",
1456 (unsigned long long *) &bsize);
1457 if (ret)
1458 return ret;
1459
1460 ret = build_mem_topology(&nodes, &nr);
1461 if (ret)
1462 return ret;
1463
1464 ret = do_write(ff, &version, sizeof(version));
1465 if (ret < 0)
1466 goto out;
1467
1468 ret = do_write(ff, &bsize, sizeof(bsize));
1469 if (ret < 0)
1470 goto out;
1471
1472 ret = do_write(ff, &nr, sizeof(nr));
1473 if (ret < 0)
1474 goto out;
1475
1476 for (i = 0; i < nr; i++) {
1477 struct memory_node *n = &nodes[i];
1478
1479 #define _W(v) \
1480 ret = do_write(ff, &n->v, sizeof(n->v)); \
1481 if (ret < 0) \
1482 goto out;
1483
1484 _W(node)
1485 _W(size)
1486
1487 #undef _W
1488
1489 ret = do_write_bitmap(ff, n->set, n->size);
1490 if (ret < 0)
1491 goto out;
1492 }
1493
1494 out:
1495 memory_node__delete_nodes(nodes, nr);
1496 return ret;
1497 }
1498
1499 static int write_compressed(struct feat_fd *ff __maybe_unused,
1500 struct evlist *evlist __maybe_unused)
1501 {
1502 int ret;
1503
1504 ret = do_write(ff, &(ff->ph->env.comp_ver), sizeof(ff->ph->env.comp_ver));
1505 if (ret)
1506 return ret;
1507
1508 ret = do_write(ff, &(ff->ph->env.comp_type), sizeof(ff->ph->env.comp_type));
1509 if (ret)
1510 return ret;
1511
1512 ret = do_write(ff, &(ff->ph->env.comp_level), sizeof(ff->ph->env.comp_level));
1513 if (ret)
1514 return ret;
1515
1516 ret = do_write(ff, &(ff->ph->env.comp_ratio), sizeof(ff->ph->env.comp_ratio));
1517 if (ret)
1518 return ret;
1519
1520 return do_write(ff, &(ff->ph->env.comp_mmap_len), sizeof(ff->ph->env.comp_mmap_len));
1521 }
1522
1523 static int __write_pmu_caps(struct feat_fd *ff, struct perf_pmu *pmu,
1524 bool write_pmu)
1525 {
1526 struct perf_pmu_caps *caps = NULL;
1527 int ret;
1528
1529 ret = do_write(ff, &pmu->nr_caps, sizeof(pmu->nr_caps));
1530 if (ret < 0)
1531 return ret;
1532
1533 list_for_each_entry(caps, &pmu->caps, list) {
1534 ret = do_write_string(ff, caps->name);
1535 if (ret < 0)
1536 return ret;
1537
1538 ret = do_write_string(ff, caps->value);
1539 if (ret < 0)
1540 return ret;
1541 }
1542
1543 if (write_pmu) {
1544 ret = do_write_string(ff, pmu->name);
1545 if (ret < 0)
1546 return ret;
1547 }
1548
1549 return ret;
1550 }
1551
1552 static int write_cpu_pmu_caps(struct feat_fd *ff,
1553 struct evlist *evlist __maybe_unused)
1554 {
1555 struct perf_pmu *cpu_pmu = perf_pmus__find("cpu");
1556 int ret;
1557
1558 if (!cpu_pmu)
1559 return -ENOENT;
1560
1561 ret = perf_pmu__caps_parse(cpu_pmu);
1562 if (ret < 0)
1563 return ret;
1564
1565 return __write_pmu_caps(ff, cpu_pmu, false);
1566 }
1567
1568 static int write_pmu_caps(struct feat_fd *ff,
1569 struct evlist *evlist __maybe_unused)
1570 {
1571 struct perf_pmu *pmu = NULL;
1572 int nr_pmu = 0;
1573 int ret;
1574
1575 while ((pmu = perf_pmus__scan(pmu))) {
1576 if (!strcmp(pmu->name, "cpu")) {
1577 /*
1578 * The "cpu" PMU is special and covered by
1579 * HEADER_CPU_PMU_CAPS. Note, core PMUs are
1580 * counted/written here for ARM, s390 and Intel hybrid.
1581 */
1582 continue;
1583 }
1584 if (perf_pmu__caps_parse(pmu) <= 0)
1585 continue;
1586 nr_pmu++;
1587 }
1588
1589 ret = do_write(ff, &nr_pmu, sizeof(nr_pmu));
1590 if (ret < 0)
1591 return ret;
1592
1593 if (!nr_pmu)
1594 return 0;
1595
1596 /*
1597 * Note older perf tools assume core PMUs come first, this is a property
1598 * of perf_pmus__scan.
1599 */
1600 pmu = NULL;
1601 while ((pmu = perf_pmus__scan(pmu))) {
1602 if (!strcmp(pmu->name, "cpu")) {
1603 /* Skip as above. */
1604 continue;
1605 }
1606 if (perf_pmu__caps_parse(pmu) <= 0)
1607 continue;
1608 ret = __write_pmu_caps(ff, pmu, true);
1609 if (ret < 0)
1610 return ret;
1611 }
1612 return 0;
1613 }
1614
1615 static void print_hostname(struct feat_fd *ff, FILE *fp)
1616 {
1617 fprintf(fp, "# hostname : %s\n", ff->ph->env.hostname);
1618 }
1619
1620 static void print_osrelease(struct feat_fd *ff, FILE *fp)
1621 {
1622 fprintf(fp, "# os release : %s\n", ff->ph->env.os_release);
1623 }
1624
1625 static void print_arch(struct feat_fd *ff, FILE *fp)
1626 {
1627 fprintf(fp, "# arch : %s\n", ff->ph->env.arch);
1628 }
1629
1630 static void print_cpudesc(struct feat_fd *ff, FILE *fp)
1631 {
1632 fprintf(fp, "# cpudesc : %s\n", ff->ph->env.cpu_desc);
1633 }
1634
1635 static void print_nrcpus(struct feat_fd *ff, FILE *fp)
1636 {
1637 fprintf(fp, "# nrcpus online : %u\n", ff->ph->env.nr_cpus_online);
1638 fprintf(fp, "# nrcpus avail : %u\n", ff->ph->env.nr_cpus_avail);
1639 }
1640
1641 static void print_version(struct feat_fd *ff, FILE *fp)
1642 {
1643 fprintf(fp, "# perf version : %s\n", ff->ph->env.version);
1644 }
1645
1646 static void print_cmdline(struct feat_fd *ff, FILE *fp)
1647 {
1648 int nr, i;
1649
1650 nr = ff->ph->env.nr_cmdline;
1651
1652 fprintf(fp, "# cmdline : ");
1653
1654 for (i = 0; i < nr; i++) {
1655 char *argv_i = strdup(ff->ph->env.cmdline_argv[i]);
1656 if (!argv_i) {
1657 fprintf(fp, "%s ", ff->ph->env.cmdline_argv[i]);
1658 } else {
1659 char *mem = argv_i;
1660 do {
1661 char *quote = strchr(argv_i, '\'');
1662 if (!quote)
1663 break;
1664 *quote++ = '\0';
1665 fprintf(fp, "%s\\\'", argv_i);
1666 argv_i = quote;
1667 } while (1);
1668 fprintf(fp, "%s ", argv_i);
1669 free(mem);
1670 }
1671 }
1672 fputc('\n', fp);
1673 }
1674
1675 static void print_cpu_topology(struct feat_fd *ff, FILE *fp)
1676 {
1677 struct perf_header *ph = ff->ph;
1678 int cpu_nr = ph->env.nr_cpus_avail;
1679 int nr, i;
1680 char *str;
1681
1682 nr = ph->env.nr_sibling_cores;
1683 str = ph->env.sibling_cores;
1684
1685 for (i = 0; i < nr; i++) {
1686 fprintf(fp, "# sibling sockets : %s\n", str);
1687 str += strlen(str) + 1;
1688 }
1689
1690 if (ph->env.nr_sibling_dies) {
1691 nr = ph->env.nr_sibling_dies;
1692 str = ph->env.sibling_dies;
1693
1694 for (i = 0; i < nr; i++) {
1695 fprintf(fp, "# sibling dies : %s\n", str);
1696 str += strlen(str) + 1;
1697 }
1698 }
1699
1700 nr = ph->env.nr_sibling_threads;
1701 str = ph->env.sibling_threads;
1702
1703 for (i = 0; i < nr; i++) {
1704 fprintf(fp, "# sibling threads : %s\n", str);
1705 str += strlen(str) + 1;
1706 }
1707
1708 if (ph->env.nr_sibling_dies) {
1709 if (ph->env.cpu != NULL) {
1710 for (i = 0; i < cpu_nr; i++)
1711 fprintf(fp, "# CPU %d: Core ID %d, "
1712 "Die ID %d, Socket ID %d\n",
1713 i, ph->env.cpu[i].core_id,
1714 ph->env.cpu[i].die_id,
1715 ph->env.cpu[i].socket_id);
1716 } else
1717 fprintf(fp, "# Core ID, Die ID and Socket ID "
1718 "information is not available\n");
1719 } else {
1720 if (ph->env.cpu != NULL) {
1721 for (i = 0; i < cpu_nr; i++)
1722 fprintf(fp, "# CPU %d: Core ID %d, "
1723 "Socket ID %d\n",
1724 i, ph->env.cpu[i].core_id,
1725 ph->env.cpu[i].socket_id);
1726 } else
1727 fprintf(fp, "# Core ID and Socket ID "
1728 "information is not available\n");
1729 }
1730 }
1731
1732 static void print_clockid(struct feat_fd *ff, FILE *fp)
1733 {
1734 fprintf(fp, "# clockid frequency: %"PRIu64" MHz\n",
1735 ff->ph->env.clock.clockid_res_ns * 1000);
1736 }
1737
1738 static void print_clock_data(struct feat_fd *ff, FILE *fp)
1739 {
1740 struct timespec clockid_ns;
1741 char tstr[64], date[64];
1742 struct timeval tod_ns;
1743 clockid_t clockid;
1744 struct tm ltime;
1745 u64 ref;
1746
1747 if (!ff->ph->env.clock.enabled) {
1748 fprintf(fp, "# reference time disabled\n");
1749 return;
1750 }
1751
1752 /* Compute TOD time. */
1753 ref = ff->ph->env.clock.tod_ns;
1754 tod_ns.tv_sec = ref / NSEC_PER_SEC;
1755 ref -= tod_ns.tv_sec * NSEC_PER_SEC;
1756 tod_ns.tv_usec = ref / NSEC_PER_USEC;
1757
1758 /* Compute clockid time. */
1759 ref = ff->ph->env.clock.clockid_ns;
1760 clockid_ns.tv_sec = ref / NSEC_PER_SEC;
1761 ref -= clockid_ns.tv_sec * NSEC_PER_SEC;
1762 clockid_ns.tv_nsec = ref;
1763
1764 clockid = ff->ph->env.clock.clockid;
1765
1766 if (localtime_r(&tod_ns.tv_sec, &ltime) == NULL)
1767 snprintf(tstr, sizeof(tstr), "<error>");
1768 else {
1769 strftime(date, sizeof(date), "%F %T", &ltime);
1770 scnprintf(tstr, sizeof(tstr), "%s.%06d",
1771 date, (int) tod_ns.tv_usec);
1772 }
1773
1774 fprintf(fp, "# clockid: %s (%u)\n", clockid_name(clockid), clockid);
1775 fprintf(fp, "# reference time: %s = %ld.%06d (TOD) = %ld.%09ld (%s)\n",
1776 tstr, (long) tod_ns.tv_sec, (int) tod_ns.tv_usec,
1777 (long) clockid_ns.tv_sec, clockid_ns.tv_nsec,
1778 clockid_name(clockid));
1779 }
1780
1781 static void print_hybrid_topology(struct feat_fd *ff, FILE *fp)
1782 {
1783 int i;
1784 struct hybrid_node *n;
1785
1786 fprintf(fp, "# hybrid cpu system:\n");
1787 for (i = 0; i < ff->ph->env.nr_hybrid_nodes; i++) {
1788 n = &ff->ph->env.hybrid_nodes[i];
1789 fprintf(fp, "# %s cpu list : %s\n", n->pmu_name, n->cpus);
1790 }
1791 }
1792
1793 static void print_dir_format(struct feat_fd *ff, FILE *fp)
1794 {
1795 struct perf_session *session;
1796 struct perf_data *data;
1797
1798 session = container_of(ff->ph, struct perf_session, header);
1799 data = session->data;
1800
1801 fprintf(fp, "# directory data version : %"PRIu64"\n", data->dir.version);
1802 }
1803
1804 #ifdef HAVE_LIBBPF_SUPPORT
1805 static void print_bpf_prog_info(struct feat_fd *ff, FILE *fp)
1806 {
1807 struct perf_env *env = &ff->ph->env;
1808 struct rb_root *root;
1809 struct rb_node *next;
1810
1811 down_read(&env->bpf_progs.lock);
1812
1813 root = &env->bpf_progs.infos;
1814 next = rb_first(root);
1815
1816 while (next) {
1817 struct bpf_prog_info_node *node;
1818
1819 node = rb_entry(next, struct bpf_prog_info_node, rb_node);
1820 next = rb_next(&node->rb_node);
1821
1822 __bpf_event__print_bpf_prog_info(&node->info_linear->info,
1823 env, fp);
1824 }
1825
1826 up_read(&env->bpf_progs.lock);
1827 }
1828
1829 static void print_bpf_btf(struct feat_fd *ff, FILE *fp)
1830 {
1831 struct perf_env *env = &ff->ph->env;
1832 struct rb_root *root;
1833 struct rb_node *next;
1834
1835 down_read(&env->bpf_progs.lock);
1836
1837 root = &env->bpf_progs.btfs;
1838 next = rb_first(root);
1839
1840 while (next) {
1841 struct btf_node *node;
1842
1843 node = rb_entry(next, struct btf_node, rb_node);
1844 next = rb_next(&node->rb_node);
1845 fprintf(fp, "# btf info of id %u\n", node->id);
1846 }
1847
1848 up_read(&env->bpf_progs.lock);
1849 }
1850 #endif // HAVE_LIBBPF_SUPPORT
1851
1852 static void free_event_desc(struct evsel *events)
1853 {
1854 struct evsel *evsel;
1855
1856 if (!events)
1857 return;
1858
1859 for (evsel = events; evsel->core.attr.size; evsel++) {
1860 zfree(&evsel->name);
1861 zfree(&evsel->core.id);
1862 }
1863
1864 free(events);
1865 }
1866
1867 static bool perf_attr_check(struct perf_event_attr *attr)
1868 {
1869 if (attr->__reserved_1 || attr->__reserved_2 || attr->__reserved_3) {
1870 pr_warning("Reserved bits are set unexpectedly. "
1871 "Please update perf tool.\n");
1872 return false;
1873 }
1874
1875 if (attr->sample_type & ~(PERF_SAMPLE_MAX-1)) {
1876 pr_warning("Unknown sample type (0x%llx) is detected. "
1877 "Please update perf tool.\n",
1878 attr->sample_type);
1879 return false;
1880 }
1881
1882 if (attr->read_format & ~(PERF_FORMAT_MAX-1)) {
1883 pr_warning("Unknown read format (0x%llx) is detected. "
1884 "Please update perf tool.\n",
1885 attr->read_format);
1886 return false;
1887 }
1888
1889 if ((attr->sample_type & PERF_SAMPLE_BRANCH_STACK) &&
1890 (attr->branch_sample_type & ~(PERF_SAMPLE_BRANCH_MAX-1))) {
1891 pr_warning("Unknown branch sample type (0x%llx) is detected. "
1892 "Please update perf tool.\n",
1893 attr->branch_sample_type);
1894
1895 return false;
1896 }
1897
1898 return true;
1899 }
1900
1901 static struct evsel *read_event_desc(struct feat_fd *ff)
1902 {
1903 struct evsel *evsel, *events = NULL;
1904 u64 *id;
1905 void *buf = NULL;
1906 u32 nre, sz, nr, i, j;
1907 size_t msz;
1908
1909 /* number of events */
1910 if (do_read_u32(ff, &nre))
1911 goto error;
1912
1913 if (do_read_u32(ff, &sz))
1914 goto error;
1915
1916 /* buffer to hold on file attr struct */
1917 buf = malloc(sz);
1918 if (!buf)
1919 goto error;
1920
1921 /* the last event terminates with evsel->core.attr.size == 0: */
1922 events = calloc(nre + 1, sizeof(*events));
1923 if (!events)
1924 goto error;
1925
1926 msz = sizeof(evsel->core.attr);
1927 if (sz < msz)
1928 msz = sz;
1929
1930 for (i = 0, evsel = events; i < nre; evsel++, i++) {
1931 evsel->core.idx = i;
1932
1933 /*
1934 * must read entire on-file attr struct to
1935 * sync up with layout.
1936 */
1937 if (__do_read(ff, buf, sz))
1938 goto error;
1939
1940 if (ff->ph->needs_swap)
1941 perf_event__attr_swap(buf);
1942
1943 memcpy(&evsel->core.attr, buf, msz);
1944
1945 if (!perf_attr_check(&evsel->core.attr))
1946 goto error;
1947
1948 if (do_read_u32(ff, &nr))
1949 goto error;
1950
1951 if (ff->ph->needs_swap)
1952 evsel->needs_swap = true;
1953
1954 evsel->name = do_read_string(ff);
1955 if (!evsel->name)
1956 goto error;
1957
1958 if (!nr)
1959 continue;
1960
1961 id = calloc(nr, sizeof(*id));
1962 if (!id)
1963 goto error;
1964 evsel->core.ids = nr;
1965 evsel->core.id = id;
1966
1967 for (j = 0 ; j < nr; j++) {
1968 if (do_read_u64(ff, id))
1969 goto error;
1970 id++;
1971 }
1972 }
1973 out:
1974 free(buf);
1975 return events;
1976 error:
1977 free_event_desc(events);
1978 events = NULL;
1979 goto out;
1980 }
1981
1982 static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
1983 void *priv __maybe_unused)
1984 {
1985 return fprintf(fp, ", %s = %s", name, val);
1986 }
1987
1988 static void print_event_desc(struct feat_fd *ff, FILE *fp)
1989 {
1990 struct evsel *evsel, *events;
1991 u32 j;
1992 u64 *id;
1993
1994 if (ff->events)
1995 events = ff->events;
1996 else
1997 events = read_event_desc(ff);
1998
1999 if (!events) {
2000 fprintf(fp, "# event desc: not available or unable to read\n");
2001 return;
2002 }
2003
2004 for (evsel = events; evsel->core.attr.size; evsel++) {
2005 fprintf(fp, "# event : name = %s, ", evsel->name);
2006
2007 if (evsel->core.ids) {
2008 fprintf(fp, ", id = {");
2009 for (j = 0, id = evsel->core.id; j < evsel->core.ids; j++, id++) {
2010 if (j)
2011 fputc(',', fp);
2012 fprintf(fp, " %"PRIu64, *id);
2013 }
2014 fprintf(fp, " }");
2015 }
2016
2017 perf_event_attr__fprintf(fp, &evsel->core.attr, __desc_attr__fprintf, NULL);
2018
2019 fputc('\n', fp);
2020 }
2021
2022 free_event_desc(events);
2023 ff->events = NULL;
2024 }
2025
2026 static void print_total_mem(struct feat_fd *ff, FILE *fp)
2027 {
2028 fprintf(fp, "# total memory : %llu kB\n", ff->ph->env.total_mem);
2029 }
2030
2031 static void print_numa_topology(struct feat_fd *ff, FILE *fp)
2032 {
2033 int i;
2034 struct numa_node *n;
2035
2036 for (i = 0; i < ff->ph->env.nr_numa_nodes; i++) {
2037 n = &ff->ph->env.numa_nodes[i];
2038
2039 fprintf(fp, "# node%u meminfo : total = %"PRIu64" kB,"
2040 " free = %"PRIu64" kB\n",
2041 n->node, n->mem_total, n->mem_free);
2042
2043 fprintf(fp, "# node%u cpu list : ", n->node);
2044 cpu_map__fprintf(n->map, fp);
2045 }
2046 }
2047
2048 static void print_cpuid(struct feat_fd *ff, FILE *fp)
2049 {
2050 fprintf(fp, "# cpuid : %s\n", ff->ph->env.cpuid);
2051 }
2052
2053 static void print_branch_stack(struct feat_fd *ff __maybe_unused, FILE *fp)
2054 {
2055 fprintf(fp, "# contains samples with branch stack\n");
2056 }
2057
2058 static void print_auxtrace(struct feat_fd *ff __maybe_unused, FILE *fp)
2059 {
2060 fprintf(fp, "# contains AUX area data (e.g. instruction trace)\n");
2061 }
2062
2063 static void print_stat(struct feat_fd *ff __maybe_unused, FILE *fp)
2064 {
2065 fprintf(fp, "# contains stat data\n");
2066 }
2067
2068 static void print_cache(struct feat_fd *ff, FILE *fp __maybe_unused)
2069 {
2070 int i;
2071
2072 fprintf(fp, "# CPU cache info:\n");
2073 for (i = 0; i < ff->ph->env.caches_cnt; i++) {
2074 fprintf(fp, "# ");
2075 cpu_cache_level__fprintf(fp, &ff->ph->env.caches[i]);
2076 }
2077 }
2078
2079 static void print_compressed(struct feat_fd *ff, FILE *fp)
2080 {
2081 fprintf(fp, "# compressed : %s, level = %d, ratio = %d\n",
2082 ff->ph->env.comp_type == PERF_COMP_ZSTD ? "Zstd" : "Unknown",
2083 ff->ph->env.comp_level, ff->ph->env.comp_ratio);
2084 }
2085
2086 static void __print_pmu_caps(FILE *fp, int nr_caps, char **caps, char *pmu_name)
2087 {
2088 const char *delimiter = "";
2089 int i;
2090
2091 if (!nr_caps) {
2092 fprintf(fp, "# %s pmu capabilities: not available\n", pmu_name);
2093 return;
2094 }
2095
2096 fprintf(fp, "# %s pmu capabilities: ", pmu_name);
2097 for (i = 0; i < nr_caps; i++) {
2098 fprintf(fp, "%s%s", delimiter, caps[i]);
2099 delimiter = ", ";
2100 }
2101
2102 fprintf(fp, "\n");
2103 }
2104
2105 static void print_cpu_pmu_caps(struct feat_fd *ff, FILE *fp)
2106 {
2107 __print_pmu_caps(fp, ff->ph->env.nr_cpu_pmu_caps,
2108 ff->ph->env.cpu_pmu_caps, (char *)"cpu");
2109 }
2110
2111 static void print_pmu_caps(struct feat_fd *ff, FILE *fp)
2112 {
2113 struct pmu_caps *pmu_caps;
2114
2115 for (int i = 0; i < ff->ph->env.nr_pmus_with_caps; i++) {
2116 pmu_caps = &ff->ph->env.pmu_caps[i];
2117 __print_pmu_caps(fp, pmu_caps->nr_caps, pmu_caps->caps,
2118 pmu_caps->pmu_name);
2119 }
2120
2121 if (strcmp(perf_env__arch(&ff->ph->env), "x86") == 0 &&
2122 perf_env__has_pmu_mapping(&ff->ph->env, "ibs_op")) {
2123 char *max_precise = perf_env__find_pmu_cap(&ff->ph->env, "cpu", "max_precise");
2124
2125 if (max_precise != NULL && atoi(max_precise) == 0)
2126 fprintf(fp, "# AMD systems uses ibs_op// PMU for some precise events, e.g.: cycles:p, see the 'perf list' man page for further details.\n");
2127 }
2128 }
2129
2130 static void print_pmu_mappings(struct feat_fd *ff, FILE *fp)
2131 {
2132 const char *delimiter = "# pmu mappings: ";
2133 char *str, *tmp;
2134 u32 pmu_num;
2135 u32 type;
2136
2137 pmu_num = ff->ph->env.nr_pmu_mappings;
2138 if (!pmu_num) {
2139 fprintf(fp, "# pmu mappings: not available\n");
2140 return;
2141 }
2142
2143 str = ff->ph->env.pmu_mappings;
2144
2145 while (pmu_num) {
2146 type = strtoul(str, &tmp, 0);
2147 if (*tmp != ':')
2148 goto error;
2149
2150 str = tmp + 1;
2151 fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
2152
2153 delimiter = ", ";
2154 str += strlen(str) + 1;
2155 pmu_num--;
2156 }
2157
2158 fprintf(fp, "\n");
2159
2160 if (!pmu_num)
2161 return;
2162 error:
2163 fprintf(fp, "# pmu mappings: unable to read\n");
2164 }
2165
2166 static void print_group_desc(struct feat_fd *ff, FILE *fp)
2167 {
2168 struct perf_session *session;
2169 struct evsel *evsel;
2170 u32 nr = 0;
2171
2172 session = container_of(ff->ph, struct perf_session, header);
2173
2174 evlist__for_each_entry(session->evlist, evsel) {
2175 if (evsel__is_group_leader(evsel) && evsel->core.nr_members > 1) {
2176 fprintf(fp, "# group: %s{%s", evsel->group_name ?: "", evsel__name(evsel));
2177
2178 nr = evsel->core.nr_members - 1;
2179 } else if (nr) {
2180 fprintf(fp, ",%s", evsel__name(evsel));
2181
2182 if (--nr == 0)
2183 fprintf(fp, "}\n");
2184 }
2185 }
2186 }
2187
2188 static void print_sample_time(struct feat_fd *ff, FILE *fp)
2189 {
2190 struct perf_session *session;
2191 char time_buf[32];
2192 double d;
2193
2194 session = container_of(ff->ph, struct perf_session, header);
2195
2196 timestamp__scnprintf_usec(session->evlist->first_sample_time,
2197 time_buf, sizeof(time_buf));
2198 fprintf(fp, "# time of first sample : %s\n", time_buf);
2199
2200 timestamp__scnprintf_usec(session->evlist->last_sample_time,
2201 time_buf, sizeof(time_buf));
2202 fprintf(fp, "# time of last sample : %s\n", time_buf);
2203
2204 d = (double)(session->evlist->last_sample_time -
2205 session->evlist->first_sample_time) / NSEC_PER_MSEC;
2206
2207 fprintf(fp, "# sample duration : %10.3f ms\n", d);
2208 }
2209
2210 static void memory_node__fprintf(struct memory_node *n,
2211 unsigned long long bsize, FILE *fp)
2212 {
2213 char buf_map[100], buf_size[50];
2214 unsigned long long size;
2215
2216 size = bsize * bitmap_weight(n->set, n->size);
2217 unit_number__scnprintf(buf_size, 50, size);
2218
2219 bitmap_scnprintf(n->set, n->size, buf_map, 100);
2220 fprintf(fp, "# %3" PRIu64 " [%s]: %s\n", n->node, buf_size, buf_map);
2221 }
2222
2223 static void print_mem_topology(struct feat_fd *ff, FILE *fp)
2224 {
2225 struct memory_node *nodes;
2226 int i, nr;
2227
2228 nodes = ff->ph->env.memory_nodes;
2229 nr = ff->ph->env.nr_memory_nodes;
2230
2231 fprintf(fp, "# memory nodes (nr %d, block size 0x%llx):\n",
2232 nr, ff->ph->env.memory_bsize);
2233
2234 for (i = 0; i < nr; i++) {
2235 memory_node__fprintf(&nodes[i], ff->ph->env.memory_bsize, fp);
2236 }
2237 }
2238
2239 static int __event_process_build_id(struct perf_record_header_build_id *bev,
2240 char *filename,
2241 struct perf_session *session)
2242 {
2243 int err = -1;
2244 struct machine *machine;
2245 u16 cpumode;
2246 struct dso *dso;
2247 enum dso_space_type dso_space;
2248
2249 machine = perf_session__findnew_machine(session, bev->pid);
2250 if (!machine)
2251 goto out;
2252
2253 cpumode = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
2254
2255 switch (cpumode) {
2256 case PERF_RECORD_MISC_KERNEL:
2257 dso_space = DSO_SPACE__KERNEL;
2258 break;
2259 case PERF_RECORD_MISC_GUEST_KERNEL:
2260 dso_space = DSO_SPACE__KERNEL_GUEST;
2261 break;
2262 case PERF_RECORD_MISC_USER:
2263 case PERF_RECORD_MISC_GUEST_USER:
2264 dso_space = DSO_SPACE__USER;
2265 break;
2266 default:
2267 goto out;
2268 }
2269
2270 dso = machine__findnew_dso(machine, filename);
2271 if (dso != NULL) {
2272 char sbuild_id[SBUILD_ID_SIZE];
2273 struct build_id bid;
2274 size_t size = BUILD_ID_SIZE;
2275
2276 if (bev->header.misc & PERF_RECORD_MISC_BUILD_ID_SIZE)
2277 size = bev->size;
2278
2279 build_id__init(&bid, bev->data, size);
2280 dso__set_build_id(dso, &bid);
2281 dso__set_header_build_id(dso, true);
2282
2283 if (dso_space != DSO_SPACE__USER) {
2284 struct kmod_path m = { .name = NULL, };
2285
2286 if (!kmod_path__parse_name(&m, filename) && m.kmod)
2287 dso__set_module_info(dso, &m, machine);
2288
2289 dso__set_kernel(dso, dso_space);
2290 free(m.name);
2291 }
2292
2293 build_id__sprintf(dso__bid(dso), sbuild_id);
2294 pr_debug("build id event received for %s: %s [%zu]\n",
2295 dso__long_name(dso), sbuild_id, size);
2296 dso__put(dso);
2297 }
2298
2299 err = 0;
2300 out:
2301 return err;
2302 }
2303
2304 static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
2305 int input, u64 offset, u64 size)
2306 {
2307 struct perf_session *session = container_of(header, struct perf_session, header);
2308 struct {
2309 struct perf_event_header header;
2310 u8 build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
2311 char filename[0];
2312 } old_bev;
2313 struct perf_record_header_build_id bev;
2314 char filename[PATH_MAX];
2315 u64 limit = offset + size;
2316
2317 while (offset < limit) {
2318 ssize_t len;
2319
2320 if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
2321 return -1;
2322
2323 if (header->needs_swap)
2324 perf_event_header__bswap(&old_bev.header);
2325
2326 len = old_bev.header.size - sizeof(old_bev);
2327 if (readn(input, filename, len) != len)
2328 return -1;
2329
2330 bev.header = old_bev.header;
2331
2332 /*
2333 * As the pid is the missing value, we need to fill
2334 * it properly. The header.misc value give us nice hint.
2335 */
2336 bev.pid = HOST_KERNEL_ID;
2337 if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
2338 bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
2339 bev.pid = DEFAULT_GUEST_KERNEL_ID;
2340
2341 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
2342 __event_process_build_id(&bev, filename, session);
2343
2344 offset += bev.header.size;
2345 }
2346
2347 return 0;
2348 }
2349
2350 static int perf_header__read_build_ids(struct perf_header *header,
2351 int input, u64 offset, u64 size)
2352 {
2353 struct perf_session *session = container_of(header, struct perf_session, header);
2354 struct perf_record_header_build_id bev;
2355 char filename[PATH_MAX];
2356 u64 limit = offset + size, orig_offset = offset;
2357 int err = -1;
2358
2359 while (offset < limit) {
2360 ssize_t len;
2361
2362 if (readn(input, &bev, sizeof(bev)) != sizeof(bev))
2363 goto out;
2364
2365 if (header->needs_swap)
2366 perf_event_header__bswap(&bev.header);
2367
2368 len = bev.header.size - sizeof(bev);
2369 if (readn(input, filename, len) != len)
2370 goto out;
2371 /*
2372 * The a1645ce1 changeset:
2373 *
2374 * "perf: 'perf kvm' tool for monitoring guest performance from host"
2375 *
2376 * Added a field to struct perf_record_header_build_id that broke the file
2377 * format.
2378 *
2379 * Since the kernel build-id is the first entry, process the
2380 * table using the old format if the well known
2381 * '[kernel.kallsyms]' string for the kernel build-id has the
2382 * first 4 characters chopped off (where the pid_t sits).
2383 */
2384 if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
2385 if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
2386 return -1;
2387 return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
2388 }
2389
2390 __event_process_build_id(&bev, filename, session);
2391
2392 offset += bev.header.size;
2393 }
2394 err = 0;
2395 out:
2396 return err;
2397 }
2398
2399 /* Macro for features that simply need to read and store a string. */
2400 #define FEAT_PROCESS_STR_FUN(__feat, __feat_env) \
2401 static int process_##__feat(struct feat_fd *ff, void *data __maybe_unused) \
2402 {\
2403 free(ff->ph->env.__feat_env); \
2404 ff->ph->env.__feat_env = do_read_string(ff); \
2405 return ff->ph->env.__feat_env ? 0 : -ENOMEM; \
2406 }
2407
2408 FEAT_PROCESS_STR_FUN(hostname, hostname);
2409 FEAT_PROCESS_STR_FUN(osrelease, os_release);
2410 FEAT_PROCESS_STR_FUN(version, version);
2411 FEAT_PROCESS_STR_FUN(arch, arch);
2412 FEAT_PROCESS_STR_FUN(cpudesc, cpu_desc);
2413 FEAT_PROCESS_STR_FUN(cpuid, cpuid);
2414
2415 #ifdef HAVE_LIBTRACEEVENT
2416 static int process_tracing_data(struct feat_fd *ff, void *data)
2417 {
2418 ssize_t ret = trace_report(ff->fd, data, false);
2419
2420 return ret < 0 ? -1 : 0;
2421 }
2422 #endif
2423
2424 static int process_build_id(struct feat_fd *ff, void *data __maybe_unused)
2425 {
2426 if (perf_header__read_build_ids(ff->ph, ff->fd, ff->offset, ff->size))
2427 pr_debug("Failed to read buildids, continuing...\n");
2428 return 0;
2429 }
2430
2431 static int process_nrcpus(struct feat_fd *ff, void *data __maybe_unused)
2432 {
2433 int ret;
2434 u32 nr_cpus_avail, nr_cpus_online;
2435
2436 ret = do_read_u32(ff, &nr_cpus_avail);
2437 if (ret)
2438 return ret;
2439
2440 ret = do_read_u32(ff, &nr_cpus_online);
2441 if (ret)
2442 return ret;
2443 ff->ph->env.nr_cpus_avail = (int)nr_cpus_avail;
2444 ff->ph->env.nr_cpus_online = (int)nr_cpus_online;
2445 return 0;
2446 }
2447
2448 static int process_total_mem(struct feat_fd *ff, void *data __maybe_unused)
2449 {
2450 u64 total_mem;
2451 int ret;
2452
2453 ret = do_read_u64(ff, &total_mem);
2454 if (ret)
2455 return -1;
2456 ff->ph->env.total_mem = (unsigned long long)total_mem;
2457 return 0;
2458 }
2459
2460 static struct evsel *evlist__find_by_index(struct evlist *evlist, int idx)
2461 {
2462 struct evsel *evsel;
2463
2464 evlist__for_each_entry(evlist, evsel) {
2465 if (evsel->core.idx == idx)
2466 return evsel;
2467 }
2468
2469 return NULL;
2470 }
2471
2472 static void evlist__set_event_name(struct evlist *evlist, struct evsel *event)
2473 {
2474 struct evsel *evsel;
2475
2476 if (!event->name)
2477 return;
2478
2479 evsel = evlist__find_by_index(evlist, event->core.idx);
2480 if (!evsel)
2481 return;
2482
2483 if (evsel->name)
2484 return;
2485
2486 evsel->name = strdup(event->name);
2487 }
2488
2489 static int
2490 process_event_desc(struct feat_fd *ff, void *data __maybe_unused)
2491 {
2492 struct perf_session *session;
2493 struct evsel *evsel, *events = read_event_desc(ff);
2494
2495 if (!events)
2496 return 0;
2497
2498 session = container_of(ff->ph, struct perf_session, header);
2499
2500 if (session->data->is_pipe) {
2501 /* Save events for reading later by print_event_desc,
2502 * since they can't be read again in pipe mode. */
2503 ff->events = events;
2504 }
2505
2506 for (evsel = events; evsel->core.attr.size; evsel++)
2507 evlist__set_event_name(session->evlist, evsel);
2508
2509 if (!session->data->is_pipe)
2510 free_event_desc(events);
2511
2512 return 0;
2513 }
2514
2515 static int process_cmdline(struct feat_fd *ff, void *data __maybe_unused)
2516 {
2517 char *str, *cmdline = NULL, **argv = NULL;
2518 u32 nr, i, len = 0;
2519
2520 if (do_read_u32(ff, &nr))
2521 return -1;
2522
2523 ff->ph->env.nr_cmdline = nr;
2524
2525 cmdline = zalloc(ff->size + nr + 1);
2526 if (!cmdline)
2527 return -1;
2528
2529 argv = zalloc(sizeof(char *) * (nr + 1));
2530 if (!argv)
2531 goto error;
2532
2533 for (i = 0; i < nr; i++) {
2534 str = do_read_string(ff);
2535 if (!str)
2536 goto error;
2537
2538 argv[i] = cmdline + len;
2539 memcpy(argv[i], str, strlen(str) + 1);
2540 len += strlen(str) + 1;
2541 free(str);
2542 }
2543 ff->ph->env.cmdline = cmdline;
2544 ff->ph->env.cmdline_argv = (const char **) argv;
2545 return 0;
2546
2547 error:
2548 free(argv);
2549 free(cmdline);
2550 return -1;
2551 }
2552
2553 static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
2554 {
2555 u32 nr, i;
2556 char *str = NULL;
2557 struct strbuf sb;
2558 int cpu_nr = ff->ph->env.nr_cpus_avail;
2559 u64 size = 0;
2560 struct perf_header *ph = ff->ph;
2561 bool do_core_id_test = true;
2562
2563 ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu));
2564 if (!ph->env.cpu)
2565 return -1;
2566
2567 if (do_read_u32(ff, &nr))
2568 goto free_cpu;
2569
2570 ph->env.nr_sibling_cores = nr;
2571 size += sizeof(u32);
2572 if (strbuf_init(&sb, 128) < 0)
2573 goto free_cpu;
2574
2575 for (i = 0; i < nr; i++) {
2576 str = do_read_string(ff);
2577 if (!str)
2578 goto error;
2579
2580 /* include a NULL character at the end */
2581 if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
2582 goto error;
2583 size += string_size(str);
2584 zfree(&str);
2585 }
2586 ph->env.sibling_cores = strbuf_detach(&sb, NULL);
2587
2588 if (do_read_u32(ff, &nr))
2589 return -1;
2590
2591 ph->env.nr_sibling_threads = nr;
2592 size += sizeof(u32);
2593
2594 for (i = 0; i < nr; i++) {
2595 str = do_read_string(ff);
2596 if (!str)
2597 goto error;
2598
2599 /* include a NULL character at the end */
2600 if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
2601 goto error;
2602 size += string_size(str);
2603 zfree(&str);
2604 }
2605 ph->env.sibling_threads = strbuf_detach(&sb, NULL);
2606
2607 /*
2608 * The header may be from old perf,
2609 * which doesn't include core id and socket id information.
2610 */
2611 if (ff->size <= size) {
2612 zfree(&ph->env.cpu);
2613 return 0;
2614 }
2615
2616 /* On s390 the socket_id number is not related to the numbers of cpus.
2617 * The socket_id number might be higher than the numbers of cpus.
2618 * This depends on the configuration.
2619 * AArch64 is the same.
2620 */
2621 if (ph->env.arch && (!strncmp(ph->env.arch, "s390", 4)
2622 || !strncmp(ph->env.arch, "aarch64", 7)))
2623 do_core_id_test = false;
2624
2625 for (i = 0; i < (u32)cpu_nr; i++) {
2626 if (do_read_u32(ff, &nr))
2627 goto free_cpu;
2628
2629 ph->env.cpu[i].core_id = nr;
2630 size += sizeof(u32);
2631
2632 if (do_read_u32(ff, &nr))
2633 goto free_cpu;
2634
2635 if (do_core_id_test && nr != (u32)-1 && nr > (u32)cpu_nr) {
2636 pr_debug("socket_id number is too big."
2637 "You may need to upgrade the perf tool.\n");
2638 goto free_cpu;
2639 }
2640
2641 ph->env.cpu[i].socket_id = nr;
2642 size += sizeof(u32);
2643 }
2644
2645 /*
2646 * The header may be from old perf,
2647 * which doesn't include die information.
2648 */
2649 if (ff->size <= size)
2650 return 0;
2651
2652 if (do_read_u32(ff, &nr))
2653 return -1;
2654
2655 ph->env.nr_sibling_dies = nr;
2656 size += sizeof(u32);
2657
2658 for (i = 0; i < nr; i++) {
2659 str = do_read_string(ff);
2660 if (!str)
2661 goto error;
2662
2663 /* include a NULL character at the end */
2664 if (strbuf_add(&sb, str, strlen(str) + 1) < 0)
2665 goto error;
2666 size += string_size(str);
2667 zfree(&str);
2668 }
2669 ph->env.sibling_dies = strbuf_detach(&sb, NULL);
2670
2671 for (i = 0; i < (u32)cpu_nr; i++) {
2672 if (do_read_u32(ff, &nr))
2673 goto free_cpu;
2674
2675 ph->env.cpu[i].die_id = nr;
2676 }
2677
2678 return 0;
2679
2680 error:
2681 strbuf_release(&sb);
2682 zfree(&str);
2683 free_cpu:
2684 zfree(&ph->env.cpu);
2685 return -1;
2686 }
2687
2688 static int process_numa_topology(struct feat_fd *ff, void *data __maybe_unused)
2689 {
2690 struct numa_node *nodes, *n;
2691 u32 nr, i;
2692 char *str;
2693
2694 /* nr nodes */
2695 if (do_read_u32(ff, &nr))
2696 return -1;
2697
2698 nodes = zalloc(sizeof(*nodes) * nr);
2699 if (!nodes)
2700 return -ENOMEM;
2701
2702 for (i = 0; i < nr; i++) {
2703 n = &nodes[i];
2704
2705 /* node number */
2706 if (do_read_u32(ff, &n->node))
2707 goto error;
2708
2709 if (do_read_u64(ff, &n->mem_total))
2710 goto error;
2711
2712 if (do_read_u64(ff, &n->mem_free))
2713 goto error;
2714
2715 str = do_read_string(ff);
2716 if (!str)
2717 goto error;
2718
2719 n->map = perf_cpu_map__new(str);
2720 free(str);
2721 if (!n->map)
2722 goto error;
2723 }
2724 ff->ph->env.nr_numa_nodes = nr;
2725 ff->ph->env.numa_nodes = nodes;
2726 return 0;
2727
2728 error:
2729 free(nodes);
2730 return -1;
2731 }
2732
2733 static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused)
2734 {
2735 char *name;
2736 u32 pmu_num;
2737 u32 type;
2738 struct strbuf sb;
2739
2740 if (do_read_u32(ff, &pmu_num))
2741 return -1;
2742
2743 if (!pmu_num) {
2744 pr_debug("pmu mappings not available\n");
2745 return 0;
2746 }
2747
2748 ff->ph->env.nr_pmu_mappings = pmu_num;
2749 if (strbuf_init(&sb, 128) < 0)
2750 return -1;
2751
2752 while (pmu_num) {
2753 if (do_read_u32(ff, &type))
2754 goto error;
2755
2756 name = do_read_string(ff);
2757 if (!name)
2758 goto error;
2759
2760 if (strbuf_addf(&sb, "%u:%s", type, name) < 0)
2761 goto error;
2762 /* include a NULL character at the end */
2763 if (strbuf_add(&sb, "", 1) < 0)
2764 goto error;
2765
2766 if (!strcmp(name, "msr"))
2767 ff->ph->env.msr_pmu_type = type;
2768
2769 free(name);
2770 pmu_num--;
2771 }
2772 ff->ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
2773 return 0;
2774
2775 error:
2776 strbuf_release(&sb);
2777 return -1;
2778 }
2779
2780 static int process_group_desc(struct feat_fd *ff, void *data __maybe_unused)
2781 {
2782 size_t ret = -1;
2783 u32 i, nr, nr_groups;
2784 struct perf_session *session;
2785 struct evsel *evsel, *leader = NULL;
2786 struct group_desc {
2787 char *name;
2788 u32 leader_idx;
2789 u32 nr_members;
2790 } *desc;
2791
2792 if (do_read_u32(ff, &nr_groups))
2793 return -1;
2794
2795 ff->ph->env.nr_groups = nr_groups;
2796 if (!nr_groups) {
2797 pr_debug("group desc not available\n");
2798 return 0;
2799 }
2800
2801 desc = calloc(nr_groups, sizeof(*desc));
2802 if (!desc)
2803 return -1;
2804
2805 for (i = 0; i < nr_groups; i++) {
2806 desc[i].name = do_read_string(ff);
2807 if (!desc[i].name)
2808 goto out_free;
2809
2810 if (do_read_u32(ff, &desc[i].leader_idx))
2811 goto out_free;
2812
2813 if (do_read_u32(ff, &desc[i].nr_members))
2814 goto out_free;
2815 }
2816
2817 /*
2818 * Rebuild group relationship based on the group_desc
2819 */
2820 session = container_of(ff->ph, struct perf_session, header);
2821
2822 i = nr = 0;
2823 evlist__for_each_entry(session->evlist, evsel) {
2824 if (i < nr_groups && evsel->core.idx == (int) desc[i].leader_idx) {
2825 evsel__set_leader(evsel, evsel);
2826 /* {anon_group} is a dummy name */
2827 if (strcmp(desc[i].name, "{anon_group}")) {
2828 evsel->group_name = desc[i].name;
2829 desc[i].name = NULL;
2830 }
2831 evsel->core.nr_members = desc[i].nr_members;
2832
2833 if (i >= nr_groups || nr > 0) {
2834 pr_debug("invalid group desc\n");
2835 goto out_free;
2836 }
2837
2838 leader = evsel;
2839 nr = evsel->core.nr_members - 1;
2840 i++;
2841 } else if (nr) {
2842 /* This is a group member */
2843 evsel__set_leader(evsel, leader);
2844
2845 nr--;
2846 }
2847 }
2848
2849 if (i != nr_groups || nr != 0) {
2850 pr_debug("invalid group desc\n");
2851 goto out_free;
2852 }
2853
2854 ret = 0;
2855 out_free:
2856 for (i = 0; i < nr_groups; i++)
2857 zfree(&desc[i].name);
2858 free(desc);
2859
2860 return ret;
2861 }
2862
2863 static int process_auxtrace(struct feat_fd *ff, void *data __maybe_unused)
2864 {
2865 struct perf_session *session;
2866 int err;
2867
2868 session = container_of(ff->ph, struct perf_session, header);
2869
2870 err = auxtrace_index__process(ff->fd, ff->size, session,
2871 ff->ph->needs_swap);
2872 if (err < 0)
2873 pr_err("Failed to process auxtrace index\n");
2874 return err;
2875 }
2876
2877 static int process_cache(struct feat_fd *ff, void *data __maybe_unused)
2878 {
2879 struct cpu_cache_level *caches;
2880 u32 cnt, i, version;
2881
2882 if (do_read_u32(ff, &version))
2883 return -1;
2884
2885 if (version != 1)
2886 return -1;
2887
2888 if (do_read_u32(ff, &cnt))
2889 return -1;
2890
2891 caches = zalloc(sizeof(*caches) * cnt);
2892 if (!caches)
2893 return -1;
2894
2895 for (i = 0; i < cnt; i++) {
2896 struct cpu_cache_level *c = &caches[i];
2897
2898 #define _R(v) \
2899 if (do_read_u32(ff, &c->v)) \
2900 goto out_free_caches; \
2901
2902 _R(level)
2903 _R(line_size)
2904 _R(sets)
2905 _R(ways)
2906 #undef _R
2907
2908 #define _R(v) \
2909 c->v = do_read_string(ff); \
2910 if (!c->v) \
2911 goto out_free_caches; \
2912
2913 _R(type)
2914 _R(size)
2915 _R(map)
2916 #undef _R
2917 }
2918
2919 ff->ph->env.caches = caches;
2920 ff->ph->env.caches_cnt = cnt;
2921 return 0;
2922 out_free_caches:
2923 for (i = 0; i < cnt; i++) {
2924 free(caches[i].type);
2925 free(caches[i].size);
2926 free(caches[i].map);
2927 }
2928 free(caches);
2929 return -1;
2930 }
2931
2932 static int process_sample_time(struct feat_fd *ff, void *data __maybe_unused)
2933 {
2934 struct perf_session *session;
2935 u64 first_sample_time, last_sample_time;
2936 int ret;
2937
2938 session = container_of(ff->ph, struct perf_session, header);
2939
2940 ret = do_read_u64(ff, &first_sample_time);
2941 if (ret)
2942 return -1;
2943
2944 ret = do_read_u64(ff, &last_sample_time);
2945 if (ret)
2946 return -1;
2947
2948 session->evlist->first_sample_time = first_sample_time;
2949 session->evlist->last_sample_time = last_sample_time;
2950 return 0;
2951 }
2952
2953 static int process_mem_topology(struct feat_fd *ff,
2954 void *data __maybe_unused)
2955 {
2956 struct memory_node *nodes;
2957 u64 version, i, nr, bsize;
2958 int ret = -1;
2959
2960 if (do_read_u64(ff, &version))
2961 return -1;
2962
2963 if (version != 1)
2964 return -1;
2965
2966 if (do_read_u64(ff, &bsize))
2967 return -1;
2968
2969 if (do_read_u64(ff, &nr))
2970 return -1;
2971
2972 nodes = zalloc(sizeof(*nodes) * nr);
2973 if (!nodes)
2974 return -1;
2975
2976 for (i = 0; i < nr; i++) {
2977 struct memory_node n;
2978
2979 #define _R(v) \
2980 if (do_read_u64(ff, &n.v)) \
2981 goto out; \
2982
2983 _R(node)
2984 _R(size)
2985
2986 #undef _R
2987
2988 if (do_read_bitmap(ff, &n.set, &n.size))
2989 goto out;
2990
2991 nodes[i] = n;
2992 }
2993
2994 ff->ph->env.memory_bsize = bsize;
2995 ff->ph->env.memory_nodes = nodes;
2996 ff->ph->env.nr_memory_nodes = nr;
2997 ret = 0;
2998
2999 out:
3000 if (ret)
3001 free(nodes);
3002 return ret;
3003 }
3004
3005 static int process_clockid(struct feat_fd *ff,
3006 void *data __maybe_unused)
3007 {
3008 if (do_read_u64(ff, &ff->ph->env.clock.clockid_res_ns))
3009 return -1;
3010
3011 return 0;
3012 }
3013
3014 static int process_clock_data(struct feat_fd *ff,
3015 void *_data __maybe_unused)
3016 {
3017 u32 data32;
3018 u64 data64;
3019
3020 /* version */
3021 if (do_read_u32(ff, &data32))
3022 return -1;
3023
3024 if (data32 != 1)
3025 return -1;
3026
3027 /* clockid */
3028 if (do_read_u32(ff, &data32))
3029 return -1;
3030
3031 ff->ph->env.clock.clockid = data32;
3032
3033 /* TOD ref time */
3034 if (do_read_u64(ff, &data64))
3035 return -1;
3036
3037 ff->ph->env.clock.tod_ns = data64;
3038
3039 /* clockid ref time */
3040 if (do_read_u64(ff, &data64))
3041 return -1;
3042
3043 ff->ph->env.clock.clockid_ns = data64;
3044 ff->ph->env.clock.enabled = true;
3045 return 0;
3046 }
3047
3048 static int process_hybrid_topology(struct feat_fd *ff,
3049 void *data __maybe_unused)
3050 {
3051 struct hybrid_node *nodes, *n;
3052 u32 nr, i;
3053
3054 /* nr nodes */
3055 if (do_read_u32(ff, &nr))
3056 return -1;
3057
3058 nodes = zalloc(sizeof(*nodes) * nr);
3059 if (!nodes)
3060 return -ENOMEM;
3061
3062 for (i = 0; i < nr; i++) {
3063 n = &nodes[i];
3064
3065 n->pmu_name = do_read_string(ff);
3066 if (!n->pmu_name)
3067 goto error;
3068
3069 n->cpus = do_read_string(ff);
3070 if (!n->cpus)
3071 goto error;
3072 }
3073
3074 ff->ph->env.nr_hybrid_nodes = nr;
3075 ff->ph->env.hybrid_nodes = nodes;
3076 return 0;
3077
3078 error:
3079 for (i = 0; i < nr; i++) {
3080 free(nodes[i].pmu_name);
3081 free(nodes[i].cpus);
3082 }
3083
3084 free(nodes);
3085 return -1;
3086 }
3087
3088 static int process_dir_format(struct feat_fd *ff,
3089 void *_data __maybe_unused)
3090 {
3091 struct perf_session *session;
3092 struct perf_data *data;
3093
3094 session = container_of(ff->ph, struct perf_session, header);
3095 data = session->data;
3096
3097 if (WARN_ON(!perf_data__is_dir(data)))
3098 return -1;
3099
3100 return do_read_u64(ff, &data->dir.version);
3101 }
3102
3103 #ifdef HAVE_LIBBPF_SUPPORT
3104 static int process_bpf_prog_info(struct feat_fd *ff, void *data __maybe_unused)
3105 {
3106 struct bpf_prog_info_node *info_node;
3107 struct perf_env *env = &ff->ph->env;
3108 struct perf_bpil *info_linear;
3109 u32 count, i;
3110 int err = -1;
3111
3112 if (ff->ph->needs_swap) {
3113 pr_warning("interpreting bpf_prog_info from systems with endianness is not yet supported\n");
3114 return 0;
3115 }
3116
3117 if (do_read_u32(ff, &count))
3118 return -1;
3119
3120 down_write(&env->bpf_progs.lock);
3121
3122 for (i = 0; i < count; ++i) {
3123 u32 info_len, data_len;
3124
3125 info_linear = NULL;
3126 info_node = NULL;
3127 if (do_read_u32(ff, &info_len))
3128 goto out;
3129 if (do_read_u32(ff, &data_len))
3130 goto out;
3131
3132 if (info_len > sizeof(struct bpf_prog_info)) {
3133 pr_warning("detected invalid bpf_prog_info\n");
3134 goto out;
3135 }
3136
3137 info_linear = malloc(sizeof(struct perf_bpil) +
3138 data_len);
3139 if (!info_linear)
3140 goto out;
3141 info_linear->info_len = sizeof(struct bpf_prog_info);
3142 info_linear->data_len = data_len;
3143 if (do_read_u64(ff, (u64 *)(&info_linear->arrays)))
3144 goto out;
3145 if (__do_read(ff, &info_linear->info, info_len))
3146 goto out;
3147 if (info_len < sizeof(struct bpf_prog_info))
3148 memset(((void *)(&info_linear->info)) + info_len, 0,
3149 sizeof(struct bpf_prog_info) - info_len);
3150
3151 if (__do_read(ff, info_linear->data, data_len))
3152 goto out;
3153
3154 info_node = malloc(sizeof(struct bpf_prog_info_node));
3155 if (!info_node)
3156 goto out;
3157
3158 /* after reading from file, translate offset to address */
3159 bpil_offs_to_addr(info_linear);
3160 info_node->info_linear = info_linear;
3161 __perf_env__insert_bpf_prog_info(env, info_node);
3162 }
3163
3164 up_write(&env->bpf_progs.lock);
3165 return 0;
3166 out:
3167 free(info_linear);
3168 free(info_node);
3169 up_write(&env->bpf_progs.lock);
3170 return err;
3171 }
3172
3173 static int process_bpf_btf(struct feat_fd *ff, void *data __maybe_unused)
3174 {
3175 struct perf_env *env = &ff->ph->env;
3176 struct btf_node *node = NULL;
3177 u32 count, i;
3178 int err = -1;
3179
3180 if (ff->ph->needs_swap) {
3181 pr_warning("interpreting btf from systems with endianness is not yet supported\n");
3182 return 0;
3183 }
3184
3185 if (do_read_u32(ff, &count))
3186 return -1;
3187
3188 down_write(&env->bpf_progs.lock);
3189
3190 for (i = 0; i < count; ++i) {
3191 u32 id, data_size;
3192
3193 if (do_read_u32(ff, &id))
3194 goto out;
3195 if (do_read_u32(ff, &data_size))
3196 goto out;
3197
3198 node = malloc(sizeof(struct btf_node) + data_size);
3199 if (!node)
3200 goto out;
3201
3202 node->id = id;
3203 node->data_size = data_size;
3204
3205 if (__do_read(ff, node->data, data_size))
3206 goto out;
3207
3208 __perf_env__insert_btf(env, node);
3209 node = NULL;
3210 }
3211
3212 err = 0;
3213 out:
3214 up_write(&env->bpf_progs.lock);
3215 free(node);
3216 return err;
3217 }
3218 #endif // HAVE_LIBBPF_SUPPORT
3219
3220 static int process_compressed(struct feat_fd *ff,
3221 void *data __maybe_unused)
3222 {
3223 if (do_read_u32(ff, &(ff->ph->env.comp_ver)))
3224 return -1;
3225
3226 if (do_read_u32(ff, &(ff->ph->env.comp_type)))
3227 return -1;
3228
3229 if (do_read_u32(ff, &(ff->ph->env.comp_level)))
3230 return -1;
3231
3232 if (do_read_u32(ff, &(ff->ph->env.comp_ratio)))
3233 return -1;
3234
3235 if (do_read_u32(ff, &(ff->ph->env.comp_mmap_len)))
3236 return -1;
3237
3238 return 0;
3239 }
3240
3241 static int __process_pmu_caps(struct feat_fd *ff, int *nr_caps,
3242 char ***caps, unsigned int *max_branches,
3243 unsigned int *br_cntr_nr,
3244 unsigned int *br_cntr_width)
3245 {
3246 char *name, *value, *ptr;
3247 u32 nr_pmu_caps, i;
3248
3249 *nr_caps = 0;
3250 *caps = NULL;
3251
3252 if (do_read_u32(ff, &nr_pmu_caps))
3253 return -1;
3254
3255 if (!nr_pmu_caps)
3256 return 0;
3257
3258 *caps = zalloc(sizeof(char *) * nr_pmu_caps);
3259 if (!*caps)
3260 return -1;
3261
3262 for (i = 0; i < nr_pmu_caps; i++) {
3263 name = do_read_string(ff);
3264 if (!name)
3265 goto error;
3266
3267 value = do_read_string(ff);
3268 if (!value)
3269 goto free_name;
3270
3271 if (asprintf(&ptr, "%s=%s", name, value) < 0)
3272 goto free_value;
3273
3274 (*caps)[i] = ptr;
3275
3276 if (!strcmp(name, "branches"))
3277 *max_branches = atoi(value);
3278
3279 if (!strcmp(name, "branch_counter_nr"))
3280 *br_cntr_nr = atoi(value);
3281
3282 if (!strcmp(name, "branch_counter_width"))
3283 *br_cntr_width = atoi(value);
3284
3285 free(value);
3286 free(name);
3287 }
3288 *nr_caps = nr_pmu_caps;
3289 return 0;
3290
3291 free_value:
3292 free(value);
3293 free_name:
3294 free(name);
3295 error:
3296 for (; i > 0; i--)
3297 free((*caps)[i - 1]);
3298 free(*caps);
3299 *caps = NULL;
3300 *nr_caps = 0;
3301 return -1;
3302 }
3303
3304 static int process_cpu_pmu_caps(struct feat_fd *ff,
3305 void *data __maybe_unused)
3306 {
3307 int ret = __process_pmu_caps(ff, &ff->ph->env.nr_cpu_pmu_caps,
3308 &ff->ph->env.cpu_pmu_caps,
3309 &ff->ph->env.max_branches,
3310 &ff->ph->env.br_cntr_nr,
3311 &ff->ph->env.br_cntr_width);
3312
3313 if (!ret && !ff->ph->env.cpu_pmu_caps)
3314 pr_debug("cpu pmu capabilities not available\n");
3315 return ret;
3316 }
3317
3318 static int process_pmu_caps(struct feat_fd *ff, void *data __maybe_unused)
3319 {
3320 struct pmu_caps *pmu_caps;
3321 u32 nr_pmu, i;
3322 int ret;
3323 int j;
3324
3325 if (do_read_u32(ff, &nr_pmu))
3326 return -1;
3327
3328 if (!nr_pmu) {
3329 pr_debug("pmu capabilities not available\n");
3330 return 0;
3331 }
3332
3333 pmu_caps = zalloc(sizeof(*pmu_caps) * nr_pmu);
3334 if (!pmu_caps)
3335 return -ENOMEM;
3336
3337 for (i = 0; i < nr_pmu; i++) {
3338 ret = __process_pmu_caps(ff, &pmu_caps[i].nr_caps,
3339 &pmu_caps[i].caps,
3340 &pmu_caps[i].max_branches,
3341 &pmu_caps[i].br_cntr_nr,
3342 &pmu_caps[i].br_cntr_width);
3343 if (ret)
3344 goto err;
3345
3346 pmu_caps[i].pmu_name = do_read_string(ff);
3347 if (!pmu_caps[i].pmu_name) {
3348 ret = -1;
3349 goto err;
3350 }
3351 if (!pmu_caps[i].nr_caps) {
3352 pr_debug("%s pmu capabilities not available\n",
3353 pmu_caps[i].pmu_name);
3354 }
3355 }
3356
3357 ff->ph->env.nr_pmus_with_caps = nr_pmu;
3358 ff->ph->env.pmu_caps = pmu_caps;
3359 return 0;
3360
3361 err:
3362 for (i = 0; i < nr_pmu; i++) {
3363 for (j = 0; j < pmu_caps[i].nr_caps; j++)
3364 free(pmu_caps[i].caps[j]);
3365 free(pmu_caps[i].caps);
3366 free(pmu_caps[i].pmu_name);
3367 }
3368
3369 free(pmu_caps);
3370 return ret;
3371 }
3372
3373 #define FEAT_OPR(n, func, __full_only) \
3374 [HEADER_##n] = { \
3375 .name = __stringify(n), \
3376 .write = write_##func, \
3377 .print = print_##func, \
3378 .full_only = __full_only, \
3379 .process = process_##func, \
3380 .synthesize = true \
3381 }
3382
3383 #define FEAT_OPN(n, func, __full_only) \
3384 [HEADER_##n] = { \
3385 .name = __stringify(n), \
3386 .write = write_##func, \
3387 .print = print_##func, \
3388 .full_only = __full_only, \
3389 .process = process_##func \
3390 }
3391
3392 /* feature_ops not implemented: */
3393 #define print_tracing_data NULL
3394 #define print_build_id NULL
3395
3396 #define process_branch_stack NULL
3397 #define process_stat NULL
3398
3399 // Only used in util/synthetic-events.c
3400 const struct perf_header_feature_ops feat_ops[HEADER_LAST_FEATURE];
3401
3402 const struct perf_header_feature_ops feat_ops[HEADER_LAST_FEATURE] = {
3403 #ifdef HAVE_LIBTRACEEVENT
3404 FEAT_OPN(TRACING_DATA, tracing_data, false),
3405 #endif
3406 FEAT_OPN(BUILD_ID, build_id, false),
3407 FEAT_OPR(HOSTNAME, hostname, false),
3408 FEAT_OPR(OSRELEASE, osrelease, false),
3409 FEAT_OPR(VERSION, version, false),
3410 FEAT_OPR(ARCH, arch, false),
3411 FEAT_OPR(NRCPUS, nrcpus, false),
3412 FEAT_OPR(CPUDESC, cpudesc, false),
3413 FEAT_OPR(CPUID, cpuid, false),
3414 FEAT_OPR(TOTAL_MEM, total_mem, false),
3415 FEAT_OPR(EVENT_DESC, event_desc, false),
3416 FEAT_OPR(CMDLINE, cmdline, false),
3417 FEAT_OPR(CPU_TOPOLOGY, cpu_topology, true),
3418 FEAT_OPR(NUMA_TOPOLOGY, numa_topology, true),
3419 FEAT_OPN(BRANCH_STACK, branch_stack, false),
3420 FEAT_OPR(PMU_MAPPINGS, pmu_mappings, false),
3421 FEAT_OPR(GROUP_DESC, group_desc, false),
3422 FEAT_OPN(AUXTRACE, auxtrace, false),
3423 FEAT_OPN(STAT, stat, false),
3424 FEAT_OPN(CACHE, cache, true),
3425 FEAT_OPR(SAMPLE_TIME, sample_time, false),
3426 FEAT_OPR(MEM_TOPOLOGY, mem_topology, true),
3427 FEAT_OPR(CLOCKID, clockid, false),
3428 FEAT_OPN(DIR_FORMAT, dir_format, false),
3429 #ifdef HAVE_LIBBPF_SUPPORT
3430 FEAT_OPR(BPF_PROG_INFO, bpf_prog_info, false),
3431 FEAT_OPR(BPF_BTF, bpf_btf, false),
3432 #endif
3433 FEAT_OPR(COMPRESSED, compressed, false),
3434 FEAT_OPR(CPU_PMU_CAPS, cpu_pmu_caps, false),
3435 FEAT_OPR(CLOCK_DATA, clock_data, false),
3436 FEAT_OPN(HYBRID_TOPOLOGY, hybrid_topology, true),
3437 FEAT_OPR(PMU_CAPS, pmu_caps, false),
3438 };
3439
3440 struct header_print_data {
3441 FILE *fp;
3442 bool full; /* extended list of headers */
3443 };
3444
3445 static int perf_file_section__fprintf_info(struct perf_file_section *section,
3446 struct perf_header *ph,
3447 int feat, int fd, void *data)
3448 {
3449 struct header_print_data *hd = data;
3450 struct feat_fd ff;
3451
3452 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
3453 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
3454 "%d, continuing...\n", section->offset, feat);
3455 return 0;
3456 }
3457 if (feat >= HEADER_LAST_FEATURE) {
3458 pr_warning("unknown feature %d\n", feat);
3459 return 0;
3460 }
3461 if (!feat_ops[feat].print)
3462 return 0;
3463
3464 ff = (struct feat_fd) {
3465 .fd = fd,
3466 .ph = ph,
3467 };
3468
3469 if (!feat_ops[feat].full_only || hd->full)
3470 feat_ops[feat].print(&ff, hd->fp);
3471 else
3472 fprintf(hd->fp, "# %s info available, use -I to display\n",
3473 feat_ops[feat].name);
3474
3475 return 0;
3476 }
3477
3478 int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
3479 {
3480 struct header_print_data hd;
3481 struct perf_header *header = &session->header;
3482 int fd = perf_data__fd(session->data);
3483 struct stat st;
3484 time_t stctime;
3485 int ret, bit;
3486
3487 hd.fp = fp;
3488 hd.full = full;
3489
3490 ret = fstat(fd, &st);
3491 if (ret == -1)
3492 return -1;
3493
3494 stctime = st.st_mtime;
3495 fprintf(fp, "# captured on : %s", ctime(&stctime));
3496
3497 fprintf(fp, "# header version : %u\n", header->version);
3498 fprintf(fp, "# data offset : %" PRIu64 "\n", header->data_offset);
3499 fprintf(fp, "# data size : %" PRIu64 "\n", header->data_size);
3500 fprintf(fp, "# feat offset : %" PRIu64 "\n", header->feat_offset);
3501
3502 perf_header__process_sections(header, fd, &hd,
3503 perf_file_section__fprintf_info);
3504
3505 if (session->data->is_pipe)
3506 return 0;
3507
3508 fprintf(fp, "# missing features: ");
3509 for_each_clear_bit(bit, header->adds_features, HEADER_LAST_FEATURE) {
3510 if (bit)
3511 fprintf(fp, "%s ", feat_ops[bit].name);
3512 }
3513
3514 fprintf(fp, "\n");
3515 return 0;
3516 }
3517
3518 struct header_fw {
3519 struct feat_writer fw;
3520 struct feat_fd *ff;
3521 };
3522
3523 static int feat_writer_cb(struct feat_writer *fw, void *buf, size_t sz)
3524 {
3525 struct header_fw *h = container_of(fw, struct header_fw, fw);
3526
3527 return do_write(h->ff, buf, sz);
3528 }
3529
3530 static int do_write_feat(struct feat_fd *ff, int type,
3531 struct perf_file_section **p,
3532 struct evlist *evlist,
3533 struct feat_copier *fc)
3534 {
3535 int err;
3536 int ret = 0;
3537
3538 if (perf_header__has_feat(ff->ph, type)) {
3539 if (!feat_ops[type].write)
3540 return -1;
3541
3542 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
3543 return -1;
3544
3545 (*p)->offset = lseek(ff->fd, 0, SEEK_CUR);
3546
3547 /*
3548 * Hook to let perf inject copy features sections from the input
3549 * file.
3550 */
3551 if (fc && fc->copy) {
3552 struct header_fw h = {
3553 .fw.write = feat_writer_cb,
3554 .ff = ff,
3555 };
3556
3557 /* ->copy() returns 0 if the feature was not copied */
3558 err = fc->copy(fc, type, &h.fw);
3559 } else {
3560 err = 0;
3561 }
3562 if (!err)
3563 err = feat_ops[type].write(ff, evlist);
3564 if (err < 0) {
3565 pr_debug("failed to write feature %s\n", feat_ops[type].name);
3566
3567 /* undo anything written */
3568 lseek(ff->fd, (*p)->offset, SEEK_SET);
3569
3570 return -1;
3571 }
3572 (*p)->size = lseek(ff->fd, 0, SEEK_CUR) - (*p)->offset;
3573 (*p)++;
3574 }
3575 return ret;
3576 }
3577
3578 static int perf_header__adds_write(struct perf_header *header,
3579 struct evlist *evlist, int fd,
3580 struct feat_copier *fc)
3581 {
3582 int nr_sections;
3583 struct feat_fd ff = {
3584 .fd = fd,
3585 .ph = header,
3586 };
3587 struct perf_file_section *feat_sec, *p;
3588 int sec_size;
3589 u64 sec_start;
3590 int feat;
3591 int err;
3592
3593 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
3594 if (!nr_sections)
3595 return 0;
3596
3597 feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));
3598 if (feat_sec == NULL)
3599 return -ENOMEM;
3600
3601 sec_size = sizeof(*feat_sec) * nr_sections;
3602
3603 sec_start = header->feat_offset;
3604 lseek(fd, sec_start + sec_size, SEEK_SET);
3605
3606 for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
3607 if (do_write_feat(&ff, feat, &p, evlist, fc))
3608 perf_header__clear_feat(header, feat);
3609 }
3610
3611 lseek(fd, sec_start, SEEK_SET);
3612 /*
3613 * may write more than needed due to dropped feature, but
3614 * this is okay, reader will skip the missing entries
3615 */
3616 err = do_write(&ff, feat_sec, sec_size);
3617 if (err < 0)
3618 pr_debug("failed to write feature section\n");
3619 free(ff.buf); /* TODO: added to silence clang-tidy. */
3620 free(feat_sec);
3621 return err;
3622 }
3623
3624 int perf_header__write_pipe(int fd)
3625 {
3626 struct perf_pipe_file_header f_header;
3627 struct feat_fd ff = {
3628 .fd = fd,
3629 };
3630 int err;
3631
3632 f_header = (struct perf_pipe_file_header){
3633 .magic = PERF_MAGIC,
3634 .size = sizeof(f_header),
3635 };
3636
3637 err = do_write(&ff, &f_header, sizeof(f_header));
3638 if (err < 0) {
3639 pr_debug("failed to write perf pipe header\n");
3640 return err;
3641 }
3642 free(ff.buf);
3643 return 0;
3644 }
3645
3646 static int perf_session__do_write_header(struct perf_session *session,
3647 struct evlist *evlist,
3648 int fd, bool at_exit,
3649 struct feat_copier *fc,
3650 bool write_attrs_after_data)
3651 {
3652 struct perf_file_header f_header;
3653 struct perf_header *header = &session->header;
3654 struct evsel *evsel;
3655 struct feat_fd ff = {
3656 .fd = fd,
3657 };
3658 u64 attr_offset = sizeof(f_header), attr_size = 0;
3659 int err;
3660
3661 if (write_attrs_after_data && at_exit) {
3662 /*
3663 * Write features at the end of the file first so that
3664 * attributes may come after them.
3665 */
3666 if (!header->data_offset && header->data_size) {
3667 pr_err("File contains data but offset unknown\n");
3668 err = -1;
3669 goto err_out;
3670 }
3671 header->feat_offset = header->data_offset + header->data_size;
3672 err = perf_header__adds_write(header, evlist, fd, fc);
3673 if (err < 0)
3674 goto err_out;
3675 attr_offset = lseek(fd, 0, SEEK_CUR);
3676 } else {
3677 lseek(fd, attr_offset, SEEK_SET);
3678 }
3679
3680 evlist__for_each_entry(session->evlist, evsel) {
3681 evsel->id_offset = attr_offset;
3682 /* Avoid writing at the end of the file until the session is exiting. */
3683 if (!write_attrs_after_data || at_exit) {
3684 err = do_write(&ff, evsel->core.id, evsel->core.ids * sizeof(u64));
3685 if (err < 0) {
3686 pr_debug("failed to write perf header\n");
3687 goto err_out;
3688 }
3689 }
3690 attr_offset += evsel->core.ids * sizeof(u64);
3691 }
3692
3693 evlist__for_each_entry(evlist, evsel) {
3694 if (evsel->core.attr.size < sizeof(evsel->core.attr)) {
3695 /*
3696 * We are likely in "perf inject" and have read
3697 * from an older file. Update attr size so that
3698 * reader gets the right offset to the ids.
3699 */
3700 evsel->core.attr.size = sizeof(evsel->core.attr);
3701 }
3702 /* Avoid writing at the end of the file until the session is exiting. */
3703 if (!write_attrs_after_data || at_exit) {
3704 struct perf_file_attr f_attr = {
3705 .attr = evsel->core.attr,
3706 .ids = {
3707 .offset = evsel->id_offset,
3708 .size = evsel->core.ids * sizeof(u64),
3709 }
3710 };
3711 err = do_write(&ff, &f_attr, sizeof(f_attr));
3712 if (err < 0) {
3713 pr_debug("failed to write perf header attribute\n");
3714 goto err_out;
3715 }
3716 }
3717 attr_size += sizeof(struct perf_file_attr);
3718 }
3719
3720 if (!header->data_offset) {
3721 if (write_attrs_after_data)
3722 header->data_offset = sizeof(f_header);
3723 else
3724 header->data_offset = attr_offset + attr_size;
3725 }
3726 header->feat_offset = header->data_offset + header->data_size;
3727
3728 if (!write_attrs_after_data && at_exit) {
3729 /* Write features now feat_offset is known. */
3730 err = perf_header__adds_write(header, evlist, fd, fc);
3731 if (err < 0)
3732 goto err_out;
3733 }
3734
3735 f_header = (struct perf_file_header){
3736 .magic = PERF_MAGIC,
3737 .size = sizeof(f_header),
3738 .attr_size = sizeof(struct perf_file_attr),
3739 .attrs = {
3740 .offset = attr_offset,
3741 .size = attr_size,
3742 },
3743 .data = {
3744 .offset = header->data_offset,
3745 .size = header->data_size,
3746 },
3747 /* event_types is ignored, store zeros */
3748 };
3749
3750 memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
3751
3752 lseek(fd, 0, SEEK_SET);
3753 err = do_write(&ff, &f_header, sizeof(f_header));
3754 if (err < 0) {
3755 pr_debug("failed to write perf header\n");
3756 goto err_out;
3757 } else {
3758 lseek(fd, 0, SEEK_END);
3759 err = 0;
3760 }
3761 err_out:
3762 free(ff.buf);
3763 return err;
3764 }
3765
3766 int perf_session__write_header(struct perf_session *session,
3767 struct evlist *evlist,
3768 int fd, bool at_exit)
3769 {
3770 return perf_session__do_write_header(session, evlist, fd, at_exit, /*fc=*/NULL,
3771 /*write_attrs_after_data=*/false);
3772 }
3773
3774 size_t perf_session__data_offset(const struct evlist *evlist)
3775 {
3776 struct evsel *evsel;
3777 size_t data_offset;
3778
3779 data_offset = sizeof(struct perf_file_header);
3780 evlist__for_each_entry(evlist, evsel) {
3781 data_offset += evsel->core.ids * sizeof(u64);
3782 }
3783 data_offset += evlist->core.nr_entries * sizeof(struct perf_file_attr);
3784
3785 return data_offset;
3786 }
3787
3788 int perf_session__inject_header(struct perf_session *session,
3789 struct evlist *evlist,
3790 int fd,
3791 struct feat_copier *fc,
3792 bool write_attrs_after_data)
3793 {
3794 return perf_session__do_write_header(session, evlist, fd, true, fc,
3795 write_attrs_after_data);
3796 }
3797
3798 static int perf_header__getbuffer64(struct perf_header *header,
3799 int fd, void *buf, size_t size)
3800 {
3801 if (readn(fd, buf, size) <= 0)
3802 return -1;
3803
3804 if (header->needs_swap)
3805 mem_bswap_64(buf, size);
3806
3807 return 0;
3808 }
3809
3810 int perf_header__process_sections(struct perf_header *header, int fd,
3811 void *data,
3812 int (*process)(struct perf_file_section *section,
3813 struct perf_header *ph,
3814 int feat, int fd, void *data))
3815 {
3816 struct perf_file_section *feat_sec, *sec;
3817 int nr_sections;
3818 int sec_size;
3819 int feat;
3820 int err;
3821
3822 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
3823 if (!nr_sections)
3824 return 0;
3825
3826 feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec));
3827 if (!feat_sec)
3828 return -1;
3829
3830 sec_size = sizeof(*feat_sec) * nr_sections;
3831
3832 lseek(fd, header->feat_offset, SEEK_SET);
3833
3834 err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
3835 if (err < 0)
3836 goto out_free;
3837
3838 for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
3839 err = process(sec++, header, feat, fd, data);
3840 if (err < 0)
3841 goto out_free;
3842 }
3843 err = 0;
3844 out_free:
3845 free(feat_sec);
3846 return err;
3847 }
3848
3849 static const int attr_file_abi_sizes[] = {
3850 [0] = PERF_ATTR_SIZE_VER0,
3851 [1] = PERF_ATTR_SIZE_VER1,
3852 [2] = PERF_ATTR_SIZE_VER2,
3853 [3] = PERF_ATTR_SIZE_VER3,
3854 [4] = PERF_ATTR_SIZE_VER4,
3855 0,
3856 };
3857
3858 /*
3859 * In the legacy file format, the magic number is not used to encode endianness.
3860 * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
3861 * on ABI revisions, we need to try all combinations for all endianness to
3862 * detect the endianness.
3863 */
3864 static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph)
3865 {
3866 uint64_t ref_size, attr_size;
3867 int i;
3868
3869 for (i = 0 ; attr_file_abi_sizes[i]; i++) {
3870 ref_size = attr_file_abi_sizes[i]
3871 + sizeof(struct perf_file_section);
3872 if (hdr_sz != ref_size) {
3873 attr_size = bswap_64(hdr_sz);
3874 if (attr_size != ref_size)
3875 continue;
3876
3877 ph->needs_swap = true;
3878 }
3879 pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
3880 i,
3881 ph->needs_swap);
3882 return 0;
3883 }
3884 /* could not determine endianness */
3885 return -1;
3886 }
3887
3888 #define PERF_PIPE_HDR_VER0 16
3889
3890 static const size_t attr_pipe_abi_sizes[] = {
3891 [0] = PERF_PIPE_HDR_VER0,
3892 0,
3893 };
3894
3895 /*
3896 * In the legacy pipe format, there is an implicit assumption that endianness
3897 * between host recording the samples, and host parsing the samples is the
3898 * same. This is not always the case given that the pipe output may always be
3899 * redirected into a file and analyzed on a different machine with possibly a
3900 * different endianness and perf_event ABI revisions in the perf tool itself.
3901 */
3902 static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph)
3903 {
3904 u64 attr_size;
3905 int i;
3906
3907 for (i = 0 ; attr_pipe_abi_sizes[i]; i++) {
3908 if (hdr_sz != attr_pipe_abi_sizes[i]) {
3909 attr_size = bswap_64(hdr_sz);
3910 if (attr_size != hdr_sz)
3911 continue;
3912
3913 ph->needs_swap = true;
3914 }
3915 pr_debug("Pipe ABI%d perf.data file detected\n", i);
3916 return 0;
3917 }
3918 return -1;
3919 }
3920
3921 bool is_perf_magic(u64 magic)
3922 {
3923 if (!memcmp(&magic, __perf_magic1, sizeof(magic))
3924 || magic == __perf_magic2
3925 || magic == __perf_magic2_sw)
3926 return true;
3927
3928 return false;
3929 }
3930
3931 static int check_magic_endian(u64 magic, uint64_t hdr_sz,
3932 bool is_pipe, struct perf_header *ph)
3933 {
3934 int ret;
3935
3936 /* check for legacy format */
3937 ret = memcmp(&magic, __perf_magic1, sizeof(magic));
3938 if (ret == 0) {
3939 ph->version = PERF_HEADER_VERSION_1;
3940 pr_debug("legacy perf.data format\n");
3941 if (is_pipe)
3942 return try_all_pipe_abis(hdr_sz, ph);
3943
3944 return try_all_file_abis(hdr_sz, ph);
3945 }
3946 /*
3947 * the new magic number serves two purposes:
3948 * - unique number to identify actual perf.data files
3949 * - encode endianness of file
3950 */
3951 ph->version = PERF_HEADER_VERSION_2;
3952
3953 /* check magic number with one endianness */
3954 if (magic == __perf_magic2)
3955 return 0;
3956
3957 /* check magic number with opposite endianness */
3958 if (magic != __perf_magic2_sw)
3959 return -1;
3960
3961 ph->needs_swap = true;
3962
3963 return 0;
3964 }
3965
3966 int perf_file_header__read(struct perf_file_header *header,
3967 struct perf_header *ph, int fd)
3968 {
3969 ssize_t ret;
3970
3971 lseek(fd, 0, SEEK_SET);
3972
3973 ret = readn(fd, header, sizeof(*header));
3974 if (ret <= 0)
3975 return -1;
3976
3977 if (check_magic_endian(header->magic,
3978 header->attr_size, false, ph) < 0) {
3979 pr_debug("magic/endian check failed\n");
3980 return -1;
3981 }
3982
3983 if (ph->needs_swap) {
3984 mem_bswap_64(header, offsetof(struct perf_file_header,
3985 adds_features));
3986 }
3987
3988 if (header->size > header->attrs.offset) {
3989 pr_err("Perf file header corrupt: header overlaps attrs\n");
3990 return -1;
3991 }
3992
3993 if (header->size > header->data.offset) {
3994 pr_err("Perf file header corrupt: header overlaps data\n");
3995 return -1;
3996 }
3997
3998 if ((header->attrs.offset <= header->data.offset &&
3999 header->attrs.offset + header->attrs.size > header->data.offset) ||
4000 (header->attrs.offset > header->data.offset &&
4001 header->data.offset + header->data.size > header->attrs.offset)) {
4002 pr_err("Perf file header corrupt: Attributes and data overlap\n");
4003 return -1;
4004 }
4005
4006 if (header->size != sizeof(*header)) {
4007 /* Support the previous format */
4008 if (header->size == offsetof(typeof(*header), adds_features))
4009 bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
4010 else
4011 return -1;
4012 } else if (ph->needs_swap) {
4013 /*
4014 * feature bitmap is declared as an array of unsigned longs --
4015 * not good since its size can differ between the host that
4016 * generated the data file and the host analyzing the file.
4017 *
4018 * We need to handle endianness, but we don't know the size of
4019 * the unsigned long where the file was generated. Take a best
4020 * guess at determining it: try 64-bit swap first (ie., file
4021 * created on a 64-bit host), and check if the hostname feature
4022 * bit is set (this feature bit is forced on as of fbe96f2).
4023 * If the bit is not, undo the 64-bit swap and try a 32-bit
4024 * swap. If the hostname bit is still not set (e.g., older data
4025 * file), punt and fallback to the original behavior --
4026 * clearing all feature bits and setting buildid.
4027 */
4028 mem_bswap_64(&header->adds_features,
4029 BITS_TO_U64(HEADER_FEAT_BITS));
4030
4031 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
4032 /* unswap as u64 */
4033 mem_bswap_64(&header->adds_features,
4034 BITS_TO_U64(HEADER_FEAT_BITS));
4035
4036 /* unswap as u32 */
4037 mem_bswap_32(&header->adds_features,
4038 BITS_TO_U32(HEADER_FEAT_BITS));
4039 }
4040
4041 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
4042 bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
4043 __set_bit(HEADER_BUILD_ID, header->adds_features);
4044 }
4045 }
4046
4047 memcpy(&ph->adds_features, &header->adds_features,
4048 sizeof(ph->adds_features));
4049
4050 ph->data_offset = header->data.offset;
4051 ph->data_size = header->data.size;
4052 ph->feat_offset = header->data.offset + header->data.size;
4053 return 0;
4054 }
4055
4056 static int perf_file_section__process(struct perf_file_section *section,
4057 struct perf_header *ph,
4058 int feat, int fd, void *data)
4059 {
4060 struct feat_fd fdd = {
4061 .fd = fd,
4062 .ph = ph,
4063 .size = section->size,
4064 .offset = section->offset,
4065 };
4066
4067 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
4068 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
4069 "%d, continuing...\n", section->offset, feat);
4070 return 0;
4071 }
4072
4073 if (feat >= HEADER_LAST_FEATURE) {
4074 pr_debug("unknown feature %d, continuing...\n", feat);
4075 return 0;
4076 }
4077
4078 if (!feat_ops[feat].process)
4079 return 0;
4080
4081 return feat_ops[feat].process(&fdd, data);
4082 }
4083
4084 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
4085 struct perf_header *ph,
4086 struct perf_data *data)
4087 {
4088 ssize_t ret;
4089
4090 ret = perf_data__read(data, header, sizeof(*header));
4091 if (ret <= 0)
4092 return -1;
4093
4094 if (check_magic_endian(header->magic, header->size, true, ph) < 0) {
4095 pr_debug("endian/magic failed\n");
4096 return -1;
4097 }
4098
4099 if (ph->needs_swap)
4100 header->size = bswap_64(header->size);
4101
4102 return 0;
4103 }
4104
4105 static int perf_header__read_pipe(struct perf_session *session)
4106 {
4107 struct perf_header *header = &session->header;
4108 struct perf_pipe_file_header f_header;
4109
4110 if (perf_file_header__read_pipe(&f_header, header, session->data) < 0) {
4111 pr_debug("incompatible file format\n");
4112 return -EINVAL;
4113 }
4114
4115 return f_header.size == sizeof(f_header) ? 0 : -1;
4116 }
4117
4118 static int read_attr(int fd, struct perf_header *ph,
4119 struct perf_file_attr *f_attr)
4120 {
4121 struct perf_event_attr *attr = &f_attr->attr;
4122 size_t sz, left;
4123 size_t our_sz = sizeof(f_attr->attr);
4124 ssize_t ret;
4125
4126 memset(f_attr, 0, sizeof(*f_attr));
4127
4128 /* read minimal guaranteed structure */
4129 ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
4130 if (ret <= 0) {
4131 pr_debug("cannot read %d bytes of header attr\n",
4132 PERF_ATTR_SIZE_VER0);
4133 return -1;
4134 }
4135
4136 /* on file perf_event_attr size */
4137 sz = attr->size;
4138
4139 if (ph->needs_swap)
4140 sz = bswap_32(sz);
4141
4142 if (sz == 0) {
4143 /* assume ABI0 */
4144 sz = PERF_ATTR_SIZE_VER0;
4145 } else if (sz > our_sz) {
4146 pr_debug("file uses a more recent and unsupported ABI"
4147 " (%zu bytes extra)\n", sz - our_sz);
4148 return -1;
4149 }
4150 /* what we have not yet read and that we know about */
4151 left = sz - PERF_ATTR_SIZE_VER0;
4152 if (left) {
4153 void *ptr = attr;
4154 ptr += PERF_ATTR_SIZE_VER0;
4155
4156 ret = readn(fd, ptr, left);
4157 }
4158 /* read perf_file_section, ids are read in caller */
4159 ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));
4160
4161 return ret <= 0 ? -1 : 0;
4162 }
4163
4164 #ifdef HAVE_LIBTRACEEVENT
4165 static int evsel__prepare_tracepoint_event(struct evsel *evsel, struct tep_handle *pevent)
4166 {
4167 struct tep_event *event;
4168 char bf[128];
4169
4170 /* already prepared */
4171 if (evsel->tp_format)
4172 return 0;
4173
4174 if (pevent == NULL) {
4175 pr_debug("broken or missing trace data\n");
4176 return -1;
4177 }
4178
4179 event = tep_find_event(pevent, evsel->core.attr.config);
4180 if (event == NULL) {
4181 pr_debug("cannot find event format for %d\n", (int)evsel->core.attr.config);
4182 return -1;
4183 }
4184
4185 if (!evsel->name) {
4186 snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
4187 evsel->name = strdup(bf);
4188 if (evsel->name == NULL)
4189 return -1;
4190 }
4191
4192 evsel->tp_format = event;
4193 return 0;
4194 }
4195
4196 static int evlist__prepare_tracepoint_events(struct evlist *evlist, struct tep_handle *pevent)
4197 {
4198 struct evsel *pos;
4199
4200 evlist__for_each_entry(evlist, pos) {
4201 if (pos->core.attr.type == PERF_TYPE_TRACEPOINT &&
4202 evsel__prepare_tracepoint_event(pos, pevent))
4203 return -1;
4204 }
4205
4206 return 0;
4207 }
4208 #endif
4209
4210 int perf_session__read_header(struct perf_session *session)
4211 {
4212 struct perf_data *data = session->data;
4213 struct perf_header *header = &session->header;
4214 struct perf_file_header f_header;
4215 struct perf_file_attr f_attr;
4216 u64 f_id;
4217 int nr_attrs, nr_ids, i, j, err;
4218 int fd = perf_data__fd(data);
4219
4220 session->evlist = evlist__new();
4221 if (session->evlist == NULL)
4222 return -ENOMEM;
4223
4224 session->evlist->env = &header->env;
4225 session->machines.host.env = &header->env;
4226
4227 /*
4228 * We can read 'pipe' data event from regular file,
4229 * check for the pipe header regardless of source.
4230 */
4231 err = perf_header__read_pipe(session);
4232 if (!err || perf_data__is_pipe(data)) {
4233 data->is_pipe = true;
4234 return err;
4235 }
4236
4237 if (perf_file_header__read(&f_header, header, fd) < 0)
4238 return -EINVAL;
4239
4240 if (header->needs_swap && data->in_place_update) {
4241 pr_err("In-place update not supported when byte-swapping is required\n");
4242 return -EINVAL;
4243 }
4244
4245 /*
4246 * Sanity check that perf.data was written cleanly; data size is
4247 * initialized to 0 and updated only if the on_exit function is run.
4248 * If data size is still 0 then the file contains only partial
4249 * information. Just warn user and process it as much as it can.
4250 */
4251 if (f_header.data.size == 0) {
4252 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
4253 "Was the 'perf record' command properly terminated?\n",
4254 data->file.path);
4255 }
4256
4257 if (f_header.attr_size == 0) {
4258 pr_err("ERROR: The %s file's attr size field is 0 which is unexpected.\n"
4259 "Was the 'perf record' command properly terminated?\n",
4260 data->file.path);
4261 return -EINVAL;
4262 }
4263
4264 nr_attrs = f_header.attrs.size / f_header.attr_size;
4265 lseek(fd, f_header.attrs.offset, SEEK_SET);
4266
4267 for (i = 0; i < nr_attrs; i++) {
4268 struct evsel *evsel;
4269 off_t tmp;
4270
4271 if (read_attr(fd, header, &f_attr) < 0)
4272 goto out_errno;
4273
4274 if (header->needs_swap) {
4275 f_attr.ids.size = bswap_64(f_attr.ids.size);
4276 f_attr.ids.offset = bswap_64(f_attr.ids.offset);
4277 perf_event__attr_swap(&f_attr.attr);
4278 }
4279
4280 tmp = lseek(fd, 0, SEEK_CUR);
4281 evsel = evsel__new(&f_attr.attr);
4282
4283 if (evsel == NULL)
4284 goto out_delete_evlist;
4285
4286 evsel->needs_swap = header->needs_swap;
4287 /*
4288 * Do it before so that if perf_evsel__alloc_id fails, this
4289 * entry gets purged too at evlist__delete().
4290 */
4291 evlist__add(session->evlist, evsel);
4292
4293 nr_ids = f_attr.ids.size / sizeof(u64);
4294 /*
4295 * We don't have the cpu and thread maps on the header, so
4296 * for allocating the perf_sample_id table we fake 1 cpu and
4297 * hattr->ids threads.
4298 */
4299 if (perf_evsel__alloc_id(&evsel->core, 1, nr_ids))
4300 goto out_delete_evlist;
4301
4302 lseek(fd, f_attr.ids.offset, SEEK_SET);
4303
4304 for (j = 0; j < nr_ids; j++) {
4305 if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
4306 goto out_errno;
4307
4308 perf_evlist__id_add(&session->evlist->core, &evsel->core, 0, j, f_id);
4309 }
4310
4311 lseek(fd, tmp, SEEK_SET);
4312 }
4313
4314 #ifdef HAVE_LIBTRACEEVENT
4315 perf_header__process_sections(header, fd, &session->tevent,
4316 perf_file_section__process);
4317
4318 if (evlist__prepare_tracepoint_events(session->evlist, session->tevent.pevent))
4319 goto out_delete_evlist;
4320 #else
4321 perf_header__process_sections(header, fd, NULL, perf_file_section__process);
4322 #endif
4323
4324 return 0;
4325 out_errno:
4326 return -errno;
4327
4328 out_delete_evlist:
4329 evlist__delete(session->evlist);
4330 session->evlist = NULL;
4331 return -ENOMEM;
4332 }
4333
4334 int perf_event__process_feature(struct perf_session *session,
4335 union perf_event *event)
4336 {
4337 const struct perf_tool *tool = session->tool;
4338 struct feat_fd ff = { .fd = 0 };
4339 struct perf_record_header_feature *fe = (struct perf_record_header_feature *)event;
4340 int type = fe->header.type;
4341 u64 feat = fe->feat_id;
4342 int ret = 0;
4343
4344 if (type < 0 || type >= PERF_RECORD_HEADER_MAX) {
4345 pr_warning("invalid record type %d in pipe-mode\n", type);
4346 return 0;
4347 }
4348 if (feat == HEADER_RESERVED || feat >= HEADER_LAST_FEATURE) {
4349 pr_warning("invalid record type %d in pipe-mode\n", type);
4350 return -1;
4351 }
4352
4353 if (!feat_ops[feat].process)
4354 return 0;
4355
4356 ff.buf = (void *)fe->data;
4357 ff.size = event->header.size - sizeof(*fe);
4358 ff.ph = &session->header;
4359
4360 if (feat_ops[feat].process(&ff, NULL)) {
4361 ret = -1;
4362 goto out;
4363 }
4364
4365 if (!feat_ops[feat].print || !tool->show_feat_hdr)
4366 goto out;
4367
4368 if (!feat_ops[feat].full_only ||
4369 tool->show_feat_hdr >= SHOW_FEAT_HEADER_FULL_INFO) {
4370 feat_ops[feat].print(&ff, stdout);
4371 } else {
4372 fprintf(stdout, "# %s info available, use -I to display\n",
4373 feat_ops[feat].name);
4374 }
4375 out:
4376 free_event_desc(ff.events);
4377 return ret;
4378 }
4379
4380 size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
4381 {
4382 struct perf_record_event_update *ev = &event->event_update;
4383 struct perf_cpu_map *map;
4384 size_t ret;
4385
4386 ret = fprintf(fp, "\n... id: %" PRI_lu64 "\n", ev->id);
4387
4388 switch (ev->type) {
4389 case PERF_EVENT_UPDATE__SCALE:
4390 ret += fprintf(fp, "... scale: %f\n", ev->scale.scale);
4391 break;
4392 case PERF_EVENT_UPDATE__UNIT:
4393 ret += fprintf(fp, "... unit: %s\n", ev->unit);
4394 break;
4395 case PERF_EVENT_UPDATE__NAME:
4396 ret += fprintf(fp, "... name: %s\n", ev->name);
4397 break;
4398 case PERF_EVENT_UPDATE__CPUS:
4399 ret += fprintf(fp, "... ");
4400
4401 map = cpu_map__new_data(&ev->cpus.cpus);
4402 if (map) {
4403 ret += cpu_map__fprintf(map, fp);
4404 perf_cpu_map__put(map);
4405 } else
4406 ret += fprintf(fp, "failed to get cpus\n");
4407 break;
4408 default:
4409 ret += fprintf(fp, "... unknown type\n");
4410 break;
4411 }
4412
4413 return ret;
4414 }
4415
4416 int perf_event__process_attr(const struct perf_tool *tool __maybe_unused,
4417 union perf_event *event,
4418 struct evlist **pevlist)
4419 {
4420 u32 i, n_ids;
4421 u64 *ids;
4422 struct evsel *evsel;
4423 struct evlist *evlist = *pevlist;
4424
4425 if (evlist == NULL) {
4426 *pevlist = evlist = evlist__new();
4427 if (evlist == NULL)
4428 return -ENOMEM;
4429 }
4430
4431 evsel = evsel__new(&event->attr.attr);
4432 if (evsel == NULL)
4433 return -ENOMEM;
4434
4435 evlist__add(evlist, evsel);
4436
4437 n_ids = event->header.size - sizeof(event->header) - event->attr.attr.size;
4438 n_ids = n_ids / sizeof(u64);
4439 /*
4440 * We don't have the cpu and thread maps on the header, so
4441 * for allocating the perf_sample_id table we fake 1 cpu and
4442 * hattr->ids threads.
4443 */
4444 if (perf_evsel__alloc_id(&evsel->core, 1, n_ids))
4445 return -ENOMEM;
4446
4447 ids = perf_record_header_attr_id(event);
4448 for (i = 0; i < n_ids; i++) {
4449 perf_evlist__id_add(&evlist->core, &evsel->core, 0, i, ids[i]);
4450 }
4451
4452 return 0;
4453 }
4454
4455 int perf_event__process_event_update(const struct perf_tool *tool __maybe_unused,
4456 union perf_event *event,
4457 struct evlist **pevlist)
4458 {
4459 struct perf_record_event_update *ev = &event->event_update;
4460 struct evlist *evlist;
4461 struct evsel *evsel;
4462 struct perf_cpu_map *map;
4463
4464 if (dump_trace)
4465 perf_event__fprintf_event_update(event, stdout);
4466
4467 if (!pevlist || *pevlist == NULL)
4468 return -EINVAL;
4469
4470 evlist = *pevlist;
4471
4472 evsel = evlist__id2evsel(evlist, ev->id);
4473 if (evsel == NULL)
4474 return -EINVAL;
4475
4476 switch (ev->type) {
4477 case PERF_EVENT_UPDATE__UNIT:
4478 free((char *)evsel->unit);
4479 evsel->unit = strdup(ev->unit);
4480 break;
4481 case PERF_EVENT_UPDATE__NAME:
4482 free(evsel->name);
4483 evsel->name = strdup(ev->name);
4484 break;
4485 case PERF_EVENT_UPDATE__SCALE:
4486 evsel->scale = ev->scale.scale;
4487 break;
4488 case PERF_EVENT_UPDATE__CPUS:
4489 map = cpu_map__new_data(&ev->cpus.cpus);
4490 if (map) {
4491 perf_cpu_map__put(evsel->core.own_cpus);
4492 evsel->core.own_cpus = map;
4493 } else
4494 pr_err("failed to get event_update cpus\n");
4495 default:
4496 break;
4497 }
4498
4499 return 0;
4500 }
4501
4502 #ifdef HAVE_LIBTRACEEVENT
4503 int perf_event__process_tracing_data(struct perf_session *session,
4504 union perf_event *event)
4505 {
4506 ssize_t size_read, padding, size = event->tracing_data.size;
4507 int fd = perf_data__fd(session->data);
4508 char buf[BUFSIZ];
4509
4510 /*
4511 * The pipe fd is already in proper place and in any case
4512 * we can't move it, and we'd screw the case where we read
4513 * 'pipe' data from regular file. The trace_report reads
4514 * data from 'fd' so we need to set it directly behind the
4515 * event, where the tracing data starts.
4516 */
4517 if (!perf_data__is_pipe(session->data)) {
4518 off_t offset = lseek(fd, 0, SEEK_CUR);
4519
4520 /* setup for reading amidst mmap */
4521 lseek(fd, offset + sizeof(struct perf_record_header_tracing_data),
4522 SEEK_SET);
4523 }
4524
4525 size_read = trace_report(fd, &session->tevent, session->trace_event_repipe);
4526 padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
4527
4528 if (readn(fd, buf, padding) < 0) {
4529 pr_err("%s: reading input file", __func__);
4530 return -1;
4531 }
4532 if (session->trace_event_repipe) {
4533 int retw = write(STDOUT_FILENO, buf, padding);
4534 if (retw <= 0 || retw != padding) {
4535 pr_err("%s: repiping tracing data padding", __func__);
4536 return -1;
4537 }
4538 }
4539
4540 if (size_read + padding != size) {
4541 pr_err("%s: tracing data size mismatch", __func__);
4542 return -1;
4543 }
4544
4545 evlist__prepare_tracepoint_events(session->evlist, session->tevent.pevent);
4546
4547 return size_read + padding;
4548 }
4549 #endif
4550
4551 int perf_event__process_build_id(struct perf_session *session,
4552 union perf_event *event)
4553 {
4554 __event_process_build_id(&event->build_id,
4555 event->build_id.filename,
4556 session);
4557 return 0;
4558 }
Kernel DRM miscellaneous fixes and cross-tree changes