1 /******************************************************************************
2 * Client-facing interface for the Xenbus driver. In other words, the
3 * interface between the Xenbus and the device-specific code, be it the
4 * frontend or the backend of that driver.
6 * Copyright (C) 2005 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
34 #include <linux/slab.h>
35 #include <linux/types.h>
36 #include <linux/spinlock.h>
37 #include <linux/vmalloc.h>
38 #include <linux/export.h>
39 #include <asm/xen/hypervisor.h>
41 #include <xen/interface/xen.h>
42 #include <xen/interface/event_channel.h>
43 #include <xen/balloon.h>
44 #include <xen/events.h>
45 #include <xen/grant_table.h>
46 #include <xen/xenbus.h>
48 #include <xen/features.h>
52 #define XENBUS_PAGES(_grants) (DIV_ROUND_UP(_grants, XEN_PFN_PER_PAGE))
54 #define XENBUS_MAX_RING_PAGES (XENBUS_PAGES(XENBUS_MAX_RING_GRANTS))
56 struct xenbus_map_node {
57 struct list_head next;
60 struct vm_struct *area;
63 struct page *pages[XENBUS_MAX_RING_PAGES];
64 unsigned long addrs[XENBUS_MAX_RING_GRANTS];
68 grant_handle_t handles[XENBUS_MAX_RING_GRANTS];
69 unsigned int nr_handles;
72 static DEFINE_SPINLOCK(xenbus_valloc_lock);
73 static LIST_HEAD(xenbus_valloc_pages);
75 struct xenbus_ring_ops {
76 int (*map)(struct xenbus_device *dev,
77 grant_ref_t *gnt_refs, unsigned int nr_grefs,
79 int (*unmap)(struct xenbus_device *dev, void *vaddr);
82 static const struct xenbus_ring_ops *ring_ops __read_mostly;
84 const char *xenbus_strstate(enum xenbus_state state)
86 static const char *const name[] = {
87 [ XenbusStateUnknown ] = "Unknown",
88 [ XenbusStateInitialising ] = "Initialising",
89 [ XenbusStateInitWait ] = "InitWait",
90 [ XenbusStateInitialised ] = "Initialised",
91 [ XenbusStateConnected ] = "Connected",
92 [ XenbusStateClosing ] = "Closing",
93 [ XenbusStateClosed ] = "Closed",
94 [XenbusStateReconfiguring] = "Reconfiguring",
95 [XenbusStateReconfigured] = "Reconfigured",
97 return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
99 EXPORT_SYMBOL_GPL(xenbus_strstate);
102 * xenbus_watch_path - register a watch
103 * @dev: xenbus device
104 * @path: path to watch
105 * @watch: watch to register
106 * @callback: callback to register
108 * Register a @watch on the given path, using the given xenbus_watch structure
109 * for storage, and the given @callback function as the callback. Return 0 on
110 * success, or -errno on error. On success, the given @path will be saved as
111 * @watch->node, and remains the caller's to free. On error, @watch->node will
112 * be NULL, the device will switch to %XenbusStateClosing, and the error will
113 * be saved in the store.
115 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
116 struct xenbus_watch *watch,
117 void (*callback)(struct xenbus_watch *,
118 const char *, const char *))
123 watch->callback = callback;
125 err = register_xenbus_watch(watch);
129 watch->callback = NULL;
130 xenbus_dev_fatal(dev, err, "adding watch on %s", path);
135 EXPORT_SYMBOL_GPL(xenbus_watch_path);
139 * xenbus_watch_pathfmt - register a watch on a sprintf-formatted path
140 * @dev: xenbus device
141 * @watch: watch to register
142 * @callback: callback to register
143 * @pathfmt: format of path to watch
145 * Register a watch on the given @path, using the given xenbus_watch
146 * structure for storage, and the given @callback function as the callback.
147 * Return 0 on success, or -errno on error. On success, the watched path
148 * (@path/@path2) will be saved as @watch->node, and becomes the caller's to
149 * kfree(). On error, watch->node will be NULL, so the caller has nothing to
150 * free, the device will switch to %XenbusStateClosing, and the error will be
151 * saved in the store.
153 int xenbus_watch_pathfmt(struct xenbus_device *dev,
154 struct xenbus_watch *watch,
155 void (*callback)(struct xenbus_watch *,
156 const char *, const char *),
157 const char *pathfmt, ...)
163 va_start(ap, pathfmt);
164 path = kvasprintf(GFP_NOIO | __GFP_HIGH, pathfmt, ap);
168 xenbus_dev_fatal(dev, -ENOMEM, "allocating path for watch");
171 err = xenbus_watch_path(dev, path, watch, callback);
177 EXPORT_SYMBOL_GPL(xenbus_watch_pathfmt);
179 static void xenbus_switch_fatal(struct xenbus_device *, int, int,
183 __xenbus_switch_state(struct xenbus_device *dev,
184 enum xenbus_state state, int depth)
186 /* We check whether the state is currently set to the given value, and
187 if not, then the state is set. We don't want to unconditionally
188 write the given state, because we don't want to fire watches
189 unnecessarily. Furthermore, if the node has gone, we don't write
190 to it, as the device will be tearing down, and we don't want to
191 resurrect that directory.
193 Note that, because of this cached value of our state, this
194 function will not take a caller's Xenstore transaction
195 (something it was trying to in the past) because dev->state
196 would not get reset if the transaction was aborted.
199 struct xenbus_transaction xbt;
203 if (state == dev->state)
209 err = xenbus_transaction_start(&xbt);
211 xenbus_switch_fatal(dev, depth, err, "starting transaction");
215 err = xenbus_scanf(xbt, dev->nodename, "state", "%d", ¤t_state);
219 err = xenbus_printf(xbt, dev->nodename, "state", "%d", state);
221 xenbus_switch_fatal(dev, depth, err, "writing new state");
227 err = xenbus_transaction_end(xbt, abort);
229 if (err == -EAGAIN && !abort)
231 xenbus_switch_fatal(dev, depth, err, "ending transaction");
239 * xenbus_switch_state
240 * @dev: xenbus device
243 * Advertise in the store a change of the given driver to the given new_state.
244 * Return 0 on success, or -errno on error. On error, the device will switch
245 * to XenbusStateClosing, and the error will be saved in the store.
247 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
249 return __xenbus_switch_state(dev, state, 0);
252 EXPORT_SYMBOL_GPL(xenbus_switch_state);
254 int xenbus_frontend_closed(struct xenbus_device *dev)
256 xenbus_switch_state(dev, XenbusStateClosed);
257 complete(&dev->down);
260 EXPORT_SYMBOL_GPL(xenbus_frontend_closed);
262 static void xenbus_va_dev_error(struct xenbus_device *dev, int err,
263 const char *fmt, va_list ap)
269 #define PRINTF_BUFFER_SIZE 4096
271 printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
275 len = sprintf(printf_buffer, "%i ", -err);
276 vsnprintf(printf_buffer + len, PRINTF_BUFFER_SIZE - len, fmt, ap);
278 dev_err(&dev->dev, "%s\n", printf_buffer);
280 path_buffer = kasprintf(GFP_KERNEL, "error/%s", dev->nodename);
282 xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer);
284 kfree(printf_buffer);
290 * @dev: xenbus device
291 * @err: error to report
292 * @fmt: error message format
294 * Report the given negative errno into the store, along with the given
297 void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, ...)
302 xenbus_va_dev_error(dev, err, fmt, ap);
305 EXPORT_SYMBOL_GPL(xenbus_dev_error);
309 * @dev: xenbus device
310 * @err: error to report
311 * @fmt: error message format
313 * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
314 * xenbus_switch_state(dev, XenbusStateClosing) to schedule an orderly
315 * closedown of this driver and its peer.
318 void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...)
323 xenbus_va_dev_error(dev, err, fmt, ap);
326 xenbus_switch_state(dev, XenbusStateClosing);
328 EXPORT_SYMBOL_GPL(xenbus_dev_fatal);
331 * Equivalent to xenbus_dev_fatal(dev, err, fmt, args), but helps
332 * avoiding recursion within xenbus_switch_state.
334 static void xenbus_switch_fatal(struct xenbus_device *dev, int depth, int err,
335 const char *fmt, ...)
340 xenbus_va_dev_error(dev, err, fmt, ap);
344 __xenbus_switch_state(dev, XenbusStateClosing, 1);
349 * @dev: xenbus device
350 * @vaddr: starting virtual address of the ring
351 * @nr_pages: number of pages to be granted
352 * @grefs: grant reference array to be filled in
354 * Grant access to the given @vaddr to the peer of the given device.
355 * Then fill in @grefs with grant references. Return 0 on success, or
356 * -errno on error. On error, the device will switch to
357 * XenbusStateClosing, and the error will be saved in the store.
359 int xenbus_grant_ring(struct xenbus_device *dev, void *vaddr,
360 unsigned int nr_pages, grant_ref_t *grefs)
365 for (i = 0; i < nr_pages; i++) {
366 err = gnttab_grant_foreign_access(dev->otherend_id,
367 virt_to_gfn(vaddr), 0);
369 xenbus_dev_fatal(dev, err,
370 "granting access to ring page");
375 vaddr = vaddr + XEN_PAGE_SIZE;
381 for (j = 0; j < i; j++)
382 gnttab_end_foreign_access_ref(grefs[j], 0);
385 EXPORT_SYMBOL_GPL(xenbus_grant_ring);
389 * Allocate an event channel for the given xenbus_device, assigning the newly
390 * created local port to *port. Return 0 on success, or -errno on error. On
391 * error, the device will switch to XenbusStateClosing, and the error will be
392 * saved in the store.
394 int xenbus_alloc_evtchn(struct xenbus_device *dev, evtchn_port_t *port)
396 struct evtchn_alloc_unbound alloc_unbound;
399 alloc_unbound.dom = DOMID_SELF;
400 alloc_unbound.remote_dom = dev->otherend_id;
402 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
405 xenbus_dev_fatal(dev, err, "allocating event channel");
407 *port = alloc_unbound.port;
411 EXPORT_SYMBOL_GPL(xenbus_alloc_evtchn);
415 * Free an existing event channel. Returns 0 on success or -errno on error.
417 int xenbus_free_evtchn(struct xenbus_device *dev, evtchn_port_t port)
419 struct evtchn_close close;
424 err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
426 xenbus_dev_error(dev, err, "freeing event channel %u", port);
430 EXPORT_SYMBOL_GPL(xenbus_free_evtchn);
434 * xenbus_map_ring_valloc
435 * @dev: xenbus device
436 * @gnt_refs: grant reference array
437 * @nr_grefs: number of grant references
438 * @vaddr: pointer to address to be filled out by mapping
440 * Map @nr_grefs pages of memory into this domain from another
441 * domain's grant table. xenbus_map_ring_valloc allocates @nr_grefs
442 * pages of virtual address space, maps the pages to that address, and
443 * sets *vaddr to that address. Returns 0 on success, and GNTST_*
444 * (see xen/include/interface/grant_table.h) or -ENOMEM / -EINVAL on
445 * error. If an error is returned, device will switch to
446 * XenbusStateClosing and the error message will be saved in XenStore.
448 int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs,
449 unsigned int nr_grefs, void **vaddr)
453 err = ring_ops->map(dev, gnt_refs, nr_grefs, vaddr);
454 /* Some hypervisors are buggy and can return 1. */
456 err = GNTST_general_error;
460 EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
462 /* N.B. sizeof(phys_addr_t) doesn't always equal to sizeof(unsigned
463 * long), e.g. 32-on-64. Caller is responsible for preparing the
464 * right array to feed into this function */
465 static int __xenbus_map_ring(struct xenbus_device *dev,
466 grant_ref_t *gnt_refs,
467 unsigned int nr_grefs,
468 grant_handle_t *handles,
473 struct gnttab_map_grant_ref map[XENBUS_MAX_RING_GRANTS];
474 struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
476 int err = GNTST_okay;
478 if (nr_grefs > XENBUS_MAX_RING_GRANTS)
481 for (i = 0; i < nr_grefs; i++) {
482 memset(&map[i], 0, sizeof(map[i]));
483 gnttab_set_map_op(&map[i], addrs[i], flags, gnt_refs[i],
485 handles[i] = INVALID_GRANT_HANDLE;
488 gnttab_batch_map(map, i);
490 for (i = 0; i < nr_grefs; i++) {
491 if (map[i].status != GNTST_okay) {
493 xenbus_dev_fatal(dev, map[i].status,
494 "mapping in shared page %d from domain %d",
495 gnt_refs[i], dev->otherend_id);
498 handles[i] = map[i].handle;
504 for (i = j = 0; i < nr_grefs; i++) {
505 if (handles[i] != INVALID_GRANT_HANDLE) {
506 memset(&unmap[j], 0, sizeof(unmap[j]));
507 gnttab_set_unmap_op(&unmap[j], (phys_addr_t)addrs[i],
508 GNTMAP_host_map, handles[i]);
513 if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, j))
517 for (i = 0; i < j; i++) {
518 if (unmap[i].status != GNTST_okay) {
529 * @dev: xenbus device
530 * @handles: grant handle array
531 * @nr_handles: number of handles in the array
532 * @vaddrs: addresses to unmap
534 * Unmap memory in this domain that was imported from another domain.
535 * Returns 0 on success and returns GNTST_* on error
536 * (see xen/include/interface/grant_table.h).
538 static int xenbus_unmap_ring(struct xenbus_device *dev, grant_handle_t *handles,
539 unsigned int nr_handles, unsigned long *vaddrs)
541 struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
545 if (nr_handles > XENBUS_MAX_RING_GRANTS)
548 for (i = 0; i < nr_handles; i++)
549 gnttab_set_unmap_op(&unmap[i], vaddrs[i],
550 GNTMAP_host_map, handles[i]);
552 if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, i))
556 for (i = 0; i < nr_handles; i++) {
557 if (unmap[i].status != GNTST_okay) {
558 xenbus_dev_error(dev, unmap[i].status,
559 "unmapping page at handle %d error %d",
560 handles[i], unmap[i].status);
561 err = unmap[i].status;
569 struct map_ring_valloc_hvm
573 /* Why do we need two arrays? See comment of __xenbus_map_ring */
574 phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS];
575 unsigned long addrs[XENBUS_MAX_RING_GRANTS];
578 static void xenbus_map_ring_setup_grant_hvm(unsigned long gfn,
579 unsigned int goffset,
583 struct map_ring_valloc_hvm *info = data;
584 unsigned long vaddr = (unsigned long)gfn_to_virt(gfn);
586 info->phys_addrs[info->idx] = vaddr;
587 info->addrs[info->idx] = vaddr;
592 static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
593 grant_ref_t *gnt_ref,
594 unsigned int nr_grefs,
597 struct xenbus_map_node *node;
601 struct map_ring_valloc_hvm info = {
604 unsigned int nr_pages = XENBUS_PAGES(nr_grefs);
606 if (nr_grefs > XENBUS_MAX_RING_GRANTS)
611 node = kzalloc(sizeof(*node), GFP_KERNEL);
615 err = alloc_xenballooned_pages(nr_pages, node->hvm.pages);
619 gnttab_foreach_grant(node->hvm.pages, nr_grefs,
620 xenbus_map_ring_setup_grant_hvm,
623 err = __xenbus_map_ring(dev, gnt_ref, nr_grefs, node->handles,
624 info.phys_addrs, GNTMAP_host_map, &leaked);
625 node->nr_handles = nr_grefs;
628 goto out_free_ballooned_pages;
630 addr = vmap(node->hvm.pages, nr_pages, VM_MAP | VM_IOREMAP,
634 goto out_xenbus_unmap_ring;
637 node->hvm.addr = addr;
639 spin_lock(&xenbus_valloc_lock);
640 list_add(&node->next, &xenbus_valloc_pages);
641 spin_unlock(&xenbus_valloc_lock);
646 out_xenbus_unmap_ring:
648 xenbus_unmap_ring(dev, node->handles, nr_grefs, info.addrs);
650 pr_alert("leaking %p size %u page(s)",
652 out_free_ballooned_pages:
654 free_xenballooned_pages(nr_pages, node->hvm.pages);
661 * xenbus_unmap_ring_vfree
662 * @dev: xenbus device
663 * @vaddr: addr to unmap
665 * Based on Rusty Russell's skeleton driver's unmap_page.
666 * Unmap a page of memory in this domain that was imported from another domain.
667 * Use xenbus_unmap_ring_vfree if you mapped in your memory with
668 * xenbus_map_ring_valloc (it will free the virtual address space).
669 * Returns 0 on success and returns GNTST_* on error
670 * (see xen/include/interface/grant_table.h).
672 int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr)
674 return ring_ops->unmap(dev, vaddr);
676 EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
679 static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,
680 grant_ref_t *gnt_refs,
681 unsigned int nr_grefs,
684 struct xenbus_map_node *node;
685 struct vm_struct *area;
686 pte_t *ptes[XENBUS_MAX_RING_GRANTS];
687 phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS];
688 int err = GNTST_okay;
694 if (nr_grefs > XENBUS_MAX_RING_GRANTS)
697 node = kzalloc(sizeof(*node), GFP_KERNEL);
701 area = alloc_vm_area(XEN_PAGE_SIZE * nr_grefs, ptes);
707 for (i = 0; i < nr_grefs; i++)
708 phys_addrs[i] = arbitrary_virt_to_machine(ptes[i]).maddr;
710 err = __xenbus_map_ring(dev, gnt_refs, nr_grefs, node->handles,
712 GNTMAP_host_map | GNTMAP_contains_pte,
717 node->nr_handles = nr_grefs;
718 node->pv.area = area;
720 spin_lock(&xenbus_valloc_lock);
721 list_add(&node->next, &xenbus_valloc_pages);
722 spin_unlock(&xenbus_valloc_lock);
731 pr_alert("leaking VM area %p size %u page(s)", area, nr_grefs);
737 static int xenbus_unmap_ring_vfree_pv(struct xenbus_device *dev, void *vaddr)
739 struct xenbus_map_node *node;
740 struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
746 spin_lock(&xenbus_valloc_lock);
747 list_for_each_entry(node, &xenbus_valloc_pages, next) {
748 if (node->pv.area->addr == vaddr) {
749 list_del(&node->next);
755 spin_unlock(&xenbus_valloc_lock);
758 xenbus_dev_error(dev, -ENOENT,
759 "can't find mapped virtual address %p", vaddr);
760 return GNTST_bad_virt_addr;
763 for (i = 0; i < node->nr_handles; i++) {
766 memset(&unmap[i], 0, sizeof(unmap[i]));
767 addr = (unsigned long)vaddr + (XEN_PAGE_SIZE * i);
768 unmap[i].host_addr = arbitrary_virt_to_machine(
769 lookup_address(addr, &level)).maddr;
770 unmap[i].dev_bus_addr = 0;
771 unmap[i].handle = node->handles[i];
774 if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, i))
779 for (i = 0; i < node->nr_handles; i++) {
780 if (unmap[i].status != GNTST_okay) {
782 xenbus_dev_error(dev, unmap[i].status,
783 "unmapping page at handle %d error %d",
784 node->handles[i], unmap[i].status);
785 err = unmap[i].status;
791 free_vm_area(node->pv.area);
793 pr_alert("leaking VM area %p size %u page(s)",
794 node->pv.area, node->nr_handles);
800 static const struct xenbus_ring_ops ring_ops_pv = {
801 .map = xenbus_map_ring_valloc_pv,
802 .unmap = xenbus_unmap_ring_vfree_pv,
806 struct unmap_ring_vfree_hvm
809 unsigned long addrs[XENBUS_MAX_RING_GRANTS];
812 static void xenbus_unmap_ring_setup_grant_hvm(unsigned long gfn,
813 unsigned int goffset,
817 struct unmap_ring_vfree_hvm *info = data;
819 info->addrs[info->idx] = (unsigned long)gfn_to_virt(gfn);
824 static int xenbus_unmap_ring_vfree_hvm(struct xenbus_device *dev, void *vaddr)
827 struct xenbus_map_node *node;
829 struct unmap_ring_vfree_hvm info = {
832 unsigned int nr_pages;
834 spin_lock(&xenbus_valloc_lock);
835 list_for_each_entry(node, &xenbus_valloc_pages, next) {
836 addr = node->hvm.addr;
838 list_del(&node->next);
844 spin_unlock(&xenbus_valloc_lock);
847 xenbus_dev_error(dev, -ENOENT,
848 "can't find mapped virtual address %p", vaddr);
849 return GNTST_bad_virt_addr;
852 nr_pages = XENBUS_PAGES(node->nr_handles);
854 gnttab_foreach_grant(node->hvm.pages, node->nr_handles,
855 xenbus_unmap_ring_setup_grant_hvm,
858 rv = xenbus_unmap_ring(dev, node->handles, node->nr_handles,
862 free_xenballooned_pages(nr_pages, node->hvm.pages);
865 WARN(1, "Leaking %p, size %u page(s)\n", vaddr, nr_pages);
872 * xenbus_read_driver_state
873 * @path: path for driver
875 * Return the state of the driver rooted at the given store path, or
876 * XenbusStateUnknown if no state can be read.
878 enum xenbus_state xenbus_read_driver_state(const char *path)
880 enum xenbus_state result;
881 int err = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
883 result = XenbusStateUnknown;
887 EXPORT_SYMBOL_GPL(xenbus_read_driver_state);
889 static const struct xenbus_ring_ops ring_ops_hvm = {
890 .map = xenbus_map_ring_valloc_hvm,
891 .unmap = xenbus_unmap_ring_vfree_hvm,
894 void __init xenbus_ring_ops_init(void)
897 if (!xen_feature(XENFEAT_auto_translated_physmap))
898 ring_ops = &ring_ops_pv;
901 ring_ops = &ring_ops_hvm;