[STORAHCI] Merge Storport Miniport driver by Aman Priyadarshi in GSoC.
[reactos.git] / rostests / kmtests / ntos_mm / MmReservedMapping.c
1 /*
2 * PROJECT: ReactOS kernel-mode tests
3 * LICENSE: LGPLv2.1+ - See COPYING.LIB in the top level directory
4 * PURPOSE: Kernel-Mode Test Suite Reserved Mapping test
5 * PROGRAMMER: Thomas Faber <thomas.faber@reactos.org>
6 */
7
8 #include <kmt_test.h>
9
10 #ifdef _M_IX86
11
12 #define PTE_BASE 0xC0000000
13 #define MiAddressToPte(x) \
14 ((PMMPTE)(((((ULONG)(x)) >> 12) << 2) + PTE_BASE))
15 #define MiPteToAddress(_Pte) ((PVOID)((ULONG)(_Pte) << 10))
16
17 #elif defined(_M_AMD64)
18
19 #define PTI_SHIFT 12L
20 #define PTE_BASE 0xFFFFF68000000000ULL
21 PMMPTE
22 FORCEINLINE
23 _MiAddressToPte(PVOID Address)
24 {
25 ULONG64 Offset = (ULONG64)Address >> (PTI_SHIFT - 3);
26 Offset &= 0xFFFFFFFFFULL << 3;
27 return (PMMPTE)(PTE_BASE + Offset);
28 }
29 #define MiAddressToPte(x) _MiAddressToPte((PVOID)(x))
30
31 #endif
32
33 static
34 _Must_inspect_result_
35 _IRQL_requires_max_ (DISPATCH_LEVEL)
36 PMDL
37 (NTAPI
38 *pMmAllocatePagesForMdlEx)(
39 _In_ PHYSICAL_ADDRESS LowAddress,
40 _In_ PHYSICAL_ADDRESS HighAddress,
41 _In_ PHYSICAL_ADDRESS SkipBytes,
42 _In_ SIZE_T TotalBytes,
43 _In_ MEMORY_CACHING_TYPE CacheType,
44 _In_ ULONG Flags);
45
46 static
47 BOOLEAN
48 ValidateMapping(
49 _In_ PVOID BaseAddress,
50 _In_ ULONG TotalPtes,
51 _In_ ULONG PoolTag,
52 _In_ ULONG ValidPtes,
53 _In_ PPFN_NUMBER Pfns)
54 {
55 BOOLEAN Valid = TRUE;
56 #if defined(_M_IX86) || defined(_M_AMD64)
57 PMMPTE PointerPte;
58 ULONG i;
59
60 PointerPte = MiAddressToPte(BaseAddress);
61 for (i = 0; i < ValidPtes; i++)
62 {
63 Valid = Valid &&
64 ok(PointerPte[i].u.Hard.Valid == 1,
65 "[%lu] PTE %p is not valid\n", i, &PointerPte[i]);
66
67 Valid = Valid &&
68 ok(PointerPte[i].u.Hard.PageFrameNumber == Pfns[i],
69 "[%lu] PTE %p has PFN %Ix, expected %Ix\n",
70 i, &PointerPte[i], PointerPte[i].u.Hard.PageFrameNumber, Pfns[i]);
71 }
72 for (; i < TotalPtes; i++)
73 {
74 Valid = Valid &&
75 ok_eq_hex(PointerPte[i].u.Long, 0UL);
76 }
77 Valid = Valid &&
78 ok_eq_tag(PointerPte[-1].u.Long, PoolTag & ~1);
79 Valid = Valid &&
80 ok_eq_ulong(PointerPte[-2].u.Long, (TotalPtes + 2) * 2);
81 #endif
82
83 return Valid;
84 }
85
86 static
87 VOID
88 TestMap(
89 _In_ PVOID Mapping,
90 _In_ ULONG TotalPtes,
91 _In_ ULONG PoolTag)
92 {
93 PMDL Mdl;
94 PHYSICAL_ADDRESS ZeroPhysical;
95 PHYSICAL_ADDRESS MaxPhysical;
96 PVOID BaseAddress;
97 PPFN_NUMBER MdlPages;
98 ULONG i;
99
100 if (skip(pMmAllocatePagesForMdlEx != NULL, "MmAllocatePagesForMdlEx unavailable\n"))
101 {
102 return;
103 }
104
105 ZeroPhysical.QuadPart = 0;
106 MaxPhysical.QuadPart = 0xffffffffffffffffLL;
107
108 /* Create a one-page MDL and map it */
109 Mdl = pMmAllocatePagesForMdlEx(ZeroPhysical,
110 MaxPhysical,
111 ZeroPhysical,
112 PAGE_SIZE,
113 MmCached,
114 0);
115 if (skip(Mdl != NULL, "No MDL\n"))
116 {
117 return;
118 }
119
120 MdlPages = (PVOID)(Mdl + 1);
121
122 BaseAddress = MmMapLockedPagesWithReservedMapping(Mapping,
123 PoolTag,
124 Mdl,
125 MmCached);
126 ok(BaseAddress != NULL, "MmMapLockedPagesWithReservedMapping failed\n");
127 if (!skip(BaseAddress != NULL, "Failed to map MDL\n"))
128 {
129 ok_eq_pointer(BaseAddress, Mapping);
130
131 ok_bool_true(ValidateMapping(BaseAddress, TotalPtes, PoolTag, 1, MdlPages),
132 "ValidateMapping returned");
133
134 KmtStartSeh()
135 *(volatile ULONG *)BaseAddress = 0x01234567;
136 KmtEndSeh(STATUS_SUCCESS);
137
138 MmUnmapReservedMapping(BaseAddress,
139 PoolTag,
140 Mdl);
141
142 ok_bool_true(ValidateMapping(Mapping, TotalPtes, PoolTag, 0, NULL),
143 "ValidateMapping returned");
144 }
145
146 /* Try again but at an unaligned address */
147 BaseAddress = MmMapLockedPagesWithReservedMapping((PUCHAR)Mapping + sizeof(ULONG),
148 PoolTag,
149 Mdl,
150 MmCached);
151 ok(BaseAddress != NULL, "MmMapLockedPagesWithReservedMapping failed\n");
152 if (!skip(BaseAddress != NULL, "Failed to map MDL\n"))
153 {
154 ok_eq_pointer(BaseAddress, (PUCHAR)Mapping + sizeof(ULONG));
155
156 ok_bool_true(ValidateMapping(BaseAddress, TotalPtes, PoolTag, 1, MdlPages),
157 "ValidateMapping returned");
158
159 KmtStartSeh()
160 *(volatile ULONG *)BaseAddress = 0x01234567;
161 KmtEndSeh(STATUS_SUCCESS);
162
163 MmUnmapReservedMapping(BaseAddress,
164 PoolTag,
165 Mdl);
166
167 ok_bool_true(ValidateMapping(Mapping, TotalPtes, PoolTag, 0, NULL),
168 "ValidateMapping returned");
169 }
170
171 MmFreePagesFromMdl(Mdl);
172
173 /* Map all pages */
174 Mdl = pMmAllocatePagesForMdlEx(ZeroPhysical,
175 MaxPhysical,
176 ZeroPhysical,
177 TotalPtes * PAGE_SIZE,
178 MmCached,
179 0);
180 if (skip(Mdl != NULL, "No MDL\n"))
181 {
182 return;
183 }
184
185 MdlPages = (PVOID)(Mdl + 1);
186
187 BaseAddress = MmMapLockedPagesWithReservedMapping(Mapping,
188 PoolTag,
189 Mdl,
190 MmCached);
191 ok(BaseAddress != NULL, "MmMapLockedPagesWithReservedMapping failed\n");
192 if (!skip(BaseAddress != NULL, "Failed to map MDL\n"))
193 {
194 ok_eq_pointer(BaseAddress, Mapping);
195
196 ok_bool_true(ValidateMapping(BaseAddress, TotalPtes, PoolTag, TotalPtes, MdlPages),
197 "ValidateMapping returned");
198
199 for (i = 0; i < TotalPtes; i++)
200 {
201 KmtStartSeh()
202 *((volatile ULONG *)BaseAddress + i * PAGE_SIZE / sizeof(ULONG)) = 0x01234567;
203 KmtEndSeh(STATUS_SUCCESS);
204 }
205
206 MmUnmapReservedMapping(BaseAddress,
207 PoolTag,
208 Mdl);
209
210 ok_bool_true(ValidateMapping(Mapping, TotalPtes, PoolTag, 0, NULL),
211 "ValidateMapping returned");
212 }
213
214 MmFreePagesFromMdl(Mdl);
215
216 /* Try to map more pages than we reserved */
217 Mdl = pMmAllocatePagesForMdlEx(ZeroPhysical,
218 MaxPhysical,
219 ZeroPhysical,
220 (TotalPtes + 1) * PAGE_SIZE,
221 MmCached,
222 0);
223 if (skip(Mdl != NULL, "No MDL\n"))
224 {
225 return;
226 }
227
228 BaseAddress = MmMapLockedPagesWithReservedMapping(Mapping,
229 PoolTag,
230 Mdl,
231 MmCached);
232 ok_eq_pointer(BaseAddress, NULL);
233 if (BaseAddress)
234 {
235 MmUnmapReservedMapping(BaseAddress,
236 PoolTag,
237 Mdl);
238 }
239
240 MmFreePagesFromMdl(Mdl);
241 }
242
243 START_TEST(MmReservedMapping)
244 {
245 PVOID Mapping;
246
247 pMmAllocatePagesForMdlEx = KmtGetSystemRoutineAddress(L"MmAllocatePagesForMdlEx");
248
249 /* one byte - single page */
250 Mapping = MmAllocateMappingAddress(1, 'MRmK');
251 ok(Mapping != NULL, "MmAllocateMappingAddress failed\n");
252 if (!skip(Mapping != NULL, "No mapping\n"))
253 {
254 ok_bool_true(ValidateMapping(Mapping, 1, 'MRmK', 0, NULL),
255 "ValidateMapping returned");
256
257 MmFreeMappingAddress(Mapping, 'MRmK');
258 }
259
260 /* 10 pages */
261 Mapping = MmAllocateMappingAddress(10 * PAGE_SIZE, 'MRmK' & ~1);
262 ok(Mapping != NULL, "MmAllocateMappingAddress failed\n");
263 if (!skip(Mapping != NULL, "No mapping\n"))
264 {
265 ok_bool_true(ValidateMapping(Mapping, 10, 'MRmK', 0, NULL),
266 "ValidateMapping returned");
267
268 /* PAGE_FAULT_IN_NONPAGED_AREA can't be caught with SEH */
269 if (0)
270 {
271 (void)*(volatile UCHAR *)Mapping;
272 }
273
274 TestMap(Mapping, 10, 'MRmK');
275
276 MmFreeMappingAddress(Mapping, 'MRmK');
277 }
278
279 /* PoolTag = 0 */
280 Mapping = MmAllocateMappingAddress(1, 0);
281 ok(Mapping == NULL, "MmAllocateMappingAddress failed\n");
282 if (Mapping != NULL)
283 {
284 MmFreeMappingAddress(Mapping, 0);
285 }
286
287 /* PoolTag = 1 */
288 Mapping = MmAllocateMappingAddress(1, 1);
289 ok(Mapping != NULL, "MmAllocateMappingAddress failed\n");
290 if (Mapping != NULL)
291 {
292 ok_bool_true(ValidateMapping(Mapping, 1, 1, 0, NULL),
293 "ValidateMapping returned");
294
295 TestMap(Mapping, 1, 1);
296
297 MmFreeMappingAddress(Mapping, 1);
298 }
299
300 /* Free an unaligned address */
301 Mapping = MmAllocateMappingAddress(PAGE_SIZE, 'MRmK');
302 ok(Mapping != NULL, "MmAllocateMappingAddress failed\n");
303 if (Mapping != NULL)
304 {
305 ok_bool_true(ValidateMapping(Mapping, 1, 'MRmK', 0, NULL),
306 "ValidateMapping returned");
307
308 TestMap(Mapping, 1, 'MRmK');
309
310 MmFreeMappingAddress((PUCHAR)Mapping + sizeof(ULONG), 'MRmK');
311 }
312 }