SUPDrv-dtrace.cpp@ 48952

Last change on this file since 48952 was 48952, checked in by vboxsync, 11 years ago
HostDrivers: Whitespace and svn:keywords cleanups by scm.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 37.8 KB

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

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

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

Download in other formats: