tools/bpf/bpftool/btf_dumper.c

   1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
   2 /* Copyright (c) 2018 Facebook */
   3
   4 #include <ctype.h>
   5 #include <stdio.h> /* for (FILE *) used by json_writer */
   6 #include <string.h>
   7 #include <asm/byteorder.h>
   8 #include <linux/bitops.h>
   9 #include <linux/btf.h>
  10 #include <linux/err.h>
  11
  12 #include "btf.h"
  13 #include "json_writer.h"
  14 #include "main.h"
  15
  16 #define BITS_PER_BYTE_MASK (BITS_PER_BYTE - 1)
  17 #define BITS_PER_BYTE_MASKED(bits) ((bits) & BITS_PER_BYTE_MASK)
  18 #define BITS_ROUNDDOWN_BYTES(bits) ((bits) >> 3)
  19 #define BITS_ROUNDUP_BYTES(bits) \
  20         (BITS_ROUNDDOWN_BYTES(bits) + !!BITS_PER_BYTE_MASKED(bits))
  21
  22 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
  23                               __u8 bit_offset, const void *data);
  24
  25 static void btf_dumper_ptr(const void *data, json_writer_t *jw,
  26                            bool is_plain_text)
  27 {
  28         if (is_plain_text)
  29                 jsonw_printf(jw, "%p", *(unsigned long *)data);
  30         else
  31                 jsonw_printf(jw, "%u", *(unsigned long *)data);
  32 }
  33
  34 static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,
  35                                __u8 bit_offset, const void *data)
  36 {
  37         int actual_type_id;
  38
  39         actual_type_id = btf__resolve_type(d->btf, type_id);
  40         if (actual_type_id < 0)
  41                 return actual_type_id;
  42
  43         return btf_dumper_do_type(d, actual_type_id, bit_offset, data);
  44 }
  45
  46 static void btf_dumper_enum(const void *data, json_writer_t *jw)
  47 {
  48         jsonw_printf(jw, "%d", *(int *)data);
  49 }
  50
  51 static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,
  52                             const void *data)
  53 {
  54         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
  55         struct btf_array *arr = (struct btf_array *)(t + 1);
  56         long long elem_size;
  57         int ret = 0;
  58         __u32 i;
  59
  60         elem_size = btf__resolve_size(d->btf, arr->type);
  61         if (elem_size < 0)
  62                 return elem_size;
  63
  64         jsonw_start_array(d->jw);
  65         for (i = 0; i < arr->nelems; i++) {
  66                 ret = btf_dumper_do_type(d, arr->type, 0,
  67                                          data + i * elem_size);
  68                 if (ret)
  69                         break;
  70         }
  71
  72         jsonw_end_array(d->jw);
  73         return ret;
  74 }
  75
  76 static void btf_dumper_bitfield(__u32 nr_bits, __u8 bit_offset,
  77                                 const void *data, json_writer_t *jw,
  78                                 bool is_plain_text)
  79 {
  80         int left_shift_bits, right_shift_bits;
  81         int bytes_to_copy;
  82         int bits_to_copy;
  83         __u64 print_num;
  84
  85         bits_to_copy = bit_offset + nr_bits;
  86         bytes_to_copy = BITS_ROUNDUP_BYTES(bits_to_copy);
  87
  88         print_num = 0;
  89         memcpy(&print_num, data, bytes_to_copy);
  90 #if defined(__BIG_ENDIAN_BITFIELD)
  91         left_shift_bits = bit_offset;
  92 #elif defined(__LITTLE_ENDIAN_BITFIELD)
  93         left_shift_bits = 64 - bits_to_copy;
  94 #else
  95 #error neither big nor little endian
  96 #endif
  97         right_shift_bits = 64 - nr_bits;
  98
  99         print_num <<= left_shift_bits;
 100         print_num >>= right_shift_bits;
 101         if (is_plain_text)
 102                 jsonw_printf(jw, "0x%llx", print_num);
 103         else
 104                 jsonw_printf(jw, "%llu", print_num);
 105 }
 106
 107
 108 static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
 109                                 const void *data, json_writer_t *jw,
 110                                 bool is_plain_text)
 111 {
 112         int nr_bits = BTF_INT_BITS(int_type);
 113         int total_bits_offset;
 114
 115         /* bits_offset is at most 7.
 116          * BTF_INT_OFFSET() cannot exceed 64 bits.
 117          */
 118         total_bits_offset = bit_offset + BTF_INT_OFFSET(int_type);
 119         data += BITS_ROUNDDOWN_BYTES(total_bits_offset);
 120         bit_offset = BITS_PER_BYTE_MASKED(total_bits_offset);
 121         btf_dumper_bitfield(nr_bits, bit_offset, data, jw,
 122                             is_plain_text);
 123 }
 124
 125 static int btf_dumper_int(const struct btf_type *t, __u8 bit_offset,
 126                           const void *data, json_writer_t *jw,
 127                           bool is_plain_text)
 128 {
 129         __u32 *int_type;
 130         __u32 nr_bits;
 131
 132         int_type = (__u32 *)(t + 1);
 133         nr_bits = BTF_INT_BITS(*int_type);
 134         /* if this is bit field */
 135         if (bit_offset || BTF_INT_OFFSET(*int_type) ||
 136             BITS_PER_BYTE_MASKED(nr_bits)) {
 137                 btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 138                                     is_plain_text);
 139                 return 0;
 140         }
 141
 142         switch (BTF_INT_ENCODING(*int_type)) {
 143         case 0:
 144                 if (BTF_INT_BITS(*int_type) == 64)
 145                         jsonw_printf(jw, "%lu", *(__u64 *)data);
 146                 else if (BTF_INT_BITS(*int_type) == 32)
 147                         jsonw_printf(jw, "%u", *(__u32 *)data);
 148                 else if (BTF_INT_BITS(*int_type) == 16)
 149                         jsonw_printf(jw, "%hu", *(__u16 *)data);
 150                 else if (BTF_INT_BITS(*int_type) == 8)
 151                         jsonw_printf(jw, "%hhu", *(__u8 *)data);
 152                 else
 153                         btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 154                                             is_plain_text);
 155                 break;
 156         case BTF_INT_SIGNED:
 157                 if (BTF_INT_BITS(*int_type) == 64)
 158                         jsonw_printf(jw, "%ld", *(long long *)data);
 159                 else if (BTF_INT_BITS(*int_type) == 32)
 160                         jsonw_printf(jw, "%d", *(int *)data);
 161                 else if (BTF_INT_BITS(*int_type) == 16)
 162                         jsonw_printf(jw, "%hd", *(short *)data);
 163                 else if (BTF_INT_BITS(*int_type) == 8)
 164                         jsonw_printf(jw, "%hhd", *(char *)data);
 165                 else
 166                         btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 167                                             is_plain_text);
 168                 break;
 169         case BTF_INT_CHAR:
 170                 if (isprint(*(char *)data))
 171                         jsonw_printf(jw, "\"%c\"", *(char *)data);
 172                 else
 173                         if (is_plain_text)
 174                                 jsonw_printf(jw, "0x%hhx", *(char *)data);
 175                         else
 176                                 jsonw_printf(jw, "\"\\u00%02hhx\"",
 177                                              *(char *)data);
 178                 break;
 179         case BTF_INT_BOOL:
 180                 jsonw_bool(jw, *(int *)data);
 181                 break;
 182         default:
 183                 /* shouldn't happen */
 184                 return -EINVAL;
 185         }
 186
 187         return 0;
 188 }
 189
 190 static int btf_dumper_struct(const struct btf_dumper *d, __u32 type_id,
 191                              const void *data)
 192 {
 193         const struct btf_type *t;
 194         struct btf_member *m;
 195         const void *data_off;
 196         int kind_flag;
 197         int ret = 0;
 198         int i, vlen;
 199
 200         t = btf__type_by_id(d->btf, type_id);
 201         if (!t)
 202                 return -EINVAL;
 203
 204         kind_flag = BTF_INFO_KFLAG(t->info);
 205         vlen = BTF_INFO_VLEN(t->info);
 206         jsonw_start_object(d->jw);
 207         m = (struct btf_member *)(t + 1);
 208
 209         for (i = 0; i < vlen; i++) {
 210                 __u32 bit_offset = m[i].offset;
 211                 __u32 bitfield_size = 0;
 212
 213                 if (kind_flag) {
 214                         bitfield_size = BTF_MEMBER_BITFIELD_SIZE(bit_offset);
 215                         bit_offset = BTF_MEMBER_BIT_OFFSET(bit_offset);
 216                 }
 217
 218                 jsonw_name(d->jw, btf__name_by_offset(d->btf, m[i].name_off));
 219                 data_off = data + BITS_ROUNDDOWN_BYTES(bit_offset);
 220                 if (bitfield_size) {
 221                         btf_dumper_bitfield(bitfield_size,
 222                                             BITS_PER_BYTE_MASKED(bit_offset),
 223                                             data_off, d->jw, d->is_plain_text);
 224                 } else {
 225                         ret = btf_dumper_do_type(d, m[i].type,
 226                                                  BITS_PER_BYTE_MASKED(bit_offset),
 227                                                  data_off);
 228                         if (ret)
 229                                 break;
 230                 }
 231         }
 232
 233         jsonw_end_object(d->jw);
 234
 235         return ret;
 236 }
 237
 238 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
 239                               __u8 bit_offset, const void *data)
 240 {
 241         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
 242
 243         switch (BTF_INFO_KIND(t->info)) {
 244         case BTF_KIND_INT:
 245                 return btf_dumper_int(t, bit_offset, data, d->jw,
 246                                      d->is_plain_text);
 247         case BTF_KIND_STRUCT:
 248         case BTF_KIND_UNION:
 249                 return btf_dumper_struct(d, type_id, data);
 250         case BTF_KIND_ARRAY:
 251                 return btf_dumper_array(d, type_id, data);
 252         case BTF_KIND_ENUM:
 253                 btf_dumper_enum(data, d->jw);
 254                 return 0;
 255         case BTF_KIND_PTR:
 256                 btf_dumper_ptr(data, d->jw, d->is_plain_text);
 257                 return 0;
 258         case BTF_KIND_UNKN:
 259                 jsonw_printf(d->jw, "(unknown)");
 260                 return 0;
 261         case BTF_KIND_FWD:
 262                 /* map key or value can't be forward */
 263                 jsonw_printf(d->jw, "(fwd-kind-invalid)");
 264                 return -EINVAL;
 265         case BTF_KIND_TYPEDEF:
 266         case BTF_KIND_VOLATILE:
 267         case BTF_KIND_CONST:
 268         case BTF_KIND_RESTRICT:
 269                 return btf_dumper_modifier(d, type_id, bit_offset, data);
 270         default:
 271                 jsonw_printf(d->jw, "(unsupported-kind");
 272                 return -EINVAL;
 273         }
 274 }
 275
 276 int btf_dumper_type(const struct btf_dumper *d, __u32 type_id,
 277                     const void *data)
 278 {
 279         return btf_dumper_do_type(d, type_id, 0, data);
 280 }
 281
 282 #define BTF_PRINT_ARG(...)                                              \
 283         do {                                                            \
 284                 pos += snprintf(func_sig + pos, size - pos,             \
 285                                 __VA_ARGS__);                           \
 286                 if (pos >= size)                                        \
 287                         return -1;                                      \
 288         } while (0)
 289 #define BTF_PRINT_TYPE(type)                                    \
 290         do {                                                            \
 291                 pos = __btf_dumper_type_only(btf, type, func_sig,       \
 292                                              pos, size);                \
 293                 if (pos == -1)                                          \
 294                         return -1;                                      \
 295         } while (0)
 296
 297 static int btf_dump_func(const struct btf *btf, char *func_sig,
 298                          const struct btf_type *func_proto,
 299                          const struct btf_type *func, int pos, int size);
 300
 301 static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,
 302                                   char *func_sig, int pos, int size)
 303 {
 304         const struct btf_type *proto_type;
 305         const struct btf_array *array;
 306         const struct btf_type *t;
 307
 308         if (!type_id) {
 309                 BTF_PRINT_ARG("void ");
 310                 return pos;
 311         }
 312
 313         t = btf__type_by_id(btf, type_id);
 314
 315         switch (BTF_INFO_KIND(t->info)) {
 316         case BTF_KIND_INT:
 317         case BTF_KIND_TYPEDEF:
 318                 BTF_PRINT_ARG("%s ", btf__name_by_offset(btf, t->name_off));
 319                 break;
 320         case BTF_KIND_STRUCT:
 321                 BTF_PRINT_ARG("struct %s ",
 322                               btf__name_by_offset(btf, t->name_off));
 323                 break;
 324         case BTF_KIND_UNION:
 325                 BTF_PRINT_ARG("union %s ",
 326                               btf__name_by_offset(btf, t->name_off));
 327                 break;
 328         case BTF_KIND_ENUM:
 329                 BTF_PRINT_ARG("enum %s ",
 330                               btf__name_by_offset(btf, t->name_off));
 331                 break;
 332         case BTF_KIND_ARRAY:
 333                 array = (struct btf_array *)(t + 1);
 334                 BTF_PRINT_TYPE(array->type);
 335                 BTF_PRINT_ARG("[%d]", array->nelems);
 336                 break;
 337         case BTF_KIND_PTR:
 338                 BTF_PRINT_TYPE(t->type);
 339                 BTF_PRINT_ARG("* ");
 340                 break;
 341         case BTF_KIND_FWD:
 342                 BTF_PRINT_ARG("%s %s ",
 343                               BTF_INFO_KFLAG(t->info) ? "union" : "struct",
 344                               btf__name_by_offset(btf, t->name_off));
 345                 break;
 346         case BTF_KIND_VOLATILE:
 347                 BTF_PRINT_ARG("volatile ");
 348                 BTF_PRINT_TYPE(t->type);
 349                 break;
 350         case BTF_KIND_CONST:
 351                 BTF_PRINT_ARG("const ");
 352                 BTF_PRINT_TYPE(t->type);
 353                 break;
 354         case BTF_KIND_RESTRICT:
 355                 BTF_PRINT_ARG("restrict ");
 356                 BTF_PRINT_TYPE(t->type);
 357                 break;
 358         case BTF_KIND_FUNC_PROTO:
 359                 pos = btf_dump_func(btf, func_sig, t, NULL, pos, size);
 360                 if (pos == -1)
 361                         return -1;
 362                 break;
 363         case BTF_KIND_FUNC:
 364                 proto_type = btf__type_by_id(btf, t->type);
 365                 pos = btf_dump_func(btf, func_sig, proto_type, t, pos, size);
 366                 if (pos == -1)
 367                         return -1;
 368                 break;
 369         case BTF_KIND_UNKN:
 370         default:
 371                 return -1;
 372         }
 373
 374         return pos;
 375 }
 376
 377 static int btf_dump_func(const struct btf *btf, char *func_sig,
 378                          const struct btf_type *func_proto,
 379                          const struct btf_type *func, int pos, int size)
 380 {
 381         int i, vlen;
 382
 383         BTF_PRINT_TYPE(func_proto->type);
 384         if (func)
 385                 BTF_PRINT_ARG("%s(", btf__name_by_offset(btf, func->name_off));
 386         else
 387                 BTF_PRINT_ARG("(");
 388         vlen = BTF_INFO_VLEN(func_proto->info);
 389         for (i = 0; i < vlen; i++) {
 390                 struct btf_param *arg = &((struct btf_param *)(func_proto + 1))[i];
 391
 392                 if (i)
 393                         BTF_PRINT_ARG(", ");
 394                 if (arg->type) {
 395                         BTF_PRINT_TYPE(arg->type);
 396                         BTF_PRINT_ARG("%s",
 397                                       btf__name_by_offset(btf, arg->name_off));
 398                 } else {
 399                         BTF_PRINT_ARG("...");
 400                 }
 401         }
 402         BTF_PRINT_ARG(")");
 403
 404         return pos;
 405 }
 406
 407 void btf_dumper_type_only(const struct btf *btf, __u32 type_id, char *func_sig,
 408                           int size)
 409 {
 410         int err;
 411
 412         func_sig[0] = '\0';
 413         if (!btf)
 414                 return;
 415
 416         err = __btf_dumper_type_only(btf, type_id, func_sig, 0, size);
 417         if (err < 0)
 418                 func_sig[0] = '\0';
 419 }
 420
 421 static const char *ltrim(const char *s)
 422 {
 423         while (isspace(*s))
 424                 s++;
 425
 426         return s;
 427 }
 428
 429 void btf_dump_linfo_plain(const struct btf *btf,
 430                           const struct bpf_line_info *linfo,
 431                           const char *prefix, bool linum)
 432 {
 433         const char *line = btf__name_by_offset(btf, linfo->line_off);
 434
 435         if (!line)
 436                 return;
 437         line = ltrim(line);
 438
 439         if (!prefix)
 440                 prefix = "";
 441
 442         if (linum) {
 443                 const char *file = btf__name_by_offset(btf, linfo->file_name_off);
 444
 445                 /* More forgiving on file because linum option is
 446                  * expected to provide more info than the already
 447                  * available src line.
 448                  */
 449                 if (!file)
 450                         file = "";
 451
 452                 printf("%s%s [file:%s line_num:%u line_col:%u]\n",
 453                        prefix, line, file,
 454                        BPF_LINE_INFO_LINE_NUM(linfo->line_col),
 455                        BPF_LINE_INFO_LINE_COL(linfo->line_col));
 456         } else {
 457                 printf("%s%s\n", prefix, line);
 458         }
 459 }
 460
 461 void btf_dump_linfo_json(const struct btf *btf,
 462                          const struct bpf_line_info *linfo, bool linum)
 463 {
 464         const char *line = btf__name_by_offset(btf, linfo->line_off);
 465
 466         if (line)
 467                 jsonw_string_field(json_wtr, "src", ltrim(line));
 468
 469         if (linum) {
 470                 const char *file = btf__name_by_offset(btf, linfo->file_name_off);
 471
 472                 if (file)
 473                         jsonw_string_field(json_wtr, "file", file);
 474
 475                 if (BPF_LINE_INFO_LINE_NUM(linfo->line_col))
 476                         jsonw_int_field(json_wtr, "line_num",
 477                                         BPF_LINE_INFO_LINE_NUM(linfo->line_col));
 478
 479                 if (BPF_LINE_INFO_LINE_COL(linfo->line_col))
 480                         jsonw_int_field(json_wtr, "line_col",
 481                                         BPF_LINE_INFO_LINE_COL(linfo->line_col));
 482         }
 483 }