threadctxhooks-r0drv-solaris.c@ 69405

Last change on this file since 69405 was 69111, checked in by vboxsync, 7 years ago
(C) year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 12.8 KB

Line
1	/* $Id: threadctxhooks-r0drv-solaris.c 69111 2017-10-17 14:26:02Z vboxsync $ */
2	/** @file
3	* IPRT - Thread Context Switching Hook, Ring-0 Driver, Solaris.
4	*/
5
6	/*
7	* Copyright (C) 2013-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	#include "the-solaris-kernel.h"
32	#include "internal/iprt.h"
33
34	#include <iprt/mem.h>
35	#include <iprt/assert.h>
36	#include <iprt/thread.h>
37	#include <iprt/err.h>
38	#include <iprt/asm.h>
39	#include <iprt/log.h>
40	#include "internal/thread.h"
41
42
43	/*********************************************************************************************************************************
44	* Structures and Typedefs *
45	*********************************************************************************************************************************/
46	/**
47	* The internal hook object for solaris.
48	*/
49	typedef struct RTTHREADCTXHOOKINT
50	{
51	/** Magic value (RTTHREADCTXHOOKINT_MAGIC). */
52	uint32_t volatile u32Magic;
53	/** The thread handle (owner) for which the context-hooks are registered. */
54	RTNATIVETHREAD hOwner;
55	/** Pointer to the registered callback function. */
56	PFNRTTHREADCTXHOOK pfnCallback;
57	/** User argument passed to the callback function. */
58	void *pvUser;
59	/** Whether the hook is enabled or not. */
60	bool volatile fEnabled;
61	/** Number of references to this object. */
62	uint32_t volatile cRefs;
63	} RTTHREADCTXHOOKINT;
64	typedef RTTHREADCTXHOOKINT *PRTTHREADCTXHOOKINT;
65
66
67	/*********************************************************************************************************************************
68	* Defined Constants And Macros *
69	*********************************************************************************************************************************/
70	/** Validates a hook handle and returns rc if not valid. */
71	#define RTTHREADCTX_VALID_RETURN_RC(pThis, rc) \
72	do { \
73	AssertPtrReturn((pThis), (rc)); \
74	AssertReturn((pThis)->u32Magic == RTTHREADCTXHOOKINT_MAGIC, (rc)); \
75	AssertReturn((pThis)->cRefs > 0, (rc)); \
76	} while (0)
77
78
79	/**
80	* Hook function for the thread-save event.
81	*
82	* @param pvThreadCtxInt Opaque pointer to the internal hook object.
83	*
84	* @remarks Called with the with preemption disabled!
85	*/
86	static void rtThreadCtxHookSolOut(void *pvThreadCtxInt)
87	{
88	PRTTHREADCTXHOOKINT pThis = (PRTTHREADCTXHOOKINT)pvThreadCtxInt;
89	AssertPtr(pThis);
90	Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
91	Assert(pThis->cRefs > 0);
92
93	if (pThis->fEnabled)
94	{
95	Assert(pThis->pfnCallback);
96	pThis->pfnCallback(RTTHREADCTXEVENT_OUT, pThis->pvUser);
97	}
98	}
99
100
101	/**
102	* Hook function for the thread-restore event.
103	*
104	* @param pvThreadCtxInt Opaque pointer to the internal hook object.
105	*
106	* @remarks Called with preemption disabled!
107	*/
108	static void rtThreadCtxHookSolIn(void *pvThreadCtxInt)
109	{
110	PRTTHREADCTXHOOKINT pThis = (PRTTHREADCTXHOOKINT)pvThreadCtxInt;
111	AssertPtr(pThis);
112	Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
113	Assert(pThis->cRefs > 0);
114
115	if (pThis->fEnabled)
116	{
117	Assert(pThis->pfnCallback);
118	pThis->pfnCallback(RTTHREADCTXEVENT_IN, pThis->pvUser);
119	}
120	}
121
122
123	/**
124	* Hook function for the thread-free event.
125	*
126	* This is used for making sure the hook object is safely released - see
127	* RTThreadCtxHookRelease for details.
128	*
129	* @param pvThreadCtxInt Opaque pointer to the internal hook object.
130	* @param fIsExec Whether this event is triggered due to exec().
131	*/
132	static void rtThreadCtxHookSolFree(void *pvThreadCtxInt, int fIsExec)
133	{
134	PRTTHREADCTXHOOKINT pThis = (PRTTHREADCTXHOOKINT)pvThreadCtxInt;
135	AssertPtrReturnVoid(pThis);
136	AssertMsgReturnVoid(pThis->u32Magic == RTTHREADCTXHOOKINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis));
137
138	uint32_t cRefs = ASMAtomicReadU32(&pThis->cRefs);
139	if (cRefs > 0)
140	{
141	cRefs = ASMAtomicDecU32(&pThis->cRefs);
142	if (!cRefs)
143	{
144	Assert(!pThis->fEnabled);
145	ASMAtomicWriteU32(&pThis->u32Magic, ~RTTHREADCTXHOOKINT_MAGIC);
146	RTMemFree(pThis);
147	}
148	}
149	else
150	{
151	/* Should never happen. */
152	AssertMsgFailed(("rtThreadCtxHookSolFree with cRefs=0 pThis=%p\n", pThis));
153	}
154	}
155
156
157	RTDECL(int) RTThreadCtxHookCreate(PRTTHREADCTXHOOK phCtxHook, uint32_t fFlags, PFNRTTHREADCTXHOOK pfnCallback, void *pvUser)
158	{
159	/*
160	* Validate input.
161	*/
162	PRTTHREADCTXHOOKINT pThis;
163	Assert(RTThreadPreemptIsEnabled(NIL_RTTHREAD));
164	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
165	AssertReturn(fFlags == 0, VERR_INVALID_FLAGS);
166
167	/*
168	* Allocate and initialize a new hook.
169	*/
170	pThis = (PRTTHREADCTXHOOKINT)RTMemAllocZ(sizeof(*pThis));
171	if (RT_UNLIKELY(!pThis))
172	return VERR_NO_MEMORY;
173	pThis->u32Magic = RTTHREADCTXHOOKINT_MAGIC;
174	pThis->hOwner = RTThreadNativeSelf();
175	pThis->pfnCallback = pfnCallback;
176	pThis->pvUser = pvUser;
177	pThis->fEnabled = false;
178	pThis->cRefs = 2; /* One reference for the thread, one for the caller. */
179
180	/*
181	* installctx() allocates memory and thus cannot be used in RTThreadCtxHookRegister() which can be used
182	* with preemption disabled. We allocate the context-hooks here and use 'fEnabled' to determine if we can
183	* invoke the consumer's hook or not.
184	*/
185	if (g_frtSolOldThreadCtx)
186	{
187	g_rtSolThreadCtx.Install.pfnSol_installctx_old(curthread,
188	pThis,
189	rtThreadCtxHookSolOut, /* save */
190	rtThreadCtxHookSolIn, /* restore */
191	NULL, /* fork */
192	NULL, /* lwp_create */
193	rtThreadCtxHookSolFree);
194	}
195	else
196	{
197	g_rtSolThreadCtx.Install.pfnSol_installctx(curthread,
198	pThis,
199	rtThreadCtxHookSolOut, /* save */
200	rtThreadCtxHookSolIn, /* restore */
201	NULL, /* fork */
202	NULL, /* lwp_create */
203	NULL, /* exit */
204	rtThreadCtxHookSolFree);
205	}
206
207	*phCtxHook = pThis;
208	return VINF_SUCCESS;
209	}
210
211
212	RTDECL(int) RTThreadCtxHookDestroy(RTTHREADCTXHOOK hCtxHook)
213	{
214	/*
215	* Validate input, ignoring NIL.
216	*/
217	PRTTHREADCTXHOOKINT pThis = hCtxHook;
218	if (pThis == NIL_RTTHREADCTXHOOK)
219	return VINF_SUCCESS;
220	RTTHREADCTX_VALID_RETURN_RC(hCtxHook, VERR_INVALID_HANDLE);
221	Assert(RTThreadPreemptIsEnabled(NIL_RTTHREAD));
222	Assert(!pThis->fEnabled \|\| pThis->hOwner == RTThreadNativeSelf());
223
224	/*
225	* Make sure it's disabled.
226	*/
227	ASMAtomicWriteBool(&pThis->fEnabled, false);
228
229	/*
230	* Decrement.
231	*/
232	uint32_t cRefs = ASMAtomicDecU32(&pThis->cRefs);
233	if ( cRefs == 1
234	&& pThis->hOwner == RTThreadNativeSelf())
235	{
236	/*
237	* removectx() will invoke rtThreadCtxHookSolFree() and there is no way to bypass it and still use
238	* rtThreadCtxHookSolFree() at the same time. Hence the convulated reference counting.
239	*
240	* When this function is called from the owner thread and is the last reference, we call removectx() which
241	* will invoke rtThreadCtxHookSolFree() with cRefs = 1 and that will then free the hook object.
242	*
243	* When the function is called from a different thread, we simply decrement the reference. Whenever the
244	* ring-0 thread dies, Solaris will call rtThreadCtxHookSolFree() which will free the hook object.
245	*/
246	int rc;
247	if (g_frtSolOldThreadCtx)
248	{
249	rc = g_rtSolThreadCtx.Remove.pfnSol_removectx_old(curthread,
250	pThis,
251	rtThreadCtxHookSolOut, /* save */
252	rtThreadCtxHookSolIn, /* restore */
253	NULL, /* fork */
254	NULL, /* lwp_create */
255	rtThreadCtxHookSolFree);
256	}
257	else
258	{
259	rc = g_rtSolThreadCtx.Remove.pfnSol_removectx(curthread,
260	pThis,
261	rtThreadCtxHookSolOut, /* save */
262	rtThreadCtxHookSolIn, /* restore */
263	NULL, /* fork */
264	NULL, /* lwp_create */
265	NULL, /* exit */
266	rtThreadCtxHookSolFree);
267	}
268	AssertMsg(rc, ("removectx() failed. rc=%d\n", rc));
269	NOREF(rc);
270
271	#if 0 /def RT_STRICT - access after free /
272	cRefs = ASMAtomicReadU32(&pThis->cRefs);
273	Assert(!cRefs);
274	#endif
275	cRefs = 0;
276	}
277	else if (!cRefs)
278	{
279	/*
280	* The ring-0 thread for this hook object has already died. Free up the object as we have no more references.
281	*/
282	Assert(pThis->hOwner != RTThreadNativeSelf());
283	ASMAtomicWriteU32(&pThis->u32Magic, ~RTTHREADCTXHOOKINT_MAGIC);
284	RTMemFree(pThis);
285	}
286
287	return cRefs;
288	}
289
290
291	RTDECL(int) RTThreadCtxHookEnable(RTTHREADCTXHOOK hCtxHook)
292	{
293	/*
294	* Validate input.
295	*/
296	PRTTHREADCTXHOOKINT pThis = hCtxHook;
297	AssertPtr(pThis);
298	AssertMsgReturn(pThis->u32Magic == RTTHREADCTXHOOKINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
299	VERR_INVALID_HANDLE);
300	Assert(pThis->hOwner == RTThreadNativeSelf());
301	Assert(!pThis->fEnabled);
302
303	/*
304	* Mark it as enabled.
305	*/
306	pThis->fEnabled = true;
307
308	return VINF_SUCCESS;
309	}
310
311
312	RTDECL(int) RTThreadCtxHookDisable(RTTHREADCTXHOOK hCtxHook)
313	{
314	/*
315	* Validate input.
316	*/
317	PRTTHREADCTXHOOKINT pThis = hCtxHook;
318	if (pThis != NIL_RTTHREADCTXHOOK)
319	{
320	AssertPtr(pThis);
321	AssertMsgReturn(pThis->u32Magic == RTTHREADCTXHOOKINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
322	VERR_INVALID_HANDLE);
323	Assert(pThis->hOwner == RTThreadNativeSelf());
324
325	/*
326	* Mark it as disabled.
327	*/
328	pThis->fEnabled = false;
329	}
330
331	return VINF_SUCCESS;
332	}
333
334
335	RTDECL(bool) RTThreadCtxHookIsEnabled(RTTHREADCTXHOOK hCtxHook)
336	{
337	/*
338	* Validate input.
339	*/
340	PRTTHREADCTXHOOKINT pThis = hCtxHook;
341	if (pThis == NIL_RTTHREADCTXHOOK)
342	return false;
343	AssertPtr(pThis);
344	AssertMsgReturn(pThis->u32Magic == RTTHREADCTXHOOKINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
345	false);
346
347	return pThis->fEnabled;
348	}
349

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

source: vbox/trunk/src/VBox/Runtime/r0drv/solaris/threadctxhooks-r0drv-solaris.c@ 69405

Download in other formats: