ruby-static-tracing 0.0.2 → 0.0.3

data/ext/ruby-static-tracing/darwin/tracepoint.h

@@ -0,0 +1,52 @@
+#ifndef STATIC_TRACING_TRACEPOINT_H
+#define STATIC_TRACING_TRACEPOINT_H
+
+#include "usdt.h"
+
+#include "ruby_static_tracing.h"
+
+// FIXME move this to shared header
+typedef union {
+  unsigned long long intval;
+  char *             strval;
+} Tracepoint_fire_arg;
+
+typedef struct {
+  char *name;
+  usdt_probedef_t *usdt_tracepoint_def;
+  usdt_probe_t    *usdt_tracepoint;
+  //Tracepoint_arg_types *args;
+} static_tracing_tracepoint_t;
+
+/*
+ * call-seq:
+ *    StaticTracing::Tracepoint.new(provider, id, *vargs) -> tracepoint
+ *
+ * Creates a new tracepoint on a provider
+ */
+VALUE
+tracepoint_initialize(VALUE self, VALUE provider, VALUE id, VALUE vargs);
+
+/*
+ * call-seq:
+ *    tracepoint.fire(*vargs) -> true
+ *
+ * Fires data for the tracepoint to be probed
+ */
+VALUE
+tracepoint_fire(VALUE self, VALUE vargs);
+
+/*
+ * call-seq:
+ *    tracepoint.enabled? -> true
+ *
+ * Checks if the tracepoint is enabled, indicating it is being traced
+ */
+VALUE
+tracepoint_enabled(VALUE self);
+
+// Allocate a static_tracing_tracepoint_type struct for ruby memory management
+VALUE
+static_tracing_tracepoint_alloc(VALUE klass);
+
+#endif //STATIC_TRACING_TRACEPOINT_H

data/ext/ruby-static-tracing/extconf.rb

@@ -3,13 +3,31 @@ $LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
 require 'mkmf'
 require 'ruby-static-tracing/platform'
 
+BASE_DIR=File.expand_path(File.dirname(__FILE__)) 
+LIB_DIR  = File.expand_path('../../../lib/ruby-static-tracing', __FILE__)
+
+MKMF_TARGET='ruby-static-tracing/ruby_static_tracing'
+
 def platform_dir(platform)
   File.expand_path("../../../ext/ruby-static-tracing/#{platform}/", __FILE__)
 end
 
+def lib_dir
+  File.expand_path("../../../lib/ruby-static-tracing/", __FILE__)
+end
+#  - Linux, via libstapsdt
 if StaticTracing::Platform.linux?
   abort 'libstapsdt.h is missing, please install libstapsdt' unless find_header('libstapsdt.h')
 
+  LIB_DIRS = [LIB_DIR, RbConfig::CONFIG['libdir']]
+  HEADER_DIRS = [
+                 File.join(BASE_DIR, 'include'),
+                 File.join(BASE_DIR, 'lib', 'libstapsdt'),
+                 RbConfig::CONFIG['includedir']
+                ]
+
+  dir_config(MKMF_TARGET, HEADER_DIRS, LIB_DIRS)
+
   have_header 'libstapsdt.h'
 
   unless have_library('stapsdt')
@@ -23,12 +41,34 @@ if StaticTracing::Platform.linux?
     $CFLAGS << "-O3"
   end
 
-  create_makefile('ruby-static-tracing/ruby_static_tracing', platform_dir("linux"))
+  create_makefile(MKMF_TARGET, platform_dir("linux"))
+
+#  - Darwin/BSD and other dtrace platforms, via libusdt
+elsif StaticTracing::Platform.darwin?
+  abort 'dtrace is missing, this platform is not supported' unless have_library("dtrace", "dtrace_open")
+
+  LIB_DIRS = [LIB_DIR, RbConfig::CONFIG['libdir']]
+  puts LIB_DIRS.inspect
+  HEADER_DIRS = [
+                 File.join(BASE_DIR, 'include'),
+                 File.join(BASE_DIR, 'lib', 'libusdt'),
+                 RbConfig::CONFIG['includedir']
+                ]
+
+  dir_config(MKMF_TARGET, HEADER_DIRS, LIB_DIRS)
+
+  have_header('usdt.h')
+  abort "ERROR: libusdt is required. It is included, so this failure is an error." unless have_library('usdt')
+
+  $CFLAGS = "-D_GNU_SOURCE -Wall " # -Werror  complaining
+  if ENV.key?('DEBUG')
+    $CFLAGS << "-O0 -g -DDEBUG"
+  else
+    $CFLAGS << "-O3"
+  end
+
+  create_makefile(MKMF_TARGET, platform_dir('darwin'))
 else
