Skip to contentSkip to conversation

Support BTF_KIND_TYPE_TAG for btf_type_tag attributes

PATCH Superseded Yonghong Song 3 participants 30 messages Nov 10, 2021 – Nov 11, 2021

Subsystems (6)

v1 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

cover Support BTF_KIND_TYPE_TAG for btf_type_tag attributes

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel() etc. to read the data.

BTF_KIND_TYPE_TAG may also useful for other tracing facility where instead of to require user to specify kernel/user address type, the kernel can detect it by itself with btf.

Patch 1 added support in kernel, Patch 2 for libbpf and Patch 3 for bpftool. Patches 4-9 are for bpf selftests and Patch 10 updated docs/bpf/btf.rst file with new btf kind.

[1] https://reviews.llvm.org/D111199
[2] https://reviews.llvm.org/D113222
[3] https://reviews.llvm.org/D113496

Yonghong Song (10):
bpf: Support BTF_KIND_TYPE_TAG for btf_type_tag attributes
libbpf: Support BTF_KIND_TYPE_TAG
bpftool: Support BTF_KIND_TYPE_TAG
selftests/bpf: Test libbpf API function btf__add_type_tag() selftests/bpf: Add BTF_KIND_TYPE_TAG unit tests selftests/bpf: Test BTF_KIND_DECL_TAG for deduplication selftests/bpf: Rename progs/tag.c to progs/btf_decl_tag.c selftests/bpf: Add a C test for btf_type_tag selftests/bpf: Clarify llvm dependency with btf_tag selftest docs/bpf: Update documentation for BTF_KIND_TYPE_TAG support

 Documentation/bpf/btf.rst                     | 13 +++-
 include/uapi/linux/btf.h                      |  3 +-
 kernel/bpf/btf.c                              | 14 +++-
 tools/bpf/bpftool/btf.c                       |  2 +
 tools/include/uapi/linux/btf.h                |  3 +-
 tools/lib/bpf/btf.c                           | 23 +++++++
 tools/lib/bpf/btf.h                           |  9 ++-
 tools/lib/bpf/btf_dump.c                      |  9 +++
 tools/lib/bpf/libbpf.c                        | 31 ++++++++-
 tools/lib/bpf/libbpf.map                      |  1 +
 tools/lib/bpf/libbpf_internal.h               |  2 +
 tools/testing/selftests/bpf/README.rst        |  9 +--
 tools/testing/selftests/bpf/btf_helpers.c     |  4 +-
 tools/testing/selftests/bpf/prog_tests/btf.c  | 64 ++++++++++++++++--
 .../selftests/bpf/prog_tests/btf_tag.c        | 44 ++++++++++--
 .../selftests/bpf/prog_tests/btf_write.c      | 67 +++++++++++--------
 .../bpf/progs/{tag.c => btf_decl_tag.c}       |  0
 .../selftests/bpf/progs/btf_type_tag.c        | 29 ++++++++
 tools/testing/selftests/bpf/test_btf.h        |  3 +
 19 files changed, 281 insertions(+), 49 deletions(-)
 rename tools/testing/selftests/bpf/progs/{tag.c => btf_decl_tag.c} (100%)
 create mode 100644 tools/testing/selftests/bpf/progs/btf_type_tag.c
Signature · 1 line
2.30.2
#4 lore raw

PATCH 2/10 libbpf: Support BTF_KIND_TYPE_TAG

Add libbpf support for BTF_KIND_TYPE_TAG.

---
 tools/lib/bpf/btf.c             | 23 +++++++++++++++++++++++
 tools/lib/bpf/btf.h             |  9 ++++++++-
 tools/lib/bpf/btf_dump.c        |  9 +++++++++
 tools/lib/bpf/libbpf.c          | 31 ++++++++++++++++++++++++++++++-
 tools/lib/bpf/libbpf.map        |  1 +
 tools/lib/bpf/libbpf_internal.h |  2 ++
 6 files changed, 73 insertions(+), 2 deletions(-)
tools/lib/bpf/btf.c +23 -0
index 7e4c5586bd87..4d9883bef330 100644
@@ -299,6 +299,7 @@ static int btf_type_size(const struct btf_type *t)
 	case BTF_KIND_TYPEDEF:
 	case BTF_KIND_FUNC:
 	case BTF_KIND_FLOAT:
+	case BTF_KIND_TYPE_TAG:
 		return base_size;
 	case BTF_KIND_INT:
 		return base_size + sizeof(__u32);
@@ -349,6 +350,7 @@ static int btf_bswap_type_rest(struct btf_type *t)
 	case BTF_KIND_TYPEDEF:
 	case BTF_KIND_FUNC:
 	case BTF_KIND_FLOAT:
+	case BTF_KIND_TYPE_TAG:
 		return 0;
 	case BTF_KIND_INT:
 		*(__u32 *)(t + 1) = bswap_32(*(__u32 *)(t + 1));
@@ -649,6 +651,7 @@ int btf__align_of(const struct btf *btf, __u32 id)
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_CONST:
 	case BTF_KIND_RESTRICT:
+	case BTF_KIND_TYPE_TAG:
 		return btf__align_of(btf, t->type);
 	case BTF_KIND_ARRAY:
 		return btf__align_of(btf, btf_array(t)->type);
@@ -2235,6 +2238,22 @@ int btf__add_restrict(struct btf *btf, int ref_type_id)
 	return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id);
 }
 
+/*
+ * Append new BTF_KIND_TYPE_TAGtype with:
+ *   - *value*, non-empty/non-NULL name;
+ *   - *ref_type_id* - referenced type ID, it might not exist yet;
+ * Returns:
+ *   - >0, type ID of newly added BTF type;
+ *   - <0, on error.
+ */
+int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id)
+{
+	if (!value|| !value[0])
+		return libbpf_err(-EINVAL);
+
+	return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id);
+}
+
 /*
  * Append new BTF_KIND_FUNC type with:
  *   - *name*, non-empty/non-NULL name;
@@ -3625,6 +3644,7 @@ static int btf_dedup_prep(struct btf_dedup *d)
 		case BTF_KIND_TYPEDEF:
 		case BTF_KIND_FUNC:
 		case BTF_KIND_FLOAT:
+		case BTF_KIND_TYPE_TAG:
 			h = btf_hash_common(t);
 			break;
 		case BTF_KIND_INT:
@@ -3685,6 +3705,7 @@ static int btf_dedup_prim_type(struct btf_dedup *d, __u32 type_id)
 	case BTF_KIND_VAR:
 	case BTF_KIND_DATASEC:
 	case BTF_KIND_DECL_TAG:
+	case BTF_KIND_TYPE_TAG:
 		return 0;
 
 	case BTF_KIND_INT:
@@ -4289,6 +4310,7 @@ static int btf_dedup_ref_type(struct btf_dedup *d, __u32 type_id)
 	case BTF_KIND_PTR:
 	case BTF_KIND_TYPEDEF:
 	case BTF_KIND_FUNC:
+	case BTF_KIND_TYPE_TAG:
 		ref_type_id = btf_dedup_ref_type(d, t->type);
 		if (ref_type_id < 0)
 			return ref_type_id;
@@ -4595,6 +4617,7 @@ int btf_type_visit_type_ids(struct btf_type *t, type_id_visit_fn visit, void *ct
 	case BTF_KIND_FUNC:
 	case BTF_KIND_VAR:
 	case BTF_KIND_DECL_TAG:
+	case BTF_KIND_TYPE_TAG:
 		return visit(&t->type, ctx);
 
 	case BTF_KIND_ARRAY: {
tools/lib/bpf/btf.h +8 -1
index bc005ba3ceec..129c2acc8493 100644
@@ -227,6 +227,7 @@ LIBBPF_API int btf__add_typedef(struct btf *btf, const char *name, int ref_type_
 LIBBPF_API int btf__add_volatile(struct btf *btf, int ref_type_id);
 LIBBPF_API int btf__add_const(struct btf *btf, int ref_type_id);
 LIBBPF_API int btf__add_restrict(struct btf *btf, int ref_type_id);
+LIBBPF_API int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id);
 
 /* func and func_proto construction APIs */
 LIBBPF_API int btf__add_func(struct btf *btf, const char *name,
@@ -403,7 +404,8 @@ static inline bool btf_is_mod(const struct btf_type *t)
 
 	return kind == BTF_KIND_VOLATILE ||
 	       kind == BTF_KIND_CONST ||
-	       kind == BTF_KIND_RESTRICT;
+	       kind == BTF_KIND_RESTRICT ||
+	       kind == BTF_KIND_TYPE_TAG;
 }
 
 static inline bool btf_is_func(const struct btf_type *t)
@@ -436,6 +438,11 @@ static inline bool btf_is_decl_tag(const struct btf_type *t)
 	return btf_kind(t) == BTF_KIND_DECL_TAG;
 }
 
+static inline bool btf_is_type_tag(const struct btf_type *t)
+{
+	return btf_kind(t) == BTF_KIND_TYPE_TAG;
+}
+
 static inline __u8 btf_int_encoding(const struct btf_type *t)
 {
 	return BTF_INT_ENCODING(*(__u32 *)(t + 1));
tools/lib/bpf/btf_dump.c +9 -0
index 17db62b5002e..380250a5bfcd 100644
@@ -317,6 +317,7 @@ static int btf_dump_mark_referenced(struct btf_dump *d)
 		case BTF_KIND_FUNC:
 		case BTF_KIND_VAR:
 		case BTF_KIND_DECL_TAG:
+		case BTF_KIND_TYPE_TAG:
 			d->type_states[t->type].referenced = 1;
 			break;
 
@@ -560,6 +561,7 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr)
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_CONST:
 	case BTF_KIND_RESTRICT:
+	case BTF_KIND_TYPE_TAG:
 		return btf_dump_order_type(d, t->type, through_ptr);
 
 	case BTF_KIND_FUNC_PROTO: {
@@ -734,6 +736,7 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id)
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_CONST:
 	case BTF_KIND_RESTRICT:
+	case BTF_KIND_TYPE_TAG:
 		btf_dump_emit_type(d, t->type, cont_id);
 		break;
 	case BTF_KIND_ARRAY:
@@ -1154,6 +1157,7 @@ static void btf_dump_emit_type_decl(struct btf_dump *d, __u32 id,
 		case BTF_KIND_CONST:
 		case BTF_KIND_RESTRICT:
 		case BTF_KIND_FUNC_PROTO:
+		case BTF_KIND_TYPE_TAG:
 			id = t->type;
 			break;
 		case BTF_KIND_ARRAY:
@@ -1322,6 +1326,11 @@ static void btf_dump_emit_type_chain(struct btf_dump *d,
 		case BTF_KIND_RESTRICT:
 			btf_dump_printf(d, " restrict");
 			break;
+		case BTF_KIND_TYPE_TAG:
+			btf_dump_emit_mods(d, decls);
+			name = btf_name_of(d, t->name_off);
+			btf_dump_printf(d, " __attribute__((btf_type_tag(\"%s\")))", name);
+			break;
 		case BTF_KIND_ARRAY: {
 			const struct btf_array *a = btf_array(t);
 			const struct btf_type *next_t;
tools/lib/bpf/libbpf.c +30 -1
index d869ebee1e27..f6bf8ce24bbd 100644
@@ -197,6 +197,8 @@ enum kern_feature_id {
 	FEAT_PERF_LINK,
 	/* BTF_KIND_DECL_TAG support */
 	FEAT_BTF_DECL_TAG,
+	/* BTF_KIND_TYPE_TAG support */
+	FEAT_BTF_TYPE_TAG,
 	__FEAT_CNT,
 };
 
@@ -2076,6 +2078,7 @@ static const char *__btf_kind_str(__u16 kind)
 	case BTF_KIND_DATASEC: return "datasec";
 	case BTF_KIND_FLOAT: return "float";
 	case BTF_KIND_DECL_TAG: return "decl_tag";
+	case BTF_KIND_TYPE_TAG: return "type_tag";
 	default: return "unknown";
 	}
 }
@@ -2588,8 +2591,10 @@ static bool btf_needs_sanitization(struct bpf_object *obj)
 	bool has_float = kernel_supports(obj, FEAT_BTF_FLOAT);
 	bool has_func = kernel_supports(obj, FEAT_BTF_FUNC);
 	bool has_decl_tag = kernel_supports(obj, FEAT_BTF_DECL_TAG);
+	bool has_type_tag = kernel_supports(obj, FEAT_BTF_TYPE_TAG);
 
-	return !has_func || !has_datasec || !has_func_global || !has_float || !has_decl_tag;
+	return !has_func || !has_datasec || !has_func_global || !has_float ||
+	       !has_decl_tag || !has_type_tag;
 }
 
 static void bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *btf)
@@ -2599,6 +2604,7 @@ static void bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *btf)
 	bool has_float = kernel_supports(obj, FEAT_BTF_FLOAT);
 	bool has_func = kernel_supports(obj, FEAT_BTF_FUNC);
 	bool has_decl_tag = kernel_supports(obj, FEAT_BTF_DECL_TAG);
+	bool has_type_tag = kernel_supports(obj, FEAT_BTF_TYPE_TAG);
 	struct btf_type *t;
 	int i, j, vlen;
 
@@ -2657,6 +2663,10 @@ static void bpf_object__sanitize_btf(struct bpf_object *obj, struct btf *btf)
 			 */
 			t->name_off = 0;
 			t->info = BTF_INFO_ENC(BTF_KIND_STRUCT, 0, 0);
+		} else if (!has_type_tag && btf_is_type_tag(t)) {
+			/* replace TYPE_TAG with a CONST */
+			t->name_off = 0;
+			t->info = BTF_INFO_ENC(BTF_KIND_CONST, 0, 0);
 		}
 	}
 }
@@ -4460,6 +4470,22 @@ static int probe_kern_btf_decl_tag(void)
 					     strs, sizeof(strs)));
 }
 
+static int probe_kern_btf_type_tag(void)
+{
+	static const char strs[] = "\0tag";
+	__u32 types[] = {
+		/* int */
+		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
+		/* attr */
+		BTF_TYPE_TYPE_TAG_ENC(1, 1),				/* [2] */
+		/* ptr */
+		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),	/* [3] */
+	};
+
+	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
+					     strs, sizeof(strs)));
+}
+
 static int probe_kern_array_mmap(void)
 {
 	struct bpf_create_map_attr attr = {
@@ -4657,6 +4683,9 @@ static struct kern_feature_desc {
 	[FEAT_BTF_DECL_TAG] = {
 		"BTF_KIND_DECL_TAG support", probe_kern_btf_decl_tag,
 	},
+	[FEAT_BTF_TYPE_TAG] = {
+		"BTF_KIND_TYPE_TAG support", probe_kern_btf_type_tag,
+	},
 };
 
 static bool kernel_supports(const struct bpf_object *obj, enum kern_feature_id feat_id)
tools/lib/bpf/libbpf.map +1 -0
index b895861a13c0..0126d924674f 100644
@@ -401,6 +401,7 @@ LIBBPF_0.6.0 {
 		bpf_program__insns;
 		btf__add_btf;
 		btf__add_decl_tag;
+		btf__add_type_tag;
 		btf__raw_data;
 		btf__type_cnt;
 } LIBBPF_0.5.0;
tools/lib/bpf/libbpf_internal.h +2 -0
index 2d873c962f99..5490fa98c0a6 100644
@@ -73,6 +73,8 @@
 	BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 0), sz)
 #define BTF_TYPE_DECL_TAG_ENC(value, type, component_idx) \
 	BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 0), type), (component_idx)
+#define BTF_TYPE_TYPE_TAG_ENC(value, type) \
+	BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_TYPE_TAG, 0, 0), type)
 
 #ifndef likely
 #define likely(x) __builtin_expect(!!(x), 1)
Signature · 1 line
2.30.2
#7 lore raw

PATCH 3/10 bpftool: Support BTF_KIND_TYPE_TAG

In reply to Yonghong Song

Add bpftool support for BTF_KIND_TYPE_TAG.

---
 tools/bpf/bpftool/btf.c | 2 ++
 1 file changed, 2 insertions(+)
tools/bpf/bpftool/btf.c +2 -0
index 015d2758f826..e77dda35d1de 100644
@@ -39,6 +39,7 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = {
 	[BTF_KIND_DATASEC]	= "DATASEC",
 	[BTF_KIND_FLOAT]	= "FLOAT",
 	[BTF_KIND_DECL_TAG]	= "DECL_TAG",
+	[BTF_KIND_TYPE_TAG]	= "TYPE_TAG",
 };
 
 struct btf_attach_point {
@@ -142,6 +143,7 @@ static int dump_btf_type(const struct btf *btf, __u32 id,
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_RESTRICT:
 	case BTF_KIND_TYPEDEF:
+	case BTF_KIND_TYPE_TAG:
 		if (json_output)
 			jsonw_uint_field(w, "type_id", t->type);
 		else
Signature · 1 line
2.30.2
#1 lore raw

PATCH 1/10 bpf: Support BTF_KIND_TYPE_TAG for btf_type_tag attributes

In reply to Yonghong Song

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel() etc. to read the data.

BTF_KIND_TYPE_TAG may also useful for other tracing facility where instead of to require user to specify kernel/user address type, the kernel can detect it by itself with btf.

[1] https://reviews.llvm.org/D111199
[2] https://reviews.llvm.org/D113222
[3] https://reviews.llvm.org/D113496

---
 include/uapi/linux/btf.h       |  3 ++-
 kernel/bpf/btf.c               | 14 +++++++++++++-
 tools/include/uapi/linux/btf.h |  3 ++-
 3 files changed, 17 insertions(+), 3 deletions(-)
include/uapi/linux/btf.h +2 -1
index deb12f755f0f..b0d8fea1951d 100644
@@ -43,7 +43,7 @@ struct btf_type {
 	 * "size" tells the size of the type it is describing.
 	 *
 	 * "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
-	 * FUNC, FUNC_PROTO, VAR and DECL_TAG.
+	 * FUNC, FUNC_PROTO, VAR, DECL_TAG and TYPE_TAG.
 	 * "type" is a type_id referring to another type.
 	 */
 	union {
@@ -75,6 +75,7 @@ enum {
 	BTF_KIND_DATASEC	= 15,	/* Section	*/
 	BTF_KIND_FLOAT		= 16,	/* Floating point	*/
 	BTF_KIND_DECL_TAG	= 17,	/* Decl Tag */
+	BTF_KIND_TYPE_TAG	= 18,	/* Type Tag */
 
 	NR_BTF_KINDS,
 	BTF_KIND_MAX		= NR_BTF_KINDS - 1,
kernel/bpf/btf.c +13 -1
index cdb0fba65600..1dd9ba82da1e 100644
@@ -282,6 +282,7 @@ static const char * const btf_kind_str[NR_BTF_KINDS] = {
 	[BTF_KIND_DATASEC]	= "DATASEC",
 	[BTF_KIND_FLOAT]	= "FLOAT",
 	[BTF_KIND_DECL_TAG]	= "DECL_TAG",
+	[BTF_KIND_TYPE_TAG]	= "TYPE_TAG",
 };
 
 const char *btf_type_str(const struct btf_type *t)
@@ -418,6 +419,7 @@ static bool btf_type_is_modifier(const struct btf_type *t)
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_CONST:
 	case BTF_KIND_RESTRICT:
+	case BTF_KIND_TYPE_TAG:
 		return true;
 	}
 
@@ -1737,6 +1739,7 @@ __btf_resolve_size(const struct btf *btf, const struct btf_type *type,
 		case BTF_KIND_VOLATILE:
 		case BTF_KIND_CONST:
 		case BTF_KIND_RESTRICT:
+		case BTF_KIND_TYPE_TAG:
 			id = type->type;
 			type = btf_type_by_id(btf, type->type);
 			break;
@@ -2345,6 +2348,8 @@ static int btf_ref_type_check_meta(struct btf_verifier_env *env,
 				   const struct btf_type *t,
 				   u32 meta_left)
 {
+	const char *value;
+
 	if (btf_type_vlen(t)) {
 		btf_verifier_log_type(env, t, "vlen != 0");
 		return -EINVAL;
@@ -2360,7 +2365,7 @@ static int btf_ref_type_check_meta(struct btf_verifier_env *env,
 		return -EINVAL;
 	}
 
-	/* typedef type must have a valid name, and other ref types,
+	/* typedef/type_tag type must have a valid name, and other ref types,
 	 * volatile, const, restrict, should have a null name.
 	 */
 	if (BTF_INFO_KIND(t->info) == BTF_KIND_TYPEDEF) {
@@ -2369,6 +2374,12 @@ static int btf_ref_type_check_meta(struct btf_verifier_env *env,
 			btf_verifier_log_type(env, t, "Invalid name");
 			return -EINVAL;
 		}
+	} else if (BTF_INFO_KIND(t->info) == BTF_KIND_TYPE_TAG) {
+		value = btf_name_by_offset(env->btf, t->name_off);
+		if (!value || !value[0]) {
+			btf_verifier_log_type(env, t, "Invalid name");
+			return -EINVAL;
+		}
 	} else {
 		if (t->name_off) {
 			btf_verifier_log_type(env, t, "Invalid name");
@@ -4059,6 +4070,7 @@ static const struct btf_kind_operations * const kind_ops[NR_BTF_KINDS] = {
 	[BTF_KIND_DATASEC] = &datasec_ops,
 	[BTF_KIND_FLOAT] = &float_ops,
 	[BTF_KIND_DECL_TAG] = &decl_tag_ops,
+	[BTF_KIND_TYPE_TAG] = &modifier_ops,
 };
 
 static s32 btf_check_meta(struct btf_verifier_env *env,
tools/include/uapi/linux/btf.h +2 -1
index deb12f755f0f..b0d8fea1951d 100644
@@ -43,7 +43,7 @@ struct btf_type {
 	 * "size" tells the size of the type it is describing.
 	 *
 	 * "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
-	 * FUNC, FUNC_PROTO, VAR and DECL_TAG.
+	 * FUNC, FUNC_PROTO, VAR, DECL_TAG and TYPE_TAG.
 	 * "type" is a type_id referring to another type.
 	 */
 	union {
@@ -75,6 +75,7 @@ enum {
 	BTF_KIND_DATASEC	= 15,	/* Section	*/
 	BTF_KIND_FLOAT		= 16,	/* Floating point	*/
 	BTF_KIND_DECL_TAG	= 17,	/* Decl Tag */
+	BTF_KIND_TYPE_TAG	= 18,	/* Type Tag */
 
 	NR_BTF_KINDS,
 	BTF_KIND_MAX		= NR_BTF_KINDS - 1,
Signature · 1 line
2.30.2
#9 lore raw

PATCH 4/10 selftests/bpf: Test libbpf API function btf__add_type_tag()

In reply to Yonghong Song

Add unit tests for btf__add_type_tag().

---
 tools/testing/selftests/bpf/btf_helpers.c     |  4 +-
 .../selftests/bpf/prog_tests/btf_write.c      | 67 +++++++++++--------
 2 files changed, 43 insertions(+), 28 deletions(-)
tools/testing/selftests/bpf/btf_helpers.c +3 -1
index 3d1a748d09d8..89e717961c43 100644
@@ -25,11 +25,12 @@ static const char * const btf_kind_str_mapping[] = {
 	[BTF_KIND_DATASEC]	= "DATASEC",
 	[BTF_KIND_FLOAT]	= "FLOAT",
 	[BTF_KIND_DECL_TAG]	= "DECL_TAG",
+	[BTF_KIND_TYPE_TAG]	= "TYPE_TAG",
 };
 
 static const char *btf_kind_str(__u16 kind)
 {
-	if (kind > BTF_KIND_DECL_TAG)
+	if (kind > BTF_KIND_TYPE_TAG)
 		return "UNKNOWN";
 	return btf_kind_str_mapping[kind];
 }
@@ -109,6 +110,7 @@ int fprintf_btf_type_raw(FILE *out, const struct btf *btf, __u32 id)
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_RESTRICT:
 	case BTF_KIND_TYPEDEF:
+	case BTF_KIND_TYPE_TAG:
 		fprintf(out, " type_id=%u", t->type);
 		break;
 	case BTF_KIND_ARRAY: {
tools/testing/selftests/bpf/prog_tests/btf_write.c +40 -27

95 lines not on this page · raw message

Signature · 1 line
2.30.2
#13 lore raw

PATCH 6/10 selftests/bpf: Test BTF_KIND_DECL_TAG for deduplication

In reply to Yonghong Song
---
 tools/testing/selftests/bpf/prog_tests/btf.c | 46 ++++++++++++++++++--
 1 file changed, 42 insertions(+), 4 deletions(-)
tools/testing/selftests/bpf/prog_tests/btf.c +42 -4
index ebd0ead5f4bc..91b19c41729f 100644
@@ -6889,15 +6889,16 @@ const struct btf_dedup_test dedup_tests[] = {
 			BTF_RESTRICT_ENC(8),						/* [11] restrict */
 			BTF_FUNC_PROTO_ENC(1, 2),					/* [12] func_proto */
 				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
-				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
+				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
 			BTF_FUNC_ENC(NAME_TBD, 12),					/* [13] func */
 			BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),				/* [14] float */
 			BTF_DECL_TAG_ENC(NAME_TBD, 13, -1),				/* [15] decl_tag */
 			BTF_DECL_TAG_ENC(NAME_TBD, 13, 1),				/* [16] decl_tag */
 			BTF_DECL_TAG_ENC(NAME_TBD, 7, -1),				/* [17] decl_tag */
+			BTF_TYPE_TAG_ENC(NAME_TBD, 8),					/* [18] type_tag */
 			BTF_END_RAW,
 		},
-		BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q"),
+		BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R"),
 	},
 	.expect = {
 		.raw_types = {
@@ -6918,15 +6919,16 @@ const struct btf_dedup_test dedup_tests[] = {
 			BTF_RESTRICT_ENC(8),						/* [11] restrict */
 			BTF_FUNC_PROTO_ENC(1, 2),					/* [12] func_proto */
 				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
-				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
+				BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
 			BTF_FUNC_ENC(NAME_TBD, 12),					/* [13] func */
 			BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),				/* [14] float */
 			BTF_DECL_TAG_ENC(NAME_TBD, 13, -1),				/* [15] decl_tag */
 			BTF_DECL_TAG_ENC(NAME_TBD, 13, 1),				/* [16] decl_tag */
 			BTF_DECL_TAG_ENC(NAME_TBD, 7, -1),				/* [17] decl_tag */
+			BTF_TYPE_TAG_ENC(NAME_TBD, 8),					/* [18] type_tag */
 			BTF_END_RAW,
 		},
-		BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q"),
+		BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R"),
 	},
 	.opts = {
 		.dont_resolve_fwds = false,
@@ -7254,6 +7256,42 @@ const struct btf_dedup_test dedup_tests[] = {
 		.dont_resolve_fwds = false,
 	},
 },
+{
+	.descr = "dedup: btf_tag_type",
+	.input = {
+		.raw_types = {
+			/* int */
+			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
+			/* tag: tag1, tag2 */
+			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
+			BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),		/* [3] */
+			BTF_PTR_ENC(3),					/* [4] */
+			/* tag: tag1, tag2 */
+			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [5] */
+			BTF_TYPE_TAG_ENC(NAME_NTH(2), 5),		/* [6] */
+			BTF_PTR_ENC(6),					/* [7] */
+			/* tag: tag1 */
+			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [8] */
+			BTF_PTR_ENC(8),					/* [9] */
+			BTF_END_RAW,
+		},
+		BTF_STR_SEC("\0tag1\0tag2"),
+	},
+	.expect = {
+		.raw_types = {
+			BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
+			BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),		/* [2] */
+			BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),		/* [3] */
+			BTF_PTR_ENC(3),					/* [4] */
+			BTF_PTR_ENC(2),					/* [5] */
+			BTF_END_RAW,
+		},
+		BTF_STR_SEC("\0tag1\0tag2"),
+	},
+	.opts = {
+		.dont_resolve_fwds = false,
+	},
+},
 
 };
 
Signature · 1 line
2.30.2
#16 lore raw

PATCH 7/10 selftests/bpf: Rename progs/tag.c to progs/btf_decl_tag.c

In reply to Yonghong Song

Rename progs/tag.c to progs/btf_decl_tag.c so we can introduce progs/btf_type_tag.c in the next patch.

Also create a subtest for btf_decl_tag in prog_tests/btf_tag.c so we can introduce btf_type_tag subtest in the next patch.

---
 .../selftests/bpf/prog_tests/btf_tag.c        | 20 ++++++++++++-------
 .../bpf/progs/{tag.c => btf_decl_tag.c}       |  0
 2 files changed, 13 insertions(+), 7 deletions(-)
 rename tools/testing/selftests/bpf/progs/{tag.c => btf_decl_tag.c} (100%)
tools/testing/selftests/bpf/prog_tests/btf_tag.c +13 -7
index 91821f42714d..d15cc7a88182 100644
@@ -1,20 +1,26 @@
 // SPDX-License-Identifier: GPL-2.0
 /* Copyright (c) 2021 Facebook */
 #include <test_progs.h>
-#include "tag.skel.h"
+#include "btf_decl_tag.skel.h"
 
-void test_btf_tag(void)
+static void test_btf_decl_tag(void)
 {
-	struct tag *skel;
+	struct btf_decl_tag *skel;
 
-	skel = tag__open_and_load();
-	if (!ASSERT_OK_PTR(skel, "btf_tag"))
+	skel = btf_decl_tag__open_and_load();
+	if (!ASSERT_OK_PTR(skel, "btf_decl_tag"))
 		return;
 
 	if (skel->rodata->skip_tests) {
-		printf("%s:SKIP: btf_tag attribute not supported", __func__);
+		printf("%s:SKIP: btf_decl_tag attribute not supported", __func__);
 		test__skip();
 	}
 
-	tag__destroy(skel);
+	btf_decl_tag__destroy(skel);
+}
+
+void test_btf_tag(void)
+{
+	if (test__start_subtest("btf_decl_tag"))
+		test_btf_decl_tag();
 }
tools/testing/selftests/bpf/progs/btf_decl_tag.c renamed from tools/testing/selftests/bpf/progs/tag.c +0 -0
similarity index 100%
rename from tools/testing/selftests/bpf/progs/tag.c
rename to tools/testing/selftests/bpf/progs/btf_decl_tag.c
Signature · 1 line
2.30.2
#21 lore raw

PATCH 9/10 selftests/bpf: Clarify llvm dependency with btf_tag selftest

In reply to Yonghong Song

btf_tag selftest needs certain llvm versions (>= llvm14). Make it clear in the selftests README.rst file.

---
 tools/testing/selftests/bpf/README.rst | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)
tools/testing/selftests/bpf/README.rst +5 -4
index 5e287e445f75..42ef250c7acc 100644
@@ -204,16 +204,17 @@ __ https://reviews.llvm.org/D93563
 btf_tag test and Clang version
 ==============================
 
-The btf_tag selftest require LLVM support to recognize the btf_decl_tag attribute.
-It was introduced in `Clang 14`__.
+The btf_tag selftest requires LLVM support to recognize the btf_decl_tag and
+btf_type_tag attributes. They are introduced in `Clang 14` [0_, 1_].
 
-Without it, the btf_tag selftest will be skipped and you will observe:
+Without them, the btf_tag selftest will be skipped and you will observe:
 
 .. code-block:: console
 
   #<test_num> btf_tag:SKIP
 
-__ https://reviews.llvm.org/D111588
+.. _0: https://reviews.llvm.org/D111588
+.. _1: https://reviews.llvm.org/D111199
 
 Clang dependencies for static linking tests
 ===========================================
Signature · 1 line
2.30.2
#28 lore raw

PATCH 10/10 docs/bpf: Update documentation for BTF_KIND_TYPE_TAG support

In reply to Yonghong Song

Add BTF_KIND_TYPE_TAG documentation in btf.rst.

---
 Documentation/bpf/btf.rst | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)
Documentation/bpf/btf.rst +12 -1
index 9ad4218a751f..d0ec40d00c28 100644
@@ -86,6 +86,7 @@ sequentially and type id is assigned to each recognized type starting from id
     #define BTF_KIND_DATASEC        15      /* Section      */
     #define BTF_KIND_FLOAT          16      /* Floating point       */
     #define BTF_KIND_DECL_TAG       17      /* Decl Tag     */
+    #define BTF_KIND_TYPE_TAG       18      /* Type Tag     */
 
 Note that the type section encodes debug info, not just pure types.
 ``BTF_KIND_FUNC`` is not a type, and it represents a defined subprogram.
@@ -107,7 +108,7 @@ Each type contains the following common data::
          * "size" tells the size of the type it is describing.
          *
          * "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
-         * FUNC, FUNC_PROTO and DECL_TAG.
+         * FUNC, FUNC_PROTO, DECL_TAG and TYPE_TAG.
          * "type" is a type_id referring to another type.
          */
         union {
@@ -492,6 +493,16 @@ the attribute is applied to a ``struct``/``union`` member or
 a ``func`` argument, and ``btf_decl_tag.component_idx`` should be a
 valid index (starting from 0) pointing to a member or an argument.
 
+2.2.17 BTF_KIND_TYPE_TAG
+~~~~~~~~~~~~~~~~~~~~~~~~
+
+``struct btf_type`` encoding requirement:
+ * ``name_off``: offset to a non-empty string
+ * ``info.kind_flag``: 0
+ * ``info.kind``: BTF_KIND_TYPE_TAG
+ * ``info.vlen``: 0
+ * ``type``: the type with ``btf_type_tag`` attribute
+
 3. BTF Kernel API
 *****************
 
Signature · 1 line
2.30.2
#18 lore raw

PATCH 8/10 selftests/bpf: Add a C test for btf_type_tag

In reply to Yonghong Song

For the C test, compiler the kernel and selftest with clang compiler by adding LLVM=1 to the make command line since btf_type_tag is only supported by clang compiler now.

The following is the key btf_type_tag usage:
#define __tag1 __attribute__((btf_type_tag("tag1"))) #define __tag2 __attribute__((btf_type_tag("tag2")))

  struct btf_type_tag_test {
       int __tag1 * __tag1 __tag2 *p;

} g;

The bpftool raw dump with related types:
[4] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED
[11] STRUCT 'btf_type_tag_test' size=8 vlen=1

          'p' type_id=14 bits_offset=0

[12] TYPE_TAG 'tag1' type_id=16
[13] TYPE_TAG 'tag2' type_id=12
[14] PTR '(anon)' type_id=13
[15] TYPE_TAG 'tag1' type_id=4
[16] PTR '(anon)' type_id=15
[17] VAR 'g' type_id=11, linkage=global

With format C dump, we have

  struct btf_type_tag_test {
        int __attribute__((btf_type_tag("tag1"))) * __attribute__((btf_type_tag("tag1"))) __attribute__((btf_type_tag("tag2"))) *p;

};
The result C code is identical to the original definition except macro's are gone.

---
 .../selftests/bpf/prog_tests/btf_tag.c        | 24 +++++++++++++++
 .../selftests/bpf/progs/btf_type_tag.c        | 29 +++++++++++++++++++
 2 files changed, 53 insertions(+)
 create mode 100644 tools/testing/selftests/bpf/progs/btf_type_tag.c
tools/testing/selftests/bpf/prog_tests/btf_tag.c +24 -0
index d15cc7a88182..88d63e23e35f 100644
@@ -3,6 +3,12 @@
 #include <test_progs.h>
 #include "btf_decl_tag.skel.h"
 
+/* struct btf_type_tag_test is referenced in btf_type_tag.skel.h */
+struct btf_type_tag_test {
+        int **p;
+};
+#include "btf_type_tag.skel.h"
+
 static void test_btf_decl_tag(void)
 {
 	struct btf_decl_tag *skel;
@@ -19,8 +25,26 @@ static void test_btf_decl_tag(void)
 	btf_decl_tag__destroy(skel);
 }
 
+static void test_btf_type_tag(void)
+{
+	struct btf_type_tag *skel;
+
+	skel = btf_type_tag__open_and_load();
+	if (!ASSERT_OK_PTR(skel, "btf_type_tag"))
+		return;
+
+	if (skel->rodata->skip_tests) {
+		printf("%s:SKIP: btf_type_tag attribute not supported", __func__);
+		test__skip();
+	}
+
+	btf_type_tag__destroy(skel);
+}
+
 void test_btf_tag(void)
 {
 	if (test__start_subtest("btf_decl_tag"))
 		test_btf_decl_tag();
+	if (test__start_subtest("btf_type_tag"))
+		test_btf_type_tag();
 }
tools/testing/selftests/bpf/progs/btf_type_tag.c new file +29 -0
new file mode 100644
index 000000000000..0e18c777862c
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2021 Facebook */
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif
+
+#if __has_attribute(btf_type_tag)
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+#define __tag2 __attribute__((btf_type_tag("tag2")))
+volatile const bool skip_tests = false;
+#else
+#define __tag1
+#define __tag2
+volatile const bool skip_tests = true;
+#endif
+
+struct btf_type_tag_test {
+	int __tag1 * __tag1 __tag2 *p;
+} g;
+
+SEC("fentry/bpf_fentry_test1")
+int BPF_PROG(sub, int x)
+{
+  return 0;
+}
Signature · 1 line
2.30.2
#23 lore raw
In reply to Yonghong Song
Quoted 10 lines · Yonghong Song

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel() etc. to read the data.

+#define __tag1 __attribute__((btf_type_tag("tag1"))) +#define __tag2 __attribute__((btf_type_tag("tag2"))) +
+struct btf_type_tag_test {
+ int __tag1 * __tag1 __tag2 *p;
+} g;

Can we build the kernel with the latest clang and get __user in BTF ?

#11 lore raw

PATCH 5/10 selftests/bpf: Add BTF_KIND_TYPE_TAG unit tests

In reply to Yonghong Song

Add BTF_KIND_TYPE_TAG unit tests.

---
 tools/testing/selftests/bpf/prog_tests/btf.c | 18 ++++++++++++++++++
 tools/testing/selftests/bpf/test_btf.h       |  3 +++
 2 files changed, 21 insertions(+)
tools/testing/selftests/bpf/prog_tests/btf.c +18 -0
index ebd1aa4d09d6..ebd0ead5f4bc 100644
@@ -3939,6 +3939,23 @@ static struct btf_raw_test raw_tests[] = {
 	.btf_load_err = true,
 	.err_str = "Invalid component_idx",
 },
+{
+	.descr = "type_tag test #1",
+	.raw_types = {
+		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),	/* [1] */
+		BTF_TYPE_TAG_ENC(NAME_TBD, 1),			/* [2] */
+		BTF_PTR_ENC(2),					/* [3] */
+		BTF_END_RAW,
+	},
+	BTF_STR_SEC("\0tag"),
+	.map_type = BPF_MAP_TYPE_ARRAY,
+	.map_name = "tag_type_check_btf",
+	.key_size = sizeof(int),
+	.value_size = 4,
+	.key_type_id = 1,
+	.value_type_id = 1,
+	.max_entries = 1,
+},
 
 }; /* struct btf_raw_test raw_tests[] */
 
@@ -7255,6 +7272,7 @@ static int btf_type_size(const struct btf_type *t)
 	case BTF_KIND_TYPEDEF:
 	case BTF_KIND_FUNC:
 	case BTF_KIND_FLOAT:
+	case BTF_KIND_TYPE_TAG:
 		return base_size;
 	case BTF_KIND_INT:
 		return base_size + sizeof(__u32);
tools/testing/selftests/bpf/test_btf.h +3 -0
index 32c7a57867da..128989bed8b7 100644
@@ -72,4 +72,7 @@
 #define BTF_DECL_TAG_ENC(value, type, component_idx)	\
 	BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 0), type), (component_idx)
 
+#define BTF_TYPE_TAG_ENC(value, type)	\
+	BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_TYPE_TAG, 0, 0), type)
+
 #endif /* _TEST_BTF_H */
Signature · 1 line
2.30.2
#24 lore raw
In reply to Alexei Starovoitov
Quoted 19 lines · Alexei Starovoitov
Quoted 10 lines · Yonghong Song

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel() etc. to read the data.

(quoted diff) +6 -0
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+#define __tag2 __attribute__((btf_type_tag("tag2")))
+
+struct btf_type_tag_test {
+       int __tag1 * __tag1 __tag2 *p;
+} g;
Quoted 1 line

Can we build the kernel with the latest clang and get __user in BTF ?

Not yet. The following are the steps:
1. land this patch set in the kernel
2. sync to libbpf repo.
3. pahole sync with libbpf repo, and pahole convert btf_type_tag in llvm to BTF
4. another kernel patch to define __user as

     __attribute__((btf_type_tag("user")))

and then we will get __user in vmlinux BTF.

#25 lore raw
Quoted 31 lines · Yonghong Song
Quoted 19 lines · Alexei Starovoitov
Quoted 10 lines · Yonghong Song

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel() etc. to read the data.

(quoted diff) +6 -0
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+#define __tag2 __attribute__((btf_type_tag("tag2")))
+
+struct btf_type_tag_test {
+       int __tag1 * __tag1 __tag2 *p;
+} g;
Quoted 1 line

Can we build the kernel with the latest clang and get __user in BTF ?

Not yet. The following are the steps:
1. land this patch set in the kernel
2. sync to libbpf repo.
3. pahole sync with libbpf repo, and pahole convert btf_type_tag in llvm to BTF
4. another kernel patch to define __user as

Quoted 2 lines
      __attribute__((btf_type_tag("user")))

and then we will get __user in vmlinux BTF.

Makes sense. I was wondering whether clang can handle the whole kernel source code with
#define __user __attribute__((btf_type_tag("user"))) Steps 1,2,3 are necessary to make use of it, but step 4 can be tried out already?

#26 lore raw
Quoted 35 lines · Alexei Starovoitov
Quoted 23 lines · Yonghong Song
Quoted 19 lines · Alexei Starovoitov
Quoted 10 lines · Yonghong Song

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel() etc. to read the data.

(quoted diff) +6 -0
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+#define __tag2 __attribute__((btf_type_tag("tag2")))
+
+struct btf_type_tag_test {
+       int __tag1 * __tag1 __tag2 *p;
+} g;
Quoted 10 lines
Quoted 1 line

Can we build the kernel with the latest clang and get __user in BTF ?

Not yet. The following are the steps:
1. land this patch set in the kernel
2. sync to libbpf repo.
3. pahole sync with libbpf repo, and pahole convert btf_type_tag in llvm to BTF
4. another kernel patch to define __user as __attribute__((btf_type_tag("user")))
and then we will get __user in vmlinux BTF.

Quoted 5 lines

Makes sense. I was wondering whether clang can handle the whole kernel source code with
#define __user __attribute__((btf_type_tag("user"))) Steps 1,2,3 are necessary to make use of it, but step 4 can be tried out already?

Yes, you try clang -> vmlinux dwarf part of step 4 with the following kernel hack:

include/linux/compiler_types.h +1 -1
index 05ceb2e92b0e..30e199c30a53 100644
@@ -32,7 +32,7 @@ static inline void __chk_io_ptr(const volatile void __iomem *ptr) { }
 # ifdef STRUCTLEAK_PLUGIN
 #  define __user       __attribute__((user))
 # else
-#  define __user
+#  define __user       __attribute__((btf_type_tag("user")))
 # endif
 # define __iomem
 # define __percpu

[[email protected] ~/work/bpf-next]

#27 lore raw
Quoted 61 lines · Yonghong Song
Quoted 35 lines · Alexei Starovoitov
Quoted 23 lines · Yonghong Song
Quoted 19 lines · Alexei Starovoitov
Quoted 10 lines · Yonghong Song

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel() etc. to read the data.

(quoted diff) +6 -0
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+#define __tag2 __attribute__((btf_type_tag("tag2")))
+
+struct btf_type_tag_test {
+       int __tag1 * __tag1 __tag2 *p;
+} g;
Quoted 10 lines
Quoted 1 line

Can we build the kernel with the latest clang and get __user in BTF ?

Not yet. The following are the steps:
1. land this patch set in the kernel
2. sync to libbpf repo.
3. pahole sync with libbpf repo, and pahole convert btf_type_tag in llvm to BTF
4. another kernel patch to define __user as __attribute__((btf_type_tag("user")))
and then we will get __user in vmlinux BTF.

Quoted 5 lines

Makes sense. I was wondering whether clang can handle the whole kernel source code with
#define __user __attribute__((btf_type_tag("user"))) Steps 1,2,3 are necessary to make use of it, but step 4 can be tried out already?

Yes, you try clang -> vmlinux dwarf part of step 4 with the following kernel hack:

include/linux/compiler_types.h +1 -1
index 05ceb2e92b0e..30e199c30a53 100644
@@ -32,7 +32,7 @@ static inline void __chk_io_ptr(const volatile void
 __iomem *ptr) { }
  # ifdef STRUCTLEAK_PLUGIN
  #  define __user       __attribute__((user))
  # else
-#  define __user
+#  define __user       __attribute__((btf_type_tag("user")))
  # endif
  # define __iomem
Quoted 1 line
  # define __percpu

I've tried the latest LLVM with the above diff and it seems to work!

$ llvm-dwarfdump kernel/bpf/built-in.a |grep -3 btf_type_tag|head
0x00003ace:   DW_TAG_pointer_type

0x00003acf: DW_TAG_LLVM_annotation

                  DW_AT_name    ("btf_type_tag")
                  DW_AT_const_value    ("user")

Nice!
Didn't notice any warnings. Great.

Acked-by on v1 1/10
#2 lore raw

Re: [PATCH bpf-next 01/10] bpf: Support BTF_KIND_TYPE_TAG for btf_type_tag attributes

In reply to Yonghong Song
Quoted 10 lines · Yonghong Song

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel()

probably meant to write bpf_probe_read_user()?

LGTM, otherwise.

Quoted 18 lines

etc. to read the data.

BTF_KIND_TYPE_TAG may also useful for other tracing facility where instead of to require user to specify kernel/user address type, the kernel can detect it by itself with btf.

[1] https://reviews.llvm.org/D111199
[2] https://reviews.llvm.org/D113222
[3] https://reviews.llvm.org/D113496

---
 include/uapi/linux/btf.h       |  3 ++-
 kernel/bpf/btf.c               | 14 +++++++++++++-
 tools/include/uapi/linux/btf.h |  3 ++-
 3 files changed, 17 insertions(+), 3 deletions(-)

[...]

Acked-by on v1 2/10
#5 lore raw

Re: [PATCH bpf-next 02/10] libbpf: Support BTF_KIND_TYPE_TAG

In reply to Yonghong Song
Quoted 5 lines · Yonghong Song

Add libbpf support for BTF_KIND_TYPE_TAG.

---

Few nits below.

Quoted 37 lines
 tools/lib/bpf/btf.c             | 23 +++++++++++++++++++++++
 tools/lib/bpf/btf.h             |  9 ++++++++-
 tools/lib/bpf/btf_dump.c        |  9 +++++++++
 tools/lib/bpf/libbpf.c          | 31 ++++++++++++++++++++++++++++++-
 tools/lib/bpf/libbpf.map        |  1 +
 tools/lib/bpf/libbpf_internal.h |  2 ++
 6 files changed, 73 insertions(+), 2 deletions(-)
tools/lib/bpf/btf.c +3 -0
index 7e4c5586bd87..4d9883bef330 100644
@@ -299,6 +299,7 @@ static int btf_type_size(const struct btf_type *t)
        case BTF_KIND_TYPEDEF:
        case BTF_KIND_FUNC:
        case BTF_KIND_FLOAT:
+       case BTF_KIND_TYPE_TAG:
                return base_size;
        case BTF_KIND_INT:
                return base_size + sizeof(__u32);
@@ -349,6 +350,7 @@ static int btf_bswap_type_rest(struct btf_type *t)
        case BTF_KIND_TYPEDEF:
        case BTF_KIND_FUNC:
        case BTF_KIND_FLOAT:
+       case BTF_KIND_TYPE_TAG:
                return 0;
        case BTF_KIND_INT:
                *(__u32 *)(t + 1) = bswap_32(*(__u32 *)(t + 1));
@@ -649,6 +651,7 @@ int btf__align_of(const struct btf *btf, __u32 id)
        case BTF_KIND_VOLATILE:
        case BTF_KIND_CONST:
        case BTF_KIND_RESTRICT:
+       case BTF_KIND_TYPE_TAG:
                return btf__align_of(btf, t->type);
        case BTF_KIND_ARRAY:
                return btf__align_of(btf, btf_array(t)->type);

tools/lib/bpf/btf.c int btf__add_restrict(struct btf *btf, int ref_type_id) · line 2242

Quoted 5 lines
tools/lib/bpf/btf.c +2 -0
@@ -2235,6 +2238,22 @@ int btf__add_restrict(struct btf *btf, int ref_type_id)
        return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id);
 }
 
+/*
+ * Append new BTF_KIND_TYPE_TAGtype with:

missing space

tools/lib/bpf/btf.c int btf__add_restrict(struct btf *btf, int ref_type_id) · line 2243

Quoted 1 line
tools/lib/bpf/btf.c +1 -0
+ *   - *value*, non-empty/non-NULL name;

s/name/tag value/ ? It's not just a name, some tags can have "parameters", right?

Quoted 13 lines
tools/lib/bpf/btf.c +13 -0
+ *   - *ref_type_id* - referenced type ID, it might not exist yet;
+ * Returns:
+ *   - >0, type ID of newly added BTF type;
+ *   - <0, on error.
+ */
+int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id)
+{
+       if (!value|| !value[0])
+               return libbpf_err(-EINVAL);
+
+       return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id);
+}
+

[...]

Acked-by on v1 4/10
#10 lore raw

Re: [PATCH bpf-next 04/10] selftests/bpf: Test libbpf API function btf__add_type_tag()

In reply to Yonghong Song
Quoted 5 lines · Yonghong Song

Add unit tests for btf__add_type_tag().

---

Quoted 4 lines
 tools/testing/selftests/bpf/btf_helpers.c     |  4 +-
 .../selftests/bpf/prog_tests/btf_write.c      | 67 +++++++++++--------
 2 files changed, 43 insertions(+), 28 deletions(-)

[...]

Acked-by on v1 5/10
#12 lore raw

Re: [PATCH bpf-next 05/10] selftests/bpf: Add BTF_KIND_TYPE_TAG unit tests

In reply to Yonghong Song
Quoted 5 lines · Yonghong Song

Add BTF_KIND_TYPE_TAG unit tests.

---

LGTM.

Quoted 4 lines
 tools/testing/selftests/bpf/prog_tests/btf.c | 18 ++++++++++++++++++
 tools/testing/selftests/bpf/test_btf.h       |  3 +++
 2 files changed, 21 insertions(+)

[...]

#14 lore raw

Re: [PATCH bpf-next 06/10] selftests/bpf: Test BTF_KIND_DECL_TAG for deduplication

In reply to Yonghong Song
Quoted 63 lines · Yonghong Song
---
 tools/testing/selftests/bpf/prog_tests/btf.c | 46 ++++++++++++++++++--
 1 file changed, 42 insertions(+), 4 deletions(-)
tools/testing/selftests/bpf/prog_tests/btf.c +17 -4
index ebd0ead5f4bc..91b19c41729f 100644
@@ -6889,15 +6889,16 @@ const struct btf_dedup_test dedup_tests[] = {
                        BTF_RESTRICT_ENC(8),                                            /* [11] restrict */
                        BTF_FUNC_PROTO_ENC(1, 2),                                       /* [12] func_proto */
                                BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
-                               BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
+                               BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
                        BTF_FUNC_ENC(NAME_TBD, 12),                                     /* [13] func */
                        BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),                                /* [14] float */
                        BTF_DECL_TAG_ENC(NAME_TBD, 13, -1),                             /* [15] decl_tag */
                        BTF_DECL_TAG_ENC(NAME_TBD, 13, 1),                              /* [16] decl_tag */
                        BTF_DECL_TAG_ENC(NAME_TBD, 7, -1),                              /* [17] decl_tag */
