1 | /* $Id: threadctxhooks-r0drv-solaris.c 76553 2019-01-01 01:45:53Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * IPRT - Thread Context Switching Hook, Ring-0 Driver, Solaris.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2013-2019 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/errcore.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 |
|
---|