ReactOS 0.4.16-dev-1188-gc03d779
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: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 
)    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:194
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 832 of file MmSection.c.

833{
834 NTSTATUS Status;
835 HANDLE FileHandle1 = NULL, FileHandle2 = NULL;
836 PFILE_OBJECT FileObject1 = NULL, FileObject2 = NULL;
837 OBJECT_ATTRIBUTES ObjectAttributes;
838 IO_STATUS_BLOCK IoStatusBlock;
839 UNICODE_STRING FileName1 = RTL_CONSTANT_STRING(L"\\SystemRoot\\kmtest-MmSection.txt");
840 UNICODE_STRING FileName2 = RTL_CONSTANT_STRING(L"\\SystemRoot\\system32\\ntdll.dll");
841 LARGE_INTEGER FileOffset;
842 UCHAR FileData = 0;
843
844 ok(ExGetPreviousMode() == UserMode, "Previous mode is kernel mode\n");
845 /* create a one-byte file that we can use */
846 InitializeObjectAttributes(&ObjectAttributes, &FileName1, OBJ_CASE_INSENSITIVE, NULL, NULL);
847 Status = ZwCreateFile(&FileHandle1, GENERIC_WRITE | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_SUPERSEDE, FILE_NON_DIRECTORY_FILE, NULL, 0);
848 ok_eq_hex(Status, STATUS_SUCCESS);
849 ok_eq_ulongptr(IoStatusBlock.Information, FILE_CREATED);
850 ok(FileHandle1 != NULL, "FileHandle1 is NULL\n");
851 if (FileHandle1)
852 {
853 FileOffset.QuadPart = 0;
854 Status = ZwWriteFile(FileHandle1, NULL, NULL, NULL, &IoStatusBlock, &FileData, sizeof FileData, &FileOffset, NULL);
855 ok(Status == STATUS_SUCCESS || Status == STATUS_PENDING, "Status = 0x%08lx\n", Status);
856 Status = ZwWaitForSingleObject(FileHandle1, FALSE, NULL);
857 ok_eq_hex(Status, STATUS_SUCCESS);
858 ok_eq_ulongptr(IoStatusBlock.Information, 1);
859 Status = ZwClose(FileHandle1);
860 ok_eq_hex(Status, STATUS_SUCCESS);
861 FileHandle1 = NULL;
862 }
863
864 InitializeObjectAttributes(&ObjectAttributes, &FileName1, OBJ_CASE_INSENSITIVE, NULL, NULL);
865 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);
866 ok_eq_hex(Status, STATUS_SUCCESS);
867 ok_eq_ulongptr(IoStatusBlock.Information, FILE_OPENED);
868 ok(FileHandle1 != NULL, "FileHandle1 is NULL\n");
869 CheckObject(FileHandle1, 2L, 1L);
870
871 InitializeObjectAttributes(&ObjectAttributes, &FileName2, OBJ_CASE_INSENSITIVE, NULL, NULL);
872 Status = ZwCreateFile(&FileHandle2, GENERIC_READ, &ObjectAttributes, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_NON_DIRECTORY_FILE, NULL, 0);
873 ok_eq_hex(Status, STATUS_SUCCESS);
874 ok_eq_ulongptr(IoStatusBlock.Information, FILE_OPENED);
875 ok(FileHandle2 != NULL, "FileHandle2 is NULL\n");
876
877 if (!skip(Status == STATUS_SUCCESS && FileHandle1 != NULL, "Failed to open file 1\n"))
878 {
879 Status = ObReferenceObjectByHandle(FileHandle1, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID *)&FileObject1, NULL);
880 ok_eq_hex(Status, STATUS_SUCCESS);
881 ok(FileObject1 != NULL, "FileObject1 is NULL\n");
882 CheckObject(FileHandle1, 3L, 1L);
883 }
884
885 if (!skip(Status == STATUS_SUCCESS && FileHandle2 != NULL, "Failed to open file 2\n"))
886 {
887 Status = ObReferenceObjectByHandle(FileHandle2, FILE_READ_DATA | FILE_WRITE_DATA, *IoFileObjectType, KernelMode, (PVOID *)&FileObject2, NULL);
888 ok_eq_hex(Status, STATUS_SUCCESS);
889 ok(FileObject2 != NULL, "FileObject2 is NULL\n");
890 }
891
892 trace("FileHandle1=%p, FileObject1=%p\n", FileHandle1, FileObject1);
893 trace("FileHandle2=%p, FileObject2=%p\n", FileHandle2, FileObject2);
894 TestCreateSection(FileHandle1, FileObject1, FileHandle2, FileObject2);
895
896 if (FileObject2)
897 ObDereferenceObject(FileObject2);
898 if (FileObject1)
899 ObDereferenceObject(FileObject1);
900 if (FileHandle2)
901 ZwClose(FileHandle2);
902 if (FileHandle1)
903 ZwClose(FileHandle1);
904
905 TestPhysicalMemorySection();
906}
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:416
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:58
ok_eq_ulongptr
#define ok_eq_ulongptr(value, expected)
Definition: apitest.h:52
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
STATUS_PENDING
#define STATUS_PENDING
Definition: d3dkmdt.h:43
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: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
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: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
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 93 of file MmSection.c.

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

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