VS2010调试程序--Dump文件方式

旧城等待， 2022-07-15 00:25 676阅读 0赞

dump文件，在VC中的调试还是非常非常非常有用的，因为我们也不会经每一行代码都加上日志，当然如果你愿意，也可以每一行都加上日志；

在Windows上，添加dump文件有两种方法：

**方法一：一个是在程序中添加代码；**

**方法二：修改注册表（参考后面的bat文件写法，在win7上用管理员程序运行）；建议用这个方法，方便实用；（http://blog.csdn[.NET][]/hgy413/article/details/7586957\#）**

from：

http://blog.csdn[.Net][.NET]/byxdaz/article/details/25872151

http://blog.csdn.net/starlee/article/details/6630816

在Windows平台下用C++开发应用程序，最不想见到的情况恐怕就是程序崩溃，而要想解决引起问题的bug，最困难的应该就是调试release版本了。因为release版本来就少了很多调试信息，更何况一般都是发布出去由用户使用，crash的现场很难保留和重现。目前有一些方法可以解决：崩溃地址 + MAP文件；MAP文件；SetUnhandledExceptionFilter + Minidump。本文重点解决Minidump方式。

一、Minidump文件生成

**1、Minidump概念**

minidump（小存储器转储）可以理解为一个dump文件，里面记录了能够帮助调试crash的最小有用信息。实际上，如果你在系统属性 \-> 高级 \-> 启动和故障恢复 \-> 设置 \-> 写入调试信息中选择“小内存转储(64 KB)”的话，当系统意外停止时都会在C:\\Windows\\Minidump\\路径下生成一个.dmp后缀的文件，这个文件就是minidump文件，只不过这个是内核态的minidump。

我们要生成的是用户态的minidump，文件中包含了程序运行的模块信息、线程信息、堆栈调用信息等。而且为了符合其mini的特性，dump文件是压缩过的。

**2、生成minidump文件**

通过drwtsn32、NTSD、CDB等调试工具生成Dump文件， drwtsn32存在的缺点虽然NTSD、CDB可以完全解决，但并不是所有的[操作系统][Link 1]中都安装了NTSD、CDB等调试工具。根据MiniDumpWriteDump接口，完全可以程序自动生成Dump文件。

**3、 自动生成Minidump文件**

当程序遇到未处理异常(主要指非指针造成)导致程序崩溃死，如果在异常发生之前调用了SetUnhandledExceptionFilter()函数，异常交给函数处理。MSDN中描述为：

Issuing SetUnhandledExceptionFilter replaces the existing top-level exception filter for all existing and all future threads in the calling process.

因而，在程序开始处增加SetUnhandledExceptionFilter()函数，并在函数中利用适当的方法生成Dump文件，即可实现需要的功能。

生成dump文件类(minidump.h)

**\[cpp\]** [view plain][] [copy][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1. \#pragma once
2. 
3. 
4. 
5. \#include <windows.h>
6. 
7. \#include <imagehlp.h>
8. 
9. \#include <stdlib.h>
10. 
11. \#pragma comment(lib, "dbghelp.lib")
12. 
13. 
14. 
15. **inline****BOOL** IsDataSectionNeeded(**const****WCHAR**\* pModuleName) 
16. 
17. \{ 
18. 
19. **if**(pModuleName == 0) 
20. 
21. \{ 
22. 
23. **return** FALSE; 
24. 
25. \} 
26. 
27. 
28. 
29. **WCHAR** szFileName\[\_MAX\_FNAME\] = L""; 
30. 
31. \_wsplitpath(pModuleName, NULL, NULL, szFileName, NULL); 
32. 
33. **if**(wcsicmp(szFileName, L"ntdll") == 0) 
34. 
35. **return** TRUE; 
36. 
37. 
38. 
39. **return** FALSE; 
40. 
41. \} 
42. 
43. 
44. 
45. **inline****BOOL** CALLBACK MiniDumpCallback(**PVOID** pParam, 
46. 
47. **const** PMINIDUMP\_CALLBACK\_INPUT pInput, 
48. 
49. PMINIDUMP\_CALLBACK\_OUTPUT pOutput) 
50. 
51. \{ 
52. 
53. **if**(pInput == 0 || pOutput == 0) 
54. 
55. **return** FALSE; 
56. 
57. 
58. 
59. **switch**(pInput->CallbackType) 
60. 
61. \{ 
62. 
63. **case** ModuleCallback: 
64. 
65. **if**(pOutput->ModuleWriteFlags & ModuleWriteDataSeg) 
66. 
67. 
68. 
69. **if**(!IsDataSectionNeeded(pInput->Module.FullPath)) 
70. 
71. 
72. 
73. pOutput->ModuleWriteFlags &= (~ModuleWriteDataSeg); 
74. 
75. 
76. 
77. **case** IncludeModuleCallback: 
78. 
79. **case** IncludeThreadCallback: 
80. 
81. **case** ThreadCallback: 
82. 
83. **case** ThreadExCallback: 
84. 
85. **return** TRUE; 
86. 
87. 
88. 
89. **default**:; 
90. 
91. \} 
92. 
93. 
94. 
95. **return** FALSE; 
96. 
97. \} 
98. 
99. 
100. 
101. //创建Dump文件
102. 
103. **inline****void** CreateMiniDump(EXCEPTION\_POINTERS\* pep, **LPCTSTR** strFileName) 
104. 
105. \{ 
106. 
107. **HANDLE** hFile = CreateFile(strFileName, GENERIC\_WRITE, 0, NULL, CREATE\_ALWAYS, FILE\_ATTRIBUTE\_NORMAL, NULL); 
108. 
109. **if**((hFile != NULL) && (hFile != INVALID\_HANDLE\_VALUE)) 
110. 
111. \{ 
112. 
113. MINIDUMP\_EXCEPTION\_INFORMATION mdei; 
114. 
115. mdei.ThreadId = GetCurrentThreadId(); 
116. 
117. mdei.ExceptionPointers = pep; 
118. 
119. mdei.ClientPointers = FALSE; 
120. 
121. MINIDUMP\_CALLBACK\_INFORMATION mci; 
122. 
123. mci.CallbackRoutine = (MINIDUMP\_CALLBACK\_ROUTINE)MiniDumpCallback; 
124. 
125. mci.CallbackParam = 0; 
126. 
127. MINIDUMP\_TYPE mdt = (MINIDUMP\_TYPE)0x0000ffff; 
128. 
129. MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpNormal, &mdei, NULL, &mci); 
130. 
131. 
132. 
133. CloseHandle(hFile); 
134. 
135. \} 
136. 
137. \} 
138. 
139. 
140. 
141. LPTOP\_LEVEL\_EXCEPTION\_FILTER WINAPI MyDummySetUnhandledExceptionFilter(LPTOP\_LEVEL\_EXCEPTION\_FILTER lpTopLevelExceptionFilter) 
142. 
143. \{ 
144. 
145. **return** NULL; 
146. 
147. \} 
148. 
149. 
150. 
151. **BOOL** PreventSetUnhandledExceptionFilter() 
152. 
153. \{ 
154. 
155. **HMODULE** hKernel32 = LoadLibrary(\_T("kernel32.dll")); 
156. 
157. **if** (hKernel32 == NULL) 
158. 
159. **return** FALSE; 
160. 
161. 
162. 
163. 
164. 
165. **void** \*pOrgEntry = GetProcAddress(hKernel32, "SetUnhandledExceptionFilter"); 
166. 
167. **if**(pOrgEntry == NULL) 
168. 
169. **return** FALSE; 
170. 
171. 
172. 
173. 
174. 
175. unsigned **char** newJump\[ 100 \]; 
176. 
177. **DWORD** dwOrgEntryAddr = (**DWORD**) pOrgEntry; 
178. 
179. dwOrgEntryAddr += 5; // add 5 for 5 op-codes for jmp far
180. 
181. 
182. 
183. 
184. 
185. **void** \*pNewFunc = &MyDummySetUnhandledExceptionFilter; 
186. 
187. **DWORD** dwNewEntryAddr = (**DWORD**) pNewFunc; 
188. 
189. **DWORD** dwRelativeAddr = dwNewEntryAddr - dwOrgEntryAddr; 
190. 
191. 
192. 
193. 
194. 
195. newJump\[ 0 \] = 0xE9; // JMP absolute
196. 
197. memcpy(&newJump\[ 1 \], &dwRelativeAddr, **sizeof**(pNewFunc)); 
198. 
199. **SIZE\_T** bytesWritten; 
200. 
201. **BOOL** bRet = WriteProcessMemory(GetCurrentProcess(), pOrgEntry, newJump, **sizeof**(pNewFunc) + 1, &bytesWritten); 
202. 
203. **return** bRet; 
204. 
205. \} 
206. 
207. 
208. 
209. 
210. 
211. **LONG** WINAPI UnhandledExceptionFilterEx(**struct****\_EXCEPTION\_POINTERS** \*pException) 
212. 
213. \{ 
214. 
215. **TCHAR** szMbsFile\[MAX\_PATH\] = \{ 0 \}; 
216. 
217. ::GetModuleFileName(NULL, szMbsFile, MAX\_PATH); 
218. 
219. **TCHAR**\* pFind = \_tcsrchr(szMbsFile, '\\\\'); 
220. 
221. **if**(pFind) 
222. 
223. \{ 
224. 
225. \*(pFind+1) = 0; 
226. 
227. \_tcscat(szMbsFile, \_T("CreateMiniDump.dmp")); 
228. 
229. CreateMiniDump(pException,szMbsFile); 
230. 
231. \} 
232. 
233. 
234. 
235. 
236. 
237. // TODO: MiniDumpWriteDump
238. 
239. FatalAppExit(-1, \_T("Fatal Error")); 
240. 
241. **return** EXCEPTION\_CONTINUE\_SEARCH; 
242. 
243. \} 
244. 
245. 
246. 
247. //运行异常处理
248. 
249. **void** RunCrashHandler() 
250. 
251. \{ 
252. 
253. SetUnhandledExceptionFilter(UnhandledExceptionFilterEx); 
254. 
255. PreventSetUnhandledExceptionFilter(); 
256. 
257. \}

