threadctxhooks-r0drv-linux.c@ 59527

Last change on this file since 59527 was 57358, checked in by vboxsync, 9 years ago
*: scm cleanup run.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 10.8 KB

Line
1	/* $Id: threadctxhooks-r0drv-linux.c 57358 2015-08-14 15:16:38Z vboxsync $ */
2	/** @file
3	* IPRT - Thread Context Switching Hook, Ring-0 Driver, Linux.
4	*/
5
6	/*
7	* Copyright (C) 2013-2015 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-linux-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	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
40	# include <iprt/asm-amd64-x86.h>
41	#endif
42	#include "internal/thread.h"
43
44
45	/*
46	* Linux kernel 2.6.23 introduced preemption notifiers but RedHat 2.6.18 kernels
47	* got it backported.
48	*/
49	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 18) && defined(CONFIG_PREEMPT_NOTIFIERS)
50
51
52	/*********************************************************************************************************************************
53	* Structures and Typedefs *
54	*********************************************************************************************************************************/
55	/**
56	* The internal hook object for linux.
57	*/
58	typedef struct RTTHREADCTXHOOKINT
59	{
60	/** Magic value (RTTHREADCTXHOOKINT_MAGIC). */
61	uint32_t volatile u32Magic;
62	/** The thread handle (owner) for which the hook is registered. */
63	RTNATIVETHREAD hOwner;
64	/** The preemption notifier object. */
65	struct preempt_notifier LnxPreemptNotifier;
66	/** Whether the hook is enabled or not. If enabled, the LnxPreemptNotifier
67	* is linked into the owning thread's list of preemption callouts. */
68	bool fEnabled;
69	/** Pointer to the user callback. */
70	PFNRTTHREADCTXHOOK pfnCallback;
71	/** User argument passed to the callback. */
72	void *pvUser;
73	/** The linux callbacks. */
74	struct preempt_ops PreemptOps;
75	#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 1, 19) && defined(RT_ARCH_AMD64)
76	/** Starting with 3.1.19, the linux kernel doesn't restore kernel RFLAGS during
77	* task switch, so we have to do that ourselves. (x86 code is not affected.) */
78	RTCCUINTREG fSavedRFlags;
79	#endif
80	} RTTHREADCTXHOOKINT;
81	typedef RTTHREADCTXHOOKINT *PRTTHREADCTXHOOKINT;
82
83
84	/**
85	* Hook function for the thread schedule out event.
86	*
87	* @param pPreemptNotifier Pointer to the preempt_notifier struct.
88	* @param pNext Pointer to the task that is being scheduled
89	* instead of the current thread.
90	*
91	* @remarks Called with the rq (runqueue) lock held and with preemption and
92	* interrupts disabled!
93	*/
94	static void rtThreadCtxHooksLnxSchedOut(struct preempt_notifier pPreemptNotifier, struct task_struct pNext)
95	{
96	PRTTHREADCTXHOOKINT pThis = RT_FROM_MEMBER(pPreemptNotifier, RTTHREADCTXHOOKINT, LnxPreemptNotifier);
97	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
98	RTCCUINTREG fSavedEFlags = ASMGetFlags();
99	stac();
100	#endif
101
102	AssertPtr(pThis);
103	AssertPtr(pThis->pfnCallback);
104	Assert(pThis->fEnabled);
105	Assert(!RTThreadPreemptIsEnabled(NIL_RTTHREAD));
106
107	pThis->pfnCallback(RTTHREADCTXEVENT_OUT, pThis->pvUser);
108
109	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
110	ASMSetFlags(fSavedEFlags);
111	# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 1, 19) && defined(RT_ARCH_AMD64)
112	pThis->fSavedRFlags = fSavedEFlags;
113	# endif
114	#endif
115	}
116
117
118	/**
119	* Hook function for the thread schedule in event.
120	*
121	* @param pPreemptNotifier Pointer to the preempt_notifier struct.
122	* @param iCpu The CPU this thread is being scheduled on.
123	*
124	* @remarks Called without holding the rq (runqueue) lock and with preemption
125	* enabled!
126	* @todo r=bird: Preemption is of course disabled when it is called.
127	*/
128	static void rtThreadCtxHooksLnxSchedIn(struct preempt_notifier *pPreemptNotifier, int iCpu)
129	{
130	PRTTHREADCTXHOOKINT pThis = RT_FROM_MEMBER(pPreemptNotifier, RTTHREADCTXHOOKINT, LnxPreemptNotifier);
131	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
132	RTCCUINTREG fSavedEFlags = ASMGetFlags();
133	stac();
134	#endif
135
136	AssertPtr(pThis);
137	AssertPtr(pThis->pfnCallback);
138	Assert(pThis->fEnabled);
139
140	pThis->pfnCallback(RTTHREADCTXEVENT_IN, pThis->pvUser);
141
142	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
143	# if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 1, 19) && defined(RT_ARCH_AMD64)
144	fSavedEFlags &= ~RT_BIT_64(18) /X86_EFL_AC/;
145	fSavedEFlags \|= pThis->fSavedRFlags & RT_BIT_64(18) /X86_EFL_AC/;
146	# endif
147	ASMSetFlags(fSavedEFlags);
148	#endif
149	}
150
151
152	/**
153	* Worker function for RTThreadCtxHooks(Deregister\|Release)().
154	*
155	* @param pThis Pointer to the internal thread-context object.
156	*/
157	DECLINLINE(void) rtThreadCtxHookDisable(PRTTHREADCTXHOOKINT pThis)
158	{
159	Assert(pThis->PreemptOps.sched_out == rtThreadCtxHooksLnxSchedOut);
160	Assert(pThis->PreemptOps.sched_in == rtThreadCtxHooksLnxSchedIn);
161	preempt_disable();
162	preempt_notifier_unregister(&pThis->LnxPreemptNotifier);
163	pThis->fEnabled = false;
164	preempt_enable();
165	}
166
167
168	RTDECL(int) RTThreadCtxHookCreate(PRTTHREADCTXHOOK phCtxHook, uint32_t fFlags, PFNRTTHREADCTXHOOK pfnCallback, void *pvUser)
169	{
170	IPRT_LINUX_SAVE_EFL_AC();
171
172	/*
173	* Validate input.
174	*/
175	PRTTHREADCTXHOOKINT pThis;
176	Assert(RTThreadPreemptIsEnabled(NIL_RTTHREAD));
177	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
178	AssertReturn(fFlags == 0, VERR_INVALID_FLAGS);
179
180	/*
181	* Allocate and initialize a new hook. We don't register it yet, just
182	* create it.
183	*/
184	pThis = (PRTTHREADCTXHOOKINT)RTMemAllocZ(sizeof(*pThis));
185	if (RT_UNLIKELY(!pThis))
186	{
187	IPRT_LINUX_RESTORE_EFL_AC();
188	return VERR_NO_MEMORY;
189	}
190	pThis->u32Magic = RTTHREADCTXHOOKINT_MAGIC;
191	pThis->hOwner = RTThreadNativeSelf();
192	pThis->fEnabled = false;
193	pThis->pfnCallback = pfnCallback;
194	pThis->pvUser = pvUser;
195	preempt_notifier_init(&pThis->LnxPreemptNotifier, &pThis->PreemptOps);
196	pThis->PreemptOps.sched_out = rtThreadCtxHooksLnxSchedOut;
197	pThis->PreemptOps.sched_in = rtThreadCtxHooksLnxSchedIn;
198
199	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
200	preempt_notifier_inc();
201	#endif
202
203	*phCtxHook = pThis;
204	IPRT_LINUX_RESTORE_EFL_AC();
205	return VINF_SUCCESS;
206	}
207	RT_EXPORT_SYMBOL(RTThreadCtxHookCreate);
208
209
210	RTDECL(int ) RTThreadCtxHookDestroy(RTTHREADCTXHOOK hCtxHook)
211	{
212	IPRT_LINUX_SAVE_EFL_AC();
213
214	/*
215	* Validate input.
216	*/
217	PRTTHREADCTXHOOKINT pThis = hCtxHook;
218	if (pThis == NIL_RTTHREADCTXHOOK)
219	return VINF_SUCCESS;
220	AssertPtr(pThis);
221	AssertMsgReturn(pThis->u32Magic == RTTHREADCTXHOOKINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
222	VERR_INVALID_HANDLE);
223	Assert(RTThreadPreemptIsEnabled(NIL_RTTHREAD));
224	Assert(!pThis->fEnabled \|\| pThis->hOwner == RTThreadNativeSelf());
225
226	/*
227	* If there's still a registered thread-context hook, deregister it now before destroying the object.
228	*/
229	if (pThis->fEnabled)
230	{
231	Assert(pThis->hOwner == RTThreadNativeSelf());
232	rtThreadCtxHookDisable(pThis);
233	Assert(!pThis->fEnabled); /* paranoia */
234	}
235
236	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 2, 0)
237	preempt_notifier_dec();
238	#endif
239
240	ASMAtomicWriteU32(&pThis->u32Magic, ~RTTHREADCTXHOOKINT_MAGIC);
241	RTMemFree(pThis);
242
243	IPRT_LINUX_RESTORE_EFL_AC();
244	return VINF_SUCCESS;
245	}
246	RT_EXPORT_SYMBOL(RTThreadCtxHookDestroy);
247
248
249	RTDECL(int) RTThreadCtxHookEnable(RTTHREADCTXHOOK hCtxHook)
250	{
251	/*
252	* Validate input.
253	*/
254	PRTTHREADCTXHOOKINT pThis = hCtxHook;
255	AssertPtr(pThis);
256	AssertMsgReturn(pThis->u32Magic == RTTHREADCTXHOOKINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
257	VERR_INVALID_HANDLE);
258	Assert(pThis->hOwner == RTThreadNativeSelf());
259	Assert(!pThis->fEnabled);
260	if (!pThis->fEnabled)
261	{
262	IPRT_LINUX_SAVE_EFL_AC();
263	Assert(pThis->PreemptOps.sched_out == rtThreadCtxHooksLnxSchedOut);
264	Assert(pThis->PreemptOps.sched_in == rtThreadCtxHooksLnxSchedIn);
265
266	/*
267	* Register the callback.
268	*/
269	preempt_disable();
270	pThis->fEnabled = true;
271	preempt_notifier_register(&pThis->LnxPreemptNotifier);
272	preempt_enable();
273
274	IPRT_LINUX_RESTORE_EFL_AC();
275	}
276
277	return VINF_SUCCESS;
278	}
279	RT_EXPORT_SYMBOL(RTThreadCtxHookEnable);
280
281
282	RTDECL(int) RTThreadCtxHookDisable(RTTHREADCTXHOOK hCtxHook)
283	{
284	/*
285	* Validate input.
286	*/
287	PRTTHREADCTXHOOKINT pThis = hCtxHook;
288	if (pThis != NIL_RTTHREADCTXHOOK)
289	{
290	AssertPtr(pThis);
291	AssertMsgReturn(pThis->u32Magic == RTTHREADCTXHOOKINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
292	VERR_INVALID_HANDLE);
293	Assert(pThis->hOwner == RTThreadNativeSelf());
294
295	/*
296	* Deregister the callback.
297	*/
298	if (pThis->fEnabled)
299	{
300	IPRT_LINUX_SAVE_EFL_AC();
301	rtThreadCtxHookDisable(pThis);
302	IPRT_LINUX_RESTORE_EFL_AC();
303	}
304	}
305	return VINF_SUCCESS;
306	}
307	RT_EXPORT_SYMBOL(RTThreadCtxHookDisable);
308
309
310	RTDECL(bool) RTThreadCtxHookIsEnabled(RTTHREADCTXHOOK hCtxHook)
311	{
312	/*
313	* Validate input.
314	*/
315	PRTTHREADCTXHOOKINT pThis = hCtxHook;
316	if (pThis == NIL_RTTHREADCTXHOOK)
317	return false;
318	AssertPtr(pThis);
319	AssertMsgReturn(pThis->u32Magic == RTTHREADCTXHOOKINT_MAGIC, ("pThis->u32Magic=%RX32 pThis=%p\n", pThis->u32Magic, pThis),
320	false);
321
322	return pThis->fEnabled;
323	}
324
325	#else /* Not supported / Not needed */
326	# include "../generic/threadctxhooks-r0drv-generic.cpp"
327	#endif /* Not supported / Not needed */
328

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

source: vbox/trunk/src/VBox/Runtime/r0drv/linux/threadctxhooks-r0drv-linux.c@ 59527

Download in other formats: