memres.c File Reference

#include <rtl.h>
#include <debug.h>

Include dependency graph for memres.c:

Go to the source code of this file.

Macros
#define	NDEBUG

Functions
static ULONGLONG	RtlpDecodeMemIoValue (_In_ UCHAR Type, _In_ USHORT Flags, _In_ ULONG Encoded)
ULONGLONG NTAPI	RtlCmDecodeMemIoResource (_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, _Out_opt_ PULONGLONG Start)
ULONGLONG NTAPI	RtlIoDecodeMemIoResource (_In_ PIO_RESOURCE_DESCRIPTOR Descriptor, _Out_opt_ PULONGLONG Alignment, _Out_opt_ PULONGLONG MinimumAddress, _Out_opt_ PULONGLONG MaximumAddress)
NTSTATUS NTAPI	RtlCmEncodeMemIoResource (_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor, _In_ UCHAR Type, _In_ ULONGLONG Length, _In_ ULONGLONG Start)
static BOOLEAN	RtlpEncodeLargeAlignment (_In_ ULONGLONG Alignment, _In_ ULONG Shift, _Out_ PULONG Encoded)
NTSTATUS NTAPI	RtlIoEncodeMemIoResource (_In_ PIO_RESOURCE_DESCRIPTOR Descriptor, _In_ UCHAR Type, _In_ ULONGLONG Length, _In_ ULONGLONG Alignment, _In_ ULONGLONG MinimumAddress, _In_ ULONGLONG MaximumAddress)
NTSTATUS NTAPI	RtlFindClosestEncodableLength (_In_ ULONGLONG SourceLength, _Out_ PULONGLONG TargetLength)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 12 of file memres.c.

Function Documentation

RtlCmDecodeMemIoResource()

ULONGLONG NTAPI RtlCmDecodeMemIoResource	(	_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR	Descriptor,
		_Out_opt_ PULONGLONG	Start
	)

Definition at line 58 of file memres.c.

{
    if (Start != NULL)
        *Start = Descriptor->u.Generic.Start.QuadPart;
 
    return RtlpDecodeMemIoValue(Descriptor->Type,
                                Descriptor->Flags,
                                Descriptor->u.Generic.Length);
}

Referenced by IopArbMemUnpackResource(), and IopArbPortUnpackResource().

RtlCmEncodeMemIoResource()

NTSTATUS NTAPI RtlCmEncodeMemIoResource	(	_In_ PCM_PARTIAL_RESOURCE_DESCRIPTOR	Descriptor,
		_In_ UCHAR	Type,
		_In_ ULONGLONG	Length,
		_In_ ULONGLONG	Start
	)

Definition at line 116 of file memres.c.

{
    if (Type != CmResourceTypePort &&
        Type != CmResourceTypeMemory &&
        Type != CmResourceTypeMemoryLarge)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* A port descriptor has only a 32-bit length and no large form. */
    if (Type == CmResourceTypePort)
    {
        if (Length > MAXULONG)
            return STATUS_INVALID_PARAMETER;
 
        Descriptor->Type = CmResourceTypePort;
        Descriptor->u.Generic.Start.QuadPart = Start;
        Descriptor->u.Generic.Length = (ULONG)Length;
        return STATUS_SUCCESS;
    }
 
    /* Drop any stale large-form flags and record the start address. */
    Descriptor->Flags &= ~CM_RESOURCE_MEMORY_LARGE;
    Descriptor->u.Generic.Start.QuadPart = Start;
 
    /* A length that fits 32 bits stays a plain memory descriptor. */
    if (Length <= MAXULONG)
    {
        Descriptor->Type = CmResourceTypeMemory;
        Descriptor->u.Generic.Length = (ULONG)Length;
        return STATUS_SUCCESS;
    }
 
    /* Otherwise pick the tightest large form whose dropped low bits are zero. */
    if (Length <= ((ULONGLONG)MAXULONG << 8) && (Length & 0xFF) == 0)
    {
        Descriptor->u.Generic.Length = (ULONG)(Length >> 8);
        Descriptor->Flags |= CM_RESOURCE_MEMORY_LARGE_40;
    }
    else if (Length <= ((ULONGLONG)MAXULONG << 16) && (Length & 0xFFFF) == 0)
    {
        Descriptor->u.Generic.Length = (ULONG)(Length >> 16);
        Descriptor->Flags |= CM_RESOURCE_MEMORY_LARGE_48;
    }
    else if (Length <= ((ULONGLONG)MAXULONG << 32) && (Length & 0xFFFFFFFF) == 0)
    {
        Descriptor->u.Generic.Length = (ULONG)(Length >> 32);
        Descriptor->Flags |= CM_RESOURCE_MEMORY_LARGE_64;
    }
    else
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    Descriptor->Type = CmResourceTypeMemoryLarge;
    return STATUS_SUCCESS;
}

