libbpf: Teach btf_dumper to emit stand-alone anonymous enum definitions

BTF-to-C converter previously skipped anonymous enums in an assumption
that those are embedded in struct's field definitions. This is not
always the case and a lot of kernel constants are defined as part of
anonymous enums. This change fixes the logic by eagerly marking all
types as either referenced by any other type or not. This is enough to
distinguish two classes of anonymous enums and emit previously omitted
enum definitions.

Signed-off-by: Andrii Nakryiko <andriin@fb.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20190925203745.3173184-1-andriin@fb.com

1 files changed, 87 insertions, 6 deletions

diff --git a/tools/lib/bpf/btf_dump.c b/tools/lib/bpf/btf_dump.c
index 84b0661db7f3..ede55fec3618 100644
--- a/tools/lib/bpf/btf_dump.c
+++ b/tools/lib/bpf/btf_dump.c
@@ -48,6 +48,8 @@ struct btf_dump_type_aux_state {
         __u8 fwd_emitted: 1;
         /* whether unique non-duplicate name was already assigned */
         __u8 name_resolved: 1;
+        /* whether type is referenced from any other type */
+        __u8 referenced: 1;
 };
 
 struct btf_dump {
@@ -173,6 +175,7 @@ void btf_dump__free(struct btf_dump *d)
         free(d);
 }
 
+static int btf_dump_mark_referenced(struct btf_dump *d);
 static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr);
 static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id);
 
@@ -213,6 +216,11 @@ int btf_dump__dump_type(struct btf_dump *d, __u32 id)
                 /* VOID is special */
                 d->type_states[0].order_state = ORDERED;
                 d->type_states[0].emit_state = EMITTED;
+
+                /* eagerly determine referenced types for anon enums */
+                err = btf_dump_mark_referenced(d);
+                if (err)
+                        return err;
         }
 
         d->emit_queue_cnt = 0;
@@ -226,6 +234,79 @@ int btf_dump__dump_type(struct btf_dump *d, __u32 id)
         return 0;
 }
 
+/*
+ * Mark all types that are referenced from any other type. This is used to
+ * determine top-level anonymous enums that need to be emitted as an
+ * independent type declarations.
+ * Anonymous enums come in two flavors: either embedded in a struct's field
+ * definition, in which case they have to be declared inline as part of field
+ * type declaration; or as a top-level anonymous enum, typically used for
+ * declaring global constants. It's impossible to distinguish between two
+ * without knowning whether given enum type was referenced from other type:
+ * top-level anonymous enum won't be referenced by anything, while embedded
+ * one will.
+ */
+static int btf_dump_mark_referenced(struct btf_dump *d)
+{
+        int i, j, n = btf__get_nr_types(d->btf);
+        const struct btf_type *t;
+        __u16 vlen;
+
+        for (i = 1; i <= n; i++) {
+                t = btf__type_by_id(d->btf, i);
+                vlen = btf_vlen(t);
+
+                switch (btf_kind(t)) {
+                case BTF_KIND_INT:
+                case BTF_KIND_ENUM:
+                case BTF_KIND_FWD:
+                        break;
+
+                case BTF_KIND_VOLATILE:
+                case BTF_KIND_CONST:
+                case BTF_KIND_RESTRICT:
+                case BTF_KIND_PTR:
+                case BTF_KIND_TYPEDEF:
+                case BTF_KIND_FUNC:
+                case BTF_KIND_VAR:
+                        d->type_states[t->type].referenced = 1;
+                        break;
+
+                case BTF_KIND_ARRAY: {
+                        const struct btf_array *a = btf_array(t);
+
+                        d->type_states[a->index_type].referenced = 1;
+                        d->type_states[a->type].referenced = 1;
+                        break;
+                }
+                case BTF_KIND_STRUCT:
+                case BTF_KIND_UNION: {
+                        const struct btf_member *m = btf_members(t);
+
+                        for (j = 0; j < vlen; j++, m++)
+                                d->type_states[m->type].referenced = 1;
+                        break;
+                }
+                case BTF_KIND_FUNC_PROTO: {
+                        const struct btf_param *p = btf_params(t);
+
+                        for (j = 0; j < vlen; j++, p++)
+                                d->type_states[p->type].referenced = 1;
+                        break;
+                }
+                case BTF_KIND_DATASEC: {
+                        const struct btf_var_secinfo *v = btf_var_secinfos(t);
+
+                        for (j = 0; j < vlen; j++, v++)
+                                d->type_states[v->type].referenced = 1;
+                        break;
+                }
+                default:
+                        return -EINVAL;
+                }
+        }
+        return 0;
+}
 static int btf_dump_add_emit_queue_id(struct btf_dump *d, __u32 id)
 {
         __u32 *new_queue;
@@ -395,7 +476,12 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr)
         }
         case BTF_KIND_ENUM:
         case BTF_KIND_FWD:
-                if (t->name_off != 0) {
+                /*
+                 * non-anonymous or non-referenced enums are top-level
+                 * declarations and should be emitted. Same logic can be
+                 * applied to FWDs, it won't hurt anyways.
+                 */
+                if (t->name_off != 0 || !tstate->referenced) {
                         err = btf_dump_add_emit_queue_id(d, id);
                         if (err)
                                 return err;
@@ -536,11 +622,6 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id)
         t = btf__type_by_id(d->btf, id);
         kind = btf_kind(t);
 
-        if (top_level_def && t->name_off == 0) {
-                pr_warning("unexpected nameless definition, id:[%u]\n", id);
-                return;
-        }
-
         if (tstate->emit_state == EMITTING) {
                 if (tstate->fwd_emitted)
                         return;