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