RtlFindClosestEncodableLength()

NTSTATUS NTAPI RtlFindClosestEncodableLength	(	_In_ ULONGLONG	SourceLength,
		_Out_ PULONGLONG	TargetLength
	)

Definition at line 310 of file memres.c.

{
    if (SourceLength <= MAXULONG)
        *TargetLength = SourceLength;
    else if (SourceLength <= ((ULONGLONG)MAXULONG << 8))
        *TargetLength = (SourceLength + 0xFF) & ~(ULONGLONG)0xFF;
    else if (SourceLength <= ((ULONGLONG)MAXULONG << 16))
        *TargetLength = (SourceLength + 0xFFFF) & ~(ULONGLONG)0xFFFF;
    else if (SourceLength <= ((ULONGLONG)MAXULONG << 32))
        *TargetLength = (SourceLength + 0xFFFFFFFF) & ~(ULONGLONG)0xFFFFFFFF;
    else
    {
        *TargetLength = 0;
        return STATUS_UNSUCCESSFUL;
    }
 
    return STATUS_SUCCESS;
}

RtlIoDecodeMemIoResource()

ULONGLONG NTAPI RtlIoDecodeMemIoResource	(	_In_ PIO_RESOURCE_DESCRIPTOR	Descriptor,
		_Out_opt_ PULONGLONG	Alignment,
		_Out_opt_ PULONGLONG	MinimumAddress,
		_Out_opt_ PULONGLONG	MaximumAddress
	)

Definition at line 79 of file memres.c.

{
    if (Alignment != NULL)
    {
        *Alignment = RtlpDecodeMemIoValue(Descriptor->Type,
                                          Descriptor->Flags,
                                          Descriptor->u.Generic.Alignment);
    }
 
    if (MinimumAddress != NULL)
        *MinimumAddress = Descriptor->u.Generic.MinimumAddress.QuadPart;
 
    if (MaximumAddress != NULL)
        *MaximumAddress = Descriptor->u.Generic.MaximumAddress.QuadPart;
 
    return RtlpDecodeMemIoValue(Descriptor->Type,
                                Descriptor->Flags,
                                Descriptor->u.Generic.Length);
}

Referenced by IopArbMemScoreRequirement(), IopArbMemUnpackRequirements(), IopArbPortScoreRequirement(), and IopArbPortUnpackRequirements().

RtlIoEncodeMemIoResource()

NTSTATUS NTAPI RtlIoEncodeMemIoResource	(	_In_ PIO_RESOURCE_DESCRIPTOR	Descriptor,
		_In_ UCHAR	Type,
		_In_ ULONGLONG	Length,
		_In_ ULONGLONG	Alignment,
		_In_ ULONGLONG	MinimumAddress,
		_In_ ULONGLONG	MaximumAddress
	)

Definition at line 215 of file memres.c.

{
    ULONG Shift;
    USHORT LargeFlag;
 
    if (Type != CmResourceTypePort &&
        Type != CmResourceTypeMemory &&
        Type != CmResourceTypeMemoryLarge)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* A port descriptor is limited to 32-bit length and alignment. */
    if (Type == CmResourceTypePort)
    {
        if (Length > MAXULONG || Alignment > MAXULONG)
            return STATUS_INVALID_PARAMETER;
 
        Descriptor->Type = CmResourceTypePort;
        Descriptor->u.Generic.MinimumAddress.QuadPart = MinimumAddress;
        Descriptor->u.Generic.MaximumAddress.QuadPart = MaximumAddress;
        Descriptor->u.Generic.Length = (ULONG)Length;
        Descriptor->u.Generic.Alignment = (ULONG)Alignment;
        return STATUS_SUCCESS;
    }
 
    /* Memory: reset any stale large-form flags and record the address bounds. */
    Descriptor->Flags &= ~CM_RESOURCE_MEMORY_LARGE;
    Descriptor->u.Generic.MinimumAddress.QuadPart = MinimumAddress;
    Descriptor->u.Generic.MaximumAddress.QuadPart = MaximumAddress;
 
    /* Both values fit 32 bits: a plain memory descriptor. */
    if (Length <= MAXULONG && Alignment <= MAXULONG)
    {
        Descriptor->Type = CmResourceTypeMemory;
        Descriptor->u.Generic.Length = (ULONG)Length;
        Descriptor->u.Generic.Alignment = (ULONG)Alignment;
        return STATUS_SUCCESS;
    }
 
    /* Select the large form from the length; the alignment must fit that tier. */
    if (Length <= ((ULONGLONG)MAXULONG << 8))
    {
        if (Alignment > ((ULONGLONG)MAXULONG << 8))
            return STATUS_UNSUCCESSFUL;
 
        Shift = 8;
        LargeFlag = CM_RESOURCE_MEMORY_LARGE_40;
    }
    else if (Length <= ((ULONGLONG)MAXULONG << 16))
    {
        if (Alignment > ((ULONGLONG)MAXULONG << 16))
            return STATUS_UNSUCCESSFUL;
 
        Shift = 16;
        LargeFlag = CM_RESOURCE_MEMORY_LARGE_48;
    }
    else if (Length <= ((ULONGLONG)MAXULONG << 32))
    {
        Shift = 32;
        LargeFlag = CM_RESOURCE_MEMORY_LARGE_64;
    }
    else
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    /* The length must be exactly representable at this granularity. */
    if ((Length & (((ULONGLONG)1 << Shift) - 1)) != 0)
        return STATUS_UNSUCCESSFUL;
 
    if (!RtlpEncodeLargeAlignment(Alignment, Shift, &Descriptor->u.Generic.Alignment))
        return STATUS_UNSUCCESSFUL;
 
    Descriptor->Type = CmResourceTypeMemoryLarge;
    Descriptor->u.Generic.Length = (ULONG)(Length >> Shift);
    Descriptor->Flags |= LargeFlag;
    return STATUS_SUCCESS;
}

RtlpDecodeMemIoValue()

static ULONGLONG RtlpDecodeMemIoValue ( _In_ UCHAR  Type, _In_ USHORT  Flags, _In_ ULONG  Encoded  )

static

Definition at line 30 of file memres.c.

{
    if (Type == CmResourceTypePort || Type == CmResourceTypeMemory)
        return Encoded;
 
    if (Flags & CM_RESOURCE_MEMORY_LARGE_40)
        return (ULONGLONG)Encoded << 8;
 
    if (Flags & CM_RESOURCE_MEMORY_LARGE_48)
        return (ULONGLONG)Encoded << 16;
 
    if (Flags & CM_RESOURCE_MEMORY_LARGE_64)
        return (ULONGLONG)Encoded << 32;
 
    return 0;
}

Referenced by RtlCmDecodeMemIoResource(), and RtlIoDecodeMemIoResource().

RtlpEncodeLargeAlignment()

static BOOLEAN RtlpEncodeLargeAlignment ( _In_ ULONGLONG  Alignment, _In_ ULONG  Shift, _Out_ PULONG  Encoded  )

static

Definition at line 184 of file memres.c.

{
    ULONGLONG LowMask = ((ULONGLONG)1 << Shift) - 1;
 
    while ((Alignment & LowMask) != 0)
    {
        ULONGLONG Doubled = Alignment << 1;
 
        if (Doubled < Alignment)   /* overflowed past 64 bits */
            return FALSE;
 
        Alignment = Doubled;
    }
 
    *Encoded = (ULONG)(Alignment >> Shift);
    return TRUE;
}

Referenced by RtlIoEncodeMemIoResource().