tools/lib/bpf/libbpf_internal.h

   1 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
   2
   3 /*
   4  * Internal libbpf helpers.
   5  *
   6  * Copyright (c) 2019 Facebook
   7  */
   8
   9 #ifndef __LIBBPF_LIBBPF_INTERNAL_H
  10 #define __LIBBPF_LIBBPF_INTERNAL_H
  11
  12 #include <stdlib.h>
  13 #include <limits.h>
  14 #include <errno.h>
  15 #include <linux/err.h>
  16 #include <fcntl.h>
  17 #include <unistd.h>
  18 #include "relo_core.h"
  19
  20 /* make sure libbpf doesn't use kernel-only integer typedefs */
  21 #pragma GCC poison u8 u16 u32 u64 s8 s16 s32 s64
  22
  23 /* prevent accidental re-addition of reallocarray() */
  24 #pragma GCC poison reallocarray
  25
  26 #include "libbpf.h"
  27 #include "btf.h"
  28
  29 #ifndef EM_BPF
  30 #define EM_BPF 247
  31 #endif
  32
  33 #ifndef R_BPF_64_64
  34 #define R_BPF_64_64 1
  35 #endif
  36 #ifndef R_BPF_64_ABS64
  37 #define R_BPF_64_ABS64 2
  38 #endif
  39 #ifndef R_BPF_64_ABS32
  40 #define R_BPF_64_ABS32 3
  41 #endif
  42 #ifndef R_BPF_64_32
  43 #define R_BPF_64_32 10
  44 #endif
  45
  46 #ifndef SHT_LLVM_ADDRSIG
  47 #define SHT_LLVM_ADDRSIG 0x6FFF4C03
  48 #endif
  49
  50 /* if libelf is old and doesn't support mmap(), fall back to read() */
  51 #ifndef ELF_C_READ_MMAP
  52 #define ELF_C_READ_MMAP ELF_C_READ
  53 #endif
  54
  55 /* Older libelf all end up in this expression, for both 32 and 64 bit */
  56 #ifndef ELF64_ST_VISIBILITY
  57 #define ELF64_ST_VISIBILITY(o) ((o) & 0x03)
  58 #endif
  59
  60 #define BTF_INFO_ENC(kind, kind_flag, vlen) \
  61         ((!!(kind_flag) << 31) | ((kind) << 24) | ((vlen) & BTF_MAX_VLEN))
  62 #define BTF_TYPE_ENC(name, info, size_or_type) (name), (info), (size_or_type)
  63 #define BTF_INT_ENC(encoding, bits_offset, nr_bits) \
  64         ((encoding) << 24 | (bits_offset) << 16 | (nr_bits))
  65 #define BTF_TYPE_INT_ENC(name, encoding, bits_offset, bits, sz) \
  66         BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_INT, 0, 0), sz), \
  67         BTF_INT_ENC(encoding, bits_offset, bits)
  68 #define BTF_MEMBER_ENC(name, type, bits_offset) (name), (type), (bits_offset)
  69 #define BTF_PARAM_ENC(name, type) (name), (type)
  70 #define BTF_VAR_SECINFO_ENC(type, offset, size) (type), (offset), (size)
  71 #define BTF_TYPE_FLOAT_ENC(name, sz) \
  72         BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 0), sz)
  73 #define BTF_TYPE_DECL_TAG_ENC(value, type, component_idx) \
  74         BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 0), type), (component_idx)
  75 #define BTF_TYPE_TYPE_TAG_ENC(value, type) \
  76         BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_TYPE_TAG, 0, 0), type)
  77
  78 #ifndef likely
  79 #define likely(x) __builtin_expect(!!(x), 1)
  80 #endif
  81 #ifndef unlikely
  82 #define unlikely(x) __builtin_expect(!!(x), 0)
  83 #endif
  84 #ifndef min
  85 # define min(x, y) ((x) < (y) ? (x) : (y))
  86 #endif
  87 #ifndef max
  88 # define max(x, y) ((x) < (y) ? (y) : (x))
  89 #endif
  90 #ifndef offsetofend
  91 # define offsetofend(TYPE, FIELD) \
  92         (offsetof(TYPE, FIELD) + sizeof(((TYPE *)0)->FIELD))
  93 #endif
  94 #ifndef __alias
  95 #define __alias(symbol) __attribute__((alias(#symbol)))
  96 #endif
  97
  98 /* Check whether a string `str` has prefix `pfx`, regardless if `pfx` is
  99  * a string literal known at compilation time or char * pointer known only at
 100  * runtime.
 101  */
 102 #define str_has_pfx(str, pfx) \
 103         (strncmp(str, pfx, __builtin_constant_p(pfx) ? sizeof(pfx) - 1 : strlen(pfx)) == 0)
 104
 105 /* suffix check */
 106 static inline bool str_has_sfx(const char *str, const char *sfx)
 107 {
 108         size_t str_len = strlen(str);
 109         size_t sfx_len = strlen(sfx);
 110
 111         if (sfx_len <= str_len)
 112                 return strcmp(str + str_len - sfx_len, sfx);
 113         return false;
 114 }
 115
 116 /* Symbol versioning is different between static and shared library.
 117  * Properly versioned symbols are needed for shared library, but
 118  * only the symbol of the new version is needed for static library.
 119  * Starting with GNU C 10, use symver attribute instead of .symver assembler
 120  * directive, which works better with GCC LTO builds.
 121  */
 122 #if defined(SHARED) && defined(__GNUC__) && __GNUC__ >= 10
 123
 124 #define DEFAULT_VERSION(internal_name, api_name, version) \
 125         __attribute__((symver(#api_name "@@" #version)))
 126 #define COMPAT_VERSION(internal_name, api_name, version) \
 127         __attribute__((symver(#api_name "@" #version)))
 128
 129 #elif defined(SHARED)
 130
 131 #define COMPAT_VERSION(internal_name, api_name, version) \
 132         asm(".symver " #internal_name "," #api_name "@" #version);
 133 #define DEFAULT_VERSION(internal_name, api_name, version) \
 134         asm(".symver " #internal_name "," #api_name "@@" #version);
 135
 136 #else /* !SHARED */
 137
 138 #define COMPAT_VERSION(internal_name, api_name, version)
 139 #define DEFAULT_VERSION(internal_name, api_name, version) \
 140         extern typeof(internal_name) api_name \
 141         __attribute__((alias(#internal_name)));
 142
 143 #endif
 144
 145 extern void libbpf_print(enum libbpf_print_level level,
 146                          const char *format, ...)
 147         __attribute__((format(printf, 2, 3)));
 148
 149 #define __pr(level, fmt, ...)   \
 150 do {                            \
 151         libbpf_print(level, "libbpf: " fmt, ##__VA_ARGS__);     \
 152 } while (0)
 153
 154 #define pr_warn(fmt, ...)       __pr(LIBBPF_WARN, fmt, ##__VA_ARGS__)
 155 #define pr_info(fmt, ...)       __pr(LIBBPF_INFO, fmt, ##__VA_ARGS__)
 156 #define pr_debug(fmt, ...)      __pr(LIBBPF_DEBUG, fmt, ##__VA_ARGS__)
 157
 158 #ifndef __has_builtin
 159 #define __has_builtin(x) 0
 160 #endif
 161
 162 struct bpf_link {
 163         int (*detach)(struct bpf_link *link);
 164         void (*dealloc)(struct bpf_link *link);
 165         char *pin_path;         /* NULL, if not pinned */
 166         int fd;                 /* hook FD, -1 if not applicable */
 167         bool disconnected;
 168 };
 169
 170 /*
 171  * Re-implement glibc's reallocarray() for libbpf internal-only use.
 172  * reallocarray(), unfortunately, is not available in all versions of glibc,
 173  * so requires extra feature detection and using reallocarray() stub from
 174  * <tools/libc_compat.h> and COMPAT_NEED_REALLOCARRAY. All this complicates
 175  * build of libbpf unnecessarily and is just a maintenance burden. Instead,
 176  * it's trivial to implement libbpf-specific internal version and use it
 177  * throughout libbpf.
 178  */
 179 static inline void *libbpf_reallocarray(void *ptr, size_t nmemb, size_t size)
 180 {
 181         size_t total;
 182
 183 #if __has_builtin(__builtin_mul_overflow)
 184         if (unlikely(__builtin_mul_overflow(nmemb, size, &total)))
 185                 return NULL;
 186 #else
 187         if (size == 0 || nmemb > ULONG_MAX / size)
 188                 return NULL;
 189         total = nmemb * size;
 190 #endif
 191         return realloc(ptr, total);
 192 }
 193
 194 /* Copy up to sz - 1 bytes from zero-terminated src string and ensure that dst
 195  * is zero-terminated string no matter what (unless sz == 0, in which case
 196  * it's a no-op). It's conceptually close to FreeBSD's strlcpy(), but differs
 197  * in what is returned. Given this is internal helper, it's trivial to extend
 198  * this, when necessary. Use this instead of strncpy inside libbpf source code.
 199  */
 200 static inline void libbpf_strlcpy(char *dst, const char *src, size_t sz)
 201 {
 202         size_t i;
 203
 204         if (sz == 0)
 205                 return;
 206
 207         sz--;
 208         for (i = 0; i < sz && src[i]; i++)
 209                 dst[i] = src[i];
 210         dst[i] = '\0';
 211 }
 212
 213 __u32 get_kernel_version(void);
 214
 215 struct btf;
 216 struct btf_type;
 217
 218 struct btf_type *btf_type_by_id(const struct btf *btf, __u32 type_id);
 219 const char *btf_kind_str(const struct btf_type *t);
 220 const struct btf_type *skip_mods_and_typedefs(const struct btf *btf, __u32 id, __u32 *res_id);
 221
 222 static inline enum btf_func_linkage btf_func_linkage(const struct btf_type *t)
 223 {
 224         return (enum btf_func_linkage)(int)btf_vlen(t);
 225 }
 226
 227 static inline __u32 btf_type_info(int kind, int vlen, int kflag)
 228 {
 229         return (kflag << 31) | (kind << 24) | vlen;
 230 }
 231
 232 enum map_def_parts {
 233         MAP_DEF_MAP_TYPE        = 0x001,
 234         MAP_DEF_KEY_TYPE        = 0x002,
 235         MAP_DEF_KEY_SIZE        = 0x004,
 236         MAP_DEF_VALUE_TYPE      = 0x008,
 237         MAP_DEF_VALUE_SIZE      = 0x010,
 238         MAP_DEF_MAX_ENTRIES     = 0x020,
 239         MAP_DEF_MAP_FLAGS       = 0x040,
 240         MAP_DEF_NUMA_NODE       = 0x080,
 241         MAP_DEF_PINNING         = 0x100,
 242         MAP_DEF_INNER_MAP       = 0x200,
 243         MAP_DEF_MAP_EXTRA       = 0x400,
 244
 245         MAP_DEF_ALL             = 0x7ff, /* combination of all above */
 246 };
 247
 248 struct btf_map_def {
 249         enum map_def_parts parts;
 250         __u32 map_type;
 251         __u32 key_type_id;
 252         __u32 key_size;
 253         __u32 value_type_id;
 254         __u32 value_size;
 255         __u32 max_entries;
 256         __u32 map_flags;
 257         __u32 numa_node;
 258         __u32 pinning;
 259         __u64 map_extra;
 260 };
 261
 262 int parse_btf_map_def(const char *map_name, struct btf *btf,
 263                       const struct btf_type *def_t, bool strict,
 264                       struct btf_map_def *map_def, struct btf_map_def *inner_def);
 265
 266 void *libbpf_add_mem(void **data, size_t *cap_cnt, size_t elem_sz,
 267                      size_t cur_cnt, size_t max_cnt, size_t add_cnt);
 268 int libbpf_ensure_mem(void **data, size_t *cap_cnt, size_t elem_sz, size_t need_cnt);
 269
 270 static inline bool libbpf_is_mem_zeroed(const char *p, ssize_t len)
 271 {
 272         while (len > 0) {
 273                 if (*p)
 274                         return false;
 275                 p++;
 276                 len--;
 277         }
 278         return true;
 279 }
 280
 281 static inline bool libbpf_validate_opts(const char *opts,
 282                                         size_t opts_sz, size_t user_sz,
 283                                         const char *type_name)
 284 {
 285         if (user_sz < sizeof(size_t)) {
 286                 pr_warn("%s size (%zu) is too small\n", type_name, user_sz);
 287                 return false;
 288         }
 289         if (!libbpf_is_mem_zeroed(opts + opts_sz, (ssize_t)user_sz - opts_sz)) {
 290                 pr_warn("%s has non-zero extra bytes\n", type_name);
 291                 return false;
 292         }
 293         return true;
 294 }
 295
 296 #define OPTS_VALID(opts, type)                                                \
 297         (!(opts) || libbpf_validate_opts((const char *)opts,                  \
 298                                          offsetofend(struct type,             \
 299                                                      type##__last_field),     \
 300                                          (opts)->sz, #type))
 301 #define OPTS_HAS(opts, field) \
 302         ((opts) && opts->sz >= offsetofend(typeof(*(opts)), field))
 303 #define OPTS_GET(opts, field, fallback_value) \
 304         (OPTS_HAS(opts, field) ? (opts)->field : fallback_value)
 305 #define OPTS_SET(opts, field, value)            \
 306         do {                                    \
 307                 if (OPTS_HAS(opts, field))      \
 308                         (opts)->field = value;  \
 309         } while (0)
 310
 311 #define OPTS_ZEROED(opts, last_nonzero_field)                                 \
 312 ({                                                                            \
 313         ssize_t __off = offsetofend(typeof(*(opts)), last_nonzero_field);     \
 314         !(opts) || libbpf_is_mem_zeroed((const void *)opts + __off,           \
 315                                         (opts)->sz - __off);                  \
 316 })
 317
 318 enum kern_feature_id {
 319         /* v4.14: kernel support for program & map names. */
 320         FEAT_PROG_NAME,
 321         /* v5.2: kernel support for global data sections. */
 322         FEAT_GLOBAL_DATA,
 323         /* BTF support */
 324         FEAT_BTF,
 325         /* BTF_KIND_FUNC and BTF_KIND_FUNC_PROTO support */
 326         FEAT_BTF_FUNC,
 327         /* BTF_KIND_VAR and BTF_KIND_DATASEC support */
 328         FEAT_BTF_DATASEC,
 329         /* BTF_FUNC_GLOBAL is supported */
 330         FEAT_BTF_GLOBAL_FUNC,
 331         /* BPF_F_MMAPABLE is supported for arrays */
 332         FEAT_ARRAY_MMAP,
 333         /* kernel support for expected_attach_type in BPF_PROG_LOAD */
 334         FEAT_EXP_ATTACH_TYPE,
 335         /* bpf_probe_read_{kernel,user}[_str] helpers */
 336         FEAT_PROBE_READ_KERN,
 337         /* BPF_PROG_BIND_MAP is supported */
 338         FEAT_PROG_BIND_MAP,
 339         /* Kernel support for module BTFs */
 340         FEAT_MODULE_BTF,
 341         /* BTF_KIND_FLOAT support */
 342         FEAT_BTF_FLOAT,
 343         /* BPF perf link support */
 344         FEAT_PERF_LINK,
 345         /* BTF_KIND_DECL_TAG support */
 346         FEAT_BTF_DECL_TAG,
 347         /* BTF_KIND_TYPE_TAG support */
 348         FEAT_BTF_TYPE_TAG,
 349         /* memcg-based accounting for BPF maps and progs */
 350         FEAT_MEMCG_ACCOUNT,
 351         /* BPF cookie (bpf_get_attach_cookie() BPF helper) support */
 352         FEAT_BPF_COOKIE,
 353         /* BTF_KIND_ENUM64 support and BTF_KIND_ENUM kflag support */
 354         FEAT_BTF_ENUM64,
 355         __FEAT_CNT,
 356 };
 357
 358 int probe_memcg_account(void);
 359 bool kernel_supports(const struct bpf_object *obj, enum kern_feature_id feat_id);
 360 int bump_rlimit_memlock(void);
 361
 362 int parse_cpu_mask_str(const char *s, bool **mask, int *mask_sz);
 363 int parse_cpu_mask_file(const char *fcpu, bool **mask, int *mask_sz);
 364 int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
 365                          const char *str_sec, size_t str_len);
 366 int btf_load_into_kernel(struct btf *btf, char *log_buf, size_t log_sz, __u32 log_level);
 367
 368 struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf);
 369 void btf_get_kernel_prefix_kind(enum bpf_attach_type attach_type,
 370                                 const char **prefix, int *kind);
 371
 372 struct btf_ext_info {
 373         /*
 374          * info points to the individual info section (e.g. func_info and
 375          * line_info) from the .BTF.ext. It does not include the __u32 rec_size.
 376          */
 377         void *info;
 378         __u32 rec_size;
 379         __u32 len;
 380         /* optional (maintained internally by libbpf) mapping between .BTF.ext
 381          * section and corresponding ELF section. This is used to join
 382          * information like CO-RE relocation records with corresponding BPF
 383          * programs defined in ELF sections
 384          */
 385         __u32 *sec_idxs;
 386         int sec_cnt;
 387 };
 388
 389 #define for_each_btf_ext_sec(seg, sec)                                  \
 390         for (sec = (seg)->info;                                         \
 391              (void *)sec < (seg)->info + (seg)->len;                    \
 392              sec = (void *)sec + sizeof(struct btf_ext_info_sec) +      \
 393                    (seg)->rec_size * sec->num_info)
 394
 395 #define for_each_btf_ext_rec(seg, sec, i, rec)                          \
 396         for (i = 0, rec = (void *)&(sec)->data;                         \
 397              i < (sec)->num_info;                                       \
 398              i++, rec = (void *)rec + (seg)->rec_size)
 399
 400 /*
 401  * The .BTF.ext ELF section layout defined as
 402  *   struct btf_ext_header
 403  *   func_info subsection
 404  *
 405  * The func_info subsection layout:
 406  *   record size for struct bpf_func_info in the func_info subsection
 407  *   struct btf_sec_func_info for section #1
 408  *   a list of bpf_func_info records for section #1
 409  *     where struct bpf_func_info mimics one in include/uapi/linux/bpf.h
 410  *     but may not be identical
 411  *   struct btf_sec_func_info for section #2
 412  *   a list of bpf_func_info records for section #2
 413  *   ......
 414  *
 415  * Note that the bpf_func_info record size in .BTF.ext may not
 416  * be the same as the one defined in include/uapi/linux/bpf.h.
 417  * The loader should ensure that record_size meets minimum
 418  * requirement and pass the record as is to the kernel. The
 419  * kernel will handle the func_info properly based on its contents.
 420  */
 421 struct btf_ext_header {
 422         __u16   magic;
 423         __u8    version;
 424         __u8    flags;
 425         __u32   hdr_len;
 426
 427         /* All offsets are in bytes relative to the end of this header */
 428         __u32   func_info_off;
 429         __u32   func_info_len;
 430         __u32   line_info_off;
 431         __u32   line_info_len;
 432
 433         /* optional part of .BTF.ext header */
 434         __u32   core_relo_off;
 435         __u32   core_relo_len;
 436 };
 437
 438 struct btf_ext {
 439         union {
 440                 struct btf_ext_header *hdr;
 441                 void *data;
 442         };
 443         struct btf_ext_info func_info;
 444         struct btf_ext_info line_info;
 445         struct btf_ext_info core_relo_info;
 446         __u32 data_size;
 447 };
 448
 449 struct btf_ext_info_sec {
 450         __u32   sec_name_off;
 451         __u32   num_info;
 452         /* Followed by num_info * record_size number of bytes */
 453         __u8    data[];
 454 };
 455
 456 /* The minimum bpf_func_info checked by the loader */
 457 struct bpf_func_info_min {
 458         __u32   insn_off;
 459         __u32   type_id;
 460 };
 461
 462 /* The minimum bpf_line_info checked by the loader */
 463 struct bpf_line_info_min {
 464         __u32   insn_off;
 465         __u32   file_name_off;
 466         __u32   line_off;
 467         __u32   line_col;
 468 };
 469
 470
 471 typedef int (*type_id_visit_fn)(__u32 *type_id, void *ctx);
 472 typedef int (*str_off_visit_fn)(__u32 *str_off, void *ctx);
 473 int btf_type_visit_type_ids(struct btf_type *t, type_id_visit_fn visit, void *ctx);
 474 int btf_type_visit_str_offs(struct btf_type *t, str_off_visit_fn visit, void *ctx);
 475 int btf_ext_visit_type_ids(struct btf_ext *btf_ext, type_id_visit_fn visit, void *ctx);
 476 int btf_ext_visit_str_offs(struct btf_ext *btf_ext, str_off_visit_fn visit, void *ctx);
 477 __s32 btf__find_by_name_kind_own(const struct btf *btf, const char *type_name,
 478                                  __u32 kind);
 479
 480 typedef int (*kallsyms_cb_t)(unsigned long long sym_addr, char sym_type,
 481                              const char *sym_name, void *ctx);
 482
 483 int libbpf_kallsyms_parse(kallsyms_cb_t cb, void *arg);
 484
 485 /* handle direct returned errors */
 486 static inline int libbpf_err(int ret)
 487 {
 488         if (ret < 0)
 489                 errno = -ret;
 490         return ret;
 491 }
 492
 493 /* handle errno-based (e.g., syscall or libc) errors according to libbpf's
 494  * strict mode settings
 495  */
 496 static inline int libbpf_err_errno(int ret)
 497 {
 498         /* errno is already assumed to be set on error */
 499         return ret < 0 ? -errno : ret;
 500 }
 501
 502 /* handle error for pointer-returning APIs, err is assumed to be < 0 always */
 503 static inline void *libbpf_err_ptr(int err)
 504 {
 505         /* set errno on error, this doesn't break anything */
 506         errno = -err;
 507         return NULL;
 508 }
 509
 510 /* handle pointer-returning APIs' error handling */
 511 static inline void *libbpf_ptr(void *ret)
 512 {
 513         /* set errno on error, this doesn't break anything */
 514         if (IS_ERR(ret))
 515                 errno = -PTR_ERR(ret);
 516
 517         return IS_ERR(ret) ? NULL : ret;
 518 }
 519
 520 static inline bool str_is_empty(const char *s)
 521 {
 522         return !s || !s[0];
 523 }
 524
 525 static inline bool is_ldimm64_insn(struct bpf_insn *insn)
 526 {
 527         return insn->code == (BPF_LD | BPF_IMM | BPF_DW);
 528 }
 529
 530 /* if fd is stdin, stdout, or stderr, dup to a fd greater than 2
 531  * Takes ownership of the fd passed in, and closes it if calling
 532  * fcntl(fd, F_DUPFD_CLOEXEC, 3).
 533  */
 534 static inline int ensure_good_fd(int fd)
 535 {
 536         int old_fd = fd, saved_errno;
 537
 538         if (fd < 0)
 539                 return fd;
 540         if (fd < 3) {
 541                 fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 542                 saved_errno = errno;
 543                 close(old_fd);
 544                 if (fd < 0) {
 545                         pr_warn("failed to dup FD %d to FD > 2: %d\n", old_fd, -saved_errno);
 546                         errno = saved_errno;
 547                 }
 548         }
 549         return fd;
 550 }
 551
 552 /* The following two functions are exposed to bpftool */
 553 int bpf_core_add_cands(struct bpf_core_cand *local_cand,
 554                        size_t local_essent_len,
 555                        const struct btf *targ_btf,
 556                        const char *targ_btf_name,
 557                        int targ_start_id,
 558                        struct bpf_core_cand_list *cands);
 559 void bpf_core_free_cands(struct bpf_core_cand_list *cands);
 560
 561 struct usdt_manager *usdt_manager_new(struct bpf_object *obj);
 562 void usdt_manager_free(struct usdt_manager *man);
 563 struct bpf_link * usdt_manager_attach_usdt(struct usdt_manager *man,
 564                                            const struct bpf_program *prog,
 565                                            pid_t pid, const char *path,
 566                                            const char *usdt_provider, const char *usdt_name,
 567                                            __u64 usdt_cookie);
 568
 569 static inline bool is_pow_of_2(size_t x)
 570 {
 571         return x && (x & (x - 1)) == 0;
 572 }
 573
 574 #endif /* __LIBBPF_LIBBPF_INTERNAL_H */