1/* 2 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com> 3 * 4 * Parts came from builtin-{top,stat,record}.c, see those files for further 5 * copyright notes. 6 * 7 * Released under the GPL v2. (and only v2, not any later version) 8 */ 9#include "util.h" 10#include <api/fs/fs.h> 11#include <poll.h> 12#include "cpumap.h" 13#include "thread_map.h" 14#include "target.h" 15#include "evlist.h" 16#include "evsel.h" 17#include "debug.h" 18#include <unistd.h> 19 20#include "parse-events.h" 21#include "parse-options.h" 22 23#include <sys/mman.h> 24 25#include <linux/bitops.h> 26#include <linux/hash.h> 27#include <linux/log2.h> 28 29static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx); 30static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx); 31 32#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y)) 33#define SID(e, x, y) xyarray__entry(e->sample_id, x, y) 34 35void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus, 36 struct thread_map *threads) 37{ 38 int i; 39 40 for (i = 0; i < PERF_EVLIST__HLIST_SIZE; ++i) 41 INIT_HLIST_HEAD(&evlist->heads[i]); 42 INIT_LIST_HEAD(&evlist->entries); 43 perf_evlist__set_maps(evlist, cpus, threads); 44 fdarray__init(&evlist->pollfd, 64); 45 evlist->workload.pid = -1; 46} 47 48struct perf_evlist *perf_evlist__new(void) 49{ 50 struct perf_evlist *evlist = zalloc(sizeof(*evlist)); 51 52 if (evlist != NULL) 53 perf_evlist__init(evlist, NULL, NULL); 54 55 return evlist; 56} 57 58struct perf_evlist *perf_evlist__new_default(void) 59{ 60 struct perf_evlist *evlist = perf_evlist__new(); 61 62 if (evlist && perf_evlist__add_default(evlist)) { 63 perf_evlist__delete(evlist); 64 evlist = NULL; 65 } 66 67 return evlist; 68} 69 70/** 71 * perf_evlist__set_id_pos - set the positions of event ids. 72 * @evlist: selected event list 73 * 74 * Events with compatible sample types all have the same id_pos 75 * and is_pos. For convenience, put a copy on evlist. 76 */ 77void perf_evlist__set_id_pos(struct perf_evlist *evlist) 78{ 79 struct perf_evsel *first = perf_evlist__first(evlist); 80 81 evlist->id_pos = first->id_pos; 82 evlist->is_pos = first->is_pos; 83} 84 85static void perf_evlist__update_id_pos(struct perf_evlist *evlist) 86{ 87 struct perf_evsel *evsel; 88 89 evlist__for_each(evlist, evsel) 90 perf_evsel__calc_id_pos(evsel); 91 92 perf_evlist__set_id_pos(evlist); 93} 94 95static void perf_evlist__purge(struct perf_evlist *evlist) 96{ 97 struct perf_evsel *pos, *n; 98 99 evlist__for_each_safe(evlist, n, pos) { 100 list_del_init(&pos->node); 101 perf_evsel__delete(pos); 102 } 103 104 evlist->nr_entries = 0; 105} 106 107void perf_evlist__exit(struct perf_evlist *evlist) 108{ 109 zfree(&evlist->mmap); 110 fdarray__exit(&evlist->pollfd); 111} 112 113void perf_evlist__delete(struct perf_evlist *evlist) 114{ 115 perf_evlist__munmap(evlist); 116 perf_evlist__close(evlist); 117 cpu_map__delete(evlist->cpus); 118 thread_map__delete(evlist->threads); 119 evlist->cpus = NULL; 120 evlist->threads = NULL; 121 perf_evlist__purge(evlist); 122 perf_evlist__exit(evlist); 123 free(evlist); 124} 125 126void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry) 127{ 128 list_add_tail(&entry->node, &evlist->entries); 129 entry->idx = evlist->nr_entries; 130 entry->tracking = !entry->idx; 131 132 if (!evlist->nr_entries++) 133 perf_evlist__set_id_pos(evlist); 134} 135 136void perf_evlist__splice_list_tail(struct perf_evlist *evlist, 137 struct list_head *list, 138 int nr_entries) 139{ 140 bool set_id_pos = !evlist->nr_entries; 141 142 list_splice_tail(list, &evlist->entries); 143 evlist->nr_entries += nr_entries; 144 if (set_id_pos) 145 perf_evlist__set_id_pos(evlist); 146} 147 148void __perf_evlist__set_leader(struct list_head *list) 149{ 150 struct perf_evsel *evsel, *leader; 151 152 leader = list_entry(list->next, struct perf_evsel, node); 153 evsel = list_entry(list->prev, struct perf_evsel, node); 154 155 leader->nr_members = evsel->idx - leader->idx + 1; 156 157 __evlist__for_each(list, evsel) { 158 evsel->leader = leader; 159 } 160} 161 162void perf_evlist__set_leader(struct perf_evlist *evlist) 163{ 164 if (evlist->nr_entries) { 165 evlist->nr_groups = evlist->nr_entries > 1 ? 1 : 0; 166 __perf_evlist__set_leader(&evlist->entries); 167 } 168} 169 170int perf_evlist__add_default(struct perf_evlist *evlist) 171{ 172 struct perf_event_attr attr = { 173 .type = PERF_TYPE_HARDWARE, 174 .config = PERF_COUNT_HW_CPU_CYCLES, 175 }; 176 struct perf_evsel *evsel; 177 178 event_attr_init(&attr); 179 180 evsel = perf_evsel__new(&attr); 181 if (evsel == NULL) 182 goto error; 183 184 /* use strdup() because free(evsel) assumes name is allocated */ 185 evsel->name = strdup("cycles"); 186 if (!evsel->name) 187 goto error_free; 188 189 perf_evlist__add(evlist, evsel); 190 return 0; 191error_free: 192 perf_evsel__delete(evsel); 193error: 194 return -ENOMEM; 195} 196 197static int perf_evlist__add_attrs(struct perf_evlist *evlist, 198 struct perf_event_attr *attrs, size_t nr_attrs) 199{ 200 struct perf_evsel *evsel, *n; 201 LIST_HEAD(head); 202 size_t i; 203 204 for (i = 0; i < nr_attrs; i++) { 205 evsel = perf_evsel__new_idx(attrs + i, evlist->nr_entries + i); 206 if (evsel == NULL) 207 goto out_delete_partial_list; 208 list_add_tail(&evsel->node, &head); 209 } 210 211 perf_evlist__splice_list_tail(evlist, &head, nr_attrs); 212 213 return 0; 214 215out_delete_partial_list: 216 __evlist__for_each_safe(&head, n, evsel) 217 perf_evsel__delete(evsel); 218 return -1; 219} 220 221int __perf_evlist__add_default_attrs(struct perf_evlist *evlist, 222 struct perf_event_attr *attrs, size_t nr_attrs) 223{ 224 size_t i; 225 226 for (i = 0; i < nr_attrs; i++) 227 event_attr_init(attrs + i); 228 229 return perf_evlist__add_attrs(evlist, attrs, nr_attrs); 230} 231 232struct perf_evsel * 233perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id) 234{ 235 struct perf_evsel *evsel; 236 237 evlist__for_each(evlist, evsel) { 238 if (evsel->attr.type == PERF_TYPE_TRACEPOINT && 239 (int)evsel->attr.config == id) 240 return evsel; 241 } 242 243 return NULL; 244} 245 246struct perf_evsel * 247perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist, 248 const char *name) 249{ 250 struct perf_evsel *evsel; 251 252 evlist__for_each(evlist, evsel) { 253 if ((evsel->attr.type == PERF_TYPE_TRACEPOINT) && 254 (strcmp(evsel->name, name) == 0)) 255 return evsel; 256 } 257 258 return NULL; 259} 260 261int perf_evlist__add_newtp(struct perf_evlist *evlist, 262 const char *sys, const char *name, void *handler) 263{ 264 struct perf_evsel *evsel = perf_evsel__newtp(sys, name); 265 266 if (evsel == NULL) 267 return -1; 268 269 evsel->handler = handler; 270 perf_evlist__add(evlist, evsel); 271 return 0; 272} 273 274static int perf_evlist__nr_threads(struct perf_evlist *evlist, 275 struct perf_evsel *evsel) 276{ 277 if (evsel->system_wide) 278 return 1; 279 else 280 return thread_map__nr(evlist->threads); 281} 282 283void perf_evlist__disable(struct perf_evlist *evlist) 284{ 285 int cpu, thread; 286 struct perf_evsel *pos; 287 int nr_cpus = cpu_map__nr(evlist->cpus); 288 int nr_threads; 289 290 for (cpu = 0; cpu < nr_cpus; cpu++) { 291 evlist__for_each(evlist, pos) { 292 if (!perf_evsel__is_group_leader(pos) || !pos->fd) 293 continue; 294 nr_threads = perf_evlist__nr_threads(evlist, pos); 295 for (thread = 0; thread < nr_threads; thread++) 296 ioctl(FD(pos, cpu, thread), 297 PERF_EVENT_IOC_DISABLE, 0); 298 } 299 } 300} 301 302void perf_evlist__enable(struct perf_evlist *evlist) 303{ 304 int cpu, thread; 305 struct perf_evsel *pos; 306 int nr_cpus = cpu_map__nr(evlist->cpus); 307 int nr_threads; 308 309 for (cpu = 0; cpu < nr_cpus; cpu++) { 310 evlist__for_each(evlist, pos) { 311 if (!perf_evsel__is_group_leader(pos) || !pos->fd) 312 continue; 313 nr_threads = perf_evlist__nr_threads(evlist, pos); 314 for (thread = 0; thread < nr_threads; thread++) 315 ioctl(FD(pos, cpu, thread), 316 PERF_EVENT_IOC_ENABLE, 0); 317 } 318 } 319} 320 321int perf_evlist__disable_event(struct perf_evlist *evlist, 322 struct perf_evsel *evsel) 323{ 324 int cpu, thread, err; 325 int nr_cpus = cpu_map__nr(evlist->cpus); 326 int nr_threads = perf_evlist__nr_threads(evlist, evsel); 327 328 if (!evsel->fd) 329 return 0; 330 331 for (cpu = 0; cpu < nr_cpus; cpu++) { 332 for (thread = 0; thread < nr_threads; thread++) { 333 err = ioctl(FD(evsel, cpu, thread), 334 PERF_EVENT_IOC_DISABLE, 0); 335 if (err) 336 return err; 337 } 338 } 339 return 0; 340} 341 342int perf_evlist__enable_event(struct perf_evlist *evlist, 343 struct perf_evsel *evsel) 344{ 345 int cpu, thread, err; 346 int nr_cpus = cpu_map__nr(evlist->cpus); 347 int nr_threads = perf_evlist__nr_threads(evlist, evsel); 348 349 if (!evsel->fd) 350 return -EINVAL; 351 352 for (cpu = 0; cpu < nr_cpus; cpu++) { 353 for (thread = 0; thread < nr_threads; thread++) { 354 err = ioctl(FD(evsel, cpu, thread), 355 PERF_EVENT_IOC_ENABLE, 0); 356 if (err) 357 return err; 358 } 359 } 360 return 0; 361} 362 363static int perf_evlist__enable_event_cpu(struct perf_evlist *evlist, 364 struct perf_evsel *evsel, int cpu) 365{ 366 int thread, err; 367 int nr_threads = perf_evlist__nr_threads(evlist, evsel); 368 369 if (!evsel->fd) 370 return -EINVAL; 371 372 for (thread = 0; thread < nr_threads; thread++) { 373 err = ioctl(FD(evsel, cpu, thread), 374 PERF_EVENT_IOC_ENABLE, 0); 375 if (err) 376 return err; 377 } 378 return 0; 379} 380 381static int perf_evlist__enable_event_thread(struct perf_evlist *evlist, 382 struct perf_evsel *evsel, 383 int thread) 384{ 385 int cpu, err; 386 int nr_cpus = cpu_map__nr(evlist->cpus); 387 388 if (!evsel->fd) 389 return -EINVAL; 390 391 for (cpu = 0; cpu < nr_cpus; cpu++) { 392 err = ioctl(FD(evsel, cpu, thread), PERF_EVENT_IOC_ENABLE, 0); 393 if (err) 394 return err; 395 } 396 return 0; 397} 398 399int perf_evlist__enable_event_idx(struct perf_evlist *evlist, 400 struct perf_evsel *evsel, int idx) 401{ 402 bool per_cpu_mmaps = !cpu_map__empty(evlist->cpus); 403 404 if (per_cpu_mmaps) 405 return perf_evlist__enable_event_cpu(evlist, evsel, idx); 406 else 407 return perf_evlist__enable_event_thread(evlist, evsel, idx); 408} 409 410int perf_evlist__alloc_pollfd(struct perf_evlist *evlist) 411{ 412 int nr_cpus = cpu_map__nr(evlist->cpus); 413 int nr_threads = thread_map__nr(evlist->threads); 414 int nfds = 0; 415 struct perf_evsel *evsel; 416 417 evlist__for_each(evlist, evsel) { 418 if (evsel->system_wide) 419 nfds += nr_cpus; 420 else 421 nfds += nr_cpus * nr_threads; 422 } 423 424 if (fdarray__available_entries(&evlist->pollfd) < nfds && 425 fdarray__grow(&evlist->pollfd, nfds) < 0) 426 return -ENOMEM; 427 428 return 0; 429} 430 431static int __perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd, int idx) 432{ 433 int pos = fdarray__add(&evlist->pollfd, fd, POLLIN | POLLERR | POLLHUP); 434 /* 435 * Save the idx so that when we filter out fds POLLHUP'ed we can 436 * close the associated evlist->mmap[] entry. 437 */ 438 if (pos >= 0) { 439 evlist->pollfd.priv[pos].idx = idx; 440 441 fcntl(fd, F_SETFL, O_NONBLOCK); 442 } 443 444 return pos; 445} 446 447int perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd) 448{ 449 return __perf_evlist__add_pollfd(evlist, fd, -1); 450} 451 452static void perf_evlist__munmap_filtered(struct fdarray *fda, int fd) 453{ 454 struct perf_evlist *evlist = container_of(fda, struct perf_evlist, pollfd); 455 456 perf_evlist__mmap_put(evlist, fda->priv[fd].idx); 457} 458 459int perf_evlist__filter_pollfd(struct perf_evlist *evlist, short revents_and_mask) 460{ 461 return fdarray__filter(&evlist->pollfd, revents_and_mask, 462 perf_evlist__munmap_filtered); 463} 464 465int perf_evlist__poll(struct perf_evlist *evlist, int timeout) 466{ 467 return fdarray__poll(&evlist->pollfd, timeout); 468} 469 470static void perf_evlist__id_hash(struct perf_evlist *evlist, 471 struct perf_evsel *evsel, 472 int cpu, int thread, u64 id) 473{ 474 int hash; 475 struct perf_sample_id *sid = SID(evsel, cpu, thread); 476 477 sid->id = id; 478 sid->evsel = evsel; 479 hash = hash_64(sid->id, PERF_EVLIST__HLIST_BITS); 480 hlist_add_head(&sid->node, &evlist->heads[hash]); 481} 482 483void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel, 484 int cpu, int thread, u64 id) 485{ 486 perf_evlist__id_hash(evlist, evsel, cpu, thread, id); 487 evsel->id[evsel->ids++] = id; 488} 489 490static int perf_evlist__id_add_fd(struct perf_evlist *evlist, 491 struct perf_evsel *evsel, 492 int cpu, int thread, int fd) 493{ 494 u64 read_data[4] = { 0, }; 495 int id_idx = 1; /* The first entry is the counter value */ 496 u64 id; 497 int ret; 498 499 ret = ioctl(fd, PERF_EVENT_IOC_ID, &id); 500 if (!ret) 501 goto add; 502 503 if (errno != ENOTTY) 504 return -1; 505 506 /* Legacy way to get event id.. All hail to old kernels! */ 507 508 /* 509 * This way does not work with group format read, so bail 510 * out in that case. 511 */ 512 if (perf_evlist__read_format(evlist) & PERF_FORMAT_GROUP) 513 return -1; 514 515 if (!(evsel->attr.read_format & PERF_FORMAT_ID) || 516 read(fd, &read_data, sizeof(read_data)) == -1) 517 return -1; 518 519 if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_ENABLED) 520 ++id_idx; 521 if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) 522 ++id_idx; 523 524 id = read_data[id_idx]; 525 526 add: 527 perf_evlist__id_add(evlist, evsel, cpu, thread, id); 528 return 0; 529} 530 531static void perf_evlist__set_sid_idx(struct perf_evlist *evlist, 532 struct perf_evsel *evsel, int idx, int cpu, 533 int thread) 534{ 535 struct perf_sample_id *sid = SID(evsel, cpu, thread); 536 sid->idx = idx; 537 if (evlist->cpus && cpu >= 0) 538 sid->cpu = evlist->cpus->map[cpu]; 539 else 540 sid->cpu = -1; 541 if (!evsel->system_wide && evlist->threads && thread >= 0) 542 sid->tid = evlist->threads->map[thread]; 543 else 544 sid->tid = -1; 545} 546 547struct perf_sample_id *perf_evlist__id2sid(struct perf_evlist *evlist, u64 id) 548{ 549 struct hlist_head *head; 550 struct perf_sample_id *sid; 551 int hash; 552 553 hash = hash_64(id, PERF_EVLIST__HLIST_BITS); 554 head = &evlist->heads[hash]; 555 556 hlist_for_each_entry(sid, head, node) 557 if (sid->id == id) 558 return sid; 559 560 return NULL; 561} 562 563struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id) 564{ 565 struct perf_sample_id *sid; 566 567 if (evlist->nr_entries == 1) 568 return perf_evlist__first(evlist); 569 570 sid = perf_evlist__id2sid(evlist, id); 571 if (sid) 572 return sid->evsel; 573 574 if (!perf_evlist__sample_id_all(evlist)) 575 return perf_evlist__first(evlist); 576 577 return NULL; 578} 579 580static int perf_evlist__event2id(struct perf_evlist *evlist, 581 union perf_event *event, u64 *id) 582{ 583 const u64 *array = event->sample.array; 584 ssize_t n; 585 586 n = (event->header.size - sizeof(event->header)) >> 3; 587 588 if (event->header.type == PERF_RECORD_SAMPLE) { 589 if (evlist->id_pos >= n) 590 return -1; 591 *id = array[evlist->id_pos]; 592 } else { 593 if (evlist->is_pos > n) 594 return -1; 595 n -= evlist->is_pos; 596 *id = array[n]; 597 } 598 return 0; 599} 600 601static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist, 602 union perf_event *event) 603{ 604 struct perf_evsel *first = perf_evlist__first(evlist); 605 struct hlist_head *head; 606 struct perf_sample_id *sid; 607 int hash; 608 u64 id; 609 610 if (evlist->nr_entries == 1) 611 return first; 612 613 if (!first->attr.sample_id_all && 614 event->header.type != PERF_RECORD_SAMPLE) 615 return first; 616 617 if (perf_evlist__event2id(evlist, event, &id)) 618 return NULL; 619 620 /* Synthesized events have an id of zero */ 621 if (!id) 622 return first; 623 624 hash = hash_64(id, PERF_EVLIST__HLIST_BITS); 625 head = &evlist->heads[hash]; 626 627 hlist_for_each_entry(sid, head, node) { 628 if (sid->id == id) 629 return sid->evsel; 630 } 631 return NULL; 632} 633 634union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx) 635{ 636 struct perf_mmap *md = &evlist->mmap[idx]; 637 u64 head = perf_mmap__read_head(md); 638 u64 old = md->prev; 639 unsigned char *data = md->base + page_size; 640 union perf_event *event = NULL; 641 642 if (evlist->overwrite) { 643 /* 644 * If we're further behind than half the buffer, there's a chance 645 * the writer will bite our tail and mess up the samples under us. 646 * 647 * If we somehow ended up ahead of the head, we got messed up. 648 * 649 * In either case, truncate and restart at head. 650 */ 651 int diff = head - old; 652 if (diff > md->mask / 2 || diff < 0) { 653 fprintf(stderr, "WARNING: failed to keep up with mmap data.\n"); 654 655 /* 656 * head points to a known good entry, start there. 657 */ 658 old = head; 659 } 660 } 661 662 if (old != head) { 663 size_t size; 664 665 event = (union perf_event *)&data[old & md->mask]; 666 size = event->header.size; 667 668 /* 669 * Event straddles the mmap boundary -- header should always 670 * be inside due to u64 alignment of output. 671 */ 672 if ((old & md->mask) + size != ((old + size) & md->mask)) { 673 unsigned int offset = old; 674 unsigned int len = min(sizeof(*event), size), cpy; 675 void *dst = md->event_copy; 676 677 do { 678 cpy = min(md->mask + 1 - (offset & md->mask), len); 679 memcpy(dst, &data[offset & md->mask], cpy); 680 offset += cpy; 681 dst += cpy; 682 len -= cpy; 683 } while (len); 684 685 event = (union perf_event *) md->event_copy; 686 } 687 688 old += size; 689 } 690 691 md->prev = old; 692 693 return event; 694} 695 696static bool perf_mmap__empty(struct perf_mmap *md) 697{ 698 return perf_mmap__read_head(md) == md->prev; 699} 700 701static void perf_evlist__mmap_get(struct perf_evlist *evlist, int idx) 702{ 703 ++evlist->mmap[idx].refcnt; 704} 705 706static void perf_evlist__mmap_put(struct perf_evlist *evlist, int idx) 707{ 708 BUG_ON(evlist->mmap[idx].refcnt == 0); 709 710 if (--evlist->mmap[idx].refcnt == 0) 711 __perf_evlist__munmap(evlist, idx); 712} 713 714void perf_evlist__mmap_consume(struct perf_evlist *evlist, int idx) 715{ 716 struct perf_mmap *md = &evlist->mmap[idx]; 717 718 if (!evlist->overwrite) { 719 u64 old = md->prev; 720 721 perf_mmap__write_tail(md, old); 722 } 723 724 if (md->refcnt == 1 && perf_mmap__empty(md)) 725 perf_evlist__mmap_put(evlist, idx); 726} 727 728static void __perf_evlist__munmap(struct perf_evlist *evlist, int idx) 729{ 730 if (evlist->mmap[idx].base != NULL) { 731 munmap(evlist->mmap[idx].base, evlist->mmap_len); 732 evlist->mmap[idx].base = NULL; 733 evlist->mmap[idx].refcnt = 0; 734 } 735} 736 737void perf_evlist__munmap(struct perf_evlist *evlist) 738{ 739 int i; 740 741 if (evlist->mmap == NULL) 742 return; 743 744 for (i = 0; i < evlist->nr_mmaps; i++) 745 __perf_evlist__munmap(evlist, i); 746 747 zfree(&evlist->mmap); 748} 749 750static int perf_evlist__alloc_mmap(struct perf_evlist *evlist) 751{ 752 evlist->nr_mmaps = cpu_map__nr(evlist->cpus); 753 if (cpu_map__empty(evlist->cpus)) 754 evlist->nr_mmaps = thread_map__nr(evlist->threads); 755 evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap)); 756 return evlist->mmap != NULL ? 0 : -ENOMEM; 757} 758 759struct mmap_params { 760 int prot; 761 int mask; 762}; 763 764static int __perf_evlist__mmap(struct perf_evlist *evlist, int idx, 765 struct mmap_params *mp, int fd) 766{ 767 /* 768 * The last one will be done at perf_evlist__mmap_consume(), so that we 769 * make sure we don't prevent tools from consuming every last event in 770 * the ring buffer. 771 * 772 * I.e. we can get the POLLHUP meaning that the fd doesn't exist 773 * anymore, but the last events for it are still in the ring buffer, 774 * waiting to be consumed. 775 * 776 * Tools can chose to ignore this at their own discretion, but the 777 * evlist layer can't just drop it when filtering events in 778 * perf_evlist__filter_pollfd(). 779 */ 780 evlist->mmap[idx].refcnt = 2; 781 evlist->mmap[idx].prev = 0; 782 evlist->mmap[idx].mask = mp->mask; 783 evlist->mmap[idx].base = mmap(NULL, evlist->mmap_len, mp->prot, 784 MAP_SHARED, fd, 0); 785 if (evlist->mmap[idx].base == MAP_FAILED) { 786 pr_debug2("failed to mmap perf event ring buffer, error %d\n", 787 errno); 788 evlist->mmap[idx].base = NULL; 789 return -1; 790 } 791 792 return 0; 793} 794 795static int perf_evlist__mmap_per_evsel(struct perf_evlist *evlist, int idx, 796 struct mmap_params *mp, int cpu, 797 int thread, int *output) 798{ 799 struct perf_evsel *evsel; 800 801 evlist__for_each(evlist, evsel) { 802 int fd; 803 804 if (evsel->system_wide && thread) 805 continue; 806 807 fd = FD(evsel, cpu, thread); 808 809 if (*output == -1) { 810 *output = fd; 811 if (__perf_evlist__mmap(evlist, idx, mp, *output) < 0) 812 return -1; 813 } else { 814 if (ioctl(fd, PERF_EVENT_IOC_SET_OUTPUT, *output) != 0) 815 return -1; 816 817 perf_evlist__mmap_get(evlist, idx); 818 } 819 820 /* 821 * The system_wide flag causes a selected event to be opened 822 * always without a pid. Consequently it will never get a 823 * POLLHUP, but it is used for tracking in combination with 824 * other events, so it should not need to be polled anyway. 825 * Therefore don't add it for polling. 826 */ 827 if (!evsel->system_wide && 828 __perf_evlist__add_pollfd(evlist, fd, idx) < 0) { 829 perf_evlist__mmap_put(evlist, idx); 830 return -1; 831 } 832 833 if (evsel->attr.read_format & PERF_FORMAT_ID) { 834 if (perf_evlist__id_add_fd(evlist, evsel, cpu, thread, 835 fd) < 0) 836 return -1; 837 perf_evlist__set_sid_idx(evlist, evsel, idx, cpu, 838 thread); 839 } 840 } 841 842 return 0; 843} 844 845static int perf_evlist__mmap_per_cpu(struct perf_evlist *evlist, 846 struct mmap_params *mp) 847{ 848 int cpu, thread; 849 int nr_cpus = cpu_map__nr(evlist->cpus); 850 int nr_threads = thread_map__nr(evlist->threads); 851 852 pr_debug2("perf event ring buffer mmapped per cpu\n"); 853 for (cpu = 0; cpu < nr_cpus; cpu++) { 854 int output = -1; 855 856 for (thread = 0; thread < nr_threads; thread++) { 857 if (perf_evlist__mmap_per_evsel(evlist, cpu, mp, cpu, 858 thread, &output)) 859 goto out_unmap; 860 } 861 } 862 863 return 0; 864 865out_unmap: 866 for (cpu = 0; cpu < nr_cpus; cpu++) 867 __perf_evlist__munmap(evlist, cpu); 868 return -1; 869} 870 871static int perf_evlist__mmap_per_thread(struct perf_evlist *evlist, 872 struct mmap_params *mp) 873{ 874 int thread; 875 int nr_threads = thread_map__nr(evlist->threads); 876 877 pr_debug2("perf event ring buffer mmapped per thread\n"); 878 for (thread = 0; thread < nr_threads; thread++) { 879 int output = -1; 880 881 if (perf_evlist__mmap_per_evsel(evlist, thread, mp, 0, thread, 882 &output)) 883 goto out_unmap; 884 } 885 886 return 0; 887 888out_unmap: 889 for (thread = 0; thread < nr_threads; thread++) 890 __perf_evlist__munmap(evlist, thread); 891 return -1; 892} 893 894static size_t perf_evlist__mmap_size(unsigned long pages) 895{ 896 if (pages == UINT_MAX) { 897 int max; 898 899 if (sysctl__read_int("kernel/perf_event_mlock_kb", &max) < 0) { 900 /* 901 * Pick a once upon a time good value, i.e. things look 902 * strange since we can't read a sysctl value, but lets not 903 * die yet... 904 */ 905 max = 512; 906 } else { 907 max -= (page_size / 1024); 908 } 909 910 pages = (max * 1024) / page_size; 911 if (!is_power_of_2(pages)) 912 pages = rounddown_pow_of_two(pages); 913 } else if (!is_power_of_2(pages)) 914 return 0; 915 916 return (pages + 1) * page_size; 917} 918 919static long parse_pages_arg(const char *str, unsigned long min, 920 unsigned long max) 921{ 922 unsigned long pages, val; 923 static struct parse_tag tags[] = { 924 { .tag = 'B', .mult = 1 }, 925 { .tag = 'K', .mult = 1 << 10 }, 926 { .tag = 'M', .mult = 1 << 20 }, 927 { .tag = 'G', .mult = 1 << 30 }, 928 { .tag = 0 }, 929 }; 930 931 if (str == NULL) 932 return -EINVAL; 933 934 val = parse_tag_value(str, tags); 935 if (val != (unsigned long) -1) { 936 /* we got file size value */ 937 pages = PERF_ALIGN(val, page_size) / page_size; 938 } else { 939 /* we got pages count value */ 940 char *eptr; 941 pages = strtoul(str, &eptr, 10); 942 if (*eptr != '\0') 943 return -EINVAL; 944 } 945 946 if (pages == 0 && min == 0) { 947 /* leave number of pages at 0 */ 948 } else if (!is_power_of_2(pages)) { 949 /* round pages up to next power of 2 */ 950 pages = roundup_pow_of_two(pages); 951 if (!pages) 952 return -EINVAL; 953 pr_info("rounding mmap pages size to %lu bytes (%lu pages)\n", 954 pages * page_size, pages); 955 } 956 957 if (pages > max) 958 return -EINVAL; 959 960 return pages; 961} 962 963int perf_evlist__parse_mmap_pages(const struct option *opt, const char *str, 964 int unset __maybe_unused) 965{ 966 unsigned int *mmap_pages = opt->value; 967 unsigned long max = UINT_MAX; 968 long pages; 969 970 if (max > SIZE_MAX / page_size) 971 max = SIZE_MAX / page_size; 972 973 pages = parse_pages_arg(str, 1, max); 974 if (pages < 0) { 975 pr_err("Invalid argument for --mmap_pages/-m\n"); 976 return -1; 977 } 978 979 *mmap_pages = pages; 980 return 0; 981} 982 983/** 984 * perf_evlist__mmap - Create mmaps to receive events. 985 * @evlist: list of events 986 * @pages: map length in pages 987 * @overwrite: overwrite older events? 988 * 989 * If @overwrite is %false the user needs to signal event consumption using 990 * perf_mmap__write_tail(). Using perf_evlist__mmap_read() does this 991 * automatically. 992 * 993 * Return: %0 on success, negative error code otherwise. 994 */ 995int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages, 996 bool overwrite) 997{ 998 struct perf_evsel *evsel; 999 const struct cpu_map *cpus = evlist->cpus; 1000 const struct thread_map *threads = evlist->threads; 1001 struct mmap_params mp = { 1002 .prot = PROT_READ | (overwrite ? 0 : PROT_WRITE), 1003 }; 1004 1005 if (evlist->mmap == NULL && perf_evlist__alloc_mmap(evlist) < 0) 1006 return -ENOMEM; 1007 1008 if (evlist->pollfd.entries == NULL && perf_evlist__alloc_pollfd(evlist) < 0) 1009 return -ENOMEM; 1010 1011 evlist->overwrite = overwrite; 1012 evlist->mmap_len = perf_evlist__mmap_size(pages); 1013 pr_debug("mmap size %zuB\n", evlist->mmap_len); 1014 mp.mask = evlist->mmap_len - page_size - 1; 1015 1016 evlist__for_each(evlist, evsel) { 1017 if ((evsel->attr.read_format & PERF_FORMAT_ID) && 1018 evsel->sample_id == NULL && 1019 perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0) 1020 return -ENOMEM; 1021 } 1022 1023 if (cpu_map__empty(cpus)) 1024 return perf_evlist__mmap_per_thread(evlist, &mp); 1025 1026 return perf_evlist__mmap_per_cpu(evlist, &mp); 1027} 1028 1029int perf_evlist__create_maps(struct perf_evlist *evlist, struct target *target) 1030{ 1031 evlist->threads = thread_map__new_str(target->pid, target->tid, 1032 target->uid); 1033 1034 if (evlist->threads == NULL) 1035 return -1; 1036 1037 if (target__uses_dummy_map(target)) 1038 evlist->cpus = cpu_map__dummy_new(); 1039 else 1040 evlist->cpus = cpu_map__new(target->cpu_list); 1041 1042 if (evlist->cpus == NULL) 1043 goto out_delete_threads; 1044 1045 return 0; 1046 1047out_delete_threads: 1048 thread_map__delete(evlist->threads); 1049 evlist->threads = NULL; 1050 return -1; 1051} 1052 1053int perf_evlist__apply_filters(struct perf_evlist *evlist, struct perf_evsel **err_evsel) 1054{ 1055 struct perf_evsel *evsel; 1056 int err = 0; 1057 const int ncpus = cpu_map__nr(evlist->cpus), 1058 nthreads = thread_map__nr(evlist->threads); 1059 1060 evlist__for_each(evlist, evsel) { 1061 if (evsel->filter == NULL) 1062 continue; 1063 1064 err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter); 1065 if (err) { 1066 *err_evsel = evsel; 1067 break; 1068 } 1069 } 1070 1071 return err; 1072} 1073 1074int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter) 1075{ 1076 struct perf_evsel *evsel; 1077 int err = 0; 1078 const int ncpus = cpu_map__nr(evlist->cpus), 1079 nthreads = thread_map__nr(evlist->threads); 1080 1081 evlist__for_each(evlist, evsel) { 1082 err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter); 1083 if (err) 1084 break; 1085 } 1086 1087 return err; 1088} 1089 1090int perf_evlist__set_filter_pids(struct perf_evlist *evlist, size_t npids, pid_t *pids) 1091{ 1092 char *filter; 1093 int ret = -1; 1094 size_t i; 1095 1096 for (i = 0; i < npids; ++i) { 1097 if (i == 0) { 1098 if (asprintf(&filter, "common_pid != %d", pids[i]) < 0) 1099 return -1; 1100 } else { 1101 char *tmp; 1102 1103 if (asprintf(&tmp, "%s && common_pid != %d", filter, pids[i]) < 0) 1104 goto out_free; 1105 1106 free(filter); 1107 filter = tmp; 1108 } 1109 } 1110 1111 ret = perf_evlist__set_filter(evlist, filter); 1112out_free: 1113 free(filter); 1114 return ret; 1115} 1116 1117int perf_evlist__set_filter_pid(struct perf_evlist *evlist, pid_t pid) 1118{ 1119 return perf_evlist__set_filter_pids(evlist, 1, &pid); 1120} 1121 1122bool perf_evlist__valid_sample_type(struct perf_evlist *evlist) 1123{ 1124 struct perf_evsel *pos; 1125 1126 if (evlist->nr_entries == 1) 1127 return true; 1128 1129 if (evlist->id_pos < 0 || evlist->is_pos < 0) 1130 return false; 1131 1132 evlist__for_each(evlist, pos) { 1133 if (pos->id_pos != evlist->id_pos || 1134 pos->is_pos != evlist->is_pos) 1135 return false; 1136 } 1137 1138 return true; 1139} 1140 1141u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist) 1142{ 1143 struct perf_evsel *evsel; 1144 1145 if (evlist->combined_sample_type) 1146 return evlist->combined_sample_type; 1147 1148 evlist__for_each(evlist, evsel) 1149 evlist->combined_sample_type |= evsel->attr.sample_type; 1150 1151 return evlist->combined_sample_type; 1152} 1153 1154u64 perf_evlist__combined_sample_type(struct perf_evlist *evlist) 1155{ 1156 evlist->combined_sample_type = 0; 1157 return __perf_evlist__combined_sample_type(evlist); 1158} 1159 1160bool perf_evlist__valid_read_format(struct perf_evlist *evlist) 1161{ 1162 struct perf_evsel *first = perf_evlist__first(evlist), *pos = first; 1163 u64 read_format = first->attr.read_format; 1164 u64 sample_type = first->attr.sample_type; 1165 1166 evlist__for_each(evlist, pos) { 1167 if (read_format != pos->attr.read_format) 1168 return false; 1169 } 1170 1171 /* PERF_SAMPLE_READ imples PERF_FORMAT_ID. */ 1172 if ((sample_type & PERF_SAMPLE_READ) && 1173 !(read_format & PERF_FORMAT_ID)) { 1174 return false; 1175 } 1176 1177 return true; 1178} 1179 1180u64 perf_evlist__read_format(struct perf_evlist *evlist) 1181{ 1182 struct perf_evsel *first = perf_evlist__first(evlist); 1183 return first->attr.read_format; 1184} 1185 1186u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist) 1187{ 1188 struct perf_evsel *first = perf_evlist__first(evlist); 1189 struct perf_sample *data; 1190 u64 sample_type; 1191 u16 size = 0; 1192 1193 if (!first->attr.sample_id_all) 1194 goto out; 1195 1196 sample_type = first->attr.sample_type; 1197 1198 if (sample_type & PERF_SAMPLE_TID) 1199 size += sizeof(data->tid) * 2; 1200 1201 if (sample_type & PERF_SAMPLE_TIME) 1202 size += sizeof(data->time); 1203 1204 if (sample_type & PERF_SAMPLE_ID) 1205 size += sizeof(data->id); 1206 1207 if (sample_type & PERF_SAMPLE_STREAM_ID) 1208 size += sizeof(data->stream_id); 1209 1210 if (sample_type & PERF_SAMPLE_CPU) 1211 size += sizeof(data->cpu) * 2; 1212 1213 if (sample_type & PERF_SAMPLE_IDENTIFIER) 1214 size += sizeof(data->id); 1215out: 1216 return size; 1217} 1218 1219bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist) 1220{ 1221 struct perf_evsel *first = perf_evlist__first(evlist), *pos = first; 1222 1223 evlist__for_each_continue(evlist, pos) { 1224 if (first->attr.sample_id_all != pos->attr.sample_id_all) 1225 return false; 1226 } 1227 1228 return true; 1229} 1230 1231bool perf_evlist__sample_id_all(struct perf_evlist *evlist) 1232{ 1233 struct perf_evsel *first = perf_evlist__first(evlist); 1234 return first->attr.sample_id_all; 1235} 1236 1237void perf_evlist__set_selected(struct perf_evlist *evlist, 1238 struct perf_evsel *evsel) 1239{ 1240 evlist->selected = evsel; 1241} 1242 1243void perf_evlist__close(struct perf_evlist *evlist) 1244{ 1245 struct perf_evsel *evsel; 1246 int ncpus = cpu_map__nr(evlist->cpus); 1247 int nthreads = thread_map__nr(evlist->threads); 1248 int n; 1249 1250 evlist__for_each_reverse(evlist, evsel) { 1251 n = evsel->cpus ? evsel->cpus->nr : ncpus; 1252 perf_evsel__close(evsel, n, nthreads); 1253 } 1254} 1255 1256static int perf_evlist__create_syswide_maps(struct perf_evlist *evlist) 1257{ 1258 int err = -ENOMEM; 1259 1260 /* 1261 * Try reading /sys/devices/system/cpu/online to get 1262 * an all cpus map. 1263 * 1264 * FIXME: -ENOMEM is the best we can do here, the cpu_map 1265 * code needs an overhaul to properly forward the 1266 * error, and we may not want to do that fallback to a 1267 * default cpu identity map :-\ 1268 */ 1269 evlist->cpus = cpu_map__new(NULL); 1270 if (evlist->cpus == NULL) 1271 goto out; 1272 1273 evlist->threads = thread_map__new_dummy(); 1274 if (evlist->threads == NULL) 1275 goto out_free_cpus; 1276 1277 err = 0; 1278out: 1279 return err; 1280out_free_cpus: 1281 cpu_map__delete(evlist->cpus); 1282 evlist->cpus = NULL; 1283 goto out; 1284} 1285 1286int perf_evlist__open(struct perf_evlist *evlist) 1287{ 1288 struct perf_evsel *evsel; 1289 int err; 1290 1291 /* 1292 * Default: one fd per CPU, all threads, aka systemwide 1293 * as sys_perf_event_open(cpu = -1, thread = -1) is EINVAL 1294 */ 1295 if (evlist->threads == NULL && evlist->cpus == NULL) { 1296 err = perf_evlist__create_syswide_maps(evlist); 1297 if (err < 0) 1298 goto out_err; 1299 } 1300 1301 perf_evlist__update_id_pos(evlist); 1302 1303 evlist__for_each(evlist, evsel) { 1304 err = perf_evsel__open(evsel, evlist->cpus, evlist->threads); 1305 if (err < 0) 1306 goto out_err; 1307 } 1308 1309 return 0; 1310out_err: 1311 perf_evlist__close(evlist); 1312 errno = -err; 1313 return err; 1314} 1315 1316int perf_evlist__prepare_workload(struct perf_evlist *evlist, struct target *target, 1317 const char *argv[], bool pipe_output, 1318 void (*exec_error)(int signo, siginfo_t *info, void *ucontext)) 1319{ 1320 int child_ready_pipe[2], go_pipe[2]; 1321 char bf; 1322 1323 if (pipe(child_ready_pipe) < 0) { 1324 perror("failed to create 'ready' pipe"); 1325 return -1; 1326 } 1327 1328 if (pipe(go_pipe) < 0) { 1329 perror("failed to create 'go' pipe"); 1330 goto out_close_ready_pipe; 1331 } 1332 1333 evlist->workload.pid = fork(); 1334 if (evlist->workload.pid < 0) { 1335 perror("failed to fork"); 1336 goto out_close_pipes; 1337 } 1338 1339 if (!evlist->workload.pid) { 1340 int ret; 1341 1342 if (pipe_output) 1343 dup2(2, 1); 1344 1345 signal(SIGTERM, SIG_DFL); 1346 1347 close(child_ready_pipe[0]); 1348 close(go_pipe[1]); 1349 fcntl(go_pipe[0], F_SETFD, FD_CLOEXEC); 1350 1351 /* 1352 * Tell the parent we're ready to go 1353 */ 1354 close(child_ready_pipe[1]); 1355 1356 /* 1357 * Wait until the parent tells us to go. 1358 */ 1359 ret = read(go_pipe[0], &bf, 1); 1360 /* 1361 * The parent will ask for the execvp() to be performed by 1362 * writing exactly one byte, in workload.cork_fd, usually via 1363 * perf_evlist__start_workload(). 1364 * 1365 * For cancelling the workload without actually running it, 1366 * the parent will just close workload.cork_fd, without writing 1367 * anything, i.e. read will return zero and we just exit() 1368 * here. 1369 */ 1370 if (ret != 1) { 1371 if (ret == -1) 1372 perror("unable to read pipe"); 1373 exit(ret); 1374 } 1375 1376 execvp(argv[0], (char **)argv); 1377 1378 if (exec_error) { 1379 union sigval val; 1380 1381 val.sival_int = errno; 1382 if (sigqueue(getppid(), SIGUSR1, val)) 1383 perror(argv[0]); 1384 } else 1385 perror(argv[0]); 1386 exit(-1); 1387 } 1388 1389 if (exec_error) { 1390 struct sigaction act = { 1391 .sa_flags = SA_SIGINFO, 1392 .sa_sigaction = exec_error, 1393 }; 1394 sigaction(SIGUSR1, &act, NULL); 1395 } 1396 1397 if (target__none(target)) { 1398 if (evlist->threads == NULL) { 1399 fprintf(stderr, "FATAL: evlist->threads need to be set at this point (%s:%d).\n", 1400 __func__, __LINE__); 1401 goto out_close_pipes; 1402 } 1403 evlist->threads->map[0] = evlist->workload.pid; 1404 } 1405 1406 close(child_ready_pipe[1]); 1407 close(go_pipe[0]); 1408 /* 1409 * wait for child to settle 1410 */ 1411 if (read(child_ready_pipe[0], &bf, 1) == -1) { 1412 perror("unable to read pipe"); 1413 goto out_close_pipes; 1414 } 1415 1416 fcntl(go_pipe[1], F_SETFD, FD_CLOEXEC); 1417 evlist->workload.cork_fd = go_pipe[1]; 1418 close(child_ready_pipe[0]); 1419 return 0; 1420 1421out_close_pipes: 1422 close(go_pipe[0]); 1423 close(go_pipe[1]); 1424out_close_ready_pipe: 1425 close(child_ready_pipe[0]); 1426 close(child_ready_pipe[1]); 1427 return -1; 1428} 1429 1430int perf_evlist__start_workload(struct perf_evlist *evlist) 1431{ 1432 if (evlist->workload.cork_fd > 0) { 1433 char bf = 0; 1434 int ret; 1435 /* 1436 * Remove the cork, let it rip! 1437 */ 1438 ret = write(evlist->workload.cork_fd, &bf, 1); 1439 if (ret < 0) 1440 perror("enable to write to pipe"); 1441 1442 close(evlist->workload.cork_fd); 1443 return ret; 1444 } 1445 1446 return 0; 1447} 1448 1449int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event, 1450 struct perf_sample *sample) 1451{ 1452 struct perf_evsel *evsel = perf_evlist__event2evsel(evlist, event); 1453 1454 if (!evsel) 1455 return -EFAULT; 1456 return perf_evsel__parse_sample(evsel, event, sample); 1457} 1458 1459size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp) 1460{ 1461 struct perf_evsel *evsel; 1462 size_t printed = 0; 1463 1464 evlist__for_each(evlist, evsel) { 1465 printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "", 1466 perf_evsel__name(evsel)); 1467 } 1468 1469 return printed + fprintf(fp, "\n"); 1470} 1471 1472int perf_evlist__strerror_open(struct perf_evlist *evlist __maybe_unused, 1473 int err, char *buf, size_t size) 1474{ 1475 int printed, value; 1476 char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf)); 1477 1478 switch (err) { 1479 case EACCES: 1480 case EPERM: 1481 printed = scnprintf(buf, size, 1482 "Error:\t%s.\n" 1483 "Hint:\tCheck /proc/sys/kernel/perf_event_paranoid setting.", emsg); 1484 1485 value = perf_event_paranoid(); 1486 1487 printed += scnprintf(buf + printed, size - printed, "\nHint:\t"); 1488 1489 if (value >= 2) { 1490 printed += scnprintf(buf + printed, size - printed, 1491 "For your workloads it needs to be <= 1\nHint:\t"); 1492 } 1493 printed += scnprintf(buf + printed, size - printed, 1494 "For system wide tracing it needs to be set to -1.\n"); 1495 1496 printed += scnprintf(buf + printed, size - printed, 1497 "Hint:\tTry: 'sudo sh -c \"echo -1 > /proc/sys/kernel/perf_event_paranoid\"'\n" 1498 "Hint:\tThe current value is %d.", value); 1499 break; 1500 default: 1501 scnprintf(buf, size, "%s", emsg); 1502 break; 1503 } 1504 1505 return 0; 1506} 1507 1508int perf_evlist__strerror_mmap(struct perf_evlist *evlist, int err, char *buf, size_t size) 1509{ 1510 char sbuf[STRERR_BUFSIZE], *emsg = strerror_r(err, sbuf, sizeof(sbuf)); 1511 int pages_attempted = evlist->mmap_len / 1024, pages_max_per_user, printed = 0; 1512 1513 switch (err) { 1514 case EPERM: 1515 sysctl__read_int("kernel/perf_event_mlock_kb", &pages_max_per_user); 1516 printed += scnprintf(buf + printed, size - printed, 1517 "Error:\t%s.\n" 1518 "Hint:\tCheck /proc/sys/kernel/perf_event_mlock_kb (%d kB) setting.\n" 1519 "Hint:\tTried using %zd kB.\n", 1520 emsg, pages_max_per_user, pages_attempted); 1521 1522 if (pages_attempted >= pages_max_per_user) { 1523 printed += scnprintf(buf + printed, size - printed, 1524 "Hint:\tTry 'sudo sh -c \"echo %d > /proc/sys/kernel/perf_event_mlock_kb\"', or\n", 1525 pages_max_per_user + pages_attempted); 1526 } 1527 1528 printed += scnprintf(buf + printed, size - printed, 1529 "Hint:\tTry using a smaller -m/--mmap-pages value."); 1530 break; 1531 default: 1532 scnprintf(buf, size, "%s", emsg); 1533 break; 1534 } 1535 1536 return 0; 1537} 1538 1539void perf_evlist__to_front(struct perf_evlist *evlist, 1540 struct perf_evsel *move_evsel) 1541{ 1542 struct perf_evsel *evsel, *n; 1543 LIST_HEAD(move); 1544 1545 if (move_evsel == perf_evlist__first(evlist)) 1546 return; 1547 1548 evlist__for_each_safe(evlist, n, evsel) { 1549 if (evsel->leader == move_evsel->leader) 1550 list_move_tail(&evsel->node, &move); 1551 } 1552 1553 list_splice(&move, &evlist->entries); 1554} 1555 1556void perf_evlist__set_tracking_event(struct perf_evlist *evlist, 1557 struct perf_evsel *tracking_evsel) 1558{ 1559 struct perf_evsel *evsel; 1560 1561 if (tracking_evsel->tracking) 1562 return; 1563 1564 evlist__for_each(evlist, evsel) { 1565 if (evsel != tracking_evsel) 1566 evsel->tracking = false; 1567 } 1568 1569 tracking_evsel->tracking = true; 1570} 1571