+                       BTF_TYPE_TAG_ENC(NAME_TBD, 8),                                  /* [18] type_tag */
                        BTF_END_RAW,
                },
-               BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q"),
+               BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R"),
        },
        .expect = {
                .raw_types = {
@@ -6918,15 +6919,16 @@ const struct btf_dedup_test dedup_tests[] = {
                        BTF_RESTRICT_ENC(8),                                            /* [11] restrict */
                        BTF_FUNC_PROTO_ENC(1, 2),                                       /* [12] func_proto */
                                BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
-                               BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
+                               BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
                        BTF_FUNC_ENC(NAME_TBD, 12),                                     /* [13] func */
                        BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),                                /* [14] float */
                        BTF_DECL_TAG_ENC(NAME_TBD, 13, -1),                             /* [15] decl_tag */
                        BTF_DECL_TAG_ENC(NAME_TBD, 13, 1),                              /* [16] decl_tag */
                        BTF_DECL_TAG_ENC(NAME_TBD, 7, -1),                              /* [17] decl_tag */
+                       BTF_TYPE_TAG_ENC(NAME_TBD, 8),                                  /* [18] type_tag */
                        BTF_END_RAW,
                },
-               BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q"),
+               BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R"),
        },
        .opts = {
                .dont_resolve_fwds = false,
@@ -7254,6 +7256,42 @@ const struct btf_dedup_test dedup_tests[] = {
                .dont_resolve_fwds = false,
        },
 },
+{
+       .descr = "dedup: btf_tag_type",
+       .input = {
+               .raw_types = {
+                       /* int */
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
+                       /* tag: tag1, tag2 */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),               /* [2] */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),               /* [3] */
+                       BTF_PTR_ENC(3),                                 /* [4] */
+                       /* tag: tag1, tag2 */

tools/testing/selftests/bpf/prog_tests/btf.c const struct btf_dedup_test dedup_tests[] = { · line 7279

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/btf.c +10 -0
+                       BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),               /* [5] */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(2), 5),               /* [6] */
+                       BTF_PTR_ENC(6),                                 /* [7] */
+                       /* tag: tag1 */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),               /* [8] */
+                       BTF_PTR_ENC(8),                                 /* [9] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0tag1\0tag2"),
+       },

Can you please add a test for two more situations:

First, like this:

tag1 -> tag2 -> int
tag1 -> int

tag1's shouldn't be deduped

Second, like this

tag1 -> tag2 -> int
tag2 -> tag1 -> int

Nothing gets deduped.

Actually, also third situation:

tag1 -> int
tag1 -> long

Nothing gets deduped.

That will document expected behavior.

Thanks.

Quoted 21 lines
tools/testing/selftests/bpf/prog_tests/btf.c +15 -1
+       .expect = {
+               .raw_types = {
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),               /* [2] */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),               /* [3] */
+                       BTF_PTR_ENC(3),                                 /* [4] */
+                       BTF_PTR_ENC(2),                                 /* [5] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0tag1\0tag2"),
+       },
+       .opts = {
+               .dont_resolve_fwds = false,
+       },
+},
 
 };
 
--

2.30.2

Acked-by on v1 7/10
#17 lore raw

Re: [PATCH bpf-next 07/10] selftests/bpf: Rename progs/tag.c to progs/btf_decl_tag.c

In reply to Yonghong Song
Quoted 9 lines · Yonghong Song

Rename progs/tag.c to progs/btf_decl_tag.c so we can introduce progs/btf_type_tag.c in the next patch.

Also create a subtest for btf_decl_tag in prog_tests/btf_tag.c so we can introduce btf_type_tag subtest in the next patch.

---

Quoted 5 lines
 .../selftests/bpf/prog_tests/btf_tag.c        | 20 ++++++++++++-------
 .../bpf/progs/{tag.c => btf_decl_tag.c}       |  0
 2 files changed, 13 insertions(+), 7 deletions(-)
 rename tools/testing/selftests/bpf/progs/{tag.c => btf_decl_tag.c} (100%)

[...]

#19 lore raw

Re: [PATCH bpf-next 08/10] selftests/bpf: Add a C test for btf_type_tag

In reply to Yonghong Song
Quoted 4 lines · Yonghong Song

For the C test, compiler the kernel and selftest with clang compiler by adding LLVM=1 to the make command line since btf_type_tag is only supported by clang compiler now.

I'm confused. Why does kernel compilation matter at all? And then for progs/*.c we always compile with Clang anyway (except for unused gcc_bpf flavor, but that's separate). So what am I missing?

Quoted 82 lines

The following is the key btf_type_tag usage:
#define __tag1 __attribute__((btf_type_tag("tag1"))) #define __tag2 __attribute__((btf_type_tag("tag2")))

  struct btf_type_tag_test {
       int __tag1 * __tag1 __tag2 *p;

} g;

The bpftool raw dump with related types:
[4] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED
[11] STRUCT 'btf_type_tag_test' size=8 vlen=1

          'p' type_id=14 bits_offset=0

[12] TYPE_TAG 'tag1' type_id=16
[13] TYPE_TAG 'tag2' type_id=12
[14] PTR '(anon)' type_id=13
[15] TYPE_TAG 'tag1' type_id=4
[16] PTR '(anon)' type_id=15
[17] VAR 'g' type_id=11, linkage=global

With format C dump, we have

  struct btf_type_tag_test {
        int __attribute__((btf_type_tag("tag1"))) * __attribute__((btf_type_tag("tag1"))) __attribute__((btf_type_tag("tag2"))) *p;

};
The result C code is identical to the original definition except macro's are gone.

---
 .../selftests/bpf/prog_tests/btf_tag.c        | 24 +++++++++++++++
 .../selftests/bpf/progs/btf_type_tag.c        | 29 +++++++++++++++++++
 2 files changed, 53 insertions(+)
 create mode 100644 tools/testing/selftests/bpf/progs/btf_type_tag.c
tools/testing/selftests/bpf/prog_tests/btf_tag.c +24 -0
index d15cc7a88182..88d63e23e35f 100644
@@ -3,6 +3,12 @@
 #include <test_progs.h>
 #include "btf_decl_tag.skel.h"
 
+/* struct btf_type_tag_test is referenced in btf_type_tag.skel.h */
+struct btf_type_tag_test {
+        int **p;
+};
+#include "btf_type_tag.skel.h"
+
 static void test_btf_decl_tag(void)
 {
        struct btf_decl_tag *skel;
@@ -19,8 +25,26 @@ static void test_btf_decl_tag(void)
        btf_decl_tag__destroy(skel);
 }
 
