timer-r0drv-linux.c revision 0cde281779e97ead3181bbd3b628451fa2b1efe1
/* $Id$ */
/** @file
* IPRT - Timers, Ring-0 Driver, Linux.
*/
/*
* Copyright (C) 2006-2010 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*/
/*******************************************************************************
* Header Files *
*******************************************************************************/
#include "the-linux-kernel.h"
#include <iprt/spinlock.h>
/** @def RTTIMER_LINUX_HAVE_HRTIMER
* Whether the kernel support high resolution timers (Linux kernel versions
* 2.6.28 and later (hrtimer_add_expires_ns()). */
# define RTTIMER_LINUX_HAVE_HRTIMER
#endif
/** @def RTTIMER_LINUX_ONLY_HRTIMER
* Whether to use high resolution timers for everything or not. Implies
* RTTIMER_LINUX_WITH_HRTIMER. */
#if !defined(RTTIMER_LINUX_ONLY_HRTIMER) \
&& defined(RTTIMER_LINUX_HAVE_HRTIMER) \
&& 0 /* currently disabled */
# define RTTIMER_LINUX_ONLY_HRTIMER
#endif
/* This check must match the ktime usage in rtTimeGetSystemNanoTS() / time-r0drv-linux.c. */
#if defined(RTTIMER_LINUX_ONLY_HRTIMER) \
&& !defined(RTTIMER_LINUX_HAVE_HRTIMER)
# error "RTTIMER_LINUX_ONLY_HRTIMER requires 2.6.28 or later, sorry."
#endif
/** @def RTTIMER_LINUX_WITH_HRTIMER
* Whether to use high resolution timers. */
#if !defined(RTTIMER_LINUX_WITH_HRTIMER) \
&& defined(RTTIMER_LINUX_HAVE_HRTIMER)
# define RTTIMER_LINUX_WITH_HRTIMER
#endif
# define mod_timer_pinned mod_timer
# define HRTIMER_MODE_ABS_PINNED HRTIMER_MODE_ABS
#endif
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* Timer state machine.
*
* This is used to try handle the issues with MP events and
* timers that runs on all CPUs. It's relatively nasty :-/
*/
typedef enum RTTIMERLNXSTATE
{
/** Stopped. */
/** Transient state; next ACTIVE. */
/** Transient state; next ACTIVE. (not really necessary) */
/** Active. */
/** Transient state; next STOPPED. */
/** Transient state; next STOPPED. */
/** The usual 32-bit hack. */
RTTIMERLNXSTATE_32BIT_HACK = 0x7fffffff
/**
* A Linux sub-timer.
*/
typedef struct RTTIMERLNXSUBTIMER
{
/** Timer specific data. */
union
{
#if defined(RTTIMER_LINUX_WITH_HRTIMER)
/** High resolution timer. */
struct
{
/** The linux timer structure. */
} Hr;
#endif
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
/** Standard timer. */
struct
{
/** The linux timer structure. */
struct timer_list LnxTimer;
/** The start of the current run (ns).
* This is used to calculate when the timer ought to fire the next time. */
/** The start of the current run (ns).
* This is used to calculate when the timer ought to fire the next time. */
/** The u64NextTS in jiffies. */
unsigned long ulNextJiffies;
} Std;
#endif
} u;
/** The current tick number (since u.Std.u64StartTS). */
/** Pointer to the parent timer. */
/** The current sub-timer state. */
RTTIMERLNXSTATE volatile enmState;
/** Pointer to a linux sub-timer. */
typedef RTTIMERLNXSUBTIMER *PRTTIMERLNXSUBTIMER;
/**
* The internal representation of an Linux timer handle.
*/
typedef struct RTTIMER
{
/** Magic.
* This is RTTIMER_MAGIC, but changes to something else before the timer
* is destroyed to indicate clearly that thread should exit. */
/** Spinlock synchronizing the fSuspended and MP event handling.
* This is NIL_RTSPINLOCK if cCpus == 1. */
/** Flag indicating that the timer is suspended. */
bool volatile fSuspended;
/** Whether the timer must run on one specific CPU or not. */
bool fSpecificCpu;
#ifdef CONFIG_SMP
/** Whether the timer must run on all CPUs or not. */
bool fAllCpus;
#endif /* else: All -> specific on non-SMP kernels */
/** Whether it is a high resolution timer or a standard one. */
bool fHighRes;
/** The id of the CPU it must run on if fSpecificCpu is set. */
/** The number of CPUs this timer should run on. */
/** Callback. */
/** User argument. */
void *pvUser;
/** The timer interval. 0 if one-shot. */
uint64_t volatile u64NanoInterval;
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
/** This is set to the number of jiffies between ticks if the interval is
* an exact number of jiffies. */
unsigned long cJiffies;
#endif
/** Sub-timers.
* Normally there is just one, but for RTTIMER_FLAGS_CPU_ALL this will contain
* an entry for all possible cpus. In that case the index will be the same as
* for the RTCpuSet. */
} RTTIMER;
/**
* A rtTimerLinuxStartOnCpu and rtTimerLinuxStartOnCpu argument package.
*/
typedef struct RTTIMERLINUXSTARTONCPUARGS
{
/** The current time (RTTimeNanoTS). */
/** When to start firing (delta). */
/** Pointer to a rtTimerLinuxStartOnCpu argument package. */
/**
* Sets the state.
*/
DECLINLINE(void) rtTimerLnxSetState(RTTIMERLNXSTATE volatile *penmState, RTTIMERLNXSTATE enmNewState)
{
}
/**
* Sets the state if it has a certain value.
*
* @return true if xchg was done.
* @return false if xchg wasn't done.
*/
DECLINLINE(bool) rtTimerLnxCmpXchgState(RTTIMERLNXSTATE volatile *penmState, RTTIMERLNXSTATE enmNewState, RTTIMERLNXSTATE enmCurState)
{
}
/**
* Gets the state.
*/
{
}
#ifdef RTTIMER_LINUX_WITH_HRTIMER
/**
* Converts a nano second time stamp to ktime_t.
*
* ASSUMES RTTimeNanoTS() is implemented using ktime_get_ts().
*
* @returns ktime_t.
* @param cNanoSecs Nanoseconds.
*/
{
/* With some luck the compiler optimizes the division out of this... (Bet it doesn't.) */
}
/**
* Converts ktime_t to a nano second time stamp.
*
* ASSUMES RTTimeNanoTS() is implemented using ktime_get_ts().
*
* @returns nano second time stamp.
* @param Kt ktime_t.
*/
{
return ktime_to_ns(Kt);
}
#endif /* RTTIMER_LINUX_WITH_HRTIMER */
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
/**
* Converts a nano second interval to jiffies.
*
* @returns Jiffies.
* @param cNanoSecs Nanoseconds.
*/
{
/* this can be made even better... */
return MAX_JIFFY_OFFSET;
# if ARCH_BITS == 32
# endif
}
#endif /* !RTTIMER_LINUX_ONLY_HRTIMER */
/**
* Starts a sub-timer (RTTimerStart).
*
* @param pSubTimer The sub-timer to start.
* @param u64Now The current timestamp (RTTimeNanoTS()).
* @param u64First The interval from u64Now to the first time the timer should fire.
* @param fPinned true = timer pinned to a specific CPU,
* false = timer can migrate between CPUs
* @param fHighRes Whether the user requested a high resolution timer or not.
*/
static void rtTimerLnxStartSubTimer(PRTTIMERLNXSUBTIMER pSubTimer, uint64_t u64Now, uint64_t u64First,
{
/*
* Calc when it should start firing.
*/
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
if (fHighRes)
{
}
#endif
#ifdef RTTIMER_LINUX_WITH_HRTIMER
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
if (fHighRes)
# endif
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
else
# endif
#endif
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
{
# ifdef CONFIG_SMP
if (fPinned)
else
# endif
}
#endif
}
/**
* Stops a sub-timer (RTTimerStart and rtTimerLinuxMpEvent()).
*
* @param pSubTimer The sub-timer.
*/
{
#ifdef RTTIMER_LINUX_WITH_HRTIMER
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
# endif
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
else
# endif
#endif
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
{
}
#endif
}
#ifdef RTTIMER_LINUX_WITH_HRTIMER
/**
* Timer callback function for high resolution timers.
*
* @returns HRTIMER_NORESTART or HRTIMER_RESTART depending on whether it's a
* one-shot or interval timer.
* @param pHrTimer Pointer to the sub-timer structure.
*/
{
enum hrtimer_restart rc;
/*
* Don't call the handler if the timer has been suspended.
* Also, when running on all CPUS, make sure we don't call out twice
* on a CPU because of timer migration.
*
* For the specific cpu case, we're just ignoring timer migration for now... (bad)
*/
#ifdef CONFIG_SMP
#endif
)
{
}
else if (!pTimer->u64NanoInterval)
{
/*
* One shot timer, stop it before dispatching it.
*/
}
else
{
/*
* Run the timer. Update the timer after calling the method.
*/
/** @todo Check reference counting wrt. RTTimerDestroy from the
* callback? */
{
}
else
}
return rc;
}
#endif /* RTTIMER_LINUX_ONLY_HRTIMER */
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
/**
* Timer callback function for standard timers.
*
* @param ulUser Address of the sub-timer structure.
*/
static void rtTimerLinuxStdCallback(unsigned long ulUser)
{
/*
* Don't call the handler if the timer has been suspended.
* Also, when running on all CPUS, make sure we don't call out twice
* on a CPU because of timer migration.
*
* For the specific cpu case, we're just ignoring timer migration for now... (bad)
*/
#ifdef CONFIG_SMP
#endif
)
else if (!pTimer->u64NanoInterval)
{
/*
* One shot timer, stop it before dispatching it.
*/
}
else
{
/*
* Interval timer, calculate the next timeout and re-arm it.
*
* The first time around, we'll re-adjust the u.Std.u64StartTS to
* try prevent some jittering if we were started at a bad time.
* This may of course backfire with highres timers...
*
* Note! u64NanoInterval won't change for standard timers.
*/
{
}
{
/* Prevent overflows when the jiffies counter wraps around.
* Special thanks to Ken Preslan for helping debugging! */
{
}
}
else
{
pSubTimer->u.Std.ulNextJiffies = jiffies + rtTimerLnxNanoToJiffies(pSubTimer->u.Std.u64NextTS - u64NanoTS);
}
# ifdef CONFIG_SMP
else
# endif
/*
* Run the timer.
*/
}
}
#endif /* !RTTIMER_LINUX_ONLY_HRTIMER */
#ifdef CONFIG_SMP
/**
* Per-cpu callback function (RTMpOnAll/RTMpOnSpecific).
*
* @param idCpu The current CPU.
* @param pvUser1 Pointer to the timer.
* @param pvUser2 Pointer to the argument structure.
*/
{
rtTimerLnxStartSubTimer(&pTimer->aSubTimers[idCpu], pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
}
/**
* Worker for RTTimerStart() that takes care of the ugly bits.
*
* @returns RTTimerStart() return value.
* @param pTimer The timer.
* @param pArgs The argument structure.
*/
{
int rc2;
/*
* Prepare all the sub-timers for the startup and then flag the timer
* as a whole as non-suspended, make sure we get them all before
* clearing fSuspended as the MP handler will be waiting on this
* should something happen while we're looping.
*/
do
{
{
}
/*
* Start them (can't find any exported function that allows me to
* do this without the cross calls).
*/
/*
* Reset the sub-timers who didn't start up (ALL CPUs case).
* CPUs that comes online between the
*/
if (rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState, RTTIMERLNXSTATE_STOPPED, RTTIMERLNXSTATE_STARTING))
{
/** @todo very odd case for a rainy day. Cpus that temporarily went offline while
* we were between calls needs to nudged as the MP handler will ignore events for
* them because of the STARTING state. This is an extremely unlikely case - not that
* that means anything in my experience... ;-) */
}
return VINF_SUCCESS;
}
/**
* Worker for RTTimerStop() that takes care of the ugly SMP bits.
*
* @returns RTTimerStop() return value.
* @param pTimer The timer (valid).
*/
{
/*
* Mark the timer as suspended and flag all timers as stopping, except
* for those being stopped by an MP event.
*/
{
do
{
if ( enmState == RTTIMERLNXSTATE_STOPPED
break;
} while (!rtTimerLnxCmpXchgState(&pTimer->aSubTimers[iCpu].enmState, RTTIMERLNXSTATE_STOPPING, enmState));
}
/*
* Do the actual stopping. Fortunately, this doesn't require any IPIs.
* Unfortunately it cannot be done synchronously from within the spinlock,
* because we might end up in an active waiting for a handler to complete.
*/
return VINF_SUCCESS;
}
/**
* Per-cpu callback function (RTMpOnSpecific) used by rtTimerLinuxMpEvent()
* to start a sub-timer on a cpu that just have come online.
*
* @param idCpu The current CPU.
* @param pvUser1 Pointer to the timer.
* @param pvUser2 Pointer to the argument structure.
*/
{
/*
* We have to be kind of careful here as we might be racing RTTimerStop
*/
if ( hSpinlock != NIL_RTSPINLOCK
{
{
/* We're sane and the timer is not suspended yet. */
if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STARTING, RTTIMERLNXSTATE_STOPPED))
rtTimerLnxStartSubTimer(pSubTimer, pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
}
}
}
/**
* MP event notification callback.
*
* @param enmEvent The event.
* @param idCpu The cpu it applies to.
* @param pvUser The timer.
*/
{
/*
* Some initial paranoia.
*/
return;
if (hSpinlock == NIL_RTSPINLOCK)
return;
/* Is it active? */
{
switch (enmEvent)
{
/*
* Try do it without leaving the spin lock, but if we have to, retake it
* when we're on the right cpu.
*/
case RTMPEVENT_ONLINE:
if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STARTING, RTTIMERLNXSTATE_STOPPED))
{
else
{
return; /* we've left the spinlock */
}
}
break;
/*
* The CPU is (going) offline, make sure the sub-timer is stopped.
*
* Linux will migrate it to a different CPU, but we don't want this. The
* timer function is checking for this.
*/
case RTMPEVENT_OFFLINE:
if (rtTimerLnxCmpXchgState(&pSubTimer->enmState, RTTIMERLNXSTATE_MP_STOPPING, RTTIMERLNXSTATE_ACTIVE))
{
return; /* we've left the spinlock */
}
break;
}
}
}
#endif /* CONFIG_SMP */
/**
* Callback function use by RTTimerStart via RTMpOnSpecific to start
* a timer running on a specific CPU.
*
* @param idCpu The current CPU.
* @param pvUser1 Pointer to the timer.
* @param pvUser2 Pointer to the argument structure.
*/
{
rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], pArgs->u64Now, pArgs->u64First, true /*fPinned*/, pTimer->fHighRes);
}
{
int rc2;
/*
* Validate.
*/
return VERR_TIMER_ACTIVE;
#ifdef CONFIG_SMP
/*
* Omnit timer?
*/
#endif
/*
* Simple timer - Pretty straight forward.
*/
if (!pTimer->fSpecificCpu)
{
rtTimerLnxStartSubTimer(&pTimer->aSubTimers[0], Args.u64Now, Args.u64First, false /*fPinned*/, pTimer->fHighRes);
}
else
{
if (RT_FAILURE(rc2))
{
/* Suspend it, the cpu id is probably invalid or offline. */
return rc2;
}
}
return VINF_SUCCESS;
}
{
/*
* Validate.
*/
return VERR_TIMER_SUSPENDED;
#ifdef CONFIG_SMP
/*
* Omni timer?
*/
return rtTimerLnxStopAll(pTimer);
#endif
/*
* Simple timer.
*/
return VINF_SUCCESS;
}
{
int rc = VINF_SUCCESS;
/*
* Validate.
*/
/*
* Make the change.
*/
#ifdef RTTIMER_LINUX_WITH_HRTIMER
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
# endif
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
else
# endif
#endif
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
#endif
return rc;
}
{
/* It's ok to pass NULL pointer. */
return VINF_SUCCESS;
/*
* Remove the MP notifications first because it'll reduce the risk of
* us overtaking any MP event that might theoretically be racing us here.
*/
#ifdef CONFIG_SMP
&& hSpinlock != NIL_RTSPINLOCK)
{
}
#endif /* CONFIG_SMP */
/*
* Stop the timer if it's running.
*/
/*
* Uninitialize the structure and free the associated resources.
* The spinlock goes last.
*/
if (hSpinlock != NIL_RTSPINLOCK)
return VINF_SUCCESS;
}
RTDECL(int) RTTimerCreateEx(PRTTIMER *ppTimer, uint64_t u64NanoInterval, uint32_t fFlags, PFNRTTIMER pfnTimer, void *pvUser)
{
unsigned cCpus;
/*
* Validate flags.
*/
if (!RTTIMER_FLAGS_ARE_VALID(fFlags))
return VERR_INVALID_PARAMETER;
if ( (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
return VERR_CPU_NOT_FOUND;
/*
* Allocate the timer handler.
*/
cCpus = 1;
#ifdef CONFIG_SMP
{
Assert(cCpus <= RTCPUSET_MAX_CPUS); /* On linux we have a 1:1 relationship between cpuid and set index. */
AssertReturn(u64NanoInterval, VERR_NOT_IMPLEMENTED); /* We don't implement single shot on all cpus, sorry. */
}
#endif
if (!pTimer)
return VERR_NO_MEMORY;
/*
* Initialize it.
*/
pTimer->fSuspended = true;
#ifdef CONFIG_SMP
pTimer->fSpecificCpu = (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC) && (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL;
pTimer->idCpu = pTimer->fSpecificCpu ? RTMpCpuIdFromSetIndex(fFlags & RTTIMER_FLAGS_CPU_MASK) : NIL_RTCPUID;
#else
#endif
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
#endif
{
#ifdef RTTIMER_LINUX_WITH_HRTIMER
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
# endif
{
}
# ifndef RTTIMER_LINUX_ONLY_HRTIMER
else
# endif
#endif
#ifndef RTTIMER_LINUX_ONLY_HRTIMER
{
}
#endif
}
#ifdef CONFIG_SMP
/*
* If this is running on ALL cpus, we'll have to register a callback
*/
if (cCpus > 1)
{
if (RT_SUCCESS(rc))
else
if (RT_FAILURE(rc))
{
return rc;
}
}
#endif /* CONFIG_SMP */
return VINF_SUCCESS;
}
{
#ifdef RTTIMER_LINUX_ONLY_HRTIMER
/** @todo Not sure if this is what we want or not... Add new API for
* querying the resolution of the high res timers? */
if (!rc)
{
}
#endif
}
{
return VERR_NOT_SUPPORTED;
}
{
return VERR_NOT_SUPPORTED;
}
RTDECL(bool) RTTimerCanDoHighResolution(void)
{
#ifdef RTTIMER_LINUX_WITH_HRTIMER
return true;
#else
return false;
#endif
}