ruby-usdt 0.1.1 → 0.1.2

data/ext/libusdt/Makefile

@@ -1,25 +1,54 @@
-UNAME=$(shell uname)
-ARCH=$(shell uname -m)
+CC = gcc
+CFLAGS = -O2
 
-MAC_BUILD=universal
-CFLAGS= -g -O0 -Wall -Werror
-CC=cc
+# 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)
-PATH +=:/usr/perl5/5.10.0/bin
-CFLAGS +=-fPIC
+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)
-CFLAGS += -Wno-error=unknown-pragmas  -I/usr/src/sys/cddl/compat/opensolaris -I/usr/src/sys/cddl/contrib/opensolaris/uts/common
+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
 
@@ -27,55 +56,66 @@ headers = usdt.h usdt_internal.h
 
 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)
-CFLAGS+= -arch i386 -arch x86_64
 
 usdt_tracepoints_i386.o: usdt_tracepoints_i386.s
-	as -arch i386 -o 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
-	as -arch x86_64 -o 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
-
-ifeq ($(ARCH), x86_64)
-usdt_tracepoints.o: usdt_tracepoints_x86_64.s
-	as -o usdt_tracepoints.o usdt_tracepoints_x86_64.s
-else
-usdt_tracepoints.o: usdt_tracepoints_i386.s
-	as -o usdt_tracepoints.o usdt_tracepoints_i386.s
-endif
 
-endif
+else # Darwin, not universal
+usdt_tracepoints.o: usdt_tracepoints_$(ARCH).s
+	$(CC) -arch $(ARCH) -o usdt_tracepoints.o -c usdt_tracepoints_$(ARCH).s
 endif
 
-ifeq ($(UNAME), FreeBSD)
-ifeq ($(ARCH), amd64)
-usdt_tracepoints.o: usdt_tracepoints_x86_64.s
-	as --64 -o usdt_tracepoints.o usdt_tracepoints_x86_64.s
-else
-usdt_tracepoints.o: usdt_tracepoints_i386.s
-	as --32 -o usdt_tracepoints.o usdt_tracepoints_i386.s
-endif
-endif
+else # not Darwin; FreeBSD and Illumos
 
-ifeq ($(UNAME), SunOS)
 ifeq ($(ARCH), x86_64)
 usdt_tracepoints.o: usdt_tracepoints_x86_64.s
-	as --64 -o usdt_tracepoints.o usdt_tracepoints_x86_64.s
-else
+	$(CC) $(CFLAGS) -o usdt_tracepoints.o -c usdt_tracepoints_x86_64.s
+endif
+ifeq ($(ARCH), i386)
 usdt_tracepoints.o: usdt_tracepoints_i386.s
-	as --32 -o usdt_tracepoints.o usdt_tracepoints_i386.s
+	$(CC) $(CFLAGS) -o usdt_tracepoints.o -c usdt_tracepoints_i386.s
 endif
+
 endif
 
-libusdt.a: $(objects) $(headers)
-	ar cru libusdt.a $(objects) 
-	ranlib libusdt.a
+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)
@@ -92,15 +132,6 @@ test_usdt: libusdt.a test_usdt.o
 	$(CC) $(CFLAGS) -o test_usdt test_usdt.o libusdt.a 
 endif
 
-clean:
-	rm -f *.gch
-	rm -f *.o
-	rm -f libusdt.a
-	rm -f fat_libusdt.a
-	rm -f test_usdt
-	rm -f test_usdt32
-	rm -f test_usdt64
-
 ifeq ($(UNAME), Darwin)
 ifeq ($(MAC_BUILD), universal)
 test: test_usdt32 test_usdt64
@@ -115,4 +146,3 @@ test: test_usdt
 	sudo prove test.pl
 endif
 
-.PHONY: clean test

data/ext/libusdt/test.pl

@@ -83,7 +83,7 @@ sub run_dtrace {
     my $t_pid = open3($t_wtr, $t_rdr, $t_err, @t_cmd);
     my $enabled = $t_rdr->getline;
 
-    my @d_cmd = ('dtrace', '-p', $t_pid, '-n', $d);
+    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);

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;
+}

data/ext/libusdt/test_usdt.c

