On 5/17/24 03:22, Alan Maguire wrote:
Map distilled base BTF type ids referenced in split BTF and their
references to the base BTF passed in, and if the mapping succeeds,
reparent the split BTF to the base BTF.
Relocation is done by first verifying that distilled base BTF
only consists of named INT, FLOAT, ENUM, FWD, STRUCT and
UNION kinds; then we sort these to speed lookups. Once sorted,
the base BTF is iterated, and for each relevant kind we check
for an equivalent in distilled base BTF. When found, the
mapping from distilled -> base BTF id and string offset is recorded.
Once all mappings are established, we can update type ids
and string offsets in split BTF and reparent it to the new base.
Signed-off-by: Alan Maguire <alan.maguire@xxxxxxxxxx>
---
[...]
+/* Comparison between base BTF type (search type) and distilled base types (target).
+ * Because there is no bsearch_r() we need to use the search key - which also is
+ * the first element of struct btf_relocate * - as a means to retrieve the
+ * struct btf_relocate *.
+ */
+static int cmp_base_and_distilled_btf_types(const void *idbase, const void *iddist)
+{
+ struct btf_relocate *r = (struct btf_relocate *)idbase;
+ const struct btf_type *tbase = btf_type_by_id(r->base_btf, *(__u32 *)idbase);
"*(__u32 *)idbase" together with the previous line is a little difficult
to decrypt. Using "r->search_id" here is more intuitive, easier to read.
+ const struct btf_type *tdist = btf_type_by_id(r->dist_base_btf, *(__u32 *)iddist);
+
+ return strcmp(btf__name_by_offset(r->base_btf, tbase->name_off),
+ btf__name_by_offset(r->dist_base_btf, tdist->name_off));
+}
+
+/* Build a map from distilled base BTF ids to base BTF ids. To do so, iterate
+ * through base BTF looking up distilled type (using binary search) equivalents.
+ */
+static int btf_relocate_map_distilled_base(struct btf_relocate *r)
+{
+ struct btf_type *t;
+ const char *name;
+ __u32 id;
+
+ /* generate a sort index array of type ids sorted by name for distilled
+ * base BTF to speed lookups.
+ */
+ for (id = 1; id < r->nr_dist_base_types; id++)
+ r->dist_base_index[id] = id;
+ qsort_r(r->dist_base_index, r->nr_dist_base_types, sizeof(__u32), cmp_btf_types,
+ (struct btf *)r->dist_base_btf);
+
+ for (id = 1; id < r->nr_base_types; id++) {
+ struct btf_type *dist_t;
+ int dist_kind, kind;
+ bool compat_kind;
+ __u32 *dist_id;
+
+ t = btf_type_by_id(r->base_btf, id);
+ kind = btf_kind(t);
+ /* distilled base consists of named types only. */
+ if (!t->name_off)
+ continue;
+ switch (kind) {
+ case BTF_KIND_INT:
+ case BTF_KIND_FLOAT:
+ case BTF_KIND_ENUM:
+ case BTF_KIND_ENUM64:
+ case BTF_KIND_FWD:
+ case BTF_KIND_STRUCT:
+ case BTF_KIND_UNION:
+ break;
+ default:
+ continue;
+ }
+ r->search_id = id;
+ dist_id = bsearch(&r->search_id, r->dist_base_index, r->nr_dist_base_types,
+ sizeof(__u32), cmp_base_and_distilled_btf_types);
+ if (!dist_id)
+ continue;
+ if (!*dist_id || *dist_id > r->nr_dist_base_types) {
+ pr_warn("base BTF id [%d] maps to invalid distilled base BTF id [%d]\n",
+ id, *dist_id);
+ return -EINVAL;
+ }
+ /* validate that kinds are compatible */
+ dist_t = btf_type_by_id(r->dist_base_btf, *dist_id);
+ dist_kind = btf_kind(dist_t);
+ name = btf__name_by_offset(r->dist_base_btf, dist_t->name_off);
+ compat_kind = dist_kind == kind;
+ if (!compat_kind) {
+ switch (dist_kind) {
+ case BTF_KIND_FWD:
+ compat_kind = kind == BTF_KIND_STRUCT || kind == BTF_KIND_UNION;
+ break;
+ case BTF_KIND_ENUM:
+ compat_kind = kind == BTF_KIND_ENUM64;
+ break;
+ default:
+ break;
+ }
+ if (!compat_kind) {
+ pr_warn("kind incompatibility (%d != %d) between distilled base type '%s'[%d] and base type [%d]\n",
+ dist_kind, kind, name, *dist_id, id);
+ return -EINVAL;
+ }
+ }
+ /* validate that int, float struct, union sizes are compatible;
+ * distilled base BTF encodes an empty STRUCT/UNION with
+ * specific size for cases where a type is embedded in a split
+ * type (so has to preserve size info). Do not error out
+ * on mismatch as another size match may occur for an
+ * identically-named type.
+ */
+ switch (btf_kind(dist_t)) {
+ case BTF_KIND_INT:
+ if (*(__u32 *)(t + 1) != *(__u32 *)(dist_t + 1))
+ continue;
I know we have code like this here and there. But, could we just use
btf_int_encoding() and btf_int_offset() or invent another function to
return this value and make this comparison more meaningful?
Or just a line of comment to explain what it is.
+ if (t->size != dist_t->size)
+ continue;
+ break;
+ case BTF_KIND_FLOAT:
+ case BTF_KIND_STRUCT:
+ case BTF_KIND_UNION:
+ if (t->size != dist_t->size)
+ continue;
+ break;
+ default:
+ break;
+ }
+ /* map id and name */
+ r->map[*dist_id] = id;
+ r->str_map[dist_t->name_off] = t->name_off;
+ }
+ /* ensure all distilled BTF ids have a mapping... */
+ for (id = 1; id < r->nr_dist_base_types; id++) {
+ if (r->map[id])
+ continue;
+ t = btf_type_by_id(r->dist_base_btf, id);
+ name = btf__name_by_offset(r->dist_base_btf, t->name_off);
+ pr_warn("distilled base BTF type '%s' [%d] is not mapped to base BTF id\n",
+ name, id);
+ return -EINVAL;
+ }
+ return 0;
+}
[...]
