ReactOS 0.4.16-dev-2110-ge3521eb
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 986 of file MmSection.c.

987{
988 NTSTATUS Status;
989 HANDLE FileHandle1 = NULL, FileHandle2 = NULL;
990 PFILE_OBJECT FileObject1 = NULL, FileObject2 = NULL;
991 OBJECT_ATTRIBUTES ObjectAttributes;
992 IO_STATUS_BLOCK IoStatusBlock;
993 UNICODE_STRING FileName1 = RTL_CONSTANT_STRING(L"\\SystemRoot\\kmtest-MmSection.txt");
994 UNICODE_STRING FileName2 = RTL_CONSTANT_STRING(L"\\SystemRoot\\system32\\ntdll.dll");
995 LARGE_INTEGER FileOffset;
996 UCHAR FileData = 0;
997
998 ok(ExGetPreviousMode() == UserMode, "Previous mode is kernel mode\n");
999 /* create a one-byte file that we can use */
1000 InitializeObjectAttributes(&ObjectAttributes, &FileName1, OBJ_CASE_INSENSITIVE, NULL, NULL);
1001 Status = ZwCreateFile(&FileHandle1, GENERIC_WRITE | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_SUPERSEDE, FILE_NON_DIRECTORY_FILE, NULL, 0);
1002 ok_eq_hex(Status, STATUS_SUCCESS);
1003 ok_eq_ulongptr(IoStatusBlock.Information, FILE_CREATED);
1004 ok(FileHandle1 != NULL, "FileHandle1 is NULL\n");
1005 if (FileHandle1)
1006 {
1007 FileOffset.QuadPart = 0;
1008 Status = ZwWriteFile(FileHandle1, NULL, NULL, NULL, &IoStatusBlock, &FileData, sizeof FileData, &FileOffset, NULL);
1009 ok(Status == STATUS_SUCCESS || Status == STATUS_PENDING, "Status = 0x%08lx\n", Status);
1010 Status = ZwWaitForSingleObject(FileHandle1, FALSE, NULL);
1011 ok_eq_hex(Status, STATUS_SUCCESS);
1012 ok_eq_ulongptr(IoStatusBlock.Information, 1);
1013 Status = ZwClose(FileHandle1);
1014 ok_eq_hex(Status, STATUS_SUCCESS);
1015 FileHandle1 = NULL;
1016 }
1017
1018 InitializeObjectAttributes(&ObjectAttributes, &FileName1, OBJ_CASE_INSENSITIVE, NULL, NULL);
1019 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);
1020 ok_eq_hex(Status, STATUS_SUCCESS);
1021 ok_eq_ulongptr(IoStatusBlock.Information, FILE_OPENED);
1022 ok(FileHandle1 != NULL, "FileHandle1 is NULL\n");
1023 if (GetNTVersion() < _WIN32_WINNT_WIN8)
1024 CheckObject(FileHandle1, 2L, 1L);
1025#ifdef _M_IX86
1026 else
1027 CheckObject(FileHandle1, 33L, 1L);
1028#else
1029 else
1030 CheckObject(FileHandle1, 32769L, 1L);
1031#endif
1032
1033 InitializeObjectAttributes(&ObjectAttributes, &FileName2, OBJ_CASE_INSENSITIVE, NULL, NULL);
1034 Status = ZwCreateFile(&FileHandle2, GENERIC_READ, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_NON_DIRECTORY_FILE, NULL, 0);
1035 ok_eq_hex(Status, STATUS_SUCCESS);
1036 ok_eq_ulongptr(IoStatusBlock.Information, FILE_OPENED);
1037 ok(FileHandle2 != NULL, "FileHandle2 is NULL\n");
1038
1039 if (!skip(Status == STATUS_SUCCESS && FileHandle1 != NULL, "Failed to open file 1\n"))
1040 {
1041 Status = ObReferenceObjectByHandle(FileHandle1, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID *)&FileObject1, NULL);
1042 ok_eq_hex(Status, STATUS_SUCCESS);
1043 ok(FileObject1 != NULL, "FileObject1 is NULL\n");
1044 if (GetNTVersion() < _WIN32_WINNT_WIN8)
1045 CheckObject(FileHandle1, 3L, 1L);
1046#ifdef _M_IX86
1047 else
1048 CheckObject(FileHandle1, 32L, 1L);
1049#else
1050 else
1051 CheckObject(FileHandle1, 32768L, 1L);
1052#endif
1053 }
1054
1055 if (!skip(Status == STATUS_SUCCESS && FileHandle2 != NULL, "Failed to open file 2\n"))
1056 {
1057 Status = ObReferenceObjectByHandle(FileHandle2, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID *)&FileObject2, NULL);
1058 ok_eq_hex(Status, STATUS_SUCCESS);
1059 ok(FileObject2 != NULL, "FileObject2 is NULL\n");
1060 }
1061
1062 trace("FileHandle1=%p, FileObject1=%p\n", FileHandle1, FileObject1);
1063 trace("FileHandle2=%p, FileObject2=%p\n", FileHandle2, FileObject2);
1064 TestCreateSection(FileHandle1, FileObject1, FileHandle2, FileObject2);
1065
1066 if (FileObject2)
1067 ObDereferenceObject(FileObject2);
1068 if (FileObject1)
1069 ObDereferenceObject(FileObject1);
1070 if (FileHandle2)
1071 ZwClose(FileHandle2);
1072 if (FileHandle1)
1073 ZwClose(FileHandle1);
1074
1075 TestPhysicalMemorySection();
1076}
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:4671
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 the zero page with write combining */
650 Mapping = NULL;
651 ViewSize = PAGE_SIZE;
652 Status = ZwMapViewOfSection(SectionHandle,
653 ZwCurrentProcess(),
654 &Mapping,
655 0,
656 0,
657 &ZeroPagePhysical,
658 &ViewSize,
659 ViewUnmap,
660 0,
661 PAGE_READWRITE | PAGE_WRITECOMBINE);
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 ZeroPageContents,
668 PAGE_SIZE);
669 ok_eq_size(EqualBytes, PAGE_SIZE);
670 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
671 ok_eq_hex(Status, STATUS_SUCCESS);
672 }
673
674 /* Map our NP page, compare, and check that modifications are reflected */
675 Mapping = NULL;
676 ViewSize = PAGE_SIZE;
677 Status = ZwMapViewOfSection(SectionHandle,
678 ZwCurrentProcess(),
679 &Mapping,
680 0,
681 0,
682 &MyPagePhysical,
683 &ViewSize,
684 ViewUnmap,
685 0,
686 PAGE_READWRITE);
687 ok_eq_hex(Status, STATUS_SUCCESS);
688 if (!skip(NT_SUCCESS(Status), "No view\n"))
689 {
690 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
691 EqualBytes = RtlCompareMemory(Mapping,
692 MyPage,
693 PAGE_SIZE);
694 ok_eq_size(EqualBytes, PAGE_SIZE);
695
696 MappingBytes = Mapping;
697 ok(MappingBytes[5] == 0x23, "Mapping[5] = 0x%x\n", MappingBytes[5]);
698 ok(MyPage[5] == 0x23, "MyPage[5] = 0x%x\n", MyPage[5]);
699
700 MyPage[5] = 0x44;
701 ok(MappingBytes[5] == 0x44, "Mapping[5] = 0x%x\n", MappingBytes[5]);
702 ok(MyPage[5] == 0x44, "MyPage[5] = 0x%x\n", MyPage[5]);
703
704 MappingBytes[5] = 0x88;
705 ok(MappingBytes[5] == 0x88, "Mapping[5] = 0x%x\n", MappingBytes[5]);
706 ok(MyPage[5] == 0x88, "MyPage[5] = 0x%x\n", MyPage[5]);
707
708 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
709 ok_eq_hex(Status, STATUS_SUCCESS);
710 }
711
712 /* Unaligned mapping will get aligned automatically */
713 Mapping = NULL;
714 ViewSize = PAGE_SIZE - 4;
715 PhysicalAddress.QuadPart = MyPagePhysical.QuadPart + 4;
716 Status = ZwMapViewOfSection(SectionHandle,
717 ZwCurrentProcess(),
718 &Mapping,
719 0,
720 0,
721 &PhysicalAddress,
722 &ViewSize,
723 ViewUnmap,
724 0,
725 PAGE_READWRITE);
726 ok_eq_hex(Status, STATUS_SUCCESS);
727 if (!skip(NT_SUCCESS(Status), "No view\n"))
728 {
729 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
730 ok(((ULONG_PTR)Mapping % PAGE_SIZE) == 0, "Mapping = %p\n", Mapping);
731 ok_eq_ulong(ViewSize, PAGE_SIZE);
732 ok_eq_longlong(PhysicalAddress.QuadPart, MyPagePhysical.QuadPart);
733
734 EqualBytes = RtlCompareMemory(Mapping,
735 MyPage,
736 PAGE_SIZE);
737 ok_eq_size(EqualBytes, PAGE_SIZE);
738
739 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
740 ok_eq_hex(Status, STATUS_SUCCESS);
741 }
742
743 /* The following tests need to pass parameters in user mode */
744 UserStruct = NULL;
745 UserMem = NULL;
746 UserSize = PAGE_SIZE;
747 Status = ZwAllocateVirtualMemory(ZwCurrentProcess(),
748 &UserMem,
749 0,
750 &UserSize,
751 MEM_COMMIT,
752 PAGE_READWRITE);
753 ok_eq_hex(Status, STATUS_SUCCESS);
754 if (NT_SUCCESS(Status))
755 UserStruct = UserMem;
756
757 /* Find highest physical page -- only kernel can map beyond this */
758 Status = ZwQuerySystemInformation(SystemBasicInformation,
759 &BasicInfo,
760 sizeof(BasicInfo),
761 NULL);
762 ok_eq_hex(Status, STATUS_SUCCESS);
763 trace("HighestPhysicalPageNumber: %lx\n", BasicInfo.HighestPhysicalPageNumber);
764
765 /* Start one page before highest physical -- succeeds for user/kernel */
766 Mapping = NULL;
767 ViewSize = PAGE_SIZE;
768 PhysicalAddress.QuadPart = (ULONGLONG)(BasicInfo.HighestPhysicalPageNumber - 1) << PAGE_SHIFT;
769 Status = ZwMapViewOfSection(SectionHandle,
770 ZwCurrentProcess(),
771 &Mapping,
772 0,
773 0,
774 &PhysicalAddress,
775 &ViewSize,
776 ViewUnmap,
777 0,
778 PAGE_READWRITE);
779 ok_eq_hex(Status, STATUS_SUCCESS);
780 if (NT_SUCCESS(Status))
781 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
782
783 /* Repeat from user mode */
784 if (!skip(UserStruct != NULL, "No user memory\n"))
785 {
786 KmtStartSeh()
787 UserStruct->Mapping = NULL;
788 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
789 UserStruct->ViewSize = PAGE_SIZE;
790 KmtEndSeh(STATUS_SUCCESS);
791
792 Status = NtMapViewOfSection(SectionHandle,
793 NtCurrentProcess(),
794 &UserStruct->Mapping,
795 0,
796 0,
797 &UserStruct->PhysicalAddress,
798 &UserStruct->ViewSize,
799 ViewUnmap,
800 0,
801 PAGE_READWRITE);
802 ok_eq_hex(Status, STATUS_SUCCESS);
803 if (NT_SUCCESS(Status))
804 {
805 KmtStartSeh()
806 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
807 KmtEndSeh(STATUS_SUCCESS);
808 }
809 }
810
811 /* Now start at highest physical -- fails for user */
812 Mapping = NULL;
813 ViewSize = PAGE_SIZE;
814 PhysicalAddress.QuadPart = (ULONGLONG)BasicInfo.HighestPhysicalPageNumber << PAGE_SHIFT;
815 Status = ZwMapViewOfSection(SectionHandle,
816 ZwCurrentProcess(),
817 &Mapping,
818 0,
819 0,
820 &PhysicalAddress,
821 &ViewSize,
822 ViewUnmap,
823 0,
824 PAGE_READWRITE);
825 ok_eq_hex(Status, STATUS_SUCCESS);
826 if (NT_SUCCESS(Status))
827 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
828
829 /* Repeat from user mode */
830 if (!skip(UserStruct != NULL, "No user memory\n"))
831 {
832 KmtStartSeh()
833 UserStruct->Mapping = NULL;
834 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
835 UserStruct->ViewSize = PAGE_SIZE;
836 KmtEndSeh(STATUS_SUCCESS);
837
838 Status = NtMapViewOfSection(SectionHandle,
839 NtCurrentProcess(),
840 &UserStruct->Mapping,
841 0,
842 0,
843 &UserStruct->PhysicalAddress,
844 &UserStruct->ViewSize,
845 ViewUnmap,
846 0,
847 PAGE_READWRITE);
848 if (GetNTVersion() < _WIN32_WINNT_WIN10)
849 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
850 else
851 ok_eq_hex(Status, STATUS_SUCCESS);
852 if (NT_SUCCESS(Status))
853 {
854 KmtStartSeh()
855 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
856 KmtEndSeh(STATUS_SUCCESS);
857 }
858 }
859
860 /* End of view crosses highest physical -- fails for user */
861 Mapping = NULL;
862 ViewSize = 2 * PAGE_SIZE;
863 PhysicalAddress.QuadPart = (ULONGLONG)(BasicInfo.HighestPhysicalPageNumber - 1) << PAGE_SHIFT;
864 Status = ZwMapViewOfSection(SectionHandle,
865 ZwCurrentProcess(),
866 &Mapping,
867 0,
868 0,
869 &PhysicalAddress,
870 &ViewSize,
871 ViewUnmap,
872 0,
873 PAGE_READWRITE);
874 ok_eq_hex(Status, STATUS_SUCCESS);
875 if (NT_SUCCESS(Status))
876 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
877
878 /* Repeat from user mode */
879 if (!skip(UserStruct != NULL, "No user memory\n"))
880 {
881 KmtStartSeh()
882 UserStruct->Mapping = NULL;
883 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
884 UserStruct->ViewSize = 2 * PAGE_SIZE;
885 KmtEndSeh(STATUS_SUCCESS);
886
887 Status = NtMapViewOfSection(SectionHandle,
888 NtCurrentProcess(),
889 &UserStruct->Mapping,
890 0,
891 0,
892 &UserStruct->PhysicalAddress,
893 &UserStruct->ViewSize,
894 ViewUnmap,
895 0,
896 PAGE_READWRITE);
897 if (GetNTVersion() < _WIN32_WINNT_WIN10)
898 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
899 else
900 ok_eq_hex(Status, STATUS_SUCCESS);
901 if (NT_SUCCESS(Status))
902 {
903 KmtStartSeh()
904 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
905 KmtEndSeh(STATUS_SUCCESS);
906 }
907 }
908
909 /* Free user memory and close section */
910 if (!skip(UserStruct != NULL, "No user memory\n"))
911 {
912 UserSize = 0;
913 Status = ZwFreeVirtualMemory(ZwCurrentProcess(),
914 &UserMem,
915 &UserSize,
916 MEM_RELEASE);
917 ok_eq_hex(Status, STATUS_SUCCESS);
918 }
919
920 Status = ObCloseHandle(SectionHandle, UserMode);
921 ok_eq_hex(Status, STATUS_SUCCESS);
922 }
923
924 /* Try flag 0x80000000, which ROS calls SEC_PHYSICALMEMORY */
925 InitializeObjectAttributes(&ObjectAttributes,
926 NULL,
927 OBJ_KERNEL_HANDLE,
928 NULL,
929 NULL);
930 Status = ZwCreateSection(&SectionHandle,
931 SECTION_ALL_ACCESS,
932 &ObjectAttributes,
933 NULL,
934 PAGE_READWRITE,
935 0x80000000,
936 NULL);
937 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
938 if (NT_SUCCESS(Status))
939 ZwClose(SectionHandle);
940
941 /* Assertion failure: AllocationAttributes & SEC_IMAGE | SEC_RESERVE | SEC_COMMIT */
942 if (!KmtIsCheckedBuild && !(GetNTVersion() >= _WIN32_WINNT_WIN10))
943 {
944 InitializeObjectAttributes(&ObjectAttributes,
945 NULL,
946 OBJ_KERNEL_HANDLE,
947 NULL,
948 NULL);
949 Status = MmCreateSection(&SectionObject,
950 SECTION_ALL_ACCESS,
951 &ObjectAttributes,
952 NULL,
953 PAGE_READWRITE,
954 0x80000000,
955 NULL,
956 NULL);
957 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
958 if (NT_SUCCESS(Status))
959 ObDereferenceObject(SectionObject);
960 }
961
962 if (GetNTVersion() < _WIN32_WINNT_WIN10)
963 {
964 InitializeObjectAttributes(&ObjectAttributes,
965 NULL,
966 OBJ_KERNEL_HANDLE,
967 NULL,
968 NULL);
969 Status = MmCreateSection(&SectionObject,
970 SECTION_ALL_ACCESS,
971 &ObjectAttributes,
972 NULL,
973 PAGE_READWRITE,
974 SEC_RESERVE | 0x80000000,
975 NULL,
976 NULL);
977 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
978 if (NT_SUCCESS(Status))
979 ObDereferenceObject(SectionObject);
980 }
981
982 ExFreePoolWithTag(ZeroPageContents, 'ZPmK');
983 ExFreePoolWithTag(MyPage, 'MPmK');
984}
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
PAGE_WRITECOMBINE
#define PAGE_WRITECOMBINE
Definition: mmtypes.h:78
ZwCurrentProcess
#define ZwCurrentProcess()

Referenced by START_TEST().