ruby-static-tracing 0.0.2 → 0.0.3

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

@@ -0,0 +1,46 @@
+#ifndef _SHARED_LIB_H
+#define _SHARED_LIB_H
+
+#include "section.h"
+#include "string-table.h"
+#include "sdtnote.h"
+#include "dynamic-symbols.h"
+
+typedef struct {
+  Section
+    *hash,
+    *dynSym,
+    *dynStr,
+    *text,
+    *sdtBase,
+    *ehFrame,
+    *dynamic,
+    *sdtNote,
+    *shStrTab;
+} SectionsList;
+
+typedef struct {
+  Elf *elf;
+  Elf64_Ehdr *ehdr;
+  Elf64_Phdr *phdrLoad1, *phdrLoad2, *phdrDyn, *phdrStack;
+
+  StringTable *stringTable;
+  StringTable *dynamicString;
+
+  DynamicSymbolTable *dynamicSymbols;
+
+  SDTNoteList_t *sdtNotes;
+  size_t sdtNotesCount;
+
+  SectionsList sections;
+} DynElf;
+
+DynElf *dynElfInit();
+
+int dynElfAddProbe(DynElf *dynElf, SDTProbe_t *probe);
+
+int dynElfSave(DynElf *dynElf);
+
+void dynElfClose(DynElf *dynElf);
+
+#endif

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

@@ -0,0 +1,67 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "string-table.h"
+
+StringTable *stringTableInit() {
+  StringTable *stringTable = (StringTable *)calloc(sizeof(StringTable), 1);
+  stringTable->count = 1;
+  stringTable->size = 1;
+
+  stringTable->first = (StringTableNode *)calloc(sizeof(StringTableNode), 1);
+
+  stringTable->first->index = 0;
+  stringTable->first->size = 1;
+  stringTable->first->str = (char *)calloc(sizeof(char), 1);
+  stringTable->first->str[0] = '\0';
+  stringTable->first->next = NULL;
+
+  return stringTable;
+}
+
+StringTableNode *stringTableAdd(StringTable *stringTable, char *str) {
+  StringTableNode *current;
+
+  for (current = stringTable->first; current->next != NULL;
+       current = current->next) {
+  }
+
+  current->next = (StringTableNode *)calloc(sizeof(StringTableNode), 1);
+  current->next->index = current->index + current->size;
+
+  current = current->next;
+  current->size = strlen(str) + 1;
+
+  current->str = (char *)calloc(current->size, 1);
+  memcpy(current->str, str, current->size);
+  current->next = NULL;
+
+  stringTable->count += 1;
+  stringTable->size += current->size;
+
+  return current;
+}
+
+char *stringTableToBuffer(StringTable *stringTable) {
+  int offset;
+  StringTableNode *current;
+  char *buffer = (char *)calloc(stringTable->size, 1);
+
+  for (current = stringTable->first, offset = 0; current != NULL;
+       offset += current->size, current = current->next) {
+    memcpy(&buffer[offset], current->str, current->size);
+  }
+
+  return buffer;
+}
+
+void stringTableFree(StringTable *table) {
+  StringTableNode *node=NULL, *next=NULL;
+  for(node=table->first; node!=NULL; node=next) {
+    free(node->str);
+
+    next=node->next;
+    free(node);
+  }
+  free(table);
+}

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

@@ -0,0 +1,28 @@
+#ifndef _STRING_TABLE_H
+#define _STRING_TABLE_H
+
+#include <stdlib.h>
+#include <string.h>
+
+typedef struct StringTableNode_ {
+  int index;
+  int size;
+  char *str;
+  struct StringTableNode_ *next;
+} StringTableNode;
+
+typedef struct {
+  int count;
+  size_t size;
+  StringTableNode *first;
+} StringTable;
+
+StringTable *stringTableInit();
+
+StringTableNode *stringTableAdd(StringTable *stringTable, char *str);
+
+char *stringTableToBuffer(StringTable *stringTable);
+
+void stringTableFree(StringTable *stringTable);
+
+#endif

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

@@ -0,0 +1,12 @@
+int roundUp(int numToRound, int multiple) {
+  if (multiple == 0) {
+    return numToRound;
+}
+
+  int remainder = numToRound % multiple;
+  if (remainder == 0) {
+    return numToRound;
+}
+
+  return numToRound + multiple - remainder;
+}

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

@@ -0,0 +1,6 @@
+#ifndef _UTIL_H
+#define _UTIL_H
+
+int roundUp(int numToRound, int multiple);
+
+#endif

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

