ke.h File Reference

Go to the source code of this file.

Classes
struct	_CONTEXT
struct	_KPCR

Macros
#define	PASSIVE_LEVEL   0
#define	LOW_LEVEL   0
#define	APC_LEVEL   1
#define	DISPATCH_LEVEL   2
#define	CLOCK_LEVEL   13
#define	IPI_LEVEL   14
#define	DRS_LEVEL   14
#define	POWER_LEVEL   14
#define	PROFILE_LEVEL   15
#define	HIGH_LEVEL   15
#define	KIP0PCRADDRESS   0xFFDFF000
#define	KI_USER_SHARED_DATA   0xFFFF9000
#define	SharedUserData   ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA)
#define	PAGE_SIZE   0x1000
#define	PAGE_SHIFT   12L
#define	MemoryBarrier()   __dmb(_ARM_BARRIER_SY)
#define	PreFetchCacheLine(l, a)   __prefetch((const void *) (a))
#define	PrefetchForWrite(p)   __prefetch((const void *) (p))
#define	ReadForWriteAccess(p)   (*(p))
#define	KeMemoryBarrierWithoutFence()   _ReadWriteBarrier()
#define	KeLowerIrql(a)   KfLowerIrql(a)
#define	KeRaiseIrql(a, b)   *(b) = KfRaiseIrql(a)
#define	KeAcquireSpinLock(a, b)   *(b) = KfAcquireSpinLock(a)
#define	KeReleaseSpinLock(a, b)   KfReleaseSpinLock(a,b)
#define	KeAcquireSpinLockAtDpcLevel(SpinLock)   KefAcquireSpinLockAtDpcLevel(SpinLock)
#define	KeReleaseSpinLockFromDpcLevel(SpinLock)   KefReleaseSpinLockFromDpcLevel(SpinLock)
#define	DbgRaiseAssertionFailure()   __emit(0xdefc)
#define	KeQueryTickCount(CurrentCount)   _KeQueryTickCount(CurrentCount)
#define	CP15_PMSELR   15, 0, 9, 12, 5 /* Event Counter Selection Register */
#define	CP15_PMXEVCNTR   15, 0, 9, 13, 2 /* Event Count Register */
#define	CP15_TPIDRURW   15, 0, 13, 0, 2 /* Software Thread ID Register, UsRW */
#define	CP15_TPIDRURO   15, 0, 13, 0, 3 /* Software Thread ID Register, UsRO */
#define	CP15_TPIDRPRW   15, 0, 13, 0, 4 /* Software Thread ID Register, Kernel */
#define	PAUSE_PROCESSOR   __yield();
#define	KERNEL_STACK_SIZE   0x3000
#define	KERNEL_LARGE_STACK_SIZE   0xF000
#define	KERNEL_LARGE_STACK_COMMIT   KERNEL_STACK_SIZE
#define	KERNEL_MCA_EXCEPTION_STACK_SIZE   0x2000
#define	EXCEPTION_READ_FAULT   0
#define	EXCEPTION_WRITE_FAULT   1
#define	EXCEPTION_EXECUTE_FAULT   8
#define	CONTEXT_ARM   0x200000L
#define	CONTEXT_CONTROL   (CONTEXT_ARM | 0x00000001L)
#define	CONTEXT_INTEGER   (CONTEXT_ARM | 0x00000002L)
#define	CONTEXT_FLOATING_POINT   (CONTEXT_ARM | 0x00000004L)
#define	CONTEXT_DEBUG_REGISTERS   (CONTEXT_ARM | 0x00000008L)
#define	CONTEXT_FULL   (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT)
#define	ARM_MAX_BREAKPOINTS   8
#define	ARM_MAX_WATCHPOINTS   1
#define	PCR_MINOR_VERSION   1
#define	PCR_MAJOR_VERSION   1
#define	CP15_PCR_RESERVED_MASK   0xFFF
#define	KIPCR()   (((ULONG_PTR)_MoveFromCoprocessor(CP15_TPIDRPRW)) & ~CP15_PCR_RESERVED_MASK)

