Skip site navigation (1)Skip section navigation (2)
Date:      Sun, 30 Dec 2007 02:23:05 GMT
From:      John Birrell <jb@FreeBSD.org>
To:        Perforce Change Reviews <perforce@freebsd.org>
Subject:   PERFORCE change 132008 for review
Message-ID:  <200712300223.lBU2N5T0065985@repoman.freebsd.org>

next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=132008

Change 132008 by jb@jb_freebsd1 on 2007/12/30 02:22:37

	Work in progress.

Affected files ...

.. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_anon.c#6 edit
.. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_cddl.h#3 edit
.. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_ioctl.c#16 edit
.. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_load.c#16 edit
.. //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_unload.c#14 edit
.. //depot/projects/dtrace/src/sys/contrib/opensolaris/uts/common/dtrace/dtrace.c#4 edit

Differences ...

==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_anon.c#6 (text+ko) ====

@@ -59,128 +59,3 @@
 		(void) dtrace_state_go(state, &dtrace_anon.dta_beganon);
 	}
 }
-
-static dtrace_state_t *
-dtrace_anon_grab(void)
-{
-	dtrace_state_t *state;
-
-	ASSERT(MUTEX_HELD(&dtrace_lock));
-
-	if ((state = dtrace_anon.dta_state) == NULL) {
-		ASSERT(dtrace_anon.dta_enabling == NULL);
-		return (NULL);
-	}
-
-	ASSERT(dtrace_anon.dta_enabling != NULL);
-	ASSERT(dtrace_retained != NULL);
-
-	dtrace_enabling_destroy(dtrace_anon.dta_enabling);
-	dtrace_anon.dta_enabling = NULL;
-	dtrace_anon.dta_state = NULL;
-
-	return (state);
-}
-
-static void
-dtrace_anon_property(void)
-{
-	int i, rv;
-	dtrace_state_t *state;
-	dof_hdr_t *dof;
-	char c[32];		/* enough for "dof-data-" + digits */
-
-	ASSERT(MUTEX_HELD(&dtrace_lock));
-	ASSERT(MUTEX_HELD(&cpu_lock));
-
-	for (i = 0; ; i++) {
-		(void) snprintf(c, sizeof (c), "dof-data-%d", i);
-
-		dtrace_err_verbose = 1;
-
-		if ((dof = dtrace_dof_property(c)) == NULL) {
-			dtrace_err_verbose = 0;
-			break;
-		}
-
-		/*
-		 * We want to create anonymous state, so we need to transition
-		 * the kernel debugger to indicate that DTrace is active.  If
-		 * this fails (e.g. because the debugger has modified text in
-		 * some way), we won't continue with the processing.
-		 */
-		if (kdi_dtrace_set(KDI_DTSET_DTRACE_ACTIVATE) != 0) {
-			cmn_err(CE_NOTE, "kernel debugger active; anonymous "
-			    "enabling ignored.");
-			dtrace_dof_destroy(dof);
-			break;
-		}
-
-		/*
-		 * If we haven't allocated an anonymous state, we'll do so now.
-		 */
-		if ((state = dtrace_anon.dta_state) == NULL) {
-#if defined(sun)
-			state = dtrace_state_create(NULL, NULL);
-#else
-			state = dtrace_state_create(NULL);
-#endif
-			dtrace_anon.dta_state = state;
-
-			if (state == NULL) {
-				/*
-				 * This basically shouldn't happen:  the only
-				 * failure mode from dtrace_state_create() is a
-				 * failure of ddi_soft_state_zalloc() that
-				 * itself should never happen.  Still, the
-				 * interface allows for a failure mode, and
-				 * we want to fail as gracefully as possible:
-				 * we'll emit an error message and cease
-				 * processing anonymous state in this case.
-				 */
-				cmn_err(CE_WARN, "failed to create "
-				    "anonymous state");
-				dtrace_dof_destroy(dof);
-				break;
-			}
-		}
-
-		rv = dtrace_dof_slurp(dof, &state->dts_vstate, CRED(),
-		    &dtrace_anon.dta_enabling, 0, B_TRUE);
-
-		if (rv == 0)
-			rv = dtrace_dof_options(dof, state);
-
-		dtrace_err_verbose = 0;
-		dtrace_dof_destroy(dof);
-
-		if (rv != 0) {
-			/*
-			 * This is malformed DOF; chuck any anonymous state
-			 * that we created.
-			 */
-			ASSERT(dtrace_anon.dta_enabling == NULL);
-			dtrace_state_destroy(state);
-			dtrace_anon.dta_state = NULL;
-			break;
-		}
-
-		ASSERT(dtrace_anon.dta_enabling != NULL);
-	}
-
-	if (dtrace_anon.dta_enabling != NULL) {
-		int rval;
-
-		/*
-		 * dtrace_enabling_retain() can only fail because we are
-		 * trying to retain more enablings than are allowed -- but
-		 * we only have one anonymous enabling, and we are guaranteed
-		 * to be allowed at least one retained enabling; we assert
-		 * that dtrace_enabling_retain() returns success.
-		 */
-		rval = dtrace_enabling_retain(dtrace_anon.dta_enabling);
-		ASSERT(rval == 0);
-
-		dtrace_enabling_dump(dtrace_anon.dta_enabling);
-	}
-}

