aboutsummaryrefslogtreecommitdiffstats
path: root/tools
diff options
context:
space:
mode:
authorIngo Molnar <mingo@elte.hu>2011-03-11 03:28:31 -0500
committerIngo Molnar <mingo@elte.hu>2011-03-11 03:28:31 -0500
commit137ee20ddd10fdc20600c389fe63edab0c39cb1a (patch)
treef2f9db93cbbe1929d2c3380658a546a748181dc9 /tools
parent4a0b1665db09cf2da9ad7d0f12da386373c10bfa (diff)
parent1c0b04d10bbe35279c50e3b36cf5b8ec2a0050d8 (diff)
Merge branch 'perf/core' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux-2.6 into perf/core
Diffstat (limited to 'tools')
-rw-r--r--tools/perf/builtin-record.c101
-rw-r--r--tools/perf/builtin-report.c4
-rw-r--r--tools/perf/builtin-top.c5
-rw-r--r--tools/perf/util/evlist.c26
-rw-r--r--tools/perf/util/evlist.h4
-rw-r--r--tools/perf/util/evsel.c21
-rw-r--r--tools/perf/util/evsel.h9
-rw-r--r--tools/perf/util/header.c422
-rw-r--r--tools/perf/util/header.h48
-rw-r--r--tools/perf/util/session.c74
-rw-r--r--tools/perf/util/session.h2
-rw-r--r--tools/perf/util/top.c48
12 files changed, 317 insertions, 447 deletions
diff --git a/tools/perf/builtin-record.c b/tools/perf/builtin-record.c
index d40a81e8cc56..6febcc168a8c 100644
--- a/tools/perf/builtin-record.c
+++ b/tools/perf/builtin-record.c
@@ -31,7 +31,6 @@
31#include <sys/mman.h> 31#include <sys/mman.h>
32 32
33#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y)) 33#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
34#define SID(e, x, y) xyarray__entry(e->id, x, y)
35 34
36enum write_mode_t { 35enum write_mode_t {
37 WRITE_FORCE, 36 WRITE_FORCE,
@@ -40,7 +39,6 @@ enum write_mode_t {
40 39
41static u64 user_interval = ULLONG_MAX; 40static u64 user_interval = ULLONG_MAX;
42static u64 default_interval = 0; 41static u64 default_interval = 0;
43static u64 sample_type;
44 42
45static unsigned int page_size; 43static unsigned int page_size;
46static unsigned int mmap_pages = 128; 44static unsigned int mmap_pages = 128;
@@ -160,54 +158,6 @@ static void sig_atexit(void)
160 kill(getpid(), signr); 158 kill(getpid(), signr);
161} 159}
162 160
163static struct perf_header_attr *get_header_attr(struct perf_event_attr *a, int nr)
164{
165 struct perf_header_attr *h_attr;
166
167 if (nr < session->header.attrs) {
168 h_attr = session->header.attr[nr];
169 } else {
170 h_attr = perf_header_attr__new(a);
171 if (h_attr != NULL)
172 if (perf_header__add_attr(&session->header, h_attr) < 0) {
173 perf_header_attr__delete(h_attr);
174 h_attr = NULL;
175 }
176 }
177
178 return h_attr;
179}
180
181static void create_counter(struct perf_evsel *evsel, int cpu)
182{
183 struct perf_event_attr *attr = &evsel->attr;
184 struct perf_header_attr *h_attr;
185 struct perf_sample_id *sid;
186 int thread_index;
187
188 for (thread_index = 0; thread_index < evsel_list->threads->nr; thread_index++) {
189 h_attr = get_header_attr(attr, evsel->idx);
190 if (h_attr == NULL)
191 die("nomem\n");
192
193 if (!file_new) {
194 if (memcmp(&h_attr->attr, attr, sizeof(*attr))) {
195 fprintf(stderr, "incompatible append\n");
196 exit(-1);
197 }
198 }
199
200 sid = SID(evsel, cpu, thread_index);
201 if (perf_header_attr__add_id(h_attr, sid->id) < 0) {
202 pr_warning("Not enough memory to add id\n");
203 exit(-1);
204 }
205 }
206
207 if (!sample_type)
208 sample_type = attr->sample_type;
209}
210
211static void config_attr(struct perf_evsel *evsel, struct perf_evlist *evlist) 161static void config_attr(struct perf_evsel *evsel, struct perf_evlist *evlist)
212{ 162{
213 struct perf_event_attr *attr = &evsel->attr; 163 struct perf_event_attr *attr = &evsel->attr;
@@ -278,10 +228,28 @@ static void config_attr(struct perf_evsel *evsel, struct perf_evlist *evlist)
278 } 228 }
279} 229}
280 230
231static bool perf_evlist__equal(struct perf_evlist *evlist,
232 struct perf_evlist *other)
233{
234 struct perf_evsel *pos, *pair;
235
236 if (evlist->nr_entries != other->nr_entries)
237 return false;
238
239 pair = list_entry(other->entries.next, struct perf_evsel, node);
240
241 list_for_each_entry(pos, &evlist->entries, node) {
242 if (memcmp(&pos->attr, &pair->attr, sizeof(pos->attr) != 0))
243 return false;
244 pair = list_entry(pair->node.next, struct perf_evsel, node);
245 }
246
247 return true;
248}
249
281static void open_counters(struct perf_evlist *evlist) 250static void open_counters(struct perf_evlist *evlist)
282{ 251{
283 struct perf_evsel *pos; 252 struct perf_evsel *pos;
284 int cpu;
285 253
286 list_for_each_entry(pos, &evlist->entries, node) { 254 list_for_each_entry(pos, &evlist->entries, node) {
287 struct perf_event_attr *attr = &pos->attr; 255 struct perf_event_attr *attr = &pos->attr;
@@ -364,10 +332,16 @@ try_again:
364 if (perf_evlist__mmap(evlist, mmap_pages, false) < 0) 332 if (perf_evlist__mmap(evlist, mmap_pages, false) < 0)
365 die("failed to mmap with %d (%s)\n", errno, strerror(errno)); 333 die("failed to mmap with %d (%s)\n", errno, strerror(errno));
366 334
367 for (cpu = 0; cpu < evsel_list->cpus->nr; ++cpu) { 335 if (file_new)
368 list_for_each_entry(pos, &evlist->entries, node) 336 session->evlist = evlist;
369 create_counter(pos, cpu); 337 else {
370 } 338 if (!perf_evlist__equal(session->evlist, evlist)) {
339 fprintf(stderr, "incompatible append\n");
340 exit(-1);
341 }
342 }
343
344 perf_session__update_sample_type(session);
371} 345}
372 346
373static int process_buildids(void) 347static int process_buildids(void)
@@ -390,7 +364,7 @@ static void atexit_header(void)
390 364
391 if (!no_buildid) 365 if (!no_buildid)
392 process_buildids(); 366 process_buildids();
393 perf_header__write(&session->header, evsel_list, output, true); 367 perf_session__write_header(session, evsel_list, output, true);
394 perf_session__delete(session); 368 perf_session__delete(session);
395 perf_evlist__delete(evsel_list); 369 perf_evlist__delete(evsel_list);
396 symbol__exit(); 370 symbol__exit();
@@ -524,7 +498,7 @@ static int __cmd_record(int argc, const char **argv)
524 perf_header__set_feat(&session->header, HEADER_BUILD_ID); 498 perf_header__set_feat(&session->header, HEADER_BUILD_ID);
525 499
526 if (!file_new) { 500 if (!file_new) {
527 err = perf_header__read(session, output); 501 err = perf_session__read_header(session, output);
528 if (err < 0) 502 if (err < 0)
529 goto out_delete_session; 503 goto out_delete_session;
530 } 504 }
@@ -588,8 +562,6 @@ static int __cmd_record(int argc, const char **argv)
588 562
589 open_counters(evsel_list); 563 open_counters(evsel_list);
590 564
591 perf_session__set_sample_type(session, sample_type);
592
593 /* 565 /*
594 * perf_session__delete(session) will be called at atexit_header() 566 * perf_session__delete(session) will be called at atexit_header()
595 */ 567 */
@@ -600,20 +572,17 @@ static int __cmd_record(int argc, const char **argv)
600 if (err < 0) 572 if (err < 0)
601 return err; 573 return err;
602 } else if (file_new) { 574 } else if (file_new) {
603 err = perf_header__write(&session->header, evsel_list, 575 err = perf_session__write_header(session, evsel_list,
604 output, false); 576 output, false);
605 if (err < 0) 577 if (err < 0)
606 return err; 578 return err;
607 } 579 }
608 580
609 post_processing_offset = lseek(output, 0, SEEK_CUR); 581 post_processing_offset = lseek(output, 0, SEEK_CUR);
610 582
611 perf_session__set_sample_id_all(session, sample_id_all_avail);
612
613 if (pipe_output) { 583 if (pipe_output) {
614 err = perf_event__synthesize_attrs(&session->header, 584 err = perf_session__synthesize_attrs(session,
615 process_synthesized_event, 585 process_synthesized_event);
616 session);
617 if (err < 0) { 586 if (err < 0) {
618 pr_err("Couldn't synthesize attrs.\n"); 587 pr_err("Couldn't synthesize attrs.\n");
619 return err; 588 return err;
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index e9b5d513333a..b1b82009ab9b 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -70,8 +70,8 @@ static int perf_session__add_hist_entry(struct perf_session *session,
70 * FIXME: Propagate this back, but at least we're in a builtin, 70 * FIXME: Propagate this back, but at least we're in a builtin,
71 * where exit() is allowed. ;-) 71 * where exit() is allowed. ;-)
72 */ 72 */
73 ui__warning("Invalid %s file, contains samples with id not in " 73 ui__warning("Invalid %s file, contains samples with id %" PRIu64 " not in "
74 "its header!\n", input_name); 74 "its header!\n", input_name, sample->id);
75 exit_browser(0); 75 exit_browser(0);
76 exit(1); 76 exit(1);
77 } 77 }
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index 417f757e3cbe..80c9e062bd5b 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -883,7 +883,6 @@ try_again:
883static int __cmd_top(void) 883static int __cmd_top(void)
884{ 884{
885 pthread_t thread; 885 pthread_t thread;
886 struct perf_evsel *first;
887 int ret __used; 886 int ret __used;
888 /* 887 /*
889 * FIXME: perf_session__new should allow passing a O_MMAP, so that all this 888 * FIXME: perf_session__new should allow passing a O_MMAP, so that all this
@@ -900,8 +899,8 @@ static int __cmd_top(void)
900 perf_event__synthesize_threads(perf_event__process, session); 899 perf_event__synthesize_threads(perf_event__process, session);
901 900
902 start_counters(top.evlist); 901 start_counters(top.evlist);
903 first = list_entry(top.evlist->entries.next, struct perf_evsel, node); 902 session->evlist = top.evlist;
904 perf_session__set_sample_type(session, first->attr.sample_type); 903 perf_session__update_sample_type(session);
905 904
906 /* Wait for a minimal set of events before starting the snapshot */ 905 /* Wait for a minimal set of events before starting the snapshot */
907 poll(top.evlist->pollfd, top.evlist->nr_fds, 100); 906 poll(top.evlist->pollfd, top.evlist->nr_fds, 100);
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 190c64c6e266..d852cefa20de 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -19,7 +19,7 @@
19#include <linux/hash.h> 19#include <linux/hash.h>
20 20
21#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y)) 21#define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
22#define SID(e, x, y) xyarray__entry(e->id, x, y) 22#define SID(e, x, y) xyarray__entry(e->sample_id, x, y)
23 23
24void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus, 24void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
25 struct thread_map *threads) 25 struct thread_map *threads)
@@ -106,8 +106,9 @@ void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd)
106 evlist->nr_fds++; 106 evlist->nr_fds++;
107} 107}
108 108
109void perf_evlist__id_hash(struct perf_evlist *evlist, struct perf_evsel *evsel, 109static void perf_evlist__id_hash(struct perf_evlist *evlist,
110 int cpu, int thread, u64 id) 110 struct perf_evsel *evsel,
111 int cpu, int thread, u64 id)
111{ 112{
112 int hash; 113 int hash;
113 struct perf_sample_id *sid = SID(evsel, cpu, thread); 114 struct perf_sample_id *sid = SID(evsel, cpu, thread);
@@ -118,9 +119,16 @@ void perf_evlist__id_hash(struct perf_evlist *evlist, struct perf_evsel *evsel,
118 hlist_add_head(&sid->node, &evlist->heads[hash]); 119 hlist_add_head(&sid->node, &evlist->heads[hash]);
119} 120}
120 121
121static int perf_evlist__id_hash_fd(struct perf_evlist *evlist, 122void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
122 struct perf_evsel *evsel, 123 int cpu, int thread, u64 id)
123 int cpu, int thread, int fd) 124{
125 perf_evlist__id_hash(evlist, evsel, cpu, thread, id);
126 evsel->id[evsel->ids++] = id;
127}
128
129static int perf_evlist__id_add_fd(struct perf_evlist *evlist,
130 struct perf_evsel *evsel,
131 int cpu, int thread, int fd)
124{ 132{
125 u64 read_data[4] = { 0, }; 133 u64 read_data[4] = { 0, };
126 int id_idx = 1; /* The first entry is the counter value */ 134 int id_idx = 1; /* The first entry is the counter value */
@@ -134,7 +142,7 @@ static int perf_evlist__id_hash_fd(struct perf_evlist *evlist,
134 if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING) 142 if (evsel->attr.read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
135 ++id_idx; 143 ++id_idx;
136 144
137 perf_evlist__id_hash(evlist, evsel, cpu, thread, read_data[id_idx]); 145 perf_evlist__id_add(evlist, evsel, cpu, thread, read_data[id_idx]);
138 return 0; 146 return 0;
139} 147}
140 148
@@ -292,7 +300,7 @@ int perf_evlist__mmap(struct perf_evlist *evlist, int pages, bool overwrite)
292 300
293 list_for_each_entry(evsel, &evlist->entries, node) { 301 list_for_each_entry(evsel, &evlist->entries, node) {
294 if ((evsel->attr.read_format & PERF_FORMAT_ID) && 302 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
295 evsel->id == NULL && 303 evsel->sample_id == NULL &&
296 perf_evsel__alloc_id(evsel, cpus->nr, threads->nr) < 0) 304 perf_evsel__alloc_id(evsel, cpus->nr, threads->nr) < 0)
297 return -ENOMEM; 305 return -ENOMEM;
298 306
@@ -308,7 +316,7 @@ int perf_evlist__mmap(struct perf_evlist *evlist, int pages, bool overwrite)
308 goto out_unmap; 316 goto out_unmap;
309 317
310 if ((evsel->attr.read_format & PERF_FORMAT_ID) && 318 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
311 perf_evlist__id_hash_fd(evlist, evsel, cpu, thread, fd) < 0) 319 perf_evlist__id_add_fd(evlist, evsel, cpu, thread, fd) < 0)
312 goto out_unmap; 320 goto out_unmap;
313 } 321 }
314 } 322 }
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 078d51256085..8b1cb7a4c5f1 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -38,8 +38,8 @@ void perf_evlist__delete(struct perf_evlist *evlist);
38void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry); 38void perf_evlist__add(struct perf_evlist *evlist, struct perf_evsel *entry);
39int perf_evlist__add_default(struct perf_evlist *evlist); 39int perf_evlist__add_default(struct perf_evlist *evlist);
40 40
41void perf_evlist__id_hash(struct perf_evlist *evlist, struct perf_evsel *evsel, 41void perf_evlist__id_add(struct perf_evlist *evlist, struct perf_evsel *evsel,
42 int cpu, int thread, u64 id); 42 int cpu, int thread, u64 id);
43 43
44int perf_evlist__alloc_pollfd(struct perf_evlist *evlist); 44int perf_evlist__alloc_pollfd(struct perf_evlist *evlist);
45void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd); 45void perf_evlist__add_pollfd(struct perf_evlist *evlist, int fd);
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 8083d5126fca..662596afd7f1 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -41,8 +41,18 @@ int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
41 41
42int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads) 42int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
43{ 43{
44 evsel->id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id)); 44 evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
45 return evsel->id != NULL ? 0 : -ENOMEM; 45 if (evsel->sample_id == NULL)
46 return -ENOMEM;
47
48 evsel->id = zalloc(ncpus * nthreads * sizeof(u64));
49 if (evsel->id == NULL) {
50 xyarray__delete(evsel->sample_id);
51 evsel->sample_id = NULL;
52 return -ENOMEM;
53 }
54
55 return 0;
46} 56}
47 57
48int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus) 58int perf_evsel__alloc_counts(struct perf_evsel *evsel, int ncpus)
@@ -60,7 +70,9 @@ void perf_evsel__free_fd(struct perf_evsel *evsel)
60 70
61void perf_evsel__free_id(struct perf_evsel *evsel) 71void perf_evsel__free_id(struct perf_evsel *evsel)
62{ 72{
63 xyarray__delete(evsel->id); 73 xyarray__delete(evsel->sample_id);
74 evsel->sample_id = NULL;
75 free(evsel->id);
64 evsel->id = NULL; 76 evsel->id = NULL;
65} 77}
66 78
@@ -79,7 +91,8 @@ void perf_evsel__exit(struct perf_evsel *evsel)
79{ 91{
80 assert(list_empty(&evsel->node)); 92 assert(list_empty(&evsel->node));
81 xyarray__delete(evsel->fd); 93 xyarray__delete(evsel->fd);
82 xyarray__delete(evsel->id); 94 xyarray__delete(evsel->sample_id);
95 free(evsel->id);
83} 96}
84 97
85void perf_evsel__delete(struct perf_evsel *evsel) 98void perf_evsel__delete(struct perf_evsel *evsel)
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index 281b60e5fc7b..6710ab538342 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -49,12 +49,17 @@ struct perf_evsel {
49 struct perf_event_attr attr; 49 struct perf_event_attr attr;
50 char *filter; 50 char *filter;
51 struct xyarray *fd; 51 struct xyarray *fd;
52 struct xyarray *id; 52 struct xyarray *sample_id;
53 u64 *id;
53 struct perf_counts *counts; 54 struct perf_counts *counts;
54 int idx; 55 int idx;
56 int ids;
55 struct hists hists; 57 struct hists hists;
56 char *name; 58 char *name;
57 void *priv; 59 union {
60 void *priv;
61 off_t id_offset;
62 };
58 struct cgroup_sel *cgrp; 63 struct cgroup_sel *cgrp;
59}; 64};
60 65
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 108b0db7bbef..5a72d421e211 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -9,6 +9,7 @@
9#include <linux/kernel.h> 9#include <linux/kernel.h>
10 10
11#include "evlist.h" 11#include "evlist.h"
12#include "evsel.h"
12#include "util.h" 13#include "util.h"
13#include "header.h" 14#include "header.h"
14#include "../perf.h" 15#include "../perf.h"
@@ -19,89 +20,6 @@
19 20
20static bool no_buildid_cache = false; 21static bool no_buildid_cache = false;
21 22
22/*
23 * Create new perf.data header attribute:
24 */
25struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr)
26{
27 struct perf_header_attr *self = malloc(sizeof(*self));
28
29 if (self != NULL) {
30 self->attr = *attr;
31 self->ids = 0;
32 self->size = 1;
33 self->id = malloc(sizeof(u64));
34 if (self->id == NULL) {
35 free(self);
36 self = NULL;
37 }
38 }
39
40 return self;
41}
42
43void perf_header_attr__delete(struct perf_header_attr *self)
44{
45 free(self->id);
46 free(self);
47}
48
49int perf_header_attr__add_id(struct perf_header_attr *self, u64 id)
50{
51 int pos = self->ids;
52
53 self->ids++;
54 if (self->ids > self->size) {
55 int nsize = self->size * 2;
56 u64 *nid = realloc(self->id, nsize * sizeof(u64));
57
58 if (nid == NULL)
59 return -1;
60
61 self->size = nsize;
62 self->id = nid;
63 }
64 self->id[pos] = id;
65 return 0;
66}
67
68int perf_header__init(struct perf_header *self)
69{
70 self->size = 1;
71 self->attr = malloc(sizeof(void *));
72 return self->attr == NULL ? -ENOMEM : 0;
73}
74
75void perf_header__exit(struct perf_header *self)
76{
77 int i;
78 for (i = 0; i < self->attrs; ++i)
79 perf_header_attr__delete(self->attr[i]);
80 free(self->attr);
81}
82
83int perf_header__add_attr(struct perf_header *self,
84 struct perf_header_attr *attr)
85{
86 if (self->frozen)
87 return -1;
88
89 if (self->attrs == self->size) {
90 int nsize = self->size * 2;
91 struct perf_header_attr **nattr;
92
93 nattr = realloc(self->attr, nsize * sizeof(void *));
94 if (nattr == NULL)
95 return -1;
96
97 self->size = nsize;
98 self->attr = nattr;
99 }
100
101 self->attr[self->attrs++] = attr;
102 return 0;
103}
104
105static int event_count; 23static int event_count;
106static struct perf_trace_event_type *events; 24static struct perf_trace_event_type *events;
107 25
@@ -148,19 +66,19 @@ struct perf_file_attr {
148 struct perf_file_section ids; 66 struct perf_file_section ids;
149}; 67};
150 68
151void perf_header__set_feat(struct perf_header *self, int feat) 69void perf_header__set_feat(struct perf_header *header, int feat)
152{ 70{
153 set_bit(feat, self->adds_features); 71 set_bit(feat, header->adds_features);
154} 72}
155 73
156void perf_header__clear_feat(struct perf_header *self, int feat) 74void perf_header__clear_feat(struct perf_header *header, int feat)
157{ 75{
158 clear_bit(feat, self->adds_features); 76 clear_bit(feat, header->adds_features);
159} 77}
160 78
161bool perf_header__has_feat(const struct perf_header *self, int feat) 79bool perf_header__has_feat(const struct perf_header *header, int feat)
162{ 80{
163 return test_bit(feat, self->adds_features); 81 return test_bit(feat, header->adds_features);
164} 82}
165 83
166static int do_write(int fd, const void *buf, size_t size) 84static int do_write(int fd, const void *buf, size_t size)
@@ -229,22 +147,22 @@ static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
229 return 0; 147 return 0;
230} 148}
231 149
232static int machine__write_buildid_table(struct machine *self, int fd) 150static int machine__write_buildid_table(struct machine *machine, int fd)
233{ 151{
234 int err; 152 int err;
235 u16 kmisc = PERF_RECORD_MISC_KERNEL, 153 u16 kmisc = PERF_RECORD_MISC_KERNEL,
236 umisc = PERF_RECORD_MISC_USER; 154 umisc = PERF_RECORD_MISC_USER;
237 155
238 if (!machine__is_host(self)) { 156 if (!machine__is_host(machine)) {
239 kmisc = PERF_RECORD_MISC_GUEST_KERNEL; 157 kmisc = PERF_RECORD_MISC_GUEST_KERNEL;
240 umisc = PERF_RECORD_MISC_GUEST_USER; 158 umisc = PERF_RECORD_MISC_GUEST_USER;
241 } 159 }
242 160
243 err = __dsos__write_buildid_table(&self->kernel_dsos, self->pid, 161 err = __dsos__write_buildid_table(&machine->kernel_dsos, machine->pid,
244 kmisc, fd); 162 kmisc, fd);
245 if (err == 0) 163 if (err == 0)
246 err = __dsos__write_buildid_table(&self->user_dsos, 164 err = __dsos__write_buildid_table(&machine->user_dsos,
247 self->pid, umisc, fd); 165 machine->pid, umisc, fd);
248 return err; 166 return err;
249} 167}
250 168
@@ -362,12 +280,12 @@ out_free:
362 return err; 280 return err;
363} 281}
364 282
365static int dso__cache_build_id(struct dso *self, const char *debugdir) 283static int dso__cache_build_id(struct dso *dso, const char *debugdir)
366{ 284{
367 bool is_kallsyms = self->kernel && self->long_name[0] != '/'; 285 bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
368 286
369 return build_id_cache__add_b(self->build_id, sizeof(self->build_id), 287 return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
370 self->long_name, debugdir, is_kallsyms); 288 dso->long_name, debugdir, is_kallsyms);
371} 289}
372 290
373static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir) 291static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
@@ -382,14 +300,14 @@ static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
382 return err; 300 return err;
383} 301}
384 302
385static int machine__cache_build_ids(struct machine *self, const char *debugdir) 303static int machine__cache_build_ids(struct machine *machine, const char *debugdir)
386{ 304{
387 int ret = __dsos__cache_build_ids(&self->kernel_dsos, debugdir); 305 int ret = __dsos__cache_build_ids(&machine->kernel_dsos, debugdir);
388 ret |= __dsos__cache_build_ids(&self->user_dsos, debugdir); 306 ret |= __dsos__cache_build_ids(&machine->user_dsos, debugdir);
389 return ret; 307 return ret;
390} 308}
391 309
392static int perf_session__cache_build_ids(struct perf_session *self) 310static int perf_session__cache_build_ids(struct perf_session *session)
393{ 311{
394 struct rb_node *nd; 312 struct rb_node *nd;
395 int ret; 313 int ret;
@@ -400,28 +318,28 @@ static int perf_session__cache_build_ids(struct perf_session *self)
400 if (mkdir(debugdir, 0755) != 0 && errno != EEXIST) 318 if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
401 return -1; 319 return -1;
402 320
403 ret = machine__cache_build_ids(&self->host_machine, debugdir); 321 ret = machine__cache_build_ids(&session->host_machine, debugdir);
404 322
405 for (nd = rb_first(&self->machines); nd; nd = rb_next(nd)) { 323 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
406 struct machine *pos = rb_entry(nd, struct machine, rb_node); 324 struct machine *pos = rb_entry(nd, struct machine, rb_node);
407 ret |= machine__cache_build_ids(pos, debugdir); 325 ret |= machine__cache_build_ids(pos, debugdir);
408 } 326 }
409 return ret ? -1 : 0; 327 return ret ? -1 : 0;
410} 328}
411 329
412static bool machine__read_build_ids(struct machine *self, bool with_hits) 330static bool machine__read_build_ids(struct machine *machine, bool with_hits)
413{ 331{
414 bool ret = __dsos__read_build_ids(&self->kernel_dsos, with_hits); 332 bool ret = __dsos__read_build_ids(&machine->kernel_dsos, with_hits);
415 ret |= __dsos__read_build_ids(&self->user_dsos, with_hits); 333 ret |= __dsos__read_build_ids(&machine->user_dsos, with_hits);
416 return ret; 334 return ret;
417} 335}
418 336
419static bool perf_session__read_build_ids(struct perf_session *self, bool with_hits) 337static bool perf_session__read_build_ids(struct perf_session *session, bool with_hits)
420{ 338{
421 struct rb_node *nd; 339 struct rb_node *nd;
422 bool ret = machine__read_build_ids(&self->host_machine, with_hits); 340 bool ret = machine__read_build_ids(&session->host_machine, with_hits);
423 341
424 for (nd = rb_first(&self->machines); nd; nd = rb_next(nd)) { 342 for (nd = rb_first(&session->machines); nd; nd = rb_next(nd)) {
425 struct machine *pos = rb_entry(nd, struct machine, rb_node); 343 struct machine *pos = rb_entry(nd, struct machine, rb_node);
426 ret |= machine__read_build_ids(pos, with_hits); 344 ret |= machine__read_build_ids(pos, with_hits);
427 } 345 }
@@ -429,7 +347,7 @@ static bool perf_session__read_build_ids(struct perf_session *self, bool with_hi
429 return ret; 347 return ret;
430} 348}
431 349
432static int perf_header__adds_write(struct perf_header *self, 350static int perf_header__adds_write(struct perf_header *header,
433 struct perf_evlist *evlist, int fd) 351 struct perf_evlist *evlist, int fd)
434{ 352{
435 int nr_sections; 353 int nr_sections;
@@ -439,13 +357,13 @@ static int perf_header__adds_write(struct perf_header *self,
439 u64 sec_start; 357 u64 sec_start;
440 int idx = 0, err; 358 int idx = 0, err;
441 359
442 session = container_of(self, struct perf_session, header); 360 session = container_of(header, struct perf_session, header);
443 361
444 if (perf_header__has_feat(self, HEADER_BUILD_ID && 362 if (perf_header__has_feat(header, HEADER_BUILD_ID &&
445 !perf_session__read_build_ids(session, true))) 363 !perf_session__read_build_ids(session, true)))
446 perf_header__clear_feat(self, HEADER_BUILD_ID); 364 perf_header__clear_feat(header, HEADER_BUILD_ID);
447 365
448 nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS); 366 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
449 if (!nr_sections) 367 if (!nr_sections)
450 return 0; 368 return 0;
451 369
@@ -455,10 +373,10 @@ static int perf_header__adds_write(struct perf_header *self,
455 373
456 sec_size = sizeof(*feat_sec) * nr_sections; 374 sec_size = sizeof(*feat_sec) * nr_sections;
457 375
458 sec_start = self->data_offset + self->data_size; 376 sec_start = header->data_offset + header->data_size;
459 lseek(fd, sec_start + sec_size, SEEK_SET); 377 lseek(fd, sec_start + sec_size, SEEK_SET);
460 378
461 if (perf_header__has_feat(self, HEADER_TRACE_INFO)) { 379 if (perf_header__has_feat(header, HEADER_TRACE_INFO)) {
462 struct perf_file_section *trace_sec; 380 struct perf_file_section *trace_sec;
463 381
464 trace_sec = &feat_sec[idx++]; 382 trace_sec = &feat_sec[idx++];
@@ -469,14 +387,14 @@ static int perf_header__adds_write(struct perf_header *self,
469 trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset; 387 trace_sec->size = lseek(fd, 0, SEEK_CUR) - trace_sec->offset;
470 } 388 }
471 389
472 if (perf_header__has_feat(self, HEADER_BUILD_ID)) { 390 if (perf_header__has_feat(header, HEADER_BUILD_ID)) {
473 struct perf_file_section *buildid_sec; 391 struct perf_file_section *buildid_sec;
474 392
475 buildid_sec = &feat_sec[idx++]; 393 buildid_sec = &feat_sec[idx++];
476 394
477 /* Write build-ids */ 395 /* Write build-ids */
478 buildid_sec->offset = lseek(fd, 0, SEEK_CUR); 396 buildid_sec->offset = lseek(fd, 0, SEEK_CUR);
479 err = dsos__write_buildid_table(self, fd); 397 err = dsos__write_buildid_table(header, fd);
480 if (err < 0) { 398 if (err < 0) {
481 pr_debug("failed to write buildid table\n"); 399 pr_debug("failed to write buildid table\n");
482 goto out_free; 400 goto out_free;
@@ -515,33 +433,41 @@ int perf_header__write_pipe(int fd)
515 return 0; 433 return 0;
516} 434}
517 435
518int perf_header__write(struct perf_header *self, struct perf_evlist *evlist, 436int perf_session__write_header(struct perf_session *session,
519 int fd, bool at_exit) 437 struct perf_evlist *evlist,
438 int fd, bool at_exit)
520{ 439{
521 struct perf_file_header f_header; 440 struct perf_file_header f_header;
522 struct perf_file_attr f_attr; 441 struct perf_file_attr f_attr;
523 struct perf_header_attr *attr; 442 struct perf_header *header = &session->header;
524 int i, err; 443 struct perf_evsel *attr, *pair = NULL;
444 int err;
525 445
526 lseek(fd, sizeof(f_header), SEEK_SET); 446 lseek(fd, sizeof(f_header), SEEK_SET);
527 447
528 for (i = 0; i < self->attrs; i++) { 448 if (session->evlist != evlist)
529 attr = self->attr[i]; 449 pair = list_entry(session->evlist->entries.next, struct perf_evsel, node);
530 450
451 list_for_each_entry(attr, &evlist->entries, node) {
531 attr->id_offset = lseek(fd, 0, SEEK_CUR); 452 attr->id_offset = lseek(fd, 0, SEEK_CUR);
532 err = do_write(fd, attr->id, attr->ids * sizeof(u64)); 453 err = do_write(fd, attr->id, attr->ids * sizeof(u64));
533 if (err < 0) { 454 if (err < 0) {
455out_err_write:
534 pr_debug("failed to write perf header\n"); 456 pr_debug("failed to write perf header\n");
535 return err; 457 return err;
536 } 458 }
459 if (session->evlist != evlist) {
460 err = do_write(fd, pair->id, pair->ids * sizeof(u64));
461 if (err < 0)
462 goto out_err_write;
463 attr->ids += pair->ids;
464 pair = list_entry(pair->node.next, struct perf_evsel, node);
465 }
537 } 466 }
538 467
468 header->attr_offset = lseek(fd, 0, SEEK_CUR);
539 469
540 self->attr_offset = lseek(fd, 0, SEEK_CUR); 470 list_for_each_entry(attr, &evlist->entries, node) {
541
542 for (i = 0; i < self->attrs; i++) {
543 attr = self->attr[i];
544
545 f_attr = (struct perf_file_attr){ 471 f_attr = (struct perf_file_attr){
546 .attr = attr->attr, 472 .attr = attr->attr,
547 .ids = { 473 .ids = {
@@ -556,20 +482,20 @@ int perf_header__write(struct perf_header *self, struct perf_evlist *evlist,
556 } 482 }
557 } 483 }
558 484
559 self->event_offset = lseek(fd, 0, SEEK_CUR); 485 header->event_offset = lseek(fd, 0, SEEK_CUR);
560 self->event_size = event_count * sizeof(struct perf_trace_event_type); 486 header->event_size = event_count * sizeof(struct perf_trace_event_type);
561 if (events) { 487 if (events) {
562 err = do_write(fd, events, self->event_size); 488 err = do_write(fd, events, header->event_size);
563 if (err < 0) { 489 if (err < 0) {
564 pr_debug("failed to write perf header events\n"); 490 pr_debug("failed to write perf header events\n");
565 return err; 491 return err;
566 } 492 }
567 } 493 }
568 494
569 self->data_offset = lseek(fd, 0, SEEK_CUR); 495 header->data_offset = lseek(fd, 0, SEEK_CUR);
570 496
571 if (at_exit) { 497 if (at_exit) {
572 err = perf_header__adds_write(self, evlist, fd); 498 err = perf_header__adds_write(header, evlist, fd);
573 if (err < 0) 499 if (err < 0)
574 return err; 500 return err;
575 } 501 }
@@ -579,20 +505,20 @@ int perf_header__write(struct perf_header *self, struct perf_evlist *evlist,
579 .size = sizeof(f_header), 505 .size = sizeof(f_header),
580 .attr_size = sizeof(f_attr), 506 .attr_size = sizeof(f_attr),
581 .attrs = { 507 .attrs = {
582 .offset = self->attr_offset, 508 .offset = header->attr_offset,
583 .size = self->attrs * sizeof(f_attr), 509 .size = evlist->nr_entries * sizeof(f_attr),
584 }, 510 },
585 .data = { 511 .data = {
586 .offset = self->data_offset, 512 .offset = header->data_offset,
587 .size = self->data_size, 513 .size = header->data_size,
588 }, 514 },
589 .event_types = { 515 .event_types = {
590 .offset = self->event_offset, 516 .offset = header->event_offset,
591 .size = self->event_size, 517 .size = header->event_size,
592 }, 518 },
593 }; 519 };
594 520
595 memcpy(&f_header.adds_features, &self->adds_features, sizeof(self->adds_features)); 521 memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
596 522
597 lseek(fd, 0, SEEK_SET); 523 lseek(fd, 0, SEEK_SET);
598 err = do_write(fd, &f_header, sizeof(f_header)); 524 err = do_write(fd, &f_header, sizeof(f_header));
@@ -600,26 +526,26 @@ int perf_header__write(struct perf_header *self, struct perf_evlist *evlist,
600 pr_debug("failed to write perf header\n"); 526 pr_debug("failed to write perf header\n");
601 return err; 527 return err;
602 } 528 }
603 lseek(fd, self->data_offset + self->data_size, SEEK_SET); 529 lseek(fd, header->data_offset + header->data_size, SEEK_SET);
604 530
605 self->frozen = 1; 531 header->frozen = 1;
606 return 0; 532 return 0;
607} 533}
608 534
609static int perf_header__getbuffer64(struct perf_header *self, 535static int perf_header__getbuffer64(struct perf_header *header,
610 int fd, void *buf, size_t size) 536 int fd, void *buf, size_t size)
611{ 537{
612 if (readn(fd, buf, size) <= 0) 538 if (readn(fd, buf, size) <= 0)
613 return -1; 539 return -1;
614 540
615 if (self->needs_swap) 541 if (header->needs_swap)
616 mem_bswap_64(buf, size); 542 mem_bswap_64(buf, size);
617 543
618 return 0; 544 return 0;
619} 545}
620 546
621int perf_header__process_sections(struct perf_header *self, int fd, 547int perf_header__process_sections(struct perf_header *header, int fd,
622 int (*process)(struct perf_file_section *self, 548 int (*process)(struct perf_file_section *section,
623 struct perf_header *ph, 549 struct perf_header *ph,
624 int feat, int fd)) 550 int feat, int fd))
625{ 551{
@@ -629,7 +555,7 @@ int perf_header__process_sections(struct perf_header *self, int fd,
629 int idx = 0; 555 int idx = 0;
630 int err = -1, feat = 1; 556 int err = -1, feat = 1;
631 557
632 nr_sections = bitmap_weight(self->adds_features, HEADER_FEAT_BITS); 558 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
633 if (!nr_sections) 559 if (!nr_sections)
634 return 0; 560 return 0;
635 561
@@ -639,17 +565,17 @@ int perf_header__process_sections(struct perf_header *self, int fd,
639 565
640 sec_size = sizeof(*feat_sec) * nr_sections; 566 sec_size = sizeof(*feat_sec) * nr_sections;
641 567
642 lseek(fd, self->data_offset + self->data_size, SEEK_SET); 568 lseek(fd, header->data_offset + header->data_size, SEEK_SET);
643 569
644 if (perf_header__getbuffer64(self, fd, feat_sec, sec_size)) 570 if (perf_header__getbuffer64(header, fd, feat_sec, sec_size))
645 goto out_free; 571 goto out_free;
646 572
647 err = 0; 573 err = 0;
648 while (idx < nr_sections && feat < HEADER_LAST_FEATURE) { 574 while (idx < nr_sections && feat < HEADER_LAST_FEATURE) {
649 if (perf_header__has_feat(self, feat)) { 575 if (perf_header__has_feat(header, feat)) {
650 struct perf_file_section *sec = &feat_sec[idx++]; 576 struct perf_file_section *sec = &feat_sec[idx++];
651 577
652 err = process(sec, self, feat, fd); 578 err = process(sec, header, feat, fd);
653 if (err < 0) 579 if (err < 0)
654 break; 580 break;
655 } 581 }
@@ -660,35 +586,35 @@ out_free:
660 return err; 586 return err;
661} 587}
662 588
663int perf_file_header__read(struct perf_file_header *self, 589int perf_file_header__read(struct perf_file_header *header,
664 struct perf_header *ph, int fd) 590 struct perf_header *ph, int fd)
665{ 591{
666 lseek(fd, 0, SEEK_SET); 592 lseek(fd, 0, SEEK_SET);
667 593
668 if (readn(fd, self, sizeof(*self)) <= 0 || 594 if (readn(fd, header, sizeof(*header)) <= 0 ||
669 memcmp(&self->magic, __perf_magic, sizeof(self->magic))) 595 memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
670 return -1; 596 return -1;
671 597
672 if (self->attr_size != sizeof(struct perf_file_attr)) { 598 if (header->attr_size != sizeof(struct perf_file_attr)) {
673 u64 attr_size = bswap_64(self->attr_size); 599 u64 attr_size = bswap_64(header->attr_size);
674 600
675 if (attr_size != sizeof(struct perf_file_attr)) 601 if (attr_size != sizeof(struct perf_file_attr))
676 return -1; 602 return -1;
677 603
678 mem_bswap_64(self, offsetof(struct perf_file_header, 604 mem_bswap_64(header, offsetof(struct perf_file_header,
679 adds_features)); 605 adds_features));
680 ph->needs_swap = true; 606 ph->needs_swap = true;
681 } 607 }
682 608
683 if (self->size != sizeof(*self)) { 609 if (header->size != sizeof(*header)) {
684 /* Support the previous format */ 610 /* Support the previous format */
685 if (self->size == offsetof(typeof(*self), adds_features)) 611 if (header->size == offsetof(typeof(*header), adds_features))
686 bitmap_zero(self->adds_features, HEADER_FEAT_BITS); 612 bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
687 else 613 else
688 return -1; 614 return -1;
689 } 615 }
690 616
691 memcpy(&ph->adds_features, &self->adds_features, 617 memcpy(&ph->adds_features, &header->adds_features,
692 sizeof(ph->adds_features)); 618 sizeof(ph->adds_features));
693 /* 619 /*
694 * FIXME: hack that assumes that if we need swap the perf.data file 620 * FIXME: hack that assumes that if we need swap the perf.data file
@@ -702,10 +628,10 @@ int perf_file_header__read(struct perf_file_header *self,
702 perf_header__set_feat(ph, HEADER_BUILD_ID); 628 perf_header__set_feat(ph, HEADER_BUILD_ID);
703 } 629 }
704 630
705 ph->event_offset = self->event_types.offset; 631 ph->event_offset = header->event_types.offset;
706 ph->event_size = self->event_types.size; 632 ph->event_size = header->event_types.size;
707 ph->data_offset = self->data.offset; 633 ph->data_offset = header->data.offset;
708 ph->data_size = self->data.size; 634 ph->data_size = header->data.size;
709 return 0; 635 return 0;
710} 636}
711 637
@@ -764,11 +690,10 @@ out:
764 return err; 690 return err;
765} 691}
766 692
767static int perf_header__read_build_ids(struct perf_header *self, 693static int perf_header__read_build_ids(struct perf_header *header,
768 int input, u64 offset, u64 size) 694 int input, u64 offset, u64 size)
769{ 695{
770 struct perf_session *session = container_of(self, 696 struct perf_session *session = container_of(header, struct perf_session, header);
771 struct perf_session, header);
772 struct build_id_event bev; 697 struct build_id_event bev;
773 char filename[PATH_MAX]; 698 char filename[PATH_MAX];
774 u64 limit = offset + size; 699 u64 limit = offset + size;
@@ -780,7 +705,7 @@ static int perf_header__read_build_ids(struct perf_header *self,
780 if (read(input, &bev, sizeof(bev)) != sizeof(bev)) 705 if (read(input, &bev, sizeof(bev)) != sizeof(bev))
781 goto out; 706 goto out;
782 707
783 if (self->needs_swap) 708 if (header->needs_swap)
784 perf_event_header__bswap(&bev.header); 709 perf_event_header__bswap(&bev.header);
785 710
786 len = bev.header.size - sizeof(bev); 711 len = bev.header.size - sizeof(bev);
@@ -796,13 +721,13 @@ out:
796 return err; 721 return err;
797} 722}
798 723
799static int perf_file_section__process(struct perf_file_section *self, 724static int perf_file_section__process(struct perf_file_section *section,
800 struct perf_header *ph, 725 struct perf_header *ph,
801 int feat, int fd) 726 int feat, int fd)
802{ 727{
803 if (lseek(fd, self->offset, SEEK_SET) == (off_t)-1) { 728 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
804 pr_debug("Failed to lseek to %" PRIu64 " offset for feature " 729 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
805 "%d, continuing...\n", self->offset, feat); 730 "%d, continuing...\n", section->offset, feat);
806 return 0; 731 return 0;
807 } 732 }
808 733
@@ -812,7 +737,7 @@ static int perf_file_section__process(struct perf_file_section *self,
812 break; 737 break;
813 738
814 case HEADER_BUILD_ID: 739 case HEADER_BUILD_ID:
815 if (perf_header__read_build_ids(ph, fd, self->offset, self->size)) 740 if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
816 pr_debug("Failed to read buildids, continuing...\n"); 741 pr_debug("Failed to read buildids, continuing...\n");
817 break; 742 break;
818 default: 743 default:
@@ -822,21 +747,21 @@ static int perf_file_section__process(struct perf_file_section *self,
822 return 0; 747 return 0;
823} 748}
824 749
825static int perf_file_header__read_pipe(struct perf_pipe_file_header *self, 750static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
826 struct perf_header *ph, int fd, 751 struct perf_header *ph, int fd,
827 bool repipe) 752 bool repipe)
828{ 753{
829 if (readn(fd, self, sizeof(*self)) <= 0 || 754 if (readn(fd, header, sizeof(*header)) <= 0 ||
830 memcmp(&self->magic, __perf_magic, sizeof(self->magic))) 755 memcmp(&header->magic, __perf_magic, sizeof(header->magic)))
831 return -1; 756 return -1;
832 757
833 if (repipe && do_write(STDOUT_FILENO, self, sizeof(*self)) < 0) 758 if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
834 return -1; 759 return -1;
835 760
836 if (self->size != sizeof(*self)) { 761 if (header->size != sizeof(*header)) {
837 u64 size = bswap_64(self->size); 762 u64 size = bswap_64(header->size);
838 763
839 if (size != sizeof(*self)) 764 if (size != sizeof(*header))
840 return -1; 765 return -1;
841 766
842 ph->needs_swap = true; 767 ph->needs_swap = true;
@@ -847,10 +772,10 @@ static int perf_file_header__read_pipe(struct perf_pipe_file_header *self,
847 772
848static int perf_header__read_pipe(struct perf_session *session, int fd) 773static int perf_header__read_pipe(struct perf_session *session, int fd)
849{ 774{
850 struct perf_header *self = &session->header; 775 struct perf_header *header = &session->header;
851 struct perf_pipe_file_header f_header; 776 struct perf_pipe_file_header f_header;
852 777
853 if (perf_file_header__read_pipe(&f_header, self, fd, 778 if (perf_file_header__read_pipe(&f_header, header, fd,
854 session->repipe) < 0) { 779 session->repipe) < 0) {
855 pr_debug("incompatible file format\n"); 780 pr_debug("incompatible file format\n");
856 return -EINVAL; 781 return -EINVAL;
@@ -861,18 +786,22 @@ static int perf_header__read_pipe(struct perf_session *session, int fd)
861 return 0; 786 return 0;
862} 787}
863 788
864int perf_header__read(struct perf_session *session, int fd) 789int perf_session__read_header(struct perf_session *session, int fd)
865{ 790{
866 struct perf_header *self = &session->header; 791 struct perf_header *header = &session->header;
867 struct perf_file_header f_header; 792 struct perf_file_header f_header;
868 struct perf_file_attr f_attr; 793 struct perf_file_attr f_attr;
869 u64 f_id; 794 u64 f_id;
870 int nr_attrs, nr_ids, i, j; 795 int nr_attrs, nr_ids, i, j;
871 796
797 session->evlist = perf_evlist__new(NULL, NULL);
798 if (session->evlist == NULL)
799 return -ENOMEM;
800
872 if (session->fd_pipe) 801 if (session->fd_pipe)
873 return perf_header__read_pipe(session, fd); 802 return perf_header__read_pipe(session, fd);
874 803
875 if (perf_file_header__read(&f_header, self, fd) < 0) { 804 if (perf_file_header__read(&f_header, header, fd) < 0) {
876 pr_debug("incompatible file format\n"); 805 pr_debug("incompatible file format\n");
877 return -EINVAL; 806 return -EINVAL;
878 } 807 }
@@ -881,33 +810,39 @@ int perf_header__read(struct perf_session *session, int fd)
881 lseek(fd, f_header.attrs.offset, SEEK_SET); 810 lseek(fd, f_header.attrs.offset, SEEK_SET);
882 811
883 for (i = 0; i < nr_attrs; i++) { 812 for (i = 0; i < nr_attrs; i++) {
884 struct perf_header_attr *attr; 813 struct perf_evsel *evsel;
885 off_t tmp; 814 off_t tmp;
886 815
887 if (perf_header__getbuffer64(self, fd, &f_attr, sizeof(f_attr))) 816 if (perf_header__getbuffer64(header, fd, &f_attr, sizeof(f_attr)))
888 goto out_errno; 817 goto out_errno;
889 818
890 tmp = lseek(fd, 0, SEEK_CUR); 819 tmp = lseek(fd, 0, SEEK_CUR);
820 evsel = perf_evsel__new(&f_attr.attr, i);
891 821
892 attr = perf_header_attr__new(&f_attr.attr); 822 if (evsel == NULL)
893 if (attr == NULL) 823 goto out_delete_evlist;
894 return -ENOMEM; 824 /*
825 * Do it before so that if perf_evsel__alloc_id fails, this
826 * entry gets purged too at perf_evlist__delete().
827 */
828 perf_evlist__add(session->evlist, evsel);
895 829
896 nr_ids = f_attr.ids.size / sizeof(u64); 830 nr_ids = f_attr.ids.size / sizeof(u64);
831 /*
832 * We don't have the cpu and thread maps on the header, so
833 * for allocating the perf_sample_id table we fake 1 cpu and
834 * hattr->ids threads.
835 */
836 if (perf_evsel__alloc_id(evsel, 1, nr_ids))
837 goto out_delete_evlist;
838
897 lseek(fd, f_attr.ids.offset, SEEK_SET); 839 lseek(fd, f_attr.ids.offset, SEEK_SET);
898 840
899 for (j = 0; j < nr_ids; j++) { 841 for (j = 0; j < nr_ids; j++) {
900 if (perf_header__getbuffer64(self, fd, &f_id, sizeof(f_id))) 842 if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
901 goto out_errno; 843 goto out_errno;
902 844
903 if (perf_header_attr__add_id(attr, f_id) < 0) { 845 perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
904 perf_header_attr__delete(attr);
905 return -ENOMEM;
906 }
907 }
908 if (perf_header__add_attr(self, attr) < 0) {
909 perf_header_attr__delete(attr);
910 return -ENOMEM;
911 } 846 }
912 847
913 lseek(fd, tmp, SEEK_SET); 848 lseek(fd, tmp, SEEK_SET);
@@ -918,51 +853,52 @@ int perf_header__read(struct perf_session *session, int fd)
918 events = malloc(f_header.event_types.size); 853 events = malloc(f_header.event_types.size);
919 if (events == NULL) 854 if (events == NULL)
920 return -ENOMEM; 855 return -ENOMEM;
921 if (perf_header__getbuffer64(self, fd, events, 856 if (perf_header__getbuffer64(header, fd, events,
922 f_header.event_types.size)) 857 f_header.event_types.size))
923 goto out_errno; 858 goto out_errno;
924 event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type); 859 event_count = f_header.event_types.size / sizeof(struct perf_trace_event_type);
925 } 860 }
926 861
927 perf_header__process_sections(self, fd, perf_file_section__process); 862 perf_header__process_sections(header, fd, perf_file_section__process);
928 863
929 lseek(fd, self->data_offset, SEEK_SET); 864 lseek(fd, header->data_offset, SEEK_SET);
930 865
931 self->frozen = 1; 866 header->frozen = 1;
932 return 0; 867 return 0;
933out_errno: 868out_errno:
934 return -errno; 869 return -errno;
870
871out_delete_evlist:
872 perf_evlist__delete(session->evlist);
873 session->evlist = NULL;
874 return -ENOMEM;
935} 875}
936 876
937u64 perf_header__sample_type(struct perf_header *header) 877u64 perf_evlist__sample_type(struct perf_evlist *evlist)
938{ 878{
879 struct perf_evsel *pos;
939 u64 type = 0; 880 u64 type = 0;
940 int i;
941
942 for (i = 0; i < header->attrs; i++) {
943 struct perf_header_attr *attr = header->attr[i];
944 881
882 list_for_each_entry(pos, &evlist->entries, node) {
945 if (!type) 883 if (!type)
946 type = attr->attr.sample_type; 884 type = pos->attr.sample_type;
947 else if (type != attr->attr.sample_type) 885 else if (type != pos->attr.sample_type)
948 die("non matching sample_type"); 886 die("non matching sample_type");
949 } 887 }
950 888
951 return type; 889 return type;
952} 890}
953 891
954bool perf_header__sample_id_all(const struct perf_header *header) 892bool perf_evlist__sample_id_all(const struct perf_evlist *evlist)
955{ 893{
956 bool value = false, first = true; 894 bool value = false, first = true;
957 int i; 895 struct perf_evsel *pos;
958
959 for (i = 0; i < header->attrs; i++) {
960 struct perf_header_attr *attr = header->attr[i];
961 896
897 list_for_each_entry(pos, &evlist->entries, node) {
962 if (first) { 898 if (first) {
963 value = attr->attr.sample_id_all; 899 value = pos->attr.sample_id_all;
964 first = false; 900 first = false;
965 } else if (value != attr->attr.sample_id_all) 901 } else if (value != pos->attr.sample_id_all)
966 die("non matching sample_id_all"); 902 die("non matching sample_id_all");
967 } 903 }
968 904
@@ -1000,16 +936,13 @@ int perf_event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
1000 return err; 936 return err;
1001} 937}
1002 938
1003int perf_event__synthesize_attrs(struct perf_header *self, 939int perf_session__synthesize_attrs(struct perf_session *session,
1004 perf_event__handler_t process, 940 perf_event__handler_t process)
1005 struct perf_session *session)
1006{ 941{
1007 struct perf_header_attr *attr; 942 struct perf_evsel *attr;
1008 int i, err = 0; 943 int err = 0;
1009
1010 for (i = 0; i < self->attrs; i++) {
1011 attr = self->attr[i];
1012 944
945 list_for_each_entry(attr, &session->evlist->entries, node) {
1013 err = perf_event__synthesize_attr(&attr->attr, attr->ids, 946 err = perf_event__synthesize_attr(&attr->attr, attr->ids,
1014 attr->id, process, session); 947 attr->id, process, session);
1015 if (err) { 948 if (err) {
@@ -1024,27 +957,36 @@ int perf_event__synthesize_attrs(struct perf_header *self,
1024int perf_event__process_attr(union perf_event *event, 957int perf_event__process_attr(union perf_event *event,
1025 struct perf_session *session) 958 struct perf_session *session)
1026{ 959{
1027 struct perf_header_attr *attr;
1028 unsigned int i, ids, n_ids; 960 unsigned int i, ids, n_ids;
961 struct perf_evsel *evsel;
1029 962
1030 attr = perf_header_attr__new(&event->attr.attr); 963 if (session->evlist == NULL) {
1031 if (attr == NULL) 964 session->evlist = perf_evlist__new(NULL, NULL);
965 if (session->evlist == NULL)
966 return -ENOMEM;
967 }
968
969 evsel = perf_evsel__new(&event->attr.attr,
970 session->evlist->nr_entries);
971 if (evsel == NULL)
1032 return -ENOMEM; 972 return -ENOMEM;
1033 973
974 perf_evlist__add(session->evlist, evsel);
975
1034 ids = event->header.size; 976 ids = event->header.size;
1035 ids -= (void *)&event->attr.id - (void *)event; 977 ids -= (void *)&event->attr.id - (void *)event;
1036 n_ids = ids / sizeof(u64); 978 n_ids = ids / sizeof(u64);
979 /*
980 * We don't have the cpu and thread maps on the header, so
981 * for allocating the perf_sample_id table we fake 1 cpu and
982 * hattr->ids threads.
983 */
984 if (perf_evsel__alloc_id(evsel, 1, n_ids))
985 return -ENOMEM;
1037 986
1038 for (i = 0; i < n_ids; i++) { 987 for (i = 0; i < n_ids; i++) {
1039 if (perf_header_attr__add_id(attr, event->attr.id[i]) < 0) { 988 perf_evlist__id_add(session->evlist, evsel, 0, i,
1040 perf_header_attr__delete(attr); 989 event->attr.id[i]);
1041 return -ENOMEM;
1042 }
1043 }
1044
1045 if (perf_header__add_attr(&session->header, attr) < 0) {
1046 perf_header_attr__delete(attr);
1047 return -ENOMEM;
1048 } 990 }
1049 991
1050 perf_session__update_sample_type(session); 992 perf_session__update_sample_type(session);
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 2fab13348aab..456661d7f10e 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -9,13 +9,6 @@
9 9
10#include <linux/bitmap.h> 10#include <linux/bitmap.h>
11 11
12struct perf_header_attr {
13 struct perf_event_attr attr;
14 int ids, size;
15 u64 *id;
16 off_t id_offset;
17};
18
19enum { 12enum {
20 HEADER_TRACE_INFO = 1, 13 HEADER_TRACE_INFO = 1,
21 HEADER_BUILD_ID, 14 HEADER_BUILD_ID,
@@ -46,14 +39,12 @@ struct perf_pipe_file_header {
46 39
47struct perf_header; 40struct perf_header;
48 41
49int perf_file_header__read(struct perf_file_header *self, 42int perf_file_header__read(struct perf_file_header *header,
50 struct perf_header *ph, int fd); 43 struct perf_header *ph, int fd);
51 44
52struct perf_header { 45struct perf_header {
53 int frozen; 46 int frozen;
54 int attrs, size;
55 bool needs_swap; 47 bool needs_swap;
56 struct perf_header_attr **attr;
57 s64 attr_offset; 48 s64 attr_offset;
58 u64 data_offset; 49 u64 data_offset;
59 u64 data_size; 50 u64 data_size;
@@ -62,35 +53,25 @@ struct perf_header {
62 DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS); 53 DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
63}; 54};
64 55
65int perf_header__init(struct perf_header *self);
66void perf_header__exit(struct perf_header *self);
67
68struct perf_evlist; 56struct perf_evlist;
69 57
70int perf_header__read(struct perf_session *session, int fd); 58int perf_session__read_header(struct perf_session *session, int fd);
71int perf_header__write(struct perf_header *self, struct perf_evlist *evlist, 59int perf_session__write_header(struct perf_session *session,
72 int fd, bool at_exit); 60 struct perf_evlist *evlist,
61 int fd, bool at_exit);
73int perf_header__write_pipe(int fd); 62int perf_header__write_pipe(int fd);
74 63
75int perf_header__add_attr(struct perf_header *self,
76 struct perf_header_attr *attr);
77
78int perf_header__push_event(u64 id, const char *name); 64int perf_header__push_event(u64 id, const char *name);
79char *perf_header__find_event(u64 id); 65char *perf_header__find_event(u64 id);
80 66
81struct perf_header_attr *perf_header_attr__new(struct perf_event_attr *attr); 67u64 perf_evlist__sample_type(struct perf_evlist *evlist);
82void perf_header_attr__delete(struct perf_header_attr *self); 68bool perf_evlist__sample_id_all(const struct perf_evlist *evlist);
69void perf_header__set_feat(struct perf_header *header, int feat);
70void perf_header__clear_feat(struct perf_header *header, int feat);
71bool perf_header__has_feat(const struct perf_header *header, int feat);
83 72
84int perf_header_attr__add_id(struct perf_header_attr *self, u64 id); 73int perf_header__process_sections(struct perf_header *header, int fd,
85 74 int (*process)(struct perf_file_section *section,
86u64 perf_header__sample_type(struct perf_header *header);
87bool perf_header__sample_id_all(const struct perf_header *header);
88void perf_header__set_feat(struct perf_header *self, int feat);
89void perf_header__clear_feat(struct perf_header *self, int feat);
90bool perf_header__has_feat(const struct perf_header *self, int feat);
91
92int perf_header__process_sections(struct perf_header *self, int fd,
93 int (*process)(struct perf_file_section *self,
94 struct perf_header *ph, 75 struct perf_header *ph,
95 int feat, int fd)); 76 int feat, int fd));
96 77
@@ -101,9 +82,8 @@ int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
101int perf_event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id, 82int perf_event__synthesize_attr(struct perf_event_attr *attr, u16 ids, u64 *id,
102 perf_event__handler_t process, 83 perf_event__handler_t process,
103 struct perf_session *session); 84 struct perf_session *session);
104int perf_event__synthesize_attrs(struct perf_header *self, 85int perf_session__synthesize_attrs(struct perf_session *session,
105 perf_event__handler_t process, 86 perf_event__handler_t process);
106 struct perf_session *session);
107int perf_event__process_attr(union perf_event *event, struct perf_session *session); 87int perf_event__process_attr(union perf_event *event, struct perf_session *session);
108 88
109int perf_event__synthesize_event_type(u64 event_id, char *name, 89int perf_event__synthesize_event_type(u64 event_id, char *name,
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 0d414199889d..f26639fa0fb3 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -13,46 +13,6 @@
13#include "sort.h" 13#include "sort.h"
14#include "util.h" 14#include "util.h"
15 15
16static int perf_session__read_evlist(struct perf_session *session)
17{
18 int i, j;
19
20 session->evlist = perf_evlist__new(NULL, NULL);
21 if (session->evlist == NULL)
22 return -ENOMEM;
23
24 for (i = 0; i < session->header.attrs; ++i) {
25 struct perf_header_attr *hattr = session->header.attr[i];
26 struct perf_evsel *evsel = perf_evsel__new(&hattr->attr, i);
27
28 if (evsel == NULL)
29 goto out_delete_evlist;
30 /*
31 * Do it before so that if perf_evsel__alloc_id fails, this
32 * entry gets purged too at perf_evlist__delete().
33 */
34 perf_evlist__add(session->evlist, evsel);
35 /*
36 * We don't have the cpu and thread maps on the header, so
37 * for allocating the perf_sample_id table we fake 1 cpu and
38 * hattr->ids threads.
39 */
40 if (perf_evsel__alloc_id(evsel, 1, hattr->ids))
41 goto out_delete_evlist;
42
43 for (j = 0; j < hattr->ids; ++j)
44 perf_evlist__id_hash(session->evlist, evsel, 0, j,
45 hattr->id[j]);
46 }
47
48 return 0;
49
50out_delete_evlist:
51 perf_evlist__delete(session->evlist);
52 session->evlist = NULL;
53 return -ENOMEM;
54}
55
56static int perf_session__open(struct perf_session *self, bool force) 16static int perf_session__open(struct perf_session *self, bool force)
57{ 17{
58 struct stat input_stat; 18 struct stat input_stat;
@@ -61,7 +21,7 @@ static int perf_session__open(struct perf_session *self, bool force)
61 self->fd_pipe = true; 21 self->fd_pipe = true;
62 self->fd = STDIN_FILENO; 22 self->fd = STDIN_FILENO;
63 23
64 if (perf_header__read(self, self->fd) < 0) 24 if (perf_session__read_header(self, self->fd) < 0)
65 pr_err("incompatible file format"); 25 pr_err("incompatible file format");
66 26
67 return 0; 27 return 0;
@@ -93,16 +53,11 @@ static int perf_session__open(struct perf_session *self, bool force)
93 goto out_close; 53 goto out_close;
94 } 54 }
95 55
96 if (perf_header__read(self, self->fd) < 0) { 56 if (perf_session__read_header(self, self->fd) < 0) {
97 pr_err("incompatible file format"); 57 pr_err("incompatible file format");
98 goto out_close; 58 goto out_close;
99 } 59 }
100 60
101 if (perf_session__read_evlist(self) < 0) {
102 pr_err("Not enough memory to read the event selector list\n");
103 goto out_close;
104 }
105
106 self->size = input_stat.st_size; 61 self->size = input_stat.st_size;
107 return 0; 62 return 0;
108 63
@@ -139,21 +94,10 @@ out:
139 session->id_hdr_size = size; 94 session->id_hdr_size = size;
140} 95}
141 96
142void perf_session__set_sample_id_all(struct perf_session *session, bool value)
143{
144 session->sample_id_all = value;
145 perf_session__id_header_size(session);
146}
147
148void perf_session__set_sample_type(struct perf_session *session, u64 type)
149{
150 session->sample_type = type;
151}
152
153void perf_session__update_sample_type(struct perf_session *self) 97void perf_session__update_sample_type(struct perf_session *self)
154{ 98{
155 self->sample_type = perf_header__sample_type(&self->header); 99 self->sample_type = perf_evlist__sample_type(self->evlist);
156 self->sample_id_all = perf_header__sample_id_all(&self->header); 100 self->sample_id_all = perf_evlist__sample_id_all(self->evlist);
157 perf_session__id_header_size(self); 101 perf_session__id_header_size(self);
158} 102}
159 103
@@ -182,9 +126,6 @@ struct perf_session *perf_session__new(const char *filename, int mode,
182 if (self == NULL) 126 if (self == NULL)
183 goto out; 127 goto out;
184 128
185 if (perf_header__init(&self->header) < 0)
186 goto out_free;
187
188 memcpy(self->filename, filename, len); 129 memcpy(self->filename, filename, len);
189 self->threads = RB_ROOT; 130 self->threads = RB_ROOT;
190 INIT_LIST_HEAD(&self->dead_threads); 131 INIT_LIST_HEAD(&self->dead_threads);
@@ -208,6 +149,7 @@ struct perf_session *perf_session__new(const char *filename, int mode,
208 if (mode == O_RDONLY) { 149 if (mode == O_RDONLY) {
209 if (perf_session__open(self, force) < 0) 150 if (perf_session__open(self, force) < 0)
210 goto out_delete; 151 goto out_delete;
152 perf_session__update_sample_type(self);
211 } else if (mode == O_WRONLY) { 153 } else if (mode == O_WRONLY) {
212 /* 154 /*
213 * In O_RDONLY mode this will be performed when reading the 155 * In O_RDONLY mode this will be performed when reading the
@@ -217,8 +159,6 @@ struct perf_session *perf_session__new(const char *filename, int mode,
217 goto out_delete; 159 goto out_delete;
218 } 160 }
219 161
220 perf_session__update_sample_type(self);
221
222 if (ops && ops->ordering_requires_timestamps && 162 if (ops && ops->ordering_requires_timestamps &&
223 ops->ordered_samples && !self->sample_id_all) { 163 ops->ordered_samples && !self->sample_id_all) {
224 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n"); 164 dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
@@ -227,9 +167,6 @@ struct perf_session *perf_session__new(const char *filename, int mode,
227 167
228out: 168out:
229 return self; 169 return self;
230out_free:
231 free(self);
232 return NULL;
233out_delete: 170out_delete:
234 perf_session__delete(self); 171 perf_session__delete(self);
235 return NULL; 172 return NULL;
@@ -260,7 +197,6 @@ static void perf_session__delete_threads(struct perf_session *self)
260 197
261void perf_session__delete(struct perf_session *self) 198void perf_session__delete(struct perf_session *self)
262{ 199{
263 perf_header__exit(&self->header);
264 perf_session__destroy_kernel_maps(self); 200 perf_session__destroy_kernel_maps(self);
265 perf_session__delete_dead_threads(self); 201 perf_session__delete_dead_threads(self);
266 perf_session__delete_threads(self); 202 perf_session__delete_threads(self);
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 05dd7bcb9453..b5b148b0aaca 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -112,8 +112,6 @@ void mem_bswap_64(void *src, int byte_size);
112int perf_session__create_kernel_maps(struct perf_session *self); 112int perf_session__create_kernel_maps(struct perf_session *self);
113 113
114void perf_session__update_sample_type(struct perf_session *self); 114void perf_session__update_sample_type(struct perf_session *self);
115void perf_session__set_sample_id_all(struct perf_session *session, bool value);
116void perf_session__set_sample_type(struct perf_session *session, u64 type);
117void perf_session__remove_thread(struct perf_session *self, struct thread *th); 115void perf_session__remove_thread(struct perf_session *self, struct thread *th);
118 116
119static inline 117static inline
diff --git a/tools/perf/util/top.c b/tools/perf/util/top.c
index 70a9c13f4ad5..75cfe4d45119 100644
--- a/tools/perf/util/top.c
+++ b/tools/perf/util/top.c
@@ -61,6 +61,12 @@ static void rb_insert_active_sym(struct rb_root *tree, struct sym_entry *se)
61 rb_insert_color(&se->rb_node, tree); 61 rb_insert_color(&se->rb_node, tree);
62} 62}
63 63
64#define SNPRINTF(buf, size, fmt, args...) \
65({ \
66 size_t r = snprintf(buf, size, fmt, ## args); \
67 r > size ? size : r; \
68})
69
64size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size) 70size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
65{ 71{
66 struct perf_evsel *counter; 72 struct perf_evsel *counter;
@@ -70,7 +76,7 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
70 size_t ret = 0; 76 size_t ret = 0;
71 77
72 if (!perf_guest) { 78 if (!perf_guest) {
73 ret = snprintf(bf, size, 79 ret = SNPRINTF(bf, size,
74 " PerfTop:%8.0f irqs/sec kernel:%4.1f%%" 80 " PerfTop:%8.0f irqs/sec kernel:%4.1f%%"
75 " exact: %4.1f%% [", samples_per_sec, 81 " exact: %4.1f%% [", samples_per_sec,
76 100.0 - (100.0 * ((samples_per_sec - ksamples_per_sec) / 82 100.0 - (100.0 * ((samples_per_sec - ksamples_per_sec) /
@@ -81,7 +87,7 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
81 float guest_kernel_samples_per_sec = top->guest_kernel_samples / top->delay_secs; 87 float guest_kernel_samples_per_sec = top->guest_kernel_samples / top->delay_secs;
82 float guest_us_samples_per_sec = top->guest_us_samples / top->delay_secs; 88 float guest_us_samples_per_sec = top->guest_us_samples / top->delay_secs;
83 89
84 ret = snprintf(bf, size, 90 ret = SNPRINTF(bf, size,
85 " PerfTop:%8.0f irqs/sec kernel:%4.1f%% us:%4.1f%%" 91 " PerfTop:%8.0f irqs/sec kernel:%4.1f%% us:%4.1f%%"
86 " guest kernel:%4.1f%% guest us:%4.1f%%" 92 " guest kernel:%4.1f%% guest us:%4.1f%%"
87 " exact: %4.1f%% [", samples_per_sec, 93 " exact: %4.1f%% [", samples_per_sec,
@@ -101,38 +107,52 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
101 if (top->evlist->nr_entries == 1 || !top->display_weighted) { 107 if (top->evlist->nr_entries == 1 || !top->display_weighted) {
102 struct perf_evsel *first; 108 struct perf_evsel *first;
103 first = list_entry(top->evlist->entries.next, struct perf_evsel, node); 109 first = list_entry(top->evlist->entries.next, struct perf_evsel, node);
104 ret += snprintf(bf + ret, size - ret, "%" PRIu64 "%s ", 110 ret += SNPRINTF(bf + ret, size - ret, "%" PRIu64 "%s ",
105 (uint64_t)first->attr.sample_period, 111 (uint64_t)first->attr.sample_period,
106 top->freq ? "Hz" : ""); 112 top->freq ? "Hz" : "");
107 } 113 }
108 114
109 if (!top->display_weighted) { 115 if (!top->display_weighted) {
110 ret += snprintf(bf + ret, size - ret, "%s", 116 ret += SNPRINTF(bf + ret, size - ret, "%s",
111 event_name(top->sym_evsel)); 117 event_name(top->sym_evsel));
112 } else list_for_each_entry(counter, &top->evlist->entries, node) { 118 } else {
113 ret += snprintf(bf + ret, size - ret, "%s%s", 119 /*
114 counter->idx ? "/" : "", event_name(counter)); 120 * Don't let events eat all the space. Leaving 30 bytes
121 * for the rest should be enough.
122 */
123 size_t last_pos = size - 30;
124
125 list_for_each_entry(counter, &top->evlist->entries, node) {
126 ret += SNPRINTF(bf + ret, size - ret, "%s%s",
127 counter->idx ? "/" : "",
128 event_name(counter));
129 if (ret > last_pos) {
130 sprintf(bf + last_pos - 3, "..");
131 ret = last_pos - 1;
132 break;
133 }
134 }
115 } 135 }
116 136
117 ret += snprintf(bf + ret, size - ret, "], "); 137 ret += SNPRINTF(bf + ret, size - ret, "], ");
118 138
119 if (top->target_pid != -1) 139 if (top->target_pid != -1)
120 ret += snprintf(bf + ret, size - ret, " (target_pid: %d", 140 ret += SNPRINTF(bf + ret, size - ret, " (target_pid: %d",
121 top->target_pid); 141 top->target_pid);
122 else if (top->target_tid != -1) 142 else if (top->target_tid != -1)
123 ret += snprintf(bf + ret, size - ret, " (target_tid: %d", 143 ret += SNPRINTF(bf + ret, size - ret, " (target_tid: %d",
124 top->target_tid); 144 top->target_tid);
125 else 145 else
126 ret += snprintf(bf + ret, size - ret, " (all"); 146 ret += SNPRINTF(bf + ret, size - ret, " (all");
127 147
128 if (top->cpu_list) 148 if (top->cpu_list)
129 ret += snprintf(bf + ret, size - ret, ", CPU%s: %s)", 149 ret += SNPRINTF(bf + ret, size - ret, ", CPU%s: %s)",
130 top->evlist->cpus->nr > 1 ? "s" : "", top->cpu_list); 150 top->evlist->cpus->nr > 1 ? "s" : "", top->cpu_list);
131 else { 151 else {
132 if (top->target_tid != -1) 152 if (top->target_tid != -1)
133 ret += snprintf(bf + ret, size - ret, ")"); 153 ret += SNPRINTF(bf + ret, size - ret, ")");
134 else 154 else
135 ret += snprintf(bf + ret, size - ret, ", %d CPU%s)", 155 ret += SNPRINTF(bf + ret, size - ret, ", %d CPU%s)",
136 top->evlist->cpus->nr, 156 top->evlist->cpus->nr,
137 top->evlist->cpus->nr > 1 ? "s" : ""); 157 top->evlist->cpus->nr > 1 ? "s" : "");
138 } 158 }
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-24 18:11:01 -0500