Typedefs
typedef struct _CONTEXT	CONTEXT
typedef struct _KPCR	KPCR
typedef struct _KPCR *	PKPCR

Functions
	$if (_WDMDDK_) typedef struct _KFLOATING_SAVE
FORCEINLINE VOID	YieldProcessor (VOID)
FORCEINLINE VOID	KeMemoryBarrier (VOID)
	_IRQL_requires_max_ (HIGH_LEVEL) _IRQL_saves_ NTHALAPI KIRQL NTAPI KeGetCurrentIrql(VOID)
	_IRQL_requires_max_ (DISPATCH_LEVEL) _IRQL_saves_ _IRQL_raises_(DISPATCH_LEVEL) NTHALAPI KIRQL NTAPI KeRaiseIrqlToDpcLevel(VOID)
NTHALAPI KIRQL NTAPI	KeRaiseIrqlToSynchLevel (VOID)
_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock	_IRQL_requires_ (DISPATCH_LEVEL) NTHALAPI VOID FASTCALL KfReleaseSpinLock(_Inout_ PKSPIN_LOCK SpinLock
_Requires_lock_not_held_ SpinLock _Acquires_lock_ SpinLock	_IRQL_requires_min_ (DISPATCH_LEVEL) NTKERNELAPI VOID FASTCALL KefAcquireSpinLockAtDpcLevel(_Inout_ PKSPIN_LOCK SpinLock)
NTSYSAPI PKTHREAD NTAPI	KeGetCurrentThread (VOID)
	_Always_ (_Post_satisfies_(return<=0)) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _Kernel_float_saved_ _At_(*FloatSave
	_Kernel_requires_resource_not_held_ (FloatState) _Kernel_acquires_resource_(FloatState)) FORCEINLINE NTSTATUS KeSaveFloatingPointState(_Out_ PKFLOATING_SAVE FloatSave)
	_Success_ (1) _Kernel_float_restored_ _At_(*FloatSave
	_Kernel_requires_resource_held_ (FloatState) _Kernel_releases_resource_(FloatState)) FORCEINLINE NTSTATUS KeRestoreFloatingPointState(_In_ PKFLOATING_SAVE FloatSave)
VOID	KeFlushIoBuffers (_In_ PMDL Mdl, _In_ BOOLEAN ReadOperation, _In_ BOOLEAN DmaOperation)
FORCEINLINE VOID	_KeQueryTickCount (OUT PLARGE_INTEGER CurrentCount)
	$endif (_WDMDDK_) $if(_NTDDK_) typedef struct _NEON128 == *HashTable
FORCEINLINE PKPCR	KeGetPcr (VOID)
FORCEINLINE ULONG	KeGetCurrentProcessorNumber (VOID)

Variables
	KFLOATING_SAVE
*	PKFLOATING_SAVE
NTKERNELAPI volatile KSYSTEM_TIME	KeTickCount
_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _In_ _IRQL_restores_ KIRQL	NewIrql
	NEON128
*	PNEON128

Macro Definition Documentation

APC_LEVEL

#define APC_LEVEL   1

ARM_MAX_BREAKPOINTS

#define ARM_MAX_BREAKPOINTS   8

Definition at line 231 of file ke.h.

ARM_MAX_WATCHPOINTS

#define ARM_MAX_WATCHPOINTS   1

Definition at line 232 of file ke.h.

CLOCK_LEVEL

#define CLOCK_LEVEL   13

CONTEXT_ARM

#define CONTEXT_ARM   0x200000L

CONTEXT_CONTROL

#define CONTEXT_CONTROL   (CONTEXT_ARM | 0x00000001L)

CONTEXT_DEBUG_REGISTERS

#define CONTEXT_DEBUG_REGISTERS   (CONTEXT_ARM | 0x00000008L)

CONTEXT_FLOATING_POINT

#define CONTEXT_FLOATING_POINT   (CONTEXT_ARM | 0x00000004L)

CONTEXT_FULL

#define CONTEXT_FULL   (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_FLOATING_POINT)

CONTEXT_INTEGER

#define CONTEXT_INTEGER   (CONTEXT_ARM | 0x00000002L)

CP15_PCR_RESERVED_MASK

#define CP15_PCR_RESERVED_MASK   0xFFF

Definition at line 336 of file ke.h.

CP15_PMSELR

#define CP15_PMSELR   15, 0, 9, 12, 5 /* Event Counter Selection Register */

Definition at line 196 of file ke.h.

CP15_PMXEVCNTR

#define CP15_PMXEVCNTR   15, 0, 9, 13, 2 /* Event Count Register */

Definition at line 197 of file ke.h.

CP15_TPIDRPRW

#define CP15_TPIDRPRW   15, 0, 13, 0, 4 /* Software Thread ID Register, Kernel */

Definition at line 200 of file ke.h.

CP15_TPIDRURO

#define CP15_TPIDRURO   15, 0, 13, 0, 3 /* Software Thread ID Register, UsRO */

Definition at line 199 of file ke.h.

CP15_TPIDRURW

#define CP15_TPIDRURW   15, 0, 13, 0, 2 /* Software Thread ID Register, UsRW */

Definition at line 198 of file ke.h.

DbgRaiseAssertionFailure

#define DbgRaiseAssertionFailure

(

)

__emit(0xdefc)

Definition at line 174 of file ke.h.

DISPATCH_LEVEL

#define DISPATCH_LEVEL   2

DRS_LEVEL

#define DRS_LEVEL   14

EXCEPTION_EXECUTE_FAULT

#define EXCEPTION_EXECUTE_FAULT   8

EXCEPTION_READ_FAULT

#define EXCEPTION_READ_FAULT   0

EXCEPTION_WRITE_FAULT

#define EXCEPTION_WRITE_FAULT   1

HIGH_LEVEL

#define HIGH_LEVEL   15

IPI_LEVEL

#define IPI_LEVEL   14

KeAcquireSpinLock

#define KeAcquireSpinLock	(		a,
			b
	)		*(b) = KfAcquireSpinLock(a)

Definition at line 104 of file ke.h.

KeAcquireSpinLockAtDpcLevel

#define KeAcquireSpinLockAtDpcLevel

(

SpinLock

)

KefAcquireSpinLockAtDpcLevel(SpinLock)

Definition at line 125 of file ke.h.

KeLowerIrql

#define KeLowerIrql

(

a

)

KfLowerIrql(a)

Definition at line 69 of file ke.h.

KeMemoryBarrierWithoutFence

#define KeMemoryBarrierWithoutFence

(

)

_ReadWriteBarrier()

Definition at line 53 of file ke.h.

KeQueryTickCount

#define KeQueryTickCount

(

CurrentCount

)

_KeQueryTickCount(CurrentCount)

Definition at line 194 of file ke.h.

KeRaiseIrql

#define KeRaiseIrql	(		a,
			b
	)		*(b) = KfRaiseIrql(a)

Definition at line 79 of file ke.h.

KeReleaseSpinLock

#define KeReleaseSpinLock	(		a,
			b
	)		KfReleaseSpinLock(a,b)

Definition at line 115 of file ke.h.

KeReleaseSpinLockFromDpcLevel

#define KeReleaseSpinLockFromDpcLevel

(

SpinLock

)

KefReleaseSpinLockFromDpcLevel(SpinLock)

Definition at line 135 of file ke.h.

KERNEL_LARGE_STACK_COMMIT

#define KERNEL_LARGE_STACK_COMMIT   KERNEL_STACK_SIZE

KERNEL_LARGE_STACK_SIZE

#define KERNEL_LARGE_STACK_SIZE   0xF000

KERNEL_MCA_EXCEPTION_STACK_SIZE

#define KERNEL_MCA_EXCEPTION_STACK_SIZE   0x2000

KERNEL_STACK_SIZE

#define KERNEL_STACK_SIZE   0x3000

KI_USER_SHARED_DATA

#define KI_USER_SHARED_DATA   0xFFFF9000

KIP0PCRADDRESS

#define KIP0PCRADDRESS   0xFFDFF000

KIPCR

#define KIPCR

(

)

(((ULONG_PTR)_MoveFromCoprocessor(CP15_TPIDRPRW)) & ~CP15_PCR_RESERVED_MASK)

Definition at line 337 of file ke.h.

LOW_LEVEL

#define LOW_LEVEL   0

MemoryBarrier

#define MemoryBarrier

(

)

__dmb(_ARM_BARRIER_SY)

Definition at line 39 of file ke.h.

PAGE_SHIFT

#define PAGE_SHIFT   12L

PAGE_SIZE

#define PAGE_SIZE   0x1000

PASSIVE_LEVEL

#define PASSIVE_LEVEL   0

PAUSE_PROCESSOR

#define PAUSE_PROCESSOR   __yield();

PCR_MAJOR_VERSION

#define PCR_MAJOR_VERSION   1

Definition at line 294 of file ke.h.

PCR_MINOR_VERSION

#define PCR_MINOR_VERSION   1

Definition at line 293 of file ke.h.

POWER_LEVEL

#define POWER_LEVEL   14

PreFetchCacheLine

#define PreFetchCacheLine	(		l,
			a
	)		__prefetch((const void *) (a))

Definition at line 40 of file ke.h.

PrefetchForWrite

#define PrefetchForWrite

(

p

)

__prefetch((const void *) (p))

Definition at line 41 of file ke.h.

PROFILE_LEVEL

#define PROFILE_LEVEL   15

ReadForWriteAccess

#define ReadForWriteAccess

(

p

)

(*(p))

Definition at line 42 of file ke.h.

SharedUserData

#define SharedUserData   ((KUSER_SHARED_DATA * const)KI_USER_SHARED_DATA)

Typedef Documentation

CONTEXT

typedef struct _CONTEXT CONTEXT

KPCR

typedef struct _KPCR KPCR

PKPCR

typedef struct _KPCR * PKPCR

Function Documentation

$endif()

$endif

(

_WDMDDK_

)

== *HashTable

Definition at line 202 of file ke.h.

{
    ULONGLONG Low;
    LONGLONG High;
} NEON128, *PNEON128;

$if()

$if

(

_WDMDDK_

)

Kernel definitions for ARM

Definition at line 1 of file ke.h.

{
    ULONG Reserved;
} KFLOATING_SAVE, *PKFLOATING_SAVE;

_Always_()

_Always_

(

_Post_satisfies_(return<=0)

)

_IRQL_requires_()

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _IRQL_requires_

(

DISPATCH_LEVEL

)

Definition at line 394 of file expool.c.

