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}

 1/* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
 2#include <iostream>
 
 
 
 3#include <bpf/libbpf.h>
 4#include <bpf/bpf.h>
 5#include <bpf/btf.h>
 6#include "test_core_extern.skel.h"
 7
 8/* do nothing, just make sure we can link successfully */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 9
10int main(int argc, char *argv[])
11{
 
12	struct test_core_extern *skel;
 
 
 
 
13
14	/* libbpf.h */
15	libbpf_set_print(NULL);
16
17	/* bpf.h */
18	bpf_prog_get_fd_by_id(0);
19
20	/* btf.h */
21	btf__new(NULL, 0);
 
 
22
23	/* BPF skeleton */
24	skel = test_core_extern__open_and_load();
25	test_core_extern__destroy(skel);
 
 
 
 
 
 
26
27	std::cout << "DONE!" << std::endl;
28
29	return 0;
30}