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 68 int xen_store_evtchn; 69 EXPORT_SYMBOL_GPL(xen_store_evtchn); 70 71 struct xenstore_domain_interface *xen_store_interface; 72 EXPORT_SYMBOL_GPL(xen_store_interface); 73 74 enum xenstore_init xen_store_domain_type; 75 EXPORT_SYMBOL_GPL(xen_store_domain_type); 76 77 static unsigned long xen_store_gfn; 78 79 static BLOCKING_NOTIFIER_HEAD(xenstore_chain); 80 81 /* If something in array of ids matches this device, return it. */ 82 static const struct xenbus_device_id * 83 match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev) 84 { 85 for (; *arr->devicetype != '\0'; arr++) { 86 if (!strcmp(arr->devicetype, dev->devicetype)) 87 return arr; 88 } 89 return NULL; 90 } 91 92 int xenbus_match(struct device *_dev, struct device_driver *_drv) 93 { 94 struct xenbus_driver *drv = to_xenbus_driver(_drv); 95 96 if (!drv->ids) 97 return 0; 98 99 return match_device(drv->ids, to_xenbus_device(_dev)) != NULL; 100 } 101 EXPORT_SYMBOL_GPL(xenbus_match); 102 103 104 static void free_otherend_details(struct xenbus_device *dev) 105 { 106 kfree(dev->otherend); 107 dev->otherend = NULL; 108 } 109 110 111 static void free_otherend_watch(struct xenbus_device *dev) 112 { 113 if (dev->otherend_watch.node) { 114 unregister_xenbus_watch(&dev->otherend_watch); 115 kfree(dev->otherend_watch.node); 116 dev->otherend_watch.node = NULL; 117 } 118 } 119 120 121 static int talk_to_otherend(struct xenbus_device *dev) 122 { 123 struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver); 124 125 free_otherend_watch(dev); 126 free_otherend_details(dev); 127 128 return drv->read_otherend_details(dev); 129 } 130 131 132 133 static int watch_otherend(struct xenbus_device *dev) 134 { 135 struct xen_bus_type *bus = 136 container_of(dev->dev.bus, struct xen_bus_type, bus); 137 138 return xenbus_watch_pathfmt(dev, &dev->otherend_watch, 139 bus->otherend_will_handle, 140 bus->otherend_changed, 141 "%s/%s", dev->otherend, "state"); 142 } 143 144 145 int xenbus_read_otherend_details(struct xenbus_device *xendev, 146 char *id_node, char *path_node) 147 { 148 int err = xenbus_gather(XBT_NIL, xendev->nodename, 149 id_node, "%i", &xendev->otherend_id, 150 path_node, NULL, &xendev->otherend, 151 NULL); 152 if (err) { 153 xenbus_dev_fatal(xendev, err, 154 "reading other end details from %s", 155 xendev->nodename); 156 return err; 157 } 158 if (strlen(xendev->otherend) == 0 || 159 !xenbus_exists(XBT_NIL, xendev->otherend, "")) { 160 xenbus_dev_fatal(xendev, -ENOENT, 161 "unable to read other end from %s. " 162 "missing or inaccessible.", 163 xendev->nodename); 164 free_otherend_details(xendev); 165 return -ENOENT; 166 } 167 168 return 0; 169 } 170 EXPORT_SYMBOL_GPL(xenbus_read_otherend_details); 171 172 void xenbus_otherend_changed(struct xenbus_watch *watch, 173 const char *path, const char *token, 174 int ignore_on_shutdown) 175 { 176 struct xenbus_device *dev = 177 container_of(watch, struct xenbus_device, otherend_watch); 178 struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver); 179 enum xenbus_state state; 180 181 /* Protect us against watches firing on old details when the otherend 182 details change, say immediately after a resume. */ 183 if (!dev->otherend || 184 strncmp(dev->otherend, path, strlen(dev->otherend))) { 185 dev_dbg(&dev->dev, "Ignoring watch at %s\n", path); 186 return; 187 } 188 189 state = xenbus_read_driver_state(dev->otherend); 190 191 dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n", 192 state, xenbus_strstate(state), dev->otherend_watch.node, path); 193 194 /* 195 * Ignore xenbus transitions during shutdown. This prevents us doing 196 * work that can fail e.g., when the rootfs is gone. 197 */ 198 if (system_state > SYSTEM_RUNNING) { 199 if (ignore_on_shutdown && (state == XenbusStateClosing)) 200 xenbus_frontend_closed(dev); 201 return; 202 } 203 204 if (drv->otherend_changed) 205 drv->otherend_changed(dev, state); 206 } 207 EXPORT_SYMBOL_GPL(xenbus_otherend_changed); 208 209 #define XENBUS_SHOW_STAT(name) \ 210 static ssize_t show_##name(struct device *_dev, \ 211 struct device_attribute *attr, \ 212 char *buf) \ 213 { \ 214 struct xenbus_device *dev = to_xenbus_device(_dev); \ 215 \ 216 return sprintf(buf, "%d\n", atomic_read(&dev->name)); \ 217 } \ 218 static DEVICE_ATTR(name, 0444, show_##name, NULL) 219 220 XENBUS_SHOW_STAT(event_channels); 221 XENBUS_SHOW_STAT(events); 222 XENBUS_SHOW_STAT(spurious_events); 223 XENBUS_SHOW_STAT(jiffies_eoi_delayed); 224 225 static ssize_t show_spurious_threshold(struct device *_dev, 226 struct device_attribute *attr, 227 char *buf) 228 { 229 struct xenbus_device *dev = to_xenbus_device(_dev); 230 231 return sprintf(buf, "%d\n", dev->spurious_threshold); 232 } 233 234 static ssize_t set_spurious_threshold(struct device *_dev, 235 struct device_attribute *attr, 236 const char *buf, size_t count) 237 { 238 struct xenbus_device *dev = to_xenbus_device(_dev); 239 unsigned int val; 240 ssize_t ret; 241 242 ret = kstrtouint(buf, 0, &val); 243 if (ret) 244 return ret; 245 246 dev->spurious_threshold = val; 247 248 return count; 249 } 250 251 static DEVICE_ATTR(spurious_threshold, 0644, show_spurious_threshold, 252 set_spurious_threshold); 253 254 static struct attribute *xenbus_attrs[] = { 255 &dev_attr_event_channels.attr, 256 &dev_attr_events.attr, 257 &dev_attr_spurious_events.attr, 258 &dev_attr_jiffies_eoi_delayed.attr, 259 &dev_attr_spurious_threshold.attr, 260 NULL 261 }; 262 263 static const struct attribute_group xenbus_group = { 264 .name = "xenbus", 265 .attrs = xenbus_attrs, 266 }; 267 268 int xenbus_dev_probe(struct device *_dev) 269 { 270 struct xenbus_device *dev = to_xenbus_device(_dev); 271 struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); 272 const struct xenbus_device_id *id; 273 int err; 274 275 DPRINTK("%s", dev->nodename); 276 277 if (!drv->probe) { 278 err = -ENODEV; 279 goto fail; 280 } 281 282 id = match_device(drv->ids, dev); 283 if (!id) { 284 err = -ENODEV; 285 goto fail; 286 } 287 288 err = talk_to_otherend(dev); 289 if (err) { 290 dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n", 291 dev->nodename); 292 return err; 293 } 294 295 if (!try_module_get(drv->driver.owner)) { 296 dev_warn(&dev->dev, "failed to acquire module reference on '%s'\n", 297 drv->driver.name); 298 err = -ESRCH; 299 goto fail; 300 } 301 302 down(&dev->reclaim_sem); 303 err = drv->probe(dev, id); 304 up(&dev->reclaim_sem); 305 if (err) 306 goto fail_put; 307 308 err = watch_otherend(dev); 309 if (err) { 310 dev_warn(&dev->dev, "watch_otherend on %s failed.\n", 311 dev->nodename); 312 return err; 313 } 314 315 dev->spurious_threshold = 1; 316 if (sysfs_create_group(&dev->dev.kobj, &xenbus_group)) 317 dev_warn(&dev->dev, "sysfs_create_group on %s failed.\n", 318 dev->nodename); 319 320 return 0; 321 fail_put: 322 module_put(drv->driver.owner); 323 fail: 324 xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename); 325 return err; 326 } 327 EXPORT_SYMBOL_GPL(xenbus_dev_probe); 328 329 int xenbus_dev_remove(struct device *_dev) 330 { 331 struct xenbus_device *dev = to_xenbus_device(_dev); 332 struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); 333 334 DPRINTK("%s", dev->nodename); 335 336 sysfs_remove_group(&dev->dev.kobj, &xenbus_group); 337 338 free_otherend_watch(dev); 339 340 if (drv->remove) { 341 down(&dev->reclaim_sem); 342 drv->remove(dev); 343 up(&dev->reclaim_sem); 344 } 345 346 module_put(drv->driver.owner); 347 348 free_otherend_details(dev); 349 350 /* 351 * If the toolstack has forced the device state to closing then set 352 * the state to closed now to allow it to be cleaned up. 353 * Similarly, if the driver does not support re-bind, set the 354 * closed. 355 */ 356 if (!drv->allow_rebind || 357 xenbus_read_driver_state(dev->nodename) == XenbusStateClosing) 358 xenbus_switch_state(dev, XenbusStateClosed); 359 360 return 0; 361 } 362 EXPORT_SYMBOL_GPL(xenbus_dev_remove); 363 364 int xenbus_register_driver_common(struct xenbus_driver *drv, 365 struct xen_bus_type *bus, 366 struct module *owner, const char *mod_name) 367 { 368 drv->driver.name = drv->name ? drv->name : drv->ids[0].devicetype; 369 drv->driver.bus = &bus->bus; 370 drv->driver.owner = owner; 371 drv->driver.mod_name = mod_name; 372 373 return driver_register(&drv->driver); 374 } 375 EXPORT_SYMBOL_GPL(xenbus_register_driver_common); 376 377 void xenbus_unregister_driver(struct xenbus_driver *drv) 378 { 379 driver_unregister(&drv->driver); 380 } 381 EXPORT_SYMBOL_GPL(xenbus_unregister_driver); 382 383 struct xb_find_info { 384 struct xenbus_device *dev; 385 const char *nodename; 386 }; 387 388 static int cmp_dev(struct device *dev, void *data) 389 { 390 struct xenbus_device *xendev = to_xenbus_device(dev); 391 struct xb_find_info *info = data; 392 393 if (!strcmp(xendev->nodename, info->nodename)) { 394 info->dev = xendev; 395 get_device(dev); 396 return 1; 397 } 398 return 0; 399 } 400 401 static struct xenbus_device *xenbus_device_find(const char *nodename, 402 struct bus_type *bus) 403 { 404 struct xb_find_info info = { .dev = NULL, .nodename = nodename }; 405 406 bus_for_each_dev(bus, NULL, &info, cmp_dev); 407 return info.dev; 408 } 409 410 static int cleanup_dev(struct device *dev, void *data) 411 { 412 struct xenbus_device *xendev = to_xenbus_device(dev); 413 struct xb_find_info *info = data; 414 int len = strlen(info->nodename); 415 416 DPRINTK("%s", info->nodename); 417 418 /* Match the info->nodename path, or any subdirectory of that path. */ 419 if (strncmp(xendev->nodename, info->nodename, len)) 420 return 0; 421 422 /* If the node name is longer, ensure it really is a subdirectory. */ 423 if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/')) 424 return 0; 425 426 info->dev = xendev; 427 get_device(dev); 428 return 1; 429 } 430 431 static void xenbus_cleanup_devices(const char *path, struct bus_type *bus) 432 { 433 struct xb_find_info info = { .nodename = path }; 434 435 do { 436 info.dev = NULL; 437 bus_for_each_dev(bus, NULL, &info, cleanup_dev); 438 if (info.dev) { 439 device_unregister(&info.dev->dev); 440 put_device(&info.dev->dev); 441 } 442 } while (info.dev); 443 } 444 445 static void xenbus_dev_release(struct device *dev) 446 { 447 if (dev) 448 kfree(to_xenbus_device(dev)); 449 } 450 451 static ssize_t nodename_show(struct device *dev, 452 struct device_attribute *attr, char *buf) 453 { 454 return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename); 455 } 456 static DEVICE_ATTR_RO(nodename); 457 458 static ssize_t devtype_show(struct device *dev, 459 struct device_attribute *attr, char *buf) 460 { 461 return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype); 462 } 463 static DEVICE_ATTR_RO(devtype); 464 465 static ssize_t modalias_show(struct device *dev, 466 struct device_attribute *attr, char *buf) 467 { 468 return sprintf(buf, "%s:%s\n", dev->bus->name, 469 to_xenbus_device(dev)->devicetype); 470 } 471 static DEVICE_ATTR_RO(modalias); 472 473 static ssize_t state_show(struct device *dev, 474 struct device_attribute *attr, char *buf) 475 { 476 return sprintf(buf, "%s\n", 477 xenbus_strstate(to_xenbus_device(dev)->state)); 478 } 479 static DEVICE_ATTR_RO(state); 480 481 static struct attribute *xenbus_dev_attrs[] = { 482 &dev_attr_nodename.attr, 483 &dev_attr_devtype.attr, 484 &dev_attr_modalias.attr, 485 &dev_attr_state.attr, 486 NULL, 487 }; 488 489 static const struct attribute_group xenbus_dev_group = { 490 .attrs = xenbus_dev_attrs, 491 }; 492 493 const struct attribute_group *xenbus_dev_groups[] = { 494 &xenbus_dev_group, 495 NULL, 496 }; 497 EXPORT_SYMBOL_GPL(xenbus_dev_groups); 498 499 int xenbus_probe_node(struct xen_bus_type *bus, 500 const char *type, 501 const char *nodename) 502 { 503 char devname[XEN_BUS_ID_SIZE]; 504 int err; 505 struct xenbus_device *xendev; 506 size_t stringlen; 507 char *tmpstring; 508 509 enum xenbus_state state = xenbus_read_driver_state(nodename); 510 511 if (state != XenbusStateInitialising) { 512 /* Device is not new, so ignore it. This can happen if a 513 device is going away after switching to Closed. */ 514 return 0; 515 } 516 517 stringlen = strlen(nodename) + 1 + strlen(type) + 1; 518 xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL); 519 if (!xendev) 520 return -ENOMEM; 521 522 xendev->state = XenbusStateInitialising; 523 524 /* Copy the strings into the extra space. */ 525 526 tmpstring = (char *)(xendev + 1); 527 strcpy(tmpstring, nodename); 528 xendev->nodename = tmpstring; 529 530 tmpstring += strlen(tmpstring) + 1; 531 strcpy(tmpstring, type); 532 xendev->devicetype = tmpstring; 533 init_completion(&xendev->down); 534 535 xendev->dev.bus = &bus->bus; 536 xendev->dev.release = xenbus_dev_release; 537 538 err = bus->get_bus_id(devname, xendev->nodename); 539 if (err) 540 goto fail; 541 542 dev_set_name(&xendev->dev, "%s", devname); 543 sema_init(&xendev->reclaim_sem, 1); 544 545 /* Register with generic device framework. */ 546 err = device_register(&xendev->dev); 547 if (err) { 548 put_device(&xendev->dev); 549 xendev = NULL; 550 goto fail; 551 } 552 553 return 0; 554 fail: 555 kfree(xendev); 556 return err; 557 } 558 EXPORT_SYMBOL_GPL(xenbus_probe_node); 559 560 static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type) 561 { 562 int err = 0; 563 char **dir; 564 unsigned int dir_n = 0; 565 int i; 566 567 dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n); 568 if (IS_ERR(dir)) 569 return PTR_ERR(dir); 570 571 for (i = 0; i < dir_n; i++) { 572 err = bus->probe(bus, type, dir[i]); 573 if (err) 574 break; 575 } 576 577 kfree(dir); 578 return err; 579 } 580 581 int xenbus_probe_devices(struct xen_bus_type *bus) 582 { 583 int err = 0; 584 char **dir; 585 unsigned int i, dir_n; 586 587 dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n); 588 if (IS_ERR(dir)) 589 return PTR_ERR(dir); 590 591 for (i = 0; i < dir_n; i++) { 592 err = xenbus_probe_device_type(bus, dir[i]); 593 if (err) 594 break; 595 } 596 597 kfree(dir); 598 return err; 599 } 600 EXPORT_SYMBOL_GPL(xenbus_probe_devices); 601 602 static unsigned int char_count(const char *str, char c) 603 { 604 unsigned int i, ret = 0; 605 606 for (i = 0; str[i]; i++) 607 if (str[i] == c) 608 ret++; 609 return ret; 610 } 611 612 static int strsep_len(const char *str, char c, unsigned int len) 613 { 614 unsigned int i; 615 616 for (i = 0; str[i]; i++) 617 if (str[i] == c) { 618 if (len == 0) 619 return i; 620 len--; 621 } 622 return (len == 0) ? i : -ERANGE; 623 } 624 625 void xenbus_dev_changed(const char *node, struct xen_bus_type *bus) 626 { 627 int exists, rootlen; 628 struct xenbus_device *dev; 629 char type[XEN_BUS_ID_SIZE]; 630 const char *p, *root; 631 632 if (char_count(node, '/') < 2) 633 return; 634 635 exists = xenbus_exists(XBT_NIL, node, ""); 636 if (!exists) { 637 xenbus_cleanup_devices(node, &bus->bus); 638 return; 639 } 640 641 /* backend/<type>/... or device/<type>/... */ 642 p = strchr(node, '/') + 1; 643 snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p); 644 type[XEN_BUS_ID_SIZE-1] = '\0'; 645 646 rootlen = strsep_len(node, '/', bus->levels); 647 if (rootlen < 0) 648 return; 649 root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node); 650 if (!root) 651 return; 652 653 dev = xenbus_device_find(root, &bus->bus); 654 if (!dev) 655 xenbus_probe_node(bus, type, root); 656 else 657 put_device(&dev->dev); 658 659 kfree(root); 660 } 661 EXPORT_SYMBOL_GPL(xenbus_dev_changed); 662 663 int xenbus_dev_suspend(struct device *dev) 664 { 665 int err = 0; 666 struct xenbus_driver *drv; 667 struct xenbus_device *xdev 668 = container_of(dev, struct xenbus_device, dev); 669 670 DPRINTK("%s", xdev->nodename); 671 672 if (dev->driver == NULL) 673 return 0; 674 drv = to_xenbus_driver(dev->driver); 675 if (drv->suspend) 676 err = drv->suspend(xdev); 677 if (err) 678 dev_warn(dev, "suspend failed: %i\n", err); 679 return 0; 680 } 681 EXPORT_SYMBOL_GPL(xenbus_dev_suspend); 682 683 int xenbus_dev_resume(struct device *dev) 684 { 685 int err; 686 struct xenbus_driver *drv; 687 struct xenbus_device *xdev 688 = container_of(dev, struct xenbus_device, dev); 689 690 DPRINTK("%s", xdev->nodename); 691 692 if (dev->driver == NULL) 693 return 0; 694 drv = to_xenbus_driver(dev->driver); 695 err = talk_to_otherend(xdev); 696 if (err) { 697 dev_warn(dev, "resume (talk_to_otherend) failed: %i\n", err); 698 return err; 699 } 700 701 xdev->state = XenbusStateInitialising; 702 703 if (drv->resume) { 704 err = drv->resume(xdev); 705 if (err) { 706 dev_warn(dev, "resume failed: %i\n", err); 707 return err; 708 } 709 } 710 711 err = watch_otherend(xdev); 712 if (err) { 713 dev_warn(dev, "resume (watch_otherend) failed: %d\n", err); 714 return err; 715 } 716 717 return 0; 718 } 719 EXPORT_SYMBOL_GPL(xenbus_dev_resume); 720 721 int xenbus_dev_cancel(struct device *dev) 722 { 723 /* Do nothing */ 724 DPRINTK("cancel"); 725 return 0; 726 } 727 EXPORT_SYMBOL_GPL(xenbus_dev_cancel); 728 729 /* A flag to determine if xenstored is 'ready' (i.e. has started) */ 730 int xenstored_ready; 731 732 733 int register_xenstore_notifier(struct notifier_block *nb) 734 { 735 int ret = 0; 736 737 if (xenstored_ready > 0) 738 ret = nb->notifier_call(nb, 0, NULL); 739 else 740 blocking_notifier_chain_register(&xenstore_chain, nb); 741 742 return ret; 743 } 744 EXPORT_SYMBOL_GPL(register_xenstore_notifier); 745 746 void unregister_xenstore_notifier(struct notifier_block *nb) 747 { 748 blocking_notifier_chain_unregister(&xenstore_chain, nb); 749 } 750 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier); 751 752 static void xenbus_probe(void) 753 { 754 xenstored_ready = 1; 755 756 /* 757 * In the HVM case, xenbus_init() deferred its call to 758 * xs_init() in case callbacks were not operational yet. 759 * So do it now. 760 */ 761 if (xen_store_domain_type == XS_HVM) 762 xs_init(); 763 764 /* Notify others that xenstore is up */ 765 blocking_notifier_call_chain(&xenstore_chain, 0, NULL); 766 } 767 768 /* 769 * Returns true when XenStore init must be deferred in order to 770 * allow the PCI platform device to be initialised, before we 771 * can actually have event channel interrupts working. 772 */ 773 static bool xs_hvm_defer_init_for_callback(void) 774 { 775 #ifdef CONFIG_XEN_PVHVM 776 return xen_store_domain_type == XS_HVM && 777 !xen_have_vector_callback; 778 #else 779 return false; 780 #endif 781 } 782 783 static int xenbus_probe_thread(void *unused) 784 { 785 DEFINE_WAIT(w); 786 787 /* 788 * We actually just want to wait for *any* trigger of xb_waitq, 789 * and run xenbus_probe() the moment it occurs. 790 */ 791 prepare_to_wait(&xb_waitq, &w, TASK_INTERRUPTIBLE); 792 schedule(); 793 finish_wait(&xb_waitq, &w); 794 795 DPRINTK("probing"); 796 xenbus_probe(); 797 return 0; 798 } 799 800 static int __init xenbus_probe_initcall(void) 801 { 802 /* 803 * Probe XenBus here in the XS_PV case, and also XS_HVM unless we 804 * need to wait for the platform PCI device to come up. 805 */ 806 if (xen_store_domain_type == XS_PV || 807 (xen_store_domain_type == XS_HVM && 808 !xs_hvm_defer_init_for_callback())) 809 xenbus_probe(); 810 811 /* 812 * For XS_LOCAL, spawn a thread which will wait for xenstored 813 * or a xenstore-stubdom to be started, then probe. It will be 814 * triggered when communication starts happening, by waiting 815 * on xb_waitq. 816 */ 817 if (xen_store_domain_type == XS_LOCAL) { 818 struct task_struct *probe_task; 819 820 probe_task = kthread_run(xenbus_probe_thread, NULL, 821 "xenbus_probe"); 822 if (IS_ERR(probe_task)) 823 return PTR_ERR(probe_task); 824 } 825 return 0; 826 } 827 device_initcall(xenbus_probe_initcall); 828 829 int xen_set_callback_via(uint64_t via) 830 { 831 struct xen_hvm_param a; 832 int ret; 833 834 a.domid = DOMID_SELF; 835 a.index = HVM_PARAM_CALLBACK_IRQ; 836 a.value = via; 837 838 ret = HYPERVISOR_hvm_op(HVMOP_set_param, &a); 839 if (ret) 840 return ret; 841 842 /* 843 * If xenbus_probe_initcall() deferred the xenbus_probe() 844 * due to the callback not functioning yet, we can do it now. 845 */ 846 if (!xenstored_ready && xs_hvm_defer_init_for_callback()) 847 xenbus_probe(); 848 849 return ret; 850 } 851 EXPORT_SYMBOL_GPL(xen_set_callback_via); 852 853 /* Set up event channel for xenstored which is run as a local process 854 * (this is normally used only in dom0) 855 */ 856 static int __init xenstored_local_init(void) 857 { 858 int err = -ENOMEM; 859 unsigned long page = 0; 860 struct evtchn_alloc_unbound alloc_unbound; 861 862 /* Allocate Xenstore page */ 863 page = get_zeroed_page(GFP_KERNEL); 864 if (!page) 865 goto out_err; 866 867 xen_store_gfn = virt_to_gfn((void *)page); 868 869 /* Next allocate a local port which xenstored can bind to */ 870 alloc_unbound.dom = DOMID_SELF; 871 alloc_unbound.remote_dom = DOMID_SELF; 872 873 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, 874 &alloc_unbound); 875 if (err == -ENOSYS) 876 goto out_err; 877 878 BUG_ON(err); 879 xen_store_evtchn = alloc_unbound.port; 880 881 return 0; 882 883 out_err: 884 if (page != 0) 885 free_page(page); 886 return err; 887 } 888 889 static int xenbus_resume_cb(struct notifier_block *nb, 890 unsigned long action, void *data) 891 { 892 int err = 0; 893 894 if (xen_hvm_domain()) { 895 uint64_t v = 0; 896 897 err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); 898 if (!err && v) 899 xen_store_evtchn = v; 900 else 901 pr_warn("Cannot update xenstore event channel: %d\n", 902 err); 903 } else 904 xen_store_evtchn = xen_start_info->store_evtchn; 905 906 return err; 907 } 908 909 static struct notifier_block xenbus_resume_nb = { 910 .notifier_call = xenbus_resume_cb, 911 }; 912 913 static int __init xenbus_init(void) 914 { 915 int err = 0; 916 uint64_t v = 0; 917 xen_store_domain_type = XS_UNKNOWN; 918 919 if (!xen_domain()) 920 return -ENODEV; 921 922 xenbus_ring_ops_init(); 923 924 if (xen_pv_domain()) 925 xen_store_domain_type = XS_PV; 926 if (xen_hvm_domain()) 927 xen_store_domain_type = XS_HVM; 928 if (xen_hvm_domain() && xen_initial_domain()) 929 xen_store_domain_type = XS_LOCAL; 930 if (xen_pv_domain() && !xen_start_info->store_evtchn) 931 xen_store_domain_type = XS_LOCAL; 932 if (xen_pv_domain() && xen_start_info->store_evtchn) 933 xenstored_ready = 1; 934 935 switch (xen_store_domain_type) { 936 case XS_LOCAL: 937 err = xenstored_local_init(); 938 if (err) 939 goto out_error; 940 xen_store_interface = gfn_to_virt(xen_store_gfn); 941 break; 942 case XS_PV: 943 xen_store_evtchn = xen_start_info->store_evtchn; 944 xen_store_gfn = xen_start_info->store_mfn; 945 xen_store_interface = gfn_to_virt(xen_store_gfn); 946 break; 947 case XS_HVM: 948 err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); 949 if (err) 950 goto out_error; 951 xen_store_evtchn = (int)v; 952 err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v); 953 if (err) 954 goto out_error; 955 xen_store_gfn = (unsigned long)v; 956 xen_store_interface = 957 xen_remap(xen_store_gfn << XEN_PAGE_SHIFT, 958 XEN_PAGE_SIZE); 959 break; 960 default: 961 pr_warn("Xenstore state unknown\n"); 962 break; 963 } 964 965 /* 966 * HVM domains may not have a functional callback yet. In that 967 * case let xs_init() be called from xenbus_probe(), which will 968 * get invoked at an appropriate time. 969 */ 970 if (xen_store_domain_type != XS_HVM) { 971 err = xs_init(); 972 if (err) { 973 pr_warn("Error initializing xenstore comms: %i\n", err); 974 goto out_error; 975 } 976 } 977 978 if ((xen_store_domain_type != XS_LOCAL) && 979 (xen_store_domain_type != XS_UNKNOWN)) 980 xen_resume_notifier_register(&xenbus_resume_nb); 981 982 #ifdef CONFIG_XEN_COMPAT_XENFS 983 /* 984 * Create xenfs mountpoint in /proc for compatibility with 985 * utilities that expect to find "xenbus" under "/proc/xen". 986 */ 987 proc_create_mount_point("xen"); 988 #endif 989 990 out_error: 991 return err; 992 } 993 994 postcore_initcall(xenbus_init); 995 996 MODULE_LICENSE("GPL"); 997