/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <libgen.h>
#include <assert.h>
#include <strings.h>
#include <libproc.h>
#include <pthread.h>
#include <dtrace_jni.h>
/* generated by javah */
#include <LocalConsumer.h>

/*
 * dtrace_jni.c defines all the native methods of the Java DTrace API.  Every
 * native method is declared in a single class, LocalConsumer.java.
 *
 * Notes:
 *
 * The data generating loop must explicitly release every object reference it
 * obtains in order to avoid a memory leak.  A local JNI object reference is not
 * automatically released until control returns to java, which never happens as
 * long as the data generating loop runs.  This applies to any JNI function that
 * obtains an object reference (such as CallObjectMethod() or NewObject()).  A
 * local reference is released by calling DeleteLocalRef(), which is safe to
 * call with an exception pending.
 *
 * It is important to check for an exception after calling java code from native
 * C, such as after notifying the java consumer of new data.  Failure to do this
 * makes it possible for users of the interface to crash the JVM by throwing an
 * exception in java code.
 *
 * Some JNI functions, like GetIntField() or ReleaseStringUTFChars(), do not
 * need to be checked for exceptions.
 *
 * GetStringUTFChars() returns NULL if and only if an exception was thrown.
 *
 * It is important to stop a DTrace consumer and remove it if an exception
 * occurs.  This API guarantees that a consumer is stopped automatically if it
 * throws an exception.  An application running multiple DTrace consumers
 * simultaneously should be able to continue running the others normally if any
 * fail.
 *
 * Calls to libdtrace are not guaranteed to be MT-safe.  Even if they are
 * currently MT-safe, they are not guaranteed to remain that way.  To address
 * this, a global lock (the LocalConsumer.class reference) is used around calls
 * to libdtrace.  In many cases, the locking is done in java, which should be
 * indicated in this file by a comment above the function that assumes prior
 * locking.  To access the same global lock from native C code, the JNI function
 * MonitorEnter() is used.  Each MonitorEnter() must have a matching
 * MonitorExit() or the application will hang (all consumer threads).  The
 * consumer loop and the getAggregate() method require a per-consumer lock
 * rather than a global lock; in that case the argument to MonitorEnter() and
 * MonitorExit() is the consumerLock member of the LocalConsumer, not the
 * LocalConsumer itself.
 */

/*
 * Increment the version whenever there is a change in the interface between
 * Java and native code, whether from Java into native code:
 * - LocalConsumer.h (generated by javah)
 * or from native code back into Java:
 * - dtj_table_load() in dtj_jnitab.c
 * Changes to dtj_load_common() in dtj_util.c should not normally require a
 * version update, since dtj_util.c defines classes in the JDK, not classes in
 * the Java DTrace API.
 *
 * This version needs to match the version in LocalConsumer.java
 */
#define DTRACE_JNI_VERSION 3

#define FIRST_HANDLE 0          /* sequence-generated consumer ID */
#define NO_HANDLE -1
#define INITIAL_CAPACITY 8      /* initial size of consumer array */
#define MAX_CAPACITY_INCREMENT 1024

static boolean_t g_dtj_load = B_FALSE;
static int g_handle_seq = NO_HANDLE;
/*
 * key: caller's consumer handle (int)
 * value: per-consumer data includes dtrace handle (consumer_t *)
 */
static dtj_consumer_t **g_consumer_table = NULL;
static size_t g_consumer_capacity = 0;
static size_t g_consumer_count = 0;
static size_t g_max_capacity_increment = MAX_CAPACITY_INCREMENT;
static size_t g_max_consumers = 0; /* no maximum */
static boolean_t g_init = B_FALSE;
static pthread_mutex_t g_table_lock;
static pthread_mutexattr_t g_table_lock_attr;
pthread_key_t g_dtj_consumer_key;

static int dtj_get_handle(JNIEnv *, jobject);
static dtj_status_t dtj_get_java_consumer(JNIEnv *, jobject,
    dtj_java_consumer_t *);
static const char *dtj_getexecname(void);
static jobject dtj_get_program_info(dtj_java_consumer_t *, dtrace_proginfo_t *);
static jobject dtj_add_program(dtj_java_consumer_t *, dtj_program_t *);
static void dtj_flag(uint_t *, uint_t, boolean_t *, boolean_t *);
static boolean_t dtj_cflag(dtj_java_consumer_t *, const char *, boolean_t *,
    boolean_t *);
static void dtj_list_probes(JNIEnv *, jobject, jobject, jobject,
    dtrace_probe_f *);
static void dtj_list_compiled_probes(JNIEnv *, jobject, jobject, jobject,
    dtrace_probe_f *);
static int dtj_list_probe(dtrace_hdl_t *, const dtrace_probedesc_t *, void *);
static int dtj_list_probe_detail(dtrace_hdl_t *, const dtrace_probedesc_t *,
    void *);
static int dtj_list_stmt(dtrace_hdl_t *, dtrace_prog_t *, dtrace_stmtdesc_t *,
    void *);
static boolean_t dtj_add_consumer(JNIEnv *, dtj_consumer_t *, int *);
static dtj_consumer_t *dtj_remove_consumer(JNIEnv *, jobject);
static dtj_consumer_t *dtj_remove_consumer_at(int);

/*
 * Gets a sequence-generated consumer ID, or NO_HANDLE if exception pending
 */
static int
dtj_get_handle(JNIEnv *jenv, jobject caller)
{
        int handle;

        if (!g_dtj_load) {
                dtj_throw_illegal_state(jenv, "JNI table not loaded");
                return (NO_HANDLE);
        }
        handle = (*jenv)->CallIntMethod(jenv, caller, g_gethandle_jm);
        if ((*jenv)->ExceptionCheck(jenv)) {
                return (NO_HANDLE);
        }
        if (handle == NO_HANDLE) {
                dtj_throw_illegal_state(jenv, "no consumer handle");
        }
        return (handle);
}

/*
 * Populates the given java consumer created for use in the current native
 * method call.  If the return value is DTJ_ERR, a java exception is pending.
 * Throws IllegalStateException if the caller does not have a valid handle.
 * Throws NoSuchElementException if the caller's handle is not in the global
 * caller table.
 */
static dtj_status_t
dtj_get_java_consumer(JNIEnv *jenv, jobject caller, dtj_java_consumer_t *jc)
{
        dtj_consumer_t *consumer;
        int handle = dtj_get_handle(jenv, caller);
        if (handle == NO_HANDLE) {
                return (DTJ_ERR); /* java exception pending */
        }
        (void) pthread_mutex_lock(&g_table_lock);
        if (g_consumer_table) {
                if ((handle >= 0) && (handle < g_consumer_capacity)) {
                        consumer = g_consumer_table[handle];
                } else {
                        consumer = NULL;
                }
        } else {
                consumer = NULL;
        }
        (void) pthread_mutex_unlock(&g_table_lock);
        if (consumer == NULL) {
                dtj_throw_no_such_element(jenv, "consumer handle %d", handle);
                return (DTJ_ERR);
        }

        /* Initialize java consumer */
        bzero(jc, sizeof (dtj_java_consumer_t));

        /* Attach per-consumer data */
        jc->dtjj_consumer = consumer;

        /* Attach per-JNI-invocation data */
        jc->dtjj_caller = caller;
        jc->dtjj_jenv = jenv;

        return (DTJ_OK);
}

