mirror/libbpf
1
0
Fork 0
mirror of https://github.com/netdata/libbpf.git synced 2026-04-08 17:49:07 +08:00
Code Issues Packages Projects Releases Wiki Activity

Symbols visibility (#3)

Browse Source 
* Sync from bpf-next

Sync the following commits from bpf-next:
commit ab9e08482122 ("libbpf: Per-symbol visibility for DSO")
commit c034a177d3c8 ("bpf: bpftool, add flag to allow non-compat map definitions")

Signed-off-by: Andrey Ignatov <rdna@fb.com>

* Use -fvisibility=hidden by default for DSO

This is Makefile part of:
commit ab9e08482122 ("libbpf: Per-symbol visibility for DSO")

See original commit for details.
This commit is contained in:
Andrey Ignatov
2018-10-16 17:24:08 -07:00
committed by yonghong-song
parent e5c75f8e94
commit 62706e5557
5 changed files with 201 additions and 157 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile
View File

@@ -11,7 +11,7 @@ ifneq ($(FEATURE_REALLOCARRAY),)
endif endif
ifdef BUILD_SHARED ifdef BUILD_SHARED
ALL_CFLAGS += -fPIC ALL_CFLAGS += -fPIC -fvisibility=hidden
endif endif
CFLAGS ?= -g -O2 -Werror -Wall CFLAGS ?= -g -O2 -Werror -Wall

121
src/bpf.h
View File

@@ -27,6 +27,10 @@
#include <stdbool.h> #include <stdbool.h>
#include <stddef.h> #include <stddef.h>
#ifndef LIBBPF_API
#define LIBBPF_API __attribute__((visibility("default")))
#endif
struct bpf_create_map_attr { struct bpf_create_map_attr {
const char *name; const char *name;
enum bpf_map_type map_type; enum bpf_map_type map_type;
@@ -42,21 +46,24 @@ struct bpf_create_map_attr {
__u32 inner_map_fd; __u32 inner_map_fd;
}; };
int bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr); LIBBPF_API int
int bpf_create_map_node(enum bpf_map_type map_type, const char *name, bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr);
int key_size, int value_size, int max_entries, LIBBPF_API int bpf_create_map_node(enum bpf_map_type map_type, const char *name,
__u32 map_flags, int node); int key_size, int value_size,
int bpf_create_map_name(enum bpf_map_type map_type, const char *name, int max_entries, __u32 map_flags, int node);
int key_size, int value_size, int max_entries, LIBBPF_API int bpf_create_map_name(enum bpf_map_type map_type, const char *name,
__u32 map_flags); int key_size, int value_size,
int bpf_create_map(enum bpf_map_type map_type, int key_size, int value_size, int max_entries, __u32 map_flags);
int max_entries, __u32 map_flags); LIBBPF_API int bpf_create_map(enum bpf_map_type map_type, int key_size,
int bpf_create_map_in_map_node(enum bpf_map_type map_type, const char *name, int value_size, int max_entries, __u32 map_flags);
int key_size, int inner_map_fd, int max_entries, LIBBPF_API int bpf_create_map_in_map_node(enum bpf_map_type map_type,
__u32 map_flags, int node); const char *name, int key_size,
int bpf_create_map_in_map(enum bpf_map_type map_type, const char *name, int inner_map_fd, int max_entries,
int key_size, int inner_map_fd, int max_entries, __u32 map_flags, int node);
__u32 map_flags); LIBBPF_API int bpf_create_map_in_map(enum bpf_map_type map_type,
const char *name, int key_size,
int inner_map_fd, int max_entries,
__u32 map_flags);
struct bpf_load_program_attr { struct bpf_load_program_attr {
enum bpf_prog_type prog_type; enum bpf_prog_type prog_type;
@@ -69,46 +76,54 @@ struct bpf_load_program_attr {
__u32 prog_ifindex; __u32 prog_ifindex;
}; };
/* Flags to direct loading requirements */
#define MAPS_RELAX_COMPAT 0x01
/* Recommend log buffer size */ /* Recommend log buffer size */
#define BPF_LOG_BUF_SIZE (256 * 1024) #define BPF_LOG_BUF_SIZE (256 * 1024)
int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr, LIBBPF_API int
char *log_buf, size_t log_buf_sz); bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,
int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns, char *log_buf, size_t log_buf_sz);
size_t insns_cnt, const char *license, LIBBPF_API int bpf_load_program(enum bpf_prog_type type,
__u32 kern_version, char *log_buf, const struct bpf_insn *insns, size_t insns_cnt,
size_t log_buf_sz); const char *license, __u32 kern_version,
int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns, char *log_buf, size_t log_buf_sz);
size_t insns_cnt, int strict_alignment, LIBBPF_API int bpf_verify_program(enum bpf_prog_type type,
const char *license, __u32 kern_version, const struct bpf_insn *insns,
char *log_buf, size_t log_buf_sz, int log_level); size_t insns_cnt, int strict_alignment,
const char *license, __u32 kern_version,
char *log_buf, size_t log_buf_sz,
int log_level);
int bpf_map_update_elem(int fd, const void *key, const void *value, LIBBPF_API int bpf_map_update_elem(int fd, const void *key, const void *value,
__u64 flags); __u64 flags);
int bpf_map_lookup_elem(int fd, const void *key, void *value); LIBBPF_API int bpf_map_lookup_elem(int fd, const void *key, void *value);
int bpf_map_delete_elem(int fd, const void *key); LIBBPF_API int bpf_map_delete_elem(int fd, const void *key);
int bpf_map_get_next_key(int fd, const void *key, void *next_key); LIBBPF_API int bpf_map_get_next_key(int fd, const void *key, void *next_key);
int bpf_obj_pin(int fd, const char *pathname); LIBBPF_API int bpf_obj_pin(int fd, const char *pathname);
int bpf_obj_get(const char *pathname); LIBBPF_API int bpf_obj_get(const char *pathname);
int bpf_prog_attach(int prog_fd, int attachable_fd, enum bpf_attach_type type, LIBBPF_API int bpf_prog_attach(int prog_fd, int attachable_fd,
unsigned int flags); enum bpf_attach_type type, unsigned int flags);
int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type); LIBBPF_API int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
int bpf_prog_detach2(int prog_fd, int attachable_fd, enum bpf_attach_type type); LIBBPF_API int bpf_prog_detach2(int prog_fd, int attachable_fd,
int bpf_prog_test_run(int prog_fd, int repeat, void *data, __u32 size, enum bpf_attach_type type);
void *data_out, __u32 *size_out, __u32 *retval, LIBBPF_API int bpf_prog_test_run(int prog_fd, int repeat, void *data,
__u32 *duration); __u32 size, void *data_out, __u32 *size_out,
int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id); __u32 *retval, __u32 *duration);
int bpf_map_get_next_id(__u32 start_id, __u32 *next_id); LIBBPF_API int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id);
int bpf_prog_get_fd_by_id(__u32 id); LIBBPF_API int bpf_map_get_next_id(__u32 start_id, __u32 *next_id);
int bpf_map_get_fd_by_id(__u32 id); LIBBPF_API int bpf_prog_get_fd_by_id(__u32 id);
int bpf_btf_get_fd_by_id(__u32 id); LIBBPF_API int bpf_map_get_fd_by_id(__u32 id);
int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len); LIBBPF_API int bpf_btf_get_fd_by_id(__u32 id);
int bpf_prog_query(int target_fd, enum bpf_attach_type type, __u32 query_flags, LIBBPF_API int bpf_obj_get_info_by_fd(int prog_fd, void *info, __u32 *info_len);
__u32 *attach_flags, __u32 *prog_ids, __u32 *prog_cnt); LIBBPF_API int bpf_prog_query(int target_fd, enum bpf_attach_type type,
int bpf_raw_tracepoint_open(const char *name, int prog_fd); __u32 query_flags, __u32 *attach_flags,
int bpf_load_btf(void *btf, __u32 btf_size, char *log_buf, __u32 log_buf_size, __u32 *prog_ids, __u32 *prog_cnt);
bool do_log); LIBBPF_API int bpf_raw_tracepoint_open(const char *name, int prog_fd);
int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf, __u32 *buf_len, LIBBPF_API int bpf_load_btf(void *btf, __u32 btf_size, char *log_buf,
__u32 *prog_id, __u32 *fd_type, __u64 *probe_offset, __u32 log_buf_size, bool do_log);
__u64 *probe_addr); LIBBPF_API int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf,
__u32 *buf_len, __u32 *prog_id, __u32 *fd_type,
__u64 *probe_offset, __u64 *probe_addr);
#endif /* __LIBBPF_BPF_H */ #endif /* __LIBBPF_BPF_H */

