ruby-static-tracing 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 72b529791f8107bbe464af7deb35b4135fafe439307e88ff6deb019ec056d266
-  data.tar.gz: e71c574619cbce9237b959949b7eac088facbccbd52a8e1d478f4c4fc45e2470
+  metadata.gz: 0c9f06dac9e5b53283124140623a3677c85d32730f390716d7b2385fb20fbed4
+  data.tar.gz: daa93d708d1e42075fa5cb3043d2aabefac3bd9fd42161defd8481a0fb7d60fa
 SHA512:
-  metadata.gz: 3c13797239eeb12eab9529a9bcf854c42c633ea1cb1b918413b2cea1ae1a94d96890739ed573495d585c5949d0a6ad0c6c50469423567239f583545a1f0b57b4
-  data.tar.gz: a7e0db40c3b13c34344430af47dfc1a18929f36c95aa586436175d4243b9ae4c84664fdb0b8d95eb7dcb10142dccef506a408ee43e174ada8a0298ed21cf129d
+  metadata.gz: b742bc905d5ff7b8bad1b5d5fd1561b349ab2480c242402e93983f9b7fd6c0f5a1ff97055fb35be15ce80bad3db3f9d4b50596d04474f5f54aa7b52401932b2b
+  data.tar.gz: d4f394274ac8a1d763913ed4ec57fd20f321f9dbe153b8eb87c321a3d6e2204c14a184e5952e8a66b0f45a9588c49fe33f4a4ee3d9183463d42431c4f6e1c0e4

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

@@ -12,7 +12,7 @@ if StaticTracing::Platform.linux?
   # and "trick" extconf into thinking it's just another .so
   File.write "Makefile", <<MAKEFILE
 all:
-	cd #{File.join(BASE_DIR, 'libstapsdt')} && make
+	cd #{File.join(BASE_DIR, 'libstapsdt')} && make CFLAGS_EXTRA=-DLIBSTAPSDT_MEMORY_BACKED_FD
 	touch deps.so # HACK
 	cp #{File.join(BASE_DIR, 'libstapsdt', 'out/libstapsdt.so.0')} #{LIB_DIR}
 	cd #{LIB_DIR} && ln -sf libstapsdt.so.0 libstapsdt.so

data/ext/ruby-static-tracing/lib/libstapsdt/Makefile