/*
 * Adds a consumer to the global consumer table.
 * Returns B_TRUE if successful; a java exception is pending otherwise.
 * Postcondition: if successful, g_handle_seq is the handle of the consumer just
 * added.
 */
static boolean_t
dtj_add_consumer(JNIEnv *jenv, dtj_consumer_t *c, int *seq)
{
        int start;

        if (!g_init) {
                (void) pthread_key_create(&g_dtj_consumer_key, NULL);
                (void) pthread_mutexattr_init(&g_table_lock_attr);
                (void) pthread_mutexattr_settype(&g_table_lock_attr,
                    PTHREAD_MUTEX_RECURSIVE);
                (void) pthread_mutex_init(&g_table_lock,
                    &g_table_lock_attr);
                g_init = B_TRUE;
        }

        *seq = NO_HANDLE;
        (void) pthread_mutex_lock(&g_table_lock);
        if (g_consumer_table == NULL) {
                g_consumer_table = malloc(INITIAL_CAPACITY *
                    sizeof (dtj_consumer_t *));
                if (!g_consumer_table) {
                        g_handle_seq = NO_HANDLE;
                        dtj_throw_out_of_memory(jenv,
                            "could not allocate consumer table");
                        (void) pthread_mutex_unlock(&g_table_lock);
                        return (B_FALSE);
                }
                bzero(g_consumer_table, (INITIAL_CAPACITY *
                    sizeof (dtj_consumer_t *)));
                g_consumer_capacity = INITIAL_CAPACITY;
        } else if ((g_max_consumers > 0) && (g_consumer_count >=
            g_max_consumers)) {
                dtj_throw_resource_limit(jenv, "Too many consumers");
                (void) pthread_mutex_unlock(&g_table_lock);
                return (B_FALSE);
        } else if (g_consumer_count >= g_consumer_capacity) {
                dtj_consumer_t **t;
                size_t new_capacity;

                if (g_consumer_capacity <= g_max_capacity_increment) {
                        new_capacity = (g_consumer_capacity * 2);
                } else {
                        new_capacity = (g_consumer_capacity +
                            g_max_capacity_increment);
                }

                if ((g_max_consumers > 0) && (new_capacity > g_max_consumers)) {
                        new_capacity = g_max_consumers;
                }

                t = realloc(g_consumer_table,
                    new_capacity * sizeof (dtj_consumer_t *));
                if (!t) {
                        dtj_throw_out_of_memory(jenv,
                            "could not reallocate consumer table");
                        (void) pthread_mutex_unlock(&g_table_lock);
                        return (B_FALSE);
                }

                g_consumer_table = t;
                bzero(g_consumer_table + g_consumer_capacity, ((new_capacity -
                    g_consumer_capacity) * sizeof (dtj_consumer_t *)));
                g_consumer_capacity = new_capacity;
        }

        /* Look for an empty slot in the table */
        g_handle_seq = (g_handle_seq == NO_HANDLE
            ? FIRST_HANDLE : g_handle_seq + 1);
        if (g_handle_seq >= g_consumer_capacity) {
                g_handle_seq = FIRST_HANDLE;
        }
        start = g_handle_seq; /* guard against infinite loop */
        while (g_consumer_table[g_handle_seq] != NULL) {
                ++g_handle_seq;
                if (g_handle_seq == start) {
                        dtj_throw_illegal_state(jenv, "consumer table full,"
                            " but count %d < capacity %d",
                            g_consumer_count, g_consumer_capacity);
                        (void) pthread_mutex_unlock(&g_table_lock);
                        return (B_FALSE);
                } else if (g_handle_seq >= g_consumer_capacity) {
                        g_handle_seq = FIRST_HANDLE;
                }
        }
        g_consumer_table[g_handle_seq] = c;
        *seq = g_handle_seq;
        ++g_consumer_count;
        (void) pthread_mutex_unlock(&g_table_lock);
        return (B_TRUE);
}

/*
 * Removes a consumer from the global consumer table.  The call may be initiated
 * from Java code or from native code (because an exception has occurred).
 * Precondition: no exception pending (any pending exception must be temporarily
 * cleared)
 * Returns NULL if the caller is not in the table or if this function throws an
 * exception; either case leaves the global consumer table unchanged.
 * Throws IllegalStateException if the caller does not have a valid handle.
 */
static dtj_consumer_t *
dtj_remove_consumer(JNIEnv *jenv, jobject caller)
{
        dtj_consumer_t *consumer;
        int handle = dtj_get_handle(jenv, caller);
        if (handle == NO_HANDLE) {
                return (NULL); /* java exception pending */
        }
        consumer = dtj_remove_consumer_at(handle);
        return (consumer);
}

/*
 * Returns NULL if there is no consumer with the given handle.  Does not throw
 * exceptions.
 */
static dtj_consumer_t *
dtj_remove_consumer_at(int handle)
{
        dtj_consumer_t *consumer;
        (void) pthread_mutex_lock(&g_table_lock);
        if (g_consumer_table) {
                if ((handle >= 0) && (handle < g_consumer_capacity)) {
                        consumer = g_consumer_table[handle];
                        if (consumer != NULL) {
                                g_consumer_table[handle] = NULL;
                                --g_consumer_count;
                                if (g_consumer_count == 0) {
                                        free(g_consumer_table);
                                        g_consumer_table = NULL;
                                        g_consumer_capacity = 0;
                                        g_handle_seq = NO_HANDLE;
                                }
                        }
                } else {
                        consumer = NULL;
                }
        } else {
                consumer = NULL;
        }
        (void) pthread_mutex_unlock(&g_table_lock);
        return (consumer);
}

/*
 * Gets the name of the executable in case it is an application with an embedded
 * JVM and not "java".  Implementation is copied from lib/mpss/common/mpss.c.
 * The use of static auxv_t makes the MT-level unsafe.  The caller is expected
 * to use the global lock (LocalConsumer.class).
 */
static const char *
dtj_getexecname(void)
{
        const char      *execname = NULL;
        static auxv_t   auxb;

        /*
         * The first time through, read the initial aux vector that was
         * passed to the process at exec(2).  Only do this once.
         */
        int fd = open("/proc/self/auxv", O_RDONLY);

        if (fd >= 0) {
                while (read(fd, &auxb, sizeof (auxv_t)) == sizeof (auxv_t)) {
                        if (auxb.a_type == AT_SUN_EXECNAME) {
                                execname = auxb.a_un.a_ptr;
                                break;
                        }
                }
                (void) close(fd);
        }
        return (execname);
}

/*
 * Add the compiled program to a list of programs the API expects to enable.
 * Returns the Program instance identifying the listed program, or NULL if the
 * Program constructor fails (exception pending in that case).
 */
static jobject
dtj_add_program(dtj_java_consumer_t *jc, dtj_program_t *p)
{
        JNIEnv *jenv = jc->dtjj_jenv;

        jobject jprogram = NULL;

        switch (p->dtjp_type) {
        case DTJ_PROGRAM_STRING:
                jprogram = (*jenv)->NewObject(jenv, g_program_jc,
                    g_proginit_jm);
                break;
        case DTJ_PROGRAM_FILE:
                jprogram = (*jenv)->NewObject(jenv, g_programfile_jc,
                    g_fproginit_jm);
                break;
        default:
                dtj_throw_illegal_argument(jenv, "unexpected program type %d\n",
                    p->dtjp_type);
        }
        if ((*jenv)->ExceptionCheck(jenv)) {
                return (NULL);
        }

        /* Does not throw exceptions */
        (*jenv)->SetIntField(jenv, jprogram, g_progid_jf,
            uu_list_numnodes(jc->dtjj_consumer->dtjc_program_list));

        if (!dtj_list_add(jc->dtjj_consumer->dtjc_program_list, p)) {
                (*jenv)->DeleteLocalRef(jenv, jprogram);
                dtj_throw_out_of_memory(jenv,
                    "could not add program");
                return (NULL);
        }

        return (jprogram);
}

/*
 * Returns a new ProgramInfo, or NULL if the constructor fails (java exception
 * pending in that case).
 */
static jobject
dtj_get_program_info(dtj_java_consumer_t *jc, dtrace_proginfo_t *pinfo)
{
        JNIEnv *jenv = jc->dtjj_jenv;

        jobject minProbeAttributes = NULL;
        jobject minStatementAttributes = NULL;
        jobject programInfo = NULL; /* return value */

        minProbeAttributes = dtj_new_attribute(jc, &pinfo->dpi_descattr);
        if (!minProbeAttributes) {
                return (NULL); /* java exception pending */
        }
        minStatementAttributes = dtj_new_attribute(jc, &pinfo->dpi_stmtattr);
        if (!minStatementAttributes) {
                (*jenv)->DeleteLocalRef(jenv, minProbeAttributes);
                return (NULL); /* java exception pending */
        }

        programInfo = (*jenv)->NewObject(jenv, g_proginfo_jc,
            g_proginfoinit_jm, minProbeAttributes, minStatementAttributes,
            pinfo->dpi_matches);
        (*jenv)->DeleteLocalRef(jenv, minProbeAttributes);
        (*jenv)->DeleteLocalRef(jenv, minStatementAttributes);

        return (programInfo);
}

/*
 * Called by LocalConsumer static initializer.
 */
JNIEXPORT void JNICALL
/* ARGSUSED */
Java_org_opensolaris_os_dtrace_LocalConsumer__1checkVersion(JNIEnv *env,
    jclass class, jint version)
{
        if (version != DTRACE_JNI_VERSION) {
                dtj_throw_illegal_state(env,
                    "LocalConsumer version %d incompatible with native "
                    "implementation version %d", version, DTRACE_JNI_VERSION);
        }
}

/*
 * Called by LocalConsumer static initializer.
 */
