Visual Leak Detector 内存泄露检测，该怎么处理

下面让我们来介绍如何使用这个小巧的工具。

首先从网站上下载zip包，解压之后得到vld.h, vldapi.h, vld.lib, vldmt.lib, vldmtdll.lib, dbghelp.dll等文件。将.h文件拷贝到Visual C++的默认include目录下，将.lib文件拷贝到Visual C++的默认lib目录下，便安装完成了。因为版本问题，如果使用windows 2000或者以前的版本，需要将dbghelp.dll拷贝到你的程序的运行目录下，或其他可以引用到的目录。

接下来需要将其加入到自己的代码中。方法很简单，只要在包含入口函数的.cpp文件中包含vld.h就可以。如果这个cpp文件包含了stdafx.h，则将包含vld.h的语句放在stdafx.h的包含语句之后，否则放在最前面。如下是一个示例程序：

#include <vld.h>

void main()

{

…

}

接下来让我们来演示如何使用Visual Leak Detector检测内存泄漏。下面是一个简单的程序，用new分配了一个int大小的堆内存，并没有释放。其申请的内存地址用printf输出到屏幕上。

#include <vld.h>

#include <stdlib.h>

#include <stdio.h>

void f()

{

int *p = new int(0x12345678)

printf("p=%08x, ", p)

}

void main()

{

f()

}

编译运行后，在标准输出窗口得到：

p=003a89c0

在Visual C++的Output窗口凯键贺得到：

WARNING: Visual Leak Detector detected memory leaks!

---------- Block 57 at 0x003A89C0: 4 bytes ------------57号块0x003A89C0地址泄漏了4个字节

Call Stack: --下面是调用堆栈

d:\test\testvldconsole\testvldconsole\main.cpp (7): f--表示在main.cpp第7行的f()函数

d:\test\testvldconsole\testvldconsole\main.cpp (14): main –双击以引导至对应代码处

f:\rtm\vctools\crt_bld\self_x86\crt\src\crtexe.c (586): __tmainCRTStartup

f:\rtm\vctools\crt_bld\self_x86\crt\src\crtexe.c (403): mainCRTStartup

0x7C816D4F (File and line number not available): RegisterWaitForInputIdle

Data: --这是泄漏内存的内容，0x12345678

78 56 34 12 xV4..... ........

Visual Leak Detector detected 1 memory leak.

第二行表示57号块有4字节的内存泄漏，地址为0x003A89C0，根据程序控制台的输出，可以知道，该地址为指针p。程序的第7行，f()函数里，在该地址处分配了4字节的堆内存空间，并赋值为0x12345678，这样在盯派报告中，我们看到了这4字节同样的内容。

可以看出，对于每一个内存泄漏，这个报告列出了它的泄漏点、长度、分配该内存时的调用堆栈、和泄露内存的内容（分别以16进制和文本格式列出）。双击该堆栈报告的某一行，会自动在代码编辑器中跳到其所指文件的对应行。这些信息对于我们查找内存泄露将有亮慎很大的帮助。

这是一个很方便易用的工具，安装后每次使用时，仅仅需要将它头文件包含进来重新build就可以。而且，该工具仅在build Debug版的时候会连接到你的程序中，如果build Release版，该工具不会对你的程序产生任何性能等方面影响。所以尽可以将其头文件一直包含在你的源代码中。

Visual Leak Detector工作原理

下面让我们来看一下该工具的工作原理。

在这之前，我们先来看一下Visual C++内置的内存泄漏检测工具是如何工作的。Visual C++内置的工具CRT Debug Heap工作原来很简单。在使用Debug版的malloc分配内存时，malloc会在内存块的头中记录分配该内存的文件名及行号。当程序退出时CRT会在main()函数返回之后做一些清理工作，这个时候来检查调试堆内存，如果仍然有内存没有被释放，则一定是存在内存泄漏。从这些没有被释放的内存块的头中，就可以获得文件名及行号。

