Index: /trunk/src/VBox/ExtPacks/VBoxDTrace/include/VBoxDTraceTypes.h
===================================================================
--- /trunk/src/VBox/ExtPacks/VBoxDTrace/include/VBoxDTraceTypes.h	(revision 53641)
+++ /trunk/src/VBox/ExtPacks/VBoxDTrace/include/VBoxDTraceTypes.h	(revision 53642)
@@ -37,4 +37,6 @@
 RT_C_DECLS_BEGIN
 
+struct modctl;
+
 typedef unsigned char           uchar_t;
 typedef unsigned int            uint_t;
@@ -58,10 +60,17 @@
     zoneid_t                cr_zone;
 } cred_t;
-#define PRIV_POLICY_ONLY(a_pCred, a_uPriv, a_fAll) (true)
-#define crgetuid(a_pCred)       ((a_pCred)->cr_uid)
-#define crgetzoneid(a_pCred)    ((a_pCred)->cr_zone)
-
-
-typedef struct VBoxDtCyclicId  *cyclic_id_t;
+#define PRIV_POLICY_ONLY(a_pCred, a_uPriv, a_fAll)  (true)
+#define priv_isequalset(a, b)                       (true)
+#define crgetuid(a_pCred)                           ((a_pCred)->cr_uid)
+#define crgetzoneid(a_pCred)                        ((a_pCred)->cr_zone)
+#define crhold(a_pCred)                             VBoxDtCredHold
+#define crfree(a_pCred)                             VBoxDtCredFree
+void VBoxDtCredHold(struct VBoxDtCred *pCred);
+void VBoxDtCredFree(struct VBoxDtCred *pCred);
+
+
+typedef struct RTTIMER  *cyclic_id_t;
+#define CYCLIC_NONE                                 ((struct RTTIMER *)NULL)
+#define cyclic_remove(a_hTimer)                     RTTimerDestroy(a_hTimer)
 
 typedef struct VBoxDtThread
@@ -81,4 +90,5 @@
 {
     uint32_t                p_flag;
+    RTPROCESS               p_pid;
     struct dtrace_helpers  *p_dtrace_helpers;
 } proc_t;
@@ -89,7 +99,5 @@
 
 
-typedef struct VBoxDtDevInfo    dev_info_t;
 typedef struct VBoxDtTaskQueue  taskq_t;
-typedef struct VBoxDtMemCache   kmem_cache_t;
 
 typedef struct VBoxDtMutex
@@ -100,4 +108,5 @@
 #define mutex_exit              VBoxDtMutexExit
 #define MUTEX_HELD(a_pMtx)      VBoxDtMutexIsOwner(a_pMtx)
+#define MUTEX_NOT_HELD(a_pMtx)  (!VBoxDtMutexIsOwner(a_pMtx))
 #define mod_lock                g_DummyMtx
 #define cpu_lock                g_DummyMtx
@@ -157,7 +166,8 @@
 typedef RTUID                   uid_t;
 typedef RTPROCESS               pid_t;
-typedef RTDEV                   dev_t;
 #endif
 
+#define B_FALSE                 (0)
+#define B_TRUE                  (1)
 #define NANOSEC                 RT_NS_1SEC
 #define MILLISEC                RT_MS_1SEC
@@ -165,5 +175,7 @@
 #define NCPU                    RTCPUSET_MAX_CPUS
 #define P2ROUNDUP(uWhat, uAlign)    ( ((uWhat) + (uAlign) - 1) & ~(uAlign - 1) )
+#define IS_P2ALIGNED(uWhat, uAlign) ( !((uWhat) & ((uAlign) - 1)) )
 #define	roundup(uWhat, uUnit)	    ( ( (uWhat) + ((uUnit) - 1)) / (uUnit) * (uUnit) )
+#define MIN(a1, a2)             RT_MIN(a1, a2)
 
 #define CPU_ON_INTR(a_pCpu)     (false)
@@ -194,4 +206,9 @@
  * comparsion warnings. */
 #define VBDTTYPE(a_VBox, a_Org) a_VBox
+/** Mark missing void in a parameter list. */
+#define VBDTVOID                void
+/** Mark missing static in a function definition. */
+#define VBDTSTATIC              static
+#define VBDTUNASS(a_Value)      = a_Value
 
 /*
@@ -207,4 +224,18 @@
 void  VBoxDtKMemFree(void *pvMem, size_t cbMem);
 
+
+typedef struct VBoxDtMemCache   kmem_cache_t;
+#define kmem_cache_create       VBoxDtKMemCacheCreate
+#define kmem_cache_destroy      VBoxDtKMemCacheDestroy
+#define kmem_cache_alloc        VBoxDtKMemCacheAlloc
+#define kmem_cache_free         VBoxDtKMemCacheFree
+struct VBoxDtMemCache *VBoxDtKMemCacheCreate(const char *pszName, size_t cbBuf, size_t cbAlign,
+                                             PFNRT pfnCtor, PFNRT pfnDtor, PFNRT pfnReclaim,
+                                             void *pvUser, void *pvVM, uint32_t fFlags);
+void  VBoxDtKMemCacheDestroy(struct VBoxDtMemCache *pCache);
+void *VBoxDtKMemCacheAlloc(struct VBoxDtMemCache *pCache, uint32_t fFlags);
+void  VBoxDtKMemCacheFree(struct VBoxDtMemCache *pCache, void *pvMem);
+
+
 typedef struct VBoxDtVMem
 {
@@ -214,6 +245,13 @@
 #define VM_SLEEP                RT_BIT(0)
 #define VM_BESTFIT              RT_BIT(1)
+#define VMC_IDENTIFIER          RT_BIT(16)
+#define vmem_create             VBoxDtVMemCreate
+#define vmem_destroy            VBoxDtVMemDestroy
 #define vmem_alloc              VBoxDtVMemAlloc
 #define vmem_free               VBoxDtVMemFree
+struct VBoxDtVMem *VBoxDtVMemCreate(const char *pszName, void *pvBase, size_t cb, size_t cbUnit,
+                                    PFNRT pfnAlloc, PFNRT pfnFree, struct VBoxDtVMem *pSrc,
+                                    size_t cbQCacheMax, uint32_t fFlags);
+void  VBoxDtVMemDestroy(struct VBoxDtVMem *pVMemArena);
 void *VBoxDtVMemAlloc(struct VBoxDtVMem *pVMemArena, size_t cbMem, uint32_t fFlags);
 void  VBoxDtVMemFree(struct VBoxDtVMem *pVMemArena, void *pvMem, size_t cbMem);
@@ -229,4 +267,12 @@
 #define ENOSPC                  (28)
 #define ENOENT                  (2)
+#define EFAULT                  (14)
+#define E2BIG                   (7)
+#define EACCES                  (13)
+#define EALREADY                (114)
+#define ENXIO                   (6)
+#define EAGAIN                  (11)
+#define ENOTTY                  (25)
+#define ESRCH                   (3)
 
 /*
@@ -235,4 +281,54 @@
 #define bcopy(a_pSrc, a_pDst, a_cb) memmove(a_pDst, a_pSrc, a_cb)
 #define bzero(a_pDst, a_cb)         RT_BZERO(a_pDst, a_cb)
+#define bcmp(a_p1, a_p2, a_cb)      memcmp(a_p1, a_p2, a_cb)
+#define snprintf                    RTStrPrintf
+
+/*
+ * Copy In/Out
+ */
+#define copyin                      VBoxDtCopyIn
+#define copyout                     VBoxDtCopyOut
+int  VBoxDtCopyIn(void const *pvUser, void *pvDst, size_t cb);
+int  VBoxDtCopyOut(void const *pvSrc, void *pvUser, size_t cb);
+
+/*
+ * Device numbers.
+ */
+typedef uint64_t                    dev_t;
+typedef uint32_t                    major_t;
+typedef uint32_t                    minor_t;
+#define makedevice(a_Maj, a_Min)    RT_MAKE_U64(a_Min, a_Maj)
+#define getemajor(a_Dev)            RT_HIDWORD(a_Dev)
+#define geteminor(a_Dev)            RT_LODWORD(a_Dev)
+#define getminor(a_Dev)             RT_LODWORD(a_Dev)
+
+/*
+ * DDI
+ */
+#define DDI_SUCCESS                 (0)
+#define DDI_FAILURE                 (-1)
+#define ddi_soft_state_init         VBoxDtDdiSoftStateInit
+#define ddi_soft_state_fini         VBoxDtDdiSoftStateTerm
+#define ddi_soft_state_zalloc       VBoxDtDdiSoftStateAllocZ
+#define ddi_get_soft_state          VBoxDtDdiSoftStateGet
+#define ddi_soft_state_free         VBoxDtDdiSoftStateFree
+int   VBoxDtDdiSoftStateInit(void **ppvSoftStates, size_t cbSoftState, uint32_t cMaxItems);
+int   VBoxDtDdiSoftStateTerm(void **ppvSoftStates);
+int   VBoxDtDdiSoftStateAllocZ(void *pvSoftStates, RTDEV uMinor);
+int   VBoxDtDdiSoftStateFree(void *pvSoftStates, RTDEV uMinor);
+void *VBoxDtDdiSoftStateGet(void *pvSoftStates, RTDEV uMinor);
+
+typedef struct VBoxDtDevInfo        dev_info_t;
+typedef enum { DDI_ATT_CMD_DUMMY }  ddi_attach_cmd_t;
+typedef enum { DDI_DETACH, DDI_SUSPEND }  ddi_detach_cmd_t;
+#define ddi_driver_major            VBoxDtDdiDriverMajor
+#define ddi_report_dev              VBoxDtDdiReportDev
+major_t VBoxDtDdiDriverMajor(struct VBoxDtDevInfo *pDevInfo);
+void    VBoxDtDdiReportDev(struct VBoxDtDevInfo *pDevInfo);
+
+/*
+ * CTF - probably needs to be ported wholesale or smth.
+ */
+#define CTF_MODEL_NATIVE            1
 
 RT_C_DECLS_END
Index: /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/dtrace/dtrace.c
===================================================================
--- /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/dtrace/dtrace.c	(revision 53641)
+++ /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/dtrace/dtrace.c	(revision 53642)
@@ -101,4 +101,5 @@
 # include <iprt/process.h>
 # include <iprt/thread.h>
+# include <iprt/timer.h>
 # include <limits.h>
 
@@ -177,5 +178,7 @@
 static vmem_t		*dtrace_arena;		/* probe ID arena */
 static vmem_t		*dtrace_minor;		/* minor number arena */
+#ifndef VBOX
 static taskq_t		*dtrace_taskq;		/* task queue */
+#endif
 static dtrace_probe_t	**dtrace_probes;	/* array of all probes */
 static VBDTTYPE(uint32_t,int) dtrace_nprobes;		/* number of probes */
@@ -410,5 +413,5 @@
 #define	DTRACE_LOADFUNC(bits)						\
 /*CSTYLED*/								\
-uint##bits##_t								\
+VBDTSTATIC uint##bits##_t						\
 dtrace_load##bits(uintptr_t addr)					\
 {									\
@@ -1116,5 +1119,5 @@
  */
 static int
-dtrace_priv_proc_common_nocd()
+dtrace_priv_proc_common_nocd(VBDTVOID)
 {
 	proc_t *proc;
@@ -1207,5 +1210,5 @@
  * cleaning is explained in detail in <sys/dtrace_impl.h>.
  */
-void
+VBDTSTATIC void
 dtrace_dynvar_clean(dtrace_dstate_t *dstate)
 {
@@ -1347,5 +1350,5 @@
  * will be incremented.
  */
-dtrace_dynvar_t *
+VBDTSTATIC dtrace_dynvar_t *
 dtrace_dynvar(dtrace_dstate_t *dstate, uint_t nkeys,
     dtrace_key_t *key, size_t dsize, dtrace_dynvar_op_t op,
@@ -1836,5 +1839,5 @@
 		}
 	} else {
-		for (i = zero + 1; i < DTRACE_QUANTIZE_NBUCKETS; i++) {
+		for (i = zero + 1; i < VBDTCAST(int)DTRACE_QUANTIZE_NBUCKETS; i++) {
 			if (val < DTRACE_QUANTIZE_BUCKETVAL(i)) {
 				quanta[i - 1] += incr;
@@ -2525,5 +2528,5 @@
 
 		rv = dtrace_cas32((uint32_t *)&spec->dtsp_state, current, new);
-		ASSERT(rv == current);
+		ASSERT(VBDTCAST(dtrace_speculation_state_t)rv == current);
 		spec->dtsp_cleaning = 0;
 	}
@@ -2609,5 +2612,5 @@
  * builtin values such as 'execname' and 'probefunc.'
  */
-uintptr_t
+VBDTSTATIC uintptr_t
 dtrace_dif_varstr(uintptr_t addr, dtrace_state_t *state,
     dtrace_mstate_t *mstate)
@@ -2810,5 +2813,5 @@
 				mstate->dtms_caller = caller[1];
 			} else if ((mstate->dtms_caller =
-			    dtrace_caller(aframes)) == -1) {
+			    dtrace_caller(aframes)) == VBDTCAST(uintptr_t)-1) {
 				/*
 				 * We have failed to do this the quick way;
@@ -3665,5 +3668,5 @@
 		uint8_t c, tokmap[32];	 /* 256 / 8 */
 		char *dest = (char *)mstate->dtms_scratch_ptr;
-		int i;
+		VBDTTYPE(unsigned,int) i;
 
 		/*
@@ -4049,5 +4052,5 @@
 		uintptr_t s1 = tupregs[0].dttk_value;
 		uintptr_t s2 = tupregs[1].dttk_value;
-		int i = 0;
+		VBDTTYPE(unsigned,int) i = 0;
 
 		if (!dtrace_strcanload(s1, size, mstate, vstate) ||
@@ -4273,5 +4276,5 @@
 		}
 
-		for (i = start, j = 0; i <= end && j < size - 1; i++, j++)
+		for (i = start, j = 0; i <= end && VBDTCAST(unsigned)j < size - 1; i++, j++)
 			dest[j] = dtrace_load8(src + i);
 
@@ -4305,5 +4308,5 @@
 			c = dtrace_load8(src + i++);
 next:
-			if (j + 5 >= size)	/* 5 = strlen("/..c\0") */
+			if (j + 5 >= VBDTCAST(int64_t)size)	/* 5 = strlen("/..c\0") */
 				break;
 
@@ -4629,5 +4632,5 @@
 	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 VBDTUNASS(0);
 	uint8_t ttop = 0;
 	dif_instr_t instr;
@@ -5598,5 +5601,5 @@
 	    (nframes * sizeof (uint64_t));
 
-	if (!DTRACE_INSCRATCH(mstate, size)) {
+	if (!DTRACE_INSCRATCH(mstate, VBDTCAST(unsigned)size)) {
 		/*
 		 * Not enough room for our frame pointers -- need to indicate
@@ -5781,5 +5784,5 @@
 		uint64_t val = 0;
 #else
-		uint64_t val;
+		uint64_t val VBDTUNASS(0);
 #endif
 
@@ -9306,5 +9309,5 @@
 		int necbs = state->dts_necbs << 1;
 
-		ASSERT(epid == state->dts_necbs + 1);
+		ASSERT(epid == VBDTCAST(dtrace_epid_t)state->dts_necbs + 1);
 
 		if (necbs == 0) {
@@ -9424,5 +9427,5 @@
 			diff = offs + sizeof (dtrace_aggid_t);
 
-			if (diff = (diff & (sizeof (uint64_t) - 1)))
+			if ((diff = (diff & (sizeof (uint64_t) - 1))))
 				offs += sizeof (uint64_t) - diff;
 
@@ -9639,5 +9642,5 @@
 		int onaggs = state->dts_naggregations;
 
-		ASSERT(aggid == state->dts_naggregations + 1);
+		ASSERT(aggid == VBDTCAST(dtrace_aggid_t)state->dts_naggregations + 1);
 
 		if (naggs == 0) {
@@ -10125,10 +10128,10 @@
 		 */
 		dtrace_ecb_t *cached = dtrace_ecb_create_cache;
-		dtrace_action_t *act = cached->dte_action;
-
-		if (act != NULL) {
-			ASSERT(act->dta_refcnt > 0);
-			act->dta_refcnt++;
-			ecb->dte_action = act;
+		dtrace_action_t *act2 = cached->dte_action;
+
+		if (act2 != NULL) {
+			ASSERT(act2->dta_refcnt > 0);
+			act2->dta_refcnt++;
+			ecb->dte_action = act2;
 			ecb->dte_action_last = cached->dte_action_last;
 			ecb->dte_needed = cached->dte_needed;
@@ -10315,5 +10318,5 @@
     for (iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++) {
 		if (   !RTCpuSetIsMember(&CpuSet, iCpu)
-			|| (cpu != DTRACE_CPUALL && cpu != iCpu))
+			|| (cpu != (processorid_t)DTRACE_CPUALL && cpu != iCpu))
 			continue;
 
@@ -10366,5 +10369,5 @@
 		for (iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++) {
 			if (   !RTCpuSetIsMember(&CpuSet, iCpu)
-				|| (cpu != DTRACE_CPUALL && cpu != iCpu))
+				|| (cpu != (processorid_t)DTRACE_CPUALL && cpu != iCpu))
 				continue;
 
@@ -11280,5 +11283,5 @@
 	 * that the length isn't outrageous.
 	 */
-	if (hdr.dofh_loadsz >= dtrace_dof_maxsize) {
+	if (hdr.dofh_loadsz >= VBDTCAST(uint64_t)dtrace_dof_maxsize) {
 		dtrace_dof_error(&hdr, "load size exceeds maximum");
 		*errp = E2BIG;
@@ -11307,4 +11310,5 @@
 dtrace_dof_property(const char *name)
 {
+#ifndef VBOX
 	uchar_t *buf;
 	uint64_t loadsz;
@@ -11347,4 +11351,7 @@
 
 	return (dof);
+#else  /* VBOX */
+	return (NULL);
+#endif /* VBOX */
 }
 
@@ -11531,5 +11538,5 @@
 
 		for (i = 0; difo[i].section != DOF_SECT_NONE; i++) {
-			if (subsec->dofs_type != difo[i].section)
+			if (subsec->dofs_type != VBDTCAST(uint32_t)difo[i].section)
 				continue;
 
@@ -11539,5 +11546,5 @@
 			}
 
-			if (subsec->dofs_align != difo[i].align) {
+			if (subsec->dofs_align != VBDTCAST(uint32_t)difo[i].align) {
 				dtrace_dof_error(dof, "bad alignment");
 				goto err;
@@ -11552,5 +11559,5 @@
 			}
 
-			if (difo[i].entsize != subsec->dofs_entsize) {
+			if (VBDTCAST(uint32_t)difo[i].entsize != subsec->dofs_entsize) {
 				dtrace_dof_error(dof, "entry size mismatch");
 				goto err;
@@ -11601,5 +11608,5 @@
 	 * setting of the option.
 	 */
-	for (i = 0; i < dp->dtdo_varlen; i++) {
+	for (i = 0; VBDTCAST(unsigned)i < dp->dtdo_varlen; i++) {
 		dtrace_difv_t *v = &dp->dtdo_vartab[i];
 		dtrace_diftype_t *t = &v->dtdv_type;
@@ -12110,5 +12117,5 @@
 	dof_optdesc_t *desc;
 
-	for (i = 0; i < dof->dofh_secnum; i++) {
+	for (i = 0; VBDTCAST(unsigned)i < dof->dofh_secnum; i++) {
 		dof_sec_t *sec = (dof_sec_t *)((uintptr_t)dof +
 		    (uintptr_t)dof->dofh_secoff + i * dof->dofh_secsize);
@@ -12142,5 +12149,5 @@
 			}
 
-			if (desc->dofo_value == DTRACEOPT_UNSET) {
+			if (desc->dofo_value == VBDTCAST(uint64_t)DTRACEOPT_UNSET) {
 				dtrace_dof_error(dof, "unset option");
 				return (EINVAL);
@@ -12161,5 +12168,5 @@
  * DTrace Consumer State Functions
  */
-int
+VBDTSTATIC int
 dtrace_dstate_init(dtrace_dstate_t *dstate, size_t size)
 {
@@ -12168,5 +12175,5 @@
 	uintptr_t limit;
 	dtrace_dynvar_t *dvar, *next, *start;
-	int i;
+	VBDTTYPE(size_t,int) i;
 
 	ASSERT(MUTEX_HELD(&dtrace_lock));
@@ -12259,5 +12266,5 @@
 }
 
-void
+VBDTSTATIC void
 dtrace_dstate_fini(dtrace_dstate_t *dstate)
 {
@@ -12306,4 +12313,11 @@
 	dtrace_speculation_clean(state);
 }
+#ifdef VBOX
+static DECLCALLBACK(void) dtrace_state_clean_timer(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
+{
+    dtrace_state_clean((dtrace_state_t *)pvUser);
+    NOREF(pTimer); NOREF(iTick);
+}
+#endif
 
 static void
@@ -12334,5 +12348,13 @@
 }
 
-dtrace_state_t *
+#ifdef VBOX
+static DECLCALLBACK(void) dtrace_state_deadman_timer(PRTTIMER pTimer, void *pvUser, uint64_t iTick)
+{
+    dtrace_state_deadman((dtrace_state_t *)pvUser);
+    NOREF(pTimer); NOREF(iTick);
+}
+#endif
+
+VBDTSTATIC dtrace_state_t *
 dtrace_state_create(dev_t *devp, cred_t *cr)
 {
@@ -12573,5 +12595,5 @@
 	}
 
-	for (size = opt[which]; size >= sizeof (uint64_t); size >>= 1) {
+	for (size = opt[which]; size >= VBDTCAST(dtrace_optval_t)sizeof (uint64_t); size >>= 1) {
 		/*
 		 * The size must be 8-byte aligned.  If the size is not 8-byte
@@ -12660,6 +12682,8 @@
 	dtrace_speculation_t *spec;
 	dtrace_buffer_t *buf;
+#ifndef VBOX
 	cyc_handler_t hdlr;
 	cyc_time_t when;
+#endif
 	int rval = 0, i, bufsize = NCPU * sizeof (dtrace_buffer_t);
 	dtrace_icookie_t cookie;
@@ -12768,5 +12792,5 @@
 			 */
 			if (opt[DTRACEOPT_BUFSIZE] == DTRACEOPT_UNSET ||
-			    opt[DTRACEOPT_BUFSIZE] < state->dts_needed) {
+			    opt[DTRACEOPT_BUFSIZE] < VBDTCAST(dtrace_optval_t)state->dts_needed) {
 				opt[DTRACEOPT_BUFSIZE] = state->dts_needed;
 			}
@@ -12839,4 +12863,5 @@
 		opt[DTRACEOPT_CLEANRATE] = dtrace_cleanrate_max;
 
+#ifndef VBOX
 	hdlr.cyh_func = (cyc_func_t)dtrace_state_clean;
 	hdlr.cyh_arg = state;
@@ -12857,4 +12882,24 @@
 	state->dts_alive = state->dts_laststatus = dtrace_gethrtime();
 	state->dts_deadman = cyclic_add(&hdlr, &when);
+#else  /* VBOX */
+
+	rval = RTTimerCreateEx(&state->dts_cleaner, opt[DTRACEOPT_CLEANRATE],
+			       RTTIMER_FLAGS_CPU_ANY, dtrace_state_clean_timer, state);
+	if (RT_FAILURE(rval)) {
+	    rval = RTErrConvertToErrno(rval);
+	    goto err;
+	}
+
+	state->dts_alive = state->dts_laststatus = dtrace_gethrtime();
+	rval = RTTimerCreateEx(&state->dts_deadman, dtrace_deadman_interval,
+			       RTTIMER_FLAGS_CPU_ANY, dtrace_state_deadman_timer, state);
+	if (RT_FAILURE(rval)) {
+	    RTTimerDestroy(state->dts_cleaner);
+	    state->dts_cleaner = CYCLIC_NONE;
+	    state->dts_deadman = CYCLIC_NONE;
+	    rval = RTErrConvertToErrno(rval);
+	    goto err;
+	}
+#endif /* VBOX */
 
 	state->dts_activity = DTRACE_ACTIVITY_WARMUP;
@@ -13196,4 +13241,5 @@
 		}
 
+#ifndef VBOX
 		/*
 		 * We want to create anonymous state, so we need to transition
@@ -13208,4 +13254,5 @@
 			break;
 		}
+#endif
 
 		/*
@@ -13288,5 +13335,5 @@
 		return;
 
-	ASSERT(vstate->dtvs_nlocals <= dtrace_helptrace_nlocals);
+	ASSERT(vstate->dtvs_nlocals <= VBDTCAST(int32_t)dtrace_helptrace_nlocals);
 
 	/*
@@ -13303,5 +13350,5 @@
 		next = dtrace_helptrace_next;
 
-		if (next + size < dtrace_helptrace_bufsize) {
+		if (next + size < VBDTCAST(unsigned)dtrace_helptrace_bufsize) {
 			nnext = next + size;
 		} else {
@@ -13326,5 +13373,5 @@
 	ent->dtht_illval = cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_illval;
 
-	for (i = 0; i < vstate->dtvs_nlocals; i++) {
+	for (i = 0; VBDTCAST(int32_t)i < vstate->dtvs_nlocals; i++) {
 		dtrace_statvar_t *svar;
 
@@ -13342,5 +13389,5 @@
     dtrace_state_t *state, uint64_t arg0, uint64_t arg1)
 {
-	uint16_t *flags = &cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags;
+	VBDTTYPE(uint16_t volatile *, uint16_t *)flags = &cpu_core[VBDT_GET_CPUID()].cpuc_dtrace_flags;
 	uint64_t sarg0 = mstate->dtms_arg[0];
 	uint64_t sarg1 = mstate->dtms_arg[1];
@@ -13454,5 +13501,5 @@
 	dtrace_helpers_t *help = p->p_dtrace_helpers;
 	dtrace_vstate_t *vstate;
-	int i;
+	VBDTTYPE(uint_t,int) i;
 
 	ASSERT(MUTEX_HELD(&dtrace_lock));
@@ -13618,5 +13665,5 @@
 	}
 
-	if (vstate->dtvs_nlocals > dtrace_helptrace_nlocals) {
+	if (vstate->dtvs_nlocals > VBDTCAST(int32_t)dtrace_helptrace_nlocals) {
 		dtrace_helptrace_nlocals = vstate->dtvs_nlocals;
 		dtrace_helptrace_next = 0;
@@ -13676,5 +13723,5 @@
 		 */
 
-		int i;
+		VBDTTYPE(uint_t,int) i;
 		mutex_exit(&dtrace_lock);
 
@@ -14009,5 +14056,5 @@
 	 */
 	if (dhp != NULL) {
-		for (i = 0; i < dof->dofh_secnum; i++) {
+		for (i = 0; i < VBDTCAST(int)dof->dofh_secnum; i++) {
 			dof_sec_t *sec = (dof_sec_t *)(uintptr_t)(daddr +
 			    dof->dofh_secoff + i * dof->dofh_secsize);
@@ -14104,5 +14151,5 @@
 	dtrace_vstate_t *vstate;
 	proc_t *p = curproc;
-	int i;
+	VBDTTYPE(uint_t, int) i;
 
 	mutex_enter(&dtrace_lock);
@@ -14232,9 +14279,9 @@
 
 			for (j = 0; j < new->dtha_nactions; j++) {
-				dtrace_difo_t *dp = helper->dtha_actions[j];
-
-				ASSERT(dp != NULL);
-				dp = dtrace_difo_duplicate(dp, vstate);
-				new->dtha_actions[j] = dp;
+				dtrace_difo_t *dp2 = helper->dtha_actions[j];
+
+				ASSERT(dp2 != NULL);
+				dp2 = dtrace_difo_duplicate(dp2, vstate);
+				new->dtha_actions[j] = dp2;
 			}
 
@@ -14258,5 +14305,5 @@
 		newhelp->dthps_provs = kmem_alloc(newhelp->dthps_nprovs *
 		    sizeof (dtrace_helper_provider_t *), KM_SLEEP);
-		for (i = 0; i < newhelp->dthps_nprovs; i++) {
+		for (i = 0; i < VBDTCAST(int)newhelp->dthps_nprovs; i++) {
 			newhelp->dthps_provs[i] = help->dthps_provs[i];
 			newhelp->dthps_provs[i]->dthp_ref++;
@@ -14271,4 +14318,6 @@
 		dtrace_helper_provider_register(to, newhelp, NULL);
 }
+
+#ifndef VBOX
 
 /*
@@ -14422,5 +14471,7 @@
 }
 
-void
+#endif /* !VBOX */
+
+VBDTSTATIC void
 dtrace_suspend(void)
 {
@@ -14428,9 +14479,18 @@
 }
 
-void
+VBDTSTATIC void
 dtrace_resume(void)
 {
 	dtrace_probe_foreach(offsetof(dtrace_pops_t, dtps_resume));
 }
+
+#ifdef VBOX
+typedef enum {
+    CPU_INVALID,
+    CPU_CONFIG,
+    CPU_UNCONFIG
+} cpu_setup_t;
+#endif
+
 
 static int
@@ -14493,4 +14553,5 @@
 }
 
+#ifndef VBOX
 static void
 dtrace_cpu_setup_initial(processorid_t cpu)
@@ -14498,4 +14559,5 @@
 	(void) dtrace_cpu_setup(CPU_CONFIG, cpu);
 }
+#endif /* !VBOX */
 
 static void
@@ -14560,4 +14622,5 @@
 	}
 
+#ifndef VBOX
 	if (ddi_create_minor_node(devi, DTRACEMNR_DTRACE, S_IFCHR,
 	    DTRACEMNRN_DTRACE, DDI_PSEUDO, NULL) == DDI_FAILURE ||
@@ -14572,8 +14635,10 @@
 		return (DDI_FAILURE);
 	}
+#endif
 
 	ddi_report_dev(devi);
 	dtrace_devi = devi;
 
+#ifndef VBOX
 	dtrace_modload = dtrace_module_loaded;
 	dtrace_modunload = dtrace_module_unloaded;
@@ -14587,4 +14652,7 @@
 
 	register_cpu_setup_func((cpu_setup_func_t *)dtrace_cpu_setup, NULL);
+#else
+	/** @todo some of these hooks needs checking out! */
+#endif
 
 	ASSERT(MUTEX_HELD(&cpu_lock));
@@ -14595,6 +14663,8 @@
 	    UINT32_MAX - DTRACEMNRN_CLONE, 1, NULL, NULL, NULL, 0,
 	    VM_SLEEP | VMC_IDENTIFIER);
+#ifndef VBOX
 	dtrace_taskq = taskq_create("dtrace_taskq", 1, maxclsyspri,
 	    1, INT_MAX, 0);
+#endif
 
 	dtrace_state_cache = kmem_cache_create("dtrace_state_cache",
@@ -14745,4 +14815,5 @@
 	dtrace_membar_producer();
 
+#ifndef VBOX
 	/*
 	 * If the kernel debugger is active (that is, if the kernel debugger
@@ -14755,4 +14826,5 @@
 		return (EBUSY);
 	}
+#endif
 
 	state = dtrace_state_create(devp, cred_p);
@@ -14760,6 +14832,8 @@
 
 	if (state == NULL) {
+#ifndef VBOX
 		if (--dtrace_opens == 0 && dtrace_anon.dta_enabling == NULL)
 			(void) kdi_dtrace_set(KDI_DTSET_DTRACE_DEACTIVATE);
+#endif
 		mutex_exit(&dtrace_lock);
 		return (EAGAIN);
@@ -14797,4 +14871,5 @@
 	ASSERT(dtrace_opens > 0);
 
+#ifndef VBOX
 	/*
 	 * Only relinquish control of the kernel debugger interface when there
@@ -14803,4 +14878,5 @@
 	if (--dtrace_opens == 0 && dtrace_anon.dta_enabling == NULL)
 		(void) kdi_dtrace_set(KDI_DTSET_DTRACE_DEACTIVATE);
+#endif
 
 	mutex_exit(&dtrace_lock);
@@ -15366,5 +15442,5 @@
 			return (EFAULT);
 
-		if (desc.dtbd_cpu < 0 || desc.dtbd_cpu >= NCPU)
+		if (/*VBox value is is unsigned: desc.dtbd_cpu < 0 ||*/ desc.dtbd_cpu >= NCPU)
 			return (EINVAL);
 
@@ -15671,4 +15747,5 @@
 		dtrace_state_destroy(state);
 
+#ifndef VBOX
 		/*
 		 * If we're being detached with anonymous state, we need to
@@ -15676,8 +15753,11 @@
 		 */
 		(void) kdi_dtrace_set(KDI_DTSET_DTRACE_DEACTIVATE);
+#endif
 	}
 
 	bzero(&dtrace_anon, sizeof (dtrace_anon_t));
+#ifndef VBOX /** @todo CPU hooks */
 	unregister_cpu_setup_func((cpu_setup_func_t *)dtrace_cpu_setup, NULL);
+#endif
 	dtrace_cpu_init = NULL;
 	dtrace_helpers_cleanup = NULL;
@@ -15720,5 +15800,7 @@
 	}
 
+#ifndef VBOX
 	ddi_remove_minor_node(dtrace_devi, NULL);
+#endif
 	dtrace_devi = NULL;
 
@@ -15740,10 +15822,13 @@
 	 * performing any operation.
 	 */
+#ifndef VBOX
 	taskq_destroy(dtrace_taskq);
 	dtrace_taskq = NULL;
+#endif
 
 	return (DDI_SUCCESS);
 }
 
+#ifndef VBOX
 /*ARGSUSED*/
 static int
@@ -15829,2 +15914,4 @@
 	return (mod_remove(&modlinkage));
 }
+
+#endif /* !VBOX */
Index: /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/sys/dtrace.h
===================================================================
--- /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/sys/dtrace.h	(revision 53641)
+++ /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/sys/dtrace.h	(revision 53642)
@@ -467,5 +467,5 @@
 	(((sizeof (uint64_t) * NBBY) - 1) * 2 + 1)
 
-#define	DTRACE_QUANTIZE_ZEROBUCKET	((sizeof (uint64_t) * NBBY) - 1)
+#define	DTRACE_QUANTIZE_ZEROBUCKET	(VBDTCAST(int)(sizeof (uint64_t) * NBBY) - 1)
 
 #define	DTRACE_QUANTIZE_BUCKETVAL(buck)					\
@@ -2196,11 +2196,11 @@
 extern void (*dtrace_modload)(struct modctl *);
 extern void (*dtrace_modunload)(struct modctl *);
-extern void (*dtrace_helpers_cleanup)();
+extern void (*dtrace_helpers_cleanup)(VBDTVOID);
 extern void (*dtrace_helpers_fork)(proc_t *parent, proc_t *child);
-extern void (*dtrace_cpustart_init)();
-extern void (*dtrace_cpustart_fini)();
-
-extern void (*dtrace_debugger_init)();
-extern void (*dtrace_debugger_fini)();
+extern void (*dtrace_cpustart_init)(VBDTVOID);
+extern void (*dtrace_cpustart_fini)(VBDTVOID);
+
+extern void (*dtrace_debugger_init)(VBDTVOID);
+extern void (*dtrace_debugger_fini)(VBDTVOID);
 extern dtrace_cacheid_t dtrace_predcache_id;
 
Index: /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/sys/dtrace_impl.h
===================================================================
--- /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/sys/dtrace_impl.h	(revision 53641)
+++ /trunk/src/VBox/ExtPacks/VBoxDTrace/onnv/uts/common/sys/dtrace_impl.h	(revision 53642)
@@ -1262,5 +1262,5 @@
 extern int dtrace_assfail(const char *, const char *, int);
 extern int dtrace_attached(void);
-extern hrtime_t dtrace_gethrestime();
+extern hrtime_t dtrace_gethrestime(void);
 
 #ifdef __sparc