ke.h File Reference

#include "pshpack4.h"
#include "poppack.h"

Include dependency graph for ke.h:

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	CMCI_LEVEL   5
#define	PROFILE_LEVEL   27
#define	CLOCK1_LEVEL   28
#define	CLOCK2_LEVEL   28
#define	IPI_LEVEL   29
#define	POWER_LEVEL   30
#define	HIGH_LEVEL   31
#define	CLOCK_LEVEL   CLOCK2_LEVEL
#define	KIP0PCRADDRESS   0xffdff000
#define	KI_USER_SHARED_DATA   0xffdf0000
#define	SharedUserData   ((KUSER_SHARED_DATA * CONST)KI_USER_SHARED_DATA)
#define	PAGE_SIZE   0x1000
#define	PAGE_SHIFT   12L
#define	KeGetDcacheFillSize()   1L
#define	EFLAG_SIGN   0x8000
#define	EFLAG_ZERO   0x4000
#define	EFLAG_SELECT   (EFLAG_SIGN | EFLAG_ZERO)
#define	RESULT_NEGATIVE   ((EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT)
#define	RESULT_ZERO   ((~EFLAG_SIGN & EFLAG_ZERO) & EFLAG_SELECT)
#define	RESULT_POSITIVE   ((~EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT)
#define	YieldProcessor   _mm_pause
#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	KeFlushIoBuffers(_Mdl, _ReadOperation, _DmaOperation)
#define	DbgRaiseAssertionFailure   __int2c
#define	KeQueryTickCount(CurrentCount)   _KeQueryTickCount(CurrentCount)
#define	PAUSE_PROCESSOR   YieldProcessor();
#define	KERNEL_STACK_SIZE   12288
#define	KERNEL_LARGE_STACK_SIZE   61440
#define	KERNEL_LARGE_STACK_COMMIT   12288
#define	SIZE_OF_80387_REGISTERS   80
#define	CONTEXT_i386   0x10000
#define	CONTEXT_i486   0x10000
#define	CONTEXT_CONTROL   (CONTEXT_i386|0x00000001L)
#define	CONTEXT_INTEGER   (CONTEXT_i386|0x00000002L)
#define	CONTEXT_SEGMENTS   (CONTEXT_i386|0x00000004L)
#define	CONTEXT_FLOATING_POINT   (CONTEXT_i386|0x00000008L)
#define	CONTEXT_DEBUG_REGISTERS   (CONTEXT_i386|0x00000010L)
#define	CONTEXT_EXTENDED_REGISTERS   (CONTEXT_i386|0x00000020L)
#define	CONTEXT_FULL   (CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS)
#define	CONTEXT_ALL
#define	CONTEXT_XSTATE   (CONTEXT_i386 | 0x00000040L)
#define	PCR_MINOR_VERSION   1
#define	PCR_MAJOR_VERSION   1
#define	IsNEC_98   (SharedUserData->AlternativeArchitecture == NEC98x86)
#define	IsNotNEC_98   (SharedUserData->AlternativeArchitecture != NEC98x86)
#define	SetNEC_98   (SharedUserData->AlternativeArchitecture = NEC98x86)
#define	SetNotNEC_98   (SharedUserData->AlternativeArchitecture = StandardDesign)

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

Functions
	$if (_WDMDDK_) typedef struct _KFLOATING_SAVE
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)) NTKERNELAPI NTSTATUS NTAPI KeSaveFloatingPointState(_Out_ PKFLOATING_SAVE FloatSave)
	_Success_ (1) _Kernel_float_restored_ _At_(*FloatSave
	_Kernel_requires_resource_held_ (FloatState) _Kernel_releases_resource_(FloatState)) NTKERNELAPI NTSTATUS NTAPI KeRestoreFloatingPointState(_In_ PKFLOATING_SAVE FloatSave)
FORCEINLINE ULONG NTAPI	KeGetCurrentProcessorIndex (VOID)
FORCEINLINE VOID	_KeQueryTickCount (OUT PLARGE_INTEGER CurrentCount)
	$endif (_WDMDDK_) $if(_NTDDK_) typedef struct _FLOATING_SAVE_AREA
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
	FLOATING_SAVE_AREA
*	PFLOATING_SAVE_AREA

Macro Definition Documentation

APC_LEVEL

#define APC_LEVEL   1

CLOCK1_LEVEL

#define CLOCK1_LEVEL   28

CLOCK2_LEVEL

#define CLOCK2_LEVEL   28

CLOCK_LEVEL

#define CLOCK_LEVEL   CLOCK2_LEVEL

CMCI_LEVEL

#define CMCI_LEVEL   5

CONTEXT_ALL

#define CONTEXT_ALL

Value:

                     (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS |  \
                     CONTEXT_FLOATING_POINT | CONTEXT_DEBUG_REGISTERS |      \
                     CONTEXT_EXTENDED_REGISTERS)

