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  *	@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 
62 static 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 
81 out_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 
95 static 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 
113 out_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 
128 static 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 
152 out_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 
165 static 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 
183 out_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 
194 static 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 
214 out_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 
227 static 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 
245 out_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 
257 static 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 
274 out_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 
291 static 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 
334 static 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 
414 static 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 
448 out_mod:
449 	module_put(wdd->ops->owner);
450 out:
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 
465 static 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 
503 static 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 
511 static 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 
526 int 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 
570 int 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 
590 int __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 
604 void __exit watchdog_dev_exit(void)
605 {
606 	unregister_chrdev_region(watchdog_devt, MAX_DOGS);
607 }
608