From nobody Sun Feb 8 05:23:09 2026 Received: from mail-pl1-f196.google.com (mail-pl1-f196.google.com [209.85.214.196]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9ED1B225760 for ; Sun, 26 Oct 2025 03:01:58 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.196 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447720; cv=none; b=mEO7hDTRnsTH0KQOVLgDpdur+a2X8XkSugofSHl1fgS0oMGvyB3Mz7spy1PJbU/QJH6G+6b7QbomvQqbfdXT3IOcvCbGeenbHMnuihg5HcAnBCn0J997lJ46mGTBixdDFiTLPcRtZVcE7YQKPF+5BZVnAQ+j2vz9vqGGBwvubx8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447720; c=relaxed/simple; bh=82cO2L7YLsUEwVJ0bB19rv4+ORe+bJYY4QkAwGUO19Y=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BxqdbOqk892hN0N7XblqXW0YXNY8Xc2S1e/txhnDXNrf3Axax3wo3Wv86UW6mfhh0Hqu4QQluCeJhHCHtvpVp/W8c03USO10gJA2BZpSsu1eWZDmAOvLhx2cYyfBbHB07RwkXvMGWdH/sVkMv8NNB7X2otexSNZ0JJ+AShw96A0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=ir/k7egm; arc=none smtp.client-ip=209.85.214.196 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="ir/k7egm" Received: by mail-pl1-f196.google.com with SMTP id d9443c01a7336-27d3540a43fso35601325ad.3 for ; Sat, 25 Oct 2025 20:01:58 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761447718; x=1762052518; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=buk9kgZdrmgQf1PPq0d8rOqpH2Yx6vJiHX6c2RK8eu0=; b=ir/k7egmB/C/aG9hBQA3ZJaJ3pmK9G6qSv7UYjpKg1AKQWXg2lbqyjs1yeikBSzXn3 IudfoLDscxc/o4vtfIsYzL9BqfE3BDImSZc215rHKuMtFjizzOV1/kBkXVHeyDJJF6mA Z9mgc4rPO1HiJJ2EAdfj86Z3bH8zW+L0Wql1hF+7rN0MVeXwXytSkQ9743j5q7gP2jqJ LQS9SAEXbuLGJEji8Er+i8TECkwS7f7dtPtu36T6Dcgad2KjPPICPxdJabHaUyfgbrdi brvJlgaCLMnzAoHhExMmYwqSFwWh2zML0rczknnw5jXC0MOMz9S5y/52MmHzbg/fmSoK fZfQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761447718; x=1762052518; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=buk9kgZdrmgQf1PPq0d8rOqpH2Yx6vJiHX6c2RK8eu0=; b=q8Me6RTzi2eJvSQgpYzd/LzpZKx5nS2KgmY63z8Td1Us1vD9Rkmcxbk2XW7x9HFLFc auoyLYhKt68rrzZfVOSDOZWdGr4I1js5TaSxiaW03f559Y4OLcu7lE0VXiniZLNM0KOK HvteZnp7+wx4PobjYMUiO37vQBLmfnK2fBpR1cYqcgXK3F2TPrOG17Ugyw1cOSSFGSGZ gwp9BfQ0jdJVyaR+fI/hdNHMevabwqicSM7HIV7tspeD6RMVawoWdgk+Fs5XfuXc1iWL oOEGwxTehdgHG4dmSnB0sKWLx1ct9MfLmR1LmByZbTYGbH/RoyRF20tCCD8II+FLGEfJ FXzA== X-Forwarded-Encrypted: i=1; AJvYcCWQPWjphiBLnom53EKk4aGIRA8PL9yWsqktm8mbBLEon8/PnsLo93fNh4UYSE+mOSeGNRDBB4Cx69laIhM=@vger.kernel.org X-Gm-Message-State: AOJu0YzxNbPNv9yeM0clEt1erHwgMfBbto91P/FLYs/QekVDXbYz5hC7 qg6TRbLPHN0s+GgIrRIL22ilF719b57IXtDxzdTjCTRcy6m8Lmd/Wq36 X-Gm-Gg: ASbGncv2wZj4g1l8TDZQj6U3ca/DPF9g1pqHguRB+2BR21Zy36fHDpl3WypNoGPMe/K wCpq9dRAVYJs7rgMTYiJzSA1C3JBa0R+y76h8MoXPpiGv4KfSlfpj4WJmjdV4PJtzXHUVYQLCid +vA29OFlQF6pGj/zVd6SRS/C/tPcBQTHY9/FuJPDuN0bv6vxGvhlN8XKCEquV9zJrTlAPp4jvjW BgBKtrMDZ7DWxzfLs8JmXeqHcvtgtrISxdF+DV9PkZopez4qLAmVKwFC/jSA90gYMCYH8WF3uEI UZwJrxrVM11klZghUGa+BTnZJptucatZtaQEOEkbboPZp2TiSr52iDhYSyvdoEDgJs7+CREJuG7 tX2tkhRxVVrF+IFGkuLOyTPbNUCeDFiLF2LRBFuEf6BQNkWI3VIJmmGY9o/eG7WvcSdzxI46p9z Jq X-Google-Smtp-Source: AGHT+IG2AKcR4tLlF+UfpTUIQ9ko/ITn8IkmjvaSu3Zau+fRjSMby/n53+loiZhqS7/x8/eD++QUsA== X-Received: by 2002:a17:903:18c:b0:294:66ad:113e with SMTP id d9443c01a7336-29466ad11e3mr166481845ad.47.1761447717646; Sat, 25 Oct 2025 20:01:57 -0700 (PDT) Received: from 7950hx ([43.129.244.20]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29498d40b1esm38100645ad.73.2025.10.25.20.01.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 25 Oct 2025 20:01:57 -0700 (PDT) From: Menglong Dong X-Google-Original-From: Menglong Dong To: ast@kernel.org, jolsa@kernel.org Cc: daniel@iogearbox.net, john.fastabend@gmail.com, andrii@kernel.org, martin.lau@linux.dev, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, kpsingh@kernel.org, sdf@fomichev.me, haoluo@google.com, mattbobrowski@google.com, rostedt@goodmis.org, mhiramat@kernel.org, leon.hwang@linux.dev, jiang.biao@linux.dev, bpf@vger.kernel.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH bpf-next v3 1/7] bpf: add tracing session support Date: Sun, 26 Oct 2025 11:01:37 +0800 Message-ID: <20251026030143.23807-2-dongml2@chinatelecom.cn> X-Mailer: git-send-email 2.51.1 In-Reply-To: <20251026030143.23807-1-dongml2@chinatelecom.cn> References: <20251026030143.23807-1-dongml2@chinatelecom.cn> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The tracing session is something that similar to kprobe session. It allow to attach a single BPF program to both the entry and the exit of the target functions. While a non-zero value is returned by the fentry, the fexit will be skipped, which is similar to kprobe session. Signed-off-by: Menglong Dong Co-developed-by: Leon Hwang Signed-off-by: Leon Hwang --- arch/arm64/net/bpf_jit_comp.c | 3 +++ arch/loongarch/net/bpf_jit.c | 3 +++ arch/powerpc/net/bpf_jit_comp.c | 3 +++ arch/riscv/net/bpf_jit_comp64.c | 3 +++ arch/s390/net/bpf_jit_comp.c | 3 +++ arch/x86/net/bpf_jit_comp.c | 3 +++ include/linux/bpf.h | 1 + include/uapi/linux/bpf.h | 1 + kernel/bpf/btf.c | 2 ++ kernel/bpf/syscall.c | 2 ++ kernel/bpf/trampoline.c | 5 ++++- kernel/bpf/verifier.c | 12 +++++++++--- net/bpf/test_run.c | 1 + net/core/bpf_sk_storage.c | 1 + tools/include/uapi/linux/bpf.h | 1 + .../selftests/bpf/prog_tests/tracing_failure.c | 2 +- 16 files changed, 41 insertions(+), 5 deletions(-) diff --git a/arch/arm64/net/bpf_jit_comp.c b/arch/arm64/net/bpf_jit_comp.c index ab83089c3d8f..06f4bd6c6755 100644 --- a/arch/arm64/net/bpf_jit_comp.c +++ b/arch/arm64/net/bpf_jit_comp.c @@ -2788,6 +2788,9 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_imag= e *im, void *ro_image, void *image, *tmp; int ret; =20 + if (tlinks[BPF_TRAMP_SESSION].nr_links) + return -EOPNOTSUPP; + /* image doesn't need to be in module memory range, so we can * use kvmalloc. */ diff --git a/arch/loongarch/net/bpf_jit.c b/arch/loongarch/net/bpf_jit.c index cbe53d0b7fb0..ad596341658a 100644 --- a/arch/loongarch/net/bpf_jit.c +++ b/arch/loongarch/net/bpf_jit.c @@ -1739,6 +1739,9 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_imag= e *im, void *ro_image, void *image, *tmp; struct jit_ctx ctx; =20 + if (tlinks[BPF_TRAMP_SESSION].nr_links) + return -EOPNOTSUPP; + size =3D ro_image_end - ro_image; image =3D kvmalloc(size, GFP_KERNEL); if (!image) diff --git a/arch/powerpc/net/bpf_jit_comp.c b/arch/powerpc/net/bpf_jit_com= p.c index 88ad5ba7b87f..bcc0ce09f6fa 100644 --- a/arch/powerpc/net/bpf_jit_comp.c +++ b/arch/powerpc/net/bpf_jit_comp.c @@ -1017,6 +1017,9 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_imag= e *im, void *image, void *i void *rw_image, *tmp; int ret; =20 + if (tlinks[BPF_TRAMP_SESSION].nr_links) + return -EOPNOTSUPP; + /* * rw_image doesn't need to be in module memory range, so we can * use kvmalloc. diff --git a/arch/riscv/net/bpf_jit_comp64.c b/arch/riscv/net/bpf_jit_comp6= 4.c index 45cbc7c6fe49..55b0284bf177 100644 --- a/arch/riscv/net/bpf_jit_comp64.c +++ b/arch/riscv/net/bpf_jit_comp64.c @@ -1286,6 +1286,9 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_imag= e *im, void *ro_image, struct rv_jit_context ctx; u32 size =3D ro_image_end - ro_image; =20 + if (tlinks[BPF_TRAMP_SESSION].nr_links) + return -EOPNOTSUPP; + image =3D kvmalloc(size, GFP_KERNEL); if (!image) return -ENOMEM; diff --git a/arch/s390/net/bpf_jit_comp.c b/arch/s390/net/bpf_jit_comp.c index cf461d76e9da..3f25bf55b150 100644 --- a/arch/s390/net/bpf_jit_comp.c +++ b/arch/s390/net/bpf_jit_comp.c @@ -2924,6 +2924,9 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_imag= e *im, void *image, struct bpf_tramp_jit tjit; int ret; =20 + if (tlinks[BPF_TRAMP_SESSION].nr_links) + return -EOPNOTSUPP; + /* Compute offsets, check whether the code fits. */ memset(&tjit, 0, sizeof(tjit)); ret =3D __arch_prepare_bpf_trampoline(im, &tjit, m, flags, diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c index d4c93d9e73e4..389c3a96e2b8 100644 --- a/arch/x86/net/bpf_jit_comp.c +++ b/arch/x86/net/bpf_jit_comp.c @@ -3478,6 +3478,9 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_imag= e *im, void *image, void *i int ret; u32 size =3D image_end - image; =20 + if (tlinks[BPF_TRAMP_SESSION].nr_links) + return -EOPNOTSUPP; + /* rw_image doesn't need to be in module memory range, so we can * use kvmalloc. */ diff --git a/include/linux/bpf.h b/include/linux/bpf.h index e53cda0aabb6..6b5855c80fa6 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -1270,6 +1270,7 @@ enum bpf_tramp_prog_type { BPF_TRAMP_FENTRY, BPF_TRAMP_FEXIT, BPF_TRAMP_MODIFY_RETURN, + BPF_TRAMP_SESSION, BPF_TRAMP_MAX, BPF_TRAMP_REPLACE, /* more than MAX */ }; diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 6829936d33f5..79ba3023e8be 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -1133,6 +1133,7 @@ enum bpf_attach_type { BPF_NETKIT_PEER, BPF_TRACE_KPROBE_SESSION, BPF_TRACE_UPROBE_SESSION, + BPF_TRACE_SESSION, __MAX_BPF_ATTACH_TYPE }; =20 diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c index 0de8fc8a0e0b..2c1c3e0caff8 100644 --- a/kernel/bpf/btf.c +++ b/kernel/bpf/btf.c @@ -6107,6 +6107,7 @@ static int btf_validate_prog_ctx_type(struct bpf_veri= fier_log *log, const struct case BPF_TRACE_FENTRY: case BPF_TRACE_FEXIT: case BPF_MODIFY_RETURN: + case BPF_TRACE_SESSION: /* allow u64* as ctx */ if (btf_is_int(t) && t->size =3D=3D 8) return 0; @@ -6704,6 +6705,7 @@ bool btf_ctx_access(int off, int size, enum bpf_acces= s_type type, fallthrough; case BPF_LSM_CGROUP: case BPF_TRACE_FEXIT: + case BPF_TRACE_SESSION: /* When LSM programs are attached to void LSM hooks * they use FEXIT trampolines and when attached to * int LSM hooks, they use MODIFY_RETURN trampolines. diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c index 8a129746bd6c..cb483701fe39 100644 --- a/kernel/bpf/syscall.c +++ b/kernel/bpf/syscall.c @@ -3564,6 +3564,7 @@ static int bpf_tracing_prog_attach(struct bpf_prog *p= rog, case BPF_PROG_TYPE_TRACING: if (prog->expected_attach_type !=3D BPF_TRACE_FENTRY && prog->expected_attach_type !=3D BPF_TRACE_FEXIT && + prog->expected_attach_type !=3D BPF_TRACE_SESSION && prog->expected_attach_type !=3D BPF_MODIFY_RETURN) { err =3D -EINVAL; goto out_put_prog; @@ -4337,6 +4338,7 @@ attach_type_to_prog_type(enum bpf_attach_type attach_= type) case BPF_TRACE_RAW_TP: case BPF_TRACE_FENTRY: case BPF_TRACE_FEXIT: + case BPF_TRACE_SESSION: case BPF_MODIFY_RETURN: return BPF_PROG_TYPE_TRACING; case BPF_LSM_MAC: diff --git a/kernel/bpf/trampoline.c b/kernel/bpf/trampoline.c index 5949095e51c3..f6d4dea3461e 100644 --- a/kernel/bpf/trampoline.c +++ b/kernel/bpf/trampoline.c @@ -111,7 +111,7 @@ bool bpf_prog_has_trampoline(const struct bpf_prog *pro= g) =20 return (ptype =3D=3D BPF_PROG_TYPE_TRACING && (eatype =3D=3D BPF_TRACE_FENTRY || eatype =3D=3D BPF_TRACE_FEXIT || - eatype =3D=3D BPF_MODIFY_RETURN)) || + eatype =3D=3D BPF_MODIFY_RETURN || eatype =3D=3D BPF_TRACE_SESSION)) || (ptype =3D=3D BPF_PROG_TYPE_LSM && eatype =3D=3D BPF_LSM_MAC); } =20 @@ -418,6 +418,7 @@ static int bpf_trampoline_update(struct bpf_trampoline = *tr, bool lock_direct_mut tr->flags &=3D (BPF_TRAMP_F_SHARE_IPMODIFY | BPF_TRAMP_F_TAIL_CALL_CTX); =20 if (tlinks[BPF_TRAMP_FEXIT].nr_links || + tlinks[BPF_TRAMP_SESSION].nr_links || tlinks[BPF_TRAMP_MODIFY_RETURN].nr_links) { /* NOTE: BPF_TRAMP_F_RESTORE_REGS and BPF_TRAMP_F_SKIP_FRAME * should not be set together. @@ -515,6 +516,8 @@ static enum bpf_tramp_prog_type bpf_attach_type_to_tram= p(struct bpf_prog *prog) return BPF_TRAMP_MODIFY_RETURN; case BPF_TRACE_FEXIT: return BPF_TRAMP_FEXIT; + case BPF_TRACE_SESSION: + return BPF_TRAMP_SESSION; case BPF_LSM_MAC: if (!prog->aux->attach_func_proto->type) /* The function returns void, we cannot modify its diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 6d175849e57a..818deb6a06e4 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -17281,6 +17281,7 @@ static int check_return_code(struct bpf_verifier_en= v *env, int regno, const char break; case BPF_TRACE_RAW_TP: case BPF_MODIFY_RETURN: + case BPF_TRACE_SESSION: return 0; case BPF_TRACE_ITER: break; @@ -22754,6 +22755,7 @@ static int do_misc_fixups(struct bpf_verifier_env *= env) if (prog_type =3D=3D BPF_PROG_TYPE_TRACING && insn->imm =3D=3D BPF_FUNC_get_func_ret) { if (eatype =3D=3D BPF_TRACE_FEXIT || + eatype =3D=3D BPF_TRACE_SESSION || eatype =3D=3D BPF_MODIFY_RETURN) { /* Load nr_args from ctx - 8 */ insn_buf[0] =3D BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8); @@ -23695,7 +23697,8 @@ int bpf_check_attach_target(struct bpf_verifier_log= *log, if (tgt_prog->type =3D=3D BPF_PROG_TYPE_TRACING && prog_extension && (tgt_prog->expected_attach_type =3D=3D BPF_TRACE_FENTRY || - tgt_prog->expected_attach_type =3D=3D BPF_TRACE_FEXIT)) { + tgt_prog->expected_attach_type =3D=3D BPF_TRACE_FEXIT || + tgt_prog->expected_attach_type =3D=3D BPF_TRACE_SESSION)) { /* Program extensions can extend all program types * except fentry/fexit. The reason is the following. * The fentry/fexit programs are used for performance @@ -23710,7 +23713,7 @@ int bpf_check_attach_target(struct bpf_verifier_log= *log, * beyond reasonable stack size. Hence extending fentry * is not allowed. */ - bpf_log(log, "Cannot extend fentry/fexit\n"); + bpf_log(log, "Cannot extend fentry/fexit/session\n"); return -EINVAL; } } else { @@ -23794,6 +23797,7 @@ int bpf_check_attach_target(struct bpf_verifier_log= *log, case BPF_LSM_CGROUP: case BPF_TRACE_FENTRY: case BPF_TRACE_FEXIT: + case BPF_TRACE_SESSION: if (!btf_type_is_func(t)) { bpf_log(log, "attach_btf_id %u is not a function\n", btf_id); @@ -23960,6 +23964,7 @@ static bool can_be_sleepable(struct bpf_prog *prog) case BPF_TRACE_FEXIT: case BPF_MODIFY_RETURN: case BPF_TRACE_ITER: + case BPF_TRACE_SESSION: return true; default: return false; @@ -24041,9 +24046,10 @@ static int check_attach_btf_id(struct bpf_verifier= _env *env) tgt_info.tgt_name); return -EINVAL; } else if ((prog->expected_attach_type =3D=3D BPF_TRACE_FEXIT || + prog->expected_attach_type =3D=3D BPF_TRACE_SESSION || prog->expected_attach_type =3D=3D BPF_MODIFY_RETURN) && btf_id_set_contains(&noreturn_deny, btf_id)) { - verbose(env, "Attaching fexit/fmod_ret to __noreturn function '%s' is re= jected.\n", + verbose(env, "Attaching fexit/session/fmod_ret to __noreturn function '%= s' is rejected.\n", tgt_info.tgt_name); return -EINVAL; } diff --git a/net/bpf/test_run.c b/net/bpf/test_run.c index 655efac6f133..ddec08b696de 100644 --- a/net/bpf/test_run.c +++ b/net/bpf/test_run.c @@ -685,6 +685,7 @@ int bpf_prog_test_run_tracing(struct bpf_prog *prog, switch (prog->expected_attach_type) { case BPF_TRACE_FENTRY: case BPF_TRACE_FEXIT: + case BPF_TRACE_SESSION: if (bpf_fentry_test1(1) !=3D 2 || bpf_fentry_test2(2, 3) !=3D 5 || bpf_fentry_test3(4, 5, 6) !=3D 15 || diff --git a/net/core/bpf_sk_storage.c b/net/core/bpf_sk_storage.c index d3fbaf89a698..8da8834aa134 100644 --- a/net/core/bpf_sk_storage.c +++ b/net/core/bpf_sk_storage.c @@ -365,6 +365,7 @@ static bool bpf_sk_storage_tracing_allowed(const struct= bpf_prog *prog) return true; case BPF_TRACE_FENTRY: case BPF_TRACE_FEXIT: + case BPF_TRACE_SESSION: return !!strncmp(prog->aux->attach_func_name, "bpf_sk_storage", strlen("bpf_sk_storage")); default: diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 6829936d33f5..79ba3023e8be 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -1133,6 +1133,7 @@ enum bpf_attach_type { BPF_NETKIT_PEER, BPF_TRACE_KPROBE_SESSION, BPF_TRACE_UPROBE_SESSION, + BPF_TRACE_SESSION, __MAX_BPF_ATTACH_TYPE }; =20 diff --git a/tools/testing/selftests/bpf/prog_tests/tracing_failure.c b/too= ls/testing/selftests/bpf/prog_tests/tracing_failure.c index 10e231965589..58b02552507d 100644 --- a/tools/testing/selftests/bpf/prog_tests/tracing_failure.c +++ b/tools/testing/selftests/bpf/prog_tests/tracing_failure.c @@ -73,7 +73,7 @@ static void test_tracing_deny(void) static void test_fexit_noreturns(void) { test_tracing_fail_prog("fexit_noreturns", - "Attaching fexit/fmod_ret to __noreturn function 'do_exit' is re= jected."); + "Attaching fexit/session/fmod_ret to __noreturn function 'do_exi= t' is rejected."); } =20 void test_tracing_failure(void) --=20 2.51.1 From nobody Sun Feb 8 05:23:09 2026 Received: from mail-pg1-f193.google.com (mail-pg1-f193.google.com [209.85.215.193]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B139B2571DA for ; Sun, 26 Oct 2025 03:02:03 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.193 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447725; cv=none; b=khQ44e/dWO4Lr3z8OrVAermtjNJhxnrL5UIPwT/fKp+HCZK0hQyjCuoSgNPF6xkutzkB5UO1sHQYKqARedO1LFisqzGL0gt3ubWkxR9sRP/Hs3K/+p7ZPkYzCvo7OJk/pVLZEiAXTiNlg4pKQ0IQTxHF+WUr00p1O2cTGnC8VdM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447725; c=relaxed/simple; bh=vK0EtXyF0TAv0W+LwES+hsw/IVhCieW5oKRtWSpXi08=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=lO9yZ/T2wN0n7y4TgxcWorUbVNr0sxAump76txty9853PvKMPtNHOUtHa1K79tl6SVx0Ibt6eLCW/ml85S5yOaH+a7kPot5RIvTh6r426X6/qEjPi2BxadQrTFPZF+vkgvsdk97ozrqGSd35U6ztrfPTgSZDBQGIBewuwi26vS0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=B0s9p8z2; arc=none smtp.client-ip=209.85.215.193 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="B0s9p8z2" Received: by mail-pg1-f193.google.com with SMTP id 41be03b00d2f7-b6cf25c9ad5so2662535a12.0 for ; Sat, 25 Oct 2025 20:02:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761447723; x=1762052523; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=oa5InkxvVUN642DJUe0KYXiTiyc8NAW7OtkrLGo/nXg=; b=B0s9p8z2rqLzmu0ZCL5H24uT5TNaB6J5AVngfJezN2R9593CoXQ0znRk25WKqdBy/1 q2OqwKAATNzs5pKGi8hSc6vAjOUspSZ2q7WcujoW9AGPtdsyhQg5McPpDcIZIaw5za7z r7bt3Nibu3JqXdbxTDyvCYnt/2r+yEwdg6CjuRM4LeC27v93YqI582TL6oMSGacEtmeY 6WmZSGQXw5RJIz2yrqV5podl0rfuRqYFMurAtTl33SDHs3jp/5//fyJuVCww/mrHeKjj O4vrn5J2cUqHlzwwqdKVCY1J/mE0tq6dzp0m+SzIZnpXfkqgtTyWd7r01SbdwgBTANZw nBiw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761447723; x=1762052523; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=oa5InkxvVUN642DJUe0KYXiTiyc8NAW7OtkrLGo/nXg=; b=R7pPgKF8uD/UtPpylINlSuddrebC7f79IzUNg/41tZ/J/L7ubzixP05jX9zXioRCMx YDoxyTfwVYQrTDsqsCLvx7NljUMekRakC7ervmgcL7Rc09Fh5V0L7bG+SXgt503HoZuO KTZgx/xsPDUbUScLj8OLyYdPBnitYvioFWweh+wkbuc+ErDV2GaFT2pH/aR4sEK5Ilrg iLLt8gQNRkha6N0QdXppqh+4jNUNW5GGxSUV+V7xjH3ZDMb/az43hfp962nRyvuBPm8Q 75q6m5FG/7RS6IdmceZoij/1zo7WPnGwOQMYIf8OnV/5Gp23t8E803Jt111CrltfJmGE HZ0A== X-Forwarded-Encrypted: i=1; AJvYcCUDF1NS6R1BkmcOIy4E16ggwYi2lex21xmiKtsuur1+Of88ycyBktCfdy4ZJz7NRzBhCYnh+Wi7QDb+epA=@vger.kernel.org X-Gm-Message-State: AOJu0YyvPshvQ2wqxOEn74DTmN3nx8JVLo3NZz9TP5WAHssxHB9G96k0 x7tMIw6c4pvt2/n7AajSxL9O/Vh5aF70bJUDr4RKlLyEl91k3pjxvfrt X-Gm-Gg: ASbGncsjz+mitprQWdsna7axHU2gW8w+qa3X+ZbK3JkoSRZOSi4E1Lt6cQhJ+fFUAcH tvf79RTOJmaXuzMxriUqNY1sXTg18CGjRJ819CuMPlGCgwycq0Wi2hO7+HVA2XEtWtCKLLjMCEl qh2m6Zmwg3USIfVuahfovWsHmvqOSo4uEqIUcunvY6Zfoi5YXzf6jUYAA8ZPvcSuJpYpBTZ4+MK 7LAPGJGD4qbzRC4MS3NurwYSX5WtSf0fj2RdB7ta/f087wiYBWuRZ/S3Lw4rwSJc+cszbI9tqt/ vX0J5w3FK2l2MpaBm5MLRDhLjEAouYlBR4cPw9YkTAPr0Mco3lJ5H27RD6QpE76Cpak7UIAwq84 xOV2V/gRInU2uM9RZrvg51FK/Ic2BwS1PyrEarQquKnI/sf1JjRAj7f+wPF+8BfLrt8jgSiry8L PH/BEfGgW776E= X-Google-Smtp-Source: AGHT+IFxWgkIq1VivRbF+1Yvqo5Ua7kf/vo2jP2bHKSgdoIAHVPL9mtpbM8fwrjkk+f/fOyMBUBZsQ== X-Received: by 2002:a17:902:e88e:b0:27e:f018:d312 with SMTP id d9443c01a7336-290c9cf350amr421236215ad.1.1761447722885; Sat, 25 Oct 2025 20:02:02 -0700 (PDT) Received: from 7950hx ([43.129.244.20]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29498d40b1esm38100645ad.73.2025.10.25.20.01.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 25 Oct 2025 20:02:02 -0700 (PDT) From: Menglong Dong X-Google-Original-From: Menglong Dong To: ast@kernel.org, jolsa@kernel.org Cc: daniel@iogearbox.net, john.fastabend@gmail.com, andrii@kernel.org, martin.lau@linux.dev, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, kpsingh@kernel.org, sdf@fomichev.me, haoluo@google.com, mattbobrowski@google.com, rostedt@goodmis.org, mhiramat@kernel.org, leon.hwang@linux.dev, jiang.biao@linux.dev, bpf@vger.kernel.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH bpf-next v3 2/7] bpf: add two kfunc for TRACE_SESSION Date: Sun, 26 Oct 2025 11:01:38 +0800 Message-ID: <20251026030143.23807-3-dongml2@chinatelecom.cn> X-Mailer: git-send-email 2.51.1 In-Reply-To: <20251026030143.23807-1-dongml2@chinatelecom.cn> References: <20251026030143.23807-1-dongml2@chinatelecom.cn> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" If TRACE_SESSION exists, we will use extra 8-bytes in the stack of the trampoline to store the flags that we needed, and the 8-bytes lie after the return value, which means ctx[nr_args + 1]. And we will store the flag "is_exit" to the first bit of it. Introduce the kfunc bpf_tracing_is_exit(), which is used to tell if it is fexit currently. Meanwhile, inline it in the verifier. Add the kfunc bpf_fsession_cookie(), which is similar to bpf_session_cookie() and return the address of the session cookie. The address of the session cookie is stored after session flags, which means ctx[nr_args + 2]. Inline this kfunc in the verifier too. Signed-off-by: Menglong Dong Co-developed-by: Leon Hwang Signed-off-by: Leon Hwang --- v3: - merge the bpf_tracing_is_exit and bpf_fsession_cookie into a single patch v2: - store the session flags after return value, instead of before nr_args - inline the bpf_tracing_is_exit, as Jiri suggested --- include/linux/bpf.h | 1 + kernel/bpf/verifier.c | 33 ++++++++++++++++++++-- kernel/trace/bpf_trace.c | 59 ++++++++++++++++++++++++++++++++++++++-- 3 files changed, 88 insertions(+), 5 deletions(-) diff --git a/include/linux/bpf.h b/include/linux/bpf.h index 6b5855c80fa6..ce55d3881c0d 100644 --- a/include/linux/bpf.h +++ b/include/linux/bpf.h @@ -1736,6 +1736,7 @@ struct bpf_prog { enforce_expected_attach_type:1, /* Enforce expected_attach_type checki= ng at attach time */ call_get_stack:1, /* Do we call bpf_get_stack() or bpf_get_stackid() */ call_get_func_ip:1, /* Do we call get_func_ip() */ + call_session_cookie:1, /* Do we call bpf_fsession_cookie() */ tstamp_type_access:1, /* Accessed __sk_buff->tstamp_type */ sleepable:1; /* BPF program is sleepable */ enum bpf_prog_type type; /* Type of BPF program */ diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 818deb6a06e4..6f8aa4718d6f 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -12293,6 +12293,8 @@ enum special_kfunc_type { KF___bpf_trap, KF_bpf_task_work_schedule_signal, KF_bpf_task_work_schedule_resume, + KF_bpf_tracing_is_exit, + KF_bpf_fsession_cookie, }; =20 BTF_ID_LIST(special_kfunc_list) @@ -12365,6 +12367,8 @@ BTF_ID(func, bpf_res_spin_unlock_irqrestore) BTF_ID(func, __bpf_trap) BTF_ID(func, bpf_task_work_schedule_signal) BTF_ID(func, bpf_task_work_schedule_resume) +BTF_ID(func, bpf_tracing_is_exit) +BTF_ID(func, bpf_fsession_cookie) =20 static bool is_task_work_add_kfunc(u32 func_id) { @@ -12419,7 +12423,9 @@ get_kfunc_ptr_arg_type(struct bpf_verifier_env *env, struct bpf_reg_state *reg =3D ®s[regno]; bool arg_mem_size =3D false; =20 - if (meta->func_id =3D=3D special_kfunc_list[KF_bpf_cast_to_kern_ctx]) + if (meta->func_id =3D=3D special_kfunc_list[KF_bpf_cast_to_kern_ctx] || + meta->func_id =3D=3D special_kfunc_list[KF_bpf_tracing_is_exit] || + meta->func_id =3D=3D special_kfunc_list[KF_bpf_fsession_cookie]) return KF_ARG_PTR_TO_CTX; =20 /* In this function, we verify the kfunc's BTF as per the argument type, @@ -13912,7 +13918,8 @@ static int check_kfunc_call(struct bpf_verifier_env= *env, struct bpf_insn *insn, } } =20 - if (meta.func_id =3D=3D special_kfunc_list[KF_bpf_session_cookie]) { + if (meta.func_id =3D=3D special_kfunc_list[KF_bpf_session_cookie] || + meta.func_id =3D=3D special_kfunc_list[KF_bpf_fsession_cookie]) { meta.r0_size =3D sizeof(u64); meta.r0_rdonly =3D false; } @@ -14193,6 +14200,9 @@ static int check_kfunc_call(struct bpf_verifier_env= *env, struct bpf_insn *insn, return err; } =20 + if (meta.func_id =3D=3D special_kfunc_list[KF_bpf_fsession_cookie]) + env->prog->call_session_cookie =3D true; + return 0; } =20 @@ -22012,6 +22022,25 @@ static int fixup_kfunc_call(struct bpf_verifier_en= v *env, struct bpf_insn *insn, desc->func_id =3D=3D special_kfunc_list[KF_bpf_rdonly_cast]) { insn_buf[0] =3D BPF_MOV64_REG(BPF_REG_0, BPF_REG_1); *cnt =3D 1; + } else if (desc->func_id =3D=3D special_kfunc_list[KF_bpf_tracing_is_exit= ]) { + /* Load nr_args from ctx - 8 */ + insn_buf[0] =3D BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8); + /* add rax, 1 */ + insn_buf[1] =3D BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 1); + insn_buf[2] =3D BPF_ALU64_IMM(BPF_LSH, BPF_REG_0, 3); + insn_buf[3] =3D BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1); + insn_buf[4] =3D BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0); + insn_buf[5] =3D BPF_ALU64_IMM(BPF_AND, BPF_REG_0, 1); + *cnt =3D 6; + } else if (desc->func_id =3D=3D special_kfunc_list[KF_bpf_fsession_cookie= ]) { + /* Load nr_args from ctx - 8 */ + insn_buf[0] =3D BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8); + /* add rax, 2 */ + insn_buf[1] =3D BPF_ALU64_IMM(BPF_ADD, BPF_REG_0, 2); + insn_buf[2] =3D BPF_ALU64_IMM(BPF_LSH, BPF_REG_0, 3); + insn_buf[3] =3D BPF_ALU64_REG(BPF_ADD, BPF_REG_0, BPF_REG_1); + insn_buf[4] =3D BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0); + *cnt =3D 5; } =20 if (env->insn_aux_data[insn_idx].arg_prog) { diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c index 4f87c16d915a..4a8568bd654d 100644 --- a/kernel/trace/bpf_trace.c +++ b/kernel/trace/bpf_trace.c @@ -3356,12 +3356,65 @@ static const struct btf_kfunc_id_set bpf_kprobe_mul= ti_kfunc_set =3D { .filter =3D bpf_kprobe_multi_filter, }; =20 -static int __init bpf_kprobe_multi_kfuncs_init(void) +__bpf_kfunc_start_defs(); + +__bpf_kfunc bool bpf_tracing_is_exit(void *ctx) { - return register_btf_kfunc_id_set(BPF_PROG_TYPE_KPROBE, &bpf_kprobe_multi_= kfunc_set); + /* This helper call is inlined by verifier. */ + u64 nr_args =3D ((u64 *)ctx)[-1]; + + /* + * ctx[nr_args + 1] is the session flags, and the last bit is + * is_exit. + */ + return ((u64 *)ctx)[nr_args + 1] & 1; +} + +__bpf_kfunc u64 *bpf_fsession_cookie(void *ctx) +{ + /* This helper call is inlined by verifier. */ + u64 nr_args =3D ((u64 *)ctx)[-1]; + + /* ctx[nr_args + 2] is the session cookie address */ + return (u64 *)((u64 *)ctx)[nr_args + 2]; +} + +__bpf_kfunc_end_defs(); + +BTF_KFUNCS_START(tracing_kfunc_set_ids) +BTF_ID_FLAGS(func, bpf_tracing_is_exit, KF_FASTCALL) +BTF_ID_FLAGS(func, bpf_fsession_cookie, KF_FASTCALL) +BTF_KFUNCS_END(tracing_kfunc_set_ids) + +static int bpf_tracing_filter(const struct bpf_prog *prog, u32 kfunc_id) +{ + if (!btf_id_set8_contains(&tracing_kfunc_set_ids, kfunc_id)) + return 0; + + if (prog->type !=3D BPF_PROG_TYPE_TRACING || + prog->expected_attach_type !=3D BPF_TRACE_SESSION) + return -EINVAL; + + return 0; +} + +static const struct btf_kfunc_id_set bpf_tracing_kfunc_set =3D { + .owner =3D THIS_MODULE, + .set =3D &tracing_kfunc_set_ids, + .filter =3D bpf_tracing_filter, +}; + +static int __init bpf_trace_kfuncs_init(void) +{ + int err =3D 0; + + err =3D err ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_KPROBE, &bpf_kprob= e_multi_kfunc_set); + err =3D err ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_TRACING, &bpf_trac= ing_kfunc_set); + + return err; } =20 -late_initcall(bpf_kprobe_multi_kfuncs_init); +late_initcall(bpf_trace_kfuncs_init); =20 typedef int (*copy_fn_t)(void *dst, const void *src, u32 size, struct task= _struct *tsk); =20 --=20 2.51.1 From nobody Sun Feb 8 05:23:09 2026 Received: from mail-pl1-f194.google.com (mail-pl1-f194.google.com [209.85.214.194]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0032326463A for ; Sun, 26 Oct 2025 03:02:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.194 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447730; cv=none; b=W+VWzW876UaPsVsEnQt1+hT7Ymqk0Zx6wF/DuIJZID3tKYGsZBVG5KqgcR1p2Iuo3LNzunLvvPQenwuNRXOC3psA9m5a4GrS1tuNwyr1QajYr477uhskyYGfXMmRSkx1bOOxfCuVskuHmwEisYEP9lsfRx6HCLjmZBuc5mmTDO4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447730; c=relaxed/simple; bh=9b4O7RsmNlvQ7AzTjosqE9BdcokjGohATbeUFSkIzxs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=iV6i8d8ETY8yS7ghCtjT0Kt/3vR8rnWBin1CKRpPGRsLvSfCY6LBJB8rS76sox3/hvIjSAmrv1EFQwXEm9kQVZmNZgHoSLtqgBMg7nhv97dP7Kx2LvCcO9lDRBCJCx39LUDQPVtgs6u8HmDBqQoLurEtjsJkFa0BAwMQYrpeRN0= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=ddii9cIp; arc=none smtp.client-ip=209.85.214.194 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="ddii9cIp" Received: by mail-pl1-f194.google.com with SMTP id d9443c01a7336-292fd52d527so35767925ad.2 for ; Sat, 25 Oct 2025 20:02:08 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761447728; x=1762052528; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=EWOtrv5GaHaiqIKPPW9jwT/KAew9UNx9hp0UFn6ftzQ=; b=ddii9cIpN2wCJ01aTrb0bMaPMDnfpLTOebBCzbLqybjW7JW4nQo2kCAVWlOB6R7VA/ w9qykQIOTerZ4l5Qv4I+8Q83gF1C6wW0YpWx7r+gASiK5nZodMLEz3Rez5jWDq8FErdU JhHh9Pe+iA7jGkn7VWoVK2AgHbNNrV9+t77wPCn22ZeZIOO1Eo6SVZsjXh9juq+XGwzt F1zV5Tu4jIwj+Hm5P/9XpQOizogCTqu6fNVhE1OqsigvI8NpVwk1GkLwNsCLgoGGv88V Etwnz1XR+hmxs62RmQ/DBHTM9b9gcFZIjzo3bPulhCp9HhCC9zLDWIlrFpAgzLyzM6NY kA9g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761447728; x=1762052528; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=EWOtrv5GaHaiqIKPPW9jwT/KAew9UNx9hp0UFn6ftzQ=; b=W09/zl7rDoF2TYMERL7JK7CAznVtzdmGtz5whCwajOBGAZLDtwDhjr1N1/YCH7OVNq uhaJYlXtS7Bw1q4//f+gwLfphFzYChHa8hz/18BS7Y3mn7Td0pKeIHqXi1hIuiB4zbz4 7YsFYZaZSlLSexbpyQoKiDbrQmBvKMB8bi6zdBhxWZjP32rIDerti35FLG7bq5VUiI/F QVmP8VKbaRlUqyPt6jL1OiWqjGw537P/98jDLUoYLtjfP3EGchXWTeZo7/7HYznnZEgL AOgJC6UGd+rOjF5jqMt2VgL5fDnTnMWCWBaWjvrToVlKMW3iH2homuqq582vyA5LABmq kXWw== X-Forwarded-Encrypted: i=1; AJvYcCXBdz1rhwOF2jQIao5olSw8A4HaGZPPlzofUXunCMF23lR7VkfAgP9YAQHEkSlR5WensYEYEnLGFwWZRvY=@vger.kernel.org X-Gm-Message-State: AOJu0YxbghMeclsiUnB3L31UW7Z6deXXa0lowvlvfmB5QNMreXdrv764 j20O8hC6fyYobwu/aDGrfrYeLk+F+pJBzpwvcbgjnSjOvLiFFRKQqRre X-Gm-Gg: ASbGncvBT37dECQkNKF4MpGUhyBRuw8ocApURvaE/hr/JZruc1COk5DI9y4L32ARyIl 7ssqYOe/OTNKyec0ROWnaQCuX1NU8BOtiEtPLKI598yHq+JF0jpcgEAEOsoii5NbiuR/JIKfMYr 0LafPruG5JsWpXZez7OLTU+hNAjK0kcv9CvA4pKszQg36u3CS/1AJsi2qtLJCxPjy5UPUijhw5M OVLQHw7vD3+H2X/KU9/pE0nB9eKDTQhYdpS2593UfANfMwZjgxJKppgJAIRAdJkODl7zJl96Nmv KrkhPdlK1CE+7pnG7FJvWnJw+vbW4sfZ3glTNDeYWoZlE8FTGSz3tZPjxrfVMq4l1FeOpcHNKNQ Yg5dL3L8Ci41BHYPQ/keRgQ6VveBlVvt9lY4jkaVS6PvrcsPzCOkM+caS4rnJGbDDA8DPBWlFYO El X-Google-Smtp-Source: AGHT+IGQ+4VLwk5Iv+/D5dAxlk6gGGm5Qf5IpkHeKj11DFxP9amuqpca575LSiEGdLR7xHA60JPV+A== X-Received: by 2002:a17:903:1252:b0:24b:270e:56cb with SMTP id d9443c01a7336-2948b9a660amr90938695ad.27.1761447728242; Sat, 25 Oct 2025 20:02:08 -0700 (PDT) Received: from 7950hx ([43.129.244.20]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29498d40b1esm38100645ad.73.2025.10.25.20.02.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 25 Oct 2025 20:02:07 -0700 (PDT) From: Menglong Dong X-Google-Original-From: Menglong Dong To: ast@kernel.org, jolsa@kernel.org Cc: daniel@iogearbox.net, john.fastabend@gmail.com, andrii@kernel.org, martin.lau@linux.dev, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, kpsingh@kernel.org, sdf@fomichev.me, haoluo@google.com, mattbobrowski@google.com, rostedt@goodmis.org, mhiramat@kernel.org, leon.hwang@linux.dev, jiang.biao@linux.dev, bpf@vger.kernel.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH bpf-next v3 3/7] bpf,x86: add ret_off to invoke_bpf() Date: Sun, 26 Oct 2025 11:01:39 +0800 Message-ID: <20251026030143.23807-4-dongml2@chinatelecom.cn> X-Mailer: git-send-email 2.51.1 In-Reply-To: <20251026030143.23807-1-dongml2@chinatelecom.cn> References: <20251026030143.23807-1-dongml2@chinatelecom.cn> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" For now, the offset of the return value in trampoline is fixed 8-bytes. In this commit, we introduce the variable "ret_off" to represent the offset of the return value. For now, the "ret_off" is just 8. And in the following patch, we will make it something else to use the room after it. Signed-off-by: Menglong Dong --- arch/x86/net/bpf_jit_comp.c | 41 +++++++++++++++++++++---------------- 1 file changed, 23 insertions(+), 18 deletions(-) diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c index 389c3a96e2b8..7a604ee9713f 100644 --- a/arch/x86/net/bpf_jit_comp.c +++ b/arch/x86/net/bpf_jit_comp.c @@ -2940,7 +2940,7 @@ static void restore_regs(const struct btf_func_model = *m, u8 **prog, =20 static int invoke_bpf_prog(const struct btf_func_model *m, u8 **pprog, struct bpf_tramp_link *l, int stack_size, - int run_ctx_off, bool save_ret, + int run_ctx_off, bool save_ret, int ret_off, void *image, void *rw_image) { u8 *prog =3D *pprog; @@ -3005,7 +3005,7 @@ static int invoke_bpf_prog(const struct btf_func_mode= l *m, u8 **pprog, * value of BPF_PROG_TYPE_STRUCT_OPS prog. */ if (save_ret) - emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8); + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -ret_off); =20 /* replace 2 nops with JE insn, since jmp target is known */ jmp_insn[0] =3D X86_JE; @@ -3055,7 +3055,7 @@ static int emit_cond_near_jump(u8 **pprog, void *func= , void *ip, u8 jmp_cond) =20 static int invoke_bpf(const struct btf_func_model *m, u8 **pprog, struct bpf_tramp_links *tl, int stack_size, - int run_ctx_off, bool save_ret, + int run_ctx_off, bool save_ret, int ret_off, void *image, void *rw_image) { int i; @@ -3063,7 +3063,8 @@ static int invoke_bpf(const struct btf_func_model *m,= u8 **pprog, =20 for (i =3D 0; i < tl->nr_links; i++) { if (invoke_bpf_prog(m, &prog, tl->links[i], stack_size, - run_ctx_off, save_ret, image, rw_image)) + run_ctx_off, save_ret, ret_off, image, + rw_image)) return -EINVAL; } *pprog =3D prog; @@ -3072,7 +3073,7 @@ static int invoke_bpf(const struct btf_func_model *m,= u8 **pprog, =20 static int invoke_bpf_mod_ret(const struct btf_func_model *m, u8 **pprog, struct bpf_tramp_links *tl, int stack_size, - int run_ctx_off, u8 **branches, + int run_ctx_off, int ret_off, u8 **branches, void *image, void *rw_image) { u8 *prog =3D *pprog; @@ -3082,18 +3083,18 @@ static int invoke_bpf_mod_ret(const struct btf_func= _model *m, u8 **pprog, * Set this to 0 to avoid confusing the program. */ emit_mov_imm32(&prog, false, BPF_REG_0, 0); - emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8); + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -ret_off); for (i =3D 0; i < tl->nr_links; i++) { if (invoke_bpf_prog(m, &prog, tl->links[i], stack_size, run_ctx_off, tru= e, - image, rw_image)) + ret_off, image, rw_image)) return -EINVAL; =20 - /* mod_ret prog stored return value into [rbp - 8]. Emit: - * if (*(u64 *)(rbp - 8) !=3D 0) + /* mod_ret prog stored return value into [rbp - ret_off]. Emit: + * if (*(u64 *)(rbp - ret_off) !=3D 0) * goto do_fexit; */ - /* cmp QWORD PTR [rbp - 0x8], 0x0 */ - EMIT4(0x48, 0x83, 0x7d, 0xf8); EMIT1(0x00); + /* cmp QWORD PTR [rbp - ret_off], 0x0 */ + EMIT4(0x48, 0x83, 0x7d, -ret_off); EMIT1(0x00); =20 /* Save the location of the branch and Generate 6 nops * (4 bytes for an offset and 2 bytes for the jump) These nops @@ -3179,7 +3180,8 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im void *func_addr) { int i, ret, nr_regs =3D m->nr_args, stack_size =3D 0; - int regs_off, nregs_off, ip_off, run_ctx_off, arg_stack_off, rbx_off; + int ret_off, regs_off, nregs_off, ip_off, run_ctx_off, arg_stack_off, + rbx_off; struct bpf_tramp_links *fentry =3D &tlinks[BPF_TRAMP_FENTRY]; struct bpf_tramp_links *fexit =3D &tlinks[BPF_TRAMP_FEXIT]; struct bpf_tramp_links *fmod_ret =3D &tlinks[BPF_TRAMP_MODIFY_RETURN]; @@ -3213,7 +3215,7 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im * RBP + 8 [ return address ] * RBP + 0 [ RBP ] * - * RBP - 8 [ return value ] BPF_TRAMP_F_CALL_ORIG or + * RBP - ret_off [ return value ] BPF_TRAMP_F_CALL_ORIG or * BPF_TRAMP_F_RET_FENTRY_RET flags * * [ reg_argN ] always @@ -3239,6 +3241,7 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im save_ret =3D flags & (BPF_TRAMP_F_CALL_ORIG | BPF_TRAMP_F_RET_FENTRY_RET); if (save_ret) stack_size +=3D 8; + ret_off =3D stack_size; =20 stack_size +=3D nr_regs * 8; regs_off =3D stack_size; @@ -3341,7 +3344,8 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im =20 if (fentry->nr_links) { if (invoke_bpf(m, &prog, fentry, regs_off, run_ctx_off, - flags & BPF_TRAMP_F_RET_FENTRY_RET, image, rw_image)) + flags & BPF_TRAMP_F_RET_FENTRY_RET, ret_off, + image, rw_image)) return -EINVAL; } =20 @@ -3352,7 +3356,8 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im return -ENOMEM; =20 if (invoke_bpf_mod_ret(m, &prog, fmod_ret, regs_off, - run_ctx_off, branches, image, rw_image)) { + run_ctx_off, ret_off, branches, + image, rw_image)) { ret =3D -EINVAL; goto cleanup; } @@ -3380,7 +3385,7 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im } } /* remember return value in a stack for bpf prog to access */ - emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -8); + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -ret_off); im->ip_after_call =3D image + (prog - (u8 *)rw_image); emit_nops(&prog, X86_PATCH_SIZE); } @@ -3403,7 +3408,7 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im =20 if (fexit->nr_links) { if (invoke_bpf(m, &prog, fexit, regs_off, run_ctx_off, - false, image, rw_image)) { + false, ret_off, image, rw_image)) { ret =3D -EINVAL; goto cleanup; } @@ -3433,7 +3438,7 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im =20 /* restore return value of orig_call or fentry prog back into RAX */ if (save_ret) - emit_ldx(&prog, BPF_DW, BPF_REG_0, BPF_REG_FP, -8); + emit_ldx(&prog, BPF_DW, BPF_REG_0, BPF_REG_FP, -ret_off); =20 emit_ldx(&prog, BPF_DW, BPF_REG_6, BPF_REG_FP, -rbx_off); EMIT1(0xC9); /* leave */ --=20 2.51.1 From nobody Sun Feb 8 05:23:09 2026 Received: from mail-pl1-f194.google.com (mail-pl1-f194.google.com [209.85.214.194]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 9C3BA266B72 for ; Sun, 26 Oct 2025 03:02:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.194 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447736; cv=none; b=If26bB6j6X+JpuZtGS9eI7ExxdLvdpWSJ3v42XOSeZvK8w0V5B2xJ/+9/jseLLQRnuUffX3igXe7a5DBWTbXKm1nGv2qkb1aGf1XXD4hdRabdwNL7KVul2i3o+3GzcnDnix7bBVSNw3HlgNYK5vsS91FK+VEqV9Xo4ZoqPVdqw0= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447736; c=relaxed/simple; bh=9WMnOBXpLJRUbH41wsToxqgSiyUE4tpopflMkrmjCnQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=IzJMktcIGajjbeEUL1dfWsvvZ1HmLGLDI8nNWgVF1MT7UV+DuqdMyYhv/CTS8w5A4LHOUBAK3qxmhZ4kRyoT7PvWQrKrg2YM7ExdUT5WGYuT52ny+BN9K8q2OsYTvyEcuFP2cubAmh2LpL/JS+gPujpcm2Q6092m/bE4vRAplGI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Rj9iIq5Y; arc=none smtp.client-ip=209.85.214.194 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Rj9iIq5Y" Received: by mail-pl1-f194.google.com with SMTP id d9443c01a7336-27c369f898fso56159535ad.3 for ; Sat, 25 Oct 2025 20:02:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761447734; x=1762052534; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=xYixTqYDGvNEVEGtkOphOlsWEmlpVEfnMBchHwjcsb8=; b=Rj9iIq5YKGQ+wcTV8RGE7PxqEkEFQWgu4/hO3iqzFm98XP05JDDS4BXnjf45/3ICDL UPYoAnx8otvVKrMQguB10qBB8yDS9uSmNuT2oki8xxbmgZmelcoGT1nBG/ljMJtbQGih bc4c2LoTyHUJtdlYhXtMf9uaKpCn3E18yUG8y+ZjGAafEvp/ArL7ga1hlVCZ6yVVoqbD 99LmZGh3BLeLzLl5iBQzueNhoCGZippSt4GmgBUCWxuGtRq3X7jKPXVqqE3eLJFAJs97 yTgsB9pl/1OsGg9NZaHbyedFhczm6IaeJA2Ex28VAIFDO52kRjvc3mv6pdU2gvL7ftRW 9rcA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761447734; x=1762052534; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=xYixTqYDGvNEVEGtkOphOlsWEmlpVEfnMBchHwjcsb8=; b=c5+kSKymtfcu6UToh5VQfBWB2LKVfouh8VyYCUlGFabCVE5f9+Qlj62WXY8WqWN/rf K9H37b5DZzEJwibsNRLtXCWJBijOGa621V/SK3eIbfRhhqIoejlLgfw6ohoV0xJMT/SH zSMUHHkWos+M7S1N1+cRfTHcPdUfjDM26hjQAGI0E2+8zJpKLHZ8GA547voRjY4cPCGM RNNFU26ht6RmckBhzA+JD/o0W8WU9narhUBB8jg/BEmr90qed6UMste3Eva7Pg68W80K xkMc17EI9Ye6BwShA0gEt85DefNw/KXmLkmbMf9afJxuEg8ARyVhSO5xjXJprDtdjkAo FRwQ== X-Forwarded-Encrypted: i=1; AJvYcCWCAjfL+PTOkjGzro2EqxXyrnGUdRa1Qm0zJ7st4LOE5TTJVCKFaxMj/s6LJ2IUL+SDFs9SdAXPeSkzW+w=@vger.kernel.org X-Gm-Message-State: AOJu0YxitxExk4t5qeoUwt2XKqn4pwJ1G7fRjpEu0AHw9LTgvI64H2Yz OKhnVL8S79PM+ZpuuW0aw5aJI+a6nDuFh5KlNNq3QKxTjuE4BiUG5fsI X-Gm-Gg: ASbGncvqdlaA7FToDkZVv1Mq/MXBb1cEKWOrjsOe2TF+QwPakfoeHs03rXDJQXkhtlo gSmP+ZDmq/q7FTrVHOYlAY70jkgZwmnlT/Hd789APa1N+4+X8f1+ozaEVu1MJqO1YLK3/Mkmx9b dZs7bMiSXgr4B6Gsn7nCQtWKiemhTIBwA/ckOJnPEpC9BgYZNCI2Vci3uiMq/DTo7Dz++dIM9tx zsfpjfkaZp6QscWD03KQA06m8r3v/4R0qQQZTESpu+ZRUsI4/Ebw3a48Tba5VQq8aoH2wL7Clmm NQDxJT7hzzZAqaAvKrCf2iwbW+rGLzoDjTkzZ9Glk0qKwGt9EG8DG0g9MsTcoLkEveydNLFX44B WEGXjlIsheIc17YsMKr5vHjaCP6+VNyo8E2aXtACeIrEJUhttiw8AvDL4IuxZJiCdb7Yx92+12K pQvcK0n9NTJbyf0iF8NRoAEg== X-Google-Smtp-Source: AGHT+IGn+lOrWPi9jnO8+VAyeqm62nJfG2lqyJ3NO9cm7pAXySURrwOZRT5Ja1F1QUdbn2Rx7CJ03A== X-Received: by 2002:a17:902:ecc8:b0:290:c516:8c53 with SMTP id d9443c01a7336-290caf831d8mr413807945ad.40.1761447733650; Sat, 25 Oct 2025 20:02:13 -0700 (PDT) Received: from 7950hx ([43.129.244.20]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29498d40b1esm38100645ad.73.2025.10.25.20.02.08 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 25 Oct 2025 20:02:13 -0700 (PDT) From: Menglong Dong X-Google-Original-From: Menglong Dong To: ast@kernel.org, jolsa@kernel.org Cc: daniel@iogearbox.net, john.fastabend@gmail.com, andrii@kernel.org, martin.lau@linux.dev, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, kpsingh@kernel.org, sdf@fomichev.me, haoluo@google.com, mattbobrowski@google.com, rostedt@goodmis.org, mhiramat@kernel.org, leon.hwang@linux.dev, jiang.biao@linux.dev, bpf@vger.kernel.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH bpf-next v3 4/7] bpf,x86: add tracing session supporting for x86_64 Date: Sun, 26 Oct 2025 11:01:40 +0800 Message-ID: <20251026030143.23807-5-dongml2@chinatelecom.cn> X-Mailer: git-send-email 2.51.1 In-Reply-To: <20251026030143.23807-1-dongml2@chinatelecom.cn> References: <20251026030143.23807-1-dongml2@chinatelecom.cn> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add BPF_TRACE_SESSION supporting to x86_64. invoke_bpf_session_entry and invoke_bpf_session_exit is introduced for this purpose. In invoke_bpf_session_entry(), we will check if the return value of the fentry is 0, and set the corresponding session flag if not. And in invoke_bpf_session_exit(), we will check if the corresponding flag is set. If set, the fexit will be skipped. As designed, the session flags and session cookie address is stored after the return value, and the stack look like this: cookie ptr -> 8 bytes session flags -> 8 bytes return value -> 8 bytes argN -> 8 bytes ... arg1 -> 8 bytes nr_args -> 8 bytes ... cookieN -> 8 bytes cookie1 -> 8 bytes In the entry of the session, we will clear the return value, so the fentry will always get 0 with ctx[nr_args] or bpf_get_func_ret(). Before the execution of the BPF prog, the "cookie ptr" will be filled with the corresponding cookie address, which is done in invoke_bpf_session_entry() and invoke_bpf_session_exit(). Signed-off-by: Menglong Dong Co-developed-by: Leon Hwang Signed-off-by: Leon Hwang --- v2: - add session cookie support - add the session stuff after return value, instead of before nr_args --- arch/x86/net/bpf_jit_comp.c | 185 +++++++++++++++++++++++++++++++++++- 1 file changed, 181 insertions(+), 4 deletions(-) diff --git a/arch/x86/net/bpf_jit_comp.c b/arch/x86/net/bpf_jit_comp.c index 7a604ee9713f..2fffc530c88c 100644 --- a/arch/x86/net/bpf_jit_comp.c +++ b/arch/x86/net/bpf_jit_comp.c @@ -3109,6 +3109,148 @@ static int invoke_bpf_mod_ret(const struct btf_func= _model *m, u8 **pprog, return 0; } =20 +static int invoke_bpf_session_entry(const struct btf_func_model *m, u8 **p= prog, + struct bpf_tramp_links *tl, int stack_size, + int run_ctx_off, int ret_off, int sflags_off, + int cookies_off, void *image, void *rw_image) +{ + int i, j =3D 0, cur_cookie_off; + u64 session_flags; + u8 *prog =3D *pprog; + u8 *jmp_insn; + + /* clear the session flags: + * xor rax, rax + * mov QWORD PTR [rbp - sflags_off], rax + */ + EMIT3(0x48, 0x31, 0xC0); + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -sflags_off); + /* + * clear the return value to make sure bpf_get_func_ret() always + * get 0 in fentry: + * mov QWORD PTR [rbp - 0x8], rax + */ + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -ret_off); + /* clear all the cookies in the cookie array */ + for (i =3D 0; i < tl->nr_links; i++) { + if (tl->links[i]->link.prog->call_session_cookie) { + cur_cookie_off =3D -cookies_off + j * 8; + /* mov QWORD PTR [rbp - sflags_off], rax */ + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, + cur_cookie_off); + j++; + } + } + + j =3D 0; + for (i =3D 0; i < tl->nr_links; i++) { + if (tl->links[i]->link.prog->call_session_cookie) { + cur_cookie_off =3D -cookies_off + j * 8; + /* + * save the cookie address to rbp - sflags_off + 8: + * lea rax, [rbp - cur_cookie_off] + * mov QWORD PTR [rbp - sflags_off + 8], rax + */ + if (!is_imm8(cur_cookie_off)) + EMIT3_off32(0x48, 0x8D, 0x85, cur_cookie_off); + else + EMIT4(0x48, 0x8D, 0x45, cur_cookie_off); + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -sflags_off + 8); + j++; + } + if (invoke_bpf_prog(m, &prog, tl->links[i], stack_size, run_ctx_off, tru= e, + ret_off, image, rw_image)) + return -EINVAL; + + /* fentry prog stored return value into [rbp - 8]. Emit: + * if (*(u64 *)(rbp - ret_off) !=3D 0) { + * *(u64 *)(rbp - sflags_off) |=3D (1 << (i + 1)); + * *(u64 *)(rbp - ret_off) =3D 0; + * } + */ + /* cmp QWORD PTR [rbp - ret_off], 0x0 */ + EMIT4(0x48, 0x83, 0x7d, -ret_off); EMIT1(0x00); + /* emit 2 nops that will be replaced with JE insn */ + jmp_insn =3D prog; + emit_nops(&prog, 2); + + session_flags =3D (1ULL << (i + 1)); + /* mov rax, $session_flags */ + emit_mov_imm64(&prog, BPF_REG_0, session_flags >> 32, (u32) session_flag= s); + /* or QWORD PTR [rbp - sflags_off], rax */ + EMIT2(0x48, 0x09); + emit_insn_suffix(&prog, BPF_REG_FP, BPF_REG_0, -sflags_off); + + /* mov QWORD PTR [rbp - ret_off], 0x0 */ + EMIT4(0x48, 0xC7, 0x45, -ret_off); EMIT4(0x00, 0x00, 0x00, 0x00); + + jmp_insn[0] =3D X86_JE; + jmp_insn[1] =3D prog - jmp_insn - 2; + } + + *pprog =3D prog; + return 0; +} + +static int invoke_bpf_session_exit(const struct btf_func_model *m, u8 **pp= rog, + struct bpf_tramp_links *tl, int stack_size, + int run_ctx_off, int ret_off, int sflags_off, + int cookies_off, void *image, void *rw_image) +{ + int i, j =3D 0, cur_cookie_off; + u64 session_flags; + u8 *prog =3D *pprog; + u8 *jmp_insn; + + /* + * set the bpf_trace_is_exit flag to the session flags: + * mov rax, 1 + * or QWORD PTR [rbp - sflags_off], rax + */ + emit_mov_imm32(&prog, false, BPF_REG_0, 1); + EMIT2(0x48, 0x09); + emit_insn_suffix(&prog, BPF_REG_FP, BPF_REG_0, -sflags_off); + + for (i =3D 0; i < tl->nr_links; i++) { + if (tl->links[i]->link.prog->call_session_cookie) { + cur_cookie_off =3D -cookies_off + j * 8; + /* + * save the cookie address to rbp - sflags_off + 8: + * lea rax, [rbp - cur_cookie_off] + * mov QWORD PTR [rbp - sflags_off + 8], rax + */ + if (!is_imm8(cur_cookie_off)) + EMIT3_off32(0x48, 0x8D, 0x85, cur_cookie_off); + else + EMIT4(0x48, 0x8D, 0x45, cur_cookie_off); + emit_stx(&prog, BPF_DW, BPF_REG_FP, BPF_REG_0, -sflags_off + 8); + j++; + } + /* check if (1 << (i+1)) is set in the session flags, and + * skip the execution of the fexit program if it is. + */ + session_flags =3D 1ULL << (i + 1); + /* mov rax, $session_flags */ + emit_mov_imm64(&prog, BPF_REG_0, session_flags >> 32, (u32) session_flag= s); + /* test QWORD PTR [rbp - sflags_off], rax */ + EMIT2(0x48, 0x85); + emit_insn_suffix(&prog, BPF_REG_FP, BPF_REG_0, -sflags_off); + /* emit 2 nops that will be replaced with JE insn */ + jmp_insn =3D prog; + emit_nops(&prog, 2); + + if (invoke_bpf_prog(m, &prog, tl->links[i], stack_size, run_ctx_off, fal= se, + ret_off, image, rw_image)) + return -EINVAL; + + jmp_insn[0] =3D X86_JNE; + jmp_insn[1] =3D prog - jmp_insn - 2; + } + + *pprog =3D prog; + return 0; +} + /* mov rax, qword ptr [rbp - rounded_stack_depth - 8] */ #define LOAD_TRAMP_TAIL_CALL_CNT_PTR(stack) \ __LOAD_TCC_PTR(-round_up(stack, 8) - 8) @@ -3181,8 +3323,9 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im { int i, ret, nr_regs =3D m->nr_args, stack_size =3D 0; int ret_off, regs_off, nregs_off, ip_off, run_ctx_off, arg_stack_off, - rbx_off; + rbx_off, sflags_off =3D 0, cookies_off; struct bpf_tramp_links *fentry =3D &tlinks[BPF_TRAMP_FENTRY]; + struct bpf_tramp_links *session =3D &tlinks[BPF_TRAMP_SESSION]; struct bpf_tramp_links *fexit =3D &tlinks[BPF_TRAMP_FEXIT]; struct bpf_tramp_links *fmod_ret =3D &tlinks[BPF_TRAMP_MODIFY_RETURN]; void *orig_call =3D func_addr; @@ -3215,6 +3358,9 @@ static int __arch_prepare_bpf_trampoline(struct bpf_t= ramp_image *im, void *rw_im * RBP + 8 [ return address ] * RBP + 0 [ RBP ] * + * [ cookie ptr ] tracing session + * RBP - sflags_off [ session flags ] tracing session + * * RBP - ret_off [ return value ] BPF_TRAMP_F_CALL_ORIG or * BPF_TRAMP_F_RET_FENTRY_RET flags * @@ -3230,6 +3376,10 @@ static int __arch_prepare_bpf_trampoline(struct bpf_= tramp_image *im, void *rw_im * * RBP - run_ctx_off [ bpf_tramp_run_ctx ] * + * [ session cookieN ] + * [ ... ] + * RBP - cookies_off [ session cookie1 ] tracing session + * * [ stack_argN ] BPF_TRAMP_F_CALL_ORIG * [ ... ] * [ stack_arg2 ] @@ -3237,6 +3387,12 @@ static int __arch_prepare_bpf_trampoline(struct bpf_= tramp_image *im, void *rw_im * RSP [ tail_call_cnt_ptr ] BPF_TRAMP_F_TAIL_CALL_CTX */ =20 + /* room for session flags and cookie ptr */ + if (session->nr_links) { + stack_size +=3D 8 + 8; + sflags_off =3D stack_size; + } + /* room for return value of orig_call or fentry prog */ save_ret =3D flags & (BPF_TRAMP_F_CALL_ORIG | BPF_TRAMP_F_RET_FENTRY_RET); if (save_ret) @@ -3261,6 +3417,14 @@ static int __arch_prepare_bpf_trampoline(struct bpf_= tramp_image *im, void *rw_im stack_size +=3D (sizeof(struct bpf_tramp_run_ctx) + 7) & ~0x7; run_ctx_off =3D stack_size; =20 + if (session->nr_links) { + for (i =3D 0; i < session->nr_links; i++) { + if (session->links[i]->link.prog->call_session_cookie) + stack_size +=3D 8; + } + } + cookies_off =3D stack_size; + if (nr_regs > 6 && (flags & BPF_TRAMP_F_CALL_ORIG)) { /* the space that used to pass arguments on-stack */ stack_size +=3D (nr_regs - get_nr_used_regs(m)) * 8; @@ -3349,6 +3513,13 @@ static int __arch_prepare_bpf_trampoline(struct bpf_= tramp_image *im, void *rw_im return -EINVAL; } =20 + if (session->nr_links) { + if (invoke_bpf_session_entry(m, &prog, session, regs_off, + run_ctx_off, ret_off, sflags_off, + cookies_off, image, rw_image)) + return -EINVAL; + } + if (fmod_ret->nr_links) { branches =3D kcalloc(fmod_ret->nr_links, sizeof(u8 *), GFP_KERNEL); @@ -3414,6 +3585,15 @@ static int __arch_prepare_bpf_trampoline(struct bpf_= tramp_image *im, void *rw_im } } =20 + if (session->nr_links) { + if (invoke_bpf_session_exit(m, &prog, session, regs_off, + run_ctx_off, ret_off, sflags_off, + cookies_off, image, rw_image)) { + ret =3D -EINVAL; + goto cleanup; + } + } + if (flags & BPF_TRAMP_F_RESTORE_REGS) restore_regs(m, &prog, regs_off); =20 @@ -3483,9 +3663,6 @@ int arch_prepare_bpf_trampoline(struct bpf_tramp_imag= e *im, void *image, void *i int ret; u32 size =3D image_end - image; =20 - if (tlinks[BPF_TRAMP_SESSION].nr_links) - return -EOPNOTSUPP; - /* rw_image doesn't need to be in module memory range, so we can * use kvmalloc. */ --=20 2.51.1 From nobody Sun Feb 8 05:23:09 2026 Received: from mail-pg1-f195.google.com (mail-pg1-f195.google.com [209.85.215.195]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 96CFE235358 for ; Sun, 26 Oct 2025 03:02:19 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.195 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447741; cv=none; b=qfqoWa96CXa3MLbua4aeYN/MRe73G7tU/i/Gans74Es1CGO/SRsIvxQF+Ryr+puFxmTyhDLc/CwuSW1z3qM1gv1o4YQp/XdckzgGSH3dM6Za9DTGThvzqWji4XZb+A4NbYcI5mP4q3h/6hnPfFDhTHm2fLYFemoMeh108L9/EkM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447741; c=relaxed/simple; bh=GuQCFueyfn/NObmpfJmrdR72fVp0TkDQ5S2HEwT1H3c=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=bPEuaXfS+yUZecAVY3aBtkaUBVRdxRGNKWxpU1bWNfMNyCpHalTdwkTnzzzk/LvI4P1uz87CNmFPQ7OIarnZhB/HUc/qA4I6QLnYUMmmv+fV7iIFK+dXQv6Rq3CTKdVn9c/9Zdx7SkpSLFeNG7jyiKfugHzKvfeQTlqsN5tsAVs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=YWgDQdHD; arc=none smtp.client-ip=209.85.215.195 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="YWgDQdHD" Received: by mail-pg1-f195.google.com with SMTP id 41be03b00d2f7-b6cf25c9ad5so2662637a12.0 for ; Sat, 25 Oct 2025 20:02:19 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761447739; x=1762052539; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=tUOMYuKJiVL10Vf/aBjRKKIq/GvniLJo4ZiI6vGstps=; b=YWgDQdHDAtXoElxx5CnGKV/TgEz36w8+uuxtC+GMnMcHLBnJbZM7/7omz82BJa/lcf Kt4EuLwfbuSTLm59z12h2680ZPPfGA0sfFNt/N1uzdzpD5J68cDj0wcJO9C71QJ5phCE ivv3gP37sB3iWVw1xYV8VG3WVjo55kC2sXqg8KSmUY75I657AHITvJH3inXOBZClNUCh j76ixUtg3FbukyWIdPRl4Qvr86/UwkGaEAmn8zQEC+Vaa23DWz2wV5XQVBT66aA96E4q M3qHi6rOhX34/7xQb5CoqyPxcB6bL70Xn73C+uiYRHV/zPyL7BzjoYO9Y2ZGP1jWXzUW 297w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761447739; x=1762052539; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=tUOMYuKJiVL10Vf/aBjRKKIq/GvniLJo4ZiI6vGstps=; b=rz71OCBP9Kdhq2kVYECBGdviFQaIhpPGueW57+r7++Eq5O45FGJ0k09rJ42tMgtXDn jytNVe3bEBkPB0xlg+QywAqi2ZsjxwzI67GHGeJw4jkyIwqnWTSpDneWjJh5Fxiiqg90 7AFpUOtIOBXPRsRR9PbH9E1pJ9bpIrB2ZS0WRu5VfrmLxCdgdze5Yul08Lwg4PbR4SZY /Ve7bbRfcGe+UAWOjkK6siP7srlPcPUUqu6wfeK/5rPgOljgcjLNFlaow6JD4CYeww4S U50q9llQ5Y1zHRXuU4tEAikhTO/T1O90yqDhIzqTQnaF+vd1MegA7i5PlN/4HpnPZs8O gEEQ== X-Forwarded-Encrypted: i=1; AJvYcCU+cBBc41GJTSbcIMeYrURZdlcCPCkZylSnL3h4h+ztBY7t1xjCP341uIn4ldzvZg4ynOcXEK5wQezAQ8g=@vger.kernel.org X-Gm-Message-State: AOJu0YwCl+2pfwtSYz9NRYF6jSBqEOIYeypcpjGF1grrbgAF3t95yQLA GawC5XYrJkC5MoY5aia75Ntxe5QT+KFHTAbkKsrM49T30gg44sF9YEiZ X-Gm-Gg: ASbGncufgWm9OPilYVLL21reJY9B49L5H29KG/Z5eFUTkGt+9Wz31buafsX76a1ZpZk 8tif4GssOPeE2rqk/TbZ8AFOP3uk1Pjp+Wy7xkkYXJ89U8MTqllv15/QO4hKY20k4Gqg/7jGeI+ da3IbjHaSttkyWcYwECUvh4UP8FKiXOYQe+a+ElVnXrjzJzq5XNOCP0oj1kPNPqAJsK1X9IQdQp gf63wsLoILopZT0aCHf7qQdQrABGSjqqUgS+rLj2Tukbi78K0aC9Io0Z28zRvipYa1Hzk7ApBy3 b7sCOK8TZbUQ4fvZIqCshiuyZUEVTg4DgVDxPkHuouy3a5XE3B3gwA8p+c+zAFCDP+kQa3/WRWp I6o34m5w/0BIkyqASYY/0X4ipFzPWvXRff2/Ei0kGhtKEeSOQ9GNImCHMP/nVsV2mLHGlUqAj7P 0FiFGuUv0WGfc= X-Google-Smtp-Source: AGHT+IGcA7pHr4jE0Gm+8ckx81Sfog4EhdhLlaxTxBPWluCuyJcg7FGtnsCogj3Zbc3RxSb9u6qqzw== X-Received: by 2002:a17:902:e841:b0:290:c902:759 with SMTP id d9443c01a7336-290ccab6c0amr359938645ad.51.1761447738936; Sat, 25 Oct 2025 20:02:18 -0700 (PDT) Received: from 7950hx ([43.129.244.20]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29498d40b1esm38100645ad.73.2025.10.25.20.02.14 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 25 Oct 2025 20:02:18 -0700 (PDT) From: Menglong Dong X-Google-Original-From: Menglong Dong To: ast@kernel.org, jolsa@kernel.org Cc: daniel@iogearbox.net, john.fastabend@gmail.com, andrii@kernel.org, martin.lau@linux.dev, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, kpsingh@kernel.org, sdf@fomichev.me, haoluo@google.com, mattbobrowski@google.com, rostedt@goodmis.org, mhiramat@kernel.org, leon.hwang@linux.dev, jiang.biao@linux.dev, bpf@vger.kernel.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH bpf-next v3 5/7] libbpf: add support for tracing session Date: Sun, 26 Oct 2025 11:01:41 +0800 Message-ID: <20251026030143.23807-6-dongml2@chinatelecom.cn> X-Mailer: git-send-email 2.51.1 In-Reply-To: <20251026030143.23807-1-dongml2@chinatelecom.cn> References: <20251026030143.23807-1-dongml2@chinatelecom.cn> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add BPF_TRACE_SESSION to libbpf and bpftool. Signed-off-by: Menglong Dong --- tools/bpf/bpftool/common.c | 1 + tools/lib/bpf/bpf.c | 2 ++ tools/lib/bpf/libbpf.c | 3 +++ 3 files changed, 6 insertions(+) diff --git a/tools/bpf/bpftool/common.c b/tools/bpf/bpftool/common.c index e8daf963ecef..534be6cfa2be 100644 --- a/tools/bpf/bpftool/common.c +++ b/tools/bpf/bpftool/common.c @@ -1191,6 +1191,7 @@ const char *bpf_attach_type_input_str(enum bpf_attach= _type t) case BPF_TRACE_FENTRY: return "fentry"; case BPF_TRACE_FEXIT: return "fexit"; case BPF_MODIFY_RETURN: return "mod_ret"; + case BPF_TRACE_SESSION: return "fsession"; case BPF_SK_REUSEPORT_SELECT: return "sk_skb_reuseport_select"; case BPF_SK_REUSEPORT_SELECT_OR_MIGRATE: return "sk_skb_reuseport_select_= or_migrate"; default: return libbpf_bpf_attach_type_str(t); diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c index 339b19797237..caed2b689068 100644 --- a/tools/lib/bpf/bpf.c +++ b/tools/lib/bpf/bpf.c @@ -794,6 +794,7 @@ int bpf_link_create(int prog_fd, int target_fd, case BPF_TRACE_FENTRY: case BPF_TRACE_FEXIT: case BPF_MODIFY_RETURN: + case BPF_TRACE_SESSION: case BPF_LSM_MAC: attr.link_create.tracing.cookie =3D OPTS_GET(opts, tracing.cookie, 0); if (!OPTS_ZEROED(opts, tracing)) @@ -917,6 +918,7 @@ int bpf_link_create(int prog_fd, int target_fd, case BPF_TRACE_FENTRY: case BPF_TRACE_FEXIT: case BPF_MODIFY_RETURN: + case BPF_TRACE_SESSION: return bpf_raw_tracepoint_open(NULL, prog_fd); default: return libbpf_err(err); diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index b90574f39d1c..50d10d01315a 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -115,6 +115,7 @@ static const char * const attach_type_name[] =3D { [BPF_TRACE_FENTRY] =3D "trace_fentry", [BPF_TRACE_FEXIT] =3D "trace_fexit", [BPF_MODIFY_RETURN] =3D "modify_return", + [BPF_TRACE_SESSION] =3D "trace_session", [BPF_LSM_MAC] =3D "lsm_mac", [BPF_LSM_CGROUP] =3D "lsm_cgroup", [BPF_SK_LOOKUP] =3D "sk_lookup", @@ -9607,6 +9608,8 @@ static const struct bpf_sec_def section_defs[] =3D { SEC_DEF("fentry.s+", TRACING, BPF_TRACE_FENTRY, SEC_ATTACH_BTF | SEC_SLE= EPABLE, attach_trace), SEC_DEF("fmod_ret.s+", TRACING, BPF_MODIFY_RETURN, SEC_ATTACH_BTF | SEC_= SLEEPABLE, attach_trace), SEC_DEF("fexit.s+", TRACING, BPF_TRACE_FEXIT, SEC_ATTACH_BTF | SEC_SLEEP= ABLE, attach_trace), + SEC_DEF("fsession+", TRACING, BPF_TRACE_SESSION, SEC_ATTACH_BTF, attach_= trace), + SEC_DEF("fsession.s+", TRACING, BPF_TRACE_SESSION, SEC_ATTACH_BTF | SEC_= SLEEPABLE, attach_trace), SEC_DEF("freplace+", EXT, 0, SEC_ATTACH_BTF, attach_trace), SEC_DEF("lsm+", LSM, BPF_LSM_MAC, SEC_ATTACH_BTF, attach_lsm), SEC_DEF("lsm.s+", LSM, BPF_LSM_MAC, SEC_ATTACH_BTF | SEC_SLEEPABLE, atta= ch_lsm), --=20 2.51.1 From nobody Sun Feb 8 05:23:09 2026 Received: from mail-pl1-f194.google.com (mail-pl1-f194.google.com [209.85.214.194]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id D4559263C8A for ; Sun, 26 Oct 2025 03:02:24 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.194 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447746; cv=none; b=JI/KphuCUqEKMkYjWqiDr8qHk/SrNOFz60nBMsJxkFpZkLRwA62Ab9b7jDpDhuglgjBEHRVgTanls8YPXjpuYIVdUUJOwwDLTM70wJI87nIET6g35s8pNhy5pUzN/EYmgwUh1TJ0uI/gOUq9BGf+0VFZNhi/Lhe8TTYCOVf433M= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447746; c=relaxed/simple; bh=WtEw/cOnIurjZ3m4c1DDzrlB/+T+8TwDeq57Z/EA/sY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=gA6ltlhahvfjBQFjoZf0MPQJgepyf0DqloqMZk6AXlQxc8ZAfzqQR+OF0SKk0EW4Sjoyf9LSgZRW5rVy9k8wfL3XbfAdANP3g5PFu5rhPACWio8JzPVWTPNB9CRfV5y7N6dSXQYC5+FngksTNRRLyYd40Je82L96gNqt8M+AjrA= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=K21sRyDk; arc=none smtp.client-ip=209.85.214.194 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="K21sRyDk" Received: by mail-pl1-f194.google.com with SMTP id d9443c01a7336-2947d345949so28400635ad.3 for ; Sat, 25 Oct 2025 20:02:24 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761447744; x=1762052544; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=Si0SffDooGR2dYlH1den/9FtyvBKYH381FHeTTZ5tGs=; b=K21sRyDkPD46xcN941DHsqTvzR/xwkUUt0FXI4L+XfLuLyBoVFC4cUazZtSKofTUgL 0nFqXG3KDL8JGWiXq5OQtk0CkXWkiF++1aglI3Zp1Ig6IQ3F+UHFKkPGVvW7edSufhdm grqZzvcLRGtMF3/Z5lvECS1VVrSvSaIZnJQDWGcdphHiP8TV672IvlUlbP8Xk73XW+pc kN43VZgVPAUQjz8gSenW+C51y/1ZQFbIHNhl4dO59+0pZmYGm3AaHv6sNXLziTdqR9ho n+rdOKHkRhCbTwQZ3xA4B8WtSGJRKMhLwFJwCdSGrkON4GnN+8FPexgOpc15Xrv6a9m5 Qyiw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761447744; x=1762052544; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Si0SffDooGR2dYlH1den/9FtyvBKYH381FHeTTZ5tGs=; b=RhTiv4zyluHQSNnK/vG63MZpws4gDzGlHzUDPRs/ibKXcQUtHM26LhwN8uZP1O+n0l eiokjMcUWgM4eTZeibyXgBVtDRaiHhPkyl9/KuhZ1XXWqFSBL7M/wssr1xzWV8+BbJ+a zG9nuCsYYmuYmQHP520qawp/dyM96bSiTzjI2RAray5C8P12VzVmRHASk5CNDCy/NQvI Ry4ocXASTpZVKrnw8dT6GxPbJ3Gnh61Ld3Yf+Db13vMQ6P8bZxJbGM/4dBUyDY/ev4ad C9QTDHSw3KotYXRiSy99GPkyLfdZorWa0sUfOksMhst3gvK4r4USsqOh5ZxLEth9Cb1u 7KLg== X-Forwarded-Encrypted: i=1; AJvYcCUEck3uRChePqXsan9ivLUOIPxPHZ6W+GfgjjHjNIZVexTXDSB7BrsAoUOJCVpCjIDqvHc3wr8NgTwiasQ=@vger.kernel.org X-Gm-Message-State: AOJu0YwqhTi/V3nxaZ5zbY8Jq3GGmdzZvqP3e8jnBfDHivIRSs4Ukd9l dRsbCiRlN+8vLlIAeAebeanAtV2/12EQ9k8e7r6J+vh1eK6L+qmcnG7M X-Gm-Gg: ASbGncsj1f5GcpwEpgWE5OOhi40v55nSgdEw/O4GMLNPcnqjqx7jKQr0blEy/RczDXA UFECFrPucxkeVut04rJxdAD5AMQFZHuTmqwgcjLml38SF7aDMZ4ClQLQxTVO2js90OjQsjuoCSe TMusmSKQj1J8QZdIxhNQZ1kfuFAFWNiFxX0+biQU1unMrfxKhy0bjVNzHnQ4/LTWyK+ZZmIagzA AXjGm9hwNPk++wIZQqw2EMbYhIOMTgIwys5H78Yh5jggvmY0X7us5NcMNlXu7mU0tw8ZxLyQqpf b5pSKY1t4Zn2xYdcQNp2EAOS/m2RxMXmVnqw25AuKPwIowZrXcnow8KO+xbirF+aoqc5vBq8KJt IOJw7Pecs7wuRHwjafiZwvAk6RdATWaYNuKAjFkMF6O8MfWvpHWGMxuzlIxg/EOyPUdo7cyLhCH GtyWzRX1wEz1U= X-Google-Smtp-Source: AGHT+IHlzYi1dMbND3J1xueB/jEv3yr7i0N8IqA07LDawWDPwJ+iwjzjlbdeHd3+1ADunZ4o9urv7g== X-Received: by 2002:a17:903:19e6:b0:273:31fb:a872 with SMTP id d9443c01a7336-290c9c89c81mr423036545ad.6.1761447744266; Sat, 25 Oct 2025 20:02:24 -0700 (PDT) Received: from 7950hx ([43.129.244.20]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29498d40b1esm38100645ad.73.2025.10.25.20.02.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 25 Oct 2025 20:02:23 -0700 (PDT) From: Menglong Dong X-Google-Original-From: Menglong Dong To: ast@kernel.org, jolsa@kernel.org Cc: daniel@iogearbox.net, john.fastabend@gmail.com, andrii@kernel.org, martin.lau@linux.dev, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, kpsingh@kernel.org, sdf@fomichev.me, haoluo@google.com, mattbobrowski@google.com, rostedt@goodmis.org, mhiramat@kernel.org, leon.hwang@linux.dev, jiang.biao@linux.dev, bpf@vger.kernel.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH bpf-next v3 6/7] selftests/bpf: add testcases for tracing session Date: Sun, 26 Oct 2025 11:01:42 +0800 Message-ID: <20251026030143.23807-7-dongml2@chinatelecom.cn> X-Mailer: git-send-email 2.51.1 In-Reply-To: <20251026030143.23807-1-dongml2@chinatelecom.cn> References: <20251026030143.23807-1-dongml2@chinatelecom.cn> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add testcases for BPF_TRACE_SESSION. The function arguments and return value are tested both in the entry and exit. And the kfunc bpf_tracing_is_exit() is also tested. As the layout of the stack changed for fsession, so we also test bpf_get_func_ip() for it. Session cookie for fsession is also tested. Multiple fsession BPF progs is attached to bpf_fentry_test1() and session cookie is read and write in the testcase. Signed-off-by: Menglong Dong --- v3: - restructure the testcase by combine the testcases for session cookie and get_func_ip into one patch --- .../selftests/bpf/prog_tests/fsession_test.c | 95 ++++++++ .../selftests/bpf/progs/fsession_test.c | 230 ++++++++++++++++++ 2 files changed, 325 insertions(+) create mode 100644 tools/testing/selftests/bpf/prog_tests/fsession_test.c create mode 100644 tools/testing/selftests/bpf/progs/fsession_test.c diff --git a/tools/testing/selftests/bpf/prog_tests/fsession_test.c b/tools= /testing/selftests/bpf/prog_tests/fsession_test.c new file mode 100644 index 000000000000..d70bdb683691 --- /dev/null +++ b/tools/testing/selftests/bpf/prog_tests/fsession_test.c @@ -0,0 +1,95 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 ChinaTelecom */ +#include +#include "fsession_test.skel.h" + +static int check_result(struct fsession_test *skel) +{ + LIBBPF_OPTS(bpf_test_run_opts, topts); + int err, prog_fd; + + /* Trigger test function calls */ + prog_fd =3D bpf_program__fd(skel->progs.test1); + err =3D bpf_prog_test_run_opts(prog_fd, &topts); + if (!ASSERT_OK(err, "test_run_opts err")) + return err; + if (!ASSERT_OK(topts.retval, "test_run_opts retval")) + return topts.retval; + + for (int i =3D 0; i < sizeof(*skel->bss) / sizeof(__u64); i++) { + if (!ASSERT_EQ(((__u64 *)skel->bss)[i], 1, "test_result")) + return -EINVAL; + } + + /* some fields go to the "data" sections, not "bss" */ + for (int i =3D 0; i < sizeof(*skel->data) / sizeof(__u64); i++) { + if (!ASSERT_EQ(((__u64 *)skel->data)[i], 1, "test_result")) + return -EINVAL; + } + return 0; +} + +static void test_fsession_basic(void) +{ + struct fsession_test *skel =3D NULL; + int err; + + skel =3D fsession_test__open_and_load(); + if (!ASSERT_OK_PTR(skel, "fsession_test__open_and_load")) + goto cleanup; + + err =3D fsession_test__attach(skel); + if (!ASSERT_OK(err, "fsession_attach")) + goto cleanup; + + check_result(skel); +cleanup: + fsession_test__destroy(skel); +} + +static void test_fsession_reattach(void) +{ + struct fsession_test *skel =3D NULL; + int err; + + skel =3D fsession_test__open_and_load(); + if (!ASSERT_OK_PTR(skel, "fsession_test__open_and_load")) + goto cleanup; + + /* First attach */ + err =3D fsession_test__attach(skel); + if (!ASSERT_OK(err, "fsession_first_attach")) + goto cleanup; + + if (check_result(skel)) + goto cleanup; + + /* Detach */ + fsession_test__detach(skel); + + /* Reset counters */ + memset(skel->bss, 0, sizeof(*skel->bss)); + + /* Second attach */ + err =3D fsession_test__attach(skel); + if (!ASSERT_OK(err, "fsession_second_attach")) + goto cleanup; + + if (check_result(skel)) + goto cleanup; + +cleanup: + fsession_test__destroy(skel); +} + +void test_fsession_test(void) +{ +#if !defined(__x86_64__) + test__skip(); + return; +#endif + if (test__start_subtest("fsession_basic")) + test_fsession_basic(); + if (test__start_subtest("fsession_reattach")) + test_fsession_reattach(); +} diff --git a/tools/testing/selftests/bpf/progs/fsession_test.c b/tools/test= ing/selftests/bpf/progs/fsession_test.c new file mode 100644 index 000000000000..8f266d8e4b55 --- /dev/null +++ b/tools/testing/selftests/bpf/progs/fsession_test.c @@ -0,0 +1,230 @@ +// SPDX-License-Identifier: GPL-2.0 +/* Copyright (c) 2025 ChinaTelecom */ +#include +#include +#include + +char _license[] SEC("license") =3D "GPL"; + +__u64 test1_entry_result =3D 0; +__u64 test1_exit_result =3D 0; + +SEC("fsession/bpf_fentry_test1") +int BPF_PROG(test1, int a, int ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + /* This is entry */ + test1_entry_result =3D a =3D=3D 1 && ret =3D=3D 0; + /* Return 0 to allow exit to be called */ + return 0; + } + + /* This is exit */ + test1_exit_result =3D a =3D=3D 1 && ret =3D=3D 2; + return 0; +} + +__u64 test2_entry_result =3D 0; +__u64 test2_exit_result =3D 1; + +SEC("fsession/bpf_fentry_test2") +int BPF_PROG(test2, int a, __u64 b, int ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + /* This is entry */ + test2_entry_result =3D a =3D=3D 2 && b =3D=3D 3 && ret =3D=3D 0; + /* Return non-zero value to block exit call */ + return 1; + } + + /* This is exit - should not be called due to blocking */ + test2_exit_result =3D 0; + return 0; +} + +__u64 test3_entry_result =3D 0; +__u64 test3_exit_result =3D 0; + +SEC("fsession/bpf_fentry_test3") +int BPF_PROG(test3, char a, int b, __u64 c, int ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + test3_entry_result =3D a =3D=3D 4 && b =3D=3D 5 && c =3D=3D 6 && ret =3D= =3D 0; + return 0; + } + + test3_exit_result =3D a =3D=3D 4 && b =3D=3D 5 && c =3D=3D 6 && ret =3D= =3D 15; + return 0; +} + +__u64 test4_entry_result =3D 0; +__u64 test4_exit_result =3D 0; + +SEC("fsession/bpf_fentry_test4") +int BPF_PROG(test4, void *a, char b, int c, __u64 d, int ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + test4_entry_result =3D a =3D=3D (void *)7 && b =3D=3D 8 && c =3D=3D 9 &&= d =3D=3D 10 && ret =3D=3D 0; + return 0; + } + + test4_exit_result =3D a =3D=3D (void *)7 && b =3D=3D 8 && c =3D=3D 9 && d= =3D=3D 10 && ret =3D=3D 34; + return 0; +} + +__u64 test5_entry_result =3D 0; +__u64 test5_exit_result =3D 0; + +SEC("fsession/bpf_fentry_test5") +int BPF_PROG(test5, __u64 a, void *b, short c, int d, __u64 e, int ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + test5_entry_result =3D a =3D=3D 11 && b =3D=3D (void *)12 && c =3D=3D 13= && d =3D=3D 14 && + e =3D=3D 15 && ret =3D=3D 0; + return 0; + } + + test5_exit_result =3D a =3D=3D 11 && b =3D=3D (void *)12 && c =3D=3D 13 &= & d =3D=3D 14 && + e =3D=3D 15 && ret =3D=3D 65; + return 0; +} + +__u64 test6_entry_result =3D 0; +__u64 test6_exit_result =3D 1; + +SEC("fsession/bpf_fentry_test6") +int BPF_PROG(test6, __u64 a, void *b, short c, int d, void *e, __u64 f, in= t ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + test6_entry_result =3D a =3D=3D 16 && b =3D=3D (void *)17 && c =3D=3D 18= && d =3D=3D 19 && + e =3D=3D (void *)20 && f =3D=3D 21 && ret =3D=3D 0; + return 1; + } + + test6_exit_result =3D 0; + return 0; +} + +__u64 test7_entry_result =3D 0; +__u64 test7_exit_result =3D 0; + +SEC("fsession/bpf_fentry_test7") +int BPF_PROG(test7, struct bpf_fentry_test_t *arg, int ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + if (!arg) + test7_entry_result =3D ret =3D=3D 0; + return 0; + } + + if (!arg) + test7_exit_result =3D 1; + return 0; +} + +__u64 test8_entry_result =3D 0; +__u64 test8_exit_result =3D 1; +/* + * test1, test8 and test9 hook the same target to verify the "ret" is alwa= ys + * 0 in the entry. + */ +SEC("fsession/bpf_fentry_test1") +int BPF_PROG(test8, int a, int ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + test8_entry_result =3D a =3D=3D 1 && ret =3D=3D 0; + return -21; + } + + /* This is exit */ + test8_exit_result =3D 0; + return 0; +} + +__u64 test9_entry_result =3D 0; +__u64 test9_exit_result =3D 1; + +SEC("fsession/bpf_fentry_test1") +int BPF_PROG(test9, int a, int ret) +{ + bool is_exit =3D bpf_tracing_is_exit(ctx); + + if (!is_exit) { + test9_entry_result =3D a =3D=3D 1 && ret =3D=3D 0; + return -22; + } + + test9_exit_result =3D 0; + return 0; +} + +__u64 test10_entry_result =3D 0; +__u64 test10_exit_result =3D 0; +SEC("fsession/bpf_fentry_test1") +int BPF_PROG(test10, int a) +{ + __u64 addr =3D bpf_get_func_ip(ctx); + + if (bpf_tracing_is_exit(ctx)) + test10_exit_result =3D (const void *) addr =3D=3D &bpf_fentry_test1; + else + test10_entry_result =3D (const void *) addr =3D=3D &bpf_fentry_test1; + return 0; +} + +__u64 test11_entry_ok =3D 0; +__u64 test11_exit_ok =3D 0; +SEC("fsession/bpf_fentry_test1") +int BPF_PROG(test11, int a) +{ + __u64 *cookie =3D bpf_fsession_cookie(ctx); + + if (!bpf_tracing_is_exit(ctx)) { + if (cookie) { + *cookie =3D 0xAAAABBBBCCCCDDDDull; + test11_entry_ok =3D *cookie =3D=3D 0xAAAABBBBCCCCDDDDull; + } + return 0; + } + + if (cookie) + test11_exit_ok =3D *cookie =3D=3D 0xAAAABBBBCCCCDDDDull; + return 0; +} + +__u64 test12_entry_ok =3D 0; +__u64 test12_exit_ok =3D 0; + +SEC("fsession/bpf_fentry_test1") +int BPF_PROG(test12, int a) +{ + __u64 *cookie =3D bpf_fsession_cookie(ctx); + + if (!bpf_tracing_is_exit(ctx)) { + if (cookie) { + *cookie =3D 0x1111222233334444ull; + test12_entry_ok =3D *cookie =3D=3D 0x1111222233334444ull; + } + return 0; + } + + if (cookie) + test12_exit_ok =3D *cookie =3D=3D 0x1111222233334444ull; + return 0; +} --=20 2.51.1 From nobody Sun Feb 8 05:23:09 2026 Received: from mail-pl1-f196.google.com (mail-pl1-f196.google.com [209.85.214.196]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 651C426C3B0 for ; Sun, 26 Oct 2025 03:02:30 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.214.196 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447752; cv=none; b=q/kfsCXiDVf2DICKymgEUAHpvaEsQ6W/eGnM7YjyE3b8h7dEtcViYBnIOSzAGKHWu8464fm412rvMaT/eikOxAjK+tWzUD43qXKTDI/ZuO1edONQjhk50wE80Q2W8TUYKp2qNqWB4jKnBggKzFxwFGsr0cqDOqzQIZyP0AZrNww= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761447752; c=relaxed/simple; bh=y3JrswmFFwfa3z/zDC2CDYfnI1obu4CnNdCVr+Dg7AQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=BaXwSBTBbIR6kp+P7wgsJKxpm/iRBdL0QBEgVR+8UwW+TivXzbL0mGw8nO8Gkhqb3wRfEc13IYX3XRVtnaLzVDE2WSz+6YV0D93to+4uKIANALsGLa90AgYG4imyPyYGMJ8279lfNE1BDODTR4hD/V/4lllcFcfJfPby0dU3NHw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=VnrYluF9; arc=none smtp.client-ip=209.85.214.196 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="VnrYluF9" Received: by mail-pl1-f196.google.com with SMTP id d9443c01a7336-290ac2ef203so31896195ad.1 for ; Sat, 25 Oct 2025 20:02:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1761447750; x=1762052550; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=juWHQU8czMasRBNz0412OczXZVru8Gf6xZfz5dotCp4=; b=VnrYluF9KDdtT2/JTAZ/9NsrtFZI7+ZBeSzr7O9Bzd4G7HgqIfbnm4ewUStaatE6v9 pTDZEYR3dJRT1DuW+WNwKANI3uB0v41AUt54Wuu7gqZcQphfJN27KtQJCnDAZZlzfWuw zw0qaSyXMKlOyWQsW+/DSdIzWkOZtr+O6HQTZ5hfQfELMejsQTVxiKxWGw/FZzK2frBw 5mFKBeZ3vS7lh+Iy8gr8Qygise84KrWaWasRIz0iQ+6DtJs5v4gkV8WagGb179x0sIck D/sf13EZB+G8YXsltdO9dvT8ABS6654yu3NPVe6ednTPN/mec5+6uOfUmzx2oBaYwb02 UV3Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1761447750; x=1762052550; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=juWHQU8czMasRBNz0412OczXZVru8Gf6xZfz5dotCp4=; b=h7eIXd1yyIonEoLxh7BWXZgCpFQJsnYQ32hjCGldM45a+q3N1iAA8RvDT7eXB52iEo N4/keDVDfsmAbWVn3Pq0PRrTyGeBK/tl566t+LDvjAH79U0L5WW6RvqLCJkmJaLDQmg+ qm4fd/I+yvtj9WvGyd98pHhGJEQ0c9cvPSD81wga/WUwb+F75hUud616XKd4CKKfJUtW C8IDJjuBk4VV46wzhqTb8p8s/K7/rOZPDwts+WER5fdBaXf5HpOxqvc+NVhVsNMOk6x/ Wi6FNL30axgaeCHTeSPw3DDJYauSbA2lwIjlsyCKvkGW0mQRVi2TV0N1NbMRyV+1QH+S 5BfA== X-Forwarded-Encrypted: i=1; AJvYcCWI54wVFK8F8EFYRpWGB5Yf7mOASyvzhkhgViIppXrK3wRXRVPB/qck+zZL+mTWHOhCkFGa6UNiLT4/ONo=@vger.kernel.org X-Gm-Message-State: AOJu0Yx6ZrC4lzBE1/2Bc0J5c51aOmS3cTZffGLIVFsezawxcvrf6CAq y2K/8cSUC+JC3a7gELIVtrmkHztbq8dkKmyhVdAuA8SCi/LWO2MtaQId X-Gm-Gg: ASbGncvW79CpQbwmrljCmSdWBjI266XqKxzdQfGIKr2cY2bK2imAoI9QOldXQs5bg4B gWEnouIxVbgFD8+e5iQkgapGQngAoy9kJ8Ddw0X2ACcoPiQgCb3fDChUlE7IhJ8rpP2MujJ7xQq WIEIU6lFpDNcARAxOjc/w8qh2Z5RLLLaOZXHfCerm3i7MElwdiWPGmUYapb233mO24nKJfG0blz KcFpe+MFgihEQguaDU4HcHYC8+dxXWCgkU04PevZwESwcwEkBzn5LWRgCYSpWVsbnuxloSITDrb nv8jftYbLx3qOwNlMVoQ0nulJ3D9rV1QwTQA/o8gpFnwswTZc76jknhAnacrX0SA0VgwJ7Yb+Un gYULRSUkte20/FfpPXa+q9REtmVUQtVUltAwXwE0D/pA0a4oEHXkE+qQWT7Tkw9jVUBJtjlbZbx /H1PcQ9eyz1Io= X-Google-Smtp-Source: AGHT+IGiKnFAn1QobwGb/3Ti6M3l+K7CtDol7CRzbD91xMh32PRYaXXOGaf2L+a0yHSp3kTqWIgWQw== X-Received: by 2002:a17:903:187:b0:24e:81d2:cfda with SMTP id d9443c01a7336-2948b81bbbfmr101272295ad.0.1761447749627; Sat, 25 Oct 2025 20:02:29 -0700 (PDT) Received: from 7950hx ([43.129.244.20]) by smtp.gmail.com with ESMTPSA id d9443c01a7336-29498d40b1esm38100645ad.73.2025.10.25.20.02.24 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 25 Oct 2025 20:02:29 -0700 (PDT) From: Menglong Dong X-Google-Original-From: Menglong Dong To: ast@kernel.org, jolsa@kernel.org Cc: daniel@iogearbox.net, john.fastabend@gmail.com, andrii@kernel.org, martin.lau@linux.dev, eddyz87@gmail.com, song@kernel.org, yonghong.song@linux.dev, kpsingh@kernel.org, sdf@fomichev.me, haoluo@google.com, mattbobrowski@google.com, rostedt@goodmis.org, mhiramat@kernel.org, leon.hwang@linux.dev, jiang.biao@linux.dev, bpf@vger.kernel.org, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCH bpf-next v3 7/7] selftests/bpf: test fsession mixed with fentry and fexit Date: Sun, 26 Oct 2025 11:01:43 +0800 Message-ID: <20251026030143.23807-8-dongml2@chinatelecom.cn> X-Mailer: git-send-email 2.51.1 In-Reply-To: <20251026030143.23807-1-dongml2@chinatelecom.cn> References: <20251026030143.23807-1-dongml2@chinatelecom.cn> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Test the fsession when it is used together with fentry, fexit. Signed-off-by: Menglong Dong --- .../selftests/bpf/progs/fsession_test.c | 34 +++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/tools/testing/selftests/bpf/progs/fsession_test.c b/tools/test= ing/selftests/bpf/progs/fsession_test.c index 8f266d8e4b55..f78348e541a4 100644 --- a/tools/testing/selftests/bpf/progs/fsession_test.c +++ b/tools/testing/selftests/bpf/progs/fsession_test.c @@ -228,3 +228,37 @@ int BPF_PROG(test12, int a) test12_exit_ok =3D *cookie =3D=3D 0x1111222233334444ull; return 0; } + +__u64 test13_entry_result =3D 0; +__u64 test13_exit_result =3D 0; + +SEC("fsession/bpf_fentry_test1") +int BPF_PROG(test13, int a, int ret) +{ + __u64 *cookie =3D bpf_fsession_cookie(ctx); + + if (!bpf_tracing_is_exit(ctx)) { + test13_entry_result =3D a =3D=3D 1 && ret =3D=3D 0; + *cookie =3D 0x123456ULL; + return 0; + } + + test13_exit_result =3D a =3D=3D 1 && ret =3D=3D 2 && *cookie =3D=3D 0x123= 456ULL; + return 0; +} + +__u64 test14_result =3D 0; +SEC("fexit/bpf_fentry_test1") +int BPF_PROG(test14, int a, int ret) +{ + test14_result =3D a =3D=3D 1 && ret =3D=3D 2; + return 0; +} + +__u64 test15_result =3D 0; +SEC("fentry/bpf_fentry_test1") +int BPF_PROG(test15, int a) +{ + test15_result =3D a =3D=3D 1; + return 0; +} --=20 2.51.1