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