python plugin

This adds a python plugin that can in turn
load plugins written in python.

To make it work, trace-cmd needs to load
plugin modules with RTLD_GLOBAL so that
the python interpreter's symbols will be
available to python C extension modules.

Signed-off-by: Johannes Berg <johannes@sipsolutions.net>

5 files changed, 289 insertions, 1 deletions

diff --git a/Documentation/README.PythonPlugin b/Documentation/README.PythonPlugin
new file mode 100644
index 0000000..3de0564
--- /dev/null
+++ b/Documentation/README.PythonPlugin
@@ -0,0 +1,127 @@
+ PYTHON PLUGIN DOCUMENTATION
+=============================
+
+With the python plugin (make python-plugin) you can now
+write plugins in python. The API exported by the python
+plugin itself (written in C) allows you to access most
+information about a record from python.
+
+To write a python plugin, put a new .py file into a new
+~/.trace-cmd/python/ directory.
+
+The most basic python plugin is this:
+
+--- %< ---
+def register(pevent):
+    pass
+--- >% ---
+
+which obviously does nothing at all.
+
+To register a callback, use the pevent.register_event_handler
+function:
+
+--- %< ---
+import tracecmd
+
+def my_event_handler(trace_seq, event):
+    pass
+
+def register(pevent):
+    pevent.register_event_handler("subsys", "event_name",
+                                  my_event_handler)
+--- >% ---
+
+
+There are four object types that you get, described below.
+
+ tracecmd.PEvent
+-----------------
+
+This is the class of the 'pevent' object above,
+you get one of those via your register callback.
+It has one method and one property:
+ * register_event_handler() - example above, to register
+                              an event handler function
+ * file_endian              - either '<' or '>' indicating
+                              which endianness the file has,
+                              to be used with struct.unpack()
+
+ tracecmd.TraceSeq
+-------------------
+
+This is the class of the 'trace_seq' parameter to your callback
+function. It has only one method, puts(), to put data into the
+buffer. Formatting must be done in python.
+
+ tracecmd.Event
+----------------------
+
+This is the class of the 'event' parameter to your callback
+function. Note that it doesn't just contain the format, but
+also the event data. As such, you can do much with this, and
+this is what you'll usually use. Each instance of this allows
+access to record items via the dict protocol, and you can get
+the items via its keys() methods. So for example, your
+callback could be
+
+--- %< ---
+def my_callback(trace_seq, event):
+    for fieldname in event.keys():
+        field = event[fieldname]
+--- >% ---
+
+Each field returned from the dict protocol is an instance of
+the next (and last) class:
+
+ tracecmd.Field
+----------------------
+
+This is an instance of a field, including its data. It affords
+numerous use cases and is what you'll be using most.
+
+ * If this is an integer field, i.e. 1, 2, 4 or 8 bytes long,
+   you can convert it to the number contained, according to
+   the file's endianness, by simply casting it to a long:
+
+     field = event['myint']
+     value = long(field)
+
+ * You can access the field's data, as field.data, and if the
+   data is really a "__data_loc" type that will be resolved
+   automatically. (If you don't know what this means, don't
+   worry about it and just use field.data)
+
+
+This is it. It's pretty simple. A fully-featured plugin could
+look like this:
+
+--- %< ---
+def my_event_handler(trace_seq, event):
+    trace_seq.puts("myev: %u", long(event['myfield']))
+
+def register(pevent):
+    pevent.register_event_handler("subsys", "event_name",
+                                  my_event_handler)
+--- >% ---
+
+
+ Tips and tricks
+-----------------
+
+Be familiar with the struct module and use it, always
+checking endianness and potentially using pevent.file_endian.
+
+
+If you need access to pevent in your callbacks, simply
+pass it in yourself:
+
+--- %< ---
+def my_event_handler(pevent, trace_seq, event):
+    pass
+
+def register(pevent):
+    pevent.register_event_handler("subsys", "event_name",
+        lambda *args: my_event_handler(pevent, *args)
+    )
+--- >% ---
diff --git a/Makefile b/Makefile
index 726d28e..a4a89ed 100644
--- a/Makefile
+++ b/Makefile
@@ -439,6 +439,8 @@ clean:
 ##### PYTHON STUFF #####
 
 PYTHON_INCLUDES = `python-config --includes`
+PYTHON_LDFLAGS = `python-config --ldflags` \
+                $(shell python -c "import distutils.sysconfig; print distutils.sysconfig.get_config_var('LINKFORSHARED')")
 PYGTK_CFLAGS = `pkg-config --cflags pygtk-2.0`
 
 ctracecmd.so: $(TCMD_LIB_OBJS) ctracecmd.i
@@ -457,6 +459,23 @@ python: ctracecmd.so
 PHONY += python-gui
 python-gui: ctracecmd.so ctracecmdgui.so 
 
+PHONY += python-plugin
+python-plugin: plugin_python.so python
+
+do_compile_python_plugin_obj =                  \
+        ($(print_plugin_obj_compile)            \
+        $(CC) -c $(CFLAGS) $(PYTHON_INCLUDES) -fPIC -o $@ $<)
+
+do_python_plugin_build =                        \
+        ($(print_plugin_build)                  \
+        $(CC) -shared $(PYTHON_LDFLAGS) -o $@ $<)
+
+plugin_python.o: %.o : $(src)/%.c
+        $(Q)$(do_compile_python_plugin_obj)
+
+plugin_python.so: %.so: %.o
+        $(Q)$(do_python_plugin_build)
+
 endif # skip-makefile
 
 PHONY += force
