ReactOS 0.4.15-dev-7953-g1f49173
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)
 
#define TestMapView(SectionObject, ExpectAtBase, ExpectM)
 

Functions

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:444
_PUBLIC_OBJECT_BASIC_INFORMATION::PointerCount
ULONG PointerCount
Definition: winternl.h:448
_PUBLIC_OBJECT_BASIC_INFORMATION::HandleCount
ULONG HandleCount
Definition: winternl.h:447

Definition at line 10 of file MmSection.c.

◆ CheckSection

#define CheckSection (   SectionObject,
  SectionFlag 
)
Value:
do \
{ \
SECTION_BASIC_INFORMATION Sbi; \
HANDLE SectionHandle = NULL; \
NTSTATUS Status; \
if (skip(SectionObject != NULL && \
SectionObject != (PVOID)0x5555555555555555ULL, \
"No section object\n")) \
break; \
Status = ObOpenObjectByPointer(SectionObject, OBJ_KERNEL_HANDLE, \
NULL, 0, MmSectionObjectType, \
KernelMode, &SectionHandle); \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok(SectionHandle != NULL, "Section handle null\n"); \
if (!skip(NT_SUCCESS(Status) && SectionHandle, \
"No section handle\n")) \
{ \
Status = ZwQuerySection(SectionHandle, SectionBasicInformation, \
&Sbi, sizeof Sbi, NULL); \
ok_eq_hex(Status, STATUS_SUCCESS); \
ok_eq_pointer(Sbi.BaseAddress, NULL); \
ok_eq_longlong(Sbi.Size.QuadPart, 1LL); \
ok_eq_hex(Sbi.Attributes, SectionFlag | SEC_FILE); \
ZwClose(SectionHandle); \
} \
} while (0)
skip
#define skip(...)
Definition: atltest.h:64
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
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:34
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
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:194
_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

Definition at line 20 of file MmSection.c.

◆ TestMapView

#define TestMapView (   SectionObject,
  ExpectAtBase,
  ExpectM 
)

Definition at line 47 of file MmSection.c.

Function Documentation

◆ START_TEST()

START_TEST ( MmSection  )

Definition at line 816 of file MmSection.c.

817{
818 NTSTATUS Status;
819 HANDLE FileHandle1 = NULL, FileHandle2 = NULL;
820 PFILE_OBJECT FileObject1 = NULL, FileObject2 = NULL;
821 OBJECT_ATTRIBUTES ObjectAttributes;
822 IO_STATUS_BLOCK IoStatusBlock;
823 UNICODE_STRING FileName1 = RTL_CONSTANT_STRING(L"\\SystemRoot\\kmtest-MmSection.txt");
824 UNICODE_STRING FileName2 = RTL_CONSTANT_STRING(L"\\SystemRoot\\system32\\ntdll.dll");
825 LARGE_INTEGER FileOffset;
826 UCHAR FileData = 0;
827
828 ok(ExGetPreviousMode() == UserMode, "Previous mode is kernel mode\n");
829 /* create a one-byte file that we can use */
830 InitializeObjectAttributes(&ObjectAttributes, &FileName1, OBJ_CASE_INSENSITIVE, NULL, NULL);
831 Status = ZwCreateFile(&FileHandle1, GENERIC_WRITE | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_SUPERSEDE, FILE_NON_DIRECTORY_FILE, NULL, 0);
832 ok_eq_hex(Status, STATUS_SUCCESS);
833 ok_eq_ulongptr(IoStatusBlock.Information, FILE_CREATED);
834 ok(FileHandle1 != NULL, "FileHandle1 is NULL\n");
835 if (FileHandle1)
836 {
837 FileOffset.QuadPart = 0;
838 Status = ZwWriteFile(FileHandle1, NULL, NULL, NULL, &IoStatusBlock, &FileData, sizeof FileData, &FileOffset, NULL);
839 ok(Status == STATUS_SUCCESS || Status == STATUS_PENDING, "Status = 0x%08lx\n", Status);
840 Status = ZwWaitForSingleObject(FileHandle1, FALSE, NULL);
841 ok_eq_hex(Status, STATUS_SUCCESS);
842 ok_eq_ulongptr(IoStatusBlock.Information, 1);
843 Status = ZwClose(FileHandle1);
844 ok_eq_hex(Status, STATUS_SUCCESS);
845 FileHandle1 = NULL;
846 }
847
848 InitializeObjectAttributes(&ObjectAttributes, &FileName1, OBJ_CASE_INSENSITIVE, NULL, NULL);
849 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);
850 ok_eq_hex(Status, STATUS_SUCCESS);
851 ok_eq_ulongptr(IoStatusBlock.Information, FILE_OPENED);
852 ok(FileHandle1 != NULL, "FileHandle1 is NULL\n");
853 CheckObject(FileHandle1, 2L, 1L);
854
855 InitializeObjectAttributes(&ObjectAttributes, &FileName2, OBJ_CASE_INSENSITIVE, NULL, NULL);
856 Status = ZwCreateFile(&FileHandle2, GENERIC_READ, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_NON_DIRECTORY_FILE, NULL, 0);
857 ok_eq_hex(Status, STATUS_SUCCESS);
858 ok_eq_ulongptr(IoStatusBlock.Information, FILE_OPENED);
859 ok(FileHandle2 != NULL, "FileHandle2 is NULL\n");
860
861 if (!skip(Status == STATUS_SUCCESS && FileHandle1 != NULL, "Failed to open file 1\n"))
862 {
863 Status = ObReferenceObjectByHandle(FileHandle1, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID *)&FileObject1, NULL);
864 ok_eq_hex(Status, STATUS_SUCCESS);
865 ok(FileObject1 != NULL, "FileObject1 is NULL\n");
866 CheckObject(FileHandle1, 3L, 1L);
867 }
868
869 if (!skip(Status == STATUS_SUCCESS && FileHandle2 != NULL, "Failed to open file 2\n"))
870 {
871 Status = ObReferenceObjectByHandle(FileHandle2, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID *)&FileObject2, NULL);
872 ok_eq_hex(Status, STATUS_SUCCESS);
873 ok(FileObject2 != NULL, "FileObject2 is NULL\n");
874 }
875
876 trace("FileHandle1=%p, FileObject1=%p\n", FileHandle1, FileObject1);
877 trace("FileHandle2=%p, FileObject2=%p\n", FileHandle2, FileObject2);
878 TestCreateSection(FileHandle1, FileObject1, FileHandle2, FileObject2);
879
880 if (FileObject2)
881 ObDereferenceObject(FileObject2);
882 if (FileObject1)
883 ObDereferenceObject(FileObject1);
884 if (FileHandle2)
885 ZwClose(FileHandle2);
886 if (FileHandle1)
887 ZwClose(FileHandle1);
888
889 TestPhysicalMemorySection();
890}
TestCreateSection
static VOID TestCreateSection(IN HANDLE FileHandle1, IN PFILE_OBJECT FileObject1, IN HANDLE FileHandle2, IN PFILE_OBJECT FileObject2)
Definition: MmSection.c:88
TestPhysicalMemorySection
static VOID TestPhysicalMemorySection(VOID)
Definition: MmSection.c:401
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:77
ok_eq_ulongptr
#define ok_eq_ulongptr(value, expected)
Definition: apitest.h:71
trace
#define trace
Definition: atltest.h:70
ok
#define ok(value,...)
Definition: atltest.h:57
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
ExGetPreviousMode
#define ExGetPreviousMode
Definition: ex.h:140
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
IoStatusBlock
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
UserMode
#define UserMode
Definition: asm.h:35
ZwClose
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
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
STATUS_PENDING
#define STATUS_PENDING
Definition: ntstatus.h:82
L
#define L(x)
Definition: ntvdm.h:50
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
_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:182
_UNICODE_STRING
Definition: env_spec_w32.h:368
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 88 of file MmSection.c.

