mirror of
https://github.com/torvalds/linux.git
synced 2024-12-27 21:33:00 +00:00
perf data: Add perf data to CTF conversion support
Adding 'perf data convert' to convert perf data file into different
format. This patch adds support for CTF format conversion.
To convert perf.data into CTF run:
$ perf data convert --to-ctf=./ctf-data/
[ perf data convert: Converted 'perf.data' into CTF data './ctf-data/' ]
[ perf data convert: Converted and wrote 11.268 MB (100230 samples) ]
The command will create CTF metadata out of perf.data file (or one
specified via -i option) and then convert all sample events into single
CTF stream.
Each sample_type bit is translated into separated CTF event field apart
from following exceptions:
PERF_SAMPLE_RAW - added in next patch
PERF_SAMPLE_READ - TODO
PERF_SAMPLE_CALLCHAIN - TODO
PERF_SAMPLE_BRANCH_STACK - TODO
PERF_SAMPLE_REGS_USER - TODO
PERF_SAMPLE_STACK_USER - TODO
$ perf --debug=data-convert=2 data convert ...
The converted CTF data could be analyzed by CTF tools, like babletrace
or tracecompass [1].
$ babeltrace ./ctf-data/
[03:19:13.962125533] (+?.?????????) cycles: { }, { ip = 0xFFFFFFFF8105443A, tid = 20714, pid = 20714, period = 1 }
[03:19:13.962130001] (+0.000004468) cycles: { }, { ip = 0xFFFFFFFF8105443A, tid = 20714, pid = 20714, period = 1 }
[03:19:13.962131936] (+0.000001935) cycles: { }, { ip = 0xFFFFFFFF8105443A, tid = 20714, pid = 20714, period = 8 }
[03:19:13.962133732] (+0.000001796) cycles: { }, { ip = 0xFFFFFFFF8105443A, tid = 20714, pid = 20714, period = 114 }
[03:19:13.962135557] (+0.000001825) cycles: { }, { ip = 0xFFFFFFFF8105443A, tid = 20714, pid = 20714, period = 2087 }
[03:19:13.962137627] (+0.000002070) cycles: { }, { ip = 0xFFFFFFFF81361938, tid = 20714, pid = 20714, period = 37582 }
[03:19:13.962161091] (+0.000023464) cycles: { }, { ip = 0xFFFFFFFF8124218F, tid = 20714, pid = 20714, period = 600246 }
[03:19:13.962517569] (+0.000356478) cycles: { }, { ip = 0xFFFFFFFF811A75DB, tid = 20714, pid = 20714, period = 1325731 }
[03:19:13.969518008] (+0.007000439) cycles: { }, { ip = 0x34080917B2, tid = 20714, pid = 20714, period = 1144298 }
The following members to the ctf-environment were decided to be added to
distinguish and specify perf CTF data:
- domain
It says "kernel" because it contains a kernel trace (not to be
confused with a user space like lttng-ust does)
- tracer_name
It says perf. This can be used to distinguish between lttng and perf
CTF based trace.
- version
The kernel version from stream. In addition to release, this is what
it looks like on a Debian kernel:
release = "3.14-1-amd64";
version = "3.14.0";
[1] http://projects.eclipse.org/projects/tools.tracecompass
Signed-off-by: Jiri Olsa <jolsa@kernel.org>
Acked-by: Namhyung Kim <namhyung@kernel.org>
Reviewed-by: David Ahern <dsahern@gmail.com>
Tested-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frederic Weisbecker <fweisbec@gmail.com>
Cc: Jeremie Galarneau <jgalar@efficios.com>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Cc: Tom Zanussi <tzanussi@gmail.com>
Cc: Wang Nan <wangnan0@huawei.com>
Link: http://lkml.kernel.org/r/1424470628-5969-4-git-send-email-jolsa@kernel.org
Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Jiri Olsa
Arnaldo Carvalho de Melo
parent
2245bf1410
commit
edbe9817ae
@ -13,3 +13,28 @@ SYNOPSIS
|
||||
DESCRIPTION
|
||||
-----------
|
||||
Data file related processing.
|
||||
|
||||
COMMANDS
|
||||
--------
|
||||
convert::
|
||||
Converts perf data file into another format (only CTF [1] format is support by now).
|
||||
It's possible to set data-convert debug variable to get debug messages from conversion,
|
||||
like:
|
||||
perf --debug data-convert data convert ...
|
||||
|
||||
OPTIONS for 'convert'
|
||||
---------------------
|
||||
--to-ctf::
|
||||
Triggers the CTF conversion, specify the path of CTF data directory.
|
||||
|
||||
-i::
|
||||
Specify input perf data file path.
|
||||
|
||||
-v::
|
||||
--verbose::
|
||||
Be more verbose (show counter open errors, etc).
|
||||
|
||||
SEE ALSO
|
||||
--------
|
||||
linkperf:perf[1]
|
||||
[1] Common Trace Format - http://www.efficios.com/ctf
|
||||
|
||||
@ -13,11 +13,16 @@ SYNOPSIS
|
||||
OPTIONS
|
||||
-------
|
||||
--debug::
|
||||
Setup debug variable (just verbose for now) in value
|
||||
Setup debug variable (see list below) in value
|
||||
range (0, 10). Use like:
|
||||
--debug verbose # sets verbose = 1
|
||||
--debug verbose=2 # sets verbose = 2
|
||||
|
||||
List of debug variables allowed to set:
|
||||
verbose - general debug messages
|
||||
ordered-events - ordered events object debug messages
|
||||
data-convert - data convert command debug messages
|
||||
|
||||
--buildid-dir::
|
||||
Setup buildid cache directory. It has higher priority than
|
||||
buildid.dir config file option.
|
||||
|
||||
@ -3,6 +3,7 @@
|
||||
#include "perf.h"
|
||||
#include "debug.h"
|
||||
#include "parse-options.h"
|
||||
#include "data-convert-bt.h"
|
||||
|
||||
typedef int (*data_cmd_fn_t)(int argc, const char **argv, const char *prefix);
|
||||
|
||||
@ -41,7 +42,50 @@ static void print_usage(void)
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
static const char * const data_convert_usage[] = {
|
||||
"perf data convert [<options>]",
|
||||
NULL
|
||||
};
|
||||
|
||||
static int cmd_data_convert(int argc, const char **argv,
|
||||
const char *prefix __maybe_unused)
|
||||
{
|
||||
const char *to_ctf = NULL;
|
||||
const struct option options[] = {
|
||||
OPT_INCR('v', "verbose", &verbose, "be more verbose"),
|
||||
OPT_STRING('i', "input", &input_name, "file", "input file name"),
|
||||
#ifdef HAVE_LIBBABELTRACE_SUPPORT
|
||||
OPT_STRING(0, "to-ctf", &to_ctf, NULL, "Convert to CTF format"),
|
||||
#endif
|
||||
OPT_END()
|
||||
};
|
||||
|
||||
#ifndef HAVE_LIBBABELTRACE_SUPPORT
|
||||
pr_err("No conversion support compiled in.\n");
|
||||
return -1;
|
||||
#endif
|
||||
|
||||
argc = parse_options(argc, argv, options,
|
||||
data_convert_usage, 0);
|
||||
if (argc) {
|
||||
usage_with_options(data_convert_usage, options);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (to_ctf) {
|
||||
#ifdef HAVE_LIBBABELTRACE_SUPPORT
|
||||
return bt_convert__perf2ctf(input_name, to_ctf);
|
||||
#else
|
||||
pr_err("The libbabeltrace support is not compiled in.\n");
|
||||
return -1;
|
||||
#endif
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct data_cmd data_cmds[] = {
|
||||
{ "convert", "converts data file between formats", cmd_data_convert },
|
||||
{ NULL },
|
||||
};
|
||||
|
||||
|
||||
@ -713,6 +713,7 @@ ifndef NO_LIBBABELTRACE
|
||||
CFLAGS += -DHAVE_LIBBABELTRACE_SUPPORT $(LIBBABELTRACE_CFLAGS)
|
||||
LDFLAGS += $(LIBBABELTRACE_LDFLAGS)
|
||||
EXTLIBS += -lbabeltrace-ctf
|
||||
$(call detected,CONFIG_LIBBABELTRACE)
|
||||
endif
|
||||
endif
|
||||
|
||||
|
||||
@ -88,6 +88,8 @@ libperf-$(CONFIG_DWARF) += dwarf-aux.o
|
||||
libperf-$(CONFIG_LIBDW_DWARF_UNWIND) += unwind-libdw.o
|
||||
libperf-$(CONFIG_LIBUNWIND) += unwind-libunwind.o
|
||||
|
||||
libperf-$(CONFIG_LIBBABELTRACE) += data-convert-bt.o
|
||||
|
||||
libperf-y += scripting-engines/
|
||||
|
||||
libperf-$(CONFIG_PERF_REGS) += perf_regs.o
|
||||
|
||||
612
tools/perf/util/data-convert-bt.c
Normal file
612
tools/perf/util/data-convert-bt.c
Normal file
@ -0,0 +1,612 @@
|
||||
/*
|
||||
* CTF writing support via babeltrace.
|
||||
*
|
||||
* Copyright (C) 2014, Jiri Olsa <jolsa@redhat.com>
|
||||
* Copyright (C) 2014, Sebastian Andrzej Siewior <bigeasy@linutronix.de>
|
||||
*
|
||||
* Released under the GPL v2. (and only v2, not any later version)
|
||||
*/
|
||||
|
||||
#include <linux/compiler.h>
|
||||
#include <babeltrace/ctf-writer/writer.h>
|
||||
#include <babeltrace/ctf-writer/clock.h>
|
||||
#include <babeltrace/ctf-writer/stream.h>
|
||||
#include <babeltrace/ctf-writer/event.h>
|
||||
#include <babeltrace/ctf-writer/event-types.h>
|
||||
#include <babeltrace/ctf-writer/event-fields.h>
|
||||
#include <babeltrace/ctf/events.h>
|
||||
#include <traceevent/event-parse.h>
|
||||
#include "asm/bug.h"
|
||||
#include "data-convert-bt.h"
|
||||
#include "session.h"
|
||||
#include "util.h"
|
||||
#include "debug.h"
|
||||
#include "tool.h"
|
||||
#include "evlist.h"
|
||||
#include "evsel.h"
|
||||
#include "machine.h"
|
||||
|
||||
#define pr_N(n, fmt, ...) \
|
||||
eprintf(n, debug_data_convert, fmt, ##__VA_ARGS__)
|
||||
|
||||
#define pr(fmt, ...) pr_N(1, pr_fmt(fmt), ##__VA_ARGS__)
|
||||
#define pr2(fmt, ...) pr_N(2, pr_fmt(fmt), ##__VA_ARGS__)
|
||||
|
||||
#define pr_time2(t, fmt, ...) pr_time_N(2, debug_data_convert, t, pr_fmt(fmt), ##__VA_ARGS__)
|
||||
|
||||
struct evsel_priv {
|
||||
struct bt_ctf_event_class *event_class;
|
||||
};
|
||||
|
||||
struct ctf_writer {
|
||||
/* writer primitives */
|
||||
struct bt_ctf_writer *writer;
|
||||
struct bt_ctf_stream *stream;
|
||||
struct bt_ctf_stream_class *stream_class;
|
||||
struct bt_ctf_clock *clock;
|
||||
|
||||
/* data types */
|
||||
union {
|
||||
struct {
|
||||
struct bt_ctf_field_type *s64;
|
||||
struct bt_ctf_field_type *u64;
|
||||
struct bt_ctf_field_type *s32;
|
||||
struct bt_ctf_field_type *u32;
|
||||
struct bt_ctf_field_type *string;
|
||||
struct bt_ctf_field_type *u64_hex;
|
||||
};
|
||||
struct bt_ctf_field_type *array[6];
|
||||
} data;
|
||||
};
|
||||
|
||||
struct convert {
|
||||
struct perf_tool tool;
|
||||
struct ctf_writer writer;
|
||||
|
||||
u64 events_size;
|
||||
u64 events_count;
|
||||
};
|
||||
|
||||
static int value_set(struct bt_ctf_field_type *type,
|
||||
struct bt_ctf_event *event,
|
||||
const char *name, u64 val)
|
||||
{
|
||||
struct bt_ctf_field *field;
|
||||
bool sign = bt_ctf_field_type_integer_get_signed(type);
|
||||
int ret;
|
||||
|
||||
field = bt_ctf_field_create(type);
|
||||
if (!field) {
|
||||
pr_err("failed to create a field %s\n", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (sign) {
|
||||
ret = bt_ctf_field_signed_integer_set_value(field, val);
|
||||
if (ret) {
|
||||
pr_err("failed to set field value %s\n", name);
|
||||
goto err;
|
||||
}
|
||||
} else {
|
||||
ret = bt_ctf_field_unsigned_integer_set_value(field, val);
|
||||
if (ret) {
|
||||
pr_err("failed to set field value %s\n", name);
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
ret = bt_ctf_event_set_payload(event, name, field);
|
||||
if (ret) {
|
||||
pr_err("failed to set payload %s\n", name);
|
||||
goto err;
|
||||
}
|
||||
|
||||
pr2(" SET [%s = %" PRIu64 "]\n", name, val);
|
||||
|
||||
err:
|
||||
bt_ctf_field_put(field);
|
||||
return ret;
|
||||
}
|
||||
|
||||
#define __FUNC_VALUE_SET(_name, _val_type) \
|
||||
static __maybe_unused int value_set_##_name(struct ctf_writer *cw, \
|
||||
struct bt_ctf_event *event, \
|
||||
const char *name, \
|
||||
_val_type val) \
|
||||
{ \
|
||||
struct bt_ctf_field_type *type = cw->data._name; \
|
||||
return value_set(type, event, name, (u64) val); \
|
||||
}
|
||||
|
||||
#define FUNC_VALUE_SET(_name) __FUNC_VALUE_SET(_name, _name)
|
||||
|
||||
FUNC_VALUE_SET(s32)
|
||||
FUNC_VALUE_SET(u32)
|
||||
FUNC_VALUE_SET(s64)
|
||||
FUNC_VALUE_SET(u64)
|
||||
__FUNC_VALUE_SET(u64_hex, u64)
|
||||
|
||||
static int add_generic_values(struct ctf_writer *cw,
|
||||
struct bt_ctf_event *event,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
u64 type = evsel->attr.sample_type;
|
||||
int ret;
|
||||
|
||||
/*
|
||||
* missing:
|
||||
* PERF_SAMPLE_TIME - not needed as we have it in
|
||||
* ctf event header
|
||||
* PERF_SAMPLE_READ - TODO
|
||||
* PERF_SAMPLE_CALLCHAIN - TODO
|
||||
* PERF_SAMPLE_RAW - tracepoint fields are handled separately
|
||||
* PERF_SAMPLE_BRANCH_STACK - TODO
|
||||
* PERF_SAMPLE_REGS_USER - TODO
|
||||
* PERF_SAMPLE_STACK_USER - TODO
|
||||
*/
|
||||
|
||||
if (type & PERF_SAMPLE_IP) {
|
||||
ret = value_set_u64_hex(cw, event, "ip", sample->ip);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (type & PERF_SAMPLE_TID) {
|
||||
ret = value_set_s32(cw, event, "tid", sample->tid);
|
||||
if (ret)
|
||||
return -1;
|
||||
|
||||
ret = value_set_s32(cw, event, "pid", sample->pid);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((type & PERF_SAMPLE_ID) ||
|
||||
(type & PERF_SAMPLE_IDENTIFIER)) {
|
||||
ret = value_set_u64(cw, event, "id", sample->id);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (type & PERF_SAMPLE_STREAM_ID) {
|
||||
ret = value_set_u64(cw, event, "stream_id", sample->stream_id);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (type & PERF_SAMPLE_CPU) {
|
||||
ret = value_set_u32(cw, event, "cpu", sample->cpu);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (type & PERF_SAMPLE_PERIOD) {
|
||||
ret = value_set_u64(cw, event, "period", sample->period);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (type & PERF_SAMPLE_WEIGHT) {
|
||||
ret = value_set_u64(cw, event, "weight", sample->weight);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (type & PERF_SAMPLE_DATA_SRC) {
|
||||
ret = value_set_u64(cw, event, "data_src", sample->data_src);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (type & PERF_SAMPLE_TRANSACTION) {
|
||||
ret = value_set_u64(cw, event, "transaction", sample->transaction);
|
||||
if (ret)
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int process_sample_event(struct perf_tool *tool,
|
||||
union perf_event *_event __maybe_unused,
|
||||
struct perf_sample *sample,
|
||||
struct perf_evsel *evsel,
|
||||
struct machine *machine __maybe_unused)
|
||||
{
|
||||
struct convert *c = container_of(tool, struct convert, tool);
|
||||
struct evsel_priv *priv = evsel->priv;
|
||||
struct ctf_writer *cw = &c->writer;
|
||||
struct bt_ctf_event_class *event_class;
|
||||
struct bt_ctf_event *event;
|
||||
int ret;
|
||||
|
||||
if (WARN_ONCE(!priv, "Failed to setup all events.\n"))
|
||||
return 0;
|
||||
|
||||
event_class = priv->event_class;
|
||||
|
||||
/* update stats */
|
||||
c->events_count++;
|
||||
c->events_size += _event->header.size;
|
||||
|
||||
pr_time2(sample->time, "sample %" PRIu64 "\n", c->events_count);
|
||||
|
||||
event = bt_ctf_event_create(event_class);
|
||||
if (!event) {
|
||||
pr_err("Failed to create an CTF event\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
bt_ctf_clock_set_time(cw->clock, sample->time);
|
||||
|
||||
ret = add_generic_values(cw, event, evsel, sample);
|
||||
if (ret)
|
||||
return -1;
|
||||
|
||||
bt_ctf_stream_append_event(cw->stream, event);
|
||||
bt_ctf_event_put(event);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int add_generic_types(struct ctf_writer *cw, struct perf_evsel *evsel,
|
||||
struct bt_ctf_event_class *event_class)
|
||||
{
|
||||
u64 type = evsel->attr.sample_type;
|
||||
|
||||
/*
|
||||
* missing:
|
||||
* PERF_SAMPLE_TIME - not needed as we have it in
|
||||
* ctf event header
|
||||
* PERF_SAMPLE_READ - TODO
|
||||
* PERF_SAMPLE_CALLCHAIN - TODO
|
||||
* PERF_SAMPLE_RAW - tracepoint fields are handled separately
|
||||
* PERF_SAMPLE_BRANCH_STACK - TODO
|
||||
* PERF_SAMPLE_REGS_USER - TODO
|
||||
* PERF_SAMPLE_STACK_USER - TODO
|
||||
*/
|
||||
|
||||
#define ADD_FIELD(cl, t, n) \
|
||||
do { \
|
||||
pr2(" field '%s'\n", n); \
|
||||
if (bt_ctf_event_class_add_field(cl, t, n)) { \
|
||||
pr_err("Failed to add field '%s;\n", n); \
|
||||
return -1; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
if (type & PERF_SAMPLE_IP)
|
||||
ADD_FIELD(event_class, cw->data.u64_hex, "ip");
|
||||
|
||||
if (type & PERF_SAMPLE_TID) {
|
||||
ADD_FIELD(event_class, cw->data.s32, "tid");
|
||||
ADD_FIELD(event_class, cw->data.s32, "pid");
|
||||
}
|
||||
|
||||
if ((type & PERF_SAMPLE_ID) ||
|
||||
(type & PERF_SAMPLE_IDENTIFIER))
|
||||
ADD_FIELD(event_class, cw->data.u64, "id");
|
||||
|
||||
if (type & PERF_SAMPLE_STREAM_ID)
|
||||
ADD_FIELD(event_class, cw->data.u64, "stream_id");
|
||||
|
||||
if (type & PERF_SAMPLE_CPU)
|
||||
ADD_FIELD(event_class, cw->data.u32, "cpu");
|
||||
|
||||
if (type & PERF_SAMPLE_PERIOD)
|
||||
ADD_FIELD(event_class, cw->data.u64, "period");
|
||||
|
||||
if (type & PERF_SAMPLE_WEIGHT)
|
||||
ADD_FIELD(event_class, cw->data.u64, "weight");
|
||||
|
||||
if (type & PERF_SAMPLE_DATA_SRC)
|
||||
ADD_FIELD(event_class, cw->data.u64, "data_src");
|
||||
|
||||
if (type & PERF_SAMPLE_TRANSACTION)
|
||||
ADD_FIELD(event_class, cw->data.u64, "transaction");
|
||||
|
||||
#undef ADD_FIELD
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int add_event(struct ctf_writer *cw, struct perf_evsel *evsel)
|
||||
{
|
||||
struct bt_ctf_event_class *event_class;
|
||||
struct evsel_priv *priv;
|
||||
const char *name = perf_evsel__name(evsel);
|
||||
int ret;
|
||||
|
||||
pr("Adding event '%s' (type %d)\n", name, evsel->attr.type);
|
||||
|
||||
event_class = bt_ctf_event_class_create(name);
|
||||
if (!event_class)
|
||||
return -1;
|
||||
|
||||
ret = add_generic_types(cw, evsel, event_class);
|
||||
if (ret)
|
||||
goto err;
|
||||
|
||||
ret = bt_ctf_stream_class_add_event_class(cw->stream_class, event_class);
|
||||
if (ret) {
|
||||
pr("Failed to add event class into stream.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
priv = malloc(sizeof(*priv));
|
||||
if (!priv)
|
||||
goto err;
|
||||
|
||||
priv->event_class = event_class;
|
||||
evsel->priv = priv;
|
||||
return 0;
|
||||
|
||||
err:
|
||||
bt_ctf_event_class_put(event_class);
|
||||
pr_err("Failed to add event '%s'.\n", name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int setup_events(struct ctf_writer *cw, struct perf_session *session)
|
||||
{
|
||||
struct perf_evlist *evlist = session->evlist;
|
||||
struct perf_evsel *evsel;
|
||||
int ret;
|
||||
|
||||
evlist__for_each(evlist, evsel) {
|
||||
ret = add_event(cw, evsel);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ctf_writer__setup_env(struct ctf_writer *cw,
|
||||
struct perf_session *session)
|
||||
{
|
||||
struct perf_header *header = &session->header;
|
||||
struct bt_ctf_writer *writer = cw->writer;
|
||||
|
||||
#define ADD(__n, __v) \
|
||||
do { \
|
||||
if (bt_ctf_writer_add_environment_field(writer, __n, __v)) \
|
||||
return -1; \
|
||||
} while (0)
|
||||
|
||||
ADD("host", header->env.hostname);
|
||||
ADD("sysname", "Linux");
|
||||
ADD("release", header->env.os_release);
|
||||
ADD("version", header->env.version);
|
||||
ADD("machine", header->env.arch);
|
||||
ADD("domain", "kernel");
|
||||
ADD("tracer_name", "perf");
|
||||
|
||||
#undef ADD
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ctf_writer__setup_clock(struct ctf_writer *cw)
|
||||
{
|
||||
struct bt_ctf_clock *clock = cw->clock;
|
||||
|
||||
bt_ctf_clock_set_description(clock, "perf clock");
|
||||
|
||||
#define SET(__n, __v) \
|
||||
do { \
|
||||
if (bt_ctf_clock_set_##__n(clock, __v)) \
|
||||
return -1; \
|
||||
} while (0)
|
||||
|
||||
SET(frequency, 1000000000);
|
||||
SET(offset_s, 0);
|
||||
SET(offset, 0);
|
||||
SET(precision, 10);
|
||||
SET(is_absolute, 0);
|
||||
|
||||
#undef SET
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct bt_ctf_field_type *create_int_type(int size, bool sign, bool hex)
|
||||
{
|
||||
struct bt_ctf_field_type *type;
|
||||
|
||||
type = bt_ctf_field_type_integer_create(size);
|
||||
if (!type)
|
||||
return NULL;
|
||||
|
||||
if (sign &&
|
||||
bt_ctf_field_type_integer_set_signed(type, 1))
|
||||
goto err;
|
||||
|
||||
if (hex &&
|
||||
bt_ctf_field_type_integer_set_base(type, BT_CTF_INTEGER_BASE_HEXADECIMAL))
|
||||
goto err;
|
||||
|
||||
pr2("Created type: INTEGER %d-bit %ssigned %s\n",
|
||||
size, sign ? "un" : "", hex ? "hex" : "");
|
||||
return type;
|
||||
|
||||
err:
|
||||
bt_ctf_field_type_put(type);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static void ctf_writer__cleanup_data(struct ctf_writer *cw)
|
||||
{
|
||||
unsigned int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(cw->data.array); i++)
|
||||
bt_ctf_field_type_put(cw->data.array[i]);
|
||||
}
|
||||
|
||||
static int ctf_writer__init_data(struct ctf_writer *cw)
|
||||
{
|
||||
#define CREATE_INT_TYPE(type, size, sign, hex) \
|
||||
do { \
|
||||
(type) = create_int_type(size, sign, hex); \
|
||||
if (!(type)) \
|
||||
goto err; \
|
||||
} while (0)
|
||||
|
||||
CREATE_INT_TYPE(cw->data.s64, 64, true, false);
|
||||
CREATE_INT_TYPE(cw->data.u64, 64, false, false);
|
||||
CREATE_INT_TYPE(cw->data.s32, 32, true, false);
|
||||
CREATE_INT_TYPE(cw->data.u32, 32, false, false);
|
||||
CREATE_INT_TYPE(cw->data.u64_hex, 64, false, true);
|
||||
|
||||
cw->data.string = bt_ctf_field_type_string_create();
|
||||
if (cw->data.string)
|
||||
return 0;
|
||||
|
||||
err:
|
||||
ctf_writer__cleanup_data(cw);
|
||||
pr_err("Failed to create data types.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
static void ctf_writer__cleanup(struct ctf_writer *cw)
|
||||
{
|
||||
ctf_writer__cleanup_data(cw);
|
||||
|
||||
bt_ctf_clock_put(cw->clock);
|
||||
bt_ctf_stream_put(cw->stream);
|
||||
bt_ctf_stream_class_put(cw->stream_class);
|
||||
bt_ctf_writer_put(cw->writer);
|
||||
|
||||
/* and NULL all the pointers */
|
||||
memset(cw, 0, sizeof(*cw));
|
||||
}
|
||||
|
||||
static int ctf_writer__init(struct ctf_writer *cw, const char *path)
|
||||
{
|
||||
struct bt_ctf_writer *writer;
|
||||
struct bt_ctf_stream_class *stream_class;
|
||||
struct bt_ctf_stream *stream;
|
||||
struct bt_ctf_clock *clock;
|
||||
|
||||
/* CTF writer */
|
||||
writer = bt_ctf_writer_create(path);
|
||||
if (!writer)
|
||||
goto err;
|
||||
|
||||
cw->writer = writer;
|
||||
|
||||
/* CTF clock */
|
||||
clock = bt_ctf_clock_create("perf_clock");
|
||||
if (!clock) {
|
||||
pr("Failed to create CTF clock.\n");
|
||||
goto err_cleanup;
|
||||
}
|
||||
|
||||
cw->clock = clock;
|
||||
|
||||
if (ctf_writer__setup_clock(cw)) {
|
||||
pr("Failed to setup CTF clock.\n");
|
||||
goto err_cleanup;
|
||||
}
|
||||
|
||||
/* CTF stream class */
|
||||
stream_class = bt_ctf_stream_class_create("perf_stream");
|
||||
if (!stream_class) {
|
||||
pr("Failed to create CTF stream class.\n");
|
||||
goto err_cleanup;
|
||||
}
|
||||
|
||||
cw->stream_class = stream_class;
|
||||
|
||||
/* CTF clock stream setup */
|
||||
if (bt_ctf_stream_class_set_clock(stream_class, clock)) {
|
||||
pr("Failed to assign CTF clock to stream class.\n");
|
||||
goto err_cleanup;
|
||||
}
|
||||
|
||||
if (ctf_writer__init_data(cw))
|
||||
goto err_cleanup;
|
||||
|
||||
/* CTF stream instance */
|
||||
stream = bt_ctf_writer_create_stream(writer, stream_class);
|
||||
if (!stream) {
|
||||
pr("Failed to create CTF stream.\n");
|
||||
goto err_cleanup;
|
||||
}
|
||||
|
||||
cw->stream = stream;
|
||||
|
||||
/* CTF clock writer setup */
|
||||
if (bt_ctf_writer_add_clock(writer, clock)) {
|
||||
pr("Failed to assign CTF clock to writer.\n");
|
||||
goto err_cleanup;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err_cleanup:
|
||||
ctf_writer__cleanup(cw);
|
||||
err:
|
||||
pr_err("Failed to setup CTF writer.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
int bt_convert__perf2ctf(const char *input, const char *path)
|
||||
{
|
||||
struct perf_session *session;
|
||||
struct perf_data_file file = {
|
||||
.path = input,
|
||||
.mode = PERF_DATA_MODE_READ,
|
||||
};
|
||||
struct convert c = {
|
||||
.tool = {
|
||||
.sample = process_sample_event,
|
||||
.mmap = perf_event__process_mmap,
|
||||
.mmap2 = perf_event__process_mmap2,
|
||||
.comm = perf_event__process_comm,
|
||||
.exit = perf_event__process_exit,
|
||||
.fork = perf_event__process_fork,
|
||||
.lost = perf_event__process_lost,
|
||||
.tracing_data = perf_event__process_tracing_data,
|
||||
.build_id = perf_event__process_build_id,
|
||||
.ordered_events = true,
|
||||
.ordering_requires_timestamps = true,
|
||||
},
|
||||
};
|
||||
struct ctf_writer *cw = &c.writer;
|
||||
int err = -1;
|
||||
|
||||
/* CTF writer */
|
||||
if (ctf_writer__init(cw, path))
|
||||
return -1;
|
||||
|
||||
/* perf.data session */
|
||||
session = perf_session__new(&file, 0, NULL);
|
||||
if (!session)
|
||||
goto free_writer;
|
||||
|
||||
/* CTF writer env/clock setup */
|
||||
if (ctf_writer__setup_env(cw, session))
|
||||
goto free_session;
|
||||
|
||||
/* CTF events setup */
|
||||
if (setup_events(cw, session))
|
||||
goto free_session;
|
||||
|
||||
err = perf_session__process_events(session, &c.tool);
|
||||
if (!err)
|
||||
err = bt_ctf_stream_flush(cw->stream);
|
||||
|
||||
fprintf(stderr,
|
||||
"[ perf data convert: Converted '%s' into CTF data '%s' ]\n",
|
||||
file.path, path);
|
||||
|
||||
fprintf(stderr,
|
||||
"[ perf data convert: Converted and wrote %.3f MB (%" PRIu64 " samples) ]\n",
|
||||
(double) c.events_size / 1024.0 / 1024.0,
|
||||
c.events_count);
|
||||
|
||||
/* its all good */
|
||||
free_session:
|
||||
perf_session__delete(session);
|
||||
|
||||
free_writer:
|
||||
ctf_writer__cleanup(cw);
|
||||
return err;
|
||||
}
|
||||
8
tools/perf/util/data-convert-bt.h
Normal file
8
tools/perf/util/data-convert-bt.h
Normal file
@ -0,0 +1,8 @@
|
||||
#ifndef __DATA_CONVERT_BT_H
|
||||
#define __DATA_CONVERT_BT_H
|
||||
#ifdef HAVE_LIBBABELTRACE_SUPPORT
|
||||
|
||||
int bt_convert__perf2ctf(const char *input_name, const char *to_ctf);
|
||||
|
||||
#endif /* HAVE_LIBBABELTRACE_SUPPORT */
|
||||
#endif /* __DATA_CONVERT_BT_H */
|
||||
@ -20,6 +20,7 @@ int verbose;
|
||||
bool dump_trace = false, quiet = false;
|
||||
int debug_ordered_events;
|
||||
static int redirect_to_stderr;
|
||||
int debug_data_convert;
|
||||
|
||||
static int _eprintf(int level, int var, const char *fmt, va_list args)
|
||||
{
|
||||
@ -147,6 +148,7 @@ static struct debug_variable {
|
||||
{ .name = "verbose", .ptr = &verbose },
|
||||
{ .name = "ordered-events", .ptr = &debug_ordered_events},
|
||||
{ .name = "stderr", .ptr = &redirect_to_stderr},
|
||||
{ .name = "data-convert", .ptr = &debug_data_convert },
|
||||
{ .name = NULL, }
|
||||
};
|
||||
|
||||
|
||||
@ -12,6 +12,7 @@
|
||||
extern int verbose;
|
||||
extern bool quiet, dump_trace;
|
||||
extern int debug_ordered_events;
|
||||
extern int debug_data_convert;
|
||||
|
||||
#ifndef pr_fmt
|
||||
#define pr_fmt(fmt) fmt
|
||||
|
||||
Loading…
Reference in New Issue
Block a user