{
    SIZE_T OldSize = PoolBigPageTableSize;
    SIZE_T NewSize, NewSizeInBytes;
    PPOOL_TRACKER_BIG_PAGES NewTable;
    PPOOL_TRACKER_BIG_PAGES OldTable;
    ULONG i;
    ULONG PagesFreed;
    ULONG Hash;
    ULONG HashMask;
 
    /* Must be holding ExpLargePoolTableLock */
    ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 
    /* Make sure we don't overflow */
    if (Shrink)
    {
        NewSize = OldSize / 2;
 
        /* Make sure we don't shrink too much. */
        ASSERT(NewSize >= ExpPoolBigEntriesInUse);
 
        NewSize = ALIGN_UP_BY(NewSize, PAGE_SIZE / sizeof(POOL_TRACKER_BIG_PAGES));
        ASSERT(NewSize <= OldSize);
 
        /* If there is only one page left, then keep it around. Not a failure either. */
        if (NewSize == OldSize)
        {
            ASSERT(NewSize == (PAGE_SIZE / sizeof(POOL_TRACKER_BIG_PAGES)));
            KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
            return TRUE;
        }
    }
    else
    {
        if (!NT_SUCCESS(RtlSIZETMult(2, OldSize, &NewSize)))
        {
            DPRINT1("Overflow expanding big page table. Size=%lu\n", OldSize);
            KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
            return FALSE;
        }
 
        /* Make sure we don't stupidly waste pages */
        NewSize = ALIGN_DOWN_BY(NewSize, PAGE_SIZE / sizeof(POOL_TRACKER_BIG_PAGES));
        ASSERT(NewSize > OldSize);
    }
 
    if (!NT_SUCCESS(RtlSIZETMult(sizeof(POOL_TRACKER_BIG_PAGES), NewSize, &NewSizeInBytes)))
    {
        DPRINT1("Overflow while calculating big page table size. Size=%lu\n", OldSize);
        KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
        return FALSE;
    }
 
    NewTable = MiAllocatePoolPages(NonPagedPool, NewSizeInBytes);
    if (NewTable == NULL)
    {
        DPRINT("Could not allocate %lu bytes for new big page table\n", NewSizeInBytes);
        KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
        return FALSE;
    }
 
    DPRINT("%s big pool tracker table to %lu entries\n", Shrink ? "Shrinking" : "Expanding", NewSize);
 
    /* Initialize the new table */
    RtlZeroMemory(NewTable, NewSizeInBytes);
    for (i = 0; i < NewSize; i++)
    {
        NewTable[i].Va = (PVOID)POOL_BIG_TABLE_ENTRY_FREE;
    }
 
    /* Copy over all items */
    OldTable = PoolBigPageTable;
    HashMask = NewSize - 1;
    for (i = 0; i < OldSize; i++)
    {
        /* Skip over empty items */
        if ((ULONG_PTR)OldTable[i].Va & POOL_BIG_TABLE_ENTRY_FREE)
        {
            continue;
        }
 
        /* Recalculate the hash due to the new table size */
        Hash = ExpComputePartialHashForAddress(OldTable[i].Va) % HashMask;
 
        /* Find the location in the new table */
        while (!((ULONG_PTR)NewTable[Hash].Va & POOL_BIG_TABLE_ENTRY_FREE))
        {
            if (++Hash == NewSize)
                Hash = 0;
        }
 
        /* We must have space */
        ASSERT((ULONG_PTR)NewTable[Hash].Va & POOL_BIG_TABLE_ENTRY_FREE);
 
        /* Finally, copy the item */
        NewTable[Hash] = OldTable[i];
    }
 
    /* Activate the new table */
    PoolBigPageTable = NewTable;
    PoolBigPageTableSize = NewSize;
    PoolBigPageTableHash = PoolBigPageTableSize - 1;
 
    /* Release the lock, we're done changing global state */
    KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
 
    /* Free the old table and update our tracker */
    PagesFreed = MiFreePoolPages(OldTable);
    ExpRemovePoolTracker('looP', PagesFreed << PAGE_SHIFT, 0);
    ExpInsertPoolTracker('looP', ALIGN_UP_BY(NewSizeInBytes, PAGE_SIZE), 0);
 
    return TRUE;
}

_IRQL_requires_max_() [1/2]

_IRQL_requires_max_

(

DISPATCH_LEVEL

)

Definition at line 3557 of file common.c.