这种静态的方法可以检测出内存泄漏及其泄漏点的文件名和行号，但是并不知道泄漏究竟是如何发生的，并不知道该内存分配语句是如何被执行到的。要想了解这些，就必须要对程序的内存分配过程进行动态跟踪。Visual Leak Detector就是这样做的。它在每次内存分配时将其上下文记录下来，当程序退出时，对于检测到的内存泄漏，查找其记录下来的上下文信息，并将其转换成报告输出。

初始化

Visual Leak Detector要记录每一次的内存分配，而它是如何监视内存分配的呢？Windows提供了分配钩子(allocation hooks)来监视调试堆内存的分配。它是一个用户定义的回调函数，在每次从调试堆分配内存之前被调用。在初始化时，Visual Leak Detector使用_CrtSetAllocHook注册这个钩子函数，这样就可以监视从此之后所有的堆内存分配了。

如何保证在Visual Leak Detector初始化之前没有堆内存分配呢？全局变量是在程序启动时就初始化的，如果将Visual Leak Detector作为一个全局变量，就可以随程序一起启动。但是C/C++并没有约定全局变量之间的初始化顺序，如果其它全局变量的构造函数中有堆内存分配，则可能无法检测到。Visual Leak Detector使用了C/C++提供的#pragma init_seg来在某种程度上减少其它全局变量在其之前初始化的概率。根据#pragma init_seg的定义，全局变量的初始化分三个阶段：首先是compiler段，一般c语言的运行时库在这个时候初始化；然后是lib段，一般用于第三方的类库的初始化等；最后是user段，大部分的初始化都在这个阶段进行。Visual Leak Detector将其初始化设置在compiler段，从而使得它在绝大多数全局变量和几乎所有的用户定义的全局变量之前初始化。

记录内存分配

一个分配钩子函数需要具有如下的形式：

int YourAllocHook( int allocType, void *userData, size_t size, int blockType, long requestNumber, const unsigned char *filename, int lineNumber)

就像前面说的，它在Visual Leak Detector初始化时被注册，每次从调试堆分配内存之前被调用。这个函数需要处理的事情是记录下此时的调用堆栈和此次堆内存分配的唯一标识——requestNumber。

得到当前的堆栈的二进制表示并不是一件很复杂的事情，但是因为不同体系结构、不同编译器、不同的函数调用约定所产生的堆栈内容略有不同，要解释堆栈并得到整个函数调用过程略显复杂。不过windows提供一个StackWalk64函数，可以获得堆栈的内容。StackWalk64的声明如下：

BOOL StackWalk64(DWORD MachineType,HANDLE hProcess,HANDLE hThread,LPSTACKFRAME64 StackFrame,PVOID ContextRecord,PREAD_PROCESS_MEMORY_ROUTINE64 ReadMemoryRoutine,PFUNCTION_TABLE_ACCESS_ROUTINE64 FunctionTableAccessRoutine,PGET_MODULE_BASE_ROUTINE64 GetModuleBaseRoutine,PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress)

STACKFRAME64结构表示了堆栈中的一个frame。给出初始的STACKFRAME64，反复调用该函数，便可以得到内存分配点的调用堆栈了。

// Walk the stack.

while (count <_VLD_maxtraceframes) {

count++

if (!pStackWalk64(architecture, m_process, m_thread, &frame, &context,

NULL, pSymFunctionTableAccess64, pSymGetModuleBase64, NULL)) {

// Couldn't trace back through any more frames.

break

}

if (frame.AddrFrame.Offset == 0) {

// End of stack.

break

}

// Push this frame's program counter onto the provided CallStack.

callstack->push_back((DWORD_PTR)frame.AddrPC.Offset)

}

那么，如何得到初始的STACKFRAME64结构呢？在STACKFRAME64结构中，其他的信息都比较容易获得，而当前的程序计数器(EIP)在x86体系结构中无法通过软件的方法直接读取。Visual Leak Detector使用了一种方法来获得当前的程序计数器。首先，它调用一个函数，则这个函数的返回地址就是当前的程序计数器，而函数的返回地址可以很容易的从堆栈中拿到。下面是Visual Leak Detector获得当前程序计数器的程序：

