COM学习（一）——COM基础思想 概述学习微软技术COM是绕不开的一道坎，最近做项目的时候发现有许多功能需要用到COM中的内容，虽然只是简单的使用COM中封装好的内容，但是许多代码仍然只知其然，不知其所以然，所以我决定从头开始好好学习一下COM基础的内容，因此在这记录下自己学习的内容，以便日后参考，也给其他朋友提供一点学习思路。COM的全称是Component Object Module，组件对象模型。组件就我自己的理解就是将各个功能部分编写成可重用的模块，程序就好像搭积木一样由这些可重用模块构成，这样将各个模块的耦合降到最低，以后升级修改功能只需要修改某一个模块，这样就大大降低了维护程序的难度和成本，提高程序的可扩展性。COM是微软公司提出的组件标准，同时微软也定义了组件程序之间进行交互的标准，提供了组件程序运行所需的环境。COM是基于组件化编程的思想，在COM中每一个组件成为一个模块，它可以是动态链接库或者可执行文件，一个组件程序可以包含一个或者多个组件对象，COM对象不同于OOP(面向对象)中的对象，COM对象是定义在二进制机器代码基础之上，是跨语言的。而OOP中的对象是建立在语言之上的。脱离了语言对象也就不复存在.COM是独立在编程语言之上的，是语言无关的。COM的这一特性使得不同语言开发的组件之间的互相交互成为可能。COM对象和接口COM中的对象类似于C++中的对象，对象是某个类中的实例。而类则是一组相关的数据和功能组合在一起的一个定义。使用对象的应用(或另一个对象)称为客户，有时也称为对象的用户。 接口是一组逻辑相关的函数的集合，比如一组处理URL的接口，处理HTTP请求的接口等等。在习惯上接口通常是以"I"开头。对象通过接口成员函数为客户提供各种形式的服务。一个对象可以拥有多个不同的接口，以表现不同的功能集合。 在C++语言中，一个接口就是一个虚基类，而对象就是该接口的实现类，派生自该接口并实现接口的功能。class IBook { public: virtual void NextPage() = 0; virtual void ForwardPage() = 0; } class IAppliances { public: virtual void charge() = 0; virtual void shutdown() = 0; } class CKindle: public IBook, IAppliances { public: virtual void NextPage(); virtual void ForwardPage(); virtual void charge(); virtual void shutdown(); }就像上面的例子，上面的例子中提供了一个书本的接口，书本可以翻到上一页，下一页，而电器有充电和关机的接口，最后我们利用kindle这个类来实现这两个接口。所以在使用上我们可以利用下面的伪代码来使用pInterface = CreateInterface(ID_IBOOK, ID_KINDLE); pInterface->NextPage(); if(Late()) { pInter2 = pInterface->QueryInterface(ID_APPLIANCES); pInter2->shutdown(); }在平时我们使用kindle的翻页功能来看书，因为翻页功能在接口IBook，所以首先调用一个创建接口的函数，传入对应接口以及接口实现类的标识，用来生成相应的接口，其实在内部也就是根据类ID来创建一个对应的实现类的实例。然后根据需要转化为对应基类的指针。在看书看累的时候，将接口转化为电子产品的接口，调用对应的关机功能，关闭电子书。在之后比如说kindle进行了升级，也就是重写了实现这些接口的代码，但是接口原型不变，这样使用接口的代码不用改变，也就是说即使kindle对内部进行了升级，优化某些功能，用户在使用上仍然是那样在用，不必改变使用习惯。再比如kindle出了一个新款，提供了背光功能，这个时候可能提供一个新接口：class IAppliances2 : public IAppliances { public: virtual void Light() = 0; }然后只需要稍微更新一下CKindle这个实现类，新增一个Light接口的实现，在使用上如果不用背光功能原来的代码就够用了，如果要使用背光功能，只需要将原来的接口类型改为IAppliances2 ，并且添加调用背光功能的函数，而其余的功能也不变，这与实际生活相似，某个产品提供新功能时，一般保持原始功能的使用方法不变，新功能会有新的按钮或者其他方法进行打开。再比如说我不想用kindle了改用其他的电子阅读器，只要接口不变，我的使用方法基本不变，唯一改变的可能是我以前拿着kindle，现在拿着其他品牌的阅读器，也就是说可能要改变传入CreateInterface函数中的类标识。COM基本接口COM中所有接口都派生自该接口：struct IUnknown { virtual HRESULT QueryInterface(REFIID riid,void **ppvObject) = 0; virtual ULONG AddRef( void) = 0; virtual ULONG Release( void) = 0; };所有类都应该实现上述三个方法，AddRef主要将接口的引用计数+1， 而Release则是将引用计数 -1，当对象的引用计数为0，则会调用析构函数，释放对象的存储空间。每一次接口的创建和转化都会增加引用计数，而每次不再使用调用Release，都会把引用计数 -1，当引用计数为0时会释放对象的空间。QueryInterface主要用来进行接口转化，将对象的指针转化为另外一个接口的指针，就好像上面例子中pInter2 = pInterface->QueryInterface(ID_APPLIANCES);这句代码将之前的Ibook接口转化为电子产品的接口。在C++中也就是做了一次强制类型转化。对象和接口的唯一标识在COM中，对象本身对于客户来说是不可见的，客户请求服务时，只能通过接口进行。每一个接口都由一个128位的全局唯一标识符(GUID，Global Unique Identifier)来标识。客户通过GUID来获得接口的指针，再通过接口指针，客户就可以调用其相应的成员函数。与接口类似，每个组件也用一个 128 位 GUID 来标识，称为 CLSID(class identifer，类标识符或类 ID)，用 CLSID 标识对象可以保证(概率意义上)在全球范围内的唯一性。实际上，客户成功地创建对象后，它得到的是一个指向对象某个接口的指针，因为 COM 对象至少实现一个接口(没有接口的 COM 对象是没有意义的)，所以客户就可以调用该接口提供的所有服务。根据 COM 规范，一个 COM 对象如果实现了多个接口，则可以从某个接口得到该对象的任意其他接口。由此可看出，客户与 COM 对象只通过接口打交道，对象对于客户来说只是一组接口。在COM中GUID的定义如下：typedef struct _GUID { unsigned long Data1; unsigned short Data2; unsigned short Data3; unsigned char Data4[ 8 ]; } GUID;一般我们在程序中只是作为一个标志来使用，并不对它进行特别的操作。生成它一般是使用VS自带的GUID生成工具。而CLSID的定义如下：typedef GUID CLSID;其实在COM中一般涉及到ID的都是GUID，只是利用typedef另外定义了一个名称而已另外COM也提供了一组函数用来对GUID进行操作：函数功能IsEqualGUID判断GUID是否相等IsEqualCLSID判断CLSID是否相等IsEqualIID判断IID是否相等CLSIDFromProgID把字符串形式的CLSID转化为CLSID结构形式（类似于将字符串的234转化为数字，也是把字面上的CLSID转化为计算机能识别的CLSID）StringFromCLSID把CLSID转化为字符串形式IIDFromString把字符串形式的IID转化为IID接口形式StringFromIID把IID结构转化为字符串StringFromGUID2把GUID形式转化为字符串形式COM接口的一般使用步骤一般使用COM中的时候首先使用CoInitialize初始化COM环境，不用的时候使用CoUninitialize卸载COM环境，在使用接口中一般需要进行下面的步骤调用CoCreateInstance函数传入对应的CLSID和对应的IID，生成对应对象并传入相应的接口指针。使用该指针进行相关操作调用接口的QueryInterface函数，转化为其他形式的接口在最后分别调用各个接口的Release函数，释放接口下面提供一个小例子，以供参考，也方便更好的理解COM//组件部分 extern "C" __declspec(dllexport) void __stdcall ComCreateObject(GUID clsID, GUID interfaceID, void** pObj); void __stdcall ComCreateObject(GUID clsID, GUID interfaceID, void** pObj) { if (clsID == CLSID_COMSTRING) { CComString *pComObject = new CComString; *pObj = pComObject->QueryInterface(interfaceID); } } class IComBase { public: virtual void* QueryInterface(GUID gInterfaceId) = 0; virtual void AddRef() = 0; virtual void Release() = 0; }; static const GUID IID_ICOMSTRING = { 0xb2fcd22c, 0x63fa, 0x4f61, { 0xbf, 0x12, 0xd3, 0xd2, 0x5a, 0x99, 0x59, 0x24 } }; class IComString : public IComBase { public: virtual void Init(LPCTSTR pStr) = 0; virtual int Find(LPCTSTR lpSubStr) = 0; virtual int GetLength() = 0; }; static const GUID CLSID_COMSTRING = { 0xf57f3489, 0xff2d, 0x4c97, { 0xb1, 0xf6, 0xc, 0x60, 0x7e, 0xf7, 0xae, 0xfc } }; class CComString : public IComString { public: virtual void* QueryInterface(GUID gInterfaceId); virtual void AddRef(); virtual void Release(); virtual void Init(LPCTSTR pStr); virtual int Find(LPCTSTR lpSubStr); virtual int GetLength(); protected: int m_nCnt = 0; CString m_csString; }; //cpp void* CComString::QueryInterface(GUID gInterfaceId) { if (gInterfaceId == IID_ICOMSTRING) { //该接口的引用计数+1 AddRef(); return dynamic_cast<IComString*>(this); } //如果它还实现了其他接口，可以再写判断，生成其他类型的接口 return NULL; } void CComString::AddRef() { m_nCnt++; } void CComString::Release() { m_nCnt--; //引用计数为0，此时没有该类的接口被使用，应该释放该类 if (m_nCnt == 0) { delete this; } } void CComString::Init(LPCTSTR pStr) { m_csString = pStr; } int CComString::Find(LPCTSTR lpSubStr) { return m_csString.Find(lpSubStr); } int CComString::GetLength() { return m_csString.GetLength(); }这些代码被封装在一个dll中，dll中导出一个函数ComCreateObject，外部在使用时调用该函数传入对应的ID，以便生成对应的接口。在这个dll里面提供一个接口的基类IComBase，这个是仿照了COM种的IUnknow基类，另外定义了一个IComString字符串的接口，同时定义了它的实现类CComString，为了简单，它的功能方法我直接使用了一个CString类实现。在函数ComCreateObject，会根据传入对应的类ID，来生成对应的类实例，然后调用实例的QueryInterface，转化成对应的接口，在实现类中实现了这个方法，实现类中的QueryInterface方法主要完成了类型转化并将引用计数+1。而Release函数在每次-1的时候会进行判断，当引用计数为0时销毁该类的实例由于类是new出来创建在堆上的，所以每次用完一定要记得调用Release释放，否则会造成内存泄露注意：在使用这里使用的是dynamic_cast进行类型转化，在进行类的强制类型转化时，特别是在有多重继承的情况下，最好使用dynamic_cast方式进行转化，当一个类拥有多个基类时，类中有多个虚函数表，为了能正常找到对应的虚函数表，就需要进行对应的偏移量的计算，C中的强制类型转化是直接将对象的首地址进行转化，这样在寻址虚函数表时可能会出错。而dynamic_cast会进行对应的计算。详细情形请参考这里在使用上void ComInitialize(); void ComUninitialize(); typedef void(__stdcall *pfnCreateInstance)(GUID, GUID, void**); pfnCreateInstance CreateInstance; HMODULE hComDll = NULL; int _tmain(int argc, _TCHAR* argv[]) { ComInitialize(); IComString *pIString = NULL; CreateInstance(CLSID_COMSTRING, IID_ICOMSTRING, (void**)&pIString); pIString->Init(_T("Hello World")); IComString* pIString2 = (IComString*)(pIString->QueryInterface(IID_ICOMSTRING)); int nLength = pIString2->GetLength(); int iPos = pIString2->Find(_T("World")); printf("%d, %d\n", nLength, iPos); pIString->Release(); pIString2->Release(); return 0; } void ComInitialize() { hComDll = LoadLibrary(_T("ComInterface.dll")); if (NULL != hComDll) { CreateInstance = (pfnCreateInstance)GetProcAddress(hComDll, "ComCreateObject"); } } void ComUninitialize() { FreeLibrary(hComDll); }给使用者使用时只需要提供对应类和接口的GUID，然后将函数ComCreateObject原型提供给调用者，以便生成对应的接口。这里为了模仿COM的使用定义了ComInitialize和ComUninitialize这两个函数，真实的初始化函数怎么写的，我也不知道，在这里只是为了模仿COM的使用。至此相信各位小伙伴应该对COM有了一个初步的了解

Vista 及后续版本的新线程池 在上一篇的博文中，说了下老版本的线程池，在Vista之后，微软重新设计了一套线程池机制，并引入一组新的线程池API，新版线程池相对于老版本的来说，它的可控性更高，它允许程序员自己定义线程池，并规定线程池中的线程数量和其他一些属性。线程池使用线程池的使用主要需要下面的四步：创建工作项提交工作项等待工作项完成清理工作项在前面说的四种线程池在使用上都是这4步，只是使用的API函数不同，每种线程池的每一步都有一个对应的API，总共有16个API普通线程池创建工作项的API为PTP_WORK WINAPI CreateThreadpoolWork( __in PTP_WORK_CALLBACK pfnwk, __inout_opt PVOID pv, __in_opt PTP_CALLBACK_ENVIRON pcbe );第一个参数是一个回调函数，当提交后，线程池中的线程会执行这个回调函数第二个参数是传递给回调函数的参数第三个参数是一个表示回调环境的结构，这个在后面会说回调函数的原型VOID CALLBACK WorkCallback( __inout PTP_CALLBACK_INSTANCE Instance, __inout_opt PVOID Context, __inout PTP_WORK Work );第一个参数用于表示线程池当前正在处理的一个工作项的实例，在后面会说它怎么用第二个参数是传给回调函数的参数的指针第三个参数是当前工作项的结构创建工作项完成之后调用SubmitThreadpoolWork将工作项提交到对应的线程池，由线程池中的线程处理这个工作项，该函数原型如下：VOID WINAPI SubmitThreadpoolWork( __inout PTP_WORK pwk );这个函数只有一个参数那就是工作项的指针，即我们想将哪个工作项提交。提交工作项之后，在需要同步的地方，调用函数WaitForThreadpoolWorkCallbacks,等待线程池中的工作项完成,该函数原型如下VOID WINAPI WaitForThreadpoolWorkCallbacks( __inout PTP_WORK pwk, __in BOOL fCancelPendingCallbacks );最后一个参数表示线程池是否需要执行未执行的工作项，注意它只能取消执行还没有开始执行的工作项，而不能取消已经有线程开始执行的工作项，最后调用函数CloseThreadpoolWork清理工作项，该函数的原型如下：VOID WINAPI CloseThreadpoolWork( __inout PTP_WORK pwk );就我个人的理解，TP_WORK应该保存的是一个工作项的信息，包含工作项的回调以及传递个回调函数的参数，每当提交一个工作项就是把这个结构放入到线程池的队列中，当线程池中有空闲线程的时候从队列中取出这个结构，将结构中的回调函数参数传递给回调函数，并调用它。我们可以重复提交同一个工作项多次，但是每个工作项一旦定义好了，那么传递给对应回调函数的参数应该是固定的，后期是没办法更改它的。它的等待函数调用时根据第二个参数，如果为TRUE则将线程池队列中的工作项清除，然后等待所有线程都为空闲状态时返回，而当参数为FALSE时，就不对队列中的工作项进行操作，并且一直等到线程池中的所有线程为空闲。下面是一个具体的使用例子：VOID CALLBACK MyWorkCallback( PTP_CALLBACK_INSTANCE Instance, PVOID Parameter, PTP_WORK Work ) { int nWaitTime = 4; printf("线程[%04x]将等待%ds\n", GetCurrentThreadId(), nWaitTime); Sleep(nWaitTime * 1000); printf("线程[%04x]执行完毕\n", GetCurrentThreadId()); } int _tmain(int argc, _TCHAR* argv[]) { PTP_WORK_CALLBACK workcallback = MyWorkCallback; PTP_WORK work = CreateThreadpoolWork(workcallback, NULL, NULL); //创建工作项 for (int i = 0; i < 4; i++) { SubmitThreadpoolWork(work); //提交工作项 } //等待线程池中的所有工作项完成 WaitForThreadpoolWorkCallbacks(work, FALSE); //关闭工作项 CloseThreadpoolWork(work); return 0; }定时器线程池定时器线程池中使用的对应的API分别为CreateThreadpoolTimer、SetThreadpoolTimer、WaitForThreadpoolTimerCallbacks和CloseThreadpoolTimer，这些函数的参数与之前的函数参数基本类似，区别比较大的是SetThreadpoolTimer，由于涉及到定时器，所以这里的参数稍微复杂一点VOID WINAPI SetThreadpoolTimer( __inout PTP_TIMER pti, __in_opt PFILETIME pftDueTime, __in DWORD msPeriod, __in_opt DWORD msWindowLength );第二个参数表示定时器触发的时间，它是一个64位的整数，如果为正数表示一个绝对的时间，表示从1960年到多少个100ns的时间后触发，如果为负数则表示从设置之时起经过多少时间后触发，单位为微秒（转化为秒是1000 * 1000）第三个参数每隔多长时间触发一次，如果只是想把这个定时器作为一次性的，和第四个参数没有用处，而如果想让线程池定期的触发它，这个值就是定期触发的间隔 时间，单位为毫秒第四个参数是用来给回调函数的执行时机增加一定的随机性，如果这个定时器是一个定期触发的定时器，那么这个值告诉线程池，可以在自定时器设置时间起，在(msPeriod - msWindowLength, mePeriod + msWindowsLong)这个区间之后的任意时间段触发另外我自己在编写测试代码的时候发现有的时候调用WaitForThreadpoolTimerCallbacks可能立即就返回了，后来我自己分析可能的原因是这个函数会在线程池队列中没有需要处理的工作项，并且线程池中线程为空闲的时候返回，当我使用定时器的时候，在等待时可能这个时候定时器上的时间未到，而线程池中又没有需要处理的定时器的工作项，所以它就返回了从而未达到等待的效果。下面是一个使用的具体例子,这个例子是《Windows核心编程》这本书中的例子，我觉得它里面有一个更改MessageBox显示信息的功能，所以将其修改了下作为例子int g_nWaitTime = 10; TCHAR g_szTitle[] = _T("提示"); #define ID_MSGBOX_STATIC_TEXT 0x0000ffff //MessageBox上内容部分的控件ID VOID CALLBACK TimerCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_TIMER Timer) { HWND hWnd = FindWindow(NULL, g_szTitle); //找到MessageBox所对应的窗口句柄 if (NULL != hWnd) { TCHAR szText[1024] = _T(""); StringCchPrintf(szText, 1024, _T("您将有%ds的时间"), --g_nWaitTime); SetDlgItemText(hWnd, ID_MSGBOX_STATIC_TEXT, szText); //更改显示信息 } if (g_nWaitTime == 0) { ExitProcess(0); } } int _tmain(int argc, _TCHAR* argv[]) { //创建定时器历程 PTP_TIMER pTimer = CreateThreadpoolTimer(TimerCallback, NULL, NULL); //将定时器历程加入到线程池 ULARGE_INTEGER uDueTime = {0}; FILETIME FileDueTime = {0}; uDueTime.QuadPart = (LONGLONG) -(1 * 10 * 1000 * 1000); //时间为1s FileDueTime.dwHighDateTime = uDueTime.HighPart; FileDueTime.dwLowDateTime = uDueTime.LowPart; SetThreadpoolTimer(pTimer, &FileDueTime, 1000, 0); //每1s调用一次 WaitForThreadpoolTimerCallbacks(pTimer, FALSE); //此处调用等待函数会立即返回 TCHAR szText[] = _T("您将有10s的时间"); MessageBox(NULL, szText, g_szTitle, MB_OK); //关闭工作项 CloseThreadpoolTimer(pTimer); return 0; }同步对象线程池对这种线程池的使用主要调用这样几个函数: CreateThreadpoolWait、SetThreadpoolWait、WaitForThreadpoolWaitCallbacks、CloseThreadpoolWait ，这几个函数的使用与之前的普通线程池的使用类似，在这就不再进行说明直接给例子VOID CALLBACK WaitCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WAIT Wait, TP_WAIT_RESULT WaitResult) { if (WaitResult == WAIT_OBJECT_0) { printf("[%04x] wait the event\n", GetCurrentThreadId()); }else if (WaitResult == WAIT_TIMEOUT) { printf("[%04x] time out\n", GetCurrentThreadId()); } } int _tmain(int argc, _TCHAR* argv[]) { //创建等待线程池 PTP_WAIT pWait = CreateThreadpoolWait(WaitCallback, NULL, NULL); //创建事件 HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); //等待时间为1s FILETIME ft = {0}; ULARGE_INTEGER uWaitTime = {0}; uWaitTime.QuadPart = (LONGLONG) - 1 * 1000 * 1000; ft.dwHighDateTime = uWaitTime.HighPart; ft.dwLowDateTime = uWaitTime.LowPart; for (int i = 0; i < 5; i++) { //模拟等待5次 SetThreadpoolWait(pWait, hEvent, &ft); Sleep(1000); //休眠 SetEvent(hEvent); } WaitForThreadpoolWaitCallbacks(pWait, FALSE); CloseThreadpoolWait(pWait); CloseHandle(hEvent); return 0; }这种类型的回调函数的WaitResult参数实际上是一个DWORD类型，表示调用这个回调的原因，WAIT_OBJECT_0表示同步对象变为有信号，WAIT_TIMEOUT表示超时WAIT_ABANDONED_0表示穿入的互斥量被遗弃（只有在同步对象为互斥量的时候才会有这种值）完成端口线程池完成端口线程池的使用主要用这些API：CreateThreadpoolIo、StartThreadpoolIo、WaitForThreadpoolIoCallbacks、CloseThreadpoolIo，这些函数的使用也是十分的简单，下面再次将之前的完成端口写日志的例子进行改写：int _tmain(int argc, _TCHAR* argv[]) { TCHAR szAppPath[MAX_PATH] = _T(""); GetAppPath(szAppPath); StringCchCat(szAppPath, MAX_PATH, _T("NewIocpLog.txt")); HANDLE hFile = CreateFile(szAppPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { return 0; } //创建IOCP线程池 g_pThreadpoolIO = CreateThreadpoolIo(hFile, IoCompletionCallback, hFile, NULL); StartThreadpoolIo(g_pThreadpoolIO); //写入Unicode字节码 LPIOCP_OVERLAPPED pIocpOverlapped = (LPIOCP_OVERLAPPED)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IOCP_OVERLAPPED)); pIocpOverlapped->dwDataLen = sizeof(WORD); pIocpOverlapped->hFile = hFile; WORD dwUnicode = MAKEWORD(0xff, 0xfe); //构造Unicode前缀 pIocpOverlapped->pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WORD)); CopyMemory(pIocpOverlapped->pData, &dwUnicode, sizeof(WORD)); //偏移文件指针 pIocpOverlapped->Overlapped.Offset = g_FilePointer.LowPart; pIocpOverlapped->Overlapped.OffsetHigh = g_FilePointer.HighPart; g_FilePointer.QuadPart += pIocpOverlapped->dwDataLen; //写文件 WriteFile(hFile, pIocpOverlapped->pData, pIocpOverlapped->dwDataLen, &pIocpOverlapped->dwWrittenLen, &pIocpOverlapped->Overlapped); //创建线程进行写日志操作 HANDLE hWrittenThreads[MAX_WRITE_THREAD]; for (int i = 0; i < MAX_WRITE_THREAD; i++) { hWrittenThreads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WriteThread, &hFile, 0, NULL); } //等待所有写线程执行完成 WaitForMultipleObjects(MAX_WRITE_THREAD, hWrittenThreads, TRUE, INFINITE); for (int i = 0; i < MAX_WRITE_THREAD; i++) { CloseHandle(hWrittenThreads[i]); } //等待线程池中待处理的IO完成请求 WaitForThreadpoolIoCallbacks(g_pThreadpoolIo, FALSE); CloseHandle(hFile); //关闭IOCP线程池 CloseThreadpoolIo(g_pThreadpoolIO); return 0; } VOID CALLBACK WriteThread(LPVOID lpParam) { TCHAR szBuf[255] = _T("线程[%04x]模拟写入一条日志记录\r\n"); TCHAR szWrittenBuf[255] = _T(""); StringCchPrintf(szWrittenBuf, 255, szBuf, GetCurrentThreadId()); for (int i = 0; i < EVERY_THREAD_WRITTEN; i++) { //提交一个IOCP历程 StartThreadpoolIo(g_pThreadpoolIO); LPIOCP_OVERLAPPED lpIocpOverlapped = (LPIOCP_OVERLAPPED)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IOCP_OVERLAPPED)); size_t dwBufLen = 0; StringCchLength(szWrittenBuf, 255, &dwBufLen); lpIocpOverlapped->dwDataLen = dwBufLen * sizeof(TCHAR); lpIocpOverlapped->pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (dwBufLen + 1) * sizeof(TCHAR)); CopyMemory(lpIocpOverlapped->pData, szWrittenBuf, dwBufLen * sizeof(TCHAR)); lpIocpOverlapped->hFile = *(HANDLE*)lpParam; //同步文件指针 *((LONGLONG*)&(lpIocpOverlapped->Overlapped.Pointer)) = InterlockedCompareExchange64(&g_FilePointer.QuadPart, g_FilePointer.QuadPart + lpIocpOverlapped->dwDataLen, g_FilePointer.QuadPart); //写文件 WriteFile(lpIocpOverlapped->hFile, lpIocpOverlapped->pData, lpIocpOverlapped->dwDataLen, &lpIocpOverlapped->dwWrittenLen, &lpIocpOverlapped->Overlapped); } } VOID CALLBACK IoCompletionCallback(PTP_CALLBACK_INSTANCE Instance,PVOID Context,PVOID Overlapped,ULONG IoResult,ULONG_PTR NumberOfBytesTransferred,PTP_IO Io) { LPIOCP_OVERLAPPED pIOCPOverlapped = (LPIOCP_OVERLAPPED)Overlapped; //释放对应的内存空间 printf("线程[%04x]得到IO完成通知,写入长度%d\n", GetCurrentThreadId(), pIOCPOverlapped->dwDataLen); if (pIOCPOverlapped->pData != NULL) { HeapFree(GetProcessHeap(), 0, pIOCPOverlapped->pData); } if (NULL != pIOCPOverlapped) { HeapFree(GetProcessHeap(), 0, pIOCPOverlapped); pIOCPOverlapped = NULL; } }在新版的完成端口的线程池中，每当需要进行IO操作时，要保证在IO操作之前调用StartThreadpoolIo提交请求。如果没有那么我们的回调函数将不会被执行。注意：后面两种线程池与旧版的相比，最大的区别在于新版的是一次性的，也就是每提交一次，它只会执行一次，要想让其不停触发就需要不停的进行提交，而旧版的只需要绑定，一旦相应的事件发生，他就会不停地的执行线程池控制回调函数的终止操作线程池提供了一种便利的方法，用来描述当我们的回调函数返回之后，应该执行的一些操作，通过这种方式，可以通知其他线程，回调函数已经执行完毕。通过调用下面的一些API可以设置对应的同步对象，在线程池外的其他线程等待同步对象就可以知道什么时候回调执行完毕函数终止操作LeaveCriticalWhenCallbackReturns当回调函数返回时，线程池会自动调用LeaveCritical,并在参数中传入指定的CRITICAL_SECTION结构ReleaseMutexWhenCallbackReturns当回调函数返回时，线程池会自动调用ReleaseMutexWhen并在参数中传入指定的HANDLEReleaseSemaphoreWhenCallbackReturns当回调函数返回时，线程会自动调用ReleaseSemphore并在参数中传入指定的HANDLESetEventWhenCallbackReturns当回调函数返回时，线程会自动调用SetEvent,并在参数中传入指定的HANDLEFreeLibraryWhenCallbackReturns当回调函数返回时，线程会自动调用FreeLibrary并在参数中传入指定的HANDLE前4个函数给我们提供了一种方式来通知另外一个线程，回调函数调用完成，而最后一个函数则提供了一种在回调函数调用完成之时，清理动态库的方式，如果回调函数是在dll中实现的，但是在回调函数结束之时，我们希望卸载这个dll，这个时候不能调用FreeLibrary，这个时候回调函数虽然完成了任务，但是在后面还有函数栈平衡的操作，如果在返回时，我们将dll从内存中卸载，必然会导致最后的栈平衡操作访问非法内存，从而时应用程序崩溃。但是我们可以调用FreeLibraryWhenCallbackReturns，完成这个任务。下面是一个具体的例子：typedef struct tagWAIT_STRUCT { HANDLE hEvent; DWORD dwThreadId; }WAIT_STRUCT, *LPWAIT_STRUCT; WAIT_STRUCT g_waitStruct = {0}; VOID CALLBACK WorkCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_WORK Work) { g_waitStruct.dwThreadId = GetCurrentThreadId(); Sleep(1000 * 10); SetEventWhenCallbackReturns(Instance, *(HANDLE*)&g_waitStruct); } int _tmain(int argc, _TCHAR* argv[]) { PTP_WORK pWork = CreateThreadpoolWork(WorkCallback, NULL, NULL); g_waitStruct.hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); SubmitThreadpoolWork(pWork); WaitForSingleObject(g_waitStruct.hEvent, INFINITE); printf("线程池中线程[%04x]执行完成\n", g_waitStruct.dwThreadId); CloseThreadpoolWork(pWork); return 0; }上面的代码首先创建一个无信号的event对象，然后在回调函数中调用SetEventWhenCallbackReturns，当回调函数完成之时就会将event设置为有信号，这样我们在主线程中就可以等待，一旦回调函数执行完成，event变为有信号，wait函数就会返回。同时我们定义一个结构体尝试着从线程池中带出一个线程ID，并在主线程中使用它对线程池进行定制上面在讨论四种线程池的时候，使用的都是系统自带的线程池，这些线程池由系统管理，我们只能使用，而不能对它们的一些属性进行定制，但是新版本的线程池中提供了这样的方式，要对线程池进行定制，不能使用系统已经定义好的线程池，得自己定义，定义线程池使用API函数CreateThreadPool,这个函数只有一个参数，这个参数是Windows的保留参数目前应该赋值为NULL。该函数会返回一个PTP_POOL 类型的值，这个值是一个指针，用来标识一个线程池。创建完成之后，我们可以函数SetThreadpoolThreadMaximum 或者SetThreadpoolThreadMinimum来规定线程池中的最大和最小线程。当不需要自定义的线程池的时候可以使用函数CloseThreadPool，来清理自定义线程池。线程池的回调环境线程池的回调环境规定了回调函数的执行环境，比如由哪个线程池中的线程来调用，对应线程池的版本，对应的清理器和其他的属性等等。环境的结构定义如下：typedef struct _TP_CALLBACK_ENVIRON { TP_VERSION Version; //线程池的版本 PTP_POOL Pool; //关联的线程池 PTP_CLEANUP_GROUP CleanupGroup; //对应的环境清理组 PTP_CLEANUP_GROUP_CANCEL_CALLBACK CleanupGroupCancelCallback; PVOID RaceDll; struct _ACTIVATION_CONTEXT *ActivationContext; PTP_SIMPLE_CALLBACK FinalizationCallback; union { DWORD Flags; struct { DWORD LongFunction : 1; DWORD Private : 31; } s; } u; } TP_CALLBACK_ENVIRON, *PTP_CALLBACK_ENVIRON;虽然这个结构微软对外公布，而且是可以在程序中直接使用的，但是最好不要这么做，我们应该使用它提供的API对其进行操作，首先可以调用InitializeThreadpoolEnvironment来创建一个对应的回调环境，对我们传入的TP_CALLBACK_ENVIRON变量进行初始化。然后可以调用函数SetThreadpoolCallbackPool来规定由哪个线程池来调用对应的回调函数，如果将参数ptpp传入NULL,则使用系统默认的线程池。另外还可以调用SetThreadpoolCallbackRunsLong 来告诉线程池，我们的任务需要较长的时间来执行。最后当我们不需要这个回调环境的时候可以使用函数DestroyThreadpoolEnvironment来清理这个结构。我自己在看这一块的时候很长时间都转不过弯来，总觉得回调环境是由线程池持有的，每个线程池都有自己的回调环境，其实这个是错误的，既然它叫做回调环境，自然与线程池无关，它是用来控制回调行为的。当我们在创建对应的任务时，最后一个参数就是回调环境的指针，在提交任务时会首先将任务提交到回调环境所规定的线程池中，由对应的线程池来处理。函数SetThreadpoolCallbackPool从表面意思来看是未线程池设置一个回调环境其实这个意思正好相反，是为某个回调指定对应调用的线程池。在后面就可以看到，回调环境可比线程池大的多线程池的清理组为了得体的销毁自定义的线程池（系统自定义线程池不会被销毁），我们需要知道系线程池中各个任务何时完成，只有当所有任务都完成时销毁线程池才算得体的销毁，只有这样才能顺利的清理相关资源。但是由于线程池中的各项任务可能由不同的线程提交，提交的时机，任务执行完所需要的时间各不相同，所以基本上不可能知道线程池中的任务何时完成。为了解决这个问题，新版的线程池提供了清理组的概念。TP_CALLBACK_ENVIRON结构的PTP_CLEANUP_GROUP就为对应的执行环境绑定了一个清理组。当线程池中的任务都处理完成时能够得体的清理线程池可以调用CreateThreadpoolCleanupGroup来创建一个清理组，然后调用SetThreadpoolCallbackCleanupGroup来将线程池与对应的清理组。它的原型如下：VOID SetThreadpoolCallbackCleanupGroup( __inout PTP_CALLBACK_ENVIRON pcbe, __in PTP_CLEANUP_GROUP ptpcg, __in_opt PTP_CLEANUP_GROUP_CANCEL_CALLBACK pfng );第一个参数是一个回调环境第二个参数是一个对应的清理组，这两个参数就将对应的回调环境和清理组关联起来第三个参数是一个回调函数，每当一个工作项被取消，这个函数将会被调用。对应的回调函数的原型如下:VOID NTAPI CleanupGroupCancelCallback(PVOID pvObjectContext, PVOID CleanupContext);每当创建一个任务时，如果最后一个参数不为NULL，那么对应的清理组中会增加一项，表示又增加一个需要潜在清理的任务。最后我们调用对应的清理工作项的函数时，相当于显示的将需要清理的项从对应的清理组中去除。当我们的应用程序想要销毁线程池时，调用函数CloseThreadpoolCleanupGroupMembers。这个函数相比于之前的WaitForThreadpoolTimerCallbacks来说，它可以等待线程池中的所有工作项，而不管工作项是哪种类型，而对应的wait函数只能等待对应类型的工作项。VOID WINAPI CloseThreadpoolCleanupGroupMembers( __inout PTP_CLEANUP_GROUP ptpcg, __in BOOL fCancelPendingCallbacks, __inout_opt PVOID pvCleanupContext );CloseThreadpoolCleanupGroupMembers函数的第二个参数也是一个BOOL类型，它的作用与对应的wait函数中第二个参数的作用相同。如果第二个参数设置为NULL，那么每当该函数取消一个工作项，对应的PTP_CLEANUP_GROUP_CANCEL_CALLBACK 类型的回调就要被调用一次CleanupGroupCancelCallback函数中第一个参数是被取消项的上下文，这个上下文是由对应的创建工作项的函数的pvContext参数传递进来的，而第二个参数是由CloseThreadpoolCleanupGroupMembers函数的第三个参数传递进来的。当所有的工作项被取消后调用CloseThreadpoolCleanupGroup来释放清理组所占的资源。最后调用DestroyThreadpoolEnviroment和CloseThreadPool这样就可以得体的关闭线程池下面是使用的一个例子:VOID NTAPI CleanupGroupCancelCallback(PVOID pvObjectContext, PVOID CleanupContext) { printf("有任务[%d][%d]被取消\n", *(int*)pvObjectContext, *(int*)CleanupContext); } VOID CALLBACK TimerCallback(PTP_CALLBACK_INSTANCE Instance, PVOID Context, PTP_TIMER Timer) { Sleep(1000); printf("有对应的定时器历程被调用\n"); } int _tmain(int argc, _TCHAR* argv[]) { TP_CALLBACK_ENVIRON environ = {0}; //创建回调环境 InitializeThreadpoolEnvironment(&environ); PTP_CLEANUP_GROUP pCleanUp = CreateThreadpoolCleanupGroup(); //创建清理组 PTP_POOL pool = CreateThreadpool(NULL); //创建自定义线程池 //设置线程池中的最大、最小线程数 SetThreadpoolThreadMinimum(pool, 2); SetThreadpoolThreadMaximum(pool, 8); //设置对应的回调环境和清理组 SetThreadpoolCallbackPool(&environ, pool); SetThreadpoolCallbackCleanupGroup(&environ, pCleanUp, CleanupGroupCancelCallback); //创建对应的工作项 int i = 1; PTP_TIMER pTimerWork = CreateThreadpoolTimer(TimerCallback, &i, &environ); ULARGE_INTEGER uDueTime = {0}; FILETIME ft = {0}; uDueTime.QuadPart = (LONGLONG) - 10 * 1000 *1000; //设置时间为10s ft.dwHighDateTime = uDueTime.HighPart; ft.dwLowDateTime = uDueTime.LowPart; SetThreadpoolTimer(pTimerWork, &ft, 10 * 1000, 0); //休眠1s保证定时器历程被提交 Sleep(1000); int j = 2; //等待所有历程执行完成，并清理资源 CloseThreadpoolCleanupGroupMembers(pCleanUp, TRUE, &j); CloseThreadpoolCleanupGroup(pCleanUp); DestroyThreadpoolEnvironment(&environ); CloseThreadpool(pool); return 0; }上面的例子中，首先定义了一个回调环境并进行初始化，然后定义自定义线程和对应的清理环境，并将他们绑定。并且在定义清理器时指定对应的回调函数。接着又定义了一个定时器线程并给一个上下文。然后提交这个定时器历程。为了保证能顺利提交，在主程序中等待1s。最后我们直接取消它，由于定时器触发的时间为10s这个时候肯定还没有执行，而根据之前说的，当我们取消一个已提交但是未执行的工作项时会调用对应的清理组规定的回调，这个时候CleanupGroupCancelCallback会被调用。它的参数的值分别由CreateThreadpoolTimer和CloseThreadpoolCleanupGroupMembers给出，所以最终输出结果如下：自定义线程池可以很方便的控制它的行为。但是为了要得体的清理它所以得加上一个清理组，最终当我们使用自定义线程池时，基本步骤如下：调用函数InitializeThreadpoolEnvironment初始化一个回调环境调用CreateThreadpoolCleanupGroup创建一个清理组，并根据需要给出对应的清理回调调用CreateThreadpool创建自定义线程池调用对应的函数，设置自定义线程池的相关属性调用函数SetThreadpoolCallbackPool将线程池与回调环境绑定调用函数SetThreadpoolCallbackCleanupGroup将回调环境与对应的清理组绑定调用对应的函数创建工作项，并提交调用函数CloseThreadpoolCleanupGroupMembers等待清理组中的所有工作项被执行完或者被取消调用CloseThreadpoolCleanupGroup关闭清理组并释放资源调用DestroyThreadpoolEnvironment清理回调环境调用CloseThreadpool函数关闭自定义的线程池使用清理组的方式清理工作项相比于调用对应的close函数清理工作项来说，显得更方便，一来自定义线程池中工作项的种类繁多，每个工作项都调用一个Close函数显得太复杂，而且当工作项过多时，不知道何时哪个工作项执行完，这个时候如果强行调用函数关闭工作项，显得有点暴力，所以用工作组的方式更为优雅一些

老版VC++线程池 在一般的设计中，当需要一个线程时，就创建一个，但是当线程过多时可能会影响系统的整体效率，这个性能的下降主要体现在：当线程过多时在线程间来回切换需要花费时间，而频繁的创建和销毁线程也需要花费额外的机器指令，同时在某些时候极少数线程可能就可以处理大量，比如http服务器可能只需要几个线程就可以处理用户发出的http请求，毕竟相对于用户需要长时间来阅读网页来说，CPU只是找到对应位置的页面返回即可。在这种情况下为每个用户连接创建一个线程长时间等待再次处理用户请求肯定是不划算的。为了解决这种问题，提出了线程池的概念，线程池中保存一定数量的 线程，当需要时，由线程池中的某一个线程来调用对应的处理函数。通过控制线程数量从而减少了CPU的线程切换，而且用完的线程还到线程池而不是销毁，下一次再用时直接从池中取，在某种程度上减少了线程创建与销毁的消耗，从而提高效率在Windows上，使用线程池十分简单，它将线程池做为一个整体，当需要使用池中的线程时，只需要定义对应的回调函数，然后调用API将回调函数进行提交，系统自带的线程池就会自动执行对应的回调函数。从而实现任务的执行，这种方式相对于传统的VC线程来说，程序员不再需要关注线程的创建与销毁，以及线程的调度问题，这些统一由系统完成，只需要将精力集中到逻辑处理的回调函数中来，这样将程序员从繁杂的线程控制中解放出来。同时Windows中线程池一般具有动态调整线程数量的自主行为，它会根据线程中执行任务的工作量来自动调整线程数，即不让大量线程处于闲置状态，也不会因为线程过少而有大量任务处于等待状态。在windows上主要有四种线程池普通线程池同步对象等待线程池定时器回调线程池完成端口回调线程池这些线程池最大的特点是需要提供一个由线程池中线程调用的回调函数，当条件满足时回调函数就会被线程池中的对应线程进行调用。从设计的角度来说,这样的设计大大简化了应用程序考虑多线程设计时的难度,此时只需要考虑回调函数中的处理逻辑和被调用的条件即可,而不必考虑线程的创建销毁等等问题(一些设计还可以绕开繁琐的同步处理)。需要注意的就是一般不要在这些回调函数中设计处理类似UI消息循环那样的循环,即不要长久占用线程池中的线程。下面来依次说明各种线程池的使用：普通线程池普通线程池在使用时主要是调用QueueUserWorkItem函数将回调函数加入线程池队列，线程池中一旦有空闲的线程就会调用这个回调，函数原型如下：BOOL WINAPI QueueUserWorkItem( __in LPTHREAD_START_ROUTINE Function, __in_opt PVOID Context, __in ULONG Flags );第一个参数是一个回调函数地址，函数原型与线程函数原型相同，所以在设计时可以考虑使用宏开关来指定这个回调函数作为线程函数还是作为线程池的回调函数第二个参数是传给回调函数的参数指针第三个参数是一个标志值，它的主要值及其含义如下：标志含义WT_EXECUTEDEFAULT线程池的默认标志WT_EXECUTEINIOTHREAD以IO可警告状态运行线程回调函数WT_EXECUTEINPERSISTENTTHREAD该线程将一直运行而不会终止WT_EXECUTELONGFUNCTION执行一个运行时间较长的任务(这会使系统考虑是否在线程池中创建新的线程)WT_TRANSFER_IMPERSONATION以当前的访问字串运行线程并调用回调函数下面是一个具体的例子:void CALLBACK ThreadProc(LPVOID lpParam); int _tmain(int argc, _TCHAR* argv[]) { int nWaitTime; while (TRUE) { printf("请输入线程等待事件:"); scanf_s("%d", &nWaitTime); printf("\n"); if (0 == nWaitTime) { break; } //将任务放入到队列中进行排队 QueueUserWorkItem((LPTHREAD_START_ROUTINE)ThreadProc, &nWaitTime, WT_EXECUTELONGFUNCTION); } //结束主线程 printf("主线程[%04x]\n", GetCurrentThreadId()); return 0; } void CALLBACK ThreadProc(LPVOID lpParam) { int nWaitTime = *(int*)lpParam; printf("线程[%04x]将等待%ds\n", GetCurrentThreadId(), nWaitTime); Sleep(nWaitTime * 1000); printf("线程[%04x]执行完毕\n", GetCurrentThreadId()); }这段代码上我们加入了WT_EXECUTELONGFUNCTION标识，其实在计算机中，只要达到毫秒级的，这个时候已经达到了系统进行线程切换的时间粒度，这个时候它就是一个需要长时间执行的任务定时器回调线程池定时器回调主要经过下面几步：调用CreateTimerQueue:创建定时器回调的队列调用CreateTimerQueueTimer创建一个指定时间周期的计时器对象，并指定对应的回调函数及参数之后当指定的时间片到达，就会将对应的回调历程放入到队列中，一旦线程池中有空闲的线程就执行它另外可以调用对应的函数对其进行相关的操作：可以调用ChangeTimerQueueTimer修改一个已有的计时器对象的计时周期调用DeleteTimerQueueTimer删除一个计时器对象调用DeleteTimerQueue删除这样一个线程池对象，在删除这个线程池的时候它上面绑定的回调也会被删除，所以在编码时可以直接删除线程池对象而不用调用DeleteTimerQueueTimer删除每一个绑定的计时器对象。但是为了编码的完整性，最好加上删除计时器对象的操作下面是一个使用的具体例子VOID CALLBACK TimerCallback(PVOID lpParameter, BOOLEAN TimerOrWaitFired); int _tmain(int argc, _TCHAR* argv[]) { HANDLE hTimeQueue = CreateTimerQueue(); HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); HANDLE hTimer; CreateTimerQueueTimer(&hTimer, hTimeQueue, (WAITORTIMERCALLBACK)TimerCallback, &hEvent, 10000, 0, WT_EXECUTEDEFAULT); //等待定时器历程被调用 WaitForSingleObject(hEvent, INFINITE); //关闭事件对象 CloseHandle(hEvent); //删除定时器与定时器线程池的绑定 DeleteTimerQueueTimer(hTimeQueue, hTimer, NULL); //删除定时器线程池 DeleteTimerQueue(hTimeQueue); return 0; } VOID CALLBACK TimerCallback(PVOID lpParameter, BOOLEAN TimerOrWaitFired) { HANDLE hEvent = *(HANDLE*)lpParameter; if (TimerOrWaitFired) { printf("定时器回调历程[%04x]被执行\n", GetCurrentThreadId()); } SetEvent(hEvent); }上述的代码中我们定义了一个同步事件对象，这个事件对象将在定时器历程中设置为有信号，这样方便我们在主线程中等待计时器历程执行完成同步对象等待线程池使用同步对象等待线程池只需要调用函数RegisterWaitForSingalObject，将一个同步对象绑定，当这个同步对象变为有信号或者等待的时间到达时，会调用对应的回调历程。该函数原型如下：BOOL WINAPI RegisterWaitForSingleObject( __out PHANDLE phNewWaitObject, __in HANDLE hObject, __in WAITORTIMERCALLBACK Callback, __in_opt PVOID Context, __in ULONG dwMilliseconds, __in ULONG dwFlags ); 第一个参数是一个输出参数，返回一个等待对象的句柄，我们可以将其看做这个线程池的句柄第二个参数是一个同步对象第三个参数是对应的回调函数第四个参数是传入到回调函数中的参数指针第五个参数是等待的时间第六个参数是一个标志与函数QueueUserWorkItem中的标识含义相同对应回调函数的原型如下：VOID CALLBACK WaitOrTimerCallback( __in PVOID lpParameter, __in BOOLEAN TimerOrWaitFired );当同步对象变为有信号或者等待的时间到达时都会调用这个回调，它的第二个参数就表示它所等待的对象是否为有信号。下面是一个使用的例子void WaitEventCallBackProc(PVOID lpParameter, BOOLEAN TimerOrWaitFired); int _tmain(int argc, _TCHAR* argv[]) { HANDLE hWait; HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); //注册等待同步对象的线程池 RegisterWaitForSingleObject(&hWait, hEvent, (WAITORTIMERCALLBACK)WaitEventCallBackProc, NULL, 5000, WT_EXECUTELONGFUNCTION); for(int i = 0; i < 5; i++) { SetEvent(hEvent); Sleep(5000); } UnregisterWaitEx(hWait, hEvent); CloseHandle(hEvent); CloseHandle(hWait); return 0; } void WaitEventCallBackProc(PVOID lpParameter, BOOLEAN TimerOrWaitFired) { if (TimerOrWaitFired) { printf("线程[%04x]等到事件对象\n"); }else { printf("线程[%04x]等待事件对象超时\n"); } }完成端口线程池在前面讲述文件操作的博文中，讲解了在文件中完成端口的使用，其实完成端口本质上就是一个线程池，或者说，windows上自带的线程池是使用完成端口的基础之上编写的。所以在这，完成端口线程池的使用将比IO完成端口来的简单通过调用BindIoCompletionCallback函数来将一个IO对象句柄与对应的完成历程绑定，这样在对应的IO操作完成后，对应的历程将会被丢到线程池中准备执行相比于前面的文件中的完成端口，这个完成端口线程池要简单许多，文件的完成端口需要自己创建完成多个线程，创建完成端口，并且将线程与完成端口绑定。另外还需要在线程中调用相应的等待函数等待IO操作完成，而线程池则不需要这些操作，我只需要准备一个完成历程，然后调用BindIoCompletionCallback，这样一旦历程被调用，就可以肯定IO操作一定完成了。这样我们只需要将主要精力集中在完成历程的编写中函数BindIoCompletionCallback的原型如下：BOOL WINAPI BindIoCompletionCallback( __in HANDLE FileHandle, __in LPOVERLAPPED_COMPLETION_ROUTINE Function, __in ULONG Flags );第一个参数是一个对应IO操作的句柄第二个参数是对应的完成历程函数指针第三个参数是一个标志，与之前的标识相同完成历程的函数原型如下：VOID CALLBACK FileIOCompletionRoutine( __in DWORD dwErrorCode, __in DWORD dwNumberOfBytesTransfered, __in LPOVERLAPPED lpOverlapped );第一个参数是一个错误码，当IO操作发生错误时可以通过这个参数获取当前错误原因第二个参数是当前IO操作操作的字节数第三个参数是一个OVERLAPPED结构这函数的使用与之前文件完成端口中完成历程一样下面我们将之前文件完成端口的例子进行改写，如下：typedef struct tagIOCP_OVERLAPPED { OVERLAPPED Overlapped; HANDLE hFile; //操作的文件句柄 DWORD dwDataLen; //当前操作数据的长度 LPVOID pData; //操作数据的指针 DWORD dwWrittenLen; //写入文件中的数据长度 }IOCP_OVERLAPPED, *LPIOCP_OVERLAPPED; #define MAX_WRITE_THREAD 20 //写线程总数 #define EVERY_THREAD_WRITTEN 100 //每个线程写入信息数 LARGE_INTEGER g_FilePointer; //全局的文件指针 void GetAppPath(LPTSTR lpAppPath) { TCHAR szExePath[MAX_PATH] = _T(""); GetModuleFileName(NULL, szExePath, MAX_PATH); size_t nPathLen = 0; StringCchLength(szExePath, MAX_PATH, &nPathLen); for (int i = nPathLen; i > 0; i--) { if (szExePath[i] == _T('\\')) { szExePath[i + 1] = _T('\0'); break; } } StringCchCopy(lpAppPath, MAX_PATH, szExePath); } VOID CALLBACK WriteThread(LPVOID lpParam); VOID CALLBACK FileIOCompletionRoutine(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped); int _tmain(int argc, _TCHAR* argv[]) { TCHAR szAppPath[MAX_PATH] = _T(""); GetAppPath(szAppPath); StringCchCat(szAppPath, MAX_PATH, _T("IocpLog.txt")); HANDLE hFile = CreateFile(szAppPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_FLAG_OVERLAPPED | FILE_ATTRIBUTE_NORMAL, NULL); if (hFile == INVALID_HANDLE_VALUE) { return 0; } //绑定IO完成端口 BindIoCompletionCallback(hFile, (LPOVERLAPPED_COMPLETION_ROUTINE)FileIOCompletionRoutine, 0); //往日志文件中写入Unicode前缀 LPIOCP_OVERLAPPED pIocpOverlapped = (LPIOCP_OVERLAPPED)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IOCP_OVERLAPPED)); pIocpOverlapped->dwDataLen = sizeof(WORD); pIocpOverlapped->hFile = hFile; WORD dwUnicode = MAKEWORD(0xff, 0xfe); //构造Unicode前缀 pIocpOverlapped->pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WORD)); CopyMemory(pIocpOverlapped->pData, &dwUnicode, sizeof(WORD)); //偏移文件指针 pIocpOverlapped->Overlapped.Offset = g_FilePointer.LowPart; pIocpOverlapped->Overlapped.OffsetHigh = g_FilePointer.HighPart; g_FilePointer.QuadPart += pIocpOverlapped->dwDataLen; //写文件 WriteFile(hFile, pIocpOverlapped->pData, pIocpOverlapped->dwDataLen, &pIocpOverlapped->dwWrittenLen, &pIocpOverlapped->Overlapped); //创建线程进行写日志操作 HANDLE hWrittenThreads[MAX_WRITE_THREAD]; for (int i = 0; i < MAX_WRITE_THREAD; i++) { hWrittenThreads[i] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)WriteThread, &hFile, 0, NULL); } //等待所有写线程执行完成 WaitForMultipleObjects(MAX_WRITE_THREAD, hWrittenThreads, TRUE, INFINITE); for (int i = 0; i < MAX_WRITE_THREAD; i++) { CloseHandle(hWrittenThreads[i]); } CloseHandle(hFile); return 0; } VOID CALLBACK FileIOCompletionRoutine(DWORD dwErrorCode, DWORD dwNumberOfBytesTransfered, LPOVERLAPPED lpOverlapped) { LPIOCP_OVERLAPPED pIOCPOverlapped = (LPIOCP_OVERLAPPED)lpOverlapped; //释放对应的内存空间 printf("线程[%04x]得到IO完成通知,写入长度%d\n", GetCurrentThreadId(), pIOCPOverlapped->dwDataLen); if (pIOCPOverlapped->pData != NULL) { HeapFree(GetProcessHeap(), 0, pIOCPOverlapped->pData); } if (NULL != pIOCPOverlapped) { HeapFree(GetProcessHeap(), 0, pIOCPOverlapped); pIOCPOverlapped = NULL; } } VOID CALLBACK WriteThread(LPVOID lpParam) { TCHAR szBuf[255] = _T("线程[%04x]模拟写入一条日志记录\r\n"); TCHAR szWrittenBuf[255] = _T(""); StringCchPrintf(szWrittenBuf, 255, szBuf, GetCurrentThreadId()); for (int i = 0; i < EVERY_THREAD_WRITTEN; i++) { LPIOCP_OVERLAPPED lpIocpOverlapped = (LPIOCP_OVERLAPPED)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IOCP_OVERLAPPED)); size_t dwBufLen = 0; StringCchLength(szWrittenBuf, 255, &dwBufLen); lpIocpOverlapped->dwDataLen = dwBufLen * sizeof(TCHAR); lpIocpOverlapped->pData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (dwBufLen + 1) * sizeof(TCHAR)); CopyMemory(lpIocpOverlapped->pData, szWrittenBuf, dwBufLen * sizeof(TCHAR)); lpIocpOverlapped->hFile = *(HANDLE*)lpParam; //同步文件指针 *((LONGLONG*)&(lpIocpOverlapped->Overlapped.Pointer)) = InterlockedCompareExchange64(&g_FilePointer.QuadPart, g_FilePointer.QuadPart + lpIocpOverlapped->dwDataLen, g_FilePointer.QuadPart); //写文件 WriteFile(lpIocpOverlapped->hFile, lpIocpOverlapped->pData, lpIocpOverlapped->dwDataLen, &lpIocpOverlapped->dwWrittenLen, &lpIocpOverlapped->Overlapped); } }

windows 纤程 纤程本质上也是线程，是多任务系统的一部分，纤程为一个线程准并行方式调用多个不同函数提供了一种可能，它本身可以作为一种轻量级的线程使用。它与线程在本质上没有区别，它也有上下文环境，纤程的上下文环境也是一组寄存器和调用堆栈。它是比线程更小的调度单位。注意一般我们认为线程是操作系统调用的最小单位，而纤程相比于线程来说更小，但是它是有程序员自己调用，而不由操作系统调用。系统在调度线程的时候会陷入到内核态，线程对象本身也是一种内核对象，而纤程完全是建立在用户层上，它不是内核对象也没有对象的句柄。通过纤程的机制实际就绕开了Windows的随机调度线程执行的行为,调度算法由应用程序自己实现，这对一些并行算法非常有意义。因为纤程和线程本质上的类同性,所以也要按照理解线程为函数调用器的方式来理解纤程。纤程的创建纤程的创建需要必须建立在线程的基础之上。在线程中调用函数ConvertThreadToFiber可以将一个线程转化为纤程（或者说将一个线程与纤程绑定，以后可以将该纤程看做主纤程）。其他的纤程函数必须在纤程中调用，也就是说，如果目前在线程中，需要调用ConverThreadToFiber将线程转化为纤程，才能调用对应的API。这个函数的原型如下：LPVOID WINAPI ConvertThreadToFiber( LPVOID lpParameter ); 这个函数传入一个参数，类似于CreateThread函数中的线程函数参数，如果我们在主纤程中需要使用到它，可以使用宏GetFiberData取得这个参数。在调用这个函数创建新纤程后，系统大概会给纤程分配200字节的栈空间，用来执行纤程函数，和保存纤程环境。这个环境由下面几个部分的内容组成：用户定义的值，这个值就是纤程回调函数中传入的参数新的结构化异常处理的链表头纤程内存栈的最高和最低地址，当线程转换为纤程的时候，这也是线程的内存栈。之前说过纤程栈是在建立在线程的基础之上，保留这两个值是为了当纤程还原为线程后，用来还原线程栈环境各种CPU寄存器环境，相当于线程的CONTENT，但是没有这个结构那么复杂，它只是保存了几个简单的寄存器的值。需要特别注意的一点是，它并没有保存对应浮点数寄存器FPU的值，所以在纤程中使用浮点数计算可能会出现未知错误。如果一定要计算浮点数，那么可以使用ConverThreadToFiberEx,在第二个参数的位置传入FIBER_FLAG_FLOAT_SWITCH值，表示将初始化并保存FPU。可以在主纤程中调用CreateFiber函数创建子纤程。该函数原型如下：LPVOID WINAPI CreateFiber( DWORD dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter );第一个参数是纤程的堆栈大小，默认给0的话，它会根据实际需求创建对应大小的堆栈，纤程的堆栈是建立在线程的基础之上，我们可以这样理解，它是从线程的堆栈中隔离一块作为纤程的堆栈。本质上它的堆栈是放在线程的堆栈上。第二个参数是一个回调，与线程函数类似，这个函数是一个纤程函数。第三个参数是传递到回调函数中的参数。函数CreateFiber 和 ConvertThreadToFiber 函数都返回一个void* 的指针，用来唯一标识一个纤程，在这我们可以将它理解为纤程的HANDLE .纤程的删除当纤程结束时需要调用DeleteFiber来删除线程，类似于CloseHandle来结束对应的内核对象。如果是调用转化函数由线程转化而来，调用DeleteFiber相当于调用ExitThread来终止线程，所以对于这种情况，最好是将纤程转化为线程，然后再设计一套合理的线程退出机制。纤程的调度在任何一个纤程内部调用SwitchToFiber函数，将纤程的void*指针传入，即可切换到对应的纤程，该函数可以在任意几个纤程中进行切换，不管这些纤程是在一个线程中或者在不同的线程中。但是最好不要在不同线程中的纤程中进行切换，它可能会带来意想不到的情况，假设存在这样一种情况，线程A创建纤程FA，线程B创建纤程FB，当我们在系统运行线程A时将纤程从FA切换到FB，由于纤程的堆栈是建立在线程之上的，所以这个时候纤程B仍然使用线程A的堆栈，但是它应该使用的线程B的堆栈，这样可能会对线程A的堆栈造成一定的破坏。下面是纤使用的一个具体的例子：#define PRIMARY_FIBER 0 #define WRITE_FIBER 1 #define READ_FIBER 2 #define FIBER_COUNT 3 #define COPY_LENGTH 512 VOID CALLBACK ReadFiber(LPVOID lpParam); VOID CALLBACK WriteFiber(LPVOID lpParam); typedef struct _tagFIBER_STRUCT { DWORD dwFiberHandle; HANDLE hFile; LPVOID lpParam; }FIBER_STRUCT, *LPFIBER_STRUCT; char *g_lpBuffer = NULL; LPVOID g_lpFiber[FIBER_COUNT] = {}; void GetApp(LPTSTR lpPath, int nBufLen) { TCHAR szBuf[MAX_PATH] = _T(""); GetModuleFileName(NULL, szBuf, MAX_PATH); int nLen = _tcslen(szBuf); for(int i = nLen; i > 0; i--) { if(szBuf[i] == '\\') { szBuf[i + 1] = _T('\0'); break; } } nLen = _tcslen(szBuf) + 1; int nCopyLen = min(nLen, nBufLen); StringCchCopy(lpPath, nCopyLen, szBuf); } int _tmain(int argc, _TCHAR* argv[]) { g_lpBuffer = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, COPY_LENGTH); FIBER_STRUCT fs[FIBER_COUNT] = {0}; TCHAR szDestPath[MAX_PATH] = _T(""); TCHAR szSrcPath[MAX_PATH] = _T(""); GetApp(szDestPath, MAX_PATH); GetApp(szSrcPath, MAX_PATH); StringCchCat(szSrcPath, MAX_PATH, _T("2.jpg")); StringCchCat(szDestPath, MAX_PATH, _T("2_Cpy.jpg")); HANDLE hSrcFile = CreateFile(szSrcPath, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL); HANDLE hDestFile = CreateFile(szDestPath, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL); fs[PRIMARY_FIBER].hFile = INVALID_HANDLE_VALUE; fs[PRIMARY_FIBER].lpParam = NULL; fs[PRIMARY_FIBER].dwFiberHandle = 0x00001234; fs[WRITE_FIBER].hFile = hDestFile; fs[WRITE_FIBER].lpParam = NULL; fs[WRITE_FIBER].dwFiberHandle = 0x12345678; fs[READ_FIBER].hFile = hSrcFile; fs[READ_FIBER].dwFiberHandle = 0x78563412; fs[READ_FIBER].lpParam = NULL; g_lpFiber[PRIMARY_FIBER] = ConvertThreadToFiber(&fs[PRIMARY_FIBER]); g_lpFiber[READ_FIBER] = CreateFiber(0, (LPFIBER_START_ROUTINE)ReadFiber, &fs[READ_FIBER]); g_lpFiber[WRITE_FIBER] = CreateFiber(0, (LPFIBER_START_ROUTINE)WriteFiber, &fs[WRITE_FIBER]); //切换到读纤程 SwitchToFiber(g_lpFiber[READ_FIBER]); //删除纤程 DeleteFiber(g_lpFiber[WRITE_FIBER]); DeleteFiber(g_lpFiber[READ_FIBER]); CloseHandle(fs[READ_FIBER].hFile); CloseHandle(fs[WRITE_FIBER].hFile); //变回线程 ConvertFiberToThread(); return 0; } VOID CALLBACK ReadFiber(LPVOID lpParam) { //拷贝文件 while (TRUE) { LPFIBER_STRUCT pFS = (LPFIBER_STRUCT)lpParam; printf("切换到[%08x]纤程\n", pFS->dwFiberHandle); DWORD dwReadLen = 0; ZeroMemory(g_lpBuffer, COPY_LENGTH); ReadFile(pFS->hFile, g_lpBuffer, COPY_LENGTH, &dwReadLen, NULL); SwitchToFiber(g_lpFiber[WRITE_FIBER]); if(dwReadLen < COPY_LENGTH) { break; } } SwitchToFiber(g_lpFiber[PRIMARY_FIBER]); } VOID CALLBACK WriteFiber(LPVOID lpParam) { while (TRUE) { LPFIBER_STRUCT pFS = (LPFIBER_STRUCT)lpParam; printf("切换到[%08x]纤程\n", pFS->dwFiberHandle); DWORD dwWriteLen = 0; WriteFile(pFS->hFile, g_lpBuffer, COPY_LENGTH, &dwWriteLen, NULL); SwitchToFiber(g_lpFiber[READ_FIBER]); if(dwWriteLen < COPY_LENGTH) { break; } } SwitchToFiber(g_lpFiber[PRIMARY_FIBER]); } 上面这段代码中首先将主线程转化为主纤程，然后创建两个纤程，分别用来读文件和写文件，然后保存这三个纤程。并定义了一个结构体用来向各个纤程函数传入对应的参数。在主线程的后面首先切换到读纤程，在读纤程中利用源文件的句柄，读入512字节的内容，然后切换到写纤程，将读到的这些内容写回到磁盘的新文件中完成拷贝，然后切换到读纤程，这样不停的在读纤程和写纤程中进行切换，直到文件拷贝完毕。再切换回主纤程，最后在主纤程中删除读写纤程，将主纤程转化为线程并结束线程。

windows 下进程池的操作 在Windows上创建进程是一件很容易的事，但是在管理上就不那么方便了，主要体现在下面几个方面：各个进程的地址空间是独立的，想要在进程间共享资源比较麻烦进程间可能相互依赖，在进程间需要进行同步时比较麻烦在服务器上可能会出现一个进程创建一大堆进程来共同为客户服务，这组进程在逻辑上应该属于同一组进程为了方便的管理同组的进程，Windows上提供了一个进程池来管理这样一组进程，在VC中将这个进程池叫做作业对象。它主要用来限制池中内存的一些属性，比如占用内存数，占用CPU周期，进程间的优先级，同时提供了一个同时关闭池中所有进程的方法。下面来说明它的主要用法作业对象的创建调用函数CreateJobObject，可以来创建作业对象，该函数有两个参数，第一个参数是一个安全属性，第二个参数是一个对象名称。作业对象本身也是一个内核对象，所以它的使用与常规的内核对象相同，比如可以通过命名实现跨进程访问，可以通过对应的Open函数打开命名作业对象。添加进程到作业对象可以通过AssignProcessToJobObject ,该函数只有两个参数，第一个是对应的作业对象，第二个是对应的进程句柄关闭作业对象中的进程可以使用TerminateJobObject 函数来一次关闭作业对象中的所有进程，它相当于对作业对象中的每一个进程调用TerminateProcess，相对来说是一个比较粗暴的方式，在实际中应该劲量避免使用，应该自己设计一种更好的退出方式控制作业对象中进程的相关属性可以使用SetInformationJobObject函数设置作业对象中进程的相关属性，函数原型如下：BOOL WINAPI SetInformationJobObject( __in HANDLE hJob, __in JOBOBJECTINFOCLASS JobObjectInfoClass, __in LPVOID lpJobObjectInfo, __in DWORD cbJobObjectInfoLength );第一个参数是一个作业对象的句柄，第二个是一系列的枚举值，用来限制其中进程的各种信息。第三个参数根据第二参数的不同，需要传入对应的结构体，第四个参数是对应结构体的长度。下面是各个枚举值以及它对应的结构体枚举值含义对应的结构体JobObjectAssociateCompletionPortInformation设置各种作业对象事件的完成端口JOBOBJECT_ASSOCIATE_COMPLETION_PORTJobObjectBasicLimitInformation设置作业对象的基本信息(如:进程作业集大小,进程亲缘性,进程CPU时间限制值,同时活动的进程数量等)JOBOBJECT_BASIC_LIMIT_INFORMATIONJobObjectBasicUIRestrictions对作业中的进程UI进行基本限制(如:指定桌面,限制调用ExitWindows函数,限制剪切板读写操作等)一般在服务程序上这个很少使用JOBOBJECT_BASIC_UI_RESTRICTIONSJobObjectEndOfJobTimeInformation指定当作业时间限制到达时,系统采取什么动作(如:通知与作业对象绑定的完成端口一个超时事件等)JOBOBJECT_END_OF_JOB_TIME_INFORMATIONJobObjectExtendedLimitInformation作业进程的扩展限制信息(限制进程的内存使用量等)JOBOBJECT_EXTENDED_LIMIT_INFORMATIONJobObjectSecurityLimitInformation限制作业对象进程中的安全属性(如:关闭一些组的特权,关闭某些特权等)要求作业对象所属进程或线程要具备更改这些作业进程安全属性的权限JOBOBJECT_SECURITY_LIMIT_INFORMATION限制进程异常退出的行为在Windows中，如果进程发生异常，那么它会寻找处理该异常的对应的异常处理模块，如果没有找到的话，它会弹出一个对话框，让用户选择，但是这样对服务程序来说很不友好，而且有的服务器是在远程没办法操作这个对话框，这个时候需要使用某种方法让其不弹出这个对话框。在作业对象中的进程，我们可以使用SetInformationJobObject函数中的JobObjectExtendedLimitInformation枚举值，将结构体JOBOBJECT_EXTENDED_LIMIT_INFORMATION中的BasicLimitInformation.LimitFlags成员设置为JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION。这相当于强制每个进程调用SetErrorMode并指定SEM_NOGPFAULTERRORBOX标志获取作业对象属性和统计信息调用QueryInformationJobObject函数来获取作业对象属性和统计信息。该函数的使用方法与之前的SetInformationJobObject函数相同。下面列举下它可选择枚举值:枚举值含义对应的结构体JobObjectBasicAccountingInformation基本统计信息JOBOBJECT_BASIC_ACCOUNTING_INFORMATIONJobObjectBasicAndIoAccountingInformation基本统计信息和IO统计信息JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATIONJobObjectBasicLimitInformation基本的限制信息JOBOBJECT_BASIC_LIMIT_INFORMATIONJobObjectBasicProcessIdList获取作业进程ID列表JOBOBJECT_BASIC_PROCESS_ID_LISTJobObjectBasicUIRestrictions查询进程UI的限制信息JOBOBJECT_BASIC_UI_RESTRICTIONSJobObjectExtendedLimitInformation查询作业进程的扩展限制信息JOBOBJECT_EXTENDED_LIMIT_INFORMATIONJobObjectSecurityLimitInformation查询作业对象进程中的安全属性JOBOBJECT_SECURITY_LIMIT_INFORMATION这些信息基本上与上面的设置限制信息是对应的。使用上也是类似的作业对象与完成端口设置作业对象的完成端口一般是使用SetInformationJobObject,并将第二个参数的枚举值指定为JobObjectAssociateCompletionPortInformation，这样就可以完成一个作业对象和完成端口的绑定。当作业对象发生某些事件的时候可以向完成端口发送对应的事件，这个时候在完成端口的线程中调用GetQueuedCompletionStatus可以获取对应的事件，但是这个函数的使用与之前在文件操作中的使用略有不同，主要体现在它的各个返回参数的含义上。各个参数函数如下：lpNumberOfBytes：返回一个事件的ID，它的事件如下：事件事件含义JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS进程异常退出JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT同时活动的进程数达到设置的上限JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO作业对象中没有活动的进程了JOB_OBJECT_MSG_END_OF_JOB_TIME作业对象的CPU周期耗尽JOB_OBJECT_MSG_END_OF_PROCESS_TIME进程的CPU周期耗尽JOB_OBJECT_MSG_EXIT_PROCESS进程正常退出JOB_OBJECT_MSG_JOB_MEMORY_LIMIT作业对象消耗内存达到上限JOB_OBJECT_MSG_NEW_PROCESS有新进程加入到作业对象中JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT进程消耗内存数达到上限lpCompletionKey： 返回触发这个事件的对象的句柄，我们将完成端口与作业对象绑定后，这个值自然是对应作业对象的句柄lpOverlapped: 指定各个事件对应的详细信息，在于进程相关的事件中，它返回一个进程ID既然知道了各个参数的含义，我们可以使用PostQueuedCompletionStatus函数在对应的位置填充相关的值，然后往完成端口上发送自定义事件。只需要将lpNumberOfBytes设置为我们自己的事件ID，然后在线程中处理即可下面是作业对象操作的完整例子#include "stdafx.h" #include <Windows.h> DWORD IOCPThread(PVOID lpParam); //完成端口线程 int GetAppPath(LPTSTR pAppName, size_t nBufferSize) { TCHAR szAppName[MAX_PATH] = _T(""); DWORD dwLen = ::GetModuleFileName(NULL, szAppName, MAX_PATH); if(dwLen == 0) { return 0; } for(int i = dwLen; i > 0; i--) { if(szAppName[i] == _T('\\')) { szAppName[i + 1] = _T('\0'); break; } } _tcscpy_s(pAppName, nBufferSize, szAppName); return 0; } int _tmain(int argc, _TCHAR* argv[]) { //获取当前进程的路径 TCHAR szModulePath[MAX_PATH] = _T(""); GetAppPath(szModulePath, MAX_PATH); //创建作业对象 HANDLE hJob = CreateJobObject(NULL, NULL); if(hJob == INVALID_HANDLE_VALUE) { return 0; } //创建完成端口 HANDLE hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 1); if(hIocp == INVALID_HANDLE_VALUE) { return 0; } //启动监视进程 CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)IOCPThread, (PVOID)hIocp, 0, NULL); //将作业对象与完成端口绑定 JOBOBJECT_ASSOCIATE_COMPLETION_PORT jacp = {0}; jacp.CompletionKey = hJob; jacp.CompletionPort = hIocp; SetInformationJobObject(hJob, JobObjectAssociateCompletionPortInformation, &jacp, sizeof(jacp)); //为作业对象设置限制条件 JOBOBJECT_BASIC_LIMIT_INFORMATION jbli = {0}; jbli.PerProcessUserTimeLimit.QuadPart = 20 * 1000 * 10i64; //限制执行的用户时间为20ms jbli.MinimumWorkingSetSize = 4 * 1024; jbli.MaximumWorkingSetSize = 256 * 1024; //限制最大内存为256k jbli.LimitFlags = JOB_OBJECT_LIMIT_PROCESS_TIME | JOB_OBJECT_LIMIT_JOB_MEMORY; SetInformationJobObject(hJob, JobObjectBasicLimitInformation, &jbli, sizeof(jbli)); //指定不显示异常对话框 JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli = {0}; jeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION; SetInformationJobObject(hJob, JobObjectExtendedLimitInformation, &jeli, sizeof(jeli)); //创建新进程 _tcscat_s(szModulePath, MAX_PATH, _T("JobProcess.exe")); STARTUPINFO si = {0}; PROCESS_INFORMATION pi = {0}; CreateProcess(szModulePath, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED | CREATE_BREAKAWAY_FROM_JOB, NULL, NULL, &si, &pi); //将进程加入到作业对象中 AssignProcessToJobObject(hJob, pi.hProcess); //运行进程 ResumeThread(pi.hThread); //查询作业对象的运行情况，在这查询基本统计信息和IO信息 JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION jbaai = {0}; DWORD dwRetLen = 0; QueryInformationJobObject(hJob, JobObjectBasicAndIoAccountingInformation, &jbaai, sizeof(jbaai), &dwRetLen); //等待进程退出 WaitForSingleObject(pi.hProcess, INFINITE); CloseHandle(pi.hThread); CloseHandle(pi.hProcess); //给完成端口线程发送退出命令 PostQueuedCompletionStatus(hIocp, 0, (ULONG_PTR)hJob, NULL); //等待线程退出 WaitForSingleObject(hIocp, INFINITE); CloseHandle(hIocp); CloseHandle(hJob); return 0; } DWORD IOCPThread(PVOID lpParam) { BOOL bLoop = TRUE; HANDLE hIocp = (HANDLE)lpParam; DWORD dwReasonId = 0; HANDLE hJob = NULL; OVERLAPPED *lpOverlapped = {0}; while (bLoop) { BOOL bSuccess = GetQueuedCompletionStatus(hIocp, &dwReasonId, (PULONG_PTR)&hJob, &lpOverlapped, INFINITE); if(!bSuccess) { return 0; } switch (dwReasonId) { case JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS: { //进程异常退出 DWORD dwProcessId = (DWORD)lpOverlapped; HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwProcessId); if(INVALID_HANDLE_VALUE != hProcess) { DWORD dwExit = 0; GetExitCodeProcess(hProcess, &dwExit); printf("进程[%08x]异常退出，退出码为[%04x]\n", dwProcessId, dwExit); } } break; case JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT: { printf("同时活动的进程数达到上限\n"); } break; case JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO: { printf("没有活动的进程了\n"); } break; case JOB_OBJECT_MSG_END_OF_JOB_TIME: { printf("作业对象CPU时间周期耗尽\n"); } break; case JOB_OBJECT_MSG_END_OF_PROCESS_TIME: { DWORD dwProcessID = (DWORD)lpOverlapped; printf("进程[%04x]CPU时间周期耗尽\n", dwProcessID); } break; case JOB_OBJECT_MSG_EXIT_PROCESS: { DWORD dwProcessId = (DWORD)lpOverlapped; HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwProcessId); if(INVALID_HANDLE_VALUE != hProcess) { DWORD dwExit = 0; GetExitCodeProcess(hProcess, &dwExit); printf("进程[%08x]正常退出，退出码为[%04x]\n", dwProcessId, dwExit); } } break; case JOB_OBJECT_MSG_JOB_MEMORY_LIMIT: { printf("作业对象消耗内存数量达到上限\n"); } break; case JOB_OBJECT_MSG_NEW_PROCESS: { DWORD dwProcessID = (DWORD)lpOverlapped; printf("进程[ID:%u]加入作业对象[h:0x%08X]\n",dwProcessID,hJob); } break; case JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT: { DWORD dwProcessID = (DWORD)lpOverlapped; printf("进程[%04x]消耗内存数量达到上限\n",dwProcessID); } break; default: bLoop = FALSE; break; } } }在上面的例子中需要注意一点，在创建进程的时候我们给这个进程一个CREATE_BREAKAWAY_FROM_JOB标志，由于Windows在创建进程时，默认会将这个子进程丢到父进程所在进程池中，如果父进程属于某一个进程池，那么我们再将子进程放到其他进程池中，自然会导致失败，这个标志表示，新创建的子进程不属于任何一个进程池，这样在后面的操作才会成功

Windows资源 Windows资源是一种二进制数据，由链接器链接进程序成为程序的一部分，通过资源的方式可以很方便的对应用程序进行扩展。在Windows中资源可以是系统自定义的，也可以是用户自定义的。在VC++中资源是以被称为资源脚本的文本文件描述的(扩展名为rc)，另外为了方便代码中调用资源,VC++环境中还会自动生成一个resource.h的头文件供C++代码使用，这个文件中主要定义了各个资源的ID，在vc++中使用ID来唯一标识一个资源，这个ID可以是数字也可以是字符串，其实在VC中真正用来标识资源的是字符串，通过宏MAKEINTRESOURCE可以将数字型的ID转化为对应的字符串，一般的资源函数在操作资源时都需要提供一个资源的字符串，而这个串就是利用这个宏传入ID生成的。在VC中资源脚本的基本格式为：资源名(ID串) 类型名 [语言] 资源数据资源数据可以是一段指定格式的文本或者一个文件，比如我们将wav作为资源加入到程序中，可以这样写：MY_WAVE_RES IDR_WAVE sample.wav.其中语言如果没有指定，那么默认为操作系统当前的语言环境。另外我们也可以将不同的资源放入不同的文本文件中，先定义好，然后在.rc文件中使用#include 来包含进来，比如在一个名为wav.resinclude文件中定义了一个WAV资源，然后可以在.rc文件中加上一句"#include <wav.resinclude> ”下面介绍下资源的操作中比较高级的技术引用自定义资源对于系统自定义资源，系统都提供了专门的函数来进行加载和操作，但是对于自定义资源，在操作时相对比较复杂，一般先使用FindResource和FindResourceEx在进程中找到对应的资源句柄，然后使用LoadResource将资源加载到内存中，以后就可以使用这个资源了。下面的一个例子演示了如何在当前exe中如何将另一个EXE作为资源加载，并执行它。__inline VOID GetAppPath(LPTSTR pszBuf) { DWORD dwLen = 0; if(0 == (dwLen = ::GetModuleFileName(NULL,pszBuf,MAX_PATH))) { printf("获取APP路径失败,错误码0x%08x\n",GetLastError()); return; } DWORD i = dwLen; for(; i > 0; i -- ) { if( '\\' == pszBuf[i] ) { pszBuf[i + 1] = '\0'; break; } } } int _tmain(int argc, _TCHAR* argv[]) { HMODULE hModule = GetModuleHandle(NULL); HRSRC hRsrc = FindResource(hModule, MAKEINTRESOURCE(IDR_RCDATA1), RT_RCDATA); if (INVALID_HANDLE_VALUE == hRsrc) { printf("加载自定义资源失败!\n"); return 0; } HGLOBAL hGlobalRes = LoadResource(hModule, hRsrc); LPVOID pResMem = LockResource(hGlobalRes); DWORD dwSize = SizeofResource(hModule, hRsrc); if (NULL == pResMem) { printf("获取资源所在内存失败！\n"); return 0; } TCHAR szFilePath[MAX_PATH] = _T(""); GetAppPath(szFilePath); StringCchCat(szFilePath, MAX_PATH, _T("test.exe")); HANDLE hFile = CreateFile(szFilePath, GENERIC_WRITE | GENERIC_READ, 0, NULL, CREATE_ALWAYS, 0, NULL); if(!WriteFile(hFile, pResMem, dwSize, &dwSize, NULL)) { printf("写文件失败\n"); return 0; } CloseHandle(hFile); STARTUPINFO si = {0}; PROCESS_INFORMATION pi = {0}; CreateProcess(szFilePath, NULL, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &si, &pi); WaitForSingleObject(pi.hProcess, INFINITE); CloseHandle(pi.hThread); CloseHandle(pi.hProcess); return 0; }为了执行上面的代码需要在该项目工程中新加一个资源，将目标EXE添加到资源中，其中资源文件会多出一行"IDR_RCDATA1 RCDATA "E:\Program\ResourcesDemo\Debug\stdWindow.exe" 在resource.h文件中生成了一个资源对应的ID，做好这些工作，该程序就能正常运行在上面的代码中，依次调用FindResource、 LoadResource、LockResource，获取资源在进程空间中的地址，并将它对应的物理页面锁定在内存中，不允许其进行内存交换。然后将这个部分的内存写入到文件形成一个新的exe，最后执行这个exe，最终上面的程序编译运行后我们会发现在程序对应的目录下会生成一个test.exe文件。更新资源在有的时候需要对程序中的资源进行更新，这种情况下一般是在原始的工程下 更改资源，然后重新编译，但是这个时候用户需要下载新的更新程序，在原始程序比较大的情况下，为了更改一个简单的资源就要重新花大量的时间下载并更新程序，可能有点杀鸡用牛刀的意思，在我们只需要更新程序中的资源的情况下，Windows提供了一种方法。首先使用BeginUpdateResource建立可执行程序文件模块的更新句柄使用UpdateResource传入之前的更新句柄，更新资源数据使用EndUpdateResource函数关闭修改句柄，如果想让整个更改存盘需要将函数的第二个参数传入FALSE，这个参数的意思是是否放弃更新，传入false表示保存更新下面是一个简单的例子 HMODULE hModule = GetModuleHandle(NULL); //加载资源 HRSRC hRsrc = FindResource(hModule, MAKEINTRESOURCE(IDI_ICON1), RT_GROUP_ICON); if (hRsrc == NULL) { printf("加载资源失败\n"); return GetLastError(); } HGLOBAL hIcon = LoadResource(hModule, hRsrc); PVOID pIconBuf = LockResource(hIcon); int nIconSize = SizeofResource(hModule, hRsrc); //更新资源 HANDLE hUpdate = BeginUpdateResource(_T("E:\\Program\\ResourcesDemo\\Debug\\stdWindow.exe"), TRUE); BOOL bRet = UpdateResource(hUpdate, MAKEINTRESOURCE(RT_GROUP_ICON), MAKEINTRESOURCE(IDI_STDWINDOW), GetUserDefaultLangID(), pIconBuf, nIconSize); bRet = EndUpdateResource(hUpdate, FALSE); return 0;枚举资源枚举资源主要使用函数EnumResourceTypes EnumResourceNames, 和EnumResourceLanguages,这几个函数分别枚举资源类型，名称和语言，在msdn中查找函数的定义发现他们的调用顺序必须是type name language，下面是一个简单的枚举的例子：BOOL CALLBACK EnumResLangProc(HANDLE hModule, LPCTSTR lpszType, LPCTSTR lpszName, WORD wIDLanguage, LONG_PTR lParam) { printf("\tlanguage :%d\n", wIDLanguage); return TRUE; } BOOL CALLBACK EnumRe1sNameProc(HMODULE hModule, LPCTSTR lpszType, LPTSTR lpszName, LONG_PTR lParam) { if ((ULONG)lpszName & 0xffff0000) { printf("\t名称:%s\n", lpszName); }else { printf("\t名称:%d\n", (USHORT)lpszName); } return EnumResourceLanguages(hModule, lpszType, lpszName, (ENUMRESLANGPROCW)EnumResLangProc, NULL); } BOOL CALLBACK EnumResTypeProc(HMODULE hModule, LPTSTR lpszType,LONG_PTR lParam) { if ((ULONG)lpszType & 0xFFFF0000) { printf("类型:%s\n", lpszType); }else { printf("类型:%d\n", (USHORT)lpszType); } return EnumResourceNames(hModule, lpszType, (ENUMRESNAMEPROCW)EnumRe1sNameProc, NULL); } int _tmain(int argc, _TCHAR* argv[]) { HMODULE hExe = LoadLibrary(_T("E:\\Program\\ResourcesDemo\\Debug\\stdWindow.exe")); if (hExe == NULL) { printf("加载目标程序出错!\n"); return GetLastError(); } printf("目标程序中包含以下资源:\n"); EnumResourceTypes(hExe, EnumResTypeProc, NULL); return 0; }这段代码有以下几点需要注意：LoadLibrary不仅仅可以用来加载dll，实际上它可以加载任意的PE文件到内存，而GetModuleHandle是在内存中查找已经存在的一个模块的句柄，而我们这个地方这个exe事先并没有加载到内存，所以这里用GetModuleHandle是不能正确加载的，只有使用LoadLibrary这几个枚举函数都需要一个回调函数，这些函数指针类型可以在msdn中查找到，在VC环境下也定义了这些函数指针，但是不知道为什么在填入函数指针时需要强制转化，否则会报错资源可以使用字符串表示，也可以使用ID表示，这些回调函数虽说传入的都是枚举到的字符串指针，但是它仍然可能是ID，所以在这不能简单的直接把他们作为字符串使用，需要进行判断，判断的依据是它是否大于65536，因为我们说只有在ID值大于这个时，系统才会将ID作为字符串来使用

hook键盘驱动中的分发函数实现键盘输入数据的拦截 我自己在看《寒江独钓》这本书的时候，书中除了给出了利用过滤的方式来拦截键盘数据之外，也提到了另外一种方法，就是hook键盘分发函数，将它替换成我们自己的，然后再自己的分发函数中获取这个数据的方式，但是书中并没有明确给出代码，我结合书中所说的一些知识加上网上找到的相关资料，自己编写了相关代码，并且试验成功了，现在给出详细的方法和代码。用这种方式时首先根据ObReferenceObjectByName函数来根据对应的驱动名称获取驱动的驱动对象指针。该函数是一个未导出函数，在使用时只需要先声明即可，函数原型如下:NTSTATUS ObReferenceObjectByName( PUNICODE_STRING ObjectName, //对应对象的名称 ULONG Attributes, //相关属性，一般给OBJ_CASE_INSENSITIVE PACCESS_STATE AccessState, //描述信息的一个结构体指针，一般给NULL ACCESS_MASK DesiredAccess, //以何种权限打开，一般给0如果或者FILL_ALL_ACCESS给它所有权限 POBJECT_TYPE ObjectType, //该指针是什么类型的指针，如果是设备对象给IoDeviceObjectType如果是驱动对象则给IoDriverObjectType KPROCESSOR_MODE AccessMode, //一般给NULL PVOID ParseContext, //附加参数，一般给NULL PVOID *pObject //用来接收相关指针的输出参数 );IoDeviceObjectType或者IoDriverObjectType也是未导出的，在使用之前需要先申明他们，例如extern POBJECT_TYPE IoDriverObjectType; extern POBJECT_TYPE IoDeviceObjectType;然后将该驱动对象中原始的分发函数保存起来，以便在hook之后调用或者在驱动卸载时恢复接下来hook相关函数，要截取键盘的数据，一般采用的是hook read函数在read函数中设置IRP的完成例程，然后调用原始的分发函数，一定要注意调用原始的分发函数，否则自己很难实现类似的功能，一旦实现不了，那么Windows上的键盘功能将瘫痪。在完成例程中解析穿回来的IRP就可得到对应键盘的信息。下面是具体的实现代码#define KDB_DRIVER_NAME L"\\Driver\\KbdClass" //键盘驱动的名称为KbdClass NTSTATUS ObReferenceObjectByName( PUNICODE_STRING ObjectName, ULONG Attributes, PACCESS_STATE AccessState, ACCESS_MASK DesiredAccess, POBJECT_TYPE ObjectType, KPROCESSOR_MODE AccessMode, PVOID ParseContext, PVOID *pObject); extern POBJECT_TYPE IoDriverObjectType; PDRIVER_OBJECT g_pKdbDriverObj; //键盘的驱动对象，保存这个是为了在卸载时还原它的分发函数 PDRIVER_DISPATCH g_oldDispatch[IRP_MJ_MAXIMUM_FUNCTION+1]; int g_KeyCount = 0; //记录键盘IRP的数量，当键盘的请求没有被处理完成时不能卸载这个驱动 VOID DriverUnload(PDRIVER_OBJECT DriverObject) { LARGE_INTEGER WaitTime; int i = 0; DbgPrint("KBD HOOK: Entry DriverUnload\n"); //等待5s WaitTime = RtlConvertLongToLargeInteger(-5 * 1000000000 / 100); //如果IRP没有被处理完成，等待5s再检测是否处理完成 while(0 != g_KeyCount) { KeDelayExecutionThread(KernelMode, FALSE, &WaitTime); } for(i = 0; i < IRP_MJ_MAXIMUM_FUNCTION + 1; i++) { //还原对应的分发函数 g_pKdbDriverObj->MajorFunction[i] = g_oldDispatch[i]; } } NTSTATUS c2cReadComplete( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID Context ) { PUCHAR pBuffer; ULONG uLength; int i = 0; if(NT_SUCCESS(Irp->IoStatus.Status)) { pBuffer = (PUCHAR)(Irp->AssociatedIrp.SystemBuffer); uLength = Irp->IoStatus.Information; for(i = 0; i < uLength; i++) { //在完成函数中只是简单的输出了对应的16进制数 DbgPrint("cap2ctrl: Key %02x\r\n", pBuffer[i]); } } //每当一个IRP完成时，未完成的IRP数量都需要减一 g_KeyCount--; if(Irp->PendingReturned) { IoMarkIrpPending( Irp ); } return Irp->IoStatus.Status; } NTSTATUS c2cReadDispathc( IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp ) { PIO_STACK_LOCATION pIroStack; DbgPrint("Hook By Me!\n"); //每当进入这个分发函数时都需要将这个未完成IRP数量加一 g_KeyCount++; //设置完成函数 //在这只能用这种方式，我自己试过用IoSetCompletionRoutine ,它注册的完成函数没有被调用，我也不知道为什么 pIroStack = IoGetCurrentIrpStackLocation(Irp); pIroStack->Control = SL_INVOKE_ON_SUCCESS|SL_INVOKE_ON_ERROR|SL_INVOKE_ON_CANCEL; pIroStack->CompletionRoutine = (PIO_COMPLETION_ROUTINE)c2cReadComplete; //调用原始的分发函数 return (g_oldDispatch[IRP_MJ_READ])(DeviceObject, Irp); } NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPath) { int i = 0; PDRIVER_OBJECT pKbdDriverObj; UNICODE_STRING uKbdDriverName; NTSTATUS status; UNREFERENCED_PARAMETER(pRegistryPath); DbgPrint("cap2ctrl: Entry DriverEntry\n"); RtlInitUnicodeString(&uKbdDriverName, KDB_DRIVER_NAME); status = ObReferenceObjectByName(&uKbdDriverName, OBJ_CASE_INSENSITIVE, NULL, 0, IoDriverObjectType, KernelMode, NULL, &g_pKdbDriverObj); if(!NT_SUCCESS(status)) { return status; } //保存原始的派遣函数 for(i = 0; i < IRP_MJ_MAXIMUM_FUNCTION+1; i++) { g_oldDispatch[i] = g_pKdbDriverObj->MajorFunction[i]; } //HOOK读请求的派遣函数 g_pKdbDriverObj->MajorFunction[IRP_MJ_READ] = c2cReadDispathc; pDriverObject->DriverUnload = DriverUnload; //绑定设备 return STATUS_SUCCESS; }

遍历系统中加载的驱动程序以及通过设备对象指针获取设备对象名称 遍历系统中加载的驱动可以在R3层完成，通过几个未导出的函数：ZwOpenDirectoryObject、ZwQueryDirectoryObject，下面是具体的代码。//在这定义些基本的数据结构，这些本身是在R0层用的比较多的 typedef struct _UNICODE_STRING { USHORT Length; USHORT MaximumLength; PWSTR Buffer; } UNICODE_STRING, *PUNICODE_STRING; typedef ULONG NTSTATUS; // 对象属性定义 typedef struct _OBJECT_ATTRIBUTES { ULONG Length; HANDLE RootDirectory; UNICODE_STRING *ObjectName; ULONG Attributes; PSECURITY_DESCRIPTOR SecurityDescriptor; PSECURITY_QUALITY_OF_SERVICE SecurityQualityOfService; } OBJECT_ATTRIBUTES, *POBJECT_ATTRIBUTES; // 基本信息定义 typedef struct _DIRECTORY_BASIC_INFORMATION { UNICODE_STRING ObjectName; UNICODE_STRING ObjectTypeName; } DIRECTORY_BASIC_INFORMATION, *PDIRECTORY_BASIC_INFORMATION; // 返回值或状态类型定义 #define OBJ_CASE_INSENSITIVE 0x00000040L #define DIRECTORY_QUERY (0x0001) #define STATUS_SUCCESS ((NTSTATUS)0x00000000L) // ntsubauth #define STATUS_MORE_ENTRIES ((NTSTATUS)0x00000105L) #define STATUS_BUFFER_TOO_SMALL ((NTSTATUS)0xC0000023L) // 初始化对象属性宏定义 #define InitializeObjectAttributes( p, n, a, r, s ) { \ (p)->Length = sizeof(OBJECT_ATTRIBUTES); \ (p)->RootDirectory = r; \ (p)->Attributes = a; \ (p)->ObjectName = n; \ (p)->SecurityDescriptor = s; \ (p)->SecurityQualityOfService = NULL; \ } // 字符串初始化 //用来存储设备驱动对象名称的链表 extern vector<CString> g_DriverNameList; vector<DRIVER_INFO> g_DriverNameList; typedef VOID(CALLBACK* RTLINITUNICODESTRING)(PUNICODE_STRING, PCWSTR); RTLINITUNICODESTRING RtlInitUnicodeString; // 打开对象 typedef NTSTATUS(WINAPI *ZWOPENDIRECTORYOBJECT)( OUT PHANDLE DirectoryHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes ); ZWOPENDIRECTORYOBJECT ZwOpenDirectoryObject; // 查询对象 typedef NTSTATUS (WINAPI *ZWQUERYDIRECTORYOBJECT)( IN HANDLE DirectoryHandle, OUT PVOID Buffer, IN ULONG BufferLength, IN BOOLEAN ReturnSingleEntry, IN BOOLEAN RestartScan, IN OUT PULONG Context, OUT PULONG ReturnLength OPTIONAL ); ZWQUERYDIRECTORYOBJECT ZwQueryDirectoryObject; // 关闭已经打开的对象 typedef NTSTATUS (WINAPI *ZWCLOSE)(IN HANDLE Handle); ZWCLOSE ZwClose; BOOL EnumDriver() { HMODULE hNtdll = NULL; UNICODE_STRING strDirName; OBJECT_ATTRIBUTES oba; NTSTATUS ntStatus; HANDLE hDirectory; hNtdll = LoadLibrary(_T("ntdll.dll")); if (NULL == hNtdll) { return FALSE; } RtlInitUnicodeString = (RTLINITUNICODESTRING)GetProcAddress(hNtdll, "RtlInitUnicodeString"); ZwOpenDirectoryObject = (ZWOPENDIRECTORYOBJECT)GetProcAddress(hNtdll, "ZwOpenDirectoryObject"); ZwQueryDirectoryObject = (ZWQUERYDIRECTORYOBJECT)GetProcAddress(hNtdll, "ZwQueryDirectoryObject"); ZwClose = (ZWCLOSE)GetProcAddress(hNtdll, "ZwClose"); RtlInitUnicodeString(&strDirName, _T("\\Driver")); InitializeObjectAttributes(&oba, &strDirName, OBJ_CASE_INSENSITIVE, NULL, NULL); ntStatus = ZwOpenDirectoryObject(&hDirectory, DIRECTORY_QUERY, &oba); if (ntStatus != STATUS_SUCCESS) { return FALSE; } PDIRECTORY_BASIC_INFORMATION pBuffer = NULL; PDIRECTORY_BASIC_INFORMATION pBuffer2 = NULL; ULONG ulLength = 0x800; // 2048 ULONG ulContext = 0; ULONG ulRet = 0; // 查询目录对象 do { if (pBuffer != NULL) { free(pBuffer); } ulLength = ulLength * 2; pBuffer = (PDIRECTORY_BASIC_INFORMATION)malloc(ulLength); if (NULL == pBuffer) { if (pBuffer != NULL) { free(pBuffer); } if (hDirectory != NULL) { ZwClose(hDirectory); } return FALSE; } ntStatus = ZwQueryDirectoryObject(hDirectory, pBuffer, ulLength, FALSE, TRUE, &ulContext, &ulRet); } while (ntStatus == STATUS_MORE_ENTRIES || ntStatus == STATUS_BUFFER_TOO_SMALL); if (STATUS_SUCCESS == ntStatus) { pBuffer2 = pBuffer; while ((pBuffer2->ObjectName.Length != 0) && (pBuffer2->ObjectTypeName.Length != 0)) { CString strDriverName; strDriverName = pBuffer2->ObjectName.Buffer; g_DriverNameList.push_back(strDriverName); pBuffer2++; } } if (pBuffer != NULL) { free(pBuffer); } if (hDirectory != NULL) { ZwClose(hDirectory); } return TRUE; }通过设备对象的地址来获取设备对象的名称一般是在R0层完成，下面是具体的代码//定义相关的结构体和宏 typedef struct _OBJECT_CREATE_INFORMATION { ULONG Attributes; HANDLE RootDirectory; PVOID ParseContext; KPROCESSOR_MODE ProbeMode; ULONG PagedPoolCharge; ULONG NonPagedPoolCharge; ULONG SecurityDescriptorCharge; PSECURITY_DESCRIPTOR SecurityDescriptor; PSECURITY_QUALITY_OF_SERVICE SecurityQos; SECURITY_QUALITY_OF_SERVICE SecurityQualityOfService; } OBJECT_CREATE_INFORMATION, * POBJECT_CREATE_INFORMATION; typedef struct _OBJECT_HEADER { LONG PointerCount; union { LONG HandleCount; PSINGLE_LIST_ENTRY SEntry; }; POBJECT_TYPE Type; UCHAR NameInfoOffset; UCHAR HandleInfoOffset; UCHAR QuotaInfoOffset; UCHAR Flags; union { POBJECT_CREATE_INFORMATION ObjectCreateInfo; PVOID QuotaBlockCharged; }; PSECURITY_DESCRIPTOR SecurityDescriptor; QUAD Body; } OBJECT_HEADER, * POBJECT_HEADER; #define NUMBER_HASH_BUCKETS 37 typedef struct _OBJECT_DIRECTORY { struct _OBJECT_DIRECTORY_ENTRY* HashBuckets[NUMBER_HASH_BUCKETS]; struct _OBJECT_DIRECTORY_ENTRY** LookupBucket; BOOLEAN LookupFound; USHORT SymbolicLinkUsageCount; struct _DEVICE_MAP* DeviceMap; } OBJECT_DIRECTORY, * POBJECT_DIRECTORY; typedef struct _OBJECT_HEADER_NAME_INFO { POBJECT_DIRECTORY Directory; UNICODE_STRING Name; ULONG Reserved; #if DBG ULONG Reserved2 ; LONG DbgDereferenceCount ; #endif } OBJECT_HEADER_NAME_INFO, * POBJECT_HEADER_NAME_INFO; #define OBJECT_TO_OBJECT_HEADER( o ) \ CONTAINING_RECORD( (o), OBJECT_HEADER, Body ) #define OBJECT_HEADER_TO_NAME_INFO( oh ) ((POBJECT_HEADER_NAME_INFO) \ ((oh)->NameInfoOffset == 0 ? NULL : ((PCHAR)(oh) - (oh)->NameInfoOffset))) void GetDeviceName(PDEVICE_OBJECT pDeviceObj) { POBJECT_HEADER ObjectHeader; POBJECT_HEADER_NAME_INFO ObjectNameInfo; if ( pDeviceObj == NULL ) { DbgPrint( "pDeviceObj is NULL!\n" ); return; } // 得到对象头 ObjectHeader = OBJECT_TO_OBJECT_HEADER( pDeviceObj ); if ( ObjectHeader ) { // 查询设备名称并打印 ObjectNameInfo = OBJECT_HEADER_TO_NAME_INFO( ObjectHeader ); if ( ObjectNameInfo && ObjectNameInfo->Name.Buffer ) { DbgPrint( "Driver Name:%wZ - Device Name:%wZ - Driver Address:0x%x - Device Address:0x%x\n", &pDeviceObj->DriverObject->DriverName, &ObjectNameInfo->Name, pDeviceObj->DriverObject, pDeviceObj ); } // 对于没有名称的设备，则打印 NULL else if ( pDeviceObj->DriverObject ) { DbgPrint( "Driver Name:%wZ - Device Name:%S - Driver Address:0x%x - Device Address:0x%x\n", &pDeviceObj->DriverObject->DriverName, L"NULL", pDeviceObj->DriverObject, pDeviceObj ); } } }

驱动开发中的常用操作 这篇文章会持续更新，由于在驱动中，有许多常用的操作代码几乎不变，而我自己有时候长时间不用经常忘记，所以希望在这把一些常用的操作记录下来，当自己遗忘的时候，有个参考创建设备对象创建设备对象使用函数IoCreateDevice，它的参数如下：NTSTATUS IoCreateDevice( IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName OPTIONAL, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject );第一个参数是驱动对象第二个参数是设备对象扩展的大小，它会自动根据大小生成一个内存空间，与对应设备绑定第三个参数是驱动名称第四个参数是驱动的类型，一般用作过滤设备的驱动类型为FILE_DEVICE_UNKNOWN第五个参数一般给FILE_DEVICE_SECURE_OPEN第六个参数表示设备是否为独占模式，一般给FALSE第七个参数是设备驱动的二级指针，用来返回生成的设备驱动的指针创建一个过滤设备的代码如下：//创建设备对象 status = IoCreateDevice(pDriverObject, sizeof(LIST_ENTRY), &uDeviceName, FILE_DEVICE_UNKNOWN, FILE_DEVICE_SECURE_OPEN, FALSE, &pDeviceObject); //为设备对象设置相关标识 pDeviceObject->Flags |= DO_BUFFERED_IO;IRP的完成在某些我们不需要进行特殊处理，但是又得需要对这个IRP进行处理的时候，一般采用完成处理的方式，这种方式主要使用函数IoCompleteRequest，使用例子如下：Irp->IoStatus.Information = 0; //设置返回给应用层的缓冲区的大小 Irp->IoStatus.Status = STATUS_SUCCESS;//给应用层当前IO操作返回成功 IoCompleteRequest(Irp, IO_NO_INCREMENT);//结束IRP在派遣函数中拿IRP的主功能号IRP中保存了它的主功能号和副功能号，他们都被存储在IRP的栈中，下面是基本的代码pStack = IoGetCurrentIrpStackLocation(Irp); //获取IRP栈 IrpCode = pStack->MajorFunction;在MJ_DEVICE_CONTROL类型的IRP中得到对应的控制码CtrlCode = pStack->Parameters.DeviceIoControl.IoControlCode;获取驱动所在的进程这个方法目前只在XP上实验过，win7或者更高版本可能有些不同。获取当前进程主要在EPROCESS结构找到名为ProcessName的项，由于这个结构微软并没有公开，所以可能以后会根据系统版本的不同它的偏移可能也有些许不同。下面是具体的代码pCurrProcess = IoGetCurrentProcess(); RtlInitUnicodeString(&uProcessName, (PTSTR)((ULONG)pCurrProcess + 0x174)); //这个偏移量是在xp上有效，是通过WinDbg获取到的，如果有变化，也可以通过windbg重新得到数据 代码所处内存的划分在驱动程序中，一定要非常小心的为每个函数，数据划分内存块，否则会出现蓝屏现象，比如处在DISPATCH_LEVEL的代码，只能位于非分页内存，因为这个IRQL下的代码不能被打断，如果发生缺页中断，那么只会造成蓝屏现象。而PASSIVE_LEVLE的代码则没有这个限制。下面是定义函数和数据在不同内存页的写法#define PAGEDCODE code_seg("PAGE") //分页内存 #define LOCKEDCODE code_seg()//非分页内存 #define INITCODE code_seg("INIT")//处在这种类型的代码，当函数执行完成后，系统会立马回收它所在的内存页 #define PAGEDDATA data_seg("PAGE") #define LOCKEDDATA data_seg() #define INITDATA data_seg("INIT") //下面是使用这些宏的例子，使用时只需要在函数或者数据前加上对应的宏 LOCKEDCODE void test() { }给编译器提示，函数某些参数在函数中不使用一般在编译驱动时，如果函数参数或者在函数内部定义了某些变量在函数中没有使用的话，编译器会报错，但是有的函数原型是系统规定，但是有些参数又确实用不到，这个时候有两种方式，一种是关掉相关的编译选项，另一种是使用宏告知编译器，这个变量在函数中不使用.UNREFERENCED_PARAMETER(RegistryPath);获取系统时间这里的获取系统时间一般是指获取时间并将它转化我们熟悉的年月日、时分秒的格式，一般的步骤如下：利用函数KeGetSystemTime()获取系统时间，这个时间是格林尼治时间从1601年起至今经历的时间，单位为100ns利用ExSystemTimeToLocalTime()将上述的格林尼治时间转化为本时区的时间，这个值得含义和单位与上述的相同利用函数RtlTimeToTimeFields()将本地时间转化为带有年月日格式的时间函数的第二个参数是TIME_FIELDS结构，他的定义如下：typedef struct TIME_FIELDS { CSHORT Year; CSHORT Month; CSHORT Day; CSHORT Hour; CSHORT Minute; CSHORT Second; CSHORT Milliseconds; CSHORT Weekday; } TIME_FIELDS;下面是一个时间转化的例子 LARGE_INTEGER current_system_time; TIME_FIELDS time_fields; LARGE_INTEGER current_local_time; KeQuerySystemTime(&current_system_time); ExSystemTimeToLocalTime(&current_system_time, &current_local_time); RtlTimeToTimeFields(&current_local_time, &time_fields); DbgPrint("Current Time: %d/%d/%d %d:%d:%d\n", time_fields.Year, time_fields.Month, time_fields.Day, time_fields.Hour, time_fields.Minute, time_fields.Second);他们三个可以互相转化，下面是它们之间转化的一个示意图：文件读写文件读写一般需要进行这样几步使用InitializeObjectAttributes初始化一个OBJECT_ATTRIBUTES对象使用ZwCreateFile创建一个文件句柄调用ZwReadFile或者ZwWriteFile读写文件这里面复杂的是InitializeObjectAttributes和ZwCreateFile传参的问题，好在这两个函数在调用时，一般传参都是固定的。VOID InitializeObjectAttributes( OUT POBJECT_ATTRIBUTES InitializedAttributes, IN PUNICODE_STRING ObjectName, //传希望打开的文件名称或者设备对象名称 IN ULONG Attributes, //权限一般给OBJ_CASE_INSENSITIVE IN HANDLE RootDirectory, //根目录，一般给NULL IN PSECURITY_DESCRIPTOR SecurityDescriptor//安全属性，一般给NULL );NTSTATUS ZwCreateFile( __out PHANDLE FileHandle, //返回的文件句柄 __in ACCESS_MASK DesiredAccess, //权限，如果希望对文件进行同步操作，需要额外加上SYNCHRONIZE __in POBJECT_ATTRIBUTES ObjectAttributes, __out PIO_STATUS_BLOCK IoStatusBlock, //一般不怎么用这个输出参数，但是的给值 __in_opt PLARGE_INTEGER AllocationSize,//一般给NULL __in ULONG FileAttributes,//文件属性,一般给FILE_ATTRIBUTE_NORMAL __in ULONG ShareAccess,//共享属性一般给0 __in ULONG CreateDisposition,//创建的描述信息，根据MSDN很容易决定 __in ULONG CreateOptions, //如果是同步操作，一般加上FILE_SYNCHRONOUS_IO_NONALERT,如果是异步操作一般给0 __in_opt PVOID EaBuffer, //一般给NULL __in ULONG EaLength//一般给0 );下面是读写不同设备的相关代码//同步读取驱动的设备对象 NTSTATUS status; HANDLE hDeviceA; OBJECT_ATTRIBUTES ObjAtrribute; UNICODE_STRING uDeviceName; IO_STATUS_BLOCK status_block; RtlInitUnicodeString(&uDeviceName, DEVICE_NAME); InitializeObjectAttributes(&ObjAtrribute, &uDeviceName, OBJ_CASE_INSENSITIVE, NULL, NULL); status = ZwCreateFile(&hDeviceA, SYNCHRONIZE | FILE_READ_ATTRIBUTES, &ObjAtrribute,&status_block, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0); if(!NT_SUCCESS(status)) { return status; } ZwReadFile(hDeviceA, NULL, NULL, NULL, &status_block, NULL, 0, NULL, NULL); ZwClose(hDeviceA); return STATUS_SUCCESS;//同步读取文件 HANDLE hFile = NULL; OBJECT_ATTRIBUTES ObjAttribute; IO_STATUS_BLOCK IoStatusBlock; UNICODE_STRING uFileName; WCHAR wFname[] = L"\\??\\C:\\log.txt"; CHAR buf[] = "Hello World\r\n"; NTSTATUS status = STATUS_SUCCESS; FILE_STANDARD_INFORMATION fsi = {0}; PCHAR pBuffer = NULL; RtlInitUnicodeString(&uFileName, wFname); InitializeObjectAttributes(&ObjAttribute, &uFileName, OBJ_CASE_INSENSITIVE, NULL, NULL); //打开文件或者创建文件 status = ZwCreateFile(&hFile, GENERIC_WRITE | GENERIC_READ, &ObjAttribute, &IoStatusBlock, NULL, 0, 0, FILE_OPEN_IF, FILE_SYNCHRONOUS_IO_NONALERT, NULL, NULL); if(!NT_SUCCESS(status)) { DbgPrint("Create File Error\n"); return; } //写文件 status = ZwWriteFile(hFile, NULL, NULL, NULL, &IoStatusBlock, buf, sizeof(buf), NULL, NULL); if(NT_SUCCESS(status)) { DbgPrint("Write File Success%u", IoStatusBlock.Information); } //读取文件长度 status = ZwQueryInformationFile(hFile, &IoStatusBlock, &fsi, sizeof(fsi), FileStandardInformation); if(NT_SUCCESS(status)) { DbgPrint("file length:%u\n", fsi.EndOfFile.QuadPart); } //读文件 pBuffer = (PCHAR)ExAllocatePoolWithTag(PagedPool, fsi.EndOfFile.QuadPart * sizeof(CHAR), 'eliF'); if(NULL != pBuffer) { status = ZwReadFile(hFile, NULL, NULL, NULL, &IoStatusBlock, pBuffer, fsi.EndOfFile.QuadPart * sizeof(CHAR), NULL, NULL); if(NT_SUCCESS(status)) { DbgPrint("Read File %s lenth: %u", pBuffer, fsi.EndOfFile.QuadPart * sizeof(CHAR)); } } //关闭文件句柄 ZwClose(hFile); ExFreePool(pBuffer);

定时器的实现 使用IO定时器IO定时器每隔1s就会触发一次，从而进入到定时器例程中，如果某个操作是每n秒执行一次（n为正整数）可以考虑在定时器例程中记录一个计数器大小就为n，每次进入定时器例程中时将计数器减一，当计数器为0时，表示到达n秒，这个时候可以执行操作。IO定时器只适合处理整数秒的情况在使用IO定时器之前需要对定时器进行初始化，初始化函数为IoInitializeTimer，定义如下：NTSTATUS IoInitializeTimer( IN PDEVICE_OBJECT DeviceObject, //设备对象指针 IN PIO_TIMER_ROUTINE TimerRoutine,//定时器例程 IN PVOID Context//传给定时器例程的函数 );初始化完成后可以使用IoStartTimer来启动定时器，使用IoStopTimer来停止定时器，下面是一个例子#define PAGEDCODE code_seg("PAGE") #define LOCKEDCODE code_seg() #define INITCODE code_seg("INIT") #define PAGEDDATA data_seg("PAGE") #define LOCKEDDATA data_seg() #define INITDATA data_seg("INIT") typedef struct _tag_DEVICE_EXTENSION { PDEVICE_OBJECT DeviceObject; UNICODE_STRING uDeviceName; UNICODE_STRING uSymbolickName; LONG lTimerCount; //定时器触发时间，以秒为单位 }DEVICE_EXTENSION, *PDEVICE_EXTENSION; NTSTATUS DriverEntry(DRIVER_OBJECT *DriverObject, PUNICODE_STRING RegistryPath) { NTSTATUS status; LONG i; PDEVICE_OBJECT pDeviceObject; UNREFERENCED_PARAMETER(RegistryPath); DriverObject->DriverUnload = DriverUnload; //设置派遣函数，这些代码在这就省略了 status = CreateDevice(DriverEntry, &pDeviceObject); IoStartTimer(pDeviceObject); return status; } #pragma LOCKEDCODE VOID IoTimer(DEVICE_OBJECT *DeviceObject,PVOID Context) { LONG ret; PDEVICE_EXTENSION pDeviceExtension; UNICODE_STRING uProcessName; PEPROCESS pCurrProcess; UNREFERENCED_PARAMETER(Context); pDeviceExtension = (PDEVICE_EXTENSION)(DeviceObject->DeviceExtension); ASSERT(NULL != pDeviceExtension); //采用互锁操作将定时器数减一 InterlockedDecrement(&pDeviceExtension->lTimerCount); //判断当前时间是否到达3秒 ret = InterlockedCompareExchange(&pDeviceExtension->lTimerCount, TIME_OUT, 0); if(0 == ret) { DbgPrint("3s time out\n"); } pCurrProcess = IoGetCurrentProcess(); RtlInitUnicodeString(&uProcessName, (PTSTR)((ULONG)pCurrProcess + 0x174)); DbgPrint("the current process %wZ", uProcessName); } #pragma INITCODE NTSTATUS CreateDevice(PDRIVER_OBJECT pDriverObject,PDEVICE_OBJECT *ppDeviceObject) { NTSTATUS status; UNICODE_STRING uDeviceName; UNICODE_STRING uSymbolickName; PDEVICE_EXTENSION pDeviceExtension; RtlInitUnicodeString(&uDeviceName, DEVICE_NAME); RtlInitUnicodeString(&uSymbolickName, SYMBOLICK_NAME); if(NULL != ppDeviceObject) { //创建设备对象并填充设备扩展中的变量 ... IoInitializeTimer(*ppDeviceObject, IoTimer, NULL); status = IoCreateSymbolicLink(&uSymbolickName, &uDeviceName); if(!NT_SUCCESS(status)) { //出错的话就做一些清理工作 ... return status; } if(NULL != pDeviceExtension) { RtlInitUnicodeString(&pDeviceExtension->uSymbolickName, SYMBOLICK_NAME); } return status; } return STATUS_UNSUCCESSFUL; }需要注意的是IO定时器例程是位于DISPATCH_LEVEL，所以它不能使用分页内存，所以在函数前加上一句#pragma LOCKEDCODE，表示它在非分页内存中DPC定时器DPC定时器相比IO定时器来说更加灵活，它可以指定任何时间间隔。DPC内部使用KTIMER这个内核对象进行定时，每当时间到达设置的时间，那么系统就会将对应的DPC例程加入到DPC队列中，当系统读取DPC队列时，这个DPC例程就会被执行，使用DPC定时器的步骤一般是：分别调用KeInitializeTimer和KeInitializeDpc初始化KTIMER对象和DPC对象用KeSetTimer开启定时器在DPC例程中再次调用KeSetTimer开启定时器调用KeCancelTimer关闭定时器由于每次执行KeSetTimer都只会触发一次DPC例程，所以如果想要周期性的调用DPC例程，需要在DPC例程中再次调用KeSetTimer。这些函数的定义如下:VOID KeInitializeDpc( IN PRKDPC Dpc, //DPC对象 IN PKDEFERRED_ROUTINE DeferredRoutine, //DPC例程 IN PVOID DeferredContext//传给DPC例程的参数 ); BOOLEAN KeSetTimer( IN PKTIMER Timer,//定时器 IN LARGE_INTEGER DueTime, //隔多久触发这个DPC例程，这个值是正数则表示从1601年1月1日到触发这个DPC例程所经历的时间，为负数，则表示从当前时间，间隔多长时间后触发，单位为100ns IN PKDPC Dpc OPTIONAL //传入上面初始化的DPC对象 );下面是一个使用的例子typedef struct _tag_DEVICE_EXTENSION { PDEVICE_OBJECT pDeviceObj; UNICODE_STRING uDeviceName; UNICODE_STRING uSymbolickName; KTIMER timer; KDPC Dpc; }DEVICE_EXTENSION, *PDEVICE_EXTENSION; NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObject, PUNICODE_STRING pRegistryPath) { PDEVICE_EXTENSION pDeviceExtension; PDEVICE_OBJECT pDeviceObj; int i; NTSTATUS status; LARGE_INTEGER time_out; UNREFERENCED_PARAMETER(pRegistryPath); pDriverObject->DriverUnload = DriverUnload; //设置派遣函数 ... status = CreateDevice(pDriverObject, &pDeviceObj); //失败处理 ... //设置定时器 time_out.QuadPart = -1 * 10000000; //1s = 1000000000ns status = KeSetTimer(&pDeviceExtension->timer,time_out, &pDeviceExtension->Dpc); return STATUS_SUCCESS; } VOID DriverUnload(PDRIVER_OBJECT pDriverObject) { //该函数主要用来清理相关资源 ... } NTSTATUS DefauleDispatch(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp) { //默认返回成功 } NTSTATUS CreateDevice(PDRIVER_OBJECT pDriverObj, PDEVICE_OBJECT *ppDeviceObj) { PDEVICE_EXTENSION pDevEx; PDEVICE_OBJECT pDevObj; UNICODE_STRING uDeviceName; UNICODE_STRING uSymbolicName; NTSTATUS status; //创建设备对象，填充扩展设备内容 ... //初始化KTIMER DPC KeInitializeTimer(&pDevEx->timer); KeInitializeDpc(&pDevEx->Dpc, TimerDpc, pDevObj); //设置连接符号 ... return STATUS_SUCCESS; } VOID TimerDpc( __in struct _KDPC *Dpc, __in_opt PVOID DeferredContext, __in_opt PVOID SystemArgument1, __in_opt PVOID SystemArgument2 ) { static int i = 0; PTSTR pProcessName; PEPROCESS pEprocess; LARGE_INTEGER time_out; PDEVICE_OBJECT pDevObj = (PDEVICE_OBJECT)DeferredContext; PDEVICE_EXTENSION pDevEx = (PDEVICE_EXTENSION)(pDevObj->DeviceExtension); ASSERT(NULL != pDevObj); pEprocess = PsGetCurrentProcess(); pProcessName = (PTSTR)((ULONG)pEprocess + 0x174); DbgPrint("%d Call TimerDpc, Process: %s\n", i, pProcessName); time_out.QuadPart = -1 * 10000000; //1s = 1000000000ns KeSetTimer(&pDevEx->timer, time_out, &pDevEx->Dpc); i++; }