Timer和DPC

一般两种方法使用/设置定时器，一种是使用I/O定时器例程，一种是使用DPC例程。
1、定时器的实现
1）使用I/O定时器例程
NTSTATUS
IoInitializeTimer(
IN PDEVICE_OBJECT DeviceObject,
IN PIO_TIMER_ROUTINE TimerRoutine,
IN PVOID Context
);
IoStartTimer
IoStopTimer
开启定时器后，每隔1s系统调用一次定时器例程。TimerRoutine运行在DISPATCH_LEVEL级别，因此不能有分页内存。另外I/O定时器是运行在任意线程的，不能直接使用应用程序的内存地址。

1 // .h
2 //设定3秒间隔时间
3 #define TIMER_OUT    3
4
5 typedef struct _DEVICE_EXTENSION {
6     PDEVICE_OBJECT pDevice;
7     UNICODE_STRING ustrDeviceName;    //设备名称
8      UNICODE_STRING ustrSymLinkName;    //符号链接名
9
10     LONG lTimerCount;
11 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
12 //.cpp
13 #pragma LOCKEDCODE
14 VOID OnTimer(
15     IN PDEVICE_OBJECT DeviceObject,
16     IN PVOID Context)
17 {
18     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
19         DeviceObject->DeviceExtension;
20     KdPrint(("Enter OnTimer!\n"));
21
22     //将计数器自锁减一
23     InterlockedDecrement(&pDevExt->lTimerCount);
24
25     //如果计数器减到0，重新编程TIMER_OUT，整个过程是互锁运算
26     LONG previousCount = InterlockedCompareExchange(&pDevExt->lTimerCount,TIMER_OUT,0);
27
28     //每隔三秒，计数器一个循环，输出以下log
29     if (previousCount==0)
30     {
31         KdPrint(("%d seconds time out!\n",TIMER_OUT));
32     }
33
34     //证明该线程运行在任意线程上下文的
35     PEPROCESS pEProcess = IoGetCurrentProcess();
36
37     PTSTR ProcessName = (PTSTR)((ULONG)pEProcess + 0x174);//即可得到用户进程
38
39     KdPrint(("The current process is %s\n",ProcessName));
40 }
41
42
43 /************************************************************************
44 * 函数名称:CreateDevice
45 * 功能描述:初始化设备对象
46 * 参数列表:
47       pDriverObject:从I/O管理器中传进来的驱动对象
48 * 返回值:返回初始化状态
49 *************************************************************************/
50 #pragma INITCODE
51 NTSTATUS CreateDevice (
52         IN PDRIVER_OBJECT    pDriverObject)
53 {
54     NTSTATUS status;
55     PDEVICE_OBJECT pDevObj;
56     PDEVICE_EXTENSION pDevExt;
57
58     //创建设备名称
59     UNICODE_STRING devName;
60     RtlInitUnicodeString(&devName,L"\\Device\\MyDDKDevice");
61
62     //创建设备
63     status = IoCreateDevice( pDriverObject,
64                         sizeof(DEVICE_EXTENSION),
65                         &(UNICODE_STRING)devName,
66                         FILE_DEVICE_UNKNOWN,
67                         0, TRUE,
68                         &pDevObj );
69     if (!NT_SUCCESS(status))
70         return status;
71
72     pDevObj->Flags |= DO_DIRECT_IO;
73     pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
74     pDevExt->pDevice = pDevObj;
75     pDevExt->ustrDeviceName = devName;
76
77     IoInitializeTimer(pDevObj,OnTimer,NULL);
78
79     //创建符号链接
80     UNICODE_STRING symLinkName;
81     RtlInitUnicodeString(&symLinkName,L"\\??\\HelloDDK");
82     pDevExt->ustrSymLinkName = symLinkName;
83     status = IoCreateSymbolicLink( &symLinkName,&devName );
84     if (!NT_SUCCESS(status))
85     {
86         IoDeleteDevice( pDevObj );
87         return status;
88     }
89     return STATUS_SUCCESS;
90 }
91 #pragma PAGEDCODE
92 NTSTATUS HelloDDKDeviceIOControl(IN PDEVICE_OBJECT pDevObj,
93                                  IN PIRP pIrp)
94 {
95     NTSTATUS status = STATUS_SUCCESS;
96     KdPrint(("Enter HelloDDKDeviceIOControl\n"));
97
98     //得到当前堆栈
99     PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
100     //得到输入缓冲区大小
101     ULONG cbin = stack->Parameters.DeviceIoControl.InputBufferLength;
102     //得到输出缓冲区大小
103     ULONG cbout = stack->Parameters.DeviceIoControl.OutputBufferLength;
104     //得到IOCTL码
105     ULONG code = stack->Parameters.DeviceIoControl.IoControlCode;
106
107     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
108         pDevObj->DeviceExtension;
109
110     ULONG info = 0;
111
112     switch (code)
113     {                        // process request
114         case IOCTL_START_TIMER:
115         {
116             KdPrint(("IOCTL_START_TIMER\n"));
117             pDevExt->lTimerCount = TIMER_OUT;
118             IoStartTimer(pDevObj);
119             break;
120         }
121         case IOCTL_STOP:
122         {
123             KdPrint(("IOCTL_STOP\n"));
124             IoStopTimer(pDevObj);
125             break;
126         }
127         default:
128             status = STATUS_INVALID_VARIANT;
129     }
130
131     // 完成IRP
132     pIrp->IoStatus.Status = status;
133     pIrp->IoStatus.Information = info;    // bytes xfered
134     IoCompleteRequest( pIrp, IO_NO_INCREMENT );
135
136     KdPrint(("Leave HelloDDKDeviceIOControl\n"));
137
138     return status;
139 }

1 #include <windows.h>
2 #include <stdio.h>
3 //使用CTL_CODE必须加入winioctl.h
4 #include <winioctl.h>
5 #include "..\NT_Driver\Ioctls.h"
6
7 int main()
8 {
9     HANDLE hDevice =
10         CreateFile("\\\\.\\HelloDDK",
11                     GENERIC_READ | GENERIC_WRITE,
12                     0,        // share mode none
13                     NULL,    // no security
14                     OPEN_EXISTING,
15                     FILE_ATTRIBUTE_NORMAL,
16                     NULL );        // no template
17
18     if (hDevice == INVALID_HANDLE_VALUE)
19     {
20         printf("Failed to obtain file handle to device: "
21             "%s with Win32 error code: %d\n",
22             "MyWDMDevice", GetLastError() );
23         return 1;
24     }
25
26     DWORD dwOutput;
27
28     DeviceIoControl(hDevice, IOCTL_START_TIMER, NULL, 0, NULL, 0, &dwOutput, NULL);
29
30     Sleep(10000);
31
32      DeviceIoControl(hDevice, IOCTL_STOP, NULL, 0, NULL, 0, &dwOutput, NULL);
33
34     CloseHandle(hDevice);
35
36     return 0;
37 }

示例代码 P278

2）使用DPC例程
DPC定时器内部使用定时器对象KTIMER，当指定的时间间隔到达后，OS会将一个DPC例程插入DPC队列。
KeInitializeTimer
KeInitializeDpc
BOOLEAN
KeSetTimer(
IN PKTIMER Timer,
IN LARGE_INTEGER DueTime, //设定时间间隔
IN PKDPC Dpc OPTIONAL
);
如果DueTime为正数，则该时间表示从1601/01/01到触发DPC例程的那个时刻，单位是100ns，如果为负数，意味着间隔多长时间，单位也是100ns。
在调用KeSetTimer后，触发一次DPC例程，如果想周期触发，则需要在DPC触发后，再次调用KeSetTimer。
KeInitializeDpc

1 //.h
2 //设定3秒间隔时间
3 #define TIMER_OUT    3
4
5 typedef struct _DEVICE_EXTENSION {
6     PDEVICE_OBJECT pDevice;
7     UNICODE_STRING ustrDeviceName;    //设备名称
8     UNICODE_STRING ustrSymLinkName;    //符号链接名
9
10     KDPC pollingDPC;    // 存储DPC对象
11     KTIMER pollingTimer;// 存储计时器对象
12     LARGE_INTEGER pollingInterval;    // 记录计时器间隔时间
13 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
14 //.cpp
15 #pragma LOCKEDCODE
16 VOID PollingTimerDpc( IN PKDPC pDpc,
17                       IN PVOID pContext,
18                       IN PVOID SysArg1,
19                       IN PVOID SysArg2 )
20 {
21     PDEVICE_OBJECT pDevObj = (PDEVICE_OBJECT)pContext;
22     PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
23     KeSetTimer(
24         &pdx->pollingTimer,
25         pdx->pollingInterval,
26         &pdx->pollingDPC );
27     KdPrint(("PollingTimerDpc\n"));
28
29     //检验是运行在任意线程上下文
30     PEPROCESS pEProcess = IoGetCurrentProcess();
31
32     PTSTR ProcessName = (PTSTR)((ULONG)pEProcess + 0x174);
33
34     KdPrint(("%s\n",ProcessName));
35 }
36 /************************************************************************
37 * 函数名称:CreateDevice
38 * 功能描述:初始化设备对象
39 * 参数列表:
40       pDriverObject:从I/O管理器中传进来的驱动对象
41 * 返回值:返回初始化状态
42 *************************************************************************/
43 #pragma INITCODE
44 NTSTATUS CreateDevice (
45         IN PDRIVER_OBJECT    pDriverObject)
46 {
47     NTSTATUS status;
48     PDEVICE_OBJECT pDevObj;
49     PDEVICE_EXTENSION pDevExt;
50
51     //创建设备名称
52     UNICODE_STRING devName;
53     RtlInitUnicodeString(&devName,L"\\Device\\MyDDKDevice");
54
55     //创建设备
56     status = IoCreateDevice( pDriverObject,
57                         sizeof(DEVICE_EXTENSION),
58                         &(UNICODE_STRING)devName,
59                         FILE_DEVICE_UNKNOWN,
60                         0, TRUE,
61                         &pDevObj );
62     if (!NT_SUCCESS(status))
63         return status;
64
65     pDevObj->Flags |= DO_DIRECT_IO;
66     pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
67     pDevExt->pDevice = pDevObj;
68     pDevExt->ustrDeviceName = devName;
69
70     KeInitializeTimer( &pDevExt->pollingTimer );
71
72     KeInitializeDpc( &pDevExt->pollingDPC,
73                         PollingTimerDpc,
74                         (PVOID) pDevObj );
75
76     //创建符号链接
77     UNICODE_STRING symLinkName;
78     RtlInitUnicodeString(&symLinkName,L"\\??\\HelloDDK");
79     pDevExt->ustrSymLinkName = symLinkName;
80     status = IoCreateSymbolicLink( &symLinkName,&devName );
81     if (!NT_SUCCESS(status))
82     {
83         IoDeleteDevice( pDevObj );
84         return status;
85     }
86     return STATUS_SUCCESS;
87 }
88 #pragma PAGEDCODE
89 NTSTATUS HelloDDKDeviceIOControl(IN PDEVICE_OBJECT pDevObj,
90                                  IN PIRP pIrp)
91 {
92     NTSTATUS status = STATUS_SUCCESS;
93     KdPrint(("Enter HelloDDKDeviceIOControl\n"));
94
95     //得到当前堆栈
96     PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
97     //得到输入缓冲区大小
98     ULONG cbin = stack->Parameters.DeviceIoControl.InputBufferLength;
99     //得到输出缓冲区大小
100     ULONG cbout = stack->Parameters.DeviceIoControl.OutputBufferLength;
101     //得到IOCTL码
102     ULONG code = stack->Parameters.DeviceIoControl.IoControlCode;
103
104     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
105         pDevObj->DeviceExtension;
106
107     ULONG info = 0;
108
109     switch (code)
110     {                        // process request
111         case IOCTL_START_TIMER:
112         {
113             KdPrint(("IOCTL_START_TIMER!\n"));
114
115             //从用户模式传进来的超时
116             ULONG ulMircoSeconds = *(PULONG)pIrp->AssociatedIrp.SystemBuffer;
117
118             pDevExt->pollingInterval = RtlConvertLongToLargeInteger( ulMircoSeconds * -10 );
119
120             KeSetTimer(
121                 &pDevExt->pollingTimer,
122                 pDevExt->pollingInterval,
123                 &pDevExt->pollingDPC );
124             break;
125         }
126         case IOCTL_STOP_TIMER:
127         {
128             KdPrint(("IOCTL_STOP_TIMER!\n"));
129
130             KeCancelTimer(&pDevExt->pollingTimer);
131
132             break;
133         }
134         default:
135             status = STATUS_INVALID_VARIANT;
136     }
137
138     // 完成IRP
139     pIrp->IoStatus.Status = status;
140     pIrp->IoStatus.Information = info;    // bytes xfered
141     IoCompleteRequest( pIrp, IO_NO_INCREMENT );
142
143     KdPrint(("Leave HelloDDKDeviceIOControl\n"));
144
145     return status;
146 }
147 //main
148 #include <windows.h>
149 #include <stdio.h>
150 //使用CTL_CODE必须加入winioctl.h
151 #include <winioctl.h>
152 #include "..\NT_Driver\Ioctls.h"
153
154 int main()
155 {
156     HANDLE hDevice =
157         CreateFile("\\\\.\\HelloDDK",
158                     GENERIC_READ | GENERIC_WRITE,
159                     0,        // share mode none
160                     NULL,    // no security
161                     OPEN_EXISTING,
162                     FILE_ATTRIBUTE_NORMAL,
163                     NULL );        // no template
164
165     if (hDevice == INVALID_HANDLE_VALUE)
166     {
167         printf("Failed to obtain file handle to device: "
168             "%s with Win32 error code: %d\n",
169             "MyWDMDevice", GetLastError() );
170         return 1;
171     }
172
173     DWORD dwOutput;
174     DWORD dwMircoSeconds = 1000*1000*2;
175
176     DeviceIoControl(hDevice, IOCTL_START_TIMER, &dwMircoSeconds, sizeof(DWORD), NULL, 0, &dwOutput, NULL);
177
178     Sleep(10000);
179
180      DeviceIoControl(hDevice, IOCTL_STOP_TIMER, NULL, 0, NULL, 0, &dwOutput, NULL);
181
182     CloseHandle(hDevice);
183
184     return 0;
185 }

示例代码 P282

DPC例程运行在DISPATCH_LEVEL级别。
2、等待
1）KeWaitForSingleObject
2）KeDelayExecutionThread 与KeWaitForSingleObject类似，都是强制当前线程进入睡眠状态。
3）KeStallExecutionProcessor 其让CPU处于忙等待，而不是睡眠，类似于自旋锁。浪费CPU时间，不宜超过50us。
4）使用定时器
定时器对象同其它内核对象一样，也有两个状态：激发与未激发态。初始化时未激发态，使用KeSetTimer后，经过指定时间后，变成激发态，可以用KeWaitForSingleObject来进行等待。

1 #pragma PAGEDCODE
2 VOID WaitMicroSecond1(ULONG ulMircoSecond)
3 {
4     KEVENT kEvent;
5
6     KdPrint(("Thread suspends %d MircoSeconds...",ulMircoSecond));
7
8     //初始化一个未激发的内核事件
9     KeInitializeEvent(&kEvent,SynchronizationEvent,FALSE);
10
11     //等待时间的单位是100纳秒，将微秒转换成这个单位
12     //负数代表是从此刻到未来的某个时刻
13     LARGE_INTEGER timeout = RtlConvertLongToLargeInteger(-10*ulMircoSecond);
14
15     //在经过timeout后，线程继续运行
16     KeWaitForSingleObject(&kEvent,
17         Executive,
18         KernelMode,
19         FALSE,
20         &timeout);
21
22     KdPrint(("Thread is running again!\n"));
23 }
24
25 #pragma PAGEDCODE
26 VOID WaitMicroSecond2(ULONG ulMircoSecond)
27 {
28     KdPrint(("Thread suspends %d MircoSeconds...",ulMircoSecond));
29
30     //等待时间的单位是100纳秒，将微秒转换成这个单位
31     //负数代表是从此刻到未来的某个时刻
32     LARGE_INTEGER timeout = RtlConvertLongToLargeInteger(-10*ulMircoSecond);
33
34     //此种方法类似于KeWaitForSingleObject
35     //将当前线程进入睡眠状态，间隔时间到转入运行状态
36     KeDelayExecutionThread(KernelMode,FALSE,&timeout);
37
38     KdPrint(("Thread is running again!\n"));
39 }
40
41 #pragma PAGEDCODE
42 VOID WaitMicroSecond3(ULONG ulMircoSecond)
43 {
44     KdPrint(("Thread suspends %d MircoSeconds...",ulMircoSecond));
45
46     //忙等待，此种方法属于忙等待，比较浪费CPU时间
47     //因此使用该方法不宜超过50微秒
48     KeStallExecutionProcessor(ulMircoSecond);
49
50     KdPrint(("Thread is running again!\n"));
51 }
52
53 #pragma PAGEDCODE
54 VOID WaitMicroSecond4(ULONG ulMircoSecond)
55 {
56     //使用计时器
57
58     KTIMER kTimer;//内核计时器
59
60     //初始化计时器
61     KeInitializeTimer(&kTimer);
62
63     LARGE_INTEGER timeout = RtlConvertLongToLargeInteger( ulMircoSecond * -10 );
64
65     //注意这个计时器没有和DPC对象关联
66     KeSetTimer(&kTimer,timeout,    NULL);
67     KdPrint(("Thread suspends %d MircoSeconds...",ulMircoSecond));
68
69     KeWaitForSingleObject(&kTimer,Executive,KernelMode,FALSE,NULL);
70
71     KdPrint(("Thread is running again!\n"));
72 }
73 #pragma PAGEDCODE
74 NTSTATUS HelloDDKDeviceIOControl(IN PDEVICE_OBJECT pDevObj,
75                                  IN PIRP pIrp)
76 {
77     NTSTATUS status = STATUS_SUCCESS;
78     KdPrint(("Enter HelloDDKDeviceIOControl\n"));
79
80     //得到当前堆栈
81     PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
82     //得到输入缓冲区大小
83     ULONG cbin = stack->Parameters.DeviceIoControl.InputBufferLength;
84     //得到输出缓冲区大小
85     ULONG cbout = stack->Parameters.DeviceIoControl.OutputBufferLength;
86     //得到IOCTL码
87     ULONG code = stack->Parameters.DeviceIoControl.IoControlCode;
88
89     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
90         pDevObj->DeviceExtension;
91
92     ULONG info = 0;
93
94     //得到用户程序传进来的微秒数
95     ULONG ulMircoSecond = *(PULONG)pIrp->AssociatedIrp.SystemBuffer;
96
97     switch (code)
98     {                        // process request
99         case IOCTL_WAIT_METHOD1:
100         {
101             KdPrint(("IOCTL_WAIT_METHOD1\n"));
102             WaitMicroSecond1(ulMircoSecond);
103             break;
104         }
105         case IOCTL_WAIT_METHOD2:
106         {
107             KdPrint(("IOCTL_WAIT_METHOD2\n"));
108             WaitMicroSecond2(ulMircoSecond);
109             break;
110         }
111         case IOCTL_WAIT_METHOD3:
112         {
113             KdPrint(("IOCTL_WAIT_METHOD3\n"));
114             WaitMicroSecond3(ulMircoSecond);
115             break;
116         }
117         case IOCTL_WAIT_METHOD4:
118         {
119             KdPrint(("IOCTL_WAIT_METHOD4\n"));
120             WaitMicroSecond4(ulMircoSecond);
121             break;
122         }
123         default:
124             status = STATUS_INVALID_VARIANT;
125     }
126
127     // 完成IRP
128     pIrp->IoStatus.Status = status;
129     pIrp->IoStatus.Information = info;    // bytes xfered
130     IoCompleteRequest( pIrp, IO_NO_INCREMENT );
131
132     KdPrint(("Leave HelloDDKDeviceIOControl\n"));
133
134     return status;
135 }
136 //.cpp
137 #include <windows.h>
138 #include <stdio.h>
139 //使用CTL_CODE必须加入winioctl.h
140 #include <winioctl.h>
141 #include "..\NT_Driver\Ioctls.h"
142
143 int main()
144 {
145     HANDLE hDevice =
146         CreateFile("\\\\.\\HelloDDK",
147                     GENERIC_READ | GENERIC_WRITE,
148                     0,        // share mode none
149                     NULL,    // no security
150                     OPEN_EXISTING,
151                     FILE_ATTRIBUTE_NORMAL,
152                     NULL );        // no template
153
154     if (hDevice == INVALID_HANDLE_VALUE)
155     {
156         printf("Failed to obtain file handle to device: "
157             "%s with Win32 error code: %d\n",
158             "MyDDKDevice", GetLastError() );
159         return 1;
160     }
161
162     DWORD dwOutput;
163
164     DWORD dwMicroSecond = 1000;
165     DeviceIoControl(hDevice, IOCTL_WAIT_METHOD1, &dwMicroSecond, sizeof(DWORD), NULL, 0, &dwOutput, NULL);
166     DeviceIoControl(hDevice, IOCTL_WAIT_METHOD2, &dwMicroSecond, sizeof(DWORD), NULL, 0, &dwOutput, NULL);
167     DeviceIoControl(hDevice, IOCTL_WAIT_METHOD3, &dwMicroSecond, sizeof(DWORD), NULL, 0, &dwOutput, NULL);
168     DeviceIoControl(hDevice, IOCTL_WAIT_METHOD4, &dwMicroSecond, sizeof(DWORD), NULL, 0, &dwOutput, NULL);
169
170     CloseHandle(hDevice);
171
172     return 0;
173 }

示例代码 P286

3、其它相关函数
获取当前系统时间：KeQuerySystemTime
This value is computed for the GMT time zone. To adjust this value for the local time zone use ExSystemTimeToLocalTime.（在控制面板中设置）
RtlTimeFieldsToTime converts TIME_FIELDS information to a system time value
RtlTimeToTimeFields

1 /************************************************************************
2 * 函数名称:DriverEntry
3 * 功能描述:初始化驱动程序，定位和申请硬件资源，创建内核对象
4 * 参数列表:
5       pDriverObject:从I/O管理器中传进来的驱动对象
6       pRegistryPath:驱动程序在注册表的中的路径
7 * 返回值:返回初始化驱动状态
8 *************************************************************************/
9 #pragma INITCODE
10 extern "C" NTSTATUS DriverEntry (
11             IN PDRIVER_OBJECT pDriverObject,
12             IN PUNICODE_STRING pRegistryPath    )
13 {
14     NTSTATUS status;
15     KdPrint(("Enter DriverEntry\n"));
16
17     //设置卸载函数
18     pDriverObject->DriverUnload = HelloDDKUnload;
19
20     //设置派遣函数
21     for (int i = 0; i < arraysize(pDriverObject->MajorFunction); ++i)
22         pDriverObject->MajorFunction[i] = HelloDDKDispatchRoutin;
23
24     pDriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = HelloDDKDeviceIOControl;
25
26     //创建驱动设备对象
27     status = CreateDevice(pDriverObject);
28
29     KdPrint(("Leave DriverEntry\n"));
30     return status;
31 }
32 #pragma PAGEDCODE
33 VOID Time_Test()
34 {
35     LARGE_INTEGER current_system_time;
36     //得到当前系统时间
37     KeQuerySystemTime(&current_system_time);
38
39     LARGE_INTEGER current_local_time;
40     //从系统时间转换成当地时区时间
41     ExSystemTimeToLocalTime(&current_system_time,&current_local_time);
42
43     TIME_FIELDS current_time_info;
44     //由当地时区时间得到月日年信息
45     RtlTimeToTimeFields(&current_local_time,&current_time_info);
46
47     //显示年月日等信息
48     KdPrint(("Current year:%d\n",current_time_info.Year));
49     KdPrint(("Current month:%d\n",current_time_info.Month));
50     KdPrint(("Current day:%d\n",current_time_info.Day));
51     KdPrint(("Current Hour:%d\n",current_time_info.Hour));
52     KdPrint(("Current Minute:%d\n",current_time_info.Minute));
53     KdPrint(("Current Second:%d\n",current_time_info.Second));
54     KdPrint(("Current Milliseconds:%d\n",current_time_info.Milliseconds));
55     KdPrint(("Current Weekday:%d\n",current_time_info.Weekday));
56 }
57
58 #pragma PAGEDCODE
59 NTSTATUS HelloDDKDeviceIOControl(IN PDEVICE_OBJECT pDevObj,
60                                  IN PIRP pIrp)
61 {
62     NTSTATUS status = STATUS_SUCCESS;
63     KdPrint(("Enter HelloDDKDeviceIOControl\n"));
64
65     //得到当前堆栈
66     PIO_STACK_LOCATION stack = IoGetCurrentIrpStackLocation(pIrp);
67     //得到输入缓冲区大小
68     ULONG cbin = stack->Parameters.DeviceIoControl.InputBufferLength;
69     //得到输出缓冲区大小
70     ULONG cbout = stack->Parameters.DeviceIoControl.OutputBufferLength;
71     //得到IOCTL码
72     ULONG code = stack->Parameters.DeviceIoControl.IoControlCode;
73
74     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
75         pDevObj->DeviceExtension;
76
77     ULONG info = 0;
78
79     switch (code)
80     {                        // process request
81         case IOCTL_TIME_TEST:
82         {
83             KdPrint(("IOCTL_TIME_TEST\n"));
84             Time_Test();
85             break;
86         }
87         default:
88             status = STATUS_INVALID_VARIANT;
89     }
90
91     // 完成IRP
92     pIrp->IoStatus.Status = status;
93     pIrp->IoStatus.Information = info;    // bytes xfered
94     IoCompleteRequest( pIrp, IO_NO_INCREMENT );
95
96     KdPrint(("Leave HelloDDKDeviceIOControl\n"));
97
98     return status;
99 }
100
101 DWORD dwOutput;
102 DeviceIoControl(hDevice, IOCTL_TIME_TEST, NULL, 0, NULL, 0, &dwOutput, NULL);
103 CloseHandle(hDevice);

示例代码 P288

4、IRP超时处理
规定时间内对某一设备的操作没有反应，则可以取消该操作。应用程序中使用CancelIo，驱动中用IoCancelIrp，来取消操作。也可以通过设置IRP超时，来取消IRO，这时进入IRP取消例程。
1）初始个定时器和DPC例程，进行关联。
2）操作IRP前，开户定时器，超时进入DPC例程。
3）如果超时前结束该IRP操作，则应取消定时器。

1 typedef struct _DEVICE_EXTENSION {
2     PDEVICE_OBJECT pDevice;
3     UNICODE_STRING ustrDeviceName;    //设备名称
4     UNICODE_STRING ustrSymLinkName;    //符号链接名
5
6     KDPC pollingDPC;    // 存储DPC对象
7     KTIMER pollingTimer;// 存储计时器对象
8     PIRP currentPendingIRP;//记录当前挂起的IRP
9 } DEVICE_EXTENSION, *PDEVICE_EXTENSION;
10
11 pDriverObject->MajorFunction[IRP_MJ_READ] = HelloDDKRead;
12
13 #pragma LOCKEDCODE
14 VOID OnTimerDpc( IN PKDPC pDpc,
15                       IN PVOID pContext,
16                       IN PVOID SysArg1,
17                       IN PVOID SysArg2 )
18 {
19     PDEVICE_OBJECT pDevObj = (PDEVICE_OBJECT)pContext;
20     PDEVICE_EXTENSION pdx = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
21
22     PIRP currentPendingIRP = pdx->currentPendingIRP;
23
24     KdPrint(("Cancel the current pending irp!\n"));
25
26     //设置完成状态为STATUS_CANCELLED
27      currentPendingIRP->IoStatus.Status = STATUS_CANCELLED;
28      currentPendingIRP->IoStatus.Information = 0;    // bytes xfered
29      IoCompleteRequest( currentPendingIRP, IO_NO_INCREMENT );
30 }
31
32 /************************************************************************
33 * 函数名称:CreateDevice
34 * 功能描述:初始化设备对象
35 * 参数列表:
36       pDriverObject:从I/O管理器中传进来的驱动对象
37 * 返回值:返回初始化状态
38 *************************************************************************/
39 #pragma INITCODE
40 NTSTATUS CreateDevice (
41         IN PDRIVER_OBJECT    pDriverObject)
42 {
43     NTSTATUS status;
44     PDEVICE_OBJECT pDevObj;
45     PDEVICE_EXTENSION pDevExt;
46
47     //创建设备名称
48     UNICODE_STRING devName;
49     RtlInitUnicodeString(&devName,L"\\Device\\MyDDKDevice");
50
51     //创建设备
52     status = IoCreateDevice( pDriverObject,
53                         sizeof(DEVICE_EXTENSION),
54                         &(UNICODE_STRING)devName,
55                         FILE_DEVICE_UNKNOWN,
56                         0, TRUE,
57                         &pDevObj );
58     if (!NT_SUCCESS(status))
59         return status;
60
61     pDevObj->Flags |= DO_BUFFERED_IO;
62     pDevExt = (PDEVICE_EXTENSION)pDevObj->DeviceExtension;
63     pDevExt->pDevice = pDevObj;
64     pDevExt->ustrDeviceName = devName;
65
66     KeInitializeTimer( &pDevExt->pollingTimer );
67
68     KeInitializeDpc( &pDevExt->pollingDPC,
69                         OnTimerDpc,
70                         (PVOID) pDevObj );
71
72     //创建符号链接
73     UNICODE_STRING symLinkName;
74     RtlInitUnicodeString(&symLinkName,L"\\??\\HelloDDK");
75     pDevExt->ustrSymLinkName = symLinkName;
76     status = IoCreateSymbolicLink( &symLinkName,&devName );
77     if (!NT_SUCCESS(status))
78     {
79         IoDeleteDevice( pDevObj );
80         return status;
81     }
82     return STATUS_SUCCESS;
83 }
84
85 NTSTATUS HelloDDKRead(IN PDEVICE_OBJECT pDevObj,
86                                  IN PIRP pIrp)
87 {
88     KdPrint(("Enter HelloDDKRead\n"));
89
90     PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)
91             pDevObj->DeviceExtension;
92
93     //将IRP设置为挂起
94     IoMarkIrpPending(pIrp);
95
96     //将挂起的IRP记录下来
97     pDevExt->currentPendingIRP = pIrp;
98
99     //定义3秒的超时
100     ULONG ulMicroSecond = 3000000;
101
102     //将32位整数转化成64位整数
103     LARGE_INTEGER timeout = RtlConvertLongToLargeInteger(-10*ulMicroSecond);
104
105     KeSetTimer(
106         &pDevExt->pollingTimer,
107         timeout,
108         &pDevExt->pollingDPC );
109
110     KdPrint(("Leave HelloDDKRead\n"));
111
112     //返回pending状态
113     return STATUS_PENDING;
114 }
115
116 //main
117 #include <windows.h>
118 #include <stdio.h>
119 #include <process.h>
120
121 int main()
122 {
123     HANDLE hDevice =
124         CreateFile("\\\\.\\HelloDDK",
125                     GENERIC_READ | GENERIC_WRITE,
126                     FILE_SHARE_READ,
127                     NULL,
128                     OPEN_EXISTING,
129                     FILE_ATTRIBUTE_NORMAL,
130                     NULL );
131
132     if (hDevice == INVALID_HANDLE_VALUE)
133     {
134         printf("Open Device failed!");
135         return 1;
136     }
137
138     DWORD dwRead;
139
140     //如果读IRP没有被完成，ReadFile一直都不会退出!
141     ReadFile(hDevice,NULL,0,&dwRead,NULL);
142
143     ReadFile(hDevice,NULL,0,&dwRead,NULL);
144
145     CloseHandle(hDevice);
146
147     return 0;
148 }

相关文章