Skip to contentSkip to conversation

perf tools: Fix perf build with dynamic libbpf

PATCH In review Jiri Olsa 4 participants 10 messages Nov 9, 2021 – Nov 13, 2021 perf events

lore
Share & tools
lore

Jiri Olsa

author
#0 lore raw

cover perf tools: Fix perf build with dynamic libbpf

hi,
sending fixes for building perf with LIBBPF_DYNAMIC=1.

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf. Fixing this with adding weak stub functions for possibly missing libbpf function.

thanks,
jirka

---
Jiri Olsa (2):
perf tools: Add more weak libbpf functions
perf tools: Add weak variants for the deprecated libbpf functions

 tools/perf/util/bpf-event.c | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
author
#1 lore raw

PATCH 1/2 perf tools: Add more weak libbpf functions

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf.

Fixing this by providing the new interface as weak functions which calls the original libbpf functions. Fortunatelly the changes were just renames.

---
 tools/perf/util/bpf-event.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
tools/perf/util/bpf-event.c +27 -0
index 4d3b4cdce176..ceb96360fd12 100644
@@ -33,6 +33,33 @@ struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
        return err ? ERR_PTR(err) : btf;
 }
 
+struct bpf_program * __weak
+bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+	return bpf_program__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+struct bpf_map * __weak
+bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+	return bpf_map__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+const void * __weak
+btf__raw_data(const struct btf *btf_ro, __u32 *size)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+	return btf__get_raw_data(btf_ro, size);
+#pragma GCC diagnostic pop
+}
+
 static int snprintf_hex(char *buf, size_t size, unsigned char *data, size_t len)
 {
 	int ret = 0;
Signature · 1 line
2.31.1
reviewer
#2 lore raw

Re: [PATCH 1/2] perf tools: Add more weak libbpf functions

Quoted 8 lines · Jiri Olsa

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf.

Fixing this by providing the new interface as weak functions which calls the original libbpf functions. Fortunatelly the changes were just renames.

Could we just provide these functions behind a libbpf version #if ? Weak symbols break things in subtle ways, under certain circumstances the weak symbol is preferred over the strong due to lazy object file resolution:
https://maskray.me/blog/2021-06-20-symbol-processing#archive-processing
This bit me last week, but in general you get away with it as the lazy object file will get processed in an archive exposing the strong symbol. With an #if you either get a linker error for 2 definitions or 0 definitions, and it's clear what is broken.

In the past we had problems due to constant propagation from weak const variables, where #if was the solution:
https://lore.kernel.org/lkml/[email protected]/

There was some recent conversation on libbpf version for pahole here:
https://lore.kernel.org/bpf/CAP-5=fUc3LtU0WYg-Py9Jf+9picaWHJdSw=sdOMA54uY3p1pdw@mail.gmail.com/T/
https://lore.kernel.org/bpf/[email protected]/

Thanks,
Ian

Quoted 46 lines
---
 tools/perf/util/bpf-event.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
tools/perf/util/bpf-event.c +27 -1
index 4d3b4cdce176..ceb96360fd12 100644
@@ -33,6 +33,33 @@ struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
        return err ? ERR_PTR(err) : btf;
 }
 
+struct bpf_program * __weak
+bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_program__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+struct bpf_map * __weak
+bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_map__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+const void * __weak
+btf__raw_data(const struct btf *btf_ro, __u32 *size)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return btf__get_raw_data(btf_ro, size);
+#pragma GCC diagnostic pop
+}
+
 static int snprintf_hex(char *buf, size_t size, unsigned char *data, size_t len)
 {
        int ret = 0;
--

2.31.1

#3 lore raw

Re: [PATCH 1/2] perf tools: Add more weak libbpf functions

Quoted 61 lines · Ian Rogers
Quoted 8 lines · Jiri Olsa

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf.

Fixing this by providing the new interface as weak functions which calls the original libbpf functions. Fortunatelly the changes were just renames.

Could we just provide these functions behind a libbpf version #if ? Weak symbols break things in subtle ways, under certain circumstances the weak symbol is preferred over the strong due to lazy object file resolution:
https://maskray.me/blog/2021-06-20-symbol-processing#archive-processing
This bit me last week, but in general you get away with it as the lazy object file will get processed in an archive exposing the strong symbol. With an #if you either get a linker error for 2 definitions or 0 definitions, and it's clear what is broken.

In the past we had problems due to constant propagation from weak const variables, where #if was the solution:
https://lore.kernel.org/lkml/[email protected]/

There was some recent conversation on libbpf version for pahole here:
https://lore.kernel.org/bpf/CAP-5=fUc3LtU0WYg-Py9Jf+9picaWHJdSw=sdOMA54uY3p1pdw@mail.gmail.com/T/
https://lore.kernel.org/bpf/[email protected]/

Thanks,
Ian

Quoted 29 lines
---
 tools/perf/util/bpf-event.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
tools/perf/util/bpf-event.c +16 -0
index 4d3b4cdce176..ceb96360fd12 100644
@@ -33,6 +33,33 @@ struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
        return err ? ERR_PTR(err) : btf;
 }
 
