Skip to contentSkip to conversation

Revamp and fix libbpf's feature-probing APIs

PATCH Superseded Andrii Nakryiko 3 participants 11 messages Dec 16, 2021 – Dec 17, 2021

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

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore

Andrii Nakryiko

author maintainer
#0 lore raw

cover Revamp and fix libbpf's feature-probing APIs

Fix and improve libbpf feature-probing APIs. Name them consistently and deprecated previous inconsistently named APIs.

Cc Dave Marchevsky <[email protected]>

Andrii Nakryiko (3):
libbpf: rework feature-probing APIs selftests/bpf: add libbpf feature-probing API selftests
bpftool: reimplement large insn size limit feature probing

 tools/bpf/bpftool/feature.c                   |  26 +-
 tools/lib/bpf/libbpf.h                        |  52 +++-
 tools/lib/bpf/libbpf.map                      |   3 +
 tools/lib/bpf/libbpf_probes.c                 | 235 ++++++++++++++----
 tools/testing/selftests/bpf/config            |   2 +
 .../selftests/bpf/prog_tests/libbpf_probes.c  | 124 +++++++++
 6 files changed, 385 insertions(+), 57 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/prog_tests/libbpf_probes.c
Signature · 1 line
2.30.2
author maintainer
#1 lore raw

PATCH 1/3 libbpf: rework feature-probing APIs

Create three extensible alternatives to inconsistently named feature-probing APIs:
- libbpf_probe_bpf_prog_type() instead of bpf_probe_prog_type();
- libbpf_probe_bpf_map_type() instead of bpf_probe_map_type();
- libbpf_probe_bpf_helper() instead of bpf_probe_helper().

Set up return values such that libbpf can report errors (e.g., if some combination of input arguments isn't possible to validate, etc), in addition to whether the feature is supported (return value 1) or not supported (return value 0).

Also schedule deprecation of those three APIs. Also schedule deprecation of bpf_probe_large_insn_limit().

Also fix all the existing detection logic for various program and map types that never worked:
- BPF_PROG_TYPE_LIRC_MODE2;
- BPF_PROG_TYPE_TRACING;
- BPF_PROG_TYPE_LSM;
- BPF_PROG_TYPE_EXT;
- BPF_PROG_TYPE_SYSCALL;
- BPF_PROG_TYPE_STRUCT_OPS;
- BPF_MAP_TYPE_STRUCT_OPS;
- BPF_MAP_TYPE_BLOOM_FILTER.

Above prog/map types needed special setups and detection logic to work. Subsequent patch adds selftests that will make sure that all the detection logic keeps working for all current and future program and map types, avoiding otherwise inevitable bit rot.

[0] Closes: https://github.com/libbpf/libbpf/issues/312

Cc Dave Marchevsky <[email protected]>
Cc Julia Kartseva <[email protected]>
---
 tools/lib/bpf/libbpf.h        |  52 +++++++-
 tools/lib/bpf/libbpf.map      |   3 +
 tools/lib/bpf/libbpf_probes.c | 235 ++++++++++++++++++++++++++--------
 3 files changed, 236 insertions(+), 54 deletions(-)
tools/lib/bpf/libbpf.h +48 -4
index 42b2f36fd9f0..85dfef88b3d2 100644
@@ -1052,13 +1052,57 @@ bpf_prog_linfo__lfind(const struct bpf_prog_linfo *prog_linfo,
  * user, causing subsequent probes to fail. In this case, the caller may want
  * to adjust that limit with setrlimit().
  */
-LIBBPF_API bool bpf_probe_prog_type(enum bpf_prog_type prog_type,
-				    __u32 ifindex);
+LIBBPF_DEPRECATED_SINCE(0, 8, "use libbpf_probe_bpf_prog_type() instead")
+LIBBPF_API bool bpf_probe_prog_type(enum bpf_prog_type prog_type, __u32 ifindex);
+LIBBPF_DEPRECATED_SINCE(0, 8, "use libbpf_probe_bpf_map_type() instead")
 LIBBPF_API bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex);
-LIBBPF_API bool bpf_probe_helper(enum bpf_func_id id,
-				 enum bpf_prog_type prog_type, __u32 ifindex);
+LIBBPF_DEPRECATED_SINCE(0, 8, "use libbpf_probe_bpf_helper() instead")
+LIBBPF_API bool bpf_probe_helper(enum bpf_func_id id, enum bpf_prog_type prog_type, __u32 ifindex);
+LIBBPF_DEPRECATED_SINCE(0, 8, "implement your own or use bpftool for feature detection")
 LIBBPF_API bool bpf_probe_large_insn_limit(__u32 ifindex);
 
+/**
+ * @brief **libbpf_probe_bpf_prog_type()** detects if host kernel supports
+ * BPF programs of a given type.
+ * @param prog_type BPF program type to detect kernel support for
+ * @param opts reserved for future extensibility, should be NULL
+ * @return 1, if given program type is supported; 0, if given program type is
+ * not supported; negative error code if feature detection failed or can't be
+ * performed
+ *
+ * Make sure the process has required set of CAP_* permissions (or runs as
+ * root) when performing feature checking.
+ */
+LIBBPF_API int libbpf_probe_bpf_prog_type(enum bpf_prog_type prog_type, const void *opts);
+/**
+ * @brief **libbpf_probe_bpf_map_type()** detects if host kernel supports
+ * BPF maps of a given type.
+ * @param map_type BPF map type to detect kernel support for
+ * @param opts reserved for future extensibility, should be NULL
+ * @return 1, if given map type is supported; 0, if given map type is
+ * not supported; negative error code if feature detection failed or can't be
+ * performed
+ *
+ * Make sure the process has required set of CAP_* permissions (or runs as
+ * root) when performing feature checking.
+ */
+LIBBPF_API int libbpf_probe_bpf_map_type(enum bpf_map_type map_type, const void *opts);
+/**
+ * @brief **libbpf_probe_bpf_helper()** detects if host kernel supports the
+ * use of a given BPF helper from specified BPF program type.
+ * @param prog_type BPF program type used to check the support of BPF helper
+ * @param helper_id BPF helper ID (enum bpf_func_id) to check support for
+ * @param opts reserved for future extensibility, should be NULL
+ * @return 1, if given combination of program type and helper is supported; 0,
+ * if the combination is not supported; negative error code if feature
+ * detection for provided input arguments failed or can't be performed
+ *
+ * Make sure the process has required set of CAP_* permissions (or runs as
+ * root) when performing feature checking.
+ */
+LIBBPF_API int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type,
+				       enum bpf_func_id helper_id, const void *opts);
+
 /*
  * Get bpf_prog_info in continuous memory
  *
tools/lib/bpf/libbpf.map +3 -0
index b3938b3f8fc9..529783967793 100644
@@ -427,5 +427,8 @@ LIBBPF_0.7.0 {
 		bpf_program__log_level;
 		bpf_program__set_log_buf;
 		bpf_program__set_log_level;
+		libbpf_probe_bpf_helper;
+		libbpf_probe_bpf_map_type;
+		libbpf_probe_bpf_prog_type;
 		libbpf_set_memlock_rlim_max;
 };
tools/lib/bpf/libbpf_probes.c +185 -50

345 lines not on this page · raw message

Signature · 1 line
2.30.2
#2 lore raw

Re: [PATCH bpf-next 1/3] libbpf: rework feature-probing APIs

Quoted 36 lines · Andrii Nakryiko

Create three extensible alternatives to inconsistently named feature-probing APIs:
- libbpf_probe_bpf_prog_type() instead of bpf_probe_prog_type();
- libbpf_probe_bpf_map_type() instead of bpf_probe_map_type();
- libbpf_probe_bpf_helper() instead of bpf_probe_helper().

Set up return values such that libbpf can report errors (e.g., if some combination of input arguments isn't possible to validate, etc), in addition to whether the feature is supported (return value 1) or not supported (return value 0).

Also schedule deprecation of those three APIs. Also schedule deprecation of bpf_probe_large_insn_limit().

Also fix all the existing detection logic for various program and map types that never worked:
- BPF_PROG_TYPE_LIRC_MODE2;
- BPF_PROG_TYPE_TRACING;
- BPF_PROG_TYPE_LSM;
- BPF_PROG_TYPE_EXT;
- BPF_PROG_TYPE_SYSCALL;
- BPF_PROG_TYPE_STRUCT_OPS;
- BPF_MAP_TYPE_STRUCT_OPS;
- BPF_MAP_TYPE_BLOOM_FILTER.

Above prog/map types needed special setups and detection logic to work. Subsequent patch adds selftests that will make sure that all the detection logic keeps working for all current and future program and map types, avoiding otherwise inevitable bit rot.

[0] Closes: https://github.com/libbpf/libbpf/issues/312

Cc Dave Marchevsky <[email protected]>
Cc Julia Kartseva <[email protected]>

---

[...]

Quoted 4 lines
tools/lib/bpf/libbpf_probes.c +0 -0
index 4bdec69523a7..65232bcaa84c 100644

[...]

Quoted 25 lines
tools/lib/bpf/libbpf_probes.c +21 -0
@@ -84,6 +92,38 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,
 	case BPF_PROG_TYPE_KPROBE:
 		opts.kern_version = get_kernel_version();
 		break;
+	case BPF_PROG_TYPE_LIRC_MODE2:
+		opts.expected_attach_type = BPF_LIRC_MODE2;
+		break;
+	case BPF_PROG_TYPE_TRACING:
+	case BPF_PROG_TYPE_LSM:
+		opts.log_buf = buf;
+		opts.log_size = sizeof(buf);
+		opts.log_level = 1;
+		if (prog_type == BPF_PROG_TYPE_TRACING)
+			opts.expected_attach_type = BPF_TRACE_FENTRY;
+		else
+			opts.expected_attach_type = BPF_MODIFY_RETURN;
+		opts.attach_btf_id = 1;
+
+		exp_err = -EINVAL;
+		exp_msg = "attach_btf_id 1 is not a function";
+		break;
+	case BPF_PROG_TYPE_EXT:
+		opts.log_buf = buf;
+		opts.log_size = sizeof(buf);
+		opts.log_level = 1;

tools/lib/bpf/libbpf_probes.c probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, · line 125

Quoted 10 lines
tools/lib/bpf/libbpf_probes.c +10 -0
+		opts.attach_btf_id = 1;
+
+		exp_err = -EINVAL;
+		exp_msg = "Cannot replace kernel functions";
+		break;
+	case BPF_PROG_TYPE_SYSCALL:
+		opts.prog_flags = BPF_F_SLEEPABLE;
+		break;
+	case BPF_PROG_TYPE_STRUCT_OPS:
+		exp_err = -524; /* -EOPNOTSUPP */

Why not use the ENOTSUPP macro here, and elsewhere in this patch? Also, maybe the comment in this particular instance is incorrect? (EOPNOTSUPP -> ENOTSUPP)

Quoted 4 lines
tools/lib/bpf/libbpf_probes.c +1 -0
+		break;
 	case BPF_PROG_TYPE_UNSPEC:
 	case BPF_PROG_TYPE_SOCKET_FILTER:
 	case BPF_PROG_TYPE_SCHED_CLS:

[...]

Quoted 36 lines
tools/lib/bpf/libbpf_probes.c +36 -0
+int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helper_id,
+			    const void *opts)
+{
+	struct bpf_insn insns[] = {
+		BPF_EMIT_CALL((__u32)helper_id),
+		BPF_EXIT_INSN(),
+	};
+	const size_t insn_cnt = ARRAY_SIZE(insns);
+	char buf[4096];
+	int ret;
+
+	if (opts)
+		return libbpf_err(-EINVAL);
+
+	/* we can't successfully load all prog types to check for BPF helper
+	 * support, so bail out with -EOPNOTSUPP error
+	 */
+	switch (prog_type) {
+	case BPF_PROG_TYPE_TRACING:
+	case BPF_PROG_TYPE_EXT:
+	case BPF_PROG_TYPE_LSM:
+	case BPF_PROG_TYPE_STRUCT_OPS:
+		return -EOPNOTSUPP;
+	default:
+		break;
+	}
+
+	buf[0] = '\0';
+	ret = probe_prog_load(prog_type, insns, insn_cnt, buf, sizeof(buf), 0);
+	if (ret < 0)
+		return libbpf_err(ret);
+
+	/* If BPF verifier doesn't recognize BPF helper ID (enum bpf_func_id)
+	 * at all, it will emit something like "invalid func unknown#181".
+	 * If BPF verifier recognizes BPF helper but it's not supported for
+	 * given BPF program type, it will emit "unknown func bpf_sys_bpf#166".

tools/lib/bpf/libbpf_probes.c bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex) · line 443

Quoted 10 lines
tools/lib/bpf/libbpf_probes.c +10 -0
+	 * In both cases, provided combination of BPF program type and BPF
+	 * helper is not supported by the kernel.
+	 * In all other cases, probe_prog_load() above will either succeed (e.g.,
+	 * because BPF helper happens to accept no input arguments or it
+	 * accepts one input argument and initial PTR_TO_CTX is fine for
+	 * that), or we'll get some more specific BPF verifier error about
+	 * some unsatisfied conditions.
+	 */
+	if (ret == 0 && (strstr(buf, "invalid func ") || strstr(buf, "unknown func ")))
+		return 0;

Maybe worth adding a comment where these are logged in verifier.c, so that if format is changed or a less brittle way of conveying this info is added, this fn can be updated.

Quoted 3 lines
tools/lib/bpf/libbpf_probes.c +1 -0
+	return 1; /* assume supported */
 }

[...]

#3 lore raw

Re: [PATCH bpf-next 1/3] libbpf: rework feature-probing APIs

Quoted 77 lines · Dave Marchevsky
Quoted 36 lines · Andrii Nakryiko

Create three extensible alternatives to inconsistently named feature-probing APIs:
- libbpf_probe_bpf_prog_type() instead of bpf_probe_prog_type();
- libbpf_probe_bpf_map_type() instead of bpf_probe_map_type();
- libbpf_probe_bpf_helper() instead of bpf_probe_helper().

Set up return values such that libbpf can report errors (e.g., if some combination of input arguments isn't possible to validate, etc), in addition to whether the feature is supported (return value 1) or not supported (return value 0).

Also schedule deprecation of those three APIs. Also schedule deprecation of bpf_probe_large_insn_limit().

Also fix all the existing detection logic for various program and map types that never worked:
- BPF_PROG_TYPE_LIRC_MODE2;
- BPF_PROG_TYPE_TRACING;
- BPF_PROG_TYPE_LSM;
- BPF_PROG_TYPE_EXT;
- BPF_PROG_TYPE_SYSCALL;
- BPF_PROG_TYPE_STRUCT_OPS;
- BPF_MAP_TYPE_STRUCT_OPS;
- BPF_MAP_TYPE_BLOOM_FILTER.

Above prog/map types needed special setups and detection logic to work. Subsequent patch adds selftests that will make sure that all the detection logic keeps working for all current and future program and map types, avoiding otherwise inevitable bit rot.

[0] Closes: https://github.com/libbpf/libbpf/issues/312

Cc Dave Marchevsky <[email protected]>
Cc Julia Kartseva <[email protected]>

---

[...]

Quoted 4 lines
tools/lib/bpf/libbpf_probes.c +0 -0
index 4bdec69523a7..65232bcaa84c 100644

[...]

Quoted 29 lines
tools/lib/bpf/libbpf_probes.c +25 -0
@@ -84,6 +92,38 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,
      case BPF_PROG_TYPE_KPROBE:
              opts.kern_version = get_kernel_version();
              break;
+     case BPF_PROG_TYPE_LIRC_MODE2:
+             opts.expected_attach_type = BPF_LIRC_MODE2;
+             break;
+     case BPF_PROG_TYPE_TRACING:
+     case BPF_PROG_TYPE_LSM:
+             opts.log_buf = buf;
+             opts.log_size = sizeof(buf);
+             opts.log_level = 1;
+             if (prog_type == BPF_PROG_TYPE_TRACING)
+                     opts.expected_attach_type = BPF_TRACE_FENTRY;
+             else
+                     opts.expected_attach_type = BPF_MODIFY_RETURN;
+             opts.attach_btf_id = 1;
+
+             exp_err = -EINVAL;
+             exp_msg = "attach_btf_id 1 is not a function";
+             break;
+     case BPF_PROG_TYPE_EXT:
+             opts.log_buf = buf;
+             opts.log_size = sizeof(buf);
+             opts.log_level = 1;
+             opts.attach_btf_id = 1;
+
+             exp_err = -EINVAL;
+             exp_msg = "Cannot replace kernel functions";
Quoted 8 lines

tools/lib/bpf/libbpf_probes.c probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, · line 125

Quoted 6 lines
tools/lib/bpf/libbpf_probes.c +6 -0
+             break;
+     case BPF_PROG_TYPE_SYSCALL:
+             opts.prog_flags = BPF_F_SLEEPABLE;
+             break;
+     case BPF_PROG_TYPE_STRUCT_OPS:
+             exp_err = -524; /* -EOPNOTSUPP */

Why not use the ENOTSUPP macro here, and elsewhere in this patch?

ENOTSUPP is kernel-internal code, so there is no #define ENOTSUPP available to user-space applications.

Quoted 2 lines

Also, maybe the comment in this particular instance is incorrect? (EOPNOTSUPP -> ENOTSUPP)

Yeah, I seem to constantly mess up comments. It should be -ENOTSUPP.

Quoted 50 lines
Quoted 5 lines
tools/lib/bpf/libbpf_probes.c +1 -0
+             break;
      case BPF_PROG_TYPE_UNSPEC:
      case BPF_PROG_TYPE_SOCKET_FILTER:
      case BPF_PROG_TYPE_SCHED_CLS:

[...]

Quoted 42 lines
tools/lib/bpf/libbpf_probes.c +42 -0
+int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helper_id,
+                         const void *opts)
+{
+     struct bpf_insn insns[] = {
+             BPF_EMIT_CALL((__u32)helper_id),
+             BPF_EXIT_INSN(),
+     };
+     const size_t insn_cnt = ARRAY_SIZE(insns);
+     char buf[4096];
+     int ret;
+
+     if (opts)
+             return libbpf_err(-EINVAL);
+
+     /* we can't successfully load all prog types to check for BPF helper
+      * support, so bail out with -EOPNOTSUPP error
+      */
+     switch (prog_type) {
+     case BPF_PROG_TYPE_TRACING:
+     case BPF_PROG_TYPE_EXT:
+     case BPF_PROG_TYPE_LSM:
+     case BPF_PROG_TYPE_STRUCT_OPS:
+             return -EOPNOTSUPP;
+     default:
+             break;
+     }
+
+     buf[0] = '\0';
+     ret = probe_prog_load(prog_type, insns, insn_cnt, buf, sizeof(buf), 0);
+     if (ret < 0)
+             return libbpf_err(ret);
+
+     /* If BPF verifier doesn't recognize BPF helper ID (enum bpf_func_id)
+      * at all, it will emit something like "invalid func unknown#181".
+      * If BPF verifier recognizes BPF helper but it's not supported for
+      * given BPF program type, it will emit "unknown func bpf_sys_bpf#166".
+      * In both cases, provided combination of BPF program type and BPF
+      * helper is not supported by the kernel.
+      * In all other cases, probe_prog_load() above will either succeed (e.g.,
+      * because BPF helper happens to accept no input arguments or it
+      * accepts one input argument and initial PTR_TO_CTX is fine for
+      * that), or we'll get some more specific BPF verifier error about
Quoted 8 lines

tools/lib/bpf/libbpf_probes.c bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex) · line 443

Quoted 4 lines
tools/lib/bpf/libbpf_probes.c +4 -0
+      * some unsatisfied conditions.
+      */
+     if (ret == 0 && (strstr(buf, "invalid func ") || strstr(buf, "unknown func ")))
+             return 0;

Maybe worth adding a comment where these are logged in verifier.c, so that if format is changed or a less brittle way of conveying this info is added, this fn can be updated.

Not sure I want to point out that this is done in verifier.c specifically. What if that code is moved somewhere else? Seems like a bit too detailed and specific comment to add. I was hoping the above big comment explains what we do here, thought?

As for the need to change this, with selftests I added we'll get immediate selftests failure, so this won't bit rot and we'll be always aware when the detection breaks.

Quoted 6 lines
Quoted 4 lines

+ return 1; /* assume supported */
}

[...]

#4 lore raw

Re: [PATCH bpf-next 1/3] libbpf: rework feature-probing APIs

Quoted 154 lines · Andrii Nakryiko
Quoted 77 lines · Dave Marchevsky
Quoted 36 lines · Andrii Nakryiko

Create three extensible alternatives to inconsistently named feature-probing APIs:
- libbpf_probe_bpf_prog_type() instead of bpf_probe_prog_type();
- libbpf_probe_bpf_map_type() instead of bpf_probe_map_type();
- libbpf_probe_bpf_helper() instead of bpf_probe_helper().

Set up return values such that libbpf can report errors (e.g., if some combination of input arguments isn't possible to validate, etc), in addition to whether the feature is supported (return value 1) or not supported (return value 0).

Also schedule deprecation of those three APIs. Also schedule deprecation of bpf_probe_large_insn_limit().

Also fix all the existing detection logic for various program and map types that never worked:
- BPF_PROG_TYPE_LIRC_MODE2;
- BPF_PROG_TYPE_TRACING;
- BPF_PROG_TYPE_LSM;
- BPF_PROG_TYPE_EXT;
- BPF_PROG_TYPE_SYSCALL;
- BPF_PROG_TYPE_STRUCT_OPS;
- BPF_MAP_TYPE_STRUCT_OPS;
- BPF_MAP_TYPE_BLOOM_FILTER.

Above prog/map types needed special setups and detection logic to work. Subsequent patch adds selftests that will make sure that all the detection logic keeps working for all current and future program and map types, avoiding otherwise inevitable bit rot.

[0] Closes: https://github.com/libbpf/libbpf/issues/312

Cc Dave Marchevsky <[email protected]>
Cc Julia Kartseva <[email protected]>

---

[...]

Quoted 4 lines
tools/lib/bpf/libbpf_probes.c +0 -0
index 4bdec69523a7..65232bcaa84c 100644

[...]

Quoted 29 lines
tools/lib/bpf/libbpf_probes.c +25 -0
@@ -84,6 +92,38 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,
      case BPF_PROG_TYPE_KPROBE:
              opts.kern_version = get_kernel_version();
              break;
+     case BPF_PROG_TYPE_LIRC_MODE2:
+             opts.expected_attach_type = BPF_LIRC_MODE2;
+             break;
+     case BPF_PROG_TYPE_TRACING:
+     case BPF_PROG_TYPE_LSM:
+             opts.log_buf = buf;
+             opts.log_size = sizeof(buf);
+             opts.log_level = 1;
+             if (prog_type == BPF_PROG_TYPE_TRACING)
+                     opts.expected_attach_type = BPF_TRACE_FENTRY;
+             else
+                     opts.expected_attach_type = BPF_MODIFY_RETURN;
+             opts.attach_btf_id = 1;
+
+             exp_err = -EINVAL;
+             exp_msg = "attach_btf_id 1 is not a function";
+             break;
+     case BPF_PROG_TYPE_EXT:
+             opts.log_buf = buf;
+             opts.log_size = sizeof(buf);
+             opts.log_level = 1;
+             opts.attach_btf_id = 1;
+
+             exp_err = -EINVAL;
+             exp_msg = "Cannot replace kernel functions";
Quoted 8 lines

tools/lib/bpf/libbpf_probes.c probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, · line 125

Quoted 6 lines
tools/lib/bpf/libbpf_probes.c +6 -0
+             break;
+     case BPF_PROG_TYPE_SYSCALL:
+             opts.prog_flags = BPF_F_SLEEPABLE;
+             break;
+     case BPF_PROG_TYPE_STRUCT_OPS:
+             exp_err = -524; /* -EOPNOTSUPP */

Why not use the ENOTSUPP macro here, and elsewhere in this patch?

ENOTSUPP is kernel-internal code, so there is no #define ENOTSUPP available to user-space applications.

Quoted 2 lines

Also, maybe the comment in this particular instance is incorrect? (EOPNOTSUPP -> ENOTSUPP)

Yeah, I seem to constantly mess up comments. It should be -ENOTSUPP.

Quoted 50 lines
Quoted 5 lines
tools/lib/bpf/libbpf_probes.c +1 -0
+             break;
      case BPF_PROG_TYPE_UNSPEC:
      case BPF_PROG_TYPE_SOCKET_FILTER:
      case BPF_PROG_TYPE_SCHED_CLS:

[...]

Quoted 42 lines
tools/lib/bpf/libbpf_probes.c +42 -0
+int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helper_id,
+                         const void *opts)
+{
+     struct bpf_insn insns[] = {
+             BPF_EMIT_CALL((__u32)helper_id),
+             BPF_EXIT_INSN(),
+     };
+     const size_t insn_cnt = ARRAY_SIZE(insns);
+     char buf[4096];
+     int ret;
+
+     if (opts)
+             return libbpf_err(-EINVAL);
+
+     /* we can't successfully load all prog types to check for BPF helper
+      * support, so bail out with -EOPNOTSUPP error
+      */
+     switch (prog_type) {
+     case BPF_PROG_TYPE_TRACING:
+     case BPF_PROG_TYPE_EXT:
+     case BPF_PROG_TYPE_LSM:
+     case BPF_PROG_TYPE_STRUCT_OPS:
+             return -EOPNOTSUPP;
+     default:
+             break;
+     }
+
+     buf[0] = '\0';
+     ret = probe_prog_load(prog_type, insns, insn_cnt, buf, sizeof(buf), 0);
+     if (ret < 0)
+             return libbpf_err(ret);
+
+     /* If BPF verifier doesn't recognize BPF helper ID (enum bpf_func_id)
+      * at all, it will emit something like "invalid func unknown#181".
+      * If BPF verifier recognizes BPF helper but it's not supported for
+      * given BPF program type, it will emit "unknown func bpf_sys_bpf#166".
+      * In both cases, provided combination of BPF program type and BPF
+      * helper is not supported by the kernel.
+      * In all other cases, probe_prog_load() above will either succeed (e.g.,
+      * because BPF helper happens to accept no input arguments or it
+      * accepts one input argument and initial PTR_TO_CTX is fine for
+      * that), or we'll get some more specific BPF verifier error about
Quoted 8 lines

tools/lib/bpf/libbpf_probes.c bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex) · line 443

Quoted 4 lines
tools/lib/bpf/libbpf_probes.c +4 -0
+      * some unsatisfied conditions.
+      */
+     if (ret == 0 && (strstr(buf, "invalid func ") || strstr(buf, "unknown func ")))
+             return 0;

Maybe worth adding a comment where these are logged in verifier.c, so that if format is changed or a less brittle way of conveying this info is added, this fn can be updated.

Quoted 8 lines

Not sure I want to point out that this is done in verifier.c specifically. What if that code is moved somewhere else? Seems like a bit too detailed and specific comment to add. I was hoping the above big comment explains what we do here, thought?

As for the need to change this, with selftests I added we'll get immediate selftests failure, so this won't bit rot and we'll be always aware when the detection breaks.

Ah, I think there's a misunderstanding. I meant "In verifier.c, could you point out that this is done here". But I agree with your point that this is unnecessary given the selftests added later in the series.

Quoted 6 lines
Quoted 6 lines
Quoted 4 lines

+ return 1; /* assume supported */
}

[...]

author maintainer
#5 lore raw

PATCH 2/3 selftests/bpf: add libbpf feature-probing API selftests

In reply to Andrii Nakryiko

Add selftests for prog/map/prog+helper feature probing APIs. Prog and map selftests are designed in such a way that they will always test all the possible prog/map types, based on running kernel's vmlinux BTF enum definition. This way we'll always be sure that when adding new BPF program types or map types, libbpf will be always updated accordingly to be able to feature-detect them.

BPF prog_helper selftest will have to be manually extended with interesting and important prog+helper combinations, it's easy, but can't be completely automated.

---
 tools/testing/selftests/bpf/config            |   2 +
 .../selftests/bpf/prog_tests/libbpf_probes.c  | 124 ++++++++++++++++++
 2 files changed, 126 insertions(+)
 create mode 100644 tools/testing/selftests/bpf/prog_tests/libbpf_probes.c
tools/testing/selftests/bpf/config +2 -0
index 5192305159ec..f6287132fa89 100644
@@ -38,7 +38,9 @@ CONFIG_IPV6_SIT=m
 CONFIG_BPF_JIT=y
 CONFIG_BPF_LSM=y
 CONFIG_SECURITY=y
+CONFIG_RC_CORE=y
 CONFIG_LIRC=y
+CONFIG_BPF_LIRC_MODE2=y
 CONFIG_IMA=y
 CONFIG_SECURITYFS=y
 CONFIG_IMA_WRITE_POLICY=y
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +124 -0

124 lines not on this page · raw message

Signature · 1 line
2.30.2
Acked-by on v1 2/3
#6 lore raw

Re: [PATCH bpf-next 2/3] selftests/bpf: add libbpf feature-probing API selftests

Quoted 13 lines · Andrii Nakryiko

Add selftests for prog/map/prog+helper feature probing APIs. Prog and map selftests are designed in such a way that they will always test all the possible prog/map types, based on running kernel's vmlinux BTF enum definition. This way we'll always be sure that when adding new BPF program types or map types, libbpf will be always updated accordingly to be able to feature-detect them.

BPF prog_helper selftest will have to be manually extended with interesting and important prog+helper combinations, it's easy, but can't be completely automated.

---

[...]

Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +4 -0
+	for (e = btf_enum(t), i = 0, n = btf_vlen(t); i < n; e++, i++) {
+		const char *prog_type_name = btf__str_by_offset(btf, e->name_off);
+		enum bpf_prog_type prog_type = (enum bpf_prog_type)e->val;
+		int res;

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c line 39

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +10 -0
+
+		if (prog_type == BPF_PROG_TYPE_UNSPEC)
+			continue;
+
+		if (!test__start_subtest(prog_type_name))
+			continue;
+
+		res = libbpf_probe_bpf_prog_type(prog_type, NULL);
+		ASSERT_EQ(res, 1, prog_type_name);
+	}

I like how easy BTF makes this.
Maybe worth trying to probe one-past-the-end of enum to confirm it fails as expected?

Regardless,

Quoted 3 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +3 -0
+cleanup:
+	btf__free(btf);
+}

[...]

#7 lore raw

Re: [PATCH bpf-next 2/3] selftests/bpf: add libbpf feature-probing API selftests

Quoted 28 lines · Dave Marchevsky
Quoted 13 lines · Andrii Nakryiko

Add selftests for prog/map/prog+helper feature probing APIs. Prog and map selftests are designed in such a way that they will always test all the possible prog/map types, based on running kernel's vmlinux BTF enum definition. This way we'll always be sure that when adding new BPF program types or map types, libbpf will be always updated accordingly to be able to feature-detect them.

BPF prog_helper selftest will have to be manually extended with interesting and important prog+helper combinations, it's easy, but can't be completely automated.

---

[...]

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +10 -0
+     for (e = btf_enum(t), i = 0, n = btf_vlen(t); i < n; e++, i++) {
+             const char *prog_type_name = btf__str_by_offset(btf, e->name_off);
+             enum bpf_prog_type prog_type = (enum bpf_prog_type)e->val;
+             int res;
+
+             if (prog_type == BPF_PROG_TYPE_UNSPEC)
+                     continue;
+
+             if (!test__start_subtest(prog_type_name))
+                     continue;
Quoted 9 lines

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c line 39

Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +4 -0
+
+             res = libbpf_probe_bpf_prog_type(prog_type, NULL);
+             ASSERT_EQ(res, 1, prog_type_name);
+     }

I like how easy BTF makes this.
Maybe worth trying to probe one-past-the-end of enum to confirm it fails as expected?

Yeah, sure, not a bad idea, I'll add in v2.

Quoted 9 lines

Regardless,

Quoted 3 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +3 -0
+cleanup:
+     btf__free(btf);
+}

[...]

#8 lore raw

Re: [PATCH bpf-next 2/3] selftests/bpf: add libbpf feature-probing API selftests

Quoted 40 lines · Andrii Nakryiko
Quoted 28 lines · Dave Marchevsky
Quoted 13 lines · Andrii Nakryiko

Add selftests for prog/map/prog+helper feature probing APIs. Prog and map selftests are designed in such a way that they will always test all the possible prog/map types, based on running kernel's vmlinux BTF enum definition. This way we'll always be sure that when adding new BPF program types or map types, libbpf will be always updated accordingly to be able to feature-detect them.

BPF prog_helper selftest will have to be manually extended with interesting and important prog+helper combinations, it's easy, but can't be completely automated.

---

[...]

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +10 -0
+     for (e = btf_enum(t), i = 0, n = btf_vlen(t); i < n; e++, i++) {
+             const char *prog_type_name = btf__str_by_offset(btf, e->name_off);
+             enum bpf_prog_type prog_type = (enum bpf_prog_type)e->val;
+             int res;
+
+             if (prog_type == BPF_PROG_TYPE_UNSPEC)
+                     continue;
+
+             if (!test__start_subtest(prog_type_name))
+                     continue;
Quoted 9 lines

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c line 39

Quoted 4 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +4 -0
+
+             res = libbpf_probe_bpf_prog_type(prog_type, NULL);
+             ASSERT_EQ(res, 1, prog_type_name);
+     }

I like how easy BTF makes this.
Maybe worth trying to probe one-past-the-end of enum to confirm it fails as expected?

Quoted 1 line

Yeah, sure, not a bad idea, I'll add in v2.

Couldn't do it :( Because selftest is using running kernel's BTF to find out maximum BPF map type. But that maximum on a slightly outdated kernel could be something that libbpf actually knows about and supports (because it was compiled against the latest kernel UAPI headers). So at run time libbpf returns 0 (correct answer, not map/prog is not supported), but not the expected -EOPNOTSUPP. And I don't want to hardcode the maximum enum values (like BPF_MAP_TYPE_BLOOM_FILTER, as of now), because every time we add new map we'll need to fix selftests in the same patch, which is a bit annoying, I think.

If we had equivalents of __BPF_FUNC_MAX_ID for bpf_map_type and bpf_prog_type, we could have just used those constants, so maybe we should do that instead?

Regardless, I'm sending selftests as they are right now and we can follow up with UAPI additions and selftests improvements separately.

Quoted 10 lines
Quoted 10 lines

Regardless,

Quoted 3 lines
tools/testing/selftests/bpf/prog_tests/libbpf_probes.c new file +3 -0
+cleanup:
+     btf__free(btf);
+}

[...]

author maintainer
#9 lore raw

PATCH 3/3 bpftool: reimplement large insn size limit feature probing

In reply to Andrii Nakryiko

Reimplement bpf_probe_large_insn_limit() in bpftool, as that libbpf API is scheduled for deprecation in v0.8.

---
 tools/bpf/bpftool/feature.c | 26 +++++++++++++++++++++++---
 1 file changed, 23 insertions(+), 3 deletions(-)
tools/bpf/bpftool/feature.c +23 -3
index 5397077d0d9e..6719b9282eca 100644
@@ -642,12 +642,32 @@ probe_helpers_for_progtype(enum bpf_prog_type prog_type, bool supported_type,
 		printf("\n");
 }
 
-static void
-probe_large_insn_limit(const char *define_prefix, __u32 ifindex)
+/*
+ * Probe for availability of kernel commit (5.3):
+ *
+ * c04c0d2b968a ("bpf: increase complexity limit and maximum program size")
+ */
+static void probe_large_insn_limit(const char *define_prefix, __u32 ifindex)
 {
+	LIBBPF_OPTS(bpf_prog_load_opts, opts,
+		.prog_ifindex = ifindex,
+	);
+	struct bpf_insn insns[BPF_MAXINSNS + 1];
 	bool res;
+	int i, fd;
+
+	for (i = 0; i < BPF_MAXINSNS; i++)
+		insns[i] = BPF_MOV64_IMM(BPF_REG_0, 1);
+	insns[BPF_MAXINSNS] = BPF_EXIT_INSN();
+
+	errno = 0;
+	fd = bpf_prog_load(BPF_PROG_TYPE_SCHED_CLS, NULL, "GPL",
+			   insns, ARRAY_SIZE(insns), &opts);
+	res = fd >= 0 || (errno != E2BIG && errno != EINVAL);
+
+	if (fd >= 0)
+		close(fd);
 
-	res = bpf_probe_large_insn_limit(ifindex);
 	print_bool_feature("have_large_insn_limit",
 			   "Large program size limit",
 			   "LARGE_INSN_LIMIT",
Signature · 1 line
2.30.2
Acked-by on v1 3/3
#10 lore raw

Re: [PATCH bpf-next 3/3] bpftool: reimplement large insn size limit feature probing

Quoted 7 lines · Andrii Nakryiko

Reimplement bpf_probe_large_insn_limit() in bpftool, as that libbpf API is scheduled for deprecation in v0.8.

---
 tools/bpf/bpftool/feature.c | 26 +++++++++++++++++++++++---
 1 file changed, 23 insertions(+), 3 deletions(-)