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 <unistd.h>
   8 #include <asm/byteorder.h>
   9 #include <linux/bitops.h>
  10 #include <linux/btf.h>
  11 #include <linux/err.h>
  12 #include <bpf/btf.h>
  13 #include <bpf/bpf.h>
  14
  15 #include "json_writer.h"
  16 #include "main.h"
  17
  18 #define BITS_PER_BYTE_MASK (BITS_PER_BYTE - 1)
  19 #define BITS_PER_BYTE_MASKED(bits) ((bits) & BITS_PER_BYTE_MASK)
  20 #define BITS_ROUNDDOWN_BYTES(bits) ((bits) >> 3)
  21 #define BITS_ROUNDUP_BYTES(bits) \
  22         (BITS_ROUNDDOWN_BYTES(bits) + !!BITS_PER_BYTE_MASKED(bits))
  23
  24 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
  25                               __u8 bit_offset, const void *data);
  26
  27 static int btf_dump_func(const struct btf *btf, char *func_sig,
  28                          const struct btf_type *func_proto,
  29                          const struct btf_type *func, int pos, int size);
  30
  31 static int dump_prog_id_as_func_ptr(const struct btf_dumper *d,
  32                                     const struct btf_type *func_proto,
  33                                     __u32 prog_id)
  34 {
  35         struct bpf_prog_info_linear *prog_info = NULL;
  36         const struct btf_type *func_type;
  37         const char *prog_name = NULL;
  38         struct bpf_func_info *finfo;
  39         struct btf *prog_btf = NULL;
  40         struct bpf_prog_info *info;
  41         int prog_fd, func_sig_len;
  42         char prog_str[1024];
  43
  44         /* Get the ptr's func_proto */
  45         func_sig_len = btf_dump_func(d->btf, prog_str, func_proto, NULL, 0,
  46                                      sizeof(prog_str));
  47         if (func_sig_len == -1)
  48                 return -1;
  49
  50         if (!prog_id)
  51                 goto print;
  52
  53         /* Get the bpf_prog's name.  Obtain from func_info. */
  54         prog_fd = bpf_prog_get_fd_by_id(prog_id);
  55         if (prog_fd == -1)
  56                 goto print;
  57
  58         prog_info = bpf_program__get_prog_info_linear(prog_fd,
  59                                                 1UL << BPF_PROG_INFO_FUNC_INFO);
  60         close(prog_fd);
  61         if (IS_ERR(prog_info)) {
  62                 prog_info = NULL;
  63                 goto print;
  64         }
  65         info = &prog_info->info;
  66
  67         if (!info->btf_id || !info->nr_func_info ||
  68             btf__get_from_id(info->btf_id, &prog_btf))
  69                 goto print;
  70         finfo = u64_to_ptr(info->func_info);
  71         func_type = btf__type_by_id(prog_btf, finfo->type_id);
  72         if (!func_type || !btf_is_func(func_type))
  73                 goto print;
  74
  75         prog_name = btf__name_by_offset(prog_btf, func_type->name_off);
  76
  77 print:
  78         if (!prog_id)
  79                 snprintf(&prog_str[func_sig_len],
  80                          sizeof(prog_str) - func_sig_len, " 0");
  81         else if (prog_name)
  82                 snprintf(&prog_str[func_sig_len],
  83                          sizeof(prog_str) - func_sig_len,
  84                          " %s/prog_id:%u", prog_name, prog_id);
  85         else
  86                 snprintf(&prog_str[func_sig_len],
  87                          sizeof(prog_str) - func_sig_len,
  88                          " <unknown_prog_name>/prog_id:%u", prog_id);
  89
  90         prog_str[sizeof(prog_str) - 1] = '\0';
  91         jsonw_string(d->jw, prog_str);
  92         btf__free(prog_btf);
  93         free(prog_info);
  94         return 0;
  95 }
  96
  97 static void btf_dumper_ptr(const struct btf_dumper *d,
  98                            const struct btf_type *t,
  99                            const void *data)
 100 {
 101         unsigned long value = *(unsigned long *)data;
 102         const struct btf_type *ptr_type;
 103         __s32 ptr_type_id;
 104
 105         if (!d->prog_id_as_func_ptr || value > UINT32_MAX)
 106                 goto print_ptr_value;
 107
 108         ptr_type_id = btf__resolve_type(d->btf, t->type);
 109         if (ptr_type_id < 0)
 110                 goto print_ptr_value;
 111         ptr_type = btf__type_by_id(d->btf, ptr_type_id);
 112         if (!ptr_type || !btf_is_func_proto(ptr_type))
 113                 goto print_ptr_value;
 114
 115         if (!dump_prog_id_as_func_ptr(d, ptr_type, value))
 116                 return;
 117
 118 print_ptr_value:
 119         if (d->is_plain_text)
 120                 jsonw_printf(d->jw, "%p", (void *)value);
 121         else
 122                 jsonw_printf(d->jw, "%lu", value);
 123 }
 124
 125 static int btf_dumper_modifier(const struct btf_dumper *d, __u32 type_id,
 126                                __u8 bit_offset, const void *data)
 127 {
 128         int actual_type_id;
 129
 130         actual_type_id = btf__resolve_type(d->btf, type_id);
 131         if (actual_type_id < 0)
 132                 return actual_type_id;
 133
 134         return btf_dumper_do_type(d, actual_type_id, bit_offset, data);
 135 }
 136
 137 static int btf_dumper_enum(const struct btf_dumper *d,
 138                             const struct btf_type *t,
 139                             const void *data)
 140 {
 141         const struct btf_enum *enums = btf_enum(t);
 142         __s64 value;
 143         __u16 i;
 144
 145         switch (t->size) {
 146         case 8:
 147                 value = *(__s64 *)data;
 148                 break;
 149         case 4:
 150                 value = *(__s32 *)data;
 151                 break;
 152         case 2:
 153                 value = *(__s16 *)data;
 154                 break;
 155         case 1:
 156                 value = *(__s8 *)data;
 157                 break;
 158         default:
 159                 return -EINVAL;
 160         }
 161
 162         for (i = 0; i < btf_vlen(t); i++) {
 163                 if (value == enums[i].val) {
 164                         jsonw_string(d->jw,
 165                                      btf__name_by_offset(d->btf,
 166                                                          enums[i].name_off));
 167                         return 0;
 168                 }
 169         }
 170
 171         jsonw_int(d->jw, value);
 172         return 0;
 173 }
 174
 175 static bool is_str_array(const struct btf *btf, const struct btf_array *arr,
 176                          const char *s)
 177 {
 178         const struct btf_type *elem_type;
 179         const char *end_s;
 180
 181         if (!arr->nelems)
 182                 return false;
 183
 184         elem_type = btf__type_by_id(btf, arr->type);
 185         /* Not skipping typedef.  typedef to char does not count as
 186          * a string now.
 187          */
 188         while (elem_type && btf_is_mod(elem_type))
 189                 elem_type = btf__type_by_id(btf, elem_type->type);
 190
 191         if (!elem_type || !btf_is_int(elem_type) || elem_type->size != 1)
 192                 return false;
 193
 194         if (btf_int_encoding(elem_type) != BTF_INT_CHAR &&
 195             strcmp("char", btf__name_by_offset(btf, elem_type->name_off)))
 196                 return false;
 197
 198         end_s = s + arr->nelems;
 199         while (s < end_s) {
 200                 if (!*s)
 201                         return true;
 202                 if (*s <= 0x1f || *s >= 0x7f)
 203                         return false;
 204                 s++;
 205         }
 206
 207         /* '\0' is not found */
 208         return false;
 209 }
 210
 211 static int btf_dumper_array(const struct btf_dumper *d, __u32 type_id,
 212                             const void *data)
 213 {
 214         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
 215         struct btf_array *arr = (struct btf_array *)(t + 1);
 216         long long elem_size;
 217         int ret = 0;
 218         __u32 i;
 219
 220         if (is_str_array(d->btf, arr, data)) {
 221                 jsonw_string(d->jw, data);
 222                 return 0;
 223         }
 224
 225         elem_size = btf__resolve_size(d->btf, arr->type);
 226         if (elem_size < 0)
 227                 return elem_size;
 228
 229         jsonw_start_array(d->jw);
 230         for (i = 0; i < arr->nelems; i++) {
 231                 ret = btf_dumper_do_type(d, arr->type, 0,
 232                                          data + i * elem_size);
 233                 if (ret)
 234                         break;
 235         }
 236
 237         jsonw_end_array(d->jw);
 238         return ret;
 239 }
 240
 241 static void btf_int128_print(json_writer_t *jw, const void *data,
 242                              bool is_plain_text)
 243 {
 244         /* data points to a __int128 number.
 245          * Suppose
 246          *     int128_num = *(__int128 *)data;
 247          * The below formulas shows what upper_num and lower_num represents:
 248          *     upper_num = int128_num >> 64;
 249          *     lower_num = int128_num & 0xffffffffFFFFFFFFULL;
 250          */
 251         __u64 upper_num, lower_num;
 252
 253 #ifdef __BIG_ENDIAN_BITFIELD
 254         upper_num = *(__u64 *)data;
 255         lower_num = *(__u64 *)(data + 8);
 256 #else
 257         upper_num = *(__u64 *)(data + 8);
 258         lower_num = *(__u64 *)data;
 259 #endif
 260
 261         if (is_plain_text) {
 262                 if (upper_num == 0)
 263                         jsonw_printf(jw, "0x%llx", lower_num);
 264                 else
 265                         jsonw_printf(jw, "0x%llx%016llx", upper_num, lower_num);
 266         } else {
 267                 if (upper_num == 0)
 268                         jsonw_printf(jw, "\"0x%llx\"", lower_num);
 269                 else
 270                         jsonw_printf(jw, "\"0x%llx%016llx\"", upper_num, lower_num);
 271         }
 272 }
 273
 274 static void btf_int128_shift(__u64 *print_num, __u16 left_shift_bits,
 275                              __u16 right_shift_bits)
 276 {
 277         __u64 upper_num, lower_num;
 278
 279 #ifdef __BIG_ENDIAN_BITFIELD
 280         upper_num = print_num[0];
 281         lower_num = print_num[1];
 282 #else
 283         upper_num = print_num[1];
 284         lower_num = print_num[0];
 285 #endif
 286
 287         /* shake out un-needed bits by shift/or operations */
 288         if (left_shift_bits >= 64) {
 289                 upper_num = lower_num << (left_shift_bits - 64);
 290                 lower_num = 0;
 291         } else {
 292                 upper_num = (upper_num << left_shift_bits) |
 293                             (lower_num >> (64 - left_shift_bits));
 294                 lower_num = lower_num << left_shift_bits;
 295         }
 296
 297         if (right_shift_bits >= 64) {
 298                 lower_num = upper_num >> (right_shift_bits - 64);
 299                 upper_num = 0;
 300         } else {
 301                 lower_num = (lower_num >> right_shift_bits) |
 302                             (upper_num << (64 - right_shift_bits));
 303                 upper_num = upper_num >> right_shift_bits;
 304         }
 305
 306 #ifdef __BIG_ENDIAN_BITFIELD
 307         print_num[0] = upper_num;
 308         print_num[1] = lower_num;
 309 #else
 310         print_num[0] = lower_num;
 311         print_num[1] = upper_num;
 312 #endif
 313 }
 314
 315 static void btf_dumper_bitfield(__u32 nr_bits, __u8 bit_offset,
 316                                 const void *data, json_writer_t *jw,
 317                                 bool is_plain_text)
 318 {
 319         int left_shift_bits, right_shift_bits;
 320         __u64 print_num[2] = {};
 321         int bytes_to_copy;
 322         int bits_to_copy;
 323
 324         bits_to_copy = bit_offset + nr_bits;
 325         bytes_to_copy = BITS_ROUNDUP_BYTES(bits_to_copy);
 326
 327         memcpy(print_num, data, bytes_to_copy);
 328 #if defined(__BIG_ENDIAN_BITFIELD)
 329         left_shift_bits = bit_offset;
 330 #elif defined(__LITTLE_ENDIAN_BITFIELD)
 331         left_shift_bits = 128 - bits_to_copy;
 332 #else
 333 #error neither big nor little endian
 334 #endif
 335         right_shift_bits = 128 - nr_bits;
 336
 337         btf_int128_shift(print_num, left_shift_bits, right_shift_bits);
 338         btf_int128_print(jw, print_num, is_plain_text);
 339 }
 340
 341
 342 static void btf_dumper_int_bits(__u32 int_type, __u8 bit_offset,
 343                                 const void *data, json_writer_t *jw,
 344                                 bool is_plain_text)
 345 {
 346         int nr_bits = BTF_INT_BITS(int_type);
 347         int total_bits_offset;
 348
 349         /* bits_offset is at most 7.
 350          * BTF_INT_OFFSET() cannot exceed 128 bits.
 351          */
 352         total_bits_offset = bit_offset + BTF_INT_OFFSET(int_type);
 353         data += BITS_ROUNDDOWN_BYTES(total_bits_offset);
 354         bit_offset = BITS_PER_BYTE_MASKED(total_bits_offset);
 355         btf_dumper_bitfield(nr_bits, bit_offset, data, jw,
 356                             is_plain_text);
 357 }
 358
 359 static int btf_dumper_int(const struct btf_type *t, __u8 bit_offset,
 360                           const void *data, json_writer_t *jw,
 361                           bool is_plain_text)
 362 {
 363         __u32 *int_type;
 364         __u32 nr_bits;
 365
 366         int_type = (__u32 *)(t + 1);
 367         nr_bits = BTF_INT_BITS(*int_type);
 368         /* if this is bit field */
 369         if (bit_offset || BTF_INT_OFFSET(*int_type) ||
 370             BITS_PER_BYTE_MASKED(nr_bits)) {
 371                 btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 372                                     is_plain_text);
 373                 return 0;
 374         }
 375
 376         if (nr_bits == 128) {
 377                 btf_int128_print(jw, data, is_plain_text);
 378                 return 0;
 379         }
 380
 381         switch (BTF_INT_ENCODING(*int_type)) {
 382         case 0:
 383                 if (BTF_INT_BITS(*int_type) == 64)
 384                         jsonw_printf(jw, "%llu", *(__u64 *)data);
 385                 else if (BTF_INT_BITS(*int_type) == 32)
 386                         jsonw_printf(jw, "%u", *(__u32 *)data);
 387                 else if (BTF_INT_BITS(*int_type) == 16)
 388                         jsonw_printf(jw, "%hu", *(__u16 *)data);
 389                 else if (BTF_INT_BITS(*int_type) == 8)
 390                         jsonw_printf(jw, "%hhu", *(__u8 *)data);
 391                 else
 392                         btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 393                                             is_plain_text);
 394                 break;
 395         case BTF_INT_SIGNED:
 396                 if (BTF_INT_BITS(*int_type) == 64)
 397                         jsonw_printf(jw, "%lld", *(long long *)data);
 398                 else if (BTF_INT_BITS(*int_type) == 32)
 399                         jsonw_printf(jw, "%d", *(int *)data);
 400                 else if (BTF_INT_BITS(*int_type) == 16)
 401                         jsonw_printf(jw, "%hd", *(short *)data);
 402                 else if (BTF_INT_BITS(*int_type) == 8)
 403                         jsonw_printf(jw, "%hhd", *(char *)data);
 404                 else
 405                         btf_dumper_int_bits(*int_type, bit_offset, data, jw,
 406                                             is_plain_text);
 407                 break;
 408         case BTF_INT_CHAR:
 409                 if (isprint(*(char *)data))
 410                         jsonw_printf(jw, "\"%c\"", *(char *)data);
 411                 else
 412                         if (is_plain_text)
 413                                 jsonw_printf(jw, "0x%hhx", *(char *)data);
 414                         else
 415                                 jsonw_printf(jw, "\"\\u00%02hhx\"",
 416                                              *(char *)data);
 417                 break;
 418         case BTF_INT_BOOL:
 419                 jsonw_bool(jw, *(int *)data);
 420                 break;
 421         default:
 422                 /* shouldn't happen */
 423                 return -EINVAL;
 424         }
 425
 426         return 0;
 427 }
 428
 429 static int btf_dumper_struct(const struct btf_dumper *d, __u32 type_id,
 430                              const void *data)
 431 {
 432         const struct btf_type *t;
 433         struct btf_member *m;
 434         const void *data_off;
 435         int kind_flag;
 436         int ret = 0;
 437         int i, vlen;
 438
 439         t = btf__type_by_id(d->btf, type_id);
 440         if (!t)
 441                 return -EINVAL;
 442
 443         kind_flag = BTF_INFO_KFLAG(t->info);
 444         vlen = BTF_INFO_VLEN(t->info);
 445         jsonw_start_object(d->jw);
 446         m = (struct btf_member *)(t + 1);
 447
 448         for (i = 0; i < vlen; i++) {
 449                 __u32 bit_offset = m[i].offset;
 450                 __u32 bitfield_size = 0;
 451
 452                 if (kind_flag) {
 453                         bitfield_size = BTF_MEMBER_BITFIELD_SIZE(bit_offset);
 454                         bit_offset = BTF_MEMBER_BIT_OFFSET(bit_offset);
 455                 }
 456
 457                 jsonw_name(d->jw, btf__name_by_offset(d->btf, m[i].name_off));
 458                 data_off = data + BITS_ROUNDDOWN_BYTES(bit_offset);
 459                 if (bitfield_size) {
 460                         btf_dumper_bitfield(bitfield_size,
 461                                             BITS_PER_BYTE_MASKED(bit_offset),
 462                                             data_off, d->jw, d->is_plain_text);
 463                 } else {
 464                         ret = btf_dumper_do_type(d, m[i].type,
 465                                                  BITS_PER_BYTE_MASKED(bit_offset),
 466                                                  data_off);
 467                         if (ret)
 468                                 break;
 469                 }
 470         }
 471
 472         jsonw_end_object(d->jw);
 473
 474         return ret;
 475 }
 476
 477 static int btf_dumper_var(const struct btf_dumper *d, __u32 type_id,
 478                           __u8 bit_offset, const void *data)
 479 {
 480         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
 481         int ret;
 482
 483         jsonw_start_object(d->jw);
 484         jsonw_name(d->jw, btf__name_by_offset(d->btf, t->name_off));
 485         ret = btf_dumper_do_type(d, t->type, bit_offset, data);
 486         jsonw_end_object(d->jw);
 487
 488         return ret;
 489 }
 490
 491 static int btf_dumper_datasec(const struct btf_dumper *d, __u32 type_id,
 492                               const void *data)
 493 {
 494         struct btf_var_secinfo *vsi;
 495         const struct btf_type *t;
 496         int ret = 0, i, vlen;
 497
 498         t = btf__type_by_id(d->btf, type_id);
 499         if (!t)
 500                 return -EINVAL;
 501
 502         vlen = BTF_INFO_VLEN(t->info);
 503         vsi = (struct btf_var_secinfo *)(t + 1);
 504
 505         jsonw_start_object(d->jw);
 506         jsonw_name(d->jw, btf__name_by_offset(d->btf, t->name_off));
 507         jsonw_start_array(d->jw);
 508         for (i = 0; i < vlen; i++) {
 509                 ret = btf_dumper_do_type(d, vsi[i].type, 0, data + vsi[i].offset);
 510                 if (ret)
 511                         break;
 512         }
 513         jsonw_end_array(d->jw);
 514         jsonw_end_object(d->jw);
 515
 516         return ret;
 517 }
 518
 519 static int btf_dumper_do_type(const struct btf_dumper *d, __u32 type_id,
 520                               __u8 bit_offset, const void *data)
 521 {
 522         const struct btf_type *t = btf__type_by_id(d->btf, type_id);
 523
 524         switch (BTF_INFO_KIND(t->info)) {
 525         case BTF_KIND_INT:
 526                 return btf_dumper_int(t, bit_offset, data, d->jw,
 527                                      d->is_plain_text);
 528         case BTF_KIND_STRUCT:
 529         case BTF_KIND_UNION:
 530                 return btf_dumper_struct(d, type_id, data);
 531         case BTF_KIND_ARRAY:
 532                 return btf_dumper_array(d, type_id, data);
 533         case BTF_KIND_ENUM:
 534                 return btf_dumper_enum(d, t, data);
 535         case BTF_KIND_PTR:
 536                 btf_dumper_ptr(d, t, data);
 537                 return 0;
 538         case BTF_KIND_UNKN:
 539                 jsonw_printf(d->jw, "(unknown)");
 540                 return 0;
 541         case BTF_KIND_FWD:
 542                 /* map key or value can't be forward */
 543                 jsonw_printf(d->jw, "(fwd-kind-invalid)");
 544                 return -EINVAL;
 545         case BTF_KIND_TYPEDEF:
 546         case BTF_KIND_VOLATILE:
 547         case BTF_KIND_CONST:
 548         case BTF_KIND_RESTRICT:
 549                 return btf_dumper_modifier(d, type_id, bit_offset, data);
 550         case BTF_KIND_VAR:
 551                 return btf_dumper_var(d, type_id, bit_offset, data);
 552         case BTF_KIND_DATASEC:
 553                 return btf_dumper_datasec(d, type_id, data);
 554         default:
 555                 jsonw_printf(d->jw, "(unsupported-kind");
 556                 return -EINVAL;
 557         }
 558 }
 559
 560 int btf_dumper_type(const struct btf_dumper *d, __u32 type_id,
 561                     const void *data)
 562 {
 563         return btf_dumper_do_type(d, type_id, 0, data);
 564 }
 565
 566 #define BTF_PRINT_ARG(...)                                              \
 567         do {                                                            \
 568                 pos += snprintf(func_sig + pos, size - pos,             \
 569                                 __VA_ARGS__);                           \
 570                 if (pos >= size)                                        \
 571                         return -1;                                      \
 572         } while (0)
 573 #define BTF_PRINT_TYPE(type)                                    \
 574         do {                                                            \
 575                 pos = __btf_dumper_type_only(btf, type, func_sig,       \
 576                                              pos, size);                \
 577                 if (pos == -1)                                          \
 578                         return -1;                                      \
 579         } while (0)
 580
 581 static int __btf_dumper_type_only(const struct btf *btf, __u32 type_id,
 582                                   char *func_sig, int pos, int size)
 583 {
 584         const struct btf_type *proto_type;
 585         const struct btf_array *array;
 586         const struct btf_var *var;
 587         const struct btf_type *t;
 588
 589         if (!type_id) {
 590                 BTF_PRINT_ARG("void ");
 591                 return pos;
 592         }
 593
 594         t = btf__type_by_id(btf, type_id);
 595
 596         switch (BTF_INFO_KIND(t->info)) {
 597         case BTF_KIND_INT:
 598         case BTF_KIND_TYPEDEF:
 599                 BTF_PRINT_ARG("%s ", btf__name_by_offset(btf, t->name_off));
 600                 break;
 601         case BTF_KIND_STRUCT:
 602                 BTF_PRINT_ARG("struct %s ",
 603                               btf__name_by_offset(btf, t->name_off));
 604                 break;
 605         case BTF_KIND_UNION:
 606                 BTF_PRINT_ARG("union %s ",
 607                               btf__name_by_offset(btf, t->name_off));
 608                 break;
 609         case BTF_KIND_ENUM:
 610                 BTF_PRINT_ARG("enum %s ",
 611                               btf__name_by_offset(btf, t->name_off));
 612                 break;
 613         case BTF_KIND_ARRAY:
 614                 array = (struct btf_array *)(t + 1);
 615                 BTF_PRINT_TYPE(array->type);
 616                 BTF_PRINT_ARG("[%d]", array->nelems);
 617                 break;
 618         case BTF_KIND_PTR:
 619                 BTF_PRINT_TYPE(t->type);
 620                 BTF_PRINT_ARG("* ");
 621                 break;
 622         case BTF_KIND_FWD:
 623                 BTF_PRINT_ARG("%s %s ",
 624                               BTF_INFO_KFLAG(t->info) ? "union" : "struct",
 625                               btf__name_by_offset(btf, t->name_off));
 626                 break;
 627         case BTF_KIND_VOLATILE:
 628                 BTF_PRINT_ARG("volatile ");
 629                 BTF_PRINT_TYPE(t->type);
 630                 break;
 631         case BTF_KIND_CONST:
 632                 BTF_PRINT_ARG("const ");
 633                 BTF_PRINT_TYPE(t->type);
 634                 break;
 635         case BTF_KIND_RESTRICT:
 636                 BTF_PRINT_ARG("restrict ");
 637                 BTF_PRINT_TYPE(t->type);
 638                 break;
 639         case BTF_KIND_FUNC_PROTO:
 640                 pos = btf_dump_func(btf, func_sig, t, NULL, pos, size);
 641                 if (pos == -1)
 642                         return -1;
 643                 break;
 644         case BTF_KIND_FUNC:
 645                 proto_type = btf__type_by_id(btf, t->type);
 646                 pos = btf_dump_func(btf, func_sig, proto_type, t, pos, size);
 647                 if (pos == -1)
 648                         return -1;
 649                 break;
 650         case BTF_KIND_VAR:
 651                 var = (struct btf_var *)(t + 1);
 652                 if (var->linkage == BTF_VAR_STATIC)
 653                         BTF_PRINT_ARG("static ");
 654                 BTF_PRINT_TYPE(t->type);
 655                 BTF_PRINT_ARG(" %s",
 656                               btf__name_by_offset(btf, t->name_off));
 657                 break;
 658         case BTF_KIND_DATASEC:
 659                 BTF_PRINT_ARG("section (\"%s\") ",
 660                               btf__name_by_offset(btf, t->name_off));
 661                 break;
 662         case BTF_KIND_UNKN:
 663         default:
 664                 return -1;
 665         }
 666
 667         return pos;
 668 }
 669
 670 static int btf_dump_func(const struct btf *btf, char *func_sig,
 671                          const struct btf_type *func_proto,
 672                          const struct btf_type *func, int pos, int size)
 673 {
 674         int i, vlen;
 675
 676         BTF_PRINT_TYPE(func_proto->type);
 677         if (func)
 678                 BTF_PRINT_ARG("%s(", btf__name_by_offset(btf, func->name_off));
 679         else
 680                 BTF_PRINT_ARG("(");
 681         vlen = BTF_INFO_VLEN(func_proto->info);
 682         for (i = 0; i < vlen; i++) {
 683                 struct btf_param *arg = &((struct btf_param *)(func_proto + 1))[i];
 684
 685                 if (i)
 686                         BTF_PRINT_ARG(", ");
 687                 if (arg->type) {
 688                         BTF_PRINT_TYPE(arg->type);
 689                         if (arg->name_off)
 690                                 BTF_PRINT_ARG("%s",
 691                                               btf__name_by_offset(btf, arg->name_off));
 692                         else if (pos && func_sig[pos - 1] == ' ')
 693                                 /* Remove unnecessary space for
 694                                  * FUNC_PROTO that does not have
 695                                  * arg->name_off
 696                                  */
 697                                 func_sig[--pos] = '\0';
 698                 } else {
 699                         BTF_PRINT_ARG("...");
 700                 }
 701         }
 702         BTF_PRINT_ARG(")");
 703
 704         return pos;
 705 }
 706
 707 void btf_dumper_type_only(const struct btf *btf, __u32 type_id, char *func_sig,
 708                           int size)
 709 {
 710         int err;
 711
 712         func_sig[0] = '\0';
 713         if (!btf)
 714                 return;
 715
 716         err = __btf_dumper_type_only(btf, type_id, func_sig, 0, size);
 717         if (err < 0)
 718                 func_sig[0] = '\0';
 719 }
 720
 721 static const char *ltrim(const char *s)
 722 {
 723         while (isspace(*s))
 724                 s++;
 725
 726         return s;
 727 }
 728
 729 void btf_dump_linfo_plain(const struct btf *btf,
 730                           const struct bpf_line_info *linfo,
 731                           const char *prefix, bool linum)
 732 {
 733         const char *line = btf__name_by_offset(btf, linfo->line_off);
 734
 735         if (!line)
 736                 return;
 737         line = ltrim(line);
 738
 739         if (!prefix)
 740                 prefix = "";
 741
 742         if (linum) {
 743                 const char *file = btf__name_by_offset(btf, linfo->file_name_off);
 744
 745                 /* More forgiving on file because linum option is
 746                  * expected to provide more info than the already
 747                  * available src line.
 748                  */
 749                 if (!file)
 750                         file = "";
 751
 752                 printf("%s%s [file:%s line_num:%u line_col:%u]\n",
 753                        prefix, line, file,
 754                        BPF_LINE_INFO_LINE_NUM(linfo->line_col),
 755                        BPF_LINE_INFO_LINE_COL(linfo->line_col));
 756         } else {
 757                 printf("%s%s\n", prefix, line);
 758         }
 759 }
 760
 761 void btf_dump_linfo_json(const struct btf *btf,
 762                          const struct bpf_line_info *linfo, bool linum)
 763 {
 764         const char *line = btf__name_by_offset(btf, linfo->line_off);
 765
 766         if (line)
 767                 jsonw_string_field(json_wtr, "src", ltrim(line));
 768
 769         if (linum) {
 770                 const char *file = btf__name_by_offset(btf, linfo->file_name_off);
 771
 772                 if (file)
 773                         jsonw_string_field(json_wtr, "file", file);
 774
 775                 if (BPF_LINE_INFO_LINE_NUM(linfo->line_col))
 776                         jsonw_int_field(json_wtr, "line_num",
 777                                         BPF_LINE_INFO_LINE_NUM(linfo->line_col));
 778
 779                 if (BPF_LINE_INFO_LINE_COL(linfo->line_col))
 780                         jsonw_int_field(json_wtr, "line_col",
 781                                         BPF_LINE_INFO_LINE_COL(linfo->line_col));
 782         }
 783 }