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 machine__delete(host_machine); 106ee45b6c2SMasami Hiramatsu host_machine = NULL; 107ee45b6c2SMasami Hiramatsu symbol__exit(); 108ee45b6c2SMasami Hiramatsu } 109ee45b6c2SMasami Hiramatsu 110469b9b88SMasami Hiramatsu static struct symbol *__find_kernel_function_by_name(const char *name, 111469b9b88SMasami Hiramatsu struct map **mapp) 112e0faa8d3SMasami Hiramatsu { 113ee45b6c2SMasami Hiramatsu return machine__find_kernel_function_by_name(host_machine, name, mapp, 114469b9b88SMasami Hiramatsu NULL); 115e0faa8d3SMasami Hiramatsu } 116469b9b88SMasami Hiramatsu 1178f33f7deSMasami Hiramatsu static struct symbol *__find_kernel_function(u64 addr, struct map **mapp) 1188f33f7deSMasami Hiramatsu { 1198f33f7deSMasami Hiramatsu return machine__find_kernel_function(host_machine, addr, mapp, NULL); 1208f33f7deSMasami Hiramatsu } 1218f33f7deSMasami Hiramatsu 1228f33f7deSMasami Hiramatsu static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void) 1238f33f7deSMasami Hiramatsu { 1248f33f7deSMasami Hiramatsu /* kmap->ref_reloc_sym should be set if host_machine is initialized */ 1258f33f7deSMasami Hiramatsu struct kmap *kmap; 126a5e813c6SArnaldo Carvalho de Melo struct map *map = machine__kernel_map(host_machine); 1278f33f7deSMasami Hiramatsu 12877e65977SArnaldo Carvalho de Melo if (map__load(map, NULL) < 0) 1298f33f7deSMasami Hiramatsu return NULL; 1308f33f7deSMasami Hiramatsu 13177e65977SArnaldo Carvalho de Melo kmap = map__kmap(map); 132ba92732eSWang Nan if (!kmap) 133ba92732eSWang Nan return NULL; 1348f33f7deSMasami Hiramatsu return kmap->ref_reloc_sym; 1358f33f7deSMasami Hiramatsu } 1368f33f7deSMasami Hiramatsu 1379b239a12SMasami Hiramatsu static int kernel_get_symbol_address_by_name(const char *name, u64 *addr, 1389b239a12SMasami Hiramatsu bool reloc, bool reladdr) 1398f33f7deSMasami Hiramatsu { 1408f33f7deSMasami Hiramatsu struct ref_reloc_sym *reloc_sym; 1418f33f7deSMasami Hiramatsu struct symbol *sym; 1428f33f7deSMasami Hiramatsu struct map *map; 1438f33f7deSMasami Hiramatsu 1448f33f7deSMasami Hiramatsu /* ref_reloc_sym is just a label. Need a special fix*/ 1458f33f7deSMasami Hiramatsu reloc_sym = kernel_get_ref_reloc_sym(); 1468f33f7deSMasami Hiramatsu if (reloc_sym && strcmp(name, reloc_sym->name) == 0) 1479b239a12SMasami Hiramatsu *addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr; 1488f33f7deSMasami Hiramatsu else { 1498f33f7deSMasami Hiramatsu sym = __find_kernel_function_by_name(name, &map); 1509b239a12SMasami Hiramatsu if (!sym) 1519b239a12SMasami Hiramatsu return -ENOENT; 1529b239a12SMasami Hiramatsu *addr = map->unmap_ip(map, sym->start) - 1539b239a12SMasami Hiramatsu ((reloc) ? 0 : map->reloc) - 1549b239a12SMasami Hiramatsu ((reladdr) ? map->start : 0); 1558f33f7deSMasami Hiramatsu } 1568f33f7deSMasami Hiramatsu return 0; 1578f33f7deSMasami Hiramatsu } 1588f33f7deSMasami Hiramatsu 159e80711caSMasami Hiramatsu static struct map *kernel_get_module_map(const char *module) 160e80711caSMasami Hiramatsu { 161ee45b6c2SMasami Hiramatsu struct map_groups *grp = &host_machine->kmaps; 1621eee78aeSArnaldo Carvalho de Melo struct maps *maps = &grp->maps[MAP__FUNCTION]; 1634bb7123dSArnaldo Carvalho de Melo struct map *pos; 164e80711caSMasami Hiramatsu 16514a8fd7cSMasami Hiramatsu /* A file path -- this is an offline module */ 16614a8fd7cSMasami Hiramatsu if (module && strchr(module, '/')) 1679f2de315SArnaldo Carvalho de Melo return machine__findnew_module_map(host_machine, 0, module); 16814a8fd7cSMasami Hiramatsu 169e80711caSMasami Hiramatsu if (!module) 170e80711caSMasami Hiramatsu module = "kernel"; 171e80711caSMasami Hiramatsu 1724bb7123dSArnaldo Carvalho de Melo for (pos = maps__first(maps); pos; pos = map__next(pos)) { 173e80711caSMasami Hiramatsu if (strncmp(pos->dso->short_name + 1, module, 174e80711caSMasami Hiramatsu pos->dso->short_name_len - 2) == 0) { 175e80711caSMasami Hiramatsu return pos; 176e80711caSMasami Hiramatsu } 177e80711caSMasami Hiramatsu } 178e80711caSMasami Hiramatsu return NULL; 179e80711caSMasami Hiramatsu } 180e80711caSMasami Hiramatsu 1819b118acaSMasami Hiramatsu static struct map *get_target_map(const char *target, bool user) 1829b118acaSMasami Hiramatsu { 1839b118acaSMasami Hiramatsu /* Init maps of given executable or kernel */ 1849b118acaSMasami Hiramatsu if (user) 1859b118acaSMasami Hiramatsu return dso__new_map(target); 1869b118acaSMasami Hiramatsu else 1879b118acaSMasami Hiramatsu return kernel_get_module_map(target); 1889b118acaSMasami Hiramatsu } 1899b118acaSMasami Hiramatsu 1909b118acaSMasami Hiramatsu static void put_target_map(struct map *map, bool user) 1919b118acaSMasami Hiramatsu { 1929b118acaSMasami Hiramatsu if (map && user) { 1939b118acaSMasami Hiramatsu /* Only the user map needs to be released */ 19484c2cafaSArnaldo Carvalho de Melo map__put(map); 1959b118acaSMasami Hiramatsu } 1969b118acaSMasami Hiramatsu } 1979b118acaSMasami Hiramatsu 1989b118acaSMasami Hiramatsu 199fb7345bbSMasami Hiramatsu static int convert_exec_to_group(const char *exec, char **result) 200fb7345bbSMasami Hiramatsu { 201fb7345bbSMasami Hiramatsu char *ptr1, *ptr2, *exec_copy; 202fb7345bbSMasami Hiramatsu char buf[64]; 203fb7345bbSMasami Hiramatsu int ret; 204fb7345bbSMasami Hiramatsu 205fb7345bbSMasami Hiramatsu exec_copy = strdup(exec); 206fb7345bbSMasami Hiramatsu if (!exec_copy) 207fb7345bbSMasami Hiramatsu return -ENOMEM; 208fb7345bbSMasami Hiramatsu 209fb7345bbSMasami Hiramatsu ptr1 = basename(exec_copy); 210fb7345bbSMasami Hiramatsu if (!ptr1) { 211fb7345bbSMasami Hiramatsu ret = -EINVAL; 212fb7345bbSMasami Hiramatsu goto out; 213fb7345bbSMasami Hiramatsu } 214fb7345bbSMasami Hiramatsu 215fb7345bbSMasami Hiramatsu ptr2 = strpbrk(ptr1, "-._"); 216fb7345bbSMasami Hiramatsu if (ptr2) 217fb7345bbSMasami Hiramatsu *ptr2 = '\0'; 218fb7345bbSMasami Hiramatsu ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1); 219fb7345bbSMasami Hiramatsu if (ret < 0) 220fb7345bbSMasami Hiramatsu goto out; 221fb7345bbSMasami Hiramatsu 222fb7345bbSMasami Hiramatsu *result = strdup(buf); 223fb7345bbSMasami Hiramatsu ret = *result ? 0 : -ENOMEM; 224fb7345bbSMasami Hiramatsu 225fb7345bbSMasami Hiramatsu out: 226fb7345bbSMasami Hiramatsu free(exec_copy); 227fb7345bbSMasami Hiramatsu return ret; 228fb7345bbSMasami Hiramatsu } 229fb7345bbSMasami Hiramatsu 2309b118acaSMasami Hiramatsu static void clear_perf_probe_point(struct perf_probe_point *pp) 2319b118acaSMasami Hiramatsu { 2329b118acaSMasami Hiramatsu free(pp->file); 2339b118acaSMasami Hiramatsu free(pp->function); 2349b118acaSMasami Hiramatsu free(pp->lazy_line); 2359b118acaSMasami Hiramatsu } 2369b118acaSMasami Hiramatsu 237eb948e50SMasami Hiramatsu static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs) 238eb948e50SMasami Hiramatsu { 239eb948e50SMasami Hiramatsu int i; 240eb948e50SMasami Hiramatsu 241eb948e50SMasami Hiramatsu for (i = 0; i < ntevs; i++) 242eb948e50SMasami Hiramatsu clear_probe_trace_event(tevs + i); 243eb948e50SMasami Hiramatsu } 244eb948e50SMasami Hiramatsu 245b031220dSMasami Hiramatsu static bool kprobe_blacklist__listed(unsigned long address); 246b031220dSMasami Hiramatsu static bool kprobe_warn_out_range(const char *symbol, unsigned long address) 247b031220dSMasami Hiramatsu { 2489b239a12SMasami Hiramatsu u64 etext_addr = 0; 2499b239a12SMasami Hiramatsu int ret; 2507c31bb8cSHe Kuang 251b031220dSMasami Hiramatsu /* Get the address of _etext for checking non-probable text symbol */ 2529b239a12SMasami Hiramatsu ret = kernel_get_symbol_address_by_name("_etext", &etext_addr, 2539b239a12SMasami Hiramatsu false, false); 2547c31bb8cSHe Kuang 2559b239a12SMasami Hiramatsu if (ret == 0 && etext_addr < address) 256b031220dSMasami Hiramatsu pr_warning("%s is out of .text, skip it.\n", symbol); 257b031220dSMasami Hiramatsu else if (kprobe_blacklist__listed(address)) 258b031220dSMasami Hiramatsu pr_warning("%s is blacklisted function, skip it.\n", symbol); 259b031220dSMasami Hiramatsu else 260b031220dSMasami Hiramatsu return false; 261b031220dSMasami Hiramatsu 262b031220dSMasami Hiramatsu return true; 263b031220dSMasami Hiramatsu } 264b031220dSMasami Hiramatsu 265c61fb959SRavi Bangoria /* 266c61fb959SRavi Bangoria * NOTE: 267c61fb959SRavi Bangoria * '.gnu.linkonce.this_module' section of kernel module elf directly 268c61fb959SRavi Bangoria * maps to 'struct module' from linux/module.h. This section contains 269c61fb959SRavi Bangoria * actual module name which will be used by kernel after loading it. 270c61fb959SRavi Bangoria * But, we cannot use 'struct module' here since linux/module.h is not 271c61fb959SRavi Bangoria * exposed to user-space. Offset of 'name' has remained same from long 272c61fb959SRavi Bangoria * time, so hardcoding it here. 273c61fb959SRavi Bangoria */ 274c61fb959SRavi Bangoria #ifdef __LP64__ 275c61fb959SRavi Bangoria #define MOD_NAME_OFFSET 24 276c61fb959SRavi Bangoria #else 277c61fb959SRavi Bangoria #define MOD_NAME_OFFSET 12 278c61fb959SRavi Bangoria #endif 279c61fb959SRavi Bangoria 280c61fb959SRavi Bangoria /* 281c61fb959SRavi Bangoria * @module can be module name of module file path. In case of path, 282c61fb959SRavi Bangoria * inspect elf and find out what is actual module name. 283c61fb959SRavi Bangoria * Caller has to free mod_name after using it. 284c61fb959SRavi Bangoria */ 285c61fb959SRavi Bangoria static char *find_module_name(const char *module) 286c61fb959SRavi Bangoria { 287c61fb959SRavi Bangoria int fd; 288c61fb959SRavi Bangoria Elf *elf; 289c61fb959SRavi Bangoria GElf_Ehdr ehdr; 290c61fb959SRavi Bangoria GElf_Shdr shdr; 291c61fb959SRavi Bangoria Elf_Data *data; 292c61fb959SRavi Bangoria Elf_Scn *sec; 293c61fb959SRavi Bangoria char *mod_name = NULL; 294c61fb959SRavi Bangoria 295c61fb959SRavi Bangoria fd = open(module, O_RDONLY); 296c61fb959SRavi Bangoria if (fd < 0) 297c61fb959SRavi Bangoria return NULL; 298c61fb959SRavi Bangoria 299c61fb959SRavi Bangoria elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 300c61fb959SRavi Bangoria if (elf == NULL) 301c61fb959SRavi Bangoria goto elf_err; 302c61fb959SRavi Bangoria 303c61fb959SRavi Bangoria if (gelf_getehdr(elf, &ehdr) == NULL) 304c61fb959SRavi Bangoria goto ret_err; 305c61fb959SRavi Bangoria 306c61fb959SRavi Bangoria sec = elf_section_by_name(elf, &ehdr, &shdr, 307c61fb959SRavi Bangoria ".gnu.linkonce.this_module", NULL); 308c61fb959SRavi Bangoria if (!sec) 309c61fb959SRavi Bangoria goto ret_err; 310c61fb959SRavi Bangoria 311c61fb959SRavi Bangoria data = elf_getdata(sec, NULL); 312c61fb959SRavi Bangoria if (!data || !data->d_buf) 313c61fb959SRavi Bangoria goto ret_err; 314c61fb959SRavi Bangoria 315c61fb959SRavi Bangoria mod_name = strdup((char *)data->d_buf + MOD_NAME_OFFSET); 316c61fb959SRavi Bangoria 317c61fb959SRavi Bangoria ret_err: 318c61fb959SRavi Bangoria elf_end(elf); 319c61fb959SRavi Bangoria elf_err: 320c61fb959SRavi Bangoria close(fd); 321c61fb959SRavi Bangoria return mod_name; 322c61fb959SRavi Bangoria } 323c61fb959SRavi Bangoria 32489fe808aSIngo Molnar #ifdef HAVE_DWARF_SUPPORT 32560fb7742SWang Nan 32660fb7742SWang Nan static int kernel_get_module_dso(const char *module, struct dso **pdso) 32760fb7742SWang Nan { 32860fb7742SWang Nan struct dso *dso; 32960fb7742SWang Nan struct map *map; 33060fb7742SWang Nan const char *vmlinux_name; 33160fb7742SWang Nan int ret = 0; 33260fb7742SWang Nan 33360fb7742SWang Nan if (module) { 334266fa2b2SArnaldo Carvalho de Melo char module_name[128]; 335266fa2b2SArnaldo Carvalho de Melo 336266fa2b2SArnaldo Carvalho de Melo snprintf(module_name, sizeof(module_name), "[%s]", module); 337266fa2b2SArnaldo Carvalho de Melo map = map_groups__find_by_name(&host_machine->kmaps, MAP__FUNCTION, module_name); 338266fa2b2SArnaldo Carvalho de Melo if (map) { 339266fa2b2SArnaldo Carvalho de Melo dso = map->dso; 34060fb7742SWang Nan goto found; 34160fb7742SWang Nan } 34260fb7742SWang Nan pr_debug("Failed to find module %s.\n", module); 34360fb7742SWang Nan return -ENOENT; 34460fb7742SWang Nan } 34560fb7742SWang Nan 346a5e813c6SArnaldo Carvalho de Melo map = machine__kernel_map(host_machine); 34760fb7742SWang Nan dso = map->dso; 34860fb7742SWang Nan 34960fb7742SWang Nan vmlinux_name = symbol_conf.vmlinux_name; 35060fb7742SWang Nan dso->load_errno = 0; 35160fb7742SWang Nan if (vmlinux_name) 35260fb7742SWang Nan ret = dso__load_vmlinux(dso, map, vmlinux_name, false, NULL); 35360fb7742SWang Nan else 35460fb7742SWang Nan ret = dso__load_vmlinux_path(dso, map, NULL); 35560fb7742SWang Nan found: 35660fb7742SWang Nan *pdso = dso; 35760fb7742SWang Nan return ret; 35860fb7742SWang Nan } 35960fb7742SWang Nan 3609b118acaSMasami Hiramatsu /* 3619b118acaSMasami Hiramatsu * Some binaries like glibc have special symbols which are on the symbol 3629b118acaSMasami Hiramatsu * table, but not in the debuginfo. If we can find the address of the 3639b118acaSMasami Hiramatsu * symbol from map, we can translate the address back to the probe point. 3649b118acaSMasami Hiramatsu */ 3659b118acaSMasami Hiramatsu static int find_alternative_probe_point(struct debuginfo *dinfo, 3669b118acaSMasami Hiramatsu struct perf_probe_point *pp, 3679b118acaSMasami Hiramatsu struct perf_probe_point *result, 3689b118acaSMasami Hiramatsu const char *target, bool uprobes) 3699b118acaSMasami Hiramatsu { 3709b118acaSMasami Hiramatsu struct map *map = NULL; 3719b118acaSMasami Hiramatsu struct symbol *sym; 3729b118acaSMasami Hiramatsu u64 address = 0; 3739b118acaSMasami Hiramatsu int ret = -ENOENT; 3749b118acaSMasami Hiramatsu 3759b118acaSMasami Hiramatsu /* This can work only for function-name based one */ 3769b118acaSMasami Hiramatsu if (!pp->function || pp->file) 3779b118acaSMasami Hiramatsu return -ENOTSUP; 3789b118acaSMasami Hiramatsu 3799b118acaSMasami Hiramatsu map = get_target_map(target, uprobes); 3809b118acaSMasami Hiramatsu if (!map) 3819b118acaSMasami Hiramatsu return -EINVAL; 3829b118acaSMasami Hiramatsu 3839b118acaSMasami Hiramatsu /* Find the address of given function */ 3849b118acaSMasami Hiramatsu map__for_each_symbol_by_name(map, pp->function, sym) { 385e6d7c91cSMasami Hiramatsu if (uprobes) 3869b118acaSMasami Hiramatsu address = sym->start; 387e6d7c91cSMasami Hiramatsu else 388e6d7c91cSMasami Hiramatsu address = map->unmap_ip(map, sym->start); 3899b118acaSMasami Hiramatsu break; 3909b118acaSMasami Hiramatsu } 3919b118acaSMasami Hiramatsu if (!address) { 3929b118acaSMasami Hiramatsu ret = -ENOENT; 3939b118acaSMasami Hiramatsu goto out; 3949b118acaSMasami Hiramatsu } 395f6c15621SWang Nan pr_debug("Symbol %s address found : %" PRIx64 "\n", 396f6c15621SWang Nan pp->function, address); 3979b118acaSMasami Hiramatsu 3989b118acaSMasami Hiramatsu ret = debuginfo__find_probe_point(dinfo, (unsigned long)address, 3999b118acaSMasami Hiramatsu result); 4009b118acaSMasami Hiramatsu if (ret <= 0) 4019b118acaSMasami Hiramatsu ret = (!ret) ? -ENOENT : ret; 4029b118acaSMasami Hiramatsu else { 4039b118acaSMasami Hiramatsu result->offset += pp->offset; 4049b118acaSMasami Hiramatsu result->line += pp->line; 4059d7b45c5SHe Kuang result->retprobe = pp->retprobe; 4069b118acaSMasami Hiramatsu ret = 0; 4079b118acaSMasami Hiramatsu } 4089b118acaSMasami Hiramatsu 4099b118acaSMasami Hiramatsu out: 4109b118acaSMasami Hiramatsu put_target_map(map, uprobes); 4119b118acaSMasami Hiramatsu return ret; 4129b118acaSMasami Hiramatsu 4139b118acaSMasami Hiramatsu } 4149b118acaSMasami Hiramatsu 4159b118acaSMasami Hiramatsu static int get_alternative_probe_event(struct debuginfo *dinfo, 4169b118acaSMasami Hiramatsu struct perf_probe_event *pev, 41744225521SMasami Hiramatsu struct perf_probe_point *tmp) 4189b118acaSMasami Hiramatsu { 4199b118acaSMasami Hiramatsu int ret; 4209b118acaSMasami Hiramatsu 4219b118acaSMasami Hiramatsu memcpy(tmp, &pev->point, sizeof(*tmp)); 4229b118acaSMasami Hiramatsu memset(&pev->point, 0, sizeof(pev->point)); 4239b118acaSMasami Hiramatsu ret = find_alternative_probe_point(dinfo, tmp, &pev->point, 42444225521SMasami Hiramatsu pev->target, pev->uprobes); 4259b118acaSMasami Hiramatsu if (ret < 0) 4269b118acaSMasami Hiramatsu memcpy(&pev->point, tmp, sizeof(*tmp)); 4279b118acaSMasami Hiramatsu 4289b118acaSMasami Hiramatsu return ret; 4299b118acaSMasami Hiramatsu } 430a15ad2f5SMasami Hiramatsu 431811dd2aeSMasami Hiramatsu static int get_alternative_line_range(struct debuginfo *dinfo, 432811dd2aeSMasami Hiramatsu struct line_range *lr, 433811dd2aeSMasami Hiramatsu const char *target, bool user) 434811dd2aeSMasami Hiramatsu { 4356d4a4896SDavid Ahern struct perf_probe_point pp = { .function = lr->function, 4366d4a4896SDavid Ahern .file = lr->file, 4376d4a4896SDavid Ahern .line = lr->start }; 4386d4a4896SDavid Ahern struct perf_probe_point result; 439811dd2aeSMasami Hiramatsu int ret, len = 0; 440811dd2aeSMasami Hiramatsu 4416d4a4896SDavid Ahern memset(&result, 0, sizeof(result)); 4426d4a4896SDavid Ahern 443811dd2aeSMasami Hiramatsu if (lr->end != INT_MAX) 444811dd2aeSMasami Hiramatsu len = lr->end - lr->start; 445811dd2aeSMasami Hiramatsu ret = find_alternative_probe_point(dinfo, &pp, &result, 446811dd2aeSMasami Hiramatsu target, user); 447811dd2aeSMasami Hiramatsu if (!ret) { 448811dd2aeSMasami Hiramatsu lr->function = result.function; 449811dd2aeSMasami Hiramatsu lr->file = result.file; 450811dd2aeSMasami Hiramatsu lr->start = result.line; 451811dd2aeSMasami Hiramatsu if (lr->end != INT_MAX) 452811dd2aeSMasami Hiramatsu lr->end = lr->start + len; 453811dd2aeSMasami Hiramatsu clear_perf_probe_point(&pp); 454811dd2aeSMasami Hiramatsu } 455811dd2aeSMasami Hiramatsu return ret; 456811dd2aeSMasami Hiramatsu } 457811dd2aeSMasami Hiramatsu 458ff741783SMasami Hiramatsu /* Open new debuginfo of given module */ 45992561cb7SMasami Hiramatsu static struct debuginfo *open_debuginfo(const char *module, bool silent) 460469b9b88SMasami Hiramatsu { 461a15ad2f5SMasami Hiramatsu const char *path = module; 462419e8738SMasami Hiramatsu char reason[STRERR_BUFSIZE]; 463419e8738SMasami Hiramatsu struct debuginfo *ret = NULL; 464419e8738SMasami Hiramatsu struct dso *dso = NULL; 465419e8738SMasami Hiramatsu int err; 46614a8fd7cSMasami Hiramatsu 467a15ad2f5SMasami Hiramatsu if (!module || !strchr(module, '/')) { 468419e8738SMasami Hiramatsu err = kernel_get_module_dso(module, &dso); 469419e8738SMasami Hiramatsu if (err < 0) { 470419e8738SMasami Hiramatsu if (!dso || dso->load_errno == 0) { 471*c8b5f2c9SArnaldo Carvalho de Melo if (!str_error_r(-err, reason, STRERR_BUFSIZE)) 472419e8738SMasami Hiramatsu strcpy(reason, "(unknown)"); 473419e8738SMasami Hiramatsu } else 474419e8738SMasami Hiramatsu dso__strerror_load(dso, reason, STRERR_BUFSIZE); 47592561cb7SMasami Hiramatsu if (!silent) 476419e8738SMasami Hiramatsu pr_err("Failed to find the path for %s: %s\n", 477419e8738SMasami Hiramatsu module ?: "kernel", reason); 478ff741783SMasami Hiramatsu return NULL; 479469b9b88SMasami Hiramatsu } 480419e8738SMasami Hiramatsu path = dso->long_name; 48114a8fd7cSMasami Hiramatsu } 48292561cb7SMasami Hiramatsu ret = debuginfo__new(path); 48392561cb7SMasami Hiramatsu if (!ret && !silent) { 48492561cb7SMasami Hiramatsu pr_warning("The %s file has no debug information.\n", path); 48592561cb7SMasami Hiramatsu if (!module || !strtailcmp(path, ".ko")) 48692561cb7SMasami Hiramatsu pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, "); 48792561cb7SMasami Hiramatsu else 48892561cb7SMasami Hiramatsu pr_warning("Rebuild with -g, "); 48992561cb7SMasami Hiramatsu pr_warning("or install an appropriate debuginfo package.\n"); 490e0faa8d3SMasami Hiramatsu } 49192561cb7SMasami Hiramatsu return ret; 49292561cb7SMasami Hiramatsu } 49392561cb7SMasami Hiramatsu 4947737af01SMasami Hiramatsu /* For caching the last debuginfo */ 4957737af01SMasami Hiramatsu static struct debuginfo *debuginfo_cache; 4967737af01SMasami Hiramatsu static char *debuginfo_cache_path; 4977737af01SMasami Hiramatsu 4987737af01SMasami Hiramatsu static struct debuginfo *debuginfo_cache__open(const char *module, bool silent) 4997737af01SMasami Hiramatsu { 50020f49859SMasami Hiramatsu const char *path = module; 50120f49859SMasami Hiramatsu 50220f49859SMasami Hiramatsu /* If the module is NULL, it should be the kernel. */ 50320f49859SMasami Hiramatsu if (!module) 50420f49859SMasami Hiramatsu path = "kernel"; 50520f49859SMasami Hiramatsu 50620f49859SMasami Hiramatsu if (debuginfo_cache_path && !strcmp(debuginfo_cache_path, path)) 5077737af01SMasami Hiramatsu goto out; 5087737af01SMasami Hiramatsu 5097737af01SMasami Hiramatsu /* Copy module path */ 5107737af01SMasami Hiramatsu free(debuginfo_cache_path); 51120f49859SMasami Hiramatsu debuginfo_cache_path = strdup(path); 5127737af01SMasami Hiramatsu if (!debuginfo_cache_path) { 5137737af01SMasami Hiramatsu debuginfo__delete(debuginfo_cache); 5147737af01SMasami Hiramatsu debuginfo_cache = NULL; 5157737af01SMasami Hiramatsu goto out; 5167737af01SMasami Hiramatsu } 5177737af01SMasami Hiramatsu 5187737af01SMasami Hiramatsu debuginfo_cache = open_debuginfo(module, silent); 5197737af01SMasami Hiramatsu if (!debuginfo_cache) 5207737af01SMasami Hiramatsu zfree(&debuginfo_cache_path); 5217737af01SMasami Hiramatsu out: 5227737af01SMasami Hiramatsu return debuginfo_cache; 5237737af01SMasami Hiramatsu } 5247737af01SMasami Hiramatsu 5257737af01SMasami Hiramatsu static void debuginfo_cache__exit(void) 5267737af01SMasami Hiramatsu { 5277737af01SMasami Hiramatsu debuginfo__delete(debuginfo_cache); 5287737af01SMasami Hiramatsu debuginfo_cache = NULL; 5297737af01SMasami Hiramatsu zfree(&debuginfo_cache_path); 5307737af01SMasami Hiramatsu } 5317737af01SMasami Hiramatsu 5324b4da7f7SMasami Hiramatsu 53399ca4233SMasami Hiramatsu static int get_text_start_address(const char *exec, unsigned long *address) 53499ca4233SMasami Hiramatsu { 53599ca4233SMasami Hiramatsu Elf *elf; 53699ca4233SMasami Hiramatsu GElf_Ehdr ehdr; 53799ca4233SMasami Hiramatsu GElf_Shdr shdr; 53899ca4233SMasami Hiramatsu int fd, ret = -ENOENT; 53999ca4233SMasami Hiramatsu 54099ca4233SMasami Hiramatsu fd = open(exec, O_RDONLY); 54199ca4233SMasami Hiramatsu if (fd < 0) 54299ca4233SMasami Hiramatsu return -errno; 54399ca4233SMasami Hiramatsu 54499ca4233SMasami Hiramatsu elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL); 545062d6c2aSMasami Hiramatsu if (elf == NULL) { 546062d6c2aSMasami Hiramatsu ret = -EINVAL; 547062d6c2aSMasami Hiramatsu goto out_close; 548062d6c2aSMasami Hiramatsu } 54999ca4233SMasami Hiramatsu 55099ca4233SMasami Hiramatsu if (gelf_getehdr(elf, &ehdr) == NULL) 55199ca4233SMasami Hiramatsu goto out; 55299ca4233SMasami Hiramatsu 55399ca4233SMasami Hiramatsu if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL)) 55499ca4233SMasami Hiramatsu goto out; 55599ca4233SMasami Hiramatsu 55699ca4233SMasami Hiramatsu *address = shdr.sh_addr - shdr.sh_offset; 55799ca4233SMasami Hiramatsu ret = 0; 55899ca4233SMasami Hiramatsu out: 55999ca4233SMasami Hiramatsu elf_end(elf); 560062d6c2aSMasami Hiramatsu out_close: 561062d6c2aSMasami Hiramatsu close(fd); 562062d6c2aSMasami Hiramatsu 56399ca4233SMasami Hiramatsu return ret; 56499ca4233SMasami Hiramatsu } 56599ca4233SMasami Hiramatsu 5665a6f6314SMasami Hiramatsu /* 5675a6f6314SMasami Hiramatsu * Convert trace point to probe point with debuginfo 5685a6f6314SMasami Hiramatsu */ 5695a6f6314SMasami Hiramatsu static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp, 5705a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 5715a6f6314SMasami Hiramatsu bool is_kprobe) 5725a6f6314SMasami Hiramatsu { 5735a6f6314SMasami Hiramatsu struct debuginfo *dinfo = NULL; 5745a6f6314SMasami Hiramatsu unsigned long stext = 0; 5755a6f6314SMasami Hiramatsu u64 addr = tp->address; 5765a6f6314SMasami Hiramatsu int ret = -ENOENT; 5775a6f6314SMasami Hiramatsu 5785a6f6314SMasami Hiramatsu /* convert the address to dwarf address */ 5795a6f6314SMasami Hiramatsu if (!is_kprobe) { 5805a6f6314SMasami Hiramatsu if (!addr) { 5815a6f6314SMasami Hiramatsu ret = -EINVAL; 5825a6f6314SMasami Hiramatsu goto error; 5835a6f6314SMasami Hiramatsu } 5845a6f6314SMasami Hiramatsu ret = get_text_start_address(tp->module, &stext); 5855a6f6314SMasami Hiramatsu if (ret < 0) 5865a6f6314SMasami Hiramatsu goto error; 5875a6f6314SMasami Hiramatsu addr += stext; 588e486367fSWang Nan } else if (tp->symbol) { 5899b239a12SMasami Hiramatsu /* If the module is given, this returns relative address */ 5909b239a12SMasami Hiramatsu ret = kernel_get_symbol_address_by_name(tp->symbol, &addr, 5919b239a12SMasami Hiramatsu false, !!tp->module); 5929b239a12SMasami Hiramatsu if (ret != 0) 5935a6f6314SMasami Hiramatsu goto error; 5945a6f6314SMasami Hiramatsu addr += tp->offset; 5955a6f6314SMasami Hiramatsu } 5965a6f6314SMasami Hiramatsu 5975a6f6314SMasami Hiramatsu pr_debug("try to find information at %" PRIx64 " in %s\n", addr, 5985a6f6314SMasami Hiramatsu tp->module ? : "kernel"); 5995a6f6314SMasami Hiramatsu 6007737af01SMasami Hiramatsu dinfo = debuginfo_cache__open(tp->module, verbose == 0); 6017737af01SMasami Hiramatsu if (dinfo) 6025a6f6314SMasami Hiramatsu ret = debuginfo__find_probe_point(dinfo, 6035a6f6314SMasami Hiramatsu (unsigned long)addr, pp); 6047737af01SMasami Hiramatsu else 6055a6f6314SMasami Hiramatsu ret = -ENOENT; 6065a6f6314SMasami Hiramatsu 6075a6f6314SMasami Hiramatsu if (ret > 0) { 6085a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 6095a6f6314SMasami Hiramatsu return 0; 6105a6f6314SMasami Hiramatsu } 6115a6f6314SMasami Hiramatsu error: 6125a6f6314SMasami Hiramatsu pr_debug("Failed to find corresponding probes from debuginfo.\n"); 6135a6f6314SMasami Hiramatsu return ret ? : -ENOENT; 6145a6f6314SMasami Hiramatsu } 6155a6f6314SMasami Hiramatsu 616fb7345bbSMasami Hiramatsu static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs, 617fb7345bbSMasami Hiramatsu int ntevs, const char *exec) 618fb7345bbSMasami Hiramatsu { 619fb7345bbSMasami Hiramatsu int i, ret = 0; 620eb948e50SMasami Hiramatsu unsigned long stext = 0; 621fb7345bbSMasami Hiramatsu 622fb7345bbSMasami Hiramatsu if (!exec) 623fb7345bbSMasami Hiramatsu return 0; 624fb7345bbSMasami Hiramatsu 625fb7345bbSMasami Hiramatsu ret = get_text_start_address(exec, &stext); 626fb7345bbSMasami Hiramatsu if (ret < 0) 627fb7345bbSMasami Hiramatsu return ret; 628fb7345bbSMasami Hiramatsu 629fb7345bbSMasami Hiramatsu for (i = 0; i < ntevs && ret >= 0; i++) { 630981a2379SMasami Hiramatsu /* point.address is the addres of point.symbol + point.offset */ 631eb948e50SMasami Hiramatsu tevs[i].point.address -= stext; 632fb7345bbSMasami Hiramatsu tevs[i].point.module = strdup(exec); 633eb948e50SMasami Hiramatsu if (!tevs[i].point.module) { 634fb7345bbSMasami Hiramatsu ret = -ENOMEM; 635fb7345bbSMasami Hiramatsu break; 636fb7345bbSMasami Hiramatsu } 637fb7345bbSMasami Hiramatsu tevs[i].uprobes = true; 638fb7345bbSMasami Hiramatsu } 639fb7345bbSMasami Hiramatsu 640fb7345bbSMasami Hiramatsu return ret; 641fb7345bbSMasami Hiramatsu } 642fb7345bbSMasami Hiramatsu 643190b57fcSMasami Hiramatsu static int add_module_to_probe_trace_events(struct probe_trace_event *tevs, 644190b57fcSMasami Hiramatsu int ntevs, const char *module) 645190b57fcSMasami Hiramatsu { 64614a8fd7cSMasami Hiramatsu int i, ret = 0; 64763a29613SRavi Bangoria char *mod_name = NULL; 64814a8fd7cSMasami Hiramatsu 64914a8fd7cSMasami Hiramatsu if (!module) 65014a8fd7cSMasami Hiramatsu return 0; 65114a8fd7cSMasami Hiramatsu 65263a29613SRavi Bangoria mod_name = find_module_name(module); 65314a8fd7cSMasami Hiramatsu 654190b57fcSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 65563a29613SRavi Bangoria tevs[i].point.module = 65663a29613SRavi Bangoria strdup(mod_name ? mod_name : module); 65714a8fd7cSMasami Hiramatsu if (!tevs[i].point.module) { 65814a8fd7cSMasami Hiramatsu ret = -ENOMEM; 65914a8fd7cSMasami Hiramatsu break; 660190b57fcSMasami Hiramatsu } 66114a8fd7cSMasami Hiramatsu } 66214a8fd7cSMasami Hiramatsu 66363a29613SRavi Bangoria free(mod_name); 66414a8fd7cSMasami Hiramatsu return ret; 665190b57fcSMasami Hiramatsu } 666190b57fcSMasami Hiramatsu 667dfef99cdSMasami Hiramatsu /* Post processing the probe events */ 668dfef99cdSMasami Hiramatsu static int post_process_probe_trace_events(struct probe_trace_event *tevs, 669dfef99cdSMasami Hiramatsu int ntevs, const char *module, 670dfef99cdSMasami Hiramatsu bool uprobe) 671dfef99cdSMasami Hiramatsu { 672dfef99cdSMasami Hiramatsu struct ref_reloc_sym *reloc_sym; 673dfef99cdSMasami Hiramatsu char *tmp; 6745a51fcd1SMasami Hiramatsu int i, skipped = 0; 675dfef99cdSMasami Hiramatsu 676dfef99cdSMasami Hiramatsu if (uprobe) 677dfef99cdSMasami Hiramatsu return add_exec_to_probe_trace_events(tevs, ntevs, module); 678dfef99cdSMasami Hiramatsu 679dfef99cdSMasami Hiramatsu /* Note that currently ref_reloc_sym based probe is not for drivers */ 680dfef99cdSMasami Hiramatsu if (module) 681dfef99cdSMasami Hiramatsu return add_module_to_probe_trace_events(tevs, ntevs, module); 682dfef99cdSMasami Hiramatsu 6838f33f7deSMasami Hiramatsu reloc_sym = kernel_get_ref_reloc_sym(); 684dfef99cdSMasami Hiramatsu if (!reloc_sym) { 685dfef99cdSMasami Hiramatsu pr_warning("Relocated base symbol is not found!\n"); 686dfef99cdSMasami Hiramatsu return -EINVAL; 687dfef99cdSMasami Hiramatsu } 688dfef99cdSMasami Hiramatsu 689dfef99cdSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 690b031220dSMasami Hiramatsu if (!tevs[i].point.address || tevs[i].point.retprobe) 691b031220dSMasami Hiramatsu continue; 6925a51fcd1SMasami Hiramatsu /* If we found a wrong one, mark it by NULL symbol */ 693b031220dSMasami Hiramatsu if (kprobe_warn_out_range(tevs[i].point.symbol, 694b031220dSMasami Hiramatsu tevs[i].point.address)) { 6955a51fcd1SMasami Hiramatsu tmp = NULL; 6965a51fcd1SMasami Hiramatsu skipped++; 6975a51fcd1SMasami Hiramatsu } else { 698dfef99cdSMasami Hiramatsu tmp = strdup(reloc_sym->name); 699dfef99cdSMasami Hiramatsu if (!tmp) 700dfef99cdSMasami Hiramatsu return -ENOMEM; 7015a51fcd1SMasami Hiramatsu } 7024c859351SMasami Hiramatsu /* If we have no realname, use symbol for it */ 7034c859351SMasami Hiramatsu if (!tevs[i].point.realname) 7044c859351SMasami Hiramatsu tevs[i].point.realname = tevs[i].point.symbol; 7054c859351SMasami Hiramatsu else 706dfef99cdSMasami Hiramatsu free(tevs[i].point.symbol); 707dfef99cdSMasami Hiramatsu tevs[i].point.symbol = tmp; 708dfef99cdSMasami Hiramatsu tevs[i].point.offset = tevs[i].point.address - 709dfef99cdSMasami Hiramatsu reloc_sym->unrelocated_addr; 710dfef99cdSMasami Hiramatsu } 7115a51fcd1SMasami Hiramatsu return skipped; 712dfef99cdSMasami Hiramatsu } 713dfef99cdSMasami Hiramatsu 7144b4da7f7SMasami Hiramatsu /* Try to find perf_probe_event with debuginfo */ 7150e60836bSSrikar Dronamraju static int try_to_find_probe_trace_events(struct perf_probe_event *pev, 716ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs) 7174b4da7f7SMasami Hiramatsu { 7184b4da7f7SMasami Hiramatsu bool need_dwarf = perf_probe_event_need_dwarf(pev); 7199b118acaSMasami Hiramatsu struct perf_probe_point tmp; 720225466f1SSrikar Dronamraju struct debuginfo *dinfo; 721190b57fcSMasami Hiramatsu int ntevs, ret = 0; 7224b4da7f7SMasami Hiramatsu 72344225521SMasami Hiramatsu dinfo = open_debuginfo(pev->target, !need_dwarf); 724ff741783SMasami Hiramatsu if (!dinfo) { 72592561cb7SMasami Hiramatsu if (need_dwarf) 726ff741783SMasami Hiramatsu return -ENOENT; 727ff741783SMasami Hiramatsu pr_debug("Could not open debuginfo. Try to use symbols.\n"); 7284b4da7f7SMasami Hiramatsu return 0; 7294b4da7f7SMasami Hiramatsu } 7304b4da7f7SMasami Hiramatsu 731dfef99cdSMasami Hiramatsu pr_debug("Try to find probe point from debuginfo.\n"); 732ff741783SMasami Hiramatsu /* Searching trace events corresponding to a probe event */ 733ddb2f58fSMasami Hiramatsu ntevs = debuginfo__find_trace_events(dinfo, pev, tevs); 734ff741783SMasami Hiramatsu 7359b118acaSMasami Hiramatsu if (ntevs == 0) { /* Not found, retry with an alternative */ 73644225521SMasami Hiramatsu ret = get_alternative_probe_event(dinfo, pev, &tmp); 7379b118acaSMasami Hiramatsu if (!ret) { 738ddb2f58fSMasami Hiramatsu ntevs = debuginfo__find_trace_events(dinfo, pev, tevs); 7399b118acaSMasami Hiramatsu /* 7409b118acaSMasami Hiramatsu * Write back to the original probe_event for 7419b118acaSMasami Hiramatsu * setting appropriate (user given) event name 7429b118acaSMasami Hiramatsu */ 7439b118acaSMasami Hiramatsu clear_perf_probe_point(&pev->point); 7449b118acaSMasami Hiramatsu memcpy(&pev->point, &tmp, sizeof(tmp)); 7459b118acaSMasami Hiramatsu } 7469b118acaSMasami Hiramatsu } 7479b118acaSMasami Hiramatsu 748ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 7494b4da7f7SMasami Hiramatsu 750146a1439SMasami Hiramatsu if (ntevs > 0) { /* Succeeded to find trace events */ 751dfef99cdSMasami Hiramatsu pr_debug("Found %d probe_trace_events.\n", ntevs); 752dfef99cdSMasami Hiramatsu ret = post_process_probe_trace_events(*tevs, ntevs, 75344225521SMasami Hiramatsu pev->target, pev->uprobes); 7545a51fcd1SMasami Hiramatsu if (ret < 0 || ret == ntevs) { 755981d05adSMasami Hiramatsu clear_probe_trace_events(*tevs, ntevs); 756981d05adSMasami Hiramatsu zfree(tevs); 757981d05adSMasami Hiramatsu } 7585a51fcd1SMasami Hiramatsu if (ret != ntevs) 759190b57fcSMasami Hiramatsu return ret < 0 ? ret : ntevs; 7605a51fcd1SMasami Hiramatsu ntevs = 0; 7615a51fcd1SMasami Hiramatsu /* Fall through */ 762146a1439SMasami Hiramatsu } 7634b4da7f7SMasami Hiramatsu 764146a1439SMasami Hiramatsu if (ntevs == 0) { /* No error but failed to find probe point. */ 7650687eba7SMasami Hiramatsu pr_warning("Probe point '%s' not found.\n", 7664b4da7f7SMasami Hiramatsu synthesize_perf_probe_point(&pev->point)); 767146a1439SMasami Hiramatsu return -ENOENT; 768146a1439SMasami Hiramatsu } 769146a1439SMasami Hiramatsu /* Error path : ntevs < 0 */ 77015eca306SMasami Hiramatsu pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs); 7711c0bd0e8SWang Nan if (ntevs < 0) { 7721c0bd0e8SWang Nan if (ntevs == -EBADF) 77315eca306SMasami Hiramatsu pr_warning("Warning: No dwarf info found in the vmlinux - " 77415eca306SMasami Hiramatsu "please rebuild kernel with CONFIG_DEBUG_INFO=y.\n"); 77515eca306SMasami Hiramatsu if (!need_dwarf) { 7760e43e5d2SMasami Hiramatsu pr_debug("Trying to use symbols.\n"); 7774b4da7f7SMasami Hiramatsu return 0; 7784b4da7f7SMasami Hiramatsu } 77915eca306SMasami Hiramatsu } 78015eca306SMasami Hiramatsu return ntevs; 78115eca306SMasami Hiramatsu } 7824b4da7f7SMasami Hiramatsu 7834b4da7f7SMasami Hiramatsu #define LINEBUF_SIZE 256 7844b4da7f7SMasami Hiramatsu #define NR_ADDITIONAL_LINES 2 7854b4da7f7SMasami Hiramatsu 786fde52dbdSFranck Bui-Huu static int __show_one_line(FILE *fp, int l, bool skip, bool show_num) 7874b4da7f7SMasami Hiramatsu { 7885f03cba4SMasami Hiramatsu char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE]; 789befe3414SFranck Bui-Huu const char *color = show_num ? "" : PERF_COLOR_BLUE; 790befe3414SFranck Bui-Huu const char *prefix = NULL; 7914b4da7f7SMasami Hiramatsu 792befe3414SFranck Bui-Huu do { 7934b4da7f7SMasami Hiramatsu if (fgets(buf, LINEBUF_SIZE, fp) == NULL) 7944b4da7f7SMasami Hiramatsu goto error; 795befe3414SFranck Bui-Huu if (skip) 796befe3414SFranck Bui-Huu continue; 797befe3414SFranck Bui-Huu if (!prefix) { 798befe3414SFranck Bui-Huu prefix = show_num ? "%7d " : " "; 799befe3414SFranck Bui-Huu color_fprintf(stdout, color, prefix, l); 8004b4da7f7SMasami Hiramatsu } 801befe3414SFranck Bui-Huu color_fprintf(stdout, color, "%s", buf); 8024b4da7f7SMasami Hiramatsu 803befe3414SFranck Bui-Huu } while (strchr(buf, '\n') == NULL); 804146a1439SMasami Hiramatsu 805fde52dbdSFranck Bui-Huu return 1; 8064b4da7f7SMasami Hiramatsu error: 807fde52dbdSFranck Bui-Huu if (ferror(fp)) { 8085f03cba4SMasami Hiramatsu pr_warning("File read error: %s\n", 809*c8b5f2c9SArnaldo Carvalho de Melo str_error_r(errno, sbuf, sizeof(sbuf))); 810146a1439SMasami Hiramatsu return -1; 8114b4da7f7SMasami Hiramatsu } 812fde52dbdSFranck Bui-Huu return 0; 813fde52dbdSFranck Bui-Huu } 814fde52dbdSFranck Bui-Huu 815fde52dbdSFranck Bui-Huu static int _show_one_line(FILE *fp, int l, bool skip, bool show_num) 816fde52dbdSFranck Bui-Huu { 817fde52dbdSFranck Bui-Huu int rv = __show_one_line(fp, l, skip, show_num); 818fde52dbdSFranck Bui-Huu if (rv == 0) { 819fde52dbdSFranck Bui-Huu pr_warning("Source file is shorter than expected.\n"); 820fde52dbdSFranck Bui-Huu rv = -1; 821fde52dbdSFranck Bui-Huu } 822fde52dbdSFranck Bui-Huu return rv; 823fde52dbdSFranck Bui-Huu } 824fde52dbdSFranck Bui-Huu 825fde52dbdSFranck Bui-Huu #define show_one_line_with_num(f,l) _show_one_line(f,l,false,true) 826fde52dbdSFranck Bui-Huu #define show_one_line(f,l) _show_one_line(f,l,false,false) 827fde52dbdSFranck Bui-Huu #define skip_one_line(f,l) _show_one_line(f,l,true,false) 828fde52dbdSFranck Bui-Huu #define show_one_line_or_eof(f,l) __show_one_line(f,l,false,false) 8294b4da7f7SMasami Hiramatsu 8304b4da7f7SMasami Hiramatsu /* 8314b4da7f7SMasami Hiramatsu * Show line-range always requires debuginfo to find source file and 8324b4da7f7SMasami Hiramatsu * line number. 8334b4da7f7SMasami Hiramatsu */ 834811dd2aeSMasami Hiramatsu static int __show_line_range(struct line_range *lr, const char *module, 835811dd2aeSMasami Hiramatsu bool user) 8364b4da7f7SMasami Hiramatsu { 837d3b63d7aSMasami Hiramatsu int l = 1; 8385a62257aSMasami Hiramatsu struct int_node *ln; 839ff741783SMasami Hiramatsu struct debuginfo *dinfo; 8404b4da7f7SMasami Hiramatsu FILE *fp; 841ff741783SMasami Hiramatsu int ret; 8427cf0b79eSMasami Hiramatsu char *tmp; 8435f03cba4SMasami Hiramatsu char sbuf[STRERR_BUFSIZE]; 8444b4da7f7SMasami Hiramatsu 8454b4da7f7SMasami Hiramatsu /* Search a line range */ 84692561cb7SMasami Hiramatsu dinfo = open_debuginfo(module, false); 84792561cb7SMasami Hiramatsu if (!dinfo) 848ff741783SMasami Hiramatsu return -ENOENT; 849146a1439SMasami Hiramatsu 850ff741783SMasami Hiramatsu ret = debuginfo__find_line_range(dinfo, lr); 851811dd2aeSMasami Hiramatsu if (!ret) { /* Not found, retry with an alternative */ 852811dd2aeSMasami Hiramatsu ret = get_alternative_line_range(dinfo, lr, module, user); 853811dd2aeSMasami Hiramatsu if (!ret) 854811dd2aeSMasami Hiramatsu ret = debuginfo__find_line_range(dinfo, lr); 855811dd2aeSMasami Hiramatsu } 856ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 8575ee05b88SMasami Hiramatsu if (ret == 0 || ret == -ENOENT) { 858146a1439SMasami Hiramatsu pr_warning("Specified source line is not found.\n"); 859146a1439SMasami Hiramatsu return -ENOENT; 860146a1439SMasami Hiramatsu } else if (ret < 0) { 8615ee05b88SMasami Hiramatsu pr_warning("Debuginfo analysis failed.\n"); 862146a1439SMasami Hiramatsu return ret; 863146a1439SMasami Hiramatsu } 8644b4da7f7SMasami Hiramatsu 8657cf0b79eSMasami Hiramatsu /* Convert source file path */ 8667cf0b79eSMasami Hiramatsu tmp = lr->path; 8676a330a3cSMasami Hiramatsu ret = get_real_path(tmp, lr->comp_dir, &lr->path); 868a78604deSHe Kuang 869a78604deSHe Kuang /* Free old path when new path is assigned */ 870a78604deSHe Kuang if (tmp != lr->path) 871a78604deSHe Kuang free(tmp); 872a78604deSHe Kuang 8737cf0b79eSMasami Hiramatsu if (ret < 0) { 8745ee05b88SMasami Hiramatsu pr_warning("Failed to find source file path.\n"); 8757cf0b79eSMasami Hiramatsu return ret; 8767cf0b79eSMasami Hiramatsu } 8777cf0b79eSMasami Hiramatsu 8784b4da7f7SMasami Hiramatsu setup_pager(); 8794b4da7f7SMasami Hiramatsu 8804b4da7f7SMasami Hiramatsu if (lr->function) 8818737ebdeSMasami Hiramatsu fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path, 8824b4da7f7SMasami Hiramatsu lr->start - lr->offset); 8834b4da7f7SMasami Hiramatsu else 88462c15fc4SFranck Bui-Huu fprintf(stdout, "<%s:%d>\n", lr->path, lr->start); 8854b4da7f7SMasami Hiramatsu 8864b4da7f7SMasami Hiramatsu fp = fopen(lr->path, "r"); 887146a1439SMasami Hiramatsu if (fp == NULL) { 888146a1439SMasami Hiramatsu pr_warning("Failed to open %s: %s\n", lr->path, 889*c8b5f2c9SArnaldo Carvalho de Melo str_error_r(errno, sbuf, sizeof(sbuf))); 890146a1439SMasami Hiramatsu return -errno; 891146a1439SMasami Hiramatsu } 8924b4da7f7SMasami Hiramatsu /* Skip to starting line number */ 89344b81e92SFranck Bui-Huu while (l < lr->start) { 894fde52dbdSFranck Bui-Huu ret = skip_one_line(fp, l++); 895146a1439SMasami Hiramatsu if (ret < 0) 896146a1439SMasami Hiramatsu goto end; 89744b81e92SFranck Bui-Huu } 8984b4da7f7SMasami Hiramatsu 89910daf4d0SArnaldo Carvalho de Melo intlist__for_each_entry(ln, lr->line_list) { 9005a62257aSMasami Hiramatsu for (; ln->i > l; l++) { 901fde52dbdSFranck Bui-Huu ret = show_one_line(fp, l - lr->offset); 90244b81e92SFranck Bui-Huu if (ret < 0) 90344b81e92SFranck Bui-Huu goto end; 90444b81e92SFranck Bui-Huu } 905fde52dbdSFranck Bui-Huu ret = show_one_line_with_num(fp, l++ - lr->offset); 906146a1439SMasami Hiramatsu if (ret < 0) 907146a1439SMasami Hiramatsu goto end; 9084b4da7f7SMasami Hiramatsu } 9094b4da7f7SMasami Hiramatsu 9104b4da7f7SMasami Hiramatsu if (lr->end == INT_MAX) 9114b4da7f7SMasami Hiramatsu lr->end = l + NR_ADDITIONAL_LINES; 912fde52dbdSFranck Bui-Huu while (l <= lr->end) { 913fde52dbdSFranck Bui-Huu ret = show_one_line_or_eof(fp, l++ - lr->offset); 914fde52dbdSFranck Bui-Huu if (ret <= 0) 91544b81e92SFranck Bui-Huu break; 91644b81e92SFranck Bui-Huu } 917146a1439SMasami Hiramatsu end: 9184b4da7f7SMasami Hiramatsu fclose(fp); 919146a1439SMasami Hiramatsu return ret; 9204b4da7f7SMasami Hiramatsu } 9214b4da7f7SMasami Hiramatsu 9222b394bc4SMasami Hiramatsu int show_line_range(struct line_range *lr, const char *module, bool user) 923ee45b6c2SMasami Hiramatsu { 924ee45b6c2SMasami Hiramatsu int ret; 925ee45b6c2SMasami Hiramatsu 9269bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(user); 927ee45b6c2SMasami Hiramatsu if (ret < 0) 928ee45b6c2SMasami Hiramatsu return ret; 929811dd2aeSMasami Hiramatsu ret = __show_line_range(lr, module, user); 9309bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 931ee45b6c2SMasami Hiramatsu 932ee45b6c2SMasami Hiramatsu return ret; 933ee45b6c2SMasami Hiramatsu } 934ee45b6c2SMasami Hiramatsu 935ff741783SMasami Hiramatsu static int show_available_vars_at(struct debuginfo *dinfo, 936ff741783SMasami Hiramatsu struct perf_probe_event *pev, 937ddb2f58fSMasami Hiramatsu struct strfilter *_filter) 938cf6eb489SMasami Hiramatsu { 939cf6eb489SMasami Hiramatsu char *buf; 940bd09d7b5SMasami Hiramatsu int ret, i, nvars; 941cf6eb489SMasami Hiramatsu struct str_node *node; 942cf6eb489SMasami Hiramatsu struct variable_list *vls = NULL, *vl; 9439b118acaSMasami Hiramatsu struct perf_probe_point tmp; 944bd09d7b5SMasami Hiramatsu const char *var; 945cf6eb489SMasami Hiramatsu 946cf6eb489SMasami Hiramatsu buf = synthesize_perf_probe_point(&pev->point); 947cf6eb489SMasami Hiramatsu if (!buf) 948cf6eb489SMasami Hiramatsu return -EINVAL; 949cf6eb489SMasami Hiramatsu pr_debug("Searching variables at %s\n", buf); 950cf6eb489SMasami Hiramatsu 951ddb2f58fSMasami Hiramatsu ret = debuginfo__find_available_vars_at(dinfo, pev, &vls); 9529b118acaSMasami Hiramatsu if (!ret) { /* Not found, retry with an alternative */ 95344225521SMasami Hiramatsu ret = get_alternative_probe_event(dinfo, pev, &tmp); 9549b118acaSMasami Hiramatsu if (!ret) { 9559b118acaSMasami Hiramatsu ret = debuginfo__find_available_vars_at(dinfo, pev, 956ddb2f58fSMasami Hiramatsu &vls); 9579b118acaSMasami Hiramatsu /* Release the old probe_point */ 9589b118acaSMasami Hiramatsu clear_perf_probe_point(&tmp); 9599b118acaSMasami Hiramatsu } 9609b118acaSMasami Hiramatsu } 961bd09d7b5SMasami Hiramatsu if (ret <= 0) { 96269e96eaaSMasami Hiramatsu if (ret == 0 || ret == -ENOENT) { 96369e96eaaSMasami Hiramatsu pr_err("Failed to find the address of %s\n", buf); 96469e96eaaSMasami Hiramatsu ret = -ENOENT; 96569e96eaaSMasami Hiramatsu } else 96669e96eaaSMasami Hiramatsu pr_warning("Debuginfo analysis failed.\n"); 967bd09d7b5SMasami Hiramatsu goto end; 968bd09d7b5SMasami Hiramatsu } 96969e96eaaSMasami Hiramatsu 970bd09d7b5SMasami Hiramatsu /* Some variables are found */ 971cf6eb489SMasami Hiramatsu fprintf(stdout, "Available variables at %s\n", buf); 972cf6eb489SMasami Hiramatsu for (i = 0; i < ret; i++) { 973cf6eb489SMasami Hiramatsu vl = &vls[i]; 974cf6eb489SMasami Hiramatsu /* 975cf6eb489SMasami Hiramatsu * A probe point might be converted to 976cf6eb489SMasami Hiramatsu * several trace points. 977cf6eb489SMasami Hiramatsu */ 978cf6eb489SMasami Hiramatsu fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol, 979cf6eb489SMasami Hiramatsu vl->point.offset); 98074cf249dSArnaldo Carvalho de Melo zfree(&vl->point.symbol); 981bd09d7b5SMasami Hiramatsu nvars = 0; 982cf6eb489SMasami Hiramatsu if (vl->vars) { 983602a1f4dSArnaldo Carvalho de Melo strlist__for_each_entry(node, vl->vars) { 984bd09d7b5SMasami Hiramatsu var = strchr(node->s, '\t') + 1; 985bd09d7b5SMasami Hiramatsu if (strfilter__compare(_filter, var)) { 986cf6eb489SMasami Hiramatsu fprintf(stdout, "\t\t%s\n", node->s); 987bd09d7b5SMasami Hiramatsu nvars++; 988bd09d7b5SMasami Hiramatsu } 989bd09d7b5SMasami Hiramatsu } 990cf6eb489SMasami Hiramatsu strlist__delete(vl->vars); 991bd09d7b5SMasami Hiramatsu } 992bd09d7b5SMasami Hiramatsu if (nvars == 0) 993bd09d7b5SMasami Hiramatsu fprintf(stdout, "\t\t(No matched variables)\n"); 994cf6eb489SMasami Hiramatsu } 995cf6eb489SMasami Hiramatsu free(vls); 996bd09d7b5SMasami Hiramatsu end: 997cf6eb489SMasami Hiramatsu free(buf); 998cf6eb489SMasami Hiramatsu return ret; 999cf6eb489SMasami Hiramatsu } 1000cf6eb489SMasami Hiramatsu 1001cf6eb489SMasami Hiramatsu /* Show available variables on given probe point */ 1002cf6eb489SMasami Hiramatsu int show_available_vars(struct perf_probe_event *pevs, int npevs, 1003ddb2f58fSMasami Hiramatsu struct strfilter *_filter) 1004cf6eb489SMasami Hiramatsu { 1005ff741783SMasami Hiramatsu int i, ret = 0; 1006ff741783SMasami Hiramatsu struct debuginfo *dinfo; 1007cf6eb489SMasami Hiramatsu 10089bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(pevs->uprobes); 1009cf6eb489SMasami Hiramatsu if (ret < 0) 1010cf6eb489SMasami Hiramatsu return ret; 1011cf6eb489SMasami Hiramatsu 101244225521SMasami Hiramatsu dinfo = open_debuginfo(pevs->target, false); 1013ff741783SMasami Hiramatsu if (!dinfo) { 1014ee45b6c2SMasami Hiramatsu ret = -ENOENT; 1015ee45b6c2SMasami Hiramatsu goto out; 1016ff741783SMasami Hiramatsu } 1017ff741783SMasami Hiramatsu 1018cc446446SMasami Hiramatsu setup_pager(); 1019cc446446SMasami Hiramatsu 1020ff741783SMasami Hiramatsu for (i = 0; i < npevs && ret >= 0; i++) 1021ddb2f58fSMasami Hiramatsu ret = show_available_vars_at(dinfo, &pevs[i], _filter); 1022ff741783SMasami Hiramatsu 1023ff741783SMasami Hiramatsu debuginfo__delete(dinfo); 1024ee45b6c2SMasami Hiramatsu out: 10259bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 1026cf6eb489SMasami Hiramatsu return ret; 1027cf6eb489SMasami Hiramatsu } 1028cf6eb489SMasami Hiramatsu 102989fe808aSIngo Molnar #else /* !HAVE_DWARF_SUPPORT */ 10304b4da7f7SMasami Hiramatsu 10317737af01SMasami Hiramatsu static void debuginfo_cache__exit(void) 10327737af01SMasami Hiramatsu { 10337737af01SMasami Hiramatsu } 10347737af01SMasami Hiramatsu 10355a6f6314SMasami Hiramatsu static int 10365a6f6314SMasami Hiramatsu find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused, 10375a6f6314SMasami Hiramatsu struct perf_probe_point *pp __maybe_unused, 10385a6f6314SMasami Hiramatsu bool is_kprobe __maybe_unused) 10394b4da7f7SMasami Hiramatsu { 10405a6f6314SMasami Hiramatsu return -ENOSYS; 10414b4da7f7SMasami Hiramatsu } 10424b4da7f7SMasami Hiramatsu 10430e60836bSSrikar Dronamraju static int try_to_find_probe_trace_events(struct perf_probe_event *pev, 1044ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs __maybe_unused) 10454b4da7f7SMasami Hiramatsu { 1046146a1439SMasami Hiramatsu if (perf_probe_event_need_dwarf(pev)) { 1047146a1439SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 1048146a1439SMasami Hiramatsu return -ENOSYS; 1049146a1439SMasami Hiramatsu } 1050225466f1SSrikar Dronamraju 10514b4da7f7SMasami Hiramatsu return 0; 10524b4da7f7SMasami Hiramatsu } 10534b4da7f7SMasami Hiramatsu 10541d037ca1SIrina Tirdea int show_line_range(struct line_range *lr __maybe_unused, 10552b394bc4SMasami Hiramatsu const char *module __maybe_unused, 10562b394bc4SMasami Hiramatsu bool user __maybe_unused) 10574b4da7f7SMasami Hiramatsu { 1058146a1439SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 1059146a1439SMasami Hiramatsu return -ENOSYS; 10604b4da7f7SMasami Hiramatsu } 10614b4da7f7SMasami Hiramatsu 10621d037ca1SIrina Tirdea int show_available_vars(struct perf_probe_event *pevs __maybe_unused, 1063ddb2f58fSMasami Hiramatsu int npevs __maybe_unused, 1064ddb2f58fSMasami Hiramatsu struct strfilter *filter __maybe_unused) 1065cf6eb489SMasami Hiramatsu { 1066cf6eb489SMasami Hiramatsu pr_warning("Debuginfo-analysis is not supported.\n"); 1067cf6eb489SMasami Hiramatsu return -ENOSYS; 1068cf6eb489SMasami Hiramatsu } 1069e0faa8d3SMasami Hiramatsu #endif 1070e0faa8d3SMasami Hiramatsu 1071e53b00d3SMasami Hiramatsu void line_range__clear(struct line_range *lr) 1072e53b00d3SMasami Hiramatsu { 1073e53b00d3SMasami Hiramatsu free(lr->function); 1074e53b00d3SMasami Hiramatsu free(lr->file); 1075e53b00d3SMasami Hiramatsu free(lr->path); 1076e53b00d3SMasami Hiramatsu free(lr->comp_dir); 10775a62257aSMasami Hiramatsu intlist__delete(lr->line_list); 1078e53b00d3SMasami Hiramatsu memset(lr, 0, sizeof(*lr)); 1079e53b00d3SMasami Hiramatsu } 1080e53b00d3SMasami Hiramatsu 10815a62257aSMasami Hiramatsu int line_range__init(struct line_range *lr) 1082e53b00d3SMasami Hiramatsu { 1083e53b00d3SMasami Hiramatsu memset(lr, 0, sizeof(*lr)); 10845a62257aSMasami Hiramatsu lr->line_list = intlist__new(NULL); 10855a62257aSMasami Hiramatsu if (!lr->line_list) 10865a62257aSMasami Hiramatsu return -ENOMEM; 10875a62257aSMasami Hiramatsu else 10885a62257aSMasami Hiramatsu return 0; 1089e53b00d3SMasami Hiramatsu } 1090e53b00d3SMasami Hiramatsu 109121dd9ae5SFranck Bui-Huu static int parse_line_num(char **ptr, int *val, const char *what) 109221dd9ae5SFranck Bui-Huu { 109321dd9ae5SFranck Bui-Huu const char *start = *ptr; 109421dd9ae5SFranck Bui-Huu 109521dd9ae5SFranck Bui-Huu errno = 0; 109621dd9ae5SFranck Bui-Huu *val = strtol(*ptr, ptr, 0); 109721dd9ae5SFranck Bui-Huu if (errno || *ptr == start) { 109821dd9ae5SFranck Bui-Huu semantic_error("'%s' is not a valid number.\n", what); 109921dd9ae5SFranck Bui-Huu return -EINVAL; 110021dd9ae5SFranck Bui-Huu } 110121dd9ae5SFranck Bui-Huu return 0; 110221dd9ae5SFranck Bui-Huu } 110321dd9ae5SFranck Bui-Huu 1104573709fdSMasami Hiramatsu /* Check the name is good for event, group or function */ 1105573709fdSMasami Hiramatsu static bool is_c_func_name(const char *name) 1106573709fdSMasami Hiramatsu { 1107573709fdSMasami Hiramatsu if (!isalpha(*name) && *name != '_') 1108573709fdSMasami Hiramatsu return false; 1109573709fdSMasami Hiramatsu while (*++name != '\0') { 1110573709fdSMasami Hiramatsu if (!isalpha(*name) && !isdigit(*name) && *name != '_') 1111573709fdSMasami Hiramatsu return false; 1112573709fdSMasami Hiramatsu } 1113573709fdSMasami Hiramatsu return true; 1114573709fdSMasami Hiramatsu } 1115573709fdSMasami Hiramatsu 11169d95b580SFranck Bui-Huu /* 11179d95b580SFranck Bui-Huu * Stuff 'lr' according to the line range described by 'arg'. 11189d95b580SFranck Bui-Huu * The line range syntax is described by: 11199d95b580SFranck Bui-Huu * 11209d95b580SFranck Bui-Huu * SRC[:SLN[+NUM|-ELN]] 1121e116dfa1SMasami Hiramatsu * FNC[@SRC][:SLN[+NUM|-ELN]] 11229d95b580SFranck Bui-Huu */ 1123146a1439SMasami Hiramatsu int parse_line_range_desc(const char *arg, struct line_range *lr) 1124631c9defSMasami Hiramatsu { 1125e116dfa1SMasami Hiramatsu char *range, *file, *name = strdup(arg); 112621dd9ae5SFranck Bui-Huu int err; 11279d95b580SFranck Bui-Huu 112821dd9ae5SFranck Bui-Huu if (!name) 112921dd9ae5SFranck Bui-Huu return -ENOMEM; 113021dd9ae5SFranck Bui-Huu 113121dd9ae5SFranck Bui-Huu lr->start = 0; 113221dd9ae5SFranck Bui-Huu lr->end = INT_MAX; 113321dd9ae5SFranck Bui-Huu 113421dd9ae5SFranck Bui-Huu range = strchr(name, ':'); 113521dd9ae5SFranck Bui-Huu if (range) { 113621dd9ae5SFranck Bui-Huu *range++ = '\0'; 113721dd9ae5SFranck Bui-Huu 113821dd9ae5SFranck Bui-Huu err = parse_line_num(&range, &lr->start, "start line"); 113921dd9ae5SFranck Bui-Huu if (err) 114021dd9ae5SFranck Bui-Huu goto err; 114121dd9ae5SFranck Bui-Huu 114221dd9ae5SFranck Bui-Huu if (*range == '+' || *range == '-') { 114321dd9ae5SFranck Bui-Huu const char c = *range++; 114421dd9ae5SFranck Bui-Huu 114521dd9ae5SFranck Bui-Huu err = parse_line_num(&range, &lr->end, "end line"); 114621dd9ae5SFranck Bui-Huu if (err) 114721dd9ae5SFranck Bui-Huu goto err; 114821dd9ae5SFranck Bui-Huu 114921dd9ae5SFranck Bui-Huu if (c == '+') { 115021dd9ae5SFranck Bui-Huu lr->end += lr->start; 115121dd9ae5SFranck Bui-Huu /* 1152dda4ab34SMasami Hiramatsu * Adjust the number of lines here. 1153dda4ab34SMasami Hiramatsu * If the number of lines == 1, the 1154dda4ab34SMasami Hiramatsu * the end of line should be equal to 1155dda4ab34SMasami Hiramatsu * the start of line. 1156dda4ab34SMasami Hiramatsu */ 115721dd9ae5SFranck Bui-Huu lr->end--; 115821dd9ae5SFranck Bui-Huu } 115921dd9ae5SFranck Bui-Huu } 116021dd9ae5SFranck Bui-Huu 1161d3b63d7aSMasami Hiramatsu pr_debug("Line range is %d to %d\n", lr->start, lr->end); 116221dd9ae5SFranck Bui-Huu 116321dd9ae5SFranck Bui-Huu err = -EINVAL; 1164d3b63d7aSMasami Hiramatsu if (lr->start > lr->end) { 1165631c9defSMasami Hiramatsu semantic_error("Start line must be smaller" 1166146a1439SMasami Hiramatsu " than end line.\n"); 116721dd9ae5SFranck Bui-Huu goto err; 1168146a1439SMasami Hiramatsu } 116921dd9ae5SFranck Bui-Huu if (*range != '\0') { 117021dd9ae5SFranck Bui-Huu semantic_error("Tailing with invalid str '%s'.\n", range); 117121dd9ae5SFranck Bui-Huu goto err; 1172146a1439SMasami Hiramatsu } 1173d3b63d7aSMasami Hiramatsu } 117402b95dadSMasami Hiramatsu 1175e116dfa1SMasami Hiramatsu file = strchr(name, '@'); 1176e116dfa1SMasami Hiramatsu if (file) { 1177e116dfa1SMasami Hiramatsu *file = '\0'; 1178e116dfa1SMasami Hiramatsu lr->file = strdup(++file); 1179e116dfa1SMasami Hiramatsu if (lr->file == NULL) { 1180e116dfa1SMasami Hiramatsu err = -ENOMEM; 1181e116dfa1SMasami Hiramatsu goto err; 1182e116dfa1SMasami Hiramatsu } 1183e116dfa1SMasami Hiramatsu lr->function = name; 1184573709fdSMasami Hiramatsu } else if (strchr(name, '/') || strchr(name, '.')) 118521dd9ae5SFranck Bui-Huu lr->file = name; 1186573709fdSMasami Hiramatsu else if (is_c_func_name(name))/* We reuse it for checking funcname */ 118721dd9ae5SFranck Bui-Huu lr->function = name; 1188573709fdSMasami Hiramatsu else { /* Invalid name */ 1189573709fdSMasami Hiramatsu semantic_error("'%s' is not a valid function name.\n", name); 1190573709fdSMasami Hiramatsu err = -EINVAL; 1191573709fdSMasami Hiramatsu goto err; 1192573709fdSMasami Hiramatsu } 1193146a1439SMasami Hiramatsu 1194146a1439SMasami Hiramatsu return 0; 119521dd9ae5SFranck Bui-Huu err: 119621dd9ae5SFranck Bui-Huu free(name); 119721dd9ae5SFranck Bui-Huu return err; 1198631c9defSMasami Hiramatsu } 1199631c9defSMasami Hiramatsu 120050656eecSMasami Hiramatsu /* Parse probepoint definition. */ 1201146a1439SMasami Hiramatsu static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev) 120250656eecSMasami Hiramatsu { 12034235b045SMasami Hiramatsu struct perf_probe_point *pp = &pev->point; 120450656eecSMasami Hiramatsu char *ptr, *tmp; 120550656eecSMasami Hiramatsu char c, nc = 0; 12063099c026SNaveen N. Rao bool file_spec = false; 120750656eecSMasami Hiramatsu /* 120850656eecSMasami Hiramatsu * <Syntax> 12098d993d96SMasami Hiramatsu * perf probe [GRP:][EVENT=]SRC[:LN|;PTN] 12108d993d96SMasami Hiramatsu * perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT] 121150656eecSMasami Hiramatsu */ 1212e59d29e8SWang Nan if (!arg) 1213e59d29e8SWang Nan return -EINVAL; 121450656eecSMasami Hiramatsu 12152a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";=@+%"); 12162a9c8c36SMasami Hiramatsu if (ptr && *ptr == '=') { /* Event name */ 1217af663d75SMasami Hiramatsu *ptr = '\0'; 1218af663d75SMasami Hiramatsu tmp = ptr + 1; 12198d993d96SMasami Hiramatsu ptr = strchr(arg, ':'); 12208d993d96SMasami Hiramatsu if (ptr) { 12218d993d96SMasami Hiramatsu *ptr = '\0'; 12228d993d96SMasami Hiramatsu if (!is_c_func_name(arg)) 12238d993d96SMasami Hiramatsu goto not_fname; 12248d993d96SMasami Hiramatsu pev->group = strdup(arg); 12258d993d96SMasami Hiramatsu if (!pev->group) 12268d993d96SMasami Hiramatsu return -ENOMEM; 12278d993d96SMasami Hiramatsu arg = ptr + 1; 12288d993d96SMasami Hiramatsu } else 12298d993d96SMasami Hiramatsu pev->group = NULL; 1230573709fdSMasami Hiramatsu if (!is_c_func_name(arg)) { 12318d993d96SMasami Hiramatsu not_fname: 1232b7702a21SMasami Hiramatsu semantic_error("%s is bad for event name -it must " 1233146a1439SMasami Hiramatsu "follow C symbol-naming rule.\n", arg); 1234146a1439SMasami Hiramatsu return -EINVAL; 1235146a1439SMasami Hiramatsu } 123602b95dadSMasami Hiramatsu pev->event = strdup(arg); 123702b95dadSMasami Hiramatsu if (pev->event == NULL) 123802b95dadSMasami Hiramatsu return -ENOMEM; 1239af663d75SMasami Hiramatsu arg = tmp; 1240af663d75SMasami Hiramatsu } 1241af663d75SMasami Hiramatsu 12423099c026SNaveen N. Rao /* 12433099c026SNaveen N. Rao * Check arg is function or file name and copy it. 12443099c026SNaveen N. Rao * 12453099c026SNaveen N. Rao * We consider arg to be a file spec if and only if it satisfies 12463099c026SNaveen N. Rao * all of the below criteria:: 12473099c026SNaveen N. Rao * - it does not include any of "+@%", 12483099c026SNaveen N. Rao * - it includes one of ":;", and 12493099c026SNaveen N. Rao * - it has a period '.' in the name. 12503099c026SNaveen N. Rao * 12513099c026SNaveen N. Rao * Otherwise, we consider arg to be a function specification. 12523099c026SNaveen N. Rao */ 12533099c026SNaveen N. Rao if (!strpbrk(arg, "+@%") && (ptr = strpbrk(arg, ";:")) != NULL) { 12543099c026SNaveen N. Rao /* This is a file spec if it includes a '.' before ; or : */ 12553099c026SNaveen N. Rao if (memchr(arg, '.', ptr - arg)) 12563099c026SNaveen N. Rao file_spec = true; 12573099c026SNaveen N. Rao } 12583099c026SNaveen N. Rao 12592a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";:+@%"); 126050656eecSMasami Hiramatsu if (ptr) { 126150656eecSMasami Hiramatsu nc = *ptr; 126250656eecSMasami Hiramatsu *ptr++ = '\0'; 126350656eecSMasami Hiramatsu } 126450656eecSMasami Hiramatsu 12656c6e024fSWang Nan if (arg[0] == '\0') 12666c6e024fSWang Nan tmp = NULL; 12676c6e024fSWang Nan else { 126802b95dadSMasami Hiramatsu tmp = strdup(arg); 126902b95dadSMasami Hiramatsu if (tmp == NULL) 127002b95dadSMasami Hiramatsu return -ENOMEM; 12716c6e024fSWang Nan } 127202b95dadSMasami Hiramatsu 12733099c026SNaveen N. Rao if (file_spec) 127402b95dadSMasami Hiramatsu pp->file = tmp; 1275da15bd9dSWang Nan else { 127602b95dadSMasami Hiramatsu pp->function = tmp; 127750656eecSMasami Hiramatsu 1278da15bd9dSWang Nan /* 1279da15bd9dSWang Nan * Keep pp->function even if this is absolute address, 1280da15bd9dSWang Nan * so it can mark whether abs_address is valid. 1281da15bd9dSWang Nan * Which make 'perf probe lib.bin 0x0' possible. 1282da15bd9dSWang Nan * 1283da15bd9dSWang Nan * Note that checking length of tmp is not needed 1284da15bd9dSWang Nan * because when we access tmp[1] we know tmp[0] is '0', 1285da15bd9dSWang Nan * so tmp[1] should always valid (but could be '\0'). 1286da15bd9dSWang Nan */ 1287da15bd9dSWang Nan if (tmp && !strncmp(tmp, "0x", 2)) { 1288da15bd9dSWang Nan pp->abs_address = strtoul(pp->function, &tmp, 0); 1289da15bd9dSWang Nan if (*tmp != '\0') { 1290da15bd9dSWang Nan semantic_error("Invalid absolute address.\n"); 1291da15bd9dSWang Nan return -EINVAL; 1292da15bd9dSWang Nan } 1293da15bd9dSWang Nan } 1294da15bd9dSWang Nan } 1295da15bd9dSWang Nan 129650656eecSMasami Hiramatsu /* Parse other options */ 129750656eecSMasami Hiramatsu while (ptr) { 129850656eecSMasami Hiramatsu arg = ptr; 129950656eecSMasami Hiramatsu c = nc; 13002a9c8c36SMasami Hiramatsu if (c == ';') { /* Lazy pattern must be the last part */ 130102b95dadSMasami Hiramatsu pp->lazy_line = strdup(arg); 130202b95dadSMasami Hiramatsu if (pp->lazy_line == NULL) 130302b95dadSMasami Hiramatsu return -ENOMEM; 13042a9c8c36SMasami Hiramatsu break; 13052a9c8c36SMasami Hiramatsu } 13062a9c8c36SMasami Hiramatsu ptr = strpbrk(arg, ";:+@%"); 130750656eecSMasami Hiramatsu if (ptr) { 130850656eecSMasami Hiramatsu nc = *ptr; 130950656eecSMasami Hiramatsu *ptr++ = '\0'; 131050656eecSMasami Hiramatsu } 131150656eecSMasami Hiramatsu switch (c) { 131250656eecSMasami Hiramatsu case ':': /* Line number */ 131350656eecSMasami Hiramatsu pp->line = strtoul(arg, &tmp, 0); 1314146a1439SMasami Hiramatsu if (*tmp != '\0') { 13152a9c8c36SMasami Hiramatsu semantic_error("There is non-digit char" 1316146a1439SMasami Hiramatsu " in line number.\n"); 1317146a1439SMasami Hiramatsu return -EINVAL; 1318146a1439SMasami Hiramatsu } 131950656eecSMasami Hiramatsu break; 132050656eecSMasami Hiramatsu case '+': /* Byte offset from a symbol */ 132150656eecSMasami Hiramatsu pp->offset = strtoul(arg, &tmp, 0); 1322146a1439SMasami Hiramatsu if (*tmp != '\0') { 13232a9c8c36SMasami Hiramatsu semantic_error("There is non-digit character" 1324146a1439SMasami Hiramatsu " in offset.\n"); 1325146a1439SMasami Hiramatsu return -EINVAL; 1326146a1439SMasami Hiramatsu } 132750656eecSMasami Hiramatsu break; 132850656eecSMasami Hiramatsu case '@': /* File name */ 1329146a1439SMasami Hiramatsu if (pp->file) { 1330146a1439SMasami Hiramatsu semantic_error("SRC@SRC is not allowed.\n"); 1331146a1439SMasami Hiramatsu return -EINVAL; 1332146a1439SMasami Hiramatsu } 133302b95dadSMasami Hiramatsu pp->file = strdup(arg); 133402b95dadSMasami Hiramatsu if (pp->file == NULL) 133502b95dadSMasami Hiramatsu return -ENOMEM; 133650656eecSMasami Hiramatsu break; 133750656eecSMasami Hiramatsu case '%': /* Probe places */ 133850656eecSMasami Hiramatsu if (strcmp(arg, "return") == 0) { 133950656eecSMasami Hiramatsu pp->retprobe = 1; 1340146a1439SMasami Hiramatsu } else { /* Others not supported yet */ 1341146a1439SMasami Hiramatsu semantic_error("%%%s is not supported.\n", arg); 1342146a1439SMasami Hiramatsu return -ENOTSUP; 1343146a1439SMasami Hiramatsu } 134450656eecSMasami Hiramatsu break; 1345146a1439SMasami Hiramatsu default: /* Buggy case */ 1346146a1439SMasami Hiramatsu pr_err("This program has a bug at %s:%d.\n", 1347146a1439SMasami Hiramatsu __FILE__, __LINE__); 1348146a1439SMasami Hiramatsu return -ENOTSUP; 134950656eecSMasami Hiramatsu break; 135050656eecSMasami Hiramatsu } 135150656eecSMasami Hiramatsu } 135250656eecSMasami Hiramatsu 135350656eecSMasami Hiramatsu /* Exclusion check */ 1354146a1439SMasami Hiramatsu if (pp->lazy_line && pp->line) { 13550e43e5d2SMasami Hiramatsu semantic_error("Lazy pattern can't be used with" 13560e43e5d2SMasami Hiramatsu " line number.\n"); 1357146a1439SMasami Hiramatsu return -EINVAL; 1358146a1439SMasami Hiramatsu } 13592a9c8c36SMasami Hiramatsu 1360146a1439SMasami Hiramatsu if (pp->lazy_line && pp->offset) { 13610e43e5d2SMasami Hiramatsu semantic_error("Lazy pattern can't be used with offset.\n"); 1362146a1439SMasami Hiramatsu return -EINVAL; 1363146a1439SMasami Hiramatsu } 13642a9c8c36SMasami Hiramatsu 1365146a1439SMasami Hiramatsu if (pp->line && pp->offset) { 13660e43e5d2SMasami Hiramatsu semantic_error("Offset can't be used with line number.\n"); 1367146a1439SMasami Hiramatsu return -EINVAL; 1368146a1439SMasami Hiramatsu } 136950656eecSMasami Hiramatsu 1370146a1439SMasami Hiramatsu if (!pp->line && !pp->lazy_line && pp->file && !pp->function) { 13712a9c8c36SMasami Hiramatsu semantic_error("File always requires line number or " 13720e43e5d2SMasami Hiramatsu "lazy pattern.\n"); 1373146a1439SMasami Hiramatsu return -EINVAL; 1374146a1439SMasami Hiramatsu } 137550656eecSMasami Hiramatsu 1376146a1439SMasami Hiramatsu if (pp->offset && !pp->function) { 13770e43e5d2SMasami Hiramatsu semantic_error("Offset requires an entry function.\n"); 1378146a1439SMasami Hiramatsu return -EINVAL; 1379146a1439SMasami Hiramatsu } 138050656eecSMasami Hiramatsu 1381146a1439SMasami Hiramatsu if (pp->retprobe && !pp->function) { 13820e43e5d2SMasami Hiramatsu semantic_error("Return probe requires an entry function.\n"); 1383146a1439SMasami Hiramatsu return -EINVAL; 1384146a1439SMasami Hiramatsu } 138550656eecSMasami Hiramatsu 1386146a1439SMasami Hiramatsu if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) { 13872a9c8c36SMasami Hiramatsu semantic_error("Offset/Line/Lazy pattern can't be used with " 13880e43e5d2SMasami Hiramatsu "return probe.\n"); 1389146a1439SMasami Hiramatsu return -EINVAL; 1390146a1439SMasami Hiramatsu } 139150656eecSMasami Hiramatsu 13924235b045SMasami Hiramatsu pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n", 13932a9c8c36SMasami Hiramatsu pp->function, pp->file, pp->line, pp->offset, pp->retprobe, 13942a9c8c36SMasami Hiramatsu pp->lazy_line); 1395146a1439SMasami Hiramatsu return 0; 139650656eecSMasami Hiramatsu } 139750656eecSMasami Hiramatsu 13987df2f329SMasami Hiramatsu /* Parse perf-probe event argument */ 1399146a1439SMasami Hiramatsu static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg) 14007df2f329SMasami Hiramatsu { 1401b2a3c12bSMasami Hiramatsu char *tmp, *goodname; 14027df2f329SMasami Hiramatsu struct perf_probe_arg_field **fieldp; 14037df2f329SMasami Hiramatsu 14047df2f329SMasami Hiramatsu pr_debug("parsing arg: %s into ", str); 14057df2f329SMasami Hiramatsu 140648481938SMasami Hiramatsu tmp = strchr(str, '='); 140748481938SMasami Hiramatsu if (tmp) { 140802b95dadSMasami Hiramatsu arg->name = strndup(str, tmp - str); 140902b95dadSMasami Hiramatsu if (arg->name == NULL) 141002b95dadSMasami Hiramatsu return -ENOMEM; 141111a1ca35SMasami Hiramatsu pr_debug("name:%s ", arg->name); 141248481938SMasami Hiramatsu str = tmp + 1; 141348481938SMasami Hiramatsu } 141448481938SMasami Hiramatsu 141511a1ca35SMasami Hiramatsu tmp = strchr(str, ':'); 141611a1ca35SMasami Hiramatsu if (tmp) { /* Type setting */ 141711a1ca35SMasami Hiramatsu *tmp = '\0'; 141802b95dadSMasami Hiramatsu arg->type = strdup(tmp + 1); 141902b95dadSMasami Hiramatsu if (arg->type == NULL) 142002b95dadSMasami Hiramatsu return -ENOMEM; 142111a1ca35SMasami Hiramatsu pr_debug("type:%s ", arg->type); 142211a1ca35SMasami Hiramatsu } 142311a1ca35SMasami Hiramatsu 1424b2a3c12bSMasami Hiramatsu tmp = strpbrk(str, "-.["); 14257df2f329SMasami Hiramatsu if (!is_c_varname(str) || !tmp) { 14267df2f329SMasami Hiramatsu /* A variable, register, symbol or special value */ 142702b95dadSMasami Hiramatsu arg->var = strdup(str); 142802b95dadSMasami Hiramatsu if (arg->var == NULL) 142902b95dadSMasami Hiramatsu return -ENOMEM; 143048481938SMasami Hiramatsu pr_debug("%s\n", arg->var); 1431146a1439SMasami Hiramatsu return 0; 14327df2f329SMasami Hiramatsu } 14337df2f329SMasami Hiramatsu 1434b2a3c12bSMasami Hiramatsu /* Structure fields or array element */ 143502b95dadSMasami Hiramatsu arg->var = strndup(str, tmp - str); 143602b95dadSMasami Hiramatsu if (arg->var == NULL) 143702b95dadSMasami Hiramatsu return -ENOMEM; 1438b2a3c12bSMasami Hiramatsu goodname = arg->var; 143948481938SMasami Hiramatsu pr_debug("%s, ", arg->var); 14407df2f329SMasami Hiramatsu fieldp = &arg->field; 14417df2f329SMasami Hiramatsu 14427df2f329SMasami Hiramatsu do { 1443e334016fSMasami Hiramatsu *fieldp = zalloc(sizeof(struct perf_probe_arg_field)); 1444e334016fSMasami Hiramatsu if (*fieldp == NULL) 1445e334016fSMasami Hiramatsu return -ENOMEM; 1446b2a3c12bSMasami Hiramatsu if (*tmp == '[') { /* Array */ 1447b2a3c12bSMasami Hiramatsu str = tmp; 1448b2a3c12bSMasami Hiramatsu (*fieldp)->index = strtol(str + 1, &tmp, 0); 1449b2a3c12bSMasami Hiramatsu (*fieldp)->ref = true; 1450b2a3c12bSMasami Hiramatsu if (*tmp != ']' || tmp == str + 1) { 1451b2a3c12bSMasami Hiramatsu semantic_error("Array index must be a" 1452b2a3c12bSMasami Hiramatsu " number.\n"); 1453b2a3c12bSMasami Hiramatsu return -EINVAL; 1454b2a3c12bSMasami Hiramatsu } 1455b2a3c12bSMasami Hiramatsu tmp++; 1456b2a3c12bSMasami Hiramatsu if (*tmp == '\0') 1457b2a3c12bSMasami Hiramatsu tmp = NULL; 1458b2a3c12bSMasami Hiramatsu } else { /* Structure */ 14597df2f329SMasami Hiramatsu if (*tmp == '.') { 14607df2f329SMasami Hiramatsu str = tmp + 1; 14617df2f329SMasami Hiramatsu (*fieldp)->ref = false; 14627df2f329SMasami Hiramatsu } else if (tmp[1] == '>') { 14637df2f329SMasami Hiramatsu str = tmp + 2; 14647df2f329SMasami Hiramatsu (*fieldp)->ref = true; 1465146a1439SMasami Hiramatsu } else { 1466b2a3c12bSMasami Hiramatsu semantic_error("Argument parse error: %s\n", 1467b2a3c12bSMasami Hiramatsu str); 1468146a1439SMasami Hiramatsu return -EINVAL; 1469146a1439SMasami Hiramatsu } 1470b2a3c12bSMasami Hiramatsu tmp = strpbrk(str, "-.["); 1471b2a3c12bSMasami Hiramatsu } 14727df2f329SMasami Hiramatsu if (tmp) { 147302b95dadSMasami Hiramatsu (*fieldp)->name = strndup(str, tmp - str); 147402b95dadSMasami Hiramatsu if ((*fieldp)->name == NULL) 147502b95dadSMasami Hiramatsu return -ENOMEM; 1476b2a3c12bSMasami Hiramatsu if (*str != '[') 1477b2a3c12bSMasami Hiramatsu goodname = (*fieldp)->name; 14787df2f329SMasami Hiramatsu pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref); 14797df2f329SMasami Hiramatsu fieldp = &(*fieldp)->next; 14807df2f329SMasami Hiramatsu } 14817df2f329SMasami Hiramatsu } while (tmp); 148202b95dadSMasami Hiramatsu (*fieldp)->name = strdup(str); 148302b95dadSMasami Hiramatsu if ((*fieldp)->name == NULL) 148402b95dadSMasami Hiramatsu return -ENOMEM; 1485b2a3c12bSMasami Hiramatsu if (*str != '[') 1486b2a3c12bSMasami Hiramatsu goodname = (*fieldp)->name; 14877df2f329SMasami Hiramatsu pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref); 1488df0faf4bSMasami Hiramatsu 1489b2a3c12bSMasami Hiramatsu /* If no name is specified, set the last field name (not array index)*/ 149002b95dadSMasami Hiramatsu if (!arg->name) { 1491b2a3c12bSMasami Hiramatsu arg->name = strdup(goodname); 149202b95dadSMasami Hiramatsu if (arg->name == NULL) 149302b95dadSMasami Hiramatsu return -ENOMEM; 149402b95dadSMasami Hiramatsu } 1495146a1439SMasami Hiramatsu return 0; 14967df2f329SMasami Hiramatsu } 14977df2f329SMasami Hiramatsu 14984235b045SMasami Hiramatsu /* Parse perf-probe event command */ 1499146a1439SMasami Hiramatsu int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev) 150050656eecSMasami Hiramatsu { 1501e1c01d61SMasami Hiramatsu char **argv; 1502146a1439SMasami Hiramatsu int argc, i, ret = 0; 1503fac13fd5SMasami Hiramatsu 15044235b045SMasami Hiramatsu argv = argv_split(cmd, &argc); 1505146a1439SMasami Hiramatsu if (!argv) { 1506146a1439SMasami Hiramatsu pr_debug("Failed to split arguments.\n"); 1507146a1439SMasami Hiramatsu return -ENOMEM; 1508146a1439SMasami Hiramatsu } 1509146a1439SMasami Hiramatsu if (argc - 1 > MAX_PROBE_ARGS) { 1510146a1439SMasami Hiramatsu semantic_error("Too many probe arguments (%d).\n", argc - 1); 1511146a1439SMasami Hiramatsu ret = -ERANGE; 1512146a1439SMasami Hiramatsu goto out; 1513146a1439SMasami Hiramatsu } 151450656eecSMasami Hiramatsu /* Parse probe point */ 1515146a1439SMasami Hiramatsu ret = parse_perf_probe_point(argv[0], pev); 1516146a1439SMasami Hiramatsu if (ret < 0) 1517146a1439SMasami Hiramatsu goto out; 151850656eecSMasami Hiramatsu 1519e1c01d61SMasami Hiramatsu /* Copy arguments and ensure return probe has no C argument */ 15204235b045SMasami Hiramatsu pev->nargs = argc - 1; 1521e334016fSMasami Hiramatsu pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs); 1522e334016fSMasami Hiramatsu if (pev->args == NULL) { 1523e334016fSMasami Hiramatsu ret = -ENOMEM; 1524e334016fSMasami Hiramatsu goto out; 1525e334016fSMasami Hiramatsu } 1526146a1439SMasami Hiramatsu for (i = 0; i < pev->nargs && ret >= 0; i++) { 1527146a1439SMasami Hiramatsu ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]); 1528146a1439SMasami Hiramatsu if (ret >= 0 && 1529146a1439SMasami Hiramatsu is_c_varname(pev->args[i].var) && pev->point.retprobe) { 15304235b045SMasami Hiramatsu semantic_error("You can't specify local variable for" 1531146a1439SMasami Hiramatsu " kretprobe.\n"); 1532146a1439SMasami Hiramatsu ret = -EINVAL; 1533e1c01d61SMasami Hiramatsu } 1534146a1439SMasami Hiramatsu } 1535146a1439SMasami Hiramatsu out: 1536e1c01d61SMasami Hiramatsu argv_free(argv); 1537146a1439SMasami Hiramatsu 1538146a1439SMasami Hiramatsu return ret; 153950656eecSMasami Hiramatsu } 154050656eecSMasami Hiramatsu 15414235b045SMasami Hiramatsu /* Return true if this perf_probe_event requires debuginfo */ 15424235b045SMasami Hiramatsu bool perf_probe_event_need_dwarf(struct perf_probe_event *pev) 15434de189feSMasami Hiramatsu { 15444235b045SMasami Hiramatsu int i; 15454235b045SMasami Hiramatsu 15464235b045SMasami Hiramatsu if (pev->point.file || pev->point.line || pev->point.lazy_line) 15474235b045SMasami Hiramatsu return true; 15484235b045SMasami Hiramatsu 15494235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) 155048481938SMasami Hiramatsu if (is_c_varname(pev->args[i].var)) 15514235b045SMasami Hiramatsu return true; 15524235b045SMasami Hiramatsu 15534235b045SMasami Hiramatsu return false; 15544235b045SMasami Hiramatsu } 15554235b045SMasami Hiramatsu 15560e60836bSSrikar Dronamraju /* Parse probe_events event into struct probe_point */ 155792f6c72eSMasami Hiramatsu int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev) 15584235b045SMasami Hiramatsu { 15590e60836bSSrikar Dronamraju struct probe_trace_point *tp = &tev->point; 15604de189feSMasami Hiramatsu char pr; 15614de189feSMasami Hiramatsu char *p; 1562bcbd0040SIrina Tirdea char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str; 15634de189feSMasami Hiramatsu int ret, i, argc; 15644de189feSMasami Hiramatsu char **argv; 15654de189feSMasami Hiramatsu 15660e60836bSSrikar Dronamraju pr_debug("Parsing probe_events: %s\n", cmd); 15674235b045SMasami Hiramatsu argv = argv_split(cmd, &argc); 1568146a1439SMasami Hiramatsu if (!argv) { 1569146a1439SMasami Hiramatsu pr_debug("Failed to split arguments.\n"); 1570146a1439SMasami Hiramatsu return -ENOMEM; 1571146a1439SMasami Hiramatsu } 1572146a1439SMasami Hiramatsu if (argc < 2) { 1573146a1439SMasami Hiramatsu semantic_error("Too few probe arguments.\n"); 1574146a1439SMasami Hiramatsu ret = -ERANGE; 1575146a1439SMasami Hiramatsu goto out; 1576146a1439SMasami Hiramatsu } 15774de189feSMasami Hiramatsu 15784de189feSMasami Hiramatsu /* Scan event and group name. */ 1579bcbd0040SIrina Tirdea argv0_str = strdup(argv[0]); 1580bcbd0040SIrina Tirdea if (argv0_str == NULL) { 1581bcbd0040SIrina Tirdea ret = -ENOMEM; 1582bcbd0040SIrina Tirdea goto out; 1583bcbd0040SIrina Tirdea } 1584bcbd0040SIrina Tirdea fmt1_str = strtok_r(argv0_str, ":", &fmt); 1585bcbd0040SIrina Tirdea fmt2_str = strtok_r(NULL, "/", &fmt); 1586bcbd0040SIrina Tirdea fmt3_str = strtok_r(NULL, " \t", &fmt); 1587bcbd0040SIrina Tirdea if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL 1588bcbd0040SIrina Tirdea || fmt3_str == NULL) { 1589146a1439SMasami Hiramatsu semantic_error("Failed to parse event name: %s\n", argv[0]); 1590146a1439SMasami Hiramatsu ret = -EINVAL; 1591146a1439SMasami Hiramatsu goto out; 1592146a1439SMasami Hiramatsu } 1593bcbd0040SIrina Tirdea pr = fmt1_str[0]; 1594bcbd0040SIrina Tirdea tev->group = strdup(fmt2_str); 1595bcbd0040SIrina Tirdea tev->event = strdup(fmt3_str); 1596bcbd0040SIrina Tirdea if (tev->group == NULL || tev->event == NULL) { 1597bcbd0040SIrina Tirdea ret = -ENOMEM; 1598bcbd0040SIrina Tirdea goto out; 1599bcbd0040SIrina Tirdea } 16004235b045SMasami Hiramatsu pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr); 16014de189feSMasami Hiramatsu 16024235b045SMasami Hiramatsu tp->retprobe = (pr == 'r'); 16034de189feSMasami Hiramatsu 1604190b57fcSMasami Hiramatsu /* Scan module name(if there), function name and offset */ 1605190b57fcSMasami Hiramatsu p = strchr(argv[1], ':'); 1606190b57fcSMasami Hiramatsu if (p) { 1607190b57fcSMasami Hiramatsu tp->module = strndup(argv[1], p - argv[1]); 1608844faa4bSMasami Hiramatsu if (!tp->module) { 1609844faa4bSMasami Hiramatsu ret = -ENOMEM; 1610844faa4bSMasami Hiramatsu goto out; 1611844faa4bSMasami Hiramatsu } 1612190b57fcSMasami Hiramatsu p++; 1613190b57fcSMasami Hiramatsu } else 1614190b57fcSMasami Hiramatsu p = argv[1]; 1615bcbd0040SIrina Tirdea fmt1_str = strtok_r(p, "+", &fmt); 1616be07afe9SWang Nan /* only the address started with 0x */ 1617be07afe9SWang Nan if (fmt1_str[0] == '0') { 1618be07afe9SWang Nan /* 1619be07afe9SWang Nan * Fix a special case: 1620be07afe9SWang Nan * if address == 0, kernel reports something like: 1621be07afe9SWang Nan * p:probe_libc/abs_0 /lib/libc-2.18.so:0x (null) arg1=%ax 1622be07afe9SWang Nan * Newer kernel may fix that, but we want to 1623be07afe9SWang Nan * support old kernel also. 1624be07afe9SWang Nan */ 1625be07afe9SWang Nan if (strcmp(fmt1_str, "0x") == 0) { 1626be07afe9SWang Nan if (!argv[2] || strcmp(argv[2], "(null)")) { 1627be07afe9SWang Nan ret = -EINVAL; 1628be07afe9SWang Nan goto out; 1629be07afe9SWang Nan } 1630be07afe9SWang Nan tp->address = 0; 1631be07afe9SWang Nan 1632be07afe9SWang Nan free(argv[2]); 1633be07afe9SWang Nan for (i = 2; argv[i + 1] != NULL; i++) 1634be07afe9SWang Nan argv[i] = argv[i + 1]; 1635be07afe9SWang Nan 1636be07afe9SWang Nan argv[i] = NULL; 1637be07afe9SWang Nan argc -= 1; 1638be07afe9SWang Nan } else 16395a6f6314SMasami Hiramatsu tp->address = strtoul(fmt1_str, NULL, 0); 1640be07afe9SWang Nan } else { 16415a6f6314SMasami Hiramatsu /* Only the symbol-based probe has offset */ 1642bcbd0040SIrina Tirdea tp->symbol = strdup(fmt1_str); 1643bcbd0040SIrina Tirdea if (tp->symbol == NULL) { 1644bcbd0040SIrina Tirdea ret = -ENOMEM; 1645bcbd0040SIrina Tirdea goto out; 1646bcbd0040SIrina Tirdea } 1647bcbd0040SIrina Tirdea fmt2_str = strtok_r(NULL, "", &fmt); 1648bcbd0040SIrina Tirdea if (fmt2_str == NULL) 16494235b045SMasami Hiramatsu tp->offset = 0; 1650bcbd0040SIrina Tirdea else 1651bcbd0040SIrina Tirdea tp->offset = strtoul(fmt2_str, NULL, 10); 16525a6f6314SMasami Hiramatsu } 16534de189feSMasami Hiramatsu 16544235b045SMasami Hiramatsu tev->nargs = argc - 2; 16550e60836bSSrikar Dronamraju tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); 1656e334016fSMasami Hiramatsu if (tev->args == NULL) { 1657e334016fSMasami Hiramatsu ret = -ENOMEM; 1658e334016fSMasami Hiramatsu goto out; 1659e334016fSMasami Hiramatsu } 16604235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 16614de189feSMasami Hiramatsu p = strchr(argv[i + 2], '='); 16624de189feSMasami Hiramatsu if (p) /* We don't need which register is assigned. */ 16634235b045SMasami Hiramatsu *p++ = '\0'; 16644235b045SMasami Hiramatsu else 16654235b045SMasami Hiramatsu p = argv[i + 2]; 166602b95dadSMasami Hiramatsu tev->args[i].name = strdup(argv[i + 2]); 16674235b045SMasami Hiramatsu /* TODO: parse regs and offset */ 166802b95dadSMasami Hiramatsu tev->args[i].value = strdup(p); 166902b95dadSMasami Hiramatsu if (tev->args[i].name == NULL || tev->args[i].value == NULL) { 167002b95dadSMasami Hiramatsu ret = -ENOMEM; 167102b95dadSMasami Hiramatsu goto out; 167202b95dadSMasami Hiramatsu } 16734de189feSMasami Hiramatsu } 1674146a1439SMasami Hiramatsu ret = 0; 1675146a1439SMasami Hiramatsu out: 1676bcbd0040SIrina Tirdea free(argv0_str); 16774de189feSMasami Hiramatsu argv_free(argv); 1678146a1439SMasami Hiramatsu return ret; 16794de189feSMasami Hiramatsu } 16804de189feSMasami Hiramatsu 16817df2f329SMasami Hiramatsu /* Compose only probe arg */ 1682909b0360SMasami Hiramatsu char *synthesize_perf_probe_arg(struct perf_probe_arg *pa) 16837df2f329SMasami Hiramatsu { 16847df2f329SMasami Hiramatsu struct perf_probe_arg_field *field = pa->field; 1685909b0360SMasami Hiramatsu struct strbuf buf; 1686bf4d5f25SMasami Hiramatsu char *ret = NULL; 1687bf4d5f25SMasami Hiramatsu int err; 16887df2f329SMasami Hiramatsu 1689bf4d5f25SMasami Hiramatsu if (strbuf_init(&buf, 64) < 0) 1690bf4d5f25SMasami Hiramatsu return NULL; 1691bf4d5f25SMasami Hiramatsu 169248481938SMasami Hiramatsu if (pa->name && pa->var) 1693bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var); 169448481938SMasami Hiramatsu else 1695bf4d5f25SMasami Hiramatsu err = strbuf_addstr(&buf, pa->name ?: pa->var); 1696bf4d5f25SMasami Hiramatsu if (err) 1697bf4d5f25SMasami Hiramatsu goto out; 16987df2f329SMasami Hiramatsu 16997df2f329SMasami Hiramatsu while (field) { 1700b2a3c12bSMasami Hiramatsu if (field->name[0] == '[') 1701bf4d5f25SMasami Hiramatsu err = strbuf_addstr(&buf, field->name); 1702b2a3c12bSMasami Hiramatsu else 1703bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".", 1704909b0360SMasami Hiramatsu field->name); 17057df2f329SMasami Hiramatsu field = field->next; 1706bf4d5f25SMasami Hiramatsu if (err) 1707bf4d5f25SMasami Hiramatsu goto out; 17087df2f329SMasami Hiramatsu } 170911a1ca35SMasami Hiramatsu 1710909b0360SMasami Hiramatsu if (pa->type) 1711bf4d5f25SMasami Hiramatsu if (strbuf_addf(&buf, ":%s", pa->type) < 0) 1712bf4d5f25SMasami Hiramatsu goto out; 171311a1ca35SMasami Hiramatsu 1714909b0360SMasami Hiramatsu ret = strbuf_detach(&buf, NULL); 1715bf4d5f25SMasami Hiramatsu out: 1716bf4d5f25SMasami Hiramatsu strbuf_release(&buf); 1717146a1439SMasami Hiramatsu return ret; 17187df2f329SMasami Hiramatsu } 17197df2f329SMasami Hiramatsu 17204235b045SMasami Hiramatsu /* Compose only probe point (not argument) */ 1721c4ff4920SMasami Hiramatsu char *synthesize_perf_probe_point(struct perf_probe_point *pp) 172250656eecSMasami Hiramatsu { 1723909b0360SMasami Hiramatsu struct strbuf buf; 1724bf4d5f25SMasami Hiramatsu char *tmp, *ret = NULL; 1725bf4d5f25SMasami Hiramatsu int len, err = 0; 172650656eecSMasami Hiramatsu 1727bf4d5f25SMasami Hiramatsu if (strbuf_init(&buf, 64) < 0) 1728bf4d5f25SMasami Hiramatsu return NULL; 1729bf4d5f25SMasami Hiramatsu 1730909b0360SMasami Hiramatsu if (pp->function) { 1731bf4d5f25SMasami Hiramatsu if (strbuf_addstr(&buf, pp->function) < 0) 1732bf4d5f25SMasami Hiramatsu goto out; 1733909b0360SMasami Hiramatsu if (pp->offset) 1734bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "+%lu", pp->offset); 1735909b0360SMasami Hiramatsu else if (pp->line) 1736bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, ":%d", pp->line); 1737909b0360SMasami Hiramatsu else if (pp->retprobe) 1738bf4d5f25SMasami Hiramatsu err = strbuf_addstr(&buf, "%return"); 1739bf4d5f25SMasami Hiramatsu if (err) 1740bf4d5f25SMasami Hiramatsu goto out; 1741fb1587d8SMasami Hiramatsu } 1742fb1587d8SMasami Hiramatsu if (pp->file) { 174332ae2adeSFranck Bui-Huu tmp = pp->file; 174432ae2adeSFranck Bui-Huu len = strlen(tmp); 174532ae2adeSFranck Bui-Huu if (len > 30) { 174632ae2adeSFranck Bui-Huu tmp = strchr(pp->file + len - 30, '/'); 174732ae2adeSFranck Bui-Huu tmp = tmp ? tmp + 1 : pp->file + len - 30; 174832ae2adeSFranck Bui-Huu } 1749bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "@%s", tmp); 1750bf4d5f25SMasami Hiramatsu if (!err && !pp->function && pp->line) 1751bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, ":%d", pp->line); 17524de189feSMasami Hiramatsu } 1753bf4d5f25SMasami Hiramatsu if (!err) 1754bf4d5f25SMasami Hiramatsu ret = strbuf_detach(&buf, NULL); 1755bf4d5f25SMasami Hiramatsu out: 1756bf4d5f25SMasami Hiramatsu strbuf_release(&buf); 1757bf4d5f25SMasami Hiramatsu return ret; 17584235b045SMasami Hiramatsu } 17594235b045SMasami Hiramatsu 17604235b045SMasami Hiramatsu char *synthesize_perf_probe_command(struct perf_probe_event *pev) 17614235b045SMasami Hiramatsu { 1762c4ff4920SMasami Hiramatsu struct strbuf buf; 1763c4ff4920SMasami Hiramatsu char *tmp, *ret = NULL; 1764c4ff4920SMasami Hiramatsu int i; 17654235b045SMasami Hiramatsu 1766c4ff4920SMasami Hiramatsu if (strbuf_init(&buf, 64)) 17674235b045SMasami Hiramatsu return NULL; 1768c4ff4920SMasami Hiramatsu if (pev->event) 1769c4ff4920SMasami Hiramatsu if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP, 1770c4ff4920SMasami Hiramatsu pev->event) < 0) 1771c4ff4920SMasami Hiramatsu goto out; 17724235b045SMasami Hiramatsu 1773c4ff4920SMasami Hiramatsu tmp = synthesize_perf_probe_point(&pev->point); 1774c4ff4920SMasami Hiramatsu if (!tmp || strbuf_addstr(&buf, tmp) < 0) 1775c4ff4920SMasami Hiramatsu goto out; 1776c4ff4920SMasami Hiramatsu free(tmp); 1777c4ff4920SMasami Hiramatsu 17784235b045SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 1779c4ff4920SMasami Hiramatsu tmp = synthesize_perf_probe_arg(pev->args + i); 1780c4ff4920SMasami Hiramatsu if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0) 1781c4ff4920SMasami Hiramatsu goto out; 1782c4ff4920SMasami Hiramatsu free(tmp); 17837ef17aafSMasami Hiramatsu } 178450656eecSMasami Hiramatsu 1785c4ff4920SMasami Hiramatsu ret = strbuf_detach(&buf, NULL); 1786c4ff4920SMasami Hiramatsu out: 1787c4ff4920SMasami Hiramatsu strbuf_release(&buf); 1788c4ff4920SMasami Hiramatsu return ret; 17894235b045SMasami Hiramatsu } 17904235b045SMasami Hiramatsu 17910e60836bSSrikar Dronamraju static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref, 1792909b0360SMasami Hiramatsu struct strbuf *buf, int depth) 17937ef17aafSMasami Hiramatsu { 1794bf4d5f25SMasami Hiramatsu int err; 17954235b045SMasami Hiramatsu if (ref->next) { 17960e60836bSSrikar Dronamraju depth = __synthesize_probe_trace_arg_ref(ref->next, buf, 1797909b0360SMasami Hiramatsu depth + 1); 17984235b045SMasami Hiramatsu if (depth < 0) 17994235b045SMasami Hiramatsu return depth; 18004235b045SMasami Hiramatsu } 1801bf4d5f25SMasami Hiramatsu err = strbuf_addf(buf, "%+ld(", ref->offset); 1802bf4d5f25SMasami Hiramatsu return (err < 0) ? err : depth; 1803bf4d5f25SMasami Hiramatsu } 18044235b045SMasami Hiramatsu 18050e60836bSSrikar Dronamraju static int synthesize_probe_trace_arg(struct probe_trace_arg *arg, 1806909b0360SMasami Hiramatsu struct strbuf *buf) 18074235b045SMasami Hiramatsu { 18080e60836bSSrikar Dronamraju struct probe_trace_arg_ref *ref = arg->ref; 1809bf4d5f25SMasami Hiramatsu int depth = 0, err; 18104235b045SMasami Hiramatsu 18114235b045SMasami Hiramatsu /* Argument name or separator */ 18124235b045SMasami Hiramatsu if (arg->name) 1813bf4d5f25SMasami Hiramatsu err = strbuf_addf(buf, " %s=", arg->name); 18144235b045SMasami Hiramatsu else 1815bf4d5f25SMasami Hiramatsu err = strbuf_addch(buf, ' '); 1816bf4d5f25SMasami Hiramatsu if (err) 1817bf4d5f25SMasami Hiramatsu return err; 18184235b045SMasami Hiramatsu 1819b7dcb857SMasami Hiramatsu /* Special case: @XXX */ 1820b7dcb857SMasami Hiramatsu if (arg->value[0] == '@' && arg->ref) 1821b7dcb857SMasami Hiramatsu ref = ref->next; 1822b7dcb857SMasami Hiramatsu 18234235b045SMasami Hiramatsu /* Dereferencing arguments */ 1824b7dcb857SMasami Hiramatsu if (ref) { 1825909b0360SMasami Hiramatsu depth = __synthesize_probe_trace_arg_ref(ref, buf, 1); 18264235b045SMasami Hiramatsu if (depth < 0) 18274235b045SMasami Hiramatsu return depth; 18284235b045SMasami Hiramatsu } 18294235b045SMasami Hiramatsu 18304235b045SMasami Hiramatsu /* Print argument value */ 1831b7dcb857SMasami Hiramatsu if (arg->value[0] == '@' && arg->ref) 1832bf4d5f25SMasami Hiramatsu err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset); 1833b7dcb857SMasami Hiramatsu else 1834bf4d5f25SMasami Hiramatsu err = strbuf_addstr(buf, arg->value); 18354235b045SMasami Hiramatsu 18364235b045SMasami Hiramatsu /* Closing */ 1837bf4d5f25SMasami Hiramatsu while (!err && depth--) 1838bf4d5f25SMasami Hiramatsu err = strbuf_addch(buf, ')'); 18394235b045SMasami Hiramatsu 1840bf4d5f25SMasami Hiramatsu /* Print argument type */ 1841bf4d5f25SMasami Hiramatsu if (!err && arg->type) 1842bf4d5f25SMasami Hiramatsu err = strbuf_addf(buf, ":%s", arg->type); 1843bf4d5f25SMasami Hiramatsu 1844bf4d5f25SMasami Hiramatsu return err; 18454235b045SMasami Hiramatsu } 18464235b045SMasami Hiramatsu 18470e60836bSSrikar Dronamraju char *synthesize_probe_trace_command(struct probe_trace_event *tev) 18484235b045SMasami Hiramatsu { 18490e60836bSSrikar Dronamraju struct probe_trace_point *tp = &tev->point; 1850909b0360SMasami Hiramatsu struct strbuf buf; 1851909b0360SMasami Hiramatsu char *ret = NULL; 1852bf4d5f25SMasami Hiramatsu int i, err; 1853eb948e50SMasami Hiramatsu 1854da15bd9dSWang Nan /* Uprobes must have tp->module */ 1855da15bd9dSWang Nan if (tev->uprobes && !tp->module) 1856909b0360SMasami Hiramatsu return NULL; 1857909b0360SMasami Hiramatsu 1858bf4d5f25SMasami Hiramatsu if (strbuf_init(&buf, 32) < 0) 1859bf4d5f25SMasami Hiramatsu return NULL; 1860bf4d5f25SMasami Hiramatsu 1861bf4d5f25SMasami Hiramatsu if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p', 1862bf4d5f25SMasami Hiramatsu tev->group, tev->event) < 0) 1863bf4d5f25SMasami Hiramatsu goto error; 1864da15bd9dSWang Nan /* 1865da15bd9dSWang Nan * If tp->address == 0, then this point must be a 1866da15bd9dSWang Nan * absolute address uprobe. 1867da15bd9dSWang Nan * try_to_find_absolute_address() should have made 1868da15bd9dSWang Nan * tp->symbol to "0x0". 1869da15bd9dSWang Nan */ 1870da15bd9dSWang Nan if (tev->uprobes && !tp->address) { 1871da15bd9dSWang Nan if (!tp->symbol || strcmp(tp->symbol, "0x0")) 1872da15bd9dSWang Nan goto error; 1873da15bd9dSWang Nan } 1874eb948e50SMasami Hiramatsu 1875eb948e50SMasami Hiramatsu /* Use the tp->address for uprobes */ 1876225466f1SSrikar Dronamraju if (tev->uprobes) 1877bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s:0x%lx", tp->module, tp->address); 1878da15bd9dSWang Nan else if (!strncmp(tp->symbol, "0x", 2)) 1879da15bd9dSWang Nan /* Absolute address. See try_to_find_absolute_address() */ 1880bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "", 1881909b0360SMasami Hiramatsu tp->module ? ":" : "", tp->address); 1882225466f1SSrikar Dronamraju else 1883bf4d5f25SMasami Hiramatsu err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "", 1884909b0360SMasami Hiramatsu tp->module ? ":" : "", tp->symbol, tp->offset); 1885bf4d5f25SMasami Hiramatsu if (err) 1886bf4d5f25SMasami Hiramatsu goto error; 1887225466f1SSrikar Dronamraju 1888909b0360SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) 1889909b0360SMasami Hiramatsu if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0) 18904235b045SMasami Hiramatsu goto error; 18917ef17aafSMasami Hiramatsu 1892909b0360SMasami Hiramatsu ret = strbuf_detach(&buf, NULL); 189350656eecSMasami Hiramatsu error: 1894909b0360SMasami Hiramatsu strbuf_release(&buf); 1895909b0360SMasami Hiramatsu return ret; 189650656eecSMasami Hiramatsu } 189750656eecSMasami Hiramatsu 18985a6f6314SMasami Hiramatsu static int find_perf_probe_point_from_map(struct probe_trace_point *tp, 18995a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 19005a6f6314SMasami Hiramatsu bool is_kprobe) 19015a6f6314SMasami Hiramatsu { 19025a6f6314SMasami Hiramatsu struct symbol *sym = NULL; 19035a6f6314SMasami Hiramatsu struct map *map; 1904e486367fSWang Nan u64 addr = tp->address; 19055a6f6314SMasami Hiramatsu int ret = -ENOENT; 19065a6f6314SMasami Hiramatsu 19075a6f6314SMasami Hiramatsu if (!is_kprobe) { 19085a6f6314SMasami Hiramatsu map = dso__new_map(tp->module); 19095a6f6314SMasami Hiramatsu if (!map) 19105a6f6314SMasami Hiramatsu goto out; 19115a6f6314SMasami Hiramatsu sym = map__find_symbol(map, addr, NULL); 19125a6f6314SMasami Hiramatsu } else { 19139b239a12SMasami Hiramatsu if (tp->symbol && !addr) { 19140a62f686SMasami Hiramatsu if (kernel_get_symbol_address_by_name(tp->symbol, 19150a62f686SMasami Hiramatsu &addr, true, false) < 0) 19169b239a12SMasami Hiramatsu goto out; 19179b239a12SMasami Hiramatsu } 19185a6f6314SMasami Hiramatsu if (addr) { 19195a6f6314SMasami Hiramatsu addr += tp->offset; 19205a6f6314SMasami Hiramatsu sym = __find_kernel_function(addr, &map); 19215a6f6314SMasami Hiramatsu } 19225a6f6314SMasami Hiramatsu } 192398d3b258SWang Nan 19245a6f6314SMasami Hiramatsu if (!sym) 19255a6f6314SMasami Hiramatsu goto out; 19265a6f6314SMasami Hiramatsu 19275a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 19285a6f6314SMasami Hiramatsu pp->offset = addr - map->unmap_ip(map, sym->start); 19295a6f6314SMasami Hiramatsu pp->function = strdup(sym->name); 19305a6f6314SMasami Hiramatsu ret = pp->function ? 0 : -ENOMEM; 19315a6f6314SMasami Hiramatsu 19325a6f6314SMasami Hiramatsu out: 19335a6f6314SMasami Hiramatsu if (map && !is_kprobe) { 193484c2cafaSArnaldo Carvalho de Melo map__put(map); 19355a6f6314SMasami Hiramatsu } 19365a6f6314SMasami Hiramatsu 19375a6f6314SMasami Hiramatsu return ret; 19385a6f6314SMasami Hiramatsu } 19395a6f6314SMasami Hiramatsu 19405a6f6314SMasami Hiramatsu static int convert_to_perf_probe_point(struct probe_trace_point *tp, 19415a6f6314SMasami Hiramatsu struct perf_probe_point *pp, 19425a6f6314SMasami Hiramatsu bool is_kprobe) 19435a6f6314SMasami Hiramatsu { 19445a6f6314SMasami Hiramatsu char buf[128]; 19455a6f6314SMasami Hiramatsu int ret; 19465a6f6314SMasami Hiramatsu 19475a6f6314SMasami Hiramatsu ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe); 19485a6f6314SMasami Hiramatsu if (!ret) 19495a6f6314SMasami Hiramatsu return 0; 19505a6f6314SMasami Hiramatsu ret = find_perf_probe_point_from_map(tp, pp, is_kprobe); 19515a6f6314SMasami Hiramatsu if (!ret) 19525a6f6314SMasami Hiramatsu return 0; 19535a6f6314SMasami Hiramatsu 19545a6f6314SMasami Hiramatsu pr_debug("Failed to find probe point from both of dwarf and map.\n"); 19555a6f6314SMasami Hiramatsu 19565a6f6314SMasami Hiramatsu if (tp->symbol) { 19575a6f6314SMasami Hiramatsu pp->function = strdup(tp->symbol); 19585a6f6314SMasami Hiramatsu pp->offset = tp->offset; 1959614e2fdbSWang Nan } else { 19605a6f6314SMasami Hiramatsu ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address); 19615a6f6314SMasami Hiramatsu if (ret < 0) 19625a6f6314SMasami Hiramatsu return ret; 19635a6f6314SMasami Hiramatsu pp->function = strdup(buf); 19645a6f6314SMasami Hiramatsu pp->offset = 0; 19655a6f6314SMasami Hiramatsu } 19665a6f6314SMasami Hiramatsu if (pp->function == NULL) 19675a6f6314SMasami Hiramatsu return -ENOMEM; 19685a6f6314SMasami Hiramatsu 19695a6f6314SMasami Hiramatsu pp->retprobe = tp->retprobe; 19705a6f6314SMasami Hiramatsu 19715a6f6314SMasami Hiramatsu return 0; 19725a6f6314SMasami Hiramatsu } 19735a6f6314SMasami Hiramatsu 19740e60836bSSrikar Dronamraju static int convert_to_perf_probe_event(struct probe_trace_event *tev, 1975225466f1SSrikar Dronamraju struct perf_probe_event *pev, bool is_kprobe) 19764de189feSMasami Hiramatsu { 1977909b0360SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 1978146a1439SMasami Hiramatsu int i, ret; 19794de189feSMasami Hiramatsu 19804b4da7f7SMasami Hiramatsu /* Convert event/group name */ 198102b95dadSMasami Hiramatsu pev->event = strdup(tev->event); 198202b95dadSMasami Hiramatsu pev->group = strdup(tev->group); 198302b95dadSMasami Hiramatsu if (pev->event == NULL || pev->group == NULL) 198402b95dadSMasami Hiramatsu return -ENOMEM; 1985fb1587d8SMasami Hiramatsu 19864b4da7f7SMasami Hiramatsu /* Convert trace_point to probe_point */ 19875a6f6314SMasami Hiramatsu ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe); 1988146a1439SMasami Hiramatsu if (ret < 0) 1989146a1439SMasami Hiramatsu return ret; 19904b4da7f7SMasami Hiramatsu 19914235b045SMasami Hiramatsu /* Convert trace_arg to probe_arg */ 19924235b045SMasami Hiramatsu pev->nargs = tev->nargs; 1993e334016fSMasami Hiramatsu pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs); 1994e334016fSMasami Hiramatsu if (pev->args == NULL) 1995e334016fSMasami Hiramatsu return -ENOMEM; 199602b95dadSMasami Hiramatsu for (i = 0; i < tev->nargs && ret >= 0; i++) { 19974235b045SMasami Hiramatsu if (tev->args[i].name) 199802b95dadSMasami Hiramatsu pev->args[i].name = strdup(tev->args[i].name); 19994235b045SMasami Hiramatsu else { 2000bf4d5f25SMasami Hiramatsu if ((ret = strbuf_init(&buf, 32)) < 0) 2001bf4d5f25SMasami Hiramatsu goto error; 2002909b0360SMasami Hiramatsu ret = synthesize_probe_trace_arg(&tev->args[i], &buf); 2003909b0360SMasami Hiramatsu pev->args[i].name = strbuf_detach(&buf, NULL); 200402b95dadSMasami Hiramatsu } 200502b95dadSMasami Hiramatsu if (pev->args[i].name == NULL && ret >= 0) 200602b95dadSMasami Hiramatsu ret = -ENOMEM; 20074de189feSMasami Hiramatsu } 2008bf4d5f25SMasami Hiramatsu error: 2009146a1439SMasami Hiramatsu if (ret < 0) 2010146a1439SMasami Hiramatsu clear_perf_probe_event(pev); 2011146a1439SMasami Hiramatsu 2012146a1439SMasami Hiramatsu return ret; 20134235b045SMasami Hiramatsu } 20144de189feSMasami Hiramatsu 20154235b045SMasami Hiramatsu void clear_perf_probe_event(struct perf_probe_event *pev) 20164235b045SMasami Hiramatsu { 20177df2f329SMasami Hiramatsu struct perf_probe_arg_field *field, *next; 20184235b045SMasami Hiramatsu int i; 20194de189feSMasami Hiramatsu 20204235b045SMasami Hiramatsu free(pev->event); 20214235b045SMasami Hiramatsu free(pev->group); 20227afb3fabSMasami Hiramatsu free(pev->target); 20239b118acaSMasami Hiramatsu clear_perf_probe_point(&pev->point); 2024f5385650SArnaldo Carvalho de Melo 20257df2f329SMasami Hiramatsu for (i = 0; i < pev->nargs; i++) { 20264235b045SMasami Hiramatsu free(pev->args[i].name); 202748481938SMasami Hiramatsu free(pev->args[i].var); 202811a1ca35SMasami Hiramatsu free(pev->args[i].type); 20297df2f329SMasami Hiramatsu field = pev->args[i].field; 20307df2f329SMasami Hiramatsu while (field) { 20317df2f329SMasami Hiramatsu next = field->next; 203274cf249dSArnaldo Carvalho de Melo zfree(&field->name); 20337df2f329SMasami Hiramatsu free(field); 20347df2f329SMasami Hiramatsu field = next; 20357df2f329SMasami Hiramatsu } 20367df2f329SMasami Hiramatsu } 20374235b045SMasami Hiramatsu free(pev->args); 20384235b045SMasami Hiramatsu memset(pev, 0, sizeof(*pev)); 20394235b045SMasami Hiramatsu } 20404235b045SMasami Hiramatsu 20410542bb9cSMasami Hiramatsu #define strdup_or_goto(str, label) \ 20420542bb9cSMasami Hiramatsu ({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; }) 20430542bb9cSMasami Hiramatsu 20440542bb9cSMasami Hiramatsu static int perf_probe_point__copy(struct perf_probe_point *dst, 20450542bb9cSMasami Hiramatsu struct perf_probe_point *src) 20460542bb9cSMasami Hiramatsu { 20470542bb9cSMasami Hiramatsu dst->file = strdup_or_goto(src->file, out_err); 20480542bb9cSMasami Hiramatsu dst->function = strdup_or_goto(src->function, out_err); 20490542bb9cSMasami Hiramatsu dst->lazy_line = strdup_or_goto(src->lazy_line, out_err); 20500542bb9cSMasami Hiramatsu dst->line = src->line; 20510542bb9cSMasami Hiramatsu dst->retprobe = src->retprobe; 20520542bb9cSMasami Hiramatsu dst->offset = src->offset; 20530542bb9cSMasami Hiramatsu return 0; 20540542bb9cSMasami Hiramatsu 20550542bb9cSMasami Hiramatsu out_err: 20560542bb9cSMasami Hiramatsu clear_perf_probe_point(dst); 20570542bb9cSMasami Hiramatsu return -ENOMEM; 20580542bb9cSMasami Hiramatsu } 20590542bb9cSMasami Hiramatsu 20600542bb9cSMasami Hiramatsu static int perf_probe_arg__copy(struct perf_probe_arg *dst, 20610542bb9cSMasami Hiramatsu struct perf_probe_arg *src) 20620542bb9cSMasami Hiramatsu { 20630542bb9cSMasami Hiramatsu struct perf_probe_arg_field *field, **ppfield; 20640542bb9cSMasami Hiramatsu 20650542bb9cSMasami Hiramatsu dst->name = strdup_or_goto(src->name, out_err); 20660542bb9cSMasami Hiramatsu dst->var = strdup_or_goto(src->var, out_err); 20670542bb9cSMasami Hiramatsu dst->type = strdup_or_goto(src->type, out_err); 20680542bb9cSMasami Hiramatsu 20690542bb9cSMasami Hiramatsu field = src->field; 20700542bb9cSMasami Hiramatsu ppfield = &(dst->field); 20710542bb9cSMasami Hiramatsu while (field) { 20720542bb9cSMasami Hiramatsu *ppfield = zalloc(sizeof(*field)); 20730542bb9cSMasami Hiramatsu if (!*ppfield) 20740542bb9cSMasami Hiramatsu goto out_err; 20750542bb9cSMasami Hiramatsu (*ppfield)->name = strdup_or_goto(field->name, out_err); 20760542bb9cSMasami Hiramatsu (*ppfield)->index = field->index; 20770542bb9cSMasami Hiramatsu (*ppfield)->ref = field->ref; 20780542bb9cSMasami Hiramatsu field = field->next; 20790542bb9cSMasami Hiramatsu ppfield = &((*ppfield)->next); 20800542bb9cSMasami Hiramatsu } 20810542bb9cSMasami Hiramatsu return 0; 20820542bb9cSMasami Hiramatsu out_err: 20830542bb9cSMasami Hiramatsu return -ENOMEM; 20840542bb9cSMasami Hiramatsu } 20850542bb9cSMasami Hiramatsu 20860542bb9cSMasami Hiramatsu int perf_probe_event__copy(struct perf_probe_event *dst, 20870542bb9cSMasami Hiramatsu struct perf_probe_event *src) 20880542bb9cSMasami Hiramatsu { 20890542bb9cSMasami Hiramatsu int i; 20900542bb9cSMasami Hiramatsu 20910542bb9cSMasami Hiramatsu dst->event = strdup_or_goto(src->event, out_err); 20920542bb9cSMasami Hiramatsu dst->group = strdup_or_goto(src->group, out_err); 20930542bb9cSMasami Hiramatsu dst->target = strdup_or_goto(src->target, out_err); 20940542bb9cSMasami Hiramatsu dst->uprobes = src->uprobes; 20950542bb9cSMasami Hiramatsu 20960542bb9cSMasami Hiramatsu if (perf_probe_point__copy(&dst->point, &src->point) < 0) 20970542bb9cSMasami Hiramatsu goto out_err; 20980542bb9cSMasami Hiramatsu 20990542bb9cSMasami Hiramatsu dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs); 21000542bb9cSMasami Hiramatsu if (!dst->args) 21010542bb9cSMasami Hiramatsu goto out_err; 21020542bb9cSMasami Hiramatsu dst->nargs = src->nargs; 21030542bb9cSMasami Hiramatsu 21040542bb9cSMasami Hiramatsu for (i = 0; i < src->nargs; i++) 21050542bb9cSMasami Hiramatsu if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0) 21060542bb9cSMasami Hiramatsu goto out_err; 21070542bb9cSMasami Hiramatsu return 0; 21080542bb9cSMasami Hiramatsu 21090542bb9cSMasami Hiramatsu out_err: 21100542bb9cSMasami Hiramatsu clear_perf_probe_event(dst); 21110542bb9cSMasami Hiramatsu return -ENOMEM; 21120542bb9cSMasami Hiramatsu } 21130542bb9cSMasami Hiramatsu 211492f6c72eSMasami Hiramatsu void clear_probe_trace_event(struct probe_trace_event *tev) 21154235b045SMasami Hiramatsu { 21160e60836bSSrikar Dronamraju struct probe_trace_arg_ref *ref, *next; 21174235b045SMasami Hiramatsu int i; 21184235b045SMasami Hiramatsu 21194235b045SMasami Hiramatsu free(tev->event); 21204235b045SMasami Hiramatsu free(tev->group); 21214235b045SMasami Hiramatsu free(tev->point.symbol); 21224c859351SMasami Hiramatsu free(tev->point.realname); 2123190b57fcSMasami Hiramatsu free(tev->point.module); 21244235b045SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 21254235b045SMasami Hiramatsu free(tev->args[i].name); 21264235b045SMasami Hiramatsu free(tev->args[i].value); 21274984912eSMasami Hiramatsu free(tev->args[i].type); 21284235b045SMasami Hiramatsu ref = tev->args[i].ref; 21294235b045SMasami Hiramatsu while (ref) { 21304235b045SMasami Hiramatsu next = ref->next; 21314235b045SMasami Hiramatsu free(ref); 21324235b045SMasami Hiramatsu ref = next; 21334235b045SMasami Hiramatsu } 21344235b045SMasami Hiramatsu } 21354235b045SMasami Hiramatsu free(tev->args); 21364235b045SMasami Hiramatsu memset(tev, 0, sizeof(*tev)); 21374de189feSMasami Hiramatsu } 21384de189feSMasami Hiramatsu 21399aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node { 21409aaf5a5fSMasami Hiramatsu struct list_head list; 21419aaf5a5fSMasami Hiramatsu unsigned long start; 21429aaf5a5fSMasami Hiramatsu unsigned long end; 21439aaf5a5fSMasami Hiramatsu char *symbol; 21449aaf5a5fSMasami Hiramatsu }; 21459aaf5a5fSMasami Hiramatsu 21469aaf5a5fSMasami Hiramatsu static void kprobe_blacklist__delete(struct list_head *blacklist) 21479aaf5a5fSMasami Hiramatsu { 21489aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 21499aaf5a5fSMasami Hiramatsu 21509aaf5a5fSMasami Hiramatsu while (!list_empty(blacklist)) { 21519aaf5a5fSMasami Hiramatsu node = list_first_entry(blacklist, 21529aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node, list); 21539aaf5a5fSMasami Hiramatsu list_del(&node->list); 21549aaf5a5fSMasami Hiramatsu free(node->symbol); 21559aaf5a5fSMasami Hiramatsu free(node); 21569aaf5a5fSMasami Hiramatsu } 21579aaf5a5fSMasami Hiramatsu } 21589aaf5a5fSMasami Hiramatsu 21599aaf5a5fSMasami Hiramatsu static int kprobe_blacklist__load(struct list_head *blacklist) 21609aaf5a5fSMasami Hiramatsu { 21619aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 21624605eab3SJiri Olsa const char *__debugfs = debugfs__mountpoint(); 21639aaf5a5fSMasami Hiramatsu char buf[PATH_MAX], *p; 21649aaf5a5fSMasami Hiramatsu FILE *fp; 21659aaf5a5fSMasami Hiramatsu int ret; 21669aaf5a5fSMasami Hiramatsu 21679aaf5a5fSMasami Hiramatsu if (__debugfs == NULL) 21689aaf5a5fSMasami Hiramatsu return -ENOTSUP; 21699aaf5a5fSMasami Hiramatsu 21709aaf5a5fSMasami Hiramatsu ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs); 21719aaf5a5fSMasami Hiramatsu if (ret < 0) 21729aaf5a5fSMasami Hiramatsu return ret; 21739aaf5a5fSMasami Hiramatsu 21749aaf5a5fSMasami Hiramatsu fp = fopen(buf, "r"); 21759aaf5a5fSMasami Hiramatsu if (!fp) 21769aaf5a5fSMasami Hiramatsu return -errno; 21779aaf5a5fSMasami Hiramatsu 21789aaf5a5fSMasami Hiramatsu ret = 0; 21799aaf5a5fSMasami Hiramatsu while (fgets(buf, PATH_MAX, fp)) { 21809aaf5a5fSMasami Hiramatsu node = zalloc(sizeof(*node)); 21819aaf5a5fSMasami Hiramatsu if (!node) { 21829aaf5a5fSMasami Hiramatsu ret = -ENOMEM; 21839aaf5a5fSMasami Hiramatsu break; 21849aaf5a5fSMasami Hiramatsu } 21859aaf5a5fSMasami Hiramatsu INIT_LIST_HEAD(&node->list); 21869aaf5a5fSMasami Hiramatsu list_add_tail(&node->list, blacklist); 21879aaf5a5fSMasami Hiramatsu if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) { 21889aaf5a5fSMasami Hiramatsu ret = -EINVAL; 21899aaf5a5fSMasami Hiramatsu break; 21909aaf5a5fSMasami Hiramatsu } 21919aaf5a5fSMasami Hiramatsu p = strchr(buf, '\t'); 21929aaf5a5fSMasami Hiramatsu if (p) { 21939aaf5a5fSMasami Hiramatsu p++; 21949aaf5a5fSMasami Hiramatsu if (p[strlen(p) - 1] == '\n') 21959aaf5a5fSMasami Hiramatsu p[strlen(p) - 1] = '\0'; 21969aaf5a5fSMasami Hiramatsu } else 21979aaf5a5fSMasami Hiramatsu p = (char *)"unknown"; 21989aaf5a5fSMasami Hiramatsu node->symbol = strdup(p); 21999aaf5a5fSMasami Hiramatsu if (!node->symbol) { 22009aaf5a5fSMasami Hiramatsu ret = -ENOMEM; 22019aaf5a5fSMasami Hiramatsu break; 22029aaf5a5fSMasami Hiramatsu } 22039aaf5a5fSMasami Hiramatsu pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n", 22049aaf5a5fSMasami Hiramatsu node->start, node->end, node->symbol); 22059aaf5a5fSMasami Hiramatsu ret++; 22069aaf5a5fSMasami Hiramatsu } 22079aaf5a5fSMasami Hiramatsu if (ret < 0) 22089aaf5a5fSMasami Hiramatsu kprobe_blacklist__delete(blacklist); 22099aaf5a5fSMasami Hiramatsu fclose(fp); 22109aaf5a5fSMasami Hiramatsu 22119aaf5a5fSMasami Hiramatsu return ret; 22129aaf5a5fSMasami Hiramatsu } 22139aaf5a5fSMasami Hiramatsu 22149aaf5a5fSMasami Hiramatsu static struct kprobe_blacklist_node * 22159aaf5a5fSMasami Hiramatsu kprobe_blacklist__find_by_address(struct list_head *blacklist, 22169aaf5a5fSMasami Hiramatsu unsigned long address) 22179aaf5a5fSMasami Hiramatsu { 22189aaf5a5fSMasami Hiramatsu struct kprobe_blacklist_node *node; 22199aaf5a5fSMasami Hiramatsu 22209aaf5a5fSMasami Hiramatsu list_for_each_entry(node, blacklist, list) { 22219aaf5a5fSMasami Hiramatsu if (node->start <= address && address <= node->end) 22229aaf5a5fSMasami Hiramatsu return node; 22239aaf5a5fSMasami Hiramatsu } 22249aaf5a5fSMasami Hiramatsu 22259aaf5a5fSMasami Hiramatsu return NULL; 22269aaf5a5fSMasami Hiramatsu } 22279aaf5a5fSMasami Hiramatsu 2228b031220dSMasami Hiramatsu static LIST_HEAD(kprobe_blacklist); 2229b031220dSMasami Hiramatsu 2230b031220dSMasami Hiramatsu static void kprobe_blacklist__init(void) 2231b031220dSMasami Hiramatsu { 2232b031220dSMasami Hiramatsu if (!list_empty(&kprobe_blacklist)) 2233b031220dSMasami Hiramatsu return; 2234b031220dSMasami Hiramatsu 2235b031220dSMasami Hiramatsu if (kprobe_blacklist__load(&kprobe_blacklist) < 0) 2236b031220dSMasami Hiramatsu pr_debug("No kprobe blacklist support, ignored\n"); 2237b031220dSMasami Hiramatsu } 2238b031220dSMasami Hiramatsu 2239b031220dSMasami Hiramatsu static void kprobe_blacklist__release(void) 2240b031220dSMasami Hiramatsu { 2241b031220dSMasami Hiramatsu kprobe_blacklist__delete(&kprobe_blacklist); 2242b031220dSMasami Hiramatsu } 2243b031220dSMasami Hiramatsu 2244b031220dSMasami Hiramatsu static bool kprobe_blacklist__listed(unsigned long address) 2245b031220dSMasami Hiramatsu { 2246b031220dSMasami Hiramatsu return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address); 2247b031220dSMasami Hiramatsu } 2248b031220dSMasami Hiramatsu 2249d350bd57SMasami Hiramatsu static int perf_probe_event__sprintf(const char *group, const char *event, 2250d350bd57SMasami Hiramatsu struct perf_probe_event *pev, 2251ba7ecb02SMasami Hiramatsu const char *module, 2252ba7ecb02SMasami Hiramatsu struct strbuf *result) 2253278498d4SMasami Hiramatsu { 2254bf4d5f25SMasami Hiramatsu int i, ret; 2255909b0360SMasami Hiramatsu char *buf; 2256909b0360SMasami Hiramatsu 2257909b0360SMasami Hiramatsu if (asprintf(&buf, "%s:%s", group, event) < 0) 2258909b0360SMasami Hiramatsu return -errno; 2259bf4d5f25SMasami Hiramatsu ret = strbuf_addf(result, " %-20s (on ", buf); 2260909b0360SMasami Hiramatsu free(buf); 2261bf4d5f25SMasami Hiramatsu if (ret) 2262bf4d5f25SMasami Hiramatsu return ret; 2263278498d4SMasami Hiramatsu 22644235b045SMasami Hiramatsu /* Synthesize only event probe point */ 2265909b0360SMasami Hiramatsu buf = synthesize_perf_probe_point(&pev->point); 2266909b0360SMasami Hiramatsu if (!buf) 2267909b0360SMasami Hiramatsu return -ENOMEM; 2268bf4d5f25SMasami Hiramatsu ret = strbuf_addstr(result, buf); 2269909b0360SMasami Hiramatsu free(buf); 22704235b045SMasami Hiramatsu 2271bf4d5f25SMasami Hiramatsu if (!ret && module) 2272bf4d5f25SMasami Hiramatsu ret = strbuf_addf(result, " in %s", module); 2273278498d4SMasami Hiramatsu 2274bf4d5f25SMasami Hiramatsu if (!ret && pev->nargs > 0) { 2275bf4d5f25SMasami Hiramatsu ret = strbuf_add(result, " with", 5); 2276bf4d5f25SMasami Hiramatsu for (i = 0; !ret && i < pev->nargs; i++) { 2277909b0360SMasami Hiramatsu buf = synthesize_perf_probe_arg(&pev->args[i]); 2278909b0360SMasami Hiramatsu if (!buf) 2279909b0360SMasami Hiramatsu return -ENOMEM; 2280bf4d5f25SMasami Hiramatsu ret = strbuf_addf(result, " %s", buf); 2281909b0360SMasami Hiramatsu free(buf); 22827df2f329SMasami Hiramatsu } 2283278498d4SMasami Hiramatsu } 2284bf4d5f25SMasami Hiramatsu if (!ret) 2285bf4d5f25SMasami Hiramatsu ret = strbuf_addch(result, ')'); 2286909b0360SMasami Hiramatsu 2287bf4d5f25SMasami Hiramatsu return ret; 2288278498d4SMasami Hiramatsu } 2289278498d4SMasami Hiramatsu 2290ba7ecb02SMasami Hiramatsu /* Show an event */ 2291b02137ccSNamhyung Kim int show_perf_probe_event(const char *group, const char *event, 2292d350bd57SMasami Hiramatsu struct perf_probe_event *pev, 2293ba7ecb02SMasami Hiramatsu const char *module, bool use_stdout) 2294ba7ecb02SMasami Hiramatsu { 2295ba7ecb02SMasami Hiramatsu struct strbuf buf = STRBUF_INIT; 2296ba7ecb02SMasami Hiramatsu int ret; 2297ba7ecb02SMasami Hiramatsu 2298d350bd57SMasami Hiramatsu ret = perf_probe_event__sprintf(group, event, pev, module, &buf); 2299ba7ecb02SMasami Hiramatsu if (ret >= 0) { 2300ba7ecb02SMasami Hiramatsu if (use_stdout) 2301ba7ecb02SMasami Hiramatsu printf("%s\n", buf.buf); 2302ba7ecb02SMasami Hiramatsu else 2303ba7ecb02SMasami Hiramatsu pr_info("%s\n", buf.buf); 2304ba7ecb02SMasami Hiramatsu } 2305ba7ecb02SMasami Hiramatsu strbuf_release(&buf); 2306ba7ecb02SMasami Hiramatsu 2307ba7ecb02SMasami Hiramatsu return ret; 2308ba7ecb02SMasami Hiramatsu } 2309ba7ecb02SMasami Hiramatsu 2310b6a89643SMasami Hiramatsu static bool filter_probe_trace_event(struct probe_trace_event *tev, 2311b6a89643SMasami Hiramatsu struct strfilter *filter) 2312b6a89643SMasami Hiramatsu { 2313b6a89643SMasami Hiramatsu char tmp[128]; 2314b6a89643SMasami Hiramatsu 2315b6a89643SMasami Hiramatsu /* At first, check the event name itself */ 2316b6a89643SMasami Hiramatsu if (strfilter__compare(filter, tev->event)) 2317b6a89643SMasami Hiramatsu return true; 2318b6a89643SMasami Hiramatsu 2319b6a89643SMasami Hiramatsu /* Next, check the combination of name and group */ 2320b6a89643SMasami Hiramatsu if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0) 2321b6a89643SMasami Hiramatsu return false; 2322b6a89643SMasami Hiramatsu return strfilter__compare(filter, tmp); 2323b6a89643SMasami Hiramatsu } 2324b6a89643SMasami Hiramatsu 2325b6a89643SMasami Hiramatsu static int __show_perf_probe_events(int fd, bool is_kprobe, 2326b6a89643SMasami Hiramatsu struct strfilter *filter) 23274de189feSMasami Hiramatsu { 2328225466f1SSrikar Dronamraju int ret = 0; 23290e60836bSSrikar Dronamraju struct probe_trace_event tev; 23304235b045SMasami Hiramatsu struct perf_probe_event pev; 23314de189feSMasami Hiramatsu struct strlist *rawlist; 23324de189feSMasami Hiramatsu struct str_node *ent; 23334de189feSMasami Hiramatsu 23344235b045SMasami Hiramatsu memset(&tev, 0, sizeof(tev)); 23354235b045SMasami Hiramatsu memset(&pev, 0, sizeof(pev)); 233672041334SMasami Hiramatsu 233792f6c72eSMasami Hiramatsu rawlist = probe_file__get_rawlist(fd); 2338146a1439SMasami Hiramatsu if (!rawlist) 23396eb08660SMasami Hiramatsu return -ENOMEM; 23404de189feSMasami Hiramatsu 2341602a1f4dSArnaldo Carvalho de Melo strlist__for_each_entry(ent, rawlist) { 23420e60836bSSrikar Dronamraju ret = parse_probe_trace_command(ent->s, &tev); 2343146a1439SMasami Hiramatsu if (ret >= 0) { 2344b6a89643SMasami Hiramatsu if (!filter_probe_trace_event(&tev, filter)) 2345b6a89643SMasami Hiramatsu goto next; 2346225466f1SSrikar Dronamraju ret = convert_to_perf_probe_event(&tev, &pev, 2347225466f1SSrikar Dronamraju is_kprobe); 2348ba7ecb02SMasami Hiramatsu if (ret < 0) 2349ba7ecb02SMasami Hiramatsu goto next; 2350d350bd57SMasami Hiramatsu ret = show_perf_probe_event(pev.group, pev.event, 2351d350bd57SMasami Hiramatsu &pev, tev.point.module, 2352ba7ecb02SMasami Hiramatsu true); 2353146a1439SMasami Hiramatsu } 2354b6a89643SMasami Hiramatsu next: 23554235b045SMasami Hiramatsu clear_perf_probe_event(&pev); 23560e60836bSSrikar Dronamraju clear_probe_trace_event(&tev); 2357146a1439SMasami Hiramatsu if (ret < 0) 2358146a1439SMasami Hiramatsu break; 23594de189feSMasami Hiramatsu } 23604de189feSMasami Hiramatsu strlist__delete(rawlist); 23617737af01SMasami Hiramatsu /* Cleanup cached debuginfo if needed */ 23627737af01SMasami Hiramatsu debuginfo_cache__exit(); 2363146a1439SMasami Hiramatsu 2364146a1439SMasami Hiramatsu return ret; 23654de189feSMasami Hiramatsu } 23664de189feSMasami Hiramatsu 2367225466f1SSrikar Dronamraju /* List up current perf-probe events */ 2368b6a89643SMasami Hiramatsu int show_perf_probe_events(struct strfilter *filter) 2369225466f1SSrikar Dronamraju { 23705e45187cSMasami Hiramatsu int kp_fd, up_fd, ret; 2371225466f1SSrikar Dronamraju 2372225466f1SSrikar Dronamraju setup_pager(); 2373225466f1SSrikar Dronamraju 23741f3736c9SMasami Hiramatsu if (probe_conf.cache) 23751f3736c9SMasami Hiramatsu return probe_cache__show_all_caches(filter); 23761f3736c9SMasami Hiramatsu 23779bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(false); 2378225466f1SSrikar Dronamraju if (ret < 0) 2379225466f1SSrikar Dronamraju return ret; 2380225466f1SSrikar Dronamraju 238192f6c72eSMasami Hiramatsu ret = probe_file__open_both(&kp_fd, &up_fd, 0); 23825e45187cSMasami Hiramatsu if (ret < 0) 2383225466f1SSrikar Dronamraju return ret; 2384225466f1SSrikar Dronamraju 238592f6c72eSMasami Hiramatsu if (kp_fd >= 0) 238692f6c72eSMasami Hiramatsu ret = __show_perf_probe_events(kp_fd, true, filter); 238792f6c72eSMasami Hiramatsu if (up_fd >= 0 && ret >= 0) 238892f6c72eSMasami Hiramatsu ret = __show_perf_probe_events(up_fd, false, filter); 238992f6c72eSMasami Hiramatsu if (kp_fd > 0) 239092f6c72eSMasami Hiramatsu close(kp_fd); 239192f6c72eSMasami Hiramatsu if (up_fd > 0) 239292f6c72eSMasami Hiramatsu close(up_fd); 23939bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 2394b498ce1fSMasami Hiramatsu 2395146a1439SMasami Hiramatsu return ret; 2396f4d7da49SMasami Hiramatsu } 239750656eecSMasami Hiramatsu 2398146a1439SMasami Hiramatsu static int get_new_event_name(char *buf, size_t len, const char *base, 2399d761b08bSMasami Hiramatsu struct strlist *namelist, bool allow_suffix) 2400b498ce1fSMasami Hiramatsu { 2401b498ce1fSMasami Hiramatsu int i, ret; 2402663b1151SMasami Hiramatsu char *p, *nbase; 240317f88fcdSMasami Hiramatsu 24043099c026SNaveen N. Rao if (*base == '.') 24053099c026SNaveen N. Rao base++; 2406663b1151SMasami Hiramatsu nbase = strdup(base); 2407663b1151SMasami Hiramatsu if (!nbase) 2408663b1151SMasami Hiramatsu return -ENOMEM; 24093099c026SNaveen N. Rao 2410663b1151SMasami Hiramatsu /* Cut off the dot suffixes (e.g. .const, .isra)*/ 2411663b1151SMasami Hiramatsu p = strchr(nbase, '.'); 2412663b1151SMasami Hiramatsu if (p && p != nbase) 2413663b1151SMasami Hiramatsu *p = '\0'; 2414663b1151SMasami Hiramatsu 2415663b1151SMasami Hiramatsu /* Try no suffix number */ 2416663b1151SMasami Hiramatsu ret = e_snprintf(buf, len, "%s", nbase); 2417146a1439SMasami Hiramatsu if (ret < 0) { 24185f03cba4SMasami Hiramatsu pr_debug("snprintf() failed: %d\n", ret); 2419663b1151SMasami Hiramatsu goto out; 2420146a1439SMasami Hiramatsu } 242117f88fcdSMasami Hiramatsu if (!strlist__has_entry(namelist, buf)) 2422663b1151SMasami Hiramatsu goto out; 242317f88fcdSMasami Hiramatsu 2424d761b08bSMasami Hiramatsu if (!allow_suffix) { 242503e01f56SWang Nan pr_warning("Error: event \"%s\" already exists.\n" 242603e01f56SWang Nan " Hint: Remove existing event by 'perf probe -d'\n" 242703e01f56SWang Nan " or force duplicates by 'perf probe -f'\n" 242803e01f56SWang Nan " or set 'force=yes' in BPF source.\n", 242903e01f56SWang Nan buf); 2430663b1151SMasami Hiramatsu ret = -EEXIST; 2431663b1151SMasami Hiramatsu goto out; 2432d761b08bSMasami Hiramatsu } 2433d761b08bSMasami Hiramatsu 243417f88fcdSMasami Hiramatsu /* Try to add suffix */ 243517f88fcdSMasami Hiramatsu for (i = 1; i < MAX_EVENT_INDEX; i++) { 2436663b1151SMasami Hiramatsu ret = e_snprintf(buf, len, "%s_%d", nbase, i); 2437146a1439SMasami Hiramatsu if (ret < 0) { 24385f03cba4SMasami Hiramatsu pr_debug("snprintf() failed: %d\n", ret); 2439663b1151SMasami Hiramatsu goto out; 2440146a1439SMasami Hiramatsu } 2441b498ce1fSMasami Hiramatsu if (!strlist__has_entry(namelist, buf)) 2442b498ce1fSMasami Hiramatsu break; 2443b498ce1fSMasami Hiramatsu } 2444146a1439SMasami Hiramatsu if (i == MAX_EVENT_INDEX) { 2445146a1439SMasami Hiramatsu pr_warning("Too many events are on the same function.\n"); 2446146a1439SMasami Hiramatsu ret = -ERANGE; 2447b498ce1fSMasami Hiramatsu } 2448b498ce1fSMasami Hiramatsu 2449663b1151SMasami Hiramatsu out: 2450663b1151SMasami Hiramatsu free(nbase); 2451146a1439SMasami Hiramatsu return ret; 2452146a1439SMasami Hiramatsu } 2453146a1439SMasami Hiramatsu 245479702f61SMasami Hiramatsu /* Warn if the current kernel's uprobe implementation is old */ 245579702f61SMasami Hiramatsu static void warn_uprobe_event_compat(struct probe_trace_event *tev) 245679702f61SMasami Hiramatsu { 245779702f61SMasami Hiramatsu int i; 245879702f61SMasami Hiramatsu char *buf = synthesize_probe_trace_command(tev); 245979702f61SMasami Hiramatsu 246079702f61SMasami Hiramatsu /* Old uprobe event doesn't support memory dereference */ 246179702f61SMasami Hiramatsu if (!tev->uprobes || tev->nargs == 0 || !buf) 246279702f61SMasami Hiramatsu goto out; 246379702f61SMasami Hiramatsu 246479702f61SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) 246579702f61SMasami Hiramatsu if (strglobmatch(tev->args[i].value, "[$@+-]*")) { 246679702f61SMasami Hiramatsu pr_warning("Please upgrade your kernel to at least " 246779702f61SMasami Hiramatsu "3.14 to have access to feature %s\n", 246879702f61SMasami Hiramatsu tev->args[i].value); 246979702f61SMasami Hiramatsu break; 247079702f61SMasami Hiramatsu } 247179702f61SMasami Hiramatsu out: 247279702f61SMasami Hiramatsu free(buf); 247379702f61SMasami Hiramatsu } 247479702f61SMasami Hiramatsu 2475a3c9de62SMasami Hiramatsu /* Set new name from original perf_probe_event and namelist */ 2476a3c9de62SMasami Hiramatsu static int probe_trace_event__set_name(struct probe_trace_event *tev, 2477a3c9de62SMasami Hiramatsu struct perf_probe_event *pev, 2478a3c9de62SMasami Hiramatsu struct strlist *namelist, 2479a3c9de62SMasami Hiramatsu bool allow_suffix) 2480a3c9de62SMasami Hiramatsu { 2481a3c9de62SMasami Hiramatsu const char *event, *group; 2482a3c9de62SMasami Hiramatsu char buf[64]; 2483a3c9de62SMasami Hiramatsu int ret; 2484a3c9de62SMasami Hiramatsu 2485bc062230SMasami Hiramatsu /* If probe_event or trace_event already have the name, reuse it */ 2486a3c9de62SMasami Hiramatsu if (pev->event) 2487a3c9de62SMasami Hiramatsu event = pev->event; 2488bc062230SMasami Hiramatsu else if (tev->event) 2489bc062230SMasami Hiramatsu event = tev->event; 2490bc062230SMasami Hiramatsu else { 2491bc062230SMasami Hiramatsu /* Or generate new one from probe point */ 2492da15bd9dSWang Nan if (pev->point.function && 2493da15bd9dSWang Nan (strncmp(pev->point.function, "0x", 2) != 0) && 2494da15bd9dSWang Nan !strisglob(pev->point.function)) 2495a3c9de62SMasami Hiramatsu event = pev->point.function; 2496a3c9de62SMasami Hiramatsu else 2497a3c9de62SMasami Hiramatsu event = tev->point.realname; 2498bc062230SMasami Hiramatsu } 2499a3c9de62SMasami Hiramatsu if (pev->group) 2500a3c9de62SMasami Hiramatsu group = pev->group; 2501bc062230SMasami Hiramatsu else if (tev->group) 2502bc062230SMasami Hiramatsu group = tev->group; 2503a3c9de62SMasami Hiramatsu else 2504a3c9de62SMasami Hiramatsu group = PERFPROBE_GROUP; 2505a3c9de62SMasami Hiramatsu 2506a3c9de62SMasami Hiramatsu /* Get an unused new event name */ 2507a3c9de62SMasami Hiramatsu ret = get_new_event_name(buf, 64, event, 2508a3c9de62SMasami Hiramatsu namelist, allow_suffix); 2509a3c9de62SMasami Hiramatsu if (ret < 0) 2510a3c9de62SMasami Hiramatsu return ret; 2511a3c9de62SMasami Hiramatsu 2512a3c9de62SMasami Hiramatsu event = buf; 2513a3c9de62SMasami Hiramatsu 2514a3c9de62SMasami Hiramatsu tev->event = strdup(event); 2515a3c9de62SMasami Hiramatsu tev->group = strdup(group); 2516a3c9de62SMasami Hiramatsu if (tev->event == NULL || tev->group == NULL) 2517a3c9de62SMasami Hiramatsu return -ENOMEM; 2518a3c9de62SMasami Hiramatsu 2519a3c9de62SMasami Hiramatsu /* Add added event name to namelist */ 2520a3c9de62SMasami Hiramatsu strlist__add(namelist, event); 2521a3c9de62SMasami Hiramatsu return 0; 2522a3c9de62SMasami Hiramatsu } 2523a3c9de62SMasami Hiramatsu 25240e60836bSSrikar Dronamraju static int __add_probe_trace_events(struct perf_probe_event *pev, 25250e60836bSSrikar Dronamraju struct probe_trace_event *tevs, 25264235b045SMasami Hiramatsu int ntevs, bool allow_suffix) 252750656eecSMasami Hiramatsu { 2528146a1439SMasami Hiramatsu int i, fd, ret; 25290e60836bSSrikar Dronamraju struct probe_trace_event *tev = NULL; 25302fd457a3SMasami Hiramatsu struct probe_cache *cache = NULL; 2531b498ce1fSMasami Hiramatsu struct strlist *namelist; 253250656eecSMasami Hiramatsu 253392f6c72eSMasami Hiramatsu fd = probe_file__open(PF_FL_RW | (pev->uprobes ? PF_FL_UPROBE : 0)); 253492f6c72eSMasami Hiramatsu if (fd < 0) 2535146a1439SMasami Hiramatsu return fd; 25365e45187cSMasami Hiramatsu 2537b498ce1fSMasami Hiramatsu /* Get current event names */ 253892f6c72eSMasami Hiramatsu namelist = probe_file__get_namelist(fd); 2539146a1439SMasami Hiramatsu if (!namelist) { 2540146a1439SMasami Hiramatsu pr_debug("Failed to get current event list.\n"); 2541ae2cb1acSMasami Hiramatsu ret = -ENOMEM; 2542ae2cb1acSMasami Hiramatsu goto close_out; 2543146a1439SMasami Hiramatsu } 254450656eecSMasami Hiramatsu 2545146a1439SMasami Hiramatsu ret = 0; 254602b95dadSMasami Hiramatsu for (i = 0; i < ntevs; i++) { 25474235b045SMasami Hiramatsu tev = &tevs[i]; 2548b031220dSMasami Hiramatsu /* Skip if the symbol is out of .text or blacklisted */ 2549bc062230SMasami Hiramatsu if (!tev->point.symbol && !pev->uprobes) 25505a51fcd1SMasami Hiramatsu continue; 25519aaf5a5fSMasami Hiramatsu 2552a3c9de62SMasami Hiramatsu /* Set new name for tev (and update namelist) */ 2553a3c9de62SMasami Hiramatsu ret = probe_trace_event__set_name(tev, pev, namelist, 2554a3c9de62SMasami Hiramatsu allow_suffix); 2555146a1439SMasami Hiramatsu if (ret < 0) 2556146a1439SMasami Hiramatsu break; 25574235b045SMasami Hiramatsu 255892f6c72eSMasami Hiramatsu ret = probe_file__add_event(fd, tev); 2559146a1439SMasami Hiramatsu if (ret < 0) 2560146a1439SMasami Hiramatsu break; 25614235b045SMasami Hiramatsu 2562d761b08bSMasami Hiramatsu /* 2563d761b08bSMasami Hiramatsu * Probes after the first probe which comes from same 2564d761b08bSMasami Hiramatsu * user input are always allowed to add suffix, because 2565d761b08bSMasami Hiramatsu * there might be several addresses corresponding to 2566d761b08bSMasami Hiramatsu * one code line. 2567d761b08bSMasami Hiramatsu */ 2568d761b08bSMasami Hiramatsu allow_suffix = true; 256950656eecSMasami Hiramatsu } 257079702f61SMasami Hiramatsu if (ret == -EINVAL && pev->uprobes) 257179702f61SMasami Hiramatsu warn_uprobe_event_compat(tev); 25722fd457a3SMasami Hiramatsu if (ret == 0 && probe_conf.cache) { 25732fd457a3SMasami Hiramatsu cache = probe_cache__new(pev->target); 25742fd457a3SMasami Hiramatsu if (!cache || 25752fd457a3SMasami Hiramatsu probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 || 25762fd457a3SMasami Hiramatsu probe_cache__commit(cache) < 0) 25772fd457a3SMasami Hiramatsu pr_warning("Failed to add event to probe cache\n"); 25782fd457a3SMasami Hiramatsu probe_cache__delete(cache); 25792fd457a3SMasami Hiramatsu } 2580146a1439SMasami Hiramatsu 2581e1d2017bSMasami Hiramatsu strlist__delete(namelist); 2582ae2cb1acSMasami Hiramatsu close_out: 258350656eecSMasami Hiramatsu close(fd); 2584146a1439SMasami Hiramatsu return ret; 258550656eecSMasami Hiramatsu } 2586fa28244dSMasami Hiramatsu 25876bb536ccSWang Nan static int find_probe_functions(struct map *map, char *name, 25886bb536ccSWang Nan struct symbol **syms) 2589eb948e50SMasami Hiramatsu { 2590564c62a4SNamhyung Kim int found = 0; 25910a3873a8SArnaldo Carvalho de Melo struct symbol *sym; 25924c859351SMasami Hiramatsu struct rb_node *tmp; 2593564c62a4SNamhyung Kim 259475e4a2a6SWang Nan if (map__load(map, NULL) < 0) 259575e4a2a6SWang Nan return 0; 259675e4a2a6SWang Nan 25974c859351SMasami Hiramatsu map__for_each_symbol(map, sym, tmp) { 25986bb536ccSWang Nan if (strglobmatch(sym->name, name)) { 2599564c62a4SNamhyung Kim found++; 26006bb536ccSWang Nan if (syms && found < probe_conf.max_probes) 26016bb536ccSWang Nan syms[found - 1] = sym; 26026bb536ccSWang Nan } 2603eb948e50SMasami Hiramatsu } 2604564c62a4SNamhyung Kim 2605564c62a4SNamhyung Kim return found; 2606eb948e50SMasami Hiramatsu } 2607eb948e50SMasami Hiramatsu 26087b6ff0bdSNaveen N. Rao void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused, 26097b6ff0bdSNaveen N. Rao struct probe_trace_event *tev __maybe_unused, 26100b3c2264SNaveen N. Rao struct map *map __maybe_unused, 26110b3c2264SNaveen N. Rao struct symbol *sym __maybe_unused) { } 26127b6ff0bdSNaveen N. Rao 2613eb948e50SMasami Hiramatsu /* 2614eb948e50SMasami Hiramatsu * Find probe function addresses from map. 2615eb948e50SMasami Hiramatsu * Return an error or the number of found probe_trace_event 2616eb948e50SMasami Hiramatsu */ 2617eb948e50SMasami Hiramatsu static int find_probe_trace_events_from_map(struct perf_probe_event *pev, 2618ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs) 2619eb948e50SMasami Hiramatsu { 2620eb948e50SMasami Hiramatsu struct map *map = NULL; 2621eb948e50SMasami Hiramatsu struct ref_reloc_sym *reloc_sym = NULL; 2622eb948e50SMasami Hiramatsu struct symbol *sym; 26236bb536ccSWang Nan struct symbol **syms = NULL; 2624eb948e50SMasami Hiramatsu struct probe_trace_event *tev; 2625eb948e50SMasami Hiramatsu struct perf_probe_point *pp = &pev->point; 2626eb948e50SMasami Hiramatsu struct probe_trace_point *tp; 2627564c62a4SNamhyung Kim int num_matched_functions; 2628b031220dSMasami Hiramatsu int ret, i, j, skipped = 0; 2629c61fb959SRavi Bangoria char *mod_name; 2630eb948e50SMasami Hiramatsu 263144225521SMasami Hiramatsu map = get_target_map(pev->target, pev->uprobes); 2632eb948e50SMasami Hiramatsu if (!map) { 2633eb948e50SMasami Hiramatsu ret = -EINVAL; 2634eb948e50SMasami Hiramatsu goto out; 2635eb948e50SMasami Hiramatsu } 2636eb948e50SMasami Hiramatsu 26376bb536ccSWang Nan syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes); 26386bb536ccSWang Nan if (!syms) { 26396bb536ccSWang Nan ret = -ENOMEM; 26406bb536ccSWang Nan goto out; 26416bb536ccSWang Nan } 26426bb536ccSWang Nan 2643eb948e50SMasami Hiramatsu /* 2644eb948e50SMasami Hiramatsu * Load matched symbols: Since the different local symbols may have 2645eb948e50SMasami Hiramatsu * same name but different addresses, this lists all the symbols. 2646eb948e50SMasami Hiramatsu */ 26476bb536ccSWang Nan num_matched_functions = find_probe_functions(map, pp->function, syms); 2648564c62a4SNamhyung Kim if (num_matched_functions == 0) { 2649eb948e50SMasami Hiramatsu pr_err("Failed to find symbol %s in %s\n", pp->function, 265044225521SMasami Hiramatsu pev->target ? : "kernel"); 2651eb948e50SMasami Hiramatsu ret = -ENOENT; 2652eb948e50SMasami Hiramatsu goto out; 2653ddb2f58fSMasami Hiramatsu } else if (num_matched_functions > probe_conf.max_probes) { 2654eb948e50SMasami Hiramatsu pr_err("Too many functions matched in %s\n", 265544225521SMasami Hiramatsu pev->target ? : "kernel"); 2656eb948e50SMasami Hiramatsu ret = -E2BIG; 2657eb948e50SMasami Hiramatsu goto out; 2658eb948e50SMasami Hiramatsu } 2659eb948e50SMasami Hiramatsu 26601a8ac29cSMasami Hiramatsu /* Note that the symbols in the kmodule are not relocated */ 26611a8ac29cSMasami Hiramatsu if (!pev->uprobes && !pp->retprobe && !pev->target) { 26620560a0c4SHe Kuang reloc_sym = kernel_get_ref_reloc_sym(); 2663eb948e50SMasami Hiramatsu if (!reloc_sym) { 2664eb948e50SMasami Hiramatsu pr_warning("Relocated base symbol is not found!\n"); 2665eb948e50SMasami Hiramatsu ret = -EINVAL; 2666eb948e50SMasami Hiramatsu goto out; 2667eb948e50SMasami Hiramatsu } 2668eb948e50SMasami Hiramatsu } 2669eb948e50SMasami Hiramatsu 2670eb948e50SMasami Hiramatsu /* Setup result trace-probe-events */ 2671eb948e50SMasami Hiramatsu *tevs = zalloc(sizeof(*tev) * num_matched_functions); 2672eb948e50SMasami Hiramatsu if (!*tevs) { 2673eb948e50SMasami Hiramatsu ret = -ENOMEM; 2674eb948e50SMasami Hiramatsu goto out; 2675eb948e50SMasami Hiramatsu } 2676eb948e50SMasami Hiramatsu 2677eb948e50SMasami Hiramatsu ret = 0; 2678564c62a4SNamhyung Kim 26796bb536ccSWang Nan for (j = 0; j < num_matched_functions; j++) { 26806bb536ccSWang Nan sym = syms[j]; 26816bb536ccSWang Nan 2682eb948e50SMasami Hiramatsu tev = (*tevs) + ret; 2683eb948e50SMasami Hiramatsu tp = &tev->point; 2684eb948e50SMasami Hiramatsu if (ret == num_matched_functions) { 2685eb948e50SMasami Hiramatsu pr_warning("Too many symbols are listed. Skip it.\n"); 2686eb948e50SMasami Hiramatsu break; 2687eb948e50SMasami Hiramatsu } 2688eb948e50SMasami Hiramatsu ret++; 2689eb948e50SMasami Hiramatsu 2690eb948e50SMasami Hiramatsu if (pp->offset > sym->end - sym->start) { 2691eb948e50SMasami Hiramatsu pr_warning("Offset %ld is bigger than the size of %s\n", 2692eb948e50SMasami Hiramatsu pp->offset, sym->name); 2693eb948e50SMasami Hiramatsu ret = -ENOENT; 2694eb948e50SMasami Hiramatsu goto err_out; 2695eb948e50SMasami Hiramatsu } 2696eb948e50SMasami Hiramatsu /* Add one probe point */ 2697eb948e50SMasami Hiramatsu tp->address = map->unmap_ip(map, sym->start) + pp->offset; 26981a8ac29cSMasami Hiramatsu 26991a8ac29cSMasami Hiramatsu /* Check the kprobe (not in module) is within .text */ 27001a8ac29cSMasami Hiramatsu if (!pev->uprobes && !pev->target && 2701b031220dSMasami Hiramatsu kprobe_warn_out_range(sym->name, tp->address)) { 2702b031220dSMasami Hiramatsu tp->symbol = NULL; /* Skip it */ 2703b031220dSMasami Hiramatsu skipped++; 2704b031220dSMasami Hiramatsu } else if (reloc_sym) { 2705eb948e50SMasami Hiramatsu tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out); 2706eb948e50SMasami Hiramatsu tp->offset = tp->address - reloc_sym->addr; 2707eb948e50SMasami Hiramatsu } else { 2708eb948e50SMasami Hiramatsu tp->symbol = strdup_or_goto(sym->name, nomem_out); 2709eb948e50SMasami Hiramatsu tp->offset = pp->offset; 2710eb948e50SMasami Hiramatsu } 27116bb536ccSWang Nan tp->realname = strdup_or_goto(sym->name, nomem_out); 27126bb536ccSWang Nan 2713eb948e50SMasami Hiramatsu tp->retprobe = pp->retprobe; 2714c61fb959SRavi Bangoria if (pev->target) { 2715c61fb959SRavi Bangoria if (pev->uprobes) { 271644225521SMasami Hiramatsu tev->point.module = strdup_or_goto(pev->target, 271744225521SMasami Hiramatsu nomem_out); 2718c61fb959SRavi Bangoria } else { 2719c61fb959SRavi Bangoria mod_name = find_module_name(pev->target); 2720c61fb959SRavi Bangoria tev->point.module = 2721c61fb959SRavi Bangoria strdup(mod_name ? mod_name : pev->target); 2722c61fb959SRavi Bangoria free(mod_name); 2723c61fb959SRavi Bangoria if (!tev->point.module) 2724c61fb959SRavi Bangoria goto nomem_out; 2725c61fb959SRavi Bangoria } 2726c61fb959SRavi Bangoria } 2727eb948e50SMasami Hiramatsu tev->uprobes = pev->uprobes; 2728eb948e50SMasami Hiramatsu tev->nargs = pev->nargs; 2729eb948e50SMasami Hiramatsu if (tev->nargs) { 2730eb948e50SMasami Hiramatsu tev->args = zalloc(sizeof(struct probe_trace_arg) * 2731eb948e50SMasami Hiramatsu tev->nargs); 2732eb948e50SMasami Hiramatsu if (tev->args == NULL) 2733eb948e50SMasami Hiramatsu goto nomem_out; 2734eb948e50SMasami Hiramatsu } 2735eb948e50SMasami Hiramatsu for (i = 0; i < tev->nargs; i++) { 2736eb948e50SMasami Hiramatsu if (pev->args[i].name) 2737eb948e50SMasami Hiramatsu tev->args[i].name = 2738eb948e50SMasami Hiramatsu strdup_or_goto(pev->args[i].name, 2739eb948e50SMasami Hiramatsu nomem_out); 2740eb948e50SMasami Hiramatsu 2741eb948e50SMasami Hiramatsu tev->args[i].value = strdup_or_goto(pev->args[i].var, 2742eb948e50SMasami Hiramatsu nomem_out); 2743eb948e50SMasami Hiramatsu if (pev->args[i].type) 2744eb948e50SMasami Hiramatsu tev->args[i].type = 2745eb948e50SMasami Hiramatsu strdup_or_goto(pev->args[i].type, 2746eb948e50SMasami Hiramatsu nomem_out); 2747eb948e50SMasami Hiramatsu } 27480b3c2264SNaveen N. Rao arch__fix_tev_from_maps(pev, tev, map, sym); 2749eb948e50SMasami Hiramatsu } 2750b031220dSMasami Hiramatsu if (ret == skipped) { 2751b031220dSMasami Hiramatsu ret = -ENOENT; 2752b031220dSMasami Hiramatsu goto err_out; 2753b031220dSMasami Hiramatsu } 2754eb948e50SMasami Hiramatsu 2755eb948e50SMasami Hiramatsu out: 27569b118acaSMasami Hiramatsu put_target_map(map, pev->uprobes); 27576bb536ccSWang Nan free(syms); 2758eb948e50SMasami Hiramatsu return ret; 2759eb948e50SMasami Hiramatsu 2760eb948e50SMasami Hiramatsu nomem_out: 2761eb948e50SMasami Hiramatsu ret = -ENOMEM; 2762eb948e50SMasami Hiramatsu err_out: 2763eb948e50SMasami Hiramatsu clear_probe_trace_events(*tevs, num_matched_functions); 2764eb948e50SMasami Hiramatsu zfree(tevs); 2765eb948e50SMasami Hiramatsu goto out; 2766eb948e50SMasami Hiramatsu } 2767eb948e50SMasami Hiramatsu 2768da15bd9dSWang Nan static int try_to_find_absolute_address(struct perf_probe_event *pev, 2769da15bd9dSWang Nan struct probe_trace_event **tevs) 2770da15bd9dSWang Nan { 2771da15bd9dSWang Nan struct perf_probe_point *pp = &pev->point; 2772da15bd9dSWang Nan struct probe_trace_event *tev; 2773da15bd9dSWang Nan struct probe_trace_point *tp; 2774da15bd9dSWang Nan int i, err; 2775da15bd9dSWang Nan 2776da15bd9dSWang Nan if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2))) 2777da15bd9dSWang Nan return -EINVAL; 2778da15bd9dSWang Nan if (perf_probe_event_need_dwarf(pev)) 2779da15bd9dSWang Nan return -EINVAL; 2780da15bd9dSWang Nan 2781da15bd9dSWang Nan /* 2782da15bd9dSWang Nan * This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at 2783da15bd9dSWang Nan * absolute address. 2784da15bd9dSWang Nan * 2785da15bd9dSWang Nan * Only one tev can be generated by this. 2786da15bd9dSWang Nan */ 2787da15bd9dSWang Nan *tevs = zalloc(sizeof(*tev)); 2788da15bd9dSWang Nan if (!*tevs) 2789da15bd9dSWang Nan return -ENOMEM; 2790da15bd9dSWang Nan 2791da15bd9dSWang Nan tev = *tevs; 2792da15bd9dSWang Nan tp = &tev->point; 2793da15bd9dSWang Nan 2794da15bd9dSWang Nan /* 2795da15bd9dSWang Nan * Don't use tp->offset, use address directly, because 2796da15bd9dSWang Nan * in synthesize_probe_trace_command() address cannot be 2797da15bd9dSWang Nan * zero. 2798da15bd9dSWang Nan */ 2799da15bd9dSWang Nan tp->address = pev->point.abs_address; 2800da15bd9dSWang Nan tp->retprobe = pp->retprobe; 2801da15bd9dSWang Nan tev->uprobes = pev->uprobes; 2802da15bd9dSWang Nan 2803da15bd9dSWang Nan err = -ENOMEM; 2804da15bd9dSWang Nan /* 2805da15bd9dSWang Nan * Give it a '0x' leading symbol name. 2806da15bd9dSWang Nan * In __add_probe_trace_events, a NULL symbol is interpreted as 2807da15bd9dSWang Nan * invalud. 2808da15bd9dSWang Nan */ 2809da15bd9dSWang Nan if (asprintf(&tp->symbol, "0x%lx", tp->address) < 0) 2810da15bd9dSWang Nan goto errout; 2811da15bd9dSWang Nan 2812da15bd9dSWang Nan /* For kprobe, check range */ 2813da15bd9dSWang Nan if ((!tev->uprobes) && 2814da15bd9dSWang Nan (kprobe_warn_out_range(tev->point.symbol, 2815da15bd9dSWang Nan tev->point.address))) { 2816da15bd9dSWang Nan err = -EACCES; 2817da15bd9dSWang Nan goto errout; 2818da15bd9dSWang Nan } 2819da15bd9dSWang Nan 2820da15bd9dSWang Nan if (asprintf(&tp->realname, "abs_%lx", tp->address) < 0) 2821da15bd9dSWang Nan goto errout; 2822da15bd9dSWang Nan 2823da15bd9dSWang Nan if (pev->target) { 2824da15bd9dSWang Nan tp->module = strdup(pev->target); 2825da15bd9dSWang Nan if (!tp->module) 2826da15bd9dSWang Nan goto errout; 2827da15bd9dSWang Nan } 2828da15bd9dSWang Nan 2829da15bd9dSWang Nan if (tev->group) { 2830da15bd9dSWang Nan tev->group = strdup(pev->group); 2831da15bd9dSWang Nan if (!tev->group) 2832da15bd9dSWang Nan goto errout; 2833da15bd9dSWang Nan } 2834da15bd9dSWang Nan 2835da15bd9dSWang Nan if (pev->event) { 2836da15bd9dSWang Nan tev->event = strdup(pev->event); 2837da15bd9dSWang Nan if (!tev->event) 2838da15bd9dSWang Nan goto errout; 2839da15bd9dSWang Nan } 2840da15bd9dSWang Nan 2841da15bd9dSWang Nan tev->nargs = pev->nargs; 2842da15bd9dSWang Nan tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs); 2843da15bd9dSWang Nan if (!tev->args) { 2844da15bd9dSWang Nan err = -ENOMEM; 2845da15bd9dSWang Nan goto errout; 2846da15bd9dSWang Nan } 2847da15bd9dSWang Nan for (i = 0; i < tev->nargs; i++) 2848da15bd9dSWang Nan copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]); 2849da15bd9dSWang Nan 2850da15bd9dSWang Nan return 1; 2851da15bd9dSWang Nan 2852da15bd9dSWang Nan errout: 2853da15bd9dSWang Nan if (*tevs) { 2854da15bd9dSWang Nan clear_probe_trace_events(*tevs, 1); 2855da15bd9dSWang Nan *tevs = NULL; 2856da15bd9dSWang Nan } 2857da15bd9dSWang Nan return err; 2858da15bd9dSWang Nan } 2859da15bd9dSWang Nan 2860d5c2e2c1SNaveen N. Rao bool __weak arch__prefers_symtab(void) { return false; } 2861d5c2e2c1SNaveen N. Rao 2862bc062230SMasami Hiramatsu static int find_probe_trace_events_from_cache(struct perf_probe_event *pev, 2863bc062230SMasami Hiramatsu struct probe_trace_event **tevs) 2864bc062230SMasami Hiramatsu { 2865bc062230SMasami Hiramatsu struct probe_cache *cache; 2866bc062230SMasami Hiramatsu struct probe_cache_entry *entry; 2867bc062230SMasami Hiramatsu struct probe_trace_event *tev; 2868bc062230SMasami Hiramatsu struct str_node *node; 2869bc062230SMasami Hiramatsu int ret, i; 2870bc062230SMasami Hiramatsu 2871bc062230SMasami Hiramatsu cache = probe_cache__new(pev->target); 2872bc062230SMasami Hiramatsu if (!cache) 2873bc062230SMasami Hiramatsu return 0; 2874bc062230SMasami Hiramatsu 2875bc062230SMasami Hiramatsu entry = probe_cache__find(cache, pev); 2876bc062230SMasami Hiramatsu if (!entry) { 2877bc062230SMasami Hiramatsu ret = 0; 2878bc062230SMasami Hiramatsu goto out; 2879bc062230SMasami Hiramatsu } 2880bc062230SMasami Hiramatsu 2881bc062230SMasami Hiramatsu ret = strlist__nr_entries(entry->tevlist); 2882bc062230SMasami Hiramatsu if (ret > probe_conf.max_probes) { 2883bc062230SMasami Hiramatsu pr_debug("Too many entries matched in the cache of %s\n", 2884bc062230SMasami Hiramatsu pev->target ? : "kernel"); 2885bc062230SMasami Hiramatsu ret = -E2BIG; 2886bc062230SMasami Hiramatsu goto out; 2887bc062230SMasami Hiramatsu } 2888bc062230SMasami Hiramatsu 2889bc062230SMasami Hiramatsu *tevs = zalloc(ret * sizeof(*tev)); 2890bc062230SMasami Hiramatsu if (!*tevs) { 2891bc062230SMasami Hiramatsu ret = -ENOMEM; 2892bc062230SMasami Hiramatsu goto out; 2893bc062230SMasami Hiramatsu } 2894bc062230SMasami Hiramatsu 2895bc062230SMasami Hiramatsu i = 0; 2896bc062230SMasami Hiramatsu strlist__for_each_entry(node, entry->tevlist) { 2897bc062230SMasami Hiramatsu tev = &(*tevs)[i++]; 2898bc062230SMasami Hiramatsu ret = parse_probe_trace_command(node->s, tev); 2899bc062230SMasami Hiramatsu if (ret < 0) 2900bc062230SMasami Hiramatsu goto out; 2901bc062230SMasami Hiramatsu /* Set the uprobes attribute as same as original */ 2902bc062230SMasami Hiramatsu tev->uprobes = pev->uprobes; 2903bc062230SMasami Hiramatsu } 2904bc062230SMasami Hiramatsu ret = i; 2905bc062230SMasami Hiramatsu 2906bc062230SMasami Hiramatsu out: 2907bc062230SMasami Hiramatsu probe_cache__delete(cache); 2908bc062230SMasami Hiramatsu return ret; 2909bc062230SMasami Hiramatsu } 2910bc062230SMasami Hiramatsu 29110e60836bSSrikar Dronamraju static int convert_to_probe_trace_events(struct perf_probe_event *pev, 2912ddb2f58fSMasami Hiramatsu struct probe_trace_event **tevs) 2913e0faa8d3SMasami Hiramatsu { 2914eb948e50SMasami Hiramatsu int ret; 29154235b045SMasami Hiramatsu 29162a12ec13SMasami Hiramatsu if (!pev->group) { 29172a12ec13SMasami Hiramatsu /* Set group name if not given */ 29182a12ec13SMasami Hiramatsu if (!pev->uprobes) { 29192a12ec13SMasami Hiramatsu pev->group = strdup(PERFPROBE_GROUP); 29202a12ec13SMasami Hiramatsu ret = pev->group ? 0 : -ENOMEM; 29212a12ec13SMasami Hiramatsu } else 292244225521SMasami Hiramatsu ret = convert_exec_to_group(pev->target, &pev->group); 2923fb7345bbSMasami Hiramatsu if (ret != 0) { 2924fb7345bbSMasami Hiramatsu pr_warning("Failed to make a group name.\n"); 2925fb7345bbSMasami Hiramatsu return ret; 2926fb7345bbSMasami Hiramatsu } 2927fb7345bbSMasami Hiramatsu } 2928fb7345bbSMasami Hiramatsu 2929da15bd9dSWang Nan ret = try_to_find_absolute_address(pev, tevs); 2930da15bd9dSWang Nan if (ret > 0) 2931da15bd9dSWang Nan return ret; 2932da15bd9dSWang Nan 2933bc062230SMasami Hiramatsu /* At first, we need to lookup cache entry */ 2934bc062230SMasami Hiramatsu ret = find_probe_trace_events_from_cache(pev, tevs); 2935bc062230SMasami Hiramatsu if (ret > 0) 2936bc062230SMasami Hiramatsu return ret; /* Found in probe cache */ 2937bc062230SMasami Hiramatsu 2938d5c2e2c1SNaveen N. Rao if (arch__prefers_symtab() && !perf_probe_event_need_dwarf(pev)) { 2939ddb2f58fSMasami Hiramatsu ret = find_probe_trace_events_from_map(pev, tevs); 2940d5c2e2c1SNaveen N. Rao if (ret > 0) 2941d5c2e2c1SNaveen N. Rao return ret; /* Found in symbol table */ 2942d5c2e2c1SNaveen N. Rao } 2943d5c2e2c1SNaveen N. Rao 29444b4da7f7SMasami Hiramatsu /* Convert perf_probe_event with debuginfo */ 2945ddb2f58fSMasami Hiramatsu ret = try_to_find_probe_trace_events(pev, tevs); 2946e334016fSMasami Hiramatsu if (ret != 0) 2947190b57fcSMasami Hiramatsu return ret; /* Found in debuginfo or got an error */ 2948e0faa8d3SMasami Hiramatsu 2949ddb2f58fSMasami Hiramatsu return find_probe_trace_events_from_map(pev, tevs); 29504235b045SMasami Hiramatsu } 29514235b045SMasami Hiramatsu 295212fae5efSWang Nan int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs) 29534235b045SMasami Hiramatsu { 2954844dffa5SNamhyung Kim int i, ret; 29554235b045SMasami Hiramatsu 29564235b045SMasami Hiramatsu /* Loop 1: convert all events */ 29574235b045SMasami Hiramatsu for (i = 0; i < npevs; i++) { 2958b031220dSMasami Hiramatsu /* Init kprobe blacklist if needed */ 295912fae5efSWang Nan if (!pevs[i].uprobes) 2960b031220dSMasami Hiramatsu kprobe_blacklist__init(); 29614235b045SMasami Hiramatsu /* Convert with or without debuginfo */ 296212fae5efSWang Nan ret = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs); 2963146a1439SMasami Hiramatsu if (ret < 0) 2964844dffa5SNamhyung Kim return ret; 296512fae5efSWang Nan pevs[i].ntevs = ret; 29664235b045SMasami Hiramatsu } 2967b031220dSMasami Hiramatsu /* This just release blacklist only if allocated */ 2968b031220dSMasami Hiramatsu kprobe_blacklist__release(); 29694235b045SMasami Hiramatsu 2970844dffa5SNamhyung Kim return 0; 2971844dffa5SNamhyung Kim } 2972844dffa5SNamhyung Kim 297312fae5efSWang Nan int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs) 2974844dffa5SNamhyung Kim { 2975844dffa5SNamhyung Kim int i, ret = 0; 2976844dffa5SNamhyung Kim 29774235b045SMasami Hiramatsu /* Loop 2: add all events */ 29788635bf6eSArnaldo Carvalho de Melo for (i = 0; i < npevs; i++) { 297912fae5efSWang Nan ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs, 298012fae5efSWang Nan pevs[i].ntevs, 2981ddb2f58fSMasami Hiramatsu probe_conf.force_add); 2982fbee632dSArnaldo Carvalho de Melo if (ret < 0) 2983fbee632dSArnaldo Carvalho de Melo break; 2984fbee632dSArnaldo Carvalho de Melo } 2985844dffa5SNamhyung Kim return ret; 2986844dffa5SNamhyung Kim } 2987844dffa5SNamhyung Kim 298812fae5efSWang Nan void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs) 2989844dffa5SNamhyung Kim { 2990844dffa5SNamhyung Kim int i, j; 2991844dffa5SNamhyung Kim 2992449e5b24SMasami Hiramatsu /* Loop 3: cleanup and free trace events */ 2993449e5b24SMasami Hiramatsu for (i = 0; i < npevs; i++) { 299412fae5efSWang Nan for (j = 0; j < pevs[i].ntevs; j++) 299512fae5efSWang Nan clear_probe_trace_event(&pevs[i].tevs[j]); 299612fae5efSWang Nan zfree(&pevs[i].tevs); 299712fae5efSWang Nan pevs[i].ntevs = 0; 2998a43aac29SNamhyung Kim clear_perf_probe_event(&pevs[i]); 2999449e5b24SMasami Hiramatsu } 3000844dffa5SNamhyung Kim } 3001844dffa5SNamhyung Kim 3002844dffa5SNamhyung Kim int add_perf_probe_events(struct perf_probe_event *pevs, int npevs) 3003844dffa5SNamhyung Kim { 3004844dffa5SNamhyung Kim int ret; 3005844dffa5SNamhyung Kim 30069bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(pevs->uprobes); 30079bae1e8cSNamhyung Kim if (ret < 0) 30089bae1e8cSNamhyung Kim return ret; 30099bae1e8cSNamhyung Kim 301012fae5efSWang Nan ret = convert_perf_probe_events(pevs, npevs); 3011844dffa5SNamhyung Kim if (ret == 0) 301212fae5efSWang Nan ret = apply_perf_probe_events(pevs, npevs); 3013844dffa5SNamhyung Kim 301412fae5efSWang Nan cleanup_perf_probe_events(pevs, npevs); 3015146a1439SMasami Hiramatsu 30169bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 3017146a1439SMasami Hiramatsu return ret; 3018e0faa8d3SMasami Hiramatsu } 3019e0faa8d3SMasami Hiramatsu 3020307a464bSMasami Hiramatsu int del_perf_probe_events(struct strfilter *filter) 3021fa28244dSMasami Hiramatsu { 3022307a464bSMasami Hiramatsu int ret, ret2, ufd = -1, kfd = -1; 3023307a464bSMasami Hiramatsu char *str = strfilter__string(filter); 3024307a464bSMasami Hiramatsu 3025307a464bSMasami Hiramatsu if (!str) 3026307a464bSMasami Hiramatsu return -EINVAL; 3027307a464bSMasami Hiramatsu 3028fa28244dSMasami Hiramatsu /* Get current event names */ 302992f6c72eSMasami Hiramatsu ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW); 303092f6c72eSMasami Hiramatsu if (ret < 0) 303192f6c72eSMasami Hiramatsu goto out; 3032225466f1SSrikar Dronamraju 303392f6c72eSMasami Hiramatsu ret = probe_file__del_events(kfd, filter); 3034307a464bSMasami Hiramatsu if (ret < 0 && ret != -ENOENT) 3035225466f1SSrikar Dronamraju goto error; 3036fa28244dSMasami Hiramatsu 303792f6c72eSMasami Hiramatsu ret2 = probe_file__del_events(ufd, filter); 3038dddc7ee3SMasami Hiramatsu if (ret2 < 0 && ret2 != -ENOENT) { 30396dbe31f7SMasami Hiramatsu ret = ret2; 3040dddc7ee3SMasami Hiramatsu goto error; 3041dddc7ee3SMasami Hiramatsu } 3042307a464bSMasami Hiramatsu ret = 0; 3043225466f1SSrikar Dronamraju 3044225466f1SSrikar Dronamraju error: 304592f6c72eSMasami Hiramatsu if (kfd >= 0) 3046225466f1SSrikar Dronamraju close(kfd); 304792f6c72eSMasami Hiramatsu if (ufd >= 0) 3048225466f1SSrikar Dronamraju close(ufd); 304992f6c72eSMasami Hiramatsu out: 3050307a464bSMasami Hiramatsu free(str); 3051146a1439SMasami Hiramatsu 3052146a1439SMasami Hiramatsu return ret; 3053fa28244dSMasami Hiramatsu } 3054225466f1SSrikar Dronamraju 30553c42258cSMasami Hiramatsu /* TODO: don't use a global variable for filter ... */ 30563c42258cSMasami Hiramatsu static struct strfilter *available_func_filter; 3057fa28244dSMasami Hiramatsu 3058e80711caSMasami Hiramatsu /* 30593c42258cSMasami Hiramatsu * If a symbol corresponds to a function with global binding and 30603c42258cSMasami Hiramatsu * matches filter return 0. For all others return 1. 3061e80711caSMasami Hiramatsu */ 30621d037ca1SIrina Tirdea static int filter_available_functions(struct map *map __maybe_unused, 3063e80711caSMasami Hiramatsu struct symbol *sym) 3064e80711caSMasami Hiramatsu { 3065e578da3bSNamhyung Kim if (strfilter__compare(available_func_filter, sym->name)) 3066e80711caSMasami Hiramatsu return 0; 30673c42258cSMasami Hiramatsu return 1; 3068e80711caSMasami Hiramatsu } 3069e80711caSMasami Hiramatsu 30702df58634SMasami Hiramatsu int show_available_funcs(const char *target, struct strfilter *_filter, 30712df58634SMasami Hiramatsu bool user) 3072e80711caSMasami Hiramatsu { 30732df58634SMasami Hiramatsu struct map *map; 30742df58634SMasami Hiramatsu int ret; 30752df58634SMasami Hiramatsu 30769bae1e8cSNamhyung Kim ret = init_probe_symbol_maps(user); 30772df58634SMasami Hiramatsu if (ret < 0) 30782df58634SMasami Hiramatsu return ret; 30792df58634SMasami Hiramatsu 30802df58634SMasami Hiramatsu /* Get a symbol map */ 30812df58634SMasami Hiramatsu if (user) 30822df58634SMasami Hiramatsu map = dso__new_map(target); 30832df58634SMasami Hiramatsu else 30842df58634SMasami Hiramatsu map = kernel_get_module_map(target); 30852df58634SMasami Hiramatsu if (!map) { 30862df58634SMasami Hiramatsu pr_err("Failed to get a map for %s\n", (target) ? : "kernel"); 3087e80711caSMasami Hiramatsu return -EINVAL; 3088e80711caSMasami Hiramatsu } 30892df58634SMasami Hiramatsu 30902df58634SMasami Hiramatsu /* Load symbols with given filter */ 30912df58634SMasami Hiramatsu available_func_filter = _filter; 30922df58634SMasami Hiramatsu if (map__load(map, filter_available_functions)) { 30932df58634SMasami Hiramatsu pr_err("Failed to load symbols in %s\n", (target) ? : "kernel"); 30942df58634SMasami Hiramatsu goto end; 30952df58634SMasami Hiramatsu } 3096e80711caSMasami Hiramatsu if (!dso__sorted_by_name(map->dso, map->type)) 3097e80711caSMasami Hiramatsu dso__sort_by_name(map->dso, map->type); 3098e80711caSMasami Hiramatsu 30992df58634SMasami Hiramatsu /* Show all (filtered) symbols */ 31002df58634SMasami Hiramatsu setup_pager(); 3101e80711caSMasami Hiramatsu dso__fprintf_symbols_by_name(map->dso, map->type, stdout); 31022df58634SMasami Hiramatsu end: 31032df58634SMasami Hiramatsu if (user) { 310484c2cafaSArnaldo Carvalho de Melo map__put(map); 3105225466f1SSrikar Dronamraju } 31069bae1e8cSNamhyung Kim exit_probe_symbol_maps(); 3107225466f1SSrikar Dronamraju 31082df58634SMasami Hiramatsu return ret; 3109225466f1SSrikar Dronamraju } 3110225466f1SSrikar Dronamraju 3111da15bd9dSWang Nan int copy_to_probe_trace_arg(struct probe_trace_arg *tvar, 3112da15bd9dSWang Nan struct perf_probe_arg *pvar) 3113da15bd9dSWang Nan { 3114da15bd9dSWang Nan tvar->value = strdup(pvar->var); 3115da15bd9dSWang Nan if (tvar->value == NULL) 3116da15bd9dSWang Nan return -ENOMEM; 3117da15bd9dSWang Nan if (pvar->type) { 3118da15bd9dSWang Nan tvar->type = strdup(pvar->type); 3119da15bd9dSWang Nan if (tvar->type == NULL) 3120da15bd9dSWang Nan return -ENOMEM; 3121da15bd9dSWang Nan } 3122da15bd9dSWang Nan if (pvar->name) { 3123da15bd9dSWang Nan tvar->name = strdup(pvar->name); 3124da15bd9dSWang Nan if (tvar->name == NULL) 3125da15bd9dSWang Nan return -ENOMEM; 3126da15bd9dSWang Nan } else 3127da15bd9dSWang Nan tvar->name = NULL; 3128da15bd9dSWang Nan return 0; 3129da15bd9dSWang Nan } 3130