+struct bpf_program * __weak
+bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_program__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+struct bpf_map * __weak
+bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_map__next(prev, obj);
+#pragma GCC diagnostic pop
Quoted 8 lines

tools/perf/util/bpf-event.c struct btf * __weak btf__load_from_kernel_by_id(__u32 id) · line 59

Quoted 8 lines
tools/perf/util/bpf-event.c +8 -0
+}
+
+const void * __weak
+btf__raw_data(const struct btf *btf_ro, __u32 *size)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return btf__get_raw_data(btf_ro, size);

you can still use old variants for the time being, if you want. Were new APIs used accidentally? Libbpf maintains a guarantee that if some API is deprecated in favor of the new one, there will be at least one full libbpf release where both APIs are available and not marked as deprecated.

Quoted 9 lines
Quoted 9 lines
tools/perf/util/bpf-event.c +3 -1
+#pragma GCC diagnostic pop
+}
+
 static int snprintf_hex(char *buf, size_t size, unsigned char *data, size_t len)
 {
        int ret = 0;
--

2.31.1

author
#4 lore raw

Re: [PATCH 1/2] perf tools: Add more weak libbpf functions

Quoted 68 lines · Andrii Nakryiko
Quoted 67 lines · Ian Rogers
Quoted 8 lines · Jiri Olsa

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf.

Fixing this by providing the new interface as weak functions which calls the original libbpf functions. Fortunatelly the changes were just renames.

Could we just provide these functions behind a libbpf version #if ? Weak symbols break things in subtle ways, under certain circumstances the weak symbol is preferred over the strong due to lazy object file resolution:
https://maskray.me/blog/2021-06-20-symbol-processing#archive-processing
This bit me last week, but in general you get away with it as the lazy object file will get processed in an archive exposing the strong symbol. With an #if you either get a linker error for 2 definitions or 0 definitions, and it's clear what is broken.

In the past we had problems due to constant propagation from weak const variables, where #if was the solution:
https://lore.kernel.org/lkml/[email protected]/

There was some recent conversation on libbpf version for pahole here:
https://lore.kernel.org/bpf/CAP-5=fUc3LtU0WYg-Py9Jf+9picaWHJdSw=sdOMA54uY3p1pdw@mail.gmail.com/T/
https://lore.kernel.org/bpf/[email protected]/

Thanks,
Ian

Quoted 35 lines
---
 tools/perf/util/bpf-event.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
tools/perf/util/bpf-event.c +22 -0
index 4d3b4cdce176..ceb96360fd12 100644
@@ -33,6 +33,33 @@ struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
        return err ? ERR_PTR(err) : btf;
 }
 
+struct bpf_program * __weak
+bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_program__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+struct bpf_map * __weak
+bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_map__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+const void * __weak
+btf__raw_data(const struct btf *btf_ro, __u32 *size)
+{
+#pragma GCC diagnostic push
Quoted 8 lines
Quoted 2 lines

tools/perf/util/bpf-event.c struct btf * __weak btf__load_from_kernel_by_id(__u32 id) · line 59

Quoted 2 lines
tools/perf/util/bpf-event.c +2 -0
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return btf__get_raw_data(btf_ro, size);

you can still use old variants for the time being, if you want. Were new APIs used accidentally? Libbpf maintains a guarantee that if some API is deprecated in favor of the new one, there will be at least one full libbpf release where both APIs are available and not marked as deprecated.

we could use old api instead of btf__raw_data, we could just revert the perf change

but bpf_object__next_program and bpf_object__next_map are used through macros like bpf_object__for_each_map or bpf_object__for_each_program, so we'd need to define 'old versions' of them

jirka

Quoted 12 lines
Quoted 11 lines
Quoted 11 lines
tools/perf/util/bpf-event.c +3 -1
+#pragma GCC diagnostic pop
+}
+
 static int snprintf_hex(char *buf, size_t size, unsigned char *data, size_t len)
 {
        int ret = 0;
--

2.31.1

#5 lore raw

Re: [PATCH 1/2] perf tools: Add more weak libbpf functions

Quoted 79 lines · Jiri Olsa
Quoted 68 lines · Andrii Nakryiko
Quoted 67 lines · Ian Rogers
Quoted 8 lines · Jiri Olsa

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf.

Fixing this by providing the new interface as weak functions which calls the original libbpf functions. Fortunatelly the changes were just renames.

Could we just provide these functions behind a libbpf version #if ? Weak symbols break things in subtle ways, under certain circumstances the weak symbol is preferred over the strong due to lazy object file resolution:
https://maskray.me/blog/2021-06-20-symbol-processing#archive-processing
This bit me last week, but in general you get away with it as the lazy object file will get processed in an archive exposing the strong symbol. With an #if you either get a linker error for 2 definitions or 0 definitions, and it's clear what is broken.

In the past we had problems due to constant propagation from weak const variables, where #if was the solution:
https://lore.kernel.org/lkml/[email protected]/

There was some recent conversation on libbpf version for pahole here:
https://lore.kernel.org/bpf/CAP-5=fUc3LtU0WYg-Py9Jf+9picaWHJdSw=sdOMA54uY3p1pdw@mail.gmail.com/T/
https://lore.kernel.org/bpf/[email protected]/

Thanks,
Ian

Quoted 35 lines
---
 tools/perf/util/bpf-event.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
tools/perf/util/bpf-event.c +22 -0
index 4d3b4cdce176..ceb96360fd12 100644
@@ -33,6 +33,33 @@ struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
        return err ? ERR_PTR(err) : btf;
 }
 
+struct bpf_program * __weak
+bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_program__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+struct bpf_map * __weak
+bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_map__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+const void * __weak
+btf__raw_data(const struct btf *btf_ro, __u32 *size)
+{
+#pragma GCC diagnostic push
Quoted 8 lines
Quoted 2 lines

tools/perf/util/bpf-event.c struct btf * __weak btf__load_from_kernel_by_id(__u32 id) · line 59

Quoted 2 lines
tools/perf/util/bpf-event.c +2 -0
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return btf__get_raw_data(btf_ro, size);

you can still use old variants for the time being, if you want. Were new APIs used accidentally? Libbpf maintains a guarantee that if some API is deprecated in favor of the new one, there will be at least one full libbpf release where both APIs are available and not marked as deprecated.

Quoted 6 lines

we could use old api instead of btf__raw_data, we could just revert the perf change

but bpf_object__next_program and bpf_object__next_map are used through macros like bpf_object__for_each_map or bpf_object__for_each_program, so we'd need to define 'old versions' of them

There is nothing magical about bpf_object__for_each_map(). If it's causing problems, just implement your own iteration logic. You'll be suffering like this because you are trying to support both shared library mode and static library mode with libbpf. I'm sorry for your pain, but you are trying to compile against the latest unreleased headers, yet work properly with older released libbpf shared library. It's painful and you know what I think about using shared libraries, right?

Quoted 16 lines

jirka

Quoted 12 lines
Quoted 11 lines
Quoted 11 lines
tools/perf/util/bpf-event.c +3 -1
+#pragma GCC diagnostic pop
+}
+
 static int snprintf_hex(char *buf, size_t size, unsigned char *data, size_t len)
 {
        int ret = 0;
--

2.31.1

author
#6 lore raw

Re: [PATCH 1/2] perf tools: Add more weak libbpf functions

Quoted 83 lines · Andrii Nakryiko
Quoted 82 lines · Jiri Olsa
Quoted 68 lines · Andrii Nakryiko
Quoted 67 lines · Ian Rogers
Quoted 8 lines · Jiri Olsa

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf.

Fixing this by providing the new interface as weak functions which calls the original libbpf functions. Fortunatelly the changes were just renames.

Could we just provide these functions behind a libbpf version #if ? Weak symbols break things in subtle ways, under certain circumstances the weak symbol is preferred over the strong due to lazy object file resolution:
https://maskray.me/blog/2021-06-20-symbol-processing#archive-processing
This bit me last week, but in general you get away with it as the lazy object file will get processed in an archive exposing the strong symbol. With an #if you either get a linker error for 2 definitions or 0 definitions, and it's clear what is broken.

In the past we had problems due to constant propagation from weak const variables, where #if was the solution:
https://lore.kernel.org/lkml/[email protected]/

There was some recent conversation on libbpf version for pahole here:
https://lore.kernel.org/bpf/CAP-5=fUc3LtU0WYg-Py9Jf+9picaWHJdSw=sdOMA54uY3p1pdw@mail.gmail.com/T/
https://lore.kernel.org/bpf/[email protected]/

Thanks,
Ian

Quoted 35 lines
---
 tools/perf/util/bpf-event.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
tools/perf/util/bpf-event.c +22 -0
index 4d3b4cdce176..ceb96360fd12 100644
@@ -33,6 +33,33 @@ struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
        return err ? ERR_PTR(err) : btf;
 }
 
+struct bpf_program * __weak
+bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_program__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+struct bpf_map * __weak
+bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_map__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+const void * __weak
+btf__raw_data(const struct btf *btf_ro, __u32 *size)
+{
+#pragma GCC diagnostic push
Quoted 8 lines
Quoted 2 lines

tools/perf/util/bpf-event.c struct btf * __weak btf__load_from_kernel_by_id(__u32 id) · line 59

Quoted 2 lines
tools/perf/util/bpf-event.c +2 -0
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return btf__get_raw_data(btf_ro, size);

you can still use old variants for the time being, if you want. Were new APIs used accidentally? Libbpf maintains a guarantee that if some API is deprecated in favor of the new one, there will be at least one full libbpf release where both APIs are available and not marked as deprecated.

we could use old api instead of btf__raw_data, we could just revert the perf change

Quoted 6 lines
Quoted 3 lines

but bpf_object__next_program and bpf_object__next_map are used through macros like bpf_object__for_each_map or bpf_object__for_each_program, so we'd need to define 'old versions' of them

There is nothing magical about bpf_object__for_each_map(). If it's causing problems, just implement your own iteration logic. You'll be

ok

Quoted 6 lines

suffering like this because you are trying to support both shared library mode and static library mode with libbpf. I'm sorry for your pain, but you are trying to compile against the latest unreleased headers, yet work properly with older released libbpf shared library. It's painful and you know what I think about using shared libraries, right?

you are not a fan.. ;-)

thanks,
jirka

author
#7 lore raw

Re: [PATCH 1/2] perf tools: Add more weak libbpf functions

In reply to Ian Rogers
Quoted 10 lines · Ian Rogers
Quoted 8 lines · Jiri Olsa

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf.

Fixing this by providing the new interface as weak functions which calls the original libbpf functions. Fortunatelly the changes were just renames.

Quoted 9 lines

Could we just provide these functions behind a libbpf version #if ? Weak symbols break things in subtle ways, under certain circumstances the weak symbol is preferred over the strong due to lazy object file resolution:
https://maskray.me/blog/2021-06-20-symbol-processing#archive-processing
This bit me last week, but in general you get away with it as the lazy object file will get processed in an archive exposing the strong symbol. With an #if you either get a linker error for 2 definitions or 0 definitions, and it's clear what is broken.

hum, I see 2 problems..

usinf #if works nicely for btf__raw_data because it's used directly, but bpf_object__next_program and bpf_object__next_map are used through macros:

   #define bpf_object__for_each_map(pos, obj)              \
        for ((pos) = bpf_object__next_map((obj), NULL); \
             (pos) != NULL;                             \
             (pos) = bpf_object__next_map((obj), (pos)))

   #define bpf_object__for_each_program(pos, obj)                  \
        for ((pos) = bpf_object__next_program((obj), NULL);     \
             (pos) != NULL;                                     \
             (pos) = bpf_object__next_program((obj), (pos)))

we would need to provide 'old version' macro as well

another issue is more disturbing.. compiling with LIBBPF_DYNAMIC=1 still seems to take the in-kernel bpf headers, because we use

  -I$(KTREE)/tools/lib

so any include with '<bpf/...> will pick up the kernel version and not the one in /usr/include, perhaps the order of '-I...' could help, I need to check

jirka

Quoted 59 lines

In the past we had problems due to constant propagation from weak const variables, where #if was the solution:
https://lore.kernel.org/lkml/[email protected]/

There was some recent conversation on libbpf version for pahole here:
https://lore.kernel.org/bpf/CAP-5=fUc3LtU0WYg-Py9Jf+9picaWHJdSw=sdOMA54uY3p1pdw@mail.gmail.com/T/
https://lore.kernel.org/bpf/[email protected]/

Thanks,
Ian

Quoted 46 lines
---
 tools/perf/util/bpf-event.c | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
tools/perf/util/bpf-event.c +27 -1
index 4d3b4cdce176..ceb96360fd12 100644
@@ -33,6 +33,33 @@ struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
        return err ? ERR_PTR(err) : btf;
 }
 
