1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * probe-file.c : operate ftrace k/uprobe events files
4  *
5  * Written by Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
6  */
7 #include <errno.h>
8 #include <fcntl.h>
9 #include <sys/stat.h>
10 #include <sys/types.h>
11 #include <sys/uio.h>
12 #include <unistd.h>
13 #include <linux/zalloc.h>
14 #include "namespaces.h"
15 #include "event.h"
16 #include "strlist.h"
17 #include "strfilter.h"
18 #include "debug.h"
19 #include "build-id.h"
20 #include "dso.h"
21 #include "color.h"
22 #include "symbol.h"
23 #include "strbuf.h"
24 #include <api/fs/tracing_path.h>
25 #include <api/fs/fs.h>
26 #include "probe-event.h"
27 #include "probe-file.h"
28 #include "session.h"
29 #include "perf_regs.h"
30 #include "string2.h"
31 
32 /* 4096 - 2 ('\n' + '\0') */
33 #define MAX_CMDLEN 4094
34 
print_common_warning(int err,bool readwrite)35 static bool print_common_warning(int err, bool readwrite)
36 {
37 	if (err == -EACCES)
38 		pr_warning("No permission to %s tracefs.\nPlease %s\n",
39 			   readwrite ? "write" : "read",
40 			   readwrite ? "run this command again with sudo." :
41 				       "try 'sudo mount -o remount,mode=755 /sys/kernel/tracing/'");
42 	else
43 		return false;
44 
45 	return true;
46 }
47 
print_configure_probe_event(int kerr,int uerr)48 static bool print_configure_probe_event(int kerr, int uerr)
49 {
50 	const char *config, *file;
51 
52 	if (kerr == -ENOENT && uerr == -ENOENT) {
53 		file = "{k,u}probe_events";
54 		config = "CONFIG_KPROBE_EVENTS=y and CONFIG_UPROBE_EVENTS=y";
55 	} else if (kerr == -ENOENT) {
56 		file = "kprobe_events";
57 		config = "CONFIG_KPROBE_EVENTS=y";
58 	} else if (uerr == -ENOENT) {
59 		file = "uprobe_events";
60 		config = "CONFIG_UPROBE_EVENTS=y";
61 	} else
62 		return false;
63 
64 	if (!debugfs__configured() && !tracefs__configured())
65 		pr_warning("Debugfs or tracefs is not mounted\n"
66 			   "Please try 'sudo mount -t tracefs nodev /sys/kernel/tracing/'\n");
67 	else
68 		pr_warning("%s/%s does not exist.\nPlease rebuild kernel with %s.\n",
69 			   tracing_path_mount(), file, config);
70 
71 	return true;
72 }
73 
print_open_warning(int err,bool uprobe,bool readwrite)74 static void print_open_warning(int err, bool uprobe, bool readwrite)
75 {
76 	char sbuf[STRERR_BUFSIZE];
77 
78 	if (print_common_warning(err, readwrite))
79 		return;
80 
81 	if (print_configure_probe_event(uprobe ? 0 : err, uprobe ? err : 0))
82 		return;
83 
84 	pr_warning("Failed to open %s/%cprobe_events: %s\n",
85 		   tracing_path_mount(), uprobe ? 'u' : 'k',
86 		   str_error_r(-err, sbuf, sizeof(sbuf)));
87 }
88 
print_both_open_warning(int kerr,int uerr,bool readwrite)89 static void print_both_open_warning(int kerr, int uerr, bool readwrite)
90 {
91 	char sbuf[STRERR_BUFSIZE];
92 
93 	if (kerr == uerr && print_common_warning(kerr, readwrite))
94 		return;
95 
96 	if (print_configure_probe_event(kerr, uerr))
97 		return;
98 
99 	if (kerr < 0)
100 		pr_warning("Failed to open %s/kprobe_events: %s.\n",
101 			   tracing_path_mount(),
102 			   str_error_r(-kerr, sbuf, sizeof(sbuf)));
103 	if (uerr < 0)
104 		pr_warning("Failed to open %s/uprobe_events: %s.\n",
105 			   tracing_path_mount(),
106 			   str_error_r(-uerr, sbuf, sizeof(sbuf)));
107 }
108 
open_trace_file(const char * trace_file,bool readwrite)109 int open_trace_file(const char *trace_file, bool readwrite)
110 {
111 	char buf[PATH_MAX];
112 	int ret;
113 
114 	ret = e_snprintf(buf, PATH_MAX, "%s/%s", tracing_path_mount(), trace_file);
115 	if (ret >= 0) {
116 		pr_debug("Opening %s write=%d\n", buf, readwrite);
117 		if (readwrite && !probe_event_dry_run)
118 			ret = open(buf, O_RDWR | O_APPEND, 0);
119 		else
120 			ret = open(buf, O_RDONLY, 0);
121 
122 		if (ret < 0)
123 			ret = -errno;
124 	}
125 	return ret;
126 }
127 
open_kprobe_events(bool readwrite)128 static int open_kprobe_events(bool readwrite)
129 {
130 	return open_trace_file("kprobe_events", readwrite);
131 }
132 
open_uprobe_events(bool readwrite)133 static int open_uprobe_events(bool readwrite)
134 {
135 	return open_trace_file("uprobe_events", readwrite);
136 }
137 
probe_file__open(int flag)138 int probe_file__open(int flag)
139 {
140 	int fd;
141 
142 	if (flag & PF_FL_UPROBE)
143 		fd = open_uprobe_events(flag & PF_FL_RW);
144 	else
145 		fd = open_kprobe_events(flag & PF_FL_RW);
146 	if (fd < 0)
147 		print_open_warning(fd, flag & PF_FL_UPROBE, flag & PF_FL_RW);
148 
149 	return fd;
150 }
151 
probe_file__open_both(int * kfd,int * ufd,int flag)152 int probe_file__open_both(int *kfd, int *ufd, int flag)
153 {
154 	if (!kfd || !ufd)
155 		return -EINVAL;
156 
157 	*kfd = open_kprobe_events(flag & PF_FL_RW);
158 	*ufd = open_uprobe_events(flag & PF_FL_RW);
159 	if (*kfd < 0 && *ufd < 0) {
160 		print_both_open_warning(*kfd, *ufd, flag & PF_FL_RW);
161 		return *kfd;
162 	}
163 
164 	return 0;
165 }
166 
167 /* Get raw string list of current kprobe_events  or uprobe_events */
probe_file__get_rawlist(int fd)168 struct strlist *probe_file__get_rawlist(int fd)
169 {
170 	int ret, idx, fddup;
171 	FILE *fp;
172 	char buf[MAX_CMDLEN];
173 	char *p;
174 	struct strlist *sl;
175 
176 	if (fd < 0)
177 		return NULL;
178 
179 	sl = strlist__new(NULL, NULL);
180 	if (sl == NULL)
181 		return NULL;
182 
183 	fddup = dup(fd);
184 	if (fddup < 0)
185 		goto out_free_sl;
186 
187 	fp = fdopen(fddup, "r");
188 	if (!fp)
189 		goto out_close_fddup;
190 
191 	while (!feof(fp)) {
192 		p = fgets(buf, MAX_CMDLEN, fp);
193 		if (!p)
194 			break;
195 
196 		idx = strlen(p) - 1;
197 		if (p[idx] == '\n')
198 			p[idx] = '\0';
199 		ret = strlist__add(sl, buf);
200 		if (ret < 0) {
201 			pr_debug("strlist__add failed (%d)\n", ret);
202 			goto out_close_fp;
203 		}
204 	}
205 	fclose(fp);
206 
207 	return sl;
208 
209 out_close_fp:
210 	fclose(fp);
211 	goto out_free_sl;
212 out_close_fddup:
213 	close(fddup);
214 out_free_sl:
215 	strlist__delete(sl);
216 	return NULL;
217 }
218 
__probe_file__get_namelist(int fd,bool include_group)219 static struct strlist *__probe_file__get_namelist(int fd, bool include_group)
220 {
221 	char buf[128];
222 	struct strlist *sl, *rawlist;
223 	struct str_node *ent;
224 	struct probe_trace_event tev;
225 	int ret = 0;
226 
227 	memset(&tev, 0, sizeof(tev));
228 	rawlist = probe_file__get_rawlist(fd);
229 	if (!rawlist)
230 		return NULL;
231 	sl = strlist__new(NULL, NULL);
232 	strlist__for_each_entry(ent, rawlist) {
233 		ret = parse_probe_trace_command(ent->s, &tev);
234 		if (ret < 0)
235 			break;
236 		if (include_group) {
237 			ret = e_snprintf(buf, 128, "%s:%s", tev.group,
238 					tev.event);
239 			if (ret >= 0)
240 				ret = strlist__add(sl, buf);
241 		} else
242 			ret = strlist__add(sl, tev.event);
243 		clear_probe_trace_event(&tev);
244 		/* Skip if there is same name multi-probe event in the list */
245 		if (ret == -EEXIST)
246 			ret = 0;
247 		if (ret < 0)
248 			break;
249 	}
250 	strlist__delete(rawlist);
251 
252 	if (ret < 0) {
253 		strlist__delete(sl);
254 		return NULL;
255 	}
256 	return sl;
257 }
258 
259 /* Get current perf-probe event names */
probe_file__get_namelist(int fd)260 struct strlist *probe_file__get_namelist(int fd)
261 {
262 	return __probe_file__get_namelist(fd, false);
263 }
264 
probe_file__add_event(int fd,struct probe_trace_event * tev)265 int probe_file__add_event(int fd, struct probe_trace_event *tev)
266 {
267 	int ret = 0;
268 	char *buf = synthesize_probe_trace_command(tev);
269 	char sbuf[STRERR_BUFSIZE];
270 
271 	if (!buf) {
272 		pr_debug("Failed to synthesize probe trace event.\n");
273 		return -EINVAL;
274 	}
275 
276 	pr_debug("Writing event: %s\n", buf);
277 	if (!probe_event_dry_run) {
278 		if (write(fd, buf, strlen(buf)) < (int)strlen(buf)) {
279 			ret = -errno;
280 			pr_warning("Failed to write event: %s\n",
281 				   str_error_r(errno, sbuf, sizeof(sbuf)));
282 		}
283 	}
284 	free(buf);
285 
286 	return ret;
287 }
288 
__del_trace_probe_event(int fd,struct str_node * ent)289 static int __del_trace_probe_event(int fd, struct str_node *ent)
290 {
291 	char *p;
292 	char buf[128];
293 	int ret;
294 
295 	/* Convert from perf-probe event to trace-probe event */
296 	ret = e_snprintf(buf, 128, "-:%s", ent->s);
297 	if (ret < 0)
298 		goto error;
299 
300 	p = strchr(buf + 2, ':');
301 	if (!p) {
302 		pr_debug("Internal error: %s should have ':' but not.\n",
303 			 ent->s);
304 		ret = -ENOTSUP;
305 		goto error;
306 	}
307 	*p = '/';
308 
309 	pr_debug("Writing event: %s\n", buf);
310 	ret = write(fd, buf, strlen(buf));
311 	if (ret < 0) {
312 		ret = -errno;
313 		goto error;
314 	}
315 
316 	return 0;
317 error:
318 	pr_warning("Failed to delete event: %s\n",
319 		   str_error_r(-ret, buf, sizeof(buf)));
320 	return ret;
321 }
322 
probe_file__get_events(int fd,struct strfilter * filter,struct strlist * plist)323 int probe_file__get_events(int fd, struct strfilter *filter,
324 			   struct strlist *plist)
325 {
326 	struct strlist *namelist;
327 	struct str_node *ent;
328 	const char *p;
329 	int ret = -ENOENT;
330 
331 	if (!plist)
332 		return -EINVAL;
333 
334 	namelist = __probe_file__get_namelist(fd, true);
335 	if (!namelist)
336 		return -ENOENT;
337 
338 	strlist__for_each_entry(ent, namelist) {
339 		p = strchr(ent->s, ':');
340 		if ((p && strfilter__compare(filter, p + 1)) ||
341 		    strfilter__compare(filter, ent->s)) {
342 			ret = strlist__add(plist, ent->s);
343 			if (ret == -ENOMEM) {
344 				pr_err("strlist__add failed with -ENOMEM\n");
345 				goto out;
346 			}
347 			ret = 0;
348 		}
349 	}
350 out:
351 	strlist__delete(namelist);
352 
353 	return ret;
354 }
355 
probe_file__del_strlist(int fd,struct strlist * namelist)356 int probe_file__del_strlist(int fd, struct strlist *namelist)
357 {
358 	int ret = 0;
359 	struct str_node *ent;
360 
361 	strlist__for_each_entry(ent, namelist) {
362 		ret = __del_trace_probe_event(fd, ent);
363 		if (ret < 0)
364 			break;
365 	}
366 	return ret;
367 }
368 
probe_file__del_events(int fd,struct strfilter * filter)369 int probe_file__del_events(int fd, struct strfilter *filter)
370 {
371 	struct strlist *namelist;
372 	int ret;
373 
374 	namelist = strlist__new(NULL, NULL);
375 	if (!namelist)
376 		return -ENOMEM;
377 
378 	ret = probe_file__get_events(fd, filter, namelist);
379 	if (ret < 0)
380 		goto out;
381 
382 	ret = probe_file__del_strlist(fd, namelist);
383 out:
384 	strlist__delete(namelist);
385 	return ret;
386 }
387 
388 /* Caller must ensure to remove this entry from list */
probe_cache_entry__delete(struct probe_cache_entry * entry)389 static void probe_cache_entry__delete(struct probe_cache_entry *entry)
390 {
391 	if (entry) {
392 		BUG_ON(!list_empty(&entry->node));
393 
394 		strlist__delete(entry->tevlist);
395 		clear_perf_probe_event(&entry->pev);
396 		zfree(&entry->spev);
397 		free(entry);
398 	}
399 }
400 
401 static struct probe_cache_entry *
probe_cache_entry__new(struct perf_probe_event * pev)402 probe_cache_entry__new(struct perf_probe_event *pev)
403 {
404 	struct probe_cache_entry *entry = zalloc(sizeof(*entry));
405 
406 	if (entry) {
407 		INIT_LIST_HEAD(&entry->node);
408 		entry->tevlist = strlist__new(NULL, NULL);
409 		if (!entry->tevlist)
410 			zfree(&entry);
411 		else if (pev) {
412 			entry->spev = synthesize_perf_probe_command(pev);
413 			if (!entry->spev ||
414 			    perf_probe_event__copy(&entry->pev, pev) < 0) {
415 				probe_cache_entry__delete(entry);
416 				return NULL;
417 			}
418 		}
419 	}
420 
421 	return entry;
422 }
423 
probe_cache_entry__get_event(struct probe_cache_entry * entry,struct probe_trace_event ** tevs)424 int probe_cache_entry__get_event(struct probe_cache_entry *entry,
425 				 struct probe_trace_event **tevs)
426 {
427 	struct probe_trace_event *tev;
428 	struct str_node *node;
429 	int ret, i;
430 
431 	ret = strlist__nr_entries(entry->tevlist);
432 	if (ret > probe_conf.max_probes)
433 		return -E2BIG;
434 
435 	*tevs = zalloc(ret * sizeof(*tev));
436 	if (!*tevs)
437 		return -ENOMEM;
438 
439 	i = 0;
440 	strlist__for_each_entry(node, entry->tevlist) {
441 		tev = &(*tevs)[i++];
442 		ret = parse_probe_trace_command(node->s, tev);
443 		if (ret < 0)
444 			break;
445 	}
446 	return i;
447 }
448 
449 /* For the kernel probe caches, pass target = NULL or DSO__NAME_KALLSYMS */
probe_cache__open(struct probe_cache * pcache,const char * target,struct nsinfo * nsi)450 static int probe_cache__open(struct probe_cache *pcache, const char *target,
451 			     struct nsinfo *nsi)
452 {
453 	char cpath[PATH_MAX];
454 	char sbuildid[SBUILD_ID_SIZE];
455 	char *dir_name = NULL;
456 	bool is_kallsyms = false;
457 	int ret, fd;
458 	struct nscookie nsc;
459 
460 	if (target && build_id_cache__cached(target)) {
461 		/* This is a cached buildid */
462 		strlcpy(sbuildid, target, SBUILD_ID_SIZE);
463 		dir_name = build_id_cache__linkname(sbuildid, NULL, 0);
464 		goto found;
465 	}
466 
467 	if (!target || !strcmp(target, DSO__NAME_KALLSYMS)) {
468 		target = DSO__NAME_KALLSYMS;
469 		is_kallsyms = true;
470 		ret = sysfs__sprintf_build_id("/", sbuildid);
471 	} else {
472 		nsinfo__mountns_enter(nsi, &nsc);
473 		ret = filename__sprintf_build_id(target, sbuildid);
474 		nsinfo__mountns_exit(&nsc);
475 	}
476 
477 	if (ret < 0) {
478 		pr_debug("Failed to get build-id from %s.\n", target);
479 		return ret;
480 	}
481 
482 	/* If we have no buildid cache, make it */
483 	if (!build_id_cache__cached(sbuildid)) {
484 		ret = build_id_cache__add_s(sbuildid, target, nsi,
485 					    is_kallsyms, NULL);
486 		if (ret < 0) {
487 			pr_debug("Failed to add build-id cache: %s\n", target);
488 			return ret;
489 		}
490 	}
491 
492 	dir_name = build_id_cache__cachedir(sbuildid, target, nsi, is_kallsyms,
493 					    false);
494 found:
495 	if (!dir_name) {
496 		pr_debug("Failed to get cache from %s\n", target);
497 		return -ENOMEM;
498 	}
499 
500 	snprintf(cpath, PATH_MAX, "%s/probes", dir_name);
501 	fd = open(cpath, O_CREAT | O_RDWR, 0644);
502 	if (fd < 0)
503 		pr_debug("Failed to open cache(%d): %s\n", fd, cpath);
504 	free(dir_name);
505 	pcache->fd = fd;
506 
507 	return fd;
508 }
509 
probe_cache__load(struct probe_cache * pcache)510 static int probe_cache__load(struct probe_cache *pcache)
511 {
512 	struct probe_cache_entry *entry = NULL;
513 	char buf[MAX_CMDLEN], *p;
514 	int ret = 0, fddup;
515 	FILE *fp;
516 
517 	fddup = dup(pcache->fd);
518 	if (fddup < 0)
519 		return -errno;
520 	fp = fdopen(fddup, "r");
521 	if (!fp) {
522 		close(fddup);
523 		return -EINVAL;
524 	}
525 
526 	while (!feof(fp)) {
527 		if (!fgets(buf, MAX_CMDLEN, fp))
528 			break;
529 		p = strchr(buf, '\n');
530 		if (p)
531 			*p = '\0';
532 		/* #perf_probe_event or %sdt_event */
533 		if (buf[0] == '#' || buf[0] == '%') {
534 			entry = probe_cache_entry__new(NULL);
535 			if (!entry) {
536 				ret = -ENOMEM;
537 				goto out;
538 			}
539 			if (buf[0] == '%')
540 				entry->sdt = true;
541 			entry->spev = strdup(buf + 1);
542 			if (entry->spev)
543 				ret = parse_perf_probe_command(buf + 1,
544 								&entry->pev);
545 			else
546 				ret = -ENOMEM;
547 			if (ret < 0) {
548 				probe_cache_entry__delete(entry);
549 				goto out;
550 			}
551 			list_add_tail(&entry->node, &pcache->entries);
552 		} else {	/* trace_probe_event */
553 			if (!entry) {
554 				ret = -EINVAL;
555 				goto out;
556 			}
557 			ret = strlist__add(entry->tevlist, buf);
558 			if (ret == -ENOMEM) {
559 				pr_err("strlist__add failed with -ENOMEM\n");
560 				goto out;
561 			}
562 		}
563 	}
564 out:
565 	fclose(fp);
566 	return ret;
567 }
568 
probe_cache__alloc(void)569 static struct probe_cache *probe_cache__alloc(void)
570 {
571 	struct probe_cache *pcache = zalloc(sizeof(*pcache));
572 
573 	if (pcache) {
574 		INIT_LIST_HEAD(&pcache->entries);
575 		pcache->fd = -EINVAL;
576 	}
577 	return pcache;
578 }
579 
probe_cache__purge(struct probe_cache * pcache)580 void probe_cache__purge(struct probe_cache *pcache)
581 {
582 	struct probe_cache_entry *entry, *n;
583 
584 	list_for_each_entry_safe(entry, n, &pcache->entries, node) {
585 		list_del_init(&entry->node);
586 		probe_cache_entry__delete(entry);
587 	}
588 }
589 
probe_cache__delete(struct probe_cache * pcache)590 void probe_cache__delete(struct probe_cache *pcache)
591 {
592 	if (!pcache)
593 		return;
594 
595 	probe_cache__purge(pcache);
596 	if (pcache->fd > 0)
597 		close(pcache->fd);
598 	free(pcache);
599 }
600 
probe_cache__new(const char * target,struct nsinfo * nsi)601 struct probe_cache *probe_cache__new(const char *target, struct nsinfo *nsi)
602 {
603 	struct probe_cache *pcache = probe_cache__alloc();
604 	int ret;
605 
606 	if (!pcache)
607 		return NULL;
608 
609 	ret = probe_cache__open(pcache, target, nsi);
610 	if (ret < 0) {
611 		pr_debug("Cache open error: %d\n", ret);
612 		goto out_err;
613 	}
614 
615 	ret = probe_cache__load(pcache);
616 	if (ret < 0) {
617 		pr_debug("Cache read error: %d\n", ret);
618 		goto out_err;
619 	}
620 
621 	return pcache;
622 
623 out_err:
624 	probe_cache__delete(pcache);
625 	return NULL;
626 }
627 
streql(const char * a,const char * b)628 static bool streql(const char *a, const char *b)
629 {
630 	if (a == b)
631 		return true;
632 
633 	if (!a || !b)
634 		return false;
635 
636 	return !strcmp(a, b);
637 }
638 
639 struct probe_cache_entry *
probe_cache__find(struct probe_cache * pcache,struct perf_probe_event * pev)640 probe_cache__find(struct probe_cache *pcache, struct perf_probe_event *pev)
641 {
642 	struct probe_cache_entry *entry = NULL;
643 	char *cmd = synthesize_perf_probe_command(pev);
644 
645 	if (!cmd)
646 		return NULL;
647 
648 	for_each_probe_cache_entry(entry, pcache) {
649 		if (pev->sdt) {
650 			if (entry->pev.event &&
651 			    streql(entry->pev.event, pev->event) &&
652 			    (!pev->group ||
653 			     streql(entry->pev.group, pev->group)))
654 				goto found;
655 
656 			continue;
657 		}
658 		/* Hit if same event name or same command-string */
659 		if ((pev->event &&
660 		     (streql(entry->pev.group, pev->group) &&
661 		      streql(entry->pev.event, pev->event))) ||
662 		    (!strcmp(entry->spev, cmd)))
663 			goto found;
664 	}
665 	entry = NULL;
666 
667 found:
668 	free(cmd);
669 	return entry;
670 }
671 
672 struct probe_cache_entry *
probe_cache__find_by_name(struct probe_cache * pcache,const char * group,const char * event)673 probe_cache__find_by_name(struct probe_cache *pcache,
674 			  const char *group, const char *event)
675 {
676 	struct probe_cache_entry *entry = NULL;
677 
678 	for_each_probe_cache_entry(entry, pcache) {
679 		/* Hit if same event name or same command-string */
680 		if (streql(entry->pev.group, group) &&
681 		    streql(entry->pev.event, event))
682 			goto found;
683 	}
684 	entry = NULL;
685 
686 found:
687 	return entry;
688 }
689 
probe_cache__add_entry(struct probe_cache * pcache,struct perf_probe_event * pev,struct probe_trace_event * tevs,int ntevs)690 int probe_cache__add_entry(struct probe_cache *pcache,
691 			   struct perf_probe_event *pev,
692 			   struct probe_trace_event *tevs, int ntevs)
693 {
694 	struct probe_cache_entry *entry = NULL;
695 	char *command;
696 	int i, ret = 0;
697 
698 	if (!pcache || !pev || !tevs || ntevs <= 0) {
699 		ret = -EINVAL;
700 		goto out_err;
701 	}
702 
703 	/* Remove old cache entry */
704 	entry = probe_cache__find(pcache, pev);
705 	if (entry) {
706 		list_del_init(&entry->node);
707 		probe_cache_entry__delete(entry);
708 	}
709 
710 	ret = -ENOMEM;
711 	entry = probe_cache_entry__new(pev);
712 	if (!entry)
713 		goto out_err;
714 
715 	for (i = 0; i < ntevs; i++) {
716 		if (!tevs[i].point.symbol)
717 			continue;
718 
719 		command = synthesize_probe_trace_command(&tevs[i]);
720 		if (!command)
721 			goto out_err;
722 		ret = strlist__add(entry->tevlist, command);
723 		if (ret == -ENOMEM) {
724 			pr_err("strlist__add failed with -ENOMEM\n");
725 			goto out_err;
726 		}
727 
728 		free(command);
729 	}
730 	list_add_tail(&entry->node, &pcache->entries);
731 	pr_debug("Added probe cache: %d\n", ntevs);
732 	return 0;
733 
734 out_err:
735 	pr_debug("Failed to add probe caches\n");
736 	probe_cache_entry__delete(entry);
737 	return ret;
738 }
739 
740 #ifdef HAVE_GELF_GETNOTE_SUPPORT
sdt_note__get_addr(struct sdt_note * note)741 static unsigned long long sdt_note__get_addr(struct sdt_note *note)
742 {
743 	return note->bit32 ?
744 		(unsigned long long)note->addr.a32[SDT_NOTE_IDX_LOC] :
745 		(unsigned long long)note->addr.a64[SDT_NOTE_IDX_LOC];
746 }
747 
sdt_note__get_ref_ctr_offset(struct sdt_note * note)748 static unsigned long long sdt_note__get_ref_ctr_offset(struct sdt_note *note)
749 {
750 	return note->bit32 ?
751 		(unsigned long long)note->addr.a32[SDT_NOTE_IDX_REFCTR] :
752 		(unsigned long long)note->addr.a64[SDT_NOTE_IDX_REFCTR];
753 }
754 
755 static const char * const type_to_suffix[] = {
756 	":s64", "", "", "", ":s32", "", ":s16", ":s8",
757 	"", ":u8", ":u16", "", ":u32", "", "", "", ":u64"
758 };
759 
760 /*
761  * Isolate the string number and convert it into a decimal value;
762  * this will be an index to get suffix of the uprobe name (defining
763  * the type)
764  */
sdt_arg_parse_size(char * n_ptr,const char ** suffix)765 static int sdt_arg_parse_size(char *n_ptr, const char **suffix)
766 {
767 	long type_idx;
768 
769 	type_idx = strtol(n_ptr, NULL, 10);
770 	if (type_idx < -8 || type_idx > 8) {
771 		pr_debug4("Failed to get a valid sdt type\n");
772 		return -1;
773 	}
774 
775 	*suffix = type_to_suffix[type_idx + 8];
776 	return 0;
777 }
778 
synthesize_sdt_probe_arg(struct strbuf * buf,int i,const char * arg)779 static int synthesize_sdt_probe_arg(struct strbuf *buf, int i, const char *arg)
780 {
781 	char *op, *desc = strdup(arg), *new_op = NULL;
782 	const char *suffix = "";
783 	int ret = -1;
784 
785 	if (desc == NULL) {
786 		pr_debug4("Allocation error\n");
787 		return ret;
788 	}
789 
790 	/*
791 	 * Argument is in N@OP format. N is size of the argument and OP is
792 	 * the actual assembly operand. N can be omitted; in that case
793 	 * argument is just OP(without @).
794 	 */
795 	op = strchr(desc, '@');
796 	if (op) {
797 		op[0] = '\0';
798 		op++;
799 
800 		if (sdt_arg_parse_size(desc, &suffix))
801 			goto error;
802 	} else {
803 		op = desc;
804 	}
805 
806 	ret = arch_sdt_arg_parse_op(op, &new_op);
807 
808 	if (ret < 0)
809 		goto error;
810 
811 	if (ret == SDT_ARG_VALID) {
812 		ret = strbuf_addf(buf, " arg%d=%s%s", i + 1, new_op, suffix);
813 		if (ret < 0)
814 			goto error;
815 	}
816 
817 	ret = 0;
818 error:
819 	free(desc);
820 	free(new_op);
821 	return ret;
822 }
823 
synthesize_sdt_probe_command(struct sdt_note * note,const char * pathname,const char * sdtgrp)824 static char *synthesize_sdt_probe_command(struct sdt_note *note,
825 					const char *pathname,
826 					const char *sdtgrp)
827 {
828 	struct strbuf buf;
829 	char *ret = NULL;
830 	int i, args_count, err;
831 	unsigned long long ref_ctr_offset;
832 	char *arg;
833 	int arg_idx = 0;
834 
835 	if (strbuf_init(&buf, 32) < 0)
836 		return NULL;
837 
838 	err = strbuf_addf(&buf, "p:%s/%s %s:0x%llx",
839 			sdtgrp, note->name, pathname,
840 			sdt_note__get_addr(note));
841 
842 	ref_ctr_offset = sdt_note__get_ref_ctr_offset(note);
843 	if (ref_ctr_offset && err >= 0)
844 		err = strbuf_addf(&buf, "(0x%llx)", ref_ctr_offset);
845 
846 	if (err < 0)
847 		goto error;
848 
849 	if (!note->args)
850 		goto out;
851 
852 	if (note->args) {
853 		char **args = argv_split(note->args, &args_count);
854 
855 		if (args == NULL)
856 			goto error;
857 
858 		for (i = 0; i < args_count; ) {
859 			/*
860 			 * FIXUP: Arm64 ELF section '.note.stapsdt' uses string
861 			 * format "-4@[sp, NUM]" if a probe is to access data in
862 			 * the stack, e.g. below is an example for the SDT
863 			 * Arguments:
864 			 *
865 			 *   Arguments: -4@[sp, 12] -4@[sp, 8] -4@[sp, 4]
866 			 *
867 			 * Since the string introduces an extra space character
868 			 * in the middle of square brackets, the argument is
869 			 * divided into two items.  Fixup for this case, if an
870 			 * item contains sub string "[sp,", need to concatenate
871 			 * the two items.
872 			 */
873 			if (strstr(args[i], "[sp,") && (i+1) < args_count) {
874 				err = asprintf(&arg, "%s %s", args[i], args[i+1]);
875 				i += 2;
876 			} else {
877 				err = asprintf(&arg, "%s", args[i]);
878 				i += 1;
879 			}
880 
881 			/* Failed to allocate memory */
882 			if (err < 0) {
883 				argv_free(args);
884 				goto error;
885 			}
886 
887 			if (synthesize_sdt_probe_arg(&buf, arg_idx, arg) < 0) {
888 				free(arg);
889 				argv_free(args);
890 				goto error;
891 			}
892 
893 			free(arg);
894 			arg_idx++;
895 		}
896 
897 		argv_free(args);
898 	}
899 
900 out:
901 	ret = strbuf_detach(&buf, NULL);
902 error:
903 	strbuf_release(&buf);
904 	return ret;
905 }
906 
probe_cache__scan_sdt(struct probe_cache * pcache,const char * pathname)907 int probe_cache__scan_sdt(struct probe_cache *pcache, const char *pathname)
908 {
909 	struct probe_cache_entry *entry = NULL;
910 	struct list_head sdtlist;
911 	struct sdt_note *note;
912 	char *buf;
913 	char sdtgrp[64];
914 	int ret;
915 
916 	INIT_LIST_HEAD(&sdtlist);
917 	ret = get_sdt_note_list(&sdtlist, pathname);
918 	if (ret < 0) {
919 		pr_debug4("Failed to get sdt note: %d\n", ret);
920 		return ret;
921 	}
922 	list_for_each_entry(note, &sdtlist, note_list) {
923 		ret = snprintf(sdtgrp, 64, "sdt_%s", note->provider);
924 		if (ret < 0)
925 			break;
926 		/* Try to find same-name entry */
927 		entry = probe_cache__find_by_name(pcache, sdtgrp, note->name);
928 		if (!entry) {
929 			entry = probe_cache_entry__new(NULL);
930 			if (!entry) {
931 				ret = -ENOMEM;
932 				break;
933 			}
934 			entry->sdt = true;
935 			ret = asprintf(&entry->spev, "%s:%s=%s", sdtgrp,
936 					note->name, note->name);
937 			if (ret < 0)
938 				break;
939 			entry->pev.event = strdup(note->name);
940 			entry->pev.group = strdup(sdtgrp);
941 			list_add_tail(&entry->node, &pcache->entries);
942 		}
943 		buf = synthesize_sdt_probe_command(note, pathname, sdtgrp);
944 		if (!buf) {
945 			ret = -ENOMEM;
946 			break;
947 		}
948 
949 		ret = strlist__add(entry->tevlist, buf);
950 
951 		free(buf);
952 		entry = NULL;
953 
954 		if (ret == -ENOMEM) {
955 			pr_err("strlist__add failed with -ENOMEM\n");
956 			break;
957 		}
958 	}
959 	if (entry) {
960 		list_del_init(&entry->node);
961 		probe_cache_entry__delete(entry);
962 	}
963 	cleanup_sdt_note_list(&sdtlist);
964 	return ret;
965 }
966 #endif
967 
probe_cache_entry__write(struct probe_cache_entry * entry,int fd)968 static int probe_cache_entry__write(struct probe_cache_entry *entry, int fd)
969 {
970 	struct str_node *snode;
971 	struct stat st;
972 	struct iovec iov[3];
973 	const char *prefix = entry->sdt ? "%" : "#";
974 	int ret;
975 	/* Save stat for rollback */
976 	ret = fstat(fd, &st);
977 	if (ret < 0)
978 		return ret;
979 
980 	pr_debug("Writing cache: %s%s\n", prefix, entry->spev);
981 	iov[0].iov_base = (void *)prefix; iov[0].iov_len = 1;
982 	iov[1].iov_base = entry->spev; iov[1].iov_len = strlen(entry->spev);
983 	iov[2].iov_base = (void *)"\n"; iov[2].iov_len = 1;
984 	ret = writev(fd, iov, 3);
985 	if (ret < (int)iov[1].iov_len + 2)
986 		goto rollback;
987 
988 	strlist__for_each_entry(snode, entry->tevlist) {
989 		iov[0].iov_base = (void *)snode->s;
990 		iov[0].iov_len = strlen(snode->s);
991 		iov[1].iov_base = (void *)"\n"; iov[1].iov_len = 1;
992 		ret = writev(fd, iov, 2);
993 		if (ret < (int)iov[0].iov_len + 1)
994 			goto rollback;
995 	}
996 	return 0;
997 
998 rollback:
999 	/* Rollback to avoid cache file corruption */
1000 	if (ret > 0)
1001 		ret = -1;
1002 	if (ftruncate(fd, st.st_size) < 0)
1003 		ret = -2;
1004 
1005 	return ret;
1006 }
1007 
probe_cache__commit(struct probe_cache * pcache)1008 int probe_cache__commit(struct probe_cache *pcache)
1009 {
1010 	struct probe_cache_entry *entry;
1011 	int ret = 0;
1012 
1013 	/* TBD: if we do not update existing entries, skip it */
1014 	ret = lseek(pcache->fd, 0, SEEK_SET);
1015 	if (ret < 0)
1016 		goto out;
1017 
1018 	ret = ftruncate(pcache->fd, 0);
1019 	if (ret < 0)
1020 		goto out;
1021 
1022 	for_each_probe_cache_entry(entry, pcache) {
1023 		ret = probe_cache_entry__write(entry, pcache->fd);
1024 		pr_debug("Cache committed: %d\n", ret);
1025 		if (ret < 0)
1026 			break;
1027 	}
1028 out:
1029 	return ret;
1030 }
1031 
probe_cache_entry__compare(struct probe_cache_entry * entry,struct strfilter * filter)1032 static bool probe_cache_entry__compare(struct probe_cache_entry *entry,
1033 				       struct strfilter *filter)
1034 {
1035 	char buf[128], *ptr = entry->spev;
1036 
1037 	if (entry->pev.event) {
1038 		snprintf(buf, 128, "%s:%s", entry->pev.group, entry->pev.event);
1039 		ptr = buf;
1040 	}
1041 	return strfilter__compare(filter, ptr);
1042 }
1043 
probe_cache__filter_purge(struct probe_cache * pcache,struct strfilter * filter)1044 int probe_cache__filter_purge(struct probe_cache *pcache,
1045 			      struct strfilter *filter)
1046 {
1047 	struct probe_cache_entry *entry, *tmp;
1048 
1049 	list_for_each_entry_safe(entry, tmp, &pcache->entries, node) {
1050 		if (probe_cache_entry__compare(entry, filter)) {
1051 			pr_info("Removed cached event: %s\n", entry->spev);
1052 			list_del_init(&entry->node);
1053 			probe_cache_entry__delete(entry);
1054 		}
1055 	}
1056 	return 0;
1057 }
1058 
probe_cache__show_entries(struct probe_cache * pcache,struct strfilter * filter)1059 static int probe_cache__show_entries(struct probe_cache *pcache,
1060 				     struct strfilter *filter)
1061 {
1062 	struct probe_cache_entry *entry;
1063 
1064 	for_each_probe_cache_entry(entry, pcache) {
1065 		if (probe_cache_entry__compare(entry, filter))
1066 			printf("%s\n", entry->spev);
1067 	}
1068 	return 0;
1069 }
1070 
1071 /* Show all cached probes */
probe_cache__show_all_caches(struct strfilter * filter)1072 int probe_cache__show_all_caches(struct strfilter *filter)
1073 {
1074 	struct probe_cache *pcache;
1075 	struct strlist *bidlist;
1076 	struct str_node *nd;
1077 	char *buf = strfilter__string(filter);
1078 
1079 	pr_debug("list cache with filter: %s\n", buf);
1080 	free(buf);
1081 
1082 	bidlist = build_id_cache__list_all(true);
1083 	if (!bidlist) {
1084 		pr_debug("Failed to get buildids: %d\n", errno);
1085 		return -EINVAL;
1086 	}
1087 	strlist__for_each_entry(nd, bidlist) {
1088 		pcache = probe_cache__new(nd->s, NULL);
1089 		if (!pcache)
1090 			continue;
1091 		if (!list_empty(&pcache->entries)) {
1092 			buf = build_id_cache__origname(nd->s);
1093 			printf("%s (%s):\n", buf, nd->s);
1094 			free(buf);
1095 			probe_cache__show_entries(pcache, filter);
1096 		}
1097 		probe_cache__delete(pcache);
1098 	}
1099 	strlist__delete(bidlist);
1100 
1101 	return 0;
1102 }
1103 
1104 enum ftrace_readme {
1105 	FTRACE_README_PROBE_TYPE_X = 0,
1106 	FTRACE_README_KRETPROBE_OFFSET,
1107 	FTRACE_README_UPROBE_REF_CTR,
1108 	FTRACE_README_USER_ACCESS,
1109 	FTRACE_README_MULTIPROBE_EVENT,
1110 	FTRACE_README_IMMEDIATE_VALUE,
1111 	FTRACE_README_END,
1112 };
1113 
1114 static struct {
1115 	const char *pattern;
1116 	bool avail;
1117 } ftrace_readme_table[] = {
1118 #define DEFINE_TYPE(idx, pat)			\
1119 	[idx] = {.pattern = pat, .avail = false}
1120 	DEFINE_TYPE(FTRACE_README_PROBE_TYPE_X, "*type: * x8/16/32/64,*"),
1121 	DEFINE_TYPE(FTRACE_README_KRETPROBE_OFFSET, "*place (kretprobe): *"),
1122 	DEFINE_TYPE(FTRACE_README_UPROBE_REF_CTR, "*ref_ctr_offset*"),
1123 	DEFINE_TYPE(FTRACE_README_USER_ACCESS, "*u]<offset>*"),
1124 	DEFINE_TYPE(FTRACE_README_MULTIPROBE_EVENT, "*Create/append/*"),
1125 	DEFINE_TYPE(FTRACE_README_IMMEDIATE_VALUE, "*\\imm-value,*"),
1126 };
1127 
scan_ftrace_readme(enum ftrace_readme type)1128 static bool scan_ftrace_readme(enum ftrace_readme type)
1129 {
1130 	int fd;
1131 	FILE *fp;
1132 	char *buf = NULL;
1133 	size_t len = 0;
1134 	bool ret = false;
1135 	static bool scanned = false;
1136 
1137 	if (scanned)
1138 		goto result;
1139 
1140 	fd = open_trace_file("README", false);
1141 	if (fd < 0)
1142 		return ret;
1143 
1144 	fp = fdopen(fd, "r");
1145 	if (!fp) {
1146 		close(fd);
1147 		return ret;
1148 	}
1149 
1150 	while (getline(&buf, &len, fp) > 0)
1151 		for (enum ftrace_readme i = 0; i < FTRACE_README_END; i++)
1152 			if (!ftrace_readme_table[i].avail)
1153 				ftrace_readme_table[i].avail =
1154 					strglobmatch(buf, ftrace_readme_table[i].pattern);
1155 	scanned = true;
1156 
1157 	fclose(fp);
1158 	free(buf);
1159 
1160 result:
1161 	if (type >= FTRACE_README_END)
1162 		return false;
1163 
1164 	return ftrace_readme_table[type].avail;
1165 }
1166 
probe_type_is_available(enum probe_type type)1167 bool probe_type_is_available(enum probe_type type)
1168 {
1169 	if (type >= PROBE_TYPE_END)
1170 		return false;
1171 	else if (type == PROBE_TYPE_X)
1172 		return scan_ftrace_readme(FTRACE_README_PROBE_TYPE_X);
1173 
1174 	return true;
1175 }
1176 
kretprobe_offset_is_supported(void)1177 bool kretprobe_offset_is_supported(void)
1178 {
1179 	return scan_ftrace_readme(FTRACE_README_KRETPROBE_OFFSET);
1180 }
1181 
uprobe_ref_ctr_is_supported(void)1182 bool uprobe_ref_ctr_is_supported(void)
1183 {
1184 	return scan_ftrace_readme(FTRACE_README_UPROBE_REF_CTR);
1185 }
1186 
user_access_is_supported(void)1187 bool user_access_is_supported(void)
1188 {
1189 	return scan_ftrace_readme(FTRACE_README_USER_ACCESS);
1190 }
1191 
multiprobe_event_is_supported(void)1192 bool multiprobe_event_is_supported(void)
1193 {
1194 	return scan_ftrace_readme(FTRACE_README_MULTIPROBE_EVENT);
1195 }
1196 
immediate_value_is_supported(void)1197 bool immediate_value_is_supported(void)
1198 {
1199 	return scan_ftrace_readme(FTRACE_README_IMMEDIATE_VALUE);
1200 }
1201