#if defined(_M_IX86) || defined(_M_X64)

#pragma auto_inline(off)

DWORD_PTR VisualLeakDetector::getprogramcounterx86x64 ()

{

DWORD_PTR programcounter

__asm mov AXREG, [BPREG + SIZEOFPTR] // Get the return address out of the current stack frame

__asm mov [programcounter], AXREG// Put the return address into the variable we'll return

return programcounter

}

#pragma auto_inline(on)

#endif // defined(_M_IX86) || defined(_M_X64)

得到了调用堆栈，自然要记录下来。Visual Leak Detector使用一个类似map的数据结构来记录该信息。这样可以方便的从requestNumber查找到其调用堆栈。分配钩子函数的allocType参数表示此次堆内存分配的类型，包括_HOOK_ALLOC, _HOOK_REALLOC, 和 _HOOK_FREE，下面代码是Visual Leak Detector对各种情况的处理。

switch (type) {

case _HOOK_ALLOC:

visualleakdetector.hookmalloc(request)

break

case _HOOK_FREE:

visualleakdetector.hookfree(pdata)

break

case _HOOK_REALLOC:

visualleakdetector.hookrealloc(pdata, request)

break

default:

visualleakdetector.report("WARNING: Visual Leak Detector: in allochook(): Unhandled allocation type (%d).\n", type)

break

}

这里，hookmalloc()函数得到当前堆栈，并将当前堆栈与requestNumber加入到类似map的数据结构中。hookfree()函数从类似map的数据结构中删除该信息。hookrealloc()函数依次调用了hookfree()和hookmalloc()。

检测内存泄露

前面提到了Visual C++内置的内存泄漏检测工具的工作原理。与该原理相同，因为全局变量以构造的相反顺序析构，在Visual Leak Detector析构时，几乎所有的其他变量都已经析构，此时如果仍然有未释放之堆内存，则必为内存泄漏。

分配的堆内存是通过一个链表来组织的，检查内存泄漏则是检查此链表。但是windows没有提供方法来访问这个链表。Visual Leak Detector使用了一个小技巧来得到它。首先在堆上申请一块临时内存，则该内存的地址可以转换成指向一个_CrtMemBlockHeader结构，在此结构中就可以获得这个链表。代码如下：

char *pheap = new char

_CrtMemBlockHeader *pheader = pHdr(pheap)->pBlockHeaderNext

delete pheap

其中pheader则为链表首指针。

报告生成

前面讲了Visual Leak Detector如何检测、记录内存泄漏及其其调用堆栈。但是如果要这个信息对程序员有用的话，必须转换成可读的形式。Visual Leak Detector使用SymGetLineFromAddr64()及SymFromAddr()生成可读的报告。

// Iterate through each frame in the call stack.

for (frame = 0frame <callstack->size()frame++) {

// Try to get the source file and line number associated with

// this program counter address.

if (pSymGetLineFromAddr64(m_process,

(*callstack)[frame], &displacement, &sourceinfo)) {

...

}

// Try to get the name of the function containing this program

// counter address.

if (pSymFromAddr(m_process, (*callstack)[frame],

&displacement64, pfunctioninfo)) {

functionname = pfunctioninfo->Name

}

else {

functionname = "(Function name unavailable)"

}

...

}

概括讲来，Visual Leak Detector的工作分为3步，首先在初始化注册一个钩子函数；然后在内存分配时该钩子函数被调用以记录下当时的现场；最后检查堆内存分配链表以确定是否存在内存泄漏并将泄漏内存的现场转换成可读的形式输出。有兴趣的读者可以阅读Visual Leak Detector的源代码。

开发虚拟串口驱动程序

虚拟串口就是当本地并没有对应的串口硬件设备，而为应用层提供串口设备一样的系统调用接口，以兼容原本使用本地串口的应用软件的“虚”设备。本文作者给出了一种在Windows平台上实现虚拟串口的方法，由此实现的“串口”具有真实串口完全相同的系统调用接口。

