Lines Matching +full:term +full:- +full:range +full:- +full:adj
1 // SPDX-License-Identifier: GPL-2.0-only
4 * Copyright (c) 2013-2015, Intel Corporation.
38 #include "util/synthetic-events.h"
49 #include <subcmd/parse-options.h>
51 #include "cs-etm.h"
52 #include "intel-pt.h"
53 #include "intel-bts.h"
54 #include "arm-spe.h"
55 #include "hisi-ptt.h"
56 #include "s390-cpumsf.h"
74 return -EINVAL;
81 evsel->core.nr_members <= 1)))
82 return -EINVAL;
95 if (leader->core.nr_members < 1)
96 leader->core.nr_members = 1;
97 leader->core.nr_members += 1;
111 return !session->itrace_synth_opts ||
112 session->itrace_synth_opts->dont_decode;
121 WARN_ONCE(mm->base, "Uninitialized auxtrace_mmap\n");
123 mm->userpg = userpg;
124 mm->mask = mp->mask;
125 mm->len = mp->len;
126 mm->prev = 0;
127 mm->idx = mp->idx;
128 mm->tid = mp->tid;
129 mm->cpu = mp->cpu.cpu;
131 if (!mp->len || !mp->mmap_needed) {
132 mm->base = NULL;
136 pc->aux_offset = mp->offset;
137 pc->aux_size = mp->len;
139 mm->base = mmap(NULL, mp->len, mp->prot, MAP_SHARED, fd, mp->offset);
140 if (mm->base == MAP_FAILED) {
142 mm->base = NULL;
143 return -1;
151 if (mm->base) {
152 munmap(mm->base, mm->len);
153 mm->base = NULL;
163 mp->offset = auxtrace_offset;
164 mp->len = auxtrace_pages * (size_t)page_size;
165 mp->mask = is_power_of_2(mp->len) ? mp->len - 1 : 0;
166 mp->prot = PROT_READ | (auxtrace_overwrite ? 0 : PROT_WRITE);
167 pr_debug2("AUX area mmap length %zu\n", mp->len);
169 mp->len = 0;
177 bool per_cpu = !perf_cpu_map__has_any_cpu(evlist->core.user_requested_cpus);
179 mp->mmap_needed = evsel->needs_auxtrace_mmap;
181 if (!mp->mmap_needed)
184 mp->idx = idx;
187 mp->cpu = perf_cpu_map__cpu(evlist->core.all_cpus, idx);
188 if (evlist->core.threads)
189 mp->tid = perf_thread_map__pid(evlist->core.threads, 0);
191 mp->tid = -1;
193 mp->cpu.cpu = -1;
194 mp->tid = perf_thread_map__pid(evlist->core.threads, idx);
223 queues->nr_queues = nr_queues;
224 queues->queue_array = auxtrace_alloc_queue_array(queues->nr_queues);
225 if (!queues->queue_array)
226 return -ENOMEM;
238 unsigned int nr_queues = queues->nr_queues;
248 if (nr_queues < queues->nr_queues || nr_queues < new_nr_queues)
249 return -EINVAL;
253 return -ENOMEM;
255 for (i = 0; i < queues->nr_queues; i++) {
256 list_splice_tail(&queues->queue_array[i].head,
258 queue_array[i].tid = queues->queue_array[i].tid;
259 queue_array[i].cpu = queues->queue_array[i].cpu;
260 queue_array[i].set = queues->queue_array[i].set;
261 queue_array[i].priv = queues->queue_array[i].priv;
264 queues->nr_queues = nr_queues;
265 queues->queue_array = queue_array;
272 int fd = perf_data__fd(session->data);
299 if (idx >= queues->nr_queues) {
305 queue = &queues->queue_array[idx];
307 if (!queue->set) {
308 queue->set = true;
309 queue->tid = buffer->tid;
310 queue->cpu = buffer->cpu.cpu;
313 buffer->buffer_nr = queues->next_buffer_nr++;
315 list_add_tail(&buffer->list, &queue->head);
317 queues->new_data = true;
318 queues->populated = true;
323 /* Limit buffers to 32MiB on 32-bit */
330 u64 sz = buffer->size;
338 return -ENOMEM;
339 b->size = BUFFER_LIMIT_FOR_32_BIT;
340 b->consecutive = consecutive;
346 buffer->data_offset += BUFFER_LIMIT_FOR_32_BIT;
347 sz -= BUFFER_LIMIT_FOR_32_BIT;
351 buffer->size = sz;
352 buffer->consecutive = consecutive;
359 unsigned long *cpu_bitmap = session->itrace_synth_opts->cpu_bitmap;
361 return cpu_bitmap && cpu.cpu != -1 && !test_bit(cpu.cpu, cpu_bitmap);
370 int err = -ENOMEM;
372 if (filter_cpu(session, buffer->cpu))
377 return -ENOMEM;
379 if (session->one_mmap) {
380 buffer->data = buffer->data_offset - session->one_mmap_offset +
381 session->one_mmap_addr;
382 } else if (perf_data__is_pipe(session->data)) {
383 buffer->data = auxtrace_copy_data(buffer->size, session);
384 if (!buffer->data)
386 buffer->data_needs_freeing = true;
388 buffer->size > BUFFER_LIMIT_FOR_32_BIT) {
415 .pid = -1,
416 .tid = event->auxtrace.tid,
417 .cpu = { event->auxtrace.cpu },
419 .offset = event->auxtrace.offset,
420 .reference = event->auxtrace.reference,
421 .size = event->auxtrace.size,
423 unsigned int idx = event->auxtrace.idx;
442 if (event->header.type == PERF_RECORD_AUXTRACE) {
443 if (event->header.size < sizeof(struct perf_record_auxtrace) ||
444 event->header.size != sz) {
445 err = -EINVAL;
448 file_offset += event->header.size;
460 for (i = 0; i < queues->nr_queues; i++) {
461 while (!list_empty(&queues->queue_array[i].head)) {
464 buffer = list_entry(queues->queue_array[i].head.next,
466 list_del_init(&buffer->list);
471 zfree(&queues->queue_array);
472 queues->nr_queues = 0;
482 parent = (pos - 1) >> 1;
497 if (queue_nr >= heap->heap_sz) {
502 heap_array = realloc(heap->heap_array,
505 return -ENOMEM;
506 heap->heap_array = heap_array;
507 heap->heap_sz = heap_sz;
510 auxtrace_heapify(heap->heap_array, heap->heap_cnt++, queue_nr, ordinal);
517 zfree(&heap->heap_array);
518 heap->heap_cnt = 0;
519 heap->heap_sz = 0;
524 unsigned int pos, last, heap_cnt = heap->heap_cnt;
530 heap->heap_cnt -= 1;
532 heap_array = heap->heap_array;
555 last = heap_cnt - 1;
564 return itr->info_priv_size(itr, evlist);
571 return -EINVAL;
580 return itr->info_fill(itr, session, auxtrace_info, priv_size);
587 itr->free(itr);
592 if (itr && itr->snapshot_start)
593 return itr->snapshot_start(itr);
599 if (!on_exit && itr && itr->snapshot_finish)
600 return itr->snapshot_finish(itr);
608 if (itr && itr->find_snapshot)
609 return itr->find_snapshot(itr, idx, mm, data, head, old);
618 itr->evlist = evlist;
619 return itr->recording_options(itr, evlist, opts);
627 return itr->reference(itr);
637 /* PMU-agnostic options */
640 opts->auxtrace_snapshot_on_exit = true;
647 if (itr && itr->parse_snapshot_options)
648 return itr->parse_snapshot_options(itr, opts, str);
651 return -EINVAL;
656 bool per_cpu_mmaps = !perf_cpu_map__has_any_cpu(evlist->core.user_requested_cpus);
659 struct perf_cpu evlist_cpu = perf_cpu_map__cpu(evlist->core.all_cpus, idx);
660 int cpu_map_idx = perf_cpu_map__idx(evsel->core.cpus, evlist_cpu);
662 if (cpu_map_idx == -1)
663 return -EINVAL;
664 return perf_evsel__enable_cpu(&evsel->core, cpu_map_idx);
667 return perf_evsel__enable_thread(&evsel->core, idx);
674 if (!itr->evlist)
675 return -EINVAL;
677 evlist__for_each_entry(itr->evlist, evsel) {
679 if (evsel->disabled)
681 return evlist__enable_event_idx(itr->evlist, evsel, idx);
684 return -EINVAL;
688 * Event record size is 16-bit which results in a maximum size of about 64KiB.
705 sz = evsel->core.attr.aux_sample_size;
713 return -EINVAL;
719 return -EINVAL;
724 return -EINVAL;
727 opts->auxtrace_sample_mode = true;
733 if (!opts->auxtrace_sample_mode) {
735 return -EINVAL;
740 return -EINVAL;
750 struct evsel_config_term *term;
763 return -EINVAL;
769 return -EINVAL;
773 sz = itr->default_aux_sample_size;
778 /* Set aux_sample_size based on --aux-sample option */
783 evsel->core.attr.aux_sample_size = sz;
788 /* Override with aux_sample_size from config term */
792 term = evsel__get_config_term(evsel, AUX_SAMPLE_SIZE);
793 if (term) {
795 evsel->core.attr.aux_sample_size = term->val.aux_sample_size;
797 if (aux_evsel && evsel->core.attr.aux_sample_size)
807 return -EINVAL;
818 {"start-paused", BIT(0), true},
831 for (opt = aux_action_opts; opt->str; opt++)
832 if (!strcmp(str, opt->str))
840 struct evsel_config_term *term;
850 term = evsel__get_config_term(evsel, AUX_ACTION);
851 if (!term) {
856 opt = auxtrace_parse_aux_action_str(term->val.str);
858 pr_err("Bad aux-action '%s'\n", term->val.str);
859 return -EINVAL;
861 if (opt->aux_event_opt && !is_aux_event) {
862 pr_err("aux-action '%s' can only be used with AUX area event\n",
863 term->val.str);
864 return -EINVAL;
866 if (!opt->aux_event_opt && is_aux_event) {
867 pr_err("aux-action '%s' cannot be used for AUX area event itself\n",
868 term->val.str);
869 return -EINVAL;
871 evsel->core.attr.aux_action = opt->aux_action;
877 pr_err("Events with aux-action must have AUX area event group leader\n");
878 return -EINVAL;
898 return -ENOMEM;
900 auxtrace_index->nr = 0;
901 INIT_LIST_HEAD(&auxtrace_index->list);
903 list_add_tail(&auxtrace_index->list, head);
913 list_del_init(&auxtrace_index->list);
929 auxtrace_index = list_entry(head->prev, struct auxtrace_index, list);
931 if (auxtrace_index->nr >= PERF_AUXTRACE_INDEX_ENTRY_COUNT) {
935 auxtrace_index = list_entry(head->prev, struct auxtrace_index,
950 return -ENOMEM;
952 nr = auxtrace_index->nr;
953 auxtrace_index->entries[nr].file_offset = file_offset;
954 auxtrace_index->entries[nr].sz = event->header.size;
955 auxtrace_index->nr += 1;
966 for (i = 0; i < auxtrace_index->nr; i++) {
967 ent.file_offset = auxtrace_index->entries[i].file_offset;
968 ent.sz = auxtrace_index->entries[i].sz;
970 return -errno;
982 total += auxtrace_index->nr;
985 return -errno;
1004 return -1;
1008 return -1;
1010 nr = auxtrace_index->nr;
1012 auxtrace_index->entries[nr].file_offset =
1014 auxtrace_index->entries[nr].sz = bswap_64(ent.sz);
1016 auxtrace_index->entries[nr].file_offset = ent.file_offset;
1017 auxtrace_index->entries[nr].sz = ent.sz;
1020 auxtrace_index->nr = nr + 1;
1028 struct list_head *head = &session->auxtrace_index;
1032 return -1;
1038 return -1;
1040 while (nr--) {
1045 return -1;
1056 ent->file_offset, ent->sz);
1070 list_for_each_entry(auxtrace_index, &session->auxtrace_index, list) {
1071 for (i = 0; i < auxtrace_index->nr; i++) {
1072 ent = &auxtrace_index->entries[i];
1087 if (list_is_last(&buffer->list, &queue->head))
1089 return list_entry(buffer->list.next, struct auxtrace_buffer,
1092 if (list_empty(&queue->head))
1094 return list_entry(queue->head.next, struct auxtrace_buffer,
1107 id = sample->id;
1111 sid = evlist__id2sid(session->evlist, id);
1115 idx = sid->idx;
1117 if (idx >= queues->nr_queues)
1120 return &queues->queue_array[idx];
1129 .pid = -1,
1132 .size = sample->aux_sample.size,
1135 u64 id = sample->id;
1139 return -EINVAL;
1141 sid = evlist__id2sid(session->evlist, id);
1143 return -ENOENT;
1145 idx = sid->idx;
1146 buffer.tid = sid->tid;
1147 buffer.cpu = sid->cpu;
1165 if (qd->events && event->header.type == PERF_RECORD_AUXTRACE) {
1166 if (event->header.size < sizeof(struct perf_record_auxtrace))
1167 return -EINVAL;
1168 offset += event->header.size;
1169 return session->auxtrace->queue_data(session, NULL, event,
1173 if (!qd->samples || event->header.type != PERF_RECORD_SAMPLE)
1177 err = evlist__parse_sample(session->evlist, event, &sample);
1182 offset += sample.aux_sample.data - (void *)event;
1184 err = session->auxtrace->queue_data(session, &sample, NULL, offset);
1201 if (perf_data__is_pipe(session->data))
1204 if (!session->auxtrace || !session->auxtrace->queue_data)
1205 return -EINVAL;
1207 return perf_session__peek_events(session, session->header.data_offset,
1208 session->header.data_size,
1215 size_t adj = buffer->data_offset & (page_size - 1);
1216 size_t size = buffer->size + adj;
1217 off_t file_offset = buffer->data_offset - adj;
1220 if (buffer->data)
1221 return buffer->data;
1227 buffer->mmap_addr = addr;
1228 buffer->mmap_size = size;
1230 buffer->data = addr + adj;
1232 return buffer->data;
1237 if (!buffer->data || !buffer->mmap_addr)
1239 munmap(buffer->mmap_addr, buffer->mmap_size);
1240 buffer->mmap_addr = NULL;
1241 buffer->mmap_size = 0;
1242 buffer->data = NULL;
1243 buffer->use_data = NULL;
1249 if (buffer->data_needs_freeing) {
1250 buffer->data_needs_freeing = false;
1251 zfree(&buffer->data);
1252 buffer->use_data = NULL;
1253 buffer->size = 0;
1272 auxtrace_error->header.type = PERF_RECORD_AUXTRACE_ERROR;
1273 auxtrace_error->type = type;
1274 auxtrace_error->code = code;
1275 auxtrace_error->cpu = cpu;
1276 auxtrace_error->pid = pid;
1277 auxtrace_error->tid = tid;
1278 auxtrace_error->fmt = 1;
1279 auxtrace_error->ip = ip;
1280 auxtrace_error->time = timestamp;
1281 strlcpy(auxtrace_error->msg, msg, MAX_AUXTRACE_ERROR_MSG);
1283 auxtrace_error->fmt = 2;
1284 auxtrace_error->machine_pid = machine_pid;
1285 auxtrace_error->vcpu = vcpu;
1288 size = (void *)auxtrace_error->msg - (void *)auxtrace_error +
1289 strlen(auxtrace_error->msg) + 1;
1291 auxtrace_error->header.size = PERF_ALIGN(size, sizeof(u64));
1299 ip, msg, timestamp, 0, -1);
1312 priv_size = auxtrace_record__info_priv_size(itr, session->evlist);
1315 return -ENOMEM;
1317 ev->auxtrace_info.header.type = PERF_RECORD_AUXTRACE_INFO;
1318 ev->auxtrace_info.header.size = sizeof(struct perf_record_auxtrace_info) +
1320 err = auxtrace_record__info_fill(itr, session, &ev->auxtrace_info,
1347 zfree(&new_leader->group_name);
1348 new_leader->group_name = leader->group_name;
1349 leader->group_name = NULL;
1351 new_leader->core.nr_members = leader->core.nr_members - 1;
1352 leader->core.nr_members = 1;
1360 evlist__for_each_entry(session->evlist, evsel) {
1363 unleader_evsel(session->evlist, evsel);
1371 enum auxtrace_type type = event->auxtrace_info.type;
1398 return -EINVAL;
1416 event->auxtrace.size, event->auxtrace.offset,
1417 event->auxtrace.reference, event->auxtrace.idx,
1418 event->auxtrace.tid, event->auxtrace.cpu);
1421 return event->auxtrace.size;
1423 if (!session->auxtrace || event->header.type != PERF_RECORD_AUXTRACE)
1424 return -EINVAL;
1426 err = session->auxtrace->process_auxtrace_event(session, event, session->tool);
1430 return event->auxtrace.size;
1443 synth_opts->branches = true;
1444 synth_opts->transactions = true;
1445 synth_opts->ptwrites = true;
1446 synth_opts->pwr_events = true;
1447 synth_opts->other_events = true;
1448 synth_opts->intr_events = true;
1449 synth_opts->errors = true;
1450 synth_opts->flc = true;
1451 synth_opts->llc = true;
1452 synth_opts->tlb = true;
1453 synth_opts->mem = true;
1454 synth_opts->remote_access = true;
1457 synth_opts->period_type = PERF_ITRACE_PERIOD_INSTRUCTIONS;
1458 synth_opts->period = 1;
1459 synth_opts->calls = true;
1461 synth_opts->instructions = true;
1462 synth_opts->cycles = true;
1463 synth_opts->period_type = PERF_ITRACE_DEFAULT_PERIOD_TYPE;
1464 synth_opts->period = PERF_ITRACE_DEFAULT_PERIOD;
1466 synth_opts->callchain_sz = PERF_ITRACE_DEFAULT_CALLCHAIN_SZ;
1467 synth_opts->last_branch_sz = PERF_ITRACE_DEFAULT_LAST_BRANCH_SZ;
1468 synth_opts->initial_skip = 0;
1477 *flags |= 1 << (c - 'a');
1484 return -1;
1496 return -1;
1498 case '-':
1501 return -1;
1518 perf_config_scan("itrace.debug-log-buffer-size", "%u", &sz);
1523 * Please check tools/perf/Documentation/perf-script.txt for information
1536 synth_opts->set = true;
1539 synth_opts->dont_decode = true;
1545 synth_opts->default_no_sample);
1554 if (p[-1] == 'y')
1555 synth_opts->cycles = true;
1557 synth_opts->instructions = true;
1561 synth_opts->period = strtoull(p, &endptr, 10);
1568 synth_opts->period_type =
1573 synth_opts->period_type =
1578 synth_opts->period *= 1000;
1581 synth_opts->period *= 1000;
1586 synth_opts->period_type =
1598 synth_opts->branches = true;
1601 synth_opts->transactions = true;
1604 synth_opts->ptwrites = true;
1607 synth_opts->pwr_events = true;
1610 synth_opts->other_events = true;
1613 synth_opts->intr_events = true;
1616 synth_opts->errors = true;
1617 if (get_flags(&p, &synth_opts->error_plus_flags,
1618 &synth_opts->error_minus_flags))
1622 synth_opts->log = true;
1623 if (get_flags(&p, &synth_opts->log_plus_flags,
1624 &synth_opts->log_minus_flags))
1626 if (synth_opts->log_plus_flags & AUXTRACE_LOG_FLG_ON_ERROR)
1627 synth_opts->log_on_error_size = itrace_log_on_error_size();
1630 synth_opts->branches = true;
1631 synth_opts->calls = true;
1634 synth_opts->branches = true;
1635 synth_opts->returns = true;
1639 if (p[-1] == 'G')
1640 synth_opts->add_callchain = true;
1642 synth_opts->callchain = true;
1643 synth_opts->callchain_sz =
1654 synth_opts->callchain_sz = val;
1659 if (p[-1] == 'L')
1660 synth_opts->add_last_branch = true;
1662 synth_opts->last_branch = true;
1663 synth_opts->last_branch_sz =
1675 synth_opts->last_branch_sz = val;
1679 synth_opts->initial_skip = strtoul(p, &endptr, 10);
1685 synth_opts->flc = true;
1688 synth_opts->llc = true;
1691 synth_opts->tlb = true;
1694 synth_opts->remote_access = true;
1697 synth_opts->mem = true;
1700 synth_opts->quick += 1;
1703 synth_opts->approx_ipc = true;
1706 synth_opts->timeless_decoding = true;
1709 synth_opts->use_timestamp = true;
1721 synth_opts->period_type =
1724 synth_opts->period = PERF_ITRACE_DEFAULT_PERIOD;
1731 return -EINVAL;
1736 return itrace_do_parse_synth_opts(opt->value, str, unset);
1756 struct perf_record_auxtrace_error *e = &event->auxtrace_error;
1757 unsigned long long nsecs = e->time;
1758 const char *msg = e->msg;
1762 auxtrace_error_name(e->type), e->type);
1764 if (e->fmt && nsecs) {
1767 nsecs -= secs * NSEC_PER_SEC;
1773 if (!e->fmt)
1774 msg = (const char *)&e->time;
1776 if (e->fmt >= 2 && e->machine_pid)
1777 ret += fprintf(fp, " machine_pid %d vcpu %d", e->machine_pid, e->vcpu);
1780 e->cpu, e->pid, e->tid, e->ip, e->code, msg);
1787 struct perf_record_auxtrace_error *e = &event->auxtrace_error;
1789 if (e->type < PERF_AUXTRACE_ERROR_MAX)
1790 session->evlist->stats.nr_auxtrace_errors[e->type] += 1;
1798 if (!stats->nr_auxtrace_errors[i])
1801 stats->nr_auxtrace_errors[i],
1817 * In the compat mode kernel runs in 64-bit and perf tool runs in 32-bit mode,
1818 * 32-bit perf tool cannot access 64-bit value atomically, which might lead to
1820 * accesses either the load operation or the store operation for 64-bit value,
1822 * is for accessing the low 32-bit value and another is for the high 32-bit;
1824 * 64-bit value, and thus leads to the unexpected load values.
1826 * kernel (64-bit) user (32-bit)
1828 * if (LOAD ->aux_tail) { --, LOAD ->aux_head_lo
1829 * STORE $aux_data | ,--->
1830 * FLUSH $aux_data | | LOAD ->aux_head_hi
1831 * STORE ->aux_head --|-------` smp_rmb()
1834 * | STORE ->aux_tail_lo
1835 * `----------->
1836 * STORE ->aux_tail_hi
1843 * high 32-bit.
1856 * promise the atomicity for 64-bit write, so return '-1' in this case to tell
1861 struct perf_event_mmap_page *pc = mm->userpg;
1866 first = READ_ONCE(pc->aux_head);
1869 second = READ_ONCE(pc->aux_head);
1872 last = READ_ONCE(pc->aux_head);
1880 struct perf_event_mmap_page *pc = mm->userpg;
1884 return -1;
1888 WRITE_ONCE(pc->aux_tail, tail);
1897 struct auxtrace_mmap *mm = &map->auxtrace_mmap;
1898 u64 head, old = mm->prev, offset, ref;
1899 unsigned char *data = mm->base;
1908 auxtrace_record__find_snapshot(itr, mm->idx, mm, data, &head, &old))
1909 return -1;
1915 mm->idx, old, head, head - old);
1917 if (mm->mask) {
1918 head_off = head & mm->mask;
1919 old_off = old & mm->mask;
1921 head_off = head % mm->len;
1922 old_off = old % mm->len;
1926 size = head_off - old_off;
1928 size = mm->len - (old_off - head_off);
1935 if (head > old || size <= head || mm->mask) {
1936 offset = head - size;
1943 u64 rem = (0ULL - mm->len) % mm->len;
1945 offset = head - size - rem;
1949 len1 = size - head_off;
1950 data1 = &data[mm->len - len1];
1955 data1 = &data[head_off - len1];
1960 if (itr->alignment) {
1961 unsigned int unwanted = len1 % itr->alignment;
1963 len1 -= unwanted;
1964 size -= unwanted;
1968 padding = size & (PERF_AUXTRACE_RECORD_ALIGNMENT - 1);
1970 padding = PERF_AUXTRACE_RECORD_ALIGNMENT - padding;
1978 ev.auxtrace.idx = mm->idx;
1979 ev.auxtrace.tid = mm->tid;
1980 ev.auxtrace.cpu = mm->cpu;
1983 return -1;
1985 mm->prev = head;
1994 if (itr->read_finish) {
1995 err = itr->read_finish(itr, mm->idx);
2019 * struct auxtrace_cache - hash table to implement a cache
2057 c->hashtable = ht;
2058 c->sz = sz;
2059 c->entry_size = entry_size;
2060 c->limit = (c->sz * limit_percent) / 100;
2061 c->bits = bits;
2079 for (i = 0; i < c->sz; i++) {
2080 hlist_for_each_entry_safe(entry, tmp, &c->hashtable[i], hash) {
2081 hlist_del(&entry->hash);
2086 c->cnt = 0;
2095 zfree(&c->hashtable);
2101 return malloc(c->entry_size);
2113 if (c->limit && ++c->cnt > c->limit)
2116 entry->key = key;
2117 hlist_add_head(&entry->hash, &c->hashtable[hash_32(key, c->bits)]);
2132 hlist = &c->hashtable[hash_32(key, c->bits)];
2134 if (entry->key == key) {
2135 hlist_del(&entry->hash);
2158 hlist = &c->hashtable[hash_32(key, c->bits)];
2160 if (entry->key == key)
2169 zfree(&filt->str);
2170 filt->action = NULL;
2171 filt->sym_from = NULL;
2172 filt->sym_to = NULL;
2173 filt->filename = NULL;
2181 INIT_LIST_HEAD(&filt->list);
2196 list_add_tail(&filt->list, &filts->head);
2197 filts->cnt += 1;
2203 list_del_init(&filt->list);
2204 filts->cnt -= 1;
2209 INIT_LIST_HEAD(&filts->head);
2210 filts->cnt = 0;
2217 list_for_each_entry_safe(filt, n, &filts->head, list) {
2232 return -EINVAL;
2236 return -errno;
2238 return -EINVAL;
2244 return -EINVAL;
2249 return -EINVAL;
2261 if (!strcmp(filt->action, "filter")) {
2262 filt->start = true;
2263 filt->range = true;
2264 } else if (!strcmp(filt->action, "start")) {
2265 filt->start = true;
2266 } else if (!strcmp(filt->action, "stop")) {
2267 filt->start = false;
2268 } else if (!strcmp(filt->action, "tracestop")) {
2269 filt->start = false;
2270 filt->range = true;
2271 filt->action += 5; /* Change 'tracestop' to 'stop' */
2273 return -EINVAL;
2280 *idx = -1;
2299 return -errno;
2301 return -EINVAL;
2324 filt->str = fstr = strdup(*filter_inp);
2326 return -ENOMEM;
2328 err = parse_num_or_str(&fstr, NULL, &filt->action, " ");
2336 err = parse_addr_size(&fstr, &filt->addr, &filt->sym_from,
2337 &filt->sym_from_idx);
2345 err = parse_addr_size(&fstr, &filt->size, &filt->sym_to,
2346 &filt->sym_to_idx);
2349 filt->range = true;
2356 err = parse_num_or_str(&fstr, NULL, &filt->filename, " ,");
2363 *filter_inp += fstr - filt->str;
2419 kern_sym_name_match(name, args->name) &&
2420 ((args->global && isupper(type)) ||
2421 (args->selected && ++(args->cnt) == args->idx) ||
2422 (!args->global && !args->selected));
2429 if (args->started) {
2430 if (!args->size)
2431 args->size = start - args->start;
2432 if (args->selected) {
2433 if (args->size)
2436 args->duplicate = true;
2440 args->started = true;
2441 args->start = start;
2453 ++args->cnt, start, type, name);
2454 args->near = true;
2455 } else if (args->near) {
2456 args->near = false;
2475 return -EINVAL;
2504 return -EINVAL;
2527 if (!args->started) {
2528 args->started = true;
2529 args->start = start;
2532 size = round_up(start, page_size) + page_size - args->start;
2533 if (size > args->size)
2534 args->size = size;
2550 filt->addr = args.start;
2551 filt->size = args.size;
2558 if (start + size >= filt->addr)
2561 if (filt->sym_from) {
2563 filt->sym_to, start, filt->sym_from, filt->addr);
2566 filt->sym_to, start, filt->addr);
2569 return -EINVAL;
2580 return -EINVAL;
2583 if (filt->sym_from && !strcmp(filt->sym_from, "*"))
2586 if (filt->sym_from) {
2587 err = find_kern_sym(filt->sym_from, &start, &size,
2588 filt->sym_from_idx);
2591 filt->addr = start;
2592 if (filt->range && !filt->size && !filt->sym_to) {
2593 filt->size = size;
2598 if (filt->sym_to) {
2599 err = find_kern_sym(filt->sym_to, &start, &size,
2600 filt->sym_to_idx);
2607 filt->size = start + size - filt->addr;
2614 filt->sym_to ? filt->sym_to : filt->sym_from);
2615 return -EINVAL;
2644 return !arch__compare_symbol_names(name, sym->name) &&
2645 ((!idx && sym->binding == STB_GLOBAL) ||
2660 if (dso_sym_match(sym, sym_name, &cnt, -1)) {
2662 ++cnt, sym->start,
2663 sym->binding == STB_GLOBAL ? 'g' :
2664 sym->binding == STB_LOCAL ? 'l' : 'w',
2665 sym->name);
2669 pr_err("\t\twhich is near\t\t%s\n", sym->name);
2692 *size = sym->start - *start;
2698 return -EINVAL;
2701 *start = sym->start;
2702 *size = sym->end - sym->start;
2717 filt->filename);
2718 return -EINVAL;
2721 filt->addr = 0;
2722 filt->size = dso__data(dso)->file_size;
2733 if (!filt->sym_from && !filt->sym_to)
2736 if (!filt->filename)
2739 dso = load_dso(filt->filename);
2741 pr_err("Failed to load symbols from: %s\n", filt->filename);
2742 return -EINVAL;
2745 if (filt->sym_from && !strcmp(filt->sym_from, "*")) {
2750 if (filt->sym_from) {
2751 err = find_dso_sym(dso, filt->sym_from, &start, &size,
2752 filt->sym_from_idx);
2755 filt->addr = start;
2756 if (filt->range && !filt->size && !filt->sym_to)
2757 filt->size = size;
2760 if (filt->sym_to) {
2761 err = find_dso_sym(dso, filt->sym_to, &start, &size,
2762 filt->sym_to_idx);
2770 filt->size = start + size - filt->addr;
2787 if (filt->filename) {
2789 fn = realpath(filt->filename, filename_buf);
2794 if (filt->range) {
2796 filt->action, filt->addr, filt->size, at, fn);
2799 filt->action, filt->addr, at, fn);
2821 err = -EINVAL;
2834 err = -ENOMEM;
2839 err = -ENOMEM;
2876 filter = evsel->filter;
2880 evsel->filter = NULL;
2885 pr_debug("Address filter: %s\n", evsel->filter);
2894 if (!session->auxtrace)
2897 return session->auxtrace->process_event(session, event, sample, tool);
2903 if (!session->auxtrace || !session->auxtrace->dump_auxtrace_sample ||
2907 session->auxtrace->dump_auxtrace_sample(session, sample);
2912 if (!session->auxtrace)
2915 return session->auxtrace->flush_events(session, tool);
2920 if (!session->auxtrace)
2923 return session->auxtrace->free_events(session);
2928 if (!session->auxtrace)
2931 return session->auxtrace->free(session);
2937 if (!session->auxtrace || !session->auxtrace->evsel_is_auxtrace)
2940 return session->auxtrace->evsel_is_auxtrace(session, evsel);