[linux-2.6-block.git] / tools / lib / bpf / btf.c

// SPDX-License-Identifier: LGPL-2.1
/* Copyright (c) 2018 Facebook */

#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <linux/err.h>
#include <linux/btf.h>
#include "btf.h"
#include "bpf.h"

#define elog(fmt, ...) { if (err_log) err_log(fmt, ##__VA_ARGS__); }
#define max(a, b) ((a) > (b) ? (a) : (b))
#define min(a, b) ((a) < (b) ? (a) : (b))

#define BTF_MAX_NR_TYPES 65535

#define IS_MODIFIER(k) (((k) == BTF_KIND_TYPEDEF) || \
		((k) == BTF_KIND_VOLATILE) || \
		((k) == BTF_KIND_CONST) || \
		((k) == BTF_KIND_RESTRICT))

static struct btf_type btf_void;

struct btf {
	union {
		struct btf_header *hdr;
		void *data;
	};
	struct btf_type **types;
	const char *strings;
	void *nohdr_data;
	__u32 nr_types;
	__u32 types_size;
	__u32 data_size;
	int fd;
};

static int btf_add_type(struct btf *btf, struct btf_type *t)
{
	if (btf->types_size - btf->nr_types < 2) {
		struct btf_type **new_types;
		__u32 expand_by, new_size;

		if (btf->types_size == BTF_MAX_NR_TYPES)
			return -E2BIG;

		expand_by = max(btf->types_size >> 2, 16);
		new_size = min(BTF_MAX_NR_TYPES, btf->types_size + expand_by);

		new_types = realloc(btf->types, sizeof(*new_types) * new_size);
		if (!new_types)
			return -ENOMEM;

		if (btf->nr_types == 0)
			new_types[0] = &btf_void;

		btf->types = new_types;
		btf->types_size = new_size;
	}

	btf->types[++(btf->nr_types)] = t;

	return 0;
}

static int btf_parse_hdr(struct btf *btf, btf_print_fn_t err_log)
{
	const struct btf_header *hdr = btf->hdr;
	__u32 meta_left;

	if (btf->data_size < sizeof(struct btf_header)) {
		elog("BTF header not found\n");
		return -EINVAL;
	}

	if (hdr->magic != BTF_MAGIC) {
		elog("Invalid BTF magic:%x\n", hdr->magic);
		return -EINVAL;
	}

	if (hdr->version != BTF_VERSION) {
		elog("Unsupported BTF version:%u\n", hdr->version);
		return -ENOTSUP;
	}

	if (hdr->flags) {
		elog("Unsupported BTF flags:%x\n", hdr->flags);
		return -ENOTSUP;
	}

	meta_left = btf->data_size - sizeof(*hdr);
	if (!meta_left) {
		elog("BTF has no data\n");
		return -EINVAL;
	}

	if (meta_left < hdr->type_off) {
		elog("Invalid BTF type section offset:%u\n", hdr->type_off);
		return -EINVAL;
	}

	if (meta_left < hdr->str_off) {
		elog("Invalid BTF string section offset:%u\n", hdr->str_off);
		return -EINVAL;
	}

	if (hdr->type_off >= hdr->str_off) {
		elog("BTF type section offset >= string section offset. No type?\n");
		return -EINVAL;
	}

	if (hdr->type_off & 0x02) {
		elog("BTF type section is not aligned to 4 bytes\n");
		return -EINVAL;
	}

	btf->nohdr_data = btf->hdr + 1;

	return 0;
}

static int btf_parse_str_sec(struct btf *btf, btf_print_fn_t err_log)
{
	const struct btf_header *hdr = btf->hdr;
	const char *start = btf->nohdr_data + hdr->str_off;
	const char *end = start + btf->hdr->str_len;

	if (!hdr->str_len || hdr->str_len - 1 > BTF_MAX_NAME_OFFSET ||
	    start[0] || end[-1]) {
		elog("Invalid BTF string section\n");
		return -EINVAL;
	}

	btf->strings = start;

	return 0;
}

