libbpf: add bulk BTF type copying API
Subsystems (4)
v2 cover libbpf: add bulk BTF type copying API
From: Andrii Nakryiko <[email protected]>
Add bulk BTF type data copying API, btf__add_btf(), to libbpf. This API is useful for tools that are manipulating BPF, such as pahole. They abstract away the details of implementing a pretty mundane, but important to get right, details of handling all possible BTF kinds, as well as, importantly, adjusting BTF type IDs and copying/deduplicating strings and string offsets, referenced from copied BTF types.
Also, being a batch API, it's possible to improve the efficiency by preallocating necessary memory more efficiently.
This API is going to be used by pahole to implement efficient parallelized BTF encoding.
v1->v2:
- fix typo in doc comment and selftest clean up fix (Song).
Andrii Nakryiko (3):
libbpf: add API that copies all BTF types from one BTF object to
another
selftests/bpf: refactor btf_write selftest to reuse BTF generation
logic
selftests/bpf: test new btf__add_btf() API
tools/lib/bpf/btf.c | 114 +++++++++++++- tools/lib/bpf/btf.h | 22 +++ tools/lib/bpf/libbpf.map | 1 + .../selftests/bpf/prog_tests/btf_write.c | 141 +++++++++++++++++- 4 files changed, 270 insertions(+), 8 deletions(-)
Signature · 1 line
2.30.2
PATCH v2 1/3 libbpf: add API that copies all BTF types from one BTF object to another
From: Andrii Nakryiko <[email protected]>
Add a bulk copying api, btf__add_btf(), that speeds up and simplifies appending entire contents of one BTF object to another one, taking care of copying BTF type data, adjusting resulting BTF type IDs according to their new locations in the destination BTF object, as well as copying and deduplicating all the referenced strings and updating all the string offsets in new BTF types as appropriate.
This API is intended to be used from tools that are generating and otherwise manipulating BTFs generically, such as pahole. In pahole's case, this API is useful for speeding up parallelized BTF encoding, as it allows pahole to offload all the intricacies of BTF type copying to libbpf and handle the parallelization aspects of the process.
--- tools/lib/bpf/btf.c | 114 ++++++++++++++++++++++++++++++++++++++- tools/lib/bpf/btf.h | 22 ++++++++ tools/lib/bpf/libbpf.map | 1 + 3 files changed, 135 insertions(+), 2 deletions(-)
tools/lib/bpf/btf.c +112 -2
@@ -189,12 +189,17 @@ int libbpf_ensure_mem(void **data, size_t *cap_cnt, size_t elem_sz, size_t need_return 0 ; } +static void *btf_add_type_offs_mem (struct btf *btf,size_t add_cnt) +{ +return libbpf_add_mem ((void **)&btf->type_offs, &btf->type_offs_cap,sizeof (__u32), + btf->nr_types,BTF_MAX_NR_TYPES , add_cnt); +} +static int btf_add_type_idx_entry (struct btf *btf,__u32 type_off) {__u32 *p; - p =libbpf_add_mem ((void **)&btf->type_offs, &btf->type_offs_cap,sizeof (__u32), - btf->nr_types,BTF_MAX_NR_TYPES ,1 ); + p =btf_add_type_offs_mem (btf,1 );if (!p)return -ENOMEM ;
@@ -1703,6 +1708,111 @@ int btf__add_type(struct btf *btf, const struct btf *src_btf, const struct btf_treturn btf_commit_type (btf, sz); } +static int btf_rewrite_type_ids (__u32 *type_id,void *ctx) +{ +struct btf *btf = ctx; + +if (!*type_id)/* nothing to do for VOID references */ +return 0 ; + +/* we haven't updated btf's type count yet, so +* btf->start_id + btf->nr_types - 1 is the type ID offset we should +* add to all newly added BTF types +*/ + *type_id += btf->start_id + btf->nr_types -1 ; +return 0 ; +} + +int btf__add_btf (struct btf *btf,const struct btf *src_btf) +{ +struct btf_pipe p = { .src = src_btf, .dst = btf }; +int data_sz, sz, cnt, i, err, old_strs_len; +__u32 *off; +void *t; + +/* appending split BTF isn't supported yet */ +if (src_btf->base_btf) +return libbpf_err (-ENOTSUP ); + +/* deconstruct BTF, if necessary, and invalidate raw_data */ +if (btf_ensure_modifiable (btf)) +return libbpf_err (-ENOMEM ); + +/* remember original strings section size if we have to roll back +* partial strings section changes +*/ + old_strs_len = btf->hdr->str_len; + + data_sz = src_btf->hdr->type_len; + cnt =btf__get_nr_types (src_btf); + +/* pre-allocate enough memory for new types */ + t =btf_add_type_mem (btf, data_sz); +if (!t) +return libbpf_err (-ENOMEM ); + +/* pre-allocate enough memory for type offset index for new types */ + off =btf_add_type_offs_mem (btf, cnt); +if (!off) +return libbpf_err (-ENOMEM ); + +/* bulk copy types data for all types from src_btf */ +memcpy (t, src_btf->types_data, data_sz); + +for (i =0 ; i < cnt; i++) { + sz =btf_type_size (t); +if (sz <0 ) { +/* unlikely, has to be corrupted src_btf */ + err = sz; + goto err_out; + } + +/* fill out type ID to type offset mapping for lookups by type ID */ + *off = t - btf->types_data; + +/* add, dedup, and remap strings referenced by this BTF type */ + err =btf_type_visit_str_offs (t, btf_rewrite_str, &p); +if (err) + goto err_out; + +/* remap all type IDs referenced from this BTF type */ + err =btf_type_visit_type_ids (t, btf_rewrite_type_ids, btf); +if (err) + goto err_out; + +/* go to next type data and type offset index entry */ + t += sz; + off++; + } + +/* Up until now any of the copied type data was effectively invisible, +* so if we exited early before this point due to error, BTF would be +* effectively unmodified. There would be extra internal memory +* pre-allocated, but it would not be available for querying. But now +* that we've copied and rewritten all the data successfully, we can +* update type count and various internal offsets and sizes to +* "commit" the changes and made them visible to the outside world. +*/ + btf->hdr->type_len += data_sz; + btf->hdr->str_off += data_sz; + btf->nr_types += cnt; + +/* return type ID of the first added BTF type */ +return btf->start_id + btf->nr_types - cnt; +err_out: +/* zero out preallocated memory as if it was just allocated with +* libbpf_add_mem() +*/ +memset (btf->types_data + btf->hdr->type_len,0 , data_sz); +memset (btf->strs_data + old_strs_len,0 , btf->hdr->str_len - old_strs_len); + +/* and now restore original strings section size; types data size +* wasn't modified, so doesn't need restoring, see big comment above */ + btf->hdr->str_len = old_strs_len; + +return libbpf_err (err); +} +/* * Append new BTF_KIND_INT type with: * - *name* - non-empty, non-NULL type name;
tools/lib/bpf/btf.h +22 -0
@@ -173,6 +173,28 @@ LIBBPF_API int btf__find_str(struct btf *btf, const char *s); LIBBPF_API int btf__add_str(struct btf *btf, const char *s); LIBBPF_API int btf__add_type(struct btf *btf, const struct btf *src_btf,const struct btf_type *src_type); +/** +* @brief **btf__add_btf()** appends all the BTF types from *src_btf* into *btf* +* @param btf BTF object which all the BTF types and strings are added to +* @param src_btf BTF object which all BTF types and referenced strings are copied from +* @return BTF type ID of the first appended BTF type, or negative error code +* +* **btf__add_btf()** can be used to simply and efficiently append the entire +* contents of one BTF object to another one. All the BTF type data is copied +* over, all referenced type IDs are adjusted by adding a necessary ID offset. +* Only strings referenced from BTF types are copied over and deduplicated, so +* if there were some unused strings in *src_btf*, those won't be copied over, +* which is consistent with the general string deduplication semantics of BTF +* writing APIs. +* +* If any error is encountered during this process, the contents of *btf* is +* left intact, which means that **btf__add_btf()** follows the transactional +* semantics and the operation as a whole is all-or-nothing. +* +* *src_btf* has to be non-split BTF, as of now copying types from split BTF +* is not supported and will result in -ENOTSUP error code returned. +*/ +LIBBPF_API int btf__add_btf(struct btf *btf, const struct btf *src_btf); LIBBPF_API int btf__add_int(struct btf *btf, const char *name, size_t byte_sz, int encoding); LIBBPF_API int btf__add_float(struct btf *btf, const char *name, size_t byte_sz);
tools/lib/bpf/libbpf.map +1 -0
@@ -389,5 +389,6 @@ LIBBPF_0.5.0 { LIBBPF_0.6.0 { global: + btf__add_btf; btf__add_tag; } LIBBPF_0.5.0;
Signature · 1 line
2.30.2
PATCH v2 2/3 selftests/bpf: refactor btf_write selftest to reuse BTF generation logic
In reply to [email protected]From: Andrii Nakryiko <[email protected]>
Next patch will need to reuse BTF generation logic, which tests every supported BTF kind, for testing btf__add_btf() APIs. So restructure existing selftests and make it as a single subtest that uses bulk VALIDATE_RAW_BTF() macro for raw BTF dump checking.
--- .../selftests/bpf/prog_tests/btf_write.c | 55 +++++++++++++++++-- 1 file changed, 49 insertions(+), 6 deletions(-)
tools/testing/selftests/bpf/prog_tests/btf_write.c +49 -6
@@ -4,19 +4,15 @@#include <bpf/btf.h> #include "btf_helpers.h" -void test_btf_write () { +static void gen_btf (struct btf *btf) +{const struct btf_var_secinfo *vi;const struct btf_type *t;const struct btf_member *m;const struct btf_enum *v;const struct btf_param *p; -struct btf *btf;int id, err, str_off; - btf =btf__new_empty (); -if (!ASSERT_OK_PTR (btf,"new_empty" )) -return ; - str_off =btf__find_str (btf,"int" );ASSERT_EQ (str_off, -ENOENT ,"int_str_missing_off" );
@@ -301,6 +297,53 @@ void test_btf_write() {ASSERT_EQ (btf_tag (t)->component_idx,1 ,"tag_component_idx" );ASSERT_STREQ (btf_type_raw_dump (btf,19 ),"[19] TAG 'tag2' type_id=14 component_idx=1" ,"raw_dump" ); +} + +static void test_btf_add () +{ +struct btf *btf; + + btf =btf__new_empty (); +if (!ASSERT_OK_PTR (btf,"new_empty" )) +return ; + +gen_btf (btf); + +VALIDATE_RAW_BTF ( + btf, +"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED" , +"[2] PTR '(anon)' type_id=1" , +"[3] CONST '(anon)' type_id=5" , +"[4] VOLATILE '(anon)' type_id=3" , +"[5] RESTRICT '(anon)' type_id=4" , +"[6] ARRAY '(anon)' type_id=2 index_type_id=1 nr_elems=10" , +"[7] STRUCT 's1' size=8 vlen=2\n" +"\t'f1' type_id=1 bits_offset=0\n" +"\t'f2' type_id=1 bits_offset=32 bitfield_size=16" , +"[8] UNION 'u1' size=8 vlen=1\n" +"\t'f1' type_id=1 bits_offset=0 bitfield_size=16" , +"[9] ENUM 'e1' size=4 vlen=2\n" +"\t'v1' val=1\n" +"\t'v2' val=2" , +"[10] FWD 'struct_fwd' fwd_kind=struct" , +"[11] FWD 'union_fwd' fwd_kind=union" , +"[12] ENUM 'enum_fwd' size=4 vlen=0" , +"[13] TYPEDEF 'typedef1' type_id=1" , +"[14] FUNC 'func1' type_id=15 linkage=global" , +"[15] FUNC_PROTO '(anon)' ret_type_id=1 vlen=2\n" +"\t'p1' type_id=1\n" +"\t'p2' type_id=2" , +"[16] VAR 'var1' type_id=1, linkage=global-alloc" , +"[17] DATASEC 'datasec1' size=12 vlen=1\n" +"\ttype_id=1 offset=4 size=8" , +"[18] TAG 'tag1' type_id=16 component_idx=-1" , +"[19] TAG 'tag2' type_id=14 component_idx=1" );btf__free (btf); } + +void test_btf_write () +{ +if (test__start_subtest ("btf_add" )) +test_btf_add (); +}
Signature · 1 line
2.30.2
PATCH v2 3/3 selftests/bpf: test new btf__add_btf() API
In reply to [email protected]From: Andrii Nakryiko <[email protected]>
Add a test that validates that btf__add_btf() API is correctly copying all the types from the source BTF into destination BTF object and adjusts type IDs and string offsets properly.
--- .../selftests/bpf/prog_tests/btf_write.c | 86 +++++++++++++++++++ 1 file changed, 86 insertions(+)
tools/testing/selftests/bpf/prog_tests/btf_write.c +86 -0
@@ -342,8 +342,94 @@ static void test_btf_add()btf__free (btf); } +static void test_btf_add_btf () +{ +struct btf *btf1 =NULL , *btf2 =NULL ; +int id; + + btf1 =btf__new_empty (); +if (!ASSERT_OK_PTR (btf1,"btf1" )) +return ; + + btf2 =btf__new_empty (); +if (!ASSERT_OK_PTR (btf2,"btf2" )) + goto cleanup; + +gen_btf (btf1); +gen_btf (btf2); + + id =btf__add_btf (btf1, btf2); +if (!ASSERT_EQ (id,20 ,"id" )) + goto cleanup; + +VALIDATE_RAW_BTF ( + btf1, +"[1] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED" , +"[2] PTR '(anon)' type_id=1" , +"[3] CONST '(anon)' type_id=5" , +"[4] VOLATILE '(anon)' type_id=3" , +"[5] RESTRICT '(anon)' type_id=4" , +"[6] ARRAY '(anon)' type_id=2 index_type_id=1 nr_elems=10" , +"[7] STRUCT 's1' size=8 vlen=2\n" +"\t'f1' type_id=1 bits_offset=0\n" +"\t'f2' type_id=1 bits_offset=32 bitfield_size=16" , +"[8] UNION 'u1' size=8 vlen=1\n" +"\t'f1' type_id=1 bits_offset=0 bitfield_size=16" , +"[9] ENUM 'e1' size=4 vlen=2\n" +"\t'v1' val=1\n" +"\t'v2' val=2" , +"[10] FWD 'struct_fwd' fwd_kind=struct" , +"[11] FWD 'union_fwd' fwd_kind=union" , +"[12] ENUM 'enum_fwd' size=4 vlen=0" , +"[13] TYPEDEF 'typedef1' type_id=1" , +"[14] FUNC 'func1' type_id=15 linkage=global" , +"[15] FUNC_PROTO '(anon)' ret_type_id=1 vlen=2\n" +"\t'p1' type_id=1\n" +"\t'p2' type_id=2" , +"[16] VAR 'var1' type_id=1, linkage=global-alloc" , +"[17] DATASEC 'datasec1' size=12 vlen=1\n" +"\ttype_id=1 offset=4 size=8" , +"[18] TAG 'tag1' type_id=16 component_idx=-1" , +"[19] TAG 'tag2' type_id=14 component_idx=1" , + +/* types appended from the second BTF */ +"[20] INT 'int' size=4 bits_offset=0 nr_bits=32 encoding=SIGNED" , +"[21] PTR '(anon)' type_id=20" , +"[22] CONST '(anon)' type_id=24" , +"[23] VOLATILE '(anon)' type_id=22" , +"[24] RESTRICT '(anon)' type_id=23" , +"[25] ARRAY '(anon)' type_id=21 index_type_id=20 nr_elems=10" , +"[26] STRUCT 's1' size=8 vlen=2\n" +"\t'f1' type_id=20 bits_offset=0\n" +"\t'f2' type_id=20 bits_offset=32 bitfield_size=16" , +"[27] UNION 'u1' size=8 vlen=1\n" +"\t'f1' type_id=20 bits_offset=0 bitfield_size=16" , +"[28] ENUM 'e1' size=4 vlen=2\n" +"\t'v1' val=1\n" +"\t'v2' val=2" , +"[29] FWD 'struct_fwd' fwd_kind=struct" , +"[30] FWD 'union_fwd' fwd_kind=union" , +"[31] ENUM 'enum_fwd' size=4 vlen=0" , +"[32] TYPEDEF 'typedef1' type_id=20" , +"[33] FUNC 'func1' type_id=34 linkage=global" , +"[34] FUNC_PROTO '(anon)' ret_type_id=20 vlen=2\n" +"\t'p1' type_id=20\n" +"\t'p2' type_id=21" , +"[35] VAR 'var1' type_id=20, linkage=global-alloc" , +"[36] DATASEC 'datasec1' size=12 vlen=1\n" +"\ttype_id=20 offset=4 size=8" , +"[37] TAG 'tag1' type_id=35 component_idx=-1" , +"[38] TAG 'tag2' type_id=33 component_idx=1" ); + +cleanup: +btf__free (btf1); +btf__free (btf2); +} +void test_btf_write () {if (test__start_subtest ("btf_add" ))test_btf_add (); +if (test__start_subtest ("btf_add_btf" )) +test_btf_add_btf (); }
Signature · 1 line
2.30.2
This series was applied to bpf/bpf-next.git (refs/heads/master):
Hello:
This series was applied to bpf/bpf-next.git (refs/heads/master):
Quoted 10 lines · On Tue, 5 Oct 2021 22:11:04 -0700 you wrote:
From: Andrii Nakryiko <[email protected]>
Add bulk BTF type data copying API,
btf__add_btf(), to libbpf. This API is useful for tools that are manipulating BPF, such as pahole. They abstract away the details of implementing a pretty mundane, but important to get right, details of handling all possible BTF kinds, as well as, importantly, adjusting BTF type IDs and copying/deduplicating strings and string offsets, referenced from copied BTF types.[...]
Here is the summary with links:
- [v2,bpf-next,1/3] libbpf: add API that copies all BTF types from one BTF object to another
https://git.kernel.org/bpf/bpf-next/c/7ca611215983 - [v2,bpf-next,2/3] selftests/bpf: refactor btf_write selftest to reuse BTF generation logic https://git.kernel.org/bpf/bpf-next/c/c65eb8082d4c - [v2,bpf-next,3/3] selftests/bpf: test new btf__add_btf() API https://git.kernel.org/bpf/bpf-next/c/9d0578722391
You are awesome, thank you!
--
Deet-doot-dot, I am a bot.
https://korg.docs.kernel.org/patchwork/pwbot.html