1 files changed, 128 insertions, 39 deletions

diff --git a/tracecmd.py b/tracecmd.py
index 6b05e23..ad80ccd 100644
--- a/tracecmd.py
+++ b/tracecmd.py
@@ -18,6 +18,7 @@
 # 2009-Dec-17:  Initial version by Darren Hart <dvhltc@us.ibm.com>
 #
 
+from functools import update_wrapper
 from ctracecmd import *
 
 """
@@ -31,13 +32,33 @@ and it is recommended applications not use it directly.
 TODO: consider a complete class hierarchy of ftrace events...
 """
 
+def cached_property(func, name=None):
+    if name is None:
+        name = func.__name__
+    def _get(self):
+        try:
+            return self.__cached_properties[name]
+        except AttributeError:
+            self.__cached_properties = {}
+        except KeyError:
+            pass
+        value = func(self)
+        self.__cached_properties[name] = value
+        return value
+    update_wrapper(_get, func)
+    def _del(self):
+        self.__cached_properties.pop(name, None)
+    return property(_get, None, _del)
+
 class Event(object):
-    def __init__(self, trace, record, cpu):
-        self.trace = trace
-        self.rec = record
-        self.cpu = cpu
-        type = pevent_data_type(trace.pe, record)
-        self.format = pevent_data_event_from_type(trace.pe, type)
+    """
+    This class can be used to access event data
+    according to an event's record and format.
+    """
+    def __init__(self, pevent, record, format):
+        self._pevent = pevent
+        self._record = record
+        self._format = format
 
     def __str__(self):
         return "%d.%d CPU%d %s: pid=%d comm=%s type=%d" % \
@@ -45,35 +66,105 @@ class Event(object):
                 self.num_field("common_pid"), self.comm, self.type)
 
     def __del__(self):
-        free_record(self.rec);
+        free_record(self._record)
+
+    def __getitem__(self, n):
+        f = pevent_find_field(self._format, n)
+        if f is None:
+            raise KeyError("no field '%s'" % n)
+        return Field(self._record, f)
 
+    def keys(self):
+        return py_format_get_keys(self._format)
 
-    # TODO: consider caching the results of the properties
-    @property
+    @cached_property
     def comm(self):
-        return self.trace.comm_from_pid(self.pid)
+        return pevent_data_comm_from_pid(self._pevent, self.pid)
 
-    @property
+    @cached_property
+    def cpu(self):
+        return record_cpu_get(self._record)
+
+    @cached_property
     def name(self):
-        return event_format_name_get(self.format)
+        return event_format_name_get(self._format)
 
-    @property
+    @cached_property
     def pid(self):
-        return pevent_data_pid(self.trace.pe, self.rec)
+        return pevent_data_pid(self._pevent, self._record)
 
-    @property
+    @cached_property
     def ts(self):
-        return record_ts_get(self.rec)
+        return record_ts_get(self._record)
 
-    @property
+    @cached_property
     def type(self):
-        return pevent_data_type(self.trace.pe, self.rec)
+        return pevent_data_type(self._pevent, self._record)
 
     def num_field(self, name):
-        f = pevent_find_any_field(self.format, name)
-        val = pevent_read_number_field_py(f, record_data_get(self.rec))
+        f = pevent_find_any_field(self._format, name)
+        if f is None:
+            return None
+        ret, val = pevent_read_number_field(f, record_data_get(self._record))
+        if ret:
+            return None
         return val
 
+    def str_field(self, name):
+        f = pevent_find_any_field(self._format, name)
+        if f is None:
+            return None
+        return py_field_get_str(f, self._record)
+
+class TraceSeq(object):
+    def __init__(self, trace_seq):
+        self._trace_seq = trace_seq
+
+    def puts(self, s):
+        return trace_seq_puts(self._trace_seq, s)
+
+class FieldError(Exception):
+    pass
+
+class Field(object):
+    def __init__(self, record, field):
+        self._record = record
+        self._field = field
+
+    @cached_property
+    def data(self):
+        return py_field_get_data(self._field, self._record)
+
+    def __long__(self):
+        ret, val =  pevent_read_number_field(self._field,
+                                             record_data_get(self._record))
+        if ret:
+            raise FieldError("Not a number field")
+        return val
+    __int__ = __long__
+
+    def __str__(self):
+        return py_field_get_str(self._field, self._record)
+
+class PEvent(object):
+    def __init__(self, pevent):
+        self._pevent = pevent
+
+    def _handler(self, cb, s, record, event_fmt):
+        return cb(TraceSeq(s), Event(self._pevent, record, event_fmt))
+
+    def register_event_handler(self, subsys, event_name, callback):
+        l = lambda s, r, e: self._handler(callback, s, r, e)
+
+        py_pevent_register_event_handler(
+                  self._pevent, -1, subsys, event_name, l)
+
+    @cached_property
+    def file_endian(self):
+        if pevent_is_file_bigendian(self._pevent):
+            return '>'
+        return '<'
+
 
 class FileFormatError(Exception):
     pass
@@ -86,45 +177,43 @@ class Trace(object):
     used to manage the trace and extract events from it.
     """
     def __init__(self, filename):
-        self.handle = tracecmd_open(filename)
+        self._handle = tracecmd_alloc(filename)
 
-        if tracecmd_read_headers(self.handle):
+        if tracecmd_read_headers(self._handle):
             raise FileFormatError("Invalid headers")
 
-        if tracecmd_init_data(self.handle):
+        if tracecmd_init_data(self._handle):
             raise FileFormatError("Failed to init data")
 
-        self.pe = tracecmd_get_pevent(self.handle)
+        self._pevent = tracecmd_get_pevent(self._handle)
 
-    @property
+    @cached_property
     def cpus(self):
-        return tracecmd_cpus(self.handle)
+        return tracecmd_cpus(self._handle)
 
     def read_event(self, cpu):
-        rec = tracecmd_read_data(self.handle, cpu)
+        rec = tracecmd_read_data(self._handle, cpu)
         if rec:
-            #rec.acquire()
-            #rec.thisown = 1
-            return Event(self, rec, cpu)
+            type = pevent_data_type(self._pevent, rec)
+            format = pevent_data_event_from_type(self._pevent, type)
+            # rec ownership goes over to Event instance
+            return Event(self._pevent, rec, format)
         return None
 
     def read_event_at(self, offset):
-        res = tracecmd_read_at(self.handle, offset)
+        res = tracecmd_read_at(self._handle, offset)
         # SWIG only returns the CPU if the record is None for some reason
         if isinstance(res, int):
             return None
-        rec,cpu = res
-        #rec.acquire()
-        #rec.thisown = 1
-        ev = Event(self, rec, cpu)
-        return ev
+        rec, cpu = res
+        type = pevent_data_type(self._pevent, rec)
+        format = pevent_data_event_from_type(self._pevent, type)
+        # rec ownership goes over to Event instance
+        return Event(self._pevent, rec, format)
 
     def peek_event(self, cpu):
         pass
 
-    def comm_from_pid(self, pid):
-        return pevent_data_comm_from_pid(self.pe, pid)
-
 
 # Basic builtin test, execute module directly
 if __name__ == "__main__":