1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  *	watchdog_core.c
4  *
5  *	(c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
6  *						All Rights Reserved.
7  *
8  *	(c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
9  *
10  *	This source code is part of the generic code that can be used
11  *	by all the watchdog timer drivers.
12  *
13  *	Based on source code of the following authors:
14  *	  Matt Domsch <Matt_Domsch@dell.com>,
15  *	  Rob Radez <rob@osinvestor.com>,
16  *	  Rusty Lynch <rusty@linux.co.intel.com>
17  *	  Satyam Sharma <satyam@infradead.org>
18  *	  Randy Dunlap <randy.dunlap@oracle.com>
19  *
20  *	Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw.
21  *	admit liability nor provide warranty for any of this software.
22  *	This material is provided "AS-IS" and at no charge.
23  */
24 
25 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
26 
27 #include <linux/module.h>	/* For EXPORT_SYMBOL/module stuff/... */
28 #include <linux/types.h>	/* For standard types */
29 #include <linux/errno.h>	/* For the -ENODEV/... values */
30 #include <linux/kernel.h>	/* For printk/panic/... */
31 #include <linux/reboot.h>	/* For restart handler */
32 #include <linux/watchdog.h>	/* For watchdog specific items */
33 #include <linux/init.h>		/* For __init/__exit/... */
34 #include <linux/idr.h>		/* For ida_* macros */
35 #include <linux/err.h>		/* For IS_ERR macros */
36 #include <linux/of.h>		/* For of_get_timeout_sec */
37 
38 #include "watchdog_core.h"	/* For watchdog_dev_register/... */
39 
40 static DEFINE_IDA(watchdog_ida);
41 
42 static int stop_on_reboot = -1;
43 module_param(stop_on_reboot, int, 0444);
44 MODULE_PARM_DESC(stop_on_reboot, "Stop watchdogs on reboot (0=keep watching, 1=stop)");
45 
46 /*
47  * Deferred Registration infrastructure.
48  *
49  * Sometimes watchdog drivers needs to be loaded as soon as possible,
50  * for example when it's impossible to disable it. To do so,
51  * raising the initcall level of the watchdog driver is a solution.
52  * But in such case, the miscdev is maybe not ready (subsys_initcall), and
53  * watchdog_core need miscdev to register the watchdog as a char device.
54  *
55  * The deferred registration infrastructure offer a way for the watchdog
56  * subsystem to register a watchdog properly, even before miscdev is ready.
57  */
58 
59 static DEFINE_MUTEX(wtd_deferred_reg_mutex);
60 static LIST_HEAD(wtd_deferred_reg_list);
61 static bool wtd_deferred_reg_done;
62 
63 static void watchdog_deferred_registration_add(struct watchdog_device *wdd)
64 {
65 	list_add_tail(&wdd->deferred,
66 		      &wtd_deferred_reg_list);
67 }
68 
69 static void watchdog_deferred_registration_del(struct watchdog_device *wdd)
70 {
71 	struct list_head *p, *n;
72 	struct watchdog_device *wdd_tmp;
73 
74 	list_for_each_safe(p, n, &wtd_deferred_reg_list) {
75 		wdd_tmp = list_entry(p, struct watchdog_device,
76 				     deferred);
77 		if (wdd_tmp == wdd) {
78 			list_del(&wdd_tmp->deferred);
79 			break;
80 		}
81 	}
82 }
83 
84 static void watchdog_check_min_max_timeout(struct watchdog_device *wdd)
85 {
86 	/*
87 	 * Check that we have valid min and max timeout values, if
88 	 * not reset them both to 0 (=not used or unknown)
89 	 */
90 	if (!wdd->max_hw_heartbeat_ms && wdd->min_timeout > wdd->max_timeout) {
91 		pr_info("Invalid min and max timeout values, resetting to 0!\n");
92 		wdd->min_timeout = 0;
93 		wdd->max_timeout = 0;
94 	}
95 }
96 
97 /**
98  * watchdog_init_timeout() - initialize the timeout field
99  * @wdd: watchdog device
100  * @timeout_parm: timeout module parameter
101  * @dev: Device that stores the timeout-sec property
102  *
103  * Initialize the timeout field of the watchdog_device struct with either the
104  * timeout module parameter (if it is valid value) or the timeout-sec property
105  * (only if it is a valid value and the timeout_parm is out of bounds).
106  * If none of them are valid then we keep the old value (which should normally
107  * be the default timeout value). Note that for the module parameter, '0' means
108  * 'use default' while it is an invalid value for the timeout-sec property.
109  * It should simply be dropped if you want to use the default value then.
110  *
111  * A zero is returned on success or -EINVAL if all provided values are out of
112  * bounds.
113  */
114 int watchdog_init_timeout(struct watchdog_device *wdd,
115 				unsigned int timeout_parm, struct device *dev)
116 {
117 	const char *dev_str = wdd->parent ? dev_name(wdd->parent) :
118 			      (const char *)wdd->info->identity;
119 	unsigned int t = 0;
120 	int ret = 0;
121 
122 	watchdog_check_min_max_timeout(wdd);
123 
124 	/* check the driver supplied value (likely a module parameter) first */
125 	if (timeout_parm) {
126 		if (!watchdog_timeout_invalid(wdd, timeout_parm)) {
127 			wdd->timeout = timeout_parm;
128 			return 0;
129 		}
130 		pr_err("%s: driver supplied timeout (%u) out of range\n",
131 			dev_str, timeout_parm);
132 		ret = -EINVAL;
133 	}
134 
135 	/* try to get the timeout_sec property */
136 	if (dev && dev->of_node &&
137 	    of_property_read_u32(dev->of_node, "timeout-sec", &t) == 0) {
138 		if (t && !watchdog_timeout_invalid(wdd, t)) {
139 			wdd->timeout = t;
140 			return 0;
141 		}
142 		pr_err("%s: DT supplied timeout (%u) out of range\n", dev_str, t);
143 		ret = -EINVAL;
144 	}
145 
146 	if (ret < 0 && wdd->timeout)
147 		pr_warn("%s: falling back to default timeout (%u)\n", dev_str,
148 			wdd->timeout);
149 
150 	return ret;
151 }
152 EXPORT_SYMBOL_GPL(watchdog_init_timeout);
153 
154 static int watchdog_reboot_notifier(struct notifier_block *nb,
155 				    unsigned long code, void *data)
156 {
157 	struct watchdog_device *wdd;
158 
159 	wdd = container_of(nb, struct watchdog_device, reboot_nb);
160 	if (code == SYS_DOWN || code == SYS_HALT) {
161 		if (watchdog_active(wdd)) {
162 			int ret;
163 
164 			ret = wdd->ops->stop(wdd);
165 			if (ret)
166 				return NOTIFY_BAD;
167 		}
168 	}
169 
170 	return NOTIFY_DONE;
171 }
172 
173 static int watchdog_restart_notifier(struct notifier_block *nb,
174 				     unsigned long action, void *data)
175 {
176 	struct watchdog_device *wdd = container_of(nb, struct watchdog_device,
177 						   restart_nb);
178 
179 	int ret;
180 
181 	ret = wdd->ops->restart(wdd, action, data);
182 	if (ret)
183 		return NOTIFY_BAD;
184 
185 	return NOTIFY_DONE;
186 }
187 
188 /**
189  * watchdog_set_restart_priority - Change priority of restart handler
190  * @wdd: watchdog device
191  * @priority: priority of the restart handler, should follow these guidelines:
192  *   0:   use watchdog's restart function as last resort, has limited restart
193  *        capabilies
194  *   128: default restart handler, use if no other handler is expected to be
195  *        available and/or if restart is sufficient to restart the entire system
196  *   255: preempt all other handlers
197  *
198  * If a wdd->ops->restart function is provided when watchdog_register_device is
199  * called, it will be registered as a restart handler with the priority given
200  * here.
201  */
202 void watchdog_set_restart_priority(struct watchdog_device *wdd, int priority)
203 {
204 	wdd->restart_nb.priority = priority;
205 }
206 EXPORT_SYMBOL_GPL(watchdog_set_restart_priority);
207 
208 static int __watchdog_register_device(struct watchdog_device *wdd)
209 {
210 	int ret, id = -1;
211 
212 	if (wdd == NULL || wdd->info == NULL || wdd->ops == NULL)
213 		return -EINVAL;
214 
215 	/* Mandatory operations need to be supported */
216 	if (!wdd->ops->start || (!wdd->ops->stop && !wdd->max_hw_heartbeat_ms))
217 		return -EINVAL;
218 
219 	watchdog_check_min_max_timeout(wdd);
220 
221 	/*
222 	 * Note: now that all watchdog_device data has been verified, we
223 	 * will not check this anymore in other functions. If data gets
224 	 * corrupted in a later stage then we expect a kernel panic!
225 	 */
226 
227 	/* Use alias for watchdog id if possible */
228 	if (wdd->parent) {
229 		ret = of_alias_get_id(wdd->parent->of_node, "watchdog");
230 		if (ret >= 0)
231 			id = ida_simple_get(&watchdog_ida, ret,
232 					    ret + 1, GFP_KERNEL);
233 	}
234 
235 	if (id < 0)
236 		id = ida_simple_get(&watchdog_ida, 0, MAX_DOGS, GFP_KERNEL);
237 
238 	if (id < 0)
239 		return id;
240 	wdd->id = id;
241 
242 	ret = watchdog_dev_register(wdd);
243 	if (ret) {
244 		ida_simple_remove(&watchdog_ida, id);
245 		if (!(id == 0 && ret == -EBUSY))
246 			return ret;
247 
248 		/* Retry in case a legacy watchdog module exists */
249 		id = ida_simple_get(&watchdog_ida, 1, MAX_DOGS, GFP_KERNEL);
250 		if (id < 0)
251 			return id;
252 		wdd->id = id;
253 
254 		ret = watchdog_dev_register(wdd);
255 		if (ret) {
256 			ida_simple_remove(&watchdog_ida, id);
257 			return ret;
258 		}
259 	}
260 
261 	/* Module parameter to force watchdog policy on reboot. */
262 	if (stop_on_reboot != -1) {
263 		if (stop_on_reboot)
264 			set_bit(WDOG_STOP_ON_REBOOT, &wdd->status);
265 		else
266 			clear_bit(WDOG_STOP_ON_REBOOT, &wdd->status);
267 	}
268 
269 	if (test_bit(WDOG_STOP_ON_REBOOT, &wdd->status)) {
270 		wdd->reboot_nb.notifier_call = watchdog_reboot_notifier;
271 
272 		ret = register_reboot_notifier(&wdd->reboot_nb);
273 		if (ret) {
274 			pr_err("watchdog%d: Cannot register reboot notifier (%d)\n",
275 			       wdd->id, ret);
276 			watchdog_dev_unregister(wdd);
277 			ida_simple_remove(&watchdog_ida, id);
278 			return ret;
279 		}
280 	}
281 
282 	if (wdd->ops->restart) {
283 		wdd->restart_nb.notifier_call = watchdog_restart_notifier;
284 
285 		ret = register_restart_handler(&wdd->restart_nb);
286 		if (ret)
287 			pr_warn("watchdog%d: Cannot register restart handler (%d)\n",
288 				wdd->id, ret);
289 	}
290 
291 	return 0;
292 }
293 
294 /**
295  * watchdog_register_device() - register a watchdog device
296  * @wdd: watchdog device
297  *
298  * Register a watchdog device with the kernel so that the
299  * watchdog timer can be accessed from userspace.
300  *
301  * A zero is returned on success and a negative errno code for
302  * failure.
303  */
304 
305 int watchdog_register_device(struct watchdog_device *wdd)
306 {
307 	const char *dev_str;
308 	int ret = 0;
309 
310 	mutex_lock(&wtd_deferred_reg_mutex);
311 	if (wtd_deferred_reg_done)
312 		ret = __watchdog_register_device(wdd);
313 	else
314 		watchdog_deferred_registration_add(wdd);
315 	mutex_unlock(&wtd_deferred_reg_mutex);
316 
317 	if (ret) {
318 		dev_str = wdd->parent ? dev_name(wdd->parent) :
319 			  (const char *)wdd->info->identity;
320 		pr_err("%s: failed to register watchdog device (err = %d)\n",
321 			dev_str, ret);
322 	}
323 
324 	return ret;
325 }
326 EXPORT_SYMBOL_GPL(watchdog_register_device);
327 
328 static void __watchdog_unregister_device(struct watchdog_device *wdd)
329 {
330 	if (wdd == NULL)
331 		return;
332 
333 	if (wdd->ops->restart)
334 		unregister_restart_handler(&wdd->restart_nb);
335 
336 	if (test_bit(WDOG_STOP_ON_REBOOT, &wdd->status))
337 		unregister_reboot_notifier(&wdd->reboot_nb);
338 
339 	watchdog_dev_unregister(wdd);
340 	ida_simple_remove(&watchdog_ida, wdd->id);
341 }
342 
343 /**
344  * watchdog_unregister_device() - unregister a watchdog device
345  * @wdd: watchdog device to unregister
346  *
347  * Unregister a watchdog device that was previously successfully
348  * registered with watchdog_register_device().
349  */
350 
351 void watchdog_unregister_device(struct watchdog_device *wdd)
352 {
353 	mutex_lock(&wtd_deferred_reg_mutex);
354 	if (wtd_deferred_reg_done)
355 		__watchdog_unregister_device(wdd);
356 	else
357 		watchdog_deferred_registration_del(wdd);
358 	mutex_unlock(&wtd_deferred_reg_mutex);
359 }
360 
361 EXPORT_SYMBOL_GPL(watchdog_unregister_device);
362 
363 static void devm_watchdog_unregister_device(struct device *dev, void *res)
364 {
365 	watchdog_unregister_device(*(struct watchdog_device **)res);
366 }
367 
368 /**
369  * devm_watchdog_register_device() - resource managed watchdog_register_device()
370  * @dev: device that is registering this watchdog device
371  * @wdd: watchdog device
372  *
373  * Managed watchdog_register_device(). For watchdog device registered by this
374  * function,  watchdog_unregister_device() is automatically called on driver
375  * detach. See watchdog_register_device() for more information.
376  */
377 int devm_watchdog_register_device(struct device *dev,
378 				struct watchdog_device *wdd)
379 {
380 	struct watchdog_device **rcwdd;
381 	int ret;
382 
383 	rcwdd = devres_alloc(devm_watchdog_unregister_device, sizeof(*rcwdd),
384 			     GFP_KERNEL);
385 	if (!rcwdd)
386 		return -ENOMEM;
387 
388 	ret = watchdog_register_device(wdd);
389 	if (!ret) {
390 		*rcwdd = wdd;
391 		devres_add(dev, rcwdd);
392 	} else {
393 		devres_free(rcwdd);
394 	}
395 
396 	return ret;
397 }
398 EXPORT_SYMBOL_GPL(devm_watchdog_register_device);
399 
400 static int __init watchdog_deferred_registration(void)
401 {
402 	mutex_lock(&wtd_deferred_reg_mutex);
403 	wtd_deferred_reg_done = true;
404 	while (!list_empty(&wtd_deferred_reg_list)) {
405 		struct watchdog_device *wdd;
406 
407 		wdd = list_first_entry(&wtd_deferred_reg_list,
408 				       struct watchdog_device, deferred);
409 		list_del(&wdd->deferred);
410 		__watchdog_register_device(wdd);
411 	}
412 	mutex_unlock(&wtd_deferred_reg_mutex);
413 	return 0;
414 }
415 
416 static int __init watchdog_init(void)
417 {
418 	int err;
419 
420 	err = watchdog_dev_init();
421 	if (err < 0)
422 		return err;
423 
424 	watchdog_deferred_registration();
425 	return 0;
426 }
427 
428 static void __exit watchdog_exit(void)
429 {
430 	watchdog_dev_exit();
431 	ida_destroy(&watchdog_ida);
432 }
433 
434 subsys_initcall_sync(watchdog_init);
435 module_exit(watchdog_exit);
436 
437 MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
438 MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
439 MODULE_DESCRIPTION("WatchDog Timer Driver Core");
440 MODULE_LICENSE("GPL");
441