semeventwait-r0drv-solaris.h revision c58f1213e628a545081c70e26c6b67a841cff880
/* $Id$ */
/** @file
* IPRT - Solaris Ring-0 Driver Helpers for Event Semaphore Waits.
*/
/*
* Copyright (C) 2006-2012 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.
*/
#include "the-solaris-kernel.h"
/** The resolution (nanoseconds) specified when using timeout_generic. */
#define RTR0SEMSOLWAIT_RESOLUTION 50000
/** Disables the cyclic fallback code for old S10 installs - see @bugref{5342}.
* @todo Fixed by @bugref{5595}, can be reenabled after checking out
* CY_HIGH_LEVEL. */
/**
* Solaris semaphore wait structure.
*/
typedef struct RTR0SEMSOLWAIT
{
/** The absolute timeout given as nanoseconds since the start of the
* monotonic clock. */
/** The timeout in nanoseconds relative to the start of the wait. */
/** The native timeout value. */
union
{
/** The timeout (abs lbolt) when fHighRes is false. */
} u;
/** Set if we use high resolution timeouts. */
bool fHighRes;
/** Set if it's an indefinite wait. */
bool fIndefinite;
/** Set if the waiting thread is ready to be woken up.
* Avoids false setrun() calls due to temporary mutex exits. */
bool volatile fWantWakeup;
/** Set if we've already timed out.
* Set by rtR0SemSolWaitDoIt or rtR0SemSolWaitHighResTimeout, read by
* rtR0SemSolWaitHasTimedOut. */
bool volatile fTimedOut;
/** Whether the wait was interrupted. */
bool fInterrupted;
/** Interruptible or uninterruptible wait. */
bool fInterruptible;
/** The thread to wake up. */
/** Cylic timer ID (used by the timeout callback). */
#endif
/** The mutex associated with the condition variable wait. */
void volatile *pvMtx;
/** Pointer to a solaris semaphore wait structure. */
typedef RTR0SEMSOLWAIT *PRTR0SEMSOLWAIT;
/**
* Initializes a wait.
*
* The caller MUST check the wait condition BEFORE calling this function or the
* timeout logic will be flawed.
*
* @returns VINF_SUCCESS or VERR_TIMEOUT.
* @param pWait The wait structure.
* @param fFlags The wait flags.
* @param uTimeout The timeout.
* @param pWaitQueue The wait queue head.
*/
{
/*
* Process the flags and timeout.
*/
if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
{
if (fFlags & RTSEMWAIT_FLAGS_MILLISECS)
: UINT64_MAX;
if (uTimeout == UINT64_MAX)
else
{
if (fFlags & RTSEMWAIT_FLAGS_RELATIVE)
{
if (uTimeout == 0)
return VERR_TIMEOUT;
u64Now = RTTimeSystemNanoTS();
}
else
{
u64Now = RTTimeSystemNanoTS();
return VERR_TIMEOUT;
}
}
}
if (!(fFlags & RTSEMWAIT_FLAGS_INDEFINITE))
{
pWait->fIndefinite = false;
#endif
)
else
{
else
{
}
}
}
if (fFlags & RTSEMWAIT_FLAGS_INDEFINITE)
{
pWait->fIndefinite = true;
}
pWait->fWantWakeup = false;
pWait->fInterrupted = false;
#endif
return VINF_SUCCESS;
}
/**
* Cyclic timeout callback that sets the timeout indicator and wakes up the
* waiting thread.
*
* @param pvUser The wait structure.
*/
static void rtR0SemSolWaitHighResTimeout(void *pvUser)
{
{
/* Enter the mutex here to make sure the thread has gone to sleep
before we wake it up.
Note: Trying to take the cpu_lock here doesn't work. */
{
}
if (fWantWakeup)
}
}
#endif
/**
* Timeout callback that sets the timeout indicator and wakes up the waiting
* thread.
*
* @param pvUser The wait structure.
*/
static void rtR0SemSolWaitTimeout(void *pvUser)
{
{
/* Enter the mutex here to make sure the thread has gone to sleep
before we wake it up. */
if (fWantWakeup)
}
}
/**
* Do the actual wait.
*
* @param pWait The wait structure.
* @param pCnd The condition variable to wait on.
* @param pMtx The mutex related to the condition variable.
* The caller has entered this.
* @param pfState The state variable to check if have changed
* after leaving the mutex (spinlock).
* @param fCurState The current value of @a pfState. We'll return
* without sleeping if @a pfState doesn't hold
* this value after reacquiring the mutex.
*
* @remarks This must be call with the object mutex (spinlock) held.
*/
{
union
{
} u;
/*
* Arm the timeout callback.
*
* We will have to leave the mutex (spinlock) when doing this because S10
* (didn't check S11) will not correctly preserve PIL across calls to
* timeout_generic() - @bugref{5595}. We do it for all timeout methods to
* be on the safe side, the nice sideeffect of which is that it solves the
* lock inversion problem found in @bugref{5342}.
*/
bool fGoToSleep = !fHasTimeout;
if (fHasTimeout)
{
{
if (g_pfnrtR0Sol_timeout_generic != NULL)
#endif
{
/*
* High resolution timeout - arm a high resolution timeout callback
* for waking up the thread at the desired time.
*/
}
else
{
/*
* High resolution timeout - arm a one-shot cyclic for waking up
* the thread at the desired time.
*/
}
#endif
}
else
{
/*
* Normal timeout.
* We're better off with our own callback like on the timeout man page,
* than calling cv_timedwait[_sig]().
*/
}
/*
* Reacquire the mutex and check if the sleep condition still holds and
* that we didn't already time out.
*/
pWait->fWantWakeup = true;
}
/*
* Do the waiting if that's still desirable.
* (rc > 0 - normal wake-up; rc == 0 - interruption; rc == -1 - timeout)
*/
if (fGoToSleep)
{
if (pWait->fInterruptible)
{
if (RT_UNLIKELY(rc <= 0))
{
pWait->fInterrupted = true;
else
}
}
else
}
/*
* Remove the timeout callback. Drop the lock while we're doing that
* to reduce lock contention / deadlocks. Before dropping the lock,
* indicate that the callback shouldn't do anything.
*
* (Too bad we are stuck with the cv_* API here, it's doing a little
* bit too much.)
*/
if (fHasTimeout)
{
pWait->fWantWakeup = false;
{
if (g_pfnrtR0Sol_timeout_generic != NULL)
#endif
else
{
{
}
}
#endif
}
else
}
}
/**
* Checks if a solaris wait was interrupted.
*
* @returns true / false
* @param pWait The wait structure.
* @remarks This shall be called before the first rtR0SemSolWaitDoIt().
*/
{
return pWait->fInterrupted;
}
/**
* Checks if a solaris wait has timed out.
*
* @returns true / false
* @param pWait The wait structure.
*/
{
}
/**
* Deletes a solaris wait.
*
* @param pWait The wait structure.
*/
{
}
/**
* Enters the mutex, unpinning the underlying current thread if contended and
* we're on an interrupt thread.
*
* The unpinning is done to prevent a deadlock, see s this could lead to a
* deadlock (see @bugref{4259} for the full explanation)
*
* @param pMtx The mutex to enter.
*/
{
if (!fAcquired)
{
/*
* Note! This assumes nobody is using the RTThreadPreemptDisable in an
* interrupt context and expects it to work right. The swtch will
* result in a voluntary preemption. To fix this, we would have to
* do our own counting in RTThreadPreemptDisable/Restore like we do
* on systems which doesn't do preemption (OS/2, linux, ...) and
* check whether preemption was disabled via RTThreadPreemptDisable
* or not and only call swtch if RTThreadPreemptDisable wasn't called.
*/
{
preempt();
}
}
}
/**
* Gets the max resolution of the timeout machinery.
*
* @returns Resolution specified in nanoseconds.
*/
{
return g_pfnrtR0Sol_timeout_generic != NULL
: cyclic_getres();
}
#endif /* ___r0drv_solaris_semeventwait_r0drv_solaris_h */