JNIEXPORT void JNICALL
/* ARGSUSED */
Java_org_opensolaris_os_dtrace_LocalConsumer__1loadJniTable(JNIEnv *env,
    jclass class)
{
        if (g_dtj_load) {
                /*
                 * JNI table includes a global reference to the LocalConsumer
                 * class, preventing the class from being unloaded.  The
                 * LocalConsumer static initializer should never execute more
                 * than once.
                 */
                dtj_throw_illegal_state(env, "JNI table already loaded");
                return;
        }

        /* If this fails, a Java Error (e.g. NoSuchMethodError) is pending */
        if (dtj_load(env) == DTJ_OK) {
                g_dtj_load = B_TRUE;
        }
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1open(JNIEnv *env, jobject obj,
    jobjectArray flags)
{
        dtrace_hdl_t *dtp;
        dtj_consumer_t *c;
        const char *f; /* flag name */
        int oflags = 0;
        int i, len;
        int id;
        int err;

        jobject flag = NULL;
        jstring flagname = NULL;

        if (!g_dtj_load) {
                dtj_throw_illegal_state(env, "JNI table not loaded");
                return;
        }

        c = dtj_consumer_create(env);
        if (!c) {
                return; /* java exception pending */
        }

        /* Get open flags */
        len = (flags ? (*env)->GetArrayLength(env, flags) : 0);
        for (i = 0; i < len; ++i) {
                flag = (*env)->GetObjectArrayElement(env, flags, i);
                if ((*env)->ExceptionCheck(env)) {
                        dtj_consumer_destroy(c);
                        return;
                }

                flagname = (*env)->CallObjectMethod(env, flag, g_enumname_jm);
                (*env)->DeleteLocalRef(env, flag);
                if ((*env)->ExceptionCheck(env)) {
                        dtj_consumer_destroy(c);
                        return;
                }
                f = (*env)->GetStringUTFChars(env, flagname, NULL);
                if ((*env)->ExceptionCheck(env)) {
                        (*env)->DeleteLocalRef(env, flagname);
                        dtj_consumer_destroy(c);
                        return;
                }
                if (strcmp(f, "ILP32") == 0) {
                        oflags |= DTRACE_O_ILP32;
                } else if (strcmp(f, "LP64") == 0) {
                        oflags |= DTRACE_O_LP64;
                }
                (*env)->ReleaseStringUTFChars(env, flagname, f);
                (*env)->DeleteLocalRef(env, flagname);
        }

        /* Check for mutually exclusive flags */
        if ((oflags & DTRACE_O_ILP32) && (oflags & DTRACE_O_LP64)) {
                dtj_throw_illegal_argument(env,
                    "Cannot set both ILP32 and LP64");
                dtj_consumer_destroy(c);
                return;
        }

        /*
         * Make sure we can add the consumer before calling dtrace_open().
         * Repeated calls to open() when the consumer table is maxed out should
         * avoid calling dtrace_open().  (Normally there is no limit to the size
         * of the consumer table, but the undocumented JAVA_DTRACE_MAX_CONSUMERS
         * system property lets you set a limit after which
         * ResourceLimitException is thrown.)
         */
        if (!dtj_add_consumer(env, c, &id)) {
                dtj_consumer_destroy(c);
                return; /* java exception pending */
        }

        (*env)->CallVoidMethod(env, obj, g_sethandle_jm, id);
        if ((*env)->ExceptionCheck(env)) {
                (void) dtj_remove_consumer_at(id);
                dtj_consumer_destroy(c);
                return;
        }

        if ((dtp = dtrace_open(DTRACE_VERSION, oflags, &err)) == NULL) {
                dtj_java_consumer_t jc;
                jc.dtjj_jenv = env;
                dtj_throw_dtrace_exception(&jc, dtrace_errmsg(NULL, err));
                (void) dtj_remove_consumer_at(id);
                dtj_consumer_destroy(c);
                return;
        }
        c->dtjc_dtp = dtp; /* set consumer handle to native DTrace library */
}

static void
dtj_flag(uint_t *flags, uint_t flag, boolean_t *get, boolean_t *set)
{
        assert((get && !set) || (set && !get));

        if (get) {
                *get = (*flags & flag);
        } else {
                if (*set) {
                        *flags |= flag;
                } else {
                        *flags &= ~flag;
                }
        }
}

/*
 * Returns B_TRUE if opt is a recognized compile flag, B_FALSE otherwise.
 */
static boolean_t
dtj_cflag(dtj_java_consumer_t *jc, const char *opt, boolean_t *get,
    boolean_t *set)
{
        boolean_t is_cflag = B_TRUE;
        uint_t *flags = &jc->dtjj_consumer->dtjc_cflags;

        /* see lib/libdtrace/common/dt_options.c */
        if (strcmp(opt, "argref") == 0) {
                dtj_flag(flags, DTRACE_C_ARGREF, get, set);
        } else if (strcmp(opt, "cpp") == 0) {
                dtj_flag(flags, DTRACE_C_CPP, get, set);
        } else if (strcmp(opt, "defaultargs") == 0) {
                dtj_flag(flags, DTRACE_C_DEFARG, get, set);
        } else if (strcmp(opt, "empty") == 0) {
                dtj_flag(flags, DTRACE_C_EMPTY, get, set);
        } else if (strcmp(opt, "errtags") == 0) {
                dtj_flag(flags, DTRACE_C_ETAGS, get, set);
        } else if (strcmp(opt, "knodefs") == 0) {
                dtj_flag(flags, DTRACE_C_KNODEF, get, set);
        } else if (strcmp(opt, "nolibs") == 0) {
                dtj_flag(flags, DTRACE_C_NOLIBS, get, set);
        } else if (strcmp(opt, "pspec") == 0) {
                dtj_flag(flags, DTRACE_C_PSPEC, get, set);
        } else if (strcmp(opt, "unodefs") == 0) {
                dtj_flag(flags, DTRACE_C_UNODEF, get, set);
        } else if (strcmp(opt, "verbose") == 0) {
                dtj_flag(flags, DTRACE_C_DIFV, get, set);
        } else if (strcmp(opt, "zdefs") == 0) {
                dtj_flag(flags, DTRACE_C_ZDEFS, get, set);
        } else {
                is_cflag = B_FALSE;
        }

        if (is_cflag && set &&
            (jc->dtjj_consumer->dtjc_state != DTJ_CONSUMER_INIT)) {
                dtj_throw_illegal_state(jc->dtjj_jenv,
                    "cannot set compile time option \"%s\" after calling go()",
                    opt);
                return (is_cflag);
        }

        return (is_cflag);
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT jobject JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1compileString(JNIEnv *env,
    jobject obj, jstring program, jobjectArray args)
{
        const char *prog;
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        dtj_program_t *p;
        int argc = 0;
        char **argv = NULL;

        jstring jprogram = NULL;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return (NULL); /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        prog = (*env)->GetStringUTFChars(env, program, 0);
        if ((*env)->ExceptionCheck(env)) {
                return (NULL);
        }

        p = dtj_program_create(env, DTJ_PROGRAM_STRING, prog);
        if (!p) {
                (*env)->ReleaseStringUTFChars(env, program, prog);
                return (NULL); /* java exception pending */
        }

        if (args) {
                argv = dtj_get_argv(env, args, &argc);
                if ((*env)->ExceptionCheck(env)) {
                        (*env)->ReleaseStringUTFChars(env, program, prog);
                        dtj_program_destroy(p, NULL);
                        return (NULL);
                }
        }

        if ((p->dtjp_program = dtrace_program_strcompile(dtp,
            prog, DTRACE_PROBESPEC_NAME, jc.dtjj_consumer->dtjc_cflags,
            argc, argv)) == NULL) {
                dtj_throw_dtrace_exception(&jc,
                    "invalid probe specifier %s: %s",
                    prog, dtrace_errmsg(dtp, dtrace_errno(dtp)));
                (*env)->ReleaseStringUTFChars(env, program, prog);
                dtj_program_destroy(p, NULL);
                dtj_free_argv(argv);
                return (NULL);
        }
        (*env)->ReleaseStringUTFChars(env, program, prog);
        dtj_free_argv(argv);

        jprogram = dtj_add_program(&jc, p);
        return (jprogram); /* NULL if exception pending */
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT jobject JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1compileFile(JNIEnv *env,
    jobject obj, jstring filename, jobjectArray args)
{
        FILE *fp;
        const char *file;
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        dtj_program_t *p;
        int argc = 0;
        char **argv = NULL;

        jstring jprogram = NULL;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return (NULL); /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        file = dtj_GetStringNativeChars(env, filename);
        if ((fp = fopen(file, "r")) == NULL) {
                dtj_throw_dtrace_exception(&jc, "failed to open %s", file);
                dtj_ReleaseStringNativeChars(env, filename, file);
                return (NULL);
        }

        p = dtj_program_create(env, DTJ_PROGRAM_FILE, file);
        if (!p) {
                (void) fclose(fp);
                dtj_ReleaseStringNativeChars(env, filename, file);
                return (NULL); /* java exception pending */
        }

        if (args) {
                argv = dtj_get_argv(env, args, &argc);
                if ((*env)->ExceptionCheck(env)) {
                        (void) fclose(fp);
                        dtj_ReleaseStringNativeChars(env, filename, file);
                        dtj_program_destroy(p, NULL);
                        return (NULL);
                }
        }

        if ((p->dtjp_program = dtrace_program_fcompile(dtp,
            fp, jc.dtjj_consumer->dtjc_cflags, argc, argv)) == NULL) {
                dtj_throw_dtrace_exception(&jc,
                    "failed to compile script %s: %s", file,
                    dtrace_errmsg(dtp, dtrace_errno(dtp)));
                (void) fclose(fp);
                dtj_ReleaseStringNativeChars(env, filename, file);
                dtj_program_destroy(p, NULL);
                dtj_free_argv(argv);
                return (NULL);
        }
        (void) fclose(fp);
        dtj_ReleaseStringNativeChars(env, filename, file);
        dtj_free_argv(argv);

        jprogram = dtj_add_program(&jc, p);
        return (jprogram); /* NULL if exception pending */
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1exec(JNIEnv *env, jobject obj,
    jobject program)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        int progid = -1;
        uu_list_walk_t *itr;
        dtj_program_t *p;
        dtrace_proginfo_t *pinfo = NULL;
        int i;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        if (program) {
                progid = (*env)->GetIntField(env, program, g_progid_jf);
        }

        if (dtj_list_empty(jc.dtjj_consumer->dtjc_program_list)) {
                dtj_throw_illegal_state(env, "no program compiled");
                return;
        }

        itr = uu_list_walk_start(jc.dtjj_consumer->dtjc_program_list, 0);
        for (i = 0; (p = uu_list_walk_next(itr)) != NULL; ++i) {
                /* enable all probes or those of given program only */
                if ((progid != -1) && (progid != i)) {
                        continue;
                }

                if (p->dtjp_enabled) {
                        dtj_throw_illegal_state(env, "program already enabled");
                        uu_list_walk_end(itr);
                        return;
                }

                pinfo = &p->dtjp_info;
                if (dtrace_program_exec(dtp, p->dtjp_program, pinfo) == -1) {
                        dtj_throw_dtrace_exception(&jc,
                            "failed to enable %s: %s", p->dtjp_name,
                            dtrace_errmsg(dtp, dtrace_errno(dtp)));
                        uu_list_walk_end(itr);
                        return;
                }
                p->dtjp_enabled = B_TRUE;
        }
        uu_list_walk_end(itr);

        if (program) {
                jobject programInfo = NULL;

                if (!pinfo) {
                        /*
                         * Consumer.enable() has already checked that the
                         * program was compiled by this consumer.  This is an
                         * implementation error, not a user error.
                         */
                        dtj_throw_illegal_state(env, "program not found");
                        return;
                }

                programInfo = dtj_get_program_info(&jc, pinfo);
                if (!programInfo) {
                        return; /* java exception pending */
                }

                (*env)->SetObjectField(env, program, g_proginfo_jf,
                    programInfo);
                (*env)->DeleteLocalRef(env, programInfo);
        }
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1getProgramInfo(JNIEnv *env,
    jobject obj, jobject program)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        int progid;
        uu_list_walk_t *itr;
        dtj_program_t *p;
        dtrace_proginfo_t *pinfo = NULL;
        int i;

        jobject programInfo = NULL;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        progid = (*env)->GetIntField(env, program, g_progid_jf);

        if (dtj_list_empty(jc.dtjj_consumer->dtjc_program_list)) {
                dtj_throw_illegal_state(env, "no program compiled");
                return;
        }

        itr = uu_list_walk_start(jc.dtjj_consumer->dtjc_program_list, 0);
        for (i = 0; ((p = uu_list_walk_next(itr)) != NULL) && !pinfo; ++i) {
                if (progid != i) {
                        /* get info of given program only */
                        continue;
                }

                pinfo = &p->dtjp_info;
                dtrace_program_info(dtp, p->dtjp_program, pinfo);
        }
        uu_list_walk_end(itr);

        programInfo = dtj_get_program_info(&jc, pinfo);
        if (!programInfo) {
                return; /* java exception pending */
        }

        (*env)->SetObjectField(env, program, g_proginfo_jf,
            programInfo);
        (*env)->DeleteLocalRef(env, programInfo);
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1setOption(JNIEnv *env,
    jobject obj, jstring option, jstring value)
{
        dtj_java_consumer_t jc;
        const char *opt;
        const char *val;
        boolean_t on;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }

        opt = (*env)->GetStringUTFChars(env, option, 0);
        if (!opt) {
                dtj_throw_out_of_memory(env,
                    "could not allocate option string");
                return;
        }

        if (value) {
                val = (*env)->GetStringUTFChars(env, value, 0);
                if (!val) {
                        dtj_throw_out_of_memory(env,
                            "could not allocate option value string");
                        (*env)->ReleaseStringUTFChars(env, option, opt);
                        return;
                }
        } else {
                /*
                 * dtrace_setopt() sets option to 0 if value is NULL.  That's
                 * not the same thing as unsetting a boolean option, since
                 * libdtrace uses -2 to mean unset.  We'll leave it to
                 * LocalConsumer.java to disallow null or not.
                 */
                val = NULL;
        }

        /*
         * Check for boolean compile-time options not handled by
         * dtrace_setopt().
         */
        on = (!val || (strcmp(val, "unset") != 0));
        if (dtj_cflag(&jc, opt, NULL, &on)) {
                (*env)->ReleaseStringUTFChars(env, option, opt);
                if (value) {
                        (*env)->ReleaseStringUTFChars(env, value, val);
                }
                return;
        }

        /*
         * The transition from INIT to GO is protected by synchronization
         * (a per-consumer lock) in LocalConsumer.java, ensuring that go() and
         * setOption() execute sequentially.
         */
        if (jc.dtjj_consumer->dtjc_state != DTJ_CONSUMER_INIT) {
                /*
                 * If the consumer is already running, defer setting the option
                 * until we wake up from dtrace_sleep.
                 */
                dtj_request_t *request;


                (void) pthread_mutex_lock(
                    &jc.dtjj_consumer->dtjc_request_list_lock);
                request = dtj_request_create(env, DTJ_REQUEST_OPTION, opt, val);
                if (request) {
                        if (!dtj_list_add(jc.dtjj_consumer->dtjc_request_list,
                            request)) {
                                dtj_throw_out_of_memory(env,
                                    "Failed to add setOption request");
                        }
                } /* else java exception pending */
                (void) pthread_mutex_unlock(
                    &jc.dtjj_consumer->dtjc_request_list_lock);
        } else {
                dtrace_hdl_t *dtp = jc.dtjj_consumer->dtjc_dtp;
                if (dtrace_setopt(dtp, opt, val) == -1) {
                        dtj_throw_dtrace_exception(&jc, dtrace_errmsg(dtp,
                            dtrace_errno(dtp)));
                }
        }

        (*env)->ReleaseStringUTFChars(env, option, opt);
        if (value) {
                (*env)->ReleaseStringUTFChars(env, value, val);
        }
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT jlong JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1getOption(JNIEnv *env,
    jobject obj, jstring option)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        const char *opt;
        dtrace_optval_t optval;
        boolean_t cflag;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return (0); /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        opt = (*env)->GetStringUTFChars(env, option, 0);
        if (!opt) {
                dtj_throw_out_of_memory(env,
                    "could not allocate option string");
                return (0);
        }

        /*
         * Check for boolean compile-time options not handled by
         * dtrace_setopt().
         */
        if (dtj_cflag(&jc, opt, &cflag, NULL)) {
                (*env)->ReleaseStringUTFChars(env, option, opt);
                return (cflag ? 1 : DTRACEOPT_UNSET);
        }

        if (dtrace_getopt(dtp, opt, &optval) == -1) {
                dtj_throw_dtrace_exception(&jc,
                    "couldn't get option %s: %s", opt,
                    dtrace_errmsg(dtp, dtrace_errno(dtp)));
                (*env)->ReleaseStringUTFChars(env, option, opt);
                return (0);
        }
        (*env)->ReleaseStringUTFChars(env, option, opt);
        return (optval);
}

/*
 * Throws IllegalStateException if not all compiled programs are enabled.
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1checkProgramEnabling(JNIEnv *env,
    jobject obj)
{
        dtj_java_consumer_t jc;
        dtj_program_t *p;
        uu_list_walk_t *itr;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }

        if (dtj_list_empty(jc.dtjj_consumer->dtjc_program_list)) {
                dtj_throw_illegal_state(env, "no program compiled");
                return;
        }

        itr = uu_list_walk_start(jc.dtjj_consumer->dtjc_program_list, 0);
        while ((p = uu_list_walk_next(itr)) != NULL) {
                if (!p->dtjp_enabled) {
                        const char *type;
                        switch (p->dtjp_type) {
                        case DTJ_PROGRAM_STRING:
                                type = "description";
                                break;
                        case DTJ_PROGRAM_FILE:
                                type = "script";
                                break;
                        default:
                                assert(p->dtjp_type == DTJ_PROGRAM_STRING ||
                                    p->dtjp_type == DTJ_PROGRAM_FILE);
                        }
                        dtj_throw_illegal_state(env,
                            "Not all compiled probes are enabled. "
                            "Compiled %s %s not enabled.",
                            type, p->dtjp_name);
                        uu_list_walk_end(itr);
                        return;
                }
        }
        uu_list_walk_end(itr);
}

JNIEXPORT jboolean JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1isEnabled(JNIEnv *env,
    jobject obj)
{
        dtj_java_consumer_t jc;
        dtj_program_t *p;
        uu_list_walk_t *itr;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return (JNI_FALSE); /* java exception pending */
        }

        if (dtj_list_empty(jc.dtjj_consumer->dtjc_program_list)) {
                return (JNI_FALSE); /* no program compiled */
        }

        itr = uu_list_walk_start(jc.dtjj_consumer->dtjc_program_list, 0);
        while ((p = uu_list_walk_next(itr)) != NULL) {
                if (!p->dtjp_enabled) {
                        uu_list_walk_end(itr);
                        return (JNI_FALSE);
                }
        }
        uu_list_walk_end(itr);

        return (JNI_TRUE);
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1go(JNIEnv *env, jobject obj)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        if (dtj_set_callback_handlers(&jc) != DTJ_OK) {
                return; /* java exception pending */
        }

        if (dtrace_go(dtp) != 0) {
                dtj_throw_dtrace_exception(&jc,
                    "could not enable tracing: %s",
                    dtrace_errmsg(dtp, dtrace_errno(dtp)));
                return;
        }

        jc.dtjj_consumer->dtjc_state = DTJ_CONSUMER_GO;
}

/*
 * Protected by global lock (LocalConsumer.class).  Called when aborting the
 * consumer loop before it starts.
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1stop(JNIEnv *env,
    jobject obj)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        if (dtrace_stop(dtp) == -1) {
                dtj_throw_dtrace_exception(&jc,
                    "couldn't stop tracing: %s",
                    dtrace_errmsg(jc.dtjj_consumer->dtjc_dtp,
                    dtrace_errno(jc.dtjj_consumer->dtjc_dtp)));
        } else {
                jc.dtjj_consumer->dtjc_state = DTJ_CONSUMER_STOP;
        }
}

JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1consume(JNIEnv *env,
    jobject obj)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;
        jc.dtjj_consumer->dtjc_state = DTJ_CONSUMER_START;

        if (dtj_java_consumer_init(env, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }

        /*
         * Must set the thread-specific java consumer before starting the
         * dtrace_work() loop because the bufhandler can also be invoked by
         * getAggregate() from another thread.  The bufhandler needs access to
         * the correct JNI state specific to either the consumer loop or the
         * getAggregate() call.
         */
        (void) pthread_setspecific(g_dtj_consumer_key, &jc);

        if (jc.dtjj_consumer->dtjc_process_list != NULL) {
                struct ps_prochandle *P;
                uu_list_walk_t *itr;

                /* Must not call MonitorEnter with a pending exception */
                if ((*env)->ExceptionCheck(env)) {
                        dtj_java_consumer_fini(env, &jc);
                        return; /* java exception pending */
                }
                (*env)->MonitorEnter(env, g_caller_jc);
                if ((*env)->ExceptionCheck(env)) {
                        dtj_java_consumer_fini(env, &jc);
                        return; /* java exception pending */
                }

                itr = uu_list_walk_start(jc.dtjj_consumer->dtjc_process_list,
                    0);
                while ((P = dtj_pointer_list_walk_next(itr)) !=
                    DTJ_INVALID_PTR) {
                        dtrace_proc_continue(dtp, P);
                }
                uu_list_walk_end(itr);

                (*env)->MonitorExit(env, g_caller_jc);
                if ((*env)->ExceptionCheck(env)) {
                        dtj_java_consumer_fini(env, &jc);
                        return; /* java exception pending */
                }
        }

        /*
         * Blocking call starts consumer loop.
         */
        (void) dtj_consume(&jc);

        dtj_java_consumer_fini(env, &jc);
        /*
         * Stop the consumer after the consumer loop terminates, whether
         * normally because of the exit() action or LocalConsumer.stop(), or
         * abnormally because of an exception.  The call is ignored if the
         * consumer is already stopped.  It is safe to call dtj_stop() with a
         * pending exception.
         */
        dtj_stop(&jc);
}

