From patchwork Wed Feb 19 21:05:17 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ihor Solodrai X-Patchwork-Id: 13982990 X-Patchwork-Delegate: bpf@iogearbox.net Received: from out-175.mta1.migadu.com (out-175.mta1.migadu.com [95.215.58.175]) (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 5A10B25335F for ; Wed, 19 Feb 2025 21:05:31 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=95.215.58.175 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739999133; cv=none; b=UvO8/6oKORsBkxMq1PRgBCXH9+CqTB+rgevzMZZMC/sU42nk5g/HmQ5iB3pKy9uTYaolY1rUYoNiStDLcYJcytcNZbKvG5x1ekbkQ75PiBeFZ0FaWlTa2z2kwgS7uLA+6c2Lr1NvnLsQ4mgzewuMbNIeOPWGyPg7AegAm22Px48= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739999133; c=relaxed/simple; bh=qLHgGhwBEwacMuYSNyCqUY96Diq8gRExKcI49kXbwPI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=WASq+fihVN9X9J85lDL0OkPRKbIbjUBz4DVotRh+QIq/c2wF1lXOSkexqLN7IHRa/0C6ApIY9XeeF24rBbeaPXE9dOP3DPjifob6rS1XjV5Sa1T0JfEa8jmwvBRkNe3p21LbSkJEIgqRN/zF4QtGwO6c5P2rX5UBdggoPuXF9PE= 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=c9e/z0T9; arc=none smtp.client-ip=95.215.58.175 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="c9e/z0T9" 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=1739999129; 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=fkxGYcxN0+BcmdBXN6OKPpltu0VWJVCQetbVHuPgcw8=; b=c9e/z0T9ypNScWIfg0RXPgJM2wBDWNmT54Ua1dDdA/tvDW0Wljrq2a4gZpIpuJpL4OGzrq 6YPdwuEAuNbnC6ukCMK+D8F7GuVa3BWoNLx2ZQTCXf43VkKuLN4J5hBViC+zWYsWnm+S41 rnnb5BtfN2x/OfBE7pLntl0DheHbwLU= 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 bpf-next v3 1/4] btf_encoder: refactor btf_encoder__tag_kfuncs() Date: Wed, 19 Feb 2025 13:05:17 -0800 Message-ID: <20250219210520.2245369-2-ihor.solodrai@linux.dev> In-Reply-To: <20250219210520.2245369-1-ihor.solodrai@linux.dev> References: <20250219210520.2245369-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 X-Patchwork-Delegate: bpf@iogearbox.net btf_encoder__tag_kfuncs() is a post-processing step of BTF encoding, executed right before BTF is deduped and dumped to the output. Rewrite btf_encoder__tag_kfuncs() into btf_encoder__collect_kfuncs(). Now it only reads the .BTF_ids section of the ELF, collecting kfunc information and adding it to corresponding elf_function structs. It is executed in btf_encoder__new() if tag_kfuncs flag is set. This way kfunc information is available within entire lifetime of the btf_encoder. BTF decl tags for kfuncs are added immediately after the function is added to BTF in btf_encoder__add_func(). It's done by btf__tag_kfunc() factored out from the btf_encoder__tag_kfunc(). As a result btf_encoder__collect_btf_funcs(), struct btf_func type and other relevant code are deleted, as they are no longer necessary. Link: https://lore.kernel.org/dwarves/3782640a577e6945c86d6330bc8a05018a1e5c52.camel@gmail.com/ Suggested-by: Eduard Zingerman Signed-off-by: Ihor Solodrai Reviewed-by: Jiri Olsa Acked-by: Eduard Zingerman --- btf_encoder.c | 189 +++++++++++++++----------------------------------- 1 file changed, 54 insertions(+), 135 deletions(-) diff --git a/btf_encoder.c b/btf_encoder.c index 511c1ea..2bea5ee 100644 --- a/btf_encoder.c +++ b/btf_encoder.c @@ -89,6 +89,8 @@ struct elf_function { const char *name; char *alias; size_t prefixlen; + bool kfunc; + uint32_t kfunc_flags; }; struct elf_secinfo { @@ -145,11 +147,6 @@ struct btf_encoder { struct list_head elf_functions_list; }; -struct btf_func { - const char *name; - int type_id; -}; - /* Half open interval representing range of addresses containing kfuncs */ struct btf_kfunc_set_range { uint64_t start; @@ -1178,6 +1175,39 @@ out: return err; } +static int btf__add_kfunc_decl_tag(struct btf *btf, const char *tag, __u32 id, const char *kfunc) +{ + int err = btf__add_decl_tag(btf, tag, id, -1); + + if (err < 0) { + fprintf(stderr, "%s: failed to insert kfunc decl tag for '%s': %d\n", + __func__, kfunc, err); + return err; + } + return 0; +} + +static int btf__tag_kfunc(struct btf *btf, struct elf_function *kfunc, __u32 btf_fn_id) +{ + int err; + + /* Note we are unconditionally adding the btf_decl_tag even + * though vmlinux may already contain btf_decl_tags for kfuncs. + * 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, btf_fn_id, kfunc->name); + if (err < 0) + return err; + + if (kfunc->kfunc_flags & KF_FASTCALL) { + err = btf__add_kfunc_decl_tag(btf, BTF_FASTCALL_TAG, btf_fn_id, kfunc->name); + if (err < 0) + return err; + } + return 0; +} + static int32_t btf_encoder__add_func(struct btf_encoder *encoder, struct btf_encoder_func_state *state) { @@ -1188,6 +1218,7 @@ static int32_t btf_encoder__add_func(struct btf_encoder *encoder, const char *value; char tmp_value[KSYM_NAME_LEN]; uint16_t idx; + int err; btf_fnproto_id = btf_encoder__add_func_proto(encoder, NULL, state); name = func->alias ?: func->name; @@ -1199,6 +1230,13 @@ static int32_t btf_encoder__add_func(struct btf_encoder *encoder, name, btf_fnproto_id < 0 ? "proto" : "func"); return -1; } + + if (func->kfunc && encoder->tag_kfuncs && !encoder->skip_encoding_decl_tag) { + err = btf__tag_kfunc(encoder->btf, func, btf_fn_id); + if (err < 0) + return err; + } + if (state->nr_annots == 0) return 0; @@ -1771,116 +1809,10 @@ static char *get_func_name(const char *sym) return func; } -static int btf_func_cmp(const void *_a, const void *_b) -{ - const struct btf_func *a = _a; - const struct btf_func *b = _b; - - return strcmp(a->name, b->name); -} - -/* - * Collects all functions described in BTF. - * Returns non-zero on error. - */ -static int btf_encoder__collect_btf_funcs(struct btf_encoder *encoder, struct gobuffer *funcs) -{ - struct btf *btf = encoder->btf; - int nr_types, type_id; - int err = -1; - - /* First collect all the func entries into an array */ - nr_types = btf__type_cnt(btf); - for (type_id = 1; type_id < nr_types; type_id++) { - const struct btf_type *type; - struct btf_func func = {}; - const char *name; - - type = btf__type_by_id(btf, type_id); - if (!type) { - fprintf(stderr, "%s: malformed BTF, can't resolve type for ID %d\n", - __func__, type_id); - err = -EINVAL; - goto out; - } - - if (!btf_is_func(type)) - continue; - - name = btf__name_by_offset(btf, type->name_off); - if (!name) { - fprintf(stderr, "%s: malformed BTF, can't resolve name for ID %d\n", - __func__, type_id); - err = -EINVAL; - goto out; - } - - func.name = name; - func.type_id = type_id; - err = gobuffer__add(funcs, &func, sizeof(func)); - if (err < 0) - goto out; - } - - /* Now that we've collected funcs, sort them by name */ - gobuffer__sort(funcs, sizeof(struct btf_func), btf_func_cmp); - - err = 0; -out: - return err; -} - -static int btf__add_kfunc_decl_tag(struct btf *btf, const char *tag, __u32 id, const char *kfunc) -{ - int err = btf__add_decl_tag(btf, tag, id, -1); - - if (err < 0) { - fprintf(stderr, "%s: failed to insert kfunc decl tag for '%s': %d\n", - __func__, kfunc, err); - return err; - } - return 0; -} - -static int btf_encoder__tag_kfunc(struct btf_encoder *encoder, struct gobuffer *funcs, const char *kfunc, __u32 flags) -{ - struct btf_func key = { .name = kfunc }; - struct btf *btf = encoder->btf; - struct btf_func *target; - const void *base; - unsigned int cnt; - int err; - - base = gobuffer__entries(funcs); - 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); - return -1; - } - - /* Note we are unconditionally adding the btf_decl_tag even - * though vmlinux may already contain btf_decl_tags for kfuncs. - * 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); - if (err < 0) - return err; - if (flags & KF_FASTCALL) { - err = btf__add_kfunc_decl_tag(btf, BTF_FASTCALL_TAG, target->type_id, kfunc); - if (err < 0) - return err; - } - - 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; @@ -1977,12 +1909,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 +1941,12 @@ 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; 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 +1987,16 @@ 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); - goto out; + elf_fn = btf_encoder__find_function(encoder, func, 0); + if (elf_fn) { + elf_fn->kfunc = true; + elf_fn->kfunc_flags = pair->flags; } free(func); } err = 0; out: - __gobuffer__delete(&btf_funcs); __gobuffer__delete(&btf_kfunc_ranges); if (elf) elf_end(elf); @@ -2083,7 +2007,6 @@ out: int btf_encoder__encode(struct btf_encoder *encoder, struct conf_load *conf) { - bool should_tag_kfuncs; int err; size_t shndx; @@ -2099,15 +2022,6 @@ int btf_encoder__encode(struct btf_encoder *encoder, struct conf_load *conf) if (btf__type_cnt(encoder->btf) == 1) return 0; - /* Note vmlinux may already contain btf_decl_tag's for kfuncs. So - * take care to call this before btf_dedup(). - */ - should_tag_kfuncs = encoder->tag_kfuncs && !encoder->skip_encoding_decl_tag; - if (should_tag_kfuncs && btf_encoder__tag_kfuncs(encoder)) { - fprintf(stderr, "%s: failed to tag kfuncs!\n", __func__); - return -1; - } - if (btf__dedup(encoder->btf, NULL)) { fprintf(stderr, "%s: btf__dedup failed!\n", __func__); return -1; @@ -2496,6 +2410,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 Wed Feb 19 21:05:18 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ihor Solodrai X-Patchwork-Id: 13982991 X-Patchwork-Delegate: bpf@iogearbox.net Received: from out-178.mta1.migadu.com (out-178.mta1.migadu.com [95.215.58.178]) (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 537D2253356 for ; Wed, 19 Feb 2025 21:05:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=95.215.58.178 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739999135; cv=none; b=IRJIm4n3A53PpK2LZNgnazz5QJuGvi4PC5RQJP6Li8UA8eXOu9r7zSUTIcKYOISV0J858/P1+LaprVrE5H5z/84mOhDgGJWsUOxoODuPY3DPphgb6xb6Mu5UI8fNCA2A/yNTsVmJqRvgqELu8ltyVD4yOHaM3qgkYamUeVO/tEI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739999135; c=relaxed/simple; bh=NR401DGkZ6X0Kw083X0R0d4HY284E4gJ6o98sSyUiDM=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=IcZBmnuCJs9ne2LdePHsQS8KDJ+hSquQjuxjbGhGnSRfE8uj9NBsxA9w7FZe8n4kyE7+bneR9g7HwjsO4hIAKt0yEGzXZEyIMIAd3dmR36+4/gpHh4BVwxawPMkQcZDMaRNd044pI/NrUn9PSFQDbBscjD1t93atwlGLkNBuJSQ= 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=bB5PVP8h; arc=none smtp.client-ip=95.215.58.178 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="bB5PVP8h" 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=1739999131; 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=XbEsZw1sAzT1POVT60+LaNyybURR5s1P5UwFZxeCkzk=; b=bB5PVP8hzubddN0lQaqfY5ggKZv9CvPfLIxOnB1kN4hVAKD/UR4+Y5IsxhrSZsghlVBInl igNV/GoNK3J/2zNNRHDmEI7C+3m4JZhHHjpRAGxbgnICFBqmp105KbbbsPJNsdwMzOLhJO 6k1/LhnbeNM3O/hEu9SpgbB1gn0xWmM= 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 bpf-next v3 2/4] btf_encoder: emit type tags for bpf_arena pointers Date: Wed, 19 Feb 2025 13:05:18 -0800 Message-ID: <20250219210520.2245369-3-ihor.solodrai@linux.dev> In-Reply-To: <20250219210520.2245369-1-ihor.solodrai@linux.dev> References: <20250219210520.2245369-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 X-Patchwork-Delegate: bpf@iogearbox.net 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 Reviewed-by: Jiri Olsa --- btf_encoder.c | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 85 insertions(+), 1 deletion(-) diff --git a/btf_encoder.c b/btf_encoder.c index 2bea5ee..844938f 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; @@ -731,6 +737,78 @@ static int32_t btf_encoder__tag_type(struct btf_encoder *encoder, uint32_t tag_t return encoder->type_id_off + tag_type; } +#if LIBBPF_MAJOR_VERSION >= 1 && LIBBPF_MINOR_VERSION >= 6 +static int btf__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__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__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__add_bpf_arena_type_tags(struct btf *btf, struct btf_encoder_func_state *state) +{ + uint32_t flags = state->elf->kfunc_flags; + int ret_type_id; + int err; + + if (KF_ARENA_RET & flags) { + ret_type_id = btf__tag_bpf_arena_ptr(btf, state->ret_type_id); + if (ret_type_id < 0) { + btf__log_err(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); + return ret_type_id; + } + state->ret_type_id = ret_type_id; + } + + if (KF_ARENA_ARG1 & flags) { + err = btf__tag_bpf_arena_arg(btf, state, 0); + if (err < 0) + return err; + } + + if (KF_ARENA_ARG2 & flags) { + err = btf__tag_bpf_arena_arg(btf, state, 1); + if (err < 0) + return err; + } + + return 0; +} +#endif // LIBBPF_MAJOR_VERSION >= 1 && LIBBPF_MINOR_VERSION >= 6 + +static inline bool is_kfunc_state(struct btf_encoder_func_state *state) +{ + return state && state->elf && state->elf->kfunc; +} + static int32_t btf_encoder__add_func_proto(struct btf_encoder *encoder, struct ftype *ftype, struct btf_encoder_func_state *state) { @@ -744,6 +822,12 @@ static int32_t btf_encoder__add_func_proto(struct btf_encoder *encoder, struct f assert(ftype != NULL || state != NULL); +#if LIBBPF_MAJOR_VERSION >= 1 && LIBBPF_MINOR_VERSION >= 6 + if (is_kfunc_state(state) && encoder->tag_kfuncs) + if (btf__add_bpf_arena_type_tags(encoder->btf, state) < 0) + return -1; +#endif + /* add btf_type for func_proto */ if (ftype) { btf = encoder->btf; From patchwork Wed Feb 19 21:05:19 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ihor Solodrai X-Patchwork-Id: 13982992 X-Patchwork-Delegate: bpf@iogearbox.net Received: from out-175.mta1.migadu.com (out-175.mta1.migadu.com [95.215.58.175]) (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 2D164255E40 for ; Wed, 19 Feb 2025 21:05:35 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=95.215.58.175 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739999137; cv=none; b=ASi6+FHSy69SaqauLrD7mTDHjz8otxKF7lVTY6IayQP+2tvdFc9yVaPzKqStFK+gyaWpa0tQk0xAtcK84kBGWWMKjrKF1GyNsK9SenwlN9t7dflN6ZQRUPRsdKF0jLmVIh6qPWaiU3cj43W4Q0A5JB+AnFrze3S3L7kt/zkIohw= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739999137; c=relaxed/simple; bh=C5nMcBEtsAOtyBGLK3LGY9LDMLC4xZxDA6KKQ80L8cY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=U15ZL5r/Iqu2iPvO1n8kv2nCKA9Wk3bcD6SSfuvsQjvUTLeVp1tB6+/XER2PEs2zBc4QqTL5yS+7RoDe1tlf6Zbmx9leXnWbkLfv/L7dTrtpPZQIdI9nbG2Bh6Da9bjipxOw01ztb788fp2r7WKmuxve+ajOepspgx5kwlO/qD0= 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=uAgGhA+p; arc=none smtp.client-ip=95.215.58.175 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="uAgGhA+p" 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=1739999134; 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=37pF3WcstHHNMOUpw/bl3UJm9H3zhz8mtI4k1lYorXc=; b=uAgGhA+p2+Mu3UgWa5U7rCBCiAaTLoPqmA7AIu984mnQuD1QMbfnes+IwHAx9ykbGJRHv4 Z9vsRE+4oFrCN8yO5W3xhv9jBf6H2Sku1Kgp4otsr2PQY/9tBLkdCcuRBQspowa9degqJL DWvH5dJRH02hZT3cK5O+//d2LEwiVkY= 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 bpf-next v3 3/4] pahole: introduce --btf_feature=attributes Date: Wed, 19 Feb 2025 13:05:19 -0800 Message-ID: <20250219210520.2245369-4-ihor.solodrai@linux.dev> In-Reply-To: <20250219210520.2245369-1-ihor.solodrai@linux.dev> References: <20250219210520.2245369-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 X-Patchwork-Delegate: bpf@iogearbox.net 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 Reviewed-by: Jiri Olsa Acked-by: Eduard Zingerman --- 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 844938f..2f56f5d 100644 --- a/btf_encoder.c +++ b/btf_encoder.c @@ -136,7 +136,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; @@ -823,7 +824,7 @@ static int32_t btf_encoder__add_func_proto(struct btf_encoder *encoder, struct f assert(ftype != NULL || state != NULL); #if LIBBPF_MAJOR_VERSION >= 1 && LIBBPF_MINOR_VERSION >= 6 - if (is_kfunc_state(state) && encoder->tag_kfuncs) + if (is_kfunc_state(state) && encoder->tag_kfuncs && encoder->encode_attributes) if (btf__add_bpf_arena_type_tags(encoder->btf, state) < 0) return -1; #endif @@ -2414,6 +2415,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; } From patchwork Wed Feb 19 21:05:20 2025 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ihor Solodrai X-Patchwork-Id: 13982993 X-Patchwork-Delegate: bpf@iogearbox.net Received: from out-171.mta1.migadu.com (out-171.mta1.migadu.com [95.215.58.171]) (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 533F2255E46 for ; Wed, 19 Feb 2025 21:05:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=95.215.58.171 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739999139; cv=none; b=G2j7bx8nzl1BWFlPvmfABph2fTtueEemfM3QSa6wcXs7PmZyguHav7NyTCqBAQDHQFhK8Z5CjNJbkfOKV6K8HntS2bllHd2II8Ofolo2bKcNc2ftFRUPzyTkx8xUZkSlEBItHQJc69KhCSclxkrPyHu2bsMaDrW4VuvpdIHJlEo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1739999139; c=relaxed/simple; bh=vg72N/6DHfjyoSjIakVAL/xbwxGciAKI+kj6lrkH/RI=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=sIsZKMMuozV7IgqjzBAdnpdtSPrk+IYmtxVkVkK6zxENmsmWZLtkv9LKmWANQ40ZWn6laj50ZBoDj+jLNmLUxgghKTHskbnaaMy8LgYTgT/L3dhSCFsfxki2bHB22ETK54mvad8LmvsbugBqCUL16GZTlat9AHDALPmoRB1JsuA= 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=CTk6HhQ6; arc=none smtp.client-ip=95.215.58.171 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="CTk6HhQ6" 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=1739999136; 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=NuvyfCtG+VEG28gEE9qzAwxBAEPojdpIbDgPKLNVZaI=; b=CTk6HhQ6/UVPDSxCLFsFjHNkxqG9D7KVOi3yoHpFxW0Xghy4c9uZSTmu/E5YhcqVLcl8Lp SnJRVWzJAwB7MiasSjN6YoJr7vp27q3GD26VpteW02FQfzOqTx263je1ommfYWjAD4q+VA 7to35ehPdmH6Mc0nwZuS67UcRIk0W2A= 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 bpf-next v3 4/4] man-pages: describe attributes and remove reproducible_build Date: Wed, 19 Feb 2025 13:05:20 -0800 Message-ID: <20250219210520.2245369-5-ihor.solodrai@linux.dev> In-Reply-To: <20250219210520.2245369-1-ihor.solodrai@linux.dev> References: <20250219210520.2245369-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 X-Patchwork-Delegate: bpf@iogearbox.net Add a description of the new --btf_feature=attributes. Also remove reproducible_build description, as it is now a moot feature flag. Signed-off-by: Ihor Solodrai Reviewed-by: Jiri Olsa --- man-pages/pahole.1 | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/man-pages/pahole.1 b/man-pages/pahole.1 index 39e7b46..3125de3 100644 --- a/man-pages/pahole.1 +++ b/man-pages/pahole.1 @@ -327,9 +327,10 @@ Encode BTF using the specified feature list, or specify 'default' for all standa Supported non-standard features (not enabled for 'default') .nf - reproducible_build Ensure generated BTF is consistent every time; - without this parallel BTF encoding can result in - inconsistent BTF ids. + attributes Allow generation of decl_tags and type_tags with + kind_flag = 1. These tags can be used to encode + arbitrary compiler attributes in BTF, but are + backward incompatible. decl_tag_kfuncs Inject a BTF_KIND_DECL_TAG for each discovered kfunc. distilled_base For split BTF, generate a distilled version of the associated base BTF to support later relocation