tools/lib/bpf/bpf.h

   1 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
   2
   3 /*
   4  * Common BPF ELF operations.
   5  *
   6  * Copyright (C) 2013-2015 Alexei Starovoitov <[email protected]>
   7  * Copyright (C) 2015 Wang Nan <[email protected]>
   8  * Copyright (C) 2015 Huawei Inc.
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation;
  13  * version 2.1 of the License (not later!)
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this program; if not,  see <http://www.gnu.org/licenses>
  22  */
  23 #ifndef __LIBBPF_BPF_H
  24 #define __LIBBPF_BPF_H
  25
  26 #include <linux/bpf.h>
  27 #include <stdbool.h>
  28 #include <stddef.h>
  29 #include <stdint.h>
  30
  31 #include "libbpf_common.h"
  32 #include "libbpf_legacy.h"
  33
  34 #ifdef __cplusplus
  35 extern "C" {
  36 #endif
  37
  38 int libbpf_set_memlock_rlim(size_t memlock_bytes);
  39
  40 struct bpf_map_create_opts {
  41         size_t sz; /* size of this struct for forward/backward compatibility */
  42
  43         __u32 btf_fd;
  44         __u32 btf_key_type_id;
  45         __u32 btf_value_type_id;
  46         __u32 btf_vmlinux_value_type_id;
  47
  48         __u32 inner_map_fd;
  49         __u32 map_flags;
  50         __u64 map_extra;
  51
  52         __u32 numa_node;
  53         __u32 map_ifindex;
  54 };
  55 #define bpf_map_create_opts__last_field map_ifindex
  56
  57 LIBBPF_API int bpf_map_create(enum bpf_map_type map_type,
  58                               const char *map_name,
  59                               __u32 key_size,
  60                               __u32 value_size,
  61                               __u32 max_entries,
  62                               const struct bpf_map_create_opts *opts);
  63
  64 struct bpf_prog_load_opts {
  65         size_t sz; /* size of this struct for forward/backward compatibility */
  66
  67         /* libbpf can retry BPF_PROG_LOAD command if bpf() syscall returns
  68          * -EAGAIN. This field determines how many attempts libbpf has to
  69          *  make. If not specified, libbpf will use default value of 5.
  70          */
  71         int attempts;
  72
  73         enum bpf_attach_type expected_attach_type;
  74         __u32 prog_btf_fd;
  75         __u32 prog_flags;
  76         __u32 prog_ifindex;
  77         __u32 kern_version;
  78
  79         __u32 attach_btf_id;
  80         __u32 attach_prog_fd;
  81         __u32 attach_btf_obj_fd;
  82
  83         const int *fd_array;
  84
  85         /* .BTF.ext func info data */
  86         const void *func_info;
  87         __u32 func_info_cnt;
  88         __u32 func_info_rec_size;
  89
  90         /* .BTF.ext line info data */
  91         const void *line_info;
  92         __u32 line_info_cnt;
  93         __u32 line_info_rec_size;
  94
  95         /* verifier log options */
  96         __u32 log_level;
  97         __u32 log_size;
  98         char *log_buf;
  99         /* output: actual total log contents size (including termintaing zero).
 100          * It could be both larger than original log_size (if log was
 101          * truncated), or smaller (if log buffer wasn't filled completely).
 102          * If kernel doesn't support this feature, log_size is left unchanged.
 103          */
 104         __u32 log_true_size;
 105         size_t :0;
 106 };
 107 #define bpf_prog_load_opts__last_field log_true_size
 108
 109 LIBBPF_API int bpf_prog_load(enum bpf_prog_type prog_type,
 110                              const char *prog_name, const char *license,
 111                              const struct bpf_insn *insns, size_t insn_cnt,
 112                              struct bpf_prog_load_opts *opts);
 113
 114 /* Flags to direct loading requirements */
 115 #define MAPS_RELAX_COMPAT       0x01
 116
 117 /* Recommended log buffer size */
 118 #define BPF_LOG_BUF_SIZE (UINT32_MAX >> 8) /* verifier maximum in kernels <= 5.1 */
 119
 120 struct bpf_btf_load_opts {
 121         size_t sz; /* size of this struct for forward/backward compatibility */
 122
 123         /* kernel log options */
 124         char *log_buf;
 125         __u32 log_level;
 126         __u32 log_size;
 127         /* output: actual total log contents size (including termintaing zero).
 128          * It could be both larger than original log_size (if log was
 129          * truncated), or smaller (if log buffer wasn't filled completely).
 130          * If kernel doesn't support this feature, log_size is left unchanged.
 131          */
 132         __u32 log_true_size;
 133         size_t :0;
 134 };
 135 #define bpf_btf_load_opts__last_field log_true_size
 136
 137 LIBBPF_API int bpf_btf_load(const void *btf_data, size_t btf_size,
 138                             struct bpf_btf_load_opts *opts);
 139
 140 LIBBPF_API int bpf_map_update_elem(int fd, const void *key, const void *value,
 141                                    __u64 flags);
 142
 143 LIBBPF_API int bpf_map_lookup_elem(int fd, const void *key, void *value);
 144 LIBBPF_API int bpf_map_lookup_elem_flags(int fd, const void *key, void *value,
 145                                          __u64 flags);
 146 LIBBPF_API int bpf_map_lookup_and_delete_elem(int fd, const void *key,
 147                                               void *value);
 148 LIBBPF_API int bpf_map_lookup_and_delete_elem_flags(int fd, const void *key,
 149                                                     void *value, __u64 flags);
 150 LIBBPF_API int bpf_map_delete_elem(int fd, const void *key);
 151 LIBBPF_API int bpf_map_delete_elem_flags(int fd, const void *key, __u64 flags);
 152 LIBBPF_API int bpf_map_get_next_key(int fd, const void *key, void *next_key);
 153 LIBBPF_API int bpf_map_freeze(int fd);
 154
 155 struct bpf_map_batch_opts {
 156         size_t sz; /* size of this struct for forward/backward compatibility */
 157         __u64 elem_flags;
 158         __u64 flags;
 159 };
 160 #define bpf_map_batch_opts__last_field flags
 161
 162
 163 /**
 164  * @brief **bpf_map_delete_batch()** allows for batch deletion of multiple
 165  * elements in a BPF map.
 166  *
 167  * @param fd BPF map file descriptor
 168  * @param keys pointer to an array of *count* keys
 169  * @param count input and output parameter; on input **count** represents the
 170  * number of  elements in the map to delete in batch;
 171  * on output if a non-EFAULT error is returned, **count** represents the number of deleted
 172  * elements if the output **count** value is not equal to the input **count** value
 173  * If EFAULT is returned, **count** should not be trusted to be correct.
 174  * @param opts options for configuring the way the batch deletion works
 175  * @return 0, on success; negative error code, otherwise (errno is also set to
 176  * the error code)
 177  */
 178 LIBBPF_API int bpf_map_delete_batch(int fd, const void *keys,
 179                                     __u32 *count,
 180                                     const struct bpf_map_batch_opts *opts);
 181
 182 /**
 183  * @brief **bpf_map_lookup_batch()** allows for batch lookup of BPF map elements.
 184  *
 185  * The parameter *in_batch* is the address of the first element in the batch to read.
 186  * *out_batch* is an output parameter that should be passed as *in_batch* to subsequent
 187  * calls to **bpf_map_lookup_batch()**. NULL can be passed for *in_batch* to indicate
 188  * that the batched lookup starts from the beginning of the map.
 189  *
 190  * The *keys* and *values* are output parameters which must point to memory large enough to
 191  * hold *count* items based on the key and value size of the map *map_fd*. The *keys*
 192  * buffer must be of *key_size* * *count*. The *values* buffer must be of
 193  * *value_size* * *count*.
 194  *
 195  * @param fd BPF map file descriptor
 196  * @param in_batch address of the first element in batch to read, can pass NULL to
 197  * indicate that the batched lookup starts from the beginning of the map.
 198  * @param out_batch output parameter that should be passed to next call as *in_batch*
 199  * @param keys pointer to an array large enough for *count* keys
 200  * @param values pointer to an array large enough for *count* values
 201  * @param count input and output parameter; on input it's the number of elements
 202  * in the map to read in batch; on output it's the number of elements that were
 203  * successfully read.
 204  * If a non-EFAULT error is returned, count will be set as the number of elements
 205  * that were read before the error occurred.
 206  * If EFAULT is returned, **count** should not be trusted to be correct.
 207  * @param opts options for configuring the way the batch lookup works
 208  * @return 0, on success; negative error code, otherwise (errno is also set to
 209  * the error code)
 210  */
 211 LIBBPF_API int bpf_map_lookup_batch(int fd, void *in_batch, void *out_batch,
 212                                     void *keys, void *values, __u32 *count,
 213                                     const struct bpf_map_batch_opts *opts);
 214
 215 /**
 216  * @brief **bpf_map_lookup_and_delete_batch()** allows for batch lookup and deletion
 217  * of BPF map elements where each element is deleted after being retrieved.
 218  *
 219  * @param fd BPF map file descriptor
 220  * @param in_batch address of the first element in batch to read, can pass NULL to
 221  * get address of the first element in *out_batch*
 222  * @param out_batch output parameter that should be passed to next call as *in_batch*
 223  * @param keys pointer to an array of *count* keys
 224  * @param values pointer to an array large enough for *count* values
 225  * @param count input and output parameter; on input it's the number of elements
 226  * in the map to read and delete in batch; on output it represents the number of
 227  * elements that were successfully read and deleted
 228  * If a non-**EFAULT** error code is returned and if the output **count** value
 229  * is not equal to the input **count** value, up to **count** elements may
 230  * have been deleted.
 231  * if **EFAULT** is returned up to *count* elements may have been deleted without
 232  * being returned via the *keys* and *values* output parameters.
 233  * @param opts options for configuring the way the batch lookup and delete works
 234  * @return 0, on success; negative error code, otherwise (errno is also set to
 235  * the error code)
 236  */
 237 LIBBPF_API int bpf_map_lookup_and_delete_batch(int fd, void *in_batch,
 238                                         void *out_batch, void *keys,
 239                                         void *values, __u32 *count,
 240                                         const struct bpf_map_batch_opts *opts);
 241
 242 /**
 243  * @brief **bpf_map_update_batch()** updates multiple elements in a map
 244  * by specifying keys and their corresponding values.
 245  *
 246  * The *keys* and *values* parameters must point to memory large enough
 247  * to hold *count* items based on the key and value size of the map.
 248  *
 249  * The *opts* parameter can be used to control how *bpf_map_update_batch()*
 250  * should handle keys that either do or do not already exist in the map.
 251  * In particular the *flags* parameter of *bpf_map_batch_opts* can be
 252  * one of the following:
 253  *
 254  * Note that *count* is an input and output parameter, where on output it
 255  * represents how many elements were successfully updated. Also note that if
 256  * **EFAULT** then *count* should not be trusted to be correct.
 257  *
 258  * **BPF_ANY**
 259  *    Create new elements or update existing.
 260  *
 261  * **BPF_NOEXIST**
 262  *    Create new elements only if they do not exist.
 263  *
 264  * **BPF_EXIST**
 265  *    Update existing elements.
 266  *
 267  * **BPF_F_LOCK**
 268  *    Update spin_lock-ed map elements. This must be
 269  *    specified if the map value contains a spinlock.
 270  *
 271  * @param fd BPF map file descriptor
 272  * @param keys pointer to an array of *count* keys
 273  * @param values pointer to an array of *count* values
 274  * @param count input and output parameter; on input it's the number of elements
 275  * in the map to update in batch; on output if a non-EFAULT error is returned,
 276  * **count** represents the number of updated elements if the output **count**
 277  * value is not equal to the input **count** value.
 278  * If EFAULT is returned, **count** should not be trusted to be correct.
 279  * @param opts options for configuring the way the batch update works
 280  * @return 0, on success; negative error code, otherwise (errno is also set to
 281  * the error code)
 282  */
 283 LIBBPF_API int bpf_map_update_batch(int fd, const void *keys, const void *values,
 284                                     __u32 *count,
 285                                     const struct bpf_map_batch_opts *opts);
 286
 287 struct bpf_obj_pin_opts {
 288         size_t sz; /* size of this struct for forward/backward compatibility */
 289
 290         __u32 file_flags;
 291         int path_fd;
 292
 293         size_t :0;
 294 };
 295 #define bpf_obj_pin_opts__last_field path_fd
 296
 297 LIBBPF_API int bpf_obj_pin(int fd, const char *pathname);
 298 LIBBPF_API int bpf_obj_pin_opts(int fd, const char *pathname,
 299                                 const struct bpf_obj_pin_opts *opts);
 300
 301 struct bpf_obj_get_opts {
 302         size_t sz; /* size of this struct for forward/backward compatibility */
 303
 304         __u32 file_flags;
 305         int path_fd;
 306
 307         size_t :0;
 308 };
 309 #define bpf_obj_get_opts__last_field path_fd
 310
 311 LIBBPF_API int bpf_obj_get(const char *pathname);
 312 LIBBPF_API int bpf_obj_get_opts(const char *pathname,
 313                                 const struct bpf_obj_get_opts *opts);
 314
 315 struct bpf_prog_attach_opts {
 316         size_t sz; /* size of this struct for forward/backward compatibility */
 317         unsigned int flags;
 318         int replace_prog_fd;
 319 };
 320 #define bpf_prog_attach_opts__last_field replace_prog_fd
 321
 322 LIBBPF_API int bpf_prog_attach(int prog_fd, int attachable_fd,
 323                                enum bpf_attach_type type, unsigned int flags);
 324 LIBBPF_API int bpf_prog_attach_opts(int prog_fd, int attachable_fd,
 325                                      enum bpf_attach_type type,
 326                                      const struct bpf_prog_attach_opts *opts);
 327 LIBBPF_API int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);
 328 LIBBPF_API int bpf_prog_detach2(int prog_fd, int attachable_fd,
 329                                 enum bpf_attach_type type);
 330
 331 union bpf_iter_link_info; /* defined in up-to-date linux/bpf.h */
 332 struct bpf_link_create_opts {
 333         size_t sz; /* size of this struct for forward/backward compatibility */
 334         __u32 flags;
 335         union bpf_iter_link_info *iter_info;
 336         __u32 iter_info_len;
 337         __u32 target_btf_id;
 338         union {
 339                 struct {
 340                         __u64 bpf_cookie;
 341                 } perf_event;
 342                 struct {
 343                         __u32 flags;
 344                         __u32 cnt;
 345                         const char **syms;
 346                         const unsigned long *addrs;
 347                         const __u64 *cookies;
 348                 } kprobe_multi;
 349                 struct {
 350                         __u64 cookie;
 351                 } tracing;
 352         };
 353         size_t :0;
 354 };
 355 #define bpf_link_create_opts__last_field kprobe_multi.cookies
 356
 357 LIBBPF_API int bpf_link_create(int prog_fd, int target_fd,
 358                                enum bpf_attach_type attach_type,
 359                                const struct bpf_link_create_opts *opts);
 360
 361 LIBBPF_API int bpf_link_detach(int link_fd);
 362
 363 struct bpf_link_update_opts {
 364         size_t sz; /* size of this struct for forward/backward compatibility */
 365         __u32 flags;       /* extra flags */
 366         __u32 old_prog_fd; /* expected old program FD */
 367         __u32 old_map_fd;  /* expected old map FD */
 368 };
 369 #define bpf_link_update_opts__last_field old_map_fd
 370
 371 LIBBPF_API int bpf_link_update(int link_fd, int new_prog_fd,
 372                                const struct bpf_link_update_opts *opts);
 373
 374 LIBBPF_API int bpf_iter_create(int link_fd);
 375
 376 struct bpf_prog_test_run_attr {
 377         int prog_fd;
 378         int repeat;
 379         const void *data_in;
 380         __u32 data_size_in;
 381         void *data_out;      /* optional */
 382         __u32 data_size_out; /* in: max length of data_out
 383                               * out: length of data_out */
 384         __u32 retval;        /* out: return code of the BPF program */
 385         __u32 duration;      /* out: average per repetition in ns */
 386         const void *ctx_in; /* optional */
 387         __u32 ctx_size_in;
 388         void *ctx_out;      /* optional */
 389         __u32 ctx_size_out; /* in: max length of ctx_out
 390                              * out: length of cxt_out */
 391 };
 392
 393 LIBBPF_API int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id);
 394 LIBBPF_API int bpf_map_get_next_id(__u32 start_id, __u32 *next_id);
 395 LIBBPF_API int bpf_btf_get_next_id(__u32 start_id, __u32 *next_id);
 396 LIBBPF_API int bpf_link_get_next_id(__u32 start_id, __u32 *next_id);
 397
 398 struct bpf_get_fd_by_id_opts {
 399         size_t sz; /* size of this struct for forward/backward compatibility */
 400         __u32 open_flags; /* permissions requested for the operation on fd */
 401         size_t :0;
 402 };
 403 #define bpf_get_fd_by_id_opts__last_field open_flags
 404
 405 LIBBPF_API int bpf_prog_get_fd_by_id(__u32 id);
 406 LIBBPF_API int bpf_prog_get_fd_by_id_opts(__u32 id,
 407                                 const struct bpf_get_fd_by_id_opts *opts);
 408 LIBBPF_API int bpf_map_get_fd_by_id(__u32 id);
 409 LIBBPF_API int bpf_map_get_fd_by_id_opts(__u32 id,
 410                                 const struct bpf_get_fd_by_id_opts *opts);
 411 LIBBPF_API int bpf_btf_get_fd_by_id(__u32 id);
 412 LIBBPF_API int bpf_btf_get_fd_by_id_opts(__u32 id,
 413                                 const struct bpf_get_fd_by_id_opts *opts);
 414 LIBBPF_API int bpf_link_get_fd_by_id(__u32 id);
 415 LIBBPF_API int bpf_link_get_fd_by_id_opts(__u32 id,
 416                                 const struct bpf_get_fd_by_id_opts *opts);
 417 LIBBPF_API int bpf_obj_get_info_by_fd(int bpf_fd, void *info, __u32 *info_len);
 418
 419 /**
 420  * @brief **bpf_prog_get_info_by_fd()** obtains information about the BPF
 421  * program corresponding to *prog_fd*.
 422  *
 423  * Populates up to *info_len* bytes of *info* and updates *info_len* with the
 424  * actual number of bytes written to *info*.
 425  *
 426  * @param prog_fd BPF program file descriptor
 427  * @param info pointer to **struct bpf_prog_info** that will be populated with
 428  * BPF program information
 429  * @param info_len pointer to the size of *info*; on success updated with the
 430  * number of bytes written to *info*
 431  * @return 0, on success; negative error code, otherwise (errno is also set to
 432  * the error code)
 433  */
 434 LIBBPF_API int bpf_prog_get_info_by_fd(int prog_fd, struct bpf_prog_info *info, __u32 *info_len);
 435
 436 /**
 437  * @brief **bpf_map_get_info_by_fd()** obtains information about the BPF
 438  * map corresponding to *map_fd*.
 439  *
 440  * Populates up to *info_len* bytes of *info* and updates *info_len* with the
 441  * actual number of bytes written to *info*.
 442  *
 443  * @param map_fd BPF map file descriptor
 444  * @param info pointer to **struct bpf_map_info** that will be populated with
 445  * BPF map information
 446  * @param info_len pointer to the size of *info*; on success updated with the
 447  * number of bytes written to *info*
 448  * @return 0, on success; negative error code, otherwise (errno is also set to
 449  * the error code)
 450  */
 451 LIBBPF_API int bpf_map_get_info_by_fd(int map_fd, struct bpf_map_info *info, __u32 *info_len);
 452
 453 /**
 454  * @brief **bpf_btf_get_info_by_fd()** obtains information about the
 455  * BTF object corresponding to *btf_fd*.
 456  *
 457  * Populates up to *info_len* bytes of *info* and updates *info_len* with the
 458  * actual number of bytes written to *info*.
 459  *
 460  * @param btf_fd BTF object file descriptor
 461  * @param info pointer to **struct bpf_btf_info** that will be populated with
 462  * BTF object information
 463  * @param info_len pointer to the size of *info*; on success updated with the
 464  * number of bytes written to *info*
 465  * @return 0, on success; negative error code, otherwise (errno is also set to
 466  * the error code)
 467  */
 468 LIBBPF_API int bpf_btf_get_info_by_fd(int btf_fd, struct bpf_btf_info *info, __u32 *info_len);
 469
 470 /**
 471  * @brief **bpf_btf_get_info_by_fd()** obtains information about the BPF
 472  * link corresponding to *link_fd*.
 473  *
 474  * Populates up to *info_len* bytes of *info* and updates *info_len* with the
 475  * actual number of bytes written to *info*.
 476  *
 477  * @param link_fd BPF link file descriptor
 478  * @param info pointer to **struct bpf_link_info** that will be populated with
 479  * BPF link information
 480  * @param info_len pointer to the size of *info*; on success updated with the
 481  * number of bytes written to *info*
 482  * @return 0, on success; negative error code, otherwise (errno is also set to
 483  * the error code)
 484  */
 485 LIBBPF_API int bpf_link_get_info_by_fd(int link_fd, struct bpf_link_info *info, __u32 *info_len);
 486
 487 struct bpf_prog_query_opts {
 488         size_t sz; /* size of this struct for forward/backward compatibility */
 489         __u32 query_flags;
 490         __u32 attach_flags; /* output argument */
 491         __u32 *prog_ids;
 492         __u32 prog_cnt; /* input+output argument */
 493         __u32 *prog_attach_flags;
 494 };
 495 #define bpf_prog_query_opts__last_field prog_attach_flags
 496
 497 LIBBPF_API int bpf_prog_query_opts(int target_fd,
 498                                    enum bpf_attach_type type,
 499                                    struct bpf_prog_query_opts *opts);
 500 LIBBPF_API int bpf_prog_query(int target_fd, enum bpf_attach_type type,
 501                               __u32 query_flags, __u32 *attach_flags,
 502                               __u32 *prog_ids, __u32 *prog_cnt);
 503
 504 LIBBPF_API int bpf_raw_tracepoint_open(const char *name, int prog_fd);
 505 LIBBPF_API int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf,
 506                                  __u32 *buf_len, __u32 *prog_id, __u32 *fd_type,
 507                                  __u64 *probe_offset, __u64 *probe_addr);
 508
 509 #ifdef __cplusplus
 510 /* forward-declaring enums in C++ isn't compatible with pure C enums, so
 511  * instead define bpf_enable_stats() as accepting int as an input
 512  */
 513 LIBBPF_API int bpf_enable_stats(int type);
 514 #else
 515 enum bpf_stats_type; /* defined in up-to-date linux/bpf.h */
 516 LIBBPF_API int bpf_enable_stats(enum bpf_stats_type type);
 517 #endif
 518
 519 struct bpf_prog_bind_opts {
 520         size_t sz; /* size of this struct for forward/backward compatibility */
 521         __u32 flags;
 522 };
 523 #define bpf_prog_bind_opts__last_field flags
 524
 525 LIBBPF_API int bpf_prog_bind_map(int prog_fd, int map_fd,
 526                                  const struct bpf_prog_bind_opts *opts);
 527
 528 struct bpf_test_run_opts {
 529         size_t sz; /* size of this struct for forward/backward compatibility */
 530         const void *data_in; /* optional */
 531         void *data_out;      /* optional */
 532         __u32 data_size_in;
 533         __u32 data_size_out; /* in: max length of data_out
 534                               * out: length of data_out
 535                               */
 536         const void *ctx_in; /* optional */
 537         void *ctx_out;      /* optional */
 538         __u32 ctx_size_in;
 539         __u32 ctx_size_out; /* in: max length of ctx_out
 540                              * out: length of cxt_out
 541                              */
 542         __u32 retval;        /* out: return code of the BPF program */
 543         int repeat;
 544         __u32 duration;      /* out: average per repetition in ns */
 545         __u32 flags;
 546         __u32 cpu;
 547         __u32 batch_size;
 548 };
 549 #define bpf_test_run_opts__last_field batch_size
 550
 551 LIBBPF_API int bpf_prog_test_run_opts(int prog_fd,
 552                                       struct bpf_test_run_opts *opts);
 553
 554 #ifdef __cplusplus
 555 } /* extern "C" */
 556 #endif
 557
 558 #endif /* __LIBBPF_BPF_H */