1083 lines · c
1/******************************************************************************2 * Talks to Xen Store to figure out what devices we have.3 *4 * Copyright (C) 2005 Rusty Russell, IBM Corporation5 * Copyright (C) 2005 Mike Wray, Hewlett-Packard6 * Copyright (C) 2005, 2006 XenSource Ltd7 *8 * This program is free software; you can redistribute it and/or9 * modify it under the terms of the GNU General Public License version 210 * as published by the Free Software Foundation; or, when distributed11 * separately from the Linux kernel or incorporated into other12 * software packages, subject to the following license:13 *14 * Permission is hereby granted, free of charge, to any person obtaining a copy15 * of this source file (the "Software"), to deal in the Software without16 * 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 to19 * the following conditions:20 *21 * The above copyright notice and this permission notice shall be included in22 * all copies or substantial portions of the Software.23 *24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE27 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER28 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING29 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS30 * IN THE SOFTWARE.31 */32 33#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt34#define dev_fmt pr_fmt35 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>46#include <linux/proc_fs.h>47#include <linux/notifier.h>48#include <linux/kthread.h>49#include <linux/mutex.h>50#include <linux/io.h>51#include <linux/slab.h>52#include <linux/module.h>53 54#include <asm/page.h>55#include <asm/xen/hypervisor.h>56 57#include <xen/xen.h>58#include <xen/xenbus.h>59#include <xen/events.h>60#include <xen/xen-ops.h>61#include <xen/page.h>62 63#include <xen/hvm.h>64 65#include "xenbus.h"66 67 68static int xs_init_irq = -1;69int xen_store_evtchn;70EXPORT_SYMBOL_GPL(xen_store_evtchn);71 72struct xenstore_domain_interface *xen_store_interface;73EXPORT_SYMBOL_GPL(xen_store_interface);74 75#define XS_INTERFACE_READY \76 ((xen_store_interface != NULL) && \77 (xen_store_interface->connection == XENSTORE_CONNECTED))78 79enum xenstore_init xen_store_domain_type;80EXPORT_SYMBOL_GPL(xen_store_domain_type);81 82static unsigned long xen_store_gfn;83 84static BLOCKING_NOTIFIER_HEAD(xenstore_chain);85 86/* If something in array of ids matches this device, return it. */87static const struct xenbus_device_id *88match_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 97int xenbus_match(struct device *_dev, const struct device_driver *_drv)98{99 const struct xenbus_driver *drv = to_xenbus_driver(_drv);100 101 if (!drv->ids)102 return 0;103 104 return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;105}106EXPORT_SYMBOL_GPL(xenbus_match);107 108 109static void free_otherend_details(struct xenbus_device *dev)110{111 kfree(dev->otherend);112 dev->otherend = NULL;113}114 115 116static 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 126static 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 138static int watch_otherend(struct xenbus_device *dev)139{140 struct xen_bus_type *bus =141 container_of(dev->dev.bus, struct xen_bus_type, bus);142 143 return xenbus_watch_pathfmt(dev, &dev->otherend_watch,144 bus->otherend_will_handle,145 bus->otherend_changed,146 "%s/%s", dev->otherend, "state");147}148 149 150int xenbus_read_otherend_details(struct xenbus_device *xendev,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}175EXPORT_SYMBOL_GPL(xenbus_read_otherend_details);176 177void xenbus_otherend_changed(struct xenbus_watch *watch,178 const char *path, const char *token,179 int ignore_on_shutdown)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 otherend187 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);191 return;192 }193 194 state = xenbus_read_driver_state(dev->otherend);195 196 dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n",197 state, xenbus_strstate(state), dev->otherend_watch.node, path);198 199 /*200 * Ignore xenbus transitions during shutdown. This prevents us doing201 * work that can fail e.g., when the rootfs is gone.202 */203 if (system_state > SYSTEM_RUNNING) {204 if (ignore_on_shutdown && (state == XenbusStateClosing))205 xenbus_frontend_closed(dev);206 return;207 }208 209 if (drv->otherend_changed)210 drv->otherend_changed(dev, state);211}212EXPORT_SYMBOL_GPL(xenbus_otherend_changed);213 214#define XENBUS_SHOW_STAT(name) \215static ssize_t name##_show(struct device *_dev, \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} \223static DEVICE_ATTR_RO(name)224 225XENBUS_SHOW_STAT(event_channels);226XENBUS_SHOW_STAT(events);227XENBUS_SHOW_STAT(spurious_events);228XENBUS_SHOW_STAT(jiffies_eoi_delayed);229 230static ssize_t spurious_threshold_show(struct device *_dev,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 239static ssize_t spurious_threshold_store(struct device *_dev,240 struct device_attribute *attr,241 const char *buf, size_t count)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 256static DEVICE_ATTR_RW(spurious_threshold);257 258static 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 NULL265};266 267static const struct attribute_group xenbus_group = {268 .name = "xenbus",269 .attrs = xenbus_attrs,270};271 272int 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 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 306 down(&dev->reclaim_sem);307 err = drv->probe(dev, id);308 up(&dev->reclaim_sem);309 if (err)310 goto fail_put;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 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 324 return 0;325fail_put:326 module_put(drv->driver.owner);327fail:328 xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename);329 return err;330}331EXPORT_SYMBOL_GPL(xenbus_dev_probe);332 333void xenbus_dev_remove(struct device *_dev)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 340 sysfs_remove_group(&dev->dev.kobj, &xenbus_group);341 342 free_otherend_watch(dev);343 344 if (drv->remove) {345 down(&dev->reclaim_sem);346 drv->remove(dev);347 up(&dev->reclaim_sem);348 }349 350 module_put(drv->driver.owner);351 352 free_otherend_details(dev);353 354 /*355 * If the toolstack has forced the device state to closing then set356 * the state to closed now to allow it to be cleaned up.357 * Similarly, if the driver does not support re-bind, set the358 * closed.359 */360 if (!drv->allow_rebind ||361 xenbus_read_driver_state(dev->nodename) == XenbusStateClosing)362 xenbus_switch_state(dev, XenbusStateClosed);363}364EXPORT_SYMBOL_GPL(xenbus_dev_remove);365 366int xenbus_register_driver_common(struct xenbus_driver *drv,367 struct xen_bus_type *bus,368 struct module *owner, const char *mod_name)369{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;374 375 return driver_register(&drv->driver);376}377EXPORT_SYMBOL_GPL(xenbus_register_driver_common);378 379void xenbus_unregister_driver(struct xenbus_driver *drv)380{381 driver_unregister(&drv->driver);382}383EXPORT_SYMBOL_GPL(xenbus_unregister_driver);384 385struct xb_find_info {386 struct xenbus_device *dev;387 const char *nodename;388};389 390static 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 403static struct xenbus_device *xenbus_device_find(const char *nodename,404 struct bus_type *bus)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 412static 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 433static 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 447static void xenbus_dev_release(struct device *dev)448{449 if (dev)450 kfree(to_xenbus_device(dev));451}452 453static ssize_t nodename_show(struct device *dev,454 struct device_attribute *attr, char *buf)455{456 return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename);457}458static DEVICE_ATTR_RO(nodename);459 460static ssize_t devtype_show(struct device *dev,461 struct device_attribute *attr, char *buf)462{463 return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype);464}465static DEVICE_ATTR_RO(devtype);466 467static ssize_t modalias_show(struct device *dev,468 struct device_attribute *attr, char *buf)469{470 return sprintf(buf, "%s:%s\n", dev->bus->name,471 to_xenbus_device(dev)->devicetype);472}473static DEVICE_ATTR_RO(modalias);474 475static 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}481static DEVICE_ATTR_RO(state);482 483static 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,488 NULL,489};490 491static const struct attribute_group xenbus_dev_group = {492 .attrs = xenbus_dev_attrs,493};494 495const struct attribute_group *xenbus_dev_groups[] = {496 &xenbus_dev_group,497 NULL,498};499EXPORT_SYMBOL_GPL(xenbus_dev_groups);500 501int xenbus_probe_node(struct xen_bus_type *bus,502 const char *type,503 const char *nodename)504{505 char devname[XEN_BUS_ID_SIZE];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 a515 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 540 err = bus->get_bus_id(devname, xendev->nodename);541 if (err)542 goto fail;543 544 dev_set_name(&xendev->dev, "%s", devname);545 sema_init(&xendev->reclaim_sem, 1);546 547 /* Register with generic device framework. */548 err = device_register(&xendev->dev);549 if (err) {550 put_device(&xendev->dev);551 xendev = NULL;552 goto fail;553 }554 555 return 0;556fail:557 kfree(xendev);558 return err;559}560EXPORT_SYMBOL_GPL(xenbus_probe_node);561 562static 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);570 if (IS_ERR(dir))571 return PTR_ERR(dir);572 573 for (i = 0; i < dir_n; i++) {574 err = bus->probe(bus, type, dir[i]);575 if (err)576 break;577 }578 579 kfree(dir);580 return err;581}582 583int 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);590 if (IS_ERR(dir))591 return PTR_ERR(dir);592 593 for (i = 0; i < dir_n; i++) {594 err = xenbus_probe_device_type(bus, dir[i]);595 if (err)596 break;597 }598 599 kfree(dir);600 return err;601}602EXPORT_SYMBOL_GPL(xenbus_probe_devices);603 604static 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 614static 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 627void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)628{629 int exists, rootlen;630 struct xenbus_device *dev;631 char type[XEN_BUS_ID_SIZE];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;645 snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p);646 type[XEN_BUS_ID_SIZE-1] = '\0';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 else659 put_device(&dev->dev);660 661 kfree(root);662}663EXPORT_SYMBOL_GPL(xenbus_dev_changed);664 665int xenbus_dev_suspend(struct device *dev)666{667 int err = 0;668 struct xenbus_driver *drv;669 struct xenbus_device *xdev670 = container_of(dev, struct xenbus_device, dev);671 672 DPRINTK("%s", xdev->nodename);673 674 if (dev->driver == NULL)675 return 0;676 drv = to_xenbus_driver(dev->driver);677 if (drv->suspend)678 err = drv->suspend(xdev);679 if (err)680 dev_warn(dev, "suspend failed: %i\n", err);681 return 0;682}683EXPORT_SYMBOL_GPL(xenbus_dev_suspend);684 685int xenbus_dev_resume(struct device *dev)686{687 int err;688 struct xenbus_driver *drv;689 struct xenbus_device *xdev690 = container_of(dev, struct xenbus_device, dev);691 692 DPRINTK("%s", xdev->nodename);693 694 if (dev->driver == NULL)695 return 0;696 drv = to_xenbus_driver(dev->driver);697 err = talk_to_otherend(xdev);698 if (err) {699 dev_warn(dev, "resume (talk_to_otherend) failed: %i\n", err);700 return err;701 }702 703 xdev->state = XenbusStateInitialising;704 705 if (drv->resume) {706 err = drv->resume(xdev);707 if (err) {708 dev_warn(dev, "resume failed: %i\n", err);709 return err;710 }711 }712 713 err = watch_otherend(xdev);714 if (err) {715 dev_warn(dev, "resume (watch_otherend) failed: %d\n", err);716 return err;717 }718 719 return 0;720}721EXPORT_SYMBOL_GPL(xenbus_dev_resume);722 723int xenbus_dev_cancel(struct device *dev)724{725 /* Do nothing */726 DPRINTK("cancel");727 return 0;728}729EXPORT_SYMBOL_GPL(xenbus_dev_cancel);730 731/* A flag to determine if xenstored is 'ready' (i.e. has started) */732int xenstored_ready;733 734 735int register_xenstore_notifier(struct notifier_block *nb)736{737 int ret = 0;738 739 if (xenstored_ready > 0)740 ret = nb->notifier_call(nb, 0, NULL);741 else742 blocking_notifier_chain_register(&xenstore_chain, nb);743 744 return ret;745}746EXPORT_SYMBOL_GPL(register_xenstore_notifier);747 748void unregister_xenstore_notifier(struct notifier_block *nb)749{750 blocking_notifier_chain_unregister(&xenstore_chain, nb);751}752EXPORT_SYMBOL_GPL(unregister_xenstore_notifier);753 754static void xenbus_probe(void)755{756 xenstored_ready = 1;757 758 if (!xen_store_interface)759 xen_store_interface = memremap(xen_store_gfn << XEN_PAGE_SHIFT,760 XEN_PAGE_SIZE, MEMREMAP_WB);761 /*762 * Now it is safe to free the IRQ used for xenstore late763 * initialization. No need to unbind: it is about to be764 * bound again from xb_init_comms. Note that calling765 * unbind_from_irqhandler now would result in xen_evtchn_close()766 * being called and the event channel not being enabled again767 * afterwards, resulting in missed event notifications.768 */769 if (xs_init_irq >= 0)770 free_irq(xs_init_irq, &xb_waitq);771 772 /*773 * In the HVM case, xenbus_init() deferred its call to774 * 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 780 /* Notify others that xenstore is up */781 blocking_notifier_call_chain(&xenstore_chain, 0, NULL);782}783 784/*785 * Returns true when XenStore init must be deferred in order to786 * allow the PCI platform device to be initialised, before we787 * can actually have event channel interrupts working.788 */789static bool xs_hvm_defer_init_for_callback(void)790{791#ifdef CONFIG_XEN_PVHVM792 return xen_store_domain_type == XS_HVM &&793 !xen_have_vector_callback;794#else795 return false;796#endif797}798 799static 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 816static int __init xenbus_probe_initcall(void)817{818 if (!xen_domain())819 return -ENODEV;820 821 /*822 * Probe XenBus here in the XS_PV case, and also XS_HVM unless we823 * need to wait for the platform PCI device to come up or824 * xen_store_interface is not ready.825 */826 if (xen_store_domain_type == XS_PV ||827 (xen_store_domain_type == XS_HVM &&828 !xs_hvm_defer_init_for_callback() &&829 XS_INTERFACE_READY))830 xenbus_probe();831 832 /*833 * For XS_LOCAL or when xen_store_interface is not ready, spawn a834 * thread which will wait for xenstored or a xenstore-stubdom to be835 * started, then probe. It will be triggered when communication836 * starts happening, by waiting on xb_waitq.837 */838 if (xen_store_domain_type == XS_LOCAL || !XS_INTERFACE_READY) {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 }846 return 0;847}848device_initcall(xenbus_probe_initcall);849 850int 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}872EXPORT_SYMBOL_GPL(xen_set_callback_via);873 874/* Set up event channel for xenstored which is run as a local process875 * (this is normally used only in dom0)876 */877static int __init xenstored_local_init(void)878{879 int err = -ENOMEM;880 unsigned long page = 0;881 struct evtchn_alloc_unbound alloc_unbound;882 883 /* Allocate Xenstore page */884 page = get_zeroed_page(GFP_KERNEL);885 if (!page)886 goto out_err;887 888 xen_store_gfn = virt_to_gfn((void *)page);889 890 /* Next allocate a local port which xenstored can bind to */891 alloc_unbound.dom = DOMID_SELF;892 alloc_unbound.remote_dom = DOMID_SELF;893 894 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,895 &alloc_unbound);896 if (err == -ENOSYS)897 goto out_err;898 899 BUG_ON(err);900 xen_store_evtchn = alloc_unbound.port;901 902 return 0;903 904 out_err:905 if (page != 0)906 free_page(page);907 return err;908}909 910static 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()) {916 uint64_t v = 0;917 918 err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v);919 if (!err && v)920 xen_store_evtchn = v;921 else922 pr_warn("Cannot update xenstore event channel: %d\n",923 err);924 } else925 xen_store_evtchn = xen_start_info->store_evtchn;926 927 return err;928}929 930static struct notifier_block xenbus_resume_nb = {931 .notifier_call = xenbus_resume_cb,932};933 934static 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 948static int __init xenbus_init(void)949{950 int err;951 uint64_t v = 0;952 bool wait = false;953 xen_store_domain_type = XS_UNKNOWN;954 955 if (!xen_domain())956 return -ENODEV;957 958 xenbus_ring_ops_init();959 960 if (xen_pv_domain())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)969 xenstored_ready = 1;970 971 switch (xen_store_domain_type) {972 case XS_LOCAL:973 err = xenstored_local_init();974 if (err)975 goto out_error;976 xen_store_interface = gfn_to_virt(xen_store_gfn);977 break;978 case XS_PV: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);982 break;983 case XS_HVM: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;991 /*992 * Uninitialized hvm_params are zero and return no error.993 * Although it is theoretically possible to have994 * HVM_PARAM_STORE_PFN set to zero on purpose, in reality it is995 * not zero when valid. If zero, it means that Xenstore hasn't996 * been properly initialized. Instead of attempting to map a997 * wrong guest physical address return error.998 *999 * Also recognize all bits set as an invalid/uninitialized value.1000 */1001 if (!v) {1002 err = -ENOENT;1003 goto out_error;1004 }1005 if (v == ~0ULL) {1006 wait = true;1007 } else {1008 /* Avoid truncation on 32-bit. */1009#if BITS_PER_LONG == 321010 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 }1016#endif1017 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",1023 __func__, v);1024 err = -EINVAL;1025 goto out_error;1026 }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);1038 goto out_error;1039 }1040 1041 xs_init_irq = err;1042 }1043 break;1044 default:1045 pr_warn("Xenstore state unknown\n");1046 break;1047 }1048 1049 /*1050 * HVM domains may not have a functional callback yet. In that1051 * case let xs_init() be called from xenbus_probe(), which will1052 * 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 }1060 }1061 1062 if ((xen_store_domain_type != XS_LOCAL) &&1063 (xen_store_domain_type != XS_UNKNOWN))1064 xen_resume_notifier_register(&xenbus_resume_nb);1065 1066#ifdef CONFIG_XEN_COMPAT_XENFS1067 /*1068 * Create xenfs mountpoint in /proc for compatibility with1069 * utilities that expect to find "xenbus" under "/proc/xen".1070 */1071 proc_create_mount_point("xen");1072#endif1073 return 0;1074 1075out_error:1076 xen_store_domain_type = XS_UNKNOWN;1077 return err;1078}1079 1080postcore_initcall(xenbus_init);1081 1082MODULE_LICENSE("GPL");1083