blob: 179b2bdd157dac0adc33faf62fbe85c3853aa19f [file] [log] [blame]
Arnaldo Carvalho de Meloa9072bc2011-10-26 12:41:38 -02001#include "util.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002#include <sys/types.h>
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02003#include <byteswap.h>
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02004#include <unistd.h>
5#include <stdio.h>
6#include <stdlib.h>
Frederic Weisbecker8671dab2009-11-11 04:51:03 +01007#include <linux/list.h>
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02008#include <linux/kernel.h>
Robert Richterb1e5a9b2011-12-07 10:02:57 +01009#include <linux/bitops.h>
Stephane Eranianfbe96f22011-09-30 15:40:40 +020010#include <sys/utsname.h>
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020011
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -020012#include "evlist.h"
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -030013#include "evsel.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020014#include "header.h"
Frederic Weisbecker03456a12009-10-06 23:36:47 +020015#include "../perf.h"
16#include "trace-event.h"
Arnaldo Carvalho de Melo301a0b02009-12-13 19:50:25 -020017#include "session.h"
Frederic Weisbecker8671dab2009-11-11 04:51:03 +010018#include "symbol.h"
Frederic Weisbecker4778d2e2009-11-11 04:51:05 +010019#include "debug.h"
Stephane Eranianfbe96f22011-09-30 15:40:40 +020020#include "cpumap.h"
Robert Richter50a96672012-08-16 21:10:24 +020021#include "pmu.h"
Jiri Olsa7dbf4dc2012-09-10 18:50:19 +020022#include "vdso.h"
Namhyung Kima1ae5652012-09-24 17:14:59 +090023#include "strbuf.h"
Jiri Olsaebb296c2012-10-27 23:18:28 +020024#include "build-id.h"
Jiri Olsacc9784bd2013-10-15 16:27:34 +020025#include "data.h"
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020026
Stephane Eranianfbe96f22011-09-30 15:40:40 +020027static u32 header_argc;
28static const char **header_argv;
29
Stephane Eranian73323f52012-02-02 13:54:44 +010030/*
31 * magic2 = "PERFILE2"
32 * must be a numerical value to let the endianness
33 * determine the memory layout. That way we are able
34 * to detect endianness when reading the perf.data file
35 * back.
36 *
37 * we check for legacy (PERFFILE) format.
38 */
39static const char *__perf_magic1 = "PERFFILE";
40static const u64 __perf_magic2 = 0x32454c4946524550ULL;
41static const u64 __perf_magic2_sw = 0x50455246494c4532ULL;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020042
Stephane Eranian73323f52012-02-02 13:54:44 +010043#define PERF_MAGIC __perf_magic2
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020044
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020045struct perf_file_attr {
Ingo Molnarcdd6c482009-09-21 12:02:48 +020046 struct perf_event_attr attr;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020047 struct perf_file_section ids;
48};
49
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -030050void perf_header__set_feat(struct perf_header *header, int feat)
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020051{
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -030052 set_bit(feat, header->adds_features);
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020053}
54
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -030055void perf_header__clear_feat(struct perf_header *header, int feat)
Arnaldo Carvalho de Melobaa2f6c2010-11-26 19:39:15 -020056{
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -030057 clear_bit(feat, header->adds_features);
Arnaldo Carvalho de Melobaa2f6c2010-11-26 19:39:15 -020058}
59
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -030060bool perf_header__has_feat(const struct perf_header *header, int feat)
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020061{
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -030062 return test_bit(feat, header->adds_features);
Arnaldo Carvalho de Melo8d063672009-11-04 18:50:43 -020063}
64
Arnaldo Carvalho de Melo3726cc72009-11-17 01:18:12 -020065static int do_write(int fd, const void *buf, size_t size)
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020066{
67 while (size) {
68 int ret = write(fd, buf, size);
69
70 if (ret < 0)
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -020071 return -errno;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020072
73 size -= ret;
74 buf += ret;
75 }
Arnaldo Carvalho de Melo3726cc72009-11-17 01:18:12 -020076
77 return 0;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +020078}
79
Namhyung Kime195fac2014-11-04 10:14:30 +090080int write_padded(int fd, const void *bf, size_t count, size_t count_aligned)
Arnaldo Carvalho de Melof92cb242010-01-04 16:19:28 -020081{
82 static const char zero_buf[NAME_ALIGN];
83 int err = do_write(fd, bf, count);
84
85 if (!err)
86 err = do_write(fd, zero_buf, count_aligned - count);
87
88 return err;
89}
90
Stephane Eranianfbe96f22011-09-30 15:40:40 +020091static int do_write_string(int fd, const char *str)
92{
93 u32 len, olen;
94 int ret;
95
96 olen = strlen(str) + 1;
Irina Tirdea9ac3e482012-09-11 01:15:01 +030097 len = PERF_ALIGN(olen, NAME_ALIGN);
Stephane Eranianfbe96f22011-09-30 15:40:40 +020098
99 /* write len, incl. \0 */
100 ret = do_write(fd, &len, sizeof(len));
101 if (ret < 0)
102 return ret;
103
104 return write_padded(fd, str, olen, len);
105}
106
107static char *do_read_string(int fd, struct perf_header *ph)
108{
109 ssize_t sz, ret;
110 u32 len;
111 char *buf;
112
Namhyung Kim5323f602012-12-17 15:38:54 +0900113 sz = readn(fd, &len, sizeof(len));
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200114 if (sz < (ssize_t)sizeof(len))
115 return NULL;
116
117 if (ph->needs_swap)
118 len = bswap_32(len);
119
120 buf = malloc(len);
121 if (!buf)
122 return NULL;
123
Namhyung Kim5323f602012-12-17 15:38:54 +0900124 ret = readn(fd, buf, len);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200125 if (ret == (ssize_t)len) {
126 /*
127 * strings are padded by zeroes
128 * thus the actual strlen of buf
129 * may be less than len
130 */
131 return buf;
132 }
133
134 free(buf);
135 return NULL;
136}
137
138int
139perf_header__set_cmdline(int argc, const char **argv)
140{
141 int i;
142
David Ahern56e6f602012-07-29 20:53:51 -0600143 /*
144 * If header_argv has already been set, do not override it.
145 * This allows a command to set the cmdline, parse args and
146 * then call another builtin function that implements a
147 * command -- e.g, cmd_kvm calling cmd_record.
148 */
149 if (header_argv)
150 return 0;
151
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200152 header_argc = (u32)argc;
153
154 /* do not include NULL termination */
155 header_argv = calloc(argc, sizeof(char *));
156 if (!header_argv)
157 return -ENOMEM;
158
159 /*
160 * must copy argv contents because it gets moved
161 * around during option parsing
162 */
163 for (i = 0; i < argc ; i++)
164 header_argv[i] = argv[i];
165
166 return 0;
167}
168
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300169static int write_tracing_data(int fd, struct perf_header *h __maybe_unused,
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200170 struct perf_evlist *evlist)
171{
172 return read_tracing_data(fd, &evlist->entries);
173}
174
175
176static int write_build_id(int fd, struct perf_header *h,
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300177 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200178{
179 struct perf_session *session;
180 int err;
181
182 session = container_of(h, struct perf_session, header);
183
Robert Richtere20960c2011-12-07 10:02:55 +0100184 if (!perf_session__read_build_ids(session, true))
185 return -1;
186
Namhyung Kim714c9c42014-11-04 10:14:29 +0900187 err = perf_session__write_buildid_table(session, fd);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200188 if (err < 0) {
189 pr_debug("failed to write buildid table\n");
190 return err;
191 }
Namhyung Kim73c5d222014-11-07 22:57:56 +0900192 perf_session__cache_build_ids(session);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200193
194 return 0;
195}
196
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300197static int write_hostname(int fd, struct perf_header *h __maybe_unused,
198 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200199{
200 struct utsname uts;
201 int ret;
202
203 ret = uname(&uts);
204 if (ret < 0)
205 return -1;
206
207 return do_write_string(fd, uts.nodename);
208}
209
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300210static int write_osrelease(int fd, struct perf_header *h __maybe_unused,
211 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200212{
213 struct utsname uts;
214 int ret;
215
216 ret = uname(&uts);
217 if (ret < 0)
218 return -1;
219
220 return do_write_string(fd, uts.release);
221}
222
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300223static int write_arch(int fd, struct perf_header *h __maybe_unused,
224 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200225{
226 struct utsname uts;
227 int ret;
228
229 ret = uname(&uts);
230 if (ret < 0)
231 return -1;
232
233 return do_write_string(fd, uts.machine);
234}
235
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300236static int write_version(int fd, struct perf_header *h __maybe_unused,
237 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200238{
239 return do_write_string(fd, perf_version_string);
240}
241
Wang Nan493c3032014-10-24 09:45:26 +0800242static int __write_cpudesc(int fd, const char *cpuinfo_proc)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200243{
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200244 FILE *file;
245 char *buf = NULL;
246 char *s, *p;
Wang Nan493c3032014-10-24 09:45:26 +0800247 const char *search = cpuinfo_proc;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200248 size_t len = 0;
249 int ret = -1;
250
251 if (!search)
252 return -1;
253
254 file = fopen("/proc/cpuinfo", "r");
255 if (!file)
256 return -1;
257
258 while (getline(&buf, &len, file) > 0) {
259 ret = strncmp(buf, search, strlen(search));
260 if (!ret)
261 break;
262 }
263
Wang Naned307752014-10-16 11:08:29 +0800264 if (ret) {
265 ret = -1;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200266 goto done;
Wang Naned307752014-10-16 11:08:29 +0800267 }
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200268
269 s = buf;
270
271 p = strchr(buf, ':');
272 if (p && *(p+1) == ' ' && *(p+2))
273 s = p + 2;
274 p = strchr(s, '\n');
275 if (p)
276 *p = '\0';
277
278 /* squash extra space characters (branding string) */
279 p = s;
280 while (*p) {
281 if (isspace(*p)) {
282 char *r = p + 1;
283 char *q = r;
284 *p = ' ';
285 while (*q && isspace(*q))
286 q++;
287 if (q != (p+1))
288 while ((*r++ = *q++));
289 }
290 p++;
291 }
292 ret = do_write_string(fd, s);
293done:
294 free(buf);
295 fclose(file);
296 return ret;
297}
298
Wang Nan493c3032014-10-24 09:45:26 +0800299static int write_cpudesc(int fd, struct perf_header *h __maybe_unused,
300 struct perf_evlist *evlist __maybe_unused)
301{
302#ifndef CPUINFO_PROC
303#define CPUINFO_PROC {"model name", }
304#endif
305 const char *cpuinfo_procs[] = CPUINFO_PROC;
306 unsigned int i;
307
308 for (i = 0; i < ARRAY_SIZE(cpuinfo_procs); i++) {
309 int ret;
310 ret = __write_cpudesc(fd, cpuinfo_procs[i]);
311 if (ret >= 0)
312 return ret;
313 }
314 return -1;
315}
316
317
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300318static int write_nrcpus(int fd, struct perf_header *h __maybe_unused,
319 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200320{
321 long nr;
322 u32 nrc, nra;
323 int ret;
324
325 nr = sysconf(_SC_NPROCESSORS_CONF);
326 if (nr < 0)
327 return -1;
328
329 nrc = (u32)(nr & UINT_MAX);
330
331 nr = sysconf(_SC_NPROCESSORS_ONLN);
332 if (nr < 0)
333 return -1;
334
335 nra = (u32)(nr & UINT_MAX);
336
337 ret = do_write(fd, &nrc, sizeof(nrc));
338 if (ret < 0)
339 return ret;
340
341 return do_write(fd, &nra, sizeof(nra));
342}
343
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300344static int write_event_desc(int fd, struct perf_header *h __maybe_unused,
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200345 struct perf_evlist *evlist)
346{
Robert Richter6606f872012-08-16 21:10:19 +0200347 struct perf_evsel *evsel;
Namhyung Kim74ba9e12012-09-05 14:02:47 +0900348 u32 nre, nri, sz;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200349 int ret;
350
Namhyung Kim74ba9e12012-09-05 14:02:47 +0900351 nre = evlist->nr_entries;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200352
353 /*
354 * write number of events
355 */
356 ret = do_write(fd, &nre, sizeof(nre));
357 if (ret < 0)
358 return ret;
359
360 /*
361 * size of perf_event_attr struct
362 */
Robert Richter6606f872012-08-16 21:10:19 +0200363 sz = (u32)sizeof(evsel->attr);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200364 ret = do_write(fd, &sz, sizeof(sz));
365 if (ret < 0)
366 return ret;
367
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -0300368 evlist__for_each(evlist, evsel) {
Robert Richter6606f872012-08-16 21:10:19 +0200369 ret = do_write(fd, &evsel->attr, sz);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200370 if (ret < 0)
371 return ret;
372 /*
373 * write number of unique id per event
374 * there is one id per instance of an event
375 *
376 * copy into an nri to be independent of the
377 * type of ids,
378 */
Robert Richter6606f872012-08-16 21:10:19 +0200379 nri = evsel->ids;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200380 ret = do_write(fd, &nri, sizeof(nri));
381 if (ret < 0)
382 return ret;
383
384 /*
385 * write event string as passed on cmdline
386 */
Robert Richter6606f872012-08-16 21:10:19 +0200387 ret = do_write_string(fd, perf_evsel__name(evsel));
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200388 if (ret < 0)
389 return ret;
390 /*
391 * write unique ids for this event
392 */
Robert Richter6606f872012-08-16 21:10:19 +0200393 ret = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200394 if (ret < 0)
395 return ret;
396 }
397 return 0;
398}
399
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300400static int write_cmdline(int fd, struct perf_header *h __maybe_unused,
401 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200402{
403 char buf[MAXPATHLEN];
404 char proc[32];
405 u32 i, n;
406 int ret;
407
408 /*
409 * actual atual path to perf binary
410 */
411 sprintf(proc, "/proc/%d/exe", getpid());
412 ret = readlink(proc, buf, sizeof(buf));
413 if (ret <= 0)
414 return -1;
415
416 /* readlink() does not add null termination */
417 buf[ret] = '\0';
418
419 /* account for binary path */
420 n = header_argc + 1;
421
422 ret = do_write(fd, &n, sizeof(n));
423 if (ret < 0)
424 return ret;
425
426 ret = do_write_string(fd, buf);
427 if (ret < 0)
428 return ret;
429
430 for (i = 0 ; i < header_argc; i++) {
431 ret = do_write_string(fd, header_argv[i]);
432 if (ret < 0)
433 return ret;
434 }
435 return 0;
436}
437
438#define CORE_SIB_FMT \
439 "/sys/devices/system/cpu/cpu%d/topology/core_siblings_list"
440#define THRD_SIB_FMT \
441 "/sys/devices/system/cpu/cpu%d/topology/thread_siblings_list"
442
443struct cpu_topo {
444 u32 core_sib;
445 u32 thread_sib;
446 char **core_siblings;
447 char **thread_siblings;
448};
449
450static int build_cpu_topo(struct cpu_topo *tp, int cpu)
451{
452 FILE *fp;
453 char filename[MAXPATHLEN];
454 char *buf = NULL, *p;
455 size_t len = 0;
Stephane Eranianc5885742013-08-14 12:04:26 +0200456 ssize_t sret;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200457 u32 i = 0;
458 int ret = -1;
459
460 sprintf(filename, CORE_SIB_FMT, cpu);
461 fp = fopen(filename, "r");
462 if (!fp)
Stephane Eranianc5885742013-08-14 12:04:26 +0200463 goto try_threads;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200464
Stephane Eranianc5885742013-08-14 12:04:26 +0200465 sret = getline(&buf, &len, fp);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200466 fclose(fp);
Stephane Eranianc5885742013-08-14 12:04:26 +0200467 if (sret <= 0)
468 goto try_threads;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200469
470 p = strchr(buf, '\n');
471 if (p)
472 *p = '\0';
473
474 for (i = 0; i < tp->core_sib; i++) {
475 if (!strcmp(buf, tp->core_siblings[i]))
476 break;
477 }
478 if (i == tp->core_sib) {
479 tp->core_siblings[i] = buf;
480 tp->core_sib++;
481 buf = NULL;
482 len = 0;
483 }
Stephane Eranianc5885742013-08-14 12:04:26 +0200484 ret = 0;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200485
Stephane Eranianc5885742013-08-14 12:04:26 +0200486try_threads:
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200487 sprintf(filename, THRD_SIB_FMT, cpu);
488 fp = fopen(filename, "r");
489 if (!fp)
490 goto done;
491
492 if (getline(&buf, &len, fp) <= 0)
493 goto done;
494
495 p = strchr(buf, '\n');
496 if (p)
497 *p = '\0';
498
499 for (i = 0; i < tp->thread_sib; i++) {
500 if (!strcmp(buf, tp->thread_siblings[i]))
501 break;
502 }
503 if (i == tp->thread_sib) {
504 tp->thread_siblings[i] = buf;
505 tp->thread_sib++;
506 buf = NULL;
507 }
508 ret = 0;
509done:
510 if(fp)
511 fclose(fp);
512 free(buf);
513 return ret;
514}
515
516static void free_cpu_topo(struct cpu_topo *tp)
517{
518 u32 i;
519
520 if (!tp)
521 return;
522
523 for (i = 0 ; i < tp->core_sib; i++)
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -0300524 zfree(&tp->core_siblings[i]);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200525
526 for (i = 0 ; i < tp->thread_sib; i++)
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -0300527 zfree(&tp->thread_siblings[i]);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200528
529 free(tp);
530}
531
532static struct cpu_topo *build_cpu_topology(void)
533{
534 struct cpu_topo *tp;
535 void *addr;
536 u32 nr, i;
537 size_t sz;
538 long ncpus;
539 int ret = -1;
540
541 ncpus = sysconf(_SC_NPROCESSORS_CONF);
542 if (ncpus < 0)
543 return NULL;
544
545 nr = (u32)(ncpus & UINT_MAX);
546
547 sz = nr * sizeof(char *);
548
549 addr = calloc(1, sizeof(*tp) + 2 * sz);
550 if (!addr)
551 return NULL;
552
553 tp = addr;
554
555 addr += sizeof(*tp);
556 tp->core_siblings = addr;
557 addr += sz;
558 tp->thread_siblings = addr;
559
560 for (i = 0; i < nr; i++) {
561 ret = build_cpu_topo(tp, i);
562 if (ret < 0)
563 break;
564 }
565 if (ret) {
566 free_cpu_topo(tp);
567 tp = NULL;
568 }
569 return tp;
570}
571
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300572static int write_cpu_topology(int fd, struct perf_header *h __maybe_unused,
573 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200574{
575 struct cpu_topo *tp;
576 u32 i;
577 int ret;
578
579 tp = build_cpu_topology();
580 if (!tp)
581 return -1;
582
583 ret = do_write(fd, &tp->core_sib, sizeof(tp->core_sib));
584 if (ret < 0)
585 goto done;
586
587 for (i = 0; i < tp->core_sib; i++) {
588 ret = do_write_string(fd, tp->core_siblings[i]);
589 if (ret < 0)
590 goto done;
591 }
592 ret = do_write(fd, &tp->thread_sib, sizeof(tp->thread_sib));
593 if (ret < 0)
594 goto done;
595
596 for (i = 0; i < tp->thread_sib; i++) {
597 ret = do_write_string(fd, tp->thread_siblings[i]);
598 if (ret < 0)
599 break;
600 }
601done:
602 free_cpu_topo(tp);
603 return ret;
604}
605
606
607
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300608static int write_total_mem(int fd, struct perf_header *h __maybe_unused,
609 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200610{
611 char *buf = NULL;
612 FILE *fp;
613 size_t len = 0;
614 int ret = -1, n;
615 uint64_t mem;
616
617 fp = fopen("/proc/meminfo", "r");
618 if (!fp)
619 return -1;
620
621 while (getline(&buf, &len, fp) > 0) {
622 ret = strncmp(buf, "MemTotal:", 9);
623 if (!ret)
624 break;
625 }
626 if (!ret) {
627 n = sscanf(buf, "%*s %"PRIu64, &mem);
628 if (n == 1)
629 ret = do_write(fd, &mem, sizeof(mem));
Wang Naned307752014-10-16 11:08:29 +0800630 } else
631 ret = -1;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200632 free(buf);
633 fclose(fp);
634 return ret;
635}
636
637static int write_topo_node(int fd, int node)
638{
639 char str[MAXPATHLEN];
640 char field[32];
641 char *buf = NULL, *p;
642 size_t len = 0;
643 FILE *fp;
644 u64 mem_total, mem_free, mem;
645 int ret = -1;
646
647 sprintf(str, "/sys/devices/system/node/node%d/meminfo", node);
648 fp = fopen(str, "r");
649 if (!fp)
650 return -1;
651
652 while (getline(&buf, &len, fp) > 0) {
653 /* skip over invalid lines */
654 if (!strchr(buf, ':'))
655 continue;
Alan Coxa761a2d2014-01-20 19:10:11 +0100656 if (sscanf(buf, "%*s %*d %31s %"PRIu64, field, &mem) != 2)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200657 goto done;
658 if (!strcmp(field, "MemTotal:"))
659 mem_total = mem;
660 if (!strcmp(field, "MemFree:"))
661 mem_free = mem;
662 }
663
664 fclose(fp);
Thomas Jarosch5809fde2013-01-28 10:21:14 +0100665 fp = NULL;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200666
667 ret = do_write(fd, &mem_total, sizeof(u64));
668 if (ret)
669 goto done;
670
671 ret = do_write(fd, &mem_free, sizeof(u64));
672 if (ret)
673 goto done;
674
675 ret = -1;
676 sprintf(str, "/sys/devices/system/node/node%d/cpulist", node);
677
678 fp = fopen(str, "r");
679 if (!fp)
680 goto done;
681
682 if (getline(&buf, &len, fp) <= 0)
683 goto done;
684
685 p = strchr(buf, '\n');
686 if (p)
687 *p = '\0';
688
689 ret = do_write_string(fd, buf);
690done:
691 free(buf);
Thomas Jarosch5809fde2013-01-28 10:21:14 +0100692 if (fp)
693 fclose(fp);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200694 return ret;
695}
696
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300697static int write_numa_topology(int fd, struct perf_header *h __maybe_unused,
698 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200699{
700 char *buf = NULL;
701 size_t len = 0;
702 FILE *fp;
703 struct cpu_map *node_map = NULL;
704 char *c;
705 u32 nr, i, j;
706 int ret = -1;
707
708 fp = fopen("/sys/devices/system/node/online", "r");
709 if (!fp)
710 return -1;
711
712 if (getline(&buf, &len, fp) <= 0)
713 goto done;
714
715 c = strchr(buf, '\n');
716 if (c)
717 *c = '\0';
718
719 node_map = cpu_map__new(buf);
720 if (!node_map)
721 goto done;
722
723 nr = (u32)node_map->nr;
724
725 ret = do_write(fd, &nr, sizeof(nr));
726 if (ret < 0)
727 goto done;
728
729 for (i = 0; i < nr; i++) {
730 j = (u32)node_map->map[i];
731 ret = do_write(fd, &j, sizeof(j));
732 if (ret < 0)
733 break;
734
735 ret = write_topo_node(fd, i);
736 if (ret < 0)
737 break;
738 }
739done:
740 free(buf);
741 fclose(fp);
742 free(node_map);
743 return ret;
744}
745
746/*
Robert Richter50a96672012-08-16 21:10:24 +0200747 * File format:
748 *
749 * struct pmu_mappings {
750 * u32 pmu_num;
751 * struct pmu_map {
752 * u32 type;
753 * char name[];
754 * }[pmu_num];
755 * };
756 */
757
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300758static int write_pmu_mappings(int fd, struct perf_header *h __maybe_unused,
759 struct perf_evlist *evlist __maybe_unused)
Robert Richter50a96672012-08-16 21:10:24 +0200760{
761 struct perf_pmu *pmu = NULL;
762 off_t offset = lseek(fd, 0, SEEK_CUR);
763 __u32 pmu_num = 0;
Namhyung Kim5323f602012-12-17 15:38:54 +0900764 int ret;
Robert Richter50a96672012-08-16 21:10:24 +0200765
766 /* write real pmu_num later */
Namhyung Kim5323f602012-12-17 15:38:54 +0900767 ret = do_write(fd, &pmu_num, sizeof(pmu_num));
768 if (ret < 0)
769 return ret;
Robert Richter50a96672012-08-16 21:10:24 +0200770
771 while ((pmu = perf_pmu__scan(pmu))) {
772 if (!pmu->name)
773 continue;
774 pmu_num++;
Namhyung Kim5323f602012-12-17 15:38:54 +0900775
776 ret = do_write(fd, &pmu->type, sizeof(pmu->type));
777 if (ret < 0)
778 return ret;
779
780 ret = do_write_string(fd, pmu->name);
781 if (ret < 0)
782 return ret;
Robert Richter50a96672012-08-16 21:10:24 +0200783 }
784
785 if (pwrite(fd, &pmu_num, sizeof(pmu_num), offset) != sizeof(pmu_num)) {
786 /* discard all */
787 lseek(fd, offset, SEEK_SET);
788 return -1;
789 }
790
791 return 0;
792}
793
794/*
Namhyung Kima8bb5592013-01-22 18:09:31 +0900795 * File format:
796 *
797 * struct group_descs {
798 * u32 nr_groups;
799 * struct group_desc {
800 * char name[];
801 * u32 leader_idx;
802 * u32 nr_members;
803 * }[nr_groups];
804 * };
805 */
806static int write_group_desc(int fd, struct perf_header *h __maybe_unused,
807 struct perf_evlist *evlist)
808{
809 u32 nr_groups = evlist->nr_groups;
810 struct perf_evsel *evsel;
811 int ret;
812
813 ret = do_write(fd, &nr_groups, sizeof(nr_groups));
814 if (ret < 0)
815 return ret;
816
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -0300817 evlist__for_each(evlist, evsel) {
Namhyung Kima8bb5592013-01-22 18:09:31 +0900818 if (perf_evsel__is_group_leader(evsel) &&
819 evsel->nr_members > 1) {
820 const char *name = evsel->group_name ?: "{anon_group}";
821 u32 leader_idx = evsel->idx;
822 u32 nr_members = evsel->nr_members;
823
824 ret = do_write_string(fd, name);
825 if (ret < 0)
826 return ret;
827
828 ret = do_write(fd, &leader_idx, sizeof(leader_idx));
829 if (ret < 0)
830 return ret;
831
832 ret = do_write(fd, &nr_members, sizeof(nr_members));
833 if (ret < 0)
834 return ret;
835 }
836 }
837 return 0;
838}
839
840/*
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200841 * default get_cpuid(): nothing gets recorded
842 * actual implementation must be in arch/$(ARCH)/util/header.c
843 */
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300844int __attribute__ ((weak)) get_cpuid(char *buffer __maybe_unused,
845 size_t sz __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200846{
847 return -1;
848}
849
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300850static int write_cpuid(int fd, struct perf_header *h __maybe_unused,
851 struct perf_evlist *evlist __maybe_unused)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200852{
853 char buffer[64];
854 int ret;
855
856 ret = get_cpuid(buffer, sizeof(buffer));
857 if (!ret)
858 goto write_it;
859
860 return -1;
861write_it:
862 return do_write_string(fd, buffer);
863}
864
Irina Tirdea1d037ca2012-09-11 01:15:03 +0300865static int write_branch_stack(int fd __maybe_unused,
866 struct perf_header *h __maybe_unused,
867 struct perf_evlist *evlist __maybe_unused)
Stephane Eranian330aa672012-03-08 23:47:46 +0100868{
869 return 0;
870}
871
Adrian Hunter99fa2982015-04-30 17:37:25 +0300872static int write_auxtrace(int fd, struct perf_header *h,
Adrian Hunter4025ea42015-04-09 18:53:41 +0300873 struct perf_evlist *evlist __maybe_unused)
874{
Adrian Hunter99fa2982015-04-30 17:37:25 +0300875 struct perf_session *session;
876 int err;
877
878 session = container_of(h, struct perf_session, header);
879
880 err = auxtrace_index__write(fd, &session->auxtrace_index);
881 if (err < 0)
882 pr_err("Failed to write auxtrace index\n");
883 return err;
Adrian Hunter4025ea42015-04-09 18:53:41 +0300884}
885
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900886static void print_hostname(struct perf_header *ph, int fd __maybe_unused,
887 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200888{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900889 fprintf(fp, "# hostname : %s\n", ph->env.hostname);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200890}
891
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900892static void print_osrelease(struct perf_header *ph, int fd __maybe_unused,
893 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200894{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900895 fprintf(fp, "# os release : %s\n", ph->env.os_release);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200896}
897
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900898static void print_arch(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200899{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900900 fprintf(fp, "# arch : %s\n", ph->env.arch);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200901}
902
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900903static void print_cpudesc(struct perf_header *ph, int fd __maybe_unused,
904 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200905{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900906 fprintf(fp, "# cpudesc : %s\n", ph->env.cpu_desc);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200907}
908
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900909static void print_nrcpus(struct perf_header *ph, int fd __maybe_unused,
910 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200911{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900912 fprintf(fp, "# nrcpus online : %u\n", ph->env.nr_cpus_online);
913 fprintf(fp, "# nrcpus avail : %u\n", ph->env.nr_cpus_avail);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200914}
915
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900916static void print_version(struct perf_header *ph, int fd __maybe_unused,
917 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200918{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900919 fprintf(fp, "# perf version : %s\n", ph->env.version);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200920}
921
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900922static void print_cmdline(struct perf_header *ph, int fd __maybe_unused,
923 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200924{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900925 int nr, i;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200926
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900927 nr = ph->env.nr_cmdline;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200928
929 fprintf(fp, "# cmdline : ");
930
Jiri Olsa768dd3f2015-07-21 14:31:31 +0200931 for (i = 0; i < nr; i++)
932 fprintf(fp, "%s ", ph->env.cmdline_argv[i]);
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200933 fputc('\n', fp);
934}
935
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900936static void print_cpu_topology(struct perf_header *ph, int fd __maybe_unused,
937 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200938{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900939 int nr, i;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200940 char *str;
941
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900942 nr = ph->env.nr_sibling_cores;
943 str = ph->env.sibling_cores;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200944
945 for (i = 0; i < nr; i++) {
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200946 fprintf(fp, "# sibling cores : %s\n", str);
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900947 str += strlen(str) + 1;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200948 }
949
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900950 nr = ph->env.nr_sibling_threads;
951 str = ph->env.sibling_threads;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200952
953 for (i = 0; i < nr; i++) {
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200954 fprintf(fp, "# sibling threads : %s\n", str);
Namhyung Kim7e94cfc2012-09-24 17:15:00 +0900955 str += strlen(str) + 1;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200956 }
957}
958
Robert Richter4e1b9c62012-08-16 21:10:22 +0200959static void free_event_desc(struct perf_evsel *events)
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200960{
Robert Richter4e1b9c62012-08-16 21:10:22 +0200961 struct perf_evsel *evsel;
962
963 if (!events)
964 return;
965
966 for (evsel = events; evsel->attr.size; evsel++) {
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -0300967 zfree(&evsel->name);
968 zfree(&evsel->id);
Robert Richter4e1b9c62012-08-16 21:10:22 +0200969 }
970
971 free(events);
972}
973
974static struct perf_evsel *
975read_event_desc(struct perf_header *ph, int fd)
976{
977 struct perf_evsel *evsel, *events = NULL;
978 u64 *id;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200979 void *buf = NULL;
Stephane Eranian62db9062012-02-09 23:21:07 +0100980 u32 nre, sz, nr, i, j;
981 ssize_t ret;
982 size_t msz;
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200983
984 /* number of events */
Namhyung Kim5323f602012-12-17 15:38:54 +0900985 ret = readn(fd, &nre, sizeof(nre));
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200986 if (ret != (ssize_t)sizeof(nre))
987 goto error;
988
989 if (ph->needs_swap)
990 nre = bswap_32(nre);
991
Namhyung Kim5323f602012-12-17 15:38:54 +0900992 ret = readn(fd, &sz, sizeof(sz));
Stephane Eranianfbe96f22011-09-30 15:40:40 +0200993 if (ret != (ssize_t)sizeof(sz))
994 goto error;
995
996 if (ph->needs_swap)
997 sz = bswap_32(sz);
998
Stephane Eranian62db9062012-02-09 23:21:07 +0100999 /* buffer to hold on file attr struct */
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001000 buf = malloc(sz);
1001 if (!buf)
1002 goto error;
1003
Robert Richter4e1b9c62012-08-16 21:10:22 +02001004 /* the last event terminates with evsel->attr.size == 0: */
1005 events = calloc(nre + 1, sizeof(*events));
1006 if (!events)
1007 goto error;
1008
1009 msz = sizeof(evsel->attr);
Jiri Olsa9fafd982012-03-20 19:15:39 +01001010 if (sz < msz)
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001011 msz = sz;
1012
Robert Richter4e1b9c62012-08-16 21:10:22 +02001013 for (i = 0, evsel = events; i < nre; evsel++, i++) {
1014 evsel->idx = i;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001015
Stephane Eranian62db9062012-02-09 23:21:07 +01001016 /*
1017 * must read entire on-file attr struct to
1018 * sync up with layout.
1019 */
Namhyung Kim5323f602012-12-17 15:38:54 +09001020 ret = readn(fd, buf, sz);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001021 if (ret != (ssize_t)sz)
1022 goto error;
1023
1024 if (ph->needs_swap)
1025 perf_event__attr_swap(buf);
1026
Robert Richter4e1b9c62012-08-16 21:10:22 +02001027 memcpy(&evsel->attr, buf, msz);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001028
Namhyung Kim5323f602012-12-17 15:38:54 +09001029 ret = readn(fd, &nr, sizeof(nr));
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001030 if (ret != (ssize_t)sizeof(nr))
1031 goto error;
1032
Arnaldo Carvalho de Melo0807d2d2012-09-26 12:48:18 -03001033 if (ph->needs_swap) {
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001034 nr = bswap_32(nr);
Arnaldo Carvalho de Melo0807d2d2012-09-26 12:48:18 -03001035 evsel->needs_swap = true;
1036 }
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001037
Robert Richter4e1b9c62012-08-16 21:10:22 +02001038 evsel->name = do_read_string(fd, ph);
1039
1040 if (!nr)
1041 continue;
1042
1043 id = calloc(nr, sizeof(*id));
1044 if (!id)
1045 goto error;
1046 evsel->ids = nr;
1047 evsel->id = id;
1048
1049 for (j = 0 ; j < nr; j++) {
Namhyung Kim5323f602012-12-17 15:38:54 +09001050 ret = readn(fd, id, sizeof(*id));
Robert Richter4e1b9c62012-08-16 21:10:22 +02001051 if (ret != (ssize_t)sizeof(*id))
1052 goto error;
1053 if (ph->needs_swap)
1054 *id = bswap_64(*id);
1055 id++;
1056 }
1057 }
1058out:
Arnaldo Carvalho de Melo04662522013-12-26 17:41:15 -03001059 free(buf);
Robert Richter4e1b9c62012-08-16 21:10:22 +02001060 return events;
1061error:
Markus Elfring4cc97612015-06-25 17:12:32 +02001062 free_event_desc(events);
Robert Richter4e1b9c62012-08-16 21:10:22 +02001063 events = NULL;
1064 goto out;
1065}
1066
Peter Zijlstra2c5e8c52015-04-07 11:09:54 +02001067static int __desc_attr__fprintf(FILE *fp, const char *name, const char *val,
1068 void *priv __attribute__((unused)))
1069{
1070 return fprintf(fp, ", %s = %s", name, val);
1071}
1072
Robert Richter4e1b9c62012-08-16 21:10:22 +02001073static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
1074{
1075 struct perf_evsel *evsel, *events = read_event_desc(ph, fd);
1076 u32 j;
1077 u64 *id;
1078
1079 if (!events) {
1080 fprintf(fp, "# event desc: not available or unable to read\n");
1081 return;
1082 }
1083
1084 for (evsel = events; evsel->attr.size; evsel++) {
1085 fprintf(fp, "# event : name = %s, ", evsel->name);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001086
Robert Richter4e1b9c62012-08-16 21:10:22 +02001087 if (evsel->ids) {
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001088 fprintf(fp, ", id = {");
Robert Richter4e1b9c62012-08-16 21:10:22 +02001089 for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) {
1090 if (j)
1091 fputc(',', fp);
1092 fprintf(fp, " %"PRIu64, *id);
1093 }
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001094 fprintf(fp, " }");
Robert Richter4e1b9c62012-08-16 21:10:22 +02001095 }
Peter Zijlstra814c8c32015-03-31 00:19:31 +02001096
Peter Zijlstra2c5e8c52015-04-07 11:09:54 +02001097 perf_event_attr__fprintf(fp, &evsel->attr, __desc_attr__fprintf, NULL);
Robert Richter4e1b9c62012-08-16 21:10:22 +02001098
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001099 fputc('\n', fp);
1100 }
Robert Richter4e1b9c62012-08-16 21:10:22 +02001101
1102 free_event_desc(events);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001103}
1104
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001105static void print_total_mem(struct perf_header *ph, int fd __maybe_unused,
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001106 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001107{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001108 fprintf(fp, "# total memory : %Lu kB\n", ph->env.total_mem);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001109}
1110
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001111static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused,
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001112 FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001113{
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001114 u32 nr, c, i;
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001115 char *str, *tmp;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001116 uint64_t mem_total, mem_free;
1117
1118 /* nr nodes */
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001119 nr = ph->env.nr_numa_nodes;
1120 str = ph->env.numa_nodes;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001121
1122 for (i = 0; i < nr; i++) {
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001123 /* node number */
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001124 c = strtoul(str, &tmp, 0);
1125 if (*tmp != ':')
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001126 goto error;
1127
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001128 str = tmp + 1;
1129 mem_total = strtoull(str, &tmp, 0);
1130 if (*tmp != ':')
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001131 goto error;
1132
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001133 str = tmp + 1;
1134 mem_free = strtoull(str, &tmp, 0);
1135 if (*tmp != ':')
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001136 goto error;
1137
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001138 fprintf(fp, "# node%u meminfo : total = %"PRIu64" kB,"
1139 " free = %"PRIu64" kB\n",
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001140 c, mem_total, mem_free);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001141
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001142 str = tmp + 1;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001143 fprintf(fp, "# node%u cpu list : %s\n", c, str);
Namhyung Kim12344712012-10-23 22:44:49 +09001144
1145 str += strlen(str) + 1;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001146 }
1147 return;
1148error:
1149 fprintf(fp, "# numa topology : not available\n");
1150}
1151
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001152static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001153{
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001154 fprintf(fp, "# cpuid : %s\n", ph->env.cpuid);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001155}
1156
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001157static void print_branch_stack(struct perf_header *ph __maybe_unused,
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001158 int fd __maybe_unused, FILE *fp)
Stephane Eranian330aa672012-03-08 23:47:46 +01001159{
1160 fprintf(fp, "# contains samples with branch stack\n");
1161}
1162
Adrian Hunter4025ea42015-04-09 18:53:41 +03001163static void print_auxtrace(struct perf_header *ph __maybe_unused,
1164 int fd __maybe_unused, FILE *fp)
1165{
1166 fprintf(fp, "# contains AUX area data (e.g. instruction trace)\n");
1167}
1168
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001169static void print_pmu_mappings(struct perf_header *ph, int fd __maybe_unused,
1170 FILE *fp)
Robert Richter50a96672012-08-16 21:10:24 +02001171{
1172 const char *delimiter = "# pmu mappings: ";
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001173 char *str, *tmp;
Robert Richter50a96672012-08-16 21:10:24 +02001174 u32 pmu_num;
1175 u32 type;
1176
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001177 pmu_num = ph->env.nr_pmu_mappings;
Robert Richter50a96672012-08-16 21:10:24 +02001178 if (!pmu_num) {
1179 fprintf(fp, "# pmu mappings: not available\n");
1180 return;
1181 }
1182
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001183 str = ph->env.pmu_mappings;
Namhyung Kimbe4a2de2012-09-05 14:02:49 +09001184
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001185 while (pmu_num) {
1186 type = strtoul(str, &tmp, 0);
1187 if (*tmp != ':')
1188 goto error;
1189
1190 str = tmp + 1;
1191 fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
1192
Robert Richter50a96672012-08-16 21:10:24 +02001193 delimiter = ", ";
Namhyung Kim7e94cfc2012-09-24 17:15:00 +09001194 str += strlen(str) + 1;
1195 pmu_num--;
Robert Richter50a96672012-08-16 21:10:24 +02001196 }
1197
1198 fprintf(fp, "\n");
1199
1200 if (!pmu_num)
1201 return;
1202error:
1203 fprintf(fp, "# pmu mappings: unable to read\n");
1204}
1205
Namhyung Kima8bb5592013-01-22 18:09:31 +09001206static void print_group_desc(struct perf_header *ph, int fd __maybe_unused,
1207 FILE *fp)
1208{
1209 struct perf_session *session;
1210 struct perf_evsel *evsel;
1211 u32 nr = 0;
1212
1213 session = container_of(ph, struct perf_session, header);
1214
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03001215 evlist__for_each(session->evlist, evsel) {
Namhyung Kima8bb5592013-01-22 18:09:31 +09001216 if (perf_evsel__is_group_leader(evsel) &&
1217 evsel->nr_members > 1) {
1218 fprintf(fp, "# group: %s{%s", evsel->group_name ?: "",
1219 perf_evsel__name(evsel));
1220
1221 nr = evsel->nr_members - 1;
1222 } else if (nr) {
1223 fprintf(fp, ",%s", perf_evsel__name(evsel));
1224
1225 if (--nr == 0)
1226 fprintf(fp, "}\n");
1227 }
1228 }
1229}
1230
Robert Richter08d95bd2012-02-10 15:41:55 +01001231static int __event_process_build_id(struct build_id_event *bev,
1232 char *filename,
1233 struct perf_session *session)
1234{
1235 int err = -1;
Robert Richter08d95bd2012-02-10 15:41:55 +01001236 struct machine *machine;
Wang Nan1f121b02015-06-03 08:52:21 +00001237 u16 cpumode;
Robert Richter08d95bd2012-02-10 15:41:55 +01001238 struct dso *dso;
1239 enum dso_kernel_type dso_type;
1240
1241 machine = perf_session__findnew_machine(session, bev->pid);
1242 if (!machine)
1243 goto out;
1244
Wang Nan1f121b02015-06-03 08:52:21 +00001245 cpumode = bev->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
Robert Richter08d95bd2012-02-10 15:41:55 +01001246
Wang Nan1f121b02015-06-03 08:52:21 +00001247 switch (cpumode) {
Robert Richter08d95bd2012-02-10 15:41:55 +01001248 case PERF_RECORD_MISC_KERNEL:
1249 dso_type = DSO_TYPE_KERNEL;
Robert Richter08d95bd2012-02-10 15:41:55 +01001250 break;
1251 case PERF_RECORD_MISC_GUEST_KERNEL:
1252 dso_type = DSO_TYPE_GUEST_KERNEL;
Robert Richter08d95bd2012-02-10 15:41:55 +01001253 break;
1254 case PERF_RECORD_MISC_USER:
1255 case PERF_RECORD_MISC_GUEST_USER:
1256 dso_type = DSO_TYPE_USER;
Robert Richter08d95bd2012-02-10 15:41:55 +01001257 break;
1258 default:
1259 goto out;
1260 }
1261
Arnaldo Carvalho de Meloaa7cc2a2015-05-29 11:31:12 -03001262 dso = machine__findnew_dso(machine, filename);
Robert Richter08d95bd2012-02-10 15:41:55 +01001263 if (dso != NULL) {
1264 char sbuild_id[BUILD_ID_SIZE * 2 + 1];
1265
1266 dso__set_build_id(dso, &bev->build_id);
1267
Wang Nan1f121b02015-06-03 08:52:21 +00001268 if (!is_kernel_module(filename, cpumode))
Robert Richter08d95bd2012-02-10 15:41:55 +01001269 dso->kernel = dso_type;
1270
1271 build_id__sprintf(dso->build_id, sizeof(dso->build_id),
1272 sbuild_id);
1273 pr_debug("build id event received for %s: %s\n",
1274 dso->long_name, sbuild_id);
Arnaldo Carvalho de Melod3a7c482015-06-02 11:53:26 -03001275 dso__put(dso);
Robert Richter08d95bd2012-02-10 15:41:55 +01001276 }
1277
1278 err = 0;
1279out:
1280 return err;
1281}
1282
1283static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
1284 int input, u64 offset, u64 size)
1285{
1286 struct perf_session *session = container_of(header, struct perf_session, header);
1287 struct {
1288 struct perf_event_header header;
Irina Tirdea9ac3e482012-09-11 01:15:01 +03001289 u8 build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
Robert Richter08d95bd2012-02-10 15:41:55 +01001290 char filename[0];
1291 } old_bev;
1292 struct build_id_event bev;
1293 char filename[PATH_MAX];
1294 u64 limit = offset + size;
1295
1296 while (offset < limit) {
1297 ssize_t len;
1298
Namhyung Kim5323f602012-12-17 15:38:54 +09001299 if (readn(input, &old_bev, sizeof(old_bev)) != sizeof(old_bev))
Robert Richter08d95bd2012-02-10 15:41:55 +01001300 return -1;
1301
1302 if (header->needs_swap)
1303 perf_event_header__bswap(&old_bev.header);
1304
1305 len = old_bev.header.size - sizeof(old_bev);
Namhyung Kim5323f602012-12-17 15:38:54 +09001306 if (readn(input, filename, len) != len)
Robert Richter08d95bd2012-02-10 15:41:55 +01001307 return -1;
1308
1309 bev.header = old_bev.header;
1310
1311 /*
1312 * As the pid is the missing value, we need to fill
1313 * it properly. The header.misc value give us nice hint.
1314 */
1315 bev.pid = HOST_KERNEL_ID;
1316 if (bev.header.misc == PERF_RECORD_MISC_GUEST_USER ||
1317 bev.header.misc == PERF_RECORD_MISC_GUEST_KERNEL)
1318 bev.pid = DEFAULT_GUEST_KERNEL_ID;
1319
1320 memcpy(bev.build_id, old_bev.build_id, sizeof(bev.build_id));
1321 __event_process_build_id(&bev, filename, session);
1322
1323 offset += bev.header.size;
1324 }
1325
1326 return 0;
1327}
1328
1329static int perf_header__read_build_ids(struct perf_header *header,
1330 int input, u64 offset, u64 size)
1331{
1332 struct perf_session *session = container_of(header, struct perf_session, header);
1333 struct build_id_event bev;
1334 char filename[PATH_MAX];
1335 u64 limit = offset + size, orig_offset = offset;
1336 int err = -1;
1337
1338 while (offset < limit) {
1339 ssize_t len;
1340
Namhyung Kim5323f602012-12-17 15:38:54 +09001341 if (readn(input, &bev, sizeof(bev)) != sizeof(bev))
Robert Richter08d95bd2012-02-10 15:41:55 +01001342 goto out;
1343
1344 if (header->needs_swap)
1345 perf_event_header__bswap(&bev.header);
1346
1347 len = bev.header.size - sizeof(bev);
Namhyung Kim5323f602012-12-17 15:38:54 +09001348 if (readn(input, filename, len) != len)
Robert Richter08d95bd2012-02-10 15:41:55 +01001349 goto out;
1350 /*
1351 * The a1645ce1 changeset:
1352 *
1353 * "perf: 'perf kvm' tool for monitoring guest performance from host"
1354 *
1355 * Added a field to struct build_id_event that broke the file
1356 * format.
1357 *
1358 * Since the kernel build-id is the first entry, process the
1359 * table using the old format if the well known
1360 * '[kernel.kallsyms]' string for the kernel build-id has the
1361 * first 4 characters chopped off (where the pid_t sits).
1362 */
1363 if (memcmp(filename, "nel.kallsyms]", 13) == 0) {
1364 if (lseek(input, orig_offset, SEEK_SET) == (off_t)-1)
1365 return -1;
1366 return perf_header__read_build_ids_abi_quirk(header, input, offset, size);
1367 }
1368
1369 __event_process_build_id(&bev, filename, session);
1370
1371 offset += bev.header.size;
1372 }
1373 err = 0;
1374out:
1375 return err;
1376}
1377
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001378static int process_tracing_data(struct perf_file_section *section __maybe_unused,
1379 struct perf_header *ph __maybe_unused,
1380 int fd, void *data)
Robert Richterf1c67db2012-02-10 15:41:56 +01001381{
Namhyung Kim3dce2ce2013-03-21 16:18:48 +09001382 ssize_t ret = trace_report(fd, data, false);
1383 return ret < 0 ? -1 : 0;
Robert Richterf1c67db2012-02-10 15:41:56 +01001384}
1385
1386static int process_build_id(struct perf_file_section *section,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001387 struct perf_header *ph, int fd,
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001388 void *data __maybe_unused)
Robert Richterf1c67db2012-02-10 15:41:56 +01001389{
1390 if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
1391 pr_debug("Failed to read buildids, continuing...\n");
1392 return 0;
1393}
1394
Namhyung Kima1ae5652012-09-24 17:14:59 +09001395static int process_hostname(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001396 struct perf_header *ph, int fd,
1397 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001398{
1399 ph->env.hostname = do_read_string(fd, ph);
1400 return ph->env.hostname ? 0 : -ENOMEM;
1401}
1402
1403static int process_osrelease(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001404 struct perf_header *ph, int fd,
1405 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001406{
1407 ph->env.os_release = do_read_string(fd, ph);
1408 return ph->env.os_release ? 0 : -ENOMEM;
1409}
1410
1411static int process_version(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001412 struct perf_header *ph, int fd,
1413 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001414{
1415 ph->env.version = do_read_string(fd, ph);
1416 return ph->env.version ? 0 : -ENOMEM;
1417}
1418
1419static int process_arch(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001420 struct perf_header *ph, int fd,
1421 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001422{
1423 ph->env.arch = do_read_string(fd, ph);
1424 return ph->env.arch ? 0 : -ENOMEM;
1425}
1426
1427static int process_nrcpus(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001428 struct perf_header *ph, int fd,
1429 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001430{
Jiri Olsa727ebd52013-11-28 11:30:14 +01001431 ssize_t ret;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001432 u32 nr;
1433
Namhyung Kim5323f602012-12-17 15:38:54 +09001434 ret = readn(fd, &nr, sizeof(nr));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001435 if (ret != sizeof(nr))
1436 return -1;
1437
1438 if (ph->needs_swap)
1439 nr = bswap_32(nr);
1440
1441 ph->env.nr_cpus_online = nr;
1442
Namhyung Kim5323f602012-12-17 15:38:54 +09001443 ret = readn(fd, &nr, sizeof(nr));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001444 if (ret != sizeof(nr))
1445 return -1;
1446
1447 if (ph->needs_swap)
1448 nr = bswap_32(nr);
1449
1450 ph->env.nr_cpus_avail = nr;
1451 return 0;
1452}
1453
1454static int process_cpudesc(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001455 struct perf_header *ph, int fd,
1456 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001457{
1458 ph->env.cpu_desc = do_read_string(fd, ph);
1459 return ph->env.cpu_desc ? 0 : -ENOMEM;
1460}
1461
1462static int process_cpuid(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001463 struct perf_header *ph, int fd,
1464 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001465{
1466 ph->env.cpuid = do_read_string(fd, ph);
1467 return ph->env.cpuid ? 0 : -ENOMEM;
1468}
1469
1470static int process_total_mem(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001471 struct perf_header *ph, int fd,
1472 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001473{
1474 uint64_t mem;
Jiri Olsa727ebd52013-11-28 11:30:14 +01001475 ssize_t ret;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001476
Namhyung Kim5323f602012-12-17 15:38:54 +09001477 ret = readn(fd, &mem, sizeof(mem));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001478 if (ret != sizeof(mem))
1479 return -1;
1480
1481 if (ph->needs_swap)
1482 mem = bswap_64(mem);
1483
1484 ph->env.total_mem = mem;
1485 return 0;
1486}
1487
Robert Richter7c2f7af2012-08-16 21:10:23 +02001488static struct perf_evsel *
1489perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
1490{
1491 struct perf_evsel *evsel;
1492
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03001493 evlist__for_each(evlist, evsel) {
Robert Richter7c2f7af2012-08-16 21:10:23 +02001494 if (evsel->idx == idx)
1495 return evsel;
1496 }
1497
1498 return NULL;
1499}
1500
1501static void
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001502perf_evlist__set_event_name(struct perf_evlist *evlist,
1503 struct perf_evsel *event)
Robert Richter7c2f7af2012-08-16 21:10:23 +02001504{
1505 struct perf_evsel *evsel;
1506
1507 if (!event->name)
1508 return;
1509
1510 evsel = perf_evlist__find_by_index(evlist, event->idx);
1511 if (!evsel)
1512 return;
1513
1514 if (evsel->name)
1515 return;
1516
1517 evsel->name = strdup(event->name);
1518}
1519
1520static int
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001521process_event_desc(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001522 struct perf_header *header, int fd,
Irina Tirdea1d037ca2012-09-11 01:15:03 +03001523 void *data __maybe_unused)
Robert Richter7c2f7af2012-08-16 21:10:23 +02001524{
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001525 struct perf_session *session;
Robert Richter7c2f7af2012-08-16 21:10:23 +02001526 struct perf_evsel *evsel, *events = read_event_desc(header, fd);
1527
1528 if (!events)
1529 return 0;
1530
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001531 session = container_of(header, struct perf_session, header);
Robert Richter7c2f7af2012-08-16 21:10:23 +02001532 for (evsel = events; evsel->attr.size; evsel++)
1533 perf_evlist__set_event_name(session->evlist, evsel);
1534
1535 free_event_desc(events);
1536
1537 return 0;
1538}
1539
Jiri Olsa768dd3f2015-07-21 14:31:31 +02001540static int process_cmdline(struct perf_file_section *section,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001541 struct perf_header *ph, int fd,
1542 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001543{
Jiri Olsa727ebd52013-11-28 11:30:14 +01001544 ssize_t ret;
Jiri Olsa768dd3f2015-07-21 14:31:31 +02001545 char *str, *cmdline = NULL, **argv = NULL;
1546 u32 nr, i, len = 0;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001547
Namhyung Kim5323f602012-12-17 15:38:54 +09001548 ret = readn(fd, &nr, sizeof(nr));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001549 if (ret != sizeof(nr))
1550 return -1;
1551
1552 if (ph->needs_swap)
1553 nr = bswap_32(nr);
1554
1555 ph->env.nr_cmdline = nr;
Jiri Olsa768dd3f2015-07-21 14:31:31 +02001556
1557 cmdline = zalloc(section->size + nr + 1);
1558 if (!cmdline)
1559 return -1;
1560
1561 argv = zalloc(sizeof(char *) * (nr + 1));
1562 if (!argv)
1563 goto error;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001564
1565 for (i = 0; i < nr; i++) {
1566 str = do_read_string(fd, ph);
1567 if (!str)
1568 goto error;
1569
Jiri Olsa768dd3f2015-07-21 14:31:31 +02001570 argv[i] = cmdline + len;
1571 memcpy(argv[i], str, strlen(str) + 1);
1572 len += strlen(str) + 1;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001573 free(str);
1574 }
Jiri Olsa768dd3f2015-07-21 14:31:31 +02001575 ph->env.cmdline = cmdline;
1576 ph->env.cmdline_argv = (const char **) argv;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001577 return 0;
1578
1579error:
Jiri Olsa768dd3f2015-07-21 14:31:31 +02001580 free(argv);
1581 free(cmdline);
Namhyung Kima1ae5652012-09-24 17:14:59 +09001582 return -1;
1583}
1584
1585static int process_cpu_topology(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001586 struct perf_header *ph, int fd,
1587 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001588{
Jiri Olsa727ebd52013-11-28 11:30:14 +01001589 ssize_t ret;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001590 u32 nr, i;
1591 char *str;
1592 struct strbuf sb;
1593
Namhyung Kim5323f602012-12-17 15:38:54 +09001594 ret = readn(fd, &nr, sizeof(nr));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001595 if (ret != sizeof(nr))
1596 return -1;
1597
1598 if (ph->needs_swap)
1599 nr = bswap_32(nr);
1600
1601 ph->env.nr_sibling_cores = nr;
1602 strbuf_init(&sb, 128);
1603
1604 for (i = 0; i < nr; i++) {
1605 str = do_read_string(fd, ph);
1606 if (!str)
1607 goto error;
1608
1609 /* include a NULL character at the end */
1610 strbuf_add(&sb, str, strlen(str) + 1);
1611 free(str);
1612 }
1613 ph->env.sibling_cores = strbuf_detach(&sb, NULL);
1614
Namhyung Kim5323f602012-12-17 15:38:54 +09001615 ret = readn(fd, &nr, sizeof(nr));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001616 if (ret != sizeof(nr))
1617 return -1;
1618
1619 if (ph->needs_swap)
1620 nr = bswap_32(nr);
1621
1622 ph->env.nr_sibling_threads = nr;
1623
1624 for (i = 0; i < nr; i++) {
1625 str = do_read_string(fd, ph);
1626 if (!str)
1627 goto error;
1628
1629 /* include a NULL character at the end */
1630 strbuf_add(&sb, str, strlen(str) + 1);
1631 free(str);
1632 }
1633 ph->env.sibling_threads = strbuf_detach(&sb, NULL);
1634 return 0;
1635
1636error:
1637 strbuf_release(&sb);
1638 return -1;
1639}
1640
1641static int process_numa_topology(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001642 struct perf_header *ph, int fd,
1643 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001644{
Jiri Olsa727ebd52013-11-28 11:30:14 +01001645 ssize_t ret;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001646 u32 nr, node, i;
1647 char *str;
1648 uint64_t mem_total, mem_free;
1649 struct strbuf sb;
1650
1651 /* nr nodes */
Namhyung Kim5323f602012-12-17 15:38:54 +09001652 ret = readn(fd, &nr, sizeof(nr));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001653 if (ret != sizeof(nr))
1654 goto error;
1655
1656 if (ph->needs_swap)
1657 nr = bswap_32(nr);
1658
1659 ph->env.nr_numa_nodes = nr;
1660 strbuf_init(&sb, 256);
1661
1662 for (i = 0; i < nr; i++) {
1663 /* node number */
Namhyung Kim5323f602012-12-17 15:38:54 +09001664 ret = readn(fd, &node, sizeof(node));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001665 if (ret != sizeof(node))
1666 goto error;
1667
Namhyung Kim5323f602012-12-17 15:38:54 +09001668 ret = readn(fd, &mem_total, sizeof(u64));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001669 if (ret != sizeof(u64))
1670 goto error;
1671
Namhyung Kim5323f602012-12-17 15:38:54 +09001672 ret = readn(fd, &mem_free, sizeof(u64));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001673 if (ret != sizeof(u64))
1674 goto error;
1675
1676 if (ph->needs_swap) {
1677 node = bswap_32(node);
1678 mem_total = bswap_64(mem_total);
1679 mem_free = bswap_64(mem_free);
1680 }
1681
1682 strbuf_addf(&sb, "%u:%"PRIu64":%"PRIu64":",
1683 node, mem_total, mem_free);
1684
1685 str = do_read_string(fd, ph);
1686 if (!str)
1687 goto error;
1688
1689 /* include a NULL character at the end */
1690 strbuf_add(&sb, str, strlen(str) + 1);
1691 free(str);
1692 }
1693 ph->env.numa_nodes = strbuf_detach(&sb, NULL);
1694 return 0;
1695
1696error:
1697 strbuf_release(&sb);
1698 return -1;
1699}
1700
1701static int process_pmu_mappings(struct perf_file_section *section __maybe_unused,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001702 struct perf_header *ph, int fd,
1703 void *data __maybe_unused)
Namhyung Kima1ae5652012-09-24 17:14:59 +09001704{
Jiri Olsa727ebd52013-11-28 11:30:14 +01001705 ssize_t ret;
Namhyung Kima1ae5652012-09-24 17:14:59 +09001706 char *name;
1707 u32 pmu_num;
1708 u32 type;
1709 struct strbuf sb;
1710
Namhyung Kim5323f602012-12-17 15:38:54 +09001711 ret = readn(fd, &pmu_num, sizeof(pmu_num));
Namhyung Kima1ae5652012-09-24 17:14:59 +09001712 if (ret != sizeof(pmu_num))
1713 return -1;
1714
1715 if (ph->needs_swap)
1716 pmu_num = bswap_32(pmu_num);
1717
1718 if (!pmu_num) {
1719 pr_debug("pmu mappings not available\n");
1720 return 0;
1721 }
1722
1723 ph->env.nr_pmu_mappings = pmu_num;
1724 strbuf_init(&sb, 128);
1725
1726 while (pmu_num) {
Namhyung Kim5323f602012-12-17 15:38:54 +09001727 if (readn(fd, &type, sizeof(type)) != sizeof(type))
Namhyung Kima1ae5652012-09-24 17:14:59 +09001728 goto error;
1729 if (ph->needs_swap)
1730 type = bswap_32(type);
1731
1732 name = do_read_string(fd, ph);
1733 if (!name)
1734 goto error;
1735
1736 strbuf_addf(&sb, "%u:%s", type, name);
1737 /* include a NULL character at the end */
1738 strbuf_add(&sb, "", 1);
1739
1740 free(name);
1741 pmu_num--;
1742 }
1743 ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
1744 return 0;
1745
1746error:
1747 strbuf_release(&sb);
1748 return -1;
1749}
1750
Namhyung Kima8bb5592013-01-22 18:09:31 +09001751static int process_group_desc(struct perf_file_section *section __maybe_unused,
1752 struct perf_header *ph, int fd,
1753 void *data __maybe_unused)
1754{
1755 size_t ret = -1;
1756 u32 i, nr, nr_groups;
1757 struct perf_session *session;
1758 struct perf_evsel *evsel, *leader = NULL;
1759 struct group_desc {
1760 char *name;
1761 u32 leader_idx;
1762 u32 nr_members;
1763 } *desc;
1764
1765 if (readn(fd, &nr_groups, sizeof(nr_groups)) != sizeof(nr_groups))
1766 return -1;
1767
1768 if (ph->needs_swap)
1769 nr_groups = bswap_32(nr_groups);
1770
1771 ph->env.nr_groups = nr_groups;
1772 if (!nr_groups) {
1773 pr_debug("group desc not available\n");
1774 return 0;
1775 }
1776
1777 desc = calloc(nr_groups, sizeof(*desc));
1778 if (!desc)
1779 return -1;
1780
1781 for (i = 0; i < nr_groups; i++) {
1782 desc[i].name = do_read_string(fd, ph);
1783 if (!desc[i].name)
1784 goto out_free;
1785
1786 if (readn(fd, &desc[i].leader_idx, sizeof(u32)) != sizeof(u32))
1787 goto out_free;
1788
1789 if (readn(fd, &desc[i].nr_members, sizeof(u32)) != sizeof(u32))
1790 goto out_free;
1791
1792 if (ph->needs_swap) {
1793 desc[i].leader_idx = bswap_32(desc[i].leader_idx);
1794 desc[i].nr_members = bswap_32(desc[i].nr_members);
1795 }
1796 }
1797
1798 /*
1799 * Rebuild group relationship based on the group_desc
1800 */
1801 session = container_of(ph, struct perf_session, header);
1802 session->evlist->nr_groups = nr_groups;
1803
1804 i = nr = 0;
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03001805 evlist__for_each(session->evlist, evsel) {
Namhyung Kima8bb5592013-01-22 18:09:31 +09001806 if (evsel->idx == (int) desc[i].leader_idx) {
1807 evsel->leader = evsel;
1808 /* {anon_group} is a dummy name */
Namhyung Kim210e8122013-11-18 11:20:43 +09001809 if (strcmp(desc[i].name, "{anon_group}")) {
Namhyung Kima8bb5592013-01-22 18:09:31 +09001810 evsel->group_name = desc[i].name;
Namhyung Kim210e8122013-11-18 11:20:43 +09001811 desc[i].name = NULL;
1812 }
Namhyung Kima8bb5592013-01-22 18:09:31 +09001813 evsel->nr_members = desc[i].nr_members;
1814
1815 if (i >= nr_groups || nr > 0) {
1816 pr_debug("invalid group desc\n");
1817 goto out_free;
1818 }
1819
1820 leader = evsel;
1821 nr = evsel->nr_members - 1;
1822 i++;
1823 } else if (nr) {
1824 /* This is a group member */
1825 evsel->leader = leader;
1826
1827 nr--;
1828 }
1829 }
1830
1831 if (i != nr_groups || nr != 0) {
1832 pr_debug("invalid group desc\n");
1833 goto out_free;
1834 }
1835
1836 ret = 0;
1837out_free:
Namhyung Kim50a27402013-11-18 11:20:44 +09001838 for (i = 0; i < nr_groups; i++)
Arnaldo Carvalho de Melo74cf2492013-12-27 16:55:14 -03001839 zfree(&desc[i].name);
Namhyung Kima8bb5592013-01-22 18:09:31 +09001840 free(desc);
1841
1842 return ret;
1843}
1844
Adrian Hunter99fa2982015-04-30 17:37:25 +03001845static int process_auxtrace(struct perf_file_section *section,
1846 struct perf_header *ph, int fd,
1847 void *data __maybe_unused)
1848{
1849 struct perf_session *session;
1850 int err;
1851
1852 session = container_of(ph, struct perf_session, header);
1853
1854 err = auxtrace_index__process(fd, section->size, session,
1855 ph->needs_swap);
1856 if (err < 0)
1857 pr_err("Failed to process auxtrace index\n");
1858 return err;
1859}
1860
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001861struct feature_ops {
1862 int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
1863 void (*print)(struct perf_header *h, int fd, FILE *fp);
Robert Richterf1c67db2012-02-10 15:41:56 +01001864 int (*process)(struct perf_file_section *section,
Namhyung Kim3d7eb862012-09-24 17:15:01 +09001865 struct perf_header *h, int fd, void *data);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001866 const char *name;
1867 bool full_only;
1868};
1869
Robert Richter8cdfa782011-12-07 10:02:56 +01001870#define FEAT_OPA(n, func) \
1871 [n] = { .name = #n, .write = write_##func, .print = print_##func }
Robert Richterf1c67db2012-02-10 15:41:56 +01001872#define FEAT_OPP(n, func) \
1873 [n] = { .name = #n, .write = write_##func, .print = print_##func, \
1874 .process = process_##func }
Robert Richter8cdfa782011-12-07 10:02:56 +01001875#define FEAT_OPF(n, func) \
Robert Richterf1c67db2012-02-10 15:41:56 +01001876 [n] = { .name = #n, .write = write_##func, .print = print_##func, \
Namhyung Kima1ae5652012-09-24 17:14:59 +09001877 .process = process_##func, .full_only = true }
Robert Richter8cdfa782011-12-07 10:02:56 +01001878
1879/* feature_ops not implemented: */
Stephane Eranian2eeaaa02012-05-15 13:28:13 +02001880#define print_tracing_data NULL
1881#define print_build_id NULL
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001882
1883static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
Stephane Eranian2eeaaa02012-05-15 13:28:13 +02001884 FEAT_OPP(HEADER_TRACING_DATA, tracing_data),
Robert Richterf1c67db2012-02-10 15:41:56 +01001885 FEAT_OPP(HEADER_BUILD_ID, build_id),
Namhyung Kima1ae5652012-09-24 17:14:59 +09001886 FEAT_OPP(HEADER_HOSTNAME, hostname),
1887 FEAT_OPP(HEADER_OSRELEASE, osrelease),
1888 FEAT_OPP(HEADER_VERSION, version),
1889 FEAT_OPP(HEADER_ARCH, arch),
1890 FEAT_OPP(HEADER_NRCPUS, nrcpus),
1891 FEAT_OPP(HEADER_CPUDESC, cpudesc),
Namhyung Kim37e9d752012-09-24 17:15:03 +09001892 FEAT_OPP(HEADER_CPUID, cpuid),
Namhyung Kima1ae5652012-09-24 17:14:59 +09001893 FEAT_OPP(HEADER_TOTAL_MEM, total_mem),
Robert Richter7c2f7af2012-08-16 21:10:23 +02001894 FEAT_OPP(HEADER_EVENT_DESC, event_desc),
Namhyung Kima1ae5652012-09-24 17:14:59 +09001895 FEAT_OPP(HEADER_CMDLINE, cmdline),
Robert Richter8cdfa782011-12-07 10:02:56 +01001896 FEAT_OPF(HEADER_CPU_TOPOLOGY, cpu_topology),
1897 FEAT_OPF(HEADER_NUMA_TOPOLOGY, numa_topology),
Stephane Eranian330aa672012-03-08 23:47:46 +01001898 FEAT_OPA(HEADER_BRANCH_STACK, branch_stack),
Namhyung Kima1ae5652012-09-24 17:14:59 +09001899 FEAT_OPP(HEADER_PMU_MAPPINGS, pmu_mappings),
Namhyung Kima8bb5592013-01-22 18:09:31 +09001900 FEAT_OPP(HEADER_GROUP_DESC, group_desc),
Adrian Hunter99fa2982015-04-30 17:37:25 +03001901 FEAT_OPP(HEADER_AUXTRACE, auxtrace),
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001902};
1903
1904struct header_print_data {
1905 FILE *fp;
1906 bool full; /* extended list of headers */
1907};
1908
1909static int perf_file_section__fprintf_info(struct perf_file_section *section,
1910 struct perf_header *ph,
1911 int feat, int fd, void *data)
1912{
1913 struct header_print_data *hd = data;
1914
1915 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
1916 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
1917 "%d, continuing...\n", section->offset, feat);
1918 return 0;
1919 }
Robert Richterb1e5a9b2011-12-07 10:02:57 +01001920 if (feat >= HEADER_LAST_FEATURE) {
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001921 pr_warning("unknown feature %d\n", feat);
Robert Richterf7a8a132011-12-07 10:02:51 +01001922 return 0;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001923 }
1924 if (!feat_ops[feat].print)
1925 return 0;
1926
1927 if (!feat_ops[feat].full_only || hd->full)
1928 feat_ops[feat].print(ph, fd, hd->fp);
1929 else
1930 fprintf(hd->fp, "# %s info available, use -I to display\n",
1931 feat_ops[feat].name);
1932
1933 return 0;
1934}
1935
1936int perf_header__fprintf_info(struct perf_session *session, FILE *fp, bool full)
1937{
1938 struct header_print_data hd;
1939 struct perf_header *header = &session->header;
Jiri Olsacc9784bd2013-10-15 16:27:34 +02001940 int fd = perf_data_file__fd(session->file);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001941 hd.fp = fp;
1942 hd.full = full;
1943
1944 perf_header__process_sections(header, fd, &hd,
1945 perf_file_section__fprintf_info);
1946 return 0;
1947}
1948
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001949static int do_write_feat(int fd, struct perf_header *h, int type,
1950 struct perf_file_section **p,
1951 struct perf_evlist *evlist)
1952{
1953 int err;
1954 int ret = 0;
1955
1956 if (perf_header__has_feat(h, type)) {
Robert Richterb1e5a9b2011-12-07 10:02:57 +01001957 if (!feat_ops[type].write)
1958 return -1;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001959
1960 (*p)->offset = lseek(fd, 0, SEEK_CUR);
1961
1962 err = feat_ops[type].write(fd, h, evlist);
1963 if (err < 0) {
1964 pr_debug("failed to write feature %d\n", type);
1965
1966 /* undo anything written */
1967 lseek(fd, (*p)->offset, SEEK_SET);
1968
1969 return -1;
1970 }
1971 (*p)->size = lseek(fd, 0, SEEK_CUR) - (*p)->offset;
1972 (*p)++;
1973 }
1974 return ret;
1975}
1976
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03001977static int perf_header__adds_write(struct perf_header *header,
Arnaldo Carvalho de Melo361c99a2011-01-11 20:56:53 -02001978 struct perf_evlist *evlist, int fd)
Frederic Weisbecker2ba08252009-10-17 17:12:34 +02001979{
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01001980 int nr_sections;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001981 struct perf_file_section *feat_sec, *p;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01001982 int sec_size;
1983 u64 sec_start;
Robert Richterb1e5a9b2011-12-07 10:02:57 +01001984 int feat;
Stephane Eranianfbe96f22011-09-30 15:40:40 +02001985 int err;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01001986
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03001987 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01001988 if (!nr_sections)
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02001989 return 0;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01001990
Paul Gortmaker91b98802013-01-30 20:05:49 -05001991 feat_sec = p = calloc(nr_sections, sizeof(*feat_sec));
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02001992 if (feat_sec == NULL)
1993 return -ENOMEM;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01001994
1995 sec_size = sizeof(*feat_sec) * nr_sections;
1996
Jiri Olsa8d541e92013-07-17 19:49:44 +02001997 sec_start = header->feat_offset;
Xiao Guangrongf887f302010-02-04 16:46:42 +08001998 lseek(fd, sec_start + sec_size, SEEK_SET);
Frederic Weisbecker2ba08252009-10-17 17:12:34 +02001999
Robert Richterb1e5a9b2011-12-07 10:02:57 +01002000 for_each_set_bit(feat, header->adds_features, HEADER_FEAT_BITS) {
2001 if (do_write_feat(fd, header, feat, &p, evlist))
2002 perf_header__clear_feat(header, feat);
2003 }
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002004
Xiao Guangrongf887f302010-02-04 16:46:42 +08002005 lseek(fd, sec_start, SEEK_SET);
Stephane Eranianfbe96f22011-09-30 15:40:40 +02002006 /*
2007 * may write more than needed due to dropped feature, but
2008 * this is okay, reader will skip the mising entries
2009 */
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02002010 err = do_write(fd, feat_sec, sec_size);
2011 if (err < 0)
2012 pr_debug("failed to write feature section\n");
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002013 free(feat_sec);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02002014 return err;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002015}
Frederic Weisbecker2ba08252009-10-17 17:12:34 +02002016
Tom Zanussi8dc58102010-04-01 23:59:15 -05002017int perf_header__write_pipe(int fd)
2018{
2019 struct perf_pipe_file_header f_header;
2020 int err;
2021
2022 f_header = (struct perf_pipe_file_header){
2023 .magic = PERF_MAGIC,
2024 .size = sizeof(f_header),
2025 };
2026
2027 err = do_write(fd, &f_header, sizeof(f_header));
2028 if (err < 0) {
2029 pr_debug("failed to write perf pipe header\n");
2030 return err;
2031 }
2032
2033 return 0;
2034}
2035
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002036int perf_session__write_header(struct perf_session *session,
2037 struct perf_evlist *evlist,
2038 int fd, bool at_exit)
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002039{
2040 struct perf_file_header f_header;
2041 struct perf_file_attr f_attr;
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002042 struct perf_header *header = &session->header;
Jiri Olsa563aecb2013-06-05 13:35:06 +02002043 struct perf_evsel *evsel;
Jiri Olsa944d62b2013-07-17 19:49:43 +02002044 u64 attr_offset;
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002045 int err;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002046
2047 lseek(fd, sizeof(f_header), SEEK_SET);
2048
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03002049 evlist__for_each(session->evlist, evsel) {
Robert Richter6606f872012-08-16 21:10:19 +02002050 evsel->id_offset = lseek(fd, 0, SEEK_CUR);
2051 err = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02002052 if (err < 0) {
2053 pr_debug("failed to write perf header\n");
2054 return err;
2055 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002056 }
2057
Jiri Olsa944d62b2013-07-17 19:49:43 +02002058 attr_offset = lseek(fd, 0, SEEK_CUR);
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002059
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03002060 evlist__for_each(evlist, evsel) {
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002061 f_attr = (struct perf_file_attr){
Robert Richter6606f872012-08-16 21:10:19 +02002062 .attr = evsel->attr,
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002063 .ids = {
Robert Richter6606f872012-08-16 21:10:19 +02002064 .offset = evsel->id_offset,
2065 .size = evsel->ids * sizeof(u64),
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002066 }
2067 };
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02002068 err = do_write(fd, &f_attr, sizeof(f_attr));
2069 if (err < 0) {
2070 pr_debug("failed to write perf header attribute\n");
2071 return err;
2072 }
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002073 }
2074
Adrian Hunterd645c442013-12-11 14:36:28 +02002075 if (!header->data_offset)
2076 header->data_offset = lseek(fd, 0, SEEK_CUR);
Jiri Olsa8d541e92013-07-17 19:49:44 +02002077 header->feat_offset = header->data_offset + header->data_size;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002078
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02002079 if (at_exit) {
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002080 err = perf_header__adds_write(header, evlist, fd);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02002081 if (err < 0)
2082 return err;
2083 }
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002084
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002085 f_header = (struct perf_file_header){
2086 .magic = PERF_MAGIC,
2087 .size = sizeof(f_header),
2088 .attr_size = sizeof(f_attr),
2089 .attrs = {
Jiri Olsa944d62b2013-07-17 19:49:43 +02002090 .offset = attr_offset,
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002091 .size = evlist->nr_entries * sizeof(f_attr),
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002092 },
2093 .data = {
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002094 .offset = header->data_offset,
2095 .size = header->data_size,
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002096 },
Jiri Olsa44b3c572013-07-11 17:28:31 +02002097 /* event_types is ignored, store zeros */
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002098 };
2099
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002100 memcpy(&f_header.adds_features, &header->adds_features, sizeof(header->adds_features));
Frederic Weisbecker2ba08252009-10-17 17:12:34 +02002101
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002102 lseek(fd, 0, SEEK_SET);
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02002103 err = do_write(fd, &f_header, sizeof(f_header));
2104 if (err < 0) {
2105 pr_debug("failed to write perf header\n");
2106 return err;
2107 }
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002108 lseek(fd, header->data_offset + header->data_size, SEEK_SET);
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002109
Arnaldo Carvalho de Melod5eed902009-11-19 14:55:56 -02002110 return 0;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002111}
2112
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002113static int perf_header__getbuffer64(struct perf_header *header,
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002114 int fd, void *buf, size_t size)
2115{
Arnaldo Carvalho de Melo1e7972c2011-01-03 16:50:55 -02002116 if (readn(fd, buf, size) <= 0)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002117 return -1;
2118
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002119 if (header->needs_swap)
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002120 mem_bswap_64(buf, size);
2121
2122 return 0;
2123}
2124
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002125int perf_header__process_sections(struct perf_header *header, int fd,
Stephane Eranianfbe96f22011-09-30 15:40:40 +02002126 void *data,
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002127 int (*process)(struct perf_file_section *section,
Robert Richterb1e5a9b2011-12-07 10:02:57 +01002128 struct perf_header *ph,
2129 int feat, int fd, void *data))
Frederic Weisbecker2ba08252009-10-17 17:12:34 +02002130{
Robert Richterb1e5a9b2011-12-07 10:02:57 +01002131 struct perf_file_section *feat_sec, *sec;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002132 int nr_sections;
2133 int sec_size;
Robert Richterb1e5a9b2011-12-07 10:02:57 +01002134 int feat;
2135 int err;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002136
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002137 nr_sections = bitmap_weight(header->adds_features, HEADER_FEAT_BITS);
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002138 if (!nr_sections)
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002139 return 0;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002140
Paul Gortmaker91b98802013-01-30 20:05:49 -05002141 feat_sec = sec = calloc(nr_sections, sizeof(*feat_sec));
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002142 if (!feat_sec)
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002143 return -1;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002144
2145 sec_size = sizeof(*feat_sec) * nr_sections;
2146
Jiri Olsa8d541e92013-07-17 19:49:44 +02002147 lseek(fd, header->feat_offset, SEEK_SET);
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002148
Robert Richterb1e5a9b2011-12-07 10:02:57 +01002149 err = perf_header__getbuffer64(header, fd, feat_sec, sec_size);
2150 if (err < 0)
Arnaldo Carvalho de Melo769885f2009-12-28 22:48:32 -02002151 goto out_free;
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002152
Robert Richterb1e5a9b2011-12-07 10:02:57 +01002153 for_each_set_bit(feat, header->adds_features, HEADER_LAST_FEATURE) {
2154 err = process(sec++, header, feat, fd, data);
2155 if (err < 0)
2156 goto out_free;
Frederic Weisbecker4778d2e2009-11-11 04:51:05 +01002157 }
Robert Richterb1e5a9b2011-12-07 10:02:57 +01002158 err = 0;
Arnaldo Carvalho de Melo769885f2009-12-28 22:48:32 -02002159out_free:
Frederic Weisbecker9e827dd2009-11-11 04:51:07 +01002160 free(feat_sec);
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002161 return err;
Arnaldo Carvalho de Melo769885f2009-12-28 22:48:32 -02002162}
Frederic Weisbecker2ba08252009-10-17 17:12:34 +02002163
Stephane Eranian114382a2012-02-09 23:21:08 +01002164static const int attr_file_abi_sizes[] = {
2165 [0] = PERF_ATTR_SIZE_VER0,
2166 [1] = PERF_ATTR_SIZE_VER1,
Jiri Olsa239cc472012-08-07 15:20:42 +02002167 [2] = PERF_ATTR_SIZE_VER2,
Jiri Olsa0f6a3012012-08-07 15:20:45 +02002168 [3] = PERF_ATTR_SIZE_VER3,
Stephane Eranian6a21c0b2014-09-24 13:48:39 +02002169 [4] = PERF_ATTR_SIZE_VER4,
Stephane Eranian114382a2012-02-09 23:21:08 +01002170 0,
2171};
2172
2173/*
2174 * In the legacy file format, the magic number is not used to encode endianness.
2175 * hdr_sz was used to encode endianness. But given that hdr_sz can vary based
2176 * on ABI revisions, we need to try all combinations for all endianness to
2177 * detect the endianness.
2178 */
2179static int try_all_file_abis(uint64_t hdr_sz, struct perf_header *ph)
2180{
2181 uint64_t ref_size, attr_size;
2182 int i;
2183
2184 for (i = 0 ; attr_file_abi_sizes[i]; i++) {
2185 ref_size = attr_file_abi_sizes[i]
2186 + sizeof(struct perf_file_section);
2187 if (hdr_sz != ref_size) {
2188 attr_size = bswap_64(hdr_sz);
2189 if (attr_size != ref_size)
2190 continue;
2191
2192 ph->needs_swap = true;
2193 }
2194 pr_debug("ABI%d perf.data file detected, need_swap=%d\n",
2195 i,
2196 ph->needs_swap);
2197 return 0;
2198 }
2199 /* could not determine endianness */
2200 return -1;
2201}
2202
2203#define PERF_PIPE_HDR_VER0 16
2204
2205static const size_t attr_pipe_abi_sizes[] = {
2206 [0] = PERF_PIPE_HDR_VER0,
2207 0,
2208};
2209
2210/*
2211 * In the legacy pipe format, there is an implicit assumption that endiannesss
2212 * between host recording the samples, and host parsing the samples is the
2213 * same. This is not always the case given that the pipe output may always be
2214 * redirected into a file and analyzed on a different machine with possibly a
2215 * different endianness and perf_event ABI revsions in the perf tool itself.
2216 */
2217static int try_all_pipe_abis(uint64_t hdr_sz, struct perf_header *ph)
2218{
2219 u64 attr_size;
2220 int i;
2221
2222 for (i = 0 ; attr_pipe_abi_sizes[i]; i++) {
2223 if (hdr_sz != attr_pipe_abi_sizes[i]) {
2224 attr_size = bswap_64(hdr_sz);
2225 if (attr_size != hdr_sz)
2226 continue;
2227
2228 ph->needs_swap = true;
2229 }
2230 pr_debug("Pipe ABI%d perf.data file detected\n", i);
2231 return 0;
2232 }
2233 return -1;
2234}
2235
Feng Tange84ba4e2012-10-30 11:56:07 +08002236bool is_perf_magic(u64 magic)
2237{
2238 if (!memcmp(&magic, __perf_magic1, sizeof(magic))
2239 || magic == __perf_magic2
2240 || magic == __perf_magic2_sw)
2241 return true;
2242
2243 return false;
2244}
2245
Stephane Eranian114382a2012-02-09 23:21:08 +01002246static int check_magic_endian(u64 magic, uint64_t hdr_sz,
2247 bool is_pipe, struct perf_header *ph)
Stephane Eranian73323f52012-02-02 13:54:44 +01002248{
2249 int ret;
2250
2251 /* check for legacy format */
Stephane Eranian114382a2012-02-09 23:21:08 +01002252 ret = memcmp(&magic, __perf_magic1, sizeof(magic));
Stephane Eranian73323f52012-02-02 13:54:44 +01002253 if (ret == 0) {
Jiri Olsa2a08c3e2013-07-17 19:49:47 +02002254 ph->version = PERF_HEADER_VERSION_1;
Stephane Eranian73323f52012-02-02 13:54:44 +01002255 pr_debug("legacy perf.data format\n");
Stephane Eranian114382a2012-02-09 23:21:08 +01002256 if (is_pipe)
2257 return try_all_pipe_abis(hdr_sz, ph);
Stephane Eranian73323f52012-02-02 13:54:44 +01002258
Stephane Eranian114382a2012-02-09 23:21:08 +01002259 return try_all_file_abis(hdr_sz, ph);
Stephane Eranian73323f52012-02-02 13:54:44 +01002260 }
Stephane Eranian114382a2012-02-09 23:21:08 +01002261 /*
2262 * the new magic number serves two purposes:
2263 * - unique number to identify actual perf.data files
2264 * - encode endianness of file
2265 */
Namhyung Kimf7913972015-01-29 17:06:45 +09002266 ph->version = PERF_HEADER_VERSION_2;
Stephane Eranian73323f52012-02-02 13:54:44 +01002267
Stephane Eranian114382a2012-02-09 23:21:08 +01002268 /* check magic number with one endianness */
2269 if (magic == __perf_magic2)
Stephane Eranian73323f52012-02-02 13:54:44 +01002270 return 0;
2271
Stephane Eranian114382a2012-02-09 23:21:08 +01002272 /* check magic number with opposite endianness */
2273 if (magic != __perf_magic2_sw)
Stephane Eranian73323f52012-02-02 13:54:44 +01002274 return -1;
2275
2276 ph->needs_swap = true;
2277
2278 return 0;
2279}
2280
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002281int perf_file_header__read(struct perf_file_header *header,
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002282 struct perf_header *ph, int fd)
2283{
Jiri Olsa727ebd52013-11-28 11:30:14 +01002284 ssize_t ret;
Stephane Eranian73323f52012-02-02 13:54:44 +01002285
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002286 lseek(fd, 0, SEEK_SET);
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002287
Stephane Eranian73323f52012-02-02 13:54:44 +01002288 ret = readn(fd, header, sizeof(*header));
2289 if (ret <= 0)
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002290 return -1;
2291
Stephane Eranian114382a2012-02-09 23:21:08 +01002292 if (check_magic_endian(header->magic,
2293 header->attr_size, false, ph) < 0) {
2294 pr_debug("magic/endian check failed\n");
Stephane Eranian73323f52012-02-02 13:54:44 +01002295 return -1;
Stephane Eranian114382a2012-02-09 23:21:08 +01002296 }
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002297
Stephane Eranian73323f52012-02-02 13:54:44 +01002298 if (ph->needs_swap) {
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002299 mem_bswap_64(header, offsetof(struct perf_file_header,
Stephane Eranian73323f52012-02-02 13:54:44 +01002300 adds_features));
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002301 }
2302
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002303 if (header->size != sizeof(*header)) {
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002304 /* Support the previous format */
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002305 if (header->size == offsetof(typeof(*header), adds_features))
2306 bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002307 else
2308 return -1;
David Ahernd327fa42011-10-18 17:34:01 -06002309 } else if (ph->needs_swap) {
David Ahernd327fa42011-10-18 17:34:01 -06002310 /*
2311 * feature bitmap is declared as an array of unsigned longs --
2312 * not good since its size can differ between the host that
2313 * generated the data file and the host analyzing the file.
2314 *
2315 * We need to handle endianness, but we don't know the size of
2316 * the unsigned long where the file was generated. Take a best
2317 * guess at determining it: try 64-bit swap first (ie., file
2318 * created on a 64-bit host), and check if the hostname feature
2319 * bit is set (this feature bit is forced on as of fbe96f2).
2320 * If the bit is not, undo the 64-bit swap and try a 32-bit
2321 * swap. If the hostname bit is still not set (e.g., older data
2322 * file), punt and fallback to the original behavior --
2323 * clearing all feature bits and setting buildid.
2324 */
David Ahern80c01202012-06-08 11:47:51 -03002325 mem_bswap_64(&header->adds_features,
2326 BITS_TO_U64(HEADER_FEAT_BITS));
David Ahernd327fa42011-10-18 17:34:01 -06002327
2328 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
David Ahern80c01202012-06-08 11:47:51 -03002329 /* unswap as u64 */
2330 mem_bswap_64(&header->adds_features,
2331 BITS_TO_U64(HEADER_FEAT_BITS));
2332
2333 /* unswap as u32 */
2334 mem_bswap_32(&header->adds_features,
2335 BITS_TO_U32(HEADER_FEAT_BITS));
David Ahernd327fa42011-10-18 17:34:01 -06002336 }
2337
2338 if (!test_bit(HEADER_HOSTNAME, header->adds_features)) {
2339 bitmap_zero(header->adds_features, HEADER_FEAT_BITS);
2340 set_bit(HEADER_BUILD_ID, header->adds_features);
2341 }
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002342 }
2343
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002344 memcpy(&ph->adds_features, &header->adds_features,
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002345 sizeof(ph->adds_features));
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002346
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002347 ph->data_offset = header->data.offset;
2348 ph->data_size = header->data.size;
Jiri Olsa8d541e92013-07-17 19:49:44 +02002349 ph->feat_offset = header->data.offset + header->data.size;
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002350 return 0;
2351}
2352
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002353static int perf_file_section__process(struct perf_file_section *section,
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002354 struct perf_header *ph,
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03002355 int feat, int fd, void *data)
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002356{
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002357 if (lseek(fd, section->offset, SEEK_SET) == (off_t)-1) {
Arnaldo Carvalho de Melo9486aa32011-01-22 20:37:02 -02002358 pr_debug("Failed to lseek to %" PRIu64 " offset for feature "
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002359 "%d, continuing...\n", section->offset, feat);
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002360 return 0;
2361 }
2362
Robert Richterb1e5a9b2011-12-07 10:02:57 +01002363 if (feat >= HEADER_LAST_FEATURE) {
2364 pr_debug("unknown feature %d, continuing...\n", feat);
2365 return 0;
2366 }
2367
Robert Richterf1c67db2012-02-10 15:41:56 +01002368 if (!feat_ops[feat].process)
2369 return 0;
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002370
Namhyung Kim3d7eb862012-09-24 17:15:01 +09002371 return feat_ops[feat].process(section, ph, fd, data);
Arnaldo Carvalho de Melo37562ea2009-11-16 16:32:43 -02002372}
2373
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002374static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
Tom Zanussi454c4072010-05-01 01:41:20 -05002375 struct perf_header *ph, int fd,
2376 bool repipe)
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002377{
Jiri Olsa727ebd52013-11-28 11:30:14 +01002378 ssize_t ret;
Stephane Eranian73323f52012-02-02 13:54:44 +01002379
2380 ret = readn(fd, header, sizeof(*header));
2381 if (ret <= 0)
2382 return -1;
2383
Stephane Eranian114382a2012-02-09 23:21:08 +01002384 if (check_magic_endian(header->magic, header->size, true, ph) < 0) {
2385 pr_debug("endian/magic failed\n");
Tom Zanussi8dc58102010-04-01 23:59:15 -05002386 return -1;
Stephane Eranian114382a2012-02-09 23:21:08 +01002387 }
2388
2389 if (ph->needs_swap)
2390 header->size = bswap_64(header->size);
Tom Zanussi8dc58102010-04-01 23:59:15 -05002391
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002392 if (repipe && do_write(STDOUT_FILENO, header, sizeof(*header)) < 0)
Tom Zanussi454c4072010-05-01 01:41:20 -05002393 return -1;
2394
Tom Zanussi8dc58102010-04-01 23:59:15 -05002395 return 0;
2396}
2397
Jiri Olsad4339562013-07-17 19:49:41 +02002398static int perf_header__read_pipe(struct perf_session *session)
Tom Zanussi8dc58102010-04-01 23:59:15 -05002399{
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002400 struct perf_header *header = &session->header;
Tom Zanussi8dc58102010-04-01 23:59:15 -05002401 struct perf_pipe_file_header f_header;
2402
Jiri Olsacc9784bd2013-10-15 16:27:34 +02002403 if (perf_file_header__read_pipe(&f_header, header,
2404 perf_data_file__fd(session->file),
Tom Zanussi454c4072010-05-01 01:41:20 -05002405 session->repipe) < 0) {
Tom Zanussi8dc58102010-04-01 23:59:15 -05002406 pr_debug("incompatible file format\n");
2407 return -EINVAL;
2408 }
2409
Tom Zanussi8dc58102010-04-01 23:59:15 -05002410 return 0;
2411}
2412
Stephane Eranian69996df2012-02-09 23:21:06 +01002413static int read_attr(int fd, struct perf_header *ph,
2414 struct perf_file_attr *f_attr)
2415{
2416 struct perf_event_attr *attr = &f_attr->attr;
2417 size_t sz, left;
2418 size_t our_sz = sizeof(f_attr->attr);
Jiri Olsa727ebd52013-11-28 11:30:14 +01002419 ssize_t ret;
Stephane Eranian69996df2012-02-09 23:21:06 +01002420
2421 memset(f_attr, 0, sizeof(*f_attr));
2422
2423 /* read minimal guaranteed structure */
2424 ret = readn(fd, attr, PERF_ATTR_SIZE_VER0);
2425 if (ret <= 0) {
2426 pr_debug("cannot read %d bytes of header attr\n",
2427 PERF_ATTR_SIZE_VER0);
2428 return -1;
2429 }
2430
2431 /* on file perf_event_attr size */
2432 sz = attr->size;
Stephane Eranian114382a2012-02-09 23:21:08 +01002433
Stephane Eranian69996df2012-02-09 23:21:06 +01002434 if (ph->needs_swap)
2435 sz = bswap_32(sz);
2436
2437 if (sz == 0) {
2438 /* assume ABI0 */
2439 sz = PERF_ATTR_SIZE_VER0;
2440 } else if (sz > our_sz) {
2441 pr_debug("file uses a more recent and unsupported ABI"
2442 " (%zu bytes extra)\n", sz - our_sz);
2443 return -1;
2444 }
2445 /* what we have not yet read and that we know about */
2446 left = sz - PERF_ATTR_SIZE_VER0;
2447 if (left) {
2448 void *ptr = attr;
2449 ptr += PERF_ATTR_SIZE_VER0;
2450
2451 ret = readn(fd, ptr, left);
2452 }
2453 /* read perf_file_section, ids are read in caller */
2454 ret = readn(fd, &f_attr->ids, sizeof(f_attr->ids));
2455
2456 return ret <= 0 ? -1 : 0;
2457}
2458
Namhyung Kim831394b2012-09-06 11:10:46 +09002459static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
2460 struct pevent *pevent)
Arnaldo Carvalho de Melocb9dd492012-06-11 19:03:32 -03002461{
Namhyung Kim831394b2012-09-06 11:10:46 +09002462 struct event_format *event;
Arnaldo Carvalho de Melocb9dd492012-06-11 19:03:32 -03002463 char bf[128];
2464
Namhyung Kim831394b2012-09-06 11:10:46 +09002465 /* already prepared */
2466 if (evsel->tp_format)
2467 return 0;
2468
Namhyung Kim3dce2ce2013-03-21 16:18:48 +09002469 if (pevent == NULL) {
2470 pr_debug("broken or missing trace data\n");
2471 return -1;
2472 }
2473
Namhyung Kim831394b2012-09-06 11:10:46 +09002474 event = pevent_find_event(pevent, evsel->attr.config);
Arnaldo Carvalho de Melocb9dd492012-06-11 19:03:32 -03002475 if (event == NULL)
2476 return -1;
2477
Namhyung Kim831394b2012-09-06 11:10:46 +09002478 if (!evsel->name) {
2479 snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
2480 evsel->name = strdup(bf);
2481 if (evsel->name == NULL)
2482 return -1;
2483 }
Arnaldo Carvalho de Melocb9dd492012-06-11 19:03:32 -03002484
Arnaldo Carvalho de Melofcf65bf2012-08-07 09:58:03 -03002485 evsel->tp_format = event;
Arnaldo Carvalho de Melocb9dd492012-06-11 19:03:32 -03002486 return 0;
2487}
2488
Namhyung Kim831394b2012-09-06 11:10:46 +09002489static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist,
2490 struct pevent *pevent)
Arnaldo Carvalho de Melocb9dd492012-06-11 19:03:32 -03002491{
2492 struct perf_evsel *pos;
2493
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03002494 evlist__for_each(evlist, pos) {
Namhyung Kim831394b2012-09-06 11:10:46 +09002495 if (pos->attr.type == PERF_TYPE_TRACEPOINT &&
2496 perf_evsel__prepare_tracepoint_event(pos, pevent))
Arnaldo Carvalho de Melocb9dd492012-06-11 19:03:32 -03002497 return -1;
2498 }
2499
2500 return 0;
2501}
2502
Jiri Olsad4339562013-07-17 19:49:41 +02002503int perf_session__read_header(struct perf_session *session)
Tom Zanussi8dc58102010-04-01 23:59:15 -05002504{
Jiri Olsacc9784bd2013-10-15 16:27:34 +02002505 struct perf_data_file *file = session->file;
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002506 struct perf_header *header = &session->header;
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002507 struct perf_file_header f_header;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002508 struct perf_file_attr f_attr;
2509 u64 f_id;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002510 int nr_attrs, nr_ids, i, j;
Jiri Olsacc9784bd2013-10-15 16:27:34 +02002511 int fd = perf_data_file__fd(file);
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002512
Namhyung Kim334fe7a2013-03-11 16:43:12 +09002513 session->evlist = perf_evlist__new();
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002514 if (session->evlist == NULL)
2515 return -ENOMEM;
2516
Jiri Olsacc9784bd2013-10-15 16:27:34 +02002517 if (perf_data_file__is_pipe(file))
Jiri Olsad4339562013-07-17 19:49:41 +02002518 return perf_header__read_pipe(session);
Tom Zanussi8dc58102010-04-01 23:59:15 -05002519
Stephane Eranian69996df2012-02-09 23:21:06 +01002520 if (perf_file_header__read(&f_header, header, fd) < 0)
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -02002521 return -EINVAL;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002522
Namhyung Kimb314e5c2013-09-30 17:19:48 +09002523 /*
2524 * Sanity check that perf.data was written cleanly; data size is
2525 * initialized to 0 and updated only if the on_exit function is run.
2526 * If data size is still 0 then the file contains only partial
2527 * information. Just warn user and process it as much as it can.
2528 */
2529 if (f_header.data.size == 0) {
2530 pr_warning("WARNING: The %s file's data size field is 0 which is unexpected.\n"
2531 "Was the 'perf record' command properly terminated?\n",
Jiri Olsacc9784bd2013-10-15 16:27:34 +02002532 file->path);
Namhyung Kimb314e5c2013-09-30 17:19:48 +09002533 }
2534
Stephane Eranian69996df2012-02-09 23:21:06 +01002535 nr_attrs = f_header.attrs.size / f_header.attr_size;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002536 lseek(fd, f_header.attrs.offset, SEEK_SET);
2537
2538 for (i = 0; i < nr_attrs; i++) {
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002539 struct perf_evsel *evsel;
Peter Zijlstra1c222bc2009-08-06 20:57:41 +02002540 off_t tmp;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002541
Stephane Eranian69996df2012-02-09 23:21:06 +01002542 if (read_attr(fd, header, &f_attr) < 0)
Arnaldo Carvalho de Melo769885f2009-12-28 22:48:32 -02002543 goto out_errno;
Arnaldo Carvalho de Meloba215942010-01-14 12:23:10 -02002544
David Ahern1060ab82015-04-09 16:15:46 -04002545 if (header->needs_swap) {
2546 f_attr.ids.size = bswap_64(f_attr.ids.size);
2547 f_attr.ids.offset = bswap_64(f_attr.ids.offset);
David Aherneda39132011-07-15 12:34:09 -06002548 perf_event__attr_swap(&f_attr.attr);
David Ahern1060ab82015-04-09 16:15:46 -04002549 }
David Aherneda39132011-07-15 12:34:09 -06002550
Peter Zijlstra1c222bc2009-08-06 20:57:41 +02002551 tmp = lseek(fd, 0, SEEK_CUR);
Arnaldo Carvalho de Meloef503832013-11-07 16:41:19 -03002552 evsel = perf_evsel__new(&f_attr.attr);
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002553
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002554 if (evsel == NULL)
2555 goto out_delete_evlist;
Arnaldo Carvalho de Melo0807d2d2012-09-26 12:48:18 -03002556
2557 evsel->needs_swap = header->needs_swap;
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002558 /*
2559 * Do it before so that if perf_evsel__alloc_id fails, this
2560 * entry gets purged too at perf_evlist__delete().
2561 */
2562 perf_evlist__add(session->evlist, evsel);
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002563
2564 nr_ids = f_attr.ids.size / sizeof(u64);
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002565 /*
2566 * We don't have the cpu and thread maps on the header, so
2567 * for allocating the perf_sample_id table we fake 1 cpu and
2568 * hattr->ids threads.
2569 */
2570 if (perf_evsel__alloc_id(evsel, 1, nr_ids))
2571 goto out_delete_evlist;
2572
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002573 lseek(fd, f_attr.ids.offset, SEEK_SET);
2574
2575 for (j = 0; j < nr_ids; j++) {
Arnaldo Carvalho de Melo1c0b04d2011-03-09 08:13:19 -03002576 if (perf_header__getbuffer64(header, fd, &f_id, sizeof(f_id)))
Arnaldo Carvalho de Melo769885f2009-12-28 22:48:32 -02002577 goto out_errno;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002578
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002579 perf_evlist__id_add(session->evlist, evsel, 0, j, f_id);
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -02002580 }
Arnaldo Carvalho de Melo11deb1f2009-11-17 01:18:09 -02002581
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002582 lseek(fd, tmp, SEEK_SET);
2583 }
2584
Arnaldo Carvalho de Melod04b35f2011-11-11 22:17:32 -02002585 symbol_conf.nr_events = nr_attrs;
2586
Jiri Olsa29f5ffd2013-12-03 14:09:23 +01002587 perf_header__process_sections(header, fd, &session->tevent,
Stephane Eranianfbe96f22011-09-30 15:40:40 +02002588 perf_file_section__process);
Frederic Weisbecker4778d2e2009-11-11 04:51:05 +01002589
Namhyung Kim831394b2012-09-06 11:10:46 +09002590 if (perf_evlist__prepare_tracepoint_events(session->evlist,
Jiri Olsa29f5ffd2013-12-03 14:09:23 +01002591 session->tevent.pevent))
Arnaldo Carvalho de Melocb9dd492012-06-11 19:03:32 -03002592 goto out_delete_evlist;
2593
Arnaldo Carvalho de Melo4dc0a042009-11-19 14:55:55 -02002594 return 0;
Arnaldo Carvalho de Melo769885f2009-12-28 22:48:32 -02002595out_errno:
2596 return -errno;
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002597
2598out_delete_evlist:
2599 perf_evlist__delete(session->evlist);
2600 session->evlist = NULL;
2601 return -ENOMEM;
Peter Zijlstra7c6a1c62009-06-25 17:05:54 +02002602}
Frederic Weisbecker0d3a5c82009-08-16 20:56:37 +02002603
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02002604int perf_event__synthesize_attr(struct perf_tool *tool,
Robert Richterf4d83432012-08-16 21:10:17 +02002605 struct perf_event_attr *attr, u32 ids, u64 *id,
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -02002606 perf_event__handler_t process)
Frederic Weisbecker0d3a5c82009-08-16 20:56:37 +02002607{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002608 union perf_event *ev;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002609 size_t size;
2610 int err;
2611
2612 size = sizeof(struct perf_event_attr);
Irina Tirdea9ac3e482012-09-11 01:15:01 +03002613 size = PERF_ALIGN(size, sizeof(u64));
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002614 size += sizeof(struct perf_event_header);
2615 size += ids * sizeof(u64);
2616
2617 ev = malloc(size);
2618
Chris Samuelce47dc52010-11-13 13:35:06 +11002619 if (ev == NULL)
2620 return -ENOMEM;
2621
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002622 ev->attr.attr = *attr;
2623 memcpy(ev->attr.id, id, ids * sizeof(u64));
2624
2625 ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
Robert Richterf4d83432012-08-16 21:10:17 +02002626 ev->attr.header.size = (u16)size;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002627
Robert Richterf4d83432012-08-16 21:10:17 +02002628 if (ev->attr.header.size == size)
2629 err = process(tool, ev, NULL, NULL);
2630 else
2631 err = -E2BIG;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002632
2633 free(ev);
2634
2635 return err;
2636}
2637
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02002638int perf_event__synthesize_attrs(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002639 struct perf_session *session,
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002640 perf_event__handler_t process)
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002641{
Robert Richter6606f872012-08-16 21:10:19 +02002642 struct perf_evsel *evsel;
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002643 int err = 0;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002644
Arnaldo Carvalho de Melo0050f7a2014-01-10 10:37:27 -03002645 evlist__for_each(session->evlist, evsel) {
Robert Richter6606f872012-08-16 21:10:19 +02002646 err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids,
2647 evsel->id, process);
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002648 if (err) {
2649 pr_debug("failed to create perf header attribute\n");
2650 return err;
2651 }
2652 }
2653
2654 return err;
2655}
2656
Adrian Hunter47c3d102013-07-04 16:20:21 +03002657int perf_event__process_attr(struct perf_tool *tool __maybe_unused,
2658 union perf_event *event,
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02002659 struct perf_evlist **pevlist)
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002660{
Robert Richterf4d83432012-08-16 21:10:17 +02002661 u32 i, ids, n_ids;
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002662 struct perf_evsel *evsel;
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02002663 struct perf_evlist *evlist = *pevlist;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002664
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02002665 if (evlist == NULL) {
Namhyung Kim334fe7a2013-03-11 16:43:12 +09002666 *pevlist = evlist = perf_evlist__new();
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02002667 if (evlist == NULL)
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002668 return -ENOMEM;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002669 }
2670
Arnaldo Carvalho de Meloef503832013-11-07 16:41:19 -03002671 evsel = perf_evsel__new(&event->attr.attr);
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002672 if (evsel == NULL)
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002673 return -ENOMEM;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002674
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02002675 perf_evlist__add(evlist, evsel);
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002676
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002677 ids = event->header.size;
2678 ids -= (void *)&event->attr.id - (void *)event;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002679 n_ids = ids / sizeof(u64);
Arnaldo Carvalho de Meloa91e5432011-03-10 11:15:54 -03002680 /*
2681 * We don't have the cpu and thread maps on the header, so
2682 * for allocating the perf_sample_id table we fake 1 cpu and
2683 * hattr->ids threads.
2684 */
2685 if (perf_evsel__alloc_id(evsel, 1, n_ids))
2686 return -ENOMEM;
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002687
2688 for (i = 0; i < n_ids; i++) {
Arnaldo Carvalho de Melo10d0f082011-11-11 22:45:41 -02002689 perf_evlist__id_add(evlist, evsel, 0, i, event->attr.id[i]);
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002690 }
2691
Adrian Hunter7e0d6fc2013-07-04 16:20:29 +03002692 symbol_conf.nr_events = evlist->nr_entries;
2693
Tom Zanussi2c46dbb2010-04-01 23:59:19 -05002694 return 0;
2695}
Tom Zanussicd19a032010-04-01 23:59:20 -05002696
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02002697int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002698 struct perf_evlist *evlist,
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -02002699 perf_event__handler_t process)
Tom Zanussi92155452010-04-01 23:59:21 -05002700{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002701 union perf_event ev;
Jiri Olsa29208e52011-10-20 15:59:43 +02002702 struct tracing_data *tdata;
Tom Zanussi92155452010-04-01 23:59:21 -05002703 ssize_t size = 0, aligned_size = 0, padding;
Irina Tirdea1d037ca2012-09-11 01:15:03 +03002704 int err __maybe_unused = 0;
Tom Zanussi92155452010-04-01 23:59:21 -05002705
Jiri Olsa29208e52011-10-20 15:59:43 +02002706 /*
2707 * We are going to store the size of the data followed
2708 * by the data contents. Since the fd descriptor is a pipe,
2709 * we cannot seek back to store the size of the data once
2710 * we know it. Instead we:
2711 *
2712 * - write the tracing data to the temp file
2713 * - get/write the data size to pipe
2714 * - write the tracing data from the temp file
2715 * to the pipe
2716 */
2717 tdata = tracing_data_get(&evlist->entries, fd, true);
2718 if (!tdata)
2719 return -1;
2720
Tom Zanussi92155452010-04-01 23:59:21 -05002721 memset(&ev, 0, sizeof(ev));
2722
2723 ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
Jiri Olsa29208e52011-10-20 15:59:43 +02002724 size = tdata->size;
Irina Tirdea9ac3e482012-09-11 01:15:01 +03002725 aligned_size = PERF_ALIGN(size, sizeof(u64));
Tom Zanussi92155452010-04-01 23:59:21 -05002726 padding = aligned_size - size;
2727 ev.tracing_data.header.size = sizeof(ev.tracing_data);
2728 ev.tracing_data.size = aligned_size;
2729
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02002730 process(tool, &ev, NULL, NULL);
Tom Zanussi92155452010-04-01 23:59:21 -05002731
Jiri Olsa29208e52011-10-20 15:59:43 +02002732 /*
2733 * The put function will copy all the tracing data
2734 * stored in temp file to the pipe.
2735 */
2736 tracing_data_put(tdata);
2737
Tom Zanussi92155452010-04-01 23:59:21 -05002738 write_padded(fd, NULL, 0, padding);
2739
2740 return aligned_size;
2741}
2742
Adrian Hunter47c3d102013-07-04 16:20:21 +03002743int perf_event__process_tracing_data(struct perf_tool *tool __maybe_unused,
2744 union perf_event *event,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002745 struct perf_session *session)
Tom Zanussi92155452010-04-01 23:59:21 -05002746{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002747 ssize_t size_read, padding, size = event->tracing_data.size;
Jiri Olsacc9784bd2013-10-15 16:27:34 +02002748 int fd = perf_data_file__fd(session->file);
2749 off_t offset = lseek(fd, 0, SEEK_CUR);
Tom Zanussi92155452010-04-01 23:59:21 -05002750 char buf[BUFSIZ];
2751
2752 /* setup for reading amidst mmap */
Jiri Olsacc9784bd2013-10-15 16:27:34 +02002753 lseek(fd, offset + sizeof(struct tracing_data_event),
Tom Zanussi92155452010-04-01 23:59:21 -05002754 SEEK_SET);
2755
Jiri Olsa29f5ffd2013-12-03 14:09:23 +01002756 size_read = trace_report(fd, &session->tevent,
Arnaldo Carvalho de Meloda378962012-06-27 13:08:42 -03002757 session->repipe);
Irina Tirdea9ac3e482012-09-11 01:15:01 +03002758 padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
Tom Zanussi92155452010-04-01 23:59:21 -05002759
Jiri Olsacc9784bd2013-10-15 16:27:34 +02002760 if (readn(fd, buf, padding) < 0) {
Arnaldo Carvalho de Melo2caa48a2013-01-24 22:34:33 -03002761 pr_err("%s: reading input file", __func__);
2762 return -1;
2763 }
Tom Zanussi454c4072010-05-01 01:41:20 -05002764 if (session->repipe) {
2765 int retw = write(STDOUT_FILENO, buf, padding);
Arnaldo Carvalho de Melo2caa48a2013-01-24 22:34:33 -03002766 if (retw <= 0 || retw != padding) {
2767 pr_err("%s: repiping tracing data padding", __func__);
2768 return -1;
2769 }
Tom Zanussi454c4072010-05-01 01:41:20 -05002770 }
Tom Zanussi92155452010-04-01 23:59:21 -05002771
Arnaldo Carvalho de Melo2caa48a2013-01-24 22:34:33 -03002772 if (size_read + padding != size) {
2773 pr_err("%s: tracing data size mismatch", __func__);
2774 return -1;
2775 }
Tom Zanussi92155452010-04-01 23:59:21 -05002776
Namhyung Kim831394b2012-09-06 11:10:46 +09002777 perf_evlist__prepare_tracepoint_events(session->evlist,
Jiri Olsa29f5ffd2013-12-03 14:09:23 +01002778 session->tevent.pevent);
Arnaldo Carvalho de Melo8b6ee4c2012-08-07 23:36:16 -03002779
Tom Zanussi92155452010-04-01 23:59:21 -05002780 return size_read + padding;
2781}
Tom Zanussic7929e42010-04-01 23:59:22 -05002782
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02002783int perf_event__synthesize_build_id(struct perf_tool *tool,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002784 struct dso *pos, u16 misc,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002785 perf_event__handler_t process,
Arnaldo Carvalho de Melo743eb862011-11-28 07:56:39 -02002786 struct machine *machine)
Tom Zanussic7929e42010-04-01 23:59:22 -05002787{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002788 union perf_event ev;
Tom Zanussic7929e42010-04-01 23:59:22 -05002789 size_t len;
2790 int err = 0;
2791
2792 if (!pos->hit)
2793 return err;
2794
2795 memset(&ev, 0, sizeof(ev));
2796
2797 len = pos->long_name_len + 1;
Irina Tirdea9ac3e482012-09-11 01:15:01 +03002798 len = PERF_ALIGN(len, NAME_ALIGN);
Tom Zanussic7929e42010-04-01 23:59:22 -05002799 memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
2800 ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
2801 ev.build_id.header.misc = misc;
Arnaldo Carvalho de Melo23346f22010-04-27 21:17:50 -03002802 ev.build_id.pid = machine->pid;
Tom Zanussic7929e42010-04-01 23:59:22 -05002803 ev.build_id.header.size = sizeof(ev.build_id) + len;
2804 memcpy(&ev.build_id.filename, pos->long_name, pos->long_name_len);
2805
Arnaldo Carvalho de Melo45694aa2011-11-28 08:30:20 -02002806 err = process(tool, &ev, NULL, machine);
Tom Zanussic7929e42010-04-01 23:59:22 -05002807
2808 return err;
2809}
2810
Irina Tirdea1d037ca2012-09-11 01:15:03 +03002811int perf_event__process_build_id(struct perf_tool *tool __maybe_unused,
Arnaldo Carvalho de Melod20deb62011-11-25 08:19:45 -02002812 union perf_event *event,
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002813 struct perf_session *session)
Tom Zanussic7929e42010-04-01 23:59:22 -05002814{
Arnaldo Carvalho de Melo8115d602011-01-29 14:01:45 -02002815 __event_process_build_id(&event->build_id,
2816 event->build_id.filename,
Zhang, Yanmina1645ce2010-04-19 13:32:50 +08002817 session);
Tom Zanussic7929e42010-04-01 23:59:22 -05002818 return 0;
2819}