ReactOS 0.4.16-dev-1946-g52006dd
Macros | Functions
MmSection.c File Reference
#include <kmt_test.h>
Include dependency graph for MmSection.c:

Go to the source code of this file.

Macros

#define CheckObject(Handle, Pointers, Handles)
 
#define CheckSection(SectionObject, SectionFlag)   CheckSection_(__LINE__, SectionObject, SectionFlag)
 
#define TestMapView(SectionObject, ExpectAtBase, ExpectM)
 

Functions

static void CheckSection_ (ULONG Line, PVOID SectionObject, ULONG SectionFlag)
 
static VOID TestCreateSection (IN HANDLE FileHandle1, IN PFILE_OBJECT FileObject1, IN HANDLE FileHandle2, IN PFILE_OBJECT FileObject2)
 
static VOID TestPhysicalMemorySection (VOID)
 
 START_TEST (MmSection)
 

Macro Definition Documentation

◆ CheckObject

#define CheckObject (   Handle,
  Pointers,
  Handles 
)
Value:
do \
{ \
PUBLIC_OBJECT_BASIC_INFORMATION ObjectInfo; \
Status = ZwQueryObject(Handle, ObjectBasicInformation, \
&ObjectInfo, sizeof ObjectInfo, NULL); \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok_eq_ulong(ObjectInfo.PointerCount, Pointers); \
ok_eq_ulong(ObjectInfo.HandleCount, Handles); \
} while (0)
ObjectBasicInformation
@ ObjectBasicInformation
Definition: DriverTester.h:54
NULL
#define NULL
Definition: types.h:112
Handle
ULONG Handle
Definition: gdb_input.c:15
Status
Status
Definition: gdiplustypes.h:25
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
_PUBLIC_OBJECT_BASIC_INFORMATION
Definition: winternl.h:448
_PUBLIC_OBJECT_BASIC_INFORMATION::PointerCount
ULONG PointerCount
Definition: winternl.h:452
_PUBLIC_OBJECT_BASIC_INFORMATION::HandleCount
ULONG HandleCount
Definition: winternl.h:451

Definition at line 10 of file MmSection.c.

◆ CheckSection

#define CheckSection (   SectionObject,
  SectionFlag 
)    CheckSection_(__LINE__, SectionObject, SectionFlag)

Definition at line 50 of file MmSection.c.

◆ TestMapView

#define TestMapView (   SectionObject,
  ExpectAtBase,
  ExpectM 
)

Definition at line 52 of file MmSection.c.

Function Documentation

◆ CheckSection_()

static void CheckSection_ ( ULONG  Line,
PVOID  SectionObject,
ULONG  SectionFlag 
)
static

Definition at line 22 of file MmSection.c.

23{
24 SECTION_BASIC_INFORMATION Sbi;
25 HANDLE SectionHandle = NULL;
26 NTSTATUS Status;
27
28 if (skip(SectionObject != NULL &&
29 SectionObject != (PVOID)0x5555555555555555ULL,
30 "No section object\n"))
31 return;
32
33 Status = ObOpenObjectByPointer(SectionObject, OBJ_KERNEL_HANDLE,
34 NULL, 0, MmSectionObjectType,
35 KernelMode, &SectionHandle);
36 ok(Status == STATUS_SUCCESS, "Line %lu: Status = 0x%lx, expected STATUS_SUCCESS\n", Line, Status);
37 ok(SectionHandle != NULL, "Line %lu: Section handle null\n", Line);
38 if (!skip(NT_SUCCESS(Status) && SectionHandle,
39 "No section handle\n"))
40 {
41 Status = ZwQuerySection(SectionHandle, SectionBasicInformation,
42 &Sbi, sizeof Sbi, NULL);
43 ok(Status == STATUS_SUCCESS, "Line %lu: Status = 0x%lx, expected STATUS_SUCCESS\n", Line, Status);
44 ok(Sbi.BaseAddress == NULL, "Line %lu: Sbi.BaseAddress = 0x%p, expected NULL\n", Line, Sbi.BaseAddress);
45 ok(Sbi.Size.QuadPart == 1LL, "Line %lu: Sbi.Size.QuadPart = 0x%I64x, expected 1\n", Line, Sbi.Size.QuadPart);
46 ok(Sbi.Attributes == (SectionFlag | SEC_FILE), "Line %lu: Sbi.Attributes = 0x%lx, expected 0x%x\n", Line, Sbi.Attributes, (SectionFlag | SEC_FILE));
47 ZwClose(SectionHandle);
48 }
49}
ok
#define ok(value,...)
Definition: atltest.h:57
skip
#define skip(...)
Definition: atltest.h:64
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
SectionObject
_Must_inspect_result_ _Outptr_ PVOID * SectionObject
Definition: fsrtlfuncs.h:860
OBJ_KERNEL_HANDLE
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
KernelMode
#define KernelMode
Definition: asm.h:38
ZwQuerySection
NTSYSAPI NTSTATUS NTAPI ZwQuerySection(_In_ HANDLE SectionHandle, _In_ SECTION_INFORMATION_CLASS SectionInformationClass, _Out_ PVOID SectionInformation, _In_ SIZE_T Length, _Out_opt_ PSIZE_T ResultLength)
SEC_FILE
#define SEC_FILE
Definition: mmtypes.h:96
SectionBasicInformation
@ SectionBasicInformation
Definition: mmtypes.h:195
ZwClose
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
ObOpenObjectByPointer
NTSTATUS NTAPI ObOpenObjectByPointer(IN PVOID Object, IN ULONG HandleAttributes, IN PACCESS_STATE PassedAccessState, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PHANDLE Handle)
Definition: obhandle.c:2742
MmSectionObjectType
POBJECT_TYPE MmSectionObjectType
Definition: section.c:192
Line
Definition: ncftp.h:79
_SECTION_BASIC_INFORMATION
Definition: mmtypes.h:333
_SECTION_BASIC_INFORMATION::BaseAddress
PVOID BaseAddress
Definition: mmtypes.h:334
_SECTION_BASIC_INFORMATION::Attributes
ULONG Attributes
Definition: mmtypes.h:335
_SECTION_BASIC_INFORMATION::Size
LARGE_INTEGER Size
Definition: mmtypes.h:336
_LARGE_INTEGER::QuadPart
LONGLONG QuadPart
Definition: typedefs.h:114

◆ START_TEST()

START_TEST ( MmSection  )

Definition at line 961 of file MmSection.c.

962{
963 NTSTATUS Status;
964 HANDLE FileHandle1 = NULL, FileHandle2 = NULL;
965 PFILE_OBJECT FileObject1 = NULL, FileObject2 = NULL;
966 OBJECT_ATTRIBUTES ObjectAttributes;
967 IO_STATUS_BLOCK IoStatusBlock;
968 UNICODE_STRING FileName1 = RTL_CONSTANT_STRING(L"\\SystemRoot\\kmtest-MmSection.txt");
969 UNICODE_STRING FileName2 = RTL_CONSTANT_STRING(L"\\SystemRoot\\system32\\ntdll.dll");
970 LARGE_INTEGER FileOffset;
971 UCHAR FileData = 0;
972
973 ok(ExGetPreviousMode() == UserMode, "Previous mode is kernel mode\n");
974 /* create a one-byte file that we can use */
975 InitializeObjectAttributes(&ObjectAttributes, &FileName1, OBJ_CASE_INSENSITIVE, NULL, NULL);
976 Status = ZwCreateFile(&FileHandle1, GENERIC_WRITE | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_SUPERSEDE, FILE_NON_DIRECTORY_FILE, NULL, 0);
977 ok_eq_hex(Status, STATUS_SUCCESS);
978 ok_eq_ulongptr(IoStatusBlock.Information, FILE_CREATED);
979 ok(FileHandle1 != NULL, "FileHandle1 is NULL\n");
980 if (FileHandle1)
981 {
982 FileOffset.QuadPart = 0;
983 Status = ZwWriteFile(FileHandle1, NULL, NULL, NULL, &IoStatusBlock, &FileData, sizeof FileData, &FileOffset, NULL);
984 ok(Status == STATUS_SUCCESS || Status == STATUS_PENDING, "Status = 0x%08lx\n", Status);
985 Status = ZwWaitForSingleObject(FileHandle1, FALSE, NULL);
986 ok_eq_hex(Status, STATUS_SUCCESS);
987 ok_eq_ulongptr(IoStatusBlock.Information, 1);
988 Status = ZwClose(FileHandle1);
989 ok_eq_hex(Status, STATUS_SUCCESS);
990 FileHandle1 = NULL;
991 }
992
993 InitializeObjectAttributes(&ObjectAttributes, &FileName1, OBJ_CASE_INSENSITIVE, NULL, NULL);
994 Status = ZwCreateFile(&FileHandle1, GENERIC_ALL, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_NON_DIRECTORY_FILE | FILE_DELETE_ON_CLOSE, NULL, 0);
995 ok_eq_hex(Status, STATUS_SUCCESS);
996 ok_eq_ulongptr(IoStatusBlock.Information, FILE_OPENED);
997 ok(FileHandle1 != NULL, "FileHandle1 is NULL\n");
998 if (GetNTVersion() < _WIN32_WINNT_WIN8)
999 CheckObject(FileHandle1, 2L, 1L);
1000#ifdef _M_IX86
1001 else
1002 CheckObject(FileHandle1, 33L, 1L);
1003#else
1004 else
1005 CheckObject(FileHandle1, 32769L, 1L);
1006#endif
1007
1008 InitializeObjectAttributes(&ObjectAttributes, &FileName2, OBJ_CASE_INSENSITIVE, NULL, NULL);
1009 Status = ZwCreateFile(&FileHandle2, GENERIC_READ, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_NON_DIRECTORY_FILE, NULL, 0);
1010 ok_eq_hex(Status, STATUS_SUCCESS);
1011 ok_eq_ulongptr(IoStatusBlock.Information, FILE_OPENED);
1012 ok(FileHandle2 != NULL, "FileHandle2 is NULL\n");
1013
1014 if (!skip(Status == STATUS_SUCCESS && FileHandle1 != NULL, "Failed to open file 1\n"))
1015 {
1016 Status = ObReferenceObjectByHandle(FileHandle1, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID *)&FileObject1, NULL);
1017 ok_eq_hex(Status, STATUS_SUCCESS);
1018 ok(FileObject1 != NULL, "FileObject1 is NULL\n");
1019 if (GetNTVersion() < _WIN32_WINNT_WIN8)
1020 CheckObject(FileHandle1, 3L, 1L);
1021#ifdef _M_IX86
1022 else
1023 CheckObject(FileHandle1, 32L, 1L);
1024#else
1025 else
1026 CheckObject(FileHandle1, 32768L, 1L);
1027#endif
1028 }
1029
1030 if (!skip(Status == STATUS_SUCCESS && FileHandle2 != NULL, "Failed to open file 2\n"))
1031 {
1032 Status = ObReferenceObjectByHandle(FileHandle2, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID *)&FileObject2, NULL);
1033 ok_eq_hex(Status, STATUS_SUCCESS);
1034 ok(FileObject2 != NULL, "FileObject2 is NULL\n");
1035 }
1036
1037 trace("FileHandle1=%p, FileObject1=%p\n", FileHandle1, FileObject1);
1038 trace("FileHandle2=%p, FileObject2=%p\n", FileHandle2, FileObject2);
1039 TestCreateSection(FileHandle1, FileObject1, FileHandle2, FileObject2);
1040
1041 if (FileObject2)
1042 ObDereferenceObject(FileObject2);
1043 if (FileObject1)
1044 ObDereferenceObject(FileObject1);
1045 if (FileHandle2)
1046 ZwClose(FileHandle2);
1047 if (FileHandle1)
1048 ZwClose(FileHandle1);
1049
1050 TestPhysicalMemorySection();
1051}
TestCreateSection
static VOID TestCreateSection(IN HANDLE FileHandle1, IN PFILE_OBJECT FileObject1, IN HANDLE FileHandle2, IN PFILE_OBJECT FileObject2)
Definition: MmSection.c:93
TestPhysicalMemorySection
static VOID TestPhysicalMemorySection(VOID)
Definition: MmSection.c:536
CheckObject
#define CheckObject(Handle, Pointers, Handles)
Definition: MmSection.c:10
FileName2
static const WCHAR FileName2[]
Definition: PrivMoveFileIdentityW.c:14
ok_eq_hex
#define ok_eq_hex(value, expected)
Definition: apitest.h:134
GetNTVersion
#define GetNTVersion()
Definition: apitest.h:17
ok_eq_ulongptr
#define ok_eq_ulongptr(value, expected)
Definition: apitest.h:128
trace
#define trace
Definition: atltest.h:70
FILE_NON_DIRECTORY_FILE
#define FILE_NON_DIRECTORY_FILE
Definition: constants.h:492
FILE_DELETE_ON_CLOSE
#define FILE_DELETE_ON_CLOSE
Definition: constants.h:494
FileData
static FILEDATA FileData[MAX_FDS]
Definition: fs.c:51
FileOffset
_In_ PFCB _In_ LONGLONG FileOffset
Definition: cdprocs.h:160
ObjectAttributes
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
FALSE
#define FALSE
Definition: types.h:117
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
FILE_ATTRIBUTE_NORMAL
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:136
L
#define L(x)
Definition: resources.c:13
ExGetPreviousMode
#define ExGetPreviousMode
Definition: ex.h:143
FILE_OPEN
#define FILE_OPEN
Definition: from_kernel.h:54
FILE_SUPERSEDE
#define FILE_SUPERSEDE
Definition: from_kernel.h:53
OBJ_CASE_INSENSITIVE
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
IoFileObjectType
POBJECT_TYPE IoFileObjectType
Definition: iomgr.c:36
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
UserMode
#define UserMode
Definition: asm.h:39
SYNCHRONIZE
#define SYNCHRONIZE
Definition: nt_native.h:61
FILE_WRITE_DATA
#define FILE_WRITE_DATA
Definition: nt_native.h:631
FILE_READ_DATA
#define FILE_READ_DATA
Definition: nt_native.h:628
FILE_CREATED
#define FILE_CREATED
Definition: nt_native.h:770
GENERIC_ALL
#define GENERIC_ALL
Definition: nt_native.h:92
FILE_OPENED
#define FILE_OPENED
Definition: nt_native.h:769
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
IoStatusBlock
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
ObReferenceObjectByHandle
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:494
_WIN32_WINNT_WIN8
#define _WIN32_WINNT_WIN8
Definition: sdkddkver.h:29
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
_IO_STATUS_BLOCK::Information
ULONG Information
Definition: env_spec_w32.h:872
_OBJECT_ATTRIBUTES
Definition: umtypes.h:184
_UNICODE_STRING
Definition: env_spec_w32.h:368
STATUS_PENDING
#define STATUS_PENDING
Definition: telnetd.h:14
RTL_CONSTANT_STRING
#define RTL_CONSTANT_STRING(s)
Definition: tunneltest.c:14
_LARGE_INTEGER
Definition: typedefs.h:103
PFILE_OBJECT
* PFILE_OBJECT
Definition: iotypes.h:1998
ObDereferenceObject
#define ObDereferenceObject
Definition: obfuncs.h:203
UCHAR
unsigned char UCHAR
Definition: xmlstorage.h:181

◆ TestCreateSection()

static VOID TestCreateSection ( IN HANDLE  FileHandle1,
IN PFILE_OBJECT  FileObject1,
IN HANDLE  FileHandle2,
IN PFILE_OBJECT  FileObject2 
)
static

Definition at line 93 of file MmSection.c.

98{
99 NTSTATUS Status = STATUS_SUCCESS, ExceptionStatus = STATUS_SUCCESS;
100 PVOID SectionObject;
101 LARGE_INTEGER MaximumSize;
102 ULONG PointerCount1, PointerCount2;
103
104 _SEH2_TRY
105 {
106 Status = MmCreateSection(NULL, 0, NULL, NULL, 0, SEC_RESERVE, NULL, NULL);
107 }
108 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
109 {
110 ExceptionStatus = _SEH2_GetExceptionCode();
111 }
112 _SEH2_END;
113
114 if (GetNTVersion() < _WIN32_WINNT_WIN10)
115 {
116 ok_eq_hex(ExceptionStatus, STATUS_SUCCESS);
117 ok_eq_hex(Status, STATUS_INVALID_PAGE_PROTECTION);
118 }
119 else
120 {
121 ok_eq_hex(ExceptionStatus, STATUS_ACCESS_VIOLATION);
122 ok_eq_hex(Status, STATUS_SUCCESS);
123 }
124
125 if (!KmtIsCheckedBuild)
126 {
127 /* PAGE_NOACCESS and missing SEC_RESERVE/SEC_COMMIT/SEC_IMAGE assert */
128 KmtStartSeh()
129 Status = MmCreateSection(NULL, 0, NULL, NULL, PAGE_NOACCESS, SEC_RESERVE, NULL, NULL);
130 KmtEndSeh(STATUS_ACCESS_VIOLATION);
131
132 KmtStartSeh()
133 Status = MmCreateSection(NULL, 0, NULL, NULL, PAGE_NOACCESS, 0, NULL, NULL);
134 KmtEndSeh(STATUS_ACCESS_VIOLATION);
135 }
136
137 SectionObject = KmtInvalidPointer;
138 _SEH2_TRY
139 {
140 Status = MmCreateSection(&SectionObject, 0, NULL, NULL, 0, SEC_RESERVE, NULL, NULL);
141 }
142 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
143 {
144 ExceptionStatus = _SEH2_GetExceptionCode();
145 }
146 _SEH2_END;
147
148 if (GetNTVersion() < _WIN32_WINNT_WIN10)
149 {
150 ok_eq_hex(ExceptionStatus, STATUS_SUCCESS);
151 ok_eq_hex(Status, STATUS_INVALID_PAGE_PROTECTION);
152 }
153 else
154 {
155 ok_eq_hex(ExceptionStatus, STATUS_ACCESS_VIOLATION);
156 ok_eq_hex(Status, STATUS_SUCCESS);
157 }
158 ok_eq_pointer(SectionObject, KmtInvalidPointer);
159
160 if (SectionObject && SectionObject != KmtInvalidPointer)
161 ObDereferenceObject(SectionObject);
162
163 KmtStartSeh()
164 Status = MmCreateSection(NULL, 0, NULL, NULL, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
165 KmtEndSeh(STATUS_ACCESS_VIOLATION);
166
167 SectionObject = KmtInvalidPointer;
168 KmtStartSeh()
169 Status = MmCreateSection(&SectionObject, 0, NULL, NULL, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
170 KmtEndSeh(STATUS_ACCESS_VIOLATION);
171 ok_eq_pointer(SectionObject, KmtInvalidPointer);
172
173 if (SectionObject && SectionObject != KmtInvalidPointer)
174 ObDereferenceObject(SectionObject);
175
176 SectionObject = KmtInvalidPointer;
177 MaximumSize.QuadPart = 0;
178 KmtStartSeh()
179 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, NULL, NULL);
180 KmtEndSeh(STATUS_SUCCESS);
181 ok_eq_hex(Status, STATUS_INVALID_FILE_FOR_SECTION);
182 ok_eq_longlong(MaximumSize.QuadPart, 0LL);
183 ok_eq_pointer(SectionObject, KmtInvalidPointer);
184
185 if (SectionObject && SectionObject != KmtInvalidPointer)
186 ObDereferenceObject(SectionObject);
187
188 MaximumSize.QuadPart = 0;
189 KmtStartSeh()
190 Status = MmCreateSection(NULL, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
191 KmtEndSeh(STATUS_SUCCESS);
192 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_4);
193 ok_eq_longlong(MaximumSize.QuadPart, 0LL);
194
195 if (SectionObject && SectionObject != KmtInvalidPointer)
196 ObDereferenceObject(SectionObject);
197
198 MaximumSize.QuadPart = -1;
199 KmtStartSeh()
200 Status = MmCreateSection(NULL, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
201 KmtEndSeh(STATUS_SUCCESS);
202 ok_eq_hex(Status, STATUS_SECTION_TOO_BIG);
203 ok_eq_longlong(MaximumSize.QuadPart, -1LL);
204
205 if (SectionObject && SectionObject != KmtInvalidPointer)
206 ObDereferenceObject(SectionObject);
207
208 MaximumSize.QuadPart = 1;
209 KmtStartSeh()
210 Status = MmCreateSection(NULL, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
211 KmtEndSeh(STATUS_ACCESS_VIOLATION);
212 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
213
214 if (SectionObject && SectionObject != KmtInvalidPointer)
215 ObDereferenceObject(SectionObject);
216
217 SectionObject = KmtInvalidPointer;
218 MaximumSize.QuadPart = 0;
219 KmtStartSeh()
220 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
221 KmtEndSeh(STATUS_SUCCESS);
222 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_4);
223 ok_eq_longlong(MaximumSize.QuadPart, 0LL);
224 ok_eq_pointer(SectionObject, KmtInvalidPointer);
225
226 if (SectionObject && SectionObject != KmtInvalidPointer)
227 ObDereferenceObject(SectionObject);
228
229 /* page file section */
230 SectionObject = KmtInvalidPointer;
231 MaximumSize.QuadPart = 1;
232 KmtStartSeh()
233 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
234 KmtEndSeh(STATUS_SUCCESS);
235 ok_eq_hex(Status, STATUS_SUCCESS);
236 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
237 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
238 ok(SectionObject != NULL, "Section object pointer NULL\n");
239
240 if (SectionObject && SectionObject != KmtInvalidPointer)
241 ObDereferenceObject(SectionObject);
242
243 if (!skip(FileHandle1 != NULL && FileObject1 != NULL &&
244 FileHandle2 != NULL && FileObject2 != NULL, "No file handle or object\n"))
245 {
246 if (GetNTVersion() < _WIN32_WINNT_WIN8)
247 {
248 PointerCount1 = 3;
249 PointerCount2 = 3;
250 }
251 else
252 {
253#ifdef _M_IX86
254 PointerCount1 = 31;
255 PointerCount2 = 33;
256#else
257 PointerCount1 = 32767;
258 PointerCount2 = 32769;
259#endif
260 }
261 /* image section */
262 CheckObject(FileHandle2, PointerCount2, 1L);
263 SectionObject = KmtInvalidPointer;
264 MaximumSize.QuadPart = 1;
265 KmtStartSeh()
266 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle2, NULL);
267 KmtEndSeh(STATUS_SUCCESS);
268 ok_eq_hex(Status, STATUS_SUCCESS);
269 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
270 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
271 ok(SectionObject != NULL, "Section object pointer NULL\n");
272 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
273 PointerCount2 -= 2;
274 CheckObject(FileHandle2, PointerCount2, 1L);
275 if (GetNTVersion() < _WIN32_WINNT_WIN8)
276 CheckSection(SectionObject, SEC_IMAGE);
277 TestMapView(SectionObject, FALSE, TRUE);
278
279 if (SectionObject && SectionObject != KmtInvalidPointer)
280 ObDereferenceObject(SectionObject);
281
282 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
283 PointerCount2--;
284 CheckObject(FileHandle2, PointerCount2, 1L);
285 SectionObject = KmtInvalidPointer;
286 MaximumSize.QuadPart = 1;
287 KmtStartSeh()
288 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, NULL, FileObject2);
289 KmtEndSeh(STATUS_SUCCESS);
290 if (GetNTVersion() < _WIN32_WINNT_WIN8)
291 ok_eq_hex(Status, STATUS_SUCCESS);
292 else
293 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
294 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
295 if (GetNTVersion() < _WIN32_WINNT_WIN8)
296 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
297 ok(SectionObject != NULL, "Section object pointer NULL\n");
298 if (GetNTVersion() == _WIN32_WINNT_WS03)
299 ++PointerCount2;
300 else if (GetNTVersion() >= _WIN32_WINNT_WIN8)
301 --PointerCount2;
302 CheckObject(FileHandle2, PointerCount2, 1L);
303 CheckSection(SectionObject, 0);
304 TestMapView(SectionObject, TRUE, TRUE);
305
306 if (SectionObject && SectionObject != KmtInvalidPointer)
307 ObDereferenceObject(SectionObject);
308
309 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
310 PointerCount2--;
311 CheckObject(FileHandle2, PointerCount2, 1L);
312 SectionObject = KmtInvalidPointer;
313 MaximumSize.QuadPart = 1;
314 KmtStartSeh()
315 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle2, FileObject2);
316 KmtEndSeh(STATUS_SUCCESS);
317 if (GetNTVersion() < _WIN32_WINNT_WIN8)
318 ok_eq_hex(Status, STATUS_SUCCESS);
319 else
320 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
321 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
322 if (GetNTVersion() < _WIN32_WINNT_WIN8)
323 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
324 ok(SectionObject != NULL, "Section object pointer NULL\n");
325 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
326 PointerCount2--;
327 CheckObject(FileHandle2, PointerCount2, 1L);
328 CheckSection(SectionObject, 0);
329 TestMapView(SectionObject, TRUE, TRUE);
330
331 if (SectionObject && SectionObject != KmtInvalidPointer)
332 ObDereferenceObject(SectionObject);
333
334 /* image section with inappropriate file */
335 CheckObject(FileHandle1, PointerCount1, 1L);
336 SectionObject = KmtInvalidPointer;
337 MaximumSize.QuadPart = 1;
338 KmtStartSeh()
339 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle1, NULL);
340 KmtEndSeh(STATUS_SUCCESS);
341 ok_eq_hex(Status, STATUS_INVALID_IMAGE_NOT_MZ);
342 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
343 ok_eq_pointer(SectionObject, KmtInvalidPointer);
344 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
345 PointerCount1 -= 2;
346 CheckObject(FileHandle1, PointerCount1, 1L);
347
348 if (SectionObject && SectionObject != KmtInvalidPointer)
349 ObDereferenceObject(SectionObject);
350
351 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
352 PointerCount1--;
353 CheckObject(FileHandle1, PointerCount1, 1L);
354 SectionObject = KmtInvalidPointer;
355 MaximumSize.QuadPart = 1;
356 KmtStartSeh()
357 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, NULL, FileObject1);
358 KmtEndSeh(STATUS_SUCCESS);
359 if (GetNTVersion() < _WIN32_WINNT_WIN8)
360 ok_eq_hex(Status, STATUS_SUCCESS);
361 else
362 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
363 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
364 if (GetNTVersion() < _WIN32_WINNT_WIN8)
365 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
366 ok(SectionObject != NULL, "Section object pointer NULL\n");
367 if (GetNTVersion() == _WIN32_WINNT_WS03)
368 ++PointerCount1;
369 else if (GetNTVersion() >= _WIN32_WINNT_WIN8)
370 --PointerCount1;
371 CheckObject(FileHandle1, PointerCount1, 1L);
372 CheckSection(SectionObject, 0);
373 TestMapView(SectionObject, TRUE, FALSE);
374
375 if (SectionObject && SectionObject != KmtInvalidPointer)
376 ObDereferenceObject(SectionObject);
377
378 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
379 --PointerCount1;
380 CheckObject(FileHandle1, PointerCount1, 1L);
381 SectionObject = KmtInvalidPointer;
382 MaximumSize.QuadPart = 1;
383 KmtStartSeh()
384 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle1, FileObject1);
385 KmtEndSeh(STATUS_SUCCESS);
386 if (GetNTVersion() < _WIN32_WINNT_WIN8)
387 ok_eq_hex(Status, STATUS_SUCCESS);
388 else
389 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
390 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
391 if (GetNTVersion() < _WIN32_WINNT_WIN8)
392 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
393 ok(SectionObject != NULL, "Section object pointer NULL\n");
394 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
395 --PointerCount1;
396 CheckObject(FileHandle1, PointerCount1, 1L);
397 CheckSection(SectionObject, 0);
398 TestMapView(SectionObject, TRUE, FALSE);
399
400 if (SectionObject && SectionObject != KmtInvalidPointer)
401 ObDereferenceObject(SectionObject);
402
403 /* image section with two different files */
404 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
405 --PointerCount1;
406 CheckObject(FileHandle1, PointerCount1, 1L);
407 SectionObject = KmtInvalidPointer;
408 MaximumSize.QuadPart = 1;
409 KmtStartSeh()
410 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle1, FileObject2);
411 KmtEndSeh(STATUS_SUCCESS);
412 if (GetNTVersion() < _WIN32_WINNT_WIN8)
413 ok_eq_hex(Status, STATUS_SUCCESS);
414 else
415 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
416 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
417 if (GetNTVersion() < _WIN32_WINNT_WIN8)
418 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
419 ok(SectionObject != NULL, "Section object pointer NULL\n");
420 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
421 {
422 --PointerCount1;
423 --PointerCount2;
424 }
425 CheckObject(FileHandle1, PointerCount1, 1L);
426 CheckObject(FileHandle2, PointerCount2, 1L);
427 CheckSection(SectionObject, 0);
428 TestMapView(SectionObject, TRUE, TRUE);
429
430 if (SectionObject && SectionObject != KmtInvalidPointer)
431 ObDereferenceObject(SectionObject);
432
433 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
434 --PointerCount1;
435 CheckObject(FileHandle1, PointerCount1, 1L);
436 SectionObject = KmtInvalidPointer;
437 MaximumSize.QuadPart = 1;
438 KmtStartSeh()
439 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle2, FileObject1);
440 KmtEndSeh(STATUS_SUCCESS);
441 if (GetNTVersion() < _WIN32_WINNT_WIN8)
442 ok_eq_hex(Status, STATUS_SUCCESS);
443 else
444 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
445 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
446 if (GetNTVersion() < _WIN32_WINNT_WIN8)
447 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
448 ok(SectionObject != NULL, "Section object pointer NULL\n");
449 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
450 {
451 --PointerCount1;
452 --PointerCount2;
453 }
454 CheckObject(FileHandle1, PointerCount1, 1L);
455 CheckObject(FileHandle2, PointerCount2, 1L);
456 CheckSection(SectionObject, 0);
457 TestMapView(SectionObject, TRUE, FALSE);
458
459 if (SectionObject && SectionObject != KmtInvalidPointer)
460 ObDereferenceObject(SectionObject);
461
462 /* data file section */
463 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
464 --PointerCount1;
465 CheckObject(FileHandle1, PointerCount1, 1L);
466 SectionObject = KmtInvalidPointer;
467 MaximumSize.QuadPart = 1;
468 KmtStartSeh()
469 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, FileHandle1, NULL);
470 KmtEndSeh(STATUS_SUCCESS);
471 ok_eq_hex(Status, STATUS_SUCCESS);
472 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
473 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
474 ok(SectionObject != NULL, "Section object pointer NULL\n");
475 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
476 PointerCount1 -= 2;
477 CheckObject(FileHandle1, PointerCount1, 1L);
478 if (GetNTVersion() < _WIN32_WINNT_WIN8)
479 CheckSection(SectionObject, 0);
480 TestMapView(SectionObject, TRUE, FALSE);
481
482 if (SectionObject && SectionObject != KmtInvalidPointer)
483 ObDereferenceObject(SectionObject);
484
485 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
486 --PointerCount1;
487 CheckObject(FileHandle1, PointerCount1, 1L);
488 SectionObject = KmtInvalidPointer;
489 MaximumSize.QuadPart = 1;
490 KmtStartSeh()
491 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, FileObject1);
492 KmtEndSeh(STATUS_SUCCESS);
493 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
494 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
495 ok(SectionObject != NULL, "Section object pointer NULL\n");
496 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
497 --PointerCount1;
498 CheckObject(FileHandle1, PointerCount1, 1L);
499 if (GetNTVersion() < _WIN32_WINNT_WIN8)
500 CheckSection(SectionObject, 0);
501 TestMapView(SectionObject, TRUE, FALSE);
502
503 if (SectionObject && SectionObject != KmtInvalidPointer)
504 ObDereferenceObject(SectionObject);
505
506 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
507 --PointerCount1;
508 CheckObject(FileHandle1, PointerCount1, 1L);
509 SectionObject = KmtInvalidPointer;
510 MaximumSize.QuadPart = 1;
511 KmtStartSeh()
512 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, FileHandle1, FileObject1);
513 KmtEndSeh(STATUS_SUCCESS);
514 ok_eq_hex(Status, STATUS_SUCCESS);
515 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
516 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
517 ok(SectionObject != NULL, "Section object pointer NULL\n");
518 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
519 --PointerCount1;
520 CheckObject(FileHandle1, PointerCount1, 1L);
521 if (GetNTVersion() < _WIN32_WINNT_WIN8)
522 CheckSection(SectionObject, 0);
523 TestMapView(SectionObject, TRUE, FALSE);
524
525 if (SectionObject && SectionObject != KmtInvalidPointer)
526 ObDereferenceObject(SectionObject);
527
528 if (GetNTVersion() >= _WIN32_WINNT_WIN8)
529 --PointerCount1;
530 CheckObject(FileHandle1, PointerCount1, 1L);
531 }
532}
TestMapView
#define TestMapView(SectionObject, ExpectAtBase, ExpectM)
Definition: MmSection.c:52
CheckSection
#define CheckSection(SectionObject, SectionFlag)
Definition: MmSection.c:50
ok_eq_pointer
#define ok_eq_pointer(value, expected)
Definition: apitest.h:116
ok_eq_longlong
#define ok_eq_longlong(value, expected)
Definition: apitest.h:121
TRUE
#define TRUE
Definition: types.h:120
PAGE_READONLY
#define PAGE_READONLY
Definition: compat.h:138
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23
n
GLdouble n
Definition: glext.h:7729
pointer
GLsizei const GLvoid * pointer
Definition: glext.h:5848
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
KmtStartSeh
#define KmtStartSeh()
Definition: kmt_test.h:285
KmtInvalidPointer
#define KmtInvalidPointer
Definition: kmt_test.h:283
KmtEndSeh
#define KmtEndSeh(ExpectedStatus)
Definition: kmt_test.h:291
KmtIsCheckedBuild
BOOLEAN KmtIsCheckedBuild
Definition: kmt_test_kernel.h:15
if
if(dx< 0)
Definition: linetemp.h:194
MaximumSize
_In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_opt_ PLARGE_INTEGER MaximumSize
Definition: mmfuncs.h:362
SEC_IMAGE
#define SEC_IMAGE
Definition: mmtypes.h:97
SEC_RESERVE
#define SEC_RESERVE
Definition: nt_native.h:1326
PAGE_NOACCESS
#define PAGE_NOACCESS
Definition: nt_native.h:1305
STATUS_INVALID_PARAMETER_4
#define STATUS_INVALID_PARAMETER_4
Definition: ntstatus.h:572
STATUS_INVALID_IMAGE_NOT_MZ
#define STATUS_INVALID_IMAGE_NOT_MZ
Definition: ntstatus.h:633
STATUS_INVALID_FILE_FOR_SECTION
#define STATUS_INVALID_FILE_FOR_SECTION
Definition: ntstatus.h:362
STATUS_INVALID_PARAMETER_6
#define STATUS_INVALID_PARAMETER_6
Definition: ntstatus.h:574
STATUS_INVALID_PAGE_PROTECTION
#define STATUS_INVALID_PAGE_PROTECTION
Definition: ntstatus.h:399
STATUS_SECTION_TOO_BIG
#define STATUS_SECTION_TOO_BIG
Definition: ntstatus.h:394
_SEH2_GetExceptionCode
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:181
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:82
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:171
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:71
_WIN32_WINNT_WIN10
#define _WIN32_WINNT_WIN10
Definition: sdkddkver.h:32
_WIN32_WINNT_WS03
#define _WIN32_WINNT_WS03
Definition: sdkddkver.h:23
MmCreateSection
NTSTATUS NTAPI MmCreateSection(OUT PVOID *Section, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize, IN ULONG SectionPageProtection, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL, IN PFILE_OBJECT FileObject OPTIONAL)
Definition: section.c:4674
file
Definition: fci.c:127
else
else
Definition: tritemp.h:161
LL
#define LL
Definition: tui.h:166
ULONG
uint32_t ULONG
Definition: typedefs.h:59
QuadPart
ret QuadPart
Definition: rtlfuncs.h:3106

Referenced by START_TEST().

◆ TestPhysicalMemorySection()

static VOID TestPhysicalMemorySection ( VOID  )
static

Definition at line 536 of file MmSection.c.

537{
538 NTSTATUS Status;
539 UNICODE_STRING SectionName = RTL_CONSTANT_STRING(L"\\Device\\PhysicalMemory");
540 OBJECT_ATTRIBUTES ObjectAttributes;
541 HANDLE SectionHandle;
542 PVOID SectionObject;
543 PUCHAR MyPage;
544 PHYSICAL_ADDRESS MyPagePhysical;
545 PUCHAR ZeroPageContents;
546 PHYSICAL_ADDRESS ZeroPagePhysical;
547 PHYSICAL_ADDRESS PhysicalAddress;
548 PVOID Mapping;
549 SYSTEM_BASIC_INFORMATION BasicInfo;
550 PUCHAR MappingBytes;
551 SIZE_T ViewSize;
552 SIZE_T EqualBytes;
553 struct
554 {
555 PVOID Mapping;
556 PHYSICAL_ADDRESS PhysicalAddress;
557 SIZE_T ViewSize;
558 } *UserStruct;
559 PVOID UserMem;
560 SIZE_T UserSize;
561
562 MyPage = ExAllocatePoolWithTag(NonPagedPool, PAGE_SIZE, 'MPmK');
563 if (skip(MyPage != NULL, "Out of memory\n"))
564 return;
565 MyPagePhysical = MmGetPhysicalAddress(MyPage);
566 RtlFillMemory(MyPage + 0 * PAGE_SIZE / 4, PAGE_SIZE / 4, 0x23);
567 RtlFillMemory(MyPage + 1 * PAGE_SIZE / 4, PAGE_SIZE / 4, 0x67);
568 RtlFillMemory(MyPage + 2 * PAGE_SIZE / 4, PAGE_SIZE / 4, 0xab);
569 RtlFillMemory(MyPage + 3 * PAGE_SIZE / 4, PAGE_SIZE / 4, 0xef);
570
571 ZeroPageContents = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, 'ZPmK');
572 if (skip(ZeroPageContents != NULL, "Out of memory\n"))
573 {
574 ExFreePoolWithTag(MyPage, 'MPmK');
575 return;
576 }
577 ZeroPagePhysical.QuadPart = 0;
578
579 Mapping = MmMapIoSpace(ZeroPagePhysical, PAGE_SIZE, MmCached);
580 if (skip(Mapping != NULL, "Failed to map zero page\n"))
581 {
582 ExFreePoolWithTag(ZeroPageContents, 'ZPmK');
583 ExFreePoolWithTag(MyPage, 'MPmK');
584 return;
585 }
586
587 RtlCopyMemory(ZeroPageContents, Mapping, PAGE_SIZE);
588 MmUnmapIoSpace(Mapping, PAGE_SIZE);
589
590 InitializeObjectAttributes(&ObjectAttributes,
591 &SectionName,
592 0,
593 NULL,
594 NULL);
595 Status = ZwOpenSection(&SectionHandle, SECTION_ALL_ACCESS, &ObjectAttributes);
596 ok_eq_hex(Status, STATUS_SUCCESS);
597 if (!skip(NT_SUCCESS(Status), "No section\n"))
598 {
599 /* Map zero page and compare */
600 Mapping = NULL;
601 ViewSize = PAGE_SIZE;
602 Status = ZwMapViewOfSection(SectionHandle,
603 ZwCurrentProcess(),
604 &Mapping,
605 0,
606 0,
607 &ZeroPagePhysical,
608 &ViewSize,
609 ViewUnmap,
610 0,
611 PAGE_READWRITE);
612 ok_eq_hex(Status, STATUS_SUCCESS);
613 if (!skip(NT_SUCCESS(Status), "No view\n"))
614 {
615 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
616 EqualBytes = RtlCompareMemory(Mapping,
617 ZeroPageContents,
618 PAGE_SIZE);
619 ok_eq_size(EqualBytes, PAGE_SIZE);
620 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
621 ok_eq_hex(Status, STATUS_SUCCESS);
622 }
623
624 /* Map the zero page non-cached */
625 Mapping = NULL;
626 ViewSize = PAGE_SIZE;
627 Status = ZwMapViewOfSection(SectionHandle,
628 ZwCurrentProcess(),
629 &Mapping,
630 0,
631 0,
632 &ZeroPagePhysical,
633 &ViewSize,
634 ViewUnmap,
635 0,
636 PAGE_READWRITE | PAGE_NOCACHE);
637 ok_eq_hex(Status, STATUS_SUCCESS);
638 if (!skip(NT_SUCCESS(Status), "No view\n"))
639 {
640 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
641 EqualBytes = RtlCompareMemory(Mapping,
642 ZeroPageContents,
643 PAGE_SIZE);
644 ok_eq_size(EqualBytes, PAGE_SIZE);
645 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
646 ok_eq_hex(Status, STATUS_SUCCESS);
647 }
648
649 /* Map our NP page, compare, and check that modifications are reflected */
650 Mapping = NULL;
651 ViewSize = PAGE_SIZE;
652 Status = ZwMapViewOfSection(SectionHandle,
653 ZwCurrentProcess(),
654 &Mapping,
655 0,
656 0,
657 &MyPagePhysical,
658 &ViewSize,
659 ViewUnmap,
660 0,
661 PAGE_READWRITE);
662 ok_eq_hex(Status, STATUS_SUCCESS);
663 if (!skip(NT_SUCCESS(Status), "No view\n"))
664 {
665 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
666 EqualBytes = RtlCompareMemory(Mapping,
667 MyPage,
668 PAGE_SIZE);
669 ok_eq_size(EqualBytes, PAGE_SIZE);
670
671 MappingBytes = Mapping;
672 ok(MappingBytes[5] == 0x23, "Mapping[5] = 0x%x\n", MappingBytes[5]);
673 ok(MyPage[5] == 0x23, "MyPage[5] = 0x%x\n", MyPage[5]);
674
675 MyPage[5] = 0x44;
676 ok(MappingBytes[5] == 0x44, "Mapping[5] = 0x%x\n", MappingBytes[5]);
677 ok(MyPage[5] == 0x44, "MyPage[5] = 0x%x\n", MyPage[5]);
678
679 MappingBytes[5] = 0x88;
680 ok(MappingBytes[5] == 0x88, "Mapping[5] = 0x%x\n", MappingBytes[5]);
681 ok(MyPage[5] == 0x88, "MyPage[5] = 0x%x\n", MyPage[5]);
682
683 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
684 ok_eq_hex(Status, STATUS_SUCCESS);
685 }
686
687 /* Unaligned mapping will get aligned automatically */
688 Mapping = NULL;
689 ViewSize = PAGE_SIZE - 4;
690 PhysicalAddress.QuadPart = MyPagePhysical.QuadPart + 4;
691 Status = ZwMapViewOfSection(SectionHandle,
692 ZwCurrentProcess(),
693 &Mapping,
694 0,
695 0,
696 &PhysicalAddress,
697 &ViewSize,
698 ViewUnmap,
699 0,
700 PAGE_READWRITE);
701 ok_eq_hex(Status, STATUS_SUCCESS);
702 if (!skip(NT_SUCCESS(Status), "No view\n"))
703 {
704 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
705 ok(((ULONG_PTR)Mapping % PAGE_SIZE) == 0, "Mapping = %p\n", Mapping);
706 ok_eq_ulong(ViewSize, PAGE_SIZE);
707 ok_eq_longlong(PhysicalAddress.QuadPart, MyPagePhysical.QuadPart);
708
709 EqualBytes = RtlCompareMemory(Mapping,
710 MyPage,
711 PAGE_SIZE);
712 ok_eq_size(EqualBytes, PAGE_SIZE);
713
714 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
715 ok_eq_hex(Status, STATUS_SUCCESS);
716 }
717
718 /* The following tests need to pass parameters in user mode */
719 UserStruct = NULL;
720 UserMem = NULL;
721 UserSize = PAGE_SIZE;
722 Status = ZwAllocateVirtualMemory(ZwCurrentProcess(),
723 &UserMem,
724 0,
725 &UserSize,
726 MEM_COMMIT,
727 PAGE_READWRITE);
728 ok_eq_hex(Status, STATUS_SUCCESS);
729 if (NT_SUCCESS(Status))
730 UserStruct = UserMem;
731
732 /* Find highest physical page -- only kernel can map beyond this */
733 Status = ZwQuerySystemInformation(SystemBasicInformation,
734 &BasicInfo,
735 sizeof(BasicInfo),
736 NULL);
737 ok_eq_hex(Status, STATUS_SUCCESS);
738 trace("HighestPhysicalPageNumber: %lx\n", BasicInfo.HighestPhysicalPageNumber);
739
740 /* Start one page before highest physical -- succeeds for user/kernel */
741 Mapping = NULL;
742 ViewSize = PAGE_SIZE;
743 PhysicalAddress.QuadPart = (ULONGLONG)(BasicInfo.HighestPhysicalPageNumber - 1) << PAGE_SHIFT;
744 Status = ZwMapViewOfSection(SectionHandle,
745 ZwCurrentProcess(),
746 &Mapping,
747 0,
748 0,
749 &PhysicalAddress,
750 &ViewSize,
751 ViewUnmap,
752 0,
753 PAGE_READWRITE);
754 ok_eq_hex(Status, STATUS_SUCCESS);
755 if (NT_SUCCESS(Status))
756 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
757
758 /* Repeat from user mode */
759 if (!skip(UserStruct != NULL, "No user memory\n"))
760 {
761 KmtStartSeh()
762 UserStruct->Mapping = NULL;
763 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
764 UserStruct->ViewSize = PAGE_SIZE;
765 KmtEndSeh(STATUS_SUCCESS);
766
767 Status = NtMapViewOfSection(SectionHandle,
768 NtCurrentProcess(),
769 &UserStruct->Mapping,
770 0,
771 0,
772 &UserStruct->PhysicalAddress,
773 &UserStruct->ViewSize,
774 ViewUnmap,
775 0,
776 PAGE_READWRITE);
777 ok_eq_hex(Status, STATUS_SUCCESS);
778 if (NT_SUCCESS(Status))
779 {
780 KmtStartSeh()
781 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
782 KmtEndSeh(STATUS_SUCCESS);
783 }
784 }
785
786 /* Now start at highest physical -- fails for user */
787 Mapping = NULL;
788 ViewSize = PAGE_SIZE;
789 PhysicalAddress.QuadPart = (ULONGLONG)BasicInfo.HighestPhysicalPageNumber << PAGE_SHIFT;
790 Status = ZwMapViewOfSection(SectionHandle,
791 ZwCurrentProcess(),
792 &Mapping,
793 0,
794 0,
795 &PhysicalAddress,
796 &ViewSize,
797 ViewUnmap,
798 0,
799 PAGE_READWRITE);
800 ok_eq_hex(Status, STATUS_SUCCESS);
801 if (NT_SUCCESS(Status))
802 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
803
804 /* Repeat from user mode */
805 if (!skip(UserStruct != NULL, "No user memory\n"))
806 {
807 KmtStartSeh()
808 UserStruct->Mapping = NULL;
809 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
810 UserStruct->ViewSize = PAGE_SIZE;
811 KmtEndSeh(STATUS_SUCCESS);
812
813 Status = NtMapViewOfSection(SectionHandle,
814 NtCurrentProcess(),
815 &UserStruct->Mapping,
816 0,
817 0,
818 &UserStruct->PhysicalAddress,
819 &UserStruct->ViewSize,
820 ViewUnmap,
821 0,
822 PAGE_READWRITE);
823 if (GetNTVersion() < _WIN32_WINNT_WIN10)
824 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
825 else
826 ok_eq_hex(Status, STATUS_SUCCESS);
827 if (NT_SUCCESS(Status))
828 {
829 KmtStartSeh()
830 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
831 KmtEndSeh(STATUS_SUCCESS);
832 }
833 }
834
835 /* End of view crosses highest physical -- fails for user */
836 Mapping = NULL;
837 ViewSize = 2 * PAGE_SIZE;
838 PhysicalAddress.QuadPart = (ULONGLONG)(BasicInfo.HighestPhysicalPageNumber - 1) << PAGE_SHIFT;
839 Status = ZwMapViewOfSection(SectionHandle,
840 ZwCurrentProcess(),
841 &Mapping,
842 0,
843 0,
844 &PhysicalAddress,
845 &ViewSize,
846 ViewUnmap,
847 0,
848 PAGE_READWRITE);
849 ok_eq_hex(Status, STATUS_SUCCESS);
850 if (NT_SUCCESS(Status))
851 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
852
853 /* Repeat from user mode */
854 if (!skip(UserStruct != NULL, "No user memory\n"))
855 {
856 KmtStartSeh()
857 UserStruct->Mapping = NULL;
858 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
859 UserStruct->ViewSize = 2 * PAGE_SIZE;
860 KmtEndSeh(STATUS_SUCCESS);
861
862 Status = NtMapViewOfSection(SectionHandle,
863 NtCurrentProcess(),
864 &UserStruct->Mapping,
865 0,
866 0,
867 &UserStruct->PhysicalAddress,
868 &UserStruct->ViewSize,
869 ViewUnmap,
870 0,
871 PAGE_READWRITE);
872 if (GetNTVersion() < _WIN32_WINNT_WIN10)
873 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
874 else
875 ok_eq_hex(Status, STATUS_SUCCESS);
876 if (NT_SUCCESS(Status))
877 {
878 KmtStartSeh()
879 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
880 KmtEndSeh(STATUS_SUCCESS);
881 }
882 }
883
884 /* Free user memory and close section */
885 if (!skip(UserStruct != NULL, "No user memory\n"))
886 {
887 UserSize = 0;
888 Status = ZwFreeVirtualMemory(ZwCurrentProcess(),
889 &UserMem,
890 &UserSize,
891 MEM_RELEASE);
892 ok_eq_hex(Status, STATUS_SUCCESS);
893 }
894
895 Status = ObCloseHandle(SectionHandle, UserMode);
896 ok_eq_hex(Status, STATUS_SUCCESS);
897 }
898
899 /* Try flag 0x80000000, which ROS calls SEC_PHYSICALMEMORY */
900 InitializeObjectAttributes(&ObjectAttributes,
901 NULL,
902 OBJ_KERNEL_HANDLE,
903 NULL,
904 NULL);
905 Status = ZwCreateSection(&SectionHandle,
906 SECTION_ALL_ACCESS,
907 &ObjectAttributes,
908 NULL,
909 PAGE_READWRITE,
910 0x80000000,
911 NULL);
912 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
913 if (NT_SUCCESS(Status))
914 ZwClose(SectionHandle);
915
916 /* Assertion failure: AllocationAttributes & SEC_IMAGE | SEC_RESERVE | SEC_COMMIT */
917 if (!KmtIsCheckedBuild && !(GetNTVersion() >= _WIN32_WINNT_WIN10))
918 {
919 InitializeObjectAttributes(&ObjectAttributes,
920 NULL,
921 OBJ_KERNEL_HANDLE,
922 NULL,
923 NULL);
924 Status = MmCreateSection(&SectionObject,
925 SECTION_ALL_ACCESS,
926 &ObjectAttributes,
927 NULL,
928 PAGE_READWRITE,
929 0x80000000,
930 NULL,
931 NULL);
932 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
933 if (NT_SUCCESS(Status))
934 ObDereferenceObject(SectionObject);
935 }
936
937 if (GetNTVersion() < _WIN32_WINNT_WIN10)
938 {
939 InitializeObjectAttributes(&ObjectAttributes,
940 NULL,
941 OBJ_KERNEL_HANDLE,
942 NULL,
943 NULL);
944 Status = MmCreateSection(&SectionObject,
945 SECTION_ALL_ACCESS,
946 &ObjectAttributes,
947 NULL,
948 PAGE_READWRITE,
949 SEC_RESERVE | 0x80000000,
950 NULL,
951 NULL);
952 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
953 if (NT_SUCCESS(Status))
954 ObDereferenceObject(SectionObject);
955 }
956
957 ExFreePoolWithTag(ZeroPageContents, 'ZPmK');
958 ExFreePoolWithTag(MyPage, 'MPmK');
959}
NtMapViewOfSection
NTSTATUS NTAPI NtMapViewOfSection(IN HANDLE SectionHandle, IN HANDLE ProcessHandle, IN OUT PVOID *BaseAddress, IN ULONG_PTR ZeroBits, IN SIZE_T CommitSize, IN OUT PLARGE_INTEGER SectionOffset OPTIONAL, IN OUT PSIZE_T ViewSize, IN SECTION_INHERIT InheritDisposition, IN ULONG AllocationType, IN ULONG Protect)
Definition: section.c:3257
ok_eq_ulong
#define ok_eq_ulong(value, expected)
Definition: apitest.h:120
ok_eq_size
#define ok_eq_size(value, expected)
Definition: apitest.h:126
user
void user(int argc, const char *argv[])
Definition: cmds.c:1350
Mapping
static PVOID Mapping[EMS_PHYSICAL_PAGES]
Definition: emsdrv.c:41
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
RtlCompareMemory
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
PAGE_SIZE
#define PAGE_SIZE
Definition: env_spec_w32.h:49
PAGE_SHIFT
#define PAGE_SHIFT
Definition: env_spec_w32.h:45
NonPagedPool
#define NonPagedPool
Definition: env_spec_w32.h:307
PagedPool
#define PagedPool
Definition: env_spec_w32.h:308
ZwQuerySystemInformation
NTSYSAPI NTSTATUS NTAPI ZwQuerySystemInformation(IN SYSTEM_INFORMATION_CLASS SystemInfoClass, OUT PVOID SystemInfoBuffer, IN ULONG SystemInfoBufferSize, OUT PULONG BytesReturned OPTIONAL)
SystemBasicInformation
@ SystemBasicInformation
Definition: ntddk_ex.h:11
RtlFillMemory
#define RtlFillMemory(Dest, Length, Fill)
Definition: winternl.h:603
MmUnmapIoSpace
VOID NTAPI MmUnmapIoSpace(IN PVOID BaseAddress, IN SIZE_T NumberOfBytes)
Definition: iosup.c:193
MmMapIoSpace
PVOID NTAPI MmMapIoSpace(IN PHYSICAL_ADDRESS PhysicalAddress, IN SIZE_T NumberOfBytes, IN MEMORY_CACHING_TYPE CacheType)
Definition: iosup.c:47
ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
memory
static char memory[1024 *256]
Definition: process.c:116
LONG_PTR
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
ZwOpenSection
NTSYSAPI NTSTATUS NTAPI ZwOpenSection(_Out_ PHANDLE SectionHandle, _In_ ACCESS_MASK DesiredAccess, _In_ POBJECT_ATTRIBUTES ObjectAttributes)
ViewSize
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:408
PAGE_NOCACHE
#define PAGE_NOCACHE
Definition: nt_native.h:1314
PAGE_READWRITE
#define PAGE_READWRITE
Definition: nt_native.h:1307
SECTION_ALL_ACCESS
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1296
NtCurrentProcess
#define NtCurrentProcess()
Definition: nt_native.h:1660
ViewUnmap
@ ViewUnmap
Definition: nt_native.h:1282
MEM_RELEASE
#define MEM_RELEASE
Definition: nt_native.h:1319
MEM_COMMIT
#define MEM_COMMIT
Definition: nt_native.h:1316
MmGetPhysicalAddress
PHYSICAL_ADDRESS NTAPI MmGetPhysicalAddress(IN PVOID Address)
Definition: stubs.c:685
ObCloseHandle
NTSTATUS NTAPI ObCloseHandle(IN HANDLE Handle, IN KPROCESSOR_MODE AccessMode)
Definition: obhandle.c:3379
_SYSTEM_BASIC_INFORMATION
Definition: ntddk_ex.h:157
_SYSTEM_BASIC_INFORMATION::HighestPhysicalPageNumber
ULONG HighestPhysicalPageNumber
Definition: ntddk_ex.h:163
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
PhysicalAddress
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS PhysicalAddress
Definition: iotypes.h:1098
MmCached
@ MmCached
Definition: mmtypes.h:130
ZwCurrentProcess
#define ZwCurrentProcess()

Referenced by START_TEST().