mmfuncs.h File Reference

Go to the source code of this file.

Macros
#define	ALIGN_DOWN_BY(size, align)   ((ULONG_PTR)(size) & ~((ULONG_PTR)(align) - 1))
#define	ALIGN_UP_BY(size, align)   (ALIGN_DOWN_BY(((ULONG_PTR)(size) + align - 1), align))
#define	ALIGN_DOWN_POINTER_BY(ptr, align)   ((PVOID)ALIGN_DOWN_BY(ptr, align))
#define	ALIGN_UP_POINTER_BY(ptr, align)   ((PVOID)ALIGN_UP_BY(ptr, align))
#define	ALIGN_DOWN(size, type)   ALIGN_DOWN_BY(size, sizeof(type))
#define	ALIGN_UP(size, type)   ALIGN_UP_BY(size, sizeof(type))
#define	ALIGN_DOWN_POINTER(ptr, type)   ALIGN_DOWN_POINTER_BY(ptr, sizeof(type))
#define	ALIGN_UP_POINTER(ptr, type)   ALIGN_UP_POINTER_BY(ptr, sizeof(type))
#define	FIELD_OFFSET(type, field)   ((ULONG)&(((type *)0)->field))
#define	FIELD_SIZE(type, field)   (sizeof(((type *)0)->field))
#define	POOL_TAGGING   1
#define	IF_DEBUG   if (FALSE)
#define	BYTE_OFFSET(Va)   ((ULONG) ((ULONG_PTR) (Va) & (PAGE_SIZE - 1)))
#define	BYTES_TO_PAGES(Size)   (((Size) >> PAGE_SHIFT) + (((Size) & (PAGE_SIZE - 1)) != 0))
#define	PAGE_ALIGN(Va)   ((PVOID) ((ULONG_PTR)(Va) & ~(PAGE_SIZE - 1)))
#define	ROUND_TO_PAGES(Size)   (((ULONG_PTR) (Size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))
#define	ADDRESS_AND_SIZE_TO_SPAN_PAGES(_Va, _Size)
#define	COMPUTE_PAGES_SPANNED(Va, Size)   ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va,Size)
#define	MmGetMdlByteCount(_Mdl)   ((_Mdl)->ByteCount)
#define	MmGetMdlByteOffset(_Mdl)   ((_Mdl)->ByteOffset)
#define	MmGetMdlBaseVa(Mdl)   ((Mdl)->StartVa)
#define	MmGetMdlPfnArray(_Mdl)   ((PPFN_NUMBER) ((_Mdl) + 1))
#define	MmGetMdlVirtualAddress(_Mdl)   ((PVOID) ((PCHAR) ((_Mdl)->StartVa) + (_Mdl)->ByteOffset))
#define	MmGetProcedureAddress(Address)   (Address)
#define	MmLockPagableCodeSection(Address)   MmLockPagableDataSection(Address)
#define	MmGetSystemAddressForMdl(Mdl)
#define	MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
#define	MmInitializeMdl(_MemoryDescriptorList, _BaseVa, _Length)
#define	MmPrepareMdlForReuse(_Mdl)

Functions
	$if (_WDMDDK_) $endif(_WDMDDK_) $if(_NTIFS_) FORCEINLINE ULONG HEAP_MAKE_TAG_FLAGS(_In_ ULONG TagBase
	$endif (_NTIFS_) $if(_WDMDDK_) _Must_inspect_result_ _IRQL_requires_max_(DISPATCH_LEVEL) _When_(return !
	_Post_writable_byte_size_ (NumberOfBytes)) NTKERNELAPI PVOID NTAPI MmAllocateContiguousMemory(_In_ SIZE_T NumberOfBytes
_Must_inspect_result_	_IRQL_requires_max_ (DISPATCH_LEVEL) _When_(return !
NTKERNELAPI PMDL NTAPI	MmCreateMdl (_Out_writes_bytes_opt_(sizeof(MDL)+(sizeof(PFN_NUMBER) *ADDRESS_AND_SIZE_TO_SPAN_PAGES(Base, Length))) PMDL MemoryDescriptorList, _In_reads_bytes_opt_(Length) PVOID Base, _In_ SIZE_T Length)
	_IRQL_requires_max_ (PASSIVE_LEVEL) NTKERNELAPI PVOID NTAPI MmGetSystemRoutineAddress(_In_ PUNICODE_STRING SystemRoutineName)
NTKERNELAPI LOGICAL NTAPI	MmIsDriverVerifying (_In_ struct _DRIVER_OBJECT *DriverObject)
_Must_inspect_result_	_IRQL_requires_max_ (APC_LEVEL) NTKERNELAPI PVOID NTAPI MmLockPagableDataSection(_In_ PVOID AddressWithinSection)
_Must_inspect_result_	_When_ (AccessMode==KernelMode, _IRQL_requires_max_(DISPATCH_LEVEL)) _When_(AccessMode
_Must_inspect_result_ _Maybe_raises_SEH_exception_ _In_	__drv_strictType (KPROCESSOR_MODE/enum _MODE, __drv_typeConst) KPROCESSOR_MODE AccessMode)
	_Post_writable_byte_size_ (MemoryDescriptorList->ByteCount) _When_(AccessMode
NTKERNELAPI MM_SYSTEMSIZE NTAPI	MmQuerySystemSize (VOID)
NTKERNELAPI SIZE_T NTAPI	MmSizeOfMdl (_In_reads_bytes_opt_(Length) PVOID Base, _In_ SIZE_T Length)
	$endif (_WDMDDK_) $if(_NTDDK_) _IRQL_requires_max_(PASSIVE_LEVEL) NTKERNELAPI PPHYSICAL_MEMORY_RANGE NTAPI MmGetPhysicalMemoryRanges(VOID)
NTKERNELAPI PHYSICAL_ADDRESS NTAPI	MmGetPhysicalAddress (_In_ PVOID BaseAddress)
NTKERNELAPI BOOLEAN NTAPI	MmIsNonPagedSystemAddressValid (_In_ PVOID VirtualAddress)
NTKERNELAPI PVOID NTAPI	MmGetVirtualForPhysical (_In_ PHYSICAL_ADDRESS PhysicalAddress)
NTKERNELAPI BOOLEAN NTAPI	MmIsThisAnNtAsSystem (VOID)
_Must_inspect_result_ _In_	__in_data_source (USER_MODE) SIZE_T Size
	$endif (_NTDDK_) $if(_NTIFS_) NTKERNELAPI BOOLEAN NTAPI MmIsRecursiveIoFault(VOID)
_Must_inspect_result_	_Out_writes_bytes_opt_ (NumberOfBytes)) NTKERNELAPI PVOID NTAPI MmAllocateMappingAddress(_In_ SIZE_T NumberOfBytes
	_In_reads_ (NumberOfLists) PREAD_LIST *ReadLists)
_Must_inspect_result_ _At_ *	BaseAddress (Mem)) __kernel_entryNTSYSCALLAPINTSTATUSNTAPINtAllocateVirtualMemory(_In_ HANDLE ProcessHandle, _Inout_ _Outptr_result_buffer_(*RegionSize) PVOID *BaseAddress, _In_ ULONG_PTR ZeroBits, _Inout_ PSIZE_T RegionSize, _In_ ULONG AllocationType, _In_ ULONG Protect
__kernel_entry _Inout_	__drv_freesMem (Mem) PVOID *BaseAddress

Variables
_In_ ULONG	Tag
_In_ PHYSICAL_ADDRESS	HighestAcceptableAddress
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS	LowestAcceptableAddress
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_opt_ PHYSICAL_ADDRESS	BoundaryAddressMultiple
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_opt_ PHYSICAL_ADDRESS _In_ MEMORY_CACHING_TYPE	CacheType
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS	HighAddress
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS	SkipBytes
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_ SIZE_T	TotalBytes
_In_ SIZE_T	NumberOfBytes
_In_ PEPROCESS	Process
_In_ PEPROCESS _In_ KPROCESSOR_MODE	AccessMode
_In_ PEPROCESS _In_ KPROCESSOR_MODE _In_ LOCK_OPERATION	Operation
_Inout_ PMDL	MemoryDescriptorList
_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_opt_ PHYSICAL_ADDRESS _In_ MEMORY_CACHING_TYPE _In_ NODE_REQUIREMENT	PreferredNode
_Must_inspect_result_ _In_ SIZE_T _In_ PVOID	PageAddress
_Must_inspect_result_ _Outptr_result_bytebuffer_ ViewSize PVOID *	MappedBase
_Must_inspect_result_ _Outptr_result_bytebuffer_ ViewSize PVOID _Inout_ PSIZE_T	ViewSize
_Must_inspect_result_ _In_ _In_ ULONG	ProbeMode
_In_ BOOLEAN	DelayClose
_In_ MMFLUSH_TYPE	FlushType
_In_opt_ PLARGE_INTEGER	NewFileSize
_In_ SIZE_T	Length
_Must_inspect_result_ _In_ ULONG	PoolTag
_Must_inspect_result_ _In_ ULONG	NewProtect
_In_ ULONG	ThunkBufferSize
_In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_ SIZE_T _In_ MEMORY_CACHING_TYPE _In_ ULONG	Flags
_Inout_ PSIZE_T _In_opt_ PMDLX	NewMdl
_Inout_ PSIZE_T _In_opt_ PMDLX _In_ MM_ROTATE_DIRECTION	Direction
_Inout_ PSIZE_T _In_opt_ PMDLX _In_ MM_ROTATE_DIRECTION _In_ PMM_ROTATE_COPY_CALLBACK_FUNCTION	CopyFunction
_Inout_ PSIZE_T _In_opt_ PMDLX _In_ MM_ROTATE_DIRECTION _In_ PMM_ROTATE_COPY_CALLBACK_FUNCTION _In_opt_ PVOID	Context
__kernel_entry _Inout_ _Inout_ PSIZE_T	RegionSize
__kernel_entry _Inout_ _Inout_ PSIZE_T _In_ ULONG	FreeType

Macro Definition Documentation

ADDRESS_AND_SIZE_TO_SPAN_PAGES

#define ADDRESS_AND_SIZE_TO_SPAN_PAGES	(		_Va,
			_Size
	)

Value:

((ULONG) ((((ULONG_PTR) (_Va) & (PAGE_SIZE - 1)) \
    + (_Size) + (PAGE_SIZE - 1)) >> PAGE_SHIFT))

ALIGN_DOWN

#define ALIGN_DOWN	(		size,
			type
	)		ALIGN_DOWN_BY(size, sizeof(type))

ALIGN_DOWN_BY

#define ALIGN_DOWN_BY	(		size,
			align
	)		((ULONG_PTR)(size) & ~((ULONG_PTR)(align) - 1))

