1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 * probe-event.c : perf-probe definition to probe_events format converter
   4 *
   5 * Written by Masami Hiramatsu <mhiramat@redhat.com>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   6 */
   7
   8#include <inttypes.h>
   9#include <sys/utsname.h>
  10#include <sys/types.h>
  11#include <sys/stat.h>
  12#include <fcntl.h>
  13#include <errno.h>
  14#include <stdio.h>
  15#include <unistd.h>
  16#include <stdlib.h>
  17#include <string.h>
  18#include <stdarg.h>
  19#include <limits.h>
  20#include <elf.h>
  21
  22#include "build-id.h"
  23#include "event.h"
  24#include "namespaces.h"
  25#include "strlist.h"
  26#include "strfilter.h"
  27#include "debug.h"
  28#include "dso.h"
  29#include "color.h"
  30#include "map.h"
  31#include "map_groups.h"
  32#include "symbol.h"
  33#include <api/fs/fs.h>
 
  34#include "trace-event.h"	/* For __maybe_unused */
  35#include "probe-event.h"
  36#include "probe-finder.h"
  37#include "probe-file.h"
  38#include "session.h"
  39#include "string2.h"
  40#include "strbuf.h"
  41
  42#include <subcmd/pager.h>
  43#include <linux/ctype.h>
  44#include <linux/zalloc.h>
  45
 
  46#define PERFPROBE_GROUP "probe"
  47
  48bool probe_event_dry_run;	/* Dry run flag */
  49struct probe_conf probe_conf;
  50
  51#define semantic_error(msg ...) pr_err("Semantic error :" msg)
  52
  53int e_snprintf(char *str, size_t size, const char *format, ...)
 
 
 
 
  54{
  55	int ret;
  56	va_list ap;
  57	va_start(ap, format);
  58	ret = vsnprintf(str, size, format, ap);
  59	va_end(ap);
  60	if (ret >= (int)size)
  61		ret = -E2BIG;
  62	return ret;
  63}
  64
 
 
  65static struct machine *host_machine;
  66
  67/* Initialize symbol maps and path of vmlinux/modules */
  68int init_probe_symbol_maps(bool user_only)
  69{
  70	int ret;
  71
  72	symbol_conf.sort_by_name = true;
  73	symbol_conf.allow_aliases = true;
  74	ret = symbol__init(NULL);
  75	if (ret < 0) {
  76		pr_debug("Failed to init symbol map.\n");
  77		goto out;
  78	}
  79
  80	if (host_machine || user_only)	/* already initialized */
  81		return 0;
  82
  83	if (symbol_conf.vmlinux_name)
  84		pr_debug("Use vmlinux: %s\n", symbol_conf.vmlinux_name);
  85
  86	host_machine = machine__new_host();
  87	if (!host_machine) {
  88		pr_debug("machine__new_host() failed.\n");
  89		symbol__exit();
  90		ret = -1;
  91	}
  92out:
  93	if (ret < 0)
  94		pr_warning("Failed to init vmlinux path.\n");
  95	return ret;
  96}
  97
  98void exit_probe_symbol_maps(void)
  99{
 100	machine__delete(host_machine);
 101	host_machine = NULL;
 
 
 102	symbol__exit();
 103}
 104
 
 
 
 
 
 
 
 
 
 
 
 
 105static struct ref_reloc_sym *kernel_get_ref_reloc_sym(void)
 106{
 107	/* kmap->ref_reloc_sym should be set if host_machine is initialized */
 108	struct kmap *kmap;
 109	struct map *map = machine__kernel_map(host_machine);
 110
 111	if (map__load(map) < 0)
 112		return NULL;
 113
 114	kmap = map__kmap(map);
 115	if (!kmap)
 116		return NULL;
 117	return kmap->ref_reloc_sym;
 118}
 119
 120static int kernel_get_symbol_address_by_name(const char *name, u64 *addr,
 121					     bool reloc, bool reladdr)
 122{
 123	struct ref_reloc_sym *reloc_sym;
 124	struct symbol *sym;
 125	struct map *map;
 126
 127	/* ref_reloc_sym is just a label. Need a special fix*/
 128	reloc_sym = kernel_get_ref_reloc_sym();
 129	if (reloc_sym && strcmp(name, reloc_sym->name) == 0)
 130		*addr = (reloc) ? reloc_sym->addr : reloc_sym->unrelocated_addr;
 131	else {
 132		sym = machine__find_kernel_symbol_by_name(host_machine, name, &map);
 133		if (!sym)
 134			return -ENOENT;
 135		*addr = map->unmap_ip(map, sym->start) -
 136			((reloc) ? 0 : map->reloc) -
 137			((reladdr) ? map->start : 0);
 138	}
 139	return 0;
 140}
 141
 142static struct map *kernel_get_module_map(const char *module)
 143{
 144	struct maps *maps = machine__kernel_maps(host_machine);
 145	struct map *pos;
 146
 147	/* A file path -- this is an offline module */
 148	if (module && strchr(module, '/'))
 149		return dso__new_map(module);
 150
 151	if (!module) {
 152		pos = machine__kernel_map(host_machine);
 153		return map__get(pos);
 154	}
 155
 156	for (pos = maps__first(maps); pos; pos = map__next(pos)) {
 157		/* short_name is "[module]" */
 158		if (strncmp(pos->dso->short_name + 1, module,
 159			    pos->dso->short_name_len - 2) == 0 &&
 160		    module[pos->dso->short_name_len - 2] == '\0') {
 161			return map__get(pos);
 162		}
 163	}
 164	return NULL;
 165}
 166
 167struct map *get_target_map(const char *target, struct nsinfo *nsi, bool user)
 168{
 169	/* Init maps of given executable or kernel */
 170	if (user) {
 171		struct map *map;
 172
 173		map = dso__new_map(target);
 174		if (map && map->dso)
 175			map->dso->nsinfo = nsinfo__get(nsi);
 176		return map;
 
 
 
 
 
 
 
 
 
 
 
 
 
 177	} else {
 178		return kernel_get_module_map(target);
 
 
 
 179	}
 
 
 
 
 
 
 
 
 180}
 181
 182static int convert_exec_to_group(const char *exec, char **result)
 183{
 184	char *ptr1, *ptr2, *exec_copy;
 185	char buf[64];
 186	int ret;
 187
 188	exec_copy = strdup(exec);
 189	if (!exec_copy)
 190		return -ENOMEM;
 191
 192	ptr1 = basename(exec_copy);
 193	if (!ptr1) {
 194		ret = -EINVAL;
 195		goto out;
 196	}
 197
 198	for (ptr2 = ptr1; *ptr2 != '\0'; ptr2++) {
 199		if (!isalnum(*ptr2) && *ptr2 != '_') {
 200			*ptr2 = '\0';
 201			break;
 202		}
 203	}
 204
 205	ret = e_snprintf(buf, 64, "%s_%s", PERFPROBE_GROUP, ptr1);
 206	if (ret < 0)
 207		goto out;
 208
 209	*result = strdup(buf);
 210	ret = *result ? 0 : -ENOMEM;
 211
 212out:
 213	free(exec_copy);
 214	return ret;
 215}
 216
 217static void clear_perf_probe_point(struct perf_probe_point *pp)
 218{
 219	zfree(&pp->file);
 220	zfree(&pp->function);
 221	zfree(&pp->lazy_line);
 222}
 223
 224static void clear_probe_trace_events(struct probe_trace_event *tevs, int ntevs)
 225{
 226	int i;
 227
 228	for (i = 0; i < ntevs; i++)
 229		clear_probe_trace_event(tevs + i);
 230}
 231
 232static bool kprobe_blacklist__listed(unsigned long address);
 233static bool kprobe_warn_out_range(const char *symbol, unsigned long address)
 234{
 235	u64 etext_addr = 0;
 236	int ret;
 237
 238	/* Get the address of _etext for checking non-probable text symbol */
 239	ret = kernel_get_symbol_address_by_name("_etext", &etext_addr,
 240						false, false);
 241
 242	if (ret == 0 && etext_addr < address)
 243		pr_warning("%s is out of .text, skip it.\n", symbol);
 244	else if (kprobe_blacklist__listed(address))
 245		pr_warning("%s is blacklisted function, skip it.\n", symbol);
 246	else
 247		return false;
 248
 249	return true;
 250}
 251
 252/*
 253 * @module can be module name of module file path. In case of path,
 254 * inspect elf and find out what is actual module name.
 255 * Caller has to free mod_name after using it.
 256 */
 257static char *find_module_name(const char *module)
 258{
 259	int fd;
 260	Elf *elf;
 261	GElf_Ehdr ehdr;
 262	GElf_Shdr shdr;
 263	Elf_Data *data;
 264	Elf_Scn *sec;
 265	char *mod_name = NULL;
 266	int name_offset;
 267
 268	fd = open(module, O_RDONLY);
 269	if (fd < 0)
 270		return NULL;
 271
 272	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 273	if (elf == NULL)
 274		goto elf_err;
 275
 276	if (gelf_getehdr(elf, &ehdr) == NULL)
 277		goto ret_err;
 278
 279	sec = elf_section_by_name(elf, &ehdr, &shdr,
 280			".gnu.linkonce.this_module", NULL);
 281	if (!sec)
 282		goto ret_err;
 283
 284	data = elf_getdata(sec, NULL);
 285	if (!data || !data->d_buf)
 286		goto ret_err;
 287
 288	/*
 289	 * NOTE:
 290	 * '.gnu.linkonce.this_module' section of kernel module elf directly
 291	 * maps to 'struct module' from linux/module.h. This section contains
 292	 * actual module name which will be used by kernel after loading it.
 293	 * But, we cannot use 'struct module' here since linux/module.h is not
 294	 * exposed to user-space. Offset of 'name' has remained same from long
 295	 * time, so hardcoding it here.
 296	 */
 297	if (ehdr.e_ident[EI_CLASS] == ELFCLASS32)
 298		name_offset = 12;
 299	else	/* expect ELFCLASS64 by default */
 300		name_offset = 24;
 301
 302	mod_name = strdup((char *)data->d_buf + name_offset);
 303
 304ret_err:
 305	elf_end(elf);
 306elf_err:
 307	close(fd);
 308	return mod_name;
 309}
 310
 311#ifdef HAVE_DWARF_SUPPORT
 312
 313static int kernel_get_module_dso(const char *module, struct dso **pdso)
 314{
 315	struct dso *dso;
 316	struct map *map;
 317	const char *vmlinux_name;
 318	int ret = 0;
 319
 320	if (module) {
 321		char module_name[128];
 322
 323		snprintf(module_name, sizeof(module_name), "[%s]", module);
 324		map = map_groups__find_by_name(&host_machine->kmaps, module_name);
 325		if (map) {
 326			dso = map->dso;
 327			goto found;
 328		}
 329		pr_debug("Failed to find module %s.\n", module);
 330		return -ENOENT;
 331	}
 332
 333	map = machine__kernel_map(host_machine);
 334	dso = map->dso;
 335
 336	vmlinux_name = symbol_conf.vmlinux_name;
 337	dso->load_errno = 0;
 338	if (vmlinux_name)
 339		ret = dso__load_vmlinux(dso, map, vmlinux_name, false);
 340	else
 341		ret = dso__load_vmlinux_path(dso, map);
 342found:
 343	*pdso = dso;
 344	return ret;
 345}
 346
 347/*
 348 * Some binaries like glibc have special symbols which are on the symbol
 349 * table, but not in the debuginfo. If we can find the address of the
 350 * symbol from map, we can translate the address back to the probe point.
 351 */
 352static int find_alternative_probe_point(struct debuginfo *dinfo,
 353					struct perf_probe_point *pp,
 354					struct perf_probe_point *result,
 355					const char *target, struct nsinfo *nsi,
 356					bool uprobes)
 357{
 358	struct map *map = NULL;
 359	struct symbol *sym;
 360	u64 address = 0;
 361	int ret = -ENOENT;
 362
 363	/* This can work only for function-name based one */
 364	if (!pp->function || pp->file)
 365		return -ENOTSUP;
 366
 367	map = get_target_map(target, nsi, uprobes);
 368	if (!map)
 369		return -EINVAL;
 370
 371	/* Find the address of given function */
 372	map__for_each_symbol_by_name(map, pp->function, sym) {
 373		if (uprobes)
 374			address = sym->start;
 375		else
 376			address = map->unmap_ip(map, sym->start) - map->reloc;
 377		break;
 378	}
 379	if (!address) {
 380		ret = -ENOENT;
 381		goto out;
 382	}
 383	pr_debug("Symbol %s address found : %" PRIx64 "\n",
 384			pp->function, address);
 385
 386	ret = debuginfo__find_probe_point(dinfo, (unsigned long)address,
 387					  result);
 388	if (ret <= 0)
 389		ret = (!ret) ? -ENOENT : ret;
 390	else {
 391		result->offset += pp->offset;
 392		result->line += pp->line;
 393		result->retprobe = pp->retprobe;
 394		ret = 0;
 395	}
 396
 397out:
 398	map__put(map);
 399	return ret;
 400
 401}
 402
 403static int get_alternative_probe_event(struct debuginfo *dinfo,
 404				       struct perf_probe_event *pev,
 405				       struct perf_probe_point *tmp)
 406{
 407	int ret;
 408
 409	memcpy(tmp, &pev->point, sizeof(*tmp));
 410	memset(&pev->point, 0, sizeof(pev->point));
 411	ret = find_alternative_probe_point(dinfo, tmp, &pev->point, pev->target,
 412					   pev->nsi, pev->uprobes);
 413	if (ret < 0)
 414		memcpy(&pev->point, tmp, sizeof(*tmp));
 415
 416	return ret;
 417}
 418
 419static int get_alternative_line_range(struct debuginfo *dinfo,
 420				      struct line_range *lr,
 421				      const char *target, bool user)
 422{
 423	struct perf_probe_point pp = { .function = lr->function,
 424				       .file = lr->file,
 425				       .line = lr->start };
 426	struct perf_probe_point result;
 427	int ret, len = 0;
 428
 429	memset(&result, 0, sizeof(result));
 430
 431	if (lr->end != INT_MAX)
 432		len = lr->end - lr->start;
 433	ret = find_alternative_probe_point(dinfo, &pp, &result,
 434					   target, NULL, user);
 435	if (!ret) {
 436		lr->function = result.function;
 437		lr->file = result.file;
 438		lr->start = result.line;
 439		if (lr->end != INT_MAX)
 440			lr->end = lr->start + len;
 441		clear_perf_probe_point(&pp);
 442	}
 443	return ret;
 444}
 445
 446/* Open new debuginfo of given module */
 447static struct debuginfo *open_debuginfo(const char *module, struct nsinfo *nsi,
 448					bool silent)
 449{
 450	const char *path = module;
 451	char reason[STRERR_BUFSIZE];
 452	struct debuginfo *ret = NULL;
 453	struct dso *dso = NULL;
 454	struct nscookie nsc;
 455	int err;
 456
 457	if (!module || !strchr(module, '/')) {
 458		err = kernel_get_module_dso(module, &dso);
 459		if (err < 0) {
 460			if (!dso || dso->load_errno == 0) {
 461				if (!str_error_r(-err, reason, STRERR_BUFSIZE))
 462					strcpy(reason, "(unknown)");
 463			} else
 464				dso__strerror_load(dso, reason, STRERR_BUFSIZE);
 465			if (!silent) {
 466				if (module)
 467					pr_err("Module %s is not loaded, please specify its full path name.\n", module);
 468				else
 469					pr_err("Failed to find the path for the kernel: %s\n", reason);
 470			}
 471			return NULL;
 472		}
 473		path = dso->long_name;
 474	}
 475	nsinfo__mountns_enter(nsi, &nsc);
 476	ret = debuginfo__new(path);
 477	if (!ret && !silent) {
 478		pr_warning("The %s file has no debug information.\n", path);
 479		if (!module || !strtailcmp(path, ".ko"))
 480			pr_warning("Rebuild with CONFIG_DEBUG_INFO=y, ");
 481		else
 482			pr_warning("Rebuild with -g, ");
 483		pr_warning("or install an appropriate debuginfo package.\n");
 484	}
 485	nsinfo__mountns_exit(&nsc);
 486	return ret;
 487}
 488
 489/* For caching the last debuginfo */
 490static struct debuginfo *debuginfo_cache;
 491static char *debuginfo_cache_path;
 492
 493static struct debuginfo *debuginfo_cache__open(const char *module, bool silent)
 494{
 495	const char *path = module;
 496
 497	/* If the module is NULL, it should be the kernel. */
 498	if (!module)
 499		path = "kernel";
 500
 501	if (debuginfo_cache_path && !strcmp(debuginfo_cache_path, path))
 502		goto out;
 503
 504	/* Copy module path */
 505	free(debuginfo_cache_path);
 506	debuginfo_cache_path = strdup(path);
 507	if (!debuginfo_cache_path) {
 508		debuginfo__delete(debuginfo_cache);
 509		debuginfo_cache = NULL;
 510		goto out;
 511	}
 512
 513	debuginfo_cache = open_debuginfo(module, NULL, silent);
 514	if (!debuginfo_cache)
 515		zfree(&debuginfo_cache_path);
 516out:
 517	return debuginfo_cache;
 518}
 519
 520static void debuginfo_cache__exit(void)
 521{
 522	debuginfo__delete(debuginfo_cache);
 523	debuginfo_cache = NULL;
 524	zfree(&debuginfo_cache_path);
 525}
 526
 527
 528static int get_text_start_address(const char *exec, unsigned long *address,
 529				  struct nsinfo *nsi)
 530{
 531	Elf *elf;
 532	GElf_Ehdr ehdr;
 533	GElf_Shdr shdr;
 534	int fd, ret = -ENOENT;
 535	struct nscookie nsc;
 536
 537	nsinfo__mountns_enter(nsi, &nsc);
 538	fd = open(exec, O_RDONLY);
 539	nsinfo__mountns_exit(&nsc);
 540	if (fd < 0)
 541		return -errno;
 542
 543	elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
 544	if (elf == NULL) {
 545		ret = -EINVAL;
 546		goto out_close;
 547	}
 548
 549	if (gelf_getehdr(elf, &ehdr) == NULL)
 550		goto out;
 551
 552	if (!elf_section_by_name(elf, &ehdr, &shdr, ".text", NULL))
 553		goto out;
 554
 555	*address = shdr.sh_addr - shdr.sh_offset;
 556	ret = 0;
 557out:
 558	elf_end(elf);
 559out_close:
 560	close(fd);
 561
 562	return ret;
 563}
 564
 565/*
 566 * Convert trace point to probe point with debuginfo
 567 */
 568static int find_perf_probe_point_from_dwarf(struct probe_trace_point *tp,
 569					    struct perf_probe_point *pp,
 570					    bool is_kprobe)
 571{
 572	struct debuginfo *dinfo = NULL;
 573	unsigned long stext = 0;
 574	u64 addr = tp->address;
 575	int ret = -ENOENT;
 576
 577	/* convert the address to dwarf address */
 578	if (!is_kprobe) {
 579		if (!addr) {
 580			ret = -EINVAL;
 581			goto error;
 582		}
 583		ret = get_text_start_address(tp->module, &stext, NULL);
 584		if (ret < 0)
 585			goto error;
 586		addr += stext;
 587	} else if (tp->symbol) {
 588		/* If the module is given, this returns relative address */
 589		ret = kernel_get_symbol_address_by_name(tp->symbol, &addr,
 590							false, !!tp->module);
 591		if (ret != 0)
 592			goto error;
 593		addr += tp->offset;
 594	}
 595
 596	pr_debug("try to find information at %" PRIx64 " in %s\n", addr,
 597		 tp->module ? : "kernel");
 598
 599	dinfo = debuginfo_cache__open(tp->module, verbose <= 0);
 600	if (dinfo)
 601		ret = debuginfo__find_probe_point(dinfo,
 602						 (unsigned long)addr, pp);
 603	else
 
 
 604		ret = -ENOENT;
 
 605
 606	if (ret > 0) {
 607		pp->retprobe = tp->retprobe;
 608		return 0;
 609	}
 610error:
 611	pr_debug("Failed to find corresponding probes from debuginfo.\n");
 612	return ret ? : -ENOENT;
 613}
 614
 615/* Adjust symbol name and address */
 616static int post_process_probe_trace_point(struct probe_trace_point *tp,
 617					   struct map *map, unsigned long offs)
 618{
 619	struct symbol *sym;
 620	u64 addr = tp->address - offs;
 621
 622	sym = map__find_symbol(map, addr);
 623	if (!sym)
 624		return -ENOENT;
 625
 626	if (strcmp(sym->name, tp->symbol)) {
 627		/* If we have no realname, use symbol for it */
 628		if (!tp->realname)
 629			tp->realname = tp->symbol;
 630		else
 631			free(tp->symbol);
 632		tp->symbol = strdup(sym->name);
 633		if (!tp->symbol)
 634			return -ENOMEM;
 635	}
 636	tp->offset = addr - sym->start;
 637	tp->address -= offs;
 638
 639	return 0;
 640}
 641
 642/*
 643 * Rename DWARF symbols to ELF symbols -- gcc sometimes optimizes functions
 644 * and generate new symbols with suffixes such as .constprop.N or .isra.N
 645 * etc. Since those symbols are not recorded in DWARF, we have to find
 646 * correct generated symbols from offline ELF binary.
 647 * For online kernel or uprobes we don't need this because those are
 648 * rebased on _text, or already a section relative address.
 649 */
 650static int
 651post_process_offline_probe_trace_events(struct probe_trace_event *tevs,
 652					int ntevs, const char *pathname)
 653{
 654	struct map *map;
 655	unsigned long stext = 0;
 656	int i, ret = 0;
 657
 658	/* Prepare a map for offline binary */
 659	map = dso__new_map(pathname);
 660	if (!map || get_text_start_address(pathname, &stext, NULL) < 0) {
 661		pr_warning("Failed to get ELF symbols for %s\n", pathname);
 662		return -EINVAL;
 663	}
 664
 665	for (i = 0; i < ntevs; i++) {
 666		ret = post_process_probe_trace_point(&tevs[i].point,
 667						     map, stext);
 668		if (ret < 0)
 669			break;
 670	}
 671	map__put(map);
 672
 673	return ret;
 674}
 675
 676static int add_exec_to_probe_trace_events(struct probe_trace_event *tevs,
 677					  int ntevs, const char *exec,
 678					  struct nsinfo *nsi)
 679{
 680	int i, ret = 0;
 681	unsigned long stext = 0;
 682
 683	if (!exec)
 684		return 0;
 685
 686	ret = get_text_start_address(exec, &stext, nsi);
 687	if (ret < 0)
 688		return ret;
 689
 690	for (i = 0; i < ntevs && ret >= 0; i++) {
 691		/* point.address is the address of point.symbol + point.offset */
 692		tevs[i].point.address -= stext;
 693		tevs[i].point.module = strdup(exec);
 694		if (!tevs[i].point.module) {
 695			ret = -ENOMEM;
 696			break;
 697		}
 698		tevs[i].uprobes = true;
 699	}
 700
 701	return ret;
 702}
 703
 704static int
 705post_process_module_probe_trace_events(struct probe_trace_event *tevs,
 706				       int ntevs, const char *module,
 707				       struct debuginfo *dinfo)
 708{
 709	Dwarf_Addr text_offs = 0;
 710	int i, ret = 0;
 711	char *mod_name = NULL;
 712	struct map *map;
 713
 714	if (!module)
 715		return 0;
 716
 717	map = get_target_map(module, NULL, false);
 718	if (!map || debuginfo__get_text_offset(dinfo, &text_offs, true) < 0) {
 719		pr_warning("Failed to get ELF symbols for %s\n", module);
 720		return -EINVAL;
 
 
 
 
 
 
 721	}
 722
 723	mod_name = find_module_name(module);
 724	for (i = 0; i < ntevs; i++) {
 725		ret = post_process_probe_trace_point(&tevs[i].point,
 726						map, (unsigned long)text_offs);
 727		if (ret < 0)
 728			break;
 729		tevs[i].point.module =
 730			strdup(mod_name ? mod_name : module);
 731		if (!tevs[i].point.module) {
 732			ret = -ENOMEM;
 733			break;
 734		}
 735	}
 736
 737	free(mod_name);
 738	map__put(map);
 739
 740	return ret;
 741}
 742
 743static int
 744post_process_kernel_probe_trace_events(struct probe_trace_event *tevs,
 745				       int ntevs)
 
 746{
 747	struct ref_reloc_sym *reloc_sym;
 748	char *tmp;
 749	int i, skipped = 0;
 
 
 
 750
 751	/* Skip post process if the target is an offline kernel */
 752	if (symbol_conf.ignore_vmlinux_buildid)
 753		return post_process_offline_probe_trace_events(tevs, ntevs,
 754						symbol_conf.vmlinux_name);
 755
 756	reloc_sym = kernel_get_ref_reloc_sym();
 757	if (!reloc_sym) {
 758		pr_warning("Relocated base symbol is not found!\n");
 759		return -EINVAL;
 760	}
 761
 762	for (i = 0; i < ntevs; i++) {
 763		if (!tevs[i].point.address)
 764			continue;
 765		if (tevs[i].point.retprobe && !kretprobe_offset_is_supported())
 766			continue;
 767		/* If we found a wrong one, mark it by NULL symbol */
 768		if (kprobe_warn_out_range(tevs[i].point.symbol,
 769					  tevs[i].point.address)) {
 770			tmp = NULL;
 771			skipped++;
 772		} else {
 773			tmp = strdup(reloc_sym->name);
 774			if (!tmp)
 775				return -ENOMEM;
 776		}
 777		/* If we have no realname, use symbol for it */
 778		if (!tevs[i].point.realname)
 779			tevs[i].point.realname = tevs[i].point.symbol;
 780		else
 781			free(tevs[i].point.symbol);
 782		tevs[i].point.symbol = tmp;
 783		tevs[i].point.offset = tevs[i].point.address -
 784				       reloc_sym->unrelocated_addr;
 
 785	}
 786	return skipped;
 787}
 788
 789void __weak
 790arch__post_process_probe_trace_events(struct perf_probe_event *pev __maybe_unused,
 791				      int ntevs __maybe_unused)
 792{
 793}
 794
 795/* Post processing the probe events */
 796static int post_process_probe_trace_events(struct perf_probe_event *pev,
 797					   struct probe_trace_event *tevs,
 798					   int ntevs, const char *module,
 799					   bool uprobe, struct debuginfo *dinfo)
 800{
 801	int ret;
 802
 803	if (uprobe)
 804		ret = add_exec_to_probe_trace_events(tevs, ntevs, module,
 805						     pev->nsi);
 806	else if (module)
 807		/* Currently ref_reloc_sym based probe is not for drivers */
 808		ret = post_process_module_probe_trace_events(tevs, ntevs,
 809							     module, dinfo);
 810	else
 811		ret = post_process_kernel_probe_trace_events(tevs, ntevs);
 812
 813	if (ret >= 0)
 814		arch__post_process_probe_trace_events(pev, ntevs);
 815
 816	return ret;
 817}
 818
 819/* Try to find perf_probe_event with debuginfo */
 820static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
 821					  struct probe_trace_event **tevs)
 
 822{
 823	bool need_dwarf = perf_probe_event_need_dwarf(pev);
 824	struct perf_probe_point tmp;
 825	struct debuginfo *dinfo;
 826	int ntevs, ret = 0;
 827
 828	dinfo = open_debuginfo(pev->target, pev->nsi, !need_dwarf);
 
 829	if (!dinfo) {
 830		if (need_dwarf)
 
 831			return -ENOENT;
 
 832		pr_debug("Could not open debuginfo. Try to use symbols.\n");
 833		return 0;
 834	}
 835
 836	pr_debug("Try to find probe point from debuginfo.\n");
 837	/* Searching trace events corresponding to a probe event */
 838	ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
 839
 840	if (ntevs == 0)	{  /* Not found, retry with an alternative */
 841		ret = get_alternative_probe_event(dinfo, pev, &tmp);
 842		if (!ret) {
 843			ntevs = debuginfo__find_trace_events(dinfo, pev, tevs);
 844			/*
 845			 * Write back to the original probe_event for
 846			 * setting appropriate (user given) event name
 847			 */
 848			clear_perf_probe_point(&pev->point);
 849			memcpy(&pev->point, &tmp, sizeof(tmp));
 850		}
 851	}
 852
 853	if (ntevs > 0) {	/* Succeeded to find trace events */
 854		pr_debug("Found %d probe_trace_events.\n", ntevs);
 855		ret = post_process_probe_trace_events(pev, *tevs, ntevs,
 856					pev->target, pev->uprobes, dinfo);
 857		if (ret < 0 || ret == ntevs) {
 858			pr_debug("Post processing failed or all events are skipped. (%d)\n", ret);
 859			clear_probe_trace_events(*tevs, ntevs);
 860			zfree(tevs);
 861			ntevs = 0;
 862		}
 
 863	}
 864
 865	debuginfo__delete(dinfo);
 866
 867	if (ntevs == 0)	{	/* No error but failed to find probe point. */
 868		pr_warning("Probe point '%s' not found.\n",
 869			   synthesize_perf_probe_point(&pev->point));
 870		return -ENOENT;
 871	} else if (ntevs < 0) {
 872		/* Error path : ntevs < 0 */
 873		pr_debug("An error occurred in debuginfo analysis (%d).\n", ntevs);
 874		if (ntevs == -EBADF)
 875			pr_warning("Warning: No dwarf info found in the vmlinux - "
 876				"please rebuild kernel with CONFIG_DEBUG_INFO=y.\n");
 877		if (!need_dwarf) {
 878			pr_debug("Trying to use symbols.\n");
 879			return 0;
 880		}
 881	}
 882	return ntevs;
 883}
 884
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 885#define LINEBUF_SIZE 256
 886#define NR_ADDITIONAL_LINES 2
 887
 888static int __show_one_line(FILE *fp, int l, bool skip, bool show_num)
 889{
 890	char buf[LINEBUF_SIZE], sbuf[STRERR_BUFSIZE];
 891	const char *color = show_num ? "" : PERF_COLOR_BLUE;
 892	const char *prefix = NULL;
 893
 894	do {
 895		if (fgets(buf, LINEBUF_SIZE, fp) == NULL)
 896			goto error;
 897		if (skip)
 898			continue;
 899		if (!prefix) {
 900			prefix = show_num ? "%7d  " : "         ";
 901			color_fprintf(stdout, color, prefix, l);
 902		}
 903		color_fprintf(stdout, color, "%s", buf);
 904
 905	} while (strchr(buf, '\n') == NULL);
 906
 907	return 1;
 908error:
 909	if (ferror(fp)) {
 910		pr_warning("File read error: %s\n",
 911			   str_error_r(errno, sbuf, sizeof(sbuf)));
 912		return -1;
 913	}
 914	return 0;
 915}
 916
 917static int _show_one_line(FILE *fp, int l, bool skip, bool show_num)
 918{
 919	int rv = __show_one_line(fp, l, skip, show_num);
 920	if (rv == 0) {
 921		pr_warning("Source file is shorter than expected.\n");
 922		rv = -1;
 923	}
 924	return rv;
 925}
 926
 927#define show_one_line_with_num(f,l)	_show_one_line(f,l,false,true)
 928#define show_one_line(f,l)		_show_one_line(f,l,false,false)
 929#define skip_one_line(f,l)		_show_one_line(f,l,true,false)
 930#define show_one_line_or_eof(f,l)	__show_one_line(f,l,false,false)
 931
 932/*
 933 * Show line-range always requires debuginfo to find source file and
 934 * line number.
 935 */
 936static int __show_line_range(struct line_range *lr, const char *module,
 937			     bool user)
 938{
 939	int l = 1;
 940	struct int_node *ln;
 941	struct debuginfo *dinfo;
 942	FILE *fp;
 943	int ret;
 944	char *tmp;
 945	char sbuf[STRERR_BUFSIZE];
 946
 947	/* Search a line range */
 948	dinfo = open_debuginfo(module, NULL, false);
 949	if (!dinfo)
 
 950		return -ENOENT;
 
 951
 952	ret = debuginfo__find_line_range(dinfo, lr);
 953	if (!ret) {	/* Not found, retry with an alternative */
 954		ret = get_alternative_line_range(dinfo, lr, module, user);
 955		if (!ret)
 956			ret = debuginfo__find_line_range(dinfo, lr);
 957	}
 958	debuginfo__delete(dinfo);
 959	if (ret == 0 || ret == -ENOENT) {
 960		pr_warning("Specified source line is not found.\n");
 961		return -ENOENT;
 962	} else if (ret < 0) {
 963		pr_warning("Debuginfo analysis failed.\n");
 964		return ret;
 965	}
 966
 967	/* Convert source file path */
 968	tmp = lr->path;
 969	ret = get_real_path(tmp, lr->comp_dir, &lr->path);
 970
 971	/* Free old path when new path is assigned */
 972	if (tmp != lr->path)
 973		free(tmp);
 974
 975	if (ret < 0) {
 976		pr_warning("Failed to find source file path.\n");
 977		return ret;
 978	}
 979
 980	setup_pager();
 981
 982	if (lr->function)
 983		fprintf(stdout, "<%s@%s:%d>\n", lr->function, lr->path,
 984			lr->start - lr->offset);
 985	else
 986		fprintf(stdout, "<%s:%d>\n", lr->path, lr->start);
 987
 988	fp = fopen(lr->path, "r");
 989	if (fp == NULL) {
 990		pr_warning("Failed to open %s: %s\n", lr->path,
 991			   str_error_r(errno, sbuf, sizeof(sbuf)));
 992		return -errno;
 993	}
 994	/* Skip to starting line number */
 995	while (l < lr->start) {
 996		ret = skip_one_line(fp, l++);
 997		if (ret < 0)
 998			goto end;
 999	}
1000
1001	intlist__for_each_entry(ln, lr->line_list) {
1002		for (; ln->i > l; l++) {
1003			ret = show_one_line(fp, l - lr->offset);
1004			if (ret < 0)
1005				goto end;
1006		}
1007		ret = show_one_line_with_num(fp, l++ - lr->offset);
1008		if (ret < 0)
1009			goto end;
1010	}
1011
1012	if (lr->end == INT_MAX)
1013		lr->end = l + NR_ADDITIONAL_LINES;
1014	while (l <= lr->end) {
1015		ret = show_one_line_or_eof(fp, l++ - lr->offset);
1016		if (ret <= 0)
1017			break;
1018	}
1019end:
1020	fclose(fp);
1021	return ret;
1022}
1023
1024int show_line_range(struct line_range *lr, const char *module,
1025		    struct nsinfo *nsi, bool user)
1026{
1027	int ret;
1028	struct nscookie nsc;
1029
1030	ret = init_probe_symbol_maps(user);
1031	if (ret < 0)
1032		return ret;
1033	nsinfo__mountns_enter(nsi, &nsc);
1034	ret = __show_line_range(lr, module, user);
1035	nsinfo__mountns_exit(&nsc);
1036	exit_probe_symbol_maps();
1037
1038	return ret;
1039}
1040
1041static int show_available_vars_at(struct debuginfo *dinfo,
1042				  struct perf_probe_event *pev,
1043				  struct strfilter *_filter)
 
