1 files changed, 406 insertions, 34 deletions

diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 496f21cadd97..d808a328f4dc 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -24,7 +24,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <stdbool.h>
 #include <errno.h>
+#include <linux/bitmap.h>
 
 #include "../../perf.h"
 #include "../debug.h"
@@ -33,6 +35,10 @@
 #include "../util.h"
 #include "../event.h"
 #include "../thread.h"
+#include "../comm.h"
+#include "../machine.h"
+#include "../db-export.h"
+#include "../thread-stack.h"
 #include "../trace-event.h"
 #include "../machine.h"
 
@@ -41,7 +47,7 @@ PyMODINIT_FUNC initperf_trace_context(void);
 #define FTRACE_MAX_EVENT                                \
         ((1 << (sizeof(unsigned short) * 8)) - 1)
 
-struct event_format *events[FTRACE_MAX_EVENT];
+static DECLARE_BITMAP(events_defined, FTRACE_MAX_EVENT);
 
 #define MAX_FIELDS      64
 #define N_COMMON_FIELDS 7
@@ -53,6 +59,24 @@ static int zero_flag_atom;
 
 static PyObject *main_module, *main_dict;
 
+struct tables {
+        struct db_export        dbe;
+        PyObject                *evsel_handler;
+        PyObject                *machine_handler;
+        PyObject                *thread_handler;
+        PyObject                *comm_handler;
+        PyObject                *comm_thread_handler;
+        PyObject                *dso_handler;
+        PyObject                *symbol_handler;
+        PyObject                *branch_type_handler;
+        PyObject                *sample_handler;
+        PyObject                *call_path_handler;
+        PyObject                *call_return_handler;
+        bool                    db_export_mode;
+};
+
+static struct tables tables_global;
+
 static void handler_call_die(const char *handler_name) NORETURN;
 static void handler_call_die(const char *handler_name)
 {
@@ -232,31 +256,6 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static inline struct event_format *find_cache_event(struct perf_evsel *evsel)
-{
-        static char ev_name[256];
-        struct event_format *event;
-        int type = evsel->attr.config;
-
-        /*
-         * XXX: Do we really need to cache this since now we have evsel->tp_format
-         * cached already? Need to re-read this "cache" routine that as well calls
-         * define_event_symbols() :-\
-         */
-        if (events[type])
-                return events[type];
-
-        events[type] = event = evsel->tp_format;
-        if (!event)
-                return NULL;
-
-        sprintf(ev_name, "%s__%s", event->system, event->name);
-
-        define_event_symbols(event, ev_name, event->print_fmt.args);
-
-        return event;
-}
-
 static PyObject *get_field_numeric_entry(struct event_format *event,
                 struct format_field *field, void *data)
 {
@@ -312,9 +311,9 @@ static PyObject *python_process_callchain(struct perf_sample *sample,
         if (!symbol_conf.use_callchain || !sample->callchain)
                 goto exit;
 
-        if (machine__resolve_callchain(al->machine, evsel, al->thread,
-                                           sample, NULL, NULL,
-                                           PERF_MAX_STACK_DEPTH) != 0) {
+        if (thread__resolve_callchain(al->thread, evsel,
+                                      sample, NULL, NULL,
+                                      PERF_MAX_STACK_DEPTH) != 0) {
                 pr_err("Failed to resolve callchain. Skipping\n");
                 goto exit;
         }
@@ -380,12 +379,12 @@ static void python_process_tracepoint(struct perf_sample *sample,
                                       struct thread *thread,
                                       struct addr_location *al)
 {
+        struct event_format *event = evsel->tp_format;
         PyObject *handler, *context, *t, *obj, *callchain;
         PyObject *dict = NULL;
         static char handler_name[256];
         struct format_field *field;
         unsigned long s, ns;
-        struct event_format *event;
         unsigned n = 0;
         int pid;
         int cpu = sample->cpu;
@@ -397,7 +396,6 @@ static void python_process_tracepoint(struct perf_sample *sample,
         if (!t)
                 Py_FatalError("couldn't create Python tuple");
 
-        event = find_cache_event(evsel);
         if (!event)
                 die("ug! no event found for type %d", (int)evsel->attr.config);
 
@@ -405,6 +403,9 @@ static void python_process_tracepoint(struct perf_sample *sample,
 
         sprintf(handler_name, "%s__%s", event->system, event->name);
 
+        if (!test_and_set_bit(event->id, events_defined))
+                define_event_symbols(event, handler_name, event->print_fmt.args);
+
         handler = get_handler(handler_name);
         if (!handler) {
                 dict = PyDict_New();
@@ -475,6 +476,289 @@ static void python_process_tracepoint(struct perf_sample *sample,
         Py_DECREF(t);
 }
 
+static PyObject *tuple_new(unsigned int sz)
+{
+        PyObject *t;
+
+        t = PyTuple_New(sz);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+        return t;
+}
+
+static int tuple_set_u64(PyObject *t, unsigned int pos, u64 val)
+{
+#if BITS_PER_LONG == 64
+        return PyTuple_SetItem(t, pos, PyInt_FromLong(val));
+#endif
+#if BITS_PER_LONG == 32
+        return PyTuple_SetItem(t, pos, PyLong_FromLongLong(val));
+#endif
+}
+
+static int tuple_set_s32(PyObject *t, unsigned int pos, s32 val)
+{
+        return PyTuple_SetItem(t, pos, PyInt_FromLong(val));
+}
+
+static int tuple_set_string(PyObject *t, unsigned int pos, const char *s)
+{
+        return PyTuple_SetItem(t, pos, PyString_FromString(s));
+}
+
+static int python_export_evsel(struct db_export *dbe, struct perf_evsel *evsel)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        PyObject *t;
+
+        t = tuple_new(2);
+
+        tuple_set_u64(t, 0, evsel->db_id);
+        tuple_set_string(t, 1, perf_evsel__name(evsel));
+
+        call_object(tables->evsel_handler, t, "evsel_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_machine(struct db_export *dbe,
+                                 struct machine *machine)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        PyObject *t;
+
+        t = tuple_new(3);
+
+        tuple_set_u64(t, 0, machine->db_id);
+        tuple_set_s32(t, 1, machine->pid);
+        tuple_set_string(t, 2, machine->root_dir ? machine->root_dir : "");
+
+        call_object(tables->machine_handler, t, "machine_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_thread(struct db_export *dbe, struct thread *thread,
+                                u64 main_thread_db_id, struct machine *machine)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        PyObject *t;
+
+        t = tuple_new(5);
+
+        tuple_set_u64(t, 0, thread->db_id);
+        tuple_set_u64(t, 1, machine->db_id);
+        tuple_set_u64(t, 2, main_thread_db_id);
+        tuple_set_s32(t, 3, thread->pid_);
+        tuple_set_s32(t, 4, thread->tid);
+
+        call_object(tables->thread_handler, t, "thread_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_comm(struct db_export *dbe, struct comm *comm)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        PyObject *t;
+
+        t = tuple_new(2);
+
+        tuple_set_u64(t, 0, comm->db_id);
+        tuple_set_string(t, 1, comm__str(comm));
+
+        call_object(tables->comm_handler, t, "comm_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_comm_thread(struct db_export *dbe, u64 db_id,
+                                     struct comm *comm, struct thread *thread)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        PyObject *t;
+
+        t = tuple_new(3);
+
+        tuple_set_u64(t, 0, db_id);
+        tuple_set_u64(t, 1, comm->db_id);
+        tuple_set_u64(t, 2, thread->db_id);
+
+        call_object(tables->comm_thread_handler, t, "comm_thread_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_dso(struct db_export *dbe, struct dso *dso,
+                             struct machine *machine)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        char sbuild_id[BUILD_ID_SIZE * 2 + 1];
+        PyObject *t;
+
+        build_id__sprintf(dso->build_id, sizeof(dso->build_id), sbuild_id);
+
+        t = tuple_new(5);
+
+        tuple_set_u64(t, 0, dso->db_id);
+        tuple_set_u64(t, 1, machine->db_id);
+        tuple_set_string(t, 2, dso->short_name);
+        tuple_set_string(t, 3, dso->long_name);
+        tuple_set_string(t, 4, sbuild_id);
+
+        call_object(tables->dso_handler, t, "dso_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_symbol(struct db_export *dbe, struct symbol *sym,
+                                struct dso *dso)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        u64 *sym_db_id = symbol__priv(sym);
+        PyObject *t;
+
+        t = tuple_new(6);
+
+        tuple_set_u64(t, 0, *sym_db_id);
+        tuple_set_u64(t, 1, dso->db_id);
+        tuple_set_u64(t, 2, sym->start);
+        tuple_set_u64(t, 3, sym->end);
+        tuple_set_s32(t, 4, sym->binding);
+        tuple_set_string(t, 5, sym->name);
+
+        call_object(tables->symbol_handler, t, "symbol_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_branch_type(struct db_export *dbe, u32 branch_type,
+                                     const char *name)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        PyObject *t;
+
+        t = tuple_new(2);
+
+        tuple_set_s32(t, 0, branch_type);
+        tuple_set_string(t, 1, name);
+
+        call_object(tables->branch_type_handler, t, "branch_type_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_sample(struct db_export *dbe,
+                                struct export_sample *es)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        PyObject *t;
+
+        t = tuple_new(21);
+
+        tuple_set_u64(t, 0, es->db_id);
+        tuple_set_u64(t, 1, es->evsel->db_id);
+        tuple_set_u64(t, 2, es->al->machine->db_id);
+        tuple_set_u64(t, 3, es->thread->db_id);
+        tuple_set_u64(t, 4, es->comm_db_id);
+        tuple_set_u64(t, 5, es->dso_db_id);
+        tuple_set_u64(t, 6, es->sym_db_id);
+        tuple_set_u64(t, 7, es->offset);
+        tuple_set_u64(t, 8, es->sample->ip);
+        tuple_set_u64(t, 9, es->sample->time);
+        tuple_set_s32(t, 10, es->sample->cpu);
+        tuple_set_u64(t, 11, es->addr_dso_db_id);
+        tuple_set_u64(t, 12, es->addr_sym_db_id);
+        tuple_set_u64(t, 13, es->addr_offset);
+        tuple_set_u64(t, 14, es->sample->addr);
+        tuple_set_u64(t, 15, es->sample->period);
+        tuple_set_u64(t, 16, es->sample->weight);
+        tuple_set_u64(t, 17, es->sample->transaction);
+        tuple_set_u64(t, 18, es->sample->data_src);
+        tuple_set_s32(t, 19, es->sample->flags & PERF_BRANCH_MASK);
+        tuple_set_s32(t, 20, !!(es->sample->flags & PERF_IP_FLAG_IN_TX));
+
+        call_object(tables->sample_handler, t, "sample_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_call_path(struct db_export *dbe, struct call_path *cp)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        PyObject *t;
+        u64 parent_db_id, sym_db_id;
+
+        parent_db_id = cp->parent ? cp->parent->db_id : 0;
+        sym_db_id = cp->sym ? *(u64 *)symbol__priv(cp->sym) : 0;
+
+        t = tuple_new(4);
+
+        tuple_set_u64(t, 0, cp->db_id);
+        tuple_set_u64(t, 1, parent_db_id);
+        tuple_set_u64(t, 2, sym_db_id);
+        tuple_set_u64(t, 3, cp->ip);
+
+        call_object(tables->call_path_handler, t, "call_path_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_export_call_return(struct db_export *dbe,
+                                     struct call_return *cr)
+{
+        struct tables *tables = container_of(dbe, struct tables, dbe);
+        u64 comm_db_id = cr->comm ? cr->comm->db_id : 0;
+        PyObject *t;
+
+        t = tuple_new(11);
+
+        tuple_set_u64(t, 0, cr->db_id);
+        tuple_set_u64(t, 1, cr->thread->db_id);
+        tuple_set_u64(t, 2, comm_db_id);
+        tuple_set_u64(t, 3, cr->cp->db_id);
+        tuple_set_u64(t, 4, cr->call_time);
+        tuple_set_u64(t, 5, cr->return_time);
+        tuple_set_u64(t, 6, cr->branch_count);
+        tuple_set_u64(t, 7, cr->call_ref);
+        tuple_set_u64(t, 8, cr->return_ref);
+        tuple_set_u64(t, 9, cr->cp->parent->db_id);
+        tuple_set_s32(t, 10, cr->flags);
+
+        call_object(tables->call_return_handler, t, "call_return_table");
+
+        Py_DECREF(t);
+
+        return 0;
+}
+
+static int python_process_call_return(struct call_return *cr, void *data)
+{
+        struct db_export *dbe = data;
+
+        return db_export__call_return(dbe, cr);
+}
+
 static void python_process_general_event(struct perf_sample *sample,
                                          struct perf_evsel *evsel,
                                          struct thread *thread,
@@ -551,19 +835,25 @@ exit:
         Py_DECREF(t);
 }
 
-static void python_process_event(union perf_event *event __maybe_unused,
+static void python_process_event(union perf_event *event,
                                  struct perf_sample *sample,
                                  struct perf_evsel *evsel,
                                  struct thread *thread,
                                  struct addr_location *al)
 {
+        struct tables *tables = &tables_global;
+
         switch (evsel->attr.type) {
         case PERF_TYPE_TRACEPOINT:
                 python_process_tracepoint(sample, evsel, thread, al);
                 break;
         /* Reserve for future process_hw/sw/raw APIs */
         default:
-                python_process_general_event(sample, evsel, thread, al);
+                if (tables->db_export_mode)
+                        db_export__sample(&tables->dbe, event, sample, evsel,
+                                          thread, al);
+                else
+                        python_process_general_event(sample, evsel, thread, al);
         }
 }
 
@@ -589,11 +879,79 @@ error:
         return -1;
 }
 
+#define SET_TABLE_HANDLER_(name, handler_name, table_name) do {         \
+        tables->handler_name = get_handler(#table_name);                \
+        if (tables->handler_name)                                       \
+                tables->dbe.export_ ## name = python_export_ ## name;   \
+} while (0)
+
+#define SET_TABLE_HANDLER(name) \
+        SET_TABLE_HANDLER_(name, name ## _handler, name ## _table)
+
+static void set_table_handlers(struct tables *tables)
+{
+        const char *perf_db_export_mode = "perf_db_export_mode";
+        const char *perf_db_export_calls = "perf_db_export_calls";
+        PyObject *db_export_mode, *db_export_calls;
+        bool export_calls = false;
+        int ret;
+
+        memset(tables, 0, sizeof(struct tables));
+        if (db_export__init(&tables->dbe))
+                Py_FatalError("failed to initialize export");
+
+        db_export_mode = PyDict_GetItemString(main_dict, perf_db_export_mode);
+        if (!db_export_mode)
+                return;
+
+        ret = PyObject_IsTrue(db_export_mode);
+        if (ret == -1)
+                handler_call_die(perf_db_export_mode);
+        if (!ret)
+                return;
+
+        tables->dbe.crp = NULL;
+        db_export_calls = PyDict_GetItemString(main_dict, perf_db_export_calls);
+        if (db_export_calls) {
+                ret = PyObject_IsTrue(db_export_calls);
+                if (ret == -1)
+                        handler_call_die(perf_db_export_calls);
+                export_calls = !!ret;
+        }
+
+        if (export_calls) {
+                tables->dbe.crp =
+                        call_return_processor__new(python_process_call_return,
+                                                   &tables->dbe);
+                if (!tables->dbe.crp)
+                        Py_FatalError("failed to create calls processor");
+        }
+
+        tables->db_export_mode = true;
+        /*
+         * Reserve per symbol space for symbol->db_id via symbol__priv()
+         */
+        symbol_conf.priv_size = sizeof(u64);
+
+        SET_TABLE_HANDLER(evsel);
+        SET_TABLE_HANDLER(machine);
+        SET_TABLE_HANDLER(thread);
+        SET_TABLE_HANDLER(comm);
+        SET_TABLE_HANDLER(comm_thread);
+        SET_TABLE_HANDLER(dso);
+        SET_TABLE_HANDLER(symbol);
+        SET_TABLE_HANDLER(branch_type);
+        SET_TABLE_HANDLER(sample);
+        SET_TABLE_HANDLER(call_path);
+        SET_TABLE_HANDLER(call_return);
+}
+
 /*
  * Start trace script
  */
 static int python_start_script(const char *script, int argc, const char **argv)
 {
+        struct tables *tables = &tables_global;
         const char **command_line;
         char buf[PATH_MAX];
         int i, err = 0;
@@ -632,6 +990,14 @@ static int python_start_script(const char *script, int argc, const char **argv)
 
         free(command_line);
 
+        set_table_handlers(tables);
+
+        if (tables->db_export_mode) {
+                err = db_export__branch_types(&tables->dbe);
+                if (err)
+                        goto error;
+        }
+
         return err;
 error:
         Py_Finalize();
@@ -642,7 +1008,9 @@ error:
 
 static int python_flush_script(void)
 {
-        return 0;
+        struct tables *tables = &tables_global;
+
+        return db_export__flush(&tables->dbe);
 }
 
 /*
@@ -650,8 +1018,12 @@ static int python_flush_script(void)
  */
 static int python_stop_script(void)
 {
+        struct tables *tables = &tables_global;
+
         try_call_object("trace_end", NULL);
 
+        db_export__exit(&tables->dbe);
+
         Py_XDECREF(main_dict);
         Py_XDECREF(main_module);
         Py_Finalize();