@@ -0,0 +1,76 @@
+
+CC=gcc
+CFLAGS= -std=gnu11 $(CFLAGS_EXTRA)
+LDFLAGS=-lelf -ldl -Wl,-z,noexecstack
+VERSION=0.1.0
+
+PREFIX=/usr
+
+OBJECTS = $(patsubst src/%.c, build/lib/%.o, $(wildcard src/*.c))
+HEADERS = $(wildcard src/*.h)
+
+SOLINK = libstapsdt.so
+SONAME = libstapsdt.so.0
+
+all: out/libstapsdt.a out/$(SONAME)
+
+install:
+	mkdir -p $(DESTDIR)$(PREFIX)/lib
+	mkdir -p $(DESTDIR)$(PREFIX)/include
+	cp out/$(SONAME) $(DESTDIR)$(PREFIX)/lib/$(SONAME)
+	cp src/libstapsdt.h $(DESTDIR)$(PREFIX)/include/
+	ln -s $(DESTDIR)$(PREFIX)/lib/$(SONAME) $(DESTDIR)$(PREFIX)/lib/$(SOLINK)
+
+uninstall:
+	rm -f $(DESTDIR)$(PREFIX)/lib/$(SONAME)
+	rm -f $(DESTDIR)$(PREFIX)/lib/$(SOLINK)
+	rm -f $(DESTDIR)$(PREFIX)/include/libstapsdt.h
+
+build/lib/libstapsdt-x86_64.o: src/asm/libstapsdt-x86_64.s
+	mkdir -p build
+	$(CC) $(CFLAGS) -fPIC -c $^ -o $@
+
+build/lib/%.o: src/%.c $(HEADERS)
+	mkdir -p build/lib/
+	$(CC) $(CFLAGS) -fPIC -c $< -o $@
+
+out/libstapsdt.a: $(OBJECTS) build/lib/libstapsdt-x86_64.o
+	mkdir -p out
+	ar rcs $@ $^
+
+out/$(SONAME): $(OBJECTS) build/lib/libstapsdt-x86_64.o
+	mkdir -p out
+	$(CC) $(CFLAGS) -shared -Wl,-soname=$(SONAME) -o $@ $^ $(LDFLAGS)
+
+demo: all example/demo.c
+	$(CC) $(CFLAGS) example/demo.c out/libstapsdt.a -o demo -Isrc/ $(LDFLAGS)
+
+test: all
+	make -C ./tests/
+
+clean:
+	rm -rf build/*
+	rm -rf out/*
+	make clean -C ./tests/
+
+lint:
+	clang-tidy src/*.h src/*.c -- -Isrc/
+
+format:
+	clang-tidy src/*.h src/*.c -fix -- -Isrc/
+
+docs:
+	make -C ./docs/ html
+
+docs-server:
+	cd docs/_build/html; python3 -m http.server;
+
+deb-pkg-setup:
+	mkdir -p dist/libstapsdt-$(VERSION)/;
+	git archive HEAD | gzip > dist/libstapsdt-$(VERSION).tar.gz;
+	tar xvzf dist/libstapsdt-$(VERSION).tar.gz -C dist/libstapsdt-$(VERSION)/;
+	cd dist/libstapsdt-$(VERSION); dh_make -l -c mit -y -f ../libstapsdt-$(VERSION).tar.gz;
+	rm -rf dist/libstapsdt-$(VERSION)/debian/*.ex  dist/libstapsdt-$(VERSION)/debian/*.EX  dist/libstapsdt-$(VERSION)/debian/README.*
+
+
+.PHONY: all clear lint format build-tests docs install uninstall deb-pkg-setup

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/asm/libstapsdt-x86_64.s

@@ -0,0 +1,14 @@
+.text
+
+.align 4, 0x90
+.globl _funcStart
+.globl _funcEnd
+
+_funcStart:
+  nop
+  nop
+  nop
+  nop
+  ret
+_funcEnd:
+  nop

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",
+  "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,258 @@
+#include <dlfcn.h>
+#include <err.h>
+#include <fcntl.h>
+#include <libelf.h>
+#include <limits.h>
+#include <stdarg.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"
+
+#ifdef LIBSTAPSDT_MEMORY_BACKED_FD
+#include <linux/memfd.h>
+#include <sys/mman.h>
+#include <sys/syscall.h>
+
+#define F_SEAL_SEAL 0x0001 /* prevent further seals from being set */
+
+// Note that linux must be 3.17 or greater to support this
+static inline int memfd_create(const char *name, unsigned int flags) {
+  return syscall(__NR_memfd_create, name, flags);
+}
+#endif
+
+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->_memfd = -1;
+
+  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);
+}
+
+static char *tempElfPath(int *fd, const char *name) {
+  char *filename = NULL;
+
+#ifdef LIBSTAPSDT_MEMORY_BACKED_FD
+  char path_buffer[PATH_MAX + 1];
+  snprintf(path_buffer, (PATH_MAX + 1), "libstapsdt:%s", name);
+
+  *fd = memfd_create(path_buffer, F_SEAL_SEAL);
+  if (*fd < 0)
+    return NULL;
+  snprintf(path_buffer, (PATH_MAX + 1), "/proc/%d/fd/%d", getpid(), *fd);
+
+  filename = calloc(sizeof(char), (strlen(path_buffer) + 1));
+  strcpy(filename, path_buffer);
+#else
+  filename = calloc(sizeof(char), strlen("/tmp/-XXXXXX.so") + strlen(name) + 1);
+
+  sprintf(filename, "/tmp/%s-XXXXXX.so", name);
+
+  if ((*fd = mkstemps(filename, 3)) < 0) {
+    free(filename);
+    return NULL;
+  }
+#endif
+  return filename;
+}
+
+int providerLoad(SDTProvider_t *provider) {
+  int fd;
+  void *fireProbe;
+  char *error;
+
+  provider->_filename = tempElfPath(&fd, provider->name);
+#ifdef LIBSTAPSDT_MEMORY_BACKED_FD
+  provider->_memfd = fd;
+#endif
+  if (provider->_filename == NULL) {
+    sdtSetError(provider, tmpCreationError);
+    return -1;
+  }
+
+  if(createSharedLibrary(fd, provider) != 0) {
+    (void)close(fd);
+    return -1;
+  }
+
+  if (provider->_memfd == -1)
+    (void)close(fd);
+
+  provider->_handle = dlopen(provider->_filename, RTLD_LAZY);
+  if (!provider->_handle) {
+    sdtSetError(provider, sharedLibraryOpenError, provider->_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, provider->_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;
+  }
+
+  if (provider->_memfd > 0) {
+    (void)close(provider->_memfd);
+    provider->_memfd = -1;
+  } else {
+    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);
+}