Linux Perf
session.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0
2 #include <errno.h>
3 #include <inttypes.h>
4 #include <linux/kernel.h>
5 #include <traceevent/event-parse.h>
6 #include <api/fs/fs.h>
7 
8 #include <byteswap.h>
9 #include <unistd.h>
10 #include <sys/types.h>
11 #include <sys/mman.h>
12 
13 #include "evlist.h"
14 #include "evsel.h"
15 #include "memswap.h"
16 #include "session.h"
17 #include "tool.h"
18 #include "sort.h"
19 #include "util.h"
20 #include "cpumap.h"
21 #include "perf_regs.h"
22 #include "asm/bug.h"
23 #include "auxtrace.h"
24 #include "thread.h"
25 #include "thread-stack.h"
26 #include "stat.h"
27 
29  union perf_event *event,
30  struct perf_tool *tool,
31  u64 file_offset);
32 
34 {
35  struct perf_data *data = session->data;
36 
37  if (perf_session__read_header(session) < 0) {
38  pr_err("incompatible file format (rerun with -v to learn more)\n");
39  return -1;
40  }
41 
42  if (perf_data__is_pipe(data))
43  return 0;
44 
46  return 0;
47 
48  if (!perf_evlist__valid_sample_type(session->evlist)) {
49  pr_err("non matching sample_type\n");
50  return -1;
51  }
52 
54  pr_err("non matching sample_id_all\n");
55  return -1;
56  }
57 
58  if (!perf_evlist__valid_read_format(session->evlist)) {
59  pr_err("non matching read_format\n");
60  return -1;
61  }
62 
63  return 0;
64 }
65 
67 {
68  u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);
69 
70  machines__set_id_hdr_size(&session->machines, id_hdr_size);
71 }
72 
74 {
75  int ret = machine__create_kernel_maps(&session->machines.host);
76 
77  if (ret >= 0)
79  return ret;
80 }
81 
83 {
85 }
86 
88 {
89  struct perf_evsel *evsel;
90 
91  evlist__for_each_entry(session->evlist, evsel) {
92  if (evsel->attr.comm_exec)
93  return true;
94  }
95 
96  return false;
97 }
98 
100 {
101  bool comm_exec = perf_session__has_comm_exec(session);
102 
103  machines__set_comm_exec(&session->machines, comm_exec);
104 }
105 
107  struct ordered_event *event)
108 {
109  struct perf_session *session = container_of(oe, struct perf_session,
111 
112  return perf_session__deliver_event(session, event->event,
113  session->tool, event->file_offset);
114 }
115 
117  bool repipe, struct perf_tool *tool)
118 {
119  struct perf_session *session = zalloc(sizeof(*session));
120 
121  if (!session)
122  goto out;
123 
124  session->repipe = repipe;
125  session->tool = tool;
126  INIT_LIST_HEAD(&session->auxtrace_index);
127  machines__init(&session->machines);
129 
130  if (data) {
131  if (perf_data__open(data))
132  goto out_delete;
133 
134  session->data = data;
135 
136  if (perf_data__is_read(data)) {
137  if (perf_session__open(session) < 0)
138  goto out_close;
139 
140  /*
141  * set session attributes that are present in perf.data
142  * but not in pipe-mode.
143  */
144  if (!data->is_pipe) {
147  }
148  }
149  } else {
150  session->machines.host.env = &perf_env;
151  }
152 
153  if (!data || perf_data__is_write(data)) {
154  /*
155  * In O_RDONLY mode this will be performed when reading the
156  * kernel MMAP event, in perf_event__process_mmap().
157  */
158  if (perf_session__create_kernel_maps(session) < 0)
159  pr_warning("Cannot read kernel map\n");
160  }
161 
162  /*
163  * In pipe-mode, evlist is empty until PERF_RECORD_HEADER_ATTR is
164  * processed, so perf_evlist__sample_id_all is not meaningful here.
165  */
166  if ((!data || !data->is_pipe) && tool && tool->ordering_requires_timestamps &&
167  tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
168  dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
169  tool->ordered_events = false;
170  }
171 
172  return session;
173 
174  out_close:
175  perf_data__close(data);
176  out_delete:
177  perf_session__delete(session);
178  out:
179  return NULL;
180 }
181 
183 {
185 }
186 
188 {
189  if (session == NULL)
190  return;
191  auxtrace__free(session);
195  perf_env__exit(&session->header.env);
196  machines__exit(&session->machines);
197  if (session->data)
198  perf_data__close(session->data);
199  free(session);
200 }
201 
203  __maybe_unused,
204  union perf_event *event
205  __maybe_unused,
206  struct perf_session *session
207  __maybe_unused)
208 {
209  dump_printf(": unhandled!\n");
210  return 0;
211 }
212 
213 static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
214  union perf_event *event __maybe_unused,
215  struct perf_evlist **pevlist
216  __maybe_unused)
217 {
218  dump_printf(": unhandled!\n");
219  return 0;
220 }
221 
222 static int process_event_synth_event_update_stub(struct perf_tool *tool __maybe_unused,
223  union perf_event *event __maybe_unused,
224  struct perf_evlist **pevlist
225  __maybe_unused)
226 {
227  if (dump_trace)
229 
230  dump_printf(": unhandled!\n");
231  return 0;
232 }
233 
234 static int process_event_sample_stub(struct perf_tool *tool __maybe_unused,
235  union perf_event *event __maybe_unused,
236  struct perf_sample *sample __maybe_unused,
237  struct perf_evsel *evsel __maybe_unused,
238  struct machine *machine __maybe_unused)
239 {
240  dump_printf(": unhandled!\n");
241  return 0;
242 }
243 
244 static int process_event_stub(struct perf_tool *tool __maybe_unused,
245  union perf_event *event __maybe_unused,
246  struct perf_sample *sample __maybe_unused,
247  struct machine *machine __maybe_unused)
248 {
249  dump_printf(": unhandled!\n");
250  return 0;
251 }
252 
253 static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
254  union perf_event *event __maybe_unused,
255  struct ordered_events *oe __maybe_unused)
256 {
257  dump_printf(": unhandled!\n");
258  return 0;
259 }
260 
261 static int process_finished_round(struct perf_tool *tool,
262  union perf_event *event,
263  struct ordered_events *oe);
264 
265 static int skipn(int fd, off_t n)
266 {
267  char buf[4096];
268  ssize_t ret;
269 
270  while (n > 0) {
271  ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
272  if (ret <= 0)
273  return ret;
274  n -= ret;
275  }
276 
277  return 0;
278 }
279 
280 static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused,
281  union perf_event *event,
282  struct perf_session *session
283  __maybe_unused)
284 {
285  dump_printf(": unhandled!\n");
288  return event->auxtrace.size;
289 }
290 
291 static int process_event_op2_stub(struct perf_tool *tool __maybe_unused,
292  union perf_event *event __maybe_unused,
293  struct perf_session *session __maybe_unused)
294 {
295  dump_printf(": unhandled!\n");
296  return 0;
297 }
298 
299 
300 static
301 int process_event_thread_map_stub(struct perf_tool *tool __maybe_unused,
302  union perf_event *event __maybe_unused,
303  struct perf_session *session __maybe_unused)
304 {
305  if (dump_trace)
306  perf_event__fprintf_thread_map(event, stdout);
307 
308  dump_printf(": unhandled!\n");
309  return 0;
310 }
311 
312 static
313 int process_event_cpu_map_stub(struct perf_tool *tool __maybe_unused,
314  union perf_event *event __maybe_unused,
315  struct perf_session *session __maybe_unused)
316 {
317  if (dump_trace)
318  perf_event__fprintf_cpu_map(event, stdout);
319 
320  dump_printf(": unhandled!\n");
321  return 0;
322 }
323 
324 static
325 int process_event_stat_config_stub(struct perf_tool *tool __maybe_unused,
326  union perf_event *event __maybe_unused,
327  struct perf_session *session __maybe_unused)
328 {
329  if (dump_trace)
330  perf_event__fprintf_stat_config(event, stdout);
331 
332  dump_printf(": unhandled!\n");
333  return 0;
334 }
335 
336 static int process_stat_stub(struct perf_tool *tool __maybe_unused,
337  union perf_event *event __maybe_unused,
338  struct perf_session *perf_session
339  __maybe_unused)
340 {
341  if (dump_trace)
342  perf_event__fprintf_stat(event, stdout);
343 
344  dump_printf(": unhandled!\n");
345  return 0;
346 }
347 
348 static int process_stat_round_stub(struct perf_tool *tool __maybe_unused,
349  union perf_event *event __maybe_unused,
350  struct perf_session *perf_session
351  __maybe_unused)
352 {
353  if (dump_trace)
354  perf_event__fprintf_stat_round(event, stdout);
355 
356  dump_printf(": unhandled!\n");
357  return 0;
358 }
359 
361 {
362  if (tool->sample == NULL)
364  if (tool->mmap == NULL)
365  tool->mmap = process_event_stub;
366  if (tool->mmap2 == NULL)
367  tool->mmap2 = process_event_stub;
368  if (tool->comm == NULL)
369  tool->comm = process_event_stub;
370  if (tool->namespaces == NULL)
372  if (tool->fork == NULL)
373  tool->fork = process_event_stub;
374  if (tool->exit == NULL)
375  tool->exit = process_event_stub;
376  if (tool->lost == NULL)
378  if (tool->lost_samples == NULL)
380  if (tool->aux == NULL)
382  if (tool->itrace_start == NULL)
384  if (tool->context_switch == NULL)
386  if (tool->read == NULL)
388  if (tool->throttle == NULL)
390  if (tool->unthrottle == NULL)
392  if (tool->attr == NULL)
394  if (tool->event_update == NULL)
396  if (tool->tracing_data == NULL)
398  if (tool->build_id == NULL)
400  if (tool->finished_round == NULL) {
401  if (tool->ordered_events)
403  else
405  }
406  if (tool->id_index == NULL)
408  if (tool->auxtrace_info == NULL)
410  if (tool->auxtrace == NULL)
412  if (tool->auxtrace_error == NULL)
414  if (tool->thread_map == NULL)
416  if (tool->cpu_map == NULL)
418  if (tool->stat_config == NULL)
420  if (tool->stat == NULL)
421  tool->stat = process_stat_stub;
422  if (tool->stat_round == NULL)
424  if (tool->time_conv == NULL)
426  if (tool->feature == NULL)
428 }
429 
430 static void swap_sample_id_all(union perf_event *event, void *data)
431 {
432  void *end = (void *) event + event->header.size;
433  int size = end - data;
434 
435  BUG_ON(size % sizeof(u64));
436  mem_bswap_64(data, size);
437 }
438 
439 static void perf_event__all64_swap(union perf_event *event,
440  bool sample_id_all __maybe_unused)
441 {
442  struct perf_event_header *hdr = &event->header;
443  mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
444 }
445 
446 static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
447 {
448  event->comm.pid = bswap_32(event->comm.pid);
449  event->comm.tid = bswap_32(event->comm.tid);
450 
451  if (sample_id_all) {
452  void *data = &event->comm.comm;
453 
454  data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
455  swap_sample_id_all(event, data);
456  }
457 }
458 
459 static void perf_event__mmap_swap(union perf_event *event,
460  bool sample_id_all)
461 {
462  event->mmap.pid = bswap_32(event->mmap.pid);
463  event->mmap.tid = bswap_32(event->mmap.tid);
464  event->mmap.start = bswap_64(event->mmap.start);
465  event->mmap.len = bswap_64(event->mmap.len);
466  event->mmap.pgoff = bswap_64(event->mmap.pgoff);
467 
468  if (sample_id_all) {
469  void *data = &event->mmap.filename;
470 
471  data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
472  swap_sample_id_all(event, data);
473  }
474 }
475 
476 static void perf_event__mmap2_swap(union perf_event *event,
477  bool sample_id_all)
478 {
479  event->mmap2.pid = bswap_32(event->mmap2.pid);
480  event->mmap2.tid = bswap_32(event->mmap2.tid);
481  event->mmap2.start = bswap_64(event->mmap2.start);
482  event->mmap2.len = bswap_64(event->mmap2.len);
483  event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
484  event->mmap2.maj = bswap_32(event->mmap2.maj);
485  event->mmap2.min = bswap_32(event->mmap2.min);
486  event->mmap2.ino = bswap_64(event->mmap2.ino);
487 
488  if (sample_id_all) {
489  void *data = &event->mmap2.filename;
490 
491  data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
492  swap_sample_id_all(event, data);
493  }
494 }
495 static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
496 {
497  event->fork.pid = bswap_32(event->fork.pid);
498  event->fork.tid = bswap_32(event->fork.tid);
499  event->fork.ppid = bswap_32(event->fork.ppid);
500  event->fork.ptid = bswap_32(event->fork.ptid);
501  event->fork.time = bswap_64(event->fork.time);
502 
503  if (sample_id_all)
504  swap_sample_id_all(event, &event->fork + 1);
505 }
506 
507 static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
508 {
509  event->read.pid = bswap_32(event->read.pid);
510  event->read.tid = bswap_32(event->read.tid);
511  event->read.value = bswap_64(event->read.value);
512  event->read.time_enabled = bswap_64(event->read.time_enabled);
513  event->read.time_running = bswap_64(event->read.time_running);
514  event->read.id = bswap_64(event->read.id);
515 
516  if (sample_id_all)
517  swap_sample_id_all(event, &event->read + 1);
518 }
519 
520 static void perf_event__aux_swap(union perf_event *event, bool sample_id_all)
521 {
522  event->aux.aux_offset = bswap_64(event->aux.aux_offset);
523  event->aux.aux_size = bswap_64(event->aux.aux_size);
524  event->aux.flags = bswap_64(event->aux.flags);
525 
526  if (sample_id_all)
527  swap_sample_id_all(event, &event->aux + 1);
528 }
529 
530 static void perf_event__itrace_start_swap(union perf_event *event,
531  bool sample_id_all)
532 {
533  event->itrace_start.pid = bswap_32(event->itrace_start.pid);
534  event->itrace_start.tid = bswap_32(event->itrace_start.tid);
535 
536  if (sample_id_all)
537  swap_sample_id_all(event, &event->itrace_start + 1);
538 }
539 
540 static void perf_event__switch_swap(union perf_event *event, bool sample_id_all)
541 {
542  if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) {
543  event->context_switch.next_prev_pid =
544  bswap_32(event->context_switch.next_prev_pid);
545  event->context_switch.next_prev_tid =
546  bswap_32(event->context_switch.next_prev_tid);
547  }
548 
549  if (sample_id_all)
550  swap_sample_id_all(event, &event->context_switch + 1);
551 }
552 
553 static void perf_event__throttle_swap(union perf_event *event,
554  bool sample_id_all)
555 {
556  event->throttle.time = bswap_64(event->throttle.time);
557  event->throttle.id = bswap_64(event->throttle.id);
558  event->throttle.stream_id = bswap_64(event->throttle.stream_id);
559 
560  if (sample_id_all)
561  swap_sample_id_all(event, &event->throttle + 1);
562 }
563 
564 static u8 revbyte(u8 b)
565 {
566  int rev = (b >> 4) | ((b & 0xf) << 4);
567  rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2);
568  rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1);
569  return (u8) rev;
570 }
571 
572 /*
573  * XXX this is hack in attempt to carry flags bitfield
574  * through endian village. ABI says:
575  *
576  * Bit-fields are allocated from right to left (least to most significant)
577  * on little-endian implementations and from left to right (most to least
578  * significant) on big-endian implementations.
579  *
580  * The above seems to be byte specific, so we need to reverse each
581  * byte of the bitfield. 'Internet' also says this might be implementation
582  * specific and we probably need proper fix and carry perf_event_attr
583  * bitfield flags in separate data file FEAT_ section. Thought this seems
584  * to work for now.
585  */
586 static void swap_bitfield(u8 *p, unsigned len)
587 {
588  unsigned i;
589 
590  for (i = 0; i < len; i++) {
591  *p = revbyte(*p);
592  p++;
593  }
594 }
595 
596 /* exported for swapping attributes in file header */
597 void perf_event__attr_swap(struct perf_event_attr *attr)
598 {
599  attr->type = bswap_32(attr->type);
600  attr->size = bswap_32(attr->size);
601 
602 #define bswap_safe(f, n) \
603  (attr->size > (offsetof(struct perf_event_attr, f) + \
604  sizeof(attr->f) * (n)))
605 #define bswap_field(f, sz) \
606 do { \
607  if (bswap_safe(f, 0)) \
608  attr->f = bswap_##sz(attr->f); \
609 } while(0)
610 #define bswap_field_16(f) bswap_field(f, 16)
611 #define bswap_field_32(f) bswap_field(f, 32)
612 #define bswap_field_64(f) bswap_field(f, 64)
613 
615  bswap_field_64(sample_period);
616  bswap_field_64(sample_type);
617  bswap_field_64(read_format);
618  bswap_field_32(wakeup_events);
619  bswap_field_32(bp_type);
620  bswap_field_64(bp_addr);
621  bswap_field_64(bp_len);
622  bswap_field_64(branch_sample_type);
623  bswap_field_64(sample_regs_user);
624  bswap_field_32(sample_stack_user);
625  bswap_field_32(aux_watermark);
626  bswap_field_16(sample_max_stack);
627 
628  /*
629  * After read_format are bitfields. Check read_format because
630  * we are unable to use offsetof on bitfield.
631  */
632  if (bswap_safe(read_format, 1))
633  swap_bitfield((u8 *) (&attr->read_format + 1),
634  sizeof(u64));
635 #undef bswap_field_64
636 #undef bswap_field_32
637 #undef bswap_field
638 #undef bswap_safe
639 }
640 
641 static void perf_event__hdr_attr_swap(union perf_event *event,
642  bool sample_id_all __maybe_unused)
643 {
644  size_t size;
645 
647 
648  size = event->header.size;
649  size -= (void *)&event->attr.id - (void *)event;
650  mem_bswap_64(event->attr.id, size);
651 }
652 
653 static void perf_event__event_update_swap(union perf_event *event,
654  bool sample_id_all __maybe_unused)
655 {
656  event->event_update.type = bswap_64(event->event_update.type);
657  event->event_update.id = bswap_64(event->event_update.id);
658 }
659 
660 static void perf_event__event_type_swap(union perf_event *event,
661  bool sample_id_all __maybe_unused)
662 {
663  event->event_type.event_type.event_id =
664  bswap_64(event->event_type.event_type.event_id);
665 }
666 
667 static void perf_event__tracing_data_swap(union perf_event *event,
668  bool sample_id_all __maybe_unused)
669 {
670  event->tracing_data.size = bswap_32(event->tracing_data.size);
671 }
672 
674  bool sample_id_all __maybe_unused)
675 {
676  size_t size;
677 
678  event->auxtrace_info.type = bswap_32(event->auxtrace_info.type);
679 
680  size = event->header.size;
681  size -= (void *)&event->auxtrace_info.priv - (void *)event;
682  mem_bswap_64(event->auxtrace_info.priv, size);
683 }
684 
685 static void perf_event__auxtrace_swap(union perf_event *event,
686  bool sample_id_all __maybe_unused)
687 {
688  event->auxtrace.size = bswap_64(event->auxtrace.size);
689  event->auxtrace.offset = bswap_64(event->auxtrace.offset);
690  event->auxtrace.reference = bswap_64(event->auxtrace.reference);
691  event->auxtrace.idx = bswap_32(event->auxtrace.idx);
692  event->auxtrace.tid = bswap_32(event->auxtrace.tid);
693  event->auxtrace.cpu = bswap_32(event->auxtrace.cpu);
694 }
695 
697  bool sample_id_all __maybe_unused)
698 {
699  event->auxtrace_error.type = bswap_32(event->auxtrace_error.type);
700  event->auxtrace_error.code = bswap_32(event->auxtrace_error.code);
701  event->auxtrace_error.cpu = bswap_32(event->auxtrace_error.cpu);
702  event->auxtrace_error.pid = bswap_32(event->auxtrace_error.pid);
703  event->auxtrace_error.tid = bswap_32(event->auxtrace_error.tid);
704  event->auxtrace_error.ip = bswap_64(event->auxtrace_error.ip);
705 }
706 
707 static void perf_event__thread_map_swap(union perf_event *event,
708  bool sample_id_all __maybe_unused)
709 {
710  unsigned i;
711 
712  event->thread_map.nr = bswap_64(event->thread_map.nr);
713 
714  for (i = 0; i < event->thread_map.nr; i++)
715  event->thread_map.entries[i].pid = bswap_64(event->thread_map.entries[i].pid);
716 }
717 
718 static void perf_event__cpu_map_swap(union perf_event *event,
719  bool sample_id_all __maybe_unused)
720 {
721  struct cpu_map_data *data = &event->cpu_map.data;
722  struct cpu_map_entries *cpus;
723  struct cpu_map_mask *mask;
724  unsigned i;
725 
726  data->type = bswap_64(data->type);
727 
728  switch (data->type) {
729  case PERF_CPU_MAP__CPUS:
730  cpus = (struct cpu_map_entries *)data->data;
731 
732  cpus->nr = bswap_16(cpus->nr);
733 
734  for (i = 0; i < cpus->nr; i++)
735  cpus->cpu[i] = bswap_16(cpus->cpu[i]);
736  break;
737  case PERF_CPU_MAP__MASK:
738  mask = (struct cpu_map_mask *) data->data;
739 
740  mask->nr = bswap_16(mask->nr);
741  mask->long_size = bswap_16(mask->long_size);
742 
743  switch (mask->long_size) {
744  case 4: mem_bswap_32(&mask->mask, mask->nr); break;
745  case 8: mem_bswap_64(&mask->mask, mask->nr); break;
746  default:
747  pr_err("cpu_map swap: unsupported long size\n");
748  }
749  default:
750  break;
751  }
752 }
753 
754 static void perf_event__stat_config_swap(union perf_event *event,
755  bool sample_id_all __maybe_unused)
756 {
757  u64 size;
758 
759  size = event->stat_config.nr * sizeof(event->stat_config.data[0]);
760  size += 1; /* nr item itself */
761  mem_bswap_64(&event->stat_config.nr, size);
762 }
763 
764 static void perf_event__stat_swap(union perf_event *event,
765  bool sample_id_all __maybe_unused)
766 {
767  event->stat.id = bswap_64(event->stat.id);
768  event->stat.thread = bswap_32(event->stat.thread);
769  event->stat.cpu = bswap_32(event->stat.cpu);
770  event->stat.val = bswap_64(event->stat.val);
771  event->stat.ena = bswap_64(event->stat.ena);
772  event->stat.run = bswap_64(event->stat.run);
773 }
774 
775 static void perf_event__stat_round_swap(union perf_event *event,
776  bool sample_id_all __maybe_unused)
777 {
778  event->stat_round.type = bswap_64(event->stat_round.type);
779  event->stat_round.time = bswap_64(event->stat_round.time);
780 }
781 
782 typedef void (*perf_event__swap_op)(union perf_event *event,
783  bool sample_id_all);
784 
786  [PERF_RECORD_MMAP] = perf_event__mmap_swap,
787  [PERF_RECORD_MMAP2] = perf_event__mmap2_swap,
788  [PERF_RECORD_COMM] = perf_event__comm_swap,
789  [PERF_RECORD_FORK] = perf_event__task_swap,
790  [PERF_RECORD_EXIT] = perf_event__task_swap,
791  [PERF_RECORD_LOST] = perf_event__all64_swap,
792  [PERF_RECORD_READ] = perf_event__read_swap,
793  [PERF_RECORD_THROTTLE] = perf_event__throttle_swap,
794  [PERF_RECORD_UNTHROTTLE] = perf_event__throttle_swap,
795  [PERF_RECORD_SAMPLE] = perf_event__all64_swap,
796  [PERF_RECORD_AUX] = perf_event__aux_swap,
797  [PERF_RECORD_ITRACE_START] = perf_event__itrace_start_swap,
798  [PERF_RECORD_LOST_SAMPLES] = perf_event__all64_swap,
799  [PERF_RECORD_SWITCH] = perf_event__switch_swap,
800  [PERF_RECORD_SWITCH_CPU_WIDE] = perf_event__switch_swap,
816  [PERF_RECORD_HEADER_MAX] = NULL,
817 };
818 
819 /*
820  * When perf record finishes a pass on every buffers, it records this pseudo
821  * event.
822  * We record the max timestamp t found in the pass n.
823  * Assuming these timestamps are monotonic across cpus, we know that if
824  * a buffer still has events with timestamps below t, they will be all
825  * available and then read in the pass n + 1.
826  * Hence when we start to read the pass n + 2, we can safely flush every
827  * events with timestamps below t.
828  *
829  * ============ PASS n =================
830  * CPU 0 | CPU 1
831  * |
832  * cnt1 timestamps | cnt2 timestamps
833  * 1 | 2
834  * 2 | 3
835  * - | 4 <--- max recorded
836  *
837  * ============ PASS n + 1 ==============
838  * CPU 0 | CPU 1
839  * |
840  * cnt1 timestamps | cnt2 timestamps
841  * 3 | 5
842  * 4 | 6
843  * 5 | 7 <---- max recorded
844  *
845  * Flush every events below timestamp 4
846  *
847  * ============ PASS n + 2 ==============
848  * CPU 0 | CPU 1
849  * |
850  * cnt1 timestamps | cnt2 timestamps
851  * 6 | 8
852  * 7 | 9
853  * - | 10
854  *
855  * Flush every events below timestamp 7
856  * etc...
857  */
858 static int process_finished_round(struct perf_tool *tool __maybe_unused,
859  union perf_event *event __maybe_unused,
860  struct ordered_events *oe)
861 {
862  if (dump_trace)
863  fprintf(stdout, "\n");
865 }
866 
868  u64 timestamp, u64 file_offset)
869 {
870  return ordered_events__queue(&s->ordered_events, event, timestamp, file_offset);
871 }
872 
874 {
875  struct ip_callchain *callchain = sample->callchain;
876  struct branch_stack *lbr_stack = sample->branch_stack;
877  u64 kernel_callchain_nr = callchain->nr;
878  unsigned int i;
879 
880  for (i = 0; i < kernel_callchain_nr; i++) {
881  if (callchain->ips[i] == PERF_CONTEXT_USER)
882  break;
883  }
884 
885  if ((i != kernel_callchain_nr) && lbr_stack->nr) {
886  u64 total_nr;
887  /*
888  * LBR callstack can only get user call chain,
889  * i is kernel call chain number,
890  * 1 is PERF_CONTEXT_USER.
891  *
892  * The user call chain is stored in LBR registers.
893  * LBR are pair registers. The caller is stored
894  * in "from" register, while the callee is stored
895  * in "to" register.
896  * For example, there is a call stack
897  * "A"->"B"->"C"->"D".
898  * The LBR registers will recorde like
899  * "C"->"D", "B"->"C", "A"->"B".
900  * So only the first "to" register and all "from"
901  * registers are needed to construct the whole stack.
902  */
903  total_nr = i + 1 + lbr_stack->nr + 1;
904  kernel_callchain_nr = i + 1;
905 
906  printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr);
907 
908  for (i = 0; i < kernel_callchain_nr; i++)
909  printf("..... %2d: %016" PRIx64 "\n",
910  i, callchain->ips[i]);
911 
912  printf("..... %2d: %016" PRIx64 "\n",
913  (int)(kernel_callchain_nr), lbr_stack->entries[0].to);
914  for (i = 0; i < lbr_stack->nr; i++)
915  printf("..... %2d: %016" PRIx64 "\n",
916  (int)(i + kernel_callchain_nr + 1), lbr_stack->entries[i].from);
917  }
918 }
919 
920 static void callchain__printf(struct perf_evsel *evsel,
921  struct perf_sample *sample)
922 {
923  unsigned int i;
924  struct ip_callchain *callchain = sample->callchain;
925 
928 
929  printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr);
930 
931  for (i = 0; i < callchain->nr; i++)
932  printf("..... %2d: %016" PRIx64 "\n",
933  i, callchain->ips[i]);
934 }
935 
937 {
938  uint64_t i;
939 
940  printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);
941 
942  for (i = 0; i < sample->branch_stack->nr; i++) {
943  struct branch_entry *e = &sample->branch_stack->entries[i];
944 
945  printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 " %hu cycles %s%s%s%s %x\n",
946  i, e->from, e->to,
947  (unsigned short)e->flags.cycles,
948  e->flags.mispred ? "M" : " ",
949  e->flags.predicted ? "P" : " ",
950  e->flags.abort ? "A" : " ",
951  e->flags.in_tx ? "T" : " ",
952  (unsigned)e->flags.reserved);
953  }
954 }
955 
956 static void regs_dump__printf(u64 mask, u64 *regs)
957 {
958  unsigned rid, i = 0;
959 
960  for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) {
961  u64 val = regs[i++];
962 
963  printf(".... %-5s 0x%" PRIx64 "\n",
964  perf_reg_name(rid), val);
965  }
966 }
967 
968 static const char *regs_abi[] = {
969  [PERF_SAMPLE_REGS_ABI_NONE] = "none",
970  [PERF_SAMPLE_REGS_ABI_32] = "32-bit",
971  [PERF_SAMPLE_REGS_ABI_64] = "64-bit",
972 };
973 
974 static inline const char *regs_dump_abi(struct regs_dump *d)
975 {
976  if (d->abi > PERF_SAMPLE_REGS_ABI_64)
977  return "unknown";
978 
979  return regs_abi[d->abi];
980 }
981 
982 static void regs__printf(const char *type, struct regs_dump *regs)
983 {
984  u64 mask = regs->mask;
985 
986  printf("... %s regs: mask 0x%" PRIx64 " ABI %s\n",
987  type,
988  mask,
989  regs_dump_abi(regs));
990 
991  regs_dump__printf(mask, regs->regs);
992 }
993 
995 {
996  struct regs_dump *user_regs = &sample->user_regs;
997 
998  if (user_regs->regs)
999  regs__printf("user", user_regs);
1000 }
1001 
1003 {
1004  struct regs_dump *intr_regs = &sample->intr_regs;
1005 
1006  if (intr_regs->regs)
1007  regs__printf("intr", intr_regs);
1008 }
1009 
1010 static void stack_user__printf(struct stack_dump *dump)
1011 {
1012  printf("... ustack: size %" PRIu64 ", offset 0x%x\n",
1013  dump->size, dump->offset);
1014 }
1015 
1016 static void perf_evlist__print_tstamp(struct perf_evlist *evlist,
1017  union perf_event *event,
1018  struct perf_sample *sample)
1019 {
1020  u64 sample_type = __perf_evlist__combined_sample_type(evlist);
1021 
1022  if (event->header.type != PERF_RECORD_SAMPLE &&
1023  !perf_evlist__sample_id_all(evlist)) {
1024  fputs("-1 -1 ", stdout);
1025  return;
1026  }
1027 
1028  if ((sample_type & PERF_SAMPLE_CPU))
1029  printf("%u ", sample->cpu);
1030 
1031  if (sample_type & PERF_SAMPLE_TIME)
1032  printf("%" PRIu64 " ", sample->time);
1033 }
1034 
1035 static void sample_read__printf(struct perf_sample *sample, u64 read_format)
1036 {
1037  printf("... sample_read:\n");
1038 
1039  if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1040  printf("...... time enabled %016" PRIx64 "\n",
1041  sample->read.time_enabled);
1042 
1043  if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1044  printf("...... time running %016" PRIx64 "\n",
1045  sample->read.time_running);
1046 
1047  if (read_format & PERF_FORMAT_GROUP) {
1048  u64 i;
1049 
1050  printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);
1051 
1052  for (i = 0; i < sample->read.group.nr; i++) {
1053  struct sample_read_value *value;
1054 
1055  value = &sample->read.group.values[i];
1056  printf("..... id %016" PRIx64
1057  ", value %016" PRIx64 "\n",
1058  value->id, value->value);
1059  }
1060  } else
1061  printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n",
1062  sample->read.one.id, sample->read.one.value);
1063 }
1064 
1065 static void dump_event(struct perf_evlist *evlist, union perf_event *event,
1066  u64 file_offset, struct perf_sample *sample)
1067 {
1068  if (!dump_trace)
1069  return;
1070 
1071  printf("\n%#" PRIx64 " [%#x]: event: %d\n",
1072  file_offset, event->header.size, event->header.type);
1073 
1074  trace_event(event);
1075 
1076  if (sample)
1077  perf_evlist__print_tstamp(evlist, event, sample);
1078 
1079  printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
1080  event->header.size, perf_event__name(event->header.type));
1081 }
1082 
1083 static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
1084  struct perf_sample *sample)
1085 {
1086  u64 sample_type;
1087 
1088  if (!dump_trace)
1089  return;
1090 
1091  printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
1092  event->header.misc, sample->pid, sample->tid, sample->ip,
1093  sample->period, sample->addr);
1094 
1095  sample_type = evsel->attr.sample_type;
1096 
1097  if (evsel__has_callchain(evsel))
1098  callchain__printf(evsel, sample);
1099 
1100  if ((sample_type & PERF_SAMPLE_BRANCH_STACK) && !perf_evsel__has_branch_callstack(evsel))
1101  branch_stack__printf(sample);
1102 
1103  if (sample_type & PERF_SAMPLE_REGS_USER)
1104  regs_user__printf(sample);
1105 
1106  if (sample_type & PERF_SAMPLE_REGS_INTR)
1107  regs_intr__printf(sample);
1108 
1109  if (sample_type & PERF_SAMPLE_STACK_USER)
1110  stack_user__printf(&sample->user_stack);
1111 
1112  if (sample_type & PERF_SAMPLE_WEIGHT)
1113  printf("... weight: %" PRIu64 "\n", sample->weight);
1114 
1115  if (sample_type & PERF_SAMPLE_DATA_SRC)
1116  printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
1117 
1118  if (sample_type & PERF_SAMPLE_PHYS_ADDR)
1119  printf(" .. phys_addr: 0x%"PRIx64"\n", sample->phys_addr);
1120 
1121  if (sample_type & PERF_SAMPLE_TRANSACTION)
1122  printf("... transaction: %" PRIx64 "\n", sample->transaction);
1123 
1124  if (sample_type & PERF_SAMPLE_READ)
1125  sample_read__printf(sample, evsel->attr.read_format);
1126 }
1127 
1128 static void dump_read(struct perf_evsel *evsel, union perf_event *event)
1129 {
1130  struct read_event *read_event = &event->read;
1131  u64 read_format;
1132 
1133  if (!dump_trace)
1134  return;
1135 
1136  printf(": %d %d %s %" PRIu64 "\n", event->read.pid, event->read.tid,
1137  evsel ? perf_evsel__name(evsel) : "FAIL",
1138  event->read.value);
1139 
1140  read_format = evsel->attr.read_format;
1141 
1142  if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
1143  printf("... time enabled : %" PRIu64 "\n", read_event->time_enabled);
1144 
1145  if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
1146  printf("... time running : %" PRIu64 "\n", read_event->time_running);
1147 
1148  if (read_format & PERF_FORMAT_ID)
1149  printf("... id : %" PRIu64 "\n", read_event->id);
1150 }
1151 
1153  union perf_event *event,
1154  struct perf_sample *sample)
1155 {
1156  struct machine *machine;
1157 
1158  if (perf_guest &&
1159  ((sample->cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
1160  (sample->cpumode == PERF_RECORD_MISC_GUEST_USER))) {
1161  u32 pid;
1162 
1163  if (event->header.type == PERF_RECORD_MMAP
1164  || event->header.type == PERF_RECORD_MMAP2)
1165  pid = event->mmap.pid;
1166  else
1167  pid = sample->pid;
1168 
1169  machine = machines__find(machines, pid);
1170  if (!machine)
1171  machine = machines__findnew(machines, DEFAULT_GUEST_KERNEL_ID);
1172  return machine;
1173  }
1174 
1175  return &machines->host;
1176 }
1177 
1178 static int deliver_sample_value(struct perf_evlist *evlist,
1179  struct perf_tool *tool,
1180  union perf_event *event,
1181  struct perf_sample *sample,
1182  struct sample_read_value *v,
1183  struct machine *machine)
1184 {
1185  struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
1186 
1187  if (sid) {
1188  sample->id = v->id;
1189  sample->period = v->value - sid->period;
1190  sid->period = v->value;
1191  }
1192 
1193  if (!sid || sid->evsel == NULL) {
1194  ++evlist->stats.nr_unknown_id;
1195  return 0;
1196  }
1197 
1198  return tool->sample(tool, event, sample, sid->evsel, machine);
1199 }
1200 
1201 static int deliver_sample_group(struct perf_evlist *evlist,
1202  struct perf_tool *tool,
1203  union perf_event *event,
1204  struct perf_sample *sample,
1205  struct machine *machine)
1206 {
1207  int ret = -EINVAL;
1208  u64 i;
1209 
1210  for (i = 0; i < sample->read.group.nr; i++) {
1211  ret = deliver_sample_value(evlist, tool, event, sample,
1212  &sample->read.group.values[i],
1213  machine);
1214  if (ret)
1215  break;
1216  }
1217 
1218  return ret;
1219 }
1220 
1221 static int
1223  struct perf_tool *tool,
1224  union perf_event *event,
1225  struct perf_sample *sample,
1226  struct perf_evsel *evsel,
1227  struct machine *machine)
1228 {
1229  /* We know evsel != NULL. */
1230  u64 sample_type = evsel->attr.sample_type;
1231  u64 read_format = evsel->attr.read_format;
1232 
1233  /* Standard sample delivery. */
1234  if (!(sample_type & PERF_SAMPLE_READ))
1235  return tool->sample(tool, event, sample, evsel, machine);
1236 
1237  /* For PERF_SAMPLE_READ we have either single or group mode. */
1238  if (read_format & PERF_FORMAT_GROUP)
1239  return deliver_sample_group(evlist, tool, event, sample,
1240  machine);
1241  else
1242  return deliver_sample_value(evlist, tool, event, sample,
1243  &sample->read.one, machine);
1244 }
1245 
1247  struct perf_evlist *evlist,
1248  union perf_event *event,
1249  struct perf_sample *sample,
1250  struct perf_tool *tool, u64 file_offset)
1251 {
1252  struct perf_evsel *evsel;
1253  struct machine *machine;
1254 
1255  dump_event(evlist, event, file_offset, sample);
1256 
1257  evsel = perf_evlist__id2evsel(evlist, sample->id);
1258 
1259  machine = machines__find_for_cpumode(machines, event, sample);
1260 
1261  switch (event->header.type) {
1262  case PERF_RECORD_SAMPLE:
1263  if (evsel == NULL) {
1264  ++evlist->stats.nr_unknown_id;
1265  return 0;
1266  }
1267  dump_sample(evsel, event, sample);
1268  if (machine == NULL) {
1269  ++evlist->stats.nr_unprocessable_samples;
1270  return 0;
1271  }
1272  return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
1273  case PERF_RECORD_MMAP:
1274  return tool->mmap(tool, event, sample, machine);
1275  case PERF_RECORD_MMAP2:
1276  if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT)
1277  ++evlist->stats.nr_proc_map_timeout;
1278  return tool->mmap2(tool, event, sample, machine);
1279  case PERF_RECORD_COMM:
1280  return tool->comm(tool, event, sample, machine);
1281  case PERF_RECORD_NAMESPACES:
1282  return tool->namespaces(tool, event, sample, machine);
1283  case PERF_RECORD_FORK:
1284  return tool->fork(tool, event, sample, machine);
1285  case PERF_RECORD_EXIT:
1286  return tool->exit(tool, event, sample, machine);
1287  case PERF_RECORD_LOST:
1288  if (tool->lost == perf_event__process_lost)
1289  evlist->stats.total_lost += event->lost.lost;
1290  return tool->lost(tool, event, sample, machine);
1291  case PERF_RECORD_LOST_SAMPLES:
1293  evlist->stats.total_lost_samples += event->lost_samples.lost;
1294  return tool->lost_samples(tool, event, sample, machine);
1295  case PERF_RECORD_READ:
1296  dump_read(evsel, event);
1297  return tool->read(tool, event, sample, evsel, machine);
1298  case PERF_RECORD_THROTTLE:
1299  return tool->throttle(tool, event, sample, machine);
1300  case PERF_RECORD_UNTHROTTLE:
1301  return tool->unthrottle(tool, event, sample, machine);
1302  case PERF_RECORD_AUX:
1303  if (tool->aux == perf_event__process_aux) {
1304  if (event->aux.flags & PERF_AUX_FLAG_TRUNCATED)
1305  evlist->stats.total_aux_lost += 1;
1306  if (event->aux.flags & PERF_AUX_FLAG_PARTIAL)
1307  evlist->stats.total_aux_partial += 1;
1308  }
1309  return tool->aux(tool, event, sample, machine);
1310  case PERF_RECORD_ITRACE_START:
1311  return tool->itrace_start(tool, event, sample, machine);
1312  case PERF_RECORD_SWITCH:
1313  case PERF_RECORD_SWITCH_CPU_WIDE:
1314  return tool->context_switch(tool, event, sample, machine);
1315  default:
1316  ++evlist->stats.nr_unknown_events;
1317  return -1;
1318  }
1319 }
1320 
1322  union perf_event *event,
1323  struct perf_tool *tool,
1324  u64 file_offset)
1325 {
1326  struct perf_sample sample;
1327  int ret;
1328 
1329  ret = perf_evlist__parse_sample(session->evlist, event, &sample);
1330  if (ret) {
1331  pr_err("Can't parse sample, err = %d\n", ret);
1332  return ret;
1333  }
1334 
1335  ret = auxtrace__process_event(session, event, &sample, tool);
1336  if (ret < 0)
1337  return ret;
1338  if (ret > 0)
1339  return 0;
1340 
1341  return machines__deliver_event(&session->machines, session->evlist,
1342  event, &sample, tool, file_offset);
1343 }
1344 
1346  union perf_event *event,
1347  u64 file_offset)
1348 {
1349  struct ordered_events *oe = &session->ordered_events;
1350  struct perf_tool *tool = session->tool;
1351  struct perf_sample sample = { .time = 0, };
1352  int fd = perf_data__fd(session->data);
1353  int err;
1354 
1355  dump_event(session->evlist, event, file_offset, &sample);
1356 
1357  /* These events are processed right away */
1358  switch (event->header.type) {
1360  err = tool->attr(tool, event, &session->evlist);
1361  if (err == 0) {
1363  perf_session__set_comm_exec(session);
1364  }
1365  return err;
1367  return tool->event_update(tool, event, &session->evlist);
1369  /*
1370  * Depreceated, but we need to handle it for sake
1371  * of old data files create in pipe mode.
1372  */
1373  return 0;
1375  /* setup for reading amidst mmap */
1376  lseek(fd, file_offset, SEEK_SET);
1377  return tool->tracing_data(tool, event, session);
1379  return tool->build_id(tool, event, session);
1381  return tool->finished_round(tool, event, oe);
1382  case PERF_RECORD_ID_INDEX:
1383  return tool->id_index(tool, event, session);
1385  return tool->auxtrace_info(tool, event, session);
1386  case PERF_RECORD_AUXTRACE:
1387  /* setup for reading amidst mmap */
1388  lseek(fd, file_offset + event->header.size, SEEK_SET);
1389  return tool->auxtrace(tool, event, session);
1391  perf_session__auxtrace_error_inc(session, event);
1392  return tool->auxtrace_error(tool, event, session);
1394  return tool->thread_map(tool, event, session);
1395  case PERF_RECORD_CPU_MAP:
1396  return tool->cpu_map(tool, event, session);
1398  return tool->stat_config(tool, event, session);
1399  case PERF_RECORD_STAT:
1400  return tool->stat(tool, event, session);
1402  return tool->stat_round(tool, event, session);
1403  case PERF_RECORD_TIME_CONV:
1404  session->time_conv = event->time_conv;
1405  return tool->time_conv(tool, event, session);
1407  return tool->feature(tool, event, session);
1408  default:
1409  return -EINVAL;
1410  }
1411 }
1412 
1414  union perf_event *event,
1415  struct perf_sample *sample)
1416 {
1417  struct perf_evlist *evlist = session->evlist;
1418  struct perf_tool *tool = session->tool;
1419 
1420  events_stats__inc(&evlist->stats, event->header.type);
1421 
1422  if (event->header.type >= PERF_RECORD_USER_TYPE_START)
1423  return perf_session__process_user_event(session, event, 0);
1424 
1425  return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0);
1426 }
1427 
1428 static void event_swap(union perf_event *event, bool sample_id_all)
1429 {
1430  perf_event__swap_op swap;
1431 
1432  swap = perf_event__swap_ops[event->header.type];
1433  if (swap)
1434  swap(event, sample_id_all);
1435 }
1436 
1437 int perf_session__peek_event(struct perf_session *session, off_t file_offset,
1438  void *buf, size_t buf_sz,
1439  union perf_event **event_ptr,
1440  struct perf_sample *sample)
1441 {
1442  union perf_event *event;
1443  size_t hdr_sz, rest;
1444  int fd;
1445 
1446  if (session->one_mmap && !session->header.needs_swap) {
1447  event = file_offset - session->one_mmap_offset +
1448  session->one_mmap_addr;
1449  goto out_parse_sample;
1450  }
1451 
1452  if (perf_data__is_pipe(session->data))
1453  return -1;
1454 
1455  fd = perf_data__fd(session->data);
1456  hdr_sz = sizeof(struct perf_event_header);
1457 
1458  if (buf_sz < hdr_sz)
1459  return -1;
1460 
1461  if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 ||
1462  readn(fd, buf, hdr_sz) != (ssize_t)hdr_sz)
1463  return -1;
1464 
1465  event = (union perf_event *)buf;
1466 
1467  if (session->header.needs_swap)
1469 
1470  if (event->header.size < hdr_sz || event->header.size > buf_sz)
1471  return -1;
1472 
1473  rest = event->header.size - hdr_sz;
1474 
1475  if (readn(fd, buf, rest) != (ssize_t)rest)
1476  return -1;
1477 
1478  if (session->header.needs_swap)
1479  event_swap(event, perf_evlist__sample_id_all(session->evlist));
1480 
1481 out_parse_sample:
1482 
1483  if (sample && event->header.type < PERF_RECORD_USER_TYPE_START &&
1484  perf_evlist__parse_sample(session->evlist, event, sample))
1485  return -1;
1486 
1487  *event_ptr = event;
1488 
1489  return 0;
1490 }
1491 
1493  union perf_event *event, u64 file_offset)
1494 {
1495  struct perf_evlist *evlist = session->evlist;
1496  struct perf_tool *tool = session->tool;
1497  int ret;
1498 
1499  if (session->header.needs_swap)
1500  event_swap(event, perf_evlist__sample_id_all(evlist));
1501 
1502  if (event->header.type >= PERF_RECORD_HEADER_MAX)
1503  return -EINVAL;
1504 
1505  events_stats__inc(&evlist->stats, event->header.type);
1506 
1507  if (event->header.type >= PERF_RECORD_USER_TYPE_START)
1508  return perf_session__process_user_event(session, event, file_offset);
1509 
1510  if (tool->ordered_events) {
1511  u64 timestamp = -1ULL;
1512 
1513  ret = perf_evlist__parse_sample_timestamp(evlist, event, &timestamp);
1514  if (ret && ret != -1)
1515  return ret;
1516 
1517  ret = perf_session__queue_event(session, event, timestamp, file_offset);
1518  if (ret != -ETIME)
1519  return ret;
1520  }
1521 
1522  return perf_session__deliver_event(session, event, tool, file_offset);
1523 }
1524 
1525 void perf_event_header__bswap(struct perf_event_header *hdr)
1526 {
1527  hdr->type = bswap_32(hdr->type);
1528  hdr->misc = bswap_16(hdr->misc);
1529  hdr->size = bswap_16(hdr->size);
1530 }
1531 
1533 {
1534  return machine__findnew_thread(&session->machines.host, -1, pid);
1535 }
1536 
1538 {
1539  struct thread *thread;
1540  int err = 0;
1541 
1542  thread = machine__findnew_thread(&session->machines.host, 0, 0);
1543  if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
1544  pr_err("problem inserting idle task.\n");
1545  err = -1;
1546  }
1547 
1548  if (thread == NULL || thread__set_namespaces(thread, 0, NULL)) {
1549  pr_err("problem inserting idle task.\n");
1550  err = -1;
1551  }
1552 
1553  /* machine__findnew_thread() got the thread, so put it */
1554  thread__put(thread);
1555  return err;
1556 }
1557 
1558 static void
1560 {
1561  const struct ordered_events *oe = &session->ordered_events;
1562  struct perf_evsel *evsel;
1563  bool should_warn = true;
1564 
1565  evlist__for_each_entry(session->evlist, evsel) {
1566  if (evsel->attr.write_backward)
1567  should_warn = false;
1568  }
1569 
1570  if (!should_warn)
1571  return;
1572  if (oe->nr_unordered_events != 0)
1573  ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events);
1574 }
1575 
1577 {
1578  const struct events_stats *stats = &session->evlist->stats;
1579 
1580  if (session->tool->lost == perf_event__process_lost &&
1581  stats->nr_events[PERF_RECORD_LOST] != 0) {
1582  ui__warning("Processed %d events and lost %d chunks!\n\n"
1583  "Check IO/CPU overload!\n\n",
1584  stats->nr_events[0],
1585  stats->nr_events[PERF_RECORD_LOST]);
1586  }
1587 
1589  double drop_rate;
1590 
1591  drop_rate = (double)stats->total_lost_samples /
1592  (double) (stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples);
1593  if (drop_rate > 0.05) {
1594  ui__warning("Processed %" PRIu64 " samples and lost %3.2f%%!\n\n",
1595  stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples,
1596  drop_rate * 100.0);
1597  }
1598  }
1599 
1600  if (session->tool->aux == perf_event__process_aux &&
1601  stats->total_aux_lost != 0) {
1602  ui__warning("AUX data lost %" PRIu64 " times out of %u!\n\n",
1603  stats->total_aux_lost,
1604  stats->nr_events[PERF_RECORD_AUX]);
1605  }
1606 
1607  if (session->tool->aux == perf_event__process_aux &&
1608  stats->total_aux_partial != 0) {
1609  bool vmm_exclusive = false;
1610 
1611  (void)sysfs__read_bool("module/kvm_intel/parameters/vmm_exclusive",
1612  &vmm_exclusive);
1613 
1614  ui__warning("AUX data had gaps in it %" PRIu64 " times out of %u!\n\n"
1615  "Are you running a KVM guest in the background?%s\n\n",
1616  stats->total_aux_partial,
1617  stats->nr_events[PERF_RECORD_AUX],
1618  vmm_exclusive ?
1619  "\nReloading kvm_intel module with vmm_exclusive=0\n"
1620  "will reduce the gaps to only guest's timeslices." :
1621  "");
1622  }
1623 
1624  if (stats->nr_unknown_events != 0) {
1625  ui__warning("Found %u unknown events!\n\n"
1626  "Is this an older tool processing a perf.data "
1627  "file generated by a more recent tool?\n\n"
1628  "If that is not the case, consider "
1629  "reporting to linux-kernel@vger.kernel.org.\n\n",
1630  stats->nr_unknown_events);
1631  }
1632 
1633  if (stats->nr_unknown_id != 0) {
1634  ui__warning("%u samples with id not present in the header\n",
1635  stats->nr_unknown_id);
1636  }
1637 
1638  if (stats->nr_invalid_chains != 0) {
1639  ui__warning("Found invalid callchains!\n\n"
1640  "%u out of %u events were discarded for this reason.\n\n"
1641  "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
1642  stats->nr_invalid_chains,
1643  stats->nr_events[PERF_RECORD_SAMPLE]);
1644  }
1645 
1646  if (stats->nr_unprocessable_samples != 0) {
1647  ui__warning("%u unprocessable samples recorded.\n"
1648  "Do you have a KVM guest running and not using 'perf kvm'?\n",
1649  stats->nr_unprocessable_samples);
1650  }
1651 
1652  perf_session__warn_order(session);
1653 
1655 
1656  if (stats->nr_proc_map_timeout != 0) {
1657  ui__warning("%d map information files for pre-existing threads were\n"
1658  "not processed, if there are samples for addresses they\n"
1659  "will not be resolved, you may find out which are these\n"
1660  "threads by running with -v and redirecting the output\n"
1661  "to a file.\n"
1662  "The time limit to process proc map is too short?\n"
1663  "Increase it by --proc-map-timeout\n",
1664  stats->nr_proc_map_timeout);
1665  }
1666 }
1667 
1669  void *p __maybe_unused)
1670 {
1671  return thread_stack__flush(thread);
1672 }
1673 
1675 {
1676  return machines__for_each_thread(&session->machines,
1678  NULL);
1679 }
1680 
1681 volatile int session_done;
1682 
1684 {
1685  struct ordered_events *oe = &session->ordered_events;
1686  struct perf_tool *tool = session->tool;
1687  int fd = perf_data__fd(session->data);
1688  union perf_event *event;
1689  uint32_t size, cur_size = 0;
1690  void *buf = NULL;
1691  s64 skip = 0;
1692  u64 head;
1693  ssize_t err;
1694  void *p;
1695 
1697 
1698  head = 0;
1699  cur_size = sizeof(union perf_event);
1700 
1701  buf = malloc(cur_size);
1702  if (!buf)
1703  return -errno;
1705 more:
1706  event = buf;
1707  err = readn(fd, event, sizeof(struct perf_event_header));
1708  if (err <= 0) {
1709  if (err == 0)
1710  goto done;
1711 
1712  pr_err("failed to read event header\n");
1713  goto out_err;
1714  }
1715 
1716  if (session->header.needs_swap)
1718 
1719  size = event->header.size;
1720  if (size < sizeof(struct perf_event_header)) {
1721  pr_err("bad event header size\n");
1722  goto out_err;
1723  }
1724 
1725  if (size > cur_size) {
1726  void *new = realloc(buf, size);
1727  if (!new) {
1728  pr_err("failed to allocate memory to read event\n");
1729  goto out_err;
1730  }
1731  buf = new;
1732  cur_size = size;
1733  event = buf;
1734  }
1735  p = event;
1736  p += sizeof(struct perf_event_header);
1737 
1738  if (size - sizeof(struct perf_event_header)) {
1739  err = readn(fd, p, size - sizeof(struct perf_event_header));
1740  if (err <= 0) {
1741  if (err == 0) {
1742  pr_err("unexpected end of event stream\n");
1743  goto done;
1744  }
1745 
1746  pr_err("failed to read event data\n");
1747  goto out_err;
1748  }
1749  }
1750 
1751  if ((skip = perf_session__process_event(session, event, head)) < 0) {
1752  pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1753  head, event->header.size, event->header.type);
1754  err = -EINVAL;
1755  goto out_err;
1756  }
1757 
1758  head += size;
1759 
1760  if (skip > 0)
1761  head += skip;
1762 
1763  if (!session_done())
1764  goto more;
1765 done:
1766  /* do the final flush for ordered samples */
1768  if (err)
1769  goto out_err;
1770  err = auxtrace__flush_events(session, tool);
1771  if (err)
1772  goto out_err;
1773  err = perf_session__flush_thread_stacks(session);
1774 out_err:
1775  free(buf);
1776  if (!tool->no_warn)
1779  auxtrace__free_events(session);
1780  return err;
1781 }
1782 
1783 static union perf_event *
1785  u64 head, size_t mmap_size, char *buf)
1786 {
1787  union perf_event *event;
1788 
1789  /*
1790  * Ensure we have enough space remaining to read
1791  * the size of the event in the headers.
1792  */
1793  if (head + sizeof(event->header) > mmap_size)
1794  return NULL;
1795 
1796  event = (union perf_event *)(buf + head);
1797 
1798  if (session->header.needs_swap)
1800 
1801  if (head + event->header.size > mmap_size) {
1802  /* We're not fetching the event so swap back again */
1803  if (session->header.needs_swap)
1805  return NULL;
1806  }
1807 
1808  return event;
1809 }
1810 
1811 /*
1812  * On 64bit we can mmap the data file in one go. No need for tiny mmap
1813  * slices. On 32bit we use 32MB.
1814  */
1815 #if BITS_PER_LONG == 64
1816 #define MMAP_SIZE ULLONG_MAX
1817 #define NUM_MMAPS 1
1818 #else
1819 #define MMAP_SIZE (32 * 1024 * 1024ULL)
1820 #define NUM_MMAPS 128
1821 #endif
1822 
1824  u64 data_offset, u64 data_size,
1825  u64 file_size)
1826 {
1827  struct ordered_events *oe = &session->ordered_events;
1828  struct perf_tool *tool = session->tool;
1829  int fd = perf_data__fd(session->data);
1830  u64 head, page_offset, file_offset, file_pos, size;
1831  int err, mmap_prot, mmap_flags, map_idx = 0;
1832  size_t mmap_size;
1833  char *buf, *mmaps[NUM_MMAPS];
1834  union perf_event *event;
1835  struct ui_progress prog;
1836  s64 skip;
1837 
1839 
1840  page_offset = page_size * (data_offset / page_size);
1841  file_offset = page_offset;
1842  head = data_offset - page_offset;
1843 
1844  if (data_size == 0)
1845  goto out;
1846 
1847  if (data_offset + data_size < file_size)
1848  file_size = data_offset + data_size;
1849 
1850  ui_progress__init_size(&prog, file_size, "Processing events...");
1851 
1852  mmap_size = MMAP_SIZE;
1853  if (mmap_size > file_size) {
1854  mmap_size = file_size;
1855  session->one_mmap = true;
1856  }
1857 
1858  memset(mmaps, 0, sizeof(mmaps));
1859 
1860  mmap_prot = PROT_READ;
1861  mmap_flags = MAP_SHARED;
1862 
1863  if (session->header.needs_swap) {
1864  mmap_prot |= PROT_WRITE;
1865  mmap_flags = MAP_PRIVATE;
1866  }
1867 remap:
1868  buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd,
1869  file_offset);
1870  if (buf == MAP_FAILED) {
1871  pr_err("failed to mmap file\n");
1872  err = -errno;
1873  goto out_err;
1874  }
1875  mmaps[map_idx] = buf;
1876  map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
1877  file_pos = file_offset + head;
1878  if (session->one_mmap) {
1879  session->one_mmap_addr = buf;
1880  session->one_mmap_offset = file_offset;
1881  }
1882 
1883 more:
1884  event = fetch_mmaped_event(session, head, mmap_size, buf);
1885  if (!event) {
1886  if (mmaps[map_idx]) {
1887  munmap(mmaps[map_idx], mmap_size);
1888  mmaps[map_idx] = NULL;
1889  }
1890 
1891  page_offset = page_size * (head / page_size);
1892  file_offset += page_offset;
1893  head -= page_offset;
1894  goto remap;
1895  }
1896 
1897  size = event->header.size;
1898 
1899  if (size < sizeof(struct perf_event_header) ||
1900  (skip = perf_session__process_event(session, event, file_pos)) < 0) {
1901  pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1902  file_offset + head, event->header.size,
1903  event->header.type);
1904  err = -EINVAL;
1905  goto out_err;
1906  }
1907 
1908  if (skip)
1909  size += skip;
1910 
1911  head += size;
1912  file_pos += size;
1913 
1914  ui_progress__update(&prog, size);
1915 
1916  if (session_done())
1917  goto out;
1918 
1919  if (file_pos < file_size)
1920  goto more;
1921 
1922 out:
1923  /* do the final flush for ordered samples */
1925  if (err)
1926  goto out_err;
1927  err = auxtrace__flush_events(session, tool);
1928  if (err)
1929  goto out_err;
1930  err = perf_session__flush_thread_stacks(session);
1931 out_err:
1933  if (!tool->no_warn)
1935  /*
1936  * We may switching perf.data output, make ordered_events
1937  * reusable.
1938  */
1940  auxtrace__free_events(session);
1941  session->one_mmap = false;
1942  return err;
1943 }
1944 
1946 {
1947  u64 size = perf_data__size(session->data);
1948  int err;
1949 
1950  if (perf_session__register_idle_thread(session) < 0)
1951  return -ENOMEM;
1952 
1953  if (!perf_data__is_pipe(session->data))
1954  err = __perf_session__process_events(session,
1955  session->header.data_offset,
1956  session->header.data_size, size);
1957  else
1958  err = __perf_session__process_pipe_events(session);
1959 
1960  return err;
1961 }
1962 
1963 bool perf_session__has_traces(struct perf_session *session, const char *msg)
1964 {
1965  struct perf_evsel *evsel;
1966 
1967  evlist__for_each_entry(session->evlist, evsel) {
1968  if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
1969  return true;
1970  }
1971 
1972  pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
1973  return false;
1974 }
1975 
1976 int map__set_kallsyms_ref_reloc_sym(struct map *map, const char *symbol_name, u64 addr)
1977 {
1978  char *bracket;
1979  struct ref_reloc_sym *ref;
1980  struct kmap *kmap;
1981 
1982  ref = zalloc(sizeof(struct ref_reloc_sym));
1983  if (ref == NULL)
1984  return -ENOMEM;
1985 
1986  ref->name = strdup(symbol_name);
1987  if (ref->name == NULL) {
1988  free(ref);
1989  return -ENOMEM;
1990  }
1991 
1992  bracket = strchr(ref->name, ']');
1993  if (bracket)
1994  *bracket = '\0';
1995 
1996  ref->addr = addr;
1997 
1998  kmap = map__kmap(map);
1999  if (kmap)
2000  kmap->ref_reloc_sym = ref;
2001 
2002  return 0;
2003 }
2004 
2006 {
2007  return machines__fprintf_dsos(&session->machines, fp);
2008 }
2009 
2011  bool (skip)(struct dso *dso, int parm), int parm)
2012 {
2013  return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm);
2014 }
2015 
2016 size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
2017 {
2018  size_t ret;
2019  const char *msg = "";
2020 
2022  msg = " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)";
2023 
2024  ret = fprintf(fp, "\nAggregated stats:%s\n", msg);
2025 
2026  ret += events_stats__fprintf(&session->evlist->stats, fp);
2027  return ret;
2028 }
2029 
2030 size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
2031 {
2032  /*
2033  * FIXME: Here we have to actually print all the machines in this
2034  * session, not just the host...
2035  */
2036  return machine__fprintf(&session->machines.host, fp);
2037 }
2038 
2040  unsigned int type)
2041 {
2042  struct perf_evsel *pos;
2043 
2044  evlist__for_each_entry(session->evlist, pos) {
2045  if (pos->attr.type == type)
2046  return pos;
2047  }
2048  return NULL;
2049 }
2050 
2052  const char *cpu_list, unsigned long *cpu_bitmap)
2053 {
2054  int i, err = -1;
2055  struct cpu_map *map;
2056 
2057  for (i = 0; i < PERF_TYPE_MAX; ++i) {
2058  struct perf_evsel *evsel;
2059 
2060  evsel = perf_session__find_first_evtype(session, i);
2061  if (!evsel)
2062  continue;
2063 
2064  if (!(evsel->attr.sample_type & PERF_SAMPLE_CPU)) {
2065  pr_err("File does not contain CPU events. "
2066  "Remove -C option to proceed.\n");
2067  return -1;
2068  }
2069  }
2070 
2071  map = cpu_map__new(cpu_list);
2072  if (map == NULL) {
2073  pr_err("Invalid cpu_list\n");
2074  return -1;
2075  }
2076 
2077  for (i = 0; i < map->nr; i++) {
2078  int cpu = map->map[i];
2079 
2080  if (cpu >= MAX_NR_CPUS) {
2081  pr_err("Requested CPU %d too large. "
2082  "Consider raising MAX_NR_CPUS\n", cpu);
2083  goto out_delete_map;
2084  }
2085 
2086  set_bit(cpu, cpu_bitmap);
2087  }
2088 
2089  err = 0;
2090 
2091 out_delete_map:
2092  cpu_map__put(map);
2093  return err;
2094 }
2095 
2096 void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
2097  bool full)
2098 {
2099  if (session == NULL || fp == NULL)
2100  return;
2101 
2102  fprintf(fp, "# ========\n");
2103  perf_header__fprintf_info(session, fp, full);
2104  fprintf(fp, "# ========\n#\n");
2105 }
2106 
2107 
2109  const struct perf_evsel_str_handler *assocs,
2110  size_t nr_assocs)
2111 {
2112  struct perf_evsel *evsel;
2113  size_t i;
2114  int err;
2115 
2116  for (i = 0; i < nr_assocs; i++) {
2117  /*
2118  * Adding a handler for an event not in the session,
2119  * just ignore it.
2120  */
2121  evsel = perf_evlist__find_tracepoint_by_name(session->evlist, assocs[i].name);
2122  if (evsel == NULL)
2123  continue;
2124 
2125  err = -EEXIST;
2126  if (evsel->handler != NULL)
2127  goto out;
2128  evsel->handler = assocs[i].handler;
2129  }
2130 
2131  err = 0;
2132 out:
2133  return err;
2134 }
2135 
2136 int perf_event__process_id_index(struct perf_tool *tool __maybe_unused,
2137  union perf_event *event,
2138  struct perf_session *session)
2139 {
2140  struct perf_evlist *evlist = session->evlist;
2141  struct id_index_event *ie = &event->id_index;
2142  size_t i, nr, max_nr;
2143 
2144  max_nr = (ie->header.size - sizeof(struct id_index_event)) /
2145  sizeof(struct id_index_entry);
2146  nr = ie->nr;
2147  if (nr > max_nr)
2148  return -EINVAL;
2149 
2150  if (dump_trace)
2151  fprintf(stdout, " nr: %zu\n", nr);
2152 
2153  for (i = 0; i < nr; i++) {
2154  struct id_index_entry *e = &ie->entries[i];
2155  struct perf_sample_id *sid;
2156 
2157  if (dump_trace) {
2158  fprintf(stdout, " ... id: %"PRIu64, e->id);
2159  fprintf(stdout, " idx: %"PRIu64, e->idx);
2160  fprintf(stdout, " cpu: %"PRId64, e->cpu);
2161  fprintf(stdout, " tid: %"PRId64"\n", e->tid);
2162  }
2163 
2164  sid = perf_evlist__id2sid(evlist, e->id);
2165  if (!sid)
2166  return -ENOENT;
2167  sid->idx = e->idx;
2168  sid->cpu = e->cpu;
2169  sid->tid = e->tid;
2170  }
2171  return 0;
2172 }
2173 
2175  perf_event__handler_t process,
2176  struct perf_evlist *evlist,
2177  struct machine *machine)
2178 {
2179  union perf_event *ev;
2180  struct perf_evsel *evsel;
2181  size_t nr = 0, i = 0, sz, max_nr, n;
2182  int err;
2183 
2184  pr_debug2("Synthesizing id index\n");
2185 
2186  max_nr = (UINT16_MAX - sizeof(struct id_index_event)) /
2187  sizeof(struct id_index_entry);
2188 
2189  evlist__for_each_entry(evlist, evsel)
2190  nr += evsel->ids;
2191 
2192  n = nr > max_nr ? max_nr : nr;
2193  sz = sizeof(struct id_index_event) + n * sizeof(struct id_index_entry);
2194  ev = zalloc(sz);
2195  if (!ev)
2196  return -ENOMEM;
2197 
2198  ev->id_index.header.type = PERF_RECORD_ID_INDEX;
2199  ev->id_index.header.size = sz;
2200  ev->id_index.nr = n;
2201 
2202  evlist__for_each_entry(evlist, evsel) {
2203  u32 j;
2204 
2205  for (j = 0; j < evsel->ids; j++) {
2206  struct id_index_entry *e;
2207  struct perf_sample_id *sid;
2208 
2209  if (i >= n) {
2210  err = process(tool, ev, NULL, machine);
2211  if (err)
2212  goto out_err;
2213  nr -= n;
2214  i = 0;
2215  }
2216 
2217  e = &ev->id_index.entries[i++];
2218 
2219  e->id = evsel->id[j];
2220 
2221  sid = perf_evlist__id2sid(evlist, e->id);
2222  if (!sid) {
2223  free(ev);
2224  return -ENOENT;
2225  }
2226 
2227  e->idx = sid->idx;
2228  e->cpu = sid->cpu;
2229  e->tid = sid->tid;
2230  }
2231  }
2232 
2233  sz = sizeof(struct id_index_event) + nr * sizeof(struct id_index_entry);
2234  ev->id_index.header.size = sz;
2235  ev->id_index.nr = nr;
2236 
2237  err = process(tool, ev, NULL, machine);
2238 out_err:
2239  free(ev);
2240 
2241  return err;
2242 }
struct event_update_event event_update
Definition: event.h:636
u64 cpu
Definition: event.h:493
void perf_session__set_id_hdr_size(struct perf_session *session)
Definition: session.c:66
int nr
Definition: cpumap.h:14
u64 aux_offset
Definition: event.h:537
#define bswap_field_32(f)
static void event_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:1428
static void regs__printf(const char *type, struct regs_dump *regs)
Definition: session.c:982
#define NUM_MMAPS
Definition: session.c:1820
static perf_event__swap_op perf_event__swap_ops[]
Definition: session.c:785
event_attr_op event_update
Definition: tool.h:61
event_op mmap2
Definition: tool.h:47
static void callchain__printf(struct perf_evsel *evsel, struct perf_sample *sample)
Definition: session.c:920
void ui_progress__update(struct ui_progress *p, u64 adv)
Definition: progress.c:17
static int process_finished_round(struct perf_tool *tool, union perf_event *event, struct ordered_events *oe)
static struct machine * machines__find_for_cpumode(struct machines *machines, union perf_event *event, struct perf_sample *sample)
Definition: session.c:1152
event_op lost
Definition: tool.h:47
struct perf_tool * tool
Definition: session.h:37
void machines__exit(struct machines *machines)
Definition: machine.c:228
int value
Definition: python.c:1143
static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused, union perf_event *event, struct perf_session *session __maybe_unused)
Definition: session.c:280
size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp, bool(skip)(struct dso *dso, int parm), int parm)
Definition: session.c:2010
static int process_stat_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_session *perf_session __maybe_unused)
Definition: session.c:336
bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)
Definition: evlist.c:1335
struct perf_evlist * evlist
Definition: session.h:25
void ordered_events__reinit(struct ordered_events *oe)
u64 weight
Definition: event.h:199
struct perf_data * data
Definition: session.h:36
void perf_session__auxtrace_error_inc(struct perf_session *session, union perf_event *event)
Definition: auxtrace.c:1160
u64 aux_size
Definition: event.h:538
static void perf_event__stat_config_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:754
bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
Definition: evlist.c:1228
void mem_bswap_64(void *src, int byte_size)
Definition: memswap.c:16
struct aux_event aux
Definition: event.h:644
static const char * regs_dump_abi(struct regs_dump *d)
Definition: session.c:974
static int perf_session__flush_thread_stack(struct thread *thread, void *p __maybe_unused)
Definition: session.c:1668
static int deliver_sample_group(struct perf_evlist *evlist, struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, struct machine *machine)
Definition: session.c:1201
static void swap_sample_id_all(union perf_event *event, void *data)
Definition: session.c:430
bool perf_evlist__valid_read_format(struct perf_evlist *evlist)
Definition: evlist.c:1276
static unsigned long perf_data__size(struct perf_data *data)
Definition: data.h:45
size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
Definition: session.c:2016
static int process_event_stat_config_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_session *session __maybe_unused)
Definition: session.c:325
u64 pgoff
Definition: event.h:27
u64 pgoff
Definition: event.h:18
int __perf_session__set_tracepoints_handlers(struct perf_session *session, const struct perf_evsel_str_handler *assocs, size_t nr_assocs)
Definition: session.c:2108
struct ordered_events ordered_events
Definition: session.h:35
size_t perf_event__fprintf_cpu_map(union perf_event *event, FILE *fp)
Definition: event.c:1369
void mem_bswap_32(void *src, int byte_size)
Definition: memswap.c:6
u32 tid
Definition: event.h:15
struct time_conv_event time_conv
Definition: session.h:30
static int process_event_op2_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_session *session __maybe_unused)
Definition: session.c:291
struct thread_map_event_entry entries[]
Definition: event.h:561
int(* perf_event__handler_t)(struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, struct machine *machine)
Definition: event.h:664
struct kmap * map__kmap(struct map *map)
Definition: map.c:881
static void auxtrace__free(struct perf_session *session __maybe_unused)
Definition: auxtrace.h:676
u64 data_src
Definition: event.h:203
size_t size
Definition: evsel.c:60
struct attr_event attr
Definition: event.h:635
static int perf_session__flush_thread_stacks(struct perf_session *session)
Definition: session.c:1674
u32 tid
Definition: event.h:53
static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:446
static int process_event_synth_tracing_data_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_session *session __maybe_unused)
Definition: session.c:202
int perf_event__process_aux(struct perf_tool *tool __maybe_unused, union perf_event *event, struct perf_sample *sample __maybe_unused, struct machine *machine)
Definition: event.c:1297
int perf_event__process_lost_samples(struct perf_tool *tool __maybe_unused, union perf_event *event, struct perf_sample *sample, struct machine *machine)
Definition: event.c:1313
static void skip(int size)
const char * name
Definition: symbol.h:174
struct machine host
Definition: machine.h:136
#define bswap_field_16(f)
static int process_stat_round_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_session *perf_session __maybe_unused)
Definition: session.c:348
u16 nr
Definition: event.h:429
unsigned int page_size
Definition: util.c:40
static bool perf_data__is_read(struct perf_data *data)
Definition: data.h:25
static void auxtrace__free_events(struct perf_session *session __maybe_unused)
Definition: auxtrace.h:666
u32 pid
Definition: event.h:52
u32 tid
Definition: event.h:39
u64 time_enabled
Definition: event.h:75
u64 addr
Definition: event.h:195
void perf_event__attr_swap(struct perf_event_attr *attr)
Definition: session.c:597
ssize_t readn(int fd, void *buf, size_t n)
Definition: util.c:351
struct tracing_data_event tracing_data
Definition: event.h:638
int machine__create_kernel_maps(struct machine *machine)
Definition: machine.c:1321
Definition: map.h:52
dictionary data
Definition: stat-cpi.py:4
void trace_event(union perf_event *event)
Definition: debug.c:164
u32 min
Definition: event.h:29
int ui__warning(const char *format,...)
Definition: util.c:44
struct ip_callchain * callchain
Definition: event.h:211
int perf_session__deliver_synth_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample)
Definition: session.c:1413
int int err
Definition: 5sec.c:44
size_t machines__fprintf_dsos(struct machines *machines, FILE *fp)
Definition: machine.c:704
u64 nr
Definition: event.h:157
u32 pid
Definition: event.h:73
u16 long_size
Definition: event.h:430
struct throttle_event throttle
Definition: event.h:633
bool perf_evlist__sample_id_all(struct perf_evlist *evlist)
Definition: evlist.c:1347
#define DEFAULT_GUEST_KERNEL_ID
Definition: machine.h:22
static int ordered_events__deliver_event(struct ordered_events *oe, struct ordered_event *event)
Definition: session.c:106
event_op lost_samples
Definition: tool.h:47
u32 thread
Definition: event.h:587
static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:507
event_op2 tracing_data
Definition: tool.h:62
#define config
#define pr_debug2(fmt,...)
Definition: debug.h:33
struct perf_env env
Definition: header.h:82
u64 from
Definition: event.h:151
void machines__set_id_hdr_size(struct machines *machines, u16 id_hdr_size)
Definition: machine.c:348
size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp)
Definition: session.c:2005
size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
Definition: session.c:2030
event_op2 auxtrace_info
Definition: tool.h:64
u64 total_lost
Definition: event.h:402
static int skipn(int fd, off_t n)
Definition: session.c:265
u16 cpu[]
Definition: event.h:425
u64 start
Definition: event.h:16
static void perf_event__throttle_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:553
size_t perf_event__fprintf_stat(union perf_event *event, FILE *fp)
Definition: stat.c:400
u64 cycles
Definition: event.h:145
static const char * perf_reg_name(int id)
Definition: perf_regs.h:18
#define MMAP_SIZE
Definition: session.c:1819
struct perf_event_header header
Definition: event.h:498
static int auxtrace__process_event(struct perf_session *session __maybe_unused, union perf_event *event __maybe_unused, struct perf_sample *sample __maybe_unused, struct perf_tool *tool __maybe_unused)
Definition: auxtrace.h:650
u64 mask
Definition: event.h:104
Definition: cpumap.h:12
u64 ips[0]
Definition: event.h:137
struct machine * machines__findnew(struct machines *machines, pid_t pid)
Definition: machine.c:303
struct stat_config_event stat_config
Definition: event.h:649
int dump_printf(const char *fmt,...)
Definition: debug.c:101
static void perf_session__delete_threads(struct perf_session *session)
Definition: session.c:182
static void perf_event__event_update_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:653
event_op2 stat_config
Definition: tool.h:64
unsigned long mask[]
Definition: event.h:431
u64 phys_addr
Definition: event.h:204
struct stat_round_event stat_round
Definition: event.h:651
struct itrace_start_event itrace_start
Definition: event.h:645
u64 reference
Definition: event.h:514
bool perf_session__has_traces(struct perf_session *session, const char *msg)
Definition: session.c:1963
u64 ip
Definition: event.h:192
x86 movsq based memset() in arch/x86/lib/memset_64.S") MEMSET_FN(memset_erms
#define pr_err(fmt,...)
Definition: json.h:21
static void perf_event__cpu_map_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:718
struct id_index_entry entries[0]
Definition: event.h:500
u64 period
Definition: evsel.h:30
struct sample_read::@79::@81 group
struct sample_read_value one
Definition: event.h:131
u32 nr_invalid_chains
Definition: event.h:411
void perf_session__delete(struct perf_session *session)
Definition: session.c:187
static int deliver_sample_value(struct perf_evlist *evlist, struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, struct sample_read_value *v, struct machine *machine)
Definition: session.c:1178
#define min(x, y)
Definition: jevents.h:15
void * one_mmap_addr
Definition: session.h:33
u16 offset
Definition: event.h:113
size_t perf_event__fprintf_event_update(union perf_event *event, FILE *fp)
Definition: header.c:3595
u32 ids
Definition: evsel.h:101
static void branch_stack__printf(struct perf_sample *sample)
Definition: session.c:936
static u8 revbyte(u8 b)
Definition: session.c:564
static void perf_event__thread_map_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:707
u32 nr_proc_map_timeout
Definition: event.h:415
int perf_event__process_itrace_start(struct perf_tool *tool __maybe_unused, union perf_event *event, struct perf_sample *sample __maybe_unused, struct machine *machine)
Definition: event.c:1305
struct branch_entry entries[0]
Definition: event.h:158
static void perf_event__mmap2_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:476
u64 id
Definition: event.h:196
static void perf_session__warn_about_errors(const struct perf_session *session)
Definition: session.c:1576
void * malloc(YYSIZE_T)
struct machine * machines__find(struct machines *machines, pid_t pid)
Definition: machine.c:277
u64 reserved
Definition: event.h:147
u64 ino
Definition: event.h:30
void machines__set_comm_exec(struct machines *machines, bool comm_exec)
Definition: machine.c:264
u32 tid
Definition: event.h:24
u32 maj
Definition: event.h:28
void cpu_map__put(struct cpu_map *map)
Definition: cpumap.c:298
static int process_event_synth_event_update_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_evlist **pevlist __maybe_unused)
Definition: session.c:222
void perf_env__exit(struct perf_env *env)
Definition: env.c:11
static void perf_session__warn_order(const struct perf_session *session)
Definition: session.c:1559
Definition: thread.h:18
void ordered_events__free(struct ordered_events *oe)
static void dump_read(struct perf_evsel *evsel, union perf_event *event)
Definition: session.c:1128
u64 val
Definition: event.h:591
u32 nr_unknown_id
Definition: event.h:412
bool perf_guest
Definition: util.c:81
int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
Definition: header.c:2628
u64 stream_id
Definition: event.h:84
Definition: tool.h:44
static struct perf_session * session
Definition: builtin-lock.c:34
const char * name
Definition: evlist.h:57
u64 id[]
Definition: event.h:447
static void perf_event__stat_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:764
int perf_data__open(struct perf_data *data)
Definition: data.c:122
bool repipe
Definition: session.h:31
#define bswap_field_64(f)
#define evlist__for_each_entry(evlist, evsel)
Definition: evlist.h:247
u64 start
Definition: event.h:25
event_oe finished_round
Definition: tool.h:63
u64 nr
Definition: event.h:136
int perf_session__read_header(struct perf_session *session)
Definition: header.c:3247
static int process_event_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_sample *sample __maybe_unused, struct machine *machine __maybe_unused)
Definition: session.c:244
static s64 perf_session__process_event(struct perf_session *session, union perf_event *event, u64 file_offset)
Definition: session.c:1492
int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event, struct perf_sample *sample)
Definition: evlist.c:1561
u64 offset
Definition: event.h:513
pid_t tid
Definition: evsel.h:27
u64 time_running
Definition: event.h:125
struct read_event read
Definition: event.h:632
static void regs_dump__printf(u64 mask, u64 *regs)
Definition: session.c:956
u64 time_running
Definition: event.h:76
static void dump_sample(struct perf_evsel *evsel, union perf_event *event, struct perf_sample *sample)
Definition: session.c:1083
struct context_switch_event context_switch
Definition: event.h:646
static bool repipe
u64 total_lost_samples
Definition: event.h:403
u64 value
Definition: event.h:74
u64 run
Definition: event.h:593
struct regs_dump user_regs
Definition: event.h:213
#define ui_progress__init_size(p, total, title)
Definition: progress.h:21
event_op exit
Definition: tool.h:47
int perf_session__register_idle_thread(struct perf_session *session)
Definition: session.c:1537
u64 len
Definition: event.h:17
bool is_pipe
Definition: data.h:19
size_t perf_event__fprintf_stat_config(union perf_event *event, FILE *fp)
Definition: stat.c:424
static int process_event_sample_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_sample *sample __maybe_unused, struct perf_evsel *evsel __maybe_unused, struct machine *machine __maybe_unused)
Definition: session.c:234
static struct perf_tool tool
Definition: builtin-diff.c:362
static int process_event_thread_map_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_session *session __maybe_unused)
Definition: session.c:301
u64 period
Definition: event.h:198
u64 predicted
Definition: event.h:142
u32 pid
Definition: event.h:193
event_op aux
Definition: tool.h:47
u64 tid
Definition: event.h:494
u32 tid
Definition: event.h:193
void auxtrace_index__free(struct list_head *head)
Definition: auxtrace.c:613
list cpus
Definition: stat-cpi.py:7
event_op2 time_conv
Definition: tool.h:64
static void perf_event__switch_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:540
static void perf_event__tracing_data_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:667
u64 id
Definition: event.h:491
static int process_event_cpu_map_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_session *session __maybe_unused)
Definition: session.c:313
struct perf_evsel * perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
Definition: evlist.c:589
bool ordered_events
Definition: tool.h:76
int perf_evlist__parse_sample_timestamp(struct perf_evlist *evlist, union perf_event *event, u64 *timestamp)
Definition: evlist.c:1571
u64 pid
Definition: event.h:554
event_op2 cpu_map
Definition: tool.h:64
static const char * cpu_list
u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
Definition: evlist.c:1302
u64 abi
Definition: event.h:103
void events_stats__inc(struct events_stats *stats, u32 type)
Definition: hist.c:2118
struct regs_dump intr_regs
Definition: event.h:214
int machines__create_guest_kernel_maps(struct machines *machines)
Definition: machine.c:1021
Definition: dso.h:138
struct perf_trace_event_type event_type
Definition: event.h:482
#define event
struct fork_event fork
Definition: event.h:629
struct branch_stack * branch_stack
Definition: event.h:212
static void perf_event__itrace_start_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:530
u64 time
Definition: event.h:54
int ordered_events__flush(struct ordered_events *oe, enum oe_flush how)
void ordered_events__init(struct ordered_events *oe, ordered_events__deliver_t deliver)
u64 in_tx
Definition: event.h:143
static void dump_event(struct perf_evlist *evlist, union perf_event *event, u64 file_offset, struct perf_sample *sample)
Definition: session.c:1065
u32 cpu
Definition: event.h:201
static int perf_session__open(struct perf_session *session)
Definition: session.c:33
u32 ptid
Definition: event.h:53
const char * perf_event__name(unsigned int id)
Definition: event.c:75
struct ref_reloc_sym * ref_reloc_sym
Definition: map.h:53
bool ordering_requires_timestamps
Definition: tool.h:77
static void regs_intr__printf(struct perf_sample *sample)
Definition: session.c:1002
Definition: data.h:17
static int perf_data__fd(struct perf_data *data)
Definition: data.h:40
size_t perf_event__fprintf_thread_map(union perf_event *event, FILE *fp)
Definition: event.c:1353
struct stat_event stat
Definition: event.h:650
size_t machines__fprintf_dsos_buildid(struct machines *machines, FILE *fp, bool(skip)(struct dso *dso, int parm), int parm)
Definition: machine.c:723
void(* perf_event__swap_op)(union perf_event *event, bool sample_id_all)
Definition: session.c:782
int map[]
Definition: cpumap.h:15
u64 idx
Definition: event.h:492
int thread__set_namespaces(struct thread *thread, u64 timestamp, struct namespaces_event *event)
Definition: thread.c:163
event_op2 thread_map
Definition: tool.h:64
u32 nr_unprocessable_samples
Definition: event.h:413
u32 tid
Definition: event.h:73
int perf_event__process_switch(struct perf_tool *tool __maybe_unused, union perf_event *event, struct perf_sample *sample __maybe_unused, struct machine *machine)
Definition: event.c:1321
static int process_finished_round_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct ordered_events *oe __maybe_unused)
Definition: session.c:253
bool no_warn
Definition: tool.h:79
void machines__destroy_kernel_maps(struct machines *machines)
Definition: machine.c:1070
u32 pid
Definition: event.h:24
bool one_mmap
Definition: session.h:32
const char * perf_evsel__name(struct perf_evsel *evsel)
Definition: evsel.c:577
static void ordered_events__set_copy_on_queue(struct ordered_events *oe, bool copy)
static void perf_session__set_comm_exec(struct perf_session *session)
Definition: session.c:99
event_op2 stat
Definition: tool.h:64
struct perf_event_header header
Definition: event.h:624
static int auxtrace__flush_events(struct perf_session *session __maybe_unused, struct perf_tool *tool __maybe_unused)
Definition: auxtrace.h:659
Definition: event.h:150
size_t events_stats__fprintf(struct events_stats *stats, FILE *fp)
Definition: hist.c:834
#define bswap_safe(f, n)
u32 pid
Definition: hists_common.c:15
volatile int session_done
Definition: session.c:1681
void perf_event_header__bswap(struct perf_event_header *hdr)
Definition: session.c:1525
static int thread__set_comm(struct thread *thread, const char *comm, u64 timestamp)
Definition: thread.h:77
size_t perf_event__fprintf_stat_round(union perf_event *event, FILE *fp)
Definition: stat.c:413
void ui_progress__finish(void)
Definition: progress.c:44
struct auxtrace_error_event auxtrace_error
Definition: event.h:643
static void swap_bitfield(u8 *p, unsigned len)
Definition: session.c:586
static int perf_data__is_pipe(struct perf_data *data)
Definition: data.h:35
event_op2 feature
Definition: tool.h:64
static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:495
struct perf_session * perf_session__new(struct perf_data *data, bool repipe, struct perf_tool *tool)
Definition: session.c:116
static void perf_event__aux_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:520
u64 one_mmap_offset
Definition: session.h:34
u64 time
Definition: event.h:82
int perf_session__queue_event(struct perf_session *s, union perf_event *event, u64 timestamp, u64 file_offset)
Definition: session.c:867
u64 transaction
Definition: event.h:200
void thread__put(struct thread *thread)
Definition: thread.c:119
bool perf_header__has_feat(const struct perf_header *header, int feat)
Definition: header.c:86
static void perf_event__auxtrace_error_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:696
static void perf_evlist__print_tstamp(struct perf_evlist *evlist, union perf_event *event, struct perf_sample *sample)
Definition: session.c:1016
event_op2 stat_round
Definition: tool.h:64
Definition: jevents.c:228
static bool perf_data__is_write(struct perf_data *data)
Definition: data.h:30
int map__set_kallsyms_ref_reloc_sym(struct map *map, const char *symbol_name, u64 addr)
Definition: session.c:1976
int perf_session__process_events(struct perf_session *session)
Definition: session.c:1945
u64 id
Definition: event.h:585
u64 __perf_evlist__combined_sample_type(struct perf_evlist *evlist)
Definition: evlist.c:1247
struct list_head auxtrace_index
Definition: session.h:28
static int machines__deliver_event(struct machines *machines, struct perf_evlist *evlist, union perf_event *event, struct perf_sample *sample, struct perf_tool *tool, u64 file_offset)
Definition: session.c:1246
void machines__init(struct machines *machines)
Definition: machine.c:222
event_op namespaces
Definition: tool.h:47
Definition: stat.h:10
void events_stats__auxtrace_error_warn(const struct events_stats *stats)
Definition: auxtrace.c:1169
union perf_event * event
u64 data_offset
Definition: header.h:78
u32 cpu
Definition: event.h:586
static void perf_event__mmap_swap(union perf_event *event, bool sample_id_all)
Definition: session.c:459
u64 time
Definition: event.h:194
struct auxtrace_event auxtrace
Definition: event.h:642
struct events_stats stats
Definition: evlist.h:50
struct perf_evsel * perf_evlist__find_tracepoint_by_name(struct perf_evlist *evlist, const char *name)
Definition: evlist.c:320
event_op2 id_index
Definition: tool.h:64
static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused, union perf_event *event __maybe_unused, struct perf_evlist **pevlist __maybe_unused)
Definition: session.c:213
struct perf_header header
Definition: session.h:23
u64 total_aux_lost
Definition: event.h:404
struct sample_read read
Definition: event.h:216
event_op comm
Definition: tool.h:47
struct perf_evsel * perf_session__find_first_evtype(struct perf_session *session, unsigned int type)
Definition: session.c:2039
bool dump_trace
Definition: debug.c:27
static void perf_event__auxtrace_info_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:673
u32 pid
Definition: event.h:15
event_op2 auxtrace_error
Definition: tool.h:64
struct comm_event comm
Definition: event.h:627
void free(void *)
int perf_event__process_id_index(struct perf_tool *tool __maybe_unused, union perf_event *event, struct perf_session *session)
Definition: session.c:2136
struct mmap2_event mmap2
Definition: event.h:626
u64 total_aux_partial
Definition: event.h:405
u32 nr_unknown_events
Definition: event.h:410
static int perf_evlist__deliver_sample(struct perf_evlist *evlist, struct perf_tool *tool, union perf_event *event, struct perf_sample *sample, struct perf_evsel *evsel, struct machine *machine)
Definition: session.c:1222
u16 type
Definition: event.h:435
u32 nr_events[PERF_RECORD_HEADER_MAX]
Definition: event.h:407
event_op itrace_start
Definition: tool.h:47
int ordered_events__queue(struct ordered_events *oe, union perf_event *event, u64 timestamp, u64 file_offset)
static void sample_read__printf(struct perf_sample *sample, u64 read_format)
Definition: session.c:1035
struct auxtrace_info_event auxtrace_info
Definition: event.h:641
struct event_type_event event_type
Definition: event.h:637
#define MAX_NR_CPUS
Definition: perf.h:27
static void perf_session__destroy_kernel_maps(struct perf_session *session)
Definition: session.c:82
int machines__for_each_thread(struct machines *machines, int(*fn)(struct thread *thread, void *p), void *priv)
Definition: machine.c:2373
event_sample read
Definition: tool.h:45
struct thread_map_event thread_map
Definition: event.h:647
static const char * regs_abi[]
Definition: session.c:968
int perf_event__process_lost(struct perf_tool *tool __maybe_unused, union perf_event *event, struct perf_sample *sample, struct machine *machine)
Definition: event.c:1289
Definition: attr.py:1
int thread_stack__flush(struct thread *thread)
Definition: thread-stack.c:211
event_op unthrottle
Definition: tool.h:47
static void regs_user__printf(struct perf_sample *sample)
Definition: session.c:994
struct thread * perf_session__findnew(struct perf_session *session, pid_t pid)
Definition: session.c:1532
int perf_session__peek_event(struct perf_session *session, off_t file_offset, void *buf, size_t buf_sz, union perf_event **event_ptr, struct perf_sample *sample)
Definition: session.c:1437
static int __perf_session__process_events(struct perf_session *session, u64 data_offset, u64 data_size, u64 file_size)
Definition: session.c:1823
static int perf_session__deliver_event(struct perf_session *session, union perf_event *event, struct perf_tool *tool, u64 file_offset)
Definition: session.c:1321
struct perf_evsel * evsel
Definition: evsel.h:24
struct perf_env perf_env
Definition: env.c:9
int perf_event__synthesize_id_index(struct perf_tool *tool, perf_event__handler_t process, struct perf_evlist *evlist, struct machine *machine)
Definition: session.c:2174
static void perf_event__event_type_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:660
u64 * regs
Definition: event.h:105
#define UINT16_MAX
static void perf_event__stat_round_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:775
static s64 perf_session__process_user_event(struct perf_session *session, union perf_event *event, u64 file_offset)
Definition: session.c:1345
static void perf_event__auxtrace_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:685
#define pr_warning(fmt,...)
Definition: debug.h:25
int perf_session__cpu_bitmap(struct perf_session *session, const char *cpu_list, unsigned long *cpu_bitmap)
Definition: session.c:2051
event_op fork
Definition: tool.h:47
static void stack_user__printf(struct stack_dump *dump)
Definition: session.c:1010
static void perf_event__all64_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:439
u64 time_enabled
Definition: event.h:124
event_attr_op attr
Definition: tool.h:60
event_op throttle
Definition: tool.h:47
struct cpu_map * cpu_map__new(const char *cpu_list)
Definition: cpumap.c:125
void perf_session__fprintf_info(struct perf_session *session, FILE *fp, bool full)
Definition: session.c:2096
static bool evsel__has_callchain(const struct perf_evsel *evsel)
Definition: evsel.h:462
bool needs_swap
Definition: header.h:77
event_op mmap
Definition: tool.h:47
u32 ppid
Definition: event.h:52
static void callchain__lbr_callstack_printf(struct perf_sample *sample)
Definition: session.c:873
event_op context_switch
Definition: tool.h:47
struct perf_sample_id * perf_evlist__id2sid(struct perf_evlist *evlist, u64 id)
Definition: evlist.c:573
char data[]
Definition: event.h:436
struct mmap_event mmap
Definition: event.h:625
void machine__delete_threads(struct machine *machine)
Definition: machine.c:174
u64 size
Definition: event.h:114
u8 cpumode
Definition: event.h:207
u64 * id
Definition: evsel.h:97
struct stack_dump user_stack
Definition: event.h:215
struct perf_event_attr attr
Definition: event.h:446
event_op2 build_id
Definition: tool.h:64
u64 len
Definition: event.h:26
u32 pid
Definition: event.h:39
void perf_data__close(struct perf_data *data)
Definition: data.c:133
static void perf_event__hdr_attr_swap(union perf_event *event, bool sample_id_all __maybe_unused)
Definition: session.c:641
struct machines machines
Definition: session.h:24
u64 to
Definition: event.h:152
size_t machine__fprintf(struct machine *machine, FILE *fp)
Definition: machine.c:756
struct thread * machine__findnew_thread(struct machine *machine, pid_t pid, pid_t tid)
Definition: machine.c:492
static bool done
Definition: futex-hash.c:35
struct perf_event_attr attr
Definition: evsel.h:93
static union perf_event * fetch_mmaped_event(struct perf_session *session, u64 head, size_t mmap_size, char *buf)
Definition: session.c:1784
int perf_session__create_kernel_maps(struct perf_session *session)
Definition: session.c:73
u64 flags
Definition: event.h:539
u64 abort
Definition: event.h:144
void perf_tool__fill_defaults(struct perf_tool *tool)
Definition: session.c:360
static bool perf_evsel__has_branch_callstack(const struct perf_evsel *evsel)
Definition: evsel.h:457
struct branch_flags flags
Definition: event.h:153
struct perf_env * env
Definition: machine.h:49
static int __perf_session__process_pipe_events(struct perf_session *session)
Definition: session.c:1683
u64 mispred
Definition: event.h:141
static bool perf_session__has_comm_exec(struct perf_session *session)
Definition: session.c:87
event_op3 auxtrace
Definition: tool.h:75
event_sample sample
Definition: tool.h:45
u64 id
Definition: event.h:77
u64 data_size
Definition: header.h:79
void static void * zalloc(size_t size)
Definition: util.h:20
u64 ena
Definition: event.h:592
void * handler
Definition: evsel.h:111