1044{
1045	char *buf;
1046	int ret, i, nvars;
1047	struct str_node *node;
1048	struct variable_list *vls = NULL, *vl;
1049	struct perf_probe_point tmp;
1050	const char *var;
1051
1052	buf = synthesize_perf_probe_point(&pev->point);
1053	if (!buf)
1054		return -EINVAL;
1055	pr_debug("Searching variables at %s\n", buf);
1056
1057	ret = debuginfo__find_available_vars_at(dinfo, pev, &vls);
1058	if (!ret) {  /* Not found, retry with an alternative */
1059		ret = get_alternative_probe_event(dinfo, pev, &tmp);
1060		if (!ret) {
1061			ret = debuginfo__find_available_vars_at(dinfo, pev,
1062								&vls);
1063			/* Release the old probe_point */
1064			clear_perf_probe_point(&tmp);
1065		}
1066	}
1067	if (ret <= 0) {
1068		if (ret == 0 || ret == -ENOENT) {
1069			pr_err("Failed to find the address of %s\n", buf);
1070			ret = -ENOENT;
1071		} else
1072			pr_warning("Debuginfo analysis failed.\n");
1073		goto end;
1074	}
1075
1076	/* Some variables are found */
1077	fprintf(stdout, "Available variables at %s\n", buf);
1078	for (i = 0; i < ret; i++) {
1079		vl = &vls[i];
1080		/*
1081		 * A probe point might be converted to
1082		 * several trace points.
1083		 */
1084		fprintf(stdout, "\t@<%s+%lu>\n", vl->point.symbol,
1085			vl->point.offset);
1086		zfree(&vl->point.symbol);
1087		nvars = 0;
1088		if (vl->vars) {
1089			strlist__for_each_entry(node, vl->vars) {
1090				var = strchr(node->s, '\t') + 1;
1091				if (strfilter__compare(_filter, var)) {
1092					fprintf(stdout, "\t\t%s\n", node->s);
1093					nvars++;
1094				}
1095			}
1096			strlist__delete(vl->vars);
1097		}
1098		if (nvars == 0)
1099			fprintf(stdout, "\t\t(No matched variables)\n");
1100	}
1101	free(vls);
1102end:
1103	free(buf);
1104	return ret;
1105}
1106
1107/* Show available variables on given probe point */
1108int show_available_vars(struct perf_probe_event *pevs, int npevs,
1109			struct strfilter *_filter)
 
1110{
1111	int i, ret = 0;
1112	struct debuginfo *dinfo;
1113
1114	ret = init_probe_symbol_maps(pevs->uprobes);
1115	if (ret < 0)
1116		return ret;
1117
1118	dinfo = open_debuginfo(pevs->target, pevs->nsi, false);
1119	if (!dinfo) {
 
1120		ret = -ENOENT;
1121		goto out;
1122	}
1123
1124	setup_pager();
1125
1126	for (i = 0; i < npevs && ret >= 0; i++)
1127		ret = show_available_vars_at(dinfo, &pevs[i], _filter);
 
1128
1129	debuginfo__delete(dinfo);
1130out:
1131	exit_probe_symbol_maps();
1132	return ret;
1133}
1134
1135#else	/* !HAVE_DWARF_SUPPORT */
1136
1137static void debuginfo_cache__exit(void)
1138{
1139}
1140
1141static int
1142find_perf_probe_point_from_dwarf(struct probe_trace_point *tp __maybe_unused,
1143				 struct perf_probe_point *pp __maybe_unused,
1144				 bool is_kprobe __maybe_unused)
1145{
1146	return -ENOSYS;
1147}
1148
1149static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
1150				struct probe_trace_event **tevs __maybe_unused)
 
 
1151{
1152	if (perf_probe_event_need_dwarf(pev)) {
1153		pr_warning("Debuginfo-analysis is not supported.\n");
1154		return -ENOSYS;
1155	}
1156
1157	return 0;
1158}
1159
1160int show_line_range(struct line_range *lr __maybe_unused,
1161		    const char *module __maybe_unused,
1162		    struct nsinfo *nsi __maybe_unused,
1163		    bool user __maybe_unused)
1164{
1165	pr_warning("Debuginfo-analysis is not supported.\n");
1166	return -ENOSYS;
1167}
1168
1169int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
1170			int npevs __maybe_unused,
1171			struct strfilter *filter __maybe_unused)
 
 
1172{
1173	pr_warning("Debuginfo-analysis is not supported.\n");
1174	return -ENOSYS;
1175}
1176#endif
1177
1178void line_range__clear(struct line_range *lr)
1179{
1180	zfree(&lr->function);
1181	zfree(&lr->file);
1182	zfree(&lr->path);
1183	zfree(&lr->comp_dir);
1184	intlist__delete(lr->line_list);
 
1185}
1186
1187int line_range__init(struct line_range *lr)
1188{
1189	memset(lr, 0, sizeof(*lr));
1190	lr->line_list = intlist__new(NULL);
1191	if (!lr->line_list)
1192		return -ENOMEM;
1193	else
1194		return 0;
1195}
1196
1197static int parse_line_num(char **ptr, int *val, const char *what)
1198{
1199	const char *start = *ptr;
1200
1201	errno = 0;
1202	*val = strtol(*ptr, ptr, 0);
1203	if (errno || *ptr == start) {
1204		semantic_error("'%s' is not a valid number.\n", what);
1205		return -EINVAL;
1206	}
1207	return 0;
1208}
1209
1210/* Check the name is good for event, group or function */
1211static bool is_c_func_name(const char *name)
1212{
1213	if (!isalpha(*name) && *name != '_')
1214		return false;
1215	while (*++name != '\0') {
1216		if (!isalpha(*name) && !isdigit(*name) && *name != '_')
1217			return false;
1218	}
1219	return true;
1220}
1221
1222/*
1223 * Stuff 'lr' according to the line range described by 'arg'.
1224 * The line range syntax is described by:
1225 *
1226 *         SRC[:SLN[+NUM|-ELN]]
1227 *         FNC[@SRC][:SLN[+NUM|-ELN]]
1228 */
1229int parse_line_range_desc(const char *arg, struct line_range *lr)
1230{
1231	char *range, *file, *name = strdup(arg);
1232	int err;
1233
1234	if (!name)
1235		return -ENOMEM;
1236
1237	lr->start = 0;
1238	lr->end = INT_MAX;
1239
1240	range = strchr(name, ':');
1241	if (range) {
1242		*range++ = '\0';
1243
1244		err = parse_line_num(&range, &lr->start, "start line");
1245		if (err)
1246			goto err;
1247
1248		if (*range == '+' || *range == '-') {
1249			const char c = *range++;
1250
1251			err = parse_line_num(&range, &lr->end, "end line");
1252			if (err)
1253				goto err;
1254
1255			if (c == '+') {
1256				lr->end += lr->start;
1257				/*
1258				 * Adjust the number of lines here.
1259				 * If the number of lines == 1, the
1260				 * the end of line should be equal to
1261				 * the start of line.
1262				 */
1263				lr->end--;
1264			}
1265		}
1266
1267		pr_debug("Line range is %d to %d\n", lr->start, lr->end);
1268
1269		err = -EINVAL;
1270		if (lr->start > lr->end) {
1271			semantic_error("Start line must be smaller"
1272				       " than end line.\n");
1273			goto err;
1274		}
1275		if (*range != '\0') {
1276			semantic_error("Tailing with invalid str '%s'.\n", range);
1277			goto err;
1278		}
1279	}
1280
1281	file = strchr(name, '@');
1282	if (file) {
1283		*file = '\0';
1284		lr->file = strdup(++file);
1285		if (lr->file == NULL) {
1286			err = -ENOMEM;
1287			goto err;
1288		}
1289		lr->function = name;
1290	} else if (strchr(name, '/') || strchr(name, '.'))
1291		lr->file = name;
1292	else if (is_c_func_name(name))/* We reuse it for checking funcname */
1293		lr->function = name;
1294	else {	/* Invalid name */
1295		semantic_error("'%s' is not a valid function name.\n", name);
1296		err = -EINVAL;
1297		goto err;
1298	}
1299
1300	return 0;
1301err:
1302	free(name);
1303	return err;
1304}
1305
1306static int parse_perf_probe_event_name(char **arg, struct perf_probe_event *pev)
 
