ReactOS 0.4.17-dev-684-ga6524ef
Classes | Macros | Functions | Variables
NtMapViewOfSection.c File Reference
#include "precomp.h"
#include <pseh/pseh2.h>
Include dependency graph for NtMapViewOfSection.c:

Go to the source code of this file.

Classes

struct  _SECTION_CONTENTS_IMAGE_FILE
 
struct  _RAW_SIZE_IMAGE_FILE
 

Macros

#define IsX86()   FALSE
 
#define BYTES4(x)   x, x, x, x
 
#define BYTES8(x)   BYTES4(x), BYTES4(x)
 
#define BYTES16(x)   BYTES8(x), BYTES8(x)
 
#define BYTES32(x)   BYTES16(x), BYTES16(x)
 
#define BYTES64(x)   BYTES32(x), BYTES32(x)
 
#define BYTES128(x)   BYTES64(x), BYTES64(x)
 
#define BYTES256(x)   BYTES128(x), BYTES128(x)
 
#define BYTES512(x)   BYTES256(x), BYTES256(x)
 
#define BYTES1024(x)   BYTES512(x), BYTES512(x)
 
#define TEST_BYTE(n, v)   StartSeh() ok_hex(Bytes[n], v); EndSeh(STATUS_SUCCESS);
 
#define TEST_WRITE(n)   StartSeh() *(volatile UCHAR *)&Bytes[n] = Bytes[n]; EndSeh(STATUS_SUCCESS);
 
#define TEST_NOWRITE(n)   StartSeh() *(volatile UCHAR *)&Bytes[n] = Bytes[n]; EndSeh(STATUS_ACCESS_VIOLATION);
 
#define TEST_BYTE(n, v)
 

Functions

void Test_PageFileSection (void)
 
void Test_ImageSection (void)
 
void Test_ImageSection2 (void)
 
void Test_BasedSection (void)
 
 C_ASSERT (FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, text_data)==0x400)
 
 C_ASSERT (FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, rossym_data)==0x800)
 
 C_ASSERT (FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, rsrc_data)==0xc00)
 
 C_ASSERT (FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, clc_data)==0x1000)
 
static void Test_SectionContents (BOOL Relocate)
 
 C_ASSERT (FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, text_data)==0x400)
 
 C_ASSERT (FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, data_data)==0x1600)
 
 C_ASSERT (FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, rsrc_data)==0x2800)
 
static void Test_RawSize (ULONG TestNumber)
 
static void Test_EmptyFile (VOID)
 
static void Test_Truncate (VOID)
 
 START_TEST (NtMapViewOfSection)
 

Variables

static struct _SECTION_CONTENTS_IMAGE_FILE SectionContentsImageFile
 
static struct _RAW_SIZE_IMAGE_FILE RawSizeImageFile
 

Macro Definition Documentation

◆ BYTES1024

#define BYTES1024 (   x)    BYTES512(x), BYTES512(x)

Definition at line 1198 of file NtMapViewOfSection.c.

◆ BYTES128

#define BYTES128 (   x)    BYTES64(x), BYTES64(x)

Definition at line 1195 of file NtMapViewOfSection.c.

◆ BYTES16

#define BYTES16 (   x)    BYTES8(x), BYTES8(x)

Definition at line 1192 of file NtMapViewOfSection.c.

◆ BYTES256

#define BYTES256 (   x)    BYTES128(x), BYTES128(x)

Definition at line 1196 of file NtMapViewOfSection.c.

◆ BYTES32

#define BYTES32 (   x)    BYTES16(x), BYTES16(x)

Definition at line 1193 of file NtMapViewOfSection.c.

◆ BYTES4

#define BYTES4 (   x)    x, x, x, x

Definition at line 1190 of file NtMapViewOfSection.c.

◆ BYTES512

#define BYTES512 (   x)    BYTES256(x), BYTES256(x)

Definition at line 1197 of file NtMapViewOfSection.c.

◆ BYTES64

#define BYTES64 (   x)    BYTES32(x), BYTES32(x)

Definition at line 1194 of file NtMapViewOfSection.c.

◆ BYTES8

#define BYTES8 (   x)    BYTES4(x), BYTES4(x)

Definition at line 1191 of file NtMapViewOfSection.c.

◆ IsX86

#define IsX86 ( )    FALSE

Definition at line 16 of file NtMapViewOfSection.c.

◆ TEST_BYTE [1/2]

#define TEST_BYTE (   n,
  v 
)    StartSeh() ok_hex(Bytes[n], v); EndSeh(STATUS_SUCCESS);

◆ TEST_BYTE [2/2]

#define TEST_BYTE (   n,
  v 
)
Value:
StartSeh() \
ok(Bytes[n] == v, "[%lu] Bytes[%u] = 0x%x, expected 0x%x\n", \
TestNumber, n, Bytes[n], v); \
EndSeh(STATUS_SUCCESS);
StartSeh
#define StartSeh()
Definition: apitest.h:93
v
const GLdouble * v
Definition: gl.h:2040
n
GLdouble n
Definition: glext.h:7729
Bytes
_In_ UINT Bytes
Definition: mmcopy.h:9
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65

◆ TEST_NOWRITE

#define TEST_NOWRITE (   n)    StartSeh() *(volatile UCHAR *)&Bytes[n] = Bytes[n]; EndSeh(STATUS_ACCESS_VIOLATION);

◆ TEST_WRITE

#define TEST_WRITE (   n)    StartSeh() *(volatile UCHAR *)&Bytes[n] = Bytes[n]; EndSeh(STATUS_SUCCESS);

Function Documentation

◆ C_ASSERT() [1/7]

C_ASSERT ( FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, data_data)  = =0x1600)

◆ C_ASSERT() [2/7]

C_ASSERT ( FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, rsrc_data)  = =0x2800)

◆ C_ASSERT() [3/7]

C_ASSERT ( FIELD_OFFSET(struct _RAW_SIZE_IMAGE_FILE, text_data)  = =0x400)

◆ C_ASSERT() [4/7]

C_ASSERT ( FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, clc_data)  = =0x1000)

◆ C_ASSERT() [5/7]

C_ASSERT ( FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, rossym_data)  = =0x800)

◆ C_ASSERT() [6/7]

C_ASSERT ( FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, rsrc_data)  = =0xc00)

◆ C_ASSERT() [7/7]

C_ASSERT ( FIELD_OFFSET(struct _SECTION_CONTENTS_IMAGE_FILE, text_data)  = =0x400)

◆ START_TEST()

START_TEST ( NtMapViewOfSection  )

Definition at line 2063 of file NtMapViewOfSection.c.

2064{
2065 Test_PageFileSection();
2066 Test_ImageSection();
2067 Test_BasedSection();
2068 Test_SectionContents(FALSE);
2069 Test_SectionContents(TRUE);
2070 Test_RawSize(0);
2071 Test_RawSize(1);
2072 Test_RawSize(2);
2073 Test_EmptyFile();
2074 Test_Truncate();
2075}
Test_SectionContents
static void Test_SectionContents(BOOL Relocate)
Definition: NtMapViewOfSection.c:1414
Test_PageFileSection
void Test_PageFileSection(void)
Definition: NtMapViewOfSection.c:20
Test_ImageSection
void Test_ImageSection(void)
Definition: NtMapViewOfSection.c:760
Test_EmptyFile
static void Test_EmptyFile(VOID)
Definition: NtMapViewOfSection.c:1922
Test_BasedSection
void Test_BasedSection(void)
Definition: NtMapViewOfSection.c:1115
Test_RawSize
static void Test_RawSize(ULONG TestNumber)
Definition: NtMapViewOfSection.c:1764
Test_Truncate
static void Test_Truncate(VOID)
Definition: NtMapViewOfSection.c:1970
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117

◆ Test_BasedSection()

void Test_BasedSection ( void  )

Definition at line 1115 of file NtMapViewOfSection.c.

1116{
1117 NTSTATUS Status;
1118 HANDLE SectionHandle1, SectionHandle2;
1119 LARGE_INTEGER MaximumSize, SectionOffset;
1120 PVOID BaseAddress1, BaseAddress2;
1121 SIZE_T ViewSize;
1122
1123 /* Create a based section with SEC_COMMIT */
1124 MaximumSize.QuadPart = 0x1000;
1125 Status = NtCreateSection(&SectionHandle1,
1126 SECTION_ALL_ACCESS,
1127 NULL,
1128 &MaximumSize,
1129 PAGE_READWRITE,
1130 SEC_COMMIT | SEC_BASED,
1131 NULL);
1132 ok_ntstatus(Status, STATUS_SUCCESS);
1133
1134 /* Map the 1st section */
1135 BaseAddress1 = NULL;
1136 SectionOffset.QuadPart = 0;
1137 ViewSize = 0;
1138 Status = NtMapViewOfSection(SectionHandle1,
1139 NtCurrentProcess(),
1140 &BaseAddress1,
1141 0,
1142 0,
1143 &SectionOffset,
1144 &ViewSize,
1145 ViewShare,
1146 0,
1147 PAGE_READWRITE);
1148#if 0 // WOW64?
1149 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1150#else
1151 ok_ntstatus(Status, STATUS_SUCCESS);
1152#endif
1153
1154 /* Create a 2nd based section with SEC_COMMIT */
1155 MaximumSize.QuadPart = 0x1000;
1156 Status = NtCreateSection(&SectionHandle2,
1157 SECTION_ALL_ACCESS,
1158 NULL,
1159 &MaximumSize,
1160 PAGE_READWRITE,
1161 SEC_COMMIT | SEC_BASED,
1162 NULL);
1163 ok_ntstatus(Status, STATUS_SUCCESS);//
1164
1165 /* Map the 2nd section */
1166 BaseAddress2 = NULL;
1167 SectionOffset.QuadPart = 0;
1168 ViewSize = 0;
1169 Status = NtMapViewOfSection(SectionHandle2,
1170 NtCurrentProcess(),
1171 &BaseAddress2,
1172 0,
1173 0,
1174 &SectionOffset,
1175 &ViewSize,
1176 ViewShare,
1177 0,
1178 PAGE_READWRITE);
1179#if 0 // WOW64?
1180 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1181#else
1182 ok_ntstatus(Status, STATUS_SUCCESS);
1183 ok((ULONG_PTR)BaseAddress2 < (ULONG_PTR)BaseAddress1,
1184 "Invalid addresses: BaseAddress1=%p, BaseAddress2=%p\n", BaseAddress1, BaseAddress2);
1185 ok(((ULONG_PTR)BaseAddress1 - (ULONG_PTR)BaseAddress2) == 0x10000,
1186 "Invalid addresses: BaseAddress1=%p, BaseAddress2=%p\n", BaseAddress1, BaseAddress2);
1187#endif
1188}
NtCreateSection
NTSTATUS NTAPI NtCreateSection(OUT PHANDLE SectionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN PLARGE_INTEGER MaximumSize OPTIONAL, IN ULONG SectionPageProtection OPTIONAL, IN ULONG AllocationAttributes, IN HANDLE FileHandle OPTIONAL)
Definition: section.c:3090
NtMapViewOfSection
NTSTATUS NTAPI NtMapViewOfSection(_In_ HANDLE SectionHandle, _In_ HANDLE ProcessHandle, _Outptr_result_bytebuffer_(*ViewSize) _Pre_valid_ PVOID *BaseAddress, _In_ ULONG_PTR ZeroBits, _In_ SIZE_T CommitSize, _Inout_opt_ PLARGE_INTEGER SectionOffset, _Inout_ PSIZE_T ViewSize, _In_range_(ViewShare, ViewUnmap) SECTION_INHERIT InheritDisposition, _In_ ULONG AllocationType, _In_ ULONG Win32Protect)
Definition: section.c:3271
ok_ntstatus
#define ok_ntstatus(status, expected)
Definition: atltest.h:135
ok
#define ok(value,...)
Definition: atltest.h:57
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
NULL
#define NULL
Definition: types.h:112
Status
Status
Definition: gdiplustypes.h:24
SectionOffset
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize _Pre_valid_ PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER SectionOffset
Definition: mmfuncs.h:411
MaximumSize
_In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_opt_ PLARGE_INTEGER MaximumSize
Definition: mmfuncs.h:366
ViewSize
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize _Pre_valid_ PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER _Inout_ PSIZE_T ViewSize
Definition: mmfuncs.h:412
SEC_COMMIT
#define SEC_COMMIT
Definition: mmtypes.h:100
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
ViewShare
@ ViewShare
Definition: nt_native.h:1281
SEC_BASED
#define SEC_BASED
Definition: ntifs.template.h:1383
STATUS_CONFLICTING_ADDRESSES
#define STATUS_CONFLICTING_ADDRESSES
Definition: ntstatus.h:354
SIZE_T
ULONG_PTR SIZE_T
Definition: typedefs.h:80
ULONG_PTR
uint32_t ULONG_PTR
Definition: typedefs.h:65
_LARGE_INTEGER
Definition: typedefs.h:103

Referenced by START_TEST().

◆ Test_EmptyFile()

static void Test_EmptyFile ( VOID  )
static

Definition at line 1922 of file NtMapViewOfSection.c.

1923{
1924 NTSTATUS Status;
1925 WCHAR TempPath[MAX_PATH];
1926 WCHAR FileName[MAX_PATH];
1927 HANDLE Handle;
1928 HANDLE SectionHandle;
1929 ULONG Length;
1930
1931 Length = GetTempPathW(MAX_PATH, TempPath);
1932 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1933 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1934 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1935 Handle = CreateFileW(FileName,
1936 FILE_ALL_ACCESS,
1937 0,
1938 NULL,
1939 CREATE_ALWAYS,
1940 0,
1941 NULL);
1942 if (Handle == INVALID_HANDLE_VALUE)
1943 {
1944 skip("Failed to create temp file %ls, error %lu\n", FileName, GetLastError());
1945 return;
1946 }
1947
1948 Status = NtCreateSection(&SectionHandle,
1949 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1950 0, 0, PAGE_READONLY, SEC_COMMIT, Handle);
1951 ok_ntstatus(Status, STATUS_MAPPED_FILE_SIZE_ZERO);
1952
1953 if (NT_SUCCESS(Status))
1954 NtClose(SectionHandle);
1955
1956 Status = NtCreateSection(&SectionHandle,
1957 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1958 0, 0, PAGE_READONLY, SEC_IMAGE, Handle);
1959 ok_ntstatus(Status, STATUS_INVALID_FILE_FOR_SECTION);
1960
1961 if (NT_SUCCESS(Status))
1962 NtClose(SectionHandle);
1963
1964 CloseHandle(Handle);
1965 DeleteFileW(FileName);
1966}
skip
#define skip(...)
Definition: atltest.h:64
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
CloseHandle
#define CloseHandle
Definition: compat.h:739
PAGE_READONLY
#define PAGE_READONLY
Definition: compat.h:138
SECTION_MAP_READ
#define SECTION_MAP_READ
Definition: compat.h:139
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
MAX_PATH
#define MAX_PATH
Definition: compat.h:34
CreateFileW
#define CreateFileW
Definition: compat.h:741
DeleteFileW
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
GetTempPathW
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:1999
L
#define L(x)
Definition: resources.c:13
GetTempFileNameW
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
Handle
ULONG Handle
Definition: gdb_input.c:15
CREATE_ALWAYS
#define CREATE_ALWAYS
Definition: disk.h:72
SEC_IMAGE
#define SEC_IMAGE
Definition: mmtypes.h:97
SECTION_QUERY
#define SECTION_QUERY
Definition: nt_native.h:1290
NtClose
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3429
FILE_ALL_ACCESS
#define FILE_ALL_ACCESS
Definition: nt_native.h:651
STANDARD_RIGHTS_REQUIRED
#define STANDARD_RIGHTS_REQUIRED
Definition: nt_native.h:63
Length
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:102
STATUS_INVALID_FILE_FOR_SECTION
#define STATUS_INVALID_FILE_FOR_SECTION
Definition: ntstatus.h:362
STATUS_MAPPED_FILE_SIZE_ZERO
#define STATUS_MAPPED_FILE_SIZE_ZERO
Definition: ntstatus.h:616
WCHAR
short WCHAR
Definition: pedump.c:58
_FileName
Definition: filecomp.c:348
ULONG
uint32_t ULONG
Definition: typedefs.h:59
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042

Referenced by START_TEST().

◆ Test_ImageSection()

void Test_ImageSection ( void  )

Definition at line 760 of file NtMapViewOfSection.c.

