内核标准wdt统一driver层分析

标签（空格分隔）： linux子系统 wdt

---

http://blog.chinaunix.net/uid-14753126-id-2984303.html

path : /driver/watchdog_dev.c

wdt的驱动挺特别的，linux内核中也对它做了一个封装并归纳处理总结出了一个框架，分为以下三层：
统一driver层（watchdog_dev）,核心层（watchdog_core）,具体的设备层

在写wdt的时候会发现，和其他driver不同的是，不需要我们在自己的driver中去创建节点，我们只需要实现ops结构体成员即可，然后去调用
wdt核心层的api注册ops即可。
其实，创建节点的工作在wdt的统一driver层已经实现了，这是因wdt设备在各个soc上是一个高度统一的设备，可以被高度抽象出来，查看代码
watchdog_dev.c中就可以看到，这是一个标准的字符设备驱动，该文件中创建”dev/watchdog”节点，同时向上层提供了ioctl接口。
driver中的各个接口调用都是以函数指针的方式去调用，而这些函数指针在我们每个soc自己的巨头的wdt driver层去初始化然后注册。

这就是linux中wdt的思想。

在使用标准的内核框架wdt driver时，需要特别注意以下两点：
1，NOWAYOUT（无路可逃）的使用：
有的时候我们希望看门狗不被停止，即上层的任何关狗的动作都不予支持，此时就可以使用NOWAYOUT功能，接配置内核的标准配置项：CONFIG_WATCHDOG_NOWAYOUT
使能该项后，要为我们的driver所用需要在具体的wdt driver中对该配置进行支持，即调用watchdog_set_nowayout（）去设置WDOG_NO_WAY_OUT：

#ifdef CONFIG_WATCHDOG_NOWAYOUT
/* Use the following function to set the nowayout feature */
static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
{
    if (nowayout)
        set_bit(WDOG_NO_WAY_OUT, &wdd->status);
}
#endif

配置后会去执行set_bit(WDOG_NO_WAY_OUT, &wdd->status);置位WDOG_NO_WAY_OUT。
在上层调用统一driver层IOCTL去调用watchdog_stop（）时，watchdog_stop会去判断是否WDOG_NO_WAY_OUT被置位，如果设置了，则直接返回不去调用实际driver中的stop函数
这样就可以屏蔽所有关wdt的动作，这个操作仍然在统一设备层，具体的wdt driver不用管这个

2：magic close特性
有的时候我们想停掉狗，不想然他reset，如果系统使用了标准的wdt框架，则需要magic close的支持。
magic close即向wdt节点写字符“V”
向wdt节点写“V”字符时，被调用到的接口watchdog_write（）会置位标志为WDOG_ALLOW_RELEASE
当上层close节点时，会调用标准的wdt统一driver层的release接口，release会去判断WDOG_ALLOW_RELEASE，如果不被置位则不执行watchdog_stop即虽然上层关掉了fd，
但是底层实际没有执行stop的操作。如果被置位，就执行watchdog_stop，按照上面的分析，watchdog_stop又会判断NOWAYOUT是否被置位。
所以想要关闭wdt rest功能结束其计数，首先需要disable WDOG_ALLOW_RELEASE，即去掉该选项。然后在close节点前向节点写“V”，然后再clsoe，

这样才可以正真调用到具体driver的stop接口

统一设备层分析：

static int watchdog_ping(struct watchdog_device *wdd)//ping接口就是实际的一个写计数api
{
    int err = 0;

    mutex_lock(&wdd->lock);

    if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
        err = -ENODEV;
        goto out_ping;
    }

    if (!watchdog_active(wdd))
        goto out_ping;

    if (wdd->ops->ping)
        err = wdd->ops->ping(wdd);  /* ping the watchdog */ 最终会调用到实际的driver中的ping函数去设置计数
    else
        err = wdd->ops->start(wdd); /* restart watchdog */

out_ping:
    mutex_unlock(&wdd->lock);
    return err;
}

/*
 *  watchdog_start: wrapper to start the watchdog.
 *  @wdd: the watchdog device to start
 *
 *  Start the watchdog if it is not active and mark it active.
 *  This function returns zero on success or a negative errno code for
 *  failure.
 */

