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

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

◆ 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 1448 of file expool.c.

 {
     ULONG OldSize = PoolBigPageTableSize;
     ULONG NewSize = 2 * OldSize;
     ULONG 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 (!NT_SUCCESS(RtlULongMult(2,
                                  OldSize * sizeof(POOL_TRACKER_BIG_PAGES),
                                  &NewSizeInBytes)))
     {
         DPRINT1("Overflow expanding big page table. Size=%lu\n", OldSize);
         KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
         return FALSE;
     }
 
     NewTable = MiAllocatePoolPages(NonPagedPool, NewSizeInBytes);
     if (NewTable == NULL)
     {
         DPRINT1("Could not allocate %lu bytes for new big page table\n", NewSizeInBytes);
         KeReleaseSpinLock(&ExpLargePoolTableLock, OldIrql);
         return FALSE;
     }
 
     DPRINT("Expanding big pool tracker table to %lu entries\n", 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))
         {
             Hash = (Hash + 1) & HashMask;
         }
 
         /* We just enlarged the table, so 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_ ( HIGH_LEVEL )

Definition at line 144 of file wdfdpc.h.

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

◆ _IRQL_requires_max_() [2/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_min_()

_Requires_lock_held_ SpinLock _Releases_lock_ SpinLock _IRQL_requires_min_ ( DISPATCH_LEVEL )

◆ _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 191 of file cpu.c.

 {
     DbgBreakPoint();
 }

◆ KeGetCurrentProcessorNumber()

FORCEINLINE ULONG KeGetCurrentProcessorNumber ( VOID )

Definition at line 350 of file ke.h.

 {
     return *((PUCHAR)KeGetPcr() + 0x580);
 }

◆ KeGetCurrentThread()

NTSYSAPI PKTHREAD NTAPI KeGetCurrentThread ( VOID )

Definition at line 284 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)(_MoveFromCoprocessor(CP15_TPIDRPRW) & ~CP15_PCR_RESERVED_MASK);
 }

◆ 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();
 }

Referenced by _ExTryToAcquireFastMutex(), _KeQueryTickCount(), _KeTryToAcquireGuardedMutex(), ExfAcquirePushLockExclusive(), ExfAcquirePushLockShared(), ExTimedWaitForUnblockPushLock(), GetTickCount(), GetTickCount64(), InternalLockCondVar(), KeIpiGenericCall(), KeQueryInterruptTime(), KeQuerySystemTime(), KeQueryTickCount(), KeTestSpinLock(), KiIdleLoop(), LdrpInitSecurityCookie(), RtlAcquireSRWLockExclusive(), RtlAcquireSRWLockShared(), RtlGetTickCount(), RtlpAcquireSRWLockExclusiveWait(), RtlpAcquireSRWLockSharedWait(), RtlpAcquireWaitBlockLock(), RtlReleaseSRWLockExclusive(), and RtlReleaseSRWLockShared().

Variable Documentation

◆ KeTickCount

NTKERNELAPI volatile KSYSTEM_TIME KeTickCount

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_(), HalpExecuteIrqs(), HalpLowerIrql(), KeLowerIrql(), KeRaiseIrql(), KeReleaseSpinLock(), KeSetCurrentIrql(), KfLowerIrql(), KfRaiseIrql(), KmtSetIrql(), KxLowerIrql(), KxRaiseIrql(), and VideoPortReleaseSpinLock().

◆ PKFLOATING_SAVE

* PKFLOATING_SAVE