SUPDrv-dtrace.cpp@ 68317

Last change on this file since 68317 was 64584, checked in by vboxsync, 8 years ago
SUPDrv-dtrace.cpp: the dtrace_register/invalidate/unregister APIs could perhaps mess up the AC flag, so safe+restore flags.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 41.6 KB

Line
1	/* $Id: SUPDrv-dtrace.cpp 64584 2016-11-04 19:08:09Z vboxsync $ */
2	/** @file
3	* VBoxDrv - The VirtualBox Support Driver - DTrace Provider.
4	*/
5
6	/*
7	* Copyright (C) 2012-2016 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*/
26
27
28	/*********************************************************************************************************************************
29	* Header Files *
30	*********************************************************************************************************************************/
31	#define LOG_GROUP LOG_GROUP_SUP_DRV
32	#include "SUPDrvInternal.h"
33
34	#include <VBox/err.h>
35	#include <VBox/log.h>
36	#include <VBox/VBoxTpG.h>
37
38	#include <iprt/assert.h>
39	#include <iprt/ctype.h>
40	#include <iprt/mem.h>
41	#include <iprt/errno.h>
42	#ifdef RT_OS_DARWIN
43	# include <iprt/dbg.h>
44	#endif
45
46	#ifdef RT_OS_DARWIN
47	# include VBOX_PATH_MACOSX_DTRACE_H
48	#elif defined(RT_OS_LINUX)
49	/* Avoid type and define conflicts. */
50	# undef UINT8_MAX
51	# undef UINT16_MAX
52	# undef UINT32_MAX
53	# undef UINT64_MAX
54	# undef INT64_MAX
55	# undef INT64_MIN
56	# define intptr_t dtrace_intptr_t
57
58	# if 0
59	/* DTrace experiments with the Unbreakable Enterprise Kernel (UEK2)
60	(Oracle Linux).
61	1. The dtrace.h here is from the dtrace module source, not
62	/usr/include/sys/dtrace.h nor /usr/include/dtrace.h.
63	2. To generate the missing entries for the dtrace module in Module.symvers
64	of UEK:
65	nm /lib/modules/....../kernel/drivers/dtrace/dtrace.ko \
66	\| grep _crc_ \
67	\| sed -e 's/^......../0x/' -e 's/ A __crc_/\t/' \
68	-e 's/$/\tdrivers\/dtrace\/dtrace\tEXPORT_SYMBOL/' \
69	>> Module.symvers
70	Update: Althernative workaround (active), resolve symbols dynamically.
71	3. No tracepoints in vboxdrv, vboxnet* or vboxpci yet. This requires yasm
72	and VBoxTpG and build time. */
73	# include "dtrace.h"
74	# else
75	/* DTrace experiments with the Unbreakable Enterprise Kernel (UEKR3)
76	(Oracle Linux).
77	1. To generate the missing entries for the dtrace module in Module.symvers
78	of UEK:
79	nm /lib/modules/....../kernel/drivers/dtrace/dtrace.ko \
80	\| grep _crc_ \
81	\| sed -e 's/^......../0x/' -e 's/ A __crc_/\t/' \
82	-e 's/$/\tdrivers\/dtrace\/dtrace\tEXPORT_SYMBOL/' \
83	>> Module.symvers
84	Update: Althernative workaround (active), resolve symbols dynamically.
85	2. No tracepoints in vboxdrv, vboxnet* or vboxpci yet. This requires yasm
86	and VBoxTpG and build time. */
87	# include <dtrace/provider.h>
88	# include <dtrace/enabling.h> /* Missing from provider.h. */
89	# include <dtrace/arg.h> /* Missing from provider.h. */
90	# endif
91	# include <linux/kallsyms.h>
92	/** Status code fixer (UEK uses linux convension unlike the others). */
93	# define FIX_UEK_RC(a_rc) (-(a_rc))
94	#else
95	# include <sys/dtrace.h>
96	#endif
97
98
99	/**
100	* The UEK DTrace port is trying to be smart and seems to have turned all
101	* errno return codes negative. While this conforms to the linux kernel way of
102	* doing things, it breaks with the way the interfaces work on Solaris and
103	* Mac OS X.
104	*/
105	#ifndef FIX_UEK_RC
106	# define FIX_UEK_RC(a_rc) (a_rc)
107	#endif
108
109
110	/** @name Macros for preserving EFLAGS.AC (despair / paranoid)
111	* @remarks We have to restore it unconditionally on darwin.
112	* @{ */
113	#if defined(RT_OS_DARWIN) \
114	\|\| ( defined(RT_OS_LINUX) \
115	&& (defined(CONFIG_X86_SMAP) \|\| defined(RT_STRICT) \|\| defined(IPRT_WITH_EFLAGS_AC_PRESERVING) ) )
116	# include <iprt/asm-amd64-x86.h>
117	# include <iprt/x86.h>
118	# define SUPDRV_SAVE_EFL_AC() RTCCUINTREG const fSavedEfl = ASMGetFlags();
119	# define SUPDRV_RESTORE_EFL_AC() ASMSetFlags(fSavedEfl)
120	# define SUPDRV_RESTORE_EFL_ONLY_AC() ASMChangeFlags(~X86_EFL_AC, fSavedEfl & X86_EFL_AC)
121	#else
122	# define SUPDRV_SAVE_EFL_AC() do { } while (0)
123	# define SUPDRV_RESTORE_EFL_AC() do { } while (0)
124	# define SUPDRV_RESTORE_EFL_ONLY_AC() do { } while (0)
125	#endif
126	/** @} */
127
128
129	/*********************************************************************************************************************************
130	* Structures and Typedefs *
131	*********************************************************************************************************************************/
132	/* Seems there is some return code difference here. Keep the return code and
133	case it to whatever the host desires. */
134	#ifdef RT_OS_DARWIN
135	# if MAC_OS_X_VERSION_MIN_REQUIRED < 1070
136	typedef void FNPOPS_ENABLE(void , dtrace_id_t, void );
137	# else
138	typedef int FNPOPS_ENABLE(void , dtrace_id_t, void );
139	# endif
140	#else
141	typedef int FNPOPS_ENABLE(void , dtrace_id_t, void );
142	#endif
143
144	/** Caller indicator. */
145	typedef enum VBOXDTCALLER
146	{
147	kVBoxDtCaller_Invalid = 0,
148	kVBoxDtCaller_Generic,
149	kVBoxDtCaller_ProbeFireUser,
150	kVBoxDtCaller_ProbeFireKernel
151	} VBOXDTCALLER;
152
153
154	/**
155	* Stack data planted before calling dtrace_probe so that we can easily find the
156	* stack argument later.
157	*/
158	typedef struct VBDTSTACKDATA
159	{
160	/** Eyecatcher no. 1 (SUPDRVDT_STACK_DATA_MAGIC2). */
161	uint32_t u32Magic1;
162	/** Eyecatcher no. 2 (SUPDRVDT_STACK_DATA_MAGIC2). */
163	uint32_t u32Magic2;
164	/** The format of the caller specific data. */
165	VBOXDTCALLER enmCaller;
166	/** Caller specific data. */
167	union
168	{
169	/** kVBoxDtCaller_ProbeFireKernel. */
170	struct
171	{
172	/** Pointer to the stack arguments of a probe function call. */
173	uintptr_t *pauStackArgs;
174	} ProbeFireKernel;
175	/** kVBoxDtCaller_ProbeFireUser. */
176	struct
177	{
178	/** The user context. */
179	PCSUPDRVTRACERUSRCTX pCtx;
180	/** The argument displacement caused by 64-bit arguments passed directly to
181	* dtrace_probe. */
182	int offArg;
183	} ProbeFireUser;
184	} u;
185	/** Pointer to this structure.
186	* This is the final bit of integrity checking. */
187	struct VBDTSTACKDATA *pSelf;
188	} VBDTSTACKDATA;
189	/** Pointer to the on-stack thread specific data. */
190	typedef VBDTSTACKDATA *PVBDTSTACKDATA;
191
192
193	/*********************************************************************************************************************************
194	* Defined Constants And Macros *
195	*********************************************************************************************************************************/
196	/** The first magic value. */
197	#define SUPDRVDT_STACK_DATA_MAGIC1 RT_MAKE_U32_FROM_U8('S', 'U', 'P', 'D')
198	/** The second magic value. */
199	#define SUPDRVDT_STACK_DATA_MAGIC2 RT_MAKE_U32_FROM_U8('D', 'T', 'r', 'c')
200
201	/** The alignment of the stack data.
202	* The data doesn't require more than sizeof(uintptr_t) alignment, but the
203	* greater alignment the quicker lookup. */
204	#define SUPDRVDT_STACK_DATA_ALIGN 32
205
206	/** Plants the stack data. */
207	#define VBDT_SETUP_STACK_DATA(a_enmCaller) \
208	uint8_t abBlob[sizeof(VBDTSTACKDATA) + SUPDRVDT_STACK_DATA_ALIGN - 1]; \
209	PVBDTSTACKDATA pStackData = (PVBDTSTACKDATA)( (uintptr_t)&abBlob[SUPDRVDT_STACK_DATA_ALIGN - 1] \
210	& ~(uintptr_t)(SUPDRVDT_STACK_DATA_ALIGN - 1)); \
211	pStackData->u32Magic1 = SUPDRVDT_STACK_DATA_MAGIC1; \
212	pStackData->u32Magic2 = SUPDRVDT_STACK_DATA_MAGIC2; \
213	pStackData->enmCaller = a_enmCaller; \
214	pStackData->pSelf = pStackData
215
216	/** Passifies the stack data and frees up resource held within it. */
217	#define VBDT_CLEAR_STACK_DATA() \
218	do \
219	{ \
220	pStackData->u32Magic1 = 0; \
221	pStackData->u32Magic2 = 0; \
222	pStackData->pSelf = NULL; \
223	} while (0)
224
225	/** Simple SUPR0Printf-style logging. */
226	#if 0 /def DEBUG_bird/
227	# define LOG_DTRACE(a) SUPR0Printf a
228	#else
229	# define LOG_DTRACE(a) do { } while (0)
230	#endif
231
232
233	/*********************************************************************************************************************************
234	* Global Variables *
235	*********************************************************************************************************************************/
236	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX)
237	/** @name DTrace kernel interface used on Darwin and Linux.
238	* @{ */
239	static void (* g_pfnDTraceProbeFire)(dtrace_id_t, uint64_t, uint64_t, uint64_t, uint64_t, uint64_t);
240	static dtrace_id_t (* g_pfnDTraceProbeCreate)(dtrace_provider_id_t, const char , const char , const char , int, void );
241	static dtrace_id_t (* g_pfnDTraceProbeLookup)(dtrace_provider_id_t, const char , const char , const char *);
242	static int (* g_pfnDTraceProviderRegister)(const char , const dtrace_pattr_t , uint32_t, /cred_t/ void *,
243	const dtrace_pops_t , void , dtrace_provider_id_t *);
244	static void (* g_pfnDTraceProviderInvalidate)(dtrace_provider_id_t);
245	static int (* g_pfnDTraceProviderUnregister)(dtrace_provider_id_t);
246
247	#define dtrace_probe g_pfnDTraceProbeFire
248	#define dtrace_probe_create g_pfnDTraceProbeCreate
249	#define dtrace_probe_lookup g_pfnDTraceProbeLookup
250	#define dtrace_register g_pfnDTraceProviderRegister
251	#define dtrace_invalidate g_pfnDTraceProviderInvalidate
252	#define dtrace_unregister g_pfnDTraceProviderUnregister
253
254	/** @} */
255	#endif
256
257
258	/**
259	* Gets the stack data.
260	*
261	* @returns Pointer to the stack data. Never NULL.
262	*/
263	static PVBDTSTACKDATA vboxDtGetStackData(void)
264	{
265	/*
266	* Locate the caller of probe_dtrace.
267	*/
268	int volatile iDummy = 1; /* use this to get the stack address. */
269	PVBDTSTACKDATA pData = (PVBDTSTACKDATA)( ((uintptr_t)&iDummy + SUPDRVDT_STACK_DATA_ALIGN - 1)
270	& ~(uintptr_t)(SUPDRVDT_STACK_DATA_ALIGN - 1));
271	for (;;)
272	{
273	if ( pData->u32Magic1 == SUPDRVDT_STACK_DATA_MAGIC1
274	&& pData->u32Magic2 == SUPDRVDT_STACK_DATA_MAGIC2
275	&& pData->pSelf == pData)
276	return pData;
277	pData = (PVBDTSTACKDATA)((uintptr_t)pData + SUPDRVDT_STACK_DATA_ALIGN);
278	}
279	}
280
281
282	/*
283	*
284	* Helpers for handling VTG structures.
285	* Helpers for handling VTG structures.
286	* Helpers for handling VTG structures.
287	*
288	*/
289
290
291
292	/**
293	* Converts an attribute from VTG description speak to DTrace.
294	*
295	* @param pDtAttr The DTrace attribute (dst).
296	* @param pVtgAttr The VTG attribute descriptor (src).
297	*/
298	static void vboxDtVtgConvAttr(dtrace_attribute_t *pDtAttr, PCVTGDESCATTR pVtgAttr)
299	{
300	pDtAttr->dtat_name = pVtgAttr->u8Code - 1;
301	pDtAttr->dtat_data = pVtgAttr->u8Data - 1;
302	pDtAttr->dtat_class = pVtgAttr->u8DataDep - 1;
303	}
304
305	/**
306	* Gets a string from the string table.
307	*
308	* @returns Pointer to the string.
309	* @param pVtgHdr The VTG object header.
310	* @param offStrTab The string table offset.
311	*/
312	static const char *vboxDtVtgGetString(PVTGOBJHDR pVtgHdr, uint32_t offStrTab)
313	{
314	Assert(offStrTab < pVtgHdr->cbStrTab);
315	return (const char *)pVtgHdr + pVtgHdr->offStrTab + offStrTab;
316	}
317
318
319
320	/*
321	*
322	* DTrace Provider Interface.
323	* DTrace Provider Interface.
324	* DTrace Provider Interface.
325	*
326	*/
327
328
329	/**
330	* @callback_method_impl{dtrace_pops_t,dtps_provide}
331	*/
332	static void vboxDtPOps_Provide(void pvProv, const dtrace_probedesc_t pDtProbeDesc)
333	{
334	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
335	AssertPtrReturnVoid(pProv);
336	LOG_DTRACE(("%s: %p / %p pDtProbeDesc=%p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, pDtProbeDesc));
337
338	if (pDtProbeDesc)
339	return; /* We don't generate probes, so never mind these requests. */
340
341	if (pProv->TracerData.DTrace.fZombie)
342	return;
343
344	dtrace_provider_id_t const idProvider = pProv->TracerData.DTrace.idProvider;
345	AssertPtrReturnVoid(idProvider);
346
347	AssertPtrReturnVoid(pProv->pHdr);
348	AssertReturnVoid(pProv->pHdr->offProbeLocs != 0);
349	uint32_t const cProbeLocs = pProv->pHdr->cbProbeLocs / sizeof(VTGPROBELOC);
350
351	/* Need a buffer for extracting the function names and mangling them in
352	case of collision. */
353	size_t const cbFnNmBuf = _4K + _1K;
354	char pszFnNmBuf = (char )RTMemAlloc(cbFnNmBuf);
355	if (!pszFnNmBuf)
356	return;
357
358	/*
359	* Itereate the probe location list and register all probes related to
360	* this provider.
361	*/
362	uint16_t const idxProv = (uint16_t)((PVTGDESCPROVIDER)((uintptr_t)pProv->pHdr + pProv->pHdr->offProviders) - pProv->pDesc);
363	uint32_t idxProbeLoc;
364	for (idxProbeLoc = 0; idxProbeLoc < cProbeLocs; idxProbeLoc++)
365	{
366	/* Skip probe location belonging to other providers or once that
367	we've already reported. */
368	PCVTGPROBELOC pProbeLocRO = &pProv->paProbeLocsRO[idxProbeLoc];
369	PVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
370	if (pProbeDesc->idxProvider != idxProv)
371	continue;
372
373	uint32_t *pidProbe;
374	if (!pProv->fUmod)
375	pidProbe = (uint32_t *)&pProbeLocRO->idProbe;
376	else
377	pidProbe = &pProv->paR0ProbeLocs[idxProbeLoc].idProbe;
378	if (*pidProbe != 0)
379	continue;
380
381	/* The function name may need to be stripped since we're using C++
382	compilers for most of the code. ASSUMES nobody are brave/stupid
383	enough to use function pointer returns without typedef'ing
384	properly them (e.g. signal). */
385	const char *pszPrbName = vboxDtVtgGetString(pProv->pHdr, pProbeDesc->offName);
386	const char *pszFunc = pProbeLocRO->pszFunction;
387	const char *psz = strchr(pProbeLocRO->pszFunction, '(');
388	size_t cch;
389	if (psz)
390	{
391	/* skip blanks preceeding the parameter parenthesis. */
392	while ( (uintptr_t)psz > (uintptr_t)pProbeLocRO->pszFunction
393	&& RT_C_IS_BLANK(psz[-1]))
394	psz--;
395
396	/* Find the start of the function name. */
397	pszFunc = psz - 1;
398	while ((uintptr_t)pszFunc > (uintptr_t)pProbeLocRO->pszFunction)
399	{
400	char ch = pszFunc[-1];
401	if (!RT_C_IS_ALNUM(ch) && ch != '_' && ch != ':')
402	break;
403	pszFunc--;
404	}
405	cch = psz - pszFunc;
406	}
407	else
408	cch = strlen(pszFunc);
409	RTStrCopyEx(pszFnNmBuf, cbFnNmBuf, pszFunc, cch);
410
411	/* Look up the probe, if we have one in the same function, mangle
412	the function name a little to avoid having to deal with having
413	multiple location entries with the same probe ID. (lazy bird) */
414	Assert(!*pidProbe);
415	if (dtrace_probe_lookup(idProvider, pProv->pszModName, pszFnNmBuf, pszPrbName) != DTRACE_IDNONE)
416	{
417	RTStrPrintf(pszFnNmBuf+cch, cbFnNmBuf - cch, "-%u", pProbeLocRO->uLine);
418	if (dtrace_probe_lookup(idProvider, pProv->pszModName, pszFnNmBuf, pszPrbName) != DTRACE_IDNONE)
419	{
420	unsigned iOrd = 2;
421	while (iOrd < 128)
422	{
423	RTStrPrintf(pszFnNmBuf+cch, cbFnNmBuf - cch, "-%u-%u", pProbeLocRO->uLine, iOrd);
424	if (dtrace_probe_lookup(idProvider, pProv->pszModName, pszFnNmBuf, pszPrbName) == DTRACE_IDNONE)
425	break;
426	iOrd++;
427	}
428	if (iOrd >= 128)
429	{
430	LogRel(("VBoxDrv: More than 128 duplicate probe location instances %s at line %u in function %s [%s], probe %s\n",
431	pProbeLocRO->uLine, pProbeLocRO->pszFunction, pszFnNmBuf, pszPrbName));
432	continue;
433	}
434	}
435	}
436
437	/* Create the probe. */
438	AssertCompile(sizeof(*pidProbe) == sizeof(dtrace_id_t));
439	*pidProbe = dtrace_probe_create(idProvider, pProv->pszModName, pszFnNmBuf, pszPrbName,
440	1 /aframes/, (void *)(uintptr_t)idxProbeLoc);
441	pProv->TracerData.DTrace.cProvidedProbes++;
442	}
443
444	RTMemFree(pszFnNmBuf);
445	LOG_DTRACE(("%s: returns\n", __FUNCTION__));
446	}
447
448
449	/**
450	* @callback_method_impl{dtrace_pops_t,dtps_enable}
451	*/
452	static int vboxDtPOps_Enable(void pvProv, dtrace_id_t idProbe, void pvProbe)
453	{
454	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
455	RT_NOREF(idProbe);
456	LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
457	AssertPtrReturn(pProv->TracerData.DTrace.idProvider, EINVAL);
458
459	if (!pProv->TracerData.DTrace.fZombie)
460	{
461	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
462	PVTGPROBELOC32 pProbeLocEn = (PVTGPROBELOC32)( (uintptr_t)pProv->pvProbeLocsEn + idxProbeLoc * pProv->cbProbeLocsEn);
463	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
464	PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
465	uint32_t const idxProbe = pProbeDesc->idxEnabled;
466
467	if (!pProv->fUmod)
468	{
469	if (!pProbeLocEn->fEnabled)
470	{
471	pProbeLocEn->fEnabled = 1;
472	ASMAtomicIncU32(&pProv->pacProbeEnabled[idxProbe]);
473	ASMAtomicIncU32(&pProv->pDesc->cProbesEnabled);
474	ASMAtomicIncU32(&pProv->pDesc->uSettingsSerialNo);
475	}
476	}
477	else
478	{
479	/* Update kernel mode structure */
480	if (!pProv->paR0ProbeLocs[idxProbeLoc].fEnabled)
481	{
482	pProv->paR0ProbeLocs[idxProbeLoc].fEnabled = 1;
483	ASMAtomicIncU32(&pProv->paR0Probes[idxProbe].cEnabled);
484	ASMAtomicIncU32(&pProv->pDesc->cProbesEnabled);
485	ASMAtomicIncU32(&pProv->pDesc->uSettingsSerialNo);
486	}
487
488	/* Update user mode structure. */
489	pProbeLocEn->fEnabled = 1;
490	pProv->pacProbeEnabled[idxProbe] = pProv->paR0Probes[idxProbe].cEnabled;
491	}
492	}
493
494	return 0;
495	}
496
497
498	/**
499	* @callback_method_impl{dtrace_pops_t,dtps_disable}
500	*/
501	static void vboxDtPOps_Disable(void pvProv, dtrace_id_t idProbe, void pvProbe)
502	{
503	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
504	AssertPtrReturnVoid(pProv);
505	RT_NOREF(idProbe);
506	LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
507	AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
508
509	if (!pProv->TracerData.DTrace.fZombie)
510	{
511	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
512	PVTGPROBELOC32 pProbeLocEn = (PVTGPROBELOC32)( (uintptr_t)pProv->pvProbeLocsEn + idxProbeLoc * pProv->cbProbeLocsEn);
513	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
514	PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
515	uint32_t const idxProbe = pProbeDesc->idxEnabled;
516
517	if (!pProv->fUmod)
518	{
519	if (pProbeLocEn->fEnabled)
520	{
521	pProbeLocEn->fEnabled = 0;
522	ASMAtomicDecU32(&pProv->pacProbeEnabled[idxProbe]);
523	ASMAtomicIncU32(&pProv->pDesc->cProbesEnabled);
524	ASMAtomicIncU32(&pProv->pDesc->uSettingsSerialNo);
525	}
526	}
527	else
528	{
529	/* Update kernel mode structure */
530	if (pProv->paR0ProbeLocs[idxProbeLoc].fEnabled)
531	{
532	pProv->paR0ProbeLocs[idxProbeLoc].fEnabled = 0;
533	ASMAtomicDecU32(&pProv->paR0Probes[idxProbe].cEnabled);
534	ASMAtomicDecU32(&pProv->pDesc->cProbesEnabled);
535	ASMAtomicIncU32(&pProv->pDesc->uSettingsSerialNo);
536	}
537
538	/* Update user mode structure. */
539	pProbeLocEn->fEnabled = 0;
540	pProv->pacProbeEnabled[idxProbe] = pProv->paR0Probes[idxProbe].cEnabled;
541	}
542	}
543	}
544
545
546	/**
547	* @callback_method_impl{dtrace_pops_t,dtps_getargdesc}
548	*/
549	static void vboxDtPOps_GetArgDesc(void pvProv, dtrace_id_t idProbe, void pvProbe,
550	dtrace_argdesc_t *pArgDesc)
551	{
552	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
553	unsigned uArg = pArgDesc->dtargd_ndx;
554	RT_NOREF(idProbe);
555
556	pArgDesc->dtargd_ndx = DTRACE_ARGNONE;
557	AssertPtrReturnVoid(pProv);
558	LOG_DTRACE(("%s: %p / %p - %#x / %p uArg=%d\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe, uArg));
559	AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
560
561	if (!pProv->TracerData.DTrace.fZombie)
562	{
563	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
564	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
565	PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
566	PCVTGDESCARGLIST pArgList = (PCVTGDESCARGLIST)( (uintptr_t)pProv->pHdr
567	+ pProv->pHdr->offArgLists
568	+ pProbeDesc->offArgList);
569	AssertReturnVoid(pProbeDesc->offArgList < pProv->pHdr->cbArgLists);
570
571	if (uArg < pArgList->cArgs)
572	{
573	const char *pszType = vboxDtVtgGetString(pProv->pHdr, pArgList->aArgs[uArg].offType);
574	size_t cchType = strlen(pszType);
575	if (cchType < sizeof(pArgDesc->dtargd_native))
576	{
577	memcpy(pArgDesc->dtargd_native, pszType, cchType + 1);
578	/** @todo mapping? */
579	pArgDesc->dtargd_ndx = uArg;
580	LOG_DTRACE(("%s: returns dtargd_native = %s\n", __FUNCTION__, pArgDesc->dtargd_native));
581	return;
582	}
583	}
584	}
585	}
586
587
588	/**
589	* @callback_method_impl{dtrace_pops_t,dtps_getargval}
590	*
591	*
592	* We just cook our own stuff here, using a stack marker for finding the
593	* required information. That's more reliable than subjecting oneself to the
594	* solaris bugs and 32-bit apple peculiarities.
595	*
596	*
597	* @remarks Solaris Bug
598	*
599	* dtrace_getarg on AMD64 has a different opinion about how to use the cFrames
600	* argument than dtrace_caller() and/or dtrace_getpcstack(), at least when the
601	* probe is fired by dtrace_probe() the way we do.
602	*
603	* Setting aframes to 1 when calling dtrace_probe_create gives me the right
604	* arguments, but the wrong 'caller'. Since I cannot do anything about
605	* 'caller', the only solution is this hack.
606	*
607	* Not sure why the Solaris guys hasn't seen this issue before, but maybe there
608	* isn't anyone using the default argument getter path for ring-0 dtrace_probe()
609	* calls, SDT surely isn't.
610	*
611	* @todo File a solaris bug on dtrace_probe() + dtrace_getarg().
612	*
613	*
614	* @remarks 32-bit XNU (Apple)
615	*
616	* The dtrace_probe arguments are 64-bit unsigned integers instead of uintptr_t,
617	* so we need to make an extra call.
618	*
619	*/
620	static uint64_t vboxDtPOps_GetArgVal(void pvProv, dtrace_id_t idProbe, void pvProbe,
621	int iArg, int cFrames)
622	{
623	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
624	AssertPtrReturn(pProv, UINT64_MAX);
625	RT_NOREF(idProbe, cFrames);
626	LOG_DTRACE(("%s: %p / %p - %#x / %p iArg=%d cFrames=%u\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe, iArg, cFrames));
627	AssertReturn(iArg >= 5, UINT64_MAX);
628	if (pProv->TracerData.DTrace.fZombie)
629	return UINT64_MAX;
630
631	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
632	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
633	PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
634	PCVTGDESCARGLIST pArgList = (PCVTGDESCARGLIST)( (uintptr_t)pProv->pHdr
635	+ pProv->pHdr->offArgLists
636	+ pProbeDesc->offArgList);
637	AssertReturn(pProbeDesc->offArgList < pProv->pHdr->cbArgLists, UINT64_MAX);
638
639	PVBDTSTACKDATA pData = vboxDtGetStackData();
640
641	/*
642	* Get the stack data. This is a wee bit complicated on 32-bit systems
643	* since we want to support 64-bit integer arguments.
644	*/
645	uint64_t u64Ret;
646	if (iArg >= 20)
647	u64Ret = UINT64_MAX;
648	else if (pData->enmCaller == kVBoxDtCaller_ProbeFireKernel)
649	{
650	#if ARCH_BITS == 64
651	u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
652	#else
653	if ( !pArgList->fHaveLargeArgs
654	\|\| iArg >= pArgList->cArgs)
655	u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
656	else
657	{
658	/* Similar to what we did for mac in when calling dtrace_probe(). */
659	uint32_t offArg = 0;
660	for (int i = 5; i < iArg; i++)
661	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
662	offArg++;
663	u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5 + offArg];
664	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
665	u64Ret \|= (uint64_t)pData->u.ProbeFireKernel.pauStackArgs[iArg - 5 + offArg + 1] << 32;
666	}
667	#endif
668	}
669	else if (pData->enmCaller == kVBoxDtCaller_ProbeFireUser)
670	{
671	int offArg = pData->u.ProbeFireUser.offArg;
672	PCSUPDRVTRACERUSRCTX pCtx = pData->u.ProbeFireUser.pCtx;
673	AssertPtrReturn(pCtx, UINT64_MAX);
674
675	if (pCtx->cBits == 32)
676	{
677	if ( !pArgList->fHaveLargeArgs
678	\|\| iArg >= pArgList->cArgs)
679	{
680	if (iArg + offArg < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
681	u64Ret = pCtx->u.X86.aArgs[iArg + offArg];
682	else
683	u64Ret = UINT64_MAX;
684	}
685	else
686	{
687	int i;
688	for (i = 5; i < iArg; i++)
689	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
690	offArg++;
691	if (offArg + iArg < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
692	{
693	u64Ret = pCtx->u.X86.aArgs[iArg + offArg];
694	if ( VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType)
695	&& offArg + iArg + 1 < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
696	u64Ret \|= (uint64_t)pCtx->u.X86.aArgs[iArg + offArg + 1] << 32;
697	}
698	else
699	u64Ret = UINT64_MAX;
700	}
701	}
702	else
703	{
704	if (iArg + offArg < (int)RT_ELEMENTS(pCtx->u.Amd64.aArgs))
705	u64Ret = pCtx->u.Amd64.aArgs[iArg + offArg];
706	else
707	u64Ret = UINT64_MAX;
708	}
709	}
710	else
711	AssertFailedReturn(UINT64_MAX);
712
713	LOG_DTRACE(("%s: returns %#llx\n", __FUNCTION__, u64Ret));
714	return u64Ret;
715	}
716
717
718	/**
719	* @callback_method_impl{dtrace_pops_t,dtps_destroy}
720	*/
721	static void vboxDtPOps_Destroy(void pvProv, dtrace_id_t idProbe, void pvProbe)
722	{
723	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
724	AssertPtrReturnVoid(pProv);
725	LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
726	AssertReturnVoid(pProv->TracerData.DTrace.cProvidedProbes > 0);
727	AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
728
729	if (!pProv->TracerData.DTrace.fZombie)
730	{
731	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
732	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
733	uint32_t *pidProbe;
734	if (!pProv->fUmod)
735	{
736	pidProbe = (uint32_t *)&pProbeLocRO->idProbe;
737	Assert(!pProbeLocRO->fEnabled);
738	Assert(*pidProbe == idProbe);
739	}
740	else
741	{
742	pidProbe = &pProv->paR0ProbeLocs[idxProbeLoc].idProbe;
743	Assert(!pProv->paR0ProbeLocs[idxProbeLoc].fEnabled);
744	Assert(*pidProbe == idProbe); NOREF(idProbe);
745	}
746	*pidProbe = 0;
747	}
748	pProv->TracerData.DTrace.cProvidedProbes--;
749	}
750
751
752
753	/**
754	* DTrace provider method table.
755	*/
756	static const dtrace_pops_t g_vboxDtVtgProvOps =
757	{
758	/* .dtps_provide = */ vboxDtPOps_Provide,
759	/* .dtps_provide_module = */ NULL,
760	/* .dtps_enable = / (FNPOPS_ENABLE )vboxDtPOps_Enable,
761	/* .dtps_disable = */ vboxDtPOps_Disable,
762	/* .dtps_suspend = */ NULL,
763	/* .dtps_resume = */ NULL,
764	/* .dtps_getargdesc = */ vboxDtPOps_GetArgDesc,
765	/* .dtps_getargval = */ vboxDtPOps_GetArgVal,
766	/* .dtps_usermode = */ NULL,
767	/* .dtps_destroy = */ vboxDtPOps_Destroy
768	};
769
770
771
772
773	/*
774	*
775	* Support Driver Tracer Interface.
776	* Support Driver Tracer Interface.
777	* Support Driver Tracer Interface.
778	*
779	*/
780
781
782
783	/**
784	* interface_method_impl{SUPDRVTRACERREG,pfnProbeFireKernel}
785	*/
786	static DECLCALLBACK(void) vboxDtTOps_ProbeFireKernel(struct VTGPROBELOC *pVtgProbeLoc, uintptr_t uArg0, uintptr_t uArg1, uintptr_t uArg2,
787	uintptr_t uArg3, uintptr_t uArg4)
788	{
789	AssertPtrReturnVoid(pVtgProbeLoc);
790	LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pVtgProbeLoc, pVtgProbeLoc->idProbe));
791	AssertPtrReturnVoid(pVtgProbeLoc->pProbe);
792	AssertPtrReturnVoid(pVtgProbeLoc->pszFunction);
793
794	SUPDRV_SAVE_EFL_AC();
795	VBDT_SETUP_STACK_DATA(kVBoxDtCaller_ProbeFireKernel);
796
797	pStackData->u.ProbeFireKernel.pauStackArgs = &uArg4 + 1;
798
799	#if defined(RT_OS_DARWIN) && ARCH_BITS == 32
800	/*
801	* Convert arguments from uintptr_t to uint64_t.
802	*/
803	PVTGDESCPROBE pProbe = (PVTGDESCPROBE)((PVTGPROBELOC)pVtgProbeLoc)->pProbe;
804	AssertPtrReturnVoid(pProbe);
805	PVTGOBJHDR pVtgHdr = (PVTGOBJHDR)((uintptr_t)pProbe + pProbe->offObjHdr);
806	AssertPtrReturnVoid(pVtgHdr);
807	PVTGDESCARGLIST pArgList = (PVTGDESCARGLIST)((uintptr_t)pVtgHdr + pVtgHdr->offArgLists + pProbe->offArgList);
808	AssertPtrReturnVoid(pArgList);
809	if (!pArgList->fHaveLargeArgs)
810	dtrace_probe(pVtgProbeLoc->idProbe, uArg0, uArg1, uArg2, uArg3, uArg4);
811	else
812	{
813	uintptr_t *auSrcArgs = &uArg0;
814	uint32_t iSrcArg = 0;
815	uint32_t iDstArg = 0;
816	uint64_t au64DstArgs[5];
817
818	while ( iDstArg < RT_ELEMENTS(au64DstArgs)
819	&& iSrcArg < pArgList->cArgs)
820	{
821	au64DstArgs[iDstArg] = auSrcArgs[iSrcArg];
822	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iDstArg].fType))
823	au64DstArgs[iDstArg] \|= (uint64_t)auSrcArgs[++iSrcArg] << 32;
824	iSrcArg++;
825	iDstArg++;
826	}
827	while (iDstArg < RT_ELEMENTS(au64DstArgs))
828	au64DstArgs[iDstArg++] = auSrcArgs[iSrcArg++];
829
830	pStackData->u.ProbeFireKernel.pauStackArgs = &auSrcArgs[iSrcArg];
831	dtrace_probe(pVtgProbeLoc->idProbe, au64DstArgs[0], au64DstArgs[1], au64DstArgs[2], au64DstArgs[3], au64DstArgs[4]);
832	}
833	#else
834	dtrace_probe(pVtgProbeLoc->idProbe, uArg0, uArg1, uArg2, uArg3, uArg4);
835	#endif
836
837	VBDT_CLEAR_STACK_DATA();
838	SUPDRV_RESTORE_EFL_AC();
839	LOG_DTRACE(("%s: returns\n", __FUNCTION__));
840	}
841
842
843	/**
844	* interface_method_impl{SUPDRVTRACERREG,pfnProbeFireUser}
845	*/
846	static DECLCALLBACK(void) vboxDtTOps_ProbeFireUser(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, PCSUPDRVTRACERUSRCTX pCtx,
847	PCVTGOBJHDR pVtgHdr, PCVTGPROBELOC pProbeLocRO)
848	{
849	RT_NOREF(pThis, pSession);
850	LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pCtx, pCtx->idProbe));
851	AssertPtrReturnVoid(pProbeLocRO);
852	AssertPtrReturnVoid(pVtgHdr);
853
854	SUPDRV_SAVE_EFL_AC();
855	VBDT_SETUP_STACK_DATA(kVBoxDtCaller_ProbeFireUser);
856
857	if (pCtx->cBits == 32)
858	{
859	pStackData->u.ProbeFireUser.pCtx = pCtx;
860	pStackData->u.ProbeFireUser.offArg = 0;
861
862	#if ARCH_BITS == 64 \|\| defined(RT_OS_DARWIN)
863	/*
864	* Combine two 32-bit arguments into one 64-bit argument where needed.
865	*/
866	PVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
867	AssertPtrReturnVoid(pProbeDesc);
868	PVTGDESCARGLIST pArgList = (PVTGDESCARGLIST)((uintptr_t)pVtgHdr + pVtgHdr->offArgLists + pProbeDesc->offArgList);
869	AssertPtrReturnVoid(pArgList);
870
871	if (!pArgList->fHaveLargeArgs)
872	dtrace_probe(pCtx->idProbe,
873	pCtx->u.X86.aArgs[0],
874	pCtx->u.X86.aArgs[1],
875	pCtx->u.X86.aArgs[2],
876	pCtx->u.X86.aArgs[3],
877	pCtx->u.X86.aArgs[4]);
878	else
879	{
880	uint32_t const *auSrcArgs = &pCtx->u.X86.aArgs[0];
881	uint32_t iSrcArg = 0;
882	uint32_t iDstArg = 0;
883	uint64_t au64DstArgs[5];
884
885	while ( iDstArg < RT_ELEMENTS(au64DstArgs)
886	&& iSrcArg < pArgList->cArgs)
887	{
888	au64DstArgs[iDstArg] = auSrcArgs[iSrcArg];
889	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iDstArg].fType))
890	au64DstArgs[iDstArg] \|= (uint64_t)auSrcArgs[++iSrcArg] << 32;
891	iSrcArg++;
892	iDstArg++;
893	}
894	while (iDstArg < RT_ELEMENTS(au64DstArgs))
895	au64DstArgs[iDstArg++] = auSrcArgs[iSrcArg++];
896
897	pStackData->u.ProbeFireUser.offArg = iSrcArg - RT_ELEMENTS(au64DstArgs);
898	dtrace_probe(pCtx->idProbe, au64DstArgs[0], au64DstArgs[1], au64DstArgs[2], au64DstArgs[3], au64DstArgs[4]);
899	}
900	#else
901	dtrace_probe(pCtx->idProbe,
902	pCtx->u.X86.aArgs[0],
903	pCtx->u.X86.aArgs[1],
904	pCtx->u.X86.aArgs[2],
905	pCtx->u.X86.aArgs[3],
906	pCtx->u.X86.aArgs[4]);
907	#endif
908	}
909	else if (pCtx->cBits == 64)
910	{
911	pStackData->u.ProbeFireUser.pCtx = pCtx;
912	pStackData->u.ProbeFireUser.offArg = 0;
913	dtrace_probe(pCtx->idProbe,
914	pCtx->u.Amd64.aArgs[0],
915	pCtx->u.Amd64.aArgs[1],
916	pCtx->u.Amd64.aArgs[2],
917	pCtx->u.Amd64.aArgs[3],
918	pCtx->u.Amd64.aArgs[4]);
919	}
920	else
921	AssertFailed();
922
923	VBDT_CLEAR_STACK_DATA();
924	SUPDRV_RESTORE_EFL_AC();
925	LOG_DTRACE(("%s: returns\n", __FUNCTION__));
926	}
927
928
929	/**
930	* interface_method_impl{SUPDRVTRACERREG,pfnTracerOpen}
931	*/
932	static DECLCALLBACK(int) vboxDtTOps_TracerOpen(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uint32_t uCookie,
933	uintptr_t uArg, uintptr_t *puSessionData)
934	{
935	NOREF(pThis); NOREF(pSession); NOREF(uCookie); NOREF(uArg);
936	*puSessionData = 0;
937	return VERR_NOT_SUPPORTED;
938	}
939
940
941	/**
942	* interface_method_impl{SUPDRVTRACERREG,pfnTracerClose}
943	*/
944	static DECLCALLBACK(int) vboxDtTOps_TracerIoCtl(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData,
945	uintptr_t uCmd, uintptr_t uArg, int32_t *piRetVal)
946	{
947	NOREF(pThis); NOREF(pSession); NOREF(uSessionData);
948	NOREF(uCmd); NOREF(uArg); NOREF(piRetVal);
949	return VERR_NOT_SUPPORTED;
950	}
951
952
953	/**
954	* interface_method_impl{SUPDRVTRACERREG,pfnTracerClose}
955	*/
956	static DECLCALLBACK(void) vboxDtTOps_TracerClose(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData)
957	{
958	NOREF(pThis); NOREF(pSession); NOREF(uSessionData);
959	return;
960	}
961
962
963	/**
964	* interface_method_impl{SUPDRVTRACERREG,pfnProviderRegister}
965	*/
966	static DECLCALLBACK(int) vboxDtTOps_ProviderRegister(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
967	{
968	RT_NOREF(pThis);
969	LOG_DTRACE(("%s: %p %s/%s\n", __FUNCTION__, pThis, pCore->pszModName, pCore->pszName));
970	AssertReturn(pCore->TracerData.DTrace.idProvider == 0, VERR_INTERNAL_ERROR_3);
971
972	PVTGDESCPROVIDER pDesc = pCore->pDesc;
973	dtrace_pattr_t DtAttrs;
974	vboxDtVtgConvAttr(&DtAttrs.dtpa_provider, &pDesc->AttrSelf);
975	vboxDtVtgConvAttr(&DtAttrs.dtpa_mod, &pDesc->AttrModules);
976	vboxDtVtgConvAttr(&DtAttrs.dtpa_func, &pDesc->AttrFunctions);
977	vboxDtVtgConvAttr(&DtAttrs.dtpa_name, &pDesc->AttrNames);
978	vboxDtVtgConvAttr(&DtAttrs.dtpa_args, &pDesc->AttrArguments);
979
980	/* Note! DTrace may call us back before dtrace_register returns, so we
981	have to point it to pCore->TracerData.DTrace.idProvider. */
982	AssertCompile(sizeof(dtrace_provider_id_t) == sizeof(pCore->TracerData.DTrace.idProvider));
983	SUPDRV_SAVE_EFL_AC();
984	int rc = dtrace_register(pCore->pszName,
985	&DtAttrs,
986	DTRACE_PRIV_KERNEL,
987	NULL /* cred */,
988	&g_vboxDtVtgProvOps,
989	pCore,
990	&pCore->TracerData.DTrace.idProvider);
991	SUPDRV_RESTORE_EFL_AC();
992	if (!rc)
993	{
994	LOG_DTRACE(("%s: idProvider=%p\n", __FUNCTION__, pCore->TracerData.DTrace.idProvider));
995	AssertPtr(pCore->TracerData.DTrace.idProvider);
996	rc = VINF_SUCCESS;
997	}
998	else
999	{
1000	pCore->TracerData.DTrace.idProvider = 0;
1001	rc = RTErrConvertFromErrno(FIX_UEK_RC(rc));
1002	}
1003
1004	LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
1005	return rc;
1006	}
1007
1008
1009	/**
1010	* interface_method_impl{SUPDRVTRACERREG,pfnProviderDeregister}
1011	*/
1012	static DECLCALLBACK(int) vboxDtTOps_ProviderDeregister(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
1013	{
1014	uintptr_t idProvider = pCore->TracerData.DTrace.idProvider;
1015	RT_NOREF(pThis);
1016	LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pThis, idProvider));
1017	AssertPtrReturn(idProvider, VERR_INTERNAL_ERROR_3);
1018
1019	SUPDRV_SAVE_EFL_AC();
1020	dtrace_invalidate(idProvider);
1021	int rc = dtrace_unregister(idProvider);
1022	SUPDRV_RESTORE_EFL_AC();
1023	if (!rc)
1024	{
1025	pCore->TracerData.DTrace.idProvider = 0;
1026	rc = VINF_SUCCESS;
1027	}
1028	else
1029	{
1030	AssertMsg(FIX_UEK_RC(rc) == EBUSY, ("%d\n", rc));
1031	pCore->TracerData.DTrace.fZombie = true;
1032	rc = VERR_TRY_AGAIN;
1033	}
1034
1035	LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
1036	return rc;
1037	}
1038
1039
1040	/**
1041	* interface_method_impl{SUPDRVTRACERREG,pfnProviderDeregisterZombie}
1042	*/
1043	static DECLCALLBACK(int) vboxDtTOps_ProviderDeregisterZombie(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
1044	{
1045	uintptr_t idProvider = pCore->TracerData.DTrace.idProvider;
1046	RT_NOREF(pThis);
1047	LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pThis, idProvider));
1048	AssertPtrReturn(idProvider, VERR_INTERNAL_ERROR_3);
1049	Assert(pCore->TracerData.DTrace.fZombie);
1050
1051	SUPDRV_SAVE_EFL_AC();
1052	int rc = dtrace_unregister(idProvider);
1053	SUPDRV_RESTORE_EFL_AC();
1054	if (!rc)
1055	{
1056	pCore->TracerData.DTrace.idProvider = 0;
1057	rc = VINF_SUCCESS;
1058	}
1059	else
1060	{
1061	AssertMsg(FIX_UEK_RC(rc) == EBUSY, ("%d\n", rc));
1062	rc = VERR_TRY_AGAIN;
1063	}
1064
1065	LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
1066	return rc;
1067	}
1068
1069
1070
1071	/**
1072	* The tracer registration record of the VBox DTrace implementation
1073	*/
1074	static SUPDRVTRACERREG g_VBoxDTraceReg =
1075	{
1076	SUPDRVTRACERREG_MAGIC,
1077	SUPDRVTRACERREG_VERSION,
1078	vboxDtTOps_ProbeFireKernel,
1079	vboxDtTOps_ProbeFireUser,
1080	vboxDtTOps_TracerOpen,
1081	vboxDtTOps_TracerIoCtl,
1082	vboxDtTOps_TracerClose,
1083	vboxDtTOps_ProviderRegister,
1084	vboxDtTOps_ProviderDeregister,
1085	vboxDtTOps_ProviderDeregisterZombie,
1086	SUPDRVTRACERREG_MAGIC
1087	};
1088
1089
1090
1091	/**
1092	* Module initialization code.
1093	*/
1094	const SUPDRVTRACERREG * VBOXCALL supdrvDTraceInit(void)
1095	{
1096	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX)
1097	/*
1098	* Resolve the kernel symbols we need.
1099	*/
1100	# ifndef RT_OS_LINUX
1101	RTDBGKRNLINFO hKrnlInfo;
1102	int rc = RTR0DbgKrnlInfoOpen(&hKrnlInfo, 0);
1103	if (RT_FAILURE(rc))
1104	{
1105	SUPR0Printf("supdrvDTraceInit: RTR0DbgKrnlInfoOpen failed with rc=%d.\n", rc);
1106	return NULL;
1107	}
1108	# endif
1109
1110	static const struct
1111	{
1112	const char *pszName;
1113	PFNRT *ppfn;
1114	} s_aDTraceFunctions[] =
1115	{
1116	{ "dtrace_probe", (PFNRT*)&dtrace_probe },
1117	{ "dtrace_probe_create", (PFNRT*)&dtrace_probe_create },
1118	{ "dtrace_probe_lookup", (PFNRT*)&dtrace_probe_lookup },
1119	{ "dtrace_register", (PFNRT*)&dtrace_register },
1120	{ "dtrace_invalidate", (PFNRT*)&dtrace_invalidate },
1121	{ "dtrace_unregister", (PFNRT*)&dtrace_unregister },
1122	};
1123	unsigned i;
1124	for (i = 0; i < RT_ELEMENTS(s_aDTraceFunctions); i++)
1125	{
1126	# ifndef RT_OS_LINUX
1127	rc = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, s_aDTraceFunctions[i].pszName,
1128	(void **)s_aDTraceFunctions[i].ppfn);
1129	if (RT_FAILURE(rc))
1130	{
1131	SUPR0Printf("supdrvDTraceInit: Failed to resolved '%s' (rc=%Rrc, i=%u).\n", s_aDTraceFunctions[i].pszName, rc, i);
1132	break;
1133	}
1134	# else
1135	unsigned long ulAddr = kallsyms_lookup_name(s_aDTraceFunctions[i].pszName);
1136	if (!ulAddr)
1137	{
1138	SUPR0Printf("supdrvDTraceInit: Failed to resolved '%s' (i=%u).\n", s_aDTraceFunctions[i].pszName, i);
1139	return NULL;
1140	}
1141	*s_aDTraceFunctions[i].ppfn = (PFNRT)ulAddr;
1142	# endif
1143	}
1144
1145	# ifndef RT_OS_LINUX
1146	RTR0DbgKrnlInfoRelease(hKrnlInfo);
1147	if (RT_FAILURE(rc))
1148	return NULL;
1149	# else
1150	/** @todo grab a reference to the dtrace module... */
1151	# endif
1152	#endif
1153
1154	return &g_VBoxDTraceReg;
1155	}
1156
1157	#ifndef VBOX_WITH_NATIVE_DTRACE
1158	# error "VBOX_WITH_NATIVE_DTRACE is not defined as it should"
1159	#endif
1160

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/HostDrivers/Support/SUPDrv-dtrace.cpp@ 68317

Download in other formats: