VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

source: vbox/trunk/src/VBox/HostDrivers/Support/SUPDrvTracer.cpp@ 67954

Last change on this file since 67954 was 62665, checked in by vboxsync, 8 years ago
SUPDrv: warnings
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 89.7 KB

Rev	Line
[40518]	1	/* $Id: SUPDrvTracer.cpp 62665 2016-07-28 23:44:29Z vboxsync $ */
	2	/** @file
[40777]	3	* VBoxDrv - The VirtualBox Support Driver - Tracer Interface.
[40518]	4	*/
	5
	6	/*
[62490]	7	* Copyright (C) 2012-2016 Oracle Corporation
[40518]	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
[57358]	28	/*********************************************************************************************************************************
	29	* Header Files *
	30	*********************************************************************************************************************************/
[40518]	31	#define LOG_GROUP LOG_GROUP_SUP_DRV
[40756]	32	#define SUPDRV_AGNOSTIC
[40518]	33	#include "SUPDrvInternal.h"
	34
	35	#include <VBox/err.h>
[40605]	36	#include <VBox/log.h>
[40600]	37	#include <VBox/VBoxTpG.h>
[40602]	38
[40518]	39	#include <iprt/assert.h>
[40602]	40	#include <iprt/ctype.h>
	41	#include <iprt/list.h>
	42	#include <iprt/mem.h>
	43	#include <iprt/semaphore.h>
[40636]	44	#include <iprt/thread.h>
[41117]	45	#include <iprt/param.h>
	46	#include <iprt/uuid.h>
[40518]	47
	48
[57358]	49	/*********************************************************************************************************************************
	50	* Structures and Typedefs *
	51	*********************************************************************************************************************************/
[41117]	52	/** Pointer to a user tracer module registration record. */
	53	typedef struct SUPDRVTRACERUMOD *PSUPDRVTRACERUMOD;
	54
[40600]	55	/**
[40756]	56	* Data for a tracepoint provider.
[40600]	57	*/
[40756]	58	typedef struct SUPDRVTPPROVIDER
[40600]	59	{
	60	/** The entry in the provider list for this image. */
[40756]	61	RTLISTNODE ListEntry;
[41117]	62	/** The entry in the per session provider list for this image. */
	63	RTLISTNODE SessionListEntry;
[40518]	64
[40756]	65	/** The core structure. */
	66	SUPDRVVDTPROVIDERCORE Core;
[40600]	67
	68	/** Pointer to the image this provider resides in. NULL if it's a
	69	* driver. */
[40756]	70	PSUPDRVLDRIMAGE pImage;
[40600]	71	/** The session this provider is associated with if registered via
[40602]	72	* SUPR0VtgRegisterDrv. NULL if pImage is set. */
[40756]	73	PSUPDRVSESSION pSession;
[41117]	74	/** The user tracepoint module associated with this provider. NULL if
	75	* pImage is set. */
	76	PSUPDRVTRACERUMOD pUmod;
[40602]	77
[40812]	78	/** Used to indicate that we've called pfnProviderDeregistered already and it
	79	* failed because the provider was busy. Next time we must try
	80	* pfnProviderDeregisterZombie.
	81	*
	82	* @remarks This does not necessiarly mean the provider is in the zombie
	83	* list. See supdrvTracerCommonDeregisterImpl. */
[40756]	84	bool fZombie;
	85	/** Set if the provider has been successfully registered with the
	86	* tracer. */
	87	bool fRegistered;
[40704]	88	/** The provider name (for logging purposes). */
[40756]	89	char szName[1];
	90	} SUPDRVTPPROVIDER;
	91	/** Pointer to the data for a tracepoint provider. */
	92	typedef SUPDRVTPPROVIDER *PSUPDRVTPPROVIDER;
[40600]	93
	94
[41117]	95	/**
	96	* User tracer module VTG data copy.
	97	*/
	98	typedef struct SUPDRVVTGCOPY
	99	{
	100	/** Magic (SUDPRVVTGCOPY_MAGIC). */
	101	uint32_t u32Magic;
	102	/** Refernece counter (we expect to share a lot of these). */
	103	uint32_t cRefs;
	104	/** The size of the */
	105	uint32_t cbStrTab;
	106	/** Image type flags. */
	107	uint32_t fFlags;
	108	/** Hash list entry (SUPDRVDEVEXT::aTrackerUmodHash). */
	109	RTLISTNODE ListEntry;
	110	/** The VTG object header.
	111	* The rest of the data follows immediately afterwards. First the object,
	112	* then the probe locations and finally the probe location string table. All
	113	* pointers are fixed up to point within this data. */
	114	VTGOBJHDR Hdr;
	115	} SUPDRVVTGCOPY;
	116	/** Pointer to a VTG object copy. */
	117	typedef SUPDRVVTGCOPY *PSUPDRVVTGCOPY;
	118	/** Magic value for SUPDRVVTGCOPY. */
	119	#define SUDPRVVTGCOPY_MAGIC UINT32_C(0x00080386)
	120
	121
	122	/**
	123	* User tracer module registration record.
	124	*/
	125	typedef struct SUPDRVTRACERUMOD
	126	{
	127	/** Magic (SUPDRVTRACERUMOD_MAGIC). */
	128	uint32_t u32Magic;
	129	/** List entry. This is anchored in SUPDRVSESSION::UmodList. */
	130	RTLISTNODE ListEntry;
	131	/** The address of the ring-3 VTG header. */
	132	RTR3PTR R3PtrVtgHdr;
	133	/** Pointer to the ring-0 copy of the VTG data. */
	134	PSUPDRVVTGCOPY pVtgCopy;
	135	/** The memory object that locks down the user memory. */
	136	RTR0MEMOBJ hMemObjLock;
	137	/** The memory object that maps the locked memory into kernel space. */
	138	RTR0MEMOBJ hMemObjMap;
	139	/** Pointer to the probe enabled-count array within the mapping. */
	140	uint32_t *pacProbeEnabled;
	141	/** Pointer to the probe location array within the mapping. */
	142	void *pvProbeLocs;
	143	/** The address of the ring-3 probe locations. */
	144	RTR3PTR R3PtrProbeLocs;
	145	/** The lookup table index. */
	146	uint8_t iLookupTable;
	147	/** The module bit count. */
	148	uint8_t cBits;
	149	/** The size of a probe location record. */
	150	uint8_t cbProbeLoc;
	151	/** The number of probe locations. */
	152	uint32_t cProbeLocs;
	153	/** Ring-0 probe location info. */
	154	SUPDRVPROBELOC aProbeLocs[1];
	155	} SUPDRVTRACERUMOD;
	156	/** Magic value for SUPDRVVTGCOPY. */
	157	#define SUPDRVTRACERUMOD_MAGIC UINT32_C(0x00080486)
	158
	159
[57358]	160	/*********************************************************************************************************************************
	161	* Defined Constants And Macros *
	162	*********************************************************************************************************************************/
[40867]	163	/** Simple SUPR0Printf-style logging. */
[40812]	164	#ifdef DEBUG_bird
[40756]	165	# define LOG_TRACER(a_Args) SUPR0Printf a_Args
[40704]	166	#else
[40756]	167	# define LOG_TRACER(a_Args) do { } while (0)
[40704]	168	#endif
	169
[40518]	170
[57358]	171	/*********************************************************************************************************************************
	172	* Global Variables *
	173	*********************************************************************************************************************************/
[40777]	174	/** The address of the current probe fire routine for kernel mode. */
[40781]	175	PFNRT g_pfnSupdrvProbeFireKernel = supdrvTracerProbeFireStub;
[40518]	176
	177
[57358]	178	/*********************************************************************************************************************************
	179	* Internal Functions *
	180	*********************************************************************************************************************************/
[41117]	181	static void supdrvVtgReleaseObjectCopy(PSUPDRVDEVEXT pDevExt, PSUPDRVVTGCOPY pThis);
[40763]	182
[41117]	183
	184
[40763]	185	/**
	186	* Validates a VTG string against length and characterset limitations.
	187	*
	188	* @returns VINF_SUCCESS, VERR_SUPDRV_VTG_BAD_STRING or
	189	* VERR_SUPDRV_VTG_STRING_TOO_LONG.
	190	* @param psz The string.
	191	*/
[40601]	192	static int supdrvVtgValidateString(const char *psz)
	193	{
	194	size_t off = 0;
	195	while (off < _4K)
	196	{
	197	char const ch = psz[off++];
	198	if (!ch)
	199	return VINF_SUCCESS;
[40602]	200	if ( !RTLocCIsAlNum(ch)
[40601]	201	&& ch != ' '
[40612]	202	&& ch != '_'
	203	&& ch != '-'
[40601]	204	&& ch != '('
	205	&& ch != ')'
	206	&& ch != ','
	207	&& ch != '*'
[40602]	208	&& ch != '&'
[40601]	209	)
[40612]	210	{
	211	/RTAssertMsg2("off=%u '%s'\n", off, psz);/
[40601]	212	return VERR_SUPDRV_VTG_BAD_STRING;
[40612]	213	}
[40601]	214	}
	215	return VERR_SUPDRV_VTG_STRING_TOO_LONG;
	216	}
	217
[40763]	218
[41117]	219	/** Used by the validation code below. */
	220	#define MY_CHECK_RET(a_Expr, a_rc) \
	221	MY_CHECK_MSG_RET(a_Expr, ("%s: Validation failed on line " RT_XSTR(__LINE__) ": " #a_Expr "\n", __FUNCTION__), a_rc)
	222
	223	/** Used by the validation code below. */
	224	#define MY_CHECK_MSG_RET(a_Expr, a_PrintfArgs, a_rc) \
	225	do { if (RT_UNLIKELY(!(a_Expr))) { SUPR0Printf a_PrintfArgs; return (a_rc); } } while (0)
	226
	227	/** Used by the validation code below. */
	228	#define MY_WITHIN_IMAGE(p, rc) \
	229	do { \
	230	if (pbImage) \
	231	{ \
	232	if ((uintptr_t)(p) - (uintptr_t)pbImage > cbImage) \
	233	{ \
	234	SUPR0Printf("supdrvVtgValidate: " #rc " - p=%p pbImage=%p cbImage=%#zxline=%u %s\n", \
	235	p, pbImage, cbImage, #p); \
	236	return (rc); \
	237	} \
	238	} \
	239	else if (!RT_VALID_PTR(p)) \
	240	return (rc); \
	241	} while (0)
	242
	243
[40602]	244	/**
[41117]	245	* Validates the VTG object header.
[40602]	246	*
[40600]	247	* @returns VBox status code.
[41117]	248	* @param pVtgHdr The header.
	249	* @param uVtgHdrAddr The address where the header is actually
	250	* loaded.
	251	* @param pbImage The image base, if available.
	252	* @param cbImage The image size, if available.
	253	* @param fUmod Whether this is a user module.
[40600]	254	*/
[41117]	255	static int supdrvVtgValidateHdr(PVTGOBJHDR pVtgHdr, RTUINTPTR uVtgHdrAddr, const uint8_t *pbImage, size_t cbImage, bool fUmod)
[40600]	256	{
[41117]	257	struct VTGAREAS
[40601]	258	{
[41117]	259	uint32_t off;
	260	uint32_t cb;
	261	} const *paAreas;
	262	unsigned cAreas;
	263	unsigned i;
	264	uint32_t cbVtgObj;
	265	uint32_t off;
[40601]	266
[41117]	267	#define MY_VALIDATE_SIZE(cb, cMin, cMax, cbUnit, rcBase) \
[40600]	268	do { \
	269	if ((cb) < (cMin) * (cbUnit)) \
[40851]	270	{ \
[41117]	271	SUPR0Printf("supdrvVtgValidateHdr: " #rcBase "_TOO_FEW - cb=%#zx cMin=%#zx cbUnit=%#zx line=%u %s\n", \
	272	(size_t)(cb), (size_t)(cMin), (size_t)cbUnit, __LINE__, #cb); \
[40602]	273	return rcBase ## _TOO_FEW; \
[40851]	274	} \
[40600]	275	if ((cb) >= (cMax) * (cbUnit)) \
[40851]	276	{ \
[41117]	277	SUPR0Printf("supdrvVtgValidateHdr: " #rcBase "_TOO_MUCH - cb=%#zx cMax=%#zx cbUnit=%#zx line=%u %s\n", \
	278	(size_t)(cb), (size_t)(cMax), (size_t)cbUnit, __LINE__, #cb); \
[40602]	279	return rcBase ## _TOO_MUCH; \
[40851]	280	} \
[40600]	281	if ((cb) / (cbUnit) * (cbUnit) != (cb)) \
[40851]	282	{ \
[41117]	283	SUPR0Printf("supdrvVtgValidateHdr: " #rcBase "_NOT_MULTIPLE - cb=%#zx cbUnit=%#zx line=%u %s\n", \
	284	(size_t)(cb), (size_t)cbUnit, __LINE__, #cb); \
[40602]	285	return rcBase ## _NOT_MULTIPLE; \
[40851]	286	} \
[40600]	287	} while (0)
[41117]	288
	289	#define MY_VALIDATE_OFF(off, cb, cMin, cMax, cbUnit, cbAlign, rcBase) \
[40601]	290	do { \
[41117]	291	if ( (cb) >= cbVtgObj \
	292	\|\| off > cbVtgObj - (cb) ) \
[40601]	293	{ \
[41117]	294	SUPR0Printf("supdrvVtgValidateHdr: " #rcBase "_OFF - off=%#x cb=%#x pVtgHdr=%p cbVtgHdr=%#zx line=%u %s\n", \
	295	(off), (cb), pVtgHdr, cbVtgObj, __LINE__, #off); \
	296	return rcBase ## _OFF; \
[40601]	297	} \
[41117]	298	if (RT_ALIGN(off, cbAlign) != (off)) \
	299	{ \
	300	SUPR0Printf("supdrvVtgValidateHdr: " #rcBase "_OFF - off=%#x align=%#zx line=%u %s\n", \
	301	(off), (size_t)(cbAlign), __LINE__, #off); \
	302	return rcBase ## _OFF; \
	303	} \
	304	MY_VALIDATE_SIZE(cb, cMin, cMax, cbUnit, rcBase); \
[40601]	305	} while (0)
[40600]	306
[40601]	307	/*
[41117]	308	* Make sure both pbImage and cbImage are NULL/0 if one if of them is.
[40601]	309	*/
[41117]	310	if (!pbImage \|\| !cbImage)
	311	{
	312	pbImage = NULL;
	313	cbImage = 0;
	314	cbVtgObj = pVtgHdr->cbObj;
	315	}
	316	else
	317	{
	318	MY_WITHIN_IMAGE(pVtgHdr, VERR_SUPDRV_VTG_BAD_HDR_PTR);
	319	cbVtgObj = pVtgHdr->cbObj;
	320	MY_WITHIN_IMAGE((uint8_t *)pVtgHdr + cbVtgObj - 1, VERR_SUPDRV_VTG_BAD_HDR_PTR);
	321	}
	322
	323	if (cbVtgObj > _1M)
	324	{
	325	SUPR0Printf("supdrvVtgValidateHdr: VERR_SUPDRV_TRACER_TOO_LARGE - cbVtgObj=%#x\n", cbVtgObj);
	326	return VERR_SUPDRV_TRACER_TOO_LARGE;
	327	}
	328
	329	/*
	330	* Set the probe location array offset and size members.
	331	*/
	332	if (!pVtgHdr->offProbeLocs)
	333	{
	334	uint64_t u64Tmp = pVtgHdr->uProbeLocsEnd.u64 - pVtgHdr->uProbeLocs.u64;
	335	if (u64Tmp >= UINT32_MAX)
[41147]	336	{
[41311]	337	SUPR0Printf("supdrvVtgValidateHdr: VERR_SUPDRV_VTG_BAD_HDR_TOO_MUCH - u64Tmp=%#llx ProbeLocs=%#llx ProbeLocsEnd=%#llx\n",
[41147]	338	u64Tmp, pVtgHdr->uProbeLocs.u64, pVtgHdr->uProbeLocsEnd.u64);
[41117]	339	return VERR_SUPDRV_VTG_BAD_HDR_TOO_MUCH;
[41147]	340	}
[49143]	341	/SUPR0Printf("supdrvVtgValidateHdr: cbProbeLocs %#x -> %#x\n", pVtgHdr->cbProbeLocs, (uint32_t)u64Tmp);/
[41117]	342	pVtgHdr->cbProbeLocs = (uint32_t)u64Tmp;
	343
	344	u64Tmp = pVtgHdr->uProbeLocs.u64 - uVtgHdrAddr;
[41311]	345	#ifdef RT_OS_DARWIN
	346	/* The loader and/or ld64-97.17 seems not to generate fixups for our
	347	__VTGObj section. Detect this by comparing them with the
[47518]	348	u64VtgObjSectionStart member and assume max image size of 4MB.
	349	Seems to be worked around by the __VTGPrLc.End and __VTGPrLc.Begin
	350	padding fudge, meaning that the linker misplaced the relocations. */
[41311]	351	if ( (int64_t)u64Tmp != (int32_t)u64Tmp
	352	&& pVtgHdr->u64VtgObjSectionStart != uVtgHdrAddr
	353	&& pVtgHdr->u64VtgObjSectionStart < _4M
	354	&& pVtgHdr->uProbeLocsEnd.u64 < _4M
	355	&& !fUmod)
	356	{
	357	uint64_t offDelta = uVtgHdrAddr - pVtgHdr->u64VtgObjSectionStart;
[49143]	358	/SUPR0Printf("supdrvVtgValidateHdr: offDelta=%#llx\n", offDelta);/
[41311]	359	pVtgHdr->uProbeLocs.u64 += offDelta;
	360	pVtgHdr->uProbeLocsEnd.u64 += offDelta;
	361	u64Tmp += offDelta;
	362	}
	363	#endif
[41117]	364	if ((int64_t)u64Tmp != (int32_t)u64Tmp)
[41147]	365	{
[41311]	366	SUPR0Printf("supdrvVtgValidateHdr: VERR_SUPDRV_VTG_BAD_HDR_PTR - u64Tmp=%#llx uProbeLocs=%#llx uVtgHdrAddr=%RTptr\n",
[41147]	367	u64Tmp, pVtgHdr->uProbeLocs.u64, uVtgHdrAddr);
[41117]	368	return VERR_SUPDRV_VTG_BAD_HDR_PTR;
[41147]	369	}
[49143]	370	/SUPR0Printf("supdrvVtgValidateHdr: offProbeLocs %#x -> %#x\n", pVtgHdr->offProbeLocs, (int32_t)u64Tmp);/
[41117]	371	pVtgHdr->offProbeLocs = (int32_t)u64Tmp;
	372	}
	373
	374	/*
	375	* The non-area description fields.
	376	*/
[40612]	377	if (memcmp(pVtgHdr->szMagic, VTGOBJHDR_MAGIC, sizeof(pVtgHdr->szMagic)))
[49143]	378	{
	379	SUPR0Printf("supdrvVtgValidateHdr: %p: %.16Rhxs\n", pVtgHdr, pVtgHdr->szMagic);
[40601]	380	return VERR_SUPDRV_VTG_MAGIC;
[49143]	381	}
[41117]	382	if ( pVtgHdr->cBits != ARCH_BITS
	383	&& ( !fUmod
	384	\|\| ( pVtgHdr->cBits != 32
	385	&& pVtgHdr->cBits != 64)) )
[40601]	386	return VERR_SUPDRV_VTG_BITS;
[41311]	387	MY_CHECK_RET(pVtgHdr->au32Reserved1[0] == 0, VERR_SUPDRV_VTG_BAD_HDR_MISC);
	388	MY_CHECK_RET(pVtgHdr->au32Reserved1[1] == 0, VERR_SUPDRV_VTG_BAD_HDR_MISC);
	389	MY_CHECK_RET(!RTUuidIsNull(&pVtgHdr->Uuid), VERR_SUPDRV_VTG_BAD_HDR_MISC);
[40600]	390
[41117]	391	/*
	392	* Check the individual area descriptors.
	393	*/
	394	MY_VALIDATE_OFF(pVtgHdr->offStrTab, pVtgHdr->cbStrTab, 4, _1M, sizeof(char), sizeof(uint8_t), VERR_SUPDRV_VTG_BAD_HDR);
	395	MY_VALIDATE_OFF(pVtgHdr->offArgLists, pVtgHdr->cbArgLists, 1, _32K, sizeof(uint32_t), sizeof(uint32_t), VERR_SUPDRV_VTG_BAD_HDR);
	396	MY_VALIDATE_OFF(pVtgHdr->offProbes, pVtgHdr->cbProbes, 1, _32K, sizeof(VTGDESCPROBE), sizeof(uint32_t), VERR_SUPDRV_VTG_BAD_HDR);
	397	MY_VALIDATE_OFF(pVtgHdr->offProviders, pVtgHdr->cbProviders, 1, 16, sizeof(VTGDESCPROVIDER), sizeof(uint32_t), VERR_SUPDRV_VTG_BAD_HDR);
	398	MY_VALIDATE_OFF(pVtgHdr->offProbeEnabled, pVtgHdr->cbProbeEnabled, 1, _32K, sizeof(uint32_t), sizeof(uint32_t), VERR_SUPDRV_VTG_BAD_HDR);
	399	if (!fUmod)
	400	{
	401	MY_WITHIN_IMAGE(pVtgHdr->uProbeLocs.p, VERR_SUPDRV_VTG_BAD_HDR_PTR);
	402	MY_WITHIN_IMAGE(pVtgHdr->uProbeLocsEnd.p, VERR_SUPDRV_VTG_BAD_HDR_PTR);
	403	MY_VALIDATE_SIZE( pVtgHdr->cbProbeLocs, 1, _128K, sizeof(VTGPROBELOC), VERR_SUPDRV_VTG_BAD_HDR);
	404	}
	405	else
	406	{
	407	if (pVtgHdr->cBits == 32)
	408	MY_VALIDATE_SIZE( pVtgHdr->cbProbeLocs, 1, _8K, sizeof(VTGPROBELOC32), VERR_SUPDRV_VTG_BAD_HDR);
	409	else
	410	MY_VALIDATE_SIZE( pVtgHdr->cbProbeLocs, 1, _8K, sizeof(VTGPROBELOC64), VERR_SUPDRV_VTG_BAD_HDR);
	411	/* Will check later that offProbeLocs are following closely on the
	412	enable count array, so no need to validate the offset here. */
	413	}
[40612]	414
[41117]	415	/*
	416	* Some additional consistency checks.
	417	*/
	418	if ( pVtgHdr->uProbeLocsEnd.u64 - pVtgHdr->uProbeLocs.u64 != pVtgHdr->cbProbeLocs
	419	\|\| (int64_t)(pVtgHdr->uProbeLocs.u64 - uVtgHdrAddr) != pVtgHdr->offProbeLocs)
[40851]	420	{
[41117]	421	SUPR0Printf("supdrvVtgValidateHdr: VERR_SUPDRV_VTG_BAD_HDR_MISC - uProbeLocs=%#llx uProbeLocsEnd=%#llx offProbeLocs=%#llx cbProbeLocs=%#x uVtgHdrAddr=%RTptr\n",
	422	pVtgHdr->uProbeLocs.u64, pVtgHdr->uProbeLocsEnd.u64, pVtgHdr->offProbeLocs, pVtgHdr->cbProbeLocs, uVtgHdrAddr);
	423	return VERR_SUPDRV_VTG_BAD_HDR_MISC;
[40851]	424	}
[41117]	425
	426	if (pVtgHdr->cbProbes / sizeof(VTGDESCPROBE) != pVtgHdr->cbProbeEnabled / sizeof(uint32_t))
[40851]	427	{
[41117]	428	SUPR0Printf("supdrvVtgValidateHdr: VERR_SUPDRV_VTG_BAD_HDR_MISC - cbProbeEnabled=%#zx cbProbes=%#zx\n",
	429	pVtgHdr->cbProbeEnabled, pVtgHdr->cbProbes);
	430	return VERR_SUPDRV_VTG_BAD_HDR_MISC;
[40851]	431	}
[41117]	432
	433	/*
	434	* Check that there are no overlapping areas. This is a little bit ugly...
	435	*/
	436	paAreas = (struct VTGAREAS const *)&pVtgHdr->offStrTab;
	437	cAreas = pVtgHdr->offProbeLocs >= 0 ? 6 : 5;
	438	off = sizeof(VTGOBJHDR);
	439	for (i = 0; i < cAreas; i++)
[40851]	440	{
[41117]	441	if (paAreas[i].off < off)
	442	{
	443	SUPR0Printf("supdrvVtgValidateHdr: VERR_SUPDRV_VTG_BAD_HDR_MISC - overlapping areas %d and %d\n", i, i-1);
	444	return VERR_SUPDRV_VTG_BAD_HDR_MISC;
	445	}
	446	off = paAreas[i].off + paAreas[i].cb;
[40851]	447	}
[41117]	448	if ( pVtgHdr->offProbeLocs > 0
	449	&& (uint32_t)-pVtgHdr->offProbeLocs < pVtgHdr->cbProbeLocs)
[40851]	450	{
[41117]	451	SUPR0Printf("supdrvVtgValidateHdr: VERR_SUPDRV_VTG_BAD_HDR_MISC - probe locations overlaps the header\n");
	452	return VERR_SUPDRV_VTG_BAD_HDR_MISC;
[40851]	453	}
[40601]	454
[41117]	455	/*
	456	* Check that the object size is correct.
	457	*/
	458	if (pVtgHdr->cbObj != pVtgHdr->offProbeEnabled + pVtgHdr->cbProbeEnabled)
[40851]	459	{
[41117]	460	SUPR0Printf("supdrvVtgValidateHdr: VERR_SUPDRV_VTG_BAD_HDR_MISC - bad header size %#x, expected %#x\n",
	461	pVtgHdr->cbObj, pVtgHdr->offProbeEnabled + pVtgHdr->cbProbeEnabled);
	462	return VERR_SUPDRV_VTG_BAD_HDR_MISC;
[40851]	463	}
[40601]	464
[41117]	465
	466	return VINF_SUCCESS;
	467	#undef MY_VALIDATE_OFF
	468	#undef MY_VALIDATE_SIZE
	469	}
	470
	471
	472	/**
	473	* Validates the VTG data.
	474	*
	475	* @returns VBox status code.
	476	* @param pVtgHdr The VTG object header of the data to validate.
	477	* @param uVtgHdrAddr The address where the header is actually
	478	* loaded.
	479	* @param pbImage The image base. For validating the probe
	480	* locations.
	481	* @param cbImage The image size to go with @a pbImage.
	482	* @param fUmod Whether this is a user module.
	483	*/
	484	static int supdrvVtgValidate(PVTGOBJHDR pVtgHdr, RTUINTPTR uVtgHdrAddr, const uint8_t *pbImage, size_t cbImage, bool fUmod)
	485	{
	486	uintptr_t offTmp;
	487	uintptr_t i;
	488	uintptr_t cProviders;
	489	int rc;
	490
	491	if (!pbImage \|\| !cbImage)
	492	{
	493	pbImage = NULL;
	494	cbImage = 0;
	495	}
	496
	497	#define MY_VALIDATE_STR(a_offStrTab) \
	498	do { \
	499	if ((a_offStrTab) >= pVtgHdr->cbStrTab) \
	500	return VERR_SUPDRV_VTG_STRTAB_OFF; \
	501	rc = supdrvVtgValidateString((char *)pVtgHdr + pVtgHdr->offStrTab + (a_offStrTab)); \
	502	if (rc != VINF_SUCCESS) \
	503	return rc; \
	504	} while (0)
	505	#define MY_VALIDATE_ATTR(Attr) \
	506	do { \
	507	if ((Attr).u8Code <= (uint8_t)kVTGStability_Invalid \|\| (Attr).u8Code >= (uint8_t)kVTGStability_End) \
	508	return VERR_SUPDRV_VTG_BAD_ATTR; \
	509	if ((Attr).u8Data <= (uint8_t)kVTGStability_Invalid \|\| (Attr).u8Data >= (uint8_t)kVTGStability_End) \
	510	return VERR_SUPDRV_VTG_BAD_ATTR; \
	511	if ((Attr).u8DataDep <= (uint8_t)kVTGClass_Invalid \|\| (Attr).u8DataDep >= (uint8_t)kVTGClass_End) \
	512	return VERR_SUPDRV_VTG_BAD_ATTR; \
	513	} while (0)
	514
[40601]	515	/*
[41117]	516	* The header.
	517	*/
	518	rc = supdrvVtgValidateHdr(pVtgHdr, uVtgHdrAddr, pbImage, cbImage, fUmod);
	519	if (RT_FAILURE(rc))
	520	return rc;
	521
	522	/*
[40601]	523	* Validate the providers.
	524	*/
[40602]	525	cProviders = i = pVtgHdr->cbProviders / sizeof(VTGDESCPROVIDER);
[40601]	526	while (i-- > 0)
[40600]	527	{
[41117]	528	PCVTGDESCPROVIDER pProvider = (PCVTGDESCPROVIDER)((uintptr_t)pVtgHdr + pVtgHdr->offProviders) + i;
	529
	530	MY_VALIDATE_STR(pProvider->offName);
	531	MY_CHECK_RET(pProvider->iFirstProbe < pVtgHdr->cbProbeEnabled / sizeof(uint32_t), VERR_SUPDRV_VTG_BAD_PROVIDER);
	532	MY_CHECK_RET((uint32_t)pProvider->iFirstProbe + pProvider->cProbes <= pVtgHdr->cbProbeEnabled / sizeof(uint32_t),
	533	VERR_SUPDRV_VTG_BAD_PROVIDER);
	534	MY_VALIDATE_ATTR(pProvider->AttrSelf);
	535	MY_VALIDATE_ATTR(pProvider->AttrModules);
	536	MY_VALIDATE_ATTR(pProvider->AttrFunctions);
	537	MY_VALIDATE_ATTR(pProvider->AttrNames);
	538	MY_VALIDATE_ATTR(pProvider->AttrArguments);
	539	MY_CHECK_RET(pProvider->bReserved == 0, VERR_SUPDRV_VTG_BAD_PROVIDER);
[58920]	540	MY_CHECK_RET(pProvider->cProbesEnabled == 0, VERR_SUPDRV_VTG_BAD_PROVIDER);
[58976]	541	MY_CHECK_RET(pProvider->uSettingsSerialNo == 0, VERR_SUPDRV_VTG_BAD_PROVIDER);
[40600]	542	}
	543
	544	/*
[40601]	545	* Validate probes.
[40600]	546	*/
[40601]	547	i = pVtgHdr->cbProbes / sizeof(VTGDESCPROBE);
	548	while (i-- > 0)
	549	{
[41117]	550	PCVTGDESCPROBE pProbe = (PCVTGDESCPROBE)( (uintptr_t)pVtgHdr + pVtgHdr->offProbes) + i;
	551	PCVTGDESCPROVIDER pProvider = (PCVTGDESCPROVIDER)((uintptr_t)pVtgHdr + pVtgHdr->offProviders) + pProbe->idxProvider;
	552	PCVTGDESCARGLIST pArgList = (PCVTGDESCARGLIST)( (uintptr_t)pVtgHdr + pVtgHdr->offArgLists + pProbe->offArgList );
	553	unsigned iArg;
	554	bool fHaveLargeArgs;
[40602]	555
[41117]	556
	557	MY_VALIDATE_STR(pProbe->offName);
	558	MY_CHECK_RET(pProbe->offArgList < pVtgHdr->cbArgLists, VERR_SUPDRV_VTG_BAD_PROBE);
	559	MY_CHECK_RET((pProbe->offArgList & 3) == 0, VERR_SUPDRV_VTG_BAD_PROBE);
	560	MY_CHECK_RET(pProbe->idxEnabled == i, VERR_SUPDRV_VTG_BAD_PROBE); /* The lists are parallel. */
	561	MY_CHECK_RET(pProbe->idxProvider < cProviders, VERR_SUPDRV_VTG_BAD_PROBE);
	562	MY_CHECK_RET(i - pProvider->iFirstProbe < pProvider->cProbes, VERR_SUPDRV_VTG_BAD_PROBE);
	563	if (pProbe->offObjHdr != (intptr_t)pVtgHdr - (intptr_t)pProbe)
[40892]	564	{
[41338]	565	SUPR0Printf("supdrvVtgValidate: VERR_SUPDRV_VTG_BAD_PROBE - iProbe=%u offObjHdr=%d expected %zd\n",
[41117]	566	i, pProbe->offObjHdr, (intptr_t)pVtgHdr - (intptr_t)pProbe);
[40892]	567	return VERR_SUPDRV_VTG_BAD_PROBE;
	568	}
[40602]	569
	570	/* The referenced argument list. */
	571	if (pArgList->cArgs > 16)
[40886]	572	{
[41338]	573	SUPR0Printf("supdrvVtgValidate: VERR_SUPDRV_VTG_BAD_ARGLIST - iProbe=%u cArgs=%u\n", i, pArgList->cArgs);
[40602]	574	return VERR_SUPDRV_VTG_BAD_ARGLIST;
[40886]	575	}
[40878]	576	if (pArgList->fHaveLargeArgs >= 2)
[40886]	577	{
[41338]	578	SUPR0Printf("supdrvVtgValidate: VERR_SUPDRV_VTG_BAD_ARGLIST - iProbe=%u fHaveLargeArgs=%d\n", i, pArgList->fHaveLargeArgs);
[40878]	579	return VERR_SUPDRV_VTG_BAD_ARGLIST;
[40886]	580	}
[40602]	581	if ( pArgList->abReserved[0]
[40878]	582	\|\| pArgList->abReserved[1])
[40886]	583	{
[41338]	584	SUPR0Printf("supdrvVtgValidate: VERR_SUPDRV_VTG_BAD_ARGLIST - reserved MBZ iProbe=%u\n", i);
[40602]	585	return VERR_SUPDRV_VTG_BAD_ARGLIST;
[40886]	586	}
[40878]	587	fHaveLargeArgs = false;
[40602]	588	iArg = pArgList->cArgs;
	589	while (iArg-- > 0)
	590	{
[40886]	591	uint32_t const fType = pArgList->aArgs[iArg].fType;
	592	if (fType & ~VTG_TYPE_VALID_MASK)
	593	{
	594	SUPR0Printf("supdrvVtgValidate: VERR_SUPDRV_TRACER_BAD_ARG_FLAGS - fType=%#x iArg=%u iProbe=%u (#0)\n", fType, iArg, i);
	595	return VERR_SUPDRV_TRACER_BAD_ARG_FLAGS;
	596	}
	597
[40878]	598	switch (pArgList->aArgs[iArg].fType & VTG_TYPE_SIZE_MASK)
	599	{
	600	case 0:
[40880]	601	if (pArgList->aArgs[iArg].fType & VTG_TYPE_FIXED_SIZED)
[40886]	602	{
	603	SUPR0Printf("supdrvVtgValidate: VERR_SUPDRV_TRACER_BAD_ARG_FLAGS - fType=%#x iArg=%u iProbe=%u (#1)\n", fType, iArg, i);
	604	return VERR_SUPDRV_TRACER_BAD_ARG_FLAGS;
	605	}
[40878]	606	break;
	607	case 1: case 2: case 4: case 8:
	608	break;
	609	default:
[40886]	610	SUPR0Printf("supdrvVtgValidate: VERR_SUPDRV_TRACER_BAD_ARG_FLAGS - fType=%#x iArg=%u iProbe=%u (#2)\n", fType, iArg, i);
	611	return VERR_SUPDRV_TRACER_BAD_ARG_FLAGS;
[40878]	612	}
[40886]	613	if (VTG_TYPE_IS_LARGE(pArgList->aArgs[iArg].fType))
[40878]	614	fHaveLargeArgs = true;
[40886]	615
	616	MY_VALIDATE_STR(pArgList->aArgs[iArg].offType);
[40602]	617	}
[40878]	618	if ((uint8_t)fHaveLargeArgs != pArgList->fHaveLargeArgs)
[40881]	619	{
[40886]	620	SUPR0Printf("supdrvVtgValidate: VERR_SUPDRV_TRACER_BAD_ARG_FLAGS - iProbe=%u fHaveLargeArgs=%d expected %d\n",
	621	i, pArgList->fHaveLargeArgs, fHaveLargeArgs);
[40878]	622	return VERR_SUPDRV_VTG_BAD_PROBE;
[40881]	623	}
[40601]	624	}
[40600]	625
[40602]	626	/*
[41117]	627	* Check that pacProbeEnabled is all zeros.
[40602]	628	*/
[41117]	629	{
	630	uint32_t const pcProbeEnabled = (uint32_t const )((uintptr_t)pVtgHdr + pVtgHdr->offProbeEnabled);
	631	i = pVtgHdr->cbProbeEnabled / sizeof(uint32_t);
	632	while (i-- > 0)
	633	MY_CHECK_RET(pcProbeEnabled[0] == 0, VERR_SUPDRV_VTG_BAD_PROBE_ENABLED);
	634	}
[40602]	635
	636	/*
	637	* Probe locations.
	638	*/
	639	{
[41311]	640	PVTGPROBELOC paProbeLocs = (PVTGPROBELOC)((intptr_t)pVtgHdr + pVtgHdr->offProbeLocs);
[41117]	641	i = pVtgHdr->cbProbeLocs / sizeof(VTGPROBELOC);
	642	while (i-- > 0)
	643	{
	644	MY_CHECK_RET(paProbeLocs[i].uLine < _1G, VERR_SUPDRV_VTG_BAD_PROBE_LOC);
	645	MY_CHECK_RET(paProbeLocs[i].fEnabled == false, VERR_SUPDRV_VTG_BAD_PROBE_LOC);
	646	MY_CHECK_RET(paProbeLocs[i].idProbe == 0, VERR_SUPDRV_VTG_BAD_PROBE_LOC);
[41130]	647	offTmp = (uintptr_t)paProbeLocs[i].pProbe - (uintptr_t)pVtgHdr->offProbes - (uintptr_t)pVtgHdr;
[41311]	648	#ifdef RT_OS_DARWIN /* See header validation code. */
	649	if ( offTmp >= pVtgHdr->cbProbes
	650	&& pVtgHdr->u64VtgObjSectionStart != uVtgHdrAddr
	651	&& pVtgHdr->u64VtgObjSectionStart < _4M
	652	&& (uintptr_t)paProbeLocs[i].pProbe < _4M
	653	&& !fUmod )
	654	{
	655	uint64_t offDelta = uVtgHdrAddr - pVtgHdr->u64VtgObjSectionStart;
[44247]	656
[41311]	657	paProbeLocs[i].pProbe = (PVTGDESCPROBE)((uintptr_t)paProbeLocs[i].pProbe + offDelta);
[44247]	658	if ((uintptr_t)paProbeLocs[i].pszFunction < _4M)
	659	paProbeLocs[i].pszFunction = (const char *)((uintptr_t)paProbeLocs[i].pszFunction + offDelta);
	660
[41311]	661	offTmp += offDelta;
	662	}
	663	#endif
[41117]	664	MY_CHECK_RET(offTmp < pVtgHdr->cbProbes, VERR_SUPDRV_VTG_BAD_PROBE_LOC);
	665	MY_CHECK_RET(offTmp / sizeof(VTGDESCPROBE) * sizeof(VTGDESCPROBE) == offTmp, VERR_SUPDRV_VTG_BAD_PROBE_LOC);
[44247]	666	MY_WITHIN_IMAGE(paProbeLocs[i].pszFunction, VERR_SUPDRV_VTG_BAD_PROBE_LOC);
[41117]	667	}
[40602]	668	}
	669
[40600]	670	return VINF_SUCCESS;
[41117]	671	}
	672
[40601]	673	#undef MY_VALIDATE_STR
[41117]	674	#undef MY_VALIDATE_ATTR
[40601]	675	#undef MY_WITHIN_IMAGE
[40600]	676
	677
[40518]	678	/**
[40602]	679	* Gets a string from the string table.
	680	*
	681	* @returns Pointer to the string.
	682	* @param pVtgHdr The VTG object header.
	683	* @param offStrTab The string table offset.
	684	*/
	685	static const char *supdrvVtgGetString(PVTGOBJHDR pVtgHdr, uint32_t offStrTab)
	686	{
	687	Assert(offStrTab < pVtgHdr->cbStrTab);
[41117]	688	return (char *)pVtgHdr + pVtgHdr->offStrTab + offStrTab;
[40602]	689	}
	690
	691
	692	/**
[40756]	693	* Frees the provider structure and associated resources.
	694	*
[40675]	695	* @param pProv The provider to free.
	696	*/
[40756]	697	static void supdrvTracerFreeProvider(PSUPDRVTPPROVIDER pProv)
[40675]	698	{
[40813]	699	LOG_TRACER(("Freeing tracepoint provider '%s' / %p\n", pProv->szName, pProv->Core.TracerData.DTrace.idProvider));
[41117]	700	pProv->fRegistered = false;
	701	pProv->fZombie = true;
	702	pProv->Core.pDesc = NULL;
	703	pProv->Core.pHdr = NULL;
	704	pProv->Core.paProbeLocsRO = NULL;
	705	pProv->Core.pvProbeLocsEn = NULL;
	706	pProv->Core.pacProbeEnabled = NULL;
	707	pProv->Core.paR0ProbeLocs = NULL;
	708	pProv->Core.paR0Probes = NULL;
[40756]	709	RT_ZERO(pProv->Core.TracerData);
[40675]	710	RTMemFree(pProv);
	711	}
	712
	713
	714	/**
[41117]	715	* Unlinks and deregisters a provider.
[40756]	716	*
[40704]	717	* If the provider is still busy, it will be put in the zombie list.
[40756]	718	*
[40704]	719	* @param pDevExt The device extension.
[40756]	720	* @param pProv The provider.
	721	*
	722	* @remarks The caller owns mtxTracer.
[40704]	723	*/
[40756]	724	static void supdrvTracerDeregisterVtgObj(PSUPDRVDEVEXT pDevExt, PSUPDRVTPPROVIDER pProv)
[40704]	725	{
	726	int rc;
[41117]	727
	728	RTListNodeRemove(&pProv->ListEntry);
	729	if (pProv->pSession)
	730	{
	731	RTListNodeRemove(&pProv->SessionListEntry);
	732	RTListInit(&pProv->SessionListEntry);
	733	pProv->pSession->cTpProviders--;
	734	}
	735
[40756]	736	if (!pProv->fRegistered \|\| !pDevExt->pTracerOps)
	737	rc = VINF_SUCCESS;
	738	else
[40777]	739	rc = pDevExt->pTracerOps->pfnProviderDeregister(pDevExt->pTracerOps, &pProv->Core);
[40756]	740	if (RT_SUCCESS(rc))
[40704]	741	{
[40756]	742	supdrvTracerFreeProvider(pProv);
[40704]	743	return;
	744	}
	745
[41117]	746	pProv->fZombie = true;
	747	pProv->pImage = NULL;
	748	pProv->pSession = NULL;
	749	pProv->pUmod = NULL;
	750	pProv->Core.pDesc = NULL;
	751	pProv->Core.pHdr = NULL;
	752	pProv->Core.paProbeLocsRO = NULL;
	753	pProv->Core.pvProbeLocsEn = NULL;
	754	pProv->Core.pacProbeEnabled = NULL;
	755	pProv->Core.paR0ProbeLocs = NULL;
	756
[40756]	757	RTListAppend(&pDevExt->TracerProviderZombieList, &pProv->ListEntry);
	758	LOG_TRACER(("Invalidated provider '%s' / %p and put it on the zombie list (rc=%Rrc)\n",
	759	pProv->szName, pProv->Core.TracerData.DTrace.idProvider, rc));
[40704]	760	}
	761
	762
	763	/**
[40756]	764	* Processes the zombie list.
	765	*
[40704]	766	* @param pDevExt The device extension.
	767	*/
[40756]	768	static void supdrvTracerProcessZombies(PSUPDRVDEVEXT pDevExt)
[40704]	769	{
[40756]	770	PSUPDRVTPPROVIDER pProv, pProvNext;
[40704]	771
[40756]	772	RTSemFastMutexRequest(pDevExt->mtxTracer);
	773	RTListForEachSafe(&pDevExt->TracerProviderZombieList, pProv, pProvNext, SUPDRVTPPROVIDER, ListEntry)
[40704]	774	{
[40777]	775	int rc = pDevExt->pTracerOps->pfnProviderDeregisterZombie(pDevExt->pTracerOps, &pProv->Core);
[40756]	776	if (RT_SUCCESS(rc))
[40704]	777	{
	778	RTListNodeRemove(&pProv->ListEntry);
[40756]	779	supdrvTracerFreeProvider(pProv);
[40704]	780	}
	781	}
[40756]	782	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40704]	783	}
	784
	785
	786	/**
[40756]	787	* Unregisters all providers, including zombies, waiting for busy providers to
	788	* go idle and unregister smoothly.
	789	*
	790	* This may block.
	791	*
	792	* @param pDevExt The device extension.
	793	*/
	794	static void supdrvTracerRemoveAllProviders(PSUPDRVDEVEXT pDevExt)
	795	{
	796	uint32_t i;
	797	PSUPDRVTPPROVIDER pProv;
	798	PSUPDRVTPPROVIDER pProvNext;
	799
	800	/*
	801	* Unregister all probes (there should only be one).
	802	*/
	803	RTSemFastMutexRequest(pDevExt->mtxTracer);
	804	RTListForEachSafe(&pDevExt->TracerProviderList, pProv, pProvNext, SUPDRVTPPROVIDER, ListEntry)
	805	{
	806	supdrvTracerDeregisterVtgObj(pDevExt, pProv);
	807	}
	808	RTSemFastMutexRelease(pDevExt->mtxTracer);
	809
	810	/*
[40819]	811	* Try unregister zombies now, sleep on busy ones and tracer opens.
[40756]	812	*/
	813	for (i = 0; ; i++)
	814	{
	815	bool fEmpty;
	816
	817	RTSemFastMutexRequest(pDevExt->mtxTracer);
[40819]	818
	819	/* Zombies */
[40756]	820	RTListForEachSafe(&pDevExt->TracerProviderZombieList, pProv, pProvNext, SUPDRVTPPROVIDER, ListEntry)
	821	{
	822	int rc;
	823	LOG_TRACER(("supdrvTracerRemoveAllProviders: Attemting to unregister '%s' / %p...\n",
	824	pProv->szName, pProv->Core.TracerData.DTrace.idProvider));
	825
	826	if (pDevExt->pTracerOps)
[40777]	827	rc = pDevExt->pTracerOps->pfnProviderDeregisterZombie(pDevExt->pTracerOps, &pProv->Core);
[40756]	828	else
	829	rc = VINF_SUCCESS;
	830	if (!rc)
	831	{
	832	RTListNodeRemove(&pProv->ListEntry);
	833	supdrvTracerFreeProvider(pProv);
	834	}
	835	else if (!(i & 0xf))
	836	SUPR0Printf("supdrvTracerRemoveAllProviders: Waiting on busy provider '%s' / %p (rc=%d)\n",
	837	pProv->szName, pProv->Core.TracerData.DTrace.idProvider, rc);
	838	else
	839	LOG_TRACER(("supdrvTracerRemoveAllProviders: Failed to unregister provider '%s' / %p - rc=%d\n",
	840	pProv->szName, pProv->Core.TracerData.DTrace.idProvider, rc));
	841	}
	842
	843	fEmpty = RTListIsEmpty(&pDevExt->TracerProviderZombieList);
[40819]	844
	845	/* Tracer opens. */
	846	if ( pDevExt->cTracerOpens
	847	&& pDevExt->pTracerOps)
	848	{
	849	fEmpty = false;
	850	if (!(i & 0xf))
	851	SUPR0Printf("supdrvTracerRemoveAllProviders: Waiting on %u opens\n", pDevExt->cTracerOpens);
	852	else
	853	LOG_TRACER(("supdrvTracerRemoveAllProviders: Waiting on %u opens\n", pDevExt->cTracerOpens));
	854	}
	855
[40756]	856	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40819]	857
[40756]	858	if (fEmpty)
	859	break;
	860
	861	/* Delay...*/
	862	RTThreadSleep(1000);
	863	}
	864	}
	865
	866
	867	/**
[40600]	868	* Registers the VTG tracepoint providers of a driver.
[40602]	869	*
	870	* @returns VBox status code.
[58340]	871	* @param pDevExt The device instance data.
[40602]	872	* @param pVtgHdr The VTG object header.
	873	* @param pImage The image if applicable.
	874	* @param pSession The session if applicable.
[41117]	875	* @param pUmod The associated user tracepoint module if
	876	* applicable.
[40602]	877	* @param pszModName The module name.
[40600]	878	*/
[41117]	879	static int supdrvTracerRegisterVtgObj(PSUPDRVDEVEXT pDevExt, PVTGOBJHDR pVtgHdr, PSUPDRVLDRIMAGE pImage,
	880	PSUPDRVSESSION pSession, PSUPDRVTRACERUMOD pUmod, const char *pszModName)
[40600]	881	{
[40602]	882	int rc;
[40819]	883	uintptr_t i;
[40756]	884	PSUPDRVTPPROVIDER pProv;
[41117]	885	size_t cchModName;
[40602]	886
[40600]	887	/*
	888	* Validate input.
	889	*/
	890	AssertPtrReturn(pDevExt, VERR_INVALID_POINTER);
	891	AssertPtrReturn(pVtgHdr, VERR_INVALID_POINTER);
	892	AssertPtrNullReturn(pImage, VERR_INVALID_POINTER);
	893	AssertPtrNullReturn(pSession, VERR_INVALID_POINTER);
	894	AssertPtrReturn(pszModName, VERR_INVALID_POINTER);
[41117]	895	cchModName = strlen(pszModName);
[40600]	896
[40602]	897	if (pImage)
[41117]	898	rc = supdrvVtgValidate(pVtgHdr, (uintptr_t)pVtgHdr,
	899	(const uint8_t *)pImage->pvImage, pImage->cbImageBits,
	900	false /fUmod/);
[40602]	901	else
[41117]	902	rc = supdrvVtgValidate(pVtgHdr, (uintptr_t)pVtgHdr, NULL, 0, pUmod != NULL);
[40602]	903	if (RT_FAILURE(rc))
	904	return rc;
[40600]	905
[41117]	906	/*
	907	* Check that there aren't any obvious duplicates.
	908	* (Yes, this isn't race free, but it's good enough for now.)
	909	*/
[40756]	910	rc = RTSemFastMutexRequest(pDevExt->mtxTracer);
[40704]	911	if (RT_FAILURE(rc))
	912	return rc;
[41133]	913	if (pImage \|\| !pSession \|\| pSession->R0Process == NIL_RTPROCESS)
[40602]	914	{
[41117]	915	RTListForEach(&pDevExt->TracerProviderList, pProv, SUPDRVTPPROVIDER, ListEntry)
[40602]	916	{
[41117]	917	if (pProv->Core.pHdr == pVtgHdr)
	918	{
	919	rc = VERR_SUPDRV_VTG_ALREADY_REGISTERED;
	920	break;
	921	}
	922
	923	if ( pProv->pSession == pSession
	924	&& pProv->pImage == pImage)
	925	{
	926	rc = VERR_SUPDRV_VTG_ONLY_ONCE_PER_SESSION;
	927	break;
	928	}
[40602]	929	}
[41117]	930	}
	931	else
	932	{
	933	RTListForEach(&pSession->TpProviders, pProv, SUPDRVTPPROVIDER, SessionListEntry)
[40704]	934	{
[41117]	935	if (pProv->Core.pHdr == pVtgHdr)
	936	{
	937	rc = VERR_SUPDRV_VTG_ALREADY_REGISTERED;
	938	break;
	939	}
[40704]	940	}
[40602]	941	}
[40756]	942	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40704]	943	if (RT_FAILURE(rc))
	944	return rc;
[40600]	945
	946	/*
[40602]	947	* Register the providers.
[40600]	948	*/
[40602]	949	i = pVtgHdr->cbProviders / sizeof(VTGDESCPROVIDER);
	950	while (i-- > 0)
	951	{
[41117]	952	PVTGDESCPROVIDER pDesc = (PVTGDESCPROVIDER)((uintptr_t)pVtgHdr + pVtgHdr->offProviders) + i;
[40704]	953	const char *pszName = supdrvVtgGetString(pVtgHdr, pDesc->offName);
[41117]	954	size_t const cchName = strlen(pszName) + (pUmod ? 16 : 0);
	955
	956	pProv = (PSUPDRVTPPROVIDER)RTMemAllocZ(RT_OFFSETOF(SUPDRVTPPROVIDER, szName[cchName + 1 + cchModName + 1]));
[40602]	957	if (pProv)
	958	{
[41117]	959	pProv->Core.pszName = &pProv->szName[0];
	960	pProv->Core.pszModName = &pProv->szName[cchName + 1];
	961	pProv->Core.pDesc = pDesc;
	962	pProv->Core.pHdr = pVtgHdr;
	963	pProv->Core.paProbeLocsRO = (PCVTGPROBELOC )((uintptr_t)pVtgHdr + pVtgHdr->offProbeLocs);
	964	if (!pUmod)
	965	{
	966	pProv->Core.pvProbeLocsEn = (void *)((uintptr_t)pVtgHdr + pVtgHdr->offProbeLocs);
	967	pProv->Core.pacProbeEnabled = (uint32_t *)((uintptr_t)pVtgHdr + pVtgHdr->offProbeEnabled);
	968	pProv->Core.paR0ProbeLocs = NULL;
	969	pProv->Core.paR0Probes = NULL;
	970	pProv->Core.cbProbeLocsEn = sizeof(VTGPROBELOC);
	971	pProv->Core.cBits = ARCH_BITS;
	972	pProv->Core.fUmod = false;
	973	}
	974	else
	975	{
	976	pProv->Core.pvProbeLocsEn = pUmod->pvProbeLocs;
	977	pProv->Core.pacProbeEnabled = pUmod->pacProbeEnabled;
	978	pProv->Core.paR0ProbeLocs = &pUmod->aProbeLocs[0];
	979	pProv->Core.paR0Probes = (PSUPDRVPROBEINFO)&pUmod->aProbeLocs[pUmod->cProbeLocs];
	980	pProv->Core.cbProbeLocsEn = pUmod->cbProbeLoc;
	981	pProv->Core.cBits = pUmod->cBits;
	982	pProv->Core.fUmod = true;
	983	}
	984	pProv->pImage = pImage;
	985	pProv->pSession = pSession;
	986	pProv->pUmod = pUmod;
	987	pProv->fZombie = false;
	988	pProv->fRegistered = true;
[40600]	989
[41117]	990	if (!pUmod)
	991	memcpy(pProv->szName, pszName, cchName + 1);
	992	else
	993	RTStrPrintf(pProv->szName, cchName + 1, "%s%u", pszName, (uint32_t)pSession->Process);
	994	memcpy((void *)pProv->Core.pszModName, pszModName, cchModName + 1);
	995
	996	/*
	997	* Do the actual registration and list manipulations while holding
	998	* down the lock.
	999	*/
[40756]	1000	rc = RTSemFastMutexRequest(pDevExt->mtxTracer);
	1001	if (RT_SUCCESS(rc))
[40602]	1002	{
[40812]	1003	if ( pDevExt->pTracerOps
	1004	&& !pDevExt->fTracerUnloading)
[40777]	1005	rc = pDevExt->pTracerOps->pfnProviderRegister(pDevExt->pTracerOps, &pProv->Core);
[40756]	1006	else
	1007	{
	1008	pProv->fRegistered = false;
	1009	rc = VINF_SUCCESS;
	1010	}
[40602]	1011	if (RT_SUCCESS(rc))
	1012	{
[40756]	1013	RTListAppend(&pDevExt->TracerProviderList, &pProv->ListEntry);
[41117]	1014	if (pSession)
	1015	{
	1016	RTListAppend(&pSession->TpProviders, &pProv->SessionListEntry);
	1017	pSession->cTpProviders++;
	1018	}
	1019	else
	1020	RTListInit(&pProv->SessionListEntry);
[40756]	1021	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40813]	1022	LOG_TRACER(("Registered tracepoint provider '%s' in '%s' -> %p\n",
[40756]	1023	pProv->szName, pszModName, pProv->Core.TracerData.DTrace.idProvider));
[40602]	1024	}
	1025	else
[40756]	1026	{
	1027	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40851]	1028	LOG_TRACER(("Failed to register tracepoint provider '%s' in '%s' -> %Rrc\n",
	1029	pProv->szName, pszModName, rc));
[40756]	1030	}
[40602]	1031	}
	1032	}
	1033	else
	1034	rc = VERR_NO_MEMORY;
	1035
[41117]	1036	/*
	1037	* In case of failure, we have to undo any providers we already
	1038	* managed to register.
	1039	*/
[40602]	1040	if (RT_FAILURE(rc))
	1041	{
[40756]	1042	PSUPDRVTPPROVIDER pProvNext;
[40602]	1043
[41117]	1044	if (pProv)
	1045	supdrvTracerFreeProvider(pProv);
	1046
[40756]	1047	RTSemFastMutexRequest(pDevExt->mtxTracer);
[41117]	1048	if (pImage)
[40602]	1049	{
[41117]	1050	RTListForEachReverseSafe(&pDevExt->TracerProviderList, pProv, pProvNext, SUPDRVTPPROVIDER, ListEntry)
[40602]	1051	{
[41117]	1052	if (pProv->Core.pHdr == pVtgHdr)
	1053	supdrvTracerDeregisterVtgObj(pDevExt, pProv);
[40602]	1054	}
	1055	}
[41117]	1056	else
	1057	{
	1058	RTListForEachSafe(&pSession->TpProviders, pProv, pProvNext, SUPDRVTPPROVIDER, SessionListEntry)
	1059	{
	1060	if (pProv->Core.pHdr == pVtgHdr)
	1061	supdrvTracerDeregisterVtgObj(pDevExt, pProv);
	1062	}
	1063	}
[40756]	1064	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40602]	1065	return rc;
	1066	}
	1067	}
	1068
	1069	return VINF_SUCCESS;
[40600]	1070	}
	1071
	1072
	1073	/**
	1074	* Registers the VTG tracepoint providers of a driver.
[40602]	1075	*
	1076	* @returns VBox status code.
	1077	* @param pSession The support driver session handle.
[40600]	1078	* @param pVtgHdr The VTG header.
	1079	* @param pszName The driver name.
	1080	*/
[40763]	1081	SUPR0DECL(int) SUPR0TracerRegisterDrv(PSUPDRVSESSION pSession, PVTGOBJHDR pVtgHdr, const char *pszName)
[40600]	1082	{
[40675]	1083	int rc;
	1084
[40607]	1085	AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
[40600]	1086	AssertPtrReturn(pszName, VERR_INVALID_POINTER);
	1087	AssertPtrReturn(pVtgHdr, VERR_INVALID_POINTER);
[40675]	1088	AssertReturn(pSession->R0Process == NIL_RTR0PROCESS, VERR_INVALID_PARAMETER);
[40851]	1089	LOG_TRACER(("SUPR0TracerRegisterDrv: pSession=%p pVtgHdr=%p pszName=%s\n", pSession, pVtgHdr, pszName));
[40600]	1090
[41117]	1091	rc = supdrvTracerRegisterVtgObj(pSession->pDevExt, pVtgHdr, NULL /pImage/, pSession, NULL /pUmod/, pszName);
[40675]	1092
	1093	/*
	1094	* Try unregister zombies while we have a chance.
	1095	*/
[40756]	1096	supdrvTracerProcessZombies(pSession->pDevExt);
[40675]	1097
	1098	return rc;
[40600]	1099	}
	1100
	1101
	1102	/**
	1103	* Deregister the VTG tracepoint providers of a driver.
[40602]	1104	*
	1105	* @param pSession The support driver session handle.
[40600]	1106	*/
[40763]	1107	SUPR0DECL(void) SUPR0TracerDeregisterDrv(PSUPDRVSESSION pSession)
[40600]	1108	{
[40756]	1109	PSUPDRVTPPROVIDER pProv, pProvNext;
[40602]	1110	PSUPDRVDEVEXT pDevExt;
	1111	AssertReturnVoid(SUP_IS_SESSION_VALID(pSession));
[40675]	1112	AssertReturnVoid(pSession->R0Process == NIL_RTR0PROCESS);
[40851]	1113	LOG_TRACER(("SUPR0TracerDeregisterDrv: pSession=%p\n", pSession));
[40602]	1114
	1115	pDevExt = pSession->pDevExt;
[40675]	1116
	1117	/*
	1118	* Search for providers belonging to this driver session.
	1119	*/
[40756]	1120	RTSemFastMutexRequest(pDevExt->mtxTracer);
[41117]	1121	RTListForEachSafe(&pSession->TpProviders, pProv, pProvNext, SUPDRVTPPROVIDER, SessionListEntry)
[40602]	1122	{
[41117]	1123	supdrvTracerDeregisterVtgObj(pDevExt, pProv);
[40602]	1124	}
[40756]	1125	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40675]	1126
	1127	/*
	1128	* Try unregister zombies while we have a chance.
	1129	*/
[40756]	1130	supdrvTracerProcessZombies(pDevExt);
[40600]	1131	}
	1132
	1133
[40636]	1134	/**
[40756]	1135	* Registers the VTG tracepoint providers of a module loaded by
	1136	* the support driver.
	1137	*
[40636]	1138	* This should be called from the ModuleInit code.
	1139	*
	1140	* @returns VBox status code.
	1141	* @param hMod The module handle.
	1142	* @param pVtgHdr The VTG header.
	1143	*/
[40763]	1144	SUPR0DECL(int) SUPR0TracerRegisterModule(void *hMod, PVTGOBJHDR pVtgHdr)
[40636]	1145	{
	1146	PSUPDRVLDRIMAGE pImage = (PSUPDRVLDRIMAGE)hMod;
	1147	PSUPDRVDEVEXT pDevExt;
[40675]	1148	int rc;
[40600]	1149
[40812]	1150	LOG_TRACER(("SUPR0TracerRegisterModule: %p\n", pVtgHdr));
	1151
[40756]	1152	/*
[40636]	1153	* Validate input and context.
	1154	*/
	1155	AssertPtrReturn(pImage, VERR_INVALID_HANDLE);
	1156	AssertPtrReturn(pVtgHdr, VERR_INVALID_POINTER);
	1157
[40756]	1158	AssertPtrReturn(pImage, VERR_INVALID_POINTER);
[40636]	1159	pDevExt = pImage->pDevExt;
	1160	AssertPtrReturn(pDevExt, VERR_INVALID_POINTER);
	1161	AssertReturn(pDevExt->pLdrInitImage == pImage, VERR_WRONG_ORDER);
	1162	AssertReturn(pDevExt->hLdrInitThread == RTThreadNativeSelf(), VERR_WRONG_ORDER);
[41117]	1163	AssertReturn((uintptr_t)pVtgHdr - (uintptr_t)pImage->pvImage < pImage->cbImageBits, VERR_INVALID_PARAMETER);
[40636]	1164
	1165	/*
[41117]	1166	* Do the job.
[40636]	1167	*/
[41117]	1168	rc = supdrvTracerRegisterVtgObj(pDevExt, pVtgHdr, pImage, NULL /pSession/, NULL /pUmod/, pImage->szName);
[40812]	1169	LOG_TRACER(("SUPR0TracerRegisterModule: rc=%d\n", rc));
[40675]	1170
	1171	/*
	1172	* Try unregister zombies while we have a chance.
	1173	*/
[40756]	1174	supdrvTracerProcessZombies(pDevExt);
[40675]	1175
	1176	return rc;
[40636]	1177	}
	1178
	1179
[40600]	1180	/**
[40763]	1181	* Registers the tracer implementation.
[40636]	1182	*
[40756]	1183	* This should be called from the ModuleInit code or from a ring-0 session.
	1184	*
	1185	* @returns VBox status code.
	1186	* @param hMod The module handle.
	1187	* @param pSession Ring-0 session handle.
	1188	* @param pReg Pointer to the tracer registration structure.
	1189	* @param ppHlp Where to return the tracer helper method table.
[40636]	1190	*/
[40763]	1191	SUPR0DECL(int) SUPR0TracerRegisterImpl(void hMod, PSUPDRVSESSION pSession, PCSUPDRVTRACERREG pReg, PCSUPDRVTRACERHLP ppHlp)
[40636]	1192	{
[40812]	1193	PSUPDRVLDRIMAGE pImage = (PSUPDRVLDRIMAGE)hMod;
	1194	PSUPDRVDEVEXT pDevExt;
	1195	PSUPDRVTPPROVIDER pProv;
	1196	int rc;
[42011]	1197	int rc2;
[40636]	1198
	1199	/*
[40756]	1200	* Validate input and context.
[40636]	1201	*/
[40756]	1202	AssertPtrReturn(ppHlp, VERR_INVALID_POINTER);
	1203	*ppHlp = NULL;
	1204	AssertPtrReturn(pReg, VERR_INVALID_HANDLE);
	1205
	1206	if (pImage)
[40636]	1207	{
[40756]	1208	AssertPtrReturn(pImage, VERR_INVALID_POINTER);
	1209	AssertReturn(pSession == NULL, VERR_INVALID_PARAMETER);
	1210	pDevExt = pImage->pDevExt;
	1211	AssertPtrReturn(pDevExt, VERR_INVALID_POINTER);
	1212	AssertReturn(pDevExt->pLdrInitImage == pImage, VERR_WRONG_ORDER);
	1213	AssertReturn(pDevExt->hLdrInitThread == RTThreadNativeSelf(), VERR_WRONG_ORDER);
[40636]	1214	}
[40756]	1215	else
	1216	{
	1217	AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
	1218	AssertReturn(pSession->R0Process == NIL_RTR0PROCESS, VERR_INVALID_PARAMETER);
	1219	pDevExt = pSession->pDevExt;
	1220	AssertPtrReturn(pDevExt, VERR_INVALID_POINTER);
	1221	}
[40675]	1222
[40812]	1223	AssertReturn(pReg->u32Magic == SUPDRVTRACERREG_MAGIC, VERR_INVALID_MAGIC);
	1224	AssertReturn(pReg->u32Version == SUPDRVTRACERREG_VERSION, VERR_VERSION_MISMATCH);
	1225	AssertReturn(pReg->uEndMagic == SUPDRVTRACERREG_MAGIC, VERR_VERSION_MISMATCH);
[40777]	1226	AssertPtrReturn(pReg->pfnProbeFireKernel, VERR_INVALID_POINTER);
	1227	AssertPtrReturn(pReg->pfnProbeFireUser, VERR_INVALID_POINTER);
	1228	AssertPtrReturn(pReg->pfnTracerOpen, VERR_INVALID_POINTER);
	1229	AssertPtrReturn(pReg->pfnTracerIoCtl, VERR_INVALID_POINTER);
	1230	AssertPtrReturn(pReg->pfnTracerClose, VERR_INVALID_POINTER);
	1231	AssertPtrReturn(pReg->pfnProviderRegister, VERR_INVALID_POINTER);
	1232	AssertPtrReturn(pReg->pfnProviderDeregister, VERR_INVALID_POINTER);
	1233	AssertPtrReturn(pReg->pfnProviderDeregisterZombie, VERR_INVALID_POINTER);
[40636]	1234
[40518]	1235	/*
[40756]	1236	* Do the job.
[40518]	1237	*/
[40756]	1238	rc = RTSemFastMutexRequest(pDevExt->mtxTracer);
[40602]	1239	if (RT_SUCCESS(rc))
	1240	{
[40756]	1241	if (!pDevExt->pTracerOps)
	1242	{
[40812]	1243	LOG_TRACER(("SUPR0TracerRegisterImpl: pReg=%p\n", pReg));
[40756]	1244	pDevExt->pTracerOps = pReg;
	1245	pDevExt->pTracerSession = pSession;
	1246	pDevExt->pTracerImage = pImage;
	1247
[40831]	1248	g_pfnSupdrvProbeFireKernel = (PFNRT)pDevExt->pTracerOps->pfnProbeFireKernel;
	1249
[40756]	1250	*ppHlp = &pDevExt->TracerHlp;
	1251	rc = VINF_SUCCESS;
[40812]	1252
	1253	/*
	1254	* Iterate the already loaded modules and register their providers.
	1255	*/
	1256	RTListForEach(&pDevExt->TracerProviderList, pProv, SUPDRVTPPROVIDER, ListEntry)
	1257	{
	1258	Assert(!pProv->fRegistered);
	1259	pProv->fRegistered = true;
[42011]	1260	rc2 = pDevExt->pTracerOps->pfnProviderRegister(pDevExt->pTracerOps, &pProv->Core);
[40812]	1261	if (RT_FAILURE(rc2))
	1262	{
	1263	pProv->fRegistered = false;
	1264	SUPR0Printf("SUPR0TracerRegisterImpl: Failed to register provider %s::%s - rc=%d\n",
	1265	pProv->Core.pszModName, pProv->szName, rc2);
	1266	}
	1267	}
[40756]	1268	}
	1269	else
	1270	rc = VERR_SUPDRV_TRACER_ALREADY_REGISTERED;
	1271	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40602]	1272	}
[40756]	1273
[40602]	1274	return rc;
[40756]	1275
[40518]	1276	}
	1277
	1278
	1279	/**
[40777]	1280	* Common tracer implementation deregistration code.
[40600]	1281	*
[40777]	1282	* The caller sets fTracerUnloading prior to calling this function.
	1283	*
	1284	* @param pDevExt The device extension structure.
	1285	*/
	1286	static void supdrvTracerCommonDeregisterImpl(PSUPDRVDEVEXT pDevExt)
	1287	{
[40812]	1288	uint32_t i;
	1289	PSUPDRVTPPROVIDER pProv;
	1290	PSUPDRVTPPROVIDER pProvNext;
[40777]	1291
	1292	RTSemFastMutexRequest(pDevExt->mtxTracer);
[40812]	1293
	1294	/*
[40831]	1295	* Reinstall the stub probe-fire function.
	1296	*/
	1297	g_pfnSupdrvProbeFireKernel = supdrvTracerProbeFireStub;
	1298
	1299	/*
[40812]	1300	* Disassociate the tracer implementation from all providers.
	1301	* We will have to wait on busy providers.
	1302	*/
	1303	for (i = 0; ; i++)
	1304	{
	1305	uint32_t cZombies = 0;
	1306
	1307	/* Live providers. */
	1308	RTListForEachSafe(&pDevExt->TracerProviderList, pProv, pProvNext, SUPDRVTPPROVIDER, ListEntry)
	1309	{
	1310	int rc;
[40819]	1311	LOG_TRACER(("supdrvTracerCommonDeregisterImpl: Attemting to unregister '%s' / %p...\n",
[40812]	1312	pProv->szName, pProv->Core.TracerData.DTrace.idProvider));
	1313
	1314	if (!pProv->fRegistered)
	1315	continue;
	1316	if (!pProv->fZombie)
	1317	{
	1318	rc = pDevExt->pTracerOps->pfnProviderDeregister(pDevExt->pTracerOps, &pProv->Core);
	1319	if (RT_FAILURE(rc))
	1320	pProv->fZombie = true;
	1321	}
	1322	else
	1323	rc = pDevExt->pTracerOps->pfnProviderDeregisterZombie(pDevExt->pTracerOps, &pProv->Core);
	1324	if (RT_SUCCESS(rc))
	1325	pProv->fZombie = pProv->fRegistered = false;
	1326	else
	1327	{
	1328	cZombies++;
	1329	if (!(i & 0xf))
	1330	SUPR0Printf("supdrvTracerCommonDeregisterImpl: Waiting on busy provider '%s' / %p (rc=%d)\n",
	1331	pProv->szName, pProv->Core.TracerData.DTrace.idProvider, rc);
	1332	else
	1333	LOG_TRACER(("supdrvTracerCommonDeregisterImpl: Failed to unregister provider '%s' / %p - rc=%d\n",
	1334	pProv->szName, pProv->Core.TracerData.DTrace.idProvider, rc));
	1335	}
	1336	}
	1337
	1338	/* Zombies providers. */
	1339	RTListForEachSafe(&pDevExt->TracerProviderZombieList, pProv, pProvNext, SUPDRVTPPROVIDER, ListEntry)
	1340	{
	1341	int rc;
[40819]	1342	LOG_TRACER(("supdrvTracerCommonDeregisterImpl: Attemting to unregister '%s' / %p (zombie)...\n",
[40812]	1343	pProv->szName, pProv->Core.TracerData.DTrace.idProvider));
	1344
	1345	rc = pDevExt->pTracerOps->pfnProviderDeregisterZombie(pDevExt->pTracerOps, &pProv->Core);
	1346	if (RT_SUCCESS(rc))
	1347	{
	1348	RTListNodeRemove(&pProv->ListEntry);
	1349	supdrvTracerFreeProvider(pProv);
	1350	}
	1351	else
	1352	{
	1353	cZombies++;
	1354	if (!(i & 0xf))
[40819]	1355	SUPR0Printf("supdrvTracerCommonDeregisterImpl: Waiting on busy provider '%s' / %p (rc=%d)\n",
[40812]	1356	pProv->szName, pProv->Core.TracerData.DTrace.idProvider, rc);
	1357	else
[40819]	1358	LOG_TRACER(("supdrvTracerCommonDeregisterImpl: Failed to unregister provider '%s' / %p - rc=%d\n",
[40812]	1359	pProv->szName, pProv->Core.TracerData.DTrace.idProvider, rc));
	1360	}
	1361	}
	1362
[40819]	1363	/* Tracer opens. */
	1364	if (pDevExt->cTracerOpens)
	1365	{
	1366	cZombies++;
	1367	if (!(i & 0xf))
	1368	SUPR0Printf("supdrvTracerCommonDeregisterImpl: Waiting on %u opens\n", pDevExt->cTracerOpens);
	1369	else
	1370	LOG_TRACER(("supdrvTracerCommonDeregisterImpl: Waiting on %u opens\n", pDevExt->cTracerOpens));
	1371	}
	1372
[41117]	1373	/* Tracer calls. */
	1374	if (pDevExt->cTracerCallers)
	1375	{
	1376	cZombies++;
	1377	if (!(i & 0xf))
	1378	SUPR0Printf("supdrvTracerCommonDeregisterImpl: Waiting on %u callers\n", pDevExt->cTracerCallers);
	1379	else
	1380	LOG_TRACER(("supdrvTracerCommonDeregisterImpl: Waiting on %u callers\n", pDevExt->cTracerCallers));
	1381	}
	1382
[40819]	1383	/* Done? */
[40812]	1384	if (cZombies == 0)
	1385	break;
	1386
	1387	/* Delay...*/
	1388	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1389	RTThreadSleep(1000);
	1390	RTSemFastMutexRequest(pDevExt->mtxTracer);
	1391	}
	1392
	1393	/*
	1394	* Deregister the tracer implementation.
	1395	*/
[40777]	1396	pDevExt->pTracerImage = NULL;
	1397	pDevExt->pTracerSession = NULL;
	1398	pDevExt->pTracerOps = NULL;
	1399	pDevExt->fTracerUnloading = false;
[40812]	1400
[40777]	1401	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1402	}
	1403
	1404
	1405	/**
	1406	* Deregister a tracer implementation.
	1407	*
	1408	* This should be called from the ModuleTerm code or from a ring-0 session.
	1409	*
[40518]	1410	* @returns VBox status code.
[40777]	1411	* @param hMod The module handle.
[40756]	1412	* @param pSession Ring-0 session handle.
[40518]	1413	*/
[40777]	1414	SUPR0DECL(int) SUPR0TracerDeregisterImpl(void *hMod, PSUPDRVSESSION pSession)
[40518]	1415	{
[40777]	1416	PSUPDRVLDRIMAGE pImage = (PSUPDRVLDRIMAGE)hMod;
[40756]	1417	PSUPDRVDEVEXT pDevExt;
	1418	int rc;
[40602]	1419
[40518]	1420	/*
[40756]	1421	* Validate input and context.
[40518]	1422	*/
[40777]	1423	if (pImage)
	1424	{
	1425	AssertPtrReturn(pImage, VERR_INVALID_POINTER);
	1426	AssertReturn(pSession == NULL, VERR_INVALID_PARAMETER);
	1427	pDevExt = pImage->pDevExt;
	1428	}
	1429	else
	1430	{
	1431	AssertReturn(SUP_IS_SESSION_VALID(pSession), VERR_INVALID_PARAMETER);
	1432	AssertReturn(pSession->R0Process == NIL_RTR0PROCESS, VERR_INVALID_PARAMETER);
	1433	pDevExt = pSession->pDevExt;
	1434	}
[40756]	1435	AssertPtrReturn(pDevExt, VERR_INVALID_POINTER);
[40518]	1436
[40675]	1437	/*
[40756]	1438	* Do the job.
[40675]	1439	*/
[40756]	1440	rc = RTSemFastMutexRequest(pDevExt->mtxTracer);
	1441	if (RT_SUCCESS(rc))
[40675]	1442	{
[40777]	1443	if ( pImage
	1444	? pDevExt->pTracerImage == pImage
	1445	: pDevExt->pTracerSession == pSession)
[40675]	1446	{
[40812]	1447	LOG_TRACER(("SUPR0TracerDeregisterImpl: Unloading ...\n"));
[40756]	1448	pDevExt->fTracerUnloading = true;
	1449	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40777]	1450	supdrvTracerCommonDeregisterImpl(pDevExt);
[40812]	1451	LOG_TRACER(("SUPR0TracerDeregisterImpl: ... done.\n"));
[40756]	1452	}
	1453	else
[40777]	1454	{
[40756]	1455	rc = VERR_SUPDRV_TRACER_NOT_REGISTERED;
[40777]	1456	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1457	}
[40602]	1458	}
[40675]	1459
[40756]	1460	return rc;
[40518]	1461	}
	1462
	1463