-  # FIXME properly stub this.
-  # Should have 3 cases:
-  #  - Linux, via libstapsdt
-  #  - BSD and other dtrace platforms, via libusdt
   #  - Stub, for other platforms that support neither
   # for now, we will yolo stub this to leave room to handle platforms
   # that support properly support conventional dtrace

data/ext/ruby-static-tracing/{linux → include}/ruby_static_tracing.h

@@ -6,14 +6,11 @@ Implements Init_ruby_static_tracing, which is used as C/Ruby entrypoint.
 #ifndef RUBY_STATIC_TRACING_H
 #define RUBY_STATIC_TRACING_H
 
-typedef enum TRACEPOINT_ARG_TYPES_ENUM {
-  Integer = int64,  // STAP enum type -8
-  String  = uint64, // STAP enum type 8
-} Tracepoint_arg_types;
-
+#include "ruby.h"
 #include "provider.h"
+#include "tracepoint.h"
 
 void Init_ruby_static_tracing();
-VALUE eUSDT, eInternal;
+extern VALUE eUSDT, eInternal;
 
 #endif //RUBY_STATIC_TRACING_H

data/ext/ruby-static-tracing/lib/deps-extconf.rb

@@ -0,0 +1,47 @@
+$LOAD_PATH.unshift File.expand_path("../../../lib", __FILE__)
+
+require 'mkmf'
+require 'ruby-static-tracing/platform'
+
+BASE_DIR = File.expand_path(File.dirname(__FILE__))
+LIB_DIR  = File.expand_path('../../../../lib/ruby-static-tracing', __FILE__)
+
+# FIXME have this install libstapsdt
+if StaticTracing::Platform.linux?
+  # This is a bit of a hack to compile libstapsdt.so
+  # and "trick" extconf into thinking it's just another .so
+  File.write "Makefile", <<MAKEFILE
+all:
+	cd #{File.join(BASE_DIR, 'libstapsdt')} && make
+	touch deps.so # HACK
+	cp #{File.join(BASE_DIR, 'libstapsdt', 'out/libstapsdt.so.0')} #{LIB_DIR}
+clean:
+	cd #{File.join(BASE_DIR, 'libstapsdt')} && make clean
+install:
+MAKEFILE
+  exit
+# We'll build libusdt and install and update linker info
+elsif StaticTracing::Platform.darwin?
+  # This is a bit of a hack to compile libusdt.dylib
+  # and "trick" extconf into thinking it's just another .bundle
+  # After installing it (in post-extconf), we forcefully update the load path for
+  # ruby_static_tracing.bundle to find it in the same directory
+  File.write "Makefile", <<MAKEFILE
+all:
+	cd #{File.join(BASE_DIR, 'libusdt')} && make libusdt.dylib
+	touch deps.bundle # HACK
+	cp #{File.join(BASE_DIR, 'libusdt', 'libusdt.dylib')} #{LIB_DIR}
+clean:
+	cd #{File.join(BASE_DIR, 'libusdt')} && make clean
+install:
+MAKEFILE
+  exit
+else
+  #  - Stub, for other platforms that we don't support, we write an empty makefile
+  File.write "Makefile", <<MAKEFILE
+all:
+clean:
+install:
+MAKEFILE
+  exit
+end

data/ext/ruby-static-tracing/lib/libstapsdt/example/demo.c

@@ -0,0 +1,42 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <libstapsdt.h>
+
+int main( int argc, char *argv[] ) {
+  SDTProvider_t *provider;
+  SDTProbe_t **probes;
+  int probesCount = 0;
+  unsigned long long i=0;
+  int j=0;
+
+  if(argc < 3) {
+    printf("usage: demo PROVIDER PROBE\n");
+    return -1;
+  }
+
+  probesCount = argc - 2;
+  probes = calloc(sizeof(SDTProvider_t *), probesCount);
+
+  provider = providerInit(argv[1]);
+  for (int idx = 0; idx < (probesCount); idx++) {
+    probes[idx] = providerAddProbe(provider, argv[idx + 2], 2, uint64, int64);
+  }
+
+  if(providerLoad(provider) == -1) {
+    printf("Something went wrong: %s\n", provider->error);
+    return -1;
+  }
+
+  while(1) {
+    printf("Firing probes...\n");
+    for (int idx = 0; idx < probesCount; idx++) {
+      printf("Firing probe [%d]...\n", idx);
+      probeFire(probes[idx], i++, j--);
+    }
+    printf("Probe fired!\n");
+    sleep(3);
+  }
+
+  return 0;
+}

data/ext/ruby-static-tracing/lib/libstapsdt/src/dynamic-symbols.c

@@ -0,0 +1,41 @@
+#include "dynamic-symbols.h"
+#include "string-table.h"
+#include <libelf.h>
+
+DynamicSymbolTable *dynamicSymbolTableInit(StringTable *dynamicString) {
+  DynamicSymbolTable *dynSymTab =
+      (DynamicSymbolTable *)calloc(sizeof(DynamicSymbolTable), 1);
+
+  dynSymTab->stringTable = dynamicString;
+
+  dynSymTab->bssStart.string = stringTableAdd(dynamicString, "__bss_start");
+  dynSymTab->eData.string = stringTableAdd(dynamicString, "_edata");
+  dynSymTab->end.string = stringTableAdd(dynamicString, "_end");
+
+  dynSymTab->count = 0;
+  dynSymTab->symbols = NULL;
+
+  return dynSymTab;
+}
+
+DynamicSymbol *dynamicSymbolTableAdd(DynamicSymbolTable *table,
+                                     char *symbolName) {
+  DynamicSymbolList *symbol = (DynamicSymbolList *)calloc(sizeof(DynamicSymbolList), 1);
+
+  symbol->symbol.string = stringTableAdd(table->stringTable, symbolName);
+
+  symbol->next = table->symbols;
+  table->symbols = symbol;
+  table->count += 1;
+
+  return &(symbol->symbol);
+}
+
+void dynamicSymbolTableFree(DynamicSymbolTable *table) {
+  DynamicSymbolList *node=NULL, *next=NULL;
+  for(node=table->symbols; node!=NULL; node=next) {
+    next=node->next;
+    free(node);
+  }
+  free(table);
+}

data/ext/ruby-static-tracing/lib/libstapsdt/src/dynamic-symbols.h

@@ -0,0 +1,34 @@
+#ifndef _DYNAMIC_SYMBOLS_
+#define _DYNAMIC_SYMBOLS_
+
+#include "string-table.h"
+#include <libelf.h>
+
+typedef struct {
+  StringTableNode *string;
+  Elf64_Sym *symbol;
+} DynamicSymbol;
+
+typedef struct DynamicSymbolList_ {
+  DynamicSymbol symbol;
+  struct DynamicSymbolList_ *next;
+} DynamicSymbolList;
+
+typedef struct {
+  StringTable *stringTable;
+
+  DynamicSymbol bssStart;
+  DynamicSymbol eData;
+  DynamicSymbol end;
+
+  size_t count;
+  DynamicSymbolList *symbols;
+} DynamicSymbolTable;
+
+DynamicSymbolTable *dynamicSymbolTableInit(StringTable *dynamicString);
+DynamicSymbol *dynamicSymbolTableAdd(DynamicSymbolTable *table,
+                                     char *symbolName);
+
+void dynamicSymbolTableFree(DynamicSymbolTable *table);
+
+#endif

data/ext/ruby-static-tracing/lib/libstapsdt/src/errors.c

@@ -0,0 +1,30 @@
+
+#include <stdarg.h>
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "errors.h"
+
+const char *sdtErrors[] = {
+  "failed to create Elf shared library for provider '%s'",
+  "failed to create temporary file '%s'",
+  "failed to open shared library '%s': %s",
+  "failed to load symbol '%s' for shared library '%s': %s",
+  "failed to close shared library '%s' for provider '%s': %s",
+};
+
+void sdtSetError(SDTProvider_t *provider, SDTError_t error, ...) {
+  va_list argp;
+
+  if(provider->error != NULL) {
+    free(provider->error);
+    provider->error = NULL;
+    provider->errno = noError;
+  }
+
+  va_start(argp, error);
+  provider->errno = error;
+  (void)vasprintf(&provider->error, sdtErrors[error], argp);
+  va_end(argp);
+}