diff --git a/ctracecmd.i b/ctracecmd.i
index 624fb63..a0baa3c 100644
--- a/ctracecmd.i
+++ b/ctracecmd.i
@@ -34,6 +34,12 @@ static int python_callback(struct trace_seq *s,
                            struct event_format *event,
                            void *context);
 
+PyObject *convert_pevent(unsigned long pevent)
+{
+        void *pev = (void *)pevent;
+        return SWIG_NewPointerObj(SWIG_as_voidptr(pev), SWIGTYPE_p_pevent, 0);
+}
+
 void py_pevent_register_event_handler(struct pevent *pevent, int id,
                                       char *subsys, char *evname,
                                       PyObject *pyfunc)
diff --git a/plugin_python.c b/plugin_python.c
new file mode 100644
index 0000000..164e774
--- /dev/null
+++ b/plugin_python.c
@@ -0,0 +1,136 @@
+#include <Python.h>
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+#include <stdio.h>
+#include <dirent.h>
+#include <fnmatch.h>
+#include "trace-cmd.h"
+
+static const char pyload[] =
+"import imp, tracecmd, ctracecmd\n"
+"fn = r'%s'\n"
+"file = open(fn, 'r')\n"
+"try:\n"
+"   module = imp.load_source('%s', fn, file)\n"
+"   module.register(tracecmd.PEvent(ctracecmd.convert_pevent(pevent)))\n"
+"finally:\n"
+"   file.close()\n";
+
+static void load_plugin(PyObject *globals, char *path, const char *name)
+{
+        int len = strlen(path) + strlen(name) + 2;
+        int nlen = strlen(name) + 1;
+        char *full = malloc(len);
+        char *n = malloc(nlen);
+        char *load;
+        PyObject *res;
+
+        if (!full || !n)
+                return;
+
+        strcpy(full, path);
+        strcat(full, "/");
+        strcat(full, name);
+
+        strcpy(n, name);
+        n[nlen - 4] = '\0';
+
+        asprintf(&load, pyload, full, n);
+        if (!load)
+                return;
+
+        res = PyRun_String(load, Py_file_input, globals, globals);
+        if (!res) {
+                fprintf(stderr, "failed loading %s\n", full);
+                PyErr_Print();
+        } else
+                Py_DECREF(res);
+
+        free(load);
+}
+
+static int load_plugins(PyObject *globals, char *path)
+{
+        struct dirent *dent;
+        struct stat st;
+        DIR *dir;
+        int ret;
+
+        ret = stat(path, &st);
+        if (ret < 0)
+                return -1;
+
+        if (!S_ISDIR(st.st_mode))
+                return -1;
+
+        dir = opendir(path);
+        if (!dir)
+                return -1;
+
+        while ((dent = readdir(dir))) {
+                const char *name = dent->d_name;
+
+                if (fnmatch("*.py", name, FNM_PERIOD))
+                        continue;
+
+                load_plugin(globals, path, name);
+        }
+
+        closedir(dir);
+
+        return 0;
+}
+
+#define LOCAL_PLUGIN_DIR        ".trace-cmd/python"
+
+int PEVENT_PLUGIN_LOADER(struct pevent *pevent)
+{
+        char *home;
+        char *path;
+        int ret;
+        PyObject *globals, *m, *py_pevent, *str;
+
+        home = getenv("HOME");
+        if (!home)
+                return 0;
+
+        Py_Initialize();
+
+        m = PyImport_AddModule("__main__");
+        globals = PyModule_GetDict(m);
+
+        str = PyString_FromString("pevent");
+        if (!str)
+                return -ENOMEM;
+
+        py_pevent = PyLong_FromUnsignedLong((unsigned long)pevent);
+        if (!py_pevent)
+                return -ENOMEM;
+
+        if (PyDict_SetItem(globals, str, py_pevent))
+                fprintf(stderr, "failed to insert pevent\n");
+
+        Py_DECREF(py_pevent);
+        Py_DECREF(str);
+
+        path = malloc(strlen(home) + strlen(LOCAL_PLUGIN_DIR) + 2);
+        if (!path)
+                return -1;
+
+        strcpy(path, home);
+        strcat(path, "/");
+        strcat(path, LOCAL_PLUGIN_DIR);
+
+        ret = load_plugins(globals, path);
+
+        free(path);
+
+        return ret;
+}
+
+int PEVENT_PLUGIN_UNLOADER(void)
+{
+        Py_Finalize();
+        return 0;
+}
diff --git a/trace-util.c b/trace-util.c
index 7c0481a..4fd1d38 100644
--- a/trace-util.c
+++ b/trace-util.c
@@ -212,7 +212,7 @@ load_plugin(struct pevent *pevent, struct plugin_list *plugin_list,
         strcat(plugin, "/");
         strcat(plugin, file);
 
-        handle = dlopen(plugin, RTLD_NOW);
+        handle = dlopen(plugin, RTLD_NOW | RTLD_GLOBAL);
         if (!handle) {
                 warning("cound not load plugin '%s'\n%s\n",
                         plugin, dlerror());