2012-01-04 16:54:20 +00: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-27 23:37:06 +00:00
|
|
|
#include "util.h"
|
2014-07-14 21:46:48 +00:00
|
|
|
#include "debug.h"
|
2013-12-09 16:14:24 +00:00
|
|
|
#include <api/fs/fs.h>
|
2010-01-16 13:21:15 +00:00
|
|
|
#include <sys/mman.h>
|
2013-09-30 10:07:11 +00:00
|
|
|
#ifdef HAVE_BACKTRACE_SUPPORT
|
2012-08-08 02:32:05 +00:00
|
|
|
#include <execinfo.h>
|
2012-09-08 00:43:23 +00:00
|
|
|
#endif
|
2012-08-08 02:32:05 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
2013-12-03 13:09:22 +00:00
|
|
|
#include <string.h>
|
|
|
|
#include <errno.h>
|
2013-12-11 12:36:23 +00:00
|
|
|
#include <limits.h>
|
2013-12-11 12:36:32 +00:00
|
|
|
#include <byteswap.h>
|
2013-11-28 10:30:15 +00:00
|
|
|
#include <linux/kernel.h>
|
2014-08-11 08:50:02 +00:00
|
|
|
#include <unistd.h>
|
2014-10-01 16:00:26 +00:00
|
|
|
#include "callchain.h"
|
|
|
|
|
|
|
|
struct callchain_param callchain_param = {
|
2015-10-05 20:05:35 +00:00
|
|
|
.mode = CHAIN_GRAPH_ABS,
|
2014-10-01 16:00:26 +00:00
|
|
|
.min_percent = 0.5,
|
2015-10-22 07:45:46 +00:00
|
|
|
.order = ORDER_CALLEE,
|
2014-10-01 16:00:26 +00:00
|
|
|
.key = CCKEY_FUNCTION
|
|
|
|
};
|
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-27 23:37:06 +00:00
|
|
|
|
2012-01-04 16:54:20 +00:00
|
|
|
/*
|
|
|
|
* XXX We need to find a better place for these things...
|
|
|
|
*/
|
2012-10-06 17:57:10 +00:00
|
|
|
unsigned int page_size;
|
2014-05-30 20:10:05 +00:00
|
|
|
int cacheline_size;
|
2012-10-06 17:57:10 +00:00
|
|
|
|
2012-12-13 19:43:04 +00:00
|
|
|
bool test_attr__enabled;
|
|
|
|
|
2012-01-04 16:54:20 +00:00
|
|
|
bool perf_host = true;
|
2012-02-10 17:05:05 +00:00
|
|
|
bool perf_guest = false;
|
2012-01-04 16:54:20 +00: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 15:12:38 +00:00
|
|
|
/* to capture ABI version */
|
|
|
|
attr->size = sizeof(*attr);
|
2012-01-04 16:54:20 +00: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-27 23:37:06 +00: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;
|
|
|
|
}
|
|
|
|
|
2015-05-18 00:30:17 +00:00
|
|
|
int rm_rf(char *path)
|
|
|
|
{
|
|
|
|
DIR *dir;
|
|
|
|
int ret = 0;
|
|
|
|
struct dirent *d;
|
|
|
|
char namebuf[PATH_MAX];
|
|
|
|
|
|
|
|
dir = opendir(path);
|
|
|
|
if (dir == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while ((d = readdir(dir)) != NULL && !ret) {
|
|
|
|
struct stat statbuf;
|
|
|
|
|
|
|
|
if (!strcmp(d->d_name, ".") || !strcmp(d->d_name, ".."))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
scnprintf(namebuf, sizeof(namebuf), "%s/%s",
|
|
|
|
path, d->d_name);
|
|
|
|
|
|
|
|
ret = stat(namebuf, &statbuf);
|
|
|
|
if (ret < 0) {
|
|
|
|
pr_debug("stat failed: %s\n", namebuf);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (S_ISREG(statbuf.st_mode))
|
|
|
|
ret = unlink(namebuf);
|
|
|
|
else if (S_ISDIR(statbuf.st_mode))
|
|
|
|
ret = rm_rf(namebuf);
|
|
|
|
else {
|
|
|
|
pr_debug("unknown file: %s\n", namebuf);
|
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
closedir(dir);
|
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return rmdir(path);
|
|
|
|
}
|
|
|
|
|
2015-06-08 14:50:16 +00:00
|
|
|
static int slow_copyfile(const char *from, const char *to)
|
2010-01-14 20:30:06 +00:00
|
|
|
{
|
2013-10-14 10:43:41 +00:00
|
|
|
int err = -1;
|
2010-01-14 20:30:06 +00:00
|
|
|
char *line = NULL;
|
|
|
|
size_t n;
|
|
|
|
FILE *from_fp = fopen(from, "r"), *to_fp;
|
|
|
|
|
|
|
|
if (from_fp == NULL)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
to_fp = fopen(to, "w");
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-05-18 00:30:18 +00:00
|
|
|
int copyfile_offset(int ifd, loff_t off_in, int ofd, loff_t off_out, u64 size)
|
|
|
|
{
|
|
|
|
void *ptr;
|
|
|
|
loff_t pgoff;
|
|
|
|
|
|
|
|
pgoff = off_in & ~(page_size - 1);
|
|
|
|
off_in -= pgoff;
|
|
|
|
|
|
|
|
ptr = mmap(NULL, off_in + size, PROT_READ, MAP_PRIVATE, ifd, pgoff);
|
|
|
|
if (ptr == MAP_FAILED)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
while (size) {
|
|
|
|
ssize_t ret = pwrite(ofd, ptr + off_in, size, off_out);
|
|
|
|
if (ret < 0 && errno == EINTR)
|
|
|
|
continue;
|
|
|
|
if (ret <= 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
size -= ret;
|
|
|
|
off_in += ret;
|
|
|
|
off_out -= ret;
|
|
|
|
}
|
|
|
|
munmap(ptr, off_in + size);
|
|
|
|
|
|
|
|
return size ? -1 : 0;
|
|
|
|
}
|
|
|
|
|
2013-10-14 10:43:41 +00: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-27 23:37:06 +00:00
|
|
|
{
|
|
|
|
int fromfd, tofd;
|
|
|
|
struct stat st;
|
|
|
|
int err = -1;
|
2015-06-08 14:50:16 +00:00
|
|
|
char *tmp = NULL, *ptr = NULL;
|
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-27 23:37:06 +00:00
|
|
|
|
|
|
|
if (stat(from, &st))
|
|
|
|
goto out;
|
|
|
|
|
2015-06-08 14:50:16 +00:00
|
|
|
/* extra 'x' at the end is to reserve space for '.' */
|
|
|
|
if (asprintf(&tmp, "%s.XXXXXXx", to) < 0) {
|
|
|
|
tmp = NULL;
|
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-27 23:37:06 +00:00
|
|
|
goto out;
|
2015-06-08 14:50:16 +00:00
|
|
|
}
|
|
|
|
ptr = strrchr(tmp, '/');
|
|
|
|
if (!ptr)
|
|
|
|
goto out;
|
|
|
|
ptr = memmove(ptr + 1, ptr, strlen(ptr) - 1);
|
|
|
|
*ptr = '.';
|
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-27 23:37:06 +00:00
|
|
|
|
2015-06-08 14:50:16 +00:00
|
|
|
tofd = mkstemp(tmp);
|
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-27 23:37:06 +00:00
|
|
|
if (tofd < 0)
|
2015-06-08 14:50:16 +00:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (fchmod(tofd, mode))
|
|
|
|
goto out_close_to;
|
|
|
|
|
|
|
|
if (st.st_size == 0) { /* /proc? do it slowly... */
|
|
|
|
err = slow_copyfile(from, tmp);
|
|
|
|
goto out_close_to;
|
|
|
|
}
|
|
|
|
|
|
|
|
fromfd = open(from, O_RDONLY);
|
|
|
|
if (fromfd < 0)
|
|
|
|
goto out_close_to;
|
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-27 23:37:06 +00:00
|
|
|
|
2015-05-18 00:30:18 +00:00
|
|
|
err = copyfile_offset(fromfd, 0, tofd, 0, st.st_size);
|
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-27 23:37:06 +00:00
|
|
|
|
|
|
|
close(fromfd);
|
2015-06-08 14:50:16 +00:00
|
|
|
out_close_to:
|
|
|
|
close(tofd);
|
|
|
|
if (!err)
|
|
|
|
err = link(tmp, to);
|
|
|
|
unlink(tmp);
|
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-27 23:37:06 +00:00
|
|
|
out:
|
2015-06-08 14:50:16 +00:00
|
|
|
free(tmp);
|
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-27 23:37:06 +00:00
|
|
|
return err;
|
|
|
|
}
|
2010-05-14 17:19:35 +00:00
|
|
|
|
2013-10-14 10:43:41 +00:00
|
|
|
int copyfile(const char *from, const char *to)
|
|
|
|
{
|
|
|
|
return copyfile_mode(from, to, 0755);
|
|
|
|
}
|
|
|
|
|
2010-05-14 17:19:35 +00: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-03 18:50:55 +00:00
|
|
|
|
2013-11-28 10:30:16 +00:00
|
|
|
static ssize_t ion(bool is_read, int fd, void *buf, size_t n)
|
2011-01-03 18:50:55 +00:00
|
|
|
{
|
|
|
|
void *buf_start = buf;
|
2013-11-28 10:30:15 +00:00
|
|
|
size_t left = n;
|
2011-01-03 18:50:55 +00:00
|
|
|
|
2013-11-28 10:30:15 +00:00
|
|
|
while (left) {
|
2013-11-28 10:30:16 +00:00
|
|
|
ssize_t ret = is_read ? read(fd, buf, left) :
|
|
|
|
write(fd, buf, left);
|
2011-01-03 18:50:55 +00:00
|
|
|
|
2014-04-24 13:27:32 +00:00
|
|
|
if (ret < 0 && errno == EINTR)
|
|
|
|
continue;
|
2011-01-03 18:50:55 +00:00
|
|
|
if (ret <= 0)
|
|
|
|
return ret;
|
|
|
|
|
2013-11-28 10:30:15 +00:00
|
|
|
left -= ret;
|
|
|
|
buf += ret;
|
2011-01-03 18:50:55 +00:00
|
|
|
}
|
|
|
|
|
2013-11-28 10:30:15 +00:00
|
|
|
BUG_ON((size_t)(buf - buf_start) != n);
|
|
|
|
return n;
|
2011-01-03 18:50:55 +00:00
|
|
|
}
|
2012-04-19 16:15:24 +00:00
|
|
|
|
2013-11-28 10:30:16 +00: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 16:15:24 +00:00
|
|
|
size_t hex_width(u64 v)
|
|
|
|
{
|
|
|
|
size_t n = 1;
|
|
|
|
|
|
|
|
while ((v >>= 4))
|
|
|
|
++n;
|
|
|
|
|
|
|
|
return n;
|
|
|
|
}
|
2012-08-08 02:32:05 +00:00
|
|
|
|
2012-10-27 21:18:30 +00: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 02:32:05 +00:00
|
|
|
/* Obtain a backtrace and print it to stdout. */
|
2013-09-30 10:07:11 +00:00
|
|
|
#ifdef HAVE_BACKTRACE_SUPPORT
|
2012-08-08 02:32:05 +00: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 00:43:23 +00:00
|
|
|
#else
|
|
|
|
void dump_stack(void) {}
|
|
|
|
#endif
|
2013-01-14 17:48:01 +00:00
|
|
|
|
2015-02-24 18:34:23 +00:00
|
|
|
void sighandler_dump_stack(int sig)
|
|
|
|
{
|
|
|
|
psignal(sig, "perf");
|
|
|
|
dump_stack();
|
|
|
|
exit(sig);
|
|
|
|
}
|
|
|
|
|
2013-01-14 17:48:01 +00: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 15:32:31 +00:00
|
|
|
|
2014-08-11 08:50:02 +00:00
|
|
|
void set_term_quiet_input(struct termios *old)
|
|
|
|
{
|
|
|
|
struct termios tc;
|
|
|
|
|
|
|
|
tcgetattr(0, old);
|
|
|
|
tc = *old;
|
|
|
|
tc.c_lflag &= ~(ICANON | ECHO);
|
|
|
|
tc.c_cc[VMIN] = 0;
|
|
|
|
tc.c_cc[VTIME] = 0;
|
|
|
|
tcsetattr(0, TCSANOW, &tc);
|
|
|
|
}
|
|
|
|
|
2013-06-04 01:50:29 +00: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 10:36:13 +00: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 07:34:17 +00:00
|
|
|
if (value > ULONG_MAX / i->mult)
|
|
|
|
break;
|
2013-09-01 10:36:13 +00:00
|
|
|
value *= i->mult;
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (unsigned long) -1;
|
|
|
|
}
|
2013-10-17 19:33:43 +00:00
|
|
|
|
2015-08-06 19:44:52 +00:00
|
|
|
int get_stack_size(const char *str, unsigned long *_size)
|
|
|
|
{
|
|
|
|
char *endptr;
|
|
|
|
unsigned long size;
|
|
|
|
unsigned long max_size = round_down(USHRT_MAX, sizeof(u64));
|
|
|
|
|
|
|
|
size = strtoul(str, &endptr, 0);
|
|
|
|
|
|
|
|
do {
|
|
|
|
if (*endptr)
|
|
|
|
break;
|
|
|
|
|
|
|
|
size = round_up(size, sizeof(u64));
|
|
|
|
if (!size || size > max_size)
|
|
|
|
break;
|
|
|
|
|
|
|
|
*_size = size;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
pr_err("callchain: Incorrect stack dump size (max %ld): %s\n",
|
|
|
|
max_size, str);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int parse_callchain_record(const char *arg, struct callchain_param *param)
|
|
|
|
{
|
|
|
|
char *tok, *name, *saveptr = NULL;
|
|
|
|
char *buf;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
/* We need buffer that we know we can write to. */
|
|
|
|
buf = malloc(strlen(arg) + 1);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
strcpy(buf, arg);
|
|
|
|
|
|
|
|
tok = strtok_r((char *)buf, ",", &saveptr);
|
|
|
|
name = tok ? : (char *)buf;
|
|
|
|
|
|
|
|
do {
|
|
|
|
/* Framepointer style */
|
|
|
|
if (!strncmp(name, "fp", sizeof("fp"))) {
|
|
|
|
if (!strtok_r(NULL, ",", &saveptr)) {
|
|
|
|
param->record_mode = CALLCHAIN_FP;
|
|
|
|
ret = 0;
|
|
|
|
} else
|
|
|
|
pr_err("callchain: No more arguments "
|
|
|
|
"needed for --call-graph fp\n");
|
|
|
|
break;
|
|
|
|
|
|
|
|
#ifdef HAVE_DWARF_UNWIND_SUPPORT
|
|
|
|
/* Dwarf style */
|
|
|
|
} else if (!strncmp(name, "dwarf", sizeof("dwarf"))) {
|
|
|
|
const unsigned long default_stack_dump_size = 8192;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
param->record_mode = CALLCHAIN_DWARF;
|
|
|
|
param->dump_size = default_stack_dump_size;
|
|
|
|
|
|
|
|
tok = strtok_r(NULL, ",", &saveptr);
|
|
|
|
if (tok) {
|
|
|
|
unsigned long size = 0;
|
|
|
|
|
|
|
|
ret = get_stack_size(tok, &size);
|
|
|
|
param->dump_size = size;
|
|
|
|
}
|
|
|
|
#endif /* HAVE_DWARF_UNWIND_SUPPORT */
|
|
|
|
} else if (!strncmp(name, "lbr", sizeof("lbr"))) {
|
|
|
|
if (!strtok_r(NULL, ",", &saveptr)) {
|
|
|
|
param->record_mode = CALLCHAIN_LBR;
|
|
|
|
ret = 0;
|
|
|
|
} else
|
|
|
|
pr_err("callchain: No more arguments "
|
|
|
|
"needed for --call-graph lbr\n");
|
|
|
|
break;
|
|
|
|
} else {
|
|
|
|
pr_err("callchain: Unknown --call-graph option "
|
|
|
|
"value: %s\n", arg);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
} while (0);
|
|
|
|
|
|
|
|
free(buf);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2013-12-03 13:09:22 +00: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;
|
2014-08-14 02:22:36 +00:00
|
|
|
char sbuf[STRERR_BUFSIZE];
|
2013-12-03 13:09:22 +00:00
|
|
|
|
|
|
|
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) {
|
2014-08-14 02:22:36 +00:00
|
|
|
pr_warning("read failed %d: %s\n", errno,
|
|
|
|
strerror_r(errno, sbuf, sizeof(sbuf)));
|
2013-12-03 13:09:22 +00:00
|
|
|
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-06 22:25:51 +00: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 12:36:23 +00:00
|
|
|
|
|
|
|
int perf_event_paranoid(void)
|
|
|
|
{
|
|
|
|
int value;
|
|
|
|
|
2014-12-11 16:37:59 +00:00
|
|
|
if (sysctl__read_int("kernel/perf_event_paranoid", &value))
|
2013-12-11 12:36:23 +00:00
|
|
|
return INT_MAX;
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
2013-12-11 12:36:32 +00: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;
|
|
|
|
}
|
|
|
|
}
|
2014-08-01 15:46:54 +00:00
|
|
|
|
|
|
|
bool find_process(const char *name)
|
|
|
|
{
|
|
|
|
size_t len = strlen(name);
|
|
|
|
DIR *dir;
|
|
|
|
struct dirent *d;
|
|
|
|
int ret = -1;
|
|
|
|
|
|
|
|
dir = opendir(procfs__mountpoint());
|
|
|
|
if (!dir)
|
2015-09-17 10:08:53 +00:00
|
|
|
return false;
|
2014-08-01 15:46:54 +00:00
|
|
|
|
|
|
|
/* Walk through the directory. */
|
|
|
|
while (ret && (d = readdir(dir)) != NULL) {
|
|
|
|
char path[PATH_MAX];
|
|
|
|
char *data;
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
if ((d->d_type != DT_DIR) ||
|
|
|
|
!strcmp(".", d->d_name) ||
|
|
|
|
!strcmp("..", d->d_name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
scnprintf(path, sizeof(path), "%s/%s/comm",
|
|
|
|
procfs__mountpoint(), d->d_name);
|
|
|
|
|
|
|
|
if (filename__read_str(path, &data, &size))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
ret = strncmp(name, data, len);
|
|
|
|
free(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
closedir(dir);
|
|
|
|
return ret ? false : true;
|
|
|
|
}
|