在很多应用中需要用到虚拟串口，如在Modem卡出现之前，已经有了接在计算机串口上的外部Modem，而且各种拔号程序也是通过串口与外部Modem通信的。为了让已有的拔号程序缺枯不做修改,像使用外部Modem一样使用内置卡，就需要内置卡的驱动程序虚拟一个串口设备。又如当前工业界使用的一些串口服务器，往往有8个或16个甚至更多的串口，以连接多个串口设备，再通过一个网卡直接连入以太网。与它在同一网络上的计算机就通过以太网与串口服务器上挂接的串口设备通信。为了让计算机中原来使用本地串口的软件兼容，就需要在计算机上提供虚拟串口驱动。

虚拟串口的设计关键在于，该“串口”实现后必须具有与真实串口完全相同的系统调用接口。要做到这点，从已有的串口设备驱动程序上做修改是最佳捷径。下文就介绍以Windows NT上的串口驱动程序为基础，开发可运行于Windows NT、Windows 2000、Windows XP的各个版本虚拟串口驱动程序。

串口驱动中使用的几个链表

由于串口是双工设备，在一个读请求发出来还没有完成之前，同时可以发出写请求，加上在驱动程序层所有I/O请求都要求异步完成，即前一个请求尚没有完成，下一个相同的请求可能又来了。为此，串口驱动程序需要使用多个双向链表数据结构来处理各种IRP（I/O Request Packet，I/O请求包）。当收到一个IRP，先判断是否可立即完成，可以马上处理并返回，如果不允许则将IRP插在相应链表尾，在适当的时候如设备亮闷有空闲时处理，这时往往会产生一个硬件中断，激发DPC（Deferred Procedure Call，暂缓过程调用）过程，由DPC处理函数逐个从链表头取出IRP并试着完成它。串口驱动中有以下几个链表和DPC(在serial.h中有定义):

ReadQueue 和 CompleteReadDpc

用于保存Read IRP的链表和用于调度的DPC，与DPC对应的处理函数是SerialCompleteRead，它在read.c文件中，该函数的主要任务就是从ReadQueue中提取下一个IRP，并试着完成它。

WriteQueue 和 CompleteWriteDpc

用于保存Write IRP的链表和对应的DPC，与DPC对应的函数是SeriaCompleteWrite，它的实现在write.c中，该函数负责从WriteQueue中提取IRP，并试着完成它。

MaskQueue 和 CommWaitDpc

这一对链表用于处理Windows串口驱动的一个特性：事件驱动机制。它允许应用程序预设一个事件标志，而后等待与标志对应事件发生。DPC所调用的函数是SerialCompleteWait，它实现在Waitmask.c文件中，该函数也是试着从MaskQueue中提取IRP并完成它。

PurgeQueue

该链表与前面几个稍有不同，它没有与之相对应的DPC机制，而是在每次收到Purge请求时从PurgeQueue中逐个提取IRP并试着完成，因某种原因不能完成时则插入链表。相应的函数伏键洞是purge.c文件中的SerialStartPurge。

以上机制是串口驱动程序的重要实现方法，在虚拟串口驱动中需要保留，但不同的是，硬件串口驱动中是ISR（中断服务程序）根据收、发或MODEM中断来激发相应的DPC，而在虚拟串口驱动中将因实际情况不同会有不同的激发机制。

DriverEntry的实现

DriverEntry是驱动程序的入口函数，相当于应用程序C语言中的main函数，开发一个虚拟串口驱动首先要修改的就是它。它的函数实体在initunlo.c文件中。只是在虚拟串口驱动中由于不与具体的硬件打交道，就不存在硬件资源分析、硬件初始化、判断其工作状态等处理，只需要为虚拟串建立设备对象、符号链接和初始化数据结构。一个典型函数实现大体如下：

NTSTATUS DriverEntry(IN PDRIVER_OBJECT DriverObject, IN PUNICODE_STRING RegistryPath)

