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