ruby-usdt 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32ca9d27b82e9e04dc7c82c91841ba967dea40d8
-  data.tar.gz: 90ea9c2c69fbc5311ea9da9992d0f7339ee5d9c6
+  metadata.gz: 465f1aa47fc3e1464824f95cec1bfc9ffab8fd29
+  data.tar.gz: af101a5e965a3aa2f235b5fe7f95eff573e6d622
 SHA512:
-  metadata.gz: 27df55c3cafad792beaa5f0858a6abd624d6c57708f79efb41d4ab2fe422429ac928dc18f234b4fce44b2ced1086021990b2ea7d55fe0f4a750827aa56a02a70
-  data.tar.gz: a909999ff4e99cca642386a96388f2838edeb5c4765176280734e9aedca964c41eb22a8d66d4331ca979e0403e749144d35d81ad49e5057e6df8865d3a84b4b4
+  metadata.gz: 836df20d76b44ae9e03952af0016e08bd1fbfbb46ca72624e29a9f73120499c59785b700eb900a33f8d45aa625772f9f6bb376aa7858c5a896cea8e193ace051
+  data.tar.gz: 6844f06f4be41aa88d9b3901f3fd0b2cfe1e9ceb4e021d4edd240183512f8110239fe4d84a8dd620f89e33b4a7382bd88725824f4483e9858835422d5b669650

data/ext/libusdt/LICENCE

@@ -0,0 +1,21 @@
+Copyright 2012 Chris Andrews. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are
+permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice, this list of
+      conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright notice, this list
+      of conditions and the following disclaimer in the documentation and/or other materials
+      provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY CHRIS ANDREWS ``AS IS'' AND ANY EXPRESS OR IMPLIED
+WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CHRIS ANDREWS OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/ext/libusdt/Makefile

