Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-06 19:52:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

[RTL]

Browse source 
Formatting, no code changes.

svn path=/trunk/; revision=55854
This commit is contained in:
Eric Kohl 2012-02-25 15:20:32 +00:00
parent 11c95e90a7
commit 0fa8a3b725
1 changed files with 368 additions and 354 deletions
Download patch file Download diff file Expand all files Collapse all files

722
reactos/lib/rtl/rangelist.c
View file

@ -47,82 +47,83 @@ typedef struct _RTL_RANGE_ENTRY
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlAddRange (IN OUT PRTL_RANGE_LIST RangeList, NTAPI
IN ULONGLONG Start, RtlAddRange(IN OUT PRTL_RANGE_LIST RangeList,
IN ULONGLONG End, IN ULONGLONG Start,
IN UCHAR Attributes, IN ULONGLONG End,
IN ULONG Flags, IN UCHAR Attributes,
IN PVOID UserData OPTIONAL, IN ULONG Flags,
IN PVOID Owner OPTIONAL) IN PVOID UserData OPTIONAL,
IN PVOID Owner OPTIONAL)
{ {
PRTL_RANGE_ENTRY RangeEntry; PRTL_RANGE_ENTRY RangeEntry;
//PRTL_RANGE_ENTRY Previous; //PRTL_RANGE_ENTRY Previous;
PRTL_RANGE_ENTRY Current; PRTL_RANGE_ENTRY Current;
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
if (Start > End) if (Start > End)
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
/* Create new range entry */ /* Create new range entry */
RangeEntry = RtlpAllocateMemory(sizeof(RTL_RANGE_ENTRY), 'elRR'); RangeEntry = RtlpAllocateMemory(sizeof(RTL_RANGE_ENTRY), 'elRR');
if (RangeEntry == NULL) if (RangeEntry == NULL)
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
/* Initialize range entry */ /* Initialize range entry */
RangeEntry->Range.Start = Start; RangeEntry->Range.Start = Start;
RangeEntry->Range.End = End; RangeEntry->Range.End = End;
RangeEntry->Range.Attributes = Attributes; RangeEntry->Range.Attributes = Attributes;
RangeEntry->Range.UserData = UserData; RangeEntry->Range.UserData = UserData;
RangeEntry->Range.Owner = Owner; RangeEntry->Range.Owner = Owner;
RangeEntry->Range.Flags = 0; RangeEntry->Range.Flags = 0;
if (Flags & RTL_RANGE_LIST_ADD_SHARED) if (Flags & RTL_RANGE_LIST_ADD_SHARED)
RangeEntry->Range.Flags |= RTL_RANGE_SHARED; RangeEntry->Range.Flags |= RTL_RANGE_SHARED;
/* Insert range entry */ /* Insert range entry */
if (RangeList->Count == 0) if (RangeList->Count == 0)
{ {
InsertTailList (&RangeList->ListHead, InsertTailList(&RangeList->ListHead,
&RangeEntry->Entry); &RangeEntry->Entry);
RangeList->Count++; RangeList->Count++;
RangeList->Stamp++; RangeList->Stamp++;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
else else
{ {
//Previous = NULL; //Previous = NULL;
Entry = RangeList->ListHead.Flink; Entry = RangeList->ListHead.Flink;
while (Entry != &RangeList->ListHead) while (Entry != &RangeList->ListHead)
{ {
Current = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry); Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
if (Current->Range.Start > RangeEntry->Range.End) if (Current->Range.Start > RangeEntry->Range.End)
{ {
/* Insert before current */ /* Insert before current */
DPRINT ("Insert before current\n"); DPRINT("Insert before current\n");
InsertTailList (&Current->Entry, InsertTailList(&Current->Entry,
&RangeEntry->Entry); &RangeEntry->Entry);
RangeList->Count++; RangeList->Count++;
RangeList->Stamp++; RangeList->Stamp++;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
//Previous = Current; //Previous = Current;
Entry = Entry->Flink; Entry = Entry->Flink;
} }
DPRINT ("Insert tail\n"); DPRINT("Insert tail\n");
InsertTailList (&RangeList->ListHead, InsertTailList(&RangeList->ListHead,
&RangeEntry->Entry); &RangeEntry->Entry);
RangeList->Count++; RangeList->Count++;
RangeList->Stamp++; RangeList->Stamp++;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
RtlpFreeMemory(RangeEntry, 0); RtlpFreeMemory(RangeEntry, 0);
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
@ -142,40 +143,41 @@ RtlAddRange (IN OUT PRTL_RANGE_LIST RangeList,
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlCopyRangeList (OUT PRTL_RANGE_LIST CopyRangeList, NTAPI
IN PRTL_RANGE_LIST RangeList) RtlCopyRangeList(OUT PRTL_RANGE_LIST CopyRangeList,
IN PRTL_RANGE_LIST RangeList)
{ {
PRTL_RANGE_ENTRY Current; PRTL_RANGE_ENTRY Current;
PRTL_RANGE_ENTRY NewEntry; PRTL_RANGE_ENTRY NewEntry;
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
CopyRangeList->Flags = RangeList->Flags; CopyRangeList->Flags = RangeList->Flags;
Entry = RangeList->ListHead.Flink; Entry = RangeList->ListHead.Flink;
while (Entry != &RangeList->ListHead) while (Entry != &RangeList->ListHead)
{ {
Current = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry); Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
NewEntry = RtlpAllocateMemory(sizeof(RTL_RANGE_ENTRY), 'elRR'); NewEntry = RtlpAllocateMemory(sizeof(RTL_RANGE_ENTRY), 'elRR');
if (NewEntry == NULL) if (NewEntry == NULL)
return STATUS_INSUFFICIENT_RESOURCES; return STATUS_INSUFFICIENT_RESOURCES;
RtlCopyMemory (&NewEntry->Range, RtlCopyMemory(&NewEntry->Range,
&Current->Range, &Current->Range,
sizeof(RTL_RANGE_ENTRY)); sizeof(RTL_RANGE_ENTRY));
InsertTailList (&CopyRangeList->ListHead, InsertTailList(&CopyRangeList->ListHead,
&NewEntry->Entry); &NewEntry->Entry);
CopyRangeList->Count++; CopyRangeList->Count++;
Entry = Entry->Flink; Entry = Entry->Flink;
} }
CopyRangeList->Stamp++; CopyRangeList->Stamp++;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -196,30 +198,31 @@ RtlCopyRangeList (OUT PRTL_RANGE_LIST CopyRangeList,
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlDeleteOwnersRanges (IN OUT PRTL_RANGE_LIST RangeList, NTAPI
IN PVOID Owner) RtlDeleteOwnersRanges(IN OUT PRTL_RANGE_LIST RangeList,
IN PVOID Owner)
{ {
PRTL_RANGE_ENTRY Current; PRTL_RANGE_ENTRY Current;
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
Entry = RangeList->ListHead.Flink; Entry = RangeList->ListHead.Flink;
while (Entry != &RangeList->ListHead) while (Entry != &RangeList->ListHead)
{ {
Current = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry); Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
if (Current->Range.Owner == Owner) if (Current->Range.Owner == Owner)
{ {
RemoveEntryList (Entry); RemoveEntryList (Entry);
RtlpFreeMemory(Current, 0); RtlpFreeMemory(Current, 0);
RangeList->Count--; RangeList->Count--;
RangeList->Stamp++; RangeList->Stamp++;
} }
Entry = Entry->Flink; Entry = Entry->Flink;
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -241,36 +244,37 @@ RtlDeleteOwnersRanges (IN OUT PRTL_RANGE_LIST RangeList,
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlDeleteRange (IN OUT PRTL_RANGE_LIST RangeList, NTAPI
IN ULONGLONG Start, RtlDeleteRange(IN OUT PRTL_RANGE_LIST RangeList,
IN ULONGLONG End, IN ULONGLONG Start,
IN PVOID Owner) IN ULONGLONG End,
IN PVOID Owner)
{ {
PRTL_RANGE_ENTRY Current; PRTL_RANGE_ENTRY Current;
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
Entry = RangeList->ListHead.Flink; Entry = RangeList->ListHead.Flink;
while (Entry != &RangeList->ListHead) while (Entry != &RangeList->ListHead)
{ {
Current = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry); Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
if (Current->Range.Start == Start && if (Current->Range.Start == Start &&
Current->Range.End == End && Current->Range.End == End &&
Current->Range.Owner == Owner) Current->Range.Owner == Owner)
{ {
RemoveEntryList (Entry); RemoveEntryList(Entry);
RtlpFreeMemory(Current, 0); RtlpFreeMemory(Current, 0);
RangeList->Count--; RangeList->Count--;
RangeList->Stamp++; RangeList->Stamp++;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
Entry = Entry->Flink; Entry = Entry->Flink;
} }
return STATUS_RANGE_NOT_FOUND; return STATUS_RANGE_NOT_FOUND;
} }
@ -301,86 +305,87 @@ RtlDeleteRange (IN OUT PRTL_RANGE_LIST RangeList,
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlFindRange (IN PRTL_RANGE_LIST RangeList, NTAPI
IN ULONGLONG Minimum, RtlFindRange(IN PRTL_RANGE_LIST RangeList,
IN ULONGLONG Maximum, IN ULONGLONG Minimum,
IN ULONG Length, IN ULONGLONG Maximum,
IN ULONG Alignment, IN ULONG Length,
IN ULONG Flags, IN ULONG Alignment,
IN UCHAR AttributeAvailableMask, IN ULONG Flags,
IN PVOID Context OPTIONAL, IN UCHAR AttributeAvailableMask,
IN PRTL_CONFLICT_RANGE_CALLBACK Callback OPTIONAL, IN PVOID Context OPTIONAL,
OUT PULONGLONG Start) IN PRTL_CONFLICT_RANGE_CALLBACK Callback OPTIONAL,
OUT PULONGLONG Start)
{ {
PRTL_RANGE_ENTRY CurrentEntry; PRTL_RANGE_ENTRY CurrentEntry;
PRTL_RANGE_ENTRY NextEntry; PRTL_RANGE_ENTRY NextEntry;
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
ULONGLONG RangeMin; ULONGLONG RangeMin;
ULONGLONG RangeMax; ULONGLONG RangeMax;
if (Alignment == 0 || Length == 0) if (Alignment == 0 || Length == 0)
{ {
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
} }
if (IsListEmpty(&RangeList->ListHead)) if (IsListEmpty(&RangeList->ListHead))
{ {
*Start = ROUND_DOWN (Maximum - (Length - 1), Alignment); *Start = ROUND_DOWN(Maximum - (Length - 1), Alignment);
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NextEntry = NULL; NextEntry = NULL;
Entry = RangeList->ListHead.Blink; Entry = RangeList->ListHead.Blink;
while (Entry != &RangeList->ListHead) while (Entry != &RangeList->ListHead)
{ {
CurrentEntry = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry); CurrentEntry = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
RangeMax = NextEntry ? (NextEntry->Range.Start - 1) : Maximum; RangeMax = NextEntry ? (NextEntry->Range.Start - 1) : Maximum;
if (RangeMax + (Length - 1) < Minimum) if (RangeMax + (Length - 1) < Minimum)
{ {
return STATUS_RANGE_NOT_FOUND; return STATUS_RANGE_NOT_FOUND;
} }
RangeMin = ROUND_DOWN (RangeMax - (Length - 1), Alignment); RangeMin = ROUND_DOWN(RangeMax - (Length - 1), Alignment);
if (RangeMin < Minimum || if (RangeMin < Minimum ||
(RangeMax - RangeMin) < (Length - 1)) (RangeMax - RangeMin) < (Length - 1))
{ {
return STATUS_RANGE_NOT_FOUND; return STATUS_RANGE_NOT_FOUND;
} }
DPRINT("RangeMax: %I64x\n", RangeMax); DPRINT("RangeMax: %I64x\n", RangeMax);
DPRINT("RangeMin: %I64x\n", RangeMin); DPRINT("RangeMin: %I64x\n", RangeMin);
if (RangeMin > CurrentEntry->Range.End) if (RangeMin > CurrentEntry->Range.End)
{ {
*Start = RangeMin; *Start = RangeMin;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
NextEntry = CurrentEntry; NextEntry = CurrentEntry;
Entry = Entry->Blink; Entry = Entry->Blink;
} }
RangeMax = NextEntry ? (NextEntry->Range.Start - 1) : Maximum; RangeMax = NextEntry ? (NextEntry->Range.Start - 1) : Maximum;
if (RangeMax + (Length - 1) < Minimum) if (RangeMax + (Length - 1) < Minimum)
{ {
return STATUS_RANGE_NOT_FOUND; return STATUS_RANGE_NOT_FOUND;
} }
RangeMin = ROUND_DOWN (RangeMax - (Length - 1), Alignment); RangeMin = ROUND_DOWN(RangeMax - (Length - 1), Alignment);
if (RangeMin < Minimum || if (RangeMin < Minimum ||
(RangeMax - RangeMin) < (Length - 1)) (RangeMax - RangeMin) < (Length - 1))
{ {
return STATUS_RANGE_NOT_FOUND; return STATUS_RANGE_NOT_FOUND;
} }
DPRINT("RangeMax: %I64x\n", RangeMax); DPRINT("RangeMax: %I64x\n", RangeMax);
DPRINT("RangeMin: %I64x\n", RangeMin); DPRINT("RangeMin: %I64x\n", RangeMin);
*Start = RangeMin; *Start = RangeMin;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -399,25 +404,26 @@ RtlFindRange (IN PRTL_RANGE_LIST RangeList,
* *
* @implemented * @implemented
*/ */
VOID NTAPI VOID
RtlFreeRangeList (IN PRTL_RANGE_LIST RangeList) NTAPI
RtlFreeRangeList(IN PRTL_RANGE_LIST RangeList)
{ {
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
PRTL_RANGE_ENTRY Current; PRTL_RANGE_ENTRY Current;
while (!IsListEmpty(&RangeList->ListHead)) while (!IsListEmpty(&RangeList->ListHead))
{ {
Entry = RemoveHeadList (&RangeList->ListHead); Entry = RemoveHeadList(&RangeList->ListHead);
Current = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry); Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
DPRINT ("Range start: %I64u\n", Current->Range.Start); DPRINT ("Range start: %I64u\n", Current->Range.Start);
DPRINT ("Range end: %I64u\n", Current->Range.End); DPRINT ("Range end: %I64u\n", Current->Range.End);
RtlpFreeMemory(Current, 0); RtlpFreeMemory(Current, 0);
} }
RangeList->Flags = 0; RangeList->Flags = 0;
RangeList->Count = 0; RangeList->Count = 0;
} }
@ -438,25 +444,27 @@ RtlFreeRangeList (IN PRTL_RANGE_LIST RangeList)
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlGetFirstRange (IN PRTL_RANGE_LIST RangeList, NTAPI
OUT PRTL_RANGE_LIST_ITERATOR Iterator, RtlGetFirstRange(IN PRTL_RANGE_LIST RangeList,
OUT PRTL_RANGE *Range) OUT PRTL_RANGE_LIST_ITERATOR Iterator,
OUT PRTL_RANGE *Range)
{ {
Iterator->RangeListHead = &RangeList->ListHead; Iterator->RangeListHead = &RangeList->ListHead;
Iterator->MergedHead = NULL; Iterator->MergedHead = NULL;
Iterator->Stamp = RangeList->Stamp; Iterator->Stamp = RangeList->Stamp;
if (IsListEmpty(&RangeList->ListHead))
if (IsListEmpty(&RangeList->ListHead))
{ {
Iterator->Current = NULL; Iterator->Current = NULL;
*Range = NULL; *Range = NULL;
return STATUS_NO_MORE_ENTRIES; return STATUS_NO_MORE_ENTRIES;
} }
Iterator->Current = RangeList->ListHead.Flink; Iterator->Current = RangeList->ListHead.Flink;
*Range = &((PRTL_RANGE_ENTRY)Iterator->Current)->Range; *Range = &((PRTL_RANGE_ENTRY)Iterator->Current)->Range;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -478,34 +486,35 @@ RtlGetFirstRange (IN PRTL_RANGE_LIST RangeList,
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlGetNextRange (IN OUT PRTL_RANGE_LIST_ITERATOR Iterator, NTAPI
OUT PRTL_RANGE *Range, RtlGetNextRange(IN OUT PRTL_RANGE_LIST_ITERATOR Iterator,
IN BOOLEAN MoveForwards) OUT PRTL_RANGE *Range,
IN BOOLEAN MoveForwards)
{ {
PRTL_RANGE_LIST RangeList; PRTL_RANGE_LIST RangeList;
PLIST_ENTRY Next; PLIST_ENTRY Next;
RangeList = CONTAINING_RECORD(Iterator->RangeListHead, RTL_RANGE_LIST, ListHead); RangeList = CONTAINING_RECORD(Iterator->RangeListHead, RTL_RANGE_LIST, ListHead);
if (Iterator->Stamp != RangeList->Stamp) if (Iterator->Stamp != RangeList->Stamp)
return STATUS_INVALID_PARAMETER; return STATUS_INVALID_PARAMETER;
if (MoveForwards) if (MoveForwards)
{ {
Next = ((PRTL_RANGE_ENTRY)Iterator->Current)->Entry.Flink; Next = ((PRTL_RANGE_ENTRY)Iterator->Current)->Entry.Flink;
} }
else else
{ {
Next = ((PRTL_RANGE_ENTRY)Iterator->Current)->Entry.Blink; Next = ((PRTL_RANGE_ENTRY)Iterator->Current)->Entry.Blink;
} }
if (Next == Iterator->RangeListHead) if (Next == Iterator->RangeListHead)
return STATUS_NO_MORE_ENTRIES; return STATUS_NO_MORE_ENTRIES;
Iterator->Current = Next; Iterator->Current = Next;
*Range = &((PRTL_RANGE_ENTRY)Next)->Range; *Range = &((PRTL_RANGE_ENTRY)Next)->Range;
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -524,13 +533,14 @@ RtlGetNextRange (IN OUT PRTL_RANGE_LIST_ITERATOR Iterator,
* *
* @implemented * @implemented
*/ */
VOID NTAPI VOID
RtlInitializeRangeList (IN OUT PRTL_RANGE_LIST RangeList) NTAPI
RtlInitializeRangeList(IN OUT PRTL_RANGE_LIST RangeList)
{ {
InitializeListHead (&RangeList->ListHead); InitializeListHead(&RangeList->ListHead);
RangeList->Flags = 0; RangeList->Flags = 0;
RangeList->Count = 0; RangeList->Count = 0;
RangeList->Stamp = 0; RangeList->Stamp = 0;
} }
@ -550,78 +560,79 @@ RtlInitializeRangeList (IN OUT PRTL_RANGE_LIST RangeList)
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlInvertRangeList (OUT PRTL_RANGE_LIST InvertedRangeList, NTAPI
IN PRTL_RANGE_LIST RangeList) RtlInvertRangeList(OUT PRTL_RANGE_LIST InvertedRangeList,
IN PRTL_RANGE_LIST RangeList)
{ {
PRTL_RANGE_ENTRY Previous; PRTL_RANGE_ENTRY Previous;
PRTL_RANGE_ENTRY Current; PRTL_RANGE_ENTRY Current;
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
NTSTATUS Status; NTSTATUS Status;
/* Don't invert an empty range list */ /* Don't invert an empty range list */
if (IsListEmpty(&RangeList->ListHead)) if (IsListEmpty(&RangeList->ListHead))
{ {
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
/* Add leading and intermediate ranges */ /* Add leading and intermediate ranges */
Previous = NULL; Previous = NULL;
Entry = RangeList->ListHead.Flink; Entry = RangeList->ListHead.Flink;
while (Entry != &RangeList->ListHead) while (Entry != &RangeList->ListHead)
{ {
Current = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry); Current = CONTAINING_RECORD(Entry, RTL_RANGE_ENTRY, Entry);
if (Previous == NULL) if (Previous == NULL)
{ {
if (Current->Range.Start != (ULONGLONG)0) if (Current->Range.Start != (ULONGLONG)0)
{ {
Status = RtlAddRange (InvertedRangeList, Status = RtlAddRange(InvertedRangeList,
(ULONGLONG)0, (ULONGLONG)0,
Current->Range.Start - 1, Current->Range.Start - 1,
0, 0,
0, 0,
NULL, NULL,
NULL); NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
return Status; return Status;
} }
} }
else else
{ {
if (Previous->Range.End + 1 != Current->Range.Start) if (Previous->Range.End + 1 != Current->Range.Start)
{ {
Status = RtlAddRange (InvertedRangeList, Status = RtlAddRange(InvertedRangeList,
Previous->Range.End + 1, Previous->Range.End + 1,
Current->Range.Start - 1, Current->Range.Start - 1,
0, 0,
0, 0,
NULL, NULL,
NULL); NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
return Status; return Status;
} }
} }
Previous = Current; Previous = Current;
Entry = Entry->Flink; Entry = Entry->Flink;
} }
/* Add trailing range */ /* Add trailing range */
if (Previous->Range.End + 1 != (ULONGLONG)-1) if (Previous->Range.End + 1 != (ULONGLONG)-1)
{ {
Status = RtlAddRange (InvertedRangeList, Status = RtlAddRange(InvertedRangeList,
Previous->Range.End + 1, Previous->Range.End + 1,
(ULONGLONG)-1, (ULONGLONG)-1,
0, 0,
0, 0,
NULL, NULL,
NULL); NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
return Status; return Status;
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -650,45 +661,47 @@ RtlInvertRangeList (OUT PRTL_RANGE_LIST InvertedRangeList,
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlIsRangeAvailable (IN PRTL_RANGE_LIST RangeList, NTAPI
IN ULONGLONG Start, RtlIsRangeAvailable(IN PRTL_RANGE_LIST RangeList,
IN ULONGLONG End, IN ULONGLONG Start,
IN ULONG Flags, IN ULONGLONG End,
IN UCHAR AttributeAvailableMask, IN ULONG Flags,
IN PVOID Context OPTIONAL, IN UCHAR AttributeAvailableMask,
IN PRTL_CONFLICT_RANGE_CALLBACK Callback OPTIONAL, IN PVOID Context OPTIONAL,
OUT PBOOLEAN Available) IN PRTL_CONFLICT_RANGE_CALLBACK Callback OPTIONAL,
OUT PBOOLEAN Available)
{ {
PRTL_RANGE_ENTRY Current; PRTL_RANGE_ENTRY Current;
PLIST_ENTRY Entry; PLIST_ENTRY Entry;
*Available = TRUE; *Available = TRUE;
Entry = RangeList->ListHead.Flink; Entry = RangeList->ListHead.Flink;
while (Entry != &RangeList->ListHead) while (Entry != &RangeList->ListHead)
{ {
Current = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry); Current = CONTAINING_RECORD (Entry, RTL_RANGE_ENTRY, Entry);
if (!((Current->Range.Start >= End && Current->Range.End > End) ||
(Current->Range.Start <= Start && Current->Range.End < Start &&
(!(Flags & RTL_RANGE_SHARED) ||
!(Current->Range.Flags & RTL_RANGE_SHARED)))))
{
if (Callback != NULL)
{
*Available = Callback (Context,
&Current->Range);
}
else
{
*Available = FALSE;
}
}
Entry = Entry->Flink; if (!((Current->Range.Start >= End && Current->Range.End > End) ||
(Current->Range.Start <= Start && Current->Range.End < Start &&
(!(Flags & RTL_RANGE_SHARED) ||
!(Current->Range.Flags & RTL_RANGE_SHARED)))))
{
if (Callback != NULL)
{
*Available = Callback(Context,
&Current->Range);
}
else
{
*Available = FALSE;
}
}
Entry = Entry->Flink;
} }
return STATUS_SUCCESS; return STATUS_SUCCESS;
} }
@ -710,49 +723,50 @@ RtlIsRangeAvailable (IN PRTL_RANGE_LIST RangeList,
* *
* @implemented * @implemented
*/ */
NTSTATUS NTAPI NTSTATUS
RtlMergeRangeLists (OUT PRTL_RANGE_LIST MergedRangeList, NTAPI
IN PRTL_RANGE_LIST RangeList1, RtlMergeRangeLists(OUT PRTL_RANGE_LIST MergedRangeList,
IN PRTL_RANGE_LIST RangeList2, IN PRTL_RANGE_LIST RangeList1,
IN ULONG Flags) IN PRTL_RANGE_LIST RangeList2,
IN ULONG Flags)
{ {
RTL_RANGE_LIST_ITERATOR Iterator; RTL_RANGE_LIST_ITERATOR Iterator;
PRTL_RANGE Range; PRTL_RANGE Range;
NTSTATUS Status; NTSTATUS Status;
/* Copy range list 1 to the merged range list */ /* Copy range list 1 to the merged range list */
Status = RtlCopyRangeList (MergedRangeList, Status = RtlCopyRangeList(MergedRangeList,
RangeList1); RangeList1);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
return Status; return Status;
/* Add range list 2 entries to the merged range list */ /* Add range list 2 entries to the merged range list */
Status = RtlGetFirstRange (RangeList2, Status = RtlGetFirstRange(RangeList2,
&Iterator, &Iterator,
&Range); &Range);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
return (Status == STATUS_NO_MORE_ENTRIES) ? STATUS_SUCCESS : Status; return (Status == STATUS_NO_MORE_ENTRIES) ? STATUS_SUCCESS : Status;
while (TRUE) while (TRUE)
{ {
Status = RtlAddRange (MergedRangeList, Status = RtlAddRange(MergedRangeList,
Range->Start, Range->Start,
Range->End, Range->End,
Range->Attributes, Range->Attributes,
Range->Flags | Flags, Range->Flags | Flags,
Range->UserData, Range->UserData,
Range->Owner); Range->Owner);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
break; break;
Status = RtlGetNextRange (&Iterator, Status = RtlGetNextRange(&Iterator,
&Range, &Range,
TRUE); TRUE);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
break; break;
} }
return (Status == STATUS_NO_MORE_ENTRIES) ? STATUS_SUCCESS : Status; return (Status == STATUS_NO_MORE_ENTRIES) ? STATUS_SUCCESS : Status;
} }
/* EOF */ /* EOF */