ruby-static-tracing 0.0.4 → 0.0.5

data/ext/ruby-static-tracing/lib/libusdt/usdt.c

@@ -0,0 +1,321 @@
+/*
+ * Copyright (c) 2012, Chris Andrews. All rights reserved.
+ */
+
+#include "usdt_internal.h"
+
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+
+char *usdt_errors[] = {
+  "failed to allocate memory",
+  "failed to allocate page-aligned memory",
+  "no probes defined",
+  "failed to load DOF: %s",
+  "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)
+{
+        int i;
+
+        switch (pd->refcnt) {
+        case 1:
+                free((char *)pd->function);
+                free((char *)pd->name);
+                if (pd->probe) {
+                        usdt_free_tracepoints(pd->probe);
+                        free(pd->probe);
+                }
+                for (i = 0; i < pd->argc; i++)
+                        free(pd->types[i]);
+                free(pd);
+                break;
+        case 2:
+                pd->refcnt = 1;
+                break;
+        default:
+                break;
+        }
+}
+
+usdt_provider_t *
+usdt_create_provider(const char *name, const char *module)
+{
+        usdt_provider_t *provider;
+
+        if ((provider = malloc(sizeof *provider)) == NULL) 
+                return NULL;
+
+        provider->name = strdup(name);
+        provider->module = strdup(module);
+        provider->probedefs = NULL;
+        provider->enabled = 0;
+
+        return provider;
+}
+
+usdt_probedef_t *
+usdt_create_probe(const char *func, const char *name, size_t argc, const char **types)
+{
+        int i;
+        usdt_probedef_t *p;
+
+        if (argc > USDT_ARG_MAX)
+                argc = USDT_ARG_MAX;
+
+        if ((p = malloc(sizeof *p)) == NULL)
+                return (NULL);
+
+        p->refcnt = 2;
+        p->function = strdup(func);
+        p->name = strdup(name);
+        p->argc = argc;
+        p->probe = NULL;
+
+        for (i = 0; i < argc; i++)
+                p->types[i] = strdup(types[i]);
+
+        return (p);
+}
+
+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;
+        else {
+                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
+usdt_provider_enable(usdt_provider_t *provider)
+{
+        usdt_strtab_t strtab;
+        usdt_dof_file_t *file;
+        usdt_probedef_t *pd;
+        int i;
+        size_t size;
+        usdt_dof_section_t sects[5];
+
+        if (provider->enabled == 1) {
+                usdt_error(provider, USDT_ERROR_ALREADYENABLED);
+                return (0); /* not fatal */
+        }
+
+        if (provider->probedefs == NULL) {
+                usdt_error(provider, USDT_ERROR_NOPROBES);
+                return (-1);
+        }
+
+        for (pd = provider->probedefs; pd != NULL; pd = pd->next) {
+                if ((pd->probe = malloc(sizeof(*pd->probe))) == NULL) {
+                        usdt_error(provider, USDT_ERROR_MALLOC);
+                        return (-1);
+                }
+        }
+
+        if ((usdt_strtab_init(&strtab, 0)) < 0) {
+                usdt_error(provider, USDT_ERROR_MALLOC);
+                return (-1);
+        }
+
+        if ((usdt_strtab_add(&strtab, provider->name)) == 0) {
+                usdt_error(provider, USDT_ERROR_MALLOC);
+                return (-1);
+        }
+
+        if ((usdt_dof_probes_sect(&sects[0], provider, &strtab)) < 0)
+                return (-1);
+        if ((usdt_dof_prargs_sect(&sects[1], provider)) < 0)
+                return (-1);
+
+        size = usdt_provider_dof_size(provider, &strtab);
+        if ((file = usdt_dof_file_init(provider, size)) == NULL)
+                return (-1);
+
+        if ((usdt_dof_proffs_sect(&sects[2], provider, file->dof)) < 0)
+                return (-1);
+        if ((usdt_dof_prenoffs_sect(&sects[3], provider, file->dof)) < 0)
+                return (-1);
+        if ((usdt_dof_provider_sect(&sects[4], provider)) < 0)
+                return (-1);
+
+        for (i = 0; i < 5; i++)
+                usdt_dof_file_append_section(file, &sects[i]);
+
+        usdt_dof_file_generate(file, &strtab);
+
+        usdt_dof_section_free((usdt_dof_section_t *)&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)
+{
+        usdt_probedef_t *pd;
+
+        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;
+
+        /* We would like to free the tracepoints here too, but OS X
+         * (and to a lesser extent Illumos) struggle with this:
+         *
+         * If a provider is repeatedly disabled and re-enabled, and is
+         * allowed to reuse the same memory for its tracepoints, *and*
+         * there's a DTrace consumer running with enablings for these
+         * probes, tracepoints are not always cleaned up sufficiently
+         * that the newly-created probes work.
+         *
+         * Here, then, we will leak the memory holding the
+         * tracepoints, which serves to stop us reusing the same
+         * memory address for new tracepoints, avoiding the bug.
+         */
+
+        for (pd = provider->probedefs; (pd != NULL); pd = pd->next) {
+                /* may have an as yet never-enabled probe on an
+                   otherwise enabled provider */
+                if (pd->probe) {
+                        /* usdt_free_tracepoints(pd->probe); */
+                        free(pd->probe);
+                        pd->probe = 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)
+{
+        if (probe != NULL)
+                return (*probe->isenabled_addr)();
+        else
+                return 0;
+}
+
+void
+usdt_fire_probe(usdt_probe_t *probe, size_t argc, void **nargv)
+{
+        if (probe != NULL)
+                usdt_probe_args(probe->probe_addr, argc, nargv);
+}
+
+static void
+usdt_verror(usdt_provider_t *provider, usdt_error_t error, va_list argp)
+{
+        vasprintf(&provider->error, usdt_errors[error], argp);
+}
+
+void
+usdt_error(usdt_provider_t *provider, usdt_error_t error, ...)
+{
+        va_list argp;
+
+        va_start(argp, error);
+        usdt_verror(provider, error, argp);
+        va_end(argp);
+}
+
+char *
+usdt_errstr(usdt_provider_t *provider)
+{
+        return (provider->error);
+}

data/ext/ruby-static-tracing/lib/libusdt/usdt.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright (c) 2012, Chris Andrews. All rights reserved.
+ */
+
+#ifndef __LIB_USDT_USDT_H__
+#define __LIB_USDT_USDT_H__
+
+#include <stdint.h>
+#include <unistd.h>
+
+#define USDT_ARG_MAX 32
+
+typedef enum usdt_error {
+        USDT_ERROR_MALLOC = 0,
+        USDT_ERROR_VALLOC,
+        USDT_ERROR_NOPROBES,
+        USDT_ERROR_LOADDOF,
+        USDT_ERROR_ALREADYENABLED,
+        USDT_ERROR_UNLOADDOF,
+        USDT_ERROR_DUP_PROBE,
+        USDT_ERROR_REMOVE_PROBE
+} usdt_error_t;
+
+typedef struct usdt_probe {
+        int (*isenabled_addr)(void);
+        void *probe_addr;
+} usdt_probe_t;
+
+int usdt_is_enabled(usdt_probe_t *probe);
+void usdt_fire_probe(usdt_probe_t *probe, size_t argc, void **argv);
+
+typedef struct usdt_probedef {
+        const char *name;
+        const char *function;
+        size_t argc;
+        char *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;
+        const char *module;
+        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);
+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);
+
+#endif // __LIB_USDT_USDT_H__

data/ext/ruby-static-tracing/lib/libusdt/usdt_dof.c

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 2012, Chris Andrews. All rights reserved.
+ */
+
+#include "usdt_internal.h"
+
+int
+usdt_dof_section_add_data(usdt_dof_section_t *section, void *data, size_t length)
+{
+        int newlen = section->size + length;
+
+        if ((section->data = realloc((char *)section->data, newlen)) == NULL)
+                return (-1);
+
+        memcpy(section->data + section->size, data, length);
+        section->size = newlen;
+        return (0);
+}
+
+size_t
+usdt_provider_dof_size(usdt_provider_t *provider, usdt_strtab_t *strtab)
+{
+        uint8_t i, j;
+        int args = 0;
+        int probes = 0;
+        size_t size = 0;
+        usdt_probedef_t *pd;
+        size_t sections[8];
+
+        for (pd = provider->probedefs; pd != NULL; pd = pd->next) {
+                args += pd->argc;
+                probes++;
+        }
+
+        sections[0] = sizeof(dof_hdr_t);
+        sections[1] = sizeof(dof_sec_t) * 6;
+        sections[2] = strtab->size;
+        sections[3] = sizeof(dof_probe_t) * probes;
+        sections[4] = sizeof(uint8_t) * args;
+        sections[5] = sizeof(uint32_t) * probes;
+        sections[6] = sizeof(uint32_t) * probes;
+        sections[7] = sizeof(dof_provider_t);
+
+        for (i = 0; i < 8; i++) {
+                size += sections[i];
+                j = size % 8;
+                if (j > 0)
+                        size += (8 - j);
+        }
+
+        return size;
+}
+
+int
+usdt_dof_section_init(usdt_dof_section_t *section, uint32_t type, dof_secidx_t index)
+{
+        section->type    = type;
+        section->index   = index;
+        section->flags   = DOF_SECF_LOAD;
+        section->offset  = 0;
+        section->size    = 0;
+        section->entsize = 0;
+        section->pad	 = 0;
+        section->next    = NULL;
+
+        if ((section->data = malloc(1)) == NULL)
+                return (-1);
+
+        switch(type) {
+        case DOF_SECT_PROBES:   section->align = 8; break;
+        case DOF_SECT_PRARGS:   section->align = 1; break;
+        case DOF_SECT_PROFFS:   section->align = 4; break;
+        case DOF_SECT_PRENOFFS: section->align = 4; break;
+        case DOF_SECT_PROVIDER: section->align = 4; break;
+        }
+
+        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)
+{
+        strtab->type    = DOF_SECT_STRTAB;;
+        strtab->index   = index;
+        strtab->flags   = DOF_SECF_LOAD;
+        strtab->offset  = 0;
+        strtab->size    = 0;
+        strtab->entsize = 0;
+        strtab->pad	  = 0;
+        strtab->data    = NULL;
+        strtab->align   = 1;
+        strtab->strindex = 1;
+
+        if ((strtab->data = (char *) malloc(1)) == NULL)
+                return (-1);
+
+        *strtab->data = '\0';
+
+        return (0);
+}
+
+dof_stridx_t
+usdt_strtab_add(usdt_strtab_t *strtab, const char *string)
+{
+        size_t length;
+        int index;
+
+        length = strlen(string);
+        index = strtab->strindex;
+        strtab->strindex += (length + 1);
+
+        if ((strtab->data = realloc(strtab->data, strtab->strindex)) == NULL)
+                return (0);
+
+        memcpy((char *) (strtab->data + index), (char *)string, length + 1);
+        strtab->size = index + length + 1;
+
+        return (index);
+}
+