2012-01-04 23:54:20 +07:00
|
|
|
#include "../perf.h"
|
perf record: Introduce a symtab cache
Now a cache will be created in a ~/.debug debuginfo like
hierarchy, so that at the end of a 'perf record' session all the
binaries (with build-ids) involved get collected and indexed by
their build-ids, so that perf report can find them.
This is interesting when developing software where you want to
do a 'perf diff' with the previous build and opens avenues for
lots more interesting tools, like a 'perf diff --graph' that
takes more than two binaries into account.
Tunables for collecting just the symtabs can be added if one
doesn't want to have the full binary, but having the full binary
allows things like 'perf rerecord' or other tools that can
re-run the tests by having access to the exact binary in some
perf.data file, so it may well be interesting to keep the full
binary there.
Space consumption is minimised by trying to use hard links, a
'perf cache' tool to manage the space used, a la ccache is
required to purge older entries.
With this in place it will be possible also to introduce new
commands, 'perf archive' and 'perf restore' (or some more
suitable and future proof names) to create a cpio/tar file with
the perf data and the files in the cache that _had_ perf hits of
interest.
There are more aspects to polish, like finding the right vmlinux
file to cache, etc, but this is enough for a first step.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1261957026-15580-10-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-28 06:37:06 +07:00
|
|
|
#include "util.h"
|
2013-12-09 23:14:24 +07:00
|
|
|
#include <api/fs/fs.h>
|
2010-01-16 20:21:15 +07:00
|
|
|
#include <sys/mman.h>
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_BACKTRACE_SUPPORT
|
2012-08-08 09:32:05 +07:00
|
|
|
#include <execinfo.h>
|
2012-09-08 07:43:23 +07:00
|
|
|
#endif
|
2012-08-08 09:32:05 +07:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2013-12-03 20:09:22 +07:00
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
2013-12-11 19:36:23 +07:00
|
|
|
#include <limits.h>
|
2013-12-11 19:36:32 +07:00
|
|
|
#include <byteswap.h>
|
2013-11-28 17:30:15 +07:00
|
|
|
#include <linux/kernel.h>
|
perf record: Introduce a symtab cache
Now a cache will be created in a ~/.debug debuginfo like
hierarchy, so that at the end of a 'perf record' session all the
binaries (with build-ids) involved get collected and indexed by
their build-ids, so that perf report can find them.
This is interesting when developing software where you want to
do a 'perf diff' with the previous build and opens avenues for
lots more interesting tools, like a 'perf diff --graph' that
takes more than two binaries into account.
Tunables for collecting just the symtabs can be added if one
doesn't want to have the full binary, but having the full binary
allows things like 'perf rerecord' or other tools that can
re-run the tests by having access to the exact binary in some
perf.data file, so it may well be interesting to keep the full
binary there.
Space consumption is minimised by trying to use hard links, a
'perf cache' tool to manage the space used, a la ccache is
required to purge older entries.
With this in place it will be possible also to introduce new
commands, 'perf archive' and 'perf restore' (or some more
suitable and future proof names) to create a cpio/tar file with
the perf data and the files in the cache that _had_ perf hits of
interest.
There are more aspects to polish, like finding the right vmlinux
file to cache, etc, but this is enough for a first step.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1261957026-15580-10-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-28 06:37:06 +07:00
|
|
|
|
2012-01-04 23:54:20 +07:00
|
|
|
/*
|
|
|
|
* XXX We need to find a better place for these things...
|
|
|
|
*/
|
2012-10-07 00:57:10 +07:00
|
|
|
unsigned int page_size;
|
|
|
|
|
2012-12-14 02:43:04 +07:00
|
|
|
bool test_attr__enabled;
|
|
|
|
|
2012-01-04 23:54:20 +07:00
|
|
|
bool perf_host = true;
|
2012-02-11 00:05:05 +07:00
|
|
|
bool perf_guest = false;
|
2012-01-04 23:54:20 +07:00
|
|
|
|
2013-02-20 22:32:31 +07:00
|
|
|
char tracing_events_path[PATH_MAX + 1] = "/sys/kernel/debug/tracing/events";
|
|
|
|
|
2012-01-04 23:54:20 +07:00
|
|
|
void event_attr_init(struct perf_event_attr *attr)
|
|
|
|
{
|
|
|
|
if (!perf_host)
|
|
|
|
attr->exclude_host = 1;
|
|
|
|
if (!perf_guest)
|
|
|
|
attr->exclude_guest = 1;
|
2012-02-09 22:12:38 +07:00
|
|
|
/* to capture ABI version */
|
|
|
|
attr->size = sizeof(*attr);
|
2012-01-04 23:54:20 +07:00
|
|
|
}
|
|
|
|
|
perf record: Introduce a symtab cache
Now a cache will be created in a ~/.debug debuginfo like
hierarchy, so that at the end of a 'perf record' session all the
binaries (with build-ids) involved get collected and indexed by
their build-ids, so that perf report can find them.
This is interesting when developing software where you want to
do a 'perf diff' with the previous build and opens avenues for
lots more interesting tools, like a 'perf diff --graph' that
takes more than two binaries into account.
Tunables for collecting just the symtabs can be added if one
doesn't want to have the full binary, but having the full binary
allows things like 'perf rerecord' or other tools that can
re-run the tests by having access to the exact binary in some
perf.data file, so it may well be interesting to keep the full
binary there.
Space consumption is minimised by trying to use hard links, a
'perf cache' tool to manage the space used, a la ccache is
required to purge older entries.
With this in place it will be possible also to introduce new
commands, 'perf archive' and 'perf restore' (or some more
suitable and future proof names) to create a cpio/tar file with
the perf data and the files in the cache that _had_ perf hits of
interest.
There are more aspects to polish, like finding the right vmlinux
file to cache, etc, but this is enough for a first step.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1261957026-15580-10-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-28 06:37:06 +07:00
|
|
|
int mkdir_p(char *path, mode_t mode)
|
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
int err;
|
|
|
|
char *d = path;
|
|
|
|
|
|
|
|
if (*d != '/')
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (stat(path, &st) == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while (*++d == '/');
|
|
|
|
|
|
|
|
while ((d = strchr(d, '/'))) {
|
|
|
|
*d = '\0';
|
|
|
|
err = stat(path, &st) && mkdir(path, mode);
|
|
|
|
*d++ = '/';
|
|
|
|
if (err)
|
|
|
|
return -1;
|
|
|
|
while (*d == '/')
|
|
|
|
++d;
|
|
|
|
}
|
|
|
|
return (stat(path, &st) && mkdir(path, mode)) ? -1 : 0;
|
|
|
|
}
|
|
|
|
|
2013-10-14 17:43:41 +07:00
|
|
|
static int slow_copyfile(const char *from, const char *to, mode_t mode)
|
2010-01-15 03:30:06 +07:00
|
|
|
{
|
2013-10-14 17:43:41 +07:00
|
|
|
int err = -1;
|
2010-01-15 03:30:06 +07:00
|
|
|
char *line = NULL;
|
|
|
|
size_t n;
|
|
|
|
FILE *from_fp = fopen(from, "r"), *to_fp;
|
2013-10-14 17:43:41 +07:00
|
|
|
mode_t old_umask;
|
2010-01-15 03:30:06 +07:00
|
|
|
|
|
|
|
if (from_fp == NULL)
|
|
|
|
goto out;
|
|
|
|
|
2013-10-14 17:43:41 +07:00
|
|
|
old_umask = umask(mode ^ 0777);
|
2010-01-15 03:30:06 +07:00
|
|
|
to_fp = fopen(to, "w");
|
2013-10-14 17:43:41 +07:00
|
|
|
umask(old_umask);
|
2010-01-15 03:30:06 +07:00
|
|
|
if (to_fp == NULL)
|
|
|
|
goto out_fclose_from;
|
|
|
|
|
|
|
|
while (getline(&line, &n, from_fp) > 0)
|
|
|
|
if (fputs(line, to_fp) == EOF)
|
|
|
|
goto out_fclose_to;
|
|
|
|
err = 0;
|
|
|
|
out_fclose_to:
|
|
|
|
fclose(to_fp);
|
|
|
|
free(line);
|
|
|
|
out_fclose_from:
|
|
|
|
fclose(from_fp);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2013-10-14 17:43:41 +07:00
|
|
|
int copyfile_mode(const char *from, const char *to, mode_t mode)
|
perf record: Introduce a symtab cache
Now a cache will be created in a ~/.debug debuginfo like
hierarchy, so that at the end of a 'perf record' session all the
binaries (with build-ids) involved get collected and indexed by
their build-ids, so that perf report can find them.
This is interesting when developing software where you want to
do a 'perf diff' with the previous build and opens avenues for
lots more interesting tools, like a 'perf diff --graph' that
takes more than two binaries into account.
Tunables for collecting just the symtabs can be added if one
doesn't want to have the full binary, but having the full binary
allows things like 'perf rerecord' or other tools that can
re-run the tests by having access to the exact binary in some
perf.data file, so it may well be interesting to keep the full
binary there.
Space consumption is minimised by trying to use hard links, a
'perf cache' tool to manage the space used, a la ccache is
required to purge older entries.
With this in place it will be possible also to introduce new
commands, 'perf archive' and 'perf restore' (or some more
suitable and future proof names) to create a cpio/tar file with
the perf data and the files in the cache that _had_ perf hits of
interest.
There are more aspects to polish, like finding the right vmlinux
file to cache, etc, but this is enough for a first step.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1261957026-15580-10-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-28 06:37:06 +07:00
|
|
|
{
|
|
|
|
int fromfd, tofd;
|
|
|
|
struct stat st;
|
|
|
|
void *addr;
|
|
|
|
int err = -1;
|
|
|
|
|
|
|
|
if (stat(from, &st))
|
|
|
|
goto out;
|
|
|
|
|
2010-01-15 03:30:06 +07:00
|
|
|
if (st.st_size == 0) /* /proc? do it slowly... */
|
2013-10-14 17:43:41 +07:00
|
|
|
return slow_copyfile(from, to, mode);
|
2010-01-15 03:30:06 +07:00
|
|
|
|
perf record: Introduce a symtab cache
Now a cache will be created in a ~/.debug debuginfo like
hierarchy, so that at the end of a 'perf record' session all the
binaries (with build-ids) involved get collected and indexed by
their build-ids, so that perf report can find them.
This is interesting when developing software where you want to
do a 'perf diff' with the previous build and opens avenues for
lots more interesting tools, like a 'perf diff --graph' that
takes more than two binaries into account.
Tunables for collecting just the symtabs can be added if one
doesn't want to have the full binary, but having the full binary
allows things like 'perf rerecord' or other tools that can
re-run the tests by having access to the exact binary in some
perf.data file, so it may well be interesting to keep the full
binary there.
Space consumption is minimised by trying to use hard links, a
'perf cache' tool to manage the space used, a la ccache is
required to purge older entries.
With this in place it will be possible also to introduce new
commands, 'perf archive' and 'perf restore' (or some more
suitable and future proof names) to create a cpio/tar file with
the perf data and the files in the cache that _had_ perf hits of
interest.
There are more aspects to polish, like finding the right vmlinux
file to cache, etc, but this is enough for a first step.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1261957026-15580-10-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-28 06:37:06 +07:00
|
|
|
fromfd = open(from, O_RDONLY);
|
|
|
|
if (fromfd < 0)
|
|
|
|
goto out;
|
|
|
|
|
2013-10-14 17:43:41 +07:00
|
|
|
tofd = creat(to, mode);
|
perf record: Introduce a symtab cache
Now a cache will be created in a ~/.debug debuginfo like
hierarchy, so that at the end of a 'perf record' session all the
binaries (with build-ids) involved get collected and indexed by
their build-ids, so that perf report can find them.
This is interesting when developing software where you want to
do a 'perf diff' with the previous build and opens avenues for
lots more interesting tools, like a 'perf diff --graph' that
takes more than two binaries into account.
Tunables for collecting just the symtabs can be added if one
doesn't want to have the full binary, but having the full binary
allows things like 'perf rerecord' or other tools that can
re-run the tests by having access to the exact binary in some
perf.data file, so it may well be interesting to keep the full
binary there.
Space consumption is minimised by trying to use hard links, a
'perf cache' tool to manage the space used, a la ccache is
required to purge older entries.
With this in place it will be possible also to introduce new
commands, 'perf archive' and 'perf restore' (or some more
suitable and future proof names) to create a cpio/tar file with
the perf data and the files in the cache that _had_ perf hits of
interest.
There are more aspects to polish, like finding the right vmlinux
file to cache, etc, but this is enough for a first step.
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1261957026-15580-10-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
2009-12-28 06:37:06 +07:00
|
|
|
if (tofd < 0)
|
|
|
|
goto out_close_from;
|
|
|
|
|
|
|
|
addr = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fromfd, 0);
|
|
|
|
if (addr == MAP_FAILED)
|
|
|
|
goto out_close_to;
|
|
|
|
|
|
|
|
if (write(tofd, addr, st.st_size) == st.st_size)
|
|
|
|
err = 0;
|
|
|
|
|
|
|
|
munmap(addr, st.st_size);
|
|
|
|
out_close_to:
|
|
|
|
close(tofd);
|
|
|
|
if (err)
|
|
|
|
unlink(to);
|
|
|
|
out_close_from:
|
|
|
|
close(fromfd);
|
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
2010-05-15 00:19:35 +07:00
|
|
|
|
2013-10-14 17:43:41 +07:00
|
|
|
int copyfile(const char *from, const char *to)
|
|
|
|
{
|
|
|
|
return copyfile_mode(from, to, 0755);
|
|
|
|
}
|
|
|
|
|
2010-05-15 00:19:35 +07:00
|
|
|
unsigned long convert_unit(unsigned long value, char *unit)
|
|
|
|
{
|
|
|
|
*unit = ' ';
|
|
|
|
|
|
|
|
if (value > 1000) {
|
|
|
|
value /= 1000;
|
|
|
|
*unit = 'K';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value > 1000) {
|
|
|
|
value /= 1000;
|
|
|
|
*unit = 'M';
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value > 1000) {
|
|
|
|
value /= 1000;
|
|
|
|
*unit = 'G';
|
|
|
|
}
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
2011-01-04 01:50:55 +07:00
|
|
|
|
2013-11-28 17:30:16 +07:00
|
|
|
static ssize_t ion(bool is_read, int fd, void *buf, size_t n)
|
2011-01-04 01:50:55 +07:00
|
|
|
{
|
|
|
|
void *buf_start = buf;
|
2013-11-28 17:30:15 +07:00
|
|
|
size_t left = n;
|
2011-01-04 01:50:55 +07:00
|
|
|
|
2013-11-28 17:30:15 +07:00
|
|
|
while (left) {
|
2013-11-28 17:30:16 +07:00
|
|
|
ssize_t ret = is_read ? read(fd, buf, left) :
|
|
|
|
write(fd, buf, left);
|
2011-01-04 01:50:55 +07:00
|
|
|
|
2014-04-24 20:27:32 +07:00
|
|
|
if (ret < 0 && errno == EINTR)
|
|
|
|
continue;
|
2011-01-04 01:50:55 +07:00
|
|
|
if (ret <= 0)
|
|
|
|
return ret;
|
|
|
|
|
2013-11-28 17:30:15 +07:00
|
|
|
left -= ret;
|
|
|
|
buf += ret;
|
2011-01-04 01:50:55 +07:00
|
|
|
}
|
|
|
|
|
2013-11-28 17:30:15 +07:00
|
|
|
BUG_ON((size_t)(buf - buf_start) != n);
|
|
|
|
return n;
|
2011-01-04 01:50:55 +07:00
|
|
|
}
|
2012-04-19 23:15:24 +07:00
|
|
|
|
2013-11-28 17:30:16 +07:00
|
|
|
/*
|
|
|
|
* Read exactly 'n' bytes or return an error.
|
|
|
|
*/
|
|
|
|
ssize_t readn(int fd, void *buf, size_t n)
|
|
|
|
{
|
|
|
|
return ion(true, fd, buf, n);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Write exactly 'n' bytes or return an error.
|
|
|
|
*/
|
|
|
|
ssize_t writen(int fd, void *buf, size_t n)
|
|
|
|
{
|
|
|
|
return ion(false, fd, buf, n);
|
|
|
|
}
|
|
|
|
|
2012-04-19 23:15:24 +07:00
|
|
|
size_t hex_width(u64 v)
|
|
|
|
{
|
|
|
|
size_t n = 1;
|
|
|
|
|
|
|
|
while ((v >>= 4))
|
|
|
|
++n;
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
2012-08-08 09:32:05 +07:00
|
|
|
|
2012-10-28 04:18:30 +07:00
|
|
|
static int hex(char ch)
|
|
|
|
{
|
|
|
|
if ((ch >= '0') && (ch <= '9'))
|
|
|
|
return ch - '0';
|
|
|
|
if ((ch >= 'a') && (ch <= 'f'))
|
|
|
|
return ch - 'a' + 10;
|
|
|
|
if ((ch >= 'A') && (ch <= 'F'))
|
|
|
|
return ch - 'A' + 10;
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* While we find nice hex chars, build a long_val.
|
|
|
|
* Return number of chars processed.
|
|
|
|
*/
|
|
|
|
int hex2u64(const char *ptr, u64 *long_val)
|
|
|
|
{
|
|
|
|
const char *p = ptr;
|
|
|
|
*long_val = 0;
|
|
|
|
|
|
|
|
while (*p) {
|
|
|
|
const int hex_val = hex(*p);
|
|
|
|
|
|
|
|
if (hex_val < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
*long_val = (*long_val << 4) | hex_val;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return p - ptr;
|
|
|
|
}
|
|
|
|
|
2012-08-08 09:32:05 +07:00
|
|
|
/* Obtain a backtrace and print it to stdout. */
|
2013-09-30 17:07:11 +07:00
|
|
|
#ifdef HAVE_BACKTRACE_SUPPORT
|
2012-08-08 09:32:05 +07:00
|
|
|
void dump_stack(void)
|
|
|
|
{
|
|
|
|
void *array[16];
|
|
|
|
size_t size = backtrace(array, ARRAY_SIZE(array));
|
|
|
|
char **strings = backtrace_symbols(array, size);
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
printf("Obtained %zd stack frames.\n", size);
|
|
|
|
|
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
printf("%s\n", strings[i]);
|
|
|
|
|
|
|
|
free(strings);
|
|
|
|
}
|
2012-09-08 07:43:23 +07:00
|
|
|
#else
|
|
|
|
void dump_stack(void) {}
|
|
|
|
#endif
|
2013-01-15 00:48:01 +07:00
|
|
|
|
|
|
|
void get_term_dimensions(struct winsize *ws)
|
|
|
|
{
|
|
|
|
char *s = getenv("LINES");
|
|
|
|
|
|
|
|
if (s != NULL) {
|
|
|
|
ws->ws_row = atoi(s);
|
|
|
|
s = getenv("COLUMNS");
|
|
|
|
if (s != NULL) {
|
|
|
|
ws->ws_col = atoi(s);
|
|
|
|
if (ws->ws_row && ws->ws_col)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef TIOCGWINSZ
|
|
|
|
if (ioctl(1, TIOCGWINSZ, ws) == 0 &&
|
|
|
|
ws->ws_row && ws->ws_col)
|
|
|
|
return;
|
|
|
|
#endif
|
|
|
|
ws->ws_row = 25;
|
|
|
|
ws->ws_col = 80;
|
|
|
|
}
|
2013-02-20 22:32:31 +07:00
|
|
|
|
|
|
|
static void set_tracing_events_path(const char *mountpoint)
|
|
|
|
{
|
|
|
|
snprintf(tracing_events_path, sizeof(tracing_events_path), "%s/%s",
|
|
|
|
mountpoint, "tracing/events");
|
|
|
|
}
|
|
|
|
|
|
|
|
const char *perf_debugfs_mount(const char *mountpoint)
|
|
|
|
{
|
|
|
|
const char *mnt;
|
|
|
|
|
|
|
|
mnt = debugfs_mount(mountpoint);
|
|
|
|
if (!mnt)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
set_tracing_events_path(mnt);
|
|
|
|
|
|
|
|
return mnt;
|
|
|
|
}
|
|
|
|
|
|
|
|
void perf_debugfs_set_path(const char *mntpt)
|
|
|
|
{
|
|
|
|
snprintf(debugfs_mountpoint, strlen(debugfs_mountpoint), "%s", mntpt);
|
|
|
|
set_tracing_events_path(mntpt);
|
|
|
|
}
|
2013-06-26 14:14:04 +07:00
|
|
|
|
|
|
|
static const char *find_debugfs(void)
|
|
|
|
{
|
|
|
|
const char *path = perf_debugfs_mount(NULL);
|
|
|
|
|
|
|
|
if (!path)
|
|
|
|
fprintf(stderr, "Your kernel does not support the debugfs filesystem");
|
|
|
|
|
|
|
|
return path;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Finds the path to the debugfs/tracing
|
|
|
|
* Allocates the string and stores it.
|
|
|
|
*/
|
|
|
|
const char *find_tracing_dir(void)
|
|
|
|
{
|
|
|
|
static char *tracing;
|
|
|
|
static int tracing_found;
|
|
|
|
const char *debugfs;
|
|
|
|
|
|
|
|
if (tracing_found)
|
|
|
|
return tracing;
|
|
|
|
|
|
|
|
debugfs = find_debugfs();
|
|
|
|
if (!debugfs)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
tracing = malloc(strlen(debugfs) + 9);
|
|
|
|
if (!tracing)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
sprintf(tracing, "%s/tracing", debugfs);
|
|
|
|
|
|
|
|
tracing_found = 1;
|
|
|
|
return tracing;
|
|
|
|
}
|
|
|
|
|
|
|
|
char *get_tracing_file(const char *name)
|
|
|
|
{
|
|
|
|
const char *tracing;
|
|
|
|
char *file;
|
|
|
|
|
|
|
|
tracing = find_tracing_dir();
|
|
|
|
if (!tracing)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
file = malloc(strlen(tracing) + strlen(name) + 2);
|
|
|
|
if (!file)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
sprintf(file, "%s/%s", tracing, name);
|
|
|
|
return file;
|
|
|
|
}
|
|
|
|
|
|
|
|
void put_tracing_file(char *file)
|
|
|
|
{
|
|
|
|
free(file);
|
|
|
|
}
|
2013-06-04 08:50:29 +07:00
|
|
|
|
|
|
|
int parse_nsec_time(const char *str, u64 *ptime)
|
|
|
|
{
|
|
|
|
u64 time_sec, time_nsec;
|
|
|
|
char *end;
|
|
|
|
|
|
|
|
time_sec = strtoul(str, &end, 10);
|
|
|
|
if (*end != '.' && *end != '\0')
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (*end == '.') {
|
|
|
|
int i;
|
|
|
|
char nsec_buf[10];
|
|
|
|
|
|
|
|
if (strlen(++end) > 9)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
strncpy(nsec_buf, end, 9);
|
|
|
|
nsec_buf[9] = '\0';
|
|
|
|
|
|
|
|
/* make it nsec precision */
|
|
|
|
for (i = strlen(nsec_buf); i < 9; i++)
|
|
|
|
nsec_buf[i] = '0';
|
|
|
|
|
|
|
|
time_nsec = strtoul(nsec_buf, &end, 10);
|
|
|
|
if (*end != '\0')
|
|
|
|
return -1;
|
|
|
|
} else
|
|
|
|
time_nsec = 0;
|
|
|
|
|
|
|
|
*ptime = time_sec * NSEC_PER_SEC + time_nsec;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-09-01 17:36:13 +07:00
|
|
|
|
|
|
|
unsigned long parse_tag_value(const char *str, struct parse_tag *tags)
|
|
|
|
{
|
|
|
|
struct parse_tag *i = tags;
|
|
|
|
|
|
|
|
while (i->tag) {
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
s = strchr(str, i->tag);
|
|
|
|
if (s) {
|
|
|
|
unsigned long int value;
|
|
|
|
char *endptr;
|
|
|
|
|
|
|
|
value = strtoul(str, &endptr, 10);
|
|
|
|
if (s != endptr)
|
|
|
|
break;
|
|
|
|
|
2013-10-22 14:34:17 +07:00
|
|
|
if (value > ULONG_MAX / i->mult)
|
|
|
|
break;
|
2013-09-01 17:36:13 +07:00
|
|
|
value *= i->mult;
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (unsigned long) -1;
|
|
|
|
}
|
2013-10-18 02:33:43 +07:00
|
|
|
|
|
|
|
int filename__read_int(const char *filename, int *value)
|
|
|
|
{
|
|
|
|
char line[64];
|
|
|
|
int fd = open(filename, O_RDONLY), err = -1;
|
|
|
|
|
|
|
|
if (fd < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (read(fd, line, sizeof(line)) > 0) {
|
|
|
|
*value = atoi(line);
|
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
return err;
|
|
|
|
}
|
2013-12-03 20:09:22 +07:00
|
|
|
|
|
|
|
int filename__read_str(const char *filename, char **buf, size_t *sizep)
|
|
|
|
{
|
|
|
|
size_t size = 0, alloc_size = 0;
|
|
|
|
void *bf = NULL, *nbf;
|
|
|
|
int fd, n, err = 0;
|
|
|
|
|
|
|
|
fd = open(filename, O_RDONLY);
|
|
|
|
if (fd < 0)
|
|
|
|
return -errno;
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (size == alloc_size) {
|
|
|
|
alloc_size += BUFSIZ;
|
|
|
|
nbf = realloc(bf, alloc_size);
|
|
|
|
if (!nbf) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
bf = nbf;
|
|
|
|
}
|
|
|
|
|
|
|
|
n = read(fd, bf + size, alloc_size - size);
|
|
|
|
if (n < 0) {
|
|
|
|
if (size) {
|
|
|
|
pr_warning("read failed %d: %s\n",
|
|
|
|
errno, strerror(errno));
|
|
|
|
err = 0;
|
|
|
|
} else
|
|
|
|
err = -errno;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
size += n;
|
|
|
|
} while (n > 0);
|
|
|
|
|
|
|
|
if (!err) {
|
|
|
|
*sizep = size;
|
|
|
|
*buf = bf;
|
|
|
|
} else
|
|
|
|
free(bf);
|
|
|
|
|
|
|
|
close(fd);
|
|
|
|
return err;
|
|
|
|
}
|
2013-12-07 05:25:51 +07:00
|
|
|
|
|
|
|
const char *get_filename_for_perf_kvm(void)
|
|
|
|
{
|
|
|
|
const char *filename;
|
|
|
|
|
|
|
|
if (perf_host && !perf_guest)
|
|
|
|
filename = strdup("perf.data.host");
|
|
|
|
else if (!perf_host && perf_guest)
|
|
|
|
filename = strdup("perf.data.guest");
|
|
|
|
else
|
|
|
|
filename = strdup("perf.data.kvm");
|
|
|
|
|
|
|
|
return filename;
|
|
|
|
}
|
2013-12-11 19:36:23 +07:00
|
|
|
|
|
|
|
int perf_event_paranoid(void)
|
|
|
|
{
|
|
|
|
char path[PATH_MAX];
|
|
|
|
const char *procfs = procfs__mountpoint();
|
|
|
|
int value;
|
|
|
|
|
|
|
|
if (!procfs)
|
|
|
|
return INT_MAX;
|
|
|
|
|
|
|
|
scnprintf(path, PATH_MAX, "%s/sys/kernel/perf_event_paranoid", procfs);
|
|
|
|
|
|
|
|
if (filename__read_int(path, &value))
|
|
|
|
return INT_MAX;
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
2013-12-11 19:36:32 +07:00
|
|
|
|
|
|
|
void mem_bswap_32(void *src, int byte_size)
|
|
|
|
{
|
|
|
|
u32 *m = src;
|
|
|
|
while (byte_size > 0) {
|
|
|
|
*m = bswap_32(*m);
|
|
|
|
byte_size -= sizeof(u32);
|
|
|
|
++m;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void mem_bswap_64(void *src, int byte_size)
|
|
|
|
{
|
|
|
|
u64 *m = src;
|
|
|
|
|
|
|
|
while (byte_size > 0) {
|
|
|
|
*m = bswap_64(*m);
|
|
|
|
byte_size -= sizeof(u64);
|
|
|
|
++m;
|
|
|
|
}
|
|
|
|
}
|