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