mpnotification-r0drv.c@ 78365

Last change on this file since 78365 was 76553, checked in by vboxsync, 6 years ago
scm --update-copyright-year
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 10.2 KB

Line
1	/* $Id: mpnotification-r0drv.c 76553 2019-01-01 01:45:53Z vboxsync $ */
2	/** @file
3	* IPRT - Multiprocessor, Ring-0 Driver, Event Notifications.
4	*/
5
6	/*
7	* Copyright (C) 2008-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 <iprt/mp.h>
32	#include "internal/iprt.h"
33
34	#include <iprt/asm.h>
35	#if defined(RT_ARCH_AMD64) \|\| defined(RT_ARCH_X86)
36	# include <iprt/asm-amd64-x86.h>
37	#endif
38	#include <iprt/assert.h>
39	#include <iprt/err.h>
40	#include <iprt/mem.h>
41	#include <iprt/spinlock.h>
42	#include <iprt/string.h>
43	#include <iprt/thread.h>
44	#include "r0drv/mp-r0drv.h"
45
46
47	/*********************************************************************************************************************************
48	* Structures and Typedefs *
49	*********************************************************************************************************************************/
50	/**
51	* Notification registration record tracking
52	* RTMpRegisterNotification() calls.
53	*/
54	typedef struct RTMPNOTIFYREG
55	{
56	/** Pointer to the next record. */
57	struct RTMPNOTIFYREG * volatile pNext;
58	/** The callback. */
59	PFNRTMPNOTIFICATION pfnCallback;
60	/** The user argument. */
61	void *pvUser;
62	/** Bit mask indicating whether we've done this callback or not. */
63	uint8_t bmDone[sizeof(void *)];
64	} RTMPNOTIFYREG;
65	/** Pointer to a registration record. */
66	typedef RTMPNOTIFYREG *PRTMPNOTIFYREG;
67
68
69	/*********************************************************************************************************************************
70	* Global Variables *
71	*********************************************************************************************************************************/
72	/** The spinlock protecting the list. */
73	static RTSPINLOCK volatile g_hRTMpNotifySpinLock = NIL_RTSPINLOCK;
74	/** List of callbacks, in registration order. */
75	static PRTMPNOTIFYREG volatile g_pRTMpCallbackHead = NULL;
76	/** The current done bit. */
77	static uint32_t volatile g_iRTMpDoneBit;
78	/** The list generation.
79	* This is increased whenever the list has been modified. The callback routine
80	* make use of this to avoid having restart at the list head after each callback. */
81	static uint32_t volatile g_iRTMpGeneration;
82
83
84
85
86	/**
87	* This is called by the native code.
88	*
89	* @param idCpu The CPU id the event applies to.
90	* @param enmEvent The event.
91	*/
92	DECLHIDDEN(void) rtMpNotificationDoCallbacks(RTMPEVENT enmEvent, RTCPUID idCpu)
93	{
94	PRTMPNOTIFYREG pCur;
95	RTSPINLOCK hSpinlock;
96
97	/*
98	* This is a little bit tricky as we cannot be holding the spinlock
99	* while calling the callback. This means that the list might change
100	* while we're walking it, and that multiple events might be running
101	* concurrently (depending on the OS).
102	*
103	* So, the first measure is to employ a 32-bitmask for each
104	* record where we'll use a bit that rotates for each call to
105	* this function to indicate which records that has been
106	* processed. This will take care of both changes to the list
107	* and a reasonable amount of concurrent events.
108	*
109	* In order to avoid having to restart the list walks for every
110	* callback we make, we'll make use a list generation number that is
111	* incremented everytime the list is changed. So, if it remains
112	* unchanged over a callback we can safely continue the iteration.
113	*/
114	uint32_t iDone = ASMAtomicIncU32(&g_iRTMpDoneBit);
115	iDone %= RT_SIZEOFMEMB(RTMPNOTIFYREG, bmDone) * 8;
116
117	hSpinlock = g_hRTMpNotifySpinLock;
118	if (hSpinlock == NIL_RTSPINLOCK)
119	return;
120	RTSpinlockAcquire(hSpinlock);
121
122	/* Clear the bit. */
123	for (pCur = g_pRTMpCallbackHead; pCur; pCur = pCur->pNext)
124	ASMAtomicBitClear(&pCur->bmDone[0], iDone);
125
126	/* Iterate the records and perform the callbacks. */
127	do
128	{
129	uint32_t const iGeneration = ASMAtomicUoReadU32(&g_iRTMpGeneration);
130
131	pCur = g_pRTMpCallbackHead;
132	while (pCur)
133	{
134	if (!ASMAtomicBitTestAndSet(&pCur->bmDone[0], iDone))
135	{
136	PFNRTMPNOTIFICATION pfnCallback = pCur->pfnCallback;
137	void *pvUser = pCur->pvUser;
138	pCur = pCur->pNext;
139	RTSpinlockRelease(g_hRTMpNotifySpinLock);
140
141	pfnCallback(enmEvent, idCpu, pvUser);
142
143	/* carefully require the lock here, see RTR0MpNotificationTerm(). */
144	hSpinlock = g_hRTMpNotifySpinLock;
145	if (hSpinlock == NIL_RTSPINLOCK)
146	return;
147	RTSpinlockAcquire(hSpinlock);
148	if (ASMAtomicUoReadU32(&g_iRTMpGeneration) != iGeneration)
149	break;
150	}
151	else
152	pCur = pCur->pNext;
153	}
154	} while (pCur);
155
156	RTSpinlockRelease(hSpinlock);
157	}
158
159
160
161	RTDECL(int) RTMpNotificationRegister(PFNRTMPNOTIFICATION pfnCallback, void *pvUser)
162	{
163	PRTMPNOTIFYREG pCur;
164	PRTMPNOTIFYREG pNew;
165
166	/*
167	* Validation.
168	*/
169	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
170	AssertReturn(g_hRTMpNotifySpinLock != NIL_RTSPINLOCK, VERR_WRONG_ORDER);
171	RT_ASSERT_PREEMPTIBLE();
172
173	RTSpinlockAcquire(g_hRTMpNotifySpinLock);
174	for (pCur = g_pRTMpCallbackHead; pCur; pCur = pCur->pNext)
175	if ( pCur->pvUser == pvUser
176	&& pCur->pfnCallback == pfnCallback)
177	break;
178	RTSpinlockRelease(g_hRTMpNotifySpinLock);
179	AssertMsgReturn(!pCur, ("pCur=%p pfnCallback=%p pvUser=%p\n", pCur, pfnCallback, pvUser), VERR_ALREADY_EXISTS);
180
181	/*
182	* Allocate a new record and attempt to insert it.
183	*/
184	pNew = (PRTMPNOTIFYREG)RTMemAlloc(sizeof(*pNew));
185	if (!pNew)
186	return VERR_NO_MEMORY;
187
188	pNew->pNext = NULL;
189	pNew->pfnCallback = pfnCallback;
190	pNew->pvUser = pvUser;
191	memset(&pNew->bmDone[0], 0xff, sizeof(pNew->bmDone));
192
193	RTSpinlockAcquire(g_hRTMpNotifySpinLock);
194
195	pCur = g_pRTMpCallbackHead;
196	if (!pCur)
197	g_pRTMpCallbackHead = pNew;
198	else
199	{
200	for (pCur = g_pRTMpCallbackHead; ; pCur = pCur->pNext)
201	if ( pCur->pvUser == pvUser
202	&& pCur->pfnCallback == pfnCallback)
203	break;
204	else if (!pCur->pNext)
205	{
206	pCur->pNext = pNew;
207	pCur = NULL;
208	break;
209	}
210	}
211
212	ASMAtomicIncU32(&g_iRTMpGeneration);
213
214	RTSpinlockRelease(g_hRTMpNotifySpinLock);
215
216	/* duplicate? */
217	if (pCur)
218	{
219	RTMemFree(pCur);
220	AssertMsgFailedReturn(("pCur=%p pfnCallback=%p pvUser=%p\n", pCur, pfnCallback, pvUser), VERR_ALREADY_EXISTS);
221	}
222
223	return VINF_SUCCESS;
224	}
225	RT_EXPORT_SYMBOL(RTMpNotificationRegister);
226
227
228	RTDECL(int) RTMpNotificationDeregister(PFNRTMPNOTIFICATION pfnCallback, void *pvUser)
229	{
230	PRTMPNOTIFYREG pPrev;
231	PRTMPNOTIFYREG pCur;
232
233	/*
234	* Validation.
235	*/
236	AssertPtrReturn(pfnCallback, VERR_INVALID_POINTER);
237	AssertReturn(g_hRTMpNotifySpinLock != NIL_RTSPINLOCK, VERR_WRONG_ORDER);
238	RT_ASSERT_INTS_ON();
239
240	/*
241	* Find and unlink the record from the list.
242	*/
243	RTSpinlockAcquire(g_hRTMpNotifySpinLock);
244	pPrev = NULL;
245	for (pCur = g_pRTMpCallbackHead; pCur; pCur = pCur->pNext)
246	{
247	if ( pCur->pvUser == pvUser
248	&& pCur->pfnCallback == pfnCallback)
249	break;
250	pPrev = pCur;
251	}
252	if (pCur)
253	{
254	if (pPrev)
255	pPrev->pNext = pCur->pNext;
256	else
257	g_pRTMpCallbackHead = pCur->pNext;
258	ASMAtomicIncU32(&g_iRTMpGeneration);
259	}
260	RTSpinlockRelease(g_hRTMpNotifySpinLock);
261
262	if (!pCur)
263	return VERR_NOT_FOUND;
264
265	/*
266	* Invalidate and free the record.
267	*/
268	pCur->pNext = NULL;
269	pCur->pfnCallback = NULL;
270	RTMemFree(pCur);
271
272	return VINF_SUCCESS;
273	}
274	RT_EXPORT_SYMBOL(RTMpNotificationDeregister);
275
276
277	DECLHIDDEN(int) rtR0MpNotificationInit(void)
278	{
279	int rc = RTSpinlockCreate((PRTSPINLOCK)&g_hRTMpNotifySpinLock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "RTR0Mp");
280	if (RT_SUCCESS(rc))
281	{
282	rc = rtR0MpNotificationNativeInit();
283	if (RT_SUCCESS(rc))
284	return rc;
285
286	RTSpinlockDestroy(g_hRTMpNotifySpinLock);
287	g_hRTMpNotifySpinLock = NIL_RTSPINLOCK;
288	}
289	return rc;
290	}
291
292
293	DECLHIDDEN(void) rtR0MpNotificationTerm(void)
294	{
295	PRTMPNOTIFYREG pHead;
296	RTSPINLOCK hSpinlock = g_hRTMpNotifySpinLock;
297	AssertReturnVoid(hSpinlock != NIL_RTSPINLOCK);
298
299	rtR0MpNotificationNativeTerm();
300
301	/* pick up the list and the spinlock. */
302	RTSpinlockAcquire(hSpinlock);
303	ASMAtomicWriteHandle(&g_hRTMpNotifySpinLock, NIL_RTSPINLOCK);
304	pHead = g_pRTMpCallbackHead;
305	g_pRTMpCallbackHead = NULL;
306	ASMAtomicIncU32(&g_iRTMpGeneration);
307	RTSpinlockRelease(hSpinlock);
308
309	/* free the list. */
310	while (pHead)
311	{
312	PRTMPNOTIFYREG pFree = pHead;
313	pHead = pHead->pNext;
314
315	pFree->pNext = NULL;
316	pFree->pfnCallback = NULL;
317	RTMemFree(pFree);
318	}
319
320	RTSpinlockDestroy(hSpinlock);
321	}
322

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

source: vbox/trunk/src/VBox/Runtime/r0drv/mpnotification-r0drv.c@ 78365

Download in other formats: