rangelist.c File Reference

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

Include dependency graph for rangelist.c:

Go to the source code of this file.

Classes
struct	_RTL_RANGE_ENTRY

Macros
#define	NDEBUG

Typedefs
typedef struct _RTL_RANGE_ENTRY	RTL_RANGE_ENTRY
typedef struct _RTL_RANGE_ENTRY *	PRTL_RANGE_ENTRY

Functions
static BOOLEAN	RtlpOverlaps (_In_ ULONGLONG Start1, _In_ ULONGLONG End1, _In_ ULONGLONG Start2, _In_ ULONGLONG End2)
static BOOLEAN	RtlpWindowIsAvailable (_In_ PRTL_RANGE_LIST RangeList, _In_ ULONGLONG Start, _In_ ULONGLONG End, _In_ ULONG Flags, _In_ UCHAR AttributeAvailableMask, _In_opt_ PVOID Context, _In_opt_ PRTL_CONFLICT_RANGE_CALLBACK Callback, _Out_opt_ PULONGLONG ConflictStart)
static BOOLEAN	RtlpConflictsOnAdd (_In_ PRTL_RANGE_LIST RangeList, _In_ ULONGLONG Start, _In_ ULONGLONG End, _In_ ULONG Flags)
NTSTATUS NTAPI	RtlAddRange (IN OUT PRTL_RANGE_LIST RangeList, IN ULONGLONG Start, IN ULONGLONG End, IN UCHAR Attributes, IN ULONG Flags, IN PVOID UserData OPTIONAL, IN PVOID Owner OPTIONAL)
NTSTATUS NTAPI	RtlCopyRangeList (OUT PRTL_RANGE_LIST CopyRangeList, IN PRTL_RANGE_LIST RangeList)
NTSTATUS NTAPI	RtlDeleteOwnersRanges (IN OUT PRTL_RANGE_LIST RangeList, IN PVOID Owner)
NTSTATUS NTAPI	RtlDeleteRange (IN OUT PRTL_RANGE_LIST RangeList, IN ULONGLONG Start, IN ULONGLONG End, IN PVOID Owner)
NTSTATUS NTAPI	RtlFindRange (IN PRTL_RANGE_LIST RangeList, IN ULONGLONG Minimum, IN ULONGLONG Maximum, IN ULONG Length, IN ULONG Alignment, IN ULONG Flags, IN UCHAR AttributeAvailableMask, IN PVOID Context OPTIONAL, IN PRTL_CONFLICT_RANGE_CALLBACK Callback OPTIONAL, OUT PULONGLONG Start)
VOID NTAPI	RtlFreeRangeList (IN PRTL_RANGE_LIST RangeList)
NTSTATUS NTAPI	RtlGetFirstRange (IN PRTL_RANGE_LIST RangeList, OUT PRTL_RANGE_LIST_ITERATOR Iterator, OUT PRTL_RANGE *Range)
NTSTATUS NTAPI	RtlGetLastRange (IN PRTL_RANGE_LIST RangeList, OUT PRTL_RANGE_LIST_ITERATOR Iterator, OUT PRTL_RANGE *Range)
NTSTATUS NTAPI	RtlGetNextRange (IN OUT PRTL_RANGE_LIST_ITERATOR Iterator, OUT PRTL_RANGE *Range, IN BOOLEAN MoveForwards)
VOID NTAPI	RtlInitializeRangeList (IN OUT PRTL_RANGE_LIST RangeList)
NTSTATUS NTAPI	RtlInvertRangeListEx (OUT PRTL_RANGE_LIST InvertedRangeList, IN PRTL_RANGE_LIST RangeList, IN UCHAR Attributes, IN PVOID UserData OPTIONAL, IN PVOID Owner OPTIONAL)
NTSTATUS NTAPI	RtlInvertRangeList (OUT PRTL_RANGE_LIST InvertedRangeList, IN PRTL_RANGE_LIST RangeList)
NTSTATUS NTAPI	RtlIsRangeAvailable (IN PRTL_RANGE_LIST RangeList, IN ULONGLONG Start, IN ULONGLONG End, IN ULONG Flags, IN UCHAR AttributeAvailableMask, IN PVOID Context OPTIONAL, IN PRTL_CONFLICT_RANGE_CALLBACK Callback OPTIONAL, OUT PBOOLEAN Available)
NTSTATUS NTAPI	RtlMergeRangeLists (OUT PRTL_RANGE_LIST MergedRangeList, IN PRTL_RANGE_LIST RangeList1, IN PRTL_RANGE_LIST RangeList2, IN ULONG Flags)

