libbpf: Add OPTS-based bpf_btf_load() API

Similar to previous bpf_prog_load() and bpf_map_create() APIs, add
bpf_btf_load() API which is taking optional OPTS struct. Schedule
bpf_load_btf() for deprecation in v0.8 ([0]).

This makes naming consistent with BPF_BTF_LOAD command, sets up an API
for extensibility in the future, moves options parameters (log-related
fields) into optional options, and also allows to pass log_level
directly.

It also removes log buffer auto-allocation logic from low-level API
(consistent with bpf_prog_load() behavior), but preserves a special
treatment of log_level == 0 with non-NULL log_buf, which matches
low-level bpf_prog_load() and high-level libbpf APIs for BTF and program
loading behaviors.

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

Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20211209193840.1248570-3-andrii@kernel.org

diff --git a/tools/lib/bpf/bpf.c b/tools/lib/bpf/bpf.c
index 3dc86342f0a0fb396e5fc2fd75a7d17e2539b8a1..6b2407e12060ba79dafc81e65b13fe2e8f4606ed 100644 (file)
--- a/tools/lib/bpf/bpf.c
+++ b/tools/lib/bpf/bpf.c
@@ -1047,24 +1047,65 @@ int bpf_raw_tracepoint_open(const char *name, int prog_fd)
        return libbpf_err_errno(fd);
 }
 
-int bpf_load_btf(const void *btf, __u32 btf_size, char *log_buf, __u32 log_buf_size,
-                bool do_log)
+int bpf_btf_load(const void *btf_data, size_t btf_size, const struct bpf_btf_load_opts *opts)
 {
-       union bpf_attr attr = {};
+       const size_t attr_sz = offsetofend(union bpf_attr, btf_log_level);
+       union bpf_attr attr;
+       char *log_buf;
+       size_t log_size;
+       __u32 log_level;
        int fd;
 
-       attr.btf = ptr_to_u64(btf);
+       memset(&attr, 0, attr_sz);
+
+       if (!OPTS_VALID(opts, bpf_btf_load_opts))
+               return libbpf_err(-EINVAL);
+
+       log_buf = OPTS_GET(opts, log_buf, NULL);
+       log_size = OPTS_GET(opts, log_size, 0);
+       log_level = OPTS_GET(opts, log_level, 0);
+
+       if (log_size > UINT_MAX)
+               return libbpf_err(-EINVAL);
+       if (log_size && !log_buf)
+               return libbpf_err(-EINVAL);
+
+       attr.btf = ptr_to_u64(btf_data);
        attr.btf_size = btf_size;
+       /* log_level == 0 and log_buf != NULL means "try loading without
+        * log_buf, but retry with log_buf and log_level=1 on error", which is
+        * consistent across low-level and high-level BTF and program loading
+        * APIs within libbpf and provides a sensible behavior in practice
+        */
+       if (log_level) {
+               attr.btf_log_buf = ptr_to_u64(log_buf);
+               attr.btf_log_size = (__u32)log_size;
+               attr.btf_log_level = log_level;
+       }
 
-retry:
-       if (do_log && log_buf && log_buf_size) {
-               attr.btf_log_level = 1;
-               attr.btf_log_size = log_buf_size;
+       fd = sys_bpf_fd(BPF_BTF_LOAD, &attr, attr_sz);
+       if (fd < 0 && log_buf && log_level == 0) {
                attr.btf_log_buf = ptr_to_u64(log_buf);
+               attr.btf_log_size = (__u32)log_size;
+               attr.btf_log_level = 1;
+               fd = sys_bpf_fd(BPF_BTF_LOAD, &attr, attr_sz);
        }
+       return libbpf_err_errno(fd);
+}
+
+int bpf_load_btf(const void *btf, __u32 btf_size, char *log_buf, __u32 log_buf_size, bool do_log)
+{
+       LIBBPF_OPTS(bpf_btf_load_opts, opts);
+       int fd;
 
-       fd = sys_bpf_fd(BPF_BTF_LOAD, &attr, sizeof(attr));
+retry:
+       if (do_log && log_buf && log_buf_size) {
+               opts.log_buf = log_buf;
+               opts.log_size = log_buf_size;
+               opts.log_level = 1;
+       }
 
+       fd = bpf_btf_load(btf, btf_size, &opts);
        if (fd < 0 && !do_log && log_buf && log_buf_size) {
                do_log = true;
                goto retry;

diff --git a/tools/lib/bpf/bpf.h b/tools/lib/bpf/bpf.h
index f79e5fbcf1c1ba336a4f3e6577073178683077ea..5f7d9636643d00bc1aba254a288761e3e13f922a 100644 (file)
--- a/tools/lib/bpf/bpf.h
+++ b/tools/lib/bpf/bpf.h
@@ -213,6 +213,23 @@ LIBBPF_API int bpf_verify_program(enum bpf_prog_type type,
                                  char *log_buf, size_t log_buf_sz,
                                  int log_level);
 
+struct bpf_btf_load_opts {
+       size_t sz; /* size of this struct for forward/backward compatibility */
+
+       /* kernel log options */
+       char *log_buf;
+       __u32 log_level;
+       __u32 log_size;
+};
+#define bpf_btf_load_opts__last_field log_size
+
+LIBBPF_API int bpf_btf_load(const void *btf_data, size_t btf_size,
+                           const struct bpf_btf_load_opts *opts);
+
+LIBBPF_DEPRECATED_SINCE(0, 8, "use bpf_btf_load() instead")
+LIBBPF_API int bpf_load_btf(const void *btf, __u32 btf_size, char *log_buf,
+                           __u32 log_buf_size, bool do_log);
+
 LIBBPF_API int bpf_map_update_elem(int fd, const void *key, const void *value,
                                   __u64 flags);
 
@@ -340,8 +357,6 @@ LIBBPF_API int bpf_prog_query(int target_fd, enum bpf_attach_type type,
                              __u32 query_flags, __u32 *attach_flags,
                              __u32 *prog_ids, __u32 *prog_cnt);
 LIBBPF_API int bpf_raw_tracepoint_open(const char *name, int prog_fd);
-LIBBPF_API int bpf_load_btf(const void *btf, __u32 btf_size, char *log_buf,
-                           __u32 log_buf_size, bool do_log);
 LIBBPF_API int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf,
                                 __u32 *buf_len, __u32 *prog_id, __u32 *fd_type,
                                 __u64 *probe_offset, __u64 *probe_addr);

diff --git a/tools/lib/bpf/libbpf.map b/tools/lib/bpf/libbpf.map
index 715df3a27389bb4c03ae4f482ca28df44e15ec81..08cdfe840436e23e56a1603331e273f820629bdf 100644 (file)
--- a/tools/lib/bpf/libbpf.map
+++ b/tools/lib/bpf/libbpf.map
@@ -422,6 +422,7 @@ LIBBPF_0.6.0 {
 
 LIBBPF_0.7.0 {
        global:
+               bpf_btf_load;
                bpf_program__log_level;
                bpf_program__set_log_level;
 };

diff --git a/tools/lib/bpf/libbpf_probes.c b/tools/lib/bpf/libbpf_probes.c
index 41f2be47c2eab8bce8f27be4db0d288bfc797922..4bdec69523a7c1259d7e5fb5e8876ef77155da7a 100644 (file)
--- a/tools/lib/bpf/libbpf_probes.c
+++ b/tools/lib/bpf/libbpf_probes.c
@@ -164,7 +164,7 @@ int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
        memcpy(raw_btf + hdr.hdr_len, raw_types, hdr.type_len);
        memcpy(raw_btf + hdr.hdr_len + hdr.type_len, str_sec, hdr.str_len);
 
-       btf_fd = bpf_load_btf(raw_btf, btf_len, NULL, 0, false);
+       btf_fd = bpf_btf_load(raw_btf, btf_len, NULL);
 
        free(raw_btf);
        return btf_fd;