+static void test_btf_type_tag(void)
+{
+       struct btf_type_tag *skel;
+
+       skel = btf_type_tag__open_and_load();
+       if (!ASSERT_OK_PTR(skel, "btf_type_tag"))
+               return;
+
+       if (skel->rodata->skip_tests) {
+               printf("%s:SKIP: btf_type_tag attribute not supported", __func__);
+               test__skip();
+       }
+
+       btf_type_tag__destroy(skel);
+}
+
 void test_btf_tag(void)
 {
        if (test__start_subtest("btf_decl_tag"))
                test_btf_decl_tag();
+       if (test__start_subtest("btf_type_tag"))
+               test_btf_type_tag();
 }
tools/testing/selftests/bpf/progs/btf_type_tag.c new file +0 -0
new file mode 100644
index 000000000000..0e18c777862c

tools/testing/selftests/bpf/progs/btf_type_tag.c line 9

Quoted 9 lines
tools/testing/selftests/bpf/progs/btf_type_tag.c new file +9 -0
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2021 Facebook */
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
+#include <bpf/bpf_tracing.h>
+
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif

is this necessary, doesn't the minimum Clang/GCC version that we support have __has_attribute already?

Quoted 23 lines
tools/testing/selftests/bpf/progs/btf_type_tag.c new file +20 -1
+
+#if __has_attribute(btf_type_tag)
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+#define __tag2 __attribute__((btf_type_tag("tag2")))
+volatile const bool skip_tests = false;
+#else
+#define __tag1
+#define __tag2
+volatile const bool skip_tests = true;
+#endif
+
+struct btf_type_tag_test {
+       int __tag1 * __tag1 __tag2 *p;
+} g;
+
+SEC("fentry/bpf_fentry_test1")
+int BPF_PROG(sub, int x)
+{
+  return 0;
+}
--

2.30.2

Acked-by on v1 9/10
#22 lore raw

Re: [PATCH bpf-next 09/10] selftests/bpf: Clarify llvm dependency with btf_tag selftest

In reply to Yonghong Song
Quoted 6 lines · Yonghong Song

btf_tag selftest needs certain llvm versions (>= llvm14). Make it clear in the selftests README.rst file.

---

Quoted 3 lines
 tools/testing/selftests/bpf/README.rst | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

[...]

#3 lore raw

Re: [PATCH bpf-next 01/10] bpf: Support BTF_KIND_TYPE_TAG for btf_type_tag attributes

In reply to Andrii Nakryiko
Quoted 6 lines · Andrii Nakryiko
Quoted 5 lines · Yonghong Song

LLVM patches ([1] for clang, [2] and [3] for BPF backend) added support for btf_type_tag attributes. This patch added support for the kernel.

Quoted 7 lines
Quoted 5 lines

The main motivation for btf_type_tag is to bring kernel annotations __user, __rcu etc. to btf. With such information available in btf, bpf verifier can detect mis-usages and reject the program. For example, for __user tagged pointer, developers can then use proper helper like bpf_probe_read_kernel()

probably meant to write bpf_probe_read_user()?

Oh, yes, a typo. should be bpf_probe_read_user().

Quoted 26 lines

LGTM, otherwise.

Quoted 18 lines

etc. to read the data.

BTF_KIND_TYPE_TAG may also useful for other tracing facility where instead of to require user to specify kernel/user address type, the kernel can detect it by itself with btf.

   [1] https://reviews.llvm.org/D111199
   [2] https://reviews.llvm.org/D113222
   [3] https://reviews.llvm.org/D113496
---
  include/uapi/linux/btf.h       |  3 ++-
  kernel/bpf/btf.c               | 14 +++++++++++++-
  tools/include/uapi/linux/btf.h |  3 ++-
  3 files changed, 17 insertions(+), 3 deletions(-)

[...]

#6 lore raw

Re: [PATCH bpf-next 02/10] libbpf: Support BTF_KIND_TYPE_TAG

In reply to Andrii Nakryiko
Quoted 51 lines · Andrii Nakryiko
Quoted 5 lines · Yonghong Song

Add libbpf support for BTF_KIND_TYPE_TAG.

---

Few nits below.

Quoted 40 lines
  tools/lib/bpf/btf.c             | 23 +++++++++++++++++++++++
  tools/lib/bpf/btf.h             |  9 ++++++++-
  tools/lib/bpf/btf_dump.c        |  9 +++++++++
  tools/lib/bpf/libbpf.c          | 31 ++++++++++++++++++++++++++++++-
  tools/lib/bpf/libbpf.map        |  1 +
  tools/lib/bpf/libbpf_internal.h |  2 ++
  6 files changed, 73 insertions(+), 2 deletions(-)
tools/lib/bpf/btf.c +3 -0
index 7e4c5586bd87..4d9883bef330 100644
@@ -299,6 +299,7 @@ static int btf_type_size(const struct btf_type *t)
         case BTF_KIND_TYPEDEF:
         case BTF_KIND_FUNC:
         case BTF_KIND_FLOAT:
+       case BTF_KIND_TYPE_TAG:
                 return base_size;
         case BTF_KIND_INT:
                 return base_size + sizeof(__u32);
@@ -349,6 +350,7 @@ static int btf_bswap_type_rest(struct btf_type *t)
         case BTF_KIND_TYPEDEF:
         case BTF_KIND_FUNC:
         case BTF_KIND_FLOAT:
+       case BTF_KIND_TYPE_TAG:
                 return 0;
         case BTF_KIND_INT:
                 *(__u32 *)(t + 1) = bswap_32(*(__u32 *)(t + 1));
@@ -649,6 +651,7 @@ int btf__align_of(const struct btf *btf, __u32 id)
         case BTF_KIND_VOLATILE:
         case BTF_KIND_CONST:
         case BTF_KIND_RESTRICT:
+       case BTF_KIND_TYPE_TAG:
                 return btf__align_of(btf, t->type);
         case BTF_KIND_ARRAY:
                 return btf__align_of(btf, btf_array(t)->type);
@@ -2235,6 +2238,22 @@ int btf__add_restrict(struct btf *btf, int ref_type_id)
         return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id);
  }
 
Quoted 4 lines

tools/lib/bpf/btf.c int btf__add_restrict(struct btf *btf, int ref_type_id) · line 2242

Quoted 2 lines
tools/lib/bpf/btf.c +2 -0
+/*
+ * Append new BTF_KIND_TYPE_TAGtype with:

missing space

Ack.

Quoted 5 lines

tools/lib/bpf/btf.c int btf__add_restrict(struct btf *btf, int ref_type_id) · line 2243

Quoted 2 lines
tools/lib/bpf/btf.c +1 -0
+ *   - *value*, non-empty/non-NULL name;

s/name/tag value/ ? It's not just a name, some tags can have "parameters", right?

copy-paste issue (I copied from btf__add_typedef). Yes, tag value is the correct terminology.

Quoted 17 lines
Quoted 14 lines
tools/lib/bpf/btf.c +13 -0
+ *   - *ref_type_id* - referenced type ID, it might not exist yet;
+ * Returns:
+ *   - >0, type ID of newly added BTF type;
+ *   - <0, on error.
+ */
+int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id)
+{
+       if (!value|| !value[0])
+               return libbpf_err(-EINVAL);
+
+       return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id);
+}
+

[...]

#15 lore raw

Re: [PATCH bpf-next 06/10] selftests/bpf: Test BTF_KIND_DECL_TAG for deduplication

In reply to Andrii Nakryiko
Quoted 91 lines · Andrii Nakryiko
Quoted 63 lines · Yonghong Song
---
  tools/testing/selftests/bpf/prog_tests/btf.c | 46 ++++++++++++++++++--
  1 file changed, 42 insertions(+), 4 deletions(-)
