SUPDrv-dtrace.cpp@ 63510

Last change on this file since 63510 was 63510, checked in by vboxsync, 8 years ago
SUP: warnings (clang)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 40.6 KB

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

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

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

Download in other formats: