4
* (c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
7
* (c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
10
* This source code is part of the generic code that can be used
11
* by all the watchdog timer drivers.
13
* This part of the generic code takes care of the following
14
* misc device: /dev/watchdog.
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>
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.
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.
33
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
35
#include <linux/module.h> /* For module stuff/... */
36
#include <linux/types.h> /* For standard types (like size_t) */
37
#include <linux/errno.h> /* For the -ENODEV/... values */
38
#include <linux/kernel.h> /* For printk/panic/... */
39
#include <linux/fs.h> /* For file operations */
40
#include <linux/watchdog.h> /* For watchdog specific items */
41
#include <linux/miscdevice.h> /* For handling misc devices */
42
#include <linux/init.h> /* For __init/__exit/... */
43
#include <linux/uaccess.h> /* For copy_to_user/put_user/... */
45
/* make sure we only register one /dev/watchdog device */
46
static unsigned long watchdog_dev_busy;
47
/* the watchdog device behind /dev/watchdog */
48
static struct watchdog_device *wdd;
51
* watchdog_ping: ping the watchdog.
52
* @wddev: the watchdog device to ping
54
* If the watchdog has no own ping operation then it needs to be
55
* restarted via the start operation. This wrapper function does
57
* We only ping when the watchdog device is running.
60
static int watchdog_ping(struct watchdog_device *wddev)
62
if (test_bit(WDOG_ACTIVE, &wddev->status)) {
64
return wddev->ops->ping(wddev); /* ping the watchdog */
66
return wddev->ops->start(wddev); /* restart watchdog */
72
* watchdog_start: wrapper to start the watchdog.
73
* @wddev: the watchdog device to start
75
* Start the watchdog if it is not active and mark it active.
76
* This function returns zero on success or a negative errno code for
80
static int watchdog_start(struct watchdog_device *wddev)
84
if (!test_bit(WDOG_ACTIVE, &wddev->status)) {
85
err = wddev->ops->start(wddev);
89
set_bit(WDOG_ACTIVE, &wddev->status);
95
* watchdog_stop: wrapper to stop the watchdog.
96
* @wddev: the watchdog device to stop
98
* Stop the watchdog if it is still active and unmark it active.
99
* This function returns zero on success or a negative errno code for
101
* If the 'nowayout' feature was set, the watchdog cannot be stopped.
104
static int watchdog_stop(struct watchdog_device *wddev)
108
if (test_bit(WDOG_NO_WAY_OUT, &wddev->status)) {
109
pr_info("%s: nowayout prevents watchdog to be stopped!\n",
110
wddev->info->identity);
114
if (test_bit(WDOG_ACTIVE, &wddev->status)) {
115
err = wddev->ops->stop(wddev);
119
clear_bit(WDOG_ACTIVE, &wddev->status);
125
* watchdog_write: writes to the watchdog.
126
* @file: file from VFS
127
* @data: user address of data
128
* @len: length of data
129
* @ppos: pointer to the file offset
131
* A write to a watchdog device is defined as a keepalive ping.
132
* Writing the magic 'V' sequence allows the next close to turn
133
* off the watchdog (if 'nowayout' is not set).
136
static ssize_t watchdog_write(struct file *file, const char __user *data,
137
size_t len, loff_t *ppos)
146
* Note: just in case someone wrote the magic character
149
clear_bit(WDOG_ALLOW_RELEASE, &wdd->status);
151
/* scan to see whether or not we got the magic character */
152
for (i = 0; i != len; i++) {
153
if (get_user(c, data + i))
156
set_bit(WDOG_ALLOW_RELEASE, &wdd->status);
159
/* someone wrote to us, so we send the watchdog a keepalive ping */
166
* watchdog_ioctl: handle the different ioctl's for the watchdog device.
167
* @file: file handle to the device
168
* @cmd: watchdog command
169
* @arg: argument pointer
171
* The watchdog API defines a common set of functions for all watchdogs
172
* according to their available features.
175
static long watchdog_ioctl(struct file *file, unsigned int cmd,
178
void __user *argp = (void __user *)arg;
179
int __user *p = argp;
183
if (wdd->ops->ioctl) {
184
err = wdd->ops->ioctl(wdd, cmd, arg);
185
if (err != -ENOIOCTLCMD)
190
case WDIOC_GETSUPPORT:
191
return copy_to_user(argp, wdd->info,
192
sizeof(struct watchdog_info)) ? -EFAULT : 0;
193
case WDIOC_GETSTATUS:
194
val = wdd->ops->status ? wdd->ops->status(wdd) : 0;
195
return put_user(val, p);
196
case WDIOC_GETBOOTSTATUS:
197
return put_user(wdd->bootstatus, p);
198
case WDIOC_SETOPTIONS:
199
if (get_user(val, p))
201
if (val & WDIOS_DISABLECARD) {
202
err = watchdog_stop(wdd);
206
if (val & WDIOS_ENABLECARD) {
207
err = watchdog_start(wdd);
212
case WDIOC_KEEPALIVE:
213
if (!(wdd->info->options & WDIOF_KEEPALIVEPING))
217
case WDIOC_SETTIMEOUT:
218
if ((wdd->ops->set_timeout == NULL) ||
219
!(wdd->info->options & WDIOF_SETTIMEOUT))
221
if (get_user(val, p))
223
if ((wdd->max_timeout != 0) &&
224
(val < wdd->min_timeout || val > wdd->max_timeout))
226
err = wdd->ops->set_timeout(wdd, val);
230
/* If the watchdog is active then we send a keepalive ping
231
* to make sure that the watchdog keep's running (and if
232
* possible that it takes the new timeout) */
235
case WDIOC_GETTIMEOUT:
236
/* timeout == 0 means that we don't know the timeout */
237
if (wdd->timeout == 0)
239
return put_user(wdd->timeout, p);
246
* watchdog_open: open the /dev/watchdog device.
247
* @inode: inode of device
248
* @file: file handle to device
250
* When the /dev/watchdog device gets opened, we start the watchdog.
251
* Watch out: the /dev/watchdog device is single open, so we make sure
252
* it can only be opened once.
255
static int watchdog_open(struct inode *inode, struct file *file)
259
/* the watchdog is single open! */
260
if (test_and_set_bit(WDOG_DEV_OPEN, &wdd->status))
264
* If the /dev/watchdog device is open, we don't want the module
267
if (!try_module_get(wdd->ops->owner))
270
err = watchdog_start(wdd);
274
/* dev/watchdog is a virtual (and thus non-seekable) filesystem */
275
return nonseekable_open(inode, file);
278
module_put(wdd->ops->owner);
280
clear_bit(WDOG_DEV_OPEN, &wdd->status);
285
* watchdog_release: release the /dev/watchdog device.
286
* @inode: inode of device
287
* @file: file handle to device
289
* This is the code for when /dev/watchdog gets closed. We will only
290
* stop the watchdog when we have received the magic char (and nowayout
291
* was not set), else the watchdog will keep running.
294
static int watchdog_release(struct inode *inode, struct file *file)
299
* We only stop the watchdog if we received the magic character
300
* or if WDIOF_MAGICCLOSE is not set. If nowayout was set then
301
* watchdog_stop will fail.
303
if (test_and_clear_bit(WDOG_ALLOW_RELEASE, &wdd->status) ||
304
!(wdd->info->options & WDIOF_MAGICCLOSE))
305
err = watchdog_stop(wdd);
307
/* If the watchdog was not stopped, send a keepalive ping */
309
pr_crit("%s: watchdog did not stop!\n", wdd->info->identity);
313
/* Allow the owner module to be unloaded again */
314
module_put(wdd->ops->owner);
316
/* make sure that /dev/watchdog can be re-opened */
317
clear_bit(WDOG_DEV_OPEN, &wdd->status);
322
static const struct file_operations watchdog_fops = {
323
.owner = THIS_MODULE,
324
.write = watchdog_write,
325
.unlocked_ioctl = watchdog_ioctl,
326
.open = watchdog_open,
327
.release = watchdog_release,
330
static struct miscdevice watchdog_miscdev = {
331
.minor = WATCHDOG_MINOR,
333
.fops = &watchdog_fops,
337
* watchdog_dev_register:
338
* @watchdog: watchdog device
340
* Register a watchdog device as /dev/watchdog. /dev/watchdog
341
* is actually a miscdevice and thus we set it up like that.
344
int watchdog_dev_register(struct watchdog_device *watchdog)
348
/* Only one device can register for /dev/watchdog */
349
if (test_and_set_bit(0, &watchdog_dev_busy)) {
350
pr_err("only one watchdog can use /dev/watchdog.\n");
356
err = misc_register(&watchdog_miscdev);
358
pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n",
359
watchdog->info->identity, WATCHDOG_MINOR, err);
367
clear_bit(0, &watchdog_dev_busy);
372
* watchdog_dev_unregister:
373
* @watchdog: watchdog device
375
* Deregister the /dev/watchdog device.
378
int watchdog_dev_unregister(struct watchdog_device *watchdog)
380
/* Check that a watchdog device was registered in the past */
381
if (!test_bit(0, &watchdog_dev_busy) || !wdd)
384
/* We can only unregister the watchdog device that was registered */
385
if (watchdog != wdd) {
386
pr_err("%s: watchdog was not registered as /dev/watchdog.\n",
387
watchdog->info->identity);
391
misc_deregister(&watchdog_miscdev);
393
clear_bit(0, &watchdog_dev_busy);