resources/usr/include/bpf/libbpf.h

   1 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
   2
   3 /*
   4  * Common eBPF ELF object loading operations.
   5  *
   6  * Copyright (C) 2013-2015 Alexei Starovoitov <ast@kernel.org>
   7  * Copyright (C) 2015 Wang Nan <wangnan0@huawei.com>
   8  * Copyright (C) 2015 Huawei Inc.
   9  */
  10 #ifndef __LIBBPF_LIBBPF_H
  11 #define __LIBBPF_LIBBPF_H
  12
  13 #include <stdarg.h>
  14 #include <stdio.h>
  15 #include <stdint.h>
  16 #include <stdbool.h>
  17 #include <sys/types.h>  // for size_t
  18 #include <linux/bpf.h>
  19
  20 #include "libbpf_common.h"
  21
  22 #ifdef __cplusplus
  23 extern "C" {
  24 #endif
  25
  26 enum libbpf_errno {
  27         __LIBBPF_ERRNO__START = 4000,
  28
  29         /* Something wrong in libelf */
  30         LIBBPF_ERRNO__LIBELF = __LIBBPF_ERRNO__START,
  31         LIBBPF_ERRNO__FORMAT,   /* BPF object format invalid */
  32         LIBBPF_ERRNO__KVERSION, /* Incorrect or no 'version' section */
  33         LIBBPF_ERRNO__ENDIAN,   /* Endian mismatch */
  34         LIBBPF_ERRNO__INTERNAL, /* Internal error in libbpf */
  35         LIBBPF_ERRNO__RELOC,    /* Relocation failed */
  36         LIBBPF_ERRNO__LOAD,     /* Load program failure for unknown reason */
  37         LIBBPF_ERRNO__VERIFY,   /* Kernel verifier blocks program loading */
  38         LIBBPF_ERRNO__PROG2BIG, /* Program too big */
  39         LIBBPF_ERRNO__KVER,     /* Incorrect kernel version */
  40         LIBBPF_ERRNO__PROGTYPE, /* Kernel doesn't support this program type */
  41         LIBBPF_ERRNO__WRNGPID,  /* Wrong pid in netlink message */
  42         LIBBPF_ERRNO__INVSEQ,   /* Invalid netlink sequence */
  43         LIBBPF_ERRNO__NLPARSE,  /* netlink parsing error */
  44         __LIBBPF_ERRNO__END,
  45 };
  46
  47 LIBBPF_API int libbpf_strerror(int err, char *buf, size_t size);
  48
  49 enum libbpf_print_level {
  50         LIBBPF_WARN,
  51         LIBBPF_INFO,
  52         LIBBPF_DEBUG,
  53 };
  54
  55 typedef int (*libbpf_print_fn_t)(enum libbpf_print_level level,
  56                                  const char *, va_list ap);
  57
  58 LIBBPF_API libbpf_print_fn_t libbpf_set_print(libbpf_print_fn_t fn);
  59
  60 /* Hide internal to user */
  61 struct bpf_object;
  62
  63 struct bpf_object_open_attr {
  64         const char *file;
  65         enum bpf_prog_type prog_type;
  66 };
  67
  68 struct bpf_object_open_opts {
  69         /* size of this struct, for forward/backward compatiblity */
  70         size_t sz;
  71         /* object name override, if provided:
  72          * - for object open from file, this will override setting object
  73          *   name from file path's base name;
  74          * - for object open from memory buffer, this will specify an object
  75          *   name and will override default "<addr>-<buf-size>" name;
  76          */
  77         const char *object_name;
  78         /* parse map definitions non-strictly, allowing extra attributes/data */
  79         bool relaxed_maps;
  80         /* DEPRECATED: handle CO-RE relocations non-strictly, allowing failures.
  81          * Value is ignored. Relocations always are processed non-strictly.
  82          * Non-relocatable instructions are replaced with invalid ones to
  83          * prevent accidental errors.
  84          * */
  85         bool relaxed_core_relocs;
  86         /* maps that set the 'pinning' attribute in their definition will have
  87          * their pin_path attribute set to a file in this directory, and be
  88          * auto-pinned to that path on load; defaults to "/sys/fs/bpf".
  89          */
  90         const char *pin_root_path;
  91         __u32 attach_prog_fd;
  92         /* Additional kernel config content that augments and overrides
  93          * system Kconfig for CONFIG_xxx externs.
  94          */
  95         const char *kconfig;
  96 };
  97 #define bpf_object_open_opts__last_field kconfig
  98
  99 LIBBPF_API struct bpf_object *bpf_object__open(const char *path);
 100 LIBBPF_API struct bpf_object *
 101 bpf_object__open_file(const char *path, const struct bpf_object_open_opts *opts);
 102 LIBBPF_API struct bpf_object *
 103 bpf_object__open_mem(const void *obj_buf, size_t obj_buf_sz,
 104                      const struct bpf_object_open_opts *opts);
 105
 106 /* deprecated bpf_object__open variants */
 107 LIBBPF_API struct bpf_object *
 108 bpf_object__open_buffer(const void *obj_buf, size_t obj_buf_sz,
 109                         const char *name);
 110 LIBBPF_API struct bpf_object *
 111 bpf_object__open_xattr(struct bpf_object_open_attr *attr);
 112
 113 enum libbpf_pin_type {
 114         LIBBPF_PIN_NONE,
 115         /* PIN_BY_NAME: pin maps by name (in /sys/fs/bpf by default) */
 116         LIBBPF_PIN_BY_NAME,
 117 };
 118
 119 /* pin_maps and unpin_maps can both be called with a NULL path, in which case
 120  * they will use the pin_path attribute of each map (and ignore all maps that
 121  * don't have a pin_path set).
 122  */
 123 LIBBPF_API int bpf_object__pin_maps(struct bpf_object *obj, const char *path);
 124 LIBBPF_API int bpf_object__unpin_maps(struct bpf_object *obj,
 125                                       const char *path);
 126 LIBBPF_API int bpf_object__pin_programs(struct bpf_object *obj,
 127                                         const char *path);
 128 LIBBPF_API int bpf_object__unpin_programs(struct bpf_object *obj,
 129                                           const char *path);
 130 LIBBPF_API int bpf_object__pin(struct bpf_object *object, const char *path);
 131 LIBBPF_API void bpf_object__close(struct bpf_object *object);
 132
 133 struct bpf_object_load_attr {
 134         struct bpf_object *obj;
 135         int log_level;
 136         const char *target_btf_path;
 137 };
 138
 139 /* Load/unload object into/from kernel */
 140 LIBBPF_API int bpf_object__load(struct bpf_object *obj);
 141 LIBBPF_API int bpf_object__load_xattr(struct bpf_object_load_attr *attr);
 142 LIBBPF_API int bpf_object__unload(struct bpf_object *obj);
 143
 144 LIBBPF_API const char *bpf_object__name(const struct bpf_object *obj);
 145 LIBBPF_API unsigned int bpf_object__kversion(const struct bpf_object *obj);
 146
 147 struct btf;
 148 LIBBPF_API struct btf *bpf_object__btf(const struct bpf_object *obj);
 149 LIBBPF_API int bpf_object__btf_fd(const struct bpf_object *obj);
 150
 151 LIBBPF_API struct bpf_program *
 152 bpf_object__find_program_by_title(const struct bpf_object *obj,
 153                                   const char *title);
 154 LIBBPF_API struct bpf_program *
 155 bpf_object__find_program_by_name(const struct bpf_object *obj,
 156                                  const char *name);
 157
 158 LIBBPF_API struct bpf_object *bpf_object__next(struct bpf_object *prev);
 159 #define bpf_object__for_each_safe(pos, tmp)                     \
 160         for ((pos) = bpf_object__next(NULL),            \
 161                 (tmp) = bpf_object__next(pos);          \
 162              (pos) != NULL;                             \
 163              (pos) = (tmp), (tmp) = bpf_object__next(tmp))
 164
 165 typedef void (*bpf_object_clear_priv_t)(struct bpf_object *, void *);
 166 LIBBPF_API int bpf_object__set_priv(struct bpf_object *obj, void *priv,
 167                                     bpf_object_clear_priv_t clear_priv);
 168 LIBBPF_API void *bpf_object__priv(const struct bpf_object *prog);
 169
 170 LIBBPF_API int
 171 libbpf_prog_type_by_name(const char *name, enum bpf_prog_type *prog_type,
 172                          enum bpf_attach_type *expected_attach_type);
 173 LIBBPF_API int libbpf_attach_type_by_name(const char *name,
 174                                           enum bpf_attach_type *attach_type);
 175 LIBBPF_API int libbpf_find_vmlinux_btf_id(const char *name,
 176                                           enum bpf_attach_type attach_type);
 177
 178 /* Accessors of bpf_program */
 179 struct bpf_program;
 180 LIBBPF_API struct bpf_program *bpf_program__next(struct bpf_program *prog,
 181                                                  const struct bpf_object *obj);
 182
 183 #define bpf_object__for_each_program(pos, obj)          \
 184         for ((pos) = bpf_program__next(NULL, (obj));    \
 185              (pos) != NULL;                             \
 186              (pos) = bpf_program__next((pos), (obj)))
 187
 188 LIBBPF_API struct bpf_program *bpf_program__prev(struct bpf_program *prog,
 189                                                  const struct bpf_object *obj);
 190
 191 typedef void (*bpf_program_clear_priv_t)(struct bpf_program *, void *);
 192
 193 LIBBPF_API int bpf_program__set_priv(struct bpf_program *prog, void *priv,
 194                                      bpf_program_clear_priv_t clear_priv);
 195
 196 LIBBPF_API void *bpf_program__priv(const struct bpf_program *prog);
 197 LIBBPF_API void bpf_program__set_ifindex(struct bpf_program *prog,
 198                                          __u32 ifindex);
 199
 200 LIBBPF_API const char *bpf_program__name(const struct bpf_program *prog);
 201 LIBBPF_API const char *bpf_program__section_name(const struct bpf_program *prog);
 202 LIBBPF_API LIBBPF_DEPRECATED("BPF program title is confusing term; please use bpf_program__section_name() instead")
 203 const char *bpf_program__title(const struct bpf_program *prog, bool needs_copy);
 204 LIBBPF_API bool bpf_program__autoload(const struct bpf_program *prog);
 205 LIBBPF_API int bpf_program__set_autoload(struct bpf_program *prog, bool autoload);
 206
 207 /* returns program size in bytes */
 208 LIBBPF_API size_t bpf_program__size(const struct bpf_program *prog);
 209
 210 LIBBPF_API int bpf_program__load(struct bpf_program *prog, char *license,
 211                                  __u32 kern_version);
 212 LIBBPF_API int bpf_program__fd(const struct bpf_program *prog);
 213 LIBBPF_API int bpf_program__pin_instance(struct bpf_program *prog,
 214                                          const char *path,
 215                                          int instance);
 216 LIBBPF_API int bpf_program__unpin_instance(struct bpf_program *prog,
 217                                            const char *path,
 218                                            int instance);
 219 LIBBPF_API int bpf_program__pin(struct bpf_program *prog, const char *path);
 220 LIBBPF_API int bpf_program__unpin(struct bpf_program *prog, const char *path);
 221 LIBBPF_API void bpf_program__unload(struct bpf_program *prog);
 222
 223 struct bpf_link;
 224
 225 LIBBPF_API struct bpf_link *bpf_link__open(const char *path);
 226 LIBBPF_API int bpf_link__fd(const struct bpf_link *link);
 227 LIBBPF_API const char *bpf_link__pin_path(const struct bpf_link *link);
 228 LIBBPF_API int bpf_link__pin(struct bpf_link *link, const char *path);
 229 LIBBPF_API int bpf_link__unpin(struct bpf_link *link);
 230 LIBBPF_API int bpf_link__update_program(struct bpf_link *link,
 231                                         struct bpf_program *prog);
 232 LIBBPF_API void bpf_link__disconnect(struct bpf_link *link);
 233 LIBBPF_API int bpf_link__detach(struct bpf_link *link);
 234 LIBBPF_API int bpf_link__destroy(struct bpf_link *link);
 235
 236 LIBBPF_API struct bpf_link *
 237 bpf_program__attach(struct bpf_program *prog);
 238 LIBBPF_API struct bpf_link *
 239 bpf_program__attach_perf_event(struct bpf_program *prog, int pfd);
 240 LIBBPF_API struct bpf_link *
 241 bpf_program__attach_kprobe(struct bpf_program *prog, bool retprobe,
 242                            const char *func_name);
 243 LIBBPF_API struct bpf_link *
 244 bpf_program__attach_uprobe(struct bpf_program *prog, bool retprobe,
 245                            pid_t pid, const char *binary_path,
 246                            size_t func_offset);
 247 LIBBPF_API struct bpf_link *
 248 bpf_program__attach_tracepoint(struct bpf_program *prog,
 249                                const char *tp_category,
 250                                const char *tp_name);
 251 LIBBPF_API struct bpf_link *
 252 bpf_program__attach_raw_tracepoint(struct bpf_program *prog,
 253                                    const char *tp_name);
 254 LIBBPF_API struct bpf_link *
 255 bpf_program__attach_trace(struct bpf_program *prog);
 256 LIBBPF_API struct bpf_link *
 257 bpf_program__attach_lsm(struct bpf_program *prog);
 258 LIBBPF_API struct bpf_link *
 259 bpf_program__attach_cgroup(struct bpf_program *prog, int cgroup_fd);
 260 LIBBPF_API struct bpf_link *
 261 bpf_program__attach_netns(struct bpf_program *prog, int netns_fd);
 262 LIBBPF_API struct bpf_link *
 263 bpf_program__attach_xdp(struct bpf_program *prog, int ifindex);
 264 LIBBPF_API struct bpf_link *
 265 bpf_program__attach_freplace(struct bpf_program *prog,
 266                              int target_fd, const char *attach_func_name);
 267
 268 struct bpf_map;
 269
 270 LIBBPF_API struct bpf_link *bpf_map__attach_struct_ops(struct bpf_map *map);
 271
 272 struct bpf_iter_attach_opts {
 273         size_t sz; /* size of this struct for forward/backward compatibility */
 274         union bpf_iter_link_info *link_info;
 275         __u32 link_info_len;
 276 };
 277 #define bpf_iter_attach_opts__last_field link_info_len
 278
 279 LIBBPF_API struct bpf_link *
 280 bpf_program__attach_iter(struct bpf_program *prog,
 281                          const struct bpf_iter_attach_opts *opts);
 282
 283 struct bpf_insn;
 284
 285 /*
 286  * Libbpf allows callers to adjust BPF programs before being loaded
 287  * into kernel. One program in an object file can be transformed into
 288  * multiple variants to be attached to different hooks.
 289  *
 290  * bpf_program_prep_t, bpf_program__set_prep and bpf_program__nth_fd
 291  * form an API for this purpose.
 292  *
 293  * - bpf_program_prep_t:
 294  *   Defines a 'preprocessor', which is a caller defined function
 295  *   passed to libbpf through bpf_program__set_prep(), and will be
 296  *   called before program is loaded. The processor should adjust
 297  *   the program one time for each instance according to the instance id
 298  *   passed to it.
 299  *
 300  * - bpf_program__set_prep:
 301  *   Attaches a preprocessor to a BPF program. The number of instances
 302  *   that should be created is also passed through this function.
 303  *
 304  * - bpf_program__nth_fd:
 305  *   After the program is loaded, get resulting FD of a given instance
 306  *   of the BPF program.
 307  *
 308  * If bpf_program__set_prep() is not used, the program would be loaded
 309  * without adjustment during bpf_object__load(). The program has only
 310  * one instance. In this case bpf_program__fd(prog) is equal to
 311  * bpf_program__nth_fd(prog, 0).
 312  */
 313
 314 struct bpf_prog_prep_result {
 315         /*
 316          * If not NULL, load new instruction array.
 317          * If set to NULL, don't load this instance.
 318          */
 319         struct bpf_insn *new_insn_ptr;
 320         int new_insn_cnt;
 321
 322         /* If not NULL, result FD is written to it. */
 323         int *pfd;
 324 };
 325
 326 /*
 327  * Parameters of bpf_program_prep_t:
 328  *  - prog:     The bpf_program being loaded.
 329  *  - n:        Index of instance being generated.
 330  *  - insns:    BPF instructions array.
 331  *  - insns_cnt:Number of instructions in insns.
 332  *  - res:      Output parameter, result of transformation.
 333  *
 334  * Return value:
 335  *  - Zero:     pre-processing success.
 336  *  - Non-zero: pre-processing error, stop loading.
 337  */
 338 typedef int (*bpf_program_prep_t)(struct bpf_program *prog, int n,
 339                                   struct bpf_insn *insns, int insns_cnt,
 340                                   struct bpf_prog_prep_result *res);
 341
 342 LIBBPF_API int bpf_program__set_prep(struct bpf_program *prog, int nr_instance,
 343                                      bpf_program_prep_t prep);
 344
 345 LIBBPF_API int bpf_program__nth_fd(const struct bpf_program *prog, int n);
 346
 347 /*
 348  * Adjust type of BPF program. Default is kprobe.
 349  */
 350 LIBBPF_API int bpf_program__set_socket_filter(struct bpf_program *prog);
 351 LIBBPF_API int bpf_program__set_tracepoint(struct bpf_program *prog);
 352 LIBBPF_API int bpf_program__set_raw_tracepoint(struct bpf_program *prog);
 353 LIBBPF_API int bpf_program__set_kprobe(struct bpf_program *prog);
 354 LIBBPF_API int bpf_program__set_lsm(struct bpf_program *prog);
 355 LIBBPF_API int bpf_program__set_sched_cls(struct bpf_program *prog);
 356 LIBBPF_API int bpf_program__set_sched_act(struct bpf_program *prog);
 357 LIBBPF_API int bpf_program__set_xdp(struct bpf_program *prog);
 358 LIBBPF_API int bpf_program__set_perf_event(struct bpf_program *prog);
 359 LIBBPF_API int bpf_program__set_tracing(struct bpf_program *prog);
 360 LIBBPF_API int bpf_program__set_struct_ops(struct bpf_program *prog);
 361 LIBBPF_API int bpf_program__set_extension(struct bpf_program *prog);
 362 LIBBPF_API int bpf_program__set_sk_lookup(struct bpf_program *prog);
 363
 364 LIBBPF_API enum bpf_prog_type bpf_program__get_type(struct bpf_program *prog);
 365 LIBBPF_API void bpf_program__set_type(struct bpf_program *prog,
 366                                       enum bpf_prog_type type);
 367
 368 LIBBPF_API enum bpf_attach_type
 369 bpf_program__get_expected_attach_type(struct bpf_program *prog);
 370 LIBBPF_API void
 371 bpf_program__set_expected_attach_type(struct bpf_program *prog,
 372                                       enum bpf_attach_type type);
 373
 374 LIBBPF_API int
 375 bpf_program__set_attach_target(struct bpf_program *prog, int attach_prog_fd,
 376                                const char *attach_func_name);
 377
 378 LIBBPF_API bool bpf_program__is_socket_filter(const struct bpf_program *prog);
 379 LIBBPF_API bool bpf_program__is_tracepoint(const struct bpf_program *prog);
 380 LIBBPF_API bool bpf_program__is_raw_tracepoint(const struct bpf_program *prog);
 381 LIBBPF_API bool bpf_program__is_kprobe(const struct bpf_program *prog);
 382 LIBBPF_API bool bpf_program__is_lsm(const struct bpf_program *prog);
 383 LIBBPF_API bool bpf_program__is_sched_cls(const struct bpf_program *prog);
 384 LIBBPF_API bool bpf_program__is_sched_act(const struct bpf_program *prog);
 385 LIBBPF_API bool bpf_program__is_xdp(const struct bpf_program *prog);
 386 LIBBPF_API bool bpf_program__is_perf_event(const struct bpf_program *prog);
 387 LIBBPF_API bool bpf_program__is_tracing(const struct bpf_program *prog);
 388 LIBBPF_API bool bpf_program__is_struct_ops(const struct bpf_program *prog);
 389 LIBBPF_API bool bpf_program__is_extension(const struct bpf_program *prog);
 390 LIBBPF_API bool bpf_program__is_sk_lookup(const struct bpf_program *prog);
 391
 392 /*
 393  * No need for __attribute__((packed)), all members of 'bpf_map_def'
 394  * are all aligned.  In addition, using __attribute__((packed))
 395  * would trigger a -Wpacked warning message, and lead to an error
 396  * if -Werror is set.
 397  */
 398 struct bpf_map_def {
 399         unsigned int type;
 400         unsigned int key_size;
 401         unsigned int value_size;
 402         unsigned int max_entries;
 403         unsigned int map_flags;
 404 };
 405
 406 /*
 407  * The 'struct bpf_map' in include/linux/bpf.h is internal to the kernel,
 408  * so no need to worry about a name clash.
 409  */
 410 LIBBPF_API struct bpf_map *
 411 bpf_object__find_map_by_name(const struct bpf_object *obj, const char *name);
 412
 413 LIBBPF_API int
 414 bpf_object__find_map_fd_by_name(const struct bpf_object *obj, const char *name);
 415
 416 /*
 417  * Get bpf_map through the offset of corresponding struct bpf_map_def
 418  * in the BPF object file.
 419  */
 420 LIBBPF_API struct bpf_map *
 421 bpf_object__find_map_by_offset(struct bpf_object *obj, size_t offset);
 422
 423 LIBBPF_API struct bpf_map *
 424 bpf_map__next(const struct bpf_map *map, const struct bpf_object *obj);
 425 #define bpf_object__for_each_map(pos, obj)              \
 426         for ((pos) = bpf_map__next(NULL, (obj));        \
 427              (pos) != NULL;                             \
 428              (pos) = bpf_map__next((pos), (obj)))
 429 #define bpf_map__for_each bpf_object__for_each_map
 430
 431 LIBBPF_API struct bpf_map *
 432 bpf_map__prev(const struct bpf_map *map, const struct bpf_object *obj);
 433
 434 /* get/set map FD */
 435 LIBBPF_API int bpf_map__fd(const struct bpf_map *map);
 436 LIBBPF_API int bpf_map__reuse_fd(struct bpf_map *map, int fd);
 437 /* get map definition */
 438 LIBBPF_API const struct bpf_map_def *bpf_map__def(const struct bpf_map *map);
 439 /* get map name */
 440 LIBBPF_API const char *bpf_map__name(const struct bpf_map *map);
 441 /* get/set map type */
 442 LIBBPF_API enum bpf_map_type bpf_map__type(const struct bpf_map *map);
 443 LIBBPF_API int bpf_map__set_type(struct bpf_map *map, enum bpf_map_type type);
 444 /* get/set map size (max_entries) */
 445 LIBBPF_API __u32 bpf_map__max_entries(const struct bpf_map *map);
 446 LIBBPF_API int bpf_map__set_max_entries(struct bpf_map *map, __u32 max_entries);
 447 LIBBPF_API int bpf_map__resize(struct bpf_map *map, __u32 max_entries);
 448 /* get/set map flags */
 449 LIBBPF_API __u32 bpf_map__map_flags(const struct bpf_map *map);
 450 LIBBPF_API int bpf_map__set_map_flags(struct bpf_map *map, __u32 flags);
 451 /* get/set map NUMA node */
 452 LIBBPF_API __u32 bpf_map__numa_node(const struct bpf_map *map);
 453 LIBBPF_API int bpf_map__set_numa_node(struct bpf_map *map, __u32 numa_node);
 454 /* get/set map key size */
 455 LIBBPF_API __u32 bpf_map__key_size(const struct bpf_map *map);
 456 LIBBPF_API int bpf_map__set_key_size(struct bpf_map *map, __u32 size);
 457 /* get/set map value size */
 458 LIBBPF_API __u32 bpf_map__value_size(const struct bpf_map *map);
 459 LIBBPF_API int bpf_map__set_value_size(struct bpf_map *map, __u32 size);
 460 /* get map key/value BTF type IDs */
 461 LIBBPF_API __u32 bpf_map__btf_key_type_id(const struct bpf_map *map);
 462 LIBBPF_API __u32 bpf_map__btf_value_type_id(const struct bpf_map *map);
 463 /* get/set map if_index */
 464 LIBBPF_API __u32 bpf_map__ifindex(const struct bpf_map *map);
 465 LIBBPF_API int bpf_map__set_ifindex(struct bpf_map *map, __u32 ifindex);
 466
 467 typedef void (*bpf_map_clear_priv_t)(struct bpf_map *, void *);
 468 LIBBPF_API int bpf_map__set_priv(struct bpf_map *map, void *priv,
 469                                  bpf_map_clear_priv_t clear_priv);
 470 LIBBPF_API void *bpf_map__priv(const struct bpf_map *map);
 471 LIBBPF_API int bpf_map__set_initial_value(struct bpf_map *map,
 472                                           const void *data, size_t size);
 473 LIBBPF_API bool bpf_map__is_offload_neutral(const struct bpf_map *map);
 474 LIBBPF_API bool bpf_map__is_internal(const struct bpf_map *map);
 475 LIBBPF_API int bpf_map__set_pin_path(struct bpf_map *map, const char *path);
 476 LIBBPF_API const char *bpf_map__get_pin_path(const struct bpf_map *map);
 477 LIBBPF_API bool bpf_map__is_pinned(const struct bpf_map *map);
 478 LIBBPF_API int bpf_map__pin(struct bpf_map *map, const char *path);
 479 LIBBPF_API int bpf_map__unpin(struct bpf_map *map, const char *path);
 480
 481 LIBBPF_API int bpf_map__set_inner_map_fd(struct bpf_map *map, int fd);
 482
 483 LIBBPF_API long libbpf_get_error(const void *ptr);
 484
 485 struct bpf_prog_load_attr {
 486         const char *file;
 487         enum bpf_prog_type prog_type;
 488         enum bpf_attach_type expected_attach_type;
 489         int ifindex;
 490         int log_level;
 491         int prog_flags;
 492 };
 493
 494 LIBBPF_API int bpf_prog_load_xattr(const struct bpf_prog_load_attr *attr,
 495                                    struct bpf_object **pobj, int *prog_fd);
 496 LIBBPF_API int bpf_prog_load(const char *file, enum bpf_prog_type type,
 497                              struct bpf_object **pobj, int *prog_fd);
 498
 499 struct xdp_link_info {
 500         __u32 prog_id;
 501         __u32 drv_prog_id;
 502         __u32 hw_prog_id;
 503         __u32 skb_prog_id;
 504         __u8 attach_mode;
 505 };
 506
 507 struct bpf_xdp_set_link_opts {
 508         size_t sz;
 509         int old_fd;
 510 };
 511 #define bpf_xdp_set_link_opts__last_field old_fd
 512
 513 LIBBPF_API int bpf_set_link_xdp_fd(int ifindex, int fd, __u32 flags);
 514 LIBBPF_API int bpf_set_link_xdp_fd_opts(int ifindex, int fd, __u32 flags,
 515                                         const struct bpf_xdp_set_link_opts *opts);
 516 LIBBPF_API int bpf_get_link_xdp_id(int ifindex, __u32 *prog_id, __u32 flags);
 517 LIBBPF_API int bpf_get_link_xdp_info(int ifindex, struct xdp_link_info *info,
 518                                      size_t info_size, __u32 flags);
 519
 520 /* Ring buffer APIs */
 521 struct ring_buffer;
 522
 523 typedef int (*ring_buffer_sample_fn)(void *ctx, void *data, size_t size);
 524
 525 struct ring_buffer_opts {
 526         size_t sz; /* size of this struct, for forward/backward compatiblity */
 527 };
 528
 529 #define ring_buffer_opts__last_field sz
 530
 531 LIBBPF_API struct ring_buffer *
 532 ring_buffer__new(int map_fd, ring_buffer_sample_fn sample_cb, void *ctx,
 533                  const struct ring_buffer_opts *opts);
 534 LIBBPF_API void ring_buffer__free(struct ring_buffer *rb);
 535 LIBBPF_API int ring_buffer__add(struct ring_buffer *rb, int map_fd,
 536                                 ring_buffer_sample_fn sample_cb, void *ctx);
 537 LIBBPF_API int ring_buffer__poll(struct ring_buffer *rb, int timeout_ms);
 538 LIBBPF_API int ring_buffer__consume(struct ring_buffer *rb);
 539
 540 /* Perf buffer APIs */
 541 struct perf_buffer;
 542
 543 typedef void (*perf_buffer_sample_fn)(void *ctx, int cpu,
 544                                       void *data, __u32 size);
 545 typedef void (*perf_buffer_lost_fn)(void *ctx, int cpu, __u64 cnt);
 546
 547 /* common use perf buffer options */
 548 struct perf_buffer_opts {
 549         /* if specified, sample_cb is called for each sample */
 550         perf_buffer_sample_fn sample_cb;
 551         /* if specified, lost_cb is called for each batch of lost samples */
 552         perf_buffer_lost_fn lost_cb;
 553         /* ctx is provided to sample_cb and lost_cb */
 554         void *ctx;
 555 };
 556
 557 LIBBPF_API struct perf_buffer *
 558 perf_buffer__new(int map_fd, size_t page_cnt,
 559                  const struct perf_buffer_opts *opts);
 560
 561 enum bpf_perf_event_ret {
 562         LIBBPF_PERF_EVENT_DONE  = 0,
 563         LIBBPF_PERF_EVENT_ERROR = -1,
 564         LIBBPF_PERF_EVENT_CONT  = -2,
 565 };
 566
 567 struct perf_event_header;
 568
 569 typedef enum bpf_perf_event_ret
 570 (*perf_buffer_event_fn)(void *ctx, int cpu, struct perf_event_header *event);
 571
 572 /* raw perf buffer options, giving most power and control */
 573 struct perf_buffer_raw_opts {
 574         /* perf event attrs passed directly into perf_event_open() */
 575         struct perf_event_attr *attr;
 576         /* raw event callback */
 577         perf_buffer_event_fn event_cb;
 578         /* ctx is provided to event_cb */
 579         void *ctx;
 580         /* if cpu_cnt == 0, open all on all possible CPUs (up to the number of
 581          * max_entries of given PERF_EVENT_ARRAY map)
 582          */
 583         int cpu_cnt;
 584         /* if cpu_cnt > 0, cpus is an array of CPUs to open ring buffers on */
 585         int *cpus;
 586         /* if cpu_cnt > 0, map_keys specify map keys to set per-CPU FDs for */
 587         int *map_keys;
 588 };
 589
 590 LIBBPF_API struct perf_buffer *
 591 perf_buffer__new_raw(int map_fd, size_t page_cnt,
 592                      const struct perf_buffer_raw_opts *opts);
 593
 594 LIBBPF_API void perf_buffer__free(struct perf_buffer *pb);
 595 LIBBPF_API int perf_buffer__epoll_fd(const struct perf_buffer *pb);
 596 LIBBPF_API int perf_buffer__poll(struct perf_buffer *pb, int timeout_ms);
 597 LIBBPF_API int perf_buffer__consume(struct perf_buffer *pb);
 598 LIBBPF_API int perf_buffer__consume_buffer(struct perf_buffer *pb, size_t buf_idx);
 599 LIBBPF_API size_t perf_buffer__buffer_cnt(const struct perf_buffer *pb);
 600 LIBBPF_API int perf_buffer__buffer_fd(const struct perf_buffer *pb, size_t buf_idx);
 601
 602 typedef enum bpf_perf_event_ret
 603         (*bpf_perf_event_print_t)(struct perf_event_header *hdr,
 604                                   void *private_data);
 605 LIBBPF_API enum bpf_perf_event_ret
 606 bpf_perf_event_read_simple(void *mmap_mem, size_t mmap_size, size_t page_size,
 607                            void **copy_mem, size_t *copy_size,
 608                            bpf_perf_event_print_t fn, void *private_data);
 609
 610 struct bpf_prog_linfo;
 611 struct bpf_prog_info;
 612
 613 LIBBPF_API void bpf_prog_linfo__free(struct bpf_prog_linfo *prog_linfo);
 614 LIBBPF_API struct bpf_prog_linfo *
 615 bpf_prog_linfo__new(const struct bpf_prog_info *info);
 616 LIBBPF_API const struct bpf_line_info *
 617 bpf_prog_linfo__lfind_addr_func(const struct bpf_prog_linfo *prog_linfo,
 618                                 __u64 addr, __u32 func_idx, __u32 nr_skip);
 619 LIBBPF_API const struct bpf_line_info *
 620 bpf_prog_linfo__lfind(const struct bpf_prog_linfo *prog_linfo,
 621                       __u32 insn_off, __u32 nr_skip);
 622
 623 /*
 624  * Probe for supported system features
 625  *
 626  * Note that running many of these probes in a short amount of time can cause
 627  * the kernel to reach the maximal size of lockable memory allowed for the
 628  * user, causing subsequent probes to fail. In this case, the caller may want
 629  * to adjust that limit with setrlimit().
 630  */
 631 LIBBPF_API bool bpf_probe_prog_type(enum bpf_prog_type prog_type,
 632                                     __u32 ifindex);
 633 LIBBPF_API bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex);
 634 LIBBPF_API bool bpf_probe_helper(enum bpf_func_id id,
 635                                  enum bpf_prog_type prog_type, __u32 ifindex);
 636 LIBBPF_API bool bpf_probe_large_insn_limit(__u32 ifindex);
 637
 638 /*
 639  * Get bpf_prog_info in continuous memory
 640  *
 641  * struct bpf_prog_info has multiple arrays. The user has option to choose
 642  * arrays to fetch from kernel. The following APIs provide an uniform way to
 643  * fetch these data. All arrays in bpf_prog_info are stored in a single
 644  * continuous memory region. This makes it easy to store the info in a
 645  * file.
 646  *
 647  * Before writing bpf_prog_info_linear to files, it is necessary to
 648  * translate pointers in bpf_prog_info to offsets. Helper functions
 649  * bpf_program__bpil_addr_to_offs() and bpf_program__bpil_offs_to_addr()
 650  * are introduced to switch between pointers and offsets.
 651  *
 652  * Examples:
 653  *   # To fetch map_ids and prog_tags:
 654  *   __u64 arrays = (1UL << BPF_PROG_INFO_MAP_IDS) |
 655  *           (1UL << BPF_PROG_INFO_PROG_TAGS);
 656  *   struct bpf_prog_info_linear *info_linear =
 657  *           bpf_program__get_prog_info_linear(fd, arrays);
 658  *
 659  *   # To save data in file
 660  *   bpf_program__bpil_addr_to_offs(info_linear);
 661  *   write(f, info_linear, sizeof(*info_linear) + info_linear->data_len);
 662  *
 663  *   # To read data from file
 664  *   read(f, info_linear, <proper_size>);
 665  *   bpf_program__bpil_offs_to_addr(info_linear);
 666  */
 667 enum bpf_prog_info_array {
 668         BPF_PROG_INFO_FIRST_ARRAY = 0,
 669         BPF_PROG_INFO_JITED_INSNS = 0,
 670         BPF_PROG_INFO_XLATED_INSNS,
 671         BPF_PROG_INFO_MAP_IDS,
 672         BPF_PROG_INFO_JITED_KSYMS,
 673         BPF_PROG_INFO_JITED_FUNC_LENS,
 674         BPF_PROG_INFO_FUNC_INFO,
 675         BPF_PROG_INFO_LINE_INFO,
 676         BPF_PROG_INFO_JITED_LINE_INFO,
 677         BPF_PROG_INFO_PROG_TAGS,
 678         BPF_PROG_INFO_LAST_ARRAY,
 679 };
 680
 681 struct bpf_prog_info_linear {
 682         /* size of struct bpf_prog_info, when the tool is compiled */
 683         __u32                   info_len;
 684         /* total bytes allocated for data, round up to 8 bytes */
 685         __u32                   data_len;
 686         /* which arrays are included in data */
 687         __u64                   arrays;
 688         struct bpf_prog_info    info;
 689         __u8                    data[];
 690 };
 691
 692 LIBBPF_API struct bpf_prog_info_linear *
 693 bpf_program__get_prog_info_linear(int fd, __u64 arrays);
 694
 695 LIBBPF_API void
 696 bpf_program__bpil_addr_to_offs(struct bpf_prog_info_linear *info_linear);
 697
 698 LIBBPF_API void
 699 bpf_program__bpil_offs_to_addr(struct bpf_prog_info_linear *info_linear);
 700
 701 /*
 702  * A helper function to get the number of possible CPUs before looking up
 703  * per-CPU maps. Negative errno is returned on failure.
 704  *
 705  * Example usage:
 706  *
 707  *     int ncpus = libbpf_num_possible_cpus();
 708  *     if (ncpus < 0) {
 709  *          // error handling
 710  *     }
 711  *     long values[ncpus];
 712  *     bpf_map_lookup_elem(per_cpu_map_fd, key, values);
 713  *
 714  */
 715 LIBBPF_API int libbpf_num_possible_cpus(void);
 716
 717 struct bpf_map_skeleton {
 718         const char *name;
 719         struct bpf_map **map;
 720         void **mmaped;
 721 };
 722
 723 struct bpf_prog_skeleton {
 724         const char *name;
 725         struct bpf_program **prog;
 726         struct bpf_link **link;
 727 };
 728
 729 struct bpf_object_skeleton {
 730         size_t sz; /* size of this struct, for forward/backward compatibility */
 731
 732         const char *name;
 733         void *data;
 734         size_t data_sz;
 735
 736         struct bpf_object **obj;
 737
 738         int map_cnt;
 739         int map_skel_sz; /* sizeof(struct bpf_skeleton_map) */
 740         struct bpf_map_skeleton *maps;
 741
 742         int prog_cnt;
 743         int prog_skel_sz; /* sizeof(struct bpf_skeleton_prog) */
 744         struct bpf_prog_skeleton *progs;
 745 };
 746
 747 LIBBPF_API int
 748 bpf_object__open_skeleton(struct bpf_object_skeleton *s,
 749                           const struct bpf_object_open_opts *opts);
 750 LIBBPF_API int bpf_object__load_skeleton(struct bpf_object_skeleton *s);
 751 LIBBPF_API int bpf_object__attach_skeleton(struct bpf_object_skeleton *s);
 752 LIBBPF_API void bpf_object__detach_skeleton(struct bpf_object_skeleton *s);
 753 LIBBPF_API void bpf_object__destroy_skeleton(struct bpf_object_skeleton *s);
 754
 755 enum libbpf_tristate {
 756         TRI_NO = 0,
 757         TRI_YES = 1,
 758         TRI_MODULE = 2,
 759 };
 760
 761 #ifdef __cplusplus
 762 } /* extern "C" */
 763 #endif
 764
 765 #endif /* __LIBBPF_LIBBPF_H */