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