static int watchdog_start(struct watchdog_device *wdd) //开启wdt
{
    int err = 0;

    mutex_lock(&wdd->lock);

    if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
        err = -ENODEV;
        goto out_start;
    }

    if (watchdog_active(wdd))
        goto out_start;

    err = wdd->ops->start(wdd);最终会调用到实际的driver中的start函数去开启wdt
    if (err == 0)
        set_bit(WDOG_ACTIVE, &wdd->status);

out_start:
    mutex_unlock(&wdd->lock);
    return err;
}
/*
 *  watchdog_stop: wrapper to stop the watchdog.
 *  @wdd: the watchdog device to stop
 *
 *  Stop the watchdog if it is still active and unmark it active.
 *  This function returns zero on success or a negative errno code for
 *  failure.
 *  If the 'nowayout' feature was set, the watchdog cannot be stopped.
 */

static int watchdog_stop(struct watchdog_device *wdd)//关闭wdt
{
    int err = 0;

    mutex_lock(&wdd->lock);

    if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
        err = -ENODEV;
        goto out_stop;
    }

    if (!watchdog_active(wdd))
        goto out_stop;
        //这里有个特殊的一点是上层调用进这个接口想关闭wdt即终止计数功能时，这里会判断status是否被设置为WDOG_NO_WAY_OUT状态，如果设置了，则直接返回不去调用实际driver中的stop函数
这个变量一般可以通过api watchdog_set_nowayout（）在实际的driver中被调用，CONFIG_WATCHDOG_NOWAYOUT是内核的一个标准配置项
-----------------------------
#ifdef CONFIG_WATCHDOG_NOWAYOUT
/* Use the following function to set the nowayout feature */
static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
{
    if (nowayout)
        set_bit(WDOG_NO_WAY_OUT, &wdd->status);
}
#endif
------------------------------
由上可以看出如果配置了CONFIG_WATCHDOG_NOWAYOUT项，则watchdog_set_nowayout就会被执行，WDOG_NO_WAY_OUT状态就会被置起来，当上层通过ioctl调用了wdt同一层的stop接口时，
则直接返回。
也就是说当NOWAYOUT被配置后，无论上层是clsoe wdt节点还是调用统一层stop接口，wdt都是不会关掉的，会一直计数下去，如果不持续喂狗就会reset。
    if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) { //此处就是判断
        dev_info(wdd->dev, "nowayout prevents watchdog being stopped!\n");
        err = -EBUSY;
        goto out_stop;
    }

    err = wdd->ops->stop(wdd);
    if (err == 0)
        clear_bit(WDOG_ACTIVE, &wdd->status);
        out_stop:
    mutex_unlock(&wdd->lock);
    return err;
}

/*
 *  watchdog_get_status: wrapper to get the watchdog status
 *  @wdd: the watchdog device to get the status from
 *  @status: the status of the watchdog device
 *
 *  Get the watchdog's status flags.
 */

static int watchdog_get_status(struct watchdog_device *wdd,
                            unsigned int *status)
{
    int err = 0;

    *status = 0;
    if (!wdd->ops->status)
        return -EOPNOTSUPP;

    mutex_lock(&wdd->lock);
    if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
        err = -ENODEV;
        goto out_status;
    }

    *status = wdd->ops->status(wdd);

out_status:
    mutex_unlock(&wdd->lock);
    return err;
}

/*
 *  watchdog_set_timeout: set the watchdog timer timeout
 *  @wdd: the watchdog device to set the timeout for
 *  @timeout: timeout to set in seconds
 */
 //设置超时时间，一般正常喂狗会下发一个时间，如果上层想主动重启，只需设置时间为0，当然实际的底层driver需要对时间做判断，当时间为0时，就重启系统。
static int watchdog_set_timeout(struct watchdog_device *wdd,
                            unsigned int timeout)
{
    int err;

    if (!wdd->ops->set_timeout || !(wdd->info->options & WDIOF_SETTIMEOUT))
        return -EOPNOTSUPP;

    if (watchdog_timeout_invalid(wdd, timeout))
        return -EINVAL;

    mutex_lock(&wdd->lock);

    if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
        err = -ENODEV;
        goto out_timeout;
    }

    err = wdd->ops->set_timeout(wdd, timeout);

out_timeout:
mutex_unlock(&wdd->lock);
    return err;
}

