关于内核定时器,DPC,线程的使用

最新推荐文章于 2023-04-12 17:13:18 发布
最新推荐文章于 2023-04-12 17:13:18 发布
阅读量2.6k 收藏
点赞数
[cpp]  view plain  copy
  1. 关于内核定时器，及DPC的使用，看来一些代码，这个估计是比较规范的用法了，很基础，希望对新手有帮助  
  2. 注意，这里的定时器不太精确！  
[cpp]  view plain  copy
  1. #include <ntddk.h>  
  2. typedef struct _DEVICE_EXTENSION {  
  3.       
  4.     LIST_ENTRY      list_head;  
  5.     KSPIN_LOCK      list_lock;      
  6.     PVOID           thread_pointer;  
  7.     BOOLEAN            terminate_thread;      
  8.     KEVENT          request_event;  
  9.     KTIMER            my_timer;  
  10.     KDPC            KiTimerExpireDpc;      
  11. } DEVICE_EXTENSION, *PDEVICE_EXTENSION;  
  12. #define dprintf if (DBG) DbgPrint  
  13. #define nprintf DbgPrint  
  14. #define DEVICE_NAME L"\\Device\\devhello" // Driver Name  
  15. #define LINK_NAME L"\\DosDevices\\hello"  // Link Name  
  16. //  
  17. // The device driver IOCTLs  
  18. //  
  19. #define IOCTL_BASE    0x800  
  20. #define MY_CTL_CODE(i) \  
  21. CTL_CODE(FILE_DEVICE_UNKNOWN, IOCTL_BASE+i, METHOD_BUFFERED, FILE_ANY_ACCESS)  
  22. #define IOCTL_HELLO    MY_CTL_CODE(0)  
  23. /  
  24. //函数声明  
  25. NTSTATUS DriverEntry(PDRIVER_OBJECT pDriverObj, PUNICODE_STRING pRegistryString);  
  26. NTSTATUS DispatchCreate(PDEVICE_OBJECT pDevObj, PIRP pIrp);  
  27. NTSTATUS DispatchClose(PDEVICE_OBJECT pDevObj, PIRP pIrp);  
  28. VOID     DriverUnload(PDRIVER_OBJECT pDriverObj);  
  29. NTSTATUS DispatchIoctl(PDEVICE_OBJECT pDevObj, PIRP pIrp);  
  30. VOID  
  31. KiTimerExpirationFunction (  
  32.                            IN struct _KDPC  *Dpc,  
  33.                            IN PVOID  DeferredContext,  
  34.                            IN PVOID  SystemArgument1,  
  35.                            IN PVOID  SystemArgument2  
  36.                            );  
  37. NTSTATUS ThreadFunc ( IN PVOID Context);  
  38. /  
  39.   
  40. NTSTATUS   
  41. DriverEntry(  
  42.     PDRIVER_OBJECT pDriverObj,   
  43.     PUNICODE_STRING pRegistryString  
  44.     )  
  45. {  
  46.     NTSTATUS status = STATUS_SUCCESS;  
  47.     UNICODE_STRING ustrLinkName;  
  48.     UNICODE_STRING ustrDevName;      
  49.     PDEVICE_OBJECT device_object;  
  50.     PDEVICE_EXTENSION device_extension;  
  51.     HANDLE  thread_handle;  
  52. /* 
  53.     在驱动中是以100纳秒为单位的 
  54.     1000纳秒=1微秒 
  55.     1000微秒=1毫秒 
  56.     1000毫秒=1秒    10*1000*1000 
  57. */  
  58.     LARGE_INTEGER duetime = {0};  
  59.     #define POLLING_INTERVAL 3000  
  60.     dprintf("[hello] DriverEntry\n");  
  61.       
  62.     pDriverObj->MajorFunction[IRP_MJ_CREATE] = DispatchCreate;  
  63.     pDriverObj->MajorFunction[IRP_MJ_CLOSE] = DispatchClose;  
  64.     pDriverObj->MajorFunction[IRP_MJ_DEVICE_CONTROL] = DispatchIoctl;  
  65.     pDriverObj->DriverUnload = DriverUnload;  
  66.   
  67.     RtlInitUnicodeString(&ustrDevName, DEVICE_NAME);  
  68.     status = IoCreateDevice(pDriverObj,   
  69.                 sizeof(DEVICE_EXTENSION),  
  70.                 &ustrDevName,   
  71.                 FILE_DEVICE_UNKNOWN,  
  72.                 0,  
  73.                 FALSE,  
  74.                 &device_object);  
  75.     if(!NT_SUCCESS(status))    {  
  76.         dprintf("[hello] IoCreateDevice = 0x%x\n", status);  
  77.         return status;  
  78.     }  
  79.     RtlInitUnicodeString(&ustrLinkName, LINK_NAME);  
  80.     status = IoCreateSymbolicLink(&ustrLinkName, &ustrDevName);   
  81.       
  82.     if(!NT_SUCCESS(status)) {  
  83.         dprintf("[hello] IoCreateSymbolicLink = 0x%x\n", status);  
  84.         IoDeleteDevice(device_object);    
  85.         return status;  
  86.     }  
  87.     device_extension = (PDEVICE_EXTENSION) device_object->DeviceExtension;  
  88.     InitializeListHead(&device_extension->list_head);      
  89.     KeInitializeSpinLock(&device_extension->list_lock);  
  90.       
  91.     KeInitializeEvent(    &device_extension->request_event,  
  92.         NotificationEvent,  
  93.                          FALSE);  
  94. //    KeInitializeTimer(&my_timer);//这是个旧的函数  
  95.     KeInitializeTimerEx(&device_extension->my_timer, NotificationTimer);  
  96.     // 初始化定时器过期的DPC对象    
  97.     KeInitializeDpc(&device_extension->KiTimerExpireDpc,  
  98.     (PKDEFERRED_ROUTINE)KiTimerExpirationFunction, (PVOID) device_object);  
  99. //    KeSetTimer(&my_timer,timeout,&KiTimerExpireDpc); 仅仅只能设置一次  
  100. //    KeSetTimerEx(&my_timer, timeout, period, &KiTimerExpireDpc);这个可以循环设置  
  101.     KeSetTimerEx(&device_extension->my_timer, duetime, POLLING_INTERVAL, &device_extension->KiTimerExpireDpc);    
  102. //    KeSetTimerEx语句启动周期定时器。由于duetime参数是0，  
  103. //    所以定时器立即进入信号态。  
  104. //  然后每隔POLLING_INTERVAL=3秒触发一次。  
  105.     device_extension->terminate_thread = FALSE;  
  106.       
  107.     status = PsCreateSystemThread(  
  108.         &thread_handle,  
  109.         (ACCESS_MASK) 0L,  
  110.         NULL,  
  111.         NULL,  
  112.         NULL,  
  113.         ThreadFunc,  
  114.         device_object  
  115.         );  
  116.     if (!NT_SUCCESS(status))  
  117.     {  
  118.         IoDeleteDevice(device_object);  
  119.         return status;  
  120.     }  
  121.       
  122.     status = ObReferenceObjectByHandle(  
  123.         thread_handle,  
  124.         THREAD_ALL_ACCESS,  
  125.         NULL,  
  126.         KernelMode,  
  127.         &device_extension->thread_pointer,  
  128.         NULL  
  129.         );  
  130.       
  131.     if (!NT_SUCCESS(status))  
  132.     {  
  133.         ZwClose(thread_handle);  
  134.         device_extension->terminate_thread = TRUE;//如果出错就关闭创建的线程  
  135.           
  136.         KeSetEvent(  
  137.             &device_extension->request_event,  
  138.             (KPRIORITY) 0,  
  139.             FALSE  
  140.             );  
  141.         IoDeleteDevice(device_object);      
  142.         return status;  
  143.     }  
  144.       
  145.     ZwClose(thread_handle);  
  146.     return STATUS_SUCCESS;  
  147. }  
  148. VOID  
  149. KiTimerExpirationFunction (  
  150.            IN struct _KDPC  *Dpc,  
  151.            IN PVOID  DeferredContext,  
  152.            IN PVOID  SystemArgument1,  
  153.            IN PVOID  SystemArgument2  
  154.            )  
  155. {      
  156. PDEVICE_OBJECT pDevObj = (PDEVICE_OBJECT)DeferredContext;  
  157. PDEVICE_EXTENSION device_extension = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;  
  158. //kesetevent 必需在较低级别用  
  159. //ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);  
  160. //dprintf("level in timer function  is %x\n",KeGetCurrentIrql());  
  161. dprintf("haha dpc function work\n");  
  162. KeSetEvent(&device_extension->request_event,  
  163.             (KPRIORITY) 0,  
  164.             FALSE);  
  165. };  
  166. NTSTATUS ThreadFunc ( IN PVOID Context)  
  167. {   
  168.     PFILE_OBJECT ConnectionFileObject, AddressFileObject;   
  169.     HANDLE AddressHandle, ConnectionHandle;   
  170.     NTSTATUS Status;   
  171.     IO_STATUS_BLOCK IoStatus;  
  172.     KEVENT Event;  
  173.     PDEVICE_OBJECT      device_object;  
  174.     PDEVICE_EXTENSION   device_extension;  
  175.     device_object = (PDEVICE_OBJECT) Context;  
  176.     device_extension = (PDEVICE_EXTENSION) device_object->DeviceExtension;  
  177.       
  178.     KeSetPriorityThread(KeGetCurrentThread(), LOW_REALTIME_PRIORITY);  
  179. //****************************  
  180. //****************************  
  181. //开始工作   此处用2重循环，你可以添加实际的代码  
  182. for (;;)  
  183. {      
  184.     do   
  185.     {  
  186.        dprintf("thread work ok !!\n");  
  187.        goto failselabel;  
  188.       } while (TRUE);  
  189. failselabel:  
  190.    KeWaitForSingleObject(  
  191.        &device_extension->request_event,  
  192.        Executive,  
  193.        KernelMode,  
  194.        FALSE,  
  195.        NULL  
  196.        );//在这儿等  
  197.     //KeClearEvent(&Event);//清除一下试试  
  198.            //killvxk 2007-01-31 11:18   
  199.     //严重提醒不要使用KeClearEvent(&Event);   
  200.     //如果你还要用那个事件就不要用那个Clear,要其它手段~如果你不需要那个event了，  
  201.            //那你应该在thread里判断下~   
  202.    KeResetEvent(&device_extension->request_event);  
  203.    if (  device_extension->terminate_thread )  
  204.     {  
  205.       PsTerminateSystemThread(STATUS_SUCCESS);  
  206.     }  
  207. }  
  208. dprintf("never be here !\n");  
  209.     return Status;   
  210. }  
  211.   
  212. VOID   
  213. DriverUnload(  
  214.     PDRIVER_OBJECT pDriverObj  
  215.     )  
  216. {      
  217.     PDEVICE_EXTENSION   device_extension;  
  218.     UNICODE_STRING strLink;  
  219.     RtlInitUnicodeString(&strLink, LINK_NAME);  
  220.     device_extension = (PDEVICE_EXTENSION) pDriverObj->DeviceObject->DeviceExtension;  
  221. //停止创建的线程  
  222.     if (KeCancelTimer(&device_extension->my_timer) == FALSE)  
  223.     {  
  224.         //    KeCancelTimer(&device_extension->my_timer);//取消定时器  
  225.         dprintf( " no timer active at terminate\n");  
  226.     }  
  227.     device_extension->terminate_thread = TRUE;//停止线程  
  228.     KeSetEvent(  
  229.         &device_extension->request_event,  
  230.         (KPRIORITY) 0,  
  231.         FALSE  
  232.         );  
  233.     KeWaitForSingleObject(  
  234.         device_extension->thread_pointer,//等待线程对象结束,注意哦，是对象  
  235.         Executive,  
  236.         KernelMode,  
  237.         FALSE,  
  238.         NULL  
  239.         );  
  240.     ObDereferenceObject(device_extension->thread_pointer);  
  241.     IoDeleteSymbolicLink(&strLink);  
  242.     IoDeleteDevice(pDriverObj->DeviceObject);  
  243.     dprintf("[hello] Unloaded\n");  
  244. }  
  245.   
  246. NTSTATUS   
  247. DispatchCreate(  
  248.     PDEVICE_OBJECT pDevObj,   
  249.     PIRP pIrp  
  250.     )  
  251. {  
  252.     pIrp->IoStatus.Status = STATUS_SUCCESS;  
  253.     pIrp->IoStatus.Information = 0;  
  254.     dprintf("[hello] IRP_MJ_CREATE\n");  
  255.     IoCompleteRequest(pIrp, IO_NO_INCREMENT);  
  256.     return STATUS_SUCCESS;  
  257. }  
  258.   
  259. NTSTATUS   
  260. DispatchClose(  
  261.     PDEVICE_OBJECT pDevObj,   
  262.     PIRP pIrp  
  263.     )  
  264. {  
  265.     pIrp->IoStatus.Status = STATUS_SUCCESS;  
  266.     pIrp->IoStatus.Information = 0;  
  267.     dprintf("[hello] IRP_MJ_CLOSE\n");  
  268.     IoCompleteRequest(pIrp, IO_NO_INCREMENT);  
  269.     return STATUS_SUCCESS;  
  270. }  
  271.   
  272. NTSTATUS   
  273. DispatchIoctl(  
  274.     PDEVICE_OBJECT pDevObj,   
  275.     PIRP pIrp  
  276.     )  
  277. {  
  278.     NTSTATUS status = STATUS_INVALID_DEVICE_REQUEST;  
  279.     PIO_STACK_LOCATION pIrpStack;  
  280.     ULONG uIoControlCode;  
  281.     PVOID pIoBuffer;  
  282.     ULONG uInSize;  
  283.     ULONG uOutSize;  
  284.     pIrpStack = IoGetCurrentIrpStackLocation(pIrp);  
  285.     uIoControlCode = pIrpStack->Parameters.DeviceIoControl.IoControlCode;  
  286.     pIoBuffer = pIrp->AssociatedIrp.SystemBuffer;  
  287.     uInSize = pIrpStack->Parameters.DeviceIoControl.InputBufferLength;  
  288.     uOutSize = pIrpStack->Parameters.DeviceIoControl.OutputBufferLength;  
  289.     switch(uIoControlCode) {  
  290.         case IOCTL_HELLO: {  
  291.               
  292.             dprintf("[hello] Hello\n");  
  293.             status = STATUS_SUCCESS;  
  294.         }  
  295.         break;  
  296.     }  
  297.     if(status == STATUS_SUCCESS)  
  298.         pIrp->IoStatus.Information = uOutSize;  
  299.     else  
  300.         pIrp->IoStatus.Information = 0;  
  301.       
  302.     /  
  303.     pIrp->IoStatus.Status = status;  
  304.     IoCompleteRequest(pIrp, IO_NO_INCREMENT);  
  305.     return status;  
  306. }  