1307{
1308	char *ptr;
1309
1310	ptr = strpbrk_esc(*arg, ":");
1311	if (ptr) {
1312		*ptr = '\0';
1313		if (!pev->sdt && !is_c_func_name(*arg))
1314			goto ng_name;
1315		pev->group = strdup_esc(*arg);
1316		if (!pev->group)
1317			return -ENOMEM;
1318		*arg = ptr + 1;
1319	} else
1320		pev->group = NULL;
1321
1322	pev->event = strdup_esc(*arg);
1323	if (pev->event == NULL)
1324		return -ENOMEM;
1325
1326	if (!pev->sdt && !is_c_func_name(pev->event)) {
1327		zfree(&pev->event);
1328ng_name:
1329		zfree(&pev->group);
1330		semantic_error("%s is bad for event name -it must "
1331			       "follow C symbol-naming rule.\n", *arg);
1332		return -EINVAL;
1333	}
1334	return 0;
1335}
1336
1337/* Parse probepoint definition. */
1338static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
1339{
1340	struct perf_probe_point *pp = &pev->point;
1341	char *ptr, *tmp;
1342	char c, nc = 0;
1343	bool file_spec = false;
1344	int ret;
1345
1346	/*
1347	 * <Syntax>
1348	 * perf probe [GRP:][EVENT=]SRC[:LN|;PTN]
1349	 * perf probe [GRP:][EVENT=]FUNC[@SRC][+OFFS|%return|:LN|;PAT]
1350	 * perf probe %[GRP:]SDT_EVENT
 
1351	 */
1352	if (!arg)
1353		return -EINVAL;
1354
1355	if (is_sdt_event(arg)) {
1356		pev->sdt = true;
1357		if (arg[0] == '%')
1358			arg++;
1359	}
1360
1361	ptr = strpbrk_esc(arg, ";=@+%");
1362	if (pev->sdt) {
1363		if (ptr) {
1364			if (*ptr != '@') {
1365				semantic_error("%s must be an SDT name.\n",
1366					       arg);
1367				return -EINVAL;
1368			}
1369			/* This must be a target file name or build id */
1370			tmp = build_id_cache__complement(ptr + 1);
1371			if (tmp) {
1372				pev->target = build_id_cache__origname(tmp);
1373				free(tmp);
1374			} else
1375				pev->target = strdup_esc(ptr + 1);
1376			if (!pev->target)
1377				return -ENOMEM;
1378			*ptr = '\0';
1379		}
1380		ret = parse_perf_probe_event_name(&arg, pev);
1381		if (ret == 0) {
1382			if (asprintf(&pev->point.function, "%%%s", pev->event) < 0)
1383				ret = -errno;
1384		}
1385		return ret;
1386	}
1387
 
1388	if (ptr && *ptr == '=') {	/* Event name */
1389		*ptr = '\0';
1390		tmp = ptr + 1;
1391		ret = parse_perf_probe_event_name(&arg, pev);
1392		if (ret < 0)
1393			return ret;
1394
 
 
 
 
 
 
 
 
 
1395		arg = tmp;
1396	}
1397
1398	/*
1399	 * Check arg is function or file name and copy it.
1400	 *
1401	 * We consider arg to be a file spec if and only if it satisfies
1402	 * all of the below criteria::
1403	 * - it does not include any of "+@%",
1404	 * - it includes one of ":;", and
1405	 * - it has a period '.' in the name.
1406	 *
1407	 * Otherwise, we consider arg to be a function specification.
1408	 */
1409	if (!strpbrk_esc(arg, "+@%")) {
1410		ptr = strpbrk_esc(arg, ";:");
1411		/* This is a file spec if it includes a '.' before ; or : */
1412		if (ptr && memchr(arg, '.', ptr - arg))
1413			file_spec = true;
1414	}
1415
1416	ptr = strpbrk_esc(arg, ";:+@%");
1417	if (ptr) {
1418		nc = *ptr;
1419		*ptr++ = '\0';
1420	}
1421
1422	if (arg[0] == '\0')
1423		tmp = NULL;
1424	else {
1425		tmp = strdup_esc(arg);
1426		if (tmp == NULL)
1427			return -ENOMEM;
1428	}
1429
1430	if (file_spec)
 
1431		pp->file = tmp;
1432	else {
1433		pp->function = tmp;
1434
1435		/*
1436		 * Keep pp->function even if this is absolute address,
1437		 * so it can mark whether abs_address is valid.
1438		 * Which make 'perf probe lib.bin 0x0' possible.
1439		 *
1440		 * Note that checking length of tmp is not needed
1441		 * because when we access tmp[1] we know tmp[0] is '0',
1442		 * so tmp[1] should always valid (but could be '\0').
1443		 */
1444		if (tmp && !strncmp(tmp, "0x", 2)) {
1445			pp->abs_address = strtoul(pp->function, &tmp, 0);
1446			if (*tmp != '\0') {
1447				semantic_error("Invalid absolute address.\n");
1448				return -EINVAL;
1449			}
1450		}
1451	}
1452
1453	/* Parse other options */
1454	while (ptr) {
1455		arg = ptr;
1456		c = nc;
1457		if (c == ';') {	/* Lazy pattern must be the last part */
1458			pp->lazy_line = strdup(arg); /* let leave escapes */
1459			if (pp->lazy_line == NULL)
1460				return -ENOMEM;
1461			break;
1462		}
1463		ptr = strpbrk_esc(arg, ";:+@%");
1464		if (ptr) {
1465			nc = *ptr;
1466			*ptr++ = '\0';
1467		}
1468		switch (c) {
1469		case ':':	/* Line number */
1470			pp->line = strtoul(arg, &tmp, 0);
1471			if (*tmp != '\0') {
1472				semantic_error("There is non-digit char"
1473					       " in line number.\n");
1474				return -EINVAL;
1475			}
1476			break;
1477		case '+':	/* Byte offset from a symbol */
1478			pp->offset = strtoul(arg, &tmp, 0);
1479			if (*tmp != '\0') {
1480				semantic_error("There is non-digit character"
1481						" in offset.\n");
1482				return -EINVAL;
1483			}
1484			break;
1485		case '@':	/* File name */
1486			if (pp->file) {
1487				semantic_error("SRC@SRC is not allowed.\n");
1488				return -EINVAL;
1489			}
1490			pp->file = strdup_esc(arg);
1491			if (pp->file == NULL)
1492				return -ENOMEM;
1493			break;
1494		case '%':	/* Probe places */
1495			if (strcmp(arg, "return") == 0) {
1496				pp->retprobe = 1;
1497			} else {	/* Others not supported yet */
1498				semantic_error("%%%s is not supported.\n", arg);
1499				return -ENOTSUP;
1500			}
1501			break;
1502		default:	/* Buggy case */
1503			pr_err("This program has a bug at %s:%d.\n",
1504				__FILE__, __LINE__);
1505			return -ENOTSUP;
1506			break;
1507		}
1508	}
1509
1510	/* Exclusion check */
1511	if (pp->lazy_line && pp->line) {
1512		semantic_error("Lazy pattern can't be used with"
1513			       " line number.\n");
1514		return -EINVAL;
1515	}
1516
1517	if (pp->lazy_line && pp->offset) {
1518		semantic_error("Lazy pattern can't be used with offset.\n");
1519		return -EINVAL;
1520	}
1521
1522	if (pp->line && pp->offset) {
1523		semantic_error("Offset can't be used with line number.\n");
1524		return -EINVAL;
1525	}
1526
1527	if (!pp->line && !pp->lazy_line && pp->file && !pp->function) {
1528		semantic_error("File always requires line number or "
1529			       "lazy pattern.\n");
1530		return -EINVAL;
1531	}
1532
1533	if (pp->offset && !pp->function) {
1534		semantic_error("Offset requires an entry function.\n");
1535		return -EINVAL;
1536	}
1537
 
 
 
 
 
1538	if ((pp->offset || pp->line || pp->lazy_line) && pp->retprobe) {
1539		semantic_error("Offset/Line/Lazy pattern can't be used with "
1540			       "return probe.\n");
1541		return -EINVAL;
1542	}
1543
1544	pr_debug("symbol:%s file:%s line:%d offset:%lu return:%d lazy:%s\n",
1545		 pp->function, pp->file, pp->line, pp->offset, pp->retprobe,
1546		 pp->lazy_line);
1547	return 0;
1548}
1549
1550/* Parse perf-probe event argument */
1551static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
1552{
1553	char *tmp, *goodname;
1554	struct perf_probe_arg_field **fieldp;
1555
1556	pr_debug("parsing arg: %s into ", str);
1557
1558	tmp = strchr(str, '=');
1559	if (tmp) {
1560		arg->name = strndup(str, tmp - str);
1561		if (arg->name == NULL)
1562			return -ENOMEM;
1563		pr_debug("name:%s ", arg->name);
1564		str = tmp + 1;
1565	}
1566
1567	tmp = strchr(str, '@');
1568	if (tmp && tmp != str && strcmp(tmp + 1, "user")) { /* user attr */
1569		if (!user_access_is_supported()) {
1570			semantic_error("ftrace does not support user access\n");
1571			return -EINVAL;
1572		}
1573		*tmp = '\0';
1574		arg->user_access = true;
1575		pr_debug("user_access ");
1576	}
1577
1578	tmp = strchr(str, ':');
1579	if (tmp) {	/* Type setting */
1580		*tmp = '\0';
1581		arg->type = strdup(tmp + 1);
1582		if (arg->type == NULL)
1583			return -ENOMEM;
1584		pr_debug("type:%s ", arg->type);
1585	}
1586
1587	tmp = strpbrk(str, "-.[");
1588	if (!is_c_varname(str) || !tmp) {
1589		/* A variable, register, symbol or special value */
1590		arg->var = strdup(str);
1591		if (arg->var == NULL)
1592			return -ENOMEM;
1593		pr_debug("%s\n", arg->var);
1594		return 0;
1595	}
1596
1597	/* Structure fields or array element */
1598	arg->var = strndup(str, tmp - str);
1599	if (arg->var == NULL)
1600		return -ENOMEM;
1601	goodname = arg->var;
1602	pr_debug("%s, ", arg->var);
1603	fieldp = &arg->field;
1604
1605	do {
1606		*fieldp = zalloc(sizeof(struct perf_probe_arg_field));
1607		if (*fieldp == NULL)
1608			return -ENOMEM;
1609		if (*tmp == '[') {	/* Array */
1610			str = tmp;
1611			(*fieldp)->index = strtol(str + 1, &tmp, 0);
1612			(*fieldp)->ref = true;
1613			if (*tmp != ']' || tmp == str + 1) {
1614				semantic_error("Array index must be a"
1615						" number.\n");
1616				return -EINVAL;
1617			}
1618			tmp++;
1619			if (*tmp == '\0')
1620				tmp = NULL;
1621		} else {		/* Structure */
1622			if (*tmp == '.') {
1623				str = tmp + 1;
1624				(*fieldp)->ref = false;
1625			} else if (tmp[1] == '>') {
1626				str = tmp + 2;
1627				(*fieldp)->ref = true;
1628			} else {
1629				semantic_error("Argument parse error: %s\n",
1630					       str);
1631				return -EINVAL;
1632			}
1633			tmp = strpbrk(str, "-.[");
1634		}
1635		if (tmp) {
1636			(*fieldp)->name = strndup(str, tmp - str);
1637			if ((*fieldp)->name == NULL)
1638				return -ENOMEM;
1639			if (*str != '[')
1640				goodname = (*fieldp)->name;
1641			pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
1642			fieldp = &(*fieldp)->next;
1643		}
1644	} while (tmp);
1645	(*fieldp)->name = strdup(str);
1646	if ((*fieldp)->name == NULL)
1647		return -ENOMEM;
1648	if (*str != '[')
1649		goodname = (*fieldp)->name;
1650	pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
1651
1652	/* If no name is specified, set the last field name (not array index)*/
1653	if (!arg->name) {
1654		arg->name = strdup(goodname);
1655		if (arg->name == NULL)
1656			return -ENOMEM;
1657	}
1658	return 0;
1659}
1660
1661/* Parse perf-probe event command */
1662int parse_perf_probe_command(const char *cmd, struct perf_probe_event *pev)
1663{
1664	char **argv;
1665	int argc, i, ret = 0;
1666
1667	argv = argv_split(cmd, &argc);
1668	if (!argv) {
1669		pr_debug("Failed to split arguments.\n");
1670		return -ENOMEM;
1671	}
1672	if (argc - 1 > MAX_PROBE_ARGS) {
1673		semantic_error("Too many probe arguments (%d).\n", argc - 1);
1674		ret = -ERANGE;
1675		goto out;
1676	}
1677	/* Parse probe point */
1678	ret = parse_perf_probe_point(argv[0], pev);
1679	if (ret < 0)
1680		goto out;
1681
1682	/* Copy arguments and ensure return probe has no C argument */
1683	pev->nargs = argc - 1;
1684	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
1685	if (pev->args == NULL) {
1686		ret = -ENOMEM;
1687		goto out;
1688	}
1689	for (i = 0; i < pev->nargs && ret >= 0; i++) {
1690		ret = parse_perf_probe_arg(argv[i + 1], &pev->args[i]);
1691		if (ret >= 0 &&
1692		    is_c_varname(pev->args[i].var) && pev->point.retprobe) {
1693			semantic_error("You can't specify local variable for"
1694				       " kretprobe.\n");
1695			ret = -EINVAL;
1696		}
1697	}
1698out:
1699	argv_free(argv);
1700
1701	return ret;
1702}
1703
1704/* Returns true if *any* ARG is either C variable, $params or $vars. */
1705bool perf_probe_with_var(struct perf_probe_event *pev)
1706{
1707	int i = 0;
1708
1709	for (i = 0; i < pev->nargs; i++)
1710		if (is_c_varname(pev->args[i].var)              ||
1711		    !strcmp(pev->args[i].var, PROBE_ARG_PARAMS) ||
1712		    !strcmp(pev->args[i].var, PROBE_ARG_VARS))
1713			return true;
1714	return false;
1715}
1716
1717/* Return true if this perf_probe_event requires debuginfo */
1718bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
1719{
 
 
1720	if (pev->point.file || pev->point.line || pev->point.lazy_line)
1721		return true;
1722
1723	if (perf_probe_with_var(pev))
1724		return true;
 
1725
1726	return false;
1727}
1728
1729/* Parse probe_events event into struct probe_point */
1730int parse_probe_trace_command(const char *cmd, struct probe_trace_event *tev)
 
