From nobody Sat Jun 20 20:53:38 2026 Received: from mail-dy1-f202.google.com (mail-dy1-f202.google.com [74.125.82.202]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id DC14E39E194 for ; Thu, 9 Apr 2026 23:06:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775775992; cv=none; b=OXQfxvMwpHffzB2M2qtC2v9zSzXwBjXhmUeOeETuY0kE9YgZ+hVSeYBGDPMzilDJfyWFb+0lqmTq071TXDfGw650QwFWIdS4HzJwuQr09BMDPc0uVSJrutEHuQ3A0qhKPSLNGXxBTexJpJ6ha1NrPGg7Vq3CIzdtDjR/2eFSE7w= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775775992; c=relaxed/simple; bh=+Y8cvPVVvvqdbquJvuJg+J4k4bR2AGmtJbF1vmdOsI0=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=TsHJKqt+8ABSU12NqehTfKwOZGXbQ1fxq82Uh4WleX8w88YVOdYfdcrKCObIJO1ZdHdjXr7Eph1xLasmwCLmC1ToUfh3TYwKtxc7CVIUo/HS3bStyuBuzShyY7UwrncyQY0SCENoU7JYE9aQzfiu9g8DNNBCuHrF7uQjK17i5zQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--irogers.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=WmkRy1zH; arc=none smtp.client-ip=74.125.82.202 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--irogers.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="WmkRy1zH" Received: by mail-dy1-f202.google.com with SMTP id 5a478bee46e88-2c0f6593ef5so1761022eec.1 for ; Thu, 09 Apr 2026 16:06:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1775775990; x=1776380790; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=93K47+1MFWVpbraQHFk+5E8Mf2fMBiBw3PCbHNvpcbw=; b=WmkRy1zHobL9de6u+gpcXyxm0BRG7zR4V1ILVvsfDR6KaMtbwjfd+h/y4qNWfmyP6s PJc0CmyzWX9eLnNWtKS/dAEDmcRFI6VSh9qZC9PDCpgfi27MpNBchD9AnXK9bJ41IF4O xH9ZVirAvHEXFFevBcZtPcZf2ZGD0c9kimIKqNO/vBumhI4py/eGS4J50zAwZUsrnjyF taImqmBNct+WjIc7XCxpb3EtQql/4AXXpWogWayqK/U/wyTRNHSdqfFIFIrF8v5oq96v UvDph3zHEjGKELqwu6czbG2+7TXKBIjWq32Bwwc+qjH/ZNCEdOqPbCmuNstev99BLLj1 Pp8w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775775990; x=1776380790; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=93K47+1MFWVpbraQHFk+5E8Mf2fMBiBw3PCbHNvpcbw=; b=jCFsMSYoEPP/PgWGjfT+TxAph5ehBab147G/qF14IuTd/ThEIePFsO6yvw+ezX1ZC7 sAsalCPWHoiRnNayZah8QiA35/R/S+9cl7NXaa4nELVYL90+8H/Lv3svgKuk20Hmo0Ai +jRYO5yphz4sjoOzdEnutZqtuJ411DOiKfcMMFCWywSvYiddR00XXRO/wMGYkgTJOnwX SHpz3FaOZnKp/h6Tkiz0UOsnSACLVOQjI53InOSnQqElEkKYVqMN0Dx8LUsft7qBCRvd majcFU+No/KaDMH6YRjbw7orrwiAOQTLVW5mNfOuTOSGOQMDAgDJbVaoEbnWJqllip/n BBwQ== X-Forwarded-Encrypted: i=1; AJvYcCVxApe+N0ARbkkz8iDsGgovJk6gbOyNiz/snuOVuhUhhzsPP2PrWKgS21LGJxE19+PaOjI1nOXVgYaYysc=@vger.kernel.org X-Gm-Message-State: AOJu0Ywg3dZc3sT9BTmAb9lP7WemA2G4jiDReU5uxV2HLJ5pB1K+o30I xn9Ekh4gdlNwIxaazzz+YZaW5cWJmJ/CUXIDSvZtfHFvfyy/cCE4cT0gJTzioHeEvYgBvy3zdcd RETeNKpQlAA== X-Received: from dycc15.prod.google.com ([2002:a05:693c:60cf:b0:2c6:415a:9023]) (user=irogers job=prod-delivery.src-stubby-dispatcher) by 2002:a05:7300:220d:b0:2be:1f56:ed21 with SMTP id 5a478bee46e88-2d5876a0820mr632825eec.7.1775775989741; Thu, 09 Apr 2026 16:06:29 -0700 (PDT) Date: Thu, 9 Apr 2026 16:06:18 -0700 In-Reply-To: <20260409230620.4176210-1-irogers@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260406170905.2614260-1-irogers@google.com> <20260409230620.4176210-1-irogers@google.com> X-Mailer: git-send-email 2.53.0.1213.gd9a14994de-goog Message-ID: <20260409230620.4176210-2-irogers@google.com> Subject: [PATCH v6 1/3] perf env: Add perf_env__e_machine helper and use in perf_env__arch From: Ian Rogers To: namhyung@kernel.org Cc: irogers@google.com, acme@kernel.org, agordeev@linux.ibm.com, gor@linux.ibm.com, hca@linux.ibm.com, jameshongleiwang@126.com, japo@linux.ibm.com, linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, linux-s390@vger.kernel.org, sumanthk@linux.ibm.com, tmricht@linux.ibm.com Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add a helper that lazily computes the e_machine and falls back of EM_HOST. Use the perf_env's arch to compute the e_machine if available. Use a binary search for some efficiency in this, but handle somewhat complex duplicate rules. Switch perf_env__arch to be derived the e_machine for consistency. This switches arch from being uname derived to matching that of the perf binary (via EM_HOST). Update session to use the helper, which may mean using EM_HOST when no threads are available. This also updates the perf data file header that gets the e_machine/e_flags from the session. Signed-off-by: Ian Rogers --- tools/perf/util/env.c | 185 ++++++++++++++++++++++++++++++-------- tools/perf/util/env.h | 1 + tools/perf/util/header.c | 44 ++++++--- tools/perf/util/session.c | 14 +-- 4 files changed, 191 insertions(+), 53 deletions(-) diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c index 1e54e2c86360..339d62ca37bb 100644 --- a/tools/perf/util/env.c +++ b/tools/perf/util/env.c @@ -1,10 +1,12 @@ // SPDX-License-Identifier: GPL-2.0 #include "cpumap.h" +#include "dwarf-regs.h" #include "debug.h" #include "env.h" #include "util/header.h" #include "util/rwsem.h" #include +#include #include #include #include @@ -588,51 +590,160 @@ void cpu_cache_level__free(struct cpu_cache_level *c= ache) zfree(&cache->size); } =20 +struct arch_to_e_machine { + const char *prefix; + uint16_t e_machine; +}; + /* - * Return architecture name in a normalized form. - * The conversion logic comes from the Makefile. + * A mapping from an arch prefix string to an ELF machine that can be used= in a + * bsearch. Some arch prefixes are shared an need additional processing as + * marked next to the architecture. The prefixes handle both perf's archit= ecture + * naming and those from uname. */ -static const char *normalize_arch(char *arch) -{ - if (!strcmp(arch, "x86_64")) - return "x86"; - if (arch[0] =3D=3D 'i' && arch[2] =3D=3D '8' && arch[3] =3D=3D '6') - return "x86"; - if (!strcmp(arch, "sun4u") || !strncmp(arch, "sparc", 5)) - return "sparc"; - if (!strncmp(arch, "aarch64", 7) || !strncmp(arch, "arm64", 5)) - return "arm64"; - if (!strncmp(arch, "arm", 3) || !strcmp(arch, "sa110")) - return "arm"; - if (!strncmp(arch, "s390", 4)) - return "s390"; - if (!strncmp(arch, "parisc", 6)) - return "parisc"; - if (!strncmp(arch, "powerpc", 7) || !strncmp(arch, "ppc", 3)) - return "powerpc"; - if (!strncmp(arch, "mips", 4)) - return "mips"; - if (!strncmp(arch, "sh", 2) && isdigit(arch[2])) - return "sh"; - if (!strncmp(arch, "loongarch", 9)) - return "loongarch"; - - return arch; +static const struct arch_to_e_machine prefix_to_e_machine[] =3D { + {"aarch64", EM_AARCH64}, + {"alpha", EM_ALPHA}, + {"arc", EM_ARC}, + {"arm", EM_ARM}, /* Check also for EM_AARCH64. */ + {"avr", EM_AVR}, /* Check also for EM_AVR32. */ + {"bfin", EM_BLACKFIN}, + {"blackfin", EM_BLACKFIN}, + {"cris", EM_CRIS}, + {"csky", EM_CSKY}, + {"hppa", EM_PARISC}, + {"i386", EM_386}, + {"i486", EM_386}, + {"i586", EM_386}, + {"i686", EM_386}, + {"loongarch", EM_LOONGARCH}, + {"m32r", EM_M32R}, + {"m68k", EM_68K}, + {"microblaze", EM_MICROBLAZE}, + {"mips", EM_MIPS}, + {"msp430", EM_MSP430}, + {"parisc", EM_PARISC}, + {"powerpc", EM_PPC}, /* Check also for EM_PPC64. */ + {"ppc", EM_PPC}, /* Check also for EM_PPC64. */ + {"riscv", EM_RISCV}, + {"s390", EM_S390}, + {"sa110", EM_ARM}, + {"sh", EM_SH}, + {"sparc", EM_SPARC}, /* Check also for EM_SPARCV9. */ + {"sun4u", EM_SPARC}, + {"x86", EM_X86_64}, /* Check also for EM_386. */ + {"xtensa", EM_XTENSA}, +}; + +static int compare_prefix(const void *key, const void *element) +{ + const char *search_key =3D key; + const struct arch_to_e_machine *map_element =3D element; + size_t prefix_len =3D strlen(map_element->prefix); + + return strncmp(search_key, map_element->prefix, prefix_len); +} + +static uint16_t perf_arch_to_e_machine(const char *perf_arch, bool is_64_b= it) +{ + /* Binary search for a matching prefix. */ + const struct arch_to_e_machine *result; + + if (!perf_arch) + return EM_HOST; + + result =3D bsearch(perf_arch, + prefix_to_e_machine, ARRAY_SIZE(prefix_to_e_machine), + sizeof(prefix_to_e_machine[0]), + compare_prefix); + + if (!result) { + pr_debug("Unknown perf arch for ELF machine mapping: %s\n", perf_arch); + return EM_NONE; + } + + /* Handle conflicting prefixes. */ + switch (result->e_machine) { + case EM_ARM: + return !strcmp(perf_arch, "arm64") ? EM_AARCH64 : EM_ARM; + case EM_AVR: + return !strcmp(perf_arch, "avr32") ? EM_AVR32 : EM_AVR; + case EM_PPC: + return is_64_bit || strstarts(perf_arch, "ppc64") ? EM_PPC64 : EM_PPC; + case EM_SPARC: + return is_64_bit || !strcmp(perf_arch, "sparc64") ? EM_SPARCV9 : EM_SPAR= C; + case EM_X86_64: + return is_64_bit || !strcmp(perf_arch, "x86_64") ? EM_X86_64 : EM_386; + default: + return result->e_machine; + } +} + +static const char *e_machine_to_perf_arch(uint16_t e_machine) +{ + /* + * Table for if either the perf arch string differs from uname or there + * are >1 ELF machine with the prefix. + */ + static const struct arch_to_e_machine extras[] =3D { + {"arm64", EM_AARCH64}, + {"avr32", EM_AVR32}, + {"powerpc", EM_PPC}, + {"powerpc", EM_PPC64}, + {"sparc", EM_SPARCV9}, + {"x86", EM_386}, + {"x86", EM_X86_64}, + {"none", EM_NONE}, + }; + + for (size_t i =3D 0; i < ARRAY_SIZE(extras); i++) { + if (extras[i].e_machine =3D=3D e_machine) + return extras[i].prefix; + } + + for (size_t i =3D 0; i < ARRAY_SIZE(prefix_to_e_machine); i++) { + if (prefix_to_e_machine[i].e_machine =3D=3D e_machine) + return prefix_to_e_machine[i].prefix; + + } + return "unknown"; +} + +uint16_t perf_env__e_machine(struct perf_env *env, uint32_t *e_flags) +{ + if (!env) { + if (e_flags) + *e_flags =3D EF_HOST; + + return EM_HOST; + } + if (env->e_machine =3D=3D EM_NONE) { + env->e_machine =3D perf_arch_to_e_machine(env->arch, env->kernel_is_64_b= it); + + if (env->e_machine =3D=3D EM_HOST) + env->e_flags =3D EF_HOST; + } + if (e_flags) + *e_flags =3D env->e_flags; + + return env->e_machine; } =20 const char *perf_env__arch(struct perf_env *env) { - char *arch_name; + if (!env) + return e_machine_to_perf_arch(EM_HOST); =20 - if (!env || !env->arch) { /* Assume local operation */ - static struct utsname uts =3D { .machine[0] =3D '\0', }; - if (uts.machine[0] =3D=3D '\0' && uname(&uts) < 0) - return NULL; - arch_name =3D uts.machine; - } else - arch_name =3D env->arch; + if (!env->arch) { + /* + * Lazily compute/allocate arch. The e_machine may have been + * read from a data file and so may not be EM_HOST. + */ + uint16_t e_machine =3D perf_env__e_machine(env, /*e_flags=3D*/NULL); =20 - return normalize_arch(arch_name); + env->arch =3D strdup(e_machine_to_perf_arch(e_machine)); + } + return env->arch; } =20 #if defined(HAVE_LIBTRACEEVENT) diff --git a/tools/perf/util/env.h b/tools/perf/util/env.h index c7052ac1f856..d36a0fb2cd04 100644 --- a/tools/perf/util/env.h +++ b/tools/perf/util/env.h @@ -187,6 +187,7 @@ int perf_env__read_cpu_topology_map(struct perf_env *en= v); =20 void cpu_cache_level__free(struct cpu_cache_level *cache); =20 +uint16_t perf_env__e_machine(struct perf_env *env, uint32_t *e_flags); const char *perf_env__arch(struct perf_env *env); const char *perf_env__arch_strerrno(struct perf_env *env, int err); const char *perf_env__cpuid(struct perf_env *env); diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index c6efddb70aee..9bb4a271b4f8 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -370,21 +370,25 @@ static int write_osrelease(struct feat_fd *ff, return do_write_string(ff, uts.release); } =20 -static int write_arch(struct feat_fd *ff, - struct evlist *evlist __maybe_unused) +static int write_arch(struct feat_fd *ff, struct evlist *evlist) { struct utsname uts; - int ret; + const char *arch =3D NULL; =20 - ret =3D uname(&uts); - if (ret < 0) - return -1; + if (evlist->session) + arch =3D perf_env__arch(perf_session__env(evlist->session)); =20 - return do_write_string(ff, uts.machine); + if (!arch) { + int ret =3D uname(&uts); + + if (ret < 0) + return -1; + arch =3D uts.machine; + } + return do_write_string(ff, arch); } =20 -static int write_e_machine(struct feat_fd *ff, - struct evlist *evlist __maybe_unused) +static int write_e_machine(struct feat_fd *ff, struct evlist *evlist) { /* e_machine expanded from 16 to 32-bits for alignment. */ uint32_t e_flags; @@ -2675,10 +2679,30 @@ static int process_##__feat(struct feat_fd *ff, voi= d *data __maybe_unused) \ FEAT_PROCESS_STR_FUN(hostname, hostname); FEAT_PROCESS_STR_FUN(osrelease, os_release); FEAT_PROCESS_STR_FUN(version, version); -FEAT_PROCESS_STR_FUN(arch, arch); FEAT_PROCESS_STR_FUN(cpudesc, cpu_desc); FEAT_PROCESS_STR_FUN(cpuid, cpuid); =20 +static int process_arch(struct feat_fd *ff, void *data __maybe_unused) +{ + uint16_t saved_e_machine =3D ff->ph->env.e_machine; + + free(ff->ph->env.arch); + ff->ph->env.arch =3D do_read_string(ff); + if (!ff->ph->env.arch) + return -ENOMEM; + /* + * Make the arch string canonical by computing the e_machine from it, + * then turning the e_machine back into an arch string. + */ + ff->ph->env.e_machine =3D EM_NONE; + if (perf_env__e_machine(&ff->ph->env, /*e_flags=3D*/NULL) !=3D EM_NONE) { + zfree(&ff->ph->env.arch); + perf_env__arch(&ff->ph->env); + } + ff->ph->env.e_machine =3D saved_e_machine; + return 0; +} + static int process_e_machine(struct feat_fd *ff, void *data __maybe_unused) { int ret; diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c index fe0de2a0277f..726568b88803 100644 --- a/tools/perf/util/session.c +++ b/tools/perf/util/session.c @@ -3023,14 +3023,16 @@ uint16_t perf_session__e_machine(struct perf_sessio= n *session, uint32_t *e_flags return EM_HOST; } =20 + /* Is the env caching an e_machine? */ env =3D perf_session__env(session); - if (env && env->e_machine !=3D EM_NONE) { - if (e_flags) - *e_flags =3D env->e_flags; - - return env->e_machine; - } + if (env && env->e_machine !=3D EM_NONE) + return perf_env__e_machine(env, e_flags); =20 + /* + * Compute from threads, note this is more accurate than + * perf_env__e_machine that falls back on EM_HOST and doesn't consider + * mixed 32-bit and 64-bit threads. + */ machines__for_each_thread(&session->machines, perf_session__e_machine_cb, &args); --=20 2.53.0.1213.gd9a14994de-goog From nobody Sat Jun 20 20:53:38 2026 Received: from mail-dy1-f202.google.com (mail-dy1-f202.google.com [74.125.82.202]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 40A2F3A0B05 for ; Thu, 9 Apr 2026 23:06:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.82.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775775994; cv=none; b=URVIl79jj47HJXBScxdvi/Ib3EhdO4AUKTPd0bgFd248Z8n3l02vd/qW++7kMb8gAMBG4RLJ626SJ9mQpeLyRsiuo5SBSyTX7upf+xWvguWYDUrDoFpxK3P7xOhmQjF6CSidJfrL9pqyHClR5/Mm75N/c1yfqOdw8n5Jnd3B1RU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775775994; c=relaxed/simple; bh=YVhmmG8eYOHv1i++Ze774gQC92yjqq+2N46fILqgY2Q=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=fp2v7+6O5cPRSr19Sq740gFSCIT+3TpT0h6qcCh1IoXjF27GykpKq3cSYmZFTUsvHU9MsnqGkUvz1nMRifQdVhKE3gZ4ErZssEezG5hCqIwC22yWgNt1pj4Kvs9wkByjHgZI8ivB55nzPs+MIXv+aSnLTxCJwG1mpMTl0fE29k0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--irogers.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=jPjDG2//; arc=none smtp.client-ip=74.125.82.202 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--irogers.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="jPjDG2//" Received: by mail-dy1-f202.google.com with SMTP id 5a478bee46e88-2d443c3b094so2049596eec.1 for ; Thu, 09 Apr 2026 16:06:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1775775992; x=1776380792; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=6I83WFnRoUjFbCNJLWtgW/snAK9/jDfYYeQBO7N8LTg=; b=jPjDG2///+T2nhir6D05N4Kp9O3odBujO76O4Gn+VELgB7wjt0pyZDkiygq0DylMo4 jOPNwD412PmGghLdGUT5OnHZywm+GqfeWpPFpDTv2V68SFJkSMkAutCQIbiuRsC9E1Qu 2/ns6rzMHm7VlK3t+1XsKKn9+S2DMx45fXqLuM2tAGF5DlHU4BVJ7E8Ekk067n/F2hpl Y+3eGKZp9IvVIQxj0PwIhx1+ORL/F8niR26yW2ASQY+CwYqxiWq73i3GBnNUG6oXV23e jho777l9gwF1uy5u9hLEQ4rhZK6HRxD9q37SfQmZddh2ES7eFULVmOHOyKWSzow/6ris g40g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775775992; x=1776380792; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=6I83WFnRoUjFbCNJLWtgW/snAK9/jDfYYeQBO7N8LTg=; b=dD/kftkaM7XBjvRjMAlzdklPePe0G+DsBuC13KTHFAjGRRqVy8UrsFVdKnacLYmfL4 aQdGQWs/icywQAvkoe1i7AdKsHUkLbJ8lBD02ViG+PCIUkRGS8Wv8CX8UyIPn7ivu7ru WkbDECZ/ciyVUJgoxapOdd4kEcYFJa4DyiiL1ByNmqa2gxgXJpRaZq6f4VVHEFyCdpuH ntzmbmcDUECBHhUcSlhP2vg6ozF5o5RGBM0LeGgkagQ7+SJDKWNaDMiPOekke8MGPZJn 3qjhFjCifyTt38YkXv8jl1fyrCMaSi7r9nKDRzdzblnTN6PTEDcEHRaCdEjFfTx+mPJd KxWQ== X-Forwarded-Encrypted: i=1; AJvYcCXAvzJKIIT+Cu0NHFHTNCMCDalc20Q6MHJyQh4hDATrl43K9Qs6yTUjIFZkRmuopQVy4wTnzMTJgvWkiKs=@vger.kernel.org X-Gm-Message-State: AOJu0Yy0+5467ZlFMw0u9foUSxbHyDBVTu1MOcybL7VVOvlG+/SdbRen AURz4NBdrNz/sYzqoPTZriPrxATwTyiSVY1r8WybXQnCxEYBV+cbd79+/Llg09S3ILT6c88dllk GPO5pmziC6Q== X-Received: from dybqd6.prod.google.com ([2002:a05:7301:6406:b0:2d5:2d6a:465f]) (user=irogers job=prod-delivery.src-stubby-dispatcher) by 2002:a05:7301:6589:b0:2c4:ec89:bc7 with SMTP id 5a478bee46e88-2d586991a81mr600594eec.10.1775775992137; Thu, 09 Apr 2026 16:06:32 -0700 (PDT) Date: Thu, 9 Apr 2026 16:06:19 -0700 In-Reply-To: <20260409230620.4176210-1-irogers@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260406170905.2614260-1-irogers@google.com> <20260409230620.4176210-1-irogers@google.com> X-Mailer: git-send-email 2.53.0.1213.gd9a14994de-goog Message-ID: <20260409230620.4176210-3-irogers@google.com> Subject: [PATCH v6 2/3] perf env: Add helper to lazily compute the os_release From: Ian Rogers To: namhyung@kernel.org Cc: irogers@google.com, acme@kernel.org, agordeev@linux.ibm.com, gor@linux.ibm.com, hca@linux.ibm.com, jameshongleiwang@126.com, japo@linux.ibm.com, linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, linux-s390@vger.kernel.org, sumanthk@linux.ibm.com, tmricht@linux.ibm.com Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" In live mode the os_release isn't being initialized, make a lazy initialization helper that assumes when the os_release isn't initialized this is live mode. Signed-off-by: Ian Rogers --- tools/perf/util/data-convert-bt.c | 2 +- tools/perf/util/env.c | 21 +++++++++++++++++++++ tools/perf/util/env.h | 1 + tools/perf/util/header.c | 16 +++++++++++----- tools/perf/util/symbol.c | 4 ++-- 5 files changed, 36 insertions(+), 8 deletions(-) diff --git a/tools/perf/util/data-convert-bt.c b/tools/perf/util/data-conve= rt-bt.c index 3b8f2df823a9..2c88420fe33e 100644 --- a/tools/perf/util/data-convert-bt.c +++ b/tools/perf/util/data-convert-bt.c @@ -1414,7 +1414,7 @@ do { \ =20 ADD("host", env->hostname); ADD("sysname", "Linux"); - ADD("release", env->os_release); + ADD("release", perf_env__os_release(env)); ADD("version", env->version); ADD("machine", env->arch); ADD("domain", "kernel"); diff --git a/tools/perf/util/env.c b/tools/perf/util/env.c index 339d62ca37bb..34b737950f73 100644 --- a/tools/perf/util/env.c +++ b/tools/perf/util/env.c @@ -330,6 +330,27 @@ int perf_env__kernel_is_64_bit(struct perf_env *env) return env->kernel_is_64_bit; } =20 +const char *perf_env__os_release(struct perf_env *env) +{ + struct utsname uts; + int ret; + + if (!env) + return perf_version_string; + + if (env->os_release) + return env->os_release; + + /* + * The os_release is being accessed but wasn't initialized from a data + * file, assume this is 'live' mode and use the release from uname. If + * uname fails then use the current perf tool version. + */ + ret =3D uname(&uts); + env->os_release =3D strdup(ret < 0 ? perf_version_string : uts.release); + return env->os_release; +} + int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv= []) { int i; diff --git a/tools/perf/util/env.h b/tools/perf/util/env.h index d36a0fb2cd04..56020f4381cd 100644 --- a/tools/perf/util/env.h +++ b/tools/perf/util/env.h @@ -175,6 +175,7 @@ void free_cpu_domain_info(struct cpu_domain_map **cd_ma= p, u32 schedstat_version, void perf_env__exit(struct perf_env *env); =20 int perf_env__kernel_is_64_bit(struct perf_env *env); +const char *perf_env__os_release(struct perf_env *env); =20 int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv= []); =20 diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c index 9bb4a271b4f8..89115134f1d2 100644 --- a/tools/perf/util/header.c +++ b/tools/perf/util/header.c @@ -361,13 +361,19 @@ static int write_osrelease(struct feat_fd *ff, struct evlist *evlist __maybe_unused) { struct utsname uts; - int ret; + const char *release =3D NULL; =20 - ret =3D uname(&uts); - if (ret < 0) - return -1; + if (evlist->session) + release =3D perf_env__os_release(perf_session__env(evlist->session)); =20 - return do_write_string(ff, uts.release); + if (!release) { + int ret =3D uname(&uts); + + if (ret < 0) + return -1; + release =3D uts.release; + } + return do_write_string(ff, release); } =20 static int write_arch(struct feat_fd *ff, struct evlist *evlist) diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c index fcaeeddbbb6b..fd332db56157 100644 --- a/tools/perf/util/symbol.c +++ b/tools/perf/util/symbol.c @@ -2209,7 +2209,7 @@ static int vmlinux_path__init(struct perf_env *env) { struct utsname uts; char bf[PATH_MAX]; - char *kernel_version; + const char *kernel_version; unsigned int i; =20 vmlinux_path =3D malloc(sizeof(char *) * (ARRAY_SIZE(vmlinux_paths) + @@ -2226,7 +2226,7 @@ static int vmlinux_path__init(struct perf_env *env) return 0; =20 if (env) { - kernel_version =3D env->os_release; + kernel_version =3D perf_env__os_release(env); } else { if (uname(&uts) < 0) goto out_fail; --=20 2.53.0.1213.gd9a14994de-goog From nobody Sat Jun 20 20:53:38 2026 Received: from mail-pg1-f202.google.com (mail-pg1-f202.google.com [209.85.215.202]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 151863A16B5 for ; Thu, 9 Apr 2026 23:06:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775775997; cv=none; b=HZbanQuzQma5AgwNYyoZxjn9VRni/4+9jRTzaiiowMHkWk46xR48l4Y3YDi77v5P2wJ5DQ5tFCW1r3LBheAOLhIdPYCjtHsUf6NI2OrdiPgD4Z5azt+UR051qqq3fFq6uura8ATb5GcglGGyATM1CJV7CNv3EhRnCCIRSgXxUOA= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1775775997; c=relaxed/simple; bh=kwaIKO/2lbXrb1wvinGWCcDIm8AJdRJjUS4AzOHgqK8=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=AIpZFaVWnFD7EE1T0JgtlLCYV0QrvxaqOQlUFTtteTxnGEZZRuhEBdeeb518lwqC3qxqfmo4cY1UNc/IBSGwpaxM5+iXAHy2UsCeXInNPlyiIu3jNx3BPhtPSNQRFeyDeDpitPtYQk/JALLg6JMRPMndKA9BWQ2gZG5iFy1VqxA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--irogers.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=iPze8wbX; arc=none smtp.client-ip=209.85.215.202 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--irogers.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="iPze8wbX" Received: by mail-pg1-f202.google.com with SMTP id 41be03b00d2f7-c76b69fb9d6so904425a12.1 for ; Thu, 09 Apr 2026 16:06:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1775775994; x=1776380794; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=2uiPOwWAEdlPZssoT2GonMajxJ0IeQq8SJyhaHBfNjU=; b=iPze8wbXnLGr1rktTrTXo2/DJR3+k5d7eZMFhbgf7UxdPMa98CSm4dZQOh30wuKbbT TWq/Gz4QZw9+bt3fgts914NnceK3NkMIelkmBJrahF4K4l7V8nZk/Bpr4PnM2SUwt90G H3wXZ90016mcDUQGeluAngsBJMWMsjMfaLapU3uX/bBFfLW2HuR9T6ZGvYF4Mlvwz0om FuZDMEAFVo56M1Zw+nNLGU0+6511n6uXohL39yUv69yBurCEWYUy+iNNwEhYBGAPiEty GbCkttLPrxy4z2/N6N+AXW4zqergOMqtch/0OXThoG2W8neDGcT3AwYlu1lIqbLL0fdl dMnA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1775775994; x=1776380794; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=2uiPOwWAEdlPZssoT2GonMajxJ0IeQq8SJyhaHBfNjU=; b=enJGgXvRHn8b/gGKB+mdWBig5Fo3pNrraVRyhPkGQWm2CqMP7XUrPUwDaCS64DXO6A CY1Rb3emlmNwd0FRmUlS5oYBLW9Po0DYNwk29SvGP5w05U/qlQKzwRSP+jZekbXvZv6+ lEFJAaNQ3EWbh0xeGfhIxgZGFq5B0FxIA6WiP3chEhPLwfpqykXhfsxbK2SyKNtyS3ch cYL3JfnID2wNOIrtxXTWLosbODj+f00mnkmquJh+2OkngFLSh5l1se1HrqAFV5WUtSwF WpLOWORjJi/1Ob7EzS/UwOw/cYNfjnZfcuDV5agpW89/TffpBxxx2kpSB75HpMvWibGf oduw== X-Forwarded-Encrypted: i=1; AJvYcCXoIVN3biQk6Bb92XfV9loSMhlDCkosSLxZQR8q1ZBJzifrpoEhlo+Tj2nTgPzPydowjT6FnkTYSh6C3SA=@vger.kernel.org X-Gm-Message-State: AOJu0Ywp6My5vegVVDAzQ+xgk9z560S4IaBW1UAQJT5WSfE2NUMqOqKq cpBIQ97Jkzu1EC8B9/eR7wtt/t5eQ/lCtBevcAHKCcQjKu6n8Tqou7WupRZ6mxIEINctovF1CEr yrr449/f58w== X-Received: from pgar14.prod.google.com ([2002:a05:6a02:2e8e:b0:c76:81aa:4124]) (user=irogers job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a20:3ca8:b0:398:71f2:59dd with SMTP id adf61e73a8af0-39fe447aba1mr655104637.9.1775775994222; Thu, 09 Apr 2026 16:06:34 -0700 (PDT) Date: Thu, 9 Apr 2026 16:06:20 -0700 In-Reply-To: <20260409230620.4176210-1-irogers@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260406170905.2614260-1-irogers@google.com> <20260409230620.4176210-1-irogers@google.com> X-Mailer: git-send-email 2.53.0.1213.gd9a14994de-goog Message-ID: <20260409230620.4176210-4-irogers@google.com> Subject: [PATCH v6 3/3] perf symbol: Lazily compute idle and use the perf_env From: Ian Rogers To: namhyung@kernel.org Cc: irogers@google.com, acme@kernel.org, agordeev@linux.ibm.com, gor@linux.ibm.com, hca@linux.ibm.com, jameshongleiwang@126.com, japo@linux.ibm.com, linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org, linux-s390@vger.kernel.org, sumanthk@linux.ibm.com, tmricht@linux.ibm.com Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Move the idle boolean to a helper symbol__is_idle function. In the function lazily compute whether a symbol is an idle function taking into consideration the kernel version and architecture of the machine. As symbols__insert no longer needs to know if a symbol is for the kernel, remove the argument. This change is inspired by mailing list discussion, particularly from Thomas Richter and Heiko Carstens : https://lore.kernel.org/lkml/20260219113850.354271-1-tmricht@linux.ibm.com/ The change switches x86 matches to use strstarts which means intel_idle_irq is matched as part of strstarts(name, "intel_idle"), a change suggested by Honglei Wang in: https://lore.kernel.org/lkml/20260323085255.98173-1-jameshongleiwang@126.co= m/ Signed-off-by: Ian Rogers --- tools/perf/builtin-top.c | 6 +- tools/perf/util/symbol-elf.c | 2 +- tools/perf/util/symbol.c | 103 ++++++++++++++++++++++------------- tools/perf/util/symbol.h | 15 +++-- 4 files changed, 82 insertions(+), 44 deletions(-) diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c index f6eb543de537..95fa3a03e62d 100644 --- a/tools/perf/builtin-top.c +++ b/tools/perf/builtin-top.c @@ -751,6 +751,7 @@ static void perf_event__process_sample(const struct per= f_tool *tool, { struct perf_top *top =3D container_of(tool, struct perf_top, tool); struct addr_location al; + struct dso *dso =3D NULL; =20 if (!machine && perf_guest) { static struct intlist *seen; @@ -830,7 +831,10 @@ static void perf_event__process_sample(const struct pe= rf_tool *tool, } } =20 - if (al.sym =3D=3D NULL || !al.sym->idle) { + if (al.map) + dso =3D map__dso(al.map); + + if (al.sym =3D=3D NULL || !symbol__is_idle(al.sym, dso, machine->env)) { struct hists *hists =3D evsel__hists(evsel); struct hist_entry_iter iter =3D { .evsel =3D evsel, diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c index 7afa8a117139..e8f7fe3f19fc 100644 --- a/tools/perf/util/symbol-elf.c +++ b/tools/perf/util/symbol-elf.c @@ -1727,7 +1727,7 @@ dso__load_sym_internal(struct dso *dso, struct map *m= ap, struct symsrc *syms_ss, =20 arch__sym_update(f, &sym); =20 - __symbols__insert(dso__symbols(curr_dso), f, dso__kernel(dso)); + __symbols__insert(dso__symbols(curr_dso), f); nr++; } dso__put(curr_dso); diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c index fd332db56157..482fd47bead2 100644 --- a/tools/perf/util/symbol.c +++ b/tools/perf/util/symbol.c @@ -25,6 +25,8 @@ #include "demangle-ocaml.h" #include "demangle-rust-v0.h" #include "dso.h" +#include "dwarf-regs.h" +#include "env.h" #include "util.h" // lsdir() #include "event.h" #include "machine.h" @@ -50,7 +52,6 @@ =20 static int dso__load_kernel_sym(struct dso *dso, struct map *map); static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map); -static bool symbol__is_idle(const char *name); =20 int vmlinux_path__nr_entries; char **vmlinux_path; @@ -358,8 +359,7 @@ void symbols__delete(struct rb_root_cached *symbols) } } =20 -void __symbols__insert(struct rb_root_cached *symbols, - struct symbol *sym, bool kernel) +void __symbols__insert(struct rb_root_cached *symbols, struct symbol *sym) { struct rb_node **p =3D &symbols->rb_root.rb_node; struct rb_node *parent =3D NULL; @@ -367,17 +367,6 @@ void __symbols__insert(struct rb_root_cached *symbols, struct symbol *s; bool leftmost =3D true; =20 - if (kernel) { - const char *name =3D sym->name; - /* - * ppc64 uses function descriptors and appends a '.' to the - * start of every instruction address. Remove it. - */ - if (name[0] =3D=3D '.') - name++; - sym->idle =3D symbol__is_idle(name); - } - while (*p !=3D NULL) { parent =3D *p; s =3D rb_entry(parent, struct symbol, rb_node); @@ -394,7 +383,7 @@ void __symbols__insert(struct rb_root_cached *symbols, =20 void symbols__insert(struct rb_root_cached *symbols, struct symbol *sym) { - __symbols__insert(symbols, sym, false); + __symbols__insert(symbols, sym); } =20 static struct symbol *symbols__find(struct rb_root_cached *symbols, u64 ip) @@ -555,7 +544,7 @@ void dso__reset_find_symbol_cache(struct dso *dso) =20 void dso__insert_symbol(struct dso *dso, struct symbol *sym) { - __symbols__insert(dso__symbols(dso), sym, dso__kernel(dso)); + __symbols__insert(dso__symbols(dso), sym); =20 /* update the symbol cache if necessary */ if (dso__last_find_result_addr(dso) >=3D sym->start && @@ -717,47 +706,85 @@ int modules__parse(const char *filename, void *arg, return err; } =20 +static int sym_name_cmp(const void *a, const void *b) +{ + const char *name =3D a; + const char *const *sym =3D b; + + return strcmp(name, *sym); +} + /* * These are symbols in the kernel image, so make sure that * sym is from a kernel DSO. */ -static bool symbol__is_idle(const char *name) +bool symbol__is_idle(struct symbol *sym, const struct dso *dso, struct per= f_env *env) { - const char * const idle_symbols[] =3D { + static const char * const idle_symbols[] =3D { "acpi_idle_do_entry", "acpi_processor_ffh_cstate_enter", "arch_cpu_idle", "cpu_idle", "cpu_startup_entry", - "idle_cpu", - "intel_idle", - "intel_idle_ibrs", "default_idle", - "native_safe_halt", "enter_idle", "exit_idle", - "mwait_idle", - "mwait_idle_with_hints", - "mwait_idle_with_hints.constprop.0", + "idle_cpu", + "native_safe_halt", "poll_idle", - "ppc64_runlatch_off", "pseries_dedicated_idle_sleep", - "psw_idle", - "psw_idle_exit", - NULL }; - int i; - static struct strlist *idle_symbols_list; + const char *name =3D sym->name; + uint16_t e_machine =3D perf_env__e_machine(env, /*e_flags=3D*/NULL); + + if (sym->idle) + return sym->idle =3D=3D SYMBOL_IDLE__IDLE; + + if (!dso || dso__kernel(dso) =3D=3D DSO_SPACE__USER) { + sym->idle =3D SYMBOL_IDLE__NOT_IDLE; + return false; + } =20 - if (idle_symbols_list) - return strlist__has_entry(idle_symbols_list, name); + /* + * ppc64 uses function descriptors and appends a '.' to the + * start of every instruction address. Remove it. + */ + if (name[0] =3D=3D '.') + name++; =20 - idle_symbols_list =3D strlist__new(NULL, NULL); + if (bsearch(name, idle_symbols, ARRAY_SIZE(idle_symbols), + sizeof(idle_symbols[0]), sym_name_cmp)) { + sym->idle =3D SYMBOL_IDLE__IDLE; + return true; + } =20 - for (i =3D 0; idle_symbols[i]; i++) - strlist__add(idle_symbols_list, idle_symbols[i]); + if (e_machine =3D=3D EM_386 || e_machine =3D=3D EM_X86_64) { + if (strstarts(name, "mwait_idle") || + strstarts(name, "intel_idle")) { + sym->idle =3D SYMBOL_IDLE__IDLE; + return true; + } + } =20 - return strlist__has_entry(idle_symbols_list, name); + if (e_machine =3D=3D EM_PPC64 && !strcmp(name, "ppc64_runlatch_off")) { + sym->idle =3D SYMBOL_IDLE__IDLE; + return true; + } + + if (e_machine =3D=3D EM_S390 && strstarts(name, "psw_idle")) { + int major =3D 0, minor =3D 0; + const char *release =3D perf_env__os_release(env); + + /* Before v6.10, s390 used psw_idle. */ + if (release && sscanf(release, "%d.%d", &major, &minor) =3D=3D 2 && + (major < 6 || (major =3D=3D 6 && minor < 10))) { + sym->idle =3D SYMBOL_IDLE__IDLE; + return true; + } + } + + sym->idle =3D SYMBOL_IDLE__NOT_IDLE; + return false; } =20 static int map__process_kallsym_symbol(void *arg, const char *name, @@ -786,7 +813,7 @@ static int map__process_kallsym_symbol(void *arg, const= char *name, * We will pass the symbols to the filter later, in * map__split_kallsyms, when we have split the maps per module */ - __symbols__insert(root, sym, !strchr(name, '[')); + __symbols__insert(root, sym); =20 return 0; } diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h index bd6eb90c8668..7e0036f80185 100644 --- a/tools/perf/util/symbol.h +++ b/tools/perf/util/symbol.h @@ -26,6 +26,7 @@ struct dso; struct map; struct maps; struct option; +struct perf_env; struct build_id; =20 /* @@ -43,6 +44,12 @@ Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep, GElf_Shdr *shp, const char *name, size_t *idx); #endif =20 +enum symbol_idle_kind { + SYMBOL_IDLE__UNKNOWN =3D 0, + SYMBOL_IDLE__NOT_IDLE =3D 1, + SYMBOL_IDLE__IDLE =3D 2, +}; + /** * A symtab entry. When allocated this may be preceded by an annotation (s= ee * symbol__annotation) and/or a browser_index (see symbol__browser_index). @@ -58,8 +65,8 @@ struct symbol { u8 type:4; /** ELF binding type as defined for st_info. E.g. STB_WEAK or STB_GLOBAL.= */ u8 binding:4; - /** Set true for kernel symbols of idle routines. */ - u8 idle:1; + /** Cache for symbol__is_idle holding enum symbol_idle_kind values. */ + u8 idle:2; /** Resolvable but tools ignore it (e.g. idle routines). */ u8 ignore:1; /** Symbol for an inlined function. */ @@ -194,8 +201,7 @@ int dso__synthesize_plt_symbols(struct dso *dso, struct= symsrc *ss); =20 char *dso__demangle_sym(struct dso *dso, int kmodule, const char *elf_name= ); =20 -void __symbols__insert(struct rb_root_cached *symbols, struct symbol *sym, - bool kernel); +void __symbols__insert(struct rb_root_cached *symbols, struct symbol *sym); void symbols__insert(struct rb_root_cached *symbols, struct symbol *sym); void symbols__fixup_duplicate(struct rb_root_cached *symbols); void symbols__fixup_end(struct rb_root_cached *symbols, bool is_kallsyms); @@ -278,5 +284,6 @@ enum { }; =20 int symbol__validate_sym_arguments(void); +bool symbol__is_idle(struct symbol *sym, const struct dso *dso, struct per= f_env *env); =20 #endif /* __PERF_SYMBOL */ --=20 2.53.0.1213.gd9a14994de-goog