devbox
IT小白
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Linux内核4.14版本——watchdog看门狗框架分析_linux kernel watchdog 源码详解

作者：IT小白 | 2024-06-13 13:51:58

赞

踩

linux kernel watchdog 源码详解

目录

0 简介

1. 设备的注册

1.1 dw_wdt_drv_probe

1.2 watchdog_register_device

1.3 __watchdog_register_device

1.4 最终misc_register注册watchdog_miscdev

2. watchdog_miscdev设备分析

2.1 watchdog_open

2.2 watchdog_write

2.3 watchdog_release

2.4 watchdog_stop

2.5 watchdog_set_timeout

2.6 watchdog_ping

2.7 watchdog_ioctl

3. 使用标准的内核框架wdt driver时，需要特别注意以下两点

3.1 NOWAYOUT（无路可逃）的使用

3.2 magic close特性

4. 应用层代码（app demo）

0 简介

版本：Linux 4.14
用到的文件：
kernel\watchdog.c
drivers\watchdog\dw_wdt.c
drivers\watchdog\watchdog_dev.c
drivers\watchdog\watchdog_core.c

      wdt的驱动挺特别的，linux内核中也对它做了一个封装并归纳处理总结出了一个框架，分为以下三层：统一driver层（watchdog_dev），核心层（watchdog_core），具体的设备层（本文以dw wdt为例）。
      在写wdt的时候会发现，和其他driver不同的是，不需要我们在自己的driver中去创建节点，我们只需要实现ops结构体成员即可，然后去调用wdt核心层的api注册ops即可。
      其实，创建节点的工作在wdt的统一driver层已经实现了，这是因wdt设备在各个soc上是一个高度统一的设备，可以被高度抽象出来，查看代码watchdog_dev.c中就可以看到，这是一个标准的字符设备驱动，该文件中创建”dev/watchdog”节点，同时向上层提供了ioctl接口。
       driver中的各个接口调用都是以函数指针的方式去调用，而这些函数指针在我们每个soc自己的巨头的wdt driver层去初始化然后注册。

1. 设备的注册

1.1 dw_wdt_drv_probe

drivers\watchdog\dw_wdt.c

  1. #ifdef CONFIG_OF
  2. static const struct of_device_id dw_wdt_of_match[] = {
  3.     { .compatible = "snps,dw-wdt", },
  4.     { /* sentinel */ }
  5. };
  6. MODULE_DEVICE_TABLE(of, dw_wdt_of_match);
  7. #endif
  8.  
  9. static struct platform_driver dw_wdt_driver = {
  10.     .probe        = dw_wdt_drv_probe,
  11.     .remove        = dw_wdt_drv_remove,
  12.     .driver        = {
  13.         .name    = "dw_wdt",
  14.         .of_match_table = of_match_ptr(dw_wdt_of_match),
  15.         .pm    = &dw_wdt_pm_ops,
  16.     },
  17. };

      设备树中比较compatible = "snps,dw-wdt"，比较通过后调用dw_wdt_drv_probe函数。

  1. static int dw_wdt_drv_probe(struct platform_device *pdev)
  2. {
  3.     struct device *dev = &pdev->dev;
  4.     struct watchdog_device *wdd;
  5.     struct dw_wdt *dw_wdt;
  6.     struct resource *mem;
  7.     int ret;
  8.  
  9.     dw_wdt = devm_kzalloc(dev, sizeof(*dw_wdt), GFP_KERNEL);
  10.     if (!dw_wdt)
  11.         return -ENOMEM;
  12.  
  13.     wdd->info = &dw_wdt_ident;
  14.     wdd->ops = &dw_wdt_ops;  //设置操作函数
  15.     ........
  16.     
  17.     watchdog_set_nowayout(wdd, nowayout);
  18.     
  19.     ........
  20.  
  21.     platform_set_drvdata(pdev, dw_wdt);
  22.  
  23.     watchdog_set_restart_priority(wdd, 128);
  24.  
  25.     ret = watchdog_register_device(wdd);
  26.     if (ret)
  27.         goto out_disable_clk;
  28.  
  29.     return 0;
  30.  
  31. out_disable_clk:
  32.     clk_disable_unprepare(dw_wdt->clk);
  33.     return ret;
  34. }
  35.  
  36. static const struct watchdog_ops dw_wdt_ops = {
  37.     .owner        = THIS_MODULE,
  38.     .start        = dw_wdt_start,
  39.     .stop        = dw_wdt_stop,
  40.     .ping        = dw_wdt_ping,
  41.     .set_timeout    = dw_wdt_set_timeout,
  42.     .get_timeleft    = dw_wdt_get_timeleft,
  43.     .restart    = dw_wdt_restart,
  44. };

      前面一些关于硬件、IO等的设置，这里不做介绍，注意wdt的fops就行。我们主要讲watchdog_register_device函数。

1.2 watchdog_register_device

      该函数drivers\watchdog\watchdog_core.c在这里面，如下:

  1. int watchdog_register_device(struct watchdog_device *wdd)
  2. {
  3.     int ret;
  4.  
  5.     mutex_lock(&wtd_deferred_reg_mutex);
  6.     if (wtd_deferred_reg_done)
  7.         ret = __watchdog_register_device(wdd);
  8.     else
  9.         ret = watchdog_deferred_registration_add(wdd);
  10.     mutex_unlock(&wtd_deferred_reg_mutex);
  11.     return ret;
  12. }

      wtd_deferred_reg_done全局变量已经定义了，所以走__watchdog_register_device分支。

  1. static int __init watchdog_deferred_registration(void)
  2. {
  3.     mutex_lock(&wtd_deferred_reg_mutex);
  4.     wtd_deferred_reg_done = true;
  5.     while (!list_empty(&wtd_deferred_reg_list)) {
  6.         struct watchdog_device *wdd;
  7.  
  8.         wdd = list_first_entry(&wtd_deferred_reg_list,
  9.                        struct watchdog_device, deferred);
  10.         list_del(&wdd->deferred);
  11.         __watchdog_register_device(wdd);
  12.     }
  13.     mutex_unlock(&wtd_deferred_reg_mutex);
  14.     return 0;
  15. }
  16.  
  17. static int __init watchdog_init(void)
  18. {
  19.     int err;
  20.  
  21.     err = watchdog_dev_init();
  22.     if (err < 0)
  23.         return err;
  24.  
  25.     watchdog_deferred_registration();
  26.     return 0;
  27. }
  28.  
  29. subsys_initcall_sync(watchdog_init);

1.3 __watchdog_register_device

  1. static int __watchdog_register_device(struct watchdog_device *wdd)
  2. {
  3.     int ret, id = -1;
  4.     .......
  5.     
  6.     ret = watchdog_dev_register(wdd);
  7.  
  8.     ....
  9.  
  10.     return 0;
  11. }

      其他不管，发现调用watchdog_dev_register。

1.4 最终misc_register注册watchdog_miscdev

  1. static int watchdog_cdev_register(struct watchdog_device *wdd)
  2. {
  3.     struct watchdog_core_data *wd_data;
  4.     int err;
  5.  
  6.     ......
  7.  
  8.     if (wdd->id == 0) {
  9.         old_wd_data = wd_data;
  10.         watchdog_miscdev.parent = wdd->parent;
  11.         err = misc_register(&watchdog_miscdev);
  12.         if (err != 0) {
  13.             pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n",
  14.                 wdd->info->identity, WATCHDOG_MINOR, err);
  15.             if (err == -EBUSY)
  16.                 pr_err("%s: a legacy watchdog module is probably present.\n",
  17.                     wdd->info->identity);
  18.             old_wd_data = NULL;
  19.             kfree(wd_data);
  20.             return err;
  21.         }
  22.     }
  23.  
  24.     .......
  25.     return 0;
  26. }

      发现最终注册了一个混杂设备watchdog_miscdev，其定义如下。

  1. static const struct file_operations watchdog_fops = {
  2.     .owner        = THIS_MODULE,
  3.     .write        = watchdog_write,
  4.     .unlocked_ioctl    = watchdog_ioctl,
  5.     .open        = watchdog_open,
  6.     .release    = watchdog_release,
  7. };
  8.  
  9. static struct miscdevice watchdog_miscdev = {
  10.     .minor        = WATCHDOG_MINOR,
  11.     .name        = "watchdog",
  12.     .fops        = &watchdog_fops,
  13. };

