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