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
1088         ptr = strpbrk(arg, ";=@+%");
1089         if (ptr && *ptr == '=') {       /* Event name */
1090                 *ptr = '\0';
1091                 tmp = ptr + 1;
1092                 if (strchr(arg, ':')) {
1093                         semantic_error("Group name is not supported yet.\n");
1094                         return -ENOTSUP;
1095                 }
1096                 if (!check_event_name(arg)) {
1097                         semantic_error("%s is bad for event name -it must "
1098                                        "follow C symbol-naming rule.\n", arg);
1099                         return -EINVAL;
1100                 }
1101                 pev->event = strdup(arg);
1102                 if (pev->event == NULL)
1103                         return -ENOMEM;
1104                 pev->group = NULL;
1105                 arg = tmp;
1106         }
1107
1108         ptr = strpbrk(arg, ";:+@%");
1109         if (ptr) {
1110                 nc = *ptr;
1111                 *ptr++ = '\0';
1112         }
1113
1114         tmp = strdup(arg);
1115         if (tmp == NULL)
1116                 return -ENOMEM;
1117
1118         /* Check arg is function or file and copy it */
1119         if (strchr(tmp, '.'))   /* File */
1120                 pp->file = tmp;
1121         else                    /* Function */
1122                 pp->function = tmp;
1123
1124         /* Parse other options */
1125         while (ptr) {
1126                 arg = ptr;
1127                 c = nc;
1128                 if (c == ';') { /* Lazy pattern must be the last part */
1129                         pp->lazy_line = strdup(arg);
1130                         if (pp->lazy_line == NULL)
1131                                 return -ENOMEM;
1132                         break;
1133                 }
1134                 ptr = strpbrk(arg, ";:+@%");
1135                 if (ptr) {
1136                         nc = *ptr;
1137                         *ptr++ = '\0';
1138                 }
1139                 switch (c) {
1140                 case ':':       /* Line number */
1141                         pp->line = strtoul(arg, &tmp, 0);
1142                         if (*tmp != '\0') {
1143                                 semantic_error("There is non-digit char"
1144                                                " in line number.\n");
1145                                 return -EINVAL;
1146                         }
1147                         break;
1148                 case '+':       /* Byte offset from a symbol */
1149                         pp->offset = strtoul(arg, &tmp, 0);
1150                         if (*tmp != '\0') {
1151                                 semantic_error("There is non-digit character"
1152                                                 " in offset.\n");
1153                                 return -EINVAL;
1154                         }
1155                         break;
1156                 case '@':       /* File name */
1157                         if (pp->file) {
1158                                 semantic_error("SRC@SRC is not allowed.\n");
1159                                 return -EINVAL;
1160                         }
1161                         pp->file = strdup(arg);
1162                         if (pp->file == NULL)
1163                                 return -ENOMEM;
1164                         break;
1165                 case '%':       /* Probe places */
1166                         if (strcmp(arg, "return") == 0) {
1167                                 pp->retprobe = 1;
1168                         } else {        /* Others not supported yet */
1169                                 semantic_error("%%%s is not supported.\n", arg);
1170                                 return -ENOTSUP;
1171                         }
1172                         break;
1173                 default:        /* Buggy case */
1174                         pr_err("This program has a bug at %s:%d.\n",
1175                                 __FILE__, __LINE__);
1176                         return -ENOTSUP;
1177                         break;
1178                 }
1179         }
1180
1181         /* Exclusion check */
1182         if (pp->lazy_line && pp->line) {
1183                 semantic_error("Lazy pattern can't be used with"
1184                                " line number.\n");
1185                 return -EINVAL;
1186         }
1187
1188         if (pp->lazy_line && pp->offset) {
1189                 semantic_error("Lazy pattern can't be used with offset.\n");
1190                 return -EINVAL;
1191         }
1192
1193         if (pp->line && pp->offset) {
1194                 semantic_error("Offset can't be used with line number.\n");
1195                 return -EINVAL;
1196         }
1197
1198         if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1199                 semantic_error("File always requires line number or "
1200                                "lazy pattern.\n");
1201                 return -EINVAL;
1202         }
1203
1204         if (pp->offset && !pp->function) {
1205                 semantic_error("Offset requires an entry function.\n");
1206                 return -EINVAL;
1207         }
1208
1209         if (pp->retprobe && !pp->function) {
1210                 semantic_error("Return probe requires an entry function.\n");
1211                 return -EINVAL;
1212         }
1213
1214         if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1215                 semantic_error("Offset/Line/Lazy pattern can't be used with "
1216                                "return probe.\n");
1217                 return -EINVAL;
1218         }
1219
1220         pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1221                  pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
1222                  pp->lazy_line);
1223         return 0;
1224 }
1225
1226 /* Parse perf-probe event argument */
1227 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1228 {
1229         char *tmp, *goodname;
1230         struct perf_probe_arg_field **fieldp;
1231
1232         pr_debug("parsing arg: %s into ", str);
1233
1234         tmp = strchr(str, '=');
1235         if (tmp) {
1236                 arg->name = strndup(str, tmp - str);
1237                 if (arg->name == NULL)
1238                         return -ENOMEM;
1239                 pr_debug("name:%s ", arg->name);
1240                 str = tmp + 1;
1241         }
1242
1243         tmp = strchr(str, ':');
1244         if (tmp) {      /* Type setting */
1245                 *tmp = '\0';
1246                 arg->type = strdup(tmp + 1);
1247                 if (arg->type == NULL)
1248                         return -ENOMEM;
1249                 pr_debug("type:%s ", arg->type);
1250         }
1251
1252         tmp = strpbrk(str, "-.[");
1253         if (!is_c_varname(str) || !tmp) {
1254                 /* A variable, register, symbol or special value */
1255                 arg->var = strdup(str);
1256                 if (arg->var == NULL)
1257                         return -ENOMEM;
1258                 pr_debug("%s\n", arg->var);
1259                 return 0;
1260         }
1261
1262         /* Structure fields or array element */
1263         arg->var = strndup(str, tmp - str);
1264         if (arg->var == NULL)
1265                 return -ENOMEM;
1266         goodname = arg->var;
1267         pr_debug("%s, ", arg->var);
1268         fieldp = &arg->field;
1269
1270         do {
1271                 *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
1272                 if (*fieldp == NULL)
1273                         return -ENOMEM;
1274                 if (*tmp == '[') {      /* Array */
1275                         str = tmp;
1276                         (*fieldp)->index = strtol(str + 1, &tmp, 0);
1277                         (*fieldp)->ref = true;
1278                         if (*tmp != ']' || tmp == str + 1) {
1279                                 semantic_error("Array index must be a"
1280                                                 " number.\n");
1281                                 return -EINVAL;
1282                         }
1283                         tmp++;
1284                         if (*tmp == '\0')
1285                                 tmp = NULL;
1286                 } else {                /* Structure */
1287                         if (*tmp == '.') {
1288                                 str = tmp + 1;
1289                                 (*fieldp)->ref = false;
1290                         } else if (tmp[1] == '>') {
1291                                 str = tmp + 2;
1292                                 (*fieldp)->ref = true;
1293                         } else {
1294                                 semantic_error("Argument parse error: %s\n",
1295                                                str);
1296                                 return -EINVAL;
1297                         }
1298                         tmp = strpbrk(str, "-.[");
1299                 }
1300                 if (tmp) {
1301                         (*fieldp)->name = strndup(str, tmp - str);
1302                         if ((*fieldp)->name == NULL)
1303                                 return -ENOMEM;
1304                         if (*str != '[')
1305                                 goodname = (*fieldp)->name;
1306                         pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
1307                         fieldp = &(*fieldp)->next;
1308                 }
1309         } while (tmp);
1310         (*fieldp)->name = strdup(str);
1311         if ((*fieldp)->name == NULL)
1312                 return -ENOMEM;
1313         if (*str != '[')
1314                 goodname = (*fieldp)->name;
1315         pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1316
1317         /* If no name is specified, set the last field name (not array index)*/
1318         if (!arg->name) {
1319                 arg->name = strdup(goodname);
1320                 if (arg->name == NULL)
1321                         return -ENOMEM;
1322         }
1323         return 0;
1324 }
1325
1326 /* Parse perf-probe event command */
1327 int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1328 {
1329         char **argv;
1330         int argc, i, ret = 0;
1331
1332         argv = argv_split(cmd, &argc);
1333         if (!argv) {
1334                 pr_debug("Failed to split arguments.\n");
1335                 return -ENOMEM;
1336         }
1337         if (argc - 1 > MAX_PROBE_ARGS) {
1338                 semantic_error("Too many probe arguments (%d).\n", argc - 1);
1339                 ret = -ERANGE;
1340                 goto out;
1341         }
1342         /* Parse probe point */
1343         ret = parse_perf_probe_point(argv[0], pev);
1344         if (ret < 0)
1345                 goto out;
1346
1347         /* Copy arguments and ensure return probe has no C argument */
1348         pev->nargs = argc - 1;
1349         pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1350         if (pev->args == NULL) {
1351                 ret = -ENOMEM;
1352                 goto out;
1353         }
1354         for (i = 0; i < pev->nargs && ret >= 0; i++) {
1355                 ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1356                 if (ret >= 0 &&
1357                     is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1358                         semantic_error("You can't specify local variable for"
1359                                        " kretprobe.\n");
1360                         ret = -EINVAL;
1361                 }
1362         }
1363 out:
1364         argv_free(argv);
1365
1366         return ret;
1367 }
1368
1369 /* Return true if this perf_probe_event requires debuginfo */
1370 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
1371 {
1372         int i;
1373
1374         if (pev->point.file || pev->point.line || pev->point.lazy_line)
1375                 return true;
1376
1377         for (i = 0; i < pev->nargs; i++)
1378                 if (is_c_varname(pev->args[i].var))
1379                         return true;
1380
1381         return false;
1382 }
1383
1384 /* Parse probe_events event into struct probe_point */
1385 static int parse_probe_trace_command(const char *cmd,
1386                                      struct probe_trace_event *tev)
1387 {
1388         struct probe_trace_point *tp = &tev->point;
1389         char pr;
1390         char *p;
1391         char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1392         int ret, i, argc;
1393         char **argv;
1394
1395         pr_debug("Parsing probe_events: %s\n", cmd);
1396         argv = argv_split(cmd, &argc);
1397         if (!argv) {
1398                 pr_debug("Failed to split arguments.\n");
1399                 return -ENOMEM;
1400         }
1401         if (argc < 2) {
1402                 semantic_error("Too few probe arguments.\n");
1403                 ret = -ERANGE;
1404                 goto out;
1405         }
1406
1407         /* Scan event and group name. */
1408         argv0_str = strdup(argv[0]);
1409         if (argv0_str == NULL) {
1410                 ret = -ENOMEM;
1411                 goto out;
1412         }
1413         fmt1_str = strtok_r(argv0_str, ":", &fmt);
1414         fmt2_str = strtok_r(NULL, "/", &fmt);
1415         fmt3_str = strtok_r(NULL, " \t", &fmt);
1416         if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
1417             || fmt3_str == NULL) {
1418                 semantic_error("Failed to parse event name: %s\n", argv[0]);
1419                 ret = -EINVAL;
1420                 goto out;
1421         }
1422         pr = fmt1_str[0];
1423         tev->group = strdup(fmt2_str);
1424         tev->event = strdup(fmt3_str);
1425         if (tev->group == NULL || tev->event == NULL) {
1426                 ret = -ENOMEM;
1427                 goto out;
1428         }
1429         pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1430
1431         tp->retprobe = (pr == 'r');
1432
1433         /* Scan module name(if there), function name and offset */
1434         p = strchr(argv[1], ':');
1435         if (p) {
1436                 tp->module = strndup(argv[1], p - argv[1]);
1437                 p++;
1438         } else
1439                 p = argv[1];
1440         fmt1_str = strtok_r(p, "+", &fmt);
1441         if (fmt1_str[0] == '0') /* only the address started with 0x */
1442                 tp->address = strtoul(fmt1_str, NULL, 0);
1443         else {
1444                 /* Only the symbol-based probe has offset */
1445                 tp->symbol = strdup(fmt1_str);
1446                 if (tp->symbol == NULL) {
1447                         ret = -ENOMEM;
1448                         goto out;
1449                 }
1450                 fmt2_str = strtok_r(NULL, "", &fmt);
1451                 if (fmt2_str == NULL)
1452                         tp->offset = 0;
1453                 else
1454                         tp->offset = strtoul(fmt2_str, NULL, 10);
1455         }
1456
1457         tev->nargs = argc - 2;
1458         tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1459         if (tev->args == NULL) {
1460                 ret = -ENOMEM;
1461                 goto out;
1462         }
1463         for (i = 0; i < tev->nargs; i++) {
1464                 p = strchr(argv[i + 2], '=');
1465                 if (p)  /* We don't need which register is assigned. */
1466                         *p++ = '\0';
1467                 else
1468                         p = argv[i + 2];
1469                 tev->args[i].name = strdup(argv[i + 2]);
1470                 /* TODO: parse regs and offset */
1471                 tev->args[i].value = strdup(p);
1472                 if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
1473                         ret = -ENOMEM;
1474                         goto out;
1475                 }
1476         }
1477         ret = 0;
1478 out:
1479         free(argv0_str);
1480         argv_free(argv);
1481         return ret;
1482 }
1483
1484 /* Compose only probe arg */
1485 int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
1486 {
1487         struct perf_probe_arg_field *field = pa->field;
1488         int ret;
1489         char *tmp = buf;
1490
1491         if (pa->name && pa->var)
1492                 ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
1493         else
1494                 ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
1495         if (ret <= 0)
1496                 goto error;
1497         tmp += ret;
1498         len -= ret;
1499
1500         while (field) {
1501                 if (field->name[0] == '[')
1502                         ret = e_snprintf(tmp, len, "%s", field->name);
1503                 else
1504                         ret = e_snprintf(tmp, len, "%s%s",
1505                                          field->ref ? "->" : ".", field->name);
1506                 if (ret <= 0)
1507                         goto error;
1508                 tmp += ret;
1509                 len -= ret;
1510                 field = field->next;
1511         }
1512
1513         if (pa->type) {
1514                 ret = e_snprintf(tmp, len, ":%s", pa->type);
1515                 if (ret <= 0)
1516                         goto error;
1517                 tmp += ret;
1518                 len -= ret;
1519         }
1520
1521         return tmp - buf;
1522 error:
1523         pr_debug("Failed to synthesize perf probe argument: %d\n", ret);
1524         return ret;
1525 }
1526
1527 /* Compose only probe point (not argument) */
1528 static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1529 {
1530         char *buf, *tmp;
1531         char offs[32] = "", line[32] = "", file[32] = "";
1532         int ret, len;
1533
1534         buf = zalloc(MAX_CMDLEN);
1535         if (buf == NULL) {
1536                 ret = -ENOMEM;
1537                 goto error;
1538         }
1539         if (pp->offset) {
1540                 ret = e_snprintf(offs, 32, "+%lu", pp->offset);
1541                 if (ret <= 0)
1542                         goto error;
1543         }
1544         if (pp->line) {
1545                 ret = e_snprintf(line, 32, ":%d", pp->line);
1546                 if (ret <= 0)
1547                         goto error;
1548         }
1549         if (pp->file) {
1550                 tmp = pp->file;
1551                 len = strlen(tmp);
1552                 if (len > 30) {
1553                         tmp = strchr(pp->file + len - 30, '/');
1554                         tmp = tmp ? tmp + 1 : pp->file + len - 30;
1555                 }
1556                 ret = e_snprintf(file, 32, "@%s", tmp);
1557                 if (ret <= 0)
1558                         goto error;
1559         }
1560
1561         if (pp->function)
1562                 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
1563                                  offs, pp->retprobe ? "%return" : "", line,
1564                                  file);
1565         else
1566                 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
1567         if (ret <= 0)
1568                 goto error;
1569
1570         return buf;
1571 error:
1572         pr_debug("Failed to synthesize perf probe point: %d\n", ret);
1573         free(buf);
1574         return NULL;
1575 }
1576
1577 #if 0
1578 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1579 {
1580         char *buf;
1581         int i, len, ret;
1582
1583         buf = synthesize_perf_probe_point(&pev->point);
1584         if (!buf)
1585                 return NULL;
1586
1587         len = strlen(buf);
1588         for (i = 0; i < pev->nargs; i++) {
1589                 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
1590                                  pev->args[i].name);
1591                 if (ret <= 0) {
1592                         free(buf);
1593                         return NULL;
1594                 }
1595                 len += ret;
1596         }
1597
1598         return buf;
1599 }
1600 #endif
1601
1602 static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1603                                              char **buf, size_t *buflen,
1604                                              int depth)
1605 {
1606         int ret;
1607         if (ref->next) {
1608                 depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1609                                                          buflen, depth + 1);
1610                 if (depth < 0)
1611                         goto out;
1612         }
1613
1614         ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
1615         if (ret < 0)
1616                 depth = ret;
1617         else {
1618                 *buf += ret;
1619                 *buflen -= ret;
1620         }
1621 out:
1622         return depth;
1623
1624 }
1625
1626 static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1627                                        char *buf, size_t buflen)
1628 {
1629         struct probe_trace_arg_ref *ref = arg->ref;
1630         int ret, depth = 0;
1631         char *tmp = buf;
1632
1633         /* Argument name or separator */
1634         if (arg->name)
1635                 ret = e_snprintf(buf, buflen, " %s=", arg->name);
1636         else
1637                 ret = e_snprintf(buf, buflen, " ");
1638         if (ret < 0)
1639                 return ret;
1640         buf += ret;
1641         buflen -= ret;
1642
1643         /* Special case: @XXX */
1644         if (arg->value[0] == '@' && arg->ref)
1645                         ref = ref->next;
1646
1647         /* Dereferencing arguments */
1648         if (ref) {
1649                 depth = __synthesize_probe_trace_arg_ref(ref, &buf,
1650                                                           &buflen, 1);
1651                 if (depth < 0)
1652                         return depth;
1653         }
1654
1655         /* Print argument value */
1656         if (arg->value[0] == '@' && arg->ref)
1657                 ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
1658                                  arg->ref->offset);
1659         else
1660                 ret = e_snprintf(buf, buflen, "%s", arg->value);
1661         if (ret < 0)
1662                 return ret;
1663         buf += ret;
1664         buflen -= ret;
1665
1666         /* Closing */
1667         while (depth--) {
1668                 ret = e_snprintf(buf, buflen, ")");
1669                 if (ret < 0)
1670                         return ret;
1671                 buf += ret;
1672                 buflen -= ret;
1673         }
1674         /* Print argument type */
1675         if (arg->type) {
1676                 ret = e_snprintf(buf, buflen, ":%s", arg->type);
1677                 if (ret <= 0)
1678                         return ret;
1679                 buf += ret;
1680         }
1681
1682         return buf - tmp;
1683 }
1684
1685 char *synthesize_probe_trace_command(struct probe_trace_event *tev)
1686 {
1687         struct probe_trace_point *tp = &tev->point;
1688         char *buf;
1689         int i, len, ret;
1690
1691         buf = zalloc(MAX_CMDLEN);
1692         if (buf == NULL)
1693                 return NULL;
1694
1695         len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
1696                          tev->group, tev->event);
1697         if (len <= 0)
1698                 goto error;
1699
1700         /* Uprobes must have tp->address and tp->module */
1701         if (tev->uprobes && (!tp->address || !tp->module))
1702                 goto error;
1703
1704         /* Use the tp->address for uprobes */
1705         if (tev->uprobes)
1706                 ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx",
1707                                  tp->module, tp->address);
1708         else
1709                 ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu",
1710                                  tp->module ?: "", tp->module ? ":" : "",
1711                                  tp->symbol, tp->offset);
1712
1713         if (ret <= 0)
1714                 goto error;
1715         len += ret;
1716
1717         for (i = 0; i < tev->nargs; i++) {
1718                 ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
1719                                                   MAX_CMDLEN - len);
1720                 if (ret <= 0)
1721                         goto error;
1722                 len += ret;
1723         }
1724
1725         return buf;
1726 error:
1727         free(buf);
1728         return NULL;
1729 }
1730
1731 static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
1732                                           struct perf_probe_point *pp,
1733                                           bool is_kprobe)
1734 {
1735         struct symbol *sym = NULL;
1736         struct map *map;
1737         u64 addr;
1738         int ret = -ENOENT;
1739
1740         if (!is_kprobe) {
1741                 map = dso__new_map(tp->module);
1742                 if (!map)
1743                         goto out;
1744                 addr = tp->address;
1745                 sym = map__find_symbol(map, addr, NULL);
1746         } else {
1747                 addr = kernel_get_symbol_address_by_name(tp->symbol, true);
1748                 if (addr) {
1749                         addr += tp->offset;
1750                         sym = __find_kernel_function(addr, &map);
1751                 }
1752         }
1753         if (!sym)
1754                 goto out;
1755
1756         pp->retprobe = tp->retprobe;
1757         pp->offset = addr - map->unmap_ip(map, sym->start);
1758         pp->function = strdup(sym->name);
1759         ret = pp->function ? 0 : -ENOMEM;
1760
1761 out:
1762         if (map && !is_kprobe) {
1763                 dso__delete(map->dso);
1764                 map__delete(map);
1765         }
1766
1767         return ret;
1768 }
1769
1770 static int convert_to_perf_probe_point(struct probe_trace_point *tp,
1771                                         struct perf_probe_point *pp,
1772                                         bool is_kprobe)
1773 {
1774         char buf[128];
1775         int ret;
1776
1777         ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
1778         if (!ret)
1779                 return 0;
1780         ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
1781         if (!ret)
1782                 return 0;
1783
1784         pr_debug("Failed to find probe point from both of dwarf and map.\n");
1785
1786         if (tp->symbol) {
1787                 pp->function = strdup(tp->symbol);
1788                 pp->offset = tp->offset;
1789         } else if (!tp->module && !is_kprobe) {
1790                 ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
1791                 if (ret < 0)
1792                         return ret;
1793                 pp->function = strdup(buf);
1794                 pp->offset = 0;
1795         }
1796         if (pp->function == NULL)
1797                 return -ENOMEM;
1798
1799         pp->retprobe = tp->retprobe;
1800
1801         return 0;
1802 }
1803
1804 static int convert_to_perf_probe_event(struct probe_trace_event *tev,
1805                                struct perf_probe_event *pev, bool is_kprobe)
1806 {
1807         char buf[64] = "";
1808         int i, ret;
1809
1810         /* Convert event/group name */
1811         pev->event = strdup(tev->event);
1812         pev->group = strdup(tev->group);
1813         if (pev->event == NULL || pev->group == NULL)
1814                 return -ENOMEM;
1815
1816         /* Convert trace_point to probe_point */
1817         ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
1818         if (ret < 0)
1819                 return ret;
1820
1821         /* Convert trace_arg to probe_arg */
1822         pev->nargs = tev->nargs;
1823         pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1824         if (pev->args == NULL)
1825                 return -ENOMEM;
1826         for (i = 0; i < tev->nargs && ret >= 0; i++) {
1827                 if (tev->args[i].name)
1828                         pev->args[i].name = strdup(tev->args[i].name);
1829                 else {
1830                         ret = synthesize_probe_trace_arg(&tev->args[i],
1831                                                           buf, 64);
1832                         pev->args[i].name = strdup(buf);
1833                 }
1834                 if (pev->args[i].name == NULL && ret >= 0)
1835                         ret = -ENOMEM;
1836         }
1837
1838         if (ret < 0)
1839                 clear_perf_probe_event(pev);
1840
1841         return ret;
1842 }
1843
1844 void clear_perf_probe_event(struct perf_probe_event *pev)
1845 {
1846         struct perf_probe_arg_field *field, *next;
1847         int i;
1848
1849         free(pev->event);
1850         free(pev->group);
1851         free(pev->target);
1852         clear_perf_probe_point(&pev->point);
1853
1854         for (i = 0; i < pev->nargs; i++) {
1855                 free(pev->args[i].name);
1856                 free(pev->args[i].var);
1857                 free(pev->args[i].type);
1858                 field = pev->args[i].field;
1859                 while (field) {
1860                         next = field->next;
1861                         zfree(&field->name);
1862                         free(field);
1863                         field = next;
1864                 }
1865         }
1866         free(pev->args);
1867         memset(pev, 0, sizeof(*pev));
1868 }
1869
1870 static void clear_probe_trace_event(struct probe_trace_event *tev)
1871 {
1872         struct probe_trace_arg_ref *ref, *next;
1873         int i;
1874
1875         free(tev->event);
1876         free(tev->group);
1877         free(tev->point.symbol);
1878         free(tev->point.module);
1879         for (i = 0; i < tev->nargs; i++) {
1880                 free(tev->args[i].name);
1881                 free(tev->args[i].value);
1882                 free(tev->args[i].type);
1883                 ref = tev->args[i].ref;
1884                 while (ref) {
1885                         next = ref->next;
1886                         free(ref);
1887                         ref = next;
1888                 }
1889         }
1890         free(tev->args);
1891         memset(tev, 0, sizeof(*tev));
1892 }
1893
1894 static void print_open_warning(int err, bool is_kprobe)
1895 {
1896         char sbuf[STRERR_BUFSIZE];
1897
1898         if (err == -ENOENT) {
1899                 const char *config;
1900
1901                 if (!is_kprobe)
1902                         config = "CONFIG_UPROBE_EVENTS";
1903                 else
1904                         config = "CONFIG_KPROBE_EVENTS";
1905
1906                 pr_warning("%cprobe_events file does not exist"
1907                            " - please rebuild kernel with %s.\n",
1908                            is_kprobe ? 'k' : 'u', config);
1909         } else if (err == -ENOTSUP)
1910                 pr_warning("Tracefs or debugfs is not mounted.\n");
1911         else
1912                 pr_warning("Failed to open %cprobe_events: %s\n",
1913                            is_kprobe ? 'k' : 'u',
1914                            strerror_r(-err, sbuf, sizeof(sbuf)));
1915 }
1916
1917 static void print_both_open_warning(int kerr, int uerr)
1918 {
1919         /* Both kprobes and uprobes are disabled, warn it. */
1920         if (kerr == -ENOTSUP && uerr == -ENOTSUP)
1921                 pr_warning("Tracefs or debugfs is not mounted.\n");
1922         else if (kerr == -ENOENT && uerr == -ENOENT)
1923                 pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS "
1924                            "or/and CONFIG_UPROBE_EVENTS.\n");
1925         else {
1926                 char sbuf[STRERR_BUFSIZE];
1927                 pr_warning("Failed to open kprobe events: %s.\n",
1928                            strerror_r(-kerr, sbuf, sizeof(sbuf)));
1929                 pr_warning("Failed to open uprobe events: %s.\n",
1930                            strerror_r(-uerr, sbuf, sizeof(sbuf)));
1931         }
1932 }
1933
1934 static int open_probe_events(const char *trace_file, bool readwrite)
1935 {
1936         char buf[PATH_MAX];
1937         const char *__debugfs;
1938         const char *tracing_dir = "";
1939         int ret;
1940
1941         __debugfs = tracefs_find_mountpoint();
1942         if (__debugfs == NULL) {
1943                 tracing_dir = "tracing/";
1944
1945                 __debugfs = debugfs_find_mountpoint();
1946                 if (__debugfs == NULL)
1947                         return -ENOTSUP;
1948         }
1949
1950         ret = e_snprintf(buf, PATH_MAX, "%s/%s%s",
1951                          __debugfs, tracing_dir, trace_file);
1952         if (ret >= 0) {
1953                 pr_debug("Opening %s write=%d\n", buf, readwrite);
1954                 if (readwrite && !probe_event_dry_run)
1955                         ret = open(buf, O_RDWR, O_APPEND);
1956                 else
1957                         ret = open(buf, O_RDONLY, 0);
1958
1959                 if (ret < 0)
1960                         ret = -errno;
1961         }
1962         return ret;
1963 }
1964
1965 static int open_kprobe_events(bool readwrite)
1966 {
1967         return open_probe_events("kprobe_events", readwrite);
1968 }
1969
1970 static int open_uprobe_events(bool readwrite)
1971 {
1972         return open_probe_events("uprobe_events", readwrite);
1973 }
1974
1975 /* Get raw string list of current kprobe_events  or uprobe_events */
1976 static struct strlist *get_probe_trace_command_rawlist(int fd)
1977 {
1978         int ret, idx;
1979         FILE *fp;
1980         char buf[MAX_CMDLEN];
1981         char *p;
1982         struct strlist *sl;
1983
1984         sl = strlist__new(true, NULL);
1985
1986         fp = fdopen(dup(fd), "r");
1987         while (!feof(fp)) {
1988                 p = fgets(buf, MAX_CMDLEN, fp);
1989                 if (!p)
1990                         break;
1991
1992                 idx = strlen(p) - 1;
1993                 if (p[idx] == '\n')
1994                         p[idx] = '\0';
1995                 ret = strlist__add(sl, buf);
1996                 if (ret < 0) {
1997                         pr_debug("strlist__add failed (%d)\n", ret);
1998                         strlist__delete(sl);
1999                         return NULL;
2000                 }
2001         }
2002         fclose(fp);
2003
2004         return sl;
2005 }
2006
2007 struct kprobe_blacklist_node {
2008         struct list_head list;
2009         unsigned long start;
2010         unsigned long end;
2011         char *symbol;
2012 };
2013
2014 static void kprobe_blacklist__delete(struct list_head *blacklist)
2015 {
2016         struct kprobe_blacklist_node *node;
2017
2018         while (!list_empty(blacklist)) {
2019                 node = list_first_entry(blacklist,
2020                                         struct kprobe_blacklist_node, list);
2021                 list_del(&node->list);
2022                 free(node->symbol);
2023                 free(node);
2024         }
2025 }
2026
2027 static int kprobe_blacklist__load(struct list_head *blacklist)
2028 {
2029         struct kprobe_blacklist_node *node;
2030         const char *__debugfs = debugfs_find_mountpoint();
2031         char buf[PATH_MAX], *p;
2032         FILE *fp;
2033         int ret;
2034
2035         if (__debugfs == NULL)
2036                 return -ENOTSUP;
2037
2038         ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
2039         if (ret < 0)
2040                 return ret;
2041
2042         fp = fopen(buf, "r");
2043         if (!fp)
2044                 return -errno;
2045
2046         ret = 0;
2047         while (fgets(buf, PATH_MAX, fp)) {
2048                 node = zalloc(sizeof(*node));
2049                 if (!node) {
2050                         ret = -ENOMEM;
2051                         break;
2052                 }
2053                 INIT_LIST_HEAD(&node->list);
2054                 list_add_tail(&node->list, blacklist);
2055                 if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
2056                         ret = -EINVAL;
2057                         break;
2058                 }
2059                 p = strchr(buf, '\t');
2060                 if (p) {
2061                         p++;
2062                         if (p[strlen(p) - 1] == '\n')
2063                                 p[strlen(p) - 1] = '\0';
2064                 } else
2065                         p = (char *)"unknown";
2066                 node->symbol = strdup(p);
2067                 if (!node->symbol) {
2068                         ret = -ENOMEM;
2069                         break;
2070                 }
2071                 pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
2072                           node->start, node->end, node->symbol);
2073                 ret++;
2074         }
2075         if (ret < 0)
2076                 kprobe_blacklist__delete(blacklist);
2077         fclose(fp);
2078
2079         return ret;
2080 }
2081
2082 static struct kprobe_blacklist_node *
2083 kprobe_blacklist__find_by_address(struct list_head *blacklist,
2084                                   unsigned long address)
2085 {
2086         struct kprobe_blacklist_node *node;
2087
2088         list_for_each_entry(node, blacklist, list) {
2089                 if (node->start <= address && address <= node->end)
2090                         return node;
2091         }
2092
2093         return NULL;
2094 }
2095
2096 /* Show an event */
2097 static int show_perf_probe_event(struct perf_probe_event *pev,
2098                                  const char *module)
2099 {
2100         int i, ret;
2101         char buf[128];
2102         char *place;
2103
2104         /* Synthesize only event probe point */
2105         place = synthesize_perf_probe_point(&pev->point);
2106         if (!place)
2107                 return -EINVAL;
2108
2109         ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
2110         if (ret < 0)
2111                 return ret;
2112
2113         pr_info("  %-20s (on %s", buf, place);
2114         if (module)
2115                 pr_info(" in %s", module);
2116
2117         if (pev->nargs > 0) {
2118                 pr_info(" with");
2119                 for (i = 0; i < pev->nargs; i++) {
2120                         ret = synthesize_perf_probe_arg(&pev->args[i],
2121                                                         buf, 128);
2122                         if (ret < 0)
2123                                 break;
2124                         pr_info(" %s", buf);
2125                 }
2126         }
2127         pr_info(")\n");
2128         free(place);
2129         return ret;
2130 }
2131
2132 static int __show_perf_probe_events(int fd, bool is_kprobe)
2133 {
2134         int ret = 0;
2135         struct probe_trace_event tev;
2136         struct perf_probe_event pev;
2137         struct strlist *rawlist;
2138         struct str_node *ent;
2139
2140         memset(&tev, 0, sizeof(tev));
2141         memset(&pev, 0, sizeof(pev));
2142
2143         rawlist = get_probe_trace_command_rawlist(fd);
2144         if (!rawlist)
2145                 return -ENOMEM;
2146
2147         strlist__for_each(ent, rawlist) {
2148                 ret = parse_probe_trace_command(ent->s, &tev);
2149                 if (ret >= 0) {
2150                         ret = convert_to_perf_probe_event(&tev, &pev,
2151                                                                 is_kprobe);
2152                         if (ret >= 0)
2153                                 ret = show_perf_probe_event(&pev,
2154                                                             tev.point.module);
2155                 }
2156                 clear_perf_probe_event(&pev);
2157                 clear_probe_trace_event(&tev);
2158                 if (ret < 0)
2159                         break;
2160         }
2161         strlist__delete(rawlist);
2162
2163         return ret;
2164 }
2165
2166 /* List up current perf-probe events */
2167 int show_perf_probe_events(void)
2168 {
2169         int kp_fd, up_fd, ret;
2170
2171         setup_pager();
2172
2173         ret = init_symbol_maps(false);
2174         if (ret < 0)
2175                 return ret;
2176
2177         kp_fd = open_kprobe_events(false);
2178         if (kp_fd >= 0) {
2179                 ret = __show_perf_probe_events(kp_fd, true);
2180                 close(kp_fd);
2181                 if (ret < 0)
2182                         goto out;
2183         }
2184
2185         up_fd = open_uprobe_events(false);
2186         if (kp_fd < 0 && up_fd < 0) {
2187                 print_both_open_warning(kp_fd, up_fd);
2188                 ret = kp_fd;
2189                 goto out;
2190         }
2191
2192         if (up_fd >= 0) {
2193                 ret = __show_perf_probe_events(up_fd, false);
2194                 close(up_fd);
2195         }
2196 out:
2197         exit_symbol_maps();
2198         return ret;
2199 }
2200
2201 /* Get current perf-probe event names */
2202 static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
2203 {
2204         char buf[128];
2205         struct strlist *sl, *rawlist;
2206         struct str_node *ent;
2207         struct probe_trace_event tev;
2208         int ret = 0;
2209
2210         memset(&tev, 0, sizeof(tev));
2211         rawlist = get_probe_trace_command_rawlist(fd);
2212         if (!rawlist)
2213                 return NULL;
2214         sl = strlist__new(true, NULL);
2215         strlist__for_each(ent, rawlist) {
2216                 ret = parse_probe_trace_command(ent->s, &tev);
2217                 if (ret < 0)
2218                         break;
2219                 if (include_group) {
2220                         ret = e_snprintf(buf, 128, "%s:%s", tev.group,
2221                                         tev.event);
2222                         if (ret >= 0)
2223                                 ret = strlist__add(sl, buf);
2224                 } else
2225                         ret = strlist__add(sl, tev.event);
2226                 clear_probe_trace_event(&tev);
2227                 if (ret < 0)
2228                         break;
2229         }
2230         strlist__delete(rawlist);
2231
2232         if (ret < 0) {
2233                 strlist__delete(sl);
2234                 return NULL;
2235         }
2236         return sl;
2237 }
2238
2239 static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
2240 {
2241         int ret = 0;
2242         char *buf = synthesize_probe_trace_command(tev);
2243         char sbuf[STRERR_BUFSIZE];
2244
2245         if (!buf) {
2246                 pr_debug("Failed to synthesize probe trace event.\n");
2247                 return -EINVAL;
2248         }
2249
2250         pr_debug("Writing event: %s\n", buf);
2251         if (!probe_event_dry_run) {
2252                 ret = write(fd, buf, strlen(buf));
2253                 if (ret <= 0) {
2254                         ret = -errno;
2255                         pr_warning("Failed to write event: %s\n",
2256                                    strerror_r(errno, sbuf, sizeof(sbuf)));
2257                 }
2258         }
2259         free(buf);
2260         return ret;
2261 }
2262
2263 static int get_new_event_name(char *buf, size_t len, const char *base,
2264                               struct strlist *namelist, bool allow_suffix)
2265 {
2266         int i, ret;
2267
2268         /* Try no suffix */
2269         ret = e_snprintf(buf, len, "%s", base);
2270         if (ret < 0) {
2271                 pr_debug("snprintf() failed: %d\n", ret);
2272                 return ret;
2273         }
2274         if (!strlist__has_entry(namelist, buf))
2275                 return 0;
2276
2277         if (!allow_suffix) {
2278                 pr_warning("Error: event \"%s\" already exists. "
2279                            "(Use -f to force duplicates.)\n", base);
2280                 return -EEXIST;
2281         }
2282
2283         /* Try to add suffix */
2284         for (i = 1; i < MAX_EVENT_INDEX; i++) {
2285                 ret = e_snprintf(buf, len, "%s_%d", base, i);
2286                 if (ret < 0) {
2287                         pr_debug("snprintf() failed: %d\n", ret);
2288                         return ret;
2289                 }
2290                 if (!strlist__has_entry(namelist, buf))
2291                         break;
2292         }
2293         if (i == MAX_EVENT_INDEX) {
2294                 pr_warning("Too many events are on the same function.\n");
2295                 ret = -ERANGE;
2296         }
2297
2298         return ret;
2299 }
2300
2301 /* Warn if the current kernel's uprobe implementation is old */
2302 static void warn_uprobe_event_compat(struct probe_trace_event *tev)
2303 {
2304         int i;
2305         char *buf = synthesize_probe_trace_command(tev);
2306
2307         /* Old uprobe event doesn't support memory dereference */
2308         if (!tev->uprobes || tev->nargs == 0 || !buf)
2309                 goto out;
2310
2311         for (i = 0; i < tev->nargs; i++)
2312                 if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
2313                         pr_warning("Please upgrade your kernel to at least "
2314                                    "3.14 to have access to feature %s\n",
2315                                    tev->args[i].value);
2316                         break;
2317                 }
2318 out:
2319         free(buf);
2320 }
2321
2322 static int __add_probe_trace_events(struct perf_probe_event *pev,
2323                                      struct probe_trace_event *tevs,
2324                                      int ntevs, bool allow_suffix)
2325 {
2326         int i, fd, ret;
2327         struct probe_trace_event *tev = NULL;
2328         char buf[64];
2329         const char *event, *group;
2330         struct strlist *namelist;
2331         LIST_HEAD(blacklist);
2332         struct kprobe_blacklist_node *node;
2333
2334         if (pev->uprobes)
2335                 fd = open_uprobe_events(true);
2336         else
2337                 fd = open_kprobe_events(true);
2338
2339         if (fd < 0) {
2340                 print_open_warning(fd, !pev->uprobes);
2341                 return fd;
2342         }
2343
2344         /* Get current event names */
2345         namelist = get_probe_trace_event_names(fd, false);
2346         if (!namelist) {
2347                 pr_debug("Failed to get current event list.\n");
2348                 return -EIO;
2349         }
2350         /* Get kprobe blacklist if exists */
2351         if (!pev->uprobes) {
2352                 ret = kprobe_blacklist__load(&blacklist);
2353                 if (ret < 0)
2354                         pr_debug("No kprobe blacklist support, ignored\n");
2355         }
2356
2357         ret = 0;
2358         pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":");
2359         for (i = 0; i < ntevs; i++) {
2360                 tev = &tevs[i];
2361                 /* Ensure that the address is NOT blacklisted */
2362                 node = kprobe_blacklist__find_by_address(&blacklist,
2363                                                          tev->point.address);
2364                 if (node) {
2365                         pr_warning("Warning: Skipped probing on blacklisted function: %s\n", node->symbol);
2366                         continue;
2367                 }
2368
2369                 if (pev->event)
2370                         event = pev->event;
2371                 else
2372                         if (pev->point.function)
2373                                 event = pev->point.function;
2374                         else
2375                                 event = tev->point.symbol;
2376                 if (pev->group)
2377                         group = pev->group;
2378                 else
2379                         group = PERFPROBE_GROUP;
2380
2381                 /* Get an unused new event name */
2382                 ret = get_new_event_name(buf, 64, event,
2383                                          namelist, allow_suffix);
2384                 if (ret < 0)
2385                         break;
2386                 event = buf;
2387
2388                 tev->event = strdup(event);
2389                 tev->group = strdup(group);
2390                 if (tev->event == NULL || tev->group == NULL) {
2391                         ret = -ENOMEM;
2392                         break;
2393                 }
2394                 ret = write_probe_trace_event(fd, tev);
2395                 if (ret < 0)
2396                         break;
2397                 /* Add added event name to namelist */
2398                 strlist__add(namelist, event);
2399
2400                 /* Trick here - save current event/group */
2401                 event = pev->event;
2402                 group = pev->group;
2403                 pev->event = tev->event;
2404                 pev->group = tev->group;
2405                 show_perf_probe_event(pev, tev->point.module);
2406                 /* Trick here - restore current event/group */
2407                 pev->event = (char *)event;
2408                 pev->group = (char *)group;
2409
2410                 /*
2411                  * Probes after the first probe which comes from same
2412                  * user input are always allowed to add suffix, because
2413                  * there might be several addresses corresponding to
2414                  * one code line.
2415                  */
2416                 allow_suffix = true;
2417         }
2418         if (ret == -EINVAL && pev->uprobes)
2419                 warn_uprobe_event_compat(tev);
2420
2421         /* Note that it is possible to skip all events because of blacklist */
2422         if (ret >= 0 && tev->event) {
2423                 /* Show how to use the event. */
2424                 pr_info("\nYou can now use it in all perf tools, such as:\n\n");
2425                 pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
2426                          tev->event);
2427         }
2428
2429         kprobe_blacklist__delete(&blacklist);
2430         strlist__delete(namelist);
2431         close(fd);
2432         return ret;
2433 }
2434
2435 static int find_probe_functions(struct map *map, char *name)
2436 {
2437         int found = 0;
2438         struct symbol *sym;
2439
2440         map__for_each_symbol_by_name(map, name, sym) {
2441                 found++;
2442         }
2443
2444         return found;
2445 }
2446
2447 #define strdup_or_goto(str, label)      \
2448         ({ char *__p = strdup(str); if (!__p) goto label; __p; })
2449
2450 /*
2451  * Find probe function addresses from map.
2452  * Return an error or the number of found probe_trace_event
2453  */
2454 static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2455                                             struct probe_trace_event **tevs,
2456                                             int max_tevs, const char *target)
2457 {
2458         struct map *map = NULL;
2459         struct ref_reloc_sym *reloc_sym = NULL;
2460         struct symbol *sym;
2461         struct probe_trace_event *tev;
2462         struct perf_probe_point *pp = &pev->point;
2463         struct probe_trace_point *tp;
2464         int num_matched_functions;
2465         int ret, i;
2466
2467         map = get_target_map(target, pev->uprobes);
2468         if (!map) {
2469                 ret = -EINVAL;
2470                 goto out;
2471         }
2472
2473         /*
2474          * Load matched symbols: Since the different local symbols may have
2475          * same name but different addresses, this lists all the symbols.
2476          */
2477         num_matched_functions = find_probe_functions(map, pp->function);
2478         if (num_matched_functions == 0) {
2479                 pr_err("Failed to find symbol %s in %s\n", pp->function,
2480                         target ? : "kernel");
2481                 ret = -ENOENT;
2482                 goto out;
2483         } else if (num_matched_functions > max_tevs) {
2484                 pr_err("Too many functions matched in %s\n",
2485                         target ? : "kernel");
2486                 ret = -E2BIG;
2487                 goto out;
2488         }
2489
2490         if (!pev->uprobes && !pp->retprobe) {
2491                 reloc_sym = kernel_get_ref_reloc_sym();
2492                 if (!reloc_sym) {
2493                         pr_warning("Relocated base symbol is not found!\n");
2494                         ret = -EINVAL;
2495                         goto out;
2496                 }
2497         }
2498
2499         /* Setup result trace-probe-events */
2500         *tevs = zalloc(sizeof(*tev) * num_matched_functions);
2501         if (!*tevs) {
2502                 ret = -ENOMEM;
2503                 goto out;
2504         }
2505
2506         ret = 0;
2507
2508         map__for_each_symbol_by_name(map, pp->function, sym) {
2509                 tev = (*tevs) + ret;
2510                 tp = &tev->point;
2511                 if (ret == num_matched_functions) {
2512                         pr_warning("Too many symbols are listed. Skip it.\n");
2513                         break;
2514                 }
2515                 ret++;
2516
2517                 if (pp->offset > sym->end - sym->start) {
2518                         pr_warning("Offset %ld is bigger than the size of %s\n",
2519                                    pp->offset, sym->name);
2520                         ret = -ENOENT;
2521                         goto err_out;
2522                 }
2523                 /* Add one probe point */
2524                 tp->address = map->unmap_ip(map, sym->start) + pp->offset;
2525                 if (reloc_sym) {
2526                         tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
2527                         tp->offset = tp->address - reloc_sym->addr;
2528                 } else {
2529                         tp->symbol = strdup_or_goto(sym->name, nomem_out);
2530                         tp->offset = pp->offset;
2531                 }
2532                 tp->retprobe = pp->retprobe;
2533                 if (target)
2534                         tev->point.module = strdup_or_goto(target, nomem_out);
2535                 tev->uprobes = pev->uprobes;
2536                 tev->nargs = pev->nargs;
2537                 if (tev->nargs) {
2538                         tev->args = zalloc(sizeof(struct probe_trace_arg) *
2539                                            tev->nargs);
2540                         if (tev->args == NULL)
2541                                 goto nomem_out;
2542                 }
2543                 for (i = 0; i < tev->nargs; i++) {
2544                         if (pev->args[i].name)
2545                                 tev->args[i].name =
2546                                         strdup_or_goto(pev->args[i].name,
2547                                                         nomem_out);
2548
2549                         tev->args[i].value = strdup_or_goto(pev->args[i].var,
2550                                                             nomem_out);
2551                         if (pev->args[i].type)
2552                                 tev->args[i].type =
2553                                         strdup_or_goto(pev->args[i].type,
2554                                                         nomem_out);
2555                 }
2556         }
2557
2558 out:
2559         put_target_map(map, pev->uprobes);
2560         return ret;
2561
2562 nomem_out:
2563         ret = -ENOMEM;
2564 err_out:
2565         clear_probe_trace_events(*tevs, num_matched_functions);
2566         zfree(tevs);
2567         goto out;
2568 }
2569
2570 static int convert_to_probe_trace_events(struct perf_probe_event *pev,
2571                                           struct probe_trace_event **tevs,
2572                                           int max_tevs, const char *target)
2573 {
2574         int ret;
2575
2576         if (pev->uprobes && !pev->group) {
2577                 /* Replace group name if not given */
2578                 ret = convert_exec_to_group(target, &pev->group);
2579                 if (ret != 0) {
2580                         pr_warning("Failed to make a group name.\n");
2581                         return ret;
2582                 }
2583         }
2584
2585         /* Convert perf_probe_event with debuginfo */
2586         ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target);
2587         if (ret != 0)
2588                 return ret;     /* Found in debuginfo or got an error */
2589
2590         return find_probe_trace_events_from_map(pev, tevs, max_tevs, target);
2591 }
2592
2593 struct __event_package {
2594         struct perf_probe_event         *pev;
2595         struct probe_trace_event        *tevs;
2596         int                             ntevs;
2597 };
2598
2599 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
2600                           int max_tevs, bool force_add)
2601 {
2602         int i, j, ret;
2603         struct __event_package *pkgs;
2604
2605         ret = 0;
2606         pkgs = zalloc(sizeof(struct __event_package) * npevs);
2607
2608         if (pkgs == NULL)
2609                 return -ENOMEM;
2610
2611         ret = init_symbol_maps(pevs->uprobes);
2612         if (ret < 0) {
2613                 free(pkgs);
2614                 return ret;
2615         }
2616
2617         /* Loop 1: convert all events */
2618         for (i = 0; i < npevs; i++) {
2619                 pkgs[i].pev = &pevs[i];
2620                 /* Convert with or without debuginfo */
2621                 ret  = convert_to_probe_trace_events(pkgs[i].pev,
2622                                                      &pkgs[i].tevs,
2623                                                      max_tevs,
2624                                                      pkgs[i].pev->target);
2625                 if (ret < 0)
2626                         goto end;
2627                 pkgs[i].ntevs = ret;
2628         }
2629
2630         /* Loop 2: add all events */
2631         for (i = 0; i < npevs; i++) {
2632                 ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
2633                                                 pkgs[i].ntevs, force_add);
2634                 if (ret < 0)
2635                         break;
2636         }
2637 end:
2638         /* Loop 3: cleanup and free trace events  */
2639         for (i = 0; i < npevs; i++) {
2640                 for (j = 0; j < pkgs[i].ntevs; j++)
2641                         clear_probe_trace_event(&pkgs[i].tevs[j]);
2642                 zfree(&pkgs[i].tevs);
2643         }
2644         free(pkgs);
2645         exit_symbol_maps();
2646
2647         return ret;
2648 }
2649
2650 static int __del_trace_probe_event(int fd, struct str_node *ent)
2651 {
2652         char *p;
2653         char buf[128];
2654         int ret;
2655
2656         /* Convert from perf-probe event to trace-probe event */
2657         ret = e_snprintf(buf, 128, "-:%s", ent->s);
2658         if (ret < 0)
2659                 goto error;
2660
2661         p = strchr(buf + 2, ':');
2662         if (!p) {
2663                 pr_debug("Internal error: %s should have ':' but not.\n",
2664                          ent->s);
2665                 ret = -ENOTSUP;
2666                 goto error;
2667         }
2668         *p = '/';
2669
2670         pr_debug("Writing event: %s\n", buf);
2671         ret = write(fd, buf, strlen(buf));
2672         if (ret < 0) {
2673                 ret = -errno;
2674                 goto error;
2675         }
2676
2677         pr_info("Removed event: %s\n", ent->s);
2678         return 0;
2679 error:
2680         pr_warning("Failed to delete event: %s\n",
2681                    strerror_r(-ret, buf, sizeof(buf)));
2682         return ret;
2683 }
2684
2685 static int del_trace_probe_event(int fd, const char *buf,
2686                                                   struct strlist *namelist)
2687 {
2688         struct str_node *ent, *n;
2689         int ret = -1;
2690
2691         if (strpbrk(buf, "*?")) { /* Glob-exp */
2692                 strlist__for_each_safe(ent, n, namelist)
2693                         if (strglobmatch(ent->s, buf)) {
2694                                 ret = __del_trace_probe_event(fd, ent);
2695                                 if (ret < 0)
2696                                         break;
2697                                 strlist__remove(namelist, ent);
2698                         }
2699         } else {
2700                 ent = strlist__find(namelist, buf);
2701                 if (ent) {
2702                         ret = __del_trace_probe_event(fd, ent);
2703                         if (ret >= 0)
2704                                 strlist__remove(namelist, ent);
2705                 }
2706         }
2707
2708         return ret;
2709 }
2710
2711 int del_perf_probe_events(struct strlist *dellist)
2712 {
2713         int ret = -1, ufd = -1, kfd = -1;
2714         char buf[128];
2715         const char *group, *event;
2716         char *p, *str;
2717         struct str_node *ent;
2718         struct strlist *namelist = NULL, *unamelist = NULL;
2719
2720         /* Get current event names */
2721         kfd = open_kprobe_events(true);
2722         if (kfd >= 0)
2723                 namelist = get_probe_trace_event_names(kfd, true);
2724
2725         ufd = open_uprobe_events(true);
2726         if (ufd >= 0)
2727                 unamelist = get_probe_trace_event_names(ufd, true);
2728
2729         if (kfd < 0 && ufd < 0) {
2730                 print_both_open_warning(kfd, ufd);
2731                 goto error;
2732         }
2733
2734         if (namelist == NULL && unamelist == NULL)
2735                 goto error;
2736
2737         strlist__for_each(ent, dellist) {
2738                 str = strdup(ent->s);
2739                 if (str == NULL) {
2740                         ret = -ENOMEM;
2741                         goto error;
2742                 }
2743                 pr_debug("Parsing: %s\n", str);
2744                 p = strchr(str, ':');
2745                 if (p) {
2746                         group = str;
2747                         *p = '\0';
2748                         event = p + 1;
2749                 } else {
2750                         group = "*";
2751                         event = str;
2752                 }
2753
2754                 ret = e_snprintf(buf, 128, "%s:%s", group, event);
2755                 if (ret < 0) {
2756                         pr_err("Failed to copy event.");
2757                         free(str);
2758                         goto error;
2759                 }
2760
2761                 pr_debug("Group: %s, Event: %s\n", group, event);
2762
2763                 if (namelist)
2764                         ret = del_trace_probe_event(kfd, buf, namelist);
2765
2766                 if (unamelist && ret != 0)
2767                         ret = del_trace_probe_event(ufd, buf, unamelist);
2768
2769                 if (ret != 0)
2770                         pr_info("Info: Event \"%s\" does not exist.\n", buf);
2771
2772                 free(str);
2773         }
2774
2775 error:
2776         if (kfd >= 0) {
2777                 strlist__delete(namelist);
2778                 close(kfd);
2779         }
2780
2781         if (ufd >= 0) {
2782                 strlist__delete(unamelist);
2783                 close(ufd);
2784         }
2785
2786         return ret;
2787 }
2788
2789 /* TODO: don't use a global variable for filter ... */
2790 static struct strfilter *available_func_filter;
2791
2792 /*
2793  * If a symbol corresponds to a function with global binding and
2794  * matches filter return 0. For all others return 1.
2795  */
2796 static int filter_available_functions(struct map *map __maybe_unused,
2797                                       struct symbol *sym)
2798 {
2799         if (strfilter__compare(available_func_filter, sym->name))
2800                 return 0;
2801         return 1;
2802 }
2803
2804 int show_available_funcs(const char *target, struct strfilter *_filter,
2805                                         bool user)
2806 {
2807         struct map *map;
2808         int ret;
2809
2810         ret = init_symbol_maps(user);
2811         if (ret < 0)
2812                 return ret;
2813
2814         /* Get a symbol map */
2815         if (user)
2816                 map = dso__new_map(target);
2817         else
2818                 map = kernel_get_module_map(target);
2819         if (!map) {
2820                 pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
2821                 return -EINVAL;
2822         }
2823
2824         /* Load symbols with given filter */
2825         available_func_filter = _filter;
2826         if (map__load(map, filter_available_functions)) {
2827                 pr_err("Failed to load symbols in %s\n", (target) ? : "kernel");
2828                 goto end;
2829         }
2830         if (!dso__sorted_by_name(map->dso, map->type))
2831                 dso__sort_by_name(map->dso, map->type);
2832
2833         /* Show all (filtered) symbols */
2834         setup_pager();
2835         dso__fprintf_symbols_by_name(map->dso, map->type, stdout);
2836 end:
2837         if (user) {
2838                 dso__delete(map->dso);
2839                 map__delete(map);
2840         }
2841         exit_symbol_maps();
2842
2843         return ret;
2844 }
2845