761{
762 UNICODE_STRING FileName;
763 NTSTATUS Status;
764 OBJECT_ATTRIBUTES FileObjectAttributes;
765 IO_STATUS_BLOCK IoStatusBlock;
766 WCHAR TestDllPath[MAX_PATH];
767 HANDLE FileHandle, DataSectionHandle, ImageSectionHandle;
768 PVOID DataBase, ImageBase;
769 SIZE_T ViewSize;
770
771 GetModuleFileNameW(NULL, TestDllPath, RTL_NUMBER_OF(TestDllPath));
772 wcsrchr(TestDllPath, L'\\')[1] = UNICODE_NULL;
773 StringCbCatW(TestDllPath, sizeof(TestDllPath), L"testdata\\test.dll");
774 if (!RtlDosPathNameToNtPathName_U(TestDllPath,
775 &FileName,
776 NULL,
777 NULL))
778 {
779 ok(0, "RtlDosPathNameToNtPathName_U failed\n");
780 return;
781 }
782
783 InitializeObjectAttributes(&FileObjectAttributes,
784 &FileName,
785 0,
786 NULL,
787 NULL);
788
789 Status = NtOpenFile(&FileHandle,
790 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
791 &FileObjectAttributes,
792 &IoStatusBlock,
793 FILE_SHARE_READ,
794 FILE_SYNCHRONOUS_IO_NONALERT);
795 ok_ntstatus(Status, STATUS_SUCCESS);
796 if (!NT_SUCCESS(Status))
797 {
798 skip("Failed to open file %s\n", wine_dbgstr_wn(FileName.Buffer, FileName.Length / sizeof(WCHAR)));
799 RtlFreeHeap(RtlGetProcessHeap(), 0, FileName.Buffer);
800 return;
801 }
802 RtlFreeHeap(RtlGetProcessHeap(), 0, FileName.Buffer);
803
804 /* Create a data section with write access */
805 Status = NtCreateSection(&DataSectionHandle,
806 SECTION_ALL_ACCESS, // DesiredAccess
807 NULL, // ObjectAttributes
808 NULL, // MaximumSize
809 PAGE_READWRITE, // SectionPageProtection
810 SEC_COMMIT, // AllocationAttributes
811 FileHandle);
812 ok_ntstatus(Status, STATUS_SUCCESS);
813 if (!NT_SUCCESS(Status))
814 {
815 skip("Failed to create data section\n");
816 NtClose(FileHandle);
817 return;
818 }
819
820 /* Map the data section as flat mapping */
821 DataBase = NULL;
822 ViewSize = 0;
823 Status = NtMapViewOfSection(DataSectionHandle,
824 NtCurrentProcess(),
825 &DataBase,
826 0,
827 0,
828 NULL,
829 &ViewSize,
830 ViewShare,
831 0,
832 PAGE_READWRITE);
833 ok_ntstatus(Status, STATUS_SUCCESS);
834 //ok(ViewSize == 0x3f95cc48, "ViewSize wrong: 0x%lx\n");
835 if (!NT_SUCCESS(Status))
836 {
837 skip("Failed to map view of data section\n");
838 NtClose(DataSectionHandle);
839 NtClose(FileHandle);
840 return;
841 }
842
843 /* Check the original data */
844 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
845
846 /* Modify the PE header (but do not flush!) */
847 *(ULONG*)DataBase = 0xdeadbabe;
848 ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n");
849
850 /* Modify data in the .data section (but do not flush!) */
851 ok(*(ULONG*)((PUCHAR)DataBase + 0x800) == 0x12345678,
852 "Data in .data section invalid: 0x%lx!\n", *(ULONG*)((PUCHAR)DataBase + 0x800));
853 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x87654321;
854
855 /* Now try to create an image section (should fail) */
856 Status = NtCreateSection(&ImageSectionHandle,
857 SECTION_ALL_ACCESS, // DesiredAccess
858 NULL, // ObjectAttributes
859 NULL, // MaximumSize
860 PAGE_READWRITE, // SectionPageProtection
861 SEC_IMAGE, // AllocationAttributes
862 FileHandle);
863 ok_ntstatus(Status, STATUS_INVALID_IMAGE_NOT_MZ);
864 if (NT_SUCCESS(Status)) NtClose(ImageSectionHandle);
865
866 /* Restore the original header */
867 *(ULONG*)DataBase = 0x00905a4d;
868
869 /* Modify data in the .data section (but do not flush!) */
870 ok_hex(*(ULONG*)((PUCHAR)DataBase + 0x800), 0x87654321);
871 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xdeadbabe;
872
873 /* Try to create an image section again */
874 Status = NtCreateSection(&ImageSectionHandle,
875 SECTION_ALL_ACCESS, // DesiredAccess
876 NULL, // ObjectAttributes
877 NULL, // MaximumSize
878 PAGE_READWRITE, // SectionPageProtection
879 SEC_IMAGE, // AllocationAttributes
880 FileHandle);
881 ok_ntstatus(Status, STATUS_SUCCESS);
882 if (!NT_SUCCESS(Status))
883 {
884 skip("Failed to create image section\n");
885 NtClose(DataSectionHandle);
886 NtClose(FileHandle);
887 return;
888 }
889
890 /* Map the image section */
891 ImageBase = NULL;
892 ViewSize = 0;
893 Status = NtMapViewOfSection(ImageSectionHandle,
894 NtCurrentProcess(),
895 &ImageBase,
896 0, // ZeroBits
897 0, // CommitSize
898 NULL, // SectionOffset
899 &ViewSize,
900 ViewShare,
901 0, // AllocationType
902 PAGE_READONLY);
903#ifdef _M_IX86
904 ok_ntstatus(Status, STATUS_SUCCESS);
905#else
906 ok_ntstatus(Status, STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
907#endif
908 if (!NT_SUCCESS(Status))
909 {
910 skip("Failed to map view of image section\n");
911 NtClose(ImageSectionHandle);
912 NtClose(DataSectionHandle);
913 NtClose(FileHandle);
914 return;
915 }
916
917 /* Check the header */
918 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
919 ok(*(ULONG*)ImageBase == 0x00905a4d, "Header not ok\n");
920
921 /* Check the data section. Either of these can be present! */
922 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
923 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
924 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
925
926 /* Now modify the data again */
927 *(ULONG*)DataBase = 0xdeadbabe;
928 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xf00dada;
929
930 /* Check the data */
931 ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n");
932 ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n");
933 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
934 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
935 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
936
937 /* Flush the view */
938 ViewSize = 0x1000;
939 Status = NtFlushVirtualMemory(NtCurrentProcess(),
940 &DataBase,
941 &ViewSize,
942 &IoStatusBlock);
943 ok_ntstatus(Status, STATUS_SUCCESS);
944
945 /* Check the data again */
946 ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n");
947 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
948 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
949 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
950
951 /* Restore the original header */
952 *(ULONG*)DataBase = 0x00905a4d;
953 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
954
955 /* Close the image mapping */
956 NtUnmapViewOfSection(NtCurrentProcess(), ImageBase);
957 NtClose(ImageSectionHandle);
958
959 /* Create an image section again */
960 Status = NtCreateSection(&ImageSectionHandle,
961 SECTION_ALL_ACCESS, // DesiredAccess
962 NULL, // ObjectAttributes
963 NULL, // MaximumSize
964 PAGE_READWRITE, // SectionPageProtection
965 SEC_IMAGE, // AllocationAttributes
966 FileHandle);
967 ok_ntstatus(Status, STATUS_SUCCESS);
968 if (!NT_SUCCESS(Status))
969 {
970 skip("Failed to create image section\n");
971 NtClose(DataSectionHandle);
972 NtClose(FileHandle);
973 return;
974 }
975
976 /* Map the image section again */
977 ImageBase = NULL;
978 ViewSize = 0;
979 Status = NtMapViewOfSection(ImageSectionHandle,
980 NtCurrentProcess(),
981 &ImageBase,
982 0,
983 0,
984 NULL,
985 &ViewSize,
986 ViewShare,
987 0,
988 PAGE_READONLY);
989#ifdef _M_IX86
990 ok_ntstatus(Status, STATUS_SUCCESS);
991#else
992 ok_ntstatus(Status, STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
993#endif
994 if (!NT_SUCCESS(Status))
995 {
996 skip("Failed to map view of image section\n");
997 NtClose(ImageSectionHandle);
998 NtClose(DataSectionHandle);
999 NtClose(FileHandle);
1000 return;
1001 }
1002
1003 // This one doesn't always work, needs investigation
1004 /* Check the .data section again */
1005 //ok(*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0xf00dada,
1006 // "Data should be synced: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
1007
1008 /* Restore the original data */
1009 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x12345678;
1010
1011 /* Close the data mapping */
1012 NtUnmapViewOfSection(NtCurrentProcess(), DataBase);
1013
1014 NtClose(DataSectionHandle);
1015
1016 /* Try to allocate memory inside the image mapping */
1017 DataBase = (PUCHAR)ImageBase + 0x20000;
1018 ViewSize = 0x1000;
1019 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &DataBase, 0, &ViewSize, MEM_RESERVE, PAGE_NOACCESS);
1020 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1021
1022 /* Cleanup */
1023 NtClose(FileHandle);
1024 NtClose(ImageSectionHandle);
1025 NtUnmapViewOfSection(NtCurrentProcess(), ImageBase);
1026}
NtUnmapViewOfSection
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3498
RTL_NUMBER_OF
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
ok_hex
#define ok_hex(expression, result)
Definition: atltest.h:94
RtlFreeHeap
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:634
wcsrchr
#define wcsrchr
Definition: compat.h:16
GENERIC_READ
#define GENERIC_READ
Definition: compat.h:135
FILE_SHARE_READ
#define FILE_SHARE_READ
Definition: compat.h:136
GetModuleFileNameW
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:600
FileName
struct _FileName FileName
Definition: fatprocs.h:897
FileHandle
_Must_inspect_result_ _In_opt_ PFLT_INSTANCE _Out_ PHANDLE FileHandle
Definition: fltkernel.h:1231
FILE_SYNCHRONOUS_IO_NONALERT
#define FILE_SYNCHRONOUS_IO_NONALERT
Definition: from_kernel.h:31
InitializeObjectAttributes
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:115
RtlDosPathNameToNtPathName_U
NTSYSAPI BOOLEAN NTAPI RtlDosPathNameToNtPathName_U(_In_opt_z_ PCWSTR DosPathName, _Out_ PUNICODE_STRING NtPathName, _Out_opt_ PCWSTR *NtFileNamePart, _Out_opt_ PRTL_RELATIVE_NAME_U DirectoryInfo)
NtOpenFile
NTSYSAPI NTSTATUS NTAPI NtOpenFile(OUT PHANDLE phFile, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG ShareMode, IN ULONG OpenMode)
Definition: file.c:3951
SYNCHRONIZE
#define SYNCHRONIZE
Definition: nt_native.h:61
MEM_RESERVE
#define MEM_RESERVE
Definition: nt_native.h:1317
GENERIC_WRITE
#define GENERIC_WRITE
Definition: nt_native.h:90
PAGE_NOACCESS
#define PAGE_NOACCESS
Definition: nt_native.h:1305
UNICODE_NULL
#define UNICODE_NULL
IoStatusBlock
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:100
NtFlushVirtualMemory
NTSTATUS NTAPI NtFlushVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *BaseAddress, IN OUT PSIZE_T NumberOfBytesToFlush, OUT PIO_STATUS_BLOCK IoStatusBlock)
Definition: virtual.c:4000
NtAllocateVirtualMemory
NTSTATUS NTAPI NtAllocateVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *UBaseAddress, IN ULONG_PTR ZeroBits, IN OUT PSIZE_T URegionSize, IN ULONG AllocationType, IN ULONG Protect)
Definition: virtual.c:4457
STATUS_IMAGE_MACHINE_TYPE_MISMATCH
#define STATUS_IMAGE_MACHINE_TYPE_MISMATCH
Definition: ntstatus.h:203
STATUS_INVALID_IMAGE_NOT_MZ
#define STATUS_INVALID_IMAGE_NOT_MZ
Definition: ntstatus.h:633
wine_dbgstr_wn
#define wine_dbgstr_wn
Definition: testlist.c:2
StringCbCatW
STRSAFEAPI StringCbCatW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:342
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
_OBJECT_ATTRIBUTES
Definition: umtypes.h:184
_UNICODE_STRING
Definition: env_spec_w32.h:368
PUCHAR
unsigned char * PUCHAR
Definition: typedefs.h:53
FileObjectAttributes
_In_ PWDFDEVICE_INIT _In_ PWDF_FILEOBJECT_CONFIG _In_opt_ PWDF_OBJECT_ATTRIBUTES FileObjectAttributes
Definition: wdfdevice.h:3406

Referenced by START_TEST().

◆ Test_ImageSection2()

void Test_ImageSection2 ( void  )

Definition at line 1029 of file NtMapViewOfSection.c.

1030{
1031 UNICODE_STRING FileName;
1032 NTSTATUS Status;
1033 OBJECT_ATTRIBUTES FileObjectAttributes;
1034 IO_STATUS_BLOCK IoStatusBlock;
1035 HANDLE FileHandle, ImageSectionHandle;
1036 PVOID ImageBase, BaseAddress;
1037 SIZE_T ViewSize;
1038 LARGE_INTEGER MaximumSize, SectionOffset;
1039
1040 if (!RtlDosPathNameToNtPathName_U(L"testdata\\nvoglv32.dll",
1041 &FileName,
1042 NULL,
1043 NULL))
1044 {
1045 ok(0, "RtlDosPathNameToNtPathName_U failed\n");
1046 return;
1047 }
1048
1049 InitializeObjectAttributes(&FileObjectAttributes,
1050 &FileName,
1051 0,
1052 NULL,
1053 NULL);
1054
1055 Status = NtOpenFile(&FileHandle,
1056 GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
1057 &FileObjectAttributes,
1058 &IoStatusBlock,
1059 FILE_SHARE_READ,
1060 FILE_SYNCHRONOUS_IO_NONALERT);
1061 RtlFreeHeap(RtlGetProcessHeap(), 0, FileName.Buffer);
1062 ok_ntstatus(Status, STATUS_SUCCESS);
1063 printf("Opened file with handle %p\n", FileHandle);
1064
1065 /* Create a data section with write access */
1066 MaximumSize.QuadPart = 0x20000;
1067 Status = NtCreateSection(&ImageSectionHandle,
1068 SECTION_ALL_ACCESS, // DesiredAccess
1069 NULL, // ObjectAttributes
1070 &MaximumSize, // MaximumSize
1071 PAGE_READWRITE, // SectionPageProtection
1072 SEC_IMAGE, // AllocationAttributes
1073 FileHandle);
1074 ok_ntstatus(Status, STATUS_SUCCESS);
1075
1076 printf("Created image section with handle %p\n", ImageSectionHandle);
1077 //system("PAUSE");
1078
1079 /* Map the image section */
1080 ImageBase = NULL;
1081 ViewSize = 0x0000;
1082 SectionOffset.QuadPart = 0x00000;
1083 Status = NtMapViewOfSection(ImageSectionHandle,
1084 NtCurrentProcess(),
1085 &ImageBase,
1086 0,
1087 0,
1088 &SectionOffset,
1089 &ViewSize,
1090 ViewShare,
1091 0,
1092 PAGE_READWRITE);
1093 ok_ntstatus(Status, STATUS_SUCCESS);
1094
1095 printf("Mapped image section at %p, value in text section: %lx\n",
1096 ImageBase, *((ULONG*)((PCHAR)ImageBase + 0x1196)));
1097 system("PAUSE");
1098
1099 /* Try to allocate a page after the section */
1100 BaseAddress = (PUCHAR)ImageBase + 0x10000;
1101 ViewSize = 0x1000;
1102 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
1103 &BaseAddress,
1104 0,
1105 &ViewSize,
1106 MEM_RESERVE | MEM_COMMIT,
1107 PAGE_READWRITE);
1108 printf("allocation status: %lx\n", Status);
1109 system("PAUSE");
1110
1111}
system
_ACRTIMP int __cdecl system(const char *)
Definition: process.c:1297
printf
#define printf
Definition: freeldr.h:103
BaseAddress
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize _Pre_valid_ PVOID * BaseAddress
Definition: mmfuncs.h:408
MEM_COMMIT
#define MEM_COMMIT
Definition: nt_native.h:1316
PCHAR
char * PCHAR
Definition: typedefs.h:51

