fxspinlock.hpp

Go to the documentation of this file.

/*++
 
Copyright (c) Microsoft Corporation
 
Module Name:
 
    FxSpinLock.hpp
 
Abstract:
 
Author:
 
 
Revision History:
 
--*/
 
#ifndef _FXSPINLOCK_H_
#define _FXSPINLOCK_H_
 
#define FX_SPIN_LOCK_NUM_HISTORY_ENTRIES (10)
 
struct FX_SPIN_LOCK_HISTORY_ENTRY {
    PVOID CallersAddress;
    LARGE_INTEGER AcquiredAtTime;
    LONGLONG LockedDuraction;
};
 
typedef struct FX_SPIN_LOCK_HISTORY_ENTRY *PFX_SPIN_LOCK_HISTORY_ENTRY;
 
struct FX_SPIN_LOCK_HISTORY {
    MxThread  OwningThread;
 
    PFX_SPIN_LOCK_HISTORY_ENTRY CurrentHistory;
 
    FX_SPIN_LOCK_HISTORY_ENTRY History[FX_SPIN_LOCK_NUM_HISTORY_ENTRIES];
};
 
typedef struct FX_SPIN_LOCK_HISTORY *PFX_SPIN_LOCK_HISTORY;
 
class FxSpinLock : public FxObject  {
 
public:
    FxSpinLock(
        __in PFX_DRIVER_GLOBALS FxDriverGlobals,
        __in USHORT ExtraSize
        );
 
 
    __drv_raisesIRQL(DISPATCH_LEVEL)
    __drv_maxIRQL(DISPATCH_LEVEL)
    VOID
    AcquireLock(
        __in PVOID CallersAddress
        );
 
    __drv_requiresIRQL(DISPATCH_LEVEL)
    VOID
    ReleaseLock(
        VOID
        );
 
 
    MdLock*
    GetLock(
        VOID
        )
    {
        return &m_SpinLock.Get();
    }
 
    VOID
    SetInterruptSpinLock(
        VOID
        )
    {
        m_InterruptLock = TRUE;
    }
 
    BOOLEAN
    IsInterruptLock(
        VOID
        )
    {
        return m_InterruptLock;
    }
 
protected:
    PFX_SPIN_LOCK_HISTORY
    GetHistory(
        VOID
        )
    {
        if (GetObjectSize() == WDF_ALIGN_SIZE_UP(sizeof(FxSpinLock),
                                                 MEMORY_ALLOCATION_ALIGNMENT)) {
            return NULL;
        }
        else {
            return WDF_PTR_ADD_OFFSET_TYPE(
                this,
                COMPUTE_RAW_OBJECT_SIZE(sizeof(FxSpinLock)),
                PFX_SPIN_LOCK_HISTORY);
        }
    }
 
protected:
    MxLock m_SpinLock;
 
    KIRQL m_Irql;
 
    //
    // TRUE, this lock is being used to synchronize FxInterrupts.  As such, the
    // caller is not allowed to actually call WDFSPINLOCK APIs on the handle
    // because it would then be acquiring a spinlock at DISPATCH_LEVEL and the
    // interrupt could be attempting to acquire the same lock at a higher IRQL
    // on the same processor.
    //
    BOOLEAN m_InterruptLock;
};
 
#endif // _FXSPINLOCK_H_