@@ -0,0 +1,77 @@
+#include "libstapsdt.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <dlfcn.h>
+
+int testElfCreationError() {
+  // TODO (mmarchini) write test case for elf creation error
+  return 1;
+}
+
+int testTmpCreationError() {
+  SDTProvider_t *provider;
+  SDTError_t errno;
+  provider = providerInit("test/probe/creation/error");
+  if(providerLoad(provider) == 0) {
+    return 0;
+  }
+  printf("[testTmpCreationError] Error message: %s\n", provider->error);
+  errno = provider->errno;
+  providerDestroy(provider);
+  return errno == tmpCreationError;
+}
+
+int testSharedLibraryOpenError() {
+  // TODO (mmarchini) write test case for shared library loading error
+  return 1;
+}
+
+int testSymbolLoadingError() {
+  // TODO (mmarchini) write test case for symbol loading error
+  return 1;
+}
+
+int testSharedLibraryCloseError() {
+  SDTProvider_t *provider;
+  SDTError_t errno;
+  provider = providerInit("test-error");
+  providerLoad(provider);
+  dlclose(provider->_handle);
+  if(providerUnload(provider) == 0) {
+    return 0;
+  }
+  errno = provider->errno;
+  printf("[testSharedLibraryCloseError] Error message: %s\n", provider->error);
+  providerDestroy(provider);
+  return errno == sharedLibraryCloseError;
+}
+
+int main() {
+  if (!testElfCreationError()) {
+    printf("Test case failed: testElfCreationError\n");
+    return -1;
+  }
+
+  if (!testTmpCreationError()) {
+    printf("Test case failed: testTmpCreationError\n");
+    return -2;
+  }
+
+  if (!testSharedLibraryOpenError()) {
+    printf("Test case failed: testSharedLibraryOpenError\n");
+    return -3;
+  }
+
+  if (!testSymbolLoadingError()) {
+    printf("Test case failed: testSymbolLoadingError\n");
+    return -4;
+  }
+
+  if (!testSharedLibraryCloseError()) {
+    printf("Test case failed: testSharedLibraryCloseError\n");
+    return -5;
+  }
+
+
+  return 0;
+}

data/ext/ruby-static-tracing/lib/libstapsdt/tests/test-memory-leaks.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <libstapsdt.h>
+
+int main( int argc, char *argv[] ) {
+  SDTProvider_t *provider;
+  SDTProbe_t *probe1, *probe2;
+
+  provider = providerInit("testProvider");
+  probe1 = providerAddProbe(provider, "testProbe1", 4, int8, uint8, int64, uint64);
+  probe2 = providerAddProbe(provider, "testProbe2", 2, int8, uint8);
+
+  if(providerLoad(provider) == -1) {
+    printf("Something went wrong...\n");
+    return -1;
+  }
+
+  probeFire(probe1, 1, 2, 3, 4);
+  probeFire(probe2, -3, 8);
+
+  providerUnload(provider);
+  providerDestroy(provider);
+
+  return 0;
+}

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

@@ -0,0 +1,37 @@
+$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__)
+
+# Linux is a noop
+if StaticTracing::Platform.linux?
+  File.write "Makefile", <<MAKEFILE
+all:
+	touch post.so
+clean:
+install:
+MAKEFILE
+  exit
+# We'll build libusdt and install and update linker info
+elsif StaticTracing::Platform.darwin?
+  # This is done to ensure that the bundle will look in its local directory for the library
+  File.write "Makefile", <<MAKEFILE
+all:
+	touch post.bundle
+	install_name_tool -change libusdt.dylib @loader_path/../ruby-static-tracing/libusdt.dylib #{File.join(LIB_DIR, 'ruby_static_tracing.bundle')}
+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/linux/provider.c

@@ -19,7 +19,7 @@ provider_initialize(VALUE self, VALUE name)
   // Check and cast arguments
   c_name_str = check_name_arg(name);
 
-  // Build semian resource structure
+  // Build provider structure
   TypedData_Get_Struct(self, static_tracing_provider_t, &static_tracing_provider_type, res);
   res->sdt_provider = providerInit(c_name_str);
   return self;

data/ext/ruby-static-tracing/linux/provider.h

@@ -1,16 +1,11 @@
-/*
-For core static tracing functions exposed directly to ruby.
-Functions here are associated with rubyland operations.
-*/
 #ifndef STATIC_TRACING_PROVIDER_H
 #define STATIC_TRACING_PROVIDER_H
 
-#include <ruby.h>
 // Include libstapsdt.h to wrap
-#include <libstapsdt.h>
+#include <libstapsdt.h> // FIXME use local
 
+#include "types.h"
 #include "ruby_static_tracing.h"