data/ext/ruby-static-tracing/lib/libstapsdt/src/errors.h

@@ -0,0 +1,8 @@
+#ifndef _ERRORS_H
+#define _ERRORS_H
+
+#include "libstapsdt.h"
+
+void sdtSetError(SDTProvider_t *provider, SDTError_t error, ...);
+
+#endif

data/ext/ruby-static-tracing/lib/libstapsdt/src/hash-table.c

@@ -0,0 +1,27 @@
+#include <stdio.h>
+#include "dynamic-symbols.h"
+
+size_t hashTableFromSymbolTable(DynamicSymbolTable *table, uint32_t **hashTable) {
+  DynamicSymbolList *current;
+  uint32_t nBuckets = table->count + 3,  // + 3, to count bss, end, and eData symbols
+           nChains = table->count + 3;
+  size_t hashTableSize = (nBuckets + nChains + 2);
+
+  uint32_t *hashTable_ = (uint32_t *)calloc(sizeof(uint32_t), hashTableSize);
+  uint32_t *buckets = &(hashTable_[2]);
+  uint32_t *chains = &(buckets[nBuckets]);
+  int idx, stringIdx=2;
+
+  hashTable_[0] = nBuckets;
+  hashTable_[1] = nChains;
+
+  for(current=table->symbols; current!=NULL; current=current->next) {
+    idx = elf_hash(current->symbol.string->str) % nBuckets;
+    chains[stringIdx] = buckets[idx];
+    buckets[idx] = stringIdx;
+    stringIdx++;
+  }
+
+  *hashTable = hashTable_;
+  return hashTableSize * sizeof(uint32_t);
+}

data/ext/ruby-static-tracing/lib/libstapsdt/src/hash-table.h

@@ -0,0 +1,3 @@
+#include "dynamic-symbols.h"
+
+size_t hashTableFromSymbolTable(DynamicSymbolTable *table, uint32_t **hashTable);

data/ext/ruby-static-tracing/lib/libstapsdt/src/libstapsdt.c

