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 case BTF_KIND_FLOAT: 600 BTF_PRINT_ARG("%s ", btf__name_by_offset(btf, t->name_off)); 601 break; 602 case BTF_KIND_STRUCT: 603 BTF_PRINT_ARG("struct %s ", 604 btf__name_by_offset(btf, t->name_off)); 605 break; 606 case BTF_KIND_UNION: 607 BTF_PRINT_ARG("union %s ", 608 btf__name_by_offset(btf, t->name_off)); 609 break; 610 case BTF_KIND_ENUM: 611 BTF_PRINT_ARG("enum %s ", 612 btf__name_by_offset(btf, t->name_off)); 613 break; 614 case BTF_KIND_ARRAY: 615 array = (struct btf_array *)(t + 1); 616 BTF_PRINT_TYPE(array->type); 617 BTF_PRINT_ARG("[%d]", array->nelems); 618 break; 619 case BTF_KIND_PTR: 620 BTF_PRINT_TYPE(t->type); 621 BTF_PRINT_ARG("* "); 622 break; 623 case BTF_KIND_FWD: 624 BTF_PRINT_ARG("%s %s ", 625 BTF_INFO_KFLAG(t->info) ? "union" : "struct", 626 btf__name_by_offset(btf, t->name_off)); 627 break; 628 case BTF_KIND_VOLATILE: 629 BTF_PRINT_ARG("volatile "); 630 BTF_PRINT_TYPE(t->type); 631 break; 632 case BTF_KIND_CONST: 633 BTF_PRINT_ARG("const "); 634 BTF_PRINT_TYPE(t->type); 635 break; 636 case BTF_KIND_RESTRICT: 637 BTF_PRINT_ARG("restrict "); 638 BTF_PRINT_TYPE(t->type); 639 break; 640 case BTF_KIND_FUNC_PROTO: 641 pos = btf_dump_func(btf, func_sig, t, NULL, pos, size); 642 if (pos == -1) 643 return -1; 644 break; 645 case BTF_KIND_FUNC: 646 proto_type = btf__type_by_id(btf, t->type); 647 pos = btf_dump_func(btf, func_sig, proto_type, t, pos, size); 648 if (pos == -1) 649 return -1; 650 break; 651 case BTF_KIND_VAR: 652 var = (struct btf_var *)(t + 1); 653 if (var->linkage == BTF_VAR_STATIC) 654 BTF_PRINT_ARG("static "); 655 BTF_PRINT_TYPE(t->type); 656 BTF_PRINT_ARG(" %s", 657 btf__name_by_offset(btf, t->name_off)); 658 break; 659 case BTF_KIND_DATASEC: 660 BTF_PRINT_ARG("section (\"%s\") ", 661 btf__name_by_offset(btf, t->name_off)); 662 break; 663 case BTF_KIND_UNKN: 664 default: 665 return -1; 666 } 667 668 return pos; 669 } 670 671 static int btf_dump_func(const struct btf *btf, char *func_sig, 672 const struct btf_type *func_proto, 673 const struct btf_type *func, int pos, int size) 674 { 675 int i, vlen; 676 677 BTF_PRINT_TYPE(func_proto->type); 678 if (func) 679 BTF_PRINT_ARG("%s(", btf__name_by_offset(btf, func->name_off)); 680 else 681 BTF_PRINT_ARG("("); 682 vlen = BTF_INFO_VLEN(func_proto->info); 683 for (i = 0; i < vlen; i++) { 684 struct btf_param *arg = &((struct btf_param *)(func_proto + 1))[i]; 685 686 if (i) 687 BTF_PRINT_ARG(", "); 688 if (arg->type) { 689 BTF_PRINT_TYPE(arg->type); 690 if (arg->name_off) 691 BTF_PRINT_ARG("%s", 692 btf__name_by_offset(btf, arg->name_off)); 693 else if (pos && func_sig[pos - 1] == ' ') 694 /* Remove unnecessary space for 695 * FUNC_PROTO that does not have 696 * arg->name_off 697 */ 698 func_sig[--pos] = '\0'; 699 } else { 700 BTF_PRINT_ARG("..."); 701 } 702 } 703 BTF_PRINT_ARG(")"); 704 705 return pos; 706 } 707 708 void btf_dumper_type_only(const struct btf *btf, __u32 type_id, char *func_sig, 709 int size) 710 { 711 int err; 712 713 func_sig[0] = '\0'; 714 if (!btf) 715 return; 716 717 err = __btf_dumper_type_only(btf, type_id, func_sig, 0, size); 718 if (err < 0) 719 func_sig[0] = '\0'; 720 } 721 722 static const char *ltrim(const char *s) 723 { 724 while (isspace(*s)) 725 s++; 726 727 return s; 728 } 729 730 void btf_dump_linfo_plain(const struct btf *btf, 731 const struct bpf_line_info *linfo, 732 const char *prefix, bool linum) 733 { 734 const char *line = btf__name_by_offset(btf, linfo->line_off); 735 736 if (!line) 737 return; 738 line = ltrim(line); 739 740 if (!prefix) 741 prefix = ""; 742 743 if (linum) { 744 const char *file = btf__name_by_offset(btf, linfo->file_name_off); 745 746 /* More forgiving on file because linum option is 747 * expected to provide more info than the already 748 * available src line. 749 */ 750 if (!file) 751 file = ""; 752 753 printf("%s%s [file:%s line_num:%u line_col:%u]\n", 754 prefix, line, file, 755 BPF_LINE_INFO_LINE_NUM(linfo->line_col), 756 BPF_LINE_INFO_LINE_COL(linfo->line_col)); 757 } else { 758 printf("%s%s\n", prefix, line); 759 } 760 } 761 762 void btf_dump_linfo_json(const struct btf *btf, 763 const struct bpf_line_info *linfo, bool linum) 764 { 765 const char *line = btf__name_by_offset(btf, linfo->line_off); 766 767 if (line) 768 jsonw_string_field(json_wtr, "src", ltrim(line)); 769 770 if (linum) { 771 const char *file = btf__name_by_offset(btf, linfo->file_name_off); 772 773 if (file) 774 jsonw_string_field(json_wtr, "file", file); 775 776 if (BPF_LINE_INFO_LINE_NUM(linfo->line_col)) 777 jsonw_int_field(json_wtr, "line_num", 778 BPF_LINE_INFO_LINE_NUM(linfo->line_col)); 779 780 if (BPF_LINE_INFO_LINE_COL(linfo->line_col)) 781 jsonw_int_field(json_wtr, "line_col", 782 BPF_LINE_INFO_LINE_COL(linfo->line_col)); 783 } 784 } 785