tools/perf/util/probe-event.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * probe-event.c : perf-probe definition to probe_events format 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 <limits.h>
  20 #include <elf.h>
  21
  22 #include "build-id.h"
  23 #include "event.h"
  24 #include "namespaces.h"
  25 #include "strlist.h"
  26 #include "strfilter.h"
  27 #include "debug.h"
  28 #include "dso.h"
  29 #include "color.h"
  30 #include "map.h"
  31 #include "maps.h"
  32 #include "symbol.h"
  33 #include <api/fs/fs.h>
  34 #include "trace-event.h"        /* For __maybe_unused */
  35 #include "probe-event.h"
  36 #include "probe-finder.h"
  37 #include "probe-file.h"
  38 #include "session.h"
  39 #include "string2.h"
  40 #include "strbuf.h"
  41
  42 #include <subcmd/pager.h>
  43 #include <linux/ctype.h>
  44 #include <linux/zalloc.h>
  45
  46 #define PERFPROBE_GROUP "probe"
  47
  48 bool probe_event_dry_run;       /* Dry run flag */
  49 struct probe_conf probe_conf = { .magic_num = DEFAULT_PROBE_MAGIC_NUM };
  50
  51 #define semantic_error(msg ...) pr_err("Semantic error :" msg)
  52
  53 int e_snprintf(char *str, size_t size, const char *format, ...)
  54 {
  55         int ret;
  56         va_list ap;
  57         va_start(ap, format);
  58         ret = vsnprintf(str, size, format, ap);
  59         va_end(ap);
  60         if (ret >= (int)size)
  61                 ret = -E2BIG;
  62         return ret;
  63 }
  64
  65 static struct machine *host_machine;
  66
  67 /* Initialize symbol maps and path of vmlinux/modules */
  68 int init_probe_symbol_maps(bool user_only)
  69 {
  70         int ret;
  71
  72         symbol_conf.sort_by_name = true;
  73         symbol_conf.allow_aliases = true;
  74         ret = symbol__init(NULL);
  75         if (ret < 0) {
  76                 pr_debug("Failed to init symbol map.\n");
  77                 goto out;
  78         }
  79
  80         if (host_machine || user_only)  /* already initialized */
  81                 return 0;
  82
  83         if (symbol_conf.vmlinux_name)
  84                 pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
  85
  86         host_machine = machine__new_host();
  87         if (!host_machine) {
  88                 pr_debug("machine__new_host() failed.\n");
  89                 symbol__exit();
  90                 ret = -1;
  91         }
  92 out:
  93         if (ret < 0)
  94                 pr_warning("Failed to init vmlinux path.\n");
  95         return ret;
  96 }
  97
  98 void exit_probe_symbol_maps(void)
  99 {
 100         machine__delete(host_machine);
 101         host_machine = NULL;
 102         symbol__exit();
 103 }
 104
 105 static struct ref_reloc_sym *kernel_get_ref_reloc_sym(struct map **pmap)
 106 {
 107         /* kmap->ref_reloc_sym should be set if host_machine is initialized */
 108         struct kmap *kmap;
 109         struct map *map = machine__kernel_map(host_machine);
 110
 111         if (map__load(map) < 0)
 112                 return NULL;
 113
 114         kmap = map__kmap(map);
 115         if (!kmap)
 116                 return NULL;
 117
 118         if (pmap)
 119                 *pmap = map;
 120
 121         return kmap->ref_reloc_sym;
 122 }
 123
 124 static int kernel_get_symbol_address_by_name(const char *name, u64 *addr,
 125                                              bool reloc, bool reladdr)
 126 {
 127         struct ref_reloc_sym *reloc_sym;
 128         struct symbol *sym;
 129         struct map *map;
 130
 131         /* ref_reloc_sym is just a label. Need a special fix*/
 132         reloc_sym = kernel_get_ref_reloc_sym(NULL);
 133         if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
 134                 *addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
 135         else {
 136                 sym = machine__find_kernel_symbol_by_name(host_machine, name, &map);
 137                 if (!sym)
 138                         return -ENOENT;
 139                 *addr = map->unmap_ip(map, sym->start) -
 140                         ((reloc) ? 0 : map->reloc) -
 141                         ((reladdr) ? map->start : 0);
 142         }
 143         return 0;
 144 }
 145
 146 static struct map *kernel_get_module_map(const char *module)
 147 {
 148         struct maps *maps = machine__kernel_maps(host_machine);
 149         struct map *pos;
 150
 151         /* A file path -- this is an offline module */
 152         if (module && strchr(module, '/'))
 153                 return dso__new_map(module);
 154
 155         if (!module) {
 156                 pos = machine__kernel_map(host_machine);
 157                 return map__get(pos);
 158         }
 159
 160         maps__for_each_entry(maps, pos) {
 161                 /* short_name is "[module]" */
 162                 if (strncmp(pos->dso->short_name + 1, module,
 163                             pos->dso->short_name_len - 2) == 0 &&
 164                     module[pos->dso->short_name_len - 2] == '\0') {
 165                         return map__get(pos);
 166                 }
 167         }
 168         return NULL;
 169 }
 170
 171 struct map *get_target_map(const char *target, struct nsinfo *nsi, bool user)
 172 {
 173         /* Init maps of given executable or kernel */
 174         if (user) {
 175                 struct map *map;
 176
 177                 map = dso__new_map(target);
 178                 if (map && map->dso)
 179                         map->dso->nsinfo = nsinfo__get(nsi);
 180                 return map;
 181         } else {
 182                 return kernel_get_module_map(target);
 183         }
 184 }
 185
 186 static int convert_exec_to_group(const char *exec, char **result)
 187 {
 188         char *ptr1, *ptr2, *exec_copy;
 189         char buf[64];
 190         int ret;
 191
 192         exec_copy = strdup(exec);
 193         if (!exec_copy)
 194                 return -ENOMEM;
 195
 196         ptr1 = basename(exec_copy);
 197         if (!ptr1) {
 198                 ret = -EINVAL;
 199                 goto out;
 200         }
 201
 202         for (ptr2 = ptr1; *ptr2 != '\0'; ptr2++) {
 203                 if (!isalnum(*ptr2) && *ptr2 != '_') {
 204                         *ptr2 = '\0';
 205                         break;
 206                 }
 207         }
 208
 209         ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
 210         if (ret < 0)
 211                 goto out;
 212
 213         *result = strdup(buf);
 214         ret = *result ? 0 : -ENOMEM;
 215
 216 out:
 217         free(exec_copy);
 218         return ret;
 219 }
 220
 221 static void clear_perf_probe_point(struct perf_probe_point *pp)
 222 {
 223         zfree(&pp->file);
 224         zfree(&pp->function);
 225         zfree(&pp->lazy_line);
 226 }
 227
 228 static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 229 {
 230         int i;
 231
 232         for (i = 0; i < ntevs; i++)
 233                 clear_probe_trace_event(tevs + i);
 234 }
 235
 236 static bool kprobe_blacklist__listed(unsigned long address);
 237 static bool kprobe_warn_out_range(const char *symbol, unsigned long address)
 238 {
 239         struct map *map;
 240         bool ret = false;
 241
 242         map = kernel_get_module_map(NULL);
 243         if (map) {
 244                 ret = address <= map->start || map->end < address;
 245                 if (ret)
 246                         pr_warning("%s is out of .text, skip it.\n", symbol);
 247                 map__put(map);
 248         }
 249         if (!ret && kprobe_blacklist__listed(address)) {
 250                 pr_warning("%s is blacklisted function, skip it.\n", symbol);
 251                 ret = true;
 252         }
 253
 254         return ret;
 255 }
 256
 257 /*
 258  * @module can be module name of module file path. In case of path,
 259  * inspect elf and find out what is actual module name.
 260  * Caller has to free mod_name after using it.
 261  */
 262 static char *find_module_name(const char *module)
 263 {
 264         int fd;
 265         Elf *elf;
 266         GElf_Ehdr ehdr;
 267         GElf_Shdr shdr;
 268         Elf_Data *data;
 269         Elf_Scn *sec;
 270         char *mod_name = NULL;
 271         int name_offset;
 272
 273         fd = open(module, O_RDONLY);
 274         if (fd < 0)
 275                 return NULL;
 276
 277         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 278         if (elf == NULL)
 279                 goto elf_err;
 280
 281         if (gelf_getehdr(elf, &ehdr) == NULL)
 282                 goto ret_err;
 283
 284         sec = elf_section_by_name(elf, &ehdr, &shdr,
 285                         ".gnu.linkonce.this_module", NULL);
 286         if (!sec)
 287                 goto ret_err;
 288
 289         data = elf_getdata(sec, NULL);
 290         if (!data || !data->d_buf)
 291                 goto ret_err;
 292
 293         /*
 294          * NOTE:
 295          * '.gnu.linkonce.this_module' section of kernel module elf directly
 296          * maps to 'struct module' from linux/module.h. This section contains
 297          * actual module name which will be used by kernel after loading it.
 298          * But, we cannot use 'struct module' here since linux/module.h is not
 299          * exposed to user-space. Offset of 'name' has remained same from long
 300          * time, so hardcoding it here.
 301          */
 302         if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
 303                 name_offset = 12;
 304         else    /* expect ELFCLASS64 by default */
 305                 name_offset = 24;
 306
 307         mod_name = strdup((char *)data->d_buf + name_offset);
 308
 309 ret_err:
 310         elf_end(elf);
 311 elf_err:
 312         close(fd);
 313         return mod_name;
 314 }
 315
 316 #ifdef HAVE_DWARF_SUPPORT
 317
 318 static int kernel_get_module_dso(const char *module, struct dso **pdso)
 319 {
 320         struct dso *dso;
 321         struct map *map;
 322         const char *vmlinux_name;
 323         int ret = 0;
 324
 325         if (module) {
 326                 char module_name[128];
 327
 328                 snprintf(module_name, sizeof(module_name), "[%s]", module);
 329                 map = maps__find_by_name(&host_machine->kmaps, module_name);
 330                 if (map) {
 331                         dso = map->dso;
 332                         goto found;
 333                 }
 334                 pr_debug("Failed to find module %s.\n", module);
 335                 return -ENOENT;
 336         }
 337
 338         map = machine__kernel_map(host_machine);
 339         dso = map->dso;
 340
 341         vmlinux_name = symbol_conf.vmlinux_name;
 342         dso->load_errno = 0;
 343         if (vmlinux_name)
 344                 ret = dso__load_vmlinux(dso, map, vmlinux_name, false);
 345         else
 346                 ret = dso__load_vmlinux_path(dso, map);
 347 found:
 348         *pdso = dso;
 349         return ret;
 350 }
 351
 352 /*
 353  * Some binaries like glibc have special symbols which are on the symbol
 354  * table, but not in the debuginfo. If we can find the address of the
 355  * symbol from map, we can translate the address back to the probe point.
 356  */
 357 static int find_alternative_probe_point(struct debuginfo *dinfo,
 358                                         struct perf_probe_point *pp,
 359                                         struct perf_probe_point *result,
 360                                         const char *target, struct nsinfo *nsi,
 361                                         bool uprobes)
 362 {
 363         struct map *map = NULL;
 364         struct symbol *sym;
 365         u64 address = 0;
 366         int ret = -ENOENT;
 367
 368         /* This can work only for function-name based one */
 369         if (!pp->function || pp->file)
 370                 return -ENOTSUP;
 371
 372         map = get_target_map(target, nsi, uprobes);
 373         if (!map)
 374                 return -EINVAL;
 375
 376         /* Find the address of given function */
 377         map__for_each_symbol_by_name(map, pp->function, sym) {
 378                 if (uprobes) {
 379                         address = sym->start;
 380                         if (sym->type == STT_GNU_IFUNC)
 381                                 pr_warning("Warning: The probe function (%s) is a GNU indirect function.\n"
 382                                            "Consider identifying the final function used at run time and set the probe directly on that.\n",
 383                                            pp->function);
 384                 } else
 385                         address = map->unmap_ip(map, sym->start) - map->reloc;
 386                 break;
 387         }
 388         if (!address) {
 389                 ret = -ENOENT;
 390                 goto out;
 391         }
 392         pr_debug("Symbol %s address found : %" PRIx64 "\n",
 393                         pp->function, address);
 394
 395         ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
 396                                           result);
 397         if (ret <= 0)
 398                 ret = (!ret) ? -ENOENT : ret;
 399         else {
 400                 result->offset += pp->offset;
 401                 result->line += pp->line;
 402                 result->retprobe = pp->retprobe;
 403                 ret = 0;
 404         }
 405
 406 out:
 407         map__put(map);
 408         return ret;
 409
 410 }
 411
 412 static int get_alternative_probe_event(struct debuginfo *dinfo,
 413                                        struct perf_probe_event *pev,
 414                                        struct perf_probe_point *tmp)
 415 {
 416         int ret;
 417
 418         memcpy(tmp, &pev->point, sizeof(*tmp));
 419         memset(&pev->point, 0, sizeof(pev->point));
 420         ret = find_alternative_probe_point(dinfo, tmp, &pev->point, pev->target,
 421                                            pev->nsi, pev->uprobes);
 422         if (ret < 0)
 423                 memcpy(&pev->point, tmp, sizeof(*tmp));
 424
 425         return ret;
 426 }
 427
 428 static int get_alternative_line_range(struct debuginfo *dinfo,
 429                                       struct line_range *lr,
 430                                       const char *target, bool user)
 431 {
 432         struct perf_probe_point pp = { .function = lr->function,
 433                                        .file = lr->file,
 434                                        .line = lr->start };
 435         struct perf_probe_point result;
 436         int ret, len = 0;
 437
 438         memset(&result, 0, sizeof(result));
 439
 440         if (lr->end != INT_MAX)
 441                 len = lr->end - lr->start;
 442         ret = find_alternative_probe_point(dinfo, &pp, &result,
 443                                            target, NULL, user);
 444         if (!ret) {
 445                 lr->function = result.function;
 446                 lr->file = result.file;
 447                 lr->start = result.line;
 448                 if (lr->end != INT_MAX)
 449                         lr->end = lr->start + len;
 450                 clear_perf_probe_point(&pp);
 451         }
 452         return ret;
 453 }
 454
 455 /* Open new debuginfo of given module */
 456 static struct debuginfo *open_debuginfo(const char *module, struct nsinfo *nsi,
 457                                         bool silent)
 458 {
 459         const char *path = module;
 460         char reason[STRERR_BUFSIZE];
 461         struct debuginfo *ret = NULL;
 462         struct dso *dso = NULL;
 463         struct nscookie nsc;
 464         int err;
 465
 466         if (!module || !strchr(module, '/')) {
 467                 err = kernel_get_module_dso(module, &dso);
 468                 if (err < 0) {
 469                         if (!dso || dso->load_errno == 0) {
 470                                 if (!str_error_r(-err, reason, STRERR_BUFSIZE))
 471                                         strcpy(reason, "(unknown)");
 472                         } else
 473                                 dso__strerror_load(dso, reason, STRERR_BUFSIZE);
 474                         if (!silent) {
 475                                 if (module)
 476                                         pr_err("Module %s is not loaded, please specify its full path name.\n", module);
 477                                 else
 478                                         pr_err("Failed to find the path for the kernel: %s\n", reason);
 479                         }
 480                         return NULL;
 481                 }
 482                 path = dso->long_name;
 483         }
 484         nsinfo__mountns_enter(nsi, &nsc);
 485         ret = debuginfo__new(path);
 486         if (!ret && !silent) {
 487                 pr_warning("The %s file has no debug information.\n", path);
 488                 if (!module || !strtailcmp(path, ".ko"))
 489                         pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
 490                 else
 491                         pr_warning("Rebuild with -g, ");
 492                 pr_warning("or install an appropriate debuginfo package.\n");
 493         }
 494         nsinfo__mountns_exit(&nsc);
 495         return ret;
 496 }
 497
 498 /* For caching the last debuginfo */
 499 static struct debuginfo *debuginfo_cache;
 500 static char *debuginfo_cache_path;
 501
 502 static struct debuginfo *debuginfo_cache__open(const char *module, bool silent)
 503 {
 504         const char *path = module;
 505
 506         /* If the module is NULL, it should be the kernel. */
 507         if (!module)
 508                 path = "kernel";
 509
 510         if (debuginfo_cache_path && !strcmp(debuginfo_cache_path, path))
 511                 goto out;
 512
 513         /* Copy module path */
 514         free(debuginfo_cache_path);
 515         debuginfo_cache_path = strdup(path);
 516         if (!debuginfo_cache_path) {
 517                 debuginfo__delete(debuginfo_cache);
 518                 debuginfo_cache = NULL;
 519                 goto out;
 520         }
 521
 522         debuginfo_cache = open_debuginfo(module, NULL, silent);
 523         if (!debuginfo_cache)
 524                 zfree(&debuginfo_cache_path);
 525 out:
 526         return debuginfo_cache;
 527 }
 528
 529 static void debuginfo_cache__exit(void)
 530 {
 531         debuginfo__delete(debuginfo_cache);
 532         debuginfo_cache = NULL;
 533         zfree(&debuginfo_cache_path);
 534 }
 535
 536
 537 static int get_text_start_address(const char *exec, unsigned long *address,
 538                                   struct nsinfo *nsi)
 539 {
 540         Elf *elf;
 541         GElf_Ehdr ehdr;
 542         GElf_Shdr shdr;
 543         int fd, ret = -ENOENT;
 544         struct nscookie nsc;
 545
 546         nsinfo__mountns_enter(nsi, &nsc);
 547         fd = open(exec, O_RDONLY);
 548         nsinfo__mountns_exit(&nsc);
 549         if (fd < 0)
 550                 return -errno;
 551
 552         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 553         if (elf == NULL) {
 554                 ret = -EINVAL;
 555                 goto out_close;
 556         }
 557
 558         if (gelf_getehdr(elf, &ehdr) == NULL)
 559                 goto out;
 560
 561         if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
 562                 goto out;
 563
 564         *address = shdr.sh_addr - shdr.sh_offset;
 565         ret = 0;
 566 out:
 567         elf_end(elf);
 568 out_close:
 569         close(fd);
 570
 571         return ret;
 572 }
 573
 574 /*
 575  * Convert trace point to probe point with debuginfo
 576  */
 577 static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
 578                                             struct perf_probe_point *pp,
 579                                             bool is_kprobe)
 580 {
 581         struct debuginfo *dinfo = NULL;
 582         unsigned long stext = 0;
 583         u64 addr = tp->address;
 584         int ret = -ENOENT;
 585
 586         /* convert the address to dwarf address */
 587         if (!is_kprobe) {
 588                 if (!addr) {
 589                         ret = -EINVAL;
 590                         goto error;
 591                 }
 592                 ret = get_text_start_address(tp->module, &stext, NULL);
 593                 if (ret < 0)
 594                         goto error;
 595                 addr += stext;
 596         } else if (tp->symbol) {
 597                 /* If the module is given, this returns relative address */
 598                 ret = kernel_get_symbol_address_by_name(tp->symbol, &addr,
 599                                                         false, !!tp->module);
 600                 if (ret != 0)
 601                         goto error;
 602                 addr += tp->offset;
 603         }
 604
 605         pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
 606                  tp->module ? : "kernel");
 607
 608         dinfo = debuginfo_cache__open(tp->module, verbose <= 0);
 609         if (dinfo)
 610                 ret = debuginfo__find_probe_point(dinfo,
 611                                                  (unsigned long)addr, pp);
 612         else
 613                 ret = -ENOENT;
 614
 615         if (ret > 0) {
 616                 pp->retprobe = tp->retprobe;
 617                 return 0;
 618         }
 619 error:
 620         pr_debug("Failed to find corresponding probes from debuginfo.\n");
 621         return ret ? : -ENOENT;
 622 }
 623
 624 /* Adjust symbol name and address */
 625 static int post_process_probe_trace_point(struct probe_trace_point *tp,
 626                                            struct map *map, unsigned long offs)
 627 {
 628         struct symbol *sym;
 629         u64 addr = tp->address - offs;
 630
 631         sym = map__find_symbol(map, addr);
 632         if (!sym)
 633                 return -ENOENT;
 634
 635         if (strcmp(sym->name, tp->symbol)) {
 636                 /* If we have no realname, use symbol for it */
 637                 if (!tp->realname)
 638                         tp->realname = tp->symbol;
 639                 else
 640                         free(tp->symbol);
 641                 tp->symbol = strdup(sym->name);
 642                 if (!tp->symbol)
 643                         return -ENOMEM;
 644         }
 645         tp->offset = addr - sym->start;
 646         tp->address -= offs;
 647
 648         return 0;
 649 }
 650
 651 /*
 652  * Rename DWARF symbols to ELF symbols -- gcc sometimes optimizes functions
 653  * and generate new symbols with suffixes such as .constprop.N or .isra.N
 654  * etc. Since those symbols are not recorded in DWARF, we have to find
 655  * correct generated symbols from offline ELF binary.
 656  * For online kernel or uprobes we don't need this because those are
 657  * rebased on _text, or already a section relative address.
 658  */
 659 static int
 660 post_process_offline_probe_trace_events(struct probe_trace_event *tevs,
 661                                         int ntevs, const char *pathname)
 662 {
 663         struct map *map;
 664         unsigned long stext = 0;
 665         int i, ret = 0;
 666
 667         /* Prepare a map for offline binary */
 668         map = dso__new_map(pathname);
 669         if (!map || get_text_start_address(pathname, &stext, NULL) < 0) {
 670                 pr_warning("Failed to get ELF symbols for %s\n", pathname);
 671                 return -EINVAL;
 672         }
 673
 674         for (i = 0; i < ntevs; i++) {
 675                 ret = post_process_probe_trace_point(&tevs[i].point,
 676                                                      map, stext);
 677                 if (ret < 0)
 678                         break;
 679         }
 680         map__put(map);
 681
 682         return ret;
 683 }
 684
 685 static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
 686                                           int ntevs, const char *exec,
 687                                           struct nsinfo *nsi)
 688 {
 689         int i, ret = 0;
 690         unsigned long stext = 0;
 691
 692         if (!exec)
 693                 return 0;
 694
 695         ret = get_text_start_address(exec, &stext, nsi);
 696         if (ret < 0)
 697                 return ret;
 698
 699         for (i = 0; i < ntevs && ret >= 0; i++) {
 700                 /* point.address is the address of point.symbol + point.offset */
 701                 tevs[i].point.address -= stext;
 702                 tevs[i].point.module = strdup(exec);
 703                 if (!tevs[i].point.module) {
 704                         ret = -ENOMEM;
 705                         break;
 706                 }
 707                 tevs[i].uprobes = true;
 708         }
 709
 710         return ret;
 711 }
 712
 713 static int
 714 post_process_module_probe_trace_events(struct probe_trace_event *tevs,
 715                                        int ntevs, const char *module,
 716                                        struct debuginfo *dinfo)
 717 {
 718         Dwarf_Addr text_offs = 0;
 719         int i, ret = 0;
 720         char *mod_name = NULL;
 721         struct map *map;
 722
 723         if (!module)
 724                 return 0;
 725
 726         map = get_target_map(module, NULL, false);
 727         if (!map || debuginfo__get_text_offset(dinfo, &text_offs, true) < 0) {
 728                 pr_warning("Failed to get ELF symbols for %s\n", module);
 729                 return -EINVAL;
 730         }
 731
 732         mod_name = find_module_name(module);
 733         for (i = 0; i < ntevs; i++) {
 734                 ret = post_process_probe_trace_point(&tevs[i].point,
 735                                                 map, (unsigned long)text_offs);
 736                 if (ret < 0)
 737                         break;
 738                 tevs[i].point.module =
 739                         strdup(mod_name ? mod_name : module);
 740                 if (!tevs[i].point.module) {
 741                         ret = -ENOMEM;
 742                         break;
 743                 }
 744         }
 745
 746         free(mod_name);
 747         map__put(map);
 748
 749         return ret;
 750 }
 751
 752 static int
 753 post_process_kernel_probe_trace_events(struct probe_trace_event *tevs,
 754                                        int ntevs)
 755 {
 756         struct ref_reloc_sym *reloc_sym;
 757         struct map *map;
 758         char *tmp;
 759         int i, skipped = 0;
 760
 761         /* Skip post process if the target is an offline kernel */
 762         if (symbol_conf.ignore_vmlinux_buildid)
 763                 return post_process_offline_probe_trace_events(tevs, ntevs,
 764                                                 symbol_conf.vmlinux_name);
 765
 766         reloc_sym = kernel_get_ref_reloc_sym(&map);
 767         if (!reloc_sym) {
 768                 pr_warning("Relocated base symbol is not found!\n");
 769                 return -EINVAL;
 770         }
 771
 772         for (i = 0; i < ntevs; i++) {
 773                 if (!tevs[i].point.address)
 774                         continue;
 775                 if (tevs[i].point.retprobe && !kretprobe_offset_is_supported())
 776                         continue;
 777                 /*
 778                  * If we found a wrong one, mark it by NULL symbol.
 779                  * Since addresses in debuginfo is same as objdump, we need
 780                  * to convert it to addresses on memory.
 781                  */
 782                 if (kprobe_warn_out_range(tevs[i].point.symbol,
 783                         map__objdump_2mem(map, tevs[i].point.address))) {
 784                         tmp = NULL;
 785                         skipped++;
 786                 } else {
 787                         tmp = strdup(reloc_sym->name);
 788                         if (!tmp)
 789                                 return -ENOMEM;
 790                 }
 791                 /* If we have no realname, use symbol for it */
 792                 if (!tevs[i].point.realname)
 793                         tevs[i].point.realname = tevs[i].point.symbol;
 794                 else
 795                         free(tevs[i].point.symbol);
 796                 tevs[i].point.symbol = tmp;
 797                 tevs[i].point.offset = tevs[i].point.address -
 798                                        reloc_sym->unrelocated_addr;
 799         }
 800         return skipped;
 801 }
 802
 803 void __weak
 804 arch__post_process_probe_trace_events(struct perf_probe_event *pev __maybe_unused,
 805                                       int ntevs __maybe_unused)
 806 {
 807 }
 808
 809 /* Post processing the probe events */
 810 static int post_process_probe_trace_events(struct perf_probe_event *pev,
 811                                            struct probe_trace_event *tevs,
 812                                            int ntevs, const char *module,
 813                                            bool uprobe, struct debuginfo *dinfo)
 814 {
 815         int ret;
 816
 817         if (uprobe)
 818                 ret = add_exec_to_probe_trace_events(tevs, ntevs, module,
 819                                                      pev->nsi);
 820         else if (module)
 821                 /* Currently ref_reloc_sym based probe is not for drivers */
 822                 ret = post_process_module_probe_trace_events(tevs, ntevs,
 823                                                              module, dinfo);
 824         else
 825                 ret = post_process_kernel_probe_trace_events(tevs, ntevs);
 826
 827         if (ret >= 0)
 828                 arch__post_process_probe_trace_events(pev, ntevs);
 829
 830         return ret;
 831 }
 832
 833 /* Try to find perf_probe_event with debuginfo */
 834 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 835                                           struct probe_trace_event **tevs)
 836 {
 837         bool need_dwarf = perf_probe_event_need_dwarf(pev);
 838         struct perf_probe_point tmp;
 839         struct debuginfo *dinfo;
 840         int ntevs, ret = 0;
 841
 842         dinfo = open_debuginfo(pev->target, pev->nsi, !need_dwarf);
 843         if (!dinfo) {
 844                 if (need_dwarf)
 845                         return -ENOENT;
 846                 pr_debug("Could not open debuginfo. Try to use symbols.\n");
 847                 return 0;
 848         }
 849
 850         pr_debug("Try to find probe point from debuginfo.\n");
 851         /* Searching trace events corresponding to a probe event */
 852         ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
 853
 854         if (ntevs == 0) {  /* Not found, retry with an alternative */
 855                 ret = get_alternative_probe_event(dinfo, pev, &tmp);
 856                 if (!ret) {
 857                         ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
 858                         /*
 859                          * Write back to the original probe_event for
 860                          * setting appropriate (user given) event name
 861                          */
 862                         clear_perf_probe_point(&pev->point);
 863                         memcpy(&pev->point, &tmp, sizeof(tmp));
 864                 }
 865         }
 866
 867         if (ntevs > 0) {        /* Succeeded to find trace events */
 868                 pr_debug("Found %d probe_trace_events.\n", ntevs);
 869                 ret = post_process_probe_trace_events(pev, *tevs, ntevs,
 870                                         pev->target, pev->uprobes, dinfo);
 871                 if (ret < 0 || ret == ntevs) {
 872                         pr_debug("Post processing failed or all events are skipped. (%d)\n", ret);
 873                         clear_probe_trace_events(*tevs, ntevs);
 874                         zfree(tevs);
 875                         ntevs = 0;
 876                 }
 877         }
 878
 879         debuginfo__delete(dinfo);
 880
 881         if (ntevs == 0) {       /* No error but failed to find probe point. */
 882                 pr_warning("Probe point '%s' not found.\n",
 883                            synthesize_perf_probe_point(&pev->point));
 884                 return -ENOENT;
 885         } else if (ntevs < 0) {
 886                 /* Error path : ntevs < 0 */
 887                 pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
 888                 if (ntevs == -EBADF)
 889                         pr_warning("Warning: No dwarf info found in the vmlinux - "
 890                                 "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
 891                 if (!need_dwarf) {
 892                         pr_debug("Trying to use symbols.\n");
 893                         return 0;
 894                 }
 895         }
 896         return ntevs;
 897 }
 898
 899 #define LINEBUF_SIZE 256
 900 #define NR_ADDITIONAL_LINES 2
 901
 902 static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
 903 {
 904         char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
 905         const char *color = show_num ? "" : PERF_COLOR_BLUE;
 906         const char *prefix = NULL;
 907
 908         do {
 909                 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
 910                         goto error;
 911                 if (skip)
 912                         continue;
 913                 if (!prefix) {
 914                         prefix = show_num ? "%7d  " : "         ";
 915                         color_fprintf(stdout, color, prefix, l);
 916                 }
 917                 color_fprintf(stdout, color, "%s", buf);
 918
 919         } while (strchr(buf, '\n') == NULL);
 920
 921         return 1;
 922 error:
 923         if (ferror(fp)) {
 924                 pr_warning("File read error: %s\n",
 925                            str_error_r(errno, sbuf, sizeof(sbuf)));
 926                 return -1;
 927         }
 928         return 0;
 929 }
 930
 931 static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
 932 {
 933         int rv = __show_one_line(fp, l, skip, show_num);
 934         if (rv == 0) {
 935                 pr_warning("Source file is shorter than expected.\n");
 936                 rv = -1;
 937         }
 938         return rv;
 939 }
 940
 941 #define show_one_line_with_num(f,l)     _show_one_line(f,l,false,true)
 942 #define show_one_line(f,l)              _show_one_line(f,l,false,false)
 943 #define skip_one_line(f,l)              _show_one_line(f,l,true,false)
 944 #define show_one_line_or_eof(f,l)       __show_one_line(f,l,false,false)
 945
 946 /*
 947  * Show line-range always requires debuginfo to find source file and
 948  * line number.
 949  */
 950 static int __show_line_range(struct line_range *lr, const char *module,
 951                              bool user)
 952 {
 953         int l = 1;
 954         struct int_node *ln;
 955         struct debuginfo *dinfo;
 956         FILE *fp;
 957         int ret;
 958         char *tmp;
 959         char sbuf[STRERR_BUFSIZE];
 960
 961         /* Search a line range */
 962         dinfo = open_debuginfo(module, NULL, false);
 963         if (!dinfo)
 964                 return -ENOENT;
 965
 966         ret = debuginfo__find_line_range(dinfo, lr);
 967         if (!ret) {     /* Not found, retry with an alternative */
 968                 ret = get_alternative_line_range(dinfo, lr, module, user);
 969                 if (!ret)
 970                         ret = debuginfo__find_line_range(dinfo, lr);
 971         }
 972         debuginfo__delete(dinfo);
 973         if (ret == 0 || ret == -ENOENT) {
 974                 pr_warning("Specified source line is not found.\n");
 975                 return -ENOENT;
 976         } else if (ret < 0) {
 977                 pr_warning("Debuginfo analysis failed.\n");
 978                 return ret;
 979         }
 980
 981         /* Convert source file path */
 982         tmp = lr->path;
 983         ret = get_real_path(tmp, lr->comp_dir, &lr->path);
 984
 985         /* Free old path when new path is assigned */
 986         if (tmp != lr->path)
 987                 free(tmp);
 988
 989         if (ret < 0) {
 990                 pr_warning("Failed to find source file path.\n");
 991                 return ret;
 992         }
 993
 994         setup_pager();
 995
 996         if (lr->function)
 997                 fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
 998                         lr->start - lr->offset);
 999         else
1000                 fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
1001
1002         fp = fopen(lr->path, "r");
1003         if (fp == NULL) {
1004                 pr_warning("Failed to open %s: %s\n", lr->path,
1005                            str_error_r(errno, sbuf, sizeof(sbuf)));
1006                 return -errno;
1007         }
1008         /* Skip to starting line number */
1009         while (l < lr->start) {
1010                 ret = skip_one_line(fp, l++);
1011                 if (ret < 0)
1012                         goto end;
1013         }
1014
1015         intlist__for_each_entry(ln, lr->line_list) {
1016                 for (; ln->i > l; l++) {
1017                         ret = show_one_line(fp, l - lr->offset);
1018                         if (ret < 0)
1019                                 goto end;
1020                 }
1021                 ret = show_one_line_with_num(fp, l++ - lr->offset);
1022                 if (ret < 0)
1023                         goto end;
1024         }
1025
1026         if (lr->end == INT_MAX)
1027                 lr->end = l + NR_ADDITIONAL_LINES;
1028         while (l <= lr->end) {
1029                 ret = show_one_line_or_eof(fp, l++ - lr->offset);
1030                 if (ret <= 0)
1031                         break;
1032         }
1033 end:
1034         fclose(fp);
1035         return ret;
1036 }
1037
1038 int show_line_range(struct line_range *lr, const char *module,
1039                     struct nsinfo *nsi, bool user)
1040 {
1041         int ret;
1042         struct nscookie nsc;
1043
1044         ret = init_probe_symbol_maps(user);
1045         if (ret < 0)
1046                 return ret;
1047         nsinfo__mountns_enter(nsi, &nsc);
1048         ret = __show_line_range(lr, module, user);
1049         nsinfo__mountns_exit(&nsc);
1050         exit_probe_symbol_maps();
1051
1052         return ret;
1053 }
1054
1055 static int show_available_vars_at(struct debuginfo *dinfo,
1056                                   struct perf_probe_event *pev,
1057                                   struct strfilter *_filter)
1058 {
1059         char *buf;
1060         int ret, i, nvars;
1061         struct str_node *node;
1062         struct variable_list *vls = NULL, *vl;
1063         struct perf_probe_point tmp;
1064         const char *var;
1065
1066         buf = synthesize_perf_probe_point(&pev->point);
1067         if (!buf)
1068                 return -EINVAL;
1069         pr_debug("Searching variables at %s\n", buf);
1070
1071         ret = debuginfo__find_available_vars_at(dinfo, pev, &vls);
1072         if (!ret) {  /* Not found, retry with an alternative */
1073                 ret = get_alternative_probe_event(dinfo, pev, &tmp);
1074                 if (!ret) {
1075                         ret = debuginfo__find_available_vars_at(dinfo, pev,
1076                                                                 &vls);
1077                         /* Release the old probe_point */
1078                         clear_perf_probe_point(&tmp);
1079                 }
1080         }
1081         if (ret <= 0) {
1082                 if (ret == 0 || ret == -ENOENT) {
1083                         pr_err("Failed to find the address of %s\n", buf);
1084                         ret = -ENOENT;
1085                 } else
1086                         pr_warning("Debuginfo analysis failed.\n");
1087                 goto end;
1088         }
1089
1090         /* Some variables are found */
1091         fprintf(stdout, "Available variables at %s\n", buf);
1092         for (i = 0; i < ret; i++) {
1093                 vl = &vls[i];
1094                 /*
1095                  * A probe point might be converted to
1096                  * several trace points.
1097                  */
1098                 fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
1099                         vl->point.offset);
1100                 zfree(&vl->point.symbol);
1101                 nvars = 0;
1102                 if (vl->vars) {
1103                         strlist__for_each_entry(node, vl->vars) {
1104                                 var = strchr(node->s, '\t') + 1;
1105                                 if (strfilter__compare(_filter, var)) {
1106                                         fprintf(stdout, "\t\t%s\n", node->s);
1107                                         nvars++;
1108                                 }
1109                         }
1110                         strlist__delete(vl->vars);
1111                 }
1112                 if (nvars == 0)
1113                         fprintf(stdout, "\t\t(No matched variables)\n");
1114         }
1115         free(vls);
1116 end:
1117         free(buf);
1118         return ret;
1119 }
1120
1121 /* Show available variables on given probe point */
1122 int show_available_vars(struct perf_probe_event *pevs, int npevs,
1123                         struct strfilter *_filter)
1124 {
1125         int i, ret = 0;
1126         struct debuginfo *dinfo;
1127
1128         ret = init_probe_symbol_maps(pevs->uprobes);
1129         if (ret < 0)
1130                 return ret;
1131
1132         dinfo = open_debuginfo(pevs->target, pevs->nsi, false);
1133         if (!dinfo) {
1134                 ret = -ENOENT;
1135                 goto out;
1136         }
1137
1138         setup_pager();
1139
1140         for (i = 0; i < npevs && ret >= 0; i++)
1141                 ret = show_available_vars_at(dinfo, &pevs[i], _filter);
1142
1143         debuginfo__delete(dinfo);
1144 out:
1145         exit_probe_symbol_maps();
1146         return ret;
1147 }
1148
1149 #else   /* !HAVE_DWARF_SUPPORT */
1150
1151 static void debuginfo_cache__exit(void)
1152 {
1153 }
1154
1155 static int
1156 find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
1157                                  struct perf_probe_point *pp __maybe_unused,
1158                                  bool is_kprobe __maybe_unused)
1159 {
1160         return -ENOSYS;
1161 }
1162
1163 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
1164                                 struct probe_trace_event **tevs __maybe_unused)
1165 {
1166         if (perf_probe_event_need_dwarf(pev)) {
1167                 pr_warning("Debuginfo-analysis is not supported.\n");
1168                 return -ENOSYS;
1169         }
1170
1171         return 0;
1172 }
1173
1174 int show_line_range(struct line_range *lr __maybe_unused,
1175                     const char *module __maybe_unused,
1176                     struct nsinfo *nsi __maybe_unused,
1177                     bool user __maybe_unused)
1178 {
1179         pr_warning("Debuginfo-analysis is not supported.\n");
1180         return -ENOSYS;
1181 }
1182
1183 int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
1184                         int npevs __maybe_unused,
1185                         struct strfilter *filter __maybe_unused)
1186 {
1187         pr_warning("Debuginfo-analysis is not supported.\n");
1188         return -ENOSYS;
1189 }
1190 #endif
1191
1192 void line_range__clear(struct line_range *lr)
1193 {
1194         zfree(&lr->function);
1195         zfree(&lr->file);
1196         zfree(&lr->path);
1197         zfree(&lr->comp_dir);
1198         intlist__delete(lr->line_list);
1199 }
1200
1201 int line_range__init(struct line_range *lr)
1202 {
1203         memset(lr, 0, sizeof(*lr));
1204         lr->line_list = intlist__new(NULL);
1205         if (!lr->line_list)
1206                 return -ENOMEM;
1207         else
1208                 return 0;
1209 }
1210
1211 static int parse_line_num(char **ptr, int *val, const char *what)
1212 {
1213         const char *start = *ptr;
1214
1215         errno = 0;
1216         *val = strtol(*ptr, ptr, 0);
1217         if (errno || *ptr == start) {
1218                 semantic_error("'%s' is not a valid number.\n", what);
1219                 return -EINVAL;
1220         }
1221         return 0;
1222 }
1223
1224 /* Check the name is good for event, group or function */
1225 static bool is_c_func_name(const char *name)
1226 {
1227         if (!isalpha(*name) && *name != '_')
1228                 return false;
1229         while (*++name != '\0') {
1230                 if (!isalpha(*name) && !isdigit(*name) && *name != '_')
1231                         return false;
1232         }
1233         return true;
1234 }
1235
1236 /*
1237  * Stuff 'lr' according to the line range described by 'arg'.
1238  * The line range syntax is described by:
1239  *
1240  *         SRC[:SLN[+NUM|-ELN]]
1241  *         FNC[@SRC][:SLN[+NUM|-ELN]]
1242  */
1243 int parse_line_range_desc(const char *arg, struct line_range *lr)
1244 {
1245         char *range, *file, *name = strdup(arg);
1246         int err;
1247
1248         if (!name)
1249                 return -ENOMEM;
1250
1251         lr->start = 0;
1252         lr->end = INT_MAX;
1253
1254         range = strchr(name, ':');
1255         if (range) {
1256                 *range++ = '\0';
1257
1258                 err = parse_line_num(&range, &lr->start, "start line");
1259                 if (err)
1260                         goto err;
1261
1262                 if (*range == '+' || *range == '-') {
1263                         const char c = *range++;
1264
1265                         err = parse_line_num(&range, &lr->end, "end line");
1266                         if (err)
1267                                 goto err;
1268
1269                         if (c == '+') {
1270                                 lr->end += lr->start;
1271                                 /*
1272                                  * Adjust the number of lines here.
1273                                  * If the number of lines == 1, the
1274                                  * the end of line should be equal to
1275                                  * the start of line.
1276                                  */
1277                                 lr->end--;
1278                         }
1279                 }
1280
1281                 pr_debug("Line range is %d to %d\n", lr->start, lr->end);
1282
1283                 err = -EINVAL;
1284                 if (lr->start > lr->end) {
1285                         semantic_error("Start line must be smaller"
1286                                        " than end line.\n");
1287                         goto err;
1288                 }
1289                 if (*range != '\0') {
1290                         semantic_error("Tailing with invalid str '%s'.\n", range);
1291                         goto err;
1292                 }
1293         }
1294
1295         file = strchr(name, '@');
1296         if (file) {
1297                 *file = '\0';
1298                 lr->file = strdup(++file);
1299                 if (lr->file == NULL) {
1300                         err = -ENOMEM;
1301                         goto err;
1302                 }
1303                 lr->function = name;
1304         } else if (strchr(name, '/') || strchr(name, '.'))
1305                 lr->file = name;
1306         else if (is_c_func_name(name))/* We reuse it for checking funcname */
1307                 lr->function = name;
1308         else {  /* Invalid name */
1309                 semantic_error("'%s' is not a valid function name.\n", name);
1310                 err = -EINVAL;
1311                 goto err;
1312         }
1313
1314         return 0;
1315 err:
1316         free(name);
1317         return err;
1318 }
1319
1320 static int parse_perf_probe_event_name(char **arg, struct perf_probe_event *pev)
1321 {
1322         char *ptr;
1323
1324         ptr = strpbrk_esc(*arg, ":");
1325         if (ptr) {
1326                 *ptr = '\0';
1327                 if (!pev->sdt && !is_c_func_name(*arg))
1328                         goto ng_name;
1329                 pev->group = strdup_esc(*arg);
1330                 if (!pev->group)
1331                         return -ENOMEM;
1332                 *arg = ptr + 1;
1333         } else
1334                 pev->group = NULL;
1335
1336         pev->event = strdup_esc(*arg);
1337         if (pev->event == NULL)
1338                 return -ENOMEM;
1339
1340         if (!pev->sdt && !is_c_func_name(pev->event)) {
1341                 zfree(&pev->event);
1342 ng_name:
1343                 zfree(&pev->group);
1344                 semantic_error("%s is bad for event name -it must "
1345                                "follow C symbol-naming rule.\n", *arg);
1346                 return -EINVAL;
1347         }
1348         return 0;
1349 }
1350
1351 /* Parse probepoint definition. */
1352 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
1353 {
1354         struct perf_probe_point *pp = &pev->point;
1355         char *ptr, *tmp;
1356         char c, nc = 0;
1357         bool file_spec = false;
1358         int ret;
1359
1360         /*
1361          * <Syntax>
1362          * perf probe [GRP:][EVENT=]SRC[:LN|;PTN]
1363          * perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
1364          * perf probe %[GRP:]SDT_EVENT
1365          */
1366         if (!arg)
1367                 return -EINVAL;
1368
1369         if (is_sdt_event(arg)) {
1370                 pev->sdt = true;
1371                 if (arg[0] == '%')
1372                         arg++;
1373         }
1374
1375         ptr = strpbrk_esc(arg, ";=@+%");
1376         if (pev->sdt) {
1377                 if (ptr) {
1378                         if (*ptr != '@') {
1379                                 semantic_error("%s must be an SDT name.\n",
1380                                                arg);
1381                                 return -EINVAL;
1382                         }
1383                         /* This must be a target file name or build id */
1384                         tmp = build_id_cache__complement(ptr + 1);
1385                         if (tmp) {
1386                                 pev->target = build_id_cache__origname(tmp);
1387                                 free(tmp);
1388                         } else
1389                                 pev->target = strdup_esc(ptr + 1);
1390                         if (!pev->target)
1391                                 return -ENOMEM;
1392                         *ptr = '\0';
1393                 }
1394                 ret = parse_perf_probe_event_name(&arg, pev);
1395                 if (ret == 0) {
1396                         if (asprintf(&pev->point.function, "%%%s", pev->event) < 0)
1397                                 ret = -errno;
1398                 }
1399                 return ret;
1400         }
1401
1402         if (ptr && *ptr == '=') {       /* Event name */
1403                 *ptr = '\0';
1404                 tmp = ptr + 1;
1405                 ret = parse_perf_probe_event_name(&arg, pev);
1406                 if (ret < 0)
1407                         return ret;
1408
1409                 arg = tmp;
1410         }
1411
1412         /*
1413          * Check arg is function or file name and copy it.
1414          *
1415          * We consider arg to be a file spec if and only if it satisfies
1416          * all of the below criteria::
1417          * - it does not include any of "+@%",
1418          * - it includes one of ":;", and
1419          * - it has a period '.' in the name.
1420          *
1421          * Otherwise, we consider arg to be a function specification.
1422          */
1423         if (!strpbrk_esc(arg, "+@%")) {
1424                 ptr = strpbrk_esc(arg, ";:");
1425                 /* This is a file spec if it includes a '.' before ; or : */
1426                 if (ptr && memchr(arg, '.', ptr - arg))
1427                         file_spec = true;
1428         }
1429
1430         ptr = strpbrk_esc(arg, ";:+@%");
1431         if (ptr) {
1432                 nc = *ptr;
1433                 *ptr++ = '\0';
1434         }
1435
1436         if (arg[0] == '\0')
1437                 tmp = NULL;
1438         else {
1439                 tmp = strdup_esc(arg);
1440                 if (tmp == NULL)
1441                         return -ENOMEM;
1442         }
1443
1444         if (file_spec)
1445                 pp->file = tmp;
1446         else {
1447                 pp->function = tmp;
1448
1449                 /*
1450                  * Keep pp->function even if this is absolute address,
1451                  * so it can mark whether abs_address is valid.
1452                  * Which make 'perf probe lib.bin 0x0' possible.
1453                  *
1454                  * Note that checking length of tmp is not needed
1455                  * because when we access tmp[1] we know tmp[0] is '0',
1456                  * so tmp[1] should always valid (but could be '\0').
1457                  */
1458                 if (tmp && !strncmp(tmp, "0x", 2)) {
1459                         pp->abs_address = strtoul(pp->function, &tmp, 0);
1460                         if (*tmp != '\0') {
1461                                 semantic_error("Invalid absolute address.\n");
1462                                 return -EINVAL;
1463                         }
1464                 }
1465         }
1466
1467         /* Parse other options */
1468         while (ptr) {
1469                 arg = ptr;
1470                 c = nc;
1471                 if (c == ';') { /* Lazy pattern must be the last part */
1472                         pp->lazy_line = strdup(arg); /* let leave escapes */
1473                         if (pp->lazy_line == NULL)
1474                                 return -ENOMEM;
1475                         break;
1476                 }
1477                 ptr = strpbrk_esc(arg, ";:+@%");
1478                 if (ptr) {
1479                         nc = *ptr;
1480                         *ptr++ = '\0';
1481                 }
1482                 switch (c) {
1483                 case ':':       /* Line number */
1484                         pp->line = strtoul(arg, &tmp, 0);
1485                         if (*tmp != '\0') {
1486                                 semantic_error("There is non-digit char"
1487                                                " in line number.\n");
1488                                 return -EINVAL;
1489                         }
1490                         break;
1491                 case '+':       /* Byte offset from a symbol */
1492                         pp->offset = strtoul(arg, &tmp, 0);
1493                         if (*tmp != '\0') {
1494                                 semantic_error("There is non-digit character"
1495                                                 " in offset.\n");
1496                                 return -EINVAL;
1497                         }
1498                         break;
1499                 case '@':       /* File name */
1500                         if (pp->file) {
1501                                 semantic_error("SRC@SRC is not allowed.\n");
1502                                 return -EINVAL;
1503                         }
1504                         pp->file = strdup_esc(arg);
1505                         if (pp->file == NULL)
1506                                 return -ENOMEM;
1507                         break;
1508                 case '%':       /* Probe places */
1509                         if (strcmp(arg, "return") == 0) {
1510                                 pp->retprobe = 1;
1511                         } else {        /* Others not supported yet */
1512                                 semantic_error("%%%s is not supported.\n", arg);
1513                                 return -ENOTSUP;
1514                         }
1515                         break;
1516                 default:        /* Buggy case */
1517                         pr_err("This program has a bug at %s:%d.\n",
1518                                 __FILE__, __LINE__);
1519                         return -ENOTSUP;
1520                         break;
1521                 }
1522         }
1523
1524         /* Exclusion check */
1525         if (pp->lazy_line && pp->line) {
1526                 semantic_error("Lazy pattern can't be used with"
1527                                " line number.\n");
1528                 return -EINVAL;
1529         }
1530
1531         if (pp->lazy_line && pp->offset) {
1532                 semantic_error("Lazy pattern can't be used with offset.\n");
1533                 return -EINVAL;
1534         }
1535
1536         if (pp->line && pp->offset) {
1537                 semantic_error("Offset can't be used with line number.\n");
1538                 return -EINVAL;
1539         }
1540
1541         if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1542                 semantic_error("File always requires line number or "
1543                                "lazy pattern.\n");
1544                 return -EINVAL;
1545         }
1546
1547         if (pp->offset && !pp->function) {
1548                 semantic_error("Offset requires an entry function.\n");
1549                 return -EINVAL;
1550         }
1551
1552         if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1553                 semantic_error("Offset/Line/Lazy pattern can't be used with "
1554                                "return probe.\n");
1555                 return -EINVAL;
1556         }
1557
1558         pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1559                  pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
1560                  pp->lazy_line);
1561         return 0;
1562 }
1563
1564 /* Parse perf-probe event argument */
1565 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1566 {
1567         char *tmp, *goodname;
1568         struct perf_probe_arg_field **fieldp;
1569
1570         pr_debug("parsing arg: %s into ", str);
1571
1572         tmp = strchr(str, '=');
1573         if (tmp) {
1574                 arg->name = strndup(str, tmp - str);
1575                 if (arg->name == NULL)
1576                         return -ENOMEM;
1577                 pr_debug("name:%s ", arg->name);
1578                 str = tmp + 1;
1579         }
1580
1581         tmp = strchr(str, '@');
1582         if (tmp && tmp != str && !strcmp(tmp + 1, "user")) { /* user attr */
1583                 if (!user_access_is_supported()) {
1584                         semantic_error("ftrace does not support user access\n");
1585                         return -EINVAL;
1586                 }
1587                 *tmp = '\0';
1588                 arg->user_access = true;
1589                 pr_debug("user_access ");
1590         }
1591
1592         tmp = strchr(str, ':');
1593         if (tmp) {      /* Type setting */
1594                 *tmp = '\0';
1595                 arg->type = strdup(tmp + 1);
1596                 if (arg->type == NULL)
1597                         return -ENOMEM;
1598                 pr_debug("type:%s ", arg->type);
1599         }
1600
1601         tmp = strpbrk(str, "-.[");
1602         if (!is_c_varname(str) || !tmp) {
1603                 /* A variable, register, symbol or special value */
1604                 arg->var = strdup(str);
1605                 if (arg->var == NULL)
1606                         return -ENOMEM;
1607                 pr_debug("%s\n", arg->var);
1608                 return 0;
1609         }
1610
1611         /* Structure fields or array element */
1612         arg->var = strndup(str, tmp - str);
1613         if (arg->var == NULL)
1614                 return -ENOMEM;
1615         goodname = arg->var;
1616         pr_debug("%s, ", arg->var);
1617         fieldp = &arg->field;
1618
1619         do {
1620                 *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
1621                 if (*fieldp == NULL)
1622                         return -ENOMEM;
1623                 if (*tmp == '[') {      /* Array */
1624                         str = tmp;
1625                         (*fieldp)->index = strtol(str + 1, &tmp, 0);
1626                         (*fieldp)->ref = true;
1627                         if (*tmp != ']' || tmp == str + 1) {
1628                                 semantic_error("Array index must be a"
1629                                                 " number.\n");
1630                                 return -EINVAL;
1631                         }
1632                         tmp++;
1633                         if (*tmp == '\0')
1634                                 tmp = NULL;
1635                 } else {                /* Structure */
1636                         if (*tmp == '.') {
1637                                 str = tmp + 1;
1638                                 (*fieldp)->ref = false;
1639                         } else if (tmp[1] == '>') {
1640                                 str = tmp + 2;
1641                                 (*fieldp)->ref = true;
1642                         } else {
1643                                 semantic_error("Argument parse error: %s\n",
1644                                                str);
1645                                 return -EINVAL;
1646                         }
1647                         tmp = strpbrk(str, "-.[");
1648                 }
1649                 if (tmp) {
1650                         (*fieldp)->name = strndup(str, tmp - str);
1651                         if ((*fieldp)->name == NULL)
1652                                 return -ENOMEM;
1653                         if (*str != '[')
1654                                 goodname = (*fieldp)->name;
1655                         pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
1656                         fieldp = &(*fieldp)->next;
1657                 }
1658         } while (tmp);
1659         (*fieldp)->name = strdup(str);
1660         if ((*fieldp)->name == NULL)
1661                 return -ENOMEM;
1662         if (*str != '[')
1663                 goodname = (*fieldp)->name;
1664         pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1665
1666         /* If no name is specified, set the last field name (not array index)*/
1667         if (!arg->name) {
1668                 arg->name = strdup(goodname);
1669                 if (arg->name == NULL)
1670                         return -ENOMEM;
1671         }
1672         return 0;
1673 }
1674
1675 /* Parse perf-probe event command */
1676 int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1677 {
1678         char **argv;
1679         int argc, i, ret = 0;
1680
1681         argv = argv_split(cmd, &argc);
1682         if (!argv) {
1683                 pr_debug("Failed to split arguments.\n");
1684                 return -ENOMEM;
1685         }
1686         if (argc - 1 > MAX_PROBE_ARGS) {
1687                 semantic_error("Too many probe arguments (%d).\n", argc - 1);
1688                 ret = -ERANGE;
1689                 goto out;
1690         }
1691         /* Parse probe point */
1692         ret = parse_perf_probe_point(argv[0], pev);
1693         if (ret < 0)
1694                 goto out;
1695
1696         /* Generate event name if needed */
1697         if (!pev->event && pev->point.function && pev->point.line
1698                         && !pev->point.lazy_line && !pev->point.offset) {
1699                 if (asprintf(&pev->event, "%s_L%d", pev->point.function,
1700                         pev->point.line) < 0)
1701                         return -ENOMEM;
1702         }
1703
1704         /* Copy arguments and ensure return probe has no C argument */
1705         pev->nargs = argc - 1;
1706         pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1707         if (pev->args == NULL) {
1708                 ret = -ENOMEM;
1709                 goto out;
1710         }
1711         for (i = 0; i < pev->nargs && ret >= 0; i++) {
1712                 ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1713                 if (ret >= 0 &&
1714                     is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1715                         semantic_error("You can't specify local variable for"
1716                                        " kretprobe.\n");
1717                         ret = -EINVAL;
1718                 }
1719         }
1720 out:
1721         argv_free(argv);
1722
1723         return ret;
1724 }
1725
1726 /* Returns true if *any* ARG is either C variable, $params or $vars. */
1727 bool perf_probe_with_var(struct perf_probe_event *pev)
1728 {
1729         int i = 0;
1730
1731         for (i = 0; i < pev->nargs; i++)
1732                 if (is_c_varname(pev->args[i].var)              ||
1733                     !strcmp(pev->args[i].var, PROBE_ARG_PARAMS) ||
1734                     !strcmp(pev->args[i].var, PROBE_ARG_VARS))
1735                         return true;
1736         return false;
1737 }
1738
1739 /* Return true if this perf_probe_event requires debuginfo */
1740 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
1741 {
1742         if (pev->point.file || pev->point.line || pev->point.lazy_line)
1743                 return true;
1744
1745         if (perf_probe_with_var(pev))
1746                 return true;
1747
1748         return false;
1749 }
1750
1751 /* Parse probe_events event into struct probe_point */
1752 int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
1753 {
1754         struct probe_trace_point *tp = &tev->point;
1755         char pr;
1756         char *p;
1757         char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1758         int ret, i, argc;
1759         char **argv;
1760
1761         pr_debug("Parsing probe_events: %s\n", cmd);
1762         argv = argv_split(cmd, &argc);
1763         if (!argv) {
1764                 pr_debug("Failed to split arguments.\n");
1765                 return -ENOMEM;
1766         }
1767         if (argc < 2) {
1768                 semantic_error("Too few probe arguments.\n");
1769                 ret = -ERANGE;
1770                 goto out;
1771         }
1772
1773         /* Scan event and group name. */
1774         argv0_str = strdup(argv[0]);
1775         if (argv0_str == NULL) {
1776                 ret = -ENOMEM;
1777                 goto out;
1778         }
1779         fmt1_str = strtok_r(argv0_str, ":", &fmt);
1780         fmt2_str = strtok_r(NULL, "/", &fmt);
1781         fmt3_str = strtok_r(NULL, " \t", &fmt);
1782         if (fmt1_str == NULL || fmt2_str == NULL || fmt3_str == NULL) {
1783                 semantic_error("Failed to parse event name: %s\n", argv[0]);
1784                 ret = -EINVAL;
1785                 goto out;
1786         }
1787         pr = fmt1_str[0];
1788         tev->group = strdup(fmt2_str);
1789         tev->event = strdup(fmt3_str);
1790         if (tev->group == NULL || tev->event == NULL) {
1791                 ret = -ENOMEM;
1792                 goto out;
1793         }
1794         pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1795
1796         tp->retprobe = (pr == 'r');
1797
1798         /* Scan module name(if there), function name and offset */
1799         p = strchr(argv[1], ':');
1800         if (p) {
1801                 tp->module = strndup(argv[1], p - argv[1]);
1802                 if (!tp->module) {
1803                         ret = -ENOMEM;
1804                         goto out;
1805                 }
1806                 tev->uprobes = (tp->module[0] == '/');
1807                 p++;
1808         } else
1809                 p = argv[1];
1810         fmt1_str = strtok_r(p, "+", &fmt);
1811         /* only the address started with 0x */
1812         if (fmt1_str[0] == '0') {
1813                 /*
1814                  * Fix a special case:
1815                  * if address == 0, kernel reports something like:
1816                  * p:probe_libc/abs_0 /lib/libc-2.18.so:0x          (null) arg1=%ax
1817                  * Newer kernel may fix that, but we want to
1818                  * support old kernel also.
1819                  */
1820                 if (strcmp(fmt1_str, "0x") == 0) {
1821                         if (!argv[2] || strcmp(argv[2], "(null)")) {
1822                                 ret = -EINVAL;
1823                                 goto out;
1824                         }
1825                         tp->address = 0;
1826
1827                         free(argv[2]);
1828                         for (i = 2; argv[i + 1] != NULL; i++)
1829                                 argv[i] = argv[i + 1];
1830
1831                         argv[i] = NULL;
1832                         argc -= 1;
1833                 } else
1834                         tp->address = strtoul(fmt1_str, NULL, 0);
1835         } else {
1836                 /* Only the symbol-based probe has offset */
1837                 tp->symbol = strdup(fmt1_str);
1838                 if (tp->symbol == NULL) {
1839                         ret = -ENOMEM;
1840                         goto out;
1841                 }
1842                 fmt2_str = strtok_r(NULL, "", &fmt);
1843                 if (fmt2_str == NULL)
1844                         tp->offset = 0;
1845                 else
1846                         tp->offset = strtoul(fmt2_str, NULL, 10);
1847         }
1848
1849         if (tev->uprobes) {
1850                 fmt2_str = strchr(p, '(');
1851                 if (fmt2_str)
1852                         tp->ref_ctr_offset = strtoul(fmt2_str + 1, NULL, 0);
1853         }
1854
1855         tev->nargs = argc - 2;
1856         tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1857         if (tev->args == NULL) {
1858                 ret = -ENOMEM;
1859                 goto out;
1860         }
1861         for (i = 0; i < tev->nargs; i++) {
1862                 p = strchr(argv[i + 2], '=');
1863                 if (p)  /* We don't need which register is assigned. */
1864                         *p++ = '\0';
1865                 else
1866                         p = argv[i + 2];
1867                 tev->args[i].name = strdup(argv[i + 2]);
1868                 /* TODO: parse regs and offset */
1869                 tev->args[i].value = strdup(p);
1870                 if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
1871                         ret = -ENOMEM;
1872                         goto out;
1873                 }
1874         }
1875         ret = 0;
1876 out:
1877         free(argv0_str);
1878         argv_free(argv);
1879         return ret;
1880 }
1881
1882 /* Compose only probe arg */
1883 char *synthesize_perf_probe_arg(struct perf_probe_arg *pa)
1884 {
1885         struct perf_probe_arg_field *field = pa->field;
1886         struct strbuf buf;
1887         char *ret = NULL;
1888         int err;
1889
1890         if (strbuf_init(&buf, 64) < 0)
1891                 return NULL;
1892
1893         if (pa->name && pa->var)
1894                 err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var);
1895         else
1896                 err = strbuf_addstr(&buf, pa->name ?: pa->var);
1897         if (err)
1898                 goto out;
1899
1900         while (field) {
1901                 if (field->name[0] == '[')
1902                         err = strbuf_addstr(&buf, field->name);
1903                 else
1904                         err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".",
1905                                           field->name);
1906                 field = field->next;
1907                 if (err)
1908                         goto out;
1909         }
1910
1911         if (pa->type)
1912                 if (strbuf_addf(&buf, ":%s", pa->type) < 0)
1913                         goto out;
1914
1915         ret = strbuf_detach(&buf, NULL);
1916 out:
1917         strbuf_release(&buf);
1918         return ret;
1919 }
1920
1921 /* Compose only probe point (not argument) */
1922 char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1923 {
1924         struct strbuf buf;
1925         char *tmp, *ret = NULL;
1926         int len, err = 0;
1927
1928         if (strbuf_init(&buf, 64) < 0)
1929                 return NULL;
1930
1931         if (pp->function) {
1932                 if (strbuf_addstr(&buf, pp->function) < 0)
1933                         goto out;
1934                 if (pp->offset)
1935                         err = strbuf_addf(&buf, "+%lu", pp->offset);
1936                 else if (pp->line)
1937                         err = strbuf_addf(&buf, ":%d", pp->line);
1938                 else if (pp->retprobe)
1939                         err = strbuf_addstr(&buf, "%return");
1940                 if (err)
1941                         goto out;
1942         }
1943         if (pp->file) {
1944                 tmp = pp->file;
1945                 len = strlen(tmp);
1946                 if (len > 30) {
1947                         tmp = strchr(pp->file + len - 30, '/');
1948                         tmp = tmp ? tmp + 1 : pp->file + len - 30;
1949                 }
1950                 err = strbuf_addf(&buf, "@%s", tmp);
1951                 if (!err && !pp->function && pp->line)
1952                         err = strbuf_addf(&buf, ":%d", pp->line);
1953         }
1954         if (!err)
1955                 ret = strbuf_detach(&buf, NULL);
1956 out:
1957         strbuf_release(&buf);
1958         return ret;
1959 }
1960
1961 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1962 {
1963         struct strbuf buf;
1964         char *tmp, *ret = NULL;
1965         int i;
1966
1967         if (strbuf_init(&buf, 64))
1968                 return NULL;
1969         if (pev->event)
1970                 if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP,
1971                                 pev->event) < 0)
1972                         goto out;
1973
1974         tmp = synthesize_perf_probe_point(&pev->point);
1975         if (!tmp || strbuf_addstr(&buf, tmp) < 0)
1976                 goto out;
1977         free(tmp);
1978
1979         for (i = 0; i < pev->nargs; i++) {
1980                 tmp = synthesize_perf_probe_arg(pev->args + i);
1981                 if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0)
1982                         goto out;
1983                 free(tmp);
1984         }
1985
1986         ret = strbuf_detach(&buf, NULL);
1987 out:
1988         strbuf_release(&buf);
1989         return ret;
1990 }
1991
1992 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1993                                             struct strbuf *buf, int depth)
1994 {
1995         int err;
1996         if (ref->next) {
1997                 depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1998                                                          depth + 1);
1999                 if (depth < 0)
2000                         return depth;
2001         }
2002         if (ref->user_access)
2003                 err = strbuf_addf(buf, "%s%ld(", "+u", ref->offset);
2004         else
2005                 err = strbuf_addf(buf, "%+ld(", ref->offset);
2006         return (err < 0) ? err : depth;
2007 }
2008
2009 static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
2010                                       struct strbuf *buf)
2011 {
2012         struct probe_trace_arg_ref *ref = arg->ref;
2013         int depth = 0, err;
2014
2015         /* Argument name or separator */
2016         if (arg->name)
2017                 err = strbuf_addf(buf, " %s=", arg->name);
2018         else
2019                 err = strbuf_addch(buf, ' ');
2020         if (err)
2021                 return err;
2022
2023         /* Special case: @XXX */
2024         if (arg->value[0] == '@' && arg->ref)
2025                         ref = ref->next;
2026
2027         /* Dereferencing arguments */
2028         if (ref) {
2029                 depth = __synthesize_probe_trace_arg_ref(ref, buf, 1);
2030                 if (depth < 0)
2031                         return depth;
2032         }
2033
2034         /* Print argument value */
2035         if (arg->value[0] == '@' && arg->ref)
2036                 err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset);
2037         else
2038                 err = strbuf_addstr(buf, arg->value);
2039
2040         /* Closing */
2041         while (!err && depth--)
2042                 err = strbuf_addch(buf, ')');
2043
2044         /* Print argument type */
2045         if (!err && arg->type)
2046                 err = strbuf_addf(buf, ":%s", arg->type);
2047
2048         return err;
2049 }
2050
2051 static int
2052 synthesize_uprobe_trace_def(struct probe_trace_event *tev, struct strbuf *buf)
2053 {
2054         struct probe_trace_point *tp = &tev->point;
2055         int err;
2056
2057         err = strbuf_addf(buf, "%s:0x%lx", tp->module, tp->address);
2058
2059         if (err >= 0 && tp->ref_ctr_offset) {
2060                 if (!uprobe_ref_ctr_is_supported())
2061                         return -1;
2062                 err = strbuf_addf(buf, "(0x%lx)", tp->ref_ctr_offset);
2063         }
2064         return err >= 0 ? 0 : -1;
2065 }
2066
2067 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
2068 {
2069         struct probe_trace_point *tp = &tev->point;
2070         struct strbuf buf;
2071         char *ret = NULL;
2072         int i, err;
2073
2074         /* Uprobes must have tp->module */
2075         if (tev->uprobes && !tp->module)
2076                 return NULL;
2077
2078         if (strbuf_init(&buf, 32) < 0)
2079                 return NULL;
2080
2081         if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
2082                         tev->group, tev->event) < 0)
2083                 goto error;
2084         /*
2085          * If tp->address == 0, then this point must be a
2086          * absolute address uprobe.
2087          * try_to_find_absolute_address() should have made
2088          * tp->symbol to "0x0".
2089          */
2090         if (tev->uprobes && !tp->address) {
2091                 if (!tp->symbol || strcmp(tp->symbol, "0x0"))
2092                         goto error;
2093         }
2094
2095         /* Use the tp->address for uprobes */
2096         if (tev->uprobes) {
2097                 err = synthesize_uprobe_trace_def(tev, &buf);
2098         } else if (!strncmp(tp->symbol, "0x", 2)) {
2099                 /* Absolute address. See try_to_find_absolute_address() */
2100                 err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "",
2101                                   tp->module ? ":" : "", tp->address);
2102         } else {
2103                 err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "",
2104                                 tp->module ? ":" : "", tp->symbol, tp->offset);
2105         }
2106
2107         if (err)
2108                 goto error;
2109
2110         for (i = 0; i < tev->nargs; i++)
2111                 if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0)
2112                         goto error;
2113
2114         ret = strbuf_detach(&buf, NULL);
2115 error:
2116         strbuf_release(&buf);
2117         return ret;
2118 }
2119
2120 static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
2121                                           struct perf_probe_point *pp,
2122                                           bool is_kprobe)
2123 {
2124         struct symbol *sym = NULL;
2125         struct map *map = NULL;
2126         u64 addr = tp->address;
2127         int ret = -ENOENT;
2128
2129         if (!is_kprobe) {
2130                 map = dso__new_map(tp->module);
2131                 if (!map)
2132                         goto out;
2133                 sym = map__find_symbol(map, addr);
2134         } else {
2135                 if (tp->symbol && !addr) {
2136                         if (kernel_get_symbol_address_by_name(tp->symbol,
2137                                                 &addr, true, false) < 0)
2138                                 goto out;
2139                 }
2140                 if (addr) {
2141                         addr += tp->offset;
2142                         sym = machine__find_kernel_symbol(host_machine, addr, &map);
2143                 }
2144         }
2145
2146         if (!sym)
2147                 goto out;
2148
2149         pp->retprobe = tp->retprobe;
2150         pp->offset = addr - map->unmap_ip(map, sym->start);
2151         pp->function = strdup(sym->name);
2152         ret = pp->function ? 0 : -ENOMEM;
2153
2154 out:
2155         if (map && !is_kprobe) {
2156                 map__put(map);
2157         }
2158
2159         return ret;
2160 }
2161
2162 static int convert_to_perf_probe_point(struct probe_trace_point *tp,
2163                                        struct perf_probe_point *pp,
2164                                        bool is_kprobe)
2165 {
2166         char buf[128];
2167         int ret;
2168
2169         ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
2170         if (!ret)
2171                 return 0;
2172         ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
2173         if (!ret)
2174                 return 0;
2175
2176         pr_debug("Failed to find probe point from both of dwarf and map.\n");
2177
2178         if (tp->symbol) {
2179                 pp->function = strdup(tp->symbol);
2180                 pp->offset = tp->offset;
2181         } else {
2182                 ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
2183                 if (ret < 0)
2184                         return ret;
2185                 pp->function = strdup(buf);
2186                 pp->offset = 0;
2187         }
2188         if (pp->function == NULL)
2189                 return -ENOMEM;
2190
2191         pp->retprobe = tp->retprobe;
2192
2193         return 0;
2194 }
2195
2196 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
2197                                struct perf_probe_event *pev, bool is_kprobe)
2198 {
2199         struct strbuf buf = STRBUF_INIT;
2200         int i, ret;
2201
2202         /* Convert event/group name */
2203         pev->event = strdup(tev->event);
2204         pev->group = strdup(tev->group);
2205         if (pev->event == NULL || pev->group == NULL)
2206                 return -ENOMEM;
2207
2208         /* Convert trace_point to probe_point */
2209         ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
2210         if (ret < 0)
2211                 return ret;
2212
2213         /* Convert trace_arg to probe_arg */
2214         pev->nargs = tev->nargs;
2215         pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
2216         if (pev->args == NULL)
2217                 return -ENOMEM;
2218         for (i = 0; i < tev->nargs && ret >= 0; i++) {
2219                 if (tev->args[i].name)
2220                         pev->args[i].name = strdup(tev->args[i].name);
2221                 else {
2222                         if ((ret = strbuf_init(&buf, 32)) < 0)
2223                                 goto error;
2224                         ret = synthesize_probe_trace_arg(&tev->args[i], &buf);
2225                         pev->args[i].name = strbuf_detach(&buf, NULL);
2226                 }
2227                 if (pev->args[i].name == NULL && ret >= 0)
2228                         ret = -ENOMEM;
2229         }
2230 error:
2231         if (ret < 0)
2232                 clear_perf_probe_event(pev);
2233
2234         return ret;
2235 }
2236
2237 void clear_perf_probe_event(struct perf_probe_event *pev)
2238 {
2239         struct perf_probe_arg_field *field, *next;
2240         int i;
2241
2242         zfree(&pev->event);
2243         zfree(&pev->group);
2244         zfree(&pev->target);
2245         clear_perf_probe_point(&pev->point);
2246
2247         for (i = 0; i < pev->nargs; i++) {
2248                 zfree(&pev->args[i].name);
2249                 zfree(&pev->args[i].var);
2250                 zfree(&pev->args[i].type);
2251                 field = pev->args[i].field;
2252                 while (field) {
2253                         next = field->next;
2254                         zfree(&field->name);
2255                         free(field);
2256                         field = next;
2257                 }
2258         }
2259         pev->nargs = 0;
2260         zfree(&pev->args);
2261 }
2262
2263 #define strdup_or_goto(str, label)      \
2264 ({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; })
2265
2266 static int perf_probe_point__copy(struct perf_probe_point *dst,
2267                                   struct perf_probe_point *src)
2268 {
2269         dst->file = strdup_or_goto(src->file, out_err);
2270         dst->function = strdup_or_goto(src->function, out_err);
2271         dst->lazy_line = strdup_or_goto(src->lazy_line, out_err);
2272         dst->line = src->line;
2273         dst->retprobe = src->retprobe;
2274         dst->offset = src->offset;
2275         return 0;
2276
2277 out_err:
2278         clear_perf_probe_point(dst);
2279         return -ENOMEM;
2280 }
2281
2282 static int perf_probe_arg__copy(struct perf_probe_arg *dst,
2283                                 struct perf_probe_arg *src)
2284 {
2285         struct perf_probe_arg_field *field, **ppfield;
2286
2287         dst->name = strdup_or_goto(src->name, out_err);
2288         dst->var = strdup_or_goto(src->var, out_err);
2289         dst->type = strdup_or_goto(src->type, out_err);
2290
2291         field = src->field;
2292         ppfield = &(dst->field);
2293         while (field) {
2294                 *ppfield = zalloc(sizeof(*field));
2295                 if (!*ppfield)
2296                         goto out_err;
2297                 (*ppfield)->name = strdup_or_goto(field->name, out_err);
2298                 (*ppfield)->index = field->index;
2299                 (*ppfield)->ref = field->ref;
2300                 field = field->next;
2301                 ppfield = &((*ppfield)->next);
2302         }
2303         return 0;
2304 out_err:
2305         return -ENOMEM;
2306 }
2307
2308 int perf_probe_event__copy(struct perf_probe_event *dst,
2309                            struct perf_probe_event *src)
2310 {
2311         int i;
2312
2313         dst->event = strdup_or_goto(src->event, out_err);
2314         dst->group = strdup_or_goto(src->group, out_err);
2315         dst->target = strdup_or_goto(src->target, out_err);
2316         dst->uprobes = src->uprobes;
2317
2318         if (perf_probe_point__copy(&dst->point, &src->point) < 0)
2319                 goto out_err;
2320
2321         dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs);
2322         if (!dst->args)
2323                 goto out_err;
2324         dst->nargs = src->nargs;
2325
2326         for (i = 0; i < src->nargs; i++)
2327                 if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0)
2328                         goto out_err;
2329         return 0;
2330
2331 out_err:
2332         clear_perf_probe_event(dst);
2333         return -ENOMEM;
2334 }
2335
2336 void clear_probe_trace_event(struct probe_trace_event *tev)
2337 {
2338         struct probe_trace_arg_ref *ref, *next;
2339         int i;
2340
2341         zfree(&tev->event);
2342         zfree(&tev->group);
2343         zfree(&tev->point.symbol);
2344         zfree(&tev->point.realname);
2345         zfree(&tev->point.module);
2346         for (i = 0; i < tev->nargs; i++) {
2347                 zfree(&tev->args[i].name);
2348                 zfree(&tev->args[i].value);
2349                 zfree(&tev->args[i].type);
2350                 ref = tev->args[i].ref;
2351                 while (ref) {
2352                         next = ref->next;
2353                         free(ref);
2354                         ref = next;
2355                 }
2356         }
2357         zfree(&tev->args);
2358         tev->nargs = 0;
2359 }
2360
2361 struct kprobe_blacklist_node {
2362         struct list_head list;
2363         unsigned long start;
2364         unsigned long end;
2365         char *symbol;
2366 };
2367
2368 static void kprobe_blacklist__delete(struct list_head *blacklist)
2369 {
2370         struct kprobe_blacklist_node *node;
2371
2372         while (!list_empty(blacklist)) {
2373                 node = list_first_entry(blacklist,
2374                                         struct kprobe_blacklist_node, list);
2375                 list_del_init(&node->list);
2376                 zfree(&node->symbol);
2377                 free(node);
2378         }
2379 }
2380
2381 static int kprobe_blacklist__load(struct list_head *blacklist)
2382 {
2383         struct kprobe_blacklist_node *node;
2384         const char *__debugfs = debugfs__mountpoint();
2385         char buf[PATH_MAX], *p;
2386         FILE *fp;
2387         int ret;
2388
2389         if (__debugfs == NULL)
2390                 return -ENOTSUP;
2391
2392         ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
2393         if (ret < 0)
2394                 return ret;
2395
2396         fp = fopen(buf, "r");
2397         if (!fp)
2398                 return -errno;
2399
2400         ret = 0;
2401         while (fgets(buf, PATH_MAX, fp)) {
2402                 node = zalloc(sizeof(*node));
2403                 if (!node) {
2404                         ret = -ENOMEM;
2405                         break;
2406                 }
2407                 INIT_LIST_HEAD(&node->list);
2408                 list_add_tail(&node->list, blacklist);
2409                 if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
2410                         ret = -EINVAL;
2411                         break;
2412                 }
2413                 p = strchr(buf, '\t');
2414                 if (p) {
2415                         p++;
2416                         if (p[strlen(p) - 1] == '\n')
2417                                 p[strlen(p) - 1] = '\0';
2418                 } else
2419                         p = (char *)"unknown";
2420                 node->symbol = strdup(p);
2421                 if (!node->symbol) {
2422                         ret = -ENOMEM;
2423                         break;
2424                 }
2425                 pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
2426                           node->start, node->end, node->symbol);
2427                 ret++;
2428         }
2429         if (ret < 0)
2430                 kprobe_blacklist__delete(blacklist);
2431         fclose(fp);
2432
2433         return ret;
2434 }
2435
2436 static struct kprobe_blacklist_node *
2437 kprobe_blacklist__find_by_address(struct list_head *blacklist,
2438                                   unsigned long address)
2439 {
2440         struct kprobe_blacklist_node *node;
2441
2442         list_for_each_entry(node, blacklist, list) {
2443                 if (node->start <= address && address < node->end)
2444                         return node;
2445         }
2446
2447         return NULL;
2448 }
2449
2450 static LIST_HEAD(kprobe_blacklist);
2451
2452 static void kprobe_blacklist__init(void)
2453 {
2454         if (!list_empty(&kprobe_blacklist))
2455                 return;
2456
2457         if (kprobe_blacklist__load(&kprobe_blacklist) < 0)
2458                 pr_debug("No kprobe blacklist support, ignored\n");
2459 }
2460
2461 static void kprobe_blacklist__release(void)
2462 {
2463         kprobe_blacklist__delete(&kprobe_blacklist);
2464 }
2465
2466 static bool kprobe_blacklist__listed(unsigned long address)
2467 {
2468         return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address);
2469 }
2470
2471 static int perf_probe_event__sprintf(const char *group, const char *event,
2472                                      struct perf_probe_event *pev,
2473                                      const char *module,
2474                                      struct strbuf *result)
2475 {
2476         int i, ret;
2477         char *buf;
2478
2479         if (asprintf(&buf, "%s:%s", group, event) < 0)
2480                 return -errno;
2481         ret = strbuf_addf(result, "  %-20s (on ", buf);
2482         free(buf);
2483         if (ret)
2484                 return ret;
2485
2486         /* Synthesize only event probe point */
2487         buf = synthesize_perf_probe_point(&pev->point);
2488         if (!buf)
2489                 return -ENOMEM;
2490         ret = strbuf_addstr(result, buf);
2491         free(buf);
2492
2493         if (!ret && module)
2494                 ret = strbuf_addf(result, " in %s", module);
2495
2496         if (!ret && pev->nargs > 0) {
2497                 ret = strbuf_add(result, " with", 5);
2498                 for (i = 0; !ret && i < pev->nargs; i++) {
2499                         buf = synthesize_perf_probe_arg(&pev->args[i]);
2500                         if (!buf)
2501                                 return -ENOMEM;
2502                         ret = strbuf_addf(result, " %s", buf);
2503                         free(buf);
2504                 }
2505         }
2506         if (!ret)
2507                 ret = strbuf_addch(result, ')');
2508
2509         return ret;
2510 }
2511
2512 /* Show an event */
2513 int show_perf_probe_event(const char *group, const char *event,
2514                           struct perf_probe_event *pev,
2515                           const char *module, bool use_stdout)
2516 {
2517         struct strbuf buf = STRBUF_INIT;
2518         int ret;
2519
2520         ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
2521         if (ret >= 0) {
2522                 if (use_stdout)
2523                         printf("%s\n", buf.buf);
2524                 else
2525                         pr_info("%s\n", buf.buf);
2526         }
2527         strbuf_release(&buf);
2528
2529         return ret;
2530 }
2531
2532 static bool filter_probe_trace_event(struct probe_trace_event *tev,
2533                                      struct strfilter *filter)
2534 {
2535         char tmp[128];
2536
2537         /* At first, check the event name itself */
2538         if (strfilter__compare(filter, tev->event))
2539                 return true;
2540
2541         /* Next, check the combination of name and group */
2542         if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0)
2543                 return false;
2544         return strfilter__compare(filter, tmp);
2545 }
2546
2547 static int __show_perf_probe_events(int fd, bool is_kprobe,
2548                                     struct strfilter *filter)
2549 {
2550         int ret = 0;
2551         struct probe_trace_event tev;
2552         struct perf_probe_event pev;
2553         struct strlist *rawlist;
2554         struct str_node *ent;
2555
2556         memset(&tev, 0, sizeof(tev));
2557         memset(&pev, 0, sizeof(pev));
2558
2559         rawlist = probe_file__get_rawlist(fd);
2560         if (!rawlist)
2561                 return -ENOMEM;
2562
2563         strlist__for_each_entry(ent, rawlist) {
2564                 ret = parse_probe_trace_command(ent->s, &tev);
2565                 if (ret >= 0) {
2566                         if (!filter_probe_trace_event(&tev, filter))
2567                                 goto next;
2568                         ret = convert_to_perf_probe_event(&tev, &pev,
2569                                                                 is_kprobe);
2570                         if (ret < 0)
2571                                 goto next;
2572                         ret = show_perf_probe_event(pev.group, pev.event,
2573                                                     &pev, tev.point.module,
2574                                                     true);
2575                 }
2576 next:
2577                 clear_perf_probe_event(&pev);
2578                 clear_probe_trace_event(&tev);
2579                 if (ret < 0)
2580                         break;
2581         }
2582         strlist__delete(rawlist);
2583         /* Cleanup cached debuginfo if needed */
2584         debuginfo_cache__exit();
2585
2586         return ret;
2587 }
2588
2589 /* List up current perf-probe events */
2590 int show_perf_probe_events(struct strfilter *filter)
2591 {
2592         int kp_fd, up_fd, ret;
2593
2594         setup_pager();
2595
2596         if (probe_conf.cache)
2597                 return probe_cache__show_all_caches(filter);
2598
2599         ret = init_probe_symbol_maps(false);
2600         if (ret < 0)
2601                 return ret;
2602
2603         ret = probe_file__open_both(&kp_fd, &up_fd, 0);
2604         if (ret < 0)
2605                 return ret;
2606
2607         if (kp_fd >= 0)
2608                 ret = __show_perf_probe_events(kp_fd, true, filter);
2609         if (up_fd >= 0 && ret >= 0)
2610                 ret = __show_perf_probe_events(up_fd, false, filter);
2611         if (kp_fd > 0)
2612                 close(kp_fd);
2613         if (up_fd > 0)
2614                 close(up_fd);
2615         exit_probe_symbol_maps();
2616
2617         return ret;
2618 }
2619
2620 static int get_new_event_name(char *buf, size_t len, const char *base,
2621                               struct strlist *namelist, bool ret_event,
2622                               bool allow_suffix)
2623 {
2624         int i, ret;
2625         char *p, *nbase;
2626
2627         if (*base == '.')
2628                 base++;
2629         nbase = strdup(base);
2630         if (!nbase)
2631                 return -ENOMEM;
2632
2633         /* Cut off the dot suffixes (e.g. .const, .isra) and version suffixes */
2634         p = strpbrk(nbase, ".@");
2635         if (p && p != nbase)
2636                 *p = '\0';
2637
2638         /* Try no suffix number */
2639         ret = e_snprintf(buf, len, "%s%s", nbase, ret_event ? "__return" : "");
2640         if (ret < 0) {
2641                 pr_debug("snprintf() failed: %d\n", ret);
2642                 goto out;
2643         }
2644         if (!strlist__has_entry(namelist, buf))
2645                 goto out;
2646
2647         if (!allow_suffix) {
2648                 pr_warning("Error: event \"%s\" already exists.\n"
2649                            " Hint: Remove existing event by 'perf probe -d'\n"
2650                            "       or force duplicates by 'perf probe -f'\n"
2651                            "       or set 'force=yes' in BPF source.\n",
2652                            buf);
2653                 ret = -EEXIST;
2654                 goto out;
2655         }
2656
2657         /* Try to add suffix */
2658         for (i = 1; i < MAX_EVENT_INDEX; i++) {
2659                 ret = e_snprintf(buf, len, "%s_%d", nbase, i);
2660                 if (ret < 0) {
2661                         pr_debug("snprintf() failed: %d\n", ret);
2662                         goto out;
2663                 }
2664                 if (!strlist__has_entry(namelist, buf))
2665                         break;
2666         }
2667         if (i == MAX_EVENT_INDEX) {
2668                 pr_warning("Too many events are on the same function.\n");
2669                 ret = -ERANGE;
2670         }
2671
2672 out:
2673         free(nbase);
2674
2675         /* Final validation */
2676         if (ret >= 0 && !is_c_func_name(buf)) {
2677                 pr_warning("Internal error: \"%s\" is an invalid event name.\n",
2678                            buf);
2679                 ret = -EINVAL;
2680         }
2681
2682         return ret;
2683 }
2684
2685 /* Warn if the current kernel's uprobe implementation is old */
2686 static void warn_uprobe_event_compat(struct probe_trace_event *tev)
2687 {
2688         int i;
2689         char *buf = synthesize_probe_trace_command(tev);
2690         struct probe_trace_point *tp = &tev->point;
2691
2692         if (tp->ref_ctr_offset && !uprobe_ref_ctr_is_supported()) {
2693                 pr_warning("A semaphore is associated with %s:%s and "
2694                            "seems your kernel doesn't support it.\n",
2695                            tev->group, tev->event);
2696         }
2697
2698         /* Old uprobe event doesn't support memory dereference */
2699         if (!tev->uprobes || tev->nargs == 0 || !buf)
2700                 goto out;
2701
2702         for (i = 0; i < tev->nargs; i++)
2703                 if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
2704                         pr_warning("Please upgrade your kernel to at least "
2705                                    "3.14 to have access to feature %s\n",
2706                                    tev->args[i].value);
2707                         break;
2708                 }
2709 out:
2710         free(buf);
2711 }
2712
2713 /* Set new name from original perf_probe_event and namelist */
2714 static int probe_trace_event__set_name(struct probe_trace_event *tev,
2715                                        struct perf_probe_event *pev,
2716                                        struct strlist *namelist,
2717                                        bool allow_suffix)
2718 {
2719         const char *event, *group;
2720         char buf[64];
2721         int ret;
2722
2723         /* If probe_event or trace_event already have the name, reuse it */
2724         if (pev->event && !pev->sdt)
2725                 event = pev->event;
2726         else if (tev->event)
2727                 event = tev->event;
2728         else {
2729                 /* Or generate new one from probe point */
2730                 if (pev->point.function &&
2731                         (strncmp(pev->point.function, "0x", 2) != 0) &&
2732                         !strisglob(pev->point.function))
2733                         event = pev->point.function;
2734                 else
2735                         event = tev->point.realname;
2736         }
2737         if (pev->group && !pev->sdt)
2738                 group = pev->group;
2739         else if (tev->group)
2740                 group = tev->group;
2741         else
2742                 group = PERFPROBE_GROUP;
2743
2744         /* Get an unused new event name */
2745         ret = get_new_event_name(buf, 64, event, namelist,
2746                                  tev->point.retprobe, allow_suffix);
2747         if (ret < 0)
2748                 return ret;
2749
2750         event = buf;
2751
2752         tev->event = strdup(event);
2753         tev->group = strdup(group);
2754         if (tev->event == NULL || tev->group == NULL)
2755                 return -ENOMEM;
2756
2757         /*
2758          * Add new event name to namelist if multiprobe event is NOT
2759          * supported, since we have to use new event name for following
2760          * probes in that case.
2761          */
2762         if (!multiprobe_event_is_supported())
2763                 strlist__add(namelist, event);
2764         return 0;
2765 }
2766
2767 static int __open_probe_file_and_namelist(bool uprobe,
2768                                           struct strlist **namelist)
2769 {
2770         int fd;
2771
2772         fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
2773         if (fd < 0)
2774                 return fd;
2775
2776         /* Get current event names */
2777         *namelist = probe_file__get_namelist(fd);
2778         if (!(*namelist)) {
2779                 pr_debug("Failed to get current event list.\n");
2780                 close(fd);
2781                 return -ENOMEM;
2782         }
2783         return fd;
2784 }
2785
2786 static int __add_probe_trace_events(struct perf_probe_event *pev,
2787                                      struct probe_trace_event *tevs,
2788                                      int ntevs, bool allow_suffix)
2789 {
2790         int i, fd[2] = {-1, -1}, up, ret;
2791         struct probe_trace_event *tev = NULL;
2792         struct probe_cache *cache = NULL;
2793         struct strlist *namelist[2] = {NULL, NULL};
2794         struct nscookie nsc;
2795
2796         up = pev->uprobes ? 1 : 0;
2797         fd[up] = __open_probe_file_and_namelist(up, &namelist[up]);
2798         if (fd[up] < 0)
2799                 return fd[up];
2800
2801         ret = 0;
2802         for (i = 0; i < ntevs; i++) {
2803                 tev = &tevs[i];
2804                 up = tev->uprobes ? 1 : 0;
2805                 if (fd[up] == -1) {     /* Open the kprobe/uprobe_events */
2806                         fd[up] = __open_probe_file_and_namelist(up,
2807                                                                 &namelist[up]);
2808                         if (fd[up] < 0)
2809                                 goto close_out;
2810                 }
2811                 /* Skip if the symbol is out of .text or blacklisted */
2812                 if (!tev->point.symbol && !pev->uprobes)
2813                         continue;
2814
2815                 /* Set new name for tev (and update namelist) */
2816                 ret = probe_trace_event__set_name(tev, pev, namelist[up],
2817                                                   allow_suffix);
2818                 if (ret < 0)
2819                         break;
2820
2821                 nsinfo__mountns_enter(pev->nsi, &nsc);
2822                 ret = probe_file__add_event(fd[up], tev);
2823                 nsinfo__mountns_exit(&nsc);
2824                 if (ret < 0)
2825                         break;
2826
2827                 /*
2828                  * Probes after the first probe which comes from same
2829                  * user input are always allowed to add suffix, because
2830                  * there might be several addresses corresponding to
2831                  * one code line.
2832                  */
2833                 allow_suffix = true;
2834         }
2835         if (ret == -EINVAL && pev->uprobes)
2836                 warn_uprobe_event_compat(tev);
2837         if (ret == 0 && probe_conf.cache) {
2838                 cache = probe_cache__new(pev->target, pev->nsi);
2839                 if (!cache ||
2840                     probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 ||
2841                     probe_cache__commit(cache) < 0)
2842                         pr_warning("Failed to add event to probe cache\n");
2843                 probe_cache__delete(cache);
2844         }
2845
2846 close_out:
2847         for (up = 0; up < 2; up++) {
2848                 strlist__delete(namelist[up]);
2849                 if (fd[up] >= 0)
2850                         close(fd[up]);
2851         }
2852         return ret;
2853 }
2854
2855 static int find_probe_functions(struct map *map, char *name,
2856                                 struct symbol **syms)
2857 {
2858         int found = 0;
2859         struct symbol *sym;
2860         struct rb_node *tmp;
2861         const char *norm, *ver;
2862         char *buf = NULL;
2863         bool cut_version = true;
2864
2865         if (map__load(map) < 0)
2866                 return 0;
2867
2868         /* If user gives a version, don't cut off the version from symbols */
2869         if (strchr(name, '@'))
2870                 cut_version = false;
2871
2872         map__for_each_symbol(map, sym, tmp) {
2873                 norm = arch__normalize_symbol_name(sym->name);
2874                 if (!norm)
2875                         continue;
2876
2877                 if (cut_version) {
2878                         /* We don't care about default symbol or not */
2879                         ver = strchr(norm, '@');
2880                         if (ver) {
2881                                 buf = strndup(norm, ver - norm);
2882                                 if (!buf)
2883                                         return -ENOMEM;
2884                                 norm = buf;
2885                         }
2886                 }
2887
2888                 if (strglobmatch(norm, name)) {
2889                         found++;
2890                         if (syms && found < probe_conf.max_probes)
2891                                 syms[found - 1] = sym;
2892                 }
2893                 if (buf)
2894                         zfree(&buf);
2895         }
2896
2897         return found;
2898 }
2899
2900 void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
2901                                 struct probe_trace_event *tev __maybe_unused,
2902                                 struct map *map __maybe_unused,
2903                                 struct symbol *sym __maybe_unused) { }
2904
2905 /*
2906  * Find probe function addresses from map.
2907  * Return an error or the number of found probe_trace_event
2908  */
2909 static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2910                                             struct probe_trace_event **tevs)
2911 {
2912         struct map *map = NULL;
2913         struct ref_reloc_sym *reloc_sym = NULL;
2914         struct symbol *sym;
2915         struct symbol **syms = NULL;
2916         struct probe_trace_event *tev;
2917         struct perf_probe_point *pp = &pev->point;
2918         struct probe_trace_point *tp;
2919         int num_matched_functions;
2920         int ret, i, j, skipped = 0;
2921         char *mod_name;
2922
2923         map = get_target_map(pev->target, pev->nsi, pev->uprobes);
2924         if (!map) {
2925                 ret = -EINVAL;
2926                 goto out;
2927         }
2928
2929         syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
2930         if (!syms) {
2931                 ret = -ENOMEM;
2932                 goto out;
2933         }
2934
2935         /*
2936          * Load matched symbols: Since the different local symbols may have
2937          * same name but different addresses, this lists all the symbols.
2938          */
2939         num_matched_functions = find_probe_functions(map, pp->function, syms);
2940         if (num_matched_functions <= 0) {
2941                 pr_err("Failed to find symbol %s in %s\n", pp->function,
2942                         pev->target ? : "kernel");
2943                 ret = -ENOENT;
2944                 goto out;
2945         } else if (num_matched_functions > probe_conf.max_probes) {
2946                 pr_err("Too many functions matched in %s\n",
2947                         pev->target ? : "kernel");
2948                 ret = -E2BIG;
2949                 goto out;
2950         }
2951
2952         /* Note that the symbols in the kmodule are not relocated */
2953         if (!pev->uprobes && !pev->target &&
2954                         (!pp->retprobe || kretprobe_offset_is_supported())) {
2955                 reloc_sym = kernel_get_ref_reloc_sym(NULL);
2956                 if (!reloc_sym) {
2957                         pr_warning("Relocated base symbol is not found!\n");
2958                         ret = -EINVAL;
2959                         goto out;
2960                 }
2961         }
2962
2963         /* Setup result trace-probe-events */
2964         *tevs = zalloc(sizeof(*tev) * num_matched_functions);
2965         if (!*tevs) {
2966                 ret = -ENOMEM;
2967                 goto out;
2968         }
2969
2970         ret = 0;
2971
2972         for (j = 0; j < num_matched_functions; j++) {
2973                 sym = syms[j];
2974
2975                 /* There can be duplicated symbols in the map */
2976                 for (i = 0; i < j; i++)
2977                         if (sym->start == syms[i]->start) {
2978                                 pr_debug("Found duplicated symbol %s @ %" PRIx64 "\n",
2979                                          sym->name, sym->start);
2980                                 break;
2981                         }
2982                 if (i != j)
2983                         continue;
2984
2985                 tev = (*tevs) + ret;
2986                 tp = &tev->point;
2987                 if (ret == num_matched_functions) {
2988                         pr_warning("Too many symbols are listed. Skip it.\n");
2989                         break;
2990                 }
2991                 ret++;
2992
2993                 if (pp->offset > sym->end - sym->start) {
2994                         pr_warning("Offset %ld is bigger than the size of %s\n",
2995                                    pp->offset, sym->name);
2996                         ret = -ENOENT;
2997                         goto err_out;
2998                 }
2999                 /* Add one probe point */
3000                 tp->address = map->unmap_ip(map, sym->start) + pp->offset;
3001
3002                 /* Check the kprobe (not in module) is within .text  */
3003                 if (!pev->uprobes && !pev->target &&
3004                     kprobe_warn_out_range(sym->name, tp->address)) {
3005                         tp->symbol = NULL;      /* Skip it */
3006                         skipped++;
3007                 } else if (reloc_sym) {
3008                         tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
3009                         tp->offset = tp->address - reloc_sym->addr;
3010                 } else {
3011                         tp->symbol = strdup_or_goto(sym->name, nomem_out);
3012                         tp->offset = pp->offset;
3013                 }
3014                 tp->realname = strdup_or_goto(sym->name, nomem_out);
3015
3016                 tp->retprobe = pp->retprobe;
3017                 if (pev->target) {
3018                         if (pev->uprobes) {
3019                                 tev->point.module = strdup_or_goto(pev->target,
3020                                                                    nomem_out);
3021                         } else {
3022                                 mod_name = find_module_name(pev->target);
3023                                 tev->point.module =
3024                                         strdup(mod_name ? mod_name : pev->target);
3025                                 free(mod_name);
3026                                 if (!tev->point.module)
3027                                         goto nomem_out;
3028                         }
3029                 }
3030                 tev->uprobes = pev->uprobes;
3031                 tev->nargs = pev->nargs;
3032                 if (tev->nargs) {
3033                         tev->args = zalloc(sizeof(struct probe_trace_arg) *
3034                                            tev->nargs);
3035                         if (tev->args == NULL)
3036                                 goto nomem_out;
3037                 }
3038                 for (i = 0; i < tev->nargs; i++) {
3039                         if (pev->args[i].name)
3040                                 tev->args[i].name =
3041                                         strdup_or_goto(pev->args[i].name,
3042                                                         nomem_out);
3043
3044                         tev->args[i].value = strdup_or_goto(pev->args[i].var,
3045                                                             nomem_out);
3046                         if (pev->args[i].type)
3047                                 tev->args[i].type =
3048                                         strdup_or_goto(pev->args[i].type,
3049                                                         nomem_out);
3050                 }
3051                 arch__fix_tev_from_maps(pev, tev, map, sym);
3052         }
3053         if (ret == skipped) {
3054                 ret = -ENOENT;
3055                 goto err_out;
3056         }
3057
3058 out:
3059         map__put(map);
3060         free(syms);
3061         return ret;
3062
3063 nomem_out:
3064         ret = -ENOMEM;
3065 err_out:
3066         clear_probe_trace_events(*tevs, num_matched_functions);
3067         zfree(tevs);
3068         goto out;
3069 }
3070
3071 static int try_to_find_absolute_address(struct perf_probe_event *pev,
3072                                         struct probe_trace_event **tevs)
3073 {
3074         struct perf_probe_point *pp = &pev->point;
3075         struct probe_trace_event *tev;
3076         struct probe_trace_point *tp;
3077         int i, err;
3078
3079         if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2)))
3080                 return -EINVAL;
3081         if (perf_probe_event_need_dwarf(pev))
3082                 return -EINVAL;
3083
3084         /*
3085          * This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at
3086          * absolute address.
3087          *
3088          * Only one tev can be generated by this.
3089          */
3090         *tevs = zalloc(sizeof(*tev));
3091         if (!*tevs)
3092                 return -ENOMEM;
3093
3094         tev = *tevs;
3095         tp = &tev->point;
3096
3097         /*
3098          * Don't use tp->offset, use address directly, because
3099          * in synthesize_probe_trace_command() address cannot be
3100          * zero.
3101          */
3102         tp->address = pev->point.abs_address;
3103         tp->retprobe = pp->retprobe;
3104         tev->uprobes = pev->uprobes;
3105
3106         err = -ENOMEM;
3107         /*
3108          * Give it a '0x' leading symbol name.
3109          * In __add_probe_trace_events, a NULL symbol is interpreted as
3110          * invalid.
3111          */
3112         if (asprintf(&tp->symbol, "0x%lx", tp->address) < 0)
3113                 goto errout;
3114
3115         /* For kprobe, check range */
3116         if ((!tev->uprobes) &&
3117             (kprobe_warn_out_range(tev->point.symbol,
3118                                    tev->point.address))) {
3119                 err = -EACCES;
3120                 goto errout;
3121         }
3122
3123         if (asprintf(&tp->realname, "abs_%lx", tp->address) < 0)
3124                 goto errout;
3125
3126         if (pev->target) {
3127                 tp->module = strdup(pev->target);
3128                 if (!tp->module)
3129                         goto errout;
3130         }
3131
3132         if (tev->group) {
3133                 tev->group = strdup(pev->group);
3134                 if (!tev->group)
3135                         goto errout;
3136         }
3137
3138         if (pev->event) {
3139                 tev->event = strdup(pev->event);
3140                 if (!tev->event)
3141                         goto errout;
3142         }
3143
3144         tev->nargs = pev->nargs;
3145         tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
3146         if (!tev->args)
3147                 goto errout;
3148
3149         for (i = 0; i < tev->nargs; i++)
3150                 copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]);
3151
3152         return 1;
3153
3154 errout:
3155         clear_probe_trace_events(*tevs, 1);
3156         *tevs = NULL;
3157         return err;
3158 }
3159
3160 /* Concatinate two arrays */
3161 static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b)
3162 {
3163         void *ret;
3164
3165         ret = malloc(sz_a + sz_b);
3166         if (ret) {
3167                 memcpy(ret, a, sz_a);
3168                 memcpy(ret + sz_a, b, sz_b);
3169         }
3170         return ret;
3171 }
3172
3173 static int
3174 concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
3175                           struct probe_trace_event **tevs2, int ntevs2)
3176 {
3177         struct probe_trace_event *new_tevs;
3178         int ret = 0;
3179
3180         if (*ntevs == 0) {
3181                 *tevs = *tevs2;
3182                 *ntevs = ntevs2;
3183                 *tevs2 = NULL;
3184                 return 0;
3185         }
3186
3187         if (*ntevs + ntevs2 > probe_conf.max_probes)
3188                 ret = -E2BIG;
3189         else {
3190                 /* Concatinate the array of probe_trace_event */
3191                 new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs),
3192                                   *tevs2, ntevs2 * sizeof(**tevs2));
3193                 if (!new_tevs)
3194                         ret = -ENOMEM;
3195                 else {
3196                         free(*tevs);
3197                         *tevs = new_tevs;
3198                         *ntevs += ntevs2;
3199                 }
3200         }
3201         if (ret < 0)
3202                 clear_probe_trace_events(*tevs2, ntevs2);
3203         zfree(tevs2);
3204
3205         return ret;
3206 }
3207
3208 /*
3209  * Try to find probe_trace_event from given probe caches. Return the number
3210  * of cached events found, if an error occurs return the error.
3211  */
3212 static int find_cached_events(struct perf_probe_event *pev,
3213                               struct probe_trace_event **tevs,
3214                               const char *target)
3215 {
3216         struct probe_cache *cache;
3217         struct probe_cache_entry *entry;
3218         struct probe_trace_event *tmp_tevs = NULL;
3219         int ntevs = 0;
3220         int ret = 0;
3221
3222         cache = probe_cache__new(target, pev->nsi);
3223         /* Return 0 ("not found") if the target has no probe cache. */
3224         if (!cache)
3225                 return 0;
3226
3227         for_each_probe_cache_entry(entry, cache) {
3228                 /* Skip the cache entry which has no name */
3229                 if (!entry->pev.event || !entry->pev.group)
3230                         continue;
3231                 if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) &&
3232                     strglobmatch(entry->pev.event, pev->event)) {
3233                         ret = probe_cache_entry__get_event(entry, &tmp_tevs);
3234                         if (ret > 0)
3235                                 ret = concat_probe_trace_events(tevs, &ntevs,
3236                                                                 &tmp_tevs, ret);
3237                         if (ret < 0)
3238                                 break;
3239                 }
3240         }
3241         probe_cache__delete(cache);
3242         if (ret < 0) {
3243                 clear_probe_trace_events(*tevs, ntevs);
3244                 zfree(tevs);
3245         } else {
3246                 ret = ntevs;
3247                 if (ntevs > 0 && target && target[0] == '/')
3248                         pev->uprobes = true;
3249         }
3250
3251         return ret;
3252 }
3253
3254 /* Try to find probe_trace_event from all probe caches */
3255 static int find_cached_events_all(struct perf_probe_event *pev,
3256                                    struct probe_trace_event **tevs)
3257 {
3258         struct probe_trace_event *tmp_tevs = NULL;
3259         struct strlist *bidlist;
3260         struct str_node *nd;
3261         char *pathname;
3262         int ntevs = 0;
3263         int ret;
3264
3265         /* Get the buildid list of all valid caches */
3266         bidlist = build_id_cache__list_all(true);
3267         if (!bidlist) {
3268                 ret = -errno;
3269                 pr_debug("Failed to get buildids: %d\n", ret);
3270                 return ret;
3271         }
3272
3273         ret = 0;
3274         strlist__for_each_entry(nd, bidlist) {
3275                 pathname = build_id_cache__origname(nd->s);
3276                 ret = find_cached_events(pev, &tmp_tevs, pathname);
3277                 /* In the case of cnt == 0, we just skip it */
3278                 if (ret > 0)
3279                         ret = concat_probe_trace_events(tevs, &ntevs,
3280                                                         &tmp_tevs, ret);
3281                 free(pathname);
3282                 if (ret < 0)
3283                         break;
3284         }
3285         strlist__delete(bidlist);
3286
3287         if (ret < 0) {
3288                 clear_probe_trace_events(*tevs, ntevs);
3289                 zfree(tevs);
3290         } else
3291                 ret = ntevs;
3292
3293         return ret;
3294 }
3295
3296 static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
3297                                               struct probe_trace_event **tevs)
3298 {
3299         struct probe_cache *cache;
3300         struct probe_cache_entry *entry;
3301         struct probe_trace_event *tev;
3302         struct str_node *node;
3303         int ret, i;
3304
3305         if (pev->sdt) {
3306                 /* For SDT/cached events, we use special search functions */
3307                 if (!pev->target)
3308                         return find_cached_events_all(pev, tevs);
3309                 else
3310                         return find_cached_events(pev, tevs, pev->target);
3311         }
3312         cache = probe_cache__new(pev->target, pev->nsi);
3313         if (!cache)
3314                 return 0;
3315
3316         entry = probe_cache__find(cache, pev);
3317         if (!entry) {
3318                 /* SDT must be in the cache */
3319                 ret = pev->sdt ? -ENOENT : 0;
3320                 goto out;
3321         }
3322
3323         ret = strlist__nr_entries(entry->tevlist);
3324         if (ret > probe_conf.max_probes) {
3325                 pr_debug("Too many entries matched in the cache of %s\n",
3326                          pev->target ? : "kernel");
3327                 ret = -E2BIG;
3328                 goto out;
3329         }
3330
3331         *tevs = zalloc(ret * sizeof(*tev));
3332         if (!*tevs) {
3333                 ret = -ENOMEM;
3334                 goto out;
3335         }
3336
3337         i = 0;
3338         strlist__for_each_entry(node, entry->tevlist) {
3339                 tev = &(*tevs)[i++];
3340                 ret = parse_probe_trace_command(node->s, tev);
3341                 if (ret < 0)
3342                         goto out;
3343                 /* Set the uprobes attribute as same as original */
3344                 tev->uprobes = pev->uprobes;
3345         }
3346         ret = i;
3347
3348 out:
3349         probe_cache__delete(cache);
3350         return ret;
3351 }
3352
3353 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
3354                                          struct probe_trace_event **tevs)
3355 {
3356         int ret;
3357
3358         if (!pev->group && !pev->sdt) {
3359                 /* Set group name if not given */
3360                 if (!pev->uprobes) {
3361                         pev->group = strdup(PERFPROBE_GROUP);
3362                         ret = pev->group ? 0 : -ENOMEM;
3363                 } else
3364                         ret = convert_exec_to_group(pev->target, &pev->group);
3365                 if (ret != 0) {
3366                         pr_warning("Failed to make a group name.\n");
3367                         return ret;
3368                 }
3369         }
3370
3371         ret = try_to_find_absolute_address(pev, tevs);
3372         if (ret > 0)
3373                 return ret;
3374
3375         /* At first, we need to lookup cache entry */
3376         ret = find_probe_trace_events_from_cache(pev, tevs);
3377         if (ret > 0 || pev->sdt)        /* SDT can be found only in the cache */
3378                 return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
3379
3380         /* Convert perf_probe_event with debuginfo */
3381         ret = try_to_find_probe_trace_events(pev, tevs);
3382         if (ret != 0)
3383                 return ret;     /* Found in debuginfo or got an error */
3384
3385         return find_probe_trace_events_from_map(pev, tevs);
3386 }
3387
3388 int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3389 {
3390         int i, ret;
3391
3392         /* Loop 1: convert all events */
3393         for (i = 0; i < npevs; i++) {
3394                 /* Init kprobe blacklist if needed */
3395                 if (!pevs[i].uprobes)
3396                         kprobe_blacklist__init();
3397                 /* Convert with or without debuginfo */
3398                 ret  = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
3399                 if (ret < 0)
3400                         return ret;
3401                 pevs[i].ntevs = ret;
3402         }
3403         /* This just release blacklist only if allocated */
3404         kprobe_blacklist__release();
3405
3406         return 0;
3407 }
3408
3409 static int show_probe_trace_event(struct probe_trace_event *tev)
3410 {
3411         char *buf = synthesize_probe_trace_command(tev);
3412
3413         if (!buf) {
3414                 pr_debug("Failed to synthesize probe trace event.\n");
3415                 return -EINVAL;
3416         }
3417
3418         /* Showing definition always go stdout */
3419         printf("%s\n", buf);
3420         free(buf);
3421
3422         return 0;
3423 }
3424
3425 int show_probe_trace_events(struct perf_probe_event *pevs, int npevs)
3426 {
3427         struct strlist *namelist = strlist__new(NULL, NULL);
3428         struct probe_trace_event *tev;
3429         struct perf_probe_event *pev;
3430         int i, j, ret = 0;
3431
3432         if (!namelist)
3433                 return -ENOMEM;
3434
3435         for (j = 0; j < npevs && !ret; j++) {
3436                 pev = &pevs[j];
3437                 for (i = 0; i < pev->ntevs && !ret; i++) {
3438                         tev = &pev->tevs[i];
3439                         /* Skip if the symbol is out of .text or blacklisted */
3440                         if (!tev->point.symbol && !pev->uprobes)
3441                                 continue;
3442
3443                         /* Set new name for tev (and update namelist) */
3444                         ret = probe_trace_event__set_name(tev, pev,
3445                                                           namelist, true);
3446                         if (!ret)
3447                                 ret = show_probe_trace_event(tev);
3448                 }
3449         }
3450         strlist__delete(namelist);
3451
3452         return ret;
3453 }
3454
3455 int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3456 {
3457         int i, ret = 0;
3458
3459         /* Loop 2: add all events */
3460         for (i = 0; i < npevs; i++) {
3461                 ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
3462                                                pevs[i].ntevs,
3463                                                probe_conf.force_add);
3464                 if (ret < 0)
3465                         break;
3466         }
3467         return ret;
3468 }
3469
3470 void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3471 {
3472         int i, j;
3473         struct perf_probe_event *pev;
3474
3475         /* Loop 3: cleanup and free trace events  */
3476         for (i = 0; i < npevs; i++) {
3477                 pev = &pevs[i];
3478                 for (j = 0; j < pevs[i].ntevs; j++)
3479                         clear_probe_trace_event(&pevs[i].tevs[j]);
3480                 zfree(&pevs[i].tevs);
3481                 pevs[i].ntevs = 0;
3482                 nsinfo__zput(pev->nsi);
3483                 clear_perf_probe_event(&pevs[i]);
3484         }
3485 }
3486
3487 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3488 {
3489         int ret;
3490
3491         ret = init_probe_symbol_maps(pevs->uprobes);
3492         if (ret < 0)
3493                 return ret;
3494
3495         ret = convert_perf_probe_events(pevs, npevs);
3496         if (ret == 0)
3497                 ret = apply_perf_probe_events(pevs, npevs);
3498
3499         cleanup_perf_probe_events(pevs, npevs);
3500
3501         exit_probe_symbol_maps();
3502         return ret;
3503 }
3504
3505 int del_perf_probe_events(struct strfilter *filter)
3506 {
3507         int ret, ret2, ufd = -1, kfd = -1;
3508         char *str = strfilter__string(filter);
3509
3510         if (!str)
3511                 return -EINVAL;
3512
3513         /* Get current event names */
3514         ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
3515         if (ret < 0)
3516                 goto out;
3517
3518         ret = probe_file__del_events(kfd, filter);
3519         if (ret < 0 && ret != -ENOENT)
3520                 goto error;
3521
3522         ret2 = probe_file__del_events(ufd, filter);
3523         if (ret2 < 0 && ret2 != -ENOENT) {
3524                 ret = ret2;
3525                 goto error;
3526         }
3527         ret = 0;
3528
3529 error:
3530         if (kfd >= 0)
3531                 close(kfd);
3532         if (ufd >= 0)
3533                 close(ufd);
3534 out:
3535         free(str);
3536
3537         return ret;
3538 }
3539
3540 int show_available_funcs(const char *target, struct nsinfo *nsi,
3541                          struct strfilter *_filter, bool user)
3542 {
3543         struct rb_node *nd;
3544         struct map *map;
3545         int ret;
3546
3547         ret = init_probe_symbol_maps(user);
3548         if (ret < 0)
3549                 return ret;
3550
3551         /* Get a symbol map */
3552         map = get_target_map(target, nsi, user);
3553         if (!map) {
3554                 pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
3555                 return -EINVAL;
3556         }
3557
3558         ret = map__load(map);
3559         if (ret) {
3560                 if (ret == -2) {
3561                         char *str = strfilter__string(_filter);
3562                         pr_err("Failed to find symbols matched to \"%s\"\n",
3563                                str);
3564                         free(str);
3565                 } else
3566                         pr_err("Failed to load symbols in %s\n",
3567                                (target) ? : "kernel");
3568                 goto end;
3569         }
3570         if (!dso__sorted_by_name(map->dso))
3571                 dso__sort_by_name(map->dso);
3572
3573         /* Show all (filtered) symbols */
3574         setup_pager();
3575
3576         for (nd = rb_first_cached(&map->dso->symbol_names); nd;
3577              nd = rb_next(nd)) {
3578                 struct symbol_name_rb_node *pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
3579
3580                 if (strfilter__compare(_filter, pos->sym.name))
3581                         printf("%s\n", pos->sym.name);
3582         }
3583 end:
3584         map__put(map);
3585         exit_probe_symbol_maps();
3586
3587         return ret;
3588 }
3589
3590 int copy_to_probe_trace_arg(struct probe_trace_arg *tvar,
3591                             struct perf_probe_arg *pvar)
3592 {
3593         tvar->value = strdup(pvar->var);
3594         if (tvar->value == NULL)
3595                 return -ENOMEM;
3596         if (pvar->type) {
3597                 tvar->type = strdup(pvar->type);
3598                 if (tvar->type == NULL)
3599                         return -ENOMEM;
3600         }
3601         if (pvar->name) {
3602                 tvar->name = strdup(pvar->name);
3603                 if (tvar->name == NULL)
3604                         return -ENOMEM;
3605         } else
3606                 tvar->name = NULL;
3607         return 0;
3608 }