All of lore.kernel.org
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Vikram Singh" <vikram.singh3@oss.qualcomm.com>
Cc: linux-perf-users@vger.kernel.org, devicetree@vger.kernel.org,
	robh@kernel.org, conor+dt@kernel.org
Subject: Re: [PATCH v5 5/7] riscv: pmu: Add driver for Control Transfer Records Ext
Date: Wed, 18 Nov 2026 10:20:06 +0000	[thread overview]
Message-ID: <sashiko-outbox-220675@kernel.org> (raw)
In-Reply-To: <20261118095053.3871267-6-vikram.singh3@oss.qualcomm.com>

Thank you for your contribution! Sashiko AI review found 13 potential
issues to consider:
- [Critical] riscv: pmu: perf_ctx_data type confusion and missing RCU in
  CTR task context
- [High] riscv: pmu: duplicate RISCV_M_MODE Kconfig definition and
  broken M-mode CSRs
- [High] riscv: pmu: NULL event->ctx->task dereference in
  riscv_pmu_ctr_add() and del()
- [High] riscv: pmu: inverted CTRDATA_CCV check and cycle truncation in
  ctr_get_cycles()
- [High] riscv: pmu: missing SxCSRIND check, CSR_SIREG* mismatch, and
  RV32 truncation
- [High] riscv: pmu: unmerged CSR_CTRCTL without filtering and hardirq
  pr_warn()
- [Medium] riscv: pmu: 32-bit truncation of CSR_CTRCTL filter bits on
  CONFIG_32BIT
- [Medium] riscv: pmu: missing CTR reset in riscv_pmu_ctr_restore() and
  unpaused save
- [Medium] riscv: pmu: section mismatch on check_available_filters() and
  filter validation
- [Medium] riscv: pmu: missing inline on CTR stubs and wrong header
  guard in riscv_pmu.h
- [Medium] riscv: pmu: reserved SCTRDEPTH_MASK write and unclamped
  ctr_get_depth()
- [Medium] riscv: pmu: early return in branch_type_to_ctr() skips
  CTRCTL_RASEMU
- [Low] riscv: pmu: non-existent Documentation/arch/riscv/pmu-sse.rst in
  MAINTAINERS
--

commit 10ed00c3c43c9d9b32ecbe8d5c8ccf6143b76904
Author: Vikram Singh <vikram.singh3@oss.qualcomm.com>

riscv: pmu: Add driver for Control Transfer Records Ext

This commit adds a driver for the RISC-V Control Transfer Records (CTR)
extension to support hardware branch stack sampling in perf.

Link: https://lore.kernel.org/r/20261106173942.3175069-6-vikram.singh3@oss.qualcomm.com

> diff --git a/MAINTAINERS b/MAINTAINERS
> index 93abbb315065d..19ddb35654445 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -24126,8 +24126,11 @@ F:	arch/riscv/boot/dts/sifive/
>  RISC-V PMU DRIVERS
>  M:	Atish Patra <atish.patra@linux.dev>
>  R:	Anup Patel <anup@brainfault.org>
> +R:	Vikram Singh <vikram.singh3@oss.qualcomm.com>
>  L:	linux-riscv@lists.infradead.org
>  S:	Supported
> +F:	Documentation/arch/riscv/pmu-sse.rst
> +F:	drivers/perf/riscv_ctr.c

[Severity: Low]
Documentation/arch/riscv/pmu-sse.rst does not exist in the tree, which causes
get_maintainer.pl and documentation file reference checks to warn.

> diff --git a/drivers/perf/Kconfig b/drivers/perf/Kconfig
> index 245e7bb763b99..0b4c04c50c227 100644
> --- a/drivers/perf/Kconfig
> +++ b/drivers/perf/Kconfig
> @@ -129,6 +129,22 @@ config ANDES_CUSTOM_PMU
>  
>  	  If you don't know what to do here, say "Y".
>  
> +config RISCV_CTR
> +	bool "Enable support for Control Transfer Records (CTR)"
> +	depends on PERF_EVENTS && RISCV_PMU
> +	default y
> +	help
> +	  Enable support for Control Transfer Records (CTR) which
> +	  allows recording branches, Jumps, Calls, returns etc taken in an
> +	  execution path. This also supports privilege based filtering. It
> +	  captures additional relevant information such as cycle count,
> +	  branch misprediction etc.