2. watchdog_miscdev设备分析

2.1 watchdog_open

  1. /*
  2.  *    watchdog_open: open the /dev/watchdog* devices.
  3.  *    @inode: inode of device
  4.  *    @file: file handle to device
  5.  *
  6.  *    When the /dev/watchdog* device gets opened, we start the watchdog.
  7.  *    Watch out: the /dev/watchdog device is single open, so we make sure
  8.  *    it can only be opened once.
  9.  */
  10. static int watchdog_open(struct inode *inode, struct file *file)
  11. {
  12.     struct watchdog_core_data *wd_data;
  13.     struct watchdog_device *wdd;
  14.     bool hw_running;
  15.     int err;
  16.  
  17.     ......
  18.  
  19.     err = watchdog_start(wdd);
  20.     if (err < 0)
  21.         goto out_mod;
  22.  
  23.     ......
  24. }

      当打开open("/dev/watchdog")时，最终调用watchdog_open，可以看出最终调用了watchdog_start。

  1. /*
  2.  *    watchdog_start: wrapper to start the watchdog.
  3.  *    @wdd: the watchdog device to start
  4.  *
  5.  *    The caller must hold wd_data->lock.
  6.  *
  7.  *    Start the watchdog if it is not active and mark it active.
  8.  *    This function returns zero on success or a negative errno code for
  9.  *    failure.
  10.  */
  11.  
  12. static int watchdog_start(struct watchdog_device *wdd)
  13. {
  14.     struct watchdog_core_data *wd_data = wdd->wd_data;
  15.     unsigned long started_at;
  16.     int err;
  17.  
  18.     .....
  19.     set_bit(_WDOG_KEEPALIVE, &wd_data->status);
  20.  
  21.     started_at = jiffies;
  22.     if (watchdog_hw_running(wdd) && wdd->ops->ping)
  23.         err = wdd->ops->ping(wdd);
  24.     else
  25.         err = wdd->ops->start(wdd);
  26.     .....
  27.  
  28.     return err;
  29. }

      查看watchdog_start源码可知，最终调用了wdt fops中的start函数。

2.2 watchdog_write

  1. /*
  2.  *    watchdog_write: writes to the watchdog.
  3.  *    @file: file from VFS
  4.  *    @data: user address of data
  5.  *    @len: length of data
  6.  *    @ppos: pointer to the file offset
  7.  *
  8.  *    A write to a watchdog device is defined as a keepalive ping.
  9.  *    Writing the magic 'V' sequence allows the next close to turn
  10.  *    off the watchdog (if 'nowayout' is not set).
  11.  */
  12.  
  13. static ssize_t watchdog_write(struct file *file, const char __user *data,
  14.                         size_t len, loff_t *ppos)
  15. {
  16.     struct watchdog_core_data *wd_data = file->private_data;
  17.     struct watchdog_device *wdd;
  18.     int err;
  19.     size_t i;
  20.     char c;
  21.  
  22.     if (len == 0)
  23.         return 0;
  24.  
  25.     /*
  26.      * Note: just in case someone wrote the magic character
  27.      * five months ago...
  28.      */
  29.     clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status);
  30.  
  31.     /* scan to see whether or not we got the magic character */
  32.     for (i = 0; i != len; i++) {
  33.         if (get_user(c, data + i))
  34.             return -EFAULT;
  35.         if (c == 'V')
  36.             set_bit(_WDOG_ALLOW_RELEASE, &wd_data->status);
  37.     }
  38.  
  39.     /* someone wrote to us, so we send the watchdog a keepalive ping */
  40.  
  41.     err = -ENODEV;
  42.     mutex_lock(&wd_data->lock);
  43.     wdd = wd_data->wdd;
  44.     if (wdd)
  45.         err = watchdog_ping(wdd);
  46.     mutex_unlock(&wd_data->lock);
  47.  
  48.     if (err < 0)
  49.         return err;
  50.  
  51.     return len;
  52. }

      这里的写有一个特殊操作，如果向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接口

2.3 watchdog_release

  1. /*
  2.  *    watchdog_release: release the watchdog device.
  3.  *    @inode: inode of device
  4.  *    @file: file handle to device
  5.  *
  6.  *    This is the code for when /dev/watchdog gets closed. We will only
  7.  *    stop the watchdog when we have received the magic char (and nowayout
  8.  *    was not set), else the watchdog will keep running.
  9.  */
  10.  
  11. static int watchdog_release(struct inode *inode, struct file *file)
  12. {
  13.     struct watchdog_core_data *wd_data = file->private_data;
  14.     struct watchdog_device *wdd;
  15.     int err = -EBUSY;
  16.     bool running;
  17.     ......
  18.  
  19.     /*
  20.      * We only stop the watchdog if we received the magic character
  21.      * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then
  22.      * watchdog_stop will fail.
  23.      */
  24.     if (!test_bit(WDOG_ACTIVE, &wdd->status))
  25.         err = 0;
  26.     else if (test_and_clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status) ||
  27.          !(wdd->info->options & WDIOF_MAGICCLOSE))
  28.         err = watchdog_stop(wdd);
  29.  
  30.     /* If the watchdog was not stopped, send a keepalive ping */
  31.     if (err < 0) {
  32.         pr_crit("watchdog%d: watchdog did not stop!\n", wdd->id);
  33.         watchdog_ping(wdd);
  34.     }
  35.  
  36.     watchdog_update_worker(wdd);
  37.  
  38.     /* make sure that /dev/watchdog can be re-opened */
  39.     clear_bit(_WDOG_DEV_OPEN, &wd_data->status);
  40.     ......
  41.     return 0;
  42. }

      release 接口，上层做close的时候会调用到。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接口。

2.4 watchdog_stop

  1. /*
  2.  *    watchdog_stop: wrapper to stop the watchdog.
  3.  *    @wdd: the watchdog device to stop
  4.  *
  5.  *    The caller must hold wd_data->lock.
  6.  *
  7.  *    Stop the watchdog if it is still active and unmark it active.
  8.  *    This function returns zero on success or a negative errno code for
  9.  *    failure.
  10.  *    If the 'nowayout' feature was set, the watchdog cannot be stopped.
  11.  */
  12.  
  13. static int watchdog_stop(struct watchdog_device *wdd)
  14. {
  15.     int err = 0;
  16.  
  17.     if (!watchdog_active(wdd))
  18.         return 0;
  19.  
  20.     if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) {
  21.         pr_info("watchdog%d: nowayout prevents watchdog being stopped!\n",
  22.             wdd->id);
  23.         return -EBUSY;
  24.     }
  25.  
  26.     if (wdd->ops->stop) {
  27.         clear_bit(WDOG_HW_RUNNING, &wdd->status);
  28.         err = wdd->ops->stop(wdd);
  29.     } else {
  30.         set_bit(WDOG_HW_RUNNING, &wdd->status);
  31.     }
  32.  
  33.     if (err == 0) {
  34.         clear_bit(WDOG_ACTIVE, &wdd->status);
  35.         watchdog_update_worker(wdd);
  36.     }
  37.  
  38.     return err;
  39. }

      WDOG_NO_WAY_OUT，这里有个特殊的一点是上层调用进这个接口想关闭wdt即终止计数功能时，这里会判断status是否被设置为WDOG_NO_WAY_OUT状态，如果设置了，则直接返回不去调用实际driver中的stop函数。也就是说当NOWAYOUT被配置后，无论上层是close wdt节点还是调用统一层stop接口，wdt都是不会关掉的，会一直计数下去，如果不持续喂狗就会reset。

  1. static bool nowayout = WATCHDOG_NOWAYOUT;
  2. #define WATCHDOG_NOWAYOUT        IS_BUILTIN(CONFIG_WATCHDOG_NOWAYOUT)
  3. /* Use the following function to set the nowayout feature */
  4. static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
  5. {
  6.     if (nowayout)
  7.         set_bit(WDOG_NO_WAY_OUT, &wdd->status);
  8. }

       由上可以看出如果配置了CONFIG_WATCHDOG_NOWAYOUT项，则watchdog_set_nowayout在dw_wdt_drv_probe就会被执行，WDOG_NO_WAY_OUT状态就会被置起来，当上层通过ioctl调用了wdt同一层的stop接口时，则直接返回。

2.5 watchdog_set_timeout

  1. /*
  2.  *    watchdog_set_timeout: set the watchdog timer timeout
  3.  *    @wdd: the watchdog device to set the timeout for
  4.  *    @timeout: timeout to set in seconds
  5.  *
  6.  *    The caller must hold wd_data->lock.
  7.  */
  8.  
  9. static int watchdog_set_timeout(struct watchdog_device *wdd,
  10.                             unsigned int timeout)
  11. {
  12.     int err = 0;
  13.  
  14.     if (!(wdd->info->options & WDIOF_SETTIMEOUT))
  15.         return -EOPNOTSUPP;
  16.  
  17.     if (watchdog_timeout_invalid(wdd, timeout))
  18.         return -EINVAL;
  19.  
  20.     if (wdd->ops->set_timeout) {
  21.         err = wdd->ops->set_timeout(wdd, timeout);
  22.     } else {
  23.         wdd->timeout = timeout;
  24.         /* Disable pretimeout if it doesn't fit the new timeout */
  25.         if (wdd->pretimeout >= wdd->timeout)
  26.             wdd->pretimeout = 0;
  27.     }
  29.     watchdog_update_worker(wdd);
  31.     return err;
  32. }

      设置超时时间，一般正常喂狗会下发一个时间，如果上层想主动重启，只需设置时间为0，当然实际的底层driver需要对时间做判断，当时间为0时，就重启系统。

2.6 watchdog_ping

  1. /*
  2.  *    watchdog_ping: ping the watchdog.
  3.  *    @wdd: the watchdog device to ping
  4.  *
  5.  *    The caller must hold wd_data->lock.
  6.  *
  7.  *    If the watchdog has no own ping operation then it needs to be
  8.  *    restarted via the start operation. This wrapper function does
  9.  *    exactly that.
  10.  *    We only ping when the watchdog device is running.
  11.  */
  12.  
  13. static int watchdog_ping(struct watchdog_device *wdd)
  14. {
  15.     struct watchdog_core_data *wd_data = wdd->wd_data;
  16.  
  17.     if (!watchdog_active(wdd) && !watchdog_hw_running(wdd))
  18.         return 0;
  19.  
  20.     set_bit(_WDOG_KEEPALIVE, &wd_data->status);
  21.  
  22.     wd_data->last_keepalive = jiffies;
  23.     return __watchdog_ping(wdd);
  24. }
  25.  
  26. static int __watchdog_ping(struct watchdog_device *wdd)
  27. {
  28.     struct watchdog_core_data *wd_data = wdd->wd_data;
  29.     unsigned long earliest_keepalive = wd_data->last_hw_keepalive +
  30.                 msecs_to_jiffies(wdd->min_hw_heartbeat_ms);
  31.     int err;
  32.  
  33.     if (time_is_after_jiffies(earliest_keepalive)) {
  34.         mod_delayed_work(watchdog_wq, &wd_data->work,
  35.                  earliest_keepalive - jiffies);
  36.         return 0;
  37.     }
  38.  
  39.     wd_data->last_hw_keepalive = jiffies;
  40.  
  41.     if (wdd->ops->ping)
  42.         err = wdd->ops->ping(wdd);  /* ping the watchdog */
  43.     else
  44.         err = wdd->ops->start(wdd); /* restart watchdog */
  45.  
  46.     watchdog_update_worker(wdd);
  47.  
  48.     return err;
  49. }

