定时器的实现

使用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定时器的步骤一般是：

1. 分别调用KeInitializeTimer和KeInitializeDpc初始化KTIMER对象和DPC对象
2. 用KeSetTimer开启定时器
3. 在DPC例程中再次调用KeSetTimer开启定时器

4. 调用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++;
   }