/*
 * Interrupts a running consumer.  May be called from any thread.
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1interrupt(JNIEnv *env,
    jobject obj)
{
        dtj_java_consumer_t jc;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }

        jc.dtjj_consumer->dtjc_interrupt = B_TRUE;
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1close(JNIEnv *env, jobject obj)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        /*
         * Need to release any created procs here, since the consumer_t
         * destructor (called by _destroy) will not have access to the dtrace
         * handle needed to release them (this function closes the dtrace
         * handle).
         */
        if (jc.dtjj_consumer->dtjc_process_list != NULL) {
                struct ps_prochandle *P;
                uu_list_walk_t *itr;
                itr = uu_list_walk_start(jc.dtjj_consumer->dtjc_process_list,
                    0);
                while ((P = dtj_pointer_list_walk_next(itr)) !=
                    DTJ_INVALID_PTR) {
                        dtrace_proc_release(dtp, P);
                }
                uu_list_walk_end(itr);
        }

        dtrace_close(dtp);
}

/*
 * Static Consumer.java method
 */
JNIEXPORT jint JNICALL
/* ARGSUSED */
Java_org_opensolaris_os_dtrace_LocalConsumer__1openCount(JNIEnv *env, jclass c)
{
        int open;
        (void) pthread_mutex_lock(&g_table_lock);
        if (g_consumer_table == NULL) {
                open = 0;
        } else {
                open = g_consumer_count;
        }
        (void) pthread_mutex_unlock(&g_table_lock);
        return (open);
}

/*
 * Static Consumer.java method
 */
JNIEXPORT jlong JNICALL
/* ARGSUSED */
Java_org_opensolaris_os_dtrace_LocalConsumer__1quantizeBucket(JNIEnv *env,
    jclass c, jint bucket)
{
        return (DTRACE_QUANTIZE_BUCKETVAL(bucket));
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT jstring JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1lookupKernelFunction(
    JNIEnv *jenv, jobject caller, jobject address)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;

        jstring jfunc; /* return value */

        GElf_Addr addr;
        char dummy;
        char *s;
        int rc;

        if (dtj_get_java_consumer(jenv, caller, &jc) != DTJ_OK) {
                return (NULL); /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        /* Does not throw exceptions */
        if ((*jenv)->IsInstanceOf(jenv, address, g_int_jc)) {
                /* intValue() of class Number does not throw exceptions */
                addr = (GElf_Addr)(uint32_t)(*jenv)->CallIntMethod(jenv,
                    address, g_intval_jm);
        } else if ((*jenv)->IsInstanceOf(jenv, address, g_number_jc)) {
                /* longValue() of class Number does not throw exceptions */
                addr = (GElf_Addr)(*jenv)->CallLongMethod(jenv,
                    address, g_longval_jm);
        } else {
                dtj_throw_class_cast(jenv, "Expected Number address");
                return (NULL);
        }

        rc = dtrace_addr2str(dtp, addr, &dummy, 1);
        s = malloc(rc + 1);
        if (!s) {
                dtj_throw_out_of_memory(jenv,
                    "Failed to allocate kernel function name");
                return (NULL);
        }
        (void) dtrace_addr2str(dtp, addr, s, rc + 1);

        jfunc = (*jenv)->NewStringUTF(jenv, s);
        free(s);
        return (jfunc);
}

/*
 * Protected by global lock in Consumer.java
 */
JNIEXPORT jstring JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1lookupUserFunction(JNIEnv *jenv,
    jobject caller, jint pid, jobject address)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;

        jstring jfunc; /* return value */

        GElf_Addr addr;
        char dummy;
        char *s;
        int rc;

        if (dtj_get_java_consumer(jenv, caller, &jc) != DTJ_OK) {
                return (NULL); /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        /* Does not throw exceptions */
        if ((*jenv)->IsInstanceOf(jenv, address, g_int_jc)) {
                /* intValue() of class Number does not throw exceptions */
                addr = (GElf_Addr)(uint32_t)(*jenv)->CallIntMethod(jenv,
                    address, g_intval_jm);
        } else if ((*jenv)->IsInstanceOf(jenv, address, g_number_jc)) {
                /* longValue() of class Number does not throw exceptions */
                addr = (GElf_Addr)(*jenv)->CallLongMethod(jenv,
                    address, g_longval_jm);
        } else {
                dtj_throw_class_cast(jenv, "Expected Number address");
                return (NULL);
        }

        rc = dtrace_uaddr2str(dtp, pid, addr, &dummy, 1);
        s = malloc(rc + 1);
        if (!s) {
                dtj_throw_out_of_memory(jenv,
                    "Failed to allocate user function name");
                return (NULL);
        }
        (void) dtrace_uaddr2str(dtp, pid, addr, s, rc + 1);

        jfunc = (*jenv)->NewStringUTF(jenv, s);
        free(s);
        return (jfunc);
}

JNIEXPORT jobject JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1getAggregate(JNIEnv *env,
    jobject obj, jobject spec)
{
        dtj_java_consumer_t jc;

        jobject aggregate = NULL;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return (NULL); /* java exception pending */
        }

        if (dtj_java_consumer_init(env, &jc) != DTJ_OK) {
                return (NULL); /* java exception pending */
        }
        jc.dtjj_aggregate_spec = spec;

        /*
         * Must set the thread-specific java consumer before calling any
         * function that triggers callbacks to the bufhandler set by
         * dtrace_handle_buffered().  The bufhandler needs access to the correct
         * JNI state specific to either the consumer loop or the
         * getAggregate() call.
         */
        (void) pthread_setspecific(g_dtj_consumer_key, &jc);
        aggregate = dtj_get_aggregate(&jc);
        if (!aggregate) {
                /* java exception pending */
                jc.dtjj_consumer->dtjc_interrupt = B_TRUE;
        }
        /*
         * Cleans up only references created by this JNI invocation.  Leaves
         * cached per-consumer state untouched.
         */
        dtj_java_consumer_fini(env, &jc);
        return (aggregate);
}

/*
 * Returns the pid of the created process, or -1 in case of an error (java
 * exception pending).
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT int JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1createProcess(JNIEnv *jenv,
    jobject caller, jstring command)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        struct ps_prochandle *P;
        char **argv;
        int argc;

        if (dtj_get_java_consumer(jenv, caller, &jc) != DTJ_OK) {
                return (-1); /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        if (jc.dtjj_consumer->dtjc_process_list == NULL) {
                jc.dtjj_consumer->dtjc_process_list = dtj_pointer_list_create();
                if (!jc.dtjj_consumer->dtjc_process_list) {
                        dtj_throw_out_of_memory(jenv,
                            "Could not allocate process list");
                        return (-1);
                }
        }

        argv = dtj_make_argv(jenv, command, &argc);
        if ((*jenv)->ExceptionCheck(jenv)) {
                return (-1);
        }

        P = dtrace_proc_create(dtp, argv[0], argv);
        dtj_free_argv(argv);

        if (!P) {
                dtj_throw_dtrace_exception(&jc, dtrace_errmsg(dtp,
                    dtrace_errno(dtp)));
                return (-1);
        }

        if (!dtj_pointer_list_add(jc.dtjj_consumer->dtjc_process_list, P)) {
                dtj_throw_out_of_memory(jenv,
                    "Failed to add process to process list");
                dtrace_proc_release(dtp, P);
                return (-1);
        }
        return (Pstatus(P)->pr_pid);
}

/*
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1grabProcess(JNIEnv *jenv,
    jobject caller, jint pid)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        struct ps_prochandle *P;

        if (dtj_get_java_consumer(jenv, caller, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        if (jc.dtjj_consumer->dtjc_process_list == NULL) {
                jc.dtjj_consumer->dtjc_process_list = dtj_pointer_list_create();
                if (jc.dtjj_consumer->dtjc_process_list == NULL) {
                        dtj_throw_out_of_memory(jenv,
                            "Could not allocate process list");
                        return;
                }
        }

        P = dtrace_proc_grab(dtp, (pid_t)pid, 0);
        if (!P) {
                dtj_throw_dtrace_exception(&jc, dtrace_errmsg(dtp,
                    dtrace_errno(dtp)));
                return;
        }

        if (!dtj_pointer_list_add(jc.dtjj_consumer->dtjc_process_list, P)) {
                dtj_throw_out_of_memory(jenv,
                    "Failed to add process to process list");
                dtrace_proc_release(dtp, P);
                return;
        }
}

/*
 * Lists all probes, or lists matching probes (using the matching rules from
 * Table 4-1 of the DTrace manual).
 *
 * In the future it may be desirable to support an array of probe filters rather
 * than a single filter.  It could be that if a probe matched any of the given
 * filters, it would be included (implied logical OR).
 *
 * Protected by global lock (LocalConsumer.class)
 * param list: an empty list to populate (this function empties the list if it
 * is not empty already)
 * param filter: a ProbeDescription instance; the list will include only probes
 * that match the filter (match all probes if filter is null)
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1listProbes(JNIEnv *env,
    jobject obj, jobject list, jobject filter)
{
        dtj_list_probes(env, obj, list, filter, dtj_list_probe);
}

JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1listProbeDetail(JNIEnv *env,
    jobject obj, jobject list, jobject filter)
{
        dtj_list_probes(env, obj, list, filter, dtj_list_probe_detail);
}

static void
dtj_list_probes(JNIEnv *env, jobject obj, jobject list, jobject filter,
    dtrace_probe_f *func)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        dtrace_probedesc_t probe;
        dtrace_probedesc_t *pdp = NULL;
        const char *probestr;
        int rc;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;

        jc.dtjj_probelist = list;

        /* clear in-out list parameter */
        (*env)->CallVoidMethod(env, list, g_listclear_jm);
        if ((*env)->ExceptionCheck(env)) {
                return;
        }

        if (filter) {
                jstring jprobestr = NULL;

                jprobestr = (*env)->CallObjectMethod(env, filter,
                    g_tostring_jm);
                if ((*env)->ExceptionCheck(env)) {
                        return;
                }
                probestr = (*env)->GetStringUTFChars(env, jprobestr, NULL);
                if (!probestr) {
                        (*env)->DeleteLocalRef(env, jprobestr);
                        return; /* java exception pending */
                }

                bzero(&probe, sizeof (probe));
                rc = dtrace_str2desc(dtp, DTRACE_PROBESPEC_NAME, probestr,
                    &probe);
                (*env)->ReleaseStringUTFChars(env, jprobestr, probestr);
                (*env)->DeleteLocalRef(env, jprobestr);
                if (rc == -1) {
                        dtj_throw_dtrace_exception(&jc,
                            "%s is not a valid probe description: %s",
                            probestr, dtrace_errmsg(dtp,
                            dtrace_errno(dtp)));
                        return;
                }

                pdp = &probe;
        }

        (void) dtrace_probe_iter(dtp, pdp, func, &jc);
}

/*
 * Returns 0 to indicate success, or -1 to cause dtrace_probe_iter() to return a
 * negative value prematurely (indicating no match or failure).
 */
static int
/* ARGSUSED */
dtj_list_probe(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp, void *arg)
{
        dtj_java_consumer_t *jc = arg;
        JNIEnv *jenv = jc->dtjj_jenv;

        jobject jprobedesc = NULL;

        jprobedesc = dtj_new_probedesc(jc, pdp);
        if (!jprobedesc) {
                return (-1); /* java exception pending */
        }

        /* add probe to list */
        (*jenv)->CallVoidMethod(jenv, jc->dtjj_probelist, g_listadd_jm,
            jprobedesc);
        (*jenv)->DeleteLocalRef(jenv, jprobedesc);
        if ((*jenv)->ExceptionCheck(jenv)) {
                return (-1);
        }

        return (0);
}

