mp-r0drv-nt.cpp@ 37379

Last change on this file since 37379 was 37379, checked in by vboxsync, 13 years ago
blank lines
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 11.6 KB

Line
1	/* $Id: mp-r0drv-nt.cpp 37379 2011-06-08 14:21:34Z vboxsync $ */
2	/** @file
3	* IPRT - Multiprocessor, Ring-0 Driver, NT.
4	*/
5
6	/*
7	* Copyright (C) 2008 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-nt-kernel.h"
32
33	#include <iprt/mp.h>
34	#include <iprt/cpuset.h>
35	#include <iprt/err.h>
36	#include <iprt/asm.h>
37	#include "r0drv/mp-r0drv.h"
38	#include "internal-r0drv-nt.h"
39
40
41	/*******************************************************************************
42	* Structures and Typedefs *
43	*******************************************************************************/
44	typedef enum
45	{
46	RT_NT_CPUID_SPECIFIC,
47	RT_NT_CPUID_OTHERS,
48	RT_NT_CPUID_ALL
49	} RT_NT_CPUID;
50
51
52	/* test a couple of assumption. */
53	AssertCompile(MAXIMUM_PROCESSORS <= RTCPUSET_MAX_CPUS);
54	AssertCompile(NIL_RTCPUID >= MAXIMUM_PROCESSORS);
55
56	/** @todo
57	* We cannot do other than assume a 1:1 relationship between the
58	* affinity mask and the process despite the vagueness/warnings in
59	* the docs. If someone knows a better way to get this done, please
60	* let bird know.
61	*/
62
63
64	RTDECL(RTCPUID) RTMpCpuId(void)
65	{
66	/* WDK upgrade warning: PCR->Number changed from BYTE to WORD. */
67	return KeGetCurrentProcessorNumber();
68	}
69
70
71	RTDECL(int) RTMpCpuIdToSetIndex(RTCPUID idCpu)
72	{
73	return idCpu < MAXIMUM_PROCESSORS ? (int)idCpu : -1;
74	}
75
76
77	RTDECL(RTCPUID) RTMpCpuIdFromSetIndex(int iCpu)
78	{
79	return (unsigned)iCpu < MAXIMUM_PROCESSORS ? iCpu : NIL_RTCPUID;
80	}
81
82
83	RTDECL(RTCPUID) RTMpGetMaxCpuId(void)
84	{
85	/** @todo use KeQueryMaximumProcessorCount on vista+ */
86	return MAXIMUM_PROCESSORS - 1;
87	}
88
89
90	RTDECL(bool) RTMpIsCpuOnline(RTCPUID idCpu)
91	{
92	if (idCpu >= MAXIMUM_PROCESSORS)
93	return false;
94
95	#if 0 /* this isn't safe at all IRQLs (great work guys) */
96	KAFFINITY Mask = KeQueryActiveProcessors();
97	return !!(Mask & RT_BIT_64(idCpu));
98	#else
99	return RTCpuSetIsMember(&g_rtMpNtCpuSet, idCpu);
100	#endif
101	}
102
103
104	RTDECL(bool) RTMpIsCpuPossible(RTCPUID idCpu)
105	{
106	/* Cannot easily distinguish between online and offline cpus. */
107	/** @todo online/present cpu stuff must be corrected for proper W2K8 support
108	* (KeQueryMaximumProcessorCount). */
109	return RTMpIsCpuOnline(idCpu);
110	}
111
112
113
114	RTDECL(PRTCPUSET) RTMpGetSet(PRTCPUSET pSet)
115	{
116	/** @todo online/present cpu stuff must be corrected for proper W2K8 support
117	* (KeQueryMaximumProcessorCount). */
118	return RTMpGetOnlineSet(pSet);
119	}
120
121
122	RTDECL(RTCPUID) RTMpGetCount(void)
123	{
124	/** @todo online/present cpu stuff must be corrected for proper W2K8 support
125	* (KeQueryMaximumProcessorCount). */
126	return RTMpGetOnlineCount();
127	}
128
129
130	RTDECL(PRTCPUSET) RTMpGetOnlineSet(PRTCPUSET pSet)
131	{
132	#if 0 /* this isn't safe at all IRQLs (great work guys) */
133	KAFFINITY Mask = KeQueryActiveProcessors();
134	return RTCpuSetFromU64(pSet, Mask);
135	#else
136	*pSet = g_rtMpNtCpuSet;
137	return pSet;
138	#endif
139	}
140
141
142	RTDECL(RTCPUID) RTMpGetOnlineCount(void)
143	{
144	RTCPUSET Set;
145	RTMpGetOnlineSet(&Set);
146	return RTCpuSetCount(&Set);
147	}
148
149
150	#if 0
151	/* Experiment with checking the undocumented KPRCB structure
152	* 'dt nt!_kprcb 0xaddress' shows the layout
153	*/
154	typedef struct
155	{
156	LIST_ENTRY DpcListHead;
157	ULONG_PTR DpcLock;
158	volatile ULONG DpcQueueDepth;
159	ULONG DpcQueueCount;
160	} KDPC_DATA, *PKDPC_DATA;
161
162	RTDECL(bool) RTMpIsCpuWorkPending(void)
163	{
164	uint8_t *pkprcb;
165	PKDPC_DATA pDpcData;
166
167	_asm {
168	mov eax, fs:0x20
169	mov pkprcb, eax
170	}
171	pDpcData = (PKDPC_DATA)(pkprcb + 0x19e0);
172	if (pDpcData->DpcQueueDepth)
173	return true;
174
175	pDpcData++;
176	if (pDpcData->DpcQueueDepth)
177	return true;
178	return false;
179	}
180	#else
181	RTDECL(bool) RTMpIsCpuWorkPending(void)
182	{
183	/** @todo not implemented */
184	return false;
185	}
186	#endif
187
188
189	/**
190	* Wrapper between the native nt per-cpu callbacks and PFNRTWORKER
191	*
192	* @param Dpc DPC object
193	* @param DeferredContext Context argument specified by KeInitializeDpc
194	* @param SystemArgument1 Argument specified by KeInsertQueueDpc
195	* @param SystemArgument2 Argument specified by KeInsertQueueDpc
196	*/
197	static VOID rtmpNtDPCWrapper(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
198	{
199	PRTMPARGS pArgs = (PRTMPARGS)DeferredContext;
200	ASMAtomicIncU32(&pArgs->cHits);
201	pArgs->pfnWorker(KeGetCurrentProcessorNumber(), pArgs->pvUser1, pArgs->pvUser2);
202	}
203
204
205	/**
206	* Internal worker for the RTMpOn* APIs.
207	*
208	* @returns IPRT status code.
209	* @param pfnWorker The callback.
210	* @param pvUser1 User argument 1.
211	* @param pvUser2 User argument 2.
212	* @param enmCpuid What to do / is idCpu valid.
213	* @param idCpu Used if enmCpuid RT_NT_CPUID_SPECIFIC, otherwise ignored.
214	*/
215	static int rtMpCall(PFNRTMPWORKER pfnWorker, void pvUser1, void pvUser2, RT_NT_CPUID enmCpuid, RTCPUID idCpu)
216	{
217	PRTMPARGS pArgs;
218	KDPC *paExecCpuDpcs;
219
220	#if 0
221	/* KeFlushQueuedDpcs must be run at IRQL PASSIVE_LEVEL according to MSDN, but the
222	* driver verifier doesn't complain...
223	*/
224	AssertMsg(KeGetCurrentIrql() == PASSIVE_LEVEL, ("%d != %d (PASSIVE_LEVEL)\n", KeGetCurrentIrql(), PASSIVE_LEVEL));
225	#endif
226
227	#ifdef IPRT_TARGET_NT4
228	KAFFINITY Mask;
229	/* g_pfnrtNt* are not present on NT anyway. */
230	return VERR_NOT_SUPPORTED;
231	#else
232	KAFFINITY Mask = KeQueryActiveProcessors();
233	#endif
234
235	/* KeFlushQueuedDpcs is not present in Windows 2000; import it dynamically so we can just fail this call. */
236	if (!g_pfnrtNtKeFlushQueuedDpcs)
237	return VERR_NOT_SUPPORTED;
238
239	pArgs = (PRTMPARGS)ExAllocatePoolWithTag(NonPagedPool, MAXIMUM_PROCESSORS*sizeof(KDPC) + sizeof(RTMPARGS), (ULONG)'RTMp');
240	if (!pArgs)
241	return VERR_NO_MEMORY;
242
243	pArgs->pfnWorker = pfnWorker;
244	pArgs->pvUser1 = pvUser1;
245	pArgs->pvUser2 = pvUser2;
246	pArgs->idCpu = NIL_RTCPUID;
247	pArgs->cHits = 0;
248
249	paExecCpuDpcs = (KDPC *)(pArgs + 1);
250
251	if (enmCpuid == RT_NT_CPUID_SPECIFIC)
252	{
253	KeInitializeDpc(&paExecCpuDpcs[0], rtmpNtDPCWrapper, pArgs);
254	KeSetImportanceDpc(&paExecCpuDpcs[0], HighImportance);
255	KeSetTargetProcessorDpc(&paExecCpuDpcs[0], (int)idCpu);
256	}
257	else
258	{
259	for (unsigned i = 0; i < MAXIMUM_PROCESSORS; i++)
260	{
261	KeInitializeDpc(&paExecCpuDpcs[i], rtmpNtDPCWrapper, pArgs);
262	KeSetImportanceDpc(&paExecCpuDpcs[i], HighImportance);
263	KeSetTargetProcessorDpc(&paExecCpuDpcs[i], i);
264	}
265	}
266
267	/* Raise the IRQL to DISPATCH_LEVEL so we can't be rescheduled to another cpu.
268	* KeInsertQueueDpc must also be executed at IRQL >= DISPATCH_LEVEL.
269	*/
270	KIRQL oldIrql;
271	KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
272
273	/*
274	* We cannot do other than assume a 1:1 relationship between the
275	* affinity mask and the process despite the warnings in the docs.
276	* If someone knows a better way to get this done, please let bird know.
277	*/
278	if (enmCpuid == RT_NT_CPUID_SPECIFIC)
279	{
280	BOOLEAN ret = KeInsertQueueDpc(&paExecCpuDpcs[0], 0, 0);
281	Assert(ret);
282	}
283	else
284	{
285	unsigned iSelf = KeGetCurrentProcessorNumber();
286
287	for (unsigned i = 0; i < MAXIMUM_PROCESSORS; i++)
288	{
289	if ( (i != iSelf)
290	&& (Mask & RT_BIT_64(i)))
291	{
292	BOOLEAN ret = KeInsertQueueDpc(&paExecCpuDpcs[i], 0, 0);
293	Assert(ret);
294	}
295	}
296	if (enmCpuid != RT_NT_CPUID_OTHERS)
297	pfnWorker(iSelf, pvUser1, pvUser2);
298	}
299
300	KeLowerIrql(oldIrql);
301
302	/* Flush all DPCs and wait for completion. (can take long!) */
303	/** @todo Consider changing this to an active wait using some atomic inc/dec
304	* stuff (and check for the current cpu above in the specific case). */
305	g_pfnrtNtKeFlushQueuedDpcs();
306
307	ExFreePool(pArgs);
308	return VINF_SUCCESS;
309	}
310
311
312	RTDECL(int) RTMpOnAll(PFNRTMPWORKER pfnWorker, void pvUser1, void pvUser2)
313	{
314	return rtMpCall(pfnWorker, pvUser1, pvUser2, RT_NT_CPUID_ALL, 0);
315	}
316
317
318	RTDECL(int) RTMpOnOthers(PFNRTMPWORKER pfnWorker, void pvUser1, void pvUser2)
319	{
320	return rtMpCall(pfnWorker, pvUser1, pvUser2, RT_NT_CPUID_OTHERS, 0);
321	}
322
323
324	RTDECL(int) RTMpOnSpecific(RTCPUID idCpu, PFNRTMPWORKER pfnWorker, void pvUser1, void pvUser2)
325	{
326	if (!RTMpIsCpuOnline(idCpu))
327	return !RTMpIsCpuPossible(idCpu)
328	? VERR_CPU_NOT_FOUND
329	: VERR_CPU_OFFLINE;
330
331	return rtMpCall(pfnWorker, pvUser1, pvUser2, RT_NT_CPUID_SPECIFIC, idCpu);
332	}
333
334	static KDPC aPokeDpcs[MAXIMUM_PROCESSORS] = {0};
335	static bool fPokeDPCsInitialized = false;
336
337	static VOID rtMpNtPokeCpuDummy(IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
338	{
339	NOREF(Dpc);
340	NOREF(DeferredContext);
341	NOREF(SystemArgument1);
342	NOREF(SystemArgument2);
343	}
344
345	#ifndef IPRT_TARGET_NT4
346
347	ULONG_PTR rtMpIpiGenericCall(ULONG_PTR Argument)
348	{
349	NOREF(Argument);
350	return 0;
351	}
352
353
354	int rtMpSendIpiVista(RTCPUID idCpu)
355	{
356	g_pfnrtKeIpiGenericCall(rtMpIpiGenericCall, 0);
357	//// g_pfnrtNtHalRequestIpi(1 << idCpu);
358	return VINF_SUCCESS;
359	}
360
361
362	int rtMpSendIpiWin7(RTCPUID idCpu)
363	{
364	g_pfnrtKeIpiGenericCall(rtMpIpiGenericCall, 0);
365	//// g_pfnrtNtHalSendSoftwareInterrupt(idCpu, DISPATCH_LEVEL);
366	return VINF_SUCCESS;
367	}
368
369	#endif /* IPRT_TARGET_NT4 */
370
371
372	int rtMpSendIpiDummy(RTCPUID idCpu)
373	{
374	return VERR_NOT_IMPLEMENTED;
375	}
376
377
378	RTDECL(int) RTMpPokeCpu(RTCPUID idCpu)
379	{
380	if (!RTMpIsCpuOnline(idCpu))
381	return !RTMpIsCpuPossible(idCpu)
382	? VERR_CPU_NOT_FOUND
383	: VERR_CPU_OFFLINE;
384
385	int rc = g_pfnrtSendIpi(idCpu);
386	if (rc == VINF_SUCCESS)
387	return rc;
388
389	/* Fallback. */
390	if (!fPokeDPCsInitialized)
391	{
392	for (unsigned i = 0; i < RT_ELEMENTS(aPokeDpcs); i++)
393	{
394	KeInitializeDpc(&aPokeDpcs[i], rtMpNtPokeCpuDummy, NULL);
395	KeSetImportanceDpc(&aPokeDpcs[i], HighImportance);
396	KeSetTargetProcessorDpc(&aPokeDpcs[i], (int)i);
397	}
398	fPokeDPCsInitialized = true;
399	}
400
401	/* Raise the IRQL to DISPATCH_LEVEL so we can't be rescheduled to another cpu.
402	* KeInsertQueueDpc must also be executed at IRQL >= DISPATCH_LEVEL.
403	*/
404	KIRQL oldIrql;
405	KeRaiseIrql(DISPATCH_LEVEL, &oldIrql);
406
407	KeSetImportanceDpc(&aPokeDpcs[idCpu], HighImportance);
408	KeSetTargetProcessorDpc(&aPokeDpcs[idCpu], (int)idCpu);
409
410	/* Assuming here that high importance DPCs will be delivered immediately; or at least an IPI will be sent immediately.
411	* @note: not true on at least Vista & Windows 7
412	*/
413	BOOLEAN bRet = KeInsertQueueDpc(&aPokeDpcs[idCpu], 0, 0);
414
415	KeLowerIrql(oldIrql);
416	return (bRet == TRUE) ? VINF_SUCCESS : VERR_ACCESS_DENIED /* already queued */;
417	}

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

source: vbox/trunk/src/VBox/Runtime/r0drv/nt/mp-r0drv-nt.cpp@ 37379

Download in other formats: