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