Make BPF skeleton easier to use from C++ code
Subsystems (4)
Andrii Nakryiko
maintainerv2 cover Make BPF skeleton easier to use from C++ code
Add minimal C++-specific additions to BPF skeleton codegen to facilitate easier use of C skeletons in C++ applications. These additions don't add any extra ongoing maintenance and allows C++ users to fit pure C skeleton better into their C++ code base. All that without the need to design, implement and support a separate C++ BPF skeleton implementation.
v1->v2:
- use default argument values in T::open() (Alexei).
Andrii Nakryiko (2):
bpftool: add C++-specific open/load/etc skeleton wrappers selftests/bpf: add Skeleton templated wrapper as an example
tools/bpf/bpftool/gen.c | 24 ++++++- tools/testing/selftests/bpf/test_cpp.cpp | 87 +++++++++++++++++++++++- 2 files changed, 107 insertions(+), 4 deletions(-)
Signature · 1 line
2.30.2
Andrii Nakryiko
maintainerPATCH v2 1/2 bpftool: add C++-specific open/load/etc skeleton wrappers
Add C++-specific static methods for code-generated BPF skeleton for each skeleton operation: open, open_opts, open_and_load, load, attach, detach, destroy, and elf_bytes. This is to facilitate easier C++ templating on top of pure C BPF skeleton.
In C, open/load/destroy/etc "methods" are of the form <skeleton_name>__<method>() to avoid name collision with similar "methods" of other skeletons withint the same application. This works well, but is very inconvenient for C++ applications that would like to write generic (templated) wrappers around BPF skeleton to fit in with C++ code base and take advantage of destructors and other convenient C++ constructs.
This patch makes it easier to build such generic templated wrappers by additionally defining C++ static methods for skeleton's struct with fixed names. This allows to refer to, say, open method as T::open() instead of having to somehow generate T__open() function call.
Next patch adds an example template to test_cpp selftest to demonstrate how it's possible to have all the operations wrapped in a generic Skeleton<my_skeleton> type without explicitly passing function references.
An example of generated declaration section without %1$s placeholders:
#ifdef __cplusplus
static struct test_attach_probe *open(const struct bpf_object_open_opts *opts = nullptr);
static struct test_attach_probe *open_and_load();
static int load(struct test_attach_probe *skel);
static int attach(struct test_attach_probe *skel);
static void detach(struct test_attach_probe *skel);
static void destroy(struct test_attach_probe *skel);
static const void *elf_bytes(size_t *sz);
#endif /* __cplusplus */--- tools/bpf/bpftool/gen.c | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-)
tools/bpf/bpftool/gen.c +22 -2
@@ -831,6 +831,16 @@ static int do_skeleton(int argc, char **argv) codegen("\ \n\ + \n\ + #ifdef __cplusplus \n\ + static struct %1$s *open(const struct bpf_object_open_opts *opts = nullptr);\n\ + static struct %1$s *open_and_load(); \n\ + static int load(struct %1$s *skel); \n\ + static int attach(struct %1$s *skel); \n\ + static void detach(struct %1$s *skel); \n\ + static void destroy(struct %1$s *skel); \n\ + static const void *elf_bytes(size_t *sz); \n\ + #endif /* __cplusplus */ \n\ }; \n\ \n\ static void \n\
@@ -1025,9 +1035,19 @@ static int do_skeleton(int argc, char **argv) \"; \n\} \n\ \n\ -#endif /* %s */ \n\ +#ifdef __cplusplus \n\ +struct %1$s *%1$s::open(const struct bpf_object_open_opts *opts) { return %1$s__open_opts(opts); }\n\ +struct %1$s *%1$s::open_and_load() { return %1$s__open_and_load(); } \n\ +int %1$s::load(struct %1$s *skel) { return %1$s__load(skel); } \n\ +int %1$s::attach(struct %1$s *skel) { return %1$s__attach(skel); } \n\ +void %1$s::detach(struct %1$s *skel) { %1$s__detach(skel); } \n\ +void %1$s::destroy(struct %1$s *skel) { %1$s__destroy(skel); } \n\ +const void *%1$s::elf_bytes(size_t *sz) { return %1$s__elf_bytes(sz); } \n\ +#endif /* __cplusplus */ \n\ +\n\ +#endif /* %2$s */ \n\ " , - header_guard); + obj_name, header_guard); err =0 ; out:bpf_object__close (obj);
Signature · 1 line
2.30.2
Andrii Nakryiko
maintainerPATCH v2 2/2 selftests/bpf: add Skeleton templated wrapper as an example
In reply to Andrii NakryikoAdd an example of how to build C++ template-based BPF skeleton wrapper. It's an actually runnable valid use of skeleton through more C++-like interface. Note that skeleton destuction happens implicitly through Skeleton<T>'s destructor.
Also make test_cpp runnable as it would have crashed on invalid btf passed into btf_dump__new().
--- tools/testing/selftests/bpf/test_cpp.cpp | 87 +++++++++++++++++++++++- 1 file changed, 85 insertions(+), 2 deletions(-)
tools/testing/selftests/bpf/test_cpp.cpp +85 -2
@@ -5,18 +5,100 @@ #include <bpf/btf.h> #include "test_core_extern.skel.h" -/* do nothing, just make sure we can link successfully */ +template <typename T> +class Skeleton { +private: + T *skel; +public: + Skeleton(): skel(nullptr) { } + + ~Skeleton() { if (skel) T::destroy(skel); } + + int open(const struct bpf_object_open_opts *opts = nullptr) + { + int err; + + if (skel) + return -EBUSY; + + skel = T::open(opts); + err = libbpf_get_error(skel); + if (err) { + skel = nullptr; + return err; + } + + return 0; + } + + int load() { return T::load(skel); } + + int attach() { return T::attach(skel); } + + void detach() { return T::detach(skel); } + + const T* operator->() const { return skel; } + + T* operator->() { return skel; } + + const T *get() const { return skel; } +}; static void dump_printf(void *ctx, const char *fmt, va_list args) { } +static void try_skeleton_template() +{ + Skeleton<test_core_extern> skel; + std::string prog_name; + int err; + LIBBPF_OPTS(bpf_object_open_opts, opts); + + err = skel.open(&opts); + if (err) { + fprintf(stderr, "Skeleton open failed: %d\n", err); + return; + } + + skel->data->kern_ver = 123; + skel->data->int_val = skel->data->ushort_val; + + err = skel.load(); + if (err) { + fprintf(stderr, "Skeleton load failed: %d\n", err); + return; + } + + if (!skel->kconfig->CONFIG_BPF_SYSCALL) + fprintf(stderr, "Seems like CONFIG_BPF_SYSCALL isn't set?!\n"); + + err = skel.attach(); + if (err) { + fprintf(stderr, "Skeleton attach failed: %d\n", err); + return; + } + + prog_name = bpf_program__name(skel->progs.handle_sys_enter); + if (prog_name != "handle_sys_enter") + fprintf(stderr, "Unexpected program name: %s\n", prog_name.c_str()); + + bpf_link__destroy(skel->links.handle_sys_enter); + skel->links.handle_sys_enter = bpf_program__attach(skel->progs.handle_sys_enter); + + skel.detach(); + + /* destructor will destory underlying skeleton */ +} + int main(int argc, char *argv[]) { struct btf_dump_opts opts = { }; struct test_core_extern *skel; struct btf *btf; + try_skeleton_template(); + /* libbpf.h */ libbpf_set_print(NULL);
@@ -25,7 +107,8 @@ int main(int argc, char *argv[]) /* btf.h */ btf = btf__new(NULL, 0); - btf_dump__new(btf, dump_printf, nullptr, &opts); + if (!libbpf_get_error(btf)) + btf_dump__new(btf, dump_printf, nullptr, &opts); /* BPF skeleton */ skel = test_core_extern__open_and_load();
Signature · 1 line
2.30.2
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Hello:
This series was applied to bpf/bpf-next.git (master) by Alexei Starovoitov <[email protected]>:
Quoted 10 lines · On Fri, 11 Feb 2022 21:57:31 -0800 you wrote:
Add minimal C++-specific additions to BPF skeleton codegen to facilitate easier use of C skeletons in C++ applications. These additions don't add any extra ongoing maintenance and allows C++ users to fit pure C skeleton better into their C++ code base. All that without the need to design, implement and support a separate C++ BPF skeleton implementation.
v1->v2:
- use default argument values inT::open()(Alexei).[...]
Here is the summary with links:
- [v2,bpf-next,1/2] bpftool: add C++-specific open/load/etc skeleton wrappers
https://git.kernel.org/bpf/bpf-next/c/bb8ffe61ea45 - [v2,bpf-next,2/2] selftests/bpf: add Skeleton templated wrapper as an example https://git.kernel.org/bpf/bpf-next/c/189e0ecabc17
You are awesome, thank you!
Signature · 2 lines
Deet-doot-dot, I am a bot. https://korg.docs.kernel.org/patchwork/pwbot.html