Commit b03bc685 authored by Andrii Nakryiko's avatar Andrii Nakryiko Committed by Alexei Starovoitov
Browse files

libbpf: convert libbpf code to use new btf helpers 



Simplify code by relying on newly added BTF helper functions.

Signed-off-by: default avatarAndrii Nakryiko <andriin@fb.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent ef20a9b2

tools/lib/bpf/btf.c

+83 −98
Original line number Diff line number Diff line
@@ -19,13 +19,6 @@ 
#define BTF_MAX_NR_TYPES 0x7fffffff

#define BTF_MAX_STR_OFFSET 0x7fffffff



#define IS_MODIFIER(k) (((k) == BTF_KIND_TYPEDEF) || \

		((k) == BTF_KIND_VOLATILE) || \

		((k) == BTF_KIND_CONST) || \

		((k) == BTF_KIND_RESTRICT))



#define IS_VAR(k) ((k) == BTF_KIND_VAR)



static struct btf_type btf_void;



struct btf {
@@ -192,9 +185,9 @@ static int btf_parse_str_sec(struct btf *btf) 
static int btf_type_size(struct btf_type *t)

{

	int base_size = sizeof(struct btf_type);

	__u16 vlen = BTF_INFO_VLEN(t->info);

	__u16 vlen = btf_vlen(t);



	switch (BTF_INFO_KIND(t->info)) {

	switch (btf_kind(t)) {

	case BTF_KIND_FWD:

	case BTF_KIND_CONST:

	case BTF_KIND_VOLATILE:
@@ -219,7 +212,7 @@ static int btf_type_size(struct btf_type *t) 
	case BTF_KIND_DATASEC:

		return base_size + vlen * sizeof(struct btf_var_secinfo);

	default:

		pr_debug("Unsupported BTF_KIND:%u\n", BTF_INFO_KIND(t->info));

		pr_debug("Unsupported BTF_KIND:%u\n", btf_kind(t));

		return -EINVAL;

	}

}
@@ -263,7 +256,7 @@ const struct btf_type *btf__type_by_id(const struct btf *btf, __u32 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;

	return t == &btf_void || btf_is_fwd(t);

}



static bool btf_type_is_void_or_null(const struct btf_type *t)
@@ -284,7 +277,7 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id) 
	t = btf__type_by_id(btf, type_id);

	for (i = 0; i < MAX_RESOLVE_DEPTH && !btf_type_is_void_or_null(t);

	     i++) {

		switch (BTF_INFO_KIND(t->info)) {

		switch (btf_kind(t)) {

		case BTF_KIND_INT:

		case BTF_KIND_STRUCT:

		case BTF_KIND_UNION:
@@ -303,7 +296,7 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id) 
			type_id = t->type;

			break;

		case BTF_KIND_ARRAY:

			array = (const struct btf_array *)(t + 1);

			array = btf_array(t);

			if (nelems && array->nelems > UINT32_MAX / nelems)

				return -E2BIG;

			nelems *= array->nelems;
@@ -334,8 +327,7 @@ int btf__resolve_type(const struct btf *btf, __u32 type_id) 
	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)) ||

