1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * probe-finder.c : C expression to kprobe event converter 4 * 5 * Written by Masami Hiramatsu <mhiramat@redhat.com> 6 */ 7 8#include <inttypes.h> 9#include <sys/utsname.h> 10#include <sys/types.h> 11#include <sys/stat.h> 12#include <fcntl.h> 13#include <errno.h> 14#include <stdio.h> 15#include <unistd.h> 16#include <stdlib.h> 17#include <string.h> 18#include <stdarg.h> 19#include <dwarf-regs.h> 20 21#include <linux/bitops.h> 22#include <linux/zalloc.h> 23#include "event.h" 24#include "dso.h" 25#include "debug.h" 26#include "intlist.h" 27#include "strbuf.h" 28#include "strlist.h" 29#include "symbol.h" 30#include "probe-finder.h" 31#include "probe-file.h" 32#include "string2.h" 33 34#ifdef HAVE_DEBUGINFOD_SUPPORT 35#include <elfutils/debuginfod.h> 36#endif 37 38/* Kprobe tracer basic type is up to u64 */ 39#define MAX_BASIC_TYPE_BITS 64 40 41/* Dwarf FL wrappers */ 42static char *debuginfo_path; /* Currently dummy */ 43 44static const Dwfl_Callbacks offline_callbacks = { 45 .find_debuginfo = dwfl_standard_find_debuginfo, 46 .debuginfo_path = &debuginfo_path, 47 48 .section_address = dwfl_offline_section_address, 49 50 /* We use this table for core files too. */ 51 .find_elf = dwfl_build_id_find_elf, 52}; 53 54/* Get a Dwarf from offline image */ 55static int debuginfo__init_offline_dwarf(struct debuginfo *dbg, 56 const char *path) 57{ 58 GElf_Addr dummy; 59 int fd; 60 61 fd = open(path, O_RDONLY); 62 if (fd < 0) 63 return fd; 64 65 dbg->dwfl = dwfl_begin(&offline_callbacks); 66 if (!dbg->dwfl) 67 goto error; 68 69 dwfl_report_begin(dbg->dwfl); 70 dbg->mod = dwfl_report_offline(dbg->dwfl, "", "", fd); 71 if (!dbg->mod) 72 goto error; 73 74 dbg->dbg = dwfl_module_getdwarf(dbg->mod, &dbg->bias); 75 if (!dbg->dbg) 76 goto error; 77 78 dwfl_module_build_id(dbg->mod, &dbg->build_id, &dummy); 79 80 dwfl_report_end(dbg->dwfl, NULL, NULL); 81 82 return 0; 83error: 84 if (dbg->dwfl) 85 dwfl_end(dbg->dwfl); 86 else 87 close(fd); 88 memset(dbg, 0, sizeof(*dbg)); 89 90 return -ENOENT; 91} 92 93static struct debuginfo *__debuginfo__new(const char *path) 94{ 95 struct debuginfo *dbg = zalloc(sizeof(*dbg)); 96 if (!dbg) 97 return NULL; 98 99 if (debuginfo__init_offline_dwarf(dbg, path) < 0) 100 zfree(&dbg); 101 if (dbg) 102 pr_debug("Open Debuginfo file: %s\n", path); 103 return dbg; 104} 105 106enum dso_binary_type distro_dwarf_types[] = { 107 DSO_BINARY_TYPE__FEDORA_DEBUGINFO, 108 DSO_BINARY_TYPE__UBUNTU_DEBUGINFO, 109 DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO, 110 DSO_BINARY_TYPE__BUILDID_DEBUGINFO, 111 DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO, 112 DSO_BINARY_TYPE__NOT_FOUND, 113}; 114 115struct debuginfo *debuginfo__new(const char *path) 116{ 117 enum dso_binary_type *type; 118 char buf[PATH_MAX], nil = '\0'; 119 struct dso *dso; 120 struct debuginfo *dinfo = NULL; 121 struct build_id bid; 122 123 /* Try to open distro debuginfo files */ 124 dso = dso__new(path); 125 if (!dso) 126 goto out; 127 128 /* Set the build id for DSO_BINARY_TYPE__BUILDID_DEBUGINFO */ 129 if (is_regular_file(path) && filename__read_build_id(path, &bid) > 0) 130 dso__set_build_id(dso, &bid); 131 132 for (type = distro_dwarf_types; 133 !dinfo && *type != DSO_BINARY_TYPE__NOT_FOUND; 134 type++) { 135 if (dso__read_binary_type_filename(dso, *type, &nil, 136 buf, PATH_MAX) < 0) 137 continue; 138 dinfo = __debuginfo__new(buf); 139 } 140 dso__put(dso); 141 142out: 143 /* if failed to open all distro debuginfo, open given binary */ 144 return dinfo ? : __debuginfo__new(path); 145} 146 147void debuginfo__delete(struct debuginfo *dbg) 148{ 149 if (dbg) { 150 if (dbg->dwfl) 151 dwfl_end(dbg->dwfl); 152 free(dbg); 153 } 154} 155 156/* 157 * Probe finder related functions 158 */ 159 160static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs) 161{ 162 struct probe_trace_arg_ref *ref; 163 ref = zalloc(sizeof(struct probe_trace_arg_ref)); 164 if (ref != NULL) 165 ref->offset = offs; 166 return ref; 167} 168 169/* 170 * Convert a location into trace_arg. 171 * If tvar == NULL, this just checks variable can be converted. 172 * If fentry == true and vr_die is a parameter, do heuristic search 173 * for the location fuzzed by function entry mcount. 174 */ 175static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr, 176 Dwarf_Op *fb_ops, Dwarf_Die *sp_die, 177 unsigned int machine, 178 struct probe_trace_arg *tvar) 179{ 180 Dwarf_Attribute attr; 181 Dwarf_Addr tmp = 0; 182 Dwarf_Op *op; 183 size_t nops; 184 unsigned int regn; 185 Dwarf_Word offs = 0; 186 bool ref = false; 187 const char *regs; 188 int ret, ret2 = 0; 189 190 if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL) 191 goto static_var; 192 193 /* Constant value */ 194 if (dwarf_attr(vr_die, DW_AT_const_value, &attr) && 195 immediate_value_is_supported()) { 196 Dwarf_Sword snum; 197 198 if (!tvar) 199 return 0; 200 201 dwarf_formsdata(&attr, &snum); 202 ret = asprintf(&tvar->value, "\\%ld", (long)snum); 203 204 return ret < 0 ? -ENOMEM : 0; 205 } 206 207 /* TODO: handle more than 1 exprs */ 208 if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL) 209 return -EINVAL; /* Broken DIE ? */ 210 if (dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0) { 211 ret = dwarf_entrypc(sp_die, &tmp); 212 if (ret) 213 return -ENOENT; 214 215 if (probe_conf.show_location_range && 216 (dwarf_tag(vr_die) == DW_TAG_variable)) { 217 ret2 = -ERANGE; 218 } else if (addr != tmp || 219 dwarf_tag(vr_die) != DW_TAG_formal_parameter) { 220 return -ENOENT; 221 } 222 223 ret = dwarf_highpc(sp_die, &tmp); 224 if (ret) 225 return -ENOENT; 226 /* 227 * This is fuzzed by fentry mcount. We try to find the 228 * parameter location at the earliest address. 229 */ 230 for (addr += 1; addr <= tmp; addr++) { 231 if (dwarf_getlocation_addr(&attr, addr, &op, 232 &nops, 1) > 0) 233 goto found; 234 } 235 return -ENOENT; 236 } 237found: 238 if (nops == 0) 239 /* TODO: Support const_value */ 240 return -ENOENT; 241 242 if (op->atom == DW_OP_addr) { 243static_var: 244 if (!tvar) 245 return ret2; 246 /* Static variables on memory (not stack), make @varname */ 247 ret = strlen(dwarf_diename(vr_die)); 248 tvar->value = zalloc(ret + 2); 249 if (tvar->value == NULL) 250 return -ENOMEM; 251 snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die)); 252 tvar->ref = alloc_trace_arg_ref((long)offs); 253 if (tvar->ref == NULL) 254 return -ENOMEM; 255 return ret2; 256 } 257 258 /* If this is based on frame buffer, set the offset */ 259 if (op->atom == DW_OP_fbreg) { 260 if (fb_ops == NULL) 261 return -ENOTSUP; 262 ref = true; 263 offs = op->number; 264 op = &fb_ops[0]; 265 } 266 267 if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) { 268 regn = op->atom - DW_OP_breg0; 269 offs += op->number; 270 ref = true; 271 } else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) { 272 regn = op->atom - DW_OP_reg0; 273 } else if (op->atom == DW_OP_bregx) { 274 regn = op->number; 275 offs += op->number2; 276 ref = true; 277 } else if (op->atom == DW_OP_regx) { 278 regn = op->number; 279 } else { 280 pr_debug("DW_OP %x is not supported.\n", op->atom); 281 return -ENOTSUP; 282 } 283 284 if (!tvar) 285 return ret2; 286 287 regs = get_dwarf_regstr(regn, machine); 288 if (!regs) { 289 /* This should be a bug in DWARF or this tool */ 290 pr_warning("Mapping for the register number %u " 291 "missing on this architecture.\n", regn); 292 return -ENOTSUP; 293 } 294 295 tvar->value = strdup(regs); 296 if (tvar->value == NULL) 297 return -ENOMEM; 298 299 if (ref) { 300 tvar->ref = alloc_trace_arg_ref((long)offs); 301 if (tvar->ref == NULL) 302 return -ENOMEM; 303 } 304 return ret2; 305} 306 307#define BYTES_TO_BITS(nb) ((nb) * BITS_PER_LONG / sizeof(long)) 308 309static int convert_variable_type(Dwarf_Die *vr_die, 310 struct probe_trace_arg *tvar, 311 const char *cast, bool user_access) 312{ 313 struct probe_trace_arg_ref **ref_ptr = &tvar->ref; 314 Dwarf_Die type; 315 char buf[16]; 316 char sbuf[STRERR_BUFSIZE]; 317 int bsize, boffs, total; 318 int ret; 319 char prefix; 320 321 /* TODO: check all types */ 322 if (cast && strcmp(cast, "string") != 0 && strcmp(cast, "ustring") && 323 strcmp(cast, "x") != 0 && 324 strcmp(cast, "s") != 0 && strcmp(cast, "u") != 0) { 325 /* Non string type is OK */ 326 /* and respect signedness/hexadecimal cast */ 327 tvar->type = strdup(cast); 328 return (tvar->type == NULL) ? -ENOMEM : 0; 329 } 330 331 bsize = dwarf_bitsize(vr_die); 332 if (bsize > 0) { 333 /* This is a bitfield */ 334 boffs = dwarf_bitoffset(vr_die); 335 total = dwarf_bytesize(vr_die); 336 if (boffs < 0 || total < 0) 337 return -ENOENT; 338 ret = snprintf(buf, 16, "b%d@%d/%zd", bsize, boffs, 339 BYTES_TO_BITS(total)); 340 goto formatted; 341 } 342 343 if (die_get_real_type(vr_die, &type) == NULL) { 344 pr_warning("Failed to get a type information of %s.\n", 345 dwarf_diename(vr_die)); 346 return -ENOENT; 347 } 348 349 pr_debug("%s type is %s.\n", 350 dwarf_diename(vr_die), dwarf_diename(&type)); 351 352 if (cast && (!strcmp(cast, "string") || !strcmp(cast, "ustring"))) { 353 /* String type */ 354 ret = dwarf_tag(&type); 355 if (ret != DW_TAG_pointer_type && 356 ret != DW_TAG_array_type) { 357 pr_warning("Failed to cast into string: " 358 "%s(%s) is not a pointer nor array.\n", 359 dwarf_diename(vr_die), dwarf_diename(&type)); 360 return -EINVAL; 361 } 362 if (die_get_real_type(&type, &type) == NULL) { 363 pr_warning("Failed to get a type" 364 " information.\n"); 365 return -ENOENT; 366 } 367 if (ret == DW_TAG_pointer_type) { 368 while (*ref_ptr) 369 ref_ptr = &(*ref_ptr)->next; 370 /* Add new reference with offset +0 */ 371 *ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref)); 372 if (*ref_ptr == NULL) { 373 pr_warning("Out of memory error\n"); 374 return -ENOMEM; 375 } 376 (*ref_ptr)->user_access = user_access; 377 } 378 if (!die_compare_name(&type, "char") && 379 !die_compare_name(&type, "unsigned char")) { 380 pr_warning("Failed to cast into string: " 381 "%s is not (unsigned) char *.\n", 382 dwarf_diename(vr_die)); 383 return -EINVAL; 384 } 385 tvar->type = strdup(cast); 386 return (tvar->type == NULL) ? -ENOMEM : 0; 387 } 388 389 if (cast && (strcmp(cast, "u") == 0)) 390 prefix = 'u'; 391 else if (cast && (strcmp(cast, "s") == 0)) 392 prefix = 's'; 393 else if (cast && (strcmp(cast, "x") == 0) && 394 probe_type_is_available(PROBE_TYPE_X)) 395 prefix = 'x'; 396 else 397 prefix = die_is_signed_type(&type) ? 's' : 398 probe_type_is_available(PROBE_TYPE_X) ? 'x' : 'u'; 399 400 ret = dwarf_bytesize(&type); 401 if (ret <= 0) 402 /* No size ... try to use default type */ 403 return 0; 404 ret = BYTES_TO_BITS(ret); 405 406 /* Check the bitwidth */ 407 if (ret > MAX_BASIC_TYPE_BITS) { 408 pr_info("%s exceeds max-bitwidth. Cut down to %d bits.\n", 409 dwarf_diename(&type), MAX_BASIC_TYPE_BITS); 410 ret = MAX_BASIC_TYPE_BITS; 411 } 412 ret = snprintf(buf, 16, "%c%d", prefix, ret); 413 414formatted: 415 if (ret < 0 || ret >= 16) { 416 if (ret >= 16) 417 ret = -E2BIG; 418 pr_warning("Failed to convert variable type: %s\n", 419 str_error_r(-ret, sbuf, sizeof(sbuf))); 420 return ret; 421 } 422 tvar->type = strdup(buf); 423 if (tvar->type == NULL) 424 return -ENOMEM; 425 return 0; 426} 427 428static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname, 429 struct perf_probe_arg_field *field, 430 struct probe_trace_arg_ref **ref_ptr, 431 Dwarf_Die *die_mem, bool user_access) 432{ 433 struct probe_trace_arg_ref *ref = *ref_ptr; 434 Dwarf_Die type; 435 Dwarf_Word offs; 436 int ret, tag; 437 438 pr_debug("converting %s in %s\n", field->name, varname); 439 if (die_get_real_type(vr_die, &type) == NULL) { 440 pr_warning("Failed to get the type of %s.\n", varname); 441 return -ENOENT; 442 } 443 pr_debug2("Var real type: %s (%x)\n", dwarf_diename(&type), 444 (unsigned)dwarf_dieoffset(&type)); 445 tag = dwarf_tag(&type); 446 447 if (field->name[0] == '[' && 448 (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) { 449 /* Save original type for next field or type */ 450 memcpy(die_mem, &type, sizeof(*die_mem)); 451 /* Get the type of this array */ 452 if (die_get_real_type(&type, &type) == NULL) { 453 pr_warning("Failed to get the type of %s.\n", varname); 454 return -ENOENT; 455 } 456 pr_debug2("Array real type: %s (%x)\n", dwarf_diename(&type), 457 (unsigned)dwarf_dieoffset(&type)); 458 if (tag == DW_TAG_pointer_type) { 459 ref = zalloc(sizeof(struct probe_trace_arg_ref)); 460 if (ref == NULL) 461 return -ENOMEM; 462 if (*ref_ptr) 463 (*ref_ptr)->next = ref; 464 else 465 *ref_ptr = ref; 466 } 467 ref->offset += dwarf_bytesize(&type) * field->index; 468 ref->user_access = user_access; 469 goto next; 470 } else if (tag == DW_TAG_pointer_type) { 471 /* Check the pointer and dereference */ 472 if (!field->ref) { 473 pr_err("Semantic error: %s must be referred by '->'\n", 474 field->name); 475 return -EINVAL; 476 } 477 /* Get the type pointed by this pointer */ 478 if (die_get_real_type(&type, &type) == NULL) { 479 pr_warning("Failed to get the type of %s.\n", varname); 480 return -ENOENT; 481 } 482 /* Verify it is a data structure */ 483 tag = dwarf_tag(&type); 484 if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) { 485 pr_warning("%s is not a data structure nor a union.\n", 486 varname); 487 return -EINVAL; 488 } 489 490 ref = zalloc(sizeof(struct probe_trace_arg_ref)); 491 if (ref == NULL) 492 return -ENOMEM; 493 if (*ref_ptr) 494 (*ref_ptr)->next = ref; 495 else 496 *ref_ptr = ref; 497 } else { 498 /* Verify it is a data structure */ 499 if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) { 500 pr_warning("%s is not a data structure nor a union.\n", 501 varname); 502 return -EINVAL; 503 } 504 if (field->name[0] == '[') { 505 pr_err("Semantic error: %s is not a pointer" 506 " nor array.\n", varname); 507 return -EINVAL; 508 } 509 /* While processing unnamed field, we don't care about this */ 510 if (field->ref && dwarf_diename(vr_die)) { 511 pr_err("Semantic error: %s must be referred by '.'\n", 512 field->name); 513 return -EINVAL; 514 } 515 if (!ref) { 516 pr_warning("Structure on a register is not " 517 "supported yet.\n"); 518 return -ENOTSUP; 519 } 520 } 521 522 if (die_find_member(&type, field->name, die_mem) == NULL) { 523 pr_warning("%s(type:%s) has no member %s.\n", varname, 524 dwarf_diename(&type), field->name); 525 return -EINVAL; 526 } 527 528 /* Get the offset of the field */ 529 if (tag == DW_TAG_union_type) { 530 offs = 0; 531 } else { 532 ret = die_get_data_member_location(die_mem, &offs); 533 if (ret < 0) { 534 pr_warning("Failed to get the offset of %s.\n", 535 field->name); 536 return ret; 537 } 538 } 539 ref->offset += (long)offs; 540 ref->user_access = user_access; 541 542 /* If this member is unnamed, we need to reuse this field */ 543 if (!dwarf_diename(die_mem)) 544 return convert_variable_fields(die_mem, varname, field, 545 &ref, die_mem, user_access); 546 547next: 548 /* Converting next field */ 549 if (field->next) 550 return convert_variable_fields(die_mem, field->name, 551 field->next, &ref, die_mem, user_access); 552 else 553 return 0; 554} 555 556static void print_var_not_found(const char *varname) 557{ 558 pr_err("Failed to find the location of the '%s' variable at this address.\n" 559 " Perhaps it has been optimized out.\n" 560 " Use -V with the --range option to show '%s' location range.\n", 561 varname, varname); 562} 563 564/* Show a variables in kprobe event format */ 565static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf) 566{ 567 Dwarf_Die die_mem; 568 int ret; 569 570 pr_debug("Converting variable %s into trace event.\n", 571 dwarf_diename(vr_die)); 572 573 ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops, 574 &pf->sp_die, pf->machine, pf->tvar); 575 if (ret == -ENOENT && pf->skip_empty_arg) 576 /* This can be found in other place. skip it */ 577 return 0; 578 if (ret == -ENOENT || ret == -EINVAL) { 579 print_var_not_found(pf->pvar->var); 580 } else if (ret == -ENOTSUP) 581 pr_err("Sorry, we don't support this variable location yet.\n"); 582 else if (ret == 0 && pf->pvar->field) { 583 ret = convert_variable_fields(vr_die, pf->pvar->var, 584 pf->pvar->field, &pf->tvar->ref, 585 &die_mem, pf->pvar->user_access); 586 vr_die = &die_mem; 587 } 588 if (ret == 0) 589 ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type, 590 pf->pvar->user_access); 591 /* *expr will be cached in libdw. Don't free it. */ 592 return ret; 593} 594 595/* Find a variable in a scope DIE */ 596static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf) 597{ 598 Dwarf_Die vr_die; 599 char *buf, *ptr; 600 int ret = 0; 601 602 /* Copy raw parameters */ 603 if (!is_c_varname(pf->pvar->var)) 604 return copy_to_probe_trace_arg(pf->tvar, pf->pvar); 605 606 if (pf->pvar->name) 607 pf->tvar->name = strdup(pf->pvar->name); 608 else { 609 buf = synthesize_perf_probe_arg(pf->pvar); 610 if (!buf) 611 return -ENOMEM; 612 ptr = strchr(buf, ':'); /* Change type separator to _ */ 613 if (ptr) 614 *ptr = '_'; 615 pf->tvar->name = buf; 616 } 617 if (pf->tvar->name == NULL) 618 return -ENOMEM; 619 620 pr_debug("Searching '%s' variable in context.\n", pf->pvar->var); 621 /* Search child die for local variables and parameters. */ 622 if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) { 623 /* Search again in global variables */ 624 if (!die_find_variable_at(&pf->cu_die, pf->pvar->var, 625 0, &vr_die)) { 626 if (pf->skip_empty_arg) 627 return 0; 628 pr_warning("Failed to find '%s' in this function.\n", 629 pf->pvar->var); 630 ret = -ENOENT; 631 } 632 } 633 if (ret >= 0) 634 ret = convert_variable(&vr_die, pf); 635 636 return ret; 637} 638 639/* Convert subprogram DIE to trace point */ 640static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod, 641 Dwarf_Addr paddr, bool retprobe, 642 const char *function, 643 struct probe_trace_point *tp) 644{ 645 Dwarf_Addr eaddr; 646 GElf_Sym sym; 647 const char *symbol; 648 649 /* Verify the address is correct */ 650 if (!dwarf_haspc(sp_die, paddr)) { 651 pr_warning("Specified offset is out of %s\n", 652 dwarf_diename(sp_die)); 653 return -EINVAL; 654 } 655 656 if (dwarf_entrypc(sp_die, &eaddr) == 0) { 657 /* If the DIE has entrypc, use it. */ 658 symbol = dwarf_diename(sp_die); 659 } else { 660 /* Try to get actual symbol name and address from symtab */ 661 symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL); 662 eaddr = sym.st_value; 663 } 664 if (!symbol) { 665 pr_warning("Failed to find symbol at 0x%lx\n", 666 (unsigned long)paddr); 667 return -ENOENT; 668 } 669 670 tp->offset = (unsigned long)(paddr - eaddr); 671 tp->address = paddr; 672 tp->symbol = strdup(symbol); 673 if (!tp->symbol) 674 return -ENOMEM; 675 676 /* Return probe must be on the head of a subprogram */ 677 if (retprobe) { 678 if (eaddr != paddr) { 679 pr_warning("Failed to find \"%s%%return\",\n" 680 " because %s is an inlined function and" 681 " has no return point.\n", function, 682 function); 683 return -EINVAL; 684 } 685 tp->retprobe = true; 686 } 687 688 return 0; 689} 690 691/* Call probe_finder callback with scope DIE */ 692static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf) 693{ 694 Dwarf_Attribute fb_attr; 695 Dwarf_Frame *frame = NULL; 696 size_t nops; 697 int ret; 698 699 if (!sc_die) { 700 pr_err("Caller must pass a scope DIE. Program error.\n"); 701 return -EINVAL; 702 } 703 704 /* If not a real subprogram, find a real one */ 705 if (!die_is_func_def(sc_die)) { 706 if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) { 707 if (die_find_tailfunc(&pf->cu_die, pf->addr, &pf->sp_die)) { 708 pr_warning("Ignoring tail call from %s\n", 709 dwarf_diename(&pf->sp_die)); 710 return 0; 711 } else { 712 pr_warning("Failed to find probe point in any " 713 "functions.\n"); 714 return -ENOENT; 715 } 716 } 717 } else 718 memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die)); 719 720 /* Get the frame base attribute/ops from subprogram */ 721 dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr); 722 ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1); 723 if (ret <= 0 || nops == 0) { 724 pf->fb_ops = NULL; 725#if _ELFUTILS_PREREQ(0, 142) 726 } else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa && 727 (pf->cfi_eh != NULL || pf->cfi_dbg != NULL)) { 728 if ((dwarf_cfi_addrframe(pf->cfi_eh, pf->addr, &frame) != 0 && 729 (dwarf_cfi_addrframe(pf->cfi_dbg, pf->addr, &frame) != 0)) || 730 dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) { 731 pr_warning("Failed to get call frame on 0x%jx\n", 732 (uintmax_t)pf->addr); 733 free(frame); 734 return -ENOENT; 735 } 736#endif 737 } 738 739 /* Call finder's callback handler */ 740 ret = pf->callback(sc_die, pf); 741 742 /* Since *pf->fb_ops can be a part of frame. we should free it here. */ 743 free(frame); 744 pf->fb_ops = NULL; 745 746 return ret; 747} 748 749struct find_scope_param { 750 const char *function; 751 const char *file; 752 int line; 753 int diff; 754 Dwarf_Die *die_mem; 755 bool found; 756}; 757 758static int find_best_scope_cb(Dwarf_Die *fn_die, void *data) 759{ 760 struct find_scope_param *fsp = data; 761 const char *file; 762 int lno; 763 764 /* Skip if declared file name does not match */ 765 if (fsp->file) { 766 file = die_get_decl_file(fn_die); 767 if (!file || strcmp(fsp->file, file) != 0) 768 return 0; 769 } 770 /* If the function name is given, that's what user expects */ 771 if (fsp->function) { 772 if (die_match_name(fn_die, fsp->function)) { 773 memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die)); 774 fsp->found = true; 775 return 1; 776 } 777 } else { 778 /* With the line number, find the nearest declared DIE */ 779 dwarf_decl_line(fn_die, &lno); 780 if (lno < fsp->line && fsp->diff > fsp->line - lno) { 781 /* Keep a candidate and continue */ 782 fsp->diff = fsp->line - lno; 783 memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die)); 784 fsp->found = true; 785 } 786 } 787 return 0; 788} 789 790/* Return innermost DIE */ 791static int find_inner_scope_cb(Dwarf_Die *fn_die, void *data) 792{ 793 struct find_scope_param *fsp = data; 794 795 memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die)); 796 fsp->found = true; 797 return 1; 798} 799 800/* Find an appropriate scope fits to given conditions */ 801static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem) 802{ 803 struct find_scope_param fsp = { 804 .function = pf->pev->point.function, 805 .file = pf->fname, 806 .line = pf->lno, 807 .diff = INT_MAX, 808 .die_mem = die_mem, 809 .found = false, 810 }; 811 int ret; 812 813 ret = cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb, 814 &fsp); 815 if (!ret && !fsp.found) 816 cu_walk_functions_at(&pf->cu_die, pf->addr, 817 find_inner_scope_cb, &fsp); 818 819 return fsp.found ? die_mem : NULL; 820} 821 822static int verify_representive_line(struct probe_finder *pf, const char *fname, 823 int lineno, Dwarf_Addr addr) 824{ 825 const char *__fname, *__func = NULL; 826 Dwarf_Die die_mem; 827 int __lineno; 828 829 /* Verify line number and address by reverse search */ 830 if (cu_find_lineinfo(&pf->cu_die, addr, &__fname, &__lineno) < 0) 831 return 0; 832 833 pr_debug2("Reversed line: %s:%d\n", __fname, __lineno); 834 if (strcmp(fname, __fname) || lineno == __lineno) 835 return 0; 836 837 pr_warning("This line is sharing the address with other lines.\n"); 838 839 if (pf->pev->point.function) { 840 /* Find best match function name and lines */ 841 pf->addr = addr; 842 if (find_best_scope(pf, &die_mem) 843 && die_match_name(&die_mem, pf->pev->point.function) 844 && dwarf_decl_line(&die_mem, &lineno) == 0) { 845 __func = dwarf_diename(&die_mem); 846 __lineno -= lineno; 847 } 848 } 849 pr_warning("Please try to probe at %s:%d instead.\n", 850 __func ? : __fname, __lineno); 851 852 return -ENOENT; 853} 854 855static int probe_point_line_walker(const char *fname, int lineno, 856 Dwarf_Addr addr, void *data) 857{ 858 struct probe_finder *pf = data; 859 Dwarf_Die *sc_die, die_mem; 860 int ret; 861 862 if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0) 863 return 0; 864 865 if (verify_representive_line(pf, fname, lineno, addr)) 866 return -ENOENT; 867 868 pf->addr = addr; 869 sc_die = find_best_scope(pf, &die_mem); 870 if (!sc_die) { 871 pr_warning("Failed to find scope of probe point.\n"); 872 return -ENOENT; 873 } 874 875 ret = call_probe_finder(sc_die, pf); 876 877 /* Continue if no error, because the line will be in inline function */ 878 return ret < 0 ? ret : 0; 879} 880 881/* Find probe point from its line number */ 882static int find_probe_point_by_line(struct probe_finder *pf) 883{ 884 return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf); 885} 886 887/* Find lines which match lazy pattern */ 888static int find_lazy_match_lines(struct intlist *list, 889 const char *fname, const char *pat) 890{ 891 FILE *fp; 892 char *line = NULL; 893 size_t line_len; 894 ssize_t len; 895 int count = 0, linenum = 1; 896 char sbuf[STRERR_BUFSIZE]; 897 898 fp = fopen(fname, "r"); 899 if (!fp) { 900 pr_warning("Failed to open %s: %s\n", fname, 901 str_error_r(errno, sbuf, sizeof(sbuf))); 902 return -errno; 903 } 904 905 while ((len = getline(&line, &line_len, fp)) > 0) { 906 907 if (line[len - 1] == '\n') 908 line[len - 1] = '\0'; 909 910 if (strlazymatch(line, pat)) { 911 intlist__add(list, linenum); 912 count++; 913 } 914 linenum++; 915 } 916 917 if (ferror(fp)) 918 count = -errno; 919 free(line); 920 fclose(fp); 921 922 if (count == 0) 923 pr_debug("No matched lines found in %s.\n", fname); 924 return count; 925} 926 927static int probe_point_lazy_walker(const char *fname, int lineno, 928 Dwarf_Addr addr, void *data) 929{ 930 struct probe_finder *pf = data; 931 Dwarf_Die *sc_die, die_mem; 932 int ret; 933 934 if (!intlist__has_entry(pf->lcache, lineno) || 935 strtailcmp(fname, pf->fname) != 0) 936 return 0; 937 938 pr_debug("Probe line found: line:%d addr:0x%llx\n", 939 lineno, (unsigned long long)addr); 940 pf->addr = addr; 941 pf->lno = lineno; 942 sc_die = find_best_scope(pf, &die_mem); 943 if (!sc_die) { 944 pr_warning("Failed to find scope of probe point.\n"); 945 return -ENOENT; 946 } 947 948 ret = call_probe_finder(sc_die, pf); 949 950 /* 951 * Continue if no error, because the lazy pattern will match 952 * to other lines 953 */ 954 return ret < 0 ? ret : 0; 955} 956 957/* Find probe points from lazy pattern */ 958static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf) 959{ 960 struct build_id bid; 961 char sbuild_id[SBUILD_ID_SIZE] = ""; 962 int ret = 0; 963 char *fpath; 964 965 if (intlist__empty(pf->lcache)) { 966 const char *comp_dir; 967 968 comp_dir = cu_get_comp_dir(&pf->cu_die); 969 if (pf->dbg->build_id) { 970 build_id__init(&bid, pf->dbg->build_id, BUILD_ID_SIZE); 971 build_id__sprintf(&bid, sbuild_id); 972 } 973 ret = find_source_path(pf->fname, sbuild_id, comp_dir, &fpath); 974 if (ret < 0) { 975 pr_warning("Failed to find source file path.\n"); 976 return ret; 977 } 978 979 /* Matching lazy line pattern */ 980 ret = find_lazy_match_lines(pf->lcache, fpath, 981 pf->pev->point.lazy_line); 982 free(fpath); 983 if (ret <= 0) 984 return ret; 985 } 986 987 return die_walk_lines(sp_die, probe_point_lazy_walker, pf); 988} 989 990static void skip_prologue(Dwarf_Die *sp_die, struct probe_finder *pf) 991{ 992 struct perf_probe_point *pp = &pf->pev->point; 993 994 /* Not uprobe? */ 995 if (!pf->pev->uprobes) 996 return; 997 998 /* Compiled with optimization? */ 999 if (die_is_optimized_target(&pf->cu_die)) 1000 return; 1001 1002 /* Don't know entrypc? */ 1003 if (!pf->addr) 1004 return; 1005 1006 /* Only FUNC and FUNC@SRC are eligible. */ 1007 if (!pp->function || pp->line || pp->retprobe || pp->lazy_line || 1008 pp->offset || pp->abs_address) 1009 return; 1010 1011 /* Not interested in func parameter? */ 1012 if (!perf_probe_with_var(pf->pev)) 1013 return; 1014 1015 pr_info("Target program is compiled without optimization. Skipping prologue.\n" 1016 "Probe on address 0x%" PRIx64 " to force probing at the function entry.\n\n", 1017 pf->addr); 1018 1019 die_skip_prologue(sp_die, &pf->cu_die, &pf->addr); 1020} 1021 1022static int probe_point_inline_cb(Dwarf_Die *in_die, void *data) 1023{ 1024 struct probe_finder *pf = data; 1025 struct perf_probe_point *pp = &pf->pev->point; 1026 Dwarf_Addr addr; 1027 int ret; 1028 1029 if (pp->lazy_line) 1030 ret = find_probe_point_lazy(in_die, pf); 1031 else { 1032 /* Get probe address */ 1033 if (die_entrypc(in_die, &addr) != 0) { 1034 pr_warning("Failed to get entry address of %s.\n", 1035 dwarf_diename(in_die)); 1036 return -ENOENT; 1037 } 1038 if (addr == 0) { 1039 pr_debug("%s has no valid entry address. skipped.\n", 1040 dwarf_diename(in_die)); 1041 return -ENOENT; 1042 } 1043 pf->addr = addr; 1044 pf->addr += pp->offset; 1045 pr_debug("found inline addr: 0x%jx\n", 1046 (uintmax_t)pf->addr); 1047 1048 ret = call_probe_finder(in_die, pf); 1049 } 1050 1051 return ret; 1052} 1053 1054/* Callback parameter with return value for libdw */ 1055struct dwarf_callback_param { 1056 void *data; 1057 int retval; 1058}; 1059 1060/* Search function from function name */ 1061static int probe_point_search_cb(Dwarf_Die *sp_die, void *data) 1062{ 1063 struct dwarf_callback_param *param = data; 1064 struct probe_finder *pf = param->data; 1065 struct perf_probe_point *pp = &pf->pev->point; 1066 const char *fname; 1067 1068 /* Check tag and diename */ 1069 if (!die_is_func_def(sp_die) || 1070 !die_match_name(sp_die, pp->function)) 1071 return DWARF_CB_OK; 1072 1073 /* Check declared file */ 1074 fname = die_get_decl_file(sp_die); 1075 if (!fname) { 1076 pr_warning("A function DIE doesn't have decl_line. Maybe broken DWARF?\n"); 1077 return DWARF_CB_OK; 1078 } 1079 if (pp->file && fname && strtailcmp(pp->file, fname)) 1080 return DWARF_CB_OK; 1081 1082 pr_debug("Matched function: %s [%lx]\n", dwarf_diename(sp_die), 1083 (unsigned long)dwarf_dieoffset(sp_die)); 1084 pf->fname = fname; 1085 if (pp->line) { /* Function relative line */ 1086 dwarf_decl_line(sp_die, &pf->lno); 1087 pf->lno += pp->line; 1088 param->retval = find_probe_point_by_line(pf); 1089 } else if (die_is_func_instance(sp_die)) { 1090 /* Instances always have the entry address */ 1091 die_entrypc(sp_die, &pf->addr); 1092 /* But in some case the entry address is 0 */ 1093 if (pf->addr == 0) { 1094 pr_debug("%s has no entry PC. Skipped\n", 1095 dwarf_diename(sp_die)); 1096 param->retval = 0; 1097 /* Real function */ 1098 } else if (pp->lazy_line) 1099 param->retval = find_probe_point_lazy(sp_die, pf); 1100 else { 1101 skip_prologue(sp_die, pf); 1102 pf->addr += pp->offset; 1103 /* TODO: Check the address in this function */ 1104 param->retval = call_probe_finder(sp_die, pf); 1105 } 1106 } else if (!probe_conf.no_inlines) { 1107 /* Inlined function: search instances */ 1108 param->retval = die_walk_instances(sp_die, 1109 probe_point_inline_cb, (void *)pf); 1110 /* This could be a non-existed inline definition */ 1111 if (param->retval == -ENOENT) 1112 param->retval = 0; 1113 } 1114 1115 /* We need to find other candidates */ 1116 if (strisglob(pp->function) && param->retval >= 0) { 1117 param->retval = 0; /* We have to clear the result */ 1118 return DWARF_CB_OK; 1119 } 1120 1121 return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */ 1122} 1123 1124static int find_probe_point_by_func(struct probe_finder *pf) 1125{ 1126 struct dwarf_callback_param _param = {.data = (void *)pf, 1127 .retval = 0}; 1128 dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0); 1129 return _param.retval; 1130} 1131 1132struct pubname_callback_param { 1133 char *function; 1134 char *file; 1135 Dwarf_Die *cu_die; 1136 Dwarf_Die *sp_die; 1137 int found; 1138}; 1139 1140static int pubname_search_cb(Dwarf *dbg, Dwarf_Global *gl, void *data) 1141{ 1142 struct pubname_callback_param *param = data; 1143 const char *fname; 1144 1145 if (dwarf_offdie(dbg, gl->die_offset, param->sp_die)) { 1146 if (dwarf_tag(param->sp_die) != DW_TAG_subprogram) 1147 return DWARF_CB_OK; 1148 1149 if (die_match_name(param->sp_die, param->function)) { 1150 if (!dwarf_offdie(dbg, gl->cu_offset, param->cu_die)) 1151 return DWARF_CB_OK; 1152 1153 if (param->file) { 1154 fname = die_get_decl_file(param->sp_die); 1155 if (!fname || strtailcmp(param->file, fname)) 1156 return DWARF_CB_OK; 1157 } 1158 1159 param->found = 1; 1160 return DWARF_CB_ABORT; 1161 } 1162 } 1163 1164 return DWARF_CB_OK; 1165} 1166 1167static int debuginfo__find_probe_location(struct debuginfo *dbg, 1168 struct probe_finder *pf) 1169{ 1170 struct perf_probe_point *pp = &pf->pev->point; 1171 Dwarf_Off off, noff; 1172 size_t cuhl; 1173 Dwarf_Die *diep; 1174 int ret = 0; 1175 1176 off = 0; 1177 pf->lcache = intlist__new(NULL); 1178 if (!pf->lcache) 1179 return -ENOMEM; 1180 1181 /* Fastpath: lookup by function name from .debug_pubnames section */ 1182 if (pp->function && !strisglob(pp->function)) { 1183 struct pubname_callback_param pubname_param = { 1184 .function = pp->function, 1185 .file = pp->file, 1186 .cu_die = &pf->cu_die, 1187 .sp_die = &pf->sp_die, 1188 .found = 0, 1189 }; 1190 struct dwarf_callback_param probe_param = { 1191 .data = pf, 1192 }; 1193 1194 dwarf_getpubnames(dbg->dbg, pubname_search_cb, 1195 &pubname_param, 0); 1196 if (pubname_param.found) { 1197 ret = probe_point_search_cb(&pf->sp_die, &probe_param); 1198 if (ret) 1199 goto found; 1200 } 1201 } 1202 1203 /* Loop on CUs (Compilation Unit) */ 1204 while (!dwarf_nextcu(dbg->dbg, off, &noff, &cuhl, NULL, NULL, NULL)) { 1205 /* Get the DIE(Debugging Information Entry) of this CU */ 1206 diep = dwarf_offdie(dbg->dbg, off + cuhl, &pf->cu_die); 1207 if (!diep) { 1208 off = noff; 1209 continue; 1210 } 1211 1212 /* Check if target file is included. */ 1213 if (pp->file) 1214 pf->fname = cu_find_realpath(&pf->cu_die, pp->file); 1215 else 1216 pf->fname = NULL; 1217 1218 if (!pp->file || pf->fname) { 1219 if (pp->function) 1220 ret = find_probe_point_by_func(pf); 1221 else if (pp->lazy_line) 1222 ret = find_probe_point_lazy(&pf->cu_die, pf); 1223 else { 1224 pf->lno = pp->line; 1225 ret = find_probe_point_by_line(pf); 1226 } 1227 if (ret < 0) 1228 break; 1229 } 1230 off = noff; 1231 } 1232 1233found: 1234 intlist__delete(pf->lcache); 1235 pf->lcache = NULL; 1236 1237 return ret; 1238} 1239 1240/* Find probe points from debuginfo */ 1241static int debuginfo__find_probes(struct debuginfo *dbg, 1242 struct probe_finder *pf) 1243{ 1244 int ret = 0; 1245 Elf *elf; 1246 GElf_Ehdr ehdr; 1247 1248 if (pf->cfi_eh || pf->cfi_dbg) 1249 return debuginfo__find_probe_location(dbg, pf); 1250 1251 /* Get the call frame information from this dwarf */ 1252 elf = dwarf_getelf(dbg->dbg); 1253 if (elf == NULL) 1254 return -EINVAL; 1255 1256 if (gelf_getehdr(elf, &ehdr) == NULL) 1257 return -EINVAL; 1258 1259 pf->machine = ehdr.e_machine; 1260 1261#if _ELFUTILS_PREREQ(0, 142) 1262 do { 1263 GElf_Shdr shdr; 1264 1265 if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) && 1266 shdr.sh_type == SHT_PROGBITS) 1267 pf->cfi_eh = dwarf_getcfi_elf(elf); 1268 1269 pf->cfi_dbg = dwarf_getcfi(dbg->dbg); 1270 } while (0); 1271#endif 1272 1273 ret = debuginfo__find_probe_location(dbg, pf); 1274 return ret; 1275} 1276 1277struct local_vars_finder { 1278 struct probe_finder *pf; 1279 struct perf_probe_arg *args; 1280 bool vars; 1281 int max_args; 1282 int nargs; 1283 int ret; 1284}; 1285 1286/* Collect available variables in this scope */ 1287static int copy_variables_cb(Dwarf_Die *die_mem, void *data) 1288{ 1289 struct local_vars_finder *vf = data; 1290 struct probe_finder *pf = vf->pf; 1291 int tag; 1292 1293 tag = dwarf_tag(die_mem); 1294 if (tag == DW_TAG_formal_parameter || 1295 (tag == DW_TAG_variable && vf->vars)) { 1296 if (convert_variable_location(die_mem, vf->pf->addr, 1297 vf->pf->fb_ops, &pf->sp_die, 1298 pf->machine, NULL) == 0) { 1299 vf->args[vf->nargs].var = (char *)dwarf_diename(die_mem); 1300 if (vf->args[vf->nargs].var == NULL) { 1301 vf->ret = -ENOMEM; 1302 return DIE_FIND_CB_END; 1303 } 1304 pr_debug(" %s", vf->args[vf->nargs].var); 1305 vf->nargs++; 1306 } 1307 } 1308 1309 if (dwarf_haspc(die_mem, vf->pf->addr)) 1310 return DIE_FIND_CB_CONTINUE; 1311 else 1312 return DIE_FIND_CB_SIBLING; 1313} 1314 1315static int expand_probe_args(Dwarf_Die *sc_die, struct probe_finder *pf, 1316 struct perf_probe_arg *args) 1317{ 1318 Dwarf_Die die_mem; 1319 int i; 1320 int n = 0; 1321 struct local_vars_finder vf = {.pf = pf, .args = args, .vars = false, 1322 .max_args = MAX_PROBE_ARGS, .ret = 0}; 1323 1324 for (i = 0; i < pf->pev->nargs; i++) { 1325 /* var never be NULL */ 1326 if (strcmp(pf->pev->args[i].var, PROBE_ARG_VARS) == 0) 1327 vf.vars = true; 1328 else if (strcmp(pf->pev->args[i].var, PROBE_ARG_PARAMS) != 0) { 1329 /* Copy normal argument */ 1330 args[n] = pf->pev->args[i]; 1331 n++; 1332 continue; 1333 } 1334 pr_debug("Expanding %s into:", pf->pev->args[i].var); 1335 vf.nargs = n; 1336 /* Special local variables */ 1337 die_find_child(sc_die, copy_variables_cb, (void *)&vf, 1338 &die_mem); 1339 pr_debug(" (%d)\n", vf.nargs - n); 1340 if (vf.ret < 0) 1341 return vf.ret; 1342 n = vf.nargs; 1343 } 1344 return n; 1345} 1346 1347static bool trace_event_finder_overlap(struct trace_event_finder *tf) 1348{ 1349 int i; 1350 1351 for (i = 0; i < tf->ntevs; i++) { 1352 if (tf->pf.addr == tf->tevs[i].point.address) 1353 return true; 1354 } 1355 return false; 1356} 1357 1358/* Add a found probe point into trace event list */ 1359static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf) 1360{ 1361 struct trace_event_finder *tf = 1362 container_of(pf, struct trace_event_finder, pf); 1363 struct perf_probe_point *pp = &pf->pev->point; 1364 struct probe_trace_event *tev; 1365 struct perf_probe_arg *args = NULL; 1366 int ret, i; 1367 1368 /* 1369 * For some reason (e.g. different column assigned to same address) 1370 * This callback can be called with the address which already passed. 1371 * Ignore it first. 1372 */ 1373 if (trace_event_finder_overlap(tf)) 1374 return 0; 1375 1376 /* Check number of tevs */ 1377 if (tf->ntevs == tf->max_tevs) { 1378 pr_warning("Too many( > %d) probe point found.\n", 1379 tf->max_tevs); 1380 return -ERANGE; 1381 } 1382 tev = &tf->tevs[tf->ntevs++]; 1383 1384 /* Trace point should be converted from subprogram DIE */ 1385 ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr, 1386 pp->retprobe, pp->function, &tev->point); 1387 if (ret < 0) 1388 goto end; 1389 1390 tev->point.realname = strdup(dwarf_diename(sc_die)); 1391 if (!tev->point.realname) { 1392 ret = -ENOMEM; 1393 goto end; 1394 } 1395 1396 pr_debug("Probe point found: %s+%lu\n", tev->point.symbol, 1397 tev->point.offset); 1398 1399 /* Expand special probe argument if exist */ 1400 args = zalloc(sizeof(struct perf_probe_arg) * MAX_PROBE_ARGS); 1401 if (args == NULL) { 1402 ret = -ENOMEM; 1403 goto end; 1404 } 1405 1406 ret = expand_probe_args(sc_die, pf, args); 1407 if (ret < 0) 1408 goto end; 1409 1410 tev->nargs = ret; 1411 tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); 1412 if (tev->args == NULL) { 1413 ret = -ENOMEM; 1414 goto end; 1415 } 1416 1417 /* Find each argument */ 1418 for (i = 0; i < tev->nargs; i++) { 1419 pf->pvar = &args[i]; 1420 pf->tvar = &tev->args[i]; 1421 /* Variable should be found from scope DIE */ 1422 ret = find_variable(sc_die, pf); 1423 if (ret != 0) 1424 break; 1425 } 1426 1427end: 1428 if (ret) { 1429 clear_probe_trace_event(tev); 1430 tf->ntevs--; 1431 } 1432 free(args); 1433 return ret; 1434} 1435 1436static int fill_empty_trace_arg(struct perf_probe_event *pev, 1437 struct probe_trace_event *tevs, int ntevs) 1438{ 1439 char **valp; 1440 char *type; 1441 int i, j, ret; 1442 1443 if (!ntevs) 1444 return -ENOENT; 1445 1446 for (i = 0; i < pev->nargs; i++) { 1447 type = NULL; 1448 for (j = 0; j < ntevs; j++) { 1449 if (tevs[j].args[i].value) { 1450 type = tevs[j].args[i].type; 1451 break; 1452 } 1453 } 1454 if (j == ntevs) { 1455 print_var_not_found(pev->args[i].var); 1456 return -ENOENT; 1457 } 1458 for (j = 0; j < ntevs; j++) { 1459 valp = &tevs[j].args[i].value; 1460 if (*valp) 1461 continue; 1462 1463 ret = asprintf(valp, "\\%lx", probe_conf.magic_num); 1464 if (ret < 0) 1465 return -ENOMEM; 1466 /* Note that type can be NULL */ 1467 if (type) { 1468 tevs[j].args[i].type = strdup(type); 1469 if (!tevs[j].args[i].type) 1470 return -ENOMEM; 1471 } 1472 } 1473 } 1474 return 0; 1475} 1476 1477/* Find probe_trace_events specified by perf_probe_event from debuginfo */ 1478int debuginfo__find_trace_events(struct debuginfo *dbg, 1479 struct perf_probe_event *pev, 1480 struct probe_trace_event **tevs) 1481{ 1482 struct trace_event_finder tf = { 1483 .pf = {.pev = pev, .dbg = dbg, .callback = add_probe_trace_event}, 1484 .max_tevs = probe_conf.max_probes, .mod = dbg->mod}; 1485 int ret, i; 1486 1487 /* Allocate result tevs array */ 1488 *tevs = zalloc(sizeof(struct probe_trace_event) * tf.max_tevs); 1489 if (*tevs == NULL) 1490 return -ENOMEM; 1491 1492 tf.tevs = *tevs; 1493 tf.ntevs = 0; 1494 1495 if (pev->nargs != 0 && immediate_value_is_supported()) 1496 tf.pf.skip_empty_arg = true; 1497 1498 ret = debuginfo__find_probes(dbg, &tf.pf); 1499 if (ret >= 0 && tf.pf.skip_empty_arg) 1500 ret = fill_empty_trace_arg(pev, tf.tevs, tf.ntevs); 1501 1502 if (ret < 0 || tf.ntevs == 0) { 1503 for (i = 0; i < tf.ntevs; i++) 1504 clear_probe_trace_event(&tf.tevs[i]); 1505 zfree(tevs); 1506 return ret; 1507 } 1508 1509 return (ret < 0) ? ret : tf.ntevs; 1510} 1511 1512/* Collect available variables in this scope */ 1513static int collect_variables_cb(Dwarf_Die *die_mem, void *data) 1514{ 1515 struct available_var_finder *af = data; 1516 struct variable_list *vl; 1517 struct strbuf buf = STRBUF_INIT; 1518 int tag, ret; 1519 1520 vl = &af->vls[af->nvls - 1]; 1521 1522 tag = dwarf_tag(die_mem); 1523 if (tag == DW_TAG_formal_parameter || 1524 tag == DW_TAG_variable) { 1525 ret = convert_variable_location(die_mem, af->pf.addr, 1526 af->pf.fb_ops, &af->pf.sp_die, 1527 af->pf.machine, NULL); 1528 if (ret == 0 || ret == -ERANGE) { 1529 int ret2; 1530 bool externs = !af->child; 1531 1532 if (strbuf_init(&buf, 64) < 0) 1533 goto error; 1534 1535 if (probe_conf.show_location_range) { 1536 if (!externs) 1537 ret2 = strbuf_add(&buf, 1538 ret ? "[INV]\t" : "[VAL]\t", 6); 1539 else 1540 ret2 = strbuf_add(&buf, "[EXT]\t", 6); 1541 if (ret2) 1542 goto error; 1543 } 1544 1545 ret2 = die_get_varname(die_mem, &buf); 1546 1547 if (!ret2 && probe_conf.show_location_range && 1548 !externs) { 1549 if (strbuf_addch(&buf, '\t') < 0) 1550 goto error; 1551 ret2 = die_get_var_range(&af->pf.sp_die, 1552 die_mem, &buf); 1553 } 1554 1555 pr_debug("Add new var: %s\n", buf.buf); 1556 if (ret2 == 0) { 1557 strlist__add(vl->vars, 1558 strbuf_detach(&buf, NULL)); 1559 } 1560 strbuf_release(&buf); 1561 } 1562 } 1563 1564 if (af->child && dwarf_haspc(die_mem, af->pf.addr)) 1565 return DIE_FIND_CB_CONTINUE; 1566 else 1567 return DIE_FIND_CB_SIBLING; 1568error: 1569 strbuf_release(&buf); 1570 pr_debug("Error in strbuf\n"); 1571 return DIE_FIND_CB_END; 1572} 1573 1574static bool available_var_finder_overlap(struct available_var_finder *af) 1575{ 1576 int i; 1577 1578 for (i = 0; i < af->nvls; i++) { 1579 if (af->pf.addr == af->vls[i].point.address) 1580 return true; 1581 } 1582 return false; 1583 1584} 1585 1586/* Add a found vars into available variables list */ 1587static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf) 1588{ 1589 struct available_var_finder *af = 1590 container_of(pf, struct available_var_finder, pf); 1591 struct perf_probe_point *pp = &pf->pev->point; 1592 struct variable_list *vl; 1593 Dwarf_Die die_mem; 1594 int ret; 1595 1596 /* 1597 * For some reason (e.g. different column assigned to same address), 1598 * this callback can be called with the address which already passed. 1599 * Ignore it first. 1600 */ 1601 if (available_var_finder_overlap(af)) 1602 return 0; 1603 1604 /* Check number of tevs */ 1605 if (af->nvls == af->max_vls) { 1606 pr_warning("Too many( > %d) probe point found.\n", af->max_vls); 1607 return -ERANGE; 1608 } 1609 vl = &af->vls[af->nvls++]; 1610 1611 /* Trace point should be converted from subprogram DIE */ 1612 ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr, 1613 pp->retprobe, pp->function, &vl->point); 1614 if (ret < 0) 1615 return ret; 1616 1617 pr_debug("Probe point found: %s+%lu\n", vl->point.symbol, 1618 vl->point.offset); 1619 1620 /* Find local variables */ 1621 vl->vars = strlist__new(NULL, NULL); 1622 if (vl->vars == NULL) 1623 return -ENOMEM; 1624 af->child = true; 1625 die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem); 1626 1627 /* Find external variables */ 1628 if (!probe_conf.show_ext_vars) 1629 goto out; 1630 /* Don't need to search child DIE for external vars. */ 1631 af->child = false; 1632 die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem); 1633 1634out: 1635 if (strlist__empty(vl->vars)) { 1636 strlist__delete(vl->vars); 1637 vl->vars = NULL; 1638 } 1639 1640 return ret; 1641} 1642 1643/* 1644 * Find available variables at given probe point 1645 * Return the number of found probe points. Return 0 if there is no 1646 * matched probe point. Return <0 if an error occurs. 1647 */ 1648int debuginfo__find_available_vars_at(struct debuginfo *dbg, 1649 struct perf_probe_event *pev, 1650 struct variable_list **vls) 1651{ 1652 struct available_var_finder af = { 1653 .pf = {.pev = pev, .dbg = dbg, .callback = add_available_vars}, 1654 .mod = dbg->mod, 1655 .max_vls = probe_conf.max_probes}; 1656 int ret; 1657 1658 /* Allocate result vls array */ 1659 *vls = zalloc(sizeof(struct variable_list) * af.max_vls); 1660 if (*vls == NULL) 1661 return -ENOMEM; 1662 1663 af.vls = *vls; 1664 af.nvls = 0; 1665 1666 ret = debuginfo__find_probes(dbg, &af.pf); 1667 if (ret < 0) { 1668 /* Free vlist for error */ 1669 while (af.nvls--) { 1670 zfree(&af.vls[af.nvls].point.symbol); 1671 strlist__delete(af.vls[af.nvls].vars); 1672 } 1673 zfree(vls); 1674 return ret; 1675 } 1676 1677 return (ret < 0) ? ret : af.nvls; 1678} 1679 1680/* For the kernel module, we need a special code to get a DIE */ 1681int debuginfo__get_text_offset(struct debuginfo *dbg, Dwarf_Addr *offs, 1682 bool adjust_offset) 1683{ 1684 int n, i; 1685 Elf32_Word shndx; 1686 Elf_Scn *scn; 1687 Elf *elf; 1688 GElf_Shdr mem, *shdr; 1689 const char *p; 1690 1691 elf = dwfl_module_getelf(dbg->mod, &dbg->bias); 1692 if (!elf) 1693 return -EINVAL; 1694 1695 /* Get the number of relocations */ 1696 n = dwfl_module_relocations(dbg->mod); 1697 if (n < 0) 1698 return -ENOENT; 1699 /* Search the relocation related .text section */ 1700 for (i = 0; i < n; i++) { 1701 p = dwfl_module_relocation_info(dbg->mod, i, &shndx); 1702 if (strcmp(p, ".text") == 0) { 1703 /* OK, get the section header */ 1704 scn = elf_getscn(elf, shndx); 1705 if (!scn) 1706 return -ENOENT; 1707 shdr = gelf_getshdr(scn, &mem); 1708 if (!shdr) 1709 return -ENOENT; 1710 *offs = shdr->sh_addr; 1711 if (adjust_offset) 1712 *offs -= shdr->sh_offset; 1713 } 1714 } 1715 return 0; 1716} 1717 1718/* Reverse search */ 1719int debuginfo__find_probe_point(struct debuginfo *dbg, u64 addr, 1720 struct perf_probe_point *ppt) 1721{ 1722 Dwarf_Die cudie, spdie, indie; 1723 Dwarf_Addr _addr = 0, baseaddr = 0; 1724 const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp; 1725 int baseline = 0, lineno = 0, ret = 0; 1726 1727 /* We always need to relocate the address for aranges */ 1728 if (debuginfo__get_text_offset(dbg, &baseaddr, false) == 0) 1729 addr += baseaddr; 1730 /* Find cu die */ 1731 if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr, &cudie)) { 1732 pr_warning("Failed to find debug information for address %#" PRIx64 "\n", 1733 addr); 1734 ret = -EINVAL; 1735 goto end; 1736 } 1737 1738 /* Find a corresponding line (filename and lineno) */ 1739 cu_find_lineinfo(&cudie, (Dwarf_Addr)addr, &fname, &lineno); 1740 /* Don't care whether it failed or not */ 1741 1742 /* Find a corresponding function (name, baseline and baseaddr) */ 1743 if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) { 1744 /* Get function entry information */ 1745 func = basefunc = dwarf_diename(&spdie); 1746 if (!func || 1747 die_entrypc(&spdie, &baseaddr) != 0 || 1748 dwarf_decl_line(&spdie, &baseline) != 0) { 1749 lineno = 0; 1750 goto post; 1751 } 1752 1753 fname = die_get_decl_file(&spdie); 1754 if (addr == baseaddr) { 1755 /* Function entry - Relative line number is 0 */ 1756 lineno = baseline; 1757 goto post; 1758 } 1759 1760 /* Track down the inline functions step by step */ 1761 while (die_find_top_inlinefunc(&spdie, (Dwarf_Addr)addr, 1762 &indie)) { 1763 /* There is an inline function */ 1764 if (die_entrypc(&indie, &_addr) == 0 && 1765 _addr == addr) { 1766 /* 1767 * addr is at an inline function entry. 1768 * In this case, lineno should be the call-site 1769 * line number. (overwrite lineinfo) 1770 */ 1771 lineno = die_get_call_lineno(&indie); 1772 fname = die_get_call_file(&indie); 1773 break; 1774 } else { 1775 /* 1776 * addr is in an inline function body. 1777 * Since lineno points one of the lines 1778 * of the inline function, baseline should 1779 * be the entry line of the inline function. 1780 */ 1781 tmp = dwarf_diename(&indie); 1782 if (!tmp || 1783 dwarf_decl_line(&indie, &baseline) != 0) 1784 break; 1785 func = tmp; 1786 spdie = indie; 1787 } 1788 } 1789 /* Verify the lineno and baseline are in a same file */ 1790 tmp = die_get_decl_file(&spdie); 1791 if (!tmp || (fname && strcmp(tmp, fname) != 0)) 1792 lineno = 0; 1793 } 1794 1795post: 1796 /* Make a relative line number or an offset */ 1797 if (lineno) 1798 ppt->line = lineno - baseline; 1799 else if (basefunc) { 1800 ppt->offset = addr - baseaddr; 1801 func = basefunc; 1802 } 1803 1804 /* Duplicate strings */ 1805 if (func) { 1806 ppt->function = strdup(func); 1807 if (ppt->function == NULL) { 1808 ret = -ENOMEM; 1809 goto end; 1810 } 1811 } 1812 if (fname) { 1813 ppt->file = strdup(fname); 1814 if (ppt->file == NULL) { 1815 zfree(&ppt->function); 1816 ret = -ENOMEM; 1817 goto end; 1818 } 1819 } 1820end: 1821 if (ret == 0 && (fname || func)) 1822 ret = 1; /* Found a point */ 1823 return ret; 1824} 1825 1826/* Add a line and store the src path */ 1827static int line_range_add_line(const char *src, unsigned int lineno, 1828 struct line_range *lr) 1829{ 1830 /* Copy source path */ 1831 if (!lr->path) { 1832 lr->path = strdup(src); 1833 if (lr->path == NULL) 1834 return -ENOMEM; 1835 } 1836 return intlist__add(lr->line_list, lineno); 1837} 1838 1839static int line_range_walk_cb(const char *fname, int lineno, 1840 Dwarf_Addr addr, void *data) 1841{ 1842 struct line_finder *lf = data; 1843 const char *__fname; 1844 int __lineno; 1845 int err; 1846 1847 if ((strtailcmp(fname, lf->fname) != 0) || 1848 (lf->lno_s > lineno || lf->lno_e < lineno)) 1849 return 0; 1850 1851 /* Make sure this line can be reversible */ 1852 if (cu_find_lineinfo(&lf->cu_die, addr, &__fname, &__lineno) > 0 1853 && (lineno != __lineno || strcmp(fname, __fname))) 1854 return 0; 1855 1856 err = line_range_add_line(fname, lineno, lf->lr); 1857 if (err < 0 && err != -EEXIST) 1858 return err; 1859 1860 return 0; 1861} 1862 1863/* Find line range from its line number */ 1864static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf) 1865{ 1866 int ret; 1867 1868 ret = die_walk_lines(sp_die ?: &lf->cu_die, line_range_walk_cb, lf); 1869 1870 /* Update status */ 1871 if (ret >= 0) 1872 if (!intlist__empty(lf->lr->line_list)) 1873 ret = lf->found = 1; 1874 else 1875 ret = 0; /* Lines are not found */ 1876 else { 1877 zfree(&lf->lr->path); 1878 } 1879 return ret; 1880} 1881 1882static int line_range_inline_cb(Dwarf_Die *in_die, void *data) 1883{ 1884 int ret = find_line_range_by_line(in_die, data); 1885 1886 /* 1887 * We have to check all instances of inlined function, because 1888 * some execution paths can be optimized out depends on the 1889 * function argument of instances. However, if an error occurs, 1890 * it should be handled by the caller. 1891 */ 1892 return ret < 0 ? ret : 0; 1893} 1894 1895/* Search function definition from function name */ 1896static int line_range_search_cb(Dwarf_Die *sp_die, void *data) 1897{ 1898 struct dwarf_callback_param *param = data; 1899 struct line_finder *lf = param->data; 1900 struct line_range *lr = lf->lr; 1901 const char *fname; 1902 1903 /* Check declared file */ 1904 if (lr->file) { 1905 fname = die_get_decl_file(sp_die); 1906 if (!fname || strtailcmp(lr->file, fname)) 1907 return DWARF_CB_OK; 1908 } 1909 1910 if (die_match_name(sp_die, lr->function) && die_is_func_def(sp_die)) { 1911 lf->fname = die_get_decl_file(sp_die); 1912 dwarf_decl_line(sp_die, &lr->offset); 1913 pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset); 1914 lf->lno_s = lr->offset + lr->start; 1915 if (lf->lno_s < 0) /* Overflow */ 1916 lf->lno_s = INT_MAX; 1917 lf->lno_e = lr->offset + lr->end; 1918 if (lf->lno_e < 0) /* Overflow */ 1919 lf->lno_e = INT_MAX; 1920 pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e); 1921 lr->start = lf->lno_s; 1922 lr->end = lf->lno_e; 1923 if (!die_is_func_instance(sp_die)) 1924 param->retval = die_walk_instances(sp_die, 1925 line_range_inline_cb, lf); 1926 else 1927 param->retval = find_line_range_by_line(sp_die, lf); 1928 return DWARF_CB_ABORT; 1929 } 1930 return DWARF_CB_OK; 1931} 1932 1933static int find_line_range_by_func(struct line_finder *lf) 1934{ 1935 struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0}; 1936 dwarf_getfuncs(&lf->cu_die, line_range_search_cb, ¶m, 0); 1937 return param.retval; 1938} 1939 1940int debuginfo__find_line_range(struct debuginfo *dbg, struct line_range *lr) 1941{ 1942 struct line_finder lf = {.lr = lr, .found = 0}; 1943 int ret = 0; 1944 Dwarf_Off off = 0, noff; 1945 size_t cuhl; 1946 Dwarf_Die *diep; 1947 const char *comp_dir; 1948 1949 /* Fastpath: lookup by function name from .debug_pubnames section */ 1950 if (lr->function) { 1951 struct pubname_callback_param pubname_param = { 1952 .function = lr->function, .file = lr->file, 1953 .cu_die = &lf.cu_die, .sp_die = &lf.sp_die, .found = 0}; 1954 struct dwarf_callback_param line_range_param = { 1955 .data = (void *)&lf, .retval = 0}; 1956 1957 dwarf_getpubnames(dbg->dbg, pubname_search_cb, 1958 &pubname_param, 0); 1959 if (pubname_param.found) { 1960 line_range_search_cb(&lf.sp_die, &line_range_param); 1961 if (lf.found) 1962 goto found; 1963 } 1964 } 1965 1966 /* Loop on CUs (Compilation Unit) */ 1967 while (!lf.found && ret >= 0) { 1968 if (dwarf_nextcu(dbg->dbg, off, &noff, &cuhl, 1969 NULL, NULL, NULL) != 0) 1970 break; 1971 1972 /* Get the DIE(Debugging Information Entry) of this CU */ 1973 diep = dwarf_offdie(dbg->dbg, off + cuhl, &lf.cu_die); 1974 if (!diep) { 1975 off = noff; 1976 continue; 1977 } 1978 1979 /* Check if target file is included. */ 1980 if (lr->file) 1981 lf.fname = cu_find_realpath(&lf.cu_die, lr->file); 1982 else 1983 lf.fname = 0; 1984 1985 if (!lr->file || lf.fname) { 1986 if (lr->function) 1987 ret = find_line_range_by_func(&lf); 1988 else { 1989 lf.lno_s = lr->start; 1990 lf.lno_e = lr->end; 1991 ret = find_line_range_by_line(NULL, &lf); 1992 } 1993 } 1994 off = noff; 1995 } 1996 1997found: 1998 /* Store comp_dir */ 1999 if (lf.found) { 2000 comp_dir = cu_get_comp_dir(&lf.cu_die); 2001 if (comp_dir) { 2002 lr->comp_dir = strdup(comp_dir); 2003 if (!lr->comp_dir) 2004 ret = -ENOMEM; 2005 } 2006 } 2007 2008 pr_debug("path: %s\n", lr->path); 2009 return (ret < 0) ? ret : lf.found; 2010} 2011 2012#ifdef HAVE_DEBUGINFOD_SUPPORT 2013/* debuginfod doesn't require the comp_dir but buildid is required */ 2014static int get_source_from_debuginfod(const char *raw_path, 2015 const char *sbuild_id, char **new_path) 2016{ 2017 debuginfod_client *c = debuginfod_begin(); 2018 const char *p = raw_path; 2019 int fd; 2020 2021 if (!c) 2022 return -ENOMEM; 2023 2024 fd = debuginfod_find_source(c, (const unsigned char *)sbuild_id, 2025 0, p, new_path); 2026 pr_debug("Search %s from debuginfod -> %d\n", p, fd); 2027 if (fd >= 0) 2028 close(fd); 2029 debuginfod_end(c); 2030 if (fd < 0) { 2031 pr_debug("Failed to find %s in debuginfod (%s)\n", 2032 raw_path, sbuild_id); 2033 return -ENOENT; 2034 } 2035 pr_debug("Got a source %s\n", *new_path); 2036 2037 return 0; 2038} 2039#else 2040static inline int get_source_from_debuginfod(const char *raw_path __maybe_unused, 2041 const char *sbuild_id __maybe_unused, 2042 char **new_path __maybe_unused) 2043{ 2044 return -ENOTSUP; 2045} 2046#endif 2047/* 2048 * Find a src file from a DWARF tag path. Prepend optional source path prefix 2049 * and chop off leading directories that do not exist. Result is passed back as 2050 * a newly allocated path on success. 2051 * Return 0 if file was found and readable, -errno otherwise. 2052 */ 2053int find_source_path(const char *raw_path, const char *sbuild_id, 2054 const char *comp_dir, char **new_path) 2055{ 2056 const char *prefix = symbol_conf.source_prefix; 2057 2058 if (sbuild_id && !prefix) { 2059 if (!get_source_from_debuginfod(raw_path, sbuild_id, new_path)) 2060 return 0; 2061 } 2062 2063 if (!prefix) { 2064 if (raw_path[0] != '/' && comp_dir) 2065 /* If not an absolute path, try to use comp_dir */ 2066 prefix = comp_dir; 2067 else { 2068 if (access(raw_path, R_OK) == 0) { 2069 *new_path = strdup(raw_path); 2070 return *new_path ? 0 : -ENOMEM; 2071 } else 2072 return -errno; 2073 } 2074 } 2075 2076 *new_path = malloc((strlen(prefix) + strlen(raw_path) + 2)); 2077 if (!*new_path) 2078 return -ENOMEM; 2079 2080 for (;;) { 2081 sprintf(*new_path, "%s/%s", prefix, raw_path); 2082 2083 if (access(*new_path, R_OK) == 0) 2084 return 0; 2085 2086 if (!symbol_conf.source_prefix) { 2087 /* In case of searching comp_dir, don't retry */ 2088 zfree(new_path); 2089 return -errno; 2090 } 2091 2092 switch (errno) { 2093 case ENAMETOOLONG: 2094 case ENOENT: 2095 case EROFS: 2096 case EFAULT: 2097 raw_path = strchr(++raw_path, '/'); 2098 if (!raw_path) { 2099 zfree(new_path); 2100 return -ENOENT; 2101 } 2102 continue; 2103 2104 default: 2105 zfree(new_path); 2106 return -errno; 2107 } 2108 } 2109} 2110