/*
 *  watchdog_get_timeleft: wrapper to get the time left before a reboot
 *  @wdd: the watchdog device to get the remaining time from
 *  @timeleft: the time that's left
 *
 *  Get the time before a watchdog will reboot (if not pinged).
 */
//获取倒计时时间
static int watchdog_get_timeleft(struct watchdog_device *wdd,
                            unsigned int *timeleft)
{
    int err = 0;

    *timeleft = 0;
    if (!wdd->ops->get_timeleft)
        return -EOPNOTSUPP;

    mutex_lock(&wdd->lock);

    if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
        err = -ENODEV;
            goto out_timeleft;
    }

    *timeleft = wdd->ops->get_timeleft(wdd);

out_timeleft:
    mutex_unlock(&wdd->lock);
    return err;
}

/*
 *  watchdog_ioctl_op: call the watchdog drivers ioctl op if defined
 *  @wdd: the watchdog device to do the ioctl on
 *  @cmd: watchdog command
 *  @arg: argument pointer
 */
 static int watchdog_ioctl_op(struct watchdog_device *wdd, unsigned int cmd,
                            unsigned long arg)
{
    int err;

    if (!wdd->ops->ioctl)
        return -ENOIOCTLCMD;

    mutex_lock(&wdd->lock);

    if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
        err = -ENODEV;
        goto out_ioctl;
    }

    err = wdd->ops->ioctl(wdd, cmd, arg);

out_ioctl:
    mutex_unlock(&wdd->lock);
    return err;
}
/*
 *  watchdog_write: writes to the watchdog.
 *  @file: file from VFS
 *  @data: user address of data
 *  @len: length of data
 *  @ppos: pointer to the file offset
 *
 *  A write to a watchdog device is defined as a keepalive ping.
 *  Writing the magic 'V' sequence allows the next close to turn
 *  off the watchdog (if 'nowayout' is not set).
 */
//这里的写有一个特殊操作，如果向wdt节点写“V”字符时，则会置位标志为WDOG_ALLOW_RELEASE，即允许release，当上层去close节点的时候会callback到这一层的release接口，release
会去判断WDOG_ALLOW_RELEASE，如果不被置位则不执行watchdog_stop即虽然上层关掉了fd，但是底层实际没有执行stop的操作。如果被置位，就执行watchdog_stop，按照上面的分析，        watchdog_stop又会判断NOWAYOUT是否被置位。
即想要关闭wdt，首先需要disable WDOG_ALLOW_RELEASE，即去掉该选项。然后在close节点前向节点写“V”，然后再clsoe，这样才可以正真调用到具体driver的stop接口
static ssize_t watchdog_write(struct file *file, const char __user *data,
                        size_t len, loff_t *ppos)
{
    struct watchdog_device *wdd = file->private_data;
    size_t i;
    char c;
    int err;

    if (len == 0)
        return 0;

    /*
     * Note: just in case someone wrote the magic character
     * five months ago...
     */
    clear_bit(WDOG_ALLOW_RELEASE, &wdd->status);

    /* scan to see whether or not we got the magic character */
    for (i = 0; i != len; i++) {
        if (get_user(c, data + i))
            return -EFAULT;
        if (c == 'V')
            set_bit(WDOG_ALLOW_RELEASE, &wdd->status);
    }
    /* someone wrote to us, so we send the watchdog a keepalive ping */
    err = watchdog_ping(wdd);
    if (err < 0)
        return err;

    return len;
}

/*
 *  watchdog_ioctl: handle the different ioctl's for the watchdog device.
 *  @file: file handle to the device
 *  @cmd: watchdog command
 *  @arg: argument pointer
 *
 *  The watchdog API defines a common set of functions for all watchdogs
 *  according to their available features.
 */
//各种ioctl操作
static long watchdog_ioctl(struct file *file, unsigned int cmd,
unsigned long arg)
{
    struct watchdog_device *wdd = file->private_data;
    void __user *argp = (void __user *)arg;
    int __user *p = argp;
    unsigned int val;
    int err;

    err = watchdog_ioctl_op(wdd, cmd, arg);
    if (err != -ENOIOCTLCMD)
        return err;

    switch (cmd) {
    case WDIOC_GETSUPPORT:
        return copy_to_user(argp, wdd->info,
            sizeof(struct watchdog_info)) ? -EFAULT : 0;
    case WDIOC_GETSTATUS:
        err = watchdog_get_status(wdd, &val);
        if (err == -ENODEV)
            return err;
        return put_user(val, p);
    case WDIOC_GETBOOTSTATUS:
        return put_user(wdd->bootstatus, p);
    case WDIOC_SETOPTIONS:
        if (get_user(val, p))
            return -EFAULT;
        if (val & WDIOS_DISABLECARD) {
            err = watchdog_stop(wdd);
            if (err < 0)
                return err;
        }
        if (val & WDIOS_ENABLECARD) {
            err = watchdog_start(wdd);
            if (err < 0)
                return err;
        }
        return 0;
    case WDIOC_KEEPALIVE:
    if (!(wdd->info->options & WDIOF_KEEPALIVEPING))
            return -EOPNOTSUPP;
        return watchdog_ping(wdd);
    case WDIOC_SETTIMEOUT:
        if (get_user(val, p))
            return -EFAULT;
        err = watchdog_set_timeout(wdd, val);
        if (err < 0)
            return err;
        /* If the watchdog is active then we send a keepalive ping
         * to make sure that the watchdog keep's running (and if
         * possible that it takes the new timeout) */
        err = watchdog_ping(wdd);
        if (err < 0)
            return err;
        /* Fall */
    case WDIOC_GETTIMEOUT:
        /* timeout == 0 means that we don't know the timeout */
        if (wdd->timeout == 0)
            return -EOPNOTSUPP;
        return put_user(wdd->timeout, p);
    case WDIOC_GETTIMELEFT:
        err = watchdog_get_timeleft(wdd, &val);
        if (err)
            return err;
        return put_user(val, p);
    default:
        return -ENOTTY;
    }
}

/*
 *  watchdog_open: open the /dev/watchdog* devices.
 *  @inode: inode of device
 *  @file: file handle to device
 *
 *  When the /dev/watchdog* device gets opened, we start the watchdog.
 *  Watch out: the /dev/watchdog device is single open, so we make sure
 *  it can only be opened once.
 */

static int watchdog_open(struct inode *inode, struct file *file)
{
    int err = -EBUSY;
    struct watchdog_device *wdd;

    /* Get the corresponding watchdog device */
    if (imajor(inode) == MISC_MAJOR)
        wdd = old_wdd;
        else
        wdd = container_of(inode->i_cdev, struct watchdog_device, cdev);

    /* the watchdog is single open! */
    if (test_and_set_bit(WDOG_DEV_OPEN, &wdd->status))
        return -EBUSY;

    /*
     * If the /dev/watchdog device is open, we don't want the module
     * to be unloaded.
     */
    if (!try_module_get(wdd->ops->owner))
        goto out;

    err = watchdog_start(wdd);
    if (err < 0)
        goto out_mod;

    file->private_data = wdd;

    if (wdd->ops->ref)
        wdd->ops->ref(wdd);

    /* dev/watchdog is a virtual (and thus non-seekable) filesystem */
    return nonseekable_open(inode, file);

out_mod:
    module_put(wdd->ops->owner);
out:
    clear_bit(WDOG_DEV_OPEN, &wdd->status);
    return err;
}

/*
 *  watchdog_release: release the watchdog device.
 *  @inode: inode of device
 *  @file: file handle to device
 *
 *  This is the code for when /dev/watchdog gets closed. We will only
 *  stop the watchdog when we have received the magic char (and nowayout
 *  was not set), else the watchdog will keep running.
 */
