ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * IPRT - Timers, Ring-0 Driver, Linux.
caa110e2153c635d3a0910161f3532ace7600bd3vboxsync * Copyright (C) 2006-2014 Oracle Corporation
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * available from http://www.virtualbox.org. This file is free software;
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * you can redistribute it and/or modify it under the terms of the GNU
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * General Public License (GPL) as published by the Free Software
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The contents of this file may alternatively be used under the terms
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * of the Common Development and Distribution License Version 1.0
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * VirtualBox OSE distribution, in which case the provisions of the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * CDDL are applicable instead of those of the GPL.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * You may elect to license modified versions of this file under the
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * terms and conditions of either the GPL or the CDDL or both.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/*******************************************************************************
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync* Header Files *
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync*******************************************************************************/
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync/** @def RTTIMER_LINUX_WITH_HRTIMER
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * Whether to use high resolution timers. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/*******************************************************************************
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync* Structures and Typedefs *
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync*******************************************************************************/
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Timer state machine.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * This is used to try handle the issues with MP events and
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * timers that runs on all CPUs. It's relatively nasty :-/
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Stopped. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Transient state; next ACTIVE. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Transient state; next ACTIVE. (not really necessary) */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Active. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /** Active and in callback; next ACTIVE, STOPPED or CALLBACK_DESTROYING. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /** Stopped while in the callback; next STOPPED. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /** Restarted while in the callback; next ACTIVE, STOPPED, DESTROYING. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /** The callback shall destroy the timer; next STOPPED. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Transient state; next STOPPED. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Transient state; next STOPPED. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** The usual 32-bit hack. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * A Linux sub-timer.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** Timer specific data. */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** High resolution timer. */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** The linux timer structure. */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** Standard timer. */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** The linux timer structure. */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** The start of the current run (ns).
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * This is used to calculate when the timer ought to fire the next time. */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** The u64NextTS in jiffies. */
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync /** Set when starting or changing the timer so that u64StartTs
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * and u64NextTS gets reinitialized (eliminating some jitter). */
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync /** The current tick number. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /** Restart the single shot timer at this specific time.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Used when a single shot timer is restarted from the callback. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Pointer to the parent timer. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** The current sub-timer state. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/** Pointer to a linux sub-timer. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The internal representation of an Linux timer handle.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * This is RTTIMER_MAGIC, but changes to something else before the timer
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * is destroyed to indicate clearly that thread should exit. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Spinlock synchronizing the fSuspended and MP event handling.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * This is NIL_RTSPINLOCK if cCpus == 1. */
b3109af8dcc2a3da7f424aa05a4e84a64bf1c43fvboxsync /** Flag indicating that the timer is suspended. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Whether the timer must run on one specific CPU or not. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Whether the timer must run on all CPUs or not. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync#endif /* else: All -> specific on non-SMP kernels */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** Whether it is a high resolution timer or a standard one. */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync /** The id of the CPU it must run on if fSpecificCpu is set. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** The number of CPUs this timer should run on. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Callback. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** User argument. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** The timer interval. 0 if one-shot. */
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync /** This is set to the number of jiffies between ticks if the interval is
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * an exact number of jiffies. (Standard timers only.) */
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync /** The change interval spinlock for standard timers only. */
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync /** Workqueue item for delayed destruction. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** Sub-timers.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Normally there is just one, but for RTTIMER_FLAGS_CPU_ALL this will contain
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * an entry for all possible cpus. In that case the index will be the same as
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * for the RTCpuSet. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * A rtTimerLinuxStartOnCpu and rtTimerLinuxStartOnCpu argument package.
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync /** The current time (RTTimeSystemNanoTS). */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** When to start firing (delta). */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync/** Pointer to a rtTimerLinuxStartOnCpu argument package. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsynctypedef RTTIMERLINUXSTARTONCPUARGS *PRTTIMERLINUXSTARTONCPUARGS;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync/*******************************************************************************
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync* Internal Functions *
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync*******************************************************************************/
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncstatic DECLCALLBACK(void) rtTimerLinuxMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser);
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsyncstatic void myLogBackdoorPrintf(const char *pszFormat, ...)
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsync cb = RTStrPrintf(szTmp, sizeof(szTmp) - 10, "%d: ", RTMpCpuId());
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsync cb += RTStrPrintfV(&szTmp[cb], sizeof(szTmp) - cb, pszFormat, args);
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync# define RTAssertMsg1Weak(pszExpr, uLine, pszFile, pszFunction) \
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsync myLogBackdoorPrintf("\n!!Guest Assertion failed!!\n%s(%d) %s\n%s\n", uLine, pszFile, pszFunction, (pszExpr))
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Sets the state.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncDECLINLINE(void) rtTimerLnxSetState(RTTIMERLNXSTATE volatile *penmState, RTTIMERLNXSTATE enmNewState)
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("set %d -> %d\n", *penmState, enmNewState));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync ASMAtomicWriteU32((uint32_t volatile *)penmState, enmNewState);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Sets the state if it has a certain value.
0780b79e94db3b60fb4a3057df7c64ba8b1cb75dvboxsync * @return true if xchg was done.
0780b79e94db3b60fb4a3057df7c64ba8b1cb75dvboxsync * @return false if xchg wasn't done.
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsync#define rtTimerLnxCmpXchgState(penmState, enmNewState, enmCurState) rtTimerLnxCmpXchgStateDebug(penmState, enmNewState, enmCurState, __LINE__)
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsyncstatic bool rtTimerLnxCmpXchgStateDebug(RTTIMERLNXSTATE volatile *penmState, RTTIMERLNXSTATE enmNewState,
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsync bool fRc = ASMAtomicCmpXchgExU32((uint32_t volatile *)penmState, enmNewState, enmCurState, (uint32_t *)&enmOldState);
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("cxg %d -> %d - %d at %u\n", enmOldState, enmNewState, fRc, uLine));
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsyncDECLINLINE(bool) rtTimerLnxCmpXchgState(RTTIMERLNXSTATE volatile *penmState, RTTIMERLNXSTATE enmNewState,
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync return ASMAtomicCmpXchgU32((uint32_t volatile *)penmState, enmNewState, enmCurState);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Gets the state.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncDECLINLINE(RTTIMERLNXSTATE) rtTimerLnxGetState(RTTIMERLNXSTATE volatile *penmState)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync return (RTTIMERLNXSTATE)ASMAtomicUoReadU32((uint32_t volatile *)penmState);
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync * Converts a nano second time stamp to ktime_t.
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * ASSUMES RTTimeSystemNanoTS() is implemented using ktime_get_ts().
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync * @returns ktime_t.
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync * @param cNanoSecs Nanoseconds.
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsyncDECLINLINE(ktime_t) rtTimerLnxNanoToKt(uint64_t cNanoSecs)
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync /* With some luck the compiler optimizes the division out of this... (Bet it doesn't.) */
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync return ktime_set(cNanoSecs / 1000000000, cNanoSecs % 1000000000);
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync * Converts ktime_t to a nano second time stamp.
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * ASSUMES RTTimeSystemNanoTS() is implemented using ktime_get_ts().
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync * @returns nano second time stamp.
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync * @param Kt ktime_t.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync#endif /* RTTIMER_LINUX_WITH_HRTIMER */
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync * Converts a nano second interval to jiffies.
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync * @returns Jiffies.
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync * @param cNanoSecs Nanoseconds.
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsyncDECLINLINE(unsigned long) rtTimerLnxNanoToJiffies(uint64_t cNanoSecs)
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync /* this can be made even better... */
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync if (cNanoSecs > (uint64_t)TICK_NSEC * MAX_JIFFY_OFFSET)
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync return ((uint32_t)cNanoSecs + (TICK_NSEC-1)) / TICK_NSEC;
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Starts a sub-timer (RTTimerStart).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pSubTimer The sub-timer to start.
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * @param u64Now The current timestamp (RTTimeSystemNanoTS()).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param u64First The interval from u64Now to the first time the timer should fire.
76cb9831bbeaff3bb30068363e35660a776736c4vboxsync * @param fPinned true = timer pinned to a specific CPU,
76cb9831bbeaff3bb30068363e35660a776736c4vboxsync * false = timer can migrate between CPUs
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * @param fHighRes Whether the user requested a high resolution timer or not.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param enmOldState The old timer state.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsyncstatic void rtTimerLnxStartSubTimer(PRTTIMERLNXSUBTIMER pSubTimer, uint64_t u64Now, uint64_t u64First,
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Calc when it should start firing.
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("startsubtimer %p\n", pSubTimer->pParent));
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync hrtimer_start(&pSubTimer->u.Hr.LnxTimer, rtTimerLnxNanoToKt(u64NextTS),
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync fPinned ? HRTIMER_MODE_ABS_PINNED : HRTIMER_MODE_ABS);
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync unsigned long cJiffies = !u64First ? 0 : rtTimerLnxNanoToJiffies(u64First);
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync pSubTimer->u.Std.ulNextJiffies = jiffies + cJiffies;
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /* Be a bit careful here since we could be racing the callback. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (!rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_STARTING))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_MP_STARTING);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Stops a sub-timer (RTTimerStart and rtTimerLinuxMpEvent()).
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * The caller has already changed the state, so we will not be in a callback
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * situation wrt to the calling thread.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pSubTimer The sub-timer.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param fHighRes Whether the user requested a high resolution timer or not.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncstatic void rtTimerLnxStopSubTimer(PRTTIMERLNXSUBTIMER pSubTimer, bool fHighRes)
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("stopsubtimer %p %d\n", pSubTimer->pParent, fHighRes));
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync /* There is no equivalent to del_timer in the hrtimer API,
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync hrtimer_cancel() == del_timer_sync(). Just like the WARN_ON in
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync del_timer_sync() asserts, waiting for a timer callback to complete
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync is deadlock prone, so don't do it. */
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync int rc = hrtimer_try_to_cancel(&pSubTimer->u.Hr.LnxTimer);
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync hrtimer_start(&pSubTimer->u.Hr.LnxTimer, ktime_set(KTIME_SEC_MAX, 0), HRTIMER_MODE_ABS);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync rtTimerLnxSetState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Used by RTTimerDestroy and rtTimerLnxCallbackDestroy to do the actual work.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pTimer The timer in question.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Remove the MP notifications first because it'll reduce the risk of
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * us overtaking any MP event that might theoretically be racing us here.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync int rc = RTMpNotificationDeregister(rtTimerLinuxMpEvent, pTimer);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync#endif /* CONFIG_SMP */
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * Invalidate the handle.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync ASMAtomicWriteU32(&pTimer->u32Magic, ~RTTIMER_MAGIC);
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * Make sure all timers have stopped executing since we're stopping them in
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * an asynchronous manner up in rtTimerLnxStopSubTimer.
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync while (iCpu-- > 0)
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync hrtimer_cancel(&pTimer->aSubTimers[iCpu].u.Hr.LnxTimer);
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync del_timer_sync(&pTimer->aSubTimers[iCpu].u.Std.LnxTimer);
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * Finally, free the resources.
25c97a3e3ce2710f95faa6d181486df26b518e74vboxsync RTMemFreeEx(pTimer, RT_OFFSETOF(RTTIMER, aSubTimers[pTimer->cCpus]));
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * Workqueue callback (no DECLCALLBACK!) for deferred destruction.
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * @param pWork Pointer to the DtorWorkqueueItem member of our timer
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * structure.
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsyncstatic void rtTimerLnxDestroyDeferred(RTR0LNXWORKQUEUEITEM *pWork)
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync PRTTIMER pTimer = RT_FROM_MEMBER(pWork, RTTIMER, DtorWorkqueueItem);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Called when the timer was destroyed by the callback function.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pTimer The timer.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pSubTimer The sub-timer which we're handling, the state of this
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * will be RTTIMERLNXSTATE_CALLBACK_DESTROYING.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncstatic void rtTimerLnxCallbackDestroy(PRTTIMER pTimer, PRTTIMERLNXSUBTIMER pSubTimer)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * If it's an omni timer, the last dude does the destroying.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync Assert(pSubTimer->enmState == RTTIMERLNXSTATE_CB_DESTROYING);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync rtTimerLnxSetState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync while (iCpu-- > 0)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState) != RTTIMERLNXSTATE_STOPPED)
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * Destroying a timer from the callback is unsafe since the callout code
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * might be touching the timer structure upon return (hrtimer does!). So,
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * we have to defer the actual destruction to the IRPT workqueue.
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync rtR0LnxWorkqueuePush(&pTimer->DtorWorkqueueItem, rtTimerLnxDestroyDeferred);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Deal with a sub-timer that has migrated.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pTimer The timer.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pSubTimer The sub-timer.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncstatic void rtTimerLnxCallbackHandleMigration(PRTTIMER pTimer, PRTTIMERLNXSUBTIMER pSubTimer)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync enmState = rtTimerLnxGetState(&pSubTimer->enmState);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, enmState))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync#endif /* CONFIG_SMP */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * The slow path of rtTimerLnxChangeToCallbackState.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @returns true if changed successfully, false if not.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pSubTimer The sub-timer.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncstatic bool rtTimerLnxChangeToCallbackStateSlow(PRTTIMERLNXSUBTIMER pSubTimer)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pSubTimer->enmState);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_CALLBACK, enmState))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return true;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return false;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Tries to change the sub-timer state to 'callback'.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @returns true if changed successfully, false if not.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pSubTimer The sub-timer.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncDECLINLINE(bool) rtTimerLnxChangeToCallbackState(PRTTIMERLNXSUBTIMER pSubTimer)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_CALLBACK, RTTIMERLNXSTATE_ACTIVE)))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return true;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return rtTimerLnxChangeToCallbackStateSlow(pSubTimer);
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * Timer callback function for high resolution timers.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * @returns HRTIMER_NORESTART or HRTIMER_RESTART depending on whether it's a
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * one-shot or interval timer.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pHrTimer Pointer to the sub-timer structure.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsyncstatic enum hrtimer_restart rtTimerLinuxHrCallback(struct hrtimer *pHrTimer)
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync PRTTIMERLNXSUBTIMER pSubTimer = RT_FROM_MEMBER(pHrTimer, RTTIMERLNXSUBTIMER, u.Hr.LnxTimer);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (RT_UNLIKELY(!rtTimerLnxChangeToCallbackState(pSubTimer)))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Check for unwanted migration.
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync ? (RTCPUID)(pSubTimer - &pTimer->aSubTimers[0]) != idCpu
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync rtTimerLnxCallbackHandleMigration(pTimer, pSubTimer);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Periodic timer, run it and update the native timer afterwards so
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * we can handle RTTimerStop and RTTimerChangeInterval from the
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * callback as well as a racing control thread.
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync hrtimer_add_expires_ns(&pSubTimer->u.Hr.LnxTimer, ASMAtomicReadU64(&pTimer->u64NanoInterval));
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CALLBACK)))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * One shot timer (no omni), stop it before dispatching it.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Allow RTTimerStart as well as RTTimerDestroy to be called from
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * the callback.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_CALLBACK)))
ad27e1d5e48ca41245120c331cc88b50464813cevboxsync * Some state change occurred while we were in the callback routine.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pSubTimer->enmState);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_CB_STOPPING))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CB_RESTARTING))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync hrtimer_set_expires(&pSubTimer->u.Hr.LnxTimer, rtTimerLnxNanoToKt(pSubTimer->uNsRestartAt));
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync#endif /* RTTIMER_LINUX_WITH_HRTIMER */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * Timer callback function for standard timers.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * @param ulUser Address of the sub-timer structure.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsyncstatic void rtTimerLinuxStdCallback(unsigned long ulUser)
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync PRTTIMERLNXSUBTIMER pSubTimer = (PRTTIMERLNXSUBTIMER)ulUser;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (RT_UNLIKELY(!rtTimerLnxChangeToCallbackState(pSubTimer)))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Check for unwanted migration.
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync ? (RTCPUID)(pSubTimer - &pTimer->aSubTimers[0]) != idCpu
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync rtTimerLnxCallbackHandleMigration(pTimer, pSubTimer);
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * Interval timer, calculate the next timeout.
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * The first time around, we'll re-adjust the u.Std.u64NextTS to
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * try prevent some jittering if we were started at a bad time.
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
3a2aedd9e337c0cc515ce501a066359ba2f9505cvboxsync /* Prevent overflows when the jiffies counter wraps around.
3a2aedd9e337c0cc515ce501a066359ba2f9505cvboxsync * Special thanks to Ken Preslan for helping debugging! */
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync while (time_before(pSubTimer->u.Std.ulNextJiffies, jiffies))
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync pSubTimer->u.Std.ulNextJiffies = jiffies + rtTimerLnxNanoToJiffies(pSubTimer->u.Std.u64NextTS - u64NanoTS);
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * Run the timer and re-arm it unless the state changed .
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * We must re-arm it afterwards as we're not in a position to undo this .
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * operation if for instance someone stopped or destroyed us while we .
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync * were in the callback. (Linux takes care of any races here.)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CALLBACK)))
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * One shot timer, stop it before dispatching it.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Allow RTTimerStart as well as RTTimerDestroy to be called from
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * the callback.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->pfnTimer(pTimer, pTimer->pvUser, ++pSubTimer->iTick);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (RT_LIKELY(rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_CALLBACK)))
ad27e1d5e48ca41245120c331cc88b50464813cevboxsync * Some state change occurred while we were in the callback routine.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pSubTimer->enmState);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_CB_STOPPING))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_ACTIVE, RTTIMERLNXSTATE_CB_RESTARTING))
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync pSubTimer->u.Std.ulNextJiffies = u64NextTS > u64NanoTS
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync ? jiffies + rtTimerLnxNanoToJiffies(u64NextTS - u64NanoTS)
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync mod_timer_pinned(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync mod_timer(&pSubTimer->u.Std.LnxTimer, pSubTimer->u.Std.ulNextJiffies);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Per-cpu callback function (RTMpOnAll/RTMpOnSpecific).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param idCpu The current CPU.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pvUser1 Pointer to the timer.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pvUser2 Pointer to the argument structure.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(void) rtTimerLnxStartAllOnCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync PRTTIMERLINUXSTARTONCPUARGS pArgs = (PRTTIMERLINUXSTARTONCPUARGS)pvUser2;
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync rtTimerLnxStartSubTimer(&pTimer->aSubTimers[idCpu], pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
2b6e5e029d7448f21b9f8b6fb2c87b13c22b4997vboxsync * Worker for RTTimerStart() that takes care of the ugly bits.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @returns RTTimerStart() return value.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pTimer The timer.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pArgs The argument structure.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncstatic int rtTimerLnxOmniStart(PRTTIMER pTimer, PRTTIMERLINUXSTARTONCPUARGS pArgs)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Prepare all the sub-timers for the startup and then flag the timer
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * as a whole as non-suspended, make sure we get them all before
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * clearing fSuspended as the MP handler will be waiting on this
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * should something happen while we're looping.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /* Just make it a omni timer restriction that no stop/start races are allowed. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState) != RTTIMERLNXSTATE_STOPPED)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync Assert(pTimer->aSubTimers[iCpu].enmState != RTTIMERLNXSTATE_MP_STOPPING);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync rtTimerLnxSetState(&pTimer->aSubTimers[iCpu].enmState,
67c73271505adae0686ddbc74eaeef778ef16792vboxsync } while (!RTCpuSetIsEqual(&OnlineSet, RTMpGetOnlineSet(&OnlineSet2)));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Start them (can't find any exported function that allows me to
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * do this without the cross calls).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync rc2 = RTMpOnAll(rtTimerLnxStartAllOnCpu, pTimer, pArgs);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Reset the sub-timers who didn't start up (ALL CPUs case).
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_STARTING))
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /** @todo very odd case for a rainy day. Cpus that temporarily went offline while
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * we were between calls needs to nudged as the MP handler will ignore events for
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * them because of the STARTING state. This is an extremely unlikely case - not that
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * that means anything in my experience... ;-) */
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("what!? iCpu=%u -> didn't start\n", iCpu));
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Worker for RTTimerStop() that takes care of the ugly SMP bits.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @returns true if there was any active callbacks, false if not.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pTimer The timer (valid).
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param fForDestroy Whether this is for RTTimerDestroy or not.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncstatic bool rtTimerLnxOmniStop(PRTTIMER pTimer, bool fForDestroy)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Mark the timer as suspended and flag all timers as stopping, except
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * for those being stopped by an MP event.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync enmState = rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync Assert(enmState != RTTIMERLNXSTATE_CB_STOPPING || fForDestroy);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState,
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync !fForDestroy ? RTTIMERLNXSTATE_CB_STOPPING : RTTIMERLNXSTATE_CB_DESTROYING,
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState, RTTIMERLNXSTATE_STOPPING, enmState))
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Do the actual stopping. Fortunately, this doesn't require any IPIs.
10f0e3bfdb61e7bae30a1a1d9c17659a908c3d37vboxsync * Unfortunately it cannot be done synchronously.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync if (rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState) == RTTIMERLNXSTATE_STOPPING)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync rtTimerLnxStopSubTimer(&pTimer->aSubTimers[iCpu], pTimer->fHighRes);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Per-cpu callback function (RTMpOnSpecific) used by rtTimerLinuxMpEvent()
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * to start a sub-timer on a cpu that just have come online.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param idCpu The current CPU.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pvUser1 Pointer to the timer.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pvUser2 Pointer to the argument structure.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(void) rtTimerLinuxMpStartOnCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync PRTTIMERLINUXSTARTONCPUARGS pArgs = (PRTTIMERLINUXSTARTONCPUARGS)pvUser2;
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync * We have to be kind of careful here as we might be racing RTTimerStop
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync * (and/or RTTimerDestroy, thus the paranoia.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* We're sane and the timer is not suspended yet. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync PRTTIMERLNXSUBTIMER pSubTimer = &pTimer->aSubTimers[idCpu];
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STARTING, RTTIMERLNXSTATE_STOPPED))
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync rtTimerLnxStartSubTimer(pSubTimer, pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * MP event notification callback.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param enmEvent The event.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param idCpu The cpu it applies to.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * @param pvUser The timer.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsyncstatic DECLCALLBACK(void) rtTimerLinuxMpEvent(RTMPEVENT enmEvent, RTCPUID idCpu, void *pvUser)
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync PRTTIMERLNXSUBTIMER pSubTimer = &pTimer->aSubTimers[idCpu];
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Some initial paranoia.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync /* Is it active? */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Try do it without leaving the spin lock, but if we have to, retake it
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * when we're on the right cpu.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STARTING, RTTIMERLNXSTATE_STOPPED))
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync rtTimerLnxStartSubTimer(pSubTimer, Args.u64Now, Args.u64First, true /*fPinned*/, pTimer->fHighRes);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync rtTimerLnxSetState(&pSubTimer->enmState, RTTIMERLNXSTATE_STOPPED); /* we'll recheck it. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync RTMpOnSpecific(idCpu, rtTimerLinuxMpStartOnCpu, pTimer, &Args);
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync return; /* we've left the spinlock */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * The CPU is (going) offline, make sure the sub-timer is stopped.
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * Linux will migrate it to a different CPU, but we don't want this. The
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync * timer function is checking for this.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync while ( (enmState = rtTimerLnxGetState(&pSubTimer->enmState)) == RTTIMERLNXSTATE_ACTIVE
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STOPPING, RTTIMERLNXSTATE_ACTIVE))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync rtTimerLnxStopSubTimer(pSubTimer, pTimer->fHighRes);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return; /* we've left the spinlock */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync else if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_CB_STOPPING, enmState))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /* State not stable, try again. */
ae41886ba231ade1b868dd32ff24ee49813ebbabvboxsync#endif /* CONFIG_SMP */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Callback function use by RTTimerStart via RTMpOnSpecific to start a timer
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * running on a specific CPU.
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * @param idCpu The current CPU.
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * @param pvUser1 Pointer to the timer.
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * @param pvUser2 Pointer to the argument structure.
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsyncstatic DECLCALLBACK(void) rtTimerLnxStartOnSpecificCpu(RTCPUID idCpu, void *pvUser1, void *pvUser2)
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync PRTTIMERLINUXSTARTONCPUARGS pArgs = (PRTTIMERLINUXSTARTONCPUARGS)pvUser2;
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsyncRTDECL(int) RTTimerStart(PRTTIMER pTimer, uint64_t u64First)
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * Validate.
b377a71756cce9f39d25b561f72bfa33ce8a39devboxsync AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("start %p cCpus=%d\n", pTimer, pTimer->cCpus));
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Omni timer?
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Simple timer - Pretty straight forward if it wasn't for restarting.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync ASMAtomicWriteU64(&pTimer->aSubTimers[0].uNsRestartAt, Args.u64Now + u64First);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pTimer->aSubTimers[0].enmState);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_STARTING, RTTIMERLNXSTATE_STOPPED))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], Args.u64Now, Args.u64First,
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync rc2 = RTMpOnSpecific(pTimer->idCpu, rtTimerLnxStartOnSpecificCpu, pTimer, &Args);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /* Suspend it, the cpu id is probably invalid or offline. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync rtTimerLnxSetState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_STOPPED);
9edbe160de7266b3b5d54ccf2f07ed95f9f40c6bvboxsync if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_CB_RESTARTING, enmState))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Common worker for RTTimerStop and RTTimerDestroy.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @returns true if there was any active callbacks, false if not.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param pTimer The timer to stop.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * @param fForDestroy Whether it's RTTimerDestroy calling or not.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsyncstatic bool rtTimerLnxStop(PRTTIMER pTimer, bool fForDestroy)
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("lnxstop %p %d\n", pTimer, fForDestroy));
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync * Omni timer?
0f77dc54d7ec617480988ccdfcd080f480e79698vboxsync * Simple timer.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pTimer->aSubTimers[0].enmState);
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState, RTTIMERLNXSTATE_STOPPING, RTTIMERLNXSTATE_ACTIVE))
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync rtTimerLnxStopSubTimer(&pTimer->aSubTimers[0], pTimer->fHighRes);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return false;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync Assert(enmState != RTTIMERLNXSTATE_CB_STOPPING || fForDestroy);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[0].enmState,
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync !fForDestroy ? RTTIMERLNXSTATE_CB_STOPPING : RTTIMERLNXSTATE_CB_DESTROYING,
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return true;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync AssertMsgFailed(("enmState=%d pTimer=%p\n", enmState, pTimer));
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return true;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync AssertMsgFailed(("enmState=%d pTimer=%p\n", enmState, pTimer));
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync return false;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync /* State not stable, try again. */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Validate.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsyncRTDECL(int) RTTimerChangeInterval(PRTTIMER pTimer, uint64_t u64NanoInterval)
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync * Validate.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync AssertReturn(u64NanoInterval, VERR_INVALID_PARAMETER);
1f17427b60832e237f8277e1aef8cae3b441f52avboxsync AssertReturn(u64NanoInterval < UINT64_MAX / 8, VERR_INVALID_PARAMETER);
1f17427b60832e237f8277e1aef8cae3b441f52avboxsync AssertReturn(pTimer->u64NanoInterval, VERR_INVALID_STATE);
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("change %p %llu\n", pTimer, u64NanoInterval));
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * For the high resolution timers it is easy since we don't care so much
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * about when it is applied to the sub-timers.
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync ASMAtomicWriteU64(&pTimer->u64NanoInterval, u64NanoInterval);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Standard timers have a bit more complicated way of calculating
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * their interval and such. So, forget omni timers for now.
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync cJiffies = u64NanoInterval / RTTimerGetSystemGranularity();
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync if (cJiffies * RTTimerGetSystemGranularity() != u64NanoInterval)
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync ASMAtomicWriteU64(&pTimer->u64NanoInterval, u64NanoInterval);
852e87ceabd0234ac0f9e71537c11d08e35f736cvboxsync spin_unlock_irqrestore(&pTimer->ChgIntLock, flFlags);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Validate. It's ok to pass NULL pointer.
b377a71756cce9f39d25b561f72bfa33ce8a39devboxsync AssertReturn(pTimer->u32Magic == RTTIMER_MAGIC, VERR_INVALID_HANDLE);
7202d537edf6d2c5fc2c26bade6855541c675fa0vboxsync/** @todo We should invalidate the magic here! */
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * Stop the timer if it's still active, then destroy it if we can.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync fCanDestroy = rtTimerLnxStop(pTimer, true /*fForDestroy*/);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync while (iCpu-- > 0)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync RTTIMERLNXSTATE enmState = rtTimerLnxGetState(&pTimer->aSubTimers[iCpu].enmState);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync if (!rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState, RTTIMERLNXSTATE_CB_DESTROYING, enmState))
7202d537edf6d2c5fc2c26bade6855541c675fa0vboxsync /* For paranoid reasons, defer actually destroying the semaphore when
7202d537edf6d2c5fc2c26bade6855541c675fa0vboxsync in atomic or interrupt context. */
7202d537edf6d2c5fc2c26bade6855541c675fa0vboxsync rtR0LnxWorkqueuePush(&pTimer->DtorWorkqueueItem, rtTimerLnxDestroyDeferred);
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsyncRTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * Validate flags.
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync && (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync && !RTMpIsCpuPossible(RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)))
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * Allocate the timer handler.
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync if ((fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL)
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync Assert(cCpus <= RTCPUSET_MAX_CPUS); /* On linux we have a 1:1 relationship between cpuid and set index. */
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync AssertReturn(u64NanoInterval, VERR_NOT_IMPLEMENTED); /* We don't implement single shot on all cpus, sorry. */
25c97a3e3ce2710f95faa6d181486df26b518e74vboxsync rc = RTMemAllocEx(RT_OFFSETOF(RTTIMER, aSubTimers[cCpus]), 0,
25c97a3e3ce2710f95faa6d181486df26b518e74vboxsync RTMEMALLOCEX_FLAGS_ZEROED | RTMEMALLOCEX_FLAGS_ANY_CTX_FREE, (void **)&pTimer);
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * Initialize it.
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->fHighRes = !!(fFlags & RTTIMER_FLAGS_HIGH_RES);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->fSpecificCpu = (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC) && (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->fAllCpus = (fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync ? RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK)
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->fSpecificCpu = !!(fFlags & RTTIMER_FLAGS_CPU_SPECIFIC);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->cJiffies = u64NanoInterval / RTTimerGetSystemGranularity();
4aafb1203580a5c145a7bdae57ebf69a36fa4f01vboxsync if (pTimer->cJiffies * RTTimerGetSystemGranularity() != u64NanoInterval)
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync hrtimer_init(&pTimer->aSubTimers[iCpu].u.Hr.LnxTimer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->aSubTimers[iCpu].u.Hr.LnxTimer.function = rtTimerLinuxHrCallback;
0cde281779e97ead3181bbd3b628451fa2b1efe1vboxsync init_timer(&pTimer->aSubTimers[iCpu].u.Std.LnxTimer);
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->aSubTimers[iCpu].u.Std.LnxTimer.data = (unsigned long)&pTimer->aSubTimers[iCpu];
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->aSubTimers[iCpu].u.Std.LnxTimer.function = rtTimerLinuxStdCallback;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->aSubTimers[iCpu].u.Std.LnxTimer.expires = jiffies;
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync pTimer->aSubTimers[iCpu].enmState = RTTIMERLNXSTATE_STOPPED;
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * If this is running on ALL cpus, we'll have to register a callback
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync * for MP events (so timers can be started/stopped on cpus going
ad27e1d5e48ca41245120c331cc88b50464813cevboxsync * online/offline). We also create the spinlock for synchronizing
4b65b0b7127fe2f685bb5c3319f803a16b84ee6cvboxsync int rc = RTSpinlockCreate(&pTimer->hSpinlock, RTSPINLOCK_FLAGS_INTERRUPT_SAFE, "RTTimerLnx");
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync rc = RTMpNotificationRegister(rtTimerLinuxMpEvent, pTimer);
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsync#endif /* CONFIG_SMP */
951d1da36c2120dd8bf59a3b57800f8429dcd387vboxsync RTTIMERLNX_LOG(("create %p hires=%d fFlags=%#x cCpus=%u\n", pTimer, pTimer->fHighRes, fFlags, cCpus));
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync#if 0 /** @todo Not sure if this is what we want or not... Add new API for
7e3ff7c4e45ee1f8eb46a1aba9d2d8816d337c4avboxsync * querying the resolution of the high res timers? */
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsyncRTDECL(int) RTTimerRequestSystemGranularity(uint32_t u32Request, uint32_t *pu32Granted)
bc0c1e33e433d1276ea1606ace81f61594ee3838vboxsyncRTDECL(int) RTTimerReleaseSystemGranularity(uint32_t u32Granted)
0dfc79e0666da4c8853deda18a14ebf5819d0d78vboxsync return true;
0dfc79e0666da4c8853deda18a14ebf5819d0d78vboxsync return false;