dlls/kernelbase/debug.c

   1 /*
   2  * Win32 debugger functions
   3  *
   4  * Copyright (C) 1999 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 <stdio.h>
  22 #include <string.h>
  23
  24 #include "ntstatus.h"
  25 #define WIN32_NO_STATUS
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winternl.h"
  29 #include "winnls.h"
  30 #include "wingdi.h"
  31 #include "winuser.h"
  32 #include "psapi.h"
  33 #include "werapi.h"
  34
  35 #include "wine/exception.h"
  36 #include "wine/server.h"
  37 #include "wine/asm.h"
  38 #include "kernelbase.h"
  39 #include "wine/debug.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(seh);
  42 WINE_DECLARE_DEBUG_CHANNEL(winedbg);
  43
  44 typedef INT (WINAPI *MessageBoxA_funcptr)(HWND,LPCSTR,LPCSTR,UINT);
  45 typedef INT (WINAPI *MessageBoxW_funcptr)(HWND,LPCWSTR,LPCWSTR,UINT);
  46
  47 static PTOP_LEVEL_EXCEPTION_FILTER top_filter;
  48
  49 void *dummy = RtlUnwind;  /* force importing RtlUnwind from ntdll */
  50
  51 /***********************************************************************
  52  *           CheckRemoteDebuggerPresent   (kernelbase.@)
  53  */
  54 BOOL WINAPI DECLSPEC_HOTPATCH CheckRemoteDebuggerPresent( HANDLE process, BOOL *present )
  55 {
  56     DWORD_PTR port;
  57
  58     if (!process || !present)
  59     {
  60         SetLastError( ERROR_INVALID_PARAMETER );
  61         return FALSE;
  62     }
  63     if (!set_ntstatus( NtQueryInformationProcess( process, ProcessDebugPort, &port, sizeof(port), NULL )))
  64         return FALSE;
  65     *present = !!port;
  66     return TRUE;
  67 }
  68
  69
  70 /**********************************************************************
  71  *           ContinueDebugEvent   (kernelbase.@)
  72  */
  73 BOOL WINAPI DECLSPEC_HOTPATCH ContinueDebugEvent( DWORD pid, DWORD tid, DWORD status )
  74 {
  75     BOOL ret;
  76     SERVER_START_REQ( continue_debug_event )
  77     {
  78         req->pid    = pid;
  79         req->tid    = tid;
  80         req->status = status;
  81         ret = !wine_server_call_err( req );
  82     }
  83     SERVER_END_REQ;
  84     return ret;
  85 }
  86
  87
  88 /**********************************************************************
  89  *           DebugActiveProcess   (kernelbase.@)
  90  */
  91 BOOL WINAPI DECLSPEC_HOTPATCH DebugActiveProcess( DWORD pid )
  92 {
  93     HANDLE process;
  94     BOOL ret;
  95
  96     SERVER_START_REQ( debug_process )
  97     {
  98         req->pid = pid;
  99         req->attach = 1;
 100         ret = !wine_server_call_err( req );
 101     }
 102     SERVER_END_REQ;
 103     if (!ret) return FALSE;
 104
 105     if (!(process = OpenProcess( PROCESS_CREATE_THREAD, FALSE, pid ))) return FALSE;
 106     ret = set_ntstatus( DbgUiIssueRemoteBreakin( process ));
 107     NtClose( process );
 108     if (!ret) DebugActiveProcessStop( pid );
 109     return ret;
 110 }
 111
 112
 113 /**********************************************************************
 114  *           DebugActiveProcessStop   (kernelbase.@)
 115  */
 116 BOOL WINAPI DECLSPEC_HOTPATCH DebugActiveProcessStop( DWORD pid )
 117 {
 118     BOOL ret;
 119
 120     SERVER_START_REQ( debug_process )
 121     {
 122         req->pid = pid;
 123         req->attach = 0;
 124         ret = !wine_server_call_err( req );
 125     }
 126     SERVER_END_REQ;
 127     return ret;
 128 }
 129
 130
 131 /***********************************************************************
 132  *           DebugBreak   (kernelbase.@)
 133  */
 134 #if defined(__i386__) || defined(__x86_64__)
 135 __ASM_STDCALL_FUNC( DebugBreak, 0, "jmp " __ASM_STDCALL("DbgBreakPoint", 0) )
 136 #else
 137 void WINAPI DebugBreak(void)
 138 {
 139     DbgBreakPoint();
 140 }
 141 #endif
 142
 143
 144 /**************************************************************************
 145  *           FatalAppExitA   (kernelbase.@)
 146  */
 147 void WINAPI DECLSPEC_HOTPATCH FatalAppExitA( UINT action, LPCSTR str )
 148 {
 149     HMODULE mod = GetModuleHandleA( "user32.dll" );
 150     MessageBoxA_funcptr pMessageBoxA = NULL;
 151
 152     if (mod) pMessageBoxA = (MessageBoxA_funcptr)GetProcAddress( mod, "MessageBoxA" );
 153     if (pMessageBoxA) pMessageBoxA( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
 154     else ERR( "%s\n", debugstr_a(str) );
 155     RtlExitUserProcess( 1 );
 156 }
 157
 158
 159 /**************************************************************************
 160  *           FatalAppExitW   (kernelbase.@)
 161  */
 162 void WINAPI DECLSPEC_HOTPATCH FatalAppExitW( UINT action, LPCWSTR str )
 163 {
 164     HMODULE mod = GetModuleHandleW( L"user32.dll" );
 165     MessageBoxW_funcptr pMessageBoxW = NULL;
 166
 167     if (mod) pMessageBoxW = (MessageBoxW_funcptr)GetProcAddress( mod, "MessageBoxW" );
 168     if (pMessageBoxW) pMessageBoxW( 0, str, NULL, MB_SYSTEMMODAL | MB_OK );
 169     else ERR( "%s\n", debugstr_w(str) );
 170     RtlExitUserProcess( 1 );
 171 }
 172
 173
 174 /***********************************************************************
 175  *           IsDebuggerPresent   (kernelbase.@)
 176  */
 177 BOOL WINAPI IsDebuggerPresent(void)
 178 {
 179     return NtCurrentTeb()->Peb->BeingDebugged;
 180 }
 181
 182
 183 static LONG WINAPI debug_exception_handler( EXCEPTION_POINTERS *eptr )
 184 {
 185     EXCEPTION_RECORD *rec = eptr->ExceptionRecord;
 186     return (rec->ExceptionCode == DBG_PRINTEXCEPTION_C) ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH;
 187 }
 188
 189 /***********************************************************************
 190  *           OutputDebugStringA   (kernelbase.@)
 191  */
 192 void WINAPI DECLSPEC_HOTPATCH OutputDebugStringA( LPCSTR str )
 193 {
 194     static HANDLE DBWinMutex = NULL;
 195     static BOOL mutex_inited = FALSE;
 196     BOOL caught_by_dbg = TRUE;
 197
 198     if (!str) str = "";
 199     WARN( "%s\n", debugstr_a(str) );
 200
 201     /* raise exception, WaitForDebugEvent() will generate a corresponding debug event */
 202     __TRY
 203     {
 204         ULONG_PTR args[2];
 205         args[0] = strlen(str) + 1;
 206         args[1] = (ULONG_PTR)str;
 207         RaiseException( DBG_PRINTEXCEPTION_C, 0, 2, args );
 208     }
 209     __EXCEPT(debug_exception_handler)
 210     {
 211         caught_by_dbg = FALSE;
 212     }
 213     __ENDTRY
 214     if (caught_by_dbg) return;
 215
 216     /* send string to a system-wide monitor */
 217     if (!mutex_inited)
 218     {
 219         /* first call to OutputDebugString, initialize mutex handle */
 220         HANDLE mutex = CreateMutexExW( NULL, L"DBWinMutex", 0, SYNCHRONIZE );
 221         if (mutex)
 222         {
 223             if (InterlockedCompareExchangePointer( &DBWinMutex, mutex, 0 ) != 0)
 224                 /* someone beat us here... */
 225                 CloseHandle( mutex );
 226         }
 227         mutex_inited = TRUE;
 228     }
 229
 230     if (DBWinMutex)
 231     {
 232         HANDLE mapping;
 233
 234         mapping = OpenFileMappingW( FILE_MAP_WRITE, FALSE, L"DBWIN_BUFFER" );
 235         if (mapping)
 236         {
 237             LPVOID buffer;
 238             HANDLE eventbuffer, eventdata;
 239
 240             buffer = MapViewOfFile( mapping, FILE_MAP_WRITE, 0, 0, 0 );
 241             eventbuffer = OpenEventW( SYNCHRONIZE, FALSE, L"DBWIN_BUFFER_READY" );
 242             eventdata = OpenEventW( EVENT_MODIFY_STATE, FALSE, L"DBWIN_DATA_READY" );
 243
 244             if (buffer && eventbuffer && eventdata)
 245             {
 246                 /* monitor is present, synchronize with other OutputDebugString invocations */
 247                 WaitForSingleObject( DBWinMutex, INFINITE );
 248
 249                 /* acquire control over the buffer */
 250                 if (WaitForSingleObject( eventbuffer, 10000 ) == WAIT_OBJECT_0)
 251                 {
 252                     int str_len = strlen( str );
 253                     struct _mon_buffer_t
 254                     {
 255                         DWORD pid;
 256                         char buffer[1];
 257                     } *mon_buffer = (struct _mon_buffer_t*) buffer;
 258
 259                     if (str_len > (4096 - sizeof(DWORD) - 1)) str_len = 4096 - sizeof(DWORD) - 1;
 260                     mon_buffer->pid = GetCurrentProcessId();
 261                     memcpy( mon_buffer->buffer, str, str_len );
 262                     mon_buffer->buffer[str_len] = 0;
 263
 264                     /* signal data ready */
 265                     SetEvent( eventdata );
 266                 }
 267                 ReleaseMutex( DBWinMutex );
 268             }
 269
 270             if (buffer) UnmapViewOfFile( buffer );
 271             if (eventbuffer) CloseHandle( eventbuffer );
 272             if (eventdata) CloseHandle( eventdata );
 273             CloseHandle( mapping );
 274         }
 275     }
 276 }
 277
 278
 279 /***********************************************************************
 280  *           OutputDebugStringW   (kernelbase.@)
 281  */
 282 void WINAPI DECLSPEC_HOTPATCH OutputDebugStringW( LPCWSTR str )
 283 {
 284     UNICODE_STRING strW;
 285     STRING strA;
 286
 287     RtlInitUnicodeString( &strW, str );
 288     if (!RtlUnicodeStringToAnsiString( &strA, &strW, TRUE ))
 289     {
 290         OutputDebugStringA( strA.Buffer );
 291         RtlFreeAnsiString( &strA );
 292     }
 293 }
 294
 295
 296 /*******************************************************************
 297  *           RaiseException  (kernelbase.@)
 298  */
 299 void WINAPI DECLSPEC_HOTPATCH RaiseException( DWORD code, DWORD flags, DWORD count, const ULONG_PTR *args )
 300 {
 301     EXCEPTION_RECORD record;
 302
 303     record.ExceptionCode    = code;
 304     record.ExceptionFlags   = flags & EH_NONCONTINUABLE;
 305     record.ExceptionRecord  = NULL;
 306     record.ExceptionAddress = RaiseException;
 307     if (count && args)
 308     {
 309         if (count > EXCEPTION_MAXIMUM_PARAMETERS) count = EXCEPTION_MAXIMUM_PARAMETERS;
 310         record.NumberParameters = count;
 311         memcpy( record.ExceptionInformation, args, count * sizeof(*args) );
 312     }
 313     else record.NumberParameters = 0;
 314
 315     RtlRaiseException( &record );
 316 }
 317
 318
 319 /***********************************************************************
 320  *           SetUnhandledExceptionFilter   (kernelbase.@)
 321  */
 322 LPTOP_LEVEL_EXCEPTION_FILTER WINAPI DECLSPEC_HOTPATCH SetUnhandledExceptionFilter(
 323     LPTOP_LEVEL_EXCEPTION_FILTER filter )
 324 {
 325     return InterlockedExchangePointer( (void **)&top_filter, filter );
 326 }
 327
 328
 329 /******************************************************************************
 330  *           WaitForDebugEvent   (kernelbase.@)
 331  */
 332 BOOL WINAPI DECLSPEC_HOTPATCH WaitForDebugEvent( DEBUG_EVENT *event, DWORD timeout )
 333 {
 334     BOOL ret;
 335     DWORD res;
 336     int i;
 337
 338     for (;;)
 339     {
 340         HANDLE wait = 0;
 341         debug_event_t data;
 342         SERVER_START_REQ( wait_debug_event )
 343         {
 344             req->get_handle = (timeout != 0);
 345             wine_server_set_reply( req, &data, sizeof(data) );
 346             if (!(ret = !wine_server_call_err( req ))) goto done;
 347
 348             if (!wine_server_reply_size( reply ))  /* timeout */
 349             {
 350                 wait = wine_server_ptr_handle( reply->wait );
 351                 ret = FALSE;
 352                 goto done;
 353             }
 354             event->dwDebugEventCode = data.code;
 355             event->dwProcessId      = (DWORD)reply->pid;
 356             event->dwThreadId       = (DWORD)reply->tid;
 357             switch (data.code)
 358             {
 359             case EXCEPTION_DEBUG_EVENT:
 360                 if (data.exception.exc_code == DBG_PRINTEXCEPTION_C && data.exception.nb_params >= 2)
 361                 {
 362                     event->dwDebugEventCode = OUTPUT_DEBUG_STRING_EVENT;
 363                     event->u.DebugString.lpDebugStringData  = wine_server_get_ptr( data.exception.params[1] );
 364                     event->u.DebugString.fUnicode           = FALSE;
 365                     event->u.DebugString.nDebugStringLength = data.exception.params[0];
 366                     break;
 367                 }
 368                 else if (data.exception.exc_code == DBG_RIPEXCEPTION && data.exception.nb_params >= 2)
 369                 {
 370                     event->dwDebugEventCode = RIP_EVENT;
 371                     event->u.RipInfo.dwError = data.exception.params[0];
 372                     event->u.RipInfo.dwType  = data.exception.params[1];
 373                     break;
 374                 }
 375                 event->u.Exception.dwFirstChance = data.exception.first;
 376                 event->u.Exception.ExceptionRecord.ExceptionCode    = data.exception.exc_code;
 377                 event->u.Exception.ExceptionRecord.ExceptionFlags   = data.exception.flags;
 378                 event->u.Exception.ExceptionRecord.ExceptionRecord  = wine_server_get_ptr( data.exception.record );
 379                 event->u.Exception.ExceptionRecord.ExceptionAddress = wine_server_get_ptr( data.exception.address );
 380                 event->u.Exception.ExceptionRecord.NumberParameters = data.exception.nb_params;
 381                 for (i = 0; i < data.exception.nb_params; i++)
 382                     event->u.Exception.ExceptionRecord.ExceptionInformation[i] = data.exception.params[i];
 383                 break;
 384             case CREATE_THREAD_DEBUG_EVENT:
 385                 event->u.CreateThread.hThread           = wine_server_ptr_handle( data.create_thread.handle );
 386                 event->u.CreateThread.lpThreadLocalBase = wine_server_get_ptr( data.create_thread.teb );
 387                 event->u.CreateThread.lpStartAddress    = wine_server_get_ptr( data.create_thread.start );
 388                 break;
 389             case CREATE_PROCESS_DEBUG_EVENT:
 390                 event->u.CreateProcessInfo.hFile                 = wine_server_ptr_handle( data.create_process.file );
 391                 event->u.CreateProcessInfo.hProcess              = wine_server_ptr_handle( data.create_process.process );
 392                 event->u.CreateProcessInfo.hThread               = wine_server_ptr_handle( data.create_process.thread );
 393                 event->u.CreateProcessInfo.lpBaseOfImage         = wine_server_get_ptr( data.create_process.base );
 394                 event->u.CreateProcessInfo.dwDebugInfoFileOffset = data.create_process.dbg_offset;
 395                 event->u.CreateProcessInfo.nDebugInfoSize        = data.create_process.dbg_size;
 396                 event->u.CreateProcessInfo.lpThreadLocalBase     = wine_server_get_ptr( data.create_process.teb );
 397                 event->u.CreateProcessInfo.lpStartAddress        = wine_server_get_ptr( data.create_process.start );
 398                 event->u.CreateProcessInfo.lpImageName           = wine_server_get_ptr( data.create_process.name );
 399                 event->u.CreateProcessInfo.fUnicode              = data.create_process.unicode;
 400                 break;
 401             case EXIT_THREAD_DEBUG_EVENT:
 402                 event->u.ExitThread.dwExitCode = data.exit.exit_code;
 403                 break;
 404             case EXIT_PROCESS_DEBUG_EVENT:
 405                 event->u.ExitProcess.dwExitCode = data.exit.exit_code;
 406                 break;
 407             case LOAD_DLL_DEBUG_EVENT:
 408                 event->u.LoadDll.hFile                 = wine_server_ptr_handle( data.load_dll.handle );
 409                 event->u.LoadDll.lpBaseOfDll           = wine_server_get_ptr( data.load_dll.base );
 410                 event->u.LoadDll.dwDebugInfoFileOffset = data.load_dll.dbg_offset;
 411                 event->u.LoadDll.nDebugInfoSize        = data.load_dll.dbg_size;
 412                 event->u.LoadDll.lpImageName           = wine_server_get_ptr( data.load_dll.name );
 413                 event->u.LoadDll.fUnicode              = data.load_dll.unicode;
 414                 break;
 415             case UNLOAD_DLL_DEBUG_EVENT:
 416                 event->u.UnloadDll.lpBaseOfDll = wine_server_get_ptr( data.unload_dll.base );
 417                 break;
 418             }
 419         done:
 420             /* nothing */ ;
 421         }
 422         SERVER_END_REQ;
 423         if (ret) return TRUE;
 424         if (!wait) break;
 425         res = WaitForSingleObject( wait, timeout );
 426         CloseHandle( wait );
 427         if (res != STATUS_WAIT_0) break;
 428     }
 429     SetLastError( ERROR_SEM_TIMEOUT );
 430     return FALSE;
 431 }
 432
 433
 434 /*******************************************************************
 435  *         format_exception_msg
 436  */
 437 static void format_exception_msg( const EXCEPTION_POINTERS *ptr, char *buffer, int size )
 438 {
 439     const EXCEPTION_RECORD *rec = ptr->ExceptionRecord;
 440     int len;
 441
 442     switch(rec->ExceptionCode)
 443     {
 444     case EXCEPTION_INT_DIVIDE_BY_ZERO:
 445         len = snprintf( buffer, size, "Unhandled division by zero" );
 446         break;
 447     case EXCEPTION_INT_OVERFLOW:
 448         len = snprintf( buffer, size, "Unhandled overflow" );
 449         break;
 450     case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
 451         len = snprintf( buffer, size, "Unhandled array bounds" );
 452         break;
 453     case EXCEPTION_ILLEGAL_INSTRUCTION:
 454         len = snprintf( buffer, size, "Unhandled illegal instruction" );
 455         break;
 456     case EXCEPTION_STACK_OVERFLOW:
 457         len = snprintf( buffer, size, "Unhandled stack overflow" );
 458         break;
 459     case EXCEPTION_PRIV_INSTRUCTION:
 460         len = snprintf( buffer, size, "Unhandled privileged instruction" );
 461         break;
 462     case EXCEPTION_ACCESS_VIOLATION:
 463         if (rec->NumberParameters == 2)
 464             len = snprintf( buffer, size, "Unhandled page fault on %s access to %p",
 465                             rec->ExceptionInformation[0] == EXCEPTION_WRITE_FAULT ? "write" :
 466                             rec->ExceptionInformation[0] == EXCEPTION_EXECUTE_FAULT ? "execute" : "read",
 467                             (void *)rec->ExceptionInformation[1]);
 468         else
 469             len = snprintf( buffer, size, "Unhandled page fault");
 470         break;
 471     case EXCEPTION_DATATYPE_MISALIGNMENT:
 472         len = snprintf( buffer, size, "Unhandled alignment" );
 473         break;
 474     case CONTROL_C_EXIT:
 475         len = snprintf( buffer, size, "Unhandled ^C");
 476         break;
 477     case STATUS_POSSIBLE_DEADLOCK:
 478         len = snprintf( buffer, size, "Critical section %p wait failed",
 479                         (void *)rec->ExceptionInformation[0]);
 480         break;
 481     case EXCEPTION_WINE_STUB:
 482         if ((ULONG_PTR)rec->ExceptionInformation[1] >> 16)
 483             len = snprintf( buffer, size, "Unimplemented function %s.%s called",
 484                             (char *)rec->ExceptionInformation[0], (char *)rec->ExceptionInformation[1] );
 485         else
 486             len = snprintf( buffer, size, "Unimplemented function %s.%ld called",
 487                             (char *)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
 488         break;
 489     case EXCEPTION_WINE_ASSERTION:
 490         len = snprintf( buffer, size, "Assertion failed" );
 491         break;
 492     default:
 493         len = snprintf( buffer, size, "Unhandled exception 0x%08x in thread %x",
 494                         rec->ExceptionCode, GetCurrentThreadId());
 495         break;
 496     }
 497     if (len < 0 || len >= size) return;
 498     snprintf( buffer + len,  size - len, " at address %p", ptr->ExceptionRecord->ExceptionAddress );
 499 }
 500
 501
 502 /******************************************************************
 503  *              start_debugger
 504  *
 505  * Does the effective debugger startup according to 'format'
 506  */
 507 static BOOL start_debugger( EXCEPTION_POINTERS *epointers, HANDLE event )
 508 {
 509     OBJECT_ATTRIBUTES attr;
 510     UNICODE_STRING nameW;
 511     WCHAR *cmdline, *env, *p, *format = NULL;
 512     HANDLE dbg_key;
 513     DWORD autostart = TRUE;
 514     PROCESS_INFORMATION info;
 515     STARTUPINFOW startup;
 516     BOOL ret = FALSE;
 517     char buffer[256];
 518
 519     format_exception_msg( epointers, buffer, sizeof(buffer) );
 520     MESSAGE( "wine: %s (thread %04x), starting debugger...\n", buffer, GetCurrentThreadId() );
 521
 522     attr.Length = sizeof(attr);
 523     attr.RootDirectory = 0;
 524     attr.ObjectName = &nameW;
 525     attr.Attributes = 0;
 526     attr.SecurityDescriptor = NULL;
 527     attr.SecurityQualityOfService = NULL;
 528     RtlInitUnicodeString( &nameW, L"\\Registry\\Machine\\Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug" );
 529
 530     if (!NtOpenKey( &dbg_key, KEY_READ, &attr ))
 531     {
 532         KEY_VALUE_PARTIAL_INFORMATION *info;
 533         DWORD format_size = 0;
 534
 535         RtlInitUnicodeString( &nameW, L"Debugger" );
 536         if (NtQueryValueKey( dbg_key, &nameW, KeyValuePartialInformation,
 537                              NULL, 0, &format_size ) == STATUS_BUFFER_TOO_SMALL)
 538         {
 539             char *data = HeapAlloc( GetProcessHeap(), 0, format_size );
 540             NtQueryValueKey( dbg_key, &nameW, KeyValuePartialInformation,
 541                              data, format_size, &format_size );
 542             info = (KEY_VALUE_PARTIAL_INFORMATION *)data;
 543             format = HeapAlloc( GetProcessHeap(), 0, info->DataLength + sizeof(WCHAR) );
 544             memcpy( format, info->Data, info->DataLength );
 545             format[info->DataLength / sizeof(WCHAR)] = 0;
 546
 547             if (info->Type == REG_EXPAND_SZ)
 548             {
 549                 WCHAR *tmp;
 550
 551                 format_size = ExpandEnvironmentStringsW( format, NULL, 0 );
 552                 tmp = HeapAlloc( GetProcessHeap(), 0, format_size * sizeof(WCHAR));
 553                 ExpandEnvironmentStringsW( format, tmp, format_size );
 554                 HeapFree( GetProcessHeap(), 0, format );
 555                 format = tmp;
 556             }
 557             HeapFree( GetProcessHeap(), 0, data );
 558         }
 559
 560         RtlInitUnicodeString( &nameW, L"Auto" );
 561         if (!NtQueryValueKey( dbg_key, &nameW, KeyValuePartialInformation,
 562                               buffer, sizeof(buffer)-sizeof(WCHAR), &format_size ))
 563        {
 564            info = (KEY_VALUE_PARTIAL_INFORMATION *)buffer;
 565            if (info->Type == REG_DWORD) memcpy( &autostart, info->Data, sizeof(DWORD) );
 566            else if (info->Type == REG_SZ)
 567            {
 568                WCHAR *str = (WCHAR *)info->Data;
 569                str[info->DataLength/sizeof(WCHAR)] = 0;
 570                autostart = wcstol( str, NULL, 10 );
 571            }
 572        }
 573
 574        NtClose( dbg_key );
 575     }
 576
 577     if (format)
 578     {
 579         size_t format_size = lstrlenW( format ) + 2*20;
 580         cmdline = HeapAlloc( GetProcessHeap(), 0, format_size * sizeof(WCHAR) );
 581         swprintf( cmdline, format_size, format, (long)GetCurrentProcessId(), (long)HandleToLong(event) );
 582         HeapFree( GetProcessHeap(), 0, format );
 583     }
 584     else
 585     {
 586         cmdline = HeapAlloc( GetProcessHeap(), 0, 80 * sizeof(WCHAR) );
 587         swprintf( cmdline, 80, L"winedbg --auto %ld %ld", (long)GetCurrentProcessId(), (long)HandleToLong(event) );
 588     }
 589
 590     if (!autostart)
 591     {
 592         HMODULE mod = GetModuleHandleA( "user32.dll" );
 593         MessageBoxA_funcptr pMessageBoxA = NULL;
 594
 595         if (mod) pMessageBoxA = (void *)GetProcAddress( mod, "MessageBoxA" );
 596         if (pMessageBoxA)
 597         {
 598             static const char msg[] = ".\nDo you wish to debug it?";
 599
 600             format_exception_msg( epointers, buffer, sizeof(buffer) - sizeof(msg) );
 601             strcat( buffer, msg );
 602             if (pMessageBoxA( 0, buffer, "Exception raised", MB_YESNO | MB_ICONHAND ) == IDNO)
 603             {
 604                 TRACE( "Killing process\n" );
 605                 goto exit;
 606             }
 607         }
 608     }
 609
 610     /* make WINEDEBUG empty in the environment */
 611     env = GetEnvironmentStringsW();
 612     if (!TRACE_ON(winedbg))
 613     {
 614         for (p = env; *p; p += lstrlenW(p) + 1)
 615         {
 616             if (!wcsncmp( p, L"WINEDEBUG=", 10 ))
 617             {
 618                 WCHAR *next = p + lstrlenW(p);
 619                 WCHAR *end = next + 1;
 620                 while (*end) end += lstrlenW(end) + 1;
 621                 memmove( p + 10, next, end + 1 - next );
 622                 break;
 623             }
 624         }
 625     }
 626
 627     TRACE( "Starting debugger %s\n", debugstr_w(cmdline) );
 628     memset( &startup, 0, sizeof(startup) );
 629     startup.cb = sizeof(startup);
 630     startup.dwFlags = STARTF_USESHOWWINDOW;
 631     startup.wShowWindow = SW_SHOWNORMAL;
 632     ret = CreateProcessW( NULL, cmdline, NULL, NULL, TRUE, 0, env, NULL, &startup, &info );
 633     FreeEnvironmentStringsW( env );
 634
 635     if (ret)
 636     {
 637         /* wait for debugger to come up... */
 638         HANDLE handles[2];
 639         CloseHandle( info.hThread );
 640         handles[0] = event;
 641         handles[1] = info.hProcess;
 642         WaitForMultipleObjects( 2, handles, FALSE, INFINITE );
 643         CloseHandle( info.hProcess );
 644     }
 645     else ERR( "Couldn't start debugger %s (%d)\n"
 646               "Read the Wine Developers Guide on how to set up winedbg or another debugger\n",
 647               debugstr_w(cmdline), GetLastError() );
 648 exit:
 649     HeapFree(GetProcessHeap(), 0, cmdline);
 650     return ret;
 651 }
 652
 653 /******************************************************************
 654  *              start_debugger_atomic
 655  *
 656  * starts the debugger in an atomic way:
 657  *      - either the debugger is not started and it is started
 658  *      - or the debugger has already been started by another thread
 659  *      - or the debugger couldn't be started
 660  *
 661  * returns TRUE for the two first conditions, FALSE for the last
 662  */
 663 static BOOL start_debugger_atomic( EXCEPTION_POINTERS *epointers )
 664 {
 665     static HANDLE once;
 666
 667     if (once == 0)
 668     {
 669         OBJECT_ATTRIBUTES attr;
 670         HANDLE event;
 671
 672         attr.Length                   = sizeof(attr);
 673         attr.RootDirectory            = 0;
 674         attr.Attributes               = OBJ_INHERIT;
 675         attr.ObjectName               = NULL;
 676         attr.SecurityDescriptor       = NULL;
 677         attr.SecurityQualityOfService = NULL;
 678
 679         /* ask for manual reset, so that once the debugger is started,
 680          * every thread will know it */
 681         NtCreateEvent( &event, EVENT_ALL_ACCESS, &attr, NotificationEvent, FALSE );
 682         if (InterlockedCompareExchangePointer( &once, event, 0 ) == 0)
 683         {
 684             /* ok, our event has been set... we're the winning thread */
 685             BOOL ret = start_debugger( epointers, once );
 686
 687             if (!ret)
 688             {
 689                 /* so that the other threads won't be stuck */
 690                 NtSetEvent( once, NULL );
 691             }
 692             return ret;
 693         }
 694
 695         /* someone beat us here... */
 696         CloseHandle( event );
 697     }
 698
 699     /* and wait for the winner to have actually created the debugger */
 700     WaitForSingleObject( once, INFINITE );
 701     /* in fact, here, we only know that someone has tried to start the debugger,
 702      * we'll know by reposting the exception if it has actually attached
 703      * to the current process */
 704     return TRUE;
 705 }
 706
 707
 708 /*******************************************************************
 709  *         check_resource_write
 710  *
 711  * Check if the exception is a write attempt to the resource data.
 712  * If yes, we unprotect the resources to let broken apps continue
 713  * (Windows does this too).
 714  */
 715 static BOOL check_resource_write( void *addr )
 716 {
 717     DWORD old_prot;
 718     void *rsrc;
 719     DWORD size;
 720     MEMORY_BASIC_INFORMATION info;
 721
 722     if (!VirtualQuery( addr, &info, sizeof(info) )) return FALSE;
 723     if (info.State == MEM_FREE || !(info.Type & MEM_IMAGE)) return FALSE;
 724     if (!(rsrc = RtlImageDirectoryEntryToData( info.AllocationBase, TRUE,
 725                                                IMAGE_DIRECTORY_ENTRY_RESOURCE, &size )))
 726         return FALSE;
 727     if (addr < rsrc || (char *)addr >= (char *)rsrc + size) return FALSE;
 728     TRACE( "Broken app is writing to the resource data, enabling work-around\n" );
 729     VirtualProtect( rsrc, size, PAGE_READWRITE, &old_prot );
 730     return TRUE;
 731 }
 732
 733
 734 /*******************************************************************
 735  *         UnhandledExceptionFilter   (kernelbase.@)
 736  */
 737 LONG WINAPI UnhandledExceptionFilter( EXCEPTION_POINTERS *epointers )
 738 {
 739     const EXCEPTION_RECORD *rec = epointers->ExceptionRecord;
 740
 741     if (rec->ExceptionCode == EXCEPTION_ACCESS_VIOLATION && rec->NumberParameters >= 2)
 742     {
 743         switch (rec->ExceptionInformation[0])
 744         {
 745         case EXCEPTION_WRITE_FAULT:
 746             if (check_resource_write( (void *)rec->ExceptionInformation[1] ))
 747                 return EXCEPTION_CONTINUE_EXECUTION;
 748             break;
 749         }
 750     }
 751
 752     if (!NtCurrentTeb()->Peb->BeingDebugged)
 753     {
 754         if (rec->ExceptionCode == CONTROL_C_EXIT)
 755         {
 756             /* do not launch the debugger on ^C, simply terminate the process */
 757             TerminateProcess( GetCurrentProcess(), 1 );
 758         }
 759
 760         if (top_filter)
 761         {
 762             LONG ret = top_filter( epointers );
 763             if (ret != EXCEPTION_CONTINUE_SEARCH) return ret;
 764         }
 765
 766         /* FIXME: Should check the current error mode */
 767
 768         if (!start_debugger_atomic( epointers ) || !NtCurrentTeb()->Peb->BeingDebugged)
 769             return EXCEPTION_EXECUTE_HANDLER;
 770     }
 771     return EXCEPTION_CONTINUE_SEARCH;
 772 }
 773
 774
 775 /***********************************************************************
 776  *         WerGetFlags   (kernelbase.@)
 777  */
 778 HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerGetFlags( HANDLE process, DWORD *flags )
 779 {
 780     FIXME( "(%p, %p) stub\n", process, flags );
 781     return E_NOTIMPL;
 782 }
 783
 784
 785 /***********************************************************************
 786  *         WerRegisterFile   (kernelbase.@)
 787  */
 788 HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerRegisterFile( const WCHAR *file, WER_REGISTER_FILE_TYPE type,
 789                                                         DWORD flags )
 790 {
 791     FIXME( "(%s, %d, %d) stub\n", debugstr_w(file), type, flags );
 792     return E_NOTIMPL;
 793 }
 794
 795
 796 /***********************************************************************
 797  *         WerRegisterMemoryBlock   (kernelbase.@)
 798  */
 799 HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerRegisterMemoryBlock( void *block, DWORD size )
 800 {
 801     FIXME( "(%p %d) stub\n", block, size );
 802     return E_NOTIMPL;
 803 }
 804
 805
 806 /***********************************************************************
 807  *         WerRegisterRuntimeExceptionModule   (kernelbase.@)
 808  */
 809 HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerRegisterRuntimeExceptionModule( const WCHAR *dll, void *context )
 810 {
 811     FIXME( "(%s, %p) stub\n", debugstr_w(dll), context );
 812     return S_OK;
 813 }
 814
 815
 816 /***********************************************************************
 817  *         WerSetFlags   (kernelbase.@)
 818  */
 819 HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerSetFlags( DWORD flags )
 820 {
 821     FIXME("(%d) stub\n", flags);
 822     return S_OK;
 823 }
 824
 825
 826 /***********************************************************************
 827  *         WerUnregisterFile   (kernelbase.@)
 828  */
 829 HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerUnregisterFile( const WCHAR *file )
 830 {
 831     FIXME( "(%s) stub\n", debugstr_w(file) );
 832     return E_NOTIMPL;
 833 }
 834
 835
 836 /***********************************************************************
 837  *         WerUnregisterMemoryBlock   (kernelbase.@)
 838  */
 839 HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerUnregisterMemoryBlock( void *block )
 840 {
 841     FIXME( "(%p) stub\n", block );
 842     return E_NOTIMPL;
 843 }
 844
 845
 846 /***********************************************************************
 847  *         WerUnregisterRuntimeExceptionModule   (kernelbase.@)
 848  */
 849 HRESULT WINAPI /* DECLSPEC_HOTPATCH */ WerUnregisterRuntimeExceptionModule( const WCHAR *dll, void *context )
 850 {
 851     FIXME( "(%s, %p) stub\n", debugstr_w(dll), context );
 852     return S_OK;
 853 }
 854
 855
 856 /***********************************************************************
 857  * psapi functions
 858  ***********************************************************************/
 859
 860
 861 typedef struct _PEB32
 862 {
 863     BOOLEAN InheritedAddressSpace;
 864     BOOLEAN ReadImageFileExecOptions;
 865     BOOLEAN BeingDebugged;
 866     BOOLEAN SpareBool;
 867     DWORD   Mutant;
 868     DWORD   ImageBaseAddress;
 869     DWORD   LdrData;
 870 } PEB32;
 871
 872 typedef struct _LIST_ENTRY32
 873 {
 874     DWORD Flink;
 875     DWORD Blink;
 876 } LIST_ENTRY32;
 877
 878 typedef struct _PEB_LDR_DATA32
 879 {
 880     ULONG        Length;
 881     BOOLEAN      Initialized;
 882     DWORD        SsHandle;
 883     LIST_ENTRY32 InLoadOrderModuleList;
 884 } PEB_LDR_DATA32;
 885
 886 typedef struct _UNICODE_STRING32
 887 {
 888     USHORT Length;
 889     USHORT MaximumLength;
 890     DWORD  Buffer;
 891 } UNICODE_STRING32;
 892
 893 typedef struct _LDR_DATA_TABLE_ENTRY32
 894 {
 895     LIST_ENTRY32        InLoadOrderModuleList;
 896     LIST_ENTRY32        InMemoryOrderModuleList;
 897     LIST_ENTRY32        InInitializationOrderModuleList;
 898     DWORD               BaseAddress;
 899     DWORD               EntryPoint;
 900     ULONG               SizeOfImage;
 901     UNICODE_STRING32    FullDllName;
 902     UNICODE_STRING32    BaseDllName;
 903 } LDR_DATA_TABLE_ENTRY32;
 904
 905 struct module_iterator
 906 {
 907     HANDLE                 process;
 908     LIST_ENTRY            *head;
 909     LIST_ENTRY            *current;
 910     BOOL                   wow64;
 911     LDR_DATA_TABLE_ENTRY   ldr_module;
 912     LDR_DATA_TABLE_ENTRY32 ldr_module32;
 913 };
 914
 915
 916 static BOOL init_module_iterator( struct module_iterator *iter, HANDLE process )
 917 {
 918     PROCESS_BASIC_INFORMATION pbi;
 919     PPEB_LDR_DATA ldr_data;
 920
 921     if (!IsWow64Process( process, &iter->wow64 )) return FALSE;
 922
 923     /* get address of PEB */
 924     if (!set_ntstatus( NtQueryInformationProcess( process, ProcessBasicInformation,
 925                                                   &pbi, sizeof(pbi), NULL )))
 926         return FALSE;
 927
 928     if (is_win64 && iter->wow64)
 929     {
 930         PEB_LDR_DATA32 *ldr_data32_ptr;
 931         DWORD ldr_data32, first_module;
 932         PEB32 *peb32;
 933
 934         peb32 = (PEB32 *)(DWORD_PTR)pbi.PebBaseAddress;
 935         if (!ReadProcessMemory( process, &peb32->LdrData, &ldr_data32, sizeof(ldr_data32), NULL ))
 936             return FALSE;
 937         ldr_data32_ptr = (PEB_LDR_DATA32 *)(DWORD_PTR) ldr_data32;
 938         if (!ReadProcessMemory( process, &ldr_data32_ptr->InLoadOrderModuleList.Flink,
 939                                 &first_module, sizeof(first_module), NULL ))
 940             return FALSE;
 941         iter->head = (LIST_ENTRY *)&ldr_data32_ptr->InLoadOrderModuleList;
 942         iter->current = (LIST_ENTRY *)(DWORD_PTR)first_module;
 943         iter->process = process;
 944         return TRUE;
 945     }
 946
 947     /* read address of LdrData from PEB */
 948     if (!ReadProcessMemory( process, &pbi.PebBaseAddress->LdrData, &ldr_data, sizeof(ldr_data), NULL ))
 949         return FALSE;
 950
 951     /* read address of first module from LdrData */
 952     if (!ReadProcessMemory( process, &ldr_data->InLoadOrderModuleList.Flink,
 953                             &iter->current, sizeof(iter->current), NULL ))
 954         return FALSE;
 955
 956     iter->head = &ldr_data->InLoadOrderModuleList;
 957     iter->process = process;
 958     return TRUE;
 959 }
 960
 961
 962 static int module_iterator_next( struct module_iterator *iter )
 963 {
 964     if (iter->current == iter->head) return 0;
 965
 966     if (is_win64 && iter->wow64)
 967     {
 968         LIST_ENTRY32 *entry32 = (LIST_ENTRY32 *)iter->current;
 969
 970         if (!ReadProcessMemory( iter->process,
 971                                 CONTAINING_RECORD(entry32, LDR_DATA_TABLE_ENTRY32, InLoadOrderModuleList),
 972                                 &iter->ldr_module32, sizeof(iter->ldr_module32), NULL ))
 973             return -1;
 974         iter->current = (LIST_ENTRY *)(DWORD_PTR)iter->ldr_module32.InLoadOrderModuleList.Flink;
 975         return 1;
 976     }
 977
 978     if (!ReadProcessMemory( iter->process,
 979                             CONTAINING_RECORD(iter->current, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks),
 980                             &iter->ldr_module, sizeof(iter->ldr_module), NULL ))
 981          return -1;
 982
 983     iter->current = iter->ldr_module.InLoadOrderLinks.Flink;
 984     return 1;
 985 }
 986
 987
 988 static BOOL get_ldr_module( HANDLE process, HMODULE module, LDR_DATA_TABLE_ENTRY *ldr_module )
 989 {
 990     struct module_iterator iter;
 991     INT ret;
 992
 993     if (!init_module_iterator( &iter, process )) return FALSE;
 994
 995     while ((ret = module_iterator_next( &iter )) > 0)
 996         /* When hModule is NULL we return the process image - which will be
 997          * the first module since our iterator uses InLoadOrderModuleList */
 998         if (!module || module == iter.ldr_module.DllBase)
 999         {
1000             *ldr_module = iter.ldr_module;
1001             return TRUE;
1002         }
1003
1004     if (ret == 0) SetLastError( ERROR_INVALID_HANDLE );
1005     return FALSE;
1006 }
1007
1008
1009 static BOOL get_ldr_module32( HANDLE process, HMODULE module, LDR_DATA_TABLE_ENTRY32 *ldr_module )
1010 {
1011     struct module_iterator iter;
1012     INT ret;
1013
1014     if (!init_module_iterator( &iter, process )) return FALSE;
1015
1016     while ((ret = module_iterator_next( &iter )) > 0)
1017         /* When hModule is NULL we return the process image - which will be
1018          * the first module since our iterator uses InLoadOrderModuleList */
1019         if (!module || (DWORD)(DWORD_PTR)module == iter.ldr_module32.BaseAddress)
1020         {
1021             *ldr_module = iter.ldr_module32;
1022             return TRUE;
1023         }
1024
1025     if (ret == 0) SetLastError( ERROR_INVALID_HANDLE );
1026     return FALSE;
1027 }
1028
1029
1030 /***********************************************************************
1031  *         K32EmptyWorkingSet   (kernelbase.@)
1032  */
1033 BOOL WINAPI DECLSPEC_HOTPATCH K32EmptyWorkingSet( HANDLE process )
1034 {
1035     return SetProcessWorkingSetSizeEx( process, (SIZE_T)-1, (SIZE_T)-1, 0 );
1036 }
1037
1038
1039 /***********************************************************************
1040  *         K32EnumDeviceDrivers   (kernelbase.@)
1041  */
1042 BOOL WINAPI K32EnumDeviceDrivers( void **image_base, DWORD count, DWORD *needed )
1043 {
1044     FIXME( "(%p, %d, %p): stub\n", image_base, count, needed );
1045     if (needed) *needed = 0;
1046     return TRUE;
1047 }
1048
1049
1050 /***********************************************************************
1051  *         K32EnumPageFilesA   (kernelbase.@)
1052  */
1053 BOOL WINAPI /* DECLSPEC_HOTPATCH */ K32EnumPageFilesA( PENUM_PAGE_FILE_CALLBACKA callback, void *context )
1054 {
1055     FIXME( "(%p, %p) stub\n", callback, context );
1056     return FALSE;
1057 }
1058
1059
1060 /***********************************************************************
1061  *         K32EnumPageFilesW   (kernelbase.@)
1062  */
1063 BOOL WINAPI /* DECLSPEC_HOTPATCH */ K32EnumPageFilesW( PENUM_PAGE_FILE_CALLBACKW callback, void *context )
1064 {
1065     FIXME( "(%p, %p) stub\n", callback, context );
1066     return FALSE;
1067 }
1068
1069
1070 /***********************************************************************
1071  *         K32EnumProcessModules   (kernelbase.@)
1072  */
1073 BOOL WINAPI DECLSPEC_HOTPATCH K32EnumProcessModules( HANDLE process, HMODULE *module,
1074                                                      DWORD count, DWORD *needed )
1075 {
1076     struct module_iterator iter;
1077     DWORD size = 0;
1078     INT ret;
1079
1080     if (process == GetCurrentProcess())
1081     {
1082         PPEB_LDR_DATA ldr_data = NtCurrentTeb()->Peb->LdrData;
1083         PLIST_ENTRY head = &ldr_data->InLoadOrderModuleList;
1084         PLIST_ENTRY entry = head->Flink;
1085
1086         if (count && !module)
1087         {
1088             SetLastError( ERROR_NOACCESS );
1089             return FALSE;
1090         }
1091         while (entry != head)
1092         {
1093             LDR_DATA_TABLE_ENTRY *ldr = CONTAINING_RECORD( entry, LDR_DATA_TABLE_ENTRY, InLoadOrderLinks );
1094             if (count >= sizeof(HMODULE))
1095             {
1096                 *module++ = ldr->DllBase;
1097                 count -= sizeof(HMODULE);
1098             }
1099             size += sizeof(HMODULE);
1100             entry = entry->Flink;
1101         }
1102         if (!needed)
1103         {
1104             SetLastError( ERROR_NOACCESS );
1105             return FALSE;
1106         }
1107         *needed = size;
1108         return TRUE;
1109     }
1110
1111     if (!init_module_iterator( &iter, process )) return FALSE;
1112
1113     if (count && !module)
1114     {
1115         SetLastError( ERROR_NOACCESS );
1116         return FALSE;
1117     }
1118
1119     while ((ret = module_iterator_next( &iter )) > 0)
1120     {
1121         if (count >= sizeof(HMODULE))
1122         {
1123             if (sizeof(void *) == 8 && iter.wow64)
1124                 *module++ = (HMODULE) (DWORD_PTR)iter.ldr_module32.BaseAddress;
1125             else
1126                 *module++ = iter.ldr_module.DllBase;
1127             count -= sizeof(HMODULE);
1128         }
1129         size += sizeof(HMODULE);
1130     }
1131
1132     if (!needed)
1133     {
1134         SetLastError( ERROR_NOACCESS );
1135         return FALSE;
1136     }
1137     *needed = size;
1138     return ret == 0;
1139 }
1140
1141
1142 /***********************************************************************
1143  *         K32EnumProcessModulesEx   (kernelbase.@)
1144  */
1145 BOOL WINAPI K32EnumProcessModulesEx( HANDLE process, HMODULE *module, DWORD count,
1146                                      DWORD *needed, DWORD filter )
1147 {
1148     FIXME( "(%p, %p, %d, %p, %d) semi-stub\n", process, module, count, needed, filter );
1149     return K32EnumProcessModules( process, module, count, needed );
1150 }
1151
1152
1153 /***********************************************************************
1154  *         K32EnumProcesses   (kernelbase.@)
1155  */
1156 BOOL WINAPI K32EnumProcesses( DWORD *ids, DWORD count, DWORD *used )
1157 {
1158     SYSTEM_PROCESS_INFORMATION *spi;
1159     ULONG size = 0x4000;
1160     void *buf = NULL;
1161     NTSTATUS status;
1162
1163     do
1164     {
1165         size *= 2;
1166         HeapFree( GetProcessHeap(), 0, buf );
1167         if (!(buf = HeapAlloc( GetProcessHeap(), 0, size ))) return FALSE;
1168         status = NtQuerySystemInformation( SystemProcessInformation, buf, size, NULL );
1169     } while (status == STATUS_INFO_LENGTH_MISMATCH);
1170
1171     if (!set_ntstatus( status ))
1172     {
1173         HeapFree( GetProcessHeap(), 0, buf );
1174         return FALSE;
1175     }
1176     spi = buf;
1177     for (*used = 0; count >= sizeof(DWORD); count -= sizeof(DWORD))
1178     {
1179         *ids++ = HandleToUlong( spi->UniqueProcessId );
1180         *used += sizeof(DWORD);
1181         if (spi->NextEntryOffset == 0) break;
1182         spi = (SYSTEM_PROCESS_INFORMATION *)(((PCHAR)spi) + spi->NextEntryOffset);
1183     }
1184     HeapFree( GetProcessHeap(), 0, buf );
1185     return TRUE;
1186 }
1187
1188
1189 /***********************************************************************
1190  *         K32GetDeviceDriverBaseNameA   (kernelbase.@)
1191  */
1192 DWORD WINAPI DECLSPEC_HOTPATCH K32GetDeviceDriverBaseNameA( void *image_base, char *name, DWORD size )
1193 {
1194     FIXME( "(%p, %p, %d): stub\n", image_base, name, size );
1195     if (name && size) name[0] = 0;
1196     return 0;
1197 }
1198
1199
1200 /***********************************************************************
1201  *         K32GetDeviceDriverBaseNameW   (kernelbase.@)
1202  */
1203 DWORD WINAPI DECLSPEC_HOTPATCH K32GetDeviceDriverBaseNameW( void *image_base, WCHAR *name, DWORD size )
1204 {
1205     FIXME( "(%p, %p, %d): stub\n", image_base, name, size );
1206     if (name && size) name[0] = 0;
1207     return 0;
1208 }
1209
1210
1211 /***********************************************************************
1212  *         K32GetDeviceDriverFileNameA   (kernelbase.@)
1213  */
1214 DWORD WINAPI DECLSPEC_HOTPATCH K32GetDeviceDriverFileNameA( void *image_base, char *name, DWORD size )
1215 {
1216     FIXME( "(%p, %p, %d): stub\n", image_base, name, size );
1217     if (name && size) name[0] = 0;
1218     return 0;
1219 }
1220
1221
1222 /***********************************************************************
1223  *         K32GetDeviceDriverFileNameW   (kernelbase.@)
1224  */
1225 DWORD WINAPI DECLSPEC_HOTPATCH K32GetDeviceDriverFileNameW( void *image_base, WCHAR *name, DWORD size )
1226 {
1227     FIXME( "(%p, %p, %d): stub\n", image_base, name, size );
1228     if (name && size) name[0] = 0;
1229     return 0;
1230 }
1231
1232
1233 /***********************************************************************
1234  *         K32GetMappedFileNameA   (kernelbase.@)
1235  */
1236 DWORD WINAPI DECLSPEC_HOTPATCH K32GetMappedFileNameA( HANDLE process, void *addr, char *name, DWORD size )
1237 {
1238     FIXME( "(%p, %p, %p, %d): stub\n", process, addr, name, size );
1239     if (name && size) name[0] = 0;
1240     return 0;
1241 }
1242
1243
1244 /***********************************************************************
1245  *         K32GetMappedFileNameW   (kernelbase.@)
1246  */
1247 DWORD WINAPI DECLSPEC_HOTPATCH K32GetMappedFileNameW( HANDLE process, void *addr, WCHAR *name, DWORD size )
1248 {
1249     FIXME( "(%p, %p, %p, %d): stub\n", process, addr, name, size );
1250     if (name && size) name[0] = 0;
1251     return 0;
1252 }
1253
1254
1255 /***********************************************************************
1256  *         K32GetModuleBaseNameA   (kernelbase.@)
1257  */
1258 DWORD WINAPI DECLSPEC_HOTPATCH K32GetModuleBaseNameA( HANDLE process, HMODULE module,
1259                                                       char *name, DWORD size )
1260 {
1261     WCHAR *name_w;
1262     DWORD len, ret = 0;
1263
1264     if (!name || !size)
1265     {
1266         SetLastError( ERROR_INVALID_PARAMETER );
1267         return 0;
1268     }
1269     if (!(name_w = HeapAlloc( GetProcessHeap(), 0, sizeof(WCHAR) * size ))) return 0;
1270
1271     len = K32GetModuleBaseNameW( process, module, name_w, size );
1272     TRACE( "%d, %s\n", len, debugstr_w(name_w) );
1273     if (len)
1274     {
1275         ret = WideCharToMultiByte( CP_ACP, 0, name_w, len, name, size, NULL, NULL );
1276         if (ret < size) name[ret] = 0;
1277     }
1278     HeapFree( GetProcessHeap(), 0, name_w );
1279     return ret;
1280 }
1281
1282
1283 /***********************************************************************
1284  *         K32GetModuleBaseNameW   (kernelbase.@)
1285  */
1286 DWORD WINAPI DECLSPEC_HOTPATCH K32GetModuleBaseNameW( HANDLE process, HMODULE module,
1287                                                       WCHAR *name, DWORD size )
1288 {
1289     BOOL wow64;
1290
1291     if (!IsWow64Process( process, &wow64 )) return 0;
1292
1293     if (is_win64 && wow64)
1294     {
1295         LDR_DATA_TABLE_ENTRY32 ldr_module32;
1296
1297         if (!get_ldr_module32(process, module, &ldr_module32)) return 0;
1298         size = min( ldr_module32.BaseDllName.Length / sizeof(WCHAR), size );
1299         if (!ReadProcessMemory( process, (void *)(DWORD_PTR)ldr_module32.BaseDllName.Buffer,
1300                                 name, size * sizeof(WCHAR), NULL ))
1301             return 0;
1302     }
1303     else
1304     {
1305         LDR_DATA_TABLE_ENTRY ldr_module;
1306
1307         if (!get_ldr_module( process, module, &ldr_module )) return 0;
1308         size = min( ldr_module.BaseDllName.Length / sizeof(WCHAR), size );
1309         if (!ReadProcessMemory( process, ldr_module.BaseDllName.Buffer,
1310                                 name, size * sizeof(WCHAR), NULL ))
1311             return 0;
1312     }
1313     name[size] = 0;
1314     return size;
1315 }
1316
1317
1318 /***********************************************************************
1319  *         K32GetModuleFileNameExA   (kernelbase.@)
1320  */
1321 DWORD WINAPI DECLSPEC_HOTPATCH K32GetModuleFileNameExA( HANDLE process, HMODULE module,
1322                                                         char *name, DWORD size )
1323 {
1324     WCHAR *ptr;
1325     DWORD len;
1326
1327     TRACE( "(process=%p, module=%p, %p, %d)\n", process, module, name, size );
1328
1329     if (!name || !size)
1330     {
1331         SetLastError( ERROR_INVALID_PARAMETER );
1332         return 0;
1333     }
1334     if (process == GetCurrentProcess())
1335     {
1336         len = GetModuleFileNameA( module, name, size );
1337         name[size - 1] = '\0';
1338         return len;
1339     }
1340
1341     if (!(ptr = HeapAlloc( GetProcessHeap(), 0, size * sizeof(WCHAR) ))) return 0;
1342     len = K32GetModuleFileNameExW( process, module, ptr, size );
1343     if (!len)
1344     {
1345         name[0] = 0;
1346     }
1347     else
1348     {
1349         if (!WideCharToMultiByte( CP_ACP, 0, ptr, -1, name, size, NULL, NULL ))
1350         {
1351             name[size - 1] = 0;
1352             len = size;
1353         }
1354         else if (len < size) len = strlen( name );
1355     }
1356     HeapFree( GetProcessHeap(), 0, ptr );
1357     return len;
1358 }
1359
1360
1361 /***********************************************************************
1362  *         K32GetModuleFileNameExW   (kernelbase.@)
1363  */
1364 DWORD WINAPI DECLSPEC_HOTPATCH K32GetModuleFileNameExW( HANDLE process, HMODULE module,
1365                                                         WCHAR *name, DWORD size )
1366 {
1367     BOOL wow64;
1368     DWORD len;
1369
1370     if (!size) return 0;
1371
1372     if (!IsWow64Process( process, &wow64 )) return 0;
1373
1374     if (is_win64 && wow64)
1375     {
1376         LDR_DATA_TABLE_ENTRY32 ldr_module32;
1377
1378         if (!get_ldr_module32( process, module, &ldr_module32 )) return 0;
1379         len = ldr_module32.FullDllName.Length / sizeof(WCHAR);
1380         if (!ReadProcessMemory( process, (void *)(DWORD_PTR)ldr_module32.FullDllName.Buffer,
1381                                 name, min( len, size ) * sizeof(WCHAR), NULL ))
1382             return 0;
1383     }
1384     else
1385     {
1386         LDR_DATA_TABLE_ENTRY ldr_module;
1387
1388         if (!get_ldr_module(process, module, &ldr_module)) return 0;
1389         len = ldr_module.FullDllName.Length / sizeof(WCHAR);
1390         if (!ReadProcessMemory( process, ldr_module.FullDllName.Buffer,
1391                                 name, min( len, size ) * sizeof(WCHAR), NULL ))
1392             return 0;
1393     }
1394
1395     if (len < size)
1396     {
1397         name[len] = 0;
1398         return len;
1399     }
1400     else
1401     {
1402         name[size - 1] = 0;
1403         return size;
1404     }
1405 }
1406
1407
1408 /***********************************************************************
1409  *         K32GetModuleInformation   (kernelbase.@)
1410  */
1411 BOOL WINAPI K32GetModuleInformation( HANDLE process, HMODULE module, MODULEINFO *modinfo, DWORD count )
1412 {
1413     BOOL wow64;
1414
1415     if (count < sizeof(MODULEINFO))
1416     {
1417         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1418         return FALSE;
1419     }
1420
1421     if (!IsWow64Process( process, &wow64 )) return FALSE;
1422
1423     if (is_win64 && wow64)
1424     {
1425         LDR_DATA_TABLE_ENTRY32 ldr_module32;
1426
1427         if (!get_ldr_module32( process, module, &ldr_module32 )) return FALSE;
1428         modinfo->lpBaseOfDll = (void *)(DWORD_PTR)ldr_module32.BaseAddress;
1429         modinfo->SizeOfImage = ldr_module32.SizeOfImage;
1430         modinfo->EntryPoint  = (void *)(DWORD_PTR)ldr_module32.EntryPoint;
1431     }
1432     else
1433     {
1434         LDR_DATA_TABLE_ENTRY ldr_module;
1435
1436         if (!get_ldr_module( process, module, &ldr_module )) return FALSE;
1437         modinfo->lpBaseOfDll = ldr_module.DllBase;
1438         modinfo->SizeOfImage = ldr_module.SizeOfImage;
1439         modinfo->EntryPoint  = ldr_module.EntryPoint;
1440     }
1441     return TRUE;
1442 }
1443
1444
1445 /***********************************************************************
1446  *         K32GetPerformanceInfo   (kernelbase.@)
1447  */
1448 BOOL WINAPI DECLSPEC_HOTPATCH K32GetPerformanceInfo( PPERFORMANCE_INFORMATION info, DWORD size )
1449 {
1450     SYSTEM_PERFORMANCE_INFORMATION perf;
1451     SYSTEM_BASIC_INFORMATION basic;
1452     SYSTEM_PROCESS_INFORMATION *process, *spi;
1453     DWORD info_size;
1454     NTSTATUS status;
1455
1456     TRACE( "(%p, %d)\n", info, size );
1457
1458     if (size < sizeof(*info))
1459     {
1460         SetLastError( ERROR_BAD_LENGTH );
1461         return FALSE;
1462     }
1463
1464     status = NtQuerySystemInformation( SystemPerformanceInformation, &perf, sizeof(perf), NULL );
1465     if (!set_ntstatus( status )) return FALSE;
1466     status = NtQuerySystemInformation( SystemBasicInformation, &basic, sizeof(basic), NULL );
1467     if (!set_ntstatus( status )) return FALSE;
1468
1469     info->cb                 = sizeof(*info);
1470     info->CommitTotal        = perf.TotalCommittedPages;
1471     info->CommitLimit        = perf.TotalCommitLimit;
1472     info->CommitPeak         = perf.PeakCommitment;
1473     info->PhysicalTotal      = basic.MmNumberOfPhysicalPages;
1474     info->PhysicalAvailable  = perf.AvailablePages;
1475     info->SystemCache        = 0;
1476     info->KernelTotal        = perf.PagedPoolUsage + perf.NonPagedPoolUsage;
1477     info->KernelPaged        = perf.PagedPoolUsage;
1478     info->KernelNonpaged     = perf.NonPagedPoolUsage;
1479     info->PageSize           = basic.PageSize;
1480
1481     /* fields from SYSTEM_PROCESS_INFORMATION */
1482     NtQuerySystemInformation( SystemProcessInformation, NULL, 0, &info_size );
1483     for (;;)
1484     {
1485         process = HeapAlloc( GetProcessHeap(), 0, info_size );
1486         if (!process)
1487         {
1488             SetLastError( ERROR_OUTOFMEMORY );
1489             return FALSE;
1490         }
1491         status = NtQuerySystemInformation( SystemProcessInformation, process, info_size, &info_size );
1492         if (!status) break;
1493         HeapFree( GetProcessHeap(), 0, process );
1494         if (status != STATUS_INFO_LENGTH_MISMATCH)
1495         {
1496             SetLastError( RtlNtStatusToDosError( status ) );
1497             return FALSE;
1498         }
1499     }
1500     info->HandleCount = info->ProcessCount = info->ThreadCount = 0;
1501     spi = process;
1502     for (;;)
1503     {
1504         info->ProcessCount++;
1505         info->HandleCount += spi->HandleCount;
1506         info->ThreadCount += spi->dwThreadCount;
1507         if (spi->NextEntryOffset == 0) break;
1508         spi = (SYSTEM_PROCESS_INFORMATION *)((char *)spi + spi->NextEntryOffset);
1509     }
1510     HeapFree( GetProcessHeap(), 0, process );
1511     return TRUE;
1512 }
1513
1514
1515 /***********************************************************************
1516  *         K32GetProcessImageFileNameA   (kernelbase.@)
1517  */
1518 DWORD WINAPI DECLSPEC_HOTPATCH K32GetProcessImageFileNameA( HANDLE process, char *file, DWORD size )
1519 {
1520     return QueryFullProcessImageNameA( process, PROCESS_NAME_NATIVE, file, &size ) ? size : 0;
1521 }
1522
1523
1524 /***********************************************************************
1525  *         K32GetProcessImageFileNameW   (kernelbase.@)
1526  */
1527 DWORD WINAPI DECLSPEC_HOTPATCH K32GetProcessImageFileNameW( HANDLE process, WCHAR *file, DWORD size )
1528 {
1529     return QueryFullProcessImageNameW( process, PROCESS_NAME_NATIVE, file, &size ) ? size : 0;
1530 }
1531
1532
1533 /***********************************************************************
1534  *         K32GetProcessMemoryInfo   (kernelbase.@)
1535  */
1536 BOOL WINAPI DECLSPEC_HOTPATCH K32GetProcessMemoryInfo( HANDLE process, PROCESS_MEMORY_COUNTERS *pmc,
1537                                                        DWORD count )
1538 {
1539     VM_COUNTERS vmc;
1540
1541     if (count < sizeof(PROCESS_MEMORY_COUNTERS))
1542     {
1543         SetLastError( ERROR_INSUFFICIENT_BUFFER );
1544         return FALSE;
1545     }
1546
1547     if (!set_ntstatus( NtQueryInformationProcess( process, ProcessVmCounters, &vmc, sizeof(vmc), NULL )))
1548         return FALSE;
1549
1550     pmc->cb = sizeof(PROCESS_MEMORY_COUNTERS);
1551     pmc->PageFaultCount = vmc.PageFaultCount;
1552     pmc->PeakWorkingSetSize = vmc.PeakWorkingSetSize;
1553     pmc->WorkingSetSize = vmc.WorkingSetSize;
1554     pmc->QuotaPeakPagedPoolUsage = vmc.QuotaPeakPagedPoolUsage;
1555     pmc->QuotaPagedPoolUsage = vmc.QuotaPagedPoolUsage;
1556     pmc->QuotaPeakNonPagedPoolUsage = vmc.QuotaPeakNonPagedPoolUsage;
1557     pmc->QuotaNonPagedPoolUsage = vmc.QuotaNonPagedPoolUsage;
1558     pmc->PagefileUsage = vmc.PagefileUsage;
1559     pmc->PeakPagefileUsage = vmc.PeakPagefileUsage;
1560     return TRUE;
1561 }
1562
1563
1564 /***********************************************************************
1565  *         K32GetWsChanges   (kernelbase.@)
1566  */
1567 BOOL WINAPI DECLSPEC_HOTPATCH K32GetWsChanges( HANDLE process, PSAPI_WS_WATCH_INFORMATION *info, DWORD size )
1568 {
1569     TRACE( "(%p, %p, %d)\n", process, info, size );
1570     return set_ntstatus( NtQueryInformationProcess( process, ProcessWorkingSetWatch, info, size, NULL ));
1571 }
1572
1573
1574 /***********************************************************************
1575  *         K32GetWsChangesEx   (kernelbase.@)
1576  */
1577 BOOL WINAPI DECLSPEC_HOTPATCH K32GetWsChangesEx( HANDLE process, PSAPI_WS_WATCH_INFORMATION_EX *info,
1578                                                  DWORD *size )
1579 {
1580     FIXME( "(%p, %p, %p)\n", process, info, size );
1581     SetLastError( ERROR_CALL_NOT_IMPLEMENTED );
1582     return FALSE;
1583 }
1584
1585
1586 /***********************************************************************
1587  *         K32InitializeProcessForWsWatch   (kernelbase.@)
1588  */
1589 BOOL WINAPI /* DECLSPEC_HOTPATCH */ K32InitializeProcessForWsWatch( HANDLE process )
1590 {
1591     FIXME( "(process=%p): stub\n", process );
1592     return TRUE;
1593 }
1594
1595
1596 /***********************************************************************
1597  *         K32QueryWorkingSet   (kernelbase.@)
1598  */
1599 BOOL WINAPI DECLSPEC_HOTPATCH K32QueryWorkingSet( HANDLE process, void *buffer, DWORD size )
1600 {
1601     TRACE( "(%p, %p, %d)\n", process, buffer, size );
1602     return set_ntstatus( NtQueryVirtualMemory( process, NULL, MemoryWorkingSetList, buffer, size, NULL ));
1603 }
1604
1605
1606 /***********************************************************************
1607  *         K32QueryWorkingSetEx   (kernelbase.@)
1608  */
1609 BOOL WINAPI K32QueryWorkingSetEx( HANDLE process, void *buffer, DWORD size )
1610 {
1611     TRACE( "(%p, %p, %d)\n", process, buffer, size );
1612     return set_ntstatus( NtQueryVirtualMemory( process, NULL, MemoryWorkingSetExInformation,
1613                                                buffer, size, NULL ));
1614 }
1615
1616
1617 /******************************************************************
1618  *         QueryFullProcessImageNameA   (kernelbase.@)
1619  */
1620 BOOL WINAPI DECLSPEC_HOTPATCH QueryFullProcessImageNameA( HANDLE process, DWORD flags,
1621                                                           char *name, DWORD *size )
1622 {
1623     BOOL ret;
1624     DWORD sizeW = *size;
1625     WCHAR *nameW = HeapAlloc( GetProcessHeap(), 0, *size * sizeof(WCHAR) );
1626
1627     ret = QueryFullProcessImageNameW( process, flags, nameW, &sizeW );
1628     if (ret) ret = (WideCharToMultiByte( CP_ACP, 0, nameW, -1, name, *size, NULL, NULL) > 0);
1629     if (ret) *size = strlen( name );
1630     HeapFree( GetProcessHeap(), 0, nameW );
1631     return ret;
1632 }
1633
1634
1635 /******************************************************************
1636  *         QueryFullProcessImageNameW   (kernelbase.@)
1637  */
1638 BOOL WINAPI DECLSPEC_HOTPATCH QueryFullProcessImageNameW( HANDLE process, DWORD flags,
1639                                                           WCHAR *name, DWORD *size )
1640 {
1641     BYTE buffer[sizeof(UNICODE_STRING) + MAX_PATH*sizeof(WCHAR)];  /* this buffer should be enough */
1642     UNICODE_STRING *dynamic_buffer = NULL;
1643     UNICODE_STRING *result = NULL;
1644     NTSTATUS status;
1645     DWORD needed;
1646
1647     /* FIXME: On Windows, ProcessImageFileName return an NT path. In Wine it
1648      * is a DOS path and we depend on this. */
1649     status = NtQueryInformationProcess( process, ProcessImageFileName, buffer,
1650                                         sizeof(buffer) - sizeof(WCHAR), &needed );
1651     if (status == STATUS_INFO_LENGTH_MISMATCH)
1652     {
1653         dynamic_buffer = HeapAlloc( GetProcessHeap(), 0, needed + sizeof(WCHAR) );
1654         status = NtQueryInformationProcess( process, ProcessImageFileName, dynamic_buffer,
1655                                             needed, &needed );
1656         result = dynamic_buffer;
1657     }
1658     else
1659         result = (UNICODE_STRING *)buffer;
1660
1661     if (status) goto cleanup;
1662
1663     if (flags & PROCESS_NAME_NATIVE)
1664     {
1665         WCHAR drive[3];
1666         WCHAR device[1024];
1667         DWORD ntlen, devlen;
1668
1669         if (result->Buffer[1] != ':' || result->Buffer[0] < 'A' || result->Buffer[0] > 'Z')
1670         {
1671             /* We cannot convert it to an NT device path so fail */
1672             status = STATUS_NO_SUCH_DEVICE;
1673             goto cleanup;
1674         }
1675
1676         /* Find this drive's NT device path */
1677         drive[0] = result->Buffer[0];
1678         drive[1] = ':';
1679         drive[2] = 0;
1680         if (!QueryDosDeviceW(drive, device, ARRAY_SIZE(device)))
1681         {
1682             status = STATUS_NO_SUCH_DEVICE;
1683             goto cleanup;
1684         }
1685
1686         devlen = lstrlenW(device);
1687         ntlen = devlen + (result->Length/sizeof(WCHAR) - 2);
1688         if (ntlen + 1 > *size)
1689         {
1690             status = STATUS_BUFFER_TOO_SMALL;
1691             goto cleanup;
1692         }
1693         *size = ntlen;
1694
1695         memcpy( name, device, devlen * sizeof(*device) );
1696         memcpy( name + devlen, result->Buffer + 2, result->Length - 2 * sizeof(WCHAR) );
1697         name[*size] = 0;
1698         TRACE( "NT path: %s\n", debugstr_w(name) );
1699     }
1700     else
1701     {
1702         if (result->Length/sizeof(WCHAR) + 1 > *size)
1703         {
1704             status = STATUS_BUFFER_TOO_SMALL;
1705             goto cleanup;
1706         }
1707
1708         *size = result->Length/sizeof(WCHAR);
1709         memcpy( name, result->Buffer, result->Length );
1710         name[*size] = 0;
1711     }
1712
1713 cleanup:
1714     HeapFree( GetProcessHeap(), 0, dynamic_buffer );
1715     return set_ntstatus( status );
1716 }