1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * watchdog_dev.c 4 * 5 * (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>, 6 * All Rights Reserved. 7 * 8 * (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>. 9 * 10 * (c) Copyright 2021 Hewlett Packard Enterprise Development LP. 11 * 12 * This source code is part of the generic code that can be used 13 * by all the watchdog timer drivers. 14 * 15 * This part of the generic code takes care of the following 16 * misc device: /dev/watchdog. 17 * 18 * Based on source code of the following authors: 19 * Matt Domsch <Matt_Domsch@dell.com>, 20 * Rob Radez <rob@osinvestor.com>, 21 * Rusty Lynch <rusty@linux.co.intel.com> 22 * Satyam Sharma <satyam@infradead.org> 23 * Randy Dunlap <randy.dunlap@oracle.com> 24 * 25 * Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw. 26 * admit liability nor provide warranty for any of this software. 27 * This material is provided "AS-IS" and at no charge. 28 */ 29 30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 31 32 #include <linux/cdev.h> /* For character device */ 33 #include <linux/errno.h> /* For the -ENODEV/... values */ 34 #include <linux/fs.h> /* For file operations */ 35 #include <linux/init.h> /* For __init/__exit/... */ 36 #include <linux/hrtimer.h> /* For hrtimers */ 37 #include <linux/kernel.h> /* For printk/panic/... */ 38 #include <linux/kstrtox.h> /* For kstrto* */ 39 #include <linux/kthread.h> /* For kthread_work */ 40 #include <linux/miscdevice.h> /* For handling misc devices */ 41 #include <linux/module.h> /* For module stuff/... */ 42 #include <linux/mutex.h> /* For mutexes */ 43 #include <linux/slab.h> /* For memory functions */ 44 #include <linux/types.h> /* For standard types (like size_t) */ 45 #include <linux/watchdog.h> /* For watchdog specific items */ 46 #include <linux/uaccess.h> /* For copy_to_user/put_user/... */ 47 48 #include "watchdog_core.h" 49 #include "watchdog_pretimeout.h" 50 51 #include <trace/events/watchdog.h> 52 53 /* the dev_t structure to store the dynamically allocated watchdog devices */ 54 static dev_t watchdog_devt; 55 /* Reference to watchdog device behind /dev/watchdog */ 56 static struct watchdog_core_data *old_wd_data; 57 58 static struct kthread_worker *watchdog_kworker; 59 60 static bool handle_boot_enabled = 61 IS_ENABLED(CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED); 62 63 static unsigned open_timeout = CONFIG_WATCHDOG_OPEN_TIMEOUT; 64 65 static bool watchdog_past_open_deadline(struct watchdog_core_data *data) 66 { 67 return ktime_after(ktime_get(), data->open_deadline); 68 } 69 70 static void watchdog_set_open_deadline(struct watchdog_core_data *data) 71 { 72 data->open_deadline = open_timeout ? 73 ktime_get() + ktime_set(open_timeout, 0) : KTIME_MAX; 74 } 75 76 static inline bool watchdog_need_worker(struct watchdog_device *wdd) 77 { 78 /* All variables in milli-seconds */ 79 unsigned int hm = wdd->max_hw_heartbeat_ms; 80 unsigned int t = wdd->timeout * 1000; 81 82 /* 83 * A worker to generate heartbeat requests is needed if all of the 84 * following conditions are true. 85 * - Userspace activated the watchdog. 86 * - The driver provided a value for the maximum hardware timeout, and 87 * thus is aware that the framework supports generating heartbeat 88 * requests. 89 * - Userspace requests a longer timeout than the hardware can handle. 90 * 91 * Alternatively, if userspace has not opened the watchdog 92 * device, we take care of feeding the watchdog if it is 93 * running. 94 */ 95 return (hm && watchdog_active(wdd) && t > hm) || 96 (t && !watchdog_active(wdd) && watchdog_hw_running(wdd)); 97 } 98 99 static ktime_t watchdog_next_keepalive(struct watchdog_device *wdd) 100 { 101 struct watchdog_core_data *wd_data = wdd->wd_data; 102 unsigned int timeout_ms = wdd->timeout * 1000; 103 ktime_t keepalive_interval; 104 ktime_t last_heartbeat, latest_heartbeat; 105 ktime_t virt_timeout; 106 unsigned int hw_heartbeat_ms; 107 108 if (watchdog_active(wdd)) 109 virt_timeout = ktime_add(wd_data->last_keepalive, 110 ms_to_ktime(timeout_ms)); 111 else 112 virt_timeout = wd_data->open_deadline; 113 114 hw_heartbeat_ms = min_not_zero(timeout_ms, wdd->max_hw_heartbeat_ms); 115 keepalive_interval = ms_to_ktime(hw_heartbeat_ms / 2); 116 117 /* 118 * To ensure that the watchdog times out wdd->timeout seconds 119 * after the most recent ping from userspace, the last 120 * worker ping has to come in hw_heartbeat_ms before this timeout. 121 */ 122 last_heartbeat = ktime_sub(virt_timeout, ms_to_ktime(hw_heartbeat_ms)); 123 latest_heartbeat = ktime_sub(last_heartbeat, ktime_get()); 124 if (ktime_before(latest_heartbeat, keepalive_interval)) 125 return latest_heartbeat; 126 return keepalive_interval; 127 } 128 129 static inline void watchdog_update_worker(struct watchdog_device *wdd) 130 { 131 struct watchdog_core_data *wd_data = wdd->wd_data; 132 133 if (watchdog_need_worker(wdd)) { 134 ktime_t t = watchdog_next_keepalive(wdd); 135 136 if (t > 0) 137 hrtimer_start(&wd_data->timer, t, 138 HRTIMER_MODE_REL_HARD); 139 } else { 140 hrtimer_cancel(&wd_data->timer); 141 } 142 } 143 144 static int __watchdog_ping(struct watchdog_device *wdd) 145 { 146 struct watchdog_core_data *wd_data = wdd->wd_data; 147 ktime_t earliest_keepalive, now; 148 int err; 149 150 earliest_keepalive = ktime_add(wd_data->last_hw_keepalive, 151 ms_to_ktime(wdd->min_hw_heartbeat_ms)); 152 now = ktime_get(); 153 154 if (ktime_after(earliest_keepalive, now)) { 155 hrtimer_start(&wd_data->timer, 156 ktime_sub(earliest_keepalive, now), 157 HRTIMER_MODE_REL_HARD); 158 return 0; 159 } 160 161 wd_data->last_hw_keepalive = now; 162 163 if (wdd->ops->ping) { 164 err = wdd->ops->ping(wdd); /* ping the watchdog */ 165 trace_watchdog_ping(wdd, err); 166 } else { 167 err = wdd->ops->start(wdd); /* restart watchdog */ 168 trace_watchdog_start(wdd, err); 169 } 170 171 if (err == 0) 172 watchdog_hrtimer_pretimeout_start(wdd); 173 174 watchdog_update_worker(wdd); 175 176 return err; 177 } 178 179 /* 180 * watchdog_ping - ping the watchdog 181 * @wdd: The watchdog device to ping 182 * 183 * If the watchdog has no own ping operation then it needs to be 184 * restarted via the start operation. This wrapper function does 185 * exactly that. 186 * We only ping when the watchdog device is running. 187 * The caller must hold wd_data->lock. 188 * 189 * Return: 0 on success, error otherwise. 190 */ 191 static int watchdog_ping(struct watchdog_device *wdd) 192 { 193 struct watchdog_core_data *wd_data = wdd->wd_data; 194 195 if (!watchdog_active(wdd) && !watchdog_hw_running(wdd)) 196 return 0; 197 198 set_bit(_WDOG_KEEPALIVE, &wd_data->status); 199 200 wd_data->last_keepalive = ktime_get(); 201 return __watchdog_ping(wdd); 202 } 203 204 static bool watchdog_worker_should_ping(struct watchdog_core_data *wd_data) 205 { 206 struct watchdog_device *wdd = wd_data->wdd; 207 208 if (!wdd) 209 return false; 210 211 if (watchdog_active(wdd)) 212 return true; 213 214 return watchdog_hw_running(wdd) && !watchdog_past_open_deadline(wd_data); 215 } 216 217 static void watchdog_ping_work(struct kthread_work *work) 218 { 219 struct watchdog_core_data *wd_data; 220 221 wd_data = container_of(work, struct watchdog_core_data, work); 222 223 mutex_lock(&wd_data->lock); 224 if (watchdog_worker_should_ping(wd_data)) 225 __watchdog_ping(wd_data->wdd); 226 mutex_unlock(&wd_data->lock); 227 } 228 229 static enum hrtimer_restart watchdog_timer_expired(struct hrtimer *timer) 230 { 231 struct watchdog_core_data *wd_data; 232 233 wd_data = container_of(timer, struct watchdog_core_data, timer); 234 235 kthread_queue_work(watchdog_kworker, &wd_data->work); 236 return HRTIMER_NORESTART; 237 } 238 239 /* 240 * watchdog_start - wrapper to start the watchdog 241 * @wdd: The watchdog device to start 242 * 243 * Start the watchdog if it is not active and mark it active. 244 * The caller must hold wd_data->lock. 245 * 246 * Return: 0 on success or a negative errno code for failure. 247 */ 248 static int watchdog_start(struct watchdog_device *wdd) 249 { 250 struct watchdog_core_data *wd_data = wdd->wd_data; 251 ktime_t started_at; 252 int err; 253 254 if (watchdog_active(wdd)) 255 return 0; 256 257 set_bit(_WDOG_KEEPALIVE, &wd_data->status); 258 259 started_at = ktime_get(); 260 if (watchdog_hw_running(wdd) && wdd->ops->ping) { 261 err = __watchdog_ping(wdd); 262 if (err == 0) { 263 set_bit(WDOG_ACTIVE, &wdd->status); 264 watchdog_hrtimer_pretimeout_start(wdd); 265 } 266 } else { 267 err = wdd->ops->start(wdd); 268 trace_watchdog_start(wdd, err); 269 if (err == 0) { 270 set_bit(WDOG_ACTIVE, &wdd->status); 271 wd_data->last_keepalive = started_at; 272 wd_data->last_hw_keepalive = started_at; 273 watchdog_update_worker(wdd); 274 watchdog_hrtimer_pretimeout_start(wdd); 275 } 276 } 277 278 return err; 279 } 280 281 /* 282 * watchdog_stop - wrapper to stop the watchdog 283 * @wdd: The watchdog device to stop 284 * 285 * Stop the watchdog if it is still active and unmark it active. 286 * If the 'nowayout' feature was set, the watchdog cannot be stopped. 287 * The caller must hold wd_data->lock. 288 * 289 * Return: 0 on success or a negative errno code for failure. 290 */ 291 static int watchdog_stop(struct watchdog_device *wdd) 292 { 293 int err = 0; 294 295 if (!watchdog_active(wdd)) 296 return 0; 297 298 if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) { 299 pr_info("watchdog%d: nowayout prevents watchdog being stopped!\n", 300 wdd->id); 301 return -EBUSY; 302 } 303 304 if (wdd->ops->stop) { 305 clear_bit(WDOG_HW_RUNNING, &wdd->status); 306 err = wdd->ops->stop(wdd); 307 trace_watchdog_stop(wdd, err); 308 } else { 309 set_bit(WDOG_HW_RUNNING, &wdd->status); 310 } 311 312 if (err == 0) { 313 clear_bit(WDOG_ACTIVE, &wdd->status); 314 watchdog_update_worker(wdd); 315 watchdog_hrtimer_pretimeout_stop(wdd); 316 } 317 318 return err; 319 } 320 321 /* 322 * watchdog_get_status - wrapper to get the watchdog status 323 * @wdd: The watchdog device to get the status from 324 * 325 * Get the watchdog's status flags. 326 * The caller must hold wd_data->lock. 327 * 328 * Return: watchdog's status flags. 329 */ 330 static unsigned int watchdog_get_status(struct watchdog_device *wdd) 331 { 332 struct watchdog_core_data *wd_data = wdd->wd_data; 333 unsigned int status; 334 335 if (wdd->ops->status) 336 status = wdd->ops->status(wdd); 337 else 338 status = wdd->bootstatus & (WDIOF_CARDRESET | 339 WDIOF_OVERHEAT | 340 WDIOF_FANFAULT | 341 WDIOF_EXTERN1 | 342 WDIOF_EXTERN2 | 343 WDIOF_POWERUNDER | 344 WDIOF_POWEROVER); 345 346 if (test_bit(_WDOG_ALLOW_RELEASE, &wd_data->status)) 347 status |= WDIOF_MAGICCLOSE; 348 349 if (test_and_clear_bit(_WDOG_KEEPALIVE, &wd_data->status)) 350 status |= WDIOF_KEEPALIVEPING; 351 352 if (IS_ENABLED(CONFIG_WATCHDOG_HRTIMER_PRETIMEOUT)) 353 status |= WDIOF_PRETIMEOUT; 354 355 return status; 356 } 357 358 /* 359 * watchdog_set_timeout - set the watchdog timer timeout 360 * @wdd: The watchdog device to set the timeout for 361 * @timeout: Timeout to set in seconds 362 * 363 * The caller must hold wd_data->lock. 364 * 365 * Return: 0 if successful, error otherwise. 366 */ 367 static int watchdog_set_timeout(struct watchdog_device *wdd, 368 unsigned int timeout) 369 { 370 int err = 0; 371 372 if (!(wdd->info->options & WDIOF_SETTIMEOUT)) 373 return -EOPNOTSUPP; 374 375 if (watchdog_timeout_invalid(wdd, timeout)) 376 return -EINVAL; 377 378 if (wdd->ops->set_timeout) { 379 err = wdd->ops->set_timeout(wdd, timeout); 380 trace_watchdog_set_timeout(wdd, timeout, err); 381 } else { 382 wdd->timeout = timeout; 383 /* Disable pretimeout if it doesn't fit the new timeout */ 384 if (wdd->pretimeout >= wdd->timeout) 385 wdd->pretimeout = 0; 386 } 387 388 watchdog_update_worker(wdd); 389 390 return err; 391 } 392 393 /* 394 * watchdog_set_pretimeout - set the watchdog timer pretimeout 395 * @wdd: The watchdog device to set the timeout for 396 * @timeout: pretimeout to set in seconds 397 * 398 * Return: 0 if successful, error otherwise. 399 */ 400 static int watchdog_set_pretimeout(struct watchdog_device *wdd, 401 unsigned int timeout) 402 { 403 int err = 0; 404 405 if (!watchdog_have_pretimeout(wdd)) 406 return -EOPNOTSUPP; 407 408 if (watchdog_pretimeout_invalid(wdd, timeout)) 409 return -EINVAL; 410 411 if (wdd->ops->set_pretimeout && (wdd->info->options & WDIOF_PRETIMEOUT)) 412 err = wdd->ops->set_pretimeout(wdd, timeout); 413 else 414 wdd->pretimeout = timeout; 415 416 return err; 417 } 418 419 /* 420 * watchdog_get_timeleft - wrapper to get the time left before a reboot 421 * @wdd: The watchdog device to get the remaining time from 422 * @timeleft: The time that's left 423 * 424 * Get the time before a watchdog will reboot (if not pinged). 425 * The caller must hold wd_data->lock. 426 * 427 * Return: 0 if successful, error otherwise. 428 */ 429 static int watchdog_get_timeleft(struct watchdog_device *wdd, 430 unsigned int *timeleft) 431 { 432 *timeleft = 0; 433 434 if (!wdd->ops->get_timeleft) 435 return -EOPNOTSUPP; 436 437 *timeleft = wdd->ops->get_timeleft(wdd); 438 439 return 0; 440 } 441 442 #ifdef CONFIG_WATCHDOG_SYSFS 443 static ssize_t nowayout_show(struct device *dev, struct device_attribute *attr, 444 char *buf) 445 { 446 struct watchdog_device *wdd = dev_get_drvdata(dev); 447 448 return sysfs_emit(buf, "%d\n", !!test_bit(WDOG_NO_WAY_OUT, 449 &wdd->status)); 450 } 451 452 static ssize_t nowayout_store(struct device *dev, struct device_attribute *attr, 453 const char *buf, size_t len) 454 { 455 struct watchdog_device *wdd = dev_get_drvdata(dev); 456 unsigned int value; 457 int ret; 458 459 ret = kstrtouint(buf, 0, &value); 460 if (ret) 461 return ret; 462 if (value > 1) 463 return -EINVAL; 464 /* nowayout cannot be disabled once set */ 465 if (test_bit(WDOG_NO_WAY_OUT, &wdd->status) && !value) 466 return -EPERM; 467 watchdog_set_nowayout(wdd, value); 468 return len; 469 } 470 static DEVICE_ATTR_RW(nowayout); 471 472 static ssize_t status_show(struct device *dev, struct device_attribute *attr, 473 char *buf) 474 { 475 struct watchdog_device *wdd = dev_get_drvdata(dev); 476 struct watchdog_core_data *wd_data = wdd->wd_data; 477 unsigned int status; 478 479 mutex_lock(&wd_data->lock); 480 status = watchdog_get_status(wdd); 481 mutex_unlock(&wd_data->lock); 482 483 return sysfs_emit(buf, "0x%x\n", status); 484 } 485 static DEVICE_ATTR_RO(status); 486 487 static ssize_t bootstatus_show(struct device *dev, 488 struct device_attribute *attr, char *buf) 489 { 490 struct watchdog_device *wdd = dev_get_drvdata(dev); 491 492 return sysfs_emit(buf, "%u\n", wdd->bootstatus); 493 } 494 static DEVICE_ATTR_RO(bootstatus); 495 496 static ssize_t timeleft_show(struct device *dev, struct device_attribute *attr, 497 char *buf) 498 { 499 struct watchdog_device *wdd = dev_get_drvdata(dev); 500 struct watchdog_core_data *wd_data = wdd->wd_data; 501 ssize_t status; 502 unsigned int val; 503 504 mutex_lock(&wd_data->lock); 505 status = watchdog_get_timeleft(wdd, &val); 506 mutex_unlock(&wd_data->lock); 507 if (!status) 508 status = sysfs_emit(buf, "%u\n", val); 509 510 return status; 511 } 512 static DEVICE_ATTR_RO(timeleft); 513 514 static ssize_t timeout_show(struct device *dev, struct device_attribute *attr, 515 char *buf) 516 { 517 struct watchdog_device *wdd = dev_get_drvdata(dev); 518 519 return sysfs_emit(buf, "%u\n", wdd->timeout); 520 } 521 static DEVICE_ATTR_RO(timeout); 522 523 static ssize_t min_timeout_show(struct device *dev, 524 struct device_attribute *attr, char *buf) 525 { 526 struct watchdog_device *wdd = dev_get_drvdata(dev); 527 528 return sysfs_emit(buf, "%u\n", wdd->min_timeout); 529 } 530 static DEVICE_ATTR_RO(min_timeout); 531 532 static ssize_t max_timeout_show(struct device *dev, 533 struct device_attribute *attr, char *buf) 534 { 535 struct watchdog_device *wdd = dev_get_drvdata(dev); 536 537 return sysfs_emit(buf, "%u\n", wdd->max_timeout); 538 } 539 static DEVICE_ATTR_RO(max_timeout); 540 541 static ssize_t pretimeout_show(struct device *dev, 542 struct device_attribute *attr, char *buf) 543 { 544 struct watchdog_device *wdd = dev_get_drvdata(dev); 545 546 return sysfs_emit(buf, "%u\n", wdd->pretimeout); 547 } 548 static DEVICE_ATTR_RO(pretimeout); 549 550 static ssize_t options_show(struct device *dev, struct device_attribute *attr, 551 char *buf) 552 { 553 struct watchdog_device *wdd = dev_get_drvdata(dev); 554 555 return sysfs_emit(buf, "0x%x\n", wdd->info->options); 556 } 557 static DEVICE_ATTR_RO(options); 558 559 static ssize_t fw_version_show(struct device *dev, struct device_attribute *attr, 560 char *buf) 561 { 562 struct watchdog_device *wdd = dev_get_drvdata(dev); 563 564 return sysfs_emit(buf, "%d\n", wdd->info->firmware_version); 565 } 566 static DEVICE_ATTR_RO(fw_version); 567 568 static ssize_t identity_show(struct device *dev, struct device_attribute *attr, 569 char *buf) 570 { 571 struct watchdog_device *wdd = dev_get_drvdata(dev); 572 573 return sysfs_emit(buf, "%s\n", wdd->info->identity); 574 } 575 static DEVICE_ATTR_RO(identity); 576 577 static ssize_t state_show(struct device *dev, struct device_attribute *attr, 578 char *buf) 579 { 580 struct watchdog_device *wdd = dev_get_drvdata(dev); 581 582 if (watchdog_active(wdd)) 583 return sysfs_emit(buf, "active\n"); 584 585 return sysfs_emit(buf, "inactive\n"); 586 } 587 static DEVICE_ATTR_RO(state); 588 589 static ssize_t pretimeout_available_governors_show(struct device *dev, 590 struct device_attribute *attr, char *buf) 591 { 592 return watchdog_pretimeout_available_governors_get(buf); 593 } 594 static DEVICE_ATTR_RO(pretimeout_available_governors); 595 596 static ssize_t pretimeout_governor_show(struct device *dev, 597 struct device_attribute *attr, 598 char *buf) 599 { 600 struct watchdog_device *wdd = dev_get_drvdata(dev); 601 602 return watchdog_pretimeout_governor_get(wdd, buf); 603 } 604 605 static ssize_t pretimeout_governor_store(struct device *dev, 606 struct device_attribute *attr, 607 const char *buf, size_t count) 608 { 609 struct watchdog_device *wdd = dev_get_drvdata(dev); 610 int ret = watchdog_pretimeout_governor_set(wdd, buf); 611 612 if (!ret) 613 ret = count; 614 615 return ret; 616 } 617 static DEVICE_ATTR_RW(pretimeout_governor); 618 619 static umode_t wdt_is_visible(struct kobject *kobj, struct attribute *attr, 620 int n) 621 { 622 struct device *dev = kobj_to_dev(kobj); 623 struct watchdog_device *wdd = dev_get_drvdata(dev); 624 umode_t mode = attr->mode; 625 626 if (attr == &dev_attr_timeleft.attr && !wdd->ops->get_timeleft) 627 mode = 0; 628 else if (attr == &dev_attr_pretimeout.attr && !watchdog_have_pretimeout(wdd)) 629 mode = 0; 630 else if ((attr == &dev_attr_pretimeout_governor.attr || 631 attr == &dev_attr_pretimeout_available_governors.attr) && 632 (!watchdog_have_pretimeout(wdd) || !IS_ENABLED(CONFIG_WATCHDOG_PRETIMEOUT_GOV))) 633 mode = 0; 634 635 return mode; 636 } 637 static struct attribute *wdt_attrs[] = { 638 &dev_attr_state.attr, 639 &dev_attr_options.attr, 640 &dev_attr_fw_version.attr, 641 &dev_attr_identity.attr, 642 &dev_attr_timeout.attr, 643 &dev_attr_min_timeout.attr, 644 &dev_attr_max_timeout.attr, 645 &dev_attr_pretimeout.attr, 646 &dev_attr_timeleft.attr, 647 &dev_attr_bootstatus.attr, 648 &dev_attr_status.attr, 649 &dev_attr_nowayout.attr, 650 &dev_attr_pretimeout_governor.attr, 651 &dev_attr_pretimeout_available_governors.attr, 652 NULL, 653 }; 654 655 static const struct attribute_group wdt_group = { 656 .attrs = wdt_attrs, 657 .is_visible = wdt_is_visible, 658 }; 659 __ATTRIBUTE_GROUPS(wdt); 660 #else 661 #define wdt_groups NULL 662 #endif 663 664 /* 665 * watchdog_ioctl_op - call the watchdog drivers ioctl op if defined 666 * @wdd: The watchdog device to do the ioctl on 667 * @cmd: Watchdog command 668 * @arg: Argument pointer 669 * 670 * The caller must hold wd_data->lock. 671 * 672 * Return: 0 if successful, error otherwise. 673 */ 674 static int watchdog_ioctl_op(struct watchdog_device *wdd, unsigned int cmd, 675 unsigned long arg) 676 { 677 if (!wdd->ops->ioctl) 678 return -ENOIOCTLCMD; 679 680 return wdd->ops->ioctl(wdd, cmd, arg); 681 } 682 683 /* 684 * watchdog_write - writes to the watchdog 685 * @file: File from VFS 686 * @data: User address of data 687 * @len: Length of data 688 * @ppos: Pointer to the file offset 689 * 690 * A write to a watchdog device is defined as a keepalive ping. 691 * Writing the magic 'V' sequence allows the next close to turn 692 * off the watchdog (if 'nowayout' is not set). 693 * 694 * Return: @len if successful, error otherwise. 695 */ 696 static ssize_t watchdog_write(struct file *file, const char __user *data, 697 size_t len, loff_t *ppos) 698 { 699 struct watchdog_core_data *wd_data = file->private_data; 700 struct watchdog_device *wdd; 701 int err; 702 size_t i; 703 char c; 704 705 if (len == 0) 706 return 0; 707 708 /* 709 * Note: just in case someone wrote the magic character 710 * five months ago... 711 */ 712 clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status); 713 714 /* scan to see whether or not we got the magic character */ 715 for (i = 0; i != len; i++) { 716 if (get_user(c, data + i)) 717 return -EFAULT; 718 if (c == 'V') 719 set_bit(_WDOG_ALLOW_RELEASE, &wd_data->status); 720 } 721 722 /* someone wrote to us, so we send the watchdog a keepalive ping */ 723 724 err = -ENODEV; 725 mutex_lock(&wd_data->lock); 726 wdd = wd_data->wdd; 727 if (wdd) 728 err = watchdog_ping(wdd); 729 mutex_unlock(&wd_data->lock); 730 731 if (err < 0) 732 return err; 733 734 return len; 735 } 736 737 /* 738 * watchdog_ioctl - handle the different ioctl's for the watchdog device 739 * @file: File handle to the device 740 * @cmd: Watchdog command 741 * @arg: Argument pointer 742 * 743 * The watchdog API defines a common set of functions for all watchdogs 744 * according to their available features. 745 * 746 * Return: 0 if successful, error otherwise. 747 */ 748 749 static long watchdog_ioctl(struct file *file, unsigned int cmd, 750 unsigned long arg) 751 { 752 struct watchdog_core_data *wd_data = file->private_data; 753 void __user *argp = (void __user *)arg; 754 struct watchdog_device *wdd; 755 int __user *p = argp; 756 unsigned int val; 757 int err; 758 759 mutex_lock(&wd_data->lock); 760 761 wdd = wd_data->wdd; 762 if (!wdd) { 763 err = -ENODEV; 764 goto out_ioctl; 765 } 766 767 err = watchdog_ioctl_op(wdd, cmd, arg); 768 if (err != -ENOIOCTLCMD) 769 goto out_ioctl; 770 771 switch (cmd) { 772 case WDIOC_GETSUPPORT: 773 err = copy_to_user(argp, wdd->info, 774 sizeof(struct watchdog_info)) ? -EFAULT : 0; 775 break; 776 case WDIOC_GETSTATUS: 777 val = watchdog_get_status(wdd); 778 err = put_user(val, p); 779 break; 780 case WDIOC_GETBOOTSTATUS: 781 err = put_user(wdd->bootstatus, p); 782 break; 783 case WDIOC_SETOPTIONS: 784 if (get_user(val, p)) { 785 err = -EFAULT; 786 break; 787 } 788 if (val & WDIOS_DISABLECARD) { 789 err = watchdog_stop(wdd); 790 if (err < 0) 791 break; 792 } 793 if (val & WDIOS_ENABLECARD) 794 err = watchdog_start(wdd); 795 break; 796 case WDIOC_KEEPALIVE: 797 if (!(wdd->info->options & WDIOF_KEEPALIVEPING)) { 798 err = -EOPNOTSUPP; 799 break; 800 } 801 err = watchdog_ping(wdd); 802 break; 803 case WDIOC_SETTIMEOUT: 804 if (get_user(val, p)) { 805 err = -EFAULT; 806 break; 807 } 808 err = watchdog_set_timeout(wdd, val); 809 if (err < 0) 810 break; 811 /* If the watchdog is active then we send a keepalive ping 812 * to make sure that the watchdog keep's running (and if 813 * possible that it takes the new timeout) */ 814 err = watchdog_ping(wdd); 815 if (err < 0) 816 break; 817 fallthrough; 818 case WDIOC_GETTIMEOUT: 819 /* timeout == 0 means that we don't know the timeout */ 820 if (wdd->timeout == 0) { 821 err = -EOPNOTSUPP; 822 break; 823 } 824 err = put_user(wdd->timeout, p); 825 break; 826 case WDIOC_GETTIMELEFT: 827 err = watchdog_get_timeleft(wdd, &val); 828 if (err < 0) 829 break; 830 err = put_user(val, p); 831 break; 832 case WDIOC_SETPRETIMEOUT: 833 if (get_user(val, p)) { 834 err = -EFAULT; 835 break; 836 } 837 err = watchdog_set_pretimeout(wdd, val); 838 break; 839 case WDIOC_GETPRETIMEOUT: 840 err = put_user(wdd->pretimeout, p); 841 break; 842 default: 843 err = -ENOTTY; 844 break; 845 } 846 847 out_ioctl: 848 mutex_unlock(&wd_data->lock); 849 return err; 850 } 851 852 /* 853 * watchdog_open - open the /dev/watchdog* devices 854 * @inode: Inode of device 855 * @file: File handle to device 856 * 857 * When the /dev/watchdog* device gets opened, we start the watchdog. 858 * Watch out: the /dev/watchdog device is single open, so we make sure 859 * it can only be opened once. 860 * 861 * Return: 0 if successful, error otherwise. 862 */ 863 static int watchdog_open(struct inode *inode, struct file *file) 864 { 865 struct watchdog_core_data *wd_data; 866 struct watchdog_device *wdd; 867 bool hw_running; 868 int err; 869 870 /* Get the corresponding watchdog device */ 871 if (imajor(inode) == MISC_MAJOR) 872 wd_data = old_wd_data; 873 else 874 wd_data = container_of(inode->i_cdev, struct watchdog_core_data, 875 cdev); 876 877 /* the watchdog is single open! */ 878 if (test_and_set_bit(_WDOG_DEV_OPEN, &wd_data->status)) 879 return -EBUSY; 880 881 wdd = wd_data->wdd; 882 883 /* 884 * If the /dev/watchdog device is open, we don't want the module 885 * to be unloaded. 886 */ 887 hw_running = watchdog_hw_running(wdd); 888 if (!hw_running && !try_module_get(wdd->ops->owner)) { 889 err = -EBUSY; 890 goto out_clear; 891 } 892 893 err = watchdog_start(wdd); 894 if (err < 0) 895 goto out_mod; 896 897 file->private_data = wd_data; 898 899 if (!hw_running) 900 get_device(&wd_data->dev); 901 902 /* 903 * open_timeout only applies for the first open from 904 * userspace. Set open_deadline to infinity so that the kernel 905 * will take care of an always-running hardware watchdog in 906 * case the device gets magic-closed or WDIOS_DISABLECARD is 907 * applied. 908 */ 909 wd_data->open_deadline = KTIME_MAX; 910 911 /* dev/watchdog is a virtual (and thus non-seekable) filesystem */ 912 return stream_open(inode, file); 913 914 out_mod: 915 module_put(wd_data->wdd->ops->owner); 916 out_clear: 917 clear_bit(_WDOG_DEV_OPEN, &wd_data->status); 918 return err; 919 } 920 921 static void watchdog_core_data_release(struct device *dev) 922 { 923 struct watchdog_core_data *wd_data; 924 925 wd_data = container_of(dev, struct watchdog_core_data, dev); 926 927 kfree(wd_data); 928 } 929 930 /* 931 * watchdog_release - release the watchdog device 932 * @inode: Inode of device 933 * @file: File handle to device 934 * 935 * This is the code for when /dev/watchdog gets closed. We will only 936 * stop the watchdog when we have received the magic char (and nowayout 937 * was not set), else the watchdog will keep running. 938 * 939 * Always returns 0. 940 */ 941 static int watchdog_release(struct inode *inode, struct file *file) 942 { 943 struct watchdog_core_data *wd_data = file->private_data; 944 struct watchdog_device *wdd; 945 int err = -EBUSY; 946 bool running; 947 948 mutex_lock(&wd_data->lock); 949 950 wdd = wd_data->wdd; 951 if (!wdd) 952 goto done; 953 954 /* 955 * We only stop the watchdog if we received the magic character 956 * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then 957 * watchdog_stop will fail. 958 */ 959 if (!watchdog_active(wdd)) 960 err = 0; 961 else if (test_and_clear_bit(_WDOG_ALLOW_RELEASE, &wd_data->status) || 962 !(wdd->info->options & WDIOF_MAGICCLOSE)) 963 err = watchdog_stop(wdd); 964 965 /* If the watchdog was not stopped, send a keepalive ping */ 966 if (err < 0) { 967 pr_crit("watchdog%d: watchdog did not stop!\n", wdd->id); 968 watchdog_ping(wdd); 969 } 970 971 watchdog_update_worker(wdd); 972 973 /* make sure that /dev/watchdog can be re-opened */ 974 clear_bit(_WDOG_DEV_OPEN, &wd_data->status); 975 976 done: 977 running = wdd && watchdog_hw_running(wdd); 978 mutex_unlock(&wd_data->lock); 979 /* 980 * Allow the owner module to be unloaded again unless the watchdog 981 * is still running. If the watchdog is still running, it can not 982 * be stopped, and its driver must not be unloaded. 983 */ 984 if (!running) { 985 module_put(wd_data->cdev.owner); 986 put_device(&wd_data->dev); 987 } 988 return 0; 989 } 990 991 static const struct file_operations watchdog_fops = { 992 .owner = THIS_MODULE, 993 .write = watchdog_write, 994 .unlocked_ioctl = watchdog_ioctl, 995 .compat_ioctl = compat_ptr_ioctl, 996 .open = watchdog_open, 997 .release = watchdog_release, 998 }; 999 1000 static struct miscdevice watchdog_miscdev = { 1001 .minor = WATCHDOG_MINOR, 1002 .name = "watchdog", 1003 .fops = &watchdog_fops, 1004 }; 1005 1006 static struct class watchdog_class = { 1007 .name = "watchdog", 1008 .dev_groups = wdt_groups, 1009 }; 1010 1011 /* 1012 * watchdog_cdev_register - register watchdog character device 1013 * @wdd: Watchdog device 1014 * 1015 * Register a watchdog character device including handling the legacy 1016 * /dev/watchdog node. /dev/watchdog is actually a miscdevice and 1017 * thus we set it up like that. 1018 * 1019 * Return: 0 if successful, error otherwise. 1020 */ 1021 static int watchdog_cdev_register(struct watchdog_device *wdd) 1022 { 1023 struct watchdog_core_data *wd_data; 1024 int err; 1025 1026 wd_data = kzalloc(sizeof(struct watchdog_core_data), GFP_KERNEL); 1027 if (!wd_data) 1028 return -ENOMEM; 1029 mutex_init(&wd_data->lock); 1030 1031 wd_data->wdd = wdd; 1032 wdd->wd_data = wd_data; 1033 1034 if (IS_ERR_OR_NULL(watchdog_kworker)) { 1035 kfree(wd_data); 1036 return -ENODEV; 1037 } 1038 1039 device_initialize(&wd_data->dev); 1040 wd_data->dev.devt = MKDEV(MAJOR(watchdog_devt), wdd->id); 1041 wd_data->dev.class = &watchdog_class; 1042 wd_data->dev.parent = wdd->parent; 1043 wd_data->dev.groups = wdd->groups; 1044 wd_data->dev.release = watchdog_core_data_release; 1045 dev_set_drvdata(&wd_data->dev, wdd); 1046 err = dev_set_name(&wd_data->dev, "watchdog%d", wdd->id); 1047 if (err) { 1048 put_device(&wd_data->dev); 1049 return err; 1050 } 1051 1052 kthread_init_work(&wd_data->work, watchdog_ping_work); 1053 hrtimer_init(&wd_data->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL_HARD); 1054 wd_data->timer.function = watchdog_timer_expired; 1055 watchdog_hrtimer_pretimeout_init(wdd); 1056 1057 if (wdd->id == 0) { 1058 old_wd_data = wd_data; 1059 watchdog_miscdev.parent = wdd->parent; 1060 err = misc_register(&watchdog_miscdev); 1061 if (err != 0) { 1062 pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n", 1063 wdd->info->identity, WATCHDOG_MINOR, err); 1064 if (err == -EBUSY) 1065 pr_err("%s: a legacy watchdog module is probably present.\n", 1066 wdd->info->identity); 1067 old_wd_data = NULL; 1068 put_device(&wd_data->dev); 1069 return err; 1070 } 1071 } 1072 1073 /* Fill in the data structures */ 1074 cdev_init(&wd_data->cdev, &watchdog_fops); 1075 1076 /* Add the device */ 1077 err = cdev_device_add(&wd_data->cdev, &wd_data->dev); 1078 if (err) { 1079 pr_err("watchdog%d unable to add device %d:%d\n", 1080 wdd->id, MAJOR(watchdog_devt), wdd->id); 1081 if (wdd->id == 0) { 1082 misc_deregister(&watchdog_miscdev); 1083 old_wd_data = NULL; 1084 } 1085 put_device(&wd_data->dev); 1086 return err; 1087 } 1088 1089 wd_data->cdev.owner = wdd->ops->owner; 1090 1091 /* Record time of most recent heartbeat as 'just before now'. */ 1092 wd_data->last_hw_keepalive = ktime_sub(ktime_get(), 1); 1093 watchdog_set_open_deadline(wd_data); 1094 1095 /* 1096 * If the watchdog is running, prevent its driver from being unloaded, 1097 * and schedule an immediate ping. 1098 */ 1099 if (watchdog_hw_running(wdd)) { 1100 __module_get(wdd->ops->owner); 1101 get_device(&wd_data->dev); 1102 if (handle_boot_enabled) 1103 hrtimer_start(&wd_data->timer, 0, 1104 HRTIMER_MODE_REL_HARD); 1105 else 1106 pr_info("watchdog%d running and kernel based pre-userspace handler disabled\n", 1107 wdd->id); 1108 } 1109 1110 return 0; 1111 } 1112 1113 /* 1114 * watchdog_cdev_unregister - unregister watchdog character device 1115 * @wdd: Watchdog device 1116 * 1117 * Unregister watchdog character device and if needed the legacy 1118 * /dev/watchdog device. 1119 */ 1120 static void watchdog_cdev_unregister(struct watchdog_device *wdd) 1121 { 1122 struct watchdog_core_data *wd_data = wdd->wd_data; 1123 1124 cdev_device_del(&wd_data->cdev, &wd_data->dev); 1125 if (wdd->id == 0) { 1126 misc_deregister(&watchdog_miscdev); 1127 old_wd_data = NULL; 1128 } 1129 1130 if (watchdog_active(wdd) && 1131 test_bit(WDOG_STOP_ON_UNREGISTER, &wdd->status)) { 1132 watchdog_stop(wdd); 1133 } 1134 1135 watchdog_hrtimer_pretimeout_stop(wdd); 1136 1137 mutex_lock(&wd_data->lock); 1138 wd_data->wdd = NULL; 1139 wdd->wd_data = NULL; 1140 mutex_unlock(&wd_data->lock); 1141 1142 hrtimer_cancel(&wd_data->timer); 1143 kthread_cancel_work_sync(&wd_data->work); 1144 1145 put_device(&wd_data->dev); 1146 } 1147 1148 /** 1149 * watchdog_dev_register - register a watchdog device 1150 * @wdd: Watchdog device 1151 * 1152 * Register a watchdog device including handling the legacy 1153 * /dev/watchdog node. /dev/watchdog is actually a miscdevice and 1154 * thus we set it up like that. 1155 * 1156 * Return: 0 if successful, error otherwise. 1157 */ 1158 int watchdog_dev_register(struct watchdog_device *wdd) 1159 { 1160 int ret; 1161 1162 ret = watchdog_cdev_register(wdd); 1163 if (ret) 1164 return ret; 1165 1166 ret = watchdog_register_pretimeout(wdd); 1167 if (ret) 1168 watchdog_cdev_unregister(wdd); 1169 1170 return ret; 1171 } 1172 1173 /** 1174 * watchdog_dev_unregister - unregister a watchdog device 1175 * @wdd: watchdog device 1176 * 1177 * Unregister watchdog device and if needed the legacy 1178 * /dev/watchdog device. 1179 */ 1180 void watchdog_dev_unregister(struct watchdog_device *wdd) 1181 { 1182 watchdog_unregister_pretimeout(wdd); 1183 watchdog_cdev_unregister(wdd); 1184 } 1185 1186 /** 1187 * watchdog_set_last_hw_keepalive - set last HW keepalive time for watchdog 1188 * @wdd: Watchdog device 1189 * @last_ping_ms: Time since last HW heartbeat 1190 * 1191 * Adjusts the last known HW keepalive time for a watchdog timer. 1192 * This is needed if the watchdog is already running when the probe 1193 * function is called, and it can't be pinged immediately. This 1194 * function must be called immediately after watchdog registration, 1195 * and min_hw_heartbeat_ms must be set for this to be useful. 1196 * 1197 * Return: 0 if successful, error otherwise. 1198 */ 1199 int watchdog_set_last_hw_keepalive(struct watchdog_device *wdd, 1200 unsigned int last_ping_ms) 1201 { 1202 struct watchdog_core_data *wd_data; 1203 ktime_t now; 1204 1205 if (!wdd) 1206 return -EINVAL; 1207 1208 wd_data = wdd->wd_data; 1209 1210 now = ktime_get(); 1211 1212 wd_data->last_hw_keepalive = ktime_sub(now, ms_to_ktime(last_ping_ms)); 1213 1214 if (watchdog_hw_running(wdd) && handle_boot_enabled) 1215 return __watchdog_ping(wdd); 1216 1217 return 0; 1218 } 1219 EXPORT_SYMBOL_GPL(watchdog_set_last_hw_keepalive); 1220 1221 /** 1222 * watchdog_dev_init - init dev part of watchdog core 1223 * 1224 * Allocate a range of chardev nodes to use for watchdog devices. 1225 * 1226 * Return: 0 if successful, error otherwise. 1227 */ 1228 int __init watchdog_dev_init(void) 1229 { 1230 int err; 1231 1232 watchdog_kworker = kthread_create_worker(0, "watchdogd"); 1233 if (IS_ERR(watchdog_kworker)) { 1234 pr_err("Failed to create watchdog kworker\n"); 1235 return PTR_ERR(watchdog_kworker); 1236 } 1237 sched_set_fifo(watchdog_kworker->task); 1238 1239 err = class_register(&watchdog_class); 1240 if (err < 0) { 1241 pr_err("couldn't register class\n"); 1242 goto err_register; 1243 } 1244 1245 err = alloc_chrdev_region(&watchdog_devt, 0, MAX_DOGS, "watchdog"); 1246 if (err < 0) { 1247 pr_err("watchdog: unable to allocate char dev region\n"); 1248 goto err_alloc; 1249 } 1250 1251 return 0; 1252 1253 err_alloc: 1254 class_unregister(&watchdog_class); 1255 err_register: 1256 kthread_destroy_worker(watchdog_kworker); 1257 return err; 1258 } 1259 1260 /** 1261 * watchdog_dev_exit - exit dev part of watchdog core 1262 * 1263 * Release the range of chardev nodes used for watchdog devices. 1264 */ 1265 void __exit watchdog_dev_exit(void) 1266 { 1267 unregister_chrdev_region(watchdog_devt, MAX_DOGS); 1268 class_unregister(&watchdog_class); 1269 kthread_destroy_worker(watchdog_kworker); 1270 } 1271 1272 int watchdog_dev_suspend(struct watchdog_device *wdd) 1273 { 1274 struct watchdog_core_data *wd_data = wdd->wd_data; 1275 int ret = 0; 1276 1277 if (!wdd->wd_data) 1278 return -ENODEV; 1279 1280 /* ping for the last time before suspend */ 1281 mutex_lock(&wd_data->lock); 1282 if (watchdog_worker_should_ping(wd_data)) 1283 ret = __watchdog_ping(wd_data->wdd); 1284 mutex_unlock(&wd_data->lock); 1285 1286 if (ret) 1287 return ret; 1288 1289 /* 1290 * make sure that watchdog worker will not kick in when the wdog is 1291 * suspended 1292 */ 1293 hrtimer_cancel(&wd_data->timer); 1294 kthread_cancel_work_sync(&wd_data->work); 1295 1296 return 0; 1297 } 1298 1299 int watchdog_dev_resume(struct watchdog_device *wdd) 1300 { 1301 struct watchdog_core_data *wd_data = wdd->wd_data; 1302 int ret = 0; 1303 1304 if (!wdd->wd_data) 1305 return -ENODEV; 1306 1307 /* 1308 * __watchdog_ping will also retrigger hrtimer and therefore restore the 1309 * ping worker if needed. 1310 */ 1311 mutex_lock(&wd_data->lock); 1312 if (watchdog_worker_should_ping(wd_data)) 1313 ret = __watchdog_ping(wd_data->wdd); 1314 mutex_unlock(&wd_data->lock); 1315 1316 return ret; 1317 } 1318 1319 module_param(handle_boot_enabled, bool, 0444); 1320 MODULE_PARM_DESC(handle_boot_enabled, 1321 "Watchdog core auto-updates boot enabled watchdogs before userspace takes over (default=" 1322 __MODULE_STRING(IS_ENABLED(CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED)) ")"); 1323 1324 module_param(open_timeout, uint, 0644); 1325 MODULE_PARM_DESC(open_timeout, 1326 "Maximum time (in seconds, 0 means infinity) for userspace to take over a running watchdog (default=" 1327 __MODULE_STRING(CONFIG_WATCHDOG_OPEN_TIMEOUT) ")"); 1328