1 /******************************************************************************
2 * Talks to Xen Store to figure out what devices we have.
4 * Copyright (C) 2005 Rusty Russell, IBM Corporation
5 * Copyright (C) 2005 Mike Wray, Hewlett-Packard
6 * Copyright (C) 2005, 2006 XenSource Ltd
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:
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:
21 * The above copyright notice and this permission notice shall be included in
22 * all copies or substantial portions of the Software.
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
33 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
34 #define dev_fmt pr_fmt
36 #define DPRINTK(fmt, args...) \
37 pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \
38 __func__, __LINE__, ##args)
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>
46 #include <linux/proc_fs.h>
47 #include <linux/notifier.h>
48 #include <linux/kthread.h>
49 #include <linux/mutex.h>
51 #include <linux/slab.h>
52 #include <linux/module.h>
55 #include <asm/xen/hypervisor.h>
58 #include <xen/xenbus.h>
59 #include <xen/events.h>
60 #include <xen/xen-ops.h>
68 static int xs_init_irq
= -1;
70 EXPORT_SYMBOL_GPL(xen_store_evtchn
);
72 struct xenstore_domain_interface
*xen_store_interface
;
73 EXPORT_SYMBOL_GPL(xen_store_interface
);
75 #define XS_INTERFACE_READY \
76 ((xen_store_interface != NULL) && \
77 (xen_store_interface->connection == XENSTORE_CONNECTED))
79 enum xenstore_init xen_store_domain_type
;
80 EXPORT_SYMBOL_GPL(xen_store_domain_type
);
82 static unsigned long xen_store_gfn
;
84 static BLOCKING_NOTIFIER_HEAD(xenstore_chain
);
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
)
90 for (; *arr
->devicetype
!= '\0'; arr
++) {
91 if (!strcmp(arr
->devicetype
, dev
->devicetype
))
97 int xenbus_match(struct device
*_dev
, const struct device_driver
*_drv
)
99 const struct xenbus_driver
*drv
= to_xenbus_driver(_drv
);
104 return match_device(drv
->ids
, to_xenbus_device(_dev
)) != NULL
;
106 EXPORT_SYMBOL_GPL(xenbus_match
);
109 static void free_otherend_details(struct xenbus_device
*dev
)
111 kfree(dev
->otherend
);
112 dev
->otherend
= NULL
;
116 static void free_otherend_watch(struct xenbus_device
*dev
)
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
;
126 static int talk_to_otherend(struct xenbus_device
*dev
)
128 struct xenbus_driver
*drv
= to_xenbus_driver(dev
->dev
.driver
);
130 free_otherend_watch(dev
);
131 free_otherend_details(dev
);
133 return drv
->read_otherend_details(dev
);
138 static int watch_otherend(struct xenbus_device
*dev
)
140 struct xen_bus_type
*bus
=
141 container_of(dev
->dev
.bus
, struct xen_bus_type
, bus
);
143 return xenbus_watch_pathfmt(dev
, &dev
->otherend_watch
,
144 bus
->otherend_will_handle
,
145 bus
->otherend_changed
,
146 "%s/%s", dev
->otherend
, "state");
150 int xenbus_read_otherend_details(struct xenbus_device
*xendev
,
151 char *id_node
, char *path_node
)
153 int err
= xenbus_gather(XBT_NIL
, xendev
->nodename
,
154 id_node
, "%i", &xendev
->otherend_id
,
155 path_node
, NULL
, &xendev
->otherend
,
158 xenbus_dev_fatal(xendev
, err
,
159 "reading other end details from %s",
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.",
169 free_otherend_details(xendev
);
175 EXPORT_SYMBOL_GPL(xenbus_read_otherend_details
);
177 void xenbus_otherend_changed(struct xenbus_watch
*watch
,
178 const char *path
, const char *token
,
179 int ignore_on_shutdown
)
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
;
186 /* Protect us against watches firing on old details when the otherend
187 details change, say immediately after a resume. */
188 if (!dev
->otherend
||
189 strncmp(dev
->otherend
, path
, strlen(dev
->otherend
))) {
190 dev_dbg(&dev
->dev
, "Ignoring watch at %s\n", path
);
194 state
= xenbus_read_driver_state(dev
->otherend
);
196 dev_dbg(&dev
->dev
, "state is %d, (%s), %s, %s\n",
197 state
, xenbus_strstate(state
), dev
->otherend_watch
.node
, path
);
200 * Ignore xenbus transitions during shutdown. This prevents us doing
201 * work that can fail e.g., when the rootfs is gone.
203 if (system_state
> SYSTEM_RUNNING
) {
204 if (ignore_on_shutdown
&& (state
== XenbusStateClosing
))
205 xenbus_frontend_closed(dev
);
209 if (drv
->otherend_changed
)
210 drv
->otherend_changed(dev
, state
);
212 EXPORT_SYMBOL_GPL(xenbus_otherend_changed
);
214 #define XENBUS_SHOW_STAT(name) \
215 static ssize_t name##_show(struct device *_dev, \
216 struct device_attribute *attr, \
219 struct xenbus_device *dev = to_xenbus_device(_dev); \
221 return sprintf(buf, "%d\n", atomic_read(&dev->name)); \
223 static DEVICE_ATTR_RO(name)
225 XENBUS_SHOW_STAT(event_channels
);
226 XENBUS_SHOW_STAT(events
);
227 XENBUS_SHOW_STAT(spurious_events
);
228 XENBUS_SHOW_STAT(jiffies_eoi_delayed
);
230 static ssize_t
spurious_threshold_show(struct device
*_dev
,
231 struct device_attribute
*attr
,
234 struct xenbus_device
*dev
= to_xenbus_device(_dev
);
236 return sprintf(buf
, "%d\n", dev
->spurious_threshold
);
239 static ssize_t
spurious_threshold_store(struct device
*_dev
,
240 struct device_attribute
*attr
,
241 const char *buf
, size_t count
)
243 struct xenbus_device
*dev
= to_xenbus_device(_dev
);
247 ret
= kstrtouint(buf
, 0, &val
);
251 dev
->spurious_threshold
= val
;
256 static DEVICE_ATTR_RW(spurious_threshold
);
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
,
267 static const struct attribute_group xenbus_group
= {
269 .attrs
= xenbus_attrs
,
272 int xenbus_dev_probe(struct device
*_dev
)
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
;
279 DPRINTK("%s", dev
->nodename
);
286 id
= match_device(drv
->ids
, dev
);
292 err
= talk_to_otherend(dev
);
294 dev_warn(&dev
->dev
, "talk_to_otherend on %s failed.\n",
299 if (!try_module_get(drv
->driver
.owner
)) {
300 dev_warn(&dev
->dev
, "failed to acquire module reference on '%s'\n",
306 down(&dev
->reclaim_sem
);
307 err
= drv
->probe(dev
, id
);
308 up(&dev
->reclaim_sem
);
312 err
= watch_otherend(dev
);
314 dev_warn(&dev
->dev
, "watch_otherend on %s failed.\n",
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",
326 module_put(drv
->driver
.owner
);
328 xenbus_dev_error(dev
, err
, "xenbus_dev_probe on %s", dev
->nodename
);
331 EXPORT_SYMBOL_GPL(xenbus_dev_probe
);
333 void xenbus_dev_remove(struct device
*_dev
)
335 struct xenbus_device
*dev
= to_xenbus_device(_dev
);
336 struct xenbus_driver
*drv
= to_xenbus_driver(_dev
->driver
);
338 DPRINTK("%s", dev
->nodename
);
340 sysfs_remove_group(&dev
->dev
.kobj
, &xenbus_group
);
342 free_otherend_watch(dev
);
345 down(&dev
->reclaim_sem
);
347 up(&dev
->reclaim_sem
);
350 module_put(drv
->driver
.owner
);
352 free_otherend_details(dev
);
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
360 if (!drv
->allow_rebind
||
361 xenbus_read_driver_state(dev
->nodename
) == XenbusStateClosing
)
362 xenbus_switch_state(dev
, XenbusStateClosed
);
364 EXPORT_SYMBOL_GPL(xenbus_dev_remove
);
366 int xenbus_register_driver_common(struct xenbus_driver
*drv
,
367 struct xen_bus_type
*bus
,
368 struct module
*owner
, const char *mod_name
)
370 drv
->driver
.name
= drv
->name
? drv
->name
: drv
->ids
[0].devicetype
;
371 drv
->driver
.bus
= &bus
->bus
;
372 drv
->driver
.owner
= owner
;
373 drv
->driver
.mod_name
= mod_name
;
375 return driver_register(&drv
->driver
);
377 EXPORT_SYMBOL_GPL(xenbus_register_driver_common
);
379 void xenbus_unregister_driver(struct xenbus_driver
*drv
)
381 driver_unregister(&drv
->driver
);
383 EXPORT_SYMBOL_GPL(xenbus_unregister_driver
);
385 struct xb_find_info
{
386 struct xenbus_device
*dev
;
387 const char *nodename
;
390 static int cmp_dev(struct device
*dev
, void *data
)
392 struct xenbus_device
*xendev
= to_xenbus_device(dev
);
393 struct xb_find_info
*info
= data
;
395 if (!strcmp(xendev
->nodename
, info
->nodename
)) {
403 static struct xenbus_device
*xenbus_device_find(const char *nodename
,
404 struct bus_type
*bus
)
406 struct xb_find_info info
= { .dev
= NULL
, .nodename
= nodename
};
408 bus_for_each_dev(bus
, NULL
, &info
, cmp_dev
);
412 static int cleanup_dev(struct device
*dev
, void *data
)
414 struct xenbus_device
*xendev
= to_xenbus_device(dev
);
415 struct xb_find_info
*info
= data
;
416 int len
= strlen(info
->nodename
);
418 DPRINTK("%s", info
->nodename
);
420 /* Match the info->nodename path, or any subdirectory of that path. */
421 if (strncmp(xendev
->nodename
, info
->nodename
, len
))
424 /* If the node name is longer, ensure it really is a subdirectory. */
425 if ((strlen(xendev
->nodename
) > len
) && (xendev
->nodename
[len
] != '/'))
433 static void xenbus_cleanup_devices(const char *path
, struct bus_type
*bus
)
435 struct xb_find_info info
= { .nodename
= path
};
439 bus_for_each_dev(bus
, NULL
, &info
, cleanup_dev
);
441 device_unregister(&info
.dev
->dev
);
442 put_device(&info
.dev
->dev
);
447 static void xenbus_dev_release(struct device
*dev
)
450 kfree(to_xenbus_device(dev
));
453 static ssize_t
nodename_show(struct device
*dev
,
454 struct device_attribute
*attr
, char *buf
)
456 return sprintf(buf
, "%s\n", to_xenbus_device(dev
)->nodename
);
458 static DEVICE_ATTR_RO(nodename
);
460 static ssize_t
devtype_show(struct device
*dev
,
461 struct device_attribute
*attr
, char *buf
)
463 return sprintf(buf
, "%s\n", to_xenbus_device(dev
)->devicetype
);
465 static DEVICE_ATTR_RO(devtype
);
467 static ssize_t
modalias_show(struct device
*dev
,
468 struct device_attribute
*attr
, char *buf
)
470 return sprintf(buf
, "%s:%s\n", dev
->bus
->name
,
471 to_xenbus_device(dev
)->devicetype
);
473 static DEVICE_ATTR_RO(modalias
);
475 static ssize_t
state_show(struct device
*dev
,
476 struct device_attribute
*attr
, char *buf
)
478 return sprintf(buf
, "%s\n",
479 xenbus_strstate(to_xenbus_device(dev
)->state
));
481 static DEVICE_ATTR_RO(state
);
483 static struct attribute
*xenbus_dev_attrs
[] = {
484 &dev_attr_nodename
.attr
,
485 &dev_attr_devtype
.attr
,
486 &dev_attr_modalias
.attr
,
487 &dev_attr_state
.attr
,
491 static const struct attribute_group xenbus_dev_group
= {
492 .attrs
= xenbus_dev_attrs
,
495 const struct attribute_group
*xenbus_dev_groups
[] = {
499 EXPORT_SYMBOL_GPL(xenbus_dev_groups
);
501 int xenbus_probe_node(struct xen_bus_type
*bus
,
503 const char *nodename
)
505 char devname
[XEN_BUS_ID_SIZE
];
507 struct xenbus_device
*xendev
;
511 enum xenbus_state state
= xenbus_read_driver_state(nodename
);
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. */
519 stringlen
= strlen(nodename
) + 1 + strlen(type
) + 1;
520 xendev
= kzalloc(sizeof(*xendev
) + stringlen
, GFP_KERNEL
);
524 xendev
->state
= XenbusStateInitialising
;
526 /* Copy the strings into the extra space. */
528 tmpstring
= (char *)(xendev
+ 1);
529 strcpy(tmpstring
, nodename
);
530 xendev
->nodename
= tmpstring
;
532 tmpstring
+= strlen(tmpstring
) + 1;
533 strcpy(tmpstring
, type
);
534 xendev
->devicetype
= tmpstring
;
535 init_completion(&xendev
->down
);
537 xendev
->dev
.bus
= &bus
->bus
;
538 xendev
->dev
.release
= xenbus_dev_release
;
540 err
= bus
->get_bus_id(devname
, xendev
->nodename
);
544 dev_set_name(&xendev
->dev
, "%s", devname
);
545 sema_init(&xendev
->reclaim_sem
, 1);
547 /* Register with generic device framework. */
548 err
= device_register(&xendev
->dev
);
550 put_device(&xendev
->dev
);
560 EXPORT_SYMBOL_GPL(xenbus_probe_node
);
562 static int xenbus_probe_device_type(struct xen_bus_type
*bus
, const char *type
)
566 unsigned int dir_n
= 0;
569 dir
= xenbus_directory(XBT_NIL
, bus
->root
, type
, &dir_n
);
573 for (i
= 0; i
< dir_n
; i
++) {
574 err
= bus
->probe(bus
, type
, dir
[i
]);
583 int xenbus_probe_devices(struct xen_bus_type
*bus
)
587 unsigned int i
, dir_n
;
589 dir
= xenbus_directory(XBT_NIL
, bus
->root
, "", &dir_n
);
593 for (i
= 0; i
< dir_n
; i
++) {
594 err
= xenbus_probe_device_type(bus
, dir
[i
]);
602 EXPORT_SYMBOL_GPL(xenbus_probe_devices
);
604 static unsigned int char_count(const char *str
, char c
)
606 unsigned int i
, ret
= 0;
608 for (i
= 0; str
[i
]; i
++)
614 static int strsep_len(const char *str
, char c
, unsigned int len
)
618 for (i
= 0; str
[i
]; i
++)
624 return (len
== 0) ? i
: -ERANGE
;
627 void xenbus_dev_changed(const char *node
, struct xen_bus_type
*bus
)
630 struct xenbus_device
*dev
;
631 char type
[XEN_BUS_ID_SIZE
];
632 const char *p
, *root
;
634 if (char_count(node
, '/') < 2)
637 exists
= xenbus_exists(XBT_NIL
, node
, "");
639 xenbus_cleanup_devices(node
, &bus
->bus
);
643 /* backend/<type>/... or device/<type>/... */
644 p
= strchr(node
, '/') + 1;
645 snprintf(type
, XEN_BUS_ID_SIZE
, "%.*s", (int)strcspn(p
, "/"), p
);
646 type
[XEN_BUS_ID_SIZE
-1] = '\0';
648 rootlen
= strsep_len(node
, '/', bus
->levels
);
651 root
= kasprintf(GFP_KERNEL
, "%.*s", rootlen
, node
);
655 dev
= xenbus_device_find(root
, &bus
->bus
);
657 xenbus_probe_node(bus
, type
, root
);
659 put_device(&dev
->dev
);
663 EXPORT_SYMBOL_GPL(xenbus_dev_changed
);
665 int xenbus_dev_suspend(struct device
*dev
)
668 struct xenbus_driver
*drv
;
669 struct xenbus_device
*xdev
670 = container_of(dev
, struct xenbus_device
, dev
);
672 DPRINTK("%s", xdev
->nodename
);
674 if (dev
->driver
== NULL
)
676 drv
= to_xenbus_driver(dev
->driver
);
678 err
= drv
->suspend(xdev
);
680 dev_warn(dev
, "suspend failed: %i\n", err
);
683 EXPORT_SYMBOL_GPL(xenbus_dev_suspend
);
685 int xenbus_dev_resume(struct device
*dev
)
688 struct xenbus_driver
*drv
;
689 struct xenbus_device
*xdev
690 = container_of(dev
, struct xenbus_device
, dev
);
692 DPRINTK("%s", xdev
->nodename
);
694 if (dev
->driver
== NULL
)
696 drv
= to_xenbus_driver(dev
->driver
);
697 err
= talk_to_otherend(xdev
);
699 dev_warn(dev
, "resume (talk_to_otherend) failed: %i\n", err
);
703 xdev
->state
= XenbusStateInitialising
;
706 err
= drv
->resume(xdev
);
708 dev_warn(dev
, "resume failed: %i\n", err
);
713 err
= watch_otherend(xdev
);
715 dev_warn(dev
, "resume (watch_otherend) failed: %d\n", err
);
721 EXPORT_SYMBOL_GPL(xenbus_dev_resume
);
723 int xenbus_dev_cancel(struct device
*dev
)
729 EXPORT_SYMBOL_GPL(xenbus_dev_cancel
);
731 /* A flag to determine if xenstored is 'ready' (i.e. has started) */
735 int register_xenstore_notifier(struct notifier_block
*nb
)
739 if (xenstored_ready
> 0)
740 ret
= nb
->notifier_call(nb
, 0, NULL
);
742 blocking_notifier_chain_register(&xenstore_chain
, nb
);
746 EXPORT_SYMBOL_GPL(register_xenstore_notifier
);
748 void unregister_xenstore_notifier(struct notifier_block
*nb
)
750 blocking_notifier_chain_unregister(&xenstore_chain
, nb
);
752 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier
);
754 static void xenbus_probe(void)
758 if (!xen_store_interface
)
759 xen_store_interface
= memremap(xen_store_gfn
<< XEN_PAGE_SHIFT
,
760 XEN_PAGE_SIZE
, MEMREMAP_WB
);
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.
769 if (xs_init_irq
>= 0)
770 free_irq(xs_init_irq
, &xb_waitq
);
773 * In the HVM case, xenbus_init() deferred its call to
774 * xs_init() in case callbacks were not operational yet.
777 if (xen_store_domain_type
== XS_HVM
)
780 /* Notify others that xenstore is up */
781 blocking_notifier_call_chain(&xenstore_chain
, 0, NULL
);
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.
789 static bool xs_hvm_defer_init_for_callback(void)
791 #ifdef CONFIG_XEN_PVHVM
792 return xen_store_domain_type
== XS_HVM
&&
793 !xen_have_vector_callback
;
799 static int xenbus_probe_thread(void *unused
)
804 * We actually just want to wait for *any* trigger of xb_waitq,
805 * and run xenbus_probe() the moment it occurs.
807 prepare_to_wait(&xb_waitq
, &w
, TASK_INTERRUPTIBLE
);
809 finish_wait(&xb_waitq
, &w
);
816 static int __init
xenbus_probe_initcall(void)
822 * Probe XenBus here in the XS_PV case, and also XS_HVM unless we
823 * need to wait for the platform PCI device to come up or
824 * xen_store_interface is not ready.
826 if (xen_store_domain_type
== XS_PV
||
827 (xen_store_domain_type
== XS_HVM
&&
828 !xs_hvm_defer_init_for_callback() &&
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.
838 if (xen_store_domain_type
== XS_LOCAL
|| !XS_INTERFACE_READY
) {
839 struct task_struct
*probe_task
;
841 probe_task
= kthread_run(xenbus_probe_thread
, NULL
,
843 if (IS_ERR(probe_task
))
844 return PTR_ERR(probe_task
);
848 device_initcall(xenbus_probe_initcall
);
850 int xen_set_callback_via(uint64_t via
)
852 struct xen_hvm_param a
;
855 a
.domid
= DOMID_SELF
;
856 a
.index
= HVM_PARAM_CALLBACK_IRQ
;
859 ret
= HYPERVISOR_hvm_op(HVMOP_set_param
, &a
);
864 * If xenbus_probe_initcall() deferred the xenbus_probe()
865 * due to the callback not functioning yet, we can do it now.
867 if (!xenstored_ready
&& xs_hvm_defer_init_for_callback())
872 EXPORT_SYMBOL_GPL(xen_set_callback_via
);
874 /* Set up event channel for xenstored which is run as a local process
875 * (this is normally used only in dom0)
877 static int __init
xenstored_local_init(void)
880 unsigned long page
= 0;
881 struct evtchn_alloc_unbound alloc_unbound
;
883 /* Allocate Xenstore page */
884 page
= get_zeroed_page(GFP_KERNEL
);
888 xen_store_gfn
= virt_to_gfn((void *)page
);
890 /* Next allocate a local port which xenstored can bind to */
891 alloc_unbound
.dom
= DOMID_SELF
;
892 alloc_unbound
.remote_dom
= DOMID_SELF
;
894 err
= HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound
,
900 xen_store_evtchn
= alloc_unbound
.port
;
910 static int xenbus_resume_cb(struct notifier_block
*nb
,
911 unsigned long action
, void *data
)
915 if (xen_hvm_domain()) {
918 err
= hvm_get_parameter(HVM_PARAM_STORE_EVTCHN
, &v
);
920 xen_store_evtchn
= v
;
922 pr_warn("Cannot update xenstore event channel: %d\n",
925 xen_store_evtchn
= xen_start_info
->store_evtchn
;
930 static struct notifier_block xenbus_resume_nb
= {
931 .notifier_call
= xenbus_resume_cb
,
934 static irqreturn_t
xenbus_late_init(int irq
, void *unused
)
939 err
= hvm_get_parameter(HVM_PARAM_STORE_PFN
, &v
);
940 if (err
|| !v
|| !~v
)
942 xen_store_gfn
= (unsigned long)v
;
948 static int __init
xenbus_init(void)
953 xen_store_domain_type
= XS_UNKNOWN
;
958 xenbus_ring_ops_init();
961 xen_store_domain_type
= XS_PV
;
962 if (xen_hvm_domain())
963 xen_store_domain_type
= XS_HVM
;
964 if (xen_hvm_domain() && xen_initial_domain())
965 xen_store_domain_type
= XS_LOCAL
;
966 if (xen_pv_domain() && !xen_start_info
->store_evtchn
)
967 xen_store_domain_type
= XS_LOCAL
;
968 if (xen_pv_domain() && xen_start_info
->store_evtchn
)
971 switch (xen_store_domain_type
) {
973 err
= xenstored_local_init();
976 xen_store_interface
= gfn_to_virt(xen_store_gfn
);
979 xen_store_evtchn
= xen_start_info
->store_evtchn
;
980 xen_store_gfn
= xen_start_info
->store_mfn
;
981 xen_store_interface
= gfn_to_virt(xen_store_gfn
);
984 err
= hvm_get_parameter(HVM_PARAM_STORE_EVTCHN
, &v
);
987 xen_store_evtchn
= (int)v
;
988 err
= hvm_get_parameter(HVM_PARAM_STORE_PFN
, &v
);
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.
999 * Also recognize all bits set as an invalid/uninitialized value.
1008 /* Avoid truncation on 32-bit. */
1009 #if BITS_PER_LONG == 32
1010 if (v
> ULONG_MAX
) {
1011 pr_err("%s: cannot handle HVM_PARAM_STORE_PFN=%llx > ULONG_MAX\n",
1017 xen_store_gfn
= (unsigned long)v
;
1018 xen_store_interface
=
1019 memremap(xen_store_gfn
<< XEN_PAGE_SHIFT
,
1020 XEN_PAGE_SIZE
, MEMREMAP_WB
);
1021 if (!xen_store_interface
) {
1022 pr_err("%s: cannot map HVM_PARAM_STORE_PFN=%llx\n",
1027 if (xen_store_interface
->connection
!= XENSTORE_CONNECTED
)
1031 err
= bind_evtchn_to_irqhandler(xen_store_evtchn
,
1033 0, "xenstore_late_init",
1036 pr_err("xenstore_late_init couldn't bind irq err=%d\n",
1045 pr_warn("Xenstore state unknown\n");
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.
1054 if (xen_store_domain_type
!= XS_HVM
) {
1057 pr_warn("Error initializing xenstore comms: %i\n", err
);
1062 if ((xen_store_domain_type
!= XS_LOCAL
) &&
1063 (xen_store_domain_type
!= XS_UNKNOWN
))
1064 xen_resume_notifier_register(&xenbus_resume_nb
);
1066 #ifdef CONFIG_XEN_COMPAT_XENFS
1068 * Create xenfs mountpoint in /proc for compatibility with
1069 * utilities that expect to find "xenbus" under "/proc/xen".
1071 proc_create_mount_point("xen");
1076 xen_store_domain_type
= XS_UNKNOWN
;
1080 postcore_initcall(xenbus_init
);
1082 MODULE_LICENSE("GPL");