tools/lib/bpf/btf.h

   1 /* SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) */
   2 /* Copyright (c) 2018 Facebook */
   3
   4 #ifndef __LIBBPF_BTF_H
   5 #define __LIBBPF_BTF_H
   6
   7 #include <stdarg.h>
   8 #include <linux/btf.h>
   9 #include <linux/types.h>
  10
  11 #include "libbpf_common.h"
  12
  13 #ifdef __cplusplus
  14 extern "C" {
  15 #endif
  16
  17 #define BTF_ELF_SEC ".BTF"
  18 #define BTF_EXT_ELF_SEC ".BTF.ext"
  19 #define MAPS_ELF_SEC ".maps"
  20
  21 struct btf;
  22 struct btf_ext;
  23 struct btf_type;
  24
  25 struct bpf_object;
  26
  27 /*
  28  * The .BTF.ext ELF section layout defined as
  29  *   struct btf_ext_header
  30  *   func_info subsection
  31  *
  32  * The func_info subsection layout:
  33  *   record size for struct bpf_func_info in the func_info subsection
  34  *   struct btf_sec_func_info for section #1
  35  *   a list of bpf_func_info records for section #1
  36  *     where struct bpf_func_info mimics one in include/uapi/linux/bpf.h
  37  *     but may not be identical
  38  *   struct btf_sec_func_info for section #2
  39  *   a list of bpf_func_info records for section #2
  40  *   ......
  41  *
  42  * Note that the bpf_func_info record size in .BTF.ext may not
  43  * be the same as the one defined in include/uapi/linux/bpf.h.
  44  * The loader should ensure that record_size meets minimum
  45  * requirement and pass the record as is to the kernel. The
  46  * kernel will handle the func_info properly based on its contents.
  47  */
  48 struct btf_ext_header {
  49         __u16   magic;
  50         __u8    version;
  51         __u8    flags;
  52         __u32   hdr_len;
  53
  54         /* All offsets are in bytes relative to the end of this header */
  55         __u32   func_info_off;
  56         __u32   func_info_len;
  57         __u32   line_info_off;
  58         __u32   line_info_len;
  59
  60         /* optional part of .BTF.ext header */
  61         __u32   field_reloc_off;
  62         __u32   field_reloc_len;
  63 };
  64
  65 LIBBPF_API void btf__free(struct btf *btf);
  66 LIBBPF_API struct btf *btf__new(__u8 *data, __u32 size);
  67 LIBBPF_API struct btf *btf__parse_elf(const char *path,
  68                                       struct btf_ext **btf_ext);
  69 LIBBPF_API int btf__finalize_data(struct bpf_object *obj, struct btf *btf);
  70 LIBBPF_API int btf__load(struct btf *btf);
  71 LIBBPF_API __s32 btf__find_by_name(const struct btf *btf,
  72                                    const char *type_name);
  73 LIBBPF_API __s32 btf__find_by_name_kind(const struct btf *btf,
  74                                         const char *type_name, __u32 kind);
  75 LIBBPF_API __u32 btf__get_nr_types(const struct btf *btf);
  76 LIBBPF_API const struct btf_type *btf__type_by_id(const struct btf *btf,
  77                                                   __u32 id);
  78 LIBBPF_API __s64 btf__resolve_size(const struct btf *btf, __u32 type_id);
  79 LIBBPF_API int btf__resolve_type(const struct btf *btf, __u32 type_id);
  80 LIBBPF_API int btf__align_of(const struct btf *btf, __u32 id);
  81 LIBBPF_API int btf__fd(const struct btf *btf);
  82 LIBBPF_API const void *btf__get_raw_data(const struct btf *btf, __u32 *size);
  83 LIBBPF_API const char *btf__name_by_offset(const struct btf *btf, __u32 offset);
  84 LIBBPF_API int btf__get_from_id(__u32 id, struct btf **btf);
  85 LIBBPF_API int btf__get_map_kv_tids(const struct btf *btf, const char *map_name,
  86                                     __u32 expected_key_size,
  87                                     __u32 expected_value_size,
  88                                     __u32 *key_type_id, __u32 *value_type_id);
  89
  90 LIBBPF_API struct btf_ext *btf_ext__new(__u8 *data, __u32 size);
  91 LIBBPF_API void btf_ext__free(struct btf_ext *btf_ext);
  92 LIBBPF_API const void *btf_ext__get_raw_data(const struct btf_ext *btf_ext,
  93                                              __u32 *size);
  94 LIBBPF_API int btf_ext__reloc_func_info(const struct btf *btf,
  95                                         const struct btf_ext *btf_ext,
  96                                         const char *sec_name, __u32 insns_cnt,
  97                                         void **func_info, __u32 *cnt);
  98 LIBBPF_API int btf_ext__reloc_line_info(const struct btf *btf,
  99                                         const struct btf_ext *btf_ext,
 100                                         const char *sec_name, __u32 insns_cnt,
 101                                         void **line_info, __u32 *cnt);
 102 LIBBPF_API __u32 btf_ext__func_info_rec_size(const struct btf_ext *btf_ext);
 103 LIBBPF_API __u32 btf_ext__line_info_rec_size(const struct btf_ext *btf_ext);
 104
 105 LIBBPF_API struct btf *libbpf_find_kernel_btf(void);
 106
 107 struct btf_dedup_opts {
 108         unsigned int dedup_table_size;
 109         bool dont_resolve_fwds;
 110 };
 111
 112 LIBBPF_API int btf__dedup(struct btf *btf, struct btf_ext *btf_ext,
 113                           const struct btf_dedup_opts *opts);
 114
 115 struct btf_dump;
 116
 117 struct btf_dump_opts {
 118         void *ctx;
 119 };
 120
 121 typedef void (*btf_dump_printf_fn_t)(void *ctx, const char *fmt, va_list args);
 122
 123 LIBBPF_API struct btf_dump *btf_dump__new(const struct btf *btf,
 124                                           const struct btf_ext *btf_ext,
 125                                           const struct btf_dump_opts *opts,
 126                                           btf_dump_printf_fn_t printf_fn);
 127 LIBBPF_API void btf_dump__free(struct btf_dump *d);
 128
 129 LIBBPF_API int btf_dump__dump_type(struct btf_dump *d, __u32 id);
 130
 131 struct btf_dump_emit_type_decl_opts {
 132         /* size of this struct, for forward/backward compatiblity */
 133         size_t sz;
 134         /* optional field name for type declaration, e.g.:
 135          * - struct my_struct <FNAME>
 136          * - void (*<FNAME>)(int)
 137          * - char (*<FNAME>)[123]
 138          */
 139         const char *field_name;
 140         /* extra indentation level (in number of tabs) to emit for multi-line
 141          * type declarations (e.g., anonymous struct); applies for lines
 142          * starting from the second one (first line is assumed to have
 143          * necessary indentation already
 144          */
 145         int indent_level;
 146 };
 147 #define btf_dump_emit_type_decl_opts__last_field indent_level
 148
 149 LIBBPF_API int
 150 btf_dump__emit_type_decl(struct btf_dump *d, __u32 id,
 151                          const struct btf_dump_emit_type_decl_opts *opts);
 152
 153 /*
 154  * A set of helpers for easier BTF types handling
 155  */
 156 static inline __u16 btf_kind(const struct btf_type *t)
 157 {
 158         return BTF_INFO_KIND(t->info);
 159 }
 160
 161 static inline __u16 btf_vlen(const struct btf_type *t)
 162 {
 163         return BTF_INFO_VLEN(t->info);
 164 }
 165
 166 static inline bool btf_kflag(const struct btf_type *t)
 167 {
 168         return BTF_INFO_KFLAG(t->info);
 169 }
 170
 171 static inline bool btf_is_int(const struct btf_type *t)
 172 {
 173         return btf_kind(t) == BTF_KIND_INT;
 174 }
 175
 176 static inline bool btf_is_ptr(const struct btf_type *t)
 177 {
 178         return btf_kind(t) == BTF_KIND_PTR;
 179 }
 180
 181 static inline bool btf_is_array(const struct btf_type *t)
 182 {
 183         return btf_kind(t) == BTF_KIND_ARRAY;
 184 }
 185
 186 static inline bool btf_is_struct(const struct btf_type *t)
 187 {
 188         return btf_kind(t) == BTF_KIND_STRUCT;
 189 }
 190
 191 static inline bool btf_is_union(const struct btf_type *t)
 192 {
 193         return btf_kind(t) == BTF_KIND_UNION;
 194 }
 195
 196 static inline bool btf_is_composite(const struct btf_type *t)
 197 {
 198         __u16 kind = btf_kind(t);
 199
 200         return kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION;
 201 }
 202
 203 static inline bool btf_is_enum(const struct btf_type *t)
 204 {
 205         return btf_kind(t) == BTF_KIND_ENUM;
 206 }
 207
 208 static inline bool btf_is_fwd(const struct btf_type *t)
 209 {
 210         return btf_kind(t) == BTF_KIND_FWD;
 211 }
 212
 213 static inline bool btf_is_typedef(const struct btf_type *t)
 214 {
 215         return btf_kind(t) == BTF_KIND_TYPEDEF;
 216 }
 217
 218 static inline bool btf_is_volatile(const struct btf_type *t)
 219 {
 220         return btf_kind(t) == BTF_KIND_VOLATILE;
 221 }
 222
 223 static inline bool btf_is_const(const struct btf_type *t)
 224 {
 225         return btf_kind(t) == BTF_KIND_CONST;
 226 }
 227
 228 static inline bool btf_is_restrict(const struct btf_type *t)
 229 {
 230         return btf_kind(t) == BTF_KIND_RESTRICT;
 231 }
 232
 233 static inline bool btf_is_mod(const struct btf_type *t)
 234 {
 235         __u16 kind = btf_kind(t);
 236
 237         return kind == BTF_KIND_VOLATILE ||
 238                kind == BTF_KIND_CONST ||
 239                kind == BTF_KIND_RESTRICT;
 240 }
 241
 242 static inline bool btf_is_func(const struct btf_type *t)
 243 {
 244         return btf_kind(t) == BTF_KIND_FUNC;
 245 }
 246
 247 static inline bool btf_is_func_proto(const struct btf_type *t)
 248 {
 249         return btf_kind(t) == BTF_KIND_FUNC_PROTO;
 250 }
 251
 252 static inline bool btf_is_var(const struct btf_type *t)
 253 {
 254         return btf_kind(t) == BTF_KIND_VAR;
 255 }
 256
 257 static inline bool btf_is_datasec(const struct btf_type *t)
 258 {
 259         return btf_kind(t) == BTF_KIND_DATASEC;
 260 }
 261
 262 static inline __u8 btf_int_encoding(const struct btf_type *t)
 263 {
 264         return BTF_INT_ENCODING(*(__u32 *)(t + 1));
 265 }
 266
 267 static inline __u8 btf_int_offset(const struct btf_type *t)
 268 {
 269         return BTF_INT_OFFSET(*(__u32 *)(t + 1));
 270 }
 271
 272 static inline __u8 btf_int_bits(const struct btf_type *t)
 273 {
 274         return BTF_INT_BITS(*(__u32 *)(t + 1));
 275 }
 276
 277 static inline struct btf_array *btf_array(const struct btf_type *t)
 278 {
 279         return (struct btf_array *)(t + 1);
 280 }
 281
 282 static inline struct btf_enum *btf_enum(const struct btf_type *t)
 283 {
 284         return (struct btf_enum *)(t + 1);
 285 }
 286
 287 static inline struct btf_member *btf_members(const struct btf_type *t)
 288 {
 289         return (struct btf_member *)(t + 1);
 290 }
 291
 292 /* Get bit offset of a member with specified index. */
 293 static inline __u32 btf_member_bit_offset(const struct btf_type *t,
 294                                           __u32 member_idx)
 295 {
 296         const struct btf_member *m = btf_members(t) + member_idx;
 297         bool kflag = btf_kflag(t);
 298
 299         return kflag ? BTF_MEMBER_BIT_OFFSET(m->offset) : m->offset;
 300 }
 301 /*
 302  * Get bitfield size of a member, assuming t is BTF_KIND_STRUCT or
 303  * BTF_KIND_UNION. If member is not a bitfield, zero is returned.
 304  */
 305 static inline __u32 btf_member_bitfield_size(const struct btf_type *t,
 306                                              __u32 member_idx)
 307 {
 308         const struct btf_member *m = btf_members(t) + member_idx;
 309         bool kflag = btf_kflag(t);
 310
 311         return kflag ? BTF_MEMBER_BITFIELD_SIZE(m->offset) : 0;
 312 }
 313
 314 static inline struct btf_param *btf_params(const struct btf_type *t)
 315 {
 316         return (struct btf_param *)(t + 1);
 317 }
 318
 319 static inline struct btf_var *btf_var(const struct btf_type *t)
 320 {
 321         return (struct btf_var *)(t + 1);
 322 }
 323
 324 static inline struct btf_var_secinfo *
 325 btf_var_secinfos(const struct btf_type *t)
 326 {
 327         return (struct btf_var_secinfo *)(t + 1);
 328 }
 329
 330 #ifdef __cplusplus
 331 } /* extern "C" */
 332 #endif
 333
 334 #endif /* __LIBBPF_BTF_H */