{
    NTSTATUS                    status;
    BOOLEAN                     requestSent = FALSE;
 
    BOOLEAN                     shouldRetry = TRUE;
    PCDB                        cdb = (PCDB)DeviceExtension->PowerContext.Srb.Cdb;
    ULONG                       timeoutValue = DeviceExtension->TimeOutValue;
    ULONG                       retryCount = 1;
 
    // reset some fields.
    DeviceExtension->PowerContext.RetryIntervalIn100ns = 0;
    status = PowerContextReuseRequest(DeviceExtension);
    RequestClearSendTime(DeviceExtension->PowerContext.PowerRequest);
 
    if (!NT_SUCCESS(status))
    {
        return status;
    }
 
    // set proper timeout value and max retry count.
    switch(DeviceExtension->PowerContext.PowerChangeState.PowerDown)
    {
    case PowerDownDeviceInitial:
    case PowerDownDeviceQuiesced:
    case PowerDownDeviceStopped:
        break;
 
    case PowerDownDeviceLocked:
        // Case of issuing SYNC CACHE command. Do not use power irp timeout remaining time in this case
        // as we want to give best try on SYNC CACHE command.
        retryCount = MAXIMUM_RETRIES;
        timeoutValue = DeviceExtension->TimeOutValue;
        break;
 
    case PowerDownDeviceFlushed:
    {
        // Case of issuing STOP UNIT command
        // As "Imme" bit is set to '1', this command should be completed in short time.
        // This command is at low importance, failure of this command has very small impact.
        ULONG secondsRemaining = 0;
 
#if (WINVER >= 0x0601)
        // this API is introduced in Windows7
        PoQueryWatchdogTime(DeviceExtension->LowerPdo, &secondsRemaining);
#endif
 
        if (secondsRemaining == 0)
        {
            // not able to retrieve remaining time from PoQueryWatchdogTime API, use default values.
            retryCount = MAXIMUM_RETRIES;
            timeoutValue = SCSI_CDROM_TIMEOUT;
        }
        else
        {
            // plan to leave about 30 seconds to lower level drivers if possible.
            if (secondsRemaining >= 32)
            {
                retryCount = (secondsRemaining - 30)/SCSI_CDROM_TIMEOUT + 1;
                timeoutValue = SCSI_CDROM_TIMEOUT;
 
                if (retryCount > MAXIMUM_RETRIES)
                {
                    retryCount = MAXIMUM_RETRIES;
                }
 
                if (retryCount == 1)
                {
                    timeoutValue = secondsRemaining - 30;
                }
            }
            else
            {
                // issue the command with minimal timeout value and do not retry on it.
                retryCount = 1;
                timeoutValue = 2;
            }
        }
    }
        break;
    default:
        NT_ASSERT( FALSE );
        status = STATUS_NOT_IMPLEMENTED;
        return status;
    }
 
    DeviceExtension->PowerContext.RetryCount = retryCount;
 
    // issue command.
    while (shouldRetry)
    {
 
        // set SRB fields.
        DeviceExtension->PowerContext.Srb.SrbFlags = SRB_FLAGS_NO_DATA_TRANSFER |
                                                     SRB_FLAGS_DISABLE_SYNCH_TRANSFER |
                                                     SRB_FLAGS_NO_QUEUE_FREEZE |
                                                     SRB_FLAGS_BYPASS_LOCKED_QUEUE |
                                                     SRB_FLAGS_D3_PROCESSING;
 
        DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_EXECUTE_SCSI;
        DeviceExtension->PowerContext.Srb.TimeOutValue = timeoutValue;
 
        if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceInitial)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_LOCK_QUEUE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceLocked)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_QUIESCE_DEVICE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
        {
            // Case of issuing SYNC CACHE command.
            DeviceExtension->PowerContext.Srb.CdbLength = 10;
            cdb->SYNCHRONIZE_CACHE10.OperationCode = SCSIOP_SYNCHRONIZE_CACHE;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceFlushed)
        {
            // Case of issuing STOP UNIT command.
            DeviceExtension->PowerContext.Srb.CdbLength = 6;
            cdb->START_STOP.OperationCode = SCSIOP_START_STOP_UNIT;
            cdb->START_STOP.Start = 0;
            cdb->START_STOP.Immediate = 1;
        }
        else if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceStopped)
        {
            DeviceExtension->PowerContext.Srb.Function = SRB_FUNCTION_UNLOCK_QUEUE;
        }
 
        // Set up completion routine and context if requested
        if (CompletionRoutine)
        {
            WdfRequestSetCompletionRoutine(DeviceExtension->PowerContext.PowerRequest,
                                           CompletionRoutine,
                                           Context);
        }
 
        status = RequestSend(DeviceExtension,
                             DeviceExtension->PowerContext.PowerRequest,
                             DeviceExtension->IoTarget,
                             CompletionRoutine ? 0 : WDF_REQUEST_SEND_OPTION_SYNCHRONOUS,
                             &requestSent);
 
        if (requestSent)
        {
            if ((CompletionRoutine == NULL) &&
                (SRB_STATUS(DeviceExtension->PowerContext.Srb.SrbStatus) != SRB_STATUS_SUCCESS))
            {
                TracePrint((TRACE_LEVEL_ERROR,
                            TRACE_FLAG_POWER,
                            "%p\tError occured when issuing %s command to device. Srb %p, Status %x\n",
                            DeviceExtension->PowerContext.PowerRequest,
                            (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced) ? "SYNC CACHE" : "STOP UNIT",
                            &DeviceExtension->PowerContext.Srb,
                            DeviceExtension->PowerContext.Srb.SrbStatus));
 
                NT_ASSERT(!(TEST_FLAG(DeviceExtension->PowerContext.Srb.SrbStatus, SRB_STATUS_QUEUE_FROZEN)));
 
                shouldRetry = RequestSenseInfoInterpret(DeviceExtension,
                                                        DeviceExtension->PowerContext.PowerRequest,
                                                        &(DeviceExtension->PowerContext.Srb),
                                                        retryCount - DeviceExtension->PowerContext.RetryCount,
                                                        &status,
                                                        &(DeviceExtension->PowerContext.RetryIntervalIn100ns));
 
                if (shouldRetry && (DeviceExtension->PowerContext.RetryCount-- == 0))
                {
                    shouldRetry = FALSE;
                }
            }
            else
            {
                // succeeded, do not need to retry.
                shouldRetry = FALSE;
            }
 
        }
        else
        {
            // request failed to be sent
            shouldRetry = FALSE;
        }
 
        if (shouldRetry)
        {
            LARGE_INTEGER t;
            t.QuadPart = -DeviceExtension->PowerContext.RetryIntervalIn100ns;
            KeDelayExecutionThread(KernelMode, FALSE, &t);
 
            status = PowerContextReuseRequest(DeviceExtension);
            if (!NT_SUCCESS(status))
            {
                shouldRetry = FALSE;
            }
        }
    }
 
    if (DeviceExtension->PowerContext.PowerChangeState.PowerDown == PowerDownDeviceQuiesced)
    {
        // record SYNC CACHE command completion time stamp.
        KeQueryTickCount(&DeviceExtension->PowerContext.Step1CompleteTime);
    }
 
    return status;
}

