tools/testing/selftests/bpf/btf_helpers.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2020 Facebook */
   3 #include <stdio.h>
   4 #include <errno.h>
   5 #include <bpf/btf.h>
   6 #include <bpf/libbpf.h>
   7 #include "test_progs.h"
   8
   9 static const char * const btf_kind_str_mapping[] = {
  10         [BTF_KIND_UNKN]         = "UNKNOWN",
  11         [BTF_KIND_INT]          = "INT",
  12         [BTF_KIND_PTR]          = "PTR",
  13         [BTF_KIND_ARRAY]        = "ARRAY",
  14         [BTF_KIND_STRUCT]       = "STRUCT",
  15         [BTF_KIND_UNION]        = "UNION",
  16         [BTF_KIND_ENUM]         = "ENUM",
  17         [BTF_KIND_FWD]          = "FWD",
  18         [BTF_KIND_TYPEDEF]      = "TYPEDEF",
  19         [BTF_KIND_VOLATILE]     = "VOLATILE",
  20         [BTF_KIND_CONST]        = "CONST",
  21         [BTF_KIND_RESTRICT]     = "RESTRICT",
  22         [BTF_KIND_FUNC]         = "FUNC",
  23         [BTF_KIND_FUNC_PROTO]   = "FUNC_PROTO",
  24         [BTF_KIND_VAR]          = "VAR",
  25         [BTF_KIND_DATASEC]      = "DATASEC",
  26         [BTF_KIND_FLOAT]        = "FLOAT",
  27         [BTF_KIND_DECL_TAG]     = "DECL_TAG",
  28         [BTF_KIND_TYPE_TAG]     = "TYPE_TAG",
  29         [BTF_KIND_ENUM64]       = "ENUM64",
  30 };
  31
  32 static const char *btf_kind_str(__u16 kind)
  33 {
  34         if (kind > BTF_KIND_ENUM64)
  35                 return "UNKNOWN";
  36         return btf_kind_str_mapping[kind];
  37 }
  38
  39 static const char *btf_int_enc_str(__u8 encoding)
  40 {
  41         switch (encoding) {
  42         case 0:
  43                 return "(none)";
  44         case BTF_INT_SIGNED:
  45                 return "SIGNED";
  46         case BTF_INT_CHAR:
  47                 return "CHAR";
  48         case BTF_INT_BOOL:
  49                 return "BOOL";
  50         default:
  51                 return "UNKN";
  52         }
  53 }
  54
  55 static const char *btf_var_linkage_str(__u32 linkage)
  56 {
  57         switch (linkage) {
  58         case BTF_VAR_STATIC:
  59                 return "static";
  60         case BTF_VAR_GLOBAL_ALLOCATED:
  61                 return "global-alloc";
  62         default:
  63                 return "(unknown)";
  64         }
  65 }
  66
  67 static const char *btf_func_linkage_str(const struct btf_type *t)
  68 {
  69         switch (btf_vlen(t)) {
  70         case BTF_FUNC_STATIC:
  71                 return "static";
  72         case BTF_FUNC_GLOBAL:
  73                 return "global";
  74         case BTF_FUNC_EXTERN:
  75                 return "extern";
  76         default:
  77                 return "(unknown)";
  78         }
  79 }
  80
  81 static const char *btf_str(const struct btf *btf, __u32 off)
  82 {
  83         if (!off)
  84                 return "(anon)";
  85         return btf__str_by_offset(btf, off) ?: "(invalid)";
  86 }
  87
  88 int fprintf_btf_type_raw(FILE *out, const struct btf *btf, __u32 id)
  89 {
  90         const struct btf_type *t;
  91         int kind, i;
  92         __u32 vlen;
  93
  94         t = btf__type_by_id(btf, id);
  95         if (!t)
  96                 return -EINVAL;
  97
  98         vlen = btf_vlen(t);
  99         kind = btf_kind(t);
 100
 101         fprintf(out, "[%u] %s '%s'", id, btf_kind_str(kind), btf_str(btf, t->name_off));
 102
 103         switch (kind) {
 104         case BTF_KIND_INT:
 105                 fprintf(out, " size=%u bits_offset=%u nr_bits=%u encoding=%s",
 106                         t->size, btf_int_offset(t), btf_int_bits(t),
 107                         btf_int_enc_str(btf_int_encoding(t)));
 108                 break;
 109         case BTF_KIND_PTR:
 110         case BTF_KIND_CONST:
 111         case BTF_KIND_VOLATILE:
 112         case BTF_KIND_RESTRICT:
 113         case BTF_KIND_TYPEDEF:
 114         case BTF_KIND_TYPE_TAG:
 115                 fprintf(out, " type_id=%u", t->type);
 116                 break;
 117         case BTF_KIND_ARRAY: {
 118                 const struct btf_array *arr = btf_array(t);
 119
 120                 fprintf(out, " type_id=%u index_type_id=%u nr_elems=%u",
 121                         arr->type, arr->index_type, arr->nelems);
 122                 break;
 123         }
 124         case BTF_KIND_STRUCT:
 125         case BTF_KIND_UNION: {
 126                 const struct btf_member *m = btf_members(t);
 127
 128                 fprintf(out, " size=%u vlen=%u", t->size, vlen);
 129                 for (i = 0; i < vlen; i++, m++) {
 130                         __u32 bit_off, bit_sz;
 131
 132                         bit_off = btf_member_bit_offset(t, i);
 133                         bit_sz = btf_member_bitfield_size(t, i);
 134                         fprintf(out, "\n\t'%s' type_id=%u bits_offset=%u",
 135                                 btf_str(btf, m->name_off), m->type, bit_off);
 136                         if (bit_sz)
 137                                 fprintf(out, " bitfield_size=%u", bit_sz);
 138                 }
 139                 break;
 140         }
 141         case BTF_KIND_ENUM: {
 142                 const struct btf_enum *v = btf_enum(t);
 143                 const char *fmt_str;
 144
 145                 fmt_str = btf_kflag(t) ? "\n\t'%s' val=%d" : "\n\t'%s' val=%u";
 146                 fprintf(out, " encoding=%s size=%u vlen=%u",
 147                         btf_kflag(t) ? "SIGNED" : "UNSIGNED", t->size, vlen);
 148                 for (i = 0; i < vlen; i++, v++) {
 149                         fprintf(out, fmt_str,
 150                                 btf_str(btf, v->name_off), v->val);
 151                 }
 152                 break;
 153         }
 154         case BTF_KIND_ENUM64: {
 155                 const struct btf_enum64 *v = btf_enum64(t);
 156                 const char *fmt_str;
 157
 158                 fmt_str = btf_kflag(t) ? "\n\t'%s' val=%lld" : "\n\t'%s' val=%llu";
 159
 160                 fprintf(out, " encoding=%s size=%u vlen=%u",
 161                         btf_kflag(t) ? "SIGNED" : "UNSIGNED", t->size, vlen);
 162                 for (i = 0; i < vlen; i++, v++) {
 163                         fprintf(out, fmt_str,
 164                                 btf_str(btf, v->name_off),
 165                                 ((__u64)v->val_hi32 << 32) | v->val_lo32);
 166                 }
 167                 break;
 168         }
 169         case BTF_KIND_FWD:
 170                 fprintf(out, " fwd_kind=%s", btf_kflag(t) ? "union" : "struct");
 171                 break;
 172         case BTF_KIND_FUNC:
 173                 fprintf(out, " type_id=%u linkage=%s", t->type, btf_func_linkage_str(t));
 174                 break;
 175         case BTF_KIND_FUNC_PROTO: {
 176                 const struct btf_param *p = btf_params(t);
 177
 178                 fprintf(out, " ret_type_id=%u vlen=%u", t->type, vlen);
 179                 for (i = 0; i < vlen; i++, p++) {
 180                         fprintf(out, "\n\t'%s' type_id=%u",
 181                                 btf_str(btf, p->name_off), p->type);
 182                 }
 183                 break;
 184         }
 185         case BTF_KIND_VAR:
 186                 fprintf(out, " type_id=%u, linkage=%s",
 187                         t->type, btf_var_linkage_str(btf_var(t)->linkage));
 188                 break;
 189         case BTF_KIND_DATASEC: {
 190                 const struct btf_var_secinfo *v = btf_var_secinfos(t);
 191
 192                 fprintf(out, " size=%u vlen=%u", t->size, vlen);
 193                 for (i = 0; i < vlen; i++, v++) {
 194                         fprintf(out, "\n\ttype_id=%u offset=%u size=%u",
 195                                 v->type, v->offset, v->size);
 196                 }
 197                 break;
 198         }
 199         case BTF_KIND_FLOAT:
 200                 fprintf(out, " size=%u", t->size);
 201                 break;
 202         case BTF_KIND_DECL_TAG:
 203                 fprintf(out, " type_id=%u component_idx=%d",
 204                         t->type, btf_decl_tag(t)->component_idx);
 205                 break;
 206         default:
 207                 break;
 208         }
 209
 210         return 0;
 211 }
 212
 213 /* Print raw BTF type dump into a local buffer and return string pointer back.
 214  * Buffer *will* be overwritten by subsequent btf_type_raw_dump() calls
 215  */
 216 const char *btf_type_raw_dump(const struct btf *btf, int type_id)
 217 {
 218         static char buf[16 * 1024];
 219         FILE *buf_file;
 220
 221         buf_file = fmemopen(buf, sizeof(buf) - 1, "w");
 222         if (!buf_file) {
 223                 fprintf(stderr, "Failed to open memstream: %d\n", errno);
 224                 return NULL;
 225         }
 226
 227         fprintf_btf_type_raw(buf_file, btf, type_id);
 228         fflush(buf_file);
 229         fclose(buf_file);
 230
 231         return buf;
 232 }
 233
 234 int btf_validate_raw(struct btf *btf, int nr_types, const char *exp_types[])
 235 {
 236         int i;
 237         bool ok = true;
 238
 239         ASSERT_EQ(btf__type_cnt(btf) - 1, nr_types, "btf_nr_types");
 240
 241         for (i = 1; i <= nr_types; i++) {
 242                 if (!ASSERT_STREQ(btf_type_raw_dump(btf, i), exp_types[i - 1], "raw_dump"))
 243                         ok = false;
 244         }
 245
 246         return ok;
 247 }
 248
 249 static void btf_dump_printf(void *ctx, const char *fmt, va_list args)
 250 {
 251         vfprintf(ctx, fmt, args);
 252 }
 253
 254 /* Print BTF-to-C dump into a local buffer and return string pointer back.
 255  * Buffer *will* be overwritten by subsequent btf_type_raw_dump() calls
 256  */
 257 const char *btf_type_c_dump(const struct btf *btf)
 258 {
 259         static char buf[16 * 1024];
 260         FILE *buf_file;
 261         struct btf_dump *d = NULL;
 262         int err, i;
 263
 264         buf_file = fmemopen(buf, sizeof(buf) - 1, "w");
 265         if (!buf_file) {
 266                 fprintf(stderr, "Failed to open memstream: %d\n", errno);
 267                 return NULL;
 268         }
 269
 270         d = btf_dump__new(btf, btf_dump_printf, buf_file, NULL);
 271         if (libbpf_get_error(d)) {
 272                 fprintf(stderr, "Failed to create btf_dump instance: %ld\n", libbpf_get_error(d));
 273                 goto err_out;
 274         }
 275
 276         for (i = 1; i < btf__type_cnt(btf); i++) {
 277                 err = btf_dump__dump_type(d, i);
 278                 if (err) {
 279                         fprintf(stderr, "Failed to dump type [%d]: %d\n", i, err);
 280                         goto err_out;
 281                 }
 282         }
 283
 284         btf_dump__free(d);
 285         fflush(buf_file);
 286         fclose(buf_file);
 287         return buf;
 288 err_out:
 289         btf_dump__free(d);
 290         fclose(buf_file);
 291         return NULL;
 292 }