1 // SPDX-License-Identifier: GPL-2.0+
5 * (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
8 * (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
10 * (c) Copyright 2021 Hewlett Packard Enterprise Development LP.
12 * This source code is part of the generic code that can be used
13 * by all the watchdog timer drivers.
15 * This part of the generic code takes care of the following
16 * misc device: /dev/watchdog.
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>
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.
30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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/kthread.h> /* For kthread_work */
39 #include <linux/miscdevice.h> /* For handling misc devices */
40 #include <linux/module.h> /* For module stuff/... */
41 #include <linux/mutex.h> /* For mutexes */
42 #include <linux/slab.h> /* For memory functions */
43 #include <linux/types.h> /* For standard types (like size_t) */
44 #include <linux/watchdog.h> /* For watchdog specific items */
45 #include <linux/uaccess.h> /* For copy_to_user/put_user/... */
47 #include "watchdog_core.h"
48 #include "watchdog_pretimeout.h"
50 /* the dev_t structure to store the dynamically allocated watchdog devices */
51 static dev_t watchdog_devt
;
52 /* Reference to watchdog device behind /dev/watchdog */
53 static struct watchdog_core_data
*old_wd_data
;
55 static struct kthread_worker
*watchdog_kworker
;
57 static bool handle_boot_enabled
=
58 IS_ENABLED(CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED
);
60 static unsigned open_timeout
= CONFIG_WATCHDOG_OPEN_TIMEOUT
;
62 static bool watchdog_past_open_deadline(struct watchdog_core_data
*data
)
64 return ktime_after(ktime_get(), data
->open_deadline
);
67 static void watchdog_set_open_deadline(struct watchdog_core_data
*data
)
69 data
->open_deadline
= open_timeout
?
70 ktime_get() + ktime_set(open_timeout
, 0) : KTIME_MAX
;
73 static inline bool watchdog_need_worker(struct watchdog_device
*wdd
)
75 /* All variables in milli-seconds */
76 unsigned int hm
= wdd
->max_hw_heartbeat_ms
;
77 unsigned int t
= wdd
->timeout
* 1000;
80 * A worker to generate heartbeat requests is needed if all of the
81 * following conditions are true.
82 * - Userspace activated the watchdog.
83 * - The driver provided a value for the maximum hardware timeout, and
84 * thus is aware that the framework supports generating heartbeat
86 * - Userspace requests a longer timeout than the hardware can handle.
88 * Alternatively, if userspace has not opened the watchdog
89 * device, we take care of feeding the watchdog if it is
92 return (hm
&& watchdog_active(wdd
) && t
> hm
) ||
93 (t
&& !watchdog_active(wdd
) && watchdog_hw_running(wdd
));
96 static ktime_t
watchdog_next_keepalive(struct watchdog_device
*wdd
)
98 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
99 unsigned int timeout_ms
= wdd
->timeout
* 1000;
100 ktime_t keepalive_interval
;
101 ktime_t last_heartbeat
, latest_heartbeat
;
102 ktime_t virt_timeout
;
103 unsigned int hw_heartbeat_ms
;
105 if (watchdog_active(wdd
))
106 virt_timeout
= ktime_add(wd_data
->last_keepalive
,
107 ms_to_ktime(timeout_ms
));
109 virt_timeout
= wd_data
->open_deadline
;
111 hw_heartbeat_ms
= min_not_zero(timeout_ms
, wdd
->max_hw_heartbeat_ms
);
112 keepalive_interval
= ms_to_ktime(hw_heartbeat_ms
/ 2);
115 * To ensure that the watchdog times out wdd->timeout seconds
116 * after the most recent ping from userspace, the last
117 * worker ping has to come in hw_heartbeat_ms before this timeout.
119 last_heartbeat
= ktime_sub(virt_timeout
, ms_to_ktime(hw_heartbeat_ms
));
120 latest_heartbeat
= ktime_sub(last_heartbeat
, ktime_get());
121 if (ktime_before(latest_heartbeat
, keepalive_interval
))
122 return latest_heartbeat
;
123 return keepalive_interval
;
126 static inline void watchdog_update_worker(struct watchdog_device
*wdd
)
128 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
130 if (watchdog_need_worker(wdd
)) {
131 ktime_t t
= watchdog_next_keepalive(wdd
);
134 hrtimer_start(&wd_data
->timer
, t
,
135 HRTIMER_MODE_REL_HARD
);
137 hrtimer_cancel(&wd_data
->timer
);
141 static int __watchdog_ping(struct watchdog_device
*wdd
)
143 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
144 ktime_t earliest_keepalive
, now
;
147 earliest_keepalive
= ktime_add(wd_data
->last_hw_keepalive
,
148 ms_to_ktime(wdd
->min_hw_heartbeat_ms
));
151 if (ktime_after(earliest_keepalive
, now
)) {
152 hrtimer_start(&wd_data
->timer
,
153 ktime_sub(earliest_keepalive
, now
),
154 HRTIMER_MODE_REL_HARD
);
158 wd_data
->last_hw_keepalive
= now
;
161 err
= wdd
->ops
->ping(wdd
); /* ping the watchdog */
163 err
= wdd
->ops
->start(wdd
); /* restart watchdog */
166 watchdog_hrtimer_pretimeout_start(wdd
);
168 watchdog_update_worker(wdd
);
174 * watchdog_ping: ping the watchdog.
175 * @wdd: the watchdog device to ping
177 * The caller must hold wd_data->lock.
179 * If the watchdog has no own ping operation then it needs to be
180 * restarted via the start operation. This wrapper function does
182 * We only ping when the watchdog device is running.
185 static int watchdog_ping(struct watchdog_device
*wdd
)
187 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
189 if (!watchdog_active(wdd
) && !watchdog_hw_running(wdd
))
192 set_bit(_WDOG_KEEPALIVE
, &wd_data
->status
);
194 wd_data
->last_keepalive
= ktime_get();
195 return __watchdog_ping(wdd
);
198 static bool watchdog_worker_should_ping(struct watchdog_core_data
*wd_data
)
200 struct watchdog_device
*wdd
= wd_data
->wdd
;
205 if (watchdog_active(wdd
))
208 return watchdog_hw_running(wdd
) && !watchdog_past_open_deadline(wd_data
);
211 static void watchdog_ping_work(struct kthread_work
*work
)
213 struct watchdog_core_data
*wd_data
;
215 wd_data
= container_of(work
, struct watchdog_core_data
, work
);
217 mutex_lock(&wd_data
->lock
);
218 if (watchdog_worker_should_ping(wd_data
))
219 __watchdog_ping(wd_data
->wdd
);
220 mutex_unlock(&wd_data
->lock
);
223 static enum hrtimer_restart
watchdog_timer_expired(struct hrtimer
*timer
)
225 struct watchdog_core_data
*wd_data
;
227 wd_data
= container_of(timer
, struct watchdog_core_data
, timer
);
229 kthread_queue_work(watchdog_kworker
, &wd_data
->work
);
230 return HRTIMER_NORESTART
;
234 * watchdog_start: wrapper to start the watchdog.
235 * @wdd: the watchdog device to start
237 * The caller must hold wd_data->lock.
239 * Start the watchdog if it is not active and mark it active.
240 * This function returns zero on success or a negative errno code for
244 static int watchdog_start(struct watchdog_device
*wdd
)
246 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
250 if (watchdog_active(wdd
))
253 set_bit(_WDOG_KEEPALIVE
, &wd_data
->status
);
255 started_at
= ktime_get();
256 if (watchdog_hw_running(wdd
) && wdd
->ops
->ping
) {
257 err
= __watchdog_ping(wdd
);
259 set_bit(WDOG_ACTIVE
, &wdd
->status
);
260 watchdog_hrtimer_pretimeout_start(wdd
);
263 err
= wdd
->ops
->start(wdd
);
265 set_bit(WDOG_ACTIVE
, &wdd
->status
);
266 wd_data
->last_keepalive
= started_at
;
267 wd_data
->last_hw_keepalive
= started_at
;
268 watchdog_update_worker(wdd
);
269 watchdog_hrtimer_pretimeout_start(wdd
);
277 * watchdog_stop: wrapper to stop the watchdog.
278 * @wdd: the watchdog device to stop
280 * The caller must hold wd_data->lock.
282 * Stop the watchdog if it is still active and unmark it active.
283 * This function returns zero on success or a negative errno code for
285 * If the 'nowayout' feature was set, the watchdog cannot be stopped.
288 static int watchdog_stop(struct watchdog_device
*wdd
)
292 if (!watchdog_active(wdd
))
295 if (test_bit(WDOG_NO_WAY_OUT
, &wdd
->status
)) {
296 pr_info("watchdog%d: nowayout prevents watchdog being stopped!\n",
301 if (wdd
->ops
->stop
) {
302 clear_bit(WDOG_HW_RUNNING
, &wdd
->status
);
303 err
= wdd
->ops
->stop(wdd
);
305 set_bit(WDOG_HW_RUNNING
, &wdd
->status
);
309 clear_bit(WDOG_ACTIVE
, &wdd
->status
);
310 watchdog_update_worker(wdd
);
311 watchdog_hrtimer_pretimeout_stop(wdd
);
318 * watchdog_get_status: wrapper to get the watchdog status
319 * @wdd: the watchdog device to get the status from
321 * The caller must hold wd_data->lock.
323 * Get the watchdog's status flags.
326 static unsigned int watchdog_get_status(struct watchdog_device
*wdd
)
328 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
331 if (wdd
->ops
->status
)
332 status
= wdd
->ops
->status(wdd
);
334 status
= wdd
->bootstatus
& (WDIOF_CARDRESET
|
342 if (test_bit(_WDOG_ALLOW_RELEASE
, &wd_data
->status
))
343 status
|= WDIOF_MAGICCLOSE
;
345 if (test_and_clear_bit(_WDOG_KEEPALIVE
, &wd_data
->status
))
346 status
|= WDIOF_KEEPALIVEPING
;
348 if (IS_ENABLED(CONFIG_WATCHDOG_HRTIMER_PRETIMEOUT
))
349 status
|= WDIOF_PRETIMEOUT
;
355 * watchdog_set_timeout: set the watchdog timer timeout
356 * @wdd: the watchdog device to set the timeout for
357 * @timeout: timeout to set in seconds
359 * The caller must hold wd_data->lock.
362 static int watchdog_set_timeout(struct watchdog_device
*wdd
,
363 unsigned int timeout
)
367 if (!(wdd
->info
->options
& WDIOF_SETTIMEOUT
))
370 if (watchdog_timeout_invalid(wdd
, timeout
))
373 if (wdd
->ops
->set_timeout
) {
374 err
= wdd
->ops
->set_timeout(wdd
, timeout
);
376 wdd
->timeout
= timeout
;
377 /* Disable pretimeout if it doesn't fit the new timeout */
378 if (wdd
->pretimeout
>= wdd
->timeout
)
382 watchdog_update_worker(wdd
);
388 * watchdog_set_pretimeout: set the watchdog timer pretimeout
389 * @wdd: the watchdog device to set the timeout for
390 * @timeout: pretimeout to set in seconds
393 static int watchdog_set_pretimeout(struct watchdog_device
*wdd
,
394 unsigned int timeout
)
398 if (!watchdog_have_pretimeout(wdd
))
401 if (watchdog_pretimeout_invalid(wdd
, timeout
))
404 if (wdd
->ops
->set_pretimeout
&& (wdd
->info
->options
& WDIOF_PRETIMEOUT
))
405 err
= wdd
->ops
->set_pretimeout(wdd
, timeout
);
407 wdd
->pretimeout
= timeout
;
413 * watchdog_get_timeleft: wrapper to get the time left before a reboot
414 * @wdd: the watchdog device to get the remaining time from
415 * @timeleft: the time that's left
417 * The caller must hold wd_data->lock.
419 * Get the time before a watchdog will reboot (if not pinged).
422 static int watchdog_get_timeleft(struct watchdog_device
*wdd
,
423 unsigned int *timeleft
)
427 if (!wdd
->ops
->get_timeleft
)
430 *timeleft
= wdd
->ops
->get_timeleft(wdd
);
435 #ifdef CONFIG_WATCHDOG_SYSFS
436 static ssize_t
nowayout_show(struct device
*dev
, struct device_attribute
*attr
,
439 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
441 return sysfs_emit(buf
, "%d\n", !!test_bit(WDOG_NO_WAY_OUT
,
445 static ssize_t
nowayout_store(struct device
*dev
, struct device_attribute
*attr
,
446 const char *buf
, size_t len
)
448 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
452 ret
= kstrtouint(buf
, 0, &value
);
457 /* nowayout cannot be disabled once set */
458 if (test_bit(WDOG_NO_WAY_OUT
, &wdd
->status
) && !value
)
460 watchdog_set_nowayout(wdd
, value
);
463 static DEVICE_ATTR_RW(nowayout
);
465 static ssize_t
status_show(struct device
*dev
, struct device_attribute
*attr
,
468 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
469 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
472 mutex_lock(&wd_data
->lock
);
473 status
= watchdog_get_status(wdd
);
474 mutex_unlock(&wd_data
->lock
);
476 return sysfs_emit(buf
, "0x%x\n", status
);
478 static DEVICE_ATTR_RO(status
);
480 static ssize_t
bootstatus_show(struct device
*dev
,
481 struct device_attribute
*attr
, char *buf
)
483 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
485 return sysfs_emit(buf
, "%u\n", wdd
->bootstatus
);
487 static DEVICE_ATTR_RO(bootstatus
);
489 static ssize_t
timeleft_show(struct device
*dev
, struct device_attribute
*attr
,
492 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
493 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
497 mutex_lock(&wd_data
->lock
);
498 status
= watchdog_get_timeleft(wdd
, &val
);
499 mutex_unlock(&wd_data
->lock
);
501 status
= sysfs_emit(buf
, "%u\n", val
);
505 static DEVICE_ATTR_RO(timeleft
);
507 static ssize_t
timeout_show(struct device
*dev
, struct device_attribute
*attr
,
510 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
512 return sysfs_emit(buf
, "%u\n", wdd
->timeout
);
514 static DEVICE_ATTR_RO(timeout
);
516 static ssize_t
min_timeout_show(struct device
*dev
,
517 struct device_attribute
*attr
, char *buf
)
519 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
521 return sysfs_emit(buf
, "%u\n", wdd
->min_timeout
);
523 static DEVICE_ATTR_RO(min_timeout
);
525 static ssize_t
max_timeout_show(struct device
*dev
,
526 struct device_attribute
*attr
, char *buf
)
528 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
530 return sysfs_emit(buf
, "%u\n", wdd
->max_timeout
);
532 static DEVICE_ATTR_RO(max_timeout
);
534 static ssize_t
pretimeout_show(struct device
*dev
,
535 struct device_attribute
*attr
, char *buf
)
537 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
539 return sysfs_emit(buf
, "%u\n", wdd
->pretimeout
);
541 static DEVICE_ATTR_RO(pretimeout
);
543 static ssize_t
identity_show(struct device
*dev
, struct device_attribute
*attr
,
546 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
548 return sysfs_emit(buf
, "%s\n", wdd
->info
->identity
);
550 static DEVICE_ATTR_RO(identity
);
552 static ssize_t
state_show(struct device
*dev
, struct device_attribute
*attr
,
555 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
557 if (watchdog_active(wdd
))
558 return sysfs_emit(buf
, "active\n");
560 return sysfs_emit(buf
, "inactive\n");
562 static DEVICE_ATTR_RO(state
);
564 static ssize_t
pretimeout_available_governors_show(struct device
*dev
,
565 struct device_attribute
*attr
, char *buf
)
567 return watchdog_pretimeout_available_governors_get(buf
);
569 static DEVICE_ATTR_RO(pretimeout_available_governors
);
571 static ssize_t
pretimeout_governor_show(struct device
*dev
,
572 struct device_attribute
*attr
,
575 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
577 return watchdog_pretimeout_governor_get(wdd
, buf
);
580 static ssize_t
pretimeout_governor_store(struct device
*dev
,
581 struct device_attribute
*attr
,
582 const char *buf
, size_t count
)
584 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
585 int ret
= watchdog_pretimeout_governor_set(wdd
, buf
);
592 static DEVICE_ATTR_RW(pretimeout_governor
);
594 static umode_t
wdt_is_visible(struct kobject
*kobj
, struct attribute
*attr
,
597 struct device
*dev
= kobj_to_dev(kobj
);
598 struct watchdog_device
*wdd
= dev_get_drvdata(dev
);
599 umode_t mode
= attr
->mode
;
601 if (attr
== &dev_attr_timeleft
.attr
&& !wdd
->ops
->get_timeleft
)
603 else if (attr
== &dev_attr_pretimeout
.attr
&& !watchdog_have_pretimeout(wdd
))
605 else if ((attr
== &dev_attr_pretimeout_governor
.attr
||
606 attr
== &dev_attr_pretimeout_available_governors
.attr
) &&
607 (!watchdog_have_pretimeout(wdd
) || !IS_ENABLED(CONFIG_WATCHDOG_PRETIMEOUT_GOV
)))
612 static struct attribute
*wdt_attrs
[] = {
613 &dev_attr_state
.attr
,
614 &dev_attr_identity
.attr
,
615 &dev_attr_timeout
.attr
,
616 &dev_attr_min_timeout
.attr
,
617 &dev_attr_max_timeout
.attr
,
618 &dev_attr_pretimeout
.attr
,
619 &dev_attr_timeleft
.attr
,
620 &dev_attr_bootstatus
.attr
,
621 &dev_attr_status
.attr
,
622 &dev_attr_nowayout
.attr
,
623 &dev_attr_pretimeout_governor
.attr
,
624 &dev_attr_pretimeout_available_governors
.attr
,
628 static const struct attribute_group wdt_group
= {
630 .is_visible
= wdt_is_visible
,
632 __ATTRIBUTE_GROUPS(wdt
);
634 #define wdt_groups NULL
638 * watchdog_ioctl_op: call the watchdog drivers ioctl op if defined
639 * @wdd: the watchdog device to do the ioctl on
640 * @cmd: watchdog command
641 * @arg: argument pointer
643 * The caller must hold wd_data->lock.
646 static int watchdog_ioctl_op(struct watchdog_device
*wdd
, unsigned int cmd
,
649 if (!wdd
->ops
->ioctl
)
652 return wdd
->ops
->ioctl(wdd
, cmd
, arg
);
656 * watchdog_write: writes to the watchdog.
657 * @file: file from VFS
658 * @data: user address of data
659 * @len: length of data
660 * @ppos: pointer to the file offset
662 * A write to a watchdog device is defined as a keepalive ping.
663 * Writing the magic 'V' sequence allows the next close to turn
664 * off the watchdog (if 'nowayout' is not set).
667 static ssize_t
watchdog_write(struct file
*file
, const char __user
*data
,
668 size_t len
, loff_t
*ppos
)
670 struct watchdog_core_data
*wd_data
= file
->private_data
;
671 struct watchdog_device
*wdd
;
680 * Note: just in case someone wrote the magic character
683 clear_bit(_WDOG_ALLOW_RELEASE
, &wd_data
->status
);
685 /* scan to see whether or not we got the magic character */
686 for (i
= 0; i
!= len
; i
++) {
687 if (get_user(c
, data
+ i
))
690 set_bit(_WDOG_ALLOW_RELEASE
, &wd_data
->status
);
693 /* someone wrote to us, so we send the watchdog a keepalive ping */
696 mutex_lock(&wd_data
->lock
);
699 err
= watchdog_ping(wdd
);
700 mutex_unlock(&wd_data
->lock
);
709 * watchdog_ioctl: handle the different ioctl's for the watchdog device.
710 * @file: file handle to the device
711 * @cmd: watchdog command
712 * @arg: argument pointer
714 * The watchdog API defines a common set of functions for all watchdogs
715 * according to their available features.
718 static long watchdog_ioctl(struct file
*file
, unsigned int cmd
,
721 struct watchdog_core_data
*wd_data
= file
->private_data
;
722 void __user
*argp
= (void __user
*)arg
;
723 struct watchdog_device
*wdd
;
724 int __user
*p
= argp
;
728 mutex_lock(&wd_data
->lock
);
736 err
= watchdog_ioctl_op(wdd
, cmd
, arg
);
737 if (err
!= -ENOIOCTLCMD
)
741 case WDIOC_GETSUPPORT
:
742 err
= copy_to_user(argp
, wdd
->info
,
743 sizeof(struct watchdog_info
)) ? -EFAULT
: 0;
745 case WDIOC_GETSTATUS
:
746 val
= watchdog_get_status(wdd
);
747 err
= put_user(val
, p
);
749 case WDIOC_GETBOOTSTATUS
:
750 err
= put_user(wdd
->bootstatus
, p
);
752 case WDIOC_SETOPTIONS
:
753 if (get_user(val
, p
)) {
757 if (val
& WDIOS_DISABLECARD
) {
758 err
= watchdog_stop(wdd
);
762 if (val
& WDIOS_ENABLECARD
)
763 err
= watchdog_start(wdd
);
765 case WDIOC_KEEPALIVE
:
766 if (!(wdd
->info
->options
& WDIOF_KEEPALIVEPING
)) {
770 err
= watchdog_ping(wdd
);
772 case WDIOC_SETTIMEOUT
:
773 if (get_user(val
, p
)) {
777 err
= watchdog_set_timeout(wdd
, val
);
780 /* If the watchdog is active then we send a keepalive ping
781 * to make sure that the watchdog keep's running (and if
782 * possible that it takes the new timeout) */
783 err
= watchdog_ping(wdd
);
787 case WDIOC_GETTIMEOUT
:
788 /* timeout == 0 means that we don't know the timeout */
789 if (wdd
->timeout
== 0) {
793 err
= put_user(wdd
->timeout
, p
);
795 case WDIOC_GETTIMELEFT
:
796 err
= watchdog_get_timeleft(wdd
, &val
);
799 err
= put_user(val
, p
);
801 case WDIOC_SETPRETIMEOUT
:
802 if (get_user(val
, p
)) {
806 err
= watchdog_set_pretimeout(wdd
, val
);
808 case WDIOC_GETPRETIMEOUT
:
809 err
= put_user(wdd
->pretimeout
, p
);
817 mutex_unlock(&wd_data
->lock
);
822 * watchdog_open: open the /dev/watchdog* devices.
823 * @inode: inode of device
824 * @file: file handle to device
826 * When the /dev/watchdog* device gets opened, we start the watchdog.
827 * Watch out: the /dev/watchdog device is single open, so we make sure
828 * it can only be opened once.
831 static int watchdog_open(struct inode
*inode
, struct file
*file
)
833 struct watchdog_core_data
*wd_data
;
834 struct watchdog_device
*wdd
;
838 /* Get the corresponding watchdog device */
839 if (imajor(inode
) == MISC_MAJOR
)
840 wd_data
= old_wd_data
;
842 wd_data
= container_of(inode
->i_cdev
, struct watchdog_core_data
,
845 /* the watchdog is single open! */
846 if (test_and_set_bit(_WDOG_DEV_OPEN
, &wd_data
->status
))
852 * If the /dev/watchdog device is open, we don't want the module
855 hw_running
= watchdog_hw_running(wdd
);
856 if (!hw_running
&& !try_module_get(wdd
->ops
->owner
)) {
861 err
= watchdog_start(wdd
);
865 file
->private_data
= wd_data
;
868 get_device(&wd_data
->dev
);
871 * open_timeout only applies for the first open from
872 * userspace. Set open_deadline to infinity so that the kernel
873 * will take care of an always-running hardware watchdog in
874 * case the device gets magic-closed or WDIOS_DISABLECARD is
877 wd_data
->open_deadline
= KTIME_MAX
;
879 /* dev/watchdog is a virtual (and thus non-seekable) filesystem */
880 return stream_open(inode
, file
);
883 module_put(wd_data
->wdd
->ops
->owner
);
885 clear_bit(_WDOG_DEV_OPEN
, &wd_data
->status
);
889 static void watchdog_core_data_release(struct device
*dev
)
891 struct watchdog_core_data
*wd_data
;
893 wd_data
= container_of(dev
, struct watchdog_core_data
, dev
);
899 * watchdog_release: release the watchdog device.
900 * @inode: inode of device
901 * @file: file handle to device
903 * This is the code for when /dev/watchdog gets closed. We will only
904 * stop the watchdog when we have received the magic char (and nowayout
905 * was not set), else the watchdog will keep running.
908 static int watchdog_release(struct inode
*inode
, struct file
*file
)
910 struct watchdog_core_data
*wd_data
= file
->private_data
;
911 struct watchdog_device
*wdd
;
915 mutex_lock(&wd_data
->lock
);
922 * We only stop the watchdog if we received the magic character
923 * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then
924 * watchdog_stop will fail.
926 if (!watchdog_active(wdd
))
928 else if (test_and_clear_bit(_WDOG_ALLOW_RELEASE
, &wd_data
->status
) ||
929 !(wdd
->info
->options
& WDIOF_MAGICCLOSE
))
930 err
= watchdog_stop(wdd
);
932 /* If the watchdog was not stopped, send a keepalive ping */
934 pr_crit("watchdog%d: watchdog did not stop!\n", wdd
->id
);
938 watchdog_update_worker(wdd
);
940 /* make sure that /dev/watchdog can be re-opened */
941 clear_bit(_WDOG_DEV_OPEN
, &wd_data
->status
);
944 running
= wdd
&& watchdog_hw_running(wdd
);
945 mutex_unlock(&wd_data
->lock
);
947 * Allow the owner module to be unloaded again unless the watchdog
948 * is still running. If the watchdog is still running, it can not
949 * be stopped, and its driver must not be unloaded.
952 module_put(wd_data
->cdev
.owner
);
953 put_device(&wd_data
->dev
);
958 static const struct file_operations watchdog_fops
= {
959 .owner
= THIS_MODULE
,
960 .write
= watchdog_write
,
961 .unlocked_ioctl
= watchdog_ioctl
,
962 .compat_ioctl
= compat_ptr_ioctl
,
963 .open
= watchdog_open
,
964 .release
= watchdog_release
,
967 static struct miscdevice watchdog_miscdev
= {
968 .minor
= WATCHDOG_MINOR
,
970 .fops
= &watchdog_fops
,
973 static struct class watchdog_class
= {
975 .owner
= THIS_MODULE
,
976 .dev_groups
= wdt_groups
,
980 * watchdog_cdev_register: register watchdog character device
981 * @wdd: watchdog device
983 * Register a watchdog character device including handling the legacy
984 * /dev/watchdog node. /dev/watchdog is actually a miscdevice and
985 * thus we set it up like that.
988 static int watchdog_cdev_register(struct watchdog_device
*wdd
)
990 struct watchdog_core_data
*wd_data
;
993 wd_data
= kzalloc(sizeof(struct watchdog_core_data
), GFP_KERNEL
);
996 mutex_init(&wd_data
->lock
);
999 wdd
->wd_data
= wd_data
;
1001 if (IS_ERR_OR_NULL(watchdog_kworker
)) {
1006 device_initialize(&wd_data
->dev
);
1007 wd_data
->dev
.devt
= MKDEV(MAJOR(watchdog_devt
), wdd
->id
);
1008 wd_data
->dev
.class = &watchdog_class
;
1009 wd_data
->dev
.parent
= wdd
->parent
;
1010 wd_data
->dev
.groups
= wdd
->groups
;
1011 wd_data
->dev
.release
= watchdog_core_data_release
;
1012 dev_set_drvdata(&wd_data
->dev
, wdd
);
1013 dev_set_name(&wd_data
->dev
, "watchdog%d", wdd
->id
);
1015 kthread_init_work(&wd_data
->work
, watchdog_ping_work
);
1016 hrtimer_init(&wd_data
->timer
, CLOCK_MONOTONIC
, HRTIMER_MODE_REL_HARD
);
1017 wd_data
->timer
.function
= watchdog_timer_expired
;
1018 watchdog_hrtimer_pretimeout_init(wdd
);
1021 old_wd_data
= wd_data
;
1022 watchdog_miscdev
.parent
= wdd
->parent
;
1023 err
= misc_register(&watchdog_miscdev
);
1025 pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n",
1026 wdd
->info
->identity
, WATCHDOG_MINOR
, err
);
1028 pr_err("%s: a legacy watchdog module is probably present.\n",
1029 wdd
->info
->identity
);
1031 put_device(&wd_data
->dev
);
1036 /* Fill in the data structures */
1037 cdev_init(&wd_data
->cdev
, &watchdog_fops
);
1039 /* Add the device */
1040 err
= cdev_device_add(&wd_data
->cdev
, &wd_data
->dev
);
1042 pr_err("watchdog%d unable to add device %d:%d\n",
1043 wdd
->id
, MAJOR(watchdog_devt
), wdd
->id
);
1045 misc_deregister(&watchdog_miscdev
);
1047 put_device(&wd_data
->dev
);
1052 wd_data
->cdev
.owner
= wdd
->ops
->owner
;
1054 /* Record time of most recent heartbeat as 'just before now'. */
1055 wd_data
->last_hw_keepalive
= ktime_sub(ktime_get(), 1);
1056 watchdog_set_open_deadline(wd_data
);
1059 * If the watchdog is running, prevent its driver from being unloaded,
1060 * and schedule an immediate ping.
1062 if (watchdog_hw_running(wdd
)) {
1063 __module_get(wdd
->ops
->owner
);
1064 get_device(&wd_data
->dev
);
1065 if (handle_boot_enabled
)
1066 hrtimer_start(&wd_data
->timer
, 0,
1067 HRTIMER_MODE_REL_HARD
);
1069 pr_info("watchdog%d running and kernel based pre-userspace handler disabled\n",
1077 * watchdog_cdev_unregister: unregister watchdog character device
1078 * @watchdog: watchdog device
1080 * Unregister watchdog character device and if needed the legacy
1081 * /dev/watchdog device.
1084 static void watchdog_cdev_unregister(struct watchdog_device
*wdd
)
1086 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
1088 cdev_device_del(&wd_data
->cdev
, &wd_data
->dev
);
1090 misc_deregister(&watchdog_miscdev
);
1094 if (watchdog_active(wdd
) &&
1095 test_bit(WDOG_STOP_ON_UNREGISTER
, &wdd
->status
)) {
1099 watchdog_hrtimer_pretimeout_stop(wdd
);
1101 mutex_lock(&wd_data
->lock
);
1102 wd_data
->wdd
= NULL
;
1103 wdd
->wd_data
= NULL
;
1104 mutex_unlock(&wd_data
->lock
);
1106 hrtimer_cancel(&wd_data
->timer
);
1107 kthread_cancel_work_sync(&wd_data
->work
);
1109 put_device(&wd_data
->dev
);
1113 * watchdog_dev_register: register a watchdog device
1114 * @wdd: watchdog device
1116 * Register a watchdog device including handling the legacy
1117 * /dev/watchdog node. /dev/watchdog is actually a miscdevice and
1118 * thus we set it up like that.
1121 int watchdog_dev_register(struct watchdog_device
*wdd
)
1125 ret
= watchdog_cdev_register(wdd
);
1129 ret
= watchdog_register_pretimeout(wdd
);
1131 watchdog_cdev_unregister(wdd
);
1137 * watchdog_dev_unregister: unregister a watchdog device
1138 * @watchdog: watchdog device
1140 * Unregister watchdog device and if needed the legacy
1141 * /dev/watchdog device.
1144 void watchdog_dev_unregister(struct watchdog_device
*wdd
)
1146 watchdog_unregister_pretimeout(wdd
);
1147 watchdog_cdev_unregister(wdd
);
1151 * watchdog_set_last_hw_keepalive: set last HW keepalive time for watchdog
1152 * @wdd: watchdog device
1153 * @last_ping_ms: time since last HW heartbeat
1155 * Adjusts the last known HW keepalive time for a watchdog timer.
1156 * This is needed if the watchdog is already running when the probe
1157 * function is called, and it can't be pinged immediately. This
1158 * function must be called immediately after watchdog registration,
1159 * and min_hw_heartbeat_ms must be set for this to be useful.
1161 int watchdog_set_last_hw_keepalive(struct watchdog_device
*wdd
,
1162 unsigned int last_ping_ms
)
1164 struct watchdog_core_data
*wd_data
;
1170 wd_data
= wdd
->wd_data
;
1174 wd_data
->last_hw_keepalive
= ktime_sub(now
, ms_to_ktime(last_ping_ms
));
1176 if (watchdog_hw_running(wdd
) && handle_boot_enabled
)
1177 return __watchdog_ping(wdd
);
1181 EXPORT_SYMBOL_GPL(watchdog_set_last_hw_keepalive
);
1184 * watchdog_dev_init: init dev part of watchdog core
1186 * Allocate a range of chardev nodes to use for watchdog devices
1189 int __init
watchdog_dev_init(void)
1193 watchdog_kworker
= kthread_create_worker(0, "watchdogd");
1194 if (IS_ERR(watchdog_kworker
)) {
1195 pr_err("Failed to create watchdog kworker\n");
1196 return PTR_ERR(watchdog_kworker
);
1198 sched_set_fifo(watchdog_kworker
->task
);
1200 err
= class_register(&watchdog_class
);
1202 pr_err("couldn't register class\n");
1206 err
= alloc_chrdev_region(&watchdog_devt
, 0, MAX_DOGS
, "watchdog");
1208 pr_err("watchdog: unable to allocate char dev region\n");
1215 class_unregister(&watchdog_class
);
1217 kthread_destroy_worker(watchdog_kworker
);
1222 * watchdog_dev_exit: exit dev part of watchdog core
1224 * Release the range of chardev nodes used for watchdog devices
1227 void __exit
watchdog_dev_exit(void)
1229 unregister_chrdev_region(watchdog_devt
, MAX_DOGS
);
1230 class_unregister(&watchdog_class
);
1231 kthread_destroy_worker(watchdog_kworker
);
1234 int watchdog_dev_suspend(struct watchdog_device
*wdd
)
1236 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
1242 /* ping for the last time before suspend */
1243 mutex_lock(&wd_data
->lock
);
1244 if (watchdog_worker_should_ping(wd_data
))
1245 ret
= __watchdog_ping(wd_data
->wdd
);
1246 mutex_unlock(&wd_data
->lock
);
1252 * make sure that watchdog worker will not kick in when the wdog is
1255 hrtimer_cancel(&wd_data
->timer
);
1256 kthread_cancel_work_sync(&wd_data
->work
);
1261 int watchdog_dev_resume(struct watchdog_device
*wdd
)
1263 struct watchdog_core_data
*wd_data
= wdd
->wd_data
;
1270 * __watchdog_ping will also retrigger hrtimer and therefore restore the
1271 * ping worker if needed.
1273 mutex_lock(&wd_data
->lock
);
1274 if (watchdog_worker_should_ping(wd_data
))
1275 ret
= __watchdog_ping(wd_data
->wdd
);
1276 mutex_unlock(&wd_data
->lock
);
1281 module_param(handle_boot_enabled
, bool, 0444);
1282 MODULE_PARM_DESC(handle_boot_enabled
,
1283 "Watchdog core auto-updates boot enabled watchdogs before userspace takes over (default="
1284 __MODULE_STRING(IS_ENABLED(CONFIG_WATCHDOG_HANDLE_BOOT_ENABLED
)) ")");
1286 module_param(open_timeout
, uint
, 0644);
1287 MODULE_PARM_DESC(open_timeout
,
1288 "Maximum time (in seconds, 0 means infinity) for userspace to take over a running watchdog (default="
1289 __MODULE_STRING(CONFIG_WATCHDOG_OPEN_TIMEOUT
) ")");