libbpf.h

Go to the documentation of this file.

// Copyright (c) eBPF for Windows contributors
// SPDX-License-Identifier: MIT
 
#ifdef __doxygen
 
int
bpf_link__destroy(struct bpf_link* link);
 
void
bpf_link__disconnect(struct bpf_link* link);
 
int
bpf_link__fd(const struct bpf_link* link);
 
int
bpf_link__pin(struct bpf_link* link, const char* path);
 
int
bpf_link__unpin(struct bpf_link* link);
 
const char*
libbpf_bpf_link_type_str(enum bpf_link_type t);
 
int
bpf_map__fd(const struct bpf_map* map);
 
bool
bpf_map__is_pinned(const struct bpf_map* map);
 
__u32
bpf_map__key_size(const struct bpf_map* map);
 
__u32
bpf_map__max_entries(const struct bpf_map* map);
 
const char*
bpf_map__name(const struct bpf_map* map);
 
int
bpf_map__pin(struct bpf_map* map, const char* path);
 
enum bpf_map_type
bpf_map__type(const struct bpf_map* map);
 
int
bpf_map__unpin(struct bpf_map* map, const char* path);
 
__u32
bpf_map__value_size(const struct bpf_map* map);
 
const char*
libbpf_bpf_map_type_str(enum bpf_map_type t);
 
void
bpf_object__close(struct bpf_object* object);
 
struct bpf_map*
bpf_object__find_map_by_name(const struct bpf_object* obj, const char* name);
 
int
bpf_object__find_map_fd_by_name(const struct bpf_object* obj, const char* name);
 
struct bpf_program*
bpf_object__find_program_by_name(const struct bpf_object* obj, const char* name);
 
int
bpf_object__load(struct bpf_object* obj);
 
const char*
bpf_object__name(const struct bpf_object* obj);
 
struct bpf_map*
bpf_object__next_map(const struct bpf_object* obj, const struct bpf_map* map);
 
struct bpf_program*
bpf_object__next_program(const struct bpf_object* obj, struct bpf_program* prog);
 
struct bpf_object*
bpf_object__open(const char* path);
 
struct bpf_object*
bpf_object__open_file(const char* path, const struct bpf_object_open_opts* opts);
 
int
bpf_object__pin(struct bpf_object* object, const char* path);
 
int
bpf_object__pin_maps(struct bpf_object* obj, const char* path);
 
int
bpf_object__pin_programs(struct bpf_object* obj, const char* path);
 
struct bpf_map*
bpf_object__prev_map(const struct bpf_object* obj, const struct bpf_map* map);
 
struct bpf_program*
bpf_object__prev_program(const struct bpf_object* obj, struct bpf_program* prog);
 
int
bpf_object__unpin_maps(struct bpf_object* obj, const char* path);
 
int
bpf_object__unpin_programs(struct bpf_object* obj, const char* path);
 
struct bpf_link*
bpf_program__attach(const struct bpf_program* prog);
 
struct bpf_link*
bpf_program__attach_xdp(struct bpf_program* prog, int ifindex);
 
bool
bpf_program__autoload(const struct bpf_program* prog);
 
int
bpf_program__set_autoload(struct bpf_program* prog, bool autoload);
 
int
bpf_prog_attach(int prog_fd, int attachable_fd, enum bpf_attach_type type, unsigned int flags);
 
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);
 
int
bpf_program__fd(const struct bpf_program* prog);
 
enum bpf_attach_type
bpf_program__get_expected_attach_type(const struct bpf_program* prog);
 
enum bpf_prog_type
bpf_program__get_type(const struct bpf_program* prog);
 
size_t
bpf_program__insn_cnt(const struct bpf_program* prog);
 
const char*
bpf_program__name(const struct bpf_program* prog);
 
int
bpf_program__pin(struct bpf_program* prog, const char* path);
 
const char*
bpf_program__section_name(const struct bpf_program* prog);
 
int
bpf_program__set_expected_attach_type(struct bpf_program* prog, enum bpf_attach_type type);
 
int
bpf_program__set_type(struct bpf_program* prog, enum bpf_prog_type type);
 
enum bpf_prog_type
bpf_program__type(const struct bpf_program* prog);
 
void
bpf_program__unload(struct bpf_program* prog);
 
int
bpf_program__unpin(struct bpf_program* prog, const char* path);
 
int
bpf_xdp_attach(int ifindex, int prog_fd, __u32 flags, const struct bpf_xdp_attach_opts* opts);
 
int
bpf_xdp_detach(int ifindex, __u32 flags, const struct bpf_xdp_attach_opts* opts);
 
int
bpf_xdp_query_id(int ifindex, int flags, __u32* prog_id);
 
int
libbpf_attach_type_by_name(const char* name, enum bpf_attach_type* attach_type);
 
const char*
libbpf_bpf_attach_type_str(enum bpf_attach_type t);
 
const char*
libbpf_bpf_prog_type_str(enum bpf_prog_type t);
 
int
libbpf_prog_type_by_name(const char* name, enum bpf_prog_type* prog_type, enum bpf_attach_type* expected_attach_type);
 
long
libbpf_get_error(const void* ptr);
 
int
libbpf_strerror(int err, char* buf, size_t size);
 
int
libbpf_num_possible_cpus(void);
 
/* Ring buffer APIs */
 
struct ring_buffer*
ring_buffer__new(int map_fd, ring_buffer_sample_fn sample_cb, void* ctx, const struct ring_buffer_opts* opts);
 
void
ring_buffer__free(struct ring_buffer* rb);
__u32
bpf_program__flags(const struct bpf_program* prog);
 
int
bpf_program__set_flags(struct bpf_program* prog, __u32 flags);
 
#else
#pragma warning(push)
#pragma warning(disable : 4200) // Zero-sized array in struct/union
#pragma warning(disable : 4201) // Zero-sized array in struct/union
#include "libbpf/src/libbpf.h"
#pragma warning(pop)
#endif
#include "libbpf_legacy.h"