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