diff options
-rw-r--r-- | drivers/watchdog/Kconfig | 10 | ||||
-rw-r--r-- | drivers/watchdog/Makefile | 3 | ||||
-rw-r--r-- | drivers/watchdog/xen_wdt.c | 359 | ||||
-rw-r--r-- | include/xen/interface/sched.h | 34 |
4 files changed, 406 insertions, 0 deletions
diff --git a/drivers/watchdog/Kconfig b/drivers/watchdog/Kconfig index 28a9835f8256..6c216f91b953 100644 --- a/drivers/watchdog/Kconfig +++ b/drivers/watchdog/Kconfig | |||
@@ -1137,6 +1137,16 @@ config WATCHDOG_RIO | |||
1137 | 1137 | ||
1138 | # XTENSA Architecture | 1138 | # XTENSA Architecture |
1139 | 1139 | ||
1140 | # Xen Architecture | ||
1141 | |||
1142 | config XEN_WDT | ||
1143 | tristate "Xen Watchdog support" | ||
1144 | depends on XEN | ||
1145 | help | ||
1146 | Say Y here to support the hypervisor watchdog capability provided | ||
1147 | by Xen 4.0 and newer. The watchdog timeout period is normally one | ||
1148 | minute but can be changed with a boot-time parameter. | ||
1149 | |||
1140 | # | 1150 | # |
1141 | # ISA-based Watchdog Cards | 1151 | # ISA-based Watchdog Cards |
1142 | # | 1152 | # |
diff --git a/drivers/watchdog/Makefile b/drivers/watchdog/Makefile index b037f3d0ec1a..d520bf9c3355 100644 --- a/drivers/watchdog/Makefile +++ b/drivers/watchdog/Makefile | |||
@@ -150,6 +150,9 @@ obj-$(CONFIG_WATCHDOG_CP1XXX) += cpwd.o | |||
150 | 150 | ||
151 | # XTENSA Architecture | 151 | # XTENSA Architecture |
152 | 152 | ||
153 | # Xen | ||
154 | obj-$(CONFIG_XEN_WDT) += xen_wdt.o | ||
155 | |||
153 | # Architecture Independant | 156 | # Architecture Independant |
154 | obj-$(CONFIG_WM831X_WATCHDOG) += wm831x_wdt.o | 157 | obj-$(CONFIG_WM831X_WATCHDOG) += wm831x_wdt.o |
155 | obj-$(CONFIG_WM8350_WATCHDOG) += wm8350_wdt.o | 158 | obj-$(CONFIG_WM8350_WATCHDOG) += wm8350_wdt.o |
diff --git a/drivers/watchdog/xen_wdt.c b/drivers/watchdog/xen_wdt.c new file mode 100644 index 000000000000..49bd9d395562 --- /dev/null +++ b/drivers/watchdog/xen_wdt.c | |||
@@ -0,0 +1,359 @@ | |||
1 | /* | ||
2 | * Xen Watchdog Driver | ||
3 | * | ||
4 | * (c) Copyright 2010 Novell, Inc. | ||
5 | * | ||
6 | * This program is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU General Public License | ||
8 | * as published by the Free Software Foundation; either version | ||
9 | * 2 of the License, or (at your option) any later version. | ||
10 | */ | ||
11 | |||
12 | #define DRV_NAME "wdt" | ||
13 | #define DRV_VERSION "0.01" | ||
14 | #define PFX DRV_NAME ": " | ||
15 | |||
16 | #include <linux/bug.h> | ||
17 | #include <linux/errno.h> | ||
18 | #include <linux/fs.h> | ||
19 | #include <linux/hrtimer.h> | ||
20 | #include <linux/kernel.h> | ||
21 | #include <linux/ktime.h> | ||
22 | #include <linux/init.h> | ||
23 | #include <linux/miscdevice.h> | ||
24 | #include <linux/module.h> | ||
25 | #include <linux/moduleparam.h> | ||
26 | #include <linux/platform_device.h> | ||
27 | #include <linux/spinlock.h> | ||
28 | #include <linux/uaccess.h> | ||
29 | #include <linux/watchdog.h> | ||
30 | #include <xen/xen.h> | ||
31 | #include <asm/xen/hypercall.h> | ||
32 | #include <xen/interface/sched.h> | ||
33 | |||
34 | static struct platform_device *platform_device; | ||
35 | static DEFINE_SPINLOCK(wdt_lock); | ||
36 | static struct sched_watchdog wdt; | ||
37 | static __kernel_time_t wdt_expires; | ||
38 | static bool is_active, expect_release; | ||
39 | |||
40 | #define WATCHDOG_TIMEOUT 60 /* in seconds */ | ||
41 | static unsigned int timeout = WATCHDOG_TIMEOUT; | ||
42 | module_param(timeout, uint, S_IRUGO); | ||
43 | MODULE_PARM_DESC(timeout, "Watchdog timeout in seconds " | ||
44 | "(default=" __MODULE_STRING(WATCHDOG_TIMEOUT) ")"); | ||
45 | |||
46 | static bool nowayout = WATCHDOG_NOWAYOUT; | ||
47 | module_param(nowayout, bool, S_IRUGO); | ||
48 | MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started " | ||
49 | "(default=" __MODULE_STRING(WATCHDOG_NOWAYOUT) ")"); | ||
50 | |||
51 | static inline __kernel_time_t set_timeout(void) | ||
52 | { | ||
53 | wdt.timeout = timeout; | ||
54 | return ktime_to_timespec(ktime_get()).tv_sec + timeout; | ||
55 | } | ||
56 | |||
57 | static int xen_wdt_start(void) | ||
58 | { | ||
59 | __kernel_time_t expires; | ||
60 | int err; | ||
61 | |||
62 | spin_lock(&wdt_lock); | ||
63 | |||
64 | expires = set_timeout(); | ||
65 | if (!wdt.id) | ||
66 | err = HYPERVISOR_sched_op(SCHEDOP_watchdog, &wdt); | ||
67 | else | ||
68 | err = -EBUSY; | ||
69 | if (err > 0) { | ||
70 | wdt.id = err; | ||
71 | wdt_expires = expires; | ||
72 | err = 0; | ||
73 | } else | ||
74 | BUG_ON(!err); | ||
75 | |||
76 | spin_unlock(&wdt_lock); | ||
77 | |||
78 | return err; | ||
79 | } | ||
80 | |||
81 | static int xen_wdt_stop(void) | ||
82 | { | ||
83 | int err = 0; | ||
84 | |||
85 | spin_lock(&wdt_lock); | ||
86 | |||
87 | wdt.timeout = 0; | ||
88 | if (wdt.id) | ||
89 | err = HYPERVISOR_sched_op(SCHEDOP_watchdog, &wdt); | ||
90 | if (!err) | ||
91 | wdt.id = 0; | ||
92 | |||
93 | spin_unlock(&wdt_lock); | ||
94 | |||
95 | return err; | ||
96 | } | ||
97 | |||
98 | static int xen_wdt_kick(void) | ||
99 | { | ||
100 | __kernel_time_t expires; | ||
101 | int err; | ||
102 | |||
103 | spin_lock(&wdt_lock); | ||
104 | |||
105 | expires = set_timeout(); | ||
106 | if (wdt.id) | ||
107 | err = HYPERVISOR_sched_op(SCHEDOP_watchdog, &wdt); | ||
108 | else | ||
109 | err = -ENXIO; | ||
110 | if (!err) | ||
111 | wdt_expires = expires; | ||
112 | |||
113 | spin_unlock(&wdt_lock); | ||
114 | |||
115 | return err; | ||
116 | } | ||
117 | |||
118 | static int xen_wdt_open(struct inode *inode, struct file *file) | ||
119 | { | ||
120 | int err; | ||
121 | |||
122 | /* /dev/watchdog can only be opened once */ | ||
123 | if (xchg(&is_active, true)) | ||
124 | return -EBUSY; | ||
125 | |||
126 | err = xen_wdt_start(); | ||
127 | if (err == -EBUSY) | ||
128 | err = xen_wdt_kick(); | ||
129 | return err ?: nonseekable_open(inode, file); | ||
130 | } | ||
131 | |||
132 | static int xen_wdt_release(struct inode *inode, struct file *file) | ||
133 | { | ||
134 | if (expect_release) | ||
135 | xen_wdt_stop(); | ||
136 | else { | ||
137 | printk(KERN_CRIT PFX | ||
138 | "unexpected close, not stopping watchdog!\n"); | ||
139 | xen_wdt_kick(); | ||
140 | } | ||
141 | is_active = false; | ||
142 | expect_release = false; | ||
143 | return 0; | ||
144 | } | ||
145 | |||
146 | static ssize_t xen_wdt_write(struct file *file, const char __user *data, | ||
147 | size_t len, loff_t *ppos) | ||
148 | { | ||
149 | /* See if we got the magic character 'V' and reload the timer */ | ||
150 | if (len) { | ||
151 | if (!nowayout) { | ||
152 | size_t i; | ||
153 | |||
154 | /* in case it was set long ago */ | ||
155 | expect_release = false; | ||
156 | |||
157 | /* scan to see whether or not we got the magic | ||
158 | character */ | ||
159 | for (i = 0; i != len; i++) { | ||
160 | char c; | ||
161 | if (get_user(c, data + i)) | ||
162 | return -EFAULT; | ||
163 | if (c == 'V') | ||
164 | expect_release = true; | ||
165 | } | ||
166 | } | ||
167 | |||
168 | /* someone wrote to us, we should reload the timer */ | ||
169 | xen_wdt_kick(); | ||
170 | } | ||
171 | return len; | ||
172 | } | ||
173 | |||
174 | static long xen_wdt_ioctl(struct file *file, unsigned int cmd, | ||
175 | unsigned long arg) | ||
176 | { | ||
177 | int new_options, retval = -EINVAL; | ||
178 | int new_timeout; | ||
179 | int __user *argp = (void __user *)arg; | ||
180 | static const struct watchdog_info ident = { | ||
181 | .options = WDIOF_SETTIMEOUT | WDIOF_MAGICCLOSE, | ||
182 | .firmware_version = 0, | ||
183 | .identity = DRV_NAME, | ||
184 | }; | ||
185 | |||
186 | switch (cmd) { | ||
187 | case WDIOC_GETSUPPORT: | ||
188 | return copy_to_user(argp, &ident, sizeof(ident)) ? -EFAULT : 0; | ||
189 | |||
190 | case WDIOC_GETSTATUS: | ||
191 | case WDIOC_GETBOOTSTATUS: | ||
192 | return put_user(0, argp); | ||
193 | |||
194 | case WDIOC_SETOPTIONS: | ||
195 | if (get_user(new_options, argp)) | ||
196 | return -EFAULT; | ||
197 | |||
198 | if (new_options & WDIOS_DISABLECARD) | ||
199 | retval = xen_wdt_stop(); | ||
200 | if (new_options & WDIOS_ENABLECARD) { | ||
201 | retval = xen_wdt_start(); | ||
202 | if (retval == -EBUSY) | ||
203 | retval = xen_wdt_kick(); | ||
204 | } | ||
205 | return retval; | ||
206 | |||
207 | case WDIOC_KEEPALIVE: | ||
208 | xen_wdt_kick(); | ||
209 | return 0; | ||
210 | |||
211 | case WDIOC_SETTIMEOUT: | ||
212 | if (get_user(new_timeout, argp)) | ||
213 | return -EFAULT; | ||
214 | if (!new_timeout) | ||
215 | return -EINVAL; | ||
216 | timeout = new_timeout; | ||
217 | xen_wdt_kick(); | ||
218 | /* fall through */ | ||
219 | case WDIOC_GETTIMEOUT: | ||
220 | return put_user(timeout, argp); | ||
221 | |||
222 | case WDIOC_GETTIMELEFT: | ||
223 | retval = wdt_expires - ktime_to_timespec(ktime_get()).tv_sec; | ||
224 | return put_user(retval, argp); | ||
225 | } | ||
226 | |||
227 | return -ENOTTY; | ||
228 | } | ||
229 | |||
230 | static const struct file_operations xen_wdt_fops = { | ||
231 | .owner = THIS_MODULE, | ||
232 | .llseek = no_llseek, | ||
233 | .write = xen_wdt_write, | ||
234 | .unlocked_ioctl = xen_wdt_ioctl, | ||
235 | .open = xen_wdt_open, | ||
236 | .release = xen_wdt_release, | ||
237 | }; | ||
238 | |||
239 | static struct miscdevice xen_wdt_miscdev = { | ||
240 | .minor = WATCHDOG_MINOR, | ||
241 | .name = "watchdog", | ||
242 | .fops = &xen_wdt_fops, | ||
243 | }; | ||
244 | |||
245 | static int __devinit xen_wdt_probe(struct platform_device *dev) | ||
246 | { | ||
247 | struct sched_watchdog wd = { .id = ~0 }; | ||
248 | int ret = HYPERVISOR_sched_op(SCHEDOP_watchdog, &wd); | ||
249 | |||
250 | switch (ret) { | ||
251 | case -EINVAL: | ||
252 | if (!timeout) { | ||
253 | timeout = WATCHDOG_TIMEOUT; | ||
254 | printk(KERN_INFO PFX | ||
255 | "timeout value invalid, using %d\n", timeout); | ||
256 | } | ||
257 | |||
258 | ret = misc_register(&xen_wdt_miscdev); | ||
259 | if (ret) { | ||
260 | printk(KERN_ERR PFX | ||
261 | "cannot register miscdev on minor=%d (%d)\n", | ||
262 | WATCHDOG_MINOR, ret); | ||
263 | break; | ||
264 | } | ||
265 | |||
266 | printk(KERN_INFO PFX | ||
267 | "initialized (timeout=%ds, nowayout=%d)\n", | ||
268 | timeout, nowayout); | ||
269 | break; | ||
270 | |||
271 | case -ENOSYS: | ||
272 | printk(KERN_INFO PFX "not supported\n"); | ||
273 | ret = -ENODEV; | ||
274 | break; | ||
275 | |||
276 | default: | ||
277 | printk(KERN_INFO PFX "bogus return value %d\n", ret); | ||
278 | break; | ||
279 | } | ||
280 | |||
281 | return ret; | ||
282 | } | ||
283 | |||
284 | static int __devexit xen_wdt_remove(struct platform_device *dev) | ||
285 | { | ||
286 | /* Stop the timer before we leave */ | ||
287 | if (!nowayout) | ||
288 | xen_wdt_stop(); | ||
289 | |||
290 | misc_deregister(&xen_wdt_miscdev); | ||
291 | |||
292 | return 0; | ||
293 | } | ||
294 | |||
295 | static void xen_wdt_shutdown(struct platform_device *dev) | ||
296 | { | ||
297 | xen_wdt_stop(); | ||
298 | } | ||
299 | |||
300 | static int xen_wdt_suspend(struct platform_device *dev, pm_message_t state) | ||
301 | { | ||
302 | return xen_wdt_stop(); | ||
303 | } | ||
304 | |||
305 | static int xen_wdt_resume(struct platform_device *dev) | ||
306 | { | ||
307 | return xen_wdt_start(); | ||
308 | } | ||
309 | |||
310 | static struct platform_driver xen_wdt_driver = { | ||
311 | .probe = xen_wdt_probe, | ||
312 | .remove = __devexit_p(xen_wdt_remove), | ||
313 | .shutdown = xen_wdt_shutdown, | ||
314 | .suspend = xen_wdt_suspend, | ||
315 | .resume = xen_wdt_resume, | ||
316 | .driver = { | ||
317 | .owner = THIS_MODULE, | ||
318 | .name = DRV_NAME, | ||
319 | }, | ||
320 | }; | ||
321 | |||
322 | static int __init xen_wdt_init_module(void) | ||
323 | { | ||
324 | int err; | ||
325 | |||
326 | if (!xen_domain()) | ||
327 | return -ENODEV; | ||
328 | |||
329 | printk(KERN_INFO PFX "Xen WatchDog Timer Driver v%s\n", DRV_VERSION); | ||
330 | |||
331 | err = platform_driver_register(&xen_wdt_driver); | ||
332 | if (err) | ||
333 | return err; | ||
334 | |||
335 | platform_device = platform_device_register_simple(DRV_NAME, | ||
336 | -1, NULL, 0); | ||
337 | if (IS_ERR(platform_device)) { | ||
338 | err = PTR_ERR(platform_device); | ||
339 | platform_driver_unregister(&xen_wdt_driver); | ||
340 | } | ||
341 | |||
342 | return err; | ||
343 | } | ||
344 | |||
345 | static void __exit xen_wdt_cleanup_module(void) | ||
346 | { | ||
347 | platform_device_unregister(platform_device); | ||
348 | platform_driver_unregister(&xen_wdt_driver); | ||
349 | printk(KERN_INFO PFX "module unloaded\n"); | ||
350 | } | ||
351 | |||
352 | module_init(xen_wdt_init_module); | ||
353 | module_exit(xen_wdt_cleanup_module); | ||
354 | |||
355 | MODULE_AUTHOR("Jan Beulich <jbeulich@novell.com>"); | ||
356 | MODULE_DESCRIPTION("Xen WatchDog Timer Driver"); | ||
357 | MODULE_VERSION(DRV_VERSION); | ||
358 | MODULE_LICENSE("GPL"); | ||
359 | MODULE_ALIAS_MISCDEV(WATCHDOG_MINOR); | ||
diff --git a/include/xen/interface/sched.h b/include/xen/interface/sched.h index 5fec575a800a..dd55dac340de 100644 --- a/include/xen/interface/sched.h +++ b/include/xen/interface/sched.h | |||
@@ -65,6 +65,39 @@ struct sched_poll { | |||
65 | DEFINE_GUEST_HANDLE_STRUCT(sched_poll); | 65 | DEFINE_GUEST_HANDLE_STRUCT(sched_poll); |
66 | 66 | ||
67 | /* | 67 | /* |
68 | * Declare a shutdown for another domain. The main use of this function is | ||
69 | * in interpreting shutdown requests and reasons for fully-virtualized | ||
70 | * domains. A para-virtualized domain may use SCHEDOP_shutdown directly. | ||
71 | * @arg == pointer to sched_remote_shutdown structure. | ||
72 | */ | ||
73 | #define SCHEDOP_remote_shutdown 4 | ||
74 | struct sched_remote_shutdown { | ||
75 | domid_t domain_id; /* Remote domain ID */ | ||
76 | unsigned int reason; /* SHUTDOWN_xxx reason */ | ||
77 | }; | ||
78 | |||
79 | /* | ||
80 | * Latch a shutdown code, so that when the domain later shuts down it | ||
81 | * reports this code to the control tools. | ||
82 | * @arg == as for SCHEDOP_shutdown. | ||
83 | */ | ||
84 | #define SCHEDOP_shutdown_code 5 | ||
85 | |||
86 | /* | ||
87 | * Setup, poke and destroy a domain watchdog timer. | ||
88 | * @arg == pointer to sched_watchdog structure. | ||
89 | * With id == 0, setup a domain watchdog timer to cause domain shutdown | ||
90 | * after timeout, returns watchdog id. | ||
91 | * With id != 0 and timeout == 0, destroy domain watchdog timer. | ||
92 | * With id != 0 and timeout != 0, poke watchdog timer and set new timeout. | ||
93 | */ | ||
94 | #define SCHEDOP_watchdog 6 | ||
95 | struct sched_watchdog { | ||
96 | uint32_t id; /* watchdog ID */ | ||
97 | uint32_t timeout; /* timeout */ | ||
98 | }; | ||
99 | |||
100 | /* | ||
68 | * Reason codes for SCHEDOP_shutdown. These may be interpreted by control | 101 | * Reason codes for SCHEDOP_shutdown. These may be interpreted by control |
69 | * software to determine the appropriate action. For the most part, Xen does | 102 | * software to determine the appropriate action. For the most part, Xen does |
70 | * not care about the shutdown code. | 103 | * not care about the shutdown code. |
@@ -73,5 +106,6 @@ DEFINE_GUEST_HANDLE_STRUCT(sched_poll); | |||
73 | #define SHUTDOWN_reboot 1 /* Clean up, kill, and then restart. */ | 106 | #define SHUTDOWN_reboot 1 /* Clean up, kill, and then restart. */ |
74 | #define SHUTDOWN_suspend 2 /* Clean up, save suspend info, kill. */ | 107 | #define SHUTDOWN_suspend 2 /* Clean up, save suspend info, kill. */ |
75 | #define SHUTDOWN_crash 3 /* Tell controller we've crashed. */ | 108 | #define SHUTDOWN_crash 3 /* Tell controller we've crashed. */ |
109 | #define SHUTDOWN_watchdog 4 /* Restart because watchdog time expired. */ | ||
76 | 110 | ||
77 | #endif /* __XEN_PUBLIC_SCHED_H__ */ | 111 | #endif /* __XEN_PUBLIC_SCHED_H__ */ |