dlls/wow64/virtual.c

   1 /*
   2  * WoW64 virtual memory functions
   3  *
   4  * Copyright 2021 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdarg.h>
  22
  23 #include "ntstatus.h"
  24 #define WIN32_NO_STATUS
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winnt.h"
  28 #include "winternl.h"
  29 #include "winioctl.h"
  30 #include "wow64_private.h"
  31 #include "wine/debug.h"
  32
  33 WINE_DEFAULT_DEBUG_CHANNEL(wow);
  34
  35 static BOOL WINAPIV send_cross_process_notification( HANDLE process, UINT id, const void *addr, SIZE_T size,
  36                                                      int nb_args, ... )
  37 {
  38     CROSS_PROCESS_WORK_LIST *list;
  39     CROSS_PROCESS_WORK_ENTRY *entry;
  40     void *unused;
  41     HANDLE section;
  42     va_list args;
  43     int i;
  44
  45     RtlOpenCrossProcessEmulatorWorkConnection( process, &section, (void **)&list );
  46     if (!list) return FALSE;
  47     if ((entry = RtlWow64PopCrossProcessWorkFromFreeList( &list->free_list )))
  48     {
  49         entry->id = id;
  50         entry->addr = (ULONG_PTR)addr;
  51         entry->size = size;
  52         if (nb_args)
  53         {
  54             va_start( args, nb_args );
  55             for (i = 0; i < nb_args; i++) entry->args[i] = va_arg( args, int );
  56             va_end( args );
  57         }
  58         RtlWow64PushCrossProcessWorkOntoWorkList( &list->work_list, entry, &unused );
  59     }
  60     NtUnmapViewOfSection( GetCurrentProcess(), list );
  61     NtClose( section );
  62     return TRUE;
  63 }
  64
  65
  66 static MEMORY_RANGE_ENTRY *memory_range_entry_array_32to64( const MEMORY_RANGE_ENTRY32 *addresses32,
  67                                                             ULONG count )
  68 {
  69     MEMORY_RANGE_ENTRY *addresses = Wow64AllocateTemp( sizeof(MEMORY_RANGE_ENTRY) * count );
  70     ULONG i;
  71
  72     for (i = 0; i < count; i++)
  73     {
  74         addresses[i].VirtualAddress = ULongToPtr( addresses32[i].VirtualAddress );
  75         addresses[i].NumberOfBytes = addresses32[i].NumberOfBytes;
  76     }
  77
  78     return addresses;
  79 }
  80
  81 static NTSTATUS mem_extended_parameters_32to64( MEM_EXTENDED_PARAMETER **ret_params,
  82                                                 const MEM_EXTENDED_PARAMETER32 *params32, ULONG *count,
  83                                                 BOOL set_limit )
  84 {
  85     ULONG i;
  86     MEM_EXTENDED_PARAMETER *params;
  87     MEM_ADDRESS_REQUIREMENTS *req;
  88     MEM_ADDRESS_REQUIREMENTS32 *req32 = NULL;
  89
  90     if (*count && !params32) return STATUS_INVALID_PARAMETER;
  91
  92     params = Wow64AllocateTemp( (*count + 1) * sizeof(*params) + sizeof(*req) );
  93     req = (MEM_ADDRESS_REQUIREMENTS *)(params + *count + 1);
  94
  95     for (i = 0; i < *count; i++)
  96     {
  97         params[i].Type = params32[i].Type;
  98         params[i].Reserved = 0;
  99         switch (params[i].Type)
 100         {
 101         case MemExtendedParameterAddressRequirements:
 102             req32 = ULongToPtr( params32[i].Pointer );
 103             params[i].Pointer = req;
 104             break;
 105         case MemExtendedParameterAttributeFlags:
 106         case MemExtendedParameterNumaNode:
 107         case MemExtendedParameterImageMachine:
 108             params[i].ULong = params32[i].ULong;
 109             break;
 110         case MemExtendedParameterPartitionHandle:
 111         case MemExtendedParameterUserPhysicalHandle:
 112             params[i].Handle = ULongToHandle( params32[i].Handle );
 113             break;
 114         }
 115     }
 116
 117     if (req32)
 118     {
 119         if (req32->HighestEndingAddress > highest_user_address) return STATUS_INVALID_PARAMETER;
 120         req->LowestStartingAddress = ULongToPtr( req32->LowestStartingAddress );
 121         req->HighestEndingAddress  = ULongToPtr( req32->HighestEndingAddress );
 122         req->Alignment             = req32->Alignment;
 123     }
 124     else if (set_limit)
 125     {
 126         req->LowestStartingAddress = NULL;
 127         req->HighestEndingAddress  = (void *)highest_user_address;
 128         req->Alignment             = 0;
 129
 130         params[i].Type = MemExtendedParameterAddressRequirements;
 131         params[i].Reserved = 0;
 132         params[i].Pointer = req;
 133         *count = i + 1;
 134     }
 135     *ret_params = params;
 136     return STATUS_SUCCESS;
 137 }
 138
 139 /**********************************************************************
 140  *           wow64_NtAllocateVirtualMemory
 141  */
 142 NTSTATUS WINAPI wow64_NtAllocateVirtualMemory( UINT *args )
 143 {
 144     HANDLE process = get_handle( &args );
 145     ULONG *addr32 = get_ptr( &args );
 146     ULONG_PTR zero_bits = get_ulong( &args );
 147     ULONG *size32 = get_ptr( &args );
 148     ULONG type = get_ulong( &args );
 149     ULONG protect = get_ulong( &args );
 150
 151     void *addr = ULongToPtr( *addr32 );
 152     SIZE_T size = *size32;
 153     BOOL is_current = RtlIsCurrentProcess( process );
 154     NTSTATUS status;
 155
 156     if (!addr && (type & MEM_COMMIT)) type |= MEM_RESERVE;
 157
 158     if (!is_current) send_cross_process_notification( process, CrossProcessPreVirtualAlloc,
 159                                                       addr, size, 3, type, protect, 0 );
 160     else if (pBTCpuNotifyMemoryAlloc) pBTCpuNotifyMemoryAlloc( addr, size, type, protect, FALSE, 0 );
 161
 162     status = NtAllocateVirtualMemory( process, &addr, get_zero_bits( zero_bits ), &size, type, protect );
 163
 164     if (!is_current) send_cross_process_notification( process, CrossProcessPostVirtualAlloc,
 165                                                       addr, size, 3, type, protect, status );
 166     else if (pBTCpuNotifyMemoryAlloc) pBTCpuNotifyMemoryAlloc( addr, size, type, protect, TRUE, status );
 167
 168     if (!status)
 169     {
 170         put_addr( addr32, addr );
 171         put_size( size32, size );
 172     }
 173     return status;
 174 }
 175
 176
 177 /**********************************************************************
 178  *           wow64_NtAllocateVirtualMemoryEx
 179  */
 180 NTSTATUS WINAPI wow64_NtAllocateVirtualMemoryEx( UINT *args )
 181 {
 182     HANDLE process = get_handle( &args );
 183     ULONG *addr32 = get_ptr( &args );
 184     ULONG *size32 = get_ptr( &args );
 185     ULONG type = get_ulong( &args );
 186     ULONG protect = get_ulong( &args );
 187     MEM_EXTENDED_PARAMETER32 *params32 = get_ptr( &args );
 188     ULONG count = get_ulong( &args );
 189
 190     void *addr = ULongToPtr( *addr32 );
 191     SIZE_T size = *size32;
 192     NTSTATUS status;
 193     MEM_EXTENDED_PARAMETER *params64;
 194     BOOL is_current = RtlIsCurrentProcess( process );
 195     BOOL set_limit = (!*addr32 && is_current);
 196
 197     if (!addr) type |= MEM_RESERVE;
 198
 199     if ((status = mem_extended_parameters_32to64( &params64, params32, &count, set_limit ))) return status;
 200
 201     if (!is_current) send_cross_process_notification( process, CrossProcessPreVirtualAlloc,
 202                                                       addr, size, 3, type, protect, 0 );
 203     else if (pBTCpuNotifyMemoryAlloc) pBTCpuNotifyMemoryAlloc( addr, size, type, protect, FALSE, 0 );
 204
 205     status = NtAllocateVirtualMemoryEx( process, &addr, &size, type, protect, params64, count );
 206
 207     if (!is_current) send_cross_process_notification( process, CrossProcessPostVirtualAlloc,
 208                                                       addr, size, 3, type, protect, status );
 209     else if (pBTCpuNotifyMemoryAlloc) pBTCpuNotifyMemoryAlloc( addr, size, type, protect, TRUE, status );
 210
 211     if (!status)
 212     {
 213         put_addr( addr32, addr );
 214         put_size( size32, size );
 215     }
 216     return status;
 217 }
 218
 219
 220 /**********************************************************************
 221  *           wow64_NtAreMappedFilesTheSame
 222  */
 223 NTSTATUS WINAPI wow64_NtAreMappedFilesTheSame( UINT *args )
 224 {
 225     void *ptr1 = get_ptr( &args );
 226     void *ptr2 = get_ptr( &args );
 227
 228     return NtAreMappedFilesTheSame( ptr1, ptr2 );
 229 }
 230
 231
 232 /**********************************************************************
 233  *           wow64_NtFlushInstructionCache
 234  */
 235 NTSTATUS WINAPI wow64_NtFlushInstructionCache( UINT *args )
 236 {
 237     HANDLE process = get_handle( &args );
 238     const void *addr = get_ptr( &args );
 239     SIZE_T size = get_ulong( &args );
 240
 241     if (RtlIsCurrentProcess( process ))
 242     {
 243         if (pBTCpuFlushInstructionCache2) pBTCpuFlushInstructionCache2( addr, size );
 244     }
 245     else send_cross_process_notification( process, CrossProcessFlushCache, addr, size, 0 );
 246
 247     return NtFlushInstructionCache( process, addr, size );
 248 }
 249
 250
 251 /**********************************************************************
 252  *           wow64_NtFlushVirtualMemory
 253  */
 254 NTSTATUS WINAPI wow64_NtFlushVirtualMemory( UINT *args )
 255 {
 256     HANDLE process = get_handle( &args );
 257     ULONG *addr32 = get_ptr( &args );
 258     ULONG *size32 = get_ptr( &args );
 259     ULONG unknown = get_ulong( &args );
 260
 261     void *addr;
 262     SIZE_T size;
 263     NTSTATUS status;
 264
 265     status = NtFlushVirtualMemory( process, (const void **)addr_32to64( &addr, addr32 ),
 266                                    size_32to64( &size, size32 ), unknown );
 267     if (!status)
 268     {
 269         put_addr( addr32, addr );
 270         put_size( size32, size );
 271     }
 272     return status;
 273 }
 274
 275
 276 /**********************************************************************
 277  *           wow64_NtFreeVirtualMemory
 278  */
 279 NTSTATUS WINAPI wow64_NtFreeVirtualMemory( UINT *args )
 280 {
 281     HANDLE process = get_handle( &args );
 282     ULONG *addr32 = get_ptr( &args );
 283     ULONG *size32 = get_ptr( &args );
 284     ULONG type = get_ulong( &args );
 285
 286     void *addr = ULongToPtr( *addr32 );
 287     SIZE_T size = *size32;
 288     BOOL is_current = RtlIsCurrentProcess( process );
 289     NTSTATUS status;
 290
 291     if (!is_current) send_cross_process_notification( process, CrossProcessPreVirtualFree,
 292                                                       addr, size, 2, type, 0 );
 293     else if (pBTCpuNotifyMemoryFree) pBTCpuNotifyMemoryFree( addr, size, type, FALSE, 0 );
 294
 295     status = NtFreeVirtualMemory( process, &addr, &size, type );
 296
 297     if (!is_current) send_cross_process_notification( process, CrossProcessPostVirtualFree,
 298                                                       addr, size, 2, type, status );
 299     else if (pBTCpuNotifyMemoryFree) pBTCpuNotifyMemoryFree( addr, size, type, TRUE, status );
 300
 301     if (!status)
 302     {
 303         put_addr( addr32, addr );
 304         put_size( size32, size );
 305     }
 306     return status;
 307 }
 308
 309
 310 /**********************************************************************
 311  *           wow64_NtGetNlsSectionPtr
 312  */
 313 NTSTATUS WINAPI wow64_NtGetNlsSectionPtr( UINT *args )
 314 {
 315     ULONG type = get_ulong( &args );
 316     ULONG id = get_ulong( &args );
 317     void *unknown = get_ptr( &args );
 318     ULONG *addr32 = get_ptr( &args );
 319     ULONG *size32 = get_ptr( &args );
 320
 321     void *addr;
 322     SIZE_T size;
 323     NTSTATUS status;
 324
 325     status = NtGetNlsSectionPtr( type, id, unknown, addr_32to64( &addr, addr32 ),
 326                                  size_32to64( &size, size32 ));
 327     if (!status)
 328     {
 329         put_addr( addr32, addr );
 330         put_size( size32, size );
 331     }
 332     return status;
 333 }
 334
 335
 336 /**********************************************************************
 337  *           wow64_NtGetWriteWatch
 338  */
 339 NTSTATUS WINAPI wow64_NtGetWriteWatch( UINT *args )
 340 {
 341     HANDLE handle = get_handle( &args );
 342     ULONG flags = get_ulong( &args );
 343     void *base = get_ptr( &args );
 344     SIZE_T size = get_ulong( &args );
 345     ULONG *addr_ptr = get_ptr( &args );
 346     ULONG *count_ptr = get_ptr( &args );
 347     ULONG *granularity = get_ptr( &args );
 348
 349     ULONG_PTR i, count = *count_ptr;
 350     void **addresses;
 351     NTSTATUS status;
 352
 353     if (!count || !size) return STATUS_INVALID_PARAMETER;
 354     if (flags & ~WRITE_WATCH_FLAG_RESET) return STATUS_INVALID_PARAMETER;
 355     if (!addr_ptr) return STATUS_ACCESS_VIOLATION;
 356
 357     addresses = Wow64AllocateTemp( count * sizeof(*addresses) );
 358     if (!(status = NtGetWriteWatch( handle, flags, base, size, addresses, &count, granularity )))
 359     {
 360         for (i = 0; i < count; i++) addr_ptr[i] = PtrToUlong( addresses[i] );
 361         *count_ptr = count;
 362     }
 363     return status;
 364 }
 365
 366
 367 /**********************************************************************
 368  *           wow64_NtInitializeNlsFiles
 369  */
 370 NTSTATUS WINAPI wow64_NtInitializeNlsFiles( UINT *args )
 371 {
 372     ULONG *addr32 = get_ptr( &args );
 373     LCID *lcid = get_ptr( &args );
 374     LARGE_INTEGER *size = get_ptr( &args );
 375
 376     void *addr;
 377     NTSTATUS status;
 378
 379     status = NtInitializeNlsFiles( addr_32to64( &addr, addr32 ), lcid, size );
 380     if (!status) put_addr( addr32, addr );
 381     return status;
 382 }
 383
 384
 385 /**********************************************************************
 386  *           wow64_NtLockVirtualMemory
 387  */
 388 NTSTATUS WINAPI wow64_NtLockVirtualMemory( UINT *args )
 389 {
 390     HANDLE process = get_handle( &args );
 391     ULONG *addr32 = get_ptr( &args );
 392     ULONG *size32 = get_ptr( &args );
 393     ULONG unknown = get_ulong( &args );
 394
 395     void *addr;
 396     SIZE_T size;
 397     NTSTATUS status;
 398
 399     status = NtLockVirtualMemory( process, addr_32to64( &addr, addr32 ),
 400                                   size_32to64( &size, size32 ), unknown );
 401     if (!status)
 402     {
 403         put_addr( addr32, addr );
 404         put_size( size32, size );
 405     }
 406     return status;
 407 }
 408
 409
 410 static void notify_map_view_of_section( HANDLE handle, void *addr, SIZE_T size, ULONG alloc,
 411                                         ULONG protect, NTSTATUS *ret_status )
 412 {
 413     SECTION_IMAGE_INFORMATION info;
 414     NTSTATUS status;
 415
 416     if (!NtCurrentTeb()->Tib.ArbitraryUserPointer) return;
 417     if (NtQuerySection( handle, SectionImageInformation, &info, sizeof(info), NULL )) return;
 418     if (info.Machine != current_machine) return;
 419     init_image_mapping( addr );
 420     if (!pBTCpuNotifyMapViewOfSection) return;
 421     status = pBTCpuNotifyMapViewOfSection( NULL, addr, NULL, size, alloc, protect );
 422     if (NT_SUCCESS(status)) return;
 423     NtUnmapViewOfSection( GetCurrentProcess(), addr );
 424     *ret_status = status;
 425 }
 426
 427 /**********************************************************************
 428  *           wow64_NtMapViewOfSection
 429  */
 430 NTSTATUS WINAPI wow64_NtMapViewOfSection( UINT *args )
 431 {
 432     HANDLE handle = get_handle( &args );
 433     HANDLE process = get_handle( &args );
 434     ULONG *addr32 = get_ptr( &args );
 435     ULONG_PTR zero_bits = get_ulong( &args );
 436     SIZE_T commit = get_ulong( &args );
 437     const LARGE_INTEGER *offset = get_ptr( &args );
 438     ULONG *size32 = get_ptr( &args );
 439     SECTION_INHERIT inherit = get_ulong( &args );
 440     ULONG alloc = get_ulong( &args );
 441     ULONG protect = get_ulong( &args );
 442
 443     void *addr;
 444     SIZE_T size;
 445     NTSTATUS status;
 446     void *prev = NtCurrentTeb()->Tib.ArbitraryUserPointer;
 447
 448     NtCurrentTeb()->Tib.ArbitraryUserPointer = ULongToPtr( NtCurrentTeb32()->Tib.ArbitraryUserPointer );
 449     status = NtMapViewOfSection( handle, process, addr_32to64( &addr, addr32 ), get_zero_bits( zero_bits ),
 450                                  commit, offset, size_32to64( &size, size32 ), inherit, alloc, protect );
 451     if (NT_SUCCESS(status))
 452     {
 453         put_addr( addr32, addr );
 454         put_size( size32, size );
 455         if (RtlIsCurrentProcess( process ))
 456             notify_map_view_of_section( handle, addr, size, alloc, protect, &status );
 457     }
 458     NtCurrentTeb()->Tib.ArbitraryUserPointer = prev;
 459     return status;
 460 }
 461
 462 /**********************************************************************
 463  *           wow64_NtMapViewOfSectionEx
 464  */
 465 NTSTATUS WINAPI wow64_NtMapViewOfSectionEx( UINT *args )
 466 {
 467     HANDLE handle = get_handle( &args );
 468     HANDLE process = get_handle( &args );
 469     ULONG *addr32 = get_ptr( &args );
 470     const LARGE_INTEGER *offset = get_ptr( &args );
 471     ULONG *size32 = get_ptr( &args );
 472     ULONG alloc = get_ulong( &args );
 473     ULONG protect = get_ulong( &args );
 474     MEM_EXTENDED_PARAMETER32 *params32 = get_ptr( &args );
 475     ULONG count = get_ulong( &args );
 476
 477     void *addr;
 478     SIZE_T size;
 479     NTSTATUS status;
 480     MEM_EXTENDED_PARAMETER *params64;
 481     BOOL is_current = RtlIsCurrentProcess( process );
 482     BOOL set_limit = (!*addr32 && is_current);
 483     void *prev = NtCurrentTeb()->Tib.ArbitraryUserPointer;
 484
 485     if ((status = mem_extended_parameters_32to64( &params64, params32, &count, set_limit ))) return status;
 486
 487     NtCurrentTeb()->Tib.ArbitraryUserPointer = ULongToPtr( NtCurrentTeb32()->Tib.ArbitraryUserPointer );
 488     status = NtMapViewOfSectionEx( handle, process, addr_32to64( &addr, addr32 ), offset,
 489                                    size_32to64( &size, size32 ), alloc, protect, params64, count );
 490     if (NT_SUCCESS(status))
 491     {
 492         put_addr( addr32, addr );
 493         put_size( size32, size );
 494         if (is_current) notify_map_view_of_section( handle, addr, size, alloc, protect, &status );
 495     }
 496     NtCurrentTeb()->Tib.ArbitraryUserPointer = prev;
 497     return status;
 498 }
 499
 500 /**********************************************************************
 501  *           wow64_NtProtectVirtualMemory
 502  */
 503 NTSTATUS WINAPI wow64_NtProtectVirtualMemory( UINT *args )
 504 {
 505     HANDLE process = get_handle( &args );
 506     ULONG *addr32 = get_ptr( &args );
 507     ULONG *size32 = get_ptr( &args );
 508     ULONG new_prot = get_ulong( &args );
 509     ULONG *old_prot = get_ptr( &args );
 510
 511     void *addr = ULongToPtr( *addr32 );
 512     SIZE_T size = *size32;
 513     BOOL is_current = RtlIsCurrentProcess( process );
 514     NTSTATUS status;
 515
 516     if (!is_current) send_cross_process_notification( process, CrossProcessPreVirtualProtect,
 517                                                       addr, size, 2, new_prot, 0 );
 518     else if (pBTCpuNotifyMemoryProtect) pBTCpuNotifyMemoryProtect( addr, size, new_prot, FALSE, 0 );
 519
 520     status = NtProtectVirtualMemory( process, &addr, &size, new_prot, old_prot );
 521
 522     if (!is_current) send_cross_process_notification( process, CrossProcessPostVirtualProtect,
 523                                                       addr, size, 2, new_prot, status );
 524     else if (pBTCpuNotifyMemoryProtect) pBTCpuNotifyMemoryProtect( addr, size, new_prot, TRUE, status );
 525
 526     if (!status)
 527     {
 528         put_addr( addr32, addr );
 529         put_size( size32, size );
 530     }
 531     return status;
 532 }
 533
 534
 535 /**********************************************************************
 536  *           wow64_NtQueryVirtualMemory
 537  */
 538 NTSTATUS WINAPI wow64_NtQueryVirtualMemory( UINT *args )
 539 {
 540     HANDLE handle = get_handle( &args );
 541     void *addr = get_ptr( &args );
 542     MEMORY_INFORMATION_CLASS class = get_ulong( &args );
 543     void *ptr = get_ptr( &args );
 544     ULONG len = get_ulong( &args );
 545     ULONG *retlen = get_ptr( &args );
 546
 547     SIZE_T res_len = 0;
 548     NTSTATUS status;
 549
 550     switch (class)
 551     {
 552     case MemoryBasicInformation:  /* MEMORY_BASIC_INFORMATION */
 553         if (len < sizeof(MEMORY_BASIC_INFORMATION32))
 554             status = STATUS_INFO_LENGTH_MISMATCH;
 555         else if ((ULONG_PTR)addr > highest_user_address)
 556             status = STATUS_INVALID_PARAMETER;
 557         else
 558         {
 559             MEMORY_BASIC_INFORMATION info;
 560             MEMORY_BASIC_INFORMATION32 *info32 = ptr;
 561
 562             if (!(status = NtQueryVirtualMemory( handle, addr, class, &info, sizeof(info), &res_len )))
 563             {
 564                 info32->BaseAddress = PtrToUlong( info.BaseAddress );
 565                 info32->AllocationBase = PtrToUlong( info.AllocationBase );
 566                 info32->AllocationProtect = info.AllocationProtect;
 567                 info32->RegionSize = info.RegionSize;
 568                 info32->State = info.State;
 569                 info32->Protect = info.Protect;
 570                 info32->Type = info.Type;
 571                 if ((ULONG_PTR)info.BaseAddress + info.RegionSize > highest_user_address)
 572                     info32->RegionSize = highest_user_address - (ULONG_PTR)info.BaseAddress + 1;
 573             }
 574         }
 575         res_len = sizeof(MEMORY_BASIC_INFORMATION32);
 576         break;
 577
 578     case MemoryMappedFilenameInformation:  /* MEMORY_SECTION_NAME */
 579     {
 580         MEMORY_SECTION_NAME *info;
 581         MEMORY_SECTION_NAME32 *info32 = ptr;
 582         SIZE_T size = len + sizeof(*info) - sizeof(*info32);
 583
 584         info = Wow64AllocateTemp( size );
 585         if (!(status = NtQueryVirtualMemory( handle, addr, class, info, size, &res_len )))
 586         {
 587             info32->SectionFileName.Length = info->SectionFileName.Length;
 588             info32->SectionFileName.MaximumLength = info->SectionFileName.MaximumLength;
 589             info32->SectionFileName.Buffer = PtrToUlong( info32 + 1 );
 590             memcpy( info32 + 1, info->SectionFileName.Buffer, info->SectionFileName.MaximumLength );
 591         }
 592         res_len += sizeof(*info32) - sizeof(*info);
 593         break;
 594     }
 595
 596     case MemoryRegionInformation: /* MEMORY_REGION_INFORMATION */
 597     {
 598         if (len < sizeof(MEMORY_REGION_INFORMATION32))
 599             status = STATUS_INFO_LENGTH_MISMATCH;
 600         else if ((ULONG_PTR)addr > highest_user_address)
 601             status = STATUS_INVALID_PARAMETER;
 602         else
 603         {
 604             MEMORY_REGION_INFORMATION info;
 605             MEMORY_REGION_INFORMATION32 *info32 = ptr;
 606
 607             if (!(status = NtQueryVirtualMemory( handle, addr, class, &info, sizeof(info), &res_len )))
 608             {
 609                 info32->AllocationBase = PtrToUlong( info.AllocationBase );
 610                 info32->AllocationProtect = info.AllocationProtect;
 611                 info32->RegionType = info.RegionType;
 612                 info32->RegionSize = info.RegionSize;
 613                 info32->CommitSize = info.CommitSize;
 614                 info32->PartitionId = info.PartitionId;
 615                 info32->NodePreference = info.NodePreference;
 616                 if ((ULONG_PTR)info.AllocationBase + info.RegionSize > highest_user_address)
 617                     info32->RegionSize = highest_user_address - (ULONG_PTR)info.AllocationBase + 1;
 618             }
 619         }
 620         res_len = sizeof(MEMORY_REGION_INFORMATION32);
 621         break;
 622     }
 623
 624     case MemoryWorkingSetExInformation:  /* MEMORY_WORKING_SET_EX_INFORMATION */
 625     {
 626         MEMORY_WORKING_SET_EX_INFORMATION32 *info32 = ptr;
 627         MEMORY_WORKING_SET_EX_INFORMATION *info;
 628         ULONG i, count = len / sizeof(*info32);
 629
 630         if (len < sizeof(*info32)) return STATUS_INFO_LENGTH_MISMATCH;
 631
 632         info = Wow64AllocateTemp( count * sizeof(*info) );
 633         for (i = 0; i < count; i++) info[i].VirtualAddress = ULongToPtr( info32[i].VirtualAddress );
 634         if (!(status = NtQueryVirtualMemory( handle, addr, class, info, count * sizeof(*info), &res_len )))
 635         {
 636             count = res_len / sizeof(*info);
 637             for (i = 0; i < count; i++) info32[i].VirtualAttributes.Flags = info[i].VirtualAttributes.Flags;
 638             res_len = count * sizeof(*info32);
 639         }
 640         break;
 641     }
 642
 643     case MemoryImageInformation: /* MEMORY_IMAGE_INFORMATION */
 644     {
 645         if (len < sizeof(MEMORY_IMAGE_INFORMATION32)) return STATUS_INFO_LENGTH_MISMATCH;
 646
 647         if ((ULONG_PTR)addr > highest_user_address) status = STATUS_INVALID_PARAMETER;
 648         else
 649         {
 650             MEMORY_IMAGE_INFORMATION info;
 651             MEMORY_IMAGE_INFORMATION32 *info32 = ptr;
 652
 653             if (!(status = NtQueryVirtualMemory( handle, addr, class, &info, sizeof(info), &res_len )))
 654             {
 655                 info32->ImageBase   = PtrToUlong( info.ImageBase );
 656                 info32->SizeOfImage = info.SizeOfImage;
 657                 info32->ImageFlags  = info.ImageFlags;
 658             }
 659         }
 660         res_len = sizeof(MEMORY_IMAGE_INFORMATION32);
 661         break;
 662     }
 663
 664     case MemoryWineUnixWow64Funcs:
 665         return STATUS_INVALID_INFO_CLASS;
 666
 667     case MemoryWineUnixFuncs:
 668         status = NtQueryVirtualMemory( handle, addr, MemoryWineUnixWow64Funcs, ptr, len, &res_len );
 669         break;
 670
 671     default:
 672         FIXME( "unsupported class %u\n", class );
 673         return STATUS_INVALID_INFO_CLASS;
 674     }
 675     if (!status || status == STATUS_INFO_LENGTH_MISMATCH) put_size( retlen, res_len );
 676     return status;
 677 }
 678
 679
 680 /**********************************************************************
 681  *           wow64_NtReadVirtualMemory
 682  */
 683 NTSTATUS WINAPI wow64_NtReadVirtualMemory( UINT *args )
 684 {
 685     HANDLE process = get_handle( &args );
 686     const void *addr = get_ptr( &args );
 687     void *buffer = get_ptr( &args );
 688     SIZE_T size = get_ulong( &args );
 689     ULONG *retlen = get_ptr( &args );
 690
 691     SIZE_T ret_size;
 692     NTSTATUS status;
 693
 694     status = NtReadVirtualMemory( process, addr, buffer, size, &ret_size );
 695     put_size( retlen, ret_size );
 696     return status;
 697 }
 698
 699
 700 /**********************************************************************
 701  *           wow64_NtResetWriteWatch
 702  */
 703 NTSTATUS WINAPI wow64_NtResetWriteWatch( UINT *args )
 704 {
 705     HANDLE process = get_handle( &args );
 706     void *base = get_ptr( &args );
 707     SIZE_T size = get_ulong( &args );
 708
 709     return NtResetWriteWatch( process, base, size );
 710 }
 711
 712
 713 /**********************************************************************
 714  *           wow64_NtSetInformationVirtualMemory
 715  */
 716 NTSTATUS WINAPI wow64_NtSetInformationVirtualMemory( UINT *args )
 717 {
 718     HANDLE process = get_handle( &args );
 719     VIRTUAL_MEMORY_INFORMATION_CLASS info_class = get_ulong( &args );
 720     ULONG count = get_ulong( &args );
 721     MEMORY_RANGE_ENTRY32 *addresses32 = get_ptr( &args );
 722     PVOID ptr = get_ptr( &args );
 723     ULONG len = get_ulong( &args );
 724
 725     MEMORY_RANGE_ENTRY *addresses;
 726
 727     if (!count) return STATUS_INVALID_PARAMETER_3;
 728     addresses = memory_range_entry_array_32to64( addresses32, count );
 729
 730     switch (info_class)
 731     {
 732     case VmPrefetchInformation:
 733         break;
 734     default:
 735         FIXME( "(%p,info_class=%u,%lu,%p,%p,%lu): not implemented\n",
 736                process, info_class, count, addresses32, ptr, len );
 737         return STATUS_INVALID_PARAMETER_2;
 738     }
 739
 740     return NtSetInformationVirtualMemory( process, info_class, count, addresses, ptr, len );
 741 }
 742
 743
 744 /**********************************************************************
 745  *           wow64_NtSetLdtEntries
 746  */
 747 NTSTATUS WINAPI wow64_NtSetLdtEntries( UINT *args )
 748 {
 749     ULONG sel1 = get_ulong( &args );
 750     ULONG entry1_low = get_ulong( &args );
 751     ULONG entry1_high = get_ulong( &args );
 752     ULONG sel2 = get_ulong( &args );
 753     ULONG entry2_low = get_ulong( &args );
 754     ULONG entry2_high = get_ulong( &args );
 755
 756     FIXME( "%04lx %08lx %08lx %04lx %08lx %08lx: stub\n",
 757            sel1, entry1_low, entry1_high, sel2, entry2_low, entry2_high );
 758     return STATUS_NOT_IMPLEMENTED;
 759 }
 760
 761
 762 /**********************************************************************
 763  *           wow64_NtUnlockVirtualMemory
 764  */
 765 NTSTATUS WINAPI wow64_NtUnlockVirtualMemory( UINT *args )
 766 {
 767     HANDLE process = get_handle( &args );
 768     ULONG *addr32 = get_ptr( &args );
 769     ULONG *size32 = get_ptr( &args );
 770     ULONG unknown = get_ulong( &args );
 771
 772     void *addr;
 773     SIZE_T size;
 774     NTSTATUS status;
 775
 776     status = NtUnlockVirtualMemory( process, addr_32to64( &addr, addr32 ),
 777                                     size_32to64( &size, size32 ), unknown );
 778     if (!status)
 779     {
 780         put_addr( addr32, addr );
 781         put_size( size32, size );
 782     }
 783     return status;
 784 }
 785
 786
 787 /**********************************************************************
 788  *           wow64_NtUnmapViewOfSection
 789  */
 790 NTSTATUS WINAPI wow64_NtUnmapViewOfSection( UINT *args )
 791 {
 792     HANDLE process = get_handle( &args );
 793     void *addr = get_ptr( &args );
 794
 795     BOOL is_current = RtlIsCurrentProcess( process );
 796     NTSTATUS status;
 797
 798     if (is_current && pBTCpuNotifyUnmapViewOfSection) pBTCpuNotifyUnmapViewOfSection( addr, FALSE, 0 );
 799     status = NtUnmapViewOfSection( process, addr );
 800     if (is_current && pBTCpuNotifyUnmapViewOfSection) pBTCpuNotifyUnmapViewOfSection( addr, TRUE, status );
 801     return status;
 802 }
 803
 804
 805 /**********************************************************************
 806  *           wow64_NtUnmapViewOfSectionEx
 807  */
 808 NTSTATUS WINAPI wow64_NtUnmapViewOfSectionEx( UINT *args )
 809 {
 810     HANDLE process = get_handle( &args );
 811     void *addr = get_ptr( &args );
 812     ULONG flags = get_ulong( &args );
 813
 814     BOOL is_current = RtlIsCurrentProcess( process );
 815     NTSTATUS status;
 816
 817     if (is_current && pBTCpuNotifyUnmapViewOfSection) pBTCpuNotifyUnmapViewOfSection( addr, FALSE, 0 );
 818     status = NtUnmapViewOfSectionEx( process, addr, flags );
 819     if (is_current && pBTCpuNotifyUnmapViewOfSection) pBTCpuNotifyUnmapViewOfSection( addr, TRUE, status );
 820     return status;
 821 }
 822
 823
 824 /**********************************************************************
 825  *           wow64_NtWow64AllocateVirtualMemory64
 826  */
 827 NTSTATUS WINAPI wow64_NtWow64AllocateVirtualMemory64( UINT *args )
 828 {
 829     HANDLE process = get_handle( &args );
 830     void **addr = get_ptr( &args );
 831     ULONG_PTR zero_bits = get_ulong64( &args );
 832     SIZE_T *size = get_ptr( &args );
 833     ULONG type = get_ulong( &args );
 834     ULONG protect = get_ulong( &args );
 835
 836     return NtAllocateVirtualMemory( process, addr, zero_bits, size, type, protect );
 837 }
 838
 839
 840 /**********************************************************************
 841  *           wow64_NtWow64ReadVirtualMemory64
 842  */
 843 NTSTATUS WINAPI wow64_NtWow64ReadVirtualMemory64( UINT *args )
 844 {
 845     HANDLE process = get_handle( &args );
 846     void *addr = (void *)(ULONG_PTR)get_ulong64( &args );
 847     void *buffer = get_ptr( &args );
 848     SIZE_T size = get_ulong64( &args );
 849     SIZE_T *ret_size = get_ptr( &args );
 850
 851     return NtReadVirtualMemory( process, addr, buffer, size, ret_size );
 852 }
 853
 854
 855 /**********************************************************************
 856  *           wow64_NtWow64WriteVirtualMemory64
 857  */
 858 NTSTATUS WINAPI wow64_NtWow64WriteVirtualMemory64( UINT *args )
 859 {
 860     HANDLE process = get_handle( &args );
 861     void *addr = (void *)(ULONG_PTR)get_ulong64( &args );
 862     const void *buffer = get_ptr( &args );
 863     SIZE_T size = get_ulong64( &args );
 864     SIZE_T *ret_size = get_ptr( &args );
 865
 866     return NtWriteVirtualMemory( process, addr, buffer, size, ret_size );
 867 }
 868
 869
 870 /**********************************************************************
 871  *           wow64_NtWriteVirtualMemory
 872  */
 873 NTSTATUS WINAPI wow64_NtWriteVirtualMemory( UINT *args )
 874 {
 875     HANDLE process = get_handle( &args );
 876     void *addr = get_ptr( &args );
 877     const void *buffer = get_ptr( &args );
 878     SIZE_T size = get_ulong( &args );
 879     ULONG *retlen = get_ptr( &args );
 880
 881     SIZE_T ret_size;
 882     NTSTATUS status;
 883
 884     status = NtWriteVirtualMemory( process, addr, buffer, size, &ret_size );
 885     put_size( retlen, ret_size );
 886     return status;
 887 }