subsystems/mvdm/ntvdm/memory.c

   1 /*
   2  * COPYRIGHT:       GPLv2+ - See COPYING in the top level directory
   3  * PROJECT:         ReactOS Virtual DOS Machine
   4  * FILE:            subsystems/mvdm/ntvdm/memory.c
   5  * PURPOSE:         Memory Management
   6  * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #include "ntvdm.h"
  12
  13 #define NDEBUG
  14 #include <debug.h>
  15
  16 #include "emulator.h"
  17 #include "memory.h"
  18
  19 /* Extra PSDK/NDK Headers */
  20 #include <ndk/mmfuncs.h>
  21
  22 /* PRIVATE VARIABLES **********************************************************/
  23
  24 typedef struct _MEM_HOOK
  25 {
  26     LIST_ENTRY Entry;
  27     HANDLE hVdd;
  28     ULONG Count;
  29
  30     union
  31     {
  32         PVDD_MEMORY_HANDLER VddHandler;
  33
  34         struct
  35         {
  36             PMEMORY_READ_HANDLER  FastReadHandler;
  37             PMEMORY_WRITE_HANDLER FastWriteHandler;
  38         };
  39     };
  40 } MEM_HOOK, *PMEM_HOOK;
  41
  42 static LIST_ENTRY HookList;
  43 static PMEM_HOOK PageTable[TOTAL_PAGES] = { NULL };
  44 static BOOLEAN A20Line = FALSE;
  45
  46 /* PRIVATE FUNCTIONS **********************************************************/
  47
  48 static inline VOID
  49 MemFastMoveMemory(OUT VOID UNALIGNED *Destination,
  50                   IN const VOID UNALIGNED *Source,
  51                   IN SIZE_T Length)
  52 {
  53 #if 1
  54     /*
  55      * We use a switch here to detect small moves of memory, as these
  56      * constitute the bulk of our moves.
  57      * Using RtlMoveMemory for all these small moves would be slow otherwise.
  58      */
  59     switch (Length)
  60     {
  61         case 0:
  62             return;
  63
  64         case sizeof(UCHAR):
  65             *(PUCHAR)Destination = *(PUCHAR)Source;
  66             return;
  67
  68         case sizeof(USHORT):
  69             *(PUSHORT)Destination = *(PUSHORT)Source;
  70             return;
  71
  72         case sizeof(ULONG):
  73             *(PULONG)Destination = *(PULONG)Source;
  74             return;
  75
  76         case sizeof(ULONGLONG):
  77             *(PULONGLONG)Destination = *(PULONGLONG)Source;
  78             return;
  79
  80         default:
  81 #if defined(__GNUC__)
  82             __builtin_memmove(Destination, Source, Length);
  83 #else
  84             RtlMoveMemory(Destination, Source, Length);
  85 #endif
  86     }
  87
  88 #else // defined(_MSC_VER)
  89
  90     PUCHAR Dest = (PUCHAR)Destination;
  91     PUCHAR Src  = (PUCHAR)Source;
  92
  93     SIZE_T Count, NewSize = Length;
  94
  95     /* Move dword */
  96     Count   = NewSize >> 2; // NewSize / sizeof(ULONG);
  97     NewSize = NewSize  & 3; // NewSize % sizeof(ULONG);
  98     __movsd(Dest, Src, Count);
  99     Dest += Count << 2; // Count * sizeof(ULONG);
 100     Src  += Count << 2;
 101
 102     /* Move word */
 103     Count   = NewSize >> 1; // NewSize / sizeof(USHORT);
 104     NewSize = NewSize  & 1; // NewSize % sizeof(USHORT);
 105     __movsw(Dest, Src, Count);
 106     Dest += Count << 1; // Count * sizeof(USHORT);
 107     Src  += Count << 1;
 108
 109     /* Move byte */
 110     Count   = NewSize; // NewSize / sizeof(UCHAR);
 111     // NewSize = NewSize; // NewSize % sizeof(UCHAR);
 112     __movsb(Dest, Src, Count);
 113
 114 #endif
 115 }
 116
 117 static inline VOID
 118 ReadPage(PMEM_HOOK Hook, ULONG Address, PVOID Buffer, ULONG Size)
 119 {
 120     if (Hook && !Hook->hVdd && Hook->FastReadHandler)
 121     {
 122         Hook->FastReadHandler(Address, REAL_TO_PHYS(Address), Size);
 123     }
 124
 125     MemFastMoveMemory(Buffer, REAL_TO_PHYS(Address), Size);
 126 }
 127
 128 static inline VOID
 129 WritePage(PMEM_HOOK Hook, ULONG Address, PVOID Buffer, ULONG Size)
 130 {
 131     if (!Hook
 132         || Hook->hVdd
 133         || !Hook->FastWriteHandler
 134         || Hook->FastWriteHandler(Address, Buffer, Size))
 135     {
 136         MemFastMoveMemory(REAL_TO_PHYS(Address), Buffer, Size);
 137     }
 138 }
 139
 140 /* PUBLIC FUNCTIONS ***********************************************************/
 141
 142 VOID FASTCALL EmulatorReadMemory(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
 143 {
 144     ULONG i, Offset, Length;
 145     ULONG FirstPage, LastPage;
 146
 147     UNREFERENCED_PARAMETER(State);
 148
 149     /* Mirror 0x000FFFF0 at 0xFFFFFFF0 */
 150     if (Address >= 0xFFFFFFF0) Address -= 0xFFF00000;
 151
 152     /* If the A20 line is disabled, mask bit 20 */
 153     if (!A20Line) Address &= ~(1 << 20);
 154
 155     if ((Address + Size - 1) >= MAX_ADDRESS)
 156     {
 157         ULONG ExtraStart = (Address < MAX_ADDRESS) ? MAX_ADDRESS - Address : 0;
 158
 159         /* Fill the memory that was above the limit with 0xFF */
 160         RtlFillMemory((PVOID)((ULONG_PTR)Buffer + ExtraStart), Size - ExtraStart, 0xFF);
 161
 162         if (Address < MAX_ADDRESS) Size = MAX_ADDRESS - Address;
 163         else return;
 164     }
 165
 166     FirstPage = Address >> 12;
 167     LastPage = (Address + Size - 1) >> 12;
 168
 169     if (FirstPage == LastPage)
 170     {
 171         ReadPage(PageTable[FirstPage], Address, Buffer, Size);
 172     }
 173     else
 174     {
 175         for (i = FirstPage; i <= LastPage; i++)
 176         {
 177             Offset = (i == FirstPage) ? (Address & (PAGE_SIZE - 1)) : 0;
 178             Length = ((i == LastPage) ? (Address + Size - (LastPage << 12)) : PAGE_SIZE) - Offset;
 179
 180             ReadPage(PageTable[i], (i << 12) + Offset, Buffer, Length);
 181             Buffer = (PVOID)((ULONG_PTR)Buffer + Length);
 182         }
 183     }
 184 }
 185
 186 VOID FASTCALL EmulatorWriteMemory(PFAST486_STATE State, ULONG Address, PVOID Buffer, ULONG Size)
 187 {
 188     ULONG i, Offset, Length;
 189     ULONG FirstPage, LastPage;
 190
 191     UNREFERENCED_PARAMETER(State);
 192
 193     /* If the A20 line is disabled, mask bit 20 */
 194     if (!A20Line) Address &= ~(1 << 20);
 195
 196     if (Address >= MAX_ADDRESS) return;
 197     Size = min(Size, MAX_ADDRESS - Address);
 198
 199     FirstPage = Address >> 12;
 200     LastPage = (Address + Size - 1) >> 12;
 201
 202     if (FirstPage == LastPage)
 203     {
 204         WritePage(PageTable[FirstPage], Address, Buffer, Size);
 205     }
 206     else
 207     {
 208         for (i = FirstPage; i <= LastPage; i++)
 209         {
 210             Offset = (i == FirstPage) ? (Address & (PAGE_SIZE - 1)) : 0;
 211             Length = ((i == LastPage) ? (Address + Size - (LastPage << 12)) : PAGE_SIZE) - Offset;
 212
 213             WritePage(PageTable[i], (i << 12) + Offset, Buffer, Length);
 214             Buffer = (PVOID)((ULONG_PTR)Buffer + Length);
 215         }
 216     }
 217 }
 218
 219 VOID FASTCALL EmulatorCopyMemory(PFAST486_STATE State, ULONG DestAddress, ULONG SrcAddress, ULONG Size)
 220 {
 221     /*
 222      * Guest-to-guest memory copy
 223      */
 224
 225     // FIXME: This is a temporary implementation of a more useful functionality
 226     // which should be a merge of EmulatorReadMemory & EmulatorWriteMemory without
 227     // any local external buffer.
 228     // NOTE: Process heap is by default serialized (unless one specifies it shouldn't).
 229     static BYTE StaticBuffer[8192]; // Smallest static buffer we can use.
 230     static PVOID HeapBuffer = NULL; // Always-growing heap buffer. Use it in case StaticBuffer is too small.
 231     static ULONG HeapBufferSize = 0;
 232     PVOID LocalBuffer;              // Points to either StaticBuffer or HeapBuffer
 233
 234     if (Size <= sizeof(StaticBuffer))
 235     {
 236         /* Use the static buffer */
 237         LocalBuffer = StaticBuffer;
 238     }
 239     else if (/* sizeof(StaticBuffer) <= Size && */ Size <= HeapBufferSize)
 240     {
 241         /* Use the heap buffer */
 242         ASSERT(HeapBufferSize > 0 && HeapBuffer != NULL);
 243         LocalBuffer = HeapBuffer;
 244     }
 245     else // if (Size > HeapBufferSize)
 246     {
 247         /* Enlarge the heap buffer and use it */
 248
 249         if (HeapBuffer == NULL)
 250         {
 251             /* First allocation */
 252             LocalBuffer = RtlAllocateHeap(RtlGetProcessHeap(), 0, Size);
 253         }
 254         else
 255         {
 256             /* Reallocation */
 257             LocalBuffer = RtlReAllocateHeap(RtlGetProcessHeap(), 0 /* HEAP_GENERATE_EXCEPTIONS */, HeapBuffer, Size);
 258         }
 259         ASSERT(LocalBuffer != NULL); // We must succeed! TODO: Handle it more properly.
 260         HeapBuffer = LocalBuffer;    // HeapBuffer is now reallocated.
 261         HeapBufferSize = Size;
 262     }
 263
 264     /* Perform memory copy */
 265     EmulatorReadMemory( State, SrcAddress , LocalBuffer, Size);
 266     EmulatorWriteMemory(State, DestAddress, LocalBuffer, Size);
 267
 268     // if (LocalBuffer != StaticBuffer)
 269     //     RtlFreeHeap(RtlGetProcessHeap(), 0, LocalBuffer);
 270
 271     // Note that we don't free HeapBuffer since it's an always-growing buffer.
 272     // It is freed when NTVDM termiantes.
 273 }
 274
 275 VOID EmulatorSetA20(BOOLEAN Enabled)
 276 {
 277     A20Line = Enabled;
 278 }
 279
 280 BOOLEAN EmulatorGetA20(VOID)
 281 {
 282     return A20Line;
 283 }
 284
 285 VOID
 286 MemExceptionHandler(ULONG FaultAddress, BOOLEAN Writing)
 287 {
 288     PMEM_HOOK Hook = PageTable[FaultAddress >> 12];
 289     DPRINT("The memory at 0x%08X could not be %s.\n", FaultAddress, Writing ? "written" : "read");
 290
 291     /* Exceptions are only supposed to happen when using VDD-style memory hooks */
 292     ASSERT(FaultAddress < MAX_ADDRESS && Hook != NULL && Hook->hVdd != NULL);
 293
 294     /* Call the VDD handler */
 295     Hook->VddHandler(REAL_TO_PHYS(FaultAddress), (ULONG)Writing);
 296 }
 297
 298 BOOL
 299 MemInstallFastMemoryHook(PVOID Address,
 300                          ULONG Size,
 301                          PMEMORY_READ_HANDLER ReadHandler,
 302                          PMEMORY_WRITE_HANDLER WriteHandler)
 303 {
 304     PMEM_HOOK Hook;
 305     ULONG i;
 306     ULONG FirstPage = (ULONG_PTR)Address >> 12;
 307     ULONG LastPage = ((ULONG_PTR)Address + Size - 1) >> 12;
 308     PLIST_ENTRY Pointer;
 309
 310     /* Make sure none of these pages are already allocated */
 311     for (i = FirstPage; i <= LastPage; i++)
 312     {
 313         if (PageTable[i] != NULL) return FALSE;
 314     }
 315
 316     for (Pointer = HookList.Flink; Pointer != &HookList; Pointer = Pointer->Flink)
 317     {
 318         Hook = CONTAINING_RECORD(Pointer, MEM_HOOK, Entry);
 319
 320         if (Hook->hVdd == NULL
 321             && Hook->FastReadHandler == ReadHandler
 322             && Hook->FastWriteHandler == WriteHandler)
 323         {
 324             break;
 325         }
 326     }
 327
 328     if (Pointer == &HookList)
 329     {
 330         /* Create and initialize a new hook entry... */
 331         Hook = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(*Hook));
 332         if (Hook == NULL) return FALSE;
 333
 334         Hook->hVdd = NULL;
 335         Hook->Count = 0;
 336         Hook->FastReadHandler = ReadHandler;
 337         Hook->FastWriteHandler = WriteHandler;
 338
 339         /* ... and add it to the list of hooks */
 340         InsertTailList(&HookList, &Hook->Entry);
 341     }
 342
 343     /* Increase the number of pages this hook has */
 344     Hook->Count += LastPage - FirstPage + 1;
 345
 346     /* Add the hook entry to the page table */
 347     for (i = FirstPage; i <= LastPage; i++) PageTable[i] = Hook;
 348
 349     return TRUE;
 350 }
 351
 352 BOOL
 353 MemRemoveFastMemoryHook(PVOID Address, ULONG Size)
 354 {
 355     PMEM_HOOK Hook;
 356     ULONG i;
 357     ULONG FirstPage = (ULONG_PTR)Address >> 12;
 358     ULONG LastPage = ((ULONG_PTR)Address + Size - 1) >> 12;
 359
 360     if (Size == 0) return FALSE;
 361
 362     for (i = FirstPage; i <= LastPage; i++)
 363     {
 364         Hook = PageTable[i];
 365         if (Hook == NULL || Hook->hVdd != NULL) continue;
 366
 367         if (--Hook->Count == 0)
 368         {
 369             /* This hook has no more pages */
 370             RemoveEntryList(&Hook->Entry);
 371             RtlFreeHeap(RtlGetProcessHeap(), 0, Hook);
 372         }
 373
 374         PageTable[i] = NULL;
 375     }
 376
 377     return TRUE;
 378 }
 379
 380 BOOLEAN
 381 MemQueryMemoryZone(ULONG StartAddress, PULONG Length, PBOOLEAN Hooked)
 382 {
 383     ULONG Page = StartAddress >> 12;
 384     if (Page >= TOTAL_PAGES) return FALSE;
 385
 386     *Length = 0;
 387     *Hooked = PageTable[Page] != NULL;
 388
 389     while (Page < TOTAL_PAGES && (PageTable[Page] != NULL) == *Hooked)
 390     {
 391         *Length += PAGE_SIZE;
 392         Page++;
 393     }
 394
 395     return TRUE;
 396 }
 397
 398 PBYTE
 399 WINAPI
 400 Sim32pGetVDMPointer(IN ULONG   Address,
 401                     IN BOOLEAN ProtectedMode)
 402 {
 403     // FIXME
 404     UNREFERENCED_PARAMETER(ProtectedMode);
 405
 406     /*
 407      * HIWORD(Address) == Segment  (if ProtectedMode == FALSE)
 408      *                 or Selector (if ProtectedMode == TRUE )
 409      * LOWORD(Address) == Offset
 410      */
 411     return (PBYTE)FAR_POINTER(Address);
 412 }
 413
 414 PBYTE
 415 WINAPI
 416 MGetVdmPointer(IN ULONG   Address,
 417                IN ULONG   Size,
 418                IN BOOLEAN ProtectedMode)
 419 {
 420     UNREFERENCED_PARAMETER(Size);
 421     return Sim32pGetVDMPointer(Address, ProtectedMode);
 422 }
 423
 424 PVOID
 425 WINAPI
 426 VdmMapFlat(IN USHORT   Segment,
 427            IN ULONG    Offset,
 428            IN VDM_MODE Mode)
 429 {
 430     // FIXME
 431     UNREFERENCED_PARAMETER(Mode);
 432
 433     return SEG_OFF_TO_PTR(Segment, Offset);
 434 }
 435
 436 #ifndef VdmFlushCache
 437
 438 BOOL
 439 WINAPI
 440 VdmFlushCache(IN USHORT   Segment,
 441               IN ULONG    Offset,
 442               IN ULONG    Size,
 443               IN VDM_MODE Mode)
 444 {
 445     // FIXME
 446     UNIMPLEMENTED;
 447     return TRUE;
 448 }
 449
 450 #endif
 451
 452 #ifndef VdmUnmapFlat
 453
 454 BOOL
 455 WINAPI
 456 VdmUnmapFlat(IN USHORT   Segment,
 457              IN ULONG    Offset,
 458              IN PVOID    Buffer,
 459              IN VDM_MODE Mode)
 460 {
 461     // FIXME
 462     UNIMPLEMENTED;
 463     return TRUE;
 464 }
 465
 466 #endif
 467
 468 BOOL
 469 WINAPI
 470 VDDInstallMemoryHook(IN HANDLE hVdd,
 471                      IN PVOID  pStart,
 472                      IN DWORD  dwCount,
 473                      IN PVDD_MEMORY_HANDLER MemoryHandler)
 474 {
 475     NTSTATUS Status;
 476     PMEM_HOOK Hook;
 477     ULONG i;
 478     ULONG FirstPage = (ULONG_PTR)PHYS_TO_REAL(pStart) >> 12;
 479     ULONG LastPage = ((ULONG_PTR)PHYS_TO_REAL(pStart) + dwCount - 1) >> 12;
 480     PVOID Address = (PVOID)REAL_TO_PHYS(FirstPage * PAGE_SIZE);
 481     SIZE_T Size = (LastPage - FirstPage + 1) * PAGE_SIZE;
 482     PLIST_ENTRY Pointer;
 483
 484     /* Check validity of the VDD handle */
 485     if (hVdd == NULL || hVdd == INVALID_HANDLE_VALUE)
 486     {
 487         SetLastError(ERROR_INVALID_PARAMETER);
 488         return FALSE;
 489     }
 490
 491     if (dwCount == 0) return FALSE;
 492
 493     /* Make sure none of these pages are already allocated */
 494     for (i = FirstPage; i <= LastPage; i++)
 495     {
 496         if (PageTable[i] != NULL) return FALSE;
 497     }
 498
 499     for (Pointer = HookList.Flink; Pointer != &HookList; Pointer = Pointer->Flink)
 500     {
 501         Hook = CONTAINING_RECORD(Pointer, MEM_HOOK, Entry);
 502         if (Hook->hVdd == hVdd && Hook->VddHandler == MemoryHandler) break;
 503     }
 504
 505     if (Pointer == &HookList)
 506     {
 507         /* Create and initialize a new hook entry... */
 508         Hook = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(*Hook));
 509         if (Hook == NULL)
 510         {
 511             SetLastError(ERROR_OUTOFMEMORY);
 512             return FALSE;
 513         }
 514
 515         Hook->hVdd = hVdd;
 516         Hook->Count = 0;
 517         Hook->VddHandler = MemoryHandler;
 518
 519         /* ... and add it to the list of hooks */
 520         InsertTailList(&HookList, &Hook->Entry);
 521     }
 522
 523     /* Decommit the pages */
 524     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 525                                  &Address,
 526                                  &Size,
 527                                  MEM_DECOMMIT);
 528     if (!NT_SUCCESS(Status))
 529     {
 530         if (Pointer == &HookList)
 531         {
 532             RemoveEntryList(&Hook->Entry);
 533             RtlFreeHeap(RtlGetProcessHeap(), 0, Hook);
 534         }
 535
 536         return FALSE;
 537     }
 538
 539     /* Increase the number of pages this hook has */
 540     Hook->Count += LastPage - FirstPage + 1;
 541
 542     /* Add the hook entry to the page table */
 543     for (i = FirstPage; i <= LastPage; i++) PageTable[i] = Hook;
 544
 545     return TRUE;
 546 }
 547
 548 BOOL
 549 WINAPI
 550 VDDDeInstallMemoryHook(IN HANDLE hVdd,
 551                        IN PVOID  pStart,
 552                        IN DWORD  dwCount)
 553 {
 554     NTSTATUS Status;
 555     PMEM_HOOK Hook;
 556     ULONG i;
 557     ULONG FirstPage = (ULONG_PTR)PHYS_TO_REAL(pStart) >> 12;
 558     ULONG LastPage = ((ULONG_PTR)PHYS_TO_REAL(pStart) + dwCount - 1) >> 12;
 559     PVOID Address = (PVOID)REAL_TO_PHYS(FirstPage * PAGE_SIZE);
 560     SIZE_T Size = (LastPage - FirstPage + 1) * PAGE_SIZE;
 561
 562     /* Check validity of the VDD handle */
 563     if (hVdd == NULL || hVdd == INVALID_HANDLE_VALUE)
 564     {
 565         SetLastError(ERROR_INVALID_PARAMETER);
 566         return FALSE;
 567     }
 568
 569     if (dwCount == 0) return FALSE;
 570
 571     /* Commit the pages */
 572     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 573                                      &Address,
 574                                      0,
 575                                      &Size,
 576                                      MEM_COMMIT,
 577                                      PAGE_READWRITE);
 578     if (!NT_SUCCESS(Status)) return FALSE;
 579
 580     for (i = FirstPage; i <= LastPage; i++)
 581     {
 582         Hook = PageTable[i];
 583         if (Hook == NULL) continue;
 584
 585         if (Hook->hVdd != hVdd)
 586         {
 587             DPRINT1("VDDDeInstallMemoryHook: Page %u owned by someone else.\n", i);
 588             continue;
 589         }
 590
 591         if (--Hook->Count == 0)
 592         {
 593             /* This hook has no more pages */
 594             RemoveEntryList(&Hook->Entry);
 595             RtlFreeHeap(RtlGetProcessHeap(), 0, Hook);
 596         }
 597
 598         PageTable[i] = NULL;
 599     }
 600
 601     return TRUE;
 602 }
 603
 604 BOOL
 605 WINAPI
 606 VDDAllocMem(IN HANDLE hVdd,
 607             IN PVOID  Address,
 608             IN ULONG  Size)
 609 {
 610     NTSTATUS Status;
 611     PMEM_HOOK Hook;
 612     ULONG i;
 613     ULONG FirstPage = (ULONG_PTR)PHYS_TO_REAL(Address) >> 12;
 614     ULONG LastPage = ((ULONG_PTR)PHYS_TO_REAL(Address) + Size - 1) >> 12;
 615     SIZE_T RealSize = (LastPage - FirstPage + 1) * PAGE_SIZE;
 616
 617     /* Check validity of the VDD handle */
 618     if (hVdd == NULL || hVdd == INVALID_HANDLE_VALUE)
 619     {
 620         SetLastError(ERROR_INVALID_PARAMETER);
 621         return FALSE;
 622     }
 623
 624     if (Size == 0) return FALSE;
 625
 626     /* Fixup the address */
 627     Address = (PVOID)REAL_TO_PHYS(FirstPage * PAGE_SIZE);
 628
 629     /* Be sure that all the region is held by the VDD */
 630     for (i = FirstPage; i <= LastPage; i++)
 631     {
 632         Hook = PageTable[i];
 633         if (Hook == NULL) return FALSE;
 634
 635         if (Hook->hVdd != hVdd)
 636         {
 637             DPRINT1("VDDAllocMem: Page %u owned by someone else.\n", i);
 638             return FALSE;
 639         }
 640     }
 641
 642     /* OK, all the range is held by the VDD. Commit the pages. */
 643     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 644                                      &Address,
 645                                      0,
 646                                      &RealSize,
 647                                      MEM_COMMIT,
 648                                      PAGE_READWRITE);
 649     return NT_SUCCESS(Status);
 650 }
 651
 652 BOOL
 653 WINAPI
 654 VDDFreeMem(IN HANDLE hVdd,
 655            IN PVOID  Address,
 656            IN ULONG  Size)
 657 {
 658     NTSTATUS Status;
 659     PMEM_HOOK Hook;
 660     ULONG i;
 661     ULONG FirstPage = (ULONG_PTR)PHYS_TO_REAL(Address) >> 12;
 662     ULONG LastPage = ((ULONG_PTR)PHYS_TO_REAL(Address) + Size - 1) >> 12;
 663     SIZE_T RealSize = (LastPage - FirstPage + 1) * PAGE_SIZE;
 664
 665     /* Check validity of the VDD handle */
 666     if (hVdd == NULL || hVdd == INVALID_HANDLE_VALUE)
 667     {
 668         SetLastError(ERROR_INVALID_PARAMETER);
 669         return FALSE;
 670     }
 671
 672     if (Size == 0) return FALSE;
 673
 674     /* Fixup the address */
 675     Address = (PVOID)REAL_TO_PHYS(FirstPage * PAGE_SIZE);
 676
 677     /* Be sure that all the region is held by the VDD */
 678     for (i = FirstPage; i <= LastPage; i++)
 679     {
 680         Hook = PageTable[i];
 681         if (Hook == NULL) return FALSE;
 682
 683         if (Hook->hVdd != hVdd)
 684         {
 685             DPRINT1("VDDFreeMem: Page %u owned by someone else.\n", i);
 686             return FALSE;
 687         }
 688     }
 689
 690     /* OK, all the range is held by the VDD. Decommit the pages. */
 691     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 692                                  &Address,
 693                                  &RealSize,
 694                                  MEM_DECOMMIT);
 695     return NT_SUCCESS(Status);
 696 }
 697
 698 BOOL
 699 WINAPI
 700 VDDIncludeMem(IN HANDLE hVdd,
 701               IN PVOID  Address,
 702               IN ULONG  Size)
 703 {
 704     // FIXME
 705     UNIMPLEMENTED;
 706     return FALSE;
 707 }
 708
 709 BOOL
 710 WINAPI
 711 VDDExcludeMem(IN HANDLE hVdd,
 712               IN PVOID  Address,
 713               IN ULONG  Size)
 714 {
 715     // FIXME
 716     UNIMPLEMENTED;
 717     return FALSE;
 718 }
 719
 720
 721
 722 BOOLEAN
 723 MemInitialize(VOID)
 724 {
 725     NTSTATUS Status;
 726     SIZE_T MemorySize = MAX_ADDRESS; // See: kernel32/client/vdm.c!BaseGetVdmConfigInfo
 727
 728     InitializeListHead(&HookList);
 729
 730 #ifndef STANDALONE
 731
 732     /*
 733      * The reserved region starts from the very first page.
 734      * We need to commit the reserved first 16 MB virtual address.
 735      *
 736      * NOTE: NULL has another signification for NtAllocateVirtualMemory.
 737      */
 738     BaseAddress = (PVOID)1;
 739
 740     /*
 741      * Since to get NULL, we allocated from 0x1, account for this.
 742      * See also: kernel32/client/proc.c!CreateProcessInternalW
 743      */
 744     MemorySize -= 1;
 745
 746 #else
 747
 748     /* Allocate it anywhere */
 749     BaseAddress = NULL;
 750
 751 #endif
 752
 753     Status = NtAllocateVirtualMemory(NtCurrentProcess(),
 754                                      &BaseAddress,
 755                                      0,
 756                                      &MemorySize,
 757 #ifndef STANDALONE
 758                                      MEM_COMMIT,
 759 #else
 760                                      MEM_RESERVE | MEM_COMMIT,
 761 #endif
 762                                      PAGE_EXECUTE_READWRITE);
 763     if (!NT_SUCCESS(Status))
 764     {
 765         wprintf(L"FATAL: Failed to commit VDM memory, Status 0x%08lx\n", Status);
 766         return FALSE;
 767     }
 768
 769 #ifndef STANDALONE
 770     ASSERT(BaseAddress == NULL);
 771 #endif
 772
 773     /*
 774      * For diagnostics purposes, we fill the memory with INT 0x03 codes
 775      * so that if a program wants to execute random code in memory, we can
 776      * retrieve the exact CS:IP where the problem happens.
 777      */
 778     RtlFillMemory(BaseAddress, MAX_ADDRESS, 0xCC);
 779     return TRUE;
 780 }
 781
 782 VOID
 783 MemCleanup(VOID)
 784 {
 785     NTSTATUS Status;
 786     SIZE_T MemorySize = MAX_ADDRESS;
 787     PLIST_ENTRY Pointer;
 788
 789     while (!IsListEmpty(&HookList))
 790     {
 791         Pointer = RemoveHeadList(&HookList);
 792         RtlFreeHeap(RtlGetProcessHeap(), 0, CONTAINING_RECORD(Pointer, MEM_HOOK, Entry));
 793     }
 794
 795     /* Decommit the VDM memory */
 796     Status = NtFreeVirtualMemory(NtCurrentProcess(),
 797                                  &BaseAddress,
 798                                  &MemorySize,
 799 #ifndef STANDALONE
 800                                  MEM_DECOMMIT
 801 #else
 802                                  MEM_RELEASE
 803 #endif
 804                                  );
 805     if (!NT_SUCCESS(Status))
 806     {
 807         DPRINT1("NTVDM: Failed to decommit VDM memory, Status 0x%08lx\n", Status);
 808     }
 809 }
 810
 811 /* EOF */