@@ -0,0 +1,148 @@
+CC = gcc
+CFLAGS = -O2
+
+# MAC_BUILD - set this to "universal" to build a 2-way fat library 
+MAC_BUILD = universal
+
+# if ARCH set, disable universal build on the mac
+ifdef ARCH
+MAC_BUILD =
+else
+ARCH = $(shell uname -m)
+endif
+
+UNAME = $(shell uname -s)
+
+ifeq ($(UNAME), SunOS)
+RANLIB=/bin/true
+PATH +=:/usr/perl5/5.10.0/bin:/usr/perl5/5.12/bin
+CFLAGS += -fPIC
+
+ifeq ($(ARCH), i86pc)
+ARCH = $(shell isainfo -k)
+ifeq ($(ARCH), amd64)
+ARCH = x86_64
+else
+ARCH = i386
+endif
+endif 
+ifeq ($(ARCH), x86_64)
+CFLAGS += -m64
+endif
+endif
+
+ifeq ($(UNAME), FreeBSD)
+RANLIB=ranlib
+CFLAGS += -Wno-error=unknown-pragmas -I/usr/src/sys/cddl/compat/opensolaris -I/usr/src/sys/cddl/contrib/opensolaris/uts/common
+ifeq ($(ARCH), i386)
+CFLAGS += -m32
+endif
+endif
+
+ifeq ($(UNAME), Darwin)
+RANLIB=ranlib
+ifeq ($(MAC_BUILD), universal)
+CFLAGS += -arch i386 -arch x86_64
+else
+CFLAGS += -arch $(ARCH)
+endif
+endif
+
+# main library build
+objects = usdt.o usdt_dof_file.o usdt_tracepoints.o usdt_probe.o usdt_dof.o usdt_dof_sections.o
+headers = usdt.h usdt_internal.h
+
+.c.o: $(headers)
+
+all: libusdt.a
+
+libusdt.a: $(objects) $(headers)
+	rm -f libusdt.a
+	$(AR) cru libusdt.a $(objects) 
+	$(RANLIB) libusdt.a
+
+# Tracepoints build. 
+#
+# If on Darwin and building a universal library, manually assemble a
+# two-way fat object file from both the 32 and 64 bit tracepoint asm
+# files.
+#
+# Otherwise, just choose the appropriate asm file based on the build
+# architecture.
+
+ifeq ($(UNAME), Darwin)
+ifeq ($(MAC_BUILD), universal)
+
+usdt_tracepoints_i386.o: usdt_tracepoints_i386.s
+	$(CC) -arch i386 -o usdt_tracepoints_i386.o -c usdt_tracepoints_i386.s
+
+usdt_tracepoints_x86_64.o: usdt_tracepoints_x86_64.s
+	$(CC) -arch x86_64 -o usdt_tracepoints_x86_64.o -c usdt_tracepoints_x86_64.s
+
+usdt_tracepoints.o: usdt_tracepoints_i386.o usdt_tracepoints_x86_64.o
+	lipo -create -output usdt_tracepoints.o usdt_tracepoints_i386.o \
+	                                        usdt_tracepoints_x86_64.o
+
+else # Darwin, not universal
+usdt_tracepoints.o: usdt_tracepoints_$(ARCH).s
+	$(CC) -arch $(ARCH) -o usdt_tracepoints.o -c usdt_tracepoints_$(ARCH).s
+endif
+
+else # not Darwin; FreeBSD and Illumos
+
+ifeq ($(ARCH), x86_64)
+usdt_tracepoints.o: usdt_tracepoints_x86_64.s
+	$(CC) $(CFLAGS) -o usdt_tracepoints.o -c usdt_tracepoints_x86_64.s
+endif
+ifeq ($(ARCH), i386)
+usdt_tracepoints.o: usdt_tracepoints_i386.s
+	$(CC) $(CFLAGS) -o usdt_tracepoints.o -c usdt_tracepoints_i386.s
+endif
+
+endif
+
+clean:
+	rm -f *.gch
+	rm -f *.o
+	rm -f libusdt.a
+	rm -f test_usdt
+	rm -f test_usdt32
+	rm -f test_usdt64
+	rm -f test_mem_usage
+
+.PHONY: clean test
+
+# testing
+
+test_mem_usage: libusdt.a test_mem_usage.o
+	$(CC) $(CFLAGS) -o test_mem_usage test_mem_usage.o libusdt.a 
+
+ifeq ($(UNAME), Darwin)
+ifeq ($(MAC_BUILD), universal)
+test_usdt64: libusdt.a test_usdt.o
+	$(CC) -arch x86_64 -o test_usdt64 test_usdt.o libusdt.a
+test_usdt32: libusdt.a test_usdt.o
+	$(CC) -arch i386 -o test_usdt32 test_usdt.o libusdt.a
+else
+test_usdt: libusdt.a test_usdt.o
+	$(CC) $(CFLAGS) -o test_usdt test_usdt.o libusdt.a 
+endif
+else
+test_usdt: libusdt.a test_usdt.o
+	$(CC) $(CFLAGS) -o test_usdt test_usdt.o libusdt.a 
+endif
+
+ifeq ($(UNAME), Darwin)
+ifeq ($(MAC_BUILD), universal)
+test: test_usdt32 test_usdt64
+	sudo prove test.pl :: 64
+	sudo prove test.pl :: 32
+else
+test: test_usdt
+	sudo prove test.pl
+endif
+else
+test: test_usdt
+	sudo prove test.pl
+endif
+

data/ext/libusdt/README.md