static int btf_parse_type_sec(struct btf *btf, btf_print_fn_t err_log)
{
	struct btf_header *hdr = btf->hdr;
	void *nohdr_data = btf->nohdr_data;
	void *next_type = nohdr_data + hdr->type_off;
	void *end_type = nohdr_data + hdr->str_off;

	while (next_type < end_type) {
		struct btf_type *t = next_type;
		__u16 vlen = BTF_INFO_VLEN(t->info);
		int err;

		next_type += sizeof(*t);
		switch (BTF_INFO_KIND(t->info)) {
		case BTF_KIND_INT:
			next_type += sizeof(int);
			break;
		case BTF_KIND_ARRAY:
			next_type += sizeof(struct btf_array);
			break;
		case BTF_KIND_STRUCT:
		case BTF_KIND_UNION:
			next_type += vlen * sizeof(struct btf_member);
			break;
		case BTF_KIND_ENUM:
			next_type += vlen * sizeof(struct btf_enum);
			break;
		case BTF_KIND_TYPEDEF:
		case BTF_KIND_PTR:
		case BTF_KIND_FWD:
		case BTF_KIND_VOLATILE:
		case BTF_KIND_CONST:
		case BTF_KIND_RESTRICT:
			break;
		default:
			elog("Unsupported BTF_KIND:%u\n",
			     BTF_INFO_KIND(t->info));
			return -EINVAL;
		}

		err = btf_add_type(btf, t);
		if (err)
			return err;
	}

	return 0;
}

const struct btf_type *btf__type_by_id(const struct btf *btf, __u32 type_id)
{
	if (type_id > btf->nr_types)
		return NULL;

	return btf->types[type_id];
}

static bool btf_type_is_void(const struct btf_type *t)
{
	return t == &btf_void || BTF_INFO_KIND(t->info) == BTF_KIND_FWD;
}

static bool btf_type_is_void_or_null(const struct btf_type *t)
{
	return !t || btf_type_is_void(t);
}

static __s64 btf_type_size(const struct btf_type *t)
{
	switch (BTF_INFO_KIND(t->info)) {
	case BTF_KIND_INT:
	case BTF_KIND_STRUCT:
	case BTF_KIND_UNION:
	case BTF_KIND_ENUM:
		return t->size;
	case BTF_KIND_PTR:
		return sizeof(void *);
	default:
		return -EINVAL;
	}
}

#define MAX_RESOLVE_DEPTH 32

__s64 btf__resolve_size(const struct btf *btf, __u32 type_id)
{
	const struct btf_array *array;
	const struct btf_type *t;
	__u32 nelems = 1;
	__s64 size = -1;
	int i;

	t = btf__type_by_id(btf, type_id);
	for (i = 0; i < MAX_RESOLVE_DEPTH && !btf_type_is_void_or_null(t);
	     i++) {
		size = btf_type_size(t);
		if (size >= 0)
			break;

		switch (BTF_INFO_KIND(t->info)) {
		case BTF_KIND_TYPEDEF:
		case BTF_KIND_VOLATILE:
		case BTF_KIND_CONST:
		case BTF_KIND_RESTRICT:
			type_id = t->type;
			break;
		case BTF_KIND_ARRAY:
			array = (const struct btf_array *)(t + 1);
			if (nelems && array->nelems > UINT32_MAX / nelems)
				return -E2BIG;
			nelems *= array->nelems;
			type_id = array->type;
			break;
		default:
			return -EINVAL;
		}

		t = btf__type_by_id(btf, type_id);
	}

	if (size < 0)
		return -EINVAL;

	if (nelems && size > UINT32_MAX / nelems)
		return -E2BIG;

	return nelems * size;
}

int btf__resolve_type(const struct btf *btf, __u32 type_id)
{
	const struct btf_type *t;
	int depth = 0;

	t = btf__type_by_id(btf, type_id);
	while (depth < MAX_RESOLVE_DEPTH &&
	       !btf_type_is_void_or_null(t) &&
	       IS_MODIFIER(BTF_INFO_KIND(t->info))) {
		type_id = t->type;
		t = btf__type_by_id(btf, type_id);
		depth++;
	}

	if (depth == MAX_RESOLVE_DEPTH || btf_type_is_void_or_null(t))
		return -EINVAL;

	return type_id;
}

__s32 btf__find_by_name(const struct btf *btf, const char *type_name)
{
	__u32 i;

	if (!strcmp(type_name, "void"))
		return 0;

	for (i = 1; i <= btf->nr_types; i++) {
		const struct btf_type *t = btf->types[i];
		const char *name = btf__name_by_offset(btf, t->name_off);

		if (name && !strcmp(type_name, name))
			return i;
	}

	return -ENOENT;
}

void btf__free(struct btf *btf)
{
	if (!btf)
		return;

	if (btf->fd != -1)
		close(btf->fd);

	free(btf->data);
	free(btf->types);
	free(btf);
}

struct btf *btf__new(__u8 *data, __u32 size, btf_print_fn_t err_log)
{
	__u32 log_buf_size = 0;
	char *log_buf = NULL;
	struct btf *btf;
	int err;

	btf = calloc(1, sizeof(struct btf));
	if (!btf)
		return ERR_PTR(-ENOMEM);

	btf->fd = -1;

	if (err_log) {
		log_buf = malloc(BPF_LOG_BUF_SIZE);
		if (!log_buf) {
			err = -ENOMEM;
			goto done;
		}
		*log_buf = 0;
		log_buf_size = BPF_LOG_BUF_SIZE;
	}

	btf->data = malloc(size);
	if (!btf->data) {
		err = -ENOMEM;
		goto done;
	}

	memcpy(btf->data, data, size);
	btf->data_size = size;

	btf->fd = bpf_load_btf(btf->data, btf->data_size,
			       log_buf, log_buf_size, false);

	if (btf->fd == -1) {
		err = -errno;
		elog("Error loading BTF: %s(%d)\n", strerror(errno), errno);
		if (log_buf && *log_buf)
			elog("%s\n", log_buf);
		goto done;
	}

	err = btf_parse_hdr(btf, err_log);
	if (err)
		goto done;

	err = btf_parse_str_sec(btf, err_log);
	if (err)
		goto done;

	err = btf_parse_type_sec(btf, err_log);

done:
	free(log_buf);

	if (err) {
		btf__free(btf);
		return ERR_PTR(err);
	}

	return btf;
}

int btf__fd(const struct btf *btf)
{
	return btf->fd;
}

const char *btf__name_by_offset(const struct btf *btf, __u32 offset)
{
	if (offset < btf->hdr->str_len)
		return &btf->strings[offset];
	else
		return NULL;
}
Commit	Line	Data
74682128	1	// SPDX-License-Identifier: LGPL-2.1
8a138aed MKL	2	/* Copyright (c) 2018 Facebook */
	3
	4	#include <stdlib.h>
8a138aed MKL	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
92b57121 OK	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
8a138aed MKL	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;
5b891af7 MKL	34	__u32 nr_types;
	35	__u32 types_size;
	36	__u32 data_size;
8a138aed MKL	37	int fd;
	38	};
	39
8a138aed MKL	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;
5b891af7	44	__u32 expand_by, new_size;
8a138aed MKL	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;
5b891af7	71	__u32 meta_left;
8a138aed MKL	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;
5b891af7	150	__u16 vlen = BTF_INFO_VLEN(t->info);
8a138aed MKL	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
38d5d3b3	189	const struct btf_type btf__type_by_id(const struct btf btf, __u32 type_id)
8a138aed MKL	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
5b891af7	207	static __s64 btf_type_size(const struct btf_type *t)
8a138aed MKL	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
5b891af7	224	__s64 btf__resolve_size(const struct btf *btf, __u32 type_id)
8a138aed MKL	225	{
	226	const struct btf_array *array;
	227	const struct btf_type *t;
5b891af7 MKL	228	__u32 nelems = 1;
5b891af7 MKL	229	__s64 size = -1;
8a138aed MKL	230	int i;
8a138aed MKL	231
92b57121	232	t = btf__type_by_id(btf, type_id);
8a138aed MKL	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
92b57121	257	t = btf__type_by_id(btf, type_id);
8a138aed MKL	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
92b57121 OK	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
5b891af7	289	__s32 btf__find_by_name(const struct btf btf, const char type_name)
8a138aed	290	{
5b891af7	291	__u32 i;
8a138aed MKL	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];
92b57121	298	const char *name = btf__name_by_offset(btf, t->name_off);
8a138aed MKL	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
5b891af7	320	struct btf btf__new(__u8 data, __u32 size, btf_print_fn_t err_log)
8a138aed	321	{
5b891af7	322	__u32 log_buf_size = 0;
8a138aed MKL	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	}
92b57121 OK	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	}