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 33#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 34#define dev_fmt pr_fmt 35 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, struct device_driver *_drv) 98{ 99 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 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); 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 doing 201 * 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 NULL 265}; 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 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); 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 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 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 else 659 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 *xdev 670 = 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 *xdev 690 = 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 else 742 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 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) 770 free_irq(xs_init_irq, &xb_waitq); 771 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 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 to 786 * allow the PCI platform device to be initialised, before we 787 * can actually have event channel interrupts working. 788 */ 789static bool xs_hvm_defer_init_for_callback(void) 790{ 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} 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 we 823 * need to wait for the platform PCI device to come up or 824 * 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 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. 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 process 875 * (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 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 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 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 * 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 == 32 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 } 1016#endif 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", 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 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 } 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_XENFS 1067 /* 1068 * Create xenfs mountpoint in /proc for compatibility with 1069 * utilities that expect to find "xenbus" under "/proc/xen". 1070 */ 1071 proc_create_mount_point("xen"); 1072#endif 1073 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