drivers/watchdog/watchdog_dev.c

   1 /*
   2  *      watchdog_dev.c
   3  *
   4  *      (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
   5  *                                              All Rights Reserved.
   6  *
   7  *      (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
   8  *
   9  *
  10  *      This source code is part of the generic code that can be used
  11  *      by all the watchdog timer drivers.
  12  *
  13  *      This part of the generic code takes care of the following
  14  *      misc device: /dev/watchdog.
  15  *
  16  *      Based on source code of the following authors:
  17  *        Matt Domsch <Matt_Domsch@dell.com>,
  18  *        Rob Radez <rob@osinvestor.com>,
  19  *        Rusty Lynch <rusty@linux.co.intel.com>
  20  *        Satyam Sharma <satyam@infradead.org>
  21  *        Randy Dunlap <randy.dunlap@oracle.com>
  22  *
  23  *      This program is free software; you can redistribute it and/or
  24  *      modify it under the terms of the GNU General Public License
  25  *      as published by the Free Software Foundation; either version
  26  *      2 of the License, or (at your option) any later version.
  27  *
  28  *      Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw.
  29  *      admit liability nor provide warranty for any of this software.
  30  *      This material is provided "AS-IS" and at no charge.
  31  */
  32
  33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  34
  35 #include <linux/cdev.h>         /* For character device */
  36 #include <linux/errno.h>        /* For the -ENODEV/... values */
  37 #include <linux/fs.h>           /* For file operations */
  38 #include <linux/init.h>         /* For __init/__exit/... */
  39 #include <linux/jiffies.h>      /* For timeout functions */
  40 #include <linux/kernel.h>       /* For printk/panic/... */
  41 #include <linux/kref.h>         /* For data references */
  42 #include <linux/miscdevice.h>   /* For handling misc devices */
  43 #include <linux/module.h>       /* For module stuff/... */
  44 #include <linux/mutex.h>        /* For mutexes */
  45 #include <linux/slab.h>         /* For memory functions */
  46 #include <linux/types.h>        /* For standard types (like size_t) */
  47 #include <linux/watchdog.h>     /* For watchdog specific items */
  48 #include <linux/workqueue.h>    /* For workqueue */
  49 #include <linux/uaccess.h>      /* For copy_to_user/put_user/... */
  50
  51 #include "watchdog_core.h"
  52
  53 /*
  54  * struct watchdog_core_data - watchdog core internal data
  55  * @kref:       Reference count.
  56  * @cdev:       The watchdog's Character device.
  57  * @wdd:        Pointer to watchdog device.
  58  * @lock:       Lock for watchdog core.
  59  * @status:     Watchdog core internal status bits.
  60  */
  61 struct watchdog_core_data {
  62         struct kref kref;
  63         struct cdev cdev;
  64         struct watchdog_device *wdd;
  65         struct mutex lock;
  66         unsigned long last_keepalive;
  67         unsigned long last_hw_keepalive;
  68         struct delayed_work work;
  69         unsigned long status;           /* Internal status bits */
  70 #define _WDOG_DEV_OPEN          0       /* Opened ? */
  71 #define _WDOG_ALLOW_RELEASE     1       /* Did we receive the magic char ? */
  72 };
  73
  74 /* the dev_t structure to store the dynamically allocated watchdog devices */
  75 static dev_t watchdog_devt;
  76 /* Reference to watchdog device behind /dev/watchdog */
  77 static struct watchdog_core_data *old_wd_data;
  78
  79 static struct workqueue_struct *watchdog_wq;
  80
  81 static inline bool watchdog_need_worker(struct watchdog_device *wdd)
  82 {
  83         /* All variables in milli-seconds */
  84         unsigned int hm = wdd->max_hw_heartbeat_ms;
  85         unsigned int t = wdd->timeout * 1000;
  86
  87         /*
  88          * A worker to generate heartbeat requests is needed if all of the
  89          * following conditions are true.
  90          * - Userspace activated the watchdog.
  91          * - The driver provided a value for the maximum hardware timeout, and
  92          *   thus is aware that the framework supports generating heartbeat
  93          *   requests.
  94          * - Userspace requests a longer timeout than the hardware can handle.
  95          */
  96         return hm && ((watchdog_active(wdd) && t > hm) ||
  97                       (t && !watchdog_active(wdd) && watchdog_hw_running(wdd)));
  98 }
  99
 100 static long watchdog_next_keepalive(struct watchdog_device *wdd)
 101 {
 102         struct watchdog_core_data *wd_data = wdd->wd_data;
 103         unsigned int timeout_ms = wdd->timeout * 1000;
 104         unsigned long keepalive_interval;
 105         unsigned long last_heartbeat;
 106         unsigned long virt_timeout;
 107         unsigned int hw_heartbeat_ms;
 108
 109         virt_timeout = wd_data->last_keepalive + msecs_to_jiffies(timeout_ms);
 110         hw_heartbeat_ms = min(timeout_ms, wdd->max_hw_heartbeat_ms);
 111         keepalive_interval = msecs_to_jiffies(hw_heartbeat_ms / 2);
 112
 113         if (!watchdog_active(wdd))
 114                 return keepalive_interval;
 115
 116         /*
 117          * To ensure that the watchdog times out wdd->timeout seconds
 118          * after the most recent ping from userspace, the last
 119          * worker ping has to come in hw_heartbeat_ms before this timeout.
 120          */
 121         last_heartbeat = virt_timeout - msecs_to_jiffies(hw_heartbeat_ms);
 122         return min_t(long, last_heartbeat - jiffies, keepalive_interval);
 123 }
 124
 125 static inline void watchdog_update_worker(struct watchdog_device *wdd)
 126 {
 127         struct watchdog_core_data *wd_data = wdd->wd_data;
 128
 129         if (watchdog_need_worker(wdd)) {
 130                 long t = watchdog_next_keepalive(wdd);
 131
 132                 if (t > 0)
 133                         mod_delayed_work(watchdog_wq, &wd_data->work, t);
 134         } else {
 135                 cancel_delayed_work(&wd_data->work);
 136         }
 137 }
 138
 139 static int __watchdog_ping(struct watchdog_device *wdd)
 140 {
 141         struct watchdog_core_data *wd_data = wdd->wd_data;
 142         unsigned long earliest_keepalive = wd_data->last_hw_keepalive +
 143                                 msecs_to_jiffies(wdd->min_hw_heartbeat_ms);
 144         int err;
 145
 146         if (time_is_after_jiffies(earliest_keepalive)) {
 147                 mod_delayed_work(watchdog_wq, &wd_data->work,
 148                                  earliest_keepalive - jiffies);
 149                 return 0;
 150         }
 151
 152         wd_data->last_hw_keepalive = jiffies;
 153
 154         if (wdd->ops->ping)
 155                 err = wdd->ops->ping(wdd);  /* ping the watchdog */
 156         else
 157                 err = wdd->ops->start(wdd); /* restart watchdog */
 158
 159         watchdog_update_worker(wdd);
 160
 161         return err;
 162 }
 163
 164 /*
 165  *      watchdog_ping: ping the watchdog.
 166  *      @wdd: the watchdog device to ping
 167  *
 168  *      The caller must hold wd_data->lock.
 169  *
 170  *      If the watchdog has no own ping operation then it needs to be
 171  *      restarted via the start operation. This wrapper function does
 172  *      exactly that.
 173  *      We only ping when the watchdog device is running.
 174  */
 175
 176 static int watchdog_ping(struct watchdog_device *wdd)
 177 {
 178         struct watchdog_core_data *wd_data = wdd->wd_data;
 179
 180         if (!watchdog_active(wdd) && !watchdog_hw_running(wdd))
 181                 return 0;
 182
 183         wd_data->last_keepalive = jiffies;
 184         return __watchdog_ping(wdd);
 185 }
 186
 187 static void watchdog_ping_work(struct work_struct *work)
 188 {
 189         struct watchdog_core_data *wd_data;
 190         struct watchdog_device *wdd;
 191
 192         wd_data = container_of(to_delayed_work(work), struct watchdog_core_data,
 193                                work);
 194
 195         mutex_lock(&wd_data->lock);
 196         wdd = wd_data->wdd;
 197         if (wdd && (watchdog_active(wdd) || watchdog_hw_running(wdd)))
 198                 __watchdog_ping(wdd);
 199         mutex_unlock(&wd_data->lock);
 200 }
 201
 202 /*
 203  *      watchdog_start: wrapper to start the watchdog.
 204  *      @wdd: the watchdog device to start
 205  *
 206  *      The caller must hold wd_data->lock.
 207  *
 208  *      Start the watchdog if it is not active and mark it active.
 209  *      This function returns zero on success or a negative errno code for
 210  *      failure.
 211  */
 212
 213 static int watchdog_start(struct watchdog_device *wdd)
 214 {
 215         struct watchdog_core_data *wd_data = wdd->wd_data;
 216         unsigned long started_at;
 217         int err;
 218
 219         if (watchdog_active(wdd))
 220                 return 0;
 221
 222         started_at = jiffies;
 223         if (watchdog_hw_running(wdd) && wdd->ops->ping)
 224                 err = wdd->ops->ping(wdd);
 225         else
 226                 err = wdd->ops->start(wdd);
 227         if (err == 0) {
 228                 set_bit(WDOG_ACTIVE, &wdd->status);
 229                 wd_data->last_keepalive = started_at;
 230                 watchdog_update_worker(wdd);
 231         }
 232
 233         return err;
 234 }
 235
 236 /*
 237  *      watchdog_stop: wrapper to stop the watchdog.
 238  *      @wdd: the watchdog device to stop
 239  *
 240  *      The caller must hold wd_data->lock.
 241  *
 242  *      Stop the watchdog if it is still active and unmark it active.
 243  *      This function returns zero on success or a negative errno code for
 244  *      failure.
 245  *      If the 'nowayout' feature was set, the watchdog cannot be stopped.
 246  */
 247
 248 static int watchdog_stop(struct watchdog_device *wdd)
 249 {
 250         int err = 0;
 251
 252         if (!watchdog_active(wdd))
 253                 return 0;
 254
 255         if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) {
 256                 pr_info("watchdog%d: nowayout prevents watchdog being stopped!\n",
 257                         wdd->id);
 258                 return -EBUSY;
 259         }
 260
 261         if (wdd->ops->stop)
 262                 err = wdd->ops->stop(wdd);
 263         else
 264                 set_bit(WDOG_HW_RUNNING, &wdd->status);
 265
 266         if (err == 0) {
 267                 clear_bit(WDOG_ACTIVE, &wdd->status);
 268                 watchdog_update_worker(wdd);
 269         }
 270
 271         return err;
 272 }
 273
 274 /*
 275  *      watchdog_get_status: wrapper to get the watchdog status
 276  *      @wdd: the watchdog device to get the status from
 277  *
 278  *      The caller must hold wd_data->lock.
 279  *
 280  *      Get the watchdog's status flags.
 281  */
 282
 283 static unsigned int watchdog_get_status(struct watchdog_device *wdd)
 284 {
 285         if (!wdd->ops->status)
 286                 return 0;
 287
 288         return wdd->ops->status(wdd);
 289 }
 290
 291 /*
 292  *      watchdog_set_timeout: set the watchdog timer timeout
 293  *      @wdd: the watchdog device to set the timeout for
 294  *      @timeout: timeout to set in seconds
 295  *
 296  *      The caller must hold wd_data->lock.
 297  */
 298
 299 static int watchdog_set_timeout(struct watchdog_device *wdd,
 300                                                         unsigned int timeout)
 301 {
 302         int err = 0;
 303
 304         if (!(wdd->info->options & WDIOF_SETTIMEOUT))
 305                 return -EOPNOTSUPP;
 306
 307         if (watchdog_timeout_invalid(wdd, timeout))
 308                 return -EINVAL;
 309
 310         if (wdd->ops->set_timeout)
 311                 err = wdd->ops->set_timeout(wdd, timeout);
 312         else
 313                 wdd->timeout = timeout;
 314
 315         watchdog_update_worker(wdd);
 316
 317         return err;
 318 }
 319
 320 /*
 321  *      watchdog_get_timeleft: wrapper to get the time left before a reboot
 322  *      @wdd: the watchdog device to get the remaining time from
 323  *      @timeleft: the time that's left
 324  *
 325  *      The caller must hold wd_data->lock.
 326  *
 327  *      Get the time before a watchdog will reboot (if not pinged).
 328  */
 329
 330 static int watchdog_get_timeleft(struct watchdog_device *wdd,
 331                                                         unsigned int *timeleft)
 332 {
 333         *timeleft = 0;
 334
 335         if (!wdd->ops->get_timeleft)
 336                 return -EOPNOTSUPP;
 337
 338         *timeleft = wdd->ops->get_timeleft(wdd);
 339
 340         return 0;
 341 }
 342
 343 #ifdef CONFIG_WATCHDOG_SYSFS
 344 static ssize_t nowayout_show(struct device *dev, struct device_attribute *attr,
 345                                 char *buf)
 346 {
 347         struct watchdog_device *wdd = dev_get_drvdata(dev);
 348
 349         return sprintf(buf, "%d\n", !!test_bit(WDOG_NO_WAY_OUT, &wdd->status));
 350 }
 351 static DEVICE_ATTR_RO(nowayout);
 352
 353 static ssize_t status_show(struct device *dev, struct device_attribute *attr,
 354                                 char *buf)
 355 {
 356         struct watchdog_device *wdd = dev_get_drvdata(dev);
 357         struct watchdog_core_data *wd_data = wdd->wd_data;
 358         unsigned int status;
 359
 360         mutex_lock(&wd_data->lock);
 361         status = watchdog_get_status(wdd);
 362         mutex_unlock(&wd_data->lock);
 363
 364         return sprintf(buf, "%u\n", status);
 365 }
 366 static DEVICE_ATTR_RO(status);
 367
 368 static ssize_t bootstatus_show(struct device *dev,
 369                                 struct device_attribute *attr, char *buf)
 370 {
 371         struct watchdog_device *wdd = dev_get_drvdata(dev);
 372
 373         return sprintf(buf, "%u\n", wdd->bootstatus);
 374 }
 375 static DEVICE_ATTR_RO(bootstatus);
 376
 377 static ssize_t timeleft_show(struct device *dev, struct device_attribute *attr,
 378                                 char *buf)
 379 {
 380         struct watchdog_device *wdd = dev_get_drvdata(dev);
 381         struct watchdog_core_data *wd_data = wdd->wd_data;
 382         ssize_t status;
 383         unsigned int val;
 384
 385         mutex_lock(&wd_data->lock);
 386         status = watchdog_get_timeleft(wdd, &val);
 387         mutex_unlock(&wd_data->lock);
 388         if (!status)
 389                 status = sprintf(buf, "%u\n", val);
 390
 391         return status;
 392 }
 393 static DEVICE_ATTR_RO(timeleft);
 394
 395 static ssize_t timeout_show(struct device *dev, struct device_attribute *attr,
 396                                 char *buf)
 397 {
 398         struct watchdog_device *wdd = dev_get_drvdata(dev);
 399
 400         return sprintf(buf, "%u\n", wdd->timeout);
 401 }
 402 static DEVICE_ATTR_RO(timeout);
 403
 404 static ssize_t identity_show(struct device *dev, struct device_attribute *attr,
 405                                 char *buf)
 406 {
 407         struct watchdog_device *wdd = dev_get_drvdata(dev);
 408
 409         return sprintf(buf, "%s\n", wdd->info->identity);
 410 }
 411 static DEVICE_ATTR_RO(identity);
 412
 413 static ssize_t state_show(struct device *dev, struct device_attribute *attr,
 414                                 char *buf)
 415 {
 416         struct watchdog_device *wdd = dev_get_drvdata(dev);
 417
 418         if (watchdog_active(wdd))
 419                 return sprintf(buf, "active\n");
 420
 421         return sprintf(buf, "inactive\n");
 422 }
 423 static DEVICE_ATTR_RO(state);
 424
 425 static umode_t wdt_is_visible(struct kobject *kobj, struct attribute *attr,
 426                                 int n)
 427 {
 428         struct device *dev = container_of(kobj, struct device, kobj);
 429         struct watchdog_device *wdd = dev_get_drvdata(dev);
 430         umode_t mode = attr->mode;
 431
 432         if (attr == &dev_attr_status.attr && !wdd->ops->status)
 433                 mode = 0;
 434         else if (attr == &dev_attr_timeleft.attr && !wdd->ops->get_timeleft)
 435                 mode = 0;
 436
 437         return mode;
 438 }
 439 static struct attribute *wdt_attrs[] = {
 440         &dev_attr_state.attr,
 441         &dev_attr_identity.attr,
 442         &dev_attr_timeout.attr,
 443         &dev_attr_timeleft.attr,
 444         &dev_attr_bootstatus.attr,
 445         &dev_attr_status.attr,
 446         &dev_attr_nowayout.attr,
 447         NULL,
 448 };
 449
 450 static const struct attribute_group wdt_group = {
 451         .attrs = wdt_attrs,
 452         .is_visible = wdt_is_visible,
 453 };
 454 __ATTRIBUTE_GROUPS(wdt);
 455 #else
 456 #define wdt_groups      NULL
 457 #endif
 458
 459 /*
 460  *      watchdog_ioctl_op: call the watchdog drivers ioctl op if defined
 461  *      @wdd: the watchdog device to do the ioctl on
 462  *      @cmd: watchdog command
 463  *      @arg: argument pointer
 464  *
 465  *      The caller must hold wd_data->lock.
 466  */
 467
 468 static int watchdog_ioctl_op(struct watchdog_device *wdd, unsigned int cmd,
 469                                                         unsigned long arg)
 470 {
 471         if (!wdd->ops->ioctl)
 472                 return -ENOIOCTLCMD;
 473
 474         return wdd->ops->ioctl(wdd, cmd, arg);
 475 }
 476
 477 /*
 478  *      watchdog_write: writes to the watchdog.
 479  *      @file: file from VFS
 480  *      @data: user address of data
 481  *      @len: length of data
 482  *      @ppos: pointer to the file offset
 483  *
 484  *      A write to a watchdog device is defined as a keepalive ping.
 485  *      Writing the magic 'V' sequence allows the next close to turn
 486  *      off the watchdog (if 'nowayout' is not set).
 487  */
 488
 489 static ssize_t watchdog_write(struct file *file, const char __user *data,
 490                                                 size_t len, loff_t *ppos)
 491 {
 492         struct watchdog_core_data *wd_data = file->private_data;
 493         struct watchdog_device *wdd;
 494         int err;
 495         size_t i;
 496         char c;
 497
 498         if (len == 0)
 499                 return 0;
 500
 501         /*
 502          * Note: just in case someone wrote the magic character
 503          * five months ago...
 504          */
 505         clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status);
 506
 507         /* scan to see whether or not we got the magic character */
 508         for (i = 0; i != len; i++) {
 509                 if (get_user(c, data + i))
 510                         return -EFAULT;
 511                 if (c == 'V')
 512                         set_bit(_WDOG_ALLOW_RELEASE, &wd_data->status);
 513         }
 514
 515         /* someone wrote to us, so we send the watchdog a keepalive ping */
 516
 517         err = -ENODEV;
 518         mutex_lock(&wd_data->lock);
 519         wdd = wd_data->wdd;
 520         if (wdd)
 521                 err = watchdog_ping(wdd);
 522         mutex_unlock(&wd_data->lock);
 523
 524         if (err < 0)
 525                 return err;
 526
 527         return len;
 528 }
 529
 530 /*
 531  *      watchdog_ioctl: handle the different ioctl's for the watchdog device.
 532  *      @file: file handle to the device
 533  *      @cmd: watchdog command
 534  *      @arg: argument pointer
 535  *
 536  *      The watchdog API defines a common set of functions for all watchdogs
 537  *      according to their available features.
 538  */
 539
 540 static long watchdog_ioctl(struct file *file, unsigned int cmd,
 541                                                         unsigned long arg)
 542 {
 543         struct watchdog_core_data *wd_data = file->private_data;
 544         void __user *argp = (void __user *)arg;
 545         struct watchdog_device *wdd;
 546         int __user *p = argp;
 547         unsigned int val;
 548         int err;
 549
 550         mutex_lock(&wd_data->lock);
 551
 552         wdd = wd_data->wdd;
 553         if (!wdd) {
 554                 err = -ENODEV;
 555                 goto out_ioctl;
 556         }
 557
 558         err = watchdog_ioctl_op(wdd, cmd, arg);
 559         if (err != -ENOIOCTLCMD)
 560                 goto out_ioctl;
 561
 562         switch (cmd) {
 563         case WDIOC_GETSUPPORT:
 564                 err = copy_to_user(argp, wdd->info,
 565                         sizeof(struct watchdog_info)) ? -EFAULT : 0;
 566                 break;
 567         case WDIOC_GETSTATUS:
 568                 val = watchdog_get_status(wdd);
 569                 err = put_user(val, p);
 570                 break;
 571         case WDIOC_GETBOOTSTATUS:
 572                 err = put_user(wdd->bootstatus, p);
 573                 break;
 574         case WDIOC_SETOPTIONS:
 575                 if (get_user(val, p)) {
 576                         err = -EFAULT;
 577                         break;
 578                 }
 579                 if (val & WDIOS_DISABLECARD) {
 580                         err = watchdog_stop(wdd);
 581                         if (err < 0)
 582                                 break;
 583                 }
 584                 if (val & WDIOS_ENABLECARD)
 585                         err = watchdog_start(wdd);
 586                 break;
 587         case WDIOC_KEEPALIVE:
 588                 if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) {
 589                         err = -EOPNOTSUPP;
 590                         break;
 591                 }
 592                 err = watchdog_ping(wdd);
 593                 break;
 594         case WDIOC_SETTIMEOUT:
 595                 if (get_user(val, p)) {
 596                         err = -EFAULT;
 597                         break;
 598                 }
 599                 err = watchdog_set_timeout(wdd, val);
 600                 if (err < 0)
 601                         break;
 602                 /* If the watchdog is active then we send a keepalive ping
 603                  * to make sure that the watchdog keep's running (and if
 604                  * possible that it takes the new timeout) */
 605                 err = watchdog_ping(wdd);
 606                 if (err < 0)
 607                         break;
 608                 /* Fall */
 609         case WDIOC_GETTIMEOUT:
 610                 /* timeout == 0 means that we don't know the timeout */
 611                 if (wdd->timeout == 0) {
 612                         err = -EOPNOTSUPP;
 613                         break;
 614                 }
 615                 err = put_user(wdd->timeout, p);
 616                 break;
 617         case WDIOC_GETTIMELEFT:
 618                 err = watchdog_get_timeleft(wdd, &val);
 619                 if (err < 0)
 620                         break;
 621                 err = put_user(val, p);
 622                 break;
 623         default:
 624                 err = -ENOTTY;
 625                 break;
 626         }
 627
 628 out_ioctl:
 629         mutex_unlock(&wd_data->lock);
 630         return err;
 631 }
 632
 633 /*
 634  *      watchdog_open: open the /dev/watchdog* devices.
 635  *      @inode: inode of device
 636  *      @file: file handle to device
 637  *
 638  *      When the /dev/watchdog* device gets opened, we start the watchdog.
 639  *      Watch out: the /dev/watchdog device is single open, so we make sure
 640  *      it can only be opened once.
 641  */
 642
 643 static int watchdog_open(struct inode *inode, struct file *file)
 644 {
 645         struct watchdog_core_data *wd_data;
 646         struct watchdog_device *wdd;
 647         int err;
 648
 649         /* Get the corresponding watchdog device */
 650         if (imajor(inode) == MISC_MAJOR)
 651                 wd_data = old_wd_data;
 652         else
 653                 wd_data = container_of(inode->i_cdev, struct watchdog_core_data,
 654                                        cdev);
 655
 656         /* the watchdog is single open! */
 657         if (test_and_set_bit(_WDOG_DEV_OPEN, &wd_data->status))
 658                 return -EBUSY;
 659
 660         wdd = wd_data->wdd;
 661
 662         /*
 663          * If the /dev/watchdog device is open, we don't want the module
 664          * to be unloaded.
 665          */
 666         if (!watchdog_hw_running(wdd) && !try_module_get(wdd->ops->owner)) {
 667                 err = -EBUSY;
 668                 goto out_clear;
 669         }
 670
 671         err = watchdog_start(wdd);
 672         if (err < 0)
 673                 goto out_mod;
 674
 675         file->private_data = wd_data;
 676
 677         if (!watchdog_hw_running(wdd))
 678                 kref_get(&wd_data->kref);
 679
 680         /* dev/watchdog is a virtual (and thus non-seekable) filesystem */
 681         return nonseekable_open(inode, file);
 682
 683 out_mod:
 684         module_put(wd_data->wdd->ops->owner);
 685 out_clear:
 686         clear_bit(_WDOG_DEV_OPEN, &wd_data->status);
 687         return err;
 688 }
 689
 690 static void watchdog_core_data_release(struct kref *kref)
 691 {
 692         struct watchdog_core_data *wd_data;
 693
 694         wd_data = container_of(kref, struct watchdog_core_data, kref);
 695
 696         kfree(wd_data);
 697 }
 698
 699 /*
 700  *      watchdog_release: release the watchdog device.
 701  *      @inode: inode of device
 702  *      @file: file handle to device
 703  *
 704  *      This is the code for when /dev/watchdog gets closed. We will only
 705  *      stop the watchdog when we have received the magic char (and nowayout
 706  *      was not set), else the watchdog will keep running.
 707  */
 708
 709 static int watchdog_release(struct inode *inode, struct file *file)
 710 {
 711         struct watchdog_core_data *wd_data = file->private_data;
 712         struct watchdog_device *wdd;
 713         int err = -EBUSY;
 714         bool running;
 715
 716         mutex_lock(&wd_data->lock);
 717
 718         wdd = wd_data->wdd;
 719         if (!wdd)
 720                 goto done;
 721
 722         /*
 723          * We only stop the watchdog if we received the magic character
 724          * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then
 725          * watchdog_stop will fail.
 726          */
 727         if (!test_bit(WDOG_ACTIVE, &wdd->status))
 728                 err = 0;
 729         else if (test_and_clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status) ||
 730                  !(wdd->info->options & WDIOF_MAGICCLOSE))
 731                 err = watchdog_stop(wdd);
 732
 733         /* If the watchdog was not stopped, send a keepalive ping */
 734         if (err < 0) {
 735                 pr_crit("watchdog%d: watchdog did not stop!\n", wdd->id);
 736                 watchdog_ping(wdd);
 737         }
 738
 739         cancel_delayed_work_sync(&wd_data->work);
 740         watchdog_update_worker(wdd);
 741
 742         /* make sure that /dev/watchdog can be re-opened */
 743         clear_bit(_WDOG_DEV_OPEN, &wd_data->status);
 744
 745 done:
 746         running = wdd && watchdog_hw_running(wdd);
 747         mutex_unlock(&wd_data->lock);
 748         /*
 749          * Allow the owner module to be unloaded again unless the watchdog
 750          * is still running. If the watchdog is still running, it can not
 751          * be stopped, and its driver must not be unloaded.
 752          */
 753         if (!running) {
 754                 module_put(wd_data->cdev.owner);
 755                 kref_put(&wd_data->kref, watchdog_core_data_release);
 756         }
 757         return 0;
 758 }
 759
 760 static const struct file_operations watchdog_fops = {
 761         .owner          = THIS_MODULE,
 762         .write          = watchdog_write,
 763         .unlocked_ioctl = watchdog_ioctl,
 764         .open           = watchdog_open,
 765         .release        = watchdog_release,
 766 };
 767
 768 static struct miscdevice watchdog_miscdev = {
 769         .minor          = WATCHDOG_MINOR,
 770         .name           = "watchdog",
 771         .fops           = &watchdog_fops,
 772 };
 773
 774 /*
 775  *      watchdog_cdev_register: register watchdog character device
 776  *      @wdd: watchdog device
 777  *      @devno: character device number
 778  *
 779  *      Register a watchdog character device including handling the legacy
 780  *      /dev/watchdog node. /dev/watchdog is actually a miscdevice and
 781  *      thus we set it up like that.
 782  */
 783
 784 static int watchdog_cdev_register(struct watchdog_device *wdd, dev_t devno)
 785 {
 786         struct watchdog_core_data *wd_data;
 787         int err;
 788
 789         wd_data = kzalloc(sizeof(struct watchdog_core_data), GFP_KERNEL);
 790         if (!wd_data)
 791                 return -ENOMEM;
 792         kref_init(&wd_data->kref);
 793         mutex_init(&wd_data->lock);
 794
 795         wd_data->wdd = wdd;
 796         wdd->wd_data = wd_data;
 797
 798         if (!watchdog_wq)
 799                 return -ENODEV;
 800
 801         INIT_DELAYED_WORK(&wd_data->work, watchdog_ping_work);
 802
 803         if (wdd->id == 0) {
 804                 old_wd_data = wd_data;
 805                 watchdog_miscdev.parent = wdd->parent;
 806                 err = misc_register(&watchdog_miscdev);
 807                 if (err != 0) {
 808                         pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n",
 809                                 wdd->info->identity, WATCHDOG_MINOR, err);
 810                         if (err == -EBUSY)
 811                                 pr_err("%s: a legacy watchdog module is probably present.\n",
 812                                         wdd->info->identity);
 813                         old_wd_data = NULL;
 814                         kfree(wd_data);
 815                         return err;
 816                 }
 817         }
 818
 819         /* Fill in the data structures */
 820         cdev_init(&wd_data->cdev, &watchdog_fops);
 821         wd_data->cdev.owner = wdd->ops->owner;
 822
 823         /* Add the device */
 824         err = cdev_add(&wd_data->cdev, devno, 1);
 825         if (err) {
 826                 pr_err("watchdog%d unable to add device %d:%d\n",
 827                         wdd->id,  MAJOR(watchdog_devt), wdd->id);
 828                 if (wdd->id == 0) {
 829                         misc_deregister(&watchdog_miscdev);
 830                         old_wd_data = NULL;
 831                         kref_put(&wd_data->kref, watchdog_core_data_release);
 832                 }
 833                 return err;
 834         }
 835
 836         /* Record time of most recent heartbeat as 'just before now'. */
 837         wd_data->last_hw_keepalive = jiffies - 1;
 838
 839         /*
 840          * If the watchdog is running, prevent its driver from being unloaded,
 841          * and schedule an immediate ping.
 842          */
 843         if (watchdog_hw_running(wdd)) {
 844                 __module_get(wdd->ops->owner);
 845                 kref_get(&wd_data->kref);
 846                 queue_delayed_work(watchdog_wq, &wd_data->work, 0);
 847         }
 848
 849         return 0;
 850 }
 851
 852 /*
 853  *      watchdog_cdev_unregister: unregister watchdog character device
 854  *      @watchdog: watchdog device
 855  *
 856  *      Unregister watchdog character device and if needed the legacy
 857  *      /dev/watchdog device.
 858  */
 859
 860 static void watchdog_cdev_unregister(struct watchdog_device *wdd)
 861 {
 862         struct watchdog_core_data *wd_data = wdd->wd_data;
 863
 864         cdev_del(&wd_data->cdev);
 865         if (wdd->id == 0) {
 866                 misc_deregister(&watchdog_miscdev);
 867                 old_wd_data = NULL;
 868         }
 869
 870         mutex_lock(&wd_data->lock);
 871         wd_data->wdd = NULL;
 872         wdd->wd_data = NULL;
 873         mutex_unlock(&wd_data->lock);
 874
 875         cancel_delayed_work_sync(&wd_data->work);
 876
 877         kref_put(&wd_data->kref, watchdog_core_data_release);
 878 }
 879
 880 static struct class watchdog_class = {
 881         .name =         "watchdog",
 882         .owner =        THIS_MODULE,
 883         .dev_groups =   wdt_groups,
 884 };
 885
 886 /*
 887  *      watchdog_dev_register: register a watchdog device
 888  *      @wdd: watchdog device
 889  *
 890  *      Register a watchdog device including handling the legacy
 891  *      /dev/watchdog node. /dev/watchdog is actually a miscdevice and
 892  *      thus we set it up like that.
 893  */
 894
 895 int watchdog_dev_register(struct watchdog_device *wdd)
 896 {
 897         struct device *dev;
 898         dev_t devno;
 899         int ret;
 900
 901         devno = MKDEV(MAJOR(watchdog_devt), wdd->id);
 902
 903         ret = watchdog_cdev_register(wdd, devno);
 904         if (ret)
 905                 return ret;
 906
 907         dev = device_create_with_groups(&watchdog_class, wdd->parent,
 908                                         devno, wdd, wdd->groups,
 909                                         "watchdog%d", wdd->id);
 910         if (IS_ERR(dev)) {
 911                 watchdog_cdev_unregister(wdd);
 912                 return PTR_ERR(dev);
 913         }
 914
 915         return ret;
 916 }
 917
 918 /*
 919  *      watchdog_dev_unregister: unregister a watchdog device
 920  *      @watchdog: watchdog device
 921  *
 922  *      Unregister watchdog device and if needed the legacy
 923  *      /dev/watchdog device.
 924  */
 925
 926 void watchdog_dev_unregister(struct watchdog_device *wdd)
 927 {
 928         device_destroy(&watchdog_class, wdd->wd_data->cdev.dev);
 929         watchdog_cdev_unregister(wdd);
 930 }
 931
 932 /*
 933  *      watchdog_dev_init: init dev part of watchdog core
 934  *
 935  *      Allocate a range of chardev nodes to use for watchdog devices
 936  */
 937
 938 int __init watchdog_dev_init(void)
 939 {
 940         int err;
 941
 942         watchdog_wq = alloc_workqueue("watchdogd",
 943                                       WQ_HIGHPRI | WQ_MEM_RECLAIM, 0);
 944         if (!watchdog_wq) {
 945                 pr_err("Failed to create watchdog workqueue\n");
 946                 return -ENOMEM;
 947         }
 948
 949         err = class_register(&watchdog_class);
 950         if (err < 0) {
 951                 pr_err("couldn't register class\n");
 952                 return err;
 953         }
 954
 955         err = alloc_chrdev_region(&watchdog_devt, 0, MAX_DOGS, "watchdog");
 956         if (err < 0) {
 957                 pr_err("watchdog: unable to allocate char dev region\n");
 958                 class_unregister(&watchdog_class);
 959                 return err;
 960         }
 961
 962         return 0;
 963 }
 964
 965 /*
 966  *      watchdog_dev_exit: exit dev part of watchdog core
 967  *
 968  *      Release the range of chardev nodes used for watchdog devices
 969  */
 970
 971 void __exit watchdog_dev_exit(void)
 972 {
 973         unregister_chrdev_region(watchdog_devt, MAX_DOGS);
 974         class_unregister(&watchdog_class);
 975         destroy_workqueue(watchdog_wq);
 976 }