[40777]	1464	/*
	1465	* The probe function is a bit more fun since we need tail jump optimizating.
	1466	*
	1467	* Since we cannot ship yasm sources for linux and freebsd, owing to the cursed
	1468	* rebuilding of the kernel module from scratch at install time, we have to
	1469	* deploy some ugly gcc inline assembly here.
	1470	*/
	1471	#if defined(__GNUC__) && (defined(RT_OS_FREEBSD) \|\| defined(RT_OS_LINUX))
[40798]	1472	__asm__("\
[40784]	1473	.section .text \n\
[40783]	1474	\n\
[40784]	1475	.p2align 2,,3 \n\
	1476	.global SUPR0TracerFireProbe \n\
[40783]	1477	SUPR0TracerFireProbe: \n\
[40777]	1478	");
	1479	# if defined(RT_ARCH_AMD64)
[40798]	1480	__asm__(" \
[48952]	1481	movq g_pfnSupdrvProbeFireKernel(%rip), %rax \n\
	1482	jmp *%rax \n\
[40784]	1483	");
[40777]	1484	# elif defined(RT_ARCH_X86)
[40798]	1485	__asm__("\
[48952]	1486	movl g_pfnSupdrvProbeFireKernel, %eax \n\
	1487	jmp *%eax \n\
[40777]	1488	");
	1489	# else
	1490	# error "Which arch is this?"
[40867]	1491	# endif
[40798]	1492	__asm__("\
[40783]	1493	\n\
[40784]	1494	.type supdrvTracerProbeFireStub,@function \n\
	1495	.global supdrvTracerProbeFireStub \n\
[40783]	1496	supdrvTracerProbeFireStub: \n\
[40784]	1497	ret \n\
[40783]	1498	\n\
[40784]	1499	.previous \n\
[40777]	1500	");
[40819]	1501	# if 0 /* Slickedit on windows highlighting fix */
	1502	)
	1503	# endif
[40777]	1504	#endif
	1505
	1506
[40518]	1507	/**
[40756]	1508	* Module unloading hook, called after execution in the module have ceased.
	1509	*
	1510	* @param pDevExt The device extension structure.
	1511	* @param pImage The image being unloaded.
[40518]	1512	*/
[40756]	1513	void VBOXCALL supdrvTracerModuleUnloading(PSUPDRVDEVEXT pDevExt, PSUPDRVLDRIMAGE pImage)
[40518]	1514	{
[40756]	1515	PSUPDRVTPPROVIDER pProv, pProvNext;
	1516	AssertPtrReturnVoid(pImage); /* paranoia */
[40602]	1517
[40756]	1518	RTSemFastMutexRequest(pDevExt->mtxTracer);
[40602]	1519
[40756]	1520	/*
	1521	* If it is the tracer image, we have to unload all the providers.
	1522	*/
	1523	if (pDevExt->pTracerImage == pImage)
	1524	{
[40812]	1525	LOG_TRACER(("supdrvTracerModuleUnloading: Unloading tracer ...\n"));
[40756]	1526	pDevExt->fTracerUnloading = true;
	1527	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40777]	1528	supdrvTracerCommonDeregisterImpl(pDevExt);
[40812]	1529	LOG_TRACER(("supdrvTracerModuleUnloading: ... done.\n"));
[40756]	1530	}
	1531	else