22
src/btf.h
View File

@@ -6,6 +6,10 @@
#include <linux/types.h> #include <linux/types.h>
#ifndef LIBBPF_API
#define LIBBPF_API __attribute__((visibility("default")))
#endif
#define BTF_ELF_SEC ".BTF" #define BTF_ELF_SEC ".BTF"
struct btf; struct btf;
@@ -14,13 +18,15 @@ struct btf_type;
typedef int (*btf_print_fn_t)(const char *, ...) typedef int (*btf_print_fn_t)(const char *, ...)
__attribute__((format(printf, 1, 2))); __attribute__((format(printf, 1, 2)));
void btf__free(struct btf *btf); LIBBPF_API void btf__free(struct btf *btf);
struct btf *btf__new(__u8 *data, __u32 size, btf_print_fn_t err_log); LIBBPF_API struct btf *btf__new(__u8 *data, __u32 size, btf_print_fn_t err_log);
__s32 btf__find_by_name(const struct btf *btf, const char *type_name); LIBBPF_API __s32 btf__find_by_name(const struct btf *btf,
const struct btf_type *btf__type_by_id(const struct btf *btf, __u32 id); const char *type_name);
__s64 btf__resolve_size(const struct btf *btf, __u32 type_id); LIBBPF_API const struct btf_type *btf__type_by_id(const struct btf *btf,
int btf__resolve_type(const struct btf *btf, __u32 type_id); __u32 id);
int btf__fd(const struct btf *btf); LIBBPF_API __s64 btf__resolve_size(const struct btf *btf, __u32 type_id);
const char *btf__name_by_offset(const struct btf *btf, __u32 offset); LIBBPF_API int btf__resolve_type(const struct btf *btf, __u32 type_id);
LIBBPF_API int btf__fd(const struct btf *btf);
LIBBPF_API const char *btf__name_by_offset(const struct btf *btf, __u32 offset);
#endif /* __LIBBPF_BTF_H */ #endif /* __LIBBPF_BTF_H */

27
src/libbpf.c
View File

@@ -562,8 +562,9 @@ static int compare_bpf_map(const void *_a, const void *_b)
} }
static int static int
bpf_object__init_maps(struct bpf_object *obj) bpf_object__init_maps(struct bpf_object *obj, int flags)
{ {
bool strict = !(flags & MAPS_RELAX_COMPAT);
int i, map_idx, map_def_sz, nr_maps = 0; int i, map_idx, map_def_sz, nr_maps = 0;
Elf_Scn *scn; Elf_Scn *scn;
Elf_Data *data; Elf_Data *data;
@@ -685,7 +686,8 @@ bpf_object__init_maps(struct bpf_object *obj)
"has unrecognized, non-zero " "has unrecognized, non-zero "
"options\n", "options\n",
obj->path, map_name); obj->path, map_name);
return -EINVAL; if (strict)
return -EINVAL;
} }
} }
memcpy(&obj->maps[map_idx].def, def, memcpy(&obj->maps[map_idx].def, def,
@@ -716,7 +718,7 @@ static bool section_have_execinstr(struct bpf_object *obj, int idx)
return false; return false;
} }
static int bpf_object__elf_collect(struct bpf_object *obj) static int bpf_object__elf_collect(struct bpf_object *obj, int flags)
{ {
Elf *elf = obj->efile.elf; Elf *elf = obj->efile.elf;
GElf_Ehdr *ep = &obj->efile.ehdr; GElf_Ehdr *ep = &obj->efile.ehdr;
@@ -843,7 +845,7 @@ static int bpf_object__elf_collect(struct bpf_object *obj)
return LIBBPF_ERRNO__FORMAT; return LIBBPF_ERRNO__FORMAT;
} }
if (obj->efile.maps_shndx >= 0) { if (obj->efile.maps_shndx >= 0) {
err = bpf_object__init_maps(obj); err = bpf_object__init_maps(obj, flags);
if (err) if (err)
goto out; goto out;
} }
@@ -1515,7 +1517,7 @@ static int bpf_object__validate(struct bpf_object *obj, bool needs_kver)
static struct bpf_object * static struct bpf_object *
__bpf_object__open(const char *path, void *obj_buf, size_t obj_buf_sz, __bpf_object__open(const char *path, void *obj_buf, size_t obj_buf_sz,
bool needs_kver) bool needs_kver, int flags)
{ {
struct bpf_object *obj; struct bpf_object *obj;
int err; int err;
@@ -1531,7 +1533,7 @@ __bpf_object__open(const char *path, void *obj_buf, size_t obj_buf_sz,
CHECK_ERR(bpf_object__elf_init(obj), err, out); CHECK_ERR(bpf_object__elf_init(obj), err, out);
CHECK_ERR(bpf_object__check_endianness(obj), err, out); CHECK_ERR(bpf_object__check_endianness(obj), err, out);
CHECK_ERR(bpf_object__elf_collect(obj), err, out); CHECK_ERR(bpf_object__elf_collect(obj, flags), err, out);
CHECK_ERR(bpf_object__collect_reloc(obj), err, out); CHECK_ERR(bpf_object__collect_reloc(obj), err, out);
CHECK_ERR(bpf_object__validate(obj, needs_kver), err, out); CHECK_ERR(bpf_object__validate(obj, needs_kver), err, out);
@@ -1542,7 +1544,8 @@ out:
return ERR_PTR(err); return ERR_PTR(err);
} }
struct bpf_object *bpf_object__open_xattr(struct bpf_object_open_attr *attr) struct bpf_object *__bpf_object__open_xattr(struct bpf_object_open_attr *attr,
int flags)
{ {
/* param validation */ /* param validation */
if (!attr->file) if (!attr->file)
@@ -1551,7 +1554,13 @@ struct bpf_object *bpf_object__open_xattr(struct bpf_object_open_attr *attr)
pr_debug("loading %s\n", attr->file); pr_debug("loading %s\n", attr->file);
return __bpf_object__open(attr->file, NULL, 0, return __bpf_object__open(attr->file, NULL, 0,
bpf_prog_type__needs_kver(attr->prog_type)); bpf_prog_type__needs_kver(attr->prog_type),
flags);
}
struct bpf_object *bpf_object__open_xattr(struct bpf_object_open_attr *attr)
{
return __bpf_object__open_xattr(attr, 0);
} }
struct bpf_object *bpf_object__open(const char *path) struct bpf_object *bpf_object__open(const char *path)
@@ -1584,7 +1593,7 @@ struct bpf_object *bpf_object__open_buffer(void *obj_buf,
pr_debug("loading object '%s' from buffer\n", pr_debug("loading object '%s' from buffer\n",
name); name);
return __bpf_object__open(name, obj_buf, obj_buf_sz, true); return __bpf_object__open(name, obj_buf, obj_buf_sz, true, true);
} }
int bpf_object__unload(struct bpf_object *obj) int bpf_object__unload(struct bpf_object *obj)