@@ -0,0 +1,81 @@
+libusdt
+=======
+
+This is "libusdt", an extraction into a C library of the common parts
+of ruby-dtrace[1], perl-dtrace[2] and node-dtrace-provider[3].
+
+Those individual language-specific implementations will then become
+bindings to this library, rather than containing their own
+implementations of DOF generation and probe creation. Other dynamic
+language bindings could then easily follow.
+
+The idea here is to allow the specification of a DTrace provider
+dynamically in code and then create the provider at runtime. This
+allows providers to be specified in dynamic languages, given suitable
+bindings.
+
+The general approach is to create two stub functions for each probe,
+one for the is-enabled check and one for the probe itself. These
+contain the appropriate instruction sequences to appear to DTrace as
+compiled-in tracepoints. A minimal DOF document is built describing
+the provider and indicating these stub functions as the tracepoints,
+then submitted to the kernel, creating the provider. The API then
+exposes the stubs, through which the probes may be fired.
+
+Status
+------
+
+The implementation here works as shown in test_usdt.c on Mac OS X,
+i386 and x86_64, on Solaris-like systems, i386 and x86_64 and on
+FreeBSD, x86_64 only (so far).
+
+Is-enabled probes are supported and exposed in the API.
+
+There is a "test" target which runs a number of tests of the library,
+for which perl is required.
+
+OS X builds are Universal by default, and on Solaris, the ARCH
+variable may be set to either i386 or x86_64 to force a particular
+build.
+
+FreeBSD builds suffer from broken argument handling; this is a known
+issue with the current state of DTrace generally on FreeBSD: only the
+first four arguments work reliably. See:
+
+  http://wiki.freebsd.org/DTraceTODO
+
+See Also
+--------
+
+There are experimental Lua bindings available, which are a thin
+layer over this library, and should serve as an example of typical use
+as a dynamic language extension:
+
+  https://github.com/chrisa/lua-usdt
+
+There are also Ruby bindings by Kevin Chan, replacing the provider
+implementation in ruby-dtrace:
+
+  https://github.com/kevinykchan/ruby-usdt
+
+To Do
+-----
+
+Platform support:
+
+ * add support for FreeBSD 9.0 i386
+ * add support for Mac OS X PowerPC
+ * add support for Solaris SPARC
+
+Features:
+
+ * add a "low level" API, allowing alternative provision of
+   tracepoints for closer integration with language VMs. 
+
+ * support structured types, with close integration with the host
+   DTrace system.
+
+
+[1] https://github.com/chrisa/ruby-dtrace
+[2] https://github.com/chrisa/perl-dtrace
+[3] https://github.com/chrisa/node-dtrace-provider

data/ext/libusdt/test.pl

