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