ReactOS 0.4.16-dev-2224-g3637fd8
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 1195 of file NtMapViewOfSection.c.

◆ BYTES128

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

Definition at line 1192 of file NtMapViewOfSection.c.

◆ BYTES16

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

Definition at line 1189 of file NtMapViewOfSection.c.

◆ BYTES256

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

Definition at line 1193 of file NtMapViewOfSection.c.

◆ BYTES32

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

Definition at line 1190 of file NtMapViewOfSection.c.

◆ BYTES4

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

Definition at line 1187 of file NtMapViewOfSection.c.

◆ BYTES512

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

Definition at line 1194 of file NtMapViewOfSection.c.

◆ BYTES64

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

Definition at line 1191 of file NtMapViewOfSection.c.

◆ BYTES8

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

Definition at line 1188 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 2060 of file NtMapViewOfSection.c.

2061{
2062 Test_PageFileSection();
2063 Test_ImageSection();
2064 Test_BasedSection();
2065 Test_SectionContents(FALSE);
2066 Test_SectionContents(TRUE);
2067 Test_RawSize(0);
2068 Test_RawSize(1);
2069 Test_RawSize(2);
2070 Test_EmptyFile();
2071 Test_Truncate();
2072}
Test_SectionContents
static void Test_SectionContents(BOOL Relocate)
Definition: NtMapViewOfSection.c:1411
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:1919
Test_BasedSection
void Test_BasedSection(void)
Definition: NtMapViewOfSection.c:1112
Test_RawSize
static void Test_RawSize(ULONG TestNumber)
Definition: NtMapViewOfSection.c:1761
Test_Truncate
static void Test_Truncate(VOID)
Definition: NtMapViewOfSection.c:1967
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117

◆ Test_BasedSection()

void Test_BasedSection ( void  )

Definition at line 1112 of file NtMapViewOfSection.c.

1113{
1114 NTSTATUS Status;
1115 HANDLE SectionHandle1, SectionHandle2;
1116 LARGE_INTEGER MaximumSize, SectionOffset;
1117 PVOID BaseAddress1, BaseAddress2;
1118 SIZE_T ViewSize;
1119
1120 /* Create a based section with SEC_COMMIT */
1121 MaximumSize.QuadPart = 0x1000;
1122 Status = NtCreateSection(&SectionHandle1,
1123 SECTION_ALL_ACCESS,
1124 NULL,
1125 &MaximumSize,
1126 PAGE_READWRITE,
1127 SEC_COMMIT | SEC_BASED,
1128 NULL);
1129 ok_ntstatus(Status, STATUS_SUCCESS);
1130
1131 /* Map the 1st section */
1132 BaseAddress1 = NULL;
1133 SectionOffset.QuadPart = 0;
1134 ViewSize = 0;
1135 Status = NtMapViewOfSection(SectionHandle1,
1136 NtCurrentProcess(),
1137 &BaseAddress1,
1138 0,
1139 0,
1140 &SectionOffset,
1141 &ViewSize,
1142 ViewShare,
1143 0,
1144 PAGE_READWRITE);
1145#if 0 // WOW64?
1146 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1147#else
1148 ok_ntstatus(Status, STATUS_SUCCESS);
1149#endif
1150
1151 /* Create a 2nd based section with SEC_COMMIT */
1152 MaximumSize.QuadPart = 0x1000;
1153 Status = NtCreateSection(&SectionHandle2,
1154 SECTION_ALL_ACCESS,
1155 NULL,
1156 &MaximumSize,
1157 PAGE_READWRITE,
1158 SEC_COMMIT | SEC_BASED,
1159 NULL);
1160 ok_ntstatus(Status, STATUS_SUCCESS);//
1161
1162 /* Map the 2nd section */
1163 BaseAddress2 = NULL;
1164 SectionOffset.QuadPart = 0;
1165 ViewSize = 0;
1166 Status = NtMapViewOfSection(SectionHandle2,
1167 NtCurrentProcess(),
1168 &BaseAddress2,
1169 0,
1170 0,
1171 &SectionOffset,
1172 &ViewSize,
1173 ViewShare,
1174 0,
1175 PAGE_READWRITE);
1176#if 0 // WOW64?
1177 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1178#else
1179 ok_ntstatus(Status, STATUS_SUCCESS);
1180 ok((ULONG_PTR)BaseAddress2 < (ULONG_PTR)BaseAddress1,
1181 "Invalid addresses: BaseAddress1=%p, BaseAddress2=%p\n", BaseAddress1, BaseAddress2);
1182 ok(((ULONG_PTR)BaseAddress1 - (ULONG_PTR)BaseAddress2) == 0x10000,
1183 "Invalid addresses: BaseAddress1=%p, BaseAddress2=%p\n", BaseAddress1, BaseAddress2);
1184#endif
1185}
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:3076
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_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:25
MaximumSize
_In_ ACCESS_MASK _In_opt_ POBJECT_ATTRIBUTES _In_opt_ PLARGE_INTEGER MaximumSize
Definition: mmfuncs.h:362
SectionOffset
_In_ HANDLE _Outptr_result_bytebuffer_ ViewSize PVOID _In_ ULONG_PTR _In_ SIZE_T _Inout_opt_ PLARGE_INTEGER SectionOffset
Definition: mmfuncs.h:407
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
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:1357
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 1919 of file NtMapViewOfSection.c.

