150656eecSMasami Hiramatsu /* 250656eecSMasami Hiramatsu * probe-event.c : perf-probe definition to kprobe_events format converter 350656eecSMasami Hiramatsu * 450656eecSMasami Hiramatsu * Written by Masami Hiramatsu <mhiramat@redhat.com> 550656eecSMasami Hiramatsu * 650656eecSMasami Hiramatsu * This program is free software; you can redistribute it and/or modify 750656eecSMasami Hiramatsu * it under the terms of the GNU General Public License as published by 850656eecSMasami Hiramatsu * the Free Software Foundation; either version 2 of the License, or 950656eecSMasami Hiramatsu * (at your option) any later version. 1050656eecSMasami Hiramatsu * 1150656eecSMasami Hiramatsu * This program is distributed in the hope that it will be useful, 1250656eecSMasami Hiramatsu * but WITHOUT ANY WARRANTY; without even the implied warranty of 1350656eecSMasami Hiramatsu * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1450656eecSMasami Hiramatsu * GNU General Public License for more details. 1550656eecSMasami Hiramatsu * 1650656eecSMasami Hiramatsu * You should have received a copy of the GNU General Public License 1750656eecSMasami Hiramatsu * along with this program; if not, write to the Free Software 1850656eecSMasami Hiramatsu * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 1950656eecSMasami Hiramatsu * 2050656eecSMasami Hiramatsu */ 2150656eecSMasami Hiramatsu 2250656eecSMasami Hiramatsu #define _GNU_SOURCE 2350656eecSMasami Hiramatsu #include <sys/utsname.h> 2450656eecSMasami Hiramatsu #include <sys/types.h> 2550656eecSMasami Hiramatsu #include <sys/stat.h> 2650656eecSMasami Hiramatsu #include <fcntl.h> 2750656eecSMasami Hiramatsu #include <errno.h> 2850656eecSMasami Hiramatsu #include <stdio.h> 2950656eecSMasami Hiramatsu #include <unistd.h> 3050656eecSMasami Hiramatsu #include <stdlib.h> 3150656eecSMasami Hiramatsu #include <string.h> 324de189feSMasami Hiramatsu #include <stdarg.h> 334de189feSMasami Hiramatsu #include <limits.h> 3450656eecSMasami Hiramatsu 3550656eecSMasami Hiramatsu #undef _GNU_SOURCE 3631facc5fSMasami Hiramatsu #include "util.h" 3750656eecSMasami Hiramatsu #include "event.h" 38e1c01d61SMasami Hiramatsu #include "string.h" 394de189feSMasami Hiramatsu #include "strlist.h" 4050656eecSMasami Hiramatsu #include "debug.h" 4172041334SMasami Hiramatsu #include "cache.h" 42631c9defSMasami Hiramatsu #include "color.h" 43e0faa8d3SMasami Hiramatsu #include "symbol.h" 44e0faa8d3SMasami Hiramatsu #include "thread.h" 4550656eecSMasami Hiramatsu #include "parse-events.h" /* For debugfs_path */ 4650656eecSMasami Hiramatsu #include "probe-event.h" 474235b045SMasami Hiramatsu #include "probe-finder.h" 4850656eecSMasami Hiramatsu 4950656eecSMasami Hiramatsu #define MAX_CMDLEN 256 5050656eecSMasami Hiramatsu #define MAX_PROBE_ARGS 128 5150656eecSMasami Hiramatsu #define PERFPROBE_GROUP "probe" 5250656eecSMasami Hiramatsu 53f4d7da49SMasami Hiramatsu bool probe_event_dry_run; /* Dry run flag */ 54f4d7da49SMasami Hiramatsu 5550656eecSMasami Hiramatsu #define semantic_error(msg ...) die("Semantic error :" msg) 5650656eecSMasami Hiramatsu 574de189feSMasami Hiramatsu /* If there is no space to write, returns -E2BIG. */ 584de189feSMasami Hiramatsu static int e_snprintf(char *str, size_t size, const char *format, ...) 5984988450SMasami Hiramatsu __attribute__((format(printf, 3, 4))); 6084988450SMasami Hiramatsu 6184988450SMasami Hiramatsu static int e_snprintf(char *str, size_t size, const char *format, ...) 624de189feSMasami Hiramatsu { 634de189feSMasami Hiramatsu int ret; 644de189feSMasami Hiramatsu va_list ap; 654de189feSMasami Hiramatsu va_start(ap, format); 664de189feSMasami Hiramatsu ret = vsnprintf(str, size, format, ap); 674de189feSMasami Hiramatsu va_end(ap); 684de189feSMasami Hiramatsu if (ret >= (int)size) 694de189feSMasami Hiramatsu ret = -E2BIG; 704de189feSMasami Hiramatsu return ret; 714de189feSMasami Hiramatsu } 724de189feSMasami Hiramatsu 73e0faa8d3SMasami Hiramatsu static struct map_groups kmap_groups; 74e0faa8d3SMasami Hiramatsu static struct map *kmaps[MAP__NR_TYPES]; 75e0faa8d3SMasami Hiramatsu 76e0faa8d3SMasami Hiramatsu /* Initialize symbol maps for vmlinux */ 77e0faa8d3SMasami Hiramatsu static void init_vmlinux(void) 78e0faa8d3SMasami Hiramatsu { 79e0faa8d3SMasami Hiramatsu symbol_conf.sort_by_name = true; 80e0faa8d3SMasami Hiramatsu if (symbol_conf.vmlinux_name == NULL) 81e0faa8d3SMasami Hiramatsu symbol_conf.try_vmlinux_path = true; 82e0faa8d3SMasami Hiramatsu else 83e0faa8d3SMasami Hiramatsu pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name); 84e0faa8d3SMasami Hiramatsu if (symbol__init() < 0) 85e0faa8d3SMasami Hiramatsu die("Failed to init symbol map."); 86e0faa8d3SMasami Hiramatsu 87e0faa8d3SMasami Hiramatsu map_groups__init(&kmap_groups); 88e0faa8d3SMasami Hiramatsu if (map_groups__create_kernel_maps(&kmap_groups, kmaps) < 0) 89e0faa8d3SMasami Hiramatsu die("Failed to create kernel maps."); 90e0faa8d3SMasami Hiramatsu } 91e0faa8d3SMasami Hiramatsu 92e0faa8d3SMasami Hiramatsu #ifndef NO_DWARF_SUPPORT 93e0faa8d3SMasami Hiramatsu static int open_vmlinux(void) 94e0faa8d3SMasami Hiramatsu { 95e0faa8d3SMasami Hiramatsu if (map__load(kmaps[MAP__FUNCTION], NULL) < 0) { 96e0faa8d3SMasami Hiramatsu pr_debug("Failed to load kernel map.\n"); 97e0faa8d3SMasami Hiramatsu return -EINVAL; 98e0faa8d3SMasami Hiramatsu } 99e0faa8d3SMasami Hiramatsu pr_debug("Try to open %s\n", kmaps[MAP__FUNCTION]->dso->long_name); 100e0faa8d3SMasami Hiramatsu return open(kmaps[MAP__FUNCTION]->dso->long_name, O_RDONLY); 101e0faa8d3SMasami Hiramatsu } 102e0faa8d3SMasami Hiramatsu #endif 103e0faa8d3SMasami Hiramatsu 104631c9defSMasami Hiramatsu void parse_line_range_desc(const char *arg, struct line_range *lr) 105631c9defSMasami Hiramatsu { 106631c9defSMasami Hiramatsu const char *ptr; 107631c9defSMasami Hiramatsu char *tmp; 108631c9defSMasami Hiramatsu /* 109631c9defSMasami Hiramatsu * <Syntax> 110631c9defSMasami Hiramatsu * SRC:SLN[+NUM|-ELN] 111631c9defSMasami Hiramatsu * FUNC[:SLN[+NUM|-ELN]] 112631c9defSMasami Hiramatsu */ 113631c9defSMasami Hiramatsu ptr = strchr(arg, ':'); 114631c9defSMasami Hiramatsu if (ptr) { 115631c9defSMasami Hiramatsu lr->start = (unsigned int)strtoul(ptr + 1, &tmp, 0); 116631c9defSMasami Hiramatsu if (*tmp == '+') 117631c9defSMasami Hiramatsu lr->end = lr->start + (unsigned int)strtoul(tmp + 1, 118631c9defSMasami Hiramatsu &tmp, 0); 119631c9defSMasami Hiramatsu else if (*tmp == '-') 120631c9defSMasami Hiramatsu lr->end = (unsigned int)strtoul(tmp + 1, &tmp, 0); 121631c9defSMasami Hiramatsu else 122631c9defSMasami Hiramatsu lr->end = 0; 123631c9defSMasami Hiramatsu pr_debug("Line range is %u to %u\n", lr->start, lr->end); 124631c9defSMasami Hiramatsu if (lr->end && lr->start > lr->end) 125631c9defSMasami Hiramatsu semantic_error("Start line must be smaller" 126631c9defSMasami Hiramatsu " than end line."); 127631c9defSMasami Hiramatsu if (*tmp != '\0') 128631c9defSMasami Hiramatsu semantic_error("Tailing with invalid character '%d'.", 129631c9defSMasami Hiramatsu *tmp); 13031facc5fSMasami Hiramatsu tmp = xstrndup(arg, (ptr - arg)); 131631c9defSMasami Hiramatsu } else 13231facc5fSMasami Hiramatsu tmp = xstrdup(arg); 133631c9defSMasami Hiramatsu 134631c9defSMasami Hiramatsu if (strchr(tmp, '.')) 135631c9defSMasami Hiramatsu lr->file = tmp; 136631c9defSMasami Hiramatsu else 137631c9defSMasami Hiramatsu lr->function = tmp; 138631c9defSMasami Hiramatsu } 139631c9defSMasami Hiramatsu 140b7702a21SMasami Hiramatsu /* Check the name is good for event/group */ 141b7702a21SMasami Hiramatsu static bool check_event_name(const char *name) 142b7702a21SMasami Hiramatsu { 143b7702a21SMasami Hiramatsu if (!isalpha(*name) && *name != '_') 144b7702a21SMasami Hiramatsu return false; 145b7702a21SMasami Hiramatsu while (*++name != '\0') { 146b7702a21SMasami Hiramatsu if (!isalpha(*name) && !isdigit(*name) && *name != '_') 147b7702a21SMasami Hiramatsu return false; 148b7702a21SMasami Hiramatsu } 149b7702a21SMasami Hiramatsu return true; 150b7702a21SMasami Hiramatsu } 151b7702a21SMasami Hiramatsu 15250656eecSMasami Hiramatsu /* Parse probepoint definition. */ 1534235b045SMasami Hiramatsu static void parse_perf_probe_point(char *arg, struct perf_probe_event *pev) 15450656eecSMasami Hiramatsu { 1554235b045SMasami Hiramatsu struct perf_probe_point *pp = &pev->point; 15650656eecSMasami Hiramatsu char *ptr, *tmp; 15750656eecSMasami Hiramatsu char c, nc = 0; 15850656eecSMasami Hiramatsu /* 15950656eecSMasami Hiramatsu * <Syntax> 1602a9c8c36SMasami Hiramatsu * perf probe [EVENT=]SRC[:LN|;PTN] 1612a9c8c36SMasami Hiramatsu * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT] 162af663d75SMasami Hiramatsu * 163af663d75SMasami Hiramatsu * TODO:Group name support 16450656eecSMasami Hiramatsu */ 16550656eecSMasami Hiramatsu 1662a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";=@+%"); 1672a9c8c36SMasami Hiramatsu if (ptr && *ptr == '=') { /* Event name */ 168af663d75SMasami Hiramatsu *ptr = '\0'; 169af663d75SMasami Hiramatsu tmp = ptr + 1; 170af663d75SMasami Hiramatsu ptr = strchr(arg, ':'); 171af663d75SMasami Hiramatsu if (ptr) /* Group name is not supported yet. */ 172af663d75SMasami Hiramatsu semantic_error("Group name is not supported yet."); 173b7702a21SMasami Hiramatsu if (!check_event_name(arg)) 174b7702a21SMasami Hiramatsu semantic_error("%s is bad for event name -it must " 175b7702a21SMasami Hiramatsu "follow C symbol-naming rule.", arg); 1764235b045SMasami Hiramatsu pev->event = xstrdup(arg); 1774235b045SMasami Hiramatsu pev->group = NULL; 178af663d75SMasami Hiramatsu arg = tmp; 179af663d75SMasami Hiramatsu } 180af663d75SMasami Hiramatsu 1812a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";:+@%"); 18250656eecSMasami Hiramatsu if (ptr) { 18350656eecSMasami Hiramatsu nc = *ptr; 18450656eecSMasami Hiramatsu *ptr++ = '\0'; 18550656eecSMasami Hiramatsu } 18650656eecSMasami Hiramatsu 18750656eecSMasami Hiramatsu /* Check arg is function or file and copy it */ 18850656eecSMasami Hiramatsu if (strchr(arg, '.')) /* File */ 18931facc5fSMasami Hiramatsu pp->file = xstrdup(arg); 19050656eecSMasami Hiramatsu else /* Function */ 19131facc5fSMasami Hiramatsu pp->function = xstrdup(arg); 19250656eecSMasami Hiramatsu 19350656eecSMasami Hiramatsu /* Parse other options */ 19450656eecSMasami Hiramatsu while (ptr) { 19550656eecSMasami Hiramatsu arg = ptr; 19650656eecSMasami Hiramatsu c = nc; 1972a9c8c36SMasami Hiramatsu if (c == ';') { /* Lazy pattern must be the last part */ 19831facc5fSMasami Hiramatsu pp->lazy_line = xstrdup(arg); 1992a9c8c36SMasami Hiramatsu break; 2002a9c8c36SMasami Hiramatsu } 2012a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";:+@%"); 20250656eecSMasami Hiramatsu if (ptr) { 20350656eecSMasami Hiramatsu nc = *ptr; 20450656eecSMasami Hiramatsu *ptr++ = '\0'; 20550656eecSMasami Hiramatsu } 20650656eecSMasami Hiramatsu switch (c) { 20750656eecSMasami Hiramatsu case ':': /* Line number */ 20850656eecSMasami Hiramatsu pp->line = strtoul(arg, &tmp, 0); 20950656eecSMasami Hiramatsu if (*tmp != '\0') 2102a9c8c36SMasami Hiramatsu semantic_error("There is non-digit char" 21150656eecSMasami Hiramatsu " in line number."); 21250656eecSMasami Hiramatsu break; 21350656eecSMasami Hiramatsu case '+': /* Byte offset from a symbol */ 21450656eecSMasami Hiramatsu pp->offset = strtoul(arg, &tmp, 0); 21550656eecSMasami Hiramatsu if (*tmp != '\0') 2162a9c8c36SMasami Hiramatsu semantic_error("There is non-digit character" 21750656eecSMasami Hiramatsu " in offset."); 21850656eecSMasami Hiramatsu break; 21950656eecSMasami Hiramatsu case '@': /* File name */ 22050656eecSMasami Hiramatsu if (pp->file) 22150656eecSMasami Hiramatsu semantic_error("SRC@SRC is not allowed."); 22231facc5fSMasami Hiramatsu pp->file = xstrdup(arg); 22350656eecSMasami Hiramatsu break; 22450656eecSMasami Hiramatsu case '%': /* Probe places */ 22550656eecSMasami Hiramatsu if (strcmp(arg, "return") == 0) { 22650656eecSMasami Hiramatsu pp->retprobe = 1; 22750656eecSMasami Hiramatsu } else /* Others not supported yet */ 22850656eecSMasami Hiramatsu semantic_error("%%%s is not supported.", arg); 22950656eecSMasami Hiramatsu break; 23050656eecSMasami Hiramatsu default: 23150656eecSMasami Hiramatsu DIE_IF("Program has a bug."); 23250656eecSMasami Hiramatsu break; 23350656eecSMasami Hiramatsu } 23450656eecSMasami Hiramatsu } 23550656eecSMasami Hiramatsu 23650656eecSMasami Hiramatsu /* Exclusion check */ 2372a9c8c36SMasami Hiramatsu if (pp->lazy_line && pp->line) 2382a9c8c36SMasami Hiramatsu semantic_error("Lazy pattern can't be used with line number."); 2392a9c8c36SMasami Hiramatsu 2402a9c8c36SMasami Hiramatsu if (pp->lazy_line && pp->offset) 2412a9c8c36SMasami Hiramatsu semantic_error("Lazy pattern can't be used with offset."); 2422a9c8c36SMasami Hiramatsu 24350656eecSMasami Hiramatsu if (pp->line && pp->offset) 24450656eecSMasami Hiramatsu semantic_error("Offset can't be used with line number."); 24550656eecSMasami Hiramatsu 2462a9c8c36SMasami Hiramatsu if (!pp->line && !pp->lazy_line && pp->file && !pp->function) 2472a9c8c36SMasami Hiramatsu semantic_error("File always requires line number or " 2482a9c8c36SMasami Hiramatsu "lazy pattern."); 24950656eecSMasami Hiramatsu 25050656eecSMasami Hiramatsu if (pp->offset && !pp->function) 25150656eecSMasami Hiramatsu semantic_error("Offset requires an entry function."); 25250656eecSMasami Hiramatsu 25350656eecSMasami Hiramatsu if (pp->retprobe && !pp->function) 25450656eecSMasami Hiramatsu semantic_error("Return probe requires an entry function."); 25550656eecSMasami Hiramatsu 2562a9c8c36SMasami Hiramatsu if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) 2572a9c8c36SMasami Hiramatsu semantic_error("Offset/Line/Lazy pattern can't be used with " 2582a9c8c36SMasami Hiramatsu "return probe."); 25950656eecSMasami Hiramatsu 2604235b045SMasami Hiramatsu pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n", 2612a9c8c36SMasami Hiramatsu pp->function, pp->file, pp->line, pp->offset, pp->retprobe, 2622a9c8c36SMasami Hiramatsu pp->lazy_line); 26350656eecSMasami Hiramatsu } 26450656eecSMasami Hiramatsu 265*7df2f329SMasami Hiramatsu /* Parse perf-probe event argument */ 266*7df2f329SMasami Hiramatsu static void parse_perf_probe_arg(const char *str, struct perf_probe_arg *arg) 267*7df2f329SMasami Hiramatsu { 268*7df2f329SMasami Hiramatsu const char *tmp; 269*7df2f329SMasami Hiramatsu struct perf_probe_arg_field **fieldp; 270*7df2f329SMasami Hiramatsu 271*7df2f329SMasami Hiramatsu pr_debug("parsing arg: %s into ", str); 272*7df2f329SMasami Hiramatsu 273*7df2f329SMasami Hiramatsu tmp = strpbrk(str, "-."); 274*7df2f329SMasami Hiramatsu if (!is_c_varname(str) || !tmp) { 275*7df2f329SMasami Hiramatsu /* A variable, register, symbol or special value */ 276*7df2f329SMasami Hiramatsu arg->name = xstrdup(str); 277*7df2f329SMasami Hiramatsu pr_debug("%s\n", arg->name); 278*7df2f329SMasami Hiramatsu return; 279*7df2f329SMasami Hiramatsu } 280*7df2f329SMasami Hiramatsu 281*7df2f329SMasami Hiramatsu /* Structure fields */ 282*7df2f329SMasami Hiramatsu arg->name = xstrndup(str, tmp - str); 283*7df2f329SMasami Hiramatsu pr_debug("%s, ", arg->name); 284*7df2f329SMasami Hiramatsu fieldp = &arg->field; 285*7df2f329SMasami Hiramatsu 286*7df2f329SMasami Hiramatsu do { 287*7df2f329SMasami Hiramatsu *fieldp = xzalloc(sizeof(struct perf_probe_arg_field)); 288*7df2f329SMasami Hiramatsu if (*tmp == '.') { 289*7df2f329SMasami Hiramatsu str = tmp + 1; 290*7df2f329SMasami Hiramatsu (*fieldp)->ref = false; 291*7df2f329SMasami Hiramatsu } else if (tmp[1] == '>') { 292*7df2f329SMasami Hiramatsu str = tmp + 2; 293*7df2f329SMasami Hiramatsu (*fieldp)->ref = true; 294*7df2f329SMasami Hiramatsu } else 295*7df2f329SMasami Hiramatsu semantic_error("Argument parse error: %s", str); 296*7df2f329SMasami Hiramatsu 297*7df2f329SMasami Hiramatsu tmp = strpbrk(str, "-."); 298*7df2f329SMasami Hiramatsu if (tmp) { 299*7df2f329SMasami Hiramatsu (*fieldp)->name = xstrndup(str, tmp - str); 300*7df2f329SMasami Hiramatsu pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref); 301*7df2f329SMasami Hiramatsu fieldp = &(*fieldp)->next; 302*7df2f329SMasami Hiramatsu } 303*7df2f329SMasami Hiramatsu } while (tmp); 304*7df2f329SMasami Hiramatsu (*fieldp)->name = xstrdup(str); 305*7df2f329SMasami Hiramatsu pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref); 306*7df2f329SMasami Hiramatsu } 307*7df2f329SMasami Hiramatsu 3084235b045SMasami Hiramatsu /* Parse perf-probe event command */ 3094235b045SMasami Hiramatsu void parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev) 31050656eecSMasami Hiramatsu { 311e1c01d61SMasami Hiramatsu char **argv; 312fac13fd5SMasami Hiramatsu int argc, i; 313fac13fd5SMasami Hiramatsu 3144235b045SMasami Hiramatsu argv = argv_split(cmd, &argc); 315e1c01d61SMasami Hiramatsu if (!argv) 316e1c01d61SMasami Hiramatsu die("argv_split failed."); 317e1c01d61SMasami Hiramatsu if (argc > MAX_PROBE_ARGS + 1) 31850656eecSMasami Hiramatsu semantic_error("Too many arguments"); 31950656eecSMasami Hiramatsu 32050656eecSMasami Hiramatsu /* Parse probe point */ 3214235b045SMasami Hiramatsu parse_perf_probe_point(argv[0], pev); 32250656eecSMasami Hiramatsu 323e1c01d61SMasami Hiramatsu /* Copy arguments and ensure return probe has no C argument */ 3244235b045SMasami Hiramatsu pev->nargs = argc - 1; 3254235b045SMasami Hiramatsu pev->args = xzalloc(sizeof(struct perf_probe_arg) * pev->nargs); 3264235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 327*7df2f329SMasami Hiramatsu parse_perf_probe_arg(argv[i + 1], &pev->args[i]); 3284235b045SMasami Hiramatsu if (is_c_varname(pev->args[i].name) && pev->point.retprobe) 3294235b045SMasami Hiramatsu semantic_error("You can't specify local variable for" 3304235b045SMasami Hiramatsu " kretprobe"); 331e1c01d61SMasami Hiramatsu } 33250656eecSMasami Hiramatsu 333e1c01d61SMasami Hiramatsu argv_free(argv); 33450656eecSMasami Hiramatsu } 33550656eecSMasami Hiramatsu 3364235b045SMasami Hiramatsu /* Return true if this perf_probe_event requires debuginfo */ 3374235b045SMasami Hiramatsu bool perf_probe_event_need_dwarf(struct perf_probe_event *pev) 3384de189feSMasami Hiramatsu { 3394235b045SMasami Hiramatsu int i; 3404235b045SMasami Hiramatsu 3414235b045SMasami Hiramatsu if (pev->point.file || pev->point.line || pev->point.lazy_line) 3424235b045SMasami Hiramatsu return true; 3434235b045SMasami Hiramatsu 3444235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) 3454235b045SMasami Hiramatsu if (is_c_varname(pev->args[i].name)) 3464235b045SMasami Hiramatsu return true; 3474235b045SMasami Hiramatsu 3484235b045SMasami Hiramatsu return false; 3494235b045SMasami Hiramatsu } 3504235b045SMasami Hiramatsu 3514235b045SMasami Hiramatsu /* Parse kprobe_events event into struct probe_point */ 3524235b045SMasami Hiramatsu void parse_kprobe_trace_command(const char *cmd, struct kprobe_trace_event *tev) 3534235b045SMasami Hiramatsu { 3544235b045SMasami Hiramatsu struct kprobe_trace_point *tp = &tev->point; 3554de189feSMasami Hiramatsu char pr; 3564de189feSMasami Hiramatsu char *p; 3574de189feSMasami Hiramatsu int ret, i, argc; 3584de189feSMasami Hiramatsu char **argv; 3594de189feSMasami Hiramatsu 3604235b045SMasami Hiramatsu pr_debug("Parsing kprobe_events: %s\n", cmd); 3614235b045SMasami Hiramatsu argv = argv_split(cmd, &argc); 3624de189feSMasami Hiramatsu if (!argv) 3634de189feSMasami Hiramatsu die("argv_split failed."); 3644de189feSMasami Hiramatsu if (argc < 2) 3654de189feSMasami Hiramatsu semantic_error("Too less arguments."); 3664de189feSMasami Hiramatsu 3674de189feSMasami Hiramatsu /* Scan event and group name. */ 36893aaa45aSLiming Wang ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]", 3694235b045SMasami Hiramatsu &pr, (float *)(void *)&tev->group, 3704235b045SMasami Hiramatsu (float *)(void *)&tev->event); 3714de189feSMasami Hiramatsu if (ret != 3) 3724de189feSMasami Hiramatsu semantic_error("Failed to parse event name: %s", argv[0]); 3734235b045SMasami Hiramatsu pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr); 3744de189feSMasami Hiramatsu 3754235b045SMasami Hiramatsu tp->retprobe = (pr == 'r'); 3764de189feSMasami Hiramatsu 3774de189feSMasami Hiramatsu /* Scan function name and offset */ 3784235b045SMasami Hiramatsu ret = sscanf(argv[1], "%a[^+]+%lu", (float *)(void *)&tp->symbol, 3794235b045SMasami Hiramatsu &tp->offset); 3804de189feSMasami Hiramatsu if (ret == 1) 3814235b045SMasami Hiramatsu tp->offset = 0; 3824de189feSMasami Hiramatsu 3834235b045SMasami Hiramatsu tev->nargs = argc - 2; 3844235b045SMasami Hiramatsu tev->args = xzalloc(sizeof(struct kprobe_trace_arg) * tev->nargs); 3854235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 3864de189feSMasami Hiramatsu p = strchr(argv[i + 2], '='); 3874de189feSMasami Hiramatsu if (p) /* We don't need which register is assigned. */ 3884235b045SMasami Hiramatsu *p++ = '\0'; 3894235b045SMasami Hiramatsu else 3904235b045SMasami Hiramatsu p = argv[i + 2]; 3914235b045SMasami Hiramatsu tev->args[i].name = xstrdup(argv[i + 2]); 3924235b045SMasami Hiramatsu /* TODO: parse regs and offset */ 3934235b045SMasami Hiramatsu tev->args[i].value = xstrdup(p); 3944de189feSMasami Hiramatsu } 3954de189feSMasami Hiramatsu 3964de189feSMasami Hiramatsu argv_free(argv); 3974de189feSMasami Hiramatsu } 3984de189feSMasami Hiramatsu 399*7df2f329SMasami Hiramatsu /* Compose only probe arg */ 400*7df2f329SMasami Hiramatsu int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len) 401*7df2f329SMasami Hiramatsu { 402*7df2f329SMasami Hiramatsu struct perf_probe_arg_field *field = pa->field; 403*7df2f329SMasami Hiramatsu int ret; 404*7df2f329SMasami Hiramatsu char *tmp = buf; 405*7df2f329SMasami Hiramatsu 406*7df2f329SMasami Hiramatsu ret = e_snprintf(tmp, len, "%s", pa->name); 407*7df2f329SMasami Hiramatsu if (ret <= 0) 408*7df2f329SMasami Hiramatsu goto error; 409*7df2f329SMasami Hiramatsu tmp += ret; 410*7df2f329SMasami Hiramatsu len -= ret; 411*7df2f329SMasami Hiramatsu 412*7df2f329SMasami Hiramatsu while (field) { 413*7df2f329SMasami Hiramatsu ret = e_snprintf(tmp, len, "%s%s", field->ref ? "->" : ".", 414*7df2f329SMasami Hiramatsu field->name); 415*7df2f329SMasami Hiramatsu if (ret <= 0) 416*7df2f329SMasami Hiramatsu goto error; 417*7df2f329SMasami Hiramatsu tmp += ret; 418*7df2f329SMasami Hiramatsu len -= ret; 419*7df2f329SMasami Hiramatsu field = field->next; 420*7df2f329SMasami Hiramatsu } 421*7df2f329SMasami Hiramatsu return tmp - buf; 422*7df2f329SMasami Hiramatsu error: 423*7df2f329SMasami Hiramatsu die("Failed to synthesize perf probe argument: %s", strerror(-ret)); 424*7df2f329SMasami Hiramatsu } 425*7df2f329SMasami Hiramatsu 4264235b045SMasami Hiramatsu /* Compose only probe point (not argument) */ 4274235b045SMasami Hiramatsu static char *synthesize_perf_probe_point(struct perf_probe_point *pp) 42850656eecSMasami Hiramatsu { 429fb1587d8SMasami Hiramatsu char *buf, *tmp; 430fb1587d8SMasami Hiramatsu char offs[32] = "", line[32] = "", file[32] = ""; 431fb1587d8SMasami Hiramatsu int ret, len; 43250656eecSMasami Hiramatsu 4334235b045SMasami Hiramatsu buf = xzalloc(MAX_CMDLEN); 4344de189feSMasami Hiramatsu if (pp->offset) { 435fb1587d8SMasami Hiramatsu ret = e_snprintf(offs, 32, "+%lu", pp->offset); 4364de189feSMasami Hiramatsu if (ret <= 0) 4374de189feSMasami Hiramatsu goto error; 4384de189feSMasami Hiramatsu } 4394de189feSMasami Hiramatsu if (pp->line) { 440fb1587d8SMasami Hiramatsu ret = e_snprintf(line, 32, ":%d", pp->line); 441fb1587d8SMasami Hiramatsu if (ret <= 0) 442fb1587d8SMasami Hiramatsu goto error; 443fb1587d8SMasami Hiramatsu } 444fb1587d8SMasami Hiramatsu if (pp->file) { 445fb1587d8SMasami Hiramatsu len = strlen(pp->file) - 32; 446fb1587d8SMasami Hiramatsu if (len < 0) 447fb1587d8SMasami Hiramatsu len = 0; 448fb1587d8SMasami Hiramatsu tmp = strchr(pp->file + len, '/'); 449fb1587d8SMasami Hiramatsu if (!tmp) 450fb1587d8SMasami Hiramatsu tmp = pp->file + len - 1; 451fb1587d8SMasami Hiramatsu ret = e_snprintf(file, 32, "@%s", tmp + 1); 4524de189feSMasami Hiramatsu if (ret <= 0) 4534de189feSMasami Hiramatsu goto error; 4544de189feSMasami Hiramatsu } 4554de189feSMasami Hiramatsu 4564de189feSMasami Hiramatsu if (pp->function) 457fb1587d8SMasami Hiramatsu ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function, 458fb1587d8SMasami Hiramatsu offs, pp->retprobe ? "%return" : "", line, 459fb1587d8SMasami Hiramatsu file); 4604de189feSMasami Hiramatsu else 461fb1587d8SMasami Hiramatsu ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line); 4624235b045SMasami Hiramatsu if (ret <= 0) 4634235b045SMasami Hiramatsu goto error; 4644235b045SMasami Hiramatsu 4654235b045SMasami Hiramatsu return buf; 4664235b045SMasami Hiramatsu error: 4674235b045SMasami Hiramatsu die("Failed to synthesize perf probe point: %s", strerror(-ret)); 4684235b045SMasami Hiramatsu } 4694235b045SMasami Hiramatsu 4704235b045SMasami Hiramatsu #if 0 4714235b045SMasami Hiramatsu char *synthesize_perf_probe_command(struct perf_probe_event *pev) 4724235b045SMasami Hiramatsu { 4734235b045SMasami Hiramatsu char *buf; 4744235b045SMasami Hiramatsu int i, len, ret; 4754235b045SMasami Hiramatsu 4764235b045SMasami Hiramatsu buf = synthesize_perf_probe_point(&pev->point); 4774235b045SMasami Hiramatsu if (!buf) 4784235b045SMasami Hiramatsu return NULL; 4794235b045SMasami Hiramatsu 4804235b045SMasami Hiramatsu len = strlen(buf); 4814235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 4824235b045SMasami Hiramatsu ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s", 4834235b045SMasami Hiramatsu pev->args[i].name); 4847ef17aafSMasami Hiramatsu if (ret <= 0) { 4854235b045SMasami Hiramatsu free(buf); 4864235b045SMasami Hiramatsu return NULL; 4877ef17aafSMasami Hiramatsu } 4884235b045SMasami Hiramatsu len += ret; 4897ef17aafSMasami Hiramatsu } 49050656eecSMasami Hiramatsu 4914235b045SMasami Hiramatsu return buf; 4924235b045SMasami Hiramatsu } 4934235b045SMasami Hiramatsu #endif 4944235b045SMasami Hiramatsu 4954235b045SMasami Hiramatsu static int __synthesize_kprobe_trace_arg_ref(struct kprobe_trace_arg_ref *ref, 4964235b045SMasami Hiramatsu char **buf, size_t *buflen, 4974235b045SMasami Hiramatsu int depth) 4987ef17aafSMasami Hiramatsu { 4994235b045SMasami Hiramatsu int ret; 5004235b045SMasami Hiramatsu if (ref->next) { 5014235b045SMasami Hiramatsu depth = __synthesize_kprobe_trace_arg_ref(ref->next, buf, 5024235b045SMasami Hiramatsu buflen, depth + 1); 5034235b045SMasami Hiramatsu if (depth < 0) 5044235b045SMasami Hiramatsu goto out; 5054235b045SMasami Hiramatsu } 5064235b045SMasami Hiramatsu 5074235b045SMasami Hiramatsu ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset); 5084235b045SMasami Hiramatsu if (ret < 0) 5094235b045SMasami Hiramatsu depth = ret; 5104235b045SMasami Hiramatsu else { 5114235b045SMasami Hiramatsu *buf += ret; 5124235b045SMasami Hiramatsu *buflen -= ret; 5134235b045SMasami Hiramatsu } 5144235b045SMasami Hiramatsu out: 5154235b045SMasami Hiramatsu return depth; 5164235b045SMasami Hiramatsu 5174235b045SMasami Hiramatsu } 5184235b045SMasami Hiramatsu 5194235b045SMasami Hiramatsu static int synthesize_kprobe_trace_arg(struct kprobe_trace_arg *arg, 5204235b045SMasami Hiramatsu char *buf, size_t buflen) 5214235b045SMasami Hiramatsu { 5224235b045SMasami Hiramatsu int ret, depth = 0; 5234235b045SMasami Hiramatsu char *tmp = buf; 5244235b045SMasami Hiramatsu 5254235b045SMasami Hiramatsu /* Argument name or separator */ 5264235b045SMasami Hiramatsu if (arg->name) 5274235b045SMasami Hiramatsu ret = e_snprintf(buf, buflen, " %s=", arg->name); 5284235b045SMasami Hiramatsu else 5294235b045SMasami Hiramatsu ret = e_snprintf(buf, buflen, " "); 5304235b045SMasami Hiramatsu if (ret < 0) 5314235b045SMasami Hiramatsu return ret; 5324235b045SMasami Hiramatsu buf += ret; 5334235b045SMasami Hiramatsu buflen -= ret; 5344235b045SMasami Hiramatsu 5354235b045SMasami Hiramatsu /* Dereferencing arguments */ 5364235b045SMasami Hiramatsu if (arg->ref) { 5374235b045SMasami Hiramatsu depth = __synthesize_kprobe_trace_arg_ref(arg->ref, &buf, 5384235b045SMasami Hiramatsu &buflen, 1); 5394235b045SMasami Hiramatsu if (depth < 0) 5404235b045SMasami Hiramatsu return depth; 5414235b045SMasami Hiramatsu } 5424235b045SMasami Hiramatsu 5434235b045SMasami Hiramatsu /* Print argument value */ 5444235b045SMasami Hiramatsu ret = e_snprintf(buf, buflen, "%s", arg->value); 5454235b045SMasami Hiramatsu if (ret < 0) 5464235b045SMasami Hiramatsu return ret; 5474235b045SMasami Hiramatsu buf += ret; 5484235b045SMasami Hiramatsu buflen -= ret; 5494235b045SMasami Hiramatsu 5504235b045SMasami Hiramatsu /* Closing */ 5514235b045SMasami Hiramatsu while (depth--) { 5524235b045SMasami Hiramatsu ret = e_snprintf(buf, buflen, ")"); 5534235b045SMasami Hiramatsu if (ret < 0) 5544235b045SMasami Hiramatsu return ret; 5554235b045SMasami Hiramatsu buf += ret; 5564235b045SMasami Hiramatsu buflen -= ret; 5574235b045SMasami Hiramatsu } 5584235b045SMasami Hiramatsu 5594235b045SMasami Hiramatsu return buf - tmp; 5604235b045SMasami Hiramatsu } 5614235b045SMasami Hiramatsu 5624235b045SMasami Hiramatsu char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev) 5634235b045SMasami Hiramatsu { 5644235b045SMasami Hiramatsu struct kprobe_trace_point *tp = &tev->point; 5657ef17aafSMasami Hiramatsu char *buf; 5667ef17aafSMasami Hiramatsu int i, len, ret; 5677ef17aafSMasami Hiramatsu 5684235b045SMasami Hiramatsu buf = xzalloc(MAX_CMDLEN); 5694235b045SMasami Hiramatsu len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s %s+%lu", 5704235b045SMasami Hiramatsu tp->retprobe ? 'r' : 'p', 5714235b045SMasami Hiramatsu tev->group, tev->event, 5724235b045SMasami Hiramatsu tp->symbol, tp->offset); 5734235b045SMasami Hiramatsu if (len <= 0) 5744235b045SMasami Hiramatsu goto error; 5757ef17aafSMasami Hiramatsu 5764235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 5774235b045SMasami Hiramatsu ret = synthesize_kprobe_trace_arg(&tev->args[i], buf + len, 5784235b045SMasami Hiramatsu MAX_CMDLEN - len); 5794de189feSMasami Hiramatsu if (ret <= 0) 58050656eecSMasami Hiramatsu goto error; 58150656eecSMasami Hiramatsu len += ret; 58250656eecSMasami Hiramatsu } 58350656eecSMasami Hiramatsu 5844235b045SMasami Hiramatsu return buf; 58550656eecSMasami Hiramatsu error: 5864235b045SMasami Hiramatsu free(buf); 5874235b045SMasami Hiramatsu return NULL; 58850656eecSMasami Hiramatsu } 58950656eecSMasami Hiramatsu 5904235b045SMasami Hiramatsu void convert_to_perf_probe_event(struct kprobe_trace_event *tev, 5914235b045SMasami Hiramatsu struct perf_probe_event *pev) 5924de189feSMasami Hiramatsu { 5934235b045SMasami Hiramatsu char buf[64]; 5944235b045SMasami Hiramatsu int i; 595fb1587d8SMasami Hiramatsu #ifndef NO_DWARF_SUPPORT 596fb1587d8SMasami Hiramatsu struct symbol *sym; 597fb1587d8SMasami Hiramatsu int fd, ret = 0; 5984de189feSMasami Hiramatsu 599fb1587d8SMasami Hiramatsu sym = map__find_symbol_by_name(kmaps[MAP__FUNCTION], 600fb1587d8SMasami Hiramatsu tev->point.symbol, NULL); 601fb1587d8SMasami Hiramatsu if (sym) { 602fb1587d8SMasami Hiramatsu fd = open_vmlinux(); 603fb1587d8SMasami Hiramatsu ret = find_perf_probe_point(fd, sym->start + tev->point.offset, 604fb1587d8SMasami Hiramatsu &pev->point); 605fb1587d8SMasami Hiramatsu close(fd); 606fb1587d8SMasami Hiramatsu } 607fb1587d8SMasami Hiramatsu if (ret <= 0) { 608fb1587d8SMasami Hiramatsu pev->point.function = xstrdup(tev->point.symbol); 609fb1587d8SMasami Hiramatsu pev->point.offset = tev->point.offset; 610fb1587d8SMasami Hiramatsu } 611fb1587d8SMasami Hiramatsu #else 6124235b045SMasami Hiramatsu /* Convert trace_point to probe_point */ 6134235b045SMasami Hiramatsu pev->point.function = xstrdup(tev->point.symbol); 6144235b045SMasami Hiramatsu pev->point.offset = tev->point.offset; 615fb1587d8SMasami Hiramatsu #endif 6164235b045SMasami Hiramatsu pev->point.retprobe = tev->point.retprobe; 6174235b045SMasami Hiramatsu 618fb1587d8SMasami Hiramatsu pev->event = xstrdup(tev->event); 619fb1587d8SMasami Hiramatsu pev->group = xstrdup(tev->group); 620fb1587d8SMasami Hiramatsu 6214235b045SMasami Hiramatsu /* Convert trace_arg to probe_arg */ 6224235b045SMasami Hiramatsu pev->nargs = tev->nargs; 6234235b045SMasami Hiramatsu pev->args = xzalloc(sizeof(struct perf_probe_arg) * pev->nargs); 6244235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) 6254235b045SMasami Hiramatsu if (tev->args[i].name) 6264235b045SMasami Hiramatsu pev->args[i].name = xstrdup(tev->args[i].name); 6274235b045SMasami Hiramatsu else { 6284235b045SMasami Hiramatsu synthesize_kprobe_trace_arg(&tev->args[i], buf, 64); 6294235b045SMasami Hiramatsu pev->args[i].name = xstrdup(buf); 6304de189feSMasami Hiramatsu } 6314235b045SMasami Hiramatsu } 6324de189feSMasami Hiramatsu 6334235b045SMasami Hiramatsu void clear_perf_probe_event(struct perf_probe_event *pev) 6344235b045SMasami Hiramatsu { 6354235b045SMasami Hiramatsu struct perf_probe_point *pp = &pev->point; 636*7df2f329SMasami Hiramatsu struct perf_probe_arg_field *field, *next; 6374235b045SMasami Hiramatsu int i; 6384de189feSMasami Hiramatsu 6394235b045SMasami Hiramatsu if (pev->event) 6404235b045SMasami Hiramatsu free(pev->event); 6414235b045SMasami Hiramatsu if (pev->group) 6424235b045SMasami Hiramatsu free(pev->group); 6434235b045SMasami Hiramatsu if (pp->file) 6444235b045SMasami Hiramatsu free(pp->file); 6454235b045SMasami Hiramatsu if (pp->function) 6464235b045SMasami Hiramatsu free(pp->function); 6474235b045SMasami Hiramatsu if (pp->lazy_line) 6484235b045SMasami Hiramatsu free(pp->lazy_line); 649*7df2f329SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 6504235b045SMasami Hiramatsu if (pev->args[i].name) 6514235b045SMasami Hiramatsu free(pev->args[i].name); 652*7df2f329SMasami Hiramatsu field = pev->args[i].field; 653*7df2f329SMasami Hiramatsu while (field) { 654*7df2f329SMasami Hiramatsu next = field->next; 655*7df2f329SMasami Hiramatsu if (field->name) 656*7df2f329SMasami Hiramatsu free(field->name); 657*7df2f329SMasami Hiramatsu free(field); 658*7df2f329SMasami Hiramatsu field = next; 659*7df2f329SMasami Hiramatsu } 660*7df2f329SMasami Hiramatsu } 6614235b045SMasami Hiramatsu if (pev->args) 6624235b045SMasami Hiramatsu free(pev->args); 6634235b045SMasami Hiramatsu memset(pev, 0, sizeof(*pev)); 6644235b045SMasami Hiramatsu } 6654235b045SMasami Hiramatsu 6664235b045SMasami Hiramatsu void clear_kprobe_trace_event(struct kprobe_trace_event *tev) 6674235b045SMasami Hiramatsu { 6684235b045SMasami Hiramatsu struct kprobe_trace_arg_ref *ref, *next; 6694235b045SMasami Hiramatsu int i; 6704235b045SMasami Hiramatsu 6714235b045SMasami Hiramatsu if (tev->event) 6724235b045SMasami Hiramatsu free(tev->event); 6734235b045SMasami Hiramatsu if (tev->group) 6744235b045SMasami Hiramatsu free(tev->group); 6754235b045SMasami Hiramatsu if (tev->point.symbol) 6764235b045SMasami Hiramatsu free(tev->point.symbol); 6774235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 6784235b045SMasami Hiramatsu if (tev->args[i].name) 6794235b045SMasami Hiramatsu free(tev->args[i].name); 6804235b045SMasami Hiramatsu if (tev->args[i].value) 6814235b045SMasami Hiramatsu free(tev->args[i].value); 6824235b045SMasami Hiramatsu ref = tev->args[i].ref; 6834235b045SMasami Hiramatsu while (ref) { 6844235b045SMasami Hiramatsu next = ref->next; 6854235b045SMasami Hiramatsu free(ref); 6864235b045SMasami Hiramatsu ref = next; 6874235b045SMasami Hiramatsu } 6884235b045SMasami Hiramatsu } 6894235b045SMasami Hiramatsu if (tev->args) 6904235b045SMasami Hiramatsu free(tev->args); 6914235b045SMasami Hiramatsu memset(tev, 0, sizeof(*tev)); 6924de189feSMasami Hiramatsu } 6934de189feSMasami Hiramatsu 694f4d7da49SMasami Hiramatsu static int open_kprobe_events(bool readwrite) 6954de189feSMasami Hiramatsu { 6964de189feSMasami Hiramatsu char buf[PATH_MAX]; 6974de189feSMasami Hiramatsu int ret; 6984de189feSMasami Hiramatsu 6994de189feSMasami Hiramatsu ret = e_snprintf(buf, PATH_MAX, "%s/../kprobe_events", debugfs_path); 7004de189feSMasami Hiramatsu if (ret < 0) 7014de189feSMasami Hiramatsu die("Failed to make kprobe_events path."); 7024de189feSMasami Hiramatsu 703f4d7da49SMasami Hiramatsu if (readwrite && !probe_event_dry_run) 704f4d7da49SMasami Hiramatsu ret = open(buf, O_RDWR, O_APPEND); 705f4d7da49SMasami Hiramatsu else 706f4d7da49SMasami Hiramatsu ret = open(buf, O_RDONLY, 0); 707f4d7da49SMasami Hiramatsu 7084de189feSMasami Hiramatsu if (ret < 0) { 7094de189feSMasami Hiramatsu if (errno == ENOENT) 7104de189feSMasami Hiramatsu die("kprobe_events file does not exist -" 71163bbd5e2SLiming Wang " please rebuild with CONFIG_KPROBE_EVENT."); 7124de189feSMasami Hiramatsu else 7134de189feSMasami Hiramatsu die("Could not open kprobe_events file: %s", 7144de189feSMasami Hiramatsu strerror(errno)); 7154de189feSMasami Hiramatsu } 7164de189feSMasami Hiramatsu return ret; 7174de189feSMasami Hiramatsu } 7184de189feSMasami Hiramatsu 7194de189feSMasami Hiramatsu /* Get raw string list of current kprobe_events */ 7204235b045SMasami Hiramatsu static struct strlist *get_kprobe_trace_command_rawlist(int fd) 7214de189feSMasami Hiramatsu { 7224de189feSMasami Hiramatsu int ret, idx; 7234de189feSMasami Hiramatsu FILE *fp; 7244de189feSMasami Hiramatsu char buf[MAX_CMDLEN]; 7254de189feSMasami Hiramatsu char *p; 7264de189feSMasami Hiramatsu struct strlist *sl; 7274de189feSMasami Hiramatsu 7284de189feSMasami Hiramatsu sl = strlist__new(true, NULL); 7294de189feSMasami Hiramatsu 7304de189feSMasami Hiramatsu fp = fdopen(dup(fd), "r"); 7314de189feSMasami Hiramatsu while (!feof(fp)) { 7324de189feSMasami Hiramatsu p = fgets(buf, MAX_CMDLEN, fp); 7334de189feSMasami Hiramatsu if (!p) 7344de189feSMasami Hiramatsu break; 7354de189feSMasami Hiramatsu 7364de189feSMasami Hiramatsu idx = strlen(p) - 1; 7374de189feSMasami Hiramatsu if (p[idx] == '\n') 7384de189feSMasami Hiramatsu p[idx] = '\0'; 7394de189feSMasami Hiramatsu ret = strlist__add(sl, buf); 7404de189feSMasami Hiramatsu if (ret < 0) 7414de189feSMasami Hiramatsu die("strlist__add failed: %s", strerror(-ret)); 7424de189feSMasami Hiramatsu } 7434de189feSMasami Hiramatsu fclose(fp); 7444de189feSMasami Hiramatsu 7454de189feSMasami Hiramatsu return sl; 7464de189feSMasami Hiramatsu } 7474de189feSMasami Hiramatsu 748278498d4SMasami Hiramatsu /* Show an event */ 7494235b045SMasami Hiramatsu static void show_perf_probe_event(struct perf_probe_event *pev) 750278498d4SMasami Hiramatsu { 7517e990a51SMasami Hiramatsu int i, ret; 752278498d4SMasami Hiramatsu char buf[128]; 7534235b045SMasami Hiramatsu char *place; 754278498d4SMasami Hiramatsu 7554235b045SMasami Hiramatsu /* Synthesize only event probe point */ 7564235b045SMasami Hiramatsu place = synthesize_perf_probe_point(&pev->point); 7574235b045SMasami Hiramatsu 7584235b045SMasami Hiramatsu ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event); 7597e990a51SMasami Hiramatsu if (ret < 0) 7607e990a51SMasami Hiramatsu die("Failed to copy event: %s", strerror(-ret)); 761fb1587d8SMasami Hiramatsu printf(" %-20s (on %s", buf, place); 762278498d4SMasami Hiramatsu 7634235b045SMasami Hiramatsu if (pev->nargs > 0) { 764278498d4SMasami Hiramatsu printf(" with"); 765*7df2f329SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 766*7df2f329SMasami Hiramatsu synthesize_perf_probe_arg(&pev->args[i], buf, 128); 767*7df2f329SMasami Hiramatsu printf(" %s", buf); 768*7df2f329SMasami Hiramatsu } 769278498d4SMasami Hiramatsu } 770278498d4SMasami Hiramatsu printf(")\n"); 7714235b045SMasami Hiramatsu free(place); 772278498d4SMasami Hiramatsu } 773278498d4SMasami Hiramatsu 7744de189feSMasami Hiramatsu /* List up current perf-probe events */ 7754de189feSMasami Hiramatsu void show_perf_probe_events(void) 7764de189feSMasami Hiramatsu { 7777ef17aafSMasami Hiramatsu int fd; 7784235b045SMasami Hiramatsu struct kprobe_trace_event tev; 7794235b045SMasami Hiramatsu struct perf_probe_event pev; 7804de189feSMasami Hiramatsu struct strlist *rawlist; 7814de189feSMasami Hiramatsu struct str_node *ent; 7824de189feSMasami Hiramatsu 78372041334SMasami Hiramatsu setup_pager(); 784fb1587d8SMasami Hiramatsu init_vmlinux(); 7854235b045SMasami Hiramatsu 7864235b045SMasami Hiramatsu memset(&tev, 0, sizeof(tev)); 7874235b045SMasami Hiramatsu memset(&pev, 0, sizeof(pev)); 78872041334SMasami Hiramatsu 789f4d7da49SMasami Hiramatsu fd = open_kprobe_events(false); 7904235b045SMasami Hiramatsu rawlist = get_kprobe_trace_command_rawlist(fd); 7914de189feSMasami Hiramatsu close(fd); 7924de189feSMasami Hiramatsu 793adf365f4SMasami Hiramatsu strlist__for_each(ent, rawlist) { 7944235b045SMasami Hiramatsu parse_kprobe_trace_command(ent->s, &tev); 7954235b045SMasami Hiramatsu convert_to_perf_probe_event(&tev, &pev); 796278498d4SMasami Hiramatsu /* Show an event */ 7974235b045SMasami Hiramatsu show_perf_probe_event(&pev); 7984235b045SMasami Hiramatsu clear_perf_probe_event(&pev); 7994235b045SMasami Hiramatsu clear_kprobe_trace_event(&tev); 8004de189feSMasami Hiramatsu } 8014de189feSMasami Hiramatsu 8024de189feSMasami Hiramatsu strlist__delete(rawlist); 8034de189feSMasami Hiramatsu } 8044de189feSMasami Hiramatsu 805b498ce1fSMasami Hiramatsu /* Get current perf-probe event names */ 8064235b045SMasami Hiramatsu static struct strlist *get_kprobe_trace_event_names(int fd, bool include_group) 807b498ce1fSMasami Hiramatsu { 808fa28244dSMasami Hiramatsu char buf[128]; 809b498ce1fSMasami Hiramatsu struct strlist *sl, *rawlist; 810b498ce1fSMasami Hiramatsu struct str_node *ent; 8114235b045SMasami Hiramatsu struct kprobe_trace_event tev; 812b498ce1fSMasami Hiramatsu 8134235b045SMasami Hiramatsu memset(&tev, 0, sizeof(tev)); 814b498ce1fSMasami Hiramatsu 8154235b045SMasami Hiramatsu rawlist = get_kprobe_trace_command_rawlist(fd); 816e1d2017bSMasami Hiramatsu sl = strlist__new(true, NULL); 817adf365f4SMasami Hiramatsu strlist__for_each(ent, rawlist) { 8184235b045SMasami Hiramatsu parse_kprobe_trace_command(ent->s, &tev); 819fa28244dSMasami Hiramatsu if (include_group) { 8204235b045SMasami Hiramatsu if (e_snprintf(buf, 128, "%s:%s", tev.group, 8214235b045SMasami Hiramatsu tev.event) < 0) 822fa28244dSMasami Hiramatsu die("Failed to copy group:event name."); 823fa28244dSMasami Hiramatsu strlist__add(sl, buf); 824fa28244dSMasami Hiramatsu } else 8254235b045SMasami Hiramatsu strlist__add(sl, tev.event); 8264235b045SMasami Hiramatsu clear_kprobe_trace_event(&tev); 827b498ce1fSMasami Hiramatsu } 828b498ce1fSMasami Hiramatsu 829b498ce1fSMasami Hiramatsu strlist__delete(rawlist); 830b498ce1fSMasami Hiramatsu 831b498ce1fSMasami Hiramatsu return sl; 832b498ce1fSMasami Hiramatsu } 833b498ce1fSMasami Hiramatsu 8344235b045SMasami Hiramatsu static void write_kprobe_trace_event(int fd, struct kprobe_trace_event *tev) 83550656eecSMasami Hiramatsu { 83650656eecSMasami Hiramatsu int ret; 8374235b045SMasami Hiramatsu char *buf = synthesize_kprobe_trace_command(tev); 83850656eecSMasami Hiramatsu 839fa28244dSMasami Hiramatsu pr_debug("Writing event: %s\n", buf); 840f4d7da49SMasami Hiramatsu if (!probe_event_dry_run) { 84150656eecSMasami Hiramatsu ret = write(fd, buf, strlen(buf)); 84250656eecSMasami Hiramatsu if (ret <= 0) 843fa28244dSMasami Hiramatsu die("Failed to write event: %s", strerror(errno)); 84450656eecSMasami Hiramatsu } 8454235b045SMasami Hiramatsu free(buf); 846f4d7da49SMasami Hiramatsu } 84750656eecSMasami Hiramatsu 848b498ce1fSMasami Hiramatsu static void get_new_event_name(char *buf, size_t len, const char *base, 849d761b08bSMasami Hiramatsu struct strlist *namelist, bool allow_suffix) 850b498ce1fSMasami Hiramatsu { 851b498ce1fSMasami Hiramatsu int i, ret; 85217f88fcdSMasami Hiramatsu 85317f88fcdSMasami Hiramatsu /* Try no suffix */ 85417f88fcdSMasami Hiramatsu ret = e_snprintf(buf, len, "%s", base); 85517f88fcdSMasami Hiramatsu if (ret < 0) 85617f88fcdSMasami Hiramatsu die("snprintf() failed: %s", strerror(-ret)); 85717f88fcdSMasami Hiramatsu if (!strlist__has_entry(namelist, buf)) 85817f88fcdSMasami Hiramatsu return; 85917f88fcdSMasami Hiramatsu 860d761b08bSMasami Hiramatsu if (!allow_suffix) { 861d761b08bSMasami Hiramatsu pr_warning("Error: event \"%s\" already exists. " 862d761b08bSMasami Hiramatsu "(Use -f to force duplicates.)\n", base); 863d761b08bSMasami Hiramatsu die("Can't add new event."); 864d761b08bSMasami Hiramatsu } 865d761b08bSMasami Hiramatsu 86617f88fcdSMasami Hiramatsu /* Try to add suffix */ 86717f88fcdSMasami Hiramatsu for (i = 1; i < MAX_EVENT_INDEX; i++) { 868b498ce1fSMasami Hiramatsu ret = e_snprintf(buf, len, "%s_%d", base, i); 869b498ce1fSMasami Hiramatsu if (ret < 0) 870b498ce1fSMasami Hiramatsu die("snprintf() failed: %s", strerror(-ret)); 871b498ce1fSMasami Hiramatsu if (!strlist__has_entry(namelist, buf)) 872b498ce1fSMasami Hiramatsu break; 873b498ce1fSMasami Hiramatsu } 874b498ce1fSMasami Hiramatsu if (i == MAX_EVENT_INDEX) 875b498ce1fSMasami Hiramatsu die("Too many events are on the same function."); 876b498ce1fSMasami Hiramatsu } 877b498ce1fSMasami Hiramatsu 8784235b045SMasami Hiramatsu static void __add_kprobe_trace_events(struct perf_probe_event *pev, 8794235b045SMasami Hiramatsu struct kprobe_trace_event *tevs, 8804235b045SMasami Hiramatsu int ntevs, bool allow_suffix) 88150656eecSMasami Hiramatsu { 8824235b045SMasami Hiramatsu int i, fd; 8834235b045SMasami Hiramatsu struct kprobe_trace_event *tev; 8844235b045SMasami Hiramatsu char buf[64]; 8854235b045SMasami Hiramatsu const char *event, *group; 886b498ce1fSMasami Hiramatsu struct strlist *namelist; 88750656eecSMasami Hiramatsu 888f4d7da49SMasami Hiramatsu fd = open_kprobe_events(true); 889b498ce1fSMasami Hiramatsu /* Get current event names */ 8904235b045SMasami Hiramatsu namelist = get_kprobe_trace_event_names(fd, false); 89150656eecSMasami Hiramatsu 8924235b045SMasami Hiramatsu printf("Add new event%s\n", (ntevs > 1) ? "s:" : ":"); 8934235b045SMasami Hiramatsu for (i = 0; i < ntevs; i++) { 8944235b045SMasami Hiramatsu tev = &tevs[i]; 8954235b045SMasami Hiramatsu if (pev->event) 8964235b045SMasami Hiramatsu event = pev->event; 8974235b045SMasami Hiramatsu else 8984235b045SMasami Hiramatsu if (pev->point.function) 8994235b045SMasami Hiramatsu event = pev->point.function; 9004235b045SMasami Hiramatsu else 9014235b045SMasami Hiramatsu event = tev->point.symbol; 9024235b045SMasami Hiramatsu if (pev->group) 9034235b045SMasami Hiramatsu group = pev->group; 9044235b045SMasami Hiramatsu else 9054235b045SMasami Hiramatsu group = PERFPROBE_GROUP; 9064235b045SMasami Hiramatsu 907b498ce1fSMasami Hiramatsu /* Get an unused new event name */ 9084235b045SMasami Hiramatsu get_new_event_name(buf, 64, event, namelist, allow_suffix); 9094235b045SMasami Hiramatsu event = buf; 9104235b045SMasami Hiramatsu 9114235b045SMasami Hiramatsu tev->event = xstrdup(event); 9124235b045SMasami Hiramatsu tev->group = xstrdup(group); 9134235b045SMasami Hiramatsu write_kprobe_trace_event(fd, tev); 914b498ce1fSMasami Hiramatsu /* Add added event name to namelist */ 915b498ce1fSMasami Hiramatsu strlist__add(namelist, event); 9164235b045SMasami Hiramatsu 9174235b045SMasami Hiramatsu /* Trick here - save current event/group */ 9184235b045SMasami Hiramatsu event = pev->event; 9194235b045SMasami Hiramatsu group = pev->group; 9204235b045SMasami Hiramatsu pev->event = tev->event; 9214235b045SMasami Hiramatsu pev->group = tev->group; 9224235b045SMasami Hiramatsu show_perf_probe_event(pev); 9234235b045SMasami Hiramatsu /* Trick here - restore current event/group */ 9244235b045SMasami Hiramatsu pev->event = (char *)event; 9254235b045SMasami Hiramatsu pev->group = (char *)group; 9264235b045SMasami Hiramatsu 927d761b08bSMasami Hiramatsu /* 928d761b08bSMasami Hiramatsu * Probes after the first probe which comes from same 929d761b08bSMasami Hiramatsu * user input are always allowed to add suffix, because 930d761b08bSMasami Hiramatsu * there might be several addresses corresponding to 931d761b08bSMasami Hiramatsu * one code line. 932d761b08bSMasami Hiramatsu */ 933d761b08bSMasami Hiramatsu allow_suffix = true; 93450656eecSMasami Hiramatsu } 935a9b495b0SMasami Hiramatsu /* Show how to use the event. */ 936a9b495b0SMasami Hiramatsu printf("\nYou can now use it on all perf tools, such as:\n\n"); 9374235b045SMasami Hiramatsu printf("\tperf record -e %s:%s -a sleep 1\n\n", tev->group, tev->event); 938a9b495b0SMasami Hiramatsu 939e1d2017bSMasami Hiramatsu strlist__delete(namelist); 94050656eecSMasami Hiramatsu close(fd); 94150656eecSMasami Hiramatsu } 942fa28244dSMasami Hiramatsu 9434235b045SMasami Hiramatsu static int convert_to_kprobe_trace_events(struct perf_probe_event *pev, 9444235b045SMasami Hiramatsu struct kprobe_trace_event **tevs) 945e0faa8d3SMasami Hiramatsu { 946e0faa8d3SMasami Hiramatsu struct symbol *sym; 9474235b045SMasami Hiramatsu bool need_dwarf; 948e0faa8d3SMasami Hiramatsu #ifndef NO_DWARF_SUPPORT 949e0faa8d3SMasami Hiramatsu int fd; 950e0faa8d3SMasami Hiramatsu #endif 9514235b045SMasami Hiramatsu int ntevs = 0, i; 9524235b045SMasami Hiramatsu struct kprobe_trace_event *tev; 9534235b045SMasami Hiramatsu 9544235b045SMasami Hiramatsu need_dwarf = perf_probe_event_need_dwarf(pev); 955e0faa8d3SMasami Hiramatsu 956e0faa8d3SMasami Hiramatsu if (need_dwarf) 957e0faa8d3SMasami Hiramatsu #ifdef NO_DWARF_SUPPORT 958e0faa8d3SMasami Hiramatsu die("Debuginfo-analysis is not supported"); 959e0faa8d3SMasami Hiramatsu #else /* !NO_DWARF_SUPPORT */ 960e0faa8d3SMasami Hiramatsu pr_debug("Some probes require debuginfo.\n"); 961e0faa8d3SMasami Hiramatsu 962e0faa8d3SMasami Hiramatsu fd = open_vmlinux(); 963e0faa8d3SMasami Hiramatsu if (fd < 0) { 964e0faa8d3SMasami Hiramatsu if (need_dwarf) 965e0faa8d3SMasami Hiramatsu die("Could not open debuginfo file."); 966e0faa8d3SMasami Hiramatsu 967e0faa8d3SMasami Hiramatsu pr_debug("Could not open vmlinux/module file." 968e0faa8d3SMasami Hiramatsu " Try to use symbols.\n"); 969e0faa8d3SMasami Hiramatsu goto end_dwarf; 970e0faa8d3SMasami Hiramatsu } 971e0faa8d3SMasami Hiramatsu 972e0faa8d3SMasami Hiramatsu /* Searching probe points */ 9734235b045SMasami Hiramatsu ntevs = find_kprobe_trace_events(fd, pev, tevs); 974e0faa8d3SMasami Hiramatsu 9754235b045SMasami Hiramatsu if (ntevs > 0) /* Found */ 9764235b045SMasami Hiramatsu goto found; 9774235b045SMasami Hiramatsu 9784235b045SMasami Hiramatsu if (ntevs == 0) /* No error but failed to find probe point. */ 979e0faa8d3SMasami Hiramatsu die("Probe point '%s' not found. - probe not added.", 9804235b045SMasami Hiramatsu synthesize_perf_probe_point(&pev->point)); 9814235b045SMasami Hiramatsu 982e0faa8d3SMasami Hiramatsu /* Error path */ 983e0faa8d3SMasami Hiramatsu if (need_dwarf) { 9844235b045SMasami Hiramatsu if (ntevs == -ENOENT) 985e0faa8d3SMasami Hiramatsu pr_warning("No dwarf info found in the vmlinux - please rebuild with CONFIG_DEBUG_INFO=y.\n"); 986e0faa8d3SMasami Hiramatsu die("Could not analyze debuginfo."); 987e0faa8d3SMasami Hiramatsu } 988e0faa8d3SMasami Hiramatsu pr_debug("An error occurred in debuginfo analysis." 989e0faa8d3SMasami Hiramatsu " Try to use symbols.\n"); 990e0faa8d3SMasami Hiramatsu 991e0faa8d3SMasami Hiramatsu end_dwarf: 992e0faa8d3SMasami Hiramatsu #endif /* !NO_DWARF_SUPPORT */ 993e0faa8d3SMasami Hiramatsu 9944235b045SMasami Hiramatsu /* Allocate trace event buffer */ 9954235b045SMasami Hiramatsu ntevs = 1; 9964235b045SMasami Hiramatsu tev = *tevs = xzalloc(sizeof(struct kprobe_trace_event)); 997e0faa8d3SMasami Hiramatsu 9984235b045SMasami Hiramatsu /* Copy parameters */ 9994235b045SMasami Hiramatsu tev->point.symbol = xstrdup(pev->point.function); 10004235b045SMasami Hiramatsu tev->point.offset = pev->point.offset; 10014235b045SMasami Hiramatsu tev->nargs = pev->nargs; 10024235b045SMasami Hiramatsu if (tev->nargs) { 10034235b045SMasami Hiramatsu tev->args = xzalloc(sizeof(struct kprobe_trace_arg) 10044235b045SMasami Hiramatsu * tev->nargs); 10054235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) 10064235b045SMasami Hiramatsu tev->args[i].value = xstrdup(pev->args[i].name); 1007e0faa8d3SMasami Hiramatsu } 1008e0faa8d3SMasami Hiramatsu 10094235b045SMasami Hiramatsu /* Currently just checking function name from symbol map */ 10104235b045SMasami Hiramatsu sym = map__find_symbol_by_name(kmaps[MAP__FUNCTION], 10114235b045SMasami Hiramatsu tev->point.symbol, NULL); 10124235b045SMasami Hiramatsu if (!sym) 10134235b045SMasami Hiramatsu die("Kernel symbol \'%s\' not found - probe not added.", 10144235b045SMasami Hiramatsu tev->point.symbol); 10154235b045SMasami Hiramatsu found: 10164235b045SMasami Hiramatsu close(fd); 10174235b045SMasami Hiramatsu return ntevs; 10184235b045SMasami Hiramatsu } 10194235b045SMasami Hiramatsu 10204235b045SMasami Hiramatsu struct __event_package { 10214235b045SMasami Hiramatsu struct perf_probe_event *pev; 10224235b045SMasami Hiramatsu struct kprobe_trace_event *tevs; 10234235b045SMasami Hiramatsu int ntevs; 10244235b045SMasami Hiramatsu }; 10254235b045SMasami Hiramatsu 10264235b045SMasami Hiramatsu void add_perf_probe_events(struct perf_probe_event *pevs, int npevs, 10274235b045SMasami Hiramatsu bool force_add) 10284235b045SMasami Hiramatsu { 10294235b045SMasami Hiramatsu int i; 10304235b045SMasami Hiramatsu struct __event_package *pkgs; 10314235b045SMasami Hiramatsu 10324235b045SMasami Hiramatsu pkgs = xzalloc(sizeof(struct __event_package) * npevs); 10334235b045SMasami Hiramatsu 10344235b045SMasami Hiramatsu /* Init vmlinux path */ 10354235b045SMasami Hiramatsu init_vmlinux(); 10364235b045SMasami Hiramatsu 10374235b045SMasami Hiramatsu /* Loop 1: convert all events */ 10384235b045SMasami Hiramatsu for (i = 0; i < npevs; i++) { 10394235b045SMasami Hiramatsu pkgs[i].pev = &pevs[i]; 10404235b045SMasami Hiramatsu /* Convert with or without debuginfo */ 10414235b045SMasami Hiramatsu pkgs[i].ntevs = convert_to_kprobe_trace_events(pkgs[i].pev, 10424235b045SMasami Hiramatsu &pkgs[i].tevs); 10434235b045SMasami Hiramatsu } 10444235b045SMasami Hiramatsu 10454235b045SMasami Hiramatsu /* Loop 2: add all events */ 10464235b045SMasami Hiramatsu for (i = 0; i < npevs; i++) 10474235b045SMasami Hiramatsu __add_kprobe_trace_events(pkgs[i].pev, pkgs[i].tevs, 10484235b045SMasami Hiramatsu pkgs[i].ntevs, force_add); 10494235b045SMasami Hiramatsu /* TODO: cleanup all trace events? */ 1050e0faa8d3SMasami Hiramatsu } 1051e0faa8d3SMasami Hiramatsu 1052bbbb521bSMasami Hiramatsu static void __del_trace_kprobe_event(int fd, struct str_node *ent) 1053bbbb521bSMasami Hiramatsu { 1054bbbb521bSMasami Hiramatsu char *p; 1055bbbb521bSMasami Hiramatsu char buf[128]; 10564235b045SMasami Hiramatsu int ret; 1057bbbb521bSMasami Hiramatsu 1058bbbb521bSMasami Hiramatsu /* Convert from perf-probe event to trace-kprobe event */ 1059bbbb521bSMasami Hiramatsu if (e_snprintf(buf, 128, "-:%s", ent->s) < 0) 1060bbbb521bSMasami Hiramatsu die("Failed to copy event."); 1061bbbb521bSMasami Hiramatsu p = strchr(buf + 2, ':'); 1062bbbb521bSMasami Hiramatsu if (!p) 1063bbbb521bSMasami Hiramatsu die("Internal error: %s should have ':' but not.", ent->s); 1064bbbb521bSMasami Hiramatsu *p = '/'; 1065bbbb521bSMasami Hiramatsu 10664235b045SMasami Hiramatsu pr_debug("Writing event: %s\n", buf); 10674235b045SMasami Hiramatsu ret = write(fd, buf, strlen(buf)); 10684235b045SMasami Hiramatsu if (ret <= 0) 10694235b045SMasami Hiramatsu die("Failed to write event: %s", strerror(errno)); 1070bbbb521bSMasami Hiramatsu printf("Remove event: %s\n", ent->s); 1071bbbb521bSMasami Hiramatsu } 1072bbbb521bSMasami Hiramatsu 1073fa28244dSMasami Hiramatsu static void del_trace_kprobe_event(int fd, const char *group, 1074fa28244dSMasami Hiramatsu const char *event, struct strlist *namelist) 1075fa28244dSMasami Hiramatsu { 1076fa28244dSMasami Hiramatsu char buf[128]; 1077bbbb521bSMasami Hiramatsu struct str_node *ent, *n; 1078bbbb521bSMasami Hiramatsu int found = 0; 1079fa28244dSMasami Hiramatsu 1080fa28244dSMasami Hiramatsu if (e_snprintf(buf, 128, "%s:%s", group, event) < 0) 1081fa28244dSMasami Hiramatsu die("Failed to copy event."); 1082fa28244dSMasami Hiramatsu 1083bbbb521bSMasami Hiramatsu if (strpbrk(buf, "*?")) { /* Glob-exp */ 1084bbbb521bSMasami Hiramatsu strlist__for_each_safe(ent, n, namelist) 1085bbbb521bSMasami Hiramatsu if (strglobmatch(ent->s, buf)) { 1086bbbb521bSMasami Hiramatsu found++; 1087bbbb521bSMasami Hiramatsu __del_trace_kprobe_event(fd, ent); 10883e340590SMasami Hiramatsu strlist__remove(namelist, ent); 1089fa28244dSMasami Hiramatsu } 1090bbbb521bSMasami Hiramatsu } else { 1091bbbb521bSMasami Hiramatsu ent = strlist__find(namelist, buf); 1092bbbb521bSMasami Hiramatsu if (ent) { 1093bbbb521bSMasami Hiramatsu found++; 1094bbbb521bSMasami Hiramatsu __del_trace_kprobe_event(fd, ent); 1095bbbb521bSMasami Hiramatsu strlist__remove(namelist, ent); 1096bbbb521bSMasami Hiramatsu } 1097bbbb521bSMasami Hiramatsu } 1098bbbb521bSMasami Hiramatsu if (found == 0) 1099bbbb521bSMasami Hiramatsu pr_info("Info: event \"%s\" does not exist, could not remove it.\n", buf); 1100bbbb521bSMasami Hiramatsu } 1101fa28244dSMasami Hiramatsu 11024235b045SMasami Hiramatsu void del_perf_probe_events(struct strlist *dellist) 1103fa28244dSMasami Hiramatsu { 1104fa28244dSMasami Hiramatsu int fd; 1105fa28244dSMasami Hiramatsu const char *group, *event; 1106fa28244dSMasami Hiramatsu char *p, *str; 1107fa28244dSMasami Hiramatsu struct str_node *ent; 1108fa28244dSMasami Hiramatsu struct strlist *namelist; 1109fa28244dSMasami Hiramatsu 1110f4d7da49SMasami Hiramatsu fd = open_kprobe_events(true); 1111fa28244dSMasami Hiramatsu /* Get current event names */ 11124235b045SMasami Hiramatsu namelist = get_kprobe_trace_event_names(fd, true); 1113fa28244dSMasami Hiramatsu 1114adf365f4SMasami Hiramatsu strlist__for_each(ent, dellist) { 111531facc5fSMasami Hiramatsu str = xstrdup(ent->s); 1116bbbb521bSMasami Hiramatsu pr_debug("Parsing: %s\n", str); 1117fa28244dSMasami Hiramatsu p = strchr(str, ':'); 1118fa28244dSMasami Hiramatsu if (p) { 1119fa28244dSMasami Hiramatsu group = str; 1120fa28244dSMasami Hiramatsu *p = '\0'; 1121fa28244dSMasami Hiramatsu event = p + 1; 1122fa28244dSMasami Hiramatsu } else { 1123bbbb521bSMasami Hiramatsu group = "*"; 1124fa28244dSMasami Hiramatsu event = str; 1125fa28244dSMasami Hiramatsu } 1126bbbb521bSMasami Hiramatsu pr_debug("Group: %s, Event: %s\n", group, event); 1127fa28244dSMasami Hiramatsu del_trace_kprobe_event(fd, group, event, namelist); 1128fa28244dSMasami Hiramatsu free(str); 1129fa28244dSMasami Hiramatsu } 1130fa28244dSMasami Hiramatsu strlist__delete(namelist); 1131fa28244dSMasami Hiramatsu close(fd); 1132fa28244dSMasami Hiramatsu } 1133fa28244dSMasami Hiramatsu 1134631c9defSMasami Hiramatsu #define LINEBUF_SIZE 256 11355c8d1cbbSMasami Hiramatsu #define NR_ADDITIONAL_LINES 2 1136631c9defSMasami Hiramatsu 1137631c9defSMasami Hiramatsu static void show_one_line(FILE *fp, unsigned int l, bool skip, bool show_num) 1138631c9defSMasami Hiramatsu { 1139631c9defSMasami Hiramatsu char buf[LINEBUF_SIZE]; 1140631c9defSMasami Hiramatsu const char *color = PERF_COLOR_BLUE; 1141631c9defSMasami Hiramatsu 1142631c9defSMasami Hiramatsu if (fgets(buf, LINEBUF_SIZE, fp) == NULL) 1143631c9defSMasami Hiramatsu goto error; 1144631c9defSMasami Hiramatsu if (!skip) { 1145631c9defSMasami Hiramatsu if (show_num) 1146631c9defSMasami Hiramatsu fprintf(stdout, "%7u %s", l, buf); 1147631c9defSMasami Hiramatsu else 1148631c9defSMasami Hiramatsu color_fprintf(stdout, color, " %s", buf); 1149631c9defSMasami Hiramatsu } 1150631c9defSMasami Hiramatsu 1151631c9defSMasami Hiramatsu while (strlen(buf) == LINEBUF_SIZE - 1 && 1152631c9defSMasami Hiramatsu buf[LINEBUF_SIZE - 2] != '\n') { 1153631c9defSMasami Hiramatsu if (fgets(buf, LINEBUF_SIZE, fp) == NULL) 1154631c9defSMasami Hiramatsu goto error; 1155631c9defSMasami Hiramatsu if (!skip) { 1156631c9defSMasami Hiramatsu if (show_num) 1157631c9defSMasami Hiramatsu fprintf(stdout, "%s", buf); 1158631c9defSMasami Hiramatsu else 1159631c9defSMasami Hiramatsu color_fprintf(stdout, color, "%s", buf); 1160631c9defSMasami Hiramatsu } 1161631c9defSMasami Hiramatsu } 1162631c9defSMasami Hiramatsu return; 1163631c9defSMasami Hiramatsu error: 1164631c9defSMasami Hiramatsu if (feof(fp)) 1165631c9defSMasami Hiramatsu die("Source file is shorter than expected."); 1166631c9defSMasami Hiramatsu else 1167631c9defSMasami Hiramatsu die("File read error: %s", strerror(errno)); 1168631c9defSMasami Hiramatsu } 1169631c9defSMasami Hiramatsu 1170631c9defSMasami Hiramatsu void show_line_range(struct line_range *lr) 1171631c9defSMasami Hiramatsu { 1172631c9defSMasami Hiramatsu unsigned int l = 1; 1173631c9defSMasami Hiramatsu struct line_node *ln; 1174631c9defSMasami Hiramatsu FILE *fp; 1175e0faa8d3SMasami Hiramatsu int fd, ret; 1176e0faa8d3SMasami Hiramatsu 1177e0faa8d3SMasami Hiramatsu /* Search a line range */ 1178e0faa8d3SMasami Hiramatsu init_vmlinux(); 1179e0faa8d3SMasami Hiramatsu fd = open_vmlinux(); 1180e0faa8d3SMasami Hiramatsu if (fd < 0) 1181e0faa8d3SMasami Hiramatsu die("Could not open debuginfo file."); 1182e0faa8d3SMasami Hiramatsu ret = find_line_range(fd, lr); 1183e0faa8d3SMasami Hiramatsu if (ret <= 0) 1184e0faa8d3SMasami Hiramatsu die("Source line is not found.\n"); 1185e0faa8d3SMasami Hiramatsu close(fd); 1186631c9defSMasami Hiramatsu 1187631c9defSMasami Hiramatsu setup_pager(); 1188631c9defSMasami Hiramatsu 1189631c9defSMasami Hiramatsu if (lr->function) 1190631c9defSMasami Hiramatsu fprintf(stdout, "<%s:%d>\n", lr->function, 1191631c9defSMasami Hiramatsu lr->start - lr->offset); 1192631c9defSMasami Hiramatsu else 1193631c9defSMasami Hiramatsu fprintf(stdout, "<%s:%d>\n", lr->file, lr->start); 1194631c9defSMasami Hiramatsu 1195631c9defSMasami Hiramatsu fp = fopen(lr->path, "r"); 1196631c9defSMasami Hiramatsu if (fp == NULL) 1197631c9defSMasami Hiramatsu die("Failed to open %s: %s", lr->path, strerror(errno)); 1198631c9defSMasami Hiramatsu /* Skip to starting line number */ 1199631c9defSMasami Hiramatsu while (l < lr->start) 1200631c9defSMasami Hiramatsu show_one_line(fp, l++, true, false); 1201631c9defSMasami Hiramatsu 1202631c9defSMasami Hiramatsu list_for_each_entry(ln, &lr->line_list, list) { 1203631c9defSMasami Hiramatsu while (ln->line > l) 1204631c9defSMasami Hiramatsu show_one_line(fp, (l++) - lr->offset, false, false); 1205631c9defSMasami Hiramatsu show_one_line(fp, (l++) - lr->offset, false, true); 1206631c9defSMasami Hiramatsu } 12075c8d1cbbSMasami Hiramatsu 12085c8d1cbbSMasami Hiramatsu if (lr->end == INT_MAX) 12095c8d1cbbSMasami Hiramatsu lr->end = l + NR_ADDITIONAL_LINES; 12105c8d1cbbSMasami Hiramatsu while (l < lr->end && !feof(fp)) 12115c8d1cbbSMasami Hiramatsu show_one_line(fp, (l++) - lr->offset, false, false); 12125c8d1cbbSMasami Hiramatsu 1213631c9defSMasami Hiramatsu fclose(fp); 1214631c9defSMasami Hiramatsu } 1215e0faa8d3SMasami Hiramatsu 1216e0faa8d3SMasami Hiramatsu 1217