1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * probe-finder.c : C expression to kprobe event 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 <dwarf-regs.h>
20 
21 #include <linux/bitops.h>
22 #include <linux/zalloc.h>
23 #include "event.h"
24 #include "dso.h"
25 #include "debug.h"
26 #include "intlist.h"
27 #include "strbuf.h"
28 #include "strlist.h"
29 #include "symbol.h"
30 #include "probe-finder.h"
31 #include "probe-file.h"
32 #include "string2.h"
33 
34 #ifdef HAVE_DEBUGINFOD_SUPPORT
35 #include <elfutils/debuginfod.h>
36 #endif
37 
38 /* Kprobe tracer basic type is up to u64 */
39 #define MAX_BASIC_TYPE_BITS	64
40 
41 /* Dwarf FL wrappers */
42 static char *debuginfo_path;	/* Currently dummy */
43 
44 static const Dwfl_Callbacks offline_callbacks = {
45 	.find_debuginfo = dwfl_standard_find_debuginfo,
46 	.debuginfo_path = &debuginfo_path,
47 
48 	.section_address = dwfl_offline_section_address,
49 
50 	/* We use this table for core files too.  */
51 	.find_elf = dwfl_build_id_find_elf,
52 };
53 
54 /* Get a Dwarf from offline image */
debuginfo__init_offline_dwarf(struct debuginfo * dbg,const char * path)55 static int debuginfo__init_offline_dwarf(struct debuginfo *dbg,
56 					 const char *path)
57 {
58 	GElf_Addr dummy;
59 	int fd;
60 
61 	fd = open(path, O_RDONLY);
62 	if (fd < 0)
63 		return fd;
64 
65 	dbg->dwfl = dwfl_begin(&offline_callbacks);
66 	if (!dbg->dwfl)
67 		goto error;
68 
69 	dwfl_report_begin(dbg->dwfl);
70 	dbg->mod = dwfl_report_offline(dbg->dwfl, "", "", fd);
71 	if (!dbg->mod)
72 		goto error;
73 
74 	dbg->dbg = dwfl_module_getdwarf(dbg->mod, &dbg->bias);
75 	if (!dbg->dbg)
76 		goto error;
77 
78 	dwfl_module_build_id(dbg->mod, &dbg->build_id, &dummy);
79 
80 	dwfl_report_end(dbg->dwfl, NULL, NULL);
81 
82 	return 0;
83 error:
84 	if (dbg->dwfl)
85 		dwfl_end(dbg->dwfl);
86 	else
87 		close(fd);
88 	memset(dbg, 0, sizeof(*dbg));
89 
90 	return -ENOENT;
91 }
92 
__debuginfo__new(const char * path)93 static struct debuginfo *__debuginfo__new(const char *path)
94 {
95 	struct debuginfo *dbg = zalloc(sizeof(*dbg));
96 	if (!dbg)
97 		return NULL;
98 
99 	if (debuginfo__init_offline_dwarf(dbg, path) < 0)
100 		zfree(&dbg);
101 	if (dbg)
102 		pr_debug("Open Debuginfo file: %s\n", path);
103 	return dbg;
104 }
105 
106 enum dso_binary_type distro_dwarf_types[] = {
107 	DSO_BINARY_TYPE__FEDORA_DEBUGINFO,
108 	DSO_BINARY_TYPE__UBUNTU_DEBUGINFO,
109 	DSO_BINARY_TYPE__OPENEMBEDDED_DEBUGINFO,
110 	DSO_BINARY_TYPE__BUILDID_DEBUGINFO,
111 	DSO_BINARY_TYPE__MIXEDUP_UBUNTU_DEBUGINFO,
112 	DSO_BINARY_TYPE__NOT_FOUND,
113 };
114 
debuginfo__new(const char * path)115 struct debuginfo *debuginfo__new(const char *path)
116 {
117 	enum dso_binary_type *type;
118 	char buf[PATH_MAX], nil = '\0';
119 	struct dso *dso;
120 	struct debuginfo *dinfo = NULL;
121 	struct build_id bid;
122 
123 	/* Try to open distro debuginfo files */
124 	dso = dso__new(path);
125 	if (!dso)
126 		goto out;
127 
128 	/* Set the build id for DSO_BINARY_TYPE__BUILDID_DEBUGINFO */
129 	if (is_regular_file(path) && filename__read_build_id(path, &bid) > 0)
130 		dso__set_build_id(dso, &bid);
131 
132 	for (type = distro_dwarf_types;
133 	     !dinfo && *type != DSO_BINARY_TYPE__NOT_FOUND;
134 	     type++) {
135 		if (dso__read_binary_type_filename(dso, *type, &nil,
136 						   buf, PATH_MAX) < 0)
137 			continue;
138 		dinfo = __debuginfo__new(buf);
139 	}
140 	dso__put(dso);
141 
142 out:
143 	/* if failed to open all distro debuginfo, open given binary */
144 	return dinfo ? : __debuginfo__new(path);
145 }
146 
debuginfo__delete(struct debuginfo * dbg)147 void debuginfo__delete(struct debuginfo *dbg)
148 {
149 	if (dbg) {
150 		if (dbg->dwfl)
151 			dwfl_end(dbg->dwfl);
152 		free(dbg);
153 	}
154 }
155 
156 /*
157  * Probe finder related functions
158  */
159 
alloc_trace_arg_ref(long offs)160 static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
161 {
162 	struct probe_trace_arg_ref *ref;
163 	ref = zalloc(sizeof(struct probe_trace_arg_ref));
164 	if (ref != NULL)
165 		ref->offset = offs;
166 	return ref;
167 }
168 
169 /*
170  * Convert a location into trace_arg.
171  * If tvar == NULL, this just checks variable can be converted.
172  * If fentry == true and vr_die is a parameter, do heuristic search
173  * for the location fuzzed by function entry mcount.
174  */
convert_variable_location(Dwarf_Die * vr_die,Dwarf_Addr addr,Dwarf_Op * fb_ops,Dwarf_Die * sp_die,unsigned int machine,struct probe_trace_arg * tvar)175 static int convert_variable_location(Dwarf_Die *vr_die, Dwarf_Addr addr,
176 				     Dwarf_Op *fb_ops, Dwarf_Die *sp_die,
177 				     unsigned int machine,
178 				     struct probe_trace_arg *tvar)
179 {
180 	Dwarf_Attribute attr;
181 	Dwarf_Addr tmp = 0;
182 	Dwarf_Op *op;
183 	size_t nops;
184 	unsigned int regn;
185 	Dwarf_Word offs = 0;
186 	bool ref = false;
187 	const char *regs;
188 	int ret, ret2 = 0;
189 
190 	if (dwarf_attr(vr_die, DW_AT_external, &attr) != NULL)
191 		goto static_var;
192 
193 	/* Constant value */
194 	if (dwarf_attr(vr_die, DW_AT_const_value, &attr) &&
195 	    immediate_value_is_supported()) {
196 		Dwarf_Sword snum;
197 
198 		if (!tvar)
199 			return 0;
200 
201 		dwarf_formsdata(&attr, &snum);
202 		ret = asprintf(&tvar->value, "\\%ld", (long)snum);
203 
204 		return ret < 0 ? -ENOMEM : 0;
205 	}
206 
207 	/* TODO: handle more than 1 exprs */
208 	if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
209 		return -EINVAL;	/* Broken DIE ? */
210 	if (dwarf_getlocation_addr(&attr, addr, &op, &nops, 1) <= 0) {
211 		ret = dwarf_entrypc(sp_die, &tmp);
212 		if (ret)
213 			return -ENOENT;
214 
215 		if (probe_conf.show_location_range &&
216 			(dwarf_tag(vr_die) == DW_TAG_variable)) {
217 			ret2 = -ERANGE;
218 		} else if (addr != tmp ||
219 			dwarf_tag(vr_die) != DW_TAG_formal_parameter) {
220 			return -ENOENT;
221 		}
222 
223 		ret = dwarf_highpc(sp_die, &tmp);
224 		if (ret)
225 			return -ENOENT;
226 		/*
227 		 * This is fuzzed by fentry mcount. We try to find the
228 		 * parameter location at the earliest address.
229 		 */
230 		for (addr += 1; addr <= tmp; addr++) {
231 			if (dwarf_getlocation_addr(&attr, addr, &op,
232 						   &nops, 1) > 0)
233 				goto found;
234 		}
235 		return -ENOENT;
236 	}
237 found:
238 	if (nops == 0)
239 		/* TODO: Support const_value */
240 		return -ENOENT;
241 
242 	if (op->atom == DW_OP_addr) {
243 static_var:
244 		if (!tvar)
245 			return ret2;
246 		/* Static variables on memory (not stack), make @varname */
247 		ret = strlen(dwarf_diename(vr_die));
248 		tvar->value = zalloc(ret + 2);
249 		if (tvar->value == NULL)
250 			return -ENOMEM;
251 		snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
252 		tvar->ref = alloc_trace_arg_ref((long)offs);
253 		if (tvar->ref == NULL)
254 			return -ENOMEM;
255 		return ret2;
256 	}
257 
258 	/* If this is based on frame buffer, set the offset */
259 	if (op->atom == DW_OP_fbreg) {
260 		if (fb_ops == NULL)
261 			return -ENOTSUP;
262 		ref = true;
263 		offs = op->number;
264 		op = &fb_ops[0];
265 	}
266 
267 	if (op->atom >= DW_OP_breg0 && op->atom <= DW_OP_breg31) {
268 		regn = op->atom - DW_OP_breg0;
269 		offs += op->number;
270 		ref = true;
271 	} else if (op->atom >= DW_OP_reg0 && op->atom <= DW_OP_reg31) {
272 		regn = op->atom - DW_OP_reg0;
273 	} else if (op->atom == DW_OP_bregx) {
274 		regn = op->number;
275 		offs += op->number2;
276 		ref = true;
277 	} else if (op->atom == DW_OP_regx) {
278 		regn = op->number;
279 	} else {
280 		pr_debug("DW_OP %x is not supported.\n", op->atom);
281 		return -ENOTSUP;
282 	}
283 
284 	if (!tvar)
285 		return ret2;
286 
287 	regs = get_dwarf_regstr(regn, machine);
288 	if (!regs) {
289 		/* This should be a bug in DWARF or this tool */
290 		pr_warning("Mapping for the register number %u "
291 			   "missing on this architecture.\n", regn);
292 		return -ENOTSUP;
293 	}
294 
295 	tvar->value = strdup(regs);
296 	if (tvar->value == NULL)
297 		return -ENOMEM;
298 
299 	if (ref) {
300 		tvar->ref = alloc_trace_arg_ref((long)offs);
301 		if (tvar->ref == NULL)
302 			return -ENOMEM;
303 	}
304 	return ret2;
305 }
306 
307 #define BYTES_TO_BITS(nb)	((nb) * BITS_PER_LONG / sizeof(long))
308 
convert_variable_type(Dwarf_Die * vr_die,struct probe_trace_arg * tvar,const char * cast,bool user_access)309 static int convert_variable_type(Dwarf_Die *vr_die,
310 				 struct probe_trace_arg *tvar,
311 				 const char *cast, bool user_access)
312 {
313 	struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
314 	Dwarf_Die type;
315 	char buf[16];
316 	char sbuf[STRERR_BUFSIZE];
317 	int bsize, boffs, total;
318 	int ret;
319 	char prefix;
320 
321 	/* TODO: check all types */
322 	if (cast && strcmp(cast, "string") != 0 && strcmp(cast, "ustring") &&
323 	    strcmp(cast, "x") != 0 &&
324 	    strcmp(cast, "s") != 0 && strcmp(cast, "u") != 0) {
325 		/* Non string type is OK */
326 		/* and respect signedness/hexadecimal cast */
327 		tvar->type = strdup(cast);
328 		return (tvar->type == NULL) ? -ENOMEM : 0;
329 	}
330 
331 	bsize = dwarf_bitsize(vr_die);
332 	if (bsize > 0) {
333 		/* This is a bitfield */
334 		boffs = dwarf_bitoffset(vr_die);
335 		total = dwarf_bytesize(vr_die);
336 		if (boffs < 0 || total < 0)
337 			return -ENOENT;
338 		ret = snprintf(buf, 16, "b%d@%d/%zd", bsize, boffs,
339 				BYTES_TO_BITS(total));
340 		goto formatted;
341 	}
342 
343 	if (die_get_real_type(vr_die, &type) == NULL) {
344 		pr_warning("Failed to get a type information of %s.\n",
345 			   dwarf_diename(vr_die));
346 		return -ENOENT;
347 	}
348 
349 	pr_debug("%s type is %s.\n",
350 		 dwarf_diename(vr_die), dwarf_diename(&type));
351 
352 	if (cast && (!strcmp(cast, "string") || !strcmp(cast, "ustring"))) {
353 		/* String type */
354 		ret = dwarf_tag(&type);
355 		if (ret != DW_TAG_pointer_type &&
356 		    ret != DW_TAG_array_type) {
357 			pr_warning("Failed to cast into string: "
358 				   "%s(%s) is not a pointer nor array.\n",
359 				   dwarf_diename(vr_die), dwarf_diename(&type));
360 			return -EINVAL;
361 		}
362 		if (die_get_real_type(&type, &type) == NULL) {
363 			pr_warning("Failed to get a type"
364 				   " information.\n");
365 			return -ENOENT;
366 		}
367 		if (ret == DW_TAG_pointer_type) {
368 			while (*ref_ptr)
369 				ref_ptr = &(*ref_ptr)->next;
370 			/* Add new reference with offset +0 */
371 			*ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
372 			if (*ref_ptr == NULL) {
373 				pr_warning("Out of memory error\n");
374 				return -ENOMEM;
375 			}
376 			(*ref_ptr)->user_access = user_access;
377 		}
378 		if (!die_compare_name(&type, "char") &&
379 		    !die_compare_name(&type, "unsigned char")) {
380 			pr_warning("Failed to cast into string: "
381 				   "%s is not (unsigned) char *.\n",
382 				   dwarf_diename(vr_die));
383 			return -EINVAL;
384 		}
385 		tvar->type = strdup(cast);
386 		return (tvar->type == NULL) ? -ENOMEM : 0;
387 	}
388 
389 	if (cast && (strcmp(cast, "u") == 0))
390 		prefix = 'u';
391 	else if (cast && (strcmp(cast, "s") == 0))
392 		prefix = 's';
393 	else if (cast && (strcmp(cast, "x") == 0) &&
394 		 probe_type_is_available(PROBE_TYPE_X))
395 		prefix = 'x';
396 	else
397 		prefix = die_is_signed_type(&type) ? 's' :
398 			 probe_type_is_available(PROBE_TYPE_X) ? 'x' : 'u';
399 
400 	ret = dwarf_bytesize(&type);
401 	if (ret <= 0)
402 		/* No size ... try to use default type */
403 		return 0;
404 	ret = BYTES_TO_BITS(ret);
405 
406 	/* Check the bitwidth */
407 	if (ret > MAX_BASIC_TYPE_BITS) {
408 		pr_info("%s exceeds max-bitwidth. Cut down to %d bits.\n",
409 			dwarf_diename(&type), MAX_BASIC_TYPE_BITS);
410 		ret = MAX_BASIC_TYPE_BITS;
411 	}
412 	ret = snprintf(buf, 16, "%c%d", prefix, ret);
413 
414 formatted:
415 	if (ret < 0 || ret >= 16) {
416 		if (ret >= 16)
417 			ret = -E2BIG;
418 		pr_warning("Failed to convert variable type: %s\n",
419 			   str_error_r(-ret, sbuf, sizeof(sbuf)));
420 		return ret;
421 	}
422 	tvar->type = strdup(buf);
423 	if (tvar->type == NULL)
424 		return -ENOMEM;
425 	return 0;
426 }
427 
convert_variable_fields(Dwarf_Die * vr_die,const char * varname,struct perf_probe_arg_field * field,struct probe_trace_arg_ref ** ref_ptr,Dwarf_Die * die_mem,bool user_access)428 static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
429 				    struct perf_probe_arg_field *field,
430 				    struct probe_trace_arg_ref **ref_ptr,
431 				    Dwarf_Die *die_mem, bool user_access)
432 {
433 	struct probe_trace_arg_ref *ref = *ref_ptr;
434 	Dwarf_Die type;
435 	Dwarf_Word offs;
436 	int ret, tag;
437 
438 	pr_debug("converting %s in %s\n", field->name, varname);
439 	if (die_get_real_type(vr_die, &type) == NULL) {
440 		pr_warning("Failed to get the type of %s.\n", varname);
441 		return -ENOENT;
442 	}
443 	pr_debug2("Var real type: %s (%x)\n", dwarf_diename(&type),
444 		  (unsigned)dwarf_dieoffset(&type));
445 	tag = dwarf_tag(&type);
446 
447 	if (field->name[0] == '[' &&
448 	    (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
449 		/* Save original type for next field or type */
450 		memcpy(die_mem, &type, sizeof(*die_mem));
451 		/* Get the type of this array */
452 		if (die_get_real_type(&type, &type) == NULL) {
453 			pr_warning("Failed to get the type of %s.\n", varname);
454 			return -ENOENT;
455 		}
456 		pr_debug2("Array real type: %s (%x)\n", dwarf_diename(&type),
457 			 (unsigned)dwarf_dieoffset(&type));
458 		if (tag == DW_TAG_pointer_type) {
459 			ref = zalloc(sizeof(struct probe_trace_arg_ref));
460 			if (ref == NULL)
461 				return -ENOMEM;
462 			if (*ref_ptr)
463 				(*ref_ptr)->next = ref;
464 			else
465 				*ref_ptr = ref;
466 		}
467 		ref->offset += dwarf_bytesize(&type) * field->index;
468 		ref->user_access = user_access;
469 		goto next;
470 	} else if (tag == DW_TAG_pointer_type) {
471 		/* Check the pointer and dereference */
472 		if (!field->ref) {
473 			pr_err("Semantic error: %s must be referred by '->'\n",
474 			       field->name);
475 			return -EINVAL;
476 		}
477 		/* Get the type pointed by this pointer */
478 		if (die_get_real_type(&type, &type) == NULL) {
479 			pr_warning("Failed to get the type of %s.\n", varname);
480 			return -ENOENT;
481 		}
482 		/* Verify it is a data structure  */
483 		tag = dwarf_tag(&type);
484 		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
485 			pr_warning("%s is not a data structure nor a union.\n",
486 				   varname);
487 			return -EINVAL;
488 		}
489 
490 		ref = zalloc(sizeof(struct probe_trace_arg_ref));
491 		if (ref == NULL)
492 			return -ENOMEM;
493 		if (*ref_ptr)
494 			(*ref_ptr)->next = ref;
495 		else
496 			*ref_ptr = ref;
497 	} else {
498 		/* Verify it is a data structure  */
499 		if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
500 			pr_warning("%s is not a data structure nor a union.\n",
501 				   varname);
502 			return -EINVAL;
503 		}
504 		if (field->name[0] == '[') {
505 			pr_err("Semantic error: %s is not a pointer"
506 			       " nor array.\n", varname);
507 			return -EINVAL;
508 		}
509 		/* While processing unnamed field, we don't care about this */
510 		if (field->ref && dwarf_diename(vr_die)) {
511 			pr_err("Semantic error: %s must be referred by '.'\n",
512 			       field->name);
513 			return -EINVAL;
514 		}
515 		if (!ref) {
516 			pr_warning("Structure on a register is not "
517 				   "supported yet.\n");
518 			return -ENOTSUP;
519 		}
520 	}
521 
522 	if (die_find_member(&type, field->name, die_mem) == NULL) {
523 		pr_warning("%s(type:%s) has no member %s.\n", varname,
524 			   dwarf_diename(&type), field->name);
525 		return -EINVAL;
526 	}
527 
528 	/* Get the offset of the field */
529 	if (tag == DW_TAG_union_type) {
530 		offs = 0;
531 	} else {
532 		ret = die_get_data_member_location(die_mem, &offs);
533 		if (ret < 0) {
534 			pr_warning("Failed to get the offset of %s.\n",
535 				   field->name);
536 			return ret;
537 		}
538 	}
539 	ref->offset += (long)offs;
540 	ref->user_access = user_access;
541 
542 	/* If this member is unnamed, we need to reuse this field */
543 	if (!dwarf_diename(die_mem))
544 		return convert_variable_fields(die_mem, varname, field,
545 						&ref, die_mem, user_access);
546 
547 next:
548 	/* Converting next field */
549 	if (field->next)
550 		return convert_variable_fields(die_mem, field->name,
551 				field->next, &ref, die_mem, user_access);
552 	else
553 		return 0;
554 }
555 
print_var_not_found(const char * varname)556 static void print_var_not_found(const char *varname)
557 {
558 	pr_err("Failed to find the location of the '%s' variable at this address.\n"
559 	       " Perhaps it has been optimized out.\n"
560 	       " Use -V with the --range option to show '%s' location range.\n",
561 		varname, varname);
562 }
563 
564 /* Show a variables in kprobe event format */
convert_variable(Dwarf_Die * vr_die,struct probe_finder * pf)565 static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
566 {
567 	Dwarf_Die die_mem;
568 	int ret;
569 
570 	pr_debug("Converting variable %s into trace event.\n",
571 		 dwarf_diename(vr_die));
572 
573 	ret = convert_variable_location(vr_die, pf->addr, pf->fb_ops,
574 					&pf->sp_die, pf->machine, pf->tvar);
575 	if (ret == -ENOENT && pf->skip_empty_arg)
576 		/* This can be found in other place. skip it */
577 		return 0;
578 	if (ret == -ENOENT || ret == -EINVAL) {
579 		print_var_not_found(pf->pvar->var);
580 	} else if (ret == -ENOTSUP)
581 		pr_err("Sorry, we don't support this variable location yet.\n");
582 	else if (ret == 0 && pf->pvar->field) {
583 		ret = convert_variable_fields(vr_die, pf->pvar->var,
584 					      pf->pvar->field, &pf->tvar->ref,
585 					      &die_mem, pf->pvar->user_access);
586 		vr_die = &die_mem;
587 	}
588 	if (ret == 0)
589 		ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type,
590 					    pf->pvar->user_access);
591 	/* *expr will be cached in libdw. Don't free it. */
592 	return ret;
593 }
594 
595 /* Find a variable in a scope DIE */
find_variable(Dwarf_Die * sc_die,struct probe_finder * pf)596 static int find_variable(Dwarf_Die *sc_die, struct probe_finder *pf)
597 {
598 	Dwarf_Die vr_die;
599 	char *buf, *ptr;
600 	int ret = 0;
601 
602 	/* Copy raw parameters */
603 	if (!is_c_varname(pf->pvar->var))
604 		return copy_to_probe_trace_arg(pf->tvar, pf->pvar);
605 
606 	if (pf->pvar->name)
607 		pf->tvar->name = strdup(pf->pvar->name);
608 	else {
609 		buf = synthesize_perf_probe_arg(pf->pvar);
610 		if (!buf)
611 			return -ENOMEM;
612 		ptr = strchr(buf, ':');	/* Change type separator to _ */
613 		if (ptr)
614 			*ptr = '_';
615 		pf->tvar->name = buf;
616 	}
617 	if (pf->tvar->name == NULL)
618 		return -ENOMEM;
619 
620 	pr_debug("Searching '%s' variable in context.\n", pf->pvar->var);
621 	/* Search child die for local variables and parameters. */
622 	if (!die_find_variable_at(sc_die, pf->pvar->var, pf->addr, &vr_die)) {
623 		/* Search again in global variables */
624 		if (!die_find_variable_at(&pf->cu_die, pf->pvar->var,
625 						0, &vr_die)) {
626 			if (pf->skip_empty_arg)
627 				return 0;
628 			pr_warning("Failed to find '%s' in this function.\n",
629 				   pf->pvar->var);
630 			ret = -ENOENT;
631 		}
632 	}
633 	if (ret >= 0)
634 		ret = convert_variable(&vr_die, pf);
635 
636 	return ret;
637 }
638 
639 /* Convert subprogram DIE to trace point */
convert_to_trace_point(Dwarf_Die * sp_die,Dwfl_Module * mod,Dwarf_Addr paddr,bool retprobe,const char * function,struct probe_trace_point * tp)640 static int convert_to_trace_point(Dwarf_Die *sp_die, Dwfl_Module *mod,
641 				  Dwarf_Addr paddr, bool retprobe,
642 				  const char *function,
643 				  struct probe_trace_point *tp)
644 {
645 	Dwarf_Addr eaddr;
646 	GElf_Sym sym;
647 	const char *symbol;
648 
649 	/* Verify the address is correct */
650 	if (!dwarf_haspc(sp_die, paddr)) {
651 		pr_warning("Specified offset is out of %s\n",
652 			   dwarf_diename(sp_die));
653 		return -EINVAL;
654 	}
655 
656 	if (dwarf_entrypc(sp_die, &eaddr) == 0) {
657 		/* If the DIE has entrypc, use it. */
658 		symbol = dwarf_diename(sp_die);
659 	} else {
660 		/* Try to get actual symbol name and address from symtab */
661 		symbol = dwfl_module_addrsym(mod, paddr, &sym, NULL);
662 		eaddr = sym.st_value;
663 	}
664 	if (!symbol) {
665 		pr_warning("Failed to find symbol at 0x%lx\n",
666 			   (unsigned long)paddr);
667 		return -ENOENT;
668 	}
669 
670 	tp->offset = (unsigned long)(paddr - eaddr);
671 	tp->address = paddr;
672 	tp->symbol = strdup(symbol);
673 	if (!tp->symbol)
674 		return -ENOMEM;
675 
676 	/* Return probe must be on the head of a subprogram */
677 	if (retprobe) {
678 		if (eaddr != paddr) {
679 			pr_warning("Failed to find \"%s%%return\",\n"
680 				   " because %s is an inlined function and"
681 				   " has no return point.\n", function,
682 				   function);
683 			return -EINVAL;
684 		}
685 		tp->retprobe = true;
686 	}
687 
688 	return 0;
689 }
690 
691 /* Call probe_finder callback with scope DIE */
call_probe_finder(Dwarf_Die * sc_die,struct probe_finder * pf)692 static int call_probe_finder(Dwarf_Die *sc_die, struct probe_finder *pf)
693 {
694 	Dwarf_Attribute fb_attr;
695 	Dwarf_Frame *frame = NULL;
696 	size_t nops;
697 	int ret;
698 
699 	if (!sc_die) {
700 		pr_err("Caller must pass a scope DIE. Program error.\n");
701 		return -EINVAL;
702 	}
703 
704 	/* If not a real subprogram, find a real one */
705 	if (!die_is_func_def(sc_die)) {
706 		if (!die_find_realfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
707 			if (die_find_tailfunc(&pf->cu_die, pf->addr, &pf->sp_die)) {
708 				pr_warning("Ignoring tail call from %s\n",
709 						dwarf_diename(&pf->sp_die));
710 				return 0;
711 			} else {
712 				pr_warning("Failed to find probe point in any "
713 					   "functions.\n");
714 				return -ENOENT;
715 			}
716 		}
717 	} else
718 		memcpy(&pf->sp_die, sc_die, sizeof(Dwarf_Die));
719 
720 	/* Get the frame base attribute/ops from subprogram */
721 	dwarf_attr(&pf->sp_die, DW_AT_frame_base, &fb_attr);
722 	ret = dwarf_getlocation_addr(&fb_attr, pf->addr, &pf->fb_ops, &nops, 1);
723 	if (ret <= 0 || nops == 0) {
724 		pf->fb_ops = NULL;
725 #if _ELFUTILS_PREREQ(0, 142)
726 	} else if (nops == 1 && pf->fb_ops[0].atom == DW_OP_call_frame_cfa &&
727 		   (pf->cfi_eh != NULL || pf->cfi_dbg != NULL)) {
728 		if ((dwarf_cfi_addrframe(pf->cfi_eh, pf->addr, &frame) != 0 &&
729 		     (dwarf_cfi_addrframe(pf->cfi_dbg, pf->addr, &frame) != 0)) ||
730 		    dwarf_frame_cfa(frame, &pf->fb_ops, &nops) != 0) {
731 			pr_warning("Failed to get call frame on 0x%jx\n",
732 				   (uintmax_t)pf->addr);
733 			free(frame);
734 			return -ENOENT;
735 		}
736 #endif
737 	}
738 
739 	/* Call finder's callback handler */
740 	ret = pf->callback(sc_die, pf);
741 
742 	/* Since *pf->fb_ops can be a part of frame. we should free it here. */
743 	free(frame);
744 	pf->fb_ops = NULL;
745 
746 	return ret;
747 }
748 
749 struct find_scope_param {
750 	const char *function;
751 	const char *file;
752 	int line;
753 	int diff;
754 	Dwarf_Die *die_mem;
755 	bool found;
756 };
757 
find_best_scope_cb(Dwarf_Die * fn_die,void * data)758 static int find_best_scope_cb(Dwarf_Die *fn_die, void *data)
759 {
760 	struct find_scope_param *fsp = data;
761 	const char *file;
762 	int lno;
763 
764 	/* Skip if declared file name does not match */
765 	if (fsp->file) {
766 		file = die_get_decl_file(fn_die);
767 		if (!file || strcmp(fsp->file, file) != 0)
768 			return 0;
769 	}
770 	/* If the function name is given, that's what user expects */
771 	if (fsp->function) {
772 		if (die_match_name(fn_die, fsp->function)) {
773 			memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
774 			fsp->found = true;
775 			return 1;
776 		}
777 	} else {
778 		/* With the line number, find the nearest declared DIE */
779 		dwarf_decl_line(fn_die, &lno);
780 		if (lno < fsp->line && fsp->diff > fsp->line - lno) {
781 			/* Keep a candidate and continue */
782 			fsp->diff = fsp->line - lno;
783 			memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
784 			fsp->found = true;
785 		}
786 	}
787 	return 0;
788 }
789 
790 /* Return innermost DIE */
find_inner_scope_cb(Dwarf_Die * fn_die,void * data)791 static int find_inner_scope_cb(Dwarf_Die *fn_die, void *data)
792 {
793 	struct find_scope_param *fsp = data;
794 
795 	memcpy(fsp->die_mem, fn_die, sizeof(Dwarf_Die));
796 	fsp->found = true;
797 	return 1;
798 }
799 
800 /* Find an appropriate scope fits to given conditions */
find_best_scope(struct probe_finder * pf,Dwarf_Die * die_mem)801 static Dwarf_Die *find_best_scope(struct probe_finder *pf, Dwarf_Die *die_mem)
802 {
803 	struct find_scope_param fsp = {
804 		.function = pf->pev->point.function,
805 		.file = pf->fname,
806 		.line = pf->lno,
807 		.diff = INT_MAX,
808 		.die_mem = die_mem,
809 		.found = false,
810 	};
811 	int ret;
812 
813 	ret = cu_walk_functions_at(&pf->cu_die, pf->addr, find_best_scope_cb,
814 				   &fsp);
815 	if (!ret && !fsp.found)
816 		cu_walk_functions_at(&pf->cu_die, pf->addr,
817 				     find_inner_scope_cb, &fsp);
818 
819 	return fsp.found ? die_mem : NULL;
820 }
821 
verify_representive_line(struct probe_finder * pf,const char * fname,int lineno,Dwarf_Addr addr)822 static int verify_representive_line(struct probe_finder *pf, const char *fname,
823 				int lineno, Dwarf_Addr addr)
824 {
825 	const char *__fname, *__func = NULL;
826 	Dwarf_Die die_mem;
827 	int __lineno;
828 
829 	/* Verify line number and address by reverse search */
830 	if (cu_find_lineinfo(&pf->cu_die, addr, &__fname, &__lineno) < 0)
831 		return 0;
832 
833 	pr_debug2("Reversed line: %s:%d\n", __fname, __lineno);
834 	if (strcmp(fname, __fname) || lineno == __lineno)
835 		return 0;
836 
837 	pr_warning("This line is sharing the address with other lines.\n");
838 
839 	if (pf->pev->point.function) {
840 		/* Find best match function name and lines */
841 		pf->addr = addr;
842 		if (find_best_scope(pf, &die_mem)
843 		    && die_match_name(&die_mem, pf->pev->point.function)
844 		    && dwarf_decl_line(&die_mem, &lineno) == 0) {
845 			__func = dwarf_diename(&die_mem);
846 			__lineno -= lineno;
847 		}
848 	}
849 	pr_warning("Please try to probe at %s:%d instead.\n",
850 		   __func ? : __fname, __lineno);
851 
852 	return -ENOENT;
853 }
854 
probe_point_line_walker(const char * fname,int lineno,Dwarf_Addr addr,void * data)855 static int probe_point_line_walker(const char *fname, int lineno,
856 				   Dwarf_Addr addr, void *data)
857 {
858 	struct probe_finder *pf = data;
859 	Dwarf_Die *sc_die, die_mem;
860 	int ret;
861 
862 	if (lineno != pf->lno || strtailcmp(fname, pf->fname) != 0)
863 		return 0;
864 
865 	if (verify_representive_line(pf, fname, lineno, addr))
866 		return -ENOENT;
867 
868 	pf->addr = addr;
869 	sc_die = find_best_scope(pf, &die_mem);
870 	if (!sc_die) {
871 		pr_warning("Failed to find scope of probe point.\n");
872 		return -ENOENT;
873 	}
874 
875 	ret = call_probe_finder(sc_die, pf);
876 
877 	/* Continue if no error, because the line will be in inline function */
878 	return ret < 0 ? ret : 0;
879 }
880 
881 /* Find probe point from its line number */
find_probe_point_by_line(struct probe_finder * pf)882 static int find_probe_point_by_line(struct probe_finder *pf)
883 {
884 	return die_walk_lines(&pf->cu_die, probe_point_line_walker, pf);
885 }
886 
887 /* Find lines which match lazy pattern */
find_lazy_match_lines(struct intlist * list,const char * fname,const char * pat)888 static int find_lazy_match_lines(struct intlist *list,
889 				 const char *fname, const char *pat)
890 {
891 	FILE *fp;
892 	char *line = NULL;
893 	size_t line_len;
894 	ssize_t len;
895 	int count = 0, linenum = 1;
896 	char sbuf[STRERR_BUFSIZE];
897 
898 	fp = fopen(fname, "r");
899 	if (!fp) {
900 		pr_warning("Failed to open %s: %s\n", fname,
901 			   str_error_r(errno, sbuf, sizeof(sbuf)));
902 		return -errno;
903 	}
904 
905 	while ((len = getline(&line, &line_len, fp)) > 0) {
906 
907 		if (line[len - 1] == '\n')
908 			line[len - 1] = '\0';
909 
910 		if (strlazymatch(line, pat)) {
911 			intlist__add(list, linenum);
912 			count++;
913 		}
914 		linenum++;
915 	}
916 
917 	if (ferror(fp))
918 		count = -errno;
919 	free(line);
920 	fclose(fp);
921 
922 	if (count == 0)
923 		pr_debug("No matched lines found in %s.\n", fname);
924 	return count;
925 }
926 
probe_point_lazy_walker(const char * fname,int lineno,Dwarf_Addr addr,void * data)927 static int probe_point_lazy_walker(const char *fname, int lineno,
928 				   Dwarf_Addr addr, void *data)
929 {
930 	struct probe_finder *pf = data;
931 	Dwarf_Die *sc_die, die_mem;
932 	int ret;
933 
934 	if (!intlist__has_entry(pf->lcache, lineno) ||
935 	    strtailcmp(fname, pf->fname) != 0)
936 		return 0;
937 
938 	pr_debug("Probe line found: line:%d addr:0x%llx\n",
939 		 lineno, (unsigned long long)addr);
940 	pf->addr = addr;
941 	pf->lno = lineno;
942 	sc_die = find_best_scope(pf, &die_mem);
943 	if (!sc_die) {
944 		pr_warning("Failed to find scope of probe point.\n");
945 		return -ENOENT;
946 	}
947 
948 	ret = call_probe_finder(sc_die, pf);
949 
950 	/*
951 	 * Continue if no error, because the lazy pattern will match
952 	 * to other lines
953 	 */
954 	return ret < 0 ? ret : 0;
955 }
956 
957 /* Find probe points from lazy pattern  */
find_probe_point_lazy(Dwarf_Die * sp_die,struct probe_finder * pf)958 static int find_probe_point_lazy(Dwarf_Die *sp_die, struct probe_finder *pf)
959 {
960 	struct build_id bid;
961 	char sbuild_id[SBUILD_ID_SIZE] = "";
962 	int ret = 0;
963 	char *fpath;
964 
965 	if (intlist__empty(pf->lcache)) {
966 		const char *comp_dir;
967 
968 		comp_dir = cu_get_comp_dir(&pf->cu_die);
969 		if (pf->dbg->build_id) {
970 			build_id__init(&bid, pf->dbg->build_id, BUILD_ID_SIZE);
971 			build_id__sprintf(&bid, sbuild_id);
972 		}
973 		ret = find_source_path(pf->fname, sbuild_id, comp_dir, &fpath);
974 		if (ret < 0) {
975 			pr_warning("Failed to find source file path.\n");
976 			return ret;
977 		}
978 
979 		/* Matching lazy line pattern */
980 		ret = find_lazy_match_lines(pf->lcache, fpath,
981 					    pf->pev->point.lazy_line);
982 		free(fpath);
983 		if (ret <= 0)
984 			return ret;
985 	}
986 
987 	return die_walk_lines(sp_die, probe_point_lazy_walker, pf);
988 }
989 
skip_prologue(Dwarf_Die * sp_die,struct probe_finder * pf)990 static void skip_prologue(Dwarf_Die *sp_die, struct probe_finder *pf)
991 {
992 	struct perf_probe_point *pp = &pf->pev->point;
993 
994 	/* Not uprobe? */
995 	if (!pf->pev->uprobes)
996 		return;
997 
998 	/* Compiled with optimization? */
999 	if (die_is_optimized_target(&pf->cu_die))
1000 		return;
1001 
1002 	/* Don't know entrypc? */
1003 	if (!pf->addr)
1004 		return;
1005 
1006 	/* Only FUNC and FUNC@SRC are eligible. */
1007 	if (!pp->function || pp->line || pp->retprobe || pp->lazy_line ||
1008 	    pp->offset || pp->abs_address)
1009 		return;
1010 
1011 	/* Not interested in func parameter? */
1012 	if (!perf_probe_with_var(pf->pev))
1013 		return;
1014 
1015 	pr_info("Target program is compiled without optimization. Skipping prologue.\n"
1016 		"Probe on address 0x%" PRIx64 " to force probing at the function entry.\n\n",
1017 		pf->addr);
1018 
1019 	die_skip_prologue(sp_die, &pf->cu_die, &pf->addr);
1020 }
1021 
probe_point_inline_cb(Dwarf_Die * in_die,void * data)1022 static int probe_point_inline_cb(Dwarf_Die *in_die, void *data)
1023 {
1024 	struct probe_finder *pf = data;
1025 	struct perf_probe_point *pp = &pf->pev->point;
1026 	Dwarf_Addr addr;
1027 	int ret;
1028 
1029 	if (pp->lazy_line)
1030 		ret = find_probe_point_lazy(in_die, pf);
1031 	else {
1032 		/* Get probe address */
1033 		if (die_entrypc(in_die, &addr) != 0) {
1034 			pr_warning("Failed to get entry address of %s.\n",
1035 				   dwarf_diename(in_die));
1036 			return -ENOENT;
1037 		}
1038 		if (addr == 0) {
1039 			pr_debug("%s has no valid entry address. skipped.\n",
1040 				 dwarf_diename(in_die));
1041 			return -ENOENT;
1042 		}
1043 		pf->addr = addr;
1044 		pf->addr += pp->offset;
1045 		pr_debug("found inline addr: 0x%jx\n",
1046 			 (uintmax_t)pf->addr);
1047 
1048 		ret = call_probe_finder(in_die, pf);
1049 	}
1050 
1051 	return ret;
1052 }
1053 
1054 /* Callback parameter with return value for libdw */
1055 struct dwarf_callback_param {
1056 	void *data;
1057 	int retval;
1058 };
1059 
1060 /* Search function from function name */
probe_point_search_cb(Dwarf_Die * sp_die,void * data)1061 static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
1062 {
1063 	struct dwarf_callback_param *param = data;
1064 	struct probe_finder *pf = param->data;
1065 	struct perf_probe_point *pp = &pf->pev->point;
1066 	const char *fname;
1067 
1068 	/* Check tag and diename */
1069 	if (!die_is_func_def(sp_die) ||
1070 	    !die_match_name(sp_die, pp->function))
1071 		return DWARF_CB_OK;
1072 
1073 	/* Check declared file */
1074 	fname = die_get_decl_file(sp_die);
1075 	if (!fname) {
1076 		pr_warning("A function DIE doesn't have decl_line. Maybe broken DWARF?\n");
1077 		return DWARF_CB_OK;
1078 	}
1079 	if (pp->file && fname && strtailcmp(pp->file, fname))
1080 		return DWARF_CB_OK;
1081 
1082 	pr_debug("Matched function: %s [%lx]\n", dwarf_diename(sp_die),
1083 		 (unsigned long)dwarf_dieoffset(sp_die));
1084 	pf->fname = fname;
1085 	if (pp->line) { /* Function relative line */
1086 		dwarf_decl_line(sp_die, &pf->lno);
1087 		pf->lno += pp->line;
1088 		param->retval = find_probe_point_by_line(pf);
1089 	} else if (die_is_func_instance(sp_die)) {
1090 		/* Instances always have the entry address */
1091 		die_entrypc(sp_die, &pf->addr);
1092 		/* But in some case the entry address is 0 */
1093 		if (pf->addr == 0) {
1094 			pr_debug("%s has no entry PC. Skipped\n",
1095 				 dwarf_diename(sp_die));
1096 			param->retval = 0;
1097 		/* Real function */
1098 		} else if (pp->lazy_line)
1099 			param->retval = find_probe_point_lazy(sp_die, pf);
1100 		else {
1101 			skip_prologue(sp_die, pf);
1102 			pf->addr += pp->offset;
1103 			/* TODO: Check the address in this function */
1104 			param->retval = call_probe_finder(sp_die, pf);
1105 		}
1106 	} else if (!probe_conf.no_inlines) {
1107 		/* Inlined function: search instances */
1108 		param->retval = die_walk_instances(sp_die,
1109 					probe_point_inline_cb, (void *)pf);
1110 		/* This could be a non-existed inline definition */
1111 		if (param->retval == -ENOENT)
1112 			param->retval = 0;
1113 	}
1114 
1115 	/* We need to find other candidates */
1116 	if (strisglob(pp->function) && param->retval >= 0) {
1117 		param->retval = 0;	/* We have to clear the result */
1118 		return DWARF_CB_OK;
1119 	}
1120 
1121 	return DWARF_CB_ABORT; /* Exit; no same symbol in this CU. */
1122 }
1123 
find_probe_point_by_func(struct probe_finder * pf)1124 static int find_probe_point_by_func(struct probe_finder *pf)
1125 {
1126 	struct dwarf_callback_param _param = {.data = (void *)pf,
1127 					      .retval = 0};
1128 	dwarf_getfuncs(&pf->cu_die, probe_point_search_cb, &_param, 0);
1129 	return _param.retval;
1130 }
1131 
1132 struct pubname_callback_param {
1133 	char *function;
1134 	char *file;
1135 	Dwarf_Die *cu_die;
1136 	Dwarf_Die *sp_die;
1137 	int found;
1138 };
1139 
pubname_search_cb(Dwarf * dbg,Dwarf_Global * gl,void * data)1140 static int pubname_search_cb(Dwarf *dbg, Dwarf_Global *gl, void *data)
1141 {
1142 	struct pubname_callback_param *param = data;
1143 	const char *fname;
1144 
1145 	if (dwarf_offdie(dbg, gl->die_offset, param->sp_die)) {
1146 		if (dwarf_tag(param->sp_die) != DW_TAG_subprogram)
1147 			return DWARF_CB_OK;
1148 
1149 		if (die_match_name(param->sp_die, param->function)) {
1150 			if (!dwarf_offdie(dbg, gl->cu_offset, param->cu_die))
1151 				return DWARF_CB_OK;
1152 
1153 			if (param->file) {
1154 				fname = die_get_decl_file(param->sp_die);
1155 				if (!fname || strtailcmp(param->file, fname))
1156 					return DWARF_CB_OK;
1157 			}
1158 
1159 			param->found = 1;
1160 			return DWARF_CB_ABORT;
1161 		}
1162 	}
1163 
1164 	return DWARF_CB_OK;
1165 }
1166 
debuginfo__find_probe_location(struct debuginfo * dbg,struct probe_finder * pf)1167 static int debuginfo__find_probe_location(struct debuginfo *dbg,
1168 				  struct probe_finder *pf)
1169 {
1170 	struct perf_probe_point *pp = &pf->pev->point;
1171 	Dwarf_Off off, noff;
1172 	size_t cuhl;
1173 	Dwarf_Die *diep;
1174 	int ret = 0;
1175 
1176 	off = 0;
1177 	pf->lcache = intlist__new(NULL);
1178 	if (!pf->lcache)
1179 		return -ENOMEM;
1180 
1181 	/* Fastpath: lookup by function name from .debug_pubnames section */
1182 	if (pp->function && !strisglob(pp->function)) {
1183 		struct pubname_callback_param pubname_param = {
1184 			.function = pp->function,
1185 			.file	  = pp->file,
1186 			.cu_die	  = &pf->cu_die,
1187 			.sp_die	  = &pf->sp_die,
1188 			.found	  = 0,
1189 		};
1190 		struct dwarf_callback_param probe_param = {
1191 			.data = pf,
1192 		};
1193 
1194 		dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1195 				  &pubname_param, 0);
1196 		if (pubname_param.found) {
1197 			ret = probe_point_search_cb(&pf->sp_die, &probe_param);
1198 			if (ret)
1199 				goto found;
1200 		}
1201 	}
1202 
1203 	/* Loop on CUs (Compilation Unit) */
1204 	while (!dwarf_nextcu(dbg->dbg, off, &noff, &cuhl, NULL, NULL, NULL)) {
1205 		/* Get the DIE(Debugging Information Entry) of this CU */
1206 		diep = dwarf_offdie(dbg->dbg, off + cuhl, &pf->cu_die);
1207 		if (!diep) {
1208 			off = noff;
1209 			continue;
1210 		}
1211 
1212 		/* Check if target file is included. */
1213 		if (pp->file)
1214 			pf->fname = cu_find_realpath(&pf->cu_die, pp->file);
1215 		else
1216 			pf->fname = NULL;
1217 
1218 		if (!pp->file || pf->fname) {
1219 			if (pp->function)
1220 				ret = find_probe_point_by_func(pf);
1221 			else if (pp->lazy_line)
1222 				ret = find_probe_point_lazy(&pf->cu_die, pf);
1223 			else {
1224 				pf->lno = pp->line;
1225 				ret = find_probe_point_by_line(pf);
1226 			}
1227 			if (ret < 0)
1228 				break;
1229 		}
1230 		off = noff;
1231 	}
1232 
1233 found:
1234 	intlist__delete(pf->lcache);
1235 	pf->lcache = NULL;
1236 
1237 	return ret;
1238 }
1239 
1240 /* Find probe points from debuginfo */
debuginfo__find_probes(struct debuginfo * dbg,struct probe_finder * pf)1241 static int debuginfo__find_probes(struct debuginfo *dbg,
1242 				  struct probe_finder *pf)
1243 {
1244 	int ret = 0;
1245 	Elf *elf;
1246 	GElf_Ehdr ehdr;
1247 
1248 	if (pf->cfi_eh || pf->cfi_dbg)
1249 		return debuginfo__find_probe_location(dbg, pf);
1250 
1251 	/* Get the call frame information from this dwarf */
1252 	elf = dwarf_getelf(dbg->dbg);
1253 	if (elf == NULL)
1254 		return -EINVAL;
1255 
1256 	if (gelf_getehdr(elf, &ehdr) == NULL)
1257 		return -EINVAL;
1258 
1259 	pf->machine = ehdr.e_machine;
1260 
1261 #if _ELFUTILS_PREREQ(0, 142)
1262 	do {
1263 		GElf_Shdr shdr;
1264 
1265 		if (elf_section_by_name(elf, &ehdr, &shdr, ".eh_frame", NULL) &&
1266 		    shdr.sh_type == SHT_PROGBITS)
1267 			pf->cfi_eh = dwarf_getcfi_elf(elf);
1268 
1269 		pf->cfi_dbg = dwarf_getcfi(dbg->dbg);
1270 	} while (0);
1271 #endif
1272 
1273 	ret = debuginfo__find_probe_location(dbg, pf);
1274 	return ret;
1275 }
1276 
1277 struct local_vars_finder {
1278 	struct probe_finder *pf;
1279 	struct perf_probe_arg *args;
1280 	bool vars;
1281 	int max_args;
1282 	int nargs;
1283 	int ret;
1284 };
1285 
1286 /* Collect available variables in this scope */
copy_variables_cb(Dwarf_Die * die_mem,void * data)1287 static int copy_variables_cb(Dwarf_Die *die_mem, void *data)
1288 {
1289 	struct local_vars_finder *vf = data;
1290 	struct probe_finder *pf = vf->pf;
1291 	int tag;
1292 
1293 	tag = dwarf_tag(die_mem);
1294 	if (tag == DW_TAG_formal_parameter ||
1295 	    (tag == DW_TAG_variable && vf->vars)) {
1296 		if (convert_variable_location(die_mem, vf->pf->addr,
1297 					      vf->pf->fb_ops, &pf->sp_die,
1298 					      pf->machine, NULL) == 0) {
1299 			vf->args[vf->nargs].var = (char *)dwarf_diename(die_mem);
1300 			if (vf->args[vf->nargs].var == NULL) {
1301 				vf->ret = -ENOMEM;
1302 				return DIE_FIND_CB_END;
1303 			}
1304 			pr_debug(" %s", vf->args[vf->nargs].var);
1305 			vf->nargs++;
1306 		}
1307 	}
1308 
1309 	if (dwarf_haspc(die_mem, vf->pf->addr))
1310 		return DIE_FIND_CB_CONTINUE;
1311 	else
1312 		return DIE_FIND_CB_SIBLING;
1313 }
1314 
expand_probe_args(Dwarf_Die * sc_die,struct probe_finder * pf,struct perf_probe_arg * args)1315 static int expand_probe_args(Dwarf_Die *sc_die, struct probe_finder *pf,
1316 			     struct perf_probe_arg *args)
1317 {
1318 	Dwarf_Die die_mem;
1319 	int i;
1320 	int n = 0;
1321 	struct local_vars_finder vf = {.pf = pf, .args = args, .vars = false,
1322 				.max_args = MAX_PROBE_ARGS, .ret = 0};
1323 
1324 	for (i = 0; i < pf->pev->nargs; i++) {
1325 		/* var never be NULL */
1326 		if (strcmp(pf->pev->args[i].var, PROBE_ARG_VARS) == 0)
1327 			vf.vars = true;
1328 		else if (strcmp(pf->pev->args[i].var, PROBE_ARG_PARAMS) != 0) {
1329 			/* Copy normal argument */
1330 			args[n] = pf->pev->args[i];
1331 			n++;
1332 			continue;
1333 		}
1334 		pr_debug("Expanding %s into:", pf->pev->args[i].var);
1335 		vf.nargs = n;
1336 		/* Special local variables */
1337 		die_find_child(sc_die, copy_variables_cb, (void *)&vf,
1338 			       &die_mem);
1339 		pr_debug(" (%d)\n", vf.nargs - n);
1340 		if (vf.ret < 0)
1341 			return vf.ret;
1342 		n = vf.nargs;
1343 	}
1344 	return n;
1345 }
1346 
trace_event_finder_overlap(struct trace_event_finder * tf)1347 static bool trace_event_finder_overlap(struct trace_event_finder *tf)
1348 {
1349 	int i;
1350 
1351 	for (i = 0; i < tf->ntevs; i++) {
1352 		if (tf->pf.addr == tf->tevs[i].point.address)
1353 			return true;
1354 	}
1355 	return false;
1356 }
1357 
1358 /* Add a found probe point into trace event list */
add_probe_trace_event(Dwarf_Die * sc_die,struct probe_finder * pf)1359 static int add_probe_trace_event(Dwarf_Die *sc_die, struct probe_finder *pf)
1360 {
1361 	struct trace_event_finder *tf =
1362 			container_of(pf, struct trace_event_finder, pf);
1363 	struct perf_probe_point *pp = &pf->pev->point;
1364 	struct probe_trace_event *tev;
1365 	struct perf_probe_arg *args = NULL;
1366 	int ret, i;
1367 
1368 	/*
1369 	 * For some reason (e.g. different column assigned to same address)
1370 	 * This callback can be called with the address which already passed.
1371 	 * Ignore it first.
1372 	 */
1373 	if (trace_event_finder_overlap(tf))
1374 		return 0;
1375 
1376 	/* Check number of tevs */
1377 	if (tf->ntevs == tf->max_tevs) {
1378 		pr_warning("Too many( > %d) probe point found.\n",
1379 			   tf->max_tevs);
1380 		return -ERANGE;
1381 	}
1382 	tev = &tf->tevs[tf->ntevs++];
1383 
1384 	/* Trace point should be converted from subprogram DIE */
1385 	ret = convert_to_trace_point(&pf->sp_die, tf->mod, pf->addr,
1386 				     pp->retprobe, pp->function, &tev->point);
1387 	if (ret < 0)
1388 		goto end;
1389 
1390 	tev->point.realname = strdup(dwarf_diename(sc_die));
1391 	if (!tev->point.realname) {
1392 		ret = -ENOMEM;
1393 		goto end;
1394 	}
1395 
1396 	pr_debug("Probe point found: %s+%lu\n", tev->point.symbol,
1397 		 tev->point.offset);
1398 
1399 	/* Expand special probe argument if exist */
1400 	args = zalloc(sizeof(struct perf_probe_arg) * MAX_PROBE_ARGS);
1401 	if (args == NULL) {
1402 		ret = -ENOMEM;
1403 		goto end;
1404 	}
1405 
1406 	ret = expand_probe_args(sc_die, pf, args);
1407 	if (ret < 0)
1408 		goto end;
1409 
1410 	tev->nargs = ret;
1411 	tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
1412 	if (tev->args == NULL) {
1413 		ret = -ENOMEM;
1414 		goto end;
1415 	}
1416 
1417 	/* Find each argument */
1418 	for (i = 0; i < tev->nargs; i++) {
1419 		pf->pvar = &args[i];
1420 		pf->tvar = &tev->args[i];
1421 		/* Variable should be found from scope DIE */
1422 		ret = find_variable(sc_die, pf);
1423 		if (ret != 0)
1424 			break;
1425 	}
1426 
1427 end:
1428 	if (ret) {
1429 		clear_probe_trace_event(tev);
1430 		tf->ntevs--;
1431 	}
1432 	free(args);
1433 	return ret;
1434 }
1435 
fill_empty_trace_arg(struct perf_probe_event * pev,struct probe_trace_event * tevs,int ntevs)1436 static int fill_empty_trace_arg(struct perf_probe_event *pev,
1437 				struct probe_trace_event *tevs, int ntevs)
1438 {
1439 	char **valp;
1440 	char *type;
1441 	int i, j, ret;
1442 
1443 	if (!ntevs)
1444 		return -ENOENT;
1445 
1446 	for (i = 0; i < pev->nargs; i++) {
1447 		type = NULL;
1448 		for (j = 0; j < ntevs; j++) {
1449 			if (tevs[j].args[i].value) {
1450 				type = tevs[j].args[i].type;
1451 				break;
1452 			}
1453 		}
1454 		if (j == ntevs) {
1455 			print_var_not_found(pev->args[i].var);
1456 			return -ENOENT;
1457 		}
1458 		for (j = 0; j < ntevs; j++) {
1459 			valp = &tevs[j].args[i].value;
1460 			if (*valp)
1461 				continue;
1462 
1463 			ret = asprintf(valp, "\\%lx", probe_conf.magic_num);
1464 			if (ret < 0)
1465 				return -ENOMEM;
1466 			/* Note that type can be NULL */
1467 			if (type) {
1468 				tevs[j].args[i].type = strdup(type);
1469 				if (!tevs[j].args[i].type)
1470 					return -ENOMEM;
1471 			}
1472 		}
1473 	}
1474 	return 0;
1475 }
1476 
1477 /* Find probe_trace_events specified by perf_probe_event from debuginfo */
debuginfo__find_trace_events(struct debuginfo * dbg,struct perf_probe_event * pev,struct probe_trace_event ** tevs)1478 int debuginfo__find_trace_events(struct debuginfo *dbg,
1479 				 struct perf_probe_event *pev,
1480 				 struct probe_trace_event **tevs)
1481 {
1482 	struct trace_event_finder tf = {
1483 			.pf = {.pev = pev, .dbg = dbg, .callback = add_probe_trace_event},
1484 			.max_tevs = probe_conf.max_probes, .mod = dbg->mod};
1485 	int ret, i;
1486 
1487 	/* Allocate result tevs array */
1488 	*tevs = zalloc(sizeof(struct probe_trace_event) * tf.max_tevs);
1489 	if (*tevs == NULL)
1490 		return -ENOMEM;
1491 
1492 	tf.tevs = *tevs;
1493 	tf.ntevs = 0;
1494 
1495 	if (pev->nargs != 0 && immediate_value_is_supported())
1496 		tf.pf.skip_empty_arg = true;
1497 
1498 	ret = debuginfo__find_probes(dbg, &tf.pf);
1499 	if (ret >= 0 && tf.pf.skip_empty_arg)
1500 		ret = fill_empty_trace_arg(pev, tf.tevs, tf.ntevs);
1501 
1502 	if (ret < 0 || tf.ntevs == 0) {
1503 		for (i = 0; i < tf.ntevs; i++)
1504 			clear_probe_trace_event(&tf.tevs[i]);
1505 		zfree(tevs);
1506 		return ret;
1507 	}
1508 
1509 	return (ret < 0) ? ret : tf.ntevs;
1510 }
1511 
1512 /* Collect available variables in this scope */
collect_variables_cb(Dwarf_Die * die_mem,void * data)1513 static int collect_variables_cb(Dwarf_Die *die_mem, void *data)
1514 {
1515 	struct available_var_finder *af = data;
1516 	struct variable_list *vl;
1517 	struct strbuf buf = STRBUF_INIT;
1518 	int tag, ret;
1519 
1520 	vl = &af->vls[af->nvls - 1];
1521 
1522 	tag = dwarf_tag(die_mem);
1523 	if (tag == DW_TAG_formal_parameter ||
1524 	    tag == DW_TAG_variable) {
1525 		ret = convert_variable_location(die_mem, af->pf.addr,
1526 						af->pf.fb_ops, &af->pf.sp_die,
1527 						af->pf.machine, NULL);
1528 		if (ret == 0 || ret == -ERANGE) {
1529 			int ret2;
1530 			bool externs = !af->child;
1531 
1532 			if (strbuf_init(&buf, 64) < 0)
1533 				goto error;
1534 
1535 			if (probe_conf.show_location_range) {
1536 				if (!externs)
1537 					ret2 = strbuf_add(&buf,
1538 						ret ? "[INV]\t" : "[VAL]\t", 6);
1539 				else
1540 					ret2 = strbuf_add(&buf, "[EXT]\t", 6);
1541 				if (ret2)
1542 					goto error;
1543 			}
1544 
1545 			ret2 = die_get_varname(die_mem, &buf);
1546 
1547 			if (!ret2 && probe_conf.show_location_range &&
1548 				!externs) {
1549 				if (strbuf_addch(&buf, '\t') < 0)
1550 					goto error;
1551 				ret2 = die_get_var_range(&af->pf.sp_die,
1552 							die_mem, &buf);
1553 			}
1554 
1555 			pr_debug("Add new var: %s\n", buf.buf);
1556 			if (ret2 == 0) {
1557 				strlist__add(vl->vars,
1558 					strbuf_detach(&buf, NULL));
1559 			}
1560 			strbuf_release(&buf);
1561 		}
1562 	}
1563 
1564 	if (af->child && dwarf_haspc(die_mem, af->pf.addr))
1565 		return DIE_FIND_CB_CONTINUE;
1566 	else
1567 		return DIE_FIND_CB_SIBLING;
1568 error:
1569 	strbuf_release(&buf);
1570 	pr_debug("Error in strbuf\n");
1571 	return DIE_FIND_CB_END;
1572 }
1573 
available_var_finder_overlap(struct available_var_finder * af)1574 static bool available_var_finder_overlap(struct available_var_finder *af)
1575 {
1576 	int i;
1577 
1578 	for (i = 0; i < af->nvls; i++) {
1579 		if (af->pf.addr == af->vls[i].point.address)
1580 			return true;
1581 	}
1582 	return false;
1583 
1584 }
1585 
1586 /* Add a found vars into available variables list */
add_available_vars(Dwarf_Die * sc_die,struct probe_finder * pf)1587 static int add_available_vars(Dwarf_Die *sc_die, struct probe_finder *pf)
1588 {
1589 	struct available_var_finder *af =
1590 			container_of(pf, struct available_var_finder, pf);
1591 	struct perf_probe_point *pp = &pf->pev->point;
1592 	struct variable_list *vl;
1593 	Dwarf_Die die_mem;
1594 	int ret;
1595 
1596 	/*
1597 	 * For some reason (e.g. different column assigned to same address),
1598 	 * this callback can be called with the address which already passed.
1599 	 * Ignore it first.
1600 	 */
1601 	if (available_var_finder_overlap(af))
1602 		return 0;
1603 
1604 	/* Check number of tevs */
1605 	if (af->nvls == af->max_vls) {
1606 		pr_warning("Too many( > %d) probe point found.\n", af->max_vls);
1607 		return -ERANGE;
1608 	}
1609 	vl = &af->vls[af->nvls++];
1610 
1611 	/* Trace point should be converted from subprogram DIE */
1612 	ret = convert_to_trace_point(&pf->sp_die, af->mod, pf->addr,
1613 				     pp->retprobe, pp->function, &vl->point);
1614 	if (ret < 0)
1615 		return ret;
1616 
1617 	pr_debug("Probe point found: %s+%lu\n", vl->point.symbol,
1618 		 vl->point.offset);
1619 
1620 	/* Find local variables */
1621 	vl->vars = strlist__new(NULL, NULL);
1622 	if (vl->vars == NULL)
1623 		return -ENOMEM;
1624 	af->child = true;
1625 	die_find_child(sc_die, collect_variables_cb, (void *)af, &die_mem);
1626 
1627 	/* Find external variables */
1628 	if (!probe_conf.show_ext_vars)
1629 		goto out;
1630 	/* Don't need to search child DIE for external vars. */
1631 	af->child = false;
1632 	die_find_child(&pf->cu_die, collect_variables_cb, (void *)af, &die_mem);
1633 
1634 out:
1635 	if (strlist__empty(vl->vars)) {
1636 		strlist__delete(vl->vars);
1637 		vl->vars = NULL;
1638 	}
1639 
1640 	return ret;
1641 }
1642 
1643 /*
1644  * Find available variables at given probe point
1645  * Return the number of found probe points. Return 0 if there is no
1646  * matched probe point. Return <0 if an error occurs.
1647  */
debuginfo__find_available_vars_at(struct debuginfo * dbg,struct perf_probe_event * pev,struct variable_list ** vls)1648 int debuginfo__find_available_vars_at(struct debuginfo *dbg,
1649 				      struct perf_probe_event *pev,
1650 				      struct variable_list **vls)
1651 {
1652 	struct available_var_finder af = {
1653 			.pf = {.pev = pev, .dbg = dbg, .callback = add_available_vars},
1654 			.mod = dbg->mod,
1655 			.max_vls = probe_conf.max_probes};
1656 	int ret;
1657 
1658 	/* Allocate result vls array */
1659 	*vls = zalloc(sizeof(struct variable_list) * af.max_vls);
1660 	if (*vls == NULL)
1661 		return -ENOMEM;
1662 
1663 	af.vls = *vls;
1664 	af.nvls = 0;
1665 
1666 	ret = debuginfo__find_probes(dbg, &af.pf);
1667 	if (ret < 0) {
1668 		/* Free vlist for error */
1669 		while (af.nvls--) {
1670 			zfree(&af.vls[af.nvls].point.symbol);
1671 			strlist__delete(af.vls[af.nvls].vars);
1672 		}
1673 		zfree(vls);
1674 		return ret;
1675 	}
1676 
1677 	return (ret < 0) ? ret : af.nvls;
1678 }
1679 
1680 /* For the kernel module, we need a special code to get a DIE */
debuginfo__get_text_offset(struct debuginfo * dbg,Dwarf_Addr * offs,bool adjust_offset)1681 int debuginfo__get_text_offset(struct debuginfo *dbg, Dwarf_Addr *offs,
1682 				bool adjust_offset)
1683 {
1684 	int n, i;
1685 	Elf32_Word shndx;
1686 	Elf_Scn *scn;
1687 	Elf *elf;
1688 	GElf_Shdr mem, *shdr;
1689 	const char *p;
1690 
1691 	elf = dwfl_module_getelf(dbg->mod, &dbg->bias);
1692 	if (!elf)
1693 		return -EINVAL;
1694 
1695 	/* Get the number of relocations */
1696 	n = dwfl_module_relocations(dbg->mod);
1697 	if (n < 0)
1698 		return -ENOENT;
1699 	/* Search the relocation related .text section */
1700 	for (i = 0; i < n; i++) {
1701 		p = dwfl_module_relocation_info(dbg->mod, i, &shndx);
1702 		if (strcmp(p, ".text") == 0) {
1703 			/* OK, get the section header */
1704 			scn = elf_getscn(elf, shndx);
1705 			if (!scn)
1706 				return -ENOENT;
1707 			shdr = gelf_getshdr(scn, &mem);
1708 			if (!shdr)
1709 				return -ENOENT;
1710 			*offs = shdr->sh_addr;
1711 			if (adjust_offset)
1712 				*offs -= shdr->sh_offset;
1713 		}
1714 	}
1715 	return 0;
1716 }
1717 
1718 /* Reverse search */
debuginfo__find_probe_point(struct debuginfo * dbg,u64 addr,struct perf_probe_point * ppt)1719 int debuginfo__find_probe_point(struct debuginfo *dbg, u64 addr,
1720 				struct perf_probe_point *ppt)
1721 {
1722 	Dwarf_Die cudie, spdie, indie;
1723 	Dwarf_Addr _addr = 0, baseaddr = 0;
1724 	const char *fname = NULL, *func = NULL, *basefunc = NULL, *tmp;
1725 	int baseline = 0, lineno = 0, ret = 0;
1726 
1727 	/* We always need to relocate the address for aranges */
1728 	if (debuginfo__get_text_offset(dbg, &baseaddr, false) == 0)
1729 		addr += baseaddr;
1730 	/* Find cu die */
1731 	if (!dwarf_addrdie(dbg->dbg, (Dwarf_Addr)addr, &cudie)) {
1732 		pr_warning("Failed to find debug information for address %#" PRIx64 "\n",
1733 			   addr);
1734 		ret = -EINVAL;
1735 		goto end;
1736 	}
1737 
1738 	/* Find a corresponding line (filename and lineno) */
1739 	cu_find_lineinfo(&cudie, (Dwarf_Addr)addr, &fname, &lineno);
1740 	/* Don't care whether it failed or not */
1741 
1742 	/* Find a corresponding function (name, baseline and baseaddr) */
1743 	if (die_find_realfunc(&cudie, (Dwarf_Addr)addr, &spdie)) {
1744 		/* Get function entry information */
1745 		func = basefunc = dwarf_diename(&spdie);
1746 		if (!func ||
1747 		    die_entrypc(&spdie, &baseaddr) != 0 ||
1748 		    dwarf_decl_line(&spdie, &baseline) != 0) {
1749 			lineno = 0;
1750 			goto post;
1751 		}
1752 
1753 		fname = die_get_decl_file(&spdie);
1754 		if (addr == baseaddr) {
1755 			/* Function entry - Relative line number is 0 */
1756 			lineno = baseline;
1757 			goto post;
1758 		}
1759 
1760 		/* Track down the inline functions step by step */
1761 		while (die_find_top_inlinefunc(&spdie, (Dwarf_Addr)addr,
1762 						&indie)) {
1763 			/* There is an inline function */
1764 			if (die_entrypc(&indie, &_addr) == 0 &&
1765 			    _addr == addr) {
1766 				/*
1767 				 * addr is at an inline function entry.
1768 				 * In this case, lineno should be the call-site
1769 				 * line number. (overwrite lineinfo)
1770 				 */
1771 				lineno = die_get_call_lineno(&indie);
1772 				fname = die_get_call_file(&indie);
1773 				break;
1774 			} else {
1775 				/*
1776 				 * addr is in an inline function body.
1777 				 * Since lineno points one of the lines
1778 				 * of the inline function, baseline should
1779 				 * be the entry line of the inline function.
1780 				 */
1781 				tmp = dwarf_diename(&indie);
1782 				if (!tmp ||
1783 				    dwarf_decl_line(&indie, &baseline) != 0)
1784 					break;
1785 				func = tmp;
1786 				spdie = indie;
1787 			}
1788 		}
1789 		/* Verify the lineno and baseline are in a same file */
1790 		tmp = die_get_decl_file(&spdie);
1791 		if (!tmp || (fname && strcmp(tmp, fname) != 0))
1792 			lineno = 0;
1793 	}
1794 
1795 post:
1796 	/* Make a relative line number or an offset */
1797 	if (lineno)
1798 		ppt->line = lineno - baseline;
1799 	else if (basefunc) {
1800 		ppt->offset = addr - baseaddr;
1801 		func = basefunc;
1802 	}
1803 
1804 	/* Duplicate strings */
1805 	if (func) {
1806 		ppt->function = strdup(func);
1807 		if (ppt->function == NULL) {
1808 			ret = -ENOMEM;
1809 			goto end;
1810 		}
1811 	}
1812 	if (fname) {
1813 		ppt->file = strdup(fname);
1814 		if (ppt->file == NULL) {
1815 			zfree(&ppt->function);
1816 			ret = -ENOMEM;
1817 			goto end;
1818 		}
1819 	}
1820 end:
1821 	if (ret == 0 && (fname || func))
1822 		ret = 1;	/* Found a point */
1823 	return ret;
1824 }
1825 
1826 /* Add a line and store the src path */
line_range_add_line(const char * src,unsigned int lineno,struct line_range * lr)1827 static int line_range_add_line(const char *src, unsigned int lineno,
1828 			       struct line_range *lr)
1829 {
1830 	/* Copy source path */
1831 	if (!lr->path) {
1832 		lr->path = strdup(src);
1833 		if (lr->path == NULL)
1834 			return -ENOMEM;
1835 	}
1836 	return intlist__add(lr->line_list, lineno);
1837 }
1838 
line_range_walk_cb(const char * fname,int lineno,Dwarf_Addr addr,void * data)1839 static int line_range_walk_cb(const char *fname, int lineno,
1840 			      Dwarf_Addr addr, void *data)
1841 {
1842 	struct line_finder *lf = data;
1843 	const char *__fname;
1844 	int __lineno;
1845 	int err;
1846 
1847 	if ((strtailcmp(fname, lf->fname) != 0) ||
1848 	    (lf->lno_s > lineno || lf->lno_e < lineno))
1849 		return 0;
1850 
1851 	/* Make sure this line can be reversible */
1852 	if (cu_find_lineinfo(&lf->cu_die, addr, &__fname, &__lineno) > 0
1853 	    && (lineno != __lineno || strcmp(fname, __fname)))
1854 		return 0;
1855 
1856 	err = line_range_add_line(fname, lineno, lf->lr);
1857 	if (err < 0 && err != -EEXIST)
1858 		return err;
1859 
1860 	return 0;
1861 }
1862 
1863 /* Find line range from its line number */
find_line_range_by_line(Dwarf_Die * sp_die,struct line_finder * lf)1864 static int find_line_range_by_line(Dwarf_Die *sp_die, struct line_finder *lf)
1865 {
1866 	int ret;
1867 
1868 	ret = die_walk_lines(sp_die ?: &lf->cu_die, line_range_walk_cb, lf);
1869 
1870 	/* Update status */
1871 	if (ret >= 0)
1872 		if (!intlist__empty(lf->lr->line_list))
1873 			ret = lf->found = 1;
1874 		else
1875 			ret = 0;	/* Lines are not found */
1876 	else {
1877 		zfree(&lf->lr->path);
1878 	}
1879 	return ret;
1880 }
1881 
line_range_inline_cb(Dwarf_Die * in_die,void * data)1882 static int line_range_inline_cb(Dwarf_Die *in_die, void *data)
1883 {
1884 	int ret = find_line_range_by_line(in_die, data);
1885 
1886 	/*
1887 	 * We have to check all instances of inlined function, because
1888 	 * some execution paths can be optimized out depends on the
1889 	 * function argument of instances. However, if an error occurs,
1890 	 * it should be handled by the caller.
1891 	 */
1892 	return ret < 0 ? ret : 0;
1893 }
1894 
1895 /* Search function definition from function name */
line_range_search_cb(Dwarf_Die * sp_die,void * data)1896 static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
1897 {
1898 	struct dwarf_callback_param *param = data;
1899 	struct line_finder *lf = param->data;
1900 	struct line_range *lr = lf->lr;
1901 	const char *fname;
1902 
1903 	/* Check declared file */
1904 	if (lr->file) {
1905 		fname = die_get_decl_file(sp_die);
1906 		if (!fname || strtailcmp(lr->file, fname))
1907 			return DWARF_CB_OK;
1908 	}
1909 
1910 	if (die_match_name(sp_die, lr->function) && die_is_func_def(sp_die)) {
1911 		lf->fname = die_get_decl_file(sp_die);
1912 		dwarf_decl_line(sp_die, &lr->offset);
1913 		pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
1914 		lf->lno_s = lr->offset + lr->start;
1915 		if (lf->lno_s < 0)	/* Overflow */
1916 			lf->lno_s = INT_MAX;
1917 		lf->lno_e = lr->offset + lr->end;
1918 		if (lf->lno_e < 0)	/* Overflow */
1919 			lf->lno_e = INT_MAX;
1920 		pr_debug("New line range: %d to %d\n", lf->lno_s, lf->lno_e);
1921 		lr->start = lf->lno_s;
1922 		lr->end = lf->lno_e;
1923 		if (!die_is_func_instance(sp_die))
1924 			param->retval = die_walk_instances(sp_die,
1925 						line_range_inline_cb, lf);
1926 		else
1927 			param->retval = find_line_range_by_line(sp_die, lf);
1928 		return DWARF_CB_ABORT;
1929 	}
1930 	return DWARF_CB_OK;
1931 }
1932 
find_line_range_by_func(struct line_finder * lf)1933 static int find_line_range_by_func(struct line_finder *lf)
1934 {
1935 	struct dwarf_callback_param param = {.data = (void *)lf, .retval = 0};
1936 	dwarf_getfuncs(&lf->cu_die, line_range_search_cb, &param, 0);
1937 	return param.retval;
1938 }
1939 
debuginfo__find_line_range(struct debuginfo * dbg,struct line_range * lr)1940 int debuginfo__find_line_range(struct debuginfo *dbg, struct line_range *lr)
1941 {
1942 	struct line_finder lf = {.lr = lr, .found = 0};
1943 	int ret = 0;
1944 	Dwarf_Off off = 0, noff;
1945 	size_t cuhl;
1946 	Dwarf_Die *diep;
1947 	const char *comp_dir;
1948 
1949 	/* Fastpath: lookup by function name from .debug_pubnames section */
1950 	if (lr->function) {
1951 		struct pubname_callback_param pubname_param = {
1952 			.function = lr->function, .file = lr->file,
1953 			.cu_die = &lf.cu_die, .sp_die = &lf.sp_die, .found = 0};
1954 		struct dwarf_callback_param line_range_param = {
1955 			.data = (void *)&lf, .retval = 0};
1956 
1957 		dwarf_getpubnames(dbg->dbg, pubname_search_cb,
1958 				  &pubname_param, 0);
1959 		if (pubname_param.found) {
1960 			line_range_search_cb(&lf.sp_die, &line_range_param);
1961 			if (lf.found)
1962 				goto found;
1963 		}
1964 	}
1965 
1966 	/* Loop on CUs (Compilation Unit) */
1967 	while (!lf.found && ret >= 0) {
1968 		if (dwarf_nextcu(dbg->dbg, off, &noff, &cuhl,
1969 				 NULL, NULL, NULL) != 0)
1970 			break;
1971 
1972 		/* Get the DIE(Debugging Information Entry) of this CU */
1973 		diep = dwarf_offdie(dbg->dbg, off + cuhl, &lf.cu_die);
1974 		if (!diep) {
1975 			off = noff;
1976 			continue;
1977 		}
1978 
1979 		/* Check if target file is included. */
1980 		if (lr->file)
1981 			lf.fname = cu_find_realpath(&lf.cu_die, lr->file);
1982 		else
1983 			lf.fname = 0;
1984 
1985 		if (!lr->file || lf.fname) {
1986 			if (lr->function)
1987 				ret = find_line_range_by_func(&lf);
1988 			else {
1989 				lf.lno_s = lr->start;
1990 				lf.lno_e = lr->end;
1991 				ret = find_line_range_by_line(NULL, &lf);
1992 			}
1993 		}
1994 		off = noff;
1995 	}
1996 
1997 found:
1998 	/* Store comp_dir */
1999 	if (lf.found) {
2000 		comp_dir = cu_get_comp_dir(&lf.cu_die);
2001 		if (comp_dir) {
2002 			lr->comp_dir = strdup(comp_dir);
2003 			if (!lr->comp_dir)
2004 				ret = -ENOMEM;
2005 		}
2006 	}
2007 
2008 	pr_debug("path: %s\n", lr->path);
2009 	return (ret < 0) ? ret : lf.found;
2010 }
2011 
2012 #ifdef HAVE_DEBUGINFOD_SUPPORT
2013 /* debuginfod doesn't require the comp_dir but buildid is required */
get_source_from_debuginfod(const char * raw_path,const char * sbuild_id,char ** new_path)2014 static int get_source_from_debuginfod(const char *raw_path,
2015 				const char *sbuild_id, char **new_path)
2016 {
2017 	debuginfod_client *c = debuginfod_begin();
2018 	const char *p = raw_path;
2019 	int fd;
2020 
2021 	if (!c)
2022 		return -ENOMEM;
2023 
2024 	fd = debuginfod_find_source(c, (const unsigned char *)sbuild_id,
2025 				0, p, new_path);
2026 	pr_debug("Search %s from debuginfod -> %d\n", p, fd);
2027 	if (fd >= 0)
2028 		close(fd);
2029 	debuginfod_end(c);
2030 	if (fd < 0) {
2031 		pr_debug("Failed to find %s in debuginfod (%s)\n",
2032 			raw_path, sbuild_id);
2033 		return -ENOENT;
2034 	}
2035 	pr_debug("Got a source %s\n", *new_path);
2036 
2037 	return 0;
2038 }
2039 #else
get_source_from_debuginfod(const char * raw_path __maybe_unused,const char * sbuild_id __maybe_unused,char ** new_path __maybe_unused)2040 static inline int get_source_from_debuginfod(const char *raw_path __maybe_unused,
2041 				const char *sbuild_id __maybe_unused,
2042 				char **new_path __maybe_unused)
2043 {
2044 	return -ENOTSUP;
2045 }
2046 #endif
2047 /*
2048  * Find a src file from a DWARF tag path. Prepend optional source path prefix
2049  * and chop off leading directories that do not exist. Result is passed back as
2050  * a newly allocated path on success.
2051  * Return 0 if file was found and readable, -errno otherwise.
2052  */
find_source_path(const char * raw_path,const char * sbuild_id,const char * comp_dir,char ** new_path)2053 int find_source_path(const char *raw_path, const char *sbuild_id,
2054 		const char *comp_dir, char **new_path)
2055 {
2056 	const char *prefix = symbol_conf.source_prefix;
2057 
2058 	if (sbuild_id && !prefix) {
2059 		if (!get_source_from_debuginfod(raw_path, sbuild_id, new_path))
2060 			return 0;
2061 	}
2062 
2063 	if (!prefix) {
2064 		if (raw_path[0] != '/' && comp_dir)
2065 			/* If not an absolute path, try to use comp_dir */
2066 			prefix = comp_dir;
2067 		else {
2068 			if (access(raw_path, R_OK) == 0) {
2069 				*new_path = strdup(raw_path);
2070 				return *new_path ? 0 : -ENOMEM;
2071 			} else
2072 				return -errno;
2073 		}
2074 	}
2075 
2076 	*new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
2077 	if (!*new_path)
2078 		return -ENOMEM;
2079 
2080 	for (;;) {
2081 		sprintf(*new_path, "%s/%s", prefix, raw_path);
2082 
2083 		if (access(*new_path, R_OK) == 0)
2084 			return 0;
2085 
2086 		if (!symbol_conf.source_prefix) {
2087 			/* In case of searching comp_dir, don't retry */
2088 			zfree(new_path);
2089 			return -errno;
2090 		}
2091 
2092 		switch (errno) {
2093 		case ENAMETOOLONG:
2094 		case ENOENT:
2095 		case EROFS:
2096 		case EFAULT:
2097 			raw_path = strchr(++raw_path, '/');
2098 			if (!raw_path) {
2099 				zfree(new_path);
2100 				return -ENOENT;
2101 			}
2102 			continue;
2103 
2104 		default:
2105 			zfree(new_path);
2106 			return -errno;
2107 		}
2108 	}
2109 }
2110