93{
94 NTSTATUS Status = STATUS_SUCCESS;
95 PVOID SectionObject;
96 LARGE_INTEGER MaximumSize;
97 ULONG PointerCount1, PointerCount2;
98
99 KmtStartSeh()
100 Status = MmCreateSection(NULL, 0, NULL, NULL, 0, SEC_RESERVE, NULL, NULL);
101 KmtEndSeh(STATUS_SUCCESS);
102 ok_eq_hex(Status, STATUS_INVALID_PAGE_PROTECTION);
103
104 if (!KmtIsCheckedBuild)
105 {
106 /* PAGE_NOACCESS and missing SEC_RESERVE/SEC_COMMIT/SEC_IMAGE assert */
107 KmtStartSeh()
108 Status = MmCreateSection(NULL, 0, NULL, NULL, PAGE_NOACCESS, SEC_RESERVE, NULL, NULL);
109 KmtEndSeh(STATUS_ACCESS_VIOLATION);
110
111 KmtStartSeh()
112 Status = MmCreateSection(NULL, 0, NULL, NULL, PAGE_NOACCESS, 0, NULL, NULL);
113 KmtEndSeh(STATUS_ACCESS_VIOLATION);
114 }
115
116 SectionObject = KmtInvalidPointer;
117 KmtStartSeh()
118 Status = MmCreateSection(&SectionObject, 0, NULL, NULL, 0, SEC_RESERVE, NULL, NULL);
119 KmtEndSeh(STATUS_SUCCESS);
120 ok_eq_hex(Status, STATUS_INVALID_PAGE_PROTECTION);
121 ok_eq_pointer(SectionObject, KmtInvalidPointer);
122
123 if (SectionObject && SectionObject != KmtInvalidPointer)
124 ObDereferenceObject(SectionObject);
125
126 KmtStartSeh()
127 Status = MmCreateSection(NULL, 0, NULL, NULL, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
128 KmtEndSeh(STATUS_ACCESS_VIOLATION);
129
130 SectionObject = KmtInvalidPointer;
131 KmtStartSeh()
132 Status = MmCreateSection(&SectionObject, 0, NULL, NULL, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
133 KmtEndSeh(STATUS_ACCESS_VIOLATION);
134 ok_eq_pointer(SectionObject, KmtInvalidPointer);
135
136 if (SectionObject && SectionObject != KmtInvalidPointer)
137 ObDereferenceObject(SectionObject);
138
139 SectionObject = KmtInvalidPointer;
140 MaximumSize.QuadPart = 0;
141 KmtStartSeh()
142 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, NULL, NULL);
143 KmtEndSeh(STATUS_SUCCESS);
144 ok_eq_hex(Status, STATUS_INVALID_FILE_FOR_SECTION);
145 ok_eq_longlong(MaximumSize.QuadPart, 0LL);
146 ok_eq_pointer(SectionObject, KmtInvalidPointer);
147
148 if (SectionObject && SectionObject != KmtInvalidPointer)
149 ObDereferenceObject(SectionObject);
150
151 MaximumSize.QuadPart = 0;
152 KmtStartSeh()
153 Status = MmCreateSection(NULL, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
154 KmtEndSeh(STATUS_SUCCESS);
155 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_4);
156 ok_eq_longlong(MaximumSize.QuadPart, 0LL);
157
158 if (SectionObject && SectionObject != KmtInvalidPointer)
159 ObDereferenceObject(SectionObject);
160
161 MaximumSize.QuadPart = 1;
162 KmtStartSeh()
163 Status = MmCreateSection(NULL, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
164 KmtEndSeh(STATUS_ACCESS_VIOLATION);
165 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
166
167 if (SectionObject && SectionObject != KmtInvalidPointer)
168 ObDereferenceObject(SectionObject);
169
170 SectionObject = KmtInvalidPointer;
171 MaximumSize.QuadPart = 0;
172 KmtStartSeh()
173 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
174 KmtEndSeh(STATUS_SUCCESS);
175 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_4);
176 ok_eq_longlong(MaximumSize.QuadPart, 0LL);
177 ok_eq_pointer(SectionObject, KmtInvalidPointer);
178
179 if (SectionObject && SectionObject != KmtInvalidPointer)
180 ObDereferenceObject(SectionObject);
181
182 /* page file section */
183 SectionObject = KmtInvalidPointer;
184 MaximumSize.QuadPart = 1;
185 KmtStartSeh()
186 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, NULL);
187 KmtEndSeh(STATUS_SUCCESS);
188 ok_eq_hex(Status, STATUS_SUCCESS);
189 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
190 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
191 ok(SectionObject != NULL, "Section object pointer NULL\n");
192
193 if (SectionObject && SectionObject != KmtInvalidPointer)
194 ObDereferenceObject(SectionObject);
195
196 if (!skip(FileHandle1 != NULL && FileObject1 != NULL &&
197 FileHandle2 != NULL && FileObject2 != NULL, "No file handle or object\n"))
198 {
199 PointerCount1 = 3;
200 PointerCount2 = 3;
201 /* image section */
202 CheckObject(FileHandle2, PointerCount2, 1L);
203 SectionObject = KmtInvalidPointer;
204 MaximumSize.QuadPart = 1;
205 KmtStartSeh()
206 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle2, NULL);
207 KmtEndSeh(STATUS_SUCCESS);
208 ok_eq_hex(Status, STATUS_SUCCESS);
209 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
210 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
211 ok(SectionObject != NULL, "Section object pointer NULL\n");
212 CheckObject(FileHandle2, PointerCount2, 1L);
213 CheckSection(SectionObject, SEC_IMAGE);
214 TestMapView(SectionObject, FALSE, TRUE);
215
216 if (SectionObject && SectionObject != KmtInvalidPointer)
217 ObDereferenceObject(SectionObject);
218
219 CheckObject(FileHandle2, PointerCount2, 1L);
220 SectionObject = KmtInvalidPointer;
221 MaximumSize.QuadPart = 1;
222 KmtStartSeh()
223 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, NULL, FileObject2);
224 KmtEndSeh(STATUS_SUCCESS);
225 ok_eq_hex(Status, STATUS_SUCCESS);
226 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
227 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
228 ok(SectionObject != NULL, "Section object pointer NULL\n");
229 ++PointerCount2;
230 CheckObject(FileHandle2, PointerCount2, 1L);
231 CheckSection(SectionObject, 0);
232 TestMapView(SectionObject, TRUE, TRUE);
233
234 if (SectionObject && SectionObject != KmtInvalidPointer)
235 ObDereferenceObject(SectionObject);
236 //--PointerCount2; // ????
237
238 CheckObject(FileHandle2, PointerCount2, 1L);
239 SectionObject = KmtInvalidPointer;
240 MaximumSize.QuadPart = 1;
241 KmtStartSeh()
242 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle2, FileObject2);
243 KmtEndSeh(STATUS_SUCCESS);
244 ok_eq_hex(Status, STATUS_SUCCESS);
245 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
246 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
247 ok(SectionObject != NULL, "Section object pointer NULL\n");
248 CheckObject(FileHandle2, PointerCount2, 1L);
249 CheckSection(SectionObject, 0);
250 TestMapView(SectionObject, TRUE, TRUE);
251
252 if (SectionObject && SectionObject != KmtInvalidPointer)
253 ObDereferenceObject(SectionObject);
254
255 /* image section with inappropriate file */
256 CheckObject(FileHandle1, PointerCount1, 1L);
257 SectionObject = KmtInvalidPointer;
258 MaximumSize.QuadPart = 1;
259 KmtStartSeh()
260 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle1, NULL);
261 KmtEndSeh(STATUS_SUCCESS);
262 ok_eq_hex(Status, STATUS_INVALID_IMAGE_NOT_MZ);
263 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
264 ok_eq_pointer(SectionObject, KmtInvalidPointer);
265 CheckObject(FileHandle1, PointerCount1, 1L);
266
267 if (SectionObject && SectionObject != KmtInvalidPointer)
268 ObDereferenceObject(SectionObject);
269
270 CheckObject(FileHandle1, PointerCount1, 1L);
271 SectionObject = KmtInvalidPointer;
272 MaximumSize.QuadPart = 1;
273 KmtStartSeh()
274 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, NULL, FileObject1);
275 KmtEndSeh(STATUS_SUCCESS);
276 ok_eq_hex(Status, STATUS_SUCCESS);
277 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
278 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
279 ok(SectionObject != NULL, "Section object pointer NULL\n");
280 ++PointerCount1;
281 CheckObject(FileHandle1, PointerCount1, 1L);
282 CheckSection(SectionObject, 0);
283 TestMapView(SectionObject, TRUE, FALSE);
284
285 if (SectionObject && SectionObject != KmtInvalidPointer)
286 ObDereferenceObject(SectionObject);
287 //--PointerCount1; // ????
288
289 CheckObject(FileHandle1, PointerCount1, 1L);
290 SectionObject = KmtInvalidPointer;
291 MaximumSize.QuadPart = 1;
292 KmtStartSeh()
293 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle1, FileObject1);
294 KmtEndSeh(STATUS_SUCCESS);
295 ok_eq_hex(Status, STATUS_SUCCESS);
296 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
297 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
298 ok(SectionObject != NULL, "Section object pointer NULL\n");
299 CheckObject(FileHandle1, PointerCount1, 1L);
300 CheckSection(SectionObject, 0);
301 TestMapView(SectionObject, TRUE, FALSE);
302
303 if (SectionObject && SectionObject != KmtInvalidPointer)
304 ObDereferenceObject(SectionObject);
305
306 /* image section with two different files */
307 CheckObject(FileHandle1, PointerCount1, 1L);
308 SectionObject = KmtInvalidPointer;
309 MaximumSize.QuadPart = 1;
310 KmtStartSeh()
311 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle1, FileObject2);
312 KmtEndSeh(STATUS_SUCCESS);
313 ok_eq_hex(Status, STATUS_SUCCESS);
314 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
315 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
316 ok(SectionObject != NULL, "Section object pointer NULL\n");
317 CheckObject(FileHandle1, PointerCount1, 1L);
318 CheckObject(FileHandle2, PointerCount2, 1L);
319 CheckSection(SectionObject, 0);
320 TestMapView(SectionObject, TRUE, TRUE);
321
322 if (SectionObject && SectionObject != KmtInvalidPointer)
323 ObDereferenceObject(SectionObject);
324
325 CheckObject(FileHandle1, PointerCount1, 1L);
326 SectionObject = KmtInvalidPointer;
327 MaximumSize.QuadPart = 1;
328 KmtStartSeh()
329 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_IMAGE, FileHandle2, FileObject1);
330 KmtEndSeh(STATUS_SUCCESS);
331 ok_eq_hex(Status, STATUS_SUCCESS);
332 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
333 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
334 ok(SectionObject != NULL, "Section object pointer NULL\n");
335 CheckObject(FileHandle1, PointerCount1, 1L);
336 CheckObject(FileHandle2, PointerCount2, 1L);
337 CheckSection(SectionObject, 0);
338 TestMapView(SectionObject, TRUE, FALSE);
339
340 if (SectionObject && SectionObject != KmtInvalidPointer)
341 ObDereferenceObject(SectionObject);
342
343 /* data file section */
344 CheckObject(FileHandle1, PointerCount1, 1L);
345 SectionObject = KmtInvalidPointer;
346 MaximumSize.QuadPart = 1;
347 KmtStartSeh()
348 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, FileHandle1, NULL);
349 KmtEndSeh(STATUS_SUCCESS);
350 ok_eq_hex(Status, STATUS_SUCCESS);
351 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
352 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
353 ok(SectionObject != NULL, "Section object pointer NULL\n");
354 CheckObject(FileHandle1, PointerCount1, 1L);
355 CheckSection(SectionObject, 0);
356 TestMapView(SectionObject, TRUE, FALSE);
357
358 if (SectionObject && SectionObject != KmtInvalidPointer)
359 ObDereferenceObject(SectionObject);
360
361 CheckObject(FileHandle1, PointerCount1, 1L);
362 SectionObject = KmtInvalidPointer;
363 MaximumSize.QuadPart = 1;
364 KmtStartSeh()
365 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, NULL, FileObject1);
366 KmtEndSeh(STATUS_SUCCESS);
367 ok_eq_hex(Status, STATUS_SUCCESS);
368 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
369 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
370 ok(SectionObject != NULL, "Section object pointer NULL\n");
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 CheckObject(FileHandle1, PointerCount1, 1L);
379 SectionObject = KmtInvalidPointer;
380 MaximumSize.QuadPart = 1;
381 KmtStartSeh()
382 Status = MmCreateSection(&SectionObject, 0, NULL, &MaximumSize, PAGE_READONLY, SEC_RESERVE, FileHandle1, FileObject1);
383 KmtEndSeh(STATUS_SUCCESS);
384 ok_eq_hex(Status, STATUS_SUCCESS);
385 ok_eq_longlong(MaximumSize.QuadPart, 1LL);
386 ok(SectionObject != KmtInvalidPointer, "Section object pointer untouched\n");
387 ok(SectionObject != NULL, "Section object pointer NULL\n");
388 CheckObject(FileHandle1, PointerCount1, 1L);
389 CheckSection(SectionObject, 0);
390 TestMapView(SectionObject, TRUE, FALSE);
391
392 if (SectionObject && SectionObject != KmtInvalidPointer)
393 ObDereferenceObject(SectionObject);
394
395 CheckObject(FileHandle1, PointerCount1, 1L);
396 }
397}
TestMapView
#define TestMapView(SectionObject, ExpectAtBase, ExpectM)
Definition: MmSection.c:47
CheckSection
#define CheckSection(SectionObject, SectionFlag)
Definition: MmSection.c:20
ok_eq_pointer
#define ok_eq_pointer(value, expected)
Definition: apitest.h:59
ok_eq_longlong
#define ok_eq_longlong(value, expected)
Definition: apitest.h:64
TRUE
#define TRUE
Definition: types.h:120
PAGE_READONLY
#define PAGE_READONLY
Definition: compat.h:138
n
GLdouble n
Definition: glext.h:7729
pointer
GLsizei const GLvoid * pointer
Definition: glext.h:5848
KmtStartSeh
#define KmtStartSeh()
Definition: kmt_test.h:282
KmtInvalidPointer
#define KmtInvalidPointer
Definition: kmt_test.h:280
KmtEndSeh
#define KmtEndSeh(ExpectedStatus)
Definition: kmt_test.h:288
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:1323
PAGE_NOACCESS
#define PAGE_NOACCESS
Definition: nt_native.h:1302
STATUS_INVALID_PARAMETER_4
#define STATUS_INVALID_PARAMETER_4
Definition: ntstatus.h:478
STATUS_INVALID_IMAGE_NOT_MZ
#define STATUS_INVALID_IMAGE_NOT_MZ
Definition: ntstatus.h:539
STATUS_INVALID_FILE_FOR_SECTION
#define STATUS_INVALID_FILE_FOR_SECTION
Definition: ntstatus.h:269
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:242
STATUS_INVALID_PAGE_PROTECTION
#define STATUS_INVALID_PAGE_PROTECTION
Definition: ntstatus.h:305
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:4620
file
Definition: fci.c:127
LL
#define LL
Definition: tui.h:167
ULONG
uint32_t ULONG
Definition: typedefs.h:59
QuadPart
ret QuadPart
Definition: rtlfuncs.h:3089

Referenced by START_TEST().

◆ TestPhysicalMemorySection()

static VOID TestPhysicalMemorySection ( VOID  )
static

Definition at line 401 of file MmSection.c.

402{
403 NTSTATUS Status;
404 UNICODE_STRING SectionName = RTL_CONSTANT_STRING(L"\\Device\\PhysicalMemory");
405 OBJECT_ATTRIBUTES ObjectAttributes;
406 HANDLE SectionHandle;
407 PVOID SectionObject;
408 PUCHAR MyPage;
409 PHYSICAL_ADDRESS MyPagePhysical;
410 PUCHAR ZeroPageContents;
411 PHYSICAL_ADDRESS ZeroPagePhysical;
412 PHYSICAL_ADDRESS PhysicalAddress;
413 PVOID Mapping;
414 SYSTEM_BASIC_INFORMATION BasicInfo;
415 PUCHAR MappingBytes;
416 SIZE_T ViewSize;
417 SIZE_T EqualBytes;
418 struct
419 {
420 PVOID Mapping;
421 PHYSICAL_ADDRESS PhysicalAddress;
422 SIZE_T ViewSize;
423 } *UserStruct;
424 PVOID UserMem;
425 SIZE_T UserSize;
426
427 MyPage = ExAllocatePoolWithTag(NonPagedPool, PAGE_SIZE, 'MPmK');
428 if (skip(MyPage != NULL, "Out of memory\n"))
429 return;
430 MyPagePhysical = MmGetPhysicalAddress(MyPage);
431 RtlFillMemory(MyPage + 0 * PAGE_SIZE / 4, PAGE_SIZE / 4, 0x23);
432 RtlFillMemory(MyPage + 1 * PAGE_SIZE / 4, PAGE_SIZE / 4, 0x67);
433 RtlFillMemory(MyPage + 2 * PAGE_SIZE / 4, PAGE_SIZE / 4, 0xab);
434 RtlFillMemory(MyPage + 3 * PAGE_SIZE / 4, PAGE_SIZE / 4, 0xef);
435
436 ZeroPageContents = ExAllocatePoolWithTag(PagedPool, PAGE_SIZE, 'ZPmK');
437 if (skip(ZeroPageContents != NULL, "Out of memory\n"))
438 {
439 ExFreePoolWithTag(MyPage, 'MPmK');
440 return;
441 }
442 ZeroPagePhysical.QuadPart = 0;
443
444 Mapping = MmMapIoSpace(ZeroPagePhysical, PAGE_SIZE, MmCached);
445 if (skip(Mapping != NULL, "Failed to map zero page\n"))
446 {
447 ExFreePoolWithTag(ZeroPageContents, 'ZPmK');
448 ExFreePoolWithTag(MyPage, 'MPmK');
449 return;
450 }
451
452 RtlCopyMemory(ZeroPageContents, Mapping, PAGE_SIZE);
453 MmUnmapIoSpace(Mapping, PAGE_SIZE);
454
455 InitializeObjectAttributes(&ObjectAttributes,
456 &SectionName,
457 0,
458 NULL,
459 NULL);
460 Status = ZwOpenSection(&SectionHandle, SECTION_ALL_ACCESS, &ObjectAttributes);
461 ok_eq_hex(Status, STATUS_SUCCESS);
462 if (!skip(NT_SUCCESS(Status), "No section\n"))
463 {
464 /* Map zero page and compare */
465 Mapping = NULL;
466 ViewSize = PAGE_SIZE;
467 Status = ZwMapViewOfSection(SectionHandle,
468 ZwCurrentProcess(),
469 &Mapping,
470 0,
471 0,
472 &ZeroPagePhysical,
473 &ViewSize,
474 ViewUnmap,
475 0,
476 PAGE_READWRITE);
477 ok_eq_hex(Status, STATUS_SUCCESS);
478 if (!skip(NT_SUCCESS(Status), "No view\n"))
479 {
480 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
481 EqualBytes = RtlCompareMemory(Mapping,
482 ZeroPageContents,
483 PAGE_SIZE);
484 ok_eq_size(EqualBytes, PAGE_SIZE);
485 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
486 ok_eq_hex(Status, STATUS_SUCCESS);
487 }
488
489 /* Map the zero page non-cached */
490 Mapping = NULL;
491 ViewSize = PAGE_SIZE;
492 Status = ZwMapViewOfSection(SectionHandle,
493 ZwCurrentProcess(),
494 &Mapping,
495 0,
496 0,
497 &ZeroPagePhysical,
498 &ViewSize,
499 ViewUnmap,
500 0,
501 PAGE_READWRITE | PAGE_NOCACHE);
502 ok_eq_hex(Status, STATUS_SUCCESS);
503 if (!skip(NT_SUCCESS(Status), "No view\n"))
504 {
505 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
506 EqualBytes = RtlCompareMemory(Mapping,
507 ZeroPageContents,
508 PAGE_SIZE);
509 ok_eq_size(EqualBytes, PAGE_SIZE);
510 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
511 ok_eq_hex(Status, STATUS_SUCCESS);
512 }
513
514 /* Map our NP page, compare, and check that modifications are reflected */
515 Mapping = NULL;
516 ViewSize = PAGE_SIZE;
517 Status = ZwMapViewOfSection(SectionHandle,
518 ZwCurrentProcess(),
519 &Mapping,
520 0,
521 0,
522 &MyPagePhysical,
523 &ViewSize,
524 ViewUnmap,
525 0,
526 PAGE_READWRITE);
527 ok_eq_hex(Status, STATUS_SUCCESS);
528 if (!skip(NT_SUCCESS(Status), "No view\n"))
529 {
530 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
531 EqualBytes = RtlCompareMemory(Mapping,
532 MyPage,
533 PAGE_SIZE);
534 ok_eq_size(EqualBytes, PAGE_SIZE);
535
536 MappingBytes = Mapping;
537 ok(MappingBytes[5] == 0x23, "Mapping[5] = 0x%x\n", MappingBytes[5]);
538 ok(MyPage[5] == 0x23, "MyPage[5] = 0x%x\n", MyPage[5]);
539
540 MyPage[5] = 0x44;
541 ok(MappingBytes[5] == 0x44, "Mapping[5] = 0x%x\n", MappingBytes[5]);
542 ok(MyPage[5] == 0x44, "MyPage[5] = 0x%x\n", MyPage[5]);
543
544 MappingBytes[5] = 0x88;
545 ok(MappingBytes[5] == 0x88, "Mapping[5] = 0x%x\n", MappingBytes[5]);
546 ok(MyPage[5] == 0x88, "MyPage[5] = 0x%x\n", MyPage[5]);
547
548 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
549 ok_eq_hex(Status, STATUS_SUCCESS);
550 }
551
552 /* Unaligned mapping will get aligned automatically */
553 Mapping = NULL;
554 ViewSize = PAGE_SIZE - 4;
555 PhysicalAddress.QuadPart = MyPagePhysical.QuadPart + 4;
556 Status = ZwMapViewOfSection(SectionHandle,
557 ZwCurrentProcess(),
558 &Mapping,
559 0,
560 0,
561 &PhysicalAddress,
562 &ViewSize,
563 ViewUnmap,
564 0,
565 PAGE_READWRITE);
566 ok_eq_hex(Status, STATUS_SUCCESS);
567 if (!skip(NT_SUCCESS(Status), "No view\n"))
568 {
569 ok((LONG_PTR)Mapping > 0, "Mapping = %p\n", Mapping);
570 ok(((ULONG_PTR)Mapping % PAGE_SIZE) == 0, "Mapping = %p\n", Mapping);
571 ok_eq_ulong(ViewSize, PAGE_SIZE);
572
573 EqualBytes = RtlCompareMemory(Mapping,
574 MyPage,
575 PAGE_SIZE);
576 ok_eq_size(EqualBytes, PAGE_SIZE);
577
578 Status = ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
579 ok_eq_hex(Status, STATUS_SUCCESS);
580 }
581
582 /* The following tests need to pass parameters in user mode */
583 UserStruct = NULL;
584 UserMem = NULL;
585 UserSize = PAGE_SIZE;
586 Status = ZwAllocateVirtualMemory(ZwCurrentProcess(),
587 &UserMem,
588 0,
589 &UserSize,
590 MEM_COMMIT,
591 PAGE_READWRITE);
592 ok_eq_hex(Status, STATUS_SUCCESS);
593 if (NT_SUCCESS(Status))
594 UserStruct = UserMem;
595
596 /* Find highest physical page -- only kernel can map beyond this */
597 Status = ZwQuerySystemInformation(SystemBasicInformation,
598 &BasicInfo,
599 sizeof(BasicInfo),
600 NULL);
601 ok_eq_hex(Status, STATUS_SUCCESS);
602 trace("HighestPhysicalPageNumber: %lx\n", BasicInfo.HighestPhysicalPageNumber);
603
604 /* Start one page before highest physical -- succeeds for user/kernel */
605 Mapping = NULL;
606 ViewSize = PAGE_SIZE;
607 PhysicalAddress.QuadPart = (ULONGLONG)(BasicInfo.HighestPhysicalPageNumber - 1) << PAGE_SHIFT;
608 Status = ZwMapViewOfSection(SectionHandle,
609 ZwCurrentProcess(),
610 &Mapping,
611 0,
612 0,
613 &PhysicalAddress,
614 &ViewSize,
615 ViewUnmap,
616 0,
617 PAGE_READWRITE);
618 ok_eq_hex(Status, STATUS_SUCCESS);
619 if (NT_SUCCESS(Status))
620 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
621
622 /* Repeat from user mode */
623 if (!skip(UserStruct != NULL, "No user memory\n"))
624 {
625 KmtStartSeh()
626 UserStruct->Mapping = NULL;
627 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
628 UserStruct->ViewSize = PAGE_SIZE;
629 KmtEndSeh(STATUS_SUCCESS);
630
631 Status = NtMapViewOfSection(SectionHandle,
632 NtCurrentProcess(),
633 &UserStruct->Mapping,
634 0,
635 0,
636 &UserStruct->PhysicalAddress,
637 &UserStruct->ViewSize,
638 ViewUnmap,
639 0,
640 PAGE_READWRITE);
641 ok_eq_hex(Status, STATUS_SUCCESS);
642 if (NT_SUCCESS(Status))
643 {
644 KmtStartSeh()
645 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
646 KmtEndSeh(STATUS_SUCCESS);
647 }
648 }
649
650 /* Now start at highest physical -- fails for user */
651 Mapping = NULL;
652 ViewSize = PAGE_SIZE;
653 PhysicalAddress.QuadPart = (ULONGLONG)BasicInfo.HighestPhysicalPageNumber << PAGE_SHIFT;
654 Status = ZwMapViewOfSection(SectionHandle,
655 ZwCurrentProcess(),
656 &Mapping,
657 0,
658 0,
659 &PhysicalAddress,
660 &ViewSize,
661 ViewUnmap,
662 0,
663 PAGE_READWRITE);
664 ok_eq_hex(Status, STATUS_SUCCESS);
665 if (NT_SUCCESS(Status))
666 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
667
668 /* Repeat from user mode */
669 if (!skip(UserStruct != NULL, "No user memory\n"))
670 {
671 KmtStartSeh()
672 UserStruct->Mapping = NULL;
673 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
674 UserStruct->ViewSize = PAGE_SIZE;
675 KmtEndSeh(STATUS_SUCCESS);
676
677 Status = NtMapViewOfSection(SectionHandle,
678 NtCurrentProcess(),
679 &UserStruct->Mapping,
680 0,
681 0,
682 &UserStruct->PhysicalAddress,
683 &UserStruct->ViewSize,
684 ViewUnmap,
685 0,
686 PAGE_READWRITE);
687 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
688 if (NT_SUCCESS(Status))
689 {
690 KmtStartSeh()
691 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
692 KmtEndSeh(STATUS_SUCCESS);
693 }
694 }
695
696 /* End of view crosses highest physical -- fails for user */
697 Mapping = NULL;
698 ViewSize = 2 * PAGE_SIZE;
699 PhysicalAddress.QuadPart = (ULONGLONG)(BasicInfo.HighestPhysicalPageNumber - 1) << PAGE_SHIFT;
700 Status = ZwMapViewOfSection(SectionHandle,
701 ZwCurrentProcess(),
702 &Mapping,
703 0,
704 0,
705 &PhysicalAddress,
706 &ViewSize,
707 ViewUnmap,
708 0,
709 PAGE_READWRITE);
710 ok_eq_hex(Status, STATUS_SUCCESS);
711 if (NT_SUCCESS(Status))
712 ZwUnmapViewOfSection(ZwCurrentProcess(), Mapping);
713
714 /* Repeat from user mode */
715 if (!skip(UserStruct != NULL, "No user memory\n"))
716 {
717 KmtStartSeh()
718 UserStruct->Mapping = NULL;
719 UserStruct->PhysicalAddress.QuadPart = PhysicalAddress.QuadPart;
720 UserStruct->ViewSize = 2 * PAGE_SIZE;
721 KmtEndSeh(STATUS_SUCCESS);
722
723 Status = NtMapViewOfSection(SectionHandle,
724 NtCurrentProcess(),
725 &UserStruct->Mapping,
726 0,
727 0,
728 &UserStruct->PhysicalAddress,
729 &UserStruct->ViewSize,
730 ViewUnmap,
731 0,
732 PAGE_READWRITE);
733 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
734 if (NT_SUCCESS(Status))
735 {
736 KmtStartSeh()
737 ZwUnmapViewOfSection(ZwCurrentProcess(), UserStruct->Mapping);
738 KmtEndSeh(STATUS_SUCCESS);
739 }
740 }
741
742 /* Free user memory and close section */
743 if (!skip(UserStruct != NULL, "No user memory\n"))
744 {
745 UserSize = 0;
746 Status = ZwFreeVirtualMemory(ZwCurrentProcess(),
747 &UserMem,
748 &UserSize,
749 MEM_RELEASE);
750 ok_eq_hex(Status, STATUS_SUCCESS);
751 }
752
753 Status = ObCloseHandle(SectionHandle, UserMode);
754 ok_eq_hex(Status, STATUS_SUCCESS);
755 }
756
757 /* Try flag 0x80000000, which ROS calls SEC_PHYSICALMEMORY */
758 InitializeObjectAttributes(&ObjectAttributes,
759 NULL,
760 OBJ_KERNEL_HANDLE,
761 NULL,
762 NULL);
763 Status = ZwCreateSection(&SectionHandle,
764 SECTION_ALL_ACCESS,
765 &ObjectAttributes,
766 NULL,
767 PAGE_READWRITE,
768 0x80000000,
769 NULL);
770 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
771 if (NT_SUCCESS(Status))
772 ZwClose(SectionHandle);
773
774 /* Assertion failure: AllocationAttributes & SEC_IMAGE | SEC_RESERVE | SEC_COMMIT */
775 if (!KmtIsCheckedBuild)
776 {
777 InitializeObjectAttributes(&ObjectAttributes,
778 NULL,
779 OBJ_KERNEL_HANDLE,
780 NULL,
781 NULL);
782 Status = MmCreateSection(&SectionObject,
783 SECTION_ALL_ACCESS,
784 &ObjectAttributes,
785 NULL,
786 PAGE_READWRITE,
787 0x80000000,
788 NULL,
789 NULL);
790 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
791 if (NT_SUCCESS(Status))
792 ObDereferenceObject(SectionObject);
793 }
794
795 InitializeObjectAttributes(&ObjectAttributes,
796 NULL,
797 OBJ_KERNEL_HANDLE,
798 NULL,
799 NULL);
800 Status = MmCreateSection(&SectionObject,
801 SECTION_ALL_ACCESS,
802 &ObjectAttributes,
803 NULL,
804 PAGE_READWRITE,
805 SEC_RESERVE | 0x80000000,
806 NULL,
807 NULL);
808 ok_eq_hex(Status, STATUS_INVALID_PARAMETER_6);
809 if (NT_SUCCESS(Status))
810 ObDereferenceObject(SectionObject);
811
812 ExFreePoolWithTag(ZeroPageContents, 'ZPmK');
813 ExFreePoolWithTag(MyPage, 'MPmK');
814}
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:3622
ok_eq_ulong
#define ok_eq_ulong(value, expected)
Definition: apitest.h:63
ok_eq_size
#define ok_eq_size(value, expected)
Definition: apitest.h:69
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:599
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:1311
PAGE_READWRITE
#define PAGE_READWRITE
Definition: nt_native.h:1304
SECTION_ALL_ACCESS
#define SECTION_ALL_ACCESS
Definition: nt_native.h:1293
NtCurrentProcess
#define NtCurrentProcess()
Definition: nt_native.h:1657
ViewUnmap
@ ViewUnmap
Definition: nt_native.h:1279
MEM_RELEASE
#define MEM_RELEASE
Definition: nt_native.h:1316
MEM_COMMIT
#define MEM_COMMIT
Definition: nt_native.h:1313
MmGetPhysicalAddress
PHYSICAL_ADDRESS NTAPI MmGetPhysicalAddress(IN PVOID Address)
Definition: stubs.c:685
STATUS_INVALID_PARAMETER_6
#define STATUS_INVALID_PARAMETER_6
Definition: ntstatus.h:480
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().