{

/*填写DriverObject->MajorFunction[]数组*/

/*建立设备对象*/

/*初始化SERIAL_DEVCIE_EXETENSION数据结构*/

Status = IoCreateDevice(DriverObject, sizeof(SERIAL_DEVICE_EXTENSION), &uniNameString, FILE_DEVICE_SERIAL_PORT, 0,TRUE,&deviceObject)

//初始化所有链表

InitializeListHead(&extension->ReadQueue)

InitializeListHead(…)

…

//初始化所有DPC

KeInitializeDpc(&extension->CompleteReadDpc,SerailCompleteRead,extension)

KeInitializeDpc(…)

/*建立符号链接*/

SerialSetupExternalNaming(extension)

return Status

}

SerialRead和SerialCompleteRead的实现

函数SerailRead和SerialCompleteRead决定了对Read IRP的响应策略，它们都存于read.c中。以串口服务器要用的虚拟串口为例，当串口服务器收到来自外部数据时将通过网络发至计算机，计算机则产生相应的网络中断并进行协议数据处理。网络接收线程缓存新收到的数据并激活CompleteReadDpc，从而SerialCompleteReadIrp得到调用，它再调用CompleteReadIrp对每个IRP进行处理。它们的实现大体如下：

NTSTATUS SerialRead(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)

{

/*此处略去变量声明和初始化*/

/*提取IRP中相关的数据*/

stack = IoGetCurrentIrpStackLocation(Irp)

ReadLen = stack->Parameters.Read.Length

/*先看本地缓冲有数据否？有的话先读取*/

if(Extension->InCounter >0 )

{ //注意这里要加锁，以防数据访问冲突

KeAcquireSpinLock(&Extension->

ReadBufferLock,&lIrql)

FirstRead = (ReadLen>Extension->

InCounter)? Extension->InCounter: ReadLen

RtlCopyMemory(Irp->AssociatedIrp.

SystemBuffer,Extension->pInBuffer,FirstRead)

Extension->InCounter -= FirstRead

ReadLen -= FirstRead

KeReleaseSpinLock(&Extension->

ReadBufferLock,lIrql)//释放锁

}

/*是否已读到足够数据？是的话则完成该IRP*/

if( 0 == ReadLen)

{

status=STATUS_SUCCESS

Irp->IoStatus.Status = status

Irp->IoStatus.Information = FirstRead

IoCompleteRequest(Irp,0)

return status

}

/*没有则将IRP插入队列中，通过网络向串口服务器发出读数据请求*/

IoMarkIrpPending(Irp)

InsertWaitList(Extension->ReadQueue,Irp)

status = TdiSendAsync(Extension->ComChannel,pAckPacket,PacketLen(pAckPacket),(PVOID)ReadAckComplete,Irp)

/*返回PENDING，表示该IRP尚没有完成*/

return STATUS_PENDING

}

Void CompleteReadIrp(IN PSERIAL_DEVICE_EXTENSION extension,IN PIRP Irp,IN PUCHAR pInData,IN ULONG Length )

{

/*此处略去变量声明和初始化*/

/*读取新数据*/

ReadLen = (ReadLen >Length)? Length : ReadLen

if(ReadLen != 0)

{

RtlCopyMemory(pReadAsync->

pReadBuffer,pInData,ReadLen)

pReadAsync->pReadBuffer += ReadLen

pReadAsync->ReadAlready += ReadLen

extension->PerfStats.ReceivedCount +=

ReadLen

}

else

{

/*因为串口服务器端只有在已经有了相应的数据或超过时间（此时，Length=0）才会发来应答并激活本DPC过程，所以此时已经超时，为了便于结束本IRP，这里有意改变TotalNeedRead，造成接收完毕的假象*/

pReadAsync->TotalNeedRead =

pReadAsync->ReadAlready

}

if(pReadAsync->TotalNeedRead == pReadAsync->ReadAlready)

{

/*该IRP是否已经接收完毕，是的话则结束该

IRP*/

EndReadIrp(Irp)；

/*从ReadQueue中取下一个IRP*/

}

/*本IRP没有完成也没有超时，则继续等待本DPC下次被激活，注意此时要判断IRP是否被要求取消*/

}

SerialWrite和SerailCompleteWrite的实现

SerialWrite和SerailCompleteWrite决定了Write IRP的实现。在SerialWrite中调用了网络发送函数TdiSendAsync,当该发送完成后将激活CompleteWriteDpc，调度SerialCompleteWrite函数，而它主要就是取出当前的WriteIRP,设置已经发送的数据数量，调用CompleteWriteIrp做该IRP的进一步处理。它们大体如下：

NTSTATUS SerialWrite(IN PDEVICE_OBJECT DeviceObject,IN PIRP Irp)

{

/*此处略去变量声明和初始化*/

/*从IRP中提取有关数据*/

stack=IoGetCurrentIrpStackLocation(Irp)

SendLen = stack->Parameters.Write.Length

/*为网络发送和异步 *** 作分配缓冲,在CompleteWrite中全部数据发送完后释放*/

pWriteAsync = ExAllocatePool(NonPagedPool,

SendLen+PACKET_HEADER_LEN+sizeof(WRITE_ASYNC))

if(pWriteAsync == NULL)

{

//错误处理

}

//保存异步数据

…

//设置网络发送数据包

BuildDataPacket(pPacket,WRITE,(USHORT)SendLen,pWriteAsync->pWriteBuffer)

/*先将IRP暂时阻塞并插入队列，在CompleteWrite中完成*/

IoMarkIrpPending(Irp)

InsertWaitList(extension->WriteQueue, Irp)

/*将写请求和相关数据通过网络发向串口服务器，由它负责将数据传到具体串口设备*/

status = TdiSendAsync(Extension->ComChannel,pPacket,PacketLen(pPacket),(PVOID)CompleteWriteIrp,Irp)

//统计数据累加

Extension->PerfStats.TransmittedCount += SendLen

return STATUS_PENDING

}

NTSTATUS CompleteWriteIrp(IN PDEVICE_OBJECT deviceobject,IN PIRP pIrp,IN PVOID context)

{

/*此处略去变量声明和初始化*/

SendLen=pWriteAsync->TotalNeedWrite - pWriteAsync->WroteAlready

if(SendLen == 0)//全部数据发送完毕

{

EndWaitWriteIrp(pWriteIrp,STATUS_SUCCESS,

pWriteAsync->WroteAlready,pWriteAsync)

//从WriteQueue中取下一个IRP

}

else //发送剩余数据

{

if(pWriteIrp->Cancel)

{

//IRP被要求取消，完成WriteIrp

EndWaitWriteIrp(pWriteIrp,STATUS_CANCELLED,

pWriteAsync->WroteAlready,pWriteAsync)

return STATUS_CANCELED

}

else

{

//再次设置网络数据包并发送

BuildDataPacket(…)

status = TdiSendAsync(…)

//统计数据累加

Extension->PerfStats.TransmittedCount +=

SendLen

return STATUS_MORE_PROCESSING_REQUIRED

}

}

}

其他几个接口函数的实现

除Read/Write外，SerialUnload、SerialCreateOpen、 SerialClose、SerialCleanup、SerailFlush等调用接口是硬件相关性比较弱的接口函数，基本不要修改，直接删除原来 *** 作硬件的部分即可。复杂一点就是SerialIoControl，该接口函数包含有大量设置、读取串口硬件状态的处理，可建立一个本地数据结构随时保存虚拟串口的当前硬件状态。同时为了保证串口服务器端的真实串口状态和上层软件要求的一致，需要将所有设置请求通过网络发送到服务器端，由它负责改变真实硬件的状态。

feof()，用这个函数判断是否读到文件尾了。

fread(buf,size,count,fp)//buf输入数据起始地址，size 每个数据块的大小，樱裂念count 每次写入的数据块个数，fp 文件指针

写源戚好后是：

while(!feof(fp))

{

fread(&temp[i],sizeof(struct use),1,fp)//这个读出来放数组里面

i++

}

问题是你读的是txt文件，完全脊困可以用fscanf()函数么。

---