Lines Matching refs:ff
101 static int __do_write_fd(struct feat_fd *ff, const void *buf, size_t size)
103 ssize_t ret = writen(ff->fd, buf, size);
110 static int __do_write_buf(struct feat_fd *ff, const void *buf, size_t size)
114 size_t new_size = ff->size;
117 if (size + ff->offset > max_size)
120 while (size > (new_size - ff->offset))
124 if (ff->size < new_size) {
125 addr = realloc(ff->buf, new_size);
128 ff->buf = addr;
129 ff->size = new_size;
132 memcpy(ff->buf + ff->offset, buf, size);
133 ff->offset += size;
139 int do_write(struct feat_fd *ff, const void *buf, size_t size)
141 if (!ff->buf)
142 return __do_write_fd(ff, buf, size);
143 return __do_write_buf(ff, buf, size);
147 static int do_write_bitmap(struct feat_fd *ff, unsigned long *set, u64 size)
152 ret = do_write(ff, &size, sizeof(size));
157 ret = do_write(ff, p + i, sizeof(*p));
166 int write_padded(struct feat_fd *ff, const void *bf,
170 int err = do_write(ff, bf, count);
173 err = do_write(ff, zero_buf, count_aligned - count);
182 static int do_write_string(struct feat_fd *ff, const char *str)
191 ret = do_write(ff, &len, sizeof(len));
195 return write_padded(ff, str, olen, len);
198 static int __do_read_fd(struct feat_fd *ff, void *addr, ssize_t size)
200 ssize_t ret = readn(ff->fd, addr, size);
207 static int __do_read_buf(struct feat_fd *ff, void *addr, ssize_t size)
209 if (size > (ssize_t)ff->size - ff->offset)
212 memcpy(addr, ff->buf + ff->offset, size);
213 ff->offset += size;
219 static int __do_read(struct feat_fd *ff, void *addr, ssize_t size)
221 if (!ff->buf)
222 return __do_read_fd(ff, addr, size);
223 return __do_read_buf(ff, addr, size);
226 static int do_read_u32(struct feat_fd *ff, u32 *addr)
230 ret = __do_read(ff, addr, sizeof(*addr));
234 if (ff->ph->needs_swap)
239 static int do_read_u64(struct feat_fd *ff, u64 *addr)
243 ret = __do_read(ff, addr, sizeof(*addr));
247 if (ff->ph->needs_swap)
252 static char *do_read_string(struct feat_fd *ff)
257 if (do_read_u32(ff, &len))
264 if (!__do_read(ff, buf, len)) {
278 static int do_read_bitmap(struct feat_fd *ff, unsigned long **pset, u64 *psize)
284 ret = do_read_u64(ff, &size);
295 ret = do_read_u64(ff, p + i);
308 static int write_tracing_data(struct feat_fd *ff,
311 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
314 return read_tracing_data(ff->fd, &evlist->core.entries);
318 static int write_build_id(struct feat_fd *ff,
324 session = container_of(ff->ph, struct perf_session, header);
329 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
332 err = perf_session__write_buildid_table(session, ff);
342 static int write_hostname(struct feat_fd *ff,
352 return do_write_string(ff, uts.nodename);
355 static int write_osrelease(struct feat_fd *ff,
365 return do_write_string(ff, uts.release);
368 static int write_arch(struct feat_fd *ff,
378 return do_write_string(ff, uts.machine);
381 static int write_version(struct feat_fd *ff,
384 return do_write_string(ff, perf_version_string);
387 static int __write_cpudesc(struct feat_fd *ff, const char *cpuinfo_proc)
435 ret = do_write_string(ff, s);
442 static int write_cpudesc(struct feat_fd *ff,
470 ret = __write_cpudesc(ff, cpuinfo_procs[i]);
478 static int write_nrcpus(struct feat_fd *ff,
493 ret = do_write(ff, &nrc, sizeof(nrc));
497 return do_write(ff, &nra, sizeof(nra));
500 static int write_event_desc(struct feat_fd *ff,
512 ret = do_write(ff, &nre, sizeof(nre));
520 ret = do_write(ff, &sz, sizeof(sz));
525 ret = do_write(ff, &evsel->core.attr, sz);
536 ret = do_write(ff, &nri, sizeof(nri));
543 ret = do_write_string(ff, evsel__name(evsel));
549 ret = do_write(ff, evsel->core.id, evsel->core.ids * sizeof(u64));
556 static int write_cmdline(struct feat_fd *ff,
568 ret = do_write(ff, &n, sizeof(n));
572 ret = do_write_string(ff, buf);
577 ret = do_write_string(ff, perf_env.cmdline_argv[i]);
585 static int write_cpu_topology(struct feat_fd *ff,
596 ret = do_write(ff, &tp->package_cpus_lists, sizeof(tp->package_cpus_lists));
601 ret = do_write_string(ff, tp->package_cpus_list[i]);
605 ret = do_write(ff, &tp->core_cpus_lists, sizeof(tp->core_cpus_lists));
610 ret = do_write_string(ff, tp->core_cpus_list[i]);
620 ret = do_write(ff, &perf_env.cpu[j].core_id,
624 ret = do_write(ff, &perf_env.cpu[j].socket_id,
633 ret = do_write(ff, &tp->die_cpus_lists, sizeof(tp->die_cpus_lists));
638 ret = do_write_string(ff, tp->die_cpus_list[i]);
644 ret = do_write(ff, &perf_env.cpu[j].die_id,
657 static int write_total_mem(struct feat_fd *ff,
678 ret = do_write(ff, &mem, sizeof(mem));
686 static int write_numa_topology(struct feat_fd *ff,
697 ret = do_write(ff, &tp->nr, sizeof(u32));
704 ret = do_write(ff, &n->node, sizeof(u32));
708 ret = do_write(ff, &n->mem_total, sizeof(u64));
712 ret = do_write(ff, &n->mem_free, sizeof(u64));
716 ret = do_write_string(ff, n->cpus);
740 static int write_pmu_mappings(struct feat_fd *ff,
754 ret = do_write(ff, &pmu_num, sizeof(pmu_num));
759 ret = do_write(ff, &pmu->type, sizeof(pmu->type));
763 ret = do_write_string(ff, pmu->name);
783 static int write_group_desc(struct feat_fd *ff,
790 ret = do_write(ff, &nr_groups, sizeof(nr_groups));
800 ret = do_write_string(ff, name);
804 ret = do_write(ff, &leader_idx, sizeof(leader_idx));
808 ret = do_write(ff, &nr_members, sizeof(nr_members));
864 static int write_cpuid(struct feat_fd *ff,
874 return do_write_string(ff, buffer);
877 static int write_branch_stack(struct feat_fd *ff __maybe_unused,
883 static int write_auxtrace(struct feat_fd *ff,
889 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
892 session = container_of(ff->ph, struct perf_session, header);
894 err = auxtrace_index__write(ff->fd, &session->auxtrace_index);
900 static int write_clockid(struct feat_fd *ff,
903 return do_write(ff, &ff->ph->env.clock.clockid_res_ns,
904 sizeof(ff->ph->env.clock.clockid_res_ns));
907 static int write_clock_data(struct feat_fd *ff,
917 ret = do_write(ff, &data32, sizeof(data32));
922 data32 = ff->ph->env.clock.clockid;
924 ret = do_write(ff, &data32, sizeof(data32));
929 data64 = &ff->ph->env.clock.tod_ns;
931 ret = do_write(ff, data64, sizeof(*data64));
936 data64 = &ff->ph->env.clock.clockid_ns;
938 return do_write(ff, data64, sizeof(*data64));
941 static int write_hybrid_topology(struct feat_fd *ff,
952 ret = do_write(ff, &tp->nr, sizeof(u32));
959 ret = do_write_string(ff, n->pmu_name);
963 ret = do_write_string(ff, n->cpus);
975 static int write_dir_format(struct feat_fd *ff,
981 session = container_of(ff->ph, struct perf_session, header);
987 return do_write(ff, &data->dir.version, sizeof(data->dir.version));
1042 static int write_bpf_prog_info(struct feat_fd *ff,
1045 struct perf_env *env = &ff->ph->env;
1052 ret = do_write(ff, &env->bpf_progs.infos_cnt,
1070 ret = do_write(ff, node->info_linear, len);
1084 static int write_bpf_btf(struct feat_fd *ff,
1087 struct perf_env *env = &ff->ph->env;
1094 ret = do_write(ff, &env->bpf_progs.btfs_cnt,
1107 ret = do_write(ff, &node->id,
1266 static int write_cache(struct feat_fd *ff,
1280 ret = do_write(ff, &version, sizeof(u32));
1284 ret = do_write(ff, &cnt, sizeof(u32));
1292 ret = do_write(ff, &c->v, sizeof(u32)); \
1303 ret = do_write_string(ff, (const char *) c->v); \
1319 static int write_stat(struct feat_fd *ff __maybe_unused,
1325 static int write_sample_time(struct feat_fd *ff,
1330 ret = do_write(ff, &evlist->first_sample_time,
1335 return do_write(ff, &evlist->last_sample_time,
1478 static int write_mem_topology(struct feat_fd *ff __maybe_unused,
1494 ret = do_write(ff, &version, sizeof(version));
1498 ret = do_write(ff, &bsize, sizeof(bsize));
1502 ret = do_write(ff, &nr, sizeof(nr));
1510 ret = do_write(ff, &n->v, sizeof(n->v)); \
1519 ret = do_write_bitmap(ff, n->set, n->size);
1529 static int write_compressed(struct feat_fd *ff __maybe_unused,
1534 ret = do_write(ff, &(ff->ph->env.comp_ver), sizeof(ff->ph->env.comp_ver));
1538 ret = do_write(ff, &(ff->ph->env.comp_type), sizeof(ff->ph->env.comp_type));
1542 ret = do_write(ff, &(ff->ph->env.comp_level), sizeof(ff->ph->env.comp_level));
1546 ret = do_write(ff, &(ff->ph->env.comp_ratio), sizeof(ff->ph->env.comp_ratio));
1550 return do_write(ff, &(ff->ph->env.comp_mmap_len), sizeof(ff->ph->env.comp_mmap_len));
1553 static int __write_pmu_caps(struct feat_fd *ff, struct perf_pmu *pmu,
1559 ret = do_write(ff, &pmu->nr_caps, sizeof(pmu->nr_caps));
1564 ret = do_write_string(ff, caps->name);
1568 ret = do_write_string(ff, caps->value);
1574 ret = do_write_string(ff, pmu->name);
1582 static int write_cpu_pmu_caps(struct feat_fd *ff,
1595 return __write_pmu_caps(ff, cpu_pmu, false);
1598 static int write_pmu_caps(struct feat_fd *ff,
1619 ret = do_write(ff, &nr_pmu, sizeof(nr_pmu));
1638 ret = __write_pmu_caps(ff, pmu, true);
1645 static void print_hostname(struct feat_fd *ff, FILE *fp)
1647 fprintf(fp, "# hostname : %s\n", ff->ph->env.hostname);
1650 static void print_osrelease(struct feat_fd *ff, FILE *fp)
1652 fprintf(fp, "# os release : %s\n", ff->ph->env.os_release);
1655 static void print_arch(struct feat_fd *ff, FILE *fp)
1657 fprintf(fp, "# arch : %s\n", ff->ph->env.arch);
1660 static void print_cpudesc(struct feat_fd *ff, FILE *fp)
1662 fprintf(fp, "# cpudesc : %s\n", ff->ph->env.cpu_desc);
1665 static void print_nrcpus(struct feat_fd *ff, FILE *fp)
1667 fprintf(fp, "# nrcpus online : %u\n", ff->ph->env.nr_cpus_online);
1668 fprintf(fp, "# nrcpus avail : %u\n", ff->ph->env.nr_cpus_avail);
1671 static void print_version(struct feat_fd *ff, FILE *fp)
1673 fprintf(fp, "# perf version : %s\n", ff->ph->env.version);
1676 static void print_cmdline(struct feat_fd *ff, FILE *fp)
1680 nr = ff->ph->env.nr_cmdline;
1685 char *argv_i = strdup(ff->ph->env.cmdline_argv[i]);
1687 fprintf(fp, "%s ", ff->ph->env.cmdline_argv[i]);
1705 static void print_cpu_topology(struct feat_fd *ff, FILE *fp)
1707 struct perf_header *ph = ff->ph;
1762 static void print_clockid(struct feat_fd *ff, FILE *fp)
1765 ff->ph->env.clock.clockid_res_ns * 1000);
1768 static void print_clock_data(struct feat_fd *ff, FILE *fp)
1777 if (!ff->ph->env.clock.enabled) {
1783 ref = ff->ph->env.clock.tod_ns;
1789 ref = ff->ph->env.clock.clockid_ns;
1794 clockid = ff->ph->env.clock.clockid;
1811 static void print_hybrid_topology(struct feat_fd *ff, FILE *fp)
1817 for (i = 0; i < ff->ph->env.nr_hybrid_nodes; i++) {
1818 n = &ff->ph->env.hybrid_nodes[i];
1823 static void print_dir_format(struct feat_fd *ff, FILE *fp)
1828 session = container_of(ff->ph, struct perf_session, header);
1835 static void print_bpf_prog_info(struct feat_fd *ff, FILE *fp)
1837 struct perf_env *env = &ff->ph->env;
1859 static void print_bpf_btf(struct feat_fd *ff, FILE *fp)
1861 struct perf_env *env = &ff->ph->env;
1931 static struct evsel *read_event_desc(struct feat_fd *ff)
1940 if (do_read_u32(ff, &nre))
1943 if (do_read_u32(ff, &sz))
1967 if (__do_read(ff, buf, sz))
1970 if (ff->ph->needs_swap)
1978 if (do_read_u32(ff, &nr))
1981 if (ff->ph->needs_swap)
1984 evsel->name = do_read_string(ff);
1998 if (do_read_u64(ff, id))
2018 static void print_event_desc(struct feat_fd *ff, FILE *fp)
2024 if (ff->events)
2025 events = ff->events;
2027 events = read_event_desc(ff);
2053 ff->events = NULL;
2056 static void print_total_mem(struct feat_fd *ff, FILE *fp)
2058 fprintf(fp, "# total memory : %llu kB\n", ff->ph->env.total_mem);
2061 static void print_numa_topology(struct feat_fd *ff, FILE *fp)
2066 for (i = 0; i < ff->ph->env.nr_numa_nodes; i++) {
2067 n = &ff->ph->env.numa_nodes[i];
2078 static void print_cpuid(struct feat_fd *ff, FILE *fp)
2080 fprintf(fp, "# cpuid : %s\n", ff->ph->env.cpuid);
2083 static void print_branch_stack(struct feat_fd *ff __maybe_unused, FILE *fp)
2088 static void print_auxtrace(struct feat_fd *ff __maybe_unused, FILE *fp)
2093 static void print_stat(struct feat_fd *ff __maybe_unused, FILE *fp)
2098 static void print_cache(struct feat_fd *ff, FILE *fp __maybe_unused)
2103 for (i = 0; i < ff->ph->env.caches_cnt; i++) {
2105 cpu_cache_level__fprintf(fp, &ff->ph->env.caches[i]);
2109 static void print_compressed(struct feat_fd *ff, FILE *fp)
2112 ff->ph->env.comp_type == PERF_COMP_ZSTD ? "Zstd" : "Unknown",
2113 ff->ph->env.comp_level, ff->ph->env.comp_ratio);
2135 static void print_cpu_pmu_caps(struct feat_fd *ff, FILE *fp)
2137 __print_pmu_caps(fp, ff->ph->env.nr_cpu_pmu_caps,
2138 ff->ph->env.cpu_pmu_caps, (char *)"cpu");
2141 static void print_pmu_caps(struct feat_fd *ff, FILE *fp)
2145 for (int i = 0; i < ff->ph->env.nr_pmus_with_caps; i++) {
2146 pmu_caps = &ff->ph->env.pmu_caps[i];
2152 static void print_pmu_mappings(struct feat_fd *ff, FILE *fp)
2159 pmu_num = ff->ph->env.nr_pmu_mappings;
2165 str = ff->ph->env.pmu_mappings;
2188 static void print_group_desc(struct feat_fd *ff, FILE *fp)
2194 session = container_of(ff->ph, struct perf_session, header);
2210 static void print_sample_time(struct feat_fd *ff, FILE *fp)
2216 session = container_of(ff->ph, struct perf_session, header);
2245 static void print_mem_topology(struct feat_fd *ff, FILE *fp)
2250 nodes = ff->ph->env.memory_nodes;
2251 nr = ff->ph->env.nr_memory_nodes;
2254 nr, ff->ph->env.memory_bsize);
2257 memory_node__fprintf(&nodes[i], ff->ph->env.memory_bsize, fp);
2423 static int process_##__feat(struct feat_fd *ff, void *data __maybe_unused) \
2425 free(ff->ph->env.__feat_env); \
2426 ff->ph->env.__feat_env = do_read_string(ff); \
2427 return ff->ph->env.__feat_env ? 0 : -ENOMEM; \
2438 static int process_tracing_data(struct feat_fd *ff, void *data)
2440 ssize_t ret = trace_report(ff->fd, data, false);
2446 static int process_build_id(struct feat_fd *ff, void *data __maybe_unused)
2448 if (perf_header__read_build_ids(ff->ph, ff->fd, ff->offset, ff->size))
2453 static int process_nrcpus(struct feat_fd *ff, void *data __maybe_unused)
2458 ret = do_read_u32(ff, &nr_cpus_avail);
2462 ret = do_read_u32(ff, &nr_cpus_online);
2465 ff->ph->env.nr_cpus_avail = (int)nr_cpus_avail;
2466 ff->ph->env.nr_cpus_online = (int)nr_cpus_online;
2470 static int process_total_mem(struct feat_fd *ff, void *data __maybe_unused)
2475 ret = do_read_u64(ff, &total_mem);
2478 ff->ph->env.total_mem = (unsigned long long)total_mem;
2512 process_event_desc(struct feat_fd *ff, void *data __maybe_unused)
2515 struct evsel *evsel, *events = read_event_desc(ff);
2520 session = container_of(ff->ph, struct perf_session, header);
2525 ff->events = events;
2537 static int process_cmdline(struct feat_fd *ff, void *data __maybe_unused)
2542 if (do_read_u32(ff, &nr))
2545 ff->ph->env.nr_cmdline = nr;
2547 cmdline = zalloc(ff->size + nr + 1);
2556 str = do_read_string(ff);
2565 ff->ph->env.cmdline = cmdline;
2566 ff->ph->env.cmdline_argv = (const char **) argv;
2575 static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
2580 int cpu_nr = ff->ph->env.nr_cpus_avail;
2582 struct perf_header *ph = ff->ph;
2589 if (do_read_u32(ff, &nr))
2598 str = do_read_string(ff);
2610 if (do_read_u32(ff, &nr))
2617 str = do_read_string(ff);
2633 if (ff->size <= size) {
2648 if (do_read_u32(ff, &nr))
2654 if (do_read_u32(ff, &nr))
2671 if (ff->size <= size)
2674 if (do_read_u32(ff, &nr))
2681 str = do_read_string(ff);
2694 if (do_read_u32(ff, &nr))
2709 static int process_numa_topology(struct feat_fd *ff, void *data __maybe_unused)
2716 if (do_read_u32(ff, &nr))
2727 if (do_read_u32(ff, &n->node))
2730 if (do_read_u64(ff, &n->mem_total))
2733 if (do_read_u64(ff, &n->mem_free))
2736 str = do_read_string(ff);
2746 ff->ph->env.nr_numa_nodes = nr;
2747 ff->ph->env.numa_nodes = nodes;
2755 static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused)
2762 if (do_read_u32(ff, &pmu_num))
2770 ff->ph->env.nr_pmu_mappings = pmu_num;
2775 if (do_read_u32(ff, &type))
2778 name = do_read_string(ff);
2789 ff->ph->env.msr_pmu_type = type;
2794 ff->ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
2802 static int process_group_desc(struct feat_fd *ff, void *data __maybe_unused)
2814 if (do_read_u32(ff, &nr_groups))
2817 ff->ph->env.nr_groups = nr_groups;
2828 desc[i].name = do_read_string(ff);
2832 if (do_read_u32(ff, &desc[i].leader_idx))
2835 if (do_read_u32(ff, &desc[i].nr_members))
2842 session = container_of(ff->ph, struct perf_session, header);
2885 static int process_auxtrace(struct feat_fd *ff, void *data __maybe_unused)
2890 session = container_of(ff->ph, struct perf_session, header);
2892 err = auxtrace_index__process(ff->fd, ff->size, session,
2893 ff->ph->needs_swap);
2899 static int process_cache(struct feat_fd *ff, void *data __maybe_unused)
2904 if (do_read_u32(ff, &version))
2910 if (do_read_u32(ff, &cnt))
2921 if (do_read_u32(ff, &c.v))\
2931 c.v = do_read_string(ff); \
2943 ff->ph->env.caches = caches;
2944 ff->ph->env.caches_cnt = cnt;
2951 static int process_sample_time(struct feat_fd *ff, void *data __maybe_unused)
2957 session = container_of(ff->ph, struct perf_session, header);
2959 ret = do_read_u64(ff, &first_sample_time);
2963 ret = do_read_u64(ff, &last_sample_time);
2972 static int process_mem_topology(struct feat_fd *ff,
2979 if (do_read_u64(ff, &version))
2985 if (do_read_u64(ff, &bsize))
2988 if (do_read_u64(ff, &nr))
2999 if (do_read_u64(ff, &n.v)) \
3007 if (do_read_bitmap(ff, &n.set, &n.size))
3013 ff->ph->env.memory_bsize = bsize;
3014 ff->ph->env.memory_nodes = nodes;
3015 ff->ph->env.nr_memory_nodes = nr;
3024 static int process_clockid(struct feat_fd *ff,
3027 if (do_read_u64(ff, &ff->ph->env.clock.clockid_res_ns))
3033 static int process_clock_data(struct feat_fd *ff,
3040 if (do_read_u32(ff, &data32))
3047 if (do_read_u32(ff, &data32))
3050 ff->ph->env.clock.clockid = data32;
3053 if (do_read_u64(ff, &data64))
3056 ff->ph->env.clock.tod_ns = data64;
3059 if (do_read_u64(ff, &data64))
3062 ff->ph->env.clock.clockid_ns = data64;
3063 ff->ph->env.clock.enabled = true;
3067 static int process_hybrid_topology(struct feat_fd *ff,
3074 if (do_read_u32(ff, &nr))
3084 n->pmu_name = do_read_string(ff);
3088 n->cpus = do_read_string(ff);
3093 ff->ph->env.nr_hybrid_nodes = nr;
3094 ff->ph->env.hybrid_nodes = nodes;
3107 static int process_dir_format(struct feat_fd *ff,
3113 session = container_of(ff->ph, struct perf_session, header);
3119 return do_read_u64(ff, &data->dir.version);
3123 static int process_bpf_prog_info(struct feat_fd *ff, void *data __maybe_unused)
3126 struct perf_env *env = &ff->ph->env;
3131 if (ff->ph->needs_swap) {
3136 if (do_read_u32(ff, &count))
3146 if (do_read_u32(ff, &info_len))
3148 if (do_read_u32(ff, &data_len))
3162 if (do_read_u64(ff, (u64 *)(&info_linear->arrays)))
3164 if (__do_read(ff, &info_linear->info, info_len))
3170 if (__do_read(ff, info_linear->data, data_len))
3192 static int process_bpf_btf(struct feat_fd *ff, void *data __maybe_unused)
3194 struct perf_env *env = &ff->ph->env;
3199 if (ff->ph->needs_swap) {
3204 if (do_read_u32(ff, &count))
3212 if (do_read_u32(ff, &id))
3214 if (do_read_u32(ff, &data_size))
3224 if (__do_read(ff, node->data, data_size))
3239 static int process_compressed(struct feat_fd *ff,
3242 if (do_read_u32(ff, &(ff->ph->env.comp_ver)))
3245 if (do_read_u32(ff, &(ff->ph->env.comp_type)))
3248 if (do_read_u32(ff, &(ff->ph->env.comp_level)))
3251 if (do_read_u32(ff, &(ff->ph->env.comp_ratio)))
3254 if (do_read_u32(ff, &(ff->ph->env.comp_mmap_len)))
3260 static int __process_pmu_caps(struct feat_fd *ff, int *nr_caps,
3269 if (do_read_u32(ff, &nr_pmu_caps))
3280 name = do_read_string(ff);
3284 value = do_read_string(ff);
3315 static int process_cpu_pmu_caps(struct feat_fd *ff,
3318 int ret = __process_pmu_caps(ff, &ff->ph->env.nr_cpu_pmu_caps,
3319 &ff->ph->env.cpu_pmu_caps,
3320 &ff->ph->env.max_branches);
3322 if (!ret && !ff->ph->env.cpu_pmu_caps)
3327 static int process_pmu_caps(struct feat_fd *ff, void *data __maybe_unused)
3334 if (do_read_u32(ff, &nr_pmu))
3347 ret = __process_pmu_caps(ff, &pmu_caps[i].nr_caps,
3353 pmu_caps[i].pmu_name = do_read_string(ff);
3364 ff->ph->env.nr_pmus_with_caps = nr_pmu;
3365 ff->ph->env.pmu_caps = pmu_caps;
3457 struct feat_fd ff;
3471 ff = (struct feat_fd) {
3477 feat_ops[feat].print(&ff, hd->fp);
3527 struct feat_fd *ff;
3534 return do_write(h->ff, buf, sz);
3537 static int do_write_feat(struct feat_fd *ff, int type,
3545 if (perf_header__has_feat(ff->ph, type)) {
3549 if (WARN(ff->buf, "Error: calling %s in pipe-mode.\n", __func__))
3552 (*p)->offset = lseek(ff->fd, 0, SEEK_CUR);
3561 .ff = ff,
3570 err = feat_ops[type].write(ff, evlist);
3575 lseek(ff->fd, (*p)->offset, SEEK_SET);
3579 (*p)->size = lseek(ff->fd, 0, SEEK_CUR) - (*p)->offset;
3590 struct feat_fd ff;
3597 ff = (struct feat_fd){
3616 if (do_write_feat(&ff, feat, &p, evlist, fc))
3625 err = do_write(&ff, feat_sec, sec_size);
3635 struct feat_fd ff;
3638 ff = (struct feat_fd){ .fd = fd };
3645 err = do_write(&ff, &f_header, sizeof(f_header));
3663 struct feat_fd ff;
3667 ff = (struct feat_fd){ .fd = fd};
3672 err = do_write(&ff, evsel->core.id, evsel->core.ids * sizeof(u64));
3679 attr_offset = lseek(ff.fd, 0, SEEK_CUR);
3697 err = do_write(&ff, &f_attr, sizeof(f_attr));
3732 err = do_write(&ff, &f_header, sizeof(f_header));
4044 struct feat_fd ff = {
4062 if (repipe && do_write(&ff, header, sizeof(*header)) < 0)
4302 struct feat_fd ff = { .fd = 0 };
4320 ff.buf = (void *)fe->data;
4321 ff.size = event->header.size - sizeof(*fe);
4322 ff.ph = &session->header;
4324 if (feat_ops[feat].process(&ff, NULL)) {
4334 feat_ops[feat].print(&ff, stdout);
4340 free_event_desc(ff.events);