@@ -11,9 +11,8 @@
 static void
 fire_probe(usdt_probedef_t *probedef, int argc, void **argv)
 {
-        if (usdt_is_enabled(probedef->probe)) {
+        if (usdt_is_enabled(probedef->probe))
                 usdt_fire_probe(probedef->probe, argc, argv);
-        }
 }
 
 int main(int argc, char **argv) {
@@ -21,7 +20,7 @@ int main(int argc, char **argv) {
         usdt_probedef_t *probedef;
         char char_argv[USDT_ARG_MAX];
         int int_argv[USDT_ARG_MAX * 2];
-        void **args;
+        void **args = NULL;
         int i;
         char buf[255];
 
@@ -75,6 +74,14 @@ int main(int argc, char **argv) {
         fgets(buf, 255, stdin);
 
         fire_probe(probedef, (argc-3), (void **)args);
+        usdt_probe_release(probedef);
+
+        if ((usdt_provider_disable(provider)) < 0) {
+                fprintf(stderr, "unable to disable provider: %s\n", usdt_errstr(provider));
+                exit (1);
+        }
+
+        usdt_provider_free(provider);
 
         return 0;
 }

data/ext/libusdt/usdt.c

@@ -15,9 +15,33 @@ char *usdt_errors[] = {
   "failed to allocate page-aligned memory",
   "no probes defined",
   "failed to load DOF: %s",
-  "provider is already enabled"
+  "provider is already enabled",
+  "failed to unload DOF: %s",
+  "probe named %s:%s:%s:%s already exists",
+  "failed to remove probe %s:%s:%s:%s"
 };
 
+static void
+free_probedef(usdt_probedef_t *pd)
+{
+        switch (pd->refcnt) {
+        case 1:
+                free((char *)pd->function);
+                free((char *)pd->name);
+                if (pd->probe) {
+                        free(pd->probe->isenabled_addr);
+                        free(pd->probe);
+                }
+                free(pd);
+                break;
+        case 2:
+                pd->refcnt = 1;
+                break;
+        default:
+                break;
+        }
+}
+
 usdt_provider_t *
 usdt_create_provider(const char *name, const char *module)
 {
@@ -46,6 +70,7 @@ usdt_create_probe(const char *func, const char *name, size_t argc, const char **
         if ((p = malloc(sizeof *p)) == NULL)
                 return (NULL);
 
+        p->refcnt = 2;
         p->function = strdup(func);
         p->name = strdup(name);
         p->argc = argc;
@@ -62,10 +87,28 @@ usdt_create_probe(const char *func, const char *name, size_t argc, const char **
 }
 
 void
+usdt_probe_release(usdt_probedef_t *probedef)
+{
+        free_probedef(probedef);
+}
+
+int
 usdt_provider_add_probe(usdt_provider_t *provider, usdt_probedef_t *probedef)
 {
         usdt_probedef_t *pd;
 
+        if (provider->probedefs != NULL) {
+                for (pd = provider->probedefs; (pd != NULL); pd = pd->next) {
+                if ((strcmp(pd->name, probedef->name) == 0) &&
+                    (strcmp(pd->function, probedef->function) == 0)) {
+                                usdt_error(provider, USDT_ERROR_DUP_PROBE,
+                                           provider->name, provider->module,
+                                           probedef->function, probedef->name);
+                                return (-1);
+                        }
+                }
+        }
+
         probedef->next = NULL;
         if (provider->probedefs == NULL)
                 provider->probedefs = probedef;
@@ -73,6 +116,39 @@ usdt_provider_add_probe(usdt_provider_t *provider, usdt_probedef_t *probedef)
                 for (pd = provider->probedefs; (pd->next != NULL); pd = pd->next) ;
                 pd->next = probedef;
         }
+
+        return (0);
+}
+
+int
+usdt_provider_remove_probe(usdt_provider_t *provider, usdt_probedef_t *probedef)
+{
+        usdt_probedef_t *pd, *prev_pd = NULL;
+
+        if (provider->probedefs == NULL) {
+                usdt_error(provider, USDT_ERROR_NOPROBES);
+                return (-1);
+        }
+
+        for (pd = provider->probedefs; (pd != NULL);
+             prev_pd = pd, pd = pd->next) {
+
+                if ((strcmp(pd->name, probedef->name) == 0) &&
+                    (strcmp(pd->function, probedef->function) == 0)) {
+
+                        if (prev_pd == NULL)
+                                provider->probedefs = pd->next;
+                        else
+                                prev_pd->next = pd->next;
+
+                        return (0);
+                }
+        }
+
+        usdt_error(provider, USDT_ERROR_REMOVE_PROBE,
+                   provider->name, provider->module,
+                   probedef->function, probedef->name);
+        return (-1);
 }
 
 int
@@ -87,7 +163,7 @@ usdt_provider_enable(usdt_provider_t *provider)
 
         if (provider->enabled == 1) {
                 usdt_error(provider, USDT_ERROR_ALREADYENABLED);
-                return (0); // not fatal
+                return (0); /* not fatal */
         }
 
         if (provider->probedefs == NULL) {
@@ -107,7 +183,7 @@ usdt_provider_enable(usdt_provider_t *provider)
                 return (-1);
         }
 
-        if ((usdt_strtab_add(&strtab, provider->name)) < 0) {
+        if ((usdt_strtab_add(&strtab, provider->name)) == 0) {
                 usdt_error(provider, USDT_ERROR_MALLOC);
                 return (-1);
         }
@@ -133,15 +209,54 @@ usdt_provider_enable(usdt_provider_t *provider)
 
         usdt_dof_file_generate(file, &strtab);
 
+        usdt_dof_section_free(&strtab);
+        for (i = 0; i < 5; i++)
+                usdt_dof_section_free(&sects[i]);
+
         if ((usdt_dof_file_load(file, provider->module)) < 0) {
                 usdt_error(provider, USDT_ERROR_LOADDOF, strerror(errno));
                 return (-1);
         }
 
         provider->enabled = 1;
+        provider->file = file;
+
+        return (0);
+}
+
+int
+usdt_provider_disable(usdt_provider_t *provider)
+{
+        if (provider->enabled == 0)
+                return (0);
+
+        if ((usdt_dof_file_unload((usdt_dof_file_t *)provider->file)) < 0) {
+                usdt_error(provider, USDT_ERROR_UNLOADDOF, strerror(errno));
+                return (-1);
+        }
+
+        usdt_dof_file_free(provider->file);
+        provider->file = NULL;
+        provider->enabled = 0;
+
         return (0);
 }
 
+void
+usdt_provider_free(usdt_provider_t *provider)
+{
+        usdt_probedef_t *pd, *next;
+
+        for (pd = provider->probedefs; pd != NULL; pd = next) {
+                next = pd->next;
+                free_probedef(pd);
+        }
+
+        free((char *)provider->name);
+        free((char *)provider->module);
+        free(provider);
+}
+
 int
 usdt_is_enabled(usdt_probe_t *probe)
 {

data/ext/libusdt/usdt.h

@@ -17,7 +17,10 @@ typedef enum usdt_error {
         USDT_ERROR_VALLOC,
         USDT_ERROR_NOPROBES,
         USDT_ERROR_LOADDOF,
-        USDT_ERROR_ALREADYENABLED
+        USDT_ERROR_ALREADYENABLED,
+        USDT_ERROR_UNLOADDOF,
+        USDT_ERROR_DUP_PROBE,
+        USDT_ERROR_REMOVE_PROBE
 } usdt_error_t;
 
 typedef struct usdt_probe {
@@ -35,10 +38,12 @@ typedef struct usdt_probedef {
         usdt_argtype_t types[USDT_ARG_MAX];
         struct usdt_probe *probe;
         struct usdt_probedef *next;
+        int refcnt;
 } usdt_probedef_t;
 
 usdt_probedef_t *usdt_create_probe(const char *func, const char *name,
                                    size_t argc, const char **types);
+void usdt_probe_release(usdt_probedef_t *probedef);
 
 typedef struct usdt_provider {
         const char *name;
@@ -46,11 +51,15 @@ typedef struct usdt_provider {
         usdt_probedef_t *probedefs;
         char *error;
         int enabled;
+        void *file;
 } usdt_provider_t;
 
 usdt_provider_t *usdt_create_provider(const char *name, const char *module);
-void usdt_provider_add_probe(usdt_provider_t *provider, usdt_probedef_t *probedef);
+int usdt_provider_add_probe(usdt_provider_t *provider, usdt_probedef_t *probedef);
+int usdt_provider_remove_probe(usdt_provider_t *provider, usdt_probedef_t *probedef);
 int usdt_provider_enable(usdt_provider_t *provider);
+int usdt_provider_disable(usdt_provider_t *provider);
+void usdt_provider_free(usdt_provider_t *provider);
 
 void usdt_error(usdt_provider_t *provider, usdt_error_t error, ...);
 char *usdt_errstr(usdt_provider_t *provider);

data/ext/libusdt/usdt_dof.c

@@ -79,6 +79,12 @@ usdt_dof_section_init(usdt_dof_section_t *section, uint32_t type, dof_secidx_t i
         return (0);
 }
 
+void
+usdt_dof_section_free(usdt_dof_section_t *section)
+{
+        free(section->data);
+}
+
 int
 usdt_strtab_init(usdt_strtab_t *strtab, dof_secidx_t index)
 {
@@ -112,11 +118,11 @@ usdt_strtab_add(usdt_strtab_t *strtab, const char *string)
         strtab->strindex += (length + 1);
 
         if ((strtab->data = realloc(strtab->data, strtab->strindex)) == NULL)
-                return (-1);
+                return (0);
 
         memcpy((char *) (strtab->data + index), (char *)string, length + 1);
         strtab->size = index + length + 1;
 
-        return index;
+        return (index);
 }
 

data/ext/libusdt/usdt_dof_file.c

@@ -47,7 +47,10 @@ load_dof(int fd, dof_helper_t *dh)
         val = (user_addr_t)(unsigned long)ioctlData;
         ret = ioctl(fd, DTRACEHIOC_ADDDOF, &val);
 
-        return ret;
+        if (ret < 0)
+                return ret;
+
+        return (int)(ioctlData->dofiod_helpers[0].dofhp_dof);
 }
 
 #else /* Solaris */
@@ -129,7 +132,8 @@ static size_t
 add_section(usdt_dof_file_t *file, size_t offset, usdt_dof_section_t *section)
 {
         if (section->pad > 0) {
-                memcpy((file->dof + offset), "\0", section->pad);
+                /* maximum padding required is 7 */
+                memcpy((file->dof + offset), "\0\0\0\0\0\0\0", section->pad);
                 offset += section->pad;
         }
 
@@ -137,6 +141,25 @@ add_section(usdt_dof_file_t *file, size_t offset, usdt_dof_section_t *section)
         return (offset + section->size);
 }
 
+int
+usdt_dof_file_unload(usdt_dof_file_t *file)
+{
+        int fd, ret;
+
+        if ((fd = open(helper, O_RDWR)) < 0)
+                return (-1);
+
+        ret = ioctl(fd, DTRACEHIOC_REMOVE, file->gen);
+
+        if (ret < 0)
+                return (-1);
+
+        if ((close(fd)) < 0)
+                return (-1);
+
+        return (0);
+}
+
 int
 usdt_dof_file_load(usdt_dof_file_t *file, const char *module)
 {
@@ -245,3 +268,10 @@ usdt_dof_file_init(usdt_provider_t *provider, size_t size)
 
         return (file);
 }
+
+void
+usdt_dof_file_free(usdt_dof_file_t *file)
+{
+        free(file->dof);
+        free(file);
+}

data/ext/libusdt/usdt_dof_sections.c

@@ -20,6 +20,7 @@ usdt_dof_probes_sect(usdt_dof_section_t *probes,
         for (pd = provider->probedefs; pd != NULL; pd = pd->next) {
                 argc = 0;
                 argv = 0;
+                type = 0;
 
                 for (i = 0; i < pd->argc; i++) {
                         switch(pd->types[i]) {
@@ -45,7 +46,7 @@ usdt_dof_probes_sect(usdt_dof_section_t *probes,
 
 #ifdef __x86_64__
                 p.dofpr_addr     = (uint64_t) pd->probe->isenabled_addr;
-#elif __i386__
+#elif __i386__ || __i386
                 p.dofpr_addr     = (uint32_t) pd->probe->isenabled_addr;
 #else
 #error "only x86_64 and i386 supported"
@@ -61,6 +62,8 @@ usdt_dof_probes_sect(usdt_dof_section_t *probes,
                 p.dofpr_noffs    = 1;
                 p.dofpr_enoffidx = offidx;
                 p.dofpr_nenoffs  = 1;
+                p.dofpr_pad1     = 0;
+                p.dofpr_pad2     = 0;
 
                 usdt_dof_section_add_data(probes, &p, sizeof(dof_probe_t));
                 probes->entsize = sizeof(dof_probe_t);
@@ -150,7 +153,7 @@ usdt_dof_provider_sect(usdt_dof_section_t *provider_s, usdt_provider_t *provider
         p.dofpv_prargs   = 2;
         p.dofpv_proffs   = 3;
         p.dofpv_prenoffs = 4;
-        p.dofpv_name     = 1; // provider name always first strtab entry.
+        p.dofpv_name     = 1; /* provider name always first strtab entry. */
 
         /*
          * Stability is something of a hack. Everything is marked *

data/ext/libusdt/usdt_internal.h

@@ -80,6 +80,7 @@ usdt_dof_file_t *usdt_dof_file_init(usdt_provider_t *provider, size_t size);
 void usdt_dof_file_append_section(usdt_dof_file_t *file, usdt_dof_section_t *section);
 void usdt_dof_file_generate(usdt_dof_file_t *file, usdt_strtab_t *strtab);
 int usdt_dof_file_load(usdt_dof_file_t *file, const char *module);
+int usdt_dof_file_unload(usdt_dof_file_t *file);
 
 int usdt_dof_probes_sect(usdt_dof_section_t *probes,
                          usdt_provider_t *provider, usdt_strtab_t *strtab);

data/ext/libusdt/usdt_probe.c

@@ -25,7 +25,7 @@ usdt_is_enabled_offset(usdt_probe_t *probe, char *dof)
 {
         uint32_t offset;
 #ifdef __x86_64__
-        offset = ((uint64_t) probe->isenabled_addr - (uint64_t) dof + 2);
+        offset = ((uint64_t) probe->isenabled_addr - (uint64_t) dof + 6);
 #elif __i386__
         offset = ((uint32_t) probe->isenabled_addr - (uint32_t) dof + 6);
 #else
@@ -39,13 +39,13 @@ usdt_is_enabled_offset(usdt_probe_t *probe, char *dof)
 uint32_t
 usdt_probe_offset(usdt_probe_t *probe, char *dof, uint8_t argc)
 {
-        return (12);
+        return (16);
 }
 
 uint32_t
 usdt_is_enabled_offset(usdt_probe_t *probe, char *dof)
 {
-        return (6);
+        return (8);
 }
 
 #endif
@@ -53,16 +53,20 @@ usdt_is_enabled_offset(usdt_probe_t *probe, char *dof)
 int
 usdt_create_tracepoints(usdt_probe_t *probe)
 {
+        size_t size;
+
         /* ensure that the tracepoints will fit the heap we're allocating */
-        assert((usdt_tracepoint_end - usdt_tracepoint_isenabled) < FUNC_SIZE);
+        size = ((char *)usdt_tracepoint_end - (char *)usdt_tracepoint_isenabled);
+        assert(size < FUNC_SIZE);
 
-        if ((probe->isenabled_addr = valloc(FUNC_SIZE)) == NULL) {
+        if ((probe->isenabled_addr = (int (*)())valloc(FUNC_SIZE)) == NULL)
                 return (-1);
-        }
-        probe->probe_addr = probe->isenabled_addr +
-                (usdt_tracepoint_probe - usdt_tracepoint_isenabled);
 
-        memcpy(probe->isenabled_addr, usdt_tracepoint_isenabled, FUNC_SIZE);
+        size = ((char *)usdt_tracepoint_probe - (char *)usdt_tracepoint_isenabled);
+        probe->probe_addr = (char *)probe->isenabled_addr + size;
+
+        memcpy((void *)probe->isenabled_addr,
+               (const void *)usdt_tracepoint_isenabled, FUNC_SIZE);
         mprotect((void *)probe->isenabled_addr, FUNC_SIZE,
                  PROT_READ | PROT_WRITE | PROT_EXEC);
 

data/ext/libusdt/usdt_tracepoints_x86_64.s

@@ -24,6 +24,7 @@ usdt_tracepoint_isenabled:
 _usdt_tracepoint_isenabled:
         pushq   %rbp
         movq    %rsp, %rbp
+        addq    $1, %rax
         xorq    %rax, %rax
         nop
         nop

data/lib/usdt/version.rb

@@ -1,3 +1,3 @@
 module USDT
-  VERSION = '0.1.1'
+  VERSION = '0.1.2'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby-usdt
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -25,6 +25,7 @@ files:
 - ext/libusdt/Makefile
 - ext/libusdt/README.md
 - ext/libusdt/test.pl
+- ext/libusdt/test_mem_usage.c
 - ext/libusdt/test_usdt.c
 - ext/libusdt/usdt.c
 - ext/libusdt/usdt.h