void MyGetTickCount(PULONG msec)
 {
     LARGE_INTEGER tick_count;
     ULONG myinc = KeQueryTimeIncrement();
     //返回每次时钟中断，系统时间增加的纳秒数
     KeQueryTickCount(&tick_count);
     //返回自系统启动以来经历的定时器中断次数
     tick_count.QuadPart *= myinc;
     //计算从系统启动来经历多的总纳秒数（纳秒为一个单位）
     tick_count.QuadPart /= ;
     //转换为毫秒数（/10则取微秒）
     *msec = tick_count.LowPart;
     //取低字节（也可以取整个LAGER_INTEGER，改变传入参数）
 }

 DbgPrint("first: Hello,my salary!");
 ULONG msec1 = 0L;
 ULONG msec2 = 0L;
 MyGetTickCount(&msec1);
 KdPrint(("msec1:%d ms",msec1));
 ; i< ; i++)
 {
     MyGetTickCount(&msec2);
 }
 MyGetTickCount(&msec2);
 KdPrint(("msec2:%d ms",msec2));
 KdPrint((,(msec2-msec1)%));

 PWCHAR MyCurTimeStr()
 {
     LARGE_INTEGER snow,now;
     TIME_FIELDS now_fileds;
     //定义静态变量缓冲区，这里先不考虑多线程隐患
     ] = {};
     //获取标准时间（格林威治时间）
     KeQuerySystemTime(&snow);
     //转换为当地时间
     ExSystemTimeToLocalTime(&snow,&now);
     //转换为可理解要素
     RtlTimeToTimeFields(&now,&now_fileds);
     //格式化到字符串
     RtlStringCchPrintfW(time_str,//缓冲区
         *,//缓冲区长度
         L"%04d-%02d-%02d %02d:%02d:%02d",
         now_fileds.Year,now_fileds.Month,now_fileds.Day,
         now_fileds.Hour,now_fileds.Minute,now_fileds.Second);
     return time_str;
 }

 //内部时钟结构
 typedef struct MY_TIMER_
 {
     KDPC dpc;//dpc
     KTIMER timer;//定时器
     LARGE_INTEGER due;//定时毫秒数
     PKDEFERRED_ROUTINE func;//用户回调函数
     PVOID privete_context;//用户上下文
 }MY_TIMER,*PMY_TIMER;

 BOOLEAN MyTimerInit(PMY_TIMER timer,PKDEFERRED_ROUTINE func);
 BOOLEAN MyTimerSet(PMY_TIMER timer,ULONG msec,PVOID context);
 BOOLEAN MyTimerDestroy(PMY_TIMER timer);
 KDEFERRED_ROUTINE MyOnTimer;

 //初始化内部时钟结构：PMY_TIMER，用户回调函数func
 BOOLEAN MyTimerInit(PMY_TIMER pTimer,PKDEFERRED_ROUTINE func)
 {
     if( !pTimer ) return FALSE;
     //初始化dpc：使用timer->dpc，回调函数TimerProc（内核回调函数）
     //上下文设置为timer(用于传给用户回调函数)
     KeInitializeDpc(&pTimer->dpc,(PKDEFERRED_ROUTINE)TimerProc,pTimer);
     pTimer->func = func;//设置用户自定义回调函数
     //初始化定时器
     KeInitializeTimer(&pTimer->timer);
     return TRUE;
 }

 //让内部时钟结构体的回调函数在n毫秒后执行：PMY_TIMER，定时毫秒数msec，用户上下文context
 BOOLEAN MyTimerSet(PMY_TIMER timer,ULONG msec,PVOID context)
 {
     //定时时间值转换
     //为正时指定相对系统的间隔时间：受系统时间设置影响
     //为负则指定绝对系统时间：为纳秒数，不受系统时间设置影响
     timer->due.QuadPart = -*(LONG)msec;//必须转为有符号类型
     //用户私有上下文
     timer->privete_context = context;
     //添加定时器到系统定时器队列
     return KeSetTimer(&timer->timer,timer->due,&timer->dpc);
 }

 //停止执行
 BOOLEAN MyTimerDestroy(PMY_TIMER pTimer)
 {
     if(pTimer) return KeCancelTimer(&pTimer->timer);
     else return FALSE;
 }

 //定时器回调函数：内核使用
 void TimerProc(struct _KDPC *Dpc,PVOID DeferredContext,PVOID SystemArgument1,PVOID SystemArgument2)
 {
     //这里传入的上下文是timer结构，用来下次再启动延时调用
     PMY_TIMER pTimer = (PMY_TIMER)DeferredContext;

     if(pTimer->func)//用户回调函数
         {
         PKDEFERRED_ROUTINE pFunc = (PKDEFERRED_ROUTINE)pTimer->func;//取得用户定义回调函数指针
         pFunc(Dpc,(PVOID)pTimer->privete_context,SystemArgument1,SystemArgument2);//调用用户定义的回调函数
     }
     else KdPrint(("No callback function !\n"));
     KeSetTimer(&pTimer->timer,pTimer->due,&pTimer->dpc);//再次设置定时器
 }

 #define SIZE 30
 //用户上下文（自定义结构体）
 typedef struct
 {
     WCHAR message[SIZE];
     ULONG times;
 }USER_CONTENT,*PUSER_CONTENT;

 //用户回调函数
 KDEFERRED_ROUTINE TimerProc;

 //定时器回调函数：用户实现（函数名可更改）
 void MyOnTimer(struct _KDPC *Dpc,PVOID DeferredContext,PVOID SystemArgument1,PVOID SystemArgument2)
 {
     //在这里做OnTimer中要做的事，封装的好处就是编码时只关注自己想关注的东西
     PUSER_CONTENT pMyContext = (PUSER_CONTENT)DeferredContext;
     pMyContext->times++;
     KdPrint(("第%d次调用定时器：%ws",pMyContext->times,pMyContext->message));
 }

 MY_TIMER timer;
 USER_CONTENT MyContent;
 ULONG i = ;

 //用户自定义结构
 RtlStringCbPrintfW((NTSTRSAFE_PWSTR)&MyContent.message,SIZE*sizeof(WCHAR),L"Hello Timer!");//格式串
 MyContent.times = ;//计数值

 //初始化定时器
 MyTimerInit(&timer,(PKDEFERRED_ROUTINE)MyOnTimer);

 //启动定时器
 MyTimerSet(&timer,,(PVOID)&MyContent);

 //等待一段时间
 *10E8 );

 //关闭定时器
 MyTimerDestroy(&timer);
 KdPrint(("定时器已经停止！"));