dlls/kernel32/virtual.c

   1 /*
   2  * Win32 virtual memory functions
   3  *
   4  * Copyright 1997 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 "config.h"
  22 #include "wine/port.h"
  23
  24 #include <fcntl.h>
  25 #include <stdarg.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <sys/types.h>
  29 #ifdef HAVE_UNISTD_H
  30 # include <unistd.h>
  31 #endif
  32
  33 #include "ntstatus.h"
  34 #define WIN32_NO_STATUS
  35 #define NONAMELESSUNION
  36 #include "windef.h"
  37 #include "winbase.h"
  38 #include "winnls.h"
  39 #include "winternl.h"
  40 #include "winerror.h"
  41 #include "psapi.h"
  42 #include "wine/exception.h"
  43 #include "wine/debug.h"
  44
  45 #include "kernel_private.h"
  46
  47 WINE_DECLARE_DEBUG_CHANNEL(seh);
  48 WINE_DECLARE_DEBUG_CHANNEL(file);
  49 WINE_DECLARE_DEBUG_CHANNEL(virtual);
  50
  51
  52 /***********************************************************************
  53  *             VirtualAlloc   (KERNEL32.@)
  54  *
  55  * Reserves or commits a region of pages in virtual address space.
  56  *
  57  * PARAMS
  58  *  addr    [I] Address of region to reserve or commit.
  59  *  size    [I] Size of region.
  60  *  type    [I] Type of allocation.
  61  *  protect [I] Type of access protection.
  62  *
  63  * RETURNS
  64  *      Success: Base address of allocated region of pages.
  65  *      Failure: NULL.
  66  */
  67 LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAlloc( void *addr, SIZE_T size, DWORD type, DWORD protect )
  68 {
  69     return VirtualAllocEx( GetCurrentProcess(), addr, size, type, protect );
  70 }
  71
  72
  73 /***********************************************************************
  74  *             VirtualAllocEx   (KERNEL32.@)
  75  *
  76  * Seems to be just as VirtualAlloc, but with process handle.
  77  *
  78  * PARAMS
  79  *  hProcess [I] Handle to process to do mem operation.
  80  *  addr     [I] Address of region to reserve or commit.
  81  *  size     [I] Size of region.
  82  *  type     [I] Type of allocation.
  83  *  protect  [I] Type of access protection.
  84  *
  85  *
  86  * RETURNS
  87  *      Success: Base address of allocated region of pages.
  88  *      Failure: NULL.
  89  */
  90 LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocEx( HANDLE hProcess, LPVOID addr, SIZE_T size,
  91     DWORD type, DWORD protect )
  92 {
  93     LPVOID ret = addr;
  94     NTSTATUS status;
  95
  96     if ((status = NtAllocateVirtualMemory( hProcess, &ret, 0, &size, type, protect )))
  97     {
  98         SetLastError( RtlNtStatusToDosError(status) );
  99         ret = NULL;
 100     }
 101     return ret;
 102 }
 103
 104
 105 /***********************************************************************
 106  *             VirtualAllocExNuma   (KERNEL32.@)
 107  */
 108 LPVOID WINAPI DECLSPEC_HOTPATCH VirtualAllocExNuma(HANDLE process, void *addr, SIZE_T size,
 109         DWORD type, DWORD protect, DWORD numa_node)
 110 {
 111     FIXME_(virtual)("Ignoring preferred numa_node\n");
 112     return VirtualAllocEx(process, addr, size, type, protect);
 113 }
 114
 115
 116 /***********************************************************************
 117  *             VirtualFree   (KERNEL32.@)
 118  *
 119  * Releases or decommits a region of pages in virtual address space.
 120  *
 121  * PARAMS
 122  *  addr [I] Address of region of committed pages.
 123  *  size [I] Size of region.
 124  *  type [I] Type of operation.
 125  *
 126  * RETURNS
 127  *      Success: TRUE.
 128  *      Failure: FALSE.
 129  */
 130 BOOL WINAPI VirtualFree( LPVOID addr, SIZE_T size, DWORD type )
 131 {
 132     return VirtualFreeEx( GetCurrentProcess(), addr, size, type );
 133 }
 134
 135
 136 /***********************************************************************
 137  *             VirtualFreeEx   (KERNEL32.@)
 138  *
 139  * Releases or decommits a region of pages in virtual address space.
 140  *
 141  * PARAMS
 142  *  process [I] Handle to process.
 143  *  addr    [I] Address of region to free.
 144  *  size    [I] Size of region.
 145  *  type    [I] Type of operation.
 146  *
 147  * RETURNS
 148  *      Success: TRUE.
 149  *      Failure: FALSE.
 150  */
 151 BOOL WINAPI VirtualFreeEx( HANDLE process, LPVOID addr, SIZE_T size, DWORD type )
 152 {
 153     NTSTATUS status = NtFreeVirtualMemory( process, &addr, &size, type );
 154     if (status) SetLastError( RtlNtStatusToDosError(status) );
 155     return !status;
 156 }
 157
 158
 159 /***********************************************************************
 160  *             VirtualLock   (KERNEL32.@)
 161  *
 162  * Locks the specified region of virtual address space.
 163  *
 164  * PARAMS
 165  *  addr [I] Address of first byte of range to lock.
 166  *  size [I] Number of bytes in range to lock.
 167  *
 168  * RETURNS
 169  *      Success: TRUE.
 170  *      Failure: FALSE.
 171  *
 172  * NOTES
 173  *      Always returns TRUE.
 174  *
 175  */
 176 BOOL WINAPI VirtualLock( LPVOID addr, SIZE_T size )
 177 {
 178     NTSTATUS status = NtLockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 );
 179     if (status) SetLastError( RtlNtStatusToDosError(status) );
 180     return !status;
 181 }
 182
 183
 184 /***********************************************************************
 185  *             VirtualUnlock   (KERNEL32.@)
 186  *
 187  * Unlocks a range of pages in the virtual address space.
 188  *
 189  * PARAMS
 190  *  addr [I] Address of first byte of range.
 191  *  size [I] Number of bytes in range.
 192  *
 193  * RETURNS
 194  *      Success: TRUE.
 195  *      Failure: FALSE.
 196  *
 197  * NOTES
 198  *      Always returns TRUE.
 199  *
 200  */
 201 BOOL WINAPI VirtualUnlock( LPVOID addr, SIZE_T size )
 202 {
 203     NTSTATUS status = NtUnlockVirtualMemory( GetCurrentProcess(), &addr, &size, 1 );
 204     if (status) SetLastError( RtlNtStatusToDosError(status) );
 205     return !status;
 206 }
 207
 208
 209 /***********************************************************************
 210  *             VirtualProtect   (KERNEL32.@)
 211  *
 212  * Changes the access protection on a region of committed pages.
 213  *
 214  * PARAMS
 215  *  addr     [I] Address of region of committed pages.
 216  *  size     [I] Size of region.
 217  *  new_prot [I] Desired access protection.
 218  *  old_prot [O] Address of variable to get old protection.
 219  *
 220  * RETURNS
 221  *      Success: TRUE.
 222  *      Failure: FALSE.
 223  */
 224 BOOL WINAPI VirtualProtect( LPVOID addr, SIZE_T size, DWORD new_prot, LPDWORD old_prot)
 225 {
 226     return VirtualProtectEx( GetCurrentProcess(), addr, size, new_prot, old_prot );
 227 }
 228
 229
 230 /***********************************************************************
 231  *             VirtualProtectEx   (KERNEL32.@)
 232  *
 233  * Changes the access protection on a region of committed pages in the
 234  * virtual address space of a specified process.
 235  *
 236  * PARAMS
 237  *  process  [I] Handle of process.
 238  *  addr     [I] Address of region of committed pages.
 239  *  size     [I] Size of region.
 240  *  new_prot [I] Desired access protection.
 241  *  old_prot [O] Address of variable to get old protection.
 242  *
 243  * RETURNS
 244  *      Success: TRUE.
 245  *      Failure: FALSE.
 246  */
 247 BOOL WINAPI VirtualProtectEx( HANDLE process, LPVOID addr, SIZE_T size,
 248     DWORD new_prot, LPDWORD old_prot )
 249 {
 250     NTSTATUS status;
 251     DWORD prot;
 252
 253     /* Win9x allows passing NULL as old_prot while this fails on NT */
 254     if (!old_prot && (GetVersion() & 0x80000000)) old_prot = &prot;
 255
 256     status = NtProtectVirtualMemory( process, &addr, &size, new_prot, old_prot );
 257     if (status) SetLastError( RtlNtStatusToDosError(status) );
 258     return !status;
 259 }
 260
 261
 262 /***********************************************************************
 263  *             VirtualQuery   (KERNEL32.@)
 264  *
 265  * Provides info about a range of pages in virtual address space.
 266  *
 267  * PARAMS
 268  *  addr [I] Address of region.
 269  *  info [O] Address of info buffer.
 270  *  len  [I] Size of buffer.
 271  *
 272  * RETURNS
 273  *      Number of bytes returned in information buffer or 0 if
 274  *      addr >= 0xc0000000 (kernel space).
 275  */
 276 SIZE_T WINAPI VirtualQuery( LPCVOID addr, PMEMORY_BASIC_INFORMATION info,
 277     SIZE_T len )
 278 {
 279     return VirtualQueryEx( GetCurrentProcess(), addr, info, len );
 280 }
 281
 282
 283 /***********************************************************************
 284  *             VirtualQueryEx   (KERNEL32.@)
 285  *
 286  * Provides info about a range of pages in virtual address space of a
 287  * specified process.
 288  *
 289  * PARAMS
 290  *  process [I] Handle to process.
 291  *  addr    [I] Address of region.
 292  *  info    [O] Address of info buffer.
 293  *  len     [I] Size of buffer.
 294  *
 295  * RETURNS
 296  *      Number of bytes returned in information buffer.
 297  */
 298 SIZE_T WINAPI VirtualQueryEx( HANDLE process, LPCVOID addr,
 299     PMEMORY_BASIC_INFORMATION info, SIZE_T len )
 300 {
 301     SIZE_T ret;
 302     NTSTATUS status;
 303
 304     if ((status = NtQueryVirtualMemory( process, addr, MemoryBasicInformation, info, len, &ret )))
 305     {
 306         SetLastError( RtlNtStatusToDosError(status) );
 307         ret = 0;
 308     }
 309     return ret;
 310 }
 311
 312
 313 /***********************************************************************
 314  *             MapViewOfFile   (KERNEL32.@)
 315  *
 316  * Maps a view of a file into the address space.
 317  *
 318  * PARAMS
 319  *  mapping     [I] File-mapping object to map.
 320  *  access      [I] Access mode.
 321  *  offset_high [I] High-order 32 bits of file offset.
 322  *  offset_low  [I] Low-order 32 bits of file offset.
 323  *  count       [I] Number of bytes to map.
 324  *
 325  * RETURNS
 326  *      Success: Starting address of mapped view.
 327  *      Failure: NULL.
 328  */
 329 LPVOID WINAPI DECLSPEC_HOTPATCH MapViewOfFile( HANDLE mapping, DWORD access,
 330     DWORD offset_high, DWORD offset_low, SIZE_T count )
 331 {
 332     return MapViewOfFileEx( mapping, access, offset_high,
 333                             offset_low, count, NULL );
 334 }
 335
 336
 337 /***********************************************************************
 338  *             MapViewOfFileEx   (KERNEL32.@)
 339  *
 340  * Maps a view of a file into the address space.
 341  *
 342  * PARAMS
 343  *  handle      [I] File-mapping object to map.
 344  *  access      [I] Access mode.
 345  *  offset_high [I] High-order 32 bits of file offset.
 346  *  offset_low  [I] Low-order 32 bits of file offset.
 347  *  count       [I] Number of bytes to map.
 348  *  addr        [I] Suggested starting address for mapped view.
 349  *
 350  * RETURNS
 351  *      Success: Starting address of mapped view.
 352  *      Failure: NULL.
 353  */
 354 LPVOID WINAPI MapViewOfFileEx( HANDLE handle, DWORD access,
 355     DWORD offset_high, DWORD offset_low, SIZE_T count, LPVOID addr )
 356 {
 357     NTSTATUS status;
 358     LARGE_INTEGER offset;
 359     ULONG protect;
 360     BOOL exec;
 361
 362     offset.u.LowPart  = offset_low;
 363     offset.u.HighPart = offset_high;
 364
 365     exec = access & FILE_MAP_EXECUTE;
 366     access &= ~FILE_MAP_EXECUTE;
 367
 368     if (access == FILE_MAP_COPY)
 369         protect = exec ? PAGE_EXECUTE_WRITECOPY : PAGE_WRITECOPY;
 370     else if (access & FILE_MAP_WRITE)
 371         protect = exec ? PAGE_EXECUTE_READWRITE : PAGE_READWRITE;
 372     else if (access & FILE_MAP_READ)
 373         protect = exec ? PAGE_EXECUTE_READ : PAGE_READONLY;
 374     else protect = PAGE_NOACCESS;
 375
 376     if ((status = NtMapViewOfSection( handle, GetCurrentProcess(), &addr, 0, 0, &offset,
 377                                       &count, ViewShare, 0, protect )) < 0)
 378     {
 379         SetLastError( RtlNtStatusToDosError(status) );
 380         addr = NULL;
 381     }
 382     return addr;
 383 }
 384
 385
 386 /***********************************************************************
 387  *             UnmapViewOfFile   (KERNEL32.@)
 388  *
 389  * Unmaps a mapped view of a file.
 390  *
 391  * PARAMS
 392  *  addr [I] Address where mapped view begins.
 393  *
 394  * RETURNS
 395  *      Success: TRUE.
 396  *      Failure: FALSE.
 397  *
 398  */
 399 BOOL WINAPI DECLSPEC_HOTPATCH UnmapViewOfFile( const void *addr )
 400 {
 401     NTSTATUS status;
 402
 403     if (GetVersion() & 0x80000000)
 404     {
 405         MEMORY_BASIC_INFORMATION info;
 406         if (!VirtualQuery( addr, &info, sizeof(info) ) || info.AllocationBase != addr)
 407         {
 408             SetLastError( ERROR_INVALID_ADDRESS );
 409             return FALSE;
 410         }
 411     }
 412
 413     status = NtUnmapViewOfSection( GetCurrentProcess(), (void *)addr );
 414     if (status) SetLastError( RtlNtStatusToDosError(status) );
 415     return !status;
 416 }
 417
 418
 419 /***********************************************************************
 420  *             FlushViewOfFile   (KERNEL32.@)
 421  *
 422  * Writes to the disk a byte range within a mapped view of a file.
 423  *
 424  * PARAMS
 425  *  base [I] Start address of byte range to flush.
 426  *  size [I] Number of bytes in range.
 427  *
 428  * RETURNS
 429  *      Success: TRUE.
 430  *      Failure: FALSE.
 431  */
 432 BOOL WINAPI FlushViewOfFile( LPCVOID base, SIZE_T size )
 433 {
 434     NTSTATUS status = NtFlushVirtualMemory( GetCurrentProcess(), &base, &size, 0 );
 435     if (status)
 436     {
 437         if (status == STATUS_NOT_MAPPED_DATA) status = STATUS_SUCCESS;
 438         else SetLastError( RtlNtStatusToDosError(status) );
 439     }
 440     return !status;
 441 }
 442
 443
 444 /***********************************************************************
 445  *             GetWriteWatch   (KERNEL32.@)
 446  */
 447 UINT WINAPI GetWriteWatch( DWORD flags, LPVOID base, SIZE_T size, LPVOID *addresses,
 448                            ULONG_PTR *count, ULONG *granularity )
 449 {
 450     NTSTATUS status;
 451
 452     status = NtGetWriteWatch( GetCurrentProcess(), flags, base, size, addresses, count, granularity );
 453     if (status) SetLastError( RtlNtStatusToDosError(status) );
 454     return status ? ~0u : 0;
 455 }
 456
 457
 458 /***********************************************************************
 459  *             ResetWriteWatch   (KERNEL32.@)
 460  */
 461 UINT WINAPI ResetWriteWatch( LPVOID base, SIZE_T size )
 462 {
 463     NTSTATUS status;
 464
 465     status = NtResetWriteWatch( GetCurrentProcess(), base, size );
 466     if (status) SetLastError( RtlNtStatusToDosError(status) );
 467     return status ? ~0u : 0;
 468 }
 469
 470
 471 /***********************************************************************
 472  *             IsBadReadPtr   (KERNEL32.@)
 473  *
 474  * Check for read access on a memory block.
 475  *
 476  * ptr  [I] Address of memory block.
 477  * size [I] Size of block.
 478  *
 479  * RETURNS
 480  *  Success: TRUE.
 481  *      Failure: FALSE. Process has read access to entire block.
 482  */
 483 BOOL WINAPI IsBadReadPtr( LPCVOID ptr, UINT_PTR size )
 484 {
 485     if (!size) return FALSE;  /* handle 0 size case w/o reference */
 486     if (!ptr) return TRUE;
 487     __TRY
 488     {
 489         volatile const char *p = ptr;
 490         char dummy __attribute__((unused));
 491         UINT_PTR count = size;
 492
 493         while (count > system_info.PageSize)
 494         {
 495             dummy = *p;
 496             p += system_info.PageSize;
 497             count -= system_info.PageSize;
 498         }
 499         dummy = p[0];
 500         dummy = p[count - 1];
 501     }
 502     __EXCEPT_PAGE_FAULT
 503     {
 504         TRACE_(seh)("%p caused page fault during read\n", ptr);
 505         return TRUE;
 506     }
 507     __ENDTRY
 508     return FALSE;
 509 }
 510
 511
 512 /***********************************************************************
 513  *             IsBadWritePtr   (KERNEL32.@)
 514  *
 515  * Check for write access on a memory block.
 516  *
 517  * PARAMS
 518  *  ptr  [I] Address of memory block.
 519  *  size [I] Size of block in bytes.
 520  *
 521  * RETURNS
 522  *  Success: TRUE.
 523  *      Failure: FALSE. Process has write access to entire block.
 524  */
 525 BOOL WINAPI IsBadWritePtr( LPVOID ptr, UINT_PTR size )
 526 {
 527     if (!size) return FALSE;  /* handle 0 size case w/o reference */
 528     if (!ptr) return TRUE;
 529     __TRY
 530     {
 531         volatile char *p = ptr;
 532         UINT_PTR count = size;
 533
 534         while (count > system_info.PageSize)
 535         {
 536             *p |= 0;
 537             p += system_info.PageSize;
 538             count -= system_info.PageSize;
 539         }
 540         p[0] |= 0;
 541         p[count - 1] |= 0;
 542     }
 543     __EXCEPT_PAGE_FAULT
 544     {
 545         TRACE_(seh)("%p caused page fault during write\n", ptr);
 546         return TRUE;
 547     }
 548     __ENDTRY
 549     return FALSE;
 550 }
 551
 552
 553 /***********************************************************************
 554  *             IsBadHugeReadPtr   (KERNEL32.@)
 555  *
 556  * Check for read access on a memory block.
 557  *
 558  * PARAMS
 559  *  ptr  [I] Address of memory block.
 560  *  size [I] Size of block.
 561  *
 562  * RETURNS
 563  *  Success: TRUE.
 564  *      Failure: FALSE. Process has read access to entire block.
 565  */
 566 BOOL WINAPI IsBadHugeReadPtr( LPCVOID ptr, UINT_PTR size )
 567 {
 568     return IsBadReadPtr( ptr, size );
 569 }
 570
 571
 572 /***********************************************************************
 573  *             IsBadHugeWritePtr   (KERNEL32.@)
 574  *
 575  * Check for write access on a memory block.
 576  *
 577  * PARAMS
 578  *  ptr  [I] Address of memory block.
 579  *  size [I] Size of block.
 580  *
 581  * RETURNS
 582  *  Success: TRUE.
 583  *      Failure: FALSE. Process has write access to entire block.
 584  */
 585 BOOL WINAPI IsBadHugeWritePtr( LPVOID ptr, UINT_PTR size )
 586 {
 587     return IsBadWritePtr( ptr, size );
 588 }
 589
 590
 591 /***********************************************************************
 592  *             IsBadCodePtr   (KERNEL32.@)
 593  *
 594  * Check for read access on a memory address.
 595  *
 596  * PARAMS
 597  *  ptr [I] Address of function.
 598  *
 599  * RETURNS
 600  *      Success: TRUE.
 601  *      Failure: FALSE. Process has read access to specified memory.
 602  */
 603 BOOL WINAPI IsBadCodePtr( FARPROC ptr )
 604 {
 605     return IsBadReadPtr( ptr, 1 );
 606 }
 607
 608
 609 /***********************************************************************
 610  *             IsBadStringPtrA   (KERNEL32.@)
 611  *
 612  * Check for read access on a range of memory pointed to by a string pointer.
 613  *
 614  * PARAMS
 615  *  str [I] Address of string.
 616  *  max [I] Maximum size of string.
 617  *
 618  * RETURNS
 619  *      Success: TRUE.
 620  *      Failure: FALSE. Read access to all bytes in string.
 621  */
 622 BOOL WINAPI IsBadStringPtrA( LPCSTR str, UINT_PTR max )
 623 {
 624     if (!str) return TRUE;
 625
 626     __TRY
 627     {
 628         volatile const char *p = str;
 629         while (p != str + max) if (!*p++) break;
 630     }
 631     __EXCEPT_PAGE_FAULT
 632     {
 633         TRACE_(seh)("%p caused page fault during read\n", str);
 634         return TRUE;
 635     }
 636     __ENDTRY
 637     return FALSE;
 638 }
 639
 640
 641 /***********************************************************************
 642  *             IsBadStringPtrW   (KERNEL32.@)
 643  *
 644  * See IsBadStringPtrA.
 645  */
 646 BOOL WINAPI IsBadStringPtrW( LPCWSTR str, UINT_PTR max )
 647 {
 648     if (!str) return TRUE;
 649
 650     __TRY
 651     {
 652         volatile const WCHAR *p = str;
 653         while (p != str + max) if (!*p++) break;
 654     }
 655     __EXCEPT_PAGE_FAULT
 656     {
 657         TRACE_(seh)("%p caused page fault during read\n", str);
 658         return TRUE;
 659     }
 660     __ENDTRY
 661     return FALSE;
 662 }
 663
 664 /***********************************************************************
 665  *           K32GetMappedFileNameA (KERNEL32.@)
 666  */
 667 DWORD WINAPI K32GetMappedFileNameA(HANDLE process, LPVOID lpv, LPSTR file_name, DWORD size)
 668 {
 669     FIXME_(file)("(%p, %p, %p, %d): stub\n", process, lpv, file_name, size);
 670
 671     if (file_name && size)
 672         file_name[0] = '\0';
 673
 674     return 0;
 675 }
 676
 677 /***********************************************************************
 678  *           K32GetMappedFileNameW (KERNEL32.@)
 679  */
 680 DWORD WINAPI K32GetMappedFileNameW(HANDLE process, LPVOID lpv, LPWSTR file_name, DWORD size)
 681 {
 682     FIXME_(file)("(%p, %p, %p, %d): stub\n", process, lpv, file_name, size);
 683
 684     if (file_name && size)
 685         file_name[0] = '\0';
 686
 687     return 0;
 688 }
 689
 690 /***********************************************************************
 691  *           K32EnumPageFilesA (KERNEL32.@)
 692  */
 693 BOOL WINAPI K32EnumPageFilesA( PENUM_PAGE_FILE_CALLBACKA callback, LPVOID context )
 694 {
 695     FIXME_(file)("(%p, %p) stub\n", callback, context );
 696     return FALSE;
 697 }
 698
 699 /***********************************************************************
 700  *           K32EnumPageFilesW (KERNEL32.@)
 701  */
 702 BOOL WINAPI K32EnumPageFilesW( PENUM_PAGE_FILE_CALLBACKW callback, LPVOID context )
 703 {
 704     FIXME_(file)("(%p, %p) stub\n", callback, context );
 705     return FALSE;
 706 }
 707
 708 /***********************************************************************
 709  *           K32GetWsChanges (KERNEL32.@)
 710  */
 711 BOOL WINAPI K32GetWsChanges(HANDLE process, PPSAPI_WS_WATCH_INFORMATION watchinfo, DWORD size)
 712 {
 713     NTSTATUS status;
 714
 715     TRACE_(seh)("(%p, %p, %d)\n", process, watchinfo, size);
 716
 717     status = NtQueryInformationProcess( process, ProcessWorkingSetWatch, watchinfo, size, NULL );
 718
 719     if (status)
 720     {
 721         SetLastError( RtlNtStatusToDosError( status ) );
 722         return FALSE;
 723     }
 724     return TRUE;
 725 }
 726
 727 /***********************************************************************
 728  *           K32GetWsChangesEx (KERNEL32.@)
 729  */
 730 BOOL WINAPI K32GetWsChangesEx(HANDLE process, PSAPI_WS_WATCH_INFORMATION_EX *watchinfoex, DWORD *size)
 731 {
 732     FIXME_(seh)("(%p, %p, %p)\n", process, watchinfoex, size);
 733
 734     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
 735     return FALSE;
 736 }
 737
 738 /***********************************************************************
 739  *           K32InitializeProcessForWsWatch (KERNEL32.@)
 740  */
 741 BOOL WINAPI K32InitializeProcessForWsWatch(HANDLE process)
 742 {
 743     FIXME_(seh)("(process=%p): stub\n", process);
 744
 745     return TRUE;
 746 }