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