2.7 watchdog_ioctl

  1. /*
  2.  *    watchdog_ioctl: handle the different ioctl's for the watchdog device.
  3.  *    @file: file handle to the device
  4.  *    @cmd: watchdog command
  5.  *    @arg: argument pointer
  6.  *
  7.  *    The watchdog API defines a common set of functions for all watchdogs
  8.  *    according to their available features.
  9.  */
  10.  
  11. static long watchdog_ioctl(struct file *file, unsigned int cmd,
  12.                             unsigned long arg)
  13. {
  14.     struct watchdog_core_data *wd_data = file->private_data;
  15.     void __user *argp = (void __user *)arg;
  16.     struct watchdog_device *wdd;
  17.     int __user *p = argp;
  18.     unsigned int val;
  19.     int err;
  20.  
  21.     mutex_lock(&wd_data->lock);
  22.  
  23.     wdd = wd_data->wdd;
  24.     if (!wdd) {
  25.         err = -ENODEV;
  26.         goto out_ioctl;
  27.     }
  28.  
  29.     err = watchdog_ioctl_op(wdd, cmd, arg);
  30.     if (err != -ENOIOCTLCMD)
  31.         goto out_ioctl;
  32.  
  33.     switch (cmd) {
  34.     case WDIOC_GETSUPPORT:
  35.         err = copy_to_user(argp, wdd->info,
  36.             sizeof(struct watchdog_info)) ? -EFAULT : 0;
  37.         break;
  38.     case WDIOC_GETSTATUS:
  39.         val = watchdog_get_status(wdd);
  40.         err = put_user(val, p);
  41.         break;
  42.     case WDIOC_GETBOOTSTATUS:
  43.         err = put_user(wdd->bootstatus, p);
  44.         break;
  45.     case WDIOC_SETOPTIONS:
  46.         if (get_user(val, p)) {
  47.             err = -EFAULT;
  48.             break;
  49.         }
  50.         if (val & WDIOS_DISABLECARD) {
  51.             err = watchdog_stop(wdd);
  52.             if (err < 0)
  53.                 break;
  54.         }
  55.         if (val & WDIOS_ENABLECARD)
  56.             err = watchdog_start(wdd);
  57.         break;
  58.     case WDIOC_KEEPALIVE:
  59.         if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) {
  60.             err = -EOPNOTSUPP;
  61.             break;
  62.         }
  63.         err = watchdog_ping(wdd);
  64.         break;
  65.     case WDIOC_SETTIMEOUT:
  66.         if (get_user(val, p)) {
  67.             err = -EFAULT;
  68.             break;
  69.         }
  70.         err = watchdog_set_timeout(wdd, val);
  71.         if (err < 0)
  72.             break;
  73.         /* If the watchdog is active then we send a keepalive ping
  74.          * to make sure that the watchdog keep's running (and if
  75.          * possible that it takes the new timeout) */
  76.         err = watchdog_ping(wdd);
  77.         if (err < 0)
  78.             break;
  79.         /* Fall */
  80.     case WDIOC_GETTIMEOUT:
  81.         /* timeout == 0 means that we don't know the timeout */
  82.         if (wdd->timeout == 0) {
  83.             err = -EOPNOTSUPP;
  84.             break;
  85.         }
  86.         err = put_user(wdd->timeout, p);
  87.         break;
  88.     case WDIOC_GETTIMELEFT:
  89.         err = watchdog_get_timeleft(wdd, &val);
  90.         if (err < 0)
  91.             break;
  92.         err = put_user(val, p);
  93.         break;
  94.     case WDIOC_SETPRETIMEOUT:
  95.         if (get_user(val, p)) {
  96.             err = -EFAULT;
  97.             break;
  98.         }
  99.         err = watchdog_set_pretimeout(wdd, val);
  100.         break;
  101.     case WDIOC_GETPRETIMEOUT:
  102.         err = put_user(wdd->pretimeout, p);
  103.         break;
  104.     default:
  105.         err = -ENOTTY;
  106.         break;
  107.     }
  108.  
  109. out_ioctl:
  110.     mutex_unlock(&wd_data->lock);
  111.     return err;
  112. }

3. 使用标准的内核框架wdt driver时，需要特别注意以下两点

3.1 NOWAYOUT（无路可逃）的使用

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

  1. static bool nowayout = WATCHDOG_NOWAYOUT;
  2. #define WATCHDOG_NOWAYOUT        IS_BUILTIN(CONFIG_WATCHDOG_NOWAYOUT)
  3. /* Use the following function to set the nowayout feature */
  4. static inline void watchdog_set_nowayout(struct watchdog_device *wdd, bool nowayout)
  5. {
  6.     if (nowayout)
  7.         set_bit(WDOG_NO_WAY_OUT, &wdd->status);
  8. }

      配置后会去执行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不用管这个

3.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接口。

4. 应用层代码（app demo）

  1. #include <stdio.h>
  2. #include <sys/types.h>
  3. #include <sys/stat.h>
  4. #include <fcntl.h>
  5. #include <errno.h>
  6. #include <pthread.h>
  7. #include <sys/ioctl.h>
  8. #include <stdlib.h>
  9. #include <unistd.h>
  10. #include <fcntl.h>
  11. #include <sys/time.h>
  12. #include <unistd.h>
  13. #include <time.h>
  14. #include <getopt.h>
  15. #include <sys/signal.h>
  16.  
  17. //watchdog 
  18. #define WATCHDOG_IOCTL_BASE     'W'
  19.  
  20. struct watchdog_info {
  21.     unsigned int options;          /* Options the card/driver supports */
  22.     unsigned int firmware_version; /* Firmware version of the card */
  23.     char identity[32];     /* Identity of the board */
  24. };
  25.  
  26. #define WDIOC_GETSUPPORT        _IOR(WATCHDOG_IOCTL_BASE, 0, struct watchdog_info)
  27. #define WDIOC_GETSTATUS         _IOR(WATCHDOG_IOCTL_BASE, 1, int)
  28. #define WDIOC_GETBOOTSTATUS     _IOR(WATCHDOG_IOCTL_BASE, 2, int)
  29. #define WDIOC_GETTEMP           _IOR(WATCHDOG_IOCTL_BASE, 3, int)
  30. #define WDIOC_SETOPTIONS        _IOR(WATCHDOG_IOCTL_BASE, 4, int)
  31. #define WDIOC_KEEPALIVE         _IOR(WATCHDOG_IOCTL_BASE, 5, int)
  32. #define WDIOC_SETTIMEOUT        _IOWR(WATCHDOG_IOCTL_BASE, 6, int)
  33. #define WDIOC_GETTIMEOUT        _IOR(WATCHDOG_IOCTL_BASE, 7, int)
  34. #define WDIOC_SETPRETIMEOUT     _IOWR(WATCHDOG_IOCTL_BASE, 8, int)
  35. #define WDIOC_GETPRETIMEOUT     _IOR(WATCHDOG_IOCTL_BASE, 9, int)
  36. #define WDIOC_GETTIMELEFT       _IOR(WATCHDOG_IOCTL_BASE, 10, int)
  37.  
  38. #define WDIOF_OVERHEAT          0x0001  /* Reset due to CPU overheat */
  39. #define WDIOF_FANFAULT          0x0002  /* Fan failed */
  40. #define WDIOF_EXTERN1           0x0004  /* External relay 1 */
  41. #define WDIOF_EXTERN2           0x0008  /* External relay 2 */
  42. #define WDIOF_POWERUNDER        0x0010  /* Power bad/power fault */
  43. #define WDIOF_CARDRESET         0x0020  /* Card previously reset the CPU */
  44. #define WDIOF_POWEROVER         0x0040  /* Power over voltage */
  45. #define WDIOF_SETTIMEOUT        0x0080  /* Set timeout (in seconds) */
  46. #define WDIOF_MAGICCLOSE        0x0100  /* Supports magic close char */
  47. #define WDIOF_PRETIMEOUT        0x0200  /* Pretimeout (in seconds), get/set */
  48. #define WDIOF_KEEPALIVEPING     0x8000  /* Keep alive ping reply */
  49.  
  50. #define WDIOS_DISABLECARD       0x0001  /* Turn off the watchdog timer */
  51. #define WDIOS_ENABLECARD        0x0002  /* Turn on the watchdog timer */
  52. #define WDIOS_TEMPPANIC         0x0004  /* Kernel panic on temperature trip */
  53.  
  54. int wdt_fd;
  55. int time_out = 5;
  56. #define DEFAULT_PING_RATE    1
  57. void stop_signal()
  58. {
  59.     int val = 0 , ret = 0 ;
  60.  
  61.     val = WDIOS_DISABLECARD ;
  62.     ret = ioctl(wdt_fd, WDIOC_SETOPTIONS, &val) ;
  63.     if (ret < 0)
  64.         printf("ioctl WDIOC_GETSUPPORT failed with %d.\n", ret);
  65.  
  66.     printf("===watchdow will be closed===\n") ;
  67.     close(wdt_fd) ;
  68.     exit(0);
  69.     
  70. }
  71.  
  72. int main(int argc, char *argv[])
  73. {
  74.     int ret;
  75.     static int count = 0;
  76.     struct watchdog_info wdt_info;
  77.     unsigned int ping_rate = DEFAULT_PING_RATE;
  78.  
  79.     signal(SIGINT, stop_signal) ;
  80.  
  81.     wdt_fd = open("/dev/watchdog0", O_RDWR);
  82.     if(wdt_fd < 0)
  83.     {
  84.         printf("open /dev/watchdog0 failed.\n");
  85.     }
  86.  
  87.     /* get watchdog infomation struct */
  88.     ret = ioctl(wdt_fd, WDIOC_GETSUPPORT, &wdt_info);
  89.     if (ret < 0)
  90.         printf("ioctl WDIOC_GETSUPPORT failed.\n");
  91.     else
  92.     {
  93.         printf("options = 0x%x,id = %s\n", wdt_info.options, wdt_info.identity);
  94.     }
  95.  
  96.     ioctl(wdt_fd, WDIOC_SETTIMEOUT, &time_out);
  97.     if (ret < 0)
  98.         printf("ioctl WDIOC_SETTIMEOUT failed.\n");
  99.     
  100.     while(1)
  101.     {
  102.         
  103.         if(count > 10)
  104.         {
  105.             printf("unfood watchdog, count = %d \n",count++);
  106.         }
  107.         else
  108.         {
  109.             ioctl(wdt_fd,WDIOC_KEEPALIVE,NULL);
  110.             printf("food watchdog, count = %d \n",count++);
  111.         }
  112.         sleep(DEFAULT_PING_RATE);
  113.     }    
  114.  
  115.     close(wdt_fd);
  116.     return 0;
  117. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/713127
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号