Blame view

drivers/watchdog/watchdog_core.c 12.2 KB
d01732789   Guenter Roeck   watchdog: convert...
1
  // SPDX-License-Identifier: GPL-2.0+
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  /*
   *	watchdog_core.c
   *
   *	(c) Copyright 2008-2011 Alan Cox <alan@lxorguk.ukuu.org.uk>,
   *						All Rights Reserved.
   *
   *	(c) Copyright 2008-2011 Wim Van Sebroeck <wim@iguana.be>.
   *
   *	This source code is part of the generic code that can be used
   *	by all the watchdog timer drivers.
   *
   *	Based on source code of the following authors:
   *	  Matt Domsch <Matt_Domsch@dell.com>,
   *	  Rob Radez <rob@osinvestor.com>,
   *	  Rusty Lynch <rusty@linux.co.intel.com>
   *	  Satyam Sharma <satyam@infradead.org>
   *	  Randy Dunlap <randy.dunlap@oracle.com>
   *
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
20
21
22
23
24
25
26
27
28
29
30
   *	Neither Alan Cox, CymruNet Ltd., Wim Van Sebroeck nor Iguana vzw.
   *	admit liability nor provide warranty for any of this software.
   *	This material is provided "AS-IS" and at no charge.
   */
  
  #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  
  #include <linux/module.h>	/* For EXPORT_SYMBOL/module stuff/... */
  #include <linux/types.h>	/* For standard types */
  #include <linux/errno.h>	/* For the -ENODEV/... values */
  #include <linux/kernel.h>	/* For printk/panic/... */
2165bf524   Damien Riegel   watchdog: core: a...
31
  #include <linux/reboot.h>	/* For restart handler */
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
32
33
  #include <linux/watchdog.h>	/* For watchdog specific items */
  #include <linux/init.h>		/* For __init/__exit/... */
45f5fed30   Alan Cox   watchdog: Add mul...
34
  #include <linux/idr.h>		/* For ida_* macros */
d6b469d91   Alan Cox   watchdog: create ...
35
  #include <linux/err.h>		/* For IS_ERR macros */
3048253ed   Fabio Porcedda   watchdog: core: d...
36
  #include <linux/of.h>		/* For of_get_timeout_sec */
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
37

6cfb5aa83   Wim Van Sebroeck   watchdog: correct...
38
  #include "watchdog_core.h"	/* For watchdog_dev_register/... */
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
39

45f5fed30   Alan Cox   watchdog: Add mul...
40
  static DEFINE_IDA(watchdog_ida);
9232c8065   Dmitry Safonov   watchdog: Add sto...
41
42
43
  static int stop_on_reboot = -1;
  module_param(stop_on_reboot, int, 0444);
  MODULE_PARM_DESC(stop_on_reboot, "Stop watchdogs on reboot (0=keep watching, 1=stop)");
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
  /*
   * Deferred Registration infrastructure.
   *
   * Sometimes watchdog drivers needs to be loaded as soon as possible,
   * for example when it's impossible to disable it. To do so,
   * raising the initcall level of the watchdog driver is a solution.
   * But in such case, the miscdev is maybe not ready (subsys_initcall), and
   * watchdog_core need miscdev to register the watchdog as a char device.
   *
   * The deferred registration infrastructure offer a way for the watchdog
   * subsystem to register a watchdog properly, even before miscdev is ready.
   */
  
  static DEFINE_MUTEX(wtd_deferred_reg_mutex);
  static LIST_HEAD(wtd_deferred_reg_list);
  static bool wtd_deferred_reg_done;
80030425e   Wolfram Sang   watchdog: make wa...
60
  static void watchdog_deferred_registration_add(struct watchdog_device *wdd)
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
61
62
63
  {
  	list_add_tail(&wdd->deferred,
  		      &wtd_deferred_reg_list);
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
  }
  
  static void watchdog_deferred_registration_del(struct watchdog_device *wdd)
  {
  	struct list_head *p, *n;
  	struct watchdog_device *wdd_tmp;
  
  	list_for_each_safe(p, n, &wtd_deferred_reg_list) {
  		wdd_tmp = list_entry(p, struct watchdog_device,
  				     deferred);
  		if (wdd_tmp == wdd) {
  			list_del(&wdd_tmp->deferred);
  			break;
  		}
  	}
  }