ALIGN_DOWN_POINTER

#define ALIGN_DOWN_POINTER	(		ptr,
			type
	)		ALIGN_DOWN_POINTER_BY(ptr, sizeof(type))

ALIGN_DOWN_POINTER_BY

#define ALIGN_DOWN_POINTER_BY	(		ptr,
			align
	)		((PVOID)ALIGN_DOWN_BY(ptr, align))

ALIGN_UP

#define ALIGN_UP	(		size,
			type
	)		ALIGN_UP_BY(size, sizeof(type))

ALIGN_UP_BY

#define ALIGN_UP_BY	(		size,
			align
	)		(ALIGN_DOWN_BY(((ULONG_PTR)(size) + align - 1), align))

ALIGN_UP_POINTER

#define ALIGN_UP_POINTER	(		ptr,
			type
	)		ALIGN_UP_POINTER_BY(ptr, sizeof(type))

ALIGN_UP_POINTER_BY

#define ALIGN_UP_POINTER_BY	(		ptr,
			align
	)		((PVOID)ALIGN_UP_BY(ptr, align))

BYTE_OFFSET

#define BYTE_OFFSET

(

Va

)

((ULONG) ((ULONG_PTR) (Va) & (PAGE_SIZE - 1)))

BYTES_TO_PAGES

#define BYTES_TO_PAGES

(

Size

)

(((Size) >> PAGE_SHIFT) + (((Size) & (PAGE_SIZE - 1)) != 0))

COMPUTE_PAGES_SPANNED

#define COMPUTE_PAGES_SPANNED	(		Va,
			Size
	)		ADDRESS_AND_SIZE_TO_SPAN_PAGES(Va,Size)

FIELD_OFFSET

#define FIELD_OFFSET	(		type,
			field
	)		((ULONG)&(((type *)0)->field))

FIELD_SIZE

#define FIELD_SIZE	(		type,
			field
	)		(sizeof(((type *)0)->field))

IF_DEBUG

#define IF_DEBUG   if (FALSE)

MmGetMdlBaseVa

#define MmGetMdlBaseVa

(

Mdl

)

((Mdl)->StartVa)

MmGetMdlByteCount

#define MmGetMdlByteCount

(

_Mdl

)

((_Mdl)->ByteCount)

MmGetMdlByteOffset

#define MmGetMdlByteOffset

(

_Mdl

)

((_Mdl)->ByteOffset)

MmGetMdlPfnArray

#define MmGetMdlPfnArray

(

_Mdl

)

((PPFN_NUMBER) ((_Mdl) + 1))

MmGetMdlVirtualAddress

#define MmGetMdlVirtualAddress

(

_Mdl

)

((PVOID) ((PCHAR) ((_Mdl)->StartVa) + (_Mdl)->ByteOffset))

MmGetProcedureAddress

#define MmGetProcedureAddress

(

Address

)

(Address)

MmGetSystemAddressForMdl

#define MmGetSystemAddressForMdl

(

Mdl

)

Value:

(((Mdl)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA | \
    MDL_SOURCE_IS_NONPAGED_POOL)) ? \
      ((Mdl)->MappedSystemVa) : \
      (MmMapLockedPages((Mdl), KernelMode)))

MmGetSystemAddressForMdlSafe

#define MmGetSystemAddressForMdlSafe	(		_Mdl,
			_Priority
	)

Value:

(((_Mdl)->MdlFlags & (MDL_MAPPED_TO_SYSTEM_VA \
    | MDL_SOURCE_IS_NONPAGED_POOL)) ? \
    (_Mdl)->MappedSystemVa : \
    (PVOID) MmMapLockedPagesSpecifyCache((_Mdl), \
      KernelMode, MmCached, NULL, FALSE, (_Priority)))

MmInitializeMdl

#define MmInitializeMdl	(		_MemoryDescriptorList,
			_BaseVa,
			_Length
	)

Value:

{ \
  (_MemoryDescriptorList)->Next = (PMDL) NULL; \
  (_MemoryDescriptorList)->Size = (CSHORT) (sizeof(MDL) + \
    (sizeof(PFN_NUMBER) * ADDRESS_AND_SIZE_TO_SPAN_PAGES(_BaseVa, _Length))); \
  (_MemoryDescriptorList)->MdlFlags = 0; \
  (_MemoryDescriptorList)->StartVa = (PVOID) PAGE_ALIGN(_BaseVa); \
  (_MemoryDescriptorList)->ByteOffset = BYTE_OFFSET(_BaseVa); \
  (_MemoryDescriptorList)->ByteCount = (ULONG) _Length; \
}

