tools/perf/util/probe-event.c

   1 /*
   2  * probe-event.c : perf-probe definition to probe_events format converter
   3  *
   4  * Written by Masami Hiramatsu <mhiramat@redhat.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19  *
  20  */
  21
  22 #include <sys/utsname.h>
  23 #include <sys/types.h>
  24 #include <sys/stat.h>
  25 #include <fcntl.h>
  26 #include <errno.h>
  27 #include <stdio.h>
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <stdarg.h>
  32 #include <limits.h>
  33 #include <elf.h>
  34
  35 #include "util.h"
  36 #include "event.h"
  37 #include "strlist.h"
  38 #include "debug.h"
  39 #include "cache.h"
  40 #include "color.h"
  41 #include "symbol.h"
  42 #include "thread.h"
  43 #include <api/fs/debugfs.h>
  44 #include <api/fs/tracefs.h>
  45 #include "trace-event.h"        /* For __maybe_unused */
  46 #include "probe-event.h"
  47 #include "probe-finder.h"
  48 #include "session.h"
  49
  50 #define MAX_CMDLEN 256
  51 #define PERFPROBE_GROUP "probe"
  52
  53 bool probe_event_dry_run;       /* Dry run flag */
  54 struct probe_conf probe_conf;
  55
  56 #define semantic_error(msg ...) pr_err("Semantic error :" msg)
  57
  58 /* If there is no space to write, returns -E2BIG. */
  59 static int e_snprintf(char *str, size_t size, const char *format, ...)
  60         __attribute__((format(printf, 3, 4)));
  61
  62 static int e_snprintf(char *str, size_t size, const char *format, ...)
  63 {
  64         int ret;
  65         va_list ap;
  66         va_start(ap, format);
  67         ret = vsnprintf(str, size, format, ap);
  68         va_end(ap);
  69         if (ret >= (int)size)
  70                 ret = -E2BIG;
  71         return ret;
  72 }
  73
  74 static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
  75 static void clear_probe_trace_event(struct probe_trace_event *tev);
  76 static struct machine *host_machine;
  77
  78 /* Initialize symbol maps and path of vmlinux/modules */
  79 static int init_symbol_maps(bool user_only)
  80 {
  81         int ret;
  82
  83         symbol_conf.sort_by_name = true;
  84         symbol_conf.allow_aliases = true;
  85         ret = symbol__init(NULL);
  86         if (ret < 0) {
  87                 pr_debug("Failed to init symbol map.\n");
  88                 goto out;
  89         }
  90
  91         if (host_machine || user_only)  /* already initialized */
  92                 return 0;
  93
  94         if (symbol_conf.vmlinux_name)
  95                 pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
  96
  97         host_machine = machine__new_host();
  98         if (!host_machine) {
  99                 pr_debug("machine__new_host() failed.\n");
 100                 symbol__exit();
 101                 ret = -1;
 102         }
 103 out:
 104         if (ret < 0)
 105                 pr_warning("Failed to init vmlinux path.\n");
 106         return ret;
 107 }
 108
 109 static void exit_symbol_maps(void)
 110 {
 111         if (host_machine) {
 112                 machine__delete(host_machine);
 113                 host_machine = NULL;
 114         }
 115         symbol__exit();
 116 }
 117
 118 static struct symbol *__find_kernel_function_by_name(const char *name,
 119                                                      struct map **mapp)
 120 {
 121         return machine__find_kernel_function_by_name(host_machine, name, mapp,
 122                                                      NULL);
 123 }
 124
 125 static struct symbol *__find_kernel_function(u64 addr, struct map **mapp)
 126 {
 127         return machine__find_kernel_function(host_machine, addr, mapp, NULL);
 128 }
 129
 130 static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
 131 {
 132         /* kmap->ref_reloc_sym should be set if host_machine is initialized */
 133         struct kmap *kmap;
 134
 135         if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0)
 136                 return NULL;
 137
 138         kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]);
 139         if (!kmap)
 140                 return NULL;
 141         return kmap->ref_reloc_sym;
 142 }
 143
 144 static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc)
 145 {
 146         struct ref_reloc_sym *reloc_sym;
 147         struct symbol *sym;
 148         struct map *map;
 149
 150         /* ref_reloc_sym is just a label. Need a special fix*/
 151         reloc_sym = kernel_get_ref_reloc_sym();
 152         if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
 153                 return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
 154         else {
 155                 sym = __find_kernel_function_by_name(name, &map);
 156                 if (sym)
 157                         return map->unmap_ip(map, sym->start) -
 158                                 ((reloc) ? 0 : map->reloc);
 159         }
 160         return 0;
 161 }
 162
 163 static struct map *kernel_get_module_map(const char *module)
 164 {
 165         struct map_groups *grp = &host_machine->kmaps;
 166         struct maps *maps = &grp->maps[MAP__FUNCTION];
 167         struct map *pos;
 168
 169         /* A file path -- this is an offline module */
 170         if (module && strchr(module, '/'))
 171                 return machine__findnew_module_map(host_machine, 0, module);
 172
 173         if (!module)
 174                 module = "kernel";
 175
 176         for (pos = maps__first(maps); pos; pos = map__next(pos)) {
 177                 if (strncmp(pos->dso->short_name + 1, module,
 178                             pos->dso->short_name_len - 2) == 0) {
 179                         return pos;
 180                 }
 181         }
 182         return NULL;
 183 }
 184
 185 static struct map *get_target_map(const char *target, bool user)
 186 {
 187         /* Init maps of given executable or kernel */
 188         if (user)
 189                 return dso__new_map(target);
 190         else
 191                 return kernel_get_module_map(target);
 192 }
 193
 194 static void put_target_map(struct map *map, bool user)
 195 {
 196         if (map && user) {
 197                 /* Only the user map needs to be released */
 198                 map__put(map);
 199         }
 200 }
 201
 202
 203 static int convert_exec_to_group(const char *exec, char **result)
 204 {
 205         char *ptr1, *ptr2, *exec_copy;
 206         char buf[64];
 207         int ret;
 208
 209         exec_copy = strdup(exec);
 210         if (!exec_copy)
 211                 return -ENOMEM;
 212
 213         ptr1 = basename(exec_copy);
 214         if (!ptr1) {
 215                 ret = -EINVAL;
 216                 goto out;
 217         }
 218
 219         ptr2 = strpbrk(ptr1, "-._");
 220         if (ptr2)
 221                 *ptr2 = '\0';
 222         ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
 223         if (ret < 0)
 224                 goto out;
 225
 226         *result = strdup(buf);
 227         ret = *result ? 0 : -ENOMEM;
 228
 229 out:
 230         free(exec_copy);
 231         return ret;
 232 }
 233
 234 static void clear_perf_probe_point(struct perf_probe_point *pp)
 235 {
 236         free(pp->file);
 237         free(pp->function);
 238         free(pp->lazy_line);
 239 }
 240
 241 static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 242 {
 243         int i;
 244
 245         for (i = 0; i < ntevs; i++)
 246                 clear_probe_trace_event(tevs + i);
 247 }
 248
 249 static bool kprobe_blacklist__listed(unsigned long address);
 250 static bool kprobe_warn_out_range(const char *symbol, unsigned long address)
 251 {
 252         u64 etext_addr;
 253
 254         /* Get the address of _etext for checking non-probable text symbol */
 255         etext_addr = kernel_get_symbol_address_by_name("_etext", false);
 256
 257         if (etext_addr != 0 && etext_addr < address)
 258                 pr_warning("%s is out of .text, skip it.\n", symbol);
 259         else if (kprobe_blacklist__listed(address))
 260                 pr_warning("%s is blacklisted function, skip it.\n", symbol);
 261         else
 262                 return false;
 263
 264         return true;
 265 }
 266
 267 #ifdef HAVE_DWARF_SUPPORT
 268
 269 static int kernel_get_module_dso(const char *module, struct dso **pdso)
 270 {
 271         struct dso *dso;
 272         struct map *map;
 273         const char *vmlinux_name;
 274         int ret = 0;
 275
 276         if (module) {
 277                 list_for_each_entry(dso, &host_machine->dsos.head, node) {
 278                         if (!dso->kernel)
 279                                 continue;
 280                         if (strncmp(dso->short_name + 1, module,
 281                                     dso->short_name_len - 2) == 0)
 282                                 goto found;
 283                 }
 284                 pr_debug("Failed to find module %s.\n", module);
 285                 return -ENOENT;
 286         }
 287
 288         map = host_machine->vmlinux_maps[MAP__FUNCTION];
 289         dso = map->dso;
 290
 291         vmlinux_name = symbol_conf.vmlinux_name;
 292         dso->load_errno = 0;
 293         if (vmlinux_name)
 294                 ret = dso__load_vmlinux(dso, map, vmlinux_name, false, NULL);
 295         else
 296                 ret = dso__load_vmlinux_path(dso, map, NULL);
 297 found:
 298         *pdso = dso;
 299         return ret;
 300 }
 301
 302 /*
 303  * Some binaries like glibc have special symbols which are on the symbol
 304  * table, but not in the debuginfo. If we can find the address of the
 305  * symbol from map, we can translate the address back to the probe point.
 306  */
 307 static int find_alternative_probe_point(struct debuginfo *dinfo,
 308                                         struct perf_probe_point *pp,
 309                                         struct perf_probe_point *result,
 310                                         const char *target, bool uprobes)
 311 {
 312         struct map *map = NULL;
 313         struct symbol *sym;
 314         u64 address = 0;
 315         int ret = -ENOENT;
 316
 317         /* This can work only for function-name based one */
 318         if (!pp->function || pp->file)
 319                 return -ENOTSUP;
 320
 321         map = get_target_map(target, uprobes);
 322         if (!map)
 323                 return -EINVAL;
 324
 325         /* Find the address of given function */
 326         map__for_each_symbol_by_name(map, pp->function, sym) {
 327                 if (uprobes)
 328                         address = sym->start;
 329                 else
 330                         address = map->unmap_ip(map, sym->start);
 331                 break;
 332         }
 333         if (!address) {
 334                 ret = -ENOENT;
 335                 goto out;
 336         }
 337         pr_debug("Symbol %s address found : %" PRIx64 "\n",
 338                         pp->function, address);
 339
 340         ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
 341                                           result);
 342         if (ret <= 0)
 343                 ret = (!ret) ? -ENOENT : ret;
 344         else {
 345                 result->offset += pp->offset;
 346                 result->line += pp->line;
 347                 result->retprobe = pp->retprobe;
 348                 ret = 0;
 349         }
 350
 351 out:
 352         put_target_map(map, uprobes);
 353         return ret;
 354
 355 }
 356
 357 static int get_alternative_probe_event(struct debuginfo *dinfo,
 358                                        struct perf_probe_event *pev,
 359                                        struct perf_probe_point *tmp)
 360 {
 361         int ret;
 362
 363         memcpy(tmp, &pev->point, sizeof(*tmp));
 364         memset(&pev->point, 0, sizeof(pev->point));
 365         ret = find_alternative_probe_point(dinfo, tmp, &pev->point,
 366                                            pev->target, pev->uprobes);
 367         if (ret < 0)
 368                 memcpy(&pev->point, tmp, sizeof(*tmp));
 369
 370         return ret;
 371 }
 372
 373 static int get_alternative_line_range(struct debuginfo *dinfo,
 374                                       struct line_range *lr,
 375                                       const char *target, bool user)
 376 {
 377         struct perf_probe_point pp = { .function = lr->function,
 378                                        .file = lr->file,
 379                                        .line = lr->start };
 380         struct perf_probe_point result;
 381         int ret, len = 0;
 382
 383         memset(&result, 0, sizeof(result));
 384
 385         if (lr->end != INT_MAX)
 386                 len = lr->end - lr->start;
 387         ret = find_alternative_probe_point(dinfo, &pp, &result,
 388                                            target, user);
 389         if (!ret) {
 390                 lr->function = result.function;
 391                 lr->file = result.file;
 392                 lr->start = result.line;
 393                 if (lr->end != INT_MAX)
 394                         lr->end = lr->start + len;
 395                 clear_perf_probe_point(&pp);
 396         }
 397         return ret;
 398 }
 399
 400 /* Open new debuginfo of given module */
 401 static struct debuginfo *open_debuginfo(const char *module, bool silent)
 402 {
 403         const char *path = module;
 404         char reason[STRERR_BUFSIZE];
 405         struct debuginfo *ret = NULL;
 406         struct dso *dso = NULL;
 407         int err;
 408
 409         if (!module || !strchr(module, '/')) {
 410                 err = kernel_get_module_dso(module, &dso);
 411                 if (err < 0) {
 412                         if (!dso || dso->load_errno == 0) {
 413                                 if (!strerror_r(-err, reason, STRERR_BUFSIZE))
 414                                         strcpy(reason, "(unknown)");
 415                         } else
 416                                 dso__strerror_load(dso, reason, STRERR_BUFSIZE);
 417                         if (!silent)
 418                                 pr_err("Failed to find the path for %s: %s\n",
 419                                         module ?: "kernel", reason);
 420                         return NULL;
 421                 }
 422                 path = dso->long_name;
 423         }
 424         ret = debuginfo__new(path);
 425         if (!ret && !silent) {
 426                 pr_warning("The %s file has no debug information.\n", path);
 427                 if (!module || !strtailcmp(path, ".ko"))
 428                         pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
 429                 else
 430                         pr_warning("Rebuild with -g, ");
 431                 pr_warning("or install an appropriate debuginfo package.\n");
 432         }
 433         return ret;
 434 }
 435
 436 /* For caching the last debuginfo */
 437 static struct debuginfo *debuginfo_cache;
 438 static char *debuginfo_cache_path;
 439
 440 static struct debuginfo *debuginfo_cache__open(const char *module, bool silent)
 441 {
 442         if ((debuginfo_cache_path && !strcmp(debuginfo_cache_path, module)) ||
 443             (!debuginfo_cache_path && !module && debuginfo_cache))
 444                 goto out;
 445
 446         /* Copy module path */
 447         free(debuginfo_cache_path);
 448         if (module) {
 449                 debuginfo_cache_path = strdup(module);
 450                 if (!debuginfo_cache_path) {
 451                         debuginfo__delete(debuginfo_cache);
 452                         debuginfo_cache = NULL;
 453                         goto out;
 454                 }
 455         }
 456
 457         debuginfo_cache = open_debuginfo(module, silent);
 458         if (!debuginfo_cache)
 459                 zfree(&debuginfo_cache_path);
 460 out:
 461         return debuginfo_cache;
 462 }
 463
 464 static void debuginfo_cache__exit(void)
 465 {
 466         debuginfo__delete(debuginfo_cache);
 467         debuginfo_cache = NULL;
 468         zfree(&debuginfo_cache_path);
 469 }
 470
 471
 472 static int get_text_start_address(const char *exec, unsigned long *address)
 473 {
 474         Elf *elf;
 475         GElf_Ehdr ehdr;
 476         GElf_Shdr shdr;
 477         int fd, ret = -ENOENT;
 478
 479         fd = open(exec, O_RDONLY);
 480         if (fd < 0)
 481                 return -errno;
 482
 483         elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 484         if (elf == NULL)
 485                 return -EINVAL;
 486
 487         if (gelf_getehdr(elf, &ehdr) == NULL)
 488                 goto out;
 489
 490         if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
 491                 goto out;
 492
 493         *address = shdr.sh_addr - shdr.sh_offset;
 494         ret = 0;
 495 out:
 496         elf_end(elf);
 497         return ret;
 498 }
 499
 500 /*
 501  * Convert trace point to probe point with debuginfo
 502  */
 503 static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
 504                                             struct perf_probe_point *pp,
 505                                             bool is_kprobe)
 506 {
 507         struct debuginfo *dinfo = NULL;
 508         unsigned long stext = 0;
 509         u64 addr = tp->address;
 510         int ret = -ENOENT;
 511
 512         /* convert the address to dwarf address */
 513         if (!is_kprobe) {
 514                 if (!addr) {
 515                         ret = -EINVAL;
 516                         goto error;
 517                 }
 518                 ret = get_text_start_address(tp->module, &stext);
 519                 if (ret < 0)
 520                         goto error;
 521                 addr += stext;
 522         } else {
 523                 addr = kernel_get_symbol_address_by_name(tp->symbol, false);
 524                 if (addr == 0)
 525                         goto error;
 526                 addr += tp->offset;
 527         }
 528
 529         pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
 530                  tp->module ? : "kernel");
 531
 532         dinfo = debuginfo_cache__open(tp->module, verbose == 0);
 533         if (dinfo)
 534                 ret = debuginfo__find_probe_point(dinfo,
 535                                                  (unsigned long)addr, pp);
 536         else
 537                 ret = -ENOENT;
 538
 539         if (ret > 0) {
 540                 pp->retprobe = tp->retprobe;
 541                 return 0;
 542         }
 543 error:
 544         pr_debug("Failed to find corresponding probes from debuginfo.\n");
 545         return ret ? : -ENOENT;
 546 }
 547
 548 static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
 549                                           int ntevs, const char *exec)
 550 {
 551         int i, ret = 0;
 552         unsigned long stext = 0;
 553
 554         if (!exec)
 555                 return 0;
 556
 557         ret = get_text_start_address(exec, &stext);
 558         if (ret < 0)
 559                 return ret;
 560
 561         for (i = 0; i < ntevs && ret >= 0; i++) {
 562                 /* point.address is the addres of point.symbol + point.offset */
 563                 tevs[i].point.address -= stext;
 564                 tevs[i].point.module = strdup(exec);
 565                 if (!tevs[i].point.module) {
 566                         ret = -ENOMEM;
 567                         break;
 568                 }
 569                 tevs[i].uprobes = true;
 570         }
 571
 572         return ret;
 573 }
 574
 575 static int add_module_to_probe_trace_events(struct probe_trace_event *tevs,
 576                                             int ntevs, const char *module)
 577 {
 578         int i, ret = 0;
 579         char *tmp;
 580
 581         if (!module)
 582                 return 0;
 583
 584         tmp = strrchr(module, '/');
 585         if (tmp) {
 586                 /* This is a module path -- get the module name */
 587                 module = strdup(tmp + 1);
 588                 if (!module)
 589                         return -ENOMEM;
 590                 tmp = strchr(module, '.');
 591                 if (tmp)
 592                         *tmp = '\0';
 593                 tmp = (char *)module;   /* For free() */
 594         }
 595
 596         for (i = 0; i < ntevs; i++) {
 597                 tevs[i].point.module = strdup(module);
 598                 if (!tevs[i].point.module) {
 599                         ret = -ENOMEM;
 600                         break;
 601                 }
 602         }
 603
 604         free(tmp);
 605         return ret;
 606 }
 607
 608 /* Post processing the probe events */
 609 static int post_process_probe_trace_events(struct probe_trace_event *tevs,
 610                                            int ntevs, const char *module,
 611                                            bool uprobe)
 612 {
 613         struct ref_reloc_sym *reloc_sym;
 614         char *tmp;
 615         int i, skipped = 0;
 616
 617         if (uprobe)
 618                 return add_exec_to_probe_trace_events(tevs, ntevs, module);
 619
 620         /* Note that currently ref_reloc_sym based probe is not for drivers */
 621         if (module)
 622                 return add_module_to_probe_trace_events(tevs, ntevs, module);
 623
 624         reloc_sym = kernel_get_ref_reloc_sym();
 625         if (!reloc_sym) {
 626                 pr_warning("Relocated base symbol is not found!\n");
 627                 return -EINVAL;
 628         }
 629
 630         for (i = 0; i < ntevs; i++) {
 631                 if (!tevs[i].point.address || tevs[i].point.retprobe)
 632                         continue;
 633                 /* If we found a wrong one, mark it by NULL symbol */
 634                 if (kprobe_warn_out_range(tevs[i].point.symbol,
 635                                           tevs[i].point.address)) {
 636                         tmp = NULL;
 637                         skipped++;
 638                 } else {
 639                         tmp = strdup(reloc_sym->name);
 640                         if (!tmp)
 641                                 return -ENOMEM;
 642                 }
 643                 /* If we have no realname, use symbol for it */
 644                 if (!tevs[i].point.realname)
 645                         tevs[i].point.realname = tevs[i].point.symbol;
 646                 else
 647                         free(tevs[i].point.symbol);
 648                 tevs[i].point.symbol = tmp;
 649                 tevs[i].point.offset = tevs[i].point.address -
 650                                        reloc_sym->unrelocated_addr;
 651         }
 652         return skipped;
 653 }
 654
 655 /* Try to find perf_probe_event with debuginfo */
 656 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 657                                           struct probe_trace_event **tevs)
 658 {
 659         bool need_dwarf = perf_probe_event_need_dwarf(pev);
 660         struct perf_probe_point tmp;
 661         struct debuginfo *dinfo;
 662         int ntevs, ret = 0;
 663
 664         dinfo = open_debuginfo(pev->target, !need_dwarf);
 665         if (!dinfo) {
 666                 if (need_dwarf)
 667                         return -ENOENT;
 668                 pr_debug("Could not open debuginfo. Try to use symbols.\n");
 669                 return 0;
 670         }
 671
 672         pr_debug("Try to find probe point from debuginfo.\n");
 673         /* Searching trace events corresponding to a probe event */
 674         ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
 675
 676         if (ntevs == 0) {  /* Not found, retry with an alternative */
 677                 ret = get_alternative_probe_event(dinfo, pev, &tmp);
 678                 if (!ret) {
 679                         ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
 680                         /*
 681                          * Write back to the original probe_event for
 682                          * setting appropriate (user given) event name
 683                          */
 684                         clear_perf_probe_point(&pev->point);
 685                         memcpy(&pev->point, &tmp, sizeof(tmp));
 686                 }
 687         }
 688
 689         debuginfo__delete(dinfo);
 690
 691         if (ntevs > 0) {        /* Succeeded to find trace events */
 692                 pr_debug("Found %d probe_trace_events.\n", ntevs);
 693                 ret = post_process_probe_trace_events(*tevs, ntevs,
 694                                                 pev->target, pev->uprobes);
 695                 if (ret < 0 || ret == ntevs) {
 696                         clear_probe_trace_events(*tevs, ntevs);
 697                         zfree(tevs);
 698                 }
 699                 if (ret != ntevs)
 700                         return ret < 0 ? ret : ntevs;
 701                 ntevs = 0;
 702                 /* Fall through */
 703         }
 704
 705         if (ntevs == 0) {       /* No error but failed to find probe point. */
 706                 pr_warning("Probe point '%s' not found.\n",
 707                            synthesize_perf_probe_point(&pev->point));
 708                 return -ENOENT;
 709         }
 710         /* Error path : ntevs < 0 */
 711         pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
 712         if (ntevs == -EBADF) {
 713                 pr_warning("Warning: No dwarf info found in the vmlinux - "
 714                         "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
 715                 if (!need_dwarf) {
 716                         pr_debug("Trying to use symbols.\n");
 717                         return 0;
 718                 }
 719         }
 720         return ntevs;
 721 }
 722
 723 #define LINEBUF_SIZE 256
 724 #define NR_ADDITIONAL_LINES 2
 725
 726 static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
 727 {
 728         char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
 729         const char *color = show_num ? "" : PERF_COLOR_BLUE;
 730         const char *prefix = NULL;
 731
 732         do {
 733                 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
 734                         goto error;
 735                 if (skip)
 736                         continue;
 737                 if (!prefix) {
 738                         prefix = show_num ? "%7d  " : "         ";
 739                         color_fprintf(stdout, color, prefix, l);
 740                 }
 741                 color_fprintf(stdout, color, "%s", buf);
 742
 743         } while (strchr(buf, '\n') == NULL);
 744
 745         return 1;
 746 error:
 747         if (ferror(fp)) {
 748                 pr_warning("File read error: %s\n",
 749                            strerror_r(errno, sbuf, sizeof(sbuf)));
 750                 return -1;
 751         }
 752         return 0;
 753 }
 754
 755 static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
 756 {
 757         int rv = __show_one_line(fp, l, skip, show_num);
 758         if (rv == 0) {
 759                 pr_warning("Source file is shorter than expected.\n");
 760                 rv = -1;
 761         }
 762         return rv;
 763 }
 764
 765 #define show_one_line_with_num(f,l)     _show_one_line(f,l,false,true)
 766 #define show_one_line(f,l)              _show_one_line(f,l,false,false)
 767 #define skip_one_line(f,l)              _show_one_line(f,l,true,false)
 768 #define show_one_line_or_eof(f,l)       __show_one_line(f,l,false,false)
 769
 770 /*
 771  * Show line-range always requires debuginfo to find source file and
 772  * line number.
 773  */
 774 static int __show_line_range(struct line_range *lr, const char *module,
 775                              bool user)
 776 {
 777         int l = 1;
 778         struct int_node *ln;
 779         struct debuginfo *dinfo;
 780         FILE *fp;
 781         int ret;
 782         char *tmp;
 783         char sbuf[STRERR_BUFSIZE];
 784
 785         /* Search a line range */
 786         dinfo = open_debuginfo(module, false);
 787         if (!dinfo)
 788                 return -ENOENT;
 789
 790         ret = debuginfo__find_line_range(dinfo, lr);
 791         if (!ret) {     /* Not found, retry with an alternative */
 792                 ret = get_alternative_line_range(dinfo, lr, module, user);
 793                 if (!ret)
 794                         ret = debuginfo__find_line_range(dinfo, lr);
 795         }
 796         debuginfo__delete(dinfo);
 797         if (ret == 0 || ret == -ENOENT) {
 798                 pr_warning("Specified source line is not found.\n");
 799                 return -ENOENT;
 800         } else if (ret < 0) {
 801                 pr_warning("Debuginfo analysis failed.\n");
 802                 return ret;
 803         }
 804
 805         /* Convert source file path */
 806         tmp = lr->path;
 807         ret = get_real_path(tmp, lr->comp_dir, &lr->path);
 808
 809         /* Free old path when new path is assigned */
 810         if (tmp != lr->path)
 811                 free(tmp);
 812
 813         if (ret < 0) {
 814                 pr_warning("Failed to find source file path.\n");
 815                 return ret;
 816         }
 817
 818         setup_pager();
 819
 820         if (lr->function)
 821                 fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
 822                         lr->start - lr->offset);
 823         else
 824                 fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
 825
 826         fp = fopen(lr->path, "r");
 827         if (fp == NULL) {
 828                 pr_warning("Failed to open %s: %s\n", lr->path,
 829                            strerror_r(errno, sbuf, sizeof(sbuf)));
 830                 return -errno;
 831         }
 832         /* Skip to starting line number */
 833         while (l < lr->start) {
 834                 ret = skip_one_line(fp, l++);
 835                 if (ret < 0)
 836                         goto end;
 837         }
 838
 839         intlist__for_each(ln, lr->line_list) {
 840                 for (; ln->i > l; l++) {
 841                         ret = show_one_line(fp, l - lr->offset);
 842                         if (ret < 0)
 843                                 goto end;
 844                 }
 845                 ret = show_one_line_with_num(fp, l++ - lr->offset);
 846                 if (ret < 0)
 847                         goto end;
 848         }
 849
 850         if (lr->end == INT_MAX)
 851                 lr->end = l + NR_ADDITIONAL_LINES;
 852         while (l <= lr->end) {
 853                 ret = show_one_line_or_eof(fp, l++ - lr->offset);
 854                 if (ret <= 0)
 855                         break;
 856         }
 857 end:
 858         fclose(fp);
 859         return ret;
 860 }
 861
 862 int show_line_range(struct line_range *lr, const char *module, bool user)
 863 {
 864         int ret;
 865
 866         ret = init_symbol_maps(user);
 867         if (ret < 0)
 868                 return ret;
 869         ret = __show_line_range(lr, module, user);
 870         exit_symbol_maps();
 871
 872         return ret;
 873 }
 874
 875 static int show_available_vars_at(struct debuginfo *dinfo,
 876                                   struct perf_probe_event *pev,
 877                                   struct strfilter *_filter)
 878 {
 879         char *buf;
 880         int ret, i, nvars;
 881         struct str_node *node;
 882         struct variable_list *vls = NULL, *vl;
 883         struct perf_probe_point tmp;
 884         const char *var;
 885
 886         buf = synthesize_perf_probe_point(&pev->point);
 887         if (!buf)
 888                 return -EINVAL;
 889         pr_debug("Searching variables at %s\n", buf);
 890
 891         ret = debuginfo__find_available_vars_at(dinfo, pev, &vls);
 892         if (!ret) {  /* Not found, retry with an alternative */
 893                 ret = get_alternative_probe_event(dinfo, pev, &tmp);
 894                 if (!ret) {
 895                         ret = debuginfo__find_available_vars_at(dinfo, pev,
 896                                                                 &vls);
 897                         /* Release the old probe_point */
 898                         clear_perf_probe_point(&tmp);
 899                 }
 900         }
 901         if (ret <= 0) {
 902                 if (ret == 0 || ret == -ENOENT) {
 903                         pr_err("Failed to find the address of %s\n", buf);
 904                         ret = -ENOENT;
 905                 } else
 906                         pr_warning("Debuginfo analysis failed.\n");
 907                 goto end;
 908         }
 909
 910         /* Some variables are found */
 911         fprintf(stdout, "Available variables at %s\n", buf);
 912         for (i = 0; i < ret; i++) {
 913                 vl = &vls[i];
 914                 /*
 915                  * A probe point might be converted to
 916                  * several trace points.
 917                  */
 918                 fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
 919                         vl->point.offset);
 920                 zfree(&vl->point.symbol);
 921                 nvars = 0;
 922                 if (vl->vars) {
 923                         strlist__for_each(node, vl->vars) {
 924                                 var = strchr(node->s, '\t') + 1;
 925                                 if (strfilter__compare(_filter, var)) {
 926                                         fprintf(stdout, "\t\t%s\n", node->s);
 927                                         nvars++;
 928                                 }
 929                         }
 930                         strlist__delete(vl->vars);
 931                 }
 932                 if (nvars == 0)
 933                         fprintf(stdout, "\t\t(No matched variables)\n");
 934         }
 935         free(vls);
 936 end:
 937         free(buf);
 938         return ret;
 939 }
 940
 941 /* Show available variables on given probe point */
 942 int show_available_vars(struct perf_probe_event *pevs, int npevs,
 943                         struct strfilter *_filter)
 944 {
 945         int i, ret = 0;
 946         struct debuginfo *dinfo;
 947
 948         ret = init_symbol_maps(pevs->uprobes);
 949         if (ret < 0)
 950                 return ret;
 951
 952         dinfo = open_debuginfo(pevs->target, false);
 953         if (!dinfo) {
 954                 ret = -ENOENT;
 955                 goto out;
 956         }
 957
 958         setup_pager();
 959
 960         for (i = 0; i < npevs && ret >= 0; i++)
 961                 ret = show_available_vars_at(dinfo, &pevs[i], _filter);
 962
 963         debuginfo__delete(dinfo);
 964 out:
 965         exit_symbol_maps();
 966         return ret;
 967 }
 968
 969 #else   /* !HAVE_DWARF_SUPPORT */
 970
 971 static void debuginfo_cache__exit(void)
 972 {
 973 }
 974
 975 static int
 976 find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
 977                                  struct perf_probe_point *pp __maybe_unused,
 978                                  bool is_kprobe __maybe_unused)
 979 {
 980         return -ENOSYS;
 981 }
 982
 983 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 984                                 struct probe_trace_event **tevs __maybe_unused)
 985 {
 986         if (perf_probe_event_need_dwarf(pev)) {
 987                 pr_warning("Debuginfo-analysis is not supported.\n");
 988                 return -ENOSYS;
 989         }
 990
 991         return 0;
 992 }
 993
 994 int show_line_range(struct line_range *lr __maybe_unused,
 995                     const char *module __maybe_unused,
 996                     bool user __maybe_unused)
 997 {
 998         pr_warning("Debuginfo-analysis is not supported.\n");
 999         return -ENOSYS;
1000 }
1001
1002 int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
1003                         int npevs __maybe_unused,
1004                         struct strfilter *filter __maybe_unused)
1005 {
1006         pr_warning("Debuginfo-analysis is not supported.\n");
1007         return -ENOSYS;
1008 }
1009 #endif
1010
1011 void line_range__clear(struct line_range *lr)
1012 {
1013         free(lr->function);
1014         free(lr->file);
1015         free(lr->path);
1016         free(lr->comp_dir);
1017         intlist__delete(lr->line_list);
1018         memset(lr, 0, sizeof(*lr));
1019 }
1020
1021 int line_range__init(struct line_range *lr)
1022 {
1023         memset(lr, 0, sizeof(*lr));
1024         lr->line_list = intlist__new(NULL);
1025         if (!lr->line_list)
1026                 return -ENOMEM;
1027         else
1028                 return 0;
1029 }
1030
1031 static int parse_line_num(char **ptr, int *val, const char *what)
1032 {
1033         const char *start = *ptr;
1034
1035         errno = 0;
1036         *val = strtol(*ptr, ptr, 0);
1037         if (errno || *ptr == start) {
1038                 semantic_error("'%s' is not a valid number.\n", what);
1039                 return -EINVAL;
1040         }
1041         return 0;
1042 }
1043
1044 /* Check the name is good for event, group or function */
1045 static bool is_c_func_name(const char *name)
1046 {
1047         if (!isalpha(*name) && *name != '_')
1048                 return false;
1049         while (*++name != '\0') {
1050                 if (!isalpha(*name) && !isdigit(*name) && *name != '_')
1051                         return false;
1052         }
1053         return true;
1054 }
1055
1056 /*
1057  * Stuff 'lr' according to the line range described by 'arg'.
1058  * The line range syntax is described by:
1059  *
1060  *         SRC[:SLN[+NUM|-ELN]]
1061  *         FNC[@SRC][:SLN[+NUM|-ELN]]
1062  */
1063 int parse_line_range_desc(const char *arg, struct line_range *lr)
1064 {
1065         char *range, *file, *name = strdup(arg);
1066         int err;
1067
1068         if (!name)
1069                 return -ENOMEM;
1070
1071         lr->start = 0;
1072         lr->end = INT_MAX;
1073
1074         range = strchr(name, ':');
1075         if (range) {
1076                 *range++ = '\0';
1077
1078                 err = parse_line_num(&range, &lr->start, "start line");
1079                 if (err)
1080                         goto err;
1081
1082                 if (*range == '+' || *range == '-') {
1083                         const char c = *range++;
1084
1085                         err = parse_line_num(&range, &lr->end, "end line");
1086                         if (err)
1087                                 goto err;
1088
1089                         if (c == '+') {
1090                                 lr->end += lr->start;
1091                                 /*
1092                                  * Adjust the number of lines here.
1093                                  * If the number of lines == 1, the
1094                                  * the end of line should be equal to
1095                                  * the start of line.
1096                                  */
1097                                 lr->end--;
1098                         }
1099                 }
1100
1101                 pr_debug("Line range is %d to %d\n", lr->start, lr->end);
1102
1103                 err = -EINVAL;
1104                 if (lr->start > lr->end) {
1105                         semantic_error("Start line must be smaller"
1106                                        " than end line.\n");
1107                         goto err;
1108                 }
1109                 if (*range != '\0') {
1110                         semantic_error("Tailing with invalid str '%s'.\n", range);
1111                         goto err;
1112                 }
1113         }
1114
1115         file = strchr(name, '@');
1116         if (file) {
1117                 *file = '\0';
1118                 lr->file = strdup(++file);
1119                 if (lr->file == NULL) {
1120                         err = -ENOMEM;
1121                         goto err;
1122                 }
1123                 lr->function = name;
1124         } else if (strchr(name, '/') || strchr(name, '.'))
1125                 lr->file = name;
1126         else if (is_c_func_name(name))/* We reuse it for checking funcname */
1127                 lr->function = name;
1128         else {  /* Invalid name */
1129                 semantic_error("'%s' is not a valid function name.\n", name);
1130                 err = -EINVAL;
1131                 goto err;
1132         }
1133
1134         return 0;
1135 err:
1136         free(name);
1137         return err;
1138 }
1139
1140 /* Parse probepoint definition. */
1141 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
1142 {
1143         struct perf_probe_point *pp = &pev->point;
1144         char *ptr, *tmp;
1145         char c, nc = 0;
1146         bool file_spec = false;
1147         /*
1148          * <Syntax>
1149          * perf probe [EVENT=]SRC[:LN|;PTN]
1150          * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
1151          *
1152          * TODO:Group name support
1153          */
1154         if (!arg)
1155                 return -EINVAL;
1156
1157         ptr = strpbrk(arg, ";=@+%");
1158         if (ptr && *ptr == '=') {       /* Event name */
1159                 *ptr = '\0';
1160                 tmp = ptr + 1;
1161                 if (strchr(arg, ':')) {
1162                         semantic_error("Group name is not supported yet.\n");
1163                         return -ENOTSUP;
1164                 }
1165                 if (!is_c_func_name(arg)) {
1166                         semantic_error("%s is bad for event name -it must "
1167                                        "follow C symbol-naming rule.\n", arg);
1168                         return -EINVAL;
1169                 }
1170                 pev->event = strdup(arg);
1171                 if (pev->event == NULL)
1172                         return -ENOMEM;
1173                 pev->group = NULL;
1174                 arg = tmp;
1175         }
1176
1177         /*
1178          * Check arg is function or file name and copy it.
1179          *
1180          * We consider arg to be a file spec if and only if it satisfies
1181          * all of the below criteria::
1182          * - it does not include any of "+@%",
1183          * - it includes one of ":;", and
1184          * - it has a period '.' in the name.
1185          *
1186          * Otherwise, we consider arg to be a function specification.
1187          */
1188         if (!strpbrk(arg, "+@%") && (ptr = strpbrk(arg, ";:")) != NULL) {
1189                 /* This is a file spec if it includes a '.' before ; or : */
1190                 if (memchr(arg, '.', ptr - arg))
1191                         file_spec = true;
1192         }
1193
1194         ptr = strpbrk(arg, ";:+@%");
1195         if (ptr) {
1196                 nc = *ptr;
1197                 *ptr++ = '\0';
1198         }
1199
1200         tmp = strdup(arg);
1201         if (tmp == NULL)
1202                 return -ENOMEM;
1203
1204         if (file_spec)
1205                 pp->file = tmp;
1206         else
1207                 pp->function = tmp;
1208
1209         /* Parse other options */
1210         while (ptr) {
1211                 arg = ptr;
1212                 c = nc;
1213                 if (c == ';') { /* Lazy pattern must be the last part */
1214                         pp->lazy_line = strdup(arg);
1215                         if (pp->lazy_line == NULL)
1216                                 return -ENOMEM;
1217                         break;
1218                 }
1219                 ptr = strpbrk(arg, ";:+@%");
1220                 if (ptr) {
1221                         nc = *ptr;
1222                         *ptr++ = '\0';
1223                 }
1224                 switch (c) {
1225                 case ':':       /* Line number */
1226                         pp->line = strtoul(arg, &tmp, 0);
1227                         if (*tmp != '\0') {
1228                                 semantic_error("There is non-digit char"
1229                                                " in line number.\n");
1230                                 return -EINVAL;
1231                         }
1232                         break;
1233                 case '+':       /* Byte offset from a symbol */
1234                         pp->offset = strtoul(arg, &tmp, 0);
1235                         if (*tmp != '\0') {
1236                                 semantic_error("There is non-digit character"
1237                                                 " in offset.\n");
1238                                 return -EINVAL;
1239                         }
1240                         break;
1241                 case '@':       /* File name */
1242                         if (pp->file) {
1243                                 semantic_error("SRC@SRC is not allowed.\n");
1244                                 return -EINVAL;
1245                         }
1246                         pp->file = strdup(arg);
1247                         if (pp->file == NULL)
1248                                 return -ENOMEM;
1249                         break;
1250                 case '%':       /* Probe places */
1251                         if (strcmp(arg, "return") == 0) {
1252                                 pp->retprobe = 1;
1253                         } else {        /* Others not supported yet */
1254                                 semantic_error("%%%s is not supported.\n", arg);
1255                                 return -ENOTSUP;
1256                         }
1257                         break;
1258                 default:        /* Buggy case */
1259                         pr_err("This program has a bug at %s:%d.\n",
1260                                 __FILE__, __LINE__);
1261                         return -ENOTSUP;
1262                         break;
1263                 }
1264         }
1265
1266         /* Exclusion check */
1267         if (pp->lazy_line && pp->line) {
1268                 semantic_error("Lazy pattern can't be used with"
1269                                " line number.\n");
1270                 return -EINVAL;
1271         }
1272
1273         if (pp->lazy_line && pp->offset) {
1274                 semantic_error("Lazy pattern can't be used with offset.\n");
1275                 return -EINVAL;
1276         }
1277
1278         if (pp->line && pp->offset) {
1279                 semantic_error("Offset can't be used with line number.\n");
1280                 return -EINVAL;
1281         }
1282
1283         if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1284                 semantic_error("File always requires line number or "
1285                                "lazy pattern.\n");
1286                 return -EINVAL;
1287         }
1288
1289         if (pp->offset && !pp->function) {
1290                 semantic_error("Offset requires an entry function.\n");
1291                 return -EINVAL;
1292         }
1293
1294         if (pp->retprobe && !pp->function) {
1295                 semantic_error("Return probe requires an entry function.\n");
1296                 return -EINVAL;
1297         }
1298
1299         if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1300                 semantic_error("Offset/Line/Lazy pattern can't be used with "
1301                                "return probe.\n");
1302                 return -EINVAL;
1303         }
1304
1305         pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1306                  pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
1307                  pp->lazy_line);
1308         return 0;
1309 }
1310
1311 /* Parse perf-probe event argument */
1312 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1313 {
1314         char *tmp, *goodname;
1315         struct perf_probe_arg_field **fieldp;
1316
1317         pr_debug("parsing arg: %s into ", str);
1318
1319         tmp = strchr(str, '=');
1320         if (tmp) {
1321                 arg->name = strndup(str, tmp - str);
1322                 if (arg->name == NULL)
1323                         return -ENOMEM;
1324                 pr_debug("name:%s ", arg->name);
1325                 str = tmp + 1;
1326         }
1327
1328         tmp = strchr(str, ':');
1329         if (tmp) {      /* Type setting */
1330                 *tmp = '\0';
1331                 arg->type = strdup(tmp + 1);
1332                 if (arg->type == NULL)
1333                         return -ENOMEM;
1334                 pr_debug("type:%s ", arg->type);
1335         }
1336
1337         tmp = strpbrk(str, "-.[");
1338         if (!is_c_varname(str) || !tmp) {
1339                 /* A variable, register, symbol or special value */
1340                 arg->var = strdup(str);
1341                 if (arg->var == NULL)
1342                         return -ENOMEM;
1343                 pr_debug("%s\n", arg->var);
1344                 return 0;
1345         }
1346
1347         /* Structure fields or array element */
1348         arg->var = strndup(str, tmp - str);
1349         if (arg->var == NULL)
1350                 return -ENOMEM;
1351         goodname = arg->var;
1352         pr_debug("%s, ", arg->var);
1353         fieldp = &arg->field;
1354
1355         do {
1356                 *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
1357                 if (*fieldp == NULL)
1358                         return -ENOMEM;
1359                 if (*tmp == '[') {      /* Array */
1360                         str = tmp;
1361                         (*fieldp)->index = strtol(str + 1, &tmp, 0);
1362                         (*fieldp)->ref = true;
1363                         if (*tmp != ']' || tmp == str + 1) {
1364                                 semantic_error("Array index must be a"
1365                                                 " number.\n");
1366                                 return -EINVAL;
1367                         }
1368                         tmp++;
1369                         if (*tmp == '\0')
1370                                 tmp = NULL;
1371                 } else {                /* Structure */
1372                         if (*tmp == '.') {
1373                                 str = tmp + 1;
1374                                 (*fieldp)->ref = false;
1375                         } else if (tmp[1] == '>') {
1376                                 str = tmp + 2;
1377                                 (*fieldp)->ref = true;
1378                         } else {
1379                                 semantic_error("Argument parse error: %s\n",
1380                                                str);
1381                                 return -EINVAL;
1382                         }
1383                         tmp = strpbrk(str, "-.[");
1384                 }
1385                 if (tmp) {
1386                         (*fieldp)->name = strndup(str, tmp - str);
1387                         if ((*fieldp)->name == NULL)
1388                                 return -ENOMEM;
1389                         if (*str != '[')
1390                                 goodname = (*fieldp)->name;
1391                         pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
1392                         fieldp = &(*fieldp)->next;
1393                 }
1394         } while (tmp);
1395         (*fieldp)->name = strdup(str);
1396         if ((*fieldp)->name == NULL)
1397                 return -ENOMEM;
1398         if (*str != '[')
1399                 goodname = (*fieldp)->name;
1400         pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1401
1402         /* If no name is specified, set the last field name (not array index)*/
1403         if (!arg->name) {
1404                 arg->name = strdup(goodname);
1405                 if (arg->name == NULL)
1406                         return -ENOMEM;
1407         }
1408         return 0;
1409 }
1410
1411 /* Parse perf-probe event command */
1412 int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1413 {
1414         char **argv;
1415         int argc, i, ret = 0;
1416
1417         argv = argv_split(cmd, &argc);
1418         if (!argv) {
1419                 pr_debug("Failed to split arguments.\n");
1420                 return -ENOMEM;
1421         }
1422         if (argc - 1 > MAX_PROBE_ARGS) {
1423                 semantic_error("Too many probe arguments (%d).\n", argc - 1);
1424                 ret = -ERANGE;
1425                 goto out;
1426         }
1427         /* Parse probe point */
1428         ret = parse_perf_probe_point(argv[0], pev);
1429         if (ret < 0)
1430                 goto out;
1431
1432         /* Copy arguments and ensure return probe has no C argument */
1433         pev->nargs = argc - 1;
1434         pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1435         if (pev->args == NULL) {
1436                 ret = -ENOMEM;
1437                 goto out;
1438         }
1439         for (i = 0; i < pev->nargs && ret >= 0; i++) {
1440                 ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1441                 if (ret >= 0 &&
1442                     is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1443                         semantic_error("You can't specify local variable for"
1444                                        " kretprobe.\n");
1445                         ret = -EINVAL;
1446                 }
1447         }
1448 out:
1449         argv_free(argv);
1450
1451         return ret;
1452 }
1453
1454 /* Return true if this perf_probe_event requires debuginfo */
1455 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
1456 {
1457         int i;
1458
1459         if (pev->point.file || pev->point.line || pev->point.lazy_line)
1460                 return true;
1461
1462         for (i = 0; i < pev->nargs; i++)
1463                 if (is_c_varname(pev->args[i].var))
1464                         return true;
1465
1466         return false;
1467 }
1468
1469 /* Parse probe_events event into struct probe_point */
1470 static int parse_probe_trace_command(const char *cmd,
1471                                      struct probe_trace_event *tev)
1472 {
1473         struct probe_trace_point *tp = &tev->point;
1474         char pr;
1475         char *p;
1476         char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1477         int ret, i, argc;
1478         char **argv;
1479
1480         pr_debug("Parsing probe_events: %s\n", cmd);
1481         argv = argv_split(cmd, &argc);
1482         if (!argv) {
1483                 pr_debug("Failed to split arguments.\n");
1484                 return -ENOMEM;
1485         }
1486         if (argc < 2) {
1487                 semantic_error("Too few probe arguments.\n");
1488                 ret = -ERANGE;
1489                 goto out;
1490         }
1491
1492         /* Scan event and group name. */
1493         argv0_str = strdup(argv[0]);
1494         if (argv0_str == NULL) {
1495                 ret = -ENOMEM;
1496                 goto out;
1497         }
1498         fmt1_str = strtok_r(argv0_str, ":", &fmt);
1499         fmt2_str = strtok_r(NULL, "/", &fmt);
1500         fmt3_str = strtok_r(NULL, " \t", &fmt);
1501         if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
1502             || fmt3_str == NULL) {
1503                 semantic_error("Failed to parse event name: %s\n", argv[0]);
1504                 ret = -EINVAL;
1505                 goto out;
1506         }
1507         pr = fmt1_str[0];
1508         tev->group = strdup(fmt2_str);
1509         tev->event = strdup(fmt3_str);
1510         if (tev->group == NULL || tev->event == NULL) {
1511                 ret = -ENOMEM;
1512                 goto out;
1513         }
1514         pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1515
1516         tp->retprobe = (pr == 'r');
1517
1518         /* Scan module name(if there), function name and offset */
1519         p = strchr(argv[1], ':');
1520         if (p) {
1521                 tp->module = strndup(argv[1], p - argv[1]);
1522                 p++;
1523         } else
1524                 p = argv[1];
1525         fmt1_str = strtok_r(p, "+", &fmt);
1526         if (fmt1_str[0] == '0') /* only the address started with 0x */
1527                 tp->address = strtoul(fmt1_str, NULL, 0);
1528         else {
1529                 /* Only the symbol-based probe has offset */
1530                 tp->symbol = strdup(fmt1_str);
1531                 if (tp->symbol == NULL) {
1532                         ret = -ENOMEM;
1533                         goto out;
1534                 }
1535                 fmt2_str = strtok_r(NULL, "", &fmt);
1536                 if (fmt2_str == NULL)
1537                         tp->offset = 0;
1538                 else
1539                         tp->offset = strtoul(fmt2_str, NULL, 10);
1540         }
1541
1542         tev->nargs = argc - 2;
1543         tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1544         if (tev->args == NULL) {
1545                 ret = -ENOMEM;
1546                 goto out;
1547         }
1548         for (i = 0; i < tev->nargs; i++) {
1549                 p = strchr(argv[i + 2], '=');
1550                 if (p)  /* We don't need which register is assigned. */
1551                         *p++ = '\0';
1552                 else
1553                         p = argv[i + 2];
1554                 tev->args[i].name = strdup(argv[i + 2]);
1555                 /* TODO: parse regs and offset */
1556                 tev->args[i].value = strdup(p);
1557                 if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
1558                         ret = -ENOMEM;
1559                         goto out;
1560                 }
1561         }
1562         ret = 0;
1563 out:
1564         free(argv0_str);
1565         argv_free(argv);
1566         return ret;
1567 }
1568
1569 /* Compose only probe arg */
1570 int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
1571 {
1572         struct perf_probe_arg_field *field = pa->field;
1573         int ret;
1574         char *tmp = buf;
1575
1576         if (pa->name && pa->var)
1577                 ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
1578         else
1579                 ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
1580         if (ret <= 0)
1581                 goto error;
1582         tmp += ret;
1583         len -= ret;
1584
1585         while (field) {
1586                 if (field->name[0] == '[')
1587                         ret = e_snprintf(tmp, len, "%s", field->name);
1588                 else
1589                         ret = e_snprintf(tmp, len, "%s%s",
1590                                          field->ref ? "->" : ".", field->name);
1591                 if (ret <= 0)
1592                         goto error;
1593                 tmp += ret;
1594                 len -= ret;
1595                 field = field->next;
1596         }
1597
1598         if (pa->type) {
1599                 ret = e_snprintf(tmp, len, ":%s", pa->type);
1600                 if (ret <= 0)
1601                         goto error;
1602                 tmp += ret;
1603                 len -= ret;
1604         }
1605
1606         return tmp - buf;
1607 error:
1608         pr_debug("Failed to synthesize perf probe argument: %d\n", ret);
1609         return ret;
1610 }
1611
1612 /* Compose only probe point (not argument) */
1613 static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1614 {
1615         char *buf, *tmp;
1616         char offs[32] = "", line[32] = "", file[32] = "";
1617         int ret, len;
1618
1619         buf = zalloc(MAX_CMDLEN);
1620         if (buf == NULL) {
1621                 ret = -ENOMEM;
1622                 goto error;
1623         }
1624         if (pp->offset) {
1625                 ret = e_snprintf(offs, 32, "+%lu", pp->offset);
1626                 if (ret <= 0)
1627                         goto error;
1628         }
1629         if (pp->line) {
1630                 ret = e_snprintf(line, 32, ":%d", pp->line);
1631                 if (ret <= 0)
1632                         goto error;
1633         }
1634         if (pp->file) {
1635                 tmp = pp->file;
1636                 len = strlen(tmp);
1637                 if (len > 30) {
1638                         tmp = strchr(pp->file + len - 30, '/');
1639                         tmp = tmp ? tmp + 1 : pp->file + len - 30;
1640                 }
1641                 ret = e_snprintf(file, 32, "@%s", tmp);
1642                 if (ret <= 0)
1643                         goto error;
1644         }
1645
1646         if (pp->function)
1647                 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
1648                                  offs, pp->retprobe ? "%return" : "", line,
1649                                  file);
1650         else
1651                 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
1652         if (ret <= 0)
1653                 goto error;
1654
1655         return buf;
1656 error:
1657         pr_debug("Failed to synthesize perf probe point: %d\n", ret);
1658         free(buf);
1659         return NULL;
1660 }
1661
1662 #if 0
1663 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1664 {
1665         char *buf;
1666         int i, len, ret;
1667
1668         buf = synthesize_perf_probe_point(&pev->point);
1669         if (!buf)
1670                 return NULL;
1671
1672         len = strlen(buf);
1673         for (i = 0; i < pev->nargs; i++) {
1674                 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
1675                                  pev->args[i].name);
1676                 if (ret <= 0) {
1677                         free(buf);
1678                         return NULL;
1679                 }
1680                 len += ret;
1681         }
1682
1683         return buf;
1684 }
1685 #endif
1686
1687 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1688                                              char **buf, size_t *buflen,
1689                                              int depth)
1690 {
1691         int ret;
1692         if (ref->next) {
1693                 depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1694                                                          buflen, depth + 1);
1695                 if (depth < 0)
1696                         goto out;
1697         }
1698
1699         ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
1700         if (ret < 0)
1701                 depth = ret;
1702         else {
1703                 *buf += ret;
1704                 *buflen -= ret;
1705         }
1706 out:
1707         return depth;
1708
1709 }
1710
1711 static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1712                                        char *buf, size_t buflen)
1713 {
1714         struct probe_trace_arg_ref *ref = arg->ref;
1715         int ret, depth = 0;
1716         char *tmp = buf;
1717
1718         /* Argument name or separator */
1719         if (arg->name)
1720                 ret = e_snprintf(buf, buflen, " %s=", arg->name);
1721         else
1722                 ret = e_snprintf(buf, buflen, " ");
1723         if (ret < 0)
1724                 return ret;
1725         buf += ret;
1726         buflen -= ret;
1727
1728         /* Special case: @XXX */
1729         if (arg->value[0] == '@' && arg->ref)
1730                         ref = ref->next;
1731
1732         /* Dereferencing arguments */
1733         if (ref) {
1734                 depth = __synthesize_probe_trace_arg_ref(ref, &buf,
1735                                                           &buflen, 1);
1736                 if (depth < 0)
1737                         return depth;
1738         }
1739
1740         /* Print argument value */
1741         if (arg->value[0] == '@' && arg->ref)
1742                 ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
1743                                  arg->ref->offset);
1744         else
1745                 ret = e_snprintf(buf, buflen, "%s", arg->value);
1746         if (ret < 0)
1747                 return ret;
1748         buf += ret;
1749         buflen -= ret;
1750
1751         /* Closing */
1752         while (depth--) {
1753                 ret = e_snprintf(buf, buflen, ")");
1754                 if (ret < 0)
1755                         return ret;
1756                 buf += ret;
1757                 buflen -= ret;
1758         }
1759         /* Print argument type */
1760         if (arg->type) {
1761                 ret = e_snprintf(buf, buflen, ":%s", arg->type);
1762                 if (ret <= 0)
1763                         return ret;
1764                 buf += ret;
1765         }
1766
1767         return buf - tmp;
1768 }
1769
1770 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1771 {
1772         struct probe_trace_point *tp = &tev->point;
1773         char *buf;
1774         int i, len, ret;
1775
1776         buf = zalloc(MAX_CMDLEN);
1777         if (buf == NULL)
1778                 return NULL;
1779
1780         len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
1781                          tev->group, tev->event);
1782         if (len <= 0)
1783                 goto error;
1784
1785         /* Uprobes must have tp->address and tp->module */
1786         if (tev->uprobes && (!tp->address || !tp->module))
1787                 goto error;
1788
1789         /* Use the tp->address for uprobes */
1790         if (tev->uprobes)
1791                 ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
1792                                  tp->module, tp->address);
1793         else
1794                 ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
1795                                  tp->module ?: "", tp->module ? ":" : "",
1796                                  tp->symbol, tp->offset);
1797
1798         if (ret <= 0)
1799                 goto error;
1800         len += ret;
1801
1802         for (i = 0; i < tev->nargs; i++) {
1803                 ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
1804                                                   MAX_CMDLEN - len);
1805                 if (ret <= 0)
1806                         goto error;
1807                 len += ret;
1808         }
1809
1810         return buf;
1811 error:
1812         free(buf);
1813         return NULL;
1814 }
1815
1816 static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
1817                                           struct perf_probe_point *pp,
1818                                           bool is_kprobe)
1819 {
1820         struct symbol *sym = NULL;
1821         struct map *map;
1822         u64 addr;
1823         int ret = -ENOENT;
1824
1825         if (!is_kprobe) {
1826                 map = dso__new_map(tp->module);
1827                 if (!map)
1828                         goto out;
1829                 addr = tp->address;
1830                 sym = map__find_symbol(map, addr, NULL);
1831         } else {
1832                 addr = kernel_get_symbol_address_by_name(tp->symbol, true);
1833                 if (addr) {
1834                         addr += tp->offset;
1835                         sym = __find_kernel_function(addr, &map);
1836                 }
1837         }
1838         if (!sym)
1839                 goto out;
1840
1841         pp->retprobe = tp->retprobe;
1842         pp->offset = addr - map->unmap_ip(map, sym->start);
1843         pp->function = strdup(sym->name);
1844         ret = pp->function ? 0 : -ENOMEM;
1845
1846 out:
1847         if (map && !is_kprobe) {
1848                 map__put(map);
1849         }
1850
1851         return ret;
1852 }
1853
1854 static int convert_to_perf_probe_point(struct probe_trace_point *tp,
1855                                         struct perf_probe_point *pp,
1856                                         bool is_kprobe)
1857 {
1858         char buf[128];
1859         int ret;
1860
1861         ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
1862         if (!ret)
1863                 return 0;
1864         ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
1865         if (!ret)
1866                 return 0;
1867
1868         pr_debug("Failed to find probe point from both of dwarf and map.\n");
1869
1870         if (tp->symbol) {
1871                 pp->function = strdup(tp->symbol);
1872                 pp->offset = tp->offset;
1873         } else if (!tp->module && !is_kprobe) {
1874                 ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
1875                 if (ret < 0)
1876                         return ret;
1877                 pp->function = strdup(buf);
1878                 pp->offset = 0;
1879         }
1880         if (pp->function == NULL)
1881                 return -ENOMEM;
1882
1883         pp->retprobe = tp->retprobe;
1884
1885         return 0;
1886 }
1887
1888 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1889                                struct perf_probe_event *pev, bool is_kprobe)
1890 {
1891         char buf[64] = "";
1892         int i, ret;
1893
1894         /* Convert event/group name */
1895         pev->event = strdup(tev->event);
1896         pev->group = strdup(tev->group);
1897         if (pev->event == NULL || pev->group == NULL)
1898                 return -ENOMEM;
1899
1900         /* Convert trace_point to probe_point */
1901         ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
1902         if (ret < 0)
1903                 return ret;
1904
1905         /* Convert trace_arg to probe_arg */
1906         pev->nargs = tev->nargs;
1907         pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1908         if (pev->args == NULL)
1909                 return -ENOMEM;
1910         for (i = 0; i < tev->nargs && ret >= 0; i++) {
1911                 if (tev->args[i].name)
1912                         pev->args[i].name = strdup(tev->args[i].name);
1913                 else {
1914                         ret = synthesize_probe_trace_arg(&tev->args[i],
1915                                                           buf, 64);
1916                         pev->args[i].name = strdup(buf);
1917                 }
1918                 if (pev->args[i].name == NULL && ret >= 0)
1919                         ret = -ENOMEM;
1920         }
1921
1922         if (ret < 0)
1923                 clear_perf_probe_event(pev);
1924
1925         return ret;
1926 }
1927
1928 void clear_perf_probe_event(struct perf_probe_event *pev)
1929 {
1930         struct perf_probe_arg_field *field, *next;
1931         int i;
1932
1933         free(pev->event);
1934         free(pev->group);
1935         free(pev->target);
1936         clear_perf_probe_point(&pev->point);
1937
1938         for (i = 0; i < pev->nargs; i++) {
1939                 free(pev->args[i].name);
1940                 free(pev->args[i].var);
1941                 free(pev->args[i].type);
1942                 field = pev->args[i].field;
1943                 while (field) {
1944                         next = field->next;
1945                         zfree(&field->name);
1946                         free(field);
1947                         field = next;
1948                 }
1949         }
1950         free(pev->args);
1951         memset(pev, 0, sizeof(*pev));
1952 }
1953
1954 static void clear_probe_trace_event(struct probe_trace_event *tev)
1955 {
1956         struct probe_trace_arg_ref *ref, *next;
1957         int i;
1958
1959         free(tev->event);
1960         free(tev->group);
1961         free(tev->point.symbol);
1962         free(tev->point.realname);
1963         free(tev->point.module);
1964         for (i = 0; i < tev->nargs; i++) {
1965                 free(tev->args[i].name);
1966                 free(tev->args[i].value);
1967                 free(tev->args[i].type);
1968                 ref = tev->args[i].ref;
1969                 while (ref) {
1970                         next = ref->next;
1971                         free(ref);
1972                         ref = next;
1973                 }
1974         }
1975         free(tev->args);
1976         memset(tev, 0, sizeof(*tev));
1977 }
1978
1979 static void print_open_warning(int err, bool is_kprobe)
1980 {
1981         char sbuf[STRERR_BUFSIZE];
1982
1983         if (err == -ENOENT) {
1984                 const char *config;
1985
1986                 if (!is_kprobe)
1987                         config = "CONFIG_UPROBE_EVENTS";
1988                 else
1989                         config = "CONFIG_KPROBE_EVENTS";
1990
1991                 pr_warning("%cprobe_events file does not exist"
1992                            " - please rebuild kernel with %s.\n",
1993                            is_kprobe ? 'k' : 'u', config);
1994         } else if (err == -ENOTSUP)
1995                 pr_warning("Tracefs or debugfs is not mounted.\n");
1996         else
1997                 pr_warning("Failed to open %cprobe_events: %s\n",
1998                            is_kprobe ? 'k' : 'u',
1999                            strerror_r(-err, sbuf, sizeof(sbuf)));
2000 }
2001
2002 static void print_both_open_warning(int kerr, int uerr)
2003 {
2004         /* Both kprobes and uprobes are disabled, warn it. */
2005         if (kerr == -ENOTSUP && uerr == -ENOTSUP)
2006                 pr_warning("Tracefs or debugfs is not mounted.\n");
2007         else if (kerr == -ENOENT && uerr == -ENOENT)
2008                 pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
2009                            "or/and CONFIG_UPROBE_EVENTS.\n");
2010         else {
2011                 char sbuf[STRERR_BUFSIZE];
2012                 pr_warning("Failed to open kprobe events: %s.\n",
2013                            strerror_r(-kerr, sbuf, sizeof(sbuf)));
2014                 pr_warning("Failed to open uprobe events: %s.\n",
2015                            strerror_r(-uerr, sbuf, sizeof(sbuf)));
2016         }
2017 }
2018
2019 static int open_probe_events(const char *trace_file, bool readwrite)
2020 {
2021         char buf[PATH_MAX];
2022         const char *__debugfs;
2023         const char *tracing_dir = "";
2024         int ret;
2025
2026         __debugfs = tracefs_find_mountpoint();
2027         if (__debugfs == NULL) {
2028                 tracing_dir = "tracing/";
2029
2030                 __debugfs = debugfs_find_mountpoint();
2031                 if (__debugfs == NULL)
2032                         return -ENOTSUP;
2033         }
2034
2035         ret = e_snprintf(buf, PATH_MAX, "%s/%s%s",
2036                          __debugfs, tracing_dir, trace_file);
2037         if (ret >= 0) {
2038                 pr_debug("Opening %s write=%d\n", buf, readwrite);
2039                 if (readwrite && !probe_event_dry_run)
2040                         ret = open(buf, O_RDWR | O_APPEND, 0);
2041                 else
2042                         ret = open(buf, O_RDONLY, 0);
2043
2044                 if (ret < 0)
2045                         ret = -errno;
2046         }
2047         return ret;
2048 }
2049
2050 static int open_kprobe_events(bool readwrite)
2051 {
2052         return open_probe_events("kprobe_events", readwrite);
2053 }
2054
2055 static int open_uprobe_events(bool readwrite)
2056 {
2057         return open_probe_events("uprobe_events", readwrite);
2058 }
2059
2060 /* Get raw string list of current kprobe_events  or uprobe_events */
2061 static struct strlist *get_probe_trace_command_rawlist(int fd)
2062 {
2063         int ret, idx;
2064         FILE *fp;
2065         char buf[MAX_CMDLEN];
2066         char *p;
2067         struct strlist *sl;
2068
2069         sl = strlist__new(true, NULL);
2070
2071         fp = fdopen(dup(fd), "r");
2072         while (!feof(fp)) {
2073                 p = fgets(buf, MAX_CMDLEN, fp);
2074                 if (!p)
2075                         break;
2076
2077                 idx = strlen(p) - 1;
2078                 if (p[idx] == '\n')
2079                         p[idx] = '\0';
2080                 ret = strlist__add(sl, buf);
2081                 if (ret < 0) {
2082                         pr_debug("strlist__add failed (%d)\n", ret);
2083                         strlist__delete(sl);
2084                         return NULL;
2085                 }
2086         }
2087         fclose(fp);
2088
2089         return sl;
2090 }
2091
2092 struct kprobe_blacklist_node {
2093         struct list_head list;
2094         unsigned long start;
2095         unsigned long end;
2096         char *symbol;
2097 };
2098
2099 static void kprobe_blacklist__delete(struct list_head *blacklist)
2100 {
2101         struct kprobe_blacklist_node *node;
2102
2103         while (!list_empty(blacklist)) {
2104                 node = list_first_entry(blacklist,
2105                                         struct kprobe_blacklist_node, list);
2106                 list_del(&node->list);
2107                 free(node->symbol);
2108                 free(node);
2109         }
2110 }
2111
2112 static int kprobe_blacklist__load(struct list_head *blacklist)
2113 {
2114         struct kprobe_blacklist_node *node;
2115         const char *__debugfs = debugfs_find_mountpoint();
2116         char buf[PATH_MAX], *p;
2117         FILE *fp;
2118         int ret;
2119
2120         if (__debugfs == NULL)
2121                 return -ENOTSUP;
2122
2123         ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
2124         if (ret < 0)
2125                 return ret;
2126
2127         fp = fopen(buf, "r");
2128         if (!fp)
2129                 return -errno;
2130
2131         ret = 0;
2132         while (fgets(buf, PATH_MAX, fp)) {
2133                 node = zalloc(sizeof(*node));
2134                 if (!node) {
2135                         ret = -ENOMEM;
2136                         break;
2137                 }
2138                 INIT_LIST_HEAD(&node->list);
2139                 list_add_tail(&node->list, blacklist);
2140                 if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
2141                         ret = -EINVAL;
2142                         break;
2143                 }
2144                 p = strchr(buf, '\t');
2145                 if (p) {
2146                         p++;
2147                         if (p[strlen(p) - 1] == '\n')
2148                                 p[strlen(p) - 1] = '\0';
2149                 } else
2150                         p = (char *)"unknown";
2151                 node->symbol = strdup(p);
2152                 if (!node->symbol) {
2153                         ret = -ENOMEM;
2154                         break;
2155                 }
2156                 pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
2157                           node->start, node->end, node->symbol);
2158                 ret++;
2159         }
2160         if (ret < 0)
2161                 kprobe_blacklist__delete(blacklist);
2162         fclose(fp);
2163
2164         return ret;
2165 }
2166
2167 static struct kprobe_blacklist_node *
2168 kprobe_blacklist__find_by_address(struct list_head *blacklist,
2169                                   unsigned long address)
2170 {
2171         struct kprobe_blacklist_node *node;
2172
2173         list_for_each_entry(node, blacklist, list) {
2174                 if (node->start <= address && address <= node->end)
2175                         return node;
2176         }
2177
2178         return NULL;
2179 }
2180
2181 static LIST_HEAD(kprobe_blacklist);
2182
2183 static void kprobe_blacklist__init(void)
2184 {
2185         if (!list_empty(&kprobe_blacklist))
2186                 return;
2187
2188         if (kprobe_blacklist__load(&kprobe_blacklist) < 0)
2189                 pr_debug("No kprobe blacklist support, ignored\n");
2190 }
2191
2192 static void kprobe_blacklist__release(void)
2193 {
2194         kprobe_blacklist__delete(&kprobe_blacklist);
2195 }
2196
2197 static bool kprobe_blacklist__listed(unsigned long address)
2198 {
2199         return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address);
2200 }
2201
2202 static int perf_probe_event__sprintf(const char *group, const char *event,
2203                                      struct perf_probe_event *pev,
2204                                      const char *module,
2205                                      struct strbuf *result)
2206 {
2207         int i, ret;
2208         char buf[128];
2209         char *place;
2210
2211         /* Synthesize only event probe point */
2212         place = synthesize_perf_probe_point(&pev->point);
2213         if (!place)
2214                 return -EINVAL;
2215
2216         ret = e_snprintf(buf, 128, "%s:%s", group, event);
2217         if (ret < 0)
2218                 goto out;
2219
2220         strbuf_addf(result, "  %-20s (on %s", buf, place);
2221         if (module)
2222                 strbuf_addf(result, " in %s", module);
2223
2224         if (pev->nargs > 0) {
2225                 strbuf_addstr(result, " with");
2226                 for (i = 0; i < pev->nargs; i++) {
2227                         ret = synthesize_perf_probe_arg(&pev->args[i],
2228                                                         buf, 128);
2229                         if (ret < 0)
2230                                 goto out;
2231                         strbuf_addf(result, " %s", buf);
2232                 }
2233         }
2234         strbuf_addch(result, ')');
2235 out:
2236         free(place);
2237         return ret;
2238 }
2239
2240 /* Show an event */
2241 static int show_perf_probe_event(const char *group, const char *event,
2242                                  struct perf_probe_event *pev,
2243                                  const char *module, bool use_stdout)
2244 {
2245         struct strbuf buf = STRBUF_INIT;
2246         int ret;
2247
2248         ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
2249         if (ret >= 0) {
2250                 if (use_stdout)
2251                         printf("%s\n", buf.buf);
2252                 else
2253                         pr_info("%s\n", buf.buf);
2254         }
2255         strbuf_release(&buf);
2256
2257         return ret;
2258 }
2259
2260 static bool filter_probe_trace_event(struct probe_trace_event *tev,
2261                                      struct strfilter *filter)
2262 {
2263         char tmp[128];
2264
2265         /* At first, check the event name itself */
2266         if (strfilter__compare(filter, tev->event))
2267                 return true;
2268
2269         /* Next, check the combination of name and group */
2270         if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0)
2271                 return false;
2272         return strfilter__compare(filter, tmp);
2273 }
2274
2275 static int __show_perf_probe_events(int fd, bool is_kprobe,
2276                                     struct strfilter *filter)
2277 {
2278         int ret = 0;
2279         struct probe_trace_event tev;
2280         struct perf_probe_event pev;
2281         struct strlist *rawlist;
2282         struct str_node *ent;
2283
2284         memset(&tev, 0, sizeof(tev));
2285         memset(&pev, 0, sizeof(pev));
2286
2287         rawlist = get_probe_trace_command_rawlist(fd);
2288         if (!rawlist)
2289                 return -ENOMEM;
2290
2291         strlist__for_each(ent, rawlist) {
2292                 ret = parse_probe_trace_command(ent->s, &tev);
2293                 if (ret >= 0) {
2294                         if (!filter_probe_trace_event(&tev, filter))
2295                                 goto next;
2296                         ret = convert_to_perf_probe_event(&tev, &pev,
2297                                                                 is_kprobe);
2298                         if (ret < 0)
2299                                 goto next;
2300                         ret = show_perf_probe_event(pev.group, pev.event,
2301                                                     &pev, tev.point.module,
2302                                                     true);
2303                 }
2304 next:
2305                 clear_perf_probe_event(&pev);
2306                 clear_probe_trace_event(&tev);
2307                 if (ret < 0)
2308                         break;
2309         }
2310         strlist__delete(rawlist);
2311         /* Cleanup cached debuginfo if needed */
2312         debuginfo_cache__exit();
2313
2314         return ret;
2315 }
2316
2317 /* List up current perf-probe events */
2318 int show_perf_probe_events(struct strfilter *filter)
2319 {
2320         int kp_fd, up_fd, ret;
2321
2322         setup_pager();
2323
2324         ret = init_symbol_maps(false);
2325         if (ret < 0)
2326                 return ret;
2327
2328         kp_fd = open_kprobe_events(false);
2329         if (kp_fd >= 0) {
2330                 ret = __show_perf_probe_events(kp_fd, true, filter);
2331                 close(kp_fd);
2332                 if (ret < 0)
2333                         goto out;
2334         }
2335
2336         up_fd = open_uprobe_events(false);
2337         if (kp_fd < 0 && up_fd < 0) {
2338                 print_both_open_warning(kp_fd, up_fd);
2339                 ret = kp_fd;
2340                 goto out;
2341         }
2342
2343         if (up_fd >= 0) {
2344                 ret = __show_perf_probe_events(up_fd, false, filter);
2345                 close(up_fd);
2346         }
2347 out:
2348         exit_symbol_maps();
2349         return ret;
2350 }
2351
2352 /* Get current perf-probe event names */
2353 static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
2354 {
2355         char buf[128];
2356         struct strlist *sl, *rawlist;
2357         struct str_node *ent;
2358         struct probe_trace_event tev;
2359         int ret = 0;
2360
2361         memset(&tev, 0, sizeof(tev));
2362         rawlist = get_probe_trace_command_rawlist(fd);
2363         if (!rawlist)
2364                 return NULL;
2365         sl = strlist__new(true, NULL);
2366         strlist__for_each(ent, rawlist) {
2367                 ret = parse_probe_trace_command(ent->s, &tev);
2368                 if (ret < 0)
2369                         break;
2370                 if (include_group) {
2371                         ret = e_snprintf(buf, 128, "%s:%s", tev.group,
2372                                         tev.event);
2373                         if (ret >= 0)
2374                                 ret = strlist__add(sl, buf);
2375                 } else
2376                         ret = strlist__add(sl, tev.event);
2377                 clear_probe_trace_event(&tev);
2378                 if (ret < 0)
2379                         break;
2380         }
2381         strlist__delete(rawlist);
2382
2383         if (ret < 0) {
2384                 strlist__delete(sl);
2385                 return NULL;
2386         }
2387         return sl;
2388 }
2389
2390 static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
2391 {
2392         int ret = 0;
2393         char *buf = synthesize_probe_trace_command(tev);
2394         char sbuf[STRERR_BUFSIZE];
2395
2396         if (!buf) {
2397                 pr_debug("Failed to synthesize probe trace event.\n");
2398                 return -EINVAL;
2399         }
2400
2401         pr_debug("Writing event: %s\n", buf);
2402         if (!probe_event_dry_run) {
2403                 ret = write(fd, buf, strlen(buf));
2404                 if (ret <= 0) {
2405                         ret = -errno;
2406                         pr_warning("Failed to write event: %s\n",
2407                                    strerror_r(errno, sbuf, sizeof(sbuf)));
2408                 }
2409         }
2410         free(buf);
2411         return ret;
2412 }
2413
2414 static int get_new_event_name(char *buf, size_t len, const char *base,
2415                               struct strlist *namelist, bool allow_suffix)
2416 {
2417         int i, ret;
2418         char *p;
2419
2420         if (*base == '.')
2421                 base++;
2422
2423         /* Try no suffix */
2424         ret = e_snprintf(buf, len, "%s", base);
2425         if (ret < 0) {
2426                 pr_debug("snprintf() failed: %d\n", ret);
2427                 return ret;
2428         }
2429         /* Cut off the postfixes (e.g. .const, .isra)*/
2430         p = strchr(buf, '.');
2431         if (p && p != buf)
2432                 *p = '\0';
2433         if (!strlist__has_entry(namelist, buf))
2434                 return 0;
2435
2436         if (!allow_suffix) {
2437                 pr_warning("Error: event \"%s\" already exists. "
2438                            "(Use -f to force duplicates.)\n", base);
2439                 return -EEXIST;
2440         }
2441
2442         /* Try to add suffix */
2443         for (i = 1; i < MAX_EVENT_INDEX; i++) {
2444                 ret = e_snprintf(buf, len, "%s_%d", base, i);
2445                 if (ret < 0) {
2446                         pr_debug("snprintf() failed: %d\n", ret);
2447                         return ret;
2448                 }
2449                 if (!strlist__has_entry(namelist, buf))
2450                         break;
2451         }
2452         if (i == MAX_EVENT_INDEX) {
2453                 pr_warning("Too many events are on the same function.\n");
2454                 ret = -ERANGE;
2455         }
2456
2457         return ret;
2458 }
2459
2460 /* Warn if the current kernel's uprobe implementation is old */
2461 static void warn_uprobe_event_compat(struct probe_trace_event *tev)
2462 {
2463         int i;
2464         char *buf = synthesize_probe_trace_command(tev);
2465
2466         /* Old uprobe event doesn't support memory dereference */
2467         if (!tev->uprobes || tev->nargs == 0 || !buf)
2468                 goto out;
2469
2470         for (i = 0; i < tev->nargs; i++)
2471                 if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
2472                         pr_warning("Please upgrade your kernel to at least "
2473                                    "3.14 to have access to feature %s\n",
2474                                    tev->args[i].value);
2475                         break;
2476                 }
2477 out:
2478         free(buf);
2479 }
2480
2481 static int __add_probe_trace_events(struct perf_probe_event *pev,
2482                                      struct probe_trace_event *tevs,
2483                                      int ntevs, bool allow_suffix)
2484 {
2485         int i, fd, ret;
2486         struct probe_trace_event *tev = NULL;
2487         char buf[64];
2488         const char *event = NULL, *group = NULL;
2489         struct strlist *namelist;
2490         bool safename;
2491
2492         if (pev->uprobes)
2493                 fd = open_uprobe_events(true);
2494         else
2495                 fd = open_kprobe_events(true);
2496
2497         if (fd < 0) {
2498                 print_open_warning(fd, !pev->uprobes);
2499                 return fd;
2500         }
2501
2502         /* Get current event names */
2503         namelist = get_probe_trace_event_names(fd, false);
2504         if (!namelist) {
2505                 pr_debug("Failed to get current event list.\n");
2506                 ret = -ENOMEM;
2507                 goto close_out;
2508         }
2509
2510         safename = (pev->point.function && !strisglob(pev->point.function));
2511         ret = 0;
2512         pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
2513         for (i = 0; i < ntevs; i++) {
2514                 tev = &tevs[i];
2515                 /* Skip if the symbol is out of .text or blacklisted */
2516                 if (!tev->point.symbol)
2517                         continue;
2518
2519                 if (pev->event)
2520                         event = pev->event;
2521                 else
2522                         if (safename)
2523                                 event = pev->point.function;
2524                         else
2525                                 event = tev->point.realname;
2526                 if (pev->group)
2527                         group = pev->group;
2528                 else
2529                         group = PERFPROBE_GROUP;
2530
2531                 /* Get an unused new event name */
2532                 ret = get_new_event_name(buf, 64, event,
2533                                          namelist, allow_suffix);
2534                 if (ret < 0)
2535                         break;
2536                 event = buf;
2537
2538                 tev->event = strdup(event);
2539                 tev->group = strdup(group);
2540                 if (tev->event == NULL || tev->group == NULL) {
2541                         ret = -ENOMEM;
2542                         break;
2543                 }
2544                 ret = write_probe_trace_event(fd, tev);
2545                 if (ret < 0)
2546                         break;
2547                 /* Add added event name to namelist */
2548                 strlist__add(namelist, event);
2549
2550                 /* We use tev's name for showing new events */
2551                 show_perf_probe_event(tev->group, tev->event, pev,
2552                                       tev->point.module, false);
2553                 /* Save the last valid name */
2554                 event = tev->event;
2555                 group = tev->group;
2556
2557                 /*
2558                  * Probes after the first probe which comes from same
2559                  * user input are always allowed to add suffix, because
2560                  * there might be several addresses corresponding to
2561                  * one code line.
2562                  */
2563                 allow_suffix = true;
2564         }
2565         if (ret == -EINVAL && pev->uprobes)
2566                 warn_uprobe_event_compat(tev);
2567
2568         /* Note that it is possible to skip all events because of blacklist */
2569         if (ret >= 0 && event) {
2570                 /* Show how to use the event. */
2571                 pr_info("\nYou can now use it in all perf tools, such as:\n\n");
2572                 pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", group, event);
2573         }
2574
2575         strlist__delete(namelist);
2576 close_out:
2577         close(fd);
2578         return ret;
2579 }
2580
2581 static int find_probe_functions(struct map *map, char *name,
2582                                 struct symbol **syms)
2583 {
2584         int found = 0;
2585         struct symbol *sym;
2586         struct rb_node *tmp;
2587
2588         if (map__load(map, NULL) < 0)
2589                 return 0;
2590
2591         map__for_each_symbol(map, sym, tmp) {
2592                 if (strglobmatch(sym->name, name)) {
2593                         found++;
2594                         if (syms && found < probe_conf.max_probes)
2595                                 syms[found - 1] = sym;
2596                 }
2597         }
2598
2599         return found;
2600 }
2601
2602 #define strdup_or_goto(str, label)      \
2603         ({ char *__p = strdup(str); if (!__p) goto label; __p; })
2604
2605 void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
2606                                 struct probe_trace_event *tev __maybe_unused,
2607                                 struct map *map __maybe_unused) { }
2608
2609 /*
2610  * Find probe function addresses from map.
2611  * Return an error or the number of found probe_trace_event
2612  */
2613 static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2614                                             struct probe_trace_event **tevs)
2615 {
2616         struct map *map = NULL;
2617         struct ref_reloc_sym *reloc_sym = NULL;
2618         struct symbol *sym;
2619         struct symbol **syms = NULL;
2620         struct probe_trace_event *tev;
2621         struct perf_probe_point *pp = &pev->point;
2622         struct probe_trace_point *tp;
2623         int num_matched_functions;
2624         int ret, i, j, skipped = 0;
2625
2626         map = get_target_map(pev->target, pev->uprobes);
2627         if (!map) {
2628                 ret = -EINVAL;
2629                 goto out;
2630         }
2631
2632         syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
2633         if (!syms) {
2634                 ret = -ENOMEM;
2635                 goto out;
2636         }
2637
2638         /*
2639          * Load matched symbols: Since the different local symbols may have
2640          * same name but different addresses, this lists all the symbols.
2641          */
2642         num_matched_functions = find_probe_functions(map, pp->function, syms);
2643         if (num_matched_functions == 0) {
2644                 pr_err("Failed to find symbol %s in %s\n", pp->function,
2645                         pev->target ? : "kernel");
2646                 ret = -ENOENT;
2647                 goto out;
2648         } else if (num_matched_functions > probe_conf.max_probes) {
2649                 pr_err("Too many functions matched in %s\n",
2650                         pev->target ? : "kernel");
2651                 ret = -E2BIG;
2652                 goto out;
2653         }
2654
2655         if (!pev->uprobes && !pp->retprobe) {
2656                 reloc_sym = kernel_get_ref_reloc_sym();
2657                 if (!reloc_sym) {
2658                         pr_warning("Relocated base symbol is not found!\n");
2659                         ret = -EINVAL;
2660                         goto out;
2661                 }
2662         }
2663
2664         /* Setup result trace-probe-events */
2665         *tevs = zalloc(sizeof(*tev) * num_matched_functions);
2666         if (!*tevs) {
2667                 ret = -ENOMEM;
2668                 goto out;
2669         }
2670
2671         ret = 0;
2672
2673         for (j = 0; j < num_matched_functions; j++) {
2674                 sym = syms[j];
2675
2676                 tev = (*tevs) + ret;
2677                 tp = &tev->point;
2678                 if (ret == num_matched_functions) {
2679                         pr_warning("Too many symbols are listed. Skip it.\n");
2680                         break;
2681                 }
2682                 ret++;
2683
2684                 if (pp->offset > sym->end - sym->start) {
2685                         pr_warning("Offset %ld is bigger than the size of %s\n",
2686                                    pp->offset, sym->name);
2687                         ret = -ENOENT;
2688                         goto err_out;
2689                 }
2690                 /* Add one probe point */
2691                 tp->address = map->unmap_ip(map, sym->start) + pp->offset;
2692                 /* If we found a wrong one, mark it by NULL symbol */
2693                 if (!pev->uprobes &&
2694                     kprobe_warn_out_range(sym->name, tp->address)) {
2695                         tp->symbol = NULL;      /* Skip it */
2696                         skipped++;
2697                 } else if (reloc_sym) {
2698                         tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
2699                         tp->offset = tp->address - reloc_sym->addr;
2700                 } else {
2701                         tp->symbol = strdup_or_goto(sym->name, nomem_out);
2702                         tp->offset = pp->offset;
2703                 }
2704                 tp->realname = strdup_or_goto(sym->name, nomem_out);
2705
2706                 tp->retprobe = pp->retprobe;
2707                 if (pev->target)
2708                         tev->point.module = strdup_or_goto(pev->target,
2709                                                            nomem_out);
2710                 tev->uprobes = pev->uprobes;
2711                 tev->nargs = pev->nargs;
2712                 if (tev->nargs) {
2713                         tev->args = zalloc(sizeof(struct probe_trace_arg) *
2714                                            tev->nargs);
2715                         if (tev->args == NULL)
2716                                 goto nomem_out;
2717                 }
2718                 for (i = 0; i < tev->nargs; i++) {
2719                         if (pev->args[i].name)
2720                                 tev->args[i].name =
2721                                         strdup_or_goto(pev->args[i].name,
2722                                                         nomem_out);
2723
2724                         tev->args[i].value = strdup_or_goto(pev->args[i].var,
2725                                                             nomem_out);
2726                         if (pev->args[i].type)
2727                                 tev->args[i].type =
2728                                         strdup_or_goto(pev->args[i].type,
2729                                                         nomem_out);
2730                 }
2731                 arch__fix_tev_from_maps(pev, tev, map);
2732         }
2733         if (ret == skipped) {
2734                 ret = -ENOENT;
2735                 goto err_out;
2736         }
2737
2738 out:
2739         put_target_map(map, pev->uprobes);
2740         free(syms);
2741         return ret;
2742
2743 nomem_out:
2744         ret = -ENOMEM;
2745 err_out:
2746         clear_probe_trace_events(*tevs, num_matched_functions);
2747         zfree(tevs);
2748         goto out;
2749 }
2750
2751 bool __weak arch__prefers_symtab(void) { return false; }
2752
2753 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
2754                                          struct probe_trace_event **tevs)
2755 {
2756         int ret;
2757
2758         if (pev->uprobes && !pev->group) {
2759                 /* Replace group name if not given */
2760                 ret = convert_exec_to_group(pev->target, &pev->group);
2761                 if (ret != 0) {
2762                         pr_warning("Failed to make a group name.\n");
2763                         return ret;
2764                 }
2765         }
2766
2767         if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) {
2768                 ret = find_probe_trace_events_from_map(pev, tevs);
2769                 if (ret > 0)
2770                         return ret; /* Found in symbol table */
2771         }
2772
2773         /* Convert perf_probe_event with debuginfo */
2774         ret = try_to_find_probe_trace_events(pev, tevs);
2775         if (ret != 0)
2776                 return ret;     /* Found in debuginfo or got an error */
2777
2778         return find_probe_trace_events_from_map(pev, tevs);
2779 }
2780
2781 struct __event_package {
2782         struct perf_probe_event         *pev;
2783         struct probe_trace_event        *tevs;
2784         int                             ntevs;
2785 };
2786
2787 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
2788 {
2789         int i, j, ret;
2790         struct __event_package *pkgs;
2791
2792         ret = 0;
2793         pkgs = zalloc(sizeof(struct __event_package) * npevs);
2794
2795         if (pkgs == NULL)
2796                 return -ENOMEM;
2797
2798         ret = init_symbol_maps(pevs->uprobes);
2799         if (ret < 0) {
2800                 free(pkgs);
2801                 return ret;
2802         }
2803
2804         /* Loop 1: convert all events */
2805         for (i = 0; i < npevs; i++) {
2806                 pkgs[i].pev = &pevs[i];
2807                 /* Init kprobe blacklist if needed */
2808                 if (!pkgs[i].pev->uprobes)
2809                         kprobe_blacklist__init();
2810                 /* Convert with or without debuginfo */
2811                 ret  = convert_to_probe_trace_events(pkgs[i].pev,
2812                                                      &pkgs[i].tevs);
2813                 if (ret < 0)
2814                         goto end;
2815                 pkgs[i].ntevs = ret;
2816         }
2817         /* This just release blacklist only if allocated */
2818         kprobe_blacklist__release();
2819
2820         /* Loop 2: add all events */
2821         for (i = 0; i < npevs; i++) {
2822                 ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
2823                                                pkgs[i].ntevs,
2824                                                probe_conf.force_add);
2825                 if (ret < 0)
2826                         break;
2827         }
2828 end:
2829         /* Loop 3: cleanup and free trace events  */
2830         for (i = 0; i < npevs; i++) {
2831                 for (j = 0; j < pkgs[i].ntevs; j++)
2832                         clear_probe_trace_event(&pkgs[i].tevs[j]);
2833                 zfree(&pkgs[i].tevs);
2834         }
2835         free(pkgs);
2836         exit_symbol_maps();
2837
2838         return ret;
2839 }
2840
2841 static int __del_trace_probe_event(int fd, struct str_node *ent)
2842 {
2843         char *p;
2844         char buf[128];
2845         int ret;
2846
2847         /* Convert from perf-probe event to trace-probe event */
2848         ret = e_snprintf(buf, 128, "-:%s", ent->s);
2849         if (ret < 0)
2850                 goto error;
2851
2852         p = strchr(buf + 2, ':');
2853         if (!p) {
2854                 pr_debug("Internal error: %s should have ':' but not.\n",
2855                          ent->s);
2856                 ret = -ENOTSUP;
2857                 goto error;
2858         }
2859         *p = '/';
2860
2861         pr_debug("Writing event: %s\n", buf);
2862         ret = write(fd, buf, strlen(buf));
2863         if (ret < 0) {
2864                 ret = -errno;
2865                 goto error;
2866         }
2867
2868         pr_info("Removed event: %s\n", ent->s);
2869         return 0;
2870 error:
2871         pr_warning("Failed to delete event: %s\n",
2872                    strerror_r(-ret, buf, sizeof(buf)));
2873         return ret;
2874 }
2875
2876 static int del_trace_probe_events(int fd, struct strfilter *filter,
2877                                   struct strlist *namelist)
2878 {
2879         struct str_node *ent;
2880         const char *p;
2881         int ret = -ENOENT;
2882
2883         if (!namelist)
2884                 return -ENOENT;
2885
2886         strlist__for_each(ent, namelist) {
2887                 p = strchr(ent->s, ':');
2888                 if ((p && strfilter__compare(filter, p + 1)) ||
2889                     strfilter__compare(filter, ent->s)) {
2890                         ret = __del_trace_probe_event(fd, ent);
2891                         if (ret < 0)
2892                                 break;
2893                 }
2894         }
2895
2896         return ret;
2897 }
2898
2899 int del_perf_probe_events(struct strfilter *filter)
2900 {
2901         int ret, ret2, ufd = -1, kfd = -1;
2902         struct strlist *namelist = NULL, *unamelist = NULL;
2903         char *str = strfilter__string(filter);
2904
2905         if (!str)
2906                 return -EINVAL;
2907
2908         pr_debug("Delete filter: \'%s\'\n", str);
2909
2910         /* Get current event names */
2911         kfd = open_kprobe_events(true);
2912         if (kfd >= 0)
2913                 namelist = get_probe_trace_event_names(kfd, true);
2914
2915         ufd = open_uprobe_events(true);
2916         if (ufd >= 0)
2917                 unamelist = get_probe_trace_event_names(ufd, true);
2918
2919         if (kfd < 0 && ufd < 0) {
2920                 print_both_open_warning(kfd, ufd);
2921                 ret = kfd;
2922                 goto error;
2923         }
2924
2925         ret = del_trace_probe_events(kfd, filter, namelist);
2926         if (ret < 0 && ret != -ENOENT)
2927                 goto error;
2928
2929         ret2 = del_trace_probe_events(ufd, filter, unamelist);
2930         if (ret2 < 0 && ret2 != -ENOENT) {
2931                 ret = ret2;
2932                 goto error;
2933         }
2934         if (ret == -ENOENT && ret2 == -ENOENT)
2935                 pr_debug("\"%s\" does not hit any event.\n", str);
2936                 /* Note that this is silently ignored */
2937         ret = 0;
2938
2939 error:
2940         if (kfd >= 0) {
2941                 strlist__delete(namelist);
2942                 close(kfd);
2943         }
2944
2945         if (ufd >= 0) {
2946                 strlist__delete(unamelist);
2947                 close(ufd);
2948         }
2949         free(str);
2950
2951         return ret;
2952 }
2953
2954 /* TODO: don't use a global variable for filter ... */
2955 static struct strfilter *available_func_filter;
2956
2957 /*
2958  * If a symbol corresponds to a function with global binding and
2959  * matches filter return 0. For all others return 1.
2960  */
2961 static int filter_available_functions(struct map *map __maybe_unused,
2962                                       struct symbol *sym)
2963 {
2964         if (strfilter__compare(available_func_filter, sym->name))
2965                 return 0;
2966         return 1;
2967 }
2968
2969 int show_available_funcs(const char *target, struct strfilter *_filter,
2970                                         bool user)
2971 {
2972         struct map *map;
2973         int ret;
2974
2975         ret = init_symbol_maps(user);
2976         if (ret < 0)
2977                 return ret;
2978
2979         /* Get a symbol map */
2980         if (user)
2981                 map = dso__new_map(target);
2982         else
2983                 map = kernel_get_module_map(target);
2984         if (!map) {
2985                 pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
2986                 return -EINVAL;
2987         }
2988
2989         /* Load symbols with given filter */
2990         available_func_filter = _filter;
2991         if (map__load(map, filter_available_functions)) {
2992                 pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
2993                 goto end;
2994         }
2995         if (!dso__sorted_by_name(map->dso, map->type))
2996                 dso__sort_by_name(map->dso, map->type);
2997
2998         /* Show all (filtered) symbols */
2999         setup_pager();
3000         dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
3001 end:
3002         if (user) {
3003                 map__put(map);
3004         }
3005         exit_symbol_maps();
3006
3007         return ret;
3008 }
3009