◆ Test_PageFileSection()

void Test_PageFileSection ( void  )

Definition at line 20 of file NtMapViewOfSection.c.

21{
22 NTSTATUS Status;
23 HANDLE SectionHandle;
24 LARGE_INTEGER MaximumSize, SectionOffset;
25 PVOID BaseAddress, BaseAddress2;
26 SIZE_T ViewSize;
27 ULONG OldProtect;
28
29 /* Create a page file backed section with SEC_COMMIT */
30 MaximumSize.QuadPart = 0x20000;
31 Status = NtCreateSection(&SectionHandle,
32 SECTION_ALL_ACCESS,
33 NULL,
34 &MaximumSize,
35 PAGE_READWRITE,
36 SEC_COMMIT,
37 NULL);
38 ok_ntstatus(Status, STATUS_SUCCESS);
39 if (!NT_SUCCESS(Status))
40 return;
41
42 /* Try to map a page at an address that is not 64k aligned */
43 BaseAddress = (PVOID)0x30001000;
44 SectionOffset.QuadPart = 0;
45 ViewSize = 0x1000;
46 Status = NtMapViewOfSection(SectionHandle,
47 NtCurrentProcess(),
48 &BaseAddress,
49 0,
50 0,
51 &SectionOffset,
52 &ViewSize,
53 ViewShare,
54 0,
55 PAGE_READWRITE);
56 ok_ntstatus(Status, STATUS_MAPPED_ALIGNMENT);
57
58 /* Try to map a page with execute rights */
59 BaseAddress = (PVOID)0x30000000;
60 SectionOffset.QuadPart = 0;
61 ViewSize = 0x1000;
62 Status = NtMapViewOfSection(SectionHandle,
63 NtCurrentProcess(),
64 &BaseAddress,
65 0,
66 0,
67 &SectionOffset,
68 &ViewSize,
69 ViewShare,
70 0,
71 PAGE_EXECUTE_READWRITE);
72 ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
73
74 /* Try to map 2 pages with MEM_COMMIT */
75 BaseAddress = (PVOID)0x30000000;
76 SectionOffset.QuadPart = 0;
77 ViewSize = 0x2000;
78 Status = NtMapViewOfSection(SectionHandle,
79 NtCurrentProcess(),
80 &BaseAddress,
81 0,
82 PAGE_SIZE,
83 &SectionOffset,
84 &ViewSize,
85 ViewShare,
86 MEM_COMMIT,
87 PAGE_READWRITE);
88 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_9);
89
90 /* Try to map 1 page, with free base address and zero bits compatible with 64k granularity */
91 BaseAddress = NULL;
92 SectionOffset.QuadPart = 0;
93 ViewSize = 0x1000;
94 Status = NtMapViewOfSection(SectionHandle,
95 NtCurrentProcess(),
96 &BaseAddress,
97 10,
98 0,
99 &SectionOffset,
100 &ViewSize,
101 ViewShare,
102 0,
103 PAGE_READWRITE);
104 ok_ntstatus(Status, STATUS_SUCCESS);
105 ok(((ULONG_PTR)BaseAddress & 0x0000FFFF) == 0, "BaseAddress not 64k aligned: %p\n", BaseAddress);
106 ok(((ULONG_PTR)BaseAddress & (ULONG_PTR)0xFFFFFFFFFFC00000ULL) == 0, "Upper bits are not all zero: %p\n", BaseAddress);
107 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
108 ok_ntstatus(Status, STATUS_SUCCESS);
109
110 /* Try to map 1 page, with free base address and zero bits incompatible with 64k granularity.
111 * Note: On 64 bit Windows, ZeroBits != 0 means that the upper (32 + ZeroBits) bits must be zero.
112 * While the documented maximum for ZeroBits is "less than 21", to not break 64 bit alignment,
113 * we need to keep at least 17 bits (i.e., ZeroBits must be less than 16). */
114 BaseAddress = NULL;
115 SectionOffset.QuadPart = 0;
116 ViewSize = 0x1000;
117 Status = NtMapViewOfSection(SectionHandle,
118 NtCurrentProcess(),
119 &BaseAddress,
120 (32 - 16),
121 0,
122 &SectionOffset,
123 &ViewSize,
124 ViewShare,
125 0,
126 PAGE_READWRITE);
127 ok_ntstatus(Status, STATUS_NO_MEMORY);
128
129 /* Try to map 1 page, with base address and zero bits being compatible */
130 BaseAddress = (PVOID)0x30000000;
131 SectionOffset.QuadPart = 0;
132 ViewSize = 0x1000;
133 Status = NtMapViewOfSection(SectionHandle,
134 NtCurrentProcess(),
135 &BaseAddress,
136 2,
137 0,
138 &SectionOffset,
139 &ViewSize,
140 ViewShare,
141 0,
142 PAGE_READWRITE);
143 ok_ntstatus(Status, STATUS_SUCCESS);
144 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
145 ok_ntstatus(Status, STATUS_SUCCESS);
146
147 /* Try to map 1 page, with base address and zero bits being incompatible */
148 BaseAddress = (PVOID)0x30000000;
149 SectionOffset.QuadPart = 0;
150 ViewSize = 0x1000;
151 Status = NtMapViewOfSection(SectionHandle,
152 NtCurrentProcess(),
153 &BaseAddress,
154 3,
155 0,
156 &SectionOffset,
157 &ViewSize,
158 ViewShare,
159 0,
160 PAGE_READWRITE);
161 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_4);
162
163 /* Try using ZeroBits like a bitmask */
164 BaseAddress = NULL;
165 SectionOffset.QuadPart = 0;
166 ViewSize = 0x1000;
167 Status = NtMapViewOfSection(SectionHandle,
168 NtCurrentProcess(),
169 &BaseAddress,
170 0x0FFFFFFF,
171 0,
172 &SectionOffset,
173 &ViewSize,
174 ViewShare,
175 0,
176 PAGE_READWRITE);
177 if (GetNTVersion() >= _WIN32_WINNT_VISTA)
178 {
179 ok_ntstatus(Status, STATUS_SUCCESS);
180 ok(((ULONG_PTR)BaseAddress & 0x0000FFFF) == 0, "BaseAddress not 64k aligned: %p\n", BaseAddress);
181 ok(((ULONG_PTR)BaseAddress & (ULONG_PTR)0xFFFFFFFFF0000000ULL) == 0, "Upper bits are not all zero: %p\n", BaseAddress);
182 }
183 else
184 {
185 ok_ntstatus(Status, STATUS_INVALID_PARAMETER_4);
186 if (!NT_SUCCESS(Status))
187 return;
188 }
189
190 /* Map 2 pages, without MEM_COMMIT */
191 BaseAddress = (PVOID)0x30000000;
192 SectionOffset.QuadPart = 0;
193 ViewSize = 0x2000;
194 Status = NtMapViewOfSection(SectionHandle,
195 NtCurrentProcess(),
196 &BaseAddress,
197 0,
198 0,
199 &SectionOffset,
200 &ViewSize,
201 ViewShare,
202 0,
203 PAGE_READWRITE);
204 ok_ntstatus(Status, STATUS_SUCCESS);
205
206 /* We must be able to access the memory */
207 _SEH2_TRY
208 {
209 *(PULONG)BaseAddress = 1;
210 }
211 _SEH2_EXCEPT(1)
212 {
213 ok(FALSE, "Got an exception\n");
214 }
215 _SEH2_END;
216
217 /* Commit a page in the section */
218 BaseAddress = (PVOID)0x30000000;
219 ViewSize = 0x1000;
220 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
221 &BaseAddress,
222 0,
223 &ViewSize,
224 MEM_COMMIT,
225 PAGE_READWRITE);
226 ok_ntstatus(Status, STATUS_SUCCESS);
227
228 /* Try to decommit a page in the section */
229 Status = NtFreeVirtualMemory(NtCurrentProcess(),
230 &BaseAddress,
231 &ViewSize,
232 MEM_DECOMMIT);
233 ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
234
235 /* Try to commit a range larger than the section */
236 BaseAddress = (PVOID)0x30000000;
237 ViewSize = 0x3000;
238 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
239 &BaseAddress,
240 0,
241 &ViewSize,
242 MEM_COMMIT,
243 PAGE_READWRITE);
244 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
245
246 /* Try to commit a page after the section */
247 BaseAddress = (PVOID)0x30002000;
248 ViewSize = 0x1000;
249 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
250 &BaseAddress,
251 0,
252 &ViewSize,
253 MEM_COMMIT,
254 PAGE_READWRITE);
255 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
256
257 /* Try to allocate a page after the section */
258 BaseAddress = (PVOID)0x30002000;
259 ViewSize = 0x1000;
260 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
261 &BaseAddress,
262 0,
263 &ViewSize,
264 MEM_RESERVE | MEM_COMMIT,
265 PAGE_READWRITE);
266 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
267
268 /* Need to go to next 64k boundary */
269 BaseAddress = (PVOID)0x30010000;
270 ViewSize = 0x1000;
271 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
272 &BaseAddress,
273 0,
274 &ViewSize,
275 MEM_RESERVE | MEM_COMMIT,
276 PAGE_READWRITE);
277 ok_ntstatus(Status, STATUS_SUCCESS);
278 if (!NT_SUCCESS(Status))
279 return;
280
281 /* Free the allocation */
282 BaseAddress = (PVOID)0x30010000;
283 ViewSize = 0x1000;
284 Status = NtFreeVirtualMemory(NtCurrentProcess(),
285 &BaseAddress,
286 &ViewSize,
287 MEM_RELEASE);
288 ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed with Status %lx\n", Status);
289
290 /* Try to release the section mapping with NtFreeVirtualMemory */
291 BaseAddress = (PVOID)0x30000000;
292 ViewSize = 0x1000;
293 Status = NtFreeVirtualMemory(NtCurrentProcess(),
294 &BaseAddress,
295 &ViewSize,
296 MEM_RELEASE);
297 ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
298
299 /* Commit a page in the section */
300 BaseAddress = (PVOID)0x30001000;
301 ViewSize = 0x1000;
302 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
303 &BaseAddress,
304 0,
305 &ViewSize,
306 MEM_COMMIT,
307 PAGE_READWRITE);
308 ok_ntstatus(Status, STATUS_SUCCESS);
309
310 /* Try to decommit the page */
311 BaseAddress = (PVOID)0x30001000;
312 ViewSize = 0x1000;
313 Status = NtFreeVirtualMemory(NtCurrentProcess(),
314 &BaseAddress,
315 &ViewSize,
316 MEM_DECOMMIT);
317 ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
318
319 BaseAddress = UlongToPtr(0x40000000);
320 SectionOffset.QuadPart = 0;
321 ViewSize = 0x1000;
322 Status = NtMapViewOfSection(SectionHandle,
323 NtCurrentProcess(),
324 &BaseAddress,
325 0,
326 0,
327 &SectionOffset,
328 &ViewSize,
329 ViewShare,
330 0,
331 PAGE_READWRITE);
332 ok_ntstatus(Status, STATUS_SUCCESS);
333 if (!NT_SUCCESS(Status))
334 return;
335
336 ok(BaseAddress == UlongToPtr(0x40000000), "Invalid BaseAddress: %p\n", BaseAddress);
337
338 BaseAddress = (PVOID)0x40080000;
339 SectionOffset.QuadPart = 0x10000;
340 ViewSize = 0x1000;
341 Status = NtMapViewOfSection(SectionHandle,
342 NtCurrentProcess(),
343 &BaseAddress,
344 0,
345 0,
346 &SectionOffset,
347 &ViewSize,
348 ViewShare,
349 0,
350 PAGE_READWRITE);
351 ok_ntstatus(Status, STATUS_SUCCESS);
352
353 ok(BaseAddress == (PVOID)0x40080000, "Invalid BaseAddress: %p\n", BaseAddress);
354
355 /* Commit a page in the section */
356 BaseAddress = (PVOID)0x40000000;
357 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
358 &BaseAddress,
359 0,
360 &ViewSize,
361 MEM_COMMIT,
362 PAGE_READWRITE);
363 ok_ntstatus(Status, STATUS_SUCCESS);
364
365 /* Close the mapping */
366 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
367 ok_ntstatus(Status, STATUS_SUCCESS);
368 BaseAddress = (PVOID)0x30000000;
369 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
370 ok_ntstatus(Status, STATUS_SUCCESS);
371 Status = NtClose(SectionHandle);
372 ok_ntstatus(Status, STATUS_SUCCESS);
373
374 /* Create a page file backed section, but only reserved */
375 MaximumSize.QuadPart = 0x20000;
376 Status = NtCreateSection(&SectionHandle,
377 SECTION_ALL_ACCESS,
378 NULL,
379 &MaximumSize,
380 PAGE_READWRITE,
381 SEC_RESERVE,
382 NULL);
383 ok_ntstatus(Status, STATUS_SUCCESS);
384
385 /* Try to map 1 page, passing MEM_RESERVE */
386 BaseAddress = NULL;
387 SectionOffset.QuadPart = 0;
388 ViewSize = PAGE_SIZE;
389 Status = NtMapViewOfSection(SectionHandle,
390 NtCurrentProcess(),
391 &BaseAddress,
392 0,
393 PAGE_SIZE,
394 &SectionOffset,
395 &ViewSize,
396 ViewShare,
397 MEM_RESERVE,
398 PAGE_READWRITE);
399 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_9);
400
401 /* Try to map 1 page using MEM_COMMIT */
402 BaseAddress = NULL;
403 SectionOffset.QuadPart = 0;
404 ViewSize = PAGE_SIZE;
405 Status = NtMapViewOfSection(SectionHandle,
406 NtCurrentProcess(),
407 &BaseAddress,
408 0,
409 PAGE_SIZE,
410 &SectionOffset,
411 &ViewSize,
412 ViewShare,
413 MEM_COMMIT,
414 PAGE_READWRITE);
415 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_9);
416
417 /* Map 2 pages, but commit 1 */
418 BaseAddress = NULL;
419 SectionOffset.QuadPart = 0;
420 ViewSize = 2 * PAGE_SIZE;
421 Status = NtMapViewOfSection(SectionHandle,
422 NtCurrentProcess(),
423 &BaseAddress,
424 0,
425 PAGE_SIZE,
426 &SectionOffset,
427 &ViewSize,
428 ViewShare,
429 0,
430 PAGE_READWRITE);
431 ok_ntstatus(Status, STATUS_SUCCESS);
432
433 /* We must be able to access the 1st page */
434 Status = STATUS_SUCCESS;
435 _SEH2_TRY
436 {
437 *(PUCHAR)BaseAddress = 1;
438 }
439 _SEH2_EXCEPT(1)
440 {
441 Status = _SEH2_GetExceptionCode();
442 }
443 _SEH2_END;
444 ok_ntstatus(Status, STATUS_SUCCESS);
445
446 /* We must not be able to access the 2nd page */
447 Status = STATUS_SUCCESS;
448 _SEH2_TRY
449 {
450 *((PUCHAR)BaseAddress + PAGE_SIZE) = 1;
451 }
452 _SEH2_EXCEPT(1)
453 {
454 Status = _SEH2_GetExceptionCode();
455 }
456 _SEH2_END;
457 ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
458
459 /* Map the 2 pages again into a different memory location */
460 BaseAddress2 = NULL;
461 Status = NtMapViewOfSection(SectionHandle,
462 NtCurrentProcess(),
463 &BaseAddress2,
464 0,
465 0,
466 &SectionOffset,
467 &ViewSize,
468 ViewShare,
469 0,
470 PAGE_READWRITE);
471 ok_ntstatus(Status, STATUS_SUCCESS);
472
473 /* Commit a the 2nd page in the 2nd memory location */
474 BaseAddress2 = (PUCHAR)BaseAddress2 + PAGE_SIZE;
475 ViewSize = PAGE_SIZE;
476 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
477 &BaseAddress2,
478 0,
479 &ViewSize,
480 MEM_COMMIT,
481 PAGE_READONLY);
482 ok_ntstatus(Status, STATUS_SUCCESS);
483
484 /* Try to commit again (the already committed page) */
485 Status = NtAllocateVirtualMemory(NtCurrentProcess(),
486 &BaseAddress2,
487 0,
488 &ViewSize,
489 MEM_COMMIT,
490 PAGE_READONLY);
491 ok_ntstatus(Status, STATUS_SUCCESS);
492
493 /* We must be able to access the memory in the 2nd page of the 1st memory location */
494 Status = STATUS_SUCCESS;
495 _SEH2_TRY
496 {
497 *((PUCHAR)BaseAddress + PAGE_SIZE) = 2;
498 }
499 _SEH2_EXCEPT(1)
500 {
501 Status = _SEH2_GetExceptionCode();
502 }
503 _SEH2_END;
504 ok_ntstatus(Status, STATUS_SUCCESS);
505
506 ok(*(PULONG)BaseAddress2 == 2, "Value in memory was wrong\n");
507
508 /* Close the mapping */
509 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
510 ok_ntstatus(Status, STATUS_SUCCESS);
511 Status = NtUnmapViewOfSection(NtCurrentProcess(), (PUCHAR)BaseAddress2 - PAGE_SIZE);
512 ok_ntstatus(Status, STATUS_SUCCESS);
513 Status = NtClose(SectionHandle);
514 ok_ntstatus(Status, STATUS_SUCCESS);
515
516 /* Try to create a 512 GB page file backed section with committed pages */
517 MaximumSize.QuadPart = 0x8000000000;
518 Status = NtCreateSection(&SectionHandle,
519 SECTION_ALL_ACCESS,
520 NULL,
521 &MaximumSize,
522 PAGE_READWRITE,
523 SEC_COMMIT,
524 NULL);
525 ok_ntstatus(Status, STATUS_COMMITMENT_LIMIT);
526
527 /* Try to create a huge page file backed section with PAGE_NOACCESS protection */
528 MaximumSize.QuadPart = 0x8000000000;
529 Status = NtCreateSection(&SectionHandle,
530 SECTION_ALL_ACCESS,
531 NULL,
532 &MaximumSize,
533 PAGE_NOACCESS,
534 SEC_COMMIT,
535 NULL);
536 ok_ntstatus(Status, STATUS_INVALID_PAGE_PROTECTION);
537
538 /* Try to create a very huge page file backed section, but only reserved */
539 MaximumSize.QuadPart = 0x80000000000;
540 Status = NtCreateSection(&SectionHandle,
541 SECTION_ALL_ACCESS,
542 NULL,
543 &MaximumSize,
544 PAGE_READWRITE,
545 SEC_RESERVE,
546 NULL);
547#ifdef _WIN64
548 ok_ntstatus(Status, STATUS_INSUFFICIENT_RESOURCES);
549#else
550 /* WoW64 returns STATUS_INSUFFICIENT_RESOURCES */
551 ok((Status == STATUS_INSUFFICIENT_RESOURCES) || (Status == STATUS_SECTION_TOO_BIG),
552 "got wrong Status: 0x%lx\n", Status);
553#endif
554
555 /* Try to create a even huger page file backed section, but only reserved */
556 MaximumSize.QuadPart = 0x800000000000;
557 Status = NtCreateSection(&SectionHandle,
558 SECTION_ALL_ACCESS,
559 NULL,
560 &MaximumSize,
561 PAGE_READWRITE,
562 SEC_RESERVE,
563 NULL);
564 ok_ntstatus(Status, STATUS_SECTION_TOO_BIG);
565
566 /* Create a 8 GB page file backed section, but only reserved */
567 MaximumSize.QuadPart = 0x200000000;
568 Status = NtCreateSection(&SectionHandle,
569 SECTION_ALL_ACCESS,
570 NULL,
571 &MaximumSize,
572 PAGE_READWRITE,
573 SEC_RESERVE,
574 NULL);
575 ok_ntstatus(Status, STATUS_SUCCESS);
576
577 /* Pass a too large region size */
578 BaseAddress = NULL;
579 SectionOffset.QuadPart = 0;
580 ViewSize = MAXULONG_PTR;
581 Status = NtMapViewOfSection(SectionHandle,
582 NtCurrentProcess(),
583 &BaseAddress,
584 0,
585 0,
586 &SectionOffset,
587 &ViewSize,
588 ViewShare,
589 0,
590 PAGE_READWRITE);
591#ifdef _WIN64
592 ok_ntstatus(Status, (GetNTVersion() >= _WIN32_WINNT_WIN10) ? STATUS_INVALID_PARAMETER : STATUS_INVALID_PARAMETER_3);
593#else
594 /* WoW64 returns STATUS_INVALID_PARAMETER_4 */
595 if (GetNTVersion() >= _WIN32_WINNT_WIN10)
596 ok(Status == STATUS_INVALID_PARAMETER, "got wrong Status: 0x%lx\n", Status);
597 else
598 ok((Status == STATUS_INVALID_PARAMETER_4) || (Status == STATUS_INVALID_PARAMETER_3),
599 "got wrong Status: 0x%lx\n", Status);
600#endif
601
602 /* Pass 0 region size */
603 BaseAddress = NULL;
604 SectionOffset.QuadPart = 0;
605 ViewSize = 0;
606 Status = NtMapViewOfSection(SectionHandle,
607 NtCurrentProcess(),
608 &BaseAddress,
609 0,
610 0,
611 &SectionOffset,
612 &ViewSize,
613 ViewShare,
614 0,
615 PAGE_READWRITE);
616#ifdef _WIN64
617 ok_ntstatus(Status, STATUS_SUCCESS);
618 ok(ViewSize == 0x200000000, "wrong ViewSize: 0x%Ix\n", ViewSize);
619#else
620 /* WoW64 returns STATUS_NO_MEMORY */
621 ok((Status == STATUS_NO_MEMORY) || (Status == STATUS_INVALID_VIEW_SIZE),
622 "got wrong Status: 0x%lx\n", Status);
623 ok(ViewSize == 0, "wrong ViewSize: 0x%Ix\n", ViewSize);
624#endif
625
626 /* Map with PAGE_NOACCESS */
627 BaseAddress = NULL;
628 SectionOffset.QuadPart = 0;
629 ViewSize = 0x20000000;
630 Status = NtMapViewOfSection(SectionHandle,
631 NtCurrentProcess(),
632 &BaseAddress,
633 0,
634 0,
635 &SectionOffset,
636 &ViewSize,
637 ViewShare,
638 0,
639 PAGE_NOACCESS);
640 ok_ntstatus(Status, STATUS_SUCCESS);
641
642 /* Try to change protection to read/write */
643 ViewSize = 0x1000;
644 OldProtect = -1;
645 BaseAddress2 = BaseAddress;
646 Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READWRITE, &OldProtect);
647 ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
648 // Windows 2003 returns bogus
649 //ok(OldProtect == PAGE_READWRITE, "Wrong protection returned: %u\n", OldProtect);
650
651 /* Test read access */
652 Status = STATUS_SUCCESS;
653 _SEH2_TRY
654 {
655 (void)(*(volatile char*)BaseAddress2);
656 }
657 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
658 {
659 Status = _SEH2_GetExceptionCode();
660 }
661 _SEH2_END;
662 ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
663
664 /* Try to change protection to read/write */
665 ViewSize = 0x1000;
666 OldProtect = -1;
667 BaseAddress2 = BaseAddress;
668 Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READWRITE, &OldProtect);
669 ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
670#ifdef _WIN64
671 ok(OldProtect == PAGE_NOACCESS, "Wrong protection returned: 0x%lx\n", OldProtect);
672#else
673 // Windows 2003 returns bogus
674#endif
675
676 /* Try to change protection to readonly */
677 ViewSize = 0x1000;
678 OldProtect = -1;
679 BaseAddress2 = BaseAddress;
680 Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READONLY, &OldProtect);
681 ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
682#ifdef _WIN64
683 //ok(OldProtect == 0, "Wrong protection returned: 0x%lx\n", OldProtect);
684#else
685 // Windows 2003 returns bogus
686#endif
687
688 /* Commit a page */
689 ViewSize = 0x1000;
690 BaseAddress2 = BaseAddress;
691 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READONLY);
692 ok_ntstatus(Status, STATUS_SUCCESS);
693 ok(BaseAddress2 == BaseAddress, "Invalid base address: %p\n", BaseAddress2);
694
695 /* Commit the page again */
696 ViewSize = 0x1000;
697 BaseAddress2 = BaseAddress;
698 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READONLY);
699 ok_ntstatus(Status, STATUS_SUCCESS);
700 ok(BaseAddress2 == BaseAddress, "Invalid base address: %p\n", BaseAddress2);
701
702 /* Test read access */
703 Status = STATUS_SUCCESS;
704 _SEH2_TRY
705 {
706 (void)(*(volatile char*)BaseAddress2);
707 }
708 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
709 {
710 Status = _SEH2_GetExceptionCode();
711 }
712 _SEH2_END;
713 ok_ntstatus(Status, STATUS_SUCCESS);
714
715 /* Test write access */
716 Status = STATUS_SUCCESS;
717 _SEH2_TRY
718 {
719 *(char*)BaseAddress2 = 1;
720 }
721 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
722 {
723 Status = _SEH2_GetExceptionCode();
724 }
725 _SEH2_END;
726 ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
727
728 /* Update protection to PAGE_READWRITE */
729 ViewSize = 0x1000;
730 BaseAddress2 = BaseAddress;
731 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READWRITE);
732 ok_ntstatus(Status, STATUS_SUCCESS);
733
734 /* Test write access */
735 Status = STATUS_SUCCESS;
736 _SEH2_TRY
737 {
738 *(char*)BaseAddress2 = 1;
739 }
740 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
741 {
742 Status = _SEH2_GetExceptionCode();
743 }
744 _SEH2_END;
745 ok_ntstatus(Status, STATUS_SUCCESS);
746
747 /* Update protection to PAGE_EXECUTE_READWRITE (1 page) */
748 ViewSize = 0x1000;
749 BaseAddress2 = BaseAddress;
750 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
751 ok_ntstatus(Status, STATUS_SUCCESS);
752
753 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
754 ok_ntstatus(Status, STATUS_SUCCESS);
755 Status = NtClose(SectionHandle);
756 ok_ntstatus(Status, STATUS_SUCCESS);
757}
GetNTVersion
#define GetNTVersion()
Definition: apitest.h:17
MAXULONG_PTR
#define MAXULONG_PTR
Definition: basetsd.h:97
STATUS_NO_MEMORY
#define STATUS_NO_MEMORY
Definition: d3dkmdt.h:51
UlongToPtr
#define UlongToPtr(u)
Definition: config.h:106
PAGE_SIZE
#define PAGE_SIZE
Definition: env_spec_w32.h:49
STATUS_ACCESS_VIOLATION
#define STATUS_ACCESS_VIOLATION
Definition: fpEnumPrinters.c:23
EXCEPTION_EXECUTE_HANDLER
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:90
MEM_DECOMMIT
#define MEM_DECOMMIT
Definition: nt_native.h:1318
SEC_RESERVE
#define SEC_RESERVE
Definition: nt_native.h:1326
MEM_RELEASE
#define MEM_RELEASE
Definition: nt_native.h:1319
PAGE_EXECUTE_READWRITE
#define PAGE_EXECUTE_READWRITE
Definition: nt_native.h:1311
NtFreeVirtualMemory
NTSTATUS NTAPI NtFreeVirtualMemory(IN HANDLE ProcessHandle, IN PVOID *UBaseAddress, IN PSIZE_T URegionSize, IN ULONG FreeType)
Definition: virtual.c:5192
NtProtectVirtualMemory
NTSTATUS NTAPI NtProtectVirtualMemory(IN HANDLE ProcessHandle, IN OUT PVOID *UnsafeBaseAddress, IN OUT SIZE_T *UnsafeNumberOfBytesToProtect, IN ULONG NewAccessProtection, OUT PULONG UnsafeOldAccessProtection)
Definition: virtual.c:3076
STATUS_INVALID_VIEW_SIZE
#define STATUS_INVALID_VIEW_SIZE
Definition: ntstatus.h:361
STATUS_MAPPED_ALIGNMENT
#define STATUS_MAPPED_ALIGNMENT
Definition: ntstatus.h:798
STATUS_SECTION_PROTECTION
#define STATUS_SECTION_PROTECTION
Definition: ntstatus.h:408
STATUS_UNABLE_TO_DELETE_SECTION
#define STATUS_UNABLE_TO_DELETE_SECTION
Definition: ntstatus.h:357
STATUS_INVALID_PARAMETER_9
#define STATUS_INVALID_PARAMETER_9
Definition: ntstatus.h:577
STATUS_INVALID_PARAMETER_4
#define STATUS_INVALID_PARAMETER_4
Definition: ntstatus.h:572
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
STATUS_INVALID_PARAMETER_3
#define STATUS_INVALID_PARAMETER_3
Definition: ntstatus.h:571
STATUS_COMMITMENT_LIMIT
#define STATUS_COMMITMENT_LIMIT
Definition: ntstatus.h:631
_SEH2_GetExceptionCode
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:204
_SEH2_EXCEPT
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:104
_SEH2_END
#define _SEH2_END
Definition: pseh2_64.h:194
_SEH2_TRY
#define _SEH2_TRY
Definition: pseh2_64.h:93
_WIN32_WINNT_WIN10
#define _WIN32_WINNT_WIN10
Definition: sdkddkver.h:32
_WIN32_WINNT_VISTA
#define _WIN32_WINNT_VISTA
Definition: sdkddkver.h:25
PULONG
uint32_t * PULONG
Definition: typedefs.h:59
PVOID
void * PVOID
Definition: typedefs.h:50
STATUS_INVALID_PARAMETER
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158

