rostests/apitests/ntdll/NtMapViewOfSection.c

   1
   2 #include <apitest.h>
   3
   4 #define WIN32_NO_STATUS
   5 #include <ndk/ntndk.h>
   6
   7 NTSYSAPI
   8 NTSTATUS
   9 NTAPI
  10 NtMapViewOfSection(
  11     HANDLE SectionHandle,
  12         HANDLE ProcessHandle,
  13         PVOID *BaseAddress,
  14         ULONG_PTR ZeroBits,
  15         SIZE_T CommitSize,
  16         PLARGE_INTEGER SectionOffset,
  17         PSIZE_T ViewSize,
  18         SECTION_INHERIT InheritDisposition,
  19         ULONG AllocationType,
  20         ULONG Protect);
  21
  22 void
  23 Test_PageFileSection(void)
  24 {
  25     NTSTATUS Status;
  26     HANDLE SectionHandle;
  27     LARGE_INTEGER MaximumSize, SectionOffset;
  28     PVOID BaseAddress, BaseAddress2;
  29     SIZE_T ViewSize;
  30     ULONG OldProtect;
  31
  32     /* Create a page file backed section with SEC_COMMIT */
  33     MaximumSize.QuadPart = 0x20000;
  34     Status = NtCreateSection(&SectionHandle,
  35                              SECTION_ALL_ACCESS,
  36                              NULL,
  37                              &MaximumSize,
  38                              PAGE_READWRITE,
  39                              SEC_COMMIT,
  40                              NULL);
  41     ok_ntstatus(Status, STATUS_SUCCESS);
  42     if (!NT_SUCCESS(Status))
  43         return;
  44
  45     /* Try to map a page at an address that is not 64k aligned */
  46     BaseAddress = (PVOID)0x30001000;
  47     SectionOffset.QuadPart = 0;
  48     ViewSize = 0x1000;
  49     Status = NtMapViewOfSection(SectionHandle,
  50                                 NtCurrentProcess(),
  51                                 &BaseAddress,
  52                                 0,
  53                                 0,
  54                                 &SectionOffset,
  55                                 &ViewSize,
  56                                 ViewShare,
  57                                 0,
  58                                 PAGE_READWRITE);
  59     ok_ntstatus(Status, STATUS_MAPPED_ALIGNMENT);
  60
  61     /* Try to map a page with execute rights */
  62     BaseAddress = (PVOID)0x30000000;
  63     SectionOffset.QuadPart = 0;
  64     ViewSize = 0x1000;
  65     Status = NtMapViewOfSection(SectionHandle,
  66                                 NtCurrentProcess(),
  67                                 &BaseAddress,
  68                                 0,
  69                                 0,
  70                                 &SectionOffset,
  71                                 &ViewSize,
  72                                 ViewShare,
  73                                 0,
  74                                 PAGE_EXECUTE_READWRITE);
  75     ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
  76
  77     /* Try to map 2 pages with MEM_COMMIT */
  78     BaseAddress = (PVOID)0x30000000;
  79     SectionOffset.QuadPart = 0;
  80     ViewSize = 0x2000;
  81     Status = NtMapViewOfSection(SectionHandle,
  82                                 NtCurrentProcess(),
  83                                 &BaseAddress,
  84                                 0,
  85                                 PAGE_SIZE,
  86                                 &SectionOffset,
  87                                 &ViewSize,
  88                                 ViewShare,
  89                                 MEM_COMMIT,
  90                                 PAGE_READWRITE);
  91     ok_ntstatus(Status, STATUS_INVALID_PARAMETER_9);
  92
  93     /* Map 2 pages, without MEM_COMMIT */
  94     BaseAddress = (PVOID)0x30000000;
  95     SectionOffset.QuadPart = 0;
  96     ViewSize = 0x2000;
  97     Status = NtMapViewOfSection(SectionHandle,
  98                                 NtCurrentProcess(),
  99                                 &BaseAddress,
 100                                 0,
 101                                 0,
 102                                 &SectionOffset,
 103                                 &ViewSize,
 104                                 ViewShare,
 105                                 0,
 106                                 PAGE_READWRITE);
 107     ok_ntstatus(Status, STATUS_SUCCESS);
 108
 109     /* We must be able to access the memory */
 110     _SEH2_TRY
 111     {
 112         *(PULONG)BaseAddress = 1;
 113     }
 114     _SEH2_EXCEPT(1)
 115     {
 116         ok(FALSE, "Got an exception\n");
 117     }
 118     _SEH2_END;
 119
 120     /* Commit a page in the section */
 121     BaseAddress = (PVOID)0x30000000;
 122     ViewSize = 0x1000;
 123     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 124                                      &BaseAddress,
 125                                      0,
 126                                      &ViewSize,
 127                                      MEM_COMMIT,
 128                                      PAGE_READWRITE);
 129     ok_ntstatus(Status, STATUS_SUCCESS);
 130
 131     /* Try to decommit a page in the section */
 132     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 133                                  &BaseAddress,
 134                                  &ViewSize,
 135                                  MEM_DECOMMIT);
 136     ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
 137
 138     /* Try to commit a range larger than the section */
 139     BaseAddress = (PVOID)0x30000000;
 140     ViewSize = 0x3000;
 141     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 142                                      &BaseAddress,
 143                                      0,
 144                                      &ViewSize,
 145                                      MEM_COMMIT,
 146                                      PAGE_READWRITE);
 147     ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
 148
 149     /* Try to commit a page after the section */
 150     BaseAddress = (PVOID)0x30002000;
 151     ViewSize = 0x1000;
 152     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 153                                      &BaseAddress,
 154                                      0,
 155                                      &ViewSize,
 156                                      MEM_COMMIT,
 157                                      PAGE_READWRITE);
 158     ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
 159
 160     /* Try to allocate a page after the section */
 161     BaseAddress = (PVOID)0x30002000;
 162     ViewSize = 0x1000;
 163     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 164                                      &BaseAddress,
 165                                      0,
 166                                      &ViewSize,
 167                                      MEM_RESERVE | MEM_COMMIT,
 168                                      PAGE_READWRITE);
 169     ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
 170
 171     /* Need to go to next 64k boundary */
 172     BaseAddress = (PVOID)0x30010000;
 173     ViewSize = 0x1000;
 174     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 175                                      &BaseAddress,
 176                                      0,
 177                                      &ViewSize,
 178                                      MEM_RESERVE | MEM_COMMIT,
 179                                      PAGE_READWRITE);
 180     ok_ntstatus(Status, STATUS_SUCCESS);
 181     if (!NT_SUCCESS(Status))
 182         return;
 183
 184     /* Free the allocation */
 185     BaseAddress = (PVOID)0x30010000;
 186     ViewSize = 0x1000;
 187     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 188                                  &BaseAddress,
 189                                  &ViewSize,
 190                                  MEM_RELEASE);
 191     ok(NT_SUCCESS(Status), "NtFreeVirtualMemory failed with Status %lx\n", Status);
 192
 193     /* Try to release the section mapping with NtFreeVirtualMemory */
 194     BaseAddress = (PVOID)0x30000000;
 195     ViewSize = 0x1000;
 196     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 197                                  &BaseAddress,
 198                                  &ViewSize,
 199                                  MEM_RELEASE);
 200     ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
 201
 202     /* Commit a page in the section */
 203     BaseAddress = (PVOID)0x30001000;
 204     ViewSize = 0x1000;
 205     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 206                                      &BaseAddress,
 207                                      0,
 208                                      &ViewSize,
 209                                      MEM_COMMIT,
 210                                      PAGE_READWRITE);
 211     ok_ntstatus(Status, STATUS_SUCCESS);
 212
 213     /* Try to decommit the page */
 214     BaseAddress = (PVOID)0x30001000;
 215     ViewSize = 0x1000;
 216     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 217                                  &BaseAddress,
 218                                  &ViewSize,
 219                                  MEM_DECOMMIT);
 220     ok_ntstatus(Status, STATUS_UNABLE_TO_DELETE_SECTION);
 221
 222     BaseAddress = UlongToPtr(0x40000000);
 223     SectionOffset.QuadPart = 0;
 224     ViewSize = 0x1000;
 225     Status = NtMapViewOfSection(SectionHandle,
 226                                 NtCurrentProcess(),
 227                                 &BaseAddress,
 228                                 0,
 229                                 0,
 230                                 &SectionOffset,
 231                                 &ViewSize,
 232                                 ViewShare,
 233                                 0,
 234                                 PAGE_READWRITE);
 235     ok_ntstatus(Status, STATUS_SUCCESS);
 236     if (!NT_SUCCESS(Status))
 237         return;
 238
 239     ok(BaseAddress == UlongToPtr(0x40000000), "Invalid BaseAddress: %p\n", BaseAddress);
 240
 241     BaseAddress = (PVOID)0x40080000;
 242     SectionOffset.QuadPart = 0x10000;
 243     ViewSize = 0x1000;
 244     Status = NtMapViewOfSection(SectionHandle,
 245                                 NtCurrentProcess(),
 246                                 &BaseAddress,
 247                                 0,
 248                                 0,
 249                                 &SectionOffset,
 250                                 &ViewSize,
 251                                 ViewShare,
 252                                 0,
 253                                 PAGE_READWRITE);
 254     ok_ntstatus(Status, STATUS_SUCCESS);
 255
 256     ok(BaseAddress == (PVOID)0x40080000, "Invalid BaseAddress: %p\n", BaseAddress);
 257
 258     /* Commit a page in the section */
 259     BaseAddress = (PVOID)0x40000000;
 260     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 261                                      &BaseAddress,
 262                                      0,
 263                                      &ViewSize,
 264                                      MEM_COMMIT,
 265                                      PAGE_READWRITE);
 266     ok_ntstatus(Status, STATUS_SUCCESS);
 267
 268     /* Close the mapping */
 269     NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
 270     NtClose(SectionHandle);
 271
 272     /* Create a page file backed section, but only reserved */
 273     MaximumSize.QuadPart = 0x20000;
 274     Status = NtCreateSection(&SectionHandle,
 275                              SECTION_ALL_ACCESS,
 276                              NULL,
 277                              &MaximumSize,
 278                              PAGE_READWRITE,
 279                              SEC_RESERVE,
 280                              NULL);
 281     ok_ntstatus(Status, STATUS_SUCCESS);
 282
 283     /* Try to map 1 page, passing MEM_RESERVE */
 284     BaseAddress = NULL;
 285     SectionOffset.QuadPart = 0;
 286     ViewSize = PAGE_SIZE;
 287     Status = NtMapViewOfSection(SectionHandle,
 288                                 NtCurrentProcess(),
 289                                 &BaseAddress,
 290                                 0,
 291                                 PAGE_SIZE,
 292                                 &SectionOffset,
 293                                 &ViewSize,
 294                                 ViewShare,
 295                                 MEM_RESERVE,
 296                                 PAGE_READWRITE);
 297     ok_ntstatus(Status, STATUS_INVALID_PARAMETER_9);
 298
 299     /* Try to map 1 page using MEM_COMMIT */
 300     BaseAddress = NULL;
 301     SectionOffset.QuadPart = 0;
 302     ViewSize = PAGE_SIZE;
 303     Status = NtMapViewOfSection(SectionHandle,
 304                                 NtCurrentProcess(),
 305                                 &BaseAddress,
 306                                 0,
 307                                 PAGE_SIZE,
 308                                 &SectionOffset,
 309                                 &ViewSize,
 310                                 ViewShare,
 311                                 MEM_COMMIT,
 312                                 PAGE_READWRITE);
 313     ok_ntstatus(Status, STATUS_INVALID_PARAMETER_9);
 314
 315     /* Map 2 pages, but commit 1 */
 316     BaseAddress = NULL;
 317     SectionOffset.QuadPart = 0;
 318     ViewSize = 2 * PAGE_SIZE;
 319     Status = NtMapViewOfSection(SectionHandle,
 320                                 NtCurrentProcess(),
 321                                 &BaseAddress,
 322                                 0,
 323                                 PAGE_SIZE,
 324                                 &SectionOffset,
 325                                 &ViewSize,
 326                                 ViewShare,
 327                                 0,
 328                                 PAGE_READWRITE);
 329     ok_ntstatus(Status, STATUS_SUCCESS);
 330
 331     /* We must be able to access the 1st page */
 332     Status = STATUS_SUCCESS;
 333     _SEH2_TRY
 334     {
 335         *(PUCHAR)BaseAddress = 1;
 336     }
 337     _SEH2_EXCEPT(1)
 338     {
 339         Status = _SEH2_GetExceptionCode();
 340     }
 341     _SEH2_END;
 342     ok_ntstatus(Status, STATUS_SUCCESS);
 343
 344     /* We must not be able to access the 2nd page */
 345     Status = STATUS_SUCCESS;
 346     _SEH2_TRY
 347     {
 348         *((PUCHAR)BaseAddress + PAGE_SIZE) = 1;
 349     }
 350     _SEH2_EXCEPT(1)
 351     {
 352         Status = _SEH2_GetExceptionCode();
 353     }
 354     _SEH2_END;
 355     ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
 356
 357     /* Map the 2 pages again into a different memory location */
 358     BaseAddress2 = NULL;
 359     Status = NtMapViewOfSection(SectionHandle,
 360                                 NtCurrentProcess(),
 361                                 &BaseAddress2,
 362                                 0,
 363                                 0,
 364                                 &SectionOffset,
 365                                 &ViewSize,
 366                                 ViewShare,
 367                                 0,
 368                                 PAGE_READWRITE);
 369     ok_ntstatus(Status, STATUS_SUCCESS);
 370
 371     /* Commit a the 2nd page in the 2nd memory location */
 372     BaseAddress2 = (PUCHAR)BaseAddress2 + PAGE_SIZE;
 373     ViewSize = PAGE_SIZE;
 374     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 375                                      &BaseAddress2,
 376                                      0,
 377                                      &ViewSize,
 378                                      MEM_COMMIT,
 379                                      PAGE_READONLY);
 380     ok_ntstatus(Status, STATUS_SUCCESS);
 381
 382     /* Try to commit again (the already committed page) */
 383     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 384                                      &BaseAddress2,
 385                                      0,
 386                                      &ViewSize,
 387                                      MEM_COMMIT,
 388                                      PAGE_READONLY);
 389     ok_ntstatus(Status, STATUS_SUCCESS);
 390
 391     /* We must be able to access the memory in the 2nd page of the 1st memory location */
 392     Status = STATUS_SUCCESS;
 393     _SEH2_TRY
 394     {
 395         *((PUCHAR)BaseAddress + PAGE_SIZE) = 2;
 396     }
 397     _SEH2_EXCEPT(1)
 398     {
 399         Status = _SEH2_GetExceptionCode();
 400     }
 401     _SEH2_END;
 402     ok_ntstatus(Status, STATUS_SUCCESS);
 403
 404     ok(*(PULONG)BaseAddress2 == 2, "Value in memory was wrong\n");
 405
 406     /* Close the mapping */
 407     NtUnmapViewOfSection(NtCurrentProcess(), BaseAddress);
 408     NtUnmapViewOfSection(NtCurrentProcess(), (PUCHAR)BaseAddress2 - PAGE_SIZE);
 409     NtClose(SectionHandle);
 410
 411     /* Try to create a 512 GB page file backed section with committed pages */
 412     MaximumSize.QuadPart = 0x8000000000;
 413     Status = NtCreateSection(&SectionHandle,
 414                              SECTION_ALL_ACCESS,
 415                              NULL,
 416                              &MaximumSize,
 417                              PAGE_READWRITE,
 418                              SEC_COMMIT,
 419                              NULL);
 420     ok_ntstatus(Status, STATUS_COMMITMENT_LIMIT);
 421
 422     /* Try to create a huge page file backed section with PAGE_NOACCESS protection */
 423     MaximumSize.QuadPart = 0x8000000000;
 424     Status = NtCreateSection(&SectionHandle,
 425                              SECTION_ALL_ACCESS,
 426                              NULL,
 427                              &MaximumSize,
 428                              PAGE_NOACCESS,
 429                              SEC_COMMIT,
 430                              NULL);
 431     ok_ntstatus(Status, STATUS_INVALID_PAGE_PROTECTION);
 432
 433     /* Try to create a very huge page file backed section, but only reserved */
 434     MaximumSize.QuadPart = 0x80000000000;
 435     Status = NtCreateSection(&SectionHandle,
 436                              SECTION_ALL_ACCESS,
 437                              NULL,
 438                              &MaximumSize,
 439                              PAGE_READWRITE,
 440                              SEC_RESERVE,
 441                              NULL);
 442 #ifdef _WIN64
 443     ok_ntstatus(Status, STATUS_INSUFFICIENT_RESOURCES);
 444 #else
 445     /* WoW64 returns STATUS_INSUFFICIENT_RESOURCES */
 446     ok((Status == STATUS_INSUFFICIENT_RESOURCES) || (Status == STATUS_SECTION_TOO_BIG),
 447        "got wrong Status: 0x%lx\n", Status);
 448 #endif
 449
 450     /* Try to create a even huger page file backed section, but only reserved */
 451     MaximumSize.QuadPart = 0x800000000000;
 452     Status = NtCreateSection(&SectionHandle,
 453                              SECTION_ALL_ACCESS,
 454                              NULL,
 455                              &MaximumSize,
 456                              PAGE_READWRITE,
 457                              SEC_RESERVE,
 458                              NULL);
 459     ok_ntstatus(Status, STATUS_SECTION_TOO_BIG);
 460
 461     /* Create a 8 GB page file backed section, but only reserved */
 462     MaximumSize.QuadPart = 0x200000000;
 463     Status = NtCreateSection(&SectionHandle,
 464                              SECTION_ALL_ACCESS,
 465                              NULL,
 466                              &MaximumSize,
 467                              PAGE_READWRITE,
 468                              SEC_RESERVE,
 469                              NULL);
 470     ok_ntstatus(Status, STATUS_SUCCESS);
 471
 472     /* Pass a too large region size */
 473     BaseAddress = NULL;
 474     SectionOffset.QuadPart = 0;
 475     ViewSize = MAXULONG_PTR;
 476     Status = NtMapViewOfSection(SectionHandle,
 477                                 NtCurrentProcess(),
 478                                 &BaseAddress,
 479                                 0,
 480                                 0,
 481                                 &SectionOffset,
 482                                 &ViewSize,
 483                                 ViewShare,
 484                                 0,
 485                                 PAGE_READWRITE);
 486 #ifdef _WIN64
 487     ok_ntstatus(Status, STATUS_INVALID_PARAMETER_3);
 488 #else
 489     /* WoW64 returns STATUS_INVALID_PARAMETER_4 */
 490     ok((Status == STATUS_INVALID_PARAMETER_4) || (Status == STATUS_INVALID_PARAMETER_3),
 491        "got wrong Status: 0x%lx\n", Status);
 492 #endif
 493
 494     /* Pass 0 region size */
 495     BaseAddress = NULL;
 496     SectionOffset.QuadPart = 0;
 497     ViewSize = 0;
 498     Status = NtMapViewOfSection(SectionHandle,
 499                                 NtCurrentProcess(),
 500                                 &BaseAddress,
 501                                 0,
 502                                 0,
 503                                 &SectionOffset,
 504                                 &ViewSize,
 505                                 ViewShare,
 506                                 0,
 507                                 PAGE_READWRITE);
 508 #ifdef _WIN64
 509     ok_ntstatus(Status, STATUS_SUCCESS);
 510     ok(ViewSize == 0x200000000, "wrong ViewSize: 0x%Ix\n", ViewSize);
 511 #else
 512     /* WoW64 returns STATUS_NO_MEMORY */
 513     ok((Status == STATUS_NO_MEMORY) || (Status == STATUS_INVALID_VIEW_SIZE),
 514        "got wrong Status: 0x%lx\n", Status);
 515     ok(ViewSize == 0, "wrong ViewSize: 0x%Ix\n", ViewSize);
 516 #endif
 517
 518     /* Map with PAGE_NOACCESS */
 519     BaseAddress = NULL;
 520     SectionOffset.QuadPart = 0;
 521     ViewSize = 0x20000000;
 522     Status = NtMapViewOfSection(SectionHandle,
 523                                 NtCurrentProcess(),
 524                                 &BaseAddress,
 525                                 0,
 526                                 0,
 527                                 &SectionOffset,
 528                                 &ViewSize,
 529                                 ViewShare,
 530                                 0,
 531                                 PAGE_NOACCESS);
 532     ok_ntstatus(Status, STATUS_SUCCESS);
 533
 534     /* Try to change protection to read/write */
 535     ViewSize = 0x1000;
 536     OldProtect = -1;
 537     BaseAddress2 = BaseAddress;
 538     Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READWRITE, &OldProtect);
 539     ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
 540     // Windows 2003 returns bogus
 541     //ok(OldProtect == PAGE_READWRITE, "Wrong protection returned: %u\n", OldProtect);
 542
 543     /* Test read access */
 544     Status = STATUS_SUCCESS;
 545     _SEH2_TRY
 546     {
 547         (void)(*(volatile char*)BaseAddress2);
 548     }
 549     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 550     {
 551         Status = _SEH2_GetExceptionCode();
 552     }
 553     _SEH2_END;
 554     ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
 555
 556     /* Try to change protection to read/write */
 557     ViewSize = 0x1000;
 558     OldProtect = -1;
 559     BaseAddress2 = BaseAddress;
 560     Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READWRITE, &OldProtect);
 561     ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
 562 #ifdef _WIN64
 563     ok(OldProtect == 0, "Wrong protection returned: 0x%lx\n", OldProtect);
 564 #else
 565     // Windows 2003 returns bogus
 566 #endif
 567
 568     /* Try to change protection to readonly */
 569     ViewSize = 0x1000;
 570     OldProtect = -1;
 571     BaseAddress2 = BaseAddress;
 572     Status = NtProtectVirtualMemory(NtCurrentProcess(), &BaseAddress2, &ViewSize, PAGE_READONLY, &OldProtect);
 573     ok_ntstatus(Status, STATUS_SECTION_PROTECTION);
 574 #ifdef _WIN64
 575     //ok(OldProtect == 0, "Wrong protection returned: 0x%lx\n", OldProtect);
 576 #else
 577     // Windows 2003 returns bogus
 578 #endif
 579
 580     /* Commit a page */
 581     ViewSize = 0x1000;
 582     BaseAddress2 = BaseAddress;
 583     Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READONLY);
 584     ok_ntstatus(Status, STATUS_SUCCESS);
 585     ok(BaseAddress2 == BaseAddress, "Invalid base address: %p\n", BaseAddress2);
 586
 587     /* Commit the page again */
 588     ViewSize = 0x1000;
 589     BaseAddress2 = BaseAddress;
 590     Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READONLY);
 591     ok_ntstatus(Status, STATUS_SUCCESS);
 592     ok(BaseAddress2 == BaseAddress, "Invalid base address: %p\n", BaseAddress2);
 593
 594     /* Test read access */
 595     Status = STATUS_SUCCESS;
 596     _SEH2_TRY
 597     {
 598         (void)(*(volatile char*)BaseAddress2);
 599     }
 600     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 601     {
 602         Status = _SEH2_GetExceptionCode();
 603     }
 604     _SEH2_END;
 605     ok_ntstatus(Status, STATUS_SUCCESS);
 606
 607     /* Test write access */
 608     Status = STATUS_SUCCESS;
 609     _SEH2_TRY
 610     {
 611         *(char*)BaseAddress2 = 1;
 612     }
 613     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 614     {
 615         Status = _SEH2_GetExceptionCode();
 616     }
 617     _SEH2_END;
 618     ok_ntstatus(Status, STATUS_ACCESS_VIOLATION);
 619
 620     /* Update protection to PAGE_READWRITE */
 621     ViewSize = 0x1000;
 622     BaseAddress2 = BaseAddress;
 623     Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_READWRITE);
 624     ok_ntstatus(Status, STATUS_SUCCESS);
 625
 626     /* Test write access */
 627     Status = STATUS_SUCCESS;
 628     _SEH2_TRY
 629     {
 630         *(char*)BaseAddress2 = 1;
 631     }
 632     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 633     {
 634         Status = _SEH2_GetExceptionCode();
 635     }
 636     _SEH2_END;
 637     ok_ntstatus(Status, STATUS_SUCCESS);
 638
 639     /* Update protection to PAGE_EXECUTE_READWRITE (1 page) */
 640     ViewSize = 0x1000;
 641     BaseAddress2 = BaseAddress;
 642     Status = NtAllocateVirtualMemory(NtCurrentProcess(), &BaseAddress2, 0, &ViewSize, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
 643     ok_ntstatus(Status, STATUS_SUCCESS);
 644
 645 }
 646
 647 void
 648 Test_ImageSection(void)
 649 {
 650     UNICODE_STRING FileName;
 651     NTSTATUS Status;
 652     OBJECT_ATTRIBUTES FileObjectAttributes;
 653     IO_STATUS_BLOCK IoStatusBlock;
 654     HANDLE FileHandle, DataSectionHandle, ImageSectionHandle;
 655     PVOID DataBase, ImageBase;
 656     SIZE_T ViewSize;
 657
 658     if (!RtlDosPathNameToNtPathName_U(L"testdata\\test.dll",
 659                                       &FileName,
 660                                       NULL,
 661                                       NULL))
 662     {
 663         ok(0, "RtlDosPathNameToNtPathName_U failed\n");
 664         return;
 665     }
 666
 667     InitializeObjectAttributes(&FileObjectAttributes,
 668                                &FileName,
 669                                0,
 670                                NULL,
 671                                NULL);
 672
 673     Status = NtOpenFile(&FileHandle,
 674                         GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
 675                         &FileObjectAttributes,
 676                         &IoStatusBlock,
 677                         FILE_SHARE_READ,
 678                         FILE_SYNCHRONOUS_IO_NONALERT);
 679     ok_ntstatus(Status, STATUS_SUCCESS);
 680     if (!NT_SUCCESS(Status))
 681     {
 682         skip("Failed to open file\n");
 683         return;
 684     }
 685
 686     /* Create a data section with write access */
 687     Status = NtCreateSection(&DataSectionHandle,
 688                              SECTION_ALL_ACCESS, // DesiredAccess
 689                              NULL, // ObjectAttributes
 690                              NULL, // MaximumSize
 691                              PAGE_READWRITE, // SectionPageProtection
 692                              SEC_COMMIT, // AllocationAttributes
 693                              FileHandle);
 694     ok_ntstatus(Status, STATUS_SUCCESS);
 695     if (!NT_SUCCESS(Status))
 696     {
 697         skip("Failed to create data section\n");
 698         NtClose(FileHandle);
 699         return;
 700     }
 701
 702     /* Map the data section as flat mapping */
 703     DataBase = NULL;
 704     ViewSize = 0;
 705     Status = NtMapViewOfSection(DataSectionHandle,
 706                                 NtCurrentProcess(),
 707                                 &DataBase,
 708                                 0,
 709                                 0,
 710                                 NULL,
 711                                 &ViewSize,
 712                                 ViewShare,
 713                                 0,
 714                                 PAGE_READWRITE);
 715     ok_ntstatus(Status, STATUS_SUCCESS);
 716     //ok(ViewSize == 0x3f95cc48, "ViewSize wrong: 0x%lx\n");
 717     if (!NT_SUCCESS(Status))
 718     {
 719         skip("Failed to map view of data section\n");
 720         NtClose(DataSectionHandle);
 721         NtClose(FileHandle);
 722         return;
 723     }
 724
 725     /* Check the original data */
 726     ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
 727
 728     /* Modify the PE header (but do not flush!) */
 729     *(ULONG*)DataBase = 0xdeadbabe;
 730     ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n");
 731
 732     /* Modify data in the .data section (but do not flush!) */
 733     ok(*(ULONG*)((PUCHAR)DataBase + 0x800) == 0x12345678,
 734        "Data in .data section invalid: 0x%lx!\n", *(ULONG*)((PUCHAR)DataBase + 0x800));
 735     *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x87654321;
 736
 737     /* Now try to create an image section (should fail) */
 738     Status = NtCreateSection(&ImageSectionHandle,
 739                              SECTION_ALL_ACCESS, // DesiredAccess
 740                              NULL, // ObjectAttributes
 741                              NULL, // MaximumSize
 742                              PAGE_READWRITE, // SectionPageProtection
 743                              SEC_IMAGE, // AllocationAttributes
 744                              FileHandle);
 745     ok_ntstatus(Status, STATUS_INVALID_IMAGE_NOT_MZ);
 746     if (NT_SUCCESS(Status)) NtClose(ImageSectionHandle);
 747
 748     /* Restore the original header */
 749     *(ULONG*)DataBase = 0x00905a4d;
 750
 751     /* Modify data in the .data section (but do not flush!) */
 752     ok_hex(*(ULONG*)((PUCHAR)DataBase + 0x800), 0x87654321);
 753     *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xdeadbabe;
 754
 755     /* Try to create an image section again */
 756     Status = NtCreateSection(&ImageSectionHandle,
 757                              SECTION_ALL_ACCESS, // DesiredAccess
 758                              NULL, // ObjectAttributes
 759                              NULL, // MaximumSize
 760                              PAGE_READWRITE, // SectionPageProtection
 761                              SEC_IMAGE, // AllocationAttributes
 762                              FileHandle);
 763     ok_ntstatus(Status, STATUS_SUCCESS);
 764     if (!NT_SUCCESS(Status))
 765     {
 766         skip("Failed to create image section\n");
 767         NtClose(DataSectionHandle);
 768         NtClose(FileHandle);
 769         return;
 770     }
 771
 772     /* Map the image section */
 773     ImageBase = NULL;
 774     ViewSize = 0;
 775     Status = NtMapViewOfSection(ImageSectionHandle,
 776                                 NtCurrentProcess(),
 777                                 &ImageBase,
 778                                 0, // ZeroBits
 779                                 0, // CommitSize
 780                                 NULL, // SectionOffset
 781                                 &ViewSize,
 782                                 ViewShare,
 783                                 0, // AllocationType
 784                                 PAGE_READONLY);
 785 #ifdef _M_IX86
 786     ok_ntstatus(Status, STATUS_IMAGE_NOT_AT_BASE);
 787 #else
 788     ok_ntstatus(Status, STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
 789 #endif
 790     if (!NT_SUCCESS(Status))
 791     {
 792         skip("Failed to map view of image section\n");
 793         NtClose(ImageSectionHandle);
 794         NtClose(DataSectionHandle);
 795         NtClose(FileHandle);
 796         return;
 797     }
 798
 799     /* Check the header */
 800     ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
 801     ok(*(ULONG*)ImageBase == 0x00905a4d, "Header not ok\n");
 802
 803     /* Check the data section. Either of these can be present! */
 804     ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
 805        (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
 806        "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
 807
 808     /* Now modify the data again */
 809     *(ULONG*)DataBase = 0xdeadbabe;
 810     *(ULONG*)((PUCHAR)DataBase + 0x800) = 0xf00dada;
 811
 812     /* Check the data */
 813     ok(*(ULONG*)DataBase == 0xdeadbabe, "Header not ok\n");
 814     ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n");
 815     ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
 816        (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
 817        "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
 818
 819     /* Flush the view */
 820     ViewSize = 0x1000;
 821     Status = NtFlushVirtualMemory(NtCurrentProcess(),
 822                                   &DataBase,
 823                                   &ViewSize,
 824                                   &IoStatusBlock);
 825     ok_ntstatus(Status, STATUS_SUCCESS);
 826
 827     /* Check the data again */
 828     ok(*(ULONG*)ImageBase == 0x00905a4d, "Data should not be synced!\n");
 829     ok((*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x87654321) ||
 830        (*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0x12345678),
 831        "Wrong value in data section: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
 832
 833     /* Restore the original header */
 834     *(ULONG*)DataBase = 0x00905a4d;
 835     ok(*(ULONG*)DataBase == 0x00905a4d, "Header not ok\n");
 836
 837     /* Close the image mapping */
 838     NtUnmapViewOfSection(NtCurrentProcess(), ImageBase);
 839     NtClose(ImageSectionHandle);
 840
 841     /* Create an image section again */
 842     Status = NtCreateSection(&ImageSectionHandle,
 843                              SECTION_ALL_ACCESS, // DesiredAccess
 844                              NULL, // ObjectAttributes
 845                              NULL, // MaximumSize
 846                              PAGE_READWRITE, // SectionPageProtection
 847                              SEC_IMAGE, // AllocationAttributes
 848                              FileHandle);
 849     ok_ntstatus(Status, STATUS_SUCCESS);
 850     if (!NT_SUCCESS(Status))
 851     {
 852         skip("Failed to create image section\n");
 853         NtClose(DataSectionHandle);
 854         NtClose(FileHandle);
 855         return;
 856     }
 857
 858     /* Map the image section again */
 859     ImageBase = NULL;
 860     ViewSize = 0;
 861     Status = NtMapViewOfSection(ImageSectionHandle,
 862                                 NtCurrentProcess(),
 863                                 &ImageBase,
 864                                 0,
 865                                 0,
 866                                 NULL,
 867                                 &ViewSize,
 868                                 ViewShare,
 869                                 0,
 870                                 PAGE_READONLY);
 871 #ifdef _M_IX86
 872     ok_ntstatus(Status, STATUS_IMAGE_NOT_AT_BASE);
 873 #else
 874     ok_ntstatus(Status, STATUS_IMAGE_MACHINE_TYPE_MISMATCH);
 875 #endif
 876     if (!NT_SUCCESS(Status))
 877     {
 878         skip("Failed to map view of image section\n");
 879         NtClose(ImageSectionHandle);
 880         NtClose(DataSectionHandle);
 881         NtClose(FileHandle);
 882         return;
 883     }
 884
 885     // This one doesn't always work, needs investigation
 886     /* Check the .data section again */
 887     //ok(*(ULONG*)((PUCHAR)ImageBase + 0x80000) == 0xf00dada,
 888     //   "Data should be synced: 0x%lx!\n", *(ULONG*)((PUCHAR)ImageBase + 0x80000));
 889
 890     /* Restore the original data */
 891     *(ULONG*)((PUCHAR)DataBase + 0x800) = 0x12345678;
 892
 893     /* Close the data mapping */
 894     NtUnmapViewOfSection(NtCurrentProcess(), DataBase);
 895
 896     NtClose(DataSectionHandle);
 897
 898     /* Try to allocate memory inside the image mapping */
 899     DataBase = (PUCHAR)ImageBase + 0x20000;
 900     ViewSize = 0x1000;
 901     Status = NtAllocateVirtualMemory(NtCurrentProcess(), &DataBase, 0, &ViewSize, MEM_RESERVE, PAGE_NOACCESS);
 902     ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
 903
 904     /* Cleanup */
 905     NtClose(FileHandle);
 906     NtClose(ImageSectionHandle);
 907     NtUnmapViewOfSection(NtCurrentProcess(), ImageBase);
 908 }
 909
 910 void
 911 Test_ImageSection2(void)
 912 {
 913     UNICODE_STRING FileName;
 914     NTSTATUS Status;
 915     OBJECT_ATTRIBUTES FileObjectAttributes;
 916     IO_STATUS_BLOCK IoStatusBlock;
 917     HANDLE FileHandle, ImageSectionHandle;
 918     PVOID ImageBase, BaseAddress;
 919     SIZE_T ViewSize;
 920     LARGE_INTEGER MaximumSize, SectionOffset;
 921
 922     if (!RtlDosPathNameToNtPathName_U(L"testdata\\nvoglv32.dll",
 923                                       &FileName,
 924                                       NULL,
 925                                       NULL))
 926     {
 927         ok(0, "RtlDosPathNameToNtPathName_U failed\n");
 928         return;
 929     }
 930
 931     InitializeObjectAttributes(&FileObjectAttributes,
 932                                &FileName,
 933                                0,
 934                                NULL,
 935                                NULL);
 936
 937     Status = NtOpenFile(&FileHandle,
 938                         GENERIC_READ|GENERIC_WRITE|SYNCHRONIZE,
 939                         &FileObjectAttributes,
 940                         &IoStatusBlock,
 941                         FILE_SHARE_READ,
 942                         FILE_SYNCHRONOUS_IO_NONALERT);
 943     ok_ntstatus(Status, STATUS_SUCCESS);
 944     printf("Opened file with handle %p\n", FileHandle);
 945
 946     /* Create a data section with write access */
 947     MaximumSize.QuadPart = 0x20000;
 948     Status = NtCreateSection(&ImageSectionHandle,
 949                              SECTION_ALL_ACCESS, // DesiredAccess
 950                              NULL, // ObjectAttributes
 951                              &MaximumSize, // MaximumSize
 952                              PAGE_READWRITE, // SectionPageProtection
 953                              SEC_IMAGE, // AllocationAttributes
 954                              FileHandle);
 955     ok_ntstatus(Status, STATUS_SUCCESS);
 956
 957     printf("Created image section with handle %p\n", ImageSectionHandle);
 958     //system("PAUSE");
 959
 960     /* Map the image section */
 961     ImageBase = NULL;
 962     ViewSize = 0x0000;
 963     SectionOffset.QuadPart = 0x00000;
 964     Status = NtMapViewOfSection(ImageSectionHandle,
 965                                 NtCurrentProcess(),
 966                                 &ImageBase,
 967                                 0,
 968                                 0,
 969                                 &SectionOffset,
 970                                 &ViewSize,
 971                                 ViewShare,
 972                                 0,
 973                                 PAGE_READWRITE);
 974     ok_ntstatus(Status, STATUS_SUCCESS);
 975
 976     printf("Mapped image section at %p, value in text section: %lx\n",
 977            ImageBase, *((ULONG*)((PCHAR)ImageBase + 0x1196)));
 978     system("PAUSE");
 979
 980     /* Try to allocate a page after the section */
 981     BaseAddress = (PUCHAR)ImageBase + 0x10000;
 982     ViewSize = 0x1000;
 983     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 984                                      &BaseAddress,
 985                                      0,
 986                                      &ViewSize,
 987                                      MEM_RESERVE | MEM_COMMIT,
 988                                      PAGE_READWRITE);
 989     printf("allocation status: %lx\n", Status);
 990     system("PAUSE");
 991
 992 }
 993
 994 // doesn't work with WoW64!
 995 void
 996 Test_BasedSection(void)
 997 {
 998     NTSTATUS Status;
 999     HANDLE SectionHandle1, SectionHandle2;
1000     LARGE_INTEGER MaximumSize, SectionOffset;
1001     PVOID BaseAddress1, BaseAddress2;
1002     SIZE_T ViewSize;
1003
1004     /* Create a based section with SEC_COMMIT */
1005     MaximumSize.QuadPart = 0x1000;
1006     Status = NtCreateSection(&SectionHandle1,
1007                              SECTION_ALL_ACCESS,
1008                              NULL,
1009                              &MaximumSize,
1010                              PAGE_READWRITE,
1011                              SEC_COMMIT | SEC_BASED,
1012                              NULL);
1013     ok_ntstatus(Status, STATUS_SUCCESS);
1014
1015     /* Map the 1st section */
1016     BaseAddress1 = NULL;
1017     SectionOffset.QuadPart = 0;
1018     ViewSize = 0;
1019     Status = NtMapViewOfSection(SectionHandle1,
1020                                 NtCurrentProcess(),
1021                                 &BaseAddress1,
1022                                 0,
1023                                 0,
1024                                 &SectionOffset,
1025                                 &ViewSize,
1026                                 ViewShare,
1027                                 0,
1028                                 PAGE_READWRITE);
1029 #if 0 // WOW64?
1030     ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1031 #else
1032     ok_ntstatus(Status, STATUS_SUCCESS);
1033 #endif
1034
1035     /* Create a 2nd based section with SEC_COMMIT */
1036     MaximumSize.QuadPart = 0x1000;
1037     Status = NtCreateSection(&SectionHandle2,
1038                              SECTION_ALL_ACCESS,
1039                              NULL,
1040                              &MaximumSize,
1041                              PAGE_READWRITE,
1042                              SEC_COMMIT | SEC_BASED,
1043                              NULL);
1044     ok_ntstatus(Status, STATUS_SUCCESS);//
1045
1046     /* Map the 2nd section */
1047     BaseAddress2 = NULL;
1048     SectionOffset.QuadPart = 0;
1049     ViewSize = 0;
1050     Status = NtMapViewOfSection(SectionHandle2,
1051                                 NtCurrentProcess(),
1052                                 &BaseAddress2,
1053                                 0,
1054                                 0,
1055                                 &SectionOffset,
1056                                 &ViewSize,
1057                                 ViewShare,
1058                                 0,
1059                                 PAGE_READWRITE);
1060 #if 0 // WOW64?
1061     ok_ntstatus(Status, STATUS_CONFLICTING_ADDRESSES);
1062 #else
1063     ok_ntstatus(Status, STATUS_SUCCESS);
1064 #endif
1065
1066     ok_ntstatus(Status, STATUS_SUCCESS);
1067     ok((ULONG_PTR)BaseAddress2 < (ULONG_PTR)BaseAddress1,
1068        "Invalid addresses: BaseAddress1=%p, BaseAddress2=%p\n", BaseAddress1, BaseAddress2);
1069     ok(((ULONG_PTR)BaseAddress1 - (ULONG_PTR)BaseAddress2) == 0x10000,
1070        "Invalid addresses: BaseAddress1=%p, BaseAddress2=%p\n", BaseAddress1, BaseAddress2);
1071
1072 }
1073
1074 START_TEST(NtMapViewOfSection)
1075 {
1076     Test_PageFileSection();
1077     Test_ImageSection();
1078     Test_BasedSection();
1079 }
1080