From nobody Tue Nov 26 11:37:39 2024 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0CD82206962; Fri, 18 Oct 2024 20:41:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1729284115; cv=none; b=hlyJ4Fuht2Bjfu/bzrqNTPE4r25bNmUOJ0dwX+gkZNG1JRlFlF1Syy2io9q208Bj3OXJsJFpDcjII+UpTIwrJgpq1ZkGu7lI9swMCYIv1Y1Y/QRezYaArslLCoobpsODvrYtIHy/H5bdXDHAiXtY9JVeMcjIMVVuDHO3UyJ+gqk= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1729284115; c=relaxed/simple; bh=loAUBML9cd5SCu/fBjpNadgXnQfN1v031ENvKILIlB8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=F05Tc69dUqJ/uUuGnNL4NS4tjQwSat5Pfk+YrXuWfRHRyKm256wBzA62jQyeA7DTYR1+tvtVl4D4IR442exDYA8rU0niRGEa0g03BReh/naSM0NS6Iuh3f5WPcRo71CUCb2ocFHB8tDsIzVl+vhHbEWv7RSC7SuL0cuV9LjBuoI= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=i20b9iSC; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="i20b9iSC" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 58D15C4CEC3; Fri, 18 Oct 2024 20:41:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1729284114; bh=loAUBML9cd5SCu/fBjpNadgXnQfN1v031ENvKILIlB8=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=i20b9iSCwlcNoqwjQoCgMUQcgX/eBtHCyYJtpA0uS5ZOnzMx2EnCxomFhlDaEhkmP kEOTLMeKG2fO7kUJ+80N6Kvzk0CQ/NFf6YVz4t2blvAlBIZURVMyIhUsX3/aOX4+kW jCFzFm2lSSgWz45c8jjyF8Gz30yba/+2mxqxgHTSJUQbvEhh1hvmGHGY7Z1+Yudw5B 0Vu+2la9YnAYxsvVgy9M5FygbH/xAbIm7NaqpkpnkGiw0iaUUPYWo1W88uo0C59W1b 9nh0fyPxRWr6mmKwVsFeDt1hLK4i3JMcJA+J6EIjroIGT+gNiLFiy+f+eswwjiErfG GR+yBLUJZ0SSQ== From: Jiri Olsa To: Oleg Nesterov , Peter Zijlstra , Alexei Starovoitov , Daniel Borkmann , Andrii Nakryiko Cc: bpf@vger.kernel.org, Martin KaFai Lau , Song Liu , Yonghong Song , John Fastabend , KP Singh , Stanislav Fomichev , Hao Luo , Steven Rostedt , Masami Hiramatsu , linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org Subject: [PATCHv8 bpf-next 03/13] bpf: Add support for uprobe multi session attach Date: Fri, 18 Oct 2024 22:40:59 +0200 Message-ID: <20241018204109.713820-4-jolsa@kernel.org> X-Mailer: git-send-email 2.46.2 In-Reply-To: <20241018204109.713820-1-jolsa@kernel.org> References: <20241018204109.713820-1-jolsa@kernel.org> 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" Adding support to attach BPF program for entry and return probe of the same function. This is common use case which at the moment requires to create two uprobe multi links. Adding new BPF_TRACE_UPROBE_SESSION attach type that instructs kernel to attach single link program to both entry and exit probe. It's possible to control execution of the BPF program on return probe simply by returning zero or non zero from the entry BPF program execution to execute or not the BPF program on return probe respectively. Acked-by: Andrii Nakryiko Signed-off-by: Jiri Olsa --- include/uapi/linux/bpf.h | 1 + kernel/bpf/syscall.c | 9 +++++++-- kernel/bpf/verifier.c | 1 + kernel/trace/bpf_trace.c | 36 +++++++++++++++++++++++++--------- tools/include/uapi/linux/bpf.h | 1 + tools/lib/bpf/libbpf.c | 1 + 6 files changed, 38 insertions(+), 11 deletions(-) diff --git a/include/uapi/linux/bpf.h b/include/uapi/linux/bpf.h index 627c4195f04f..9b1ae0ccd427 100644 --- a/include/uapi/linux/bpf.h +++ b/include/uapi/linux/bpf.h @@ -1116,6 +1116,7 @@ enum bpf_attach_type { BPF_NETKIT_PRIMARY, BPF_NETKIT_PEER, BPF_TRACE_KPROBE_SESSION, + BPF_TRACE_UPROBE_SESSION, __MAX_BPF_ATTACH_TYPE }; =20 diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c index 4d04d4d9c1f3..a4bbdb924093 100644 --- a/kernel/bpf/syscall.c +++ b/kernel/bpf/syscall.c @@ -3984,10 +3984,14 @@ static int bpf_prog_attach_check_attach_type(const = struct bpf_prog *prog, if (prog->expected_attach_type =3D=3D BPF_TRACE_UPROBE_MULTI && attach_type !=3D BPF_TRACE_UPROBE_MULTI) return -EINVAL; + if (prog->expected_attach_type =3D=3D BPF_TRACE_UPROBE_SESSION && + attach_type !=3D BPF_TRACE_UPROBE_SESSION) + return -EINVAL; if (attach_type !=3D BPF_PERF_EVENT && attach_type !=3D BPF_TRACE_KPROBE_MULTI && attach_type !=3D BPF_TRACE_KPROBE_SESSION && - attach_type !=3D BPF_TRACE_UPROBE_MULTI) + attach_type !=3D BPF_TRACE_UPROBE_MULTI && + attach_type !=3D BPF_TRACE_UPROBE_SESSION) return -EINVAL; return 0; case BPF_PROG_TYPE_SCHED_CLS: @@ -5240,7 +5244,8 @@ static int link_create(union bpf_attr *attr, bpfptr_t= uattr) else if (attr->link_create.attach_type =3D=3D BPF_TRACE_KPROBE_MULTI || attr->link_create.attach_type =3D=3D BPF_TRACE_KPROBE_SESSION) ret =3D bpf_kprobe_multi_link_attach(attr, prog); - else if (attr->link_create.attach_type =3D=3D BPF_TRACE_UPROBE_MULTI) + else if (attr->link_create.attach_type =3D=3D BPF_TRACE_UPROBE_MULTI || + attr->link_create.attach_type =3D=3D BPF_TRACE_UPROBE_SESSION) ret =3D bpf_uprobe_multi_link_attach(attr, prog); break; default: diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c index 5c941fd1b141..89bf0a58edbd 100644 --- a/kernel/bpf/verifier.c +++ b/kernel/bpf/verifier.c @@ -15918,6 +15918,7 @@ static int check_return_code(struct bpf_verifier_en= v *env, int regno, const char case BPF_PROG_TYPE_KPROBE: switch (env->prog->expected_attach_type) { case BPF_TRACE_KPROBE_SESSION: + case BPF_TRACE_UPROBE_SESSION: range =3D retval_range(0, 1); break; default: diff --git a/kernel/trace/bpf_trace.c b/kernel/trace/bpf_trace.c index 3c1e5a561df4..5f10994376d0 100644 --- a/kernel/trace/bpf_trace.c +++ b/kernel/trace/bpf_trace.c @@ -1557,6 +1557,17 @@ static inline bool is_kprobe_session(const struct bp= f_prog *prog) return prog->expected_attach_type =3D=3D BPF_TRACE_KPROBE_SESSION; } =20 +static inline bool is_uprobe_multi(const struct bpf_prog *prog) +{ + return prog->expected_attach_type =3D=3D BPF_TRACE_UPROBE_MULTI || + prog->expected_attach_type =3D=3D BPF_TRACE_UPROBE_SESSION; +} + +static inline bool is_uprobe_session(const struct bpf_prog *prog) +{ + return prog->expected_attach_type =3D=3D BPF_TRACE_UPROBE_SESSION; +} + static const struct bpf_func_proto * kprobe_prog_func_proto(enum bpf_func_id func_id, const struct bpf_prog *pr= og) { @@ -1574,13 +1585,13 @@ kprobe_prog_func_proto(enum bpf_func_id func_id, co= nst struct bpf_prog *prog) case BPF_FUNC_get_func_ip: if (is_kprobe_multi(prog)) return &bpf_get_func_ip_proto_kprobe_multi; - if (prog->expected_attach_type =3D=3D BPF_TRACE_UPROBE_MULTI) + if (is_uprobe_multi(prog)) return &bpf_get_func_ip_proto_uprobe_multi; return &bpf_get_func_ip_proto_kprobe; case BPF_FUNC_get_attach_cookie: if (is_kprobe_multi(prog)) return &bpf_get_attach_cookie_proto_kmulti; - if (prog->expected_attach_type =3D=3D BPF_TRACE_UPROBE_MULTI) + if (is_uprobe_multi(prog)) return &bpf_get_attach_cookie_proto_umulti; return &bpf_get_attach_cookie_proto_trace; default: @@ -3074,6 +3085,7 @@ struct bpf_uprobe { u64 cookie; struct uprobe *uprobe; struct uprobe_consumer consumer; + bool session; }; =20 struct bpf_uprobe_multi_link { @@ -3247,9 +3259,13 @@ uprobe_multi_link_handler(struct uprobe_consumer *co= n, struct pt_regs *regs, __u64 *data) { struct bpf_uprobe *uprobe; + int ret; =20 uprobe =3D container_of(con, struct bpf_uprobe, consumer); - return uprobe_prog_run(uprobe, instruction_pointer(regs), regs); + ret =3D uprobe_prog_run(uprobe, instruction_pointer(regs), regs); + if (uprobe->session) + return ret ? UPROBE_HANDLER_IGNORE : 0; + return 0; } =20 static int @@ -3259,7 +3275,8 @@ uprobe_multi_link_ret_handler(struct uprobe_consumer = *con, unsigned long func, s struct bpf_uprobe *uprobe; =20 uprobe =3D container_of(con, struct bpf_uprobe, consumer); - return uprobe_prog_run(uprobe, func, regs); + uprobe_prog_run(uprobe, func, regs); + return 0; } =20 static u64 bpf_uprobe_multi_entry_ip(struct bpf_run_ctx *ctx) @@ -3298,7 +3315,7 @@ int bpf_uprobe_multi_link_attach(const union bpf_attr= *attr, struct bpf_prog *pr if (sizeof(u64) !=3D sizeof(void *)) return -EOPNOTSUPP; =20 - if (prog->expected_attach_type !=3D BPF_TRACE_UPROBE_MULTI) + if (!is_uprobe_multi(prog)) return -EINVAL; =20 flags =3D attr->link_create.uprobe_multi.flags; @@ -3374,11 +3391,12 @@ int bpf_uprobe_multi_link_attach(const union bpf_at= tr *attr, struct bpf_prog *pr =20 uprobes[i].link =3D link; =20 - if (flags & BPF_F_UPROBE_MULTI_RETURN) - uprobes[i].consumer.ret_handler =3D uprobe_multi_link_ret_handler; - else + if (!(flags & BPF_F_UPROBE_MULTI_RETURN)) uprobes[i].consumer.handler =3D uprobe_multi_link_handler; - + if (flags & BPF_F_UPROBE_MULTI_RETURN || is_uprobe_session(prog)) + uprobes[i].consumer.ret_handler =3D uprobe_multi_link_ret_handler; + if (is_uprobe_session(prog)) + uprobes[i].session =3D true; if (pid) uprobes[i].consumer.filter =3D uprobe_multi_link_filter; } diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h index 0e49ce2981a0..cbbcd206f221 100644 --- a/tools/include/uapi/linux/bpf.h +++ b/tools/include/uapi/linux/bpf.h @@ -1116,6 +1116,7 @@ enum bpf_attach_type { BPF_NETKIT_PRIMARY, BPF_NETKIT_PEER, BPF_TRACE_KPROBE_SESSION, + BPF_TRACE_UPROBE_SESSION, __MAX_BPF_ATTACH_TYPE }; =20 diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c index 7c40286c3948..e650809e7170 100644 --- a/tools/lib/bpf/libbpf.c +++ b/tools/lib/bpf/libbpf.c @@ -133,6 +133,7 @@ static const char * const attach_type_name[] =3D { [BPF_NETKIT_PRIMARY] =3D "netkit_primary", [BPF_NETKIT_PEER] =3D "netkit_peer", [BPF_TRACE_KPROBE_SESSION] =3D "trace_kprobe_session", + [BPF_TRACE_UPROBE_SESSION] =3D "trace_uprobe_session", }; =20 static const char * const link_type_name[] =3D { --=20 2.46.2