kingswb
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
DPC计时器
qinqin772的博客
01-03 709
DPC计时器，是除了IO计时器的另一种内核方式的计时器技术，它能实现比IO计时器（秒级别）更加细微级别的时间间隔，   实现DPC 计时器所需要的函数 KeInitializeTimer,KeInitializeDpc,KeSetTimer #include KTIMER kTimer = { 0 }; KDPC dpc1 = { 0 }; KDPC dpc2 = { 0 }; VOID
Delphi驱动开发研究之内核同步对象—线程与定时器
08-26 931
本篇及下篇教程我们将讲述内核同步对象。同步是一个涉及面非常广的主题，系统提供了多种同步对象，因此两篇文章也仅能让您对其有个大致的了解。 10.1 同步对象 迄今为止，我们都不需要独占访问某个数据，因为我们仅有一个线程在工作。当有两个或多个线程都需要访问同一个资源时，就需要引入
DPC定时器
dengjiatao9832的博客
09-21 147
KeInitializeTimer 初始化定时器 KeInitializeTimerEx 初始化定时器 KeSetTimer 开启定时器(只执行一次) KeSetTimerEx 开启定时器(可以设置循环) KeInitializeDpc 初始化DPC对象 KeCancelTimer 取消定时器 在驱动中是以100纳秒为单位的 100...
x64 驱动 创建 dpc 定时器
LYSM
07-06 418
初始化 KTIMER my_timer; KDPC KiTimerExpireDpc; KTIMER: typedef struct _KTIMER { DISPATCHER_HEADER Header; ULARGE_INTEGER DueTime; LIST_ENTRY TimerListEntry; struct _KDPC *Dpc; #if !defined(KENCODED_TIMER_PROCESSOR) ULONG Processor; #en
内核定时器的用法及原理
Android开发
07-12 834
内核定时器timer的使用demo #include <linux/init.h> #include <linux/module.h> #include <linux/timer.h> #include <linux/rtc.h> #define SHOW_DL_TIME #define WAY1 //#define WAY2 //#d...
Windows内核驱动中的定时器和时钟管理
本文将深入探讨定时器和时钟在Windows内核驱动中的作用，以及它们的基本原理、使用方法和应用场景。 ## 1.2 定时器和时钟在Windows内核中的作用 定时器和时钟在Windows内核中扮演着重要角色： - 定时器：用于在...
时钟与定时器在内核编程中的应用
时钟和定时器的基础知识 1.1 时钟和定时器的概念介绍 时钟和定时器在计算机系统中扮演着至关重要的角色。时钟通常用来跟踪时间的流逝，提供系统时间信息。而定时器则用于在特定时间间隔内触发某些操作或事件。...
Windows系统的线程调度与软件中断分发
lziog的专栏
08-29 2586
在Windows操作系统内核把软件中断分为三个中断级别：DISPATCH_LEVEL，APC_LEVEL，PASSVIE_LEVEL。同时他们与线程的调试相关，WINDOWS内核中没有一个专门的程序来做线程的调度工作，它是散落在系统各个部分的。总结一下主要以下几种情况。
windows内核原理分析之DPC函数的执行（3）
yushui的笔记本
06-04 2169
windows内核原理分析之DPC函数的执行（3）windows内核什么时候会扫描DPC请求队列，执行这些DPC函数呢？答案是，每当CPU的运行级别从DISPATCH_LEVEL或以上降低到DISPATCH_LEVEL以下时，如果有扫描DPC请求队列的要求存在，内核就会扫描DPC请求队列并执行DPC函数（如果队列非空的话）。为此，我们不妨从宏操作KeLowerIrql()开始往下看。#define
驱动开发：内核枚举DpcTimer定时器
CSDN
10-16 1万+
在笔者上一篇文章`《驱动开发：内核枚举IoTimer定时器》`中我们通过`IoInitializeTimer`这个API函数为跳板，向下扫描特征码获取到了`IopTimerQueueHead`也就是IO定时器的队列头，本章学习的枚举DPC定时器依然使用特征码扫描，唯一不同的是在新版系统中DPC是被异或加密的，想要找到正确的地址，只是需要在找到DPC表头时进行解密操作即可。
内核dpc定时器
最新发布
sanfenlu的专栏
04-12 799
另外，应用程序每次取声音的数据量是根据系统的声音设置而定的，系统声音设置“录制”属性中设置44100每次取1764，设置48000每次取1920。默认值是第一次安装驱动中的接口而定的。应用程序每次只请求1764个字节，每一个中断对应有1920个字节，这样每一个中断就会在驱动中累积156个字节而导致数据在驱动中溢出。总数据量：48000*2*2＝192000，应用程序每次请求1920个字节，驱动中的CELL刚好也是1920，这样就每一个中断往应用层写入一次，每秒刚好有100个中断（192000/1920）。
x64枚举DPC定时器
07-31 405
@写在前面 不同于x86，x64的DPC是被加密了的。对于x64DPC的兴趣始于我已经流产的scalpel计划。当时问某牛怎么遍历，得到的答案是“500大洋给代码”。真是R了狗了，好歹小哥我也是搞技术的，自己搞吧。 PS：这个代码编辑功能。。。醉的不行了。 @前言 在早期的x86系统上面，DPCTimer都是裸奔的，直接用过已导出的KiTimerTa...
x64驱动遍历 DPC 定时器
LYSM
05-22 779
目的 拿到类似于 PChunter 中的信息： 过程 首先，要拿到系统的 _KPRCB ，也就是 KiProcessorBlock 的地址： 我这里显示了 4 地址，这是因为我的 CPU 是 4 核 —— （垃圾电脑勿喷） 对于 KiProcessorBlock 这个 API , Windows 没有导出： 但是可以通过另一种办法获取到这个地址： // 获取特殊寄存器中的值，拿 _KPRCB ULONG64 PrcbAddress = (ULONG64)__readmsr(0xC0000101)
驱动开发：内核使用IO/DPC定时器
热门推荐
CSDN
04-04 1万+
本章将继续探索驱动开发中的基础部分，定时器在内核中同样很常用，在内核中定时器可以使用两种，即IO定时器，以及DPC定时器，一般来说IO定时器是DDK中提供的一种，该定时器可以为间隔为N秒做定时，但如果要实现毫秒级别间隔，微秒级别间隔，就需要用到DPC定时器，如果是秒级定时其两者基本上无任何差异，本章将简单介绍。编译并运行这段程序，会发现其运行后的定时效果与IO定时器并无太大区别，但是DPC可以控制更精细，通过。函数对定时器进行初始化，但需要注意的是此函数每个设备对象只能调用一次，当初始化完成后用户可调用。
DPC，时钟中断，以及DPC定时器（1）
Returns' Station
05-18 2045
一、DPC DPC IRQL高于软件中断 低于硬件中断，硬中断之后，用来完成需要延迟处理的额外操作（当然你也可以用来干别的，比如指定运行某个函数的cpu） 存储于KPRCB中，在wrk中是一个有两项的KDPC_DATA数组（多处理器中） 一个是普通的DPC，一个是针对指定线程的DPC（KiExecuteDpc 这个线程优先级最高 0） t
DPC，时间中断，以及DPC定时器（2）
Returns' Station
05-18 2038
二、WRK中的时钟中断和DPC定时器 之前研究过一点应用 http://hi.baidu.com/andriy_aolala/blog/item/5aba868b235d50749f2fb437.html 为了每次时间中断能够搜索较少的链表 来获得定时器 这里引入了哈希表 。按照不同的时间段被分为512项 挂入链表中，每次中断后先计算出一个下标，然后快速找到相应链表 KiTi
Ps回调通知例程、Dpc定时器、内核线程使用方法.
kingswb的博客
05-21 1135
好久没发代码了,发个以前写的东西,代码是照葫芦画瓢来的,共同学习,共同进步,欢迎拍砖. 代码: #ifndef _SAFENOTIFYROUTINE_H #define _SAFENOTIFYROUTINE_H /************************************************************************/ /**************
Windows 2000内核模式时间分析与中断DPC监控
课程涉及使用性能监视器（Performance Monitor）来监控中断处理和DPC（ Deferred Procedure Calls）的时间占比，以及如何诊断系统在内核模式下过度消耗资源的问题。 在Windows 2000系统中，"处理器时间"是指处理器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值