Macro Definition Documentation

NDEBUG

#define NDEBUG

Definition at line 13 of file rangelist.c.

Typedef Documentation

PRTL_RANGE_ENTRY

typedef struct _RTL_RANGE_ENTRY * PRTL_RANGE_ENTRY

RTL_RANGE_ENTRY

typedef struct _RTL_RANGE_ENTRY RTL_RANGE_ENTRY

Function Documentation

RtlAddRange()

NTSTATUS NTAPI RtlAddRange	(	IN OUT PRTL_RANGE_LIST	RangeList,
		IN ULONGLONG	Start,
		IN ULONGLONG	End,
		IN UCHAR	Attributes,
		IN ULONG	Flags,
		IN PVOID UserData	OPTIONAL,
		IN PVOID Owner	OPTIONAL
	)

Definition at line 187 of file rangelist.c.

{
    PRTL_RANGE_ENTRY RangeEntry;
    //PRTL_RANGE_ENTRY Previous;
    PRTL_RANGE_ENTRY Current;
    PLIST_ENTRY Entry;
 
    if (Start > End)
        return STATUS_INVALID_PARAMETER;
 
    /*
     * Unless the caller explicitly allows adding on top of a conflict, reject
     * a range that overlaps an incompatible existing entry.
     */
    if (!(Flags & RTL_RANGE_LIST_ADD_IF_CONFLICT) &&
        RtlpConflictsOnAdd(RangeList, Start, End, Flags))
    {
        return STATUS_RANGE_LIST_CONFLICT;
    }
 
    /* Create new range entry */
    RangeEntry = RtlpAllocateMemory(sizeof(RTL_RANGE_ENTRY), 'elRR');
    if (RangeEntry == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Initialize range entry */
    RangeEntry->Range.Start = Start;
    RangeEntry->Range.End = End;
    RangeEntry->Range.Attributes = Attributes;
    RangeEntry->Range.UserData = UserData;
    RangeEntry->Range.Owner = Owner;
 
    RangeEntry->Range.Flags = 0;
    if (Flags & RTL_RANGE_LIST_ADD_SHARED)
        RangeEntry->Range.Flags |= RTL_RANGE_SHARED;
 
    /* Insert range entry */
    if (RangeList->Count == 0)
    {
        InsertTailList(&RangeList->ListHead,
                       &RangeEntry->Entry);
        RangeList->Count++;
        RangeList->Stamp++;
        return STATUS_SUCCESS;
    }
    else
    {
         //Previous = NULL;
        Entry = RangeList->ListHead.Flink;
        while (Entry != &RangeList->ListHead)
        {
            Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
            if (Current->Range.Start > RangeEntry->Range.Start)
            {
                /* Insert before current */
                DPRINT("Insert before current\n");
                InsertTailList(&Current->Entry,
                               &RangeEntry->Entry);
 
                RangeList->Count++;
                RangeList->Stamp++;
                return STATUS_SUCCESS;
            }
 
            //Previous = Current;
            Entry = Entry->Flink;
        }
 
        DPRINT("Insert tail\n");
        InsertTailList(&RangeList->ListHead,
                       &RangeEntry->Entry);
        RangeList->Count++;
        RangeList->Stamp++;
        return STATUS_SUCCESS;
    }
 
    RtlpFreeMemory(RangeEntry, 0);
 
    return STATUS_UNSUCCESSFUL;
}

Referenced by RtlInvertRangeListEx(), and RtlMergeRangeLists().

RtlCopyRangeList()

NTSTATUS NTAPI RtlCopyRangeList	(	OUT PRTL_RANGE_LIST	CopyRangeList,
		IN PRTL_RANGE_LIST	RangeList
	)

Definition at line 293 of file rangelist.c.

{
    PRTL_RANGE_ENTRY Current;
    PRTL_RANGE_ENTRY NewEntry;
    PLIST_ENTRY Entry;
 
    CopyRangeList->Flags = RangeList->Flags;
 
    Entry = RangeList->ListHead.Flink;
    while (Entry != &RangeList->ListHead)
    {
        Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
 
        NewEntry = RtlpAllocateMemory(sizeof(RTL_RANGE_ENTRY), 'elRR');
        if (NewEntry == NULL)
            return STATUS_INSUFFICIENT_RESOURCES;
 
        RtlCopyMemory(&NewEntry->Range,
                      &Current->Range,
                      sizeof(RTL_RANGE));
 
        InsertTailList(&CopyRangeList->ListHead,
                       &NewEntry->Entry);
 
        CopyRangeList->Count++;
 
        Entry = Entry->Flink;
    }
 
    CopyRangeList->Stamp++;
 
    return STATUS_SUCCESS;
}

Referenced by RtlMergeRangeLists().

RtlDeleteOwnersRanges()

NTSTATUS NTAPI RtlDeleteOwnersRanges	(	IN OUT PRTL_RANGE_LIST	RangeList,
		IN PVOID	Owner
	)

Definition at line 348 of file rangelist.c.

{
    PRTL_RANGE_ENTRY Current;
    PLIST_ENTRY Entry;
    PLIST_ENTRY Next;
 
    Entry = RangeList->ListHead.Flink;
    while (Entry != &RangeList->ListHead)
    {
        /* Capture the next link before we possibly free this entry */
        Next = Entry->Flink;
 
        Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
        if (Current->Range.Owner == Owner)
        {
            RemoveEntryList(Entry);
            RtlpFreeMemory(Current, 0);
 
            RangeList->Count--;
            RangeList->Stamp++;
        }
 
        Entry = Next;
    }
 
    return STATUS_SUCCESS;
}

RtlDeleteRange()

NTSTATUS NTAPI RtlDeleteRange	(	IN OUT PRTL_RANGE_LIST	RangeList,
		IN ULONGLONG	Start,
		IN ULONGLONG	End,
		IN PVOID	Owner
	)

Definition at line 398 of file rangelist.c.

{
    PRTL_RANGE_ENTRY Current;
    PLIST_ENTRY Entry;
 
    Entry = RangeList->ListHead.Flink;
    while (Entry != &RangeList->ListHead)
    {
        Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
        if (Current->Range.Start == Start &&
            Current->Range.End == End &&
            Current->Range.Owner == Owner)
        {
            RemoveEntryList(Entry);
 
            RtlpFreeMemory(Current, 0);
 
            RangeList->Count--;
            RangeList->Stamp++;
            return STATUS_SUCCESS;
        }
 
        Entry = Entry->Flink;
    }
 
    return STATUS_RANGE_NOT_FOUND;
}

RtlFindRange()

NTSTATUS NTAPI RtlFindRange	(	IN PRTL_RANGE_LIST	RangeList,
		IN ULONGLONG	Minimum,
		IN ULONGLONG	Maximum,
		IN ULONG	Length,
		IN ULONG	Alignment,
		IN ULONG	Flags,
		IN UCHAR	AttributeAvailableMask,
		IN PVOID Context	OPTIONAL,
		IN PRTL_CONFLICT_RANGE_CALLBACK Callback	OPTIONAL,
		OUT PULONGLONG	Start
	)

Definition at line 458 of file rangelist.c.

{
    ULONGLONG Candidate;
    ULONGLONG CandidateEnd;
    ULONGLONG ConflictStart = 0;
 
    if (Alignment == 0 || Length == 0)
    {
        return STATUS_INVALID_PARAMETER;
    }
 
    /* A window of Length can only end at Maximum if it also fits below it */
    if ((ULONGLONG)(Length - 1) > Maximum)
    {
        return STATUS_RANGE_NOT_FOUND;
    }
 
    Candidate = (Maximum - (Length - 1)) & ~((ULONGLONG)Alignment - 1);
 
    for (;;)
    {
        if (Candidate < Minimum)
        {
            return STATUS_RANGE_NOT_FOUND;
        }
 
        CandidateEnd = Candidate + (Length - 1);
 
        if (RtlpWindowIsAvailable(RangeList,
                                  Candidate,
                                  CandidateEnd,
                                  Flags,
                                  AttributeAvailableMask,
                                  Context,
                                  Callback,
                                  &ConflictStart))
        {
            DPRINT("Found range: %I64x\n", Candidate);
            *Start = Candidate;
            return STATUS_SUCCESS;
        }
 
        /*
         * Jump the window entirely below the lowest conflicting entry.
         * Because that entry overlaps the current window, this strictly
         * decreases Candidate, so the loop always terminates.
         */
        if (ConflictStart == 0)
        {
            return STATUS_RANGE_NOT_FOUND;
        }
 
        if ((ULONGLONG)(Length - 1) > ConflictStart - 1)
        {
            return STATUS_RANGE_NOT_FOUND;
        }
 
        Candidate = ((ConflictStart - 1) - (Length - 1)) & ~((ULONGLONG)Alignment - 1);
    }
}

RtlFreeRangeList()

VOID NTAPI RtlFreeRangeList

(

IN PRTL_RANGE_LIST

RangeList

)

Definition at line 546 of file rangelist.c.

{
    PLIST_ENTRY Entry;
    PRTL_RANGE_ENTRY Current;
 
    while (!IsListEmpty(&RangeList->ListHead))
    {
        Entry = RemoveHeadList(&RangeList->ListHead);
        Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
 
        DPRINT ("Range start: %I64u\n", Current->Range.Start);
        DPRINT ("Range end:   %I64u\n", Current->Range.End);
 
        RtlpFreeMemory(Current, 0);
    }
 
    RangeList->Flags = 0;
    RangeList->Count = 0;
}

RtlGetFirstRange()

NTSTATUS NTAPI RtlGetFirstRange	(	IN PRTL_RANGE_LIST	RangeList,
		OUT PRTL_RANGE_LIST_ITERATOR	Iterator,
		OUT PRTL_RANGE *	Range
	)

Definition at line 586 of file rangelist.c.

{
    Iterator->RangeListHead = &RangeList->ListHead;
    Iterator->MergedHead = NULL;
    Iterator->Stamp = RangeList->Stamp;
 
    if (IsListEmpty(&RangeList->ListHead))
    {
        Iterator->Current = NULL;
        *Range = NULL;
        return STATUS_NO_MORE_ENTRIES;
    }
 
    *Range = &CONTAINING_RECORD(RangeList->ListHead.Flink, RTL_RANGE_ENTRY, Entry)->Range;
    Iterator->Current = *Range;
 
    return STATUS_SUCCESS;
}

Referenced by RtlMergeRangeLists().

RtlGetLastRange()

NTSTATUS NTAPI RtlGetLastRange	(	IN PRTL_RANGE_LIST	RangeList,
		OUT PRTL_RANGE_LIST_ITERATOR	Iterator,
		OUT PRTL_RANGE *	Range
	)

Definition at line 628 of file rangelist.c.

{
    Iterator->RangeListHead = &RangeList->ListHead;
    Iterator->MergedHead = NULL;
    Iterator->Stamp = RangeList->Stamp;
 
    if (IsListEmpty(&RangeList->ListHead))
    {
        Iterator->Current = NULL;
        *Range = NULL;
        return STATUS_NO_MORE_ENTRIES;
    }
 
    *Range = &CONTAINING_RECORD(RangeList->ListHead.Blink, RTL_RANGE_ENTRY, Entry)->Range;
    Iterator->Current = *Range;
 
    return STATUS_SUCCESS;
}

RtlGetNextRange()

NTSTATUS NTAPI RtlGetNextRange	(	IN OUT PRTL_RANGE_LIST_ITERATOR	Iterator,
		OUT PRTL_RANGE *	Range,
		IN BOOLEAN	MoveForwards
	)

Definition at line 670 of file rangelist.c.

{
    PRTL_RANGE_LIST RangeList;
    PRTL_RANGE_ENTRY Current;
    PLIST_ENTRY Next;
 
    RangeList = CONTAINING_RECORD(Iterator->RangeListHead, RTL_RANGE_LIST, ListHead);
    if (Iterator->Stamp != RangeList->Stamp)
        return STATUS_INVALID_PARAMETER;
 
    if (Iterator->Current == NULL)
    {
        *Range = NULL;
        return STATUS_NO_MORE_ENTRIES;
    }
 
    /* Iterator->Current points at the RTL_RANGE; recover its entry */
    Current = CONTAINING_RECORD(Iterator->Current, RTL_RANGE_ENTRY, Range);
    if (MoveForwards)
    {
        Next = Current->Entry.Flink;
    }
    else
    {
        Next = Current->Entry.Blink;
    }
 
    if (Next == Iterator->RangeListHead)
    {
        Iterator->Current = NULL;
        *Range = NULL;
        return STATUS_NO_MORE_ENTRIES;
    }
 
    *Range = &CONTAINING_RECORD(Next, RTL_RANGE_ENTRY, Entry)->Range;
    Iterator->Current = *Range;
 
    return STATUS_SUCCESS;
}

Referenced by RtlMergeRangeLists().

RtlInitializeRangeList()

VOID NTAPI RtlInitializeRangeList

(

IN OUT PRTL_RANGE_LIST

RangeList

)

Definition at line 730 of file rangelist.c.

{
    InitializeListHead(&RangeList->ListHead);
    RangeList->Flags = 0;
    RangeList->Count = 0;
    RangeList->Stamp = 0;
}

RtlInvertRangeList()

NTSTATUS NTAPI RtlInvertRangeList	(	OUT PRTL_RANGE_LIST	InvertedRangeList,
		IN PRTL_RANGE_LIST	RangeList
	)

Definition at line 874 of file rangelist.c.

{
    return RtlInvertRangeListEx(InvertedRangeList,
                                RangeList,
                                0,
                                NULL,
                                NULL);
}

RtlInvertRangeListEx()

NTSTATUS NTAPI RtlInvertRangeListEx	(	OUT PRTL_RANGE_LIST	InvertedRangeList,
		IN PRTL_RANGE_LIST	RangeList,
		IN UCHAR	Attributes,
		IN PVOID UserData	OPTIONAL,
		IN PVOID Owner	OPTIONAL
	)

Definition at line 761 of file rangelist.c.

{
    PRTL_RANGE_ENTRY Current;
    PLIST_ENTRY Entry;
    ULONGLONG GapStart;
    NTSTATUS Status;
 
    /*
     * The list is sorted by ascending Start, but RtlAddRange permits
     * overlapping entries (RTL_RANGE_LIST_ADD_IF_CONFLICT)
     *
     * Whenever two ranges overlap:
     * walk the covered address space upward from 0: grab every range that
     * covers the current position... so we can emit the gap up to the next range that
     * starts beyond it.
     */
    GapStart = (ULONGLONG)0;
 
    for (;;)
    {
        ULONGLONG NextStart;
        BOOLEAN Absorbed;
        BOOLEAN Found;
 
        /* Advance GapStart past every range that covers it (handles overlaps). */
        do
        {
            Absorbed = FALSE;
            Entry = RangeList->ListHead.Flink;
            while (Entry != &RangeList->ListHead)
            {
                Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
                if (Current->Range.Start <= GapStart &&
                    Current->Range.End >= GapStart)
                {
                    /* Covered all the way to the top: no gap remains. */
                    if (Current->Range.End == (ULONGLONG)-1)
                        return STATUS_SUCCESS;
 
                    GapStart = Current->Range.End + 1;
                    Absorbed = TRUE;
                }
                Entry = Entry->Flink;
            }
        }
        while (Absorbed);
 
        /* GapStart is now uncovered; find the nearest range starting above it. */
        NextStart = (ULONGLONG)-1;
        Found = FALSE;
        Entry = RangeList->ListHead.Flink;
        while (Entry != &RangeList->ListHead)
        {
            Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
            if (Current->Range.Start > GapStart &&
                Current->Range.Start <= NextStart)
            {
                NextStart = Current->Range.Start;
                Found = TRUE;
            }
            Entry = Entry->Flink;
        }
 
        /* No further ranges: the gap runs to the top of the address space. */
        if (!Found)
        {
            return RtlAddRange(InvertedRangeList,
                               GapStart,
                               (ULONGLONG)-1,
                               Attributes,
                               RTL_RANGE_LIST_ADD_IF_CONFLICT,
                               UserData,
                               Owner);
        }
 
        Status = RtlAddRange(InvertedRangeList,
                             GapStart,
                             NextStart - 1,
                             Attributes,
                             RTL_RANGE_LIST_ADD_IF_CONFLICT,
                             UserData,
                             Owner);
        if (!NT_SUCCESS(Status))
            return Status;
 
        /* Resume from the next covered region. */
        GapStart = NextStart;
    }
}

Referenced by RtlInvertRangeList().

RtlIsRangeAvailable()

NTSTATUS NTAPI RtlIsRangeAvailable	(	IN PRTL_RANGE_LIST	RangeList,
		IN ULONGLONG	Start,
		IN ULONGLONG	End,
		IN ULONG	Flags,
		IN UCHAR	AttributeAvailableMask,
		IN PVOID Context	OPTIONAL,
		IN PRTL_CONFLICT_RANGE_CALLBACK Callback	OPTIONAL,
		OUT PBOOLEAN	Available
	)

Definition at line 909 of file rangelist.c.

{
    if (Start > End)
        return STATUS_INVALID_PARAMETER;
 
    *Available = RtlpWindowIsAvailable(RangeList,
                                       Start,
                                       End,
                                       Flags,
                                       AttributeAvailableMask,
                                       Context,
                                       Callback,
                                       NULL);
 
    return STATUS_SUCCESS;
}

RtlMergeRangeLists()

NTSTATUS NTAPI RtlMergeRangeLists	(	OUT PRTL_RANGE_LIST	MergedRangeList,
		IN PRTL_RANGE_LIST	RangeList1,
		IN PRTL_RANGE_LIST	RangeList2,
		IN ULONG	Flags
	)

Definition at line 954 of file rangelist.c.

{
    RTL_RANGE_LIST_ITERATOR Iterator;
    PRTL_RANGE Range;
    NTSTATUS Status;
 
    /* Copy range list 1 to the merged range list */
    Status = RtlCopyRangeList(MergedRangeList,
                              RangeList1);
    if (!NT_SUCCESS(Status))
        return Status;
 
    /* Add range list 2 entries to the merged range list */
    Status = RtlGetFirstRange(RangeList2,
                              &Iterator,
                              &Range);
    if (!NT_SUCCESS(Status))
        return (Status == STATUS_NO_MORE_ENTRIES) ? STATUS_SUCCESS : Status;
 
    while (TRUE)
    {
        Status = RtlAddRange(MergedRangeList,
                             Range->Start,
                             Range->End,
                             Range->Attributes,
                             Range->Flags | Flags,
                             Range->UserData,
                             Range->Owner);
        if (!NT_SUCCESS(Status))
            break;
 
        Status = RtlGetNextRange(&Iterator,
                                 &Range,
                                 TRUE);
        if (!NT_SUCCESS(Status))
            break;
    }
 
    return (Status == STATUS_NO_MORE_ENTRIES) ? STATUS_SUCCESS : Status;
}

RtlpConflictsOnAdd()

static BOOLEAN RtlpConflictsOnAdd ( _In_ PRTL_RANGE_LIST  RangeList, _In_ ULONGLONG  Start, _In_ ULONGLONG  End, _In_ ULONG  Flags  )

static

Definition at line 131 of file rangelist.c.

{
    PLIST_ENTRY Entry;
 
    for (Entry = RangeList->ListHead.Flink;
         Entry != &RangeList->ListHead;
         Entry = Entry->Flink)
    {
        PRTL_RANGE_ENTRY Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
 
        if (Current->Range.Start > End)
            break;
 
        if (!RtlpOverlaps(Start, End, Current->Range.Start, Current->Range.End))
            continue;
 
        /* Overlapping shared ranges may coexist */
        if ((Flags & RTL_RANGE_LIST_ADD_SHARED) &&
            (Current->Range.Flags & RTL_RANGE_SHARED))
            continue;
 
        return TRUE;
    }
 
    return FALSE;
}

Referenced by RtlAddRange().

RtlpOverlaps()

static BOOLEAN RtlpOverlaps ( _In_ ULONGLONG  Start1, _In_ ULONGLONG  End1, _In_ ULONGLONG  Start2, _In_ ULONGLONG  End2  )

static

Definition at line 36 of file rangelist.c.

{
    return (Start1 <= End2 && Start2 <= End1);
}

Referenced by RtlpConflictsOnAdd(), and RtlpWindowIsAvailable().

RtlpWindowIsAvailable()

static BOOLEAN RtlpWindowIsAvailable ( _In_ PRTL_RANGE_LIST  RangeList, _In_ ULONGLONG  Start, _In_ ULONGLONG  End, _In_ ULONG  Flags, _In_ UCHAR  AttributeAvailableMask, _In_opt_ PVOID  Context, _In_opt_ PRTL_CONFLICT_RANGE_CALLBACK  Callback, _Out_opt_ PULONGLONG  ConflictStart  )

static

Definition at line 64 of file rangelist.c.

{
    PLIST_ENTRY Entry;
    BOOLEAN Available = TRUE;
    ULONGLONG Lowest = 0;
 
    for (Entry = RangeList->ListHead.Flink;
         Entry != &RangeList->ListHead;
         Entry = Entry->Flink)
    {
        PRTL_RANGE_ENTRY Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
 
        if (Current->Range.Start > End)
            break;
 
        /* Ignore entries that do not overlap the requested window */
        if (!RtlpOverlaps(Start, End, Current->Range.Start, Current->Range.End))
            continue;
 
        /* An overlapping entry that is treated as available is not a conflict */
        if ((Flags & RTL_RANGE_LIST_SHARED_OK) &&
            (Current->Range.Flags & RTL_RANGE_SHARED))
            continue;
 
        if (AttributeAvailableMask & Current->Range.Attributes)
            continue;
 
        if ((Flags & RTL_RANGE_LIST_NULL_CONFLICT_OK) &&
            Current->Range.Owner == NULL)
            continue;
 
        /* provide callers the ability to change code paths before we make the range as unavailable. */
        if (Callback != NULL && Callback(Context, &Current->Range))
            continue;
 
        /* This is a real conflict */
        if (Available || Current->Range.Start < Lowest)
            Lowest = Current->Range.Start;
 
        Available = FALSE;
    }
 
    if (ConflictStart != NULL && !Available)
        *ConflictStart = Lowest;
 
    return Available;
}

Referenced by RtlFindRange(), and RtlIsRangeAvailable().