1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* Copyright (c) 2018 Facebook */ 3 4 #include <stdlib.h> 5 #include <stdint.h> 6 #include <string.h> 7 #include <unistd.h> 8 #include <errno.h> 9 #include <linux/err.h> 10 #include <linux/btf.h> 11 #include "btf.h" 12 #include "bpf.h" 13 14 #define elog(fmt, ...) { if (err_log) err_log(fmt, ##__VA_ARGS__); } 15 #define max(a, b) ((a) > (b) ? (a) : (b)) 16 #define min(a, b) ((a) < (b) ? (a) : (b)) 17 18 #define BTF_MAX_NR_TYPES 65535 19 20 #define IS_MODIFIER(k) (((k) == BTF_KIND_TYPEDEF) || \ 21 ((k) == BTF_KIND_VOLATILE) || \ 22 ((k) == BTF_KIND_CONST) || \ 23 ((k) == BTF_KIND_RESTRICT)) 24 25 static struct btf_type btf_void; 26 27 struct btf { 28 union { 29 struct btf_header *hdr; 30 void *data; 31 }; 32 struct btf_type **types; 33 const char *strings; 34 void *nohdr_data; 35 uint32_t nr_types; 36 uint32_t types_size; 37 uint32_t data_size; 38 int fd; 39 }; 40 41 static int btf_add_type(struct btf *btf, struct btf_type *t) 42 { 43 if (btf->types_size - btf->nr_types < 2) { 44 struct btf_type **new_types; 45 u32 expand_by, new_size; 46 47 if (btf->types_size == BTF_MAX_NR_TYPES) 48 return -E2BIG; 49 50 expand_by = max(btf->types_size >> 2, 16); 51 new_size = min(BTF_MAX_NR_TYPES, btf->types_size + expand_by); 52 53 new_types = realloc(btf->types, sizeof(*new_types) * new_size); 54 if (!new_types) 55 return -ENOMEM; 56 57 if (btf->nr_types == 0) 58 new_types[0] = &btf_void; 59 60 btf->types = new_types; 61 btf->types_size = new_size; 62 } 63 64 btf->types[++(btf->nr_types)] = t; 65 66 return 0; 67 } 68 69 static int btf_parse_hdr(struct btf *btf, btf_print_fn_t err_log) 70 { 71 const struct btf_header *hdr = btf->hdr; 72 u32 meta_left; 73 74 if (btf->data_size < sizeof(struct btf_header)) { 75 elog("BTF header not found\n"); 76 return -EINVAL; 77 } 78 79 if (hdr->magic != BTF_MAGIC) { 80 elog("Invalid BTF magic:%x\n", hdr->magic); 81 return -EINVAL; 82 } 83 84 if (hdr->version != BTF_VERSION) { 85 elog("Unsupported BTF version:%u\n", hdr->version); 86 return -ENOTSUP; 87 } 88 89 if (hdr->flags) { 90 elog("Unsupported BTF flags:%x\n", hdr->flags); 91 return -ENOTSUP; 92 } 93 94 meta_left = btf->data_size - sizeof(*hdr); 95 if (!meta_left) { 96 elog("BTF has no data\n"); 97 return -EINVAL; 98 } 99 100 if (meta_left < hdr->type_off) { 101 elog("Invalid BTF type section offset:%u\n", hdr->type_off); 102 return -EINVAL; 103 } 104 105 if (meta_left < hdr->str_off) { 106 elog("Invalid BTF string section offset:%u\n", hdr->str_off); 107 return -EINVAL; 108 } 109 110 if (hdr->type_off >= hdr->str_off) { 111 elog("BTF type section offset >= string section offset. No type?\n"); 112 return -EINVAL; 113 } 114 115 if (hdr->type_off & 0x02) { 116 elog("BTF type section is not aligned to 4 bytes\n"); 117 return -EINVAL; 118 } 119 120 btf->nohdr_data = btf->hdr + 1; 121 122 return 0; 123 } 124 125 static int btf_parse_str_sec(struct btf *btf, btf_print_fn_t err_log) 126 { 127 const struct btf_header *hdr = btf->hdr; 128 const char *start = btf->nohdr_data + hdr->str_off; 129 const char *end = start + btf->hdr->str_len; 130 131 if (!hdr->str_len || hdr->str_len - 1 > BTF_MAX_NAME_OFFSET || 132 start[0] || end[-1]) { 133 elog("Invalid BTF string section\n"); 134 return -EINVAL; 135 } 136 137 btf->strings = start; 138 139 return 0; 140 } 141 142 static int btf_parse_type_sec(struct btf *btf, btf_print_fn_t err_log) 143 { 144 struct btf_header *hdr = btf->hdr; 145 void *nohdr_data = btf->nohdr_data; 146 void *next_type = nohdr_data + hdr->type_off; 147 void *end_type = nohdr_data + hdr->str_off; 148 149 while (next_type < end_type) { 150 struct btf_type *t = next_type; 151 uint16_t vlen = BTF_INFO_VLEN(t->info); 152 int err; 153 154 next_type += sizeof(*t); 155 switch (BTF_INFO_KIND(t->info)) { 156 case BTF_KIND_INT: 157 next_type += sizeof(int); 158 break; 159 case BTF_KIND_ARRAY: 160 next_type += sizeof(struct btf_array); 161 break; 162 case BTF_KIND_STRUCT: 163 case BTF_KIND_UNION: 164 next_type += vlen * sizeof(struct btf_member); 165 break; 166 case BTF_KIND_ENUM: 167 next_type += vlen * sizeof(struct btf_enum); 168 break; 169 case BTF_KIND_TYPEDEF: 170 case BTF_KIND_PTR: 171 case BTF_KIND_FWD: 172 case BTF_KIND_VOLATILE: 173 case BTF_KIND_CONST: 174 case BTF_KIND_RESTRICT: 175 break; 176 default: 177 elog("Unsupported BTF_KIND:%u\n", 178 BTF_INFO_KIND(t->info)); 179 return -EINVAL; 180 } 181 182 err = btf_add_type(btf, t); 183 if (err) 184 return err; 185 } 186 187 return 0; 188 } 189 190 static bool btf_type_is_void(const struct btf_type *t) 191 { 192 return t == &btf_void || BTF_INFO_KIND(t->info) == BTF_KIND_FWD; 193 } 194 195 static bool btf_type_is_void_or_null(const struct btf_type *t) 196 { 197 return !t || btf_type_is_void(t); 198 } 199 200 static int64_t btf_type_size(const struct btf_type *t) 201 { 202 switch (BTF_INFO_KIND(t->info)) { 203 case BTF_KIND_INT: 204 case BTF_KIND_STRUCT: 205 case BTF_KIND_UNION: 206 case BTF_KIND_ENUM: 207 return t->size; 208 case BTF_KIND_PTR: 209 return sizeof(void *); 210 default: 211 return -EINVAL; 212 } 213 } 214 215 #define MAX_RESOLVE_DEPTH 32 216 217 int64_t btf__resolve_size(const struct btf *btf, uint32_t type_id) 218 { 219 const struct btf_array *array; 220 const struct btf_type *t; 221 uint32_t nelems = 1; 222 int64_t size = -1; 223 int i; 224 225 t = btf__type_by_id(btf, type_id); 226 for (i = 0; i < MAX_RESOLVE_DEPTH && !btf_type_is_void_or_null(t); 227 i++) { 228 size = btf_type_size(t); 229 if (size >= 0) 230 break; 231 232 switch (BTF_INFO_KIND(t->info)) { 233 case BTF_KIND_TYPEDEF: 234 case BTF_KIND_VOLATILE: 235 case BTF_KIND_CONST: 236 case BTF_KIND_RESTRICT: 237 type_id = t->type; 238 break; 239 case BTF_KIND_ARRAY: 240 array = (const struct btf_array *)(t + 1); 241 if (nelems && array->nelems > UINT32_MAX / nelems) 242 return -E2BIG; 243 nelems *= array->nelems; 244 type_id = array->type; 245 break; 246 default: 247 return -EINVAL; 248 } 249 250 t = btf__type_by_id(btf, type_id); 251 } 252 253 if (size < 0) 254 return -EINVAL; 255 256 if (nelems && size > UINT32_MAX / nelems) 257 return -E2BIG; 258 259 return nelems * size; 260 } 261 262 int btf__resolve_type(const struct btf *btf, __u32 type_id) 263 { 264 const struct btf_type *t; 265 int depth = 0; 266 267 t = btf__type_by_id(btf, type_id); 268 while (depth < MAX_RESOLVE_DEPTH && 269 !btf_type_is_void_or_null(t) && 270 IS_MODIFIER(BTF_INFO_KIND(t->info))) { 271 type_id = t->type; 272 t = btf__type_by_id(btf, type_id); 273 depth++; 274 } 275 276 if (depth == MAX_RESOLVE_DEPTH || btf_type_is_void_or_null(t)) 277 return -EINVAL; 278 279 return type_id; 280 } 281 282 int32_t btf__find_by_name(const struct btf *btf, const char *type_name) 283 { 284 uint32_t i; 285 286 if (!strcmp(type_name, "void")) 287 return 0; 288 289 for (i = 1; i <= btf->nr_types; i++) { 290 const struct btf_type *t = btf->types[i]; 291 const char *name = btf__name_by_offset(btf, t->name_off); 292 293 if (name && !strcmp(type_name, name)) 294 return i; 295 } 296 297 return -ENOENT; 298 } 299 300 void btf__free(struct btf *btf) 301 { 302 if (!btf) 303 return; 304 305 if (btf->fd != -1) 306 close(btf->fd); 307 308 free(btf->data); 309 free(btf->types); 310 free(btf); 311 } 312 313 struct btf *btf__new(uint8_t *data, uint32_t size, 314 btf_print_fn_t err_log) 315 { 316 uint32_t log_buf_size = 0; 317 char *log_buf = NULL; 318 struct btf *btf; 319 int err; 320 321 btf = calloc(1, sizeof(struct btf)); 322 if (!btf) 323 return ERR_PTR(-ENOMEM); 324 325 btf->fd = -1; 326 327 if (err_log) { 328 log_buf = malloc(BPF_LOG_BUF_SIZE); 329 if (!log_buf) { 330 err = -ENOMEM; 331 goto done; 332 } 333 *log_buf = 0; 334 log_buf_size = BPF_LOG_BUF_SIZE; 335 } 336 337 btf->data = malloc(size); 338 if (!btf->data) { 339 err = -ENOMEM; 340 goto done; 341 } 342 343 memcpy(btf->data, data, size); 344 btf->data_size = size; 345 346 btf->fd = bpf_load_btf(btf->data, btf->data_size, 347 log_buf, log_buf_size, false); 348 349 if (btf->fd == -1) { 350 err = -errno; 351 elog("Error loading BTF: %s(%d)\n", strerror(errno), errno); 352 if (log_buf && *log_buf) 353 elog("%s\n", log_buf); 354 goto done; 355 } 356 357 err = btf_parse_hdr(btf, err_log); 358 if (err) 359 goto done; 360 361 err = btf_parse_str_sec(btf, err_log); 362 if (err) 363 goto done; 364 365 err = btf_parse_type_sec(btf, err_log); 366 367 done: 368 free(log_buf); 369 370 if (err) { 371 btf__free(btf); 372 return ERR_PTR(err); 373 } 374 375 return btf; 376 } 377 378 int btf__fd(const struct btf *btf) 379 { 380 return btf->fd; 381 } 382 383 const char *btf__name_by_offset(const struct btf *btf, __u32 offset) 384 { 385 if (offset < btf->hdr->str_len) 386 return &btf->strings[offset]; 387 else 388 return NULL; 389 } 390 391 const struct btf_type *btf__type_by_id(const struct btf *btf, 392 __u32 type_id) 393 { 394 if (type_id > btf->nr_types) 395 return NULL; 396 397 return btf->types[type_id]; 398 } 399