|
|
// TITLE("Fast Mutex Support")//++//// Module Name://// fmutex.s//// Abstract://// This module implements the code necessary to acquire and release fast// mutxes.////// Author://// William K. Cheung (wcheung) 02-Oct-1995//// Environment://// Kernel mode only.//// Revision History://// 08-Feb-96 Updated to EAS2.1////--
#include "ksia64.h"
.file "fmutex.s"
PublicFunction(KeWaitForSingleObject) PublicFunction(KeSetEventBoostPriority) PublicFunction(KiCheckForSoftwareInterrupt)
//++//// VOID// ExAcquireFastMutex (// IN PFAST_MUTEX FastMutex// )//// Routine Description://// This function acquires ownership of a fast mutex and raises IRQL to// APC Level. Must be called at IRQL < DISPATCH_LEVEL.//// Arguments://// FastMutex (a0) - Supplies a pointer to a fast mutex.//// Return Value://// None.////--
//// t0 -- Original value of Fmutex.FmCount// t1 -- Address of Fmutex.FmCount// t2 -- Address of Fmutex.FmOldIrql// t3 -- Address of KiPcr// t4 -- Address of Fmutex.FmContention// t8 -- Address of KiPcr.PcCurrentThread// r35 -- old IRQL//// t5 -- temp//
NESTED_ENTRY(ExAcquireFastMutex)
.regstk 1, 4, 5, 0 .prologue 0xC, savedpfs
alloc savedpfs = ar.pfs, 1, 4, 5, 0 add loc3 = FmOwner, a0 mov savedbrp = brp GET_IRQL (loc2) // Get old IRQL
PROLOGUE_END
mov t4 = APC_LEVEL add t1 = FmCount, a0 add t2 = FmOldIrql, a0 ;;
SET_IRQL (t4) // change IRQL to APC_LEVEL ;;
// // synchronize subsequent reads //
fetchadd4.acq t0 = [t1], -1 // decrement mutex count add t4 = FmContention, a0 add out0 = FmEvent, a0
mov out1 = Executive // set reason for wait mov out2 = KernelMode // set mode of wait ;;
cmp4.le pt7, pt8 = t0, zero // if le, mutex acq failed mov out3 = FALSE // set nonalertable wait mov out4 = zero // set NULL timeout pointer ;;
(pt7) ld4 t5 = [t4] // load contention count (pt8) st8 [loc3] = sp // Save the SP so we can identify the owner. (pt8) st4 [t2] = loc2 // save old IRQL (pt8) br.ret.sptk.clr brp // return ;;
Eafm10:
(pt7) add t5 = 1, t5 // inc contention count ;;
st4 [t4] = t5 // save contention count br.call.sptk.many brp = KeWaitForSingleObject
add t2 = FmOldIrql, a0 mov ar.pfs = savedpfs // restore pfs mov brp = savedbrp // restore brp ;;
st4 [t2] = loc2 // save old IRQL st8 [loc3] = sp // Save the SP so we can identify the owner. br.ret.sptk.clr brp // return
NESTED_EXIT(ExAcquireFastMutex)
//++//// VOID// ExReleaseFastMutex (// IN PFAST_MUTEX FastMutex// )//// Routine Description://// This function releases ownership to a fast mutex and lowers IRQL to// its previous level.//// Arguments://// FastMutex (a0) - Supplies a pointer to a fast mutex.//// Return Value://// None.////--
NESTED_ENTRY(ExReleaseFastMutex) NESTED_SETUP(1, 3, 2, 0) add t1 = FmCount, a0
PROLOGUE_END
//// Increment mutex count and release waiter if contention.//
// // use release semantics to synchronize all previous writes // add t2 = FmOldIrql, a0 ;;
ld4 loc2 = [t2] // get old IRQL before releasing lock fetchadd4.rel t9 = [t1], 1 // increment mutex count add out0 = FmEvent, a0 ;;
cmp4.eq pt1, pt0 = zero, t9 // if eq, no waiter mov out1 = zero (pt0) br.call.spnt.many brp = KeSetEventBoostPriority ;;
LOWER_IRQL (loc2) NESTED_RETURN
NESTED_EXIT(ExReleaseFastMutex)
//++//// BOOLEAN// ExTryToAcquireFastMutex (// IN PFAST_MUTEX FastMutex// )//// Routine Description://// This function attempts to acquire ownership of a fast mutex, and if// successful, raises IRQL to APC level.//// Arguments://// FastMutex (a0) - Supplies a pointer to a fast mutex.//// Return Value://// If the fast mutex was successfully acquired, then a value of TRUE// is returned as the function value. Otherwise, a valye of FALSE is// returned.////--
LEAF_ENTRY(ExTryToAcquireFastMutex)
mov t4 = APC_LEVEL add t1 = FmCount, a0 add t2 = FmOldIrql, a0 add t6 = FmOwner, a0 GET_IRQL (t0) // get old IRQL SET_IRQL (t4) // change IRQL to APC_LEVEL ;;
ld4 t4 = [t1] ;;
mov ar.ccv = t4 cmp4.le pt8, pt7 = t4, zero // if le, mutex acq failed
add t5 = -1, t4 mov v0 = TRUE // return TRUE by default (pt8) br.spnt.few Ettafm10 ;;
// // use acquire semantics to sychronize subsequent reads //
cmpxchg4.acq t4 = [t1], t5, ar.ccv ;;
cmp4.le pt8, pt7 = t4, zero // if le, mutex acq failed ;;
Ettafm10:
PSET_IRQL (pt8, t0) // restore IRQL (pt7) st4 [t2] = t0 // save old IRQL (pt8) mov v0 = FALSE // return FALSE (pt7) st8 [t6] = sp // Save the SP so we can identify the owner. br.ret.sptk.clr brp // return
LEAF_EXIT(ExTryToAcquireFastMutex)
//++//// VOID// ExAcquireFastMutexUnsafe (// IN PFAST_MUTEX FastMutex// )//// Routine Description://// This function acquires ownership of a fast mutex, but does not raise// IRQL to APC Level.//// Arguments://// FastMutex (a0) - Supplies a pointer to a fast mutex.//// Return Value://// None.////--
NESTED_ENTRY(ExAcquireFastMutexUnsafe)
NESTED_SETUP(1, 3, 5, 0) add t1 = FmCount, a0 ;;
PROLOGUE_END
// // Use acquire semantics to synchronize subsequent reads //
fetchadd4.acq t0 = [t1], -1 // decrement mutex count add out0 = FmEvent, a0
add t3 = FmContention, a0 add loc2 = FmOwner, a0 mov out1 = Executive // set reason for wait mov out2 = KernelMode // set mode of wait ;;
cmp4.le p0, pt8 = t0, zero // if le, contention mov out3 = FALSE // set nonalertable wait ;;
(pt8) st8 [loc2] = sp // Save the SP so we can identify the owner. (pt8) br.ret.sptk.clr brp // return
//// Increment the contention count and then call KeWaitForSingleObject().// The outgoing arguments have been set up ahead of time.//
ld4 t4 = [t3] // get contention count ;;
add t4 = 1, t4 // increment contention count mov out4 = 0 // set NULL timeout pointer ;;
st4 [t3] = t4 // save contention count br.call.sptk.many brp = KeWaitForSingleObject mov ar.pfs = savedpfs // restore pfs mov brp = savedbrp // restore return link st8 [loc2] = sp // Save the sp of the owner br.ret.sptk.clr brp // return
NESTED_EXIT(ExAcquireFastMutexUnsafe)
//++//// VOID// ExReleaseFastMutexUnsafe (// IN PFAST_MUTEX FastMutex// )//// Routine Description://// This function releases ownership to a fast mutex, and does not// restore IRQL to its previous level.//// Arguments://// FastMutex (a0) - Supplies a pointer to a fast mutex.//// Return Value://// None.////--
NESTED_ENTRY(ExReleaseFastMutexUnsafe) NESTED_SETUP(1, 2, 2, 0) add t1 = FmCount, a0 ;;
PROLOGUE_END
//// Increment mutex count and release waiter if contention.//
// // Use release semantics to syncrhonize all previous writes // before the mutext is released. //
fetchadd4.rel t9 = [t1], 1 // increment mutex count ;;
add out0 = FmEvent, a0 cmp4.eq pt7, pt8 = zero, t9 // if eq, no waiter
add out1 = zero, zero (pt7) br.ret.sptk.clr brp // return (pt8) br.call.spnt.many brp = KeSetEventBoostPriority
mov ar.pfs = savedpfs mov brp = savedbrp br.ret.sptk.clr brp // return
NESTED_EXIT(ExReleaseFastMutexUnsafe)
//++//// BOOLEAN// ExTryToAcquireFastMutexUnsafe (// IN PFAST_MUTEX FastMutex// )//// Routine Description://// This function attempts to acquire ownership of a fast mutex, and if// successful, does not raise IRQL to APC level.//// Arguments://// FastMutex (a0) - Supplies a pointer to a fast mutex.//// Return Value://// If the fast mutex was successfully acquired, then a value of TRUE// is returned as the function value. Otherwise, a valye of FALSE is// returned.////--
#if 0
LEAF_ENTRY(ExTryToAcquireFastMutexUnsafe)
LEAF_EXIT(ExTryToAcquireFastMutexUnsafe)#endif
|