+struct bpf_program * __weak
+bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_program__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+struct bpf_map * __weak
+bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return bpf_map__next(prev, obj);
+#pragma GCC diagnostic pop
+}
+
+const void * __weak
+btf__raw_data(const struct btf *btf_ro, __u32 *size)
+{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+       return btf__get_raw_data(btf_ro, size);
+#pragma GCC diagnostic pop
+}
+
 static int snprintf_hex(char *buf, size_t size, unsigned char *data, size_t len)
 {
        int ret = 0;
--

2.31.1

#8 lore raw

Re: [PATCH 1/2] perf tools: Add more weak libbpf functions

In reply to Ian Rogers

Em Tue, Nov 09, 2021 at 10:49:53AM -0800, Ian Rogers escreveu:

Quoted 20 lines · Jiri Olsa
Quoted 8 lines

We hit the window where perf uses libbpf functions, that did not make it to the official libbpf release yet and it's breaking perf build with dynamicly linked libbpf.

Fixing this by providing the new interface as weak functions which calls the original libbpf functions. Fortunatelly the changes were just renames.

Could we just provide these functions behind a libbpf version #if ? Weak symbols break things in subtle ways, under certain circumstances the weak symbol is preferred over the strong due to lazy object file resolution:
https://maskray.me/blog/2021-06-20-symbol-processing#archive-processing
This bit me last week, but in general you get away with it as the lazy object file will get processed in an archive exposing the strong symbol. With an #if you either get a linker error for 2 definitions or 0 definitions, and it's clear what is broken.

Quoted 7 lines

In the past we had problems due to constant propagation from weak const variables, where #if was the solution:
https://lore.kernel.org/lkml/[email protected]/

There was some recent conversation on libbpf version for pahole here:
https://lore.kernel.org/bpf/CAP-5=fUc3LtU0WYg-Py9Jf+9picaWHJdSw=sdOMA54uY3p1pdw@mail.gmail.com/T/
https://lore.kernel.org/bpf/[email protected]/

Valid concerns and we should improve the situation, but I'm going with Jiri's stopgap solution so as to have everything buildind for v5.16, which window is closing.

We can improve this in followup patches.

Thanks,

- Arnaldo

author
#9 lore raw

PATCH 2/2 perf tools: Add weak variants for the deprecated libbpf functions

In reply to Jiri Olsa

Adding weak functions for deprecated libbpf functions, so that we don't get build fail with libbpf version where they are finally removed.

---
 tools/perf/util/bpf-event.c | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
tools/perf/util/bpf-event.c +33 -0
index ceb96360fd12..476427f3e804 100644
@@ -22,6 +22,20 @@
 #include "record.h"
 #include "util/synthetic-events.h"
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wredundant-decls"
+int btf__get_from_id(__u32 id, struct btf **btf);
+struct bpf_program *bpf_program__next(struct bpf_program *prog,
+				      const struct bpf_object *obj);
+struct bpf_map *bpf_map__next(const struct bpf_map *map, const struct bpf_object *obj);
+const void *btf__get_raw_data(const struct btf *btf, __u32 *size);
+#pragma GCC diagnostic pop
+
+int __weak btf__get_from_id(__u32 id __maybe_unused, struct btf **btf __maybe_unused)
+{
+	return -ENOTSUP;
+}
+
 struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
 {
        struct btf *btf;
@@ -33,6 +47,13 @@ struct btf * __weak btf__load_from_kernel_by_id(__u32 id)
        return err ? ERR_PTR(err) : btf;
 }
 
+struct bpf_program * __weak
+bpf_program__next(struct bpf_program *prog __maybe_unused,
+		  const struct bpf_object *obj __maybe_unused)
+{
+	return NULL;
+}
+
 struct bpf_program * __weak
 bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
 {
@@ -42,6 +63,12 @@ bpf_object__next_program(const struct bpf_object *obj, struct bpf_program *prev)
 #pragma GCC diagnostic pop
 }
 
+struct bpf_map * __weak bpf_map__next(const struct bpf_map *map __maybe_unused,
+				      const struct bpf_object *obj __maybe_unused)
+{
+	return NULL;
+}
+
 struct bpf_map * __weak
 bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
 {
@@ -51,6 +78,12 @@ bpf_object__next_map(const struct bpf_object *obj, const struct bpf_map *prev)
 #pragma GCC diagnostic pop
 }
 
+const void * __weak btf__get_raw_data(const struct btf *btf __maybe_unused,
+				      __u32 *size __maybe_unused)
+{
+	return NULL;
+}
+
 const void * __weak
 btf__raw_data(const struct btf *btf_ro, __u32 *size)
 {
Signature · 1 line
2.31.1