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
  36 static MEMORY_RANGE_ENTRY *memory_range_entry_array_32to64( const MEMORY_RANGE_ENTRY32 *addresses32,
  37                                                             ULONG count )
  38 {
  39     MEMORY_RANGE_ENTRY *addresses = Wow64AllocateTemp( sizeof(MEMORY_RANGE_ENTRY) * count );
  40     ULONG i;
  41
  42     for (i = 0; i < count; i++)
  43     {
  44         addresses[i].VirtualAddress = ULongToPtr( addresses32[i].VirtualAddress );
  45         addresses[i].NumberOfBytes = addresses32[i].NumberOfBytes;
  46     }
  47
  48     return addresses;
  49 }
  50
  51 /**********************************************************************
  52  *           wow64_NtAllocateVirtualMemory
  53  */
  54 NTSTATUS WINAPI wow64_NtAllocateVirtualMemory( UINT *args )
  55 {
  56     HANDLE process = get_handle( &args );
  57     ULONG *addr32 = get_ptr( &args );
  58     ULONG_PTR zero_bits = get_ulong( &args );
  59     ULONG *size32 = get_ptr( &args );
  60     ULONG type = get_ulong( &args );
  61     ULONG protect = get_ulong( &args );
  62
  63     void *addr;
  64     SIZE_T size;
  65     NTSTATUS status;
  66
  67     status = NtAllocateVirtualMemory( process, addr_32to64( &addr, addr32 ), get_zero_bits( zero_bits ),
  68                                       size_32to64( &size, size32 ), type, protect );
  69     if (!status)
  70     {
  71         put_addr( addr32, addr );
  72         put_size( size32, size );
  73     }
  74     return status;
  75 }
  76
  77
  78 /**********************************************************************
  79  *           wow64_NtAllocateVirtualMemoryEx
  80  */
  81 NTSTATUS WINAPI wow64_NtAllocateVirtualMemoryEx( UINT *args )
  82 {
  83     HANDLE process = get_handle( &args );
  84     ULONG *addr32 = get_ptr( &args );
  85     ULONG *size32 = get_ptr( &args );
  86     ULONG type = get_ulong( &args );
  87     ULONG protect = get_ulong( &args );
  88     MEM_EXTENDED_PARAMETER *params = get_ptr( &args );
  89     ULONG count = get_ulong( &args );
  90
  91     void *addr;
  92     SIZE_T size;
  93     NTSTATUS status;
  94     SIZE_T alloc_size = count * sizeof(*params);
  95     MEM_EXTENDED_PARAMETER *params64;
  96     BOOL set_highest_address = (!*addr32 && process == GetCurrentProcess());
  97     BOOL add_address_requirements = set_highest_address;
  98     MEM_ADDRESS_REQUIREMENTS *buf;
  99     unsigned int i;
 100
 101     if (count && !params) return STATUS_INVALID_PARAMETER;
 102
 103     for (i = 0; i < count; ++i)
 104     {
 105         if (params[i].Type == MemExtendedParameterAddressRequirements)
 106         {
 107             alloc_size += sizeof(MEM_ADDRESS_REQUIREMENTS);
 108             add_address_requirements = FALSE;
 109         }
 110         else if (params[i].Type && params[i].Type < MemExtendedParameterMax)
 111         {
 112             FIXME( "Unsupported parameter type %d.\n", params[i].Type);
 113         }
 114     }
 115
 116     if (add_address_requirements)
 117         alloc_size += sizeof(*params) + sizeof(MEM_ADDRESS_REQUIREMENTS);
 118     params64 = Wow64AllocateTemp( alloc_size );
 119     memcpy( params64, params, count * sizeof(*params64) );
 120     if (add_address_requirements)
 121     {
 122         buf = (MEM_ADDRESS_REQUIREMENTS *)((char *)params64 + (count + 1) * sizeof(*params64));
 123         params64[count].Type = MemExtendedParameterAddressRequirements;
 124         params64[count].Pointer = buf;
 125         memset(buf, 0, sizeof(*buf));
 126         buf->HighestEndingAddress = (void *)highest_user_address;
 127         ++buf;
 128     }
 129     else
 130     {
 131         buf = (MEM_ADDRESS_REQUIREMENTS *)((char *)params64 + count * sizeof(*params64));
 132     }
 133     for (i = 0; i < count; ++i)
 134     {
 135         if (params64[i].Type == MemExtendedParameterAddressRequirements)
 136         {
 137             MEM_ADDRESS_REQUIREMENTS32 *p = (MEM_ADDRESS_REQUIREMENTS32 *)params[i].Pointer;
 138
 139             buf->LowestStartingAddress = ULongToPtr(p->LowestStartingAddress);
 140             if (p->HighestEndingAddress)
 141             {
 142                 if (p->HighestEndingAddress > highest_user_address) return STATUS_INVALID_PARAMETER;
 143                 buf->HighestEndingAddress = ULongToPtr(p->HighestEndingAddress);
 144             }
 145             else
 146             {
 147                 buf->HighestEndingAddress = set_highest_address ? (void *)highest_user_address : NULL;
 148             }
 149             buf->Alignment = p->Alignment;
 150             params64[i].Pointer = buf;
 151             ++buf;
 152         }
 153     }
 154
 155     status = NtAllocateVirtualMemoryEx( process, addr_32to64( &addr, addr32 ), size_32to64( &size, size32 ),
 156                                         type, protect, params64, count + add_address_requirements );
 157     if (!status)
 158     {
 159         put_addr( addr32, addr );
 160         put_size( size32, size );
 161     }
 162     return status;
 163 }
 164
 165
 166 /**********************************************************************
 167  *           wow64_NtAreMappedFilesTheSame
 168  */
 169 NTSTATUS WINAPI wow64_NtAreMappedFilesTheSame( UINT *args )
 170 {
 171     void *ptr1 = get_ptr( &args );
 172     void *ptr2 = get_ptr( &args );
 173
 174     return NtAreMappedFilesTheSame( ptr1, ptr2 );
 175 }
 176
 177
 178 /**********************************************************************
 179  *           wow64_NtFlushVirtualMemory
 180  */
 181 NTSTATUS WINAPI wow64_NtFlushVirtualMemory( UINT *args )
 182 {
 183     HANDLE process = get_handle( &args );
 184     ULONG *addr32 = get_ptr( &args );
 185     ULONG *size32 = get_ptr( &args );
 186     ULONG unknown = get_ulong( &args );
 187
 188     void *addr;
 189     SIZE_T size;
 190     NTSTATUS status;
 191
 192     status = NtFlushVirtualMemory( process, (const void **)addr_32to64( &addr, addr32 ),
 193                                    size_32to64( &size, size32 ), unknown );
 194     if (!status)
 195     {
 196         put_addr( addr32, addr );
 197         put_size( size32, size );
 198     }
 199     return status;
 200 }
 201
 202
 203 /**********************************************************************
 204  *           wow64_NtFreeVirtualMemory
 205  */
 206 NTSTATUS WINAPI wow64_NtFreeVirtualMemory( UINT *args )
 207 {
 208     HANDLE process = get_handle( &args );
 209     ULONG *addr32 = get_ptr( &args );
 210     ULONG *size32 = get_ptr( &args );
 211     ULONG type = get_ulong( &args );
 212
 213     void *addr;
 214     SIZE_T size;
 215     NTSTATUS status;
 216
 217     status = NtFreeVirtualMemory( process, addr_32to64( &addr, addr32 ),
 218                                   size_32to64( &size, size32 ), type );
 219     if (!status)
 220     {
 221         put_addr( addr32, addr );
 222         put_size( size32, size );
 223     }
 224     return status;
 225 }
 226
 227
 228 /**********************************************************************
 229  *           wow64_NtGetNlsSectionPtr
 230  */
 231 NTSTATUS WINAPI wow64_NtGetNlsSectionPtr( UINT *args )
 232 {
 233     ULONG type = get_ulong( &args );
 234     ULONG id = get_ulong( &args );
 235     void *unknown = get_ptr( &args );
 236     ULONG *addr32 = get_ptr( &args );
 237     ULONG *size32 = get_ptr( &args );
 238
 239     void *addr;
 240     SIZE_T size;
 241     NTSTATUS status;
 242
 243     status = NtGetNlsSectionPtr( type, id, unknown, addr_32to64( &addr, addr32 ),
 244                                  size_32to64( &size, size32 ));
 245     if (!status)
 246     {
 247         put_addr( addr32, addr );
 248         put_size( size32, size );
 249     }
 250     return status;
 251 }
 252
 253
 254 /**********************************************************************
 255  *           wow64_NtGetWriteWatch
 256  */
 257 NTSTATUS WINAPI wow64_NtGetWriteWatch( UINT *args )
 258 {
 259     HANDLE handle = get_handle( &args );
 260     ULONG flags = get_ulong( &args );
 261     void *base = get_ptr( &args );
 262     SIZE_T size = get_ulong( &args );
 263     ULONG *addr_ptr = get_ptr( &args );
 264     ULONG *count_ptr = get_ptr( &args );
 265     ULONG *granularity = get_ptr( &args );
 266
 267     ULONG_PTR i, count = *count_ptr;
 268     void **addresses;
 269     NTSTATUS status;
 270
 271     if (!count || !size) return STATUS_INVALID_PARAMETER;
 272     if (flags & ~WRITE_WATCH_FLAG_RESET) return STATUS_INVALID_PARAMETER;
 273     if (!addr_ptr) return STATUS_ACCESS_VIOLATION;
 274
 275     addresses = Wow64AllocateTemp( count * sizeof(*addresses) );
 276     if (!(status = NtGetWriteWatch( handle, flags, base, size, addresses, &count, granularity )))
 277     {
 278         for (i = 0; i < count; i++) addr_ptr[i] = PtrToUlong( addresses[i] );
 279         *count_ptr = count;
 280     }
 281     return status;
 282 }
 283
 284
 285 /**********************************************************************
 286  *           wow64_NtInitializeNlsFiles
 287  */
 288 NTSTATUS WINAPI wow64_NtInitializeNlsFiles( UINT *args )
 289 {
 290     ULONG *addr32 = get_ptr( &args );
 291     LCID *lcid = get_ptr( &args );
 292     LARGE_INTEGER *size = get_ptr( &args );
 293
 294     void *addr;
 295     NTSTATUS status;
 296
 297     status = NtInitializeNlsFiles( addr_32to64( &addr, addr32 ), lcid, size );
 298     if (!status) put_addr( addr32, addr );
 299     return status;
 300 }
 301
 302
 303 /**********************************************************************
 304  *           wow64_NtLockVirtualMemory
 305  */
 306 NTSTATUS WINAPI wow64_NtLockVirtualMemory( UINT *args )
 307 {
 308     HANDLE process = get_handle( &args );
 309     ULONG *addr32 = get_ptr( &args );
 310     ULONG *size32 = get_ptr( &args );
 311     ULONG unknown = get_ulong( &args );
 312
 313     void *addr;
 314     SIZE_T size;
 315     NTSTATUS status;
 316
 317     status = NtLockVirtualMemory( process, addr_32to64( &addr, addr32 ),
 318                                   size_32to64( &size, size32 ), unknown );
 319     if (!status)
 320     {
 321         put_addr( addr32, addr );
 322         put_size( size32, size );
 323     }
 324     return status;
 325 }
 326
 327
 328 /**********************************************************************
 329  *           wow64_NtMapViewOfSection
 330  */
 331 NTSTATUS WINAPI wow64_NtMapViewOfSection( UINT *args )
 332 {
 333     HANDLE handle = get_handle( &args );
 334     HANDLE process = get_handle( &args );
 335     ULONG *addr32 = get_ptr( &args );
 336     ULONG_PTR zero_bits = get_ulong( &args );
 337     SIZE_T commit = get_ulong( &args );
 338     const LARGE_INTEGER *offset = get_ptr( &args );
 339     ULONG *size32 = get_ptr( &args );
 340     SECTION_INHERIT inherit = get_ulong( &args );
 341     ULONG alloc = get_ulong( &args );
 342     ULONG protect = get_ulong( &args );
 343
 344     void *addr;
 345     SIZE_T size;
 346     NTSTATUS status;
 347
 348     status = NtMapViewOfSection( handle, process, addr_32to64( &addr, addr32 ), get_zero_bits( zero_bits ),
 349                                  commit, offset, size_32to64( &size, size32 ), inherit, alloc, protect );
 350     if (NT_SUCCESS(status))
 351     {
 352         SECTION_IMAGE_INFORMATION info;
 353
 354         if (!NtQuerySection( handle, SectionImageInformation, &info, sizeof(info), NULL ))
 355         {
 356             if (info.Machine == current_machine) init_image_mapping( addr );
 357         }
 358         put_addr( addr32, addr );
 359         put_size( size32, size );
 360     }
 361     return status;
 362 }
 363
 364 /**********************************************************************
 365  *           wow64_NtMapViewOfSectionEx
 366  */
 367 NTSTATUS WINAPI wow64_NtMapViewOfSectionEx( UINT *args )
 368 {
 369     HANDLE handle = get_handle( &args );
 370     HANDLE process = get_handle( &args );
 371     ULONG *addr32 = get_ptr( &args );
 372     const LARGE_INTEGER *offset = get_ptr( &args );
 373     ULONG *size32 = get_ptr( &args );
 374     ULONG alloc = get_ulong( &args );
 375     ULONG protect = get_ulong( &args );
 376     MEM_EXTENDED_PARAMETER *params = get_ptr( &args );
 377     ULONG params_count = get_ulong( &args );
 378
 379     void *addr;
 380     SIZE_T size;
 381     NTSTATUS status;
 382
 383     status = NtMapViewOfSectionEx( handle, process, addr_32to64( &addr, addr32 ), offset, size_32to64( &size, size32 ), alloc,
 384             protect, params, params_count );
 385     if (NT_SUCCESS(status))
 386     {
 387         SECTION_IMAGE_INFORMATION info;
 388
 389         if (!NtQuerySection( handle, SectionImageInformation, &info, sizeof(info), NULL ))
 390         {
 391             if (info.Machine == current_machine) init_image_mapping( addr );
 392         }
 393         put_addr( addr32, addr );
 394         put_size( size32, size );
 395     }
 396     return status;
 397 }
 398
 399 /**********************************************************************
 400  *           wow64_NtProtectVirtualMemory
 401  */
 402 NTSTATUS WINAPI wow64_NtProtectVirtualMemory( UINT *args )
 403 {
 404     HANDLE process = get_handle( &args );
 405     ULONG *addr32 = get_ptr( &args );
 406     ULONG *size32 = get_ptr( &args );
 407     ULONG new_prot = get_ulong( &args );
 408     ULONG *old_prot = get_ptr( &args );
 409
 410     void *addr;
 411     SIZE_T size;
 412     NTSTATUS status;
 413
 414     status = NtProtectVirtualMemory( process, addr_32to64( &addr, addr32 ),
 415                                      size_32to64( &size, size32 ), new_prot, old_prot );
 416     if (!status)
 417     {
 418         put_addr( addr32, addr );
 419         put_size( size32, size );
 420     }
 421     return status;
 422 }
 423
 424
 425 /**********************************************************************
 426  *           wow64_NtQueryVirtualMemory
 427  */
 428 NTSTATUS WINAPI wow64_NtQueryVirtualMemory( UINT *args )
 429 {
 430     HANDLE handle = get_handle( &args );
 431     void *addr = get_ptr( &args );
 432     MEMORY_INFORMATION_CLASS class = get_ulong( &args );
 433     void *ptr = get_ptr( &args );
 434     ULONG len = get_ulong( &args );
 435     ULONG *retlen = get_ptr( &args );
 436
 437     SIZE_T res_len = 0;
 438     NTSTATUS status;
 439
 440     switch (class)
 441     {
 442     case MemoryBasicInformation:  /* MEMORY_BASIC_INFORMATION */
 443         if (len < sizeof(MEMORY_BASIC_INFORMATION32))
 444             status = STATUS_INFO_LENGTH_MISMATCH;
 445         else if ((ULONG_PTR)addr > highest_user_address)
 446             status = STATUS_INVALID_PARAMETER;
 447         else
 448         {
 449             MEMORY_BASIC_INFORMATION info;
 450             MEMORY_BASIC_INFORMATION32 *info32 = ptr;
 451
 452             if (!(status = NtQueryVirtualMemory( handle, addr, class, &info, sizeof(info), &res_len )))
 453             {
 454                 info32->BaseAddress = PtrToUlong( info.BaseAddress );
 455                 info32->AllocationBase = PtrToUlong( info.AllocationBase );
 456                 info32->AllocationProtect = info.AllocationProtect;
 457                 info32->RegionSize = info.RegionSize;
 458                 info32->State = info.State;
 459                 info32->Protect = info.Protect;
 460                 info32->Type = info.Type;
 461                 if ((ULONG_PTR)info.BaseAddress + info.RegionSize > highest_user_address)
 462                     info32->RegionSize = highest_user_address - (ULONG_PTR)info.BaseAddress + 1;
 463             }
 464         }
 465         res_len = sizeof(MEMORY_BASIC_INFORMATION32);
 466         break;
 467
 468     case MemoryMappedFilenameInformation:  /* MEMORY_SECTION_NAME */
 469     {
 470         MEMORY_SECTION_NAME *info;
 471         MEMORY_SECTION_NAME32 *info32 = ptr;
 472         SIZE_T size = len + sizeof(*info) - sizeof(*info32);
 473
 474         info = Wow64AllocateTemp( size );
 475         if (!(status = NtQueryVirtualMemory( handle, addr, class, info, size, &res_len )))
 476         {
 477             info32->SectionFileName.Length = info->SectionFileName.Length;
 478             info32->SectionFileName.MaximumLength = info->SectionFileName.MaximumLength;
 479             info32->SectionFileName.Buffer = PtrToUlong( info32 + 1 );
 480             memcpy( info32 + 1, info->SectionFileName.Buffer, info->SectionFileName.MaximumLength );
 481         }
 482         res_len += sizeof(*info32) - sizeof(*info);
 483         break;
 484     }
 485
 486     case MemoryRegionInformation: /* MEMORY_REGION_INFORMATION */
 487     {
 488         if (len < sizeof(MEMORY_REGION_INFORMATION32))
 489             status = STATUS_INFO_LENGTH_MISMATCH;
 490         if ((ULONG_PTR)addr > highest_user_address)
 491             status = STATUS_INVALID_PARAMETER;
 492         else
 493         {
 494             MEMORY_REGION_INFORMATION info;
 495             MEMORY_REGION_INFORMATION32 *info32 = ptr;
 496
 497             if (!(status = NtQueryVirtualMemory( handle, addr, class, &info, sizeof(info), &res_len )))
 498             {
 499                 info32->AllocationBase = PtrToUlong( info.AllocationBase );
 500                 info32->AllocationProtect = info.AllocationProtect;
 501                 info32->RegionType = info.RegionType;
 502                 info32->RegionSize = info.RegionSize;
 503                 info32->CommitSize = info.CommitSize;
 504                 info32->PartitionId = info.PartitionId;
 505                 info32->NodePreference = info.NodePreference;
 506                 if ((ULONG_PTR)info.AllocationBase + info.RegionSize > highest_user_address)
 507                     info32->RegionSize = highest_user_address - (ULONG_PTR)info.AllocationBase + 1;
 508             }
 509         }
 510         res_len = sizeof(MEMORY_REGION_INFORMATION32);
 511         break;
 512     }
 513
 514     case MemoryWorkingSetExInformation:  /* MEMORY_WORKING_SET_EX_INFORMATION */
 515     {
 516         MEMORY_WORKING_SET_EX_INFORMATION32 *info32 = ptr;
 517         MEMORY_WORKING_SET_EX_INFORMATION *info;
 518         ULONG i, count = len / sizeof(*info32);
 519
 520         info = Wow64AllocateTemp( count * sizeof(*info) );
 521         for (i = 0; i < count; i++) info[i].VirtualAddress = ULongToPtr( info32[i].VirtualAddress );
 522         if (!(status = NtQueryVirtualMemory( handle, addr, class, info, count * sizeof(*info), &res_len )))
 523         {
 524             count = res_len / sizeof(*info);
 525             for (i = 0; i < count; i++) info32[i].VirtualAttributes.Flags = info[i].VirtualAttributes.Flags;
 526             res_len = count * sizeof(*info32);
 527         }
 528         break;
 529     }
 530
 531     case MemoryWineUnixWow64Funcs:
 532         return STATUS_INVALID_INFO_CLASS;
 533
 534     case MemoryWineUnixFuncs:
 535         status = NtQueryVirtualMemory( handle, addr, MemoryWineUnixWow64Funcs, ptr, len, &res_len );
 536         break;
 537
 538     default:
 539         FIXME( "unsupported class %u\n", class );
 540         return STATUS_INVALID_INFO_CLASS;
 541     }
 542     if (!status || status == STATUS_INFO_LENGTH_MISMATCH) put_size( retlen, res_len );
 543     return status;
 544 }
 545
 546
 547 /**********************************************************************
 548  *           wow64_NtReadVirtualMemory
 549  */
 550 NTSTATUS WINAPI wow64_NtReadVirtualMemory( UINT *args )
 551 {
 552     HANDLE process = get_handle( &args );
 553     const void *addr = get_ptr( &args );
 554     void *buffer = get_ptr( &args );
 555     SIZE_T size = get_ulong( &args );
 556     ULONG *retlen = get_ptr( &args );
 557
 558     SIZE_T ret_size;
 559     NTSTATUS status;
 560
 561     status = NtReadVirtualMemory( process, addr, buffer, size, &ret_size );
 562     put_size( retlen, ret_size );
 563     return status;
 564 }
 565
 566
 567 /**********************************************************************
 568  *           wow64_NtResetWriteWatch
 569  */
 570 NTSTATUS WINAPI wow64_NtResetWriteWatch( UINT *args )
 571 {
 572     HANDLE process = get_handle( &args );
 573     void *base = get_ptr( &args );
 574     SIZE_T size = get_ulong( &args );
 575
 576     return NtResetWriteWatch( process, base, size );
 577 }
 578
 579
 580 /**********************************************************************
 581  *           wow64_NtSetInformationVirtualMemory
 582  */
 583 NTSTATUS WINAPI wow64_NtSetInformationVirtualMemory( UINT *args )
 584 {
 585     HANDLE process = get_handle( &args );
 586     VIRTUAL_MEMORY_INFORMATION_CLASS info_class = get_ulong( &args );
 587     ULONG count = get_ulong( &args );
 588     MEMORY_RANGE_ENTRY32 *addresses32 = get_ptr( &args );
 589     PVOID ptr = get_ptr( &args );
 590     ULONG len = get_ulong( &args );
 591
 592     MEMORY_RANGE_ENTRY *addresses;
 593
 594     if (!count) return STATUS_INVALID_PARAMETER_3;
 595     addresses = memory_range_entry_array_32to64( addresses32, count );
 596
 597     switch (info_class)
 598     {
 599     case VmPrefetchInformation:
 600         break;
 601     default:
 602         FIXME( "(%p,info_class=%u,%lu,%p,%p,%lu): not implemented\n",
 603                process, info_class, count, addresses32, ptr, len );
 604         return STATUS_INVALID_PARAMETER_2;
 605     }
 606
 607     return NtSetInformationVirtualMemory( process, info_class, count, addresses, ptr, len );
 608 }
 609
 610
 611 /**********************************************************************
 612  *           wow64_NtSetLdtEntries
 613  */
 614 NTSTATUS WINAPI wow64_NtSetLdtEntries( UINT *args )
 615 {
 616     ULONG sel1 = get_ulong( &args );
 617     ULONG entry1_low = get_ulong( &args );
 618     ULONG entry1_high = get_ulong( &args );
 619     ULONG sel2 = get_ulong( &args );
 620     ULONG entry2_low = get_ulong( &args );
 621     ULONG entry2_high = get_ulong( &args );
 622
 623     FIXME( "%04lx %08lx %08lx %04lx %08lx %08lx: stub\n",
 624            sel1, entry1_low, entry1_high, sel2, entry2_low, entry2_high );
 625     return STATUS_NOT_IMPLEMENTED;
 626 }
 627
 628
 629 /**********************************************************************
 630  *           wow64_NtUnlockVirtualMemory
 631  */
 632 NTSTATUS WINAPI wow64_NtUnlockVirtualMemory( UINT *args )
 633 {
 634     HANDLE process = get_handle( &args );
 635     ULONG *addr32 = get_ptr( &args );
 636     ULONG *size32 = get_ptr( &args );
 637     ULONG unknown = get_ulong( &args );
 638
 639     void *addr;
 640     SIZE_T size;
 641     NTSTATUS status;
 642
 643     status = NtUnlockVirtualMemory( process, addr_32to64( &addr, addr32 ),
 644                                     size_32to64( &size, size32 ), unknown );
 645     if (!status)
 646     {
 647         put_addr( addr32, addr );
 648         put_size( size32, size );
 649     }
 650     return status;
 651 }
 652
 653
 654 /**********************************************************************
 655  *           wow64_NtUnmapViewOfSection
 656  */
 657 NTSTATUS WINAPI wow64_NtUnmapViewOfSection( UINT *args )
 658 {
 659     HANDLE process = get_handle( &args );
 660     void *addr = get_ptr( &args );
 661
 662     return NtUnmapViewOfSection( process, addr );
 663 }
 664
 665
 666 /**********************************************************************
 667  *           wow64_NtUnmapViewOfSectionEx
 668  */
 669 NTSTATUS WINAPI wow64_NtUnmapViewOfSectionEx( UINT *args )
 670 {
 671     HANDLE process = get_handle( &args );
 672     void *addr = get_ptr( &args );
 673     ULONG flags = get_ulong( &args );
 674
 675     return NtUnmapViewOfSectionEx( process, addr, flags );
 676 }
 677
 678
 679 /**********************************************************************
 680  *           wow64_NtWow64AllocateVirtualMemory64
 681  */
 682 NTSTATUS WINAPI wow64_NtWow64AllocateVirtualMemory64( UINT *args )
 683 {
 684     HANDLE process = get_handle( &args );
 685     void **addr = get_ptr( &args );
 686     ULONG_PTR zero_bits = get_ulong64( &args );
 687     SIZE_T *size = get_ptr( &args );
 688     ULONG type = get_ulong( &args );
 689     ULONG protect = get_ulong( &args );
 690
 691     return NtAllocateVirtualMemory( process, addr, zero_bits, size, type, protect );
 692 }
 693
 694
 695 /**********************************************************************
 696  *           wow64_NtWow64ReadVirtualMemory64
 697  */
 698 NTSTATUS WINAPI wow64_NtWow64ReadVirtualMemory64( UINT *args )
 699 {
 700     HANDLE process = get_handle( &args );
 701     void *addr = (void *)(ULONG_PTR)get_ulong64( &args );
 702     void *buffer = get_ptr( &args );
 703     SIZE_T size = get_ulong64( &args );
 704     SIZE_T *ret_size = get_ptr( &args );
 705
 706     return NtReadVirtualMemory( process, addr, buffer, size, ret_size );
 707 }
 708
 709
 710 /**********************************************************************
 711  *           wow64_NtWow64WriteVirtualMemory64
 712  */
 713 NTSTATUS WINAPI wow64_NtWow64WriteVirtualMemory64( UINT *args )
 714 {
 715     HANDLE process = get_handle( &args );
 716     void *addr = (void *)(ULONG_PTR)get_ulong64( &args );
 717     const void *buffer = get_ptr( &args );
 718     SIZE_T size = get_ulong64( &args );
 719     SIZE_T *ret_size = get_ptr( &args );
 720
 721     return NtWriteVirtualMemory( process, addr, buffer, size, ret_size );
 722 }
 723
 724
 725 /**********************************************************************
 726  *           wow64_NtWriteVirtualMemory
 727  */
 728 NTSTATUS WINAPI wow64_NtWriteVirtualMemory( UINT *args )
 729 {
 730     HANDLE process = get_handle( &args );
 731     void *addr = get_ptr( &args );
 732     const void *buffer = get_ptr( &args );
 733     SIZE_T size = get_ulong( &args );
 734     ULONG *retlen = get_ptr( &args );
 735
 736     SIZE_T ret_size;
 737     NTSTATUS status;
 738
 739     status = NtWriteVirtualMemory( process, addr, buffer, size, &ret_size );
 740     put_size( retlen, ret_size );
 741     return status;
 742 }