[Severity: Medium]
Should RISCV_CTR depend on 64BIT?

On CONFIG_32BIT=y builds, csr_read() and csr_write() cast values to a 32-bit
unsigned long, truncating bits 33..47 (CTRCTL_EXCINH through
CTRCTL_DIROJUMP_INH) of CSR_CTRCTL in check_available_filters() and
riscv_pmu_ctr_enable().

> +
> +config RISCV_M_MODE
> +		bool "Enable M Mode"
> +		depends on RISCV_CTR
> +		default n

[Severity: High]
Does defining RISCV_M_MODE here conflict with the architecture-wide symbol in
arch/riscv/Kconfig?

arch/riscv/Kconfig restricts RISCV_M_MODE with "depends on !MMU", whereas
redefining it here without "!MMU" makes CONFIG_RISCV_M_MODE selectable on
S-mode MMU kernels (and enabled in allyesconfig/allmodconfig).  That disables
CONFIG_RISCV_SBI and switches core CSR macros such as CSR_STATUS, CSR_IE and
CSR_TVEC to Machine-mode CSRs, breaking S-mode builds and boot.

> diff --git a/drivers/perf/riscv_ctr.c b/drivers/perf/riscv_ctr.c
> new file mode 100644
> index 0000000000000..1af8a304dd699
> --- /dev/null
> +++ b/drivers/perf/riscv_ctr.c
[ ... ]
> +static inline u64 get_ctr_src_reg(unsigned int ctr_idx)
> +{
> +	return csr_indirect_read(CSR_SIREG, CTR_ENTRIES_FIRST, ctr_idx);
> +}
> +
> +static inline void set_ctr_src_reg(unsigned int ctr_idx, u64 value)
> +{
> +	return csr_indirect_write(CSR_SIREG, CTR_ENTRIES_FIRST, ctr_idx, value);
> +}
> +
> +static inline u64 get_ctr_tgt_reg(unsigned int ctr_idx)
> +{
> +	return csr_indirect_read(CSR_SIREG2, CTR_ENTRIES_FIRST, ctr_idx);
> +}
> +
> +static inline void set_ctr_tgt_reg(unsigned int ctr_idx, u64 value)
> +{
> +	return csr_indirect_write(CSR_SIREG2, CTR_ENTRIES_FIRST, ctr_idx, value);
> +}
> +
> +static inline u64 get_ctr_data_reg(unsigned int ctr_idx)
> +{
> +	return csr_indirect_read(CSR_SIREG3, CTR_ENTRIES_FIRST, ctr_idx);
> +}
> +
> +static inline void set_ctr_data_reg(unsigned int ctr_idx, u64 value)
> +{
> +	return csr_indirect_write(CSR_SIREG3, CTR_ENTRIES_FIRST, ctr_idx, value);
> +}

[Severity: High]
Should these helpers pass CSR_IREG, CSR_IREG2 and CSR_IREG3 instead of
hardcoding S-mode CSR_SIREG, CSR_SIREG2 and CSR_SIREG3?

csr_indirect_read() and csr_indirect_write() program CSR_ISELECT (which maps
to CSR_MISELECT under CONFIG_RISCV_M_MODE), so passing CSR_SIREG* accesses the
wrong indirect CSR window in M-mode.  In addition, riscv_pmu_ctr_init(),
riscv_pmu_ctr_starting_cpu() and riscv_pmu_ctr_dying_cpu() only check for
SxCTR and SSCOFPMF without checking riscv_isa_extension_available(NULL,
SxCSRIND), which traps with an illegal instruction if SxCSRIND is absent.

[ ... ]

> +static inline unsigned int ctr_get_cycles(u64 ctr_data)
> +{
> +	const unsigned int cce = FIELD_GET(CTRDATA_CCE_MASK, ctr_data);
> +	const unsigned int ccm = FIELD_GET(CTRDATA_CCM_MASK, ctr_data);
> +
> +	if (ctr_data & CTRDATA_CCV)
> +		return 0;
> +
> +	/* Formula to calculate cycles from spec: (2^12 + CCM) << CCE-1 */
> +	if (cce > 0)
> +		return (4096 + ccm) << (cce - 1);
> +
> +	return FIELD_GET(CTRDATA_CCM_MASK, ctr_data);
> +}