1731{
1732	struct probe_trace_point *tp = &tev->point;
1733	char pr;
1734	char *p;
1735	char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
1736	int ret, i, argc;
1737	char **argv;
1738
1739	pr_debug("Parsing probe_events: %s\n", cmd);
1740	argv = argv_split(cmd, &argc);
1741	if (!argv) {
1742		pr_debug("Failed to split arguments.\n");
1743		return -ENOMEM;
1744	}
1745	if (argc < 2) {
1746		semantic_error("Too few probe arguments.\n");
1747		ret = -ERANGE;
1748		goto out;
1749	}
1750
1751	/* Scan event and group name. */
1752	argv0_str = strdup(argv[0]);
1753	if (argv0_str == NULL) {
1754		ret = -ENOMEM;
1755		goto out;
1756	}
1757	fmt1_str = strtok_r(argv0_str, ":", &fmt);
1758	fmt2_str = strtok_r(NULL, "/", &fmt);
1759	fmt3_str = strtok_r(NULL, " \t", &fmt);
1760	if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
1761	    || fmt3_str == NULL) {
1762		semantic_error("Failed to parse event name: %s\n", argv[0]);
1763		ret = -EINVAL;
1764		goto out;
1765	}
1766	pr = fmt1_str[0];
1767	tev->group = strdup(fmt2_str);
1768	tev->event = strdup(fmt3_str);
1769	if (tev->group == NULL || tev->event == NULL) {
1770		ret = -ENOMEM;
1771		goto out;
1772	}
1773	pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
1774
1775	tp->retprobe = (pr == 'r');
1776
1777	/* Scan module name(if there), function name and offset */
1778	p = strchr(argv[1], ':');
1779	if (p) {
1780		tp->module = strndup(argv[1], p - argv[1]);
1781		if (!tp->module) {
1782			ret = -ENOMEM;
1783			goto out;
1784		}
1785		tev->uprobes = (tp->module[0] == '/');
1786		p++;
1787	} else
1788		p = argv[1];
1789	fmt1_str = strtok_r(p, "+", &fmt);
1790	/* only the address started with 0x */
1791	if (fmt1_str[0] == '0')	{
1792		/*
1793		 * Fix a special case:
1794		 * if address == 0, kernel reports something like:
1795		 * p:probe_libc/abs_0 /lib/libc-2.18.so:0x          (null) arg1=%ax
1796		 * Newer kernel may fix that, but we want to
1797		 * support old kernel also.
1798		 */
1799		if (strcmp(fmt1_str, "0x") == 0) {
1800			if (!argv[2] || strcmp(argv[2], "(null)")) {
1801				ret = -EINVAL;
1802				goto out;
1803			}
1804			tp->address = 0;
1805
1806			free(argv[2]);
1807			for (i = 2; argv[i + 1] != NULL; i++)
1808				argv[i] = argv[i + 1];
1809
1810			argv[i] = NULL;
1811			argc -= 1;
1812		} else
1813			tp->address = strtoul(fmt1_str, NULL, 0);
1814	} else {
1815		/* Only the symbol-based probe has offset */
1816		tp->symbol = strdup(fmt1_str);
1817		if (tp->symbol == NULL) {
1818			ret = -ENOMEM;
1819			goto out;
1820		}
1821		fmt2_str = strtok_r(NULL, "", &fmt);
1822		if (fmt2_str == NULL)
1823			tp->offset = 0;
1824		else
1825			tp->offset = strtoul(fmt2_str, NULL, 10);
1826	}
1827
1828	if (tev->uprobes) {
1829		fmt2_str = strchr(p, '(');
1830		if (fmt2_str)
1831			tp->ref_ctr_offset = strtoul(fmt2_str + 1, NULL, 0);
1832	}
1833
1834	tev->nargs = argc - 2;
1835	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1836	if (tev->args == NULL) {
1837		ret = -ENOMEM;
1838		goto out;
1839	}
1840	for (i = 0; i < tev->nargs; i++) {
1841		p = strchr(argv[i + 2], '=');
1842		if (p)	/* We don't need which register is assigned. */
1843			*p++ = '\0';
1844		else
1845			p = argv[i + 2];
1846		tev->args[i].name = strdup(argv[i + 2]);
1847		/* TODO: parse regs and offset */
1848		tev->args[i].value = strdup(p);
1849		if (tev->args[i].name == NULL || tev->args[i].value == NULL) {
1850			ret = -ENOMEM;
1851			goto out;
1852		}
1853	}
1854	ret = 0;
1855out:
1856	free(argv0_str);
1857	argv_free(argv);
1858	return ret;
1859}
1860
1861/* Compose only probe arg */
1862char *synthesize_perf_probe_arg(struct perf_probe_arg *pa)
1863{
1864	struct perf_probe_arg_field *field = pa->field;
1865	struct strbuf buf;
1866	char *ret = NULL;
1867	int err;
1868
1869	if (strbuf_init(&buf, 64) < 0)
1870		return NULL;
1871
1872	if (pa->name && pa->var)
1873		err = strbuf_addf(&buf, "%s=%s", pa->name, pa->var);
1874	else
1875		err = strbuf_addstr(&buf, pa->name ?: pa->var);
1876	if (err)
1877		goto out;
 
 
1878
1879	while (field) {
1880		if (field->name[0] == '[')
1881			err = strbuf_addstr(&buf, field->name);
1882		else
1883			err = strbuf_addf(&buf, "%s%s", field->ref ? "->" : ".",
1884					  field->name);
 
 
 
 
1885		field = field->next;
1886		if (err)
1887			goto out;
1888	}
1889
1890	if (pa->type)
1891		if (strbuf_addf(&buf, ":%s", pa->type) < 0)
1892			goto out;
 
 
 
 
1893
1894	ret = strbuf_detach(&buf, NULL);
1895out:
1896	strbuf_release(&buf);
 
1897	return ret;
1898}
1899
1900/* Compose only probe point (not argument) */
1901char *synthesize_perf_probe_point(struct perf_probe_point *pp)
1902{
1903	struct strbuf buf;
1904	char *tmp, *ret = NULL;
1905	int len, err = 0;
1906
1907	if (strbuf_init(&buf, 64) < 0)
1908		return NULL;
1909
1910	if (pp->function) {
1911		if (strbuf_addstr(&buf, pp->function) < 0)
1912			goto out;
1913		if (pp->offset)
1914			err = strbuf_addf(&buf, "+%lu", pp->offset);
1915		else if (pp->line)
1916			err = strbuf_addf(&buf, ":%d", pp->line);
1917		else if (pp->retprobe)
1918			err = strbuf_addstr(&buf, "%return");
1919		if (err)
1920			goto out;
 
 
 
1921	}
1922	if (pp->file) {
1923		tmp = pp->file;
1924		len = strlen(tmp);
1925		if (len > 30) {
1926			tmp = strchr(pp->file + len - 30, '/');
1927			tmp = tmp ? tmp + 1 : pp->file + len - 30;
1928		}
1929		err = strbuf_addf(&buf, "@%s", tmp);
1930		if (!err && !pp->function && pp->line)
1931			err = strbuf_addf(&buf, ":%d", pp->line);
1932	}
1933	if (!err)
1934		ret = strbuf_detach(&buf, NULL);
1935out:
1936	strbuf_release(&buf);
1937	return ret;
 
 
 
 
 
 
 
 
 
 
 
1938}
1939
 
1940char *synthesize_perf_probe_command(struct perf_probe_event *pev)
1941{
1942	struct strbuf buf;
1943	char *tmp, *ret = NULL;
1944	int i;
1945
1946	if (strbuf_init(&buf, 64))
 
1947		return NULL;
1948	if (pev->event)
1949		if (strbuf_addf(&buf, "%s:%s=", pev->group ?: PERFPROBE_GROUP,
1950				pev->event) < 0)
1951			goto out;
1952
1953	tmp = synthesize_perf_probe_point(&pev->point);
1954	if (!tmp || strbuf_addstr(&buf, tmp) < 0)
1955		goto out;
1956	free(tmp);
1957
 
1958	for (i = 0; i < pev->nargs; i++) {
1959		tmp = synthesize_perf_probe_arg(pev->args + i);
1960		if (!tmp || strbuf_addf(&buf, " %s", tmp) < 0)
1961			goto out;
1962		free(tmp);
 
 
 
1963	}
1964
1965	ret = strbuf_detach(&buf, NULL);
1966out:
1967	strbuf_release(&buf);
1968	return ret;
1969}
 
1970
1971static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
1972					    struct strbuf *buf, int depth)
 
1973{
1974	int err;
1975	if (ref->next) {
1976		depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
1977							 depth + 1);
1978		if (depth < 0)
1979			return depth;
 
 
 
 
 
 
 
 
1980	}
1981	err = strbuf_addf(buf, "%+ld(", ref->offset);
1982	return (err < 0) ? err : depth;
 
1983}
1984
1985static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
1986				      struct strbuf *buf)
1987{
1988	struct probe_trace_arg_ref *ref = arg->ref;
1989	int depth = 0, err;
 
1990
1991	/* Argument name or separator */
1992	if (arg->name)
1993		err = strbuf_addf(buf, " %s=", arg->name);
1994	else
1995		err = strbuf_addch(buf, ' ');
1996	if (err)
1997		return err;
 
 
1998
1999	/* Special case: @XXX */
2000	if (arg->value[0] == '@' && arg->ref)
2001			ref = ref->next;
2002
2003	/* Dereferencing arguments */
2004	if (ref) {
2005		depth = __synthesize_probe_trace_arg_ref(ref, buf, 1);
 
2006		if (depth < 0)
2007			return depth;
2008	}
2009
2010	/* Print argument value */
2011	if (arg->value[0] == '@' && arg->ref)
2012		err = strbuf_addf(buf, "%s%+ld", arg->value, arg->ref->offset);
 
2013	else
2014		err = strbuf_addstr(buf, arg->value);
 
 
 
 
2015
2016	/* Closing */
2017	while (!err && depth--)
2018		err = strbuf_addch(buf, ')');
2019
 
 
 
 
2020	/* Print argument type */
2021	if (!err && arg->type)
2022		err = strbuf_addf(buf, ":%s", arg->type);
2023
2024	return err;
2025}
2026
2027static int
2028synthesize_uprobe_trace_def(struct probe_trace_event *tev, struct strbuf *buf)
2029{
2030	struct probe_trace_point *tp = &tev->point;
2031	int err;
2032
2033	err = strbuf_addf(buf, "%s:0x%lx", tp->module, tp->address);
2034
2035	if (err >= 0 && tp->ref_ctr_offset) {
2036		if (!uprobe_ref_ctr_is_supported())
2037			return -1;
2038		err = strbuf_addf(buf, "(0x%lx)", tp->ref_ctr_offset);
2039	}
2040	return err >= 0 ? 0 : -1;
 
2041}
2042
2043char *synthesize_probe_trace_command(struct probe_trace_event *tev)
2044{
2045	struct probe_trace_point *tp = &tev->point;
2046	struct strbuf buf;
2047	char *ret = NULL;
2048	int i, err;
2049
2050	/* Uprobes must have tp->module */
2051	if (tev->uprobes && !tp->module)
2052		return NULL;
2053
2054	if (strbuf_init(&buf, 32) < 0)
2055		return NULL;
 
 
2056
2057	if (strbuf_addf(&buf, "%c:%s/%s ", tp->retprobe ? 'r' : 'p',
2058			tev->group, tev->event) < 0)
2059		goto error;
2060	/*
2061	 * If tp->address == 0, then this point must be a
2062	 * absolute address uprobe.
2063	 * try_to_find_absolute_address() should have made
2064	 * tp->symbol to "0x0".
2065	 */
2066	if (tev->uprobes && !tp->address) {
2067		if (!tp->symbol || strcmp(tp->symbol, "0x0"))
2068			goto error;
2069	}
2070
2071	/* Use the tp->address for uprobes */
2072	if (tev->uprobes) {
2073		err = synthesize_uprobe_trace_def(tev, &buf);
2074	} else if (!strncmp(tp->symbol, "0x", 2)) {
2075		/* Absolute address. See try_to_find_absolute_address() */
2076		err = strbuf_addf(&buf, "%s%s0x%lx", tp->module ?: "",
2077				  tp->module ? ":" : "", tp->address);
2078	} else {
2079		err = strbuf_addf(&buf, "%s%s%s+%lu", tp->module ?: "",
2080				tp->module ? ":" : "", tp->symbol, tp->offset);
2081	}
2082
2083	if (err)
2084		goto error;
 
2085
2086	for (i = 0; i < tev->nargs; i++)
2087		if (synthesize_probe_trace_arg(&tev->args[i], &buf) < 0)
 
 
2088			goto error;
 
 
2089
2090	ret = strbuf_detach(&buf, NULL);
2091error:
2092	strbuf_release(&buf);
2093	return ret;
2094}
2095
2096static int find_perf_probe_point_from_map(struct probe_trace_point *tp,
2097					  struct perf_probe_point *pp,
2098					  bool is_kprobe)
2099{
2100	struct symbol *sym = NULL;
2101	struct map *map = NULL;
2102	u64 addr = tp->address;
2103	int ret = -ENOENT;
2104
2105	if (!is_kprobe) {
2106		map = dso__new_map(tp->module);
2107		if (!map)
2108			goto out;
2109		sym = map__find_symbol(map, addr);
 
2110	} else {
2111		if (tp->symbol && !addr) {
2112			if (kernel_get_symbol_address_by_name(tp->symbol,
2113						&addr, true, false) < 0)
2114				goto out;
2115		}
2116		if (addr) {
2117			addr += tp->offset;
2118			sym = machine__find_kernel_symbol(host_machine, addr, &map);
2119		}
2120	}
2121
2122	if (!sym)
2123		goto out;
2124
2125	pp->retprobe = tp->retprobe;
2126	pp->offset = addr - map->unmap_ip(map, sym->start);
2127	pp->function = strdup(sym->name);
2128	ret = pp->function ? 0 : -ENOMEM;
2129
2130out:
2131	if (map && !is_kprobe) {
2132		map__put(map);
 
2133	}
2134
2135	return ret;
2136}
2137
2138static int convert_to_perf_probe_point(struct probe_trace_point *tp,
2139				       struct perf_probe_point *pp,
2140				       bool is_kprobe)
2141{
2142	char buf[128];
2143	int ret;
2144
2145	ret = find_perf_probe_point_from_dwarf(tp, pp, is_kprobe);
2146	if (!ret)
2147		return 0;
2148	ret = find_perf_probe_point_from_map(tp, pp, is_kprobe);
2149	if (!ret)
2150		return 0;
2151
2152	pr_debug("Failed to find probe point from both of dwarf and map.\n");
2153
2154	if (tp->symbol) {
2155		pp->function = strdup(tp->symbol);
2156		pp->offset = tp->offset;
2157	} else {
2158		ret = e_snprintf(buf, 128, "0x%" PRIx64, (u64)tp->address);
2159		if (ret < 0)
2160			return ret;
2161		pp->function = strdup(buf);
2162		pp->offset = 0;
2163	}
2164	if (pp->function == NULL)
2165		return -ENOMEM;
2166
2167	pp->retprobe = tp->retprobe;
2168
2169	return 0;
2170}
2171
2172static int convert_to_perf_probe_event(struct probe_trace_event *tev,
2173			       struct perf_probe_event *pev, bool is_kprobe)
2174{
2175	struct strbuf buf = STRBUF_INIT;
2176	int i, ret;
2177
2178	/* Convert event/group name */
2179	pev->event = strdup(tev->event);
2180	pev->group = strdup(tev->group);
2181	if (pev->event == NULL || pev->group == NULL)
2182		return -ENOMEM;
2183
2184	/* Convert trace_point to probe_point */
2185	ret = convert_to_perf_probe_point(&tev->point, &pev->point, is_kprobe);
2186	if (ret < 0)
2187		return ret;
2188
2189	/* Convert trace_arg to probe_arg */
2190	pev->nargs = tev->nargs;
2191	pev->args = zalloc(sizeof(struct perf_probe_arg) * pev->nargs);
2192	if (pev->args == NULL)
2193		return -ENOMEM;
2194	for (i = 0; i < tev->nargs && ret >= 0; i++) {
2195		if (tev->args[i].name)
2196			pev->args[i].name = strdup(tev->args[i].name);
2197		else {
2198			if ((ret = strbuf_init(&buf, 32)) < 0)
2199				goto error;
2200			ret = synthesize_probe_trace_arg(&tev->args[i], &buf);
2201			pev->args[i].name = strbuf_detach(&buf, NULL);
2202		}
2203		if (pev->args[i].name == NULL && ret >= 0)
2204			ret = -ENOMEM;
2205	}
2206error:
2207	if (ret < 0)
2208		clear_perf_probe_event(pev);
2209
2210	return ret;
2211}
2212
2213void clear_perf_probe_event(struct perf_probe_event *pev)
2214{
 
2215	struct perf_probe_arg_field *field, *next;
2216	int i;
2217
2218	zfree(&pev->event);
2219	zfree(&pev->group);
2220	zfree(&pev->target);
2221	clear_perf_probe_point(&pev->point);
 
2222
2223	for (i = 0; i < pev->nargs; i++) {
2224		zfree(&pev->args[i].name);
2225		zfree(&pev->args[i].var);
2226		zfree(&pev->args[i].type);
2227		field = pev->args[i].field;
2228		while (field) {
2229			next = field->next;
2230			zfree(&field->name);
2231			free(field);
2232			field = next;
2233		}
2234	}
2235	pev->nargs = 0;
2236	zfree(&pev->args);
2237}
2238
2239#define strdup_or_goto(str, label)	\
2240({ char *__p = NULL; if (str && !(__p = strdup(str))) goto label; __p; })
2241
2242static int perf_probe_point__copy(struct perf_probe_point *dst,
2243				  struct perf_probe_point *src)
2244{
2245	dst->file = strdup_or_goto(src->file, out_err);
2246	dst->function = strdup_or_goto(src->function, out_err);
2247	dst->lazy_line = strdup_or_goto(src->lazy_line, out_err);
2248	dst->line = src->line;
2249	dst->retprobe = src->retprobe;
2250	dst->offset = src->offset;
2251	return 0;
2252
2253out_err:
2254	clear_perf_probe_point(dst);
2255	return -ENOMEM;
2256}
2257
2258static int perf_probe_arg__copy(struct perf_probe_arg *dst,
2259				struct perf_probe_arg *src)
2260{
2261	struct perf_probe_arg_field *field, **ppfield;
2262
2263	dst->name = strdup_or_goto(src->name, out_err);
2264	dst->var = strdup_or_goto(src->var, out_err);
2265	dst->type = strdup_or_goto(src->type, out_err);
2266
2267	field = src->field;
2268	ppfield = &(dst->field);
2269	while (field) {
2270		*ppfield = zalloc(sizeof(*field));
2271		if (!*ppfield)
2272			goto out_err;
2273		(*ppfield)->name = strdup_or_goto(field->name, out_err);
2274		(*ppfield)->index = field->index;
2275		(*ppfield)->ref = field->ref;
2276		field = field->next;
2277		ppfield = &((*ppfield)->next);
2278	}
2279	return 0;
2280out_err:
2281	return -ENOMEM;
2282}
2283
2284int perf_probe_event__copy(struct perf_probe_event *dst,
2285			   struct perf_probe_event *src)
2286{
2287	int i;
2288
2289	dst->event = strdup_or_goto(src->event, out_err);
2290	dst->group = strdup_or_goto(src->group, out_err);
2291	dst->target = strdup_or_goto(src->target, out_err);
2292	dst->uprobes = src->uprobes;
2293
2294	if (perf_probe_point__copy(&dst->point, &src->point) < 0)
2295		goto out_err;
2296
2297	dst->args = zalloc(sizeof(struct perf_probe_arg) * src->nargs);
2298	if (!dst->args)
2299		goto out_err;
2300	dst->nargs = src->nargs;
2301
2302	for (i = 0; i < src->nargs; i++)
2303		if (perf_probe_arg__copy(&dst->args[i], &src->args[i]) < 0)
2304			goto out_err;
2305	return 0;
2306
2307out_err:
2308	clear_perf_probe_event(dst);
2309	return -ENOMEM;
2310}
2311
2312void clear_probe_trace_event(struct probe_trace_event *tev)
2313{
2314	struct probe_trace_arg_ref *ref, *next;
2315	int i;
2316
2317	zfree(&tev->event);
2318	zfree(&tev->group);
2319	zfree(&tev->point.symbol);
2320	zfree(&tev->point.realname);
2321	zfree(&tev->point.module);
2322	for (i = 0; i < tev->nargs; i++) {
2323		zfree(&tev->args[i].name);
2324		zfree(&tev->args[i].value);
2325		zfree(&tev->args[i].type);
2326		ref = tev->args[i].ref;
2327		while (ref) {
2328			next = ref->next;
2329			free(ref);
2330			ref = next;
2331		}
2332	}
2333	zfree(&tev->args);
2334	tev->nargs = 0;
2335}
2336
2337struct kprobe_blacklist_node {
2338	struct list_head list;
2339	unsigned long start;
2340	unsigned long end;
2341	char *symbol;
2342};
2343
2344static void kprobe_blacklist__delete(struct list_head *blacklist)
2345{
2346	struct kprobe_blacklist_node *node;
2347
2348	while (!list_empty(blacklist)) {
2349		node = list_first_entry(blacklist,
2350					struct kprobe_blacklist_node, list);
2351		list_del_init(&node->list);
2352		zfree(&node->symbol);
2353		free(node);
2354	}
 
 
 
 
 
 
2355}
2356
2357static int kprobe_blacklist__load(struct list_head *blacklist)
 
2358{
2359	struct kprobe_blacklist_node *node;
2360	const char *__debugfs = debugfs__mountpoint();
2361	char buf[PATH_MAX], *p;
2362	FILE *fp;
2363	int ret;
2364
2365	if (__debugfs == NULL)
2366		return -ENOTSUP;
2367
2368	ret = e_snprintf(buf, PATH_MAX, "%s/kprobes/blacklist", __debugfs);
2369	if (ret < 0)
2370		return ret;
2371
2372	fp = fopen(buf, "r");
2373	if (!fp)
2374		return -errno;
2375
2376	ret = 0;
2377	while (fgets(buf, PATH_MAX, fp)) {
2378		node = zalloc(sizeof(*node));
2379		if (!node) {
2380			ret = -ENOMEM;
2381			break;
2382		}
2383		INIT_LIST_HEAD(&node->list);
2384		list_add_tail(&node->list, blacklist);
2385		if (sscanf(buf, "0x%lx-0x%lx", &node->start, &node->end) != 2) {
2386			ret = -EINVAL;
2387			break;
2388		}
2389		p = strchr(buf, '\t');
2390		if (p) {
2391			p++;
2392			if (p[strlen(p) - 1] == '\n')
2393				p[strlen(p) - 1] = '\0';
2394		} else
2395			p = (char *)"unknown";
2396		node->symbol = strdup(p);
2397		if (!node->symbol) {
2398			ret = -ENOMEM;
2399			break;
2400		}
2401		pr_debug2("Blacklist: 0x%lx-0x%lx, %s\n",
2402			  node->start, node->end, node->symbol);
2403		ret++;
2404	}
2405	if (ret < 0)
2406		kprobe_blacklist__delete(blacklist);
2407	fclose(fp);
2408
2409	return ret;
2410}
 
 
 
 
 
2411
2412static struct kprobe_blacklist_node *
2413kprobe_blacklist__find_by_address(struct list_head *blacklist,
2414				  unsigned long address)
2415{
2416	struct kprobe_blacklist_node *node;
2417
2418	list_for_each_entry(node, blacklist, list) {
2419		if (node->start <= address && address < node->end)
2420			return node;
2421	}
2422
2423	return NULL;
2424}
2425
2426static LIST_HEAD(kprobe_blacklist);
2427
2428static void kprobe_blacklist__init(void)
2429{
2430	if (!list_empty(&kprobe_blacklist))
2431		return;
2432
2433	if (kprobe_blacklist__load(&kprobe_blacklist) < 0)
2434		pr_debug("No kprobe blacklist support, ignored\n");
2435}
2436
2437static void kprobe_blacklist__release(void)
2438{
2439	kprobe_blacklist__delete(&kprobe_blacklist);
2440}
2441
2442static bool kprobe_blacklist__listed(unsigned long address)
2443{
2444	return !!kprobe_blacklist__find_by_address(&kprobe_blacklist, address);
2445}
2446
2447static int perf_probe_event__sprintf(const char *group, const char *event,
2448				     struct perf_probe_event *pev,
2449				     const char *module,
2450				     struct strbuf *result)
2451{
2452	int i, ret;
2453	char *buf;
2454
2455	if (asprintf(&buf, "%s:%s", group, event) < 0)
2456		return -errno;
2457	ret = strbuf_addf(result, "  %-20s (on ", buf);
2458	free(buf);
2459	if (ret)
2460		return ret;
2461
2462	/* Synthesize only event probe point */
2463	buf = synthesize_perf_probe_point(&pev->point);
2464	if (!buf)
2465		return -ENOMEM;
2466	ret = strbuf_addstr(result, buf);
2467	free(buf);
2468
2469	if (!ret && module)
2470		ret = strbuf_addf(result, " in %s", module);
 
 
 
2471
2472	if (!ret && pev->nargs > 0) {
2473		ret = strbuf_add(result, " with", 5);
2474		for (i = 0; !ret && i < pev->nargs; i++) {
2475			buf = synthesize_perf_probe_arg(&pev->args[i]);
2476			if (!buf)
2477				return -ENOMEM;
2478			ret = strbuf_addf(result, " %s", buf);
2479			free(buf);
2480		}
2481	}
2482	if (!ret)
2483		ret = strbuf_addch(result, ')');
2484
2485	return ret;
2486}
2487
2488/* Show an event */
2489int show_perf_probe_event(const char *group, const char *event,
2490			  struct perf_probe_event *pev,
2491			  const char *module, bool use_stdout)
2492{
2493	struct strbuf buf = STRBUF_INIT;
2494	int ret;
2495
2496	ret = perf_probe_event__sprintf(group, event, pev, module, &buf);
2497	if (ret >= 0) {
2498		if (use_stdout)
2499			printf("%s\n", buf.buf);
2500		else
2501			pr_info("%s\n", buf.buf);
2502	}
2503	strbuf_release(&buf);
2504
2505	return ret;
2506}
2507
2508static bool filter_probe_trace_event(struct probe_trace_event *tev,
2509				     struct strfilter *filter)
2510{
2511	char tmp[128];
2512
2513	/* At first, check the event name itself */
2514	if (strfilter__compare(filter, tev->event))
2515		return true;
2516
2517	/* Next, check the combination of name and group */
2518	if (e_snprintf(tmp, 128, "%s:%s", tev->group, tev->event) < 0)
2519		return false;
2520	return strfilter__compare(filter, tmp);
 
 
 
 
 
 
 
 
 
 
 
 
 
2521}
2522
2523static int __show_perf_probe_events(int fd, bool is_kprobe,
2524				    struct strfilter *filter)
2525{
2526	int ret = 0;
2527	struct probe_trace_event tev;
2528	struct perf_probe_event pev;
2529	struct strlist *rawlist;
2530	struct str_node *ent;
2531
2532	memset(&tev, 0, sizeof(tev));
2533	memset(&pev, 0, sizeof(pev));
2534
2535	rawlist = probe_file__get_rawlist(fd);
2536	if (!rawlist)
2537		return -ENOMEM;
2538
2539	strlist__for_each_entry(ent, rawlist) {
2540		ret = parse_probe_trace_command(ent->s, &tev);
2541		if (ret >= 0) {
2542			if (!filter_probe_trace_event(&tev, filter))
2543				goto next;
2544			ret = convert_to_perf_probe_event(&tev, &pev,
2545								is_kprobe);
2546			if (ret < 0)
2547				goto next;
2548			ret = show_perf_probe_event(pev.group, pev.event,
2549						    &pev, tev.point.module,
2550						    true);
2551		}
2552next:
2553		clear_perf_probe_event(&pev);
2554		clear_probe_trace_event(&tev);
2555		if (ret < 0)
2556			break;
2557	}
2558	strlist__delete(rawlist);
2559	/* Cleanup cached debuginfo if needed */
2560	debuginfo_cache__exit();
2561
2562	return ret;
2563}
2564
2565/* List up current perf-probe events */
2566int show_perf_probe_events(struct strfilter *filter)
2567{
2568	int kp_fd, up_fd, ret;
2569
2570	setup_pager();
 
2571
2572	if (probe_conf.cache)
2573		return probe_cache__show_all_caches(filter);
2574
2575	ret = init_probe_symbol_maps(false);
2576	if (ret < 0)
2577		return ret;
2578
2579	ret = probe_file__open_both(&kp_fd, &up_fd, 0);
2580	if (ret < 0)
2581		return ret;
2582
2583	if (kp_fd >= 0)
2584		ret = __show_perf_probe_events(kp_fd, true, filter);
2585	if (up_fd >= 0 && ret >= 0)
2586		ret = __show_perf_probe_events(up_fd, false, filter);
2587	if (kp_fd > 0)
2588		close(kp_fd);
2589	if (up_fd > 0)
2590		close(up_fd);
2591	exit_probe_symbol_maps();
2592
 
2593	return ret;
2594}
2595
2596static int get_new_event_name(char *buf, size_t len, const char *base,
2597			      struct strlist *namelist, bool ret_event,
2598			      bool allow_suffix)
2599{
2600	int i, ret;
2601	char *p, *nbase;
 
 
 
2602
2603	if (*base == '.')
2604		base++;
2605	nbase = strdup(base);
2606	if (!nbase)
2607		return -ENOMEM;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2608
2609	/* Cut off the dot suffixes (e.g. .const, .isra) and version suffixes */
2610	p = strpbrk(nbase, ".@");
2611	if (p && p != nbase)
2612		*p = '\0';
2613
2614	/* Try no suffix number */
2615	ret = e_snprintf(buf, len, "%s%s", nbase, ret_event ? "__return" : "");
2616	if (ret < 0) {
2617		pr_debug("snprintf() failed: %d\n", ret);
2618		goto out;
2619	}
2620	if (!strlist__has_entry(namelist, buf))
2621		goto out;
2622
2623	if (!allow_suffix) {
2624		pr_warning("Error: event \"%s\" already exists.\n"
2625			   " Hint: Remove existing event by 'perf probe -d'\n"
2626			   "       or force duplicates by 'perf probe -f'\n"
2627			   "       or set 'force=yes' in BPF source.\n",
2628			   buf);
2629		ret = -EEXIST;
2630		goto out;
2631	}
2632
2633	/* Try to add suffix */
2634	for (i = 1; i < MAX_EVENT_INDEX; i++) {
2635		ret = e_snprintf(buf, len, "%s_%d", nbase, i);
2636		if (ret < 0) {
2637			pr_debug("snprintf() failed: %d\n", ret);
2638			goto out;
2639		}
2640		if (!strlist__has_entry(namelist, buf))
2641			break;
2642	}
2643	if (i == MAX_EVENT_INDEX) {
2644		pr_warning("Too many events are on the same function.\n");
2645		ret = -ERANGE;
2646	}
2647
2648out:
2649	free(nbase);
2650
2651	/* Final validation */
2652	if (ret >= 0 && !is_c_func_name(buf)) {
2653		pr_warning("Internal error: \"%s\" is an invalid event name.\n",
2654			   buf);
2655		ret = -EINVAL;
2656	}
2657
2658	return ret;
2659}
2660
2661/* Warn if the current kernel's uprobe implementation is old */
2662static void warn_uprobe_event_compat(struct probe_trace_event *tev)
2663{
2664	int i;
2665	char *buf = synthesize_probe_trace_command(tev);
2666	struct probe_trace_point *tp = &tev->point;
2667
2668	if (tp->ref_ctr_offset && !uprobe_ref_ctr_is_supported()) {
2669		pr_warning("A semaphore is associated with %s:%s and "
2670			   "seems your kernel doesn't support it.\n",
2671			   tev->group, tev->event);
2672	}
2673
2674	/* Old uprobe event doesn't support memory dereference */
2675	if (!tev->uprobes || tev->nargs == 0 || !buf)
2676		goto out;
2677
2678	for (i = 0; i < tev->nargs; i++)
2679		if (strglobmatch(tev->args[i].value, "[$@+-]*")) {
2680			pr_warning("Please upgrade your kernel to at least "
2681				   "3.14 to have access to feature %s\n",
2682				   tev->args[i].value);
2683			break;
2684		}
2685out:
2686	free(buf);
2687}
2688
2689/* Set new name from original perf_probe_event and namelist */
2690static int probe_trace_event__set_name(struct probe_trace_event *tev,
2691				       struct perf_probe_event *pev,
2692				       struct strlist *namelist,
2693				       bool allow_suffix)
2694{
2695	const char *event, *group;
 
2696	char buf[64];
2697	int ret;
 
2698
2699	/* If probe_event or trace_event already have the name, reuse it */
2700	if (pev->event && !pev->sdt)
2701		event = pev->event;
2702	else if (tev->event)
2703		event = tev->event;
2704	else {
2705		/* Or generate new one from probe point */
2706		if (pev->point.function &&
2707			(strncmp(pev->point.function, "0x", 2) != 0) &&
2708			!strisglob(pev->point.function))
2709			event = pev->point.function;
2710		else
2711			event = tev->point.realname;
2712	}
2713	if (pev->group && !pev->sdt)
2714		group = pev->group;
2715	else if (tev->group)
2716		group = tev->group;
2717	else
2718		group = PERFPROBE_GROUP;
2719
2720	/* Get an unused new event name */
2721	ret = get_new_event_name(buf, 64, event, namelist,
2722				 tev->point.retprobe, allow_suffix);
2723	if (ret < 0)
2724		return ret;
2725
2726	event = buf;
2727
2728	tev->event = strdup(event);
2729	tev->group = strdup(group);
2730	if (tev->event == NULL || tev->group == NULL)
2731		return -ENOMEM;
2732
2733	/* Add added event name to namelist */
2734	strlist__add(namelist, event);
2735	return 0;
2736}
2737
2738static int __open_probe_file_and_namelist(bool uprobe,
2739					  struct strlist **namelist)
2740{
2741	int fd;
2742
2743	fd = probe_file__open(PF_FL_RW | (uprobe ? PF_FL_UPROBE : 0));
2744	if (fd < 0)
2745		return fd;
2746
2747	/* Get current event names */
2748	*namelist = probe_file__get_namelist(fd);
2749	if (!(*namelist)) {
2750		pr_debug("Failed to get current event list.\n");
2751		close(fd);
2752		return -ENOMEM;
2753	}
2754	return fd;
2755}
2756
2757static int __add_probe_trace_events(struct perf_probe_event *pev,
2758				     struct probe_trace_event *tevs,
2759				     int ntevs, bool allow_suffix)
2760{
2761	int i, fd[2] = {-1, -1}, up, ret;
2762	struct probe_trace_event *tev = NULL;
2763	struct probe_cache *cache = NULL;
2764	struct strlist *namelist[2] = {NULL, NULL};
2765	struct nscookie nsc;
2766
2767	up = pev->uprobes ? 1 : 0;
2768	fd[up] = __open_probe_file_and_namelist(up, &namelist[up]);
2769	if (fd[up] < 0)
2770		return fd[up];
2771
2772	ret = 0;
 
2773	for (i = 0; i < ntevs; i++) {
2774		tev = &tevs[i];
2775		up = tev->uprobes ? 1 : 0;
2776		if (fd[up] == -1) {	/* Open the kprobe/uprobe_events */
2777			fd[up] = __open_probe_file_and_namelist(up,
2778								&namelist[up]);
2779			if (fd[up] < 0)
2780				goto close_out;
2781		}
2782		/* Skip if the symbol is out of .text or blacklisted */
2783		if (!tev->point.symbol && !pev->uprobes)
2784			continue;
 
2785
2786		/* Set new name for tev (and update namelist) */
2787		ret = probe_trace_event__set_name(tev, pev, namelist[up],
2788						  allow_suffix);
2789		if (ret < 0)
2790			break;
 
2791
2792		nsinfo__mountns_enter(pev->nsi, &nsc);
2793		ret = probe_file__add_event(fd[up], tev);
2794		nsinfo__mountns_exit(&nsc);
 
 
 
 
2795		if (ret < 0)
2796			break;
 
 
 
 
 
 
 
 
 
 
 
 
2797
2798		/*
2799		 * Probes after the first probe which comes from same
2800		 * user input are always allowed to add suffix, because
2801		 * there might be several addresses corresponding to
2802		 * one code line.
2803		 */
2804		allow_suffix = true;
2805	}
2806	if (ret == -EINVAL && pev->uprobes)
2807		warn_uprobe_event_compat(tev);
2808	if (ret == 0 && probe_conf.cache) {
2809		cache = probe_cache__new(pev->target, pev->nsi);
2810		if (!cache ||
2811		    probe_cache__add_entry(cache, pev, tevs, ntevs) < 0 ||
2812		    probe_cache__commit(cache) < 0)
2813			pr_warning("Failed to add event to probe cache\n");
2814		probe_cache__delete(cache);
2815	}
2816
2817close_out:
2818	for (up = 0; up < 2; up++) {
2819		strlist__delete(namelist[up]);
2820		if (fd[up] >= 0)
2821			close(fd[up]);
2822	}
 
 
 
2823	return ret;
2824}
2825
2826static int find_probe_functions(struct map *map, char *name,
2827				struct symbol **syms)
2828{
2829	int found = 0;
2830	struct symbol *sym;
2831	struct rb_node *tmp;
2832	const char *norm, *ver;
2833	char *buf = NULL;
2834	bool cut_version = true;
2835
2836	if (map__load(map) < 0)
 
 
 
 
 
2837		return 0;
2838
2839	/* If user gives a version, don't cut off the version from symbols */
2840	if (strchr(name, '@'))
2841		cut_version = false;
2842
2843	map__for_each_symbol(map, sym, tmp) {
2844		norm = arch__normalize_symbol_name(sym->name);
2845		if (!norm)
2846			continue;
2847
2848		if (cut_version) {
2849			/* We don't care about default symbol or not */
2850			ver = strchr(norm, '@');
2851			if (ver) {
2852				buf = strndup(norm, ver - norm);
2853				if (!buf)
2854					return -ENOMEM;
2855				norm = buf;
2856			}
2857		}
2858
2859		if (strglobmatch(norm, name)) {
2860			found++;
2861			if (syms && found < probe_conf.max_probes)
2862				syms[found - 1] = sym;
2863		}
2864		if (buf)
2865			zfree(&buf);
2866	}
2867
2868	return found;
2869}
2870
2871void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
2872				struct probe_trace_event *tev __maybe_unused,
2873				struct map *map __maybe_unused,
2874				struct symbol *sym __maybe_unused) { }
2875
2876/*
2877 * Find probe function addresses from map.
2878 * Return an error or the number of found probe_trace_event
2879 */
2880static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
2881					    struct probe_trace_event **tevs)
 
