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/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/... */
44
45#include "watchdog_core.h"
46
47/* the dev_t structure to store the dynamically allocated watchdog devices */
48static dev_t watchdog_devt;
49/* the watchdog device behind /dev/watchdog */
50static struct watchdog_device *old_wdd;
51
52/*
53 *	watchdog_ping: ping the watchdog.
54 *	@wdd: the watchdog device to ping
55 *
56 *	If the watchdog has no own ping operation then it needs to be
57 *	restarted via the start operation. This wrapper function does
58 *	exactly that.
59 *	We only ping when the watchdog device is running.
60 */
61
62static int watchdog_ping(struct watchdog_device *wdd)
63{
64	int err = 0;
65
66	mutex_lock(&wdd->lock);
67
68	if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
69		err = -ENODEV;
70		goto out_ping;
71	}
72
73	if (!watchdog_active(wdd))
74		goto out_ping;
75
76	if (wdd->ops->ping)
77		err = wdd->ops->ping(wdd);	/* ping the watchdog */
78	else
79		err = wdd->ops->start(wdd);	/* restart watchdog */
80
81out_ping:
82	mutex_unlock(&wdd->lock);
83	return err;
84}
85
86/*
87 *	watchdog_start: wrapper to start the watchdog.
88 *	@wdd: the watchdog device to start
89 *
90 *	Start the watchdog if it is not active and mark it active.
91 *	This function returns zero on success or a negative errno code for
92 *	failure.
93 */
94
95static int watchdog_start(struct watchdog_device *wdd)
96{
97	int err = 0;
98
99	mutex_lock(&wdd->lock);
100
101	if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
102		err = -ENODEV;
103		goto out_start;
104	}
105
106	if (watchdog_active(wdd))
107		goto out_start;
108
109	err = wdd->ops->start(wdd);
110	if (err == 0)
111		set_bit(WDOG_ACTIVE, &wdd->status);
112
113out_start:
114	mutex_unlock(&wdd->lock);
115	return err;
116}
117
118/*
119 *	watchdog_stop: wrapper to stop the watchdog.
120 *	@wdd: the watchdog device to stop
121 *
122 *	Stop the watchdog if it is still active and unmark it active.
123 *	This function returns zero on success or a negative errno code for
124 *	failure.
125 *	If the 'nowayout' feature was set, the watchdog cannot be stopped.
126 */
127
128static int watchdog_stop(struct watchdog_device *wdd)
129{
130	int err = 0;
131
132	mutex_lock(&wdd->lock);
133
134	if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
135		err = -ENODEV;
136		goto out_stop;
137	}
138
139	if (!watchdog_active(wdd))
140		goto out_stop;
141
142	if (test_bit(WDOG_NO_WAY_OUT, &wdd->status)) {
143		dev_info(wdd->dev, "nowayout prevents watchdog being stopped!\n");
144		err = -EBUSY;
145		goto out_stop;
146	}
147
148	err = wdd->ops->stop(wdd);
149	if (err == 0)
150		clear_bit(WDOG_ACTIVE, &wdd->status);
151
152out_stop:
153	mutex_unlock(&wdd->lock);
154	return err;
155}
156
157/*
158 *	watchdog_get_status: wrapper to get the watchdog status
159 *	@wdd: the watchdog device to get the status from
160 *	@status: the status of the watchdog device
161 *
162 *	Get the watchdog's status flags.
163 */
164
165static int watchdog_get_status(struct watchdog_device *wdd,
166							unsigned int *status)
167{
168	int err = 0;
169
170	*status = 0;
171	if (!wdd->ops->status)
172		return -EOPNOTSUPP;
173
174	mutex_lock(&wdd->lock);
175
176	if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
177		err = -ENODEV;
178		goto out_status;
179	}
180
181	*status = wdd->ops->status(wdd);
182
183out_status:
184	mutex_unlock(&wdd->lock);
185	return err;
186}
187
188/*
189 *	watchdog_set_timeout: set the watchdog timer timeout
190 *	@wdd: the watchdog device to set the timeout for
191 *	@timeout: timeout to set in seconds
192 */
193
194static int watchdog_set_timeout(struct watchdog_device *wdd,
195							unsigned int timeout)
196{
197	int err;
198
199	if (!wdd->ops->set_timeout || !(wdd->info->options & WDIOF_SETTIMEOUT))
200		return -EOPNOTSUPP;
201
202	if (watchdog_timeout_invalid(wdd, timeout))
203		return -EINVAL;
204
205	mutex_lock(&wdd->lock);
206
207	if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
208		err = -ENODEV;
209		goto out_timeout;
210	}
211
212	err = wdd->ops->set_timeout(wdd, timeout);
213
214out_timeout:
215	mutex_unlock(&wdd->lock);
216	return err;
217}
218
219/*
220 *	watchdog_get_timeleft: wrapper to get the time left before a reboot
221 *	@wdd: the watchdog device to get the remaining time from
222 *	@timeleft: the time that's left
223 *
224 *	Get the time before a watchdog will reboot (if not pinged).
225 */
226
227static int watchdog_get_timeleft(struct watchdog_device *wdd,
228							unsigned int *timeleft)
229{
230	int err = 0;
231
232	*timeleft = 0;
233	if (!wdd->ops->get_timeleft)
234		return -EOPNOTSUPP;
235
236	mutex_lock(&wdd->lock);
237
238	if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
239		err = -ENODEV;
240		goto out_timeleft;
241	}
242
243	*timeleft = wdd->ops->get_timeleft(wdd);
244
245out_timeleft:
246	mutex_unlock(&wdd->lock);
247	return err;
248}
249
250/*
251 *	watchdog_ioctl_op: call the watchdog drivers ioctl op if defined
252 *	@wdd: the watchdog device to do the ioctl on
253 *	@cmd: watchdog command
254 *	@arg: argument pointer
255 */
256
257static int watchdog_ioctl_op(struct watchdog_device *wdd, unsigned int cmd,
258							unsigned long arg)
259{
260	int err;
261
262	if (!wdd->ops->ioctl)
263		return -ENOIOCTLCMD;
264
265	mutex_lock(&wdd->lock);
266
267	if (test_bit(WDOG_UNREGISTERED, &wdd->status)) {
268		err = -ENODEV;
269		goto out_ioctl;
270	}
271
272	err = wdd->ops->ioctl(wdd, cmd, arg);
273
274out_ioctl:
275	mutex_unlock(&wdd->lock);
276	return err;
277}
278
279/*
280 *	watchdog_write: writes to the watchdog.
281 *	@file: file from VFS
282 *	@data: user address of data
283 *	@len: length of data
284 *	@ppos: pointer to the file offset
285 *
286 *	A write to a watchdog device is defined as a keepalive ping.
287 *	Writing the magic 'V' sequence allows the next close to turn
288 *	off the watchdog (if 'nowayout' is not set).
289 */
290
291static ssize_t watchdog_write(struct file *file, const char __user *data,
292						size_t len, loff_t *ppos)
293{
294	struct watchdog_device *wdd = file->private_data;
295	size_t i;
296	char c;
297	int err;
298
299	if (len == 0)
300		return 0;
301
302	/*
303	 * Note: just in case someone wrote the magic character
304	 * five months ago...
305	 */
306	clear_bit(WDOG_ALLOW_RELEASE, &wdd->status);
307
308	/* scan to see whether or not we got the magic character */
309	for (i = 0; i != len; i++) {
310		if (get_user(c, data + i))
311			return -EFAULT;
312		if (c == 'V')
313			set_bit(WDOG_ALLOW_RELEASE, &wdd->status);
314	}
315
316	/* someone wrote to us, so we send the watchdog a keepalive ping */
317	err = watchdog_ping(wdd);
318	if (err < 0)
319		return err;
320
321	return len;
322}
323
324/*
325 *	watchdog_ioctl: handle the different ioctl's for the watchdog device.
326 *	@file: file handle to the device
327 *	@cmd: watchdog command
328 *	@arg: argument pointer
329 *
330 *	The watchdog API defines a common set of functions for all watchdogs
331 *	according to their available features.
332 */
333
334static long watchdog_ioctl(struct file *file, unsigned int cmd,
335							unsigned long arg)
336{
337	struct watchdog_device *wdd = file->private_data;
338	void __user *argp = (void __user *)arg;
339	int __user *p = argp;
340	unsigned int val;
341	int err;
342
343	err = watchdog_ioctl_op(wdd, cmd, arg);
344	if (err != -ENOIOCTLCMD)
345		return err;
346
347	switch (cmd) {
348	case WDIOC_GETSUPPORT:
349		return copy_to_user(argp, wdd->info,
350			sizeof(struct watchdog_info)) ? -EFAULT : 0;
351	case WDIOC_GETSTATUS:
352		err = watchdog_get_status(wdd, &val);
353		if (err == -ENODEV)
354			return err;
355		return put_user(val, p);
356	case WDIOC_GETBOOTSTATUS:
357		return put_user(wdd->bootstatus, p);
358	case WDIOC_SETOPTIONS:
359		if (get_user(val, p))
360			return -EFAULT;
361		if (val & WDIOS_DISABLECARD) {
362			err = watchdog_stop(wdd);
363			if (err < 0)
364				return err;
365		}
366		if (val & WDIOS_ENABLECARD) {
367			err = watchdog_start(wdd);
368			if (err < 0)
369				return err;
370		}
371		return 0;
372	case WDIOC_KEEPALIVE:
373		if (!(wdd->info->options & WDIOF_KEEPALIVEPING))
374			return -EOPNOTSUPP;
375		return watchdog_ping(wdd);
376	case WDIOC_SETTIMEOUT:
377		if (get_user(val, p))
378			return -EFAULT;
379		err = watchdog_set_timeout(wdd, val);
380		if (err < 0)
381			return err;
382		/* If the watchdog is active then we send a keepalive ping
383		 * to make sure that the watchdog keep's running (and if
384		 * possible that it takes the new timeout) */
385		err = watchdog_ping(wdd);
386		if (err < 0)
387			return err;
388		/* Fall */
389	case WDIOC_GETTIMEOUT:
390		/* timeout == 0 means that we don't know the timeout */
391		if (wdd->timeout == 0)
392			return -EOPNOTSUPP;
393		return put_user(wdd->timeout, p);
394	case WDIOC_GETTIMELEFT:
395		err = watchdog_get_timeleft(wdd, &val);
396		if (err)
397			return err;
398		return put_user(val, p);
399	default:
400		return -ENOTTY;
401	}
402}
403
404/*
405 *	watchdog_open: open the /dev/watchdog* devices.
406 *	@inode: inode of device
407 *	@file: file handle to device
408 *
409 *	When the /dev/watchdog* device gets opened, we start the watchdog.
410 *	Watch out: the /dev/watchdog device is single open, so we make sure
411 *	it can only be opened once.
412 */
413
414static int watchdog_open(struct inode *inode, struct file *file)
415{
416	int err = -EBUSY;
417	struct watchdog_device *wdd;
418
419	/* Get the corresponding watchdog device */
420	if (imajor(inode) == MISC_MAJOR)
421		wdd = old_wdd;
422	else
423		wdd = container_of(inode->i_cdev, struct watchdog_device, cdev);
424
425	/* the watchdog is single open! */
426	if (test_and_set_bit(WDOG_DEV_OPEN, &wdd->status))
427		return -EBUSY;
428
429	/*
430	 * If the /dev/watchdog device is open, we don't want the module
431	 * to be unloaded.
432	 */
433	if (!try_module_get(wdd->ops->owner))
434		goto out;
435
436	err = watchdog_start(wdd);
437	if (err < 0)
438		goto out_mod;
439
440	file->private_data = wdd;
441
442	if (wdd->ops->ref)
443		wdd->ops->ref(wdd);
444
445	/* dev/watchdog is a virtual (and thus non-seekable) filesystem */
446	return nonseekable_open(inode, file);
447
448out_mod:
449	module_put(wdd->ops->owner);
450out:
451	clear_bit(WDOG_DEV_OPEN, &wdd->status);
452	return err;
453}
454
455/*
456 *	watchdog_release: release the watchdog device.
457 *	@inode: inode of device
458 *	@file: file handle to device
459 *
460 *	This is the code for when /dev/watchdog gets closed. We will only
461 *	stop the watchdog when we have received the magic char (and nowayout
462 *	was not set), else the watchdog will keep running.
463 */
464
465static int watchdog_release(struct inode *inode, struct file *file)
466{
467	struct watchdog_device *wdd = file->private_data;
468	int err = -EBUSY;
469
470	/*
471	 * We only stop the watchdog if we received the magic character
472	 * or if WDIOF_MAGICCLOSE is not set. If nowayout was set then
473	 * watchdog_stop will fail.
474	 */
475	if (!test_bit(WDOG_ACTIVE, &wdd->status))
476		err = 0;
477	else if (test_and_clear_bit(WDOG_ALLOW_RELEASE, &wdd->status) ||
478		 !(wdd->info->options & WDIOF_MAGICCLOSE))
479		err = watchdog_stop(wdd);
480
481	/* If the watchdog was not stopped, send a keepalive ping */
482	if (err < 0) {
483		mutex_lock(&wdd->lock);
484		if (!test_bit(WDOG_UNREGISTERED, &wdd->status))
485			dev_crit(wdd->dev, "watchdog did not stop!\n");
486		mutex_unlock(&wdd->lock);
487		watchdog_ping(wdd);
488	}
489
490	/* Allow the owner module to be unloaded again */
491	module_put(wdd->ops->owner);
492
493	/* make sure that /dev/watchdog can be re-opened */
494	clear_bit(WDOG_DEV_OPEN, &wdd->status);
495
496	/* Note wdd may be gone after this, do not use after this! */
497	if (wdd->ops->unref)
498		wdd->ops->unref(wdd);
499
500	return 0;
501}
502
503static const struct file_operations watchdog_fops = {
504	.owner		= THIS_MODULE,
505	.write		= watchdog_write,
506	.unlocked_ioctl	= watchdog_ioctl,
507	.open		= watchdog_open,
508	.release	= watchdog_release,
509};
510
511static struct miscdevice watchdog_miscdev = {
512	.minor		= WATCHDOG_MINOR,
513	.name		= "watchdog",
514	.fops		= &watchdog_fops,
515};
516
517/*
518 *	watchdog_dev_register: register a watchdog device
519 *	@wdd: watchdog device
520 *
521 *	Register a watchdog device including handling the legacy
522 *	/dev/watchdog node. /dev/watchdog is actually a miscdevice and
523 *	thus we set it up like that.
524 */
525
526int watchdog_dev_register(struct watchdog_device *wdd)
527{
528	int err, devno;
529
530	if (wdd->id == 0) {
531		old_wdd = wdd;
532		watchdog_miscdev.parent = wdd->parent;
533		err = misc_register(&watchdog_miscdev);
534		if (err != 0) {
535			pr_err("%s: cannot register miscdev on minor=%d (err=%d).\n",
536				wdd->info->identity, WATCHDOG_MINOR, err);
537			if (err == -EBUSY)
538				pr_err("%s: a legacy watchdog module is probably present.\n",
539					wdd->info->identity);
540			old_wdd = NULL;
541			return err;
542		}
543	}
544
545	/* Fill in the data structures */
546	devno = MKDEV(MAJOR(watchdog_devt), wdd->id);
547	cdev_init(&wdd->cdev, &watchdog_fops);
548	wdd->cdev.owner = wdd->ops->owner;
549
550	/* Add the device */
551	err  = cdev_add(&wdd->cdev, devno, 1);
552	if (err) {
553		pr_err("watchdog%d unable to add device %d:%d\n",
554			wdd->id,  MAJOR(watchdog_devt), wdd->id);
555		if (wdd->id == 0) {
556			misc_deregister(&watchdog_miscdev);
557			old_wdd = NULL;
558		}
559	}
560	return err;
561}
562
563/*
564 *	watchdog_dev_unregister: unregister a watchdog device
565 *	@watchdog: watchdog device
566 *
567 *	Unregister the watchdog and if needed the legacy /dev/watchdog device.
568 */
569
570int watchdog_dev_unregister(struct watchdog_device *wdd)
571{
572	mutex_lock(&wdd->lock);
573	set_bit(WDOG_UNREGISTERED, &wdd->status);
574	mutex_unlock(&wdd->lock);
575
576	cdev_del(&wdd->cdev);
577	if (wdd->id == 0) {
578		misc_deregister(&watchdog_miscdev);
579		old_wdd = NULL;
580	}
581	return 0;
582}
583
584/*
585 *	watchdog_dev_init: init dev part of watchdog core
586 *
587 *	Allocate a range of chardev nodes to use for watchdog devices
588 */
589
590int __init watchdog_dev_init(void)
591{
592	int err = alloc_chrdev_region(&watchdog_devt, 0, MAX_DOGS, "watchdog");
593	if (err < 0)
594		pr_err("watchdog: unable to allocate char dev region\n");
595	return err;
596}
597
598/*
599 *	watchdog_dev_exit: exit dev part of watchdog core
600 *
601 *	Release the range of chardev nodes used for watchdog devices
602 */
603
604void __exit watchdog_dev_exit(void)
605{
606	unregister_chrdev_region(watchdog_devt, MAX_DOGS);
607}
608