MmLockPagableCodeSection

#define MmLockPagableCodeSection

(

Address

)

MmLockPagableDataSection(Address)

MmPrepareMdlForReuse

#define MmPrepareMdlForReuse

(

_Mdl

)

Value:

{ \
  if (((_Mdl)->MdlFlags & MDL_PARTIAL_HAS_BEEN_MAPPED) != 0) { \
    ASSERT(((_Mdl)->MdlFlags & MDL_PARTIAL) != 0); \
    MmUnmapLockedPages((_Mdl)->MappedSystemVa, (_Mdl)); \
  } else if (((_Mdl)->MdlFlags & MDL_PARTIAL) == 0) { \
    ASSERT(((_Mdl)->MdlFlags & MDL_MAPPED_TO_SYSTEM_VA) == 0); \
  } \
}

PAGE_ALIGN

#define PAGE_ALIGN

(

Va

)

((PVOID) ((ULONG_PTR)(Va) & ~(PAGE_SIZE - 1)))

POOL_TAGGING

#define POOL_TAGGING   1

ROUND_TO_PAGES

#define ROUND_TO_PAGES

(

Size

)

(((ULONG_PTR) (Size) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))

Function Documentation

$endif() [1/3]

$endif

(

_NTIFS_

)

Definition at line 2827 of file rtlfuncs.h.

{
  LARGE_INTEGER ret;
  ret.QuadPart = SignedInteger;
  return ret;
}

$endif() [2/3]

$endif

(

_WDMDDK_

)

Definition at line 202 of file ke.h.

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

$endif() [3/3]

$endif

(

_NTDDK_

)

Definition at line 2490 of file iofuncs.h.

{
    PriorityInfo->Size = sizeof(IO_PRIORITY_INFO);
    PriorityInfo->ThreadPriority = 0xffff;
    PriorityInfo->IoPriority = IoPriorityNormal;
    PriorityInfo->PagePriority = 0;
}

$if()

$if

(

_WDMDDK_

)

Kernel definitions for AMD64

Kernel definitions for ARM

Definition at line 1 of file ke.h.

{
    ULONG Dummy;
} KFLOATING_SAVE, *PKFLOATING_SAVE;

__drv_freesMem()

__kernel_entry _Inout_ __drv_freesMem

(

Mem

)

Definition at line 1523 of file exfuncs.h.

{
  Lookaside->L.TotalFrees++;
#ifdef NONAMELESSUNION
  if (ExQueryDepthSList(&Lookaside->L.u.ListHead) >= Lookaside->L.Depth) {
    Lookaside->L.u3.FreeMisses++;
    (Lookaside->L.u5.Free)(Entry);
  } else {
#if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
      ExInterlockedPushEntrySList(&Lookaside->L.u.ListHead,
                                  (PSLIST_ENTRY)Entry,
                                  &Lookaside->Lock__ObsoleteButDoNotDelete);
#else
      InterlockedPushEntrySList(&Lookaside->L.u.ListHead, (PSLIST_ENTRY)Entry);
#endif
   }
#else /* NONAMELESSUNION */
  if (ExQueryDepthSList(&Lookaside->L.ListHead) >= Lookaside->L.Depth) {
    Lookaside->L.FreeMisses++;
    (Lookaside->L.Free)(Entry);
  } else {
#if defined(_WIN2K_COMPAT_SLIST_USAGE) && defined(_X86_)
      ExInterlockedPushEntrySList(&Lookaside->L.ListHead,
                                  (PSLIST_ENTRY)Entry,
                                  &Lookaside->Lock__ObsoleteButDoNotDelete);
#else
      InterlockedPushEntrySList(&Lookaside->L.ListHead, (PSLIST_ENTRY)Entry);
#endif
   }
#endif /* NONAMELESSUNION */
}

__drv_strictType()

_Must_inspect_result_ _Maybe_raises_SEH_exception_ _In_ __drv_strictType	(	KPROCESSOR_MODE/enum	_MODE,
		__drv_typeConst
	)

__in_data_source()

_Must_inspect_result_ _In_ __in_data_source

(

USER_MODE

)

_In_reads_()

_In_reads_

(

NumberOfLists

)

_IRQL_requires_max_() [1/3]

_Must_inspect_result_ _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/3]

_IRQL_requires_max_

(

PASSIVE_LEVEL

)

Definition at line 64 of file Messaging.c.

