libbpf: Don't allocate 16M for log buffer by default

For each prog/btf load we allocate and free 16 megs of verifier buffer.
On production systems it doesn't really make sense because the
programs/btf have gone through extensive testing and (mostly) guaranteed
to successfully load.

Let's assume successful case by default and skip buffer allocation
on the first try. If there is an error, start with BPF_LOG_BUF_SIZE
and double it on each ENOSPC iteration.

v3:
* Return -ENOMEM when can't allocate log buffer (Andrii Nakryiko)

v2:
* Don't allocate the buffer at all on the first try (Andrii Nakryiko)

Signed-off-by: Stanislav Fomichev <sdf@google.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Andrii Nakryiko <andriin@fb.com>
Link: https://lore.kernel.org/bpf/20200325195521.112210-1-sdf@google.com

diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
index 3d1c25fc97aefcfeafe62bbc9ad145cb69a67fd4..bfef3d606b54efd01a0dc28c7d93075d104fb037 100644 (file)
--- a/tools/lib/bpf/btf.c
+++ b/tools/lib/bpf/btf.c
@@ -657,22 +657,32 @@ int btf__finalize_data(struct bpf_object *obj, struct btf *btf)
 
 int btf__load(struct btf *btf)
 {
-       __u32 log_buf_size = BPF_LOG_BUF_SIZE;
+       __u32 log_buf_size = 0;
        char *log_buf = NULL;
        int err = 0;
 
        if (btf->fd >= 0)
                return -EEXIST;
 
-       log_buf = malloc(log_buf_size);
-       if (!log_buf)
-               return -ENOMEM;
+retry_load:
+       if (log_buf_size) {
+               log_buf = malloc(log_buf_size);
+               if (!log_buf)
+                       return -ENOMEM;
 
-       *log_buf = 0;
+               *log_buf = 0;
+       }
 
        btf->fd = bpf_load_btf(btf->data, btf->data_size,
                               log_buf, log_buf_size, false);
        if (btf->fd < 0) {
+               if (!log_buf || errno == ENOSPC) {
+                       log_buf_size = max((__u32)BPF_LOG_BUF_SIZE,
+                                          log_buf_size << 1);
+                       free(log_buf);
+                       goto retry_load;
+               }
+
                err = -errno;
                pr_warn("Error loading BTF: %s(%d)\n", strerror(errno), errno);
                if (*log_buf)

diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index e9479ad9dd51a90331d6c739dc9bf8230e2bf0c9..62903302935e1db61c47fada4d972a0826eea090 100644 (file)
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -4851,8 +4851,8 @@ load_program(struct bpf_program *prog, struct bpf_insn *insns, int insns_cnt,
 {
        struct bpf_load_program_attr load_attr;
        char *cp, errmsg[STRERR_BUFSIZE];
-       int log_buf_size = BPF_LOG_BUF_SIZE;
-       char *log_buf;
+       size_t log_buf_size = 0;
+       char *log_buf = NULL;
        int btf_fd, ret;
 
        if (!insns || !insns_cnt)
@@ -4892,22 +4892,28 @@ load_program(struct bpf_program *prog, struct bpf_insn *insns, int insns_cnt,
        load_attr.prog_flags = prog->prog_flags;
 
 retry_load:
-       log_buf = malloc(log_buf_size);
-       if (!log_buf)
-               pr_warn("Alloc log buffer for bpf loader error, continue without log\n");
+       if (log_buf_size) {
+               log_buf = malloc(log_buf_size);
+               if (!log_buf)
+                       return -ENOMEM;
+
+               *log_buf = 0;
+       }
 
        ret = bpf_load_program_xattr(&load_attr, log_buf, log_buf_size);
 
        if (ret >= 0) {
-               if (load_attr.log_level)
+               if (log_buf && load_attr.log_level)
                        pr_debug("verifier log:\n%s", log_buf);
                *pfd = ret;
                ret = 0;
                goto out;
        }
 
-       if (errno == ENOSPC) {
-               log_buf_size <<= 1;
+       if (!log_buf || errno == ENOSPC) {
+               log_buf_size = max((size_t)BPF_LOG_BUF_SIZE,
+                                  log_buf_size << 1);
+
                free(log_buf);
                goto retry_load;
        }