[Severity: High]
Is the CTRDATA_CCV check inverted here?

Per the CTR specification, CTRDATA_CCV (Cycle Count Valid) is 1 when the cycle
count is valid and 0 when invalid, so returning 0 when CTRDATA_CCV is set
discards all valid cycle counts.  Also, (4096 + ccm) << (cce - 1) can reach
27 bits when cce >= 5, so assigning the unclamped return value to the 16-bit
entry->cycles bitfield in capture_ctr_flags() truncates the upper bits instead
of saturating at U16_MAX.

> +
> +static inline unsigned int ctr_get_type(u64 ctr_data)
> +{
> +	return FIELD_GET(CTRDATA_TYPE_MASK, ctr_data);
> +}
> +
> +static inline unsigned int ctr_get_depth(u64 ctr_depth)
> +{
> +	/* Depth table from CTR Spec: 2.4 sctrdepth.
> +	 *
> +	 * sctrdepth.depth       Depth
> +	 * 000			- 16
> +	 * 001			- 32
> +	 * 010			- 64
> +	 * 011			- 128
> +	 * 100			- 256
> +	 *
> +	 * Depth = 16 * 2 ^ (ctrdepth.depth)
> +	 * or
> +	 * Depth = 16 << ctrdepth.depth.
> +	 */
> +	return 16 << FIELD_GET(SCTRDEPTH_MASK, ctr_depth);
> +}

[Severity: Medium]
Can riscv_pmu->ctr_depth exceed MAX_BRANCH_RECORDS (256) or select a
non-maximum WARL depth?

riscv_pmu_ctr_init() and riscv_pmu_ctr_starting_cpu() write the reserved
encoding SCTRDEPTH_MASK (0x7) instead of SCTRDEPTH_MAX (0x4) to CSR_SCTRDEPTH.
Under WARL rules a reserved value may map to any legal depth, and if an
implementation retains a field value in 5..7, ctr_get_depth() returns
512..2048 and overflows cpuc->branches->branch_entries[MAX_BRANCH_RECORDS] and
task_ctx->store[MAX_BRANCH_RECORDS].

[ ... ]