{
    PFLT_SERVER_PORT_OBJECT PortObject;
    NTSTATUS Status;

    /* The caller must allow at least one connection */
    if (MaxConnections == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }

    /* The request must be for a kernel handle */
    if (!(ObjectAttributes->Attributes & OBJ_KERNEL_HANDLE))
    {
        return STATUS_INVALID_PARAMETER;
    }

    /*
     * Get rundown protection on the target to stop the owner
     * from unloading whilst this port object is open. It gets
     * removed in the FltpServerPortClose callback
     */
    Status = FltObjectReference(Filter);
    if (!NT_SUCCESS(Status))
    {
        return Status;
    }

    /* Create the server port object for this filter */
    Status = ObCreateObject(KernelMode,
                            ServerPortObjectType,
                            ObjectAttributes,
                            KernelMode,
                            NULL,
                            sizeof(FLT_SERVER_PORT_OBJECT),
                            0,
                            0,
                            (PVOID *)&PortObject);
    if (NT_SUCCESS(Status))
    {
        /* Zero out the struct */
        RtlZeroMemory(PortObject, sizeof(FLT_SERVER_PORT_OBJECT));

        /* Increment the ref count on the target filter */
        FltpObjectPointerReference((PFLT_OBJECT)Filter);

        /* Setup the filter port object */
        PortObject->Filter = Filter;
        PortObject->ConnectNotify = ConnectNotifyCallback;
        PortObject->DisconnectNotify = DisconnectNotifyCallback;
        PortObject->MessageNotify = MessageNotifyCallback;
        PortObject->Cookie = ServerPortCookie;
        PortObject->MaxConnections = MaxConnections;

        /* Insert the object */
        Status = ObInsertObject(PortObject,
                                NULL,
                                STANDARD_RIGHTS_ALL | FILE_READ_DATA,
                                0,
                                NULL,
                                (PHANDLE)ServerPort);
        if (NT_SUCCESS(Status))
        {
            /* Lock the connection list */
            ExAcquireFastMutex(&Filter->ConnectionList.mLock);

            /* Add the new port object to the connection list and increment the count */
            InsertTailList(&Filter->ConnectionList.mList, &PortObject->FilterLink);
            Filter->ConnectionList.mCount++;

            /* Unlock the connection list*/
            ExReleaseFastMutex(&Filter->ConnectionList.mLock);
        }
    }

    if (!NT_SUCCESS(Status))
    {
        /* Allow the filter to be cleaned up */
        FltObjectDereference(Filter);
    }

    return Status;
}

_IRQL_requires_max_() [3/3]

_Must_inspect_result_ _IRQL_requires_max_

(

APC_LEVEL

)

Definition at line 197 of file cddata.c.

{
    THREAD_CONTEXT ThreadContext = {0};
    PIRP_CONTEXT IrpContext = NULL;
    BOOLEAN Wait;

#ifdef CD_SANITY
    PVOID PreviousTopLevel;
#endif

    NTSTATUS Status;

#if DBG

    KIRQL SaveIrql = KeGetCurrentIrql();

#endif

    ASSERT_OPTIONAL_IRP( Irp );

    UNREFERENCED_PARAMETER( DeviceObject );

    FsRtlEnterFileSystem();

#ifdef CD_SANITY
    PreviousTopLevel = IoGetTopLevelIrp();
#endif

    //
    //  Loop until this request has been completed or posted.
    //

    do {

        //
        //  Use a try-except to handle the exception cases.
        //

        _SEH2_TRY {

            //
            //  If the IrpContext is NULL then this is the first pass through
            //  this loop.
            //

            if (IrpContext == NULL) {

                //
                //  Decide if this request is waitable an allocate the IrpContext.
                //  If the file object in the stack location is NULL then this
                //  is a mount which is always waitable.  Otherwise we look at
                //  the file object flags.
                //

                if (IoGetCurrentIrpStackLocation( Irp )->FileObject == NULL) {

                    Wait = TRUE;

                } else {

                    Wait = CanFsdWait( Irp );
                }

                IrpContext = CdCreateIrpContext( Irp, Wait );

                //
                //  Update the thread context information.
                //

                CdSetThreadContext( IrpContext, &ThreadContext );

#ifdef CD_SANITY
                NT_ASSERT( !CdTestTopLevel ||
                        SafeNodeType( IrpContext->TopLevel ) == CDFS_NTC_IRP_CONTEXT );
#endif

            //
            //  Otherwise cleanup the IrpContext for the retry.
            //

            } else {

                //
                //  Set the MORE_PROCESSING flag to make sure the IrpContext
                //  isn't inadvertently deleted here.  Then cleanup the
                //  IrpContext to perform the retry.
                //

                SetFlag( IrpContext->Flags, IRP_CONTEXT_FLAG_MORE_PROCESSING );
                CdCleanupIrpContext( IrpContext, FALSE );
            }

            //
            //  Case on the major irp code.
            //

            switch (IrpContext->MajorFunction) {

            case IRP_MJ_CREATE :

                Status = CdCommonCreate( IrpContext, Irp );
                break;

            case IRP_MJ_CLOSE :

                Status = CdCommonClose( IrpContext, Irp );
                break;

            case IRP_MJ_READ :

                //
                //  If this is an Mdl complete request, don't go through
                //  common read.
                //

                if (FlagOn( IrpContext->MinorFunction, IRP_MN_COMPLETE )) {

                    Status = CdCompleteMdl( IrpContext, Irp );

                } else {

                    Status = CdCommonRead( IrpContext, Irp );
                }

                break;

            case IRP_MJ_WRITE :

                Status = CdCommonWrite( IrpContext, Irp );
                break;

            case IRP_MJ_QUERY_INFORMATION :

                Status = CdCommonQueryInfo( IrpContext, Irp );
                break;

            case IRP_MJ_SET_INFORMATION :

                Status = CdCommonSetInfo( IrpContext, Irp );
                break;

            case IRP_MJ_QUERY_VOLUME_INFORMATION :

                Status = CdCommonQueryVolInfo( IrpContext, Irp );
                break;

            case IRP_MJ_DIRECTORY_CONTROL :

                Status = CdCommonDirControl( IrpContext, Irp );
                break;

            case IRP_MJ_FILE_SYSTEM_CONTROL :

                Status = CdCommonFsControl( IrpContext, Irp );
                break;

            case IRP_MJ_DEVICE_CONTROL :

                Status = CdCommonDevControl( IrpContext, Irp );
                break;

            case IRP_MJ_LOCK_CONTROL :

                Status = CdCommonLockControl( IrpContext, Irp );
                break;

            case IRP_MJ_CLEANUP :

                Status = CdCommonCleanup( IrpContext, Irp );
                break;

            case IRP_MJ_PNP :

                Status = CdCommonPnp( IrpContext, Irp );
                break;

            case IRP_MJ_SHUTDOWN :
            
                Status = CdCommonShutdown( IrpContext, Irp );
                break;

            default :

                Status = STATUS_INVALID_DEVICE_REQUEST;
                CdCompleteRequest( IrpContext, Irp, Status );
            }

        } _SEH2_EXCEPT( CdExceptionFilter( IrpContext, _SEH2_GetExceptionInformation() )) {

            Status = CdProcessException( IrpContext, Irp, _SEH2_GetExceptionCode() );
        } _SEH2_END;

    } while (Status == STATUS_CANT_WAIT);

#ifdef CD_SANITY
    NT_ASSERT( !CdTestTopLevel ||
            (PreviousTopLevel == IoGetTopLevelIrp()) );
#endif

    FsRtlExitFileSystem();

    NT_ASSERT( SaveIrql == KeGetCurrentIrql( ));

    return Status;
}