@@ -0,0 +1,112 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+use IPC::Open3;
+use Symbol 'gensym'; 
+use IO::Handle;
+use Test::More qw/ no_plan /;
+
+my $USDT_ARG_MAX = 32;
+
+my $arch;
+if (scalar @ARGV == 1) {
+    $arch = $ARGV[0];
+}
+
+my $user_t = ($^O eq 'solaris') ? 'uintptr_t' : 'user_addr_t';
+
+run_tests('c', 'A');
+run_tests('i', 1);
+
+sub run_tests {
+    my ($type, $start_arg) = @_;
+    
+    for my $i (0..$USDT_ARG_MAX) {
+        my ($t_status, $d_status, $output) = run_dtrace('func', 'name', split(//, $type x $i));
+        is($t_status, 0, 'test exit status is 0');
+        is($d_status, 0, 'dtrace exit status is 0');
+        like($output, qr/func:name/, 'function and name match');
+
+        my $arg = $start_arg;
+        for my $j (0..$i - 1) {
+            like($output, qr/arg$j:'\Q$arg\E'/, "type '$type' arg $j is $arg");
+            if ($type eq 'i') {
+                $arg++;
+            }
+            else {
+                $arg = chr(ord($arg) + 1);
+            }
+        }
+    }
+}
+
+# --------------------------------------------------------------------------
+
+sub gen_d {
+    my (@types) = @_;
+
+    my $d = 'testlibusdt*:::{ ';
+    my $i = 0;
+    for my $type (@types) {
+        if ($type eq 'i') {
+            $d .= "printf(\"arg$i:'%i' \", args[$i]); ";
+        }
+        if ($type eq 'c') {
+            $d .= "printf(\"arg$i:'%s' \", copyinstr(($user_t)args[$i])); ";
+        }
+        $i++;
+    }
+    $d .= '}';
+
+    return $d;
+}
+         
+sub run_dtrace {
+    my ($func, $name, @types) = @_;
+    my $d = gen_d(@types);
+
+    my @t_cmd;
+    if (defined $arch) {
+        @t_cmd = ("./test_usdt$arch", $func, $name, @types);
+    }
+    else {
+        @t_cmd = ("./test_usdt", $func, $name, @types);
+    }
+
+    my ($d_wtr, $d_rdr, $d_err);
+    my ($t_wtr, $t_rdr, $t_err);
+
+    $d_err = gensym;
+    $t_err = gensym;
+
+    #diag(join(' ', @t_cmd));
+    my $t_pid = open3($t_wtr, $t_rdr, $t_err, @t_cmd);
+    my $enabled = $t_rdr->getline;
+
+    my @d_cmd = ('/usr/sbin/dtrace', '-p', $t_pid, '-n', $d);
+
+    #diag(join(' ', @d_cmd));
+    my $d_pid = open3($d_wtr, $d_rdr, $d_err, @d_cmd);
+    my $matched = $d_err->getline; # expect "matched 1 probe"
+
+    $t_wtr->print("go\n");
+    $t_wtr->flush;
+    waitpid( $t_pid, 0 );
+    my $t_status = $? >> 8;
+
+    my ($header, $output) = ($d_rdr->getline, $d_rdr->getline);
+    chomp $header;
+    chomp $output;
+    #diag("DTrace header: $header\n");
+    #diag("DTrace output: $output\n");
+    waitpid( $d_pid, 0 );
+
+    my $d_status = $? >> 8;
+    while (!$d_err->eof) {
+        my $error = $d_err->getline;
+        chomp $error;
+        #diag "DTrace error: $error";
+    }
+
+    return ($t_status, $d_status, $output || '');
+}

data/ext/libusdt/test_mem_usage.c

@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2012, Chris Andrews. All rights reserved.
+ */
+
+#include "usdt.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static void
+create_and_free_provider(int argc, char **argv)
+{
+        usdt_provider_t *provider;
+        usdt_probedef_t *probedef;
+
+        if ((provider = usdt_create_provider("testlibusdt", "modname")) == NULL) {
+                fprintf(stderr, "unable to create provider\n");
+                exit (1);
+        }
+        if ((probedef = usdt_create_probe((const char *)argv[1],
+                                          (const char *)argv[2],
+                                          (argc-3), (const char **)&argv[3])) == NULL)
+        {
+                fprintf(stderr, "unable to create probe\n");
+                exit (1);
+        }
+        usdt_provider_add_probe(provider, probedef);
+
+        if ((usdt_provider_enable(provider)) < 0) {
+                fprintf(stderr, "unable to enable provider: %s\n", usdt_errstr(provider));
+                exit (1);
+        }
+
+        if ((usdt_provider_disable(provider)) < 0) {
+                fprintf(stderr, "unable to disable provider: %s\n", usdt_errstr(provider));
+                exit (1);
+        }
+
+        usdt_probe_release(probedef);
+        usdt_provider_free(provider);
+}
+
+int
+main(int argc, char **argv)
+{
+        char char_argv[USDT_ARG_MAX];
+        int int_argv[USDT_ARG_MAX * 2];
+        int i;
+        char buf[255];
+
+        for (i = 0; i < USDT_ARG_MAX; i++)
+                int_argv[i] = i + 1;
+        for (i = 0; i < USDT_ARG_MAX; i++)
+                char_argv[i] = (char) i + 65;
+
+        if (argc < 3) {
+                fprintf(stderr, "usage: %s func name [types ...]\n", argv[0]);
+                return(1);
+        }
+
+        for (i = 0; i < USDT_ARG_MAX; i++) {
+                if (argv[i+3] != NULL && i+3 < argc) {
+                        if (strncmp("c", argv[i+3], 1) == 0) {
+                                argv[i+3] = strdup("char *");
+                        }
+                        if (strncmp("i", argv[i+3], 1) == 0) {
+                                argv[i+3] = strdup("int");
+                        }
+                }
+        }
+
+        for (i = 0; i < 100000; i++)
+                create_and_free_provider(argc, argv);
+
+        return 0;
+}