SUPDrv-dtrace.cpp@ 54666

Last change on this file since 54666 was 49396, checked in by vboxsync, 11 years ago
SUPDrv: Made dtrace support build against UEKR3.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 39.4 KB

Line
1	/* $Id: SUPDrv-dtrace.cpp 49396 2013-11-05 18:40:50Z 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	/* 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	LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
437	AssertPtrReturn(pProv->TracerData.DTrace.idProvider, EINVAL);
438
439	if (!pProv->TracerData.DTrace.fZombie)
440	{
441	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
442	PVTGPROBELOC32 pProbeLocEn = (PVTGPROBELOC32)( (uintptr_t)pProv->pvProbeLocsEn + idxProbeLoc * pProv->cbProbeLocsEn);
443	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
444	PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
445	uint32_t const idxProbe = pProbeDesc->idxEnabled;
446
447	if (!pProv->fUmod)
448	{
449	if (!pProbeLocEn->fEnabled)
450	{
451	pProbeLocEn->fEnabled = 1;
452	ASMAtomicIncU32(&pProv->pacProbeEnabled[idxProbe]);
453	}
454	}
455	else
456	{
457	/* Update kernel mode structure */
458	if (!pProv->paR0ProbeLocs[idxProbeLoc].fEnabled)
459	{
460	pProv->paR0ProbeLocs[idxProbeLoc].fEnabled = 1;
461	ASMAtomicIncU32(&pProv->paR0Probes[idxProbe].cEnabled);
462	}
463
464	/* Update user mode structure. */
465	pProbeLocEn->fEnabled = 1;
466	pProv->pacProbeEnabled[idxProbe] = pProv->paR0Probes[idxProbe].cEnabled;
467	}
468	}
469
470	return 0;
471	}
472
473
474	/**
475	* @callback_method_impl{dtrace_pops_t,dtps_disable}
476	*/
477	static void vboxDtPOps_Disable(void pvProv, dtrace_id_t idProbe, void pvProbe)
478	{
479	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
480	AssertPtrReturnVoid(pProv);
481	LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
482	AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
483
484	if (!pProv->TracerData.DTrace.fZombie)
485	{
486	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
487	PVTGPROBELOC32 pProbeLocEn = (PVTGPROBELOC32)( (uintptr_t)pProv->pvProbeLocsEn + idxProbeLoc * pProv->cbProbeLocsEn);
488	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
489	PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
490	uint32_t const idxProbe = pProbeDesc->idxEnabled;
491
492	if (!pProv->fUmod)
493	{
494	if (pProbeLocEn->fEnabled)
495	{
496	pProbeLocEn->fEnabled = 0;
497	ASMAtomicDecU32(&pProv->pacProbeEnabled[idxProbe]);
498	}
499	}
500	else
501	{
502	/* Update kernel mode structure */
503	if (pProv->paR0ProbeLocs[idxProbeLoc].fEnabled)
504	{
505	pProv->paR0ProbeLocs[idxProbeLoc].fEnabled = 0;
506	ASMAtomicDecU32(&pProv->paR0Probes[idxProbe].cEnabled);
507	}
508
509	/* Update user mode structure. */
510	pProbeLocEn->fEnabled = 0;
511	pProv->pacProbeEnabled[idxProbe] = pProv->paR0Probes[idxProbe].cEnabled;
512	}
513	}
514	}
515
516
517	/**
518	* @callback_method_impl{dtrace_pops_t,dtps_getargdesc}
519	*/
520	static void vboxDtPOps_GetArgDesc(void pvProv, dtrace_id_t idProbe, void pvProbe,
521	dtrace_argdesc_t *pArgDesc)
522	{
523	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
524	unsigned uArg = pArgDesc->dtargd_ndx;
525
526	pArgDesc->dtargd_ndx = DTRACE_ARGNONE;
527	AssertPtrReturnVoid(pProv);
528	LOG_DTRACE(("%s: %p / %p - %#x / %p uArg=%d\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe, uArg));
529	AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
530
531	if (!pProv->TracerData.DTrace.fZombie)
532	{
533	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
534	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
535	PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
536	PCVTGDESCARGLIST pArgList = (PCVTGDESCARGLIST)( (uintptr_t)pProv->pHdr
537	+ pProv->pHdr->offArgLists
538	+ pProbeDesc->offArgList);
539	AssertReturnVoid(pProbeDesc->offArgList < pProv->pHdr->cbArgLists);
540
541	if (uArg < pArgList->cArgs)
542	{
543	const char *pszType = vboxDtVtgGetString(pProv->pHdr, pArgList->aArgs[uArg].offType);
544	size_t cchType = strlen(pszType);
545	if (cchType < sizeof(pArgDesc->dtargd_native))
546	{
547	memcpy(pArgDesc->dtargd_native, pszType, cchType + 1);
548	/** @todo mapping? */
549	pArgDesc->dtargd_ndx = uArg;
550	LOG_DTRACE(("%s: returns dtargd_native = %s\n", __FUNCTION__, pArgDesc->dtargd_native));
551	return;
552	}
553	}
554	}
555	}
556
557
558	/**
559	* @callback_method_impl{dtrace_pops_t,dtps_getargval}
560	*
561	*
562	* We just cook our own stuff here, using a stack marker for finding the
563	* required information. That's more reliable than subjecting oneself to the
564	* solaris bugs and 32-bit apple peculiarities.
565	*
566	*
567	* @remarks Solaris Bug
568	*
569	* dtrace_getarg on AMD64 has a different opinion about how to use the cFrames
570	* argument than dtrace_caller() and/or dtrace_getpcstack(), at least when the
571	* probe is fired by dtrace_probe() the way we do.
572	*
573	* Setting aframes to 1 when calling dtrace_probe_create gives me the right
574	* arguments, but the wrong 'caller'. Since I cannot do anything about
575	* 'caller', the only solution is this hack.
576	*
577	* Not sure why the Solaris guys hasn't seen this issue before, but maybe there
578	* isn't anyone using the default argument getter path for ring-0 dtrace_probe()
579	* calls, SDT surely isn't.
580	*
581	* @todo File a solaris bug on dtrace_probe() + dtrace_getarg().
582	*
583	*
584	* @remarks 32-bit XNU (Apple)
585	*
586	* The dtrace_probe arguments are 64-bit unsigned integers instead of uintptr_t,
587	* so we need to make an extra call.
588	*
589	*/
590	static uint64_t vboxDtPOps_GetArgVal(void pvProv, dtrace_id_t idProbe, void pvProbe,
591	int iArg, int cFrames)
592	{
593	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
594	AssertPtrReturn(pProv, UINT64_MAX);
595	LOG_DTRACE(("%s: %p / %p - %#x / %p iArg=%d cFrames=%u\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe, iArg, cFrames));
596	AssertReturn(iArg >= 5, UINT64_MAX);
597	if (pProv->TracerData.DTrace.fZombie)
598	return UINT64_MAX;
599
600	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
601	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
602	PCVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
603	PCVTGDESCARGLIST pArgList = (PCVTGDESCARGLIST)( (uintptr_t)pProv->pHdr
604	+ pProv->pHdr->offArgLists
605	+ pProbeDesc->offArgList);
606	AssertReturn(pProbeDesc->offArgList < pProv->pHdr->cbArgLists, UINT64_MAX);
607
608	PVBDTSTACKDATA pData = vboxDtGetStackData();
609
610	/*
611	* Get the stack data. This is a wee bit complicated on 32-bit systems
612	* since we want to support 64-bit integer arguments.
613	*/
614	uint64_t u64Ret;
615	if (iArg >= 20)
616	u64Ret = UINT64_MAX;
617	else if (pData->enmCaller == kVBoxDtCaller_ProbeFireKernel)
618	{
619	#if ARCH_BITS == 64
620	u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
621	#else
622	if ( !pArgList->fHaveLargeArgs
623	\|\| iArg >= pArgList->cArgs)
624	u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5];
625	else
626	{
627	/* Similar to what we did for mac in when calling dtrace_probe(). */
628	uint32_t offArg = 0;
629	for (int i = 5; i < iArg; i++)
630	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
631	offArg++;
632	u64Ret = pData->u.ProbeFireKernel.pauStackArgs[iArg - 5 + offArg];
633	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
634	u64Ret \|= (uint64_t)pData->u.ProbeFireKernel.pauStackArgs[iArg - 5 + offArg + 1] << 32;
635	}
636	#endif
637	}
638	else if (pData->enmCaller == kVBoxDtCaller_ProbeFireUser)
639	{
640	int offArg = pData->u.ProbeFireUser.offArg;
641	PCSUPDRVTRACERUSRCTX pCtx = pData->u.ProbeFireUser.pCtx;
642	AssertPtrReturn(pCtx, UINT64_MAX);
643
644	if (pCtx->cBits == 32)
645	{
646	if ( !pArgList->fHaveLargeArgs
647	\|\| iArg >= pArgList->cArgs)
648	{
649	if (iArg + offArg < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
650	u64Ret = pCtx->u.X86.aArgs[iArg + offArg];
651	else
652	u64Ret = UINT64_MAX;
653	}
654	else
655	{
656	int i;
657	for (i = 5; i < iArg; i++)
658	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
659	offArg++;
660	if (offArg + iArg < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
661	{
662	u64Ret = pCtx->u.X86.aArgs[iArg + offArg];
663	if ( VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType)
664	&& offArg + iArg + 1 < (int)RT_ELEMENTS(pCtx->u.X86.aArgs))
665	u64Ret \|= (uint64_t)pCtx->u.X86.aArgs[iArg + offArg + 1] << 32;
666	}
667	else
668	u64Ret = UINT64_MAX;
669	}
670	}
671	else
672	{
673	if (iArg + offArg < (int)RT_ELEMENTS(pCtx->u.Amd64.aArgs))
674	u64Ret = pCtx->u.Amd64.aArgs[iArg + offArg];
675	else
676	u64Ret = UINT64_MAX;
677	}
678	}
679	else
680	AssertFailedReturn(UINT64_MAX);
681
682	LOG_DTRACE(("%s: returns %#llx\n", __FUNCTION__, u64Ret));
683	return u64Ret;
684	}
685
686
687	/**
688	* @callback_method_impl{dtrace_pops_t,dtps_destroy}
689	*/
690	static void vboxDtPOps_Destroy(void pvProv, dtrace_id_t idProbe, void pvProbe)
691	{
692	PSUPDRVVDTPROVIDERCORE pProv = (PSUPDRVVDTPROVIDERCORE)pvProv;
693	AssertPtrReturnVoid(pProv);
694	LOG_DTRACE(("%s: %p / %p - %#x / %p\n", __FUNCTION__, pProv, pProv->TracerData.DTrace.idProvider, idProbe, pvProbe));
695	AssertReturnVoid(pProv->TracerData.DTrace.cProvidedProbes > 0);
696	AssertPtrReturnVoid(pProv->TracerData.DTrace.idProvider);
697
698	if (!pProv->TracerData.DTrace.fZombie)
699	{
700	uint32_t idxProbeLoc = (uint32_t)(uintptr_t)pvProbe;
701	PCVTGPROBELOC pProbeLocRO = (PVTGPROBELOC)&pProv->paProbeLocsRO[idxProbeLoc];
702	uint32_t *pidProbe;
703	if (!pProv->fUmod)
704	{
705	pidProbe = (uint32_t *)&pProbeLocRO->idProbe;
706	Assert(!pProbeLocRO->fEnabled);
707	Assert(*pidProbe == idProbe);
708	}
709	else
710	{
711	pidProbe = &pProv->paR0ProbeLocs[idxProbeLoc].idProbe;
712	Assert(!pProv->paR0ProbeLocs[idxProbeLoc].fEnabled);
713	Assert(*pidProbe == idProbe); NOREF(idProbe);
714	}
715	*pidProbe = 0;
716	}
717	pProv->TracerData.DTrace.cProvidedProbes--;
718	}
719
720
721
722	/**
723	* DTrace provider method table.
724	*/
725	static const dtrace_pops_t g_vboxDtVtgProvOps =
726	{
727	/* .dtps_provide = */ vboxDtPOps_Provide,
728	/* .dtps_provide_module = */ NULL,
729	/* .dtps_enable = / (FNPOPS_ENABLE )vboxDtPOps_Enable,
730	/* .dtps_disable = */ vboxDtPOps_Disable,
731	/* .dtps_suspend = */ NULL,
732	/* .dtps_resume = */ NULL,
733	/* .dtps_getargdesc = */ vboxDtPOps_GetArgDesc,
734	/* .dtps_getargval = */ vboxDtPOps_GetArgVal,
735	/* .dtps_usermode = */ NULL,
736	/* .dtps_destroy = */ vboxDtPOps_Destroy
737	};
738
739
740
741
742	/*
743	*
744	* Support Driver Tracer Interface.
745	* Support Driver Tracer Interface.
746	* Support Driver Tracer Interface.
747	*
748	*/
749
750
751
752	/**
753	* interface_method_impl{SUPDRVTRACERREG,pfnProbeFireKernel}
754	*/
755	static DECLCALLBACK(void) vboxDtTOps_ProbeFireKernel(struct VTGPROBELOC *pVtgProbeLoc, uintptr_t uArg0, uintptr_t uArg1, uintptr_t uArg2,
756	uintptr_t uArg3, uintptr_t uArg4)
757	{
758	AssertPtrReturnVoid(pVtgProbeLoc);
759	LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pVtgProbeLoc, pVtgProbeLoc->idProbe));
760	AssertPtrReturnVoid(pVtgProbeLoc->pProbe);
761	AssertPtrReturnVoid(pVtgProbeLoc->pszFunction);
762
763	VBDT_SETUP_STACK_DATA(kVBoxDtCaller_ProbeFireKernel);
764
765	pStackData->u.ProbeFireKernel.pauStackArgs = &uArg4 + 1;
766
767	#if defined(RT_OS_DARWIN) && ARCH_BITS == 32
768	/*
769	* Convert arguments from uintptr_t to uint64_t.
770	*/
771	PVTGDESCPROBE pProbe = (PVTGDESCPROBE)((PVTGPROBELOC)pVtgProbeLoc)->pProbe;
772	AssertPtrReturnVoid(pProbe);
773	PVTGOBJHDR pVtgHdr = (PVTGOBJHDR)((uintptr_t)pProbe + pProbe->offObjHdr);
774	AssertPtrReturnVoid(pVtgHdr);
775	PVTGDESCARGLIST pArgList = (PVTGDESCARGLIST)((uintptr_t)pVtgHdr + pVtgHdr->offArgLists + pProbe->offArgList);
776	AssertPtrReturnVoid(pArgList);
777	if (!pArgList->fHaveLargeArgs)
778	dtrace_probe(pVtgProbeLoc->idProbe, uArg0, uArg1, uArg2, uArg3, uArg4);
779	else
780	{
781	uintptr_t *auSrcArgs = &uArg0;
782	uint32_t iSrcArg = 0;
783	uint32_t iDstArg = 0;
784	uint64_t au64DstArgs[5];
785
786	while ( iDstArg < RT_ELEMENTS(au64DstArgs)
787	&& iSrcArg < pArgList->cArgs)
788	{
789	au64DstArgs[iDstArg] = auSrcArgs[iSrcArg];
790	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iDstArg].fType))
791	au64DstArgs[iDstArg] \|= (uint64_t)auSrcArgs[++iSrcArg] << 32;
792	iSrcArg++;
793	iDstArg++;
794	}
795	while (iDstArg < RT_ELEMENTS(au64DstArgs))
796	au64DstArgs[iDstArg++] = auSrcArgs[iSrcArg++];
797
798	pStackData->u.ProbeFireKernel.pauStackArgs = &auSrcArgs[iSrcArg];
799	dtrace_probe(pVtgProbeLoc->idProbe, au64DstArgs[0], au64DstArgs[1], au64DstArgs[2], au64DstArgs[3], au64DstArgs[4]);
800	}
801	#else
802	dtrace_probe(pVtgProbeLoc->idProbe, uArg0, uArg1, uArg2, uArg3, uArg4);
803	#endif
804
805	VBDT_CLEAR_STACK_DATA();
806	LOG_DTRACE(("%s: returns\n", __FUNCTION__));
807	}
808
809
810	/**
811	* interface_method_impl{SUPDRVTRACERREG,pfnProbeFireUser}
812	*/
813	static DECLCALLBACK(void) vboxDtTOps_ProbeFireUser(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, PCSUPDRVTRACERUSRCTX pCtx,
814	PCVTGOBJHDR pVtgHdr, PCVTGPROBELOC pProbeLocRO)
815	{
816	LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pCtx, pCtx->idProbe));
817	AssertPtrReturnVoid(pProbeLocRO);
818	AssertPtrReturnVoid(pVtgHdr);
819
820	VBDT_SETUP_STACK_DATA(kVBoxDtCaller_ProbeFireUser);
821
822	if (pCtx->cBits == 32)
823	{
824	pStackData->u.ProbeFireUser.pCtx = pCtx;
825	pStackData->u.ProbeFireUser.offArg = 0;
826
827	#if ARCH_BITS == 64 \|\| defined(RT_OS_DARWIN)
828	/*
829	* Combine two 32-bit arguments into one 64-bit argument where needed.
830	*/
831	PVTGDESCPROBE pProbeDesc = pProbeLocRO->pProbe;
832	AssertPtrReturnVoid(pProbeDesc);
833	PVTGDESCARGLIST pArgList = (PVTGDESCARGLIST)((uintptr_t)pVtgHdr + pVtgHdr->offArgLists + pProbeDesc->offArgList);
834	AssertPtrReturnVoid(pArgList);
835
836	if (!pArgList->fHaveLargeArgs)
837	dtrace_probe(pCtx->idProbe,
838	pCtx->u.X86.aArgs[0],
839	pCtx->u.X86.aArgs[1],
840	pCtx->u.X86.aArgs[2],
841	pCtx->u.X86.aArgs[3],
842	pCtx->u.X86.aArgs[4]);
843	else
844	{
845	uint32_t const *auSrcArgs = &pCtx->u.X86.aArgs[0];
846	uint32_t iSrcArg = 0;
847	uint32_t iDstArg = 0;
848	uint64_t au64DstArgs[5];
849
850	while ( iDstArg < RT_ELEMENTS(au64DstArgs)
851	&& iSrcArg < pArgList->cArgs)
852	{
853	au64DstArgs[iDstArg] = auSrcArgs[iSrcArg];
854	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iDstArg].fType))
855	au64DstArgs[iDstArg] \|= (uint64_t)auSrcArgs[++iSrcArg] << 32;
856	iSrcArg++;
857	iDstArg++;
858	}
859	while (iDstArg < RT_ELEMENTS(au64DstArgs))
860	au64DstArgs[iDstArg++] = auSrcArgs[iSrcArg++];
861
862	pStackData->u.ProbeFireUser.offArg = iSrcArg - RT_ELEMENTS(au64DstArgs);
863	dtrace_probe(pCtx->idProbe, au64DstArgs[0], au64DstArgs[1], au64DstArgs[2], au64DstArgs[3], au64DstArgs[4]);
864	}
865	#else
866	dtrace_probe(pCtx->idProbe,
867	pCtx->u.X86.aArgs[0],
868	pCtx->u.X86.aArgs[1],
869	pCtx->u.X86.aArgs[2],
870	pCtx->u.X86.aArgs[3],
871	pCtx->u.X86.aArgs[4]);
872	#endif
873	}
874	else if (pCtx->cBits == 64)
875	{
876	pStackData->u.ProbeFireUser.pCtx = pCtx;
877	pStackData->u.ProbeFireUser.offArg = 0;
878	dtrace_probe(pCtx->idProbe,
879	pCtx->u.Amd64.aArgs[0],
880	pCtx->u.Amd64.aArgs[1],
881	pCtx->u.Amd64.aArgs[2],
882	pCtx->u.Amd64.aArgs[3],
883	pCtx->u.Amd64.aArgs[4]);
884	}
885	else
886	AssertFailed();
887
888	VBDT_CLEAR_STACK_DATA();
889	LOG_DTRACE(("%s: returns\n", __FUNCTION__));
890	}
891
892
893	/**
894	* interface_method_impl{SUPDRVTRACERREG,pfnTracerOpen}
895	*/
896	static DECLCALLBACK(int) vboxDtTOps_TracerOpen(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uint32_t uCookie,
897	uintptr_t uArg, uintptr_t *puSessionData)
898	{
899	NOREF(pThis); NOREF(pSession); NOREF(uCookie); NOREF(uArg);
900	*puSessionData = 0;
901	return VERR_NOT_SUPPORTED;
902	}
903
904
905	/**
906	* interface_method_impl{SUPDRVTRACERREG,pfnTracerClose}
907	*/
908	static DECLCALLBACK(int) vboxDtTOps_TracerIoCtl(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData,
909	uintptr_t uCmd, uintptr_t uArg, int32_t *piRetVal)
910	{
911	NOREF(pThis); NOREF(pSession); NOREF(uSessionData);
912	NOREF(uCmd); NOREF(uArg); NOREF(piRetVal);
913	return VERR_NOT_SUPPORTED;
914	}
915
916
917	/**
918	* interface_method_impl{SUPDRVTRACERREG,pfnTracerClose}
919	*/
920	static DECLCALLBACK(void) vboxDtTOps_TracerClose(PCSUPDRVTRACERREG pThis, PSUPDRVSESSION pSession, uintptr_t uSessionData)
921	{
922	NOREF(pThis); NOREF(pSession); NOREF(uSessionData);
923	return;
924	}
925
926
927	/**
928	* interface_method_impl{SUPDRVTRACERREG,pfnProviderRegister}
929	*/
930	static DECLCALLBACK(int) vboxDtTOps_ProviderRegister(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
931	{
932	LOG_DTRACE(("%s: %p %s/%s\n", __FUNCTION__, pThis, pCore->pszModName, pCore->pszName));
933	AssertReturn(pCore->TracerData.DTrace.idProvider == 0, VERR_INTERNAL_ERROR_3);
934
935	PVTGDESCPROVIDER pDesc = pCore->pDesc;
936	dtrace_pattr_t DtAttrs;
937	vboxDtVtgConvAttr(&DtAttrs.dtpa_provider, &pDesc->AttrSelf);
938	vboxDtVtgConvAttr(&DtAttrs.dtpa_mod, &pDesc->AttrModules);
939	vboxDtVtgConvAttr(&DtAttrs.dtpa_func, &pDesc->AttrFunctions);
940	vboxDtVtgConvAttr(&DtAttrs.dtpa_name, &pDesc->AttrNames);
941	vboxDtVtgConvAttr(&DtAttrs.dtpa_args, &pDesc->AttrArguments);
942
943	/* Note! DTrace may call us back before dtrace_register returns, so we
944	have to point it to pCore->TracerData.DTrace.idProvider. */
945	AssertCompile(sizeof(dtrace_provider_id_t) == sizeof(pCore->TracerData.DTrace.idProvider));
946	int rc = dtrace_register(pCore->pszName,
947	&DtAttrs,
948	DTRACE_PRIV_KERNEL,
949	NULL /* cred */,
950	&g_vboxDtVtgProvOps,
951	pCore,
952	&pCore->TracerData.DTrace.idProvider);
953	if (!rc)
954	{
955	LOG_DTRACE(("%s: idProvider=%p\n", __FUNCTION__, pCore->TracerData.DTrace.idProvider));
956	AssertPtr(pCore->TracerData.DTrace.idProvider);
957	rc = VINF_SUCCESS;
958	}
959	else
960	{
961	pCore->TracerData.DTrace.idProvider = 0;
962	rc = RTErrConvertFromErrno(FIX_UEK_RC(rc));
963	}
964
965	LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
966	return rc;
967	}
968
969
970	/**
971	* interface_method_impl{SUPDRVTRACERREG,pfnProviderDeregister}
972	*/
973	static DECLCALLBACK(int) vboxDtTOps_ProviderDeregister(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
974	{
975	uintptr_t idProvider = pCore->TracerData.DTrace.idProvider;
976	LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pThis, idProvider));
977	AssertPtrReturn(idProvider, VERR_INTERNAL_ERROR_3);
978
979	dtrace_invalidate(idProvider);
980	int rc = dtrace_unregister(idProvider);
981	if (!rc)
982	{
983	pCore->TracerData.DTrace.idProvider = 0;
984	rc = VINF_SUCCESS;
985	}
986	else
987	{
988	AssertMsg(FIX_UEK_RC(rc) == EBUSY, ("%d\n", rc));
989	pCore->TracerData.DTrace.fZombie = true;
990	rc = VERR_TRY_AGAIN;
991	}
992
993	LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
994	return rc;
995	}
996
997
998	/**
999	* interface_method_impl{SUPDRVTRACERREG,pfnProviderDeregisterZombie}
1000	*/
1001	static DECLCALLBACK(int) vboxDtTOps_ProviderDeregisterZombie(PCSUPDRVTRACERREG pThis, PSUPDRVVDTPROVIDERCORE pCore)
1002	{
1003	uintptr_t idProvider = pCore->TracerData.DTrace.idProvider;
1004	LOG_DTRACE(("%s: %p / %p\n", __FUNCTION__, pThis, idProvider));
1005	AssertPtrReturn(idProvider, VERR_INTERNAL_ERROR_3);
1006	Assert(pCore->TracerData.DTrace.fZombie);
1007
1008	int rc = dtrace_unregister(idProvider);
1009	if (!rc)
1010	{
1011	pCore->TracerData.DTrace.idProvider = 0;
1012	rc = VINF_SUCCESS;
1013	}
1014	else
1015	{
1016	AssertMsg(FIX_UEK_RC(rc) == EBUSY, ("%d\n", rc));
1017	rc = VERR_TRY_AGAIN;
1018	}
1019
1020	LOG_DTRACE(("%s: returns %Rrc\n", __FUNCTION__, rc));
1021	return rc;
1022	}
1023
1024
1025
1026	/**
1027	* The tracer registration record of the VBox DTrace implementation
1028	*/
1029	static SUPDRVTRACERREG g_VBoxDTraceReg =
1030	{
1031	SUPDRVTRACERREG_MAGIC,
1032	SUPDRVTRACERREG_VERSION,
1033	vboxDtTOps_ProbeFireKernel,
1034	vboxDtTOps_ProbeFireUser,
1035	vboxDtTOps_TracerOpen,
1036	vboxDtTOps_TracerIoCtl,
1037	vboxDtTOps_TracerClose,
1038	vboxDtTOps_ProviderRegister,
1039	vboxDtTOps_ProviderDeregister,
1040	vboxDtTOps_ProviderDeregisterZombie,
1041	SUPDRVTRACERREG_MAGIC
1042	};
1043
1044
1045
1046	/**
1047	* Module initialization code.
1048	*
1049	* @param hMod Opque module handle.
1050	*/
1051	const SUPDRVTRACERREG * VBOXCALL supdrvDTraceInit(void)
1052	{
1053	#if defined(RT_OS_DARWIN) \|\| defined(RT_OS_LINUX)
1054	/*
1055	* Resolve the kernel symbols we need.
1056	*/
1057	# ifndef RT_OS_LINUX
1058	RTDBGKRNLINFO hKrnlInfo;
1059	int rc = RTR0DbgKrnlInfoOpen(&hKrnlInfo, 0);
1060	if (RT_FAILURE(rc))
1061	{
1062	SUPR0Printf("supdrvDTraceInit: RTR0DbgKrnlInfoOpen failed with rc=%d.\n", rc);
1063	return NULL;
1064	}
1065	# endif
1066
1067	static const struct
1068	{
1069	const char *pszName;
1070	PFNRT *ppfn;
1071	} s_aDTraceFunctions[] =
1072	{
1073	{ "dtrace_probe", (PFNRT*)&dtrace_probe },
1074	{ "dtrace_probe_create", (PFNRT*)&dtrace_probe_create },
1075	{ "dtrace_probe_lookup", (PFNRT*)&dtrace_probe_lookup },
1076	{ "dtrace_register", (PFNRT*)&dtrace_register },
1077	{ "dtrace_invalidate", (PFNRT*)&dtrace_invalidate },
1078	{ "dtrace_unregister", (PFNRT*)&dtrace_unregister },
1079	};
1080	unsigned i;
1081	for (i = 0; i < RT_ELEMENTS(s_aDTraceFunctions); i++)
1082	{
1083	# ifndef RT_OS_LINUX
1084	rc = RTR0DbgKrnlInfoQuerySymbol(hKrnlInfo, NULL, s_aDTraceFunctions[i].pszName,
1085	(void **)s_aDTraceFunctions[i].ppfn);
1086	if (RT_FAILURE(rc))
1087	{
1088	SUPR0Printf("supdrvDTraceInit: Failed to resolved '%s' (rc=%Rrc, i=%u).\n", s_aDTraceFunctions[i].pszName, rc, i);
1089	break;
1090	}
1091	# else
1092	unsigned long ulAddr = kallsyms_lookup_name(s_aDTraceFunctions[i].pszName);
1093	if (!ulAddr)
1094	{
1095	SUPR0Printf("supdrvDTraceInit: Failed to resolved '%s' (i=%u).\n", s_aDTraceFunctions[i].pszName, i);
1096	return NULL;
1097	}
1098	*s_aDTraceFunctions[i].ppfn = (PFNRT)ulAddr;
1099	# endif
1100	}
1101
1102	# ifndef RT_OS_LINUX
1103	RTR0DbgKrnlInfoRelease(hKrnlInfo);
1104	if (RT_FAILURE(rc))
1105	return NULL;
1106	# else
1107	/** @todo grab a reference to the dtrace module... */
1108	# endif
1109	#endif
1110
1111	return &g_VBoxDTraceReg;
1112	}
1113
1114	#ifndef VBOX_WITH_NATIVE_DTRACE
1115	# error "VBOX_WITH_NATIVE_DTRACE is not defined as it should"
1116	#endif
1117

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

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

Download in other formats: