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" 434605eab3SJiri Olsa #include <api/fs/fs.h> 441d037ca1SIrina Tirdea #include "trace-event.h" /* For __maybe_unused */ 4550656eecSMasami Hiramatsu #include "probe-event.h" 464235b045SMasami Hiramatsu #include "probe-finder.h" 4792f6c72eSMasami Hiramatsu #include "probe-file.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 */ 54ddb2f58fSMasami Hiramatsu struct probe_conf probe_conf; 55f4d7da49SMasami Hiramatsu 56146a1439SMasami Hiramatsu #define semantic_error(msg ...) pr_err("Semantic error :" msg) 5750656eecSMasami Hiramatsu 5892f6c72eSMasami Hiramatsu int e_snprintf(char *str, size_t size, const char *format, ...) 594de189feSMasami Hiramatsu { 604de189feSMasami Hiramatsu int ret; 614de189feSMasami Hiramatsu va_list ap; 624de189feSMasami Hiramatsu va_start(ap, format); 634de189feSMasami Hiramatsu ret = vsnprintf(str, size, format, ap); 644de189feSMasami Hiramatsu va_end(ap); 654de189feSMasami Hiramatsu if (ret >= (int)size) 664de189feSMasami Hiramatsu ret = -E2BIG; 674de189feSMasami Hiramatsu return ret; 684de189feSMasami Hiramatsu } 694de189feSMasami Hiramatsu 70ee45b6c2SMasami Hiramatsu static struct machine *host_machine; 71e0faa8d3SMasami Hiramatsu 72469b9b88SMasami Hiramatsu /* Initialize symbol maps and path of vmlinux/modules */ 739bae1e8cSNamhyung Kim int init_probe_symbol_maps(bool user_only) 74e0faa8d3SMasami Hiramatsu { 75146a1439SMasami Hiramatsu int ret; 76146a1439SMasami Hiramatsu 77e0faa8d3SMasami Hiramatsu symbol_conf.sort_by_name = true; 78680d926aSNamhyung Kim symbol_conf.allow_aliases = true; 790a7e6d1bSNamhyung Kim ret = symbol__init(NULL); 80146a1439SMasami Hiramatsu if (ret < 0) { 81146a1439SMasami Hiramatsu pr_debug("Failed to init symbol map.\n"); 82146a1439SMasami Hiramatsu goto out; 83146a1439SMasami Hiramatsu } 84e0faa8d3SMasami Hiramatsu 85ee45b6c2SMasami Hiramatsu if (host_machine || user_only) /* already initialized */ 86ee45b6c2SMasami Hiramatsu return 0; 87d28c6223SArnaldo Carvalho de Melo 88ee45b6c2SMasami Hiramatsu if (symbol_conf.vmlinux_name) 89ee45b6c2SMasami Hiramatsu pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name); 90ee45b6c2SMasami Hiramatsu 91ee45b6c2SMasami Hiramatsu host_machine = machine__new_host(); 92ee45b6c2SMasami Hiramatsu if (!host_machine) { 93ee45b6c2SMasami Hiramatsu pr_debug("machine__new_host() failed.\n"); 94ee45b6c2SMasami Hiramatsu symbol__exit(); 95ee45b6c2SMasami Hiramatsu ret = -1; 96469b9b88SMasami Hiramatsu } 97146a1439SMasami Hiramatsu out: 98146a1439SMasami Hiramatsu if (ret < 0) 99146a1439SMasami Hiramatsu pr_warning("Failed to init vmlinux path.\n"); 100146a1439SMasami Hiramatsu return ret; 101e0faa8d3SMasami Hiramatsu } 102e0faa8d3SMasami Hiramatsu 1039bae1e8cSNamhyung Kim void exit_probe_symbol_maps(void) 104ee45b6c2SMasami Hiramatsu { 105ee45b6c2SMasami Hiramatsu if (host_machine) { 106ee45b6c2SMasami Hiramatsu machine__delete(host_machine); 107ee45b6c2SMasami Hiramatsu host_machine = NULL; 108ee45b6c2SMasami Hiramatsu } 109ee45b6c2SMasami Hiramatsu symbol__exit(); 110ee45b6c2SMasami Hiramatsu } 111ee45b6c2SMasami Hiramatsu 112469b9b88SMasami Hiramatsu static struct symbol *__find_kernel_function_by_name(const char *name, 113469b9b88SMasami Hiramatsu struct map **mapp) 114e0faa8d3SMasami Hiramatsu { 115ee45b6c2SMasami Hiramatsu return machine__find_kernel_function_by_name(host_machine, name, mapp, 116469b9b88SMasami Hiramatsu NULL); 117e0faa8d3SMasami Hiramatsu } 118469b9b88SMasami Hiramatsu 1198f33f7deSMasami Hiramatsu static struct symbol *__find_kernel_function(u64 addr, struct map **mapp) 1208f33f7deSMasami Hiramatsu { 1218f33f7deSMasami Hiramatsu return machine__find_kernel_function(host_machine, addr, mapp, NULL); 1228f33f7deSMasami Hiramatsu } 1238f33f7deSMasami Hiramatsu 1248f33f7deSMasami Hiramatsu static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void) 1258f33f7deSMasami Hiramatsu { 1268f33f7deSMasami Hiramatsu /* kmap->ref_reloc_sym should be set if host_machine is initialized */ 1278f33f7deSMasami Hiramatsu struct kmap *kmap; 128a5e813c6SArnaldo Carvalho de Melo struct map *map = machine__kernel_map(host_machine); 1298f33f7deSMasami Hiramatsu 13077e65977SArnaldo Carvalho de Melo if (map__load(map, NULL) < 0) 1318f33f7deSMasami Hiramatsu return NULL; 1328f33f7deSMasami Hiramatsu 13377e65977SArnaldo Carvalho de Melo kmap = map__kmap(map); 134ba92732eSWang Nan if (!kmap) 135ba92732eSWang Nan return NULL; 1368f33f7deSMasami Hiramatsu return kmap->ref_reloc_sym; 1378f33f7deSMasami Hiramatsu } 1388f33f7deSMasami Hiramatsu 1399b239a12SMasami Hiramatsu static int kernel_get_symbol_address_by_name(const char *name, u64 *addr, 1409b239a12SMasami Hiramatsu bool reloc, bool reladdr) 1418f33f7deSMasami Hiramatsu { 1428f33f7deSMasami Hiramatsu struct ref_reloc_sym *reloc_sym; 1438f33f7deSMasami Hiramatsu struct symbol *sym; 1448f33f7deSMasami Hiramatsu struct map *map; 1458f33f7deSMasami Hiramatsu 1468f33f7deSMasami Hiramatsu /* ref_reloc_sym is just a label. Need a special fix*/ 1478f33f7deSMasami Hiramatsu reloc_sym = kernel_get_ref_reloc_sym(); 1488f33f7deSMasami Hiramatsu if (reloc_sym && strcmp(name, reloc_sym->name) == 0) 1499b239a12SMasami Hiramatsu *addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr; 1508f33f7deSMasami Hiramatsu else { 1518f33f7deSMasami Hiramatsu sym = __find_kernel_function_by_name(name, &map); 1529b239a12SMasami Hiramatsu if (!sym) 1539b239a12SMasami Hiramatsu return -ENOENT; 1549b239a12SMasami Hiramatsu *addr = map->unmap_ip(map, sym->start) - 1559b239a12SMasami Hiramatsu ((reloc) ? 0 : map->reloc) - 1569b239a12SMasami Hiramatsu ((reladdr) ? map->start : 0); 1578f33f7deSMasami Hiramatsu } 1588f33f7deSMasami Hiramatsu return 0; 1598f33f7deSMasami Hiramatsu } 1608f33f7deSMasami Hiramatsu 161e80711caSMasami Hiramatsu static struct map *kernel_get_module_map(const char *module) 162e80711caSMasami Hiramatsu { 163ee45b6c2SMasami Hiramatsu struct map_groups *grp = &host_machine->kmaps; 1641eee78aeSArnaldo Carvalho de Melo struct maps *maps = &grp->maps[MAP__FUNCTION]; 1654bb7123dSArnaldo Carvalho de Melo struct map *pos; 166e80711caSMasami Hiramatsu 16714a8fd7cSMasami Hiramatsu /* A file path -- this is an offline module */ 16814a8fd7cSMasami Hiramatsu if (module && strchr(module, '/')) 1699f2de315SArnaldo Carvalho de Melo return machine__findnew_module_map(host_machine, 0, module); 17014a8fd7cSMasami Hiramatsu 171e80711caSMasami Hiramatsu if (!module) 172e80711caSMasami Hiramatsu module = "kernel"; 173e80711caSMasami Hiramatsu 1744bb7123dSArnaldo Carvalho de Melo for (pos = maps__first(maps); pos; pos = map__next(pos)) { 175e80711caSMasami Hiramatsu if (strncmp(pos->dso->short_name + 1, module, 176e80711caSMasami Hiramatsu pos->dso->short_name_len - 2) == 0) { 177e80711caSMasami Hiramatsu return pos; 178e80711caSMasami Hiramatsu } 179e80711caSMasami Hiramatsu } 180e80711caSMasami Hiramatsu return NULL; 181e80711caSMasami Hiramatsu } 182e80711caSMasami Hiramatsu 1839b118acaSMasami Hiramatsu static struct map *get_target_map(const char *target, bool user) 1849b118acaSMasami Hiramatsu { 1859b118acaSMasami Hiramatsu /* Init maps of given executable or kernel */ 1869b118acaSMasami Hiramatsu if (user) 1879b118acaSMasami Hiramatsu return dso__new_map(target); 1889b118acaSMasami Hiramatsu else 1899b118acaSMasami Hiramatsu return kernel_get_module_map(target); 1909b118acaSMasami Hiramatsu } 1919b118acaSMasami Hiramatsu 1929b118acaSMasami Hiramatsu static void put_target_map(struct map *map, bool user) 1939b118acaSMasami Hiramatsu { 1949b118acaSMasami Hiramatsu if (map && user) { 1959b118acaSMasami Hiramatsu /* Only the user map needs to be released */ 19684c2cafaSArnaldo Carvalho de Melo map__put(map); 1979b118acaSMasami Hiramatsu } 1989b118acaSMasami Hiramatsu } 1999b118acaSMasami Hiramatsu 2009b118acaSMasami Hiramatsu 201fb7345bbSMasami Hiramatsu static int convert_exec_to_group(const char *exec, char **result) 202fb7345bbSMasami Hiramatsu { 203fb7345bbSMasami Hiramatsu char *ptr1, *ptr2, *exec_copy; 204fb7345bbSMasami Hiramatsu char buf[64]; 205fb7345bbSMasami Hiramatsu int ret; 206fb7345bbSMasami Hiramatsu 207fb7345bbSMasami Hiramatsu exec_copy = strdup(exec); 208fb7345bbSMasami Hiramatsu if (!exec_copy) 209fb7345bbSMasami Hiramatsu return -ENOMEM; 210fb7345bbSMasami Hiramatsu 211fb7345bbSMasami Hiramatsu ptr1 = basename(exec_copy); 212fb7345bbSMasami Hiramatsu if (!ptr1) { 213fb7345bbSMasami Hiramatsu ret = -EINVAL; 214fb7345bbSMasami Hiramatsu goto out; 215fb7345bbSMasami Hiramatsu } 216fb7345bbSMasami Hiramatsu 217fb7345bbSMasami Hiramatsu ptr2 = strpbrk(ptr1, "-._"); 218fb7345bbSMasami Hiramatsu if (ptr2) 219fb7345bbSMasami Hiramatsu *ptr2 = '\0'; 220fb7345bbSMasami Hiramatsu ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1); 221fb7345bbSMasami Hiramatsu if (ret < 0) 222fb7345bbSMasami Hiramatsu goto out; 223fb7345bbSMasami Hiramatsu 224fb7345bbSMasami Hiramatsu *result = strdup(buf); 225fb7345bbSMasami Hiramatsu ret = *result ? 0 : -ENOMEM; 226fb7345bbSMasami Hiramatsu 227fb7345bbSMasami Hiramatsu out: 228fb7345bbSMasami Hiramatsu free(exec_copy); 229fb7345bbSMasami Hiramatsu return ret; 230fb7345bbSMasami Hiramatsu } 231fb7345bbSMasami Hiramatsu 2329b118acaSMasami Hiramatsu static void clear_perf_probe_point(struct perf_probe_point *pp) 2339b118acaSMasami Hiramatsu { 2349b118acaSMasami Hiramatsu free(pp->file); 2359b118acaSMasami Hiramatsu free(pp->function); 2369b118acaSMasami Hiramatsu free(pp->lazy_line); 2379b118acaSMasami Hiramatsu } 2389b118acaSMasami Hiramatsu 239eb948e50SMasami Hiramatsu static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs) 240eb948e50SMasami Hiramatsu { 241eb948e50SMasami Hiramatsu int i; 242eb948e50SMasami Hiramatsu 243eb948e50SMasami Hiramatsu for (i = 0; i < ntevs; i++) 244eb948e50SMasami Hiramatsu clear_probe_trace_event(tevs + i); 245eb948e50SMasami Hiramatsu } 246eb948e50SMasami Hiramatsu 247b031220dSMasami Hiramatsu static bool kprobe_blacklist__listed(unsigned long address); 248b031220dSMasami Hiramatsu static bool kprobe_warn_out_range(const char *symbol, unsigned long address) 249b031220dSMasami Hiramatsu { 2509b239a12SMasami Hiramatsu u64 etext_addr = 0; 2519b239a12SMasami Hiramatsu int ret; 2527c31bb8cSHe Kuang 253b031220dSMasami Hiramatsu /* Get the address of _etext for checking non-probable text symbol */ 2549b239a12SMasami Hiramatsu ret = kernel_get_symbol_address_by_name("_etext", &etext_addr, 2559b239a12SMasami Hiramatsu false, false); 2567c31bb8cSHe Kuang 2579b239a12SMasami Hiramatsu if (ret == 0 && etext_addr < address) 258b031220dSMasami Hiramatsu pr_warning("%s is out of .text, skip it.\n", symbol); 259b031220dSMasami Hiramatsu else if (kprobe_blacklist__listed(address)) 260b031220dSMasami Hiramatsu pr_warning("%s is blacklisted function, skip it.\n", symbol); 261b031220dSMasami Hiramatsu else 262b031220dSMasami Hiramatsu return false; 263b031220dSMasami Hiramatsu 264b031220dSMasami Hiramatsu return true; 265b031220dSMasami Hiramatsu } 266b031220dSMasami Hiramatsu 267c61fb959SRavi Bangoria /* 268c61fb959SRavi Bangoria * NOTE: 269c61fb959SRavi Bangoria * '.gnu.linkonce.this_module' section of kernel module elf directly 270c61fb959SRavi Bangoria * maps to 'struct module' from linux/module.h. This section contains 271c61fb959SRavi Bangoria * actual module name which will be used by kernel after loading it. 272c61fb959SRavi Bangoria * But, we cannot use 'struct module' here since linux/module.h is not 273c61fb959SRavi Bangoria * exposed to user-space. Offset of 'name' has remained same from long 274c61fb959SRavi Bangoria * time, so hardcoding it here. 275c61fb959SRavi Bangoria */ 276c61fb959SRavi Bangoria #ifdef __LP64__ 277c61fb959SRavi Bangoria #define MOD_NAME_OFFSET 24 278c61fb959SRavi Bangoria #else 279c61fb959SRavi Bangoria #define MOD_NAME_OFFSET 12 280c61fb959SRavi Bangoria #endif 281c61fb959SRavi Bangoria 282c61fb959SRavi Bangoria /* 283c61fb959SRavi Bangoria * @module can be module name of module file path. In case of path, 284c61fb959SRavi Bangoria * inspect elf and find out what is actual module name. 285c61fb959SRavi Bangoria * Caller has to free mod_name after using it. 286c61fb959SRavi Bangoria */ 287c61fb959SRavi Bangoria static char *find_module_name(const char *module) 288c61fb959SRavi Bangoria { 289c61fb959SRavi Bangoria int fd; 290c61fb959SRavi Bangoria Elf *elf; 291c61fb959SRavi Bangoria GElf_Ehdr ehdr; 292c61fb959SRavi Bangoria GElf_Shdr shdr; 293c61fb959SRavi Bangoria Elf_Data *data; 294c61fb959SRavi Bangoria Elf_Scn *sec; 295c61fb959SRavi Bangoria char *mod_name = NULL; 296c61fb959SRavi Bangoria 297c61fb959SRavi Bangoria fd = open(module, O_RDONLY); 298c61fb959SRavi Bangoria if (fd < 0) 299c61fb959SRavi Bangoria return NULL; 300c61fb959SRavi Bangoria 301c61fb959SRavi Bangoria elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 302c61fb959SRavi Bangoria if (elf == NULL) 303c61fb959SRavi Bangoria goto elf_err; 304c61fb959SRavi Bangoria 305c61fb959SRavi Bangoria if (gelf_getehdr(elf, &ehdr) == NULL) 306c61fb959SRavi Bangoria goto ret_err; 307c61fb959SRavi Bangoria 308c61fb959SRavi Bangoria sec = elf_section_by_name(elf, &ehdr, &shdr, 309c61fb959SRavi Bangoria ".gnu.linkonce.this_module", NULL); 310c61fb959SRavi Bangoria if (!sec) 311c61fb959SRavi Bangoria goto ret_err; 312c61fb959SRavi Bangoria 313c61fb959SRavi Bangoria data = elf_getdata(sec, NULL); 314c61fb959SRavi Bangoria if (!data || !data->d_buf) 315c61fb959SRavi Bangoria goto ret_err; 316c61fb959SRavi Bangoria 317c61fb959SRavi Bangoria mod_name = strdup((char *)data->d_buf + MOD_NAME_OFFSET); 318c61fb959SRavi Bangoria 319c61fb959SRavi Bangoria ret_err: 320c61fb959SRavi Bangoria elf_end(elf); 321c61fb959SRavi Bangoria elf_err: 322c61fb959SRavi Bangoria close(fd); 323c61fb959SRavi Bangoria return mod_name; 324c61fb959SRavi Bangoria } 325c61fb959SRavi Bangoria 32689fe808aSIngo Molnar #ifdef HAVE_DWARF_SUPPORT 32760fb7742SWang Nan 32860fb7742SWang Nan static int kernel_get_module_dso(const char *module, struct dso **pdso) 32960fb7742SWang Nan { 33060fb7742SWang Nan struct dso *dso; 33160fb7742SWang Nan struct map *map; 33260fb7742SWang Nan const char *vmlinux_name; 33360fb7742SWang Nan int ret = 0; 33460fb7742SWang Nan 33560fb7742SWang Nan if (module) { 336266fa2b2SArnaldo Carvalho de Melo char module_name[128]; 337266fa2b2SArnaldo Carvalho de Melo 338266fa2b2SArnaldo Carvalho de Melo snprintf(module_name, sizeof(module_name), "[%s]", module); 339266fa2b2SArnaldo Carvalho de Melo map = map_groups__find_by_name(&host_machine->kmaps, MAP__FUNCTION, module_name); 340266fa2b2SArnaldo Carvalho de Melo if (map) { 341266fa2b2SArnaldo Carvalho de Melo dso = map->dso; 34260fb7742SWang Nan goto found; 34360fb7742SWang Nan } 34460fb7742SWang Nan pr_debug("Failed to find module %s.\n", module); 34560fb7742SWang Nan return -ENOENT; 34660fb7742SWang Nan } 34760fb7742SWang Nan 348a5e813c6SArnaldo Carvalho de Melo map = machine__kernel_map(host_machine); 34960fb7742SWang Nan dso = map->dso; 35060fb7742SWang Nan 35160fb7742SWang Nan vmlinux_name = symbol_conf.vmlinux_name; 35260fb7742SWang Nan dso->load_errno = 0; 35360fb7742SWang Nan if (vmlinux_name) 35460fb7742SWang Nan ret = dso__load_vmlinux(dso, map, vmlinux_name, false, NULL); 35560fb7742SWang Nan else 35660fb7742SWang Nan ret = dso__load_vmlinux_path(dso, map, NULL); 35760fb7742SWang Nan found: 35860fb7742SWang Nan *pdso = dso; 35960fb7742SWang Nan return ret; 36060fb7742SWang Nan } 36160fb7742SWang Nan 3629b118acaSMasami Hiramatsu /* 3639b118acaSMasami Hiramatsu * Some binaries like glibc have special symbols which are on the symbol 3649b118acaSMasami Hiramatsu * table, but not in the debuginfo. If we can find the address of the 3659b118acaSMasami Hiramatsu * symbol from map, we can translate the address back to the probe point. 3669b118acaSMasami Hiramatsu */ 3679b118acaSMasami Hiramatsu static int find_alternative_probe_point(struct debuginfo *dinfo, 3689b118acaSMasami Hiramatsu struct perf_probe_point *pp, 3699b118acaSMasami Hiramatsu struct perf_probe_point *result, 3709b118acaSMasami Hiramatsu const char *target, bool uprobes) 3719b118acaSMasami Hiramatsu { 3729b118acaSMasami Hiramatsu struct map *map = NULL; 3739b118acaSMasami Hiramatsu struct symbol *sym; 3749b118acaSMasami Hiramatsu u64 address = 0; 3759b118acaSMasami Hiramatsu int ret = -ENOENT; 3769b118acaSMasami Hiramatsu 3779b118acaSMasami Hiramatsu /* This can work only for function-name based one */ 3789b118acaSMasami Hiramatsu if (!pp->function || pp->file) 3799b118acaSMasami Hiramatsu return -ENOTSUP; 3809b118acaSMasami Hiramatsu 3819b118acaSMasami Hiramatsu map = get_target_map(target, uprobes); 3829b118acaSMasami Hiramatsu if (!map) 3839b118acaSMasami Hiramatsu return -EINVAL; 3849b118acaSMasami Hiramatsu 3859b118acaSMasami Hiramatsu /* Find the address of given function */ 3869b118acaSMasami Hiramatsu map__for_each_symbol_by_name(map, pp->function, sym) { 387e6d7c91cSMasami Hiramatsu if (uprobes) 3889b118acaSMasami Hiramatsu address = sym->start; 389e6d7c91cSMasami Hiramatsu else 390e6d7c91cSMasami Hiramatsu address = map->unmap_ip(map, sym->start); 3919b118acaSMasami Hiramatsu break; 3929b118acaSMasami Hiramatsu } 3939b118acaSMasami Hiramatsu if (!address) { 3949b118acaSMasami Hiramatsu ret = -ENOENT; 3959b118acaSMasami Hiramatsu goto out; 3969b118acaSMasami Hiramatsu } 397f6c15621SWang Nan pr_debug("Symbol %s address found : %" PRIx64 "\n", 398f6c15621SWang Nan pp->function, address); 3999b118acaSMasami Hiramatsu 4009b118acaSMasami Hiramatsu ret = debuginfo__find_probe_point(dinfo, (unsigned long)address, 4019b118acaSMasami Hiramatsu result); 4029b118acaSMasami Hiramatsu if (ret <= 0) 4039b118acaSMasami Hiramatsu ret = (!ret) ? -ENOENT : ret; 4049b118acaSMasami Hiramatsu else { 4059b118acaSMasami Hiramatsu result->offset += pp->offset; 4069b118acaSMasami Hiramatsu result->line += pp->line; 4079d7b45c5SHe Kuang result->retprobe = pp->retprobe; 4089b118acaSMasami Hiramatsu ret = 0; 4099b118acaSMasami Hiramatsu } 4109b118acaSMasami Hiramatsu 4119b118acaSMasami Hiramatsu out: 4129b118acaSMasami Hiramatsu put_target_map(map, uprobes); 4139b118acaSMasami Hiramatsu return ret; 4149b118acaSMasami Hiramatsu 4159b118acaSMasami Hiramatsu } 4169b118acaSMasami Hiramatsu 4179b118acaSMasami Hiramatsu static int get_alternative_probe_event(struct debuginfo *dinfo, 4189b118acaSMasami Hiramatsu struct perf_probe_event *pev, 41944225521SMasami Hiramatsu struct perf_probe_point *tmp) 4209b118acaSMasami Hiramatsu { 4219b118acaSMasami Hiramatsu int ret; 4229b118acaSMasami Hiramatsu 4239b118acaSMasami Hiramatsu memcpy(tmp, &pev->point, sizeof(*tmp)); 4249b118acaSMasami Hiramatsu memset(&pev->point, 0, sizeof(pev->point)); 4259b118acaSMasami Hiramatsu ret = find_alternative_probe_point(dinfo, tmp, &pev->point, 42644225521SMasami Hiramatsu pev->target, pev->uprobes); 4279b118acaSMasami Hiramatsu if (ret < 0) 4289b118acaSMasami Hiramatsu memcpy(&pev->point, tmp, sizeof(*tmp)); 4299b118acaSMasami Hiramatsu 4309b118acaSMasami Hiramatsu return ret; 4319b118acaSMasami Hiramatsu } 432a15ad2f5SMasami Hiramatsu 433811dd2aeSMasami Hiramatsu static int get_alternative_line_range(struct debuginfo *dinfo, 434811dd2aeSMasami Hiramatsu struct line_range *lr, 435811dd2aeSMasami Hiramatsu const char *target, bool user) 436811dd2aeSMasami Hiramatsu { 4376d4a4896SDavid Ahern struct perf_probe_point pp = { .function = lr->function, 4386d4a4896SDavid Ahern .file = lr->file, 4396d4a4896SDavid Ahern .line = lr->start }; 4406d4a4896SDavid Ahern struct perf_probe_point result; 441811dd2aeSMasami Hiramatsu int ret, len = 0; 442811dd2aeSMasami Hiramatsu 4436d4a4896SDavid Ahern memset(&result, 0, sizeof(result)); 4446d4a4896SDavid Ahern 445811dd2aeSMasami Hiramatsu if (lr->end != INT_MAX) 446811dd2aeSMasami Hiramatsu len = lr->end - lr->start; 447811dd2aeSMasami Hiramatsu ret = find_alternative_probe_point(dinfo, &pp, &result, 448811dd2aeSMasami Hiramatsu target, user); 449811dd2aeSMasami Hiramatsu if (!ret) { 450811dd2aeSMasami Hiramatsu lr->function = result.function; 451811dd2aeSMasami Hiramatsu lr->file = result.file; 452811dd2aeSMasami Hiramatsu lr->start = result.line; 453811dd2aeSMasami Hiramatsu if (lr->end != INT_MAX) 454811dd2aeSMasami Hiramatsu lr->end = lr->start + len; 455811dd2aeSMasami Hiramatsu clear_perf_probe_point(&pp); 456811dd2aeSMasami Hiramatsu } 457811dd2aeSMasami Hiramatsu return ret; 458811dd2aeSMasami Hiramatsu } 459811dd2aeSMasami Hiramatsu 460ff741783SMasami Hiramatsu /* Open new debuginfo of given module */ 46192561cb7SMasami Hiramatsu static struct debuginfo *open_debuginfo(const char *module, bool silent) 462469b9b88SMasami Hiramatsu { 463a15ad2f5SMasami Hiramatsu const char *path = module; 464419e8738SMasami Hiramatsu char reason[STRERR_BUFSIZE]; 465419e8738SMasami Hiramatsu struct debuginfo *ret = NULL; 466419e8738SMasami Hiramatsu struct dso *dso = NULL; 467419e8738SMasami Hiramatsu int err; 46814a8fd7cSMasami Hiramatsu 469a15ad2f5SMasami Hiramatsu if (!module || !strchr(module, '/')) { 470419e8738SMasami Hiramatsu err = kernel_get_module_dso(module, &dso); 471419e8738SMasami Hiramatsu if (err < 0) { 472419e8738SMasami Hiramatsu if (!dso || dso->load_errno == 0) { 473419e8738SMasami Hiramatsu if (!strerror_r(-err, reason, STRERR_BUFSIZE)) 474419e8738SMasami Hiramatsu strcpy(reason, "(unknown)"); 475419e8738SMasami Hiramatsu } else 476419e8738SMasami Hiramatsu dso__strerror_load(dso, reason, STRERR_BUFSIZE); 47792561cb7SMasami Hiramatsu if (!silent) 478419e8738SMasami Hiramatsu pr_err("Failed to find the path for %s: %s\n", 479419e8738SMasami Hiramatsu module ?: "kernel", reason); 480ff741783SMasami Hiramatsu return NULL; 481469b9b88SMasami Hiramatsu } 482419e8738SMasami Hiramatsu path = dso->long_name; 48314a8fd7cSMasami Hiramatsu } 48492561cb7SMasami Hiramatsu ret = debuginfo__new(path); 48592561cb7SMasami Hiramatsu if (!ret && !silent) { 48692561cb7SMasami Hiramatsu pr_warning("The %s file has no debug information.\n", path); 48792561cb7SMasami Hiramatsu if (!module || !strtailcmp(path, ".ko")) 48892561cb7SMasami Hiramatsu pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, "); 48992561cb7SMasami Hiramatsu else 49092561cb7SMasami Hiramatsu pr_warning("Rebuild with -g, "); 49192561cb7SMasami Hiramatsu pr_warning("or install an appropriate debuginfo package.\n"); 492e0faa8d3SMasami Hiramatsu } 49392561cb7SMasami Hiramatsu return ret; 49492561cb7SMasami Hiramatsu } 49592561cb7SMasami Hiramatsu 4967737af01SMasami Hiramatsu /* For caching the last debuginfo */ 4977737af01SMasami Hiramatsu static struct debuginfo *debuginfo_cache; 4987737af01SMasami Hiramatsu static char *debuginfo_cache_path; 4997737af01SMasami Hiramatsu 5007737af01SMasami Hiramatsu static struct debuginfo *debuginfo_cache__open(const char *module, bool silent) 5017737af01SMasami Hiramatsu { 50220f49859SMasami Hiramatsu const char *path = module; 50320f49859SMasami Hiramatsu 50420f49859SMasami Hiramatsu /* If the module is NULL, it should be the kernel. */ 50520f49859SMasami Hiramatsu if (!module) 50620f49859SMasami Hiramatsu path = "kernel"; 50720f49859SMasami Hiramatsu 50820f49859SMasami Hiramatsu if (debuginfo_cache_path && !strcmp(debuginfo_cache_path, path)) 5097737af01SMasami Hiramatsu goto out; 5107737af01SMasami Hiramatsu 5117737af01SMasami Hiramatsu /* Copy module path */ 5127737af01SMasami Hiramatsu free(debuginfo_cache_path); 51320f49859SMasami Hiramatsu debuginfo_cache_path = strdup(path); 5147737af01SMasami Hiramatsu if (!debuginfo_cache_path) { 5157737af01SMasami Hiramatsu debuginfo__delete(debuginfo_cache); 5167737af01SMasami Hiramatsu debuginfo_cache = NULL; 5177737af01SMasami Hiramatsu goto out; 5187737af01SMasami Hiramatsu } 5197737af01SMasami Hiramatsu 5207737af01SMasami Hiramatsu debuginfo_cache = open_debuginfo(module, silent); 5217737af01SMasami Hiramatsu if (!debuginfo_cache) 5227737af01SMasami Hiramatsu zfree(&debuginfo_cache_path); 5237737af01SMasami Hiramatsu out: 5247737af01SMasami Hiramatsu return debuginfo_cache; 5257737af01SMasami Hiramatsu } 5267737af01SMasami Hiramatsu 5277737af01SMasami Hiramatsu static void debuginfo_cache__exit(void) 5287737af01SMasami Hiramatsu { 5297737af01SMasami Hiramatsu debuginfo__delete(debuginfo_cache); 5307737af01SMasami Hiramatsu debuginfo_cache = NULL; 5317737af01SMasami Hiramatsu zfree(&debuginfo_cache_path); 5327737af01SMasami Hiramatsu } 5337737af01SMasami Hiramatsu 5344b4da7f7SMasami Hiramatsu 53599ca4233SMasami Hiramatsu static int get_text_start_address(const char *exec, unsigned long *address) 53699ca4233SMasami Hiramatsu { 53799ca4233SMasami Hiramatsu Elf *elf; 53899ca4233SMasami Hiramatsu GElf_Ehdr ehdr; 53999ca4233SMasami Hiramatsu GElf_Shdr shdr; 54099ca4233SMasami Hiramatsu int fd, ret = -ENOENT; 54199ca4233SMasami Hiramatsu 54299ca4233SMasami Hiramatsu fd = open(exec, O_RDONLY); 54399ca4233SMasami Hiramatsu if (fd < 0) 54499ca4233SMasami Hiramatsu return -errno; 54599ca4233SMasami Hiramatsu 54699ca4233SMasami Hiramatsu elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 547062d6c2aSMasami Hiramatsu if (elf == NULL) { 548062d6c2aSMasami Hiramatsu ret = -EINVAL; 549062d6c2aSMasami Hiramatsu goto out_close; 550062d6c2aSMasami Hiramatsu } 55199ca4233SMasami Hiramatsu 55299ca4233SMasami Hiramatsu if (gelf_getehdr(elf, &ehdr) == NULL) 55399ca4233SMasami Hiramatsu goto out; 55499ca4233SMasami Hiramatsu 55599ca4233SMasami Hiramatsu if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL)) 55699ca4233SMasami Hiramatsu goto out; 55799ca4233SMasami Hiramatsu 55899ca4233SMasami Hiramatsu *address = shdr.sh_addr - shdr.sh_offset; 55999ca4233SMasami Hiramatsu ret = 0; 56099ca4233SMasami Hiramatsu out: 56199ca4233SMasami Hiramatsu elf_end(elf); 562062d6c2aSMasami Hiramatsu out_close: 563062d6c2aSMasami Hiramatsu close(fd); 564062d6c2aSMasami Hiramatsu 56599ca4233SMasami Hiramatsu return ret; 56699ca4233SMasami Hiramatsu } 56799ca4233SMasami Hiramatsu 5685a6f6314SMasami Hiramatsu /* 5695a6f6314SMasami Hiramatsu * Convert trace point to probe point with debuginfo 5705a6f6314SMasami Hiramatsu */ 5715a6f6314SMasami Hiramatsu static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp, 5725a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 5735a6f6314SMasami Hiramatsu bool is_kprobe) 5745a6f6314SMasami Hiramatsu { 5755a6f6314SMasami Hiramatsu struct debuginfo *dinfo = NULL; 5765a6f6314SMasami Hiramatsu unsigned long stext = 0; 5775a6f6314SMasami Hiramatsu u64 addr = tp->address; 5785a6f6314SMasami Hiramatsu int ret = -ENOENT; 5795a6f6314SMasami Hiramatsu 5805a6f6314SMasami Hiramatsu /* convert the address to dwarf address */ 5815a6f6314SMasami Hiramatsu if (!is_kprobe) { 5825a6f6314SMasami Hiramatsu if (!addr) { 5835a6f6314SMasami Hiramatsu ret = -EINVAL; 5845a6f6314SMasami Hiramatsu goto error; 5855a6f6314SMasami Hiramatsu } 5865a6f6314SMasami Hiramatsu ret = get_text_start_address(tp->module, &stext); 5875a6f6314SMasami Hiramatsu if (ret < 0) 5885a6f6314SMasami Hiramatsu goto error; 5895a6f6314SMasami Hiramatsu addr += stext; 590e486367fSWang Nan } else if (tp->symbol) { 5919b239a12SMasami Hiramatsu /* If the module is given, this returns relative address */ 5929b239a12SMasami Hiramatsu ret = kernel_get_symbol_address_by_name(tp->symbol, &addr, 5939b239a12SMasami Hiramatsu false, !!tp->module); 5949b239a12SMasami Hiramatsu if (ret != 0) 5955a6f6314SMasami Hiramatsu goto error; 5965a6f6314SMasami Hiramatsu addr += tp->offset; 5975a6f6314SMasami Hiramatsu } 5985a6f6314SMasami Hiramatsu 5995a6f6314SMasami Hiramatsu pr_debug("try to find information at %" PRIx64 " in %s\n", addr, 6005a6f6314SMasami Hiramatsu tp->module ? : "kernel"); 6015a6f6314SMasami Hiramatsu 6027737af01SMasami Hiramatsu dinfo = debuginfo_cache__open(tp->module, verbose == 0); 6037737af01SMasami Hiramatsu if (dinfo) 6045a6f6314SMasami Hiramatsu ret = debuginfo__find_probe_point(dinfo, 6055a6f6314SMasami Hiramatsu (unsigned long)addr, pp); 6067737af01SMasami Hiramatsu else 6075a6f6314SMasami Hiramatsu ret = -ENOENT; 6085a6f6314SMasami Hiramatsu 6095a6f6314SMasami Hiramatsu if (ret > 0) { 6105a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 6115a6f6314SMasami Hiramatsu return 0; 6125a6f6314SMasami Hiramatsu } 6135a6f6314SMasami Hiramatsu error: 6145a6f6314SMasami Hiramatsu pr_debug("Failed to find corresponding probes from debuginfo.\n"); 6155a6f6314SMasami Hiramatsu return ret ? : -ENOENT; 6165a6f6314SMasami Hiramatsu } 6175a6f6314SMasami Hiramatsu 618fb7345bbSMasami Hiramatsu static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs, 619fb7345bbSMasami Hiramatsu int ntevs, const char *exec) 620fb7345bbSMasami Hiramatsu { 621fb7345bbSMasami Hiramatsu int i, ret = 0; 622eb948e50SMasami Hiramatsu unsigned long stext = 0; 623fb7345bbSMasami Hiramatsu 624fb7345bbSMasami Hiramatsu if (!exec) 625fb7345bbSMasami Hiramatsu return 0; 626fb7345bbSMasami Hiramatsu 627fb7345bbSMasami Hiramatsu ret = get_text_start_address(exec, &stext); 628fb7345bbSMasami Hiramatsu if (ret < 0) 629fb7345bbSMasami Hiramatsu return ret; 630fb7345bbSMasami Hiramatsu 631fb7345bbSMasami Hiramatsu for (i = 0; i < ntevs && ret >= 0; i++) { 632981a2379SMasami Hiramatsu /* point.address is the addres of point.symbol + point.offset */ 633eb948e50SMasami Hiramatsu tevs[i].point.address -= stext; 634fb7345bbSMasami Hiramatsu tevs[i].point.module = strdup(exec); 635eb948e50SMasami Hiramatsu if (!tevs[i].point.module) { 636fb7345bbSMasami Hiramatsu ret = -ENOMEM; 637fb7345bbSMasami Hiramatsu break; 638fb7345bbSMasami Hiramatsu } 639fb7345bbSMasami Hiramatsu tevs[i].uprobes = true; 640fb7345bbSMasami Hiramatsu } 641fb7345bbSMasami Hiramatsu 642fb7345bbSMasami Hiramatsu return ret; 643fb7345bbSMasami Hiramatsu } 644fb7345bbSMasami Hiramatsu 645190b57fcSMasami Hiramatsu static int add_module_to_probe_trace_events(struct probe_trace_event *tevs, 646190b57fcSMasami Hiramatsu int ntevs, const char *module) 647190b57fcSMasami Hiramatsu { 64814a8fd7cSMasami Hiramatsu int i, ret = 0; 64963a29613SRavi Bangoria char *mod_name = NULL; 65014a8fd7cSMasami Hiramatsu 65114a8fd7cSMasami Hiramatsu if (!module) 65214a8fd7cSMasami Hiramatsu return 0; 65314a8fd7cSMasami Hiramatsu 65463a29613SRavi Bangoria mod_name = find_module_name(module); 65514a8fd7cSMasami Hiramatsu 656190b57fcSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 65763a29613SRavi Bangoria tevs[i].point.module = 65863a29613SRavi Bangoria strdup(mod_name ? mod_name : module); 65914a8fd7cSMasami Hiramatsu if (!tevs[i].point.module) { 66014a8fd7cSMasami Hiramatsu ret = -ENOMEM; 66114a8fd7cSMasami Hiramatsu break; 662190b57fcSMasami Hiramatsu } 66314a8fd7cSMasami Hiramatsu } 66414a8fd7cSMasami Hiramatsu 66563a29613SRavi Bangoria free(mod_name); 66614a8fd7cSMasami Hiramatsu return ret; 667190b57fcSMasami Hiramatsu } 668190b57fcSMasami Hiramatsu 669dfef99cdSMasami Hiramatsu /* Post processing the probe events */ 670dfef99cdSMasami Hiramatsu static int post_process_probe_trace_events(struct probe_trace_event *tevs, 671dfef99cdSMasami Hiramatsu int ntevs, const char *module, 672dfef99cdSMasami Hiramatsu bool uprobe) 673dfef99cdSMasami Hiramatsu { 674dfef99cdSMasami Hiramatsu struct ref_reloc_sym *reloc_sym; 675dfef99cdSMasami Hiramatsu char *tmp; 6765a51fcd1SMasami Hiramatsu int i, skipped = 0; 677dfef99cdSMasami Hiramatsu 678dfef99cdSMasami Hiramatsu if (uprobe) 679dfef99cdSMasami Hiramatsu return add_exec_to_probe_trace_events(tevs, ntevs, module); 680dfef99cdSMasami Hiramatsu 681dfef99cdSMasami Hiramatsu /* Note that currently ref_reloc_sym based probe is not for drivers */ 682dfef99cdSMasami Hiramatsu if (module) 683dfef99cdSMasami Hiramatsu return add_module_to_probe_trace_events(tevs, ntevs, module); 684dfef99cdSMasami Hiramatsu 6858f33f7deSMasami Hiramatsu reloc_sym = kernel_get_ref_reloc_sym(); 686dfef99cdSMasami Hiramatsu if (!reloc_sym) { 687dfef99cdSMasami Hiramatsu pr_warning("Relocated base symbol is not found!\n"); 688dfef99cdSMasami Hiramatsu return -EINVAL; 689dfef99cdSMasami Hiramatsu } 690dfef99cdSMasami Hiramatsu 691dfef99cdSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 692b031220dSMasami Hiramatsu if (!tevs[i].point.address || tevs[i].point.retprobe) 693b031220dSMasami Hiramatsu continue; 6945a51fcd1SMasami Hiramatsu /* If we found a wrong one, mark it by NULL symbol */ 695b031220dSMasami Hiramatsu if (kprobe_warn_out_range(tevs[i].point.symbol, 696b031220dSMasami Hiramatsu tevs[i].point.address)) { 6975a51fcd1SMasami Hiramatsu tmp = NULL; 6985a51fcd1SMasami Hiramatsu skipped++; 6995a51fcd1SMasami Hiramatsu } else { 700dfef99cdSMasami Hiramatsu tmp = strdup(reloc_sym->name); 701dfef99cdSMasami Hiramatsu if (!tmp) 702dfef99cdSMasami Hiramatsu return -ENOMEM; 7035a51fcd1SMasami Hiramatsu } 7044c859351SMasami Hiramatsu /* If we have no realname, use symbol for it */ 7054c859351SMasami Hiramatsu if (!tevs[i].point.realname) 7064c859351SMasami Hiramatsu tevs[i].point.realname = tevs[i].point.symbol; 7074c859351SMasami Hiramatsu else 708dfef99cdSMasami Hiramatsu free(tevs[i].point.symbol); 709dfef99cdSMasami Hiramatsu tevs[i].point.symbol = tmp; 710dfef99cdSMasami Hiramatsu tevs[i].point.offset = tevs[i].point.address - 711dfef99cdSMasami Hiramatsu reloc_sym->unrelocated_addr; 712dfef99cdSMasami Hiramatsu } 7135a51fcd1SMasami Hiramatsu return skipped; 714dfef99cdSMasami Hiramatsu } 715dfef99cdSMasami Hiramatsu 7164b4da7f7SMasami Hiramatsu /* Try to find perf_probe_event with debuginfo */ 7170e60836bSSrikar Dronamraju static int try_to_find_probe_trace_events(struct perf_probe_event *pev, 718ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs) 7194b4da7f7SMasami Hiramatsu { 7204b4da7f7SMasami Hiramatsu bool need_dwarf = perf_probe_event_need_dwarf(pev); 7219b118acaSMasami Hiramatsu struct perf_probe_point tmp; 722225466f1SSrikar Dronamraju struct debuginfo *dinfo; 723190b57fcSMasami Hiramatsu int ntevs, ret = 0; 7244b4da7f7SMasami Hiramatsu 72544225521SMasami Hiramatsu dinfo = open_debuginfo(pev->target, !need_dwarf); 726ff741783SMasami Hiramatsu if (!dinfo) { 72792561cb7SMasami Hiramatsu if (need_dwarf) 728ff741783SMasami Hiramatsu return -ENOENT; 729ff741783SMasami Hiramatsu pr_debug("Could not open debuginfo. Try to use symbols.\n"); 7304b4da7f7SMasami Hiramatsu return 0; 7314b4da7f7SMasami Hiramatsu } 7324b4da7f7SMasami Hiramatsu 733dfef99cdSMasami Hiramatsu pr_debug("Try to find probe point from debuginfo.\n"); 734ff741783SMasami Hiramatsu /* Searching trace events corresponding to a probe event */ 735ddb2f58fSMasami Hiramatsu ntevs = debuginfo__find_trace_events(dinfo, pev, tevs); 736ff741783SMasami Hiramatsu 7379b118acaSMasami Hiramatsu if (ntevs == 0) { /* Not found, retry with an alternative */ 73844225521SMasami Hiramatsu ret = get_alternative_probe_event(dinfo, pev, &tmp); 7399b118acaSMasami Hiramatsu if (!ret) { 740ddb2f58fSMasami Hiramatsu ntevs = debuginfo__find_trace_events(dinfo, pev, tevs); 7419b118acaSMasami Hiramatsu /* 7429b118acaSMasami Hiramatsu * Write back to the original probe_event for 7439b118acaSMasami Hiramatsu * setting appropriate (user given) event name 7449b118acaSMasami Hiramatsu */ 7459b118acaSMasami Hiramatsu clear_perf_probe_point(&pev->point); 7469b118acaSMasami Hiramatsu memcpy(&pev->point, &tmp, sizeof(tmp)); 7479b118acaSMasami Hiramatsu } 7489b118acaSMasami Hiramatsu } 7499b118acaSMasami Hiramatsu 750ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 7514b4da7f7SMasami Hiramatsu 752146a1439SMasami Hiramatsu if (ntevs > 0) { /* Succeeded to find trace events */ 753dfef99cdSMasami Hiramatsu pr_debug("Found %d probe_trace_events.\n", ntevs); 754dfef99cdSMasami Hiramatsu ret = post_process_probe_trace_events(*tevs, ntevs, 75544225521SMasami Hiramatsu pev->target, pev->uprobes); 7565a51fcd1SMasami Hiramatsu if (ret < 0 || ret == ntevs) { 757981d05adSMasami Hiramatsu clear_probe_trace_events(*tevs, ntevs); 758981d05adSMasami Hiramatsu zfree(tevs); 759981d05adSMasami Hiramatsu } 7605a51fcd1SMasami Hiramatsu if (ret != ntevs) 761190b57fcSMasami Hiramatsu return ret < 0 ? ret : ntevs; 7625a51fcd1SMasami Hiramatsu ntevs = 0; 7635a51fcd1SMasami Hiramatsu /* Fall through */ 764146a1439SMasami Hiramatsu } 7654b4da7f7SMasami Hiramatsu 766146a1439SMasami Hiramatsu if (ntevs == 0) { /* No error but failed to find probe point. */ 7670687eba7SMasami Hiramatsu pr_warning("Probe point '%s' not found.\n", 7684b4da7f7SMasami Hiramatsu synthesize_perf_probe_point(&pev->point)); 769146a1439SMasami Hiramatsu return -ENOENT; 770146a1439SMasami Hiramatsu } 771146a1439SMasami Hiramatsu /* Error path : ntevs < 0 */ 77215eca306SMasami Hiramatsu pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs); 7731c0bd0e8SWang Nan if (ntevs < 0) { 7741c0bd0e8SWang Nan if (ntevs == -EBADF) 77515eca306SMasami Hiramatsu pr_warning("Warning: No dwarf info found in the vmlinux - " 77615eca306SMasami Hiramatsu "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n"); 77715eca306SMasami Hiramatsu if (!need_dwarf) { 7780e43e5d2SMasami Hiramatsu pr_debug("Trying to use symbols.\n"); 7794b4da7f7SMasami Hiramatsu return 0; 7804b4da7f7SMasami Hiramatsu } 78115eca306SMasami Hiramatsu } 78215eca306SMasami Hiramatsu return ntevs; 78315eca306SMasami Hiramatsu } 7844b4da7f7SMasami Hiramatsu 7854b4da7f7SMasami Hiramatsu #define LINEBUF_SIZE 256 7864b4da7f7SMasami Hiramatsu #define NR_ADDITIONAL_LINES 2 7874b4da7f7SMasami Hiramatsu 788fde52dbdSFranck Bui-Huu static int __show_one_line(FILE *fp, int l, bool skip, bool show_num) 7894b4da7f7SMasami Hiramatsu { 7905f03cba4SMasami Hiramatsu char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE]; 791befe3414SFranck Bui-Huu const char *color = show_num ? "" : PERF_COLOR_BLUE; 792befe3414SFranck Bui-Huu const char *prefix = NULL; 7934b4da7f7SMasami Hiramatsu 794befe3414SFranck Bui-Huu do { 7954b4da7f7SMasami Hiramatsu if (fgets(buf, LINEBUF_SIZE, fp) == NULL) 7964b4da7f7SMasami Hiramatsu goto error; 797befe3414SFranck Bui-Huu if (skip) 798befe3414SFranck Bui-Huu continue; 799befe3414SFranck Bui-Huu if (!prefix) { 800befe3414SFranck Bui-Huu prefix = show_num ? "%7d " : " "; 801befe3414SFranck Bui-Huu color_fprintf(stdout, color, prefix, l); 8024b4da7f7SMasami Hiramatsu } 803befe3414SFranck Bui-Huu color_fprintf(stdout, color, "%s", buf); 8044b4da7f7SMasami Hiramatsu 805befe3414SFranck Bui-Huu } while (strchr(buf, '\n') == NULL); 806146a1439SMasami Hiramatsu 807fde52dbdSFranck Bui-Huu return 1; 8084b4da7f7SMasami Hiramatsu error: 809fde52dbdSFranck Bui-Huu if (ferror(fp)) { 8105f03cba4SMasami Hiramatsu pr_warning("File read error: %s\n", 8115f03cba4SMasami Hiramatsu strerror_r(errno, sbuf, sizeof(sbuf))); 812146a1439SMasami Hiramatsu return -1; 8134b4da7f7SMasami Hiramatsu } 814fde52dbdSFranck Bui-Huu return 0; 815fde52dbdSFranck Bui-Huu } 816fde52dbdSFranck Bui-Huu 817fde52dbdSFranck Bui-Huu static int _show_one_line(FILE *fp, int l, bool skip, bool show_num) 818fde52dbdSFranck Bui-Huu { 819fde52dbdSFranck Bui-Huu int rv = __show_one_line(fp, l, skip, show_num); 820fde52dbdSFranck Bui-Huu if (rv == 0) { 821fde52dbdSFranck Bui-Huu pr_warning("Source file is shorter than expected.\n"); 822fde52dbdSFranck Bui-Huu rv = -1; 823fde52dbdSFranck Bui-Huu } 824fde52dbdSFranck Bui-Huu return rv; 825fde52dbdSFranck Bui-Huu } 826fde52dbdSFranck Bui-Huu 827fde52dbdSFranck Bui-Huu #define show_one_line_with_num(f,l) _show_one_line(f,l,false,true) 828fde52dbdSFranck Bui-Huu #define show_one_line(f,l) _show_one_line(f,l,false,false) 829fde52dbdSFranck Bui-Huu #define skip_one_line(f,l) _show_one_line(f,l,true,false) 830fde52dbdSFranck Bui-Huu #define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false) 8314b4da7f7SMasami Hiramatsu 8324b4da7f7SMasami Hiramatsu /* 8334b4da7f7SMasami Hiramatsu * Show line-range always requires debuginfo to find source file and 8344b4da7f7SMasami Hiramatsu * line number. 8354b4da7f7SMasami Hiramatsu */ 836811dd2aeSMasami Hiramatsu static int __show_line_range(struct line_range *lr, const char *module, 837811dd2aeSMasami Hiramatsu bool user) 8384b4da7f7SMasami Hiramatsu { 839d3b63d7aSMasami Hiramatsu int l = 1; 8405a62257aSMasami Hiramatsu struct int_node *ln; 841ff741783SMasami Hiramatsu struct debuginfo *dinfo; 8424b4da7f7SMasami Hiramatsu FILE *fp; 843ff741783SMasami Hiramatsu int ret; 8447cf0b79eSMasami Hiramatsu char *tmp; 8455f03cba4SMasami Hiramatsu char sbuf[STRERR_BUFSIZE]; 8464b4da7f7SMasami Hiramatsu 8474b4da7f7SMasami Hiramatsu /* Search a line range */ 84892561cb7SMasami Hiramatsu dinfo = open_debuginfo(module, false); 84992561cb7SMasami Hiramatsu if (!dinfo) 850ff741783SMasami Hiramatsu return -ENOENT; 851146a1439SMasami Hiramatsu 852ff741783SMasami Hiramatsu ret = debuginfo__find_line_range(dinfo, lr); 853811dd2aeSMasami Hiramatsu if (!ret) { /* Not found, retry with an alternative */ 854811dd2aeSMasami Hiramatsu ret = get_alternative_line_range(dinfo, lr, module, user); 855811dd2aeSMasami Hiramatsu if (!ret) 856811dd2aeSMasami Hiramatsu ret = debuginfo__find_line_range(dinfo, lr); 857811dd2aeSMasami Hiramatsu } 858ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 8595ee05b88SMasami Hiramatsu if (ret == 0 || ret == -ENOENT) { 860146a1439SMasami Hiramatsu pr_warning("Specified source line is not found.\n"); 861146a1439SMasami Hiramatsu return -ENOENT; 862146a1439SMasami Hiramatsu } else if (ret < 0) { 8635ee05b88SMasami Hiramatsu pr_warning("Debuginfo analysis failed.\n"); 864146a1439SMasami Hiramatsu return ret; 865146a1439SMasami Hiramatsu } 8664b4da7f7SMasami Hiramatsu 8677cf0b79eSMasami Hiramatsu /* Convert source file path */ 8687cf0b79eSMasami Hiramatsu tmp = lr->path; 8696a330a3cSMasami Hiramatsu ret = get_real_path(tmp, lr->comp_dir, &lr->path); 870a78604deSHe Kuang 871a78604deSHe Kuang /* Free old path when new path is assigned */ 872a78604deSHe Kuang if (tmp != lr->path) 873a78604deSHe Kuang free(tmp); 874a78604deSHe Kuang 8757cf0b79eSMasami Hiramatsu if (ret < 0) { 8765ee05b88SMasami Hiramatsu pr_warning("Failed to find source file path.\n"); 8777cf0b79eSMasami Hiramatsu return ret; 8787cf0b79eSMasami Hiramatsu } 8797cf0b79eSMasami Hiramatsu 8804b4da7f7SMasami Hiramatsu setup_pager(); 8814b4da7f7SMasami Hiramatsu 8824b4da7f7SMasami Hiramatsu if (lr->function) 8838737ebdeSMasami Hiramatsu fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path, 8844b4da7f7SMasami Hiramatsu lr->start - lr->offset); 8854b4da7f7SMasami Hiramatsu else 88662c15fc4SFranck Bui-Huu fprintf(stdout, "<%s:%d>\n", lr->path, lr->start); 8874b4da7f7SMasami Hiramatsu 8884b4da7f7SMasami Hiramatsu fp = fopen(lr->path, "r"); 889146a1439SMasami Hiramatsu if (fp == NULL) { 890146a1439SMasami Hiramatsu pr_warning("Failed to open %s: %s\n", lr->path, 8915f03cba4SMasami Hiramatsu strerror_r(errno, sbuf, sizeof(sbuf))); 892146a1439SMasami Hiramatsu return -errno; 893146a1439SMasami Hiramatsu } 8944b4da7f7SMasami Hiramatsu /* Skip to starting line number */ 89544b81e92SFranck Bui-Huu while (l < lr->start) { 896fde52dbdSFranck Bui-Huu ret = skip_one_line(fp, l++); 897146a1439SMasami Hiramatsu if (ret < 0) 898146a1439SMasami Hiramatsu goto end; 89944b81e92SFranck Bui-Huu } 9004b4da7f7SMasami Hiramatsu 9015a62257aSMasami Hiramatsu intlist__for_each(ln, lr->line_list) { 9025a62257aSMasami Hiramatsu for (; ln->i > l; l++) { 903fde52dbdSFranck Bui-Huu ret = show_one_line(fp, l - lr->offset); 90444b81e92SFranck Bui-Huu if (ret < 0) 90544b81e92SFranck Bui-Huu goto end; 90644b81e92SFranck Bui-Huu } 907fde52dbdSFranck Bui-Huu ret = show_one_line_with_num(fp, l++ - lr->offset); 908146a1439SMasami Hiramatsu if (ret < 0) 909146a1439SMasami Hiramatsu goto end; 9104b4da7f7SMasami Hiramatsu } 9114b4da7f7SMasami Hiramatsu 9124b4da7f7SMasami Hiramatsu if (lr->end == INT_MAX) 9134b4da7f7SMasami Hiramatsu lr->end = l + NR_ADDITIONAL_LINES; 914fde52dbdSFranck Bui-Huu while (l <= lr->end) { 915fde52dbdSFranck Bui-Huu ret = show_one_line_or_eof(fp, l++ - lr->offset); 916fde52dbdSFranck Bui-Huu if (ret <= 0) 91744b81e92SFranck Bui-Huu break; 91844b81e92SFranck Bui-Huu } 919146a1439SMasami Hiramatsu end: 9204b4da7f7SMasami Hiramatsu fclose(fp); 921146a1439SMasami Hiramatsu return ret; 9224b4da7f7SMasami Hiramatsu } 9234b4da7f7SMasami Hiramatsu 9242b394bc4SMasami Hiramatsu int show_line_range(struct line_range *lr, const char *module, bool user) 925ee45b6c2SMasami Hiramatsu { 926ee45b6c2SMasami Hiramatsu int ret; 927ee45b6c2SMasami Hiramatsu 9289bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(user); 929ee45b6c2SMasami Hiramatsu if (ret < 0) 930ee45b6c2SMasami Hiramatsu return ret; 931811dd2aeSMasami Hiramatsu ret = __show_line_range(lr, module, user); 9329bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 933ee45b6c2SMasami Hiramatsu 934ee45b6c2SMasami Hiramatsu return ret; 935ee45b6c2SMasami Hiramatsu } 936ee45b6c2SMasami Hiramatsu 937ff741783SMasami Hiramatsu static int show_available_vars_at(struct debuginfo *dinfo, 938ff741783SMasami Hiramatsu struct perf_probe_event *pev, 939ddb2f58fSMasami Hiramatsu struct strfilter *_filter) 940cf6eb489SMasami Hiramatsu { 941cf6eb489SMasami Hiramatsu char *buf; 942bd09d7b5SMasami Hiramatsu int ret, i, nvars; 943cf6eb489SMasami Hiramatsu struct str_node *node; 944cf6eb489SMasami Hiramatsu struct variable_list *vls = NULL, *vl; 9459b118acaSMasami Hiramatsu struct perf_probe_point tmp; 946bd09d7b5SMasami Hiramatsu const char *var; 947cf6eb489SMasami Hiramatsu 948cf6eb489SMasami Hiramatsu buf = synthesize_perf_probe_point(&pev->point); 949cf6eb489SMasami Hiramatsu if (!buf) 950cf6eb489SMasami Hiramatsu return -EINVAL; 951cf6eb489SMasami Hiramatsu pr_debug("Searching variables at %s\n", buf); 952cf6eb489SMasami Hiramatsu 953ddb2f58fSMasami Hiramatsu ret = debuginfo__find_available_vars_at(dinfo, pev, &vls); 9549b118acaSMasami Hiramatsu if (!ret) { /* Not found, retry with an alternative */ 95544225521SMasami Hiramatsu ret = get_alternative_probe_event(dinfo, pev, &tmp); 9569b118acaSMasami Hiramatsu if (!ret) { 9579b118acaSMasami Hiramatsu ret = debuginfo__find_available_vars_at(dinfo, pev, 958ddb2f58fSMasami Hiramatsu &vls); 9599b118acaSMasami Hiramatsu /* Release the old probe_point */ 9609b118acaSMasami Hiramatsu clear_perf_probe_point(&tmp); 9619b118acaSMasami Hiramatsu } 9629b118acaSMasami Hiramatsu } 963bd09d7b5SMasami Hiramatsu if (ret <= 0) { 96469e96eaaSMasami Hiramatsu if (ret == 0 || ret == -ENOENT) { 96569e96eaaSMasami Hiramatsu pr_err("Failed to find the address of %s\n", buf); 96669e96eaaSMasami Hiramatsu ret = -ENOENT; 96769e96eaaSMasami Hiramatsu } else 96869e96eaaSMasami Hiramatsu pr_warning("Debuginfo analysis failed.\n"); 969bd09d7b5SMasami Hiramatsu goto end; 970bd09d7b5SMasami Hiramatsu } 97169e96eaaSMasami Hiramatsu 972bd09d7b5SMasami Hiramatsu /* Some variables are found */ 973cf6eb489SMasami Hiramatsu fprintf(stdout, "Available variables at %s\n", buf); 974cf6eb489SMasami Hiramatsu for (i = 0; i < ret; i++) { 975cf6eb489SMasami Hiramatsu vl = &vls[i]; 976cf6eb489SMasami Hiramatsu /* 977cf6eb489SMasami Hiramatsu * A probe point might be converted to 978cf6eb489SMasami Hiramatsu * several trace points. 979cf6eb489SMasami Hiramatsu */ 980cf6eb489SMasami Hiramatsu fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol, 981cf6eb489SMasami Hiramatsu vl->point.offset); 98274cf249dSArnaldo Carvalho de Melo zfree(&vl->point.symbol); 983bd09d7b5SMasami Hiramatsu nvars = 0; 984cf6eb489SMasami Hiramatsu if (vl->vars) { 985bd09d7b5SMasami Hiramatsu strlist__for_each(node, vl->vars) { 986bd09d7b5SMasami Hiramatsu var = strchr(node->s, '\t') + 1; 987bd09d7b5SMasami Hiramatsu if (strfilter__compare(_filter, var)) { 988cf6eb489SMasami Hiramatsu fprintf(stdout, "\t\t%s\n", node->s); 989bd09d7b5SMasami Hiramatsu nvars++; 990bd09d7b5SMasami Hiramatsu } 991bd09d7b5SMasami Hiramatsu } 992cf6eb489SMasami Hiramatsu strlist__delete(vl->vars); 993bd09d7b5SMasami Hiramatsu } 994bd09d7b5SMasami Hiramatsu if (nvars == 0) 995bd09d7b5SMasami Hiramatsu fprintf(stdout, "\t\t(No matched variables)\n"); 996cf6eb489SMasami Hiramatsu } 997cf6eb489SMasami Hiramatsu free(vls); 998bd09d7b5SMasami Hiramatsu end: 999cf6eb489SMasami Hiramatsu free(buf); 1000cf6eb489SMasami Hiramatsu return ret; 1001cf6eb489SMasami Hiramatsu } 1002cf6eb489SMasami Hiramatsu 1003cf6eb489SMasami Hiramatsu /* Show available variables on given probe point */ 1004cf6eb489SMasami Hiramatsu int show_available_vars(struct perf_probe_event *pevs, int npevs, 1005ddb2f58fSMasami Hiramatsu struct strfilter *_filter) 1006cf6eb489SMasami Hiramatsu { 1007ff741783SMasami Hiramatsu int i, ret = 0; 1008ff741783SMasami Hiramatsu struct debuginfo *dinfo; 1009cf6eb489SMasami Hiramatsu 10109bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(pevs->uprobes); 1011cf6eb489SMasami Hiramatsu if (ret < 0) 1012cf6eb489SMasami Hiramatsu return ret; 1013cf6eb489SMasami Hiramatsu 101444225521SMasami Hiramatsu dinfo = open_debuginfo(pevs->target, false); 1015ff741783SMasami Hiramatsu if (!dinfo) { 1016ee45b6c2SMasami Hiramatsu ret = -ENOENT; 1017ee45b6c2SMasami Hiramatsu goto out; 1018ff741783SMasami Hiramatsu } 1019ff741783SMasami Hiramatsu 1020cc446446SMasami Hiramatsu setup_pager(); 1021cc446446SMasami Hiramatsu 1022ff741783SMasami Hiramatsu for (i = 0; i < npevs && ret >= 0; i++) 1023ddb2f58fSMasami Hiramatsu ret = show_available_vars_at(dinfo, &pevs[i], _filter); 1024ff741783SMasami Hiramatsu 1025ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 1026ee45b6c2SMasami Hiramatsu out: 10279bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 1028cf6eb489SMasami Hiramatsu return ret; 1029cf6eb489SMasami Hiramatsu } 1030cf6eb489SMasami Hiramatsu 103189fe808aSIngo Molnar #else /* !HAVE_DWARF_SUPPORT */ 10324b4da7f7SMasami Hiramatsu 10337737af01SMasami Hiramatsu static void debuginfo_cache__exit(void) 10347737af01SMasami Hiramatsu { 10357737af01SMasami Hiramatsu } 10367737af01SMasami Hiramatsu 10375a6f6314SMasami Hiramatsu static int 10385a6f6314SMasami Hiramatsu find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused, 10395a6f6314SMasami Hiramatsu struct perf_probe_point *pp __maybe_unused, 10405a6f6314SMasami Hiramatsu bool is_kprobe __maybe_unused) 10414b4da7f7SMasami Hiramatsu { 10425a6f6314SMasami Hiramatsu return -ENOSYS; 10434b4da7f7SMasami Hiramatsu } 10444b4da7f7SMasami Hiramatsu 10450e60836bSSrikar Dronamraju static int try_to_find_probe_trace_events(struct perf_probe_event *pev, 1046ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs __maybe_unused) 10474b4da7f7SMasami Hiramatsu { 1048146a1439SMasami Hiramatsu if (perf_probe_event_need_dwarf(pev)) { 1049146a1439SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 1050146a1439SMasami Hiramatsu return -ENOSYS; 1051146a1439SMasami Hiramatsu } 1052225466f1SSrikar Dronamraju 10534b4da7f7SMasami Hiramatsu return 0; 10544b4da7f7SMasami Hiramatsu } 10554b4da7f7SMasami Hiramatsu 10561d037ca1SIrina Tirdea int show_line_range(struct line_range *lr __maybe_unused, 10572b394bc4SMasami Hiramatsu const char *module __maybe_unused, 10582b394bc4SMasami Hiramatsu bool user __maybe_unused) 10594b4da7f7SMasami Hiramatsu { 1060146a1439SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 1061146a1439SMasami Hiramatsu return -ENOSYS; 10624b4da7f7SMasami Hiramatsu } 10634b4da7f7SMasami Hiramatsu 10641d037ca1SIrina Tirdea int show_available_vars(struct perf_probe_event *pevs __maybe_unused, 1065ddb2f58fSMasami Hiramatsu int npevs __maybe_unused, 1066ddb2f58fSMasami Hiramatsu struct strfilter *filter __maybe_unused) 1067cf6eb489SMasami Hiramatsu { 1068cf6eb489SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 1069cf6eb489SMasami Hiramatsu return -ENOSYS; 1070cf6eb489SMasami Hiramatsu } 1071e0faa8d3SMasami Hiramatsu #endif 1072e0faa8d3SMasami Hiramatsu 1073e53b00d3SMasami Hiramatsu void line_range__clear(struct line_range *lr) 1074e53b00d3SMasami Hiramatsu { 1075e53b00d3SMasami Hiramatsu free(lr->function); 1076e53b00d3SMasami Hiramatsu free(lr->file); 1077e53b00d3SMasami Hiramatsu free(lr->path); 1078e53b00d3SMasami Hiramatsu free(lr->comp_dir); 10795a62257aSMasami Hiramatsu intlist__delete(lr->line_list); 1080e53b00d3SMasami Hiramatsu memset(lr, 0, sizeof(*lr)); 1081e53b00d3SMasami Hiramatsu } 1082e53b00d3SMasami Hiramatsu 10835a62257aSMasami Hiramatsu int line_range__init(struct line_range *lr) 1084e53b00d3SMasami Hiramatsu { 1085e53b00d3SMasami Hiramatsu memset(lr, 0, sizeof(*lr)); 10865a62257aSMasami Hiramatsu lr->line_list = intlist__new(NULL); 10875a62257aSMasami Hiramatsu if (!lr->line_list) 10885a62257aSMasami Hiramatsu return -ENOMEM; 10895a62257aSMasami Hiramatsu else 10905a62257aSMasami Hiramatsu return 0; 1091e53b00d3SMasami Hiramatsu } 1092e53b00d3SMasami Hiramatsu 109321dd9ae5SFranck Bui-Huu static int parse_line_num(char **ptr, int *val, const char *what) 109421dd9ae5SFranck Bui-Huu { 109521dd9ae5SFranck Bui-Huu const char *start = *ptr; 109621dd9ae5SFranck Bui-Huu 109721dd9ae5SFranck Bui-Huu errno = 0; 109821dd9ae5SFranck Bui-Huu *val = strtol(*ptr, ptr, 0); 109921dd9ae5SFranck Bui-Huu if (errno || *ptr == start) { 110021dd9ae5SFranck Bui-Huu semantic_error("'%s' is not a valid number.\n", what); 110121dd9ae5SFranck Bui-Huu return -EINVAL; 110221dd9ae5SFranck Bui-Huu } 110321dd9ae5SFranck Bui-Huu return 0; 110421dd9ae5SFranck Bui-Huu } 110521dd9ae5SFranck Bui-Huu 1106573709fdSMasami Hiramatsu /* Check the name is good for event, group or function */ 1107573709fdSMasami Hiramatsu static bool is_c_func_name(const char *name) 1108573709fdSMasami Hiramatsu { 1109573709fdSMasami Hiramatsu if (!isalpha(*name) && *name != '_') 1110573709fdSMasami Hiramatsu return false; 1111573709fdSMasami Hiramatsu while (*++name != '\0') { 1112573709fdSMasami Hiramatsu if (!isalpha(*name) && !isdigit(*name) && *name != '_') 1113573709fdSMasami Hiramatsu return false; 1114573709fdSMasami Hiramatsu } 1115573709fdSMasami Hiramatsu return true; 1116573709fdSMasami Hiramatsu } 1117573709fdSMasami Hiramatsu 11189d95b580SFranck Bui-Huu /* 11199d95b580SFranck Bui-Huu * Stuff 'lr' according to the line range described by 'arg'. 11209d95b580SFranck Bui-Huu * The line range syntax is described by: 11219d95b580SFranck Bui-Huu * 11229d95b580SFranck Bui-Huu * SRC[:SLN[+NUM|-ELN]] 1123e116dfa1SMasami Hiramatsu * FNC[@SRC][:SLN[+NUM|-ELN]] 11249d95b580SFranck Bui-Huu */ 1125146a1439SMasami Hiramatsu int parse_line_range_desc(const char *arg, struct line_range *lr) 1126631c9defSMasami Hiramatsu { 1127e116dfa1SMasami Hiramatsu char *range, *file, *name = strdup(arg); 112821dd9ae5SFranck Bui-Huu int err; 11299d95b580SFranck Bui-Huu 113021dd9ae5SFranck Bui-Huu if (!name) 113121dd9ae5SFranck Bui-Huu return -ENOMEM; 113221dd9ae5SFranck Bui-Huu 113321dd9ae5SFranck Bui-Huu lr->start = 0; 113421dd9ae5SFranck Bui-Huu lr->end = INT_MAX; 113521dd9ae5SFranck Bui-Huu 113621dd9ae5SFranck Bui-Huu range = strchr(name, ':'); 113721dd9ae5SFranck Bui-Huu if (range) { 113821dd9ae5SFranck Bui-Huu *range++ = '\0'; 113921dd9ae5SFranck Bui-Huu 114021dd9ae5SFranck Bui-Huu err = parse_line_num(&range, &lr->start, "start line"); 114121dd9ae5SFranck Bui-Huu if (err) 114221dd9ae5SFranck Bui-Huu goto err; 114321dd9ae5SFranck Bui-Huu 114421dd9ae5SFranck Bui-Huu if (*range == '+' || *range == '-') { 114521dd9ae5SFranck Bui-Huu const char c = *range++; 114621dd9ae5SFranck Bui-Huu 114721dd9ae5SFranck Bui-Huu err = parse_line_num(&range, &lr->end, "end line"); 114821dd9ae5SFranck Bui-Huu if (err) 114921dd9ae5SFranck Bui-Huu goto err; 115021dd9ae5SFranck Bui-Huu 115121dd9ae5SFranck Bui-Huu if (c == '+') { 115221dd9ae5SFranck Bui-Huu lr->end += lr->start; 115321dd9ae5SFranck Bui-Huu /* 1154dda4ab34SMasami Hiramatsu * Adjust the number of lines here. 1155dda4ab34SMasami Hiramatsu * If the number of lines == 1, the 1156dda4ab34SMasami Hiramatsu * the end of line should be equal to 1157dda4ab34SMasami Hiramatsu * the start of line. 1158dda4ab34SMasami Hiramatsu */ 115921dd9ae5SFranck Bui-Huu lr->end--; 116021dd9ae5SFranck Bui-Huu } 116121dd9ae5SFranck Bui-Huu } 116221dd9ae5SFranck Bui-Huu 1163d3b63d7aSMasami Hiramatsu pr_debug("Line range is %d to %d\n", lr->start, lr->end); 116421dd9ae5SFranck Bui-Huu 116521dd9ae5SFranck Bui-Huu err = -EINVAL; 1166d3b63d7aSMasami Hiramatsu if (lr->start > lr->end) { 1167631c9defSMasami Hiramatsu semantic_error("Start line must be smaller" 1168146a1439SMasami Hiramatsu " than end line.\n"); 116921dd9ae5SFranck Bui-Huu goto err; 1170146a1439SMasami Hiramatsu } 117121dd9ae5SFranck Bui-Huu if (*range != '\0') { 117221dd9ae5SFranck Bui-Huu semantic_error("Tailing with invalid str '%s'.\n", range); 117321dd9ae5SFranck Bui-Huu goto err; 1174146a1439SMasami Hiramatsu } 1175d3b63d7aSMasami Hiramatsu } 117602b95dadSMasami Hiramatsu 1177e116dfa1SMasami Hiramatsu file = strchr(name, '@'); 1178e116dfa1SMasami Hiramatsu if (file) { 1179e116dfa1SMasami Hiramatsu *file = '\0'; 1180e116dfa1SMasami Hiramatsu lr->file = strdup(++file); 1181e116dfa1SMasami Hiramatsu if (lr->file == NULL) { 1182e116dfa1SMasami Hiramatsu err = -ENOMEM; 1183e116dfa1SMasami Hiramatsu goto err; 1184e116dfa1SMasami Hiramatsu } 1185e116dfa1SMasami Hiramatsu lr->function = name; 1186573709fdSMasami Hiramatsu } else if (strchr(name, '/') || strchr(name, '.')) 118721dd9ae5SFranck Bui-Huu lr->file = name; 1188573709fdSMasami Hiramatsu else if (is_c_func_name(name))/* We reuse it for checking funcname */ 118921dd9ae5SFranck Bui-Huu lr->function = name; 1190573709fdSMasami Hiramatsu else { /* Invalid name */ 1191573709fdSMasami Hiramatsu semantic_error("'%s' is not a valid function name.\n", name); 1192573709fdSMasami Hiramatsu err = -EINVAL; 1193573709fdSMasami Hiramatsu goto err; 1194573709fdSMasami Hiramatsu } 1195146a1439SMasami Hiramatsu 1196146a1439SMasami Hiramatsu return 0; 119721dd9ae5SFranck Bui-Huu err: 119821dd9ae5SFranck Bui-Huu free(name); 119921dd9ae5SFranck Bui-Huu return err; 1200631c9defSMasami Hiramatsu } 1201631c9defSMasami Hiramatsu 120250656eecSMasami Hiramatsu /* Parse probepoint definition. */ 1203146a1439SMasami Hiramatsu static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev) 120450656eecSMasami Hiramatsu { 12054235b045SMasami Hiramatsu struct perf_probe_point *pp = &pev->point; 120650656eecSMasami Hiramatsu char *ptr, *tmp; 120750656eecSMasami Hiramatsu char c, nc = 0; 12083099c026SNaveen N. Rao bool file_spec = false; 120950656eecSMasami Hiramatsu /* 121050656eecSMasami Hiramatsu * <Syntax> 12112a9c8c36SMasami Hiramatsu * perf probe [EVENT=]SRC[:LN|;PTN] 12122a9c8c36SMasami Hiramatsu * perf probe [EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT] 1213af663d75SMasami Hiramatsu * 1214af663d75SMasami Hiramatsu * TODO:Group name support 121550656eecSMasami Hiramatsu */ 1216e59d29e8SWang Nan if (!arg) 1217e59d29e8SWang Nan return -EINVAL; 121850656eecSMasami Hiramatsu 12192a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";=@+%"); 12202a9c8c36SMasami Hiramatsu if (ptr && *ptr == '=') { /* Event name */ 1221af663d75SMasami Hiramatsu *ptr = '\0'; 1222af663d75SMasami Hiramatsu tmp = ptr + 1; 1223146a1439SMasami Hiramatsu if (strchr(arg, ':')) { 1224146a1439SMasami Hiramatsu semantic_error("Group name is not supported yet.\n"); 1225146a1439SMasami Hiramatsu return -ENOTSUP; 1226146a1439SMasami Hiramatsu } 1227573709fdSMasami Hiramatsu if (!is_c_func_name(arg)) { 1228b7702a21SMasami Hiramatsu semantic_error("%s is bad for event name -it must " 1229146a1439SMasami Hiramatsu "follow C symbol-naming rule.\n", arg); 1230146a1439SMasami Hiramatsu return -EINVAL; 1231146a1439SMasami Hiramatsu } 123202b95dadSMasami Hiramatsu pev->event = strdup(arg); 123302b95dadSMasami Hiramatsu if (pev->event == NULL) 123402b95dadSMasami Hiramatsu return -ENOMEM; 12354235b045SMasami Hiramatsu pev->group = NULL; 1236af663d75SMasami Hiramatsu arg = tmp; 1237af663d75SMasami Hiramatsu } 1238af663d75SMasami Hiramatsu 12393099c026SNaveen N. Rao /* 12403099c026SNaveen N. Rao * Check arg is function or file name and copy it. 12413099c026SNaveen N. Rao * 12423099c026SNaveen N. Rao * We consider arg to be a file spec if and only if it satisfies 12433099c026SNaveen N. Rao * all of the below criteria:: 12443099c026SNaveen N. Rao * - it does not include any of "+@%", 12453099c026SNaveen N. Rao * - it includes one of ":;", and 12463099c026SNaveen N. Rao * - it has a period '.' in the name. 12473099c026SNaveen N. Rao * 12483099c026SNaveen N. Rao * Otherwise, we consider arg to be a function specification. 12493099c026SNaveen N. Rao */ 12503099c026SNaveen N. Rao if (!strpbrk(arg, "+@%") && (ptr = strpbrk(arg, ";:")) != NULL) { 12513099c026SNaveen N. Rao /* This is a file spec if it includes a '.' before ; or : */ 12523099c026SNaveen N. Rao if (memchr(arg, '.', ptr - arg)) 12533099c026SNaveen N. Rao file_spec = true; 12543099c026SNaveen N. Rao } 12553099c026SNaveen N. Rao 12562a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";:+@%"); 125750656eecSMasami Hiramatsu if (ptr) { 125850656eecSMasami Hiramatsu nc = *ptr; 125950656eecSMasami Hiramatsu *ptr++ = '\0'; 126050656eecSMasami Hiramatsu } 126150656eecSMasami Hiramatsu 12626c6e024fSWang Nan if (arg[0] == '\0') 12636c6e024fSWang Nan tmp = NULL; 12646c6e024fSWang Nan else { 126502b95dadSMasami Hiramatsu tmp = strdup(arg); 126602b95dadSMasami Hiramatsu if (tmp == NULL) 126702b95dadSMasami Hiramatsu return -ENOMEM; 12686c6e024fSWang Nan } 126902b95dadSMasami Hiramatsu 12703099c026SNaveen N. Rao if (file_spec) 127102b95dadSMasami Hiramatsu pp->file = tmp; 1272da15bd9dSWang Nan else { 127302b95dadSMasami Hiramatsu pp->function = tmp; 127450656eecSMasami Hiramatsu 1275da15bd9dSWang Nan /* 1276da15bd9dSWang Nan * Keep pp->function even if this is absolute address, 1277da15bd9dSWang Nan * so it can mark whether abs_address is valid. 1278da15bd9dSWang Nan * Which make 'perf probe lib.bin 0x0' possible. 1279da15bd9dSWang Nan * 1280da15bd9dSWang Nan * Note that checking length of tmp is not needed 1281da15bd9dSWang Nan * because when we access tmp[1] we know tmp[0] is '0', 1282da15bd9dSWang Nan * so tmp[1] should always valid (but could be '\0'). 1283da15bd9dSWang Nan */ 1284da15bd9dSWang Nan if (tmp && !strncmp(tmp, "0x", 2)) { 1285da15bd9dSWang Nan pp->abs_address = strtoul(pp->function, &tmp, 0); 1286da15bd9dSWang Nan if (*tmp != '\0') { 1287da15bd9dSWang Nan semantic_error("Invalid absolute address.\n"); 1288da15bd9dSWang Nan return -EINVAL; 1289da15bd9dSWang Nan } 1290da15bd9dSWang Nan } 1291da15bd9dSWang Nan } 1292da15bd9dSWang Nan 129350656eecSMasami Hiramatsu /* Parse other options */ 129450656eecSMasami Hiramatsu while (ptr) { 129550656eecSMasami Hiramatsu arg = ptr; 129650656eecSMasami Hiramatsu c = nc; 12972a9c8c36SMasami Hiramatsu if (c == ';') { /* Lazy pattern must be the last part */ 129802b95dadSMasami Hiramatsu pp->lazy_line = strdup(arg); 129902b95dadSMasami Hiramatsu if (pp->lazy_line == NULL) 130002b95dadSMasami Hiramatsu return -ENOMEM; 13012a9c8c36SMasami Hiramatsu break; 13022a9c8c36SMasami Hiramatsu } 13032a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";:+@%"); 130450656eecSMasami Hiramatsu if (ptr) { 130550656eecSMasami Hiramatsu nc = *ptr; 130650656eecSMasami Hiramatsu *ptr++ = '\0'; 130750656eecSMasami Hiramatsu } 130850656eecSMasami Hiramatsu switch (c) { 130950656eecSMasami Hiramatsu case ':': /* Line number */ 131050656eecSMasami Hiramatsu pp->line = strtoul(arg, &tmp, 0); 1311146a1439SMasami Hiramatsu if (*tmp != '\0') { 13122a9c8c36SMasami Hiramatsu semantic_error("There is non-digit char" 1313146a1439SMasami Hiramatsu " in line number.\n"); 1314146a1439SMasami Hiramatsu return -EINVAL; 1315146a1439SMasami Hiramatsu } 131650656eecSMasami Hiramatsu break; 131750656eecSMasami Hiramatsu case '+': /* Byte offset from a symbol */ 131850656eecSMasami Hiramatsu pp->offset = strtoul(arg, &tmp, 0); 1319146a1439SMasami Hiramatsu if (*tmp != '\0') { 13202a9c8c36SMasami Hiramatsu semantic_error("There is non-digit character" 1321146a1439SMasami Hiramatsu " in offset.\n"); 1322146a1439SMasami Hiramatsu return -EINVAL; 1323146a1439SMasami Hiramatsu } 132450656eecSMasami Hiramatsu break; 132550656eecSMasami Hiramatsu case '@': /* File name */ 1326146a1439SMasami Hiramatsu if (pp->file) { 1327146a1439SMasami Hiramatsu semantic_error("SRC@SRC is not allowed.\n"); 1328146a1439SMasami Hiramatsu return -EINVAL; 1329146a1439SMasami Hiramatsu } 133002b95dadSMasami Hiramatsu pp->file = strdup(arg); 133102b95dadSMasami Hiramatsu if (pp->file == NULL) 133202b95dadSMasami Hiramatsu return -ENOMEM; 133350656eecSMasami Hiramatsu break; 133450656eecSMasami Hiramatsu case '%': /* Probe places */ 133550656eecSMasami Hiramatsu if (strcmp(arg, "return") == 0) { 133650656eecSMasami Hiramatsu pp->retprobe = 1; 1337146a1439SMasami Hiramatsu } else { /* Others not supported yet */ 1338146a1439SMasami Hiramatsu semantic_error("%%%s is not supported.\n", arg); 1339146a1439SMasami Hiramatsu return -ENOTSUP; 1340146a1439SMasami Hiramatsu } 134150656eecSMasami Hiramatsu break; 1342146a1439SMasami Hiramatsu default: /* Buggy case */ 1343146a1439SMasami Hiramatsu pr_err("This program has a bug at %s:%d.\n", 1344146a1439SMasami Hiramatsu __FILE__, __LINE__); 1345146a1439SMasami Hiramatsu return -ENOTSUP; 134650656eecSMasami Hiramatsu break; 134750656eecSMasami Hiramatsu } 134850656eecSMasami Hiramatsu } 134950656eecSMasami Hiramatsu 135050656eecSMasami Hiramatsu /* Exclusion check */ 1351146a1439SMasami Hiramatsu if (pp->lazy_line && pp->line) { 13520e43e5d2SMasami Hiramatsu semantic_error("Lazy pattern can't be used with" 13530e43e5d2SMasami Hiramatsu " line number.\n"); 1354146a1439SMasami Hiramatsu return -EINVAL; 1355146a1439SMasami Hiramatsu } 13562a9c8c36SMasami Hiramatsu 1357146a1439SMasami Hiramatsu if (pp->lazy_line && pp->offset) { 13580e43e5d2SMasami Hiramatsu semantic_error("Lazy pattern can't be used with offset.\n"); 1359146a1439SMasami Hiramatsu return -EINVAL; 1360146a1439SMasami Hiramatsu } 13612a9c8c36SMasami Hiramatsu 1362146a1439SMasami Hiramatsu if (pp->line && pp->offset) { 13630e43e5d2SMasami Hiramatsu semantic_error("Offset can't be used with line number.\n"); 1364146a1439SMasami Hiramatsu return -EINVAL; 1365146a1439SMasami Hiramatsu } 136650656eecSMasami Hiramatsu 1367146a1439SMasami Hiramatsu if (!pp->line && !pp->lazy_line && pp->file && !pp->function) { 13682a9c8c36SMasami Hiramatsu semantic_error("File always requires line number or " 13690e43e5d2SMasami Hiramatsu "lazy pattern.\n"); 1370146a1439SMasami Hiramatsu return -EINVAL; 1371146a1439SMasami Hiramatsu } 137250656eecSMasami Hiramatsu 1373146a1439SMasami Hiramatsu if (pp->offset && !pp->function) { 13740e43e5d2SMasami Hiramatsu semantic_error("Offset requires an entry function.\n"); 1375146a1439SMasami Hiramatsu return -EINVAL; 1376146a1439SMasami Hiramatsu } 137750656eecSMasami Hiramatsu 1378146a1439SMasami Hiramatsu if (pp->retprobe && !pp->function) { 13790e43e5d2SMasami Hiramatsu semantic_error("Return probe requires an entry function.\n"); 1380146a1439SMasami Hiramatsu return -EINVAL; 1381146a1439SMasami Hiramatsu } 138250656eecSMasami Hiramatsu 1383146a1439SMasami Hiramatsu if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) { 13842a9c8c36SMasami Hiramatsu semantic_error("Offset/Line/Lazy pattern can't be used with " 13850e43e5d2SMasami Hiramatsu "return probe.\n"); 1386146a1439SMasami Hiramatsu return -EINVAL; 1387146a1439SMasami Hiramatsu } 138850656eecSMasami Hiramatsu 13894235b045SMasami Hiramatsu pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n", 13902a9c8c36SMasami Hiramatsu pp->function, pp->file, pp->line, pp->offset, pp->retprobe, 13912a9c8c36SMasami Hiramatsu pp->lazy_line); 1392146a1439SMasami Hiramatsu return 0; 139350656eecSMasami Hiramatsu } 139450656eecSMasami Hiramatsu 13957df2f329SMasami Hiramatsu /* Parse perf-probe event argument */ 1396146a1439SMasami Hiramatsu static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg) 13977df2f329SMasami Hiramatsu { 1398b2a3c12bSMasami Hiramatsu char *tmp, *goodname; 13997df2f329SMasami Hiramatsu struct perf_probe_arg_field **fieldp; 14007df2f329SMasami Hiramatsu 14017df2f329SMasami Hiramatsu pr_debug("parsing arg: %s into ", str); 14027df2f329SMasami Hiramatsu 140348481938SMasami Hiramatsu tmp = strchr(str, '='); 140448481938SMasami Hiramatsu if (tmp) { 140502b95dadSMasami Hiramatsu arg->name = strndup(str, tmp - str); 140602b95dadSMasami Hiramatsu if (arg->name == NULL) 140702b95dadSMasami Hiramatsu return -ENOMEM; 140811a1ca35SMasami Hiramatsu pr_debug("name:%s ", arg->name); 140948481938SMasami Hiramatsu str = tmp + 1; 141048481938SMasami Hiramatsu } 141148481938SMasami Hiramatsu 141211a1ca35SMasami Hiramatsu tmp = strchr(str, ':'); 141311a1ca35SMasami Hiramatsu if (tmp) { /* Type setting */ 141411a1ca35SMasami Hiramatsu *tmp = '\0'; 141502b95dadSMasami Hiramatsu arg->type = strdup(tmp + 1); 141602b95dadSMasami Hiramatsu if (arg->type == NULL) 141702b95dadSMasami Hiramatsu return -ENOMEM; 141811a1ca35SMasami Hiramatsu pr_debug("type:%s ", arg->type); 141911a1ca35SMasami Hiramatsu } 142011a1ca35SMasami Hiramatsu 1421b2a3c12bSMasami Hiramatsu tmp = strpbrk(str, "-.["); 14227df2f329SMasami Hiramatsu if (!is_c_varname(str) || !tmp) { 14237df2f329SMasami Hiramatsu /* A variable, register, symbol or special value */ 142402b95dadSMasami Hiramatsu arg->var = strdup(str); 142502b95dadSMasami Hiramatsu if (arg->var == NULL) 142602b95dadSMasami Hiramatsu return -ENOMEM; 142748481938SMasami Hiramatsu pr_debug("%s\n", arg->var); 1428146a1439SMasami Hiramatsu return 0; 14297df2f329SMasami Hiramatsu } 14307df2f329SMasami Hiramatsu 1431b2a3c12bSMasami Hiramatsu /* Structure fields or array element */ 143202b95dadSMasami Hiramatsu arg->var = strndup(str, tmp - str); 143302b95dadSMasami Hiramatsu if (arg->var == NULL) 143402b95dadSMasami Hiramatsu return -ENOMEM; 1435b2a3c12bSMasami Hiramatsu goodname = arg->var; 143648481938SMasami Hiramatsu pr_debug("%s, ", arg->var); 14377df2f329SMasami Hiramatsu fieldp = &arg->field; 14387df2f329SMasami Hiramatsu 14397df2f329SMasami Hiramatsu do { 1440e334016fSMasami Hiramatsu *fieldp = zalloc(sizeof(struct perf_probe_arg_field)); 1441e334016fSMasami Hiramatsu if (*fieldp == NULL) 1442e334016fSMasami Hiramatsu return -ENOMEM; 1443b2a3c12bSMasami Hiramatsu if (*tmp == '[') { /* Array */ 1444b2a3c12bSMasami Hiramatsu str = tmp; 1445b2a3c12bSMasami Hiramatsu (*fieldp)->index = strtol(str + 1, &tmp, 0); 1446b2a3c12bSMasami Hiramatsu (*fieldp)->ref = true; 1447b2a3c12bSMasami Hiramatsu if (*tmp != ']' || tmp == str + 1) { 1448b2a3c12bSMasami Hiramatsu semantic_error("Array index must be a" 1449b2a3c12bSMasami Hiramatsu " number.\n"); 1450b2a3c12bSMasami Hiramatsu return -EINVAL; 1451b2a3c12bSMasami Hiramatsu } 1452b2a3c12bSMasami Hiramatsu tmp++; 1453b2a3c12bSMasami Hiramatsu if (*tmp == '\0') 1454b2a3c12bSMasami Hiramatsu tmp = NULL; 1455b2a3c12bSMasami Hiramatsu } else { /* Structure */ 14567df2f329SMasami Hiramatsu if (*tmp == '.') { 14577df2f329SMasami Hiramatsu str = tmp + 1; 14587df2f329SMasami Hiramatsu (*fieldp)->ref = false; 14597df2f329SMasami Hiramatsu } else if (tmp[1] == '>') { 14607df2f329SMasami Hiramatsu str = tmp + 2; 14617df2f329SMasami Hiramatsu (*fieldp)->ref = true; 1462146a1439SMasami Hiramatsu } else { 1463b2a3c12bSMasami Hiramatsu semantic_error("Argument parse error: %s\n", 1464b2a3c12bSMasami Hiramatsu str); 1465146a1439SMasami Hiramatsu return -EINVAL; 1466146a1439SMasami Hiramatsu } 1467b2a3c12bSMasami Hiramatsu tmp = strpbrk(str, "-.["); 1468b2a3c12bSMasami Hiramatsu } 14697df2f329SMasami Hiramatsu if (tmp) { 147002b95dadSMasami Hiramatsu (*fieldp)->name = strndup(str, tmp - str); 147102b95dadSMasami Hiramatsu if ((*fieldp)->name == NULL) 147202b95dadSMasami Hiramatsu return -ENOMEM; 1473b2a3c12bSMasami Hiramatsu if (*str != '[') 1474b2a3c12bSMasami Hiramatsu goodname = (*fieldp)->name; 14757df2f329SMasami Hiramatsu pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref); 14767df2f329SMasami Hiramatsu fieldp = &(*fieldp)->next; 14777df2f329SMasami Hiramatsu } 14787df2f329SMasami Hiramatsu } while (tmp); 147902b95dadSMasami Hiramatsu (*fieldp)->name = strdup(str); 148002b95dadSMasami Hiramatsu if ((*fieldp)->name == NULL) 148102b95dadSMasami Hiramatsu return -ENOMEM; 1482b2a3c12bSMasami Hiramatsu if (*str != '[') 1483b2a3c12bSMasami Hiramatsu goodname = (*fieldp)->name; 14847df2f329SMasami Hiramatsu pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref); 1485df0faf4bSMasami Hiramatsu 1486b2a3c12bSMasami Hiramatsu /* If no name is specified, set the last field name (not array index)*/ 148702b95dadSMasami Hiramatsu if (!arg->name) { 1488b2a3c12bSMasami Hiramatsu arg->name = strdup(goodname); 148902b95dadSMasami Hiramatsu if (arg->name == NULL) 149002b95dadSMasami Hiramatsu return -ENOMEM; 149102b95dadSMasami Hiramatsu } 1492146a1439SMasami Hiramatsu return 0; 14937df2f329SMasami Hiramatsu } 14947df2f329SMasami Hiramatsu 14954235b045SMasami Hiramatsu /* Parse perf-probe event command */ 1496146a1439SMasami Hiramatsu int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev) 149750656eecSMasami Hiramatsu { 1498e1c01d61SMasami Hiramatsu char **argv; 1499146a1439SMasami Hiramatsu int argc, i, ret = 0; 1500fac13fd5SMasami Hiramatsu 15014235b045SMasami Hiramatsu argv = argv_split(cmd, &argc); 1502146a1439SMasami Hiramatsu if (!argv) { 1503146a1439SMasami Hiramatsu pr_debug("Failed to split arguments.\n"); 1504146a1439SMasami Hiramatsu return -ENOMEM; 1505146a1439SMasami Hiramatsu } 1506146a1439SMasami Hiramatsu if (argc - 1 > MAX_PROBE_ARGS) { 1507146a1439SMasami Hiramatsu semantic_error("Too many probe arguments (%d).\n", argc - 1); 1508146a1439SMasami Hiramatsu ret = -ERANGE; 1509146a1439SMasami Hiramatsu goto out; 1510146a1439SMasami Hiramatsu } 151150656eecSMasami Hiramatsu /* Parse probe point */ 1512146a1439SMasami Hiramatsu ret = parse_perf_probe_point(argv[0], pev); 1513146a1439SMasami Hiramatsu if (ret < 0) 1514146a1439SMasami Hiramatsu goto out; 151550656eecSMasami Hiramatsu 1516e1c01d61SMasami Hiramatsu /* Copy arguments and ensure return probe has no C argument */ 15174235b045SMasami Hiramatsu pev->nargs = argc - 1; 1518e334016fSMasami Hiramatsu pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs); 1519e334016fSMasami Hiramatsu if (pev->args == NULL) { 1520e334016fSMasami Hiramatsu ret = -ENOMEM; 1521e334016fSMasami Hiramatsu goto out; 1522e334016fSMasami Hiramatsu } 1523146a1439SMasami Hiramatsu for (i = 0; i < pev->nargs && ret >= 0; i++) { 1524146a1439SMasami Hiramatsu ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]); 1525146a1439SMasami Hiramatsu if (ret >= 0 && 1526146a1439SMasami Hiramatsu is_c_varname(pev->args[i].var) && pev->point.retprobe) { 15274235b045SMasami Hiramatsu semantic_error("You can't specify local variable for" 1528146a1439SMasami Hiramatsu " kretprobe.\n"); 1529146a1439SMasami Hiramatsu ret = -EINVAL; 1530e1c01d61SMasami Hiramatsu } 1531146a1439SMasami Hiramatsu } 1532146a1439SMasami Hiramatsu out: 1533e1c01d61SMasami Hiramatsu argv_free(argv); 1534146a1439SMasami Hiramatsu 1535146a1439SMasami Hiramatsu return ret; 153650656eecSMasami Hiramatsu } 153750656eecSMasami Hiramatsu 15384235b045SMasami Hiramatsu /* Return true if this perf_probe_event requires debuginfo */ 15394235b045SMasami Hiramatsu bool perf_probe_event_need_dwarf(struct perf_probe_event *pev) 15404de189feSMasami Hiramatsu { 15414235b045SMasami Hiramatsu int i; 15424235b045SMasami Hiramatsu 15434235b045SMasami Hiramatsu if (pev->point.file || pev->point.line || pev->point.lazy_line) 15444235b045SMasami Hiramatsu return true; 15454235b045SMasami Hiramatsu 15464235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) 154748481938SMasami Hiramatsu if (is_c_varname(pev->args[i].var)) 15484235b045SMasami Hiramatsu return true; 15494235b045SMasami Hiramatsu 15504235b045SMasami Hiramatsu return false; 15514235b045SMasami Hiramatsu } 15524235b045SMasami Hiramatsu 15530e60836bSSrikar Dronamraju /* Parse probe_events event into struct probe_point */ 155492f6c72eSMasami Hiramatsu int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev) 15554235b045SMasami Hiramatsu { 15560e60836bSSrikar Dronamraju struct probe_trace_point *tp = &tev->point; 15574de189feSMasami Hiramatsu char pr; 15584de189feSMasami Hiramatsu char *p; 1559bcbd0040SIrina Tirdea char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str; 15604de189feSMasami Hiramatsu int ret, i, argc; 15614de189feSMasami Hiramatsu char **argv; 15624de189feSMasami Hiramatsu 15630e60836bSSrikar Dronamraju pr_debug("Parsing probe_events: %s\n", cmd); 15644235b045SMasami Hiramatsu argv = argv_split(cmd, &argc); 1565146a1439SMasami Hiramatsu if (!argv) { 1566146a1439SMasami Hiramatsu pr_debug("Failed to split arguments.\n"); 1567146a1439SMasami Hiramatsu return -ENOMEM; 1568146a1439SMasami Hiramatsu } 1569146a1439SMasami Hiramatsu if (argc < 2) { 1570146a1439SMasami Hiramatsu semantic_error("Too few probe arguments.\n"); 1571146a1439SMasami Hiramatsu ret = -ERANGE; 1572146a1439SMasami Hiramatsu goto out; 1573146a1439SMasami Hiramatsu } 15744de189feSMasami Hiramatsu 15754de189feSMasami Hiramatsu /* Scan event and group name. */ 1576bcbd0040SIrina Tirdea argv0_str = strdup(argv[0]); 1577bcbd0040SIrina Tirdea if (argv0_str == NULL) { 1578bcbd0040SIrina Tirdea ret = -ENOMEM; 1579bcbd0040SIrina Tirdea goto out; 1580bcbd0040SIrina Tirdea } 1581bcbd0040SIrina Tirdea fmt1_str = strtok_r(argv0_str, ":", &fmt); 1582bcbd0040SIrina Tirdea fmt2_str = strtok_r(NULL, "/", &fmt); 1583bcbd0040SIrina Tirdea fmt3_str = strtok_r(NULL, " \t", &fmt); 1584bcbd0040SIrina Tirdea if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL 1585bcbd0040SIrina Tirdea || fmt3_str == NULL) { 1586146a1439SMasami Hiramatsu semantic_error("Failed to parse event name: %s\n", argv[0]); 1587146a1439SMasami Hiramatsu ret = -EINVAL; 1588146a1439SMasami Hiramatsu goto out; 1589146a1439SMasami Hiramatsu } 1590bcbd0040SIrina Tirdea pr = fmt1_str[0]; 1591bcbd0040SIrina Tirdea tev->group = strdup(fmt2_str); 1592bcbd0040SIrina Tirdea tev->event = strdup(fmt3_str); 1593bcbd0040SIrina Tirdea if (tev->group == NULL || tev->event == NULL) { 1594bcbd0040SIrina Tirdea ret = -ENOMEM; 1595bcbd0040SIrina Tirdea goto out; 1596bcbd0040SIrina Tirdea } 15974235b045SMasami Hiramatsu pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr); 15984de189feSMasami Hiramatsu 15994235b045SMasami Hiramatsu tp->retprobe = (pr == 'r'); 16004de189feSMasami Hiramatsu 1601190b57fcSMasami Hiramatsu /* Scan module name(if there), function name and offset */ 1602190b57fcSMasami Hiramatsu p = strchr(argv[1], ':'); 1603190b57fcSMasami Hiramatsu if (p) { 1604190b57fcSMasami Hiramatsu tp->module = strndup(argv[1], p - argv[1]); 1605844faa4bSMasami Hiramatsu if (!tp->module) { 1606844faa4bSMasami Hiramatsu ret = -ENOMEM; 1607844faa4bSMasami Hiramatsu goto out; 1608844faa4bSMasami Hiramatsu } 1609190b57fcSMasami Hiramatsu p++; 1610190b57fcSMasami Hiramatsu } else 1611190b57fcSMasami Hiramatsu p = argv[1]; 1612bcbd0040SIrina Tirdea fmt1_str = strtok_r(p, "+", &fmt); 1613be07afe9SWang Nan /* only the address started with 0x */ 1614be07afe9SWang Nan if (fmt1_str[0] == '0') { 1615be07afe9SWang Nan /* 1616be07afe9SWang Nan * Fix a special case: 1617be07afe9SWang Nan * if address == 0, kernel reports something like: 1618be07afe9SWang Nan * p:probe_libc/abs_0 /lib/libc-2.18.so:0x (null) arg1=%ax 1619be07afe9SWang Nan * Newer kernel may fix that, but we want to 1620be07afe9SWang Nan * support old kernel also. 1621be07afe9SWang Nan */ 1622be07afe9SWang Nan if (strcmp(fmt1_str, "0x") == 0) { 1623be07afe9SWang Nan if (!argv[2] || strcmp(argv[2], "(null)")) { 1624be07afe9SWang Nan ret = -EINVAL; 1625be07afe9SWang Nan goto out; 1626be07afe9SWang Nan } 1627be07afe9SWang Nan tp->address = 0; 1628be07afe9SWang Nan 1629be07afe9SWang Nan free(argv[2]); 1630be07afe9SWang Nan for (i = 2; argv[i + 1] != NULL; i++) 1631be07afe9SWang Nan argv[i] = argv[i + 1]; 1632be07afe9SWang Nan 1633be07afe9SWang Nan argv[i] = NULL; 1634be07afe9SWang Nan argc -= 1; 1635be07afe9SWang Nan } else 16365a6f6314SMasami Hiramatsu tp->address = strtoul(fmt1_str, NULL, 0); 1637be07afe9SWang Nan } else { 16385a6f6314SMasami Hiramatsu /* Only the symbol-based probe has offset */ 1639bcbd0040SIrina Tirdea tp->symbol = strdup(fmt1_str); 1640bcbd0040SIrina Tirdea if (tp->symbol == NULL) { 1641bcbd0040SIrina Tirdea ret = -ENOMEM; 1642bcbd0040SIrina Tirdea goto out; 1643bcbd0040SIrina Tirdea } 1644bcbd0040SIrina Tirdea fmt2_str = strtok_r(NULL, "", &fmt); 1645bcbd0040SIrina Tirdea if (fmt2_str == NULL) 16464235b045SMasami Hiramatsu tp->offset = 0; 1647bcbd0040SIrina Tirdea else 1648bcbd0040SIrina Tirdea tp->offset = strtoul(fmt2_str, NULL, 10); 16495a6f6314SMasami Hiramatsu } 16504de189feSMasami Hiramatsu 16514235b045SMasami Hiramatsu tev->nargs = argc - 2; 16520e60836bSSrikar Dronamraju tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); 1653e334016fSMasami Hiramatsu if (tev->args == NULL) { 1654e334016fSMasami Hiramatsu ret = -ENOMEM; 1655e334016fSMasami Hiramatsu goto out; 1656e334016fSMasami Hiramatsu } 16574235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 16584de189feSMasami Hiramatsu p = strchr(argv[i + 2], '='); 16594de189feSMasami Hiramatsu if (p) /* We don't need which register is assigned. */ 16604235b045SMasami Hiramatsu *p++ = '\0'; 16614235b045SMasami Hiramatsu else 16624235b045SMasami Hiramatsu p = argv[i + 2]; 166302b95dadSMasami Hiramatsu tev->args[i].name = strdup(argv[i + 2]); 16644235b045SMasami Hiramatsu /* TODO: parse regs and offset */ 166502b95dadSMasami Hiramatsu tev->args[i].value = strdup(p); 166602b95dadSMasami Hiramatsu if (tev->args[i].name == NULL || tev->args[i].value == NULL) { 166702b95dadSMasami Hiramatsu ret = -ENOMEM; 166802b95dadSMasami Hiramatsu goto out; 166902b95dadSMasami Hiramatsu } 16704de189feSMasami Hiramatsu } 1671146a1439SMasami Hiramatsu ret = 0; 1672146a1439SMasami Hiramatsu out: 1673bcbd0040SIrina Tirdea free(argv0_str); 16744de189feSMasami Hiramatsu argv_free(argv); 1675146a1439SMasami Hiramatsu return ret; 16764de189feSMasami Hiramatsu } 16774de189feSMasami Hiramatsu 16787df2f329SMasami Hiramatsu /* Compose only probe arg */ 1679909b0360SMasami Hiramatsu char *synthesize_perf_probe_arg(struct perf_probe_arg *pa) 16807df2f329SMasami Hiramatsu { 16817df2f329SMasami Hiramatsu struct perf_probe_arg_field *field = pa->field; 1682909b0360SMasami Hiramatsu struct strbuf buf; 1683bf4d5f25SMasami Hiramatsu char *ret = NULL; 1684bf4d5f25SMasami Hiramatsu int err; 16857df2f329SMasami Hiramatsu 1686bf4d5f25SMasami Hiramatsu if (strbuf_init(&buf, 64) < 0) 1687bf4d5f25SMasami Hiramatsu return NULL; 1688bf4d5f25SMasami Hiramatsu 168948481938SMasami Hiramatsu if (pa->name && pa->var) 1690bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var); 169148481938SMasami Hiramatsu else 1692bf4d5f25SMasami Hiramatsu err = strbuf_addstr(&buf, pa->name ?: pa->var); 1693bf4d5f25SMasami Hiramatsu if (err) 1694bf4d5f25SMasami Hiramatsu goto out; 16957df2f329SMasami Hiramatsu 16967df2f329SMasami Hiramatsu while (field) { 1697b2a3c12bSMasami Hiramatsu if (field->name[0] == '[') 1698bf4d5f25SMasami Hiramatsu err = strbuf_addstr(&buf, field->name); 1699b2a3c12bSMasami Hiramatsu else 1700bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".", 1701909b0360SMasami Hiramatsu field->name); 17027df2f329SMasami Hiramatsu field = field->next; 1703bf4d5f25SMasami Hiramatsu if (err) 1704bf4d5f25SMasami Hiramatsu goto out; 17057df2f329SMasami Hiramatsu } 170611a1ca35SMasami Hiramatsu 1707909b0360SMasami Hiramatsu if (pa->type) 1708bf4d5f25SMasami Hiramatsu if (strbuf_addf(&buf, ":%s", pa->type) < 0) 1709bf4d5f25SMasami Hiramatsu goto out; 171011a1ca35SMasami Hiramatsu 1711909b0360SMasami Hiramatsu ret = strbuf_detach(&buf, NULL); 1712bf4d5f25SMasami Hiramatsu out: 1713bf4d5f25SMasami Hiramatsu strbuf_release(&buf); 1714146a1439SMasami Hiramatsu return ret; 17157df2f329SMasami Hiramatsu } 17167df2f329SMasami Hiramatsu 17174235b045SMasami Hiramatsu /* Compose only probe point (not argument) */ 1718*c4ff4920SMasami Hiramatsu char *synthesize_perf_probe_point(struct perf_probe_point *pp) 171950656eecSMasami Hiramatsu { 1720909b0360SMasami Hiramatsu struct strbuf buf; 1721bf4d5f25SMasami Hiramatsu char *tmp, *ret = NULL; 1722bf4d5f25SMasami Hiramatsu int len, err = 0; 172350656eecSMasami Hiramatsu 1724bf4d5f25SMasami Hiramatsu if (strbuf_init(&buf, 64) < 0) 1725bf4d5f25SMasami Hiramatsu return NULL; 1726bf4d5f25SMasami Hiramatsu 1727909b0360SMasami Hiramatsu if (pp->function) { 1728bf4d5f25SMasami Hiramatsu if (strbuf_addstr(&buf, pp->function) < 0) 1729bf4d5f25SMasami Hiramatsu goto out; 1730909b0360SMasami Hiramatsu if (pp->offset) 1731bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "+%lu", pp->offset); 1732909b0360SMasami Hiramatsu else if (pp->line) 1733bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, ":%d", pp->line); 1734909b0360SMasami Hiramatsu else if (pp->retprobe) 1735bf4d5f25SMasami Hiramatsu err = strbuf_addstr(&buf, "%return"); 1736bf4d5f25SMasami Hiramatsu if (err) 1737bf4d5f25SMasami Hiramatsu goto out; 1738fb1587d8SMasami Hiramatsu } 1739fb1587d8SMasami Hiramatsu if (pp->file) { 174032ae2adeSFranck Bui-Huu tmp = pp->file; 174132ae2adeSFranck Bui-Huu len = strlen(tmp); 174232ae2adeSFranck Bui-Huu if (len > 30) { 174332ae2adeSFranck Bui-Huu tmp = strchr(pp->file + len - 30, '/'); 174432ae2adeSFranck Bui-Huu tmp = tmp ? tmp + 1 : pp->file + len - 30; 174532ae2adeSFranck Bui-Huu } 1746bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "@%s", tmp); 1747bf4d5f25SMasami Hiramatsu if (!err && !pp->function && pp->line) 1748bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, ":%d", pp->line); 17494de189feSMasami Hiramatsu } 1750bf4d5f25SMasami Hiramatsu if (!err) 1751bf4d5f25SMasami Hiramatsu ret = strbuf_detach(&buf, NULL); 1752bf4d5f25SMasami Hiramatsu out: 1753bf4d5f25SMasami Hiramatsu strbuf_release(&buf); 1754bf4d5f25SMasami Hiramatsu return ret; 17554235b045SMasami Hiramatsu } 17564235b045SMasami Hiramatsu 17574235b045SMasami Hiramatsu char *synthesize_perf_probe_command(struct perf_probe_event *pev) 17584235b045SMasami Hiramatsu { 1759*c4ff4920SMasami Hiramatsu struct strbuf buf; 1760*c4ff4920SMasami Hiramatsu char *tmp, *ret = NULL; 1761*c4ff4920SMasami Hiramatsu int i; 17624235b045SMasami Hiramatsu 1763*c4ff4920SMasami Hiramatsu if (strbuf_init(&buf, 64)) 17644235b045SMasami Hiramatsu return NULL; 1765*c4ff4920SMasami Hiramatsu if (pev->event) 1766*c4ff4920SMasami Hiramatsu if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP, 1767*c4ff4920SMasami Hiramatsu pev->event) < 0) 1768*c4ff4920SMasami Hiramatsu goto out; 17694235b045SMasami Hiramatsu 1770*c4ff4920SMasami Hiramatsu tmp = synthesize_perf_probe_point(&pev->point); 1771*c4ff4920SMasami Hiramatsu if (!tmp || strbuf_addstr(&buf, tmp) < 0) 1772*c4ff4920SMasami Hiramatsu goto out; 1773*c4ff4920SMasami Hiramatsu free(tmp); 1774*c4ff4920SMasami Hiramatsu 17754235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 1776*c4ff4920SMasami Hiramatsu tmp = synthesize_perf_probe_arg(pev->args + i); 1777*c4ff4920SMasami Hiramatsu if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0) 1778*c4ff4920SMasami Hiramatsu goto out; 1779*c4ff4920SMasami Hiramatsu free(tmp); 17807ef17aafSMasami Hiramatsu } 178150656eecSMasami Hiramatsu 1782*c4ff4920SMasami Hiramatsu ret = strbuf_detach(&buf, NULL); 1783*c4ff4920SMasami Hiramatsu out: 1784*c4ff4920SMasami Hiramatsu strbuf_release(&buf); 1785*c4ff4920SMasami Hiramatsu return ret; 17864235b045SMasami Hiramatsu } 17874235b045SMasami Hiramatsu 17880e60836bSSrikar Dronamraju static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref, 1789909b0360SMasami Hiramatsu struct strbuf *buf, int depth) 17907ef17aafSMasami Hiramatsu { 1791bf4d5f25SMasami Hiramatsu int err; 17924235b045SMasami Hiramatsu if (ref->next) { 17930e60836bSSrikar Dronamraju depth = __synthesize_probe_trace_arg_ref(ref->next, buf, 1794909b0360SMasami Hiramatsu depth + 1); 17954235b045SMasami Hiramatsu if (depth < 0) 17964235b045SMasami Hiramatsu return depth; 17974235b045SMasami Hiramatsu } 1798bf4d5f25SMasami Hiramatsu err = strbuf_addf(buf, "%+ld(", ref->offset); 1799bf4d5f25SMasami Hiramatsu return (err < 0) ? err : depth; 1800bf4d5f25SMasami Hiramatsu } 18014235b045SMasami Hiramatsu 18020e60836bSSrikar Dronamraju static int synthesize_probe_trace_arg(struct probe_trace_arg *arg, 1803909b0360SMasami Hiramatsu struct strbuf *buf) 18044235b045SMasami Hiramatsu { 18050e60836bSSrikar Dronamraju struct probe_trace_arg_ref *ref = arg->ref; 1806bf4d5f25SMasami Hiramatsu int depth = 0, err; 18074235b045SMasami Hiramatsu 18084235b045SMasami Hiramatsu /* Argument name or separator */ 18094235b045SMasami Hiramatsu if (arg->name) 1810bf4d5f25SMasami Hiramatsu err = strbuf_addf(buf, " %s=", arg->name); 18114235b045SMasami Hiramatsu else 1812bf4d5f25SMasami Hiramatsu err = strbuf_addch(buf, ' '); 1813bf4d5f25SMasami Hiramatsu if (err) 1814bf4d5f25SMasami Hiramatsu return err; 18154235b045SMasami Hiramatsu 1816b7dcb857SMasami Hiramatsu /* Special case: @XXX */ 1817b7dcb857SMasami Hiramatsu if (arg->value[0] == '@' && arg->ref) 1818b7dcb857SMasami Hiramatsu ref = ref->next; 1819b7dcb857SMasami Hiramatsu 18204235b045SMasami Hiramatsu /* Dereferencing arguments */ 1821b7dcb857SMasami Hiramatsu if (ref) { 1822909b0360SMasami Hiramatsu depth = __synthesize_probe_trace_arg_ref(ref, buf, 1); 18234235b045SMasami Hiramatsu if (depth < 0) 18244235b045SMasami Hiramatsu return depth; 18254235b045SMasami Hiramatsu } 18264235b045SMasami Hiramatsu 18274235b045SMasami Hiramatsu /* Print argument value */ 1828b7dcb857SMasami Hiramatsu if (arg->value[0] == '@' && arg->ref) 1829bf4d5f25SMasami Hiramatsu err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset); 1830b7dcb857SMasami Hiramatsu else 1831bf4d5f25SMasami Hiramatsu err = strbuf_addstr(buf, arg->value); 18324235b045SMasami Hiramatsu 18334235b045SMasami Hiramatsu /* Closing */ 1834bf4d5f25SMasami Hiramatsu while (!err && depth--) 1835bf4d5f25SMasami Hiramatsu err = strbuf_addch(buf, ')'); 18364235b045SMasami Hiramatsu 1837bf4d5f25SMasami Hiramatsu /* Print argument type */ 1838bf4d5f25SMasami Hiramatsu if (!err && arg->type) 1839bf4d5f25SMasami Hiramatsu err = strbuf_addf(buf, ":%s", arg->type); 1840bf4d5f25SMasami Hiramatsu 1841bf4d5f25SMasami Hiramatsu return err; 18424235b045SMasami Hiramatsu } 18434235b045SMasami Hiramatsu 18440e60836bSSrikar Dronamraju char *synthesize_probe_trace_command(struct probe_trace_event *tev) 18454235b045SMasami Hiramatsu { 18460e60836bSSrikar Dronamraju struct probe_trace_point *tp = &tev->point; 1847909b0360SMasami Hiramatsu struct strbuf buf; 1848909b0360SMasami Hiramatsu char *ret = NULL; 1849bf4d5f25SMasami Hiramatsu int i, err; 1850eb948e50SMasami Hiramatsu 1851da15bd9dSWang Nan /* Uprobes must have tp->module */ 1852da15bd9dSWang Nan if (tev->uprobes && !tp->module) 1853909b0360SMasami Hiramatsu return NULL; 1854909b0360SMasami Hiramatsu 1855bf4d5f25SMasami Hiramatsu if (strbuf_init(&buf, 32) < 0) 1856bf4d5f25SMasami Hiramatsu return NULL; 1857bf4d5f25SMasami Hiramatsu 1858bf4d5f25SMasami Hiramatsu if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p', 1859bf4d5f25SMasami Hiramatsu tev->group, tev->event) < 0) 1860bf4d5f25SMasami Hiramatsu goto error; 1861da15bd9dSWang Nan /* 1862da15bd9dSWang Nan * If tp->address == 0, then this point must be a 1863da15bd9dSWang Nan * absolute address uprobe. 1864da15bd9dSWang Nan * try_to_find_absolute_address() should have made 1865da15bd9dSWang Nan * tp->symbol to "0x0". 1866da15bd9dSWang Nan */ 1867da15bd9dSWang Nan if (tev->uprobes && !tp->address) { 1868da15bd9dSWang Nan if (!tp->symbol || strcmp(tp->symbol, "0x0")) 1869da15bd9dSWang Nan goto error; 1870da15bd9dSWang Nan } 1871eb948e50SMasami Hiramatsu 1872eb948e50SMasami Hiramatsu /* Use the tp->address for uprobes */ 1873225466f1SSrikar Dronamraju if (tev->uprobes) 1874bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s:0x%lx", tp->module, tp->address); 1875da15bd9dSWang Nan else if (!strncmp(tp->symbol, "0x", 2)) 1876da15bd9dSWang Nan /* Absolute address. See try_to_find_absolute_address() */ 1877bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "", 1878909b0360SMasami Hiramatsu tp->module ? ":" : "", tp->address); 1879225466f1SSrikar Dronamraju else 1880bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "", 1881909b0360SMasami Hiramatsu tp->module ? ":" : "", tp->symbol, tp->offset); 1882bf4d5f25SMasami Hiramatsu if (err) 1883bf4d5f25SMasami Hiramatsu goto error; 1884225466f1SSrikar Dronamraju 1885909b0360SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) 1886909b0360SMasami Hiramatsu if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0) 18874235b045SMasami Hiramatsu goto error; 18887ef17aafSMasami Hiramatsu 1889909b0360SMasami Hiramatsu ret = strbuf_detach(&buf, NULL); 189050656eecSMasami Hiramatsu error: 1891909b0360SMasami Hiramatsu strbuf_release(&buf); 1892909b0360SMasami Hiramatsu return ret; 189350656eecSMasami Hiramatsu } 189450656eecSMasami Hiramatsu 18955a6f6314SMasami Hiramatsu static int find_perf_probe_point_from_map(struct probe_trace_point *tp, 18965a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 18975a6f6314SMasami Hiramatsu bool is_kprobe) 18985a6f6314SMasami Hiramatsu { 18995a6f6314SMasami Hiramatsu struct symbol *sym = NULL; 19005a6f6314SMasami Hiramatsu struct map *map; 1901e486367fSWang Nan u64 addr = tp->address; 19025a6f6314SMasami Hiramatsu int ret = -ENOENT; 19035a6f6314SMasami Hiramatsu 19045a6f6314SMasami Hiramatsu if (!is_kprobe) { 19055a6f6314SMasami Hiramatsu map = dso__new_map(tp->module); 19065a6f6314SMasami Hiramatsu if (!map) 19075a6f6314SMasami Hiramatsu goto out; 19085a6f6314SMasami Hiramatsu sym = map__find_symbol(map, addr, NULL); 19095a6f6314SMasami Hiramatsu } else { 19109b239a12SMasami Hiramatsu if (tp->symbol && !addr) { 19110a62f686SMasami Hiramatsu if (kernel_get_symbol_address_by_name(tp->symbol, 19120a62f686SMasami Hiramatsu &addr, true, false) < 0) 19139b239a12SMasami Hiramatsu goto out; 19149b239a12SMasami Hiramatsu } 19155a6f6314SMasami Hiramatsu if (addr) { 19165a6f6314SMasami Hiramatsu addr += tp->offset; 19175a6f6314SMasami Hiramatsu sym = __find_kernel_function(addr, &map); 19185a6f6314SMasami Hiramatsu } 19195a6f6314SMasami Hiramatsu } 192098d3b258SWang Nan 19215a6f6314SMasami Hiramatsu if (!sym) 19225a6f6314SMasami Hiramatsu goto out; 19235a6f6314SMasami Hiramatsu 19245a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 19255a6f6314SMasami Hiramatsu pp->offset = addr - map->unmap_ip(map, sym->start); 19265a6f6314SMasami Hiramatsu pp->function = strdup(sym->name); 19275a6f6314SMasami Hiramatsu ret = pp->function ? 0 : -ENOMEM; 19285a6f6314SMasami Hiramatsu 19295a6f6314SMasami Hiramatsu out: 19305a6f6314SMasami Hiramatsu if (map && !is_kprobe) { 193184c2cafaSArnaldo Carvalho de Melo map__put(map); 19325a6f6314SMasami Hiramatsu } 19335a6f6314SMasami Hiramatsu 19345a6f6314SMasami Hiramatsu return ret; 19355a6f6314SMasami Hiramatsu } 19365a6f6314SMasami Hiramatsu 19375a6f6314SMasami Hiramatsu static int convert_to_perf_probe_point(struct probe_trace_point *tp, 19385a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 19395a6f6314SMasami Hiramatsu bool is_kprobe) 19405a6f6314SMasami Hiramatsu { 19415a6f6314SMasami Hiramatsu char buf[128]; 19425a6f6314SMasami Hiramatsu int ret; 19435a6f6314SMasami Hiramatsu 19445a6f6314SMasami Hiramatsu ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe); 19455a6f6314SMasami Hiramatsu if (!ret) 19465a6f6314SMasami Hiramatsu return 0; 19475a6f6314SMasami Hiramatsu ret = find_perf_probe_point_from_map(tp, pp, is_kprobe); 19485a6f6314SMasami Hiramatsu if (!ret) 19495a6f6314SMasami Hiramatsu return 0; 19505a6f6314SMasami Hiramatsu 19515a6f6314SMasami Hiramatsu pr_debug("Failed to find probe point from both of dwarf and map.\n"); 19525a6f6314SMasami Hiramatsu 19535a6f6314SMasami Hiramatsu if (tp->symbol) { 19545a6f6314SMasami Hiramatsu pp->function = strdup(tp->symbol); 19555a6f6314SMasami Hiramatsu pp->offset = tp->offset; 1956614e2fdbSWang Nan } else { 19575a6f6314SMasami Hiramatsu ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address); 19585a6f6314SMasami Hiramatsu if (ret < 0) 19595a6f6314SMasami Hiramatsu return ret; 19605a6f6314SMasami Hiramatsu pp->function = strdup(buf); 19615a6f6314SMasami Hiramatsu pp->offset = 0; 19625a6f6314SMasami Hiramatsu } 19635a6f6314SMasami Hiramatsu if (pp->function == NULL) 19645a6f6314SMasami Hiramatsu return -ENOMEM; 19655a6f6314SMasami Hiramatsu 19665a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 19675a6f6314SMasami Hiramatsu 19685a6f6314SMasami Hiramatsu return 0; 19695a6f6314SMasami Hiramatsu } 19705a6f6314SMasami Hiramatsu 19710e60836bSSrikar Dronamraju static int convert_to_perf_probe_event(struct probe_trace_event *tev, 1972225466f1SSrikar Dronamraju struct perf_probe_event *pev, bool is_kprobe) 19734de189feSMasami Hiramatsu { 1974909b0360SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 1975146a1439SMasami Hiramatsu int i, ret; 19764de189feSMasami Hiramatsu 19774b4da7f7SMasami Hiramatsu /* Convert event/group name */ 197802b95dadSMasami Hiramatsu pev->event = strdup(tev->event); 197902b95dadSMasami Hiramatsu pev->group = strdup(tev->group); 198002b95dadSMasami Hiramatsu if (pev->event == NULL || pev->group == NULL) 198102b95dadSMasami Hiramatsu return -ENOMEM; 1982fb1587d8SMasami Hiramatsu 19834b4da7f7SMasami Hiramatsu /* Convert trace_point to probe_point */ 19845a6f6314SMasami Hiramatsu ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe); 1985146a1439SMasami Hiramatsu if (ret < 0) 1986146a1439SMasami Hiramatsu return ret; 19874b4da7f7SMasami Hiramatsu 19884235b045SMasami Hiramatsu /* Convert trace_arg to probe_arg */ 19894235b045SMasami Hiramatsu pev->nargs = tev->nargs; 1990e334016fSMasami Hiramatsu pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs); 1991e334016fSMasami Hiramatsu if (pev->args == NULL) 1992e334016fSMasami Hiramatsu return -ENOMEM; 199302b95dadSMasami Hiramatsu for (i = 0; i < tev->nargs && ret >= 0; i++) { 19944235b045SMasami Hiramatsu if (tev->args[i].name) 199502b95dadSMasami Hiramatsu pev->args[i].name = strdup(tev->args[i].name); 19964235b045SMasami Hiramatsu else { 1997bf4d5f25SMasami Hiramatsu if ((ret = strbuf_init(&buf, 32)) < 0) 1998bf4d5f25SMasami Hiramatsu goto error; 1999909b0360SMasami Hiramatsu ret = synthesize_probe_trace_arg(&tev->args[i], &buf); 2000909b0360SMasami Hiramatsu pev->args[i].name = strbuf_detach(&buf, NULL); 200102b95dadSMasami Hiramatsu } 200202b95dadSMasami Hiramatsu if (pev->args[i].name == NULL && ret >= 0) 200302b95dadSMasami Hiramatsu ret = -ENOMEM; 20044de189feSMasami Hiramatsu } 2005bf4d5f25SMasami Hiramatsu error: 2006146a1439SMasami Hiramatsu if (ret < 0) 2007146a1439SMasami Hiramatsu clear_perf_probe_event(pev); 2008146a1439SMasami Hiramatsu 2009146a1439SMasami Hiramatsu return ret; 20104235b045SMasami Hiramatsu } 20114de189feSMasami Hiramatsu 20124235b045SMasami Hiramatsu void clear_perf_probe_event(struct perf_probe_event *pev) 20134235b045SMasami Hiramatsu { 20147df2f329SMasami Hiramatsu struct perf_probe_arg_field *field, *next; 20154235b045SMasami Hiramatsu int i; 20164de189feSMasami Hiramatsu 20174235b045SMasami Hiramatsu free(pev->event); 20184235b045SMasami Hiramatsu free(pev->group); 20197afb3fabSMasami Hiramatsu free(pev->target); 20209b118acaSMasami Hiramatsu clear_perf_probe_point(&pev->point); 2021f5385650SArnaldo Carvalho de Melo 20227df2f329SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 20234235b045SMasami Hiramatsu free(pev->args[i].name); 202448481938SMasami Hiramatsu free(pev->args[i].var); 202511a1ca35SMasami Hiramatsu free(pev->args[i].type); 20267df2f329SMasami Hiramatsu field = pev->args[i].field; 20277df2f329SMasami Hiramatsu while (field) { 20287df2f329SMasami Hiramatsu next = field->next; 202974cf249dSArnaldo Carvalho de Melo zfree(&field->name); 20307df2f329SMasami Hiramatsu free(field); 20317df2f329SMasami Hiramatsu field = next; 20327df2f329SMasami Hiramatsu } 20337df2f329SMasami Hiramatsu } 20344235b045SMasami Hiramatsu free(pev->args); 20354235b045SMasami Hiramatsu memset(pev, 0, sizeof(*pev)); 20364235b045SMasami Hiramatsu } 20374235b045SMasami Hiramatsu 20380542bb9cSMasami Hiramatsu #define strdup_or_goto(str, label) \ 20390542bb9cSMasami Hiramatsu ({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; }) 20400542bb9cSMasami Hiramatsu 20410542bb9cSMasami Hiramatsu static int perf_probe_point__copy(struct perf_probe_point *dst, 20420542bb9cSMasami Hiramatsu struct perf_probe_point *src) 20430542bb9cSMasami Hiramatsu { 20440542bb9cSMasami Hiramatsu dst->file = strdup_or_goto(src->file, out_err); 20450542bb9cSMasami Hiramatsu dst->function = strdup_or_goto(src->function, out_err); 20460542bb9cSMasami Hiramatsu dst->lazy_line = strdup_or_goto(src->lazy_line, out_err); 20470542bb9cSMasami Hiramatsu dst->line = src->line; 20480542bb9cSMasami Hiramatsu dst->retprobe = src->retprobe; 20490542bb9cSMasami Hiramatsu dst->offset = src->offset; 20500542bb9cSMasami Hiramatsu return 0; 20510542bb9cSMasami Hiramatsu 20520542bb9cSMasami Hiramatsu out_err: 20530542bb9cSMasami Hiramatsu clear_perf_probe_point(dst); 20540542bb9cSMasami Hiramatsu return -ENOMEM; 20550542bb9cSMasami Hiramatsu } 20560542bb9cSMasami Hiramatsu 20570542bb9cSMasami Hiramatsu static int perf_probe_arg__copy(struct perf_probe_arg *dst, 20580542bb9cSMasami Hiramatsu struct perf_probe_arg *src) 20590542bb9cSMasami Hiramatsu { 20600542bb9cSMasami Hiramatsu struct perf_probe_arg_field *field, **ppfield; 20610542bb9cSMasami Hiramatsu 20620542bb9cSMasami Hiramatsu dst->name = strdup_or_goto(src->name, out_err); 20630542bb9cSMasami Hiramatsu dst->var = strdup_or_goto(src->var, out_err); 20640542bb9cSMasami Hiramatsu dst->type = strdup_or_goto(src->type, out_err); 20650542bb9cSMasami Hiramatsu 20660542bb9cSMasami Hiramatsu field = src->field; 20670542bb9cSMasami Hiramatsu ppfield = &(dst->field); 20680542bb9cSMasami Hiramatsu while (field) { 20690542bb9cSMasami Hiramatsu *ppfield = zalloc(sizeof(*field)); 20700542bb9cSMasami Hiramatsu if (!*ppfield) 20710542bb9cSMasami Hiramatsu goto out_err; 20720542bb9cSMasami Hiramatsu (*ppfield)->name = strdup_or_goto(field->name, out_err); 20730542bb9cSMasami Hiramatsu (*ppfield)->index = field->index; 20740542bb9cSMasami Hiramatsu (*ppfield)->ref = field->ref; 20750542bb9cSMasami Hiramatsu field = field->next; 20760542bb9cSMasami Hiramatsu ppfield = &((*ppfield)->next); 20770542bb9cSMasami Hiramatsu } 20780542bb9cSMasami Hiramatsu return 0; 20790542bb9cSMasami Hiramatsu out_err: 20800542bb9cSMasami Hiramatsu return -ENOMEM; 20810542bb9cSMasami Hiramatsu } 20820542bb9cSMasami Hiramatsu 20830542bb9cSMasami Hiramatsu int perf_probe_event__copy(struct perf_probe_event *dst, 20840542bb9cSMasami Hiramatsu struct perf_probe_event *src) 20850542bb9cSMasami Hiramatsu { 20860542bb9cSMasami Hiramatsu int i; 20870542bb9cSMasami Hiramatsu 20880542bb9cSMasami Hiramatsu dst->event = strdup_or_goto(src->event, out_err); 20890542bb9cSMasami Hiramatsu dst->group = strdup_or_goto(src->group, out_err); 20900542bb9cSMasami Hiramatsu dst->target = strdup_or_goto(src->target, out_err); 20910542bb9cSMasami Hiramatsu dst->uprobes = src->uprobes; 20920542bb9cSMasami Hiramatsu 20930542bb9cSMasami Hiramatsu if (perf_probe_point__copy(&dst->point, &src->point) < 0) 20940542bb9cSMasami Hiramatsu goto out_err; 20950542bb9cSMasami Hiramatsu 20960542bb9cSMasami Hiramatsu dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs); 20970542bb9cSMasami Hiramatsu if (!dst->args) 20980542bb9cSMasami Hiramatsu goto out_err; 20990542bb9cSMasami Hiramatsu dst->nargs = src->nargs; 21000542bb9cSMasami Hiramatsu 21010542bb9cSMasami Hiramatsu for (i = 0; i < src->nargs; i++) 21020542bb9cSMasami Hiramatsu if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0) 21030542bb9cSMasami Hiramatsu goto out_err; 21040542bb9cSMasami Hiramatsu return 0; 21050542bb9cSMasami Hiramatsu 21060542bb9cSMasami Hiramatsu out_err: 21070542bb9cSMasami Hiramatsu clear_perf_probe_event(dst); 21080542bb9cSMasami Hiramatsu return -ENOMEM; 21090542bb9cSMasami Hiramatsu } 21100542bb9cSMasami Hiramatsu 211192f6c72eSMasami Hiramatsu void clear_probe_trace_event(struct probe_trace_event *tev) 21124235b045SMasami Hiramatsu { 21130e60836bSSrikar Dronamraju struct probe_trace_arg_ref *ref, *next; 21144235b045SMasami Hiramatsu int i; 21154235b045SMasami Hiramatsu 21164235b045SMasami Hiramatsu free(tev->event); 21174235b045SMasami Hiramatsu free(tev->group); 21184235b045SMasami Hiramatsu free(tev->point.symbol); 21194c859351SMasami Hiramatsu free(tev->point.realname); 2120190b57fcSMasami Hiramatsu free(tev->point.module); 21214235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 21224235b045SMasami Hiramatsu free(tev->args[i].name); 21234235b045SMasami Hiramatsu free(tev->args[i].value); 21244984912eSMasami Hiramatsu free(tev->args[i].type); 21254235b045SMasami Hiramatsu ref = tev->args[i].ref; 21264235b045SMasami Hiramatsu while (ref) { 21274235b045SMasami Hiramatsu next = ref->next; 21284235b045SMasami Hiramatsu free(ref); 21294235b045SMasami Hiramatsu ref = next; 21304235b045SMasami Hiramatsu } 21314235b045SMasami Hiramatsu } 21324235b045SMasami Hiramatsu free(tev->args); 21334235b045SMasami Hiramatsu memset(tev, 0, sizeof(*tev)); 21344de189feSMasami Hiramatsu } 21354de189feSMasami Hiramatsu 21369aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node { 21379aaf5a5fSMasami Hiramatsu struct list_head list; 21389aaf5a5fSMasami Hiramatsu unsigned long start; 21399aaf5a5fSMasami Hiramatsu unsigned long end; 21409aaf5a5fSMasami Hiramatsu char *symbol; 21419aaf5a5fSMasami Hiramatsu }; 21429aaf5a5fSMasami Hiramatsu 21439aaf5a5fSMasami Hiramatsu static void kprobe_blacklist__delete(struct list_head *blacklist) 21449aaf5a5fSMasami Hiramatsu { 21459aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 21469aaf5a5fSMasami Hiramatsu 21479aaf5a5fSMasami Hiramatsu while (!list_empty(blacklist)) { 21489aaf5a5fSMasami Hiramatsu node = list_first_entry(blacklist, 21499aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node, list); 21509aaf5a5fSMasami Hiramatsu list_del(&node->list); 21519aaf5a5fSMasami Hiramatsu free(node->symbol); 21529aaf5a5fSMasami Hiramatsu free(node); 21539aaf5a5fSMasami Hiramatsu } 21549aaf5a5fSMasami Hiramatsu } 21559aaf5a5fSMasami Hiramatsu 21569aaf5a5fSMasami Hiramatsu static int kprobe_blacklist__load(struct list_head *blacklist) 21579aaf5a5fSMasami Hiramatsu { 21589aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 21594605eab3SJiri Olsa const char *__debugfs = debugfs__mountpoint(); 21609aaf5a5fSMasami Hiramatsu char buf[PATH_MAX], *p; 21619aaf5a5fSMasami Hiramatsu FILE *fp; 21629aaf5a5fSMasami Hiramatsu int ret; 21639aaf5a5fSMasami Hiramatsu 21649aaf5a5fSMasami Hiramatsu if (__debugfs == NULL) 21659aaf5a5fSMasami Hiramatsu return -ENOTSUP; 21669aaf5a5fSMasami Hiramatsu 21679aaf5a5fSMasami Hiramatsu ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs); 21689aaf5a5fSMasami Hiramatsu if (ret < 0) 21699aaf5a5fSMasami Hiramatsu return ret; 21709aaf5a5fSMasami Hiramatsu 21719aaf5a5fSMasami Hiramatsu fp = fopen(buf, "r"); 21729aaf5a5fSMasami Hiramatsu if (!fp) 21739aaf5a5fSMasami Hiramatsu return -errno; 21749aaf5a5fSMasami Hiramatsu 21759aaf5a5fSMasami Hiramatsu ret = 0; 21769aaf5a5fSMasami Hiramatsu while (fgets(buf, PATH_MAX, fp)) { 21779aaf5a5fSMasami Hiramatsu node = zalloc(sizeof(*node)); 21789aaf5a5fSMasami Hiramatsu if (!node) { 21799aaf5a5fSMasami Hiramatsu ret = -ENOMEM; 21809aaf5a5fSMasami Hiramatsu break; 21819aaf5a5fSMasami Hiramatsu } 21829aaf5a5fSMasami Hiramatsu INIT_LIST_HEAD(&node->list); 21839aaf5a5fSMasami Hiramatsu list_add_tail(&node->list, blacklist); 21849aaf5a5fSMasami Hiramatsu if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) { 21859aaf5a5fSMasami Hiramatsu ret = -EINVAL; 21869aaf5a5fSMasami Hiramatsu break; 21879aaf5a5fSMasami Hiramatsu } 21889aaf5a5fSMasami Hiramatsu p = strchr(buf, '\t'); 21899aaf5a5fSMasami Hiramatsu if (p) { 21909aaf5a5fSMasami Hiramatsu p++; 21919aaf5a5fSMasami Hiramatsu if (p[strlen(p) - 1] == '\n') 21929aaf5a5fSMasami Hiramatsu p[strlen(p) - 1] = '\0'; 21939aaf5a5fSMasami Hiramatsu } else 21949aaf5a5fSMasami Hiramatsu p = (char *)"unknown"; 21959aaf5a5fSMasami Hiramatsu node->symbol = strdup(p); 21969aaf5a5fSMasami Hiramatsu if (!node->symbol) { 21979aaf5a5fSMasami Hiramatsu ret = -ENOMEM; 21989aaf5a5fSMasami Hiramatsu break; 21999aaf5a5fSMasami Hiramatsu } 22009aaf5a5fSMasami Hiramatsu pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n", 22019aaf5a5fSMasami Hiramatsu node->start, node->end, node->symbol); 22029aaf5a5fSMasami Hiramatsu ret++; 22039aaf5a5fSMasami Hiramatsu } 22049aaf5a5fSMasami Hiramatsu if (ret < 0) 22059aaf5a5fSMasami Hiramatsu kprobe_blacklist__delete(blacklist); 22069aaf5a5fSMasami Hiramatsu fclose(fp); 22079aaf5a5fSMasami Hiramatsu 22089aaf5a5fSMasami Hiramatsu return ret; 22099aaf5a5fSMasami Hiramatsu } 22109aaf5a5fSMasami Hiramatsu 22119aaf5a5fSMasami Hiramatsu static struct kprobe_blacklist_node * 22129aaf5a5fSMasami Hiramatsu kprobe_blacklist__find_by_address(struct list_head *blacklist, 22139aaf5a5fSMasami Hiramatsu unsigned long address) 22149aaf5a5fSMasami Hiramatsu { 22159aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 22169aaf5a5fSMasami Hiramatsu 22179aaf5a5fSMasami Hiramatsu list_for_each_entry(node, blacklist, list) { 22189aaf5a5fSMasami Hiramatsu if (node->start <= address && address <= node->end) 22199aaf5a5fSMasami Hiramatsu return node; 22209aaf5a5fSMasami Hiramatsu } 22219aaf5a5fSMasami Hiramatsu 22229aaf5a5fSMasami Hiramatsu return NULL; 22239aaf5a5fSMasami Hiramatsu } 22249aaf5a5fSMasami Hiramatsu 2225b031220dSMasami Hiramatsu static LIST_HEAD(kprobe_blacklist); 2226b031220dSMasami Hiramatsu 2227b031220dSMasami Hiramatsu static void kprobe_blacklist__init(void) 2228b031220dSMasami Hiramatsu { 2229b031220dSMasami Hiramatsu if (!list_empty(&kprobe_blacklist)) 2230b031220dSMasami Hiramatsu return; 2231b031220dSMasami Hiramatsu 2232b031220dSMasami Hiramatsu if (kprobe_blacklist__load(&kprobe_blacklist) < 0) 2233b031220dSMasami Hiramatsu pr_debug("No kprobe blacklist support, ignored\n"); 2234b031220dSMasami Hiramatsu } 2235b031220dSMasami Hiramatsu 2236b031220dSMasami Hiramatsu static void kprobe_blacklist__release(void) 2237b031220dSMasami Hiramatsu { 2238b031220dSMasami Hiramatsu kprobe_blacklist__delete(&kprobe_blacklist); 2239b031220dSMasami Hiramatsu } 2240b031220dSMasami Hiramatsu 2241b031220dSMasami Hiramatsu static bool kprobe_blacklist__listed(unsigned long address) 2242b031220dSMasami Hiramatsu { 2243b031220dSMasami Hiramatsu return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address); 2244b031220dSMasami Hiramatsu } 2245b031220dSMasami Hiramatsu 2246d350bd57SMasami Hiramatsu static int perf_probe_event__sprintf(const char *group, const char *event, 2247d350bd57SMasami Hiramatsu struct perf_probe_event *pev, 2248ba7ecb02SMasami Hiramatsu const char *module, 2249ba7ecb02SMasami Hiramatsu struct strbuf *result) 2250278498d4SMasami Hiramatsu { 2251bf4d5f25SMasami Hiramatsu int i, ret; 2252909b0360SMasami Hiramatsu char *buf; 2253909b0360SMasami Hiramatsu 2254909b0360SMasami Hiramatsu if (asprintf(&buf, "%s:%s", group, event) < 0) 2255909b0360SMasami Hiramatsu return -errno; 2256bf4d5f25SMasami Hiramatsu ret = strbuf_addf(result, " %-20s (on ", buf); 2257909b0360SMasami Hiramatsu free(buf); 2258bf4d5f25SMasami Hiramatsu if (ret) 2259bf4d5f25SMasami Hiramatsu return ret; 2260278498d4SMasami Hiramatsu 22614235b045SMasami Hiramatsu /* Synthesize only event probe point */ 2262909b0360SMasami Hiramatsu buf = synthesize_perf_probe_point(&pev->point); 2263909b0360SMasami Hiramatsu if (!buf) 2264909b0360SMasami Hiramatsu return -ENOMEM; 2265bf4d5f25SMasami Hiramatsu ret = strbuf_addstr(result, buf); 2266909b0360SMasami Hiramatsu free(buf); 22674235b045SMasami Hiramatsu 2268bf4d5f25SMasami Hiramatsu if (!ret && module) 2269bf4d5f25SMasami Hiramatsu ret = strbuf_addf(result, " in %s", module); 2270278498d4SMasami Hiramatsu 2271bf4d5f25SMasami Hiramatsu if (!ret && pev->nargs > 0) { 2272bf4d5f25SMasami Hiramatsu ret = strbuf_add(result, " with", 5); 2273bf4d5f25SMasami Hiramatsu for (i = 0; !ret && i < pev->nargs; i++) { 2274909b0360SMasami Hiramatsu buf = synthesize_perf_probe_arg(&pev->args[i]); 2275909b0360SMasami Hiramatsu if (!buf) 2276909b0360SMasami Hiramatsu return -ENOMEM; 2277bf4d5f25SMasami Hiramatsu ret = strbuf_addf(result, " %s", buf); 2278909b0360SMasami Hiramatsu free(buf); 22797df2f329SMasami Hiramatsu } 2280278498d4SMasami Hiramatsu } 2281bf4d5f25SMasami Hiramatsu if (!ret) 2282bf4d5f25SMasami Hiramatsu ret = strbuf_addch(result, ')'); 2283909b0360SMasami Hiramatsu 2284bf4d5f25SMasami Hiramatsu return ret; 2285278498d4SMasami Hiramatsu } 2286278498d4SMasami Hiramatsu 2287ba7ecb02SMasami Hiramatsu /* Show an event */ 2288b02137ccSNamhyung Kim int show_perf_probe_event(const char *group, const char *event, 2289d350bd57SMasami Hiramatsu struct perf_probe_event *pev, 2290ba7ecb02SMasami Hiramatsu const char *module, bool use_stdout) 2291ba7ecb02SMasami Hiramatsu { 2292ba7ecb02SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 2293ba7ecb02SMasami Hiramatsu int ret; 2294ba7ecb02SMasami Hiramatsu 2295d350bd57SMasami Hiramatsu ret = perf_probe_event__sprintf(group, event, pev, module, &buf); 2296ba7ecb02SMasami Hiramatsu if (ret >= 0) { 2297ba7ecb02SMasami Hiramatsu if (use_stdout) 2298ba7ecb02SMasami Hiramatsu printf("%s\n", buf.buf); 2299ba7ecb02SMasami Hiramatsu else 2300ba7ecb02SMasami Hiramatsu pr_info("%s\n", buf.buf); 2301ba7ecb02SMasami Hiramatsu } 2302ba7ecb02SMasami Hiramatsu strbuf_release(&buf); 2303ba7ecb02SMasami Hiramatsu 2304ba7ecb02SMasami Hiramatsu return ret; 2305ba7ecb02SMasami Hiramatsu } 2306ba7ecb02SMasami Hiramatsu 2307b6a89643SMasami Hiramatsu static bool filter_probe_trace_event(struct probe_trace_event *tev, 2308b6a89643SMasami Hiramatsu struct strfilter *filter) 2309b6a89643SMasami Hiramatsu { 2310b6a89643SMasami Hiramatsu char tmp[128]; 2311b6a89643SMasami Hiramatsu 2312b6a89643SMasami Hiramatsu /* At first, check the event name itself */ 2313b6a89643SMasami Hiramatsu if (strfilter__compare(filter, tev->event)) 2314b6a89643SMasami Hiramatsu return true; 2315b6a89643SMasami Hiramatsu 2316b6a89643SMasami Hiramatsu /* Next, check the combination of name and group */ 2317b6a89643SMasami Hiramatsu if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0) 2318b6a89643SMasami Hiramatsu return false; 2319b6a89643SMasami Hiramatsu return strfilter__compare(filter, tmp); 2320b6a89643SMasami Hiramatsu } 2321b6a89643SMasami Hiramatsu 2322b6a89643SMasami Hiramatsu static int __show_perf_probe_events(int fd, bool is_kprobe, 2323b6a89643SMasami Hiramatsu struct strfilter *filter) 23244de189feSMasami Hiramatsu { 2325225466f1SSrikar Dronamraju int ret = 0; 23260e60836bSSrikar Dronamraju struct probe_trace_event tev; 23274235b045SMasami Hiramatsu struct perf_probe_event pev; 23284de189feSMasami Hiramatsu struct strlist *rawlist; 23294de189feSMasami Hiramatsu struct str_node *ent; 23304de189feSMasami Hiramatsu 23314235b045SMasami Hiramatsu memset(&tev, 0, sizeof(tev)); 23324235b045SMasami Hiramatsu memset(&pev, 0, sizeof(pev)); 233372041334SMasami Hiramatsu 233492f6c72eSMasami Hiramatsu rawlist = probe_file__get_rawlist(fd); 2335146a1439SMasami Hiramatsu if (!rawlist) 23366eb08660SMasami Hiramatsu return -ENOMEM; 23374de189feSMasami Hiramatsu 2338adf365f4SMasami Hiramatsu strlist__for_each(ent, rawlist) { 23390e60836bSSrikar Dronamraju ret = parse_probe_trace_command(ent->s, &tev); 2340146a1439SMasami Hiramatsu if (ret >= 0) { 2341b6a89643SMasami Hiramatsu if (!filter_probe_trace_event(&tev, filter)) 2342b6a89643SMasami Hiramatsu goto next; 2343225466f1SSrikar Dronamraju ret = convert_to_perf_probe_event(&tev, &pev, 2344225466f1SSrikar Dronamraju is_kprobe); 2345ba7ecb02SMasami Hiramatsu if (ret < 0) 2346ba7ecb02SMasami Hiramatsu goto next; 2347d350bd57SMasami Hiramatsu ret = show_perf_probe_event(pev.group, pev.event, 2348d350bd57SMasami Hiramatsu &pev, tev.point.module, 2349ba7ecb02SMasami Hiramatsu true); 2350146a1439SMasami Hiramatsu } 2351b6a89643SMasami Hiramatsu next: 23524235b045SMasami Hiramatsu clear_perf_probe_event(&pev); 23530e60836bSSrikar Dronamraju clear_probe_trace_event(&tev); 2354146a1439SMasami Hiramatsu if (ret < 0) 2355146a1439SMasami Hiramatsu break; 23564de189feSMasami Hiramatsu } 23574de189feSMasami Hiramatsu strlist__delete(rawlist); 23587737af01SMasami Hiramatsu /* Cleanup cached debuginfo if needed */ 23597737af01SMasami Hiramatsu debuginfo_cache__exit(); 2360146a1439SMasami Hiramatsu 2361146a1439SMasami Hiramatsu return ret; 23624de189feSMasami Hiramatsu } 23634de189feSMasami Hiramatsu 2364225466f1SSrikar Dronamraju /* List up current perf-probe events */ 2365b6a89643SMasami Hiramatsu int show_perf_probe_events(struct strfilter *filter) 2366225466f1SSrikar Dronamraju { 23675e45187cSMasami Hiramatsu int kp_fd, up_fd, ret; 2368225466f1SSrikar Dronamraju 2369225466f1SSrikar Dronamraju setup_pager(); 2370225466f1SSrikar Dronamraju 23719bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(false); 2372225466f1SSrikar Dronamraju if (ret < 0) 2373225466f1SSrikar Dronamraju return ret; 2374225466f1SSrikar Dronamraju 237592f6c72eSMasami Hiramatsu ret = probe_file__open_both(&kp_fd, &up_fd, 0); 23765e45187cSMasami Hiramatsu if (ret < 0) 2377225466f1SSrikar Dronamraju return ret; 2378225466f1SSrikar Dronamraju 237992f6c72eSMasami Hiramatsu if (kp_fd >= 0) 238092f6c72eSMasami Hiramatsu ret = __show_perf_probe_events(kp_fd, true, filter); 238192f6c72eSMasami Hiramatsu if (up_fd >= 0 && ret >= 0) 238292f6c72eSMasami Hiramatsu ret = __show_perf_probe_events(up_fd, false, filter); 238392f6c72eSMasami Hiramatsu if (kp_fd > 0) 238492f6c72eSMasami Hiramatsu close(kp_fd); 238592f6c72eSMasami Hiramatsu if (up_fd > 0) 238692f6c72eSMasami Hiramatsu close(up_fd); 23879bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 2388b498ce1fSMasami Hiramatsu 2389146a1439SMasami Hiramatsu return ret; 2390f4d7da49SMasami Hiramatsu } 239150656eecSMasami Hiramatsu 2392146a1439SMasami Hiramatsu static int get_new_event_name(char *buf, size_t len, const char *base, 2393d761b08bSMasami Hiramatsu struct strlist *namelist, bool allow_suffix) 2394b498ce1fSMasami Hiramatsu { 2395b498ce1fSMasami Hiramatsu int i, ret; 2396663b1151SMasami Hiramatsu char *p, *nbase; 239717f88fcdSMasami Hiramatsu 23983099c026SNaveen N. Rao if (*base == '.') 23993099c026SNaveen N. Rao base++; 2400663b1151SMasami Hiramatsu nbase = strdup(base); 2401663b1151SMasami Hiramatsu if (!nbase) 2402663b1151SMasami Hiramatsu return -ENOMEM; 24033099c026SNaveen N. Rao 2404663b1151SMasami Hiramatsu /* Cut off the dot suffixes (e.g. .const, .isra)*/ 2405663b1151SMasami Hiramatsu p = strchr(nbase, '.'); 2406663b1151SMasami Hiramatsu if (p && p != nbase) 2407663b1151SMasami Hiramatsu *p = '\0'; 2408663b1151SMasami Hiramatsu 2409663b1151SMasami Hiramatsu /* Try no suffix number */ 2410663b1151SMasami Hiramatsu ret = e_snprintf(buf, len, "%s", nbase); 2411146a1439SMasami Hiramatsu if (ret < 0) { 24125f03cba4SMasami Hiramatsu pr_debug("snprintf() failed: %d\n", ret); 2413663b1151SMasami Hiramatsu goto out; 2414146a1439SMasami Hiramatsu } 241517f88fcdSMasami Hiramatsu if (!strlist__has_entry(namelist, buf)) 2416663b1151SMasami Hiramatsu goto out; 241717f88fcdSMasami Hiramatsu 2418d761b08bSMasami Hiramatsu if (!allow_suffix) { 241903e01f56SWang Nan pr_warning("Error: event \"%s\" already exists.\n" 242003e01f56SWang Nan " Hint: Remove existing event by 'perf probe -d'\n" 242103e01f56SWang Nan " or force duplicates by 'perf probe -f'\n" 242203e01f56SWang Nan " or set 'force=yes' in BPF source.\n", 242303e01f56SWang Nan buf); 2424663b1151SMasami Hiramatsu ret = -EEXIST; 2425663b1151SMasami Hiramatsu goto out; 2426d761b08bSMasami Hiramatsu } 2427d761b08bSMasami Hiramatsu 242817f88fcdSMasami Hiramatsu /* Try to add suffix */ 242917f88fcdSMasami Hiramatsu for (i = 1; i < MAX_EVENT_INDEX; i++) { 2430663b1151SMasami Hiramatsu ret = e_snprintf(buf, len, "%s_%d", nbase, i); 2431146a1439SMasami Hiramatsu if (ret < 0) { 24325f03cba4SMasami Hiramatsu pr_debug("snprintf() failed: %d\n", ret); 2433663b1151SMasami Hiramatsu goto out; 2434146a1439SMasami Hiramatsu } 2435b498ce1fSMasami Hiramatsu if (!strlist__has_entry(namelist, buf)) 2436b498ce1fSMasami Hiramatsu break; 2437b498ce1fSMasami Hiramatsu } 2438146a1439SMasami Hiramatsu if (i == MAX_EVENT_INDEX) { 2439146a1439SMasami Hiramatsu pr_warning("Too many events are on the same function.\n"); 2440146a1439SMasami Hiramatsu ret = -ERANGE; 2441b498ce1fSMasami Hiramatsu } 2442b498ce1fSMasami Hiramatsu 2443663b1151SMasami Hiramatsu out: 2444663b1151SMasami Hiramatsu free(nbase); 2445146a1439SMasami Hiramatsu return ret; 2446146a1439SMasami Hiramatsu } 2447146a1439SMasami Hiramatsu 244879702f61SMasami Hiramatsu /* Warn if the current kernel's uprobe implementation is old */ 244979702f61SMasami Hiramatsu static void warn_uprobe_event_compat(struct probe_trace_event *tev) 245079702f61SMasami Hiramatsu { 245179702f61SMasami Hiramatsu int i; 245279702f61SMasami Hiramatsu char *buf = synthesize_probe_trace_command(tev); 245379702f61SMasami Hiramatsu 245479702f61SMasami Hiramatsu /* Old uprobe event doesn't support memory dereference */ 245579702f61SMasami Hiramatsu if (!tev->uprobes || tev->nargs == 0 || !buf) 245679702f61SMasami Hiramatsu goto out; 245779702f61SMasami Hiramatsu 245879702f61SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) 245979702f61SMasami Hiramatsu if (strglobmatch(tev->args[i].value, "[$@+-]*")) { 246079702f61SMasami Hiramatsu pr_warning("Please upgrade your kernel to at least " 246179702f61SMasami Hiramatsu "3.14 to have access to feature %s\n", 246279702f61SMasami Hiramatsu tev->args[i].value); 246379702f61SMasami Hiramatsu break; 246479702f61SMasami Hiramatsu } 246579702f61SMasami Hiramatsu out: 246679702f61SMasami Hiramatsu free(buf); 246779702f61SMasami Hiramatsu } 246879702f61SMasami Hiramatsu 2469a3c9de62SMasami Hiramatsu /* Set new name from original perf_probe_event and namelist */ 2470a3c9de62SMasami Hiramatsu static int probe_trace_event__set_name(struct probe_trace_event *tev, 2471a3c9de62SMasami Hiramatsu struct perf_probe_event *pev, 2472a3c9de62SMasami Hiramatsu struct strlist *namelist, 2473a3c9de62SMasami Hiramatsu bool allow_suffix) 2474a3c9de62SMasami Hiramatsu { 2475a3c9de62SMasami Hiramatsu const char *event, *group; 2476a3c9de62SMasami Hiramatsu char buf[64]; 2477a3c9de62SMasami Hiramatsu int ret; 2478a3c9de62SMasami Hiramatsu 2479a3c9de62SMasami Hiramatsu if (pev->event) 2480a3c9de62SMasami Hiramatsu event = pev->event; 2481a3c9de62SMasami Hiramatsu else 2482da15bd9dSWang Nan if (pev->point.function && 2483da15bd9dSWang Nan (strncmp(pev->point.function, "0x", 2) != 0) && 2484da15bd9dSWang Nan !strisglob(pev->point.function)) 2485a3c9de62SMasami Hiramatsu event = pev->point.function; 2486a3c9de62SMasami Hiramatsu else 2487a3c9de62SMasami Hiramatsu event = tev->point.realname; 2488a3c9de62SMasami Hiramatsu if (pev->group) 2489a3c9de62SMasami Hiramatsu group = pev->group; 2490a3c9de62SMasami Hiramatsu else 2491a3c9de62SMasami Hiramatsu group = PERFPROBE_GROUP; 2492a3c9de62SMasami Hiramatsu 2493a3c9de62SMasami Hiramatsu /* Get an unused new event name */ 2494a3c9de62SMasami Hiramatsu ret = get_new_event_name(buf, 64, event, 2495a3c9de62SMasami Hiramatsu namelist, allow_suffix); 2496a3c9de62SMasami Hiramatsu if (ret < 0) 2497a3c9de62SMasami Hiramatsu return ret; 2498a3c9de62SMasami Hiramatsu 2499a3c9de62SMasami Hiramatsu event = buf; 2500a3c9de62SMasami Hiramatsu 2501a3c9de62SMasami Hiramatsu tev->event = strdup(event); 2502a3c9de62SMasami Hiramatsu tev->group = strdup(group); 2503a3c9de62SMasami Hiramatsu if (tev->event == NULL || tev->group == NULL) 2504a3c9de62SMasami Hiramatsu return -ENOMEM; 2505a3c9de62SMasami Hiramatsu 2506a3c9de62SMasami Hiramatsu /* Add added event name to namelist */ 2507a3c9de62SMasami Hiramatsu strlist__add(namelist, event); 2508a3c9de62SMasami Hiramatsu return 0; 2509a3c9de62SMasami Hiramatsu } 2510a3c9de62SMasami Hiramatsu 25110e60836bSSrikar Dronamraju static int __add_probe_trace_events(struct perf_probe_event *pev, 25120e60836bSSrikar Dronamraju struct probe_trace_event *tevs, 25134235b045SMasami Hiramatsu int ntevs, bool allow_suffix) 251450656eecSMasami Hiramatsu { 2515146a1439SMasami Hiramatsu int i, fd, ret; 25160e60836bSSrikar Dronamraju struct probe_trace_event *tev = NULL; 2517b498ce1fSMasami Hiramatsu struct strlist *namelist; 251850656eecSMasami Hiramatsu 251992f6c72eSMasami Hiramatsu fd = probe_file__open(PF_FL_RW | (pev->uprobes ? PF_FL_UPROBE : 0)); 252092f6c72eSMasami Hiramatsu if (fd < 0) 2521146a1439SMasami Hiramatsu return fd; 25225e45187cSMasami Hiramatsu 2523b498ce1fSMasami Hiramatsu /* Get current event names */ 252492f6c72eSMasami Hiramatsu namelist = probe_file__get_namelist(fd); 2525146a1439SMasami Hiramatsu if (!namelist) { 2526146a1439SMasami Hiramatsu pr_debug("Failed to get current event list.\n"); 2527ae2cb1acSMasami Hiramatsu ret = -ENOMEM; 2528ae2cb1acSMasami Hiramatsu goto close_out; 2529146a1439SMasami Hiramatsu } 253050656eecSMasami Hiramatsu 2531146a1439SMasami Hiramatsu ret = 0; 253202b95dadSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 25334235b045SMasami Hiramatsu tev = &tevs[i]; 2534b031220dSMasami Hiramatsu /* Skip if the symbol is out of .text or blacklisted */ 25355a51fcd1SMasami Hiramatsu if (!tev->point.symbol) 25365a51fcd1SMasami Hiramatsu continue; 25379aaf5a5fSMasami Hiramatsu 2538a3c9de62SMasami Hiramatsu /* Set new name for tev (and update namelist) */ 2539a3c9de62SMasami Hiramatsu ret = probe_trace_event__set_name(tev, pev, namelist, 2540a3c9de62SMasami Hiramatsu allow_suffix); 2541146a1439SMasami Hiramatsu if (ret < 0) 2542146a1439SMasami Hiramatsu break; 25434235b045SMasami Hiramatsu 254492f6c72eSMasami Hiramatsu ret = probe_file__add_event(fd, tev); 2545146a1439SMasami Hiramatsu if (ret < 0) 2546146a1439SMasami Hiramatsu break; 25474235b045SMasami Hiramatsu 2548d761b08bSMasami Hiramatsu /* 2549d761b08bSMasami Hiramatsu * Probes after the first probe which comes from same 2550d761b08bSMasami Hiramatsu * user input are always allowed to add suffix, because 2551d761b08bSMasami Hiramatsu * there might be several addresses corresponding to 2552d761b08bSMasami Hiramatsu * one code line. 2553d761b08bSMasami Hiramatsu */ 2554d761b08bSMasami Hiramatsu allow_suffix = true; 255550656eecSMasami Hiramatsu } 255679702f61SMasami Hiramatsu if (ret == -EINVAL && pev->uprobes) 255779702f61SMasami Hiramatsu warn_uprobe_event_compat(tev); 2558146a1439SMasami Hiramatsu 2559e1d2017bSMasami Hiramatsu strlist__delete(namelist); 2560ae2cb1acSMasami Hiramatsu close_out: 256150656eecSMasami Hiramatsu close(fd); 2562146a1439SMasami Hiramatsu return ret; 256350656eecSMasami Hiramatsu } 2564fa28244dSMasami Hiramatsu 25656bb536ccSWang Nan static int find_probe_functions(struct map *map, char *name, 25666bb536ccSWang Nan struct symbol **syms) 2567eb948e50SMasami Hiramatsu { 2568564c62a4SNamhyung Kim int found = 0; 25690a3873a8SArnaldo Carvalho de Melo struct symbol *sym; 25704c859351SMasami Hiramatsu struct rb_node *tmp; 2571564c62a4SNamhyung Kim 257275e4a2a6SWang Nan if (map__load(map, NULL) < 0) 257375e4a2a6SWang Nan return 0; 257475e4a2a6SWang Nan 25754c859351SMasami Hiramatsu map__for_each_symbol(map, sym, tmp) { 25766bb536ccSWang Nan if (strglobmatch(sym->name, name)) { 2577564c62a4SNamhyung Kim found++; 25786bb536ccSWang Nan if (syms && found < probe_conf.max_probes) 25796bb536ccSWang Nan syms[found - 1] = sym; 25806bb536ccSWang Nan } 2581eb948e50SMasami Hiramatsu } 2582564c62a4SNamhyung Kim 2583564c62a4SNamhyung Kim return found; 2584eb948e50SMasami Hiramatsu } 2585eb948e50SMasami Hiramatsu 25867b6ff0bdSNaveen N. Rao void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused, 25877b6ff0bdSNaveen N. Rao struct probe_trace_event *tev __maybe_unused, 25880b3c2264SNaveen N. Rao struct map *map __maybe_unused, 25890b3c2264SNaveen N. Rao struct symbol *sym __maybe_unused) { } 25907b6ff0bdSNaveen N. Rao 2591eb948e50SMasami Hiramatsu /* 2592eb948e50SMasami Hiramatsu * Find probe function addresses from map. 2593eb948e50SMasami Hiramatsu * Return an error or the number of found probe_trace_event 2594eb948e50SMasami Hiramatsu */ 2595eb948e50SMasami Hiramatsu static int find_probe_trace_events_from_map(struct perf_probe_event *pev, 2596ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs) 2597eb948e50SMasami Hiramatsu { 2598eb948e50SMasami Hiramatsu struct map *map = NULL; 2599eb948e50SMasami Hiramatsu struct ref_reloc_sym *reloc_sym = NULL; 2600eb948e50SMasami Hiramatsu struct symbol *sym; 26016bb536ccSWang Nan struct symbol **syms = NULL; 2602eb948e50SMasami Hiramatsu struct probe_trace_event *tev; 2603eb948e50SMasami Hiramatsu struct perf_probe_point *pp = &pev->point; 2604eb948e50SMasami Hiramatsu struct probe_trace_point *tp; 2605564c62a4SNamhyung Kim int num_matched_functions; 2606b031220dSMasami Hiramatsu int ret, i, j, skipped = 0; 2607c61fb959SRavi Bangoria char *mod_name; 2608eb948e50SMasami Hiramatsu 260944225521SMasami Hiramatsu map = get_target_map(pev->target, pev->uprobes); 2610eb948e50SMasami Hiramatsu if (!map) { 2611eb948e50SMasami Hiramatsu ret = -EINVAL; 2612eb948e50SMasami Hiramatsu goto out; 2613eb948e50SMasami Hiramatsu } 2614eb948e50SMasami Hiramatsu 26156bb536ccSWang Nan syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes); 26166bb536ccSWang Nan if (!syms) { 26176bb536ccSWang Nan ret = -ENOMEM; 26186bb536ccSWang Nan goto out; 26196bb536ccSWang Nan } 26206bb536ccSWang Nan 2621eb948e50SMasami Hiramatsu /* 2622eb948e50SMasami Hiramatsu * Load matched symbols: Since the different local symbols may have 2623eb948e50SMasami Hiramatsu * same name but different addresses, this lists all the symbols. 2624eb948e50SMasami Hiramatsu */ 26256bb536ccSWang Nan num_matched_functions = find_probe_functions(map, pp->function, syms); 2626564c62a4SNamhyung Kim if (num_matched_functions == 0) { 2627eb948e50SMasami Hiramatsu pr_err("Failed to find symbol %s in %s\n", pp->function, 262844225521SMasami Hiramatsu pev->target ? : "kernel"); 2629eb948e50SMasami Hiramatsu ret = -ENOENT; 2630eb948e50SMasami Hiramatsu goto out; 2631ddb2f58fSMasami Hiramatsu } else if (num_matched_functions > probe_conf.max_probes) { 2632eb948e50SMasami Hiramatsu pr_err("Too many functions matched in %s\n", 263344225521SMasami Hiramatsu pev->target ? : "kernel"); 2634eb948e50SMasami Hiramatsu ret = -E2BIG; 2635eb948e50SMasami Hiramatsu goto out; 2636eb948e50SMasami Hiramatsu } 2637eb948e50SMasami Hiramatsu 26381a8ac29cSMasami Hiramatsu /* Note that the symbols in the kmodule are not relocated */ 26391a8ac29cSMasami Hiramatsu if (!pev->uprobes && !pp->retprobe && !pev->target) { 26400560a0c4SHe Kuang reloc_sym = kernel_get_ref_reloc_sym(); 2641eb948e50SMasami Hiramatsu if (!reloc_sym) { 2642eb948e50SMasami Hiramatsu pr_warning("Relocated base symbol is not found!\n"); 2643eb948e50SMasami Hiramatsu ret = -EINVAL; 2644eb948e50SMasami Hiramatsu goto out; 2645eb948e50SMasami Hiramatsu } 2646eb948e50SMasami Hiramatsu } 2647eb948e50SMasami Hiramatsu 2648eb948e50SMasami Hiramatsu /* Setup result trace-probe-events */ 2649eb948e50SMasami Hiramatsu *tevs = zalloc(sizeof(*tev) * num_matched_functions); 2650eb948e50SMasami Hiramatsu if (!*tevs) { 2651eb948e50SMasami Hiramatsu ret = -ENOMEM; 2652eb948e50SMasami Hiramatsu goto out; 2653eb948e50SMasami Hiramatsu } 2654eb948e50SMasami Hiramatsu 2655eb948e50SMasami Hiramatsu ret = 0; 2656564c62a4SNamhyung Kim 26576bb536ccSWang Nan for (j = 0; j < num_matched_functions; j++) { 26586bb536ccSWang Nan sym = syms[j]; 26596bb536ccSWang Nan 2660eb948e50SMasami Hiramatsu tev = (*tevs) + ret; 2661eb948e50SMasami Hiramatsu tp = &tev->point; 2662eb948e50SMasami Hiramatsu if (ret == num_matched_functions) { 2663eb948e50SMasami Hiramatsu pr_warning("Too many symbols are listed. Skip it.\n"); 2664eb948e50SMasami Hiramatsu break; 2665eb948e50SMasami Hiramatsu } 2666eb948e50SMasami Hiramatsu ret++; 2667eb948e50SMasami Hiramatsu 2668eb948e50SMasami Hiramatsu if (pp->offset > sym->end - sym->start) { 2669eb948e50SMasami Hiramatsu pr_warning("Offset %ld is bigger than the size of %s\n", 2670eb948e50SMasami Hiramatsu pp->offset, sym->name); 2671eb948e50SMasami Hiramatsu ret = -ENOENT; 2672eb948e50SMasami Hiramatsu goto err_out; 2673eb948e50SMasami Hiramatsu } 2674eb948e50SMasami Hiramatsu /* Add one probe point */ 2675eb948e50SMasami Hiramatsu tp->address = map->unmap_ip(map, sym->start) + pp->offset; 26761a8ac29cSMasami Hiramatsu 26771a8ac29cSMasami Hiramatsu /* Check the kprobe (not in module) is within .text */ 26781a8ac29cSMasami Hiramatsu if (!pev->uprobes && !pev->target && 2679b031220dSMasami Hiramatsu kprobe_warn_out_range(sym->name, tp->address)) { 2680b031220dSMasami Hiramatsu tp->symbol = NULL; /* Skip it */ 2681b031220dSMasami Hiramatsu skipped++; 2682b031220dSMasami Hiramatsu } else if (reloc_sym) { 2683eb948e50SMasami Hiramatsu tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out); 2684eb948e50SMasami Hiramatsu tp->offset = tp->address - reloc_sym->addr; 2685eb948e50SMasami Hiramatsu } else { 2686eb948e50SMasami Hiramatsu tp->symbol = strdup_or_goto(sym->name, nomem_out); 2687eb948e50SMasami Hiramatsu tp->offset = pp->offset; 2688eb948e50SMasami Hiramatsu } 26896bb536ccSWang Nan tp->realname = strdup_or_goto(sym->name, nomem_out); 26906bb536ccSWang Nan 2691eb948e50SMasami Hiramatsu tp->retprobe = pp->retprobe; 2692c61fb959SRavi Bangoria if (pev->target) { 2693c61fb959SRavi Bangoria if (pev->uprobes) { 269444225521SMasami Hiramatsu tev->point.module = strdup_or_goto(pev->target, 269544225521SMasami Hiramatsu nomem_out); 2696c61fb959SRavi Bangoria } else { 2697c61fb959SRavi Bangoria mod_name = find_module_name(pev->target); 2698c61fb959SRavi Bangoria tev->point.module = 2699c61fb959SRavi Bangoria strdup(mod_name ? mod_name : pev->target); 2700c61fb959SRavi Bangoria free(mod_name); 2701c61fb959SRavi Bangoria if (!tev->point.module) 2702c61fb959SRavi Bangoria goto nomem_out; 2703c61fb959SRavi Bangoria } 2704c61fb959SRavi Bangoria } 2705eb948e50SMasami Hiramatsu tev->uprobes = pev->uprobes; 2706eb948e50SMasami Hiramatsu tev->nargs = pev->nargs; 2707eb948e50SMasami Hiramatsu if (tev->nargs) { 2708eb948e50SMasami Hiramatsu tev->args = zalloc(sizeof(struct probe_trace_arg) * 2709eb948e50SMasami Hiramatsu tev->nargs); 2710eb948e50SMasami Hiramatsu if (tev->args == NULL) 2711eb948e50SMasami Hiramatsu goto nomem_out; 2712eb948e50SMasami Hiramatsu } 2713eb948e50SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 2714eb948e50SMasami Hiramatsu if (pev->args[i].name) 2715eb948e50SMasami Hiramatsu tev->args[i].name = 2716eb948e50SMasami Hiramatsu strdup_or_goto(pev->args[i].name, 2717eb948e50SMasami Hiramatsu nomem_out); 2718eb948e50SMasami Hiramatsu 2719eb948e50SMasami Hiramatsu tev->args[i].value = strdup_or_goto(pev->args[i].var, 2720eb948e50SMasami Hiramatsu nomem_out); 2721eb948e50SMasami Hiramatsu if (pev->args[i].type) 2722eb948e50SMasami Hiramatsu tev->args[i].type = 2723eb948e50SMasami Hiramatsu strdup_or_goto(pev->args[i].type, 2724eb948e50SMasami Hiramatsu nomem_out); 2725eb948e50SMasami Hiramatsu } 27260b3c2264SNaveen N. Rao arch__fix_tev_from_maps(pev, tev, map, sym); 2727eb948e50SMasami Hiramatsu } 2728b031220dSMasami Hiramatsu if (ret == skipped) { 2729b031220dSMasami Hiramatsu ret = -ENOENT; 2730b031220dSMasami Hiramatsu goto err_out; 2731b031220dSMasami Hiramatsu } 2732eb948e50SMasami Hiramatsu 2733eb948e50SMasami Hiramatsu out: 27349b118acaSMasami Hiramatsu put_target_map(map, pev->uprobes); 27356bb536ccSWang Nan free(syms); 2736eb948e50SMasami Hiramatsu return ret; 2737eb948e50SMasami Hiramatsu 2738eb948e50SMasami Hiramatsu nomem_out: 2739eb948e50SMasami Hiramatsu ret = -ENOMEM; 2740eb948e50SMasami Hiramatsu err_out: 2741eb948e50SMasami Hiramatsu clear_probe_trace_events(*tevs, num_matched_functions); 2742eb948e50SMasami Hiramatsu zfree(tevs); 2743eb948e50SMasami Hiramatsu goto out; 2744eb948e50SMasami Hiramatsu } 2745eb948e50SMasami Hiramatsu 2746da15bd9dSWang Nan static int try_to_find_absolute_address(struct perf_probe_event *pev, 2747da15bd9dSWang Nan struct probe_trace_event **tevs) 2748da15bd9dSWang Nan { 2749da15bd9dSWang Nan struct perf_probe_point *pp = &pev->point; 2750da15bd9dSWang Nan struct probe_trace_event *tev; 2751da15bd9dSWang Nan struct probe_trace_point *tp; 2752da15bd9dSWang Nan int i, err; 2753da15bd9dSWang Nan 2754da15bd9dSWang Nan if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2))) 2755da15bd9dSWang Nan return -EINVAL; 2756da15bd9dSWang Nan if (perf_probe_event_need_dwarf(pev)) 2757da15bd9dSWang Nan return -EINVAL; 2758da15bd9dSWang Nan 2759da15bd9dSWang Nan /* 2760da15bd9dSWang Nan * This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at 2761da15bd9dSWang Nan * absolute address. 2762da15bd9dSWang Nan * 2763da15bd9dSWang Nan * Only one tev can be generated by this. 2764da15bd9dSWang Nan */ 2765da15bd9dSWang Nan *tevs = zalloc(sizeof(*tev)); 2766da15bd9dSWang Nan if (!*tevs) 2767da15bd9dSWang Nan return -ENOMEM; 2768da15bd9dSWang Nan 2769da15bd9dSWang Nan tev = *tevs; 2770da15bd9dSWang Nan tp = &tev->point; 2771da15bd9dSWang Nan 2772da15bd9dSWang Nan /* 2773da15bd9dSWang Nan * Don't use tp->offset, use address directly, because 2774da15bd9dSWang Nan * in synthesize_probe_trace_command() address cannot be 2775da15bd9dSWang Nan * zero. 2776da15bd9dSWang Nan */ 2777da15bd9dSWang Nan tp->address = pev->point.abs_address; 2778da15bd9dSWang Nan tp->retprobe = pp->retprobe; 2779da15bd9dSWang Nan tev->uprobes = pev->uprobes; 2780da15bd9dSWang Nan 2781da15bd9dSWang Nan err = -ENOMEM; 2782da15bd9dSWang Nan /* 2783da15bd9dSWang Nan * Give it a '0x' leading symbol name. 2784da15bd9dSWang Nan * In __add_probe_trace_events, a NULL symbol is interpreted as 2785da15bd9dSWang Nan * invalud. 2786da15bd9dSWang Nan */ 2787da15bd9dSWang Nan if (asprintf(&tp->symbol, "0x%lx", tp->address) < 0) 2788da15bd9dSWang Nan goto errout; 2789da15bd9dSWang Nan 2790da15bd9dSWang Nan /* For kprobe, check range */ 2791da15bd9dSWang Nan if ((!tev->uprobes) && 2792da15bd9dSWang Nan (kprobe_warn_out_range(tev->point.symbol, 2793da15bd9dSWang Nan tev->point.address))) { 2794da15bd9dSWang Nan err = -EACCES; 2795da15bd9dSWang Nan goto errout; 2796da15bd9dSWang Nan } 2797da15bd9dSWang Nan 2798da15bd9dSWang Nan if (asprintf(&tp->realname, "abs_%lx", tp->address) < 0) 2799da15bd9dSWang Nan goto errout; 2800da15bd9dSWang Nan 2801da15bd9dSWang Nan if (pev->target) { 2802da15bd9dSWang Nan tp->module = strdup(pev->target); 2803da15bd9dSWang Nan if (!tp->module) 2804da15bd9dSWang Nan goto errout; 2805da15bd9dSWang Nan } 2806da15bd9dSWang Nan 2807da15bd9dSWang Nan if (tev->group) { 2808da15bd9dSWang Nan tev->group = strdup(pev->group); 2809da15bd9dSWang Nan if (!tev->group) 2810da15bd9dSWang Nan goto errout; 2811da15bd9dSWang Nan } 2812da15bd9dSWang Nan 2813da15bd9dSWang Nan if (pev->event) { 2814da15bd9dSWang Nan tev->event = strdup(pev->event); 2815da15bd9dSWang Nan if (!tev->event) 2816da15bd9dSWang Nan goto errout; 2817da15bd9dSWang Nan } 2818da15bd9dSWang Nan 2819da15bd9dSWang Nan tev->nargs = pev->nargs; 2820da15bd9dSWang Nan tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); 2821da15bd9dSWang Nan if (!tev->args) { 2822da15bd9dSWang Nan err = -ENOMEM; 2823da15bd9dSWang Nan goto errout; 2824da15bd9dSWang Nan } 2825da15bd9dSWang Nan for (i = 0; i < tev->nargs; i++) 2826da15bd9dSWang Nan copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]); 2827da15bd9dSWang Nan 2828da15bd9dSWang Nan return 1; 2829da15bd9dSWang Nan 2830da15bd9dSWang Nan errout: 2831da15bd9dSWang Nan if (*tevs) { 2832da15bd9dSWang Nan clear_probe_trace_events(*tevs, 1); 2833da15bd9dSWang Nan *tevs = NULL; 2834da15bd9dSWang Nan } 2835da15bd9dSWang Nan return err; 2836da15bd9dSWang Nan } 2837da15bd9dSWang Nan 2838d5c2e2c1SNaveen N. Rao bool __weak arch__prefers_symtab(void) { return false; } 2839d5c2e2c1SNaveen N. Rao 28400e60836bSSrikar Dronamraju static int convert_to_probe_trace_events(struct perf_probe_event *pev, 2841ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs) 2842e0faa8d3SMasami Hiramatsu { 2843eb948e50SMasami Hiramatsu int ret; 28444235b045SMasami Hiramatsu 28452a12ec13SMasami Hiramatsu if (!pev->group) { 28462a12ec13SMasami Hiramatsu /* Set group name if not given */ 28472a12ec13SMasami Hiramatsu if (!pev->uprobes) { 28482a12ec13SMasami Hiramatsu pev->group = strdup(PERFPROBE_GROUP); 28492a12ec13SMasami Hiramatsu ret = pev->group ? 0 : -ENOMEM; 28502a12ec13SMasami Hiramatsu } else 285144225521SMasami Hiramatsu ret = convert_exec_to_group(pev->target, &pev->group); 2852fb7345bbSMasami Hiramatsu if (ret != 0) { 2853fb7345bbSMasami Hiramatsu pr_warning("Failed to make a group name.\n"); 2854fb7345bbSMasami Hiramatsu return ret; 2855fb7345bbSMasami Hiramatsu } 2856fb7345bbSMasami Hiramatsu } 2857fb7345bbSMasami Hiramatsu 2858da15bd9dSWang Nan ret = try_to_find_absolute_address(pev, tevs); 2859da15bd9dSWang Nan if (ret > 0) 2860da15bd9dSWang Nan return ret; 2861da15bd9dSWang Nan 2862d5c2e2c1SNaveen N. Rao if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) { 2863ddb2f58fSMasami Hiramatsu ret = find_probe_trace_events_from_map(pev, tevs); 2864d5c2e2c1SNaveen N. Rao if (ret > 0) 2865d5c2e2c1SNaveen N. Rao return ret; /* Found in symbol table */ 2866d5c2e2c1SNaveen N. Rao } 2867d5c2e2c1SNaveen N. Rao 28684b4da7f7SMasami Hiramatsu /* Convert perf_probe_event with debuginfo */ 2869ddb2f58fSMasami Hiramatsu ret = try_to_find_probe_trace_events(pev, tevs); 2870e334016fSMasami Hiramatsu if (ret != 0) 2871190b57fcSMasami Hiramatsu return ret; /* Found in debuginfo or got an error */ 2872e0faa8d3SMasami Hiramatsu 2873ddb2f58fSMasami Hiramatsu return find_probe_trace_events_from_map(pev, tevs); 28744235b045SMasami Hiramatsu } 28754235b045SMasami Hiramatsu 287612fae5efSWang Nan int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs) 28774235b045SMasami Hiramatsu { 2878844dffa5SNamhyung Kim int i, ret; 28794235b045SMasami Hiramatsu 28804235b045SMasami Hiramatsu /* Loop 1: convert all events */ 28814235b045SMasami Hiramatsu for (i = 0; i < npevs; i++) { 2882b031220dSMasami Hiramatsu /* Init kprobe blacklist if needed */ 288312fae5efSWang Nan if (!pevs[i].uprobes) 2884b031220dSMasami Hiramatsu kprobe_blacklist__init(); 28854235b045SMasami Hiramatsu /* Convert with or without debuginfo */ 288612fae5efSWang Nan ret = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs); 2887146a1439SMasami Hiramatsu if (ret < 0) 2888844dffa5SNamhyung Kim return ret; 288912fae5efSWang Nan pevs[i].ntevs = ret; 28904235b045SMasami Hiramatsu } 2891b031220dSMasami Hiramatsu /* This just release blacklist only if allocated */ 2892b031220dSMasami Hiramatsu kprobe_blacklist__release(); 28934235b045SMasami Hiramatsu 2894844dffa5SNamhyung Kim return 0; 2895844dffa5SNamhyung Kim } 2896844dffa5SNamhyung Kim 289712fae5efSWang Nan int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs) 2898844dffa5SNamhyung Kim { 2899844dffa5SNamhyung Kim int i, ret = 0; 2900844dffa5SNamhyung Kim 29014235b045SMasami Hiramatsu /* Loop 2: add all events */ 29028635bf6eSArnaldo Carvalho de Melo for (i = 0; i < npevs; i++) { 290312fae5efSWang Nan ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs, 290412fae5efSWang Nan pevs[i].ntevs, 2905ddb2f58fSMasami Hiramatsu probe_conf.force_add); 2906fbee632dSArnaldo Carvalho de Melo if (ret < 0) 2907fbee632dSArnaldo Carvalho de Melo break; 2908fbee632dSArnaldo Carvalho de Melo } 2909844dffa5SNamhyung Kim return ret; 2910844dffa5SNamhyung Kim } 2911844dffa5SNamhyung Kim 291212fae5efSWang Nan void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs) 2913844dffa5SNamhyung Kim { 2914844dffa5SNamhyung Kim int i, j; 2915844dffa5SNamhyung Kim 2916449e5b24SMasami Hiramatsu /* Loop 3: cleanup and free trace events */ 2917449e5b24SMasami Hiramatsu for (i = 0; i < npevs; i++) { 291812fae5efSWang Nan for (j = 0; j < pevs[i].ntevs; j++) 291912fae5efSWang Nan clear_probe_trace_event(&pevs[i].tevs[j]); 292012fae5efSWang Nan zfree(&pevs[i].tevs); 292112fae5efSWang Nan pevs[i].ntevs = 0; 2922a43aac29SNamhyung Kim clear_perf_probe_event(&pevs[i]); 2923449e5b24SMasami Hiramatsu } 2924844dffa5SNamhyung Kim } 2925844dffa5SNamhyung Kim 2926844dffa5SNamhyung Kim int add_perf_probe_events(struct perf_probe_event *pevs, int npevs) 2927844dffa5SNamhyung Kim { 2928844dffa5SNamhyung Kim int ret; 2929844dffa5SNamhyung Kim 29309bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(pevs->uprobes); 29319bae1e8cSNamhyung Kim if (ret < 0) 29329bae1e8cSNamhyung Kim return ret; 29339bae1e8cSNamhyung Kim 293412fae5efSWang Nan ret = convert_perf_probe_events(pevs, npevs); 2935844dffa5SNamhyung Kim if (ret == 0) 293612fae5efSWang Nan ret = apply_perf_probe_events(pevs, npevs); 2937844dffa5SNamhyung Kim 293812fae5efSWang Nan cleanup_perf_probe_events(pevs, npevs); 2939146a1439SMasami Hiramatsu 29409bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 2941146a1439SMasami Hiramatsu return ret; 2942e0faa8d3SMasami Hiramatsu } 2943e0faa8d3SMasami Hiramatsu 2944307a464bSMasami Hiramatsu int del_perf_probe_events(struct strfilter *filter) 2945fa28244dSMasami Hiramatsu { 2946307a464bSMasami Hiramatsu int ret, ret2, ufd = -1, kfd = -1; 2947307a464bSMasami Hiramatsu char *str = strfilter__string(filter); 2948307a464bSMasami Hiramatsu 2949307a464bSMasami Hiramatsu if (!str) 2950307a464bSMasami Hiramatsu return -EINVAL; 2951307a464bSMasami Hiramatsu 2952fa28244dSMasami Hiramatsu /* Get current event names */ 295392f6c72eSMasami Hiramatsu ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW); 295492f6c72eSMasami Hiramatsu if (ret < 0) 295592f6c72eSMasami Hiramatsu goto out; 2956225466f1SSrikar Dronamraju 295792f6c72eSMasami Hiramatsu ret = probe_file__del_events(kfd, filter); 2958307a464bSMasami Hiramatsu if (ret < 0 && ret != -ENOENT) 2959225466f1SSrikar Dronamraju goto error; 2960fa28244dSMasami Hiramatsu 296192f6c72eSMasami Hiramatsu ret2 = probe_file__del_events(ufd, filter); 2962dddc7ee3SMasami Hiramatsu if (ret2 < 0 && ret2 != -ENOENT) { 29636dbe31f7SMasami Hiramatsu ret = ret2; 2964dddc7ee3SMasami Hiramatsu goto error; 2965dddc7ee3SMasami Hiramatsu } 2966307a464bSMasami Hiramatsu ret = 0; 2967225466f1SSrikar Dronamraju 2968225466f1SSrikar Dronamraju error: 296992f6c72eSMasami Hiramatsu if (kfd >= 0) 2970225466f1SSrikar Dronamraju close(kfd); 297192f6c72eSMasami Hiramatsu if (ufd >= 0) 2972225466f1SSrikar Dronamraju close(ufd); 297392f6c72eSMasami Hiramatsu out: 2974307a464bSMasami Hiramatsu free(str); 2975146a1439SMasami Hiramatsu 2976146a1439SMasami Hiramatsu return ret; 2977fa28244dSMasami Hiramatsu } 2978225466f1SSrikar Dronamraju 29793c42258cSMasami Hiramatsu /* TODO: don't use a global variable for filter ... */ 29803c42258cSMasami Hiramatsu static struct strfilter *available_func_filter; 2981fa28244dSMasami Hiramatsu 2982e80711caSMasami Hiramatsu /* 29833c42258cSMasami Hiramatsu * If a symbol corresponds to a function with global binding and 29843c42258cSMasami Hiramatsu * matches filter return 0. For all others return 1. 2985e80711caSMasami Hiramatsu */ 29861d037ca1SIrina Tirdea static int filter_available_functions(struct map *map __maybe_unused, 2987e80711caSMasami Hiramatsu struct symbol *sym) 2988e80711caSMasami Hiramatsu { 2989e578da3bSNamhyung Kim if (strfilter__compare(available_func_filter, sym->name)) 2990e80711caSMasami Hiramatsu return 0; 29913c42258cSMasami Hiramatsu return 1; 2992e80711caSMasami Hiramatsu } 2993e80711caSMasami Hiramatsu 29942df58634SMasami Hiramatsu int show_available_funcs(const char *target, struct strfilter *_filter, 29952df58634SMasami Hiramatsu bool user) 2996e80711caSMasami Hiramatsu { 29972df58634SMasami Hiramatsu struct map *map; 29982df58634SMasami Hiramatsu int ret; 29992df58634SMasami Hiramatsu 30009bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(user); 30012df58634SMasami Hiramatsu if (ret < 0) 30022df58634SMasami Hiramatsu return ret; 30032df58634SMasami Hiramatsu 30042df58634SMasami Hiramatsu /* Get a symbol map */ 30052df58634SMasami Hiramatsu if (user) 30062df58634SMasami Hiramatsu map = dso__new_map(target); 30072df58634SMasami Hiramatsu else 30082df58634SMasami Hiramatsu map = kernel_get_module_map(target); 30092df58634SMasami Hiramatsu if (!map) { 30102df58634SMasami Hiramatsu pr_err("Failed to get a map for %s\n", (target) ? : "kernel"); 3011e80711caSMasami Hiramatsu return -EINVAL; 3012e80711caSMasami Hiramatsu } 30132df58634SMasami Hiramatsu 30142df58634SMasami Hiramatsu /* Load symbols with given filter */ 30152df58634SMasami Hiramatsu available_func_filter = _filter; 30162df58634SMasami Hiramatsu if (map__load(map, filter_available_functions)) { 30172df58634SMasami Hiramatsu pr_err("Failed to load symbols in %s\n", (target) ? : "kernel"); 30182df58634SMasami Hiramatsu goto end; 30192df58634SMasami Hiramatsu } 3020e80711caSMasami Hiramatsu if (!dso__sorted_by_name(map->dso, map->type)) 3021e80711caSMasami Hiramatsu dso__sort_by_name(map->dso, map->type); 3022e80711caSMasami Hiramatsu 30232df58634SMasami Hiramatsu /* Show all (filtered) symbols */ 30242df58634SMasami Hiramatsu setup_pager(); 3025e80711caSMasami Hiramatsu dso__fprintf_symbols_by_name(map->dso, map->type, stdout); 30262df58634SMasami Hiramatsu end: 30272df58634SMasami Hiramatsu if (user) { 302884c2cafaSArnaldo Carvalho de Melo map__put(map); 3029225466f1SSrikar Dronamraju } 30309bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 3031225466f1SSrikar Dronamraju 30322df58634SMasami Hiramatsu return ret; 3033225466f1SSrikar Dronamraju } 3034225466f1SSrikar Dronamraju 3035da15bd9dSWang Nan int copy_to_probe_trace_arg(struct probe_trace_arg *tvar, 3036da15bd9dSWang Nan struct perf_probe_arg *pvar) 3037da15bd9dSWang Nan { 3038da15bd9dSWang Nan tvar->value = strdup(pvar->var); 3039da15bd9dSWang Nan if (tvar->value == NULL) 3040da15bd9dSWang Nan return -ENOMEM; 3041da15bd9dSWang Nan if (pvar->type) { 3042da15bd9dSWang Nan tvar->type = strdup(pvar->type); 3043da15bd9dSWang Nan if (tvar->type == NULL) 3044da15bd9dSWang Nan return -ENOMEM; 3045da15bd9dSWang Nan } 3046da15bd9dSWang Nan if (pvar->name) { 3047da15bd9dSWang Nan tvar->name = strdup(pvar->name); 3048da15bd9dSWang Nan if (tvar->name == NULL) 3049da15bd9dSWang Nan return -ENOMEM; 3050da15bd9dSWang Nan } else 3051da15bd9dSWang Nan tvar->name = NULL; 3052da15bd9dSWang Nan return 0; 3053da15bd9dSWang Nan } 3054