/*ARGSUSED*/
static int
dtj_list_probe_detail(dtrace_hdl_t *dtp, const dtrace_probedesc_t *pdp,
    void *arg)
{
        dtj_java_consumer_t *jc = arg;
        JNIEnv *jenv = jc->dtjj_jenv;
        dtrace_probeinfo_t p;

        jobject jprobedesc = NULL;
        jobject jprobeinfo = NULL;
        jobject jprobe = NULL;

        jprobedesc = dtj_new_probedesc(jc, pdp);
        if (!jprobedesc) {
                return (-1); /* java exception pending */
        }

        /*
         * If dtrace_probe_info() returns a non-zero value, dtrace_errno is set
         * for us.  In that case, ignore the dtrace error and simply omit probe
         * info.  That error is implicitly cleared the next time a call is made
         * using the same dtrace handle.
         */
        if (dtrace_probe_info(dtp, pdp, &p) == 0) {
                /* create probe info instance */
                jprobeinfo = dtj_new_probeinfo(jc, &p);
                if (!jprobeinfo) {
                        (*jenv)->DeleteLocalRef(jenv, jprobedesc);
                        return (-1); /* java exception pending */
                }
        }

        /* create listed probe instance */
        jprobe = (*jenv)->NewObject(jenv, g_probe_jc, g_probeinit_jm,
            jprobedesc, jprobeinfo);
        (*jenv)->DeleteLocalRef(jenv, jprobedesc);
        (*jenv)->DeleteLocalRef(jenv, jprobeinfo);
        if (!jprobe) {
                return (-1); /* java exception pending */
        }

        /* add probe to list */
        (*jenv)->CallVoidMethod(jenv, jc->dtjj_probelist, g_listadd_jm,
            jprobe);
        (*jenv)->DeleteLocalRef(jenv, jprobe);
        if ((*jenv)->ExceptionCheck(jenv)) {
                return (-1);
        }

        return (0);
}

/*ARGSUSED*/
static int
dtj_list_stmt(dtrace_hdl_t *dtp, dtrace_prog_t *pgp,
    dtrace_stmtdesc_t *stp, void *arg)
{
        dtj_java_consumer_t *jc = arg;
        dtrace_ecbdesc_t *edp = stp->dtsd_ecbdesc;

        if (edp == jc->dtjj_consumer->dtjc_last_probe) {
                return (0);
        }

        if (dtrace_probe_iter(dtp, &edp->dted_probe,
            jc->dtjj_consumer->dtjc_plistfunc, arg) != 0) {
                dtj_throw_dtrace_exception(jc,
                    "failed to match %s:%s:%s:%s: %s",
                    edp->dted_probe.dtpd_provider, edp->dted_probe.dtpd_mod,
                    edp->dted_probe.dtpd_func, edp->dted_probe.dtpd_name,
                    dtrace_errmsg(dtp, dtrace_errno(dtp)));
                return (1);
        }

        jc->dtjj_consumer->dtjc_last_probe = edp;
        return (0);
}

/*
 * Protected by global lock in Consumer.java
 */
JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1listCompiledProbes(JNIEnv *env,
    jobject obj, jobject list, jobject program)
{
        dtj_list_compiled_probes(env, obj, list, program, dtj_list_probe);
}

JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1listCompiledProbeDetail(
    JNIEnv *env, jobject obj, jobject list, jobject program)
{
        dtj_list_compiled_probes(env, obj, list, program,
            dtj_list_probe_detail);
}

static void
dtj_list_compiled_probes(JNIEnv *env, jobject obj, jobject list,
    jobject program, dtrace_probe_f *func)
{
        dtj_java_consumer_t jc;
        dtrace_hdl_t *dtp;
        uu_list_walk_t *itr;
        dtj_program_t *p;
        boolean_t found;
        int progid = -1;
        int i;

        if (dtj_get_java_consumer(env, obj, &jc) != DTJ_OK) {
                return; /* java exception pending */
        }
        dtp = jc.dtjj_consumer->dtjc_dtp;
        jc.dtjj_probelist = list;

        (*env)->CallVoidMethod(env, list, g_listclear_jm);
        if ((*env)->ExceptionCheck(env)) {
                return;
        }

        if (program) {
                if (dtj_list_empty(jc.dtjj_consumer->dtjc_program_list)) {
                        dtj_throw_no_such_element(env, "no compiled program");
                        return;
                }
                progid = (*env)->GetIntField(env, program, g_progid_jf);
                if (progid == -1) {
                        dtj_throw_illegal_argument(env, "invalid program");
                        return;
                }
        }

        jc.dtjj_consumer->dtjc_plistfunc = func;
        found = B_FALSE;
        itr = uu_list_walk_start(jc.dtjj_consumer->dtjc_program_list, 0);
        for (i = 0; (p = uu_list_walk_next(itr)) != NULL; ++i) {
                if ((progid != -1) && (progid != i)) {
                        continue;
                }

                found = B_TRUE;
                (void) dtrace_stmt_iter(dtp, p->dtjp_program,
                    (dtrace_stmt_f *)dtj_list_stmt, &jc);
        }
        uu_list_walk_end(itr);

        if (program && !found) {
                dtj_throw_no_such_element(env, "program not found");
        }
}

/*
 * Static LocalConsumer.java method
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT jstring JNICALL
/* ARGSUSED */
Java_org_opensolaris_os_dtrace_LocalConsumer__1getVersion(JNIEnv *env,
    jclass class)
{
        /*
         * Handles the case of locale-specific encoding of the user-visible
         * version string containing non-ASCII characters.
         */
        return (dtj_NewStringNative(env, _dtrace_version));
}

/*
 * Static LocalConsumer.java method
 * Protected by global lock (LocalConsumer.class)
 */
JNIEXPORT jstring JNICALL
/* ARGSUSED */
Java_org_opensolaris_os_dtrace_LocalConsumer__1getExecutableName(JNIEnv *env,
    jclass class)
{
        jstring jname = NULL;
        const char *name = NULL;
        char *s;
        int len;

        name = dtj_getexecname();
        len = strlen(name);
        s = malloc(len + 1);
        if (!s) {
                dtj_throw_out_of_memory(env, "Failed to allocate execname");
                return (NULL);
        }
        (void) strcpy(s, name);
        name = basename(s);
        free(s);
        jname = (*env)->NewStringUTF(env, name);
        return (jname);
}

/*
 * Static LocalConsumer.java method
 */
JNIEXPORT void JNICALL
/* ARGSUSED */
Java_org_opensolaris_os_dtrace_LocalConsumer__1setMaximumConsumers(JNIEnv *env,
    jclass class, jint max)
{
        g_max_consumers = max;
}

/*
 * Static LocalConsumer.java method
 */
JNIEXPORT void JNICALL
/* ARGSUSED */
Java_org_opensolaris_os_dtrace_LocalConsumer__1setDebug(JNIEnv *env,
    jclass class, jboolean debug)
{
        g_dtj_util_debug = debug;
}

JNIEXPORT void JNICALL
Java_org_opensolaris_os_dtrace_LocalConsumer__1destroy(JNIEnv *env, jobject obj)
{
        dtj_consumer_t *c;

        c = dtj_remove_consumer(env, obj);
        if (c == NULL) {
                return; /* java exception pending */
        }
        dtj_consumer_destroy(c);
}