kernel/bpf/btf.c

157  * members because a member is always referring to another
158  * type.  A struct's member can be treated as "RESOLVED" if
194 #define for_each_member_from(i, from, struct_type, member)		\
195 	for (i = from, member = btf_type_member(struct_type) + from;	\
197 	     i++, member++)
199 #define for_each_vsi_from(i, from, struct_type, member)				\
200 	for (i = from, member = btf_type_var_secinfo(struct_type) + from;	\
202 	     i++, member++)
429 		const struct btf_member *member;
430 		char name[BTF_SHOW_NAME_SIZE];	/* space for member name/type */
448 			    const struct btf_member *member,
452 				  const struct btf_member *member,
662  * btf_type_is_struct() because its member refers to
663  * another type (through member->type).
672  * member-type repeated by array->nelems of times.
883  * Check that given struct member is a regular int with expected
956 	const struct btf_member *m = show->state.member;
960 	const char *member = NULL;
968 	 * Don't show type name if we're showing an array member;
970 	 * ourselves for each member.
975 	/* Retrieve member name, if any. */
977 		member = btf_name_by_offset(show->btf, m->name_off);
978 		show_member = strlen(member) > 0;
1003 	 * the typedef/pointee/array member target type.
1090 			 /* first 3 strings comprise ".member = " */
1092 			 show_member ? member : "",
1355 	show->state.member = m;
1366 	show->state.member = NULL;
1482 				    const struct btf_member *member,
1503 	 * If member is logged again, it must hit an error in
1504 	 * parsing this member.  It is useful to print out which
1505 	 * struct this member belongs to.
1513 				   __btf_name_by_offset(btf, member->name_off),
1514 				   member->type,
1515 				   BTF_MEMBER_BITFIELD_SIZE(member->offset),
1516 				   BTF_MEMBER_BIT_OFFSET(member->offset));
1519 				   __btf_name_by_offset(btf, member->name_off),
1520 				   member->type, member->offset);
2063 			       const struct btf_member *member,
2073 				     const struct btf_member *member,
2086 					  const struct btf_member *member,
2089 	if (BTF_MEMBER_BITFIELD_SIZE(member->offset)) {
2090 		btf_verifier_log_member(env, struct_type, member,
2091 					"Invalid member bitfield_size");
2095 	/* bitfield size is 0, so member->offset represents bit offset only.
2099 						       member,
2119 				const struct btf_member *member,
2123 	u32 struct_bits_off = member->offset;
2129 		btf_verifier_log_member(env, struct_type, member,
2140 		btf_verifier_log_member(env, struct_type, member,
2147 		btf_verifier_log_member(env, struct_type, member,
2157 				      const struct btf_member *member,
2165 	/* a regular int type is required for the kflag int member */
2167 		btf_verifier_log_member(env, struct_type, member,
2168 					"Invalid member base type");
2173 	nr_bits = BTF_MEMBER_BITFIELD_SIZE(member->offset);
2174 	struct_bits_off = BTF_MEMBER_BIT_OFFSET(member->offset);
2177 		/* Not a bitfield member, member offset must be at byte
2181 			btf_verifier_log_member(env, struct_type, member,
2182 						"Invalid member offset");
2188 		btf_verifier_log_member(env, struct_type, member,
2189 					"Invalid member bitfield_size");
2196 		btf_verifier_log_member(env, struct_type, member,
2203 		btf_verifier_log_member(env, struct_type, member,
2478 				     const struct btf_member *member,
2482 	u32 resolved_type_id = member->type;
2488 		btf_verifier_log_member(env, struct_type, member,
2489 					"Invalid member");
2493 	resolved_member = *member;
2503 					   const struct btf_member *member,
2507 	u32 resolved_type_id = member->type;
2513 		btf_verifier_log_member(env, struct_type, member,
2514 					"Invalid member");
2518 	resolved_member = *member;
2528 				const struct btf_member *member,
2534 	struct_bits_off = member->offset;
2538 		btf_verifier_log_member(env, struct_type, member,
2544 		btf_verifier_log_member(env, struct_type, member,
2852 				  const struct btf_member *member,
2855 	u32 struct_bits_off = member->offset;
2861 		btf_verifier_log_member(env, struct_type, member,
2866 	array_type_id = member->type;
2871 		btf_verifier_log_member(env, struct_type, member,
3063 	const struct btf_member *m = show->state.member;
3076 		show->state.member = m;
3086 		 * non-zero array member(s).
3103 				   const struct btf_member *member,
3106 	u32 struct_bits_off = member->offset;
3110 		btf_verifier_log_member(env, struct_type, member,
3118 		btf_verifier_log_member(env, struct_type, member,
3131 	const struct btf_member *member;
3138 	meta_needed = btf_type_vlen(t) * sizeof(*member);
3156 	for_each_member(i, t, member) {
3157 		if (!btf_name_offset_valid(btf, member->name_off)) {
3158 			btf_verifier_log_member(env, t, member,
3159 						"Invalid member name_offset:%u",
3160 						member->name_off);
3164 		/* struct member either no name or a valid one */
3165 		if (member->name_off &&
3166 		    !btf_name_valid_identifier(btf, member->name_off)) {
3167 			btf_verifier_log_member(env, t, member, "Invalid name");
3170 		/* A member cannot be in type void */
3171 		if (!member->type || !BTF_TYPE_ID_VALID(member->type)) {
3172 			btf_verifier_log_member(env, t, member,
3177 		offset = __btf_member_bit_offset(t, member);
3179 			btf_verifier_log_member(env, t, member,
3180 						"Invalid member bits_offset");
3185 		 * ">" instead of ">=" because the last member could be
3189 			btf_verifier_log_member(env, t, member,
3190 						"Invalid member bits_offset");
3195 			btf_verifier_log_member(env, t, member,
3200 		btf_verifier_log_member(env, t, member, NULL);
3210 	const struct btf_member *member;
3215 	 * ensure the last member is indeed resolved to a
3243 	for_each_member_from(i, v->next_member, v->t, member) {
3244 		u32 member_type_id = member->type;
3250 			btf_verifier_log_member(env, v->t, member,
3251 						"Invalid member");
3263 									    member,
3267 								      member,
3492 	const struct btf_member *member;
3496 	for_each_member(i, t, member) {
3498 								    member->type);
3507 		off = __btf_member_bit_offset(t, member);
3732 	const struct btf_member *member;
3741 	for_each_member(i, t, member) {
3743 			   __btf_name_by_offset(btf, member->name_off)))
3748 		n = btf_type_by_id(btf, member->type);
3753 		offset = __btf_member_bit_offset(n, member);
3980 	const struct btf_member *member;
3988 	for_each_member(i, t, member) {
3990 								member->type);
3996 		btf_show_start_member(show, member);
3998 		member_offset = __btf_member_bit_offset(t, member);
3999 		bitfield_size = __btf_member_bitfield_size(t, member);
4004 							member->type,
4013 			ops->show(btf, member_type, member->type,
4027 	const struct btf_member *m = show->state.member;
4040 		/* Restore saved member data here */
4041 		show->state.member = m;
4068 				 const struct btf_member *member,
4071 	u32 struct_bits_off = member->offset;
4075 		btf_verifier_log_member(env, struct_type, member,
4083 		btf_verifier_log_member(env, struct_type, member,
4093 				       const struct btf_member *member,
4099 	struct_bits_off = BTF_MEMBER_BIT_OFFSET(member->offset);
4100 	nr_bits = BTF_MEMBER_BITFIELD_SIZE(member->offset);
4103 			btf_verifier_log_member(env, struct_type, member,
4110 		btf_verifier_log_member(env, struct_type, member,
4111 					"Invalid member bitfield_size");
4118 		btf_verifier_log_member(env, struct_type, member,
4167 		/* enum member must have a valid name */
4275 		/* enum member must have a valid name */
4411 	 * a struct's member.
4414 	 * (i.e. struct's member -> BTF_KIND_PTR -> BTF_KIND_FUNC_PROTO)
4624 					     "Not a VAR kind member");
4716 				  const struct btf_member *member,
4731 	div64_u64_rem(member->offset, align_bits, &misalign_bits);
4733 		btf_verifier_log_member(env, struct_type, member,
4738 	start_offset_bytes = member->offset / BITS_PER_BYTE;
4741 		btf_verifier_log_member(env, struct_type, member,
5418 		const struct btf_member *member;
5434 		for_each_member(j, t, member) {
5435 			if (btf_id_set_contains(&aof.set, member->type))
5952 	/* get member for kernel ctx type */
6399 	const struct btf_member *member;
6417 		 * unions with a single member
6430 		member = btf_type_member(t) + vlen - 1;
6431 		mtype = btf_type_skip_modifiers(btf, member->type,
6440 		moff = __btf_member_bit_offset(t, member) / 8;
6463 	for_each_member(i, t, member) {
6465 		moff = __btf_member_bit_offset(t, member) / 8;
6470 		if (__btf_member_bitfield_size(t, member)) {
6471 			u32 end_bit = __btf_member_bit_offset(t, member) +
6472 				__btf_member_bitfield_size(t, member);
6475 			 * does not generate a BTF member for anonymous
6486 			/* off may be accessing a following member
6506 		mid = member->type;
6507 		mtype = btf_type_by_id(btf, member->type);
6508 		mname = __btf_name_by_offset(btf, member->name_off);
6520 			/* no overlap with member, keep iterating */
6550 			 * caring the current member is an array or
6558 			 * member (i.e. array in this case).  That
6584 			/* return if the offset matches the member offset */
6602 					"cannot access ptr member %s with moff %u in struct %s with off %u size %u\n",
6640 				"access beyond the end of member %s (mend:%u) in struct %s with off %u size %u\n",
8764 	const struct btf_member *member;
8785 	for_each_member(i, safe_type, member) {
8786 		const char *m_name = __btf_name_by_offset(btf, member->name_off);
8787 		const struct btf_type *mtype = btf_type_by_id(btf, member->type);