_Out_writes_bytes_opt_()

_Must_inspect_result_ _Out_writes_bytes_opt_

(

NumberOfBytes

)

_Post_writable_byte_size_() [1/2]

_Must_inspect_result_ _Post_writable_byte_size_

(

NumberOfBytes

)

_Post_writable_byte_size_() [2/2]

_Post_writable_byte_size_

(

MemoryDescriptorList->

ByteCount

)

_When_()

_Must_inspect_result_ _When_	(	AccessMode	= =KernelMode,
		_IRQL_requires_max_(DISPATCH_LEVEL)
	)

BaseAddress()

_Must_inspect_result_ _At_* BaseAddress

(

Mem

)

MmCreateMdl()

NTKERNELAPI PMDL NTAPI MmCreateMdl	(	_Out_writes_bytes_opt_(sizeof(MDL)+(sizeof(PFN_NUMBER) *ADDRESS_AND_SIZE_TO_SPAN_PAGES(Base, Length))) PMDL	MemoryDescriptorList,
		_In_reads_bytes_opt_(Length) PVOID	Base,
		_In_ SIZE_T	Length
	)

MmGetPhysicalAddress()

NTKERNELAPI PHYSICAL_ADDRESS NTAPI MmGetPhysicalAddress

(

_In_ PVOID

BaseAddress

)

MmGetVirtualForPhysical()

NTKERNELAPI PVOID NTAPI MmGetVirtualForPhysical

(

_In_ PHYSICAL_ADDRESS

PhysicalAddress

)

MmIsDriverVerifying()

NTKERNELAPI LOGICAL NTAPI MmIsDriverVerifying

(

_In_ struct _DRIVER_OBJECT *

DriverObject

)

MmIsNonPagedSystemAddressValid()

NTKERNELAPI BOOLEAN NTAPI MmIsNonPagedSystemAddressValid

(

_In_ PVOID

VirtualAddress

)

MmIsThisAnNtAsSystem()

NTKERNELAPI BOOLEAN NTAPI MmIsThisAnNtAsSystem

(

VOID

)

Definition at line 246 of file mmsup.c.

{
    /* Return if this is a server system */
    return MmProductType & 0xFF;
}

Referenced by FsRtlInitializeTunnels(), PsChangeQuantumTable(), and UDFInitializeZones().

MmQuerySystemSize()

NTKERNELAPI MM_SYSTEMSIZE NTAPI MmQuerySystemSize

(

VOID

)

Definition at line 257 of file mmsup.c.

{
    /* Return the low, medium or high memory system type */
    return MmSystemSize;
}

Referenced by CcInitializeCacheManager(), CdInitializeGlobalData(), DriverEntry(), PspInitPhase0(), RxInitializeWorkQueueDispatcher(), and UDFInitializeZones().

MmSizeOfMdl()

NTKERNELAPI SIZE_T NTAPI MmSizeOfMdl	(	_In_reads_bytes_opt_(Length) PVOID	Base,
		_In_ SIZE_T	Length
	)

Variable Documentation

AccessMode

_In_opt_ PVOID _In_opt_ PUNICODE_STRING _In_ PSECURITY_DESCRIPTOR _In_ PACCESS_STATE _In_ BOOLEAN _In_ BOOLEAN _In_ KPROCESSOR_MODE AccessMode

Definition at line 395 of file mmfuncs.h.