==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_cddl.h#3 (text+ko) ====

@@ -27,6 +27,8 @@
 
 #include <sys/proc.h>
 
+#define LOCK_LEVEL	10
+
 /*
  * Kernel DTrace extension to 'struct proc' for FreeBSD.
  */
@@ -93,11 +95,40 @@
  * Definitions for fields in struct proc which are named differntly in FreeBSD.
  */
 #define	p_cred		p_ucred
+#define	p_parent	p_pptr
 
 /*
  * Definitions for fields in struct thread which are named differntly in FreeBSD.
  */
 #define	t_procp		td_proc
 #define	t_tid		td_tid
+#define	t_did		td_tid
+
+
+int priv_policy(const cred_t *, int, boolean_t, int, const char *);
+boolean_t priv_policy_only(const cred_t *, int, boolean_t);
+boolean_t priv_policy_choice(const cred_t *, int, boolean_t);
+
+/*
+ * Test privilege. Audit success or failure, allow privilege debugging.
+ * Returns 0 for success, err for failure.
+ */
+#define	PRIV_POLICY(cred, priv, all, err, reason) \
+		priv_policy((cred), (priv), (all), (err), (reason))
+
+/*
+ * Test privilege. Audit success only, no privilege debugging.
+ * Returns 1 for success, and 0 for failure.
+ */
+#define	PRIV_POLICY_CHOICE(cred, priv, all) \
+		priv_policy_choice((cred), (priv), (all))
+
+/*
+ * Test privilege. No priv_debugging, no auditing.
+ * Returns 1 for success, and 0 for failure.
+ */
+
+#define	PRIV_POLICY_ONLY(cred, priv, all) \
+		priv_policy_only((cred), (priv), (all))
 
 #endif	/* !_DTRACE_CDDL_H_ */

==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_ioctl.c#16 (text+ko) ====

@@ -336,7 +336,7 @@
 		}
 
 		if ((dof = dtrace_dof_copyin((uintptr_t) p->dof, &rval)) == NULL)
-			return (rval);
+			return (EINVAL);
 
 		mutex_enter(&cpu_lock);
 		mutex_enter(&dtrace_lock);
@@ -738,10 +738,6 @@
 
 		return (rval);
 	}
-	/* Really handled in upper layer */
-	case FIOASYNC:
-	case FIONBIO:
-		break;
 	default:
 		error = ENOTTY;
 	}

==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_load.c#16 (text+ko) ====

@@ -39,8 +39,7 @@
 	 * XXX This is a short term hack to avoid having to comment
 	 * out lots and lots of lock/unlock calls.
 	 */
-	dtrace_mutex_init(&cpu_lock,"XXX cpu_lock hack");
-	dtrace_mutex_init(&mod_lock,"XXX mod_lock hack");
+	mutex_init(&mod_lock,"XXX mod_lock hack", MUTEX_DEFAULT, NULL);
 
 	/*
 	 * Initialise the mutexes without 'witness' because the dtrace
@@ -50,10 +49,10 @@
 	 * low memory situation. And that low memory situation might be
 	 * the very problem we are trying to trace.
 	 */
-	dtrace_mutex_init(&dtrace_lock,"dtrace probe state");
-	dtrace_mutex_init(&dtrace_provider_lock,"dtrace provider state");
-	dtrace_mutex_init(&dtrace_meta_lock,"dtrace meta-provider state");
-	dtrace_mutex_init(&dtrace_errlock,"dtrace error lock");
+	mutex_init(&dtrace_lock,"dtrace probe state", MUTEX_DEFAULT, NULL);
+	mutex_init(&dtrace_provider_lock,"dtrace provider state", MUTEX_DEFAULT, NULL);
+	mutex_init(&dtrace_meta_lock,"dtrace meta-provider state", MUTEX_DEFAULT, NULL);
+	mutex_init(&dtrace_errlock,"dtrace error lock", MUTEX_DEFAULT, NULL);
 
 	mutex_enter(&cpu_lock);
 	mutex_enter(&dtrace_provider_lock);

==== //depot/projects/dtrace/src/sys/cddl/dev/dtrace/dtrace_unload.c#14 (text+ko) ====

@@ -61,11 +61,13 @@
 		ASSERT(state->dts_necbs == 0);
 		dtrace_state_destroy(state);
 
+#ifdef DOODAD
 		/*
 		 * If we're being detached with anonymous state, we need to
 		 * indicate to the kernel debugger that DTrace is now inactive.
 		 */
 		(void) kdi_dtrace_set(KDI_DTSET_DTRACE_DEACTIVATE);
+#endif
 	}
 
 	bzero(&dtrace_anon, sizeof (dtrace_anon_t));
@@ -145,14 +147,13 @@
 	dtrace_taskq = NULL;
 #endif
 
-	dtrace_mutex_destroy(&dtrace_meta_lock);
-	dtrace_mutex_destroy(&dtrace_provider_lock);
-	dtrace_mutex_destroy(&dtrace_lock);
-	dtrace_mutex_destroy(&dtrace_errlock);
+	mutex_destroy(&dtrace_meta_lock);
+	mutex_destroy(&dtrace_provider_lock);
+	mutex_destroy(&dtrace_lock);
+	mutex_destroy(&dtrace_errlock);
 
 	/* XXX Hack */
-	dtrace_mutex_destroy(&cpu_lock);
-	dtrace_mutex_destroy(&mod_lock);
+	mutex_destroy(&mod_lock);
 
 	/*
 	 * Reset our hook for thread switches, but ensure that vtime isn't

==== //depot/projects/dtrace/src/sys/contrib/opensolaris/uts/common/dtrace/dtrace.c#4 (text) ====

@@ -114,7 +114,9 @@
 #include <sys/limits.h>
 #include <sys/kernel.h>
 #include <sys/malloc.h>
+#include <sys/sysctl.h>
 #include <sys/vmem.h>
+#include <sys/dtrace_bsd.h>
 #include "dtrace_cddl.h"
 #endif
 
@@ -190,14 +192,18 @@
 #endif
 static vmem_t		*dtrace_arena;		/* probe ID arena */
 static vmem_t		*dtrace_minor;		/* minor number arena */
+#if defined(sun)
 static taskq_t		*dtrace_taskq;		/* task queue */
+#endif
 static dtrace_probe_t	**dtrace_probes;	/* array of all probes */
 static int		dtrace_nprobes;		/* number of probes */
 static dtrace_provider_t *dtrace_provider;	/* provider list */
 static dtrace_meta_t	*dtrace_meta_pid;	/* user-land meta provider */
 static int		dtrace_opens;		/* number of opens */
 static int		dtrace_helpers;		/* number of helpers */
+#if defined(sun)
 static void		*dtrace_softstate;	/* softstate pointer */
+#endif
 static dtrace_hash_t	*dtrace_bymod;		/* probes hashed by module */
 static dtrace_hash_t	*dtrace_byfunc;		/* probes hashed by function */
 static dtrace_hash_t	*dtrace_byname;		/* probes hashed by name */
@@ -252,7 +258,6 @@
 MALLOC_DEFINE(M_DTRACE, "dtrace", "Dynamic Trace");
 
 /* XXX FreeBSD hacks. */
-static kmutex_t		cpu_lock;
 static kmutex_t		mod_lock;
 
 #define cr_suid		cr_svuid
@@ -387,6 +392,7 @@
  * no way for a global variable key signature to match a thread-local key
  * signature.
  */
+#if defined(sun)
 #define	DTRACE_TLS_THRKEY(where) { \
 	uint_t intr = 0; \
 	uint_t actv = CPU->cpu_intr_actv >> (LOCK_LEVEL + 1); \
@@ -396,6 +402,18 @@
 	(where) = ((curthread->t_did + DIF_VARIABLE_MAX) & \
 	    (((uint64_t)1 << 61) - 1)) | ((uint64_t)intr << 61); \
 }
+#else
+#define	DTRACE_TLS_THRKEY(where) { \
+	solaris_cpu_t *_c = &solaris_cpu[curcpu]; \
+	uint_t intr = 0; \
+	uint_t actv = _c->cpu_intr_actv >> (LOCK_LEVEL + 1); \
+	for (; actv; actv >>= 1) \
+		intr++; \
+	ASSERT(intr < (1 << 3)); \
+	(where) = ((curthread->td_tid + DIF_VARIABLE_MAX) & \
+	    (((uint64_t)1 << 61) - 1)) | ((uint64_t)intr << 61); \
+}
+#endif
 
 #define	DT_BSWAP_8(x)	((x) & 0xff)
 #define	DT_BSWAP_16(x)	((DT_BSWAP_8(x) << 8) | DT_BSWAP_8((x) >> 8))
@@ -463,7 +481,7 @@
 		 * This address falls within a toxic region; return 0.	\
 		 */							\
 		*flags |= CPU_DTRACE_BADADDR;				\
-		cpu_core[curcpu].cpuc_dtrace_illval = addr;	\
+		cpu_core[curcpu].cpuc_dtrace_illval = addr;		\
 		return (0);						\
 	}								\
 									\
@@ -513,16 +531,20 @@
 static int dtrace_enabling_match(dtrace_enabling_t *, int *);
 static void dtrace_enabling_matchall(void);
 static dtrace_state_t *dtrace_anon_grab(void);
+#if defined(sun)
 static uint64_t dtrace_helper(int, dtrace_mstate_t *,
     dtrace_state_t *, uint64_t, uint64_t);
 static dtrace_helpers_t *dtrace_helpers_create(proc_t *);
+#endif
 static void dtrace_buffer_drop(dtrace_buffer_t *);
 static intptr_t dtrace_buffer_reserve(dtrace_buffer_t *, size_t, size_t,
     dtrace_state_t *, dtrace_mstate_t *);
 static int dtrace_state_option(dtrace_state_t *, dtrace_optid_t,
     dtrace_optval_t);
 static int dtrace_ecb_create_enable(dtrace_probe_t *, void *);
+#if defined(sun)
 static void dtrace_helper_provider_destroy(dtrace_helper_provider_t *);
+#endif
 uint16_t dtrace_load16(uintptr_t);
 uint32_t dtrace_load32(uintptr_t);
 uint64_t dtrace_load64(uintptr_t);
@@ -2124,7 +2146,7 @@
 	dtrace_speculation_t *spec;
 	dtrace_buffer_t *src, *dest;
 	uintptr_t daddr, saddr, dlimit;
-	dtrace_speculation_state_t current, new;
+	dtrace_speculation_state_t current, new = 0;
 	intptr_t offs;
 
 	if (which == 0)
