ReactOS 0.4.17-dev-683-g0dafdc5
RtlRangeList.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS kernel-mode tests
3 * LICENSE: LGPL-2.1-or-later (https://spdx.org/licenses/LGPL-2.1-or-later)
4 * PURPOSE: Test for Rtl Range Lists
5 * COPYRIGHT: Copyright 2020 Thomas Faber (thomas.faber@reactos.org)
6 */
7
8#include <kmt_test.h>
9#include <ndk/rtlfuncs.h>
10#include <stdint.h>
11
12static UCHAR MyUserData1, MyUserData2;
13static UCHAR MyOwner1, MyOwner2;
14
15/* Conflict callbacks: return TRUE to tell the range list to ignore the conflict. */
16static
17BOOLEAN
18NTAPI
19IgnoreConflictCallback(
20 _In_ PVOID Context,
21 _In_ struct _RTL_RANGE *Range)
22{
23 UNREFERENCED_PARAMETER(Context);
24 UNREFERENCED_PARAMETER(Range);
25 return TRUE;
26}
27
28static
29BOOLEAN
30NTAPI
31KeepConflictCallback(
32 _In_ PVOID Context,
33 _In_ struct _RTL_RANGE *Range)
34{
35 UNREFERENCED_PARAMETER(Context);
36 UNREFERENCED_PARAMETER(Range);
37 return FALSE;
38}
39
40/* Helpers *******************************************************************/
41static
42NTSTATUS
43RtlAddRangeWrapper(
44 _Inout_ PRTL_RANGE_LIST RangeList,
45 _In_ const RTL_RANGE *Range,
46 _In_ ULONG Flags)
47{
48 return RtlAddRange(RangeList,
49 Range->Start,
50 Range->End,
51 Range->Attributes,
52 Flags,
53 Range->UserData,
54 Range->Owner);
55}
56
57static
58void
59ExpectRange(
60 _In_ PCSTR File,
61 _In_ INT Line,
62 _In_ ULONG Index,
63 _In_ const RTL_RANGE *ActualRange,
64 _In_ const RTL_RANGE *ExpectedRange)
65{
66 CHAR FileAndLine[128];
67 RtlStringCbPrintfA(FileAndLine, sizeof(FileAndLine), "%s:%d", File, Line);
68
69 KmtOk(ActualRange->Start == ExpectedRange->Start, FileAndLine,
70 "[%lu] Start = 0x%I64x, expected 0x%I64x\n", Index, ActualRange->Start, ExpectedRange->Start);
71 KmtOk(ActualRange->End == ExpectedRange->End, FileAndLine,
72 "[%lu] End = 0x%I64x, expected 0x%I64x\n", Index, ActualRange->End, ExpectedRange->End);
73 KmtOk(ActualRange->UserData == ExpectedRange->UserData, FileAndLine,
74 "[%lu] UserData = %p, expected %p\n", Index, ActualRange->UserData, ExpectedRange->UserData);
75 KmtOk(ActualRange->Owner == ExpectedRange->Owner, FileAndLine,
76 "[%lu] Owner = %p, expected %p\n", Index, ActualRange->Owner, ExpectedRange->Owner);
77 KmtOk(ActualRange->Attributes == ExpectedRange->Attributes, FileAndLine,
78 "[%lu] Attributes = 0x%x, expected 0x%x\n", Index, ActualRange->Attributes, ExpectedRange->Attributes);
79 KmtOk(ActualRange->Flags == ExpectedRange->Flags, FileAndLine,
80 "[%lu] Flags = 0x%x, expected 0x%x\n", Index, ActualRange->Flags, ExpectedRange->Flags);
81}
82
83static
84void
85ExpectRangeEntryList(
86 _In_ PCSTR File,
87 _In_ INT Line,
88 _In_ RTL_RANGE_LIST *RangeList,
89 _In_ ULONG NumRanges,
90 _In_reads_(NumRanges) const RTL_RANGE *Ranges)
91{
92 NTSTATUS Status;
93 ULONG i;
94 RTL_RANGE_LIST_ITERATOR Iterator;
95 PRTL_RANGE Range;
96 CHAR FileAndLine[128];
97 RtlStringCbPrintfA(FileAndLine, sizeof(FileAndLine), "%s:%d", File, Line);
98
99 RtlFillMemory(&Iterator, sizeof(Iterator), 0x55);
100 Range = KmtInvalidPointer;
101 Status = RtlGetFirstRange(RangeList, &Iterator, &Range);
102#ifdef _WIN64
103 /* Padding at the end is uninitialized */
104 C_ASSERT(sizeof(Iterator) == RTL_SIZEOF_THROUGH_FIELD(RTL_RANGE_LIST_ITERATOR, Stamp) + sizeof(ULONG));
105 KmtOk((&Iterator.Stamp)[1] == 0x55555555, FileAndLine,
106 "Padding is 0x%lx\n", (&Iterator.Stamp)[1]);
107#endif
108
109 for (i = 0; i < NumRanges; i++)
110 {
111 if (!KmtSkip(NT_SUCCESS(Status), FileAndLine, "Range does not have %lu element(s)\n", i + 1))
112 {
113 ExpectRange(File, Line, i, Range, &Ranges[i]);
114
115 /* Validate iterator */
116 KmtOk(Iterator.RangeListHead == &RangeList->ListHead, FileAndLine,
117 "[%lu] Iterator.RangeListHead = %p, expected %p\n", i, Iterator.RangeListHead, &RangeList->ListHead);
118 KmtOk(Iterator.MergedHead == NULL, FileAndLine,
119 "[%lu] Iterator.MergedHead = %p\n", i, Iterator.MergedHead);
120 KmtOk(Iterator.Current == Range, FileAndLine,
121 "[%lu] Iterator.Current = %p, expected %p\n", i, Iterator.Current, Range);
122 KmtOk(Iterator.Stamp == RangeList->Stamp, FileAndLine,
123 "[%lu] Iterator.Stamp = %lu, expected %lu\n", i, Iterator.Stamp, RangeList->Stamp);
124 }
125
126 Range = KmtInvalidPointer;
127 Status = RtlGetNextRange(&Iterator, &Range, TRUE);
128 }
129
130 /* Final iteration status */
131 KmtOk(Status == STATUS_NO_MORE_ENTRIES, FileAndLine,
132 "Status = 0x%lx after enumeration\n", Status);
133 KmtOk(Range == NULL, FileAndLine,
134 "[%lu] Range = %p\n", i, Range);
135 KmtOk(Iterator.RangeListHead == &RangeList->ListHead, FileAndLine,
136 "[%lu] Iterator.RangeListHead = %p, expected %p\n", i, Iterator.RangeListHead, &RangeList->ListHead);
137 KmtOk(Iterator.MergedHead == NULL, FileAndLine,
138 "[%lu] Iterator.MergedHead = %p\n", i, Iterator.MergedHead);
139 KmtOk(Iterator.Current == NULL, FileAndLine,
140 "[%lu] Iterator.Current = %p\n", i, Iterator.Current);
141 KmtOk(Iterator.Stamp == RangeList->Stamp, FileAndLine,
142 "[%lu] Iterator.Stamp = %lu, expected %lu\n", i, Iterator.Stamp, RangeList->Stamp);
143
144 /* Try one more iteration */
145 Range = KmtInvalidPointer;
146 Status = RtlGetNextRange(&Iterator, &Range, TRUE);
147 KmtOk(Status == STATUS_NO_MORE_ENTRIES, FileAndLine,
148 "Status = 0x%lx after enumeration\n", Status);
149 KmtOk(Range == NULL, FileAndLine,
150 "[%lu] Range = %p\n", i, Range);
151 KmtOk(Iterator.RangeListHead == &RangeList->ListHead, FileAndLine,
152 "[%lu] Iterator.RangeListHead = %p, expected %p\n", i, Iterator.RangeListHead, &RangeList->ListHead);
153 KmtOk(Iterator.MergedHead == NULL, FileAndLine,
154 "[%lu] Iterator.MergedHead = %p\n", i, Iterator.MergedHead);
155 KmtOk(Iterator.Current == NULL, FileAndLine,
156 "[%lu] Iterator.Current = %p\n", i, Iterator.Current);
157 KmtOk(Iterator.Stamp == RangeList->Stamp, FileAndLine,
158 "[%lu] Iterator.Stamp = %lu, expected %lu\n", i, Iterator.Stamp, RangeList->Stamp);
159}
160
161#define expect_range_entries(RangeList, NumRanges, Ranges) \
162 ExpectRangeEntryList(__FILE__, __LINE__, RangeList, NumRanges, Ranges)
163
164/* Test functions ************************************************************/
165static
166void
167TestStartGreaterThanEnd(
168 _Inout_ PRTL_RANGE_LIST RangeList,
169 _Inout_ PRTL_RANGE Ranges)
170{
171 NTSTATUS Status;
172 ULONG StartStamp = RangeList->Stamp;
173
174 Ranges[1].Start = 0x300;
175 Ranges[1].End = 0x2ff;
176 Ranges[1].Attributes = 2;
177 Ranges[1].Flags = 0;
178 Ranges[1].UserData = &MyUserData2;
179 Ranges[1].Owner = &MyOwner2;
180
181 /* Start > End bails out early with invalid parameter */
182 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], 0);
183 ok_eq_hex(Status, STATUS_INVALID_PARAMETER);
184
185 /* List should be unchanged */
186 ok_eq_ulong(RangeList->Flags, 0UL);
187 ok_eq_ulong(RangeList->Count, 1UL);
188 ok_eq_ulong(RangeList->Stamp, StartStamp);
189 expect_range_entries(RangeList, 1, &Ranges[0]);
190}
191
192static
193void
194TestStartEqualsEnd(
195 _Inout_ PRTL_RANGE_LIST RangeList,
196 _Inout_ PRTL_RANGE Ranges)
197{
198 NTSTATUS Status;
199 ULONG StartStamp = RangeList->Stamp;
200
201 Ranges[1].Start = 0x300;
202 Ranges[1].End = 0x300;
203 Ranges[1].Attributes = 0xff;
204 Ranges[1].Flags = 0;
205 Ranges[1].UserData = &MyUserData2;
206 Ranges[1].Owner = &MyOwner2;
207
208 /* Start == End is valid */
209 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], 0);
210 ok_eq_hex(Status, STATUS_SUCCESS);
211
212 /* List now has two entries */
213 ok_eq_ulong(RangeList->Flags, 0UL);
214 ok_eq_ulong(RangeList->Count, 2UL);
215 ok_eq_ulong(RangeList->Stamp, StartStamp + 1);
216 expect_range_entries(RangeList, 2, &Ranges[0]);
217
218 /* Delete our new entry -- List goes back to one entry */
219 Status = RtlDeleteRange(RangeList, Ranges[1].Start, Ranges[1].End, Ranges[1].Owner);
220 ok_eq_hex(Status, STATUS_SUCCESS);
221 ok_eq_ulong(RangeList->Flags, 0UL);
222 ok_eq_ulong(RangeList->Count, 1UL);
223 ok_eq_ulong(RangeList->Stamp, StartStamp + 2);
224 expect_range_entries(RangeList, 1, &Ranges[0]);
225}
226
227static
228void
229TestSharedFlag(
230 _Inout_ PRTL_RANGE_LIST RangeList,
231 _Inout_ PRTL_RANGE Ranges)
232{
233 NTSTATUS Status;
234 ULONG StartStamp = RangeList->Stamp;
235
236 Ranges[1].Start = 0x300;
237 Ranges[1].End = 0x400;
238 Ranges[1].Attributes = 2;
239 Ranges[1].Flags = RTL_RANGE_SHARED;
240 Ranges[1].UserData = &MyUserData2;
241 Ranges[1].Owner = &MyOwner2;
242
243 /* Pass in the shared flag */
244 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], RTL_RANGE_LIST_ADD_SHARED);
245 ok_eq_hex(Status, STATUS_SUCCESS);
246
247 /* List now has two entries */
248 ok_eq_ulong(RangeList->Flags, 0UL);
249 ok_eq_ulong(RangeList->Count, 2UL);
250 ok_eq_ulong(RangeList->Stamp, StartStamp + 1);
251 expect_range_entries(RangeList, 2, &Ranges[0]);
252
253 /* Delete our new entry -- List goes back to one entry */
254 Status = RtlDeleteRange(RangeList, Ranges[1].Start, Ranges[1].End, Ranges[1].Owner);
255 ok_eq_hex(Status, STATUS_SUCCESS);
256 ok_eq_ulong(RangeList->Flags, 0UL);
257 ok_eq_ulong(RangeList->Count, 1UL);
258 ok_eq_ulong(RangeList->Stamp, StartStamp + 2);
259 expect_range_entries(RangeList, 1, &Ranges[0]);
260}
261
262static
263void
264TestIsAvailable(
265 _Inout_ PRTL_RANGE_LIST RangeList,
266 _Inout_ PRTL_RANGE Ranges)
267{
268 NTSTATUS Status;
269 BOOLEAN Available;
270 ULONG StartStamp = RangeList->Stamp;
271
272#define is_range_available(RangeList, Start, End, pAvail) \
273 RtlIsRangeAvailable(RangeList, \
274 Start, \
275 End, \
276 0, \
277 0, \
278 NULL, \
279 NULL, \
280 pAvail)
281
282 /* Single item range before Start */
283 Status = is_range_available(RangeList,
284 Ranges[0].Start - 1,
285 Ranges[0].Start - 1,
286 &Available);
287 ok_eq_hex(Status, STATUS_SUCCESS);
288 ok_eq_bool(Available, TRUE);
289
290 /* Single item range at Start */
291 Status = is_range_available(RangeList,
292 Ranges[0].Start,
293 Ranges[0].Start,
294 &Available);
295 ok_eq_hex(Status, STATUS_SUCCESS);
296 ok_eq_bool(Available, FALSE);
297
298 /* Single item range at End */
299 Status = is_range_available(RangeList,
300 Ranges[0].End,
301 Ranges[0].End,
302 &Available);
303 ok_eq_hex(Status, STATUS_SUCCESS);
304 ok_eq_bool(Available, FALSE);
305
306 /* Single item range after End */
307 Status = is_range_available(RangeList,
308 Ranges[0].End + 1,
309 Ranges[0].End + 1,
310 &Available);
311 ok_eq_hex(Status, STATUS_SUCCESS);
312 ok_eq_bool(Available, TRUE);
313
314 /* Range ending before Start */
315 Status = is_range_available(RangeList,
316 0x0,
317 Ranges[0].Start - 1,
318 &Available);
319 ok_eq_hex(Status, STATUS_SUCCESS);
320 ok_eq_bool(Available, TRUE);
321
322 /* Range ending at Start */
323 Status = is_range_available(RangeList,
324 0x0,
325 Ranges[0].Start,
326 &Available);
327 ok_eq_hex(Status, STATUS_SUCCESS);
328 ok_eq_bool(Available, FALSE);
329
330 /* Range ending in the middle */
331 Status = is_range_available(RangeList,
332 0x0,
333 (Ranges[0].Start + Ranges[0].End) / 2,
334 &Available);
335 ok_eq_hex(Status, STATUS_SUCCESS);
336 ok_eq_bool(Available, FALSE);
337
338 /* Range going all the way through */
339 Status = is_range_available(RangeList,
340 0x0,
341 Ranges[0].End + 0x100,
342 &Available);
343 ok_eq_hex(Status, STATUS_SUCCESS);
344 ok_eq_bool(Available, FALSE);
345
346 /* Range starting in the middle */
347 Status = is_range_available(RangeList,
348 (Ranges[0].Start + Ranges[0].End) / 2,
349 Ranges[0].End + 0x100,
350 &Available);
351 ok_eq_hex(Status, STATUS_SUCCESS);
352 ok_eq_bool(Available, FALSE);
353
354 /* Range starting at End */
355 Status = is_range_available(RangeList,
356 Ranges[0].End,
357 Ranges[0].End + 0x100,
358 &Available);
359 ok_eq_hex(Status, STATUS_SUCCESS);
360 ok_eq_bool(Available, FALSE);
361
362 /* Range starting after End */
363 Status = is_range_available(RangeList,
364 Ranges[0].End + 1,
365 Ranges[0].End + 0x100,
366 &Available);
367 ok_eq_hex(Status, STATUS_SUCCESS);
368 ok_eq_bool(Available, TRUE);
369
370 /* Start > End, at start */
371 Status = is_range_available(RangeList,
372 Ranges[0].Start,
373 Ranges[0].Start - 1,
374 &Available);
375 ok_eq_hex(Status, STATUS_SUCCESS);
376 ok_eq_bool(Available, TRUE);
377
378 /* Start > End, at start */
379 Status = is_range_available(RangeList,
380 Ranges[0].Start + 1,
381 Ranges[0].Start,
382 &Available);
383 ok_eq_hex(Status, STATUS_SUCCESS);
384 ok_eq_bool(Available, FALSE);
385
386 /* Start > End, at end */
387 Status = is_range_available(RangeList,
388 Ranges[0].End + 1,
389 Ranges[0].End,
390 &Available);
391 ok_eq_hex(Status, STATUS_SUCCESS);
392 ok_eq_bool(Available, TRUE);
393
394 /* Start > End, at end */
395 Status = is_range_available(RangeList,
396 Ranges[0].End,
397 Ranges[0].End - 1,
398 &Available);
399 ok_eq_hex(Status, STATUS_SUCCESS);
400 ok_eq_bool(Available, FALSE);
401
402 /* Start > End, through the range */
403 Status = is_range_available(RangeList,
404 Ranges[0].End + 1,
405 Ranges[0].Start - 1,
406 &Available);
407 ok_eq_hex(Status, STATUS_SUCCESS);
408 ok_eq_bool(Available, TRUE);
409
410 /* AttributesAvailableMask will make our range available */
411 Status = RtlIsRangeAvailable(RangeList,
412 0x0,
413 Ranges[0].End + 0x100,
414 0,
415 Ranges[0].Attributes,
416 NULL,
417 NULL,
418 &Available);
419 ok_eq_hex(Status, STATUS_SUCCESS);
420 ok_eq_bool(Available, TRUE);
421
422 /* AttributesAvailableMask with additional bits */
423 Status = RtlIsRangeAvailable(RangeList,
424 0x0,
425 Ranges[0].End + 0x100,
426 0,
427 0xFF,
428 NULL,
429 NULL,
430 &Available);
431 ok_eq_hex(Status, STATUS_SUCCESS);
432 ok_eq_bool(Available, TRUE);
433
434 ok_eq_ulong(RangeList->Stamp, StartStamp);
435}
436
437static
438void
439TestAddConflict(
440 _Inout_ PRTL_RANGE_LIST RangeList,
441 _Inout_ PRTL_RANGE Ranges)
442{
443 NTSTATUS Status;
444 ULONG StartStamp = RangeList->Stamp;
445
446 /* A range overlapping our [0x100, 0x200] entry */
447 Ranges[1].Start = 0x180;
448 Ranges[1].End = 0x280;
449 Ranges[1].Attributes = 0;
450 Ranges[1].Flags = 0;
451 Ranges[1].UserData = &MyUserData2;
452 Ranges[1].Owner = &MyOwner2;
453
454 /* Without RTL_RANGE_LIST_ADD_IF_CONFLICT the add is rejected */
455 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], 0);
456 ok_eq_hex(Status, STATUS_RANGE_LIST_CONFLICT);
457 ok_eq_ulong(RangeList->Count, 1UL);
458 ok_eq_ulong(RangeList->Stamp, StartStamp);
459 expect_range_entries(RangeList, 1, &Ranges[0]);
460
461 /* With the flag it succeeds */
462 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], RTL_RANGE_LIST_ADD_IF_CONFLICT);
463 ok_eq_hex(Status, STATUS_SUCCESS);
464 ok_eq_ulong(RangeList->Count, 2UL);
465
466 /* Restore the single-entry list */
467 Status = RtlDeleteRange(RangeList, Ranges[1].Start, Ranges[1].End, Ranges[1].Owner);
468 ok_eq_hex(Status, STATUS_SUCCESS);
469 ok_eq_ulong(RangeList->Count, 1UL);
470 expect_range_entries(RangeList, 1, &Ranges[0]);
471}
472
473static
474void
475TestFindRange(
476 _Inout_ PRTL_RANGE_LIST RangeList,
477 _Inout_ PRTL_RANGE Ranges)
478{
479 NTSTATUS Status;
480 ULONGLONG Start;
481 RTL_RANGE_LIST EmptyList;
482
483 /* Invalid parameters */
484 Start = 0x55;
485 Status = RtlFindRange(RangeList, 0x0, 0x1000, 0 /* Length */, 1, 0, 0, NULL, NULL, &Start);
486 ok_eq_hex(Status, STATUS_INVALID_PARAMETER);
487 Status = RtlFindRange(RangeList, 0x0, 0x1000, 0x10, 0 /* Alignment */, 0, 0, NULL, NULL, &Start);
488 ok_eq_hex(Status, STATUS_INVALID_PARAMETER);
489
490 /* Top-down search finds the highest aligned hole below Maximum */
491 Start = 0x55;
492 Status = RtlFindRange(RangeList, 0x0, 0x1000, 0x10, 1, 0, 0, NULL, NULL, &Start);
493 ok_eq_hex(Status, STATUS_SUCCESS);
494 ok_eq_ulonglong(Start, 0xFF1ULL);
495
496 /* Alignment is honored */
497 Start = 0x55;
498 Status = RtlFindRange(RangeList, 0x0, 0x1000, 0x10, 0x100, 0, 0, NULL, NULL, &Start);
499 ok_eq_hex(Status, STATUS_SUCCESS);
500 ok_eq_ulonglong(Start, 0xF00ULL);
501
502 /* Capping Maximum at the occupied range forces the search below it */
503 Start = 0x55;
504 Status = RtlFindRange(RangeList, 0x0, 0x200, 0x10, 1, 0, 0, NULL, NULL, &Start);
505 ok_eq_hex(Status, STATUS_SUCCESS);
506 ok_eq_ulonglong(Start, 0xF0ULL);
507
508 /* No room below and the range is opaque -> not found */
509 Start = 0x55;
510 Status = RtlFindRange(RangeList, 0x100, 0x200, 0x10, 1, 0, 0, NULL, NULL, &Start);
511 ok_eq_hex(Status, STATUS_RANGE_NOT_FOUND);
512
513 /* AttributeAvailableMask makes the occupied range transparent -> place on top of it */
514 Start = 0x55;
515 Status = RtlFindRange(RangeList, 0x0, 0x200, 0x10, 1, 0, Ranges[0].Attributes, NULL, NULL, &Start);
516 ok_eq_hex(Status, STATUS_SUCCESS);
517 ok_eq_ulonglong(Start, 0x1F1ULL);
518
519 /* Empty list: the whole [Minimum, Maximum] window is free */
520 RtlInitializeRangeList(&EmptyList);
521 Start = 0x55;
522 Status = RtlFindRange(&EmptyList, 0x0, 0xFFF, 0x10, 1, 0, 0, NULL, NULL, &Start);
523 ok_eq_hex(Status, STATUS_SUCCESS);
524 ok_eq_ulonglong(Start, 0xFF0ULL);
525 RtlFreeRangeList(&EmptyList);
526
527 /* Searching never mutates the list */
528 expect_range_entries(RangeList, 1, &Ranges[0]);
529}
530
531static
532void
533TestGetLastRange(
534 _Inout_ PRTL_RANGE_LIST RangeList,
535 _Inout_ PRTL_RANGE Ranges)
536{
537 NTSTATUS Status;
538 RTL_RANGE_LIST_ITERATOR Iterator;
539 PRTL_RANGE Range;
540 RTL_RANGE_LIST EmptyList;
541
542 /* Single entry: last == first */
543 Range = KmtInvalidPointer;
544 Status = RtlGetLastRange(RangeList, &Iterator, &Range);
545 ok_eq_hex(Status, STATUS_SUCCESS);
546 if (Range != NULL && Range != KmtInvalidPointer)
547 {
548 ok_eq_ulonglong(Range->Start, Ranges[0].Start);
549 ok_eq_ulonglong(Range->End, Ranges[0].End);
550 }
551 ok_eq_pointer(Iterator.RangeListHead, &RangeList->ListHead);
552 ok_eq_pointer(Iterator.MergedHead, NULL);
553
554 /* Add a higher second entry */
555 Ranges[1].Start = 0x300;
556 Ranges[1].End = 0x400;
557 Ranges[1].Attributes = 2;
558 Ranges[1].Flags = 0;
559 Ranges[1].UserData = &MyUserData2;
560 Ranges[1].Owner = &MyOwner2;
561 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], 0);
562 ok_eq_hex(Status, STATUS_SUCCESS);
563
564 /* GetLastRange returns the higher entry */
565 Range = KmtInvalidPointer;
566 Status = RtlGetLastRange(RangeList, &Iterator, &Range);
567 ok_eq_hex(Status, STATUS_SUCCESS);
568 if (Range != NULL && Range != KmtInvalidPointer)
569 {
570 ok_eq_ulonglong(Range->Start, Ranges[1].Start);
571 ok_eq_ulonglong(Range->End, Ranges[1].End);
572 }
573
574 /* Walking backwards reaches the first entry, then stops */
575 Range = KmtInvalidPointer;
576 Status = RtlGetNextRange(&Iterator, &Range, FALSE);
577 ok_eq_hex(Status, STATUS_SUCCESS);
578 if (Range != NULL && Range != KmtInvalidPointer)
579 {
580 ok_eq_ulonglong(Range->Start, Ranges[0].Start);
581 ok_eq_ulonglong(Range->End, Ranges[0].End);
582 }
583 Range = KmtInvalidPointer;
584 Status = RtlGetNextRange(&Iterator, &Range, FALSE);
585 ok_eq_hex(Status, STATUS_NO_MORE_ENTRIES);
586 ok_eq_pointer(Range, NULL);
587
588 /* Restore the single-entry list */
589 Status = RtlDeleteRange(RangeList, Ranges[1].Start, Ranges[1].End, Ranges[1].Owner);
590 ok_eq_hex(Status, STATUS_SUCCESS);
591 expect_range_entries(RangeList, 1, &Ranges[0]);
592
593 /* Empty list */
594 RtlInitializeRangeList(&EmptyList);
595 Range = KmtInvalidPointer;
596 Status = RtlGetLastRange(&EmptyList, &Iterator, &Range);
597 ok_eq_hex(Status, STATUS_NO_MORE_ENTRIES);
598 ok_eq_pointer(Range, NULL);
599 ok_eq_pointer(Iterator.Current, NULL);
600 RtlFreeRangeList(&EmptyList);
601}
602
603static
604void
605TestSharedNullCallback(
606 _Inout_ PRTL_RANGE_LIST RangeList,
607 _Inout_ PRTL_RANGE Ranges)
608{
609 NTSTATUS Status;
610 BOOLEAN Available;
611
612 /* A shared range */
613 Ranges[1].Start = 0x300;
614 Ranges[1].End = 0x400;
615 Ranges[1].Attributes = 0;
616 Ranges[1].Flags = RTL_RANGE_SHARED;
617 Ranges[1].UserData = &MyUserData2;
618 Ranges[1].Owner = &MyOwner2;
619 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], RTL_RANGE_LIST_ADD_SHARED);
620 ok_eq_hex(Status, STATUS_SUCCESS);
621
622 /* Not available without RTL_RANGE_LIST_SHARED_OK */
623 Status = RtlIsRangeAvailable(RangeList, 0x300, 0x400, 0, 0, NULL, NULL, &Available);
624 ok_eq_hex(Status, STATUS_SUCCESS);
625 ok_eq_bool(Available, FALSE);
626
627 /* Available with RTL_RANGE_LIST_SHARED_OK */
628 Status = RtlIsRangeAvailable(RangeList, 0x300, 0x400, RTL_RANGE_LIST_SHARED_OK, 0, NULL, NULL, &Available);
629 ok_eq_hex(Status, STATUS_SUCCESS);
630 ok_eq_bool(Available, TRUE);
631
632 /* A callback that ignores the conflict makes it available */
633 Status = RtlIsRangeAvailable(RangeList, 0x300, 0x400, 0, 0, NULL, IgnoreConflictCallback, &Available);
634 ok_eq_hex(Status, STATUS_SUCCESS);
635 ok_eq_bool(Available, TRUE);
636
637 /* A callback that keeps the conflict leaves it unavailable */
638 Status = RtlIsRangeAvailable(RangeList, 0x300, 0x400, 0, 0, NULL, KeepConflictCallback, &Available);
639 ok_eq_hex(Status, STATUS_SUCCESS);
640 ok_eq_bool(Available, FALSE);
641
642 Status = RtlDeleteRange(RangeList, Ranges[1].Start, Ranges[1].End, Ranges[1].Owner);
643 ok_eq_hex(Status, STATUS_SUCCESS);
644
645 /* A NULL-owner range */
646 Ranges[1].Start = 0x500;
647 Ranges[1].End = 0x600;
648 Ranges[1].Attributes = 0;
649 Ranges[1].Flags = 0;
650 Ranges[1].UserData = NULL;
651 Ranges[1].Owner = NULL;
652 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], 0);
653 ok_eq_hex(Status, STATUS_SUCCESS);
654
655 /* Not available without RTL_RANGE_LIST_NULL_CONFLICT_OK */
656 Status = RtlIsRangeAvailable(RangeList, 0x500, 0x600, 0, 0, NULL, NULL, &Available);
657 ok_eq_hex(Status, STATUS_SUCCESS);
658 ok_eq_bool(Available, FALSE);
659
660 /* Available with RTL_RANGE_LIST_NULL_CONFLICT_OK */
661 Status = RtlIsRangeAvailable(RangeList, 0x500, 0x600, RTL_RANGE_LIST_NULL_CONFLICT_OK, 0, NULL, NULL, &Available);
662 ok_eq_hex(Status, STATUS_SUCCESS);
663 ok_eq_bool(Available, TRUE);
664
665 Status = RtlDeleteRange(RangeList, 0x500, 0x600, NULL);
666 ok_eq_hex(Status, STATUS_SUCCESS);
667
668 expect_range_entries(RangeList, 1, &Ranges[0]);
669}
670
671static
672void
673TestDeleteOwnersRanges(
674 _Inout_ PRTL_RANGE_LIST RangeList,
675 _Inout_ PRTL_RANGE Ranges)
676{
677 NTSTATUS Status;
678
679 /* Two entries owned by MyOwner2, adjacent in iteration order */
680 Ranges[1].Start = 0x300;
681 Ranges[1].End = 0x400;
682 Ranges[1].Attributes = 0;
683 Ranges[1].Flags = 0;
684 Ranges[1].UserData = &MyUserData2;
685 Ranges[1].Owner = &MyOwner2;
686 Status = RtlAddRangeWrapper(RangeList, &Ranges[1], 0);
687 ok_eq_hex(Status, STATUS_SUCCESS);
688
689 Ranges[2].Start = 0x500;
690 Ranges[2].End = 0x600;
691 Ranges[2].Attributes = 0;
692 Ranges[2].Flags = 0;
693 Ranges[2].UserData = &MyUserData2;
694 Ranges[2].Owner = &MyOwner2;
695 Status = RtlAddRangeWrapper(RangeList, &Ranges[2], 0);
696 ok_eq_hex(Status, STATUS_SUCCESS);
697 ok_eq_ulong(RangeList->Count, 3UL);
698
699 /*
700 * Deleting MyOwner2 removes both entries in a single pass. Deleting two
701 * consecutively-matched entries exercises the delete-during-iteration path
702 * (which must capture Flink before freeing the current entry).
703 */
704 Status = RtlDeleteOwnersRanges(RangeList, &MyOwner2);
705 ok_eq_hex(Status, STATUS_SUCCESS);
706 ok_eq_ulong(RangeList->Count, 1UL);
707 expect_range_entries(RangeList, 1, &Ranges[0]);
708
709 /* Deleting an owner with no ranges changes nothing */
710 Status = RtlDeleteOwnersRanges(RangeList, &MyOwner2);
711 ok_eq_hex(Status, STATUS_SUCCESS);
712 ok_eq_ulong(RangeList->Count, 1UL);
713 expect_range_entries(RangeList, 1, &Ranges[0]);
714}
715
716static
717void
718TestInvertRangeList(void)
719{
720 NTSTATUS Status;
721 RTL_RANGE_LIST List;
722 RTL_RANGE_LIST Inverted;
723 RTL_RANGE Expected[3];
724
725 RtlInitializeRangeList(&List);
726 Status = RtlAddRange(&List, 0x100, 0x200, 0, RTL_RANGE_LIST_ADD_IF_CONFLICT, NULL, NULL);
727 ok_eq_hex(Status, STATUS_SUCCESS);
728 Status = RtlAddRange(&List, 0x400, 0x500, 0, RTL_RANGE_LIST_ADD_IF_CONFLICT, NULL, NULL);
729 ok_eq_hex(Status, STATUS_SUCCESS);
730
731 /* Plain invert: leading, middle and trailing gaps, Attributes 0 / Owner NULL */
732 RtlInitializeRangeList(&Inverted);
733 Status = RtlInvertRangeList(&Inverted, &List);
734 ok_eq_hex(Status, STATUS_SUCCESS);
735 ok_eq_ulong(Inverted.Count, 3UL);
736 Expected[0].Start = 0x0; Expected[0].End = 0xFF;
737 Expected[1].Start = 0x201; Expected[1].End = 0x3FF;
738 Expected[2].Start = 0x501; Expected[2].End = ULLONG_MAX;
739 Expected[0].Attributes = Expected[1].Attributes = Expected[2].Attributes = 0;
740 Expected[0].Flags = Expected[1].Flags = Expected[2].Flags = 0;
741 Expected[0].UserData = Expected[1].UserData = Expected[2].UserData = NULL;
742 Expected[0].Owner = Expected[1].Owner = Expected[2].Owner = NULL;
743 expect_range_entries(&Inverted, 3, Expected);
744 RtlFreeRangeList(&Inverted);
745
746 /* Ex invert: the gap ranges carry the supplied Attributes / UserData / Owner */
747 RtlInitializeRangeList(&Inverted);
748 Status = RtlInvertRangeListEx(&Inverted, &List, 0x5, &MyUserData1, &MyOwner1);
749 ok_eq_hex(Status, STATUS_SUCCESS);
750 ok_eq_ulong(Inverted.Count, 3UL);
751 Expected[0].Attributes = Expected[1].Attributes = Expected[2].Attributes = 0x5;
752 Expected[0].UserData = Expected[1].UserData = Expected[2].UserData = &MyUserData1;
753 Expected[0].Owner = Expected[1].Owner = Expected[2].Owner = &MyOwner1;
754 expect_range_entries(&Inverted, 3, Expected);
755 RtlFreeRangeList(&Inverted);
756
757 RtlFreeRangeList(&List);
758
759 /* Inverting an empty list yields the whole address space */
760 RtlInitializeRangeList(&List);
761 RtlInitializeRangeList(&Inverted);
762 Status = RtlInvertRangeList(&Inverted, &List);
763 ok_eq_hex(Status, STATUS_SUCCESS);
764 ok_eq_ulong(Inverted.Count, 1UL);
765 Expected[0].Start = 0x0;
766 Expected[0].End = ULLONG_MAX;
767 Expected[0].Attributes = 0;
768 Expected[0].Flags = 0;
769 Expected[0].UserData = NULL;
770 Expected[0].Owner = NULL;
771 expect_range_entries(&Inverted, 1, Expected);
772 RtlFreeRangeList(&Inverted);
773 RtlFreeRangeList(&List);
774}
775
776/* Entry point ***************************************************************/
777START_TEST(RtlRangeList)
778{
779 NTSTATUS Status;
780 RTL_RANGE_LIST RangeList;
781 RTL_RANGE Ranges[5];
782 ULONG Stamp;
783
784 RtlFillMemory(&RangeList, sizeof(RangeList), 0x55);
785 RtlInitializeRangeList(&RangeList);
786 ok(IsListEmpty(&RangeList.ListHead),
787 "RangeList.ListHead %p %p %p, expected empty\n",
788 &RangeList.ListHead, RangeList.ListHead.Flink, RangeList.ListHead.Blink);
789 ok_eq_ulong(RangeList.Flags, 0UL);
790 ok_eq_ulong(RangeList.Count, 0UL);
791 ok_eq_ulong(RangeList.Stamp, 0UL);
792#ifdef _WIN64
793 /* Padding at the end is uninitialized */
794 C_ASSERT(sizeof(RangeList) == RTL_SIZEOF_THROUGH_FIELD(RTL_RANGE_LIST, Stamp) + sizeof(ULONG));
795 ok_eq_ulong((&RangeList.Stamp)[1], 0x55555555UL);
796#endif
797
798 /* Add a simple range */
799 Ranges[0].Start = 0x100;
800 Ranges[0].End = 0x200;
801 Ranges[0].Attributes = 1;
802 Ranges[0].Flags = 0;
803 Ranges[0].UserData = &MyUserData1;
804 Ranges[0].Owner = &MyOwner1;
805 Status = RtlAddRangeWrapper(&RangeList, &Ranges[0], 0);
806 ok_eq_hex(Status, STATUS_SUCCESS);
807 ok_eq_ulong(RangeList.Flags, 0UL);
808 ok_eq_ulong(RangeList.Count, 1UL);
809 ok_eq_ulong(RangeList.Stamp, 1UL);
810 expect_range_entries(&RangeList, 1, &Ranges[0]);
811
812 /*
813 * Individual tests.
814 * These should always leave the list with our single start entry.
815 * Stamp may change between tests.
816 */
817 TestStartGreaterThanEnd(&RangeList, Ranges);
818 TestStartEqualsEnd(&RangeList, Ranges);
819 TestSharedFlag(&RangeList, Ranges);
820 TestIsAvailable(&RangeList, Ranges);
821 TestAddConflict(&RangeList, Ranges);
822 TestFindRange(&RangeList, Ranges);
823 TestGetLastRange(&RangeList, Ranges);
824 TestSharedNullCallback(&RangeList, Ranges);
825 TestDeleteOwnersRanges(&RangeList, Ranges);
826 TestInvertRangeList();
827
828 Stamp = RangeList.Stamp;
829
830 /* Free it and check the result */
831 RtlFreeRangeList(&RangeList);
832 ok_eq_ulong(RangeList.Flags, 0UL);
833 ok_eq_ulong(RangeList.Count, 0UL);
834 ok_eq_ulong(RangeList.Stamp, Stamp);
835 expect_range_entries(&RangeList, 0, NULL);
836}
Expected
BOOLEAN Expected
Definition: FsRtlExpression.c:22
Start
static _Out_opt_ PULONGLONG Start
Definition: RtlMemIoResource.c:16
RtlAddRangeWrapper
static NTSTATUS RtlAddRangeWrapper(_Inout_ PRTL_RANGE_LIST RangeList, _In_ const RTL_RANGE *Range, _In_ ULONG Flags)
Definition: RtlRangeList.c:43
ExpectRangeEntryList
static void ExpectRangeEntryList(_In_ PCSTR File, _In_ INT Line, _In_ RTL_RANGE_LIST *RangeList, _In_ ULONG NumRanges, _In_reads_(NumRanges) const RTL_RANGE *Ranges)
Definition: RtlRangeList.c:85
MyUserData1
static UCHAR MyUserData1
Definition: RtlRangeList.c:12
TestAddConflict
static void TestAddConflict(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:439
TestDeleteOwnersRanges
static void TestDeleteOwnersRanges(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:673
MyOwner2
static UCHAR MyOwner2
Definition: RtlRangeList.c:13
TestGetLastRange
static void TestGetLastRange(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:533
ExpectRange
static void ExpectRange(_In_ PCSTR File, _In_ INT Line, _In_ ULONG Index, _In_ const RTL_RANGE *ActualRange, _In_ const RTL_RANGE *ExpectedRange)
Definition: RtlRangeList.c:59
TestFindRange
static void TestFindRange(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:475
TestStartEqualsEnd
static void TestStartEqualsEnd(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:194
MyOwner1
static UCHAR MyOwner1
Definition: RtlRangeList.c:13
TestSharedNullCallback
static void TestSharedNullCallback(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:605
KeepConflictCallback
static BOOLEAN NTAPI KeepConflictCallback(_In_ PVOID Context, _In_ struct _RTL_RANGE *Range)
Definition: RtlRangeList.c:31
IgnoreConflictCallback
static BOOLEAN NTAPI IgnoreConflictCallback(_In_ PVOID Context, _In_ struct _RTL_RANGE *Range)
Definition: RtlRangeList.c:19
expect_range_entries
#define expect_range_entries(RangeList, NumRanges, Ranges)
Definition: RtlRangeList.c:161
TestStartGreaterThanEnd
static void TestStartGreaterThanEnd(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:167
is_range_available
#define is_range_available(RangeList, Start, End, pAvail)
MyUserData2
static UCHAR MyUserData2
Definition: RtlRangeList.c:12
TestIsAvailable
static void TestIsAvailable(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:264
TestInvertRangeList
static void TestInvertRangeList(void)
Definition: RtlRangeList.c:718
TestSharedFlag
static void TestSharedFlag(_Inout_ PRTL_RANGE_LIST RangeList, _Inout_ PRTL_RANGE Ranges)
Definition: RtlRangeList.c:229
BOOLEAN
unsigned char BOOLEAN
Definition: actypes.h:127
ok_eq_pointer
#define ok_eq_pointer(value, expected)
Definition: apitest.h:116
ok_eq_hex
#define ok_eq_hex(value, expected)
Definition: apitest.h:134
ok_eq_ulong
#define ok_eq_ulong(value, expected)
Definition: apitest.h:120
ok_eq_ulonglong
#define ok_eq_ulonglong(value, expected)
Definition: apitest.h:122
ok_eq_bool
#define ok_eq_bool(value, expected)
Definition: apitest.h:137
ok
#define ok(value,...)
Definition: atltest.h:57
START_TEST
#define START_TEST(x)
Definition: atltest.h:75
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
File
Definition: File.h:16
NULL
#define NULL
Definition: types.h:112
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
ULLONG_MAX
#define ULLONG_MAX
Definition: limits.h:35
IsListEmpty
#define IsListEmpty(ListHead)
Definition: env_spec_w32.h:954
Status
Status
Definition: gdiplustypes.h:24
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
C_ASSERT
#define C_ASSERT(e)
Definition: intsafe.h:73
kmt_test.h
KmtOk
BOOLEAN BOOLEAN KmtOk(INT Condition, PCSTR FileAndLine, PCSTR Format,...) KMT_FORMAT(ms_printf
KmtSkip
BOOLEAN BOOLEAN VOID VOID BOOLEAN BOOLEAN KmtSkip(INT Condition, PCSTR FileAndLine, PCSTR Format,...) KMT_FORMAT(ms_printf
KmtInvalidPointer
#define KmtInvalidPointer
Definition: kmt_test.h:287
RtlIsRangeAvailable
NTSYSAPI NTSTATUS NTAPI RtlIsRangeAvailable(_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_ PBOOLEAN Available)
RtlDeleteOwnersRanges
NTSYSAPI NTSTATUS NTAPI RtlDeleteOwnersRanges(_Inout_ PRTL_RANGE_LIST RangeList, _In_ _Maybenull_ PVOID Owner)
Owner
_Out_writes_bytes_to_opt_ AbsoluteSecurityDescriptorSize PSECURITY_DESCRIPTOR _Inout_ PULONG _Out_writes_bytes_to_opt_ DaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ SaclSize PACL _Inout_ PULONG _Out_writes_bytes_to_opt_ OwnerSize PSID Owner
Definition: rtlfuncs.h:1629
RtlDeleteRange
NTSYSAPI NTSTATUS NTAPI RtlDeleteRange(_Inout_ PRTL_RANGE_LIST RangeList, _In_ ULONGLONG Start, _In_ ULONGLONG End, _In_ PVOID Owner)
RtlAddRange
NTSYSAPI NTSTATUS NTAPI RtlAddRange(_Inout_ PRTL_RANGE_LIST RangeList, _In_ ULONGLONG Start, _In_ ULONGLONG End, _In_ UCHAR Attributes, _In_ ULONG Flags, _In_opt_ PVOID UserData, _In_opt_ PVOID Owner)
RtlInvertRangeList
NTSYSAPI NTSTATUS NTAPI RtlInvertRangeList(_Out_ PRTL_RANGE_LIST InvertedRangeList, _In_ PRTL_RANGE_LIST RangeList)
RtlInitializeRangeList
NTSYSAPI VOID NTAPI RtlInitializeRangeList(_Out_ PRTL_RANGE_LIST RangeList)
RtlGetLastRange
NTSYSAPI NTSTATUS NTAPI RtlGetLastRange(_In_ PRTL_RANGE_LIST RangeList, _Out_ PRTL_RANGE_LIST_ITERATOR Iterator, _Outptr_ PRTL_RANGE *Range)
RtlFindRange
NTSYSAPI 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_opt_ PVOID Context, _In_opt_ PRTL_CONFLICT_RANGE_CALLBACK Callback, _Out_ PULONGLONG Start)
RtlInvertRangeListEx
NTSYSAPI NTSTATUS NTAPI RtlInvertRangeListEx(_Out_ PRTL_RANGE_LIST InvertedRangeList, _In_ PRTL_RANGE_LIST RangeList, _In_ UCHAR Attributes, _In_opt_ PVOID UserData, _In_opt_ PVOID Owner)
RtlGetNextRange
NTSYSAPI NTSTATUS NTAPI RtlGetNextRange(_Inout_ PRTL_RANGE_LIST_ITERATOR Iterator, _Outptr_ PRTL_RANGE *Range, _In_ BOOLEAN MoveForwards)
RtlGetFirstRange
NTSYSAPI NTSTATUS NTAPI RtlGetFirstRange(_In_ PRTL_RANGE_LIST RangeList, _Out_ PRTL_RANGE_LIST_ITERATOR Iterator, _Outptr_ PRTL_RANGE *Range)
RtlFreeRangeList
NTSYSAPI VOID NTAPI RtlFreeRangeList(_In_ PRTL_RANGE_LIST RangeList)
RTL_RANGE_LIST_ADD_IF_CONFLICT
#define RTL_RANGE_LIST_ADD_IF_CONFLICT
Definition: rtltypes.h:81
RTL_RANGE_LIST_ADD_SHARED
#define RTL_RANGE_LIST_ADD_SHARED
Definition: rtltypes.h:82
RTL_RANGE_LIST_NULL_CONFLICT_OK
#define RTL_RANGE_LIST_NULL_CONFLICT_OK
Definition: rtltypes.h:90
RTL_RANGE_SHARED
#define RTL_RANGE_SHARED
Definition: rtltypes.h:92
RTL_RANGE_LIST_SHARED_OK
#define RTL_RANGE_LIST_SHARED_OK
Definition: rtltypes.h:89
_In_reads_
#define _In_reads_(s)
Definition: no_sal2.h:168
_Inout_
#define _Inout_
Definition: no_sal2.h:162
_In_
#define _In_
Definition: no_sal2.h:158
RTL_SIZEOF_THROUGH_FIELD
#define RTL_SIZEOF_THROUGH_FIELD(type, field)
Definition: ntbasedef.h:684
UNREFERENCED_PARAMETER
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:329
STATUS_NO_MORE_ENTRIES
#define STATUS_NO_MORE_ENTRIES
Definition: ntstatus.h:285
STATUS_RANGE_LIST_CONFLICT
#define STATUS_RANGE_LIST_CONFLICT
Definition: ntstatus.h:885
STATUS_RANGE_NOT_FOUND
#define STATUS_RANGE_NOT_FOUND
Definition: ntstatus.h:893
RtlStringCbPrintfA
NTSTRSAFEVAPI RtlStringCbPrintfA(_Out_writes_bytes_(cbDest) _Always_(_Post_z_) NTSTRSAFE_PSTR pszDest, _In_ size_t cbDest, _In_ _Printf_format_string_ NTSTRSAFE_PCSTR pszFormat,...)
Definition: ntstrsafe.h:1148
CHAR
char CHAR
Definition: pedump.c:57
RtlFillMemory
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:603
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
Context
_In_ PVOID Context
Definition: storport.h:2269
Line
Definition: ncftp.h:79
_LIST_ENTRY::Blink
struct _LIST_ENTRY * Blink
Definition: typedefs.h:122
_LIST_ENTRY::Flink
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
_RANGE_LIST_ITERATOR
Definition: rtltypes.h:1505
_RTL_RANGE_LIST
Definition: rtltypes.h:1487
_RTL_RANGE_LIST::Stamp
ULONG Stamp
Definition: rtltypes.h:1491
_RTL_RANGE_LIST::ListHead
LIST_ENTRY ListHead
Definition: rtltypes.h:1488
_RTL_RANGE_LIST::Count
ULONG Count
Definition: rtltypes.h:1490
_RTL_RANGE_LIST::Flags
ULONG Flags
Definition: rtltypes.h:1489
_RTL_RANGE
Definition: rtltypes.h:1495
_RTL_RANGE::End
ULONGLONG End
Definition: rtltypes.h:1497
_RTL_RANGE::Start
ULONGLONG Start
Definition: rtltypes.h:1496
_RTL_RANGE::Attributes
UCHAR Attributes
Definition: rtltypes.h:1500
_RTL_RANGE::UserData
PVOID UserData
Definition: rtltypes.h:1498
_RTL_RANGE::Owner
PVOID Owner
Definition: rtltypes.h:1499
_RTL_RANGE::Flags
UCHAR Flags
Definition: rtltypes.h:1501
UL
#define UL
Definition: tui.h:164
UCHAR
unsigned char UCHAR
Definition: typedefs.h:53
NTAPI
#define NTAPI
Definition: typedefs.h:36
INT
int32_t INT
Definition: typedefs.h:58
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
PCSTR
const char * PCSTR
Definition: typedefs.h:52
ULONG
uint32_t ULONG
Definition: typedefs.h:59
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
Iterator
_In_ WDFCHILDLIST _In_ PWDF_CHILD_LIST_ITERATOR Iterator
Definition: wdfchildlist.h:656
Index
_In_ WDFCOLLECTION _In_ ULONG Index
Definition: wdfcollection.h:182
Attributes
_Must_inspect_result_ _In_ WDFDMAENABLER _In_ _In_opt_ PWDF_OBJECT_ATTRIBUTES Attributes
Definition: wdfcommonbuffer.h:97
List
_Must_inspect_result_ _In_ WDFCMRESLIST List
Definition: wdfresource.h:550
Flags
_Must_inspect_result_ _In_ ULONG Flags
Definition: wsk.h:170