2 * Wine debugger - minidump handling
4 * Copyright 2005 Eric Pouech
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.
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.
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
21 #define NONAMELESSUNION
22 #define NONAMELESSSTRUCT
35 #include "wine/debug.h"
36 #include "wine/exception.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(winedbg
);
40 static struct be_process_io be_process_minidump_io
;
42 void minidump_write(const char* file
, const EXCEPTION_RECORD
* rec
)
45 MINIDUMP_EXCEPTION_INFORMATION mei
;
46 EXCEPTION_POINTERS ep
;
48 hFile
= CreateFile(file
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
, CREATE_ALWAYS
,
49 FILE_ATTRIBUTE_NORMAL
, NULL
);
51 if (hFile
== INVALID_HANDLE_VALUE
) return;
55 mei
.ThreadId
= dbg_curr_thread
->tid
;
56 mei
.ExceptionPointers
= &ep
;
57 ep
.ExceptionRecord
= (EXCEPTION_RECORD
*)rec
;
58 ep
.ContextRecord
= &dbg_context
;
59 mei
.ClientPointers
= FALSE
;
61 MiniDumpWriteDump(dbg_curr_process
->handle
, dbg_curr_process
->pid
,
62 hFile
, MiniDumpNormal
/*|MiniDumpWithDataSegs*/,
63 rec
? &mei
: NULL
, NULL
, NULL
);
67 #define Wine_ElfModuleListStream 0xFFF0
69 struct tgt_process_minidump_data
76 static inline struct tgt_process_minidump_data
* PRIVATE(struct dbg_process
* pcs
)
78 return (struct tgt_process_minidump_data
*)pcs
->pio_data
;
81 static BOOL WINAPI
tgt_process_minidump_read(HANDLE hProcess
, const void* addr
,
82 void* buffer
, SIZE_T len
, SIZE_T
* rlen
)
85 MINIDUMP_DIRECTORY
* dir
;
88 if (!PRIVATE(dbg_curr_process
)->mapping
) return FALSE
;
89 if (MiniDumpReadDumpStream(PRIVATE(dbg_curr_process
)->mapping
,
90 MemoryListStream
, &dir
, &stream
, &size
))
92 MINIDUMP_MEMORY_LIST
* mml
= (MINIDUMP_MEMORY_LIST
*)stream
;
93 MINIDUMP_MEMORY_DESCRIPTOR
* mmd
= &mml
->MemoryRanges
[0];
96 for (i
= 0; i
< mml
->NumberOfMemoryRanges
; i
++, mmd
++)
98 if (mmd
->StartOfMemoryRange
<= (DWORD_PTR
)addr
&&
99 (DWORD_PTR
)addr
< mmd
->StartOfMemoryRange
+ mmd
->Memory
.DataSize
)
101 len
= min(len
, mmd
->StartOfMemoryRange
+ mmd
->Memory
.DataSize
- (DWORD_PTR
)addr
);
103 (char*)PRIVATE(dbg_curr_process
)->mapping
+ mmd
->Memory
.Rva
+ (DWORD_PTR
)addr
- mmd
->StartOfMemoryRange
,
105 if (rlen
) *rlen
= len
;
110 /* FIXME: this is a dirty hack to let the last frame in a bt to work
111 * However, we need to check who's to blame, this code or the current
112 * dbghelp!StackWalk implementation
114 if ((DWORD_PTR
)addr
< 32)
116 memset(buffer
, 0, len
);
117 if (rlen
) *rlen
= len
;
123 static BOOL WINAPI
tgt_process_minidump_write(HANDLE hProcess
, void* addr
,
124 const void* buffer
, SIZE_T len
, SIZE_T
* wlen
)
129 BOOL CALLBACK
validate_file(PCWSTR name
, void* user
)
131 return FALSE
; /* get the first file we find !! */
134 static enum dbg_start
minidump_do_reload(struct tgt_process_minidump_data
* data
)
137 MINIDUMP_DIRECTORY
* dir
;
139 DWORD pid
= 1; /* by default */
140 HANDLE hProc
= (HANDLE
)0x900DBAAD;
142 MINIDUMP_MODULE_LIST
* mml
;
144 MINIDUMP_STRING
* mds
;
145 char exec_name
[1024];
150 if (MiniDumpReadDumpStream(data
->mapping
, MiscInfoStream
, &dir
, &stream
, &size
))
152 MINIDUMP_MISC_INFO
* mmi
= (MINIDUMP_MISC_INFO
*)stream
;
153 if (mmi
->Flags1
& MINIDUMP_MISC1_PROCESS_ID
)
154 pid
= mmi
->ProcessId
;
157 /* fetch executable name (it's normally the first one in module list) */
158 strcpy(exec_name
, "<minidump-exec>"); /* default */
159 if (MiniDumpReadDumpStream(data
->mapping
, ModuleListStream
, &dir
, &stream
, &size
))
161 mml
= (MINIDUMP_MODULE_LIST
*)stream
;
162 if (mml
->NumberOfModules
)
166 mm
= &mml
->Modules
[0];
167 mds
= (MINIDUMP_STRING
*)((char*)data
->mapping
+ mm
->ModuleNameRva
);
168 len
= WideCharToMultiByte(CP_ACP
, 0, mds
->Buffer
,
169 mds
->Length
/ sizeof(WCHAR
),
170 exec_name
, sizeof(exec_name
) - 1, NULL
, NULL
);
172 for (ptr
= exec_name
+ len
- 1; ptr
>= exec_name
; ptr
--)
174 if (*ptr
== '/' || *ptr
== '\\')
176 memmove(exec_name
, ptr
+ 1, strlen(ptr
+ 1) + 1);
183 if (MiniDumpReadDumpStream(data
->mapping
, SystemInfoStream
, &dir
, &stream
, &size
))
185 MINIDUMP_SYSTEM_INFO
* msi
= (MINIDUMP_SYSTEM_INFO
*)stream
;
189 dbg_printf("WineDbg starting on minidump on pid %04x\n", pid
);
190 switch (msi
->ProcessorArchitecture
)
192 case PROCESSOR_ARCHITECTURE_UNKNOWN
:
195 case PROCESSOR_ARCHITECTURE_INTEL
:
196 strcpy(tmp
, "Intel ");
197 switch (msi
->ProcessorLevel
)
199 case 3: str
= "80386"; break;
200 case 4: str
= "80486"; break;
201 case 5: str
= "Pentium"; break;
202 case 6: str
= "Pentium Pro/II"; break;
203 default: str
= "???"; break;
206 if (msi
->ProcessorLevel
== 3 || msi
->ProcessorLevel
== 4)
208 if (HIWORD(msi
->ProcessorRevision
) == 0xFF)
209 sprintf(tmp
+ strlen(tmp
), "-%c%d",
210 'A' + HIBYTE(LOWORD(msi
->ProcessorRevision
)),
211 LOBYTE(LOWORD(msi
->ProcessorRevision
)));
213 sprintf(tmp
+ strlen(tmp
), "-%c%d",
214 'A' + HIWORD(msi
->ProcessorRevision
),
215 LOWORD(msi
->ProcessorRevision
));
217 else sprintf(tmp
+ strlen(tmp
), "-%d.%d",
218 HIWORD(msi
->ProcessorRevision
),
219 LOWORD(msi
->ProcessorRevision
));
222 case PROCESSOR_ARCHITECTURE_MIPS
:
225 case PROCESSOR_ARCHITECTURE_ALPHA
:
228 case PROCESSOR_ARCHITECTURE_PPC
:
235 dbg_printf(" %s was running on #%d %s CPU%s",
236 exec_name
, msi
->u
.s
.NumberOfProcessors
, str
,
237 msi
->u
.s
.NumberOfProcessors
< 2 ? "" : "s");
238 switch (msi
->MajorVersion
)
241 switch (msi
->MinorVersion
)
243 case 51: str
= "NT 3.51"; break;
244 default: str
= "3-????"; break;
248 switch (msi
->MinorVersion
)
250 case 0: str
= (msi
->PlatformId
== VER_PLATFORM_WIN32_NT
) ? "NT 4.0" : "95"; break;
251 case 10: str
= "98"; break;
252 case 90: str
= "ME"; break;
253 default: str
= "5-????"; break;
257 switch (msi
->MinorVersion
)
259 case 0: str
= "2000"; break;
260 case 1: str
= "XP"; break;
261 case 2: str
= "Server 2003"; break;
262 default: str
= "5-????"; break;
265 default: str
= "???"; break;
267 dbg_printf(" on Windows %s (%u)\n", str
, msi
->BuildNumber
);
268 /* FIXME CSD: msi->CSDVersionRva */
271 dbg_curr_process
= dbg_add_process(&be_process_minidump_io
, pid
, hProc
);
273 dbg_curr_process
->pio_data
= data
;
274 dbg_set_process_name(dbg_curr_process
, exec_name
);
276 SymInitialize(hProc
, NULL
, FALSE
);
278 if (MiniDumpReadDumpStream(data
->mapping
, ThreadListStream
, &dir
, &stream
, &size
))
280 MINIDUMP_THREAD_LIST
* mtl
= (MINIDUMP_THREAD_LIST
*)stream
;
283 for (i
= 0; i
< mtl
->NumberOfThreads
; i
++)
285 dbg_add_thread(dbg_curr_process
, mtl
->Threads
[i
].ThreadId
, NULL
,
286 (void*)(DWORD_PTR
)mtl
->Threads
[i
].Teb
);
289 /* first load ELF modules, then do the PE ones */
290 if (MiniDumpReadDumpStream(data
->mapping
, Wine_ElfModuleListStream
, &dir
,
293 WCHAR buffer
[MAX_PATH
];
295 mml
= (MINIDUMP_MODULE_LIST
*)stream
;
296 for (i
= 0, mm
= &mml
->Modules
[0]; i
< mml
->NumberOfModules
; i
++, mm
++)
298 mds
= (MINIDUMP_STRING
*)((char*)data
->mapping
+ mm
->ModuleNameRva
);
299 memcpy(nameW
, mds
->Buffer
, mds
->Length
);
300 nameW
[mds
->Length
/ sizeof(WCHAR
)] = 0;
301 if (SymFindFileInPathW(hProc
, NULL
, nameW
, (void*)(DWORD_PTR
)mm
->CheckSum
,
302 0, 0, SSRVOPT_DWORD
, buffer
, validate_file
, NULL
))
303 SymLoadModuleExW(hProc
, NULL
, buffer
, NULL
, mm
->BaseOfImage
, mm
->SizeOfImage
,
306 SymLoadModuleExW(hProc
, NULL
, nameW
, NULL
, mm
->BaseOfImage
, mm
->SizeOfImage
,
307 NULL
, SLMFLAG_VIRTUAL
);
310 if (MiniDumpReadDumpStream(data
->mapping
, ModuleListStream
, &dir
, &stream
, &size
))
312 mml
= (MINIDUMP_MODULE_LIST
*)stream
;
313 for (i
= 0, mm
= &mml
->Modules
[0]; i
< mml
->NumberOfModules
; i
++, mm
++)
315 mds
= (MINIDUMP_STRING
*)((char*)data
->mapping
+ mm
->ModuleNameRva
);
316 memcpy(nameW
, mds
->Buffer
, mds
->Length
);
317 nameW
[mds
->Length
/ sizeof(WCHAR
)] = 0;
318 SymLoadModuleExW(hProc
, NULL
, nameW
, NULL
, mm
->BaseOfImage
, mm
->SizeOfImage
,
322 if (MiniDumpReadDumpStream(data
->mapping
, ExceptionStream
, &dir
, &stream
, &size
))
324 MINIDUMP_EXCEPTION_STREAM
* mes
= (MINIDUMP_EXCEPTION_STREAM
*)stream
;
326 if ((dbg_curr_thread
= dbg_get_thread(dbg_curr_process
, mes
->ThreadId
)))
330 dbg_curr_tid
= mes
->ThreadId
;
331 dbg_curr_thread
->in_exception
= TRUE
;
332 dbg_curr_thread
->excpt_record
.ExceptionCode
= mes
->ExceptionRecord
.ExceptionCode
;
333 dbg_curr_thread
->excpt_record
.ExceptionFlags
= mes
->ExceptionRecord
.ExceptionFlags
;
334 dbg_curr_thread
->excpt_record
.ExceptionRecord
= (void*)(DWORD_PTR
)mes
->ExceptionRecord
.ExceptionRecord
;
335 dbg_curr_thread
->excpt_record
.ExceptionAddress
= (void*)(DWORD_PTR
)mes
->ExceptionRecord
.ExceptionAddress
;
336 dbg_curr_thread
->excpt_record
.NumberParameters
= mes
->ExceptionRecord
.NumberParameters
;
337 for (i
= 0; i
< dbg_curr_thread
->excpt_record
.NumberParameters
; i
++)
339 dbg_curr_thread
->excpt_record
.ExceptionInformation
[i
] = mes
->ExceptionRecord
.ExceptionInformation
[i
];
341 memcpy(&dbg_context
, (char*)data
->mapping
+ mes
->ThreadContext
.Rva
,
342 min(sizeof(dbg_context
), mes
->ThreadContext
.DataSize
));
343 memory_get_current_pc(&addr
);
344 stack_fetch_frames();
345 be_cpu
->print_context(dbg_curr_thread
->handle
, &dbg_context
, 0);
347 be_cpu
->print_segment_info(dbg_curr_thread
->handle
, &dbg_context
);
348 stack_backtrace(mes
->ThreadId
);
349 source_list_from_addr(&addr
, 0);
355 static void cleanup(struct tgt_process_minidump_data
* data
)
357 if (data
->mapping
) UnmapViewOfFile(data
->mapping
);
358 if (data
->hMap
) CloseHandle(data
->hMap
);
359 if (data
->hFile
!= INVALID_HANDLE_VALUE
) CloseHandle(data
->hFile
);
360 HeapFree(GetProcessHeap(), 0, data
);
363 static struct be_process_io be_process_minidump_io
;
365 enum dbg_start
minidump_reload(int argc
, char* argv
[])
367 struct tgt_process_minidump_data
* data
;
368 enum dbg_start ret
= start_error_parse
;
370 /* try the form <myself> minidump-file */
371 if (argc
!= 1) return start_error_parse
;
373 WINE_TRACE("Processing Minidump file %s\n", argv
[0]);
375 data
= HeapAlloc(GetProcessHeap(), 0, sizeof(struct tgt_process_minidump_data
));
376 if (!data
) return start_error_init
;
377 data
->mapping
= NULL
;
379 data
->hFile
= INVALID_HANDLE_VALUE
;
381 if ((data
->hFile
= CreateFileA(argv
[0], GENERIC_READ
, FILE_SHARE_READ
, NULL
,
382 OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
)) != INVALID_HANDLE_VALUE
&&
383 ((data
->hMap
= CreateFileMappingA(data
->hFile
, NULL
, PAGE_READONLY
, 0, 0, NULL
)) != 0) &&
384 ((data
->mapping
= MapViewOfFile(data
->hMap
, FILE_MAP_READ
, 0, 0, 0)) != NULL
))
388 if (((MINIDUMP_HEADER
*)data
->mapping
)->Signature
== MINIDUMP_SIGNATURE
)
390 ret
= minidump_do_reload(data
);
395 dbg_printf("Unexpected fault while reading minidump %s\n", argv
[0]);
400 if (ret
!= start_ok
) cleanup(data
);
404 static BOOL
tgt_process_minidump_close_process(struct dbg_process
* pcs
, BOOL kill
)
406 struct tgt_process_minidump_data
* data
= PRIVATE(pcs
);
409 pcs
->pio_data
= NULL
;
410 SymCleanup(pcs
->handle
);
411 dbg_del_process(pcs
);
415 static struct be_process_io be_process_minidump_io
=
417 tgt_process_minidump_close_process
,
418 tgt_process_minidump_read
,
419 tgt_process_minidump_write
,