186
src/libbpf.h
View File

@@ -16,6 +16,10 @@
#include <sys/types.h> // for size_t #include <sys/types.h> // for size_t
#include <linux/bpf.h> #include <linux/bpf.h>
#ifndef LIBBPF_API
#define LIBBPF_API __attribute__((visibility("default")))
#endif
enum libbpf_errno { enum libbpf_errno {
__LIBBPF_ERRNO__START = 4000, __LIBBPF_ERRNO__START = 4000,
@@ -37,7 +41,7 @@ enum libbpf_errno {
__LIBBPF_ERRNO__END, __LIBBPF_ERRNO__END,
}; };
int libbpf_strerror(int err, char *buf, size_t size); LIBBPF_API int libbpf_strerror(int err, char *buf, size_t size);
/* /*
* __printf is defined in include/linux/compiler-gcc.h. However, * __printf is defined in include/linux/compiler-gcc.h. However,
@@ -47,9 +51,9 @@ int libbpf_strerror(int err, char *buf, size_t size);
typedef int (*libbpf_print_fn_t)(const char *, ...) typedef int (*libbpf_print_fn_t)(const char *, ...)
__attribute__((format(printf, 1, 2))); __attribute__((format(printf, 1, 2)));
void libbpf_set_print(libbpf_print_fn_t warn, LIBBPF_API void libbpf_set_print(libbpf_print_fn_t warn,
libbpf_print_fn_t info, libbpf_print_fn_t info,
libbpf_print_fn_t debug); libbpf_print_fn_t debug);
/* Hide internal to user */ /* Hide internal to user */
struct bpf_object; struct bpf_object;
@@ -59,25 +63,28 @@ struct bpf_object_open_attr {
enum bpf_prog_type prog_type; enum bpf_prog_type prog_type;
}; };
struct bpf_object *bpf_object__open(const char *path); LIBBPF_API struct bpf_object *bpf_object__open(const char *path);
struct bpf_object *bpf_object__open_xattr(struct bpf_object_open_attr *attr); LIBBPF_API struct bpf_object *
struct bpf_object *bpf_object__open_buffer(void *obj_buf, bpf_object__open_xattr(struct bpf_object_open_attr *attr);
size_t obj_buf_sz, struct bpf_object *__bpf_object__open_xattr(struct bpf_object_open_attr *attr,
const char *name); int flags);
int bpf_object__pin(struct bpf_object *object, const char *path); LIBBPF_API struct bpf_object *bpf_object__open_buffer(void *obj_buf,
void bpf_object__close(struct bpf_object *object); size_t obj_buf_sz,
const char *name);
LIBBPF_API int bpf_object__pin(struct bpf_object *object, const char *path);
LIBBPF_API void bpf_object__close(struct bpf_object *object);
/* Load/unload object into/from kernel */ /* Load/unload object into/from kernel */
int bpf_object__load(struct bpf_object *obj); LIBBPF_API int bpf_object__load(struct bpf_object *obj);
int bpf_object__unload(struct bpf_object *obj); LIBBPF_API int bpf_object__unload(struct bpf_object *obj);
const char *bpf_object__name(struct bpf_object *obj); LIBBPF_API const char *bpf_object__name(struct bpf_object *obj);
unsigned int bpf_object__kversion(struct bpf_object *obj); LIBBPF_API unsigned int bpf_object__kversion(struct bpf_object *obj);
int bpf_object__btf_fd(const struct bpf_object *obj); LIBBPF_API int bpf_object__btf_fd(const struct bpf_object *obj);
struct bpf_program * LIBBPF_API struct bpf_program *
bpf_object__find_program_by_title(struct bpf_object *obj, const char *title); bpf_object__find_program_by_title(struct bpf_object *obj, const char *title);
struct bpf_object *bpf_object__next(struct bpf_object *prev); LIBBPF_API struct bpf_object *bpf_object__next(struct bpf_object *prev);
#define bpf_object__for_each_safe(pos, tmp) \ #define bpf_object__for_each_safe(pos, tmp) \
for ((pos) = bpf_object__next(NULL), \ for ((pos) = bpf_object__next(NULL), \
(tmp) = bpf_object__next(pos); \ (tmp) = bpf_object__next(pos); \
@@ -85,19 +92,20 @@ struct bpf_object *bpf_object__next(struct bpf_object *prev);
(pos) = (tmp), (tmp) = bpf_object__next(tmp)) (pos) = (tmp), (tmp) = bpf_object__next(tmp))
typedef void (*bpf_object_clear_priv_t)(struct bpf_object *, void *); typedef void (*bpf_object_clear_priv_t)(struct bpf_object *, void *);
int bpf_object__set_priv(struct bpf_object *obj, void *priv, LIBBPF_API int bpf_object__set_priv(struct bpf_object *obj, void *priv,
bpf_object_clear_priv_t clear_priv); bpf_object_clear_priv_t clear_priv);
void *bpf_object__priv(struct bpf_object *prog); LIBBPF_API void *bpf_object__priv(struct bpf_object *prog);
int libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type, LIBBPF_API int
enum bpf_attach_type *expected_attach_type); libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,
int libbpf_attach_type_by_name(const char *name, enum bpf_attach_type *expected_attach_type);
enum bpf_attach_type *attach_type); LIBBPF_API int libbpf_attach_type_by_name(const char *name,
enum bpf_attach_type *attach_type);
/* Accessors of bpf_program */ /* Accessors of bpf_program */
struct bpf_program; struct bpf_program;
struct bpf_program *bpf_program__next(struct bpf_program *prog, LIBBPF_API struct bpf_program *bpf_program__next(struct bpf_program *prog,
struct bpf_object *obj); struct bpf_object *obj);
#define bpf_object__for_each_program(pos, obj) \ #define bpf_object__for_each_program(pos, obj) \
for ((pos) = bpf_program__next(NULL, (obj)); \ for ((pos) = bpf_program__next(NULL, (obj)); \
@@ -107,21 +115,24 @@ struct bpf_program *bpf_program__next(struct bpf_program *prog,
typedef void (*bpf_program_clear_priv_t)(struct bpf_program *, typedef void (*bpf_program_clear_priv_t)(struct bpf_program *,
void *); void *);
int bpf_program__set_priv(struct bpf_program *prog, void *priv, LIBBPF_API int bpf_program__set_priv(struct bpf_program *prog, void *priv,
bpf_program_clear_priv_t clear_priv); bpf_program_clear_priv_t clear_priv);
void *bpf_program__priv(struct bpf_program *prog); LIBBPF_API void *bpf_program__priv(struct bpf_program *prog);
void bpf_program__set_ifindex(struct bpf_program *prog, __u32 ifindex); LIBBPF_API void bpf_program__set_ifindex(struct bpf_program *prog,
__u32 ifindex);
const char *bpf_program__title(struct bpf_program *prog, bool needs_copy); LIBBPF_API const char *bpf_program__title(struct bpf_program *prog,
bool needs_copy);
int bpf_program__load(struct bpf_program *prog, char *license, LIBBPF_API int bpf_program__load(struct bpf_program *prog, char *license,
__u32 kern_version); __u32 kern_version);
int bpf_program__fd(struct bpf_program *prog); LIBBPF_API int bpf_program__fd(struct bpf_program *prog);
int bpf_program__pin_instance(struct bpf_program *prog, const char *path, LIBBPF_API int bpf_program__pin_instance(struct bpf_program *prog,
int instance); const char *path,
int bpf_program__pin(struct bpf_program *prog, const char *path); int instance);
void bpf_program__unload(struct bpf_program *prog); LIBBPF_API int bpf_program__pin(struct bpf_program *prog, const char *path);
LIBBPF_API void bpf_program__unload(struct bpf_program *prog);
struct bpf_insn; struct bpf_insn;
@@ -182,34 +193,36 @@ typedef int (*bpf_program_prep_t)(struct bpf_program *prog, int n,
struct bpf_insn *insns, int insns_cnt, struct bpf_insn *insns, int insns_cnt,
struct bpf_prog_prep_result *res); struct bpf_prog_prep_result *res);
int bpf_program__set_prep(struct bpf_program *prog, int nr_instance, LIBBPF_API int bpf_program__set_prep(struct bpf_program *prog, int nr_instance,
bpf_program_prep_t prep); bpf_program_prep_t prep);
int bpf_program__nth_fd(struct bpf_program *prog, int n); LIBBPF_API int bpf_program__nth_fd(struct bpf_program *prog, int n);
/* /*
* Adjust type of BPF program. Default is kprobe. * Adjust type of BPF program. Default is kprobe.
*/ */
int bpf_program__set_socket_filter(struct bpf_program *prog); LIBBPF_API int bpf_program__set_socket_filter(struct bpf_program *prog);
int bpf_program__set_tracepoint(struct bpf_program *prog); LIBBPF_API int bpf_program__set_tracepoint(struct bpf_program *prog);
int bpf_program__set_raw_tracepoint(struct bpf_program *prog); LIBBPF_API int bpf_program__set_raw_tracepoint(struct bpf_program *prog);
int bpf_program__set_kprobe(struct bpf_program *prog); LIBBPF_API int bpf_program__set_kprobe(struct bpf_program *prog);
int bpf_program__set_sched_cls(struct bpf_program *prog); LIBBPF_API int bpf_program__set_sched_cls(struct bpf_program *prog);
int bpf_program__set_sched_act(struct bpf_program *prog); LIBBPF_API int bpf_program__set_sched_act(struct bpf_program *prog);
int bpf_program__set_xdp(struct bpf_program *prog); LIBBPF_API int bpf_program__set_xdp(struct bpf_program *prog);
int bpf_program__set_perf_event(struct bpf_program *prog); LIBBPF_API int bpf_program__set_perf_event(struct bpf_program *prog);
void bpf_program__set_type(struct bpf_program *prog, enum bpf_prog_type type); LIBBPF_API void bpf_program__set_type(struct bpf_program *prog,
void bpf_program__set_expected_attach_type(struct bpf_program *prog, enum bpf_prog_type type);
enum bpf_attach_type type); LIBBPF_API void
bpf_program__set_expected_attach_type(struct bpf_program *prog,
enum bpf_attach_type type);
bool bpf_program__is_socket_filter(struct bpf_program *prog); LIBBPF_API bool bpf_program__is_socket_filter(struct bpf_program *prog);
bool bpf_program__is_tracepoint(struct bpf_program *prog); LIBBPF_API bool bpf_program__is_tracepoint(struct bpf_program *prog);
bool bpf_program__is_raw_tracepoint(struct bpf_program *prog); LIBBPF_API bool bpf_program__is_raw_tracepoint(struct bpf_program *prog);
bool bpf_program__is_kprobe(struct bpf_program *prog); LIBBPF_API bool bpf_program__is_kprobe(struct bpf_program *prog);
bool bpf_program__is_sched_cls(struct bpf_program *prog); LIBBPF_API bool bpf_program__is_sched_cls(struct bpf_program *prog);
bool bpf_program__is_sched_act(struct bpf_program *prog); LIBBPF_API bool bpf_program__is_sched_act(struct bpf_program *prog);
bool bpf_program__is_xdp(struct bpf_program *prog); LIBBPF_API bool bpf_program__is_xdp(struct bpf_program *prog);
bool bpf_program__is_perf_event(struct bpf_program *prog); LIBBPF_API bool bpf_program__is_perf_event(struct bpf_program *prog);
/* /*
* No need for __attribute__((packed)), all members of 'bpf_map_def' * No need for __attribute__((packed)), all members of 'bpf_map_def'
@@ -230,39 +243,39 @@ struct bpf_map_def {
* so no need to worry about a name clash. * so no need to worry about a name clash.
*/ */
struct bpf_map; struct bpf_map;
struct bpf_map * LIBBPF_API struct bpf_map *
bpf_object__find_map_by_name(struct bpf_object *obj, const char *name); bpf_object__find_map_by_name(struct bpf_object *obj, const char *name);
/* /*
* Get bpf_map through the offset of corresponding struct bpf_map_def * Get bpf_map through the offset of corresponding struct bpf_map_def
* in the BPF object file. * in the BPF object file.
*/ */
struct bpf_map * LIBBPF_API struct bpf_map *
bpf_object__find_map_by_offset(struct bpf_object *obj, size_t offset); bpf_object__find_map_by_offset(struct bpf_object *obj, size_t offset);
struct bpf_map * LIBBPF_API struct bpf_map *
bpf_map__next(struct bpf_map *map, struct bpf_object *obj); bpf_map__next(struct bpf_map *map, struct bpf_object *obj);
#define bpf_map__for_each(pos, obj) \ #define bpf_map__for_each(pos, obj) \
for ((pos) = bpf_map__next(NULL, (obj)); \ for ((pos) = bpf_map__next(NULL, (obj)); \
(pos) != NULL; \ (pos) != NULL; \
(pos) = bpf_map__next((pos), (obj))) (pos) = bpf_map__next((pos), (obj)))
int bpf_map__fd(struct bpf_map *map); LIBBPF_API int bpf_map__fd(struct bpf_map *map);
const struct bpf_map_def *bpf_map__def(struct bpf_map *map); LIBBPF_API const struct bpf_map_def *bpf_map__def(struct bpf_map *map);
const char *bpf_map__name(struct bpf_map *map); LIBBPF_API const char *bpf_map__name(struct bpf_map *map);
__u32 bpf_map__btf_key_type_id(const struct bpf_map *map); LIBBPF_API __u32 bpf_map__btf_key_type_id(const struct bpf_map *map);
__u32 bpf_map__btf_value_type_id(const struct bpf_map *map); LIBBPF_API __u32 bpf_map__btf_value_type_id(const struct bpf_map *map);
typedef void (*bpf_map_clear_priv_t)(struct bpf_map *, void *); typedef void (*bpf_map_clear_priv_t)(struct bpf_map *, void *);
int bpf_map__set_priv(struct bpf_map *map, void *priv, LIBBPF_API int bpf_map__set_priv(struct bpf_map *map, void *priv,
bpf_map_clear_priv_t clear_priv); bpf_map_clear_priv_t clear_priv);
void *bpf_map__priv(struct bpf_map *map); LIBBPF_API void *bpf_map__priv(struct bpf_map *map);
int bpf_map__reuse_fd(struct bpf_map *map, int fd); LIBBPF_API int bpf_map__reuse_fd(struct bpf_map *map, int fd);
bool bpf_map__is_offload_neutral(struct bpf_map *map); LIBBPF_API bool bpf_map__is_offload_neutral(struct bpf_map *map);
void bpf_map__set_ifindex(struct bpf_map *map, __u32 ifindex); LIBBPF_API void bpf_map__set_ifindex(struct bpf_map *map, __u32 ifindex);
int bpf_map__pin(struct bpf_map *map, const char *path); LIBBPF_API int bpf_map__pin(struct bpf_map *map, const char *path);
long libbpf_get_error(const void *ptr); LIBBPF_API long libbpf_get_error(const void *ptr);
struct bpf_prog_load_attr { struct bpf_prog_load_attr {
const char *file; const char *file;
@@ -271,12 +284,12 @@ struct bpf_prog_load_attr {
int ifindex; int ifindex;
}; };
int bpf_prog_load_xattr(const struct bpf_prog_load_attr *attr, LIBBPF_API int bpf_prog_load_xattr(const struct bpf_prog_load_attr *attr,
struct bpf_object **pobj, int *prog_fd); struct bpf_object **pobj, int *prog_fd);
int bpf_prog_load(const char *file, enum bpf_prog_type type, LIBBPF_API int bpf_prog_load(const char *file, enum bpf_prog_type type,
struct bpf_object **pobj, int *prog_fd); struct bpf_object **pobj, int *prog_fd);
int bpf_set_link_xdp_fd(int ifindex, int fd, __u32 flags); LIBBPF_API int bpf_set_link_xdp_fd(int ifindex, int fd, __u32 flags);
enum bpf_perf_event_ret { enum bpf_perf_event_ret {
LIBBPF_PERF_EVENT_DONE = 0, LIBBPF_PERF_EVENT_DONE = 0,
@@ -286,10 +299,11 @@ enum bpf_perf_event_ret {
typedef enum bpf_perf_event_ret (*bpf_perf_event_print_t)(void *event, typedef enum bpf_perf_event_ret (*bpf_perf_event_print_t)(void *event,
void *priv); void *priv);
int bpf_perf_event_read_simple(void *mem, unsigned long size, LIBBPF_API int bpf_perf_event_read_simple(void *mem, unsigned long size,
unsigned long page_size, unsigned long page_size,
void **buf, size_t *buf_len, void **buf, size_t *buf_len,
bpf_perf_event_print_t fn, void *priv); bpf_perf_event_print_t fn,
void *priv);
struct nlattr; struct nlattr;
typedef int (*libbpf_dump_nlmsg_t)(void *cookie, void *msg, struct nlattr **tb); typedef int (*libbpf_dump_nlmsg_t)(void *cookie, void *msg, struct nlattr **tb);