aboutsummaryrefslogtreecommitdiffstats
path: root/tools/perf/util
diff options
context:
space:
mode:
authorArnaldo Carvalho de Melo <acme@redhat.com>2011-11-28 05:30:20 -0500
committerArnaldo Carvalho de Melo <acme@redhat.com>2011-11-28 07:39:28 -0500
commit45694aa7702bc44d538a3bcb51bb2bb96cf190c0 (patch)
tree81bc1f449f55984556d89b63c461dcf181dc97e5 /tools/perf/util
parent743eb868657bdb1b26c7b24077ca21c67c82c777 (diff)
perf tools: Rename perf_event_ops to perf_tool
To better reflect that it became the base class for all tools, that must be in each tool struct and where common stuff will be put. Cc: David Ahern <dsahern@gmail.com> Cc: Frederic Weisbecker <fweisbec@gmail.com> Cc: Mike Galbraith <efault@gmx.de> Cc: Paul Mackerras <paulus@samba.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Stephane Eranian <eranian@google.com> Link: http://lkml.kernel.org/n/tip-qgpc4msetqlwr8y2k7537cxe@git.kernel.org Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Diffstat (limited to 'tools/perf/util')
-rw-r--r--tools/perf/util/build-id.c7
-rw-r--r--tools/perf/util/build-id.h2
-rw-r--r--tools/perf/util/event.c54
-rw-r--r--tools/perf/util/event.h22
-rw-r--r--tools/perf/util/header.c28
-rw-r--r--tools/perf/util/header.h16
-rw-r--r--tools/perf/util/session.c163
-rw-r--r--tools/perf/util/session.h49
-rw-r--r--tools/perf/util/tool.h45
-rw-r--r--tools/perf/util/top.h7
10 files changed, 203 insertions, 190 deletions
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 2f84c4802ac..dff9c7a725f 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -14,8 +14,9 @@
14#include <linux/kernel.h> 14#include <linux/kernel.h>
15#include "debug.h" 15#include "debug.h"
16#include "session.h" 16#include "session.h"
17#include "tool.h"
17 18
18static int build_id__mark_dso_hit(struct perf_event_ops *ops __used, 19static int build_id__mark_dso_hit(struct perf_tool *tool __used,
19 union perf_event *event, 20 union perf_event *event,
20 struct perf_sample *sample __used, 21 struct perf_sample *sample __used,
21 struct perf_evsel *evsel __used, 22 struct perf_evsel *evsel __used,
@@ -40,7 +41,7 @@ static int build_id__mark_dso_hit(struct perf_event_ops *ops __used,
40 return 0; 41 return 0;
41} 42}
42 43
43static int perf_event__exit_del_thread(struct perf_event_ops *ops __used, 44static int perf_event__exit_del_thread(struct perf_tool *tool __used,
44 union perf_event *event, 45 union perf_event *event,
45 struct perf_sample *sample __used, 46 struct perf_sample *sample __used,
46 struct machine *machine) 47 struct machine *machine)
@@ -59,7 +60,7 @@ static int perf_event__exit_del_thread(struct perf_event_ops *ops __used,
59 return 0; 60 return 0;
60} 61}
61 62
62struct perf_event_ops build_id__mark_dso_hit_ops = { 63struct perf_tool build_id__mark_dso_hit_ops = {
63 .sample = build_id__mark_dso_hit, 64 .sample = build_id__mark_dso_hit,
64 .mmap = perf_event__process_mmap, 65 .mmap = perf_event__process_mmap,
65 .fork = perf_event__process_task, 66 .fork = perf_event__process_task,
diff --git a/tools/perf/util/build-id.h b/tools/perf/util/build-id.h
index 5dafb00eaa0..a993ba87d99 100644
--- a/tools/perf/util/build-id.h
+++ b/tools/perf/util/build-id.h
@@ -3,7 +3,7 @@
3 3
4#include "session.h" 4#include "session.h"
5 5
6extern struct perf_event_ops build_id__mark_dso_hit_ops; 6extern struct perf_tool build_id__mark_dso_hit_ops;
7 7
8char *dso__build_id_filename(struct dso *self, char *bf, size_t size); 8char *dso__build_id_filename(struct dso *self, char *bf, size_t size);
9 9
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 0cdc811c48e..0ebbe764133 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -43,7 +43,7 @@ static struct perf_sample synth_sample = {
43 .period = 1, 43 .period = 1,
44}; 44};
45 45
46static pid_t perf_event__synthesize_comm(struct perf_event_ops *ops, 46static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
47 union perf_event *event, pid_t pid, 47 union perf_event *event, pid_t pid,
48 int full, perf_event__handler_t process, 48 int full, perf_event__handler_t process,
49 struct machine *machine) 49 struct machine *machine)
@@ -99,7 +99,7 @@ out_race:
99 if (!full) { 99 if (!full) {
100 event->comm.tid = pid; 100 event->comm.tid = pid;
101 101
102 process(ops, event, &synth_sample, machine); 102 process(tool, event, &synth_sample, machine);
103 goto out; 103 goto out;
104 } 104 }
105 105
@@ -117,7 +117,7 @@ out_race:
117 117
118 event->comm.tid = pid; 118 event->comm.tid = pid;
119 119
120 process(ops, event, &synth_sample, machine); 120 process(tool, event, &synth_sample, machine);
121 } 121 }
122 122
123 closedir(tasks); 123 closedir(tasks);
@@ -127,7 +127,7 @@ out:
127 return tgid; 127 return tgid;
128} 128}
129 129
130static int perf_event__synthesize_mmap_events(struct perf_event_ops *ops, 130static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
131 union perf_event *event, 131 union perf_event *event,
132 pid_t pid, pid_t tgid, 132 pid_t pid, pid_t tgid,
133 perf_event__handler_t process, 133 perf_event__handler_t process,
@@ -199,7 +199,7 @@ static int perf_event__synthesize_mmap_events(struct perf_event_ops *ops,
199 event->mmap.pid = tgid; 199 event->mmap.pid = tgid;
200 event->mmap.tid = pid; 200 event->mmap.tid = pid;
201 201
202 process(ops, event, &synth_sample, machine); 202 process(tool, event, &synth_sample, machine);
203 } 203 }
204 } 204 }
205 205
@@ -207,7 +207,7 @@ static int perf_event__synthesize_mmap_events(struct perf_event_ops *ops,
207 return 0; 207 return 0;
208} 208}
209 209
210int perf_event__synthesize_modules(struct perf_event_ops *ops, 210int perf_event__synthesize_modules(struct perf_tool *tool,
211 perf_event__handler_t process, 211 perf_event__handler_t process,
212 struct machine *machine) 212 struct machine *machine)
213{ 213{
@@ -252,7 +252,7 @@ int perf_event__synthesize_modules(struct perf_event_ops *ops,
252 252
253 memcpy(event->mmap.filename, pos->dso->long_name, 253 memcpy(event->mmap.filename, pos->dso->long_name,
254 pos->dso->long_name_len + 1); 254 pos->dso->long_name_len + 1);
255 process(ops, event, &synth_sample, machine); 255 process(tool, event, &synth_sample, machine);
256 } 256 }
257 257
258 free(event); 258 free(event);
@@ -262,18 +262,18 @@ int perf_event__synthesize_modules(struct perf_event_ops *ops,
262static int __event__synthesize_thread(union perf_event *comm_event, 262static int __event__synthesize_thread(union perf_event *comm_event,
263 union perf_event *mmap_event, 263 union perf_event *mmap_event,
264 pid_t pid, perf_event__handler_t process, 264 pid_t pid, perf_event__handler_t process,
265 struct perf_event_ops *ops, 265 struct perf_tool *tool,
266 struct machine *machine) 266 struct machine *machine)
267{ 267{
268 pid_t tgid = perf_event__synthesize_comm(ops, comm_event, pid, 1, 268 pid_t tgid = perf_event__synthesize_comm(tool, comm_event, pid, 1,
269 process, machine); 269 process, machine);
270 if (tgid == -1) 270 if (tgid == -1)
271 return -1; 271 return -1;
272 return perf_event__synthesize_mmap_events(ops, mmap_event, pid, tgid, 272 return perf_event__synthesize_mmap_events(tool, mmap_event, pid, tgid,
273 process, machine); 273 process, machine);
274} 274}
275 275
276int perf_event__synthesize_thread_map(struct perf_event_ops *ops, 276int perf_event__synthesize_thread_map(struct perf_tool *tool,
277 struct thread_map *threads, 277 struct thread_map *threads,
278 perf_event__handler_t process, 278 perf_event__handler_t process,
279 struct machine *machine) 279 struct machine *machine)
@@ -293,7 +293,7 @@ int perf_event__synthesize_thread_map(struct perf_event_ops *ops,
293 for (thread = 0; thread < threads->nr; ++thread) { 293 for (thread = 0; thread < threads->nr; ++thread) {
294 if (__event__synthesize_thread(comm_event, mmap_event, 294 if (__event__synthesize_thread(comm_event, mmap_event,
295 threads->map[thread], 295 threads->map[thread],
296 process, ops, machine)) { 296 process, tool, machine)) {
297 err = -1; 297 err = -1;
298 break; 298 break;
299 } 299 }
@@ -305,7 +305,7 @@ out:
305 return err; 305 return err;
306} 306}
307 307
308int perf_event__synthesize_threads(struct perf_event_ops *ops, 308int perf_event__synthesize_threads(struct perf_tool *tool,
309 perf_event__handler_t process, 309 perf_event__handler_t process,
310 struct machine *machine) 310 struct machine *machine)
311{ 311{
@@ -334,7 +334,7 @@ int perf_event__synthesize_threads(struct perf_event_ops *ops,
334 continue; 334 continue;
335 335
336 __event__synthesize_thread(comm_event, mmap_event, pid, 336 __event__synthesize_thread(comm_event, mmap_event, pid,
337 process, ops, machine); 337 process, tool, machine);
338 } 338 }
339 339
340 closedir(proc); 340 closedir(proc);
@@ -369,7 +369,7 @@ static int find_symbol_cb(void *arg, const char *name, char type,
369 return 1; 369 return 1;
370} 370}
371 371
372int perf_event__synthesize_kernel_mmap(struct perf_event_ops *ops, 372int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
373 perf_event__handler_t process, 373 perf_event__handler_t process,
374 struct machine *machine, 374 struct machine *machine,
375 const char *symbol_name) 375 const char *symbol_name)
@@ -427,13 +427,13 @@ int perf_event__synthesize_kernel_mmap(struct perf_event_ops *ops,
427 event->mmap.len = map->end - event->mmap.start; 427 event->mmap.len = map->end - event->mmap.start;
428 event->mmap.pid = machine->pid; 428 event->mmap.pid = machine->pid;
429 429
430 err = process(ops, event, &synth_sample, machine); 430 err = process(tool, event, &synth_sample, machine);
431 free(event); 431 free(event);
432 432
433 return err; 433 return err;
434} 434}
435 435
436int perf_event__process_comm(struct perf_event_ops *ops __used, 436int perf_event__process_comm(struct perf_tool *tool __used,
437 union perf_event *event, 437 union perf_event *event,
438 struct perf_sample *sample __used, 438 struct perf_sample *sample __used,
439 struct machine *machine) 439 struct machine *machine)
@@ -450,7 +450,7 @@ int perf_event__process_comm(struct perf_event_ops *ops __used,
450 return 0; 450 return 0;
451} 451}
452 452
453int perf_event__process_lost(struct perf_event_ops *ops __used, 453int perf_event__process_lost(struct perf_tool *tool __used,
454 union perf_event *event, 454 union perf_event *event,
455 struct perf_sample *sample __used, 455 struct perf_sample *sample __used,
456 struct machine *machine __used) 456 struct machine *machine __used)
@@ -473,7 +473,7 @@ static void perf_event__set_kernel_mmap_len(union perf_event *event,
473 maps[MAP__FUNCTION]->end = ~0ULL; 473 maps[MAP__FUNCTION]->end = ~0ULL;
474} 474}
475 475
476static int perf_event__process_kernel_mmap(struct perf_event_ops *ops __used, 476static int perf_event__process_kernel_mmap(struct perf_tool *tool __used,
477 union perf_event *event, 477 union perf_event *event,
478 struct machine *machine) 478 struct machine *machine)
479{ 479{
@@ -566,7 +566,7 @@ out_problem:
566 return -1; 566 return -1;
567} 567}
568 568
569int perf_event__process_mmap(struct perf_event_ops *ops, 569int perf_event__process_mmap(struct perf_tool *tool,
570 union perf_event *event, 570 union perf_event *event,
571 struct perf_sample *sample __used, 571 struct perf_sample *sample __used,
572 struct machine *machine) 572 struct machine *machine)
@@ -582,7 +582,7 @@ int perf_event__process_mmap(struct perf_event_ops *ops,
582 582
583 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL || 583 if (cpumode == PERF_RECORD_MISC_GUEST_KERNEL ||
584 cpumode == PERF_RECORD_MISC_KERNEL) { 584 cpumode == PERF_RECORD_MISC_KERNEL) {
585 ret = perf_event__process_kernel_mmap(ops, event, machine); 585 ret = perf_event__process_kernel_mmap(tool, event, machine);
586 if (ret < 0) 586 if (ret < 0)
587 goto out_problem; 587 goto out_problem;
588 return 0; 588 return 0;
@@ -606,7 +606,7 @@ out_problem:
606 return 0; 606 return 0;
607} 607}
608 608
609int perf_event__process_task(struct perf_event_ops *ops __used, 609int perf_event__process_task(struct perf_tool *tool __used,
610 union perf_event *event, 610 union perf_event *event,
611 struct perf_sample *sample __used, 611 struct perf_sample *sample __used,
612 struct machine *machine) 612 struct machine *machine)
@@ -631,22 +631,22 @@ int perf_event__process_task(struct perf_event_ops *ops __used,
631 return 0; 631 return 0;
632} 632}
633 633
634int perf_event__process(struct perf_event_ops *ops, union perf_event *event, 634int perf_event__process(struct perf_tool *tool, union perf_event *event,
635 struct perf_sample *sample, struct machine *machine) 635 struct perf_sample *sample, struct machine *machine)
636{ 636{
637 switch (event->header.type) { 637 switch (event->header.type) {
638 case PERF_RECORD_COMM: 638 case PERF_RECORD_COMM:
639 perf_event__process_comm(ops, event, sample, machine); 639 perf_event__process_comm(tool, event, sample, machine);
640 break; 640 break;
641 case PERF_RECORD_MMAP: 641 case PERF_RECORD_MMAP:
642 perf_event__process_mmap(ops, event, sample, machine); 642 perf_event__process_mmap(tool, event, sample, machine);
643 break; 643 break;
644 case PERF_RECORD_FORK: 644 case PERF_RECORD_FORK:
645 case PERF_RECORD_EXIT: 645 case PERF_RECORD_EXIT:
646 perf_event__process_task(ops, event, sample, machine); 646 perf_event__process_task(tool, event, sample, machine);
647 break; 647 break;
648 case PERF_RECORD_LOST: 648 case PERF_RECORD_LOST:
649 perf_event__process_lost(ops, event, sample, machine); 649 perf_event__process_lost(tool, event, sample, machine);
650 default: 650 default:
651 break; 651 break;
652 } 652 }
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 1564877e870..d8499e7cf64 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -141,47 +141,47 @@ union perf_event {
141 141
142void perf_event__print_totals(void); 142void perf_event__print_totals(void);
143 143
144struct perf_event_ops; 144struct perf_tool;
145struct thread_map; 145struct thread_map;
146 146
147typedef int (*perf_event__handler_t)(struct perf_event_ops *ops, 147typedef int (*perf_event__handler_t)(struct perf_tool *tool,
148 union perf_event *event, 148 union perf_event *event,
149 struct perf_sample *sample, 149 struct perf_sample *sample,
150 struct machine *machine); 150 struct machine *machine);
151 151
152int perf_event__synthesize_thread_map(struct perf_event_ops *ops, 152int perf_event__synthesize_thread_map(struct perf_tool *tool,
153 struct thread_map *threads, 153 struct thread_map *threads,
154 perf_event__handler_t process, 154 perf_event__handler_t process,
155 struct machine *machine); 155 struct machine *machine);
156int perf_event__synthesize_threads(struct perf_event_ops *ops, 156int perf_event__synthesize_threads(struct perf_tool *tool,
157 perf_event__handler_t process, 157 perf_event__handler_t process,
158 struct machine *machine); 158 struct machine *machine);
159int perf_event__synthesize_kernel_mmap(struct perf_event_ops *ops, 159int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
160 perf_event__handler_t process, 160 perf_event__handler_t process,
161 struct machine *machine, 161 struct machine *machine,
162 const char *symbol_name); 162 const char *symbol_name);
163 163
164int perf_event__synthesize_modules(struct perf_event_ops *ops, 164int perf_event__synthesize_modules(struct perf_tool *tool,
165 perf_event__handler_t process, 165 perf_event__handler_t process,
166 struct machine *machine); 166 struct machine *machine);
167 167
168int perf_event__process_comm(struct perf_event_ops *ops, 168int perf_event__process_comm(struct perf_tool *tool,
169 union perf_event *event, 169 union perf_event *event,
170 struct perf_sample *sample, 170 struct perf_sample *sample,
171 struct machine *machine); 171 struct machine *machine);
172int perf_event__process_lost(struct perf_event_ops *ops, 172int perf_event__process_lost(struct perf_tool *tool,
173 union perf_event *event, 173 union perf_event *event,
174 struct perf_sample *sample, 174 struct perf_sample *sample,
175 struct machine *machine); 175 struct machine *machine);
176int perf_event__process_mmap(struct perf_event_ops *ops, 176int perf_event__process_mmap(struct perf_tool *tool,
177 union perf_event *event, 177 union perf_event *event,
178 struct perf_sample *sample, 178 struct perf_sample *sample,
179 struct machine *machine); 179 struct machine *machine);
180int perf_event__process_task(struct perf_event_ops *ops, 180int perf_event__process_task(struct perf_tool *tool,
181 union perf_event *event, 181 union perf_event *event,
182 struct perf_sample *sample, 182 struct perf_sample *sample,
183 struct machine *machine); 183 struct machine *machine);
184int perf_event__process(struct perf_event_ops *ops, 184int perf_event__process(struct perf_tool *tool,
185 union perf_event *event, 185 union perf_event *event,
186 struct perf_sample *sample, 186 struct perf_sample *sample,
187 struct machine *machine); 187 struct machine *machine);
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index db280d6ca89..9272f3a20ca 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -2070,7 +2070,7 @@ out_delete_evlist:
2070 return -ENOMEM; 2070 return -ENOMEM;
2071} 2071}
2072 2072
2073int perf_event__synthesize_attr(struct perf_event_ops *ops, 2073int perf_event__synthesize_attr(struct perf_tool *tool,
2074 struct perf_event_attr *attr, u16 ids, u64 *id, 2074 struct perf_event_attr *attr, u16 ids, u64 *id,
2075 perf_event__handler_t process) 2075 perf_event__handler_t process)
2076{ 2076{
@@ -2094,14 +2094,14 @@ int perf_event__synthesize_attr(struct perf_event_ops *ops,
2094 ev->attr.header.type = PERF_RECORD_HEADER_ATTR; 2094 ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
2095 ev->attr.header.size = size; 2095 ev->attr.header.size = size;
2096 2096
2097 err = process(ops, ev, NULL, NULL); 2097 err = process(tool, ev, NULL, NULL);
2098 2098
2099 free(ev); 2099 free(ev);
2100 2100
2101 return err; 2101 return err;
2102} 2102}
2103 2103
2104int perf_event__synthesize_attrs(struct perf_event_ops *ops, 2104int perf_event__synthesize_attrs(struct perf_tool *tool,
2105 struct perf_session *session, 2105 struct perf_session *session,
2106 perf_event__handler_t process) 2106 perf_event__handler_t process)
2107{ 2107{
@@ -2109,7 +2109,7 @@ int perf_event__synthesize_attrs(struct perf_event_ops *ops,
2109 int err = 0; 2109 int err = 0;
2110 2110
2111 list_for_each_entry(attr, &session->evlist->entries, node) { 2111 list_for_each_entry(attr, &session->evlist->entries, node) {
2112 err = perf_event__synthesize_attr(ops, &attr->attr, attr->ids, 2112 err = perf_event__synthesize_attr(tool, &attr->attr, attr->ids,
2113 attr->id, process); 2113 attr->id, process);
2114 if (err) { 2114 if (err) {
2115 pr_debug("failed to create perf header attribute\n"); 2115 pr_debug("failed to create perf header attribute\n");
@@ -2157,7 +2157,7 @@ int perf_event__process_attr(union perf_event *event,
2157 return 0; 2157 return 0;
2158} 2158}
2159 2159
2160int perf_event__synthesize_event_type(struct perf_event_ops *ops, 2160int perf_event__synthesize_event_type(struct perf_tool *tool,
2161 u64 event_id, char *name, 2161 u64 event_id, char *name,
2162 perf_event__handler_t process, 2162 perf_event__handler_t process,
2163 struct machine *machine) 2163 struct machine *machine)
@@ -2178,12 +2178,12 @@ int perf_event__synthesize_event_type(struct perf_event_ops *ops,
2178 ev.event_type.header.size = sizeof(ev.event_type) - 2178 ev.event_type.header.size = sizeof(ev.event_type) -
2179 (sizeof(ev.event_type.event_type.name) - size); 2179 (sizeof(ev.event_type.event_type.name) - size);
2180 2180
2181 err = process(ops, &ev, NULL, machine); 2181 err = process(tool, &ev, NULL, machine);
2182 2182
2183 return err; 2183 return err;
2184} 2184}
2185 2185
2186int perf_event__synthesize_event_types(struct perf_event_ops *ops, 2186int perf_event__synthesize_event_types(struct perf_tool *tool,
2187 perf_event__handler_t process, 2187 perf_event__handler_t process,
2188 struct machine *machine) 2188 struct machine *machine)
2189{ 2189{
@@ -2193,7 +2193,7 @@ int perf_event__synthesize_event_types(struct perf_event_ops *ops,
2193 for (i = 0; i < event_count; i++) { 2193 for (i = 0; i < event_count; i++) {
2194 type = &events[i]; 2194 type = &events[i];
2195 2195
2196 err = perf_event__synthesize_event_type(ops, type->event_id, 2196 err = perf_event__synthesize_event_type(tool, type->event_id,
2197 type->name, process, 2197 type->name, process,
2198 machine); 2198 machine);
2199 if (err) { 2199 if (err) {
@@ -2205,7 +2205,7 @@ int perf_event__synthesize_event_types(struct perf_event_ops *ops,
2205 return err; 2205 return err;
2206} 2206}
2207 2207
2208int perf_event__process_event_type(struct perf_event_ops *ops __unused, 2208int perf_event__process_event_type(struct perf_tool *tool __unused,
2209 union perf_event *event) 2209 union perf_event *event)
2210{ 2210{
2211 if (perf_header__push_event(event->event_type.event_type.event_id, 2211 if (perf_header__push_event(event->event_type.event_type.event_id,
@@ -2215,7 +2215,7 @@ int perf_event__process_event_type(struct perf_event_ops *ops __unused,
2215 return 0; 2215 return 0;
2216} 2216}
2217 2217
2218int perf_event__synthesize_tracing_data(struct perf_event_ops *ops, int fd, 2218int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
2219 struct perf_evlist *evlist, 2219 struct perf_evlist *evlist,
2220 perf_event__handler_t process) 2220 perf_event__handler_t process)
2221{ 2221{
@@ -2248,7 +2248,7 @@ int perf_event__synthesize_tracing_data(struct perf_event_ops *ops, int fd,
2248 ev.tracing_data.header.size = sizeof(ev.tracing_data); 2248 ev.tracing_data.header.size = sizeof(ev.tracing_data);
2249 ev.tracing_data.size = aligned_size; 2249 ev.tracing_data.size = aligned_size;
2250 2250
2251 process(ops, &ev, NULL, NULL); 2251 process(tool, &ev, NULL, NULL);
2252 2252
2253 /* 2253 /*
2254 * The put function will copy all the tracing data 2254 * The put function will copy all the tracing data
@@ -2290,7 +2290,7 @@ int perf_event__process_tracing_data(union perf_event *event,
2290 return size_read + padding; 2290 return size_read + padding;
2291} 2291}
2292 2292
2293int perf_event__synthesize_build_id(struct perf_event_ops *ops, 2293int perf_event__synthesize_build_id(struct perf_tool *tool,
2294 struct dso *pos, u16 misc, 2294 struct dso *pos, u16 misc,
2295 perf_event__handler_t process, 2295 perf_event__handler_t process,
2296 struct machine *machine) 2296 struct machine *machine)
@@ -2313,12 +2313,12 @@ int perf_event__synthesize_build_id(struct perf_event_ops *ops,
2313 ev.build_id.header.size = sizeof(ev.build_id) + len; 2313 ev.build_id.header.size = sizeof(ev.build_id) + len;
2314 memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len); 2314 memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
2315 2315
2316 err = process(ops, &ev, NULL, machine); 2316 err = process(tool, &ev, NULL, machine);
2317 2317
2318 return err; 2318 return err;
2319} 2319}
2320 2320
2321int perf_event__process_build_id(struct perf_event_ops *ops __used, 2321int perf_event__process_build_id(struct perf_tool *tool __used,
2322 union perf_event *event, 2322 union perf_event *event,
2323 struct perf_session *session) 2323 struct perf_session *session)
2324{ 2324{
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index a604962fc43..09365b32098 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -97,35 +97,35 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
97 const char *name, bool is_kallsyms); 97 const char *name, bool is_kallsyms);
98int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir); 98int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
99 99
100int perf_event__synthesize_attr(struct perf_event_ops *ops, 100int perf_event__synthesize_attr(struct perf_tool *tool,
101 struct perf_event_attr *attr, u16 ids, u64 *id, 101 struct perf_event_attr *attr, u16 ids, u64 *id,
102 perf_event__handler_t process); 102 perf_event__handler_t process);
103int perf_event__synthesize_attrs(struct perf_event_ops *ops, 103int perf_event__synthesize_attrs(struct perf_tool *tool,
104 struct perf_session *session, 104 struct perf_session *session,
105 perf_event__handler_t process); 105 perf_event__handler_t process);
106int perf_event__process_attr(union perf_event *event, struct perf_evlist **pevlist); 106int perf_event__process_attr(union perf_event *event, struct perf_evlist **pevlist);
107 107
108int perf_event__synthesize_event_type(struct perf_event_ops *ops, 108int perf_event__synthesize_event_type(struct perf_tool *tool,
109 u64 event_id, char *name, 109 u64 event_id, char *name,
110 perf_event__handler_t process, 110 perf_event__handler_t process,
111 struct machine *machine); 111 struct machine *machine);
112int perf_event__synthesize_event_types(struct perf_event_ops *ops, 112int perf_event__synthesize_event_types(struct perf_tool *tool,
113 perf_event__handler_t process, 113 perf_event__handler_t process,
114 struct machine *machine); 114 struct machine *machine);
115int perf_event__process_event_type(struct perf_event_ops *ops, 115int perf_event__process_event_type(struct perf_tool *tool,
116 union perf_event *event); 116 union perf_event *event);
117 117
118int perf_event__synthesize_tracing_data(struct perf_event_ops *ops, 118int perf_event__synthesize_tracing_data(struct perf_tool *tool,
119 int fd, struct perf_evlist *evlist, 119 int fd, struct perf_evlist *evlist,
120 perf_event__handler_t process); 120 perf_event__handler_t process);
121int perf_event__process_tracing_data(union perf_event *event, 121int perf_event__process_tracing_data(union perf_event *event,
122 struct perf_session *session); 122 struct perf_session *session);
123 123
124int perf_event__synthesize_build_id(struct perf_event_ops *ops, 124int perf_event__synthesize_build_id(struct perf_tool *tool,
125 struct dso *pos, u16 misc, 125 struct dso *pos, u16 misc,
126 perf_event__handler_t process, 126 perf_event__handler_t process,
127 struct machine *machine); 127 struct machine *machine);
128int perf_event__process_build_id(struct perf_event_ops *ops, 128int perf_event__process_build_id(struct perf_tool *tool,
129 union perf_event *event, 129 union perf_event *event,
130 struct perf_session *session); 130 struct perf_session *session);
131 131
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index be33606386b..7d159088c4a 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -10,6 +10,7 @@
10#include "evlist.h" 10#include "evlist.h"
11#include "evsel.h" 11#include "evsel.h"
12#include "session.h" 12#include "session.h"
13#include "tool.h"
13#include "sort.h" 14#include "sort.h"
14#include "util.h" 15#include "util.h"
15#include "cpumap.h" 16#include "cpumap.h"
@@ -104,7 +105,7 @@ static void perf_session__destroy_kernel_maps(struct perf_session *self)
104 105
105struct perf_session *perf_session__new(const char *filename, int mode, 106struct perf_session *perf_session__new(const char *filename, int mode,
106 bool force, bool repipe, 107 bool force, bool repipe,
107 struct perf_event_ops *ops) 108 struct perf_tool *tool)
108{ 109{
109 size_t len = filename ? strlen(filename) + 1 : 0; 110 size_t len = filename ? strlen(filename) + 1 : 0;
110 struct perf_session *self = zalloc(sizeof(*self) + len); 111 struct perf_session *self = zalloc(sizeof(*self) + len);
@@ -142,10 +143,10 @@ struct perf_session *perf_session__new(const char *filename, int mode,
142 goto out_delete; 143 goto out_delete;
143 } 144 }
144 145
145 if (ops && ops->ordering_requires_timestamps && 146 if (tool && tool->ordering_requires_timestamps &&
146 ops->ordered_samples && !self->sample_id_all) { 147 tool->ordered_samples && !self->sample_id_all) {
147 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n"); 148 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
148 ops->ordered_samples = false; 149 tool->ordered_samples = false;
149 } 150 }
150 151
151out: 152out:
@@ -285,7 +286,7 @@ static int process_event_synth_attr_stub(union perf_event *event __used,
285 return 0; 286 return 0;
286} 287}
287 288
288static int process_event_sample_stub(struct perf_event_ops *ops __used, 289static int process_event_sample_stub(struct perf_tool *tool __used,
289 union perf_event *event __used, 290 union perf_event *event __used,
290 struct perf_sample *sample __used, 291 struct perf_sample *sample __used,
291 struct perf_evsel *evsel __used, 292 struct perf_evsel *evsel __used,
@@ -295,7 +296,7 @@ static int process_event_sample_stub(struct perf_event_ops *ops __used,
295 return 0; 296 return 0;
296} 297}
297 298
298static int process_event_stub(struct perf_event_ops *ops __used, 299static int process_event_stub(struct perf_tool *tool __used,
299 union perf_event *event __used, 300 union perf_event *event __used,
300 struct perf_sample *sample __used, 301 struct perf_sample *sample __used,
301 struct machine *machine __used) 302 struct machine *machine __used)
@@ -304,7 +305,7 @@ static int process_event_stub(struct perf_event_ops *ops __used,
304 return 0; 305 return 0;
305} 306}
306 307
307static int process_finished_round_stub(struct perf_event_ops *ops __used, 308static int process_finished_round_stub(struct perf_tool *tool __used,
308 union perf_event *event __used, 309 union perf_event *event __used,
309 struct perf_session *perf_session __used) 310 struct perf_session *perf_session __used)
310{ 311{
@@ -312,50 +313,50 @@ static int process_finished_round_stub(struct perf_event_ops *ops __used,
312 return 0; 313 return 0;
313} 314}
314 315
315static int process_event_type_stub(struct perf_event_ops *ops __used, 316static int process_event_type_stub(struct perf_tool *tool __used,
316 union perf_event *event __used) 317 union perf_event *event __used)
317{ 318{
318 dump_printf(": unhandled!\n"); 319 dump_printf(": unhandled!\n");
319 return 0; 320 return 0;
320} 321}
321 322
322static int process_finished_round(struct perf_event_ops *ops, 323static int process_finished_round(struct perf_tool *tool,
323 union perf_event *event, 324 union perf_event *event,
324 struct perf_session *session); 325 struct perf_session *session);
325 326
326static void perf_event_ops__fill_defaults(struct perf_event_ops *handler) 327static void perf_tool__fill_defaults(struct perf_tool *tool)
327{ 328{
328 if (handler->sample == NULL) 329 if (tool->sample == NULL)
329 handler->sample = process_event_sample_stub; 330 tool->sample = process_event_sample_stub;
330 if (handler->mmap == NULL) 331 if (tool->mmap == NULL)
331 handler->mmap = process_event_stub; 332 tool->mmap = process_event_stub;
332 if (handler->comm == NULL) 333 if (tool->comm == NULL)
333 handler->comm = process_event_stub; 334 tool->comm = process_event_stub;
334 if (handler->fork == NULL) 335 if (tool->fork == NULL)
335 handler->fork = process_event_stub; 336 tool->fork = process_event_stub;
336 if (handler->exit == NULL) 337 if (tool->exit == NULL)
337 handler->exit = process_event_stub; 338 tool->exit = process_event_stub;
338 if (handler->lost == NULL) 339 if (tool->lost == NULL)
339 handler->lost = perf_event__process_lost; 340 tool->lost = perf_event__process_lost;
340 if (handler->read == NULL) 341 if (tool->read == NULL)
341 handler->read = process_event_sample_stub; 342 tool->read = process_event_sample_stub;
342 if (handler->throttle == NULL) 343 if (tool->throttle == NULL)
343 handler->throttle = process_event_stub; 344 tool->throttle = process_event_stub;
344 if (handler->unthrottle == NULL) 345 if (tool->unthrottle == NULL)
345 handler->unthrottle = process_event_stub; 346 tool->unthrottle = process_event_stub;
346 if (handler->attr == NULL) 347 if (tool->attr == NULL)
347 handler->attr = process_event_synth_attr_stub; 348 tool->attr = process_event_synth_attr_stub;
348 if (handler->event_type == NULL) 349 if (tool->event_type == NULL)
349 handler->event_type = process_event_type_stub; 350 tool->event_type = process_event_type_stub;
350 if (handler->tracing_data == NULL) 351 if (tool->tracing_data == NULL)
351 handler->tracing_data = process_event_synth_tracing_data_stub; 352 tool->tracing_data = process_event_synth_tracing_data_stub;
352 if (handler->build_id == NULL) 353 if (tool->build_id == NULL)
353 handler->build_id = process_finished_round_stub; 354 tool->build_id = process_finished_round_stub;
354 if (handler->finished_round == NULL) { 355 if (tool->finished_round == NULL) {
355 if (handler->ordered_samples) 356 if (tool->ordered_samples)
356 handler->finished_round = process_finished_round; 357 tool->finished_round = process_finished_round;
357 else 358 else
358 handler->finished_round = process_finished_round_stub; 359 tool->finished_round = process_finished_round_stub;
359 } 360 }
360} 361}
361 362
@@ -487,11 +488,11 @@ static void perf_session_free_sample_buffers(struct perf_session *session)
487static int perf_session_deliver_event(struct perf_session *session, 488static int perf_session_deliver_event(struct perf_session *session,
488 union perf_event *event, 489 union perf_event *event,
489 struct perf_sample *sample, 490 struct perf_sample *sample,
490 struct perf_event_ops *ops, 491 struct perf_tool *tool,
491 u64 file_offset); 492 u64 file_offset);
492 493
493static void flush_sample_queue(struct perf_session *s, 494static void flush_sample_queue(struct perf_session *s,
494 struct perf_event_ops *ops) 495 struct perf_tool *tool)
495{ 496{
496 struct ordered_samples *os = &s->ordered_samples; 497 struct ordered_samples *os = &s->ordered_samples;
497 struct list_head *head = &os->samples; 498 struct list_head *head = &os->samples;
@@ -502,7 +503,7 @@ static void flush_sample_queue(struct perf_session *s,
502 unsigned idx = 0, progress_next = os->nr_samples / 16; 503 unsigned idx = 0, progress_next = os->nr_samples / 16;
503 int ret; 504 int ret;
504 505
505 if (!ops->ordered_samples || !limit) 506 if (!tool->ordered_samples || !limit)
506 return; 507 return;
507 508
508 list_for_each_entry_safe(iter, tmp, head, list) { 509 list_for_each_entry_safe(iter, tmp, head, list) {
@@ -513,7 +514,7 @@ static void flush_sample_queue(struct perf_session *s,
513 if (ret) 514 if (ret)
514 pr_err("Can't parse sample, err = %d\n", ret); 515 pr_err("Can't parse sample, err = %d\n", ret);
515 else 516 else
516 perf_session_deliver_event(s, iter->event, &sample, ops, 517 perf_session_deliver_event(s, iter->event, &sample, tool,
517 iter->file_offset); 518 iter->file_offset);
518 519
519 os->last_flush = iter->timestamp; 520 os->last_flush = iter->timestamp;
@@ -575,11 +576,11 @@ static void flush_sample_queue(struct perf_session *s,
575 * Flush every events below timestamp 7 576 * Flush every events below timestamp 7
576 * etc... 577 * etc...
577 */ 578 */
578static int process_finished_round(struct perf_event_ops *ops, 579static int process_finished_round(struct perf_tool *tool,
579 union perf_event *event __used, 580 union perf_event *event __used,
580 struct perf_session *session) 581 struct perf_session *session)
581{ 582{
582 flush_sample_queue(session, ops); 583 flush_sample_queue(session, tool);
583 session->ordered_samples.next_flush = session->ordered_samples.max_timestamp; 584 session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
584 585
585 return 0; 586 return 0;
@@ -749,7 +750,7 @@ static struct machine *
749static int perf_session_deliver_event(struct perf_session *session, 750static int perf_session_deliver_event(struct perf_session *session,
750 union perf_event *event, 751 union perf_event *event,
751 struct perf_sample *sample, 752 struct perf_sample *sample,
752 struct perf_event_ops *ops, 753 struct perf_tool *tool,
753 u64 file_offset) 754 u64 file_offset)
754{ 755{
755 struct perf_evsel *evsel; 756 struct perf_evsel *evsel;
@@ -784,25 +785,25 @@ static int perf_session_deliver_event(struct perf_session *session,
784 ++session->hists.stats.nr_unknown_id; 785 ++session->hists.stats.nr_unknown_id;
785 return -1; 786 return -1;
786 } 787 }
787 return ops->sample(ops, event, sample, evsel, machine); 788 return tool->sample(tool, event, sample, evsel, machine);
788 case PERF_RECORD_MMAP: 789 case PERF_RECORD_MMAP:
789 return ops->mmap(ops, event, sample, machine); 790 return tool->mmap(tool, event, sample, machine);
790 case PERF_RECORD_COMM: 791 case PERF_RECORD_COMM:
791 return ops->comm(ops, event, sample, machine); 792 return tool->comm(tool, event, sample, machine);
792 case PERF_RECORD_FORK: 793 case PERF_RECORD_FORK:
793 return ops->fork(ops, event, sample, machine); 794 return tool->fork(tool, event, sample, machine);
794 case PERF_RECORD_EXIT: 795 case PERF_RECORD_EXIT:
795 return ops->exit(ops, event, sample, machine); 796 return tool->exit(tool, event, sample, machine);
796 case PERF_RECORD_LOST: 797 case PERF_RECORD_LOST:
797 if (ops->lost == perf_event__process_lost) 798 if (tool->lost == perf_event__process_lost)
798 session->hists.stats.total_lost += event->lost.lost; 799 session->hists.stats.total_lost += event->lost.lost;
799 return ops->lost(ops, event, sample, machine); 800 return tool->lost(tool, event, sample, machine);
800 case PERF_RECORD_READ: 801 case PERF_RECORD_READ:
801 return ops->read(ops, event, sample, evsel, machine); 802 return tool->read(tool, event, sample, evsel, machine);
802 case PERF_RECORD_THROTTLE: 803 case PERF_RECORD_THROTTLE:
803 return ops->throttle(ops, event, sample, machine); 804 return tool->throttle(tool, event, sample, machine);
804 case PERF_RECORD_UNTHROTTLE: 805 case PERF_RECORD_UNTHROTTLE:
805 return ops->unthrottle(ops, event, sample, machine); 806 return tool->unthrottle(tool, event, sample, machine);
806 default: 807 default:
807 ++session->hists.stats.nr_unknown_events; 808 ++session->hists.stats.nr_unknown_events;
808 return -1; 809 return -1;
@@ -826,7 +827,7 @@ static int perf_session__preprocess_sample(struct perf_session *session,
826} 827}
827 828
828static int perf_session__process_user_event(struct perf_session *session, union perf_event *event, 829static int perf_session__process_user_event(struct perf_session *session, union perf_event *event,
829 struct perf_event_ops *ops, u64 file_offset) 830 struct perf_tool *tool, u64 file_offset)
830{ 831{
831 int err; 832 int err;
832 833
@@ -835,20 +836,20 @@ static int perf_session__process_user_event(struct perf_session *session, union
835 /* These events are processed right away */ 836 /* These events are processed right away */
836 switch (event->header.type) { 837 switch (event->header.type) {
837 case PERF_RECORD_HEADER_ATTR: 838 case PERF_RECORD_HEADER_ATTR:
838 err = ops->attr(event, &session->evlist); 839 err = tool->attr(event, &session->evlist);
839 if (err == 0) 840 if (err == 0)
840 perf_session__update_sample_type(session); 841 perf_session__update_sample_type(session);
841 return err; 842 return err;
842 case PERF_RECORD_HEADER_EVENT_TYPE: 843 case PERF_RECORD_HEADER_EVENT_TYPE:
843 return ops->event_type(ops, event); 844 return tool->event_type(tool, event);
844 case PERF_RECORD_HEADER_TRACING_DATA: 845 case PERF_RECORD_HEADER_TRACING_DATA:
845 /* setup for reading amidst mmap */ 846 /* setup for reading amidst mmap */
846 lseek(session->fd, file_offset, SEEK_SET); 847 lseek(session->fd, file_offset, SEEK_SET);
847 return ops->tracing_data(event, session); 848 return tool->tracing_data(event, session);
848 case PERF_RECORD_HEADER_BUILD_ID: 849 case PERF_RECORD_HEADER_BUILD_ID:
849 return ops->build_id(ops, event, session); 850 return tool->build_id(tool, event, session);
850 case PERF_RECORD_FINISHED_ROUND: 851 case PERF_RECORD_FINISHED_ROUND:
851 return ops->finished_round(ops, event, session); 852 return tool->finished_round(tool, event, session);
852 default: 853 default:
853 return -EINVAL; 854 return -EINVAL;
854 } 855 }
@@ -856,7 +857,7 @@ static int perf_session__process_user_event(struct perf_session *session, union
856 857
857static int perf_session__process_event(struct perf_session *session, 858static int perf_session__process_event(struct perf_session *session,
858 union perf_event *event, 859 union perf_event *event,
859 struct perf_event_ops *ops, 860 struct perf_tool *tool,
860 u64 file_offset) 861 u64 file_offset)
861{ 862{
862 struct perf_sample sample; 863 struct perf_sample sample;
@@ -872,7 +873,7 @@ static int perf_session__process_event(struct perf_session *session,
872 hists__inc_nr_events(&session->hists, event->header.type); 873 hists__inc_nr_events(&session->hists, event->header.type);
873 874
874 if (event->header.type >= PERF_RECORD_USER_TYPE_START) 875 if (event->header.type >= PERF_RECORD_USER_TYPE_START)
875 return perf_session__process_user_event(session, event, ops, file_offset); 876 return perf_session__process_user_event(session, event, tool, file_offset);
876 877
877 /* 878 /*
878 * For all kernel events we get the sample data 879 * For all kernel events we get the sample data
@@ -885,14 +886,14 @@ static int perf_session__process_event(struct perf_session *session,
885 if (perf_session__preprocess_sample(session, event, &sample)) 886 if (perf_session__preprocess_sample(session, event, &sample))
886 return 0; 887 return 0;
887 888
888 if (ops->ordered_samples) { 889 if (tool->ordered_samples) {
889 ret = perf_session_queue_event(session, event, &sample, 890 ret = perf_session_queue_event(session, event, &sample,
890 file_offset); 891 file_offset);
891 if (ret != -ETIME) 892 if (ret != -ETIME)
892 return ret; 893 return ret;
893 } 894 }
894 895
895 return perf_session_deliver_event(session, event, &sample, ops, 896 return perf_session_deliver_event(session, event, &sample, tool,
896 file_offset); 897 file_offset);
897} 898}
898 899
@@ -921,9 +922,9 @@ static struct thread *perf_session__register_idle_thread(struct perf_session *se
921} 922}
922 923
923static void perf_session__warn_about_errors(const struct perf_session *session, 924static void perf_session__warn_about_errors(const struct perf_session *session,
924 const struct perf_event_ops *ops) 925 const struct perf_tool *tool)
925{ 926{
926 if (ops->lost == perf_event__process_lost && 927 if (tool->lost == perf_event__process_lost &&
927 session->hists.stats.nr_events[PERF_RECORD_LOST] != 0) { 928 session->hists.stats.nr_events[PERF_RECORD_LOST] != 0) {
928 ui__warning("Processed %d events and lost %d chunks!\n\n" 929 ui__warning("Processed %d events and lost %d chunks!\n\n"
929 "Check IO/CPU overload!\n\n", 930 "Check IO/CPU overload!\n\n",
@@ -958,7 +959,7 @@ static void perf_session__warn_about_errors(const struct perf_session *session,
958volatile int session_done; 959volatile int session_done;
959 960
960static int __perf_session__process_pipe_events(struct perf_session *self, 961static int __perf_session__process_pipe_events(struct perf_session *self,
961 struct perf_event_ops *ops) 962 struct perf_tool *tool)
962{ 963{
963 union perf_event event; 964 union perf_event event;
964 uint32_t size; 965 uint32_t size;
@@ -967,7 +968,7 @@ static int __perf_session__process_pipe_events(struct perf_session *self,
967 int err; 968 int err;
968 void *p; 969 void *p;
969 970
970 perf_event_ops__fill_defaults(ops); 971 perf_tool__fill_defaults(tool);
971 972
972 head = 0; 973 head = 0;
973more: 974more:
@@ -1004,7 +1005,7 @@ more:
1004 } 1005 }
1005 1006
1006 if (size == 0 || 1007 if (size == 0 ||
1007 (skip = perf_session__process_event(self, &event, ops, head)) < 0) { 1008 (skip = perf_session__process_event(self, &event, tool, head)) < 0) {
1008 dump_printf("%#" PRIx64 " [%#x]: skipping unknown header type: %d\n", 1009 dump_printf("%#" PRIx64 " [%#x]: skipping unknown header type: %d\n",
1009 head, event.header.size, event.header.type); 1010 head, event.header.size, event.header.type);
1010 /* 1011 /*
@@ -1027,7 +1028,7 @@ more:
1027done: 1028done:
1028 err = 0; 1029 err = 0;
1029out_err: 1030out_err:
1030 perf_session__warn_about_errors(self, ops); 1031 perf_session__warn_about_errors(self, tool);
1031 perf_session_free_sample_buffers(self); 1032 perf_session_free_sample_buffers(self);
1032 return err; 1033 return err;
1033} 1034}
@@ -1058,7 +1059,7 @@ fetch_mmaped_event(struct perf_session *session,
1058 1059
1059int __perf_session__process_events(struct perf_session *session, 1060int __perf_session__process_events(struct perf_session *session,
1060 u64 data_offset, u64 data_size, 1061 u64 data_offset, u64 data_size,
1061 u64 file_size, struct perf_event_ops *ops) 1062 u64 file_size, struct perf_tool *tool)
1062{ 1063{
1063 u64 head, page_offset, file_offset, file_pos, progress_next; 1064 u64 head, page_offset, file_offset, file_pos, progress_next;
1064 int err, mmap_prot, mmap_flags, map_idx = 0; 1065 int err, mmap_prot, mmap_flags, map_idx = 0;
@@ -1067,7 +1068,7 @@ int __perf_session__process_events(struct perf_session *session,
1067 union perf_event *event; 1068 union perf_event *event;
1068 uint32_t size; 1069 uint32_t size;
1069 1070
1070 perf_event_ops__fill_defaults(ops); 1071 perf_tool__fill_defaults(tool);
1071 1072
1072 page_size = sysconf(_SC_PAGESIZE); 1073 page_size = sysconf(_SC_PAGESIZE);
1073 1074
@@ -1122,7 +1123,7 @@ more:
1122 size = event->header.size; 1123 size = event->header.size;
1123 1124
1124 if (size == 0 || 1125 if (size == 0 ||
1125 perf_session__process_event(session, event, ops, file_pos) < 0) { 1126 perf_session__process_event(session, event, tool, file_pos) < 0) {
1126 dump_printf("%#" PRIx64 " [%#x]: skipping unknown header type: %d\n", 1127 dump_printf("%#" PRIx64 " [%#x]: skipping unknown header type: %d\n",
1127 file_offset + head, event->header.size, 1128 file_offset + head, event->header.size,
1128 event->header.type); 1129 event->header.type);
@@ -1151,15 +1152,15 @@ more:
1151 err = 0; 1152 err = 0;
1152 /* do the final flush for ordered samples */ 1153 /* do the final flush for ordered samples */
1153 session->ordered_samples.next_flush = ULLONG_MAX; 1154 session->ordered_samples.next_flush = ULLONG_MAX;
1154 flush_sample_queue(session, ops); 1155 flush_sample_queue(session, tool);
1155out_err: 1156out_err:
1156 perf_session__warn_about_errors(session, ops); 1157 perf_session__warn_about_errors(session, tool);
1157 perf_session_free_sample_buffers(session); 1158 perf_session_free_sample_buffers(session);
1158 return err; 1159 return err;
1159} 1160}
1160 1161
1161int perf_session__process_events(struct perf_session *self, 1162int perf_session__process_events(struct perf_session *self,
1162 struct perf_event_ops *ops) 1163 struct perf_tool *tool)
1163{ 1164{
1164 int err; 1165 int err;
1165 1166
@@ -1170,9 +1171,9 @@ int perf_session__process_events(struct perf_session *self,
1170 err = __perf_session__process_events(self, 1171 err = __perf_session__process_events(self,
1171 self->header.data_offset, 1172 self->header.data_offset,
1172 self->header.data_size, 1173 self->header.data_size,
1173 self->size, ops); 1174 self->size, tool);
1174 else 1175 else
1175 err = __perf_session__process_pipe_events(self, ops); 1176 err = __perf_session__process_pipe_events(self, tool);
1176 1177
1177 return err; 1178 return err;
1178} 1179}
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 1c5823c7d6d..30e9c6b6fc3 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -53,55 +53,20 @@ struct perf_session {
53 char filename[0]; 53 char filename[0];
54}; 54};
55 55
56struct perf_evsel; 56struct perf_tool;
57struct perf_event_ops;
58
59typedef int (*event_sample)(struct perf_event_ops *ops,
60 union perf_event *event, struct perf_sample *sample,
61 struct perf_evsel *evsel, struct machine *machine);
62typedef int (*event_op)(struct perf_event_ops *ops, union perf_event *event,
63 struct perf_sample *sample,
64 struct machine *machine);
65typedef int (*event_synth_op)(union perf_event *self,
66 struct perf_session *session);
67typedef int (*event_attr_op)(union perf_event *event,
68 struct perf_evlist **pevlist);
69typedef int (*event_simple_op)(struct perf_event_ops *ops,
70 union perf_event *event);
71typedef int (*event_op2)(struct perf_event_ops *ops, union perf_event *event,
72 struct perf_session *session);
73
74struct perf_event_ops {
75 event_sample sample,
76 read;
77 event_op mmap,
78 comm,
79 fork,
80 exit,
81 lost,
82 throttle,
83 unthrottle;
84 event_attr_op attr;
85 event_synth_op tracing_data;
86 event_simple_op event_type;
87 event_op2 finished_round,
88 build_id;
89 bool ordered_samples;
90 bool ordering_requires_timestamps;
91};
92 57
93struct perf_session *perf_session__new(const char *filename, int mode, 58struct perf_session *perf_session__new(const char *filename, int mode,
94 bool force, bool repipe, 59 bool force, bool repipe,
95 struct perf_event_ops *ops); 60 struct perf_tool *tool);
96void perf_session__delete(struct perf_session *self); 61void perf_session__delete(struct perf_session *self);
97 62
98void perf_event_header__bswap(struct perf_event_header *self); 63void perf_event_header__bswap(struct perf_event_header *self);
99 64
100int __perf_session__process_events(struct perf_session *self, 65int __perf_session__process_events(struct perf_session *self,
101 u64 data_offset, u64 data_size, u64 size, 66 u64 data_offset, u64 data_size, u64 size,
102 struct perf_event_ops *ops); 67 struct perf_tool *tool);
103int perf_session__process_events(struct perf_session *self, 68int perf_session__process_events(struct perf_session *self,
104 struct perf_event_ops *event_ops); 69 struct perf_tool *tool);
105 70
106int perf_session__resolve_callchain(struct perf_session *self, struct perf_evsel *evsel, 71int perf_session__resolve_callchain(struct perf_session *self, struct perf_evsel *evsel,
107 struct thread *thread, 72 struct thread *thread,
@@ -142,11 +107,11 @@ struct machine *perf_session__findnew_machine(struct perf_session *self, pid_t p
142 107
143static inline 108static inline
144void perf_session__process_machines(struct perf_session *self, 109void perf_session__process_machines(struct perf_session *self,
145 struct perf_event_ops *ops, 110 struct perf_tool *tool,
146 machine__process_t process) 111 machine__process_t process)
147{ 112{
148 process(&self->host_machine, ops); 113 process(&self->host_machine, tool);
149 return machines__process(&self->machines, process, ops); 114 return machines__process(&self->machines, process, tool);
150} 115}
151 116
152struct thread *perf_session__findnew(struct perf_session *self, pid_t pid); 117struct thread *perf_session__findnew(struct perf_session *self, pid_t pid);
diff --git a/tools/perf/util/tool.h b/tools/perf/util/tool.h
new file mode 100644
index 00000000000..89ff1b551a7
--- /dev/null
+++ b/tools/perf/util/tool.h
@@ -0,0 +1,45 @@
1#ifndef __PERF_TOOL_H
2#define __PERF_TOOL_H
3
4struct perf_session;
5struct perf_evsel;
6struct perf_tool;
7struct machine;
8
9typedef int (*event_sample)(struct perf_tool *tool, union perf_event *event,
10 struct perf_sample *sample,
11 struct perf_evsel *evsel, struct machine *machine);
12
13typedef int (*event_op)(struct perf_tool *tool, union perf_event *event,
14 struct perf_sample *sample, struct machine *machine);
15
16typedef int (*event_attr_op)(union perf_event *event,
17 struct perf_evlist **pevlist);
18typedef int (*event_simple_op)(struct perf_tool *tool, union perf_event *event);
19
20typedef int (*event_synth_op)(union perf_event *event,
21 struct perf_session *session);
22
23typedef int (*event_op2)(struct perf_tool *tool, union perf_event *event,
24 struct perf_session *session);
25
26struct perf_tool {
27 event_sample sample,
28 read;
29 event_op mmap,
30 comm,
31 fork,
32 exit,
33 lost,
34 throttle,
35 unthrottle;
36 event_attr_op attr;
37 event_synth_op tracing_data;
38 event_simple_op event_type;
39 event_op2 finished_round,
40 build_id;
41 bool ordered_samples;
42 bool ordering_requires_timestamps;
43};
44
45#endif /* __PERF_TOOL_H */
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index 44eda6fc6b3..40430ec5c26 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -1,16 +1,17 @@
1#ifndef __PERF_TOP_H 1#ifndef __PERF_TOP_H
2#define __PERF_TOP_H 1 2#define __PERF_TOP_H 1
3 3
4#include "tool.h"
4#include "types.h" 5#include "types.h"
5#include "session.h"
6#include "../perf.h"
7#include <stddef.h> 6#include <stddef.h>
7#include <stdbool.h>
8 8
9struct perf_evlist; 9struct perf_evlist;
10struct perf_evsel; 10struct perf_evsel;
11struct perf_session;
11 12
12struct perf_top { 13struct perf_top {
13 struct perf_event_ops ops; 14 struct perf_tool tool;
14 struct perf_evlist *evlist; 15 struct perf_evlist *evlist;
15 /* 16 /*
16 * Symbols will be added here in perf_event__process_sample and will 17 * Symbols will be added here in perf_event__process_sample and will
generated by cgit v1.2.2 (git 2.25.0) at 2024-10-24 02:21:22 -0400