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
next prev parent reply other threads:[~2026-11-18 10:20 UTC|newest]
Thread overview: 15+ 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 ` [PATCH v5 1/7] perf: Increase the maximum number of branches remove_loops() can process 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 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 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 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 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 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 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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox