Skip to contentSkip to conversation

Trusted PTR_TO_BTF_ID arg support in global subprogs

PATCH Superseded Andrii Nakryiko 4 participants 14 messages Jan 25, 2024 – Jan 29, 2024

Subsystems (5)
Kselftest BPF BPF selftests BPF core +1 more subsystems

v2 of 3 Superseded 3 of 7 applied Latest is v3 →

lore
Share & tools
lore

Andrii Nakryiko

author maintainer
#0 lore raw

v2 cover Trusted PTR_TO_BTF_ID arg support in global subprogs

This patch set follows recent changes that added btf_decl_tag-based argument annotation support for global subprogs. This time we add ability to pass PTR_TO_BTF_ID (BTF-aware kernel pointers) arguments into global subprograms. We support explicitly trusted arguments only, for now.

First three patches are preparatory. Patches #1 and #3 does post-BPF token code adjustments, to undo merge conflict avoidance measures. Patch #2 makes PERF_EVENT type enforcement logic aligned with kernel-side logic.

Patch #4 adds logic for arg:trusted tag support on the verifier side. Default semantic of such arguments is non-NULL, enforced on caller side. But patch #5 adds arg:maybe_null tag that can be combined with arg:trusted to make callee explicitly do the NULL check, which helps implement "optional" PTR_TO_BTF_ID arguments.

Patch #6 adds libbpf-side __arg_trusted and __arg_maybe_null macros. Patch #7 adds a bunch of tests validating __arg_trusted in combination with __arg_maybe_null.

v1->v2:
- added fix up to type enforcement changes, landed earlier;
- dropped bpf_core_cast() changes, will post them separately, as they now

    are not used in added tests;

- dropped arg:untrusted support (Alexei);
- renamed arg:nullable to arg:maybe_null (Alexei);
- and also added task_struct___local flavor tests (Alexei).

Andrii Nakryiko (7):
libbpf: integrate __arg_ctx feature detector into kernel_supports()
libbpf: fix __arg_ctx type enforcement for perf_event programs
bpf: move arg:ctx type enforcement check inside the main logic loop
bpf: add __arg_trusted global func arg tag
bpf: add arg:maybe_null tag to be combined with trusted pointers
libbpf: add __arg_trusted and __arg_maybe_null tag macros selftests/bpf: add trusted global subprog arg tests

 include/linux/bpf_verifier.h                  |   1 +
 kernel/bpf/btf.c                              | 130 +++++++++++----
 kernel/bpf/verifier.c                         |  24 +++
 tools/lib/bpf/bpf_helpers.h                   |   2 +
 tools/lib/bpf/features.c                      |  58 +++++++
 tools/lib/bpf/libbpf.c                        |  86 +++-------
 tools/lib/bpf/libbpf_internal.h               |   2 +
 .../selftests/bpf/prog_tests/verifier.c       |   2 +
 .../bpf/progs/verifier_global_ptr_args.c      | 156 ++++++++++++++++++
 9 files changed, 366 insertions(+), 95 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/progs/verifier_global_ptr_args.c
Signature · 1 line
2.34.1
author maintainer
#1 lore raw

PATCH v2 1/7 libbpf: integrate __arg_ctx feature detector into kernel_supports()

Now that feature detection code is in bpf-next tree, integrate __arg_ctx kernel-side support into kernel_supports() framework.

---
 tools/lib/bpf/features.c        | 58 +++++++++++++++++++++++++++++
 tools/lib/bpf/libbpf.c          | 65 +--------------------------------
 tools/lib/bpf/libbpf_internal.h |  2 +
 3 files changed, 61 insertions(+), 64 deletions(-)
tools/lib/bpf/features.c +58 -0
index 5a5c766bf615..6b0738ad7063 100644
@@ -407,6 +407,61 @@ static int probe_kern_btf_enum64(int token_fd)
 					     strs, sizeof(strs), token_fd));
 }
 
+static int probe_kern_arg_ctx_tag(int token_fd)
+{
+	static const char strs[] = "\0a\0b\0arg:ctx\0";
+	const __u32 types[] = {
+		/* [1] INT */
+		BTF_TYPE_INT_ENC(1 /* "a" */, BTF_INT_SIGNED, 0, 32, 4),
+		/* [2] PTR -> VOID */
+		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
+		/* [3] FUNC_PROTO `int(void *a)` */
+		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 1),
+		BTF_PARAM_ENC(1 /* "a" */, 2),
+		/* [4] FUNC 'a' -> FUNC_PROTO (main prog) */
+		BTF_TYPE_ENC(1 /* "a" */, BTF_INFO_ENC(BTF_KIND_FUNC, 0, BTF_FUNC_GLOBAL), 3),
+		/* [5] FUNC_PROTO `int(void *b __arg_ctx)` */
+		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 1),
+		BTF_PARAM_ENC(3 /* "b" */, 2),
+		/* [6] FUNC 'b' -> FUNC_PROTO (subprog) */
+		BTF_TYPE_ENC(3 /* "b" */, BTF_INFO_ENC(BTF_KIND_FUNC, 0, BTF_FUNC_GLOBAL), 5),
+		/* [7] DECL_TAG 'arg:ctx' -> func 'b' arg 'b' */
+		BTF_TYPE_DECL_TAG_ENC(5 /* "arg:ctx" */, 6, 0),
+	};
+	const struct bpf_insn insns[] = {
+		/* main prog */
+		BPF_CALL_REL(+1),
+		BPF_EXIT_INSN(),
+		/* global subprog */
+		BPF_EMIT_CALL(BPF_FUNC_get_func_ip), /* needs PTR_TO_CTX */
+		BPF_EXIT_INSN(),
+	};
+	const struct bpf_func_info_min func_infos[] = {
+		{ 0, 4 }, /* main prog -> FUNC 'a' */
+		{ 2, 6 }, /* subprog -> FUNC 'b' */
+	};
+	LIBBPF_OPTS(bpf_prog_load_opts, opts,
+		.token_fd = token_fd,
+		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
+	);
+	int prog_fd, btf_fd, insn_cnt = ARRAY_SIZE(insns);
+
+	btf_fd = libbpf__load_raw_btf((char *)types, sizeof(types), strs, sizeof(strs), token_fd);
+	if (btf_fd < 0)
+		return 0;
+
+	opts.prog_btf_fd = btf_fd;
+	opts.func_info = &func_infos;
+	opts.func_info_cnt = ARRAY_SIZE(func_infos);
+	opts.func_info_rec_size = sizeof(func_infos[0]);
+
+	prog_fd = bpf_prog_load(BPF_PROG_TYPE_KPROBE, "det_arg_ctx",
+				"GPL", insns, insn_cnt, &opts);
+	close(btf_fd);
+
+	return probe_fd(prog_fd);
+}
+
 typedef int (*feature_probe_fn)(int /* token_fd */);
 
 static struct kern_feature_cache feature_cache;
@@ -476,6 +531,9 @@ static struct kern_feature_desc {
 	[FEAT_UPROBE_MULTI_LINK] = {
 		"BPF multi-uprobe link support", probe_uprobe_multi_link,
 	},
+	[FEAT_ARG_CTX_TAG] = {
+		"kernel-side __arg_ctx tag", probe_kern_arg_ctx_tag,
+	},
 };
 
 bool feat_supported(struct kern_feature_cache *cache, enum kern_feature_id feat_id)
tools/lib/bpf/libbpf.c +1 -64

77 lines not on this page · raw message

tools/lib/bpf/libbpf_internal.h +2 -0
index 930cc9616527..757dde832d8c 100644
@@ -358,6 +358,8 @@ enum kern_feature_id {
 	FEAT_SYSCALL_WRAPPER,
 	/* BPF multi-uprobe link support */
 	FEAT_UPROBE_MULTI_LINK,
+	/* Kernel supports arg:ctx tag (__arg_ctx) for global subprogs natively */
+	FEAT_ARG_CTX_TAG,
 	__FEAT_CNT,
 };
 
Signature · 1 line
2.34.1
author maintainer
#2 lore raw

PATCH v2 2/7 libbpf: fix __arg_ctx type enforcement for perf_event programs

In reply to Andrii Nakryiko

Adjust PERF_EVENT type enforcement around __arg_ctx to match exactly what kernel is doing.

Fixes 76ec90a996e3 ("libbpf: warn on unexpected __arg_ctx type when rewriting BTF")
---
 tools/lib/bpf/libbpf.c | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)
tools/lib/bpf/libbpf.c +20 -1
index 41ab7a21f868..db65ea59a05a 100644
@@ -33,6 +33,7 @@
 #include <linux/filter.h>
 #include <linux/limits.h>
 #include <linux/perf_event.h>
+#include <linux/bpf_perf_event.h>
 #include <linux/ring_buffer.h>
 #include <sys/epoll.h>
 #include <sys/ioctl.h>
@@ -6339,6 +6340,14 @@ static struct {
 	/* all other program types don't have "named" context structs */
 };
 
+/* forward declarations for arch-specific underlying types of bpf_user_pt_regs_t typedef,
+ * for below __builtin_types_compatible_p() checks;
+ * with this approach we don't need any extra arch-specific #ifdef guards
+ */
+struct pt_regs;
+struct user_pt_regs;
+struct user_regs_struct;
+
 static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_program *prog,
 				     const char *subprog_name, int arg_idx,
 				     int arg_type_id, const char *ctx_name)
@@ -6379,11 +6388,21 @@ static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro
 	/* special cases */
 	switch (prog->type) {
 	case BPF_PROG_TYPE_KPROBE:
-	case BPF_PROG_TYPE_PERF_EVENT:
 		/* `struct pt_regs *` is expected, but we need to fix up */
 		if (btf_is_struct(t) && strcmp(tname, "pt_regs") == 0)
 			return true;
 		break;
+	case BPF_PROG_TYPE_PERF_EVENT:
+		if (__builtin_types_compatible_p(bpf_user_pt_regs_t, struct pt_regs) &&
+		    btf_is_struct(t) && strcmp(tname, "pt_regs") == 0)
+			return 0;
+		if (__builtin_types_compatible_p(bpf_user_pt_regs_t, struct user_pt_regs) &&
+		    btf_is_struct(t) && strcmp(tname, "user_pt_regs") == 0)
+			return 0;
+		if (__builtin_types_compatible_p(bpf_user_pt_regs_t, struct user_regs_struct) &&
+		    btf_is_struct(t) && strcmp(tname, "user_regs_struct") == 0)
+			return 0;
+		break;
 	case BPF_PROG_TYPE_RAW_TRACEPOINT:
 	case BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE:
 		/* allow u64* as ctx */
Signature · 1 line
2.34.1
maintainer
#3 lore raw

Re: [PATCH v2 bpf-next 2/7] libbpf: fix __arg_ctx type enforcement for perf_event programs

On Thu, 2024-01-25 at 12:55 -0800, Andrii Nakryiko wrote:
[...]

tools/lib/bpf/libbpf.c static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro · line 6394

Quoted 9 lines
tools/lib/bpf/libbpf.c +0 -1
@@ -6379,11 +6388,21 @@ static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro
 	/* special cases */
 	switch (prog->type) {
 	case BPF_PROG_TYPE_KPROBE:
-	case BPF_PROG_TYPE_PERF_EVENT:
 		/* `struct pt_regs *` is expected, but we need to fix up */
 		if (btf_is_struct(t) && strcmp(tname, "pt_regs") == 0)
 			return true;
 		break;

Sorry, this was probably discussed, but I got lost a bit. Kernel side does not change pt_regs for BPF_PROG_TYPE_KPROBE (in ./kernel/bpf/btf.c:btf_validate_prog_ctx_type) but here we do, why do it differently?

[...]

#4 lore raw

Re: [PATCH v2 bpf-next 2/7] libbpf: fix __arg_ctx type enforcement for perf_event programs

Quoted 4 lines · Eduard Zingerman

On Thu, 2024-01-25 at 12:55 -0800, Andrii Nakryiko wrote:
[...]

Quoted 15 lines

tools/lib/bpf/libbpf.c static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro · line 6394

Quoted 9 lines
tools/lib/bpf/libbpf.c +0 -1
@@ -6379,11 +6388,21 @@ static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro
      /* special cases */
      switch (prog->type) {
      case BPF_PROG_TYPE_KPROBE:
-     case BPF_PROG_TYPE_PERF_EVENT:
              /* `struct pt_regs *` is expected, but we need to fix up */
              if (btf_is_struct(t) && strcmp(tname, "pt_regs") == 0)
                      return true;
              break;

Sorry, this was probably discussed, but I got lost a bit. Kernel side does not change pt_regs for BPF_PROG_TYPE_KPROBE (in ./kernel/bpf/btf.c:btf_validate_prog_ctx_type) but here we do, why do it differently?

Hm... We do the same. After this patch w end up with this logic on libbpf side (which matches kernel-side one, I believe):

for KPROBE => allow pt_regs (unconditionally)
for PERF_EVENT => allow user_regs_struct|user_pt_regs|pt_regs, depending on bpf_user_pt_regs_t definition on host platform

That should match what the kernel is doing.

Quoted 1 line

[...]

maintainer
#5 lore raw

Re: [PATCH v2 bpf-next 2/7] libbpf: fix __arg_ctx type enforcement for perf_event programs

Quoted 21 lines · Andrii Nakryiko
Quoted 4 lines · Eduard Zingerman

On Thu, 2024-01-25 at 12:55 -0800, Andrii Nakryiko wrote:
[...]

Quoted 15 lines

tools/lib/bpf/libbpf.c static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro · line 6394

Quoted 9 lines
tools/lib/bpf/libbpf.c +0 -1
@@ -6379,11 +6388,21 @@ static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro
      /* special cases */
      switch (prog->type) {
      case BPF_PROG_TYPE_KPROBE:
-     case BPF_PROG_TYPE_PERF_EVENT:
              /* `struct pt_regs *` is expected, but we need to fix up */
              if (btf_is_struct(t) && strcmp(tname, "pt_regs") == 0)
                      return true;
              break;

Sorry, this was probably discussed, but I got lost a bit. Kernel side does not change pt_regs for BPF_PROG_TYPE_KPROBE (in ./kernel/bpf/btf.c:btf_validate_prog_ctx_type) but here we do, why do it differently?

Quoted 8 lines

Hm... We do the same. After this patch w end up with this logic on libbpf side (which matches kernel-side one, I believe):

for KPROBE => allow pt_regs (unconditionally)
for PERF_EVENT => allow user_regs_struct|user_pt_regs|pt_regs, depending on bpf_user_pt_regs_t definition on host platform

That should match what the kernel is doing.

Oh..., I see:
After (and before) this patch on libbpf side for KPROBE/pt_regs need_func_arg_type_fixup() would return true,
thus bpf_program_fixup_func_info() would apply type transformation (convert it to bpf_user_pt_regs_t).
And kernel before the arg:ctx series expected bpf_user_pt_regs_t for global subprograms called from KPROBE programs, hence old kernel would accept program with KPROBE/pt_regs thanks to libbpf manipulations.

I was put off by need_func_arg_type_fixup() returning true, thus requiring change, and btf_validate_prog_ctx_type() just accepting pt_regs => not doing anything.

Thank you for explaining.

#6 lore raw

Re: [PATCH v2 bpf-next 2/7] libbpf: fix __arg_ctx type enforcement for perf_event programs

Quoted 32 lines · Eduard Zingerman
Quoted 21 lines · Andrii Nakryiko
Quoted 4 lines · Eduard Zingerman

On Thu, 2024-01-25 at 12:55 -0800, Andrii Nakryiko wrote:
[...]

Quoted 15 lines

tools/lib/bpf/libbpf.c static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro · line 6394

Quoted 9 lines
tools/lib/bpf/libbpf.c +0 -1
@@ -6379,11 +6388,21 @@ static bool need_func_arg_type_fixup(const struct btf *btf, const struct bpf_pro
      /* special cases */
      switch (prog->type) {
      case BPF_PROG_TYPE_KPROBE:
-     case BPF_PROG_TYPE_PERF_EVENT:
              /* `struct pt_regs *` is expected, but we need to fix up */
              if (btf_is_struct(t) && strcmp(tname, "pt_regs") == 0)
                      return true;
              break;

Sorry, this was probably discussed, but I got lost a bit. Kernel side does not change pt_regs for BPF_PROG_TYPE_KPROBE (in ./kernel/bpf/btf.c:btf_validate_prog_ctx_type) but here we do, why do it differently?

Quoted 8 lines

Hm... We do the same. After this patch w end up with this logic on libbpf side (which matches kernel-side one, I believe):

for KPROBE => allow pt_regs (unconditionally)
for PERF_EVENT => allow user_regs_struct|user_pt_regs|pt_regs, depending on bpf_user_pt_regs_t definition on host platform

That should match what the kernel is doing.

Quoted 9 lines

Oh..., I see:
After (and before) this patch on libbpf side for KPROBE/pt_regs need_func_arg_type_fixup() would return true,
thus bpf_program_fixup_func_info() would apply type transformation (convert it to bpf_user_pt_regs_t).
And kernel before the arg:ctx series expected bpf_user_pt_regs_t for global subprograms called from KPROBE programs, hence old kernel would accept program with KPROBE/pt_regs thanks to libbpf manipulations.

Yep, with libbpf it's always a "time travel" kind of thinking, taking into account old kernels.

Quoted 6 lines

I was put off by need_func_arg_type_fixup() returning true, thus requiring change, and btf_validate_prog_ctx_type() just accepting pt_regs => not doing anything.

Thank you for explaining.

Well... I didn't explain all the above, you pieced it all together yourself ;)

author maintainer
#7 lore raw

PATCH v2 3/7 bpf: move arg:ctx type enforcement check inside the main logic loop

In reply to Andrii Nakryiko

Now that bpf and bpf-next trees converged and we don't run the risk of merge conflicts, move btf_validate_prog_ctx_type() into its most logical place inside the main logic loop.

---
 kernel/bpf/btf.c | 21 ++++-----------------
 1 file changed, 4 insertions(+), 17 deletions(-)
kernel/bpf/btf.c +4 -17
index edef96ceffa3..9ec08cfb2967 100644
@@ -7112,6 +7112,10 @@ int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog)
 				bpf_log(log, "arg#%d has invalid combination of tags\n", i);
 				return -EINVAL;
 			}
+			if ((tags & ARG_TAG_CTX) &&
+			    btf_validate_prog_ctx_type(log, btf, t, i, prog_type,
+						       prog->expected_attach_type))
+				return -EINVAL;
 			sub->args[i].arg_type = ARG_PTR_TO_CTX;
 			continue;
 		}
@@ -7156,23 +7160,6 @@ int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog)
 		return -EINVAL;
 	}
 
-	for (i = 0; i < nargs; i++) {
-		const char *tag;
-
-		if (sub->args[i].arg_type != ARG_PTR_TO_CTX)
-			continue;
-
-		/* check if arg has "arg:ctx" tag */
-		t = btf_type_by_id(btf, args[i].type);
-		tag = btf_find_decl_tag_value(btf, fn_t, i, "arg:");
-		if (IS_ERR_OR_NULL(tag) || strcmp(tag, "ctx") != 0)
-			continue;
-
-		if (btf_validate_prog_ctx_type(log, btf, t, i, prog_type,
-					       prog->expected_attach_type))
-			return -EINVAL;
-	}
-
 	sub->arg_cnt = nargs;
 	sub->args_cached = true;
 
Signature · 1 line
2.34.1
author maintainer
#8 lore raw

PATCH v2 4/7 bpf: add __arg_trusted global func arg tag

In reply to Andrii Nakryiko

Add support for passing PTR_TO_BTF_ID registers to global subprogs. Currently only PTR_TRUSTED flavor of PTR_TO_BTF_ID is supported. Non-NULL semantics is assumed, so caller will be forced to prove PTR_TO_BTF_ID can't be NULL.

Note, we disallow global subprogs to destroy passed in PTR_TO_BTF_ID arguments, even the trusted one. We achieve that by not setting ref_obj_id when validating subprog code. This basically enforces (in Rust terms) borrowing semantics vs move semantics. Borrowing semantics seems to be a better fit for isolated global subprog validation approach.

Implementation-wise, we utilize existing logic for matching user-provided BTF type to kernel-side BTF type, used by BPF CO-RE logic and following same matching rules. We enforce a unique match for types.

---
 include/linux/bpf_verifier.h |  1 +
 kernel/bpf/btf.c             | 99 +++++++++++++++++++++++++++++++-----
 kernel/bpf/verifier.c        | 24 +++++++++
 3 files changed, 111 insertions(+), 13 deletions(-)
include/linux/bpf_verifier.h +1 -0
index 7f5816482a10..0dcde339dc7e 100644
@@ -610,6 +610,7 @@ struct bpf_subprog_arg_info {
 	enum bpf_arg_type arg_type;
 	union {
 		u32 mem_size;
+		u32 btf_id;
 	};
 };
 
kernel/bpf/btf.c +86 -13

132 lines not on this page · raw message

kernel/bpf/verifier.c +24 -0
index fe833e831cb6..4879dee8d725 100644
@@ -9336,6 +9336,18 @@ static int btf_check_func_arg_match(struct bpf_verifier_env *env, int subprog,
 			ret = process_dynptr_func(env, regno, -1, arg->arg_type, 0);
 			if (ret)
 				return ret;
+		} else if (base_type(arg->arg_type) == ARG_PTR_TO_BTF_ID) {
+			struct bpf_call_arg_meta meta;
+			int err;
+
+			if (register_is_null(reg) && type_may_be_null(arg->arg_type))
+				continue;
+
+			memset(&meta, 0, sizeof(meta)); /* leave func_id as zero */
+			err = check_reg_type(env, regno, arg->arg_type, &arg->btf_id, &meta);
+			err = err ?: check_func_arg_reg_off(env, reg, regno, arg->arg_type);
+			if (err)
+				return err;
 		} else {
 			bpf_log(log, "verifier bug: unrecognized arg#%d type %d\n",
 				i, arg->arg_type);
@@ -20137,6 +20149,18 @@ static int do_check_common(struct bpf_verifier_env *env, int subprog)
 				mark_reg_known_zero(env, regs, i);
 				reg->mem_size = arg->mem_size;
 				reg->id = ++env->id_gen;
+			} else if (base_type(arg->arg_type) == ARG_PTR_TO_BTF_ID) {
+				reg->type = PTR_TO_BTF_ID;
+				if (arg->arg_type & PTR_MAYBE_NULL)
+					reg->type |= PTR_MAYBE_NULL;
+				if (arg->arg_type & PTR_UNTRUSTED)
+					reg->type |= PTR_UNTRUSTED;
+				if (arg->arg_type & PTR_TRUSTED)
+					reg->type |= PTR_TRUSTED;
+				mark_reg_known_zero(env, regs, i);
+				reg->btf = bpf_get_btf_vmlinux(); /* can't fail at this point */
+				reg->btf_id = arg->btf_id;
+				reg->id = ++env->id_gen;
 			} else {
 				WARN_ONCE(1, "BUG: unhandled arg#%d type %d\n",
 					  i - BPF_REG_1, arg->arg_type);
Signature · 1 line
2.34.1
author maintainer
#9 lore raw

PATCH v2 5/7 bpf: add arg:maybe_null tag to be combined with trusted pointers

In reply to Andrii Nakryiko

Add ability to mark arg:trusted arguments with optional arg:maybe_null tag to mark is as PTR_TO_BTF_ID_OR_NULL variant, which will allow callers to pass NULL, and subsequently will force global subprog's code to do NULL check. This allows to have "optional" PTR_TO_BTF_ID values passed into global subprogs.

For now arg:maybe_null cannot be combined with anything else.

---
 kernel/bpf/btf.c | 10 ++++++++++
 1 file changed, 10 insertions(+)
kernel/bpf/btf.c +10 -0
index ed7a05815984..270804ece93c 100644
@@ -7056,6 +7056,7 @@ enum btf_arg_tag {
 	ARG_TAG_CTX = 0x1,
 	ARG_TAG_NONNULL = 0x2,
 	ARG_TAG_TRUSTED = 0x4,
+	ARG_TAG_MAYBE_NULL = 0x8,
 };
 
 /* Process BTF of a function to produce high-level expectation of function
@@ -7161,6 +7162,8 @@ int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog)
 				tags |= ARG_TAG_TRUSTED;
 			} else if (strcmp(tag, "nonnull") == 0) {
 				tags |= ARG_TAG_NONNULL;
+			} else if (strcmp(tag, "maybe_null") == 0) {
+				tags |= ARG_TAG_MAYBE_NULL;
 			} else {
 				bpf_log(log, "arg#%d has unsupported set of tags\n", i);
 				return -EOPNOTSUPP;
@@ -7210,12 +7213,19 @@ int btf_prepare_func_args(struct bpf_verifier_env *env, int subprog)
 				return kern_type_id;
 
 			sub->args[i].arg_type = ARG_PTR_TO_BTF_ID | PTR_TRUSTED;
+			if (tags & ARG_TAG_MAYBE_NULL)
+				sub->args[i].arg_type |= PTR_MAYBE_NULL;
 			sub->args[i].btf_id = kern_type_id;
 			continue;
 		}
 		if (is_global) { /* generic user data pointer */
 			u32 mem_size;
 
+			if (tags & ARG_TAG_MAYBE_NULL) {
+				bpf_log(log, "arg#%d has invalid combination of tags\n", i);
+				return -EINVAL;
+			}
+
 			t = btf_type_skip_modifiers(btf, t->type, NULL);
 			ref_t = btf_resolve_size(btf, t, &mem_size);
 			if (IS_ERR(ref_t)) {
Signature · 1 line
2.34.1
author maintainer
#10 lore raw

PATCH v2 6/7 libbpf: add __arg_trusted and __arg_maybe_null tag macros

In reply to Andrii Nakryiko

Add __arg_trusted to annotate global func args that accept trusted PTR_TO_BTF_ID arguments.

Also add __arg_maybe_null to combine with __arg_trusted (and maybe other tags in the future) to force global subprog itself (i.e., callee) to do NULL checks, as opposed to default non-NULL semantics (and thus caller's responsibility to ensure non-NULL values).

---
 tools/lib/bpf/bpf_helpers.h | 2 ++
 1 file changed, 2 insertions(+)
tools/lib/bpf/bpf_helpers.h +2 -0
index 2324cc42b017..5f5901187c94 100644
@@ -190,6 +190,8 @@ enum libbpf_tristate {
 
 #define __arg_ctx __attribute__((btf_decl_tag("arg:ctx")))
 #define __arg_nonnull __attribute((btf_decl_tag("arg:nonnull")))
+#define __arg_maybe_null __attribute((btf_decl_tag("arg:maybe_null")))
+#define __arg_trusted __attribute((btf_decl_tag("arg:trusted")))
 
 #ifndef ___bpf_concat
 #define ___bpf_concat(a, b) a ## b
Signature · 1 line
2.34.1
author maintainer
#11 lore raw

PATCH v2 7/7 selftests/bpf: add trusted global subprog arg tests

In reply to Andrii Nakryiko

Add a bunch of test cases validating behavior of __arg_trusted and its combination with __arg_maybe_null tag. We also validate CO-RE flavor support by kernel for __arg_trusted args.

---
 .../selftests/bpf/prog_tests/verifier.c       |   2 +
 .../bpf/progs/verifier_global_ptr_args.c      | 156 ++++++++++++++++++
 2 files changed, 158 insertions(+)
 create mode 100644 tools/testing/selftests/bpf/progs/verifier_global_ptr_args.c
tools/testing/selftests/bpf/prog_tests/verifier.c +2 -0
index d62c5bf00e71..9c6072a19745 100644
@@ -28,6 +28,7 @@
 #include "verifier_div0.skel.h"
 #include "verifier_div_overflow.skel.h"
 #include "verifier_global_subprogs.skel.h"
+#include "verifier_global_ptr_args.skel.h"
 #include "verifier_gotol.skel.h"
 #include "verifier_helper_access_var_len.skel.h"
 #include "verifier_helper_packet_access.skel.h"
@@ -140,6 +141,7 @@ void test_verifier_direct_stack_access_wraparound(void) { RUN(verifier_direct_st
 void test_verifier_div0(void)                 { RUN(verifier_div0); }
 void test_verifier_div_overflow(void)         { RUN(verifier_div_overflow); }
 void test_verifier_global_subprogs(void)      { RUN(verifier_global_subprogs); }
+void test_verifier_global_ptr_args(void)      { RUN(verifier_global_ptr_args); }
 void test_verifier_gotol(void)                { RUN(verifier_gotol); }
 void test_verifier_helper_access_var_len(void) { RUN(verifier_helper_access_var_len); }
 void test_verifier_helper_packet_access(void) { RUN(verifier_helper_packet_access); }
tools/testing/selftests/bpf/progs/verifier_global_ptr_args.c new file +156 -0

156 lines not on this page · raw message

Signature · 1 line
2.34.1
maintainer Acked-by on the v2 series
#12 lore raw
In reply to Andrii Nakryiko
Quoted 19 lines · Andrii Nakryiko

This patch set follows recent changes that added btf_decl_tag-based argument annotation support for global subprogs. This time we add ability to pass PTR_TO_BTF_ID (BTF-aware kernel pointers) arguments into global subprograms. We support explicitly trusted arguments only, for now.

First three patches are preparatory. Patches #1 and #3 does post-BPF token code adjustments, to undo merge conflict avoidance measures. Patch #2 makes PERF_EVENT type enforcement logic aligned with kernel-side logic.

Patch #4 adds logic for arg:trusted tag support on the verifier side. Default semantic of such arguments is non-NULL, enforced on caller side. But patch #5 adds arg:maybe_null tag that can be combined with arg:trusted to make callee explicitly do the NULL check, which helps implement "optional" PTR_TO_BTF_ID arguments.

Patch #6 adds libbpf-side __arg_trusted and __arg_maybe_null macros. Patch #7 adds a bunch of tests validating __arg_trusted in combination with __arg_maybe_null.

Quoted 7 lines

v1->v2:
- added fix up to type enforcement changes, landed earlier;
- dropped bpf_core_cast() changes, will post them separately, as they now

    are not used in added tests;

- dropped arg:untrusted support (Alexei);
- renamed arg:nullable to arg:maybe_null (Alexei);
- and also added task_struct___local flavor tests (Alexei).

Full patch-set looks good to me.

#13 lore raw
In reply to Andrii Nakryiko
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:

Hello:

This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:

Quoted 10 lines · On Thu, 25 Jan 2024 12:55:03 -0800 you wrote:

This patch set follows recent changes that added btf_decl_tag-based argument annotation support for global subprogs. This time we add ability to pass PTR_TO_BTF_ID (BTF-aware kernel pointers) arguments into global subprograms. We support explicitly trusted arguments only, for now.

First three patches are preparatory. Patches #1 and #3 does post-BPF token code adjustments, to undo merge conflict avoidance measures. Patch #2 makes PERF_EVENT type enforcement logic aligned with kernel-side logic.

[...]

Here is the summary with links:
- [v2,bpf-next,1/7] libbpf: integrate __arg_ctx feature detector into kernel_supports()

    https://git.kernel.org/bpf/bpf-next/c/0e6d0a9d2348
  - [v2,bpf-next,2/7] libbpf: fix __arg_ctx type enforcement for perf_event programs
    https://git.kernel.org/bpf/bpf-next/c/9eea8fafe33e
  - [v2,bpf-next,3/7] bpf: move arg:ctx type enforcement check inside the main logic loop
    https://git.kernel.org/bpf/bpf-next/c/add9c58cd44e

- [v2,bpf-next,4/7] bpf: add __arg_trusted global func arg tag
(no matching commit)
- [v2,bpf-next,5/7] bpf: add arg:maybe_null tag to be combined with trusted pointers (no matching commit)
- [v2,bpf-next,6/7] libbpf: add __arg_trusted and __arg_maybe_null tag macros (no matching commit)
- [v2,bpf-next,7/7] selftests/bpf: add trusted global subprog arg tests (no matching commit)

You are awesome, thank you!

Signature · 2 lines
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html