Commit | Line | Data |
---|---|---|
4bac07c9 JF |
1 | /****************************************************************************** |
2 | * Talks to Xen Store to figure out what devices we have. | |
3 | * | |
4 | * Copyright (C) 2005 Rusty Russell, IBM Corporation | |
5 | * Copyright (C) 2005 Mike Wray, Hewlett-Packard | |
6 | * Copyright (C) 2005, 2006 XenSource Ltd | |
7 | * | |
8 | * This program is free software; you can redistribute it and/or | |
9 | * modify it under the terms of the GNU General Public License version 2 | |
10 | * as published by the Free Software Foundation; or, when distributed | |
11 | * separately from the Linux kernel or incorporated into other | |
12 | * software packages, subject to the following license: | |
13 | * | |
14 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
15 | * of this source file (the "Software"), to deal in the Software without | |
16 | * restriction, including without limitation the rights to use, copy, modify, | |
17 | * merge, publish, distribute, sublicense, and/or sell copies of the Software, | |
18 | * and to permit persons to whom the Software is furnished to do so, subject to | |
19 | * the following conditions: | |
20 | * | |
21 | * The above copyright notice and this permission notice shall be included in | |
22 | * all copies or substantial portions of the Software. | |
23 | * | |
24 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
25 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
26 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
27 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
28 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
29 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | |
30 | * IN THE SOFTWARE. | |
31 | */ | |
32 | ||
283c0972 | 33 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
64b3eaf3 | 34 | #define dev_fmt pr_fmt |
283c0972 | 35 | |
4bac07c9 JF |
36 | #define DPRINTK(fmt, args...) \ |
37 | pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \ | |
38 | __func__, __LINE__, ##args) | |
39 | ||
40 | #include <linux/kernel.h> | |
41 | #include <linux/err.h> | |
42 | #include <linux/string.h> | |
43 | #include <linux/ctype.h> | |
44 | #include <linux/fcntl.h> | |
45 | #include <linux/mm.h> | |
1107ba88 | 46 | #include <linux/proc_fs.h> |
4bac07c9 JF |
47 | #include <linux/notifier.h> |
48 | #include <linux/kthread.h> | |
49 | #include <linux/mutex.h> | |
50 | #include <linux/io.h> | |
5a0e3ad6 | 51 | #include <linux/slab.h> |
72ee5112 | 52 | #include <linux/module.h> |
4bac07c9 JF |
53 | |
54 | #include <asm/page.h> | |
4bac07c9 | 55 | #include <asm/xen/hypervisor.h> |
1ccbf534 JF |
56 | |
57 | #include <xen/xen.h> | |
4bac07c9 JF |
58 | #include <xen/xenbus.h> |
59 | #include <xen/events.h> | |
16f1cf3b | 60 | #include <xen/xen-ops.h> |
4bac07c9 JF |
61 | #include <xen/page.h> |
62 | ||
bee6ab53 SY |
63 | #include <xen/hvm.h> |
64 | ||
332f791d | 65 | #include "xenbus.h" |
4bac07c9 | 66 | |
1107ba88 | 67 | |
a3607581 | 68 | static int xs_init_irq = -1; |
4bac07c9 | 69 | int xen_store_evtchn; |
8e3e9991 | 70 | EXPORT_SYMBOL_GPL(xen_store_evtchn); |
1107ba88 | 71 | |
4bac07c9 | 72 | struct xenstore_domain_interface *xen_store_interface; |
8e3e9991 JF |
73 | EXPORT_SYMBOL_GPL(xen_store_interface); |
74 | ||
a3607581 HW |
75 | #define XS_INTERFACE_READY \ |
76 | ((xen_store_interface != NULL) && \ | |
77 | (xen_store_interface->connection == XENSTORE_CONNECTED)) | |
78 | ||
33c1174b AC |
79 | enum xenstore_init xen_store_domain_type; |
80 | EXPORT_SYMBOL_GPL(xen_store_domain_type); | |
81 | ||
5f51042f | 82 | static unsigned long xen_store_gfn; |
4bac07c9 JF |
83 | |
84 | static BLOCKING_NOTIFIER_HEAD(xenstore_chain); | |
85 | ||
4bac07c9 JF |
86 | /* If something in array of ids matches this device, return it. */ |
87 | static const struct xenbus_device_id * | |
88 | match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev) | |
89 | { | |
90 | for (; *arr->devicetype != '\0'; arr++) { | |
91 | if (!strcmp(arr->devicetype, dev->devicetype)) | |
92 | return arr; | |
93 | } | |
94 | return NULL; | |
95 | } | |
96 | ||
d69d8048 | 97 | int xenbus_match(struct device *_dev, const struct device_driver *_drv) |
4bac07c9 | 98 | { |
d69d8048 | 99 | const struct xenbus_driver *drv = to_xenbus_driver(_drv); |
4bac07c9 JF |
100 | |
101 | if (!drv->ids) | |
102 | return 0; | |
103 | ||
104 | return match_device(drv->ids, to_xenbus_device(_dev)) != NULL; | |
105 | } | |
2de06cc1 IC |
106 | EXPORT_SYMBOL_GPL(xenbus_match); |
107 | ||
4bac07c9 | 108 | |
4bac07c9 JF |
109 | static void free_otherend_details(struct xenbus_device *dev) |
110 | { | |
111 | kfree(dev->otherend); | |
112 | dev->otherend = NULL; | |
113 | } | |
114 | ||
115 | ||
116 | static void free_otherend_watch(struct xenbus_device *dev) | |
117 | { | |
118 | if (dev->otherend_watch.node) { | |
119 | unregister_xenbus_watch(&dev->otherend_watch); | |
120 | kfree(dev->otherend_watch.node); | |
121 | dev->otherend_watch.node = NULL; | |
122 | } | |
123 | } | |
124 | ||
125 | ||
2de06cc1 IC |
126 | static int talk_to_otherend(struct xenbus_device *dev) |
127 | { | |
128 | struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver); | |
129 | ||
130 | free_otherend_watch(dev); | |
131 | free_otherend_details(dev); | |
132 | ||
133 | return drv->read_otherend_details(dev); | |
134 | } | |
135 | ||
136 | ||
137 | ||
138 | static int watch_otherend(struct xenbus_device *dev) | |
139 | { | |
6bac7f9f IC |
140 | struct xen_bus_type *bus = |
141 | container_of(dev->dev.bus, struct xen_bus_type, bus); | |
2de06cc1 | 142 | |
6bac7f9f | 143 | return xenbus_watch_pathfmt(dev, &dev->otherend_watch, |
be987200 SP |
144 | bus->otherend_will_handle, |
145 | bus->otherend_changed, | |
2de06cc1 IC |
146 | "%s/%s", dev->otherend, "state"); |
147 | } | |
148 | ||
149 | ||
150 | int xenbus_read_otherend_details(struct xenbus_device *xendev, | |
4bac07c9 JF |
151 | char *id_node, char *path_node) |
152 | { | |
153 | int err = xenbus_gather(XBT_NIL, xendev->nodename, | |
154 | id_node, "%i", &xendev->otherend_id, | |
155 | path_node, NULL, &xendev->otherend, | |
156 | NULL); | |
157 | if (err) { | |
158 | xenbus_dev_fatal(xendev, err, | |
159 | "reading other end details from %s", | |
160 | xendev->nodename); | |
161 | return err; | |
162 | } | |
163 | if (strlen(xendev->otherend) == 0 || | |
164 | !xenbus_exists(XBT_NIL, xendev->otherend, "")) { | |
165 | xenbus_dev_fatal(xendev, -ENOENT, | |
166 | "unable to read other end from %s. " | |
167 | "missing or inaccessible.", | |
168 | xendev->nodename); | |
169 | free_otherend_details(xendev); | |
170 | return -ENOENT; | |
171 | } | |
172 | ||
173 | return 0; | |
174 | } | |
2de06cc1 | 175 | EXPORT_SYMBOL_GPL(xenbus_read_otherend_details); |
4bac07c9 | 176 | |
2de06cc1 | 177 | void xenbus_otherend_changed(struct xenbus_watch *watch, |
5584ea25 | 178 | const char *path, const char *token, |
2de06cc1 | 179 | int ignore_on_shutdown) |
4bac07c9 JF |
180 | { |
181 | struct xenbus_device *dev = | |
182 | container_of(watch, struct xenbus_device, otherend_watch); | |
183 | struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver); | |
184 | enum xenbus_state state; | |
185 | ||
186 | /* Protect us against watches firing on old details when the otherend | |
187 | details change, say immediately after a resume. */ | |
188 | if (!dev->otherend || | |
5584ea25 JG |
189 | strncmp(dev->otherend, path, strlen(dev->otherend))) { |
190 | dev_dbg(&dev->dev, "Ignoring watch at %s\n", path); | |
4bac07c9 JF |
191 | return; |
192 | } | |
193 | ||
194 | state = xenbus_read_driver_state(dev->otherend); | |
195 | ||
898eb71c | 196 | dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n", |
5584ea25 | 197 | state, xenbus_strstate(state), dev->otherend_watch.node, path); |
4bac07c9 JF |
198 | |
199 | /* | |
200 | * Ignore xenbus transitions during shutdown. This prevents us doing | |
201 | * work that can fail e.g., when the rootfs is gone. | |
202 | */ | |
203 | if (system_state > SYSTEM_RUNNING) { | |
2de06cc1 | 204 | if (ignore_on_shutdown && (state == XenbusStateClosing)) |
4bac07c9 JF |
205 | xenbus_frontend_closed(dev); |
206 | return; | |
207 | } | |
208 | ||
209 | if (drv->otherend_changed) | |
210 | drv->otherend_changed(dev, state); | |
211 | } | |
2de06cc1 | 212 | EXPORT_SYMBOL_GPL(xenbus_otherend_changed); |
4bac07c9 | 213 | |
06f45fe9 | 214 | #define XENBUS_SHOW_STAT(name) \ |
20600617 | 215 | static ssize_t name##_show(struct device *_dev, \ |
06f45fe9 JG |
216 | struct device_attribute *attr, \ |
217 | char *buf) \ | |
218 | { \ | |
219 | struct xenbus_device *dev = to_xenbus_device(_dev); \ | |
220 | \ | |
221 | return sprintf(buf, "%d\n", atomic_read(&dev->name)); \ | |
222 | } \ | |
20600617 | 223 | static DEVICE_ATTR_RO(name) |
06f45fe9 JG |
224 | |
225 | XENBUS_SHOW_STAT(event_channels); | |
226 | XENBUS_SHOW_STAT(events); | |
227 | XENBUS_SHOW_STAT(spurious_events); | |
228 | XENBUS_SHOW_STAT(jiffies_eoi_delayed); | |
229 | ||
20600617 | 230 | static ssize_t spurious_threshold_show(struct device *_dev, |
06f45fe9 JG |
231 | struct device_attribute *attr, |
232 | char *buf) | |
233 | { | |
234 | struct xenbus_device *dev = to_xenbus_device(_dev); | |
235 | ||
236 | return sprintf(buf, "%d\n", dev->spurious_threshold); | |
237 | } | |
238 | ||
20600617 Y |
239 | static ssize_t spurious_threshold_store(struct device *_dev, |
240 | struct device_attribute *attr, | |
241 | const char *buf, size_t count) | |
06f45fe9 JG |
242 | { |
243 | struct xenbus_device *dev = to_xenbus_device(_dev); | |
244 | unsigned int val; | |
245 | ssize_t ret; | |
246 | ||
247 | ret = kstrtouint(buf, 0, &val); | |
248 | if (ret) | |
249 | return ret; | |
250 | ||
251 | dev->spurious_threshold = val; | |
252 | ||
253 | return count; | |
254 | } | |
255 | ||
20600617 | 256 | static DEVICE_ATTR_RW(spurious_threshold); |
06f45fe9 JG |
257 | |
258 | static struct attribute *xenbus_attrs[] = { | |
259 | &dev_attr_event_channels.attr, | |
260 | &dev_attr_events.attr, | |
261 | &dev_attr_spurious_events.attr, | |
262 | &dev_attr_jiffies_eoi_delayed.attr, | |
263 | &dev_attr_spurious_threshold.attr, | |
264 | NULL | |
265 | }; | |
266 | ||
267 | static const struct attribute_group xenbus_group = { | |
268 | .name = "xenbus", | |
269 | .attrs = xenbus_attrs, | |
270 | }; | |
271 | ||
4bac07c9 JF |
272 | int xenbus_dev_probe(struct device *_dev) |
273 | { | |
274 | struct xenbus_device *dev = to_xenbus_device(_dev); | |
275 | struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); | |
276 | const struct xenbus_device_id *id; | |
277 | int err; | |
278 | ||
279 | DPRINTK("%s", dev->nodename); | |
280 | ||
281 | if (!drv->probe) { | |
282 | err = -ENODEV; | |
283 | goto fail; | |
284 | } | |
285 | ||
286 | id = match_device(drv->ids, dev); | |
287 | if (!id) { | |
288 | err = -ENODEV; | |
289 | goto fail; | |
290 | } | |
291 | ||
292 | err = talk_to_otherend(dev); | |
293 | if (err) { | |
294 | dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n", | |
295 | dev->nodename); | |
296 | return err; | |
297 | } | |
298 | ||
196748a2 PD |
299 | if (!try_module_get(drv->driver.owner)) { |
300 | dev_warn(&dev->dev, "failed to acquire module reference on '%s'\n", | |
301 | drv->driver.name); | |
302 | err = -ESRCH; | |
303 | goto fail; | |
304 | } | |
305 | ||
2f69a110 | 306 | down(&dev->reclaim_sem); |
4bac07c9 | 307 | err = drv->probe(dev, id); |
2f69a110 | 308 | up(&dev->reclaim_sem); |
4bac07c9 | 309 | if (err) |
196748a2 | 310 | goto fail_put; |
4bac07c9 JF |
311 | |
312 | err = watch_otherend(dev); | |
313 | if (err) { | |
314 | dev_warn(&dev->dev, "watch_otherend on %s failed.\n", | |
315 | dev->nodename); | |
316 | return err; | |
317 | } | |
318 | ||
06f45fe9 JG |
319 | dev->spurious_threshold = 1; |
320 | if (sysfs_create_group(&dev->dev.kobj, &xenbus_group)) | |
321 | dev_warn(&dev->dev, "sysfs_create_group on %s failed.\n", | |
322 | dev->nodename); | |
323 | ||
4bac07c9 | 324 | return 0; |
196748a2 PD |
325 | fail_put: |
326 | module_put(drv->driver.owner); | |
4bac07c9 JF |
327 | fail: |
328 | xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename); | |
7432e4bd | 329 | return err; |
4bac07c9 | 330 | } |
2de06cc1 | 331 | EXPORT_SYMBOL_GPL(xenbus_dev_probe); |
4bac07c9 | 332 | |
fc7a6209 | 333 | void xenbus_dev_remove(struct device *_dev) |
4bac07c9 JF |
334 | { |
335 | struct xenbus_device *dev = to_xenbus_device(_dev); | |
336 | struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); | |
337 | ||
338 | DPRINTK("%s", dev->nodename); | |
339 | ||
06f45fe9 JG |
340 | sysfs_remove_group(&dev->dev.kobj, &xenbus_group); |
341 | ||
4bac07c9 | 342 | free_otherend_watch(dev); |
4bac07c9 | 343 | |
060eabe8 | 344 | if (drv->remove) { |
2f69a110 | 345 | down(&dev->reclaim_sem); |
4bac07c9 | 346 | drv->remove(dev); |
2f69a110 | 347 | up(&dev->reclaim_sem); |
060eabe8 | 348 | } |
4bac07c9 | 349 | |
196748a2 PD |
350 | module_put(drv->driver.owner); |
351 | ||
bd0d5aa4 JB |
352 | free_otherend_details(dev); |
353 | ||
672b7763 PD |
354 | /* |
355 | * If the toolstack has forced the device state to closing then set | |
356 | * the state to closed now to allow it to be cleaned up. | |
357 | * Similarly, if the driver does not support re-bind, set the | |
358 | * closed. | |
359 | */ | |
360 | if (!drv->allow_rebind || | |
361 | xenbus_read_driver_state(dev->nodename) == XenbusStateClosing) | |
362 | xenbus_switch_state(dev, XenbusStateClosed); | |
4bac07c9 | 363 | } |
2de06cc1 | 364 | EXPORT_SYMBOL_GPL(xenbus_dev_remove); |
4bac07c9 | 365 | |
4bac07c9 | 366 | int xenbus_register_driver_common(struct xenbus_driver *drv, |
95afae48 DV |
367 | struct xen_bus_type *bus, |
368 | struct module *owner, const char *mod_name) | |
4bac07c9 | 369 | { |
95afae48 | 370 | drv->driver.name = drv->name ? drv->name : drv->ids[0].devicetype; |
4bac07c9 | 371 | drv->driver.bus = &bus->bus; |
95afae48 DV |
372 | drv->driver.owner = owner; |
373 | drv->driver.mod_name = mod_name; | |
4bac07c9 JF |
374 | |
375 | return driver_register(&drv->driver); | |
376 | } | |
2de06cc1 | 377 | EXPORT_SYMBOL_GPL(xenbus_register_driver_common); |
4bac07c9 JF |
378 | |
379 | void xenbus_unregister_driver(struct xenbus_driver *drv) | |
380 | { | |
381 | driver_unregister(&drv->driver); | |
382 | } | |
383 | EXPORT_SYMBOL_GPL(xenbus_unregister_driver); | |
384 | ||
6913200a | 385 | struct xb_find_info { |
4bac07c9 JF |
386 | struct xenbus_device *dev; |
387 | const char *nodename; | |
388 | }; | |
389 | ||
390 | static int cmp_dev(struct device *dev, void *data) | |
391 | { | |
392 | struct xenbus_device *xendev = to_xenbus_device(dev); | |
393 | struct xb_find_info *info = data; | |
394 | ||
395 | if (!strcmp(xendev->nodename, info->nodename)) { | |
396 | info->dev = xendev; | |
397 | get_device(dev); | |
398 | return 1; | |
399 | } | |
400 | return 0; | |
401 | } | |
402 | ||
b8b0f559 KRW |
403 | static struct xenbus_device *xenbus_device_find(const char *nodename, |
404 | struct bus_type *bus) | |
4bac07c9 JF |
405 | { |
406 | struct xb_find_info info = { .dev = NULL, .nodename = nodename }; | |
407 | ||
408 | bus_for_each_dev(bus, NULL, &info, cmp_dev); | |
409 | return info.dev; | |
410 | } | |
411 | ||
412 | static int cleanup_dev(struct device *dev, void *data) | |
413 | { | |
414 | struct xenbus_device *xendev = to_xenbus_device(dev); | |
415 | struct xb_find_info *info = data; | |
416 | int len = strlen(info->nodename); | |
417 | ||
418 | DPRINTK("%s", info->nodename); | |
419 | ||
420 | /* Match the info->nodename path, or any subdirectory of that path. */ | |
421 | if (strncmp(xendev->nodename, info->nodename, len)) | |
422 | return 0; | |
423 | ||
424 | /* If the node name is longer, ensure it really is a subdirectory. */ | |
425 | if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/')) | |
426 | return 0; | |
427 | ||
428 | info->dev = xendev; | |
429 | get_device(dev); | |
430 | return 1; | |
431 | } | |
432 | ||
433 | static void xenbus_cleanup_devices(const char *path, struct bus_type *bus) | |
434 | { | |
435 | struct xb_find_info info = { .nodename = path }; | |
436 | ||
437 | do { | |
438 | info.dev = NULL; | |
439 | bus_for_each_dev(bus, NULL, &info, cleanup_dev); | |
440 | if (info.dev) { | |
441 | device_unregister(&info.dev->dev); | |
442 | put_device(&info.dev->dev); | |
443 | } | |
444 | } while (info.dev); | |
445 | } | |
446 | ||
447 | static void xenbus_dev_release(struct device *dev) | |
448 | { | |
449 | if (dev) | |
450 | kfree(to_xenbus_device(dev)); | |
451 | } | |
452 | ||
cc85e933 BB |
453 | static ssize_t nodename_show(struct device *dev, |
454 | struct device_attribute *attr, char *buf) | |
4bac07c9 JF |
455 | { |
456 | return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename); | |
457 | } | |
85dd9268 | 458 | static DEVICE_ATTR_RO(nodename); |
4bac07c9 | 459 | |
cc85e933 BB |
460 | static ssize_t devtype_show(struct device *dev, |
461 | struct device_attribute *attr, char *buf) | |
4bac07c9 JF |
462 | { |
463 | return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype); | |
464 | } | |
85dd9268 | 465 | static DEVICE_ATTR_RO(devtype); |
4bac07c9 | 466 | |
cc85e933 BB |
467 | static ssize_t modalias_show(struct device *dev, |
468 | struct device_attribute *attr, char *buf) | |
d2f0c52b | 469 | { |
149bb2fa BB |
470 | return sprintf(buf, "%s:%s\n", dev->bus->name, |
471 | to_xenbus_device(dev)->devicetype); | |
d2f0c52b | 472 | } |
85dd9268 | 473 | static DEVICE_ATTR_RO(modalias); |
cc85e933 | 474 | |
076e2ced JJ |
475 | static ssize_t state_show(struct device *dev, |
476 | struct device_attribute *attr, char *buf) | |
477 | { | |
478 | return sprintf(buf, "%s\n", | |
479 | xenbus_strstate(to_xenbus_device(dev)->state)); | |
480 | } | |
481 | static DEVICE_ATTR_RO(state); | |
482 | ||
85dd9268 GKH |
483 | static struct attribute *xenbus_dev_attrs[] = { |
484 | &dev_attr_nodename.attr, | |
485 | &dev_attr_devtype.attr, | |
486 | &dev_attr_modalias.attr, | |
076e2ced | 487 | &dev_attr_state.attr, |
85dd9268 | 488 | NULL, |
cc85e933 | 489 | }; |
85dd9268 GKH |
490 | |
491 | static const struct attribute_group xenbus_dev_group = { | |
492 | .attrs = xenbus_dev_attrs, | |
493 | }; | |
494 | ||
495 | const struct attribute_group *xenbus_dev_groups[] = { | |
496 | &xenbus_dev_group, | |
497 | NULL, | |
498 | }; | |
499 | EXPORT_SYMBOL_GPL(xenbus_dev_groups); | |
4bac07c9 JF |
500 | |
501 | int xenbus_probe_node(struct xen_bus_type *bus, | |
502 | const char *type, | |
503 | const char *nodename) | |
504 | { | |
2a678cc5 | 505 | char devname[XEN_BUS_ID_SIZE]; |
4bac07c9 JF |
506 | int err; |
507 | struct xenbus_device *xendev; | |
508 | size_t stringlen; | |
509 | char *tmpstring; | |
510 | ||
511 | enum xenbus_state state = xenbus_read_driver_state(nodename); | |
512 | ||
513 | if (state != XenbusStateInitialising) { | |
514 | /* Device is not new, so ignore it. This can happen if a | |
515 | device is going away after switching to Closed. */ | |
516 | return 0; | |
517 | } | |
518 | ||
519 | stringlen = strlen(nodename) + 1 + strlen(type) + 1; | |
520 | xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL); | |
521 | if (!xendev) | |
522 | return -ENOMEM; | |
523 | ||
524 | xendev->state = XenbusStateInitialising; | |
525 | ||
526 | /* Copy the strings into the extra space. */ | |
527 | ||
528 | tmpstring = (char *)(xendev + 1); | |
529 | strcpy(tmpstring, nodename); | |
530 | xendev->nodename = tmpstring; | |
531 | ||
532 | tmpstring += strlen(tmpstring) + 1; | |
533 | strcpy(tmpstring, type); | |
534 | xendev->devicetype = tmpstring; | |
535 | init_completion(&xendev->down); | |
536 | ||
537 | xendev->dev.bus = &bus->bus; | |
538 | xendev->dev.release = xenbus_dev_release; | |
539 | ||
2a678cc5 | 540 | err = bus->get_bus_id(devname, xendev->nodename); |
4bac07c9 JF |
541 | if (err) |
542 | goto fail; | |
543 | ||
02aa2a37 | 544 | dev_set_name(&xendev->dev, "%s", devname); |
2f69a110 | 545 | sema_init(&xendev->reclaim_sem, 1); |
2a678cc5 | 546 | |
4bac07c9 JF |
547 | /* Register with generic device framework. */ |
548 | err = device_register(&xendev->dev); | |
351b2bcc AY |
549 | if (err) { |
550 | put_device(&xendev->dev); | |
551 | xendev = NULL; | |
4bac07c9 | 552 | goto fail; |
351b2bcc | 553 | } |
4bac07c9 | 554 | |
4bac07c9 | 555 | return 0; |
4bac07c9 JF |
556 | fail: |
557 | kfree(xendev); | |
558 | return err; | |
559 | } | |
2de06cc1 | 560 | EXPORT_SYMBOL_GPL(xenbus_probe_node); |
4bac07c9 JF |
561 | |
562 | static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type) | |
563 | { | |
564 | int err = 0; | |
565 | char **dir; | |
566 | unsigned int dir_n = 0; | |
567 | int i; | |
568 | ||
569 | dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n); | |
a39bda27 | 570 | if (IS_ERR(dir)) |
4bac07c9 JF |
571 | return PTR_ERR(dir); |
572 | ||
573 | for (i = 0; i < dir_n; i++) { | |
2de06cc1 | 574 | err = bus->probe(bus, type, dir[i]); |
a39bda27 | 575 | if (err) |
4bac07c9 JF |
576 | break; |
577 | } | |
a39bda27 | 578 | |
4bac07c9 JF |
579 | kfree(dir); |
580 | return err; | |
581 | } | |
582 | ||
583 | int xenbus_probe_devices(struct xen_bus_type *bus) | |
584 | { | |
585 | int err = 0; | |
586 | char **dir; | |
587 | unsigned int i, dir_n; | |
588 | ||
589 | dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n); | |
a39bda27 | 590 | if (IS_ERR(dir)) |
4bac07c9 JF |
591 | return PTR_ERR(dir); |
592 | ||
593 | for (i = 0; i < dir_n; i++) { | |
594 | err = xenbus_probe_device_type(bus, dir[i]); | |
a39bda27 | 595 | if (err) |
4bac07c9 JF |
596 | break; |
597 | } | |
a39bda27 | 598 | |
4bac07c9 JF |
599 | kfree(dir); |
600 | return err; | |
601 | } | |
2de06cc1 | 602 | EXPORT_SYMBOL_GPL(xenbus_probe_devices); |
4bac07c9 JF |
603 | |
604 | static unsigned int char_count(const char *str, char c) | |
605 | { | |
606 | unsigned int i, ret = 0; | |
607 | ||
608 | for (i = 0; str[i]; i++) | |
609 | if (str[i] == c) | |
610 | ret++; | |
611 | return ret; | |
612 | } | |
613 | ||
614 | static int strsep_len(const char *str, char c, unsigned int len) | |
615 | { | |
616 | unsigned int i; | |
617 | ||
618 | for (i = 0; str[i]; i++) | |
619 | if (str[i] == c) { | |
620 | if (len == 0) | |
621 | return i; | |
622 | len--; | |
623 | } | |
624 | return (len == 0) ? i : -ERANGE; | |
625 | } | |
626 | ||
627 | void xenbus_dev_changed(const char *node, struct xen_bus_type *bus) | |
628 | { | |
629 | int exists, rootlen; | |
630 | struct xenbus_device *dev; | |
2a678cc5 | 631 | char type[XEN_BUS_ID_SIZE]; |
4bac07c9 JF |
632 | const char *p, *root; |
633 | ||
634 | if (char_count(node, '/') < 2) | |
635 | return; | |
636 | ||
637 | exists = xenbus_exists(XBT_NIL, node, ""); | |
638 | if (!exists) { | |
639 | xenbus_cleanup_devices(node, &bus->bus); | |
640 | return; | |
641 | } | |
642 | ||
643 | /* backend/<type>/... or device/<type>/... */ | |
644 | p = strchr(node, '/') + 1; | |
2a678cc5 KS |
645 | snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p); |
646 | type[XEN_BUS_ID_SIZE-1] = '\0'; | |
4bac07c9 JF |
647 | |
648 | rootlen = strsep_len(node, '/', bus->levels); | |
649 | if (rootlen < 0) | |
650 | return; | |
651 | root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node); | |
652 | if (!root) | |
653 | return; | |
654 | ||
655 | dev = xenbus_device_find(root, &bus->bus); | |
656 | if (!dev) | |
657 | xenbus_probe_node(bus, type, root); | |
658 | else | |
659 | put_device(&dev->dev); | |
660 | ||
661 | kfree(root); | |
662 | } | |
c6a960ce | 663 | EXPORT_SYMBOL_GPL(xenbus_dev_changed); |
4bac07c9 | 664 | |
c7853aea | 665 | int xenbus_dev_suspend(struct device *dev) |
4bac07c9 JF |
666 | { |
667 | int err = 0; | |
668 | struct xenbus_driver *drv; | |
6bac7f9f IC |
669 | struct xenbus_device *xdev |
670 | = container_of(dev, struct xenbus_device, dev); | |
4bac07c9 | 671 | |
2de06cc1 | 672 | DPRINTK("%s", xdev->nodename); |
4bac07c9 JF |
673 | |
674 | if (dev->driver == NULL) | |
675 | return 0; | |
676 | drv = to_xenbus_driver(dev->driver); | |
4bac07c9 | 677 | if (drv->suspend) |
c7853aea | 678 | err = drv->suspend(xdev); |
4bac07c9 | 679 | if (err) |
64b3eaf3 | 680 | dev_warn(dev, "suspend failed: %i\n", err); |
4bac07c9 JF |
681 | return 0; |
682 | } | |
2de06cc1 | 683 | EXPORT_SYMBOL_GPL(xenbus_dev_suspend); |
4bac07c9 | 684 | |
2de06cc1 | 685 | int xenbus_dev_resume(struct device *dev) |
4bac07c9 JF |
686 | { |
687 | int err; | |
688 | struct xenbus_driver *drv; | |
6bac7f9f IC |
689 | struct xenbus_device *xdev |
690 | = container_of(dev, struct xenbus_device, dev); | |
4bac07c9 | 691 | |
2de06cc1 | 692 | DPRINTK("%s", xdev->nodename); |
4bac07c9 JF |
693 | |
694 | if (dev->driver == NULL) | |
695 | return 0; | |
4bac07c9 | 696 | drv = to_xenbus_driver(dev->driver); |
4bac07c9 JF |
697 | err = talk_to_otherend(xdev); |
698 | if (err) { | |
64b3eaf3 | 699 | dev_warn(dev, "resume (talk_to_otherend) failed: %i\n", err); |
4bac07c9 JF |
700 | return err; |
701 | } | |
702 | ||
703 | xdev->state = XenbusStateInitialising; | |
704 | ||
705 | if (drv->resume) { | |
706 | err = drv->resume(xdev); | |
707 | if (err) { | |
64b3eaf3 | 708 | dev_warn(dev, "resume failed: %i\n", err); |
4bac07c9 JF |
709 | return err; |
710 | } | |
711 | } | |
712 | ||
713 | err = watch_otherend(xdev); | |
714 | if (err) { | |
64b3eaf3 | 715 | dev_warn(dev, "resume (watch_otherend) failed: %d\n", err); |
4bac07c9 JF |
716 | return err; |
717 | } | |
718 | ||
719 | return 0; | |
720 | } | |
2de06cc1 | 721 | EXPORT_SYMBOL_GPL(xenbus_dev_resume); |
4bac07c9 | 722 | |
c7853aea KS |
723 | int xenbus_dev_cancel(struct device *dev) |
724 | { | |
725 | /* Do nothing */ | |
726 | DPRINTK("cancel"); | |
727 | return 0; | |
728 | } | |
729 | EXPORT_SYMBOL_GPL(xenbus_dev_cancel); | |
730 | ||
4bac07c9 | 731 | /* A flag to determine if xenstored is 'ready' (i.e. has started) */ |
6913200a | 732 | int xenstored_ready; |
4bac07c9 JF |
733 | |
734 | ||
735 | int register_xenstore_notifier(struct notifier_block *nb) | |
736 | { | |
737 | int ret = 0; | |
738 | ||
a947f0f8 SS |
739 | if (xenstored_ready > 0) |
740 | ret = nb->notifier_call(nb, 0, NULL); | |
741 | else | |
742 | blocking_notifier_chain_register(&xenstore_chain, nb); | |
4bac07c9 JF |
743 | |
744 | return ret; | |
745 | } | |
746 | EXPORT_SYMBOL_GPL(register_xenstore_notifier); | |
747 | ||
748 | void unregister_xenstore_notifier(struct notifier_block *nb) | |
749 | { | |
750 | blocking_notifier_chain_unregister(&xenstore_chain, nb); | |
751 | } | |
752 | EXPORT_SYMBOL_GPL(unregister_xenstore_notifier); | |
753 | ||
c4295ab0 | 754 | static void xenbus_probe(void) |
4bac07c9 | 755 | { |
a947f0f8 | 756 | xenstored_ready = 1; |
4bac07c9 | 757 | |
a3607581 | 758 | if (!xen_store_interface) |
41925b10 JG |
759 | xen_store_interface = memremap(xen_store_gfn << XEN_PAGE_SHIFT, |
760 | XEN_PAGE_SIZE, MEMREMAP_WB); | |
a3607581 HW |
761 | /* |
762 | * Now it is safe to free the IRQ used for xenstore late | |
763 | * initialization. No need to unbind: it is about to be | |
764 | * bound again from xb_init_comms. Note that calling | |
765 | * unbind_from_irqhandler now would result in xen_evtchn_close() | |
766 | * being called and the event channel not being enabled again | |
767 | * afterwards, resulting in missed event notifications. | |
768 | */ | |
769 | if (xs_init_irq >= 0) | |
5b335394 | 770 | free_irq(xs_init_irq, &xb_waitq); |
5b335394 | 771 | |
3499ba81 DW |
772 | /* |
773 | * In the HVM case, xenbus_init() deferred its call to | |
774 | * xs_init() in case callbacks were not operational yet. | |
775 | * So do it now. | |
776 | */ | |
777 | if (xen_store_domain_type == XS_HVM) | |
778 | xs_init(); | |
779 | ||
4bac07c9 JF |
780 | /* Notify others that xenstore is up */ |
781 | blocking_notifier_call_chain(&xenstore_chain, 0, NULL); | |
782 | } | |
783 | ||
3499ba81 DW |
784 | /* |
785 | * Returns true when XenStore init must be deferred in order to | |
786 | * allow the PCI platform device to be initialised, before we | |
787 | * can actually have event channel interrupts working. | |
788 | */ | |
789 | static bool xs_hvm_defer_init_for_callback(void) | |
183d03cc | 790 | { |
3499ba81 DW |
791 | #ifdef CONFIG_XEN_PVHVM |
792 | return xen_store_domain_type == XS_HVM && | |
793 | !xen_have_vector_callback; | |
794 | #else | |
795 | return false; | |
796 | #endif | |
797 | } | |
183d03cc | 798 | |
5f46400f DW |
799 | static int xenbus_probe_thread(void *unused) |
800 | { | |
801 | DEFINE_WAIT(w); | |
802 | ||
803 | /* | |
804 | * We actually just want to wait for *any* trigger of xb_waitq, | |
805 | * and run xenbus_probe() the moment it occurs. | |
806 | */ | |
807 | prepare_to_wait(&xb_waitq, &w, TASK_INTERRUPTIBLE); | |
808 | schedule(); | |
809 | finish_wait(&xb_waitq, &w); | |
810 | ||
811 | DPRINTK("probing"); | |
812 | xenbus_probe(); | |
813 | return 0; | |
814 | } | |
815 | ||
3499ba81 DW |
816 | static int __init xenbus_probe_initcall(void) |
817 | { | |
0d8f7cc8 SS |
818 | if (!xen_domain()) |
819 | return -ENODEV; | |
820 | ||
3499ba81 DW |
821 | /* |
822 | * Probe XenBus here in the XS_PV case, and also XS_HVM unless we | |
5b335394 LM |
823 | * need to wait for the platform PCI device to come up or |
824 | * xen_store_interface is not ready. | |
3499ba81 DW |
825 | */ |
826 | if (xen_store_domain_type == XS_PV || | |
827 | (xen_store_domain_type == XS_HVM && | |
5b335394 | 828 | !xs_hvm_defer_init_for_callback() && |
a3607581 | 829 | XS_INTERFACE_READY)) |
3499ba81 | 830 | xenbus_probe(); |
183d03cc | 831 | |
5f46400f | 832 | /* |
5b335394 LM |
833 | * For XS_LOCAL or when xen_store_interface is not ready, spawn a |
834 | * thread which will wait for xenstored or a xenstore-stubdom to be | |
835 | * started, then probe. It will be triggered when communication | |
836 | * starts happening, by waiting on xb_waitq. | |
5f46400f | 837 | */ |
a3607581 | 838 | if (xen_store_domain_type == XS_LOCAL || !XS_INTERFACE_READY) { |
5f46400f DW |
839 | struct task_struct *probe_task; |
840 | ||
841 | probe_task = kthread_run(xenbus_probe_thread, NULL, | |
842 | "xenbus_probe"); | |
843 | if (IS_ERR(probe_task)) | |
844 | return PTR_ERR(probe_task); | |
845 | } | |
183d03cc SS |
846 | return 0; |
847 | } | |
183d03cc SS |
848 | device_initcall(xenbus_probe_initcall); |
849 | ||
3499ba81 DW |
850 | int xen_set_callback_via(uint64_t via) |
851 | { | |
852 | struct xen_hvm_param a; | |
853 | int ret; | |
854 | ||
855 | a.domid = DOMID_SELF; | |
856 | a.index = HVM_PARAM_CALLBACK_IRQ; | |
857 | a.value = via; | |
858 | ||
859 | ret = HYPERVISOR_hvm_op(HVMOP_set_param, &a); | |
860 | if (ret) | |
861 | return ret; | |
862 | ||
863 | /* | |
864 | * If xenbus_probe_initcall() deferred the xenbus_probe() | |
865 | * due to the callback not functioning yet, we can do it now. | |
866 | */ | |
867 | if (!xenstored_ready && xs_hvm_defer_init_for_callback()) | |
868 | xenbus_probe(); | |
869 | ||
870 | return ret; | |
871 | } | |
872 | EXPORT_SYMBOL_GPL(xen_set_callback_via); | |
873 | ||
e4184aaf DDG |
874 | /* Set up event channel for xenstored which is run as a local process |
875 | * (this is normally used only in dom0) | |
876 | */ | |
877 | static int __init xenstored_local_init(void) | |
4bac07c9 | 878 | { |
2466d4b9 | 879 | int err = -ENOMEM; |
b37a56d6 | 880 | unsigned long page = 0; |
e4184aaf | 881 | struct evtchn_alloc_unbound alloc_unbound; |
4bac07c9 | 882 | |
e4184aaf DDG |
883 | /* Allocate Xenstore page */ |
884 | page = get_zeroed_page(GFP_KERNEL); | |
885 | if (!page) | |
886 | goto out_err; | |
4bac07c9 | 887 | |
515e6541 | 888 | xen_store_gfn = virt_to_gfn((void *)page); |
4bac07c9 | 889 | |
e4184aaf DDG |
890 | /* Next allocate a local port which xenstored can bind to */ |
891 | alloc_unbound.dom = DOMID_SELF; | |
892 | alloc_unbound.remote_dom = DOMID_SELF; | |
b37a56d6 | 893 | |
e4184aaf DDG |
894 | err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, |
895 | &alloc_unbound); | |
896 | if (err == -ENOSYS) | |
897 | goto out_err; | |
b37a56d6 | 898 | |
e4184aaf | 899 | BUG_ON(err); |
515e6541 | 900 | xen_store_evtchn = alloc_unbound.port; |
b37a56d6 | 901 | |
e4184aaf | 902 | return 0; |
b37a56d6 | 903 | |
e4184aaf DDG |
904 | out_err: |
905 | if (page != 0) | |
906 | free_page(page); | |
907 | return err; | |
908 | } | |
b37a56d6 | 909 | |
16f1cf3b BO |
910 | static int xenbus_resume_cb(struct notifier_block *nb, |
911 | unsigned long action, void *data) | |
912 | { | |
913 | int err = 0; | |
914 | ||
915 | if (xen_hvm_domain()) { | |
76ea3cb4 | 916 | uint64_t v = 0; |
16f1cf3b BO |
917 | |
918 | err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); | |
919 | if (!err && v) | |
920 | xen_store_evtchn = v; | |
921 | else | |
922 | pr_warn("Cannot update xenstore event channel: %d\n", | |
923 | err); | |
924 | } else | |
925 | xen_store_evtchn = xen_start_info->store_evtchn; | |
926 | ||
927 | return err; | |
928 | } | |
929 | ||
930 | static struct notifier_block xenbus_resume_nb = { | |
931 | .notifier_call = xenbus_resume_cb, | |
932 | }; | |
933 | ||
5b335394 LM |
934 | static irqreturn_t xenbus_late_init(int irq, void *unused) |
935 | { | |
936 | int err; | |
937 | uint64_t v = 0; | |
938 | ||
939 | err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v); | |
940 | if (err || !v || !~v) | |
941 | return IRQ_HANDLED; | |
942 | xen_store_gfn = (unsigned long)v; | |
943 | ||
944 | wake_up(&xb_waitq); | |
945 | return IRQ_HANDLED; | |
946 | } | |
947 | ||
e4184aaf DDG |
948 | static int __init xenbus_init(void) |
949 | { | |
08f6c2b0 | 950 | int err; |
ecc635f9 | 951 | uint64_t v = 0; |
5b335394 | 952 | bool wait = false; |
33c1174b | 953 | xen_store_domain_type = XS_UNKNOWN; |
b37a56d6 | 954 | |
e4184aaf DDG |
955 | if (!xen_domain()) |
956 | return -ENODEV; | |
957 | ||
2c5d37d3 DDG |
958 | xenbus_ring_ops_init(); |
959 | ||
ecc635f9 | 960 | if (xen_pv_domain()) |
33c1174b | 961 | xen_store_domain_type = XS_PV; |
ecc635f9 | 962 | if (xen_hvm_domain()) |
33c1174b | 963 | xen_store_domain_type = XS_HVM; |
ecc635f9 | 964 | if (xen_hvm_domain() && xen_initial_domain()) |
33c1174b | 965 | xen_store_domain_type = XS_LOCAL; |
ecc635f9 | 966 | if (xen_pv_domain() && !xen_start_info->store_evtchn) |
33c1174b | 967 | xen_store_domain_type = XS_LOCAL; |
ecc635f9 SS |
968 | if (xen_pv_domain() && xen_start_info->store_evtchn) |
969 | xenstored_ready = 1; | |
970 | ||
33c1174b AC |
971 | switch (xen_store_domain_type) { |
972 | case XS_LOCAL: | |
ecc635f9 SS |
973 | err = xenstored_local_init(); |
974 | if (err) | |
975 | goto out_error; | |
5f51042f | 976 | xen_store_interface = gfn_to_virt(xen_store_gfn); |
ecc635f9 | 977 | break; |
33c1174b | 978 | case XS_PV: |
ecc635f9 | 979 | xen_store_evtchn = xen_start_info->store_evtchn; |
5f51042f JG |
980 | xen_store_gfn = xen_start_info->store_mfn; |
981 | xen_store_interface = gfn_to_virt(xen_store_gfn); | |
ecc635f9 | 982 | break; |
33c1174b | 983 | case XS_HVM: |
e4184aaf DDG |
984 | err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); |
985 | if (err) | |
986 | goto out_error; | |
987 | xen_store_evtchn = (int)v; | |
988 | err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v); | |
989 | if (err) | |
990 | goto out_error; | |
36e8f60f SS |
991 | /* |
992 | * Uninitialized hvm_params are zero and return no error. | |
993 | * Although it is theoretically possible to have | |
994 | * HVM_PARAM_STORE_PFN set to zero on purpose, in reality it is | |
995 | * not zero when valid. If zero, it means that Xenstore hasn't | |
996 | * been properly initialized. Instead of attempting to map a | |
997 | * wrong guest physical address return error. | |
998 | * | |
5b335394 | 999 | * Also recognize all bits set as an invalid/uninitialized value. |
36e8f60f | 1000 | */ |
5b335394 | 1001 | if (!v) { |
36e8f60f SS |
1002 | err = -ENOENT; |
1003 | goto out_error; | |
1004 | } | |
5b335394 LM |
1005 | if (v == ~0ULL) { |
1006 | wait = true; | |
1007 | } else { | |
1008 | /* Avoid truncation on 32-bit. */ | |
36e8f60f | 1009 | #if BITS_PER_LONG == 32 |
5b335394 LM |
1010 | if (v > ULONG_MAX) { |
1011 | pr_err("%s: cannot handle HVM_PARAM_STORE_PFN=%llx > ULONG_MAX\n", | |
1012 | __func__, v); | |
1013 | err = -EINVAL; | |
1014 | goto out_error; | |
1015 | } | |
36e8f60f | 1016 | #endif |
5b335394 LM |
1017 | xen_store_gfn = (unsigned long)v; |
1018 | xen_store_interface = | |
41925b10 JG |
1019 | memremap(xen_store_gfn << XEN_PAGE_SHIFT, |
1020 | XEN_PAGE_SIZE, MEMREMAP_WB); | |
a3607581 HW |
1021 | if (!xen_store_interface) { |
1022 | pr_err("%s: cannot map HVM_PARAM_STORE_PFN=%llx\n", | |
1023 | __func__, v); | |
1024 | err = -EINVAL; | |
1025 | goto out_error; | |
1026 | } | |
5b335394 LM |
1027 | if (xen_store_interface->connection != XENSTORE_CONNECTED) |
1028 | wait = true; | |
1029 | } | |
1030 | if (wait) { | |
1031 | err = bind_evtchn_to_irqhandler(xen_store_evtchn, | |
1032 | xenbus_late_init, | |
1033 | 0, "xenstore_late_init", | |
1034 | &xb_waitq); | |
1035 | if (err < 0) { | |
1036 | pr_err("xenstore_late_init couldn't bind irq err=%d\n", | |
1037 | err); | |
44961b81 | 1038 | goto out_error; |
5b335394 LM |
1039 | } |
1040 | ||
1041 | xs_init_irq = err; | |
1042 | } | |
ecc635f9 SS |
1043 | break; |
1044 | default: | |
1045 | pr_warn("Xenstore state unknown\n"); | |
1046 | break; | |
4bac07c9 | 1047 | } |
4bac07c9 | 1048 | |
3499ba81 DW |
1049 | /* |
1050 | * HVM domains may not have a functional callback yet. In that | |
1051 | * case let xs_init() be called from xenbus_probe(), which will | |
1052 | * get invoked at an appropriate time. | |
1053 | */ | |
1054 | if (xen_store_domain_type != XS_HVM) { | |
1055 | err = xs_init(); | |
1056 | if (err) { | |
1057 | pr_warn("Error initializing xenstore comms: %i\n", err); | |
1058 | goto out_error; | |
1059 | } | |
4bac07c9 JF |
1060 | } |
1061 | ||
16f1cf3b BO |
1062 | if ((xen_store_domain_type != XS_LOCAL) && |
1063 | (xen_store_domain_type != XS_UNKNOWN)) | |
1064 | xen_resume_notifier_register(&xenbus_resume_nb); | |
1065 | ||
1107ba88 AZ |
1066 | #ifdef CONFIG_XEN_COMPAT_XENFS |
1067 | /* | |
1068 | * Create xenfs mountpoint in /proc for compatibility with | |
1069 | * utilities that expect to find "xenbus" under "/proc/xen". | |
1070 | */ | |
f97df70b | 1071 | proc_create_mount_point("xen"); |
1107ba88 | 1072 | #endif |
08f6c2b0 | 1073 | return 0; |
1107ba88 | 1074 | |
6913200a | 1075 | out_error: |
08f6c2b0 | 1076 | xen_store_domain_type = XS_UNKNOWN; |
4bac07c9 JF |
1077 | return err; |
1078 | } | |
1079 | ||
183d03cc | 1080 | postcore_initcall(xenbus_init); |
4bac07c9 JF |
1081 | |
1082 | MODULE_LICENSE("GPL"); |