From patchwork Fri Feb 7 02:14:40 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ihor Solodrai X-Patchwork-Id: 13964238 Received: from out-174.mta1.migadu.com (out-174.mta1.migadu.com [95.215.58.174]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id B25B631A89 for ; Fri, 7 Feb 2025 02:15:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=95.215.58.174 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738894502; cv=none; b=ZyUcEslCqRoyWG1qlfxhfY8XOTW4SmOSt0/xzvdZ08abiSSjkT6W/8RL0ZSBSGw0Ooi/M2Nl3i/5McOm5U+tJgePH4Qc/xyoZDZSRSqudFBfetGuWKijTEsI77zfvsWuHGn8gbnaEF/BjizLcMbcHFYtWkimaDWaiM3x4ccmM08= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738894502; c=relaxed/simple; bh=hTZK4fJFV4wz4mxSVNhzk+nVPLCOxAuXpL4jlX/Hrt8=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=eOBJfVRcyZ1AnjwaMl2i3Y4NGR2ScaBBEkVkPCyuOiye3RBKaoOiX94aLVJKqfEjWMXNRTlAzyjcrBjIqP1XGHab9F+15DUq1zUYMpcvDOl2mEedSp2oAx7Z83to4Dq6Er7HkuQNEZE3Gc8IJfavORQmb9CLOdcbwFymAbJdDcE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=EjFtDuS7; arc=none smtp.client-ip=95.215.58.174 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="EjFtDuS7" X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1738894498; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=JmWw1aCGijLdPWWGvxKTFfBiabzcN8HCR+SwKE3cTF4=; b=EjFtDuS7TDkKVXn+wrE27jRfP1t33baWwfKRaOv1C7NHArKrJepFaDuZsJRpdOa07GMUmb vFfAUt1B0emJ7IEyfm6ywLARz3Y4R2TkcawHYYWY6+GpcBPfe1FKn7/KVyLDZ/SFiptd71 moaFS76MLotwEaovnCnugADBJlZ/DIM= From: Ihor Solodrai To: dwarves@vger.kernel.org, bpf@vger.kernel.org Cc: acme@kernel.org, alan.maguire@oracle.com, ast@kernel.org, andrii@kernel.org, eddyz87@gmail.com, mykolal@fb.com, kernel-team@meta.com Subject: [PATCH dwarves 1/3] btf_encoder: collect kfuncs info in btf_encoder__new Date: Thu, 6 Feb 2025 18:14:40 -0800 Message-ID: <20250207021442.155703-2-ihor.solodrai@linux.dev> In-Reply-To: <20250207021442.155703-1-ihor.solodrai@linux.dev> References: <20250207021442.155703-1-ihor.solodrai@linux.dev> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Migadu-Flow: FLOW_OUT From: Ihor Solodrai btf_encoder__tag_kfuncs() is a post-processing step of BTF encoding, executed right before BTF is deduped and dumped to the output. Split btf_encoder__tag_kfuncs() routine in two parts: * btf_encoder__collect_kfuncs() * btf_encoder__tag_kfuncs() btf_encoder__collect_kfuncs() reads the .BTF_ids section of the ELF, collecting kfunc information into a list of kfunc_info structs in the btf_encoder. It is executed in btf_encoder__new() when tag_kfuncs flag is set. This way kfunc information is available during entire lifetime of the btf_encoder. btf_encoder__tag_kfuncs() is basically the same: collect BTF functions, and then for each kfunc find and tag correspoding BTF func. Except now kfunc information is not collected in-place, but is simply read from the btf_encoder. Signed-off-by: Ihor Solodrai --- btf_encoder.c | 89 +++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 68 insertions(+), 21 deletions(-) diff --git a/btf_encoder.c b/btf_encoder.c index 511c1ea..e9f4baf 100644 --- a/btf_encoder.c +++ b/btf_encoder.c @@ -89,6 +89,7 @@ struct elf_function { const char *name; char *alias; size_t prefixlen; + bool kfunc; }; struct elf_secinfo { @@ -100,6 +101,13 @@ struct elf_secinfo { struct gobuffer secinfo; }; +struct kfunc_info { + struct list_head node; + uint32_t id; + uint32_t flags; + const char* name; +}; + struct elf_functions { struct list_head node; /* for elf_functions_list */ Elf *elf; /* source ELF */ @@ -143,6 +151,7 @@ struct btf_encoder { * so we have to store elf_functions tables per ELF. */ struct list_head elf_functions_list; + struct list_head kfuncs; /* list of kfunc_info */ }; struct btf_func { @@ -1842,9 +1851,9 @@ static int btf__add_kfunc_decl_tag(struct btf *btf, const char *tag, __u32 id, c return 0; } -static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, struct gobuffer *funcs, const char *kfunc, __u32 flags) +static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, struct gobuffer *funcs, const struct kfunc_info *kfunc) { - struct btf_func key = { .name = kfunc }; + struct btf_func key = { .name = kfunc->name }; struct btf *btf = encoder->btf; struct btf_func *target; const void *base; @@ -1855,7 +1864,7 @@ static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, struct gobuffer * cnt = gobuffer__nr_entries(funcs); target = bsearch(&key, base, cnt, sizeof(key), btf_func_cmp); if (!target) { - fprintf(stderr, "%s: failed to find kfunc '%s' in BTF\n", __func__, kfunc); + fprintf(stderr, "%s: failed to find kfunc '%s' in BTF\n", __func__, kfunc->name); return -1; } @@ -1864,11 +1873,12 @@ static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, struct gobuffer * * We are ok to do this b/c we will later btf__dedup() to remove * any duplicates. */ - err = btf__add_kfunc_decl_tag(btf, BTF_KFUNC_TYPE_TAG, target->type_id, kfunc); + err = btf__add_kfunc_decl_tag(btf, BTF_KFUNC_TYPE_TAG, target->type_id, kfunc->name); if (err < 0) return err; - if (flags & KF_FASTCALL) { - err = btf__add_kfunc_decl_tag(btf, BTF_FASTCALL_TAG, target->type_id, kfunc); + + if (kfunc->flags & KF_FASTCALL) { + err = btf__add_kfunc_decl_tag(btf, BTF_FASTCALL_TAG, target->type_id, kfunc->name); if (err < 0) return err; } @@ -1876,11 +1886,10 @@ static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, struct gobuffer * return 0; } -static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder) +static int btf_encoder__collect_kfuncs(struct btf_encoder *encoder) { const char *filename = encoder->source_filename; struct gobuffer btf_kfunc_ranges = {}; - struct gobuffer btf_funcs = {}; Elf_Data *symbols = NULL; Elf_Data *idlist = NULL; Elf_Scn *symscn = NULL; @@ -1897,6 +1906,8 @@ static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder) int nr_syms; int i = 0; + INIT_LIST_HEAD(&encoder->kfuncs); + fd = open(filename, O_RDONLY); if (fd < 0) { fprintf(stderr, "Cannot open %s\n", filename); @@ -1977,12 +1988,6 @@ static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder) } nr_syms = shdr.sh_size / shdr.sh_entsize; - err = btf_encoder__collect_btf_funcs(encoder, &btf_funcs); - if (err) { - fprintf(stderr, "%s: failed to collect BTF funcs\n", __func__); - goto out; - } - /* First collect all kfunc set ranges. * * Note we choose not to sort these ranges and accept a linear @@ -2015,12 +2020,13 @@ static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder) for (i = 0; i < nr_syms; i++) { const struct btf_kfunc_set_range *ranges; const struct btf_id_and_flag *pair; + struct elf_function *elf_fn; + struct kfunc_info *kfunc; unsigned int ranges_cnt; char *func, *name; ptrdiff_t off; GElf_Sym sym; bool found; - int err; int j; if (!gelf_getsym(symbols, i, &sym)) { @@ -2061,18 +2067,26 @@ static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder) continue; } - err = btf_encoder__tag_kfunc(encoder, &btf_funcs, func, pair->flags); - if (err) { - fprintf(stderr, "%s: failed to tag kfunc '%s'\n", __func__, func); - free(func); + elf_fn = btf_encoder__find_function(encoder, func, 0); + free(func); + if (!elf_fn) + continue; + elf_fn->kfunc = true; + + kfunc = calloc(1, sizeof(*kfunc)); + if (!kfunc) { + fprintf(stderr, "%s: failed to allocate memory for kfunc info\n", __func__); + err = -ENOMEM; goto out; } - free(func); + kfunc->id = pair->id; + kfunc->flags = pair->flags; + kfunc->name = elf_fn->name; + list_add(&kfunc->node, &encoder->kfuncs); } err = 0; out: - __gobuffer__delete(&btf_funcs); __gobuffer__delete(&btf_kfunc_ranges); if (elf) elf_end(elf); @@ -2081,6 +2095,34 @@ out: return err; } +static int btf_encoder__tag_kfuncs(struct btf_encoder *encoder) +{ + struct gobuffer btf_funcs = {}; + int err; + + err = btf_encoder__collect_btf_funcs(encoder, &btf_funcs); + if (err) { + fprintf(stderr, "%s: failed to collect BTF funcs\n", __func__); + goto out; + } + + struct kfunc_info *kfunc, *tmp; + list_for_each_entry_safe(kfunc, tmp, &encoder->kfuncs, node) { + err = btf_encoder__tag_kfunc(encoder, &btf_funcs, kfunc); + if (err) { + fprintf(stderr, "%s: failed to tag kfunc '%s'\n", __func__, kfunc->name); + goto out; + } + list_del(&kfunc->node); + free(kfunc); + } + + err = 0; +out: + __gobuffer__delete(&btf_funcs); + return err; +} + int btf_encoder__encode(struct btf_encoder *encoder, struct conf_load *conf) { bool should_tag_kfuncs; @@ -2496,6 +2538,11 @@ struct btf_encoder *btf_encoder__new(struct cu *cu, const char *detached_filenam if (!found_percpu && encoder->verbose) printf("%s: '%s' doesn't have '%s' section\n", __func__, cu->filename, PERCPU_SECTION); + if (encoder->tag_kfuncs) { + if (btf_encoder__collect_kfuncs(encoder)) + goto out_delete; + } + if (encoder->verbose) printf("File %s:\n", cu->filename); } From patchwork Fri Feb 7 02:14:41 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ihor Solodrai X-Patchwork-Id: 13964239 Received: from out-173.mta1.migadu.com (out-173.mta1.migadu.com [95.215.58.173]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C6896154439 for ; Fri, 7 Feb 2025 02:15:02 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=95.215.58.173 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738894504; cv=none; b=nlq9BfLs+/5516hTGjCF8zM12kCXfjOKL7FY/JLY+0y2iu70mIMsYX3CRq73c9B1rZb7q4YpStjgYm18qujJJdaOiTYjrl6Y+FOfOlM9GbazTO+GiGUy9SXh1TA8hTaBTl0nN3vYFereSkvHEQLaTJSc7ZzO+9O1f5CzZxOGC3g= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738894504; c=relaxed/simple; bh=xH6JVxKXv02D9eBvNCN/2zADWeZazcaYrH3iv3ta4vc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=QcEoqC2jarcG1MDRxGxYlR5IlncdLp6KlXVUud64L02hDWcFV1hYXwpVdd1lzrxnbyUloHGJA7v7gfPfFLbowY2YpiSWUyF5+IGFtkHM57p5EUuSfh4litFzQvLWAVd0cgzJyBJ/npMJmz/h2nj4S1kukEWM01zVE34BK3mJ+Uw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=R5LECFlF; arc=none smtp.client-ip=95.215.58.173 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="R5LECFlF" X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1738894500; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=9MSiZyIbYtR+URtoCK7wRmnwe0Y1izHjUCMvMV44yoA=; b=R5LECFlFuh5y2CCUq/aQ9Hvd2hGHC52pKsJTAutt6e8MzXAW1g8p0YDaJMmMWL2I10Y/NM 0ZVZXOCk2h9Lb1FIsQ3CRDEqf67SD9b5A69Hei66AFRVJvZrIlEuU2zl9FgmonXhDpVxwj tlIjauQSQOuMak00MA1mKDWHj4yHz28= From: Ihor Solodrai To: dwarves@vger.kernel.org, bpf@vger.kernel.org Cc: acme@kernel.org, alan.maguire@oracle.com, ast@kernel.org, andrii@kernel.org, eddyz87@gmail.com, mykolal@fb.com, kernel-team@meta.com Subject: [PATCH dwarves 2/3] btf_encoder: emit type tags for bpf_arena pointers Date: Thu, 6 Feb 2025 18:14:41 -0800 Message-ID: <20250207021442.155703-3-ihor.solodrai@linux.dev> In-Reply-To: <20250207021442.155703-1-ihor.solodrai@linux.dev> References: <20250207021442.155703-1-ihor.solodrai@linux.dev> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Migadu-Flow: FLOW_OUT When adding a kfunc prototype to BTF, check for the flags indicating bpf_arena pointers and emit a type tag encoding __attribute__((address_space(1))) for them. This also requires updating BTF type ids in the btf_encoder_func_state, which is done as a side effect in the tagging functions. This feature depends on recent update in libbpf, supporting arbitrarty attribute encoding [1]. [1] https://lore.kernel.org/bpf/20250130201239.1429648-1-ihor.solodrai@linux.dev/ Signed-off-by: Ihor Solodrai Reviewed-by: Alan Maguire --- btf_encoder.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 96 insertions(+), 1 deletion(-) diff --git a/btf_encoder.c b/btf_encoder.c index e9f4baf..d7837c2 100644 --- a/btf_encoder.c +++ b/btf_encoder.c @@ -40,7 +40,13 @@ #define BTF_SET8_KFUNCS (1 << 0) #define BTF_KFUNC_TYPE_TAG "bpf_kfunc" #define BTF_FASTCALL_TAG "bpf_fastcall" -#define KF_FASTCALL (1 << 12) +#define BPF_ARENA_ATTR "address_space(1)" + +/* kfunc flags, see include/linux/btf.h in the kernel source */ +#define KF_FASTCALL (1 << 12) +#define KF_ARENA_RET (1 << 13) +#define KF_ARENA_ARG1 (1 << 14) +#define KF_ARENA_ARG2 (1 << 15) struct btf_id_and_flag { uint32_t id; @@ -743,6 +749,91 @@ static int32_t btf_encoder__tag_type(struct btf_encoder *encoder, uint32_t tag_t return encoder->type_id_off + tag_type; } +static inline struct kfunc_info* btf_encoder__kfunc_by_name(struct btf_encoder *encoder, const char *name) { + struct kfunc_info *kfunc; + + list_for_each_entry(kfunc, &encoder->kfuncs, node) { + if (strcmp(kfunc->name, name) == 0) + return kfunc; + } + return NULL; +} + +#if LIBBPF_MAJOR_VERSION >= 1 && LIBBPF_MINOR_VERSION >= 6 +static int btf_encoder__tag_bpf_arena_ptr(struct btf *btf, int ptr_id) +{ + const struct btf_type *ptr; + int tagged_type_id; + + ptr = btf__type_by_id(btf, ptr_id); + if (!btf_is_ptr(ptr)) + return -EINVAL; + + tagged_type_id = btf__add_type_attr(btf, BPF_ARENA_ATTR, ptr->type); + if (tagged_type_id < 0) + return tagged_type_id; + + return btf__add_ptr(btf, tagged_type_id); +} + +static int btf_encoder__tag_bpf_arena_arg(struct btf *btf, struct btf_encoder_func_state *state, int idx) +{ + int id; + + if (state->nr_parms <= idx) + return -EINVAL; + + id = btf_encoder__tag_bpf_arena_ptr(btf, state->parms[idx].type_id); + if (id < 0) { + btf__log_err(btf, BTF_KIND_TYPE_TAG, BPF_ARENA_ATTR, true, id, + "Error adding BPF_ARENA_ATTR for an argument of kfunc '%s'", state->elf->name); + return id; + } + state->parms[idx].type_id = id; + + return id; +} + +static int btf_encoder__add_bpf_arena_type_tags(struct btf_encoder *encoder, struct btf_encoder_func_state *state) +{ + struct kfunc_info *kfunc = NULL; + int ret_type_id; + int err = 0; + + if (!state || !state->elf || !state->elf->kfunc) + goto out; + + kfunc = btf_encoder__kfunc_by_name(encoder, state->elf->name); + if (!kfunc) + goto out; + + if (KF_ARENA_RET & kfunc->flags) { + ret_type_id = btf_encoder__tag_bpf_arena_ptr(encoder->btf, state->ret_type_id); + if (ret_type_id < 0) { + btf__log_err(encoder->btf, BTF_KIND_TYPE_TAG, BPF_ARENA_ATTR, true, ret_type_id, + "Error adding BPF_ARENA_ATTR for return type of kfunc '%s'", state->elf->name); + err = ret_type_id; + goto out; + } + state->ret_type_id = ret_type_id; + } + + if (KF_ARENA_ARG1 & kfunc->flags) { + err = btf_encoder__tag_bpf_arena_arg(encoder->btf, state, 0); + if (err < 0) + goto out; + } + + if (KF_ARENA_ARG2 & kfunc->flags) { + err = btf_encoder__tag_bpf_arena_arg(encoder->btf, state, 1); + if (err < 0) + goto out; + } +out: + return err; +} +#endif // LIBBPF_MAJOR_VERSION >= 1 && LIBBPF_MINOR_VERSION >= 6 + static int32_t btf_encoder__add_func_proto(struct btf_encoder *encoder, struct ftype *ftype, struct btf_encoder_func_state *state) { @@ -762,6 +853,10 @@ static int32_t btf_encoder__add_func_proto(struct btf_encoder *encoder, struct f nr_params = ftype->nr_parms + (ftype->unspec_parms ? 1 : 0); type_id = btf_encoder__tag_type(encoder, ftype->tag.type); } else if (state) { +#if LIBBPF_MAJOR_VERSION >= 1 && LIBBPF_MINOR_VERSION >= 6 + if (btf_encoder__add_bpf_arena_type_tags(encoder, state) < 0) + return -1; +#endif encoder = state->encoder; btf = state->encoder->btf; nr_params = state->nr_parms; From patchwork Fri Feb 7 02:14:42 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ihor Solodrai X-Patchwork-Id: 13964240 Received: from out-174.mta1.migadu.com (out-174.mta1.migadu.com [95.215.58.174]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 49E1F1624E5 for ; Fri, 7 Feb 2025 02:15:05 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=95.215.58.174 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738894508; cv=none; b=mtDR5Ot+YjCHJap4qoVJRz9N0B/2UsVyGU/KAcPzSa4hCTXiHB1myl7URjU3t4pQKBYt1Sr3+ASxpl4D/+1oH7UYl6WeS7NmbaQL1eMP52dWjHh7hGQMjapLnApSyPaU0ozHYnFH6K+z1w58yclhWgfYUl1VZp9FGzWnJNiN3x4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1738894508; c=relaxed/simple; bh=sPtnUM+a4Sf6PqonCFWka4MME0SiGFhUo/lQWyLP72Q=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=WpOtvtOqGMrxaUvYjt/KLkq7/T1joSJWvEhAi4X8LlRuXwfq1gdf5xu+iYvTabkUJXp6EtbYb7jBUGJFvND1k7fgpBtGC2Da8uifHJGhOTcODxTHBW3R2C/rZs/CtTYmcC3+rOTAf49a5TEMiP0PRIMaCrL5dkPDOeRu119iKrg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev; spf=pass smtp.mailfrom=linux.dev; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b=kQT7vk6e; arc=none smtp.client-ip=95.215.58.174 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.dev Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.dev Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=linux.dev header.i=@linux.dev header.b="kQT7vk6e" X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1738894503; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=3SATihpDI6gKCPNDFWYK7idPXOGcxYr2zvSTDYPOLQQ=; b=kQT7vk6eTCAIKNUNONebA9oSmRP2fR1Ahr5qJVejfLTcQ4l3I41qEqkj+VQOyXjMPajMeR msEuxTKirl3GqQO+R/HrWzCxAK/CTatKje5QW3GpAhfyQOn2LnE5LAtErhtNWoQwArGXDG FEJ+DtUNEAh+E07ZX41vKdf8vS51sBs= From: Ihor Solodrai To: dwarves@vger.kernel.org, bpf@vger.kernel.org Cc: acme@kernel.org, alan.maguire@oracle.com, ast@kernel.org, andrii@kernel.org, eddyz87@gmail.com, mykolal@fb.com, kernel-team@meta.com Subject: [PATCH dwarves 3/3] pahole: introduce --btf_feature=attributes Date: Thu, 6 Feb 2025 18:14:42 -0800 Message-ID: <20250207021442.155703-4-ihor.solodrai@linux.dev> In-Reply-To: <20250207021442.155703-1-ihor.solodrai@linux.dev> References: <20250207021442.155703-1-ihor.solodrai@linux.dev> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-Migadu-Flow: FLOW_OUT Add a feature flag "attributes" (default: false) controlling whether pahole is allowed to generate BTF attributes: type tags and decl tags with kind_flag = 1. This is necessary for backward compatibility, as BPF verifier does not recognize tags with kind_flag = 1 prior to (at least) 6.14-rc1 [1]. [1] https://lore.kernel.org/bpf/20250130201239.1429648-1-ihor.solodrai@linux.dev/ Signed-off-by: Ihor Solodrai Reviewed-by: Alan Maguire --- btf_encoder.c | 6 ++++-- dwarves.h | 1 + pahole.c | 11 +++++++++++ 3 files changed, 16 insertions(+), 2 deletions(-) diff --git a/btf_encoder.c b/btf_encoder.c index d7837c2..0a734d4 100644 --- a/btf_encoder.c +++ b/btf_encoder.c @@ -142,7 +142,8 @@ struct btf_encoder { gen_floats, skip_encoding_decl_tag, tag_kfuncs, - gen_distilled_base; + gen_distilled_base, + encode_attributes; uint32_t array_index_id; struct elf_secinfo *secinfo; size_t seccnt; @@ -800,7 +801,7 @@ static int btf_encoder__add_bpf_arena_type_tags(struct btf_encoder *encoder, str int ret_type_id; int err = 0; - if (!state || !state->elf || !state->elf->kfunc) + if (!encoder->encode_attributes || !state || !state->elf || !state->elf->kfunc) goto out; kfunc = btf_encoder__kfunc_by_name(encoder, state->elf->name); @@ -2553,6 +2554,7 @@ struct btf_encoder *btf_encoder__new(struct cu *cu, const char *detached_filenam encoder->skip_encoding_decl_tag = conf_load->skip_encoding_btf_decl_tag; encoder->tag_kfuncs = conf_load->btf_decl_tag_kfuncs; encoder->gen_distilled_base = conf_load->btf_gen_distilled_base; + encoder->encode_attributes = conf_load->btf_attributes; encoder->verbose = verbose; encoder->has_index_type = false; encoder->need_index_type = false; diff --git a/dwarves.h b/dwarves.h index 8234e1a..99ed783 100644 --- a/dwarves.h +++ b/dwarves.h @@ -89,6 +89,7 @@ struct conf_load { bool reproducible_build; bool btf_decl_tag_kfuncs; bool btf_gen_distilled_base; + bool btf_attributes; uint8_t hashtable_bits; uint8_t max_hashtable_bits; uint16_t kabi_prefix_len; diff --git a/pahole.c b/pahole.c index af3e1cf..0bda249 100644 --- a/pahole.c +++ b/pahole.c @@ -1152,6 +1152,7 @@ ARGP_PROGRAM_VERSION_HOOK_DEF = dwarves_print_version; #define ARG_padding_ge 347 #define ARG_padding 348 #define ARGP_with_embedded_flexible_array 349 +#define ARGP_btf_attributes 350 /* --btf_features=feature1[,feature2,..] allows us to specify * a list of requested BTF features or "default" to enable all default @@ -1210,6 +1211,9 @@ struct btf_feature { BTF_NON_DEFAULT_FEATURE(distilled_base, btf_gen_distilled_base, false), #endif BTF_NON_DEFAULT_FEATURE(global_var, encode_btf_global_vars, false), +#if LIBBPF_MAJOR_VERSION >= 1 && LIBBPF_MINOR_VERSION >= 6 + BTF_NON_DEFAULT_FEATURE(attributes, btf_attributes, false), +#endif }; #define BTF_MAX_FEATURE_STR 1024 @@ -1785,6 +1789,11 @@ static const struct argp_option pahole__options[] = { .key = ARGP_running_kernel_vmlinux, .doc = "Search for, possibly getting from a debuginfo server, a vmlinux matching the running kernel build-id (from /sys/kernel/notes)" }, + { + .name = "btf_attributes", + .key = ARGP_btf_attributes, + .doc = "Allow generation of attributes in BTF. Attributes are the type tags and decl tags with the kind_flag set to 1.", + }, { .name = NULL, } @@ -1979,6 +1988,8 @@ static error_t pahole__options_parser(int key, char *arg, show_supported_btf_features(stdout); exit(0); case ARGP_btf_features_strict: parse_btf_features(arg, true); break; + case ARGP_btf_attributes: + conf_load.btf_attributes = true; break; default: return ARGP_ERR_UNKNOWN; }