1920{
1921 NTSTATUS Status;
1922 WCHAR TempPath[MAX_PATH];
1923 WCHAR FileName[MAX_PATH];
1924 HANDLE Handle;
1925 HANDLE SectionHandle;
1926 ULONG Length;
1927
1928 Length = GetTempPathW(MAX_PATH, TempPath);
1929 ok(Length != 0, "GetTempPathW failed with %lu\n", GetLastError());
1930 Length = GetTempFileNameW(TempPath, L"nta", 0, FileName);
1931 ok(Length != 0, "GetTempFileNameW failed with %lu\n", GetLastError());
1932 Handle = CreateFileW(FileName,
1933 FILE_ALL_ACCESS,
1934 0,
1935 NULL,
1936 CREATE_ALWAYS,
1937 0,
1938 NULL);
1939 if (Handle == INVALID_HANDLE_VALUE)
1940 {
1941 skip("Failed to create temp file %ls, error %lu\n", FileName, GetLastError());
1942 return;
1943 }
1944
1945 Status = NtCreateSection(&SectionHandle,
1946 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1947 0, 0, PAGE_READONLY, SEC_COMMIT, Handle);
1948 ok_ntstatus(Status, STATUS_MAPPED_FILE_SIZE_ZERO);
1949
1950 if (NT_SUCCESS(Status))
1951 NtClose(SectionHandle);
1952
1953 Status = NtCreateSection(&SectionHandle,
1954 STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ,
1955 0, 0, PAGE_READONLY, SEC_IMAGE, Handle);
1956 ok_ntstatus(Status, STATUS_INVALID_FILE_FOR_SECTION);
1957
1958 if (NT_SUCCESS(Status))
1959 NtClose(SectionHandle);
1960
1961 CloseHandle(Handle);
1962 DeleteFileW(FileName);
1963}
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:2080
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:3402
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
_FileName
Definition: filecomp.c:348
ULONG
uint32_t ULONG
Definition: typedefs.h:59
GetLastError
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

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 return;
800 }
801
802 /* Create a data section with write access */
803 Status = NtCreateSection(&DataSectionHandle,
804 SECTION_ALL_ACCESS, // DesiredAccess
805 NULL, // ObjectAttributes
806 NULL, // MaximumSize
807 PAGE_READWRITE, // SectionPageProtection
808 SEC_COMMIT, // AllocationAttributes
809 FileHandle);
810 ok_ntstatus(Status, STATUS_SUCCESS);
811 if (!NT_SUCCESS(Status))
812 {
813 skip("Failed to create data section\n");
814 NtClose(FileHandle);
815 return;
816 }
817
818 /* Map the data section as flat mapping */
819 DataBase = NULL;
820 ViewSize = 0;
821 Status = NtMapViewOfSection(DataSectionHandle,
822 NtCurrentProcess(),
823 &DataBase,
824 0,
825 0,
826 NULL,
827 &ViewSize,
828 ViewShare,
829 0,
830 PAGE_READWRITE);
831 ok_ntstatus(Status, STATUS_SUCCESS);
832 //ok(ViewSize == 0x3f95cc48, "ViewSize wrong: 0x%lx\n");
833 if (!NT_SUCCESS(Status))
834 {
835 skip("Failed to map view of data section\n");
836 NtClose(DataSectionHandle);
837 NtClose(FileHandle);
838 return;
839 }
840
841 /* Check the original data */
842 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
843
844 /* Modify the PE header (but do not flush!) */
845 *(ULONG*)DataBase = 0xdeadbabe;
846 ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n");
847
848 /* Modify data in the .data section (but do not flush!) */
849 ok(*(ULONG*)((PUCHAR)DataBase + 0x800) == 0x12345678,
850 "Data in .data section invalid: 0x%lx!\n", *(ULONG*)((PUCHAR)DataBase + 0x800));
851 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x87654321;
852
853 /* Now try to create an image section (should fail) */
854 Status = NtCreateSection(&ImageSectionHandle,
855 SECTION_ALL_ACCESS, // DesiredAccess
856 NULL, // ObjectAttributes
857 NULL, // MaximumSize
858 PAGE_READWRITE, // SectionPageProtection
859 SEC_IMAGE, // AllocationAttributes
860 FileHandle);
861 ok_ntstatus(Status, STATUS_INVALID_IMAGE_NOT_MZ);
862 if (NT_SUCCESS(Status)) NtClose(ImageSectionHandle);
863
864 /* Restore the original header */
865 *(ULONG*)DataBase = 0x00905a4d;
866
867 /* Modify data in the .data section (but do not flush!) */
868 ok_hex(*(ULONG*)((PUCHAR)DataBase + 0x800), 0x87654321);
869 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xdeadbabe;
870
871 /* Try to create an image section again */
872 Status = NtCreateSection(&ImageSectionHandle,
873 SECTION_ALL_ACCESS, // DesiredAccess
874 NULL, // ObjectAttributes
875 NULL, // MaximumSize
876 PAGE_READWRITE, // SectionPageProtection
877 SEC_IMAGE, // AllocationAttributes
878 FileHandle);
879 ok_ntstatus(Status, STATUS_SUCCESS);
880 if (!NT_SUCCESS(Status))
881 {
882 skip("Failed to create image section\n");
883 NtClose(DataSectionHandle);
884 NtClose(FileHandle);
885 return;
886 }
887
888 /* Map the image section */
889 ImageBase = NULL;
890 ViewSize = 0;
891 Status = NtMapViewOfSection(ImageSectionHandle,
892 NtCurrentProcess(),
893 &ImageBase,
894 0, // ZeroBits
895 0, // CommitSize
896 NULL, // SectionOffset
897 &ViewSize,
898 ViewShare,
899 0, // AllocationType
900 PAGE_READONLY);
901#ifdef _M_IX86
902 ok_ntstatus(Status, STATUS_SUCCESS);
903#else
904 ok_ntstatus(Status, STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
905#endif
906 if (!NT_SUCCESS(Status))
907 {
908 skip("Failed to map view of image section\n");
909 NtClose(ImageSectionHandle);
910 NtClose(DataSectionHandle);
911 NtClose(FileHandle);
912 return;
913 }
914
915 /* Check the header */
916 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
917 ok(*(ULONG*)ImageBase == 0x00905a4d, "Header not ok\n");
918
919 /* Check the data section. Either of these can be present! */
920 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
921 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
922 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
923
924 /* Now modify the data again */
925 *(ULONG*)DataBase = 0xdeadbabe;
926 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xf00dada;
927
928 /* Check the data */
929 ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n");
930 ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n");
931 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
932 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
933 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
934
935 /* Flush the view */
936 ViewSize = 0x1000;
937 Status = NtFlushVirtualMemory(NtCurrentProcess(),
938 &DataBase,
939 &ViewSize,
940 &IoStatusBlock);
941 ok_ntstatus(Status, STATUS_SUCCESS);
942
943 /* Check the data again */
944 ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n");
945 ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
946 (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
947 "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
948
949 /* Restore the original header */
950 *(ULONG*)DataBase = 0x00905a4d;
951 ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
952
953 /* Close the image mapping */
954 NtUnmapViewOfSection(NtCurrentProcess(), ImageBase);
955 NtClose(ImageSectionHandle);
956
957 /* Create an image section again */
958 Status = NtCreateSection(&ImageSectionHandle,
959 SECTION_ALL_ACCESS, // DesiredAccess
960 NULL, // ObjectAttributes
961 NULL, // MaximumSize
962 PAGE_READWRITE, // SectionPageProtection
963 SEC_IMAGE, // AllocationAttributes
964 FileHandle);
965 ok_ntstatus(Status, STATUS_SUCCESS);
966 if (!NT_SUCCESS(Status))
967 {
968 skip("Failed to create image section\n");
969 NtClose(DataSectionHandle);
970 NtClose(FileHandle);
971 return;
972 }
973
974 /* Map the image section again */
975 ImageBase = NULL;
976 ViewSize = 0;
977 Status = NtMapViewOfSection(ImageSectionHandle,
978 NtCurrentProcess(),
979 &ImageBase,
980 0,
981 0,
982 NULL,
983 &ViewSize,
984 ViewShare,
985 0,
986 PAGE_READONLY);
987#ifdef _M_IX86
988 ok_ntstatus(Status, STATUS_SUCCESS);
989#else
990 ok_ntstatus(Status, STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
991#endif
992 if (!NT_SUCCESS(Status))
993 {
994 skip("Failed to map view of image section\n");
995 NtClose(ImageSectionHandle);
996 NtClose(DataSectionHandle);
997 NtClose(FileHandle);
998 return;
999 }
1000
1001 // This one doesn't always work, needs investigation
1002 /* Check the .data section again */
1003 //ok(*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0xf00dada,
1004 // "Data should be synced: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
1005
1006 /* Restore the original data */
1007 *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x12345678;
1008
1009 /* Close the data mapping */
1010 NtUnmapViewOfSection(NtCurrentProcess(), DataBase);
1011
1012 NtClose(DataSectionHandle);
1013
1014 /* Try to allocate memory inside the image mapping */
1015 DataBase = (PUCHAR)ImageBase + 0x20000;
1016 ViewSize = 0x1000;
1017 Status = NtAllocateVirtualMemory(NtCurrentProcess(), &DataBase, 0, &ViewSize, MEM_RESERVE, PAGE_NOACCESS);
1018 ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1019
1020 /* Cleanup */
1021 NtClose(FileHandle);
1022 NtClose(ImageSectionHandle);
1023 NtUnmapViewOfSection(NtCurrentProcess(), ImageBase);
1024}
NtUnmapViewOfSection
NTSTATUS NTAPI NtUnmapViewOfSection(IN HANDLE ProcessHandle, IN PVOID BaseAddress)
Definition: section.c:3483
RTL_NUMBER_OF
#define RTL_NUMBER_OF(x)
Definition: RtlRegistry.c:12
ok_hex
#define ok_hex(expression, result)
Definition: atltest.h:94
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:106
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:3953
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:75
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 1027 of file NtMapViewOfSection.c.

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

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

Referenced by START_TEST().

◆ Test_SectionContents()

static void Test_SectionContents ( BOOL  Relocate)
static

Definition at line 1411 of file NtMapViewOfSection.c.

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

Referenced by START_TEST().

◆ Test_Truncate()

static void Test_Truncate ( VOID  )
static

Definition at line 1967 of file NtMapViewOfSection.c.

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