ruby-static-tracing 0.0.12 → 0.0.13

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/libusdt/Makefile

@@ -0,0 +1,168 @@
+CC = gcc
+CFLAGS = -O2 -Wall
+
+# MAC_BUILD - set this to "universal" to build a 2-way fat library 
+MAC_BUILD = universal
+
+ARCH=x86_64
+
+# 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), Linux)
+RANLIB=ranlib
+CFLAGS+=-D_GNU_SOURCE -fPIC
+endif
+
+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
+else
+CFLAGS += -m32
+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
+CFLAGS += -fPIC
+ifeq ($(ARCH), i386)
+CFLAGS += -m32
+endif
+ifeq ($(ARCH), amd64)
+ARCH = x86_64
+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)
+
+ifeq ($(UNAME), Darwin)
+all: libusdt.a libusdt.dylib
+else
+all: libusdt.a
+endif
+
+libusdt.dylib: $(objects)
+	$(CC) $(CFLAGS) -dynamiclib -o $@ $^
+
+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 libusdt.dylib
+	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/ruby-static-tracing/lib/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;
+}