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