* [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code
@ 2022-02-12 5:57 Andrii Nakryiko
2022-02-12 5:57 ` [PATCH v2 bpf-next 1/2] bpftool: add C++-specific open/load/etc skeleton wrappers Andrii Nakryiko
` (2 more replies)
0 siblings, 3 replies; 4+ messages in thread
From: Andrii Nakryiko @ 2022-02-12 5:57 UTC (permalink / raw)
To: bpf, ast, daniel; +Cc: andrii, kernel-team
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(-)
--
2.30.2
^ permalink raw reply [flat|nested] 4+ messages in thread
* [PATCH v2 bpf-next 1/2] bpftool: add C++-specific open/load/etc skeleton wrappers
2022-02-12 5:57 [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code Andrii Nakryiko
@ 2022-02-12 5:57 ` Andrii Nakryiko
2022-02-12 5:57 ` [PATCH v2 bpf-next 2/2] selftests/bpf: add Skeleton templated wrapper as an example Andrii Nakryiko
2022-02-15 18:10 ` [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code patchwork-bot+netdevbpf
2 siblings, 0 replies; 4+ messages in thread
From: Andrii Nakryiko @ 2022-02-12 5:57 UTC (permalink / raw)
To: bpf, ast, daniel; +Cc: andrii, kernel-team
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 */
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
---
tools/bpf/bpftool/gen.c | 24 ++++++++++++++++++++++--
1 file changed, 22 insertions(+), 2 deletions(-)
diff --git a/tools/bpf/bpftool/gen.c b/tools/bpf/bpftool/gen.c
index 6f2e20be0c62..022f30490567 100644
--- a/tools/bpf/bpftool/gen.c
+++ b/tools/bpf/bpftool/gen.c
@@ -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);
--
2.30.2
^ permalink raw reply related [flat|nested] 4+ messages in thread
* [PATCH v2 bpf-next 2/2] selftests/bpf: add Skeleton templated wrapper as an example
2022-02-12 5:57 [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code Andrii Nakryiko
2022-02-12 5:57 ` [PATCH v2 bpf-next 1/2] bpftool: add C++-specific open/load/etc skeleton wrappers Andrii Nakryiko
@ 2022-02-12 5:57 ` Andrii Nakryiko
2022-02-15 18:10 ` [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code patchwork-bot+netdevbpf
2 siblings, 0 replies; 4+ messages in thread
From: Andrii Nakryiko @ 2022-02-12 5:57 UTC (permalink / raw)
To: bpf, ast, daniel; +Cc: andrii, kernel-team
Add 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().
Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
---
tools/testing/selftests/bpf/test_cpp.cpp | 87 +++++++++++++++++++++++-
1 file changed, 85 insertions(+), 2 deletions(-)
diff --git a/tools/testing/selftests/bpf/test_cpp.cpp b/tools/testing/selftests/bpf/test_cpp.cpp
index e00201de2890..773f165c4898 100644
--- a/tools/testing/selftests/bpf/test_cpp.cpp
+++ b/tools/testing/selftests/bpf/test_cpp.cpp
@@ -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();
--
2.30.2
^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code
2022-02-12 5:57 [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code Andrii Nakryiko
2022-02-12 5:57 ` [PATCH v2 bpf-next 1/2] bpftool: add C++-specific open/load/etc skeleton wrappers Andrii Nakryiko
2022-02-12 5:57 ` [PATCH v2 bpf-next 2/2] selftests/bpf: add Skeleton templated wrapper as an example Andrii Nakryiko
@ 2022-02-15 18:10 ` patchwork-bot+netdevbpf
2 siblings, 0 replies; 4+ messages in thread
From: patchwork-bot+netdevbpf @ 2022-02-15 18:10 UTC (permalink / raw)
To: Andrii Nakryiko; +Cc: bpf, ast, daniel, kernel-team
Hello:
This series was applied to bpf/bpf-next.git (master)
by Alexei Starovoitov <ast@kernel.org>:
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 in T::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!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2022-02-15 18:10 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2022-02-12 5:57 [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code Andrii Nakryiko
2022-02-12 5:57 ` [PATCH v2 bpf-next 1/2] bpftool: add C++-specific open/load/etc skeleton wrappers Andrii Nakryiko
2022-02-12 5:57 ` [PATCH v2 bpf-next 2/2] selftests/bpf: add Skeleton templated wrapper as an example Andrii Nakryiko
2022-02-15 18:10 ` [PATCH v2 bpf-next 0/2] Make BPF skeleton easier to use from C++ code patchwork-bot+netdevbpf
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).