2882{
2883	struct map *map = NULL;
 
2884	struct ref_reloc_sym *reloc_sym = NULL;
2885	struct symbol *sym;
2886	struct symbol **syms = NULL;
2887	struct probe_trace_event *tev;
2888	struct perf_probe_point *pp = &pev->point;
2889	struct probe_trace_point *tp;
2890	int num_matched_functions;
2891	int ret, i, j, skipped = 0;
2892	char *mod_name;
2893
2894	map = get_target_map(pev->target, pev->nsi, pev->uprobes);
 
 
 
 
2895	if (!map) {
2896		ret = -EINVAL;
2897		goto out;
2898	}
2899
2900	syms = malloc(sizeof(struct symbol *) * probe_conf.max_probes);
2901	if (!syms) {
2902		ret = -ENOMEM;
2903		goto out;
2904	}
2905
2906	/*
2907	 * Load matched symbols: Since the different local symbols may have
2908	 * same name but different addresses, this lists all the symbols.
2909	 */
2910	num_matched_functions = find_probe_functions(map, pp->function, syms);
2911	if (num_matched_functions <= 0) {
 
 
2912		pr_err("Failed to find symbol %s in %s\n", pp->function,
2913			pev->target ? : "kernel");
2914		ret = -ENOENT;
2915		goto out;
2916	} else if (num_matched_functions > probe_conf.max_probes) {
2917		pr_err("Too many functions matched in %s\n",
2918			pev->target ? : "kernel");
2919		ret = -E2BIG;
2920		goto out;
2921	}
2922
2923	/* Note that the symbols in the kmodule are not relocated */
2924	if (!pev->uprobes && !pev->target &&
2925			(!pp->retprobe || kretprobe_offset_is_supported())) {
2926		reloc_sym = kernel_get_ref_reloc_sym();
2927		if (!reloc_sym) {
2928			pr_warning("Relocated base symbol is not found!\n");
2929			ret = -EINVAL;
2930			goto out;
2931		}
2932	}
2933
2934	/* Setup result trace-probe-events */
2935	*tevs = zalloc(sizeof(*tev) * num_matched_functions);
2936	if (!*tevs) {
2937		ret = -ENOMEM;
2938		goto out;
2939	}
2940
2941	ret = 0;
2942
2943	for (j = 0; j < num_matched_functions; j++) {
2944		sym = syms[j];
2945
2946		tev = (*tevs) + ret;
2947		tp = &tev->point;
2948		if (ret == num_matched_functions) {
2949			pr_warning("Too many symbols are listed. Skip it.\n");
2950			break;
2951		}
2952		ret++;
2953
2954		if (pp->offset > sym->end - sym->start) {
2955			pr_warning("Offset %ld is bigger than the size of %s\n",
2956				   pp->offset, sym->name);
2957			ret = -ENOENT;
2958			goto err_out;
2959		}
2960		/* Add one probe point */
2961		tp->address = map->unmap_ip(map, sym->start) + pp->offset;
2962
2963		/* Check the kprobe (not in module) is within .text  */
2964		if (!pev->uprobes && !pev->target &&
2965		    kprobe_warn_out_range(sym->name, tp->address)) {
2966			tp->symbol = NULL;	/* Skip it */
2967			skipped++;
2968		} else if (reloc_sym) {
2969			tp->symbol = strdup_or_goto(reloc_sym->name, nomem_out);
2970			tp->offset = tp->address - reloc_sym->addr;
2971		} else {
2972			tp->symbol = strdup_or_goto(sym->name, nomem_out);
2973			tp->offset = pp->offset;
2974		}
2975		tp->realname = strdup_or_goto(sym->name, nomem_out);
2976
2977		tp->retprobe = pp->retprobe;
2978		if (pev->target) {
2979			if (pev->uprobes) {
2980				tev->point.module = strdup_or_goto(pev->target,
2981								   nomem_out);
2982			} else {
2983				mod_name = find_module_name(pev->target);
2984				tev->point.module =
2985					strdup(mod_name ? mod_name : pev->target);
2986				free(mod_name);
2987				if (!tev->point.module)
2988					goto nomem_out;
2989			}
2990		}
2991		tev->uprobes = pev->uprobes;
2992		tev->nargs = pev->nargs;
2993		if (tev->nargs) {
2994			tev->args = zalloc(sizeof(struct probe_trace_arg) *
2995					   tev->nargs);
2996			if (tev->args == NULL)
2997				goto nomem_out;
2998		}
2999		for (i = 0; i < tev->nargs; i++) {
3000			if (pev->args[i].name)
3001				tev->args[i].name =
3002					strdup_or_goto(pev->args[i].name,
3003							nomem_out);
3004
3005			tev->args[i].value = strdup_or_goto(pev->args[i].var,
3006							    nomem_out);
3007			if (pev->args[i].type)
3008				tev->args[i].type =
3009					strdup_or_goto(pev->args[i].type,
3010							nomem_out);
3011		}
3012		arch__fix_tev_from_maps(pev, tev, map, sym);
3013	}
3014	if (ret == skipped) {
3015		ret = -ENOENT;
3016		goto err_out;
3017	}
3018
3019out:
3020	map__put(map);
3021	free(syms);
 
 
 
3022	return ret;
3023
3024nomem_out:
3025	ret = -ENOMEM;
3026err_out:
3027	clear_probe_trace_events(*tevs, num_matched_functions);
3028	zfree(tevs);
3029	goto out;
3030}
3031
3032static int try_to_find_absolute_address(struct perf_probe_event *pev,
3033					struct probe_trace_event **tevs)
 
3034{
3035	struct perf_probe_point *pp = &pev->point;
3036	struct probe_trace_event *tev;
3037	struct probe_trace_point *tp;
3038	int i, err;
3039
3040	if (!(pev->point.function && !strncmp(pev->point.function, "0x", 2)))
3041		return -EINVAL;
3042	if (perf_probe_event_need_dwarf(pev))
3043		return -EINVAL;
3044
3045	/*
3046	 * This is 'perf probe /lib/libc.so 0xabcd'. Try to probe at
3047	 * absolute address.
3048	 *
3049	 * Only one tev can be generated by this.
3050	 */
3051	*tevs = zalloc(sizeof(*tev));
3052	if (!*tevs)
3053		return -ENOMEM;
3054
3055	tev = *tevs;
3056	tp = &tev->point;
3057
3058	/*
3059	 * Don't use tp->offset, use address directly, because
3060	 * in synthesize_probe_trace_command() address cannot be
3061	 * zero.
3062	 */
3063	tp->address = pev->point.abs_address;
3064	tp->retprobe = pp->retprobe;
3065	tev->uprobes = pev->uprobes;
3066
3067	err = -ENOMEM;
3068	/*
3069	 * Give it a '0x' leading symbol name.
3070	 * In __add_probe_trace_events, a NULL symbol is interpreted as
3071	 * invalid.
3072	 */
3073	if (asprintf(&tp->symbol, "0x%lx", tp->address) < 0)
3074		goto errout;
3075
3076	/* For kprobe, check range */
3077	if ((!tev->uprobes) &&
3078	    (kprobe_warn_out_range(tev->point.symbol,
3079				   tev->point.address))) {
3080		err = -EACCES;
3081		goto errout;
3082	}
3083
3084	if (asprintf(&tp->realname, "abs_%lx", tp->address) < 0)
3085		goto errout;
3086
3087	if (pev->target) {
3088		tp->module = strdup(pev->target);
3089		if (!tp->module)
3090			goto errout;
3091	}
3092
3093	if (tev->group) {
3094		tev->group = strdup(pev->group);
3095		if (!tev->group)
3096			goto errout;
3097	}
3098
3099	if (pev->event) {
3100		tev->event = strdup(pev->event);
3101		if (!tev->event)
3102			goto errout;
 
 
 
3103	}
3104
3105	tev->nargs = pev->nargs;
3106	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
3107	if (!tev->args)
3108		goto errout;
3109
3110	for (i = 0; i < tev->nargs; i++)
3111		copy_to_probe_trace_arg(&tev->args[i], &pev->args[i]);
3112
3113	return 1;
3114
3115errout:
3116	clear_probe_trace_events(*tevs, 1);
3117	*tevs = NULL;
3118	return err;
3119}
3120
3121/* Concatinate two arrays */
3122static void *memcat(void *a, size_t sz_a, void *b, size_t sz_b)
3123{
3124	void *ret;
3125
3126	ret = malloc(sz_a + sz_b);
3127	if (ret) {
3128		memcpy(ret, a, sz_a);
3129		memcpy(ret + sz_a, b, sz_b);
3130	}
3131	return ret;
3132}
3133
3134static int
3135concat_probe_trace_events(struct probe_trace_event **tevs, int *ntevs,
3136			  struct probe_trace_event **tevs2, int ntevs2)
3137{
3138	struct probe_trace_event *new_tevs;
3139	int ret = 0;
3140
3141	if (*ntevs == 0) {
3142		*tevs = *tevs2;
3143		*ntevs = ntevs2;
3144		*tevs2 = NULL;
3145		return 0;
3146	}
3147
3148	if (*ntevs + ntevs2 > probe_conf.max_probes)
3149		ret = -E2BIG;
3150	else {
3151		/* Concatinate the array of probe_trace_event */
3152		new_tevs = memcat(*tevs, (*ntevs) * sizeof(**tevs),
3153				  *tevs2, ntevs2 * sizeof(**tevs2));
3154		if (!new_tevs)
3155			ret = -ENOMEM;
3156		else {
3157			free(*tevs);
3158			*tevs = new_tevs;
3159			*ntevs += ntevs2;
3160		}
3161	}
3162	if (ret < 0)
3163		clear_probe_trace_events(*tevs2, ntevs2);
3164	zfree(tevs2);
3165
3166	return ret;
3167}
3168
3169/*
3170 * Try to find probe_trace_event from given probe caches. Return the number
3171 * of cached events found, if an error occurs return the error.
3172 */
3173static int find_cached_events(struct perf_probe_event *pev,
3174			      struct probe_trace_event **tevs,
3175			      const char *target)
3176{
3177	struct probe_cache *cache;
3178	struct probe_cache_entry *entry;
3179	struct probe_trace_event *tmp_tevs = NULL;
3180	int ntevs = 0;
3181	int ret = 0;
3182
3183	cache = probe_cache__new(target, pev->nsi);
3184	/* Return 0 ("not found") if the target has no probe cache. */
3185	if (!cache)
3186		return 0;
3187
3188	for_each_probe_cache_entry(entry, cache) {
3189		/* Skip the cache entry which has no name */
3190		if (!entry->pev.event || !entry->pev.group)
3191			continue;
3192		if ((!pev->group || strglobmatch(entry->pev.group, pev->group)) &&
3193		    strglobmatch(entry->pev.event, pev->event)) {
3194			ret = probe_cache_entry__get_event(entry, &tmp_tevs);
3195			if (ret > 0)
3196				ret = concat_probe_trace_events(tevs, &ntevs,
3197								&tmp_tevs, ret);
3198			if (ret < 0)
3199				break;
3200		}
3201	}
3202	probe_cache__delete(cache);
3203	if (ret < 0) {
3204		clear_probe_trace_events(*tevs, ntevs);
3205		zfree(tevs);
3206	} else {
3207		ret = ntevs;
3208		if (ntevs > 0 && target && target[0] == '/')
3209			pev->uprobes = true;
3210	}
3211
3212	return ret;
3213}
3214
3215/* Try to find probe_trace_event from all probe caches */
3216static int find_cached_events_all(struct perf_probe_event *pev,
3217				   struct probe_trace_event **tevs)
3218{
3219	struct probe_trace_event *tmp_tevs = NULL;
3220	struct strlist *bidlist;
3221	struct str_node *nd;
3222	char *pathname;
3223	int ntevs = 0;
3224	int ret;
3225
3226	/* Get the buildid list of all valid caches */
3227	bidlist = build_id_cache__list_all(true);
3228	if (!bidlist) {
3229		ret = -errno;
3230		pr_debug("Failed to get buildids: %d\n", ret);
3231		return ret;
3232	}
3233
3234	ret = 0;
3235	strlist__for_each_entry(nd, bidlist) {
3236		pathname = build_id_cache__origname(nd->s);
3237		ret = find_cached_events(pev, &tmp_tevs, pathname);
3238		/* In the case of cnt == 0, we just skip it */
3239		if (ret > 0)
3240			ret = concat_probe_trace_events(tevs, &ntevs,
3241							&tmp_tevs, ret);
3242		free(pathname);
3243		if (ret < 0)
3244			break;
3245	}
3246	strlist__delete(bidlist);
3247
3248	if (ret < 0) {
3249		clear_probe_trace_events(*tevs, ntevs);
3250		zfree(tevs);
3251	} else
3252		ret = ntevs;
3253
3254	return ret;
3255}
3256
3257static int find_probe_trace_events_from_cache(struct perf_probe_event *pev,
3258					      struct probe_trace_event **tevs)
3259{
3260	struct probe_cache *cache;
3261	struct probe_cache_entry *entry;
3262	struct probe_trace_event *tev;
3263	struct str_node *node;
3264	int ret, i;
3265
3266	if (pev->sdt) {
3267		/* For SDT/cached events, we use special search functions */
3268		if (!pev->target)
3269			return find_cached_events_all(pev, tevs);
3270		else
3271			return find_cached_events(pev, tevs, pev->target);
3272	}
3273	cache = probe_cache__new(pev->target, pev->nsi);
3274	if (!cache)
3275		return 0;
3276
3277	entry = probe_cache__find(cache, pev);
3278	if (!entry) {
3279		/* SDT must be in the cache */
3280		ret = pev->sdt ? -ENOENT : 0;
3281		goto out;
3282	}
3283
3284	ret = strlist__nr_entries(entry->tevlist);
3285	if (ret > probe_conf.max_probes) {
3286		pr_debug("Too many entries matched in the cache of %s\n",
3287			 pev->target ? : "kernel");
3288		ret = -E2BIG;
3289		goto out;
3290	}
3291
3292	*tevs = zalloc(ret * sizeof(*tev));
3293	if (!*tevs) {
3294		ret = -ENOMEM;
3295		goto out;
3296	}
3297
3298	i = 0;
3299	strlist__for_each_entry(node, entry->tevlist) {
3300		tev = &(*tevs)[i++];
3301		ret = parse_probe_trace_command(node->s, tev);
3302		if (ret < 0)
3303			goto out;
3304		/* Set the uprobes attribute as same as original */
3305		tev->uprobes = pev->uprobes;
 
 
 
 
 
3306	}
3307	ret = i;
 
3308
3309out:
3310	probe_cache__delete(cache);
3311	return ret;
3312}
3313
3314static int convert_to_probe_trace_events(struct perf_probe_event *pev,
3315					 struct probe_trace_event **tevs)
3316{
 
 
3317	int ret;
3318
3319	if (!pev->group && !pev->sdt) {
3320		/* Set group name if not given */
3321		if (!pev->uprobes) {
3322			pev->group = strdup(PERFPROBE_GROUP);
3323			ret = pev->group ? 0 : -ENOMEM;
3324		} else
3325			ret = convert_exec_to_group(pev->target, &pev->group);
3326		if (ret != 0) {
3327			pr_warning("Failed to make a group name.\n");
3328			return ret;
3329		}
3330	}
3331
3332	ret = try_to_find_absolute_address(pev, tevs);
3333	if (ret > 0)
3334		return ret;
3335
3336	/* At first, we need to lookup cache entry */
3337	ret = find_probe_trace_events_from_cache(pev, tevs);
3338	if (ret > 0 || pev->sdt)	/* SDT can be found only in the cache */
3339		return ret == 0 ? -ENOENT : ret; /* Found in probe cache */
3340
3341	/* Convert perf_probe_event with debuginfo */
3342	ret = try_to_find_probe_trace_events(pev, tevs);
3343	if (ret != 0)
3344		return ret;	/* Found in debuginfo or got an error */
3345
3346	return find_probe_trace_events_from_map(pev, tevs);
3347}
3348
3349int convert_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3350{
3351	int i, ret;
3352
3353	/* Loop 1: convert all events */
3354	for (i = 0; i < npevs; i++) {
3355		/* Init kprobe blacklist if needed */
3356		if (!pevs[i].uprobes)
3357			kprobe_blacklist__init();
3358		/* Convert with or without debuginfo */
3359		ret  = convert_to_probe_trace_events(&pevs[i], &pevs[i].tevs);
3360		if (ret < 0)
3361			return ret;
3362		pevs[i].ntevs = ret;
3363	}
3364	/* This just release blacklist only if allocated */
3365	kprobe_blacklist__release();
3366
3367	return 0;
3368}
3369
3370static int show_probe_trace_event(struct probe_trace_event *tev)
3371{
3372	char *buf = synthesize_probe_trace_command(tev);
3373
3374	if (!buf) {
3375		pr_debug("Failed to synthesize probe trace event.\n");
3376		return -EINVAL;
 
 
3377	}
3378
3379	/* Showing definition always go stdout */
3380	printf("%s\n", buf);
3381	free(buf);
3382
3383	return 0;
 
 
 
3384}
3385
3386int show_probe_trace_events(struct perf_probe_event *pevs, int npevs)
 
3387{
3388	struct strlist *namelist = strlist__new(NULL, NULL);
3389	struct probe_trace_event *tev;
3390	struct perf_probe_event *pev;
3391	int i, j, ret = 0;
3392
3393	if (!namelist)
3394		return -ENOMEM;
3395
3396	for (j = 0; j < npevs && !ret; j++) {
3397		pev = &pevs[j];
3398		for (i = 0; i < pev->ntevs && !ret; i++) {
3399			tev = &pev->tevs[i];
3400			/* Skip if the symbol is out of .text or blacklisted */
3401			if (!tev->point.symbol && !pev->uprobes)
3402				continue;
3403
3404			/* Set new name for tev (and update namelist) */
3405			ret = probe_trace_event__set_name(tev, pev,
3406							  namelist, true);
3407			if (!ret)
3408				ret = show_probe_trace_event(tev);
3409		}
3410	}
3411	strlist__delete(namelist);
3412
3413	return ret;
3414}
3415
3416int apply_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3417{
3418	int i, ret = 0;
3419
3420	/* Loop 2: add all events */
3421	for (i = 0; i < npevs; i++) {
3422		ret = __add_probe_trace_events(&pevs[i], pevs[i].tevs,
3423					       pevs[i].ntevs,
3424					       probe_conf.force_add);
3425		if (ret < 0)
3426			break;
3427	}
3428	return ret;
3429}
3430
3431void cleanup_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3432{
3433	int i, j;
3434	struct perf_probe_event *pev;
 
 
 
 
3435
3436	/* Loop 3: cleanup and free trace events  */
3437	for (i = 0; i < npevs; i++) {
3438		pev = &pevs[i];
3439		for (j = 0; j < pevs[i].ntevs; j++)
3440			clear_probe_trace_event(&pevs[i].tevs[j]);
3441		zfree(&pevs[i].tevs);
3442		pevs[i].ntevs = 0;
3443		nsinfo__zput(pev->nsi);
3444		clear_perf_probe_event(&pevs[i]);
3445	}
3446}
3447
3448int add_perf_probe_events(struct perf_probe_event *pevs, int npevs)
3449{
3450	int ret;
3451
3452	ret = init_probe_symbol_maps(pevs->uprobes);
3453	if (ret < 0)
3454		return ret;
3455
3456	ret = convert_perf_probe_events(pevs, npevs);
3457	if (ret == 0)
3458		ret = apply_perf_probe_events(pevs, npevs);
3459
3460	cleanup_perf_probe_events(pevs, npevs);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3461
3462	exit_probe_symbol_maps();
3463	return ret;
3464}
 
 
 
3465
3466int del_perf_probe_events(struct strfilter *filter)
3467{
3468	int ret, ret2, ufd = -1, kfd = -1;
3469	char *str = strfilter__string(filter);
3470
3471	if (!str)
3472		return -EINVAL;
3473
3474	/* Get current event names */
3475	ret = probe_file__open_both(&kfd, &ufd, PF_FL_RW);
3476	if (ret < 0)
3477		goto out;
3478
3479	ret = probe_file__del_events(kfd, filter);
3480	if (ret < 0 && ret != -ENOENT)
3481		goto error;
3482
3483	ret2 = probe_file__del_events(ufd, filter);
3484	if (ret2 < 0 && ret2 != -ENOENT) {
3485		ret = ret2;
3486		goto error;
3487	}
3488	ret = 0;
3489
3490error:
3491	if (kfd >= 0)
 
3492		close(kfd);
3493	if (ufd >= 0)
 
 
 
3494		close(ufd);
3495out:
3496	free(str);
3497
3498	return ret;
3499}
3500
3501int show_available_funcs(const char *target, struct nsinfo *nsi,
3502			 struct strfilter *_filter, bool user)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
3503{
3504        struct rb_node *nd;
3505	struct map *map;
3506	int ret;
3507
3508	ret = init_probe_symbol_maps(user);
3509	if (ret < 0)
3510		return ret;
3511
3512	/* Get a symbol map */
3513	map = get_target_map(target, nsi, user);
 
 
 
3514	if (!map) {
3515		pr_err("Failed to get a map for %s\n", (target) ? : "kernel");
3516		return -EINVAL;
3517	}
3518
3519	ret = map__load(map);
3520	if (ret) {
3521		if (ret == -2) {
3522			char *str = strfilter__string(_filter);
3523			pr_err("Failed to find symbols matched to \"%s\"\n",
3524			       str);
3525			free(str);
3526		} else
3527			pr_err("Failed to load symbols in %s\n",
3528			       (target) ? : "kernel");
3529		goto end;
3530	}
3531	if (!dso__sorted_by_name(map->dso))
3532		dso__sort_by_name(map->dso);
3533
3534	/* Show all (filtered) symbols */
3535	setup_pager();
3536
3537	for (nd = rb_first_cached(&map->dso->symbol_names); nd;
3538	     nd = rb_next(nd)) {
3539		struct symbol_name_rb_node *pos = rb_entry(nd, struct symbol_name_rb_node, rb_node);
3540
3541		if (strfilter__compare(_filter, pos->sym.name))
3542			printf("%s\n", pos->sym.name);
3543	}
3544end:
3545	map__put(map);
3546	exit_probe_symbol_maps();
 
 
 
3547
3548	return ret;
3549}
3550
3551int copy_to_probe_trace_arg(struct probe_trace_arg *tvar,
3552			    struct perf_probe_arg *pvar)
3553{
3554	tvar->value = strdup(pvar->var);
3555	if (tvar->value == NULL)
3556		return -ENOMEM;
3557	if (pvar->type) {
3558		tvar->type = strdup(pvar->type);
3559		if (tvar->type == NULL)
3560			return -ENOMEM;
3561	}
3562	if (pvar->name) {
3563		tvar->name = strdup(pvar->name);
3564		if (tvar->name == NULL)
3565			return -ENOMEM;
3566	} else
3567		tvar->name = NULL;
3568	return 0;
3569}