@@ -2260,7 +2282,7 @@
     dtrace_specid_t which)
 {
 	dtrace_speculation_t *spec;
-	dtrace_speculation_state_t current, new;
+	dtrace_speculation_state_t current, new = 0;
 	dtrace_buffer_t *buf;
 
 	if (which == 0)
@@ -2422,7 +2444,7 @@
     dtrace_specid_t which)
 {
 	dtrace_speculation_t *spec;
-	dtrace_speculation_state_t current, new;
+	dtrace_speculation_state_t current, new = 0;
 	dtrace_buffer_t *buf;
 
 	if (which == 0)
@@ -2794,19 +2816,22 @@
 		 */
 		return ((uint64_t)curthread->t_procp->p_ppid);
 #else
-		return ((uint64_t)curproc->p_ppid);
+		return ((uint64_t)curproc->p_pptr->p_pid);
 #endif
 
 	case DIF_VAR_TID:
+#if defined(sun)
 		/*
 		 * See comment in DIF_VAR_PID.
 		 */
 		if (DTRACE_ANCHORED(mstate->dtms_probe) && CPU_ON_INTR(CPU))
 			return (0);
+#endif
 
 		return ((uint64_t)curthread->t_tid);
 
 	case DIF_VAR_EXECNAME:
+#if defined(sun)
 		if (!dtrace_priv_proc(state))
 			return (0);
 
@@ -2825,6 +2850,9 @@
 		return (dtrace_dif_varstr(
 		    (uintptr_t)curthread->t_procp->p_user.u_comm,
 		    state, mstate));
+#else
+		return ((uint64_t)(uintptr_t) curthread->td_proc->p_comm);
+#endif
 
 	case DIF_VAR_ZONENAME:
 #if defined(sun)
@@ -2854,11 +2882,13 @@
 		if (!dtrace_priv_proc(state))
 			return (0);
 
+#if defined(sun)
 		/*
 		 * See comment in DIF_VAR_PID.
 		 */
 		if (DTRACE_ANCHORED(mstate->dtms_probe) && CPU_ON_INTR(CPU))
 			return ((uint64_t)p0.p_cred->cr_uid);
+#endif
 
 		/*
 		 * It is always safe to dereference one's own t_procp pointer:
@@ -2875,11 +2905,13 @@
 		if (!dtrace_priv_proc(state))
 			return (0);
 
+#if defined(sun)
 		/*
 		 * See comment in DIF_VAR_PID.
 		 */
 		if (DTRACE_ANCHORED(mstate->dtms_probe) && CPU_ON_INTR(CPU))
 			return ((uint64_t)p0.p_cred->cr_gid);
+#endif
 
 		/*
 		 * It is always safe to dereference one's own t_procp pointer:
@@ -2893,6 +2925,7 @@
 		return ((uint64_t)curthread->t_procp->p_cred->cr_gid);
 
 	case DIF_VAR_ERRNO: {
+#if defined(sun)
 		klwp_t *lwp;
 		if (!dtrace_priv_proc(state))
 			return (0);
@@ -2913,6 +2946,9 @@
 			return (0);
 
 		return ((uint64_t)lwp->lwp_errno);
+#else
+		return (0);
+#endif
 	}
 	default:
 		DTRACE_CPUFLAG_SET(CPU_DTRACE_ILLOP);
@@ -2936,6 +2972,7 @@
 	volatile uintptr_t *illval = &cpu_core[curcpu].cpuc_dtrace_illval;
 	dtrace_vstate_t *vstate = &state->dts_vstate;
 
+#ifdef DOODAD
 	union {
 		mutex_impl_t mi;
 		uint64_t mx;
@@ -2945,6 +2982,7 @@
 		krwlock_t ri;
 		uintptr_t rw;
 	} r;
+#endif
 
 	switch (subr) {
 	case DIF_SUBR_RAND:
@@ -2952,6 +2990,8 @@
 		break;
 
 	case DIF_SUBR_MUTEX_OWNED:
+#ifdef DOODAD
+	union {
 		if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t),
 		    mstate, vstate)) {
 			regs[rd] = 0;
@@ -2963,9 +3003,12 @@
 			regs[rd] = MUTEX_OWNER(&m.mi) != MUTEX_NO_OWNER;
 		else
 			regs[rd] = LOCK_HELD(&m.mi.m_spin.m_spinlock);
+#endif
 		break;
 
 	case DIF_SUBR_MUTEX_OWNER:
+#ifdef DOODAD
+	union {
 		if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t),
 		    mstate, vstate)) {
 			regs[rd] = 0;
@@ -2978,9 +3021,12 @@
 			regs[rd] = (uintptr_t)MUTEX_OWNER(&m.mi);
 		else
 			regs[rd] = 0;
+#endif
 		break;
 
 	case DIF_SUBR_MUTEX_TYPE_ADAPTIVE:
+#ifdef DOODAD
+	union {
 		if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t),
 		    mstate, vstate)) {
 			regs[rd] = 0;
@@ -2989,9 +3035,12 @@
 
 		m.mx = dtrace_load64(tupregs[0].dttk_value);
 		regs[rd] = MUTEX_TYPE_ADAPTIVE(&m.mi);
+#endif
 		break;
 
 	case DIF_SUBR_MUTEX_TYPE_SPIN:
+#ifdef DOODAD
+	union {
 		if (!dtrace_canload(tupregs[0].dttk_value, sizeof (kmutex_t),
 		    mstate, vstate)) {
 			regs[rd] = 0;
@@ -3000,9 +3049,12 @@
 
 		m.mx = dtrace_load64(tupregs[0].dttk_value);
 		regs[rd] = MUTEX_TYPE_SPIN(&m.mi);
+#endif
 		break;
 
 	case DIF_SUBR_RW_READ_HELD: {
+#ifdef DOODAD
+	union {
 		uintptr_t tmp;
 
 		if (!dtrace_canload(tupregs[0].dttk_value, sizeof (uintptr_t),
@@ -3013,10 +3065,13 @@
 
 		r.rw = dtrace_loadptr(tupregs[0].dttk_value);
 		regs[rd] = _RW_READ_HELD(&r.ri, tmp);
+#endif
 		break;
 	}
 
 	case DIF_SUBR_RW_WRITE_HELD:
+#ifdef DOODAD
+	union {
 		if (!dtrace_canload(tupregs[0].dttk_value, sizeof (krwlock_t),
 		    mstate, vstate)) {
 			regs[rd] = 0;
@@ -3025,9 +3080,12 @@
 
 		r.rw = dtrace_loadptr(tupregs[0].dttk_value);
 		regs[rd] = _RW_WRITE_HELD(&r.ri);
+#endif
 		break;
 
 	case DIF_SUBR_RW_ISWRITER:
+#ifdef DOODAD
+	union {
 		if (!dtrace_canload(tupregs[0].dttk_value, sizeof (krwlock_t),
 		    mstate, vstate)) {
 			regs[rd] = 0;
@@ -3036,6 +3094,7 @@
 
 		r.rw = dtrace_loadptr(tupregs[0].dttk_value);
 		regs[rd] = _RW_ISWRITER(&r.ri);
+#endif
 		break;
 
 	case DIF_SUBR_BCOPY: {
@@ -3469,7 +3528,7 @@
 		uintptr_t tokaddr = tupregs[1].dttk_value;
 		uint64_t size = state->dts_options[DTRACEOPT_STRSIZE];
 		uintptr_t limit, toklimit = tokaddr + size;
-		uint8_t c, tokmap[32];	 /* 256 / 8 */
+		uint8_t c = 0, tokmap[32];	 /* 256 / 8 */
 		char *dest = (char *)mstate->dtms_scratch_ptr;
 		int i;
 
@@ -4421,7 +4480,7 @@
 
 	uint8_t cc_n = 0, cc_z = 0, cc_v = 0, cc_c = 0;
 	int64_t cc_r;
-	uint_t pc = 0, id, opc;
+	uint_t pc = 0, id, opc = 0;
 	uint8_t ttop = 0;
 	dif_instr_t instr;
 	uint_t r1, r2, rd;
@@ -5296,8 +5355,8 @@
 	if (curthread->t_dtrace_sig == 0)
 		curthread->t_dtrace_sig = (uint8_t)sig;
 
+#ifdef DOODAD
 	curthread->t_sig_check = 1;
-#ifdef DOODAD
 	aston(curthread);
 #endif
 }
@@ -5310,8 +5369,8 @@
 
 	if (!curthread->t_dtrace_stop) {
 		curthread->t_dtrace_stop = 1;
+#ifdef DOODAD
 		curthread->t_sig_check = 1;
-#ifdef DOODAD
 		aston(curthread);
 #endif
 	}
@@ -5320,12 +5379,14 @@
 static void
 dtrace_action_chill(dtrace_mstate_t *mstate, hrtime_t val)
 {
+#ifdef DOODAD
 	hrtime_t now;
 	volatile uint16_t *flags;
 #if defined(sun)
 	cpu_t *cpu = CPU;
 #else
-	cpu_t *cpu = pcpu_find(curcpu);
+	cpu_t *c = &solaris_cpu[curcpu];
+	struct pcpu *cpu = pcpu_find(curcpu);
 #endif
 
 	if (dtrace_destructive_disallow)
@@ -5364,6 +5425,7 @@
 	 */
 	mstate->dtms_present &= ~DTRACE_MSTATE_TIMESTAMP;
 	cpu->cpu_dtrace_chilled += val;
+#endif
 }
 
 static void
@@ -5502,6 +5564,7 @@
 	volatile uint16_t *flags;
 	hrtime_t now;
 
+#if defined(sun)
 	/*
 	 * Kick out immediately if this CPU is still being born (in which case
 	 * curthread will be set to -1) or the current thread can't allow
@@ -5509,6 +5572,7 @@
 	 */
 	if (((uintptr_t)curthread & 1) || (curthread->t_flag & T_DONTDTRACE))
 		return;
+#endif
 
 	cookie = dtrace_interrupt_disable();
 	probe = dtrace_probes[id - 1];
@@ -5572,11 +5636,7 @@
 		 * arguments to aggregating actions, one iteration of the
 		 * action loop will use the last iteration's value.
 		 */
-#ifdef lint
 		uint64_t val = 0;
-#else
-		uint64_t val;
-#endif
 
 		mstate.dtms_present = DTRACE_MSTATE_ARGS | DTRACE_MSTATE_PROBE;
 		*flags &= ~CPU_DTRACE_ERROR;
@@ -6382,6 +6442,7 @@
 {
 	uint32_t priv;
 
+#if defined(sun)
 	if (cr == NULL || PRIV_POLICY_ONLY(cr, PRIV_ALL, B_FALSE)) {
 		/*
 		 * For DTRACE_PRIV_ALL, the uid and zoneid don't matter.
@@ -6403,6 +6464,9 @@
 		if (PRIV_POLICY_ONLY(cr, PRIV_PROC_ZONE, B_FALSE))
 			priv |= DTRACE_PRIV_ZONEOWNER;
 	}
+#else
+	priv = DTRACE_PRIV_ALL;
+#endif
 
 	*privp = priv;
 }
@@ -7446,6 +7510,7 @@
 	} while (all && (prv = prv->dtpv_next) != NULL);
 }
 
+#if defined(sun)
 /*
  * Iterate over each probe, and call the Framework-to-Provider API function
  * denoted by offs.
@@ -7486,6 +7551,7 @@
 
 	dtrace_interrupt_enable(cookie);
 }
+#endif
 
 static int
 dtrace_probe_enable(dtrace_probedesc_t *desc, dtrace_enabling_t *enab)
@@ -7657,6 +7723,7 @@
 	dtrace_enabling_matchall();
 }
 
+#if defined(sun)
 static void
 dtrace_helper_provider_remove_one(dof_helper_t *dhp, dof_sec_t *sec, pid_t pid)
 {
@@ -7704,6 +7771,7 @@
 		dtrace_helper_provider_remove_one(dhp, sec, pid);
 	}
 }
+#endif
 
 /*
  * DTrace Meta Provider-to-Framework API Functions
@@ -8243,6 +8311,7 @@
 	return (err);
 }
 
+#if defined(sun)
 /*
  * Validate a DTrace DIF object that it is to be used as a helper.  Helpers
  * are much more constrained than normal DIFOs.  Specifically, they may
@@ -8397,6 +8466,7 @@
 
 	return (err);
 }
+#endif
 
 /*
  * Returns 1 if the expression in the DIF object can be cached on a per-thread
@@ -8482,7 +8552,7 @@
 static void
 dtrace_difo_chunksize(dtrace_difo_t *dp, dtrace_vstate_t *vstate)
 {
-	uint64_t sval;
+	uint64_t sval = 0;
 	dtrace_key_t tupregs[DIF_DTR_NREGS + 2]; /* +2 for thread and id */
 	const dif_instr_t *text = dp->dtdo_buf;
 	uint_t pc, srd = 0;
@@ -8496,7 +8566,7 @@
 		uint_t rd = DIF_INSTR_RD(instr);
 		uint_t r1 = DIF_INSTR_R1(instr);
 		uint_t nkeys = 0;
-		uchar_t scope;
+		uchar_t scope = 0;
 
 		dtrace_key_t *key = tupregs;
 
@@ -8625,10 +8695,10 @@
 
 	for (i = 0; i < dp->dtdo_varlen; i++) {
 		dtrace_difv_t *v = &dp->dtdo_vartab[i];
-		dtrace_statvar_t *svar, ***svarp;
+		dtrace_statvar_t *svar, ***svarp = NULL;
 		size_t dsize = 0;
 		uint8_t scope = v->dtdv_scope;
-		int *np;
+		int *np = NULL;
 
 		if ((id = v->dtdv_id) < DIF_VAR_OTHER_UBASE)
 			continue;
@@ -8727,6 +8797,7 @@
 	dtrace_difo_hold(dp);
 }
 
+#if defined(sun)
 static dtrace_difo_t *
 dtrace_difo_duplicate(dtrace_difo_t *dp, dtrace_vstate_t *vstate)
 {
@@ -8770,6 +8841,7 @@
 	dtrace_difo_init(new, vstate);
 	return (new);
 }
+#endif
 
 static void
 dtrace_difo_destroy(dtrace_difo_t *dp, dtrace_vstate_t *vstate)
@@ -8780,10 +8852,10 @@
 
 	for (i = 0; i < dp->dtdo_varlen; i++) {
 		dtrace_difv_t *v = &dp->dtdo_vartab[i];
-		dtrace_statvar_t *svar, **svarp;
+		dtrace_statvar_t *svar, **svarp = NULL;
 		uint_t id;
 		uint8_t scope = v->dtdv_scope;
-		int *np;
+		int *np = NULL;
 
 		switch (scope) {
 		case DIFV_SCOPE_THREAD:
@@ -9476,7 +9548,7 @@
 	uint16_t format = 0;
 	dtrace_recdesc_t *rec;
 	dtrace_state_t *state = ecb->dte_state;
-	dtrace_optval_t *opt = state->dts_options, nframes, strsize;
+	dtrace_optval_t *opt = state->dts_options, nframes = 0, strsize;
 	uint64_t arg = desc->dtad_arg;
 
 	ASSERT(MUTEX_HELD(&dtrace_lock));
@@ -10061,7 +10133,11 @@
 dtrace_buffer_alloc(dtrace_buffer_t *bufs, size_t size, int flags,
     processorid_t cpu)
 {
+#if defined(sun)
 	cpu_t *cp;
+#else
+	struct pcpu *cp;
+#endif
 	dtrace_buffer_t *buf;
 
 #if defined(sun)
@@ -11116,6 +11192,41 @@
 	return (dof);
 }
 
+#if !defined(sun)
+static __inline uchar_t
+dtrace_dof_char(char c) {
+	switch (c) {
+	case '0':
+	case '1':
+	case '2':
+	case '3':
+	case '4':
+	case '5':
+	case '6':
+	case '7':
+	case '8':
+	case '9':
+		return (c - '0');
+	case 'A':
+	case 'B':
+	case 'C':
+	case 'D':
+	case 'E':
+	case 'F':
+		return (c - 'A' + 10);
+	case 'a':
+	case 'b':
+	case 'c':
+	case 'd':
+	case 'e':
+	case 'f':
+		return (c - 'a' + 10);
+	}
+	/* Should not reach here. */
+	return (0);
+}
+#endif
+
 static dof_hdr_t *
 dtrace_dof_property(const char *name)
 {
@@ -11133,39 +11244,71 @@
 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dtrace_devi, 0,
 	    (char *)name, (int **)&buf, &len) != DDI_PROP_SUCCESS)
 		return (NULL);
-#endif
 
 	for (i = 0; i < len; i++)
 		buf[i] = (uchar_t)(((int *)buf)[i]);
 
 	if (len < sizeof (dof_hdr_t)) {
-#if defined(sun)
 		ddi_prop_free(buf);
-#endif
 		dtrace_dof_error(NULL, "truncated header");
 		return (NULL);
 	}
 
 	if (len < (loadsz = ((dof_hdr_t *)buf)->dofh_loadsz)) {
-#if defined(sun)
 		ddi_prop_free(buf);
-#endif
 		dtrace_dof_error(NULL, "truncated DOF");
 		return (NULL);
 	}
 
 	if (loadsz >= dtrace_dof_maxsize) {
-#if defined(sun)
 		ddi_prop_free(buf);
-#endif
 		dtrace_dof_error(NULL, "oversized DOF");
 		return (NULL);
 	}
 
 	dof = kmem_alloc(loadsz, KM_SLEEP);
 	bcopy(buf, dof, loadsz);
-#if defined(sun)
 	ddi_prop_free(buf);
+#else
+	char *p;
+	char *p_env;
+
+	if ((p_env = getenv(name)) == NULL)
+		return (NULL);
+
+	len = strlen(p_env) / 2;
+
+	buf = kmem_alloc(len, KM_SLEEP);
+
+	dof = (dof_hdr_t *) buf;
+
+	p = p_env;
+
+	for (i = 0; i < len; i++) {
+		buf[i] = (dtrace_dof_char(p[0]) << 4) |
+		     dtrace_dof_char(p[1]);
+		p += 2;
+	}
+
+	freeenv(p_env);
+
+	if (len < sizeof (dof_hdr_t)) {
+		free(buf, M_DTRACE);
+		dtrace_dof_error(NULL, "truncated header");
+		return (NULL);
+	}
+
+	if (len < (loadsz = dof->dofh_loadsz)) {
+		free(buf, M_DTRACE);
+		dtrace_dof_error(NULL, "truncated DOF");
+		return (NULL);
+	}
+
+	if (loadsz >= dtrace_dof_maxsize) {
+		free(buf, M_DTRACE);
+		dtrace_dof_error(NULL, "oversized DOF");
+		return (NULL);
+	}
 #endif
 
 	return (dof);
@@ -11976,7 +12119,7 @@
 /*
  * DTrace Consumer State Functions
  */
-int
+static int
 dtrace_dstate_init(dtrace_dstate_t *dstate, size_t size)
 {
 	size_t hashsize, maxper, min, chunksize = dstate->dtds_chunksize;
@@ -12078,7 +12221,7 @@
 	return (0);
 }
 
-void
+static void
 dtrace_dstate_fini(dtrace_dstate_t *dstate)
 {
 	ASSERT(MUTEX_HELD(&cpu_lock));
@@ -12153,7 +12296,7 @@
 	state->dts_alive = now;
 }
 
-dtrace_state_t *
+static dtrace_state_t *
 #if defined(sun)
 dtrace_state_create(dev_t *devp, cred_t *cr)
 #else
@@ -12389,7 +12532,7 @@
 dtrace_state_buffer(dtrace_state_t *state, dtrace_buffer_t *buf, int which)
 {
 	dtrace_optval_t *opt = state->dts_options, size;
-	processorid_t cpu;
+	processorid_t cpu = 0;;
 	int flags = 0, rval;
 
 	ASSERT(MUTEX_HELD(&dtrace_lock));
@@ -13131,6 +13274,7 @@
 	}

>>> TRUNCATED FOR MAIL (1000 lines) <<<



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200712300223.lBU2N5T0065985>