//release 接口，上层做close的时候会调用到
static int watchdog_release(struct inode *inode, struct file *file)
{
    struct watchdog_device *wdd = file->private_data;
    int err = -EBUSY;

    /*
    * We only stop the watchdog if we received the magic character
     * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then
     * watchdog_stop will fail.
     */
    if (!test_bit(WDOG_ACTIVE, &wdd->status))
        err = 0;
//release会去判断WDOG_ALLOW_RELEASE，而这个标志在write函数中会被置位，（向节点写“V”操作）。如果不被置位则不执行watchdog_stop即虽然上层关掉了fd，但是底层实际没有执行stop的     操作。如果被置位，就执行watchdog_stop，按照上面的分析，watchdog_stop又会判断NOWAYOUT是否被置位。
即想要关闭wdt，首先需要disable WDOG_ALLOW_RELEASE，即去掉该选项。然后在close节点前向节点写“V”，然后再clsoe，这样才可以正真调用到具体driver的stop接口
    else if (test_and_clear_bit(WDOG_ALLOW_RELEASE, &wdd->status) || 
         !(wdd->info->options & WDIOF_MAGICCLOSE))
        err = watchdog_stop(wdd);

    /* If the watchdog was not stopped, send a keepalive ping */
    if (err < 0) {
        mutex_lock(&wdd->lock);
        if (!test_bit(WDOG_UNREGISTERED, &wdd->status))
            dev_crit(wdd->dev, "watchdog did not stop!\n");
            mutex_unlock(&wdd->lock);
        watchdog_ping(wdd);
    }

    /* Allow the owner module to be unloaded again */
    module_put(wdd->ops->owner);

    /* make sure that /dev/watchdog can be re-opened */
    clear_bit(WDOG_DEV_OPEN, &wdd->status);

    /* Note wdd may be gone after this, do not use after this! */
    if (wdd->ops->unref)
        wdd->ops->unref(wdd);

    return 0;
}

static const struct file_operations watchdog_fops = {
    .owner      = THIS_MODULE,
    .write      = watchdog_write,
    .unlocked_ioctl = watchdog_ioctl,
    .open       = watchdog_open,
    .release    = watchdog_release,
};
static struct miscdevice watchdog_miscdev = {
    .minor      = WATCHDOG_MINOR,
    .name       = "watchdog",
    .fops       = &watchdog_fops,
};

/*
 *  watchdog_dev_register: register a watchdog device
 *  @wdd: watchdog device
 *
 *  Register a watchdog device including handling the legacy
 *  /dev/watchdog node. /dev/watchdog is actually a miscdevice and
 *  thus we set it up like that.
 */

int watchdog_dev_register(struct watchdog_device *wdd)
{
    int err, devno;

    if (wdd->id == 0) {
        old_wdd = wdd;
        watchdog_miscdev.parent = wdd->parent;
        err = misc_register(&watchdog_miscdev);
        if (err != 0) {
            pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n",
                wdd->info->identity, WATCHDOG_MINOR, err);
            if (err == -EBUSY)
                pr_err("%s: a legacy watchdog module is probably present.\n",
                    wdd->info->identity);
            old_wdd = NULL;
            return err;
        }
    }

    /* Fill in the data structures */
    devno = MKDEV(MAJOR(watchdog_devt), wdd->id);
    cdev_init(&wdd->cdev, &watchdog_fops);
    wdd->cdev.owner = wdd->ops->owner;

    /* Add the device */
    err  = cdev_add(&wdd->cdev, devno, 1);
    if (err) {
        pr_err("watchdog%d unable to add device %d:%d\n",
            wdd->id,  MAJOR(watchdog_devt), wdd->id);
        if (wdd->id == 0) {
            misc_deregister(&watchdog_miscdev);
            old_wdd = NULL;
        }
    }
    return err;
}

/*
 *  watchdog_dev_unregister: unregister a watchdog device
 *  @watchdog: watchdog device
 *
 *  Unregister the watchdog and if needed the legacy /dev/watchdog device.
 */

int watchdog_dev_unregister(struct watchdog_device *wdd)
{
    mutex_lock(&wdd->lock);
    set_bit(WDOG_UNREGISTERED, &wdd->status);
    mutex_unlock(&wdd->lock);

    cdev_del(&wdd->cdev);
    if (wdd->id == 0) {
        misc_deregister(&watchdog_miscdev);
        old_wdd = NULL;
    }
    return 0;
    }

/*
 *  watchdog_dev_init: init dev part of watchdog core
 *
 *  Allocate a range of chardev nodes to use for watchdog devices
 */

int __init watchdog_dev_init(void)
{
    int err = alloc_chrdev_region(&watchdog_devt, 0, MAX_DOGS, "watchdog");
    if (err < 0)
        pr_err("watchdog: unable to allocate char dev region\n");
    return err;
}

/*
 *  watchdog_dev_exit: exit dev part of watchdog core
 *
 *  Release the range of chardev nodes used for watchdog devices
 */
void __exit watchdog_dev_exit(void)
{
    unregister_chrdev_region(watchdog_devt, MAX_DOGS);
}