From: Mykyta Yatsenko <mykyta.yatsenko5@gmail.com>
To: Kumar Kartikeya Dwivedi <memxor@gmail.com>, bpf@vger.kernel.org
Cc: Emil Tsalapatis <emil@etsalapatis.com>,
Alexei Starovoitov <ast@kernel.org>,
Andrii Nakryiko <andrii@kernel.org>,
Daniel Borkmann <daniel@iogearbox.net>,
Martin KaFai Lau <martin.lau@kernel.org>,
Eduard Zingerman <eddyz87@gmail.com>, Tejun Heo <tj@kernel.org>,
Dan Schatzberg <dschatzberg@meta.com>,
kkd@meta.com, kernel-team@meta.com
Subject: Re: [PATCH bpf-next v3 2/3] selftests/bpf: Add syscall ctx variable offset tests
Date: Wed, 18 Mar 2026 14:45:22 +0000 [thread overview]
Message-ID: <878qbpkxh9.fsf@gmail.com> (raw)
In-Reply-To: <20260318103526.2590079-3-memxor@gmail.com>
Kumar Kartikeya Dwivedi <memxor@gmail.com> writes:
> Add various tests to exercise fixed and variable offsets on PTR_TO_CTX
> for syscall programs, and cover disallowed cases for other program types
> lacking convert_ctx_access callback. Load verifier_ctx with CAP_SYS_ADMIN
> so that kfunc related logic can be tested. While at it, convert assembly
> tests to C.
>
> Reviewed-by: Emil Tsalapatis <emil@etsalapatis.com>
> Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
> ---
> .../selftests/bpf/prog_tests/verifier.c | 34 +-
> .../selftests/bpf/progs/verifier_ctx.c | 356 +++++++++++++++---
> .../selftests/bpf/test_kmods/bpf_testmod.c | 2 +-
> 3 files changed, 325 insertions(+), 67 deletions(-)
>
> diff --git a/tools/testing/selftests/bpf/prog_tests/verifier.c b/tools/testing/selftests/bpf/prog_tests/verifier.c
> index 8cdfd74c95d7..04d5f46264a3 100644
> --- a/tools/testing/selftests/bpf/prog_tests/verifier.c
> +++ b/tools/testing/selftests/bpf/prog_tests/verifier.c
> @@ -126,29 +126,35 @@ struct test_val {
> __maybe_unused
> static void run_tests_aux(const char *skel_name,
> skel_elf_bytes_fn elf_bytes_factory,
> - pre_execution_cb pre_execution_cb)
> + pre_execution_cb pre_execution_cb,
> + bool drop_sys_admin)
> {
> struct test_loader tester = {};
> __u64 old_caps;
> int err;
>
> - /* test_verifier tests are executed w/o CAP_SYS_ADMIN, do the same here */
> - err = cap_disable_effective(1ULL << CAP_SYS_ADMIN, &old_caps);
> - if (err) {
> - PRINT_FAIL("failed to drop CAP_SYS_ADMIN: %i, %s\n", err, strerror(-err));
> - return;
> + if (drop_sys_admin) {
> + /* test_verifier tests are executed w/o CAP_SYS_ADMIN, do the same here */
> + err = cap_disable_effective(1ULL << CAP_SYS_ADMIN, &old_caps);
> + if (err) {
> + PRINT_FAIL("failed to drop CAP_SYS_ADMIN: %i, %s\n", err, strerror(-err));
> + return;
> + }
> }
>
> test_loader__set_pre_execution_cb(&tester, pre_execution_cb);
> test_loader__run_subtests(&tester, skel_name, elf_bytes_factory);
> test_loader_fini(&tester);
>
> - err = cap_enable_effective(old_caps, NULL);
> - if (err)
> - PRINT_FAIL("failed to restore CAP_SYS_ADMIN: %i, %s\n", err, strerror(-err));
> + if (drop_sys_admin) {
> + err = cap_enable_effective(old_caps, NULL);
> + if (err)
> + PRINT_FAIL("failed to restore CAP_SYS_ADMIN: %i, %s\n", err, strerror(-err));
> + }
> }
>
> -#define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL)
> +#define RUN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL, true)
> +#define RUN_WITH_CAP_SYS_ADMIN(skel) run_tests_aux(#skel, skel##__elf_bytes, NULL, false)
>
> void test_verifier_align(void) { RUN(verifier_align); }
> void test_verifier_and(void) { RUN(verifier_and); }
> @@ -173,7 +179,7 @@ void test_verifier_cgroup_skb(void) { RUN(verifier_cgroup_skb); }
> void test_verifier_cgroup_storage(void) { RUN(verifier_cgroup_storage); }
> void test_verifier_const(void) { RUN(verifier_const); }
> void test_verifier_const_or(void) { RUN(verifier_const_or); }
> -void test_verifier_ctx(void) { RUN(verifier_ctx); }
> +void test_verifier_ctx(void) { RUN_WITH_CAP_SYS_ADMIN(verifier_ctx); }
> void test_verifier_ctx_sk_msg(void) { RUN(verifier_ctx_sk_msg); }
> void test_verifier_d_path(void) { RUN(verifier_d_path); }
> void test_verifier_default_trusted_ptr(void) { RUN_TESTS(verifier_default_trusted_ptr); }
> @@ -293,7 +299,8 @@ void test_verifier_array_access(void)
> {
> run_tests_aux("verifier_array_access",
> verifier_array_access__elf_bytes,
> - init_array_access_maps);
> + init_array_access_maps,
> + true);
> }
> void test_verifier_async_cb_context(void) { RUN(verifier_async_cb_context); }
>
> @@ -306,5 +313,6 @@ void test_verifier_value_ptr_arith(void)
> {
> run_tests_aux("verifier_value_ptr_arith",
> verifier_value_ptr_arith__elf_bytes,
> - init_value_ptr_arith_maps);
> + init_value_ptr_arith_maps,
> + true);
> }
> diff --git a/tools/testing/selftests/bpf/progs/verifier_ctx.c b/tools/testing/selftests/bpf/progs/verifier_ctx.c
> index 371780290c0d..c054c8cb7242 100644
> --- a/tools/testing/selftests/bpf/progs/verifier_ctx.c
> +++ b/tools/testing/selftests/bpf/progs/verifier_ctx.c
> @@ -4,6 +4,10 @@
> #include "vmlinux.h"
> #include <bpf/bpf_helpers.h>
> #include "bpf_misc.h"
> +#include "../test_kmods/bpf_testmod_kfunc.h"
> +
> +const char ctx_strncmp_target[] = "ctx";
> +const char ctx_snprintf_fmt[] = "";
>
> SEC("tc")
> __description("context stores via BPF_ATOMIC")
> @@ -69,7 +73,6 @@ __naked void ctx_pointer_to_helper_1(void)
> SEC("socket")
> __description("pass modified ctx pointer to helper, 2")
> __failure __msg("negative offset ctx ptr R1 off=-612 disallowed")
> -__failure_unpriv __msg_unpriv("negative offset ctx ptr R1 off=-612 disallowed")
> __naked void ctx_pointer_to_helper_2(void)
> {
> asm volatile (" \
> @@ -295,77 +298,324 @@ padding_access("sk_reuseport", sk_reuseport_md, hash, 4);
> SEC("syscall")
> __description("syscall: write to ctx with fixed offset")
> __success
> -__naked void syscall_ctx_fixed_off_write(void)
> +int syscall_ctx_fixed_off_write(void *ctx)
> {
> - asm volatile (" \
> - r0 = 0; \
> - *(u32*)(r1 + 0) = r0; \
> - r1 += 4; \
> - *(u32*)(r1 + 0) = r0; \
> - exit; \
> -" ::: __clobber_all);
> + char *p = ctx;
> +
> + *(__u32 *)p = 0;
> + *(__u32 *)(p + 4) = 0;
> + return 0;
> +}
> +
> +SEC("syscall")
> +__description("syscall: read ctx with fixed offset")
> +__success
> +int syscall_ctx_fixed_off_read(void *ctx)
> +{
> + char *p = ctx;
> + volatile __u32 val;
> +
> + val = *(__u32 *)(p + 4);
> + (void)val;
> + return 0;
> +}
> +
> +SEC("syscall")
> +__description("syscall: read ctx with variable offset")
> +__success
> +int syscall_ctx_var_off_read(void *ctx)
> +{
> + __u64 off = bpf_get_prandom_u32();
> + char *p = ctx;
> + volatile __u32 val;
> +
> + off &= 0xfc;
> + p += off;
> + val = *(__u32 *)p;
> + (void)val;
> + return 0;
> +}
> +
> +SEC("syscall")
> +__description("syscall: write ctx with variable offset")
> +__success
> +int syscall_ctx_var_off_write(void *ctx)
> +{
> + __u64 off = bpf_get_prandom_u32();
> + char *p = ctx;
> +
> + off &= 0xfc;
> + p += off;
> + *(__u32 *)p = 0;
> + return 0;
> +}
> +
> +SEC("syscall")
> +__description("syscall: reject negative variable offset ctx access")
> +__failure __msg("min value is negative")
> +int syscall_ctx_neg_var_off(void *ctx)
> +{
> + __u64 off = bpf_get_prandom_u32();
> + char *p = ctx;
> +
> + off &= 4;
> + p -= off;
> + return *(__u32 *)p;
> +}
> +
> +SEC("syscall")
> +__description("syscall: reject unbounded variable offset ctx access")
> +__failure __msg("unbounded memory access")
> +int syscall_ctx_unbounded_var_off(void *ctx)
> +{
> + __u64 off = (__u32)bpf_get_prandom_u32();
> + char *p = ctx;
> +
> + off <<= 2;
> + p += off;
> + return *(__u32 *)p;
> +}
> +
> +SEC("syscall")
> +__description("syscall: helper read ctx with fixed offset")
> +__success
> +int syscall_ctx_helper_fixed_off_read(void *ctx)
> +{
> + char *p = ctx;
> +
> + p += 4;
> + return bpf_strncmp(p, 4, ctx_strncmp_target);
> +}
> +
> +SEC("syscall")
> +__description("syscall: helper write ctx with fixed offset")
> +__success
> +int syscall_ctx_helper_fixed_off_write(void *ctx)
> +{
> + char *p = ctx;
> +
> + p += 4;
> + return bpf_probe_read_kernel(p, 4, 0);
> +}
> +
> +SEC("syscall")
> +__description("syscall: helper read ctx with variable offset")
> +__success
> +int syscall_ctx_helper_var_off_read(void *ctx)
> +{
> + __u64 off = bpf_get_prandom_u32();
> + char *p = ctx;
> +
> + off &= 0xfc;
> + p += off;
> + return bpf_strncmp(p, 4, ctx_strncmp_target);
> +}
> +
> +SEC("syscall")
> +__description("syscall: helper write ctx with variable offset")
> +__success
> +int syscall_ctx_helper_var_off_write(void *ctx)
> +{
> + __u64 off = bpf_get_prandom_u32();
> + char *p = ctx;
> +
> + off &= 0xfc;
> + p += off;
> + return bpf_probe_read_kernel(p, 4, 0);
> +}
> +
> +SEC("syscall")
> +__description("syscall: helper read zero-sized ctx access")
> +__success
> +int syscall_ctx_helper_zero_sized_read(void *ctx)
> +{
> + return bpf_snprintf(0, 0, ctx_snprintf_fmt, ctx, 0);
> +}
> +
> +SEC("syscall")
> +__description("syscall: helper write zero-sized ctx access")
> +__success
> +int syscall_ctx_helper_zero_sized_write(void *ctx)
> +{
> + return bpf_probe_read_kernel(ctx, 0, 0);
> +}
> +
> +SEC("syscall")
> +__description("syscall: kfunc access ctx with fixed offset")
> +__success
> +int syscall_ctx_kfunc_fixed_off(void *ctx)
> +{
> + char *p = ctx;
> +
> + p += 4;
> + bpf_kfunc_call_test_mem_len_pass1(p, 4);
> + return 0;
> +}
> +
> +SEC("syscall")
> +__description("syscall: kfunc access ctx with variable offset")
> +__success
> +int syscall_ctx_kfunc_var_off(void *ctx)
> +{
> + __u64 off = bpf_get_prandom_u32();
> + char *p = ctx;
> +
> + off &= 0xfc;
> + p += off;
> + bpf_kfunc_call_test_mem_len_pass1(p, 4);
> + return 0;
> +}
> +
> +SEC("syscall")
> +__description("syscall: kfunc access zero-sized ctx")
> +__success
> +int syscall_ctx_kfunc_zero_sized(void *ctx)
> +{
> + bpf_kfunc_call_test_mem_len_pass1(ctx, 0);
> + return 0;
> }
Tests are comprehensive. Do we need to test rejection of unaligned read
too?
Acked-by: Mykyta Yatsenko <yatsenko@meta.com>
>
> /*
> - * Test that program types without convert_ctx_access can dereference
> - * their ctx pointer after adding a fixed offset. Variable and negative
> - * offsets should still be rejected.
> + * For non-syscall program types without convert_ctx_access, direct ctx
> + * dereference is still allowed after adding a fixed offset, while variable
> + * and negative direct accesses reject.
> + *
> + * Passing ctx as a helper or kfunc memory argument is only permitted for
> + * syscall programs, so the helper and kfunc cases below validate rejection
> + * for non-syscall ctx pointers at fixed, variable, and zero-sized accesses.
> */
> -#define no_rewrite_ctx_access(type, name, off, ld_op) \
> +#define no_rewrite_ctx_access(type, name, off, load_t) \
> SEC(type) \
> __description(type ": read ctx at fixed offset") \
> __success \
> - __naked void no_rewrite_##name##_fixed(void) \
> + int no_rewrite_##name##_fixed(void *ctx) \
> { \
> - asm volatile (" \
> - r1 += %[__off]; \
> - r0 = *(" #ld_op " *)(r1 + 0); \
> - r0 = 0; \
> - exit;" \
> - : \
> - : __imm_const(__off, off) \
> - : __clobber_all); \
> + char *p = ctx; \
> + volatile load_t val; \
> + \
> + val = *(load_t *)(p + off); \
> + (void)val; \
> + return 0; \
> } \
> SEC(type) \
> __description(type ": reject variable offset ctx access") \
> __failure __msg("variable ctx access var_off=") \
> - __naked void no_rewrite_##name##_var(void) \
> + int no_rewrite_##name##_var(void *ctx) \
> { \
> - asm volatile (" \
> - r6 = r1; \
> - call %[bpf_get_prandom_u32]; \
> - r1 = r6; \
> - r0 &= 4; \
> - r1 += r0; \
> - r0 = *(" #ld_op " *)(r1 + 0); \
> - r0 = 0; \
> - exit;" \
> - : \
> - : __imm(bpf_get_prandom_u32) \
> - : __clobber_all); \
> + __u64 off_var = bpf_get_prandom_u32(); \
> + char *p = ctx; \
> + \
> + off_var &= 4; \
> + p += off_var; \
> + return *(load_t *)p; \
> } \
> SEC(type) \
> __description(type ": reject negative offset ctx access") \
> - __failure __msg("negative offset ctx ptr") \
> - __naked void no_rewrite_##name##_neg(void) \
> + __failure __msg("invalid bpf_context access") \
> + int no_rewrite_##name##_neg(void *ctx) \
> { \
> - asm volatile (" \
> - r1 += %[__neg_off]; \
> - r0 = *(" #ld_op " *)(r1 + 0); \
> - r0 = 0; \
> - exit;" \
> - : \
> - : __imm_const(__neg_off, -(off)) \
> - : __clobber_all); \
> + char *p = ctx; \
> + \
> + p -= 612; \
> + return *(load_t *)p; \
> + } \
> + SEC(type) \
> + __description(type ": reject helper read ctx at fixed offset") \
> + __failure __msg("dereference of modified ctx ptr") \
> + int no_rewrite_##name##_helper_read_fixed(void *ctx) \
> + { \
> + char *p = ctx; \
> + \
> + p += off; \
> + return bpf_strncmp(p, 4, ctx_strncmp_target); \
> + } \
> + SEC(type) \
> + __description(type ": reject helper write ctx at fixed offset") \
> + __failure __msg("dereference of modified ctx ptr") \
> + int no_rewrite_##name##_helper_write_fixed(void *ctx) \
> + { \
> + char *p = ctx; \
> + \
> + p += off; \
> + return bpf_probe_read_kernel(p, 4, 0); \
> + } \
> + SEC(type) \
> + __description(type ": reject helper read ctx with variable offset") \
> + __failure __msg("variable ctx access var_off=") \
> + int no_rewrite_##name##_helper_read_var(void *ctx) \
> + { \
> + __u64 off_var = bpf_get_prandom_u32(); \
> + char *p = ctx; \
> + \
> + off_var &= 4; \
> + p += off_var; \
> + return bpf_strncmp(p, 4, ctx_strncmp_target); \
> + } \
> + SEC(type) \
> + __description(type ": reject helper write ctx with variable offset") \
> + __failure __msg("variable ctx access var_off=") \
> + int no_rewrite_##name##_helper_write_var(void *ctx) \
> + { \
> + __u64 off_var = bpf_get_prandom_u32(); \
> + char *p = ctx; \
> + \
> + off_var &= 4; \
> + p += off_var; \
> + return bpf_probe_read_kernel(p, 4, 0); \
> + } \
> + SEC(type) \
> + __description(type ": reject helper read zero-sized ctx access") \
> + __failure __msg("R4 type=ctx expected=fp") \
> + int no_rewrite_##name##_helper_read_zero(void *ctx) \
> + { \
> + return bpf_snprintf(0, 0, ctx_snprintf_fmt, ctx, 0); \
> + } \
> + SEC(type) \
> + __description(type ": reject helper write zero-sized ctx access") \
> + __failure __msg("R1 type=ctx expected=fp") \
> + int no_rewrite_##name##_helper_write_zero(void *ctx) \
> + { \
> + return bpf_probe_read_kernel(ctx, 0, 0); \
> + } \
> + SEC(type) \
> + __description(type ": reject kfunc ctx at fixed offset") \
> + __failure __msg("dereference of modified ctx ptr") \
> + int no_rewrite_##name##_kfunc_fixed(void *ctx) \
> + { \
> + char *p = ctx; \
> + \
> + p += off; \
> + bpf_kfunc_call_test_mem_len_pass1(p, 4); \
> + return 0; \
> + } \
> + SEC(type) \
> + __description(type ": reject kfunc ctx with variable offset") \
> + __failure __msg("variable ctx access var_off=") \
> + int no_rewrite_##name##_kfunc_var(void *ctx) \
> + { \
> + __u64 off_var = bpf_get_prandom_u32(); \
> + char *p = ctx; \
> + \
> + off_var &= 4; \
> + p += off_var; \
> + bpf_kfunc_call_test_mem_len_pass1(p, 4); \
> + return 0; \
> + } \
> + SEC(type) \
> + __description(type ": reject kfunc zero-sized ctx access") \
> + __failure __msg("R1 type=ctx expected=fp") \
> + int no_rewrite_##name##_kfunc_zero(void *ctx) \
> + { \
> + bpf_kfunc_call_test_mem_len_pass1(ctx, 0); \
> + return 0; \
> }
>
> -no_rewrite_ctx_access("syscall", syscall, 4, u32);
> -no_rewrite_ctx_access("kprobe", kprobe, 8, u64);
> -no_rewrite_ctx_access("tracepoint", tp, 8, u64);
> -no_rewrite_ctx_access("raw_tp", raw_tp, 8, u64);
> -no_rewrite_ctx_access("raw_tracepoint.w", raw_tp_w, 8, u64);
> -no_rewrite_ctx_access("fentry/bpf_modify_return_test", fentry, 8, u64);
> -no_rewrite_ctx_access("cgroup/dev", cgroup_dev, 4, u32);
> -no_rewrite_ctx_access("netfilter", netfilter, offsetof(struct bpf_nf_ctx, skb), u64);
> +no_rewrite_ctx_access("kprobe", kprobe, 8, __u64);
> +no_rewrite_ctx_access("tracepoint", tp, 8, __u64);
> +no_rewrite_ctx_access("raw_tp", raw_tp, 8, __u64);
> +no_rewrite_ctx_access("raw_tracepoint.w", raw_tp_w, 8, __u64);
> +no_rewrite_ctx_access("fentry/bpf_modify_return_test", fentry, 8, __u64);
> +no_rewrite_ctx_access("cgroup/dev", cgroup_dev, 4, __u32);
> +no_rewrite_ctx_access("netfilter", netfilter, offsetof(struct bpf_nf_ctx, skb), __u64);
>
> char _license[] SEC("license") = "GPL";
> diff --git a/tools/testing/selftests/bpf/test_kmods/bpf_testmod.c b/tools/testing/selftests/bpf/test_kmods/bpf_testmod.c
> index 94edbd2afa67..f91b484d80f2 100644
> --- a/tools/testing/selftests/bpf/test_kmods/bpf_testmod.c
> +++ b/tools/testing/selftests/bpf/test_kmods/bpf_testmod.c
> @@ -716,6 +716,7 @@ BTF_ID_FLAGS(func, bpf_iter_testmod_seq_next, KF_ITER_NEXT | KF_RET_NULL)
> BTF_ID_FLAGS(func, bpf_iter_testmod_seq_destroy, KF_ITER_DESTROY)
> BTF_ID_FLAGS(func, bpf_iter_testmod_seq_value)
> BTF_ID_FLAGS(func, bpf_kfunc_common_test)
> +BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_pass1)
> BTF_ID_FLAGS(func, bpf_kfunc_dynptr_test)
> BTF_ID_FLAGS(func, bpf_kfunc_nested_acquire_nonzero_offset_test, KF_ACQUIRE)
> BTF_ID_FLAGS(func, bpf_kfunc_nested_acquire_zero_offset_test, KF_ACQUIRE)
> @@ -1280,7 +1281,6 @@ BTF_ID_FLAGS(func, bpf_kfunc_call_test2)
> BTF_ID_FLAGS(func, bpf_kfunc_call_test3)
> BTF_ID_FLAGS(func, bpf_kfunc_call_test4)
> BTF_ID_FLAGS(func, bpf_kfunc_call_test5)
> -BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_pass1)
> BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_fail1)
> BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_fail2)
> BTF_ID_FLAGS(func, bpf_kfunc_call_test_acquire, KF_ACQUIRE | KF_RET_NULL)
> --
> 2.52.0
next prev parent reply other threads:[~2026-03-18 14:45 UTC|newest]
Thread overview: 17+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-03-18 10:35 [PATCH bpf-next v3 0/3] Allow variable offsets for syscall PTR_TO_CTX Kumar Kartikeya Dwivedi
2026-03-18 10:35 ` [PATCH bpf-next v3 1/3] bpf: Support " Kumar Kartikeya Dwivedi
2026-03-18 14:06 ` Mykyta Yatsenko
2026-03-18 21:59 ` Kumar Kartikeya Dwivedi
2026-03-18 21:13 ` Eduard Zingerman
2026-03-18 21:57 ` Kumar Kartikeya Dwivedi
2026-03-18 22:37 ` Eduard Zingerman
2026-03-18 23:33 ` Kumar Kartikeya Dwivedi
2026-03-18 23:43 ` Kumar Kartikeya Dwivedi
2026-03-18 10:35 ` [PATCH bpf-next v3 2/3] selftests/bpf: Add syscall ctx variable offset tests Kumar Kartikeya Dwivedi
2026-03-18 14:45 ` Mykyta Yatsenko [this message]
2026-03-18 21:41 ` Eduard Zingerman
2026-03-18 21:58 ` Kumar Kartikeya Dwivedi
2026-03-18 22:01 ` Kumar Kartikeya Dwivedi
2026-03-18 10:35 ` [PATCH bpf-next v3 3/3] selftests/bpf: Test modified syscall ctx for ARG_PTR_TO_CTX Kumar Kartikeya Dwivedi
2026-03-18 15:13 ` Mykyta Yatsenko
2026-03-18 11:45 ` [PATCH bpf-next v3 0/3] Allow variable offsets for syscall PTR_TO_CTX Puranjay Mohan
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=878qbpkxh9.fsf@gmail.com \
--to=mykyta.yatsenko5@gmail.com \
--cc=andrii@kernel.org \
--cc=ast@kernel.org \
--cc=bpf@vger.kernel.org \
--cc=daniel@iogearbox.net \
--cc=dschatzberg@meta.com \
--cc=eddyz87@gmail.com \
--cc=emil@etsalapatis.com \
--cc=kernel-team@meta.com \
--cc=kkd@meta.com \
--cc=martin.lau@kernel.org \
--cc=memxor@gmail.com \
--cc=tj@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox