Timer 结构定时器列表，定时器不'；停不下来

我对以下代码有问题。 每次我调用ioctl REGISTER时，计时器都会启动，当计时器过期时，它会调用“update”，它使用工作队列调度任务，doJob方法只是用新的过期时间更新计时器

当我调用ioctl UNREGISTER时，计时器被终止。。。但它会继续调用update（从而更新其过期时间）。为什么调用ioctl UNREGISTER后计时器不停止

int time = 1;
module_param(time, int, 0644);
int delay;
struct workqueue_struct* wq;
struct work_struct task;
struct timer_list timer;        /* timer */

long ioctl(struct file *filp, unsigned int cmd, unsigned long args) {
    switch (cmd) {
        case REGISTER:
            add_timer(&timer);
            return 0;
        case UNREGISTER:
            del_timer_sync(&timer); 
            return 0;
    }
}

static void doJob(struct work_struct *work) {
    printk(KERN_EMERG "\ndoJob\n");
    mod_timer(&timer, jiffies + delay); 

}
void update(unsigned long arg) {
    queue_work(wq, &task);
}
struct file_operations fop = {
    .owner = THIS_MODULE,
    .unlocked_ioctl = ioctl
};

static struct miscdevice dev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "timer",
    .fops = &fop
};


static int __init init(void)
{
    delay = HZ * time / 1000; 
    if (delay < 1) {
        printk(KERN_EMERG "time param is too small\n");
        return -1;
    }

    init_timer(&timer);
    timer.data = 0;
    timer.function = update;
    timer.expires = jiffies + delay;

    if (misc_register(&dev) < 0) {
        printk(KERN_EMERG "error registering misc device\n");   
        return -1;  
    }
    wq = create_workqueue("timer_task");
    INIT_WORK(&task, doJob);

    return 0;
}

static void __exit fini(void)
{   

    misc_deregister(&dev);
    printk(KERN_EMERG "deregistered\n");

}

module_init(init);
module_exit(fini);

int-time=1；
模块参数（时间，整数，0644）；
整数延迟；
struct workqueue_struct*wq；
结构工作\结构任务；
结构计时器\u列表计时器；/*计时器*/
长ioctl（结构文件*filp，无符号int cmd，无符号长参数）{
开关（cmd）{
个案登记册：
添加计时器（&计时器）；
返回0；
案件注销：
del_timer_sync（&timer）；
返回0；
}
}
静态void doJob（结构工作\u结构*工作）{
printk（KERN_EMERG“\ndoJob\n”）；
mod_定时器（&定时器，jiffies+延迟）；
}
无效更新（未签名的长参数）{
队列工作（wq和任务）；
}
结构文件\u操作fop={
.owner=此_模块，
.unlocked_ioctl=ioctl
};
静态结构设备开发={
.minor=杂项动力minor，
.name=“计时器”，
.fops=&fop
};
静态int uu init init（void）
{
延迟=赫兹*时间/1000；
如果（延迟<1）{
printk（KERN_EMERG“时间参数太小”\n）；
返回-1；
}
初始化计时器（&计时器）；
timer.data=0；
timer.function=更新；
timer.expires=jiffies+延迟；
如果（杂项寄存器（&dev）<0）{
printk（KERN_EMERG“错误注册杂项设备”\n）；
返回-1；
}
wq=创建工作队列（“计时器任务”）；
初始化工作（&task，doJob）；
返回0；
}
静态无效\uuu退出fini（无效）
{   
杂项注销登记（&dev）；
printk（KERN_EMERG“注销”）；
}
模块_init（init）；
模块_出口（fini）；

对于

del\u timer\u sync（）

来说：

Callers must prevent restarting of the timer, otherwise this function is meaningless.

换句话说，

del\u timer\u sync（）

等待处理程序退出，但如果该处理程序重新调度计时器，那么下次它将愉快地再次运行

您需要做的就是保持另一个变量

timer\u处于活动状态

。在启动计时器之前将其设置为true，在删除计时器之前将其设置为false。然后，只有当

定时器处于活动状态时才重新安排定时器。按照该顺序，您可以保证在
del\u timer\u sync（）
返回后不会再运行计时器