refactored

Thijs Metsch · Thijs Metsch · commit fe66065c61b0 · 2011-10-10T11:03:53.000+02:00
diff --git a/.gitignore b/.gitignore
@@ -1,3 +1,4 @@
+MANIFEST
 .make.state.Debug
 .dep.inc
 Makefile
diff --git a/.project b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>python-dtrace</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.python.pydev.pythonNature</nature>
+	</natures>
+</projectDescription>
diff --git a/.pydevproject b/.pydevproject
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?>
+
+<pydev_project>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
+<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
+<path>/python-dtrace</path>
+</pydev_pathproperty>
+</pydev_project>
diff --git a/LICENSE b/LICENSE
@@ -0,0 +1,3 @@
+Copyright (C) 2011 by Thijs Metsch
+
+LICENSE TBD
diff --git a/MANIFEST.in b/MANIFEST.in
@@ -0,0 +1,3 @@
+include setup.py
+include LICENSE
+recursive-include examples/ *.py
diff --git a/README.md b/README.md
@@ -2,14 +2,8 @@
 Python as a DTrace consumer
 ===========================
 
-This is a first shot into looking at getting something up and running like https://github.com/bcantrill/node-libdtrace for Python. 
+This is a first shot into looking at getting something up and running like https://github.com/bcantrill/node-libdtrace for Python.
 
-Note: This is far from ready - documentation on writing own DTrace consumers is very rare :-) Therefore I started of with main.c which is a simple starting point to interface DTrace.
+Note: This is far from ready - documentation on writing own DTrace consumers is very rare :-)
 
