timer-r0drv-linux.c@ 69108

Last change on this file since 69108 was 63341, checked in by vboxsync, 8 years ago
Runtime/r0drv/linux: 4.8 mod_timer_pinned fix
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 57.0 KB

Line
1	/* $Id: timer-r0drv-linux.c 63341 2016-08-11 14:12:42Z vboxsync $ */
2	/** @file
3	* IPRT - Timers, Ring-0 Driver, Linux.
4	*/
5
6	/*
7	* Copyright (C) 2006-2016 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/timer.h>
35	#include <iprt/time.h>
36	#include <iprt/mp.h>
37	#include <iprt/cpuset.h>
38	#include <iprt/spinlock.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/magics.h"
45
46	/** @def RTTIMER_LINUX_WITH_HRTIMER
47	* Whether to use high resolution timers. */
48	#if !defined(RTTIMER_LINUX_WITH_HRTIMER) \
49	&& defined(IPRT_LINUX_HAS_HRTIMER)
50	# define RTTIMER_LINUX_WITH_HRTIMER
51	#endif
52
53	#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 31)
54	# define mod_timer_pinned mod_timer
55	# define HRTIMER_MODE_ABS_PINNED HRTIMER_MODE_ABS
56	#endif
57
58
59	/*********************************************************************************************************************************
60	* Structures and Typedefs *
61	*********************************************************************************************************************************/
62	/**
63	* Timer state machine.
64	*
65	* This is used to try handle the issues with MP events and
66	* timers that runs on all CPUs. It's relatively nasty :-/
67	*/
68	typedef enum RTTIMERLNXSTATE
69	{
70	/** Stopped. */
71	RTTIMERLNXSTATE_STOPPED = 0,
72	/** Transient state; next ACTIVE. */
73	RTTIMERLNXSTATE_STARTING,
74	/** Transient state; next ACTIVE. (not really necessary) */
75	RTTIMERLNXSTATE_MP_STARTING,
76	/** Active. */
77	RTTIMERLNXSTATE_ACTIVE,
78	/** Active and in callback; next ACTIVE, STOPPED or CALLBACK_DESTROYING. */
79	RTTIMERLNXSTATE_CALLBACK,
80	/** Stopped while in the callback; next STOPPED. */
81	RTTIMERLNXSTATE_CB_STOPPING,
82	/** Restarted while in the callback; next ACTIVE, STOPPED, DESTROYING. */
83	RTTIMERLNXSTATE_CB_RESTARTING,
84	/** The callback shall destroy the timer; next STOPPED. */
85	RTTIMERLNXSTATE_CB_DESTROYING,
86	/** Transient state; next STOPPED. */
87	RTTIMERLNXSTATE_STOPPING,
88	/** Transient state; next STOPPED. */
89	RTTIMERLNXSTATE_MP_STOPPING,
90	/** The usual 32-bit hack. */
91	RTTIMERLNXSTATE_32BIT_HACK = 0x7fffffff
92	} RTTIMERLNXSTATE;
93
94
95	/**
96	* A Linux sub-timer.
97	*/
98	typedef struct RTTIMERLNXSUBTIMER
99	{
100	/** Timer specific data. */
101	union
102	{
103	#if defined(RTTIMER_LINUX_WITH_HRTIMER)
104	/** High resolution timer. */
105	struct
106	{
107	/** The linux timer structure. */
108	struct hrtimer LnxTimer;
109	} Hr;
110	#endif
111	/** Standard timer. */
112	struct
113	{
114	/** The linux timer structure. */
115	struct timer_list LnxTimer;
116	/** The start of the current run (ns).
117	* This is used to calculate when the timer ought to fire the next time. */
118	uint64_t u64NextTS;
119	/** The u64NextTS in jiffies. */
120	unsigned long ulNextJiffies;
121	/** Set when starting or changing the timer so that u64StartTs
122	* and u64NextTS gets reinitialized (eliminating some jitter). */
123	bool volatile fFirstAfterChg;
124	} Std;
125	} u;
126	/** The current tick number. */
127	uint64_t iTick;
128	/** Restart the single shot timer at this specific time.
129	* Used when a single shot timer is restarted from the callback. */
130	uint64_t volatile uNsRestartAt;
131	/** Pointer to the parent timer. */
132	PRTTIMER pParent;
133	/** The current sub-timer state. */
134	RTTIMERLNXSTATE volatile enmState;
135	} RTTIMERLNXSUBTIMER;
136	/** Pointer to a linux sub-timer. */
137	typedef RTTIMERLNXSUBTIMER *PRTTIMERLNXSUBTIMER;
138
139
140	/**
141	* The internal representation of an Linux timer handle.
142	*/
143	typedef struct RTTIMER
144	{
145	/** Magic.
146	* This is RTTIMER_MAGIC, but changes to something else before the timer
147	* is destroyed to indicate clearly that thread should exit. */
148	uint32_t volatile u32Magic;
149	/** Spinlock synchronizing the fSuspended and MP event handling.
150	* This is NIL_RTSPINLOCK if cCpus == 1. */
151	RTSPINLOCK hSpinlock;
152	/** Flag indicating that the timer is suspended. */
153	bool volatile fSuspended;
154	/** Whether the timer must run on one specific CPU or not. */
155	bool fSpecificCpu;
156	#ifdef CONFIG_SMP
157	/** Whether the timer must run on all CPUs or not. */
158	bool fAllCpus;
159	#endif /* else: All -> specific on non-SMP kernels */
160	/** Whether it is a high resolution timer or a standard one. */
161	bool fHighRes;
162	/** The id of the CPU it must run on if fSpecificCpu is set. */
163	RTCPUID idCpu;
164	/** The number of CPUs this timer should run on. */
165	RTCPUID cCpus;
166	/** Callback. */
167	PFNRTTIMER pfnTimer;
168	/** User argument. */
169	void *pvUser;
170	/** The timer interval. 0 if one-shot. */
171	uint64_t volatile u64NanoInterval;
172	/** This is set to the number of jiffies between ticks if the interval is
173	* an exact number of jiffies. (Standard timers only.) */
174	unsigned long volatile cJiffies;
175	/** The change interval spinlock for standard timers only. */
176	spinlock_t ChgIntLock;
177	/** Workqueue item for delayed destruction. */
178	RTR0LNXWORKQUEUEITEM DtorWorkqueueItem;
179	/** Sub-timers.
180	* Normally there is just one, but for RTTIMER_FLAGS_CPU_ALL this will contain
181	* an entry for all possible cpus. In that case the index will be the same as
182	* for the RTCpuSet. */
183	RTTIMERLNXSUBTIMER aSubTimers[1];
184	} RTTIMER;
185
186
187	/**
188	* A rtTimerLinuxStartOnCpu and rtTimerLinuxStartOnCpu argument package.
189	*/
190	typedef struct RTTIMERLINUXSTARTONCPUARGS
191	{
192	/** The current time (RTTimeSystemNanoTS). */
193	uint64_t u64Now;
194	/** When to start firing (delta). */
195	uint64_t u64First;
196	} RTTIMERLINUXSTARTONCPUARGS;
197	/** Pointer to a rtTimerLinuxStartOnCpu argument package. */
198	typedef RTTIMERLINUXSTARTONCPUARGS *PRTTIMERLINUXSTARTONCPUARGS;
199
200
201	/*********************************************************************************************************************************
202	* Internal Functions *
203	*********************************************************************************************************************************/
204	#ifdef CONFIG_SMP
205	static DECLCALLBACK(void) rtTimerLinuxMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser);
206	#endif
207
208	#if 0
209	#define DEBUG_HACKING
210	#include <iprt/string.h>
211	#include <iprt/asm-amd64-x86.h>
212	static void myLogBackdoorPrintf(const char *pszFormat, ...)
213	{
214	char szTmp[256];
215	va_list args;
216	size_t cb;
217
218	cb = RTStrPrintf(szTmp, sizeof(szTmp) - 10, "%d: ", RTMpCpuId());
219	va_start(args, pszFormat);
220	cb += RTStrPrintfV(&szTmp[cb], sizeof(szTmp) - cb, pszFormat, args);
221	va_end(args);
222
223	ASMOutStrU8(0x504, (uint8_t *)&szTmp[0], cb);
224	}
225	# define RTAssertMsg1Weak(pszExpr, uLine, pszFile, pszFunction) \
226	myLogBackdoorPrintf("\n!!Guest Assertion failed!!\n%s(%d) %s\n%s\n", uLine, pszFile, pszFunction, (pszExpr))
227	# define RTAssertMsg2Weak myLogBackdoorPrintf
228	# define RTTIMERLNX_LOG(a) myLogBackdoorPrintf a
229	#else
230	# define RTTIMERLNX_LOG(a) do { } while (0)
231	#endif
232
233	/**
234	* Sets the state.
235	*/
236	DECLINLINE(void) rtTimerLnxSetState(RTTIMERLNXSTATE volatile *penmState, RTTIMERLNXSTATE enmNewState)
237	{
238	#ifdef DEBUG_HACKING
239	RTTIMERLNX_LOG(("set %d -> %d\n", *penmState, enmNewState));
240	#endif
241	ASMAtomicWriteU32((uint32_t volatile *)penmState, enmNewState);
242	}
243
244
245	/**
246	* Sets the state if it has a certain value.
247	*
248	* @return true if xchg was done.
249	* @return false if xchg wasn't done.
250	*/
251	#ifdef DEBUG_HACKING
252	#define rtTimerLnxCmpXchgState(penmState, enmNewState, enmCurState) rtTimerLnxCmpXchgStateDebug(penmState, enmNewState, enmCurState, __LINE__)
253	static bool rtTimerLnxCmpXchgStateDebug(RTTIMERLNXSTATE volatile *penmState, RTTIMERLNXSTATE enmNewState,
254	RTTIMERLNXSTATE enmCurState, uint32_t uLine)
255	{
256	RTTIMERLNXSTATE enmOldState = enmCurState;
257	bool fRc = ASMAtomicCmpXchgExU32((uint32_t volatile )penmState, enmNewState, enmCurState, (uint32_t )&enmOldState);
258	RTTIMERLNX_LOG(("cxg %d -> %d - %d at %u\n", enmOldState, enmNewState, fRc, uLine));
259	return fRc;
260	}
261	#else
262	DECLINLINE(bool) rtTimerLnxCmpXchgState(RTTIMERLNXSTATE volatile *penmState, RTTIMERLNXSTATE enmNewState,
263	RTTIMERLNXSTATE enmCurState)
264	{
265	return ASMAtomicCmpXchgU32((uint32_t volatile *)penmState, enmNewState, enmCurState);
266	}
267	#endif
268
269
270	/**
271	* Gets the state.
272	*/
273	DECLINLINE(RTTIMERLNXSTATE) rtTimerLnxGetState(RTTIMERLNXSTATE volatile *penmState)
274	{
275	return (RTTIMERLNXSTATE)ASMAtomicUoReadU32((uint32_t volatile *)penmState);
276	}
277
278	#ifdef RTTIMER_LINUX_WITH_HRTIMER
279
280	/**
281	* Converts a nano second time stamp to ktime_t.
282	*
283	* ASSUMES RTTimeSystemNanoTS() is implemented using ktime_get_ts().
284	*
285	* @returns ktime_t.
286	* @param cNanoSecs Nanoseconds.
287	*/
288	DECLINLINE(ktime_t) rtTimerLnxNanoToKt(uint64_t cNanoSecs)
289	{
290	/* With some luck the compiler optimizes the division out of this... (Bet it doesn't.) */
291	return ktime_set(cNanoSecs / 1000000000, cNanoSecs % 1000000000);
292	}
293
294	/**
295	* Converts ktime_t to a nano second time stamp.
296	*
297	* ASSUMES RTTimeSystemNanoTS() is implemented using ktime_get_ts().
298	*
299	* @returns nano second time stamp.
300	* @param Kt ktime_t.
301	*/
302	DECLINLINE(uint64_t) rtTimerLnxKtToNano(ktime_t Kt)
303	{
304	return ktime_to_ns(Kt);
305	}
306
307	#endif /* RTTIMER_LINUX_WITH_HRTIMER */
308
309	/**
310	* Converts a nano second interval to jiffies.
311	*
312	* @returns Jiffies.
313	* @param cNanoSecs Nanoseconds.
314	*/
315	DECLINLINE(unsigned long) rtTimerLnxNanoToJiffies(uint64_t cNanoSecs)
316	{
317	/* this can be made even better... */
318	if (cNanoSecs > (uint64_t)TICK_NSEC * MAX_JIFFY_OFFSET)
319	return MAX_JIFFY_OFFSET;
320	# if ARCH_BITS == 32
321	if (RT_LIKELY(cNanoSecs <= UINT32_MAX))
322	return ((uint32_t)cNanoSecs + (TICK_NSEC-1)) / TICK_NSEC;
323	# endif
324	return (cNanoSecs + (TICK_NSEC-1)) / TICK_NSEC;
325	}
326
327
328	/**
329	* Starts a sub-timer (RTTimerStart).
330	*
331	* @param pSubTimer The sub-timer to start.
332	* @param u64Now The current timestamp (RTTimeSystemNanoTS()).
333	* @param u64First The interval from u64Now to the first time the timer should fire.
334	* @param fPinned true = timer pinned to a specific CPU,
335	* false = timer can migrate between CPUs
336	* @param fHighRes Whether the user requested a high resolution timer or not.
337	* @param enmOldState The old timer state.
338	*/
339	static void rtTimerLnxStartSubTimer(PRTTIMERLNXSUBTIMER pSubTimer, uint64_t u64Now, uint64_t u64First,
340	bool fPinned, bool fHighRes)
341	{
342	/*
343	* Calc when it should start firing.
344	*/
345	uint64_t u64NextTS = u64Now + u64First;
346	if (!fHighRes)
347	pSubTimer->u.Std.u64NextTS = u64NextTS;
348	RTTIMERLNX_LOG(("startsubtimer %p\n", pSubTimer->pParent));
349
350	pSubTimer->iTick = 0;
351
352	#ifdef RTTIMER_LINUX_WITH_HRTIMER
353	if (fHighRes)
354	hrtimer_start(&pSubTimer->u.Hr.LnxTimer, rtTimerLnxNanoToKt(u64NextTS),
355	fPinned ? HRTIMER_MODE_ABS_PINNED : HRTIMER_MODE_ABS);
356	else
357	#endif
358	{
359	unsigned long cJiffies = !u64First ? 0 : rtTimerLnxNanoToJiffies(u64First);
360	pSubTimer->u.Std.ulNextJiffies = jiffies + cJiffies;
361	pSubTimer->u.Std.fFirstAfterChg = true;
362	#ifdef CONFIG_SMP
363	if (fPinned)
364	{
365	# if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
366	mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
367	# else
368	mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
369	# endif
370	}
371	else
372	#endif
373	mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
374	}
375
376	/* Be a bit careful here since we could be racing the callback. */
377	if (!rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_STARTING))
378	rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_MP_STARTING);
379	}
380
381
382	/**
383	* Stops a sub-timer (RTTimerStart and rtTimerLinuxMpEvent()).
384	*
385	* The caller has already changed the state, so we will not be in a callback
386	* situation wrt to the calling thread.
387	*
388	* @param pSubTimer The sub-timer.
389	* @param fHighRes Whether the user requested a high resolution timer or not.
390	*/
391	static void rtTimerLnxStopSubTimer(PRTTIMERLNXSUBTIMER pSubTimer, bool fHighRes)
392	{
393	RTTIMERLNX_LOG(("stopsubtimer %p %d\n", pSubTimer->pParent, fHighRes));
394	#ifdef RTTIMER_LINUX_WITH_HRTIMER
395	if (fHighRes)
396	{
397	/* There is no equivalent to del_timer in the hrtimer API,
398	hrtimer_cancel() == del_timer_sync(). Just like the WARN_ON in
399	del_timer_sync() asserts, waiting for a timer callback to complete
400	is deadlock prone, so don't do it. */
401	int rc = hrtimer_try_to_cancel(&pSubTimer->u.Hr.LnxTimer);
402	if (rc < 0)
403	{
404	hrtimer_start(&pSubTimer->u.Hr.LnxTimer, ktime_set(KTIME_SEC_MAX, 0), HRTIMER_MODE_ABS);
405	hrtimer_try_to_cancel(&pSubTimer->u.Hr.LnxTimer);
406	}
407	}
408	else
409	#endif
410	del_timer(&pSubTimer->u.Std.LnxTimer);
411
412	rtTimerLnxSetState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED);
413	}
414
415
416	/**
417	* Used by RTTimerDestroy and rtTimerLnxCallbackDestroy to do the actual work.
418	*
419	* @param pTimer The timer in question.
420	*/
421	static void rtTimerLnxDestroyIt(PRTTIMER pTimer)
422	{
423	RTSPINLOCK hSpinlock = pTimer->hSpinlock;
424	RTCPUID iCpu;
425	Assert(pTimer->fSuspended);
426	RTTIMERLNX_LOG(("destroyit %p\n", pTimer));
427
428	/*
429	* Remove the MP notifications first because it'll reduce the risk of
430	* us overtaking any MP event that might theoretically be racing us here.
431	*/
432	#ifdef CONFIG_SMP
433	if ( pTimer->cCpus > 1
434	&& hSpinlock != NIL_RTSPINLOCK)
435	{
436	int rc = RTMpNotificationDeregister(rtTimerLinuxMpEvent, pTimer);
437	AssertRC(rc);
438	}
439	#endif /* CONFIG_SMP */
440
441	/*
442	* Invalidate the handle.
443	*/
444	ASMAtomicWriteU32(&pTimer->u32Magic, ~RTTIMER_MAGIC);
445
446	/*
447	* Make sure all timers have stopped executing since we're stopping them in
448	* an asynchronous manner up in rtTimerLnxStopSubTimer.
449	*/
450	iCpu = pTimer->cCpus;
451	while (iCpu-- > 0)
452	{
453	#ifdef RTTIMER_LINUX_WITH_HRTIMER
454	if (pTimer->fHighRes)
455	hrtimer_cancel(&pTimer->aSubTimers[iCpu].u.Hr.LnxTimer);
456	else
457	#endif
458	del_timer_sync(&pTimer->aSubTimers[iCpu].u.Std.LnxTimer);
459	}
460
461	/*
462	* Finally, free the resources.
463	*/
464	RTMemFreeEx(pTimer, RT_OFFSETOF(RTTIMER, aSubTimers[pTimer->cCpus]));
465	if (hSpinlock != NIL_RTSPINLOCK)
466	RTSpinlockDestroy(hSpinlock);
467	}
468
469
470	/**
471	* Workqueue callback (no DECLCALLBACK!) for deferred destruction.
472	*
473	* @param pWork Pointer to the DtorWorkqueueItem member of our timer
474	* structure.
475	*/
476	static void rtTimerLnxDestroyDeferred(RTR0LNXWORKQUEUEITEM *pWork)
477	{
478	PRTTIMER pTimer = RT_FROM_MEMBER(pWork, RTTIMER, DtorWorkqueueItem);
479	rtTimerLnxDestroyIt(pTimer);
480	}
481
482
483	/**
484	* Called when the timer was destroyed by the callback function.
485	*
486	* @param pTimer The timer.
487	* @param pSubTimer The sub-timer which we're handling, the state of this
488	* will be RTTIMERLNXSTATE_CALLBACK_DESTROYING.
489	*/
490	static void rtTimerLnxCallbackDestroy(PRTTIMER pTimer, PRTTIMERLNXSUBTIMER pSubTimer)
491	{
492	/*
493	* If it's an omni timer, the last dude does the destroying.
494	*/
495	if (pTimer->cCpus > 1)
496	{
497	uint32_t iCpu = pTimer->cCpus;
498	RTSpinlockAcquire(pTimer->hSpinlock);
499
500	Assert(pSubTimer->enmState == RTTIMERLNXSTATE_CB_DESTROYING);
501	rtTimerLnxSetState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED);
502
503	while (iCpu-- > 0)
504	if (rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState) != RTTIMERLNXSTATE_STOPPED)
505	{
506	RTSpinlockRelease(pTimer->hSpinlock);
507	return;
508	}
509
510	RTSpinlockRelease(pTimer->hSpinlock);
511	}
512
513	/*
514	* Destroying a timer from the callback is unsafe since the callout code
515	* might be touching the timer structure upon return (hrtimer does!). So,
516	* we have to defer the actual destruction to the IRPT workqueue.
517	*/
518	rtR0LnxWorkqueuePush(&pTimer->DtorWorkqueueItem, rtTimerLnxDestroyDeferred);
519	}
520
521
522	#ifdef CONFIG_SMP
523	/**
524	* Deal with a sub-timer that has migrated.
525	*
526	* @param pTimer The timer.
527	* @param pSubTimer The sub-timer.
528	*/
529	static void rtTimerLnxCallbackHandleMigration(PRTTIMER pTimer, PRTTIMERLNXSUBTIMER pSubTimer)
530	{
531	RTTIMERLNXSTATE enmState;
532	if (pTimer->cCpus > 1)
533	RTSpinlockAcquire(pTimer->hSpinlock);
534
535	do
536	{
537	enmState = rtTimerLnxGetState(&pSubTimer->enmState);
538	switch (enmState)
539	{
540	case RTTIMERLNXSTATE_STOPPING:
541	case RTTIMERLNXSTATE_MP_STOPPING:
542	enmState = RTTIMERLNXSTATE_STOPPED;
543	case RTTIMERLNXSTATE_STOPPED:
544	break;
545
546	default:
547	AssertMsgFailed(("%d\n", enmState));
548	case RTTIMERLNXSTATE_STARTING:
549	case RTTIMERLNXSTATE_MP_STARTING:
550	case RTTIMERLNXSTATE_ACTIVE:
551	case RTTIMERLNXSTATE_CALLBACK:
552	case RTTIMERLNXSTATE_CB_STOPPING:
553	case RTTIMERLNXSTATE_CB_RESTARTING:
554	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, enmState))
555	enmState = RTTIMERLNXSTATE_STOPPED;
556	break;
557
558	case RTTIMERLNXSTATE_CB_DESTROYING:
559	{
560	if (pTimer->cCpus > 1)
561	RTSpinlockRelease(pTimer->hSpinlock);
562
563	rtTimerLnxCallbackDestroy(pTimer, pSubTimer);
564	return;
565	}
566	}
567	} while (enmState != RTTIMERLNXSTATE_STOPPED);
568
569	if (pTimer->cCpus > 1)
570	RTSpinlockRelease(pTimer->hSpinlock);
571	}
572	#endif /* CONFIG_SMP */
573
574
575	/**
576	* The slow path of rtTimerLnxChangeToCallbackState.
577	*
578	* @returns true if changed successfully, false if not.
579	* @param pSubTimer The sub-timer.
580	*/
581	static bool rtTimerLnxChangeToCallbackStateSlow(PRTTIMERLNXSUBTIMER pSubTimer)
582	{
583	for (;;)
584	{
585	RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pSubTimer->enmState);
586	switch (enmState)
587	{
588	case RTTIMERLNXSTATE_ACTIVE:
589	case RTTIMERLNXSTATE_STARTING:
590	case RTTIMERLNXSTATE_MP_STARTING:
591	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_CALLBACK, enmState))
592	return true;
593	break;
594
595	case RTTIMERLNXSTATE_CALLBACK:
596	case RTTIMERLNXSTATE_CB_STOPPING:
597	case RTTIMERLNXSTATE_CB_RESTARTING:
598	case RTTIMERLNXSTATE_CB_DESTROYING:
599	AssertMsgFailed(("%d\n", enmState));
600	default:
601	return false;
602	}
603	ASMNopPause();
604	}
605	}
606
607
608	/**
609	* Tries to change the sub-timer state to 'callback'.
610	*
611	* @returns true if changed successfully, false if not.
612	* @param pSubTimer The sub-timer.
613	*/
614	DECLINLINE(bool) rtTimerLnxChangeToCallbackState(PRTTIMERLNXSUBTIMER pSubTimer)
615	{
616	if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_CALLBACK, RTTIMERLNXSTATE_ACTIVE)))
617	return true;
618	return rtTimerLnxChangeToCallbackStateSlow(pSubTimer);
619	}
620
621
622	#ifdef RTTIMER_LINUX_WITH_HRTIMER
623	/**
624	* Timer callback function for high resolution timers.
625	*
626	* @returns HRTIMER_NORESTART or HRTIMER_RESTART depending on whether it's a
627	* one-shot or interval timer.
628	* @param pHrTimer Pointer to the sub-timer structure.
629	*/
630	static enum hrtimer_restart rtTimerLinuxHrCallback(struct hrtimer *pHrTimer)
631	{
632	PRTTIMERLNXSUBTIMER pSubTimer = RT_FROM_MEMBER(pHrTimer, RTTIMERLNXSUBTIMER, u.Hr.LnxTimer);
633	PRTTIMER pTimer = pSubTimer->pParent;
634
635
636	RTTIMERLNX_LOG(("hrcallback %p\n", pTimer));
637	if (RT_UNLIKELY(!rtTimerLnxChangeToCallbackState(pSubTimer)))
638	return HRTIMER_NORESTART;
639
640	#ifdef CONFIG_SMP
641	/*
642	* Check for unwanted migration.
643	*/
644	if (pTimer->fAllCpus \|\| pTimer->fSpecificCpu)
645	{
646	RTCPUID idCpu = RTMpCpuId();
647	if (RT_UNLIKELY( pTimer->fAllCpus
648	? (RTCPUID)(pSubTimer - &pTimer->aSubTimers[0]) != idCpu
649	: pTimer->idCpu != idCpu))
650	{
651	rtTimerLnxCallbackHandleMigration(pTimer, pSubTimer);
652	return HRTIMER_NORESTART;
653	}
654	}
655	#endif
656
657	if (pTimer->u64NanoInterval)
658	{
659	/*
660	* Periodic timer, run it and update the native timer afterwards so
661	* we can handle RTTimerStop and RTTimerChangeInterval from the
662	* callback as well as a racing control thread.
663	*/
664	pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
665	hrtimer_add_expires_ns(&pSubTimer->u.Hr.LnxTimer, ASMAtomicReadU64(&pTimer->u64NanoInterval));
666	if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CALLBACK)))
667	return HRTIMER_RESTART;
668	}
669	else
670	{
671	/*
672	* One shot timer (no omni), stop it before dispatching it.
673	* Allow RTTimerStart as well as RTTimerDestroy to be called from
674	* the callback.
675	*/
676	ASMAtomicWriteBool(&pTimer->fSuspended, true);
677	pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
678	if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_CALLBACK)))
679	return HRTIMER_NORESTART;
680	}
681
682	/*
683	* Some state change occurred while we were in the callback routine.
684	*/
685	for (;;)
686	{
687	RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pSubTimer->enmState);
688	switch (enmState)
689	{
690	case RTTIMERLNXSTATE_CB_DESTROYING:
691	rtTimerLnxCallbackDestroy(pTimer, pSubTimer);
692	return HRTIMER_NORESTART;
693
694	case RTTIMERLNXSTATE_CB_STOPPING:
695	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_CB_STOPPING))
696	return HRTIMER_NORESTART;
697	break;
698
699	case RTTIMERLNXSTATE_CB_RESTARTING:
700	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CB_RESTARTING))
701	{
702	pSubTimer->iTick = 0;
703	hrtimer_set_expires(&pSubTimer->u.Hr.LnxTimer, rtTimerLnxNanoToKt(pSubTimer->uNsRestartAt));
704	return HRTIMER_RESTART;
705	}
706	break;
707
708	default:
709	AssertMsgFailed(("%d\n", enmState));
710	return HRTIMER_NORESTART;
711	}
712	ASMNopPause();
713	}
714	}
715	#endif /* RTTIMER_LINUX_WITH_HRTIMER */
716
717
718	/**
719	* Timer callback function for standard timers.
720	*
721	* @param ulUser Address of the sub-timer structure.
722	*/
723	static void rtTimerLinuxStdCallback(unsigned long ulUser)
724	{
725	PRTTIMERLNXSUBTIMER pSubTimer = (PRTTIMERLNXSUBTIMER)ulUser;
726	PRTTIMER pTimer = pSubTimer->pParent;
727
728	RTTIMERLNX_LOG(("stdcallback %p\n", pTimer));
729	if (RT_UNLIKELY(!rtTimerLnxChangeToCallbackState(pSubTimer)))
730	return;
731
732	#ifdef CONFIG_SMP
733	/*
734	* Check for unwanted migration.
735	*/
736	if (pTimer->fAllCpus \|\| pTimer->fSpecificCpu)
737	{
738	RTCPUID idCpu = RTMpCpuId();
739	if (RT_UNLIKELY( pTimer->fAllCpus
740	? (RTCPUID)(pSubTimer - &pTimer->aSubTimers[0]) != idCpu
741	: pTimer->idCpu != idCpu))
742	{
743	rtTimerLnxCallbackHandleMigration(pTimer, pSubTimer);
744	return;
745	}
746	}
747	#endif
748
749	if (pTimer->u64NanoInterval)
750	{
751	/*
752	* Interval timer, calculate the next timeout.
753	*
754	* The first time around, we'll re-adjust the u.Std.u64NextTS to
755	* try prevent some jittering if we were started at a bad time.
756	*/
757	const uint64_t iTick = ++pSubTimer->iTick;
758	uint64_t u64NanoInterval;
759	unsigned long cJiffies;
760	unsigned long flFlags;
761
762	spin_lock_irqsave(&pTimer->ChgIntLock, flFlags);
763	u64NanoInterval = pTimer->u64NanoInterval;
764	cJiffies = pTimer->cJiffies;
765	if (RT_UNLIKELY(pSubTimer->u.Std.fFirstAfterChg))
766	{
767	pSubTimer->u.Std.fFirstAfterChg = false;
768	pSubTimer->u.Std.u64NextTS = RTTimeSystemNanoTS();
769	pSubTimer->u.Std.ulNextJiffies = jiffies;
770	}
771	spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
772
773	pSubTimer->u.Std.u64NextTS += u64NanoInterval;
774	if (cJiffies)
775	{
776	pSubTimer->u.Std.ulNextJiffies += cJiffies;
777	/* Prevent overflows when the jiffies counter wraps around.
778	* Special thanks to Ken Preslan for helping debugging! */
779	while (time_before(pSubTimer->u.Std.ulNextJiffies, jiffies))
780	{
781	pSubTimer->u.Std.ulNextJiffies += cJiffies;
782	pSubTimer->u.Std.u64NextTS += u64NanoInterval;
783	}
784	}
785	else
786	{
787	const uint64_t u64NanoTS = RTTimeSystemNanoTS();
788	while (pSubTimer->u.Std.u64NextTS < u64NanoTS)
789	pSubTimer->u.Std.u64NextTS += u64NanoInterval;
790	pSubTimer->u.Std.ulNextJiffies = jiffies + rtTimerLnxNanoToJiffies(pSubTimer->u.Std.u64NextTS - u64NanoTS);
791	}
792
793	/*
794	* Run the timer and re-arm it unless the state changed .
795	* .
796	* We must re-arm it afterwards as we're not in a position to undo this .
797	* operation if for instance someone stopped or destroyed us while we .
798	* were in the callback. (Linux takes care of any races here.)
799	*/
800	pTimer->pfnTimer(pTimer, pTimer->pvUser, iTick);
801	if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CALLBACK)))
802	{
803	#ifdef CONFIG_SMP
804	if (pTimer->fSpecificCpu \|\| pTimer->fAllCpus)
805	{
806	# if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
807	mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
808	# else
809	mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
810	# endif
811	}
812	else
813	#endif
814	mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
815	return;
816	}
817	}
818	else
819	{
820	/*
821	* One shot timer, stop it before dispatching it.
822	* Allow RTTimerStart as well as RTTimerDestroy to be called from
823	* the callback.
824	*/
825	ASMAtomicWriteBool(&pTimer->fSuspended, true);
826	pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
827	if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_CALLBACK)))
828	return;
829	}
830
831	/*
832	* Some state change occurred while we were in the callback routine.
833	*/
834	for (;;)
835	{
836	RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pSubTimer->enmState);
837	switch (enmState)
838	{
839	case RTTIMERLNXSTATE_CB_DESTROYING:
840	rtTimerLnxCallbackDestroy(pTimer, pSubTimer);
841	return;
842
843	case RTTIMERLNXSTATE_CB_STOPPING:
844	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_CB_STOPPING))
845	return;
846	break;
847
848	case RTTIMERLNXSTATE_CB_RESTARTING:
849	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CB_RESTARTING))
850	{
851	uint64_t u64NanoTS;
852	uint64_t u64NextTS;
853	unsigned long flFlags;
854
855	spin_lock_irqsave(&pTimer->ChgIntLock, flFlags);
856	u64NextTS = pSubTimer->uNsRestartAt;
857	u64NanoTS = RTTimeSystemNanoTS();
858	pSubTimer->iTick = 0;
859	pSubTimer->u.Std.u64NextTS = u64NextTS;
860	pSubTimer->u.Std.fFirstAfterChg = true;
861	pSubTimer->u.Std.ulNextJiffies = u64NextTS > u64NanoTS
862	? jiffies + rtTimerLnxNanoToJiffies(u64NextTS - u64NanoTS)
863	: jiffies;
864	spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
865
866	#ifdef CONFIG_SMP
867	if (pTimer->fSpecificCpu \|\| pTimer->fAllCpus)
868	{
869	# if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
870	mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
871	# else
872	mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
873	# endif
874	}
875	else
876	#endif
877	mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
878	return;
879	}
880	break;
881
882	default:
883	AssertMsgFailed(("%d\n", enmState));
884	return;
885	}
886	ASMNopPause();
887	}
888	}
889
890
891	#ifdef CONFIG_SMP
892
893	/**
894	* Per-cpu callback function (RTMpOnAll/RTMpOnSpecific).
895	*
896	* @param idCpu The current CPU.
897	* @param pvUser1 Pointer to the timer.
898	* @param pvUser2 Pointer to the argument structure.
899	*/
900	static DECLCALLBACK(void) rtTimerLnxStartAllOnCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
901	{
902	PRTTIMERLINUXSTARTONCPUARGS pArgs = (PRTTIMERLINUXSTARTONCPUARGS)pvUser2;
903	PRTTIMER pTimer = (PRTTIMER)pvUser1;
904	Assert(idCpu < pTimer->cCpus);
905	rtTimerLnxStartSubTimer(&pTimer->aSubTimers[idCpu], pArgs->u64Now, pArgs->u64First, true /fPinned/, pTimer->fHighRes);
906	}
907
908
909	/**
910	* Worker for RTTimerStart() that takes care of the ugly bits.
911	*
912	* @returns RTTimerStart() return value.
913	* @param pTimer The timer.
914	* @param pArgs The argument structure.
915	*/
916	static int rtTimerLnxOmniStart(PRTTIMER pTimer, PRTTIMERLINUXSTARTONCPUARGS pArgs)
917	{
918	RTCPUID iCpu;
919	RTCPUSET OnlineSet;
920	RTCPUSET OnlineSet2;
921	int rc2;
922
923	/*
924	* Prepare all the sub-timers for the startup and then flag the timer
925	* as a whole as non-suspended, make sure we get them all before
926	* clearing fSuspended as the MP handler will be waiting on this
927	* should something happen while we're looping.
928	*/
929	RTSpinlockAcquire(pTimer->hSpinlock);
930
931	/* Just make it a omni timer restriction that no stop/start races are allowed. */
932	for (iCpu = 0; iCpu < pTimer->cCpus; iCpu++)
933	if (rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState) != RTTIMERLNXSTATE_STOPPED)
934	{
935	RTSpinlockRelease(pTimer->hSpinlock);
936	return VERR_TIMER_BUSY;
937	}
938
939	do
940	{
941	RTMpGetOnlineSet(&OnlineSet);
942	for (iCpu = 0; iCpu < pTimer->cCpus; iCpu++)
943	{
944	Assert(pTimer->aSubTimers[iCpu].enmState != RTTIMERLNXSTATE_MP_STOPPING);
945	rtTimerLnxSetState(&pTimer->aSubTimers[iCpu].enmState,
946	RTCpuSetIsMember(&OnlineSet, iCpu)
947	? RTTIMERLNXSTATE_STARTING
948	: RTTIMERLNXSTATE_STOPPED);
949	}
950	} while (!RTCpuSetIsEqual(&OnlineSet, RTMpGetOnlineSet(&OnlineSet2)));
951
952	ASMAtomicWriteBool(&pTimer->fSuspended, false);
953
954	RTSpinlockRelease(pTimer->hSpinlock);
955
956	/*
957	* Start them (can't find any exported function that allows me to
958	* do this without the cross calls).
959	*/
960	pArgs->u64Now = RTTimeSystemNanoTS();
961	rc2 = RTMpOnAll(rtTimerLnxStartAllOnCpu, pTimer, pArgs);
962	AssertRC(rc2); /* screw this if it fails. */
963
964	/*
965	* Reset the sub-timers who didn't start up (ALL CPUs case).
966	*/
967	RTSpinlockAcquire(pTimer->hSpinlock);
968
969	for (iCpu = 0; iCpu < pTimer->cCpus; iCpu++)
970	if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_STARTING))
971	{
972	/** @todo very odd case for a rainy day. Cpus that temporarily went offline while
973	* we were between calls needs to nudged as the MP handler will ignore events for
974	* them because of the STARTING state. This is an extremely unlikely case - not that
975	* that means anything in my experience... ;-) */
976	RTTIMERLNX_LOG(("what!? iCpu=%u -> didn't start\n", iCpu));
977	}
978
979	RTSpinlockRelease(pTimer->hSpinlock);
980
981	return VINF_SUCCESS;
982	}
983
984
985	/**
986	* Worker for RTTimerStop() that takes care of the ugly SMP bits.
987	*
988	* @returns true if there was any active callbacks, false if not.
989	* @param pTimer The timer (valid).
990	* @param fForDestroy Whether this is for RTTimerDestroy or not.
991	*/
992	static bool rtTimerLnxOmniStop(PRTTIMER pTimer, bool fForDestroy)
993	{
994	bool fActiveCallbacks = false;
995	RTCPUID iCpu;
996	RTTIMERLNXSTATE enmState;
997
998
999	/*
1000	* Mark the timer as suspended and flag all timers as stopping, except
1001	* for those being stopped by an MP event.
1002	*/
1003	RTSpinlockAcquire(pTimer->hSpinlock);
1004
1005	ASMAtomicWriteBool(&pTimer->fSuspended, true);
1006	for (iCpu = 0; iCpu < pTimer->cCpus; iCpu++)
1007	{
1008	for (;;)
1009	{
1010	enmState = rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState);
1011	if ( enmState == RTTIMERLNXSTATE_STOPPED
1012	\|\| enmState == RTTIMERLNXSTATE_MP_STOPPING)
1013	break;
1014	if ( enmState == RTTIMERLNXSTATE_CALLBACK
1015	\|\| enmState == RTTIMERLNXSTATE_CB_STOPPING
1016	\|\| enmState == RTTIMERLNXSTATE_CB_RESTARTING)
1017	{
1018	Assert(enmState != RTTIMERLNXSTATE_CB_STOPPING \|\| fForDestroy);
1019	if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState,
1020	!fForDestroy ? RTTIMERLNXSTATE_CB_STOPPING : RTTIMERLNXSTATE_CB_DESTROYING,
1021	enmState))
1022	{
1023	fActiveCallbacks = true;
1024	break;
1025	}
1026	}
1027	else
1028	{
1029	Assert(enmState == RTTIMERLNXSTATE_ACTIVE);
1030	if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState, RTTIMERLNXSTATE_STOPPING, enmState))
1031	break;
1032	}
1033	ASMNopPause();
1034	}
1035	}
1036
1037	RTSpinlockRelease(pTimer->hSpinlock);
1038
1039	/*
1040	* Do the actual stopping. Fortunately, this doesn't require any IPIs.
1041	* Unfortunately it cannot be done synchronously.
1042	*/
1043	for (iCpu = 0; iCpu < pTimer->cCpus; iCpu++)
1044	if (rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState) == RTTIMERLNXSTATE_STOPPING)
1045	rtTimerLnxStopSubTimer(&pTimer->aSubTimers[iCpu], pTimer->fHighRes);
1046
1047	return fActiveCallbacks;
1048	}
1049
1050
1051	/**
1052	* Per-cpu callback function (RTMpOnSpecific) used by rtTimerLinuxMpEvent()
1053	* to start a sub-timer on a cpu that just have come online.
1054	*
1055	* @param idCpu The current CPU.
1056	* @param pvUser1 Pointer to the timer.
1057	* @param pvUser2 Pointer to the argument structure.
1058	*/
1059	static DECLCALLBACK(void) rtTimerLinuxMpStartOnCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
1060	{
1061	PRTTIMERLINUXSTARTONCPUARGS pArgs = (PRTTIMERLINUXSTARTONCPUARGS)pvUser2;
1062	PRTTIMER pTimer = (PRTTIMER)pvUser1;
1063	RTSPINLOCK hSpinlock;
1064	Assert(idCpu < pTimer->cCpus);
1065
1066	/*
1067	* We have to be kind of careful here as we might be racing RTTimerStop
1068	* (and/or RTTimerDestroy, thus the paranoia.
1069	*/
1070	hSpinlock = pTimer->hSpinlock;
1071	if ( hSpinlock != NIL_RTSPINLOCK
1072	&& pTimer->u32Magic == RTTIMER_MAGIC)
1073	{
1074	RTSpinlockAcquire(hSpinlock);
1075
1076	if ( !ASMAtomicUoReadBool(&pTimer->fSuspended)
1077	&& pTimer->u32Magic == RTTIMER_MAGIC)
1078	{
1079	/* We're sane and the timer is not suspended yet. */
1080	PRTTIMERLNXSUBTIMER pSubTimer = &pTimer->aSubTimers[idCpu];
1081	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STARTING, RTTIMERLNXSTATE_STOPPED))
1082	rtTimerLnxStartSubTimer(pSubTimer, pArgs->u64Now, pArgs->u64First, true /fPinned/, pTimer->fHighRes);
1083	}
1084
1085	RTSpinlockRelease(hSpinlock);
1086	}
1087	}
1088
1089
1090	/**
1091	* MP event notification callback.
1092	*
1093	* @param enmEvent The event.
1094	* @param idCpu The cpu it applies to.
1095	* @param pvUser The timer.
1096	*/
1097	static DECLCALLBACK(void) rtTimerLinuxMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser)
1098	{
1099	PRTTIMER pTimer = (PRTTIMER)pvUser;
1100	PRTTIMERLNXSUBTIMER pSubTimer = &pTimer->aSubTimers[idCpu];
1101	RTSPINLOCK hSpinlock;
1102
1103	Assert(idCpu < pTimer->cCpus);
1104
1105	/*
1106	* Some initial paranoia.
1107	*/
1108	if (pTimer->u32Magic != RTTIMER_MAGIC)
1109	return;
1110	hSpinlock = pTimer->hSpinlock;
1111	if (hSpinlock == NIL_RTSPINLOCK)
1112	return;
1113
1114	RTSpinlockAcquire(hSpinlock);
1115
1116	/* Is it active? */
1117	if ( !ASMAtomicUoReadBool(&pTimer->fSuspended)
1118	&& pTimer->u32Magic == RTTIMER_MAGIC)
1119	{
1120	switch (enmEvent)
1121	{
1122	/*
1123	* Try do it without leaving the spin lock, but if we have to, retake it
1124	* when we're on the right cpu.
1125	*/
1126	case RTMPEVENT_ONLINE:
1127	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STARTING, RTTIMERLNXSTATE_STOPPED))
1128	{
1129	RTTIMERLINUXSTARTONCPUARGS Args;
1130	Args.u64Now = RTTimeSystemNanoTS();
1131	Args.u64First = 0;
1132
1133	if (RTMpCpuId() == idCpu)
1134	rtTimerLnxStartSubTimer(pSubTimer, Args.u64Now, Args.u64First, true /fPinned/, pTimer->fHighRes);
1135	else
1136	{
1137	rtTimerLnxSetState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED); /* we'll recheck it. */
1138	RTSpinlockRelease(hSpinlock);
1139
1140	RTMpOnSpecific(idCpu, rtTimerLinuxMpStartOnCpu, pTimer, &Args);
1141	return; /* we've left the spinlock */
1142	}
1143	}
1144	break;
1145
1146	/*
1147	* The CPU is (going) offline, make sure the sub-timer is stopped.
1148	*
1149	* Linux will migrate it to a different CPU, but we don't want this. The
1150	* timer function is checking for this.
1151	*/
1152	case RTMPEVENT_OFFLINE:
1153	{
1154	RTTIMERLNXSTATE enmState;
1155	while ( (enmState = rtTimerLnxGetState(&pSubTimer->enmState)) == RTTIMERLNXSTATE_ACTIVE
1156	\|\| enmState == RTTIMERLNXSTATE_CALLBACK
1157	\|\| enmState == RTTIMERLNXSTATE_CB_RESTARTING)
1158	{
1159	if (enmState == RTTIMERLNXSTATE_ACTIVE)
1160	{
1161	if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STOPPING, RTTIMERLNXSTATE_ACTIVE))
1162	{
1163	RTSpinlockRelease(hSpinlock);
1164
1165	rtTimerLnxStopSubTimer(pSubTimer, pTimer->fHighRes);
1166	return; /* we've left the spinlock */
1167	}
1168	}
1169	else if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_CB_STOPPING, enmState))
1170	break;
1171
1172	/* State not stable, try again. */
1173	ASMNopPause();
1174	}
1175	break;
1176	}
1177	}
1178	}
1179
1180	RTSpinlockRelease(hSpinlock);
1181	}
1182
1183	#endif /* CONFIG_SMP */
1184
1185
1186	/**
1187	* Callback function use by RTTimerStart via RTMpOnSpecific to start a timer
1188	* running on a specific CPU.
1189	*
1190	* @param idCpu The current CPU.
1191	* @param pvUser1 Pointer to the timer.
1192	* @param pvUser2 Pointer to the argument structure.
1193	*/
1194	static DECLCALLBACK(void) rtTimerLnxStartOnSpecificCpu(RTCPUID idCpu, void pvUser1, void pvUser2)
1195	{
1196	PRTTIMERLINUXSTARTONCPUARGS pArgs = (PRTTIMERLINUXSTARTONCPUARGS)pvUser2;
1197	PRTTIMER pTimer = (PRTTIMER)pvUser1;
1198	RT_NOREF_PV(idCpu);
1199	rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], pArgs->u64Now, pArgs->u64First, true /fPinned/, pTimer->fHighRes);
1200	}
1201
1202
1203	RTDECL(int) RTTimerStart(PRTTIMER pTimer, uint64_t u64First)
1204	{
1205	RTTIMERLINUXSTARTONCPUARGS Args;
1206	int rc2;
1207	IPRT_LINUX_SAVE_EFL_AC();
1208
1209	/*
1210	* Validate.
1211	*/
1212	AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
1213	AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
1214
1215	if (!ASMAtomicUoReadBool(&pTimer->fSuspended))
1216	return VERR_TIMER_ACTIVE;
1217	RTTIMERLNX_LOG(("start %p cCpus=%d\n", pTimer, pTimer->cCpus));
1218
1219	Args.u64First = u64First;
1220	#ifdef CONFIG_SMP
1221	/*
1222	* Omni timer?
1223	*/
1224	if (pTimer->fAllCpus)
1225	{
1226	rc2 = rtTimerLnxOmniStart(pTimer, &Args);
1227	IPRT_LINUX_RESTORE_EFL_AC();
1228	return rc2;
1229	}
1230	#endif
1231
1232	/*
1233	* Simple timer - Pretty straight forward if it wasn't for restarting.
1234	*/
1235	Args.u64Now = RTTimeSystemNanoTS();
1236	ASMAtomicWriteU64(&pTimer->aSubTimers[0].uNsRestartAt, Args.u64Now + u64First);
1237	for (;;)
1238	{
1239	RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pTimer->aSubTimers[0].enmState);
1240	switch (enmState)
1241	{
1242	case RTTIMERLNXSTATE_STOPPED:
1243	if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_STARTING, RTTIMERLNXSTATE_STOPPED))
1244	{
1245	ASMAtomicWriteBool(&pTimer->fSuspended, false);
1246	if (!pTimer->fSpecificCpu)
1247	rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], Args.u64Now, Args.u64First,
1248	false /fPinned/, pTimer->fHighRes);
1249	else
1250	{
1251	rc2 = RTMpOnSpecific(pTimer->idCpu, rtTimerLnxStartOnSpecificCpu, pTimer, &Args);
1252	if (RT_FAILURE(rc2))
1253	{
1254	/* Suspend it, the cpu id is probably invalid or offline. */
1255	ASMAtomicWriteBool(&pTimer->fSuspended, true);
1256	rtTimerLnxSetState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_STOPPED);
1257	return rc2;
1258	}
1259	}
1260	IPRT_LINUX_RESTORE_EFL_AC();
1261	return VINF_SUCCESS;
1262	}
1263	break;
1264
1265	case RTTIMERLNXSTATE_CALLBACK:
1266	case RTTIMERLNXSTATE_CB_STOPPING:
1267	if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_CB_RESTARTING, enmState))
1268	{
1269	ASMAtomicWriteBool(&pTimer->fSuspended, false);
1270	IPRT_LINUX_RESTORE_EFL_AC();
1271	return VINF_SUCCESS;
1272	}
1273	break;
1274
1275	default:
1276	AssertMsgFailed(("%d\n", enmState));
1277	IPRT_LINUX_RESTORE_EFL_AC();
1278	return VERR_INTERNAL_ERROR_4;
1279	}
1280	ASMNopPause();
1281	}
1282	}
1283	RT_EXPORT_SYMBOL(RTTimerStart);
1284
1285
1286	/**
1287	* Common worker for RTTimerStop and RTTimerDestroy.
1288	*
1289	* @returns true if there was any active callbacks, false if not.
1290	* @param pTimer The timer to stop.
1291	* @param fForDestroy Whether it's RTTimerDestroy calling or not.
1292	*/
1293	static bool rtTimerLnxStop(PRTTIMER pTimer, bool fForDestroy)
1294	{
1295	RTTIMERLNX_LOG(("lnxstop %p %d\n", pTimer, fForDestroy));
1296	#ifdef CONFIG_SMP
1297	/*
1298	* Omni timer?
1299	*/
1300	if (pTimer->fAllCpus)
1301	return rtTimerLnxOmniStop(pTimer, fForDestroy);
1302	#endif
1303
1304	/*
1305	* Simple timer.
1306	*/
1307	ASMAtomicWriteBool(&pTimer->fSuspended, true);
1308	for (;;)
1309	{
1310	RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pTimer->aSubTimers[0].enmState);
1311	switch (enmState)
1312	{
1313	case RTTIMERLNXSTATE_ACTIVE:
1314	if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_STOPPING, RTTIMERLNXSTATE_ACTIVE))
1315	{
1316	rtTimerLnxStopSubTimer(&pTimer->aSubTimers[0], pTimer->fHighRes);
1317	return false;
1318	}
1319	break;
1320
1321	case RTTIMERLNXSTATE_CALLBACK:
1322	case RTTIMERLNXSTATE_CB_RESTARTING:
1323	case RTTIMERLNXSTATE_CB_STOPPING:
1324	Assert(enmState != RTTIMERLNXSTATE_CB_STOPPING \|\| fForDestroy);
1325	if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState,
1326	!fForDestroy ? RTTIMERLNXSTATE_CB_STOPPING : RTTIMERLNXSTATE_CB_DESTROYING,
1327	enmState))
1328	return true;
1329	break;
1330
1331	case RTTIMERLNXSTATE_STOPPED:
1332	return VINF_SUCCESS;
1333
1334	case RTTIMERLNXSTATE_CB_DESTROYING:
1335	AssertMsgFailed(("enmState=%d pTimer=%p\n", enmState, pTimer));
1336	return true;
1337
1338	default:
1339	case RTTIMERLNXSTATE_STARTING:
1340	case RTTIMERLNXSTATE_MP_STARTING:
1341	case RTTIMERLNXSTATE_STOPPING:
1342	case RTTIMERLNXSTATE_MP_STOPPING:
1343	AssertMsgFailed(("enmState=%d pTimer=%p\n", enmState, pTimer));
1344	return false;
1345	}
1346
1347	/* State not stable, try again. */
1348	ASMNopPause();
1349	}
1350	}
1351
1352
1353	RTDECL(int) RTTimerStop(PRTTIMER pTimer)
1354	{
1355	/*
1356	* Validate.
1357	*/
1358	IPRT_LINUX_SAVE_EFL_AC();
1359	AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
1360	AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
1361	RTTIMERLNX_LOG(("stop %p\n", pTimer));
1362
1363	if (ASMAtomicUoReadBool(&pTimer->fSuspended))
1364	return VERR_TIMER_SUSPENDED;
1365
1366	rtTimerLnxStop(pTimer, false /fForDestroy/);
1367
1368	IPRT_LINUX_RESTORE_EFL_AC();
1369	return VINF_SUCCESS;
1370	}
1371	RT_EXPORT_SYMBOL(RTTimerStop);
1372
1373
1374	RTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
1375	{
1376	unsigned long cJiffies;
1377	unsigned long flFlags;
1378	IPRT_LINUX_SAVE_EFL_AC();
1379
1380	/*
1381	* Validate.
1382	*/
1383	AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
1384	AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
1385	AssertReturn(u64NanoInterval, VERR_INVALID_PARAMETER);
1386	AssertReturn(u64NanoInterval < UINT64_MAX / 8, VERR_INVALID_PARAMETER);
1387	AssertReturn(pTimer->u64NanoInterval, VERR_INVALID_STATE);
1388	RTTIMERLNX_LOG(("change %p %llu\n", pTimer, u64NanoInterval));
1389
1390	#ifdef RTTIMER_LINUX_WITH_HRTIMER
1391	/*
1392	* For the high resolution timers it is easy since we don't care so much
1393	* about when it is applied to the sub-timers.
1394	*/
1395	if (pTimer->fHighRes)
1396	{
1397	ASMAtomicWriteU64(&pTimer->u64NanoInterval, u64NanoInterval);
1398	IPRT_LINUX_RESTORE_EFL_AC();
1399	return VINF_SUCCESS;
1400	}
1401	#endif
1402
1403	/*
1404	* Standard timers have a bit more complicated way of calculating
1405	* their interval and such. So, forget omni timers for now.
1406	*/
1407	if (pTimer->cCpus > 1)
1408	return VERR_NOT_SUPPORTED;
1409
1410	cJiffies = u64NanoInterval / RTTimerGetSystemGranularity();
1411	if (cJiffies * RTTimerGetSystemGranularity() != u64NanoInterval)
1412	cJiffies = 0;
1413
1414	spin_lock_irqsave(&pTimer->ChgIntLock, flFlags);
1415	pTimer->aSubTimers[0].u.Std.fFirstAfterChg = true;
1416	pTimer->cJiffies = cJiffies;
1417	ASMAtomicWriteU64(&pTimer->u64NanoInterval, u64NanoInterval);
1418	spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
1419	IPRT_LINUX_RESTORE_EFL_AC();
1420	return VINF_SUCCESS;
1421	}
1422	RT_EXPORT_SYMBOL(RTTimerChangeInterval);
1423
1424
1425	RTDECL(int) RTTimerDestroy(PRTTIMER pTimer)
1426	{
1427	bool fCanDestroy;
1428	IPRT_LINUX_SAVE_EFL_AC();
1429
1430	/*
1431	* Validate. It's ok to pass NULL pointer.
1432	*/
1433	if (pTimer == /NIL_RTTIMER/ NULL)
1434	return VINF_SUCCESS;
1435	AssertPtrReturn(pTimer, VERR_INVALID_HANDLE);
1436	AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
1437	RTTIMERLNX_LOG(("destroy %p\n", pTimer));
1438	/** @todo We should invalidate the magic here! */
1439
1440	/*
1441	* Stop the timer if it's still active, then destroy it if we can.
1442	*/
1443	if (!ASMAtomicUoReadBool(&pTimer->fSuspended))
1444	fCanDestroy = rtTimerLnxStop(pTimer, true /fForDestroy/);
1445	else
1446	{
1447	uint32_t iCpu = pTimer->cCpus;
1448	if (pTimer->cCpus > 1)
1449	RTSpinlockAcquire(pTimer->hSpinlock);
1450
1451	fCanDestroy = true;
1452	while (iCpu-- > 0)
1453	{
1454	for (;;)
1455	{
1456	RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState);
1457	switch (enmState)
1458	{
1459	case RTTIMERLNXSTATE_CALLBACK:
1460	case RTTIMERLNXSTATE_CB_RESTARTING:
1461	case RTTIMERLNXSTATE_CB_STOPPING:
1462	if (!rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState, RTTIMERLNXSTATE_CB_DESTROYING, enmState))
1463	continue;
1464	fCanDestroy = false;
1465	break;
1466
1467	case RTTIMERLNXSTATE_CB_DESTROYING:
1468	AssertMsgFailed(("%d\n", enmState));
1469	fCanDestroy = false;
1470	break;
1471	default:
1472	break;
1473	}
1474	break;
1475	}
1476	}
1477
1478	if (pTimer->cCpus > 1)
1479	RTSpinlockRelease(pTimer->hSpinlock);
1480	}
1481
1482	if (fCanDestroy)
1483	{
1484	/* For paranoid reasons, defer actually destroying the semaphore when
1485	in atomic or interrupt context. */
1486	#if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 32)
1487	if (in_atomic() \|\| in_interrupt())
1488	#else
1489	if (in_interrupt())
1490	#endif
1491	rtR0LnxWorkqueuePush(&pTimer->DtorWorkqueueItem, rtTimerLnxDestroyDeferred);
1492	else
1493	rtTimerLnxDestroyIt(pTimer);
1494	}
1495
1496	IPRT_LINUX_RESTORE_EFL_AC();
1497	return VINF_SUCCESS;
1498	}
1499	RT_EXPORT_SYMBOL(RTTimerDestroy);
1500
1501
1502	RTDECL(int) RTTimerCreateEx(PRTTIMER ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void pvUser)
1503	{
1504	PRTTIMER pTimer;
1505	RTCPUID iCpu;
1506	unsigned cCpus;
1507	int rc;
1508	IPRT_LINUX_SAVE_EFL_AC();
1509
1510	rtR0LnxWorkqueueFlush(); /* for 2.4 */
1511	*ppTimer = NULL;
1512
1513	/*
1514	* Validate flags.
1515	*/
1516	if (!RTTIMER_FLAGS_ARE_VALID(fFlags))
1517	{
1518	IPRT_LINUX_RESTORE_EFL_AC();
1519	return VERR_INVALID_PARAMETER;
1520	}
1521	if ( (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
1522	&& (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
1523	&& !RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)))
1524	{
1525	IPRT_LINUX_RESTORE_EFL_AC();
1526	return VERR_CPU_NOT_FOUND;
1527	}
1528
1529	/*
1530	* Allocate the timer handler.
1531	*/
1532	cCpus = 1;
1533	#ifdef CONFIG_SMP
1534	if ((fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL)
1535	{
1536	cCpus = RTMpGetMaxCpuId() + 1;
1537	Assert(cCpus <= RTCPUSET_MAX_CPUS); /* On linux we have a 1:1 relationship between cpuid and set index. */
1538	AssertReturnStmt(u64NanoInterval, IPRT_LINUX_RESTORE_EFL_AC(), VERR_NOT_IMPLEMENTED); /* We don't implement single shot on all cpus, sorry. */
1539	}
1540	#endif
1541
1542	rc = RTMemAllocEx(RT_OFFSETOF(RTTIMER, aSubTimers[cCpus]), 0,
1543	RTMEMALLOCEX_FLAGS_ZEROED \| RTMEMALLOCEX_FLAGS_ANY_CTX_FREE, (void **)&pTimer);
1544	if (RT_FAILURE(rc))
1545	{
1546	IPRT_LINUX_RESTORE_EFL_AC();
1547	return rc;
1548	}
1549
1550	/*
1551	* Initialize it.
1552	*/
1553	pTimer->u32Magic = RTTIMER_MAGIC;
1554	pTimer->hSpinlock = NIL_RTSPINLOCK;
1555	pTimer->fSuspended = true;
1556	pTimer->fHighRes = !!(fFlags & RTTIMER_FLAGS_HIGH_RES);
1557	#ifdef CONFIG_SMP
1558	pTimer->fSpecificCpu = (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC) && (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL;
1559	pTimer->fAllCpus = (fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL;
1560	pTimer->idCpu = pTimer->fSpecificCpu
1561	? RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)
1562	: NIL_RTCPUID;
1563	#else
1564	pTimer->fSpecificCpu = !!(fFlags & RTTIMER_FLAGS_CPU_SPECIFIC);
1565	pTimer->idCpu = RTMpCpuId();
1566	#endif
1567	pTimer->cCpus = cCpus;
1568	pTimer->pfnTimer = pfnTimer;
1569	pTimer->pvUser = pvUser;
1570	pTimer->u64NanoInterval = u64NanoInterval;
1571	pTimer->cJiffies = u64NanoInterval / RTTimerGetSystemGranularity();
1572	if (pTimer->cJiffies * RTTimerGetSystemGranularity() != u64NanoInterval)
1573	pTimer->cJiffies = 0;
1574	spin_lock_init(&pTimer->ChgIntLock);
1575
1576	for (iCpu = 0; iCpu < cCpus; iCpu++)
1577	{
1578	#ifdef RTTIMER_LINUX_WITH_HRTIMER
1579	if (pTimer->fHighRes)
1580	{
1581	hrtimer_init(&pTimer->aSubTimers[iCpu].u.Hr.LnxTimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
1582	pTimer->aSubTimers[iCpu].u.Hr.LnxTimer.function = rtTimerLinuxHrCallback;
1583	}
1584	else
1585	#endif
1586	{
1587	#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 8, 0)
1588	init_timer_pinned(&pTimer->aSubTimers[iCpu].u.Std.LnxTimer);
1589	#else
1590	init_timer(&pTimer->aSubTimers[iCpu].u.Std.LnxTimer);
1591	#endif
1592	pTimer->aSubTimers[iCpu].u.Std.LnxTimer.data = (unsigned long)&pTimer->aSubTimers[iCpu];
1593	pTimer->aSubTimers[iCpu].u.Std.LnxTimer.function = rtTimerLinuxStdCallback;
1594	pTimer->aSubTimers[iCpu].u.Std.LnxTimer.expires = jiffies;
1595	pTimer->aSubTimers[iCpu].u.Std.u64NextTS = 0;
1596	}
1597	pTimer->aSubTimers[iCpu].iTick = 0;
1598	pTimer->aSubTimers[iCpu].pParent = pTimer;
1599	pTimer->aSubTimers[iCpu].enmState = RTTIMERLNXSTATE_STOPPED;
1600	}
1601
1602	#ifdef CONFIG_SMP
1603	/*
1604	* If this is running on ALL cpus, we'll have to register a callback
1605	* for MP events (so timers can be started/stopped on cpus going
1606	* online/offline). We also create the spinlock for synchronizing
1607	* stop/start/mp-event.
1608	*/
1609	if (cCpus > 1)
1610	{
1611	int rc = RTSpinlockCreate(&pTimer->hSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "RTTimerLnx");
1612	if (RT_SUCCESS(rc))
1613	rc = RTMpNotificationRegister(rtTimerLinuxMpEvent, pTimer);
1614	else
1615	pTimer->hSpinlock = NIL_RTSPINLOCK;
1616	if (RT_FAILURE(rc))
1617	{
1618	RTTimerDestroy(pTimer);
1619	IPRT_LINUX_RESTORE_EFL_AC();
1620	return rc;
1621	}
1622	}
1623	#endif /* CONFIG_SMP */
1624
1625	RTTIMERLNX_LOG(("create %p hires=%d fFlags=%#x cCpus=%u\n", pTimer, pTimer->fHighRes, fFlags, cCpus));
1626	*ppTimer = pTimer;
1627	IPRT_LINUX_RESTORE_EFL_AC();
1628	return VINF_SUCCESS;
1629	}
1630	RT_EXPORT_SYMBOL(RTTimerCreateEx);
1631
1632
1633	RTDECL(uint32_t) RTTimerGetSystemGranularity(void)
1634	{
1635	#if 0 /** @todo Not sure if this is what we want or not... Add new API for
1636	* querying the resolution of the high res timers? */
1637	struct timespec Ts;
1638	int rc;
1639	IPRT_LINUX_SAVE_EFL_AC();
1640	rc = hrtimer_get_res(CLOCK_MONOTONIC, &Ts);
1641	IPRT_LINUX_RESTORE_EFL_AC();
1642	if (!rc)
1643	{
1644	Assert(!Ts.tv_sec);
1645	return Ts.tv_nsec;
1646	}
1647	#endif
1648	return RT_NS_1SEC / HZ; /* ns */
1649	}
1650	RT_EXPORT_SYMBOL(RTTimerGetSystemGranularity);
1651
1652
1653	RTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
1654	{
1655	RT_NOREF_PV(u32Request); RT_NOREF_PV(*pu32Granted);
1656	return VERR_NOT_SUPPORTED;
1657	}
1658	RT_EXPORT_SYMBOL(RTTimerRequestSystemGranularity);
1659
1660
1661	RTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
1662	{
1663	RT_NOREF_PV(u32Granted);
1664	return VERR_NOT_SUPPORTED;
1665	}
1666	RT_EXPORT_SYMBOL(RTTimerReleaseSystemGranularity);
1667
1668
1669	RTDECL(bool) RTTimerCanDoHighResolution(void)
1670	{
1671	#ifdef RTTIMER_LINUX_WITH_HRTIMER
1672	return true;
1673	#else
1674	return false;
1675	#endif
1676	}
1677	RT_EXPORT_SYMBOL(RTTimerCanDoHighResolution);
1678

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

source: vbox/trunk/src/VBox/Runtime/r0drv/linux/timer-r0drv-linux.c@ 69108

Download in other formats: