* [PATCH v7 03/20] KVM: selftests: Rename guest_rng to kvm_rng
From: Sean Christopherson @ 2026-06-13 0:20 UTC (permalink / raw)
To: Paolo Bonzini, Marc Zyngier, Oliver Upton, Sean Christopherson
Cc: Joey Gouly, Steffen Eiden, Suzuki K Poulose, Zenghui Yu, kvm,
linux-arm-kernel, kvmarm, linux-kernel, David Matlack, Josh Hilke
In-Reply-To: <20260613002031.745413-1-seanjc@google.com>
From: Josh Hilke <jrhilke@google.com>
Rename functions prefixed with 'guest_random_' to 'kvm_random_' and the
global random state variable 'guest_rng' to 'kvm_rng', as the pRNG isn't
strictly limited to guest code. This will allow using the pRNG in host
code without creating confusing/misleading function calls.
No functional changes are intended.
Suggested-by: Sean Christopherson <seanjc@google.com>
Signed-off-by: Josh Hilke <jrhilke@google.com>
[sean: massage changelog]
Signed-off-by: Sean Christopherson <seanjc@google.com>
---
.../selftests/kvm/dirty_log_perf_test.c | 4 ++--
tools/testing/selftests/kvm/dirty_log_test.c | 2 +-
.../testing/selftests/kvm/include/test_util.h | 22 +++++++++----------
.../selftests/kvm/include/x86/kvm_util_arch.h | 4 ++--
tools/testing/selftests/kvm/lib/kvm_util.c | 20 ++++++++---------
tools/testing/selftests/kvm/lib/memstress.c | 8 +++----
tools/testing/selftests/kvm/lib/test_util.c | 6 ++---
.../testing/selftests/kvm/x86/sev_dbg_test.c | 2 +-
8 files changed, 34 insertions(+), 34 deletions(-)
diff --git a/tools/testing/selftests/kvm/dirty_log_perf_test.c b/tools/testing/selftests/kvm/dirty_log_perf_test.c
index ef779fa91827..7c5abe1ae9e0 100644
--- a/tools/testing/selftests/kvm/dirty_log_perf_test.c
+++ b/tools/testing/selftests/kvm/dirty_log_perf_test.c
@@ -311,7 +311,7 @@ int main(int argc, char *argv[])
int opt;
/* Override the seed to be deterministic by default. */
- guest_random_seed = 1;
+ kvm_random_seed = 1;
dirty_log_manual_caps =
kvm_check_cap(KVM_CAP_MANUAL_DIRTY_LOG_PROTECT2);
@@ -357,7 +357,7 @@ int main(int argc, char *argv[])
p.phys_offset = strtoull(optarg, NULL, 0);
break;
case 'r':
- guest_random_seed = atoi_positive("Random seed", optarg);
+ kvm_random_seed = atoi_positive("Random seed", optarg);
break;
case 's':
p.backing_src = parse_backing_src_type(optarg);
diff --git a/tools/testing/selftests/kvm/dirty_log_test.c b/tools/testing/selftests/kvm/dirty_log_test.c
index 087e94a8a81a..e8419d7da1ea 100644
--- a/tools/testing/selftests/kvm/dirty_log_test.c
+++ b/tools/testing/selftests/kvm/dirty_log_test.c
@@ -121,7 +121,7 @@ static void guest_code(void)
while (true) {
while (!READ_ONCE(vcpu_stop)) {
addr = guest_test_virt_mem;
- addr += (guest_random_u64(&guest_rng) % guest_num_pages)
+ addr += (kvm_random_u64(&kvm_rng) % guest_num_pages)
* guest_page_size;
addr = align_down(addr, host_page_size);
diff --git a/tools/testing/selftests/kvm/include/test_util.h b/tools/testing/selftests/kvm/include/test_util.h
index a56271c237ae..44c0104d60ac 100644
--- a/tools/testing/selftests/kvm/include/test_util.h
+++ b/tools/testing/selftests/kvm/include/test_util.h
@@ -108,30 +108,30 @@ struct timespec timespec_sub(struct timespec ts1, struct timespec ts2);
struct timespec timespec_elapsed(struct timespec start);
struct timespec timespec_div(struct timespec ts, int divisor);
-struct guest_random_state {
+struct kvm_random_state {
u32 seed;
};
-extern u32 guest_random_seed;
-extern struct guest_random_state guest_rng;
+extern u32 kvm_random_seed;
+extern struct kvm_random_state kvm_rng;
-struct guest_random_state new_guest_random_state(u32 seed);
-u32 guest_random_u32(struct guest_random_state *state);
+struct kvm_random_state new_kvm_random_state(u32 seed);
+u32 kvm_random_u32(struct kvm_random_state *state);
-static inline bool __guest_random_bool(struct guest_random_state *state,
+static inline bool __kvm_random_bool(struct kvm_random_state *state,
u8 percent)
{
- return (guest_random_u32(state) % 100) < percent;
+ return (kvm_random_u32(state) % 100) < percent;
}
-static inline bool guest_random_bool(struct guest_random_state *state)
+static inline bool kvm_random_bool(struct kvm_random_state *state)
{
- return __guest_random_bool(state, 50);
+ return __kvm_random_bool(state, 50);
}
-static inline u64 guest_random_u64(struct guest_random_state *state)
+static inline u64 kvm_random_u64(struct kvm_random_state *state)
{
- return ((u64)guest_random_u32(state) << 32) | guest_random_u32(state);
+ return ((u64)kvm_random_u32(state) << 32) | kvm_random_u32(state);
}
enum vm_mem_backing_src_type {
diff --git a/tools/testing/selftests/kvm/include/x86/kvm_util_arch.h b/tools/testing/selftests/kvm/include/x86/kvm_util_arch.h
index c33ab6e04171..6904dbda79f9 100644
--- a/tools/testing/selftests/kvm/include/x86/kvm_util_arch.h
+++ b/tools/testing/selftests/kvm/include/x86/kvm_util_arch.h
@@ -55,9 +55,9 @@ static inline bool __vm_arch_has_protected_memory(struct kvm_vm_arch *arch)
do { \
const typeof(mem) val = (__val); \
\
- if (!is_forced_emulation_enabled || guest_random_bool(&guest_rng)) { \
+ if (!is_forced_emulation_enabled || kvm_random_bool(&kvm_rng)) { \
(mem) = val; \
- } else if (guest_random_bool(&guest_rng)) { \
+ } else if (kvm_random_bool(&kvm_rng)) { \
__asm__ __volatile__(KVM_FEP "mov %1, %0" \
: "+m" (mem) \
: "r" (val) : "memory"); \
diff --git a/tools/testing/selftests/kvm/lib/kvm_util.c b/tools/testing/selftests/kvm/lib/kvm_util.c
index 195f3fdae1e3..875030c22d07 100644
--- a/tools/testing/selftests/kvm/lib/kvm_util.c
+++ b/tools/testing/selftests/kvm/lib/kvm_util.c
@@ -20,9 +20,9 @@
#define KVM_UTIL_MIN_PFN 2
-u32 guest_random_seed;
-struct guest_random_state guest_rng;
-static u32 last_guest_seed;
+u32 kvm_random_seed;
+struct kvm_random_state kvm_rng;
+static u32 last_kvm_seed;
static size_t vcpu_mmap_sz(void);
@@ -515,12 +515,12 @@ struct kvm_vm *__vm_create(struct vm_shape shape, u32 nr_runnable_vcpus,
slot0 = memslot2region(vm, 0);
ucall_init(vm, slot0->region.guest_phys_addr + slot0->region.memory_size);
- if (guest_random_seed != last_guest_seed) {
- pr_info("Random seed: 0x%x\n", guest_random_seed);
- last_guest_seed = guest_random_seed;
+ if (kvm_random_seed != last_kvm_seed) {
+ pr_info("Random seed: 0x%x\n", kvm_random_seed);
+ last_kvm_seed = kvm_random_seed;
}
- guest_rng = new_guest_random_state(guest_random_seed);
- sync_global_to_guest(vm, guest_rng);
+ kvm_rng = new_kvm_random_state(kvm_random_seed);
+ sync_global_to_guest(vm, kvm_rng);
kvm_arch_vm_post_create(vm, nr_runnable_vcpus);
@@ -2279,8 +2279,8 @@ void __attribute((constructor)) kvm_selftest_init(void)
sigaction(SIGILL, &sig_sa, NULL);
sigaction(SIGFPE, &sig_sa, NULL);
- guest_random_seed = last_guest_seed = random();
- pr_info("Random seed: 0x%x\n", guest_random_seed);
+ kvm_random_seed = last_kvm_seed = random();
+ pr_info("Random seed: 0x%x\n", kvm_random_seed);
kvm_selftest_arch_init();
}
diff --git a/tools/testing/selftests/kvm/lib/memstress.c b/tools/testing/selftests/kvm/lib/memstress.c
index 6dcd15910a06..3599b75d97c9 100644
--- a/tools/testing/selftests/kvm/lib/memstress.c
+++ b/tools/testing/selftests/kvm/lib/memstress.c
@@ -48,14 +48,14 @@ void memstress_guest_code(u32 vcpu_idx)
{
struct memstress_args *args = &memstress_args;
struct memstress_vcpu_args *vcpu_args = &args->vcpu_args[vcpu_idx];
- struct guest_random_state rand_state;
+ struct kvm_random_state rand_state;
gva_t gva;
u64 pages;
u64 addr;
u64 page;
int i;
- rand_state = new_guest_random_state(guest_random_seed + vcpu_idx);
+ rand_state = new_kvm_random_state(kvm_random_seed + vcpu_idx);
gva = vcpu_args->gva;
pages = vcpu_args->pages;
@@ -69,13 +69,13 @@ void memstress_guest_code(u32 vcpu_idx)
for (i = 0; i < pages; i++) {
if (args->random_access)
- page = guest_random_u32(&rand_state) % pages;
+ page = kvm_random_u32(&rand_state) % pages;
else
page = i;
addr = gva + (page * args->guest_page_size);
- if (__guest_random_bool(&rand_state, args->write_percent))
+ if (__kvm_random_bool(&rand_state, args->write_percent))
*(u64 *)addr = 0x0123456789ABCDEF;
else
READ_ONCE(*(u64 *)addr);
diff --git a/tools/testing/selftests/kvm/lib/test_util.c b/tools/testing/selftests/kvm/lib/test_util.c
index bab1bd2b775b..e98ca7ef439c 100644
--- a/tools/testing/selftests/kvm/lib/test_util.c
+++ b/tools/testing/selftests/kvm/lib/test_util.c
@@ -30,13 +30,13 @@ void __attribute__((used)) expect_sigbus_handler(int signum)
* Park-Miller LCG using standard constants.
*/
-struct guest_random_state new_guest_random_state(u32 seed)
+struct kvm_random_state new_kvm_random_state(u32 seed)
{
- struct guest_random_state s = {.seed = seed};
+ struct kvm_random_state s = {.seed = seed};
return s;
}
-u32 guest_random_u32(struct guest_random_state *state)
+u32 kvm_random_u32(struct kvm_random_state *state)
{
state->seed = (u64)state->seed * 48271 % ((u32)(1 << 31) - 1);
return state->seed;
diff --git a/tools/testing/selftests/kvm/x86/sev_dbg_test.c b/tools/testing/selftests/kvm/x86/sev_dbg_test.c
index a9d8e4c059f9..eaa8201b937d 100644
--- a/tools/testing/selftests/kvm/x86/sev_dbg_test.c
+++ b/tools/testing/selftests/kvm/x86/sev_dbg_test.c
@@ -34,7 +34,7 @@ static void validate_buffers(void)
static void ____test_sev_dbg(struct kvm_vm *vm, int i, int j, int nr_bytes)
{
- u8 pattern = guest_random_u32(&guest_rng);
+ u8 pattern = kvm_random_u32(&kvm_rng);
if (i + nr_bytes > BUFFER_SIZE || j + nr_bytes > BUFFER_SIZE)
return;
--
2.54.0.1136.gdb2ca164c4-goog
^ permalink raw reply related
* [PATCH v7 01/20] KVM: selftests: Build and link selftests/vfio/lib into KVM selftests
From: Sean Christopherson @ 2026-06-13 0:20 UTC (permalink / raw)
To: Paolo Bonzini, Marc Zyngier, Oliver Upton, Sean Christopherson
Cc: Joey Gouly, Steffen Eiden, Suzuki K Poulose, Zenghui Yu, kvm,
linux-arm-kernel, kvmarm, linux-kernel, David Matlack, Josh Hilke
In-Reply-To: <20260613002031.745413-1-seanjc@google.com>
From: David Matlack <dmatlack@google.com>
Include libvfio.mk into the KVM selftests Makefile and link it into all
KVM selftests by adding it to LIBKVM_OBJS.
This lays the groundwork for future changes to utilize VFIO devices to
verify IRQ bypass in KVM selftests.
Note that KVM selftests build their own copy of selftests/vfio/lib and
the resulting object files are placed in $(OUTPUT)/lib. This allows the
KVM and VFIO selftests to apply different CFLAGS when building without
conflicting with each other.
Signed-off-by: David Matlack <dmatlack@google.com>
Signed-off-by: Josh Hilke <jrhilke@google.com>
Signed-off-by: Sean Christopherson <seanjc@google.com>
---
tools/testing/selftests/kvm/Makefile.kvm | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/tools/testing/selftests/kvm/Makefile.kvm b/tools/testing/selftests/kvm/Makefile.kvm
index 9462919d2660..59ec232b1e93 100644
--- a/tools/testing/selftests/kvm/Makefile.kvm
+++ b/tools/testing/selftests/kvm/Makefile.kvm
@@ -258,6 +258,7 @@ OVERRIDE_TARGETS = 1
# which causes the environment variable to override the makefile).
include ../lib.mk
include ../cgroup/lib/libcgroup.mk
+include ../vfio/lib/libvfio.mk
INSTALL_HDR_PATH = $(top_srcdir)/usr
LINUX_HDR_PATH = $(INSTALL_HDR_PATH)/include/
@@ -312,7 +313,9 @@ LIBKVM_S := $(filter %.S,$(LIBKVM))
LIBKVM_C_OBJ := $(patsubst %.c, $(OUTPUT)/%.o, $(LIBKVM_C))
LIBKVM_S_OBJ := $(patsubst %.S, $(OUTPUT)/%.o, $(LIBKVM_S))
LIBKVM_STRING_OBJ := $(patsubst %.c, $(OUTPUT)/%.o, $(LIBKVM_STRING))
-LIBKVM_OBJS = $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ) $(LIBKVM_STRING_OBJ) $(LIBCGROUP_O)
+LIBKVM_OBJS = $(LIBKVM_C_OBJ) $(LIBKVM_S_OBJ) $(LIBKVM_STRING_OBJ)
+LIBKVM_OBJS += $(LIBCGROUP_O)
+LIBKVM_OBJS += $(LIBVFIO_O)
SPLIT_TEST_GEN_PROGS := $(patsubst %, $(OUTPUT)/%, $(SPLIT_TESTS))
SPLIT_TEST_GEN_OBJ := $(patsubst %, $(OUTPUT)/$(ARCH)/%.o, $(SPLIT_TESTS))
--
2.54.0.1136.gdb2ca164c4-goog
^ permalink raw reply related
* [PATCH v7 00/20] KVM: selftests: Add eventfd+VFIO IRQ test
From: Sean Christopherson @ 2026-06-13 0:20 UTC (permalink / raw)
To: Paolo Bonzini, Marc Zyngier, Oliver Upton, Sean Christopherson
Cc: Joey Gouly, Steffen Eiden, Suzuki K Poulose, Zenghui Yu, kvm,
linux-arm-kernel, kvmarm, linux-kernel, David Matlack, Josh Hilke
David and Josh's series to add a selftest for verifying interrupt delivery
via eventfd (via KVM_IRQFD), and also from a real device, wired up via VFIO.
I originally wanted to get this into 7.2, but that's not going to happen. But
I hope to get this applied early in the 7.3 cycle so that additional features
and whatnot can be developed on top without too much pain (hopefully).
Gory details in the patches, and in the v5 cover letter.
v7:
- Seed kvm_rng during kvm_selftest_init(). [Sashiko]
- Seed libc's RNG during kvm_selftest_init(), so that the seed (from random())
that's printed and passed to kvm_rng isn't the same every time.
- Init irq_cpu to -1 in all paths. [Sashiko]
v6:
- Massage most changelogs.
- Fix SoB ordering issues.
- Clean up KVM_SET_GSI_ROUTING helper.
- Remove misleading "IRQ injection" and "emulated eventfd" terminology.
- Add GUEST_RECEIVED_INTERRUPT() to simplifiy the core loop.
- Use cpu_relax() in tight loops while waiting for interrupts.
- Print as much information as possible in the actual assert, instead of
printing to stdout separately.
- Make a best guess as to the right VFIO vs. IOMMUFD mode instead of
assuming IOMMUFD, and give the user the option to overide said guess.
- Simplify open_proc_irq_smp_affinity_list() +
write_proc_irq_smp_affinity_list() into proc_irq_set_smp_affinity().
- Drop print_proc_irq_file() and kvm_print_vcpu_affinity() (for now) to avoid
potential issues on systems with high CPU counts.
- Drop the blocking/HLT testing as it was at best broken.
- Use -e for "empty", not -c for "clear", when completely tearing down GSI
routing, because routing can be "cleared" without completely emptying the
routing information.
- Use the main task's CPU affinity as the available_cpus set.
- Allow overcommiting vCPUs:pCPUs.
- Set the target vCPU's affinity instead of batching when vCPU0 is targeted.
- Add support for 256+ vCPUs with x2APIC.
- Restrict xAPIC mode to 255 vCPUs.
- Restrict the test to KVM selftest's max supported vCPUs.
v5:
- https://lore.kernel.org/all/20260604020143.748245-1-jrhilke@google.com
- Rename get_proc_vfio_irq_number() to vfio_msix_to_host_irq()
- Rename open_proc_irq_affinity() and write_proc_irq_affinity() to include "_smp_affinity_list"
- Print /proc/irq/<irq>/smp_affinity and effective_affinity on timeout failures
- Convert IRQ type from 'int' to 'unsigned int' across helpers and the test
- Fix compiler warnings for uninitialized variables in irq_test.c
- Remove rate-limiting on affinity changes
v4: https://lore.kernel.org/kvm/20260530002134.558837-1-jrhilke@google.com
David Matlack (11):
KVM: selftests: Build and link selftests/vfio/lib into KVM selftests
KVM: selftests: Add macros to read/write+sync to/from guest memory
KVM: selftests: Add an irqfd send+receive (and later IRQ bypass) test
KVM: selftests: Add helper to get host IRQ from device MSI-X for IRQ
bypass test
KVM: selftests: Add VFIO device support to eventfd IRQ test
KVM: selftests: Verify interrupts are received when IRQ affinity
changes in IRQ test
KVM: selftests: Add option to set empty routing between IRQs in
eventfd IRQ test
KVM: selftests: Make number of IRQs configurable in IRQ test
KVM: selftests: Verify vCPU migration during IRQ delivery in IRQ test
KVM: selftests: Make number of vCPUs configurable in IRQ test
KVM: selftests: Add xAPIC support in eventfd IRQ test
Josh Hilke (6):
KVM: selftests: Rename guest_rng to kvm_rng
KVM: selftests: Add helper to generate random u64 in range [min,max]
KVM: selftests: Add a helper to set proc IRQ affinity for IRQ test
KVM: selftests: Add kvm_gettid() wrapper and convert users
KVM: selftests: Add kvm_sched_getaffinity() wrapper and convert users
KVM: selftests: Add a utility to pin a task to a random CPU, given a
CPU set
Sean Christopherson (3):
KVM: selftests: Initialize the default/global pRNG during
kvm_selftest_init()
KVM: selftests: Seed libc's RNG before using it to generate a seed for
KVM's pRNG
KVM: selftests: Verify non-postable IRQ remapping in IRQ test
tools/testing/selftests/kvm/Makefile.kvm | 7 +-
tools/testing/selftests/kvm/arch_timer.c | 2 +-
.../kvm/arm64/arch_timer_edge_cases.c | 2 +-
.../selftests/kvm/demand_paging_test.c | 2 +-
.../selftests/kvm/dirty_log_perf_test.c | 4 +-
tools/testing/selftests/kvm/dirty_log_test.c | 11 +-
.../selftests/kvm/include/kvm_syscalls.h | 7 +
.../testing/selftests/kvm/include/kvm_util.h | 12 +
.../testing/selftests/kvm/include/proc_util.h | 11 +
.../testing/selftests/kvm/include/test_util.h | 25 +-
.../selftests/kvm/include/x86/kvm_util_arch.h | 4 +-
tools/testing/selftests/kvm/irq_test.c | 350 ++++++++++++++++++
tools/testing/selftests/kvm/lib/assert.c | 8 +-
tools/testing/selftests/kvm/lib/kvm_util.c | 53 ++-
tools/testing/selftests/kvm/lib/memstress.c | 8 +-
tools/testing/selftests/kvm/lib/proc_util.c | 54 +++
tools/testing/selftests/kvm/lib/test_util.c | 27 +-
tools/testing/selftests/kvm/mmu_stress_test.c | 15 +-
tools/testing/selftests/kvm/rseq_test.c | 6 +-
tools/testing/selftests/kvm/steal_time.c | 22 +-
.../testing/selftests/kvm/x86/sev_dbg_test.c | 2 +-
21 files changed, 548 insertions(+), 84 deletions(-)
create mode 100644 tools/testing/selftests/kvm/include/proc_util.h
create mode 100644 tools/testing/selftests/kvm/irq_test.c
create mode 100644 tools/testing/selftests/kvm/lib/proc_util.c
base-commit: c1f7303302927f9cbf4efedf70f0512cde168c65
--
2.54.0.1136.gdb2ca164c4-goog
^ permalink raw reply
* Re: [RFC PATCH 0/2] kasan: hw_tags: Add option to tag only at allocation time
From: Isaac Manjarres @ 2026-06-13 0:16 UTC (permalink / raw)
To: Dev Jain
Cc: ryabinin.a.a, akpm, corbet, glider, andreyknvl, dvyukov,
vincenzo.frascino, kasan-dev, linux-mm, linux-kernel, skhan,
workflows, linux-doc, linux-arm-kernel, ryan.roberts,
anshuman.khandual, kaleshsingh, 21cnbao, david, will,
catalin.marinas
In-Reply-To: <20260612044425.763060-1-dev.jain@arm.com>
On Fri, Jun 12, 2026 at 04:44:22AM +0000, Dev Jain wrote:
> Introduce a boot option to tag only at allocation time of the objects. This
> reduces KASAN MTE overhead, the tradeoff being reduced ability of
> catching bugs.
>
> Now, when a memory object will be freed, it will retain the random tag it
> had at allocation time. This compromises on catching UAF bugs, till the
> time the object is not reallocated, at which point it will have a new
> random tag.
>
> Hence, not catching "use-after-free-before-reallocation" and not catching
> "double-free" will be the compromise for reduced KASAN overhead.
>
> This is an RFC because we are not clear about the performance benefit.
>
> Android folks, please help with testing!
>
> ---
> Applies on Linus master (9716c086c8e8).
>
> Dev Jain (2):
> kasan: hw_tags: Use KASAN_PAGE_REDZONE for vmalloc redzoning
> kasan: hw_tags: Add boot option to elide free time poisoning
>
> Documentation/dev-tools/kasan.rst | 4 +++
> mm/kasan/hw_tags.c | 45 +++++++++++++++++++++++++++++--
> mm/kasan/kasan.h | 23 +++++++++++++++-
> 3 files changed, 69 insertions(+), 3 deletions(-)
>
> --
> 2.43.0
I tested out this series on one of our devices that has MTE support,
and didn't see any functional issues.
One thing I did notice though, and it's independent of this patch, is
that the vmalloc_oob is failing, but that happens even if these patches
aren't present.
Thanks,
Isaac
^ permalink raw reply
* Re: [PATCH v2 3/3] arm64: escalate smp_send_stop() to an SDEI NMI as a last resort
From: Doug Anderson @ 2026-06-12 23:44 UTC (permalink / raw)
To: Kiryl Shutsemau
Cc: Catalin Marinas, Will Deacon, James Morse, Mark Rutland,
Marc Zyngier, Petr Mladek, Thomas Gleixner, Andrew Morton,
Baoquan He, Puranjay Mohan, Usama Arif, Breno Leitao,
Julien Thierry, Lecopzer Chen, Sumit Garg, kernel-team, kexec,
linux-arm-kernel, linux-kernel
In-Reply-To: <airhxVP7vAVehIXQ@thinkstation>
Hi,
On Thu, Jun 11, 2026 at 10:47 AM Kiryl Shutsemau <kirill@shutemov.name> wrote:
>
> > FWIW, I'm not totally sure I followed the logic for why "die_on_crash"
> > needs to be "false" for the SDEI case,
>
> It's not about kexec mechanics, it's about the SDEI dispatch state.
>
> The SDEI stop handler parks inside an SDEI event that it deliberately
> never completes — completing it makes firmware resume the wedged
> context, which is the opposite of what we want. PSCI CPU_OFF from inside
> that not-yet-completed event silently wedges EL3 on at least one
> production firmware (still root-causing on the firmware side), so the
> SDEI path saves the crashed context and parks instead of powering off.
>
> The only consequence is that an SMP capture kernel can't re-online that
> CPU. The dump itself is complete. I've left "power the SDEI-stopped CPU
> off too" as a follow-up and called it out in the cover letter. The IPI
> crash path is unaffected and still does CPU_OFF, exactly as before.
Ah, OK. This makes sense. I read the cover letter, but I guess this
part of it didn't stick in my mind. I wouldn't mind an explanation of
what's going on being included as a comment in the code. Then someone
down the line won't be left wondering.
> > Do you have any reasoning for why you don't pick a separate EVENT ID
> > for "backtrace" vs. "stop". If you absolutely have to share an ID
> > because they're a limited resource then I guess it's fine, but it
> > would make the code easier to understand / reason about if they were
> > separate IDs.
> >
> > If you had a separate EVENT ID, then it seems like you could
> > completely eliminate the (potentially large) `sdei_nmi_stop_mask`
> > variable, right? Any time a "STOP" event fires you can unconditionally
> > consider it to be a stop w/ no globals needed, right?
>
> Separate event IDs aren't available: SDEI_EVENT_SIGNAL only ever signals
> event 0 — it's the one architecturally software-signalled event. Every
> other event number is an interrupt-bound event that firmware has to
> define and bind, which is the firmware dependency this series is
> specifically trying not to add. So backtrace and stop are stuck sharing
> event 0.
Oh well.
> But you're right that the mask should go — just not via a second event. A
> stop is terminal and system-wide (sdei_nmi_stop_cpus() is only reached
> from smp_send_stop(), which never returns), so once a stop is requested
> every later event-0 fire is a stop too. I replaced the cpumask with a
> single write-once flag the handler reads; a backtrace that races in
> after a stop has begun just stops that CPU, which is fine. So the
> (potentially large) variable is gone.
Yeah, this sounds much better, thanks!
^ permalink raw reply
* [PATCH v2] arm64: tlbflush: Reset active_cpu on ASID rollover
From: Sayali Kulkarni @ 2026-06-12 23:21 UTC (permalink / raw)
To: catalin.marinas
Cc: linux-arm-kernel, linux-kernel, will, ryan.roberts, linu.cherian,
yang, cl, sskulkarni
In-Reply-To: <airWIxSd_a5kR65-@arm.com>
From: Sayali Kulkarni <sskulkarni@amperecomputing.com>
Hi Catalin,
Thank you for the review. I’ve addressed your feedback in v2:
- Moved `WRITE_ONCE(mm->context.active_cpu, ACTIVE_CPU_NONE)` from `check_and_switch_context()` to `new_context()` after the `set_asid` label. At this point, a brand new ASID has been allocated that no CPU has ever used, so the reset is safe even for multi-threaded processes where other CPUs may still be running with the old ASID via `reserved_asids`.
- Updated the commit message to correct the safety reasoning: `flush_context()` only sets `tlb_flush_pending`; it does not issue a global TLB flush.
Thanks,
Sayali
Once active_cpu flips to ACTIVE_CPU_MULTIPLE it never resets, even if
the process settles back to one CPU. Reset it to ACTIVE_CPU_NONE in
new_context() after a new ASID is allocated at the set_asid label.
At this point a brand new ASID has been assigned that no CPU has ever
used, so ACTIVE_CPU_NONE accurately reflects reality. Any other threads
of the same process continue running with the old ASID via
reserved_asids and are unaffected.
This gives processes a fresh chance at the local-only flush fast path
after each ASID generation rollover.
Signed-off-by: Sayali Kulkarni <sskulkarni@amperecomputing.com> (Ampere)
---
arch/arm64/mm/context.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/arch/arm64/mm/context.c b/arch/arm64/mm/context.c
index f34ed78393e0..46c7fd07b9bf 100644
--- a/arch/arm64/mm/context.c
+++ b/arch/arm64/mm/context.c
@@ -209,6 +209,7 @@ static u64 new_context(struct mm_struct *mm)
set_asid:
__set_bit(asid, asid_map);
cur_idx = asid;
+ WRITE_ONCE(mm->context.active_cpu, ACTIVE_CPU_NONE);
return asid2ctxid(asid, generation);
}
--
2.47.3
^ permalink raw reply related
* [PATCH v4 00/31] Introduce SCMI Telemetry FS support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
Hi all,
--------------------------------------------------------------------------------
[TLDR Summary]
This series introduces a new SCMI driver which uses a new Telemetry FS to expose
and configure SCMI Telemetry Data Events retrieved from the platform SCMI FW
at runtime. The patches carrying the new STLMFS Filesystem support are tagged
with 'stlmfs'.
--------------------------------------------------------------------------------
the upcoming SCMI v4.0 specification [0] introduces a new SCMI protocol
dedicated to System Telemetry.
In a nutshell, the SCMI Telemetry protocol allows an agent to discover at
runtime the set of Telemetry Data Events (DEs) available on a specific
platform and provides the means to configure the set of DEs that a user is
interested into, while reading them back using the collection method that
is deeemed more suitable for the usecase at hand. (...amongst the various
possible collection methods allowed by SCMI specification)
Without delving into the gory details of the whole SCMI Telemetry protocol
let's just say that the SCMI platform/server firmware advertises a number
of Telemetry Data Events, each one identified by a 32bit unique ID, and an
SCMI agent/client, like Linux, can discover them and read back at will the
associated data value in a number of ways.
Data collection is mainly intended to happen on demand via shared memory
areas exposed by the platform firmware, discovered dynamically via SCMI
Telemetry and accessed by Linux on-demand, but some DE can also be reported
via SCMI Notifications asynchronous messages or via direct dedicated
FastChannels (another kind of SCMI memory based access): all of this
underlying mechanism is anyway hidden to the user since it is mediated by
the kernel driver which will return the proper data value when queried.
Anyway, the set of well-known architected DE IDs defined by the spec is
limited to a dozen IDs, which means that the vast majority of DE IDs are
customizable per-platform: as a consequence, though, the same ID, say
'0x1234', could represent completely different things on different systems.
Precise definitions and semantic of such custom Data Event IDs are out of
the scope of the SCMI Telemetry specification and of this implementation:
they are supposed to be provided using some kind of JSON-like description
file that will have to be consumed by a userspace tool which would be
finally in charge of making sense of the set of available DEs.
IOW, in turn, this means that even though the DEs enumerated via SCMI come
with some sort of topological and qualitative description provided by the
protocol (like unit of measurements, name, topology info etc), kernel-wise
we CANNOT be completely sure of "what is what" without being fed-back some
sort of information about the DEs by the afore mentioned userspace tool.
For these reasons, currently this series does NOT attempt to register any
of these DEs with any of the usual in-kernel subsystems (like HWMON, IIO,
PERF etc), simply because we cannot be sure which DE is suitable, or even
desirable, for a given subsystem. This also means there are NO in-kernel
users of these Telemetry data events as of now.
So, while we do not exclude, for the future, to feed/register some of the
discovered DEs to/with some of the above mentioned Kernel subsystems, as
of now we have ONLY modeled a custom userspace API to make SCMI Telemetry
available to userspace tools.
In deciding which kind of interface to expose SCMI Telemetry data to a
user, this new SCMI Telemetry driver aims at satisfying 2 main reqs:
- exposing an FS-based human-readable interface that can be used to
discover, configure and access our Telemetry data directly also from
the shell without special tools
- exposing alternative machine-friendly, more-performant, binary
interfaces that can be used to avoid the overhead of multiple accesses
to the VFS and that can be more suitable to access with custom tools
In the initial RFC posted a few months ago [1], the above was achieved
with a combination of a SysFS interface, for the human-readable side of
the story, and a classic chardev/ioctl for the plain binary access.
Since V1, instead, we moved away from this combined approach, especially
away from SysFS, for the following reason:
1. "Abusing SysFS": SysFS is a handy way to expose device related
properties in a common way, using a few common helpers built on
kernfs; this means, though, that unfortunately in our scenario I had
to generate a dummy simple device for EACH SCMI Telemetry DataEvent
that I got to discover at runtime and attach to them, all of the
properties I need.
This by itself seemed to me abusing the SysFS framework, but, even
ignoring this, the impact on the system when we have to deal with
hundreds or tens of thousands of DEs is sensible.
In some test scenario I ended with 50k DE devices and half-a-millon
related property files ... O_o
2. "SysFS constraints": SysFS usage itself has its well-known constraints
and best practices, like the one-file/one-value rule, and due to the
fact that any virtual file with a complex structure or handling logic
is frowned upon, you can forget about IOCTLs and mmap'ing to provide
a more performant interface within SysFs, which is the reason why,
in the previous RFC, there was an additional alternative chardev
interface.
These latter limitations around the implementation of files with a
more complex semantic (i.e. with a broader set of file_operations)
derive from the underlying KernFS support, so KernFS is equally not
suitable as a building block for our implementation.
2. "Chardev limitations": Given the nature of the protocol, the hybrid
approach employing character devices was itself problematic: first
of all because there is an upper limit on the number of chardev we
can create, dictated by the range of available minor numbers, and
then because the fact itself to have to maintain 2 completely
different interfaces (FS + chardev) is painful.
As a final remark, please NOTE THAT all of this is supposed to be available
in production systems across a number of heterogeneous platforms: for these
reasons the easy choice, debugFS, is NOT an option here.
Due to the above reasoning, since V1 we opted for a new approach with the
proposed interfaces now based on a full fledged, unified, virtual pseudo
filesystem implemented from scratch, so that we can:
- expose all the DEs property we like as before with SysFS, but without
any of the constraint imposed by the usage of SysFs or kernfs.
- easily expose additional alternative views of the same set of DEs
using symlinking capabilities (e.g. alternative topological view)
- additionally expose a few alternative and more performant interfaces
by embedding in that same FS, a few special virtual files:
+ 'control': to issue IOCTLs for quicker discovery and on-demand access
to data
+ 'pipe' [TBD]: to provide a stream of events using a virtual
infinite-style file
+ 'raw_<N>' [TBD]: to provide direct memory mapped access to the raw
SCMI Telemetry data from userspace
- use a mount option to enable a lazy enumeration operation mode to delay
SCMI related background discovery activities to the effective point in
time when the user needs it (if ever) so as to mitigate the effect at
boot-time of the initial SCMI full discovery process
INTERFACES
===========
We propose a couple of interfaces, both rooted in the same unified
SCMI Telemetry Filesystem STLMFS, which can be mounted with:
mount -t stlmfs none /sys/fs/arm_telemetry/
The new pseudo FS rationale, design and related ABI interface is documented
in detail at:
- Documentation/filesystems/stlmfs.rst
- Documentation/ABI/testing/stlmfs
...anyway, roughly, STLMFS exposes the following interfaces, rooted at
different points in the FS:
1. a FS based human-readable API tree
This API present the discovered DEs and DEs-groups rooted under a
structrure like this:
/sys/fs/arm_telemetry/tlm_0/
|-- all_des_enable
|-- all_des_tstamp_enable
|-- available_update_intervals_ms
|-- current_update_interval_ms
|-- de_implementation_version
|-- des
| |-- 0x00000000/
| |-- 0x00000016/
| |-- 0x00001010/
| |-- 0x0000A000/
| |-- 0x0000A001/
| |-- 0x0000A002/
| |-- 0x0000A005/
| |-- 0x0000A007/
| |-- 0x0000A008/
| |-- 0x0000A00A/
| |-- 0x0000A00B/
| |-- 0x0000A00C/
| `-- 0x0000A010/
|-- des_bulk_read
|-- des_single_sample_read
|-- groups
| |-- 0/
| `-- 1/
|-- intervals_discrete
|-- reset
|-- tlm_enable
`-- version
At the top level we have general configuration knobs to:
- enable/disable all DEs with or without tstamp
- configure the update interval that the platform will use
- enable Telemetry as a whole
- read all the enabled DEs in a buffer one-per-line
<DE_ID> <TIMESTAMP> <DATA_VALUE>
- des_single_sample_read to request an immediate updated read of
all the enabled DEs in a single buffer one-per-line:
<DE_ID> <TIMESTAMP> <DATA_VALUE>
where each DE in turn is represented by a flat subtree like:
tlm_0/des/0x0000A001/
|-- compo_instance_id
|-- compo_type
|-- enable
|-- instance_id
|-- name
|-- persistent
|-- tstamp_enable
|-- tstamp_exp
|-- type
|-- unit
|-- unit_exp
`-- value
where, beside a bunch of description items, you can:
- enable/disable a single DE
- read back its tstamp and data from 'value' as in:
<TIMESTAMP>: <DATA_VALUE>
then for each (optionally) discovered group of DEs:
scmi_tlm_0/groups/0/
|-- available_update_intervals_ms
|-- composing_des
|-- current_update_interval_ms
|-- des_bulk_read
|-- des_single_sample_read
|-- enable
|-- intervals_discrete
`-- tstamp_enable
you can find the knobs to:
- enable/disable the group as a whole
- lookup group composition
- set a per-group update interval (if supported)
- des_bulk_read to read all the enabled DEs for this group in a
single buffer one-per-line:
<DE_ID> <TIMESTAMP> <DATA_VALUE>
- des_single_sample_read to request an immediate updated read of
all the enabled DEs for this group in a single buffer
one-per-line:
<DE_ID> <TIMESTAMP> <DATA_VALUE>
2. Leveraging the capabilities offered by the full-fledged filesystem
implementation and the topological information provided by SCMI
Telemetry we expose also and alternative view of the above tree, by
symlinking a few of the same entries above under another, topologically
sorted, subtree:
by-components/
├── cpu
│ ├── 0
│ │ ├── celsius
│ │ │ └── 0
│ │ │ └── 0x00000001[pe_0] -> ../../../../../des/0x00000001
│ │ └── cycles
│ │ ├── 0
│ │ │ └── 0x00001010[] -> ../../../../../des/0x00001010
│ │ └── 1
│ │ └── 0x00002020[] -> ../../../../../des/0x00002020
│ ├── 1
│ │ └── celsius
│ │ └── 0
│ │ └── 0x00000002[pe_1] -> ../../../../../des/0x00000002
│ └── 2
│ └── celsius
│ └── 0
│ └── 0x00000003[pe_2] -> ../../../../../des/0x00000003
├── interconnnect
│ └── 0
│ └── hertz
│ └── 0
│ ├── 0x0000A008[A008_de] -> ../../../../../des/0x0000A008
│ └── 0x0000A00B[] -> ../../../../../des/0x0000A00B
├── mem_cntrl
│ └── 0
│ ├── bps
│ │ └── 0
│ │ └── 0x0000A00A[] -> ../../../../../des/0x0000A00A
│ ├── celsius
│ │ └── 0
│ │ └── 0x0000A007[DRAM_temp] -> ../../../../../des/0x0000A007
│ └── joules
│ └── 0
│ └── 0x0000A002[DRAM_energy] -> ../../../../../des/0x0000A002
├── periph
│ ├── 0
│ │ └── messages
│ │ └── 0
│ │ └── 0x00000016[device_16] -> ../../../../../des/0x00000016
│ ├── 1
│ │ └── messages
│ │ └── 0
│ │ └── 0x00000017[device_17] -> ../../../../../des/0x00000017
│ └── 2
│ └── messages
│ └── 0
│ └── 0x00000018[device_18] -> ../../../../../des/0x00000018
└── unspec
└── 0
├── celsius
│ └── 0
│ └── 0x0000A005[] -> ../../../../../des/0x0000A005
├── counts
│ └── 0
│ └── 0x0000A00C[] -> ../../../../../des/0x0000A00C
├── joules
│ └── 0
│ ├── 0x0000A000[SOC_Energy] -> ../../../../../des/0x0000A000
│ └── 0x0000A001[] -> ../../../../../des/0x0000A001
└── state
└── 0
└── 0x0000A010[] -> ../../../../../des/0x0000A010
...so as to provide the human user with a more understandable topological
layout of the madness...
All of this is nice and fancy human-readable, easily scriptable, but
certainly not the fastest possible to access especially on huge trees...
... so for the afore-mentioned reasons we alternatively expose
3. a more performant API based on IOCTLs as described fully in:
include/uapi/linux/scmi.h
As described succinctly in the above UAPI header too, this API is meant
to be called on a few special files named 'control' that are populated
into the tree:
.
|-- all_des_enable
.....
|-- components
| |-- cpu
| |-- interconnnect
| |-- mem_cntrl
| |-- periph
| `-- unspec
|-- control
.....................
|-- groups
| |-- 0
| | |-- available_update_intervals_ms
| | |-- composing_des
| | |-- control
.....................
| |-- 1
| | |-- available_update_intervals_ms
| | |-- composing_des
| | |-- control
.....................
| `-- 2
| |-- available_update_intervals_ms
| |-- composing_des
| |-- control
.....................
This allows a tool to:
- use some IOCTLs to configure a set of properties equivalent to the
ones above in FS
- use some other IOCTLs for direct access to data in binary format
for a single DEs or all of them
4. [FUTURE/NOT IN THIS SERIES]
Add another alternative, completely binary, direct raw accessbinterface
via a new set of memory mappable special files so as to allow userspace
tools to access SCMI Telemetry data directly in binary form without any
kernel mediation.
NOTE THAT this series, at the firmware interface level NOW supports ONLY
the latest SCMI v4.0 specification [0].
Missing feats & future steps
----------------------------
- add direct access interface via mmap-able 'raw' files
- add streaming mode interface via 'pipe' file (tentative)
- evolve/enhance app in tools/testing/scmi/stlm to be interactive
KNOWN ISSUES
------------
- STLMFS code layout and location...nothing lives in fs/ and no distinct
FS Kconfig...but the SCMI Telemetry driver itself has no point in existing
without the FS that exposes...so should I split the pure FS part into fs/
anyway or not ?
- residual sparse/smatch static analyzers errors
- stlm tool utility is minimal for testing or development
Based on V7.1-rc7, tested on an emulated setup.
This series is available also at [2].
If you still reading...any feedback welcome :P
Thanks,
Cristian
----
v3 --> v4
- rebased on v7.1-rc7
- updatded doc to detail Concurrency model
- bail out on FW_BUG errors
- make all_des_enable/all_des_tstamp_enable entry readable
- refactored access to TDE values
- refactored common accessors for tlm_priv (FIX WARN on kfree)
- make all files by default world readable and user writable (if needed)
- added uid/god/umask mount options (and docs)
- added generation counter to aid spotting config changes (and docs)
- added DebugFS configurable support to debug/dump SHMTI areas (and docs)
- hide FS entries when NOT supported (like des_simple_sample_read)
- fixed output format of des/<NNN>/value to -> <TS> <VALUE>
- renamed top-dir by_components to by-components
- add a .remove method to SCMI System Telemetry Driver
- use kzalloc_obj
V2 --> V3
- rebased on v7.0-rc5
- ported the firmware interface to SCMI v4.0 BETA
- split the SCMI protocol layer in a lot of small patches
- completd filesystem and ABI documentation
- renamed components subtree to by_components
- fixed uninitialized var in scmi_telemetry_de_subdir_symlink
- renamd tstamp_exp to tstamp_rate
- swap logic in scmi_telemetry_initial_state_lookup
- use memcpy_from_le32 where required
- changed a dfew dev_err into Telemetry traces
- define and use new helper scmi_telemetry_de_unlink
- simplify a few assignments with ternary ops
- added a missing __mmust_check on the internal SCMI API
- reworked and clarified de_data_read returned errno:
ENODATA vs EINVAL vs ENODEV/ENOENT
- removed some risky/unneeded devres allocations
- various checkpatch fixes
- reworked and clarified usage of traces in Telemetry
- added the missing DT binding for protocol 0x1B
- split out unrelated change around notification from patch
adding support for protocol internal notifier
- more comments
V1 --> V2
- rebased on v6.19-rc3
- harden TDCF shared memory areas accesses by using proper accessors
- reworked protocol resources lifecycle to allow lazy enumeration
- using NEW FS mount API
- reworked FS inode allocation to use a std kmem_cache
- fixed a few IOCTLs support routine to support lazy enumeration
- added (RFC) a new FS lazy mount option to support lazily population of
some subtrees of the FS (des/ groups/ components/)
- reworked implementation of components/ alternative FS view to use
symlinks instead of hardlinks
- added a basic simple (RFC) testing tool to exercise UAPI ioctls interface
- hardened Telmetry protocol and driver to support partial out-of-spec FW
lacking some cmds (best effort)
- reworked probing races handling
- reviewed behaviour on unmount/unload
- added support for Boot_ON Telemetry by supporting SCMI Telemetry cmds:
+ DE_ENABLED_LIST
+ CONFIG_GET
- added FS and ABI docs
RFC --> V1
---
- moved from SysFS/chardev to a full fledged FS
- added support for SCMI Telemetry BLK timestamps
Thanks,
Cristian
[0]: https://developer.arm.com/documentation/den0056/f/?lang=en
[1]: https://lore.kernel.org/arm-scmi/20250620192813.2463367-1-cristian.marussi@arm.com/
[2]: https://git.kernel.org/pub/scm/linux/kernel/git/cris/linux.git/log/?h=scmi_telemetry_unified_fs_V4
Cristian Marussi (31):
firmware: arm_scmi: Add new SCMIv4.0 error codes definitions
firmware: arm_scmi: Reduce the scope of protocols mutex
firmware: arm_scmi: Allow registration of unknown-size events/reports
firmware: arm_scmi: Allow protocols to register for notifications
uapi: Add ARM SCMI definitions
dt-bindings: firmware: arm,scmi: Add support for telemetry protocol
include: trace: Add Telemetry trace events
firmware: arm_scmi: Add basic Telemetry support
firmware: arm_scmi: Add support to parse SHMTIs areas
firmware: arm_scmi: Add Telemetry configuration operations
firmware: arm_scmi: Add Telemetry DataEvent read capabilities
firmware: arm_scmi: Add support for Telemetry reset
firmware: arm_scmi: Add Telemetry notification support
firmware: arm_scmi: Add support for boot-on Telemetry
firmware: arm_scmi: Add Telemetry generation counter
firmware: arm_scmi: Add common per-protocol debugfs support
firmware: arm_scmi: Add Telemetry debugfs SHMTI dump support
firmware: arm_scmi: Add Telemetry debugfs ABI documentation
firmware: arm_scmi: stlmfs: Add System Telemetry filesystem driver
fs/stlmfs: Document ARM SCMI Telemetry filesystem
firmware: arm_scmi: stlmfs: Add basic mount options
fs/stlmfs: Document ARM SCMI Telemetry FS mount options
firmware: arm_scmi: stlmfs: Add ioctls support
fs/stlmfs: Document alternative ioctl based binary interface
firmware: arm_scmi: stlmfs: Add by-components view
fs/stlmfs: Document alternative topological view
firmware: arm_scmi: stlmfs: Add generation file
[RFC] docs: stlmfs: Document ARM SCMI Telemetry FS ABI
firmware: arm_scmi: stlmfs: Add lazy population support
fs/stlmfs: Document lazy mode and related mount option
[RFC] tools/scmi: Add SCMI Telemetry testing tool
Documentation/ABI/testing/debugfs-scmi | 22 +
Documentation/ABI/testing/stlmfs | 348 ++
.../bindings/firmware/arm,scmi.yaml | 8 +
Documentation/filesystems/stlmfs.rst | 342 ++
MAINTAINERS | 1 +
drivers/firmware/arm_scmi/Kconfig | 24 +
drivers/firmware/arm_scmi/Makefile | 3 +-
drivers/firmware/arm_scmi/common.h | 10 +
drivers/firmware/arm_scmi/driver.c | 93 +-
drivers/firmware/arm_scmi/notify.c | 30 +-
drivers/firmware/arm_scmi/notify.h | 8 +-
drivers/firmware/arm_scmi/protocols.h | 13 +
.../firmware/arm_scmi/scmi_system_telemetry.c | 3146 ++++++++++++++++
drivers/firmware/arm_scmi/telemetry.c | 3300 +++++++++++++++++
include/linux/scmi_protocol.h | 203 +-
include/trace/events/scmi.h | 48 +-
include/uapi/linux/scmi.h | 289 ++
tools/testing/scmi/Makefile | 25 +
tools/testing/scmi/stlm.c | 434 +++
19 files changed, 8307 insertions(+), 40 deletions(-)
create mode 100644 Documentation/ABI/testing/stlmfs
create mode 100644 Documentation/filesystems/stlmfs.rst
create mode 100644 drivers/firmware/arm_scmi/scmi_system_telemetry.c
create mode 100644 drivers/firmware/arm_scmi/telemetry.c
create mode 100644 include/uapi/linux/scmi.h
create mode 100644 tools/testing/scmi/Makefile
create mode 100644 tools/testing/scmi/stlm.c
--
2.54.0
^ permalink raw reply
* Re: [PATCH v14 10/44] arm64: RMI: Add support for SRO
From: Dan Williams (nvidia) @ 2026-06-12 23:07 UTC (permalink / raw)
To: Steven Price, Gavin Shan, kvm, kvmarm
Cc: Catalin Marinas, Marc Zyngier, Will Deacon, James Morse,
Oliver Upton, Suzuki K Poulose, Zenghui Yu, linux-arm-kernel,
linux-kernel, Joey Gouly, Alexandru Elisei, Christoffer Dall,
Fuad Tabba, linux-coco, Ganapatrao Kulkarni, Shanker Donthineni,
Alper Gun, Aneesh Kumar K . V, Emi Kisanuki, Vishal Annapurve,
WeiLin.Chang, Lorenzo.Pieralisi2
In-Reply-To: <50d70588-2ebc-4c9b-98ec-68f3d04a9d21@arm.com>
Steven Price wrote:
[..]
> > alloc_pages_exact() will fail if the requested size exceeds the maximal
> > allowed
> > size (1 << MAX_PAGE_ORDER). The maximal size is usually smaller than
> > PUD_SIZE
> > but PUD_SIZE is allowed by the RMM.
>
> This is an area where to be honest I'm really not sure what to do.
> Technically the RMM is allowed to ask for a contiguous range of 512GB
> pages (on a 4K system - larger with larger page sizes) - but clearly no
> real OS is going to be able to provide anything like that.
>
> In practise we don't expect the RMM to do anything so crazy. It's not
> really clear to be whether even 2MB (PMD_SIZE) is needed. But the spec
> is written to be generic.
>
> So my current approach is to calculate the required size and pass it
> into alloc_pages_exact(). For "stupidly large" values this will fail and
> Linux just doesn't support an RMM which attempts this. If there is ever
> a usecase which needs this then we'd need to find a different method of
> providing the memory (most likely some form of carveout to avoid
> fragmentation). But my view is we should wait for that usecase to be
> identified first.
Just some comparison comments as I am also going through the TDX patches
which enable "Extension SEAMCALLs". These new SEAMCALLs are similar to
the SRO mechanism [1].
TDX asks for an upfront delegation of memory at init time using
alloc_contig_pages() that is never returned until entire module is
shutdown. alloc_contig_pages() is not subject to the MAX_ORDER limit,
but not sure that alloc_contig_pages() is suitable for small+dynamic
runtime memory add / release that SRO potentially wants to do?
Does SRO always balance the size of RMI_OP_MEM_REQ_DONATE with
RMI_OP_MEM_REQ_RECLAIM, or might some donate requests be a one way
donation like TDX? Just poking to see if there is a path to preallocate
a pool vs the fine grained per-operation alloc/free.
[1]: http://lore.kernel.org/20260522034128.3144354-3-yilun.xu@linux.intel.com
^ permalink raw reply
* [GIT PULL] Qualcomm clock updates for v7.2
From: Bjorn Andersson @ 2026-06-12 22:48 UTC (permalink / raw)
To: Stephen Boyd, linux-clk
Cc: linux-arm-msm, linux-arm-kernel, Vivek Aknurwar, Luca Weiss,
Jagadeesh Kona, Krzysztof Kozlowski, Luo Jie, Bartosz Golaszewski,
Kathiravan Thirumoorthy, Alexander Koskovich, Biswapriyo Nath,
Konrad Dybcio, Phillip Varney
The following changes since commit 254f49634ee16a731174d2ae34bc50bd5f45e731:
Linux 7.1-rc1 (2026-04-26 14:19:00 -0700)
are available in the Git repository at:
https://git.kernel.org/pub/scm/linux/kernel/git/qcom/linux.git tags/qcom-clk-for-7.2
for you to fetch changes up to e108373c54fbc844b7f541c6fd7ecb31772afd3c:
clk: qcom: regmap-phy-mux: Rework the implementation (2026-06-08 09:17:24 -0500)
----------------------------------------------------------------
Qualcomm clock updates for v7.2
Introduce global, TCSR, and RPMh clock controllers for the Hawi mobile
SoC.
Introduce GX clock for Milos, and ensure that camera clock controller
votes for interconnect bandwidth in order to ensure the TOP_GDSC can be
turned on.
Introduce camera and video clock controllers for Hamoa and Purwa. Reduce
the max_register of the display clock controller to avoid regmap
attemting to dump protected registers.
Introduce global clock controller for the IPQ9650 SoC and add IPQ5332
support to the cmnpll driver.
Add missing USB2 PHY reset to the Nord NegCC.
Rework the PHY mux clock implementation as necessary for upcoming USB4
support.
----------------------------------------------------------------
Alexander Koskovich (1):
clk: qcom: clk-rpmh: Make all VRMs optional
Bartosz Golaszewski (2):
dt-bindings: clock: qcom: add the definition for the USB2 PHY reset
clk: qcom: nord: negcc: add support for the USB2 PHY reset
Biswapriyo Nath (1):
dt-bindings: clock: qcom,sm6125-dispcc: reference qcom,gcc.yaml
Bjorn Andersson (2):
Merge branch '20260507-ipq9650_boot_to_shell-v3-1-62742b49c991@oss.qualcomm.com' into clk-for-7.2
Merge branch '20260106-qcom_ipq5332_cmnpll-v2-2-f9f7e4efbd79@oss.qualcomm.com' into clk-for-7.2
Jagadeesh Kona (5):
dt-bindings: clock: qcom: Add X1P42100 video clock controller
dt-bindings: clock: qcom: Add X1P42100 camera clock controller
clk: qcom: videocc-x1p42100: Add support for video clock controller
clk: qcom: camcc-x1e80100: Add support for camera QDSS debug clocks
clk: qcom: camcc-x1p42100: Add support for camera clock controller
Kathiravan Thirumoorthy (2):
dt-bindings: clock: add Qualcomm IPQ9650 GCC
clk: qcom: add Global Clock controller (GCC) driver for IPQ9650 SoC
Konrad Dybcio (1):
clk: qcom: regmap-phy-mux: Rework the implementation
Krzysztof Kozlowski (3):
clk: qcom: dispcc-x1e80100: Fix (possibly) dumping regmap
clk: qcom: Constify qcom_cc_driver_data and list of critical CBCR registers
dt-bindings: clock: qcom,kaanapali-gxclkctl: Correctly use additionalProperties
Luca Weiss (6):
dt-bindings: clock: qcom: document the Milos GX clock controller
clk: qcom: Add support for GXCLK for Milos
interconnect: Add devm_of_icc_get_by_index() as exported API for users
dt-bindings: clock: qcom,milos-camcc: Document interconnect path
clk: qcom: gdsc: Support enabling interconnect path for power domain
clk: qcom: camcc-milos: Declare icc path dependency for CAMSS_TOP_GDSC
Luo Jie (3):
dt-bindings: clock: qcom: Add CMN PLL support for IPQ5332 SoC
clk: qcom: cmnpll: Account for reference clock divider
clk: qcom: cmnpll: Add IPQ5332 SoC support
Phillip Varney (1):
clk: qcom: a53: Corrected frequency multiplier for 1152MHz
Vivek Aknurwar (7):
dt-bindings: clock: qcom-rpmhcc: Add RPMHCC bindings for Hawi
dt-bindings: clock: qcom: Add Hawi TCSR clock controller
dt-bindings: clock: qcom: Add Hawi global clock controller
clk: qcom: rpmh: Add support for Hawi RPMH clocks
clk: qcom: Add Hawi TCSR clock controller driver
clk: qcom: clk-alpha-pll: Add support for Taycan EHA_T PLL
clk: qcom: Add support for global clock controller on Hawi
.../bindings/clock/qcom,dispcc-sm6125.yaml | 17 +-
.../devicetree/bindings/clock/qcom,hawi-gcc.yaml | 63 +
.../bindings/clock/qcom,ipq9574-cmn-pll.yaml | 1 +
.../bindings/clock/qcom,ipq9650-gcc.yaml | 68 +
.../bindings/clock/qcom,kaanapali-gxclkctl.yaml | 2 +-
.../bindings/clock/qcom,milos-camcc.yaml | 8 +
.../bindings/clock/qcom,milos-gxclkctl.yaml | 61 +
.../devicetree/bindings/clock/qcom,rpmhcc.yaml | 1 +
.../bindings/clock/qcom,sm8450-videocc.yaml | 3 +
.../bindings/clock/qcom,sm8550-tcsr.yaml | 2 +
.../bindings/clock/qcom,x1e80100-camcc.yaml | 1 +
drivers/clk/qcom/Kconfig | 48 +
drivers/clk/qcom/Makefile | 7 +-
drivers/clk/qcom/a53-pll.c | 2 +-
drivers/clk/qcom/camcc-milos.c | 7 +
drivers/clk/qcom/camcc-x1e80100.c | 64 +
drivers/clk/qcom/camcc-x1p42100.c | 2223 ++++++++++++
drivers/clk/qcom/clk-alpha-pll.h | 6 +
drivers/clk/qcom/clk-regmap-phy-mux.c | 52 +-
drivers/clk/qcom/clk-rpmh.c | 41 +-
drivers/clk/qcom/dispcc-x1e80100.c | 2 +-
drivers/clk/qcom/gcc-hawi.c | 3657 ++++++++++++++++++++
drivers/clk/qcom/gcc-ipq9650.c | 3445 ++++++++++++++++++
drivers/clk/qcom/gcc-nord.c | 2 +-
drivers/clk/qcom/gdsc.c | 33 +
drivers/clk/qcom/gdsc.h | 5 +
drivers/clk/qcom/gpucc-sm8750.c | 4 +-
drivers/clk/qcom/gxclkctl-kaanapali.c | 1 +
drivers/clk/qcom/ipq-cmn-pll.c | 30 +-
drivers/clk/qcom/negcc-nord.c | 3 +-
drivers/clk/qcom/nwgcc-nord.c | 4 +-
drivers/clk/qcom/segcc-nord.c | 2 +-
drivers/clk/qcom/tcsrcc-hawi.c | 158 +
drivers/clk/qcom/videocc-x1p42100.c | 585 ++++
drivers/interconnect/core.c | 20 +
include/dt-bindings/clock/qcom,hawi-gcc.h | 253 ++
include/dt-bindings/clock/qcom,hawi-tcsrcc.h | 16 +
include/dt-bindings/clock/qcom,ipq5332-cmn-pll.h | 19 +
include/dt-bindings/clock/qcom,ipq9650-gcc.h | 172 +
include/dt-bindings/clock/qcom,nord-negcc.h | 1 +
include/dt-bindings/clock/qcom,rpmh.h | 2 +
include/dt-bindings/clock/qcom,x1e80100-camcc.h | 3 +
include/dt-bindings/clock/qcom,x1p42100-videocc.h | 48 +
include/dt-bindings/reset/qcom,ipq9650-gcc.h | 215 ++
include/linux/interconnect.h | 6 +
45 files changed, 11313 insertions(+), 50 deletions(-)
create mode 100644 Documentation/devicetree/bindings/clock/qcom,hawi-gcc.yaml
create mode 100644 Documentation/devicetree/bindings/clock/qcom,ipq9650-gcc.yaml
create mode 100644 Documentation/devicetree/bindings/clock/qcom,milos-gxclkctl.yaml
create mode 100644 drivers/clk/qcom/camcc-x1p42100.c
create mode 100644 drivers/clk/qcom/gcc-hawi.c
create mode 100644 drivers/clk/qcom/gcc-ipq9650.c
create mode 100644 drivers/clk/qcom/tcsrcc-hawi.c
create mode 100644 drivers/clk/qcom/videocc-x1p42100.c
create mode 100644 include/dt-bindings/clock/qcom,hawi-gcc.h
create mode 100644 include/dt-bindings/clock/qcom,hawi-tcsrcc.h
create mode 100644 include/dt-bindings/clock/qcom,ipq5332-cmn-pll.h
create mode 100644 include/dt-bindings/clock/qcom,ipq9650-gcc.h
create mode 100644 include/dt-bindings/clock/qcom,x1p42100-videocc.h
create mode 100644 include/dt-bindings/reset/qcom,ipq9650-gcc.h
^ permalink raw reply
* [PATCH v4 31/31] [RFC] tools/scmi: Add SCMI Telemetry testing tool
From: Cristian Marussi @ 2026-06-12 22:38 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a testing tool that exercises the SCMI ioctls UAPI interface: as of
now the tool simply queries the initial state of the SCMI Telemetry
subsystem, tries to enable all the existent Data Events and dumps all
the Telemetry data.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- added generation file support
Basic implementation just to exercise a few IOCTls: to be refined and
extended to support a more interactive usage.
---
tools/testing/scmi/Makefile | 25 +++
tools/testing/scmi/stlm.c | 434 ++++++++++++++++++++++++++++++++++++
2 files changed, 459 insertions(+)
create mode 100644 tools/testing/scmi/Makefile
create mode 100644 tools/testing/scmi/stlm.c
diff --git a/tools/testing/scmi/Makefile b/tools/testing/scmi/Makefile
new file mode 100644
index 000000000000..a6a101f8398b
--- /dev/null
+++ b/tools/testing/scmi/Makefile
@@ -0,0 +1,25 @@
+# SPDX-License-Identifier: GPL-2.0-or-later
+
+CC?=$(CROSS_COMPILE)gcc
+OBJS = stlm.o
+
+CFLAGS=-Wall -static -std=gnu11 -I ../../../include/uapi/
+ifneq ($(DEBUG), )
+ CFLAGS+=-O0 -g -ggdb
+else
+ CFLAGS+=-static
+endif
+
+all: stlm
+
+stlm: $(OBJS)
+ $(CC) $(CFLAGS) $^ -o $@
+
+%.o: %.c
+ $(CC) $(CFLAGS) -c $<
+
+clean:
+ rm -f *.o
+ rm -f stlm
+
+.PHONY: clean
diff --git a/tools/testing/scmi/stlm.c b/tools/testing/scmi/stlm.c
new file mode 100644
index 000000000000..f153b6e6a4cd
--- /dev/null
+++ b/tools/testing/scmi/stlm.c
@@ -0,0 +1,434 @@
+// SPDX-License-Identifier: GPL-2.0-only
+
+#include <errno.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+
+#include <unistd.h>
+
+#include <linux/scmi.h>
+
+#define SLEEP_MS 3000
+#define DEF_TLM_ROOT "/sys/fs/arm_telemetry/"
+
+#define IOCTL_ERR_STR(_ioctl) "IOCTL:" #_ioctl
+
+struct tlm_de {
+ struct scmi_tlm_de_info *info;
+ struct scmi_tlm_de_config cfg;
+ struct scmi_tlm_de_sample sample;
+};
+
+struct tlm_group {
+ int fd;
+ struct scmi_tlm_grp_info *info;
+ struct scmi_tlm_grp_desc *desc;
+ struct scmi_tlm_intervals *ivs;
+};
+
+struct tlm_state {
+ int dfd;
+ int fd;
+ int g_dfd;
+ const char *path;
+ struct scmi_tlm_base_info info;
+ struct scmi_tlm_config cfg;
+ struct scmi_tlm_intervals *ivs;
+ unsigned int num_des;
+ struct tlm_de *des;
+ unsigned int num_groups;
+ struct tlm_group *grps;
+};
+
+static inline void dump_state(struct tlm_state *st)
+{
+ uint32_t *uuid32 = st->info.de_impl_version;
+ uint16_t *uuid16 = (uint16_t *)&st->info.de_impl_version[1];
+
+ fprintf(stdout, "- SYSTEM TELEMETRY @instance: %s\n\n", st->path);
+ fprintf(stdout, "+ Version: 0x%08X\n", st->info.version);
+ fprintf(stdout, "+ DEs#: %d\n", st->info.num_des);
+ fprintf(stdout, "+ GRPS#: %d\n", st->info.num_groups);
+ fprintf(stdout, "+ INTRV#: %d\n", st->info.num_intervals);
+
+ fprintf(stdout, "+ UUID: ");
+ fprintf(stdout, "%X-", uuid32[0]);
+ fprintf(stdout, "%X-", uuid16[0]);
+ fprintf(stdout, "%X-", uuid16[1]);
+ fprintf(stdout, "%X", uuid16[2]);
+ fprintf(stdout, "%X\n", uuid32[3]);
+
+ fprintf(stdout, "\n+ TLM_ENABLED: %d\n", st->cfg.enable);
+ fprintf(stdout, "+ CURRENT_UPDATE_INTERVAL: %d\n",
+ st->cfg.current_update_interval);
+
+ fprintf(stdout, "+ Found #%u Global Update Intervals\n",
+ st->info.num_intervals);
+ for (int i = 0; i < st->ivs->num_intervals; i++)
+ fprintf(stdout, "\t[%d]::%u\n", i, st->ivs->update_intervals[i]);
+
+ if (st->info.num_des != st->num_des) {
+ fprintf(stdout, "\n++++++ DES NOT FULLY_ENUMERATED ++++++\n");
+ fprintf(stdout, "+++ DECLARED:%u ENUMERATED:%u +++\n",
+ st->info.num_des, st->num_des);
+ }
+
+ fprintf(stdout, "\n+ Found #%d DEs:\n", st->num_des);
+ for (int i = 0; i < st->num_des; i++)
+ fprintf(stdout, "\t0x%08X %s %s -- TS:%16llu %016llX\n",
+ st->des[i].info->id,
+ st->des[i].cfg.enable ? "ON" : "--",
+ st->des[i].cfg.t_enable ? "TS_ON" : "-----",
+ st->des[i].sample.tstamp, st->des[i].sample.val);
+ fprintf(stdout, "\n");
+
+ fprintf(stdout, "+ Found %d GRPs: ", st->num_groups);
+ for (int i = 0; i < st->num_groups; i++) {
+ fprintf(stdout, "\n\tGRP_ID:%d DES#:%d INTRVS#:%d\n",
+ st->grps[i].info->id, st->grps[i].info->num_des,
+ st->grps[i].info->num_intervals);
+
+ fprintf(stdout, "\tCOMPOSING_DES:");
+ for (int j = 0; j < st->grps[i].desc->num_des; j++)
+ fprintf(stdout, "0x%08X ",
+ st->grps[i].desc->composing_des[j]);
+ fprintf(stdout, "\n");
+ }
+}
+
+static int discover_base_info(int fd, struct scmi_tlm_base_info *info)
+{
+ int ret;
+
+ ret = ioctl(fd, SCMI_TLM_GET_INFO, info);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_INFO));
+ return ret;
+ }
+
+ return ret;
+}
+
+static struct scmi_tlm_des_list *scmi_get_des_list(int fd, int num_des)
+{
+ struct scmi_tlm_des_list *dsl;
+ size_t size = sizeof(*dsl) + num_des * sizeof(dsl->des[0]);
+ int ret;
+
+ dsl = malloc(size);
+ if (!dsl)
+ return NULL;
+
+ bzero(dsl, size);
+ dsl->num_des = num_des;
+ ret = ioctl(fd, SCMI_TLM_GET_DE_LIST, dsl);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_DE_LIST));
+ return NULL;
+ }
+
+ return dsl;
+}
+
+static struct tlm_de *enumerate_des(struct tlm_state *st)
+{
+ struct scmi_tlm_des_list *dsl;
+ struct tlm_de *des;
+
+ dsl = scmi_get_des_list(st->fd, st->info.num_des);
+ if (!dsl)
+ return NULL;
+
+ st->num_des = dsl->num_des;
+ des = malloc(sizeof(*des) * st->num_des);
+ if (!des)
+ return NULL;
+
+ bzero(des, sizeof(*des) * st->num_des);
+ for (int i = 0; i < st->num_des; i++) {
+ struct tlm_de *de = &des[i];
+ int ret;
+
+ de->info = &dsl->des[i];
+ de->cfg.id = de->info->id;
+ ret = ioctl(st->fd, SCMI_TLM_GET_DE_CFG, &de->cfg);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_DE_CFG));
+ continue;
+ }
+
+ if (!de->cfg.enable)
+ continue;
+
+ /* Collect initial sample */
+ de->sample.id = de->info->id;
+ ret = ioctl(st->fd, SCMI_TLM_GET_DE_VALUE, &de->sample);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_DE_VALUE));
+ continue;
+ }
+ }
+
+ return des;
+}
+
+static int get_current_config(int fd, struct scmi_tlm_config *cfg)
+{
+ int ret;
+
+ ret = ioctl(fd, SCMI_TLM_GET_CFG, cfg);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_CFG));
+ return ret;
+ }
+
+ return ret;
+}
+
+static struct scmi_tlm_grps_list *scmi_get_grps_list(int fd, int num_groups)
+{
+ struct scmi_tlm_grps_list *gsl;
+ size_t size = sizeof(*gsl) + num_groups * sizeof(gsl->grps[0]);
+ int ret;
+
+ gsl = malloc(size);
+ if (!gsl)
+ return NULL;
+
+ bzero(gsl, size);
+ gsl->num_grps = num_groups;
+ ret = ioctl(fd, SCMI_TLM_GET_GRP_LIST, gsl);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_GRP_LIST));
+ return NULL;
+ }
+
+ return gsl;
+}
+
+static struct scmi_tlm_intervals *enumerate_intervals(int fd, int num_intervals)
+{
+ struct scmi_tlm_intervals *ivs;
+ size_t sz;
+ int ret;
+
+ sz = sizeof(*ivs) + sizeof(*ivs->update_intervals) * num_intervals;
+ ivs = malloc(sz);
+ if (!ivs)
+ return NULL;
+
+ memset(ivs, 0, sz);
+
+ ivs->num_intervals = num_intervals;
+ ret = ioctl(fd, SCMI_TLM_GET_INTRVS, ivs);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_INTRVS));
+ free(ivs);
+ return NULL;
+ }
+
+ return ivs;
+}
+
+static struct tlm_group *enumerate_groups(struct tlm_state *st)
+{
+ struct scmi_tlm_grps_list *gsl;
+ struct tlm_group *grps;
+
+ gsl = scmi_get_grps_list(st->fd, st->info.num_groups);
+ if (!gsl)
+ return NULL;
+
+ st->g_dfd = openat(st->dfd, "groups", O_RDONLY);
+ if (st->g_dfd < 0)
+ return NULL;
+
+ st->num_groups = gsl->num_grps;
+ grps = malloc(sizeof(*grps) * st->num_groups);
+ if (!grps)
+ return NULL;
+
+ bzero(grps, sizeof(*grps) * st->num_groups);
+ for (int i = 0; i < st->num_groups; i++) {
+ struct tlm_group *grp = &grps[i];
+ char gctrl[32];
+ size_t size;
+ int ret;
+
+ snprintf(gctrl, 32, "%d/control", i);
+ grp->fd = openat(st->g_dfd, gctrl, O_RDWR);
+ if (grp->fd < 0)
+ return NULL;
+
+ grp->info = &gsl->grps[i];
+ size = sizeof(*grp->desc) + sizeof(uint32_t) * grp->info->num_des;
+ grp->desc = malloc(size);
+ if (!grp->desc)
+ return NULL;
+
+ bzero(grp->desc, size);
+ grp->desc->num_des = grp->info->num_des;
+ ret = ioctl(grp->fd, SCMI_TLM_GET_GRP_DESC, grp->desc);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_GET_GRP_DESC));
+ continue;
+ }
+
+ grp->ivs = enumerate_intervals(grp->fd, grp->info->num_intervals);
+ }
+
+ return grps;
+}
+
+static int get_tlm_state(const char *path, struct tlm_state *st)
+{
+ int ret;
+
+ st->dfd = open(path, O_RDONLY);
+ if (st->dfd < 0) {
+ perror("open");
+ return st->dfd;
+ }
+
+ st->fd = openat(st->dfd, "control", O_RDWR);
+ if (st->fd < 0) {
+ perror("openat");
+ return st->fd;
+ }
+
+ ret = discover_base_info(st->fd, &st->info);
+ if (ret)
+ return ret;
+
+ st->ivs = enumerate_intervals(st->fd, st->info.num_intervals);
+ if (!st->ivs)
+ return -1;
+
+ ret = get_current_config(st->fd, &st->cfg);
+ if (ret)
+ return ret;
+
+ if (st->info.num_des)
+ st->des = enumerate_des(st);
+
+ if (st->info.num_groups)
+ st->grps = enumerate_groups(st);
+
+ st->path = path;
+
+ return 0;
+}
+
+#define MAX_GENERATIONS 5
+
+static void get_tlm_generation(struct tlm_state *st)
+{
+ int fd, i = 0;
+ struct pollfd pfds[1];
+
+ fd = openat(st->dfd, "generation", O_RDONLY);
+ if (fd < 0) {
+ perror("openat");
+ return ;
+ }
+
+ pfds[0].fd = fd;
+ pfds[0].events = POLLIN;
+
+ do {
+ int ret;
+
+ pfds[0].revents = 0;
+ ret = poll(pfds, 1, -1);
+ if (ret < 0 ) {
+ perror("poll generation");
+ break;;
+ }
+
+ if (!pfds[0].revents)
+ continue;
+
+ if (pfds[0].revents & POLLIN) {
+ int n;
+ char buf[32] = {};
+
+ n = read(fd, buf, 32);
+ if (n < 0) {
+ perror("read generation");
+ break;
+ }
+
+ fprintf(stdout, "Generation[%u]: %s\n", i, buf);
+ }
+ } while (i++ < MAX_GENERATIONS);
+
+ close(fd);
+}
+
+int main(int argc, char **argv)
+{
+ const char *tlm_root_instance = DEF_TLM_ROOT "tlm_0/";
+ struct scmi_tlm_data_read *bulk;
+ struct scmi_tlm_de_config de_cfg = {};
+ struct tlm_state st = {};
+ size_t bulk_sz;
+ int ret;
+
+ ret = get_tlm_state(tlm_root_instance, &st);
+ if (ret)
+ return ret;
+
+ dump_state(&st);
+
+ get_tlm_generation(&st);
+
+ bulk_sz = sizeof(*bulk) + sizeof(bulk->samples[0]) * st.info.num_des;
+ bulk = malloc(bulk_sz);
+ if (!bulk)
+ return -1;
+
+ bzero(bulk, bulk_sz);
+ bulk->num_samples = st.info.num_des;
+ ret = ioctl(st.fd, SCMI_TLM_SINGLE_SAMPLE, bulk);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_SINGLE_SAMPLE));
+ return -1;
+ }
+
+ fprintf(stdout, "\n--- Enabling ALL DEs with timestamp...\n");
+ de_cfg.enable = 1;
+ de_cfg.t_enable = 1;
+ ret = ioctl(st.fd, SCMI_TLM_SET_ALL_CFG, &de_cfg);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_SET_ALL_CFG));
+ return ret;
+ }
+
+ fprintf(stdout, "\n- Single ASYNC read -\n-------------------\n");
+ for (int i = 0; i < bulk->num_samples; i++)
+ fprintf(stdout, "0x%08X %016llu %016llX\n",
+ bulk->samples[i].id, bulk->samples[i].tstamp,
+ bulk->samples[i].val);
+
+ bzero(bulk, bulk_sz);
+ bulk->num_samples = st.info.num_des;
+ ret = ioctl(st.fd, SCMI_TLM_BULK_READ, bulk);
+ if (ret) {
+ perror(IOCTL_ERR_STR(SCMI_TLM_BULK_READ));
+ return -1;
+ }
+
+ fprintf(stdout, "\n- BULK read -\n-------------------\n");
+ for (int i = 0; i < bulk->num_samples; i++)
+ fprintf(stdout, "0x%08X %016llu %016llX\n",
+ bulk->samples[i].id, bulk->samples[i].tstamp,
+ bulk->samples[i].val);
+
+ return 0;
+}
--
2.54.0
^ permalink raw reply related
* [PATCH v4 30/31] fs/stlmfs: Document lazy mode and related mount option
From: Cristian Marussi @ 2026-06-12 22:38 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi, Jonathan Corbet, Shuah Khan
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Document optional lazy enumeration behaviour and related mount option.
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Cc: linux-doc@vger.kernel.org
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
Documentation/filesystems/stlmfs.rst | 21 +++++++++++++++++++--
1 file changed, 19 insertions(+), 2 deletions(-)
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
index b5b3cd649775..fe69d40f9249 100644
--- a/Documentation/filesystems/stlmfs.rst
+++ b/Documentation/filesystems/stlmfs.rst
@@ -74,8 +74,12 @@ Design
STLMFS is a pseudo filesystem used to expose ARM SCMI Telemetry data
discovered dynamically at run-time via SCMI.
-Inodes are all dynamically created at mount-time from a dedicated
-kmem_cache based on the gathered available SCMI Telemetry information.
+Normally all of the top level file/inodes are dynamically created at
+mount-time from a dedicated kmem_cache based on the gathered available
+SCMI Telemetry information, but it is possible to enable a lazy enumeration
+and FS population mode that delays SCMI Telemetry resources enumerations
+and related FS population till the moment a user steps into the related FS
+subdirectories: *des/* *groups/* and *components/*.
Since inodes represent the discovered Telemetry entities, which in turn are
statically defined at the platform level and immutable throughout the same
@@ -128,6 +132,19 @@ Note that all of the above options are explicitly designed NOT to support
a remount operation, so as not have surprising effects on permissions of
already discovered/created telemetry files.
+It is possible to mount it in lazy-mode by using the *lazy* mount option::
+
+ mount -t stlmfs -o lazy none /sys/fs/arm_telemetry
+
+In this latter case, the des/ groups/ and components/ directory will be
+created empty at mount-time and only filled later when 'walked in'.
+
+This allows a user to benefit from a lazy enumeration scheme of the SCMI
+Telemetry resources by delaying such, usually expensive, message exchanges
+to the last possible moment: ideally, even never, if using some of the
+other alternative binary interfaces that does not need any resource
+enumeration at all.
+
Usage
=====
--
2.54.0
^ permalink raw reply related
* [PATCH v4 29/31] firmware: arm_scmi: stlmfs: Add lazy population support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a filesystem mount option to the SCMI Telemetry filesystem so as to
delay resources enumeration and related fs subtrees population to the
last possible moment when the related fs paths are accessed.
Only basic global fs entries are populated at mount time when the lazy
mount option is used.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- add lazy support to show_options
- make FS entries world-Readable and user-Writable where applicable
- added stlmfs tag in $SUBJECT
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 521 +++++++++++++++---
1 file changed, 430 insertions(+), 91 deletions(-)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index df45fc212e13..9cb8779d2b59 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -42,12 +42,14 @@ enum {
Opt_uid,
Opt_gid,
Opt_umask,
+ Opt_lazy,
};
static const struct fs_parameter_spec stlmfs_param_spec[] = {
fsparam_uid("uid", Opt_uid),
fsparam_gid("gid", Opt_gid),
fsparam_u32oct("umask", Opt_umask),
+ fsparam_flag_no("lazy", Opt_lazy),
{}
};
@@ -56,18 +58,29 @@ struct stlmfs_fs_context {
kuid_t uid;
kgid_t gid;
umode_t umask;
+ bool lazy;
+};
+
+struct stlmfs_lazy_tracker {
+ bool des;
+ bool grps;
+ bool topo;
};
struct stlmfs_sb_info {
kuid_t uid;
kgid_t gid;
umode_t umask;
+ bool lazy;
+ unsigned int num_inst;
+ struct stlmfs_lazy_tracker populated[] __counted_by(num_inst);
};
static struct kmem_cache *stlmfs_inode_cachep;
static DEFINE_MUTEX(stlmfs_mtx);
static struct super_block *stlmfs_sb;
+static unsigned int stlmfs_instances;
static atomic_t scmi_tlm_instance_count = ATOMIC_INIT(0);
@@ -134,9 +147,11 @@ struct scmi_tlm_class {
#define TLM_IS_STATE BIT(0)
#define TLM_IS_GROUP BIT(1)
#define TLM_IS_DYNAMIC BIT(2)
+#define TLM_IS_LAZY BIT(3)
#define IS_STATE(_f) ((_f) & TLM_IS_STATE)
#define IS_GROUP(_f) ((_f) & TLM_IS_GROUP)
#define IS_DYNAMIC(_f) ((_f) & TLM_IS_DYNAMIC)
+#define IS_LAZY(_f) ((_f) & TLM_IS_LAZY)
const struct file_operations *f_op;
const struct inode_operations *i_op;
};
@@ -166,6 +181,10 @@ struct scmi_tlm_class {
* @info: SCMI instance information data reference.
* @vfs_inode: The embedded VFS inode that will be initialized and plugged
* into the live filesystem at mount time.
+ * @node: List item field.
+ * @children: A list containing all the children of this node.
+ * @num_children: Number of items stored in the @children list.
+ * @mtx: A mutex to protect the @children list.
*
* This structure is used to describe each SCMI Telemetry entity discovered
* at probe time, store its related SCMI data, and link to the proper
@@ -181,6 +200,11 @@ struct scmi_tlm_inode {
const struct scmi_telemetry_info *info;
};
struct inode vfs_inode;
+ struct list_head node;
+ struct list_head children;
+ unsigned int num_children;
+ /* Mutext to protect @children list */
+ struct mutex mtx;
};
#define to_tlm_inode(t) container_of(t, struct scmi_tlm_inode, vfs_inode)
@@ -195,8 +219,6 @@ struct scmi_tlm_inode {
* struct scmi_tlm_instance - Telemetry instance descriptor
* @id: Progressive number identifying this probed instance; it will be used
* to name the top node at the root of this instance.
- * @res_enumerated: A flag to indicate if full resources enumeration has been
- * successfully performed.
* @name: Name to be used for the top root node of the instance. (tlm_<id>)
* @node: A node to link this in the list of all instances.
* @sb: A reference to the current super_block.
@@ -211,7 +233,6 @@ struct scmi_tlm_inode {
*/
struct scmi_tlm_instance {
int id;
- bool res_enumerated;
char name[MAX_INST_NAME];
struct list_head node;
struct super_block *sb;
@@ -224,6 +245,8 @@ struct scmi_tlm_instance {
const struct scmi_telemetry_info *info;
};
+static int scmi_telemetry_groups_initialize(const struct scmi_tlm_instance *ti);
+static int scmi_telemetry_topology_view_initialize(const struct scmi_tlm_instance *ti);
static int scmi_telemetry_instance_register(struct super_block *sb,
struct scmi_tlm_instance *ti);
@@ -778,12 +801,10 @@ stlmfs_create_dentry(struct super_block *sb, struct scmi_tlm_setup *tsp,
struct dentry *parent, const struct scmi_tlm_class *cls,
const void *priv)
{
- struct scmi_tlm_inode *tlmi;
+ struct scmi_tlm_inode *tlmi, *tlmi_parent;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
struct dentry *dentry;
- struct inode *inode;
-
- if (!parent)
- parent = sb->s_root;
+ struct inode *inode, *i_parent;
/*
* Bail-out when called on a bad tree, so that there is NO need to
@@ -792,7 +813,15 @@ stlmfs_create_dentry(struct super_block *sb, struct scmi_tlm_setup *tsp,
if (IS_ERR(parent))
return parent;
- dentry = simple_start_creating(parent, cls->name);
+ i_parent = d_inode(parent);
+ if (!i_parent)
+ return ERR_PTR(-ENOENT);
+
+ if (!sbi->lazy)
+ dentry = simple_start_creating(parent, cls->name);
+ else
+ dentry = d_alloc_name(parent, cls->name);
+
if (IS_ERR(dentry))
return dentry;
@@ -815,14 +844,24 @@ stlmfs_create_dentry(struct super_block *sb, struct scmi_tlm_setup *tsp,
inode->i_private = (void *)priv;
tlmi = to_tlm_inode(inode);
-
tlmi->cls = cls;
tlmi->tsp = tsp;
tlmi->priv = priv;
+ tlmi_parent = to_tlm_inode(i_parent);
+ if (sbi->lazy && tlmi_parent->cls && IS_LAZY(tlmi_parent->cls->flags)) {
+ scoped_guard(mutex, &tlmi_parent->mtx) {
+ list_add(&tlmi->node, &tlmi_parent->children);
+ tlmi_parent->num_children++;
+ }
+ }
+
d_make_persistent(dentry, inode);
- simple_done_creating(dentry);
+ if (!sbi->lazy)
+ simple_done_creating(dentry);
+ else
+ dput(dentry);
return dentry;
}
@@ -1477,8 +1516,6 @@ static const struct scmi_tlm_class tlm_tops[] = {
DEFINE_TLM_CLASS(reset_tlmo, "reset", 0, S_IFREG | 0200, &reset_fops, NULL);
-DEFINE_TLM_CLASS(des_dir_cls, "des", 0,
- S_IFDIR | 0700, NULL, NULL);
DEFINE_TLM_CLASS(name_tlmo, "name", 0,
S_IFREG | 0444, &string_ro_fops, NULL);
DEFINE_TLM_CLASS(ena_tlmo, "enable", TLM_IS_STATE,
@@ -1550,48 +1587,72 @@ static int scmi_telemetry_de_populate(struct super_block *sb,
return 0;
}
+static struct dentry *
+scmi_telemetry_subdir_create(struct super_block *sb, struct scmi_tlm_setup *tsp,
+ const char *dname, struct dentry *parent,
+ const void *priv)
+{
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+ struct dentry *dentry;
+
+ struct scmi_tlm_class *tlm_cls __free(kfree) =
+ kzalloc(sizeof(*tlm_cls), GFP_KERNEL);
+ if (!tlm_cls)
+ return ERR_PTR(-ENOMEM);
+
+ tlm_cls->name = dname;
+ tlm_cls->mode = S_IFDIR | 0755;
+ tlm_cls->flags = TLM_IS_DYNAMIC;
+ if (sbi->lazy)
+ tlm_cls->flags |= TLM_IS_LAZY;
+ dentry = stlmfs_create_dentry(sb, tsp, parent, tlm_cls, priv);
+ if (IS_ERR(dentry))
+ return dentry;
+
+ retain_and_null_ptr(tlm_cls);
+
+ return dentry;
+}
+
static int
-scmi_telemetry_des_lazy_enumerate(struct scmi_tlm_instance *ti,
- const struct scmi_telemetry_res_info *rinfo)
+scmi_telemetry_des_enumerate(const struct scmi_tlm_instance *ti,
+ const struct scmi_telemetry_res_info *rinfo)
{
struct scmi_tlm_setup *tsp = ti->tsp;
struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
for (int i = 0; i < rinfo->num_des; i++) {
const struct scmi_telemetry_de *de = rinfo->des[i];
struct dentry *de_dir_dentry;
int ret;
- struct scmi_tlm_class *de_tlm_cls __free(kfree) =
- kzalloc(sizeof(*de_tlm_cls), GFP_KERNEL);
- if (!de_tlm_cls)
- return -ENOMEM;
-
- de_tlm_cls->name = kasprintf(GFP_KERNEL, "0x%08X", de->info->id);
- if (!de_tlm_cls->name)
+ const char *dname __free(kfree) =
+ kasprintf(GFP_KERNEL, "0x%08X", de->info->id);
+ if (!dname)
return -ENOMEM;
- de_tlm_cls->mode = S_IFDIR | 0700;
- de_tlm_cls->flags = TLM_IS_DYNAMIC;
- de_dir_dentry = stlmfs_create_dentry(sb, tsp, ti->des_dentry,
- de_tlm_cls, de);
+ de_dir_dentry = scmi_telemetry_subdir_create(sb, tsp, dname,
+ ti->des_dentry, de);
+ if (IS_ERR(de_dir_dentry))
+ return PTR_ERR(de_dir_dentry);
ret = scmi_telemetry_de_populate(sb, tsp, de_dir_dentry, de,
rinfo->fully_enumerated);
if (ret)
return ret;
- retain_and_null_ptr(de_tlm_cls);
+ retain_and_null_ptr(dname);
}
- ti->res_enumerated = true;
+ sbi->populated[ti->id].des = true;
dev_info(tsp->dev, "Found %d Telemetry DE resources.\n", rinfo->num_des);
return 0;
}
-static int scmi_telemetry_des_initialize(struct scmi_tlm_instance *ti)
+static int scmi_telemetry_des_initialize(const struct scmi_tlm_instance *ti)
{
const struct scmi_telemetry_res_info *rinfo;
@@ -1599,9 +1660,196 @@ static int scmi_telemetry_des_initialize(struct scmi_tlm_instance *ti)
if (!rinfo)
return -ENODEV;
- return scmi_telemetry_des_lazy_enumerate(ti, rinfo);
+ return scmi_telemetry_des_enumerate(ti, rinfo);
+}
+
+static inline struct dentry *
+scmi_telemetry_dentry_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct dentry *d, *dentry_dir;
+
+ const char *dname __free(kfree) =
+ kmemdup_nul(dentry->d_name.name, dentry->d_name.len, GFP_KERNEL);
+ if (!dname)
+ return ERR_PTR(-ENOMEM);
+
+ dentry_dir = d_find_alias(dir);
+ if (!dentry_dir)
+ return simple_lookup(dir, dentry, flags);
+
+ d = stlmfs_lookup_by_name(dentry_dir, dname);
+ dput(dentry_dir);
+
+ return d;
+}
+
+static struct dentry *
+stlmfs_lazy_des_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(dir);
+ struct scmi_tlm_instance *ti = (struct scmi_tlm_instance *)tlmi->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+ int ret;
+
+ if (sbi->populated[ti->id].des)
+ return simple_lookup(dir, dentry, flags);
+
+ ret = scmi_telemetry_des_initialize(ti);
+ if (ret)
+ return ERR_PTR(ret);
+
+ return scmi_telemetry_dentry_lookup(dir, dentry, flags);
+}
+
+static const struct inode_operations lazy_des_dir_iops = {
+ .lookup = stlmfs_lazy_des_lookup,
+};
+
+static struct dentry *
+stlmfs_lazy_grps_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(dir);
+ struct scmi_tlm_instance *ti = (struct scmi_tlm_instance *)tlmi->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+ int ret;
+
+ if (sbi->populated[ti->id].grps)
+ return simple_lookup(dir, dentry, flags);
+
+ ret = scmi_telemetry_groups_initialize(ti);
+ if (ret)
+ return ERR_PTR(ret);
+
+ return scmi_telemetry_dentry_lookup(dir, dentry, flags);
+}
+
+static const struct inode_operations lazy_grps_dir_iops = {
+ .lookup = stlmfs_lazy_grps_lookup,
+};
+
+static struct dentry *
+stlmfs_lazy_compo_lookup(struct inode *dir, struct dentry *dentry,
+ unsigned int flags)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(dir);
+ struct scmi_tlm_instance *ti = (struct scmi_tlm_instance *)tlmi->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+ int ret;
+
+ if (sbi->populated[ti->id].topo)
+ return simple_lookup(dir, dentry, flags);
+
+ ret = scmi_telemetry_topology_view_initialize(ti);
+ if (ret)
+ return ERR_PTR(ret);
+
+ return scmi_telemetry_dentry_lookup(dir, dentry, flags);
}
+static const struct inode_operations lazy_compo_dir_iops = {
+ .lookup = stlmfs_lazy_compo_lookup,
+};
+
+static inline void
+scmi_telemetry_children_dir_emit(struct dir_context *ctx,
+ struct scmi_tlm_inode *tlmi_parent)
+{
+ struct scmi_tlm_inode *tlmi;
+
+ if (ctx->pos >= tlmi_parent->num_children)
+ return;
+
+ guard(mutex)(&tlmi_parent->mtx);
+ list_for_each_entry(tlmi, &tlmi_parent->children, node) {
+ if (!dir_emit(ctx, tlmi->cls->name, strlen(tlmi->cls->name),
+ tlmi->vfs_inode.i_ino,
+ S_ISDIR(tlmi->cls->mode) ? DT_DIR : DT_REG))
+ break;
+ ctx->pos++;
+ }
+}
+
+static int
+stlmfs_lazy_des_iterate_shared(struct file *filp, struct dir_context *ctx)
+{
+ struct scmi_tlm_inode *tlmi_des = to_tlm_inode(file_inode(filp));
+ const struct scmi_tlm_instance *ti = tlmi_des->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
+ if (!sbi->populated[ti->id].des) {
+ int ret;
+
+ ret = scmi_telemetry_des_initialize(ti);
+ if (ret)
+ return ret;
+ }
+
+ scmi_telemetry_children_dir_emit(ctx, tlmi_des);
+
+ return 0;
+}
+
+static const struct file_operations lazy_des_fops = {
+ .iterate_shared = stlmfs_lazy_des_iterate_shared,
+};
+
+static int
+stlmfs_lazy_grps_iterate_shared(struct file *filp, struct dir_context *ctx)
+{
+ struct scmi_tlm_inode *tlmi_des = to_tlm_inode(file_inode(filp));
+ const struct scmi_tlm_instance *ti = tlmi_des->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
+ if (!sbi->populated[ti->id].grps) {
+ int ret;
+
+ ret = scmi_telemetry_groups_initialize(ti);
+ if (ret)
+ return ret;
+ }
+
+ scmi_telemetry_children_dir_emit(ctx, tlmi_des);
+
+ return 0;
+}
+
+static const struct file_operations lazy_grps_fops = {
+ .iterate_shared = stlmfs_lazy_grps_iterate_shared,
+};
+
+static int
+stlmfs_lazy_compo_iterate_shared(struct file *filp, struct dir_context *ctx)
+{
+ struct scmi_tlm_inode *tlmi_des = to_tlm_inode(file_inode(filp));
+ const struct scmi_tlm_instance *ti = tlmi_des->priv;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
+ if (!sbi->populated[ti->id].topo) {
+ int ret;
+
+ ret = scmi_telemetry_topology_view_initialize(ti);
+ if (ret)
+ return ret;
+ }
+
+ scmi_telemetry_children_dir_emit(ctx, tlmi_des);
+
+ return 0;
+}
+
+static const struct file_operations lazy_compo_fops = {
+ .iterate_shared = stlmfs_lazy_compo_iterate_shared,
+};
+
DEFINE_TLM_CLASS(version_tlmo, "version", 0,
S_IFREG | 0444, &sa_x32_ro_fops, NULL);
@@ -1728,8 +1976,6 @@ static const struct scmi_tlm_class tlm_grps[] = {
DEFINE_TLM_CLASS(grp_data_tlmo, "des_bulk_read", TLM_IS_GROUP,
S_IFREG | 0444, &scmi_tlm_data_fops, NULL);
-DEFINE_TLM_CLASS(groups_dir_cls, "groups", 0, S_IFDIR | 0700, NULL, NULL);
-
DEFINE_TLM_CLASS(grp_single_sample_tlmo, "des_single_sample_read", TLM_IS_GROUP,
S_IFREG | 0444, &scmi_tlm_single_sample_fops, NULL);
@@ -2146,67 +2392,85 @@ DEFINE_TLM_CLASS(ctrl_tlmo, "control", 0,
DEFINE_TLM_CLASS(grp_ctrl_tlmo, "control", TLM_IS_GROUP,
S_IFREG | 0666, &scmi_tlm_ctrl_fops, NULL);
-static int scmi_telemetry_groups_initialize(struct scmi_tlm_instance *ti)
+static int
+scmi_telemetry_grp_populate(struct super_block *sb, struct scmi_tlm_setup *tsp,
+ struct dentry *parent,
+ const struct scmi_telemetry_group *grp,
+ bool single_read_support,
+ bool per_group_config_support)
+{
+ for (const struct scmi_tlm_class *gto = tlm_grps; gto->name; gto++)
+ stlmfs_create_dentry(sb, tsp, parent, gto, grp);
+
+ stlmfs_create_dentry(sb, tsp, parent, &grp_composing_des_tlmo,
+ grp->des_str);
+
+ stlmfs_create_dentry(sb, tsp, parent, &grp_ctrl_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, parent, &grp_data_tlmo, grp);
+ if (single_read_support)
+ stlmfs_create_dentry(sb, tsp, parent, &grp_single_sample_tlmo, grp);
+
+ if (per_group_config_support) {
+ stlmfs_create_dentry(sb, tsp, parent,
+ &grp_current_interval_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, parent,
+ &grp_available_interval_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, parent,
+ &grp_intervals_discrete_tlmo, grp);
+ }
+
+ return 0;
+}
+
+static int
+scmi_telemetry_groups_enumerate(const struct scmi_tlm_instance *ti,
+ const struct scmi_telemetry_res_info *rinfo)
{
- const struct scmi_telemetry_res_info *rinfo;
struct scmi_tlm_setup *tsp = ti->tsp;
struct super_block *sb = ti->sb;
- struct device *dev = tsp->dev;
- struct dentry *grp_dir_dentry;
-
- if (ti->info->base.num_groups == 0)
- return 0;
-
- rinfo = scmi_telemetry_res_info_get(tsp);
- if (!rinfo)
- return -ENODEV;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
for (int i = 0; i < rinfo->num_groups; i++) {
- const struct scmi_telemetry_group *grp = &rinfo->grps[i];
-
- struct scmi_tlm_class *grp_tlm_cls __free(kfree) =
- kzalloc(sizeof(*grp_tlm_cls), GFP_KERNEL);
- if (!grp_tlm_cls)
- return -ENOMEM;
+ struct dentry *grp_dentry;
+ int ret;
- grp_tlm_cls->name = kasprintf(GFP_KERNEL, "%u", grp->info->id);
- if (!grp_tlm_cls->name)
+ const char *dname __free(kfree) =
+ kasprintf(GFP_KERNEL, "%u", rinfo->grps[i].info->id);
+ if (!dname)
return -ENOMEM;
- grp_tlm_cls->mode = S_IFDIR | 0700;
- grp_tlm_cls->flags = TLM_IS_DYNAMIC;
+ grp_dentry = scmi_telemetry_subdir_create(sb, tsp, dname,
+ ti->grps_dentry,
+ &rinfo->grps[i]);
+ if (IS_ERR(grp_dentry))
+ return PTR_ERR(grp_dentry);
- grp_dir_dentry = stlmfs_create_dentry(sb, tsp, ti->grps_dentry,
- grp_tlm_cls, grp);
+ ret = scmi_telemetry_grp_populate(sb, tsp, grp_dentry,
+ &rinfo->grps[i],
+ ti->info->single_read_support,
+ ti->info->per_group_config_support);
+ if (ret)
+ return ret;
- for (const struct scmi_tlm_class *gto = tlm_grps; gto->name; gto++)
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry, gto, grp);
+ retain_and_null_ptr(dname);
+ }
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_composing_des_tlmo, grp->des_str);
+ sbi->populated[ti->id].grps = true;
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_ctrl_tlmo, grp);
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_data_tlmo, grp);
- if (ti->info->single_read_support)
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_single_sample_tlmo, grp);
+ dev_info(tsp->dev, "Found %d Telemetry GROUPS resources.\n", rinfo->num_groups);
- if (ti->info->per_group_config_support) {
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_current_interval_tlmo, grp);
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_available_interval_tlmo, grp);
- stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
- &grp_intervals_discrete_tlmo, grp);
- }
+ return 0;
+}
- retain_and_null_ptr(grp_tlm_cls);
- }
+static int scmi_telemetry_groups_initialize(const struct scmi_tlm_instance *ti)
+{
+ const struct scmi_telemetry_res_info *rinfo;
- dev_info(dev, "Found %d Telemetry GROUPS resources.\n",
- rinfo->num_groups);
+ rinfo = scmi_telemetry_res_info_get(ti->tsp);
+ if (!rinfo || !rinfo->fully_enumerated)
+ return -ENODEV;
- return 0;
+ return scmi_telemetry_groups_enumerate(ti, rinfo);
}
static struct scmi_tlm_instance *scmi_tlm_init(struct scmi_tlm_setup *tsp,
@@ -2263,6 +2527,7 @@ static int scmi_telemetry_probe(struct scmi_device *sdev)
mutex_lock(&stlmfs_mtx);
list_add(&ti->node, &scmi_telemetry_instances);
+ stlmfs_instances++;
sb = stlmfs_sb;
mutex_unlock(&stlmfs_mtx);
@@ -2320,6 +2585,9 @@ static struct inode *stlmfs_alloc_inode(struct super_block *sb)
return NULL;
tlmi->cls = NULL;
+ mutex_init(&tlmi->mtx);
+ INIT_LIST_HEAD(&tlmi->children);
+ tlmi->num_children = 0;
return &tlmi->vfs_inode;
}
@@ -2346,6 +2614,8 @@ static int stlmfs_show_options(struct seq_file *seq, struct dentry *root)
seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, sbi->gid));
if (sbi->umask != SCMI_TLM_DEFAULT_UMASK)
seq_printf(seq, ",umask=%04u", sbi->umask);
+ if (sbi->lazy)
+ seq_printf(seq, ",lazy");
return 0;
}
@@ -2423,6 +2693,7 @@ scmi_telemetry_topology_path_get(struct super_block *sb,
struct scmi_tlm_setup *tsp,
struct dentry *parent, const char *dname)
{
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
struct dentry *dentry;
dentry = stlmfs_lookup_by_name(parent, dname);
@@ -2438,6 +2709,8 @@ scmi_telemetry_topology_path_get(struct super_block *sb,
dir_tlm_cls->mode = S_IFDIR | 0755;
dir_tlm_cls->flags = TLM_IS_DYNAMIC;
+ if (sbi->lazy)
+ dir_tlm_cls->flags |= TLM_IS_LAZY;
dentry = stlmfs_create_dentry(sb, tsp, parent,
dir_tlm_cls, NULL);
@@ -2449,7 +2722,7 @@ scmi_telemetry_topology_path_get(struct super_block *sb,
}
static int scmi_telemetry_topology_add_node(struct super_block *sb,
- struct scmi_tlm_instance *ti,
+ const struct scmi_tlm_instance *ti,
const struct scmi_telemetry_de *de)
{
struct dentry *ctype, *cinst, *cunit, *dinst;
@@ -2490,21 +2763,19 @@ static int scmi_telemetry_topology_add_node(struct super_block *sb,
return ret;
}
-DEFINE_TLM_CLASS(compo_dir_cls, "by-components", 0, S_IFDIR | 0700, NULL, NULL);
-
-static int scmi_telemetry_topology_view_add(struct scmi_tlm_instance *ti)
+static int
+scmi_telemetry_topology_view_initialize(const struct scmi_tlm_instance *ti)
{
const struct scmi_telemetry_res_info *rinfo;
struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
struct device *dev = tsp->dev;
rinfo = scmi_telemetry_res_info_get(tsp);
if (!rinfo || !rinfo->fully_enumerated)
return -ENODEV;
- ti->compo_dentry =
- stlmfs_create_dentry(ti->sb, tsp, ti->top_dentry, &compo_dir_cls, NULL);
-
for (int i = 0; i < rinfo->num_des; i++) {
int ret;
@@ -2514,13 +2785,51 @@ static int scmi_telemetry_topology_view_add(struct scmi_tlm_instance *ti)
rinfo->des[i]->info->name);
}
+ sbi->populated[ti->id].topo = true;
+
+ if (sbi->lazy && !sbi->populated[ti->id].des) {
+ int ret;
+
+ ret = scmi_telemetry_des_initialize(ti);
+ if (ret)
+ return ret;
+ }
+
return 0;
}
+static struct dentry *
+scmi_telemetry_top_dentry_create(struct scmi_tlm_instance *ti, bool lazy,
+ const char *dname, struct dentry *parent,
+ const struct file_operations *lazy_fops,
+ const struct inode_operations *lazy_dir_iops,
+ void *priv)
+{
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+
+ struct scmi_tlm_class *tlm_cls __free(kfree) =
+ kzalloc(sizeof(*tlm_cls), GFP_KERNEL);
+ if (!tlm_cls)
+ return ERR_PTR(-ENOMEM);
+
+ tlm_cls->name = kasprintf(GFP_KERNEL, "%s", dname);
+ tlm_cls->mode = S_IFDIR | 0755;
+ tlm_cls->flags = TLM_IS_DYNAMIC;
+ if (lazy) {
+ tlm_cls->flags |= TLM_IS_LAZY;
+ tlm_cls->f_op = lazy_fops;
+ tlm_cls->i_op = lazy_dir_iops;
+ }
+
+ return stlmfs_create_dentry(sb, tsp, parent, no_free_ptr(tlm_cls), priv);
+}
+
static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
{
struct scmi_tlm_setup *tsp = ti->tsp;
struct super_block *sb = ti->sb;
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
scnprintf(ti->name, MAX_INST_NAME, "tlm_%d", ti->id);
@@ -2543,10 +2852,25 @@ static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
stlmfs_create_dentry(sb, tsp, ti->top_dentry,
&single_sample_tlmo, ti->info);
stlmfs_create_dentry(sb, tsp, ti->top_dentry, &ctrl_tlmo, ti->info);
- ti->des_dentry =
- stlmfs_create_dentry(sb, tsp, ti->top_dentry, &des_dir_cls, NULL);
- ti->grps_dentry =
- stlmfs_create_dentry(sb, tsp, ti->top_dentry, &groups_dir_cls, NULL);
+
+ ti->des_dentry = scmi_telemetry_top_dentry_create(ti, sbi->lazy, "des",
+ ti->top_dentry,
+ &lazy_des_fops,
+ &lazy_des_dir_iops,
+ ti);
+
+ ti->grps_dentry = scmi_telemetry_top_dentry_create(ti, sbi->lazy, "groups",
+ ti->top_dentry,
+ &lazy_grps_fops,
+ &lazy_grps_dir_iops,
+ ti);
+
+ ti->compo_dentry = scmi_telemetry_top_dentry_create(ti, sbi->lazy,
+ "by-components",
+ ti->top_dentry,
+ &lazy_compo_fops,
+ &lazy_compo_dir_iops,
+ ti);
return 0;
}
@@ -2554,6 +2878,7 @@ static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
static int scmi_telemetry_instance_register(struct super_block *sb,
struct scmi_tlm_instance *ti)
{
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
int ret;
ti->sb = sb;
@@ -2561,6 +2886,9 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
if (ret)
return ret;
+ if (sbi->lazy)
+ return 0;
+
ret = scmi_telemetry_des_initialize(ti);
if (ret)
return ret;
@@ -2572,11 +2900,12 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
ti->top_cls.name);
}
- ret = scmi_telemetry_topology_view_add(ti);
- if (ret)
+ ret = scmi_telemetry_topology_view_initialize(ti);
+ if (ret) {
dev_warn(ti->tsp->dev,
"Failed to create topology view for instance %s.\n",
ti->top_cls.name);
+ }
return 0;
}
@@ -2593,11 +2922,13 @@ static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
return 0;
struct stlmfs_sb_info *sbi __free(kfree) =
- kzalloc(sizeof(*sbi), GFP_KERNEL);
+ kzalloc(struct_size(sbi, populated, stlmfs_instances), GFP_KERNEL);
if (!sbi)
return -ENOMEM;
ctx = fc->fs_private;
+ sbi->num_inst = stlmfs_instances;
+ sbi->lazy = ctx->lazy;
sbi->uid = ctx->uid;
sbi->gid = ctx->gid;
sbi->umask = ctx->umask;
@@ -2673,6 +3004,10 @@ static int stlmfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
ctx->umask = result.uint_32 & 07777;
ctx->opts |= BIT(Opt_umask);
break;
+ case Opt_lazy:
+ ctx->lazy = result.boolean;
+ ctx->opts |= BIT(Opt_lazy);
+ break;
default:
return -ENOPARAM;
}
@@ -2692,6 +3027,8 @@ static int stlmfs_reconfigure(struct fs_context *fc)
return invalfc(fc, "gid cannot be changed on remount");
if (ctx->opts & BIT(Opt_umask))
return invalfc(fc, "umask cannot be changed on remount");
+ if (ctx->opts & BIT(Opt_lazy))
+ return invalfc(fc, "lazy cannot be changed on remount");
return 0;
}
@@ -2712,6 +3049,7 @@ static int stlmfs_init_fs_context(struct fs_context *fc)
return -ENOMEM;
/* defaults */
+ ctx->lazy = false;
ctx->uid = GLOBAL_ROOT_UID;
ctx->gid = GLOBAL_ROOT_GID;
ctx->umask = SCMI_TLM_DEFAULT_UMASK;
@@ -2740,6 +3078,7 @@ static struct file_system_type scmi_telemetry_fs = {
.name = TLM_FS_NAME,
.kill_sb = stlmfs_kill_sb,
.init_fs_context = stlmfs_init_fs_context,
+ .parameters = stlmfs_param_spec,
.fs_flags = 0,
};
--
2.54.0
^ permalink raw reply related
* [PATCH v4 28/31] [RFC] docs: stlmfs: Document ARM SCMI Telemetry FS ABI
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add full ABI dcoumentation for stlmfs under testing/
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- renamed to by-components
- updated date/versions
- changed output of des/0x<NNN>/value to -> <tstamp> <value>
(removed colon)
- added Rationale and Concurrency model
- added generation counter Description
v2 --> v3
- complete ABI entries docs
RFC since unsure if place this into stable/ or testing/
---
Documentation/ABI/testing/stlmfs | 348 +++++++++++++++++++++++++++++++
1 file changed, 348 insertions(+)
create mode 100644 Documentation/ABI/testing/stlmfs
diff --git a/Documentation/ABI/testing/stlmfs b/Documentation/ABI/testing/stlmfs
new file mode 100644
index 000000000000..826092a4baf4
--- /dev/null
+++ b/Documentation/ABI/testing/stlmfs
@@ -0,0 +1,348 @@
+What: /sys/fs/arm_telemetry/tlm_<N>/...
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Rationale: This filesystem provides access to SCMI telemetry data and
+ configuration.
+ The interface is required to support:
+ - hierarchical dynamically discovered telemetry objects
+ - bulk data read across multiple sources
+ - representation of complex structured data and their
+ relationship
+ - alternative high-frequency data access (ioctl/mmap)
+ These characteristics exceed the intended use of sysfs, which is
+ designed to represent devices properties with simple attribute
+ based configuration with one value per file: representing
+ telemetry Data Events with devices was deemed an abuse by
+ itself.
+ A dedicated filesystem is therefore used to provide a more
+ suitable abstraction for this class of functionality.
+
+Concurrency: The telemetry configuration exposed through this filesystem is
+ global to each SCMI telemetry instance, indentified by the top
+ tlm_<N> directory.
+ Concurrent access from multiple user-space processes is allowed.
+ The kernel does not enforce exclusivity or ownership of the
+ interface.
+ All configuration changes are applied immediately by issuing
+ the related SCMI commands. Writes to different attributes may
+ interleave and no atomicity across multiple files is guaranteed.
+ In case of concurrent writes to the same attribute, the last
+ writer wins.
+ Read operations may observe state that has been already modified
+ and it is stale.
+ Userspace is responsible for coordinating access if stronger
+ consistency or serialization is required and this filesystem
+ provides a generation counter to aid in the detection of sudden
+ configuration changes.
+
+What: /sys/fs/arm_telemetry/tlm_<N>/all_des_enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean WO entry to enable all the discovered Data Events for
+ SCMI instance <N>.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/all_tstamp_des_enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean WO entry to enable timestamps for all the discovered
+ Data Events for SCMI instance <N>. (when available)
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/available_update_intervals_ms
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns a space separated list of tuples of
+ values, separated by a coma, each one representing a
+ configurable update interval for SCMI instance <N>.
+ Each tuple describes a possible update interval using the
+ format <secs>,<exp> where the final represented interval is
+ calculated as: <secs> * 10 ^ <exp>
+ An example of list of tuples that can be read from this entry:
+ 3,0 4,-1 75,-2 300,-3 1,1 5,3 222,-7
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/by-components/
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A subdirectory that exposes an alternative topological view of
+ the same set of discovered DEs that can be already found under
+ the des/ branch.
+ This topology subtree is built following this structure:
+ by-components/
+ ├── <COMPO_TYPE_STR>
+ │ ├── <COMPO_ISTANCE_ID>
+ │ │ ├── <DE_UNIT_TYPE_STR>
+ │ │ │ └── <DE_INSTANCE_ID>
+ │ │ │ └── 0x<DE_ID>[<DE_NAME>] -> ../../../../../des/0x<DE_ID>
+
+ The leaves are actual symlinks to an existing des/0x<DE_ID>
+ subdirectory, while the naming of the subdirectories composing
+ the inner nodes of the subtree are derived from the DataEvent
+ Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/control
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: An RW entry that can be used to discover, configure and retrieve
+ Telemetry data using the alternative binary interface based on
+ ioctls which is documented in include/uapi/linux/scmi.h
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/current_update_intervals_ms
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: An RW entry that can be used to get or set the platform update
+ interval for SCMI instance <N>.
+ On read the returned tuple represents the current update
+ interval using the format <secs>,<exp> where the final
+ represented interval is calculated as: <secs> * 10 ^ <exp>
+ On write the accepted format is the same as on read <secs>,<exp>
+ but, optionally, the second element of the tuple can be omitted
+ and in that case the assumed value for the exponent will default
+ to -3, i.e. milliseconds.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/de_implementation_version
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns a string representing the 128bit UUID
+ that uniquely identifies the set of SCMI Telemetry Data Events
+ and their semantic for SCMI instance <N>.
+ This is compliant with the DE_IMPLEMENTATION_REVISION described
+ in SCMI v4.0 Telemetry 3.12.4.3.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des_bulk_read
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns a multi-line string containing all the
+ the DEs enabled for SCMI instance <N>, one-per-line, formatted
+ as: <DE_ID> <TIMESTAMP> <DATA_VALUE>
+ These DEs readings represent the last value updated by the
+ platform following the configured update interval: on the
+ backend they will have been collected transparently in a number
+ of different ways: on-demand SHMTI lookup, notifications,
+ fastchannels. Data consistency is guaranteed by the underlying
+ SCMI synchronization mechanisms.
+ Any disabled or unavailable DE is simply NOT included.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des_single_sample_read
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns a multi-line string containing all the
+ the DEs enabled for SCMI instance <N>, one-per-line, formmatted
+ as: <DE_ID> <TIMESTAMP> <DATA_VALUE>
+ These DEs readings are generated by triggering an explicit and
+ immediate platform update using single sample asynchronous
+ collect methods.
+ Any disabled or unavailable DE is simply NOT included.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/generation
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that returns an integer representing the number of
+ configuration changes applied using any entry in this interface:
+ any read, following the first one after the open, blocks until
+ the next configuration change is applied and the counter is
+ increased: this entry supports poll/select system calls to ease
+ the monitoring process.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/intervals_discrete
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean RO entry to specify if the intervals reported for
+ SCMI instance <N> in available_update_intervals_ms are a list of
+ discrete intervals or a triplet of values representing
+ <LOWEST_UPDATE_INTERVAL> <HIGHEST_UPDATE_INTERVAL> <STEP_SIZE>.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/reset
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean WO entry that can be used the full reset of the SCMI
+ Telemetry subsystem, both of the configurations and of the
+ collected data, as specified in SCMI v4.0 3.12.4.12
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/tlm_enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A boolean RW entry that can be used to get or set the general
+ enable status of the Telemetry subsystem. Temporarily disabling
+ Telemetry as a whole does NOT reset the current configuration,
+ it only stops all the configured DEs updates platform side.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/version
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry used to report the SCMI Telemetry protocol version
+ used in this implementation.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/compo_instance_id
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the component instance to which this DE
+ belongs, as described by the DataEvent Descriptor in SCMI v4.0
+ 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/compo_type
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the component type to which this DE is
+ associated, as described by the DataEvent Descriptor in SCMI v4.0
+ 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/instance_id
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the DE instance ID that identifies this DE
+ within the component instance to which it belongs, as described
+ by the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/name
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A optional RO entry to report the name associated with this DE,
+ as described by the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/persistent
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO boolean to report that the DE data values are persistent
+ across all reboot cycles, except cold reboot, as described by
+ the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/tstamp_rate
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: An optional RO entry to report the clock rate in KHZ used to
+ generate the timestamps associated to this DE, as described by
+ the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/type
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the type of DataEvent as described by the
+ DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/unit
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the unit of measurements used by this DE,
+ as described by the DataEvent Descriptor in SCMI v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/unit_exp
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry to report the power-of-10 multiplier in two's
+ complement format that is applied to the unit specified by the
+ DE unit field, as described by the DataEvent Descriptor in SCMI
+ v4.0 3.12.4.6.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/value
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry used to read the last value and timestamp collected
+ for Data Event with id 0x<NNNNNNNN> for SCMI instance <N>.
+ The output is formatted as: <TIMESTAMP> <DATA_VALUE>
+ Reading from this entry can fail with:
+ -ENODATA: the DE itself, or the whole telemetry subsystem,
+ was in a disabled state at the time of the read.
+ -EINVAL: the data value associated to this DE is NOT usable
+ since it was found to have been internally marked as
+ DATA_INVALID; this could be due to a temporary or
+ permanent error condition of the underlying hardware
+ in charge of this DE data collection.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RW boolean entry used to enable or disable Data Event
+ with id 0x<NNNNNNNN> for SCMI instance <N>.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/des/0x<NNNNNNNN>/tstamp_enable
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: An RW boolean entry used to enable or disable timestamping for
+ Data Event with id 0x<NNNNNNNN> for SCMI instance <N>.
+ This entry is optional and present only if the DE supports
+ timestamping.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/groups/<M>/
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A subdirectory containing entries that describe configurations
+ and values related to group <M> of SCMI instance <N>.
+ Most of the contained entries share the same names with some
+ other, already defined entries, elsewhere:
+
+ groups/0/
+ ├── available_update_intervals_ms
+ ├── control
+ ├── current_update_interval_ms
+ ├── des_bulk_read
+ ├── des_single_sample_read
+ ├── enable
+ ├── intervals_discrete
+ └── tstamp_enable
+
+ These homonyms carry the same syntax and semantic as the other
+ but they are usually restricted in their definitions to the
+ specific group <M>.
+ These common entries won't be described further again here.
+Users: Any userspace telemetry tool
+
+What: /sys/fs/arm_telemetry/tlm_<N>/groups/<M>/composing_des
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A RO entry that reports the space separated list of DataEvents
+ belonging to group <M> for SCMI instance <N>
+Users: Any userspace telemetry tool
--
2.54.0
^ permalink raw reply related
* [PATCH v4 27/31] firmware: arm_scmi: stlmfs: Add generation file
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a read-only generation file to be used for monitoring configuration
changes across an instance: first read after the open returns the current
value, then it blocks till next confiuration change is detected.
Generation file supports also poll system call to monitor chamges.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- added stlmfs tag in $SUBJECT
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 89 +++++++++++++++++++
1 file changed, 89 insertions(+)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index c83d9763d479..df45fc212e13 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -19,12 +19,14 @@
#include <linux/list.h>
#include <linux/module.h>
#include <linux/overflow.h>
+#include <linux/poll.h>
#include <linux/scmi_protocol.h>
#include <linux/slab.h>
#include <linux/sprintf.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/uaccess.h>
+#include <linux/wait.h>
#include <uapi/linux/scmi.h>
@@ -1368,6 +1370,91 @@ static const struct file_operations available_interv_fops = {
.release = scmi_tlm_priv_release,
};
+struct scmi_tlm_gen_priv {
+ unsigned int last_seen;
+ struct wait_queue_head *wq;
+ struct scmi_tlm_buffer tb;
+};
+
+static int scmi_tlm_generation_open(struct inode *ino, struct file *filp)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(ino);
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ struct scmi_tlm_gen_priv *gen;
+
+ gen = kzalloc_obj(*gen);
+ if (!gen)
+ return -ENOMEM;
+
+ gen->wq = tsp->ops->event_wq_get(tsp->ph);
+ if (!gen->wq) {
+ kfree(gen);
+ return -ENOMEM;
+ }
+
+ gen->last_seen = SCMI_TLM_GENERATION_INVALID;
+ filp->private_data = gen;
+
+ return nonseekable_open(ino, filp);
+}
+
+static ssize_t
+scmi_tlm_generation_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_gen_priv *gen = filp->private_data;
+ struct scmi_telemetry_info *info = (struct scmi_telemetry_info *)tlmi->priv;
+ unsigned int c;
+
+ if (*ppos == gen->tb.used)
+ gen->tb.used = *ppos = 0;
+
+ if (!gen->tb.used) {
+ int ret;
+
+ ret = wait_event_interruptible(*gen->wq,
+ (c = atomic_read(&info->generation)) !=
+ gen->last_seen);
+ if (ret)
+ return -ERESTARTSYS;
+
+ gen->last_seen = c;
+ gen->tb.used = scnprintf(gen->tb.buf, SCMI_TLM_MAX_BUF_SZ, "%u\n", c);
+ }
+
+ return simple_read_from_buffer(buf, count, ppos, gen->tb.buf, gen->tb.used);
+}
+
+static __poll_t scmi_tlm_generation_poll(struct file *filp, poll_table *wait)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_telemetry_info *info = (struct scmi_telemetry_info *)tlmi->priv;
+ struct scmi_tlm_gen_priv *gen = filp->private_data;
+
+ poll_wait(filp, gen->wq, wait);
+ if (atomic_read(&info->generation) != gen->last_seen)
+ return EPOLLIN | EPOLLRDNORM;
+
+ return 0;
+}
+
+static int scmi_tlm_generation_release(struct inode *ino, struct file *filp)
+{
+ struct scmi_tlm_gen_priv *gen = filp->private_data;
+
+ kfree(gen);
+
+ return 0;
+}
+
+static const struct file_operations generation_fops = {
+ .open = scmi_tlm_generation_open,
+ .read = scmi_tlm_generation_read,
+ .poll = scmi_tlm_generation_poll,
+ .release = scmi_tlm_generation_release,
+};
+
static const struct scmi_tlm_class tlm_tops[] = {
TLM_ANON_CLASS("all_des_enable", TLM_IS_STATE,
S_IFREG | 0666, &all_des_fops, NULL),
@@ -1383,6 +1470,8 @@ static const struct scmi_tlm_class tlm_tops[] = {
S_IFREG | 0444, &de_impl_vers_fops, NULL),
TLM_ANON_CLASS("tlm_enable", 0,
S_IFREG | 0666, &tlm_enable_fops, NULL),
+ TLM_ANON_CLASS("generation", 0,
+ S_IFREG | 0444, &generation_fops, NULL),
TLM_ANON_CLASS(NULL, 0, 0, NULL, NULL),
};
--
2.54.0
^ permalink raw reply related
* [PATCH v4 26/31] fs/stlmfs: Document alternative topological view
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
The human readable interface presents an alternative view based on the
discovered topological relations between the DEs.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- renamed to by-components
v2 --> v3
- completed FS tree description
- renamed components to by_components
---
Documentation/filesystems/stlmfs.rst | 72 ++++++++++++++++++++++++++++
1 file changed, 72 insertions(+)
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
index 0c7b7c006709..b5b3cd649775 100644
--- a/Documentation/filesystems/stlmfs.rst
+++ b/Documentation/filesystems/stlmfs.rst
@@ -143,6 +143,7 @@ create the following directory structure::
|-- all_des_enable
|-- all_des_tstamp_enable
|-- available_update_intervals_ms
+ |-- by-components/
|-- control
|-- current_update_interval_ms
|-- de_implementation_version
@@ -233,6 +234,77 @@ values, as in::
|-- intervals_discrete
`-- tstamp_enable
+by-components/
+-----------
+
+An alternative topological view of the des/ directory based on the topology
+relationship information described in des/ ::
+
+ by-components/
+ ├── cpu
+ │ ├── 0
+ │ │ ├── celsius
+ │ │ │ └── 0
+ │ │ │ └── 0x00000001[pe_0] -> ../../../../../des/0x00000001
+ │ │ └── cycles
+ │ │ ├── 0
+ │ │ │ └── 0x00001010[] -> ../../../../../des/0x00001010
+ │ │ └── 1
+ │ │ └── 0x00002020[] -> ../../../../../des/0x00002020
+ │ ├── 1
+ │ │ └── celsius
+ │ │ └── 0
+ │ │ └── 0x00000002[pe_1] -> ../../../../../des/0x00000002
+ │ └── 2
+ │ └── celsius
+ │ └── 0
+ │ └── 0x00000003[pe_2] -> ../../../../../des/0x00000003
+ ├── interconnnect
+ │ └── 0
+ │ └── hertz
+ │ └── 0
+ │ ├── 0x0000A008[A008_de] -> ../../../../../des/0x0000A008
+ │ └── 0x0000A00B[] -> ../../../../../des/0x0000A00B
+ ├── mem_cntrl
+ │ └── 0
+ │ ├── bps
+ │ │ └── 0
+ │ │ └── 0x0000A00A[] -> ../../../../../des/0x0000A00A
+ │ ├── celsius
+ │ │ └── 0
+ │ │ └── 0x0000A007[DRAM_temp] -> ../../../../../des/0x0000A007
+ │ └── joules
+ │ └── 0
+ │ └── 0x0000A002[DRAM_energy] -> ../../../../../des/0x0000A002
+ ├── periph
+ │ ├── 0
+ │ │ └── messages
+ │ │ └── 0
+ │ │ └── 0x00000016[device_16] -> ../../../../../des/0x00000016
+ │ ├── 1
+ │ │ └── messages
+ │ │ └── 0
+ │ │ └── 0x00000017[device_17] -> ../../../../../des/0x00000017
+ │ └── 2
+ │ └── messages
+ │ └── 0
+ │ └── 0x00000018[device_18] -> ../../../../../des/0x00000018
+ └── unspec
+ └── 0
+ ├── celsius
+ │ └── 0
+ │ └── 0x0000A005[] -> ../../../../../des/0x0000A005
+ ├── counts
+ │ └── 0
+ │ └── 0x0000A00C[] -> ../../../../../des/0x0000A00C
+ ├── joules
+ │ └── 0
+ │ ├── 0x0000A000[SOC_Energy] -> ../../../../../des/0x0000A000
+ │ └── 0x0000A001[] -> ../../../../../des/0x0000A001
+ └── state
+ └── 0
+ └── 0x0000A010[] -> ../../../../../des/0x0000A010
+
Alternative Binary Interfaces - Special files
=============================================
--
2.54.0
^ permalink raw reply related
* [PATCH v4 25/31] firmware: arm_scmi: stlmfs: Add by-components view
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add an alternative filesystem view for the discovered Data Events, where
the tree of DEs is laid out following the discovered topological order
instead of the existing flat layout.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- make FS entries world-Readable and user-Writable where applicable
- renamed top dir to by-components
- use octal permissions
- added stlmfs tag in $SUBJECT
v2 --> v3
- renamed components to by_components
- fixed uninitialized variable in scmi_telemetry_de_subdir_symlink()
as reported by Elif
v1 --> v2
- Use new FS API
- Introduce new stlmfs_lookup_by_name helper
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 681 ++++++++++++++++++
1 file changed, 681 insertions(+)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index 720930f6bcd1..c83d9763d479 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -203,6 +203,7 @@ struct scmi_tlm_inode {
* @top_dentry: A reference to the top dentry for this instance.
* @des_dentry: A reference to the DES dentry for this instance.
* @grps_dentry: A reference to the groups dentry for this instance.
+ * @compo_dentry: A reference to the components dentry for this instance.
* @info: A handy reference to this instance SCMI Telemetry info data.
*
*/
@@ -217,6 +218,7 @@ struct scmi_tlm_instance {
struct dentry *top_dentry;
struct dentry *des_dentry;
struct dentry *grps_dentry;
+ struct dentry *compo_dentry;
const struct scmi_telemetry_info *info;
};
@@ -225,6 +227,526 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
static LIST_HEAD(scmi_telemetry_instances);
+#define TYPES_ARRAY_SZ 256
+
+static const char *compo_types[TYPES_ARRAY_SZ] = {
+ "unspec",
+ "cpu",
+ "cluster",
+ "gpu",
+ "npu",
+ "interconnnect",
+ "mem_cntrl",
+ "l1_cache",
+ "l2_cache",
+ "l3_cache",
+ "ll_cache",
+ "sys_cache",
+ "disp_cntrl",
+ "ipu",
+ "chiplet",
+ "package",
+ "soc",
+ "system",
+ "smcu",
+ "accel",
+ "battery",
+ "charger",
+ "pmic",
+ "board",
+ "memory",
+ "periph",
+ "periph_subc",
+ "lid",
+ "display",
+ "res_29",
+ "res_30",
+ "res_31",
+ "res_32",
+ "res_33",
+ "res_34",
+ "res_35",
+ "res_36",
+ "res_37",
+ "res_38",
+ "res_39",
+ "res_40",
+ "res_41",
+ "res_42",
+ "res_43",
+ "res_44",
+ "res_45",
+ "res_46",
+ "res_47",
+ "res_48",
+ "res_49",
+ "res_50",
+ "res_51",
+ "res_52",
+ "res_53",
+ "res_54",
+ "res_55",
+ "res_56",
+ "res_57",
+ "res_58",
+ "res_59",
+ "res_60",
+ "res_61",
+ "res_62",
+ "res_63",
+ "res_64",
+ "res_65",
+ "res_66",
+ "res_67",
+ "res_68",
+ "res_69",
+ "res_70",
+ "res_71",
+ "res_72",
+ "res_73",
+ "res_74",
+ "res_75",
+ "res_76",
+ "res_77",
+ "res_78",
+ "res_79",
+ "res_80",
+ "res_81",
+ "res_82",
+ "res_83",
+ "res_84",
+ "res_85",
+ "res_86",
+ "res_87",
+ "res_88",
+ "res_89",
+ "res_90",
+ "res_91",
+ "res_92",
+ "res_93",
+ "res_94",
+ "res_95",
+ "res_96",
+ "res_97",
+ "res_98",
+ "res_99",
+ "res_100",
+ "res_101",
+ "res_102",
+ "res_103",
+ "res_104",
+ "res_105",
+ "res_106",
+ "res_107",
+ "res_108",
+ "res_109",
+ "res_110",
+ "res_111",
+ "res_112",
+ "res_113",
+ "res_114",
+ "res_115",
+ "res_116",
+ "res_117",
+ "res_118",
+ "res_119",
+ "res_120",
+ "res_121",
+ "res_122",
+ "res_123",
+ "res_124",
+ "res_125",
+ "res_126",
+ "res_127",
+ "res_128",
+ "res_129",
+ "res_130",
+ "res_131",
+ "res_132",
+ "res_133",
+ "res_134",
+ "res_135",
+ "res_136",
+ "res_137",
+ "res_138",
+ "res_139",
+ "res_140",
+ "res_141",
+ "res_142",
+ "res_143",
+ "res_144",
+ "res_145",
+ "res_146",
+ "res_147",
+ "res_148",
+ "res_149",
+ "res_150",
+ "res_151",
+ "res_152",
+ "res_153",
+ "res_154",
+ "res_155",
+ "res_156",
+ "res_157",
+ "res_158",
+ "res_159",
+ "res_160",
+ "res_161",
+ "res_162",
+ "res_163",
+ "res_164",
+ "res_165",
+ "res_166",
+ "res_167",
+ "res_168",
+ "res_169",
+ "res_170",
+ "res_171",
+ "res_172",
+ "res_173",
+ "res_174",
+ "res_175",
+ "res_176",
+ "res_177",
+ "res_178",
+ "res_179",
+ "res_180",
+ "res_181",
+ "res_182",
+ "res_183",
+ "res_184",
+ "res_185",
+ "res_186",
+ "res_187",
+ "res_188",
+ "res_189",
+ "res_190",
+ "res_191",
+ "res_192",
+ "res_193",
+ "res_194",
+ "res_195",
+ "res_196",
+ "res_197",
+ "res_198",
+ "res_199",
+ "res_200",
+ "res_201",
+ "res_202",
+ "res_203",
+ "res_204",
+ "res_205",
+ "res_206",
+ "res_207",
+ "res_208",
+ "res_209",
+ "res_210",
+ "res_211",
+ "res_212",
+ "res_213",
+ "res_214",
+ "res_215",
+ "res_216",
+ "res_217",
+ "res_218",
+ "res_219",
+ "res_220",
+ "res_221",
+ "res_222",
+ "res_223",
+ "oem_224",
+ "oem_225",
+ "oem_226",
+ "oem_227",
+ "oem_228",
+ "oem_229",
+ "oem_230",
+ "oem_231",
+ "oem_232",
+ "oem_233",
+ "oem_234",
+ "oem_235",
+ "oem_236",
+ "oem_237",
+ "oem_238",
+ "oem_239",
+ "oem_240",
+ "oem_241",
+ "oem_242",
+ "oem_243",
+ "oem_244",
+ "oem_245",
+ "oem_246",
+ "oem_247",
+ "oem_248",
+ "oem_249",
+ "oem_250",
+ "oem_251",
+ "oem_252",
+ "oem_253",
+ "oem_254",
+ "oem_255",
+};
+
+static const char *unit_types[TYPES_ARRAY_SZ] = {
+ "none",
+ "unspec",
+ "celsius",
+ "fahrenheit",
+ "kelvin",
+ "volts",
+ "amps",
+ "watts",
+ "joules",
+ "coulombs",
+ "va",
+ "nits",
+ "lumens",
+ "lux",
+ "candelas",
+ "kpa",
+ "psi",
+ "newtons",
+ "cfm",
+ "rpm",
+ "hertz",
+ "seconds",
+ "minutes",
+ "hours",
+ "days",
+ "weeks",
+ "mils",
+ "inches",
+ "feet",
+ "cubic_inches",
+ "cubic_feet",
+ "meters",
+ "cubic_centimeters",
+ "cubic_meters",
+ "liters",
+ "fluid_ounces",
+ "radians",
+ "steradians",
+ "revolutions",
+ "cycles",
+ "gravities",
+ "ounces",
+ "pounds",
+ "foot_pounds",
+ "ounce_inches",
+ "gauss",
+ "gilberts",
+ "henries",
+ "farads",
+ "ohms",
+ "siemens",
+ "moles",
+ "becquerels",
+ "ppm",
+ "decibels",
+ "dba",
+ "dbc",
+ "grays",
+ "sieverts",
+ "color_temp_kelvin",
+ "bits",
+ "bytes",
+ "words",
+ "dwords",
+ "qwords",
+ "percentage",
+ "pascals",
+ "counts",
+ "grams",
+ "newton_meters",
+ "hits",
+ "misses",
+ "retries",
+ "overruns",
+ "underruns",
+ "collisions",
+ "packets",
+ "messages",
+ "chars",
+ "errors",
+ "corrected_err",
+ "uncorrectable_err",
+ "square_mils",
+ "square_inches",
+ "square_feet",
+ "square_centimeters",
+ "square_meters",
+ "radians_per_secs",
+ "beats_per_minute",
+ "meters_per_secs_squared",
+ "meters_per_secs",
+ "cubic_meter_per_secs",
+ "millimeters_mercury",
+ "radians_per_secs_squared",
+ "state",
+ "bps",
+ "res_96",
+ "res_97",
+ "res_98",
+ "res_99",
+ "res_100",
+ "res_101",
+ "res_102",
+ "res_103",
+ "res_104",
+ "res_105",
+ "res_106",
+ "res_107",
+ "res_108",
+ "res_109",
+ "res_110",
+ "res_111",
+ "res_112",
+ "res_113",
+ "res_114",
+ "res_115",
+ "res_116",
+ "res_117",
+ "res_118",
+ "res_119",
+ "res_120",
+ "res_121",
+ "res_122",
+ "res_123",
+ "res_124",
+ "res_125",
+ "res_126",
+ "res_127",
+ "res_128",
+ "res_129",
+ "res_130",
+ "res_131",
+ "res_132",
+ "res_133",
+ "res_134",
+ "res_135",
+ "res_136",
+ "res_137",
+ "res_138",
+ "res_139",
+ "res_140",
+ "res_141",
+ "res_142",
+ "res_143",
+ "res_144",
+ "res_145",
+ "res_146",
+ "res_147",
+ "res_148",
+ "res_149",
+ "res_150",
+ "res_151",
+ "res_152",
+ "res_153",
+ "res_154",
+ "res_155",
+ "res_156",
+ "res_157",
+ "res_158",
+ "res_159",
+ "res_160",
+ "res_161",
+ "res_162",
+ "res_163",
+ "res_164",
+ "res_165",
+ "res_166",
+ "res_167",
+ "res_168",
+ "res_169",
+ "res_170",
+ "res_171",
+ "res_172",
+ "res_173",
+ "res_174",
+ "res_175",
+ "res_176",
+ "res_177",
+ "res_178",
+ "res_179",
+ "res_180",
+ "res_181",
+ "res_182",
+ "res_183",
+ "res_184",
+ "res_185",
+ "res_186",
+ "res_187",
+ "res_188",
+ "res_189",
+ "res_190",
+ "res_191",
+ "res_192",
+ "res_193",
+ "res_194",
+ "res_195",
+ "res_196",
+ "res_197",
+ "res_198",
+ "res_199",
+ "res_200",
+ "res_201",
+ "res_202",
+ "res_203",
+ "res_204",
+ "res_205",
+ "res_206",
+ "res_207",
+ "res_208",
+ "res_209",
+ "res_210",
+ "res_211",
+ "res_212",
+ "res_213",
+ "res_214",
+ "res_215",
+ "res_216",
+ "res_217",
+ "res_218",
+ "res_219",
+ "res_220",
+ "res_221",
+ "res_222",
+ "res_223",
+ "res_224",
+ "res_225",
+ "res_226",
+ "res_227",
+ "res_228",
+ "res_229",
+ "res_230",
+ "res_231",
+ "res_232",
+ "res_233",
+ "res_234",
+ "res_235",
+ "res_236",
+ "res_237",
+ "res_238",
+ "res_239",
+ "res_240",
+ "res_241",
+ "res_242",
+ "res_243",
+ "res_244",
+ "res_245",
+ "res_246",
+ "res_247",
+ "res_248",
+ "res_249",
+ "res_250",
+ "res_251",
+ "res_252",
+ "res_253",
+ "res_254",
+ "oem_unit",
+};
+
static struct inode *stlmfs_get_inode(struct super_block *sb, umode_t mode)
{
struct inode *inode = new_inode(sb);
@@ -893,6 +1415,18 @@ DEFINE_TLM_CLASS(persistent_tlmo, "persistent", 0,
DEFINE_TLM_CLASS(value_tlmo, "value", 0,
S_IFREG | 0444, &de_read_fops, NULL);
+static inline struct dentry *
+stlmfs_lookup_by_name(struct dentry *parent, const char *dname)
+{
+ struct qstr qstr;
+
+ qstr.name = dname;
+ qstr.len = strlen(dname);
+ qstr.hash = full_name_hash(parent, qstr.name, qstr.len);
+
+ return d_lookup(parent, &qstr);
+}
+
static int scmi_telemetry_de_populate(struct super_block *sb,
struct scmi_tlm_setup *tsp,
struct dentry *parent,
@@ -1753,6 +2287,147 @@ static struct dentry *stlmfs_create_root_dentry(struct super_block *sb)
return dentry;
}
+static int scmi_telemetry_de_subdir_symlink(struct super_block *sb,
+ struct scmi_tlm_setup *tsp,
+ const struct scmi_telemetry_de *de,
+ struct dentry *parent)
+{
+ struct dentry *dentry;
+ struct inode *inode;
+
+ if (IS_ERR(parent))
+ return 0;
+
+ char *name __free(kfree) = kasprintf(GFP_KERNEL, "0x%08X[%s]",
+ de->info->id, (const char *)de->info->name);
+ if (!name)
+ return -ENOMEM;
+
+ char *link __free(kfree) =
+ kasprintf(GFP_KERNEL, "../../../../../des/0x%08X", de->info->id);
+ if (!link)
+ return -ENOMEM;
+
+ dentry = simple_start_creating(parent, name);
+ if (IS_ERR(dentry))
+ return PTR_ERR(dentry);
+
+ inode = stlmfs_get_inode(sb, S_IFLNK | 0777);
+ if (unlikely(!inode)) {
+ dev_err(tsp->dev,
+ "out of free dentries, cannot create '%s'", name);
+ return stlmfs_failed_creating(dentry);
+ }
+
+ inode->i_op = &simple_symlink_inode_operations;
+ inode->i_link = no_free_ptr(link);
+
+ d_make_persistent(dentry, inode);
+
+ simple_done_creating(dentry);
+
+ return 0;
+}
+
+static struct dentry *
+scmi_telemetry_topology_path_get(struct super_block *sb,
+ struct scmi_tlm_setup *tsp,
+ struct dentry *parent, const char *dname)
+{
+ struct dentry *dentry;
+
+ dentry = stlmfs_lookup_by_name(parent, dname);
+ if (!dentry) {
+ struct scmi_tlm_class *dir_tlm_cls __free(kfree) =
+ kzalloc(sizeof(*dir_tlm_cls), GFP_KERNEL);
+ if (!dir_tlm_cls)
+ return NULL;
+
+ dir_tlm_cls->name = kasprintf(GFP_KERNEL, "%s", dname);
+ if (!dir_tlm_cls->name)
+ return NULL;
+
+ dir_tlm_cls->mode = S_IFDIR | 0755;
+ dir_tlm_cls->flags = TLM_IS_DYNAMIC;
+
+ dentry = stlmfs_create_dentry(sb, tsp, parent,
+ dir_tlm_cls, NULL);
+ if (!IS_ERR(dentry))
+ retain_and_null_ptr(dir_tlm_cls);
+ }
+
+ return dentry;
+}
+
+static int scmi_telemetry_topology_add_node(struct super_block *sb,
+ struct scmi_tlm_instance *ti,
+ const struct scmi_telemetry_de *de)
+{
+ struct dentry *ctype, *cinst, *cunit, *dinst;
+ struct scmi_tlm_de_info *dei = de->info;
+ char inst_str[32];
+ int ret;
+
+ /* by_compo_type/<COMPO_TYPE_STR>/ */
+ ctype = scmi_telemetry_topology_path_get(sb, ti->tsp, ti->compo_dentry,
+ compo_types[dei->compo_type]);
+ if (!ctype)
+ return -ENOMEM;
+
+ /* by_compo_type/<COMPO_TYPE_STR>/<N>/ */
+ snprintf(inst_str, 32, "%u", dei->compo_instance_id);
+ cinst = scmi_telemetry_topology_path_get(sb, ti->tsp, ctype, inst_str);
+ dput(ctype);
+ if (!cinst)
+ return -ENOMEM;
+
+ /* by_compo_type/<COMPO_TYPE_STR>/<N>/<DE_UNIT_TYPE_STR>/ */
+ cunit = scmi_telemetry_topology_path_get(sb, ti->tsp, cinst,
+ unit_types[dei->unit]);
+ dput(cinst);
+ if (!cunit)
+ return -ENOMEM;
+
+ /* by_compo_type/<COMPO_TYPE_STR>/<N>/<DE_UNIT_TYPE_STR>/<N> */
+ snprintf(inst_str, 32, "%u", dei->instance_id);
+ dinst = scmi_telemetry_topology_path_get(sb, ti->tsp, cunit, inst_str);
+ dput(cunit);
+ if (!dinst)
+ return -ENOMEM;
+
+ ret = scmi_telemetry_de_subdir_symlink(sb, ti->tsp, de, dinst);
+ dput(dinst);
+
+ return ret;
+}
+
+DEFINE_TLM_CLASS(compo_dir_cls, "by-components", 0, S_IFDIR | 0700, NULL, NULL);
+
+static int scmi_telemetry_topology_view_add(struct scmi_tlm_instance *ti)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct device *dev = tsp->dev;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (!rinfo || !rinfo->fully_enumerated)
+ return -ENODEV;
+
+ ti->compo_dentry =
+ stlmfs_create_dentry(ti->sb, tsp, ti->top_dentry, &compo_dir_cls, NULL);
+
+ for (int i = 0; i < rinfo->num_des; i++) {
+ int ret;
+
+ ret = scmi_telemetry_topology_add_node(ti->sb, ti, rinfo->des[i]);
+ if (ret)
+ dev_err(dev, "Fail to add node %s to topology. Skip.\n",
+ rinfo->des[i]->info->name);
+ }
+
+ return 0;
+}
+
static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
{
struct scmi_tlm_setup *tsp = ti->tsp;
@@ -1808,6 +2483,12 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
ti->top_cls.name);
}
+ ret = scmi_telemetry_topology_view_add(ti);
+ if (ret)
+ dev_warn(ti->tsp->dev,
+ "Failed to create topology view for instance %s.\n",
+ ti->top_cls.name);
+
return 0;
}
--
2.54.0
^ permalink raw reply related
* [PATCH v4 24/31] fs/stlmfs: Document alternative ioctl based binary interface
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Document the additionally provided special files and their usage in the
context of the alternative binary ioctl-based interface.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
Documentation/filesystems/stlmfs.rst | 24 ++++++++++++++++++++++++
1 file changed, 24 insertions(+)
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
index a15da85b9971..0c7b7c006709 100644
--- a/Documentation/filesystems/stlmfs.rst
+++ b/Documentation/filesystems/stlmfs.rst
@@ -143,6 +143,7 @@ create the following directory structure::
|-- all_des_enable
|-- all_des_tstamp_enable
|-- available_update_intervals_ms
+ |-- control
|-- current_update_interval_ms
|-- de_implementation_version
|-- des/
@@ -160,6 +161,10 @@ create the following directory structure::
|-- tlm_enable
`-- version
+.. Note::
+ The control/ special file can be used to use the alternative
+ binary interface described in include/uapi/linux/scmi.h
+
Each subdirectory is defined as follows.
des/
@@ -220,6 +225,7 @@ values, as in::
scmi_tlm_0/groups/0/
|-- available_update_intervals_ms
|-- composing_des
+ |-- control
|-- current_update_interval_ms
|-- des_bulk_read
|-- des_single_sample_read
@@ -227,3 +233,21 @@ values, as in::
|-- intervals_discrete
`-- tstamp_enable
+Alternative Binary Interfaces - Special files
+=============================================
+
+Special files are populated across the filesystem so as to implement the support
+of more performant alternative binary interfaces that can be used instead of the
+main human readable ABI.
+
+IOCTLs Interface
+----------------
+
+The ioctl-based interface is detailed in::
+
+ include/uapi/linux/scmi.h
+
+The filesystem provides special files named *control/* to be used with the
+ioctl interface mentioned above: note that the behaviour of some of the ioctls
+is dependent on which *control/* file is used to invoke them (as detailed in the
+UAPI header above).
--
2.54.0
^ permalink raw reply related
* [PATCH v4 23/31] firmware: arm_scmi: stlmfs: Add ioctls support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Extend the filesystem based interface with special 'control' files that can
be used to configure and retrieve SCMI Telemetry data in binary form using
the ioctls-based ABI described in uapi/linux/scmi.h.
This alternative ABI is meant to provide a more performant access to SCMI
Telemetry configuration and data events, without the hassle of navigating
the human readable VFS based intwerface.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- make FS entries world-Readable and user-Writable where applicable
- consider default umask when defining file perms
- update Telemetry ioctl state query caller with tracking data
- added stlmfs tag in $SUBJECT
v1 --> v2
- Use new res_get() operation which use new resource accessors
- Use new de_lookup() tlm_ops
- Using cleanup.h
- use new interval.num_intervals
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 404 ++++++++++++++++++
1 file changed, 404 insertions(+)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index f4d284335ac0..720930f6bcd1 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -26,6 +26,8 @@
#include <linux/types.h>
#include <linux/uaccess.h>
+#include <uapi/linux/scmi.h>
+
#define TLM_FS_MAGIC 0x75C01C80
#define TLM_FS_NAME "stlmfs"
#define TLM_FS_MNT "arm_telemetry"
@@ -1121,6 +1123,406 @@ DEFINE_TLM_CLASS(grp_available_interval_tlmo, "available_update_intervals_ms",
DEFINE_TLM_CLASS(grp_intervals_discrete_tlmo, "intervals_discrete",
TLM_IS_GROUP, S_IFREG | 0444, &intrv_discrete_fops, NULL);
+static long
+scmi_tlm_info_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ const struct scmi_telemetry_info *info = tlmi->priv;
+ void * __user uptr = (void * __user)arg;
+
+ if (copy_to_user(uptr, &info->base, sizeof(info->base)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_intervals_get_ioctl(const struct scmi_tlm_inode *tlmi,
+ unsigned long arg, bool is_group)
+{
+ struct scmi_tlm_intervals ivs, *tlm_ivs;
+ void * __user uptr = (void * __user)arg;
+
+ if (copy_from_user(&ivs, uptr, sizeof(ivs)))
+ return -EFAULT;
+
+ if (!is_group) {
+ const struct scmi_telemetry_info *info = tlmi->priv;
+
+ tlm_ivs = info->intervals;
+ } else {
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+
+ tlm_ivs = grp->intervals;
+ }
+
+ if (ivs.num_intervals != tlm_ivs->num_intervals)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, tlm_ivs,
+ sizeof(*tlm_ivs) + sizeof(u32) * ivs.num_intervals))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_de_config_set_ioctl(const struct scmi_tlm_inode *tlmi,
+ unsigned long arg, bool all)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ struct scmi_tlm_de_config tcfg = {};
+ int ret;
+
+ if (copy_from_user(&tcfg, uptr, sizeof(tcfg)))
+ return -EFAULT;
+
+ if (!all)
+ return tsp->ops->state_set(tsp->ph, false, tcfg.id,
+ (bool *)&tcfg.enable,
+ (bool *)&tcfg.t_enable);
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ for (int i = 0; i < rinfo->num_des; i++) {
+ ret = tsp->ops->state_set(tsp->ph, false,
+ rinfo->des[i]->info->id,
+ (bool *)&tcfg.enable,
+ (bool *)&tcfg.t_enable);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
+static long
+scmi_tlm_de_config_get_ioctl(const struct scmi_tlm_inode *tlmi,
+ unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_de_config tcfg = {};
+ int ret;
+
+ if (copy_from_user(&tcfg, uptr, sizeof(tcfg)))
+ return -EFAULT;
+
+ ret = tsp->ops->state_get(tsp->ph, &tcfg.id,
+ (bool *)&tcfg.enable, (bool *)&tcfg.t_enable);
+ if (ret)
+ return ret;
+
+ if (copy_to_user(uptr, &tcfg, sizeof(tcfg)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_config_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg,
+ bool is_group)
+{
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_config cfg;
+
+ if (!is_group) {
+ const struct scmi_telemetry_info *info = tlmi->priv;
+
+ cfg.enable = !!info->enabled;
+ cfg.current_update_interval = info->active_update_interval;
+ } else {
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+
+ cfg.enable = !!grp->enabled;
+ cfg.t_enable = !!grp->tstamp_enabled;
+ cfg.current_update_interval = grp->active_update_interval;
+ }
+
+ if (copy_to_user(uptr, &cfg, sizeof(cfg)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_config_set_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg,
+ bool is_group)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_config cfg = {};
+ bool grp_ignore;
+ int res_id;
+
+ if (copy_from_user(&cfg, uptr, sizeof(cfg)))
+ return -EFAULT;
+
+ if (!is_group) {
+ res_id = SCMI_TLM_GRP_INVALID;
+ grp_ignore = true;
+ } else {
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+ int ret;
+
+ res_id = grp->info->id;
+ grp_ignore = false;
+ ret = tsp->ops->state_set(tsp->ph, true, res_id,
+ (bool *)&cfg.enable,
+ (bool *)&cfg.t_enable);
+ if (ret)
+ return ret;
+ }
+
+ return tsp->ops->collection_configure(tsp->ph, res_id, grp_ignore,
+ (bool *)&cfg.enable,
+ &cfg.current_update_interval,
+ NULL);
+}
+
+static long
+scmi_tlm_de_info_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ const struct scmi_telemetry_de *de;
+ struct scmi_tlm_de_info dei;
+
+ if (copy_from_user(&dei, uptr, sizeof(dei)))
+ return -EFAULT;
+
+ de = tsp->ops->de_lookup(tsp->ph, dei.id);
+ if (!de)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, de->info, sizeof(*de->info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_des_list_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ const struct scmi_telemetry_res_info *rinfo;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_des_list dsl;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (copy_from_user(&dsl, uptr, sizeof(dsl)))
+ return -EFAULT;
+
+ if (dsl.num_des < rinfo->num_des)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, &rinfo->num_des, sizeof(rinfo->num_des)))
+ return -EFAULT;
+
+ if (copy_to_user(uptr + sizeof(rinfo->num_des), rinfo->dei_store,
+ rinfo->num_des * sizeof(*rinfo->dei_store)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_de_value_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_de_sample sample;
+ int ret;
+
+ if (copy_from_user(&sample, uptr, sizeof(sample)))
+ return -EFAULT;
+
+ ret = tsp->ops->de_data_read(tsp->ph,
+ (struct scmi_telemetry_de_sample *)&sample);
+ if (ret)
+ return ret;
+
+ if (copy_to_user(uptr, &sample, sizeof(sample)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_grp_info_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+ void * __user uptr = (void * __user)arg;
+
+ if (copy_to_user(uptr, grp->info, sizeof(*grp->info)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_grp_desc_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+ unsigned int num_des = grp->info->num_des;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_grp_desc grp_desc;
+
+ if (copy_from_user(&grp_desc, uptr, sizeof(grp_desc)))
+ return -EFAULT;
+
+ if (grp_desc.num_des < num_des)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, &num_des, sizeof(num_des)))
+ return -EFAULT;
+
+ if (copy_to_user(uptr + sizeof(num_des), grp->des,
+ sizeof(*grp->des) * num_des))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long
+scmi_tlm_grps_list_get_ioctl(const struct scmi_tlm_inode *tlmi, unsigned long arg)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ const struct scmi_telemetry_res_info *rinfo;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_grps_list gsl;
+
+ if (copy_from_user(&gsl, uptr, sizeof(gsl)))
+ return -EFAULT;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (gsl.num_grps < rinfo->num_groups)
+ return -EINVAL;
+
+ if (copy_to_user(uptr, &rinfo->num_groups, sizeof(rinfo->num_groups)))
+ return -EFAULT;
+
+ if (copy_to_user(uptr + sizeof(rinfo->num_groups), rinfo->grps_store,
+ rinfo->num_groups * sizeof(*rinfo->grps_store)))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long scmi_tlm_des_read_ioctl(const struct scmi_tlm_inode *tlmi,
+ unsigned long arg, bool single,
+ bool is_group)
+{
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ void * __user uptr = (void * __user)arg;
+ struct scmi_tlm_data_read bulk;
+ int ret, grp_id = SCMI_TLM_GRP_INVALID;
+
+ if (copy_from_user(&bulk, uptr, sizeof(bulk)))
+ return -EFAULT;
+
+ struct scmi_tlm_data_read *bulk_ptr __free(kfree) =
+ kzalloc(struct_size(bulk_ptr, samples, bulk.num_samples),
+ GFP_KERNEL);
+ if (!bulk_ptr)
+ return -ENOMEM;
+
+ if (is_group) {
+ const struct scmi_telemetry_group *grp = tlmi->priv;
+
+ grp_id = grp->info->id;
+ }
+
+ bulk_ptr->num_samples = bulk.num_samples;
+ if (!single)
+ ret = tsp->ops->des_bulk_read(tsp->ph, grp_id,
+ &bulk_ptr->num_samples,
+ (struct scmi_telemetry_de_sample *)bulk_ptr->samples);
+ else
+ ret = tsp->ops->des_sample_get(tsp->ph, grp_id,
+ &bulk_ptr->num_samples,
+ (struct scmi_telemetry_de_sample *)bulk_ptr->samples);
+ if (ret)
+ return ret;
+
+ if (copy_to_user(uptr, bulk_ptr, sizeof(*bulk_ptr) +
+ bulk_ptr->num_samples * sizeof(bulk_ptr->samples[0])))
+ return -EFAULT;
+
+ return 0;
+}
+
+static long scmi_tlm_unlocked_ioctl(struct file *filp, unsigned int cmd,
+ unsigned long arg)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ bool is_group = IS_GROUP(tlmi->cls->flags);
+
+ switch (cmd) {
+ case SCMI_TLM_GET_INFO:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_info_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_CFG:
+ return scmi_tlm_config_get_ioctl(tlmi, arg, is_group);
+ case SCMI_TLM_SET_CFG:
+ return scmi_tlm_config_set_ioctl(tlmi, arg, is_group);
+ case SCMI_TLM_GET_INTRVS:
+ return scmi_tlm_intervals_get_ioctl(tlmi, arg, is_group);
+ case SCMI_TLM_GET_DE_CFG:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_de_config_get_ioctl(tlmi, arg);
+ case SCMI_TLM_SET_DE_CFG:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_de_config_set_ioctl(tlmi, arg, false);
+ case SCMI_TLM_GET_DE_INFO:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_de_info_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_DE_LIST:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_des_list_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_DE_VALUE:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_de_value_get_ioctl(tlmi, arg);
+ case SCMI_TLM_SET_ALL_CFG:
+ return scmi_tlm_de_config_set_ioctl(tlmi, arg, true);
+ case SCMI_TLM_GET_GRP_LIST:
+ if (is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_grps_list_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_GRP_INFO:
+ if (!is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_grp_info_get_ioctl(tlmi, arg);
+ case SCMI_TLM_GET_GRP_DESC:
+ if (!is_group)
+ return -EOPNOTSUPP;
+ return scmi_tlm_grp_desc_get_ioctl(tlmi, arg);
+ case SCMI_TLM_SINGLE_SAMPLE:
+ return scmi_tlm_des_read_ioctl(tlmi, arg, true, is_group);
+ case SCMI_TLM_BULK_READ:
+ return scmi_tlm_des_read_ioctl(tlmi, arg, false, is_group);
+ default:
+ return -ENOTTY;
+ }
+}
+
+static const struct file_operations scmi_tlm_ctrl_fops = {
+ .owner = THIS_MODULE,
+ .open = nonseekable_open,
+ .unlocked_ioctl = scmi_tlm_unlocked_ioctl,
+};
+
+DEFINE_TLM_CLASS(ctrl_tlmo, "control", 0,
+ S_IFREG | 0666, &scmi_tlm_ctrl_fops, NULL);
+DEFINE_TLM_CLASS(grp_ctrl_tlmo, "control", TLM_IS_GROUP,
+ S_IFREG | 0666, &scmi_tlm_ctrl_fops, NULL);
+
static int scmi_telemetry_groups_initialize(struct scmi_tlm_instance *ti)
{
const struct scmi_telemetry_res_info *rinfo;
@@ -1160,6 +1562,7 @@ static int scmi_telemetry_groups_initialize(struct scmi_tlm_instance *ti)
stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
&grp_composing_des_tlmo, grp->des_str);
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_ctrl_tlmo, grp);
stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_data_tlmo, grp);
if (ti->info->single_read_support)
stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
@@ -1375,6 +1778,7 @@ static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
if (ti->info->single_read_support)
stlmfs_create_dentry(sb, tsp, ti->top_dentry,
&single_sample_tlmo, ti->info);
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &ctrl_tlmo, ti->info);
ti->des_dentry =
stlmfs_create_dentry(sb, tsp, ti->top_dentry, &des_dir_cls, NULL);
ti->grps_dentry =
--
2.54.0
^ permalink raw reply related
* [PATCH v4 22/31] fs/stlmfs: Document ARM SCMI Telemetry FS mount options
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi, Jonathan Corbet, Shuah Khan
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Detail ARM SCMI Telemetry filesystem available mount options.
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Cc: linux-doc@vger.kernel.org
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
Documentation/filesystems/stlmfs.rst | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
index 123e0e68e041..a15da85b9971 100644
--- a/Documentation/filesystems/stlmfs.rst
+++ b/Documentation/filesystems/stlmfs.rst
@@ -109,6 +109,25 @@ sense to allow this FS to be mounted inside a container.
All files are created world readable and, where needed for configuration,
owner writable.
+Mount Options
+=============
+
+This FS supports the typical mount options needed to modify, at mount time, the
+ownership of the root and all of the underlying inodes:
+
+ - uid: id of the owner of the root inode and all of the files subsequently
+ created under it
+
+ - gid: id of the group of the root inode and all of the files subsequently
+ created under it
+
+ - umask: a standard umask filter to be applied to user/group/other: defaults
+ to 00222
+
+Note that all of the above options are explicitly designed NOT to support
+a remount operation, so as not have surprising effects on permissions of
+already discovered/created telemetry files.
+
Usage
=====
--
2.54.0
^ permalink raw reply related
* [PATCH v4 21/31] firmware: arm_scmi: stlmfs: Add basic mount options
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add mount options to choose different uid/gid/umask for all the created
files; reject handling changes to these options while remounting.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
.../firmware/arm_scmi/scmi_system_telemetry.c | 146 +++++++++++++++++-
1 file changed, 143 insertions(+), 3 deletions(-)
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
index 567585dfb036..f4d284335ac0 100644
--- a/drivers/firmware/arm_scmi/scmi_system_telemetry.c
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -34,6 +34,32 @@
#define MAX_AVAILABLE_INTERV_CHAR_LENGTH 25
#define MAX_BULK_LINE_CHAR_LENGTH 64
+enum {
+ Opt_uid,
+ Opt_gid,
+ Opt_umask,
+};
+
+static const struct fs_parameter_spec stlmfs_param_spec[] = {
+ fsparam_uid("uid", Opt_uid),
+ fsparam_gid("gid", Opt_gid),
+ fsparam_u32oct("umask", Opt_umask),
+ {}
+};
+
+struct stlmfs_fs_context {
+ unsigned int opts;
+ kuid_t uid;
+ kgid_t gid;
+ umode_t umask;
+};
+
+struct stlmfs_sb_info {
+ kuid_t uid;
+ kgid_t gid;
+ umode_t umask;
+};
+
static struct kmem_cache *stlmfs_inode_cachep;
static DEFINE_MUTEX(stlmfs_mtx);
@@ -202,10 +228,12 @@ static struct inode *stlmfs_get_inode(struct super_block *sb, umode_t mode)
struct inode *inode = new_inode(sb);
if (inode) {
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
inode->i_ino = get_next_ino();
- inode->i_uid = GLOBAL_ROOT_UID;
- inode->i_gid = GLOBAL_ROOT_GID;
- inode->i_mode = mode & ~SCMI_TLM_DEFAULT_UMASK;
+ inode->i_uid = sbi->uid;
+ inode->i_gid = sbi->gid;
+ inode->i_mode = mode & ~sbi->umask;
simple_inode_init_ts(inode);
}
@@ -1282,10 +1310,25 @@ static void stlmfs_free_inode(struct inode *inode)
kmem_cache_free(stlmfs_inode_cachep, tlmi);
}
+static int stlmfs_show_options(struct seq_file *seq, struct dentry *root)
+{
+ struct stlmfs_sb_info *sbi = root->d_sb->s_fs_info;
+
+ if (!uid_eq(sbi->uid, GLOBAL_ROOT_UID))
+ seq_printf(seq, ",uid=%u", from_kuid_munged(&init_user_ns, sbi->uid));
+ if (!gid_eq(sbi->gid, GLOBAL_ROOT_GID))
+ seq_printf(seq, ",gid=%u", from_kgid_munged(&init_user_ns, sbi->gid));
+ if (sbi->umask != SCMI_TLM_DEFAULT_UMASK)
+ seq_printf(seq, ",umask=%04u", sbi->umask);
+
+ return 0;
+}
+
static const struct super_operations tlm_sops = {
.statfs = simple_statfs,
.alloc_inode = stlmfs_alloc_inode,
.free_inode = stlmfs_free_inode,
+ .show_options = stlmfs_show_options,
};
static struct dentry *stlmfs_create_root_dentry(struct super_block *sb)
@@ -1366,10 +1409,26 @@ static int scmi_telemetry_instance_register(struct super_block *sb,
static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
{
+ struct stlmfs_fs_context *ctx;
struct scmi_tlm_instance *ti;
struct dentry *root_dentry;
int ret;
+ /* Bail out if already initialized */
+ if (sb->s_fs_info)
+ return 0;
+
+ struct stlmfs_sb_info *sbi __free(kfree) =
+ kzalloc(sizeof(*sbi), GFP_KERNEL);
+ if (!sbi)
+ return -ENOMEM;
+
+ ctx = fc->fs_private;
+ sbi->uid = ctx->uid;
+ sbi->gid = ctx->gid;
+ sbi->umask = ctx->umask;
+
+ sb->s_fs_info = sbi;
sb->s_magic = TLM_FS_MAGIC;
sb->s_blocksize = PAGE_SIZE;
sb->s_blocksize_bits = PAGE_SHIFT;
@@ -1379,6 +1438,7 @@ static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
if (IS_ERR(root_dentry))
return PTR_ERR(root_dentry);
+ retain_and_null_ptr(sbi);
sb->s_root = root_dentry;
mutex_lock(&stlmfs_mtx);
@@ -1396,17 +1456,93 @@ static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
return 0;
}
+static void stlmfs_free(struct fs_context *fc)
+{
+ struct stlmfs_fs_context *ctx;
+
+ ctx = fc->fs_private;
+
+ kfree(ctx);
+}
+
static int stlmfs_get_tree(struct fs_context *fc)
{
return get_tree_single(fc, stlmfs_fill_super);
}
+static int stlmfs_parse_param(struct fs_context *fc, struct fs_parameter *param)
+{
+ struct stlmfs_fs_context *ctx;
+ struct fs_parse_result result;
+ int opt;
+
+ opt = fs_parse(fc, stlmfs_param_spec, param, &result);
+ if (opt < 0)
+ return opt;
+
+ ctx = fc->fs_private;
+
+ switch (opt) {
+ case Opt_uid:
+ if (!kuid_has_mapping(fc->user_ns, result.uid))
+ return invalfc(fc, "Invalid uid");
+ ctx->uid = result.uid;
+ ctx->opts |= BIT(Opt_uid);
+ break;
+ case Opt_gid:
+ if (!kgid_has_mapping(fc->user_ns, result.gid))
+ return invalfc(fc, "Invalid gid");
+ ctx->gid = result.gid;
+ ctx->opts |= BIT(Opt_gid);
+ break;
+ case Opt_umask:
+ ctx->umask = result.uint_32 & 07777;
+ ctx->opts |= BIT(Opt_umask);
+ break;
+ default:
+ return -ENOPARAM;
+ }
+
+ return 0;
+}
+
+static int stlmfs_reconfigure(struct fs_context *fc)
+{
+ struct stlmfs_fs_context *ctx = fc->fs_private;
+
+ sync_filesystem(fc->root->d_sb);
+
+ if (ctx->opts & BIT(Opt_uid))
+ return invalfc(fc, "uid cannot be changed on remount");
+ if (ctx->opts & BIT(Opt_gid))
+ return invalfc(fc, "gid cannot be changed on remount");
+ if (ctx->opts & BIT(Opt_umask))
+ return invalfc(fc, "umask cannot be changed on remount");
+
+ return 0;
+}
+
static const struct fs_context_operations stlmfs_fc_ops = {
.get_tree = stlmfs_get_tree,
+ .parse_param = stlmfs_parse_param,
+ .free = stlmfs_free,
+ .reconfigure = stlmfs_reconfigure,
};
static int stlmfs_init_fs_context(struct fs_context *fc)
{
+ struct stlmfs_fs_context *ctx;
+
+ ctx = kzalloc_obj(*ctx);
+ if (!ctx)
+ return -ENOMEM;
+
+ /* defaults */
+ ctx->uid = GLOBAL_ROOT_UID;
+ ctx->gid = GLOBAL_ROOT_GID;
+ ctx->umask = SCMI_TLM_DEFAULT_UMASK;
+
+ fc->fs_private = ctx;
fc->ops = &stlmfs_fc_ops;
return 0;
@@ -1414,11 +1550,15 @@ static int stlmfs_init_fs_context(struct fs_context *fc)
static void stlmfs_kill_sb(struct super_block *sb)
{
+ struct stlmfs_sb_info *sbi = sb->s_fs_info;
+
mutex_lock(&stlmfs_mtx);
stlmfs_sb = NULL;
mutex_unlock(&stlmfs_mtx);
kill_anon_super(sb);
+
+ kfree(sbi);
}
static struct file_system_type scmi_telemetry_fs = {
--
2.54.0
^ permalink raw reply related
* [PATCH v4 20/31] fs/stlmfs: Document ARM SCMI Telemetry filesystem
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi, Jonathan Corbet, Shuah Khan
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Introduce initial ARM SCMI Telemetry filesystem documentation.
Cc: Jonathan Corbet <corbet@lwn.net>
Cc: Shuah Khan <skhan@linuxfoundation.org>
Cc: linux-doc@vger.kernel.org
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- refactored mount description
v2 --> v3
- changed tstamp_exp to tstamp_rate
---
Documentation/filesystems/stlmfs.rst | 210 +++++++++++++++++++++++++++
1 file changed, 210 insertions(+)
create mode 100644 Documentation/filesystems/stlmfs.rst
diff --git a/Documentation/filesystems/stlmfs.rst b/Documentation/filesystems/stlmfs.rst
new file mode 100644
index 000000000000..123e0e68e041
--- /dev/null
+++ b/Documentation/filesystems/stlmfs.rst
@@ -0,0 +1,210 @@
+.. SPDX-License-Identifier: GPL-2.0
+
+=============================================
+STLMFS - Arm SCMI Telemetry Pseudo Filesystem
+=============================================
+
+.. contents::
+
+Overview
+========
+
+ARM SCMI is a System and Configuration Management protocol, based on a
+client-server model, that defines a number of messages that allows a
+client/agent like Linux to discover, configure and make use of services
+provided by the server/platform firmware.
+
+SCMI v4.0 introduced support for System Telemetry, through which an agent
+can dynamically enumerate configure and collect Telemetry Data Events (DE)
+exposed by the platform.
+
+This filesystem, in turn, exposes to userspace the set of discovered DEs
+allowing for their configuration and retrieval.
+
+Rationale
+=========
+
+**Why not using SysFS/KernFS or DebugFS ?**
+
+The provided userspace interface aims to satisfy 2 main concurrent
+requirements:
+
+ - expose an FS-based human-readable interface that can be used to
+ discover, configure and access Telemetry data directly easily also from
+ the shell without any special tool
+
+ - allow also alternative machine-friendly, more-performant, binary
+ interfaces that can be used by custom tools without the overhead of
+ multiple accesses through the VFS layers and the hassle of navigating
+ vast filesystem tree structures
+
+All of the above is meant to be available on production systems, not
+simply as a tool for development or testing, so debugFS is NOT an option
+here.
+
+An initial design based on SysFS and chardev/ioctl based interfaces was
+dropped in favour of this full-fledged filesystem implementation since:
+
+- SysFS is a standard way to expose device related properties using a few
+ common helpers built on kernfs; this means, though, that unfortunately in
+ our scenario we would have to generate a dummy simple device for each
+ discovered DE.
+ This by itself seems an abuse of the SysFS framework, but even ignoring
+ this, the sheer number of potentially discoverable DEs (in the order of
+ tens of thousands easily) would have led to the creation of a sensibly
+ vast number of dummy DE devices.
+
+- SysFS usage itself has its well-known constraints and best practices,
+ like the one-file/one-value rule, that hardly cope with SCMI Telemetry
+ needs.
+
+- The need to implement more complex file operations (ioctls/mmap) in
+ order to support the alternative binary interfaces does not fit with
+ SysFS/kernFS facilities.
+
+- Given the nature of the Telemetry protocol, the hybrid approach with
+ chardev/ioctl was itself problematic: on one side being upper-limited
+ in the number of chardev potentially created by the minor numbers
+ availability, on the other side the hassle of having to maintain a
+ completely different interface on the side of a FS based one.
+
+Design
+======
+
+STLMFS is a pseudo filesystem used to expose ARM SCMI Telemetry data
+discovered dynamically at run-time via SCMI.
+
+Inodes are all dynamically created at mount-time from a dedicated
+kmem_cache based on the gathered available SCMI Telemetry information.
+
+Since inodes represent the discovered Telemetry entities, which in turn are
+statically defined at the platform level and immutable throughout the same
+session (boot), allocated inodes are freed only at unmount-time and the
+user is not allowed to delete or create any kind of file within the STLMFS
+filesystem after mount has completed.
+
+A single instance of STLMFS is created at the filesystem level, using
+get_tree_single(), given that the same SCMI backend entities will be
+involved no matter how many times you mount it.
+
+STLMFS configurations gets appplied by issuing the related SCMI commands to
+the backend SCMI platform server: for such reason any configuration applied
+by this FS interface will survive the unmount or the unload of the module, but
+not a reboot.
+
+Mountpoints
+===========
+
+A pre-defined mountpoint is available at::
+
+ /sys/fs/arm_telemetry/
+
+The filesystem can be typically mounted with::
+
+ mount -t stlmfs none /sys/fs/arm_telemetry
+
+It does NOT support namespaces (no FS_USERNS_MOUNT) since it would NOT make
+sense to allow this FS to be mounted inside a container.
+
+All files are created world readable and, where needed for configuration,
+owner writable.
+
+Usage
+=====
+
+.. Note::
+ See Documentation/ABI/testing/stlmfs for a detailed description of
+ this ABI.
+
+Once mounted the FS will proceed to create a top subdirectory for each of the
+discovered SCMI Telemetry instances named as 'tlm_<N>' under which it will
+create the following directory structure::
+
+ /sys/fs/arm_telemetry/tlm_0/
+ |-- all_des_enable
+ |-- all_des_tstamp_enable
+ |-- available_update_intervals_ms
+ |-- current_update_interval_ms
+ |-- de_implementation_version
+ |-- des/
+ | |-- ...
+ | |-- ...
+ | `-- ...
+ |-- des_bulk_read
+ |-- des_single_sample_read
+ |-- groups
+ | |-- ...
+ | |-- ...
+ | `-- ...
+ |-- intervals_discrete
+ |-- reset
+ |-- tlm_enable
+ `-- version
+
+Each subdirectory is defined as follows.
+
+des/
+----
+A subtree containing in turn one subdirectory for each discovered DE and
+named by Data Event ID in hexadecimal form as in::
+
+ |-- des
+ | |-- 0x00000000
+ | |-- 0x00000016
+ | |-- 0x00001010
+ | |-- 0x0000A000
+ | |-- 0x0000A001
+ | |-- 0x0000A002
+ | |-- 0x0000A005
+ | |-- ..........
+ | |-- ..........
+ | |-- 0x0000A007
+ | |-- 0x0000A008
+ | |-- 0x0000A00A
+ | |-- 0x0000A00B
+ | |-- 0x0000A00C
+ | `-- 0x0000A010
+
+where each dedicated DE subdirectory in turn will contain files used to
+describe some DE characteristics, configure it, or read its current data
+value as in::
+
+ tlm_0/des/0xA001/
+ |-- compo_instance_id
+ |-- compo_type
+ |-- enable
+ |-- instance_id
+ |-- name
+ |-- persistent
+ |-- tstamp_enable
+ |-- tstamp_rate
+ |-- type
+ |-- unit
+ |-- unit_exp
+ `-- value
+
+groups/
+-------
+
+An optional subtree containing in turn one subdirectory for each discovered
+Group and named by Group ID as in::
+
+ |-- groups
+ | |-- 0
+ | |-- ..
+ | `-- 1
+
+where each dedicated GROUP subdirectory in turn will contain files used to
+describe some Group characteristics, configure it, or read its current data
+values, as in::
+
+ scmi_tlm_0/groups/0/
+ |-- available_update_intervals_ms
+ |-- composing_des
+ |-- current_update_interval_ms
+ |-- des_bulk_read
+ |-- des_single_sample_read
+ |-- enable
+ |-- intervals_discrete
+ `-- tstamp_enable
+
--
2.54.0
^ permalink raw reply related
* [PATCH v4 19/31] firmware: arm_scmi: stlmfs: Add System Telemetry filesystem driver
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add a new SCMI System Telemetry driver which gathers platform Telemetry
data through the new the SCMI Telemetry protocol and expose all of the
discovered Telemetry data events on a dedicated pseudo-filesystem that
can be used to interactively configure SCMI Telemetry and access its
provided data.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
v3 --> v4
- make FS entries world-Readable and user-Writable where applicable
- drop inode_init_owner, use static uid/gid/umask
- use kzalloc_obj
- use octal permissions
- added stlmfs tag in $SUBJECT
- changed des/0x<NNNN>/value to -> <tstamp> <value>
- hide single_sample_read entries when NOT supported by platform
- generalize and refactor tlm_priv fops: data initialze now at open
- add a .remove function to cleanup properly also on unbind
v2 --> v3
- change from tstamp_exp to tstamp_rate entry
- use new interval.num_intervals
- addded a few more comments
v1 --> v2
- Harden System Telemetry writes, DO report errors
- New 'secs[, <exp>]' for current_interval_update_ms
- Use new mount_api based on fs_context
- Use new res_get() operation to make use of new accessors
- Move des/groups enumeration to mount time
- Support partial out-of-spec FW lacking some cmds (best effort)
- Reworked init/exit sequence
- Using dev_err_probe
- Reworked probing races handling
- Avoid disabling telemetry on module removal and drop remove() code
---
drivers/firmware/arm_scmi/Kconfig | 10 +
drivers/firmware/arm_scmi/Makefile | 1 +
.../firmware/arm_scmi/scmi_system_telemetry.c | 1493 +++++++++++++++++
3 files changed, 1504 insertions(+)
create mode 100644 drivers/firmware/arm_scmi/scmi_system_telemetry.c
diff --git a/drivers/firmware/arm_scmi/Kconfig b/drivers/firmware/arm_scmi/Kconfig
index 06d2319420a0..1fc9182224cc 100644
--- a/drivers/firmware/arm_scmi/Kconfig
+++ b/drivers/firmware/arm_scmi/Kconfig
@@ -113,4 +113,14 @@ config ARM_SCMI_POWER_CONTROL
called scmi_power_control. Note this may needed early in boot to catch
early shutdown/reboot SCMI requests.
+config ARM_SCMI_SYSTEM_TELEMETRY
+ tristate "SCMI System Telemetry driver"
+ depends on ARM_SCMI_PROTOCOL || (COMPILE_TEST && OF)
+ help
+ This enables SCMI Systemn Telemetry support that allows userspace to
+ retrieve ARM Telemetry data made available via SCMI.
+
+ This driver can also be built as a module. If so, the module will be
+ called scmi_system_telemetry.
+
endmenu
diff --git a/drivers/firmware/arm_scmi/Makefile b/drivers/firmware/arm_scmi/Makefile
index fe55b7aa0707..20f8d55840a5 100644
--- a/drivers/firmware/arm_scmi/Makefile
+++ b/drivers/firmware/arm_scmi/Makefile
@@ -18,3 +18,4 @@ obj-$(CONFIG_ARM_SCMI_PROTOCOL) += scmi-core.o
obj-$(CONFIG_ARM_SCMI_PROTOCOL) += scmi-module.o
obj-$(CONFIG_ARM_SCMI_POWER_CONTROL) += scmi_power_control.o
+obj-$(CONFIG_ARM_SCMI_SYSTEM_TELEMETRY) += scmi_system_telemetry.o
diff --git a/drivers/firmware/arm_scmi/scmi_system_telemetry.c b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
new file mode 100644
index 000000000000..567585dfb036
--- /dev/null
+++ b/drivers/firmware/arm_scmi/scmi_system_telemetry.c
@@ -0,0 +1,1493 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * SCMI - System Telemetry Driver
+ *
+ * Copyright (C) 2026 ARM Ltd.
+ */
+
+#include <linux/atomic.h>
+#include <linux/bitfield.h>
+#include <linux/cred.h>
+#include <linux/ctype.h>
+#include <linux/dcache.h>
+#include <linux/device.h>
+#include <linux/err.h>
+#include <linux/fs.h>
+#include <linux/fs_context.h>
+#include <linux/fs_parser.h>
+#include <linux/kstrtox.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/overflow.h>
+#include <linux/scmi_protocol.h>
+#include <linux/slab.h>
+#include <linux/sprintf.h>
+#include <linux/string.h>
+#include <linux/types.h>
+#include <linux/uaccess.h>
+
+#define TLM_FS_MAGIC 0x75C01C80
+#define TLM_FS_NAME "stlmfs"
+#define TLM_FS_MNT "arm_telemetry"
+
+#define SCMI_TLM_DEFAULT_UMASK 0022U
+#define MAX_AVAILABLE_INTERV_CHAR_LENGTH 25
+#define MAX_BULK_LINE_CHAR_LENGTH 64
+
+static struct kmem_cache *stlmfs_inode_cachep;
+
+static DEFINE_MUTEX(stlmfs_mtx);
+static struct super_block *stlmfs_sb;
+
+static atomic_t scmi_tlm_instance_count = ATOMIC_INIT(0);
+
+struct scmi_tlm_setup;
+
+struct scmi_tlm_priv {
+ char *buf;
+ size_t buf_sz;
+ int buf_len;
+ int (*bulk_retrieve)(struct scmi_tlm_setup *tsp,
+ int res_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples);
+};
+
+/**
+ * struct scmi_tlm_buffer - Output Telemetry buffer descriptor
+ * @used: Current number of used bytes in @buf
+ * @buf: Actual buffer for output data
+ *
+ * This describes an output buffer which will be made available to each r/w
+ * entry file_operations.
+ */
+struct scmi_tlm_buffer {
+ size_t used;
+#define SCMI_TLM_MAX_BUF_SZ 128
+ unsigned char buf[SCMI_TLM_MAX_BUF_SZ];
+};
+
+/**
+ * struct scmi_tlm_setup - Telemetry setup descriptor
+ * @dev: A reference to the related device
+ * @ph: A reference to the protocol handle to be used with the ops
+ * @rinfo: A reference to the resource info descriptor
+ * @ops: A reference to the protocol ops
+ */
+struct scmi_tlm_setup {
+ struct device *dev;
+ struct scmi_protocol_handle *ph;
+ const struct scmi_telemetry_res_info __private *rinfo;
+ const struct scmi_telemetry_proto_ops *ops;
+};
+
+/**
+ * struct scmi_tlm_class - Telemetry class descriptor
+ * @name: A string to be used for filesystem dentry name.
+ * @mode: Filesystem mode mask.
+ * @flags: Optional misc flags that can slighly modify provided @f_op behaviour;
+ * this way the same @scmi_tlm_class can be used to describe multiple
+ * entries in the filesystem whose @f_op behaviour is very similar.
+ * @f_op: Optional file ops attached to this object. Used to initialized inodes.
+ * @i_op: Optional inode ops attached to this object. Used to initialize inodes.
+ *
+ * This structure describes a class of telemetry entities that will be
+ * associated with filesystem inodes having the same behaviour, i.e. the same
+ * @f_op and @i_op: this way it will be possible to statically define a set of
+ * common descriptors to describe all the possible behaviours and then link it
+ * to the effective inodes that will be created to support the set of DEs
+ * effectively discovered at run-time via SCMI.
+ */
+struct scmi_tlm_class {
+ const char *name;
+ umode_t mode;
+ int flags;
+#define TLM_IS_STATE BIT(0)
+#define TLM_IS_GROUP BIT(1)
+#define TLM_IS_DYNAMIC BIT(2)
+#define IS_STATE(_f) ((_f) & TLM_IS_STATE)
+#define IS_GROUP(_f) ((_f) & TLM_IS_GROUP)
+#define IS_DYNAMIC(_f) ((_f) & TLM_IS_DYNAMIC)
+ const struct file_operations *f_op;
+ const struct inode_operations *i_op;
+};
+
+#define TLM_ANON_CLASS(_n, _f, _m, _fo, _io) \
+ { \
+ .name = _n, \
+ .flags = _f, \
+ .f_op = _fo, \
+ .i_op = _io, \
+ .mode = _m, \
+ }
+
+#define DEFINE_TLM_CLASS(_tag, _ns, _fl, _mo, _fop, _iop) \
+ static const struct scmi_tlm_class _tag = \
+ TLM_ANON_CLASS(_ns, _fl, _mo, _fop, _iop)
+
+/**
+ * struct scmi_tlm_inode - Telemetry node descriptor
+ * @tsp: A reference to a structure holding data needed to interact with
+ * the SCMI instance associated to this inode.
+ * @cls: A reference to the @scmi_tlm_class describing the behaviour of this
+ * inode.
+ * @priv: Generic private data reference.
+ * @de: SCMI DE data reference.
+ * @grp: SCMI Group data reference.
+ * @info: SCMI instance information data reference.
+ * @vfs_inode: The embedded VFS inode that will be initialized and plugged
+ * into the live filesystem at mount time.
+ *
+ * This structure is used to describe each SCMI Telemetry entity discovered
+ * at probe time, store its related SCMI data, and link to the proper
+ * telemetry class @scmi_tlm_class.
+ */
+struct scmi_tlm_inode {
+ struct scmi_tlm_setup *tsp;
+ const struct scmi_tlm_class *cls;
+ union {
+ const void *priv;
+ const struct scmi_telemetry_de *de;
+ const struct scmi_telemetry_group *grp;
+ const struct scmi_telemetry_info *info;
+ };
+ struct inode vfs_inode;
+};
+
+#define to_tlm_inode(t) container_of(t, struct scmi_tlm_inode, vfs_inode)
+
+#define MAX_INST_NAME 32
+
+#define TOP_NODES_NUM 32
+#define NODES_PER_DE_NUM 12
+#define NODES_PER_GRP_NUM 9
+
+/**
+ * struct scmi_tlm_instance - Telemetry instance descriptor
+ * @id: Progressive number identifying this probed instance; it will be used
+ * to name the top node at the root of this instance.
+ * @res_enumerated: A flag to indicate if full resources enumeration has been
+ * successfully performed.
+ * @name: Name to be used for the top root node of the instance. (tlm_<id>)
+ * @node: A node to link this in the list of all instances.
+ * @sb: A reference to the current super_block.
+ * @tsp: A reference to the SCMI instance data.
+ * @top_cls: A class to represent the top node behaviour.
+ * @top_dentry: A reference to the top dentry for this instance.
+ * @des_dentry: A reference to the DES dentry for this instance.
+ * @grps_dentry: A reference to the groups dentry for this instance.
+ * @info: A handy reference to this instance SCMI Telemetry info data.
+ *
+ */
+struct scmi_tlm_instance {
+ int id;
+ bool res_enumerated;
+ char name[MAX_INST_NAME];
+ struct list_head node;
+ struct super_block *sb;
+ struct scmi_tlm_setup *tsp;
+ struct scmi_tlm_class top_cls;
+ struct dentry *top_dentry;
+ struct dentry *des_dentry;
+ struct dentry *grps_dentry;
+ const struct scmi_telemetry_info *info;
+};
+
+static int scmi_telemetry_instance_register(struct super_block *sb,
+ struct scmi_tlm_instance *ti);
+
+static LIST_HEAD(scmi_telemetry_instances);
+
+static struct inode *stlmfs_get_inode(struct super_block *sb, umode_t mode)
+{
+ struct inode *inode = new_inode(sb);
+
+ if (inode) {
+ inode->i_ino = get_next_ino();
+ inode->i_uid = GLOBAL_ROOT_UID;
+ inode->i_gid = GLOBAL_ROOT_GID;
+ inode->i_mode = mode & ~SCMI_TLM_DEFAULT_UMASK;
+ simple_inode_init_ts(inode);
+ }
+
+ return inode;
+}
+
+static int stlmfs_failed_creating(struct dentry *dentry)
+{
+ simple_done_creating(dentry);
+
+ return -ENOMEM;
+}
+
+static struct dentry *
+stlmfs_create_dentry(struct super_block *sb, struct scmi_tlm_setup *tsp,
+ struct dentry *parent, const struct scmi_tlm_class *cls,
+ const void *priv)
+{
+ struct scmi_tlm_inode *tlmi;
+ struct dentry *dentry;
+ struct inode *inode;
+
+ if (!parent)
+ parent = sb->s_root;
+
+ /*
+ * Bail-out when called on a bad tree, so that there is NO need to
+ * check upfront for errors at call-site. (like debugfs)
+ */
+ if (IS_ERR(parent))
+ return parent;
+
+ dentry = simple_start_creating(parent, cls->name);
+ if (IS_ERR(dentry))
+ return dentry;
+
+ inode = stlmfs_get_inode(sb, cls->mode);
+ if (unlikely(!inode)) {
+ dev_err(tsp->dev,
+ "out of free dentries, cannot create '%s'",
+ cls->name);
+ return ERR_PTR(stlmfs_failed_creating(dentry));
+ }
+
+ if (S_ISDIR(cls->mode)) {
+ inode->i_op = cls->i_op ?: &simple_dir_inode_operations;
+ inode->i_fop = cls->f_op ?: &simple_dir_operations;
+ } else {
+ inode->i_op = cls->i_op ?: &simple_dir_inode_operations;
+ inode->i_fop = cls->f_op;
+ }
+
+ inode->i_private = (void *)priv;
+
+ tlmi = to_tlm_inode(inode);
+
+ tlmi->cls = cls;
+ tlmi->tsp = tsp;
+ tlmi->priv = priv;
+
+ d_make_persistent(dentry, inode);
+
+ simple_done_creating(dentry);
+
+ return dentry;
+}
+
+static inline int
+__scmi_tlm_priv_generic_open(struct inode *ino, struct file *filp,
+ int (*data_init_op)(struct scmi_tlm_inode *tlmi,
+ struct scmi_tlm_priv *tp),
+ int (*bulk_op)(struct scmi_tlm_setup *tsp,
+ int res_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples))
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(ino);
+ int ret;
+
+ struct scmi_tlm_priv *tp __free(kfree) = kzalloc_obj(*tp);
+ if (!tp)
+ return -ENOMEM;
+
+ tp->bulk_retrieve = bulk_op;
+ ret = data_init_op(tlmi, tp);
+ if (ret)
+ return ret;
+
+ filp->private_data = no_free_ptr(tp);
+
+ return nonseekable_open(ino, filp);
+}
+
+static int scmi_tlm_priv_release(struct inode *ino, struct file *filp)
+{
+ struct scmi_tlm_priv *tp = filp->private_data;
+
+ kfree(tp->buf);
+ kfree(tp);
+
+ return 0;
+}
+
+/**
+ * scmi_telemetry_res_info_get - Resources info getter
+ * @tsp: A reference to the telemetry instance setup
+ *
+ * On first call this helper takes care to retrieve and cache all the resources
+ * descriptor from the platform, then, on the following invocations it will
+ * always return the cached value.
+ */
+static inline const struct scmi_telemetry_res_info *
+scmi_telemetry_res_info_get(struct scmi_tlm_setup *tsp)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+
+ if (tsp->rinfo)
+ return ACCESS_PRIVATE(tsp, rinfo);
+
+ rinfo = tsp->ops->res_get(tsp->ph);
+ /* Cache the retrieved resource info value */
+ smp_store_mb(tsp->rinfo, rinfo);
+
+ return rinfo;
+}
+
+static ssize_t scmi_tlm_all_des_write(struct file *filp,
+ const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ const struct scmi_tlm_class *cls = tlmi->cls;
+ bool enable;
+ int ret;
+
+ ret = kstrtobool_from_user(buf, count, &enable);
+ if (ret)
+ return ret;
+
+ /* When !IS_STATE imply that is a tstamp_enable operation */
+ if (IS_STATE(cls->flags) && !enable) {
+ ret = tsp->ops->all_disable(tsp->ph, false);
+ if (ret)
+ return ret;
+ } else {
+ const struct scmi_telemetry_res_info *rinfo;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (!rinfo)
+ return -ENODEV;
+
+ for (int i = 0; i < rinfo->num_des; i++) {
+ ret = tsp->ops->state_set(tsp->ph, false,
+ rinfo->des[i]->info->id,
+ IS_STATE(cls->flags) ? &enable : NULL,
+ !IS_STATE(cls->flags) ? &enable : NULL);
+ if (ret)
+ return ret;
+ }
+ }
+
+ return count;
+}
+
+static ssize_t scmi_tlm_all_des_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ const struct scmi_tlm_class *cls = tlmi->cls;
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ bool enabled, tstamp_enabled, state;
+ char o_buf[2];
+ int ret;
+
+ ret = tsp->ops->state_get(tsp->ph, NULL, &enabled, &tstamp_enabled);
+ if (ret)
+ return ret;
+
+ state = IS_STATE(cls->flags) ? enabled : tstamp_enabled;
+ o_buf[0] = state ? 'Y' : 'N';
+ o_buf[1] = '\n';
+
+ return simple_read_from_buffer(buf, count, ppos, o_buf, 2);
+}
+
+static const struct file_operations all_des_fops = {
+ .open = nonseekable_open,
+ .write = scmi_tlm_all_des_write,
+ .read = scmi_tlm_all_des_read,
+};
+
+static ssize_t scmi_tlm_obj_enable_write(struct file *filp,
+ const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ const struct scmi_tlm_class *cls = tlmi->cls;
+ bool enabled, is_group = IS_GROUP(cls->flags);
+ int ret, res_id;
+
+ ret = kstrtobool_from_user(buf, count, &enabled);
+ if (ret)
+ return ret;
+
+ res_id = !is_group ? tlmi->de->info->id : tlmi->grp->info->id;
+ ret = tsp->ops->state_set(tsp->ph, is_group, res_id,
+ IS_STATE(cls->flags) ? &enabled : NULL,
+ !IS_STATE(cls->flags) ? &enabled : NULL);
+ if (ret)
+ return ret;
+
+ return count;
+}
+
+static ssize_t scmi_tlm_obj_enable_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ const bool *enabled_state, *tstamp_enabled_state;
+ char o_buf[2];
+ bool enabled;
+
+ if (!IS_GROUP(tlmi->cls->flags)) {
+ enabled_state = &tlmi->de->enabled;
+ tstamp_enabled_state = &tlmi->de->tstamp_enabled;
+ } else {
+ enabled_state = &tlmi->grp->enabled;
+ tstamp_enabled_state = &tlmi->grp->tstamp_enabled;
+ }
+
+ enabled = IS_STATE(tlmi->cls->flags) ? *enabled_state : *tstamp_enabled_state;
+ o_buf[0] = enabled ? 'Y' : 'N';
+ o_buf[1] = '\n';
+
+ return simple_read_from_buffer(buf, count, ppos, o_buf, 2);
+}
+
+static const struct file_operations obj_enable_fops = {
+ .open = nonseekable_open,
+ .write = scmi_tlm_obj_enable_write,
+ .read = scmi_tlm_obj_enable_read,
+};
+
+static int scmi_tlm_open(struct inode *ino, struct file *filp)
+{
+ struct scmi_tlm_buffer *data;
+
+ /* Allocate some per-open buffer */
+ data = kzalloc_obj(*data);
+ if (!data)
+ return -ENOMEM;
+
+ filp->private_data = data;
+
+ return nonseekable_open(ino, filp);
+}
+
+static int scmi_tlm_release(struct inode *ino, struct file *filp)
+{
+ kfree(filp->private_data);
+
+ return 0;
+}
+
+static ssize_t
+scmi_tlm_update_interval_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_buffer *data = filp->private_data;
+ unsigned int active_update_interval;
+
+ if (!data)
+ return 0;
+
+ if (!IS_GROUP(tlmi->cls->flags))
+ active_update_interval = tlmi->info->active_update_interval;
+ else
+ active_update_interval = tlmi->grp->active_update_interval;
+
+ if (!data->used)
+ data->used =
+ scnprintf(data->buf, SCMI_TLM_MAX_BUF_SZ, "%u,%d\n",
+ SCMI_TLM_GET_UPDATE_INTERVAL_SECS(active_update_interval),
+ SCMI_TLM_GET_UPDATE_INTERVAL_EXP(active_update_interval));
+
+ return simple_read_from_buffer(buf, count, ppos, data->buf, data->used);
+}
+
+static ssize_t
+scmi_tlm_update_interval_write(struct file *filp, const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ struct scmi_tlm_buffer *data = filp->private_data;
+ bool is_group = IS_GROUP(tlmi->cls->flags);
+ unsigned int update_interval_ms = 0, secs = 0;
+ int ret, grp_id, exp = -3;
+ char *p, *token;
+
+ if (count >= SCMI_TLM_MAX_BUF_SZ)
+ return -ENOSPC;
+
+ if (copy_from_user(data->buf, buf, count))
+ return -EFAULT;
+
+ /*
+ * Accepting interval specified as:
+ *
+ * - a single value, interpreted as milliseconds
+ * - a coma separated tuple, with interleaving spaces removed,
+ * interpreted as <secs>,<exp> so that the interval is calculated as:
+ * <secs> x 10 ^ <exp>
+ */
+ p = data->buf;
+ token = strsep(&p, ",");
+ if (!token || iscntrl(token[0]))
+ return -EINVAL;
+
+ ret = kstrtouint(strim(token), 0, &secs);
+ if (ret)
+ return ret;
+
+ if (p) {
+ token = p;
+ if (!token || iscntrl(token[0]))
+ return -EINVAL;
+
+ ret = kstrtoint(strim(token), 0, &exp);
+ if (ret)
+ return ret;
+ }
+
+ update_interval_ms = SCMI_TLM_BUILD_UPDATE_INTERVAL(secs, exp);
+
+ grp_id = !is_group ? SCMI_TLM_GRP_INVALID : tlmi->grp->info->id;
+ ret = tsp->ops->collection_configure(tsp->ph, grp_id, !is_group, NULL,
+ &update_interval_ms, NULL);
+ if (ret)
+ return ret;
+
+ return count;
+}
+
+static const struct file_operations current_interval_fops = {
+ .open = scmi_tlm_open,
+ .read = scmi_tlm_update_interval_read,
+ .write = scmi_tlm_update_interval_write,
+ .release = scmi_tlm_release,
+};
+
+static ssize_t scmi_tlm_de_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ struct scmi_tlm_buffer *data = filp->private_data;
+ int ret;
+
+ if (!data)
+ return 0;
+
+ if (!data->used) {
+ struct scmi_telemetry_de_sample sample;
+
+ sample.id = tlmi->de->info->id;
+ ret = tsp->ops->de_data_read(tsp->ph, &sample);
+ if (ret)
+ return ret;
+
+ data->used = scnprintf(data->buf, SCMI_TLM_MAX_BUF_SZ,
+ "%llu %016llX\n", sample.tstamp,
+ sample.val);
+ }
+
+ return simple_read_from_buffer(buf, count, ppos, data->buf, data->used);
+}
+
+static const struct file_operations de_read_fops = {
+ .open = scmi_tlm_open,
+ .read = scmi_tlm_de_read,
+ .release = scmi_tlm_release,
+};
+
+static ssize_t
+scmi_tlm_enable_read(struct file *filp, char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ char o_buf[2];
+
+ o_buf[0] = tlmi->info->enabled ? 'Y' : 'N';
+ o_buf[1] = '\n';
+
+ return simple_read_from_buffer(buf, count, ppos, o_buf, 2);
+}
+
+static ssize_t
+scmi_tlm_enable_write(struct file *filp, const char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ enum scmi_telemetry_collection mode = SCMI_TLM_ONDEMAND;
+ struct scmi_tlm_setup *tsp = tlmi->tsp;
+ bool enabled;
+ int ret;
+
+ ret = kstrtobool_from_user(buf, count, &enabled);
+ if (ret)
+ return ret;
+
+ ret = tsp->ops->collection_configure(tsp->ph, SCMI_TLM_GRP_INVALID, true,
+ &enabled, NULL, &mode);
+ if (ret)
+ return ret;
+
+ return count;
+}
+
+static const struct file_operations tlm_enable_fops = {
+ .open = nonseekable_open,
+ .read = scmi_tlm_enable_read,
+ .write = scmi_tlm_enable_write,
+};
+
+static ssize_t
+scmi_tlm_intrv_discrete_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ bool discrete;
+ char o_buf[2];
+
+ discrete = !IS_GROUP(tlmi->cls->flags) ?
+ tlmi->info->intervals->discrete : tlmi->grp->intervals->discrete;
+
+ o_buf[0] = discrete ? 'Y' : 'N';
+ o_buf[1] = '\n';
+
+ return simple_read_from_buffer(buf, count, ppos, o_buf, 2);
+}
+
+static const struct file_operations intrv_discrete_fops = {
+ .open = nonseekable_open,
+ .read = scmi_tlm_intrv_discrete_read,
+};
+
+static ssize_t
+scmi_tlm_reset_write(struct file *filp, const char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ int ret;
+
+ ret = tlmi->tsp->ops->reset(tlmi->tsp->ph);
+ if (ret)
+ return ret;
+
+ return count;
+}
+
+static const struct file_operations reset_fops = {
+ .open = nonseekable_open,
+ .write = scmi_tlm_reset_write,
+};
+
+static int sa_u32_get(void *data, u64 *val)
+{
+ *val = *(u32 *)data;
+ return 0;
+}
+
+static int sa_u32_set(void *data, u64 val)
+{
+ *(u32 *)data = val;
+ return 0;
+}
+
+static int sa_u32_open(struct inode *ino, struct file *filp)
+{
+ return simple_attr_open(ino, filp, sa_u32_get, sa_u32_set, "%u\n");
+}
+
+static int sa_s32_open(struct inode *ino, struct file *filp)
+{
+ return simple_attr_open(ino, filp, sa_u32_get, sa_u32_set, "%d\n");
+}
+
+static int sa_x32_open(struct inode *ino, struct file *filp)
+{
+ return simple_attr_open(ino, filp, sa_u32_get, sa_u32_set, "0x%X\n");
+}
+
+static const struct file_operations sa_x32_ro_fops = {
+ .open = sa_x32_open,
+ .read = simple_attr_read,
+ .release = simple_attr_release,
+};
+
+static const struct file_operations sa_u32_ro_fops = {
+ .open = sa_u32_open,
+ .read = simple_attr_read,
+ .release = simple_attr_release,
+};
+
+static const struct file_operations sa_s32_ro_fops = {
+ .open = sa_s32_open,
+ .read = simple_attr_read,
+ .release = simple_attr_release,
+};
+
+static ssize_t
+scmi_de_impl_version_read(struct file *filp, char __user *buf, size_t count,
+ loff_t *ppos)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(file_inode(filp));
+ struct scmi_tlm_buffer *data = filp->private_data;
+
+ if (!data)
+ return 0;
+
+ if (!data->used)
+ data->used = scnprintf(data->buf, SCMI_TLM_MAX_BUF_SZ,
+ "%pUL\n", tlmi->info->base.de_impl_version);
+
+ return simple_read_from_buffer(buf, count, ppos, data->buf, data->used);
+}
+
+static const struct file_operations de_impl_vers_fops = {
+ .open = scmi_tlm_open,
+ .read = scmi_de_impl_version_read,
+ .release = scmi_tlm_release,
+};
+
+static ssize_t scmi_tlm_priv_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_tlm_priv *tp = filp->private_data;
+
+ return simple_read_from_buffer(buf, count, ppos, tp->buf, tp->buf_len);
+}
+
+static int scmi_tlm_priv_string_init(struct scmi_tlm_inode *tlmi,
+ struct scmi_tlm_priv *tp)
+{
+ const char *str = tlmi->priv;
+
+ tp->buf = kasprintf(GFP_KERNEL, "%s\n", str);
+ if (!tp->buf)
+ return -ENOMEM;
+
+ tp->buf_len = strlen(tp->buf) + 1;
+
+ return 0;
+}
+
+static int scmi_tlm_priv_string_open(struct inode *ino, struct file *filp)
+{
+ return __scmi_tlm_priv_generic_open(ino, filp,
+ scmi_tlm_priv_string_init, NULL);
+}
+
+static const struct file_operations string_ro_fops = {
+ .open = scmi_tlm_priv_string_open,
+ .read = scmi_tlm_priv_read,
+ .release = scmi_tlm_priv_release,
+};
+
+static int scmi_tlm_priv_available_init(struct scmi_tlm_inode *tlmi,
+ struct scmi_tlm_priv *tp)
+{
+ struct scmi_tlm_intervals *intervals;
+ int len = 0;
+
+ intervals = !IS_GROUP(tlmi->cls->flags) ?
+ tlmi->info->intervals : tlmi->grp->intervals;
+ tp->buf_len = intervals->num_intervals * MAX_AVAILABLE_INTERV_CHAR_LENGTH;
+ tp->buf = kzalloc(tp->buf_len, GFP_KERNEL);
+ if (!tp->buf)
+ return -ENOMEM;
+
+ for (int i = 0; i < intervals->num_intervals; i++) {
+ u32 ivl;
+
+ ivl = intervals->update_intervals[i];
+ len += scnprintf(tp->buf + len, tp->buf_len - len,
+ "%u,%d ",
+ SCMI_TLM_GET_UPDATE_INTERVAL_SECS(ivl),
+ SCMI_TLM_GET_UPDATE_INTERVAL_EXP(ivl));
+ }
+
+ tp->buf[len - 1] = '\n';
+
+ return 0;
+}
+
+static int scmi_tlm_priv_available_open(struct inode *ino, struct file *filp)
+{
+ return __scmi_tlm_priv_generic_open(ino, filp,
+ scmi_tlm_priv_available_init, NULL);
+}
+
+static const struct file_operations available_interv_fops = {
+ .open = scmi_tlm_priv_available_open,
+ .read = scmi_tlm_priv_read,
+ .release = scmi_tlm_priv_release,
+};
+
+static const struct scmi_tlm_class tlm_tops[] = {
+ TLM_ANON_CLASS("all_des_enable", TLM_IS_STATE,
+ S_IFREG | 0666, &all_des_fops, NULL),
+ TLM_ANON_CLASS("all_des_tstamp_enable", 0,
+ S_IFREG | 0666, &all_des_fops, NULL),
+ TLM_ANON_CLASS("current_update_interval_ms", 0,
+ S_IFREG | 0666, ¤t_interval_fops, NULL),
+ TLM_ANON_CLASS("intervals_discrete", 0,
+ S_IFREG | 0444, &intrv_discrete_fops, NULL),
+ TLM_ANON_CLASS("available_update_intervals_ms", 0,
+ S_IFREG | 0444, &available_interv_fops, NULL),
+ TLM_ANON_CLASS("de_implementation_version", 0,
+ S_IFREG | 0444, &de_impl_vers_fops, NULL),
+ TLM_ANON_CLASS("tlm_enable", 0,
+ S_IFREG | 0666, &tlm_enable_fops, NULL),
+ TLM_ANON_CLASS(NULL, 0, 0, NULL, NULL),
+};
+
+DEFINE_TLM_CLASS(reset_tlmo, "reset", 0, S_IFREG | 0200, &reset_fops, NULL);
+
+DEFINE_TLM_CLASS(des_dir_cls, "des", 0,
+ S_IFDIR | 0700, NULL, NULL);
+DEFINE_TLM_CLASS(name_tlmo, "name", 0,
+ S_IFREG | 0444, &string_ro_fops, NULL);
+DEFINE_TLM_CLASS(ena_tlmo, "enable", TLM_IS_STATE,
+ S_IFREG | 0666, &obj_enable_fops, NULL);
+DEFINE_TLM_CLASS(tstamp_ena_tlmo, "tstamp_enable", 0,
+ S_IFREG | 0666, &obj_enable_fops, NULL);
+DEFINE_TLM_CLASS(type_tlmo, "type", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(unit_tlmo, "unit", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(unit_exp_tlmo, "unit_exp", 0,
+ S_IFREG | 0444, &sa_s32_ro_fops, NULL);
+DEFINE_TLM_CLASS(instance_id_tlmo, "instance_id", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(compo_type_tlmo, "compo_type", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(compo_inst_id_tlmo, "compo_instance_id", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(tstamp_rate_tlmo, "tstamp_rate", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(persistent_tlmo, "persistent", 0,
+ S_IFREG | 0444, &sa_u32_ro_fops, NULL);
+DEFINE_TLM_CLASS(value_tlmo, "value", 0,
+ S_IFREG | 0444, &de_read_fops, NULL);
+
+static int scmi_telemetry_de_populate(struct super_block *sb,
+ struct scmi_tlm_setup *tsp,
+ struct dentry *parent,
+ const struct scmi_telemetry_de *de,
+ bool fully_enumerated)
+{
+ struct scmi_tlm_de_info *dei = de->info;
+
+ stlmfs_create_dentry(sb, tsp, parent, &ena_tlmo, de);
+ stlmfs_create_dentry(sb, tsp, parent, &value_tlmo, de);
+ if (!fully_enumerated)
+ return 0;
+
+ if (de->name_support)
+ stlmfs_create_dentry(sb, tsp, parent, &name_tlmo, dei->name);
+
+ if (de->tstamp_support) {
+ stlmfs_create_dentry(sb, tsp, parent, &tstamp_ena_tlmo, de);
+ stlmfs_create_dentry(sb, tsp, parent, &tstamp_rate_tlmo,
+ &dei->ts_rate);
+ }
+
+ stlmfs_create_dentry(sb, tsp, parent, &type_tlmo, &dei->type);
+ stlmfs_create_dentry(sb, tsp, parent, &unit_tlmo, &dei->unit);
+ stlmfs_create_dentry(sb, tsp, parent, &unit_exp_tlmo, &dei->unit_exp);
+ stlmfs_create_dentry(sb, tsp, parent, &instance_id_tlmo, &dei->instance_id);
+ stlmfs_create_dentry(sb, tsp, parent, &compo_type_tlmo, &dei->compo_type);
+ stlmfs_create_dentry(sb, tsp, parent, &compo_inst_id_tlmo,
+ &dei->compo_instance_id);
+ stlmfs_create_dentry(sb, tsp, parent, &persistent_tlmo, &dei->persistent);
+
+ return 0;
+}
+
+static int
+scmi_telemetry_des_lazy_enumerate(struct scmi_tlm_instance *ti,
+ const struct scmi_telemetry_res_info *rinfo)
+{
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+
+ for (int i = 0; i < rinfo->num_des; i++) {
+ const struct scmi_telemetry_de *de = rinfo->des[i];
+ struct dentry *de_dir_dentry;
+ int ret;
+
+ struct scmi_tlm_class *de_tlm_cls __free(kfree) =
+ kzalloc(sizeof(*de_tlm_cls), GFP_KERNEL);
+ if (!de_tlm_cls)
+ return -ENOMEM;
+
+ de_tlm_cls->name = kasprintf(GFP_KERNEL, "0x%08X", de->info->id);
+ if (!de_tlm_cls->name)
+ return -ENOMEM;
+
+ de_tlm_cls->mode = S_IFDIR | 0700;
+ de_tlm_cls->flags = TLM_IS_DYNAMIC;
+ de_dir_dentry = stlmfs_create_dentry(sb, tsp, ti->des_dentry,
+ de_tlm_cls, de);
+
+ ret = scmi_telemetry_de_populate(sb, tsp, de_dir_dentry, de,
+ rinfo->fully_enumerated);
+ if (ret)
+ return ret;
+
+ retain_and_null_ptr(de_tlm_cls);
+ }
+
+ ti->res_enumerated = true;
+
+ dev_info(tsp->dev, "Found %d Telemetry DE resources.\n", rinfo->num_des);
+
+ return 0;
+}
+
+static int scmi_telemetry_des_initialize(struct scmi_tlm_instance *ti)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+
+ rinfo = scmi_telemetry_res_info_get(ti->tsp);
+ if (!rinfo)
+ return -ENODEV;
+
+ return scmi_telemetry_des_lazy_enumerate(ti, rinfo);
+}
+
+DEFINE_TLM_CLASS(version_tlmo, "version", 0,
+ S_IFREG | 0444, &sa_x32_ro_fops, NULL);
+
+static int scmi_tlm_bulk_on_demand(struct scmi_tlm_setup *tsp,
+ int res_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples)
+{
+ return tsp->ops->des_bulk_read(tsp->ph, res_id, num_samples, samples);
+}
+
+static int scmi_tlm_buffer_fill(struct device *dev, char *buf, size_t size,
+ int *len, int num,
+ struct scmi_telemetry_de_sample *samples)
+{
+ int idx, bytes = 0;
+
+ /* Loop till there space for the next line */
+ for (idx = 0; idx < num && size - bytes >= MAX_BULK_LINE_CHAR_LENGTH; idx++) {
+ bytes += scnprintf(buf + bytes, size - bytes,
+ "0x%08X %llu %016llX\n", samples[idx].id,
+ samples[idx].tstamp, samples[idx].val);
+ }
+
+ if (idx < num) {
+ dev_err(dev, "Bulk buffer truncated !\n");
+ return -ENOSPC;
+ }
+
+ if (len)
+ *len = bytes;
+
+ return 0;
+}
+
+static int scmi_tlm_bulk_buffer_fill(struct scmi_tlm_setup *tsp,
+ struct scmi_tlm_priv *tp,
+ int res_id, int num_samples)
+{
+ int ret;
+
+ struct scmi_telemetry_de_sample *samples __free(kfree) =
+ kcalloc(num_samples, sizeof(*samples), GFP_KERNEL);
+ if (!samples)
+ return -ENOMEM;
+
+ ret = tp->bulk_retrieve(tsp, res_id, &num_samples, samples);
+ if (ret)
+ return ret;
+
+ return scmi_tlm_buffer_fill(tsp->dev, tp->buf, tp->buf_sz, &tp->buf_len,
+ num_samples, samples);
+}
+
+static int scmi_tlm_priv_data_init(struct scmi_tlm_inode *tlmi,
+ struct scmi_tlm_priv *tp)
+{
+ const struct scmi_tlm_class *cls = tlmi->cls;
+ bool is_group = IS_GROUP(cls->flags);
+ int res_id, num_samples;
+
+ num_samples = !is_group ? tlmi->info->base.num_des :
+ tlmi->grp->info->num_des;
+ res_id = is_group ? tlmi->grp->info->id : SCMI_TLM_GRP_INVALID;
+ tp->buf_sz = num_samples * MAX_BULK_LINE_CHAR_LENGTH;
+ /*
+ * Note that tp->buf is a scratch buffer, filled once, used to
+ * support multiple chunked read and freed in
+ * scmi_tlm_priv_release.
+ */
+ tp->buf = kzalloc(tp->buf_sz, GFP_KERNEL);
+ if (!tp->buf)
+ return -ENOMEM;
+
+ return scmi_tlm_bulk_buffer_fill(tlmi->tsp, tp, res_id, num_samples);
+}
+
+static int scmi_tlm_priv_data_open(struct inode *ino, struct file *filp)
+{
+ return __scmi_tlm_priv_generic_open(ino, filp, scmi_tlm_priv_data_init,
+ scmi_tlm_bulk_on_demand);
+}
+
+static const struct file_operations scmi_tlm_data_fops = {
+ .owner = THIS_MODULE,
+ .open = scmi_tlm_priv_data_open,
+ .read = scmi_tlm_priv_read,
+ .release = scmi_tlm_priv_release,
+};
+
+DEFINE_TLM_CLASS(data_tlmo, "des_bulk_read", 0,
+ S_IFREG | 0444, &scmi_tlm_data_fops, NULL);
+
+static int scmi_tlm_bulk_single_read(struct scmi_tlm_setup *tsp,
+ int res_id, int *num_samples,
+ struct scmi_telemetry_de_sample *samples)
+{
+ return tsp->ops->des_sample_get(tsp->ph, res_id, num_samples, samples);
+}
+
+static int scmi_tlm_priv_single_read_open(struct inode *ino, struct file *filp)
+{
+ return __scmi_tlm_priv_generic_open(ino, filp, scmi_tlm_priv_data_init,
+ scmi_tlm_bulk_single_read);
+}
+
+static const struct file_operations scmi_tlm_single_sample_fops = {
+ .owner = THIS_MODULE,
+ .open = scmi_tlm_priv_single_read_open,
+ .read = scmi_tlm_priv_read,
+ .release = scmi_tlm_priv_release,
+};
+
+DEFINE_TLM_CLASS(single_sample_tlmo, "des_single_sample_read", 0,
+ S_IFREG | 0444, &scmi_tlm_single_sample_fops, NULL);
+
+static const struct scmi_tlm_class tlm_grps[] = {
+ TLM_ANON_CLASS("enable", TLM_IS_STATE | TLM_IS_GROUP,
+ S_IFREG | 0666, &obj_enable_fops, NULL),
+ TLM_ANON_CLASS("tstamp_enable", TLM_IS_GROUP,
+ S_IFREG | 0666, &obj_enable_fops, NULL),
+ TLM_ANON_CLASS(NULL, 0, 0, NULL, NULL),
+};
+
+DEFINE_TLM_CLASS(grp_data_tlmo, "des_bulk_read", TLM_IS_GROUP,
+ S_IFREG | 0444, &scmi_tlm_data_fops, NULL);
+
+DEFINE_TLM_CLASS(groups_dir_cls, "groups", 0, S_IFDIR | 0700, NULL, NULL);
+
+DEFINE_TLM_CLASS(grp_single_sample_tlmo, "des_single_sample_read", TLM_IS_GROUP,
+ S_IFREG | 0444, &scmi_tlm_single_sample_fops, NULL);
+
+DEFINE_TLM_CLASS(grp_composing_des_tlmo, "composing_des", TLM_IS_GROUP,
+ S_IFREG | 0444, &string_ro_fops, NULL);
+
+DEFINE_TLM_CLASS(grp_current_interval_tlmo, "current_update_interval_ms",
+ TLM_IS_GROUP, S_IFREG | 0666,
+ ¤t_interval_fops, NULL);
+
+DEFINE_TLM_CLASS(grp_available_interval_tlmo, "available_update_intervals_ms",
+ TLM_IS_GROUP, S_IFREG | 0444, &available_interv_fops, NULL);
+
+DEFINE_TLM_CLASS(grp_intervals_discrete_tlmo, "intervals_discrete",
+ TLM_IS_GROUP, S_IFREG | 0444, &intrv_discrete_fops, NULL);
+
+static int scmi_telemetry_groups_initialize(struct scmi_tlm_instance *ti)
+{
+ const struct scmi_telemetry_res_info *rinfo;
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+ struct device *dev = tsp->dev;
+ struct dentry *grp_dir_dentry;
+
+ if (ti->info->base.num_groups == 0)
+ return 0;
+
+ rinfo = scmi_telemetry_res_info_get(tsp);
+ if (!rinfo)
+ return -ENODEV;
+
+ for (int i = 0; i < rinfo->num_groups; i++) {
+ const struct scmi_telemetry_group *grp = &rinfo->grps[i];
+
+ struct scmi_tlm_class *grp_tlm_cls __free(kfree) =
+ kzalloc(sizeof(*grp_tlm_cls), GFP_KERNEL);
+ if (!grp_tlm_cls)
+ return -ENOMEM;
+
+ grp_tlm_cls->name = kasprintf(GFP_KERNEL, "%u", grp->info->id);
+ if (!grp_tlm_cls->name)
+ return -ENOMEM;
+
+ grp_tlm_cls->mode = S_IFDIR | 0700;
+ grp_tlm_cls->flags = TLM_IS_DYNAMIC;
+
+ grp_dir_dentry = stlmfs_create_dentry(sb, tsp, ti->grps_dentry,
+ grp_tlm_cls, grp);
+
+ for (const struct scmi_tlm_class *gto = tlm_grps; gto->name; gto++)
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry, gto, grp);
+
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_composing_des_tlmo, grp->des_str);
+
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry, &grp_data_tlmo, grp);
+ if (ti->info->single_read_support)
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_single_sample_tlmo, grp);
+
+ if (ti->info->per_group_config_support) {
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_current_interval_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_available_interval_tlmo, grp);
+ stlmfs_create_dentry(sb, tsp, grp_dir_dentry,
+ &grp_intervals_discrete_tlmo, grp);
+ }
+
+ retain_and_null_ptr(grp_tlm_cls);
+ }
+
+ dev_info(dev, "Found %d Telemetry GROUPS resources.\n",
+ rinfo->num_groups);
+
+ return 0;
+}
+
+static struct scmi_tlm_instance *scmi_tlm_init(struct scmi_tlm_setup *tsp,
+ int instance_id)
+{
+ struct device *dev = tsp->dev;
+ struct scmi_tlm_instance *ti;
+
+ ti = devm_kzalloc(dev, sizeof(*ti), GFP_KERNEL);
+ if (!ti)
+ return ERR_PTR(-ENOMEM);
+
+ ti->info = tsp->ops->info_get(tsp->ph);
+ if (!ti->info)
+ return dev_err_ptr_probe(dev,
+ -EINVAL, "invalid Telemetry info !\n");
+
+ ti->id = instance_id;
+ ti->tsp = tsp;
+
+ return ti;
+}
+
+static int scmi_telemetry_probe(struct scmi_device *sdev)
+{
+ const struct scmi_handle *handle = sdev->handle;
+ struct scmi_protocol_handle *ph;
+ struct device *dev = &sdev->dev;
+ struct scmi_tlm_instance *ti;
+ struct scmi_tlm_setup *tsp;
+ struct super_block *sb;
+ const void *ops;
+
+ if (!handle)
+ return -ENODEV;
+
+ ops = handle->devm_protocol_get(sdev, sdev->protocol_id, &ph);
+ if (IS_ERR(ops))
+ return dev_err_probe(dev, PTR_ERR(ops),
+ "Cannot access protocol:0x%X\n",
+ sdev->protocol_id);
+
+ tsp = devm_kzalloc(dev, sizeof(*tsp), GFP_KERNEL);
+ if (!tsp)
+ return -ENOMEM;
+
+ tsp->dev = dev;
+ tsp->ops = ops;
+ tsp->ph = ph;
+
+ ti = scmi_tlm_init(tsp, atomic_fetch_inc(&scmi_tlm_instance_count));
+ if (IS_ERR(ti))
+ return PTR_ERR(ti);
+
+ mutex_lock(&stlmfs_mtx);
+ list_add(&ti->node, &scmi_telemetry_instances);
+ sb = stlmfs_sb;
+ mutex_unlock(&stlmfs_mtx);
+
+ /*
+ * In the rare case that the file system had already been mounted by the
+ * time this instance was probed, register explicitly, since the list
+ * has been scanned already.
+ */
+ if (sb) {
+ int ret;
+
+ ret = scmi_telemetry_instance_register(sb, ti);
+ if (ret) {
+ dev_err(dev, "Failed to register instance %u at probe.\n",
+ ti->id);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static void scmi_telemetry_remove(struct scmi_device *sdev)
+{
+ struct scmi_tlm_instance *ti, *tmp;
+
+ guard(mutex)(&stlmfs_mtx);
+ list_for_each_entry_safe(ti, tmp, &scmi_telemetry_instances, node) {
+ list_del(&ti->node);
+ stlmfs_instances--;
+ }
+
+ atomic_dec(&scmi_tlm_instance_count);
+}
+
+static const struct scmi_device_id scmi_id_table[] = {
+ { SCMI_PROTOCOL_TELEMETRY, "telemetry" },
+ { }
+};
+MODULE_DEVICE_TABLE(scmi, scmi_id_table);
+
+static struct scmi_driver scmi_telemetry_driver = {
+ .name = "scmi-telemetry-driver",
+ .probe = scmi_telemetry_probe,
+ .remove = scmi_telemetry_remove,
+ .id_table = scmi_id_table,
+};
+
+static struct inode *stlmfs_alloc_inode(struct super_block *sb)
+{
+ struct scmi_tlm_inode *tlmi;
+
+ tlmi = alloc_inode_sb(sb, stlmfs_inode_cachep, GFP_KERNEL);
+ if (!tlmi)
+ return NULL;
+
+ tlmi->cls = NULL;
+
+ return &tlmi->vfs_inode;
+}
+
+static void stlmfs_free_inode(struct inode *inode)
+{
+ struct scmi_tlm_inode *tlmi = to_tlm_inode(inode);
+
+ if (tlmi->cls && IS_DYNAMIC(tlmi->cls->flags)) {
+ kfree(tlmi->cls->name);
+ kfree(tlmi->cls);
+ }
+
+ kmem_cache_free(stlmfs_inode_cachep, tlmi);
+}
+
+static const struct super_operations tlm_sops = {
+ .statfs = simple_statfs,
+ .alloc_inode = stlmfs_alloc_inode,
+ .free_inode = stlmfs_free_inode,
+};
+
+static struct dentry *stlmfs_create_root_dentry(struct super_block *sb)
+{
+ struct dentry *dentry;
+ struct inode *inode;
+
+ inode = stlmfs_get_inode(sb, S_IFDIR | 0755);
+ if (!inode)
+ return ERR_PTR(-ENOMEM);
+
+ inode->i_op = &simple_dir_inode_operations;
+ inode->i_fop = &simple_dir_operations;
+
+ dentry = d_make_root(inode);
+ if (!dentry)
+ return ERR_PTR(-ENOMEM);
+
+ return dentry;
+}
+
+static int scmi_tlm_root_dentries_initialize(struct scmi_tlm_instance *ti)
+{
+ struct scmi_tlm_setup *tsp = ti->tsp;
+ struct super_block *sb = ti->sb;
+
+ scnprintf(ti->name, MAX_INST_NAME, "tlm_%d", ti->id);
+
+ /* Allocate top instance node */
+ ti->top_cls.name = ti->name;
+ ti->top_cls.mode = S_IFDIR | 0755;
+
+ /* Create the root of this instance */
+ ti->top_dentry = stlmfs_create_dentry(sb, tsp, sb->s_root, &ti->top_cls, NULL);
+ for (const struct scmi_tlm_class *tlmo = tlm_tops; tlmo->name; tlmo++)
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, tlmo, ti->info);
+
+ if (ti->info->reset_support)
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &reset_tlmo, NULL);
+
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &version_tlmo,
+ &ti->info->base.version);
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &data_tlmo, ti->info);
+ if (ti->info->single_read_support)
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry,
+ &single_sample_tlmo, ti->info);
+ ti->des_dentry =
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &des_dir_cls, NULL);
+ ti->grps_dentry =
+ stlmfs_create_dentry(sb, tsp, ti->top_dentry, &groups_dir_cls, NULL);
+
+ return 0;
+}
+
+static int scmi_telemetry_instance_register(struct super_block *sb,
+ struct scmi_tlm_instance *ti)
+{
+ int ret;
+
+ ti->sb = sb;
+ ret = scmi_tlm_root_dentries_initialize(ti);
+ if (ret)
+ return ret;
+
+ ret = scmi_telemetry_des_initialize(ti);
+ if (ret)
+ return ret;
+
+ ret = scmi_telemetry_groups_initialize(ti);
+ if (ret) {
+ dev_warn(ti->tsp->dev,
+ "Failed to initialize groups for instance %s.\n",
+ ti->top_cls.name);
+ }
+
+ return 0;
+}
+
+static int stlmfs_fill_super(struct super_block *sb, struct fs_context *fc)
+{
+ struct scmi_tlm_instance *ti;
+ struct dentry *root_dentry;
+ int ret;
+
+ sb->s_magic = TLM_FS_MAGIC;
+ sb->s_blocksize = PAGE_SIZE;
+ sb->s_blocksize_bits = PAGE_SHIFT;
+ sb->s_op = &tlm_sops;
+
+ root_dentry = stlmfs_create_root_dentry(sb);
+ if (IS_ERR(root_dentry))
+ return PTR_ERR(root_dentry);
+
+ sb->s_root = root_dentry;
+
+ mutex_lock(&stlmfs_mtx);
+ list_for_each_entry(ti, &scmi_telemetry_instances, node) {
+ mutex_unlock(&stlmfs_mtx);
+ ret = scmi_telemetry_instance_register(sb, ti);
+ if (ret)
+ dev_err(ti->tsp->dev,
+ "Failed to register instance %u.\n", ti->id);
+ mutex_lock(&stlmfs_mtx);
+ }
+ stlmfs_sb = sb;
+ mutex_unlock(&stlmfs_mtx);
+
+ return 0;
+}
+
+static int stlmfs_get_tree(struct fs_context *fc)
+{
+ return get_tree_single(fc, stlmfs_fill_super);
+}
+
+static const struct fs_context_operations stlmfs_fc_ops = {
+ .get_tree = stlmfs_get_tree,
+};
+
+static int stlmfs_init_fs_context(struct fs_context *fc)
+{
+ fc->ops = &stlmfs_fc_ops;
+
+ return 0;
+}
+
+static void stlmfs_kill_sb(struct super_block *sb)
+{
+ mutex_lock(&stlmfs_mtx);
+ stlmfs_sb = NULL;
+ mutex_unlock(&stlmfs_mtx);
+
+ kill_anon_super(sb);
+}
+
+static struct file_system_type scmi_telemetry_fs = {
+ .owner = THIS_MODULE,
+ .name = TLM_FS_NAME,
+ .kill_sb = stlmfs_kill_sb,
+ .init_fs_context = stlmfs_init_fs_context,
+ .fs_flags = 0,
+};
+
+static void stlmfs_init_once(void *arg)
+{
+ struct scmi_tlm_inode *tlmi = arg;
+
+ inode_init_once(&tlmi->vfs_inode);
+}
+
+static int __init scmi_telemetry_init(void)
+{
+ int ret;
+
+ ret = sysfs_create_mount_point(fs_kobj, TLM_FS_MNT);
+ if (ret && ret != -EEXIST)
+ return ret;
+
+ stlmfs_inode_cachep = kmem_cache_create("stlmfs_inode_cache",
+ sizeof(struct scmi_tlm_inode), 0,
+ SLAB_RECLAIM_ACCOUNT | SLAB_ACCOUNT,
+ stlmfs_init_once);
+ if (!stlmfs_inode_cachep) {
+ ret = -ENOMEM;
+ goto out_mnt;
+ }
+
+ ret = register_filesystem(&scmi_telemetry_fs);
+ if (ret)
+ goto out_kmem;
+
+ ret = scmi_register(&scmi_telemetry_driver);
+ if (ret)
+ goto out_reg;
+
+ return 0;
+
+out_reg:
+ unregister_filesystem(&scmi_telemetry_fs);
+out_kmem:
+ kmem_cache_destroy(stlmfs_inode_cachep);
+out_mnt:
+ sysfs_remove_mount_point(fs_kobj, TLM_FS_MNT);
+
+ return ret;
+}
+module_init(scmi_telemetry_init);
+
+static void __exit scmi_telemetry_exit(void)
+{
+ int ret;
+
+ scmi_unregister(&scmi_telemetry_driver);
+ ret = unregister_filesystem(&scmi_telemetry_fs);
+ if (ret)
+ pr_err("Failed to unregister %s\n", TLM_FS_NAME);
+
+ sysfs_remove_mount_point(fs_kobj, TLM_FS_MNT);
+ kmem_cache_destroy(stlmfs_inode_cachep);
+}
+module_exit(scmi_telemetry_exit);
+
+MODULE_AUTHOR("Cristian Marussi <cristian.marussi@arm.com>");
+MODULE_DESCRIPTION("ARM SCMI Telemetry Driver");
+MODULE_LICENSE("GPL");
--
2.54.0
^ permalink raw reply related
* [PATCH v4 18/31] firmware: arm_scmi: Add Telemetry debugfs ABI documentation
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Add description of the debugfs SCMI Telemetry protocol ABI.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
Documentation/ABI/testing/debugfs-scmi | 22 ++++++++++++++++++++++
1 file changed, 22 insertions(+)
diff --git a/Documentation/ABI/testing/debugfs-scmi b/Documentation/ABI/testing/debugfs-scmi
index ee7179ab2edf..9026f75e0016 100644
--- a/Documentation/ABI/testing/debugfs-scmi
+++ b/Documentation/ABI/testing/debugfs-scmi
@@ -68,3 +68,25 @@ Description: Max number of concurrently allowed in-flight SCMI messages for
the currently configured SCMI transport for instance <n> on the
RX channels.
Users: Debugging, any userspace test suite
+
+What: /sys/kernel/debug/scmi/<n>/protocols/0x<m>/
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A subdirectory grouping debug entries related to protocol <m>
+ for instance <n>. Each protocol owns and defines the subtree
+ of entries rooted under this directory.
+Users: Debugging, any userspace test suite
+
+What: /sys/kernel/debug/scmi/<n>/protocols/0x1B/shmtis/<n>
+Date: Nov 2026
+KernelVersion: 7.3
+Contact: cristian.marussi@arm.com
+Description: A set of RO files exposed by the Telemetry protocol (0x1B) in
+ order to dump the latest snapshot of each SHMTI memory area in
+ binary format: each file is named by its SHMTI id.
+ File is seekable and a seek to position zero on an open file
+ causes the SHMTI snapshot to refreshed; file timestamps are
+ updated after each snapshot.
+ This directory reports SHMTIs for instance <n>.
+Users: Debugging, any userspace test suite
--
2.54.0
^ permalink raw reply related
* [PATCH v4 17/31] firmware: arm_scmi: Add Telemetry debugfs SHMTI dump support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Expose one debugfs entry for each discovered SHMTI that can be used to
dump the related SHMTI in binary form from TBGN up to TEND markers.
No processing is done kernel side, beside using proper accessors for
device memory.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
drivers/firmware/arm_scmi/telemetry.c | 90 +++++++++++++++++++++++++++
1 file changed, 90 insertions(+)
diff --git a/drivers/firmware/arm_scmi/telemetry.c b/drivers/firmware/arm_scmi/telemetry.c
index ab1be6c462f1..a43d67494d73 100644
--- a/drivers/firmware/arm_scmi/telemetry.c
+++ b/drivers/firmware/arm_scmi/telemetry.c
@@ -11,6 +11,8 @@
#include <linux/compiler_types.h>
#include <linux/completion.h>
#include <linux/err.h>
+#include <linux/fs.h>
+#include <linux/debugfs.h>
#include <linux/delay.h>
#include <linux/io.h>
#include <linux/limits.h>
@@ -371,6 +373,12 @@ struct telemetry_shmti {
u32 last_magic;
};
+struct scmi_telemetry_dbg_shmti {
+ struct telemetry_shmti *shmti;
+ size_t buf_sz;
+ void *buf;
+};
+
#define SHMTI_EPLG(s) \
({ \
struct telemetry_shmti *_s = (s); \
@@ -1299,6 +1307,85 @@ scmi_telemetry_enumerate_common_intervals(struct telemetry_info *ti)
ti->info.intervals);
}
+static int scmi_telemetry_dbg_shmti_open(struct inode *inode, struct file *filp)
+{
+ struct scmi_telemetry_dbg_shmti *sblob;
+ struct telemetry_shmti *shmti;
+
+ if (!inode->i_private)
+ return -ENODEV;
+
+ shmti = inode->i_private;
+ sblob = kzalloc_obj(*sblob);
+ if (!sblob)
+ return -ENOMEM;
+
+ sblob->shmti = shmti;
+ sblob->buf = kzalloc(shmti->len, GFP_KERNEL);
+ if (!sblob->buf) {
+ kfree(sblob);
+ return -ENOMEM;
+ }
+
+ filp->private_data = sblob;
+
+ return 0;
+}
+
+static ssize_t scmi_telemetry_dbg_shmti_read(struct file *filp, char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct scmi_telemetry_dbg_shmti *sblob = filp->private_data;
+
+ /* Dump on first read and again after each rewind to start pos */
+ if (!sblob->buf_sz || *ppos == 0) {
+ memcpy_fromio(sblob->buf, sblob->shmti->base, sblob->shmti->len);
+ sblob->buf_sz = sblob->shmti->len;
+ /* update inode timestamps */
+ simple_inode_init_ts(file_inode(filp));
+ }
+
+ return simple_read_from_buffer(buf, count, ppos, sblob->buf, sblob->buf_sz);
+}
+
+static int scmi_telemetry_dbg_shmti_release(struct inode *inode, struct file *filp)
+{
+ struct scmi_telemetry_dbg_shmti *sblob = filp->private_data;
+
+ kfree(sblob->buf);
+ kfree(sblob);
+
+ return 0;
+}
+
+static const struct file_operations scmi_telemetry_dbg_shmti_fops = {
+ .open = scmi_telemetry_dbg_shmti_open,
+ .release = scmi_telemetry_dbg_shmti_release,
+ .read = scmi_telemetry_dbg_shmti_read,
+ .llseek = generic_file_llseek,
+ .owner = THIS_MODULE,
+};
+
+static void scmi_telemetry_debugfs_initialize(struct telemetry_info *ti)
+{
+ const struct scmi_protocol_handle *ph = ti->ph;
+ struct dentry *top, *shmti_top;
+
+ top = ph->hops->debugfs_proto_dentry_get(ph);
+ shmti_top = debugfs_create_dir("shmtis", top);
+
+ for (unsigned int i = 0; i < ti->num_shmti; i++) {
+ struct dentry *d;
+ char id[16];
+
+ snprintf(id, 16, "%u", i);
+ d = debugfs_create_file(id, 0444, shmti_top, &ti->shmti[i],
+ &scmi_telemetry_dbg_shmti_fops);
+ if (!IS_ERR(d))
+ i_size_write(d->d_inode, ti->shmti[i].len);
+ }
+}
+
static int iter_shmti_update_state(struct scmi_iterator_state *st,
const void *response, void *priv)
{
@@ -3195,6 +3282,9 @@ static int scmi_telemetry_protocol_init(const struct scmi_protocol_handle *ph)
"Could NOT register Telemetry notifications\n");
}
+ if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_PROTOCOLS))
+ scmi_telemetry_debugfs_initialize(ti);
+
return ret;
}
--
2.54.0
^ permalink raw reply related
* [PATCH v4 16/31] firmware: arm_scmi: Add common per-protocol debugfs support
From: Cristian Marussi @ 2026-06-12 22:37 UTC (permalink / raw)
To: linux-kernel, linux-arm-kernel, arm-scmi, linux-fsdevel,
linux-doc
Cc: sudeep.holla, james.quinlan, f.fainelli, vincent.guittot,
etienne.carriere, peng.fan, michal.simek, d-gole, jic23,
elif.topuz, lukasz.luba, philip.radford, brauner,
souvik.chakravarty, leitao, kas, puranjay, usama.arif,
kernel-team, Cristian Marussi
In-Reply-To: <20260612223802.1337232-1-cristian.marussi@arm.com>
Allow interested SCMI protocols to register their own specific debugfs
entries under a common per-instance and per-protocol subtree rooted
at /sys/kernel/debug/scmi/<N>/protocols/<PROTO_ID>/
Expose a helper to enable protocol initialization code to get access to
such per-protocol/per-instance dentries in order to be able to install
their own dedicated debugfs entries.
Per-protocol debugfs support is configurable and default off.
Signed-off-by: Cristian Marussi <cristian.marussi@arm.com>
---
drivers/firmware/arm_scmi/Kconfig | 14 +++++++++++++
drivers/firmware/arm_scmi/common.h | 2 ++
drivers/firmware/arm_scmi/driver.c | 29 +++++++++++++++++++++++++++
drivers/firmware/arm_scmi/protocols.h | 6 ++++++
include/linux/scmi_protocol.h | 12 ++++++++++-
5 files changed, 62 insertions(+), 1 deletion(-)
diff --git a/drivers/firmware/arm_scmi/Kconfig b/drivers/firmware/arm_scmi/Kconfig
index e3fb36825978..06d2319420a0 100644
--- a/drivers/firmware/arm_scmi/Kconfig
+++ b/drivers/firmware/arm_scmi/Kconfig
@@ -69,6 +69,20 @@ config ARM_SCMI_DEBUG_COUNTERS
such useful debug counters. This can be helpful for debugging and
SCMI monitoring.
+config ARM_SCMI_DEBUG_PROTOCOLS
+ bool "Enable SCMI protocols debug"
+ select ARM_SCMI_NEED_DEBUGFS
+ depends on DEBUG_FS
+ default n
+ help
+ Enables per-protocol specific debug features, where available.
+ When provided, such per-protocol debugfs entries are grouped
+ inside a common a subtree named by the protocol number and rooted
+ under a per-instance 'protocols' directory.
+
+ Such per-protocol entries subtree structure is freely defined
+ within the related protocol code.
+
config ARM_SCMI_QUIRKS
bool "Enable SCMI Quirks framework"
depends on JUMP_LABEL || COMPILE_TEST
diff --git a/drivers/firmware/arm_scmi/common.h b/drivers/firmware/arm_scmi/common.h
index a8a45bacfa3f..79fda80f049a 100644
--- a/drivers/firmware/arm_scmi/common.h
+++ b/drivers/firmware/arm_scmi/common.h
@@ -321,6 +321,7 @@ enum debug_counters {
/**
* struct scmi_debug_info - Debug common info
* @top_dentry: A reference to the top debugfs dentry
+ * @protos: A reference to the top debugfs protocols subdirectory
* @name: Name of this SCMI instance
* @type: Type of this SCMI instance
* @is_atomic: Flag to state if the transport of this instance is atomic
@@ -328,6 +329,7 @@ enum debug_counters {
*/
struct scmi_debug_info {
struct dentry *top_dentry;
+ struct dentry *protos;
const char *name;
const char *type;
bool is_atomic;
diff --git a/drivers/firmware/arm_scmi/driver.c b/drivers/firmware/arm_scmi/driver.c
index dd9446b54858..e844f40b19d9 100644
--- a/drivers/firmware/arm_scmi/driver.c
+++ b/drivers/firmware/arm_scmi/driver.c
@@ -18,6 +18,7 @@
#include <linux/bitmap.h>
#include <linux/cleanup.h>
+#include <linux/dcache.h>
#include <linux/debugfs.h>
#include <linux/device.h>
#include <linux/export.h>
@@ -99,6 +100,8 @@ struct scmi_xfers_info {
* has completed.
* @ph: An embedded protocol handle that will be passed down to protocol
* initialization code to identify this instance.
+ * @dbg: An optional reference to this protocol top debugfs directory; it will
+ * be automatically recursively removed on protocol de-initialization.
*
* Each protocol is initialized independently once for each SCMI platform in
* which is defined by DT and implemented by the SCMI server fw.
@@ -112,6 +115,7 @@ struct scmi_protocol_instance {
unsigned int version;
unsigned int negotiated_version;
struct scmi_protocol_handle ph;
+ struct dentry *dbg;
};
#define ph_to_pi(h) container_of(h, struct scmi_protocol_instance, ph)
@@ -2054,6 +2058,25 @@ static void scmi_common_fastchannel_db_ring(struct scmi_fc_db_info *db)
SCMI_PROTO_FC_RING_DB(64);
}
+static struct dentry *
+scmi_debugfs_proto_dentry_get(const struct scmi_protocol_handle *ph)
+{
+ struct scmi_protocol_instance *pi = ph_to_pi(ph);
+ struct scmi_info *info = handle_to_scmi_info(pi->handle);
+
+ if (!IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_PROTOCOLS))
+ return ERR_PTR(-ENODEV);
+
+ if (!pi->dbg) {
+ char proto_dir[8];
+
+ snprintf(proto_dir, 8, "0x%02X", pi->proto->id);
+ pi->dbg = debugfs_create_dir(proto_dir, info->dbg->protos);
+ }
+
+ return pi->dbg;
+}
+
static const struct scmi_proto_helpers_ops helpers_ops = {
.extended_name_get = scmi_common_extended_name_get,
.get_max_msg_size = scmi_common_get_max_msg_size,
@@ -2062,6 +2085,7 @@ static const struct scmi_proto_helpers_ops helpers_ops = {
.protocol_msg_check = scmi_protocol_msg_check,
.fastchannel_init = scmi_common_fastchannel_init,
.fastchannel_db_ring = scmi_common_fastchannel_db_ring,
+ .debugfs_proto_dentry_get = scmi_debugfs_proto_dentry_get,
};
/**
@@ -2356,6 +2380,8 @@ void scmi_protocol_release(const struct scmi_handle *handle, u8 protocol_id)
if (refcount_dec_and_test(&pi->users)) {
void *gid = pi->gid;
+ debugfs_remove_recursive(pi->dbg);
+
if (pi->proto->events)
scmi_deregister_protocol_events(handle, protocol_id);
@@ -3080,6 +3106,9 @@ static struct scmi_debug_info *scmi_debugfs_common_setup(struct scmi_info *info)
if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_COUNTERS))
scmi_debugfs_counters_setup(dbg, trans);
+ if (IS_ENABLED(CONFIG_ARM_SCMI_DEBUG_PROTOCOLS))
+ dbg->protos = debugfs_create_dir("protocols", top_dentry);
+
dbg->top_dentry = top_dentry;
if (devm_add_action_or_reset(info->dev,
diff --git a/drivers/firmware/arm_scmi/protocols.h b/drivers/firmware/arm_scmi/protocols.h
index 3250d981664b..84ffff9376c9 100644
--- a/drivers/firmware/arm_scmi/protocols.h
+++ b/drivers/firmware/arm_scmi/protocols.h
@@ -11,6 +11,7 @@
#include <linux/bitfield.h>
#include <linux/completion.h>
+#include <linux/debugfs.h>
#include <linux/device.h>
#include <linux/errno.h>
#include <linux/kernel.h>
@@ -272,6 +273,9 @@ struct scmi_fc_info {
* gathering FC descriptions from the SCMI platform server.
* @fastchannel_db_ring: A common helper to ring a FC doorbell.
* @get_max_msg_size: A common helper to get the maximum message size.
+ * @debugfs_proto_dentry_get: A common helper to get a per-protocol debugfs top
+ * directory to use as a root. It will be
+ * recursively removed on protocol de-initialization.
*/
struct scmi_proto_helpers_ops {
int (*extended_name_get)(const struct scmi_protocol_handle *ph,
@@ -292,6 +296,8 @@ struct scmi_proto_helpers_ops {
u32 *rate_limit);
void (*fastchannel_db_ring)(struct scmi_fc_db_info *db);
int (*get_max_msg_size)(const struct scmi_protocol_handle *ph);
+ struct dentry *(*debugfs_proto_dentry_get)
+ (const struct scmi_protocol_handle *ph);
};
/**
diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h
index c7e8a740ce16..6b0ea1c05e7f 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -1076,6 +1076,12 @@ struct scmi_notify_ops {
* never sleep and act accordingly.
* An optional atomic threshold value could be returned
* where configured.
+ * @debugfs_entry_get: method to get, and possibly create, a debugfs dentry
+ * rooted under the top debugfs directory for the SCMI
+ * instance referred by handle.
+ * @debugfs_entry_put: method to put, and possibly destroy, a debugfs dentry
+ * rooted under the top debugfs directory for the SCMI
+ * instance referred by handle.
* @notify_ops: pointer to set of notifications related operations
*/
struct scmi_handle {
@@ -1090,7 +1096,11 @@ struct scmi_handle {
void (*devm_protocol_put)(struct scmi_device *sdev, u8 proto);
bool (*is_transport_atomic)(const struct scmi_handle *handle,
unsigned int *atomic_threshold);
-
+ struct dentry __must_check *
+ (*debugfs_entry_get)(const struct scmi_handle *handle,
+ const char *name);
+ void (*debugfs_entry_put)(const struct scmi_handle *handle,
+ struct dentry *dentry);
const struct scmi_notify_ops *notify_ops;
};
--
2.54.0
^ permalink raw reply related
page: next (older) | prev (newer) | latest
- recent:[subjects (threaded)|topics (new)|topics (active)]
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox