Skip to contentSkip to conversation

bpf: adjust btf load error logging

PATCH In review Jordan Rome 2 participants 5 messages Mar 12, 2025 – Mar 16, 2025

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH v4 1/1 bpf: adjust btf load error logging

For kernels where btf is not mandatory we should log loading errors with pr_info and not retry where we increase the log level as this is just added noise.

---
 tools/lib/bpf/btf.c             | 36 ++++++++++++++++++---------------
 tools/lib/bpf/libbpf.c          |  3 ++-
 tools/lib/bpf/libbpf_internal.h |  2 +-
 3 files changed, 23 insertions(+), 18 deletions(-)
tools/lib/bpf/btf.c +20 -16
index eea99c766a20..7da4807451bb 100644
@@ -1379,9 +1379,10 @@ static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endi
 
 int btf_load_into_kernel(struct btf *btf,
 			 char *log_buf, size_t log_sz, __u32 log_level,
-			 int token_fd)
+			 int token_fd, bool btf_mandatory)
 {
 	LIBBPF_OPTS(bpf_btf_load_opts, opts);
+	enum libbpf_print_level print_level;
 	__u32 buf_sz = 0, raw_size;
 	char *buf = NULL, *tmp;
 	void *raw_data;
@@ -1435,22 +1436,25 @@ int btf_load_into_kernel(struct btf *btf,
 
 	btf->fd = bpf_btf_load(raw_data, raw_size, &opts);
 	if (btf->fd < 0) {
-		/* time to turn on verbose mode and try again */
-		if (log_level == 0) {
-			log_level = 1;
-			goto retry_load;
+		if (btf_mandatory) {
+			/* time to turn on verbose mode and try again */
+			if (log_level == 0) {
+				log_level = 1;
+				goto retry_load;
+			}
+			/* only retry if caller didn't provide custom log_buf, but
+			 * make sure we can never overflow buf_sz
+			 */
+			if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2)
+				goto retry_load;
 		}
-		/* only retry if caller didn't provide custom log_buf, but
-		 * make sure we can never overflow buf_sz
-		 */
-		if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2)
-			goto retry_load;
-
 		err = -errno;
-		pr_warn("BTF loading error: %s\n", errstr(err));
-		/* don't print out contents of custom log_buf */
-		if (!log_buf && buf[0])
-			pr_warn("-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n", buf);
+		print_level = btf_mandatory ? LIBBPF_WARN : LIBBPF_INFO;
+		__pr(print_level, "BTF loading error: %s\n", errstr(err));
+		if (!log_buf && log_level)
+			__pr(print_level,
+			     "-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n",
+			     buf);
 	}
 
 done:
@@ -1460,7 +1464,7 @@ int btf_load_into_kernel(struct btf *btf,
 
 int btf__load_into_kernel(struct btf *btf)
 {
-	return btf_load_into_kernel(btf, NULL, 0, 0, 0);
+	return btf_load_into_kernel(btf, NULL, 0, 0, 0, true);
 }
 
 int btf__fd(const struct btf *btf)
tools/lib/bpf/libbpf.c +2 -1
index 8e32286854ef..2cb3f067a12e 100644
@@ -3604,9 +3604,10 @@ static int bpf_object__sanitize_and_load_btf(struct bpf_object *obj)
 		 */
 		btf__set_fd(kern_btf, 0);
 	} else {
+		btf_mandatory = kernel_needs_btf(obj);
 		/* currently BPF_BTF_LOAD only supports log_level 1 */
 		err = btf_load_into_kernel(kern_btf, obj->log_buf, obj->log_size,
-					   obj->log_level ? 1 : 0, obj->token_fd);
+					   obj->log_level ? 1 : 0, obj->token_fd, btf_mandatory);
 	}
 	if (sanitize) {
 		if (!err) {
tools/lib/bpf/libbpf_internal.h +1 -1
index de498e2dd6b0..f1de2ba462c3 100644
@@ -408,7 +408,7 @@ int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
 			 int token_fd);
 int btf_load_into_kernel(struct btf *btf,
 			 char *log_buf, size_t log_sz, __u32 log_level,
-			 int token_fd);
+			 int token_fd, bool btf_mandatory);
 
 struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf);
 void btf_get_kernel_prefix_kind(enum bpf_attach_type attach_type,

--
2.47.1

#1 lore raw
Quoted 37 lines · Jordan Rome

For kernels where btf is not mandatory we should log loading errors with pr_info and not retry where we increase the log level as this is just added noise.

---
 tools/lib/bpf/btf.c             | 36 ++++++++++++++++++---------------
 tools/lib/bpf/libbpf.c          |  3 ++-
 tools/lib/bpf/libbpf_internal.h |  2 +-
 3 files changed, 23 insertions(+), 18 deletions(-)
tools/lib/bpf/btf.c +2 -5
index eea99c766a20..7da4807451bb 100644
@@ -1379,9 +1379,10 @@ static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endi
 
 int btf_load_into_kernel(struct btf *btf,
                         char *log_buf, size_t log_sz, __u32 log_level,
-                        int token_fd)
+                        int token_fd, bool btf_mandatory)
 {
        LIBBPF_OPTS(bpf_btf_load_opts, opts);
+       enum libbpf_print_level print_level;
        __u32 buf_sz = 0, raw_size;
        char *buf = NULL, *tmp;
        void *raw_data;
@@ -1435,22 +1436,25 @@ int btf_load_into_kernel(struct btf *btf,
 
        btf->fd = bpf_btf_load(raw_data, raw_size, &opts);
        if (btf->fd < 0) {
-               /* time to turn on verbose mode and try again */
-               if (log_level == 0) {
-                       log_level = 1;
-                       goto retry_load;

tools/lib/bpf/btf.c int btf_load_into_kernel(struct btf *btf, · line 1448

Quoted 10 lines
tools/lib/bpf/btf.c +10 -0
+               if (btf_mandatory) {
+                       /* time to turn on verbose mode and try again */
+                       if (log_level == 0) {
+                               log_level = 1;
+                               goto retry_load;
+                       }
+                       /* only retry if caller didn't provide custom log_buf, but
+                        * make sure we can never overflow buf_sz
+                        */
+                       if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2)

Original behavior was to go from log_level 0 to log_level 1 when the user provided custom log_buf, which would happen even for non-btf_mandatory case. I'd like to not change that behavior.

Did you find some problem with the code I proposed a few emails back? If not, why not do that instead and preserve that custom log_buf and log_level upgrade behavior?

pw-bot: cr

Quoted 63 lines
tools/lib/bpf/btf.c +8 -11
+                               goto retry_load;
                }
-               /* only retry if caller didn't provide custom log_buf, but
-                * make sure we can never overflow buf_sz
-                */
-               if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2)
-                       goto retry_load;
-
                err = -errno;
-               pr_warn("BTF loading error: %s\n", errstr(err));
-               /* don't print out contents of custom log_buf */
-               if (!log_buf && buf[0])
-                       pr_warn("-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n", buf);
+               print_level = btf_mandatory ? LIBBPF_WARN : LIBBPF_INFO;
+               __pr(print_level, "BTF loading error: %s\n", errstr(err));
+               if (!log_buf && log_level)
+                       __pr(print_level,
+                            "-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n",
+                            buf);
        }
 
 done:
@@ -1460,7 +1464,7 @@ int btf_load_into_kernel(struct btf *btf,
 
 int btf__load_into_kernel(struct btf *btf)
 {
-       return btf_load_into_kernel(btf, NULL, 0, 0, 0);
+       return btf_load_into_kernel(btf, NULL, 0, 0, 0, true);
 }
 
 int btf__fd(const struct btf *btf)
tools/lib/bpf/libbpf.c +2 -1
index 8e32286854ef..2cb3f067a12e 100644
@@ -3604,9 +3604,10 @@ static int bpf_object__sanitize_and_load_btf(struct bpf_object *obj)
                 */
                btf__set_fd(kern_btf, 0);
        } else {
+               btf_mandatory = kernel_needs_btf(obj);
                /* currently BPF_BTF_LOAD only supports log_level 1 */
                err = btf_load_into_kernel(kern_btf, obj->log_buf, obj->log_size,
-                                          obj->log_level ? 1 : 0, obj->token_fd);
+                                          obj->log_level ? 1 : 0, obj->token_fd, btf_mandatory);
        }
        if (sanitize) {
                if (!err) {
tools/lib/bpf/libbpf_internal.h +1 -2
index de498e2dd6b0..f1de2ba462c3 100644
@@ -408,7 +408,7 @@ int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
                         int token_fd);
 int btf_load_into_kernel(struct btf *btf,
                         char *log_buf, size_t log_sz, __u32 log_level,
-                        int token_fd);
+                        int token_fd, bool btf_mandatory);
 
 struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf);
 void btf_get_kernel_prefix_kind(enum bpf_attach_type attach_type,
--

2.47.1

#2 lore raw
Quoted 45 lines · Andrii Nakryiko
Quoted 43 lines · Jordan Rome

For kernels where btf is not mandatory we should log loading errors with pr_info and not retry where we increase the log level as this is just added noise.

---
 tools/lib/bpf/btf.c             | 36 ++++++++++++++++++---------------
 tools/lib/bpf/libbpf.c          |  3 ++-
 tools/lib/bpf/libbpf_internal.h |  2 +-
 3 files changed, 23 insertions(+), 18 deletions(-)
tools/lib/bpf/btf.c +8 -5
index eea99c766a20..7da4807451bb 100644
@@ -1379,9 +1379,10 @@ static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endi
 
 int btf_load_into_kernel(struct btf *btf,
                         char *log_buf, size_t log_sz, __u32 log_level,
-                        int token_fd)
+                        int token_fd, bool btf_mandatory)
 {
        LIBBPF_OPTS(bpf_btf_load_opts, opts);
+       enum libbpf_print_level print_level;
        __u32 buf_sz = 0, raw_size;
        char *buf = NULL, *tmp;
        void *raw_data;
@@ -1435,22 +1436,25 @@ int btf_load_into_kernel(struct btf *btf,
 
        btf->fd = bpf_btf_load(raw_data, raw_size, &opts);
        if (btf->fd < 0) {
-               /* time to turn on verbose mode and try again */
-               if (log_level == 0) {
-                       log_level = 1;
-                       goto retry_load;
+               if (btf_mandatory) {
+                       /* time to turn on verbose mode and try again */
+                       if (log_level == 0) {
+                               log_level = 1;
+                               goto retry_load;
+                       }
Quoted 9 lines

tools/lib/bpf/btf.c int btf_load_into_kernel(struct btf *btf, · line 1448

Quoted 4 lines
tools/lib/bpf/btf.c +4 -0
+                       /* only retry if caller didn't provide custom log_buf, but
+                        * make sure we can never overflow buf_sz
+                        */
+                       if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2)

Original behavior was to go from log_level 0 to log_level 1 when the user provided custom log_buf, which would happen even for non-btf_mandatory case. I'd like to not change that behavior.

I don't quite understand why we want to increase the log level if btf is not mandatory. Users will still get an info message that btf failed to load and if they are still curious, they can increase the log level themselves right? The goal of this patch is to reduce log noise in cases where btf fails to load and is not mandatory.

Quoted 1 line

Did you find some problem with the code I proposed a few emails back?

Truth be told, I didn't like the added complexity in the conditionals. I tried something similar in an earlier version and it led to a SEGFAULT when trying to access buf[0] which had not been allocated.

Quoted 68 lines

If not, why not do that instead and preserve that custom log_buf and log_level upgrade behavior?

pw-bot: cr

Quoted 63 lines
tools/lib/bpf/btf.c +8 -11
+                               goto retry_load;
                }
-               /* only retry if caller didn't provide custom log_buf, but
-                * make sure we can never overflow buf_sz
-                */
-               if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2)
-                       goto retry_load;
-
                err = -errno;
-               pr_warn("BTF loading error: %s\n", errstr(err));
-               /* don't print out contents of custom log_buf */
-               if (!log_buf && buf[0])
-                       pr_warn("-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n", buf);
+               print_level = btf_mandatory ? LIBBPF_WARN : LIBBPF_INFO;
+               __pr(print_level, "BTF loading error: %s\n", errstr(err));
+               if (!log_buf && log_level)
+                       __pr(print_level,
+                            "-- BEGIN BTF LOAD LOG ---\n%s\n-- END BTF LOAD LOG --\n",
+                            buf);
        }
 
 done:
@@ -1460,7 +1464,7 @@ int btf_load_into_kernel(struct btf *btf,
 
 int btf__load_into_kernel(struct btf *btf)
 {
-       return btf_load_into_kernel(btf, NULL, 0, 0, 0);
+       return btf_load_into_kernel(btf, NULL, 0, 0, 0, true);
 }
 
 int btf__fd(const struct btf *btf)
tools/lib/bpf/libbpf.c +2 -1
index 8e32286854ef..2cb3f067a12e 100644
@@ -3604,9 +3604,10 @@ static int bpf_object__sanitize_and_load_btf(struct bpf_object *obj)
                 */
                btf__set_fd(kern_btf, 0);
        } else {
+               btf_mandatory = kernel_needs_btf(obj);
                /* currently BPF_BTF_LOAD only supports log_level 1 */
                err = btf_load_into_kernel(kern_btf, obj->log_buf, obj->log_size,
-                                          obj->log_level ? 1 : 0, obj->token_fd);
+                                          obj->log_level ? 1 : 0, obj->token_fd, btf_mandatory);
        }
        if (sanitize) {
                if (!err) {
tools/lib/bpf/libbpf_internal.h +1 -2
index de498e2dd6b0..f1de2ba462c3 100644
@@ -408,7 +408,7 @@ int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
                         int token_fd);
 int btf_load_into_kernel(struct btf *btf,
                         char *log_buf, size_t log_sz, __u32 log_level,
-                        int token_fd);
+                        int token_fd, bool btf_mandatory);
 
 struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf);
 void btf_get_kernel_prefix_kind(enum bpf_attach_type attach_type,
--

2.47.1

#3 lore raw
Quoted 58 lines · Jordan Rome
Quoted 45 lines · Andrii Nakryiko
Quoted 43 lines · Jordan Rome

For kernels where btf is not mandatory we should log loading errors with pr_info and not retry where we increase the log level as this is just added noise.

---
 tools/lib/bpf/btf.c             | 36 ++++++++++++++++++---------------
 tools/lib/bpf/libbpf.c          |  3 ++-
 tools/lib/bpf/libbpf_internal.h |  2 +-
 3 files changed, 23 insertions(+), 18 deletions(-)
tools/lib/bpf/btf.c +8 -5
index eea99c766a20..7da4807451bb 100644
@@ -1379,9 +1379,10 @@ static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endi
 
 int btf_load_into_kernel(struct btf *btf,
                         char *log_buf, size_t log_sz, __u32 log_level,
-                        int token_fd)
+                        int token_fd, bool btf_mandatory)
 {
        LIBBPF_OPTS(bpf_btf_load_opts, opts);
+       enum libbpf_print_level print_level;
        __u32 buf_sz = 0, raw_size;
        char *buf = NULL, *tmp;
        void *raw_data;
@@ -1435,22 +1436,25 @@ int btf_load_into_kernel(struct btf *btf,
 
        btf->fd = bpf_btf_load(raw_data, raw_size, &opts);
        if (btf->fd < 0) {
-               /* time to turn on verbose mode and try again */
-               if (log_level == 0) {
-                       log_level = 1;
-                       goto retry_load;
+               if (btf_mandatory) {
+                       /* time to turn on verbose mode and try again */
+                       if (log_level == 0) {
+                               log_level = 1;
+                               goto retry_load;
+                       }
Quoted 9 lines

tools/lib/bpf/btf.c int btf_load_into_kernel(struct btf *btf, · line 1448

Quoted 4 lines
tools/lib/bpf/btf.c +4 -0
+                       /* only retry if caller didn't provide custom log_buf, but
+                        * make sure we can never overflow buf_sz
+                        */
+                       if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2)

Original behavior was to go from log_level 0 to log_level 1 when the user provided custom log_buf, which would happen even for non-btf_mandatory case. I'd like to not change that behavior.

Quoted 5 lines

I don't quite understand why we want to increase the log level if btf is not mandatory. Users will still get an info message that btf failed to load and if they are still curious, they can increase the log level themselves right? The goal of this patch is to reduce log noise in cases where btf fails to load and is not mandatory.

Program's BTF is almost always not mandatory, so we'll basically never log BTF verification failure (only for struct_ops stuff), even with user-provided custom log buffer, which makes this whole logic much less useful.

Perhaps we just need to keep existing logic as is? It's not expected for BTF to fail to be loaded into the kernel, even for old kernels. libbpf does BTF sanitization for that reason. So when this BTF loading fails, it usually does indicate a real issue.

That's exactly what happened with the original issue that prompted your patches. And that's a good thing that the user was bothered by those warnings, which eventually led to fixing an issue with a missing patch in their backported kernel, right?

Let's just keep things as is for now. I'd rather users complain about this rather than these BTF upload failures go unnoticed forever.

Quoted 12 lines
Quoted 2 lines

Did you find some problem with the code I proposed a few emails back?

Truth be told, I didn't like the added complexity in the conditionals. I tried something similar in an earlier version and it led to a SEGFAULT when trying to access buf[0] which had not been allocated.

Quoted 5 lines

If not, why not do that instead and preserve that custom log_buf and log_level upgrade behavior?

pw-bot: cr

[...]

#4 lore raw
Quoted 76 lines · Andrii Nakryiko
Quoted 58 lines · Jordan Rome
Quoted 45 lines · Andrii Nakryiko
Quoted 43 lines · Jordan Rome

For kernels where btf is not mandatory we should log loading errors with pr_info and not retry where we increase the log level as this is just added noise.

---
 tools/lib/bpf/btf.c             | 36 ++++++++++++++++++---------------
 tools/lib/bpf/libbpf.c          |  3 ++-
 tools/lib/bpf/libbpf_internal.h |  2 +-
 3 files changed, 23 insertions(+), 18 deletions(-)
tools/lib/bpf/btf.c +8 -5
index eea99c766a20..7da4807451bb 100644
@@ -1379,9 +1379,10 @@ static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endi
 
 int btf_load_into_kernel(struct btf *btf,
                         char *log_buf, size_t log_sz, __u32 log_level,
-                        int token_fd)
+                        int token_fd, bool btf_mandatory)
 {
        LIBBPF_OPTS(bpf_btf_load_opts, opts);
+       enum libbpf_print_level print_level;
        __u32 buf_sz = 0, raw_size;
        char *buf = NULL, *tmp;
        void *raw_data;
@@ -1435,22 +1436,25 @@ int btf_load_into_kernel(struct btf *btf,
 
        btf->fd = bpf_btf_load(raw_data, raw_size, &opts);
        if (btf->fd < 0) {
-               /* time to turn on verbose mode and try again */
-               if (log_level == 0) {
-                       log_level = 1;
-                       goto retry_load;
+               if (btf_mandatory) {
+                       /* time to turn on verbose mode and try again */
+                       if (log_level == 0) {
+                               log_level = 1;
+                               goto retry_load;
+                       }
Quoted 9 lines

tools/lib/bpf/btf.c int btf_load_into_kernel(struct btf *btf, · line 1448

Quoted 4 lines
tools/lib/bpf/btf.c +4 -0
+                       /* only retry if caller didn't provide custom log_buf, but
+                        * make sure we can never overflow buf_sz
+                        */
+                       if (!log_buf && errno == ENOSPC && buf_sz <= UINT_MAX / 2)

Original behavior was to go from log_level 0 to log_level 1 when the user provided custom log_buf, which would happen even for non-btf_mandatory case. I'd like to not change that behavior.

Quoted 5 lines

I don't quite understand why we want to increase the log level if btf is not mandatory. Users will still get an info message that btf failed to load and if they are still curious, they can increase the log level themselves right? The goal of this patch is to reduce log noise in cases where btf fails to load and is not mandatory.

Program's BTF is almost always not mandatory, so we'll basically never log BTF verification failure (only for struct_ops stuff), even with user-provided custom log buffer, which makes this whole logic much less useful.

Perhaps we just need to keep existing logic as is? It's not expected for BTF to fail to be loaded into the kernel, even for old kernels. libbpf does BTF sanitization for that reason. So when this BTF loading fails, it usually does indicate a real issue.

Quoted 8 lines

That's exactly what happened with the original issue that prompted your patches. And that's a good thing that the user was bothered by those warnings, which eventually led to fixing an issue with a missing patch in their backported kernel, right?

Let's just keep things as is for now. I'd rather users complain about this rather than these BTF upload failures go unnoticed forever.

Fair enough.

Quoted 14 lines
Quoted 12 lines
Quoted 2 lines

Did you find some problem with the code I proposed a few emails back?

Truth be told, I didn't like the added complexity in the conditionals. I tried something similar in an earlier version and it led to a SEGFAULT when trying to access buf[0] which had not been allocated.

Quoted 5 lines

If not, why not do that instead and preserve that custom log_buf and log_level upgrade behavior?

pw-bot: cr

[...]