Referenced by BuildExplicitAccessWithNameA(), BuildExplicitAccessWithNameW(), BuildImpersonateExplicitAccessWithNameA(), BuildImpersonateExplicitAccessWithNameW(), CmpConvertHandleToKernelHandle(), CmpCreateLinkNode(), CmpDoCreate(), CmpDoCreateChild(), CmpDoOpen(), CmpParseKey(), DosCreateFileEx(), DosOpenFile(), ExLockUserBuffer(), ExpDesktopOkToClose(), ExpWindowStationOkToClose(), ExpWinStaObjectParse(), FxProbeAndLockForRead(), FxProbeAndLockForWrite(), FxProbeAndLockWithAccess(), IntCreateDesktop(), IntCreateWindowStation(), IntValidateDesktopHandle(), IntValidateWindowStationHandle(), IopCreateFile(), IopParseDevice(), IopParseFile(), IopQueryAttributesFile(), MmMapLockedPages(), MmMapLockedPagesSpecifyCache(), MmProbeAndLockPages(), MockMmProbeAndLockPages(), MockObReferenceObjectByHandle(), Mx::MxReferenceObjectByHandle(), NtDeleteFile(), ObCheckCreateObjectAccess(), ObCheckObjectAccess(), ObCloseHandle(), ObCreateObject(), ObOpenObjectByName(), ObOpenObjectByPointer(), ObpCaptureObjectCreateInformation(), ObpCaptureObjectName(), ObpCheckObjectReference(), ObpCheckTraverseAccess(), ObpCloseHandle(), ObpCloseHandleTableEntry(), ObpCreateHandle(), ObpCreateUnnamedHandle(), ObpIncrementHandleCount(), ObpLookupObjectName(), ObpParseSymbolicLink(), ObpReferenceProcessObjectByHandle(), ObReferenceFileObjectForWrite(), ObReferenceObjectByHandle(), ObReferenceObjectByName(), ObReferenceObjectByPointer(), OkayToCloseProc(), ProbeAndCaptureObjectAttributes(), QueryNameProc(), ReleaseCapturedObjectAttributes(), SeAccessCheck(), SeFastTraverseCheck(), SeOpenObjectAuditAlarm(), SepCaptureAcl(), SepCaptureSecurityQualityOfService(), SepCaptureSid(), SepReleaseAcl(), SepReleaseSecurityQualityOfService(), SepReleaseSid(), SeReleaseSidAndAttributesArray(), WmipCaptureGuidObjectAttributes(), WmipOpenGuidObject(), and WmipOpenGuidObjectByName().

BoundaryAddressMultiple

_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_opt_ PHYSICAL_ADDRESS BoundaryAddressMultiple

Definition at line 214 of file mmfuncs.h.

Referenced by MmAllocateContiguousMemorySpecifyCache().

CacheType

_In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_ SIZE_T _In_ MEMORY_CACHING_TYPE CacheType

Definition at line 214 of file mmfuncs.h.

Referenced by DECLARE_INTERFACE_(), FxCmResList::MapIoSpaceWorker(), MiAllocateContiguousMemory(), MiFindContiguousMemory(), MiMapLockedPagesInUserSpace(), MmAllocateContiguousMemorySpecifyCache(), MmAllocatePagesForMdlEx(), MmMapIoSpace(), MmMapLockedPagesSpecifyCache(), MmMapVideoDisplay(), and TestMessageHandler().

Context

_Inout_ PSIZE_T _In_opt_ PMDLX _In_ MM_ROTATE_DIRECTION _In_ PMM_ROTATE_COPY_CALLBACK_FUNCTION _In_opt_ PVOID Context

Definition at line 772 of file mmfuncs.h.

CopyFunction

_Inout_ PSIZE_T _In_opt_ PMDLX _In_ MM_ROTATE_DIRECTION _In_ PMM_ROTATE_COPY_CALLBACK_FUNCTION CopyFunction

Definition at line 772 of file mmfuncs.h.

Referenced by HidParser_AddCollection(), HidParser_AddReportToCollection(), HidParser_GetScaledUsageValueWithReport(), HidParser_GetUsageValueWithReport(), HidParser_ParseReportDescriptor(), HidParser_ReserveReportItems(), and HidParser_StoreCollection().

DelayClose

_In_ BOOLEAN DelayClose

Definition at line 592 of file mmfuncs.h.

Direction

_Inout_ PSIZE_T _In_opt_ PMDLX _In_ MM_ROTATE_DIRECTION Direction

Definition at line 772 of file mmfuncs.h.

Flags

_In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_ SIZE_T _In_ MEMORY_CACHING_TYPE _In_ ULONG Flags

Definition at line 748 of file mmfuncs.h.

FlushType

_In_ MMFLUSH_TYPE FlushType

Definition at line 600 of file mmfuncs.h.

FreeType

__kernel_entry _Inout_ _Inout_ PSIZE_T _In_ ULONG FreeType

Definition at line 809 of file mmfuncs.h.

HighAddress

_In_ PHYSICAL_ADDRESS HighAddress

Definition at line 226 of file mmfuncs.h.

Referenced by DECLARE_INTERFACE_(), MiAllocatePagesForMdl(), MmAllocateNonCachedMemory(), MmAllocatePagesForMdl(), MmAllocatePagesForMdlEx(), and TestMmAllocatePagesForMdl().

HighestAcceptableAddress

_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS HighestAcceptableAddress

Definition at line 204 of file mmfuncs.h.

Length

_In_ SIZE_T Length

Definition at line 616 of file mmfuncs.h.

LowestAcceptableAddress

_Must_inspect_result_ _In_ PHYSICAL_ADDRESS LowestAcceptableAddress

Definition at line 214 of file mmfuncs.h.

Referenced by HalAllocateCommonBuffer(), HalpGrowMapBuffers(), and MmAllocateContiguousMemorySpecifyCache().

MappedBase

_Must_inspect_result_ _Outptr_result_bytebuffer_ ViewSize PVOID * MappedBase

Definition at line 492 of file mmfuncs.h.

Referenced by BlImgAllocateImageBuffer(), BlImgLoadImageWithProgress2(), BlMmMapPhysicalAddressEx(), MiMapViewInSystemSpace(), MiRosUnmapViewInSystemSpace(), MiUnmapViewInSystemSpace(), MmCommitSessionMappedView(), MmMapViewInSessionSpace(), MmMapViewInSystemSpace(), MmMapViewInSystemSpaceEx(), MmUnmapViewInSessionSpace(), MmUnmapViewInSystemSpace(), and RamdiskMapPages().

MemoryDescriptorList

_In_ ULONG _Inout_ PMDL MemoryDescriptorList

Definition at line 405 of file mmfuncs.h.

Referenced by CcMdlReadComplete2(), DECLARE_INTERFACE_(), FsRtlMdlReadCompleteDev(), and Mx::MxInitializeMdl().

NewFileSize

_In_opt_ PLARGE_INTEGER NewFileSize

Definition at line 608 of file mmfuncs.h.

Referenced by MmCanFileBeTruncated(), NtfsSetEndOfFile(), and UDFCommonCleanup().

NewMdl

_Inout_ PSIZE_T _In_opt_ PMDLX NewMdl

Definition at line 772 of file mmfuncs.h.

NewProtect

_Must_inspect_result_ _In_ ULONG NewProtect

Definition at line 682 of file mmfuncs.h.

Referenced by MiQueryMemoryBasicInformation(), MiSetProtectionOnSection(), MmAccessFaultSectionView(), MmAlterRegion(), MmAlterViewAttributes(), and MmSplitRegion().

NumberOfBytes

_Inout_ PSIZE_T NumberOfBytes

Definition at line 260 of file mmfuncs.h.

Operation

_In_ PEPROCESS _In_ KPROCESSOR_MODE _In_ LOCK_OPERATION Operation

Definition at line 395 of file mmfuncs.h.

PageAddress

_Must_inspect_result_ _In_ SIZE_T _In_ PVOID PageAddress

Definition at line 471 of file mmfuncs.h.

Referenced by MmAreMemoryPagesAvailable().

PoolTag

_In_ ULONG PoolTag

Definition at line 642 of file mmfuncs.h.

PreferredNode

_Must_inspect_result_ _In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_opt_ PHYSICAL_ADDRESS _In_ MEMORY_CACHING_TYPE _In_ NODE_REQUIREMENT PreferredNode

Definition at line 415 of file mmfuncs.h.

ProbeMode

_Must_inspect_result_ _In_ _In_ ULONG ProbeMode

Definition at line 561 of file mmfuncs.h.

Referenced by HackSecureVirtualMemory(), ObCreateObject(), and ObpIncrementHandleCount().

Process

_In_ PEPROCESS Process

Definition at line 395 of file mmfuncs.h.

RegionSize

__kernel_entry _Inout_ _Inout_ PSIZE_T RegionSize

Definition at line 809 of file mmfuncs.h.

SkipBytes

_In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS SkipBytes

Definition at line 226 of file mmfuncs.h.

Referenced by IsDataUnicode(), MiAllocatePagesForMdl(), MmAllocateNonCachedMemory(), MmAllocatePagesForMdl(), MmAllocatePagesForMdlEx(), TestMmAllocatePagesForMdl(), and wmain().

Tag

_In_ ULONG Tag

Initial value:

{
  
  return ((ULONG)((TagBase) + ((Tag) << HEAP_TAG_SHIFT)))

Definition at line 188 of file mmfuncs.h.

ThunkBufferSize

_In_ ULONG ThunkBufferSize

Definition at line 699 of file mmfuncs.h.

Referenced by MmAddVerifierThunks().

TotalBytes

_In_ PHYSICAL_ADDRESS _In_ PHYSICAL_ADDRESS _In_ SIZE_T TotalBytes

Definition at line 226 of file mmfuncs.h.

Referenced by CookupNodeId(), DECLARE_INTERFACE_(), MiAllocatePagesForMdl(), MmAllocatePagesForMdl(), and MmAllocatePagesForMdlEx().

ViewSize

_Must_inspect_result_ _Outptr_result_bytebuffer_ ViewSize PVOID _Inout_ PSIZE_T ViewSize

Definition at line 492 of file mmfuncs.h.