tools/testing/selftests/bpf/prog_tests/btf.c +17 -4
index ebd0ead5f4bc..91b19c41729f 100644
@@ -6889,15 +6889,16 @@ const struct btf_dedup_test dedup_tests[] = {
                         BTF_RESTRICT_ENC(8),                                            /* [11] restrict */
                         BTF_FUNC_PROTO_ENC(1, 2),                                       /* [12] func_proto */
                                 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
-                               BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
+                               BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
                         BTF_FUNC_ENC(NAME_TBD, 12),                                     /* [13] func */
                         BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),                                /* [14] float */
                         BTF_DECL_TAG_ENC(NAME_TBD, 13, -1),                             /* [15] decl_tag */
                         BTF_DECL_TAG_ENC(NAME_TBD, 13, 1),                              /* [16] decl_tag */
                         BTF_DECL_TAG_ENC(NAME_TBD, 7, -1),                              /* [17] decl_tag */
+                       BTF_TYPE_TAG_ENC(NAME_TBD, 8),                                  /* [18] type_tag */
                         BTF_END_RAW,
                 },
-               BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q"),
+               BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R"),
         },
         .expect = {
                 .raw_types = {
@@ -6918,15 +6919,16 @@ const struct btf_dedup_test dedup_tests[] = {
                         BTF_RESTRICT_ENC(8),                                            /* [11] restrict */
                         BTF_FUNC_PROTO_ENC(1, 2),                                       /* [12] func_proto */
                                 BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 1),
-                               BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 8),
+                               BTF_FUNC_PROTO_ARG_ENC(NAME_TBD, 18),
                         BTF_FUNC_ENC(NAME_TBD, 12),                                     /* [13] func */
                         BTF_TYPE_FLOAT_ENC(NAME_TBD, 2),                                /* [14] float */
                         BTF_DECL_TAG_ENC(NAME_TBD, 13, -1),                             /* [15] decl_tag */
                         BTF_DECL_TAG_ENC(NAME_TBD, 13, 1),                              /* [16] decl_tag */
                         BTF_DECL_TAG_ENC(NAME_TBD, 7, -1),                              /* [17] decl_tag */
+                       BTF_TYPE_TAG_ENC(NAME_TBD, 8),                                  /* [18] type_tag */
                         BTF_END_RAW,
                 },
-               BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q"),
+               BTF_STR_SEC("\0A\0B\0C\0D\0E\0F\0G\0H\0I\0J\0K\0L\0M\0N\0O\0P\0Q\0R"),
         },
         .opts = {
                 .dont_resolve_fwds = false,
@@ -7254,6 +7256,42 @@ const struct btf_dedup_test dedup_tests[] = {
                 .dont_resolve_fwds = false,
         },
  },
+{
+       .descr = "dedup: btf_tag_type",
+       .input = {
+               .raw_types = {
+                       /* int */
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
+                       /* tag: tag1, tag2 */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),               /* [2] */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),               /* [3] */
+                       BTF_PTR_ENC(3),                                 /* [4] */
+                       /* tag: tag1, tag2 */

tools/testing/selftests/bpf/prog_tests/btf.c const struct btf_dedup_test dedup_tests[] = { · line 7279

Quoted 10 lines
tools/testing/selftests/bpf/prog_tests/btf.c +10 -0
+                       BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),               /* [5] */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(2), 5),               /* [6] */
+                       BTF_PTR_ENC(6),                                 /* [7] */
+                       /* tag: tag1 */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),               /* [8] */
+                       BTF_PTR_ENC(8),                                 /* [9] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0tag1\0tag2"),
+       },

Can you please add a test for two more situations:

First, like this:

tag1 -> tag2 -> int
tag1 -> int

tag1's shouldn't be deduped

Second, like this

tag1 -> tag2 -> int
tag2 -> tag1 -> int

Nothing gets deduped.

Quoted 8 lines

Actually, also third situation:

tag1 -> int
tag1 -> long

Nothing gets deduped.

That will document expected behavior.

Will do.

Quoted 24 lines

Thanks.

Quoted 21 lines
tools/testing/selftests/bpf/prog_tests/btf.c +15 -1
+       .expect = {
+               .raw_types = {
+                       BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(1), 1),               /* [2] */
+                       BTF_TYPE_TAG_ENC(NAME_NTH(2), 2),               /* [3] */
+                       BTF_PTR_ENC(3),                                 /* [4] */
+                       BTF_PTR_ENC(2),                                 /* [5] */
+                       BTF_END_RAW,
+               },
+               BTF_STR_SEC("\0tag1\0tag2"),
+       },
+       .opts = {
+               .dont_resolve_fwds = false,
+       },
+},
 
  };
 
--

2.30.2

#20 lore raw

Re: [PATCH bpf-next 08/10] selftests/bpf: Add a C test for btf_type_tag

In reply to Andrii Nakryiko
Quoted 9 lines · Andrii Nakryiko
Quoted 4 lines · Yonghong Song

For the C test, compiler the kernel and selftest with clang compiler by adding LLVM=1 to the make command line since btf_type_tag is only supported by clang compiler now.

I'm confused. Why does kernel compilation matter at all? And then for progs/*.c we always compile with Clang anyway (except for unused gcc_bpf flavor, but that's separate). So what am I missing?

This patch set is tested with additional change with
#define __user __attribute__((btf_type_tag("user")))
plus pahole hack so I can ensure kernel implementation is okay with vmlinux + btf_type_tag.
LLVM=1 is needed to test this.

But just for this patch set, you are right, LLVM=1 is not needed. Will remove it.

Quoted 87 lines
Quoted 87 lines

The following is the key btf_type_tag usage:

   #define __tag1 __attribute__((btf_type_tag("tag1")))
   #define __tag2 __attribute__((btf_type_tag("tag2")))
   struct btf_type_tag_test {
        int __tag1 * __tag1 __tag2 *p;
   } g;

The bpftool raw dump with related types:

   [4] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED
   [11] STRUCT 'btf_type_tag_test' size=8 vlen=1
           'p' type_id=14 bits_offset=0
   [12] TYPE_TAG 'tag1' type_id=16
   [13] TYPE_TAG 'tag2' type_id=12
   [14] PTR '(anon)' type_id=13
   [15] TYPE_TAG 'tag1' type_id=4
   [16] PTR '(anon)' type_id=15
   [17] VAR 'g' type_id=11, linkage=global

With format C dump, we have

   struct btf_type_tag_test {
         int __attribute__((btf_type_tag("tag1"))) * __attribute__((btf_type_tag("tag1"))) __attribute__((btf_type_tag("tag2"))) *p;

};
The result C code is identical to the original definition except macro's are gone.

---
  .../selftests/bpf/prog_tests/btf_tag.c        | 24 +++++++++++++++
  .../selftests/bpf/progs/btf_type_tag.c        | 29 +++++++++++++++++++
  2 files changed, 53 insertions(+)

create mode 100644 tools/testing/selftests/bpf/progs/btf_type_tag.c

tools/testing/selftests/bpf/prog_tests/btf_tag.c +24 -0
index d15cc7a88182..88d63e23e35f 100644
@@ -3,6 +3,12 @@
  #include <test_progs.h>
  #include "btf_decl_tag.skel.h"
 
+/* struct btf_type_tag_test is referenced in btf_type_tag.skel.h */
+struct btf_type_tag_test {
+        int **p;
+};
+#include "btf_type_tag.skel.h"
+
  static void test_btf_decl_tag(void)
  {
         struct btf_decl_tag *skel;
@@ -19,8 +25,26 @@ static void test_btf_decl_tag(void)
         btf_decl_tag__destroy(skel);
  }
 
+static void test_btf_type_tag(void)
+{
+       struct btf_type_tag *skel;
+
+       skel = btf_type_tag__open_and_load();
+       if (!ASSERT_OK_PTR(skel, "btf_type_tag"))
+               return;
+
+       if (skel->rodata->skip_tests) {
+               printf("%s:SKIP: btf_type_tag attribute not supported", __func__);
+               test__skip();
+       }
+
+       btf_type_tag__destroy(skel);
+}
+
  void test_btf_tag(void)
  {
         if (test__start_subtest("btf_decl_tag"))
                 test_btf_decl_tag();
+       if (test__start_subtest("btf_type_tag"))
+               test_btf_type_tag();
  }
tools/testing/selftests/bpf/progs/btf_type_tag.c new file +4 -0
new file mode 100644
index 000000000000..0e18c777862c
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2021 Facebook */
+#include "vmlinux.h"
+#include <bpf/bpf_helpers.h>
Quoted 8 lines

tools/testing/selftests/bpf/progs/btf_type_tag.c line 9

Quoted 5 lines
tools/testing/selftests/bpf/progs/btf_type_tag.c new file +5 -0
+#include <bpf/bpf_tracing.h>
+
+#ifndef __has_attribute
+#define __has_attribute(x) 0
+#endif

is this necessary, doesn't the minimum Clang/GCC version that we support have __has_attribute already?

No. It is not necessary. I just copy-pasted code from
https://clang.llvm.org/docs/LanguageExtensions.html#has-attribute

We recommend clang >= 11 for kernel. So above is indeed not needed.

Quoted 24 lines
Quoted 24 lines
tools/testing/selftests/bpf/progs/btf_type_tag.c new file +20 -1
+
+#if __has_attribute(btf_type_tag)
+#define __tag1 __attribute__((btf_type_tag("tag1")))
+#define __tag2 __attribute__((btf_type_tag("tag2")))
+volatile const bool skip_tests = false;
+#else
+#define __tag1
+#define __tag2
+volatile const bool skip_tests = true;
+#endif
+
+struct btf_type_tag_test {
+       int __tag1 * __tag1 __tag2 *p;
+} g;
+
+SEC("fentry/bpf_fentry_test1")
+int BPF_PROG(sub, int x)
+{
+  return 0;
+}
--

2.30.2