_IRQL_requires_max_() [2/2]

_IRQL_requires_max_

(

HIGH_LEVEL

)

Definition at line 134 of file wdfdpc.h.

{
    return ((PFN_WDFDPCENQUEUE) WdfFunctions[WdfDpcEnqueueTableIndex])(WdfDriverGlobals, Dpc);
}

_IRQL_requires_min_()

_Requires_lock_not_held_ SpinLock _Acquires_lock_ SpinLock _IRQL_requires_min_

(

DISPATCH_LEVEL

)

Definition at line 1013 of file mm.h.

{
    PKSPIN_LOCK_QUEUE LockQueue;
 
    ASSERT(KeGetCurrentIrql() >= DISPATCH_LEVEL);
    LockQueue = &KeGetCurrentPrcb()->LockQueue[LockQueuePfnLock];
    KeAcquireQueuedSpinLockAtDpcLevel(LockQueue);
}

_KeQueryTickCount()

FORCEINLINE VOID _KeQueryTickCount

(

OUT PLARGE_INTEGER

CurrentCount

)

Definition at line 178 of file ke.h.

{
  for (;;) {
#ifdef NONAMELESSUNION
    CurrentCount->s.HighPart = KeTickCount.High1Time;
    CurrentCount->s.LowPart = KeTickCount.LowPart;
    if (CurrentCount->s.HighPart == KeTickCount.High2Time) break;
#else
    CurrentCount->HighPart = KeTickCount.High1Time;
    CurrentCount->LowPart = KeTickCount.LowPart;
    if (CurrentCount->HighPart == KeTickCount.High2Time) break;
#endif
    YieldProcessor();
  }
}