[40675]	1532	{
[40756]	1533	/*
	1534	* Unregister all providers belonging to this image.
	1535	*/
	1536	RTListForEachSafe(&pDevExt->TracerProviderList, pProv, pProvNext, SUPDRVTPPROVIDER, ListEntry)
[40675]	1537	{
[40756]	1538	if (pProv->pImage == pImage)
	1539	supdrvTracerDeregisterVtgObj(pDevExt, pProv);
[40675]	1540	}
[40602]	1541
[40756]	1542	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40518]	1543
[40756]	1544	/*
	1545	* Try unregister zombies while we have a chance.
	1546	*/
	1547	supdrvTracerProcessZombies(pDevExt);
[40602]	1548	}
[40518]	1549	}
	1550
	1551
	1552	/**
[40759]	1553	* Called when a session is being cleaned up.
	1554	*
	1555	* @param pDevExt The device extension structure.
	1556	* @param pSession The session that is being torn down.
	1557	*/
	1558	void VBOXCALL supdrvTracerCleanupSession(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
	1559	{
	1560	/*
[41117]	1561	* Deregister all providers.
[40759]	1562	*/
[41117]	1563	SUPDRVTPPROVIDER *pProvNext;
	1564	SUPDRVTPPROVIDER *pProv;
	1565	RTSemFastMutexRequest(pDevExt->mtxTracer);
	1566	RTListForEachSafe(&pSession->TpProviders, pProv, pProvNext, SUPDRVTPPROVIDER, SessionListEntry)
	1567	{
	1568	supdrvTracerDeregisterVtgObj(pDevExt, pProv);
	1569	}
	1570	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1571
	1572	/*
	1573	* Clean up instance data the trace may have associated with the session.
	1574	*/
	1575	if (pSession->uTracerData)
	1576	supdrvIOCtl_TracerClose(pDevExt, pSession);
	1577
	1578	/*
	1579	* Deregister any tracer implementation.
	1580	*/
[40759]	1581	if (pSession->R0Process == NIL_RTR0PROCESS)
[41117]	1582	(void)SUPR0TracerDeregisterImpl(NULL, pSession);
	1583
	1584	if (pSession->R0Process != NIL_RTR0PROCESS)
[40759]	1585	{
[41117]	1586	/*
	1587	* Free any lingering user modules. We don't bother holding the lock
	1588	* here as there shouldn't be anyone messing with the session at this
	1589	* point.
	1590	*/
	1591	PSUPDRVTRACERUMOD pUmodNext;
	1592	PSUPDRVTRACERUMOD pUmod;
	1593	RTListForEachSafe(&pSession->TpUmods, pUmod, pUmodNext, SUPDRVTRACERUMOD, ListEntry)
	1594	{
	1595	RTR0MemObjFree(pUmod->hMemObjMap, false /fFreeMappings/);
	1596	RTR0MemObjFree(pUmod->hMemObjLock, false /fFreeMappings/);
	1597	supdrvVtgReleaseObjectCopy(pDevExt, pUmod->pVtgCopy);
	1598	RTMemFree(pUmod);
	1599	}
	1600	}
	1601	}
[40759]	1602
[41117]	1603
	1604	static void supdrvVtgReleaseObjectCopy(PSUPDRVDEVEXT pDevExt, PSUPDRVVTGCOPY pThis)
	1605	{
	1606	uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
	1607	if (!cRefs)
	1608	{
[40759]	1609	RTSemFastMutexRequest(pDevExt->mtxTracer);
[41117]	1610	pThis->u32Magic = ~SUDPRVVTGCOPY_MAGIC;
	1611	RTListNodeRemove(&pThis->ListEntry);
	1612	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1613
	1614	RTMemFree(pThis);
	1615	}
	1616	}
	1617
	1618
	1619	/**
	1620	* Finds a matching VTG object copy, caller owns the lock already.
	1621	*
	1622	* @returns Copy with reference. NULL if not found.
	1623	* @param pHashList The hash list to search.
	1624	* @param pHdr The VTG header (valid).
	1625	* @param cbStrTab The string table size.
	1626	* @param fFlags The user module flags.
	1627	*/
	1628	static PSUPDRVVTGCOPY supdrvVtgFindObjectCopyLocked(PRTLISTANCHOR pHashList, PCVTGOBJHDR pHdr, uint32_t cbStrTab, uint32_t fFlags)
	1629	{
	1630	PSUPDRVVTGCOPY pCur;
	1631
	1632	fFlags &= SUP_TRACER_UMOD_FLAGS_TYPE_MASK;
	1633	RTListForEach(pHashList, pCur, SUPDRVVTGCOPY, ListEntry)
	1634	{
	1635	#define HDR_EQUALS(member) pCur->Hdr.member == pHdr->member
	1636	if ( HDR_EQUALS(Uuid.au32[0])
	1637	&& HDR_EQUALS(Uuid.au32[1])
	1638	&& HDR_EQUALS(Uuid.au32[2])
	1639	&& HDR_EQUALS(Uuid.au32[3])
	1640	&& HDR_EQUALS(cbObj)
	1641	&& HDR_EQUALS(cBits)
	1642	&& pCur->cbStrTab == cbStrTab
	1643	&& pCur->fFlags == fFlags
	1644	)
[40759]	1645	{
[41117]	1646	if (RT_LIKELY( HDR_EQUALS(offStrTab)
	1647	&& HDR_EQUALS(cbStrTab)
	1648	&& HDR_EQUALS(offArgLists)
	1649	&& HDR_EQUALS(cbArgLists)
	1650	&& HDR_EQUALS(offProbes)
	1651	&& HDR_EQUALS(cbProbes)
	1652	&& HDR_EQUALS(offProviders)
	1653	&& HDR_EQUALS(cbProviders)
	1654	&& HDR_EQUALS(offProbeEnabled)
	1655	&& HDR_EQUALS(cbProbeEnabled)
	1656	&& HDR_EQUALS(offProbeLocs)
	1657	&& HDR_EQUALS(cbProbeLocs)
	1658	)
	1659	)
[40759]	1660	{
[41117]	1661	Assert(pCur->cRefs > 0);
	1662	Assert(pCur->cRefs < _1M);
	1663	pCur->cRefs++;
	1664	return pCur;
[40759]	1665	}
	1666	}
[41117]	1667	#undef HDR_EQUALS
	1668	}
[40759]	1669
[41117]	1670	return NULL;
	1671	}
	1672
	1673
	1674	/**
	1675	* Finds a matching VTG object copy.
	1676	*
	1677	* @returns Copy with reference. NULL if not found.
	1678	* @param pDevExt The device extension.
	1679	* @param pHdr The VTG header (valid).
	1680	* @param cbStrTab The string table size.
	1681	* @param fFlags The user module flags.
	1682	*/
	1683	static PSUPDRVVTGCOPY supdrvVtgFindObjectCopy(PSUPDRVDEVEXT pDevExt, PCVTGOBJHDR pHdr, uint32_t cbStrTab, uint32_t fFlags)
	1684	{
	1685	PRTLISTANCHOR pHashList = &pDevExt->aTrackerUmodHash[pHdr->Uuid.au8[3] % RT_ELEMENTS(pDevExt->aTrackerUmodHash)];
	1686	PSUPDRVVTGCOPY pRet;
	1687
	1688	int rc = RTSemFastMutexRequest(pDevExt->mtxTracer);
	1689	AssertRCReturn(rc, NULL);
	1690
	1691	pRet = supdrvVtgFindObjectCopyLocked(pHashList, pHdr, cbStrTab, fFlags);
	1692
	1693	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1694	return pRet;
	1695	}
	1696
	1697
	1698	/**
	1699	* Makes a shared copy of the VTG object.
	1700	*
	1701	* @returns VBox status code.
	1702	* @param pDevExt The device extension.
	1703	* @param pVtgHdr The VTG header (valid).
	1704	* @param R3PtrVtgHdr The ring-3 VTG header address.
	1705	* @param uVtgHdrAddr The address of the VTG header in the context
	1706	* where it is actually used.
	1707	* @param R3PtrStrTab The ring-3 address of the probe location string
	1708	* table. The probe location array have offsets
	1709	* into this instead of funciton name pointers.
	1710	* @param cbStrTab The size of the probe location string table.
	1711	* @param fFlags The user module flags.
	1712	* @param pUmod The structure we've allocated to track the
	1713	* module. This have a valid kernel mapping of the
	1714	* probe location array. Upon successful return,
	1715	* the pVtgCopy member will hold the address of our
	1716	* copy (with a referenced of course).
	1717	*/
	1718	static int supdrvVtgCreateObjectCopy(PSUPDRVDEVEXT pDevExt, PCVTGOBJHDR pVtgHdr, RTR3PTR R3PtrVtgHdr, RTUINTPTR uVtgHdrAddr,
	1719	RTR3PTR R3PtrStrTab, uint32_t cbStrTab, uint32_t fFlags, PSUPDRVTRACERUMOD pUmod)
	1720	{
	1721	/*
	1722	* Calculate the space required, allocate and copy in the data.
	1723	*/
	1724	int rc;
[62665]	1725	uint32_t const cProbeLocs = pVtgHdr->cbProbeLocs / (pVtgHdr->cBits == 32 ? sizeof(VTGPROBELOC32) : sizeof(VTGPROBELOC64));
	1726	uint32_t const cbProbeLocs = cProbeLocs * sizeof(VTGPROBELOC);
	1727	uint32_t const offProbeLocs = RT_ALIGN(pVtgHdr->cbObj, 8);
[41117]	1728	size_t const cb = offProbeLocs + cbProbeLocs + cbStrTab + 1;
	1729	PSUPDRVVTGCOPY pThis = (PSUPDRVVTGCOPY)RTMemAlloc(RT_OFFSETOF(SUPDRVVTGCOPY, Hdr) + cb);
	1730	if (!pThis)
	1731	return VERR_NO_MEMORY;
	1732
	1733	pThis->u32Magic = SUDPRVVTGCOPY_MAGIC;
	1734	pThis->cRefs = 1;
	1735	pThis->cbStrTab = cbStrTab;
	1736	pThis->fFlags = fFlags & SUP_TRACER_UMOD_FLAGS_TYPE_MASK;
	1737	RTListInit(&pThis->ListEntry);
	1738
	1739	rc = RTR0MemUserCopyFrom(&pThis->Hdr, R3PtrVtgHdr, pVtgHdr->cbObj);
	1740	if (RT_SUCCESS(rc))
	1741	{
	1742	char pchStrTab = (char )&pThis->Hdr + offProbeLocs + cbProbeLocs;
	1743	rc = RTR0MemUserCopyFrom(pchStrTab, R3PtrStrTab, cbStrTab);
	1744	if (RT_SUCCESS(rc))
	1745	{
	1746	PVTGPROBELOC paDst = (PVTGPROBELOC)((char *)&pThis->Hdr + offProbeLocs);
	1747	uint32_t i;
	1748
	1749	/*
	1750	* Some paranoia: Overwrite the header with the copy we've already
	1751	* validated and zero terminate the string table.
	1752	*/
	1753	pThis->Hdr = *pVtgHdr;
	1754	pchStrTab[cbStrTab] = '\0';
	1755
	1756	/*
	1757	* Set the probe location array related header members since we're
	1758	* making our own copy in a different location.
	1759	*/
	1760	pThis->Hdr.uProbeLocs.u64 = (uintptr_t)paDst;
	1761	pThis->Hdr.uProbeLocsEnd.u64 = (uintptr_t)paDst + cbProbeLocs;
	1762	pThis->Hdr.offProbeLocs = offProbeLocs;
	1763	pThis->Hdr.cbProbeLocs = cbProbeLocs;
	1764	pThis->Hdr.cBits = ARCH_BITS;
	1765
	1766	/*
[41783]	1767	* Copy, convert and fix up the probe location table.
[41117]	1768	*/
	1769	if (pVtgHdr->cBits == 32)
	1770	{
	1771	uintptr_t const offDelta = (uintptr_t)&pThis->Hdr - uVtgHdrAddr;
	1772	PCVTGPROBELOC32 paSrc = (PCVTGPROBELOC32)pUmod->pvProbeLocs;
	1773
	1774	for (i = 0; i < cProbeLocs; i++)
	1775	{
	1776	paDst[i].uLine = paSrc[i].uLine;
	1777	paDst[i].fEnabled = paSrc[i].fEnabled;
	1778	paDst[i].idProbe = paSrc[i].idProbe;
	1779	if (paSrc[i].pszFunction > cbStrTab)
	1780	{
	1781	rc = VERR_SUPDRV_TRACER_UMOD_STRTAB_OFF_BAD;
	1782	break;
	1783	}
	1784	paDst[i].pszFunction = pchStrTab + paSrc[i].pszFunction;
[41130]	1785	paDst[i].pProbe = (PVTGDESCPROBE)(uintptr_t)(paSrc[i].pProbe + offDelta);
[41117]	1786	}
	1787	}
	1788	else
	1789	{
	1790	uint64_t const offDelta = (uintptr_t)&pThis->Hdr - uVtgHdrAddr;
	1791	PCVTGPROBELOC64 paSrc = (PCVTGPROBELOC64)pUmod->pvProbeLocs;
	1792
	1793	for (i = 0; i < cProbeLocs; i++)
	1794	{
	1795	paDst[i].uLine = paSrc[i].uLine;
	1796	paDst[i].fEnabled = paSrc[i].fEnabled;
	1797	paDst[i].idProbe = paSrc[i].idProbe;
	1798	if (paSrc[i].pszFunction > cbStrTab)
	1799	{
	1800	rc = VERR_SUPDRV_TRACER_UMOD_STRTAB_OFF_BAD;
	1801	break;
	1802	}
	1803	paDst[i].pszFunction = pchStrTab + (uintptr_t)paSrc[i].pszFunction;
[41130]	1804	paDst[i].pProbe = (PVTGDESCPROBE)(uintptr_t)(paSrc[i].pProbe + offDelta);
[41117]	1805	}
	1806	}
	1807
	1808	/*
	1809	* Validate it
	1810	*
	1811	* Note! fUmod is false as this is a kernel copy with all native
	1812	* structures.
	1813	*/
	1814	if (RT_SUCCESS(rc))
	1815	rc = supdrvVtgValidate(&pThis->Hdr, (uintptr_t)&pThis->Hdr, (uint8_t )&pThis->Hdr, cb, false /fUmod*/);
	1816	if (RT_SUCCESS(rc))
	1817	{
	1818	/*
	1819	* Add it to the hash list, making sure nobody raced us.
	1820	*/
	1821	PRTLISTANCHOR pHashList = &pDevExt->aTrackerUmodHash[ pVtgHdr->Uuid.au8[3]
	1822	% RT_ELEMENTS(pDevExt->aTrackerUmodHash)];
	1823
	1824	rc = RTSemFastMutexRequest(pDevExt->mtxTracer);
	1825	if (RT_SUCCESS(rc))
	1826	{
	1827	pUmod->pVtgCopy = supdrvVtgFindObjectCopyLocked(pHashList, pVtgHdr, cbStrTab, fFlags);
	1828	if (!pUmod->pVtgCopy)
	1829	{
	1830	pUmod->pVtgCopy = pThis;
	1831	RTListAppend(pHashList, &pThis->ListEntry);
	1832	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1833	return rc;
	1834	}
	1835
	1836	/*
	1837	* Someone raced us, free our copy and return the existing
	1838	* one instead.
	1839	*/
	1840	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1841	}
	1842	}
	1843	}
[40759]	1844	}
[41117]	1845	RTMemFree(pThis);
	1846	return rc;
	1847	}
[40759]	1848
[41117]	1849
	1850	/**
	1851	* Undoes what supdrvTracerUmodSetProbeIds did.
	1852	*
	1853	* @param pDevExt The device extension.
	1854	* @param pSession The current session.
	1855	* @param pUmod The user tracepoint module.
	1856	*/
	1857	static void supdrvTracerUmodClearProbeIds(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVTRACERUMOD pUmod)
	1858	{
	1859	uint32_t i;
	1860
	1861	AssertReturnVoid(pUmod->iLookupTable < RT_ELEMENTS(pSession->apTpLookupTable));
	1862	AssertReturnVoid(pSession->apTpLookupTable[pUmod->iLookupTable] == pUmod);
	1863
[40759]	1864	/*
[41117]	1865	* Clear the probe IDs and disable the probes.
[40759]	1866	*/
[41117]	1867	i = pUmod->cProbeLocs;
	1868	if (pUmod->cBits == 32)
	1869	{
	1870	PVTGPROBELOC32 paProbeLocs = (PVTGPROBELOC32)pUmod->pvProbeLocs;
	1871	while (i-- > 0)
	1872	paProbeLocs[i].idProbe = 0;
	1873	}
	1874	else
	1875	{
	1876	PVTGPROBELOC64 paProbeLocs = (PVTGPROBELOC64)pUmod->pvProbeLocs;
	1877	while (i-- > 0)
	1878	paProbeLocs[i].idProbe = 0;
	1879	}
	1880
	1881	/*
	1882	* Free the lookup table entry. We'll have to wait for the table to go
	1883	* idle to make sure there are no current users of pUmod.
	1884	*/
	1885	RTSemFastMutexRequest(pDevExt->mtxTracer);
	1886	if (pSession->apTpLookupTable[pUmod->iLookupTable] == pUmod)
	1887	{
	1888	if (pSession->cTpProbesFiring > 0)
	1889	{
[41135]	1890	i = 0;
[41117]	1891	while (pSession->cTpProbesFiring > 0)
	1892	{
	1893	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1894	i++;
	1895	if (!(i & 0xff))
	1896	SUPR0Printf("supdrvTracerUmodClearProbeIds: waiting for lookup table to go idle (i=%u)\n", i);
	1897	RTThreadSleep(10);
	1898	RTSemFastMutexRequest(pDevExt->mtxTracer);
	1899	}
	1900	}
	1901	ASMAtomicWriteNullPtr(&pSession->apTpLookupTable[pUmod->iLookupTable]);
	1902	}
	1903	RTSemFastMutexRelease(pDevExt->mtxTracer);
[40759]	1904	}
	1905
	1906
[41117]	1907	/**
	1908	* Allocates a lookup table entry for the Umod and sets the
	1909	* VTGPROBELOC::idProbe fields in user mode.
	1910	*
	1911	* @returns VINF_SUCCESS or VERR_SUPDRV_TRACER_TOO_MANY_PROVIDERS.
	1912	* @param pDevExt The device extension.
	1913	* @param pSession The current session.
	1914	* @param pUmod The user tracepoint module.
	1915	*/
	1916	static int supdrvTracerUmodSetProbeIds(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVTRACERUMOD pUmod)
[40981]	1917	{
[41117]	1918	uint32_t iBase;
	1919	uint32_t i;
	1920
	1921	/*
	1922	* Allocate a lookup table entry.
	1923	*/
	1924	RTSemFastMutexRequest(pDevExt->mtxTracer);
	1925	for (i = 0; i < RT_ELEMENTS(pSession->apTpLookupTable); i++)
	1926	{
	1927	if (!pSession->apTpLookupTable[i])
	1928	{
	1929	pSession->apTpLookupTable[i] = pUmod;
	1930	pUmod->iLookupTable = i;
	1931	break;
	1932	}
	1933	}
	1934	RTSemFastMutexRelease(pDevExt->mtxTracer);
	1935	if (i >= RT_ELEMENTS(pSession->apTpLookupTable))
	1936	return VERR_SUPDRV_TRACER_TOO_MANY_PROVIDERS;
	1937
	1938	/*
	1939	* Set probe IDs of the usermode probe location to indicate our lookup
	1940	* table entry as well as the probe location array entry.
	1941	*/
	1942	iBase = (uint32_t)pUmod->iLookupTable << 24;
	1943	i = pUmod->cProbeLocs;
	1944	if (pUmod->cBits == 32)
	1945	{
	1946	PVTGPROBELOC32 paProbeLocs = (PVTGPROBELOC32)pUmod->pvProbeLocs;
	1947	while (i-- > 0)
	1948	paProbeLocs[i].idProbe = iBase \| i;
	1949	}
	1950	else
	1951	{
	1952	PVTGPROBELOC64 paProbeLocs = (PVTGPROBELOC64)pUmod->pvProbeLocs;
	1953	while (i-- > 0)
	1954	paProbeLocs[i].idProbe = iBase \| i;
	1955	}
	1956
	1957	return VINF_SUCCESS;
[40981]	1958	}
	1959
[41117]	1960
	1961	int VBOXCALL supdrvIOCtl_TracerUmodRegister(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession,
	1962	RTR3PTR R3PtrVtgHdr, RTUINTPTR uVtgHdrAddr,
	1963	RTR3PTR R3PtrStrTab, uint32_t cbStrTab,
	1964	const char *pszModName, uint32_t fFlags)
[40981]	1965	{
[41117]	1966	VTGOBJHDR Hdr;
	1967	PSUPDRVTRACERUMOD pUmod;
	1968	RTR3PTR R3PtrLock;
	1969	size_t cbLock;
	1970	uint32_t cProbeLocs;
	1971	int rc;
	1972
	1973	/*
	1974	* Validate input.
	1975	*/
	1976	if (pSession->R0Process == NIL_RTR0PROCESS)
	1977	return VERR_INVALID_CONTEXT;
	1978	if ( fFlags != SUP_TRACER_UMOD_FLAGS_EXE
	1979	&& fFlags != SUP_TRACER_UMOD_FLAGS_SHARED)
	1980	return VERR_INVALID_PARAMETER;
	1981
	1982	if (pSession->cTpProviders >= RT_ELEMENTS(pSession->apTpLookupTable))
	1983	return VERR_SUPDRV_TRACER_TOO_MANY_PROVIDERS;
	1984
	1985	if ( cbStrTab < 2
	1986	\|\| cbStrTab > _1M)
	1987	return VERR_SUPDRV_TRACER_UMOD_STRTAB_TOO_BIG;
	1988
	1989	/*
	1990	* Read the VTG header into a temporary buffer and perform some simple
	1991	* validations to make sure we aren't wasting our time here.
	1992	*/
	1993	rc = RTR0MemUserCopyFrom(&Hdr, R3PtrVtgHdr, sizeof(Hdr));
	1994	if (RT_FAILURE(rc))
	1995	return rc;
	1996	rc = supdrvVtgValidateHdr(&Hdr, uVtgHdrAddr, NULL, 0, true /fUmod/);
	1997	if (RT_FAILURE(rc))
	1998	return rc;
	1999	if (Hdr.cbProviders / sizeof(VTGDESCPROVIDER) > 2)
	2000	return VERR_SUPDRV_TRACER_TOO_MANY_PROVIDERS;
	2001
	2002	/*
	2003	* Check how much needs to be locked down and how many probe locations
	2004	* there are.
	2005	*/
	2006	if ( Hdr.offProbeLocs <= 0
	2007	\|\| Hdr.offProbeEnabled > (uint32_t)Hdr.offProbeLocs
	2008	\|\| (uint32_t)Hdr.offProbeLocs - Hdr.offProbeEnabled - Hdr.cbProbeEnabled > 128)
	2009	return VERR_SUPDRV_TRACER_UMOD_NOT_ADJACENT;
	2010	R3PtrLock = R3PtrVtgHdr + Hdr.offProbeEnabled;
	2011	cbLock = Hdr.offProbeLocs + Hdr.cbProbeLocs - Hdr.offProbeEnabled + (R3PtrLock & PAGE_OFFSET_MASK);
	2012	R3PtrLock &= ~(RTR3PTR)PAGE_OFFSET_MASK;
	2013	if (cbLock > _64K)
	2014	return VERR_SUPDRV_TRACER_UMOD_TOO_MANY_PROBES;
	2015
	2016	cProbeLocs = Hdr.cbProbeLocs / (Hdr.cBits == 32 ? sizeof(VTGPROBELOC32) : sizeof(VTGPROBELOC64));
	2017
	2018	/*
	2019	* Allocate the tracker data we keep in the session.
	2020	*/
	2021	pUmod = (PSUPDRVTRACERUMOD)RTMemAllocZ( RT_OFFSETOF(SUPDRVTRACERUMOD, aProbeLocs[cProbeLocs])
	2022	+ (Hdr.cbProbeEnabled / sizeof(uint32_t) * sizeof(SUPDRVPROBEINFO)) );
	2023	if (!pUmod)
	2024	return VERR_NO_MEMORY;
	2025	pUmod->u32Magic = SUPDRVTRACERUMOD_MAGIC;
	2026	RTListInit(&pUmod->ListEntry);
	2027	pUmod->R3PtrVtgHdr = R3PtrVtgHdr;
	2028	pUmod->pVtgCopy = NULL;
	2029	pUmod->hMemObjLock = NIL_RTR0MEMOBJ;
	2030	pUmod->hMemObjMap = NIL_RTR0MEMOBJ;
	2031	pUmod->R3PtrProbeLocs = (RTR3INTPTR)R3PtrVtgHdr + Hdr.offProbeLocs;
	2032	pUmod->iLookupTable = UINT8_MAX;
	2033	pUmod->cBits = Hdr.cBits;
	2034	pUmod->cbProbeLoc = Hdr.cBits == 32 ? sizeof(VTGPROBELOC32) : sizeof(VTGPROBELOC64);
	2035	pUmod->cProbeLocs = cProbeLocs;
	2036
	2037	/*
	2038	* Lock down and map the user-mode structures.
	2039	*/
	2040	rc = RTR0MemObjLockUser(&pUmod->hMemObjLock, R3PtrLock, cbLock, RTMEM_PROT_READ \| RTMEM_PROT_WRITE, NIL_RTR0PROCESS);
	2041	if (RT_SUCCESS(rc))
	2042	{
	2043	rc = RTR0MemObjMapKernel(&pUmod->hMemObjMap, pUmod->hMemObjLock, (void *)-1, 0, RTMEM_PROT_READ \| RTMEM_PROT_WRITE);
	2044	if (RT_SUCCESS(rc))
	2045	{
	2046	pUmod->pacProbeEnabled = (uint32_t *)( (uintptr_t)RTR0MemObjAddress(pUmod->hMemObjMap)
	2047	+ ((uintptr_t)(R3PtrVtgHdr + Hdr.offProbeEnabled) & PAGE_OFFSET_MASK));
	2048	pUmod->pvProbeLocs = (uint8_t *)pUmod->pacProbeEnabled + Hdr.offProbeLocs - Hdr.offProbeEnabled;
	2049
	2050	/*
	2051	* Does some other process use the same module already? If so,
	2052	* share the VTG data with it. Otherwise, make a ring-0 copy it.
	2053	*/
	2054	pUmod->pVtgCopy = supdrvVtgFindObjectCopy(pDevExt, &Hdr, cbStrTab, fFlags);
	2055	if (!pUmod->pVtgCopy)
	2056	rc = supdrvVtgCreateObjectCopy(pDevExt, &Hdr, R3PtrVtgHdr, uVtgHdrAddr, R3PtrStrTab, cbStrTab, fFlags, pUmod);
	2057	if (RT_SUCCESS(rc))
	2058	{
	2059	AssertPtr(pUmod->pVtgCopy);
	2060
	2061	/*
	2062	* Grabe a place in apTpLookupTable and set the probe IDs
	2063	* accordingly.
	2064	*/
	2065	rc = supdrvTracerUmodSetProbeIds(pDevExt, pSession, pUmod);
	2066	if (RT_SUCCESS(rc))
	2067	{
	2068	/*
	2069	* Register the providers.
	2070	*/
	2071	rc = supdrvTracerRegisterVtgObj(pDevExt, &pUmod->pVtgCopy->Hdr,
	2072	NULL /pImage/, pSession, pUmod, pszModName);
	2073	if (RT_SUCCESS(rc))
	2074	{
	2075	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2076	RTListAppend(&pSession->TpUmods, &pUmod->ListEntry);
	2077	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2078
	2079	return VINF_SUCCESS;
	2080	}
	2081
	2082	/* bail out. */
	2083	supdrvTracerUmodClearProbeIds(pDevExt, pSession, pUmod);
	2084	}
	2085	supdrvVtgReleaseObjectCopy(pDevExt, pUmod->pVtgCopy);
	2086	}
	2087	RTR0MemObjFree(pUmod->hMemObjMap, false /fFreeMappings/);
	2088	}
	2089	RTR0MemObjFree(pUmod->hMemObjLock, false /fFreeMappings/);
	2090	}
	2091	pUmod->u32Magic = ~SUPDRVTRACERUMOD_MAGIC;
	2092	RTMemFree(pUmod);
	2093	return rc;
[40981]	2094	}
	2095
[41117]	2096
	2097	int VBOXCALL supdrvIOCtl_TracerUmodDeregister(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, RTR3PTR R3PtrVtgHdr)
[40981]	2098	{
[41117]	2099	PSUPDRVTRACERUMOD pUmod = NULL;
	2100	uint32_t i;
	2101	int rc;
[40981]	2102
[41117]	2103	/*
	2104	* Validate the request.
	2105	*/
	2106	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2107	for (i = 0; i < RT_ELEMENTS(pSession->apTpLookupTable); i++)
	2108	{
	2109	pUmod = pSession->apTpLookupTable[i];
	2110	if ( pUmod
	2111	&& pUmod->u32Magic == SUPDRVTRACERUMOD_MAGIC
	2112	&& pUmod->R3PtrVtgHdr == R3PtrVtgHdr)
	2113	break;
	2114	}
	2115	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2116	if (pUmod)
	2117	{
	2118	SUPDRVTPPROVIDER *pProvNext;
	2119	SUPDRVTPPROVIDER *pProv;
	2120
	2121	/*
	2122	* Remove ourselves from the lookup table and clean up the ring-3 bits
	2123	* we've dirtied. We do this first to make sure no probes are firing
	2124	* when we're destroying the providers in the next step.
	2125	*/
	2126	supdrvTracerUmodClearProbeIds(pDevExt, pSession, pUmod);
	2127
	2128	/*
	2129	* Deregister providers related to the VTG object.
	2130	*/
	2131	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2132	RTListForEachSafe(&pSession->TpProviders, pProv, pProvNext, SUPDRVTPPROVIDER, SessionListEntry)
	2133	{
	2134	if (pProv->pUmod == pUmod)
	2135	supdrvTracerDeregisterVtgObj(pDevExt, pProv);
	2136	}
	2137	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2138
	2139	/*
	2140	* Destroy the Umod object.
	2141	*/
	2142	pUmod->u32Magic = ~SUPDRVTRACERUMOD_MAGIC;
	2143	supdrvVtgReleaseObjectCopy(pDevExt, pUmod->pVtgCopy);
	2144	RTR0MemObjFree(pUmod->hMemObjMap, false /fFreeMappings/);
	2145	RTR0MemObjFree(pUmod->hMemObjLock, false /fFreeMappings/);
	2146	RTMemFree(pUmod);
[44370]	2147	rc = VINF_SUCCESS;
[41117]	2148	}
	2149	else
	2150	rc = VERR_NOT_FOUND;
	2151	return rc;
[40981]	2152	}
	2153
	2154
[40759]	2155	/**
[41117]	2156	* Implementation of supdrvIOCtl_TracerUmodProbeFire and
	2157	* SUPR0TracerUmodProbeFire.
	2158	*
	2159	* @param pDevExt The device extension.
	2160	* @param pSession The calling session.
	2161	* @param pCtx The context record.
	2162	*/
	2163	static void supdrvTracerUmodProbeFire(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVTRACERUSRCTX pCtx)
	2164	{
	2165	/*
	2166	* We cannot trust user mode to hand us the right bits nor not calling us
	2167	* when disabled. So, we have to check for our selves.
	2168	*/
	2169	PSUPDRVTRACERUMOD pUmod;
	2170	uint32_t const iLookupTable = pCtx->idProbe >> 24;
	2171	uint32_t const iProbeLoc = pCtx->idProbe & UINT32_C(0x00ffffff);
	2172
	2173	if (RT_UNLIKELY( !pDevExt->pTracerOps
	2174	\|\| pDevExt->fTracerUnloading))
	2175	return;
	2176	if (RT_UNLIKELY(iLookupTable >= RT_ELEMENTS(pSession->apTpLookupTable)))
	2177	return;
	2178	if (RT_UNLIKELY( pCtx->cBits != 32
	2179	&& pCtx->cBits != 64))
	2180	return;
	2181
	2182	ASMAtomicIncU32(&pSession->cTpProviders);
	2183
	2184	pUmod = pSession->apTpLookupTable[iLookupTable];
	2185	if (RT_LIKELY(pUmod))
	2186	{
	2187	if (RT_LIKELY( pUmod->u32Magic == SUPDRVTRACERUMOD_MAGIC
	2188	&& iProbeLoc < pUmod->cProbeLocs
	2189	&& pCtx->cBits == pUmod->cBits))
	2190	{
[41156]	2191	#if 0 /* This won't work for RC modules. */
[41117]	2192	RTR3PTR R3PtrProbeLoc = pUmod->R3PtrProbeLocs + iProbeLoc * pUmod->cbProbeLoc;
	2193	if (RT_LIKELY( (pCtx->cBits == 32 ? (RTR3PTR)pCtx->u.X86.uVtgProbeLoc : pCtx->u.Amd64.uVtgProbeLoc)
	2194	== R3PtrProbeLoc))
[41156]	2195	#endif
[41117]	2196	{
	2197	if (RT_LIKELY(pUmod->aProbeLocs[iProbeLoc].fEnabled))
	2198	{
[41130]	2199	PSUPDRVVTGCOPY pVtgCopy;
[41117]	2200	ASMAtomicIncU32(&pDevExt->cTracerCallers);
[41130]	2201	pVtgCopy = pUmod->pVtgCopy;
[41117]	2202	if (RT_LIKELY( pDevExt->pTracerOps
[41130]	2203	&& !pDevExt->fTracerUnloading
	2204	&& pVtgCopy))
[41117]	2205	{
[41130]	2206	PCVTGPROBELOC pProbeLocRO;
	2207	pProbeLocRO = (PCVTGPROBELOC)((uintptr_t)&pVtgCopy->Hdr + pVtgCopy->Hdr.offProbeLocs) + iProbeLoc;
	2208
[41117]	2209	pCtx->idProbe = pUmod->aProbeLocs[iProbeLoc].idProbe;
[41130]	2210	pDevExt->pTracerOps->pfnProbeFireUser(pDevExt->pTracerOps, pSession, pCtx, &pVtgCopy->Hdr, pProbeLocRO);
[41117]	2211	}
	2212	ASMAtomicDecU32(&pDevExt->cTracerCallers);
	2213	}
	2214	}
	2215	}
	2216	}
	2217
	2218	ASMAtomicDecU32(&pSession->cTpProviders);
	2219	}
	2220
	2221
	2222	SUPR0DECL(void) SUPR0TracerUmodProbeFire(PSUPDRVSESSION pSession, PSUPDRVTRACERUSRCTX pCtx)
	2223	{
	2224	AssertReturnVoid(SUP_IS_SESSION_VALID(pSession));
	2225	AssertPtrReturnVoid(pCtx);
	2226
	2227	supdrvTracerUmodProbeFire(pSession->pDevExt, pSession, pCtx);
	2228	}
	2229
	2230
	2231	void VBOXCALL supdrvIOCtl_TracerUmodProbeFire(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, PSUPDRVTRACERUSRCTX pCtx)
	2232	{
	2233	supdrvTracerUmodProbeFire(pDevExt, pSession, pCtx);
	2234	}
	2235
	2236
	2237	/**
[40819]	2238	* Open the tracer.
	2239	*
	2240	* @returns VBox status code
	2241	* @param pDevExt The device extension structure.
	2242	* @param pSession The current session.
	2243	* @param uCookie The tracer cookie.
	2244	* @param uArg The tracer open argument.
	2245	*/
	2246	int VBOXCALL supdrvIOCtl_TracerOpen(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, uint32_t uCookie, uintptr_t uArg)
	2247	{
	2248	RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
	2249	int rc;
	2250
	2251	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2252
	2253	if (!pSession->uTracerData)
	2254	{
	2255	if (pDevExt->pTracerOps)
	2256	{
	2257	if (pDevExt->pTracerSession != pSession)
	2258	{
	2259	if (!pDevExt->fTracerUnloading)
	2260	{
	2261	if (pSession->hTracerCaller == NIL_RTNATIVETHREAD)
	2262	{
	2263	pDevExt->cTracerOpens++;
	2264	pSession->uTracerData = ~(uintptr_t)0;
	2265	pSession->hTracerCaller = hNativeSelf;
	2266	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2267
	2268	rc = pDevExt->pTracerOps->pfnTracerOpen(pDevExt->pTracerOps, pSession, uCookie, uArg, &pSession->uTracerData);
	2269
	2270	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2271	if (RT_FAILURE(rc))
	2272	{
	2273	pDevExt->cTracerOpens--;
	2274	pSession->uTracerData = 0;
	2275	}
	2276	pSession->hTracerCaller = NIL_RTNATIVETHREAD;
	2277	}
	2278	else
	2279	rc = VERR_SUPDRV_TRACER_SESSION_BUSY;
	2280	}
	2281	else
	2282	rc = VERR_SUPDRV_TRACER_UNLOADING;
	2283	}
	2284	else
	2285	rc = VERR_SUPDRV_TRACER_CANNOT_OPEN_SELF;
	2286	}
	2287	else
	2288	rc = VERR_SUPDRV_TRACER_NOT_PRESENT;
	2289	}
	2290	else
	2291	rc = VERR_SUPDRV_TRACER_ALREADY_OPENED;
	2292
	2293	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2294	return rc;
	2295	}
	2296
	2297
	2298	/**
	2299	* Closes the tracer.
	2300	*
	2301	* @returns VBox status code.
	2302	* @param pDevExt The device extension structure.
	2303	* @param pSession The current session.
	2304	*/
	2305	int VBOXCALL supdrvIOCtl_TracerClose(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession)
	2306	{
	2307	RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
	2308	int rc;
	2309
	2310	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2311
	2312	if (pSession->uTracerData)
	2313	{
	2314	Assert(pDevExt->cTracerOpens > 0);
	2315
	2316	if (pDevExt->pTracerOps)
	2317	{
	2318	if (pSession->hTracerCaller == NIL_RTNATIVETHREAD)
	2319	{
	2320	uintptr_t uTracerData = pSession->uTracerData;
	2321	pSession->uTracerData = 0;
	2322	pSession->hTracerCaller = hNativeSelf;
	2323	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2324
	2325	pDevExt->pTracerOps->pfnTracerClose(pDevExt->pTracerOps, pSession, uTracerData);
	2326	rc = VINF_SUCCESS;
	2327
	2328	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2329	pSession->hTracerCaller = NIL_RTNATIVETHREAD;
	2330	Assert(pDevExt->cTracerOpens > 0);
	2331	pDevExt->cTracerOpens--;
	2332	}
	2333	else
	2334	rc = VERR_SUPDRV_TRACER_SESSION_BUSY;
	2335	}
	2336	else
	2337	{
	2338	rc = VERR_SUPDRV_TRACER_NOT_PRESENT;
	2339	pSession->uTracerData = 0;
	2340	Assert(pDevExt->cTracerOpens > 0);
	2341	pDevExt->cTracerOpens--;
	2342	}
	2343	}
	2344	else
	2345	rc = VERR_SUPDRV_TRACER_NOT_OPENED;
	2346
	2347	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2348	return rc;
	2349	}
	2350
	2351
	2352	/**
	2353	* Performs a tracer I/O control request.
	2354	*
	2355	* @returns VBox status code.
	2356	* @param pDevExt The device extension structure.
	2357	* @param pSession The current session.
	2358	* @param uCmd The tracer command.
	2359	* @param uArg The tracer argument.
	2360	* @param piRetVal Where to store the tracer specific return value.
	2361	*/
	2362	int VBOXCALL supdrvIOCtl_TracerIOCtl(PSUPDRVDEVEXT pDevExt, PSUPDRVSESSION pSession, uintptr_t uCmd, uintptr_t uArg, int32_t *piRetVal)
	2363	{
	2364	RTNATIVETHREAD hNativeSelf = RTThreadNativeSelf();
	2365	int rc;
	2366
[40823]	2367	*piRetVal = 0;
[40819]	2368	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2369
	2370	if (pSession->uTracerData)
	2371	{
	2372	Assert(pDevExt->cTracerOpens > 0);
	2373	if (pDevExt->pTracerOps)
	2374	{
	2375	if (!pDevExt->fTracerUnloading)
	2376	{
	2377	if (pSession->hTracerCaller == NIL_RTNATIVETHREAD)
	2378	{
	2379	uintptr_t uTracerData = pSession->uTracerData;
	2380	pDevExt->cTracerOpens++;
	2381	pSession->hTracerCaller = hNativeSelf;
	2382	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2383
	2384	rc = pDevExt->pTracerOps->pfnTracerIoCtl(pDevExt->pTracerOps, pSession, uTracerData, uCmd, uArg, piRetVal);
	2385
	2386	RTSemFastMutexRequest(pDevExt->mtxTracer);
	2387	pSession->hTracerCaller = NIL_RTNATIVETHREAD;
	2388	Assert(pDevExt->cTracerOpens > 0);
	2389	pDevExt->cTracerOpens--;
	2390	}
	2391	else
	2392	rc = VERR_SUPDRV_TRACER_SESSION_BUSY;
	2393	}
	2394	else
	2395	rc = VERR_SUPDRV_TRACER_UNLOADING;
	2396	}
	2397	else
	2398	rc = VERR_SUPDRV_TRACER_NOT_PRESENT;
	2399	}
	2400	else
	2401	rc = VERR_SUPDRV_TRACER_NOT_OPENED;
	2402
	2403	RTSemFastMutexRelease(pDevExt->mtxTracer);
	2404	return rc;
	2405	}
	2406
	2407
	2408	/**
[40756]	2409	* Early module initialization hook.
	2410	*
	2411	* @returns VBox status code.
	2412	* @param pDevExt The device extension structure.
[40518]	2413	*/
[40756]	2414	int VBOXCALL supdrvTracerInit(PSUPDRVDEVEXT pDevExt)
[40518]	2415	{
[40756]	2416	/*
[40851]	2417	* Initialize the tracer.
[40756]	2418	*/
	2419	int rc = RTSemFastMutexCreate(&pDevExt->mtxTracer);
	2420	if (RT_SUCCESS(rc))
[40602]	2421	{
[41117]	2422	uint32_t i;
	2423
[40756]	2424	pDevExt->TracerHlp.uVersion = SUPDRVTRACERHLP_VERSION;
	2425	/** @todo */
	2426	pDevExt->TracerHlp.uEndVersion = SUPDRVTRACERHLP_VERSION;
	2427	RTListInit(&pDevExt->TracerProviderList);
	2428	RTListInit(&pDevExt->TracerProviderZombieList);
[41117]	2429	for (i = 0; i < RT_ELEMENTS(pDevExt->aTrackerUmodHash); i++)
	2430	RTListInit(&pDevExt->aTrackerUmodHash[i]);
[40759]	2431
[40975]	2432	#ifdef VBOX_WITH_NATIVE_DTRACE
[40851]	2433	pDevExt->pTracerOps = supdrvDTraceInit();
[40867]	2434	if (pDevExt->pTracerOps)
	2435	g_pfnSupdrvProbeFireKernel = (PFNRT)pDevExt->pTracerOps->pfnProbeFireKernel;
[40851]	2436	#endif
	2437
[40867]	2438	/*
[40851]	2439	* Register the provider for this module, if compiled in.
	2440	*/
[40777]	2441	#ifdef VBOX_WITH_DTRACE_R0DRV
[41117]	2442	rc = supdrvTracerRegisterVtgObj(pDevExt, &g_VTGObjHeader, NULL /pImage/, NULL /pSession/, NULL /pUmod/, "vboxdrv");
[40756]	2443	if (RT_SUCCESS(rc))
	2444	return rc;
[40851]	2445	SUPR0Printf("supdrvTracerInit: supdrvTracerRegisterVtgObj failed with rc=%d\n", rc);
[40756]	2446	RTSemFastMutexDestroy(pDevExt->mtxTracer);
[40851]	2447	#else
	2448
	2449	return VINF_SUCCESS;
	2450	#endif
[40602]	2451	}
[40756]	2452	pDevExt->mtxTracer = NIL_RTSEMFASTMUTEX;
	2453	return rc;
[40518]	2454	}
	2455
	2456
	2457	/**
[40756]	2458	* Late module termination hook.
	2459	*
	2460	* @returns VBox status code.
	2461	* @param pDevExt The device extension structure.
[40518]	2462	*/
[40756]	2463	void VBOXCALL supdrvTracerTerm(PSUPDRVDEVEXT pDevExt)
[40518]	2464	{
[40756]	2465	LOG_TRACER(("supdrvTracerTerm\n"));
[40518]	2466
[40756]	2467	supdrvTracerRemoveAllProviders(pDevExt);
[40518]	2468
[40756]	2469	RTSemFastMutexDestroy(pDevExt->mtxTracer);
	2470	pDevExt->mtxTracer = NIL_RTSEMFASTMUTEX;
	2471	LOG_TRACER(("supdrvTracerTerm: Done\n"));
[40518]	2472	}
	2473

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

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use