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_int128_print(json_writer_t *jw, const void *data,
  77                              bool is_plain_text)
  78 {
  79         /* data points to a __int128 number.
  80          * Suppose
  81          *     int128_num = *(__int128 *)data;
  82          * The below formulas shows what upper_num and lower_num represents:
  83          *     upper_num = int128_num >> 64;
  84          *     lower_num = int128_num & 0xffffffffFFFFFFFFULL;
  85          */
  86         __u64 upper_num, lower_num;
  87
  88 #ifdef __BIG_ENDIAN_BITFIELD
  89         upper_num = *(__u64 *)data;
  90         lower_num = *(__u64 *)(data + 8);
  91 #else
  92         upper_num = *(__u64 *)(data + 8);
  93         lower_num = *(__u64 *)data;
  94 #endif
  95
  96         if (is_plain_text) {
  97                 if (upper_num == 0)
  98                         jsonw_printf(jw, "0x%llx", lower_num);
  99                 else
 100                         jsonw_printf(jw, "0x%llx%016llx", upper_num, lower_num);
 101         } else {
 102                 if (upper_num == 0)
 103                         jsonw_printf(jw, "\"0x%llx\"", lower_num);
 104                 else
 105                         jsonw_printf(jw, "\"0x%llx%016llx\"", upper_num, lower_num);
 106         }
 107 }
 108
 109 static void btf_int128_shift(__u64 *print_num, u16 left_shift_bits,
 110                              u16 right_shift_bits)
 111 {
 112         __u64 upper_num, lower_num;
 113
 114 #ifdef __BIG_ENDIAN_BITFIELD
 115         upper_num = print_num[0];
 116         lower_num = print_num[1];
 117 #else
 118         upper_num = print_num[1];
 119         lower_num = print_num[0];
 120 #endif
 121
 122         /* shake out un-needed bits by shift/or operations */
 123         if (left_shift_bits >= 64) {
 124                 upper_num = lower_num << (left_shift_bits - 64);
 125                 lower_num = 0;
 126         } else {
 127                 upper_num = (upper_num << left_shift_bits) |
 128                             (lower_num >> (64 - left_shift_bits));
 129                 lower_num = lower_num << left_shift_bits;
 130         }
 131
 132         if (right_shift_bits >= 64) {
 133                 lower_num = upper_num >> (right_shift_bits - 64);
 134                 upper_num = 0;
 135         } else {
 136                 lower_num = (lower_num >> right_shift_bits) |
 137                             (upper_num << (64 - right_shift_bits));
 138                 upper_num = upper_num >> right_shift_bits;
 139         }
 140
 141 #ifdef __BIG_ENDIAN_BITFIELD
 142         print_num[0] = upper_num;
 143         print_num[1] = lower_num;
 144 #else
 145         print_num[0] = lower_num;
 146         print_num[1] = upper_num;
 147 #endif
 148 }
 149
 150 static void btf_dumper_bitfield(__u32 nr_bits, __u8 bit_offset,
 151                                 const void *data, json_writer_t *jw,
 152                                 bool is_plain_text)
 153 {
 154         int left_shift_bits, right_shift_bits;
 155         __u64 print_num[2] = {};
 156         int bytes_to_copy;
 157         int bits_to_copy;
 158
 159         bits_to_copy = bit_offset + nr_bits;
 160         bytes_to_copy = BITS_ROUNDUP_BYTES(bits_to_copy);
 161
 162         memcpy(print_num, data, bytes_to_copy);
 163 #if defined(__BIG_ENDIAN_BITFIELD)
 164         left_shift_bits = bit_offset;
 165 #elif defined(__LITTLE_ENDIAN_BITFIELD)
 166         left_shift_bits = 128 - bits_to_copy;
 167 #else
 168 #error neither big nor little endian
 169 #endif
 170         right_shift_bits = 128 - nr_bits;
 171
 172         btf_int128_shift(print_num, left_shift_bits, right_shift_bits);
 173         btf_int128_print(jw, print_num, is_plain_text);
 174 }
 175
 176
 177 static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
 178                                 const void *data, json_writer_t *jw,
 179                                 bool is_plain_text)
 180 {
 181         int nr_bits = BTF_INT_BITS(int_type);
 182         int total_bits_offset;
 183
 184         /* bits_offset is at most 7.
 185          * BTF_INT_OFFSET() cannot exceed 128 bits.
 186          */
 187         total_bits_offset = bit_offset + BTF_INT_OFFSET(int_type);
 188         data += BITS_ROUNDDOWN_BYTES(total_bits_offset);
 189         bit_offset = BITS_PER_BYTE_MASKED(total_bits_offset);
 190         btf_dumper_bitfield(nr_bits, bit_offset, data, jw,
 191                             is_plain_text);
 192 }
 193
 194 static int btf_dumper_int(const struct btf_type *t, __u8 bit_offset,
 195                           const void *data, json_writer_t *jw,
 196                           bool is_plain_text)
 197 {
 198         __u32 *int_type;
 199         __u32 nr_bits;
 200
 201         int_type = (__u32 *)(t + 1);
 202         nr_bits = BTF_INT_BITS(*int_type);
 203         /* if this is bit field */
 204         if (bit_offset || BTF_INT_OFFSET(*int_type) ||
 205             BITS_PER_BYTE_MASKED(nr_bits)) {
 206                 btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 207                                     is_plain_text);
 208                 return 0;
 209         }
 210
 211         if (nr_bits == 128) {
 212                 btf_int128_print(jw, data, is_plain_text);
 213                 return 0;
 214         }
 215
 216         switch (BTF_INT_ENCODING(*int_type)) {
 217         case 0:
 218                 if (BTF_INT_BITS(*int_type) == 64)
 219                         jsonw_printf(jw, "%lu", *(__u64 *)data);
 220                 else if (BTF_INT_BITS(*int_type) == 32)
 221                         jsonw_printf(jw, "%u", *(__u32 *)data);
 222                 else if (BTF_INT_BITS(*int_type) == 16)
 223                         jsonw_printf(jw, "%hu", *(__u16 *)data);
 224                 else if (BTF_INT_BITS(*int_type) == 8)
 225                         jsonw_printf(jw, "%hhu", *(__u8 *)data);
 226                 else
 227                         btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 228                                             is_plain_text);
 229                 break;
 230         case BTF_INT_SIGNED:
 231                 if (BTF_INT_BITS(*int_type) == 64)
 232                         jsonw_printf(jw, "%ld", *(long long *)data);
 233                 else if (BTF_INT_BITS(*int_type) == 32)
 234                         jsonw_printf(jw, "%d", *(int *)data);
 235                 else if (BTF_INT_BITS(*int_type) == 16)
 236                         jsonw_printf(jw, "%hd", *(short *)data);
 237                 else if (BTF_INT_BITS(*int_type) == 8)
 238                         jsonw_printf(jw, "%hhd", *(char *)data);
 239                 else
 240                         btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 241                                             is_plain_text);
 242                 break;
 243         case BTF_INT_CHAR:
 244                 if (isprint(*(char *)data))
 245                         jsonw_printf(jw, "\"%c\"", *(char *)data);
 246                 else
 247                         if (is_plain_text)
 248                                 jsonw_printf(jw, "0x%hhx", *(char *)data);
 249                         else
 250                                 jsonw_printf(jw, "\"\\u00%02hhx\"",
 251                                              *(char *)data);
 252                 break;
 253         case BTF_INT_BOOL:
 254                 jsonw_bool(jw, *(int *)data);
 255                 break;
 256         default:
 257                 /* shouldn't happen */
 258                 return -EINVAL;
 259         }
 260
 261         return 0;
 262 }
 263
 264 static int btf_dumper_struct(const struct btf_dumper *d, __u32 type_id,
 265                              const void *data)
 266 {
 267         const struct btf_type *t;
 268         struct btf_member *m;
 269         const void *data_off;
 270         int kind_flag;
 271         int ret = 0;
 272         int i, vlen;
 273
 274         t = btf__type_by_id(d->btf, type_id);
 275         if (!t)
 276                 return -EINVAL;
 277
 278         kind_flag = BTF_INFO_KFLAG(t->info);
 279         vlen = BTF_INFO_VLEN(t->info);
 280         jsonw_start_object(d->jw);
 281         m = (struct btf_member *)(t + 1);
 282
 283         for (i = 0; i < vlen; i++) {
 284                 __u32 bit_offset = m[i].offset;
 285                 __u32 bitfield_size = 0;
 286
 287                 if (kind_flag) {
 288                         bitfield_size = BTF_MEMBER_BITFIELD_SIZE(bit_offset);
 289                         bit_offset = BTF_MEMBER_BIT_OFFSET(bit_offset);
 290                 }
 291
 292                 jsonw_name(d->jw, btf__name_by_offset(d->btf, m[i].name_off));
 293                 data_off = data + BITS_ROUNDDOWN_BYTES(bit_offset);
 294                 if (bitfield_size) {
 295                         btf_dumper_bitfield(bitfield_size,
 296                                             BITS_PER_BYTE_MASKED(bit_offset),
 297                                             data_off, d->jw, d->is_plain_text);
 298                 } else {
 299                         ret = btf_dumper_do_type(d, m[i].type,
 300                                                  BITS_PER_BYTE_MASKED(bit_offset),
 301                                                  data_off);
 302                         if (ret)
 303                                 break;
 304                 }
 305         }
 306
 307         jsonw_end_object(d->jw);
 308
 309         return ret;
 310 }
 311
 312 static int btf_dumper_var(const struct btf_dumper *d, __u32 type_id,
 313                           __u8 bit_offset, const void *data)
 314 {
 315         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
 316         int ret;
 317
 318         jsonw_start_object(d->jw);
 319         jsonw_name(d->jw, btf__name_by_offset(d->btf, t->name_off));
 320         ret = btf_dumper_do_type(d, t->type, bit_offset, data);
 321         jsonw_end_object(d->jw);
 322
 323         return ret;
 324 }
 325
 326 static int btf_dumper_datasec(const struct btf_dumper *d, __u32 type_id,
 327                               const void *data)
 328 {
 329         struct btf_var_secinfo *vsi;
 330         const struct btf_type *t;
 331         int ret = 0, i, vlen;
 332
 333         t = btf__type_by_id(d->btf, type_id);
 334         if (!t)
 335                 return -EINVAL;
 336
 337         vlen = BTF_INFO_VLEN(t->info);
 338         vsi = (struct btf_var_secinfo *)(t + 1);
 339
 340         jsonw_start_object(d->jw);
 341         jsonw_name(d->jw, btf__name_by_offset(d->btf, t->name_off));
 342         jsonw_start_array(d->jw);
 343         for (i = 0; i < vlen; i++) {
 344                 ret = btf_dumper_do_type(d, vsi[i].type, 0, data + vsi[i].offset);
 345                 if (ret)
 346                         break;
 347         }
 348         jsonw_end_array(d->jw);
 349         jsonw_end_object(d->jw);
 350
 351         return ret;
 352 }
 353
 354 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
 355                               __u8 bit_offset, const void *data)
 356 {
 357         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
 358
 359         switch (BTF_INFO_KIND(t->info)) {
 360         case BTF_KIND_INT:
 361                 return btf_dumper_int(t, bit_offset, data, d->jw,
 362                                      d->is_plain_text);
 363         case BTF_KIND_STRUCT:
 364         case BTF_KIND_UNION:
 365                 return btf_dumper_struct(d, type_id, data);
 366         case BTF_KIND_ARRAY:
 367                 return btf_dumper_array(d, type_id, data);
 368         case BTF_KIND_ENUM:
 369                 btf_dumper_enum(data, d->jw);
 370                 return 0;
 371         case BTF_KIND_PTR:
 372                 btf_dumper_ptr(data, d->jw, d->is_plain_text);
 373                 return 0;
 374         case BTF_KIND_UNKN:
 375                 jsonw_printf(d->jw, "(unknown)");
 376                 return 0;
 377         case BTF_KIND_FWD:
 378                 /* map key or value can't be forward */
 379                 jsonw_printf(d->jw, "(fwd-kind-invalid)");
 380                 return -EINVAL;
 381         case BTF_KIND_TYPEDEF:
 382         case BTF_KIND_VOLATILE:
 383         case BTF_KIND_CONST:
 384         case BTF_KIND_RESTRICT:
 385                 return btf_dumper_modifier(d, type_id, bit_offset, data);
 386         case BTF_KIND_VAR:
 387                 return btf_dumper_var(d, type_id, bit_offset, data);
 388         case BTF_KIND_DATASEC:
 389                 return btf_dumper_datasec(d, type_id, data);
 390         default:
 391                 jsonw_printf(d->jw, "(unsupported-kind");
 392                 return -EINVAL;
 393         }
 394 }
 395
 396 int btf_dumper_type(const struct btf_dumper *d, __u32 type_id,
 397                     const void *data)
 398 {
 399         return btf_dumper_do_type(d, type_id, 0, data);
 400 }
 401
 402 #define BTF_PRINT_ARG(...)                                              \
 403         do {                                                            \
 404                 pos += snprintf(func_sig + pos, size - pos,             \
 405                                 __VA_ARGS__);                           \
 406                 if (pos >= size)                                        \
 407                         return -1;                                      \
 408         } while (0)
 409 #define BTF_PRINT_TYPE(type)                                    \
 410         do {                                                            \
 411                 pos = __btf_dumper_type_only(btf, type, func_sig,       \
 412                                              pos, size);                \
 413                 if (pos == -1)                                          \
 414                         return -1;                                      \
 415         } while (0)
 416
 417 static int btf_dump_func(const struct btf *btf, char *func_sig,
 418                          const struct btf_type *func_proto,
 419                          const struct btf_type *func, int pos, int size);
 420
 421 static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,
 422                                   char *func_sig, int pos, int size)
 423 {
 424         const struct btf_type *proto_type;
 425         const struct btf_array *array;
 426         const struct btf_var *var;
 427         const struct btf_type *t;
 428
 429         if (!type_id) {
 430                 BTF_PRINT_ARG("void ");
 431                 return pos;
 432         }
 433
 434         t = btf__type_by_id(btf, type_id);
 435
 436         switch (BTF_INFO_KIND(t->info)) {
 437         case BTF_KIND_INT:
 438         case BTF_KIND_TYPEDEF:
 439                 BTF_PRINT_ARG("%s ", btf__name_by_offset(btf, t->name_off));
 440                 break;
 441         case BTF_KIND_STRUCT:
 442                 BTF_PRINT_ARG("struct %s ",
 443                               btf__name_by_offset(btf, t->name_off));
 444                 break;
 445         case BTF_KIND_UNION:
 446                 BTF_PRINT_ARG("union %s ",
 447                               btf__name_by_offset(btf, t->name_off));
 448                 break;
 449         case BTF_KIND_ENUM:
 450                 BTF_PRINT_ARG("enum %s ",
 451                               btf__name_by_offset(btf, t->name_off));
 452                 break;
 453         case BTF_KIND_ARRAY:
 454                 array = (struct btf_array *)(t + 1);
 455                 BTF_PRINT_TYPE(array->type);
 456                 BTF_PRINT_ARG("[%d]", array->nelems);
 457                 break;
 458         case BTF_KIND_PTR:
 459                 BTF_PRINT_TYPE(t->type);
 460                 BTF_PRINT_ARG("* ");
 461                 break;
 462         case BTF_KIND_FWD:
 463                 BTF_PRINT_ARG("%s %s ",
 464                               BTF_INFO_KFLAG(t->info) ? "union" : "struct",
 465                               btf__name_by_offset(btf, t->name_off));
 466                 break;
 467         case BTF_KIND_VOLATILE:
 468                 BTF_PRINT_ARG("volatile ");
 469                 BTF_PRINT_TYPE(t->type);
 470                 break;
 471         case BTF_KIND_CONST:
 472                 BTF_PRINT_ARG("const ");
 473                 BTF_PRINT_TYPE(t->type);
 474                 break;
 475         case BTF_KIND_RESTRICT:
 476                 BTF_PRINT_ARG("restrict ");
 477                 BTF_PRINT_TYPE(t->type);
 478                 break;
 479         case BTF_KIND_FUNC_PROTO:
 480                 pos = btf_dump_func(btf, func_sig, t, NULL, pos, size);
 481                 if (pos == -1)
 482                         return -1;
 483                 break;
 484         case BTF_KIND_FUNC:
 485                 proto_type = btf__type_by_id(btf, t->type);
 486                 pos = btf_dump_func(btf, func_sig, proto_type, t, pos, size);
 487                 if (pos == -1)
 488                         return -1;
 489                 break;
 490         case BTF_KIND_VAR:
 491                 var = (struct btf_var *)(t + 1);
 492                 if (var->linkage == BTF_VAR_STATIC)
 493                         BTF_PRINT_ARG("static ");
 494                 BTF_PRINT_TYPE(t->type);
 495                 BTF_PRINT_ARG(" %s",
 496                               btf__name_by_offset(btf, t->name_off));
 497                 break;
 498         case BTF_KIND_DATASEC:
 499                 BTF_PRINT_ARG("section (\"%s\") ",
 500                               btf__name_by_offset(btf, t->name_off));
 501                 break;
 502         case BTF_KIND_UNKN:
 503         default:
 504                 return -1;
 505         }
 506
 507         return pos;
 508 }
 509
 510 static int btf_dump_func(const struct btf *btf, char *func_sig,
 511                          const struct btf_type *func_proto,
 512                          const struct btf_type *func, int pos, int size)
 513 {
 514         int i, vlen;
 515
 516         BTF_PRINT_TYPE(func_proto->type);
 517         if (func)
 518                 BTF_PRINT_ARG("%s(", btf__name_by_offset(btf, func->name_off));
 519         else
 520                 BTF_PRINT_ARG("(");
 521         vlen = BTF_INFO_VLEN(func_proto->info);
 522         for (i = 0; i < vlen; i++) {
 523                 struct btf_param *arg = &((struct btf_param *)(func_proto + 1))[i];
 524
 525                 if (i)
 526                         BTF_PRINT_ARG(", ");
 527                 if (arg->type) {
 528                         BTF_PRINT_TYPE(arg->type);
 529                         BTF_PRINT_ARG("%s",
 530                                       btf__name_by_offset(btf, arg->name_off));
 531                 } else {
 532                         BTF_PRINT_ARG("...");
 533                 }
 534         }
 535         BTF_PRINT_ARG(")");
 536
 537         return pos;
 538 }
 539
 540 void btf_dumper_type_only(const struct btf *btf, __u32 type_id, char *func_sig,
 541                           int size)
 542 {
 543         int err;
 544
 545         func_sig[0] = '\0';
 546         if (!btf)
 547                 return;
 548
 549         err = __btf_dumper_type_only(btf, type_id, func_sig, 0, size);
 550         if (err < 0)
 551                 func_sig[0] = '\0';
 552 }
 553
 554 static const char *ltrim(const char *s)
 555 {
 556         while (isspace(*s))
 557                 s++;
 558
 559         return s;
 560 }
 561
 562 void btf_dump_linfo_plain(const struct btf *btf,
 563                           const struct bpf_line_info *linfo,
 564                           const char *prefix, bool linum)
 565 {
 566         const char *line = btf__name_by_offset(btf, linfo->line_off);
 567
 568         if (!line)
 569                 return;
 570         line = ltrim(line);
 571
 572         if (!prefix)
 573                 prefix = "";
 574
 575         if (linum) {
 576                 const char *file = btf__name_by_offset(btf, linfo->file_name_off);
 577
 578                 /* More forgiving on file because linum option is
 579                  * expected to provide more info than the already
 580                  * available src line.
 581                  */
 582                 if (!file)
 583                         file = "";
 584
 585                 printf("%s%s [file:%s line_num:%u line_col:%u]\n",
 586                        prefix, line, file,
 587                        BPF_LINE_INFO_LINE_NUM(linfo->line_col),
 588                        BPF_LINE_INFO_LINE_COL(linfo->line_col));
 589         } else {
 590                 printf("%s%s\n", prefix, line);
 591         }
 592 }
 593
 594 void btf_dump_linfo_json(const struct btf *btf,
 595                          const struct bpf_line_info *linfo, bool linum)
 596 {
 597         const char *line = btf__name_by_offset(btf, linfo->line_off);
 598
 599         if (line)
 600                 jsonw_string_field(json_wtr, "src", ltrim(line));
 601
 602         if (linum) {
 603                 const char *file = btf__name_by_offset(btf, linfo->file_name_off);
 604
 605                 if (file)
 606                         jsonw_string_field(json_wtr, "file", file);
 607
 608                 if (BPF_LINE_INFO_LINE_NUM(linfo->line_col))
 609                         jsonw_int_field(json_wtr, "line_num",
 610                                         BPF_LINE_INFO_LINE_NUM(linfo->line_col));
 611
 612                 if (BPF_LINE_INFO_LINE_COL(linfo->line_col))
 613                         jsonw_int_field(json_wtr, "line_col",
 614                                         BPF_LINE_INFO_LINE_COL(linfo->line_col));
 615         }
 616 }