-#include "tracepoint.h"
 
 typedef struct {
   char *name;

data/ext/ruby-static-tracing/linux/ruby_static_tracing.c

@@ -1,5 +1,6 @@
-#include "provider.h"
-#include "tracepoint.h"
+#include "ruby_static_tracing.h"
+
+VALUE eUSDT, eInternal;
 
 void Init_ruby_static_tracing()
 {
@@ -41,7 +42,7 @@ void Init_ruby_static_tracing()
 
   rb_define_alloc_func(cTracepoint, static_tracing_tracepoint_alloc);
   rb_define_method(cTracepoint, "tracepoint_initialize", tracepoint_initialize, 3);
-  rb_define_method(cTracepoint, "fire_tracepoint", tracepoint_fire, 1);
+  rb_define_method(cTracepoint, "_fire_tracepoint", tracepoint_fire, 1);
   rb_define_method(cTracepoint, "enabled?", tracepoint_enabled, 0);
 }
 

data/ext/ruby-static-tracing/linux/tracepoint.c

@@ -1,5 +1,4 @@
 #include "tracepoint.h"
-#include "provider.h"
 
 static const rb_data_type_t
 static_tracing_tracepoint_type;

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

@@ -1,16 +1,12 @@
-/*
-For core static tracing functions exposed directly to ruby.
-Functions here are associated with rubyland operations.
-*/
 #ifndef STATIC_TRACING_TRACEPOINT_H
 #define STATIC_TRACING_TRACEPOINT_H
 
 #include <ruby.h>
 // Include libstapsdt.h to wrap
 #include <libstapsdt.h>
-// Probably need to include provider.h to be able to initialize self
 
 #include "ruby_static_tracing.h"
+#include "types.h"
 
 typedef union {
   unsigned long long intval;

data/ext/ruby-static-tracing/linux/types.h

@@ -0,0 +1,11 @@
+#ifndef STATIC_TRACING_TYPES_H
+#define STATIC_TRACING_TYPES_H
+
+#include <libstapsdt.h>
+
+typedef enum TRACEPOINT_ARG_TYPES_ENUM {
+  Integer = int64,  // STAP enum type -8
+  String  = uint64, // STAP enum type 8
+} Tracepoint_arg_types;
+
+#endif // STATIC_TRACING_TYPEs_H

data/lib/ruby-static-tracing.rb

@@ -6,6 +6,7 @@ require 'ruby-static-tracing/version'
 require 'ruby-static-tracing/platform'
 require 'ruby-static-tracing/provider'
 require 'ruby-static-tracing/tracepoint'
+require 'ruby-static-tracing/tracepoints'
 require 'ruby-static-tracing/configuration'
 require 'ruby-static-tracing/tracers'
 
@@ -45,12 +46,15 @@ module StaticTracing
   # with a wrapped version that has tracing enabled
   def enable!
     tracers.each(&:enable!)
+    StaticTracing::Provider.enable!
     @enabled = true
   end
 
   # Overwrite the definition of all functions to their original definition,
   # no longer wrapping them
   def disable!
+    tracers.each(&:disable!)
+    StaticTracing::Provider.disable!
     @enabled = false
   end
 
@@ -72,10 +76,4 @@ module StaticTracing
   end
 end
 
-# FIXME add signal handlers to enable-disable on specific process signals
-# within a trap handler.
-# Specify default signals, but allow these to be overidden for easier integration
-
-# This loads the actual C extension, we might want to guard it
-# for cases where the extension isn't yet built
-require 'ruby-static-tracing/ruby_static_tracing' if StaticTracing::Platform.linux?
+require 'ruby-static-tracing/ruby_static_tracing' if StaticTracing::Platform.linux? || StaticTracing::Platform.darwin?

data/lib/ruby-static-tracing/platform.rb

@@ -3,9 +3,57 @@
 module StaticTracing
   module Platform
     extend self
+    UNSUPPORTED_POST_INSTALL_MESSAGE = %(
+    WARNING: You have installed this on an unsupported platform, somehow.
+
+    You should verify for yourself that the behavior on your platform is safe.
+    )
+
+    LINUX_POST_INSTALL_MESSAGE = %(
+    WARNING: you will need a new kernel (4.14+) that supports eBPF.
+
+    You should use the newest possible version of bpftrace
+    ).freeze
+
+    DARWIN_POST_INSTALL_MESSAGE = %(
+    WARNING: tracing with dtrace will not work with SIP enabled.
+
+    SIP is enabled by default on recent versions of OSX. You can
+    check if SIP is enabled with:
+
+        csrutil status
+
+    If you want to test your probes out locally, you will need to at
+    least allow dtrace. To do this, you must reboot into recovery mode
+    by holding CMD + R while your Mac is booting. Once it has booted,
+    open a terminal and type:
+
+        csrutil clear
+        csrutil enable --without-dtrace
+
+    After this, you should be able to use dtrace on the tracepoints you
+    define here. If it still doesn't work, you can disable SIP entirely
+    but this is not recommended for security purposes.
+    ).freeze
 
     def linux?
       /linux/.match(RUBY_PLATFORM)
     end
+
+    def darwin?
+      /darwin/.match(RUBY_PLATFORM)
+    end
+
+    def post_install_message
+      message = begin
+        if linux?
+          LINUX_POST_INSTALL_MESSAGE
+        elsif darwin?
+          DARWIN_POST_INSTALL_MESSAGE
+        else
+          UNSUPPORTED_POST_INSTALL_MESSAGE
+        end
+      end
+    end
   end
 end