mirrors/linux
2
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-07-16 17:57:38 -04:00
Code Issues Packages Projects Releases Wiki Activity

perf header: Clean up use of perf_env

Browse Source 
Always use the perf_env from the feat_fd's perf_header. Cache the
value on entry to a function in `env` and use `env->` consistently in
the code. Ensure the header is initialized for use in
perf_session__do_write_header.

Signed-off-by: Ian Rogers <irogers@google.com>
Link: https://lore.kernel.org/r/20250724163302.596743-12-irogers@google.com
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
This commit is contained in:
Ian Rogers
2025-07-24 09:32:51 -07:00
committed by Namhyung Kim
parent 57ddb9cbb5
commit b743a1368d
1 changed files with 98 additions and 76 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
tools/perf/util/header.c
View File

@@ -557,6 +557,7 @@ static int write_event_desc(struct feat_fd *ff,
static int write_cmdline(struct feat_fd *ff,
struct evlist *evlist __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
char pbuf[MAXPATHLEN], *buf;
int i, ret, n;
@@ -564,7 +565,7 @@ static int write_cmdline(struct feat_fd *ff,
buf = perf_exe(pbuf, MAXPATHLEN);
/* account for binary path */
n = perf_env.nr_cmdline + 1;
n = env->nr_cmdline + 1;
ret = do_write(ff, &n, sizeof(n));
if (ret < 0)
@@ -574,8 +575,8 @@ static int write_cmdline(struct feat_fd *ff,
if (ret < 0)
return ret;
for (i = 0 ; i < perf_env.nr_cmdline; i++) {
ret = do_write_string(ff, perf_env.cmdline_argv[i]);
for (i = 0 ; i < env->nr_cmdline; i++) {
ret = do_write_string(ff, env->cmdline_argv[i]);
if (ret < 0)
return ret;
}
@@ -586,6 +587,7 @@ static int write_cmdline(struct feat_fd *ff,
static int write_cpu_topology(struct feat_fd *ff,
struct evlist *evlist __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
struct cpu_topology *tp;
u32 i;
int ret, j;
@@ -613,17 +615,17 @@ static int write_cpu_topology(struct feat_fd *ff,
break;
}
ret = perf_env__read_cpu_topology_map(&perf_env);
ret = perf_env__read_cpu_topology_map(env);
if (ret < 0)
goto done;
for (j = 0; j < perf_env.nr_cpus_avail; j++) {
ret = do_write(ff, &perf_env.cpu[j].core_id,
sizeof(perf_env.cpu[j].core_id));
for (j = 0; j < env->nr_cpus_avail; j++) {
ret = do_write(ff, &env->cpu[j].core_id,
sizeof(env->cpu[j].core_id));
if (ret < 0)
return ret;
ret = do_write(ff, &perf_env.cpu[j].socket_id,
sizeof(perf_env.cpu[j].socket_id));
ret = do_write(ff, &env->cpu[j].socket_id,
sizeof(env->cpu[j].socket_id));
if (ret < 0)
return ret;
}
@@ -641,9 +643,9 @@ static int write_cpu_topology(struct feat_fd *ff,
goto done;
}
for (j = 0; j < perf_env.nr_cpus_avail; j++) {
ret = do_write(ff, &perf_env.cpu[j].die_id,
sizeof(perf_env.cpu[j].die_id));
for (j = 0; j < env->nr_cpus_avail; j++) {
ret = do_write(ff, &env->cpu[j].die_id,
sizeof(env->cpu[j].die_id));
if (ret < 0)
return ret;
}
@@ -2123,17 +2125,18 @@ static void print_cpu_pmu_caps(struct feat_fd *ff, FILE *fp)
static void print_pmu_caps(struct feat_fd *ff, FILE *fp)
{
struct perf_env *env = &ff->ph->env;
struct pmu_caps *pmu_caps;
for (int i = 0; i < ff->ph->env.nr_pmus_with_caps; i++) {
pmu_caps = &ff->ph->env.pmu_caps[i];
for (int i = 0; i < env->nr_pmus_with_caps; i++) {
pmu_caps = &env->pmu_caps[i];
__print_pmu_caps(fp, pmu_caps->nr_caps, pmu_caps->caps,
pmu_caps->pmu_name);
}
if (strcmp(perf_env__arch(&ff->ph->env), "x86") == 0 &&
perf_env__has_pmu_mapping(&ff->ph->env, "ibs_op")) {
char *max_precise = perf_env__find_pmu_cap(&ff->ph->env, "cpu", "max_precise");
if (strcmp(perf_env__arch(env), "x86") == 0 &&
perf_env__has_pmu_mapping(env, "ibs_op")) {
char *max_precise = perf_env__find_pmu_cap(env, "cpu", "max_precise");
if (max_precise != NULL && atoi(max_precise) == 0)
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");
@@ -2142,18 +2145,19 @@ static void print_pmu_caps(struct feat_fd *ff, FILE *fp)
static void print_pmu_mappings(struct feat_fd *ff, FILE *fp)
{
struct perf_env *env = &ff->ph->env;
const char *delimiter = "# pmu mappings: ";
char *str, *tmp;
u32 pmu_num;
u32 type;
pmu_num = ff->ph->env.nr_pmu_mappings;
pmu_num = env->nr_pmu_mappings;
if (!pmu_num) {
fprintf(fp, "# pmu mappings: not available\n");
return;
}
str = ff->ph->env.pmu_mappings;
str = env->pmu_mappings;
while (pmu_num) {
type = strtoul(str, &tmp, 0);
@@ -2235,17 +2239,18 @@ static void memory_node__fprintf(struct memory_node *n,
static void print_mem_topology(struct feat_fd *ff, FILE *fp)
{
struct perf_env *env = &ff->ph->env;
struct memory_node *nodes;
int i, nr;
nodes = ff->ph->env.memory_nodes;
nr = ff->ph->env.nr_memory_nodes;
nodes = env->memory_nodes;
nr = env->nr_memory_nodes;
fprintf(fp, "# memory nodes (nr %d, block size 0x%llx):\n",
nr, ff->ph->env.memory_bsize);
nr, env->memory_bsize);
for (i = 0; i < nr; i++) {
memory_node__fprintf(&nodes[i], ff->ph->env.memory_bsize, fp);
memory_node__fprintf(&nodes[i], env->memory_bsize, fp);
}
}
@@ -2443,6 +2448,7 @@ static int process_build_id(struct feat_fd *ff, void *data __maybe_unused)
static int process_nrcpus(struct feat_fd *ff, void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
int ret;
u32 nr_cpus_avail, nr_cpus_online;
@@ -2453,20 +2459,21 @@ static int process_nrcpus(struct feat_fd *ff, void *data __maybe_unused)
ret = do_read_u32(ff, &nr_cpus_online);
if (ret)
return ret;
ff->ph->env.nr_cpus_avail = (int)nr_cpus_avail;
ff->ph->env.nr_cpus_online = (int)nr_cpus_online;
env->nr_cpus_avail = (int)nr_cpus_avail;
env->nr_cpus_online = (int)nr_cpus_online;
return 0;
}
static int process_total_mem(struct feat_fd *ff, void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
u64 total_mem;
int ret;
ret = do_read_u64(ff, &total_mem);
if (ret)
return -1;
ff->ph->env.total_mem = (unsigned long long)total_mem;
env->total_mem = (unsigned long long)total_mem;
return 0;
}
@@ -2527,13 +2534,14 @@ process_event_desc(struct feat_fd *ff, void *data __maybe_unused)
static int process_cmdline(struct feat_fd *ff, void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
char *str, *cmdline = NULL, **argv = NULL;
u32 nr, i, len = 0;
if (do_read_u32(ff, &nr))
return -1;
ff->ph->env.nr_cmdline = nr;
env->nr_cmdline = nr;
cmdline = zalloc(ff->size + nr + 1);
if (!cmdline)
@@ -2553,8 +2561,8 @@ static int process_cmdline(struct feat_fd *ff, void *data __maybe_unused)
len += strlen(str) + 1;
free(str);
}
ff->ph->env.cmdline = cmdline;
ff->ph->env.cmdline_argv = (const char **) argv;
env->cmdline = cmdline;
env->cmdline_argv = (const char **) argv;
return 0;
error:
@@ -2568,18 +2576,18 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
u32 nr, i;
char *str = NULL;
struct strbuf sb;
int cpu_nr = ff->ph->env.nr_cpus_avail;
struct perf_env *env = &ff->ph->env;
int cpu_nr = env->nr_cpus_avail;
u64 size = 0;
struct perf_header *ph = ff->ph;
ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu));
if (!ph->env.cpu)
env->cpu = calloc(cpu_nr, sizeof(*env->cpu));
if (!env->cpu)
return -1;
if (do_read_u32(ff, &nr))
goto free_cpu;
ph->env.nr_sibling_cores = nr;
env->nr_sibling_cores = nr;
size += sizeof(u32);
if (strbuf_init(&sb, 128) < 0)
goto free_cpu;
@@ -2595,12 +2603,12 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
size += string_size(str);
zfree(&str);
}
ph->env.sibling_cores = strbuf_detach(&sb, NULL);
env->sibling_cores = strbuf_detach(&sb, NULL);
if (do_read_u32(ff, &nr))
return -1;
ph->env.nr_sibling_threads = nr;
env->nr_sibling_threads = nr;
size += sizeof(u32);
for (i = 0; i < nr; i++) {
@@ -2614,14 +2622,14 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
size += string_size(str);
zfree(&str);
}
ph->env.sibling_threads = strbuf_detach(&sb, NULL);
env->sibling_threads = strbuf_detach(&sb, NULL);
/*
* The header may be from old perf,
* which doesn't include core id and socket id information.
*/
if (ff->size <= size) {
zfree(&ph->env.cpu);
zfree(&env->cpu);
return 0;
}
@@ -2629,13 +2637,13 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
if (do_read_u32(ff, &nr))
goto free_cpu;
ph->env.cpu[i].core_id = nr;
env->cpu[i].core_id = nr;
size += sizeof(u32);
if (do_read_u32(ff, &nr))
goto free_cpu;
ph->env.cpu[i].socket_id = nr;
env->cpu[i].socket_id = nr;
size += sizeof(u32);
}
@@ -2649,7 +2657,7 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
if (do_read_u32(ff, &nr))
return -1;
ph->env.nr_sibling_dies = nr;
env->nr_sibling_dies = nr;
size += sizeof(u32);
for (i = 0; i < nr; i++) {
@@ -2663,13 +2671,13 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
size += string_size(str);
zfree(&str);
}
ph->env.sibling_dies = strbuf_detach(&sb, NULL);
env->sibling_dies = strbuf_detach(&sb, NULL);
for (i = 0; i < (u32)cpu_nr; i++) {
if (do_read_u32(ff, &nr))
goto free_cpu;
ph->env.cpu[i].die_id = nr;
env->cpu[i].die_id = nr;
}
return 0;
@@ -2678,12 +2686,13 @@ static int process_cpu_topology(struct feat_fd *ff, void *data __maybe_unused)
strbuf_release(&sb);
zfree(&str);
free_cpu:
zfree(&ph->env.cpu);
zfree(&env->cpu);
return -1;
}
static int process_numa_topology(struct feat_fd *ff, void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
struct numa_node *nodes, *n;
u32 nr, i;
char *str;
@@ -2718,8 +2727,8 @@ static int process_numa_topology(struct feat_fd *ff, void *data __maybe_unused)
if (!n->map)
goto error;
}
ff->ph->env.nr_numa_nodes = nr;
ff->ph->env.numa_nodes = nodes;
env->nr_numa_nodes = nr;
env->numa_nodes = nodes;
return 0;
error:
@@ -2729,6 +2738,7 @@ static int process_numa_topology(struct feat_fd *ff, void *data __maybe_unused)
static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
char *name;
u32 pmu_num;
u32 type;
@@ -2742,7 +2752,7 @@ static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused)
return 0;
}
ff->ph->env.nr_pmu_mappings = pmu_num;
env->nr_pmu_mappings = pmu_num;
if (strbuf_init(&sb, 128) < 0)
return -1;
@@ -2761,14 +2771,14 @@ static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused)
goto error;
if (!strcmp(name, "msr"))
ff->ph->env.msr_pmu_type = type;
env->msr_pmu_type = type;
free(name);
pmu_num--;
}
/* AMD may set it by evlist__has_amd_ibs() from perf_session__new() */
free(ff->ph->env.pmu_mappings);
ff->ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
free(env->pmu_mappings);
env->pmu_mappings = strbuf_detach(&sb, NULL);
return 0;
error:
@@ -2778,6 +2788,7 @@ static int process_pmu_mappings(struct feat_fd *ff, void *data __maybe_unused)
static int process_group_desc(struct feat_fd *ff, void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
size_t ret = -1;
u32 i, nr, nr_groups;
struct perf_session *session;
@@ -2791,7 +2802,7 @@ static int process_group_desc(struct feat_fd *ff, void *data __maybe_unused)
if (do_read_u32(ff, &nr_groups))
return -1;
ff->ph->env.nr_groups = nr_groups;
env->nr_groups = nr_groups;
if (!nr_groups) {
pr_debug("group desc not available\n");
return 0;
@@ -2875,6 +2886,7 @@ static int process_auxtrace(struct feat_fd *ff, void *data __maybe_unused)
static int process_cache(struct feat_fd *ff, void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
struct cpu_cache_level *caches;
u32 cnt, i, version;
@@ -2915,8 +2927,8 @@ static int process_cache(struct feat_fd *ff, void *data __maybe_unused)
#undef _R
}
ff->ph->env.caches = caches;
ff->ph->env.caches_cnt = cnt;
env->caches = caches;
env->caches_cnt = cnt;
return 0;
out_free_caches:
for (i = 0; i < cnt; i++) {
@@ -2952,6 +2964,7 @@ static int process_sample_time(struct feat_fd *ff, void *data __maybe_unused)
static int process_mem_topology(struct feat_fd *ff,
void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
struct memory_node *nodes;
u64 version, i, nr, bsize;
int ret = -1;
@@ -2990,9 +3003,9 @@ static int process_mem_topology(struct feat_fd *ff,
nodes[i] = n;
}
ff->ph->env.memory_bsize = bsize;
ff->ph->env.memory_nodes = nodes;
ff->ph->env.nr_memory_nodes = nr;
env->memory_bsize = bsize;
env->memory_nodes = nodes;
env->nr_memory_nodes = nr;
ret = 0;
out:
@@ -3004,7 +3017,9 @@ static int process_mem_topology(struct feat_fd *ff,
static int process_clockid(struct feat_fd *ff,
void *data __maybe_unused)
{
if (do_read_u64(ff, &ff->ph->env.clock.clockid_res_ns))
struct perf_env *env = &ff->ph->env;
if (do_read_u64(ff, &env->clock.clockid_res_ns))
return -1;
return 0;
@@ -3013,6 +3028,7 @@ static int process_clockid(struct feat_fd *ff,
static int process_clock_data(struct feat_fd *ff,
void *_data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
u32 data32;
u64 data64;
@@ -3027,26 +3043,27 @@ static int process_clock_data(struct feat_fd *ff,
if (do_read_u32(ff, &data32))
return -1;
ff->ph->env.clock.clockid = data32;
env->clock.clockid = data32;
/* TOD ref time */
if (do_read_u64(ff, &data64))
return -1;
ff->ph->env.clock.tod_ns = data64;
env->clock.tod_ns = data64;
/* clockid ref time */
if (do_read_u64(ff, &data64))
return -1;
ff->ph->env.clock.clockid_ns = data64;
ff->ph->env.clock.enabled = true;
env->clock.clockid_ns = data64;
env->clock.enabled = true;
return 0;
}
static int process_hybrid_topology(struct feat_fd *ff,
void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
struct hybrid_node *nodes, *n;
u32 nr, i;
@@ -3070,8 +3087,8 @@ static int process_hybrid_topology(struct feat_fd *ff,
goto error;
}
ff->ph->env.nr_hybrid_nodes = nr;
ff->ph->env.hybrid_nodes = nodes;
env->nr_hybrid_nodes = nr;
env->hybrid_nodes = nodes;
return 0;
error:
@@ -3224,19 +3241,21 @@ static int process_bpf_btf(struct feat_fd *ff, void *data __maybe_unused)
static int process_compressed(struct feat_fd *ff,
void *data __maybe_unused)
{
if (do_read_u32(ff, &(ff->ph->env.comp_ver)))
struct perf_env *env = &ff->ph->env;
if (do_read_u32(ff, &(env->comp_ver)))
return -1;
if (do_read_u32(ff, &(ff->ph->env.comp_type)))
if (do_read_u32(ff, &(env->comp_type)))
return -1;
if (do_read_u32(ff, &(ff->ph->env.comp_level)))
if (do_read_u32(ff, &(env->comp_level)))
return -1;
if (do_read_u32(ff, &(ff->ph->env.comp_ratio)))
if (do_read_u32(ff, &(env->comp_ratio)))
return -1;
if (do_read_u32(ff, &(ff->ph->env.comp_mmap_len)))
if (do_read_u32(ff, &(env->comp_mmap_len)))
return -1;
return 0;
@@ -3308,19 +3327,21 @@ static int __process_pmu_caps(struct feat_fd *ff, int *nr_caps,
static int process_cpu_pmu_caps(struct feat_fd *ff,
void *data __maybe_unused)
{
int ret = __process_pmu_caps(ff, &ff->ph->env.nr_cpu_pmu_caps,
&ff->ph->env.cpu_pmu_caps,
&ff->ph->env.max_branches,
&ff->ph->env.br_cntr_nr,
&ff->ph->env.br_cntr_width);
struct perf_env *env = &ff->ph->env;
int ret = __process_pmu_caps(ff, &env->nr_cpu_pmu_caps,
&env->cpu_pmu_caps,
&env->max_branches,
&env->br_cntr_nr,
&env->br_cntr_width);
if (!ret && !ff->ph->env.cpu_pmu_caps)
if (!ret && !env->cpu_pmu_caps)
pr_debug("cpu pmu capabilities not available\n");
return ret;
}
static int process_pmu_caps(struct feat_fd *ff, void *data __maybe_unused)
{
struct perf_env *env = &ff->ph->env;
struct pmu_caps *pmu_caps;
u32 nr_pmu, i;
int ret;
@@ -3358,8 +3379,8 @@ static int process_pmu_caps(struct feat_fd *ff, void *data __maybe_unused)
}
}
ff->ph->env.nr_pmus_with_caps = nr_pmu;
ff->ph->env.pmu_caps = pmu_caps;
env->nr_pmus_with_caps = nr_pmu;
env->pmu_caps = pmu_caps;
return 0;
err:
@@ -3657,6 +3678,7 @@ static int perf_session__do_write_header(struct perf_session *session,
struct perf_header *header = &session->header;
struct evsel *evsel;
struct feat_fd ff = {
.ph = header,
.fd = fd,
};
u64 attr_offset = sizeof(f_header), attr_size = 0;