Adding simple session read/write test to keep up
with file format changes.
Dumping the session to the file with several events
and reading it again back.
Signed-off-by: Jiri Olsa <jo...@redhat.com>
Cc: Corey Ashford <cjash...@linux.vnet.ibm.com>
Cc: Frederic Weisbecker <fweis...@gmail.com>
Cc: Ingo Molnar <mi...@elte.hu>
Cc: Namhyung Kim <namhy...@kernel.org>
Cc: Paul Mackerras <pau...@samba.org>
Cc: Peter Zijlstra <a.p.zijls...@chello.nl>
Cc: Arnaldo Carvalho de Melo <a...@redhat.com>
Cc: Andi Kleen <a...@linux.intel.com>
Cc: David Ahern <dsah...@gmail.com>
---
tools/perf/Makefile | 1 +
tools/perf/tests/builtin-test.c | 4 +
tools/perf/tests/session-simple.c | 602 ++++++++++++++++++++++++++++++++++++++
tools/perf/tests/tests.h | 1 +
4 files changed, 608 insertions(+)
create mode 100644 tools/perf/tests/session-simple.c
diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index ecebfd0..7484119 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -394,6 +394,7 @@ ifeq ($(ARCH),x86)
LIB_OBJS += $(OUTPUT)tests/perf-time-to-tsc.o
endif
LIB_OBJS += $(OUTPUT)tests/code-reading.o
+LIB_OBJS += $(OUTPUT)tests/session-simple.o
BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
BUILTIN_OBJS += $(OUTPUT)builtin-bench.o
diff --git a/tools/perf/tests/builtin-test.c b/tools/perf/tests/builtin-test.c
index 8ad9415..e40aec9 100644
--- a/tools/perf/tests/builtin-test.c
+++ b/tools/perf/tests/builtin-test.c
@@ -108,6 +108,10 @@ static struct test {
.func = test__sample_parsing,
},
{
+ .desc = "Test session - simple read/write",
+ .func = test__session_simple,
+ },
+ {
.func = NULL,
},
};
diff --git a/tools/perf/tests/session-simple.c
b/tools/perf/tests/session-simple.c
new file mode 100644
index 0000000..612f84d
--- /dev/null
+++ b/tools/perf/tests/session-simple.c
@@ -0,0 +1,602 @@
+
+/*
+ * FIXME Missing test for PERF_RECORD_READ event.
+ */
+
+#include <stdlib.h>
+#include <linux/kernel.h>
+
+#include "tests.h"
+#include "session.h"
+#include "header.h"
+#include "util.h"
+#include "evlist.h"
+
+#define EVENTS_MMAP 5
+#define EVENTS_LOST 6
+#define EVENTS_COMM 3
+#define EVENTS_EXIT 4
+#define EVENTS_FORK 8
+#define EVENTS_THROTTLE 2
+#define EVENTS_UNTHROTTLE 3
+#define EVENTS_SAMPLE 4
+
+static int events_mmap;
+static int events_lost;
+static int events_comm;
+static int events_exit;
+static int events_fork;
+static int events_throttle;
+static int events_unthrottle;
+static int events_sample;
+
+/* global sample type for sample */
+static u64 sample_type = PERF_SAMPLE_IP |
+ PERF_SAMPLE_TID |
+ PERF_SAMPLE_TIME |
+ PERF_SAMPLE_ADDR |
+ PERF_SAMPLE_ID |
+ PERF_SAMPLE_CPU |
+ PERF_SAMPLE_PERIOD |
+ PERF_SAMPLE_STREAM_ID |
+ PERF_SAMPLE_WEIGHT |
+ PERF_SAMPLE_DATA_SRC;
+
+static char *get_file(void)
+{
+ static char buf[PATH_MAX];
+ int fd;
+
+ snprintf(buf, PATH_MAX, "/tmp/perf-test-session-simple-data-XXXXXX");
+ fd = mkstemp(buf);
+ if (fd < 0) {
+ pr_err("mkstemp failed");
+ return NULL;
+ }
+
+ close(fd);
+
+ pr_debug("data file %s\n", buf);
+ return buf;
+}
+
+static union perf_event *get_event_MMAP(void)
+{
+ static union perf_event event;
+ size_t size;
+
+ size = snprintf(event.mmap.filename, sizeof(event.mmap.filename),
+ "krava") + 1;
+ size = PERF_ALIGN(size, sizeof(u64));
+
+ event.header.type = PERF_RECORD_MMAP;
+ event.header.misc = PERF_RECORD_MISC_KERNEL;
+ event.header.size = sizeof(event.mmap) -
+ (sizeof(event.mmap.filename) - size);
+
+ event.mmap.pgoff = 10;
+ event.mmap.start = 0;
+ event.mmap.len = 10;
+ event.mmap.pid = 123;
+
+ return &event;
+}
+
+static int process_mmap(struct perf_tool *tool __maybe_unused,
+ union perf_event *event,
+ struct perf_sample *sample __maybe_unused,
+ struct machine *machine __maybe_unused)
+{
+ pr_debug("event MMAP misc %d, pgoff %lu, start %lu,"
+ " len %lu, pid %d, filename '%s'\n",
+ event->header.misc,
+ event->mmap.pgoff,
+ event->mmap.start,
+ event->mmap.len,
+ event->mmap.pid,
+ event->mmap.filename);
+
+ TEST_ASSERT_VAL("wrong MMAP misc\n",
+ event->header.misc == PERF_RECORD_MISC_KERNEL);
+
+ TEST_ASSERT_VAL("wrong MMAP pgoff\n",
+ event->mmap.pgoff == 10);
+
+ TEST_ASSERT_VAL("wrong MMAP start\n",
+ event->mmap.start == 0);
+
+ TEST_ASSERT_VAL("wrong MMAP len\n",
+ event->mmap.len == 10);
+
+ TEST_ASSERT_VAL("wrong MMAP pid\n",
+ event->mmap.pid == 123);
+
+ TEST_ASSERT_VAL("wrong MMAP filename\n",
+ !strcmp(event->mmap.filename, "krava"));
+
+ TEST_ASSERT_VAL("wrong MMAP misc\n",
+ event->header.misc == PERF_RECORD_MISC_KERNEL);
+
+ TEST_ASSERT_VAL("wrong MMAP pgoff\n",
+ event->mmap.pgoff == 10);
+
+ TEST_ASSERT_VAL("wrong MMAP start\n",
+ event->mmap.start == 0);
+
+ TEST_ASSERT_VAL("wrong MMAP len\n",
+ event->mmap.len == 10);
+
+ TEST_ASSERT_VAL("wrong MMAP pid\n",
+ event->mmap.pid == 123);
+
+ TEST_ASSERT_VAL("wrong MMAP filename\n",
+ !strcmp(event->mmap.filename, "krava"));
+
+ events_mmap++;
+ return 0;
+}
+
+static union perf_event *get_event_LOST(void)
+{
+ static union perf_event event;
+
+ event.header.type = PERF_RECORD_LOST;
+ event.header.misc = PERF_RECORD_MISC_USER;
+ event.header.size = sizeof(event.lost);
+
+ event.lost.id = 12345;
+ event.lost.lost = 293467890514143;
+ return &event;
+}
+
+static int process_lost(struct perf_tool *tool __maybe_unused,
+ union perf_event *event,
+ struct perf_sample *sample __maybe_unused,
+ struct machine *machine __maybe_unused)
+{
+ pr_debug("event LOST id %lu, lost %lu\n",
+ event->lost.id,
+ event->lost.lost);
+
+ TEST_ASSERT_VAL("wrong LOST id\n",
+ event->lost.id == 12345);
+
+ TEST_ASSERT_VAL("wrong LOST lost\n",
+ event->lost.lost == 293467890514143);
+
+ events_lost++;
+ return 0;
+}
+
+static union perf_event *get_event_COMM(void)
+{
+ static union perf_event event;
+ size_t size;
+
+ size = snprintf(event.comm.comm, sizeof(event.comm.comm),
+ "krava") + 1;
+ size = PERF_ALIGN(size, sizeof(u64));
+
+ event.header.type = PERF_RECORD_COMM;
+ event.header.size = sizeof(event.comm) -
+ (sizeof(event.comm.comm) - size);
+
+ event.comm.pid = 1234;
+ event.comm.tid = 4321;
+
+ return &event;
+}
+
+static int process_comm(struct perf_tool *tool __maybe_unused,
+ union perf_event *event,
+ struct perf_sample *sample __maybe_unused,
+ struct machine *machine __maybe_unused)
+{
+ pr_debug("event COMM pid %d, tid %d, comm '%s'\n",
+ event->comm.pid,
+ event->comm.tid,
+ event->comm.comm);
+
+ TEST_ASSERT_VAL("wrong COMM pid\n",
+ event->comm.pid == 1234);
+
+ TEST_ASSERT_VAL("wrong COMM tid\n",
+ event->comm.tid == 4321);
+
+ TEST_ASSERT_VAL("wrong COMM comm\n",
+ !strcmp(event->comm.comm, "krava"));
+
+ events_comm++;
+ return 0;
+}
+
+static union perf_event *get_event_EXIT(void)
+{
+ static union perf_event event;
+
+ event.header.type = PERF_RECORD_EXIT;
+ event.header.size = sizeof(event.fork);
+
+ event.fork.pid = 2322;
+ event.fork.tid = 2232;
+ event.fork.ppid = 10;
+ event.fork.ptid = 1;
+ event.fork.time = 0xB16B00B5;
+
+ return &event;
+}
+
+static int process_exit(struct perf_tool *tool __maybe_unused,
+ union perf_event *event,
+ struct perf_sample *sample __maybe_unused,
+ struct machine *machine __maybe_unused)
+{
+ pr_debug("event EXIT pid %d, tid %d, ppid %d, ptid %d, time 0x%lx\n",
+ event->fork.pid, event->fork.tid,
+ event->fork.ppid, event->fork.ptid,
+ event->fork.time);
+
+ TEST_ASSERT_VAL("wrong EXIT pid\n",
+ event->fork.pid == 2322);
+
+ TEST_ASSERT_VAL("wrong EXIT tid\n",
+ event->fork.tid == 2232);
+
+ TEST_ASSERT_VAL("wrong EXIT ppid\n",
+ event->fork.ppid == 10);
+
+ TEST_ASSERT_VAL("wrong EXIT ptid\n",
+ event->fork.ptid == 1);
+
+ TEST_ASSERT_VAL("wrong EXIT time\n",
+ event->fork.time == 0xB16B00B5);
+
+ events_exit++;
+ return 0;
+}
+
+static union perf_event *get_event_FORK(void)
+{
+ static union perf_event event;
+
+ event.header.type = PERF_RECORD_FORK;
+ event.header.size = sizeof(event.fork);
+
+ event.fork.pid = 4321;
+ event.fork.tid = 1234;
+ event.fork.ppid = 14321;
+ event.fork.ptid = 11234;
+ event.fork.time = 0xdeadbeef;
+
+ return &event;
+}
+
+static int process_fork(struct perf_tool *tool __maybe_unused,
+ union perf_event *event,
+ struct perf_sample *sample __maybe_unused,
+ struct machine *machine __maybe_unused)
+{
+ pr_debug("event FORK pid %d, tid %d, ppid %d, ptid %d, time 0x%lx\n",
+ event->fork.pid, event->fork.tid,
+ event->fork.ppid, event->fork.ptid,
+ event->fork.time);
+
+ TEST_ASSERT_VAL("wrong FORK pid\n",
+ event->fork.pid == 4321);
+
+ TEST_ASSERT_VAL("wrong FORK tid\n",
+ event->fork.tid == 1234);
+
+ TEST_ASSERT_VAL("wrong FORK ppid\n",
+ event->fork.ppid == 14321);
+
+ TEST_ASSERT_VAL("wrong FORK ptid\n",
+ event->fork.ptid == 11234);
+
+ TEST_ASSERT_VAL("wrong FORK time\n",
+ event->fork.time == 0xdeadbeef);
+
+ events_fork++;
+ return 0;
+}
+
+static union perf_event *get_event_THROTTLE(void)
+{
+ static union perf_event event;
+
+ event.header.type = PERF_RECORD_THROTTLE;
+ event.header.size = sizeof(event.throttle);
+
+ event.throttle.time = 0xdeadbeef;
+ event.throttle.id = 123;
+ event.throttle.stream_id = 987;
+
+ return &event;
+}
+
+static int process_throttle(struct perf_tool *tool __maybe_unused,
+ union perf_event *event,
+ struct perf_sample *sample __maybe_unused,
+ struct machine *machine __maybe_unused)
+{
+ pr_debug("event THROTTLE time 0x%lx, id 0x%lx, stream_id 0x%lx\n",
+ event->throttle.time, event->throttle.id,
+ event->throttle.stream_id);
+
+ TEST_ASSERT_VAL("wrong THROTTLE time\n",
+ event->throttle.time == 0xdeadbeef);
+
+ TEST_ASSERT_VAL("wrong THROTTLE id\n",
+ event->throttle.id == 123);
+
+ TEST_ASSERT_VAL("wrong THROTTLE id\n",
+ event->throttle.stream_id == 987);
+
+ events_throttle++;
+ return 0;
+}
+
+static union perf_event *get_event_UNTHROTTLE(void)
+{
+ static union perf_event event;
+
+ event.header.type = PERF_RECORD_UNTHROTTLE;
+ event.header.size = sizeof(event.throttle);
+
+ event.throttle.time = 0xdeadbeef;
+ event.throttle.id = 542318590;
+ event.throttle.stream_id = 2341238951;
+
+ return &event;
+}
+
+static int process_unthrottle(struct perf_tool *tool __maybe_unused,
+ union perf_event *event,
+ struct perf_sample *sample __maybe_unused,
+ struct machine *machine __maybe_unused)
+{
+ pr_debug("event UNTHROTTLE time 0x%lx, id 0x%lx, stream_id 0x%lx\n",
+ event->throttle.time, event->throttle.id,
+ event->throttle.stream_id);
+
+ TEST_ASSERT_VAL("wrong UNTHROTTLE time\n",
+ event->throttle.time == 0xdeadbeef);
+
+ TEST_ASSERT_VAL("wrong UNTHROTTLE id\n",
+ event->throttle.id == 542318590);
+
+ TEST_ASSERT_VAL("wrong UNTHROTTLE id\n",
+ event->throttle.stream_id == 2341238951);
+
+ events_unthrottle++;
+ return 0;
+}
+
+static union perf_event *get_event_SAMPLE(void)
+{
+ static unsigned char buf[4096];
+ static union perf_event *event = (union perf_event *) buf;
+ struct perf_sample sample = {
+ .ip = 0xaaa,
+ .pid = 0xedfa,
+ .tid = 0xabc,
+ .time = 123456789,
+ .addr = 0xabababab,
+ .id = 0xedf234abf,
+ .stream_id = 9273651,
+ .period = 0xdead,
+ .weight = 1,
+ .cpu = 1024,
+ .data_src = 3,
+ };
+ size_t sz;
+ int ret;
+
+ sz = perf_event__sample_event_size(&sample, sample_type, 0, 0);
+
+ event->header.type = PERF_RECORD_SAMPLE;
+ event->header.misc = 0;
+ event->header.size = sz;
+
+ ret = perf_event__synthesize_sample(event, sample_type, 0, 0,
+ &sample, false);
+ return ret ? NULL : event;
+}
+
+static int process_sample(struct perf_tool *tool __maybe_unused,
+ union perf_event *event __maybe_unused,
+ struct perf_sample *sample,
+ struct perf_evsel *evsel __maybe_unused,
+ struct machine *machine __maybe_unused)
+{
+ pr_debug("event SAMPLE ip %lx, pid %x, tid %x, time %lx, "
+ "addr %lx, id %lx, stream_id %lx, period %lx, "
+ "weight %lx, cpu %x, data_src %lx\n",
+ sample->ip, sample->pid, sample->tid, sample->time,
+ sample->addr, sample->id, sample->stream_id,
+ sample->period, sample->weight, sample->cpu,
+ sample->data_src);
+
+ TEST_ASSERT_VAL("wrong SAMPLE ip\n", sample->ip == 0xaaa);
+ TEST_ASSERT_VAL("wrong SAMPLE pid\n", sample->pid == 0xedfa);
+ TEST_ASSERT_VAL("wrong SAMPLE tid\n", sample->tid == 0xabc);
+ TEST_ASSERT_VAL("wrong SAMPLE time\n", sample->time == 123456789);
+ TEST_ASSERT_VAL("wrong SAMPLE addr\n", sample->addr == 0xabababab);
+ TEST_ASSERT_VAL("wrong SAMPLE id\n", sample->id == 0xedf234abf);
+ TEST_ASSERT_VAL("wrong SAMPLE stream_id\n",
+ sample->stream_id == 9273651);
+ TEST_ASSERT_VAL("wrong SAMPLE period\n", sample->period == 0xdead);
+ TEST_ASSERT_VAL("wrong SAMPLE weight\n", sample->weight == 1);
+ TEST_ASSERT_VAL("wrong SAMPLE cpu\n", sample->cpu == 1024);
+ TEST_ASSERT_VAL("wrong SAMPLE data_src\n", sample->data_src == 3);
+
+ events_sample++;
+ return 0;
+}
+
+static int store_event(int fd, union perf_event *event, size_t *size)
+{
+ TEST_ASSERT_VAL("no event\n", event);
+ *size += event->header.size;
+ return write(fd, event, event->header.size) > 0 ? 0 : -1;
+}
+
+static int session_write(char *file)
+{
+ struct perf_session *session;
+ struct perf_evlist *evlist;
+ size_t size = 0;
+ int feat, fd;
+
+ fd = open(file, O_RDWR);
+ TEST_ASSERT_VAL("failed to open data file", fd >= 0);
+
+ evlist = perf_evlist__new_default();
+ TEST_ASSERT_VAL("failed to get evlist", evlist);
+
+ perf_evlist__first(evlist)->attr.sample_type = sample_type;
+
+ pr_debug("session writing start\n");
+
+ session = perf_session__new(file, O_WRONLY, true, false, NULL);
+ TEST_ASSERT_VAL("failed to create session", session);
+
+ session->evlist = evlist;
+ session->fd = fd;
+
+ for (feat = HEADER_FIRST_FEATURE; feat < HEADER_LAST_FEATURE; feat++)
+ perf_header__set_feat(&session->header, feat);
+
+ perf_header__clear_feat(&session->header, HEADER_BUILD_ID);
+ perf_header__clear_feat(&session->header, HEADER_TRACING_DATA);
+ perf_header__clear_feat(&session->header, HEADER_BRANCH_STACK);
+
+ TEST_ASSERT_VAL("failed to write header",
+ !perf_session__write_header(session, evlist, fd, false));
+
+#define STORE_EVENTS(str, func, cnt) \
+do { \
+ int i; \
+ for (i = 0; i < cnt; i++) { \
+ TEST_ASSERT_VAL(str, \
+ !store_event(fd, func(), &size)); \
+ } \
+} while (0)
+
+ STORE_EVENTS("failed to store MMAP event",
+ get_event_MMAP, EVENTS_MMAP);
+
+ STORE_EVENTS("failed to store LOST event",
+ get_event_LOST, EVENTS_LOST);
+
+ STORE_EVENTS("failed to store COMM event",
+ get_event_COMM, EVENTS_COMM);
+
+ STORE_EVENTS("failed to store EXIT event",
+ get_event_EXIT, EVENTS_EXIT);
+
+ STORE_EVENTS("failed to store FORK event",
+ get_event_FORK, EVENTS_FORK);
+
+ STORE_EVENTS("failed to store THROTTLE event",
+ get_event_THROTTLE, EVENTS_THROTTLE);
+
+ STORE_EVENTS("failed to store UNTHROTTLE event",
+ get_event_UNTHROTTLE, EVENTS_UNTHROTTLE);
+
+ STORE_EVENTS("failed to store SAMPLE event",
+ get_event_SAMPLE, EVENTS_SAMPLE);
+
+#undef STORE_EVENTS
+
+ session->header.data_size += size;
+
+ TEST_ASSERT_VAL("failed to write header",
+ !perf_session__write_header(session, evlist, fd, true));
+
+ perf_session__delete(session);
+ perf_evlist__delete(evlist);
+
+ pr_debug("session writing stop\n");
+ return 0;
+}
+
+static int __session_read(char *file)
+{
+ struct perf_session *session;
+ struct perf_tool tool = {
+ .mmap = process_mmap,
+ .lost = process_lost,
+ .comm = process_comm,
+ .exit = process_exit,
+ .fork = process_fork,
+ .throttle = process_throttle,
+ .unthrottle = process_unthrottle,
+ .sample = process_sample,
+ };
+
+ pr_debug("session reading start\n");
+
+ session = perf_session__new(file, O_RDONLY, false, false, &tool);
+ TEST_ASSERT_VAL("failed to create session", session);
+
+ TEST_ASSERT_VAL("failed to process events",
+ perf_session__process_events(session, &tool) == 0);
+
+ perf_session__delete(session);
+
+ pr_debug("session reading stop\n");
+ return 0;
+}
+
+static int session_read(char *file)
+{
+ events_mmap = 0;
+ events_lost = 0;
+ events_comm = 0;
+ events_exit = 0;
+ events_fork = 0;
+ events_throttle = 0;
+ events_unthrottle = 0;
+ events_sample = 0;
+
+ if (__session_read(file))
+ return -1;
+
+ TEST_ASSERT_VAL("wrong MMAP events count", events_mmap == EVENTS_MMAP);
+ TEST_ASSERT_VAL("wrong LOST events count", events_lost == EVENTS_LOST);
+ TEST_ASSERT_VAL("wrong COMM events count", events_comm == EVENTS_COMM);
+ TEST_ASSERT_VAL("wrong EXIT events count", events_exit == EVENTS_EXIT);
+ TEST_ASSERT_VAL("wrong FORK events count", events_fork == EVENTS_FORK);
+ TEST_ASSERT_VAL("wrong THROTTLE events count",
+ events_throttle == EVENTS_THROTTLE);
+ TEST_ASSERT_VAL("wrong UNTHROTTLE events count",
+ events_unthrottle == EVENTS_UNTHROTTLE);
+ TEST_ASSERT_VAL("wrong SAMPLE events count",
+ events_sample == EVENTS_SAMPLE);
+ return 0;
+}
+
+static int test_generated_data(void)
+{
+ char *file = get_file();
+ int err = 0;
+
+ TEST_ASSERT_VAL("failed to get temporary file", file);
+
+ err = session_write(file);
+ if (!err)
+ err = session_read(file);
+
+ unlink(file);
+ return err;
+}
+
+int test__session_simple(void)
+{
+ int err;
+
+ pr_debug("Testing generated data\n");
+ err = test_generated_data();
+ return err;
+}
diff --git a/tools/perf/tests/tests.h b/tools/perf/tests/tests.h
index 83d5b71..94b04cd 100644
--- a/tools/perf/tests/tests.h
+++ b/tools/perf/tests/tests.h
@@ -38,5 +38,6 @@ int test__sw_clock_freq(void);
int test__perf_time_to_tsc(void);
int test__code_reading(void);
int test__sample_parsing(void);
+int test__session_simple(void);
#endif /* TESTS_H */
--
1.7.11.7
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majord...@vger.kernel.org
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
