Loading...
1/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
2#include <iostream>
3#include <unistd.h>
4#include <linux/bpf.h>
5#include <linux/btf.h>
6#include <bpf/libbpf.h>
7#include <bpf/bpf.h>
8#include <bpf/btf.h>
9
10#ifndef _Bool
11#define _Bool bool
12#endif
13#include "test_core_extern.skel.h"
14#include "struct_ops_module.skel.h"
15
16template <typename T>
17class Skeleton {
18private:
19 T *skel;
20public:
21 Skeleton(): skel(nullptr) { }
22
23 ~Skeleton() { if (skel) T::destroy(skel); }
24
25 int open(const struct bpf_object_open_opts *opts = nullptr)
26 {
27 int err;
28
29 if (skel)
30 return -EBUSY;
31
32 skel = T::open(opts);
33 err = libbpf_get_error(skel);
34 if (err) {
35 skel = nullptr;
36 return err;
37 }
38
39 return 0;
40 }
41
42 int load() { return T::load(skel); }
43
44 int attach() { return T::attach(skel); }
45
46 void detach() { return T::detach(skel); }
47
48 const T* operator->() const { return skel; }
49
50 T* operator->() { return skel; }
51
52 const T *get() const { return skel; }
53};
54
55static void dump_printf(void *ctx, const char *fmt, va_list args)
56{
57}
58
59static void try_skeleton_template()
60{
61 Skeleton<test_core_extern> skel;
62 std::string prog_name;
63 int err;
64 LIBBPF_OPTS(bpf_object_open_opts, opts);
65
66 err = skel.open(&opts);
67 if (err) {
68 fprintf(stderr, "Skeleton open failed: %d\n", err);
69 return;
70 }
71
72 skel->data->kern_ver = 123;
73 skel->data->int_val = skel->data->ushort_val;
74
75 err = skel.load();
76 if (err) {
77 fprintf(stderr, "Skeleton load failed: %d\n", err);
78 return;
79 }
80
81 if (!skel->kconfig->CONFIG_BPF_SYSCALL)
82 fprintf(stderr, "Seems like CONFIG_BPF_SYSCALL isn't set?!\n");
83
84 err = skel.attach();
85 if (err) {
86 fprintf(stderr, "Skeleton attach failed: %d\n", err);
87 return;
88 }
89
90 prog_name = bpf_program__name(skel->progs.handle_sys_enter);
91 if (prog_name != "handle_sys_enter")
92 fprintf(stderr, "Unexpected program name: %s\n", prog_name.c_str());
93
94 bpf_link__destroy(skel->links.handle_sys_enter);
95 skel->links.handle_sys_enter = bpf_program__attach(skel->progs.handle_sys_enter);
96
97 skel.detach();
98
99 /* destructor will destroy underlying skeleton */
100}
101
102int main(int argc, char *argv[])
103{
104 struct btf_dump_opts opts = { };
105 struct test_core_extern *skel;
106 struct struct_ops_module *skel2;
107 struct btf *btf;
108 int fd;
109
110 try_skeleton_template();
111
112 /* libbpf.h */
113 libbpf_set_print(NULL);
114
115 /* bpf.h */
116 bpf_prog_get_fd_by_id(0);
117
118 /* btf.h */
119 btf = btf__new(NULL, 0);
120 if (!libbpf_get_error(btf))
121 btf_dump__new(btf, dump_printf, nullptr, &opts);
122
123 /* BPF skeleton */
124 skel = test_core_extern__open_and_load();
125 test_core_extern__destroy(skel);
126
127 skel2 = struct_ops_module__open_and_load();
128 struct_ops_module__destroy(skel2);
129
130 fd = bpf_enable_stats(BPF_STATS_RUN_TIME);
131 if (fd < 0)
132 std::cout << "FAILED to enable stats: " << fd << std::endl;
133 else
134 ::close(fd);
135
136 std::cout << "DONE!" << std::endl;
137
138 return 0;
139}
1/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
2#include <iostream>
3#include <unistd.h>
4#include <linux/bpf.h>
5#include <linux/btf.h>
6#include <bpf/libbpf.h>
7#include <bpf/bpf.h>
8#include <bpf/btf.h>
9#include "test_core_extern.skel.h"
10
11template <typename T>
12class Skeleton {
13private:
14 T *skel;
15public:
16 Skeleton(): skel(nullptr) { }
17
18 ~Skeleton() { if (skel) T::destroy(skel); }
19
20 int open(const struct bpf_object_open_opts *opts = nullptr)
21 {
22 int err;
23
24 if (skel)
25 return -EBUSY;
26
27 skel = T::open(opts);
28 err = libbpf_get_error(skel);
29 if (err) {
30 skel = nullptr;
31 return err;
32 }
33
34 return 0;
35 }
36
37 int load() { return T::load(skel); }
38
39 int attach() { return T::attach(skel); }
40
41 void detach() { return T::detach(skel); }
42
43 const T* operator->() const { return skel; }
44
45 T* operator->() { return skel; }
46
47 const T *get() const { return skel; }
48};
49
50static void dump_printf(void *ctx, const char *fmt, va_list args)
51{
52}
53
54static void try_skeleton_template()
55{
56 Skeleton<test_core_extern> skel;
57 std::string prog_name;
58 int err;
59 LIBBPF_OPTS(bpf_object_open_opts, opts);
60
61 err = skel.open(&opts);
62 if (err) {
63 fprintf(stderr, "Skeleton open failed: %d\n", err);
64 return;
65 }
66
67 skel->data->kern_ver = 123;
68 skel->data->int_val = skel->data->ushort_val;
69
70 err = skel.load();
71 if (err) {
72 fprintf(stderr, "Skeleton load failed: %d\n", err);
73 return;
74 }
75
76 if (!skel->kconfig->CONFIG_BPF_SYSCALL)
77 fprintf(stderr, "Seems like CONFIG_BPF_SYSCALL isn't set?!\n");
78
79 err = skel.attach();
80 if (err) {
81 fprintf(stderr, "Skeleton attach failed: %d\n", err);
82 return;
83 }
84
85 prog_name = bpf_program__name(skel->progs.handle_sys_enter);
86 if (prog_name != "handle_sys_enter")
87 fprintf(stderr, "Unexpected program name: %s\n", prog_name.c_str());
88
89 bpf_link__destroy(skel->links.handle_sys_enter);
90 skel->links.handle_sys_enter = bpf_program__attach(skel->progs.handle_sys_enter);
91
92 skel.detach();
93
94 /* destructor will destroy underlying skeleton */
95}
96
97int main(int argc, char *argv[])
98{
99 struct btf_dump_opts opts = { };
100 struct test_core_extern *skel;
101 struct btf *btf;
102 int fd;
103
104 try_skeleton_template();
105
106 /* libbpf.h */
107 libbpf_set_print(NULL);
108
109 /* bpf.h */
110 bpf_prog_get_fd_by_id(0);
111
112 /* btf.h */
113 btf = btf__new(NULL, 0);
114 if (!libbpf_get_error(btf))
115 btf_dump__new(btf, dump_printf, nullptr, &opts);
116
117 /* BPF skeleton */
118 skel = test_core_extern__open_and_load();
119 test_core_extern__destroy(skel);
120
121 fd = bpf_enable_stats(BPF_STATS_RUN_TIME);
122 if (fd < 0)
123 std::cout << "FAILED to enable stats: " << fd << std::endl;
124 else
125 ::close(fd);
126
127 std::cout << "DONE!" << std::endl;
128
129 return 0;
130}