-What does work: run a 'Hello World' - works for the C code (main.c) and python code (dtrace.py). Both programs should give a rough overview of how to access DTrace and write an own DTrace consumer.
-
-Current ideas on how to progress include:
-
- * Call libdtrace using ctypes directly (Might be hard because of the callbacks during aggregation)
- * Writing a simple C interface which is more 'pythonic' which than can be used in Python (maybe the way to go - but requires some work)
- * maybe even SWIG :-/
+The codes in the examples folder should give an overview of how to use Python as a DTrace consumer.
diff --git a/attic/dtrace.py b/attic/dtrace.py
@@ -45,7 +45,7 @@ class dtrace_bufdata(Structure):
     As defined in dtrace.h:310
     '''
     _fields_ = [("dtbda_handle", c_void_p),
-                ("dtbda_buffered", c_char_p),       # works
+                ("dtbda_buffered", c_char_p), # works
                 ("dtbda_probe", c_void_p),
                 ("dtbda_recdesc", c_void_p),
                 ("dtbda_aggdata", c_void_p),
@@ -70,7 +70,7 @@ class dtrace_probedata(Structure):
     _fields_ = [("dtpda_handle", c_void_p),
                ("dtpda_edesc", c_void_p),
                ("dtpda_pdesc", dtrace_probedesc),
-               ("dtpda_cpu", c_int),                # works
+               ("dtpda_cpu", c_int), # works
                ("dtpda_data", c_void_p),
                ("dtpda_flow", c_void_p),
                ("dtpda_prefix", c_void_p),
@@ -126,12 +126,12 @@ def chewrec_func(data, rec, arg):
     return 0
 
 
-def out(bufdata, arg):
+def buffered_stdout_writer(bufdata, arg):
     '''
     In case dtrace_work is given None as filename - this one is called.
     '''
     tmp = c_char_p(bufdata.contents.dtbda_buffered).value.strip()
-    print '  +--> In out: ', tmp
+    print '  +--> In buffered_stdout_writer: ', tmp
     return 0
 
 
@@ -167,7 +167,7 @@ def run_dtrace():
         raise Exception(c_char_p(txt).value)
 
     # callbacks
-    buf_func = BUFFERED_FUNC(out)
+    buf_func = BUFFERED_FUNC(buffered_stdout_writer)
     LIBRARY.dtrace_handle_buffered(handle, buf_func, None)
 
     # compile
diff --git a/attic/main.c b/attic/main.c
diff --git a/dtrace/__init__.py b/dtrace/__init__.py
@@ -0,0 +1,7 @@
+'''
+Package containing the DTrace consumer.
+
+Created on Oct 10, 2011
+
+@author: tmetsch
+'''
diff --git a/dtrace/__init__.pyc b/dtrace/__init__.pyc
diff --git a/dtrace/consumer.py b/dtrace/consumer.py
@@ -0,0 +1,161 @@
+'''
+The implementation of the consumer.
+
+Created on Oct 10, 2011
+
+@author: tmetsch
+'''
+
+from ctypes import cdll, CDLL, byref, c_int, c_char_p, CFUNCTYPE, c_void_p, \
+    POINTER, cast
+from dtrace.dtrace_structs import dtrace_bufdata, dtrace_probedata, \
+    dtrace_aggdata, dtrace_recdesc
+import time
+
+cdll.LoadLibrary("libdtrace.so")
+
+LIBRARY = CDLL("libdtrace.so")
+
+
+def chew_func(data, arg):
+    '''
+    Callback for chew.
+    '''
+    print 'CPU :', c_int(data.contents.dtpda_cpu).value
+    return 0
+
+
+def chewrec_func(data, rec, arg):
+    '''
+    Callback for record chewing.
+    '''
+    if rec == None:
+        return 1
+    return 0
+
+
+def buffered_stdout_writer(bufdata, arg):
+    '''
+    In case dtrace_work is given None as filename - this one is called.
+    '''
+    tmp = c_char_p(bufdata.contents.dtbda_buffered).value.strip()
+    print 'out >', tmp
+    return 0
+
+
+def walk(data, arg):
+    '''
+    Aggregate walker.
+    '''
+
+    # TODO: pickup the 16 and 272 from offset in desc...
+
+    tmp = data.contents.dtada_data
+    name = cast(tmp + 16, c_char_p).value
+    instance = deref(tmp + 272, c_int).value
+
+    print '{0:60s} :{1:10d}'.format(name, instance)
+
+    return 0
+
+
+def deref(addr, typ):
+    '''
+    Deref a pointer.
+    '''
+    return cast(addr, POINTER(typ)).contents
+
+CHEW_FUNC = CFUNCTYPE(c_int,
+                      POINTER(dtrace_probedata),
+                      POINTER(c_void_p))
+CHEWREC_FUNC = CFUNCTYPE(c_int,
+                         POINTER(dtrace_probedata),
+                         POINTER(dtrace_recdesc),
+                         POINTER(c_void_p))
+BUFFERED_FUNC = CFUNCTYPE(c_int,
+                          POINTER(dtrace_bufdata),
+                          POINTER(c_void_p))
+WALK_FUNC = CFUNCTYPE(c_int,
+                      POINTER(dtrace_aggdata),
+                      POINTER(c_void_p))
+
+class DTraceConsumer(object):
+    '''
+    A Pyton based DTrace consumer.
+    '''
+
+    def __init__(self):
+        '''
+        Constructor. will get the DTrace handle
+        '''
+        # get dtrace handle
+        self.handle = LIBRARY.dtrace_open(3, 0, byref(c_int(0)))
+        if self.handle == None:
+            raise Exception('Unable to get a DTrace handle.')
+
+        # set buffer options
+        if LIBRARY.dtrace_setopt(self.handle, 'bufsize', '4m') != 0:
+            raise Exception(self._get_error_msg())
+
+        if LIBRARY.dtrace_setopt(self.handle, 'aggsize', '4m') != 0:
+            raise Exception(self._get_error_msg())
+
+    def __del__(self):
+        '''
+        Always close the DTrace handle :-)
+        '''
+        LIBRARY.dtrace_close(self.handle)
+
+    def run_script(self, script, runtime=1):
+        '''
+        Run a DTrace script for a number of seconds defined by the runtime.
+
+        After the run is complete the aggregate is walked. During execution the
+        stdout of DTrace is redirected to the chew, chewrec and buffered output
+        writer.
+
+        script -- The script to run.
+        runtime -- The time the script should run in second (Default: 1s).
+        '''
+        # set simple output callbacks
+        buf_func = BUFFERED_FUNC(buffered_stdout_writer)
+        if LIBRARY.dtrace_handle_buffered(self.handle, buf_func, None) == -1:
+            raise Exception('Unable to set the stdout buffered writer.')
+
+        # compile
+        prg = LIBRARY.dtrace_program_strcompile(self.handle,
+                                                     script, 3, 4, 0, None)
+        if prg == None:
+            raise Exception('Unable to compile the script: ',
+                            self._get_error_msg())
+
+        # run
+        if LIBRARY.dtrace_program_exec(self.handle, prg, None) == -1:
+            raise Exception('Failed to execute: ', self._get_error_msg())
+        if LIBRARY.dtrace_go(self.handle) != 0:
+            raise Exception('Failed to run_script: ', self._get_error_msg())
+
+        # aggregate data for a few sec...
+        i = 0
+        chew = CHEW_FUNC(chew_func)
+        chew_rec = CHEWREC_FUNC(chewrec_func)
+        while i < runtime:
+            LIBRARY.dtrace_sleep(self.handle)
+            LIBRARY.dtrace_work(self.handle, None, chew, chew_rec, None)
+
+            time.sleep(1)
+            i += 1
+
+        LIBRARY.dtrace_stop(self.handle)
+
+        # sorting instead of dtrace_aggregate_walk
+        walk_func = WALK_FUNC(walk)
+        if LIBRARY.dtrace_aggregate_walk_valsorted(self.handle, walk_func,
+                                                   None) != 0:
+            raise Exception('Failed to walk the aggregate: ',
+                            self._get_error_msg())
+
+    def _get_error_msg(self):
+        txt = LIBRARY.dtrace_errmsg(self.handle,
+                                    LIBRARY.dtrace_errno(self.handle))
+        return c_char_p(txt).value
diff --git a/dtrace/consumer.pyc b/dtrace/consumer.pyc
diff --git a/dtrace/dtrace_structs.py b/dtrace/dtrace_structs.py
@@ -0,0 +1,79 @@
+'''
+The DTrace data structures.
+
+Created on Oct 10, 2011
+
+@author: tmetsch
+'''
+
+# disabling 'too few public meth' pylint check
+# pylint: disable=R0903
+
+from ctypes import Structure, c_int, c_void_p, c_char_p, c_char, c_uint
+
+
+class dtrace_aggdesc(Structure):
+    '''
+    TODO - use offset
+    '''
+    _fields_ = [("dtagd_flags", c_int)]
+
+
+class dtrace_aggdata(Structure):
+    '''
+    As defined in dtrace.h:351
+    '''
+    _fields_ = [("dtada_handle", c_void_p),
+                ("dtada_desc", dtrace_aggdesc),
+                ("dtada_edesc", c_void_p),
+                ("dtada_pdesc", c_void_p),
+                ("dtada_data", c_void_p),
+                ("dtada_normal", c_void_p),
+                ("dtada_size", c_int),
+                ("dtada_delta", c_void_p),
+                ("dtada_percpu", c_void_p),
+                ("dtada_percpu_delta", c_void_p)]
+
+
+class dtrace_bufdata(Structure):
+    '''
+    As defined in dtrace.h:310
+    '''
+    _fields_ = [("dtbda_handle", c_void_p),
+                ("dtbda_buffered", c_char_p), # works
+                ("dtbda_probe", c_void_p),
+                ("dtbda_recdesc", c_void_p),
+                ("dtbda_aggdata", c_void_p),
+                ("dtbda_flags", c_uint)]
+
+
+class dtrace_probedesc(Structure):
+    '''
+    As defined in sys/dtrace.h:884
+    '''
+    _fields_ = [("dtrace_id_t", c_uint),
+                ("dtpd_provider", c_char),
+                ("dtpd_mod", c_char),
+                ("dtpd_func", c_char_p),
+                ("dtpd_name", c_char_p)]
+
+
+class dtrace_probedata(Structure):
+    '''
+    As defined in dtrace.h:186
+    '''
+    _fields_ = [("dtpda_handle", c_void_p),
+               ("dtpda_edesc", c_void_p),
+               ("dtpda_pdesc", dtrace_probedesc),
+               ("dtpda_cpu", c_int), # works
+               ("dtpda_data", c_void_p),
+               ("dtpda_flow", c_void_p),
+               ("dtpda_prefix", c_void_p),
+               ("dtpda_indent", c_int)]
+
+
+class dtrace_recdesc(Structure):
+    '''
+    As defined in sys/dtrace.h:931
+    '''
+    pass
diff --git a/dtrace/dtrace_structs.pyc b/dtrace/dtrace_structs.pyc
diff --git a/examples/hello_world.py b/examples/hello_world.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+'''
+Use the Python DTrace consumer and run a Hello World DTrace script.
+
+Created on Oct 10, 2011
+
+@author: tmetsch
+'''
+
+from dtrace.consumer import DTraceConsumer
+
+script = 'dtrace:::BEGIN {trace("Hello World");}'
+
+def main():
+    consumer = DTraceConsumer()
+    consumer.run_script(script)
+
+if __name__ == '__main__':
+    main()
diff --git a/examples/syscall_count.py b/examples/syscall_count.py
@@ -0,0 +1,20 @@
+#!/usr/bin/env python
+
+'''
+Use the Python DTrace consumer and run a syscall counter DTrace script.
+
+Created on Oct 10, 2011
+
+@author: tmetsch
+'''
+
+from dtrace.consumer import DTraceConsumer
+
+script = 'syscall:::entry { @num[execname] = count(); }'
+
+def main():
+    consumer = DTraceConsumer()
+    consumer.run_script(script, 4)
+
+if __name__ == '__main__':
+    main()
diff --git a/setup.py b/setup.py

Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,4 @@`
	`1`	`+MANIFEST`
`1`	`2`	`.make.state.Debug`
`2`	`3`	`.dep.inc`
`3`	`4`	`Makefile`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+Copyright (C) 2011 by Thijs Metsch`
	`2`	`+`
	`3`	`+LICENSE TBD`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+include setup.py`
	`2`	`+include LICENSE`
	`3`	`+recursive-include examples/ *.py`