_Kernel_requires_resource_held_()

_Kernel_requires_resource_held_

(

FloatState

)

Definition at line 158 of file ke.h.

{
    UNREFERENCED_PARAMETER(FloatSave);
    return STATUS_SUCCESS;
}

_Kernel_requires_resource_not_held_()

_Kernel_requires_resource_not_held_

(

FloatState

)

Definition at line 146 of file ke.h.

{
    UNREFERENCED_PARAMETER(FloatSave);
    return STATUS_SUCCESS;
}

_Success_()

_Success_

(

1

)

KeFlushIoBuffers()

VOID KeFlushIoBuffers	(	_In_ PMDL	Mdl,
		_In_ BOOLEAN	ReadOperation,
		_In_ BOOLEAN	DmaOperation
	)

Definition at line 176 of file cpu.c.

{
    DbgBreakPoint();
}

KeGetCurrentProcessorNumber()

FORCEINLINE ULONG KeGetCurrentProcessorNumber

(

VOID

)

Definition at line 349 of file ke.h.

{
    return (ULONG)*((PUCHAR)KIPCR() + 0x580);
}

KeGetCurrentThread()

NTSYSAPI PKTHREAD NTAPI KeGetCurrentThread

(

VOID

)

Definition at line 387 of file ke.h.

{
    /* Return the current thread */
    return ((PKIPCR)KeGetPcr())->PrcbData.CurrentThread;
}

KeGetPcr()

FORCEINLINE PKPCR KeGetPcr

(

VOID

)

Definition at line 341 of file ke.h.

{
    return (PKPCR)KIPCR();
}

KeMemoryBarrier()

FORCEINLINE VOID KeMemoryBarrier

(

VOID

)

Definition at line 46 of file ke.h.

{
    _ReadWriteBarrier();
    MemoryBarrier();
}

KeRaiseIrqlToSynchLevel()

NTHALAPI KIRQL NTAPI KeRaiseIrqlToSynchLevel

(

VOID

)

Definition at line 156 of file pic.c.

{
    PKPCR Pcr = KeGetPcr();
    KIRQL CurrentIrql;
 
    /* Save and update IRQL */
    CurrentIrql = Pcr->Irql;
    Pcr->Irql = SYNCH_LEVEL;
 
#ifdef IRQL_DEBUG
    /* Validate correct raise */
    if (CurrentIrql > SYNCH_LEVEL)
    {
        /* Crash system */
        KeBugCheckEx(IRQL_NOT_GREATER_OR_EQUAL,
                     CurrentIrql,
                     SYNCH_LEVEL,
                     0,
                     1);
    }
#endif
 
    /* Return the previous value */
    return CurrentIrql;
}

YieldProcessor()

FORCEINLINE VOID YieldProcessor

(

VOID

)

Definition at line 32 of file ke.h.

{
    __dmb(_ARM_BARRIER_ISHST);
    __yield();
}

Variable Documentation

KeTickCount

NTKERNELAPI volatile KSYSTEM_TIME KeTickCount

extern

Definition at line 19 of file clock.c.

KFLOATING_SAVE

KFLOATING_SAVE

Definition at line 26 of file ke.h.

NEON128

NEON128

Definition at line 229 of file ke.h.

NewIrql

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _In_ _IRQL_restores_ KIRQL NewIrql

Definition at line 114 of file ke.h.

Referenced by __drv_maxIRQL(), _Releases_lock_(), HalpLowerIrql(), KeLowerIrql(), KeRaiseIrql(), KeReleaseSpinLock(), KeSetCurrentIrql(), KfLowerIrql(), KfRaiseIrql(), KmtSetIrql(), KxLowerIrql(), KxRaiseIrql(), and VideoPortReleaseSpinLock().

PKFLOATING_SAVE

* PKFLOATING_SAVE

Definition at line 26 of file ke.h.

PNEON128

* PNEON128

Definition at line 229 of file ke.h.