Referenced by START_TEST().

◆ Test_RawSize()

static void Test_RawSize ( ULONG  TestNumber)
static

Definition at line 1764 of file NtMapViewOfSection.c.

1765{
1766 NTSTATUS Status;
1767 WCHAR TempPath[MAX_PATH];
1768 WCHAR FileName[MAX_PATH];
1769 HANDLE Handle;
1770 HANDLE SectionHandle;
1771 LARGE_INTEGER SectionOffset;
1772 PVOID BaseAddress;
1773 SIZE_T ViewSize;
1774 ULONG Written;
1775 ULONG Length;
1776 BOOL Success;
1777
1778 Length = GetTempPathW(MAX_PATH, TempPath);
1779 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1780 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1781 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1782 Handle = CreateFileW(FileName,
1783 FILE_ALL_ACCESS,
1784 0,
1785 NULL,
1786 CREATE_ALWAYS,
1787 0,
1788 NULL);
1789 if (Handle == INVALID_HANDLE_VALUE)
1790 {
1791 skip("Failed to create temp file %ls, error %lu\n", FileName, GetLastError());
1792 return;
1793 }
1794 RawSizeImageFile.nthdrs.OptionalHeader.ImageBase = 0xe400000;
1795 if (TestNumber == 1)
1796 {
1797 /* Just for fun, show that these flags don't matter. */
1798 RawSizeImageFile.text_header.Characteristics &= ~(IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_UNINITIALIZED_DATA);
1799 RawSizeImageFile.data_header.Characteristics &= ~(IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_UNINITIALIZED_DATA);
1800 RawSizeImageFile.zdata_header.Characteristics &= ~(IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_UNINITIALIZED_DATA);
1801 RawSizeImageFile.rsrc_header.Characteristics &= ~(IMAGE_SCN_CNT_CODE | IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_CNT_UNINITIALIZED_DATA);
1802 }
1803 else if (TestNumber == 2)
1804 {
1805 /* SizeOfRawData is too large and will overflow.
1806 * This should cause failure to load the file */
1807 RawSizeImageFile.rsrc_header.SizeOfRawData = (ULONG)-0x200;
1808 }
1809
1810 Success = WriteFile(Handle,
1811 &RawSizeImageFile,
1812 sizeof(RawSizeImageFile),
1813 &Written,
1814 NULL);
1815 ok(Success == TRUE, "WriteFile failed with %lu\n", GetLastError());
1816 ok(Written == sizeof(RawSizeImageFile), "WriteFile wrote %lu bytes\n", Written);
1817
1818 Status = NtCreateSection(&SectionHandle,
1819 SECTION_ALL_ACCESS,
1820 NULL,
1821 NULL,
1822 PAGE_EXECUTE_READWRITE,
1823 SEC_IMAGE,
1824 Handle);
1825 if (TestNumber == 2)
1826 {
1827 /* overflow in SizeOfRawData */
1828 ok_ntstatus(Status, STATUS_INVALID_IMAGE_FORMAT);
1829 }
1830 else
1831 {
1832 ok_ntstatus(Status, STATUS_SUCCESS);
1833 }
1834
1835 if (NT_SUCCESS(Status))
1836 {
1837 /* Map the section with */
1838 BaseAddress = NULL;
1839 SectionOffset.QuadPart = 0;
1840 ViewSize = 0;
1841 Status = NtMapViewOfSection(SectionHandle,
1842 NtCurrentProcess(),
1843 &BaseAddress,
1844 0,
1845 0,
1846 &SectionOffset,
1847 &ViewSize,
1848 ViewShare,
1849 0,
1850 PAGE_READWRITE);
1851 ok_ntstatus(Status, IsX86() ? STATUS_SUCCESS : STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
1852 if (NT_SUCCESS(Status))
1853 {
1854 PUCHAR Bytes = BaseAddress;
1855 struct _RAW_SIZE_IMAGE_FILE *ImageFile = BaseAddress;
1856
1857 /* .text section header is unmodified */
1858 ok_hex(ImageFile->text_header.Misc.VirtualSize, RawSizeImageFile.text_header.Misc.VirtualSize);
1859 ok_hex(ImageFile->text_header.VirtualAddress, RawSizeImageFile.text_header.VirtualAddress);
1860 ok_hex(ImageFile->text_header.SizeOfRawData, RawSizeImageFile.text_header.SizeOfRawData);
1861 ok_hex(ImageFile->text_header.PointerToRawData, RawSizeImageFile.text_header.PointerToRawData);
1862
1863 /* SizeOfRawData = 0 resets PointerToRawData to 0 */
1864 ok_hex(ImageFile->zdata_header.Misc.VirtualSize, RawSizeImageFile.zdata_header.Misc.VirtualSize);
1865 ok_hex(ImageFile->zdata_header.VirtualAddress, RawSizeImageFile.zdata_header.VirtualAddress);
1866 ok_hex(ImageFile->zdata_header.SizeOfRawData, RawSizeImageFile.zdata_header.SizeOfRawData);
1867 ok_hex(ImageFile->zdata_header.PointerToRawData, 0);
1868
1869 /* .bss section is unmodified */
1870 ok_hex(ImageFile->bss_header.SizeOfRawData, 0x600);
1871 ok_hex(ImageFile->bss_header.PointerToRawData, 0);
1872
1873#define TEST_BYTE(n, v) \
1874 StartSeh() \
1875 ok(Bytes[n] == v, "[%lu] Bytes[%u] = 0x%x, expected 0x%x\n", \
1876 TestNumber, n, Bytes[n], v); \
1877 EndSeh(STATUS_SUCCESS);
1878 /* .text section data matches file up to 0x1000 */
1879 TEST_BYTE(0x1000, 0xc3);
1880 TEST_BYTE(0x1001, 0x00);
1881 TEST_BYTE(0x1008, 0x01);
1882 TEST_BYTE(0x1010, 0x02);
1883 TEST_BYTE(0x1fff, 0x0a);
1884
1885 /* .data section data matches file up to 0x1000 */
1886 TEST_BYTE(0x2000, 0x01);
1887 TEST_BYTE(0x2001, 0x23);
1888 TEST_BYTE(0x20ff, 0xee);
1889 TEST_BYTE(0x2100, 0xff);
1890 TEST_BYTE(0x2fff, 0xbb);
1891
1892 /* .zdata section data is all zeroes */
1893 TEST_BYTE(0x3000, 0x00);
1894 TEST_BYTE(0x3001, 0x00);
1895 TEST_BYTE(0x3800, 0x00);
1896 TEST_BYTE(0x3fff, 0x00);
1897
1898 /* .rsrc section data matches file up to VirtualSize 0x200 */
1899 TEST_BYTE(0x4000, 0xff);
1900 TEST_BYTE(0x4100, 0xee);
1901 TEST_BYTE(0x4180, 0xdd);
1902 TEST_BYTE(0x41c0, 0xcc);
1903 TEST_BYTE(0x41e0, 0xbb);
1904 TEST_BYTE(0x41f0, 0xaa);
1905 TEST_BYTE(0x41fe, 0x23);
1906 TEST_BYTE(0x41ff, 0x01);
1907 TEST_BYTE(0x4200, 0x00);
1908 TEST_BYTE(0x4fff, 0x00);
1909#undef TEST_BYTE
1910 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
1911 ok_ntstatus(Status, STATUS_SUCCESS);
1912 }
1913 Status = NtClose(SectionHandle);
1914 ok_ntstatus(Status, STATUS_SUCCESS);
1915 }
1916
1917 CloseHandle(Handle);
1918 DeleteFileW(FileName);
1919}
TEST_BYTE
#define TEST_BYTE(n, v)
IsX86
#define IsX86()
Definition: NtMapViewOfSection.c:16
RawSizeImageFile
static struct _RAW_SIZE_IMAGE_FILE RawSizeImageFile
WriteFile
BOOL WINAPI WriteFile(_In_ HANDLE hFile, _In_reads_bytes_opt_(nNumberOfBytesToWrite) LPCVOID lpBuffer, _In_ DWORD nNumberOfBytesToWrite, _Out_opt_ LPDWORD lpNumberOfBytesWritten, _Inout_opt_ LPOVERLAPPED lpOverlapped)
Definition: rw.c:25
Success
@ Success
Definition: eventcreate.c:712
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
ImageFile
static PWSTR ImageFile
Definition: imagefile.c:10
IMAGE_SCN_CNT_INITIALIZED_DATA
#define IMAGE_SCN_CNT_INITIALIZED_DATA
Definition: ntimage.h:231
IMAGE_SCN_CNT_CODE
#define IMAGE_SCN_CNT_CODE
Definition: ntimage.h:230
IMAGE_SCN_CNT_UNINITIALIZED_DATA
#define IMAGE_SCN_CNT_UNINITIALIZED_DATA
Definition: ntimage.h:232
STATUS_INVALID_IMAGE_FORMAT
#define STATUS_INVALID_IMAGE_FORMAT
Definition: ntstatus.h:453
_RAW_SIZE_IMAGE_FILE
Definition: NtMapViewOfSection.c:1541

Referenced by START_TEST().

◆ Test_SectionContents()

static void Test_SectionContents ( BOOL  Relocate)
static

Definition at line 1414 of file NtMapViewOfSection.c.

1415{
1416 NTSTATUS Status;
1417 WCHAR TempPath[MAX_PATH];
1418 WCHAR FileName[MAX_PATH];
1419 HANDLE Handle;
1420 HANDLE SectionHandle;
1421 LARGE_INTEGER SectionOffset;
1422 PVOID BaseAddress;
1423 SIZE_T ViewSize;
1424 ULONG Written;
1425 ULONG Length;
1426 BOOL Success;
1427
1428 Length = GetTempPathW(MAX_PATH, TempPath);
1429 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1430 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1431 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1432 Handle = CreateFileW(FileName,
1433 FILE_ALL_ACCESS,
1434 0,
1435 NULL,
1436 CREATE_ALWAYS,
1437 0,
1438 NULL);
1439 if (Handle == INVALID_HANDLE_VALUE)
1440 {
1441 skip("Failed to create temp file %ls, error %lu\n", FileName, GetLastError());
1442 return;
1443 }
1444 if (Relocate)
1445 {
1446#ifdef _WIN64
1447 ok((ULONG_PTR)GetModuleHandle(NULL) <= 0x00007FFFFFFFFFFF, "Module at %p\n", GetModuleHandle(NULL));
1448#else
1449 ok((ULONG_PTR)GetModuleHandle(NULL) <= 0x80000000, "Module at %p\n", GetModuleHandle(NULL));
1450#endif
1451 SectionContentsImageFile.nthdrs.OptionalHeader.ImageBase = (ULONG_PTR)GetModuleHandle(NULL);
1452 }
1453 else
1454 {
1455 SectionContentsImageFile.nthdrs.OptionalHeader.ImageBase = 0xe400000;
1456 }
1457
1458 Success = WriteFile(Handle,
1459 &SectionContentsImageFile,
1460 sizeof(SectionContentsImageFile),
1461 &Written,
1462 NULL);
1463 ok(Success == TRUE, "WriteFile failed with %lu\n", GetLastError());
1464 ok(Written == sizeof(SectionContentsImageFile), "WriteFile wrote %lu bytes\n", Written);
1465
1466 Status = NtCreateSection(&SectionHandle,
1467 SECTION_ALL_ACCESS,
1468 NULL,
1469 NULL,
1470 PAGE_EXECUTE_READWRITE,
1471 SEC_IMAGE,
1472 Handle);
1473 ok_ntstatus(Status, STATUS_SUCCESS);
1474
1475 if (NT_SUCCESS(Status))
1476 {
1477 /* Map the section with */
1478 BaseAddress = NULL;
1479 SectionOffset.QuadPart = 0;
1480 ViewSize = 0;
1481 Status = NtMapViewOfSection(SectionHandle,
1482 NtCurrentProcess(),
1483 &BaseAddress,
1484 0,
1485 0,
1486 &SectionOffset,
1487 &ViewSize,
1488 ViewShare,
1489 0,
1490 PAGE_READWRITE);
1491 if (Relocate)
1492 ok_ntstatus(Status, STATUS_IMAGE_NOT_AT_BASE);
1493 else
1494 ok_ntstatus(Status, STATUS_SUCCESS);
1495 if (NT_SUCCESS(Status))
1496 {
1497 PUCHAR Bytes = BaseAddress;
1498#define TEST_BYTE(n, v) StartSeh() ok_hex(Bytes[n], v); EndSeh(STATUS_SUCCESS);
1499#define TEST_WRITE(n) StartSeh() *(volatile UCHAR *)&Bytes[n] = Bytes[n]; EndSeh(STATUS_SUCCESS);
1500#define TEST_NOWRITE(n) StartSeh() *(volatile UCHAR *)&Bytes[n] = Bytes[n]; EndSeh(STATUS_ACCESS_VIOLATION);
1501 TEST_NOWRITE(0x2000);
1502 TEST_BYTE(0x2000, 0xc3);
1503 TEST_BYTE(0x2001, 0x00);
1504 TEST_NOWRITE(0x4000);
1505 TEST_BYTE(0x4000, 0x01);
1506 TEST_BYTE(0x4001, 0x23);
1507 TEST_BYTE(0x4007, 0xef);
1508 TEST_BYTE(0x4008, 0xaa);
1509 TEST_BYTE(0x4010, 0xbb);
1510 TEST_BYTE(0x4020, 0xcc);
1511 TEST_BYTE(0x4040, 0xdd);
1512 TEST_BYTE(0x4080, 0xee);
1513 TEST_BYTE(0x40c0, 0xff);
1514 TEST_BYTE(0x40ff, 0xff);
1515 TEST_BYTE(0x4100, 0x00);
1516 TEST_BYTE(0x41ff, 0x00);
1517 TEST_NOWRITE(0x6000);
1518 TEST_BYTE(0x6000, 0xee);
1519 TEST_BYTE(0x60ff, 0x55);
1520 TEST_BYTE(0x6100, 0xee);
1521 TEST_BYTE(0x63ff, 0xdd);
1522 TEST_BYTE(0x6400, 0x00);
1523 TEST_WRITE(0x8000);
1524 TEST_BYTE(0x8000, 0x11);
1525 TEST_BYTE(0x8400, 0x33);
1526#undef TEST_BYTE
1527#undef TEST_WRITE
1528#undef TEST_NOWRITE
1529 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
1530 ok_ntstatus(Status, STATUS_SUCCESS);
1531 }
1532 Status = NtClose(SectionHandle);
1533 ok_ntstatus(Status, STATUS_SUCCESS);
1534 }
1535
1536 CloseHandle(Handle);
1537 DeleteFileW(FileName);
1538}
TEST_WRITE
#define TEST_WRITE(n)
TEST_NOWRITE
#define TEST_NOWRITE(n)
SectionContentsImageFile
static struct _SECTION_CONTENTS_IMAGE_FILE SectionContentsImageFile
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
STATUS_IMAGE_NOT_AT_BASE
#define STATUS_IMAGE_NOT_AT_BASE
Definition: ntstatus.h:192
GetModuleHandle
#define GetModuleHandle
Definition: winbase.h:3548

Referenced by START_TEST().

◆ Test_Truncate()

static void Test_Truncate ( VOID  )
static

Definition at line 1970 of file NtMapViewOfSection.c.

1971{
1972 WCHAR TempPath[MAX_PATH];
1973 WCHAR FileName[MAX_PATH];
1974 NTSTATUS Status;
1975 SIZE_T ViewSize = 0;
1976 HANDLE Handle;
1977 HANDLE SectionHandle;
1978
1979 SIZE_T Length;
1980 BOOL Success;
1981 DWORD Written, Error;
1982 VOID* BaseAddress;
1983
1984 Length = GetTempPathW(MAX_PATH, TempPath);
1985 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1986 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1987 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1988 Handle = CreateFileW(FileName, FILE_ALL_ACCESS, 0, NULL, CREATE_ALWAYS, 0, NULL);
1989
1990 Success = WriteFile(Handle, "TESTDATA", 8, &Written, NULL);
1991 ok(Success == TRUE, "WriteFile failed with %lu\n", GetLastError());
1992 ok(Written == 8, "WriteFile wrote %lu bytes\n", Written);
1993
1994 Written = SetFilePointer(Handle, 6, NULL, FILE_BEGIN);
1995 ok(Written == 6, "SetFilePointer returned %lu bytes\n", Written);
1996 Success = SetEndOfFile(Handle);
1997 ok(Success == TRUE, "SetEndOfFile failed with %lu\n", GetLastError());
1998
1999 Status = NtCreateSection(&SectionHandle,
2000 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
2001 0, 0, PAGE_READONLY, SEC_COMMIT, Handle);
2002 ok_ntstatus(Status, STATUS_SUCCESS);
2003 BaseAddress = NULL;
2004 ViewSize = 0;
2005 Status = NtMapViewOfSection(SectionHandle, NtCurrentProcess(), &BaseAddress, 0,
2006 0, 0, &ViewSize, ViewShare, 0, PAGE_READONLY);
2007 ok_ntstatus(Status, STATUS_SUCCESS);
2008
2009 if (BaseAddress)
2010 {
2011 // First we test data that was truncated even before the file mapping was opened
2012 Length = strlen((char*)BaseAddress);
2013 ok(Length == 6, "Old data was not properly erased! (Length=%lu)\n", Length);
2014 }
2015
2016 // Now we truncate the file on disk some more
2017 Written = SetFilePointer(Handle, 4, NULL, FILE_BEGIN);
2018 ok(Written == 4, "SetFilePointer returned %lu bytes\n", Written);
2019 Success = SetEndOfFile(Handle);
2020 Error = GetLastError();
2021 ok(Success == FALSE, "SetEndOfFile succeeded\n");
2022 ok(Error == ERROR_USER_MAPPED_FILE, "SetEndOfFile did not set error to ERROR_USER_MAPPED_FILE (%lu)\n", Error);
2023
2024 if (BaseAddress)
2025 {
2026 Length = strlen((char*)BaseAddress);
2027 ok(Length == 6, "Length should not have changed! (Length=%lu)\n", Length);
2028 }
2029
2030 // Unmap and set the end shorter.
2031 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
2032 ok_ntstatus(Status, STATUS_SUCCESS);
2033 Success = CloseHandle(SectionHandle);
2034 ok(Success == TRUE, "CloseHandle failed with %lu\n", GetLastError());
2035
2036 Written = SetFilePointer(Handle, 4, NULL, FILE_BEGIN);
2037 ok(Written == 4, "SetFilePointer returned %lu bytes\n", Written);
2038 Success = SetEndOfFile(Handle);
2039 ok(Success == TRUE, "SetEndOfFile failed with %lu\n", GetLastError());
2040
2041 Status = NtCreateSection(&SectionHandle,
2042 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
2043 0, 0, PAGE_READONLY, SEC_COMMIT, Handle);
2044 ok_ntstatus(Status, STATUS_SUCCESS);
2045 BaseAddress = NULL;
2046 ViewSize = 0;
2047 Status = NtMapViewOfSection(SectionHandle, NtCurrentProcess(), &BaseAddress, 0,
2048 0, 0, &ViewSize, ViewShare, 0, PAGE_READONLY);
2049 ok_ntstatus(Status, STATUS_SUCCESS);
2050
2051 // CLEANUP
2052 Status = NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
2053 ok_ntstatus(Status, STATUS_SUCCESS);
2054 Success = CloseHandle(SectionHandle);
2055 ok(Success == TRUE, "CloseHandle failed with %lu\n", GetLastError());
2056 Success = CloseHandle(Handle);
2057 ok(Success == TRUE, "CloseHandle failed with %lu\n", GetLastError());
2058
2059 Success = DeleteFileW(FileName);
2060 ok(Success == TRUE, "DeleteFileW failed with %lu\n", GetLastError());
2061}
Error
BOOL Error
Definition: chkdsk.c:66
FILE_BEGIN
#define FILE_BEGIN
Definition: compat.h:761
SetFilePointer
#define SetFilePointer
Definition: compat.h:743
SetEndOfFile
BOOL WINAPI SetEndOfFile(HANDLE hFile)
Definition: fileinfo.c:989
strlen
_ACRTIMP size_t __cdecl strlen(const char *)
Definition: string.c:1597
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
ERROR_USER_MAPPED_FILE
#define ERROR_USER_MAPPED_FILE
Definition: winerror.h:1056

Referenced by START_TEST().

Variable Documentation

◆ RawSizeImageFile

struct _RAW_SIZE_IMAGE_FILE RawSizeImageFile
static

Referenced by Test_RawSize().

◆ SectionContentsImageFile

struct _SECTION_CONTENTS_IMAGE_FILE SectionContentsImageFile
static

Referenced by Test_SectionContents().