		IS_VAR(BTF_INFO_KIND(t->info)))) {

	       (btf_is_mod(t) || btf_is_typedef(t) || btf_is_var(t))) {

		type_id = t->type;

		t = btf__type_by_id(btf, type_id);

		depth++;
@@ -554,11 +546,11 @@ static int compare_vsi_off(const void *_a, const void *_b) 
static int btf_fixup_datasec(struct bpf_object *obj, struct btf *btf,

			     struct btf_type *t)

{

	__u32 size = 0, off = 0, i, vars = BTF_INFO_VLEN(t->info);

	__u32 size = 0, off = 0, i, vars = btf_vlen(t);

	const char *name = btf__name_by_offset(btf, t->name_off);

	const struct btf_type *t_var;

	struct btf_var_secinfo *vsi;

	struct btf_var *var;

	const struct btf_var *var;

	int ret;



	if (!name) {
@@ -574,12 +566,11 @@ static int btf_fixup_datasec(struct bpf_object *obj, struct btf *btf, 


	t->size = size;



	for (i = 0, vsi = (struct btf_var_secinfo *)(t + 1);

	     i < vars; i++, vsi++) {

	for (i = 0, vsi = btf_var_secinfos(t); i < vars; i++, vsi++) {

		t_var = btf__type_by_id(btf, vsi->type);

		var = (struct btf_var *)(t_var + 1);

		var = btf_var(t_var);



		if (BTF_INFO_KIND(t_var->info) != BTF_KIND_VAR) {

		if (!btf_is_var(t_var)) {

			pr_debug("Non-VAR type seen in section %s\n", name);

			return -EINVAL;

		}
@@ -595,7 +586,8 @@ static int btf_fixup_datasec(struct bpf_object *obj, struct btf *btf, 


		ret = bpf_object__variable_offset(obj, name, &off);

		if (ret) {

			pr_debug("No offset found in symbol table for VAR %s\n", name);

			pr_debug("No offset found in symbol table for VAR %s\n",

				 name);

			return -ENOENT;

		}
@@ -619,7 +611,7 @@ int btf__finalize_data(struct bpf_object *obj, struct btf *btf) 
		 * is section size and global variable offset. We use

		 * the info from the ELF itself for this purpose.

		 */

		if (BTF_INFO_KIND(t->info) == BTF_KIND_DATASEC) {

		if (btf_is_datasec(t)) {

			err = btf_fixup_datasec(obj, btf, t);

			if (err)

				break;
@@ -774,14 +766,13 @@ int btf__get_map_kv_tids(const struct btf *btf, const char *map_name, 
		return -EINVAL;

	}



	if (BTF_INFO_KIND(container_type->info) != BTF_KIND_STRUCT ||

	    BTF_INFO_VLEN(container_type->info) < 2) {

	if (!btf_is_struct(container_type) || btf_vlen(container_type) < 2) {

		pr_warning("map:%s container_name:%s is an invalid container struct\n",

			   map_name, container_name);

		return -EINVAL;

	}



	key = (struct btf_member *)(container_type + 1);

	key = btf_members(container_type);

	value = key + 1;



	key_size = btf__resolve_size(btf, key->type);
@@ -1440,10 +1431,9 @@ static struct btf_dedup *btf_dedup_new(struct btf *btf, struct btf_ext *btf_ext, 
	d->map[0] = 0;

	for (i = 1; i <= btf->nr_types; i++) {

		struct btf_type *t = d->btf->types[i];

		__u16 kind = BTF_INFO_KIND(t->info);



		/* VAR and DATASEC are never deduped and are self-canonical */

		if (kind == BTF_KIND_VAR || kind == BTF_KIND_DATASEC)

		if (btf_is_var(t) || btf_is_datasec(t))

			d->map[i] = i;

		else

			d->map[i] = BTF_UNPROCESSED_ID;
@@ -1484,11 +1474,11 @@ static int btf_for_each_str_off(struct btf_dedup *d, str_off_fn_t fn, void *ctx) 
		if (r)

			return r;



		switch (BTF_INFO_KIND(t->info)) {

		switch (btf_kind(t)) {

		case BTF_KIND_STRUCT:

		case BTF_KIND_UNION: {

			struct btf_member *m = (struct btf_member *)(t + 1);

			__u16 vlen = BTF_INFO_VLEN(t->info);

			struct btf_member *m = btf_members(t);

			__u16 vlen = btf_vlen(t);



			for (j = 0; j < vlen; j++) {

				r = fn(&m->name_off, ctx);
@@ -1499,8 +1489,8 @@ static int btf_for_each_str_off(struct btf_dedup *d, str_off_fn_t fn, void *ctx) 
			break;

		}

		case BTF_KIND_ENUM: {

			struct btf_enum *m = (struct btf_enum *)(t + 1);

			__u16 vlen = BTF_INFO_VLEN(t->info);

			struct btf_enum *m = btf_enum(t);

			__u16 vlen = btf_vlen(t);



			for (j = 0; j < vlen; j++) {

				r = fn(&m->name_off, ctx);
@@ -1511,8 +1501,8 @@ static int btf_for_each_str_off(struct btf_dedup *d, str_off_fn_t fn, void *ctx) 
			break;

		}

		case BTF_KIND_FUNC_PROTO: {

			struct btf_param *m = (struct btf_param *)(t + 1);

			__u16 vlen = BTF_INFO_VLEN(t->info);

			struct btf_param *m = btf_params(t);

			__u16 vlen = btf_vlen(t);



			for (j = 0; j < vlen; j++) {

				r = fn(&m->name_off, ctx);
@@ -1801,16 +1791,16 @@ static long btf_hash_enum(struct btf_type *t) 
/* Check structural equality of two ENUMs. */

static bool btf_equal_enum(struct btf_type *t1, struct btf_type *t2)

{

	struct btf_enum *m1, *m2;

	const struct btf_enum *m1, *m2;

	__u16 vlen;

	int i;



	if (!btf_equal_common(t1, t2))

		return false;



	vlen = BTF_INFO_VLEN(t1->info);

	m1 = (struct btf_enum *)(t1 + 1);

	m2 = (struct btf_enum *)(t2 + 1);

	vlen = btf_vlen(t1);

	m1 = btf_enum(t1);

	m2 = btf_enum(t2);

	for (i = 0; i < vlen; i++) {

		if (m1->name_off != m2->name_off || m1->val != m2->val)

			return false;
@@ -1822,8 +1812,7 @@ static bool btf_equal_enum(struct btf_type *t1, struct btf_type *t2) 


static inline bool btf_is_enum_fwd(struct btf_type *t)

{

	return BTF_INFO_KIND(t->info) == BTF_KIND_ENUM &&

	       BTF_INFO_VLEN(t->info) == 0;

	return btf_is_enum(t) && btf_vlen(t) == 0;

}



static bool btf_compat_enum(struct btf_type *t1, struct btf_type *t2)
@@ -1843,8 +1832,8 @@ static bool btf_compat_enum(struct btf_type *t1, struct btf_type *t2) 
 */

static long btf_hash_struct(struct btf_type *t)

{

	struct btf_member *member = (struct btf_member *)(t + 1);

	__u32 vlen = BTF_INFO_VLEN(t->info);

	const struct btf_member *member = btf_members(t);

	__u32 vlen = btf_vlen(t);

	long h = btf_hash_common(t);

	int i;
@@ -1864,16 +1853,16 @@ static long btf_hash_struct(struct btf_type *t) 
 */

static bool btf_shallow_equal_struct(struct btf_type *t1, struct btf_type *t2)

{

	struct btf_member *m1, *m2;

	const struct btf_member *m1, *m2;

	__u16 vlen;

	int i;



	if (!btf_equal_common(t1, t2))

		return false;



	vlen = BTF_INFO_VLEN(t1->info);

	m1 = (struct btf_member *)(t1 + 1);

	m2 = (struct btf_member *)(t2 + 1);

	vlen = btf_vlen(t1);

	m1 = btf_members(t1);

	m2 = btf_members(t2);

	for (i = 0; i < vlen; i++) {

		if (m1->name_off != m2->name_off || m1->offset != m2->offset)

			return false;
@@ -1890,7 +1879,7 @@ static bool btf_shallow_equal_struct(struct btf_type *t1, struct btf_type *t2) 
 */

static long btf_hash_array(struct btf_type *t)

{

	struct btf_array *info = (struct btf_array *)(t + 1);

	const struct btf_array *info = btf_array(t);

	long h = btf_hash_common(t);



	h = hash_combine(h, info->type);
@@ -1908,13 +1897,13 @@ static long btf_hash_array(struct btf_type *t) 
 */

static bool btf_equal_array(struct btf_type *t1, struct btf_type *t2)

{

	struct btf_array *info1, *info2;

	const struct btf_array *info1, *info2;



	if (!btf_equal_common(t1, t2))

		return false;



	info1 = (struct btf_array *)(t1 + 1);

	info2 = (struct btf_array *)(t2 + 1);

	info1 = btf_array(t1);

	info2 = btf_array(t2);

	return info1->type == info2->type &&

	       info1->index_type == info2->index_type &&

	       info1->nelems == info2->nelems;
@@ -1927,14 +1916,10 @@ static bool btf_equal_array(struct btf_type *t1, struct btf_type *t2) 
 */

static bool btf_compat_array(struct btf_type *t1, struct btf_type *t2)

{

	struct btf_array *info1, *info2;



	if (!btf_equal_common(t1, t2))

		return false;



	info1 = (struct btf_array *)(t1 + 1);

	info2 = (struct btf_array *)(t2 + 1);

	return info1->nelems == info2->nelems;

	return btf_array(t1)->nelems == btf_array(t2)->nelems;

}



/*
@@ -1944,8 +1929,8 @@ static bool btf_compat_array(struct btf_type *t1, struct btf_type *t2) 
 */

static long btf_hash_fnproto(struct btf_type *t)

{

	struct btf_param *member = (struct btf_param *)(t + 1);

	__u16 vlen = BTF_INFO_VLEN(t->info);

	const struct btf_param *member = btf_params(t);

	__u16 vlen = btf_vlen(t);

	long h = btf_hash_common(t);

	int i;
@@ -1966,16 +1951,16 @@ static long btf_hash_fnproto(struct btf_type *t) 
 */

static bool btf_equal_fnproto(struct btf_type *t1, struct btf_type *t2)

{

	struct btf_param *m1, *m2;

	const struct btf_param *m1, *m2;

	__u16 vlen;

	int i;



	if (!btf_equal_common(t1, t2))

		return false;



	vlen = BTF_INFO_VLEN(t1->info);

	m1 = (struct btf_param *)(t1 + 1);

	m2 = (struct btf_param *)(t2 + 1);

	vlen = btf_vlen(t1);

	m1 = btf_params(t1);

	m2 = btf_params(t2);

	for (i = 0; i < vlen; i++) {

		if (m1->name_off != m2->name_off || m1->type != m2->type)

			return false;
@@ -1992,7 +1977,7 @@ static bool btf_equal_fnproto(struct btf_type *t1, struct btf_type *t2) 
 */

static bool btf_compat_fnproto(struct btf_type *t1, struct btf_type *t2)

{

	struct btf_param *m1, *m2;

	const struct btf_param *m1, *m2;

	__u16 vlen;

	int i;
@@ -2000,9 +1985,9 @@ static bool btf_compat_fnproto(struct btf_type *t1, struct btf_type *t2) 
	if (t1->name_off != t2->name_off || t1->info != t2->info)

		return false;



	vlen = BTF_INFO_VLEN(t1->info);

	m1 = (struct btf_param *)(t1 + 1);

	m2 = (struct btf_param *)(t2 + 1);

	vlen = btf_vlen(t1);

	m1 = btf_params(t1);

	m2 = btf_params(t2);

	for (i = 0; i < vlen; i++) {

		if (m1->name_off != m2->name_off)

			return false;
@@ -2028,7 +2013,7 @@ static int btf_dedup_prim_type(struct btf_dedup *d, __u32 type_id) 
	__u32 cand_id;

	long h;



	switch (BTF_INFO_KIND(t->info)) {

	switch (btf_kind(t)) {

	case BTF_KIND_CONST:

	case BTF_KIND_VOLATILE:

	case BTF_KIND_RESTRICT:
@@ -2141,13 +2126,13 @@ static uint32_t resolve_fwd_id(struct btf_dedup *d, uint32_t type_id) 
{

	__u32 orig_type_id = type_id;



	if (BTF_INFO_KIND(d->btf->types[type_id]->info) != BTF_KIND_FWD)

	if (!btf_is_fwd(d->btf->types[type_id]))

		return type_id;



	while (is_type_mapped(d, type_id) && d->map[type_id] != type_id)

		type_id = d->map[type_id];



	if (BTF_INFO_KIND(d->btf->types[type_id]->info) != BTF_KIND_FWD)

	if (!btf_is_fwd(d->btf->types[type_id]))

		return type_id;



	return orig_type_id;
@@ -2156,7 +2141,7 @@ static uint32_t resolve_fwd_id(struct btf_dedup *d, uint32_t type_id) 


static inline __u16 btf_fwd_kind(struct btf_type *t)

{

	return BTF_INFO_KFLAG(t->info) ? BTF_KIND_UNION : BTF_KIND_STRUCT;

	return btf_kflag(t) ? BTF_KIND_UNION : BTF_KIND_STRUCT;

}



/*
@@ -2277,8 +2262,8 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id, 


	cand_type = d->btf->types[cand_id];

	canon_type = d->btf->types[canon_id];

	cand_kind = BTF_INFO_KIND(cand_type->info);

	canon_kind = BTF_INFO_KIND(canon_type->info);

	cand_kind = btf_kind(cand_type);

	canon_kind = btf_kind(canon_type);



	if (cand_type->name_off != canon_type->name_off)

		return 0;
@@ -2327,12 +2312,12 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id, 
		return btf_dedup_is_equiv(d, cand_type->type, canon_type->type);



	case BTF_KIND_ARRAY: {

		struct btf_array *cand_arr, *canon_arr;

		const struct btf_array *cand_arr, *canon_arr;



		if (!btf_compat_array(cand_type, canon_type))

			return 0;

		cand_arr = (struct btf_array *)(cand_type + 1);

		canon_arr = (struct btf_array *)(canon_type + 1);

		cand_arr = btf_array(cand_type);

		canon_arr = btf_array(canon_type);

		eq = btf_dedup_is_equiv(d,

			cand_arr->index_type, canon_arr->index_type);

		if (eq <= 0)
@@ -2342,14 +2327,14 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id, 


	case BTF_KIND_STRUCT:

	case BTF_KIND_UNION: {

		struct btf_member *cand_m, *canon_m;

		const struct btf_member *cand_m, *canon_m;

		__u16 vlen;



		if (!btf_shallow_equal_struct(cand_type, canon_type))

			return 0;

		vlen = BTF_INFO_VLEN(cand_type->info);

		cand_m = (struct btf_member *)(cand_type + 1);

		canon_m = (struct btf_member *)(canon_type + 1);

		vlen = btf_vlen(cand_type);

		cand_m = btf_members(cand_type);

		canon_m = btf_members(canon_type);

		for (i = 0; i < vlen; i++) {

			eq = btf_dedup_is_equiv(d, cand_m->type, canon_m->type);

			if (eq <= 0)
@@ -2362,7 +2347,7 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id, 
	}



	case BTF_KIND_FUNC_PROTO: {

		struct btf_param *cand_p, *canon_p;

		const struct btf_param *cand_p, *canon_p;

		__u16 vlen;



		if (!btf_compat_fnproto(cand_type, canon_type))
@@ -2370,9 +2355,9 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id, 
		eq = btf_dedup_is_equiv(d, cand_type->type, canon_type->type);

		if (eq <= 0)

			return eq;

		vlen = BTF_INFO_VLEN(cand_type->info);

		cand_p = (struct btf_param *)(cand_type + 1);

		canon_p = (struct btf_param *)(canon_type + 1);

		vlen = btf_vlen(cand_type);

		cand_p = btf_params(cand_type);

		canon_p = btf_params(canon_type);

		for (i = 0; i < vlen; i++) {

			eq = btf_dedup_is_equiv(d, cand_p->type, canon_p->type);

			if (eq <= 0)
@@ -2427,8 +2412,8 @@ static void btf_dedup_merge_hypot_map(struct btf_dedup *d) 
		targ_type_id = d->hypot_map[cand_type_id];

		t_id = resolve_type_id(d, targ_type_id);

		c_id = resolve_type_id(d, cand_type_id);

		t_kind = BTF_INFO_KIND(d->btf->types[t_id]->info);

		c_kind = BTF_INFO_KIND(d->btf->types[c_id]->info);

		t_kind = btf_kind(d->btf->types[t_id]);

		c_kind = btf_kind(d->btf->types[c_id]);

		/*

		 * Resolve FWD into STRUCT/UNION.

		 * It's ok to resolve FWD into STRUCT/UNION that's not yet
@@ -2497,7 +2482,7 @@ static int btf_dedup_struct_type(struct btf_dedup *d, __u32 type_id) 
		return 0;



	t = d->btf->types[type_id];

	kind = BTF_INFO_KIND(t->info);

	kind = btf_kind(t);



	if (kind != BTF_KIND_STRUCT && kind != BTF_KIND_UNION)

		return 0;
@@ -2592,7 +2577,7 @@ static int btf_dedup_ref_type(struct btf_dedup *d, __u32 type_id) 
	t = d->btf->types[type_id];

	d->map[type_id] = BTF_IN_PROGRESS_ID;



	switch (BTF_INFO_KIND(t->info)) {

	switch (btf_kind(t)) {

	case BTF_KIND_CONST:

	case BTF_KIND_VOLATILE:

	case BTF_KIND_RESTRICT:
@@ -2616,7 +2601,7 @@ static int btf_dedup_ref_type(struct btf_dedup *d, __u32 type_id) 
		break;



	case BTF_KIND_ARRAY: {

		struct btf_array *info = (struct btf_array *)(t + 1);

		struct btf_array *info = btf_array(t);



		ref_type_id = btf_dedup_ref_type(d, info->type);

		if (ref_type_id < 0)
@@ -2650,8 +2635,8 @@ static int btf_dedup_ref_type(struct btf_dedup *d, __u32 type_id) 
			return ref_type_id;

		t->type = ref_type_id;



		vlen = BTF_INFO_VLEN(t->info);

		param = (struct btf_param *)(t + 1);

		vlen = btf_vlen(t);

		param = btf_params(t);

		for (i = 0; i < vlen; i++) {

			ref_type_id = btf_dedup_ref_type(d, param->type);

			if (ref_type_id < 0)
@@ -2791,7 +2776,7 @@ static int btf_dedup_remap_type(struct btf_dedup *d, __u32 type_id) 
	struct btf_type *t = d->btf->types[type_id];

	int i, r;



	switch (BTF_INFO_KIND(t->info)) {

	switch (btf_kind(t)) {

	case BTF_KIND_INT:

	case BTF_KIND_ENUM:

		break;
@@ -2811,7 +2796,7 @@ static int btf_dedup_remap_type(struct btf_dedup *d, __u32 type_id) 
		break;



	case BTF_KIND_ARRAY: {

		struct btf_array *arr_info = (struct btf_array *)(t + 1);

		struct btf_array *arr_info = btf_array(t);



		r = btf_dedup_remap_type_id(d, arr_info->type);

		if (r < 0)
@@ -2826,8 +2811,8 @@ static int btf_dedup_remap_type(struct btf_dedup *d, __u32 type_id) 


	case BTF_KIND_STRUCT:

	case BTF_KIND_UNION: {

		struct btf_member *member = (struct btf_member *)(t + 1);

		__u16 vlen = BTF_INFO_VLEN(t->info);

		struct btf_member *member = btf_members(t);

		__u16 vlen = btf_vlen(t);



		for (i = 0; i < vlen; i++) {

			r = btf_dedup_remap_type_id(d, member->type);
@@ -2840,8 +2825,8 @@ static int btf_dedup_remap_type(struct btf_dedup *d, __u32 type_id) 
	}



	case BTF_KIND_FUNC_PROTO: {

		struct btf_param *param = (struct btf_param *)(t + 1);

		__u16 vlen = BTF_INFO_VLEN(t->info);

		struct btf_param *param = btf_params(t);

		__u16 vlen = btf_vlen(t);



		r = btf_dedup_remap_type_id(d, t->type);

		if (r < 0)
@@ -2859,8 +2844,8 @@ static int btf_dedup_remap_type(struct btf_dedup *d, __u32 type_id) 
	}



	case BTF_KIND_DATASEC: {

		struct btf_var_secinfo *var = (struct btf_var_secinfo *)(t + 1);

		__u16 vlen = BTF_INFO_VLEN(t->info);

		struct btf_var_secinfo *var = btf_var_secinfos(t);

		__u16 vlen = btf_vlen(t);



		for (i = 0; i < vlen; i++) {

			r = btf_dedup_remap_type_id(d, var->type);

tools/lib/bpf/btf_dump.c

+46 −92
Original line number Diff line number Diff line
@@ -100,21 +100,6 @@ static bool str_equal_fn(const void *a, const void *b, void *ctx) 
	return strcmp(a, b) == 0;

}



static __u16 btf_kind_of(const struct btf_type *t)

{

	return BTF_INFO_KIND(t->info);

}



static __u16 btf_vlen_of(const struct btf_type *t)

{

	return BTF_INFO_VLEN(t->info);

}



static bool btf_kflag_of(const struct btf_type *t)

{

	return BTF_INFO_KFLAG(t->info);

}



static const char *btf_name_of(const struct btf_dump *d, __u32 name_off)

{

	return btf__name_by_offset(d->btf, name_off);
@@ -349,7 +334,7 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr) 
	 */

	struct btf_dump_type_aux_state *tstate = &d->type_states[id];

	const struct btf_type *t;

	__u16 kind, vlen;

	__u16 vlen;

	int err, i;



	/* return true, letting typedefs know that it's ok to be emitted */
@@ -357,18 +342,16 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr) 
		return 1;



	t = btf__type_by_id(d->btf, id);

	kind = btf_kind_of(t);



	if (tstate->order_state == ORDERING) {

		/* type loop, but resolvable through fwd declaration */

		if ((kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION) &&

		    through_ptr && t->name_off != 0)

		if (btf_is_composite(t) && through_ptr && t->name_off != 0)

			return 0;

		pr_warning("unsatisfiable type cycle, id:[%u]\n", id);

		return -ELOOP;

	}



	switch (kind) {

	switch (btf_kind(t)) {

	case BTF_KIND_INT:

		tstate->order_state = ORDERED;

		return 0;
@@ -378,14 +361,12 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr) 
		tstate->order_state = ORDERED;

		return err;



	case BTF_KIND_ARRAY: {

		const struct btf_array *a = (void *)(t + 1);

	case BTF_KIND_ARRAY:

		return btf_dump_order_type(d, btf_array(t)->type, through_ptr);



		return btf_dump_order_type(d, a->type, through_ptr);

	}

	case BTF_KIND_STRUCT:

	case BTF_KIND_UNION: {

		const struct btf_member *m = (void *)(t + 1);

		const struct btf_member *m = btf_members(t);

		/*

		 * struct/union is part of strong link, only if it's embedded

		 * (so no ptr in a path) or it's anonymous (so has to be
@@ -396,7 +377,7 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr) 


		tstate->order_state = ORDERING;



		vlen = btf_vlen_of(t);

		vlen = btf_vlen(t);

		for (i = 0; i < vlen; i++, m++) {

			err = btf_dump_order_type(d, m->type, false);

			if (err < 0)
@@ -447,7 +428,7 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr) 
		return btf_dump_order_type(d, t->type, through_ptr);



	case BTF_KIND_FUNC_PROTO: {

		const struct btf_param *p = (void *)(t + 1);

		const struct btf_param *p = btf_params(t);

		bool is_strong;



		err = btf_dump_order_type(d, t->type, through_ptr);
@@ -455,7 +436,7 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr) 
			return err;

		is_strong = err > 0;



		vlen = btf_vlen_of(t);

		vlen = btf_vlen(t);

		for (i = 0; i < vlen; i++, p++) {

			err = btf_dump_order_type(d, p->type, through_ptr);

			if (err < 0)
@@ -553,7 +534,7 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id) 
		return;



	t = btf__type_by_id(d->btf, id);

	kind = btf_kind_of(t);

	kind = btf_kind(t);



	if (top_level_def && t->name_off == 0) {

		pr_warning("unexpected nameless definition, id:[%u]\n", id);
@@ -618,12 +599,9 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id) 
	case BTF_KIND_RESTRICT:

		btf_dump_emit_type(d, t->type, cont_id);

		break;

	case BTF_KIND_ARRAY: {

		const struct btf_array *a = (void *)(t + 1);



		btf_dump_emit_type(d, a->type, cont_id);

	case BTF_KIND_ARRAY:

		btf_dump_emit_type(d, btf_array(t)->type, cont_id);

		break;

	}

	case BTF_KIND_FWD:

		btf_dump_emit_fwd_def(d, id, t);

		btf_dump_printf(d, ";\n\n");
@@ -656,8 +634,8 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id) 
		 * applicable

		 */

		if (top_level_def || t->name_off == 0) {

			const struct btf_member *m = (void *)(t + 1);

			__u16 vlen = btf_vlen_of(t);

			const struct btf_member *m = btf_members(t);

			__u16 vlen = btf_vlen(t);

			int i, new_cont_id;



			new_cont_id = t->name_off == 0 ? cont_id : id;
@@ -678,8 +656,8 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id) 
		}

		break;

	case BTF_KIND_FUNC_PROTO: {

		const struct btf_param *p = (void *)(t + 1);

		__u16 vlen = btf_vlen_of(t);

		const struct btf_param *p = btf_params(t);

		__u16 vlen = btf_vlen(t);

		int i;



		btf_dump_emit_type(d, t->type, cont_id);
@@ -696,7 +674,7 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id) 
static int btf_align_of(const struct btf *btf, __u32 id)

{

	const struct btf_type *t = btf__type_by_id(btf, id);

	__u16 kind = btf_kind_of(t);

	__u16 kind = btf_kind(t);



	switch (kind) {

	case BTF_KIND_INT:
@@ -709,15 +687,12 @@ static int btf_align_of(const struct btf *btf, __u32 id) 
	case BTF_KIND_CONST:

	case BTF_KIND_RESTRICT:

		return btf_align_of(btf, t->type);

	case BTF_KIND_ARRAY: {

		const struct btf_array *a = (void *)(t + 1);



		return btf_align_of(btf, a->type);

	}

	case BTF_KIND_ARRAY:

		return btf_align_of(btf, btf_array(t)->type);

	case BTF_KIND_STRUCT:

	case BTF_KIND_UNION: {

		const struct btf_member *m = (void *)(t + 1);

		__u16 vlen = btf_vlen_of(t);

		const struct btf_member *m = btf_members(t);

		__u16 vlen = btf_vlen(t);

		int i, align = 1;



		for (i = 0; i < vlen; i++, m++)
@@ -726,7 +701,7 @@ static int btf_align_of(const struct btf *btf, __u32 id) 
		return align;

	}

	default:

		pr_warning("unsupported BTF_KIND:%u\n", btf_kind_of(t));

		pr_warning("unsupported BTF_KIND:%u\n", btf_kind(t));

		return 1;

	}

}
@@ -737,20 +712,18 @@ static bool btf_is_struct_packed(const struct btf *btf, __u32 id, 
	const struct btf_member *m;

	int align, i, bit_sz;

	__u16 vlen;

	bool kflag;



	align = btf_align_of(btf, id);

	/* size of a non-packed struct has to be a multiple of its alignment*/

	if (t->size % align)

		return true;



	m = (void *)(t + 1);

	kflag = btf_kflag_of(t);

	vlen = btf_vlen_of(t);

	m = btf_members(t);

	vlen = btf_vlen(t);

	/* all non-bitfield fields have to be naturally aligned */

	for (i = 0; i < vlen; i++, m++) {

		align = btf_align_of(btf, m->type);

		bit_sz = kflag ? BTF_MEMBER_BITFIELD_SIZE(m->offset) : 0;

		bit_sz = btf_member_bitfield_size(t, i);

		if (bit_sz == 0 && m->offset % (8 * align) != 0)

			return true;

	}
@@ -807,7 +780,7 @@ static void btf_dump_emit_struct_fwd(struct btf_dump *d, __u32 id, 
				     const struct btf_type *t)

{

	btf_dump_printf(d, "%s %s",

			btf_kind_of(t) == BTF_KIND_STRUCT ? "struct" : "union",

			btf_is_struct(t) ? "struct" : "union",

			btf_dump_type_name(d, id));

}
@@ -816,12 +789,11 @@ static void btf_dump_emit_struct_def(struct btf_dump *d, 
				     const struct btf_type *t,

				     int lvl)

{

	const struct btf_member *m = (void *)(t + 1);

	bool kflag = btf_kflag_of(t), is_struct;

	const struct btf_member *m = btf_members(t);

	bool is_struct = btf_is_struct(t);

	int align, i, packed, off = 0;

	__u16 vlen = btf_vlen_of(t);

	__u16 vlen = btf_vlen(t);



	is_struct = btf_kind_of(t) == BTF_KIND_STRUCT;

	packed = is_struct ? btf_is_struct_packed(d->btf, id, t) : 0;

	align = packed ? 1 : btf_align_of(d->btf, id);
@@ -835,8 +807,8 @@ static void btf_dump_emit_struct_def(struct btf_dump *d, 
		int m_off, m_sz;



		fname = btf_name_of(d, m->name_off);

		m_sz = kflag ? BTF_MEMBER_BITFIELD_SIZE(m->offset) : 0;

		m_off = kflag ? BTF_MEMBER_BIT_OFFSET(m->offset) : m->offset;

		m_sz = btf_member_bitfield_size(t, i);

		m_off = btf_member_bit_offset(t, i);

		align = packed ? 1 : btf_align_of(d->btf, m->type);



		btf_dump_emit_bit_padding(d, off, m_off, m_sz, align, lvl + 1);
@@ -870,8 +842,8 @@ static void btf_dump_emit_enum_def(struct btf_dump *d, __u32 id, 
				   const struct btf_type *t,

				   int lvl)

{

	const struct btf_enum *v = (void *)(t+1);

	__u16 vlen = btf_vlen_of(t);

	const struct btf_enum *v = btf_enum(t);

	__u16 vlen = btf_vlen(t);

	const char *name;

	size_t dup_cnt;

	int i;
@@ -905,7 +877,7 @@ static void btf_dump_emit_fwd_def(struct btf_dump *d, __u32 id, 
{

	const char *name = btf_dump_type_name(d, id);



	if (btf_kflag_of(t))

	if (btf_kflag(t))

		btf_dump_printf(d, "union %s", name);

	else

		btf_dump_printf(d, "struct %s", name);
@@ -987,7 +959,6 @@ static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id, 
	struct id_stack decl_stack;

	const struct btf_type *t;

	int err, stack_start;

	__u16 kind;



	stack_start = d->decl_stack_cnt;

	for (;;) {
@@ -1008,8 +979,7 @@ static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id, 
			break;



		t = btf__type_by_id(d->btf, id);

		kind = btf_kind_of(t);

		switch (kind) {

		switch (btf_kind(t)) {

		case BTF_KIND_PTR:

		case BTF_KIND_VOLATILE:

		case BTF_KIND_CONST:
@@ -1017,12 +987,9 @@ static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id, 
		case BTF_KIND_FUNC_PROTO:

			id = t->type;

			break;

		case BTF_KIND_ARRAY: {

			const struct btf_array *a = (void *)(t + 1);



			id = a->type;

		case BTF_KIND_ARRAY:

			id = btf_array(t)->type;

			break;

		}

		case BTF_KIND_INT:

		case BTF_KIND_ENUM:

		case BTF_KIND_FWD:
@@ -1032,7 +999,7 @@ static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id, 
			goto done;

		default:

			pr_warning("unexpected type in decl chain, kind:%u, id:[%u]\n",

				   kind, id);

				   btf_kind(t), id);

			goto done;

		}

	}
@@ -1070,7 +1037,7 @@ static void btf_dump_emit_mods(struct btf_dump *d, struct id_stack *decl_stack) 
		id = decl_stack->ids[decl_stack->cnt - 1];

		t = btf__type_by_id(d->btf, id);



		switch (btf_kind_of(t)) {

		switch (btf_kind(t)) {

		case BTF_KIND_VOLATILE:

			btf_dump_printf(d, "volatile ");

			break;
@@ -1087,20 +1054,6 @@ static void btf_dump_emit_mods(struct btf_dump *d, struct id_stack *decl_stack) 
	}

}



static bool btf_is_mod_kind(const struct btf *btf, __u32 id)

{

	const struct btf_type *t = btf__type_by_id(btf, id);



	switch (btf_kind_of(t)) {

	case BTF_KIND_VOLATILE:

	case BTF_KIND_CONST:

	case BTF_KIND_RESTRICT:

		return true;

	default:

		return false;

	}

}



static void btf_dump_emit_name(const struct btf_dump *d,

			       const char *name, bool last_was_ptr)

{
@@ -1139,7 +1092,7 @@ static void btf_dump_emit_type_chain(struct btf_dump *d, 
		}



		t = btf__type_by_id(d->btf, id);

		kind = btf_kind_of(t);

		kind = btf_kind(t);



		switch (kind) {

		case BTF_KIND_INT:
@@ -1185,7 +1138,7 @@ static void btf_dump_emit_type_chain(struct btf_dump *d, 
			btf_dump_printf(d, " restrict");

			break;

		case BTF_KIND_ARRAY: {

			const struct btf_array *a = (void *)(t + 1);

			const struct btf_array *a = btf_array(t);

			const struct btf_type *next_t;

			__u32 next_id;

			bool multidim;
@@ -1201,7 +1154,8 @@ static void btf_dump_emit_type_chain(struct btf_dump *d, 
			 */

			while (decls->cnt) {

				next_id = decls->ids[decls->cnt - 1];

				if (btf_is_mod_kind(d->btf, next_id))

				next_t = btf__type_by_id(d->btf, next_id);

				if (btf_is_mod(next_t))

					decls->cnt--;

				else

					break;
@@ -1214,7 +1168,7 @@ static void btf_dump_emit_type_chain(struct btf_dump *d, 
			}



			next_t = btf__type_by_id(d->btf, next_id);

			multidim = btf_kind_of(next_t) == BTF_KIND_ARRAY;

			multidim = btf_is_array(next_t);

			/* we need space if we have named non-pointer */

			if (fname[0] && !last_was_ptr)

				btf_dump_printf(d, " ");
@@ -1228,8 +1182,8 @@ static void btf_dump_emit_type_chain(struct btf_dump *d, 
			return;

		}

		case BTF_KIND_FUNC_PROTO: {

			const struct btf_param *p = (void *)(t + 1);

			__u16 vlen = btf_vlen_of(t);

			const struct btf_param *p = btf_params(t);

			__u16 vlen = btf_vlen(t);

			int i;



			btf_dump_emit_mods(d, decls);

tools/lib/bpf/libbpf.c

+29 −31

File changed.

Preview size limit exceeded, changes collapsed.