libbpf: add bpf object kern_version attribute setter
PATCH v3 1/1 libbpf: add bpf object kern_version attribute setter
Unfortunately some distros don't have their kernel version defined accurately in <linux/version.h> due to different long term support reasons.
It is important to have a way to override the bpf kern_version attribute during runtime: some old kernels might still check for kern_version attribute during bpf_prog_load().
--- tools/lib/bpf/libbpf.c | 10 ++++++++++ tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + 3 files changed, 12 insertions(+)
tools/lib/bpf/libbpf.c +10 -0
@@ -8269,6 +8269,16 @@ int bpf_object__btf_fd(const struct bpf_object *obj)return obj->btf ?btf__fd (obj->btf) :-1 ; } +int bpf_object__set_kversion (struct bpf_object *obj,__u32 kern_version) +{ +if (obj->loaded) +return -EINVAL ; + + obj->kern_version = kern_version; + +return 0 ; +} +int bpf_object__set_priv (struct bpf_object *obj,void *priv,bpf_object_clear_priv_t clear_priv) {
tools/lib/bpf/libbpf.h +1 -0
@@ -143,6 +143,7 @@ LIBBPF_API int bpf_object__unload(struct bpf_object *obj); LIBBPF_API const char *bpf_object__name(const struct bpf_object *obj); LIBBPF_API unsigned int bpf_object__kversion(const struct bpf_object *obj); +LIBBPF_API int bpf_object__set_kversion(struct bpf_object *obj, __u32 kern_version);struct btf ; LIBBPF_API struct btf *bpf_object__btf(const struct bpf_object *obj);
tools/lib/bpf/libbpf.map +1 -0
@@ -359,4 +359,5 @@ LIBBPF_0.4.0 { bpf_linker__finalize; bpf_linker__free; bpf_linker__new; + bpf_object__set_kversion; } LIBBPF_0.3.0;
Signature · 1 line
2.27.0
Quoted 8 lines · Rafael David Tinoco
Unfortunately some distros don't have their kernel version defined accurately in <
linux/version.h> due to different long term support reasons.It is important to have a way to override the bpf
kern_versionattribute during runtime: some old kernels might still check forkern_versionattribute duringbpf_prog_load().
Quoted 7 lines
Signed-off-by Rafael David Tinoco <[email protected]>--- tools/lib/bpf/libbpf.c | 10 ++++++++++ tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + 3 files changed, 12 insertions(+)
Hi Andrii and Rafael,
Did you consider making kernel version an attribute of the load API, bpf_prog_load_xattr()? This feels slightly more natural to me, to tell the API the kernel you need at load time.
Although, I don't use the skeleton pieces so maybe it would be awkward for that usage.
Sorry, missed v1,v2 so didn't reply sooner.
Quoted 8 lines
tools/lib/bpf/libbpf.c +0
-0@@ -8269,6 +8269,16 @@ int bpf_object__btf_fd(const struct bpf_object *obj)return obj->btf ?btf__fd (obj->btf) :-1 ; }
tools/lib/bpf/libbpf.c int bpf_object__btf_fd(const struct bpf_object *obj) · line 8281
Quoted 10 lines
tools/lib/bpf/libbpf.c +10
-0+int bpf_object__set_kversion (struct bpf_object *obj,__u32 kern_version) +{ +if (obj->loaded) +return -EINVAL ; + + obj->kern_version = kern_version; + +return 0 ; +} +
Having a test to read uname and feed it into libbpf using above to be sure we don't break this in the future would be nice.
Quoted 28 lines
tools/lib/bpf/libbpf.c +0
-0int bpf_object__set_priv (struct bpf_object *obj,void *priv,bpf_object_clear_priv_t clear_priv) {tools/lib/bpf/libbpf.h +1
-0@@ -143,6 +143,7 @@ LIBBPF_API int bpf_object__unload(struct bpf_object *obj); LIBBPF_API const char *bpf_object__name(const struct bpf_object *obj); LIBBPF_API unsigned int bpf_object__kversion(const struct bpf_object *obj); +LIBBPF_API int bpf_object__set_kversion(struct bpf_object *obj, __u32 kern_version);struct btf ; LIBBPF_API struct btf *bpf_object__btf(const struct bpf_object *obj);tools/lib/bpf/libbpf.map +1
-0@@ -359,4 +359,5 @@ LIBBPF_0.4.0 { bpf_linker__finalize; bpf_linker__free; bpf_linker__new; + bpf_object__set_kversion; } LIBBPF_0.3.0;Signature · 1 line
2.27.0
Quoted 16 lines
Quoted 8 lines
Unfortunately some distros don't have their kernel version defined accurately in <
linux/version.h> due to different long term support reasons.It is important to have a way to override the bpf
kern_versionattribute during runtime: some old kernels might still check forkern_versionattribute duringbpf_prog_load().Quoted 7 lines
Signed-off-by Rafael David Tinoco <[email protected]>--- tools/lib/bpf/libbpf.c | 10 ++++++++++ tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + 3 files changed, 12 insertions(+)
Quoted 5 lines
Hi Andrii and Rafael,
Did you consider making kernel version an attribute of the load API,
bpf_prog_load_xattr()? This feels slightly more natural to me, to tell the API the kernel you need at load time.
Hi John,
This is how I'm using:
https://github.com/rafaeldtinoco/portablebpf/blob/master/mine.c#L285
Quoted 2 lines
Although, I don't use the skeleton pieces so maybe it would be awkward for that usage.
having a xxx_bpf object:
xxx_bpf__open_and_load() -> xxx_bpf__load() -> bpf_object__load_skeleton() -> bpf_object_load() -> bpf_object__loadxattr()
We would have to add kern_version to 'bpf_object_skeleton' struct, to be passed to 'bpf_object__load_skeleton()' to have it passed on.
I'll let Andrii to see what he prefers.
Note:
Reason for all this (including the legacy kprobe logic, in other commit) is to continue the https://github.com/rafaeldtinoco/conntracker/tree/poc-cmd project, making sure it supports 4.x kernels. Still adding bpf support to it (identify task/pid per flow) and will replace the libnf* usage with bpf after that.
Thanks
-rafaeldtinoco
Andrii Nakryiko
Acked-byQuoted 33 lines · Rafael David Tinoco
Quoted 17 lines
Quoted 9 lines
Unfortunately some distros don't have their kernel version defined accurately in <
linux/version.h> due to different long term support reasons.It is important to have a way to override the bpf
kern_versionattribute during runtime: some old kernels might still check forkern_versionattribute duringbpf_prog_load().Quoted 7 lines
Signed-off-by Rafael David Tinoco <[email protected]>--- tools/lib/bpf/libbpf.c | 10 ++++++++++ tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + 3 files changed, 12 insertions(+)Quoted 5 lines
Hi Andrii and Rafael,
Did you consider making kernel version an attribute of the load API,
bpf_prog_load_xattr()? This feels slightly more natural to me, to tell the API the kernel you need at load time.Hi John,
This is how I'm using:
https://github.com/rafaeldtinoco/portablebpf/blob/master/mine.c#L285Quoted 2 lines
Although, I don't use the skeleton pieces so maybe it would be awkward for that usage.
having a
xxx_bpfobject:
Quoted 7 lines
xxx_bpf__open_and_load()->xxx_bpf__load()->bpf_object__load_skeleton()->bpf_object_load()->bpf_object__loadxattr()We would have to add
kern_versionto 'bpf_object_skeleton' struct, to be passed to 'bpf_object__load_skeleton()' to have it passed on.I'll let Andrii to see what he prefers.
See my reply to John. What he asked for already exists. Having a test would be nice, but selftests/bpf don't have an infrastructure to even perform this test, so I don't think it's worth it.
So in summary, LGTM. I'll apply it once bpf-next is ready to accept new patches.
Quoted 12 lines
Note:
Reason for all this (including the legacy kprobe logic, in other commit) is to continue the
https://github.com/rafaeldtinoco/conntracker/tree/poc-cmd project, making sure it supports 4.x kernels. Still adding bpf support to it (identify task/pid per flow) and will replace the libnf* usage with bpf after that.Thanks
-rafaeldtinoco
Quoted 18 lines · John Fastabend
Quoted 8 lines · Rafael David Tinoco
Unfortunately some distros don't have their kernel version defined accurately in <
linux/version.h> due to different long term support reasons.It is important to have a way to override the bpf
kern_versionattribute during runtime: some old kernels might still check forkern_versionattribute duringbpf_prog_load().Quoted 7 lines
Signed-off-by Rafael David Tinoco <[email protected]>--- tools/lib/bpf/libbpf.c | 10 ++++++++++ tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + 3 files changed, 12 insertions(+)
Quoted 5 lines
Hi Andrii and Rafael,
Did you consider making kernel version an attribute of the load API,
bpf_prog_load_xattr()? This feels slightly more natural to me, to tell the API the kernel you need at load time.
Um... kern_version is already part of bpf_load_program_attr, used by bpf_load_program_xattr. What am I missing? But you can't use that with bpf_object APIs.
Quoted 3 lines
Although, I don't use the skeleton pieces so maybe it would be awkward for that usage.
Yes, low-level APIs are separate. This is for cases where you have struct bpf_program abstractions, which are loaded by bpf_object__load(). We could set it at per-program level, but they should be all the same, so bpf_object__set_kversion() makes more sense and is more convenient to use. And there is already a getter for that, so it complements that nicely.
Quoted 11 lines
Sorry, missed v1,v2 so didn't reply sooner.
Quoted 8 lines
tools/lib/bpf/libbpf.c +0
-0@@ -8269,6 +8269,16 @@ int bpf_object__btf_fd(const struct bpf_object *obj)return obj->btf ?btf__fd (obj->btf) :-1 ; }
Quoted 14 lines
tools/lib/bpf/libbpf.c int bpf_object__btf_fd(const struct bpf_object *obj) · line 8281
Quoted 10 lines
tools/lib/bpf/libbpf.c +10
-0+int bpf_object__set_kversion (struct bpf_object *obj,__u32 kern_version) +{ +if (obj->loaded) +return -EINVAL ; + + obj->kern_version = kern_version; + +return 0 ; +} +Having a test to read uname and feed it into libbpf using above to be sure we don't break this in the future would be nice.
kern_version has been ignored by kernel for a long time. So there is no way to test this in selftests/bpf. We could use libbpf CI's old kernel setup to validate, but I don't think it's worth it. It's extremely unlikely this will ever change or break (and it's a legacy stuff we move away from anyways, so it's born sort of obsolete).
Quoted 29 lines
Quoted 29 lines
tools/lib/bpf/libbpf.c +0
-0int bpf_object__set_priv (struct bpf_object *obj,void *priv,bpf_object_clear_priv_t clear_priv) {tools/lib/bpf/libbpf.h +1
-0@@ -143,6 +143,7 @@ LIBBPF_API int bpf_object__unload(struct bpf_object *obj); LIBBPF_API const char *bpf_object__name(const struct bpf_object *obj); LIBBPF_API unsigned int bpf_object__kversion(const struct bpf_object *obj); +LIBBPF_API int bpf_object__set_kversion(struct bpf_object *obj, __u32 kern_version);struct btf ; LIBBPF_API struct btf *bpf_object__btf(const struct bpf_object *obj);tools/lib/bpf/libbpf.map +1
-1@@ -359,4 +359,5 @@ LIBBPF_0.4.0 { bpf_linker__finalize; bpf_linker__free; bpf_linker__new; + bpf_object__set_kversion; } LIBBPF_0.3.0; --2.27.0
John Fastabend
Acked-byQuoted 22 lines · Andrii Nakryiko
Quoted 20 lines · John Fastabend
Quoted 8 lines · Rafael David Tinoco
Unfortunately some distros don't have their kernel version defined accurately in <
linux/version.h> due to different long term support reasons.It is important to have a way to override the bpf
kern_versionattribute during runtime: some old kernels might still check forkern_versionattribute duringbpf_prog_load().Quoted 7 lines
Signed-off-by Rafael David Tinoco <[email protected]>--- tools/lib/bpf/libbpf.c | 10 ++++++++++ tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + 3 files changed, 12 insertions(+)Hi Andrii and Rafael,
Quoted 7 lines
Quoted 3 lines
Did you consider making kernel version an attribute of the load API,
bpf_prog_load_xattr()? This feels slightly more natural to me, to tell the API the kernel you need at load time.Um...
kern_versionis already part ofbpf_load_program_attr, used bybpf_load_program_xattr. What am I missing? But you can't use that withbpf_objectAPIs.
Aha I mistyped. It looks like I have a patch floating around on my stack to add it to bpf_object_load_attr.
Quoted 10 lines
Quoted 3 lines
Although, I don't use the skeleton pieces so maybe it would be awkward for that usage.
Yes, low-level APIs are separate. This is for cases where you have struct
bpf_programabstractions, which are loaded bybpf_object__load(). We could set it at per-program level, but they should be all the same, sobpf_object__set_kversion()makes more sense and is more convenient to use. And there is already a getter for that, so it complements that nicely.
+1
Quoted 27 lines
Quoted 12 lines
Sorry, missed v1,v2 so didn't reply sooner.
Quoted 8 lines
tools/lib/bpf/libbpf.c +0
-0@@ -8269,6 +8269,16 @@ int bpf_object__btf_fd(const struct bpf_object *obj)return obj->btf ?btf__fd (obj->btf) :-1 ; }Quoted 14 lines
tools/lib/bpf/libbpf.c int bpf_object__btf_fd(const struct bpf_object *obj) · line 8281
Quoted 10 lines
tools/lib/bpf/libbpf.c +10
-0+int bpf_object__set_kversion (struct bpf_object *obj,__u32 kern_version) +{ +if (obj->loaded) +return -EINVAL ; + + obj->kern_version = kern_version; + +return 0 ; +} +Having a test to read uname and feed it into libbpf using above to be sure we don't break this in the future would be nice.
Quoted 5 lines
kern_versionhas been ignored by kernel for a long time. So there is no way to test this in selftests/bpf. We could use libbpf CI's old kernel setup to validate, but I don't think it's worth it. It's extremely unlikely this will ever change or break (and it's a legacy stuff we move away from anyways, so it's born sort of obsolete).
+1
For the patch, thanks for the details Andrii, thanks for the patch Rafael it will be useful here.
Quoted 28 lines · John Fastabend
Quoted 26 lines · Andrii Nakryiko
Quoted 23 lines · John Fastabend
Quoted 8 lines · Rafael David Tinoco
Unfortunately some distros don't have their kernel version defined accurately in <
linux/version.h> due to different long term support reasons.It is important to have a way to override the bpf
kern_versionattribute during runtime: some old kernels might still check forkern_versionattribute duringbpf_prog_load().Quoted 7 lines
Signed-off-by Rafael David Tinoco <[email protected]>--- tools/lib/bpf/libbpf.c | 10 ++++++++++ tools/lib/bpf/libbpf.h | 1 + tools/lib/bpf/libbpf.map | 1 + 3 files changed, 12 insertions(+)Hi Andrii and Rafael,
Did you consider making kernel version an attribute of the load API,
bpf_prog_load_xattr()? This feels slightly more natural to me, to tell the API the kernel you need at load time.
Quoted 6 lines
Quoted 3 lines
Um...
kern_versionis already part ofbpf_load_program_attr, used bybpf_load_program_xattr. What am I missing? But you can't use that withbpf_objectAPIs.Aha I mistyped. It looks like I have a patch floating around on my stack to add it to
bpf_object_load_attr.
Oh, you meant this one. I'm actually trying to move away from having load() to take options at all. If you check BPF skeletons, their load doesn't even accept options. Adding getters/setter is better in one major way:
- it's more flexible approach and allows to have both per-object
setters/options and per-program ones. bpf_object_load_attr provides only per-object options, which are often inadequate (see recent bpf_program__set_attach_target() and bpf_program__set_autoload(), which are just impossible to sanely do with per-object options)
- even though we now have the whole forward/backwards compatible
OPTS "framework" within libbpf, I think it's less pleasant to use than setters. We have to do options on load, because we don't have any object before open happens (if we had separate new() and open() that wouldn't be the case), so there is a need to specify things before bpf_object is instantiated. bpf_object__load() doesn't have this problem, because we have entire bpf_object and bpf_map/bpf_program to tweak before we perform load.
- adding new APIs is inherently forward compatible. And backwards
compatibility is the same between OPTS and new API methods: you need to make sure to use recent enough libbpf version that has options/API you need.
So in short, I'm against adding load-time options, because there are better and more flexible alternatives.
Quoted 54 lines
Quoted 6 lines
Quoted 5 lines
Although, I don't use the skeleton pieces so maybe it would be awkward for that usage.
Quoted 6 lines
Yes, low-level APIs are separate. This is for cases where you have struct
bpf_programabstractions, which are loaded bybpf_object__load(). We could set it at per-program level, but they should be all the same, sobpf_object__set_kversion()makes more sense and is more convenient to use. And there is already a getter for that, so it complements that nicely.+1
Quoted 27 lines
Quoted 12 lines
Sorry, missed v1,v2 so didn't reply sooner.
Quoted 8 lines
tools/lib/bpf/libbpf.c +0
-0@@ -8269,6 +8269,16 @@ int bpf_object__btf_fd(const struct bpf_object *obj)return obj->btf ?btf__fd (obj->btf) :-1 ; }Quoted 14 lines
tools/lib/bpf/libbpf.c int bpf_object__btf_fd(const struct bpf_object *obj) · line 8281
Quoted 10 lines
tools/lib/bpf/libbpf.c +10
-0+int bpf_object__set_kversion (struct bpf_object *obj,__u32 kern_version) +{ +if (obj->loaded) +return -EINVAL ; + + obj->kern_version = kern_version; + +return 0 ; +} +Having a test to read uname and feed it into libbpf using above to be sure we don't break this in the future would be nice.
Quoted 5 lines
kern_versionhas been ignored by kernel for a long time. So there is no way to test this in selftests/bpf. We could use libbpf CI's old kernel setup to validate, but I don't think it's worth it. It's extremely unlikely this will ever change or break (and it's a legacy stuff we move away from anyways, so it's born sort of obsolete).+1
For the patch, thanks for the details Andrii, thanks for the patch Rafael it will be useful here.
Acked-by John Fastabend <[email protected]>