> +static u64 branch_type_to_ctr(int branch_type)
> +{
> +	u64 config = CTR_BRANCH_FILTERS_INH | CTRCTL_LCOFIFRZ;
> +
> +	if (branch_type & PERF_SAMPLE_BRANCH_USER)
> +		config |= CTRCTL_U_ENABLE;
> +
> +	if (branch_type & PERF_SAMPLE_BRANCH_KERNEL)
> +		config |= CTRCTL_KERNEL_ENABLE;
> +
> +	if (branch_type & PERF_SAMPLE_BRANCH_HV) {
> +		if (riscv_isa_extension_available(NULL, H))
> +			config |= CTRCTL_KERNEL_ENABLE;
> +	}
> +
> +	if (branch_type & PERF_SAMPLE_BRANCH_ANY) {
> +		config &= ~CTR_BRANCH_FILTERS_INH;
> +		return config;
> +	}

[Severity: Medium]
Does returning early for PERF_SAMPLE_BRANCH_ANY skip setting CTRCTL_RASEMU
when PERF_SAMPLE_BRANCH_CALL_STACK is also requested?

riscv_pmu_ctr_valid() and riscv_pmu_ctr_add() accept events combining
PERF_SAMPLE_BRANCH_ANY and PERF_SAMPLE_BRANCH_CALL_STACK, but the early return
here bypasses the PERF_SAMPLE_BRANCH_CALL_STACK check below and leaves RAS
emulation disabled in hardware.

[ ... ]

> +static void ctr_set_perf_entry_type(struct perf_branch_entry *entry,
> +				    u64 ctr_data)
> +{
> +	int ctr_type = ctr_get_type(ctr_data);
> +
> +	entry->type = ctr_perf_map[ctr_type];
> +	if (entry->type == PERF_BR_UNKNOWN)
> +		pr_warn("%d - unknown branch type captured\n", ctr_type);
> +}
[ ... ]
> +static void ctr_regset_to_branch_entry(struct cpu_hw_events *cpuc,
> +				       struct perf_event *event,
> +				       struct ctr_regset *regset,
> +				       unsigned int idx)
> +{
> +	struct perf_branch_entry *entry = &cpuc->branches->branch_entries[idx];
> +
> +	*entry = (struct perf_branch_entry){ };
> +	entry->from = regset->src & (~CTRSOURCE_VALID);
> +	entry->to = regset->target & (~CTRTARGET_MISP);
> +	capture_ctr_flags(entry, event, regset->ctr_data, regset->target);
> +}

[Severity: High]
Can concurrent CTR events clobber CSR_CTRCTL or leak kernel branch addresses
to unprivileged user-only events, and can ctr_set_perf_entry_type() flood the
kernel log from hardirq context?

riscv_pmu_ctr_enable() overwrites CSR_CTRCTL with a single event's
configuration and riscv_pmu_ctr_disable() unconditionally zeroes CSR_CTRCTL
while other CTR events on the CPU are still active.  When a privileged kernel
event and an unprivileged PERF_SAMPLE_BRANCH_USER event share a CPU (or when
branch_type_to_ctr() clears CTRCTL_EXCINH, CTRCTL_INTRINH and CTRCTL_TRETINH
without PERF_SAMPLE_BRANCH_KERNEL), ctr_regset_to_branch_entry() copies
entries without software privilege or type filtering.  Also,
CTRDATA_TYPE_CO_ROUTINE_SWAP (produced by unprivileged jalr x1, x5, 0
instructions) maps to PERF_BR_UNKNOWN and triggers an un-ratelimited pr_warn()
up to 256 times per PMU overflow interrupt.

[ ... ]

> +static void riscv_pmu_ctr_restore(void *ctx)
> +{
> +	if (task_context(ctx)->stack_state == CTR_STATE_NONE ||
> +	    task_context(ctx)->callstack_users == 0) {
> +		return;
> +	}
> +
> +	riscv_pmu_ctr_reset();
> +	__riscv_pmu_ctr_restore(ctx);
> +
> +	task_context(ctx)->stack_state = CTR_STATE_NONE;
> +}
> +
> +static void __riscv_pmu_ctr_save(void *ctx, unsigned int depth)
> +{
> +	struct riscv_perf_task_context *task_ctx = ctx;
> +	struct ctr_regset *dst;
> +	unsigned int i;
> +
> +	for (i = 0; i < depth; i++) {
> +		dst = &task_ctx->store[i];
> +		if (!get_ctr_regset(dst, i))
> +			break;
> +	}
> +
> +	task_ctx->num_entries = i;
> +
> +	task_ctx->ctr_status = csr_read(CSR_SCTRSTATUS);
> +}

[Severity: Medium]
Does returning early in riscv_pmu_ctr_restore() leave the previous task's
branch records in the CTR registers?

When task_ctx is non-NULL on context switch in, riscv_pmu_ctr_sched_task()
calls riscv_pmu_ctr_restore() and returns before reaching the fallback
riscv_pmu_ctr_reset(), so an early return when stack_state == CTR_STATE_NONE
or callstack_users == 0 exposes stale hardware records to the incoming task.
In addition, __riscv_pmu_ctr_save() and __riscv_pmu_ctr_restore() access the
CTR registers without clearing CTR_BRANCH_ENABLE_BITS in CSR_CTRCTL first, so
branches taken during the save/restore loops corrupt the state when kernel
branch recording is enabled.

[ ... ]

> +void riscv_pmu_ctr_sched_task(struct perf_event_pmu_context *pmu_ctx, struct task_struct *task,
> +			      bool sched_in)
> +{
> +	struct riscv_pmu *rvpmu = to_riscv_pmu(pmu_ctx->pmu);
> +	struct cpu_hw_events *cpuc = this_cpu_ptr(rvpmu->hw_events);
> +	void *task_ctx;
> +
> +	if (!cpuc->ctr_users)
> +		return;
> +
> +	/* Save branch records in task_ctx on sched out */
> +	task_ctx = pmu_ctx ? task->perf_ctx_data : NULL;
> +	if (task_ctx) {
> +		if (sched_in)
> +			riscv_pmu_ctr_restore(task_ctx);
> +		else
> +			riscv_pmu_ctr_save(task_ctx, rvpmu->ctr_depth);
> +		return;
> +	}
> +
> +	/* Reset branch records on sched in */
> +	if (sched_in)
> +		riscv_pmu_ctr_reset();
> +}
> +
> +static inline bool branch_user_callstack(unsigned int br_type)
> +{
> +	return (br_type & PERF_SAMPLE_BRANCH_USER) &&
> +		(br_type & PERF_SAMPLE_BRANCH_CALL_STACK);
> +}
> +
> +void riscv_pmu_ctr_add(struct perf_event *event)
> +{
> +	struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);
> +	struct cpu_hw_events *cpuc = this_cpu_ptr(rvpmu->hw_events);
> +
> +	if (branch_user_callstack(event->attr.branch_sample_type) &&
> +	    event->ctx->task->perf_ctx_data)
> +		task_context(event->ctx->task->perf_ctx_data)->callstack_users++;
> +
> +	perf_sched_cb_inc(event->pmu);
> +
> +	if (!cpuc->ctr_users++)
> +		riscv_pmu_ctr_reset();
> +}
> +
> +void riscv_pmu_ctr_del(struct perf_event *event)
> +{
> +	struct riscv_pmu *rvpmu = to_riscv_pmu(event->pmu);
> +	struct cpu_hw_events *cpuc = this_cpu_ptr(rvpmu->hw_events);
> +
> +	if (branch_user_callstack(event->attr.branch_sample_type) &&
> +	    event->ctx->task->perf_ctx_data)
> +		task_context(event->ctx->task->perf_ctx_data)->callstack_users--;

[Severity: Critical]
Does passing task->perf_ctx_data directly to task_context(),
riscv_pmu_ctr_save() and riscv_pmu_ctr_restore() corrupt struct perf_ctx_data
and overflow the slab allocation?

task->perf_ctx_data is an RCU-protected pointer to a 40-byte struct
perf_ctx_data wrapper whose ->data field holds the PMU's task_ctx_cache
object:

include/linux/perf_event.h:
struct perf_ctx_data {
	struct rcu_head			rcu_head;
	refcount_t			refcount;
	unsigned int			global;
	struct kmem_cache		*ctx_cache;
	void				*data;
};

Treating task->perf_ctx_data itself as struct riscv_perf_task_context
overwrites rcu_head when updating callstack_users and writes up to 256
ctr_regset entries (6144 bytes) past the 40-byte struct perf_ctx_data on
context switch.  These accesses should use rcu_dereference(task->perf_ctx_data)
under rcu_read_lock() and pass cd->data to task_context().

[Severity: High]
Can event->ctx->task be NULL in riscv_pmu_ctr_add() and riscv_pmu_ctr_del()?

For per-CPU events (pid == -1) configured with PERF_SAMPLE_BRANCH_USER |
PERF_SAMPLE_BRANCH_CALL_STACK, event->ctx->task is NULL, so evaluating
event->ctx->task->perf_ctx_data causes a NULL pointer dereference when the
event is scheduled in or out.

[ ... ]

> +static void __init check_available_filters(void)
> +{
[ ... ]
> +	if (ctr_ctl & (CTRCTL_INDCALL_INH | CTRCTL_DIRCALL_INH))
> +		allowed_filters |= PERF_SAMPLE_BRANCH_ANY_CALL;
[ ... ]
> +}
[ ... ]
> +int riscv_pmu_ctr_init(struct riscv_pmu *riscv_pmu)
> +{
> +	size_t size = sizeof(struct riscv_perf_task_context);
> +
> +	if (!riscv_isa_extension_available(NULL, SxCTR) ||
> +	    !riscv_isa_extension_available(NULL, SSCOFPMF))
> +		return 0;
> +
> +	riscv_pmu->pmu.task_ctx_cache =
> +		kmem_cache_create("ctr_task_ctx", size, sizeof(u64), 0, NULL);
> +	if (!riscv_pmu->pmu.task_ctx_cache)
> +		return -ENOMEM;
> +
> +	check_available_filters();

[Severity: Medium]
Does calling __init check_available_filters() from non-__init
riscv_pmu_ctr_init() cause a section mismatch?

riscv_pmu_ctr_init() is in .text and called from platform driver probe, so
calling check_available_filters() in .init.text triggers a modpost warning and
will execute freed init memory if probe is deferred or rebound after boot.
Also, check_available_filters() checks whether each branch type's own inhibit
bit is writable rather than the complement inhibit bits used by
branch_type_to_ctr() to isolate that type, and riscv_pmu_ctr_valid() does not
verify that at least one branch type filter is set in branch_sample_type.

> diff --git a/include/linux/perf/riscv_pmu.h b/include/linux/perf/riscv_pmu.h
> index c748a06ad7514..848977ecf319f 100644
> --- a/include/linux/perf/riscv_pmu.h
> +++ b/include/linux/perf/riscv_pmu.h
[ ... ]
>  #endif /* CONFIG_RISCV_PMU */
>  
> +#ifdef CONFIG_RISCV_CTR
> +
> +bool riscv_pmu_ctr_valid(struct perf_event *event);
> +void riscv_pmu_ctr_consume(struct cpu_hw_events *cpuc, struct perf_event *event);
[ ... ]
> +#else
> +
> +static inline bool riscv_pmu_ctr_valid(struct perf_event *event) { return false; }
> +static inline void riscv_pmu_ctr_consume(struct cpu_hw_events *cpuc,
> +					 struct perf_event *event) { }
> +static inline void riscv_pmu_ctr_sched_task(struct perf_event_pmu_context *,
> +					    struct task_struct *task, bool sched_in) { }
> +static void riscv_pmu_ctr_add(struct perf_event *event) { }
> +static void riscv_pmu_ctr_del(struct perf_event *event) { }

[Severity: Medium]
Should riscv_pmu_ctr_add() and riscv_pmu_ctr_del() be marked static inline,
and should the CONFIG_RISCV_CTR block sit inside #ifdef CONFIG_RISCV_PMU?

Without inline, every translation unit including this header when
CONFIG_RISCV_CTR=n triggers -Wunused-function warnings.  Also, struct
cpu_hw_events and struct riscv_pmu are only declared inside #ifdef
CONFIG_RISCV_PMU, so placing these prototypes after #endif /* CONFIG_RISCV_PMU
*/ triggers -Wvisibility warnings when CONFIG_RISCV_PMU=n.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261118095053.3871267-1-vikram.singh3@oss.qualcomm.com?part=5

  reply	other threads:[~2026-11-18 10:20 UTC|newest]

Thread overview: 23+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-18  9:50 [PATCH v5 0/7] riscv: pmu: Add support for Control Transfer Records Ext Vikram Singh
2026-11-18  9:50 ` Vikram Singh
2026-11-18  9:50 ` [PATCH v5 1/7] perf: Increase the maximum number of branches remove_loops() can process Vikram Singh
2026-11-18  9:50   ` Vikram Singh
2026-11-18  9:58   ` sashiko-bot
2026-11-18  9:50 ` [PATCH v5 2/7] riscv: pmu: Add Control transfer records CSR definations Vikram Singh
2026-11-18  9:50   ` Vikram Singh
2026-11-18 10:00   ` sashiko-bot
2026-11-18  9:50 ` [PATCH v5 3/7] riscv: Add Control Transfer Records extension parsing Vikram Singh
2026-11-18  9:50   ` Vikram Singh
2026-11-18 10:02   ` sashiko-bot
2026-11-18  9:50 ` [PATCH v5 4/7] riscv: pmu: Add infrastructure for Control Transfer Record Vikram Singh
2026-11-18  9:50   ` Vikram Singh
2026-11-18 10:09   ` sashiko-bot
2026-11-18  9:50 ` [PATCH v5 5/7] riscv: pmu: Add driver for Control Transfer Records Ext Vikram Singh
2026-11-18  9:50   ` Vikram Singh
2026-11-18 10:20   ` sashiko-bot [this message]
2026-11-18  9:50 ` [PATCH v5 6/7] riscv: pmu: Integrate CTR Ext support in riscv_pmu_dev driver Vikram Singh
2026-11-18  9:50   ` Vikram Singh
2026-11-18 10:21   ` sashiko-bot
2026-11-18  9:50 ` [PATCH v5 7/7] dt-bindings: riscv: add Sxctr ISA extension description Vikram Singh
2026-11-18  9:50   ` Vikram Singh
2026-11-18 10:24   ` sashiko-bot

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=sashiko-outbox-220675@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=conor+dt@kernel.org \
    --cc=devicetree@vger.kernel.org \
    --cc=linux-perf-users@vger.kernel.org \
    --cc=robh@kernel.org \
    --cc=sashiko-reviews@lists.linux.dev \
    --cc=vikram.singh3@oss.qualcomm.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.