tools/perf/util/probe-event.c

   1 /*
   2  * probe-event.c : perf-probe definition to kprobe_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 #define _GNU_SOURCE
  23 #include <sys/utsname.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <errno.h>
  28 #include <stdio.h>
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <stdarg.h>
  33 #include <limits.h>
  34
  35 #undef _GNU_SOURCE
  36 #include "util.h"
  37 #include "event.h"
  38 #include "string.h"
  39 #include "strlist.h"
  40 #include "debug.h"
  41 #include "cache.h"
  42 #include "color.h"
  43 #include "symbol.h"
  44 #include "thread.h"
  45 #include "debugfs.h"
  46 #include "trace-event.h"        /* For __unused */
  47 #include "probe-event.h"
  48 #include "probe-finder.h"
  49
  50 #define MAX_CMDLEN 256
  51 #define MAX_PROBE_ARGS 128
  52 #define PERFPROBE_GROUP "probe"
  53
  54 bool probe_event_dry_run;       /* Dry run flag */
  55
  56 #define semantic_error(msg ...) pr_err("Semantic error :" msg)
  57
  58 /* If there is no space to write, returns -E2BIG. */
  59 static int e_snprintf(char *str, size_t size, const char *format, ...)
  60         __attribute__((format(printf, 3, 4)));
  61
  62 static int e_snprintf(char *str, size_t size, const char *format, ...)
  63 {
  64         int ret;
  65         va_list ap;
  66         va_start(ap, format);
  67         ret = vsnprintf(str, size, format, ap);
  68         va_end(ap);
  69         if (ret >= (int)size)
  70                 ret = -E2BIG;
  71         return ret;
  72 }
  73
  74 static char *synthesize_perf_probe_point(struct perf_probe_point *pp);
  75 static struct map_groups kmap_groups;
  76 static struct map *kmaps[MAP__NR_TYPES];
  77
  78 /* Initialize symbol maps and path of vmlinux */
  79 static int init_vmlinux(void)
  80 {
  81         struct dso *kernel;
  82         int ret;
  83
  84         symbol_conf.sort_by_name = true;
  85         if (symbol_conf.vmlinux_name == NULL)
  86                 symbol_conf.try_vmlinux_path = true;
  87         else
  88                 pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
  89         ret = symbol__init();
  90         if (ret < 0) {
  91                 pr_debug("Failed to init symbol map.\n");
  92                 goto out;
  93         }
  94
  95         kernel = dso__new_kernel(symbol_conf.vmlinux_name);
  96         if (kernel == NULL)
  97                 die("Failed to create kernel dso.");
  98
  99         map_groups__init(&kmap_groups);
 100         ret = __map_groups__create_kernel_maps(&kmap_groups, kmaps, kernel);
 101         if (ret < 0)
 102                 pr_debug("Failed to create kernel maps.\n");
 103
 104 out:
 105         if (ret < 0)
 106                 pr_warning("Failed to init vmlinux path.\n");
 107         return ret;
 108 }
 109
 110 #ifdef DWARF_SUPPORT
 111 static int open_vmlinux(void)
 112 {
 113         if (map__load(kmaps[MAP__FUNCTION], NULL) < 0) {
 114                 pr_debug("Failed to load kernel map.\n");
 115                 return -EINVAL;
 116         }
 117         pr_debug("Try to open %s\n", kmaps[MAP__FUNCTION]->dso->long_name);
 118         return open(kmaps[MAP__FUNCTION]->dso->long_name, O_RDONLY);
 119 }
 120
 121 /* Convert trace point to probe point with debuginfo */
 122 static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
 123                                        struct perf_probe_point *pp)
 124 {
 125         struct symbol *sym;
 126         int fd, ret = -ENOENT;
 127
 128         sym = map__find_symbol_by_name(kmaps[MAP__FUNCTION],
 129                                        tp->symbol, NULL);
 130         if (sym) {
 131                 fd = open_vmlinux();
 132                 if (fd >= 0) {
 133                         ret = find_perf_probe_point(fd,
 134                                                  sym->start + tp->offset, pp);
 135                         close(fd);
 136                 }
 137         }
 138         if (ret <= 0) {
 139                 pr_debug("Failed to find corresponding probes from "
 140                          "debuginfo. Use kprobe event information.\n");
 141                 pp->function = strdup(tp->symbol);
 142                 if (pp->function == NULL)
 143                         return -ENOMEM;
 144                 pp->offset = tp->offset;
 145         }
 146         pp->retprobe = tp->retprobe;
 147
 148         return 0;
 149 }
 150
 151 /* Try to find perf_probe_event with debuginfo */
 152 static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
 153                                            struct kprobe_trace_event **tevs,
 154                                            int max_tevs)
 155 {
 156         bool need_dwarf = perf_probe_event_need_dwarf(pev);
 157         int fd, ntevs;
 158
 159         fd = open_vmlinux();
 160         if (fd < 0) {
 161                 if (need_dwarf) {
 162                         pr_warning("Failed to open debuginfo file.\n");
 163                         return fd;
 164                 }
 165                 pr_debug("Could not open vmlinux. Try to use symbols.\n");
 166                 return 0;
 167         }
 168
 169         /* Searching trace events corresponding to probe event */
 170         ntevs = find_kprobe_trace_events(fd, pev, tevs, max_tevs);
 171         close(fd);
 172
 173         if (ntevs > 0) {        /* Succeeded to find trace events */
 174                 pr_debug("find %d kprobe_trace_events.\n", ntevs);
 175                 return ntevs;
 176         }
 177
 178         if (ntevs == 0) {       /* No error but failed to find probe point. */
 179                 pr_warning("Probe point '%s' not found.\n",
 180                            synthesize_perf_probe_point(&pev->point));
 181                 return -ENOENT;
 182         }
 183         /* Error path : ntevs < 0 */
 184         pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
 185         if (ntevs == -EBADF) {
 186                 pr_warning("Warning: No dwarf info found in the vmlinux - "
 187                         "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
 188                 if (!need_dwarf) {
 189                         pr_debug("Trying to use symbols.\nn");
 190                         return 0;
 191                 }
 192         }
 193         return ntevs;
 194 }
 195
 196 #define LINEBUF_SIZE 256
 197 #define NR_ADDITIONAL_LINES 2
 198
 199 static int show_one_line(FILE *fp, int l, bool skip, bool show_num)
 200 {
 201         char buf[LINEBUF_SIZE];
 202         const char *color = PERF_COLOR_BLUE;
 203
 204         if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
 205                 goto error;
 206         if (!skip) {
 207                 if (show_num)
 208                         fprintf(stdout, "%7d  %s", l, buf);
 209                 else
 210                         color_fprintf(stdout, color, "         %s", buf);
 211         }
 212
 213         while (strlen(buf) == LINEBUF_SIZE - 1 &&
 214                buf[LINEBUF_SIZE - 2] != '\n') {
 215                 if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
 216                         goto error;
 217                 if (!skip) {
 218                         if (show_num)
 219                                 fprintf(stdout, "%s", buf);
 220                         else
 221                                 color_fprintf(stdout, color, "%s", buf);
 222                 }
 223         }
 224
 225         return 0;
 226 error:
 227         if (feof(fp))
 228                 pr_warning("Source file is shorter than expected.\n");
 229         else
 230                 pr_warning("File read error: %s\n", strerror(errno));
 231
 232         return -1;
 233 }
 234
 235 /*
 236  * Show line-range always requires debuginfo to find source file and
 237  * line number.
 238  */
 239 int show_line_range(struct line_range *lr)
 240 {
 241         int l = 1;
 242         struct line_node *ln;
 243         FILE *fp;
 244         int fd, ret;
 245
 246         /* Search a line range */
 247         ret = init_vmlinux();
 248         if (ret < 0)
 249                 return ret;
 250
 251         fd = open_vmlinux();
 252         if (fd < 0) {
 253                 pr_warning("Failed to open debuginfo file.\n");
 254                 return fd;
 255         }
 256
 257         ret = find_line_range(fd, lr);
 258         close(fd);
 259         if (ret == 0) {
 260                 pr_warning("Specified source line is not found.\n");
 261                 return -ENOENT;
 262         } else if (ret < 0) {
 263                 pr_warning("Debuginfo analysis failed. (%d)\n", ret);
 264                 return ret;
 265         }
 266
 267         setup_pager();
 268
 269         if (lr->function)
 270                 fprintf(stdout, "<%s:%d>\n", lr->function,
 271                         lr->start - lr->offset);
 272         else
 273                 fprintf(stdout, "<%s:%d>\n", lr->file, lr->start);
 274
 275         fp = fopen(lr->path, "r");
 276         if (fp == NULL) {
 277                 pr_warning("Failed to open %s: %s\n", lr->path,
 278                            strerror(errno));
 279                 return -errno;
 280         }
 281         /* Skip to starting line number */
 282         while (l < lr->start && ret >= 0)
 283                 ret = show_one_line(fp, l++, true, false);
 284         if (ret < 0)
 285                 goto end;
 286
 287         list_for_each_entry(ln, &lr->line_list, list) {
 288                 while (ln->line > l && ret >= 0)
 289                         ret = show_one_line(fp, (l++) - lr->offset,
 290                                             false, false);
 291                 if (ret >= 0)
 292                         ret = show_one_line(fp, (l++) - lr->offset,
 293                                             false, true);
 294                 if (ret < 0)
 295                         goto end;
 296         }
 297
 298         if (lr->end == INT_MAX)
 299                 lr->end = l + NR_ADDITIONAL_LINES;
 300         while (l <= lr->end && !feof(fp) && ret >= 0)
 301                 ret = show_one_line(fp, (l++) - lr->offset, false, false);
 302 end:
 303         fclose(fp);
 304         return ret;
 305 }
 306
 307 #else   /* !DWARF_SUPPORT */
 308
 309 static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
 310                                         struct perf_probe_point *pp)
 311 {
 312         pp->function = strdup(tp->symbol);
 313         if (pp->function == NULL)
 314                 return -ENOMEM;
 315         pp->offset = tp->offset;
 316         pp->retprobe = tp->retprobe;
 317
 318         return 0;
 319 }
 320
 321 static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
 322                                 struct kprobe_trace_event **tevs __unused,
 323                                 int max_tevs __unused)
 324 {
 325         if (perf_probe_event_need_dwarf(pev)) {
 326                 pr_warning("Debuginfo-analysis is not supported.\n");
 327                 return -ENOSYS;
 328         }
 329         return 0;
 330 }
 331
 332 int show_line_range(struct line_range *lr __unused)
 333 {
 334         pr_warning("Debuginfo-analysis is not supported.\n");
 335         return -ENOSYS;
 336 }
 337
 338 #endif
 339
 340 int parse_line_range_desc(const char *arg, struct line_range *lr)
 341 {
 342         const char *ptr;
 343         char *tmp;
 344         /*
 345          * <Syntax>
 346          * SRC:SLN[+NUM|-ELN]
 347          * FUNC[:SLN[+NUM|-ELN]]
 348          */
 349         ptr = strchr(arg, ':');
 350         if (ptr) {
 351                 lr->start = (int)strtoul(ptr + 1, &tmp, 0);
 352                 if (*tmp == '+') {
 353                         lr->end = lr->start + (int)strtoul(tmp + 1, &tmp, 0);
 354                         lr->end--;      /*
 355                                          * Adjust the number of lines here.
 356                                          * If the number of lines == 1, the
 357                                          * the end of line should be equal to
 358                                          * the start of line.
 359                                          */
 360                 } else if (*tmp == '-')
 361                         lr->end = (int)strtoul(tmp + 1, &tmp, 0);
 362                 else
 363                         lr->end = INT_MAX;
 364                 pr_debug("Line range is %d to %d\n", lr->start, lr->end);
 365                 if (lr->start > lr->end) {
 366                         semantic_error("Start line must be smaller"
 367                                        " than end line.\n");
 368                         return -EINVAL;
 369                 }
 370                 if (*tmp != '\0') {
 371                         semantic_error("Tailing with invalid character '%d'.\n",
 372                                        *tmp);
 373                         return -EINVAL;
 374                 }
 375                 tmp = strndup(arg, (ptr - arg));
 376         } else {
 377                 tmp = strdup(arg);
 378                 lr->end = INT_MAX;
 379         }
 380
 381         if (tmp == NULL)
 382                 return -ENOMEM;
 383
 384         if (strchr(tmp, '.'))
 385                 lr->file = tmp;
 386         else
 387                 lr->function = tmp;
 388
 389         return 0;
 390 }
 391
 392 /* Check the name is good for event/group */
 393 static bool check_event_name(const char *name)
 394 {
 395         if (!isalpha(*name) && *name != '_')
 396                 return false;
 397         while (*++name != '\0') {
 398                 if (!isalpha(*name) && !isdigit(*name) && *name != '_')
 399                         return false;
 400         }
 401         return true;
 402 }
 403
 404 /* Parse probepoint definition. */
 405 static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
 406 {
 407         struct perf_probe_point *pp = &pev->point;
 408         char *ptr, *tmp;
 409         char c, nc = 0;
 410         /*
 411          * <Syntax>
 412          * perf probe [EVENT=]SRC[:LN|;PTN]
 413          * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
 414          *
 415          * TODO:Group name support
 416          */
 417
 418         ptr = strpbrk(arg, ";=@+%");
 419         if (ptr && *ptr == '=') {       /* Event name */
 420                 *ptr = '\0';
 421                 tmp = ptr + 1;
 422                 if (strchr(arg, ':')) {
 423                         semantic_error("Group name is not supported yet.\n");
 424                         return -ENOTSUP;
 425                 }
 426                 if (!check_event_name(arg)) {
 427                         semantic_error("%s is bad for event name -it must "
 428                                        "follow C symbol-naming rule.\n", arg);
 429                         return -EINVAL;
 430                 }
 431                 pev->event = strdup(arg);
 432                 if (pev->event == NULL)
 433                         return -ENOMEM;
 434                 pev->group = NULL;
 435                 arg = tmp;
 436         }
 437
 438         ptr = strpbrk(arg, ";:+@%");
 439         if (ptr) {
 440                 nc = *ptr;
 441                 *ptr++ = '\0';
 442         }
 443
 444         tmp = strdup(arg);
 445         if (tmp == NULL)
 446                 return -ENOMEM;
 447
 448         /* Check arg is function or file and copy it */
 449         if (strchr(tmp, '.'))   /* File */
 450                 pp->file = tmp;
 451         else                    /* Function */
 452                 pp->function = tmp;
 453
 454         /* Parse other options */
 455         while (ptr) {
 456                 arg = ptr;
 457                 c = nc;
 458                 if (c == ';') { /* Lazy pattern must be the last part */
 459                         pp->lazy_line = strdup(arg);
 460                         if (pp->lazy_line == NULL)
 461                                 return -ENOMEM;
 462                         break;
 463                 }
 464                 ptr = strpbrk(arg, ";:+@%");
 465                 if (ptr) {
 466                         nc = *ptr;
 467                         *ptr++ = '\0';
 468                 }
 469                 switch (c) {
 470                 case ':':       /* Line number */
 471                         pp->line = strtoul(arg, &tmp, 0);
 472                         if (*tmp != '\0') {
 473                                 semantic_error("There is non-digit char"
 474                                                " in line number.\n");
 475                                 return -EINVAL;
 476                         }
 477                         break;
 478                 case '+':       /* Byte offset from a symbol */
 479                         pp->offset = strtoul(arg, &tmp, 0);
 480                         if (*tmp != '\0') {
 481                                 semantic_error("There is non-digit character"
 482                                                 " in offset.\n");
 483                                 return -EINVAL;
 484                         }
 485                         break;
 486                 case '@':       /* File name */
 487                         if (pp->file) {
 488                                 semantic_error("SRC@SRC is not allowed.\n");
 489                                 return -EINVAL;
 490                         }
 491                         pp->file = strdup(arg);
 492                         if (pp->file == NULL)
 493                                 return -ENOMEM;
 494                         break;
 495                 case '%':       /* Probe places */
 496                         if (strcmp(arg, "return") == 0) {
 497                                 pp->retprobe = 1;
 498                         } else {        /* Others not supported yet */
 499                                 semantic_error("%%%s is not supported.\n", arg);
 500                                 return -ENOTSUP;
 501                         }
 502                         break;
 503                 default:        /* Buggy case */
 504                         pr_err("This program has a bug at %s:%d.\n",
 505                                 __FILE__, __LINE__);
 506                         return -ENOTSUP;
 507                         break;
 508                 }
 509         }
 510
 511         /* Exclusion check */
 512         if (pp->lazy_line && pp->line) {
 513                 semantic_error("Lazy pattern can't be used with line number.");
 514                 return -EINVAL;
 515         }
 516
 517         if (pp->lazy_line && pp->offset) {
 518                 semantic_error("Lazy pattern can't be used with offset.");
 519                 return -EINVAL;
 520         }
 521
 522         if (pp->line && pp->offset) {
 523                 semantic_error("Offset can't be used with line number.");
 524                 return -EINVAL;
 525         }
 526
 527         if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
 528                 semantic_error("File always requires line number or "
 529                                "lazy pattern.");
 530                 return -EINVAL;
 531         }
 532
 533         if (pp->offset && !pp->function) {
 534                 semantic_error("Offset requires an entry function.");
 535                 return -EINVAL;
 536         }
 537
 538         if (pp->retprobe && !pp->function) {
 539                 semantic_error("Return probe requires an entry function.");
 540                 return -EINVAL;
 541         }
 542
 543         if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
 544                 semantic_error("Offset/Line/Lazy pattern can't be used with "
 545                                "return probe.");
 546                 return -EINVAL;
 547         }
 548
 549         pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
 550                  pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
 551                  pp->lazy_line);
 552         return 0;
 553 }
 554
 555 /* Parse perf-probe event argument */
 556 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
 557 {
 558         char *tmp;
 559         struct perf_probe_arg_field **fieldp;
 560
 561         pr_debug("parsing arg: %s into ", str);
 562
 563         tmp = strchr(str, '=');
 564         if (tmp) {
 565                 arg->name = strndup(str, tmp - str);
 566                 if (arg->name == NULL)
 567                         return -ENOMEM;
 568                 pr_debug("name:%s ", arg->name);
 569                 str = tmp + 1;
 570         }
 571
 572         tmp = strchr(str, ':');
 573         if (tmp) {      /* Type setting */
 574                 *tmp = '\0';
 575                 arg->type = strdup(tmp + 1);
 576                 if (arg->type == NULL)
 577                         return -ENOMEM;
 578                 pr_debug("type:%s ", arg->type);
 579         }
 580
 581         tmp = strpbrk(str, "-.");
 582         if (!is_c_varname(str) || !tmp) {
 583                 /* A variable, register, symbol or special value */
 584                 arg->var = strdup(str);
 585                 if (arg->var == NULL)
 586                         return -ENOMEM;
 587                 pr_debug("%s\n", arg->var);
 588                 return 0;
 589         }
 590
 591         /* Structure fields */
 592         arg->var = strndup(str, tmp - str);
 593         if (arg->var == NULL)
 594                 return -ENOMEM;
 595         pr_debug("%s, ", arg->var);
 596         fieldp = &arg->field;
 597
 598         do {
 599                 *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
 600                 if (*fieldp == NULL)
 601                         return -ENOMEM;
 602                 if (*tmp == '.') {
 603                         str = tmp + 1;
 604                         (*fieldp)->ref = false;
 605                 } else if (tmp[1] == '>') {
 606                         str = tmp + 2;
 607                         (*fieldp)->ref = true;
 608                 } else {
 609                         semantic_error("Argument parse error: %s\n", str);
 610                         return -EINVAL;
 611                 }
 612
 613                 tmp = strpbrk(str, "-.");
 614                 if (tmp) {
 615                         (*fieldp)->name = strndup(str, tmp - str);
 616                         if ((*fieldp)->name == NULL)
 617                                 return -ENOMEM;
 618                         pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
 619                         fieldp = &(*fieldp)->next;
 620                 }
 621         } while (tmp);
 622         (*fieldp)->name = strdup(str);
 623         if ((*fieldp)->name == NULL)
 624                 return -ENOMEM;
 625         pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
 626
 627         /* If no name is specified, set the last field name */
 628         if (!arg->name) {
 629                 arg->name = strdup((*fieldp)->name);
 630                 if (arg->name == NULL)
 631                         return -ENOMEM;
 632         }
 633         return 0;
 634 }
 635
 636 /* Parse perf-probe event command */
 637 int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
 638 {
 639         char **argv;
 640         int argc, i, ret = 0;
 641
 642         argv = argv_split(cmd, &argc);
 643         if (!argv) {
 644                 pr_debug("Failed to split arguments.\n");
 645                 return -ENOMEM;
 646         }
 647         if (argc - 1 > MAX_PROBE_ARGS) {
 648                 semantic_error("Too many probe arguments (%d).\n", argc - 1);
 649                 ret = -ERANGE;
 650                 goto out;
 651         }
 652         /* Parse probe point */
 653         ret = parse_perf_probe_point(argv[0], pev);
 654         if (ret < 0)
 655                 goto out;
 656
 657         /* Copy arguments and ensure return probe has no C argument */
 658         pev->nargs = argc - 1;
 659         pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
 660         if (pev->args == NULL) {
 661                 ret = -ENOMEM;
 662                 goto out;
 663         }
 664         for (i = 0; i < pev->nargs && ret >= 0; i++) {
 665                 ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
 666                 if (ret >= 0 &&
 667                     is_c_varname(pev->args[i].var) && pev->point.retprobe) {
 668                         semantic_error("You can't specify local variable for"
 669                                        " kretprobe.\n");
 670                         ret = -EINVAL;
 671                 }
 672         }
 673 out:
 674         argv_free(argv);
 675
 676         return ret;
 677 }
 678
 679 /* Return true if this perf_probe_event requires debuginfo */
 680 bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
 681 {
 682         int i;
 683
 684         if (pev->point.file || pev->point.line || pev->point.lazy_line)
 685                 return true;
 686
 687         for (i = 0; i < pev->nargs; i++)
 688                 if (is_c_varname(pev->args[i].var))
 689                         return true;
 690
 691         return false;
 692 }
 693
 694 /* Parse kprobe_events event into struct probe_point */
 695 int parse_kprobe_trace_command(const char *cmd, struct kprobe_trace_event *tev)
 696 {
 697         struct kprobe_trace_point *tp = &tev->point;
 698         char pr;
 699         char *p;
 700         int ret, i, argc;
 701         char **argv;
 702
 703         pr_debug("Parsing kprobe_events: %s\n", cmd);
 704         argv = argv_split(cmd, &argc);
 705         if (!argv) {
 706                 pr_debug("Failed to split arguments.\n");
 707                 return -ENOMEM;
 708         }
 709         if (argc < 2) {
 710                 semantic_error("Too few probe arguments.\n");
 711                 ret = -ERANGE;
 712                 goto out;
 713         }
 714
 715         /* Scan event and group name. */
 716         ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
 717                      &pr, (float *)(void *)&tev->group,
 718                      (float *)(void *)&tev->event);
 719         if (ret != 3) {
 720                 semantic_error("Failed to parse event name: %s\n", argv[0]);
 721                 ret = -EINVAL;
 722                 goto out;
 723         }
 724         pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
 725
 726         tp->retprobe = (pr == 'r');
 727
 728         /* Scan function name and offset */
 729         ret = sscanf(argv[1], "%a[^+]+%lu", (float *)(void *)&tp->symbol,
 730                      &tp->offset);
 731         if (ret == 1)
 732                 tp->offset = 0;
 733
 734         tev->nargs = argc - 2;
 735         tev->args = zalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
 736         if (tev->args == NULL) {
 737                 ret = -ENOMEM;
 738                 goto out;
 739         }
 740         for (i = 0; i < tev->nargs; i++) {
 741                 p = strchr(argv[i + 2], '=');
 742                 if (p)  /* We don't need which register is assigned. */
 743                         *p++ = '\0';
 744                 else
 745                         p = argv[i + 2];
 746                 tev->args[i].name = strdup(argv[i + 2]);
 747                 /* TODO: parse regs and offset */
 748                 tev->args[i].value = strdup(p);
 749                 if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
 750                         ret = -ENOMEM;
 751                         goto out;
 752                 }
 753         }
 754         ret = 0;
 755 out:
 756         argv_free(argv);
 757         return ret;
 758 }
 759
 760 /* Compose only probe arg */
 761 int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
 762 {
 763         struct perf_probe_arg_field *field = pa->field;
 764         int ret;
 765         char *tmp = buf;
 766
 767         if (pa->name && pa->var)
 768                 ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var);
 769         else
 770                 ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var);
 771         if (ret <= 0)
 772                 goto error;
 773         tmp += ret;
 774         len -= ret;
 775
 776         while (field) {
 777                 ret = e_snprintf(tmp, len, "%s%s", field->ref ? "->" : ".",
 778                                  field->name);
 779                 if (ret <= 0)
 780                         goto error;
 781                 tmp += ret;
 782                 len -= ret;
 783                 field = field->next;
 784         }
 785
 786         if (pa->type) {
 787                 ret = e_snprintf(tmp, len, ":%s", pa->type);
 788                 if (ret <= 0)
 789                         goto error;
 790                 tmp += ret;
 791                 len -= ret;
 792         }
 793
 794         return tmp - buf;
 795 error:
 796         pr_debug("Failed to synthesize perf probe argument: %s",
 797                  strerror(-ret));
 798         return ret;
 799 }
 800
 801 /* Compose only probe point (not argument) */
 802 static char *synthesize_perf_probe_point(struct perf_probe_point *pp)
 803 {
 804         char *buf, *tmp;
 805         char offs[32] = "", line[32] = "", file[32] = "";
 806         int ret, len;
 807
 808         buf = zalloc(MAX_CMDLEN);
 809         if (buf == NULL) {
 810                 ret = -ENOMEM;
 811                 goto error;
 812         }
 813         if (pp->offset) {
 814                 ret = e_snprintf(offs, 32, "+%lu", pp->offset);
 815                 if (ret <= 0)
 816                         goto error;
 817         }
 818         if (pp->line) {
 819                 ret = e_snprintf(line, 32, ":%d", pp->line);
 820                 if (ret <= 0)
 821                         goto error;
 822         }
 823         if (pp->file) {
 824                 len = strlen(pp->file) - 31;
 825                 if (len < 0)
 826                         len = 0;
 827                 tmp = strchr(pp->file + len, '/');
 828                 if (!tmp)
 829                         tmp = pp->file + len;
 830                 ret = e_snprintf(file, 32, "@%s", tmp + 1);
 831                 if (ret <= 0)
 832                         goto error;
 833         }
 834
 835         if (pp->function)
 836                 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function,
 837                                  offs, pp->retprobe ? "%return" : "", line,
 838                                  file);
 839         else
 840                 ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line);
 841         if (ret <= 0)
 842                 goto error;
 843
 844         return buf;
 845 error:
 846         pr_debug("Failed to synthesize perf probe point: %s",
 847                  strerror(-ret));
 848         if (buf)
 849                 free(buf);
 850         return NULL;
 851 }
 852
 853 #if 0
 854 char *synthesize_perf_probe_command(struct perf_probe_event *pev)
 855 {
 856         char *buf;
 857         int i, len, ret;
 858
 859         buf = synthesize_perf_probe_point(&pev->point);
 860         if (!buf)
 861                 return NULL;
 862
 863         len = strlen(buf);
 864         for (i = 0; i < pev->nargs; i++) {
 865                 ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s",
 866                                  pev->args[i].name);
 867                 if (ret <= 0) {
 868                         free(buf);
 869                         return NULL;
 870                 }
 871                 len += ret;
 872         }
 873
 874         return buf;
 875 }
 876 #endif
 877
 878 static int __synthesize_kprobe_trace_arg_ref(struct kprobe_trace_arg_ref *ref,
 879                                              char **buf, size_t *buflen,
 880                                              int depth)
 881 {
 882         int ret;
 883         if (ref->next) {
 884                 depth = __synthesize_kprobe_trace_arg_ref(ref->next, buf,
 885                                                          buflen, depth + 1);
 886                 if (depth < 0)
 887                         goto out;
 888         }
 889
 890         ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset);
 891         if (ret < 0)
 892                 depth = ret;
 893         else {
 894                 *buf += ret;
 895                 *buflen -= ret;
 896         }
 897 out:
 898         return depth;
 899
 900 }
 901
 902 static int synthesize_kprobe_trace_arg(struct kprobe_trace_arg *arg,
 903                                        char *buf, size_t buflen)
 904 {
 905         int ret, depth = 0;
 906         char *tmp = buf;
 907
 908         /* Argument name or separator */
 909         if (arg->name)
 910                 ret = e_snprintf(buf, buflen, " %s=", arg->name);
 911         else
 912                 ret = e_snprintf(buf, buflen, " ");
 913         if (ret < 0)
 914                 return ret;
 915         buf += ret;
 916         buflen -= ret;
 917
 918         /* Dereferencing arguments */
 919         if (arg->ref) {
 920                 depth = __synthesize_kprobe_trace_arg_ref(arg->ref, &buf,
 921                                                           &buflen, 1);
 922                 if (depth < 0)
 923                         return depth;
 924         }
 925
 926         /* Print argument value */
 927         ret = e_snprintf(buf, buflen, "%s", arg->value);
 928         if (ret < 0)
 929                 return ret;
 930         buf += ret;
 931         buflen -= ret;
 932
 933         /* Closing */
 934         while (depth--) {
 935                 ret = e_snprintf(buf, buflen, ")");
 936                 if (ret < 0)
 937                         return ret;
 938                 buf += ret;
 939                 buflen -= ret;
 940         }
 941         /* Print argument type */
 942         if (arg->type) {
 943                 ret = e_snprintf(buf, buflen, ":%s", arg->type);
 944                 if (ret <= 0)
 945                         return ret;
 946                 buf += ret;
 947         }
 948
 949         return buf - tmp;
 950 }
 951
 952 char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev)
 953 {
 954         struct kprobe_trace_point *tp = &tev->point;
 955         char *buf;
 956         int i, len, ret;
 957
 958         buf = zalloc(MAX_CMDLEN);
 959         if (buf == NULL)
 960                 return NULL;
 961
 962         len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s+%lu",
 963                          tp->retprobe ? 'r' : 'p',
 964                          tev->group, tev->event,
 965                          tp->symbol, tp->offset);
 966         if (len <= 0)
 967                 goto error;
 968
 969         for (i = 0; i < tev->nargs; i++) {
 970                 ret = synthesize_kprobe_trace_arg(&tev->args[i], buf + len,
 971                                                   MAX_CMDLEN - len);
 972                 if (ret <= 0)
 973                         goto error;
 974                 len += ret;
 975         }
 976
 977         return buf;
 978 error:
 979         free(buf);
 980         return NULL;
 981 }
 982
 983 int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
 984                                 struct perf_probe_event *pev)
 985 {
 986         char buf[64] = "";
 987         int i, ret;
 988
 989         /* Convert event/group name */
 990         pev->event = strdup(tev->event);
 991         pev->group = strdup(tev->group);
 992         if (pev->event == NULL || pev->group == NULL)
 993                 return -ENOMEM;
 994
 995         /* Convert trace_point to probe_point */
 996         ret = convert_to_perf_probe_point(&tev->point, &pev->point);
 997         if (ret < 0)
 998                 return ret;
 999
1000         /* Convert trace_arg to probe_arg */
1001         pev->nargs = tev->nargs;
1002         pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1003         if (pev->args == NULL)
1004                 return -ENOMEM;
1005         for (i = 0; i < tev->nargs && ret >= 0; i++) {
1006                 if (tev->args[i].name)
1007                         pev->args[i].name = strdup(tev->args[i].name);
1008                 else {
1009                         ret = synthesize_kprobe_trace_arg(&tev->args[i],
1010                                                           buf, 64);
1011                         pev->args[i].name = strdup(buf);
1012                 }
1013                 if (pev->args[i].name == NULL && ret >= 0)
1014                         ret = -ENOMEM;
1015         }
1016
1017         if (ret < 0)
1018                 clear_perf_probe_event(pev);
1019
1020         return ret;
1021 }
1022
1023 void clear_perf_probe_event(struct perf_probe_event *pev)
1024 {
1025         struct perf_probe_point *pp = &pev->point;
1026         struct perf_probe_arg_field *field, *next;
1027         int i;
1028
1029         if (pev->event)
1030                 free(pev->event);
1031         if (pev->group)
1032                 free(pev->group);
1033         if (pp->file)
1034                 free(pp->file);
1035         if (pp->function)
1036                 free(pp->function);
1037         if (pp->lazy_line)
1038                 free(pp->lazy_line);
1039         for (i = 0; i < pev->nargs; i++) {
1040                 if (pev->args[i].name)
1041                         free(pev->args[i].name);
1042                 if (pev->args[i].var)
1043                         free(pev->args[i].var);
1044                 if (pev->args[i].type)
1045                         free(pev->args[i].type);
1046                 field = pev->args[i].field;
1047                 while (field) {
1048                         next = field->next;
1049                         if (field->name)
1050                                 free(field->name);
1051                         free(field);
1052                         field = next;
1053                 }
1054         }
1055         if (pev->args)
1056                 free(pev->args);
1057         memset(pev, 0, sizeof(*pev));
1058 }
1059
1060 void clear_kprobe_trace_event(struct kprobe_trace_event *tev)
1061 {
1062         struct kprobe_trace_arg_ref *ref, *next;
1063         int i;
1064
1065         if (tev->event)
1066                 free(tev->event);
1067         if (tev->group)
1068                 free(tev->group);
1069         if (tev->point.symbol)
1070                 free(tev->point.symbol);
1071         for (i = 0; i < tev->nargs; i++) {
1072                 if (tev->args[i].name)
1073                         free(tev->args[i].name);
1074                 if (tev->args[i].value)
1075                         free(tev->args[i].value);
1076                 if (tev->args[i].type)
1077                         free(tev->args[i].type);
1078                 ref = tev->args[i].ref;
1079                 while (ref) {
1080                         next = ref->next;
1081                         free(ref);
1082                         ref = next;
1083                 }
1084         }
1085         if (tev->args)
1086                 free(tev->args);
1087         memset(tev, 0, sizeof(*tev));
1088 }
1089
1090 static int open_kprobe_events(bool readwrite)
1091 {
1092         char buf[PATH_MAX];
1093         const char *__debugfs;
1094         int ret;
1095
1096         __debugfs = debugfs_find_mountpoint();
1097         if (__debugfs == NULL) {
1098                 pr_warning("Debugfs is not mounted.\n");
1099                 return -ENOENT;
1100         }
1101
1102         ret = e_snprintf(buf, PATH_MAX, "%stracing/kprobe_events", __debugfs);
1103         if (ret >= 0) {
1104                 pr_debug("Opening %s write=%d\n", buf, readwrite);
1105                 if (readwrite && !probe_event_dry_run)
1106                         ret = open(buf, O_RDWR, O_APPEND);
1107                 else
1108                         ret = open(buf, O_RDONLY, 0);
1109         }
1110
1111         if (ret < 0) {
1112                 if (errno == ENOENT)
1113                         pr_warning("kprobe_events file does not exist - please"
1114                                  " rebuild kernel with CONFIG_KPROBE_EVENT.\n");
1115                 else
1116                         pr_warning("Failed to open kprobe_events file: %s\n",
1117                                    strerror(errno));
1118         }
1119         return ret;
1120 }
1121
1122 /* Get raw string list of current kprobe_events */
1123 static struct strlist *get_kprobe_trace_command_rawlist(int fd)
1124 {
1125         int ret, idx;
1126         FILE *fp;
1127         char buf[MAX_CMDLEN];
1128         char *p;
1129         struct strlist *sl;
1130
1131         sl = strlist__new(true, NULL);
1132
1133         fp = fdopen(dup(fd), "r");
1134         while (!feof(fp)) {
1135                 p = fgets(buf, MAX_CMDLEN, fp);
1136                 if (!p)
1137                         break;
1138
1139                 idx = strlen(p) - 1;
1140                 if (p[idx] == '\n')
1141                         p[idx] = '\0';
1142                 ret = strlist__add(sl, buf);
1143                 if (ret < 0) {
1144                         pr_debug("strlist__add failed: %s\n", strerror(-ret));
1145                         strlist__delete(sl);
1146                         return NULL;
1147                 }
1148         }
1149         fclose(fp);
1150
1151         return sl;
1152 }
1153
1154 /* Show an event */
1155 static int show_perf_probe_event(struct perf_probe_event *pev)
1156 {
1157         int i, ret;
1158         char buf[128];
1159         char *place;
1160
1161         /* Synthesize only event probe point */
1162         place = synthesize_perf_probe_point(&pev->point);
1163         if (!place)
1164                 return -EINVAL;
1165
1166         ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event);
1167         if (ret < 0)
1168                 return ret;
1169
1170         printf("  %-20s (on %s", buf, place);
1171
1172         if (pev->nargs > 0) {
1173                 printf(" with");
1174                 for (i = 0; i < pev->nargs; i++) {
1175                         ret = synthesize_perf_probe_arg(&pev->args[i],
1176                                                         buf, 128);
1177                         if (ret < 0)
1178                                 break;
1179                         printf(" %s", buf);
1180                 }
1181         }
1182         printf(")\n");
1183         free(place);
1184         return ret;
1185 }
1186
1187 /* List up current perf-probe events */
1188 int show_perf_probe_events(void)
1189 {
1190         int fd, ret;
1191         struct kprobe_trace_event tev;
1192         struct perf_probe_event pev;
1193         struct strlist *rawlist;
1194         struct str_node *ent;
1195
1196         setup_pager();
1197         ret = init_vmlinux();
1198         if (ret < 0)
1199                 return ret;
1200
1201         memset(&tev, 0, sizeof(tev));
1202         memset(&pev, 0, sizeof(pev));
1203
1204         fd = open_kprobe_events(false);
1205         if (fd < 0)
1206                 return fd;
1207
1208         rawlist = get_kprobe_trace_command_rawlist(fd);
1209         close(fd);
1210         if (!rawlist)
1211                 return -ENOENT;
1212
1213         strlist__for_each(ent, rawlist) {
1214                 ret = parse_kprobe_trace_command(ent->s, &tev);
1215                 if (ret >= 0) {
1216                         ret = convert_to_perf_probe_event(&tev, &pev);
1217                         if (ret >= 0)
1218                                 ret = show_perf_probe_event(&pev);
1219                 }
1220                 clear_perf_probe_event(&pev);
1221                 clear_kprobe_trace_event(&tev);
1222                 if (ret < 0)
1223                         break;
1224         }
1225         strlist__delete(rawlist);
1226
1227         return ret;
1228 }
1229
1230 /* Get current perf-probe event names */
1231 static struct strlist *get_kprobe_trace_event_names(int fd, bool include_group)
1232 {
1233         char buf[128];
1234         struct strlist *sl, *rawlist;
1235         struct str_node *ent;
1236         struct kprobe_trace_event tev;
1237         int ret = 0;
1238
1239         memset(&tev, 0, sizeof(tev));
1240
1241         rawlist = get_kprobe_trace_command_rawlist(fd);
1242         sl = strlist__new(true, NULL);
1243         strlist__for_each(ent, rawlist) {
1244                 ret = parse_kprobe_trace_command(ent->s, &tev);
1245                 if (ret < 0)
1246                         break;
1247                 if (include_group) {
1248                         ret = e_snprintf(buf, 128, "%s:%s", tev.group,
1249                                         tev.event);
1250                         if (ret >= 0)
1251                                 ret = strlist__add(sl, buf);
1252                 } else
1253                         ret = strlist__add(sl, tev.event);
1254                 clear_kprobe_trace_event(&tev);
1255                 if (ret < 0)
1256                         break;
1257         }
1258         strlist__delete(rawlist);
1259
1260         if (ret < 0) {
1261                 strlist__delete(sl);
1262                 return NULL;
1263         }
1264         return sl;
1265 }
1266
1267 static int write_kprobe_trace_event(int fd, struct kprobe_trace_event *tev)
1268 {
1269         int ret = 0;
1270         char *buf = synthesize_kprobe_trace_command(tev);
1271
1272         if (!buf) {
1273                 pr_debug("Failed to synthesize kprobe trace event.\n");
1274                 return -EINVAL;
1275         }
1276
1277         pr_debug("Writing event: %s\n", buf);
1278         if (!probe_event_dry_run) {
1279                 ret = write(fd, buf, strlen(buf));
1280                 if (ret <= 0)
1281                         pr_warning("Failed to write event: %s\n",
1282                                    strerror(errno));
1283         }
1284         free(buf);
1285         return ret;
1286 }
1287
1288 static int get_new_event_name(char *buf, size_t len, const char *base,
1289                               struct strlist *namelist, bool allow_suffix)
1290 {
1291         int i, ret;
1292
1293         /* Try no suffix */
1294         ret = e_snprintf(buf, len, "%s", base);
1295         if (ret < 0) {
1296                 pr_debug("snprintf() failed: %s\n", strerror(-ret));
1297                 return ret;
1298         }
1299         if (!strlist__has_entry(namelist, buf))
1300                 return 0;
1301
1302         if (!allow_suffix) {
1303                 pr_warning("Error: event \"%s\" already exists. "
1304                            "(Use -f to force duplicates.)\n", base);
1305                 return -EEXIST;
1306         }
1307
1308         /* Try to add suffix */
1309         for (i = 1; i < MAX_EVENT_INDEX; i++) {
1310                 ret = e_snprintf(buf, len, "%s_%d", base, i);
1311                 if (ret < 0) {
1312                         pr_debug("snprintf() failed: %s\n", strerror(-ret));
1313                         return ret;
1314                 }
1315                 if (!strlist__has_entry(namelist, buf))
1316                         break;
1317         }
1318         if (i == MAX_EVENT_INDEX) {
1319                 pr_warning("Too many events are on the same function.\n");
1320                 ret = -ERANGE;
1321         }
1322
1323         return ret;
1324 }
1325
1326 static int __add_kprobe_trace_events(struct perf_probe_event *pev,
1327                                      struct kprobe_trace_event *tevs,
1328                                      int ntevs, bool allow_suffix)
1329 {
1330         int i, fd, ret;
1331         struct kprobe_trace_event *tev = NULL;
1332         char buf[64];
1333         const char *event, *group;
1334         struct strlist *namelist;
1335
1336         fd = open_kprobe_events(true);
1337         if (fd < 0)
1338                 return fd;
1339         /* Get current event names */
1340         namelist = get_kprobe_trace_event_names(fd, false);
1341         if (!namelist) {
1342                 pr_debug("Failed to get current event list.\n");
1343                 return -EIO;
1344         }
1345
1346         ret = 0;
1347         printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":");
1348         for (i = 0; i < ntevs; i++) {
1349                 tev = &tevs[i];
1350                 if (pev->event)
1351                         event = pev->event;
1352                 else
1353                         if (pev->point.function)
1354                                 event = pev->point.function;
1355                         else
1356                                 event = tev->point.symbol;
1357                 if (pev->group)
1358                         group = pev->group;
1359                 else
1360                         group = PERFPROBE_GROUP;
1361
1362                 /* Get an unused new event name */
1363                 ret = get_new_event_name(buf, 64, event,
1364                                          namelist, allow_suffix);
1365                 if (ret < 0)
1366                         break;
1367                 event = buf;
1368
1369                 tev->event = strdup(event);
1370                 tev->group = strdup(group);
1371                 if (tev->event == NULL || tev->group == NULL) {
1372                         ret = -ENOMEM;
1373                         break;
1374                 }
1375                 ret = write_kprobe_trace_event(fd, tev);
1376                 if (ret < 0)
1377                         break;
1378                 /* Add added event name to namelist */
1379                 strlist__add(namelist, event);
1380
1381                 /* Trick here - save current event/group */
1382                 event = pev->event;
1383                 group = pev->group;
1384                 pev->event = tev->event;
1385                 pev->group = tev->group;
1386                 show_perf_probe_event(pev);
1387                 /* Trick here - restore current event/group */
1388                 pev->event = (char *)event;
1389                 pev->group = (char *)group;
1390
1391                 /*
1392                  * Probes after the first probe which comes from same
1393                  * user input are always allowed to add suffix, because
1394                  * there might be several addresses corresponding to
1395                  * one code line.
1396                  */
1397                 allow_suffix = true;
1398         }
1399
1400         if (ret >= 0) {
1401                 /* Show how to use the event. */
1402                 printf("\nYou can now use it on all perf tools, such as:\n\n");
1403                 printf("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group,
1404                          tev->event);
1405         }
1406
1407         strlist__delete(namelist);
1408         close(fd);
1409         return ret;
1410 }
1411
1412 static int convert_to_kprobe_trace_events(struct perf_probe_event *pev,
1413                                           struct kprobe_trace_event **tevs,
1414                                           int max_tevs)
1415 {
1416         struct symbol *sym;
1417         int ret = 0, i;
1418         struct kprobe_trace_event *tev;
1419
1420         /* Convert perf_probe_event with debuginfo */
1421         ret = try_to_find_kprobe_trace_events(pev, tevs, max_tevs);
1422         if (ret != 0)
1423                 return ret;
1424
1425         /* Allocate trace event buffer */
1426         tev = *tevs = zalloc(sizeof(struct kprobe_trace_event));
1427         if (tev == NULL)
1428                 return -ENOMEM;
1429
1430         /* Copy parameters */
1431         tev->point.symbol = strdup(pev->point.function);
1432         if (tev->point.symbol == NULL) {
1433                 ret = -ENOMEM;
1434                 goto error;
1435         }
1436         tev->point.offset = pev->point.offset;
1437         tev->nargs = pev->nargs;
1438         if (tev->nargs) {
1439                 tev->args = zalloc(sizeof(struct kprobe_trace_arg)
1440                                    * tev->nargs);
1441                 if (tev->args == NULL) {
1442                         ret = -ENOMEM;
1443                         goto error;
1444                 }
1445                 for (i = 0; i < tev->nargs; i++) {
1446                         if (pev->args[i].name) {
1447                                 tev->args[i].name = strdup(pev->args[i].name);
1448                                 if (tev->args[i].name == NULL) {
1449                                         ret = -ENOMEM;
1450                                         goto error;
1451                                 }
1452                         }
1453                         tev->args[i].value = strdup(pev->args[i].var);
1454                         if (tev->args[i].value == NULL) {
1455                                 ret = -ENOMEM;
1456                                 goto error;
1457                         }
1458                         if (pev->args[i].type) {
1459                                 tev->args[i].type = strdup(pev->args[i].type);
1460                                 if (tev->args[i].type == NULL) {
1461                                         ret = -ENOMEM;
1462                                         goto error;
1463                                 }
1464                         }
1465                 }
1466         }
1467
1468         /* Currently just checking function name from symbol map */
1469         sym = map__find_symbol_by_name(kmaps[MAP__FUNCTION],
1470                                        tev->point.symbol, NULL);
1471         if (!sym) {
1472                 pr_warning("Kernel symbol \'%s\' not found.\n",
1473                            tev->point.symbol);
1474                 ret = -ENOENT;
1475                 goto error;
1476         }
1477
1478         return 1;
1479 error:
1480         clear_kprobe_trace_event(tev);
1481         free(tev);
1482         *tevs = NULL;
1483         return ret;
1484 }
1485
1486 struct __event_package {
1487         struct perf_probe_event         *pev;
1488         struct kprobe_trace_event       *tevs;
1489         int                             ntevs;
1490 };
1491
1492 int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
1493                           bool force_add, int max_tevs)
1494 {
1495         int i, j, ret;
1496         struct __event_package *pkgs;
1497
1498         pkgs = zalloc(sizeof(struct __event_package) * npevs);
1499         if (pkgs == NULL)
1500                 return -ENOMEM;
1501
1502         /* Init vmlinux path */
1503         ret = init_vmlinux();
1504         if (ret < 0)
1505                 return ret;
1506
1507         /* Loop 1: convert all events */
1508         for (i = 0; i < npevs; i++) {
1509                 pkgs[i].pev = &pevs[i];
1510                 /* Convert with or without debuginfo */
1511                 ret  = convert_to_kprobe_trace_events(pkgs[i].pev,
1512                                                       &pkgs[i].tevs, max_tevs);
1513                 if (ret < 0)
1514                         goto end;
1515                 pkgs[i].ntevs = ret;
1516         }
1517
1518         /* Loop 2: add all events */
1519         for (i = 0; i < npevs && ret >= 0; i++)
1520                 ret = __add_kprobe_trace_events(pkgs[i].pev, pkgs[i].tevs,
1521                                                 pkgs[i].ntevs, force_add);
1522 end:
1523         /* Loop 3: cleanup trace events  */
1524         for (i = 0; i < npevs; i++)
1525                 for (j = 0; j < pkgs[i].ntevs; j++)
1526                         clear_kprobe_trace_event(&pkgs[i].tevs[j]);
1527
1528         return ret;
1529 }
1530
1531 static int __del_trace_kprobe_event(int fd, struct str_node *ent)
1532 {
1533         char *p;
1534         char buf[128];
1535         int ret;
1536
1537         /* Convert from perf-probe event to trace-kprobe event */
1538         ret = e_snprintf(buf, 128, "-:%s", ent->s);
1539         if (ret < 0)
1540                 goto error;
1541
1542         p = strchr(buf + 2, ':');
1543         if (!p) {
1544                 pr_debug("Internal error: %s should have ':' but not.\n",
1545                          ent->s);
1546                 ret = -ENOTSUP;
1547                 goto error;
1548         }
1549         *p = '/';
1550
1551         pr_debug("Writing event: %s\n", buf);
1552         ret = write(fd, buf, strlen(buf));
1553         if (ret < 0)
1554                 goto error;
1555
1556         printf("Remove event: %s\n", ent->s);
1557         return 0;
1558 error:
1559         pr_warning("Failed to delete event: %s\n", strerror(-ret));
1560         return ret;
1561 }
1562
1563 static int del_trace_kprobe_event(int fd, const char *group,
1564                                   const char *event, struct strlist *namelist)
1565 {
1566         char buf[128];
1567         struct str_node *ent, *n;
1568         int found = 0, ret = 0;
1569
1570         ret = e_snprintf(buf, 128, "%s:%s", group, event);
1571         if (ret < 0) {
1572                 pr_err("Failed to copy event.");
1573                 return ret;
1574         }
1575
1576         if (strpbrk(buf, "*?")) { /* Glob-exp */
1577                 strlist__for_each_safe(ent, n, namelist)
1578                         if (strglobmatch(ent->s, buf)) {
1579                                 found++;
1580                                 ret = __del_trace_kprobe_event(fd, ent);
1581                                 if (ret < 0)
1582                                         break;
1583                                 strlist__remove(namelist, ent);
1584                         }
1585         } else {
1586                 ent = strlist__find(namelist, buf);
1587                 if (ent) {
1588                         found++;
1589                         ret = __del_trace_kprobe_event(fd, ent);
1590                         if (ret >= 0)
1591                                 strlist__remove(namelist, ent);
1592                 }
1593         }
1594         if (found == 0 && ret >= 0)
1595                 pr_info("Info: Event \"%s\" does not exist.\n", buf);
1596
1597         return ret;
1598 }
1599
1600 int del_perf_probe_events(struct strlist *dellist)
1601 {
1602         int fd, ret = 0;
1603         const char *group, *event;
1604         char *p, *str;
1605         struct str_node *ent;
1606         struct strlist *namelist;
1607
1608         fd = open_kprobe_events(true);
1609         if (fd < 0)
1610                 return fd;
1611
1612         /* Get current event names */
1613         namelist = get_kprobe_trace_event_names(fd, true);
1614         if (namelist == NULL)
1615                 return -EINVAL;
1616
1617         strlist__for_each(ent, dellist) {
1618                 str = strdup(ent->s);
1619                 if (str == NULL) {
1620                         ret = -ENOMEM;
1621                         break;
1622                 }
1623                 pr_debug("Parsing: %s\n", str);
1624                 p = strchr(str, ':');
1625                 if (p) {
1626                         group = str;
1627                         *p = '\0';
1628                         event = p + 1;
1629                 } else {
1630                         group = "*";
1631                         event = str;
1632                 }
1633                 pr_debug("Group: %s, Event: %s\n", group, event);
1634                 ret = del_trace_kprobe_event(fd, group, event, namelist);
1635                 free(str);
1636                 if (ret < 0)
1637                         break;
1638         }
1639         strlist__delete(namelist);
1640         close(fd);
1641
1642         return ret;
1643 }
1644