libdtrace_jni/common/dtrace_jni.c

/*
 * 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.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#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);
}