@@ -0,0 +1,208 @@
+#include <stdarg.h>
+#include <dlfcn.h>
+#include <err.h>
+#include <fcntl.h>
+#include <libelf.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include "dynamic-symbols.h"
+#include "sdtnote.h"
+#include "section.h"
+#include "string-table.h"
+#include "shared-lib.h"
+#include "util.h"
+#include "libstapsdt.h"
+#include "errors.h"
+
+int createSharedLibrary(int fd, SDTProvider_t *provider) {
+  DynElf *dynElf = dynElfInit(fd);
+
+  for(SDTProbeList_t *node=provider->probes; node != NULL; node = node->next) {
+    dynElfAddProbe(dynElf, &(node->probe));
+  }
+
+  if(dynElfSave(dynElf) == -1) {
+    sdtSetError(provider, elfCreationError, provider->name);
+    return -1;
+  }
+
+  dynElfClose(dynElf);
+
+  return 0;
+}
+
+SDTProvider_t *providerInit(const char *name) {
+  SDTProvider_t *provider = (SDTProvider_t *) calloc(sizeof(SDTProvider_t), 1);
+  provider->error     = NULL;
+  provider->errno     = noError;
+  provider->probes    = NULL;
+  provider->_handle   = NULL;
+  provider->_filename = NULL;
+
+  provider->name = (char *) calloc(sizeof(char), strlen(name) + 1);
+  memcpy(provider->name, name, sizeof(char) * strlen(name) + 1);
+
+  return provider;
+}
+
+SDTProbe_t *providerAddProbe(SDTProvider_t *provider, const char *name, int argCount, ...) {
+  int i;
+  va_list vl;
+  ArgType_t arg;
+  va_start(vl, argCount);
+
+  SDTProbeList_t *probeList = (SDTProbeList_t *) calloc(sizeof(SDTProbeList_t), 1);
+  probeList->probe._fire = NULL;
+
+  probeList->probe.name = (char *) calloc(sizeof(char), strlen(name) + 1);
+  memcpy(probeList->probe.name, name, sizeof(char) * strlen(name) + 1);
+
+  probeList->next = provider->probes;
+  provider->probes = probeList;
+
+  probeList->probe.argCount = argCount;
+
+  for(i=0; i < argCount; i++) {
+    arg = va_arg(vl, ArgType_t);
+    probeList->probe.argFmt[i] = arg;
+  }
+
+  for(; i<MAX_ARGUMENTS; i++) {
+    probeList->probe.argFmt[i] = noarg;
+  }
+
+  probeList->probe.provider = provider;
+
+  return &(probeList->probe);
+}
+
+int providerLoad(SDTProvider_t *provider) {
+  int fd;
+  void *fireProbe;
+  char *filename = calloc(sizeof(char), strlen("/tmp/-XXXXXX.so") + strlen(provider->name) + 1);
+  char *error;
+
+  sprintf(filename, "/tmp/%s-XXXXXX.so", provider->name);
+
+  if ((fd = mkstemps(filename, 3)) < 0) {
+    sdtSetError(provider, tmpCreationError, filename);
+    free(filename);
+    return -1;
+  }
+  provider->_filename = filename;
+
+  if(createSharedLibrary(fd, provider) != 0) {
+    (void)close(fd);
+    return -1;
+  }
+  (void)close(fd);
+
+  provider->_handle = dlopen(filename, RTLD_LAZY);
+  if (!provider->_handle) {
+    sdtSetError(provider, sharedLibraryOpenError, filename, dlerror());
+    return -1;
+  }
+
+  for(SDTProbeList_t *node=provider->probes; node != NULL; node = node->next) {
+    fireProbe = dlsym(provider->_handle, node->probe.name);
+
+    // TODO (mmarchini) handle errors better when a symbol fails to load
+    if ((error = dlerror()) != NULL) {
+      sdtSetError(provider, sharedLibraryOpenError, filename, node->probe.name, error);
+      return -1;
+    }
+
+    node->probe._fire = fireProbe;
+  }
+
+
+  return 0;
+}
+
+int providerUnload(SDTProvider_t *provider) {
+  if(provider->_handle == NULL) {
+    return 0;
+  }
+  if(dlclose(provider->_handle) != 0) {
+    sdtSetError(provider, sharedLibraryCloseError, provider->_filename, provider->name, dlerror());
+    return -1;
+  }
+  provider->_handle = NULL;
+
+  for(SDTProbeList_t *node=provider->probes; node != NULL; node = node->next) {
+    node->probe._fire = NULL;
+  }
+
+  unlink(provider->_filename);
+  free(provider->_filename);
+
+  return 0;
+}
+
+void probeFire(SDTProbe_t *probe, ...) {
+  if(probe->_fire == NULL) {
+    return;
+  }
+  va_list vl;
+  va_start(vl, probe);
+  uint64_t arg[6] = {0};
+  for(int i=0; i < probe->argCount; i++) {
+    arg[i] = va_arg(vl, uint64_t);
+  }
+
+  switch(probe->argCount) {
+    case 0:
+      ((void (*)())probe->_fire) ();
+      return;
+    case 1:
+      ((void (*)())probe->_fire) (arg[0]);
+      return;
+    case 2:
+      ((void (*)())probe->_fire) (arg[0], arg[1]);
+      return;
+    case 3:
+      ((void (*)())probe->_fire) (arg[0], arg[1], arg[2]);
+      return;
+    case 4:
+      ((void (*)())probe->_fire) (arg[0], arg[1], arg[2], arg[3]);
+      return;
+    case 5:
+      ((void (*)())probe->_fire) (arg[0], arg[1], arg[2], arg[3], arg[4]);
+      return;
+    case 6:
+      ((void (*)())probe->_fire) (arg[0], arg[1], arg[2], arg[3], arg[4], arg[5]);
+      return;
+    default:
+      ((void (*)())probe->_fire) ();
+      return;
+  }
+}
+
+int probeIsEnabled(SDTProbe_t *probe) {
+  if(probe->_fire == NULL) {
+    return 0;
+  }
+  if(((*(char *)probe->_fire) & 0x90) == 0x90) {
+    return 0;
+  }
+  return 1;
+}
+
+void providerDestroy(SDTProvider_t *provider) {
+  SDTProbeList_t *node=NULL, *next=NULL;
+
+  for(node=provider->probes; node!=NULL; node=next) {
+    free(node->probe.name);
+    next=node->next;
+    free(node);
+  }
+  free(provider->name);
+  if(provider->error != NULL) {
+    free(provider->error);
+  }
+  free(provider);
+}