3048253ed   Fabio Porcedda   watchdog: core: d...
80
81
82
83
84
85
  static void watchdog_check_min_max_timeout(struct watchdog_device *wdd)
  {
  	/*
  	 * Check that we have valid min and max timeout values, if
  	 * not reset them both to 0 (=not used or unknown)
  	 */
1894cad9b   Pratyush Anand   watchdog: skip mi...
86
  	if (!wdd->max_hw_heartbeat_ms && wdd->min_timeout > wdd->max_timeout) {
3048253ed   Fabio Porcedda   watchdog: core: d...
87
88
89
90
91
92
93
94
95
  		pr_info("Invalid min and max timeout values, resetting to 0!
  ");
  		wdd->min_timeout = 0;
  		wdd->max_timeout = 0;
  	}
  }
  
  /**
   * watchdog_init_timeout() - initialize the timeout field
8bc86475a   Corentin Labbe   watchdog: documen...
96
   * @wdd: watchdog device
3048253ed   Fabio Porcedda   watchdog: core: d...
97
98
99
100
101
102
103
   * @timeout_parm: timeout module parameter
   * @dev: Device that stores the timeout-sec property
   *
   * Initialize the timeout field of the watchdog_device struct with either the
   * timeout module parameter (if it is valid value) or the timeout-sec property
   * (only if it is a valid value and the timeout_parm is out of bounds).
   * If none of them are valid then we keep the old value (which should normally
34ef4087a   Wolfram Sang   watchdog: refacto...
104
105
106
   * be the default timeout value). Note that for the module parameter, '0' means
   * 'use default' while it is an invalid value for the timeout-sec property.
   * It should simply be dropped if you want to use the default value then.
3048253ed   Fabio Porcedda   watchdog: core: d...
107
   *
34ef4087a   Wolfram Sang   watchdog: refacto...
108
109
   * A zero is returned on success or -EINVAL if all provided values are out of
   * bounds.
3048253ed   Fabio Porcedda   watchdog: core: d...
110
111
112
113
   */
  int watchdog_init_timeout(struct watchdog_device *wdd,
  				unsigned int timeout_parm, struct device *dev)
  {
e907972be   Wolfram Sang   watchdog: add err...
114
115
  	const char *dev_str = wdd->parent ? dev_name(wdd->parent) :
  			      (const char *)wdd->info->identity;
3048253ed   Fabio Porcedda   watchdog: core: d...
116
117
118
119
  	unsigned int t = 0;
  	int ret = 0;
  
  	watchdog_check_min_max_timeout(wdd);
34ef4087a   Wolfram Sang   watchdog: refacto...
120
121
122
123
124
125
  	/* check the driver supplied value (likely a module parameter) first */
  	if (timeout_parm) {
  		if (!watchdog_timeout_invalid(wdd, timeout_parm)) {
  			wdd->timeout = timeout_parm;
  			return 0;
  		}
e907972be   Wolfram Sang   watchdog: add err...
126
127
128
  		pr_err("%s: driver supplied timeout (%u) out of range
  ",
  			dev_str, timeout_parm);
3048253ed   Fabio Porcedda   watchdog: core: d...
129
  		ret = -EINVAL;
34ef4087a   Wolfram Sang   watchdog: refacto...
130
  	}
3048253ed   Fabio Porcedda   watchdog: core: d...
131
132
  
  	/* try to get the timeout_sec property */
34ef4087a   Wolfram Sang   watchdog: refacto...
133
134
135
136
137
138
  	if (dev && dev->of_node &&
  	    of_property_read_u32(dev->of_node, "timeout-sec", &t) == 0) {
  		if (t && !watchdog_timeout_invalid(wdd, t)) {
  			wdd->timeout = t;
  			return 0;
  		}
e907972be   Wolfram Sang   watchdog: add err...
139
140
  		pr_err("%s: DT supplied timeout (%u) out of range
  ", dev_str, t);
3048253ed   Fabio Porcedda   watchdog: core: d...
141
  		ret = -EINVAL;
34ef4087a   Wolfram Sang   watchdog: refacto...
142
  	}
3048253ed   Fabio Porcedda   watchdog: core: d...
143

e907972be   Wolfram Sang   watchdog: add err...
144
145
146
147
  	if (ret < 0 && wdd->timeout)
  		pr_warn("%s: falling back to default timeout (%u)
  ", dev_str,
  			wdd->timeout);
3048253ed   Fabio Porcedda   watchdog: core: d...
148
149
150
  	return ret;
  }
  EXPORT_SYMBOL_GPL(watchdog_init_timeout);
69503e585   Vladis Dronov   watchdog: fix UAF...
151
152
153
154
155
156
157
  static int watchdog_reboot_notifier(struct notifier_block *nb,
  				    unsigned long code, void *data)
  {
  	struct watchdog_device *wdd;
  
  	wdd = container_of(nb, struct watchdog_device, reboot_nb);
  	if (code == SYS_DOWN || code == SYS_HALT) {
3ba331827   Zhao Qiang   watchdog: stop wd...
158
  		if (watchdog_active(wdd) || watchdog_hw_running(wdd)) {
69503e585   Vladis Dronov   watchdog: fix UAF...
159
160
161
162
163
164
165
166
167
168
  			int ret;
  
  			ret = wdd->ops->stop(wdd);
  			if (ret)
  				return NOTIFY_BAD;
  		}
  	}
  
  	return NOTIFY_DONE;
  }
2165bf524   Damien Riegel   watchdog: core: a...
169
170
171
172
173
174
175
  static int watchdog_restart_notifier(struct notifier_block *nb,
  				     unsigned long action, void *data)
  {
  	struct watchdog_device *wdd = container_of(nb, struct watchdog_device,
  						   restart_nb);
  
  	int ret;
4d8b229d5   Guenter Roeck   watchdog: Add 'ac...
176
  	ret = wdd->ops->restart(wdd, action, data);
2165bf524   Damien Riegel   watchdog: core: a...
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
  	if (ret)
  		return NOTIFY_BAD;
  
  	return NOTIFY_DONE;
  }
  
  /**
   * watchdog_set_restart_priority - Change priority of restart handler
   * @wdd: watchdog device
   * @priority: priority of the restart handler, should follow these guidelines:
   *   0:   use watchdog's restart function as last resort, has limited restart
   *        capabilies
   *   128: default restart handler, use if no other handler is expected to be
   *        available and/or if restart is sufficient to restart the entire system
   *   255: preempt all other handlers
   *
   * If a wdd->ops->restart function is provided when watchdog_register_device is
   * called, it will be registered as a restart handler with the priority given
   * here.
   */
  void watchdog_set_restart_priority(struct watchdog_device *wdd, int priority)
  {
  	wdd->restart_nb.priority = priority;
  }
  EXPORT_SYMBOL_GPL(watchdog_set_restart_priority);
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
202
  static int __watchdog_register_device(struct watchdog_device *wdd)
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
203
  {
32ecc6392   Guenter Roeck   watchdog: Create ...
204
  	int ret, id = -1;
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
205
206
207
208
209
  
  	if (wdd == NULL || wdd->info == NULL || wdd->ops == NULL)
  		return -EINVAL;
  
  	/* Mandatory operations need to be supported */
d0684c8a9   Guenter Roeck   watchdog: Make st...
210
  	if (!wdd->ops->start || (!wdd->ops->stop && !wdd->max_hw_heartbeat_ms))
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
211
  		return -EINVAL;
3048253ed   Fabio Porcedda   watchdog: core: d...
212
  	watchdog_check_min_max_timeout(wdd);
3f43f68e2   Wim Van Sebroeck   watchdog: WatchDo...
213
214
  
  	/*
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
215
216
217
218
  	 * Note: now that all watchdog_device data has been verified, we
  	 * will not check this anymore in other functions. If data gets
  	 * corrupted in a later stage then we expect a kernel panic!
  	 */
9dd4e173f   Justin Chen   watchdog: watchdo...
219
220
221
222
223
224
225
226
227
228
  	/* Use alias for watchdog id if possible */
  	if (wdd->parent) {
  		ret = of_alias_get_id(wdd->parent->of_node, "watchdog");
  		if (ret >= 0)
  			id = ida_simple_get(&watchdog_ida, ret,
  					    ret + 1, GFP_KERNEL);
  	}
  
  	if (id < 0)
  		id = ida_simple_get(&watchdog_ida, 0, MAX_DOGS, GFP_KERNEL);
45f5fed30   Alan Cox   watchdog: Add mul...
229
230
231
  	if (id < 0)
  		return id;
  	wdd->id = id;
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
232
233
  	ret = watchdog_dev_register(wdd);
  	if (ret) {
45f5fed30   Alan Cox   watchdog: Add mul...
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
  		ida_simple_remove(&watchdog_ida, id);
  		if (!(id == 0 && ret == -EBUSY))
  			return ret;
  
  		/* Retry in case a legacy watchdog module exists */
  		id = ida_simple_get(&watchdog_ida, 1, MAX_DOGS, GFP_KERNEL);
  		if (id < 0)
  			return id;
  		wdd->id = id;
  
  		ret = watchdog_dev_register(wdd);
  		if (ret) {
  			ida_simple_remove(&watchdog_ida, id);
  			return ret;
  		}
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
249
  	}
9232c8065   Dmitry Safonov   watchdog: Add sto...
250
251
252
253
254
255
256
  	/* Module parameter to force watchdog policy on reboot. */
  	if (stop_on_reboot != -1) {
  		if (stop_on_reboot)
  			set_bit(WDOG_STOP_ON_REBOOT, &wdd->status);
  		else
  			clear_bit(WDOG_STOP_ON_REBOOT, &wdd->status);
  	}
69503e585   Vladis Dronov   watchdog: fix UAF...
257
  	if (test_bit(WDOG_STOP_ON_REBOOT, &wdd->status)) {
9dc1b44d4   Wang Wensheng   watchdog: Fix pot...
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
  		if (!wdd->ops->stop)
  			pr_warn("watchdog%d: stop_on_reboot not supported
  ", wdd->id);
  		else {
  			wdd->reboot_nb.notifier_call = watchdog_reboot_notifier;
  
  			ret = register_reboot_notifier(&wdd->reboot_nb);
  			if (ret) {
  				pr_err("watchdog%d: Cannot register reboot notifier (%d)
  ",
  					wdd->id, ret);
  				watchdog_dev_unregister(wdd);
  				ida_simple_remove(&watchdog_ida, id);
  				return ret;
  			}
69503e585   Vladis Dronov   watchdog: fix UAF...
273
274
  		}
  	}
2165bf524   Damien Riegel   watchdog: core: a...
275
276
277
278
279
  	if (wdd->ops->restart) {
  		wdd->restart_nb.notifier_call = watchdog_restart_notifier;
  
  		ret = register_restart_handler(&wdd->restart_nb);
  		if (ret)
c01e01597   Masanari Iida   treewide: Fix typ...
280
281
  			pr_warn("watchdog%d: Cannot register restart handler (%d)
  ",
0254e9535   Guenter Roeck   watchdog: Drop po...
282
  				wdd->id, ret);
2165bf524   Damien Riegel   watchdog: core: a...
283
  	}
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
284
285
  	return 0;
  }
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
286
287
  
  /**
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
288
289
   * watchdog_register_device() - register a watchdog device
   * @wdd: watchdog device
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
290
   *
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
291
292
293
294
295
   * Register a watchdog device with the kernel so that the
   * watchdog timer can be accessed from userspace.
   *
   * A zero is returned on success and a negative errno code for
   * failure.
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
296
   */
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
297
298
299
  
  int watchdog_register_device(struct watchdog_device *wdd)
  {
b608075e4   Wolfram Sang   watchdog: let cor...
300
  	const char *dev_str;
80030425e   Wolfram Sang   watchdog: make wa...
301
  	int ret = 0;
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
302
303
304
305
306
  
  	mutex_lock(&wtd_deferred_reg_mutex);
  	if (wtd_deferred_reg_done)
  		ret = __watchdog_register_device(wdd);
  	else
80030425e   Wolfram Sang   watchdog: make wa...
307
  		watchdog_deferred_registration_add(wdd);
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
308
  	mutex_unlock(&wtd_deferred_reg_mutex);
b608075e4   Wolfram Sang   watchdog: let cor...
309
310
311
312
313
314
315
316
  
  	if (ret) {
  		dev_str = wdd->parent ? dev_name(wdd->parent) :
  			  (const char *)wdd->info->identity;
  		pr_err("%s: failed to register watchdog device (err = %d)
  ",
  			dev_str, ret);
  	}
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
317
318
319
320
321
  	return ret;
  }
  EXPORT_SYMBOL_GPL(watchdog_register_device);
  
  static void __watchdog_unregister_device(struct watchdog_device *wdd)
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
322
  {
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
323
324
  	if (wdd == NULL)
  		return;
2165bf524   Damien Riegel   watchdog: core: a...
325
326
  	if (wdd->ops->restart)
  		unregister_restart_handler(&wdd->restart_nb);
69503e585   Vladis Dronov   watchdog: fix UAF...
327
328
  	if (test_bit(WDOG_STOP_ON_REBOOT, &wdd->status))
  		unregister_reboot_notifier(&wdd->reboot_nb);
32ecc6392   Guenter Roeck   watchdog: Create ...
329
  	watchdog_dev_unregister(wdd);
45f5fed30   Alan Cox   watchdog: Add mul...
330
  	ida_simple_remove(&watchdog_ida, wdd->id);
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
331
  }
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
  
  /**
   * watchdog_unregister_device() - unregister a watchdog device
   * @wdd: watchdog device to unregister
   *
   * Unregister a watchdog device that was previously successfully
   * registered with watchdog_register_device().
   */
  
  void watchdog_unregister_device(struct watchdog_device *wdd)
  {
  	mutex_lock(&wtd_deferred_reg_mutex);
  	if (wtd_deferred_reg_done)
  		__watchdog_unregister_device(wdd);
  	else
  		watchdog_deferred_registration_del(wdd);
  	mutex_unlock(&wtd_deferred_reg_mutex);
  }
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
350
  EXPORT_SYMBOL_GPL(watchdog_unregister_device);
83fbae5a1   Neil Armstrong   watchdog: Add a d...
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
  static void devm_watchdog_unregister_device(struct device *dev, void *res)
  {
  	watchdog_unregister_device(*(struct watchdog_device **)res);
  }
  
  /**
   * devm_watchdog_register_device() - resource managed watchdog_register_device()
   * @dev: device that is registering this watchdog device
   * @wdd: watchdog device
   *
   * Managed watchdog_register_device(). For watchdog device registered by this
   * function,  watchdog_unregister_device() is automatically called on driver
   * detach. See watchdog_register_device() for more information.
   */
  int devm_watchdog_register_device(struct device *dev,
  				struct watchdog_device *wdd)
  {
  	struct watchdog_device **rcwdd;
  	int ret;
2e91838bf   Guenter Roeck   watchdog: core: F...
370
  	rcwdd = devres_alloc(devm_watchdog_unregister_device, sizeof(*rcwdd),
83fbae5a1   Neil Armstrong   watchdog: Add a d...
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
  			     GFP_KERNEL);
  	if (!rcwdd)
  		return -ENOMEM;
  
  	ret = watchdog_register_device(wdd);
  	if (!ret) {
  		*rcwdd = wdd;
  		devres_add(dev, rcwdd);
  	} else {
  		devres_free(rcwdd);
  	}
  
  	return ret;
  }
  EXPORT_SYMBOL_GPL(devm_watchdog_register_device);
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
  static int __init watchdog_deferred_registration(void)
  {
  	mutex_lock(&wtd_deferred_reg_mutex);
  	wtd_deferred_reg_done = true;
  	while (!list_empty(&wtd_deferred_reg_list)) {
  		struct watchdog_device *wdd;
  
  		wdd = list_first_entry(&wtd_deferred_reg_list,
  				       struct watchdog_device, deferred);
  		list_del(&wdd->deferred);
  		__watchdog_register_device(wdd);
  	}
  	mutex_unlock(&wtd_deferred_reg_mutex);
  	return 0;
  }
45f5fed30   Alan Cox   watchdog: Add mul...
401
402
  static int __init watchdog_init(void)
  {
32ecc6392   Guenter Roeck   watchdog: Create ...
403
404
405
406
407
  	int err;
  
  	err = watchdog_dev_init();
  	if (err < 0)
  		return err;
d6b469d91   Alan Cox   watchdog: create ...
408

ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
409
  	watchdog_deferred_registration();
d6b469d91   Alan Cox   watchdog: create ...
410
  	return 0;
45f5fed30   Alan Cox   watchdog: Add mul...
411
412
413
414
415
416
417
  }
  
  static void __exit watchdog_exit(void)
  {
  	watchdog_dev_exit();
  	ida_destroy(&watchdog_ida);
  }
ef90174f8   Jean-Baptiste Theou   watchdog: watchdo...
418
  subsys_initcall_sync(watchdog_init);
45f5fed30   Alan Cox   watchdog: Add mul...
419
  module_exit(watchdog_exit);
43316044d   Wim Van Sebroeck   watchdog: WatchDo...
420
421
422
423
  MODULE_AUTHOR("Alan Cox <alan@lxorguk.ukuu.org.uk>");
  MODULE_AUTHOR("Wim Van Sebroeck <wim@iguana.be>");
  MODULE_DESCRIPTION("WatchDog Timer Driver Core");
  MODULE_LICENSE("GPL");