CONTEXT_CONTROL

#define CONTEXT_CONTROL   (CONTEXT_i386|0x00000001L)

CONTEXT_DEBUG_REGISTERS

#define CONTEXT_DEBUG_REGISTERS   (CONTEXT_i386|0x00000010L)

CONTEXT_EXTENDED_REGISTERS

#define CONTEXT_EXTENDED_REGISTERS   (CONTEXT_i386|0x00000020L)

CONTEXT_FLOATING_POINT

#define CONTEXT_FLOATING_POINT   (CONTEXT_i386|0x00000008L)

CONTEXT_FULL

#define CONTEXT_FULL   (CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS)

CONTEXT_i386

#define CONTEXT_i386   0x10000

CONTEXT_i486

#define CONTEXT_i486   0x10000

CONTEXT_INTEGER

#define CONTEXT_INTEGER   (CONTEXT_i386|0x00000002L)

CONTEXT_SEGMENTS

#define CONTEXT_SEGMENTS   (CONTEXT_i386|0x00000004L)

CONTEXT_XSTATE

#define CONTEXT_XSTATE   (CONTEXT_i386 | 0x00000040L)

DbgRaiseAssertionFailure

#define DbgRaiseAssertionFailure   __int2c

Definition at line 191 of file ke.h.

DISPATCH_LEVEL

#define DISPATCH_LEVEL   2

EFLAG_SELECT

#define EFLAG_SELECT   (EFLAG_SIGN | EFLAG_ZERO)

EFLAG_SIGN

#define EFLAG_SIGN   0x8000

EFLAG_ZERO

#define EFLAG_ZERO   0x4000

HIGH_LEVEL

#define HIGH_LEVEL   31

IPI_LEVEL

#define IPI_LEVEL   29

IsNEC_98

#define IsNEC_98   (SharedUserData->AlternativeArchitecture == NEC98x86)

Definition at line 352 of file ke.h.

IsNotNEC_98

#define IsNotNEC_98   (SharedUserData->AlternativeArchitecture != NEC98x86)

Definition at line 357 of file ke.h.

KeAcquireSpinLock

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

Definition at line 114 of file ke.h.

KeAcquireSpinLockAtDpcLevel

#define KeAcquireSpinLockAtDpcLevel

(

SpinLock

)

KefAcquireSpinLockAtDpcLevel(SpinLock)

Definition at line 135 of file ke.h.

KeFlushIoBuffers

#define KeFlushIoBuffers	(		_Mdl,
			_ReadOperation,
			_DmaOperation
	)

Definition at line 188 of file ke.h.

KeGetDcacheFillSize

#define KeGetDcacheFillSize

(

)

1L

KeLowerIrql

#define KeLowerIrql

(

a

)

KfLowerIrql(a)

Definition at line 79 of file ke.h.

KeMemoryBarrierWithoutFence

#define KeMemoryBarrierWithoutFence

(

)

_ReadWriteBarrier()

Definition at line 64 of file ke.h.

KeQueryTickCount

#define KeQueryTickCount

(

CurrentCount

)

_KeQueryTickCount(CurrentCount)

Definition at line 211 of file ke.h.

KeRaiseIrql

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

Definition at line 89 of file ke.h.

KeReleaseSpinLock

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

Definition at line 125 of file ke.h.

KeReleaseSpinLockFromDpcLevel

#define KeReleaseSpinLockFromDpcLevel

(

SpinLock

)

KefReleaseSpinLockFromDpcLevel(SpinLock)

Definition at line 145 of file ke.h.

KERNEL_LARGE_STACK_COMMIT

#define KERNEL_LARGE_STACK_COMMIT   12288

KERNEL_LARGE_STACK_SIZE

#define KERNEL_LARGE_STACK_SIZE   61440

KERNEL_STACK_SIZE

#define KERNEL_STACK_SIZE   12288

KI_USER_SHARED_DATA

#define KI_USER_SHARED_DATA   0xffdf0000

KIP0PCRADDRESS

#define KIP0PCRADDRESS   0xffdff000

LOW_LEVEL

#define LOW_LEVEL   0

PAGE_SHIFT

#define PAGE_SHIFT   12L

PAGE_SIZE

#define PAGE_SIZE   0x1000

PASSIVE_LEVEL

#define PASSIVE_LEVEL   0

PAUSE_PROCESSOR

#define PAUSE_PROCESSOR   YieldProcessor();

PCR_MAJOR_VERSION

#define PCR_MAJOR_VERSION   1

Definition at line 287 of file ke.h.

PCR_MINOR_VERSION

#define PCR_MINOR_VERSION   1

Definition at line 286 of file ke.h.

POWER_LEVEL

#define POWER_LEVEL   30

PROFILE_LEVEL

#define PROFILE_LEVEL   27

RESULT_NEGATIVE

#define RESULT_NEGATIVE   ((EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT)

RESULT_POSITIVE

#define RESULT_POSITIVE   ((~EFLAG_SIGN & ~EFLAG_ZERO) & EFLAG_SELECT)

RESULT_ZERO

#define RESULT_ZERO   ((~EFLAG_SIGN & EFLAG_ZERO) & EFLAG_SELECT)

SetNEC_98

#define SetNEC_98   (SharedUserData->AlternativeArchitecture = NEC98x86)

Definition at line 362 of file ke.h.

SetNotNEC_98

#define SetNotNEC_98   (SharedUserData->AlternativeArchitecture = StandardDesign)

Definition at line 367 of file ke.h.

SharedUserData

#define SharedUserData   ((KUSER_SHARED_DATA * CONST)KI_USER_SHARED_DATA)

SIZE_OF_80387_REGISTERS

#define SIZE_OF_80387_REGISTERS   80

YieldProcessor

#define YieldProcessor   _mm_pause

Definition at line 48 of file ke.h.

Typedef Documentation

CONTEXT

typedef struct _CONTEXT CONTEXT

KPCR

typedef struct _KPCR KPCR

PKPCR

typedef struct _KPCR * PKPCR

Function Documentation

$endif()

$endif

(

_WDMDDK_

)

Definition at line 213 of file ke.h.

                                   {
  ULONG ControlWord;
  ULONG StatusWord;
  ULONG TagWord;
  ULONG ErrorOffset;
  ULONG ErrorSelector;
  ULONG DataOffset;
  ULONG DataSelector;
  UCHAR RegisterArea[SIZE_OF_80387_REGISTERS];
  ULONG Cr0NpxState;
} FLOATING_SAVE_AREA, *PFLOATING_SAVE_AREA;

$if()

$if

(

_WDMDDK_

)

Kernel definitions for x86

Definition at line 1 of file ke.h.

                               {
  ULONG ControlWord;
  ULONG StatusWord;
  ULONG ErrorOffset;
  ULONG ErrorSelector;
  ULONG DataOffset;
  ULONG DataSelector;
  ULONG Cr0NpxState;
  ULONG Spare1;
} KFLOATING_SAVE, *PKFLOATING_SAVE;

Referenced by $endif().

_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 1015 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 195 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 149 of file ke.h.

{
    UNREFERENCED_PARAMETER(FloatSave);
    return STATUS_SUCCESS;
}

_Kernel_requires_resource_not_held_()

_Kernel_requires_resource_not_held_

(

FloatState

)

Definition at line 137 of file ke.h.

{
    UNREFERENCED_PARAMETER(FloatSave);
    return STATUS_SUCCESS;
}

_Success_()

_Success_

(

1

)

KeGetCurrentProcessorIndex()

FORCEINLINE ULONG NTAPI KeGetCurrentProcessorIndex

(

VOID

)

Definition at line 176 of file ke.h.

{
    return __readfsbyte(0x51);
}

KeGetCurrentProcessorNumber()

FORCEINLINE ULONG KeGetCurrentProcessorNumber

(

VOID

)

Definition at line 343 of file ke.h.

{
    return (ULONG)__readfsbyte(FIELD_OFFSET(KPCR, Number));
}

KeGetCurrentThread()

NTSYSAPI PKTHREAD NTAPI KeGetCurrentThread

(

VOID

)

Definition at line 387 of file ke.h.

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

KeMemoryBarrier()

FORCEINLINE VOID KeMemoryBarrier

(

VOID

)

Definition at line 52 of file ke.h.

{
  LONG Barrier, *Dummy = &Barrier;
  (VOID)Dummy;
 
#if defined(__GNUC__)
  __asm__ __volatile__ ("xchg %%eax, %0" : : "m" (Barrier) : "%eax");
#elif defined(_MSC_VER)
  __asm xchg [Barrier], eax
#endif
}

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;
}

Referenced by _Requires_lock_not_held_(), KeDelayExecutionThread(), KeFlushEntireTb(), KeQueryBasePriorityThread(), KeRemoveQueue(), KeSignalGateBoostPriority(), KeWaitForMultipleObjects(), KeWaitForSingleObject(), KiRetireDpcList(), and NtYieldExecution().

Variable Documentation

FLOATING_SAVE_AREA

FLOATING_SAVE_AREA

Definition at line 254 of file ke.h.

KeTickCount

NTKERNELAPI volatile KSYSTEM_TIME KeTickCount

extern

Definition at line 19 of file clock.c.

Referenced by KeQueryTickCount().

KFLOATING_SAVE

KFLOATING_SAVE

Definition at line 44 of file ke.h.

NewIrql

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _In_ _IRQL_restores_ KIRQL NewIrql

Definition at line 124 of file ke.h.

PFLOATING_SAVE_AREA

* PFLOATING_SAVE_AREA

Definition at line 254 of file ke.h.

PKFLOATING_SAVE

* PKFLOATING_SAVE

Definition at line 44 of file ke.h.