timer-r0drv-nt.cpp@ 9700

Last change on this file since 9700 was 9586, checked in by vboxsync, 17 years ago
Fixed missing time unit conversion in RTTimerREquestSystemGranularity.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 15.3 KB

Line
1	/* $Id: timer-r0drv-nt.cpp 9586 2008-06-11 00:36:56Z vboxsync $ */
2	/** @file
3	* IPRT - Timers, Ring-0 Driver, NT.
4	*/
5
6	/*
7	* Copyright (C) 2006-2008 Sun Microsystems, Inc.
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	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	*/
30
31	/*******************************************************************************
32	* Header Files *
33	*******************************************************************************/
34	#include "the-nt-kernel.h"
35
36	#include <iprt/timer.h>
37	#include <iprt/mp.h>
38	#include <iprt/cpuset.h>
39	#include <iprt/err.h>
40	#include <iprt/asm.h>
41	#include <iprt/assert.h>
42	#include <iprt/alloc.h>
43
44	#include "internal-r0drv-nt.h"
45	#include "internal/magics.h"
46
47
48	/*******************************************************************************
49	* Structures and Typedefs *
50	*******************************************************************************/
51	/**
52	* A sub timer structure.
53	*
54	* This is used for keeping the per-cpu tick and DPC object.
55	*/
56	typedef struct RTTIMERNTSUBTIMER
57	{
58	/** The tick counter. */
59	uint64_t iTick;
60	/** Pointer to the parent timer. */
61	PRTTIMER pParent;
62	/** The NT DPC object. */
63	KDPC NtDpc;
64	} RTTIMERNTSUBTIMER;
65	/** Pointer to a NT sub-timer structure. */
66	typedef RTTIMERNTSUBTIMER *PRTTIMERNTSUBTIMER;
67
68	/**
69	* The internal representation of an Linux timer handle.
70	*/
71	typedef struct RTTIMER
72	{
73	/** Magic.
74	* This is RTTIMER_MAGIC, but changes to something else before the timer
75	* is destroyed to indicate clearly that thread should exit. */
76	uint32_t volatile u32Magic;
77	/** Flag indicating the the timer is suspended. */
78	bool volatile fSuspended;
79	/** Whether the timer must run on one specific CPU or not. */
80	bool fSpecificCpu;
81	/** Whether the timer must run on all CPUs or not. */
82	bool fOmniTimer;
83	/** The CPU it must run on if fSpecificCpu is set.
84	* The master CPU for an omni-timer. */
85	RTCPUID idCpu;
86	/** Callback. */
87	PFNRTTIMER pfnTimer;
88	/** User argument. */
89	void *pvUser;
90	/** The timer interval. 0 if one-shot. */
91	uint64_t u64NanoInterval;
92	/** The Nt timer object. */
93	KTIMER NtTimer;
94	/** The number of sub-timers. */
95	RTCPUID cSubTimers;
96	/** Sub-timers.
97	* Normally there is just one, but for RTTIMER_FLAGS_CPU_ALL this will contain
98	* an entry for all possible cpus. In that case the index will be the same as
99	* for the RTCpuSet. */
100	RTTIMERNTSUBTIMER aSubTimers[1];
101	} RTTIMER;
102
103
104
105	/**
106	* Timer callback function for the non-omni timers.
107	*
108	* @returns HRTIMER_NORESTART or HRTIMER_RESTART depending on whether it's a one-shot or interval timer.
109	* @param pHrTimer Pointer to the timer structure.
110	*/
111	static void _stdcall rtTimerNtSimpleCallback(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
112	{
113	PRTTIMER pTimer = (PRTTIMER)pvUser;
114	AssertPtr(pTimer);
115	#ifdef RT_STRICT
116	if (KeGetCurrentIrql() < DISPATCH_LEVEL)
117	AssertMsg2("rtTimerNtSimpleCallback: Irql=%d expected >=%d\n", KeGetCurrentIrql(), DISPATCH_LEVEL);
118	#endif
119
120	/*
121	* Check that we haven't been suspended before doing the callout.
122	*/
123	if ( !ASMAtomicUoReadBool(&pTimer->fSuspended)
124	&& pTimer->u32Magic == RTTIMER_MAGIC)
125	pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pTimer->aSubTimers[0].iTick);
126
127	NOREF(pDpc); NOREF(SystemArgument1); NOREF(SystemArgument2);
128	}
129
130
131	/**
132	* The slave DPC callback for an omni timer.
133	*
134	* @param pDpc The DPC object.
135	* @param pvUser Pointer to the sub-timer.
136	* @param SystemArgument1 Some system stuff.
137	* @param SystemArgument2 Some system stuff.
138	*/
139	static void _stdcall rtTimerNtOmniSlaveCallback(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
140	{
141	PRTTIMERNTSUBTIMER pSubTimer = (PRTTIMERNTSUBTIMER)pvUser;
142	PRTTIMER pTimer = pSubTimer->pParent;
143
144	AssertPtr(pTimer);
145	#ifdef RT_STRICT
146	if (KeGetCurrentIrql() < DISPATCH_LEVEL)
147	AssertMsg2("rtTimerNtOmniSlaveCallback: Irql=%d expected >=%d\n", KeGetCurrentIrql(), DISPATCH_LEVEL);
148	int iCpuSelf = RTMpCpuIdToSetIndex(RTMpCpuId());
149	if (pSubTimer - &pTimer->aSubTimers[0] != iCpuSelf)
150	AssertMsg2("rtTimerNtOmniSlaveCallback: iCpuSelf=%d pSubTimer=%p / %d\n", iCpuSelf, pSubTimer, pSubTimer - &pTimer->aSubTimers[0]);
151	#endif
152
153	/*
154	* Check that we haven't been suspended before doing the callout.
155	*/
156	if ( !ASMAtomicUoReadBool(&pTimer->fSuspended)
157	&& pTimer->u32Magic == RTTIMER_MAGIC)
158	pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
159
160	NOREF(pDpc); NOREF(SystemArgument1); NOREF(SystemArgument2);
161	}
162
163
164	/**
165	* The timer callback for an omni-timer.
166	*
167	* This is responsible for queueing the DPCs for the other CPUs and
168	* perform the callback on the CPU on which it is called.
169	*
170	* @param pDpc The DPC object.
171	* @param pvUser Pointer to the sub-timer.
172	* @param SystemArgument1 Some system stuff.
173	* @param SystemArgument2 Some system stuff.
174	*/
175	static void _stdcall rtTimerNtOmniMasterCallback(IN PKDPC pDpc, IN PVOID pvUser, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
176	{
177	PRTTIMERNTSUBTIMER pSubTimer = (PRTTIMERNTSUBTIMER)pvUser;
178	PRTTIMER pTimer = pSubTimer->pParent;
179	int iCpuSelf = RTMpCpuIdToSetIndex(RTMpCpuId());
180
181	AssertPtr(pTimer);
182	#ifdef RT_STRICT
183	if (KeGetCurrentIrql() < DISPATCH_LEVEL)
184	AssertMsg2("rtTimerNtOmniMasterCallback: Irql=%d expected >=%d\n", KeGetCurrentIrql(), DISPATCH_LEVEL);
185	if (pSubTimer - &pTimer->aSubTimers[0] != iCpuSelf)
186	AssertMsg2("rtTimerNtOmniMasterCallback: iCpuSelf=%d pSubTimer=%p / %d\n", iCpuSelf, pSubTimer, pSubTimer - &pTimer->aSubTimers[0]);
187	#endif
188
189	/*
190	* Check that we haven't been suspended before scheduling the other DPCs
191	* and doing the callout.
192	*/
193	if ( !ASMAtomicUoReadBool(&pTimer->fSuspended)
194	&& pTimer->u32Magic == RTTIMER_MAGIC)
195	{
196	RTCPUSET OnlineSet;
197	RTMpGetOnlineSet(&OnlineSet);
198	for (int iCpu = 0; iCpu < RTCPUSET_MAX_CPUS; iCpu++)
199	if ( RTCpuSetIsMemberByIndex(&OnlineSet, iCpu)
200	&& iCpuSelf != iCpu)
201	KeInsertQueueDpc(&pTimer->aSubTimers[iCpu].NtDpc, 0, 0);
202
203	pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
204	}
205
206	NOREF(pDpc); NOREF(SystemArgument1); NOREF(SystemArgument2);
207	}
208
209
210
211	RTDECL(int) RTTimerStart(PRTTIMER pTimer, uint64_t u64First)
212	{
213	/*
214	* Validate.
215	*/
216	AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
217	AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
218
219	if (!ASMAtomicUoReadBool(&pTimer->fSuspended))
220	return VERR_TIMER_ACTIVE;
221
222	/*
223	* Start the timer.
224	*/
225	PKDPC pMasterDpc = pTimer->fOmniTimer
226	? &pTimer->aSubTimers[RTMpCpuIdToSetIndex(pTimer->idCpu)].NtDpc
227	: &pTimer->aSubTimers[0].NtDpc;
228
229	uint64_t u64Interval = pTimer->u64NanoInterval / 100000; /* This is ms, believe it or not. */
230	ULONG ulInterval = (ULONG)u64Interval;
231	if (ulInterval != u64Interval)
232	ulInterval = MAXLONG;
233	else if (!ulInterval && pTimer->u64NanoInterval)
234	ulInterval = 1;
235
236	LARGE_INTEGER DueTime;
237	DueTime.QuadPart = -(int64_t)(u64First / 100); /* Relative, NT time. */
238	if (DueTime.QuadPart)
239	DueTime.QuadPart = -1;
240
241	ASMAtomicWriteBool(&pTimer->fSuspended, false);
242	KeSetTimerEx(&pTimer->NtTimer, DueTime, ulInterval, pMasterDpc);
243	return VINF_SUCCESS;
244	}
245
246
247	/**
248	* Worker function that stops an active timer.
249	*
250	* Shared by RTTimerStop and RTTimerDestroy.
251	*
252	* @param pTimer The active timer.
253	*/
254	static void rtTimerNtStopWorker(PRTTIMER pTimer)
255	{
256	/*
257	* Just cancel the timer, dequeue the DPCs and flush them (if this is supported).
258	*/
259	ASMAtomicWriteBool(&pTimer->fSuspended, true);
260	KeCancelTimer(&pTimer->NtTimer);
261
262	for (RTCPUID iCpu = 0; iCpu < pTimer->cSubTimers; iCpu++)
263	KeRemoveQueueDpc(&pTimer->aSubTimers[iCpu].NtDpc);
264
265	/*
266	* I'm a bit uncertain whether this should be done during RTTimerStop
267	* or only in RTTimerDestroy()... Linux and Solaris will wait AFAIK,
268	* which is why I'm keeping this here for now.
269	*/
270	if (g_pfnrtNtKeFlushQueuedDpcs)
271	g_pfnrtNtKeFlushQueuedDpcs();
272	}
273
274
275	RTDECL(int) RTTimerStop(PRTTIMER pTimer)
276	{
277	/*
278	* Validate.
279	*/
280	AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
281	AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
282
283	if (ASMAtomicUoReadBool(&pTimer->fSuspended))
284	return VERR_TIMER_SUSPENDED;
285
286	/*
287	* Call the worker we share with RTTimerDestroy.
288	*/
289	rtTimerNtStopWorker(pTimer);
290	return VINF_SUCCESS;
291	}
292
293
294	RTDECL(int) RTTimerDestroy(PRTTIMER pTimer)
295	{
296	/* It's ok to pass NULL pointer. */
297	if (pTimer == /NIL_RTTIMER/ NULL)
298	return VINF_SUCCESS;
299	AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
300	AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
301
302	/*
303	* Invalidate the timer, stop it if it's running and finally .
304	* free up the memory.
305	*/
306	ASMAtomicWriteU32(&pTimer->u32Magic, ~RTTIMER_MAGIC);
307	if (!ASMAtomicUoReadBool(&pTimer->fSuspended))
308	rtTimerNtStopWorker(pTimer);
309	RTMemFree(pTimer);
310
311	return VINF_SUCCESS;
312	}
313
314
315	RTDECL(int) RTTimerCreateEx(PRTTIMER ppTimer, uint64_t u64NanoInterval, unsigned fFlags, PFNRTTIMER pfnTimer, void pvUser)
316	{
317	*ppTimer = NULL;
318
319	/*
320	* Validate flags.
321	*/
322	if (!RTTIMER_FLAGS_ARE_VALID(fFlags))
323	return VERR_INVALID_PARAMETER;
324	if ( (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
325	&& (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
326	&& !RTMpIsCpuOnline(fFlags & RTTIMER_FLAGS_CPU_MASK))
327	return (fFlags & RTTIMER_FLAGS_CPU_MASK) > RTMpGetMaxCpuId()
328	? VERR_CPU_NOT_FOUND
329	: VERR_CPU_OFFLINE;
330
331	/*
332	* Allocate the timer handler.
333	*/
334	RTCPUID cSubTimers = 1;
335	if ((fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL)
336	{
337	cSubTimers = RTMpGetMaxCpuId() + 1;
338	Assert(cSubTimers <= RTCPUSET_MAX_CPUS); /* On Windows we have a 1:1 relationship between cpuid and set index. */
339	}
340
341	PRTTIMER pTimer = (PRTTIMER)RTMemAllocZ(RT_OFFSETOF(RTTIMER, aSubTimers[cSubTimers]));
342	if (!pTimer)
343	return VERR_NO_MEMORY;
344
345	/*
346	* Initialize it.
347	*/
348	pTimer->u32Magic = RTTIMER_MAGIC;
349	pTimer->fSuspended = true;
350	pTimer->fSpecificCpu = (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC) && (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL;
351	pTimer->fOmniTimer = (fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL;
352	pTimer->idCpu = fFlags & RTTIMER_FLAGS_CPU_MASK;
353	pTimer->cSubTimers = cSubTimers;
354	pTimer->pfnTimer = pfnTimer;
355	pTimer->pvUser = pvUser;
356	pTimer->u64NanoInterval = u64NanoInterval;
357	KeInitializeTimerEx(&pTimer->NtTimer, SynchronizationTimer);
358	if (pTimer->fOmniTimer)
359	{
360	/*
361	* Initialize the per-cpu "sub-timers", select the first online cpu
362	* to be the master.
363	* ASSUMES that no cpus will ever go offline.
364	*/
365	pTimer->idCpu = NIL_RTCPUID; /* */
366	for (unsigned iCpu = 0; iCpu < cSubTimers; iCpu++)
367	{
368	pTimer->aSubTimers[iCpu].iTick = 0;
369	pTimer->aSubTimers[iCpu].pParent = pTimer;
370
371	if ( pTimer->idCpu == NIL_RTCPUID
372	&& RTMpIsCpuOnline(RTMpCpuIdFromSetIndex(iCpu)))
373	{
374	pTimer->idCpu = RTMpCpuIdFromSetIndex(iCpu);
375	KeInitializeDpc(&pTimer->aSubTimers[iCpu].NtDpc, rtTimerNtOmniMasterCallback, &pTimer->aSubTimers[iCpu]);
376	}
377	else
378	KeInitializeDpc(&pTimer->aSubTimers[iCpu].NtDpc, rtTimerNtOmniSlaveCallback, &pTimer->aSubTimers[iCpu]);
379	KeSetImportanceDpc(&pTimer->aSubTimers[iCpu].NtDpc, HighImportance);
380	KeSetTargetProcessorDpc(&pTimer->aSubTimers[iCpu].NtDpc, (int)RTMpCpuIdFromSetIndex(iCpu));
381	}
382	Assert(pTimer->idCpu != NIL_RTCPUID);
383	}
384	else
385	{
386	/*
387	* Initialize the first "sub-timer", target the DPC on a specific processor
388	* if requested to do so.
389	*/
390	pTimer->aSubTimers[0].iTick = 0;
391	pTimer->aSubTimers[0].pParent = pTimer;
392
393	KeInitializeDpc(&pTimer->aSubTimers[0].NtDpc, rtTimerNtSimpleCallback, pTimer);
394	KeSetImportanceDpc(&pTimer->aSubTimers[0].NtDpc, HighImportance);
395	if (pTimer->fSpecificCpu)
396	KeSetTargetProcessorDpc(&pTimer->aSubTimers[0].NtDpc, (int)pTimer->idCpu);
397	}
398
399	*ppTimer = pTimer;
400	return VINF_SUCCESS;
401	}
402
403
404	RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
405	{
406	/*
407	* Get the default/max timer increment value, return it if ExtSetTimerResolution
408	* isn't available. Accoring to the sysinternals guys NtQueryTimerResolution
409	* is only available in userland and they find it equally annoying.
410	*/
411	ULONG ulTimeInc = KeQueryTimeIncrement();
412	if (!g_pfnrtNtExSetTimerResolution)
413	return ulTimeInc * 100; /* The value is in 100ns, the funny NT unit. */
414
415	/*
416	* Use the value returned by ExSetTimerResolution. Since the kernel is keeping
417	* count of these calls, we have to do two calls that cancel each other out.
418	*/
419	ULONG ulResolution1 = g_pfnrtNtExSetTimerResolution(ulTimeInc, TRUE);
420	ULONG ulResolution2 = g_pfnrtNtExSetTimerResolution(0 /ignored/, FALSE);
421	AssertMsg(ulResolution1 == ulResolution2, ("%ld, %ld\n", ulResolution1, ulResolution2)); /* not supposed to change it! */
422	return ulResolution2 * 100; /* NT -> ns */
423	}
424
425
426	RTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
427	{
428	if (!g_pfnrtNtExSetTimerResolution)
429	return VERR_NOT_SUPPORTED;
430
431	ULONG ulGranted = g_pfnrtNtExSetTimerResolution(u32Request / 100, TRUE);
432	if (pu32Granted)
433	pu32Granted = ulGranted 100; /* NT -> ns */
434	return VINF_SUCCESS;
435	}
436
437
438	RTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
439	{
440	if (!g_pfnrtNtExSetTimerResolution)
441	return VERR_NOT_SUPPORTED;
442
443	g_pfnrtNtExSetTimerResolution(0 /* ignored */, FALSE);
444	NOREF(u32Granted);
445	return VINF_SUCCESS;
446	}
447
448

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

source: vbox/trunk/src/VBox/Runtime/r0drv/nt/timer-r0drv-nt.cpp@ 9700

Download in other formats: