150656eecSMasami Hiramatsu /* 20e60836bSSrikar Dronamraju * probe-event.c : perf-probe definition to probe_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 #include <sys/utsname.h> 2350656eecSMasami Hiramatsu #include <sys/types.h> 2450656eecSMasami Hiramatsu #include <sys/stat.h> 2550656eecSMasami Hiramatsu #include <fcntl.h> 2650656eecSMasami Hiramatsu #include <errno.h> 2750656eecSMasami Hiramatsu #include <stdio.h> 2850656eecSMasami Hiramatsu #include <unistd.h> 2950656eecSMasami Hiramatsu #include <stdlib.h> 3050656eecSMasami Hiramatsu #include <string.h> 314de189feSMasami Hiramatsu #include <stdarg.h> 324de189feSMasami Hiramatsu #include <limits.h> 33e80711caSMasami Hiramatsu #include <elf.h> 3450656eecSMasami Hiramatsu 3531facc5fSMasami Hiramatsu #include "util.h" 3650656eecSMasami Hiramatsu #include "event.h" 374de189feSMasami Hiramatsu #include "strlist.h" 3850656eecSMasami Hiramatsu #include "debug.h" 3972041334SMasami Hiramatsu #include "cache.h" 40631c9defSMasami Hiramatsu #include "color.h" 41e0faa8d3SMasami Hiramatsu #include "symbol.h" 42e0faa8d3SMasami Hiramatsu #include "thread.h" 43553873e1SBorislav Petkov #include <api/fs/debugfs.h> 4423773ca1SSteven Rostedt (Red Hat) #include <api/fs/tracefs.h> 451d037ca1SIrina Tirdea #include "trace-event.h" /* For __maybe_unused */ 4650656eecSMasami Hiramatsu #include "probe-event.h" 474235b045SMasami Hiramatsu #include "probe-finder.h" 48225466f1SSrikar Dronamraju #include "session.h" 4950656eecSMasami Hiramatsu 5050656eecSMasami Hiramatsu #define MAX_CMDLEN 256 5150656eecSMasami Hiramatsu #define PERFPROBE_GROUP "probe" 5250656eecSMasami Hiramatsu 53f4d7da49SMasami Hiramatsu bool probe_event_dry_run; /* Dry run flag */ 54f4d7da49SMasami Hiramatsu 55146a1439SMasami Hiramatsu #define semantic_error(msg ...) pr_err("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 734b4da7f7SMasami Hiramatsu static char *synthesize_perf_probe_point(struct perf_probe_point *pp); 74981d05adSMasami Hiramatsu static void clear_probe_trace_event(struct probe_trace_event *tev); 75ee45b6c2SMasami Hiramatsu static struct machine *host_machine; 76e0faa8d3SMasami Hiramatsu 77469b9b88SMasami Hiramatsu /* Initialize symbol maps and path of vmlinux/modules */ 78ee45b6c2SMasami Hiramatsu static int init_symbol_maps(bool user_only) 79e0faa8d3SMasami Hiramatsu { 80146a1439SMasami Hiramatsu int ret; 81146a1439SMasami Hiramatsu 82e0faa8d3SMasami Hiramatsu symbol_conf.sort_by_name = true; 83680d926aSNamhyung Kim symbol_conf.allow_aliases = true; 840a7e6d1bSNamhyung Kim ret = symbol__init(NULL); 85146a1439SMasami Hiramatsu if (ret < 0) { 86146a1439SMasami Hiramatsu pr_debug("Failed to init symbol map.\n"); 87146a1439SMasami Hiramatsu goto out; 88146a1439SMasami Hiramatsu } 89e0faa8d3SMasami Hiramatsu 90ee45b6c2SMasami Hiramatsu if (host_machine || user_only) /* already initialized */ 91ee45b6c2SMasami Hiramatsu return 0; 92d28c6223SArnaldo Carvalho de Melo 93ee45b6c2SMasami Hiramatsu if (symbol_conf.vmlinux_name) 94ee45b6c2SMasami Hiramatsu pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name); 95ee45b6c2SMasami Hiramatsu 96ee45b6c2SMasami Hiramatsu host_machine = machine__new_host(); 97ee45b6c2SMasami Hiramatsu if (!host_machine) { 98ee45b6c2SMasami Hiramatsu pr_debug("machine__new_host() failed.\n"); 99ee45b6c2SMasami Hiramatsu symbol__exit(); 100ee45b6c2SMasami Hiramatsu ret = -1; 101469b9b88SMasami Hiramatsu } 102146a1439SMasami Hiramatsu out: 103146a1439SMasami Hiramatsu if (ret < 0) 104146a1439SMasami Hiramatsu pr_warning("Failed to init vmlinux path.\n"); 105146a1439SMasami Hiramatsu return ret; 106e0faa8d3SMasami Hiramatsu } 107e0faa8d3SMasami Hiramatsu 108ee45b6c2SMasami Hiramatsu static void exit_symbol_maps(void) 109ee45b6c2SMasami Hiramatsu { 110ee45b6c2SMasami Hiramatsu if (host_machine) { 111ee45b6c2SMasami Hiramatsu machine__delete(host_machine); 112ee45b6c2SMasami Hiramatsu host_machine = NULL; 113ee45b6c2SMasami Hiramatsu } 114ee45b6c2SMasami Hiramatsu symbol__exit(); 115ee45b6c2SMasami Hiramatsu } 116ee45b6c2SMasami Hiramatsu 117469b9b88SMasami Hiramatsu static struct symbol *__find_kernel_function_by_name(const char *name, 118469b9b88SMasami Hiramatsu struct map **mapp) 119e0faa8d3SMasami Hiramatsu { 120ee45b6c2SMasami Hiramatsu return machine__find_kernel_function_by_name(host_machine, name, mapp, 121469b9b88SMasami Hiramatsu NULL); 122e0faa8d3SMasami Hiramatsu } 123469b9b88SMasami Hiramatsu 1248f33f7deSMasami Hiramatsu static struct symbol *__find_kernel_function(u64 addr, struct map **mapp) 1258f33f7deSMasami Hiramatsu { 1268f33f7deSMasami Hiramatsu return machine__find_kernel_function(host_machine, addr, mapp, NULL); 1278f33f7deSMasami Hiramatsu } 1288f33f7deSMasami Hiramatsu 1298f33f7deSMasami Hiramatsu static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void) 1308f33f7deSMasami Hiramatsu { 1318f33f7deSMasami Hiramatsu /* kmap->ref_reloc_sym should be set if host_machine is initialized */ 1328f33f7deSMasami Hiramatsu struct kmap *kmap; 1338f33f7deSMasami Hiramatsu 1348f33f7deSMasami Hiramatsu if (map__load(host_machine->vmlinux_maps[MAP__FUNCTION], NULL) < 0) 1358f33f7deSMasami Hiramatsu return NULL; 1368f33f7deSMasami Hiramatsu 1378f33f7deSMasami Hiramatsu kmap = map__kmap(host_machine->vmlinux_maps[MAP__FUNCTION]); 138ba92732eSWang Nan if (!kmap) 139ba92732eSWang Nan return NULL; 1408f33f7deSMasami Hiramatsu return kmap->ref_reloc_sym; 1418f33f7deSMasami Hiramatsu } 1428f33f7deSMasami Hiramatsu 1438f33f7deSMasami Hiramatsu static u64 kernel_get_symbol_address_by_name(const char *name, bool reloc) 1448f33f7deSMasami Hiramatsu { 1458f33f7deSMasami Hiramatsu struct ref_reloc_sym *reloc_sym; 1468f33f7deSMasami Hiramatsu struct symbol *sym; 1478f33f7deSMasami Hiramatsu struct map *map; 1488f33f7deSMasami Hiramatsu 1498f33f7deSMasami Hiramatsu /* ref_reloc_sym is just a label. Need a special fix*/ 1508f33f7deSMasami Hiramatsu reloc_sym = kernel_get_ref_reloc_sym(); 1518f33f7deSMasami Hiramatsu if (reloc_sym && strcmp(name, reloc_sym->name) == 0) 1528f33f7deSMasami Hiramatsu return (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr; 1538f33f7deSMasami Hiramatsu else { 1548f33f7deSMasami Hiramatsu sym = __find_kernel_function_by_name(name, &map); 1558f33f7deSMasami Hiramatsu if (sym) 1568f33f7deSMasami Hiramatsu return map->unmap_ip(map, sym->start) - 157f56847c2SHe Kuang ((reloc) ? 0 : map->reloc); 1588f33f7deSMasami Hiramatsu } 1598f33f7deSMasami Hiramatsu return 0; 1608f33f7deSMasami Hiramatsu } 1618f33f7deSMasami Hiramatsu 162e80711caSMasami Hiramatsu static struct map *kernel_get_module_map(const char *module) 163e80711caSMasami Hiramatsu { 164e80711caSMasami Hiramatsu struct rb_node *nd; 165ee45b6c2SMasami Hiramatsu struct map_groups *grp = &host_machine->kmaps; 166e80711caSMasami Hiramatsu 16714a8fd7cSMasami Hiramatsu /* A file path -- this is an offline module */ 16814a8fd7cSMasami Hiramatsu if (module && strchr(module, '/')) 169ee45b6c2SMasami Hiramatsu return machine__new_module(host_machine, 0, module); 17014a8fd7cSMasami Hiramatsu 171e80711caSMasami Hiramatsu if (!module) 172e80711caSMasami Hiramatsu module = "kernel"; 173e80711caSMasami Hiramatsu 174e80711caSMasami Hiramatsu for (nd = rb_first(&grp->maps[MAP__FUNCTION]); nd; nd = rb_next(nd)) { 175e80711caSMasami Hiramatsu struct map *pos = rb_entry(nd, struct map, rb_node); 176e80711caSMasami Hiramatsu if (strncmp(pos->dso->short_name + 1, module, 177e80711caSMasami Hiramatsu pos->dso->short_name_len - 2) == 0) { 178e80711caSMasami Hiramatsu return pos; 179e80711caSMasami Hiramatsu } 180e80711caSMasami Hiramatsu } 181e80711caSMasami Hiramatsu return NULL; 182e80711caSMasami Hiramatsu } 183e80711caSMasami Hiramatsu 1849b118acaSMasami Hiramatsu static struct map *get_target_map(const char *target, bool user) 1859b118acaSMasami Hiramatsu { 1869b118acaSMasami Hiramatsu /* Init maps of given executable or kernel */ 1879b118acaSMasami Hiramatsu if (user) 1889b118acaSMasami Hiramatsu return dso__new_map(target); 1899b118acaSMasami Hiramatsu else 1909b118acaSMasami Hiramatsu return kernel_get_module_map(target); 1919b118acaSMasami Hiramatsu } 1929b118acaSMasami Hiramatsu 1939b118acaSMasami Hiramatsu static void put_target_map(struct map *map, bool user) 1949b118acaSMasami Hiramatsu { 1959b118acaSMasami Hiramatsu if (map && user) { 1969b118acaSMasami Hiramatsu /* Only the user map needs to be released */ 1979b118acaSMasami Hiramatsu dso__delete(map->dso); 1989b118acaSMasami Hiramatsu map__delete(map); 1999b118acaSMasami Hiramatsu } 2009b118acaSMasami Hiramatsu } 2019b118acaSMasami Hiramatsu 2029b118acaSMasami Hiramatsu 203e80711caSMasami Hiramatsu static struct dso *kernel_get_module_dso(const char *module) 204469b9b88SMasami Hiramatsu { 205469b9b88SMasami Hiramatsu struct dso *dso; 206fd930ff9SFranck Bui-Huu struct map *map; 207fd930ff9SFranck Bui-Huu const char *vmlinux_name; 208469b9b88SMasami Hiramatsu 209469b9b88SMasami Hiramatsu if (module) { 2108fa7d87fSWaiman Long list_for_each_entry(dso, &host_machine->kernel_dsos.head, 2118fa7d87fSWaiman Long node) { 212469b9b88SMasami Hiramatsu if (strncmp(dso->short_name + 1, module, 213469b9b88SMasami Hiramatsu dso->short_name_len - 2) == 0) 214469b9b88SMasami Hiramatsu goto found; 215469b9b88SMasami Hiramatsu } 216469b9b88SMasami Hiramatsu pr_debug("Failed to find module %s.\n", module); 217469b9b88SMasami Hiramatsu return NULL; 218fd930ff9SFranck Bui-Huu } 219fd930ff9SFranck Bui-Huu 220ee45b6c2SMasami Hiramatsu map = host_machine->vmlinux_maps[MAP__FUNCTION]; 221fd930ff9SFranck Bui-Huu dso = map->dso; 222fd930ff9SFranck Bui-Huu 223fd930ff9SFranck Bui-Huu vmlinux_name = symbol_conf.vmlinux_name; 224fd930ff9SFranck Bui-Huu if (vmlinux_name) { 2255230fb7dSArnaldo Carvalho de Melo if (dso__load_vmlinux(dso, map, vmlinux_name, false, NULL) <= 0) 226fd930ff9SFranck Bui-Huu return NULL; 227469b9b88SMasami Hiramatsu } else { 228c3a34e06SFranck Bui-Huu if (dso__load_vmlinux_path(dso, map, NULL) <= 0) { 229469b9b88SMasami Hiramatsu pr_debug("Failed to load kernel map.\n"); 230469b9b88SMasami Hiramatsu return NULL; 231469b9b88SMasami Hiramatsu } 232469b9b88SMasami Hiramatsu } 233469b9b88SMasami Hiramatsu found: 234e80711caSMasami Hiramatsu return dso; 235e80711caSMasami Hiramatsu } 236e80711caSMasami Hiramatsu 237e80711caSMasami Hiramatsu const char *kernel_get_module_path(const char *module) 238e80711caSMasami Hiramatsu { 239e80711caSMasami Hiramatsu struct dso *dso = kernel_get_module_dso(module); 240e80711caSMasami Hiramatsu return (dso) ? dso->long_name : NULL; 241469b9b88SMasami Hiramatsu } 242469b9b88SMasami Hiramatsu 243fb7345bbSMasami Hiramatsu static int convert_exec_to_group(const char *exec, char **result) 244fb7345bbSMasami Hiramatsu { 245fb7345bbSMasami Hiramatsu char *ptr1, *ptr2, *exec_copy; 246fb7345bbSMasami Hiramatsu char buf[64]; 247fb7345bbSMasami Hiramatsu int ret; 248fb7345bbSMasami Hiramatsu 249fb7345bbSMasami Hiramatsu exec_copy = strdup(exec); 250fb7345bbSMasami Hiramatsu if (!exec_copy) 251fb7345bbSMasami Hiramatsu return -ENOMEM; 252fb7345bbSMasami Hiramatsu 253fb7345bbSMasami Hiramatsu ptr1 = basename(exec_copy); 254fb7345bbSMasami Hiramatsu if (!ptr1) { 255fb7345bbSMasami Hiramatsu ret = -EINVAL; 256fb7345bbSMasami Hiramatsu goto out; 257fb7345bbSMasami Hiramatsu } 258fb7345bbSMasami Hiramatsu 259fb7345bbSMasami Hiramatsu ptr2 = strpbrk(ptr1, "-._"); 260fb7345bbSMasami Hiramatsu if (ptr2) 261fb7345bbSMasami Hiramatsu *ptr2 = '\0'; 262fb7345bbSMasami Hiramatsu ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1); 263fb7345bbSMasami Hiramatsu if (ret < 0) 264fb7345bbSMasami Hiramatsu goto out; 265fb7345bbSMasami Hiramatsu 266fb7345bbSMasami Hiramatsu *result = strdup(buf); 267fb7345bbSMasami Hiramatsu ret = *result ? 0 : -ENOMEM; 268fb7345bbSMasami Hiramatsu 269fb7345bbSMasami Hiramatsu out: 270fb7345bbSMasami Hiramatsu free(exec_copy); 271fb7345bbSMasami Hiramatsu return ret; 272fb7345bbSMasami Hiramatsu } 273fb7345bbSMasami Hiramatsu 2749b118acaSMasami Hiramatsu static void clear_perf_probe_point(struct perf_probe_point *pp) 2759b118acaSMasami Hiramatsu { 2769b118acaSMasami Hiramatsu free(pp->file); 2779b118acaSMasami Hiramatsu free(pp->function); 2789b118acaSMasami Hiramatsu free(pp->lazy_line); 2799b118acaSMasami Hiramatsu } 2809b118acaSMasami Hiramatsu 281eb948e50SMasami Hiramatsu static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs) 282eb948e50SMasami Hiramatsu { 283eb948e50SMasami Hiramatsu int i; 284eb948e50SMasami Hiramatsu 285eb948e50SMasami Hiramatsu for (i = 0; i < ntevs; i++) 286eb948e50SMasami Hiramatsu clear_probe_trace_event(tevs + i); 287eb948e50SMasami Hiramatsu } 288eb948e50SMasami Hiramatsu 28989fe808aSIngo Molnar #ifdef HAVE_DWARF_SUPPORT 2909b118acaSMasami Hiramatsu /* 2919b118acaSMasami Hiramatsu * Some binaries like glibc have special symbols which are on the symbol 2929b118acaSMasami Hiramatsu * table, but not in the debuginfo. If we can find the address of the 2939b118acaSMasami Hiramatsu * symbol from map, we can translate the address back to the probe point. 2949b118acaSMasami Hiramatsu */ 2959b118acaSMasami Hiramatsu static int find_alternative_probe_point(struct debuginfo *dinfo, 2969b118acaSMasami Hiramatsu struct perf_probe_point *pp, 2979b118acaSMasami Hiramatsu struct perf_probe_point *result, 2989b118acaSMasami Hiramatsu const char *target, bool uprobes) 2999b118acaSMasami Hiramatsu { 3009b118acaSMasami Hiramatsu struct map *map = NULL; 3019b118acaSMasami Hiramatsu struct symbol *sym; 3029b118acaSMasami Hiramatsu u64 address = 0; 3039b118acaSMasami Hiramatsu int ret = -ENOENT; 3049b118acaSMasami Hiramatsu 3059b118acaSMasami Hiramatsu /* This can work only for function-name based one */ 3069b118acaSMasami Hiramatsu if (!pp->function || pp->file) 3079b118acaSMasami Hiramatsu return -ENOTSUP; 3089b118acaSMasami Hiramatsu 3099b118acaSMasami Hiramatsu map = get_target_map(target, uprobes); 3109b118acaSMasami Hiramatsu if (!map) 3119b118acaSMasami Hiramatsu return -EINVAL; 3129b118acaSMasami Hiramatsu 3139b118acaSMasami Hiramatsu /* Find the address of given function */ 3149b118acaSMasami Hiramatsu map__for_each_symbol_by_name(map, pp->function, sym) { 315e6d7c91cSMasami Hiramatsu if (uprobes) 3169b118acaSMasami Hiramatsu address = sym->start; 317e6d7c91cSMasami Hiramatsu else 318e6d7c91cSMasami Hiramatsu address = map->unmap_ip(map, sym->start); 3199b118acaSMasami Hiramatsu break; 3209b118acaSMasami Hiramatsu } 3219b118acaSMasami Hiramatsu if (!address) { 3229b118acaSMasami Hiramatsu ret = -ENOENT; 3239b118acaSMasami Hiramatsu goto out; 3249b118acaSMasami Hiramatsu } 325f6c15621SWang Nan pr_debug("Symbol %s address found : %" PRIx64 "\n", 326f6c15621SWang Nan pp->function, address); 3279b118acaSMasami Hiramatsu 3289b118acaSMasami Hiramatsu ret = debuginfo__find_probe_point(dinfo, (unsigned long)address, 3299b118acaSMasami Hiramatsu result); 3309b118acaSMasami Hiramatsu if (ret <= 0) 3319b118acaSMasami Hiramatsu ret = (!ret) ? -ENOENT : ret; 3329b118acaSMasami Hiramatsu else { 3339b118acaSMasami Hiramatsu result->offset += pp->offset; 3349b118acaSMasami Hiramatsu result->line += pp->line; 3359d7b45c5SHe Kuang result->retprobe = pp->retprobe; 3369b118acaSMasami Hiramatsu ret = 0; 3379b118acaSMasami Hiramatsu } 3389b118acaSMasami Hiramatsu 3399b118acaSMasami Hiramatsu out: 3409b118acaSMasami Hiramatsu put_target_map(map, uprobes); 3419b118acaSMasami Hiramatsu return ret; 3429b118acaSMasami Hiramatsu 3439b118acaSMasami Hiramatsu } 3449b118acaSMasami Hiramatsu 3459b118acaSMasami Hiramatsu static int get_alternative_probe_event(struct debuginfo *dinfo, 3469b118acaSMasami Hiramatsu struct perf_probe_event *pev, 3479b118acaSMasami Hiramatsu struct perf_probe_point *tmp, 3489b118acaSMasami Hiramatsu const char *target) 3499b118acaSMasami Hiramatsu { 3509b118acaSMasami Hiramatsu int ret; 3519b118acaSMasami Hiramatsu 3529b118acaSMasami Hiramatsu memcpy(tmp, &pev->point, sizeof(*tmp)); 3539b118acaSMasami Hiramatsu memset(&pev->point, 0, sizeof(pev->point)); 3549b118acaSMasami Hiramatsu ret = find_alternative_probe_point(dinfo, tmp, &pev->point, 3559b118acaSMasami Hiramatsu target, pev->uprobes); 3569b118acaSMasami Hiramatsu if (ret < 0) 3579b118acaSMasami Hiramatsu memcpy(&pev->point, tmp, sizeof(*tmp)); 3589b118acaSMasami Hiramatsu 3599b118acaSMasami Hiramatsu return ret; 3609b118acaSMasami Hiramatsu } 361a15ad2f5SMasami Hiramatsu 362811dd2aeSMasami Hiramatsu static int get_alternative_line_range(struct debuginfo *dinfo, 363811dd2aeSMasami Hiramatsu struct line_range *lr, 364811dd2aeSMasami Hiramatsu const char *target, bool user) 365811dd2aeSMasami Hiramatsu { 3666d4a4896SDavid Ahern struct perf_probe_point pp = { .function = lr->function, 3676d4a4896SDavid Ahern .file = lr->file, 3686d4a4896SDavid Ahern .line = lr->start }; 3696d4a4896SDavid Ahern struct perf_probe_point result; 370811dd2aeSMasami Hiramatsu int ret, len = 0; 371811dd2aeSMasami Hiramatsu 3726d4a4896SDavid Ahern memset(&result, 0, sizeof(result)); 3736d4a4896SDavid Ahern 374811dd2aeSMasami Hiramatsu if (lr->end != INT_MAX) 375811dd2aeSMasami Hiramatsu len = lr->end - lr->start; 376811dd2aeSMasami Hiramatsu ret = find_alternative_probe_point(dinfo, &pp, &result, 377811dd2aeSMasami Hiramatsu target, user); 378811dd2aeSMasami Hiramatsu if (!ret) { 379811dd2aeSMasami Hiramatsu lr->function = result.function; 380811dd2aeSMasami Hiramatsu lr->file = result.file; 381811dd2aeSMasami Hiramatsu lr->start = result.line; 382811dd2aeSMasami Hiramatsu if (lr->end != INT_MAX) 383811dd2aeSMasami Hiramatsu lr->end = lr->start + len; 384811dd2aeSMasami Hiramatsu clear_perf_probe_point(&pp); 385811dd2aeSMasami Hiramatsu } 386811dd2aeSMasami Hiramatsu return ret; 387811dd2aeSMasami Hiramatsu } 388811dd2aeSMasami Hiramatsu 389ff741783SMasami Hiramatsu /* Open new debuginfo of given module */ 39092561cb7SMasami Hiramatsu static struct debuginfo *open_debuginfo(const char *module, bool silent) 391469b9b88SMasami Hiramatsu { 392a15ad2f5SMasami Hiramatsu const char *path = module; 39392561cb7SMasami Hiramatsu struct debuginfo *ret; 39414a8fd7cSMasami Hiramatsu 395a15ad2f5SMasami Hiramatsu if (!module || !strchr(module, '/')) { 39614a8fd7cSMasami Hiramatsu path = kernel_get_module_path(module); 397469b9b88SMasami Hiramatsu if (!path) { 39892561cb7SMasami Hiramatsu if (!silent) 3990e43e5d2SMasami Hiramatsu pr_err("Failed to find path of %s module.\n", 4000e43e5d2SMasami Hiramatsu module ?: "kernel"); 401ff741783SMasami Hiramatsu return NULL; 402469b9b88SMasami Hiramatsu } 40314a8fd7cSMasami Hiramatsu } 40492561cb7SMasami Hiramatsu ret = debuginfo__new(path); 40592561cb7SMasami Hiramatsu if (!ret && !silent) { 40692561cb7SMasami Hiramatsu pr_warning("The %s file has no debug information.\n", path); 40792561cb7SMasami Hiramatsu if (!module || !strtailcmp(path, ".ko")) 40892561cb7SMasami Hiramatsu pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, "); 40992561cb7SMasami Hiramatsu else 41092561cb7SMasami Hiramatsu pr_warning("Rebuild with -g, "); 41192561cb7SMasami Hiramatsu pr_warning("or install an appropriate debuginfo package.\n"); 412e0faa8d3SMasami Hiramatsu } 41392561cb7SMasami Hiramatsu return ret; 41492561cb7SMasami Hiramatsu } 41592561cb7SMasami Hiramatsu 4164b4da7f7SMasami Hiramatsu 41799ca4233SMasami Hiramatsu static int get_text_start_address(const char *exec, unsigned long *address) 41899ca4233SMasami Hiramatsu { 41999ca4233SMasami Hiramatsu Elf *elf; 42099ca4233SMasami Hiramatsu GElf_Ehdr ehdr; 42199ca4233SMasami Hiramatsu GElf_Shdr shdr; 42299ca4233SMasami Hiramatsu int fd, ret = -ENOENT; 42399ca4233SMasami Hiramatsu 42499ca4233SMasami Hiramatsu fd = open(exec, O_RDONLY); 42599ca4233SMasami Hiramatsu if (fd < 0) 42699ca4233SMasami Hiramatsu return -errno; 42799ca4233SMasami Hiramatsu 42899ca4233SMasami Hiramatsu elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 42999ca4233SMasami Hiramatsu if (elf == NULL) 43099ca4233SMasami Hiramatsu return -EINVAL; 43199ca4233SMasami Hiramatsu 43299ca4233SMasami Hiramatsu if (gelf_getehdr(elf, &ehdr) == NULL) 43399ca4233SMasami Hiramatsu goto out; 43499ca4233SMasami Hiramatsu 43599ca4233SMasami Hiramatsu if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL)) 43699ca4233SMasami Hiramatsu goto out; 43799ca4233SMasami Hiramatsu 43899ca4233SMasami Hiramatsu *address = shdr.sh_addr - shdr.sh_offset; 43999ca4233SMasami Hiramatsu ret = 0; 44099ca4233SMasami Hiramatsu out: 44199ca4233SMasami Hiramatsu elf_end(elf); 44299ca4233SMasami Hiramatsu return ret; 44399ca4233SMasami Hiramatsu } 44499ca4233SMasami Hiramatsu 4455a6f6314SMasami Hiramatsu /* 4465a6f6314SMasami Hiramatsu * Convert trace point to probe point with debuginfo 4475a6f6314SMasami Hiramatsu */ 4485a6f6314SMasami Hiramatsu static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp, 4495a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 4505a6f6314SMasami Hiramatsu bool is_kprobe) 4515a6f6314SMasami Hiramatsu { 4525a6f6314SMasami Hiramatsu struct debuginfo *dinfo = NULL; 4535a6f6314SMasami Hiramatsu unsigned long stext = 0; 4545a6f6314SMasami Hiramatsu u64 addr = tp->address; 4555a6f6314SMasami Hiramatsu int ret = -ENOENT; 4565a6f6314SMasami Hiramatsu 4575a6f6314SMasami Hiramatsu /* convert the address to dwarf address */ 4585a6f6314SMasami Hiramatsu if (!is_kprobe) { 4595a6f6314SMasami Hiramatsu if (!addr) { 4605a6f6314SMasami Hiramatsu ret = -EINVAL; 4615a6f6314SMasami Hiramatsu goto error; 4625a6f6314SMasami Hiramatsu } 4635a6f6314SMasami Hiramatsu ret = get_text_start_address(tp->module, &stext); 4645a6f6314SMasami Hiramatsu if (ret < 0) 4655a6f6314SMasami Hiramatsu goto error; 4665a6f6314SMasami Hiramatsu addr += stext; 4675a6f6314SMasami Hiramatsu } else { 4685a6f6314SMasami Hiramatsu addr = kernel_get_symbol_address_by_name(tp->symbol, false); 4695a6f6314SMasami Hiramatsu if (addr == 0) 4705a6f6314SMasami Hiramatsu goto error; 4715a6f6314SMasami Hiramatsu addr += tp->offset; 4725a6f6314SMasami Hiramatsu } 4735a6f6314SMasami Hiramatsu 4745a6f6314SMasami Hiramatsu pr_debug("try to find information at %" PRIx64 " in %s\n", addr, 4755a6f6314SMasami Hiramatsu tp->module ? : "kernel"); 4765a6f6314SMasami Hiramatsu 47792561cb7SMasami Hiramatsu dinfo = open_debuginfo(tp->module, verbose == 0); 4785a6f6314SMasami Hiramatsu if (dinfo) { 4795a6f6314SMasami Hiramatsu ret = debuginfo__find_probe_point(dinfo, 4805a6f6314SMasami Hiramatsu (unsigned long)addr, pp); 4815a6f6314SMasami Hiramatsu debuginfo__delete(dinfo); 48292561cb7SMasami Hiramatsu } else 4835a6f6314SMasami Hiramatsu ret = -ENOENT; 4845a6f6314SMasami Hiramatsu 4855a6f6314SMasami Hiramatsu if (ret > 0) { 4865a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 4875a6f6314SMasami Hiramatsu return 0; 4885a6f6314SMasami Hiramatsu } 4895a6f6314SMasami Hiramatsu error: 4905a6f6314SMasami Hiramatsu pr_debug("Failed to find corresponding probes from debuginfo.\n"); 4915a6f6314SMasami Hiramatsu return ret ? : -ENOENT; 4925a6f6314SMasami Hiramatsu } 4935a6f6314SMasami Hiramatsu 494fb7345bbSMasami Hiramatsu static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs, 495fb7345bbSMasami Hiramatsu int ntevs, const char *exec) 496fb7345bbSMasami Hiramatsu { 497fb7345bbSMasami Hiramatsu int i, ret = 0; 498eb948e50SMasami Hiramatsu unsigned long stext = 0; 499fb7345bbSMasami Hiramatsu 500fb7345bbSMasami Hiramatsu if (!exec) 501fb7345bbSMasami Hiramatsu return 0; 502fb7345bbSMasami Hiramatsu 503fb7345bbSMasami Hiramatsu ret = get_text_start_address(exec, &stext); 504fb7345bbSMasami Hiramatsu if (ret < 0) 505fb7345bbSMasami Hiramatsu return ret; 506fb7345bbSMasami Hiramatsu 507fb7345bbSMasami Hiramatsu for (i = 0; i < ntevs && ret >= 0; i++) { 508981a2379SMasami Hiramatsu /* point.address is the addres of point.symbol + point.offset */ 509eb948e50SMasami Hiramatsu tevs[i].point.address -= stext; 510fb7345bbSMasami Hiramatsu tevs[i].point.module = strdup(exec); 511eb948e50SMasami Hiramatsu if (!tevs[i].point.module) { 512fb7345bbSMasami Hiramatsu ret = -ENOMEM; 513fb7345bbSMasami Hiramatsu break; 514fb7345bbSMasami Hiramatsu } 515fb7345bbSMasami Hiramatsu tevs[i].uprobes = true; 516fb7345bbSMasami Hiramatsu } 517fb7345bbSMasami Hiramatsu 518fb7345bbSMasami Hiramatsu return ret; 519fb7345bbSMasami Hiramatsu } 520fb7345bbSMasami Hiramatsu 521190b57fcSMasami Hiramatsu static int add_module_to_probe_trace_events(struct probe_trace_event *tevs, 522190b57fcSMasami Hiramatsu int ntevs, const char *module) 523190b57fcSMasami Hiramatsu { 52414a8fd7cSMasami Hiramatsu int i, ret = 0; 52514a8fd7cSMasami Hiramatsu char *tmp; 52614a8fd7cSMasami Hiramatsu 52714a8fd7cSMasami Hiramatsu if (!module) 52814a8fd7cSMasami Hiramatsu return 0; 52914a8fd7cSMasami Hiramatsu 53014a8fd7cSMasami Hiramatsu tmp = strrchr(module, '/'); 53114a8fd7cSMasami Hiramatsu if (tmp) { 53214a8fd7cSMasami Hiramatsu /* This is a module path -- get the module name */ 53314a8fd7cSMasami Hiramatsu module = strdup(tmp + 1); 53414a8fd7cSMasami Hiramatsu if (!module) 53514a8fd7cSMasami Hiramatsu return -ENOMEM; 53614a8fd7cSMasami Hiramatsu tmp = strchr(module, '.'); 53714a8fd7cSMasami Hiramatsu if (tmp) 53814a8fd7cSMasami Hiramatsu *tmp = '\0'; 53914a8fd7cSMasami Hiramatsu tmp = (char *)module; /* For free() */ 54014a8fd7cSMasami Hiramatsu } 54114a8fd7cSMasami Hiramatsu 542190b57fcSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 543190b57fcSMasami Hiramatsu tevs[i].point.module = strdup(module); 54414a8fd7cSMasami Hiramatsu if (!tevs[i].point.module) { 54514a8fd7cSMasami Hiramatsu ret = -ENOMEM; 54614a8fd7cSMasami Hiramatsu break; 547190b57fcSMasami Hiramatsu } 54814a8fd7cSMasami Hiramatsu } 54914a8fd7cSMasami Hiramatsu 55014a8fd7cSMasami Hiramatsu free(tmp); 55114a8fd7cSMasami Hiramatsu return ret; 552190b57fcSMasami Hiramatsu } 553190b57fcSMasami Hiramatsu 554dfef99cdSMasami Hiramatsu /* Post processing the probe events */ 555dfef99cdSMasami Hiramatsu static int post_process_probe_trace_events(struct probe_trace_event *tevs, 556dfef99cdSMasami Hiramatsu int ntevs, const char *module, 557dfef99cdSMasami Hiramatsu bool uprobe) 558dfef99cdSMasami Hiramatsu { 559dfef99cdSMasami Hiramatsu struct ref_reloc_sym *reloc_sym; 560dfef99cdSMasami Hiramatsu char *tmp; 561dfef99cdSMasami Hiramatsu int i; 562dfef99cdSMasami Hiramatsu 563dfef99cdSMasami Hiramatsu if (uprobe) 564dfef99cdSMasami Hiramatsu return add_exec_to_probe_trace_events(tevs, ntevs, module); 565dfef99cdSMasami Hiramatsu 566dfef99cdSMasami Hiramatsu /* Note that currently ref_reloc_sym based probe is not for drivers */ 567dfef99cdSMasami Hiramatsu if (module) 568dfef99cdSMasami Hiramatsu return add_module_to_probe_trace_events(tevs, ntevs, module); 569dfef99cdSMasami Hiramatsu 5708f33f7deSMasami Hiramatsu reloc_sym = kernel_get_ref_reloc_sym(); 571dfef99cdSMasami Hiramatsu if (!reloc_sym) { 572dfef99cdSMasami Hiramatsu pr_warning("Relocated base symbol is not found!\n"); 573dfef99cdSMasami Hiramatsu return -EINVAL; 574dfef99cdSMasami Hiramatsu } 575dfef99cdSMasami Hiramatsu 576dfef99cdSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 57725dd9171SNamhyung Kim if (tevs[i].point.address && !tevs[i].point.retprobe) { 578dfef99cdSMasami Hiramatsu tmp = strdup(reloc_sym->name); 579dfef99cdSMasami Hiramatsu if (!tmp) 580dfef99cdSMasami Hiramatsu return -ENOMEM; 581dfef99cdSMasami Hiramatsu free(tevs[i].point.symbol); 582dfef99cdSMasami Hiramatsu tevs[i].point.symbol = tmp; 583dfef99cdSMasami Hiramatsu tevs[i].point.offset = tevs[i].point.address - 584dfef99cdSMasami Hiramatsu reloc_sym->unrelocated_addr; 585dfef99cdSMasami Hiramatsu } 586dfef99cdSMasami Hiramatsu } 587dfef99cdSMasami Hiramatsu return 0; 588dfef99cdSMasami Hiramatsu } 589dfef99cdSMasami Hiramatsu 5904b4da7f7SMasami Hiramatsu /* Try to find perf_probe_event with debuginfo */ 5910e60836bSSrikar Dronamraju static int try_to_find_probe_trace_events(struct perf_probe_event *pev, 5920e60836bSSrikar Dronamraju struct probe_trace_event **tevs, 5934eced234SSrikar Dronamraju int max_tevs, const char *target) 5944b4da7f7SMasami Hiramatsu { 5954b4da7f7SMasami Hiramatsu bool need_dwarf = perf_probe_event_need_dwarf(pev); 5969b118acaSMasami Hiramatsu struct perf_probe_point tmp; 597225466f1SSrikar Dronamraju struct debuginfo *dinfo; 598190b57fcSMasami Hiramatsu int ntevs, ret = 0; 5994b4da7f7SMasami Hiramatsu 60092561cb7SMasami Hiramatsu dinfo = open_debuginfo(target, !need_dwarf); 601225466f1SSrikar Dronamraju 602ff741783SMasami Hiramatsu if (!dinfo) { 60392561cb7SMasami Hiramatsu if (need_dwarf) 604ff741783SMasami Hiramatsu return -ENOENT; 605ff741783SMasami Hiramatsu pr_debug("Could not open debuginfo. Try to use symbols.\n"); 6064b4da7f7SMasami Hiramatsu return 0; 6074b4da7f7SMasami Hiramatsu } 6084b4da7f7SMasami Hiramatsu 609dfef99cdSMasami Hiramatsu pr_debug("Try to find probe point from debuginfo.\n"); 610ff741783SMasami Hiramatsu /* Searching trace events corresponding to a probe event */ 611ff741783SMasami Hiramatsu ntevs = debuginfo__find_trace_events(dinfo, pev, tevs, max_tevs); 612ff741783SMasami Hiramatsu 6139b118acaSMasami Hiramatsu if (ntevs == 0) { /* Not found, retry with an alternative */ 6149b118acaSMasami Hiramatsu ret = get_alternative_probe_event(dinfo, pev, &tmp, target); 6159b118acaSMasami Hiramatsu if (!ret) { 6169b118acaSMasami Hiramatsu ntevs = debuginfo__find_trace_events(dinfo, pev, 6179b118acaSMasami Hiramatsu tevs, max_tevs); 6189b118acaSMasami Hiramatsu /* 6199b118acaSMasami Hiramatsu * Write back to the original probe_event for 6209b118acaSMasami Hiramatsu * setting appropriate (user given) event name 6219b118acaSMasami Hiramatsu */ 6229b118acaSMasami Hiramatsu clear_perf_probe_point(&pev->point); 6239b118acaSMasami Hiramatsu memcpy(&pev->point, &tmp, sizeof(tmp)); 6249b118acaSMasami Hiramatsu } 6259b118acaSMasami Hiramatsu } 6269b118acaSMasami Hiramatsu 627ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 6284b4da7f7SMasami Hiramatsu 629146a1439SMasami Hiramatsu if (ntevs > 0) { /* Succeeded to find trace events */ 630dfef99cdSMasami Hiramatsu pr_debug("Found %d probe_trace_events.\n", ntevs); 631dfef99cdSMasami Hiramatsu ret = post_process_probe_trace_events(*tevs, ntevs, 632dfef99cdSMasami Hiramatsu target, pev->uprobes); 633981d05adSMasami Hiramatsu if (ret < 0) { 634981d05adSMasami Hiramatsu clear_probe_trace_events(*tevs, ntevs); 635981d05adSMasami Hiramatsu zfree(tevs); 636981d05adSMasami Hiramatsu } 637190b57fcSMasami Hiramatsu return ret < 0 ? ret : ntevs; 638146a1439SMasami Hiramatsu } 6394b4da7f7SMasami Hiramatsu 640146a1439SMasami Hiramatsu if (ntevs == 0) { /* No error but failed to find probe point. */ 6410687eba7SMasami Hiramatsu pr_warning("Probe point '%s' not found.\n", 6424b4da7f7SMasami Hiramatsu synthesize_perf_probe_point(&pev->point)); 643146a1439SMasami Hiramatsu return -ENOENT; 644146a1439SMasami Hiramatsu } 645146a1439SMasami Hiramatsu /* Error path : ntevs < 0 */ 64615eca306SMasami Hiramatsu pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs); 64715eca306SMasami Hiramatsu if (ntevs == -EBADF) { 64815eca306SMasami Hiramatsu pr_warning("Warning: No dwarf info found in the vmlinux - " 64915eca306SMasami Hiramatsu "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n"); 65015eca306SMasami Hiramatsu if (!need_dwarf) { 6510e43e5d2SMasami Hiramatsu pr_debug("Trying to use symbols.\n"); 6524b4da7f7SMasami Hiramatsu return 0; 6534b4da7f7SMasami Hiramatsu } 65415eca306SMasami Hiramatsu } 65515eca306SMasami Hiramatsu return ntevs; 65615eca306SMasami Hiramatsu } 6574b4da7f7SMasami Hiramatsu 6584b4da7f7SMasami Hiramatsu #define LINEBUF_SIZE 256 6594b4da7f7SMasami Hiramatsu #define NR_ADDITIONAL_LINES 2 6604b4da7f7SMasami Hiramatsu 661fde52dbdSFranck Bui-Huu static int __show_one_line(FILE *fp, int l, bool skip, bool show_num) 6624b4da7f7SMasami Hiramatsu { 6635f03cba4SMasami Hiramatsu char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE]; 664befe3414SFranck Bui-Huu const char *color = show_num ? "" : PERF_COLOR_BLUE; 665befe3414SFranck Bui-Huu const char *prefix = NULL; 6664b4da7f7SMasami Hiramatsu 667befe3414SFranck Bui-Huu do { 6684b4da7f7SMasami Hiramatsu if (fgets(buf, LINEBUF_SIZE, fp) == NULL) 6694b4da7f7SMasami Hiramatsu goto error; 670befe3414SFranck Bui-Huu if (skip) 671befe3414SFranck Bui-Huu continue; 672befe3414SFranck Bui-Huu if (!prefix) { 673befe3414SFranck Bui-Huu prefix = show_num ? "%7d " : " "; 674befe3414SFranck Bui-Huu color_fprintf(stdout, color, prefix, l); 6754b4da7f7SMasami Hiramatsu } 676befe3414SFranck Bui-Huu color_fprintf(stdout, color, "%s", buf); 6774b4da7f7SMasami Hiramatsu 678befe3414SFranck Bui-Huu } while (strchr(buf, '\n') == NULL); 679146a1439SMasami Hiramatsu 680fde52dbdSFranck Bui-Huu return 1; 6814b4da7f7SMasami Hiramatsu error: 682fde52dbdSFranck Bui-Huu if (ferror(fp)) { 6835f03cba4SMasami Hiramatsu pr_warning("File read error: %s\n", 6845f03cba4SMasami Hiramatsu strerror_r(errno, sbuf, sizeof(sbuf))); 685146a1439SMasami Hiramatsu return -1; 6864b4da7f7SMasami Hiramatsu } 687fde52dbdSFranck Bui-Huu return 0; 688fde52dbdSFranck Bui-Huu } 689fde52dbdSFranck Bui-Huu 690fde52dbdSFranck Bui-Huu static int _show_one_line(FILE *fp, int l, bool skip, bool show_num) 691fde52dbdSFranck Bui-Huu { 692fde52dbdSFranck Bui-Huu int rv = __show_one_line(fp, l, skip, show_num); 693fde52dbdSFranck Bui-Huu if (rv == 0) { 694fde52dbdSFranck Bui-Huu pr_warning("Source file is shorter than expected.\n"); 695fde52dbdSFranck Bui-Huu rv = -1; 696fde52dbdSFranck Bui-Huu } 697fde52dbdSFranck Bui-Huu return rv; 698fde52dbdSFranck Bui-Huu } 699fde52dbdSFranck Bui-Huu 700fde52dbdSFranck Bui-Huu #define show_one_line_with_num(f,l) _show_one_line(f,l,false,true) 701fde52dbdSFranck Bui-Huu #define show_one_line(f,l) _show_one_line(f,l,false,false) 702fde52dbdSFranck Bui-Huu #define skip_one_line(f,l) _show_one_line(f,l,true,false) 703fde52dbdSFranck Bui-Huu #define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false) 7044b4da7f7SMasami Hiramatsu 7054b4da7f7SMasami Hiramatsu /* 7064b4da7f7SMasami Hiramatsu * Show line-range always requires debuginfo to find source file and 7074b4da7f7SMasami Hiramatsu * line number. 7084b4da7f7SMasami Hiramatsu */ 709811dd2aeSMasami Hiramatsu static int __show_line_range(struct line_range *lr, const char *module, 710811dd2aeSMasami Hiramatsu bool user) 7114b4da7f7SMasami Hiramatsu { 712d3b63d7aSMasami Hiramatsu int l = 1; 7135a62257aSMasami Hiramatsu struct int_node *ln; 714ff741783SMasami Hiramatsu struct debuginfo *dinfo; 7154b4da7f7SMasami Hiramatsu FILE *fp; 716ff741783SMasami Hiramatsu int ret; 7177cf0b79eSMasami Hiramatsu char *tmp; 7185f03cba4SMasami Hiramatsu char sbuf[STRERR_BUFSIZE]; 7194b4da7f7SMasami Hiramatsu 7204b4da7f7SMasami Hiramatsu /* Search a line range */ 72192561cb7SMasami Hiramatsu dinfo = open_debuginfo(module, false); 72292561cb7SMasami Hiramatsu if (!dinfo) 723ff741783SMasami Hiramatsu return -ENOENT; 724146a1439SMasami Hiramatsu 725ff741783SMasami Hiramatsu ret = debuginfo__find_line_range(dinfo, lr); 726811dd2aeSMasami Hiramatsu if (!ret) { /* Not found, retry with an alternative */ 727811dd2aeSMasami Hiramatsu ret = get_alternative_line_range(dinfo, lr, module, user); 728811dd2aeSMasami Hiramatsu if (!ret) 729811dd2aeSMasami Hiramatsu ret = debuginfo__find_line_range(dinfo, lr); 730811dd2aeSMasami Hiramatsu } 731ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 7325ee05b88SMasami Hiramatsu if (ret == 0 || ret == -ENOENT) { 733146a1439SMasami Hiramatsu pr_warning("Specified source line is not found.\n"); 734146a1439SMasami Hiramatsu return -ENOENT; 735146a1439SMasami Hiramatsu } else if (ret < 0) { 7365ee05b88SMasami Hiramatsu pr_warning("Debuginfo analysis failed.\n"); 737146a1439SMasami Hiramatsu return ret; 738146a1439SMasami Hiramatsu } 7394b4da7f7SMasami Hiramatsu 7407cf0b79eSMasami Hiramatsu /* Convert source file path */ 7417cf0b79eSMasami Hiramatsu tmp = lr->path; 7426a330a3cSMasami Hiramatsu ret = get_real_path(tmp, lr->comp_dir, &lr->path); 743a78604deSHe Kuang 744a78604deSHe Kuang /* Free old path when new path is assigned */ 745a78604deSHe Kuang if (tmp != lr->path) 746a78604deSHe Kuang free(tmp); 747a78604deSHe Kuang 7487cf0b79eSMasami Hiramatsu if (ret < 0) { 7495ee05b88SMasami Hiramatsu pr_warning("Failed to find source file path.\n"); 7507cf0b79eSMasami Hiramatsu return ret; 7517cf0b79eSMasami Hiramatsu } 7527cf0b79eSMasami Hiramatsu 7534b4da7f7SMasami Hiramatsu setup_pager(); 7544b4da7f7SMasami Hiramatsu 7554b4da7f7SMasami Hiramatsu if (lr->function) 7568737ebdeSMasami Hiramatsu fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path, 7574b4da7f7SMasami Hiramatsu lr->start - lr->offset); 7584b4da7f7SMasami Hiramatsu else 75962c15fc4SFranck Bui-Huu fprintf(stdout, "<%s:%d>\n", lr->path, lr->start); 7604b4da7f7SMasami Hiramatsu 7614b4da7f7SMasami Hiramatsu fp = fopen(lr->path, "r"); 762146a1439SMasami Hiramatsu if (fp == NULL) { 763146a1439SMasami Hiramatsu pr_warning("Failed to open %s: %s\n", lr->path, 7645f03cba4SMasami Hiramatsu strerror_r(errno, sbuf, sizeof(sbuf))); 765146a1439SMasami Hiramatsu return -errno; 766146a1439SMasami Hiramatsu } 7674b4da7f7SMasami Hiramatsu /* Skip to starting line number */ 76844b81e92SFranck Bui-Huu while (l < lr->start) { 769fde52dbdSFranck Bui-Huu ret = skip_one_line(fp, l++); 770146a1439SMasami Hiramatsu if (ret < 0) 771146a1439SMasami Hiramatsu goto end; 77244b81e92SFranck Bui-Huu } 7734b4da7f7SMasami Hiramatsu 7745a62257aSMasami Hiramatsu intlist__for_each(ln, lr->line_list) { 7755a62257aSMasami Hiramatsu for (; ln->i > l; l++) { 776fde52dbdSFranck Bui-Huu ret = show_one_line(fp, l - lr->offset); 77744b81e92SFranck Bui-Huu if (ret < 0) 77844b81e92SFranck Bui-Huu goto end; 77944b81e92SFranck Bui-Huu } 780fde52dbdSFranck Bui-Huu ret = show_one_line_with_num(fp, l++ - lr->offset); 781146a1439SMasami Hiramatsu if (ret < 0) 782146a1439SMasami Hiramatsu goto end; 7834b4da7f7SMasami Hiramatsu } 7844b4da7f7SMasami Hiramatsu 7854b4da7f7SMasami Hiramatsu if (lr->end == INT_MAX) 7864b4da7f7SMasami Hiramatsu lr->end = l + NR_ADDITIONAL_LINES; 787fde52dbdSFranck Bui-Huu while (l <= lr->end) { 788fde52dbdSFranck Bui-Huu ret = show_one_line_or_eof(fp, l++ - lr->offset); 789fde52dbdSFranck Bui-Huu if (ret <= 0) 79044b81e92SFranck Bui-Huu break; 79144b81e92SFranck Bui-Huu } 792146a1439SMasami Hiramatsu end: 7934b4da7f7SMasami Hiramatsu fclose(fp); 794146a1439SMasami Hiramatsu return ret; 7954b4da7f7SMasami Hiramatsu } 7964b4da7f7SMasami Hiramatsu 7972b394bc4SMasami Hiramatsu int show_line_range(struct line_range *lr, const char *module, bool user) 798ee45b6c2SMasami Hiramatsu { 799ee45b6c2SMasami Hiramatsu int ret; 800ee45b6c2SMasami Hiramatsu 8012b394bc4SMasami Hiramatsu ret = init_symbol_maps(user); 802ee45b6c2SMasami Hiramatsu if (ret < 0) 803ee45b6c2SMasami Hiramatsu return ret; 804811dd2aeSMasami Hiramatsu ret = __show_line_range(lr, module, user); 805ee45b6c2SMasami Hiramatsu exit_symbol_maps(); 806ee45b6c2SMasami Hiramatsu 807ee45b6c2SMasami Hiramatsu return ret; 808ee45b6c2SMasami Hiramatsu } 809ee45b6c2SMasami Hiramatsu 810ff741783SMasami Hiramatsu static int show_available_vars_at(struct debuginfo *dinfo, 811ff741783SMasami Hiramatsu struct perf_probe_event *pev, 812bd09d7b5SMasami Hiramatsu int max_vls, struct strfilter *_filter, 8139b118acaSMasami Hiramatsu bool externs, const char *target) 814cf6eb489SMasami Hiramatsu { 815cf6eb489SMasami Hiramatsu char *buf; 816bd09d7b5SMasami Hiramatsu int ret, i, nvars; 817cf6eb489SMasami Hiramatsu struct str_node *node; 818cf6eb489SMasami Hiramatsu struct variable_list *vls = NULL, *vl; 8199b118acaSMasami Hiramatsu struct perf_probe_point tmp; 820bd09d7b5SMasami Hiramatsu const char *var; 821cf6eb489SMasami Hiramatsu 822cf6eb489SMasami Hiramatsu buf = synthesize_perf_probe_point(&pev->point); 823cf6eb489SMasami Hiramatsu if (!buf) 824cf6eb489SMasami Hiramatsu return -EINVAL; 825cf6eb489SMasami Hiramatsu pr_debug("Searching variables at %s\n", buf); 826cf6eb489SMasami Hiramatsu 827ff741783SMasami Hiramatsu ret = debuginfo__find_available_vars_at(dinfo, pev, &vls, 828ff741783SMasami Hiramatsu max_vls, externs); 8299b118acaSMasami Hiramatsu if (!ret) { /* Not found, retry with an alternative */ 8309b118acaSMasami Hiramatsu ret = get_alternative_probe_event(dinfo, pev, &tmp, target); 8319b118acaSMasami Hiramatsu if (!ret) { 8329b118acaSMasami Hiramatsu ret = debuginfo__find_available_vars_at(dinfo, pev, 8339b118acaSMasami Hiramatsu &vls, max_vls, externs); 8349b118acaSMasami Hiramatsu /* Release the old probe_point */ 8359b118acaSMasami Hiramatsu clear_perf_probe_point(&tmp); 8369b118acaSMasami Hiramatsu } 8379b118acaSMasami Hiramatsu } 838bd09d7b5SMasami Hiramatsu if (ret <= 0) { 83969e96eaaSMasami Hiramatsu if (ret == 0 || ret == -ENOENT) { 84069e96eaaSMasami Hiramatsu pr_err("Failed to find the address of %s\n", buf); 84169e96eaaSMasami Hiramatsu ret = -ENOENT; 84269e96eaaSMasami Hiramatsu } else 84369e96eaaSMasami Hiramatsu pr_warning("Debuginfo analysis failed.\n"); 844bd09d7b5SMasami Hiramatsu goto end; 845bd09d7b5SMasami Hiramatsu } 84669e96eaaSMasami Hiramatsu 847bd09d7b5SMasami Hiramatsu /* Some variables are found */ 848cf6eb489SMasami Hiramatsu fprintf(stdout, "Available variables at %s\n", buf); 849cf6eb489SMasami Hiramatsu for (i = 0; i < ret; i++) { 850cf6eb489SMasami Hiramatsu vl = &vls[i]; 851cf6eb489SMasami Hiramatsu /* 852cf6eb489SMasami Hiramatsu * A probe point might be converted to 853cf6eb489SMasami Hiramatsu * several trace points. 854cf6eb489SMasami Hiramatsu */ 855cf6eb489SMasami Hiramatsu fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol, 856cf6eb489SMasami Hiramatsu vl->point.offset); 85774cf249dSArnaldo Carvalho de Melo zfree(&vl->point.symbol); 858bd09d7b5SMasami Hiramatsu nvars = 0; 859cf6eb489SMasami Hiramatsu if (vl->vars) { 860bd09d7b5SMasami Hiramatsu strlist__for_each(node, vl->vars) { 861bd09d7b5SMasami Hiramatsu var = strchr(node->s, '\t') + 1; 862bd09d7b5SMasami Hiramatsu if (strfilter__compare(_filter, var)) { 863cf6eb489SMasami Hiramatsu fprintf(stdout, "\t\t%s\n", node->s); 864bd09d7b5SMasami Hiramatsu nvars++; 865bd09d7b5SMasami Hiramatsu } 866bd09d7b5SMasami Hiramatsu } 867cf6eb489SMasami Hiramatsu strlist__delete(vl->vars); 868bd09d7b5SMasami Hiramatsu } 869bd09d7b5SMasami Hiramatsu if (nvars == 0) 870bd09d7b5SMasami Hiramatsu fprintf(stdout, "\t\t(No matched variables)\n"); 871cf6eb489SMasami Hiramatsu } 872cf6eb489SMasami Hiramatsu free(vls); 873bd09d7b5SMasami Hiramatsu end: 874cf6eb489SMasami Hiramatsu free(buf); 875cf6eb489SMasami Hiramatsu return ret; 876cf6eb489SMasami Hiramatsu } 877cf6eb489SMasami Hiramatsu 878cf6eb489SMasami Hiramatsu /* Show available variables on given probe point */ 879cf6eb489SMasami Hiramatsu int show_available_vars(struct perf_probe_event *pevs, int npevs, 880bd09d7b5SMasami Hiramatsu int max_vls, const char *module, 881bd09d7b5SMasami Hiramatsu struct strfilter *_filter, bool externs) 882cf6eb489SMasami Hiramatsu { 883ff741783SMasami Hiramatsu int i, ret = 0; 884ff741783SMasami Hiramatsu struct debuginfo *dinfo; 885cf6eb489SMasami Hiramatsu 8862b394bc4SMasami Hiramatsu ret = init_symbol_maps(pevs->uprobes); 887cf6eb489SMasami Hiramatsu if (ret < 0) 888cf6eb489SMasami Hiramatsu return ret; 889cf6eb489SMasami Hiramatsu 89092561cb7SMasami Hiramatsu dinfo = open_debuginfo(module, false); 891ff741783SMasami Hiramatsu if (!dinfo) { 892ee45b6c2SMasami Hiramatsu ret = -ENOENT; 893ee45b6c2SMasami Hiramatsu goto out; 894ff741783SMasami Hiramatsu } 895ff741783SMasami Hiramatsu 896cc446446SMasami Hiramatsu setup_pager(); 897cc446446SMasami Hiramatsu 898ff741783SMasami Hiramatsu for (i = 0; i < npevs && ret >= 0; i++) 899ff741783SMasami Hiramatsu ret = show_available_vars_at(dinfo, &pevs[i], max_vls, _filter, 9009b118acaSMasami Hiramatsu externs, module); 901ff741783SMasami Hiramatsu 902ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 903ee45b6c2SMasami Hiramatsu out: 904ee45b6c2SMasami Hiramatsu exit_symbol_maps(); 905cf6eb489SMasami Hiramatsu return ret; 906cf6eb489SMasami Hiramatsu } 907cf6eb489SMasami Hiramatsu 90889fe808aSIngo Molnar #else /* !HAVE_DWARF_SUPPORT */ 9094b4da7f7SMasami Hiramatsu 9105a6f6314SMasami Hiramatsu static int 9115a6f6314SMasami Hiramatsu find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused, 9125a6f6314SMasami Hiramatsu struct perf_probe_point *pp __maybe_unused, 9135a6f6314SMasami Hiramatsu bool is_kprobe __maybe_unused) 9144b4da7f7SMasami Hiramatsu { 9155a6f6314SMasami Hiramatsu return -ENOSYS; 9164b4da7f7SMasami Hiramatsu } 9174b4da7f7SMasami Hiramatsu 9180e60836bSSrikar Dronamraju static int try_to_find_probe_trace_events(struct perf_probe_event *pev, 9191d037ca1SIrina Tirdea struct probe_trace_event **tevs __maybe_unused, 9201d027ee9SArnaldo Carvalho de Melo int max_tevs __maybe_unused, 9211d027ee9SArnaldo Carvalho de Melo const char *target __maybe_unused) 9224b4da7f7SMasami Hiramatsu { 923146a1439SMasami Hiramatsu if (perf_probe_event_need_dwarf(pev)) { 924146a1439SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 925146a1439SMasami Hiramatsu return -ENOSYS; 926146a1439SMasami Hiramatsu } 927225466f1SSrikar Dronamraju 9284b4da7f7SMasami Hiramatsu return 0; 9294b4da7f7SMasami Hiramatsu } 9304b4da7f7SMasami Hiramatsu 9311d037ca1SIrina Tirdea int show_line_range(struct line_range *lr __maybe_unused, 9322b394bc4SMasami Hiramatsu const char *module __maybe_unused, 9332b394bc4SMasami Hiramatsu bool user __maybe_unused) 9344b4da7f7SMasami Hiramatsu { 935146a1439SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 936146a1439SMasami Hiramatsu return -ENOSYS; 9374b4da7f7SMasami Hiramatsu } 9384b4da7f7SMasami Hiramatsu 9391d037ca1SIrina Tirdea int show_available_vars(struct perf_probe_event *pevs __maybe_unused, 9401d037ca1SIrina Tirdea int npevs __maybe_unused, int max_vls __maybe_unused, 9411d037ca1SIrina Tirdea const char *module __maybe_unused, 9421d037ca1SIrina Tirdea struct strfilter *filter __maybe_unused, 9431d037ca1SIrina Tirdea bool externs __maybe_unused) 944cf6eb489SMasami Hiramatsu { 945cf6eb489SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 946cf6eb489SMasami Hiramatsu return -ENOSYS; 947cf6eb489SMasami Hiramatsu } 948e0faa8d3SMasami Hiramatsu #endif 949e0faa8d3SMasami Hiramatsu 950e53b00d3SMasami Hiramatsu void line_range__clear(struct line_range *lr) 951e53b00d3SMasami Hiramatsu { 952e53b00d3SMasami Hiramatsu free(lr->function); 953e53b00d3SMasami Hiramatsu free(lr->file); 954e53b00d3SMasami Hiramatsu free(lr->path); 955e53b00d3SMasami Hiramatsu free(lr->comp_dir); 9565a62257aSMasami Hiramatsu intlist__delete(lr->line_list); 957e53b00d3SMasami Hiramatsu memset(lr, 0, sizeof(*lr)); 958e53b00d3SMasami Hiramatsu } 959e53b00d3SMasami Hiramatsu 9605a62257aSMasami Hiramatsu int line_range__init(struct line_range *lr) 961e53b00d3SMasami Hiramatsu { 962e53b00d3SMasami Hiramatsu memset(lr, 0, sizeof(*lr)); 9635a62257aSMasami Hiramatsu lr->line_list = intlist__new(NULL); 9645a62257aSMasami Hiramatsu if (!lr->line_list) 9655a62257aSMasami Hiramatsu return -ENOMEM; 9665a62257aSMasami Hiramatsu else 9675a62257aSMasami Hiramatsu return 0; 968e53b00d3SMasami Hiramatsu } 969e53b00d3SMasami Hiramatsu 97021dd9ae5SFranck Bui-Huu static int parse_line_num(char **ptr, int *val, const char *what) 97121dd9ae5SFranck Bui-Huu { 97221dd9ae5SFranck Bui-Huu const char *start = *ptr; 97321dd9ae5SFranck Bui-Huu 97421dd9ae5SFranck Bui-Huu errno = 0; 97521dd9ae5SFranck Bui-Huu *val = strtol(*ptr, ptr, 0); 97621dd9ae5SFranck Bui-Huu if (errno || *ptr == start) { 97721dd9ae5SFranck Bui-Huu semantic_error("'%s' is not a valid number.\n", what); 97821dd9ae5SFranck Bui-Huu return -EINVAL; 97921dd9ae5SFranck Bui-Huu } 98021dd9ae5SFranck Bui-Huu return 0; 98121dd9ae5SFranck Bui-Huu } 98221dd9ae5SFranck Bui-Huu 9839d95b580SFranck Bui-Huu /* 9849d95b580SFranck Bui-Huu * Stuff 'lr' according to the line range described by 'arg'. 9859d95b580SFranck Bui-Huu * The line range syntax is described by: 9869d95b580SFranck Bui-Huu * 9879d95b580SFranck Bui-Huu * SRC[:SLN[+NUM|-ELN]] 988e116dfa1SMasami Hiramatsu * FNC[@SRC][:SLN[+NUM|-ELN]] 9899d95b580SFranck Bui-Huu */ 990146a1439SMasami Hiramatsu int parse_line_range_desc(const char *arg, struct line_range *lr) 991631c9defSMasami Hiramatsu { 992e116dfa1SMasami Hiramatsu char *range, *file, *name = strdup(arg); 99321dd9ae5SFranck Bui-Huu int err; 9949d95b580SFranck Bui-Huu 99521dd9ae5SFranck Bui-Huu if (!name) 99621dd9ae5SFranck Bui-Huu return -ENOMEM; 99721dd9ae5SFranck Bui-Huu 99821dd9ae5SFranck Bui-Huu lr->start = 0; 99921dd9ae5SFranck Bui-Huu lr->end = INT_MAX; 100021dd9ae5SFranck Bui-Huu 100121dd9ae5SFranck Bui-Huu range = strchr(name, ':'); 100221dd9ae5SFranck Bui-Huu if (range) { 100321dd9ae5SFranck Bui-Huu *range++ = '\0'; 100421dd9ae5SFranck Bui-Huu 100521dd9ae5SFranck Bui-Huu err = parse_line_num(&range, &lr->start, "start line"); 100621dd9ae5SFranck Bui-Huu if (err) 100721dd9ae5SFranck Bui-Huu goto err; 100821dd9ae5SFranck Bui-Huu 100921dd9ae5SFranck Bui-Huu if (*range == '+' || *range == '-') { 101021dd9ae5SFranck Bui-Huu const char c = *range++; 101121dd9ae5SFranck Bui-Huu 101221dd9ae5SFranck Bui-Huu err = parse_line_num(&range, &lr->end, "end line"); 101321dd9ae5SFranck Bui-Huu if (err) 101421dd9ae5SFranck Bui-Huu goto err; 101521dd9ae5SFranck Bui-Huu 101621dd9ae5SFranck Bui-Huu if (c == '+') { 101721dd9ae5SFranck Bui-Huu lr->end += lr->start; 101821dd9ae5SFranck Bui-Huu /* 1019dda4ab34SMasami Hiramatsu * Adjust the number of lines here. 1020dda4ab34SMasami Hiramatsu * If the number of lines == 1, the 1021dda4ab34SMasami Hiramatsu * the end of line should be equal to 1022dda4ab34SMasami Hiramatsu * the start of line. 1023dda4ab34SMasami Hiramatsu */ 102421dd9ae5SFranck Bui-Huu lr->end--; 102521dd9ae5SFranck Bui-Huu } 102621dd9ae5SFranck Bui-Huu } 102721dd9ae5SFranck Bui-Huu 1028d3b63d7aSMasami Hiramatsu pr_debug("Line range is %d to %d\n", lr->start, lr->end); 102921dd9ae5SFranck Bui-Huu 103021dd9ae5SFranck Bui-Huu err = -EINVAL; 1031d3b63d7aSMasami Hiramatsu if (lr->start > lr->end) { 1032631c9defSMasami Hiramatsu semantic_error("Start line must be smaller" 1033146a1439SMasami Hiramatsu " than end line.\n"); 103421dd9ae5SFranck Bui-Huu goto err; 1035146a1439SMasami Hiramatsu } 103621dd9ae5SFranck Bui-Huu if (*range != '\0') { 103721dd9ae5SFranck Bui-Huu semantic_error("Tailing with invalid str '%s'.\n", range); 103821dd9ae5SFranck Bui-Huu goto err; 1039146a1439SMasami Hiramatsu } 1040d3b63d7aSMasami Hiramatsu } 104102b95dadSMasami Hiramatsu 1042e116dfa1SMasami Hiramatsu file = strchr(name, '@'); 1043e116dfa1SMasami Hiramatsu if (file) { 1044e116dfa1SMasami Hiramatsu *file = '\0'; 1045e116dfa1SMasami Hiramatsu lr->file = strdup(++file); 1046e116dfa1SMasami Hiramatsu if (lr->file == NULL) { 1047e116dfa1SMasami Hiramatsu err = -ENOMEM; 1048e116dfa1SMasami Hiramatsu goto err; 1049e116dfa1SMasami Hiramatsu } 1050e116dfa1SMasami Hiramatsu lr->function = name; 1051e116dfa1SMasami Hiramatsu } else if (strchr(name, '.')) 105221dd9ae5SFranck Bui-Huu lr->file = name; 1053631c9defSMasami Hiramatsu else 105421dd9ae5SFranck Bui-Huu lr->function = name; 1055146a1439SMasami Hiramatsu 1056146a1439SMasami Hiramatsu return 0; 105721dd9ae5SFranck Bui-Huu err: 105821dd9ae5SFranck Bui-Huu free(name); 105921dd9ae5SFranck Bui-Huu return err; 1060631c9defSMasami Hiramatsu } 1061631c9defSMasami Hiramatsu 1062b7702a21SMasami Hiramatsu /* Check the name is good for event/group */ 1063b7702a21SMasami Hiramatsu static bool check_event_name(const char *name) 1064b7702a21SMasami Hiramatsu { 1065b7702a21SMasami Hiramatsu if (!isalpha(*name) && *name != '_') 1066b7702a21SMasami Hiramatsu return false; 1067b7702a21SMasami Hiramatsu while (*++name != '\0') { 1068b7702a21SMasami Hiramatsu if (!isalpha(*name) && !isdigit(*name) && *name != '_') 1069b7702a21SMasami Hiramatsu return false; 1070b7702a21SMasami Hiramatsu } 1071b7702a21SMasami Hiramatsu return true; 1072b7702a21SMasami Hiramatsu } 1073b7702a21SMasami Hiramatsu 107450656eecSMasami Hiramatsu /* Parse probepoint definition. */ 1075146a1439SMasami Hiramatsu static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev) 107650656eecSMasami Hiramatsu { 10774235b045SMasami Hiramatsu struct perf_probe_point *pp = &pev->point; 107850656eecSMasami Hiramatsu char *ptr, *tmp; 107950656eecSMasami Hiramatsu char c, nc = 0; 108050656eecSMasami Hiramatsu /* 108150656eecSMasami Hiramatsu * <Syntax> 10822a9c8c36SMasami Hiramatsu * perf probe [EVENT=]SRC[:LN|;PTN] 10832a9c8c36SMasami Hiramatsu * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT] 1084af663d75SMasami Hiramatsu * 1085af663d75SMasami Hiramatsu * TODO:Group name support 108650656eecSMasami Hiramatsu */ 108750656eecSMasami Hiramatsu 10882a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";=@+%"); 10892a9c8c36SMasami Hiramatsu if (ptr && *ptr == '=') { /* Event name */ 1090af663d75SMasami Hiramatsu *ptr = '\0'; 1091af663d75SMasami Hiramatsu tmp = ptr + 1; 1092146a1439SMasami Hiramatsu if (strchr(arg, ':')) { 1093146a1439SMasami Hiramatsu semantic_error("Group name is not supported yet.\n"); 1094146a1439SMasami Hiramatsu return -ENOTSUP; 1095146a1439SMasami Hiramatsu } 1096146a1439SMasami Hiramatsu if (!check_event_name(arg)) { 1097b7702a21SMasami Hiramatsu semantic_error("%s is bad for event name -it must " 1098146a1439SMasami Hiramatsu "follow C symbol-naming rule.\n", arg); 1099146a1439SMasami Hiramatsu return -EINVAL; 1100146a1439SMasami Hiramatsu } 110102b95dadSMasami Hiramatsu pev->event = strdup(arg); 110202b95dadSMasami Hiramatsu if (pev->event == NULL) 110302b95dadSMasami Hiramatsu return -ENOMEM; 11044235b045SMasami Hiramatsu pev->group = NULL; 1105af663d75SMasami Hiramatsu arg = tmp; 1106af663d75SMasami Hiramatsu } 1107af663d75SMasami Hiramatsu 11082a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";:+@%"); 110950656eecSMasami Hiramatsu if (ptr) { 111050656eecSMasami Hiramatsu nc = *ptr; 111150656eecSMasami Hiramatsu *ptr++ = '\0'; 111250656eecSMasami Hiramatsu } 111350656eecSMasami Hiramatsu 111402b95dadSMasami Hiramatsu tmp = strdup(arg); 111502b95dadSMasami Hiramatsu if (tmp == NULL) 111602b95dadSMasami Hiramatsu return -ENOMEM; 111702b95dadSMasami Hiramatsu 111850656eecSMasami Hiramatsu /* Check arg is function or file and copy it */ 111902b95dadSMasami Hiramatsu if (strchr(tmp, '.')) /* File */ 112002b95dadSMasami Hiramatsu pp->file = tmp; 112150656eecSMasami Hiramatsu else /* Function */ 112202b95dadSMasami Hiramatsu pp->function = tmp; 112350656eecSMasami Hiramatsu 112450656eecSMasami Hiramatsu /* Parse other options */ 112550656eecSMasami Hiramatsu while (ptr) { 112650656eecSMasami Hiramatsu arg = ptr; 112750656eecSMasami Hiramatsu c = nc; 11282a9c8c36SMasami Hiramatsu if (c == ';') { /* Lazy pattern must be the last part */ 112902b95dadSMasami Hiramatsu pp->lazy_line = strdup(arg); 113002b95dadSMasami Hiramatsu if (pp->lazy_line == NULL) 113102b95dadSMasami Hiramatsu return -ENOMEM; 11322a9c8c36SMasami Hiramatsu break; 11332a9c8c36SMasami Hiramatsu } 11342a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";:+@%"); 113550656eecSMasami Hiramatsu if (ptr) { 113650656eecSMasami Hiramatsu nc = *ptr; 113750656eecSMasami Hiramatsu *ptr++ = '\0'; 113850656eecSMasami Hiramatsu } 113950656eecSMasami Hiramatsu switch (c) { 114050656eecSMasami Hiramatsu case ':': /* Line number */ 114150656eecSMasami Hiramatsu pp->line = strtoul(arg, &tmp, 0); 1142146a1439SMasami Hiramatsu if (*tmp != '\0') { 11432a9c8c36SMasami Hiramatsu semantic_error("There is non-digit char" 1144146a1439SMasami Hiramatsu " in line number.\n"); 1145146a1439SMasami Hiramatsu return -EINVAL; 1146146a1439SMasami Hiramatsu } 114750656eecSMasami Hiramatsu break; 114850656eecSMasami Hiramatsu case '+': /* Byte offset from a symbol */ 114950656eecSMasami Hiramatsu pp->offset = strtoul(arg, &tmp, 0); 1150146a1439SMasami Hiramatsu if (*tmp != '\0') { 11512a9c8c36SMasami Hiramatsu semantic_error("There is non-digit character" 1152146a1439SMasami Hiramatsu " in offset.\n"); 1153146a1439SMasami Hiramatsu return -EINVAL; 1154146a1439SMasami Hiramatsu } 115550656eecSMasami Hiramatsu break; 115650656eecSMasami Hiramatsu case '@': /* File name */ 1157146a1439SMasami Hiramatsu if (pp->file) { 1158146a1439SMasami Hiramatsu semantic_error("SRC@SRC is not allowed.\n"); 1159146a1439SMasami Hiramatsu return -EINVAL; 1160146a1439SMasami Hiramatsu } 116102b95dadSMasami Hiramatsu pp->file = strdup(arg); 116202b95dadSMasami Hiramatsu if (pp->file == NULL) 116302b95dadSMasami Hiramatsu return -ENOMEM; 116450656eecSMasami Hiramatsu break; 116550656eecSMasami Hiramatsu case '%': /* Probe places */ 116650656eecSMasami Hiramatsu if (strcmp(arg, "return") == 0) { 116750656eecSMasami Hiramatsu pp->retprobe = 1; 1168146a1439SMasami Hiramatsu } else { /* Others not supported yet */ 1169146a1439SMasami Hiramatsu semantic_error("%%%s is not supported.\n", arg); 1170146a1439SMasami Hiramatsu return -ENOTSUP; 1171146a1439SMasami Hiramatsu } 117250656eecSMasami Hiramatsu break; 1173146a1439SMasami Hiramatsu default: /* Buggy case */ 1174146a1439SMasami Hiramatsu pr_err("This program has a bug at %s:%d.\n", 1175146a1439SMasami Hiramatsu __FILE__, __LINE__); 1176146a1439SMasami Hiramatsu return -ENOTSUP; 117750656eecSMasami Hiramatsu break; 117850656eecSMasami Hiramatsu } 117950656eecSMasami Hiramatsu } 118050656eecSMasami Hiramatsu 118150656eecSMasami Hiramatsu /* Exclusion check */ 1182146a1439SMasami Hiramatsu if (pp->lazy_line && pp->line) { 11830e43e5d2SMasami Hiramatsu semantic_error("Lazy pattern can't be used with" 11840e43e5d2SMasami Hiramatsu " line number.\n"); 1185146a1439SMasami Hiramatsu return -EINVAL; 1186146a1439SMasami Hiramatsu } 11872a9c8c36SMasami Hiramatsu 1188146a1439SMasami Hiramatsu if (pp->lazy_line && pp->offset) { 11890e43e5d2SMasami Hiramatsu semantic_error("Lazy pattern can't be used with offset.\n"); 1190146a1439SMasami Hiramatsu return -EINVAL; 1191146a1439SMasami Hiramatsu } 11922a9c8c36SMasami Hiramatsu 1193146a1439SMasami Hiramatsu if (pp->line && pp->offset) { 11940e43e5d2SMasami Hiramatsu semantic_error("Offset can't be used with line number.\n"); 1195146a1439SMasami Hiramatsu return -EINVAL; 1196146a1439SMasami Hiramatsu } 119750656eecSMasami Hiramatsu 1198146a1439SMasami Hiramatsu if (!pp->line && !pp->lazy_line && pp->file && !pp->function) { 11992a9c8c36SMasami Hiramatsu semantic_error("File always requires line number or " 12000e43e5d2SMasami Hiramatsu "lazy pattern.\n"); 1201146a1439SMasami Hiramatsu return -EINVAL; 1202146a1439SMasami Hiramatsu } 120350656eecSMasami Hiramatsu 1204146a1439SMasami Hiramatsu if (pp->offset && !pp->function) { 12050e43e5d2SMasami Hiramatsu semantic_error("Offset requires an entry function.\n"); 1206146a1439SMasami Hiramatsu return -EINVAL; 1207146a1439SMasami Hiramatsu } 120850656eecSMasami Hiramatsu 1209146a1439SMasami Hiramatsu if (pp->retprobe && !pp->function) { 12100e43e5d2SMasami Hiramatsu semantic_error("Return probe requires an entry function.\n"); 1211146a1439SMasami Hiramatsu return -EINVAL; 1212146a1439SMasami Hiramatsu } 121350656eecSMasami Hiramatsu 1214146a1439SMasami Hiramatsu if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) { 12152a9c8c36SMasami Hiramatsu semantic_error("Offset/Line/Lazy pattern can't be used with " 12160e43e5d2SMasami Hiramatsu "return probe.\n"); 1217146a1439SMasami Hiramatsu return -EINVAL; 1218146a1439SMasami Hiramatsu } 121950656eecSMasami Hiramatsu 12204235b045SMasami Hiramatsu pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n", 12212a9c8c36SMasami Hiramatsu pp->function, pp->file, pp->line, pp->offset, pp->retprobe, 12222a9c8c36SMasami Hiramatsu pp->lazy_line); 1223146a1439SMasami Hiramatsu return 0; 122450656eecSMasami Hiramatsu } 122550656eecSMasami Hiramatsu 12267df2f329SMasami Hiramatsu /* Parse perf-probe event argument */ 1227146a1439SMasami Hiramatsu static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg) 12287df2f329SMasami Hiramatsu { 1229b2a3c12bSMasami Hiramatsu char *tmp, *goodname; 12307df2f329SMasami Hiramatsu struct perf_probe_arg_field **fieldp; 12317df2f329SMasami Hiramatsu 12327df2f329SMasami Hiramatsu pr_debug("parsing arg: %s into ", str); 12337df2f329SMasami Hiramatsu 123448481938SMasami Hiramatsu tmp = strchr(str, '='); 123548481938SMasami Hiramatsu if (tmp) { 123602b95dadSMasami Hiramatsu arg->name = strndup(str, tmp - str); 123702b95dadSMasami Hiramatsu if (arg->name == NULL) 123802b95dadSMasami Hiramatsu return -ENOMEM; 123911a1ca35SMasami Hiramatsu pr_debug("name:%s ", arg->name); 124048481938SMasami Hiramatsu str = tmp + 1; 124148481938SMasami Hiramatsu } 124248481938SMasami Hiramatsu 124311a1ca35SMasami Hiramatsu tmp = strchr(str, ':'); 124411a1ca35SMasami Hiramatsu if (tmp) { /* Type setting */ 124511a1ca35SMasami Hiramatsu *tmp = '\0'; 124602b95dadSMasami Hiramatsu arg->type = strdup(tmp + 1); 124702b95dadSMasami Hiramatsu if (arg->type == NULL) 124802b95dadSMasami Hiramatsu return -ENOMEM; 124911a1ca35SMasami Hiramatsu pr_debug("type:%s ", arg->type); 125011a1ca35SMasami Hiramatsu } 125111a1ca35SMasami Hiramatsu 1252b2a3c12bSMasami Hiramatsu tmp = strpbrk(str, "-.["); 12537df2f329SMasami Hiramatsu if (!is_c_varname(str) || !tmp) { 12547df2f329SMasami Hiramatsu /* A variable, register, symbol or special value */ 125502b95dadSMasami Hiramatsu arg->var = strdup(str); 125602b95dadSMasami Hiramatsu if (arg->var == NULL) 125702b95dadSMasami Hiramatsu return -ENOMEM; 125848481938SMasami Hiramatsu pr_debug("%s\n", arg->var); 1259146a1439SMasami Hiramatsu return 0; 12607df2f329SMasami Hiramatsu } 12617df2f329SMasami Hiramatsu 1262b2a3c12bSMasami Hiramatsu /* Structure fields or array element */ 126302b95dadSMasami Hiramatsu arg->var = strndup(str, tmp - str); 126402b95dadSMasami Hiramatsu if (arg->var == NULL) 126502b95dadSMasami Hiramatsu return -ENOMEM; 1266b2a3c12bSMasami Hiramatsu goodname = arg->var; 126748481938SMasami Hiramatsu pr_debug("%s, ", arg->var); 12687df2f329SMasami Hiramatsu fieldp = &arg->field; 12697df2f329SMasami Hiramatsu 12707df2f329SMasami Hiramatsu do { 1271e334016fSMasami Hiramatsu *fieldp = zalloc(sizeof(struct perf_probe_arg_field)); 1272e334016fSMasami Hiramatsu if (*fieldp == NULL) 1273e334016fSMasami Hiramatsu return -ENOMEM; 1274b2a3c12bSMasami Hiramatsu if (*tmp == '[') { /* Array */ 1275b2a3c12bSMasami Hiramatsu str = tmp; 1276b2a3c12bSMasami Hiramatsu (*fieldp)->index = strtol(str + 1, &tmp, 0); 1277b2a3c12bSMasami Hiramatsu (*fieldp)->ref = true; 1278b2a3c12bSMasami Hiramatsu if (*tmp != ']' || tmp == str + 1) { 1279b2a3c12bSMasami Hiramatsu semantic_error("Array index must be a" 1280b2a3c12bSMasami Hiramatsu " number.\n"); 1281b2a3c12bSMasami Hiramatsu return -EINVAL; 1282b2a3c12bSMasami Hiramatsu } 1283b2a3c12bSMasami Hiramatsu tmp++; 1284b2a3c12bSMasami Hiramatsu if (*tmp == '\0') 1285b2a3c12bSMasami Hiramatsu tmp = NULL; 1286b2a3c12bSMasami Hiramatsu } else { /* Structure */ 12877df2f329SMasami Hiramatsu if (*tmp == '.') { 12887df2f329SMasami Hiramatsu str = tmp + 1; 12897df2f329SMasami Hiramatsu (*fieldp)->ref = false; 12907df2f329SMasami Hiramatsu } else if (tmp[1] == '>') { 12917df2f329SMasami Hiramatsu str = tmp + 2; 12927df2f329SMasami Hiramatsu (*fieldp)->ref = true; 1293146a1439SMasami Hiramatsu } else { 1294b2a3c12bSMasami Hiramatsu semantic_error("Argument parse error: %s\n", 1295b2a3c12bSMasami Hiramatsu str); 1296146a1439SMasami Hiramatsu return -EINVAL; 1297146a1439SMasami Hiramatsu } 1298b2a3c12bSMasami Hiramatsu tmp = strpbrk(str, "-.["); 1299b2a3c12bSMasami Hiramatsu } 13007df2f329SMasami Hiramatsu if (tmp) { 130102b95dadSMasami Hiramatsu (*fieldp)->name = strndup(str, tmp - str); 130202b95dadSMasami Hiramatsu if ((*fieldp)->name == NULL) 130302b95dadSMasami Hiramatsu return -ENOMEM; 1304b2a3c12bSMasami Hiramatsu if (*str != '[') 1305b2a3c12bSMasami Hiramatsu goodname = (*fieldp)->name; 13067df2f329SMasami Hiramatsu pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref); 13077df2f329SMasami Hiramatsu fieldp = &(*fieldp)->next; 13087df2f329SMasami Hiramatsu } 13097df2f329SMasami Hiramatsu } while (tmp); 131002b95dadSMasami Hiramatsu (*fieldp)->name = strdup(str); 131102b95dadSMasami Hiramatsu if ((*fieldp)->name == NULL) 131202b95dadSMasami Hiramatsu return -ENOMEM; 1313b2a3c12bSMasami Hiramatsu if (*str != '[') 1314b2a3c12bSMasami Hiramatsu goodname = (*fieldp)->name; 13157df2f329SMasami Hiramatsu pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref); 1316df0faf4bSMasami Hiramatsu 1317b2a3c12bSMasami Hiramatsu /* If no name is specified, set the last field name (not array index)*/ 131802b95dadSMasami Hiramatsu if (!arg->name) { 1319b2a3c12bSMasami Hiramatsu arg->name = strdup(goodname); 132002b95dadSMasami Hiramatsu if (arg->name == NULL) 132102b95dadSMasami Hiramatsu return -ENOMEM; 132202b95dadSMasami Hiramatsu } 1323146a1439SMasami Hiramatsu return 0; 13247df2f329SMasami Hiramatsu } 13257df2f329SMasami Hiramatsu 13264235b045SMasami Hiramatsu /* Parse perf-probe event command */ 1327146a1439SMasami Hiramatsu int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev) 132850656eecSMasami Hiramatsu { 1329e1c01d61SMasami Hiramatsu char **argv; 1330146a1439SMasami Hiramatsu int argc, i, ret = 0; 1331fac13fd5SMasami Hiramatsu 13324235b045SMasami Hiramatsu argv = argv_split(cmd, &argc); 1333146a1439SMasami Hiramatsu if (!argv) { 1334146a1439SMasami Hiramatsu pr_debug("Failed to split arguments.\n"); 1335146a1439SMasami Hiramatsu return -ENOMEM; 1336146a1439SMasami Hiramatsu } 1337146a1439SMasami Hiramatsu if (argc - 1 > MAX_PROBE_ARGS) { 1338146a1439SMasami Hiramatsu semantic_error("Too many probe arguments (%d).\n", argc - 1); 1339146a1439SMasami Hiramatsu ret = -ERANGE; 1340146a1439SMasami Hiramatsu goto out; 1341146a1439SMasami Hiramatsu } 134250656eecSMasami Hiramatsu /* Parse probe point */ 1343146a1439SMasami Hiramatsu ret = parse_perf_probe_point(argv[0], pev); 1344146a1439SMasami Hiramatsu if (ret < 0) 1345146a1439SMasami Hiramatsu goto out; 134650656eecSMasami Hiramatsu 1347e1c01d61SMasami Hiramatsu /* Copy arguments and ensure return probe has no C argument */ 13484235b045SMasami Hiramatsu pev->nargs = argc - 1; 1349e334016fSMasami Hiramatsu pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs); 1350e334016fSMasami Hiramatsu if (pev->args == NULL) { 1351e334016fSMasami Hiramatsu ret = -ENOMEM; 1352e334016fSMasami Hiramatsu goto out; 1353e334016fSMasami Hiramatsu } 1354146a1439SMasami Hiramatsu for (i = 0; i < pev->nargs && ret >= 0; i++) { 1355146a1439SMasami Hiramatsu ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]); 1356146a1439SMasami Hiramatsu if (ret >= 0 && 1357146a1439SMasami Hiramatsu is_c_varname(pev->args[i].var) && pev->point.retprobe) { 13584235b045SMasami Hiramatsu semantic_error("You can't specify local variable for" 1359146a1439SMasami Hiramatsu " kretprobe.\n"); 1360146a1439SMasami Hiramatsu ret = -EINVAL; 1361e1c01d61SMasami Hiramatsu } 1362146a1439SMasami Hiramatsu } 1363146a1439SMasami Hiramatsu out: 1364e1c01d61SMasami Hiramatsu argv_free(argv); 1365146a1439SMasami Hiramatsu 1366146a1439SMasami Hiramatsu return ret; 136750656eecSMasami Hiramatsu } 136850656eecSMasami Hiramatsu 13694235b045SMasami Hiramatsu /* Return true if this perf_probe_event requires debuginfo */ 13704235b045SMasami Hiramatsu bool perf_probe_event_need_dwarf(struct perf_probe_event *pev) 13714de189feSMasami Hiramatsu { 13724235b045SMasami Hiramatsu int i; 13734235b045SMasami Hiramatsu 13744235b045SMasami Hiramatsu if (pev->point.file || pev->point.line || pev->point.lazy_line) 13754235b045SMasami Hiramatsu return true; 13764235b045SMasami Hiramatsu 13774235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) 137848481938SMasami Hiramatsu if (is_c_varname(pev->args[i].var)) 13794235b045SMasami Hiramatsu return true; 13804235b045SMasami Hiramatsu 13814235b045SMasami Hiramatsu return false; 13824235b045SMasami Hiramatsu } 13834235b045SMasami Hiramatsu 13840e60836bSSrikar Dronamraju /* Parse probe_events event into struct probe_point */ 13850e60836bSSrikar Dronamraju static int parse_probe_trace_command(const char *cmd, 13860e60836bSSrikar Dronamraju struct probe_trace_event *tev) 13874235b045SMasami Hiramatsu { 13880e60836bSSrikar Dronamraju struct probe_trace_point *tp = &tev->point; 13894de189feSMasami Hiramatsu char pr; 13904de189feSMasami Hiramatsu char *p; 1391bcbd0040SIrina Tirdea char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str; 13924de189feSMasami Hiramatsu int ret, i, argc; 13934de189feSMasami Hiramatsu char **argv; 13944de189feSMasami Hiramatsu 13950e60836bSSrikar Dronamraju pr_debug("Parsing probe_events: %s\n", cmd); 13964235b045SMasami Hiramatsu argv = argv_split(cmd, &argc); 1397146a1439SMasami Hiramatsu if (!argv) { 1398146a1439SMasami Hiramatsu pr_debug("Failed to split arguments.\n"); 1399146a1439SMasami Hiramatsu return -ENOMEM; 1400146a1439SMasami Hiramatsu } 1401146a1439SMasami Hiramatsu if (argc < 2) { 1402146a1439SMasami Hiramatsu semantic_error("Too few probe arguments.\n"); 1403146a1439SMasami Hiramatsu ret = -ERANGE; 1404146a1439SMasami Hiramatsu goto out; 1405146a1439SMasami Hiramatsu } 14064de189feSMasami Hiramatsu 14074de189feSMasami Hiramatsu /* Scan event and group name. */ 1408bcbd0040SIrina Tirdea argv0_str = strdup(argv[0]); 1409bcbd0040SIrina Tirdea if (argv0_str == NULL) { 1410bcbd0040SIrina Tirdea ret = -ENOMEM; 1411bcbd0040SIrina Tirdea goto out; 1412bcbd0040SIrina Tirdea } 1413bcbd0040SIrina Tirdea fmt1_str = strtok_r(argv0_str, ":", &fmt); 1414bcbd0040SIrina Tirdea fmt2_str = strtok_r(NULL, "/", &fmt); 1415bcbd0040SIrina Tirdea fmt3_str = strtok_r(NULL, " \t", &fmt); 1416bcbd0040SIrina Tirdea if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL 1417bcbd0040SIrina Tirdea || fmt3_str == NULL) { 1418146a1439SMasami Hiramatsu semantic_error("Failed to parse event name: %s\n", argv[0]); 1419146a1439SMasami Hiramatsu ret = -EINVAL; 1420146a1439SMasami Hiramatsu goto out; 1421146a1439SMasami Hiramatsu } 1422bcbd0040SIrina Tirdea pr = fmt1_str[0]; 1423bcbd0040SIrina Tirdea tev->group = strdup(fmt2_str); 1424bcbd0040SIrina Tirdea tev->event = strdup(fmt3_str); 1425bcbd0040SIrina Tirdea if (tev->group == NULL || tev->event == NULL) { 1426bcbd0040SIrina Tirdea ret = -ENOMEM; 1427bcbd0040SIrina Tirdea goto out; 1428bcbd0040SIrina Tirdea } 14294235b045SMasami Hiramatsu pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr); 14304de189feSMasami Hiramatsu 14314235b045SMasami Hiramatsu tp->retprobe = (pr == 'r'); 14324de189feSMasami Hiramatsu 1433190b57fcSMasami Hiramatsu /* Scan module name(if there), function name and offset */ 1434190b57fcSMasami Hiramatsu p = strchr(argv[1], ':'); 1435190b57fcSMasami Hiramatsu if (p) { 1436190b57fcSMasami Hiramatsu tp->module = strndup(argv[1], p - argv[1]); 1437190b57fcSMasami Hiramatsu p++; 1438190b57fcSMasami Hiramatsu } else 1439190b57fcSMasami Hiramatsu p = argv[1]; 1440bcbd0040SIrina Tirdea fmt1_str = strtok_r(p, "+", &fmt); 14415a6f6314SMasami Hiramatsu if (fmt1_str[0] == '0') /* only the address started with 0x */ 14425a6f6314SMasami Hiramatsu tp->address = strtoul(fmt1_str, NULL, 0); 14435a6f6314SMasami Hiramatsu else { 14445a6f6314SMasami Hiramatsu /* Only the symbol-based probe has offset */ 1445bcbd0040SIrina Tirdea tp->symbol = strdup(fmt1_str); 1446bcbd0040SIrina Tirdea if (tp->symbol == NULL) { 1447bcbd0040SIrina Tirdea ret = -ENOMEM; 1448bcbd0040SIrina Tirdea goto out; 1449bcbd0040SIrina Tirdea } 1450bcbd0040SIrina Tirdea fmt2_str = strtok_r(NULL, "", &fmt); 1451bcbd0040SIrina Tirdea if (fmt2_str == NULL) 14524235b045SMasami Hiramatsu tp->offset = 0; 1453bcbd0040SIrina Tirdea else 1454bcbd0040SIrina Tirdea tp->offset = strtoul(fmt2_str, NULL, 10); 14555a6f6314SMasami Hiramatsu } 14564de189feSMasami Hiramatsu 14574235b045SMasami Hiramatsu tev->nargs = argc - 2; 14580e60836bSSrikar Dronamraju tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); 1459e334016fSMasami Hiramatsu if (tev->args == NULL) { 1460e334016fSMasami Hiramatsu ret = -ENOMEM; 1461e334016fSMasami Hiramatsu goto out; 1462e334016fSMasami Hiramatsu } 14634235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 14644de189feSMasami Hiramatsu p = strchr(argv[i + 2], '='); 14654de189feSMasami Hiramatsu if (p) /* We don't need which register is assigned. */ 14664235b045SMasami Hiramatsu *p++ = '\0'; 14674235b045SMasami Hiramatsu else 14684235b045SMasami Hiramatsu p = argv[i + 2]; 146902b95dadSMasami Hiramatsu tev->args[i].name = strdup(argv[i + 2]); 14704235b045SMasami Hiramatsu /* TODO: parse regs and offset */ 147102b95dadSMasami Hiramatsu tev->args[i].value = strdup(p); 147202b95dadSMasami Hiramatsu if (tev->args[i].name == NULL || tev->args[i].value == NULL) { 147302b95dadSMasami Hiramatsu ret = -ENOMEM; 147402b95dadSMasami Hiramatsu goto out; 147502b95dadSMasami Hiramatsu } 14764de189feSMasami Hiramatsu } 1477146a1439SMasami Hiramatsu ret = 0; 1478146a1439SMasami Hiramatsu out: 1479bcbd0040SIrina Tirdea free(argv0_str); 14804de189feSMasami Hiramatsu argv_free(argv); 1481146a1439SMasami Hiramatsu return ret; 14824de189feSMasami Hiramatsu } 14834de189feSMasami Hiramatsu 14847df2f329SMasami Hiramatsu /* Compose only probe arg */ 14857df2f329SMasami Hiramatsu int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len) 14867df2f329SMasami Hiramatsu { 14877df2f329SMasami Hiramatsu struct perf_probe_arg_field *field = pa->field; 14887df2f329SMasami Hiramatsu int ret; 14897df2f329SMasami Hiramatsu char *tmp = buf; 14907df2f329SMasami Hiramatsu 149148481938SMasami Hiramatsu if (pa->name && pa->var) 149248481938SMasami Hiramatsu ret = e_snprintf(tmp, len, "%s=%s", pa->name, pa->var); 149348481938SMasami Hiramatsu else 149448481938SMasami Hiramatsu ret = e_snprintf(tmp, len, "%s", pa->name ? pa->name : pa->var); 14957df2f329SMasami Hiramatsu if (ret <= 0) 14967df2f329SMasami Hiramatsu goto error; 14977df2f329SMasami Hiramatsu tmp += ret; 14987df2f329SMasami Hiramatsu len -= ret; 14997df2f329SMasami Hiramatsu 15007df2f329SMasami Hiramatsu while (field) { 1501b2a3c12bSMasami Hiramatsu if (field->name[0] == '[') 1502b2a3c12bSMasami Hiramatsu ret = e_snprintf(tmp, len, "%s", field->name); 1503b2a3c12bSMasami Hiramatsu else 1504b2a3c12bSMasami Hiramatsu ret = e_snprintf(tmp, len, "%s%s", 1505b2a3c12bSMasami Hiramatsu field->ref ? "->" : ".", field->name); 15067df2f329SMasami Hiramatsu if (ret <= 0) 15077df2f329SMasami Hiramatsu goto error; 15087df2f329SMasami Hiramatsu tmp += ret; 15097df2f329SMasami Hiramatsu len -= ret; 15107df2f329SMasami Hiramatsu field = field->next; 15117df2f329SMasami Hiramatsu } 151211a1ca35SMasami Hiramatsu 151311a1ca35SMasami Hiramatsu if (pa->type) { 151411a1ca35SMasami Hiramatsu ret = e_snprintf(tmp, len, ":%s", pa->type); 151511a1ca35SMasami Hiramatsu if (ret <= 0) 151611a1ca35SMasami Hiramatsu goto error; 151711a1ca35SMasami Hiramatsu tmp += ret; 151811a1ca35SMasami Hiramatsu len -= ret; 151911a1ca35SMasami Hiramatsu } 152011a1ca35SMasami Hiramatsu 15217df2f329SMasami Hiramatsu return tmp - buf; 15227df2f329SMasami Hiramatsu error: 15235f03cba4SMasami Hiramatsu pr_debug("Failed to synthesize perf probe argument: %d\n", ret); 1524146a1439SMasami Hiramatsu return ret; 15257df2f329SMasami Hiramatsu } 15267df2f329SMasami Hiramatsu 15274235b045SMasami Hiramatsu /* Compose only probe point (not argument) */ 15284235b045SMasami Hiramatsu static char *synthesize_perf_probe_point(struct perf_probe_point *pp) 152950656eecSMasami Hiramatsu { 1530fb1587d8SMasami Hiramatsu char *buf, *tmp; 1531fb1587d8SMasami Hiramatsu char offs[32] = "", line[32] = "", file[32] = ""; 1532fb1587d8SMasami Hiramatsu int ret, len; 153350656eecSMasami Hiramatsu 1534e334016fSMasami Hiramatsu buf = zalloc(MAX_CMDLEN); 1535e334016fSMasami Hiramatsu if (buf == NULL) { 1536e334016fSMasami Hiramatsu ret = -ENOMEM; 1537e334016fSMasami Hiramatsu goto error; 1538e334016fSMasami Hiramatsu } 15394de189feSMasami Hiramatsu if (pp->offset) { 1540fb1587d8SMasami Hiramatsu ret = e_snprintf(offs, 32, "+%lu", pp->offset); 15414de189feSMasami Hiramatsu if (ret <= 0) 15424de189feSMasami Hiramatsu goto error; 15434de189feSMasami Hiramatsu } 15444de189feSMasami Hiramatsu if (pp->line) { 1545fb1587d8SMasami Hiramatsu ret = e_snprintf(line, 32, ":%d", pp->line); 1546fb1587d8SMasami Hiramatsu if (ret <= 0) 1547fb1587d8SMasami Hiramatsu goto error; 1548fb1587d8SMasami Hiramatsu } 1549fb1587d8SMasami Hiramatsu if (pp->file) { 155032ae2adeSFranck Bui-Huu tmp = pp->file; 155132ae2adeSFranck Bui-Huu len = strlen(tmp); 155232ae2adeSFranck Bui-Huu if (len > 30) { 155332ae2adeSFranck Bui-Huu tmp = strchr(pp->file + len - 30, '/'); 155432ae2adeSFranck Bui-Huu tmp = tmp ? tmp + 1 : pp->file + len - 30; 155532ae2adeSFranck Bui-Huu } 155632ae2adeSFranck Bui-Huu ret = e_snprintf(file, 32, "@%s", tmp); 15574de189feSMasami Hiramatsu if (ret <= 0) 15584de189feSMasami Hiramatsu goto error; 15594de189feSMasami Hiramatsu } 15604de189feSMasami Hiramatsu 15614de189feSMasami Hiramatsu if (pp->function) 1562fb1587d8SMasami Hiramatsu ret = e_snprintf(buf, MAX_CMDLEN, "%s%s%s%s%s", pp->function, 1563fb1587d8SMasami Hiramatsu offs, pp->retprobe ? "%return" : "", line, 1564fb1587d8SMasami Hiramatsu file); 15654de189feSMasami Hiramatsu else 1566fb1587d8SMasami Hiramatsu ret = e_snprintf(buf, MAX_CMDLEN, "%s%s", file, line); 15674235b045SMasami Hiramatsu if (ret <= 0) 15684235b045SMasami Hiramatsu goto error; 15694235b045SMasami Hiramatsu 15704235b045SMasami Hiramatsu return buf; 15714235b045SMasami Hiramatsu error: 15725f03cba4SMasami Hiramatsu pr_debug("Failed to synthesize perf probe point: %d\n", ret); 1573146a1439SMasami Hiramatsu free(buf); 1574146a1439SMasami Hiramatsu return NULL; 15754235b045SMasami Hiramatsu } 15764235b045SMasami Hiramatsu 15774235b045SMasami Hiramatsu #if 0 15784235b045SMasami Hiramatsu char *synthesize_perf_probe_command(struct perf_probe_event *pev) 15794235b045SMasami Hiramatsu { 15804235b045SMasami Hiramatsu char *buf; 15814235b045SMasami Hiramatsu int i, len, ret; 15824235b045SMasami Hiramatsu 15834235b045SMasami Hiramatsu buf = synthesize_perf_probe_point(&pev->point); 15844235b045SMasami Hiramatsu if (!buf) 15854235b045SMasami Hiramatsu return NULL; 15864235b045SMasami Hiramatsu 15874235b045SMasami Hiramatsu len = strlen(buf); 15884235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 15894235b045SMasami Hiramatsu ret = e_snprintf(&buf[len], MAX_CMDLEN - len, " %s", 15904235b045SMasami Hiramatsu pev->args[i].name); 15917ef17aafSMasami Hiramatsu if (ret <= 0) { 15924235b045SMasami Hiramatsu free(buf); 15934235b045SMasami Hiramatsu return NULL; 15947ef17aafSMasami Hiramatsu } 15954235b045SMasami Hiramatsu len += ret; 15967ef17aafSMasami Hiramatsu } 159750656eecSMasami Hiramatsu 15984235b045SMasami Hiramatsu return buf; 15994235b045SMasami Hiramatsu } 16004235b045SMasami Hiramatsu #endif 16014235b045SMasami Hiramatsu 16020e60836bSSrikar Dronamraju static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref, 16034235b045SMasami Hiramatsu char **buf, size_t *buflen, 16044235b045SMasami Hiramatsu int depth) 16057ef17aafSMasami Hiramatsu { 16064235b045SMasami Hiramatsu int ret; 16074235b045SMasami Hiramatsu if (ref->next) { 16080e60836bSSrikar Dronamraju depth = __synthesize_probe_trace_arg_ref(ref->next, buf, 16094235b045SMasami Hiramatsu buflen, depth + 1); 16104235b045SMasami Hiramatsu if (depth < 0) 16114235b045SMasami Hiramatsu goto out; 16124235b045SMasami Hiramatsu } 16134235b045SMasami Hiramatsu 16144235b045SMasami Hiramatsu ret = e_snprintf(*buf, *buflen, "%+ld(", ref->offset); 16154235b045SMasami Hiramatsu if (ret < 0) 16164235b045SMasami Hiramatsu depth = ret; 16174235b045SMasami Hiramatsu else { 16184235b045SMasami Hiramatsu *buf += ret; 16194235b045SMasami Hiramatsu *buflen -= ret; 16204235b045SMasami Hiramatsu } 16214235b045SMasami Hiramatsu out: 16224235b045SMasami Hiramatsu return depth; 16234235b045SMasami Hiramatsu 16244235b045SMasami Hiramatsu } 16254235b045SMasami Hiramatsu 16260e60836bSSrikar Dronamraju static int synthesize_probe_trace_arg(struct probe_trace_arg *arg, 16274235b045SMasami Hiramatsu char *buf, size_t buflen) 16284235b045SMasami Hiramatsu { 16290e60836bSSrikar Dronamraju struct probe_trace_arg_ref *ref = arg->ref; 16304235b045SMasami Hiramatsu int ret, depth = 0; 16314235b045SMasami Hiramatsu char *tmp = buf; 16324235b045SMasami Hiramatsu 16334235b045SMasami Hiramatsu /* Argument name or separator */ 16344235b045SMasami Hiramatsu if (arg->name) 16354235b045SMasami Hiramatsu ret = e_snprintf(buf, buflen, " %s=", arg->name); 16364235b045SMasami Hiramatsu else 16374235b045SMasami Hiramatsu ret = e_snprintf(buf, buflen, " "); 16384235b045SMasami Hiramatsu if (ret < 0) 16394235b045SMasami Hiramatsu return ret; 16404235b045SMasami Hiramatsu buf += ret; 16414235b045SMasami Hiramatsu buflen -= ret; 16424235b045SMasami Hiramatsu 1643b7dcb857SMasami Hiramatsu /* Special case: @XXX */ 1644b7dcb857SMasami Hiramatsu if (arg->value[0] == '@' && arg->ref) 1645b7dcb857SMasami Hiramatsu ref = ref->next; 1646b7dcb857SMasami Hiramatsu 16474235b045SMasami Hiramatsu /* Dereferencing arguments */ 1648b7dcb857SMasami Hiramatsu if (ref) { 16490e60836bSSrikar Dronamraju depth = __synthesize_probe_trace_arg_ref(ref, &buf, 16504235b045SMasami Hiramatsu &buflen, 1); 16514235b045SMasami Hiramatsu if (depth < 0) 16524235b045SMasami Hiramatsu return depth; 16534235b045SMasami Hiramatsu } 16544235b045SMasami Hiramatsu 16554235b045SMasami Hiramatsu /* Print argument value */ 1656b7dcb857SMasami Hiramatsu if (arg->value[0] == '@' && arg->ref) 1657b7dcb857SMasami Hiramatsu ret = e_snprintf(buf, buflen, "%s%+ld", arg->value, 1658b7dcb857SMasami Hiramatsu arg->ref->offset); 1659b7dcb857SMasami Hiramatsu else 16604235b045SMasami Hiramatsu ret = e_snprintf(buf, buflen, "%s", arg->value); 16614235b045SMasami Hiramatsu if (ret < 0) 16624235b045SMasami Hiramatsu return ret; 16634235b045SMasami Hiramatsu buf += ret; 16644235b045SMasami Hiramatsu buflen -= ret; 16654235b045SMasami Hiramatsu 16664235b045SMasami Hiramatsu /* Closing */ 16674235b045SMasami Hiramatsu while (depth--) { 16684235b045SMasami Hiramatsu ret = e_snprintf(buf, buflen, ")"); 16694235b045SMasami Hiramatsu if (ret < 0) 16704235b045SMasami Hiramatsu return ret; 16714235b045SMasami Hiramatsu buf += ret; 16724235b045SMasami Hiramatsu buflen -= ret; 16734235b045SMasami Hiramatsu } 16744984912eSMasami Hiramatsu /* Print argument type */ 16754984912eSMasami Hiramatsu if (arg->type) { 16764984912eSMasami Hiramatsu ret = e_snprintf(buf, buflen, ":%s", arg->type); 16774984912eSMasami Hiramatsu if (ret <= 0) 16784984912eSMasami Hiramatsu return ret; 16794984912eSMasami Hiramatsu buf += ret; 16804984912eSMasami Hiramatsu } 16814235b045SMasami Hiramatsu 16824235b045SMasami Hiramatsu return buf - tmp; 16834235b045SMasami Hiramatsu } 16844235b045SMasami Hiramatsu 16850e60836bSSrikar Dronamraju char *synthesize_probe_trace_command(struct probe_trace_event *tev) 16864235b045SMasami Hiramatsu { 16870e60836bSSrikar Dronamraju struct probe_trace_point *tp = &tev->point; 16887ef17aafSMasami Hiramatsu char *buf; 16897ef17aafSMasami Hiramatsu int i, len, ret; 16907ef17aafSMasami Hiramatsu 1691e334016fSMasami Hiramatsu buf = zalloc(MAX_CMDLEN); 1692e334016fSMasami Hiramatsu if (buf == NULL) 1693e334016fSMasami Hiramatsu return NULL; 1694e334016fSMasami Hiramatsu 1695eb948e50SMasami Hiramatsu len = e_snprintf(buf, MAX_CMDLEN, "%c:%s/%s ", tp->retprobe ? 'r' : 'p', 1696eb948e50SMasami Hiramatsu tev->group, tev->event); 1697eb948e50SMasami Hiramatsu if (len <= 0) 1698eb948e50SMasami Hiramatsu goto error; 1699eb948e50SMasami Hiramatsu 1700eb948e50SMasami Hiramatsu /* Uprobes must have tp->address and tp->module */ 1701eb948e50SMasami Hiramatsu if (tev->uprobes && (!tp->address || !tp->module)) 1702eb948e50SMasami Hiramatsu goto error; 1703eb948e50SMasami Hiramatsu 1704eb948e50SMasami Hiramatsu /* Use the tp->address for uprobes */ 1705225466f1SSrikar Dronamraju if (tev->uprobes) 1706eb948e50SMasami Hiramatsu ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s:0x%lx", 1707eb948e50SMasami Hiramatsu tp->module, tp->address); 1708225466f1SSrikar Dronamraju else 1709eb948e50SMasami Hiramatsu ret = e_snprintf(buf + len, MAX_CMDLEN - len, "%s%s%s+%lu", 1710190b57fcSMasami Hiramatsu tp->module ?: "", tp->module ? ":" : "", 17114235b045SMasami Hiramatsu tp->symbol, tp->offset); 1712225466f1SSrikar Dronamraju 1713eb948e50SMasami Hiramatsu if (ret <= 0) 17144235b045SMasami Hiramatsu goto error; 1715eb948e50SMasami Hiramatsu len += ret; 17167ef17aafSMasami Hiramatsu 17174235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 17180e60836bSSrikar Dronamraju ret = synthesize_probe_trace_arg(&tev->args[i], buf + len, 17194235b045SMasami Hiramatsu MAX_CMDLEN - len); 17204de189feSMasami Hiramatsu if (ret <= 0) 172150656eecSMasami Hiramatsu goto error; 172250656eecSMasami Hiramatsu len += ret; 172350656eecSMasami Hiramatsu } 172450656eecSMasami Hiramatsu 17254235b045SMasami Hiramatsu return buf; 172650656eecSMasami Hiramatsu error: 17274235b045SMasami Hiramatsu free(buf); 17284235b045SMasami Hiramatsu return NULL; 172950656eecSMasami Hiramatsu } 173050656eecSMasami Hiramatsu 17315a6f6314SMasami Hiramatsu static int find_perf_probe_point_from_map(struct probe_trace_point *tp, 17325a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 17335a6f6314SMasami Hiramatsu bool is_kprobe) 17345a6f6314SMasami Hiramatsu { 17355a6f6314SMasami Hiramatsu struct symbol *sym = NULL; 17365a6f6314SMasami Hiramatsu struct map *map; 17375a6f6314SMasami Hiramatsu u64 addr; 17385a6f6314SMasami Hiramatsu int ret = -ENOENT; 17395a6f6314SMasami Hiramatsu 17405a6f6314SMasami Hiramatsu if (!is_kprobe) { 17415a6f6314SMasami Hiramatsu map = dso__new_map(tp->module); 17425a6f6314SMasami Hiramatsu if (!map) 17435a6f6314SMasami Hiramatsu goto out; 17445a6f6314SMasami Hiramatsu addr = tp->address; 17455a6f6314SMasami Hiramatsu sym = map__find_symbol(map, addr, NULL); 17465a6f6314SMasami Hiramatsu } else { 17475a6f6314SMasami Hiramatsu addr = kernel_get_symbol_address_by_name(tp->symbol, true); 17485a6f6314SMasami Hiramatsu if (addr) { 17495a6f6314SMasami Hiramatsu addr += tp->offset; 17505a6f6314SMasami Hiramatsu sym = __find_kernel_function(addr, &map); 17515a6f6314SMasami Hiramatsu } 17525a6f6314SMasami Hiramatsu } 17535a6f6314SMasami Hiramatsu if (!sym) 17545a6f6314SMasami Hiramatsu goto out; 17555a6f6314SMasami Hiramatsu 17565a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 17575a6f6314SMasami Hiramatsu pp->offset = addr - map->unmap_ip(map, sym->start); 17585a6f6314SMasami Hiramatsu pp->function = strdup(sym->name); 17595a6f6314SMasami Hiramatsu ret = pp->function ? 0 : -ENOMEM; 17605a6f6314SMasami Hiramatsu 17615a6f6314SMasami Hiramatsu out: 17625a6f6314SMasami Hiramatsu if (map && !is_kprobe) { 17635a6f6314SMasami Hiramatsu dso__delete(map->dso); 17645a6f6314SMasami Hiramatsu map__delete(map); 17655a6f6314SMasami Hiramatsu } 17665a6f6314SMasami Hiramatsu 17675a6f6314SMasami Hiramatsu return ret; 17685a6f6314SMasami Hiramatsu } 17695a6f6314SMasami Hiramatsu 17705a6f6314SMasami Hiramatsu static int convert_to_perf_probe_point(struct probe_trace_point *tp, 17715a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 17725a6f6314SMasami Hiramatsu bool is_kprobe) 17735a6f6314SMasami Hiramatsu { 17745a6f6314SMasami Hiramatsu char buf[128]; 17755a6f6314SMasami Hiramatsu int ret; 17765a6f6314SMasami Hiramatsu 17775a6f6314SMasami Hiramatsu ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe); 17785a6f6314SMasami Hiramatsu if (!ret) 17795a6f6314SMasami Hiramatsu return 0; 17805a6f6314SMasami Hiramatsu ret = find_perf_probe_point_from_map(tp, pp, is_kprobe); 17815a6f6314SMasami Hiramatsu if (!ret) 17825a6f6314SMasami Hiramatsu return 0; 17835a6f6314SMasami Hiramatsu 17845a6f6314SMasami Hiramatsu pr_debug("Failed to find probe point from both of dwarf and map.\n"); 17855a6f6314SMasami Hiramatsu 17865a6f6314SMasami Hiramatsu if (tp->symbol) { 17875a6f6314SMasami Hiramatsu pp->function = strdup(tp->symbol); 17885a6f6314SMasami Hiramatsu pp->offset = tp->offset; 17895a6f6314SMasami Hiramatsu } else if (!tp->module && !is_kprobe) { 17905a6f6314SMasami Hiramatsu ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address); 17915a6f6314SMasami Hiramatsu if (ret < 0) 17925a6f6314SMasami Hiramatsu return ret; 17935a6f6314SMasami Hiramatsu pp->function = strdup(buf); 17945a6f6314SMasami Hiramatsu pp->offset = 0; 17955a6f6314SMasami Hiramatsu } 17965a6f6314SMasami Hiramatsu if (pp->function == NULL) 17975a6f6314SMasami Hiramatsu return -ENOMEM; 17985a6f6314SMasami Hiramatsu 17995a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 18005a6f6314SMasami Hiramatsu 18015a6f6314SMasami Hiramatsu return 0; 18025a6f6314SMasami Hiramatsu } 18035a6f6314SMasami Hiramatsu 18040e60836bSSrikar Dronamraju static int convert_to_perf_probe_event(struct probe_trace_event *tev, 1805225466f1SSrikar Dronamraju struct perf_probe_event *pev, bool is_kprobe) 18064de189feSMasami Hiramatsu { 180702b95dadSMasami Hiramatsu char buf[64] = ""; 1808146a1439SMasami Hiramatsu int i, ret; 18094de189feSMasami Hiramatsu 18104b4da7f7SMasami Hiramatsu /* Convert event/group name */ 181102b95dadSMasami Hiramatsu pev->event = strdup(tev->event); 181202b95dadSMasami Hiramatsu pev->group = strdup(tev->group); 181302b95dadSMasami Hiramatsu if (pev->event == NULL || pev->group == NULL) 181402b95dadSMasami Hiramatsu return -ENOMEM; 1815fb1587d8SMasami Hiramatsu 18164b4da7f7SMasami Hiramatsu /* Convert trace_point to probe_point */ 18175a6f6314SMasami Hiramatsu ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe); 1818146a1439SMasami Hiramatsu if (ret < 0) 1819146a1439SMasami Hiramatsu return ret; 18204b4da7f7SMasami Hiramatsu 18214235b045SMasami Hiramatsu /* Convert trace_arg to probe_arg */ 18224235b045SMasami Hiramatsu pev->nargs = tev->nargs; 1823e334016fSMasami Hiramatsu pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs); 1824e334016fSMasami Hiramatsu if (pev->args == NULL) 1825e334016fSMasami Hiramatsu return -ENOMEM; 182602b95dadSMasami Hiramatsu for (i = 0; i < tev->nargs && ret >= 0; i++) { 18274235b045SMasami Hiramatsu if (tev->args[i].name) 182802b95dadSMasami Hiramatsu pev->args[i].name = strdup(tev->args[i].name); 18294235b045SMasami Hiramatsu else { 18300e60836bSSrikar Dronamraju ret = synthesize_probe_trace_arg(&tev->args[i], 1831146a1439SMasami Hiramatsu buf, 64); 183202b95dadSMasami Hiramatsu pev->args[i].name = strdup(buf); 183302b95dadSMasami Hiramatsu } 183402b95dadSMasami Hiramatsu if (pev->args[i].name == NULL && ret >= 0) 183502b95dadSMasami Hiramatsu ret = -ENOMEM; 18364de189feSMasami Hiramatsu } 1837146a1439SMasami Hiramatsu 1838146a1439SMasami Hiramatsu if (ret < 0) 1839146a1439SMasami Hiramatsu clear_perf_probe_event(pev); 1840146a1439SMasami Hiramatsu 1841146a1439SMasami Hiramatsu return ret; 18424235b045SMasami Hiramatsu } 18434de189feSMasami Hiramatsu 18444235b045SMasami Hiramatsu void clear_perf_probe_event(struct perf_probe_event *pev) 18454235b045SMasami Hiramatsu { 18467df2f329SMasami Hiramatsu struct perf_probe_arg_field *field, *next; 18474235b045SMasami Hiramatsu int i; 18484de189feSMasami Hiramatsu 18494235b045SMasami Hiramatsu free(pev->event); 18504235b045SMasami Hiramatsu free(pev->group); 18517afb3fabSMasami Hiramatsu free(pev->target); 18529b118acaSMasami Hiramatsu clear_perf_probe_point(&pev->point); 1853f5385650SArnaldo Carvalho de Melo 18547df2f329SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 18554235b045SMasami Hiramatsu free(pev->args[i].name); 185648481938SMasami Hiramatsu free(pev->args[i].var); 185711a1ca35SMasami Hiramatsu free(pev->args[i].type); 18587df2f329SMasami Hiramatsu field = pev->args[i].field; 18597df2f329SMasami Hiramatsu while (field) { 18607df2f329SMasami Hiramatsu next = field->next; 186174cf249dSArnaldo Carvalho de Melo zfree(&field->name); 18627df2f329SMasami Hiramatsu free(field); 18637df2f329SMasami Hiramatsu field = next; 18647df2f329SMasami Hiramatsu } 18657df2f329SMasami Hiramatsu } 18664235b045SMasami Hiramatsu free(pev->args); 18674235b045SMasami Hiramatsu memset(pev, 0, sizeof(*pev)); 18684235b045SMasami Hiramatsu } 18694235b045SMasami Hiramatsu 18700e60836bSSrikar Dronamraju static void clear_probe_trace_event(struct probe_trace_event *tev) 18714235b045SMasami Hiramatsu { 18720e60836bSSrikar Dronamraju struct probe_trace_arg_ref *ref, *next; 18734235b045SMasami Hiramatsu int i; 18744235b045SMasami Hiramatsu 18754235b045SMasami Hiramatsu free(tev->event); 18764235b045SMasami Hiramatsu free(tev->group); 18774235b045SMasami Hiramatsu free(tev->point.symbol); 1878190b57fcSMasami Hiramatsu free(tev->point.module); 18794235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 18804235b045SMasami Hiramatsu free(tev->args[i].name); 18814235b045SMasami Hiramatsu free(tev->args[i].value); 18824984912eSMasami Hiramatsu free(tev->args[i].type); 18834235b045SMasami Hiramatsu ref = tev->args[i].ref; 18844235b045SMasami Hiramatsu while (ref) { 18854235b045SMasami Hiramatsu next = ref->next; 18864235b045SMasami Hiramatsu free(ref); 18874235b045SMasami Hiramatsu ref = next; 18884235b045SMasami Hiramatsu } 18894235b045SMasami Hiramatsu } 18904235b045SMasami Hiramatsu free(tev->args); 18914235b045SMasami Hiramatsu memset(tev, 0, sizeof(*tev)); 18924de189feSMasami Hiramatsu } 18934de189feSMasami Hiramatsu 18945e45187cSMasami Hiramatsu static void print_open_warning(int err, bool is_kprobe) 1895225466f1SSrikar Dronamraju { 18965f03cba4SMasami Hiramatsu char sbuf[STRERR_BUFSIZE]; 1897225466f1SSrikar Dronamraju 18985e45187cSMasami Hiramatsu if (err == -ENOENT) { 1899225466f1SSrikar Dronamraju const char *config; 1900225466f1SSrikar Dronamraju 1901225466f1SSrikar Dronamraju if (!is_kprobe) 1902225466f1SSrikar Dronamraju config = "CONFIG_UPROBE_EVENTS"; 1903225466f1SSrikar Dronamraju else 1904225466f1SSrikar Dronamraju config = "CONFIG_KPROBE_EVENTS"; 1905225466f1SSrikar Dronamraju 19065e45187cSMasami Hiramatsu pr_warning("%cprobe_events file does not exist" 19075e45187cSMasami Hiramatsu " - please rebuild kernel with %s.\n", 19085e45187cSMasami Hiramatsu is_kprobe ? 'k' : 'u', config); 19095e45187cSMasami Hiramatsu } else if (err == -ENOTSUP) 191023773ca1SSteven Rostedt (Red Hat) pr_warning("Tracefs or debugfs is not mounted.\n"); 19115e45187cSMasami Hiramatsu else 19125e45187cSMasami Hiramatsu pr_warning("Failed to open %cprobe_events: %s\n", 19135e45187cSMasami Hiramatsu is_kprobe ? 'k' : 'u', 19145e45187cSMasami Hiramatsu strerror_r(-err, sbuf, sizeof(sbuf))); 1915225466f1SSrikar Dronamraju } 1916225466f1SSrikar Dronamraju 1917467ec085SMasami Hiramatsu static void print_both_open_warning(int kerr, int uerr) 1918467ec085SMasami Hiramatsu { 1919467ec085SMasami Hiramatsu /* Both kprobes and uprobes are disabled, warn it. */ 1920467ec085SMasami Hiramatsu if (kerr == -ENOTSUP && uerr == -ENOTSUP) 192123773ca1SSteven Rostedt (Red Hat) pr_warning("Tracefs or debugfs is not mounted.\n"); 1922467ec085SMasami Hiramatsu else if (kerr == -ENOENT && uerr == -ENOENT) 1923467ec085SMasami Hiramatsu pr_warning("Please rebuild kernel with CONFIG_KPROBE_EVENTS " 1924467ec085SMasami Hiramatsu "or/and CONFIG_UPROBE_EVENTS.\n"); 1925467ec085SMasami Hiramatsu else { 19265f03cba4SMasami Hiramatsu char sbuf[STRERR_BUFSIZE]; 1927467ec085SMasami Hiramatsu pr_warning("Failed to open kprobe events: %s.\n", 1928467ec085SMasami Hiramatsu strerror_r(-kerr, sbuf, sizeof(sbuf))); 1929467ec085SMasami Hiramatsu pr_warning("Failed to open uprobe events: %s.\n", 1930467ec085SMasami Hiramatsu strerror_r(-uerr, sbuf, sizeof(sbuf))); 1931467ec085SMasami Hiramatsu } 1932467ec085SMasami Hiramatsu } 1933467ec085SMasami Hiramatsu 19345e45187cSMasami Hiramatsu static int open_probe_events(const char *trace_file, bool readwrite) 19354de189feSMasami Hiramatsu { 19364de189feSMasami Hiramatsu char buf[PATH_MAX]; 19377ca5989dSMasami Hiramatsu const char *__debugfs; 193823773ca1SSteven Rostedt (Red Hat) const char *tracing_dir = ""; 19394de189feSMasami Hiramatsu int ret; 19404de189feSMasami Hiramatsu 194123773ca1SSteven Rostedt (Red Hat) __debugfs = tracefs_find_mountpoint(); 194223773ca1SSteven Rostedt (Red Hat) if (__debugfs == NULL) { 194323773ca1SSteven Rostedt (Red Hat) tracing_dir = "tracing/"; 194423773ca1SSteven Rostedt (Red Hat) 19457ca5989dSMasami Hiramatsu __debugfs = debugfs_find_mountpoint(); 19465e45187cSMasami Hiramatsu if (__debugfs == NULL) 19475e45187cSMasami Hiramatsu return -ENOTSUP; 194823773ca1SSteven Rostedt (Red Hat) } 19497ca5989dSMasami Hiramatsu 195023773ca1SSteven Rostedt (Red Hat) ret = e_snprintf(buf, PATH_MAX, "%s/%s%s", 195123773ca1SSteven Rostedt (Red Hat) __debugfs, tracing_dir, trace_file); 1952146a1439SMasami Hiramatsu if (ret >= 0) { 19537ca5989dSMasami Hiramatsu pr_debug("Opening %s write=%d\n", buf, readwrite); 1954f4d7da49SMasami Hiramatsu if (readwrite && !probe_event_dry_run) 1955f4d7da49SMasami Hiramatsu ret = open(buf, O_RDWR, O_APPEND); 1956f4d7da49SMasami Hiramatsu else 1957f4d7da49SMasami Hiramatsu ret = open(buf, O_RDONLY, 0); 1958f4d7da49SMasami Hiramatsu 1959225466f1SSrikar Dronamraju if (ret < 0) 19605e45187cSMasami Hiramatsu ret = -errno; 19614de189feSMasami Hiramatsu } 19624de189feSMasami Hiramatsu return ret; 19634de189feSMasami Hiramatsu } 19644de189feSMasami Hiramatsu 1965225466f1SSrikar Dronamraju static int open_kprobe_events(bool readwrite) 1966225466f1SSrikar Dronamraju { 196723773ca1SSteven Rostedt (Red Hat) return open_probe_events("kprobe_events", readwrite); 1968225466f1SSrikar Dronamraju } 1969225466f1SSrikar Dronamraju 1970225466f1SSrikar Dronamraju static int open_uprobe_events(bool readwrite) 1971225466f1SSrikar Dronamraju { 197223773ca1SSteven Rostedt (Red Hat) return open_probe_events("uprobe_events", readwrite); 1973225466f1SSrikar Dronamraju } 1974225466f1SSrikar Dronamraju 1975225466f1SSrikar Dronamraju /* Get raw string list of current kprobe_events or uprobe_events */ 19760e60836bSSrikar Dronamraju static struct strlist *get_probe_trace_command_rawlist(int fd) 19774de189feSMasami Hiramatsu { 19784de189feSMasami Hiramatsu int ret, idx; 19794de189feSMasami Hiramatsu FILE *fp; 19804de189feSMasami Hiramatsu char buf[MAX_CMDLEN]; 19814de189feSMasami Hiramatsu char *p; 19824de189feSMasami Hiramatsu struct strlist *sl; 19834de189feSMasami Hiramatsu 19844de189feSMasami Hiramatsu sl = strlist__new(true, NULL); 19854de189feSMasami Hiramatsu 19864de189feSMasami Hiramatsu fp = fdopen(dup(fd), "r"); 19874de189feSMasami Hiramatsu while (!feof(fp)) { 19884de189feSMasami Hiramatsu p = fgets(buf, MAX_CMDLEN, fp); 19894de189feSMasami Hiramatsu if (!p) 19904de189feSMasami Hiramatsu break; 19914de189feSMasami Hiramatsu 19924de189feSMasami Hiramatsu idx = strlen(p) - 1; 19934de189feSMasami Hiramatsu if (p[idx] == '\n') 19944de189feSMasami Hiramatsu p[idx] = '\0'; 19954de189feSMasami Hiramatsu ret = strlist__add(sl, buf); 1996146a1439SMasami Hiramatsu if (ret < 0) { 19976eb08660SMasami Hiramatsu pr_debug("strlist__add failed (%d)\n", ret); 1998146a1439SMasami Hiramatsu strlist__delete(sl); 1999146a1439SMasami Hiramatsu return NULL; 2000146a1439SMasami Hiramatsu } 20014de189feSMasami Hiramatsu } 20024de189feSMasami Hiramatsu fclose(fp); 20034de189feSMasami Hiramatsu 20044de189feSMasami Hiramatsu return sl; 20054de189feSMasami Hiramatsu } 20064de189feSMasami Hiramatsu 20079aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node { 20089aaf5a5fSMasami Hiramatsu struct list_head list; 20099aaf5a5fSMasami Hiramatsu unsigned long start; 20109aaf5a5fSMasami Hiramatsu unsigned long end; 20119aaf5a5fSMasami Hiramatsu char *symbol; 20129aaf5a5fSMasami Hiramatsu }; 20139aaf5a5fSMasami Hiramatsu 20149aaf5a5fSMasami Hiramatsu static void kprobe_blacklist__delete(struct list_head *blacklist) 20159aaf5a5fSMasami Hiramatsu { 20169aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 20179aaf5a5fSMasami Hiramatsu 20189aaf5a5fSMasami Hiramatsu while (!list_empty(blacklist)) { 20199aaf5a5fSMasami Hiramatsu node = list_first_entry(blacklist, 20209aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node, list); 20219aaf5a5fSMasami Hiramatsu list_del(&node->list); 20229aaf5a5fSMasami Hiramatsu free(node->symbol); 20239aaf5a5fSMasami Hiramatsu free(node); 20249aaf5a5fSMasami Hiramatsu } 20259aaf5a5fSMasami Hiramatsu } 20269aaf5a5fSMasami Hiramatsu 20279aaf5a5fSMasami Hiramatsu static int kprobe_blacklist__load(struct list_head *blacklist) 20289aaf5a5fSMasami Hiramatsu { 20299aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 20309aaf5a5fSMasami Hiramatsu const char *__debugfs = debugfs_find_mountpoint(); 20319aaf5a5fSMasami Hiramatsu char buf[PATH_MAX], *p; 20329aaf5a5fSMasami Hiramatsu FILE *fp; 20339aaf5a5fSMasami Hiramatsu int ret; 20349aaf5a5fSMasami Hiramatsu 20359aaf5a5fSMasami Hiramatsu if (__debugfs == NULL) 20369aaf5a5fSMasami Hiramatsu return -ENOTSUP; 20379aaf5a5fSMasami Hiramatsu 20389aaf5a5fSMasami Hiramatsu ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs); 20399aaf5a5fSMasami Hiramatsu if (ret < 0) 20409aaf5a5fSMasami Hiramatsu return ret; 20419aaf5a5fSMasami Hiramatsu 20429aaf5a5fSMasami Hiramatsu fp = fopen(buf, "r"); 20439aaf5a5fSMasami Hiramatsu if (!fp) 20449aaf5a5fSMasami Hiramatsu return -errno; 20459aaf5a5fSMasami Hiramatsu 20469aaf5a5fSMasami Hiramatsu ret = 0; 20479aaf5a5fSMasami Hiramatsu while (fgets(buf, PATH_MAX, fp)) { 20489aaf5a5fSMasami Hiramatsu node = zalloc(sizeof(*node)); 20499aaf5a5fSMasami Hiramatsu if (!node) { 20509aaf5a5fSMasami Hiramatsu ret = -ENOMEM; 20519aaf5a5fSMasami Hiramatsu break; 20529aaf5a5fSMasami Hiramatsu } 20539aaf5a5fSMasami Hiramatsu INIT_LIST_HEAD(&node->list); 20549aaf5a5fSMasami Hiramatsu list_add_tail(&node->list, blacklist); 20559aaf5a5fSMasami Hiramatsu if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) { 20569aaf5a5fSMasami Hiramatsu ret = -EINVAL; 20579aaf5a5fSMasami Hiramatsu break; 20589aaf5a5fSMasami Hiramatsu } 20599aaf5a5fSMasami Hiramatsu p = strchr(buf, '\t'); 20609aaf5a5fSMasami Hiramatsu if (p) { 20619aaf5a5fSMasami Hiramatsu p++; 20629aaf5a5fSMasami Hiramatsu if (p[strlen(p) - 1] == '\n') 20639aaf5a5fSMasami Hiramatsu p[strlen(p) - 1] = '\0'; 20649aaf5a5fSMasami Hiramatsu } else 20659aaf5a5fSMasami Hiramatsu p = (char *)"unknown"; 20669aaf5a5fSMasami Hiramatsu node->symbol = strdup(p); 20679aaf5a5fSMasami Hiramatsu if (!node->symbol) { 20689aaf5a5fSMasami Hiramatsu ret = -ENOMEM; 20699aaf5a5fSMasami Hiramatsu break; 20709aaf5a5fSMasami Hiramatsu } 20719aaf5a5fSMasami Hiramatsu pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n", 20729aaf5a5fSMasami Hiramatsu node->start, node->end, node->symbol); 20739aaf5a5fSMasami Hiramatsu ret++; 20749aaf5a5fSMasami Hiramatsu } 20759aaf5a5fSMasami Hiramatsu if (ret < 0) 20769aaf5a5fSMasami Hiramatsu kprobe_blacklist__delete(blacklist); 20779aaf5a5fSMasami Hiramatsu fclose(fp); 20789aaf5a5fSMasami Hiramatsu 20799aaf5a5fSMasami Hiramatsu return ret; 20809aaf5a5fSMasami Hiramatsu } 20819aaf5a5fSMasami Hiramatsu 20829aaf5a5fSMasami Hiramatsu static struct kprobe_blacklist_node * 20839aaf5a5fSMasami Hiramatsu kprobe_blacklist__find_by_address(struct list_head *blacklist, 20849aaf5a5fSMasami Hiramatsu unsigned long address) 20859aaf5a5fSMasami Hiramatsu { 20869aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 20879aaf5a5fSMasami Hiramatsu 20889aaf5a5fSMasami Hiramatsu list_for_each_entry(node, blacklist, list) { 20899aaf5a5fSMasami Hiramatsu if (node->start <= address && address <= node->end) 20909aaf5a5fSMasami Hiramatsu return node; 20919aaf5a5fSMasami Hiramatsu } 20929aaf5a5fSMasami Hiramatsu 20939aaf5a5fSMasami Hiramatsu return NULL; 20949aaf5a5fSMasami Hiramatsu } 20959aaf5a5fSMasami Hiramatsu 2096278498d4SMasami Hiramatsu /* Show an event */ 2097fb226ccdSMasami Hiramatsu static int show_perf_probe_event(struct perf_probe_event *pev, 2098fb226ccdSMasami Hiramatsu const char *module) 2099278498d4SMasami Hiramatsu { 21007e990a51SMasami Hiramatsu int i, ret; 2101278498d4SMasami Hiramatsu char buf[128]; 21024235b045SMasami Hiramatsu char *place; 2103278498d4SMasami Hiramatsu 21044235b045SMasami Hiramatsu /* Synthesize only event probe point */ 21054235b045SMasami Hiramatsu place = synthesize_perf_probe_point(&pev->point); 2106146a1439SMasami Hiramatsu if (!place) 2107146a1439SMasami Hiramatsu return -EINVAL; 21084235b045SMasami Hiramatsu 21094235b045SMasami Hiramatsu ret = e_snprintf(buf, 128, "%s:%s", pev->group, pev->event); 21107e990a51SMasami Hiramatsu if (ret < 0) 2111146a1439SMasami Hiramatsu return ret; 2112146a1439SMasami Hiramatsu 21135e17b28fSMasami Hiramatsu pr_info(" %-20s (on %s", buf, place); 2114fb226ccdSMasami Hiramatsu if (module) 21155e17b28fSMasami Hiramatsu pr_info(" in %s", module); 2116278498d4SMasami Hiramatsu 21174235b045SMasami Hiramatsu if (pev->nargs > 0) { 21185e17b28fSMasami Hiramatsu pr_info(" with"); 21197df2f329SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 2120146a1439SMasami Hiramatsu ret = synthesize_perf_probe_arg(&pev->args[i], 2121146a1439SMasami Hiramatsu buf, 128); 2122146a1439SMasami Hiramatsu if (ret < 0) 2123146a1439SMasami Hiramatsu break; 21245e17b28fSMasami Hiramatsu pr_info(" %s", buf); 21257df2f329SMasami Hiramatsu } 2126278498d4SMasami Hiramatsu } 21275e17b28fSMasami Hiramatsu pr_info(")\n"); 21284235b045SMasami Hiramatsu free(place); 2129146a1439SMasami Hiramatsu return ret; 2130278498d4SMasami Hiramatsu } 2131278498d4SMasami Hiramatsu 2132225466f1SSrikar Dronamraju static int __show_perf_probe_events(int fd, bool is_kprobe) 21334de189feSMasami Hiramatsu { 2134225466f1SSrikar Dronamraju int ret = 0; 21350e60836bSSrikar Dronamraju struct probe_trace_event tev; 21364235b045SMasami Hiramatsu struct perf_probe_event pev; 21374de189feSMasami Hiramatsu struct strlist *rawlist; 21384de189feSMasami Hiramatsu struct str_node *ent; 21394de189feSMasami Hiramatsu 21404235b045SMasami Hiramatsu memset(&tev, 0, sizeof(tev)); 21414235b045SMasami Hiramatsu memset(&pev, 0, sizeof(pev)); 214272041334SMasami Hiramatsu 21430e60836bSSrikar Dronamraju rawlist = get_probe_trace_command_rawlist(fd); 2144146a1439SMasami Hiramatsu if (!rawlist) 21456eb08660SMasami Hiramatsu return -ENOMEM; 21464de189feSMasami Hiramatsu 2147adf365f4SMasami Hiramatsu strlist__for_each(ent, rawlist) { 21480e60836bSSrikar Dronamraju ret = parse_probe_trace_command(ent->s, &tev); 2149146a1439SMasami Hiramatsu if (ret >= 0) { 2150225466f1SSrikar Dronamraju ret = convert_to_perf_probe_event(&tev, &pev, 2151225466f1SSrikar Dronamraju is_kprobe); 2152146a1439SMasami Hiramatsu if (ret >= 0) 2153fb226ccdSMasami Hiramatsu ret = show_perf_probe_event(&pev, 2154fb226ccdSMasami Hiramatsu tev.point.module); 2155146a1439SMasami Hiramatsu } 21564235b045SMasami Hiramatsu clear_perf_probe_event(&pev); 21570e60836bSSrikar Dronamraju clear_probe_trace_event(&tev); 2158146a1439SMasami Hiramatsu if (ret < 0) 2159146a1439SMasami Hiramatsu break; 21604de189feSMasami Hiramatsu } 21614de189feSMasami Hiramatsu strlist__delete(rawlist); 2162146a1439SMasami Hiramatsu 2163146a1439SMasami Hiramatsu return ret; 21644de189feSMasami Hiramatsu } 21654de189feSMasami Hiramatsu 2166225466f1SSrikar Dronamraju /* List up current perf-probe events */ 2167225466f1SSrikar Dronamraju int show_perf_probe_events(void) 2168225466f1SSrikar Dronamraju { 21695e45187cSMasami Hiramatsu int kp_fd, up_fd, ret; 2170225466f1SSrikar Dronamraju 2171225466f1SSrikar Dronamraju setup_pager(); 2172225466f1SSrikar Dronamraju 2173ee45b6c2SMasami Hiramatsu ret = init_symbol_maps(false); 2174225466f1SSrikar Dronamraju if (ret < 0) 2175225466f1SSrikar Dronamraju return ret; 2176225466f1SSrikar Dronamraju 21775e45187cSMasami Hiramatsu kp_fd = open_kprobe_events(false); 21785e45187cSMasami Hiramatsu if (kp_fd >= 0) { 21795e45187cSMasami Hiramatsu ret = __show_perf_probe_events(kp_fd, true); 21805e45187cSMasami Hiramatsu close(kp_fd); 21815e45187cSMasami Hiramatsu if (ret < 0) 21825e45187cSMasami Hiramatsu goto out; 2183225466f1SSrikar Dronamraju } 2184225466f1SSrikar Dronamraju 21855e45187cSMasami Hiramatsu up_fd = open_uprobe_events(false); 21865e45187cSMasami Hiramatsu if (kp_fd < 0 && up_fd < 0) { 2187467ec085SMasami Hiramatsu print_both_open_warning(kp_fd, up_fd); 21885e45187cSMasami Hiramatsu ret = kp_fd; 21895e45187cSMasami Hiramatsu goto out; 21905e45187cSMasami Hiramatsu } 21915e45187cSMasami Hiramatsu 21925e45187cSMasami Hiramatsu if (up_fd >= 0) { 21935e45187cSMasami Hiramatsu ret = __show_perf_probe_events(up_fd, false); 21945e45187cSMasami Hiramatsu close(up_fd); 21955e45187cSMasami Hiramatsu } 21965e45187cSMasami Hiramatsu out: 2197ee45b6c2SMasami Hiramatsu exit_symbol_maps(); 2198225466f1SSrikar Dronamraju return ret; 2199225466f1SSrikar Dronamraju } 2200225466f1SSrikar Dronamraju 2201b498ce1fSMasami Hiramatsu /* Get current perf-probe event names */ 22020e60836bSSrikar Dronamraju static struct strlist *get_probe_trace_event_names(int fd, bool include_group) 2203b498ce1fSMasami Hiramatsu { 2204fa28244dSMasami Hiramatsu char buf[128]; 2205b498ce1fSMasami Hiramatsu struct strlist *sl, *rawlist; 2206b498ce1fSMasami Hiramatsu struct str_node *ent; 22070e60836bSSrikar Dronamraju struct probe_trace_event tev; 2208146a1439SMasami Hiramatsu int ret = 0; 2209b498ce1fSMasami Hiramatsu 22104235b045SMasami Hiramatsu memset(&tev, 0, sizeof(tev)); 22110e60836bSSrikar Dronamraju rawlist = get_probe_trace_command_rawlist(fd); 22126eb08660SMasami Hiramatsu if (!rawlist) 22136eb08660SMasami Hiramatsu return NULL; 2214e1d2017bSMasami Hiramatsu sl = strlist__new(true, NULL); 2215adf365f4SMasami Hiramatsu strlist__for_each(ent, rawlist) { 22160e60836bSSrikar Dronamraju ret = parse_probe_trace_command(ent->s, &tev); 2217146a1439SMasami Hiramatsu if (ret < 0) 2218146a1439SMasami Hiramatsu break; 2219fa28244dSMasami Hiramatsu if (include_group) { 2220146a1439SMasami Hiramatsu ret = e_snprintf(buf, 128, "%s:%s", tev.group, 2221146a1439SMasami Hiramatsu tev.event); 2222146a1439SMasami Hiramatsu if (ret >= 0) 2223146a1439SMasami Hiramatsu ret = strlist__add(sl, buf); 2224fa28244dSMasami Hiramatsu } else 2225146a1439SMasami Hiramatsu ret = strlist__add(sl, tev.event); 22260e60836bSSrikar Dronamraju clear_probe_trace_event(&tev); 2227146a1439SMasami Hiramatsu if (ret < 0) 2228146a1439SMasami Hiramatsu break; 2229b498ce1fSMasami Hiramatsu } 2230b498ce1fSMasami Hiramatsu strlist__delete(rawlist); 2231b498ce1fSMasami Hiramatsu 2232146a1439SMasami Hiramatsu if (ret < 0) { 2233146a1439SMasami Hiramatsu strlist__delete(sl); 2234146a1439SMasami Hiramatsu return NULL; 2235146a1439SMasami Hiramatsu } 2236b498ce1fSMasami Hiramatsu return sl; 2237b498ce1fSMasami Hiramatsu } 2238b498ce1fSMasami Hiramatsu 22390e60836bSSrikar Dronamraju static int write_probe_trace_event(int fd, struct probe_trace_event *tev) 224050656eecSMasami Hiramatsu { 22416eca8cc3SFrederic Weisbecker int ret = 0; 22420e60836bSSrikar Dronamraju char *buf = synthesize_probe_trace_command(tev); 22435f03cba4SMasami Hiramatsu char sbuf[STRERR_BUFSIZE]; 224450656eecSMasami Hiramatsu 2245146a1439SMasami Hiramatsu if (!buf) { 22460e60836bSSrikar Dronamraju pr_debug("Failed to synthesize probe trace event.\n"); 2247146a1439SMasami Hiramatsu return -EINVAL; 2248146a1439SMasami Hiramatsu } 2249146a1439SMasami Hiramatsu 2250fa28244dSMasami Hiramatsu pr_debug("Writing event: %s\n", buf); 2251f4d7da49SMasami Hiramatsu if (!probe_event_dry_run) { 225250656eecSMasami Hiramatsu ret = write(fd, buf, strlen(buf)); 22537949ba1fSNamhyung Kim if (ret <= 0) { 22547949ba1fSNamhyung Kim ret = -errno; 2255146a1439SMasami Hiramatsu pr_warning("Failed to write event: %s\n", 22565f03cba4SMasami Hiramatsu strerror_r(errno, sbuf, sizeof(sbuf))); 225750656eecSMasami Hiramatsu } 22587949ba1fSNamhyung Kim } 22594235b045SMasami Hiramatsu free(buf); 2260146a1439SMasami Hiramatsu return ret; 2261f4d7da49SMasami Hiramatsu } 226250656eecSMasami Hiramatsu 2263146a1439SMasami Hiramatsu static int get_new_event_name(char *buf, size_t len, const char *base, 2264d761b08bSMasami Hiramatsu struct strlist *namelist, bool allow_suffix) 2265b498ce1fSMasami Hiramatsu { 2266b498ce1fSMasami Hiramatsu int i, ret; 226717f88fcdSMasami Hiramatsu 226817f88fcdSMasami Hiramatsu /* Try no suffix */ 226917f88fcdSMasami Hiramatsu ret = e_snprintf(buf, len, "%s", base); 2270146a1439SMasami Hiramatsu if (ret < 0) { 22715f03cba4SMasami Hiramatsu pr_debug("snprintf() failed: %d\n", ret); 2272146a1439SMasami Hiramatsu return ret; 2273146a1439SMasami Hiramatsu } 227417f88fcdSMasami Hiramatsu if (!strlist__has_entry(namelist, buf)) 2275146a1439SMasami Hiramatsu return 0; 227617f88fcdSMasami Hiramatsu 2277d761b08bSMasami Hiramatsu if (!allow_suffix) { 2278d761b08bSMasami Hiramatsu pr_warning("Error: event \"%s\" already exists. " 2279d761b08bSMasami Hiramatsu "(Use -f to force duplicates.)\n", base); 2280146a1439SMasami Hiramatsu return -EEXIST; 2281d761b08bSMasami Hiramatsu } 2282d761b08bSMasami Hiramatsu 228317f88fcdSMasami Hiramatsu /* Try to add suffix */ 228417f88fcdSMasami Hiramatsu for (i = 1; i < MAX_EVENT_INDEX; i++) { 2285b498ce1fSMasami Hiramatsu ret = e_snprintf(buf, len, "%s_%d", base, i); 2286146a1439SMasami Hiramatsu if (ret < 0) { 22875f03cba4SMasami Hiramatsu pr_debug("snprintf() failed: %d\n", ret); 2288146a1439SMasami Hiramatsu return ret; 2289146a1439SMasami Hiramatsu } 2290b498ce1fSMasami Hiramatsu if (!strlist__has_entry(namelist, buf)) 2291b498ce1fSMasami Hiramatsu break; 2292b498ce1fSMasami Hiramatsu } 2293146a1439SMasami Hiramatsu if (i == MAX_EVENT_INDEX) { 2294146a1439SMasami Hiramatsu pr_warning("Too many events are on the same function.\n"); 2295146a1439SMasami Hiramatsu ret = -ERANGE; 2296b498ce1fSMasami Hiramatsu } 2297b498ce1fSMasami Hiramatsu 2298146a1439SMasami Hiramatsu return ret; 2299146a1439SMasami Hiramatsu } 2300146a1439SMasami Hiramatsu 230179702f61SMasami Hiramatsu /* Warn if the current kernel's uprobe implementation is old */ 230279702f61SMasami Hiramatsu static void warn_uprobe_event_compat(struct probe_trace_event *tev) 230379702f61SMasami Hiramatsu { 230479702f61SMasami Hiramatsu int i; 230579702f61SMasami Hiramatsu char *buf = synthesize_probe_trace_command(tev); 230679702f61SMasami Hiramatsu 230779702f61SMasami Hiramatsu /* Old uprobe event doesn't support memory dereference */ 230879702f61SMasami Hiramatsu if (!tev->uprobes || tev->nargs == 0 || !buf) 230979702f61SMasami Hiramatsu goto out; 231079702f61SMasami Hiramatsu 231179702f61SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) 231279702f61SMasami Hiramatsu if (strglobmatch(tev->args[i].value, "[$@+-]*")) { 231379702f61SMasami Hiramatsu pr_warning("Please upgrade your kernel to at least " 231479702f61SMasami Hiramatsu "3.14 to have access to feature %s\n", 231579702f61SMasami Hiramatsu tev->args[i].value); 231679702f61SMasami Hiramatsu break; 231779702f61SMasami Hiramatsu } 231879702f61SMasami Hiramatsu out: 231979702f61SMasami Hiramatsu free(buf); 232079702f61SMasami Hiramatsu } 232179702f61SMasami Hiramatsu 23220e60836bSSrikar Dronamraju static int __add_probe_trace_events(struct perf_probe_event *pev, 23230e60836bSSrikar Dronamraju struct probe_trace_event *tevs, 23244235b045SMasami Hiramatsu int ntevs, bool allow_suffix) 232550656eecSMasami Hiramatsu { 2326146a1439SMasami Hiramatsu int i, fd, ret; 23270e60836bSSrikar Dronamraju struct probe_trace_event *tev = NULL; 23284235b045SMasami Hiramatsu char buf[64]; 23294235b045SMasami Hiramatsu const char *event, *group; 2330b498ce1fSMasami Hiramatsu struct strlist *namelist; 23319aaf5a5fSMasami Hiramatsu LIST_HEAD(blacklist); 23329aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 233350656eecSMasami Hiramatsu 2334225466f1SSrikar Dronamraju if (pev->uprobes) 2335225466f1SSrikar Dronamraju fd = open_uprobe_events(true); 2336225466f1SSrikar Dronamraju else 2337f4d7da49SMasami Hiramatsu fd = open_kprobe_events(true); 2338225466f1SSrikar Dronamraju 23395e45187cSMasami Hiramatsu if (fd < 0) { 23405e45187cSMasami Hiramatsu print_open_warning(fd, !pev->uprobes); 2341146a1439SMasami Hiramatsu return fd; 23425e45187cSMasami Hiramatsu } 23435e45187cSMasami Hiramatsu 2344b498ce1fSMasami Hiramatsu /* Get current event names */ 23450e60836bSSrikar Dronamraju namelist = get_probe_trace_event_names(fd, false); 2346146a1439SMasami Hiramatsu if (!namelist) { 2347146a1439SMasami Hiramatsu pr_debug("Failed to get current event list.\n"); 2348146a1439SMasami Hiramatsu return -EIO; 2349146a1439SMasami Hiramatsu } 23509aaf5a5fSMasami Hiramatsu /* Get kprobe blacklist if exists */ 23519aaf5a5fSMasami Hiramatsu if (!pev->uprobes) { 23529aaf5a5fSMasami Hiramatsu ret = kprobe_blacklist__load(&blacklist); 23539aaf5a5fSMasami Hiramatsu if (ret < 0) 23549aaf5a5fSMasami Hiramatsu pr_debug("No kprobe blacklist support, ignored\n"); 23559aaf5a5fSMasami Hiramatsu } 235650656eecSMasami Hiramatsu 2357146a1439SMasami Hiramatsu ret = 0; 23585e17b28fSMasami Hiramatsu pr_info("Added new event%s\n", (ntevs > 1) ? "s:" : ":"); 235902b95dadSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 23604235b045SMasami Hiramatsu tev = &tevs[i]; 23619aaf5a5fSMasami Hiramatsu /* Ensure that the address is NOT blacklisted */ 23629aaf5a5fSMasami Hiramatsu node = kprobe_blacklist__find_by_address(&blacklist, 23639aaf5a5fSMasami Hiramatsu tev->point.address); 23649aaf5a5fSMasami Hiramatsu if (node) { 23659aaf5a5fSMasami Hiramatsu pr_warning("Warning: Skipped probing on blacklisted function: %s\n", node->symbol); 23669aaf5a5fSMasami Hiramatsu continue; 23679aaf5a5fSMasami Hiramatsu } 23689aaf5a5fSMasami Hiramatsu 23694235b045SMasami Hiramatsu if (pev->event) 23704235b045SMasami Hiramatsu event = pev->event; 23714235b045SMasami Hiramatsu else 23724235b045SMasami Hiramatsu if (pev->point.function) 23734235b045SMasami Hiramatsu event = pev->point.function; 23744235b045SMasami Hiramatsu else 23754235b045SMasami Hiramatsu event = tev->point.symbol; 23764235b045SMasami Hiramatsu if (pev->group) 23774235b045SMasami Hiramatsu group = pev->group; 23784235b045SMasami Hiramatsu else 23794235b045SMasami Hiramatsu group = PERFPROBE_GROUP; 23804235b045SMasami Hiramatsu 2381b498ce1fSMasami Hiramatsu /* Get an unused new event name */ 2382146a1439SMasami Hiramatsu ret = get_new_event_name(buf, 64, event, 2383146a1439SMasami Hiramatsu namelist, allow_suffix); 2384146a1439SMasami Hiramatsu if (ret < 0) 2385146a1439SMasami Hiramatsu break; 23864235b045SMasami Hiramatsu event = buf; 23874235b045SMasami Hiramatsu 238802b95dadSMasami Hiramatsu tev->event = strdup(event); 238902b95dadSMasami Hiramatsu tev->group = strdup(group); 239002b95dadSMasami Hiramatsu if (tev->event == NULL || tev->group == NULL) { 239102b95dadSMasami Hiramatsu ret = -ENOMEM; 239202b95dadSMasami Hiramatsu break; 239302b95dadSMasami Hiramatsu } 23940e60836bSSrikar Dronamraju ret = write_probe_trace_event(fd, tev); 2395146a1439SMasami Hiramatsu if (ret < 0) 2396146a1439SMasami Hiramatsu break; 2397b498ce1fSMasami Hiramatsu /* Add added event name to namelist */ 2398b498ce1fSMasami Hiramatsu strlist__add(namelist, event); 23994235b045SMasami Hiramatsu 24004235b045SMasami Hiramatsu /* Trick here - save current event/group */ 24014235b045SMasami Hiramatsu event = pev->event; 24024235b045SMasami Hiramatsu group = pev->group; 24034235b045SMasami Hiramatsu pev->event = tev->event; 24044235b045SMasami Hiramatsu pev->group = tev->group; 2405fb226ccdSMasami Hiramatsu show_perf_probe_event(pev, tev->point.module); 24064235b045SMasami Hiramatsu /* Trick here - restore current event/group */ 24074235b045SMasami Hiramatsu pev->event = (char *)event; 24084235b045SMasami Hiramatsu pev->group = (char *)group; 24094235b045SMasami Hiramatsu 2410d761b08bSMasami Hiramatsu /* 2411d761b08bSMasami Hiramatsu * Probes after the first probe which comes from same 2412d761b08bSMasami Hiramatsu * user input are always allowed to add suffix, because 2413d761b08bSMasami Hiramatsu * there might be several addresses corresponding to 2414d761b08bSMasami Hiramatsu * one code line. 2415d761b08bSMasami Hiramatsu */ 2416d761b08bSMasami Hiramatsu allow_suffix = true; 241750656eecSMasami Hiramatsu } 241879702f61SMasami Hiramatsu if (ret == -EINVAL && pev->uprobes) 241979702f61SMasami Hiramatsu warn_uprobe_event_compat(tev); 2420146a1439SMasami Hiramatsu 24219aaf5a5fSMasami Hiramatsu /* Note that it is possible to skip all events because of blacklist */ 24229aaf5a5fSMasami Hiramatsu if (ret >= 0 && tev->event) { 2423a9b495b0SMasami Hiramatsu /* Show how to use the event. */ 24245e17b28fSMasami Hiramatsu pr_info("\nYou can now use it in all perf tools, such as:\n\n"); 24255e17b28fSMasami Hiramatsu pr_info("\tperf record -e %s:%s -aR sleep 1\n\n", tev->group, 2426146a1439SMasami Hiramatsu tev->event); 2427146a1439SMasami Hiramatsu } 2428a9b495b0SMasami Hiramatsu 24299aaf5a5fSMasami Hiramatsu kprobe_blacklist__delete(&blacklist); 2430e1d2017bSMasami Hiramatsu strlist__delete(namelist); 243150656eecSMasami Hiramatsu close(fd); 2432146a1439SMasami Hiramatsu return ret; 243350656eecSMasami Hiramatsu } 2434fa28244dSMasami Hiramatsu 2435564c62a4SNamhyung Kim static int find_probe_functions(struct map *map, char *name) 2436eb948e50SMasami Hiramatsu { 2437564c62a4SNamhyung Kim int found = 0; 24380a3873a8SArnaldo Carvalho de Melo struct symbol *sym; 2439564c62a4SNamhyung Kim 24400a3873a8SArnaldo Carvalho de Melo map__for_each_symbol_by_name(map, name, sym) { 2441564c62a4SNamhyung Kim found++; 2442eb948e50SMasami Hiramatsu } 2443564c62a4SNamhyung Kim 2444564c62a4SNamhyung Kim return found; 2445eb948e50SMasami Hiramatsu } 2446eb948e50SMasami Hiramatsu 2447eb948e50SMasami Hiramatsu #define strdup_or_goto(str, label) \ 2448eb948e50SMasami Hiramatsu ({ char *__p = strdup(str); if (!__p) goto label; __p; }) 2449eb948e50SMasami Hiramatsu 2450eb948e50SMasami Hiramatsu /* 2451eb948e50SMasami Hiramatsu * Find probe function addresses from map. 2452eb948e50SMasami Hiramatsu * Return an error or the number of found probe_trace_event 2453eb948e50SMasami Hiramatsu */ 2454eb948e50SMasami Hiramatsu static int find_probe_trace_events_from_map(struct perf_probe_event *pev, 2455eb948e50SMasami Hiramatsu struct probe_trace_event **tevs, 2456eb948e50SMasami Hiramatsu int max_tevs, const char *target) 2457eb948e50SMasami Hiramatsu { 2458eb948e50SMasami Hiramatsu struct map *map = NULL; 2459eb948e50SMasami Hiramatsu struct ref_reloc_sym *reloc_sym = NULL; 2460eb948e50SMasami Hiramatsu struct symbol *sym; 2461eb948e50SMasami Hiramatsu struct probe_trace_event *tev; 2462eb948e50SMasami Hiramatsu struct perf_probe_point *pp = &pev->point; 2463eb948e50SMasami Hiramatsu struct probe_trace_point *tp; 2464564c62a4SNamhyung Kim int num_matched_functions; 2465eb948e50SMasami Hiramatsu int ret, i; 2466eb948e50SMasami Hiramatsu 24679b118acaSMasami Hiramatsu map = get_target_map(target, pev->uprobes); 2468eb948e50SMasami Hiramatsu if (!map) { 2469eb948e50SMasami Hiramatsu ret = -EINVAL; 2470eb948e50SMasami Hiramatsu goto out; 2471eb948e50SMasami Hiramatsu } 2472eb948e50SMasami Hiramatsu 2473eb948e50SMasami Hiramatsu /* 2474eb948e50SMasami Hiramatsu * Load matched symbols: Since the different local symbols may have 2475eb948e50SMasami Hiramatsu * same name but different addresses, this lists all the symbols. 2476eb948e50SMasami Hiramatsu */ 2477564c62a4SNamhyung Kim num_matched_functions = find_probe_functions(map, pp->function); 2478564c62a4SNamhyung Kim if (num_matched_functions == 0) { 2479eb948e50SMasami Hiramatsu pr_err("Failed to find symbol %s in %s\n", pp->function, 2480eb948e50SMasami Hiramatsu target ? : "kernel"); 2481eb948e50SMasami Hiramatsu ret = -ENOENT; 2482eb948e50SMasami Hiramatsu goto out; 2483eb948e50SMasami Hiramatsu } else if (num_matched_functions > max_tevs) { 2484eb948e50SMasami Hiramatsu pr_err("Too many functions matched in %s\n", 2485eb948e50SMasami Hiramatsu target ? : "kernel"); 2486eb948e50SMasami Hiramatsu ret = -E2BIG; 2487eb948e50SMasami Hiramatsu goto out; 2488eb948e50SMasami Hiramatsu } 2489eb948e50SMasami Hiramatsu 249025dd9171SNamhyung Kim if (!pev->uprobes && !pp->retprobe) { 24910560a0c4SHe Kuang reloc_sym = kernel_get_ref_reloc_sym(); 2492eb948e50SMasami Hiramatsu if (!reloc_sym) { 2493eb948e50SMasami Hiramatsu pr_warning("Relocated base symbol is not found!\n"); 2494eb948e50SMasami Hiramatsu ret = -EINVAL; 2495eb948e50SMasami Hiramatsu goto out; 2496eb948e50SMasami Hiramatsu } 2497eb948e50SMasami Hiramatsu } 2498eb948e50SMasami Hiramatsu 2499eb948e50SMasami Hiramatsu /* Setup result trace-probe-events */ 2500eb948e50SMasami Hiramatsu *tevs = zalloc(sizeof(*tev) * num_matched_functions); 2501eb948e50SMasami Hiramatsu if (!*tevs) { 2502eb948e50SMasami Hiramatsu ret = -ENOMEM; 2503eb948e50SMasami Hiramatsu goto out; 2504eb948e50SMasami Hiramatsu } 2505eb948e50SMasami Hiramatsu 2506eb948e50SMasami Hiramatsu ret = 0; 2507564c62a4SNamhyung Kim 25080a3873a8SArnaldo Carvalho de Melo map__for_each_symbol_by_name(map, pp->function, sym) { 2509eb948e50SMasami Hiramatsu tev = (*tevs) + ret; 2510eb948e50SMasami Hiramatsu tp = &tev->point; 2511eb948e50SMasami Hiramatsu if (ret == num_matched_functions) { 2512eb948e50SMasami Hiramatsu pr_warning("Too many symbols are listed. Skip it.\n"); 2513eb948e50SMasami Hiramatsu break; 2514eb948e50SMasami Hiramatsu } 2515eb948e50SMasami Hiramatsu ret++; 2516eb948e50SMasami Hiramatsu 2517eb948e50SMasami Hiramatsu if (pp->offset > sym->end - sym->start) { 2518eb948e50SMasami Hiramatsu pr_warning("Offset %ld is bigger than the size of %s\n", 2519eb948e50SMasami Hiramatsu pp->offset, sym->name); 2520eb948e50SMasami Hiramatsu ret = -ENOENT; 2521eb948e50SMasami Hiramatsu goto err_out; 2522eb948e50SMasami Hiramatsu } 2523eb948e50SMasami Hiramatsu /* Add one probe point */ 2524eb948e50SMasami Hiramatsu tp->address = map->unmap_ip(map, sym->start) + pp->offset; 2525eb948e50SMasami Hiramatsu if (reloc_sym) { 2526eb948e50SMasami Hiramatsu tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out); 2527eb948e50SMasami Hiramatsu tp->offset = tp->address - reloc_sym->addr; 2528eb948e50SMasami Hiramatsu } else { 2529eb948e50SMasami Hiramatsu tp->symbol = strdup_or_goto(sym->name, nomem_out); 2530eb948e50SMasami Hiramatsu tp->offset = pp->offset; 2531eb948e50SMasami Hiramatsu } 2532eb948e50SMasami Hiramatsu tp->retprobe = pp->retprobe; 2533eb948e50SMasami Hiramatsu if (target) 2534eb948e50SMasami Hiramatsu tev->point.module = strdup_or_goto(target, nomem_out); 2535eb948e50SMasami Hiramatsu tev->uprobes = pev->uprobes; 2536eb948e50SMasami Hiramatsu tev->nargs = pev->nargs; 2537eb948e50SMasami Hiramatsu if (tev->nargs) { 2538eb948e50SMasami Hiramatsu tev->args = zalloc(sizeof(struct probe_trace_arg) * 2539eb948e50SMasami Hiramatsu tev->nargs); 2540eb948e50SMasami Hiramatsu if (tev->args == NULL) 2541eb948e50SMasami Hiramatsu goto nomem_out; 2542eb948e50SMasami Hiramatsu } 2543eb948e50SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 2544eb948e50SMasami Hiramatsu if (pev->args[i].name) 2545eb948e50SMasami Hiramatsu tev->args[i].name = 2546eb948e50SMasami Hiramatsu strdup_or_goto(pev->args[i].name, 2547eb948e50SMasami Hiramatsu nomem_out); 2548eb948e50SMasami Hiramatsu 2549eb948e50SMasami Hiramatsu tev->args[i].value = strdup_or_goto(pev->args[i].var, 2550eb948e50SMasami Hiramatsu nomem_out); 2551eb948e50SMasami Hiramatsu if (pev->args[i].type) 2552eb948e50SMasami Hiramatsu tev->args[i].type = 2553eb948e50SMasami Hiramatsu strdup_or_goto(pev->args[i].type, 2554eb948e50SMasami Hiramatsu nomem_out); 2555eb948e50SMasami Hiramatsu } 2556eb948e50SMasami Hiramatsu } 2557eb948e50SMasami Hiramatsu 2558eb948e50SMasami Hiramatsu out: 25599b118acaSMasami Hiramatsu put_target_map(map, pev->uprobes); 2560eb948e50SMasami Hiramatsu return ret; 2561eb948e50SMasami Hiramatsu 2562eb948e50SMasami Hiramatsu nomem_out: 2563eb948e50SMasami Hiramatsu ret = -ENOMEM; 2564eb948e50SMasami Hiramatsu err_out: 2565eb948e50SMasami Hiramatsu clear_probe_trace_events(*tevs, num_matched_functions); 2566eb948e50SMasami Hiramatsu zfree(tevs); 2567eb948e50SMasami Hiramatsu goto out; 2568eb948e50SMasami Hiramatsu } 2569eb948e50SMasami Hiramatsu 2570*d5c2e2c1SNaveen N. Rao bool __weak arch__prefers_symtab(void) { return false; } 2571*d5c2e2c1SNaveen N. Rao 25720e60836bSSrikar Dronamraju static int convert_to_probe_trace_events(struct perf_probe_event *pev, 25730e60836bSSrikar Dronamraju struct probe_trace_event **tevs, 25744eced234SSrikar Dronamraju int max_tevs, const char *target) 2575e0faa8d3SMasami Hiramatsu { 2576eb948e50SMasami Hiramatsu int ret; 25774235b045SMasami Hiramatsu 2578fb7345bbSMasami Hiramatsu if (pev->uprobes && !pev->group) { 2579fb7345bbSMasami Hiramatsu /* Replace group name if not given */ 2580fb7345bbSMasami Hiramatsu ret = convert_exec_to_group(target, &pev->group); 2581fb7345bbSMasami Hiramatsu if (ret != 0) { 2582fb7345bbSMasami Hiramatsu pr_warning("Failed to make a group name.\n"); 2583fb7345bbSMasami Hiramatsu return ret; 2584fb7345bbSMasami Hiramatsu } 2585fb7345bbSMasami Hiramatsu } 2586fb7345bbSMasami Hiramatsu 2587*d5c2e2c1SNaveen N. Rao if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) { 2588*d5c2e2c1SNaveen N. Rao ret = find_probe_trace_events_from_map(pev, tevs, max_tevs, target); 2589*d5c2e2c1SNaveen N. Rao if (ret > 0) 2590*d5c2e2c1SNaveen N. Rao return ret; /* Found in symbol table */ 2591*d5c2e2c1SNaveen N. Rao } 2592*d5c2e2c1SNaveen N. Rao 25934b4da7f7SMasami Hiramatsu /* Convert perf_probe_event with debuginfo */ 25944eced234SSrikar Dronamraju ret = try_to_find_probe_trace_events(pev, tevs, max_tevs, target); 2595e334016fSMasami Hiramatsu if (ret != 0) 2596190b57fcSMasami Hiramatsu return ret; /* Found in debuginfo or got an error */ 2597e0faa8d3SMasami Hiramatsu 2598eb948e50SMasami Hiramatsu return find_probe_trace_events_from_map(pev, tevs, max_tevs, target); 25994235b045SMasami Hiramatsu } 26004235b045SMasami Hiramatsu 26014235b045SMasami Hiramatsu struct __event_package { 26024235b045SMasami Hiramatsu struct perf_probe_event *pev; 26030e60836bSSrikar Dronamraju struct probe_trace_event *tevs; 26044235b045SMasami Hiramatsu int ntevs; 26054235b045SMasami Hiramatsu }; 26064235b045SMasami Hiramatsu 2607146a1439SMasami Hiramatsu int add_perf_probe_events(struct perf_probe_event *pevs, int npevs, 26087afb3fabSMasami Hiramatsu int max_tevs, bool force_add) 26094235b045SMasami Hiramatsu { 2610146a1439SMasami Hiramatsu int i, j, ret; 26114235b045SMasami Hiramatsu struct __event_package *pkgs; 26124235b045SMasami Hiramatsu 2613225466f1SSrikar Dronamraju ret = 0; 2614e334016fSMasami Hiramatsu pkgs = zalloc(sizeof(struct __event_package) * npevs); 2615225466f1SSrikar Dronamraju 2616e334016fSMasami Hiramatsu if (pkgs == NULL) 2617e334016fSMasami Hiramatsu return -ENOMEM; 26184235b045SMasami Hiramatsu 2619ee45b6c2SMasami Hiramatsu ret = init_symbol_maps(pevs->uprobes); 2620449e5b24SMasami Hiramatsu if (ret < 0) { 2621449e5b24SMasami Hiramatsu free(pkgs); 2622146a1439SMasami Hiramatsu return ret; 2623449e5b24SMasami Hiramatsu } 26244235b045SMasami Hiramatsu 26254235b045SMasami Hiramatsu /* Loop 1: convert all events */ 26264235b045SMasami Hiramatsu for (i = 0; i < npevs; i++) { 26274235b045SMasami Hiramatsu pkgs[i].pev = &pevs[i]; 26284235b045SMasami Hiramatsu /* Convert with or without debuginfo */ 26290e60836bSSrikar Dronamraju ret = convert_to_probe_trace_events(pkgs[i].pev, 2630469b9b88SMasami Hiramatsu &pkgs[i].tevs, 2631469b9b88SMasami Hiramatsu max_tevs, 26327afb3fabSMasami Hiramatsu pkgs[i].pev->target); 2633146a1439SMasami Hiramatsu if (ret < 0) 2634146a1439SMasami Hiramatsu goto end; 2635146a1439SMasami Hiramatsu pkgs[i].ntevs = ret; 26364235b045SMasami Hiramatsu } 26374235b045SMasami Hiramatsu 26384235b045SMasami Hiramatsu /* Loop 2: add all events */ 26398635bf6eSArnaldo Carvalho de Melo for (i = 0; i < npevs; i++) { 26400e60836bSSrikar Dronamraju ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs, 26414235b045SMasami Hiramatsu pkgs[i].ntevs, force_add); 2642fbee632dSArnaldo Carvalho de Melo if (ret < 0) 2643fbee632dSArnaldo Carvalho de Melo break; 2644fbee632dSArnaldo Carvalho de Melo } 2645146a1439SMasami Hiramatsu end: 2646449e5b24SMasami Hiramatsu /* Loop 3: cleanup and free trace events */ 2647449e5b24SMasami Hiramatsu for (i = 0; i < npevs; i++) { 2648146a1439SMasami Hiramatsu for (j = 0; j < pkgs[i].ntevs; j++) 26490e60836bSSrikar Dronamraju clear_probe_trace_event(&pkgs[i].tevs[j]); 265074cf249dSArnaldo Carvalho de Melo zfree(&pkgs[i].tevs); 2651449e5b24SMasami Hiramatsu } 2652449e5b24SMasami Hiramatsu free(pkgs); 2653ee45b6c2SMasami Hiramatsu exit_symbol_maps(); 2654146a1439SMasami Hiramatsu 2655146a1439SMasami Hiramatsu return ret; 2656e0faa8d3SMasami Hiramatsu } 2657e0faa8d3SMasami Hiramatsu 26580e60836bSSrikar Dronamraju static int __del_trace_probe_event(int fd, struct str_node *ent) 2659bbbb521bSMasami Hiramatsu { 2660bbbb521bSMasami Hiramatsu char *p; 2661bbbb521bSMasami Hiramatsu char buf[128]; 26624235b045SMasami Hiramatsu int ret; 2663bbbb521bSMasami Hiramatsu 26640e60836bSSrikar Dronamraju /* Convert from perf-probe event to trace-probe event */ 2665146a1439SMasami Hiramatsu ret = e_snprintf(buf, 128, "-:%s", ent->s); 2666146a1439SMasami Hiramatsu if (ret < 0) 2667146a1439SMasami Hiramatsu goto error; 2668146a1439SMasami Hiramatsu 2669bbbb521bSMasami Hiramatsu p = strchr(buf + 2, ':'); 2670146a1439SMasami Hiramatsu if (!p) { 2671146a1439SMasami Hiramatsu pr_debug("Internal error: %s should have ':' but not.\n", 2672146a1439SMasami Hiramatsu ent->s); 2673146a1439SMasami Hiramatsu ret = -ENOTSUP; 2674146a1439SMasami Hiramatsu goto error; 2675146a1439SMasami Hiramatsu } 2676bbbb521bSMasami Hiramatsu *p = '/'; 2677bbbb521bSMasami Hiramatsu 26784235b045SMasami Hiramatsu pr_debug("Writing event: %s\n", buf); 26794235b045SMasami Hiramatsu ret = write(fd, buf, strlen(buf)); 268044a56040SMasami Hiramatsu if (ret < 0) { 268144a56040SMasami Hiramatsu ret = -errno; 2682146a1439SMasami Hiramatsu goto error; 268344a56040SMasami Hiramatsu } 2684146a1439SMasami Hiramatsu 26855e17b28fSMasami Hiramatsu pr_info("Removed event: %s\n", ent->s); 2686146a1439SMasami Hiramatsu return 0; 2687146a1439SMasami Hiramatsu error: 26885f03cba4SMasami Hiramatsu pr_warning("Failed to delete event: %s\n", 26895f03cba4SMasami Hiramatsu strerror_r(-ret, buf, sizeof(buf))); 2690146a1439SMasami Hiramatsu return ret; 2691bbbb521bSMasami Hiramatsu } 2692bbbb521bSMasami Hiramatsu 2693225466f1SSrikar Dronamraju static int del_trace_probe_event(int fd, const char *buf, 2694225466f1SSrikar Dronamraju struct strlist *namelist) 2695fa28244dSMasami Hiramatsu { 2696bbbb521bSMasami Hiramatsu struct str_node *ent, *n; 26976dbe31f7SMasami Hiramatsu int ret = -ENOENT; 2698fa28244dSMasami Hiramatsu 2699bbbb521bSMasami Hiramatsu if (strpbrk(buf, "*?")) { /* Glob-exp */ 2700bbbb521bSMasami Hiramatsu strlist__for_each_safe(ent, n, namelist) 2701bbbb521bSMasami Hiramatsu if (strglobmatch(ent->s, buf)) { 27020e60836bSSrikar Dronamraju ret = __del_trace_probe_event(fd, ent); 2703146a1439SMasami Hiramatsu if (ret < 0) 2704146a1439SMasami Hiramatsu break; 27053e340590SMasami Hiramatsu strlist__remove(namelist, ent); 2706fa28244dSMasami Hiramatsu } 2707bbbb521bSMasami Hiramatsu } else { 2708bbbb521bSMasami Hiramatsu ent = strlist__find(namelist, buf); 2709bbbb521bSMasami Hiramatsu if (ent) { 27100e60836bSSrikar Dronamraju ret = __del_trace_probe_event(fd, ent); 2711146a1439SMasami Hiramatsu if (ret >= 0) 2712bbbb521bSMasami Hiramatsu strlist__remove(namelist, ent); 2713bbbb521bSMasami Hiramatsu } 2714bbbb521bSMasami Hiramatsu } 2715146a1439SMasami Hiramatsu 2716146a1439SMasami Hiramatsu return ret; 2717bbbb521bSMasami Hiramatsu } 2718fa28244dSMasami Hiramatsu 2719146a1439SMasami Hiramatsu int del_perf_probe_events(struct strlist *dellist) 2720fa28244dSMasami Hiramatsu { 27216dbe31f7SMasami Hiramatsu int ret = -1, ret2, ufd = -1, kfd = -1; 2722225466f1SSrikar Dronamraju char buf[128]; 2723fa28244dSMasami Hiramatsu const char *group, *event; 2724fa28244dSMasami Hiramatsu char *p, *str; 2725fa28244dSMasami Hiramatsu struct str_node *ent; 2726225466f1SSrikar Dronamraju struct strlist *namelist = NULL, *unamelist = NULL; 2727146a1439SMasami Hiramatsu 2728fa28244dSMasami Hiramatsu /* Get current event names */ 2729225466f1SSrikar Dronamraju kfd = open_kprobe_events(true); 2730467ec085SMasami Hiramatsu if (kfd >= 0) 2731225466f1SSrikar Dronamraju namelist = get_probe_trace_event_names(kfd, true); 2732225466f1SSrikar Dronamraju 2733467ec085SMasami Hiramatsu ufd = open_uprobe_events(true); 2734467ec085SMasami Hiramatsu if (ufd >= 0) 2735225466f1SSrikar Dronamraju unamelist = get_probe_trace_event_names(ufd, true); 2736225466f1SSrikar Dronamraju 2737467ec085SMasami Hiramatsu if (kfd < 0 && ufd < 0) { 2738467ec085SMasami Hiramatsu print_both_open_warning(kfd, ufd); 2739467ec085SMasami Hiramatsu goto error; 2740467ec085SMasami Hiramatsu } 2741467ec085SMasami Hiramatsu 27426dbe31f7SMasami Hiramatsu if (namelist == NULL && unamelist == NULL) { 27436dbe31f7SMasami Hiramatsu ret = -ENOENT; 2744225466f1SSrikar Dronamraju goto error; 27456dbe31f7SMasami Hiramatsu } 2746fa28244dSMasami Hiramatsu 2747adf365f4SMasami Hiramatsu strlist__for_each(ent, dellist) { 274802b95dadSMasami Hiramatsu str = strdup(ent->s); 274902b95dadSMasami Hiramatsu if (str == NULL) { 275002b95dadSMasami Hiramatsu ret = -ENOMEM; 2751225466f1SSrikar Dronamraju goto error; 275202b95dadSMasami Hiramatsu } 2753bbbb521bSMasami Hiramatsu pr_debug("Parsing: %s\n", str); 2754fa28244dSMasami Hiramatsu p = strchr(str, ':'); 2755fa28244dSMasami Hiramatsu if (p) { 2756fa28244dSMasami Hiramatsu group = str; 2757fa28244dSMasami Hiramatsu *p = '\0'; 2758fa28244dSMasami Hiramatsu event = p + 1; 2759fa28244dSMasami Hiramatsu } else { 2760bbbb521bSMasami Hiramatsu group = "*"; 2761fa28244dSMasami Hiramatsu event = str; 2762fa28244dSMasami Hiramatsu } 2763225466f1SSrikar Dronamraju 2764225466f1SSrikar Dronamraju ret = e_snprintf(buf, 128, "%s:%s", group, event); 2765225466f1SSrikar Dronamraju if (ret < 0) { 2766225466f1SSrikar Dronamraju pr_err("Failed to copy event."); 2767fa28244dSMasami Hiramatsu free(str); 2768225466f1SSrikar Dronamraju goto error; 2769fa28244dSMasami Hiramatsu } 2770225466f1SSrikar Dronamraju 2771225466f1SSrikar Dronamraju pr_debug("Group: %s, Event: %s\n", group, event); 27726dbe31f7SMasami Hiramatsu free(str); 2773225466f1SSrikar Dronamraju 27746dbe31f7SMasami Hiramatsu ret = ret2 = -ENOENT; 2775225466f1SSrikar Dronamraju if (namelist) 2776225466f1SSrikar Dronamraju ret = del_trace_probe_event(kfd, buf, namelist); 2777225466f1SSrikar Dronamraju 27786dbe31f7SMasami Hiramatsu if ((ret >= 0 || ret == -ENOENT) && unamelist) 27796dbe31f7SMasami Hiramatsu ret2 = del_trace_probe_event(ufd, buf, unamelist); 2780225466f1SSrikar Dronamraju 27816dbe31f7SMasami Hiramatsu /* Since we can remove probes which already removed, don't check it */ 27826dbe31f7SMasami Hiramatsu if (ret == -ENOENT && ret2 == -ENOENT) 27836dbe31f7SMasami Hiramatsu pr_debug("Event \"%s\" does not exist.\n", buf); 27846dbe31f7SMasami Hiramatsu else if (ret < 0 || ret2 < 0) { 27856dbe31f7SMasami Hiramatsu if (ret >= 0) 27866dbe31f7SMasami Hiramatsu ret = ret2; 27876dbe31f7SMasami Hiramatsu break; 27886dbe31f7SMasami Hiramatsu } 2789225466f1SSrikar Dronamraju } 2790225466f1SSrikar Dronamraju 2791225466f1SSrikar Dronamraju error: 2792225466f1SSrikar Dronamraju if (kfd >= 0) { 2793fa28244dSMasami Hiramatsu strlist__delete(namelist); 2794225466f1SSrikar Dronamraju close(kfd); 2795225466f1SSrikar Dronamraju } 2796225466f1SSrikar Dronamraju 2797225466f1SSrikar Dronamraju if (ufd >= 0) { 2798225466f1SSrikar Dronamraju strlist__delete(unamelist); 2799225466f1SSrikar Dronamraju close(ufd); 2800225466f1SSrikar Dronamraju } 2801146a1439SMasami Hiramatsu 2802146a1439SMasami Hiramatsu return ret; 2803fa28244dSMasami Hiramatsu } 2804225466f1SSrikar Dronamraju 28053c42258cSMasami Hiramatsu /* TODO: don't use a global variable for filter ... */ 28063c42258cSMasami Hiramatsu static struct strfilter *available_func_filter; 2807fa28244dSMasami Hiramatsu 2808e80711caSMasami Hiramatsu /* 28093c42258cSMasami Hiramatsu * If a symbol corresponds to a function with global binding and 28103c42258cSMasami Hiramatsu * matches filter return 0. For all others return 1. 2811e80711caSMasami Hiramatsu */ 28121d037ca1SIrina Tirdea static int filter_available_functions(struct map *map __maybe_unused, 2813e80711caSMasami Hiramatsu struct symbol *sym) 2814e80711caSMasami Hiramatsu { 2815e578da3bSNamhyung Kim if (strfilter__compare(available_func_filter, sym->name)) 2816e80711caSMasami Hiramatsu return 0; 28173c42258cSMasami Hiramatsu return 1; 2818e80711caSMasami Hiramatsu } 2819e80711caSMasami Hiramatsu 28202df58634SMasami Hiramatsu int show_available_funcs(const char *target, struct strfilter *_filter, 28212df58634SMasami Hiramatsu bool user) 2822e80711caSMasami Hiramatsu { 28232df58634SMasami Hiramatsu struct map *map; 28242df58634SMasami Hiramatsu int ret; 28252df58634SMasami Hiramatsu 28262df58634SMasami Hiramatsu ret = init_symbol_maps(user); 28272df58634SMasami Hiramatsu if (ret < 0) 28282df58634SMasami Hiramatsu return ret; 28292df58634SMasami Hiramatsu 28302df58634SMasami Hiramatsu /* Get a symbol map */ 28312df58634SMasami Hiramatsu if (user) 28322df58634SMasami Hiramatsu map = dso__new_map(target); 28332df58634SMasami Hiramatsu else 28342df58634SMasami Hiramatsu map = kernel_get_module_map(target); 28352df58634SMasami Hiramatsu if (!map) { 28362df58634SMasami Hiramatsu pr_err("Failed to get a map for %s\n", (target) ? : "kernel"); 2837e80711caSMasami Hiramatsu return -EINVAL; 2838e80711caSMasami Hiramatsu } 28392df58634SMasami Hiramatsu 28402df58634SMasami Hiramatsu /* Load symbols with given filter */ 28412df58634SMasami Hiramatsu available_func_filter = _filter; 28422df58634SMasami Hiramatsu if (map__load(map, filter_available_functions)) { 28432df58634SMasami Hiramatsu pr_err("Failed to load symbols in %s\n", (target) ? : "kernel"); 28442df58634SMasami Hiramatsu goto end; 28452df58634SMasami Hiramatsu } 2846e80711caSMasami Hiramatsu if (!dso__sorted_by_name(map->dso, map->type)) 2847e80711caSMasami Hiramatsu dso__sort_by_name(map->dso, map->type); 2848e80711caSMasami Hiramatsu 28492df58634SMasami Hiramatsu /* Show all (filtered) symbols */ 28502df58634SMasami Hiramatsu setup_pager(); 2851e80711caSMasami Hiramatsu dso__fprintf_symbols_by_name(map->dso, map->type, stdout); 28522df58634SMasami Hiramatsu end: 28532df58634SMasami Hiramatsu if (user) { 2854225466f1SSrikar Dronamraju dso__delete(map->dso); 2855225466f1SSrikar Dronamraju map__delete(map); 2856225466f1SSrikar Dronamraju } 28572df58634SMasami Hiramatsu exit_symbol_maps(); 2858225466f1SSrikar Dronamraju 28592df58634SMasami Hiramatsu return ret; 2860225466f1SSrikar Dronamraju } 2861225466f1SSrikar Dronamraju 2862