From: Ian Rogers <irogers@google.com>
To: Peter Zijlstra <peterz@infradead.org>,
Ingo Molnar <mingo@redhat.com>,
Arnaldo Carvalho de Melo <acme@kernel.org>,
Namhyung Kim <namhyung@kernel.org>, Jiri Olsa <jolsa@kernel.org>,
Ian Rogers <irogers@google.com>,
Adrian Hunter <adrian.hunter@intel.com>,
James Clark <james.clark@linaro.org>
Cc: linux-perf-users@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: [PATCH v2 05/30] perf env: Make lazy perf_env initialization thread-safe
Date: Fri, 13 Nov 2026 11:53:10 -0800 [thread overview]
Message-ID: <20261113195335.2865725-6-irogers@google.com> (raw)
In-Reply-To: <20261113195335.2865725-1-irogers@google.com>
Guard lazy initialization of kernel_is_64_bit, nr_cpus_avail, e_machine,
cpuid, nr_pmu_mappings, pmu_mappings, and numa_map in struct perf_env
with env->lock, and use DO_ONCE() to initialize the cached host utsname
structure. This prevents data races when multiple threads concurrently
query a shared struct perf_env.
Signed-off-by: Ian Rogers <irogers@google.com>
---
tools/perf/util/env.c | 178 +++++++++++++++++++++++++-------------
tools/perf/util/session.c | 15 +++-
2 files changed, 131 insertions(+), 62 deletions(-)
diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c
index 50993b0dedc5..4ab46ca6b4ef 100644
--- a/tools/perf/util/env.c
+++ b/tools/perf/util/env.c
@@ -313,18 +313,17 @@ void perf_env__init(struct perf_env *env)
mutex_init(&env->lock);
}
-static void perf_env__init_kernel_mode(struct perf_env *env)
+static const char *uts_machine(void)
{
- const char *arch = env->arch;
+ static struct utsname uts;
- if (!arch) {
- static struct utsname uts = { .machine[0] = '\0', };
+ DO_ONCE(uname, &uts);
+ return uts.machine[0] != '\0' ? uts.machine : NULL;
+}
- if (uts.machine[0] == '\0')
- uname(&uts);
- if (uts.machine[0] != '\0')
- arch = uts.machine;
- }
+static void perf_env__init_kernel_mode(struct perf_env *env)
+{
+ const char *arch = env->arch ?: uts_machine();
if (arch) {
if (strstr(arch, "64") || strstr(arch, "s390x"))
@@ -340,10 +339,15 @@ static void perf_env__init_kernel_mode(struct perf_env *env)
int perf_env__kernel_is_64_bit(struct perf_env *env)
{
+ int is_64_bit;
+
+ mutex_lock(&env->lock);
if (env->kernel_is_64_bit == -1)
perf_env__init_kernel_mode(env);
+ is_64_bit = env->kernel_is_64_bit;
+ mutex_unlock(&env->lock);
- return env->kernel_is_64_bit;
+ return is_64_bit;
}
bool perf_arch_is_big_endian(const char *arch)
@@ -474,7 +478,6 @@ int perf_env__read_pmu_mappings(struct perf_env *env)
pr_debug("pmu mappings not available\n");
return -ENOENT;
}
- env->nr_pmu_mappings = pmu_num;
if (strbuf_init(&sb, 128 * pmu_num) < 0)
return -ENOMEM;
@@ -488,6 +491,7 @@ int perf_env__read_pmu_mappings(struct perf_env *env)
}
env->pmu_mappings = strbuf_detach(&sb, NULL);
+ env->nr_pmu_mappings = pmu_num;
return 0;
@@ -632,7 +636,17 @@ int perf_env__read_core_pmu_caps(struct perf_env *env)
int perf_env__nr_cpus_avail(struct perf_env *env)
{
- return env && !perf_env__read_nr_cpus_avail(env) ? env->nr_cpus_avail : 0;
+ int nr_cpus = 0;
+
+ if (!env)
+ return 0;
+
+ mutex_lock(&env->lock);
+ if (!perf_env__read_nr_cpus_avail(env))
+ nr_cpus = env->nr_cpus_avail;
+ mutex_unlock(&env->lock);
+
+ return nr_cpus;
}
void cpu_cache_level__free(struct cpu_cache_level *cache)
@@ -780,7 +794,7 @@ static const char *e_machine_to_perf_arch(uint16_t e_machine)
return "unknown";
}
-uint16_t perf_env__e_machine_nocache(struct perf_env *env, uint32_t *e_flags)
+static uint16_t __perf_env__e_machine_nocache(struct perf_env *env, uint32_t *e_flags)
{
uint16_t e_machine = EM_NONE;
const char *arch = NULL;
@@ -794,14 +808,8 @@ uint16_t perf_env__e_machine_nocache(struct perf_env *env, uint32_t *e_flags)
is_64_bit = env->kernel_is_64_bit;
}
- if (!arch) {
- static struct utsname uts = { .machine[0] = '\0', };
-
- if (uts.machine[0] == '\0')
- uname(&uts);
- if (uts.machine[0] != '\0')
- arch = uts.machine;
- }
+ if (!arch)
+ arch = uts_machine();
e_machine = perf_arch_to_e_machine(arch, is_64_bit);
@@ -811,18 +819,37 @@ uint16_t perf_env__e_machine_nocache(struct perf_env *env, uint32_t *e_flags)
return e_machine;
}
+uint16_t perf_env__e_machine_nocache(struct perf_env *env, uint32_t *e_flags)
+{
+ uint16_t e_machine;
+
+ if (!env)
+ return __perf_env__e_machine_nocache(NULL, e_flags);
+
+ mutex_lock(&env->lock);
+ e_machine = __perf_env__e_machine_nocache(env, e_flags);
+ mutex_unlock(&env->lock);
+
+ return e_machine;
+}
+
uint16_t perf_env__e_machine(struct perf_env *env, uint32_t *e_flags)
{
uint16_t e_machine;
uint32_t local_e_flags = 0;
- if (env && env->e_machine != EM_NONE) {
+ if (!env)
+ return __perf_env__e_machine_nocache(NULL, e_flags);
+
+ mutex_lock(&env->lock);
+ if (env->e_machine != EM_NONE) {
if (e_flags)
*e_flags = env->e_flags;
-
- return env->e_machine;
+ e_machine = env->e_machine;
+ mutex_unlock(&env->lock);
+ return e_machine;
}
- e_machine = perf_env__e_machine_nocache(env, &local_e_flags);
+ e_machine = __perf_env__e_machine_nocache(env, &local_e_flags);
/*
* Only cache the e_machine in perf_env if env->arch is not NULL.
* If env->arch is NULL, the e_machine is just a fallback to EM_HOST.
@@ -830,10 +857,12 @@ uint16_t perf_env__e_machine(struct perf_env *env, uint32_t *e_flags)
* thread-based session e_machine scanning later in
* perf_session__e_machine().
*/
- if (env && env->arch) {
+ if (env->arch) {
env->e_machine = e_machine;
env->e_flags = local_e_flags;
}
+ mutex_unlock(&env->lock);
+
if (e_flags)
*e_flags = local_e_flags;
@@ -846,13 +875,11 @@ const char *perf_env__arch(struct perf_env *env)
const char *arch;
if (!env) {
- static struct utsname uts = { .machine[0] = '\0', };
- uint16_t host_e_machine;
+ const char *host_arch = uts_machine();
+
+ if (host_arch) {
+ uint16_t host_e_machine = perf_arch_to_e_machine(host_arch, -1);
- if (uts.machine[0] == '\0')
- uname(&uts);
- if (uts.machine[0] != '\0') {
- host_e_machine = perf_arch_to_e_machine(uts.machine, -1);
return e_machine_to_perf_arch(host_e_machine);
}
return e_machine_to_perf_arch(EM_HOST);
@@ -884,45 +911,60 @@ const char *perf_env__arch_strerrno(uint16_t e_machine, int err)
const char *perf_env__cpuid(struct perf_env *env)
{
- int status;
+ const char *cpuid;
+ mutex_lock(&env->lock);
if (!env->cpuid) { /* Assume local operation */
- status = perf_env__read_cpuid(env);
- if (status)
+ if (perf_env__read_cpuid(env)) {
+ mutex_unlock(&env->lock);
return NULL;
+ }
}
+ cpuid = env->cpuid;
+ mutex_unlock(&env->lock);
- return env->cpuid;
+ return cpuid;
}
int perf_env__nr_pmu_mappings(struct perf_env *env)
{
- int status;
+ int nr;
+ mutex_lock(&env->lock);
if (!env->nr_pmu_mappings) { /* Assume local operation */
- status = perf_env__read_pmu_mappings(env);
- if (status)
+ if (perf_env__read_pmu_mappings(env)) {
+ mutex_unlock(&env->lock);
return 0;
+ }
}
+ nr = env->nr_pmu_mappings;
+ mutex_unlock(&env->lock);
- return env->nr_pmu_mappings;
+ return nr;
}
const char *perf_env__pmu_mappings(struct perf_env *env)
{
- int status;
+ const char *mappings;
+ mutex_lock(&env->lock);
if (!env->pmu_mappings) { /* Assume local operation */
- status = perf_env__read_pmu_mappings(env);
- if (status)
+ if (perf_env__read_pmu_mappings(env)) {
+ mutex_unlock(&env->lock);
return NULL;
+ }
}
+ mappings = env->pmu_mappings;
+ mutex_unlock(&env->lock);
- return env->pmu_mappings;
+ return mappings;
}
int perf_env__numa_node(struct perf_env *env, struct perf_cpu cpu)
{
+ int node;
+
+ mutex_lock(&env->lock);
if (!env->nr_numa_map) {
struct numa_node *nn;
int i, nr = 0;
@@ -939,8 +981,10 @@ int perf_env__numa_node(struct perf_env *env, struct perf_cpu cpu)
* it for missing cpus, which return node -1
*/
env->numa_map = malloc(nr * sizeof(int));
- if (!env->numa_map)
+ if (!env->numa_map) {
+ mutex_unlock(&env->lock);
return -1;
+ }
for (i = 0; i < nr; i++)
env->numa_map[i] = -1;
@@ -957,25 +1001,37 @@ int perf_env__numa_node(struct perf_env *env, struct perf_cpu cpu)
}
}
- return cpu.cpu >= 0 && cpu.cpu < env->nr_numa_map ? env->numa_map[cpu.cpu] : -1;
+ node = cpu.cpu >= 0 && cpu.cpu < env->nr_numa_map ? env->numa_map[cpu.cpu] : -1;
+ mutex_unlock(&env->lock);
+
+ return node;
}
bool perf_env__has_pmu_mapping(struct perf_env *env, const char *pmu_name)
{
- char *pmu_mapping = env->pmu_mappings, *colon;
+ char *pmu_mapping, *colon;
+ bool ret = false;
+
+ mutex_lock(&env->lock);
+ pmu_mapping = env->pmu_mappings;
+ if (!pmu_mapping)
+ goto out_unlock;
for (int i = 0; i < env->nr_pmu_mappings; ++i) {
if (strtoul(pmu_mapping, &colon, 0) == ULONG_MAX || *colon != ':')
- goto out_error;
+ goto out_unlock;
pmu_mapping = colon + 1;
- if (strcmp(pmu_mapping, pmu_name) == 0)
- return true;
+ if (strcmp(pmu_mapping, pmu_name) == 0) {
+ ret = true;
+ break;
+ }
pmu_mapping += strlen(pmu_mapping) + 1;
}
-out_error:
- return false;
+out_unlock:
+ mutex_unlock(&env->lock);
+ return ret;
}
char *perf_env__find_pmu_cap(struct perf_env *env, const char *pmu_name,
@@ -1043,12 +1099,13 @@ void perf_env__find_br_cntr_info(struct perf_env *env,
bool perf_env__is_x86_amd_cpu(struct perf_env *env)
{
- static int is_amd; /* 0: Uninitialized, 1: Yes, -1: No */
+ bool is_amd;
- if (is_amd == 0)
- is_amd = env->cpuid && strstarts(env->cpuid, "AuthenticAMD") ? 1 : -1;
+ mutex_lock(&env->lock);
+ is_amd = env->cpuid && strstarts(env->cpuid, "AuthenticAMD");
+ mutex_unlock(&env->lock);
- return is_amd >= 1 ? true : false;
+ return is_amd;
}
bool x86__is_amd_cpu(void)
@@ -1066,12 +1123,13 @@ bool x86__is_amd_cpu(void)
bool perf_env__is_x86_intel_cpu(struct perf_env *env)
{
- static int is_intel; /* 0: Uninitialized, 1: Yes, -1: No */
+ bool is_intel;
- if (is_intel == 0)
- is_intel = env->cpuid && strstarts(env->cpuid, "GenuineIntel") ? 1 : -1;
+ mutex_lock(&env->lock);
+ is_intel = env->cpuid && strstarts(env->cpuid, "GenuineIntel");
+ mutex_unlock(&env->lock);
- return is_intel >= 1 ? true : false;
+ return is_intel;
}
bool x86__is_intel_cpu(void)
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 56a5e57ec512..f35d6867e816 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -4235,8 +4235,17 @@ uint16_t perf_session__e_machine(struct perf_session *session, uint32_t *e_flags
* more accurate threads.
*/
env = perf_session__env(session);
- if (env && env->e_machine != EM_NONE)
- return perf_env__e_machine(env, e_flags);
+ if (env) {
+ uint16_t e_machine;
+
+ mutex_lock(&env->lock);
+ e_machine = env->e_machine;
+ if (e_machine != EM_NONE && e_flags)
+ *e_flags = env->e_flags;
+ mutex_unlock(&env->lock);
+ if (e_machine != EM_NONE)
+ return e_machine;
+ }
/*
* Compute from threads, note this is more accurate than
@@ -4249,8 +4258,10 @@ uint16_t perf_session__e_machine(struct perf_session *session, uint32_t *e_flags
if (args.e_machine != EM_NONE) {
if (env) {
+ mutex_lock(&env->lock);
env->e_machine = args.e_machine;
env->e_flags = args.e_flags;
+ mutex_unlock(&env->lock);
}
if (e_flags)
*e_flags = args.e_flags;
--
2.56.1.703.gf848ed807c-goog
next prev parent reply other threads:[~2026-11-13 19:53 UTC|newest]
Thread overview: 31+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-13 19:53 [PATCH v2 00/30] perf: Per-env PMUs, metric event sharing, and recorded event metrics Ian Rogers
2026-11-13 19:53 ` [PATCH v2 01/30] perf pmus: Don't skip core PMUs as duplicates Ian Rogers
2026-11-13 19:53 ` [PATCH v2 02/30] perf script: Fix metrics computed from samples Ian Rogers
2026-11-13 19:53 ` [PATCH v2 03/30] perf script: Don't drop metric samples for CPUs missing from the evsel Ian Rogers
2026-11-13 19:53 ` [PATCH v2 04/30] perf metricgroup: Don't prefer tool events for displaying a metric Ian Rogers
2026-11-13 19:53 ` Ian Rogers [this message]
2026-11-13 19:53 ` [PATCH v2 06/30] perf env: Add host_env() singleton Ian Rogers
2026-11-13 19:53 ` [PATCH v2 07/30] perf pmu: Add from_env parameter to perf_pmu__init() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 08/30] perf pmus: Introduce struct perf_pmus and perf_env__pmus() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 09/30] perf pmus: Pass struct perf_pmus to find helpers Ian Rogers
2026-11-13 19:53 ` [PATCH v2 10/30] perf pmus: Pass struct perf_pmus to scan helpers Ian Rogers
2026-11-13 19:53 ` [PATCH v2 11/30] perf pmu-events: Add e_machine to struct pmu_events_map Ian Rogers
2026-11-13 19:53 ` [PATCH v2 12/30] perf pmu-events: Pass e_machine to find_core_*_table() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 13/30] perf header: Pass e_machine to strcmp_cpuid_str() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 14/30] perf header: Support CPUID matching across all architectures Ian Rogers
2026-11-13 19:53 ` [PATCH v2 15/30] perf test: Make the CPUID matching test architecture independent Ian Rogers
2026-11-13 19:53 ` [PATCH v2 16/30] perf test: Add CPUID matching tests for other architectures Ian Rogers
2026-11-13 19:53 ` [PATCH v2 17/30] perf dwarf-regs: Add e_machine__same_arch() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 18/30] perf metricgroup: Pass struct perf_pmus to metricgroup__for_each_metric() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 19/30] perf metricgroup: Move matching of metrics to recorded events from perf script Ian Rogers
2026-11-13 19:53 ` [PATCH v2 20/30] perf parse-events: Decode metric-id terms when adding events Ian Rogers
2026-11-13 19:53 ` [PATCH v2 21/30] perf evsel: Generalize metric_id to a set of metric_ids Ian Rogers
2026-11-13 19:53 ` [PATCH v2 22/30] perf pmu: Add perf_pmu__for_each_name_from_config() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 23/30] perf metricgroup: Share metric events by their counter encoding Ian Rogers
2026-11-13 19:53 ` [PATCH v2 24/30] perf stat: Share events between metrics and command line events Ian Rogers
2026-11-13 19:53 ` [PATCH v2 25/30] perf pmus: Add perf_pmus__read_from_env() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 26/30] perf metricgroup: Improve matching of metrics to recorded events Ian Rogers
2026-11-13 19:53 ` [PATCH v2 27/30] perf metricgroup: Add metricgroup__add_recorded_metrics() Ian Rogers
2026-11-13 19:53 ` [PATCH v2 28/30] perf stat report: Display metrics for recorded events Ian Rogers
2026-11-13 19:53 ` [PATCH v2 29/30] perf script: Display metrics for perf stat record data Ian Rogers
2026-11-13 19:53 ` [PATCH v2 30/30] perf test: Add stat record metrics test Ian Rogers
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261113195335.2865725-6-irogers@google.com \
--to=irogers@google.com \
--cc=acme@kernel.org \
--cc=adrian.hunter@intel.com \
--cc=james.clark@linaro.org \
--cc=jolsa@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-perf-users@vger.kernel.org \
--cc=mingo@redhat.com \
--cc=namhyung@kernel.org \
--cc=peterz@infradead.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®