//测试实现文件

// 一个有函数调用的类

class CrashTest

public:

void Test()

Crash();

private:

void Crash()

strcpy(NULL,"adfadfg");

\};

int \_tmain(int argc, \_TCHAR\* argv\[\])

//设置异常处理函数

RunCrashHandler();

CrashTest test;

test.Test();

getchar();

return 0;

注意事项

1、需要配置debug选项，在C/C++选项à常规à调试信息格式(设置为程序[数据库][Link 2](/Zi))；在连接器选项—>调试à生成调试信息(设置为是)；C/C++选项à优化à禁用。(参见下图)

2、可执行文件（exe）必须找到dbghelp.dll，才能生成Dump文件。这个DLL可以从调试工具包中找到。

3、\*.exe、\*.pdb、\*.dump、dbghelp.dll 这四个文件需要放在同一目录下才好调试，双击dump文件时，就可以自动关联到出错代码位置。

4、为了获取更多更深入的调试信息，需要把程序优化开关设置成禁用。

5、当异常代码定位成功以后，如果无法阻止异常的产生，可以用 \_\_try 结构包装异常代码，\_\_try 和 try 不同，前者可以捕获非法指针产生的异常。

\_\_try \{

// 会异常的函数

\_\_except( EXCEPTION\_EXECUTE\_HANDLER )\{

// 异常处理

![Center][]

![Center 1][]

![Center 2][]

二、调试Minidump文件

1.  双击minidump文件（\*.dmp）。默认会启动vs2008。
2.  菜单Tools/Options, Debugging/Symbols，增加PDB文件路径。注：如果minidump文件与pdb文件在同一目录，就不用设置这个了。
3.  若调试的程序需要微软基础库的PDB信息，可以增加一个路径为：
4.  [http://msdl.microsoft.com/download/symbols][http_msdl.microsoft.com_download_symbols]
5.  在界面下方Cache Symbol From symbol…选择本地存储这些Symbols的路径。 注：如果本地已存储过微软基础库的pdb，就直接按照此步操作设置本地路径，不必执行上一步操作了。
6.  ![20130717160631937][]设置代码路径：

设置代码路径：

刚打开的dmp工程，进入解决方案的属性。在这里输入源程序的代码路径。注：一定是sln所在的路径，而不是vcproj的路径！

![20130717160712875][]

按F5，debug吧。

demo代码下载：[http://download.csdn.net/detail/byxdaz/7349325][http_download.csdn.net_detail_byxdaz_7349325]

//-

\#pragma once 
 
 
 
 
 
 
\#include <windows.h> 
 
 
\#include <imagehlp.h> 
 
 
\#include <stdlib.h> 
 
 
\#pragma comment(lib, "dbghelp.lib") 
 
 
 
 
 
 
inline BOOL IsDataSectionNeeded(const WCHAR\* pModuleName) 
 
 
\{ 
 
 
if(pModuleName == 0) 
 
 
\{ 
 
 
return FALSE; 
 
 
\} 
 
 
 
 
 
 
WCHAR szFileName\[\_MAX\_FNAME\] = L""; 
 
 
\_wsplitpath(pModuleName, NULL, NULL, szFileName, NULL); 
 
 
if(wcsicmp(szFileName, L"ntdll") == 0) 
 
 
return TRUE; 
 
 
 
 
 
 
return FALSE; 
 
 
\} 
 
 
 
 
 
 
inline BOOL CALLBACK MiniDumpCallback(PVOID pParam, 
 
 
const PMINIDUMP\_CALLBACK\_INPUT pInput, 
 
 
PMINIDUMP\_CALLBACK\_OUTPUT pOutput) 
 
 
\{ 
 
 
if(pInput == 0 || pOutput == 0) 
 
 
return FALSE; 
 
 
 
 
 
 
switch(pInput->CallbackType) 
 
 
\{ 
 
 
case ModuleCallback: 
 
 
if(pOutput->ModuleWriteFlags & ModuleWriteDataSeg) 
 
 
 
 
 
 
if(!IsDataSectionNeeded(pInput->Module.FullPath)) 
 
 
 
 
 
 
pOutput->ModuleWriteFlags &= (~ModuleWriteDataSeg); 
 
 
 
 
 
 
case IncludeModuleCallback: 
 
 
case IncludeThreadCallback: 
 
 
case ThreadCallback: 
 
 
case ThreadExCallback: 
 
 
return TRUE; 
 
 
 
 
 
 
default:; 
 
 
\} 
 
 
 
 
 
 
return FALSE; 
 
 
\} 
 
 
 
 
 
 
//创建Dump文件 
 
 
inline void CreateMiniDump(EXCEPTION\_POINTERS\* pep, LPCTSTR strFileName) 
 
 
\{ 
 
 
HANDLE hFile = CreateFile(strFileName, GENERIC\_WRITE, 0, NULL, CREATE\_ALWAYS, FILE\_ATTRIBUTE\_NORMAL, NULL); 
 
 
if((hFile != NULL) && (hFile != INVALID\_HANDLE\_VALUE)) 
 
 
\{ 
 
 
MINIDUMP\_EXCEPTION\_INFORMATION mdei; 
 
 
mdei.ThreadId = GetCurrentThreadId(); 
 
 
mdei.ExceptionPointers = pep; 
 
 
mdei.ClientPointers = FALSE; 
 
 
MINIDUMP\_CALLBACK\_INFORMATION mci; 
 
 
mci.CallbackRoutine = (MINIDUMP\_CALLBACK\_ROUTINE)MiniDumpCallback; 
 
 
mci.CallbackParam = 0; 
 
 
MINIDUMP\_TYPE mdt = (MINIDUMP\_TYPE)0x0000ffff; 
 
 
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, MiniDumpNormal, &mdei, NULL, &mci); 
 
 
 
 
 
 
CloseHandle(hFile); 
 
 
\} 
 
 
\} 
 
 
 
 
 
 
LPTOP\_LEVEL\_EXCEPTION\_FILTER WINAPI MyDummySetUnhandledExceptionFilter(LPTOP\_LEVEL\_EXCEPTION\_FILTER lpTopLevelExceptionFilter) 
 
 
\{ 
 
 
return NULL; 
 
 
\} 
 
 
 
 
 
 
BOOL PreventSetUnhandledExceptionFilter() 
 
 
\{ 
 
 
HMODULE hKernel32 = LoadLibrary(\_T("kernel32.dll")); 
 
 
if (hKernel32 == NULL) 
 
 
return FALSE; 
 
 
 
 
 
 
 
 
 
 
void \*pOrgEntry = GetProcAddress(hKernel32, "SetUnhandledExceptionFilter"); 
 
 
if(pOrgEntry == NULL) 
 
 
return FALSE; 
 
 
 
 
 
 
 
 
 
 
unsigned char newJump\[ 100 \]; 
 
 
DWORD dwOrgEntryAddr = (DWORD) pOrgEntry; 
 
 
dwOrgEntryAddr += 5; // add 5 for 5 op-codes for jmp far 
 
 
 
 
 
 
 
 
 
 
void \*pNewFunc = &MyDummySetUnhandledExceptionFilter; 
 
 
DWORD dwNewEntryAddr = (DWORD) pNewFunc; 
 
 
DWORD dwRelativeAddr = dwNewEntryAddr - dwOrgEntryAddr; 
 
 
 
 
 
 
 
 
 
 
newJump\[ 0 \] = 0xE9; // JMP absolute 
 
 
memcpy(&newJump\[ 1 \], &dwRelativeAddr, sizeof(pNewFunc)); 
 
 
SIZE\_T bytesWritten; 
 
 
BOOL bRet = WriteProcessMemory(GetCurrentProcess(), pOrgEntry, newJump, sizeof(pNewFunc) + 1, &bytesWritten); 
 
 
return bRet; 
 
 
\} 
 
 
 
 
 
 
 
 
 
 
LONG WINAPI UnhandledExceptionFilterEx(struct \_EXCEPTION\_POINTERS \*pException) 
 
 
\{ 
 
 
TCHAR szMbsFile\[MAX\_PATH\] = \{ 0 \}; 
 
 
::GetModuleFileName(NULL, szMbsFile, MAX\_PATH); 
 
 
TCHAR\* pFind = \_tcsrchr(szMbsFile, '\\\\'); 
 
 
if(pFind) 
 
 
\{ 
 
 
\*(pFind+1) = 0; 
 
 
\_tcscat(szMbsFile, \_T("CreateMiniDump.dmp")); 
 
 
CreateMiniDump(pException,szMbsFile); 
 
 
\} 
 
 
 
 
 
 
 
 
 
 
// TODO: MiniDumpWriteDump 
 
 
FatalAppExit(-1, \_T("Fatal Error")); 
 
 
return EXCEPTION\_CONTINUE\_SEARCH; 
 
 
\} 
 
 
 
 
 
 
//运行异常处理 
 
 
void RunCrashHandler() 
 
 
\{ 
 
 
SetUnhandledExceptionFilter(UnhandledExceptionFilterEx); 
 
 
PreventSetUnhandledExceptionFilter(); 
 
 
\}

调试方法不用上述那么麻烦，直接在Debug目录下 或者 Release目录下 exe + pdb + dmp 在同一目录，然后双击dmp文件VC2010就可以打开，然后点击右上角的调试按钮就可以直接定位到崩溃的代码了；

参考这里： http://blog.csdn.net/starlee/article/details/6630816

**别人机器上的dump调试：**

http://blog.csdn.net/xhk456/article/details/7523150

这段时间突然发现，要一下做一个金刚不坏之身的程序是不太可能滴，至于对我来说吧。  
这个程序也要经过千锤百炼才能够练就一个强大的自信心。

我现在做系统就不考虑一下把程序做的足够强壮了，因为我也做不到![大哭][wail.gif]，现在做系统时，总考虑的一个问题:

当系统异常的时候怎么去处理？

我不怕系统程序出现异常，甚至直接Over，只要能在异常时处理异常后继续运作，在崩溃重启后能够继续把没

干的活给干了，那么这个在我能够承受的范围内，也在大多数客户的承受范围内，因为这样就是我们所说的将

损失减小到最低，其实是不是最低只有自己能够知道。

当然了，我更希望能够做出一个健壮无比的牛逼程序，所以我想知道程序是在什么情况下崩溃的，可是有些问题

你懂的，老在客户机器上或者生产环境下出现，却在自己的机器上和测试环境就他妈的不出现，遇见这种情况我是

跳楼或者杀人的心情都有了，偶尔我也犯过情绪，想提出辞职申请，换个行业去，告别这苦逼的程序员生涯，

可总不知道是什么力量支持着我，让我坚强依旧滴做着程序员，过着狗日的日子。

后来，不经意间，一位同事给我说了一个种在系统中异常或者崩溃的时候，来生成dump文件，然后用调试器来调试。

这样就可以在生产环境中的dmp文件，拷贝到自己的开发机器上，调试就可以找到错误的位置，配合程序调试符号pdb文件，

直接可以定位到源代码中位置，真是太他妈的神奇了，虽然Release版本下的很多变量的值是不对滴，但并不影响我这个

这么有执着心的coder来找bug。

同事给了我他写的示例，往空指针拷贝数据，在非调试下运行后，果然的崩了，果断滴生成了一个扩展名为dmp的文件，

然后他用vs2010打开那个dmp文件，vs2010很果断滴定位到了那个往空指针拷贝数据那里。

看他那娴熟的操作，顿时感觉到了他的强大和微软的牛逼。

后来我就学他，在程序中加入程序异常时产生dump文件的功能，待系统发布后，在一次不经意间一个程序挂掉了。

在客户的谩骂中，我面带笑容说：这个问题很好解决。我满怀信心滴从服务器上拷贝了程序崩溃产生dump文件，

然后学着那个同事用vs2010打开，我了个去，咋没有定位到源代码中内，只定位到了可执行文件的一个地址，这让哥

情何以堪呐！

![1335711563_1631.jpg][]

还好，我对pdb了解还比较熟悉，想来应该是符号文件的问题，于是就开始摸索的，不经意见的在

堆栈处右击了下，发现菜单里竟然有“加载符号”，而且还有“符号路径”，我想这大概就是让我来选择

对应的pdb文件吧，顿时感觉曙光就在前面。

![1335712008_9868.jpg][]

点击了“符号路径”后如下图：

![1335712209_6923.jpg][]

才发现了，它并不是来选择符号文件，而是选择对应的可执行程序的路径，选择了后果断滴定位到了源代码的位置，

才发现一个很简单很美丽的bug，修改后，在测试后重现发布，系统的健壮性又提高了一个台阶。

回头想了想，我同事给我演示的时候，他程序运行的目录和就是他直接用vs2010生成的目录，所以此种情况下

用vs2010打开dmp文件即可定位到源代码文件。而发布后的程序，一般情况下你根本不知道别人放在什么地方去执行的，

因此调试时还并必须选相同版本的可执行文件，然后pdb文件才会好好工作，要不没可执行文件，咋个调试嘛。

哎，这同事，居然还留了一手，坑爹啊。

不过还是要感谢他滴，我又掌握了一些东西，又增强了我这个苦逼程序员写好程序的信心。

在写这个之前看了相关文章，感觉比较好的推荐一哈：

[http://www.cppblog.com/woaidongmao/archive/2011/05/10/146086.html][http_www.cppblog.com_woaidongmao_archive_2011_05_10_146086.html]

到这里，你就可以在你的工程中通过代码的方式添加，在程序崩溃的时候回创建dump文件了；

# .**dump** #

**.dump** 命令创建一个用户模式或内核模式崩溃转储文件。分析工具：[https://msdn.microsoft.com/en-us/library/windows/desktop/ee416349(v=vs.85).aspx\#writing\_a\_minidump][https_msdn.microsoft.com_en-us_library_windows_desktop_ee416349_v_vs.85_.aspx_writing_a_minidump]

程序崩溃（crash）的时候， 为了以后能够调试分析问题， 可以使用WinDBG要把当时程序内存空间数据都保存下来，生成的文件称为dump 文件。 步骤：

1） 打开WinDBG并将之Attach 到crash的程序进程

2） 输入产生dump 文件的命令

直接用.dump -?可以看到它的简单说明：

**\[cpp\]** [view plain][view plain 1] [copy][view plain 1]

1. 0:000> .dump -? 
2. Usage: .dump \[options\] filename 
3. Options are: 
4. /a - Create dumps **for** all processes (requires -u) 
5. /b\[a\] - Package dump in a CAB and **delete** dump 
6. /c <comment> - Add a comment (not supported in all formats) 
7. /j <addr> - Provide a JIT\_DEBUG\_INFO address 
8. /f - Create a legacy style full dump 
9. /m\[acdfFhiprRtuw\] - Create a minidump (**default**) 
10. /o - Overwrite any existing file 
11. /u - Append unique identifier to dump name

**/o** :覆盖具有相同名字的dump文件。如果没有使用该选项又存在一个相同名字的文件，则dump文件不会被写入：比如我的C盘原有一个myapp.dmp文件：

**\[cpp\]** [view plain][view plain 1] [copy][view plain 1]

1.  0:000> .dump c:/myapp.dmp 
2.  Unable to create file 'c:/myapp.dmp' \- Win32 error 0n80 
3.  "文件存在。"
4.  0:000> .dump /o c:/myapp.dmp 
5.  Creating c:/myapp.dmp - mini user dump 
6.  Dump successfully written

**/f** *(用户模式：)* 创建一个 [完整用户模式dump][dump]，这里要注意不要字面理解,

*完整用户模式dump*是基本的用户模式dump文件。这种dump文件包含进程的完整内存空间、程序本身的可执行映像、句柄表和其他对调试器有用的信息

**注意** 和名字无关，最大的"minidump"文件实际上可以提供比完整用户模式dump更多的信息。例如，**.dump /mf**或**.dump /ma**将创建比**.dump /f**更大更完整的文件。

用户模式下，使用**.dump /m**\[*MiniOptions*\] 是最好的选择。通过这个开关创建的dump文件可以很小也可以很大。通过指定合适的*MiniOptions* 可以控制究竟需要包含哪些信息。

**\[cpp\]** [view plain][view plain 1] [copy][view plain 1]

1.  0:000> .dump /o/f c:/myapp.dmp 
2.  \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* 
3.  \* .dump /ma is the recommend method of creating a complete memory dump \* 
4.  \* of a user mode process. \* 
5.  \*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\* 
6.  Creating c:/myapp.dmp - user full dump 
7.  Dump successfully written

我们看到了，系统给出了提示：.dump /ma是创建完整dump的推荐方式（用户模式下)

**/m**\[ *MiniOptions*\] 创建一个 [小内存dump][dump](内核模式)或者 [minidump ][dump](用户模式)。如果没有指定  **/f** 和 **/m** ， **/m** 是默认选项。 用户模式下， **/m** 后面可以跟附加的 *MiniOptions* 用来指定dump文件中包含的数据。如果没有使用 *MiniOptions* ，dump文件包含模块、线程和调用堆栈信息，但是没有其他附加信息

<table style="color:rgb(51,51,51); font-size:14px; line-height:26px"> 
 <tbody> 
 <tr> 
 <th>MiniOption</th> 
 <th>作用</th> 
 </tr> 
 <tr> 
 <td>a</td> 
 <td>创建一个包含所有附加选项的minidump。/ma选项相当于/mfFhut&nbsp;—它会在minidump中添加完整的内存数据、句柄数据、已卸载模块信息、基本内存信息和线程时间信息。</td> 
 </tr> 
 <tr> 
 <td>f</td> 
 <td>在minidump中包含完整内存数据。目标程序拥有的所有 可访问的已交付的页面(committed pages)都会包含进去。</td> 
 </tr> 
 <tr> 
 <td>F</td> 
 <td>在minidump中添加所有基本内存信息。这会将一个流加入到包含完整基本内存信息的minidump中，而不单是可使用的内存。这样可以使得调试器能够重建minidump生成时进程的完整虚拟内存布局。</td> 
 </tr> 
 <tr> 
 <td>h</td> 
 <td>在minidump中包含和目标进程相关的句柄信息。</td> 
 </tr> 
 <tr> 
 <td>u</td> 
 <td>在minidump中包含已卸载模块信息。仅在Windows Server 2003和之后版本的Windows中可用。</td> 
 </tr> 
 <tr> 
 <td>t</td> 
 <td>在minidump中包含附加的线程信息。包括可以在调试minidump时使用<a href="http://blog.csdn.net/hgy413/article/details/7586957" style="color:rgb(51,102,153); text-decoration:none" rel="nofollow">!runaway</a>扩展命令或<a href="http://blog.csdn.net/hgy413/article/details/7586957" style="color:rgb(51,102,153); text-decoration:none" rel="nofollow">.ttime&nbsp;(Display Thread Times)</a>命令进行显示的线程时间。</td> 
 </tr> 
 <tr> 
 <td>i</td> 
 <td>在minidump中包含次级内存(secondary memory)。次级内存是由堆栈中的指针或备份存储(backing store)中引用到的任何内存，加上该地址周围的一小段区域。</td> 
 </tr> 
 <tr> 
 <td>p</td> 
 <td>在minidump中包含进程环境块(PEB)和线程环境块(TEB)。这在想访问程序的进程和线程相关的Windows系统信息时很有用。</td> 
 </tr> 
 <tr> 
 <td>w</td> 
 <td>将所有已交付的可读写的私有页面包含进minidump。</td> 
 </tr> 
 <tr> 
 <td>d</td> 
 <td>在minidump中包含可执行映像中所有可读写的数据段。</td> 
 </tr> 
 <tr> 
 <td>c</td> 
 <td>加入映像中的代码段。</td> 
 </tr> 
 <tr> 
 <td>r</td> 
 <td>从minidump中去掉对重建调用堆栈无用的堆栈和存储内存部分。局部变量和其他数据类型值也被删除。这个选项不会使得minidump变小(因为这些内存节仅仅是变成0)，但是当想保护其他程序中的机密信息时有用。</td> 
 </tr> 
 <tr> 
 <td>R</td> 
 <td>在minidump中去掉完整的模块路径。仅包含模块名。如果想保护用户的目录结构时该选项有用。</td> 
 </tr> 
 </tbody> 
</table>

**选项(1)**： /m

**命令行示例**：.dump /m C:/dumps/myapp.dmp

**注解**： 缺省选项，生成标准的minidump， 转储文件通常较小，便于在网络上通过邮件或其他方式传输。 这种文件的信息量较少，只包含系统信息、加载的模块（DLL）信息、 进程信息和线程信息。

**选项(2)**： /ma

**命令行示例**：.dump /ma C:/dumps/myapp.dmp

**注解**： 带有尽量多选项的minidump（包括完整的内存内容、句柄、未加载的模块，等等），文件很大，但如果条件允许（本机调试，局域网环境）， 推荐使用这中dump。

**选项(3)**：/mFhutwd

**命令行示例**：.dump /mFhutwd C:/dumps/myapp.dmp

**注解**：带有数据段、非共享的读/写内存页和其他有用的信息的minidump。包含了通过minidump能够得到的最多的信息。是一种折中方案。

Fhutwd按字母对应上面的*MiniOptions表示*

//-xp自动生成dump-----------------------------------------------------------------------------------------------------------------------------------------------------------------

那怎么自动生成dump文件呢，比如对方的电脑没有windbg，这里用到一个window XP系统自带工具，Dr.Watson

运行方式很简单：

直接run-输入drwtsn32 -i就可以了，会提示这样的:

![1337583098_3339.JPG][]

这个命令真难记，实话，记**华生医生吧，福尔摩斯中的**

**如果有程序崩溃，会自动生成dump,这时再输入drwtsn32就会运行这个程序:**

![1337583292_3003.JPG][]

找到对应路径的DMP文件就行了，一般放在如下路径:  
C:\\Documents and Settings\\All Users\\Application Data\\Microsoft\\Dr Watson

//-win7自动生成dump-----------------------------------------------------------------------------------------------------------------------------------------------------------------

win7下需打开regedit--> 找到:

\[HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\]

在它下面加一项LocalDumps,并做如下项配置：

<table style="color:rgb(51,51,51); font-size:14px; line-height:26px"> 
 <tbody> 
 <tr> 
 <td>Value</td> 
 <td>描述</td> 
 <td>Type</td> 
 <td>默认值</td> 
 </tr> 
 <tr> 
 <td>DumpFolder</td> 
 <td>文件保存路径</td> 
 <td>REG_EXPAND_SZ</td> 
 <td>%LOCALAPPDATA%CrashDumps</td> 
 </tr> 
 <tr> 
 <td>DumpCount</td> 
 <td>dump文件的最大数目</td> 
 <td>REG_DWORD</td> 
 <td>10</td> 
 </tr> 
 <tr> 
 <td>DumpType</td> 
 <td>指定生成的dump类型: 0:Custom dump 1:Mini dump 2:Full dump</td> 
 <td>REG_DWORD</td> 
 <td>1</td> 
 </tr> 
 <tr> 
 <td>CustomDumpFlags</td> 
 <td>仅在DumpType为0时使用 为MINIDUMP_TYPE的组合</td> 
 <td>REG_DWORD</td> 
 <td><pre style="white-space: pre-wrap; word-wrap: break-word;">MiniDumpWithDataSegs|</pre><pre style="white-space: pre-wrap; word-wrap: break-word;">MiniDumpWithUnloadedModules|</pre><pre style="white-space: pre-wrap; word-wrap: break-word;">MiniDumpWithProcessThreadData</pre></td> 
 </tr> 
 </tbody> 
</table>

**可以写成.bat：**

**\[cpp\] [view plain][view plain 1][copy][view plain 1]**

1.  **@echo off** 
2.  **echo 设置Dump...** 
3.  **reg add "HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps"**
4.  **reg add "HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps" /v DumpFolder /t REG\_EXPAND\_SZ /d "C:\\MyDump" /f** 
5.  **reg add "HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps" /v DumpType /t REG\_DWORD /d 2 /f** 
6.  **reg add "HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps" /v DumpCount /t REG\_DWORD /d 10 /f** 
7.  **echo Dump已经设置** 
8.  **pause** 
9.  **@echo on**

**\[cpp\] [view plain][view plain 1][copy][view plain 1]**

1.  **@echo off** 
2.  **echo 正在取消设置Dump...** 
3.  **reg delete"HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps" /f** 
4.  **echo Dump已经取消设置** 
5.  **pause** 
6.  **@echo on**

**LocalDumps是全局的，如果想针对指定进程单独设置，如test1.exe，则在/LocalDumps下新建子项test1.exe，同时在test1目录下复制上表的选项，这样，系统就会先读全局设置，再读子项test1.exe的设置**

简单测试：

void CtMFC5Dlg::OnBnClickedButton1()  
\{  
// TODO: 在此添加控件通知处理程序代码  
char \* pstr = NULL;

int n = strlen( pstr );

在Windows 7上可以由多个方法产生dump文件：

转一篇文章：

[Windows调试 - 如何使用dump文件][Windows_ - _dump]

**如何使用dump文件**

我最近在开发一个windows下的程序(win7/win8)，有一些case下会crash，如果在自己开发机器上调试比较简单：运行程序，然后vs attach到进程上即可，但是在每台QA的机器上安装vs时不现实的，因此我们要用到dump文件。

微软网站有一篇文章讲述如何创建dump文件：

http://support.microsoft.com/kb/931673

**第一种： 通过任务管理器**：这种适用在程序挂了(crash)的时候进程还未退出，比如我运行程序，出现了下面的错：

![1359965831_1729.jpg][]

此时打开任务管理器，右击相应进程，点击"Create Dump File“：

![1359965880_4133.jpg][]

一会创建完成：

![1359965880_5630.jpg][]

然后把这个DMP文件拷到开发机器上，用VS打开： 会出现下面的界面，要想知道发生错误时候的调用栈，需要设置symbol的路径，点击”Set Symbol Paths“：

![1359965880_3656.jpg][]

注意这个pdb要对应于crash的exe，否则调用栈没法显示：

![1359965881_7214.jpg][]

设置完成后，点击”Debug with Native Only“ 你就可以看到调用栈了。

**第二种： 改注册表**

如果程序crash的时候没有框蹦出来，可以通过改注册表的设置让操作系统在程序crash的时候自动生成dump，并放到特定的目录下

**\[plain\]** [view plain][view plain 2] [copy][view plain 2]

1.  HKEY\_LOCAL\_MACHINE\\SOFTWARE\\Microsoft\\Windows\\Windows Error Reporting\\LocalDumps 
2.  Value Name = DumpType 
3.  Data type: REG\_DWORD 
4.  Value Data = 1

其中Value Data=1代表的含义是：

**\[plain\]** [view plain][view plain 2] [copy][view plain 2]

1.  0 = Create a custom dump 
2.  1 = Mini dump 
3.  2 = Full dump

设置完成后，crash发生时，操作系统生成dump，路径在%LOCALAPPDATA%\\CrashDumps下，详细可以参考：

http://msdn.microsoft.com/en-us/library/bb787181%28v=VS.85%29.aspx

（完）

http://blog.csdn.net/chinabinlang/article/details/49491813

[.NET]: http://lib.csdn.net/base/dotnet
[Link 1]: http://lib.csdn.net/base/operatingsystem
[view plain]: http://blog.csdn.net/byxdaz/article/details/25872151#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/346316
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/346316/fork
[Link 2]: http://lib.csdn.net/base/mysql
[Center]: /images/20220715/5cb27351c82b4afbba1efc13c07494cc.png
[Center 1]: /images/20220715/eb68fc879a73473b91bacbbf4d4720c3.png
[Center 2]: /images/20220715/0bb120de2ed24514a4fbea4818bb158f.png
[http_msdl.microsoft.com_download_symbols]: http://msdl.microsoft.com/download/symbols
[20130717160631937]: /images/20220715/bec6122921554620857e0d11e60ac791.png
[20130717160712875]: /images/20220715/999f547152d64408ae8e01d108b6846f.png
[http_download.csdn.net_detail_byxdaz_7349325]: http://download.csdn.net/detail/byxdaz/7349325
[wail.gif]: /images/20220715/2900c20a959d4b158001ab45fa3ded7b.png
[1335711563_1631.jpg]: https://img-my.csdn.net/uploads/201204/29/1335711563_1631.jpg
[1335712008_9868.jpg]: https://img-my.csdn.net/uploads/201204/29/1335712008_9868.jpg
[1335712209_6923.jpg]: https://img-my.csdn.net/uploads/201204/29/1335712209_6923.jpg
[http_www.cppblog.com_woaidongmao_archive_2011_05_10_146086.html]: http://www.cppblog.com/woaidongmao/archive/2011/05/10/146086.html
[https_msdn.microsoft.com_en-us_library_windows_desktop_ee416349_v_vs.85_.aspx_writing_a_minidump]: https://msdn.microsoft.com/en-us/library/windows/desktop/ee416349%28v=vs.85%29.aspx#writing_a_minidump
[view plain 1]: http://blog.csdn.net/hgy413/article/details/7586957#
[dump]: http://blog.csdn.net/hgy413/article/details/7586957
[1337583098_3339.JPG]: https://img-my.csdn.net/uploads/201205/21/1337583098_3339.JPG
[1337583292_3003.JPG]: https://img-my.csdn.net/uploads/201205/21/1337583292_3003.JPG
[Windows_ - _dump]: http://blog.csdn.net/jfkidear/article/details/22201829
[1359965831_1729.jpg]: https://img-my.csdn.net/uploads/201302/04/1359965831_1729.jpg
[1359965880_4133.jpg]: https://img-my.csdn.net/uploads/201302/04/1359965880_4133.jpg
[1359965880_5630.jpg]: https://img-my.csdn.net/uploads/201302/04/1359965880_5630.jpg
[1359965880_3656.jpg]: https://img-my.csdn.net/uploads/201302/04/1359965880_3656.jpg
[1359965881_7214.jpg]: https://img-my.csdn.net/uploads/201302/04/1359965881_7214.jpg
[view plain 2]: http://blog.csdn.net/wangzhi0417/article/details/8569234#