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 int xenbus_dev_probe(struct device *_dev) 210 { 211 struct xenbus_device *dev = to_xenbus_device(_dev); 212 struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); 213 const struct xenbus_device_id *id; 214 int err; 215 216 DPRINTK("%s", dev->nodename); 217 218 if (!drv->probe) { 219 err = -ENODEV; 220 goto fail; 221 } 222 223 id = match_device(drv->ids, dev); 224 if (!id) { 225 err = -ENODEV; 226 goto fail; 227 } 228 229 err = talk_to_otherend(dev); 230 if (err) { 231 dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n", 232 dev->nodename); 233 return err; 234 } 235 236 if (!try_module_get(drv->driver.owner)) { 237 dev_warn(&dev->dev, "failed to acquire module reference on '%s'\n", 238 drv->driver.name); 239 err = -ESRCH; 240 goto fail; 241 } 242 243 down(&dev->reclaim_sem); 244 err = drv->probe(dev, id); 245 up(&dev->reclaim_sem); 246 if (err) 247 goto fail_put; 248 249 err = watch_otherend(dev); 250 if (err) { 251 dev_warn(&dev->dev, "watch_otherend on %s failed.\n", 252 dev->nodename); 253 return err; 254 } 255 256 return 0; 257 fail_put: 258 module_put(drv->driver.owner); 259 fail: 260 xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename); 261 return err; 262 } 263 EXPORT_SYMBOL_GPL(xenbus_dev_probe); 264 265 int xenbus_dev_remove(struct device *_dev) 266 { 267 struct xenbus_device *dev = to_xenbus_device(_dev); 268 struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); 269 270 DPRINTK("%s", dev->nodename); 271 272 free_otherend_watch(dev); 273 274 if (drv->remove) { 275 down(&dev->reclaim_sem); 276 drv->remove(dev); 277 up(&dev->reclaim_sem); 278 } 279 280 module_put(drv->driver.owner); 281 282 free_otherend_details(dev); 283 284 /* 285 * If the toolstack has forced the device state to closing then set 286 * the state to closed now to allow it to be cleaned up. 287 * Similarly, if the driver does not support re-bind, set the 288 * closed. 289 */ 290 if (!drv->allow_rebind || 291 xenbus_read_driver_state(dev->nodename) == XenbusStateClosing) 292 xenbus_switch_state(dev, XenbusStateClosed); 293 294 return 0; 295 } 296 EXPORT_SYMBOL_GPL(xenbus_dev_remove); 297 298 int xenbus_register_driver_common(struct xenbus_driver *drv, 299 struct xen_bus_type *bus, 300 struct module *owner, const char *mod_name) 301 { 302 drv->driver.name = drv->name ? drv->name : drv->ids[0].devicetype; 303 drv->driver.bus = &bus->bus; 304 drv->driver.owner = owner; 305 drv->driver.mod_name = mod_name; 306 307 return driver_register(&drv->driver); 308 } 309 EXPORT_SYMBOL_GPL(xenbus_register_driver_common); 310 311 void xenbus_unregister_driver(struct xenbus_driver *drv) 312 { 313 driver_unregister(&drv->driver); 314 } 315 EXPORT_SYMBOL_GPL(xenbus_unregister_driver); 316 317 struct xb_find_info { 318 struct xenbus_device *dev; 319 const char *nodename; 320 }; 321 322 static int cmp_dev(struct device *dev, void *data) 323 { 324 struct xenbus_device *xendev = to_xenbus_device(dev); 325 struct xb_find_info *info = data; 326 327 if (!strcmp(xendev->nodename, info->nodename)) { 328 info->dev = xendev; 329 get_device(dev); 330 return 1; 331 } 332 return 0; 333 } 334 335 static struct xenbus_device *xenbus_device_find(const char *nodename, 336 struct bus_type *bus) 337 { 338 struct xb_find_info info = { .dev = NULL, .nodename = nodename }; 339 340 bus_for_each_dev(bus, NULL, &info, cmp_dev); 341 return info.dev; 342 } 343 344 static int cleanup_dev(struct device *dev, void *data) 345 { 346 struct xenbus_device *xendev = to_xenbus_device(dev); 347 struct xb_find_info *info = data; 348 int len = strlen(info->nodename); 349 350 DPRINTK("%s", info->nodename); 351 352 /* Match the info->nodename path, or any subdirectory of that path. */ 353 if (strncmp(xendev->nodename, info->nodename, len)) 354 return 0; 355 356 /* If the node name is longer, ensure it really is a subdirectory. */ 357 if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/')) 358 return 0; 359 360 info->dev = xendev; 361 get_device(dev); 362 return 1; 363 } 364 365 static void xenbus_cleanup_devices(const char *path, struct bus_type *bus) 366 { 367 struct xb_find_info info = { .nodename = path }; 368 369 do { 370 info.dev = NULL; 371 bus_for_each_dev(bus, NULL, &info, cleanup_dev); 372 if (info.dev) { 373 device_unregister(&info.dev->dev); 374 put_device(&info.dev->dev); 375 } 376 } while (info.dev); 377 } 378 379 static void xenbus_dev_release(struct device *dev) 380 { 381 if (dev) 382 kfree(to_xenbus_device(dev)); 383 } 384 385 static ssize_t nodename_show(struct device *dev, 386 struct device_attribute *attr, char *buf) 387 { 388 return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename); 389 } 390 static DEVICE_ATTR_RO(nodename); 391 392 static ssize_t devtype_show(struct device *dev, 393 struct device_attribute *attr, char *buf) 394 { 395 return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype); 396 } 397 static DEVICE_ATTR_RO(devtype); 398 399 static ssize_t modalias_show(struct device *dev, 400 struct device_attribute *attr, char *buf) 401 { 402 return sprintf(buf, "%s:%s\n", dev->bus->name, 403 to_xenbus_device(dev)->devicetype); 404 } 405 static DEVICE_ATTR_RO(modalias); 406 407 static ssize_t state_show(struct device *dev, 408 struct device_attribute *attr, char *buf) 409 { 410 return sprintf(buf, "%s\n", 411 xenbus_strstate(to_xenbus_device(dev)->state)); 412 } 413 static DEVICE_ATTR_RO(state); 414 415 static struct attribute *xenbus_dev_attrs[] = { 416 &dev_attr_nodename.attr, 417 &dev_attr_devtype.attr, 418 &dev_attr_modalias.attr, 419 &dev_attr_state.attr, 420 NULL, 421 }; 422 423 static const struct attribute_group xenbus_dev_group = { 424 .attrs = xenbus_dev_attrs, 425 }; 426 427 const struct attribute_group *xenbus_dev_groups[] = { 428 &xenbus_dev_group, 429 NULL, 430 }; 431 EXPORT_SYMBOL_GPL(xenbus_dev_groups); 432 433 int xenbus_probe_node(struct xen_bus_type *bus, 434 const char *type, 435 const char *nodename) 436 { 437 char devname[XEN_BUS_ID_SIZE]; 438 int err; 439 struct xenbus_device *xendev; 440 size_t stringlen; 441 char *tmpstring; 442 443 enum xenbus_state state = xenbus_read_driver_state(nodename); 444 445 if (state != XenbusStateInitialising) { 446 /* Device is not new, so ignore it. This can happen if a 447 device is going away after switching to Closed. */ 448 return 0; 449 } 450 451 stringlen = strlen(nodename) + 1 + strlen(type) + 1; 452 xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL); 453 if (!xendev) 454 return -ENOMEM; 455 456 xendev->state = XenbusStateInitialising; 457 458 /* Copy the strings into the extra space. */ 459 460 tmpstring = (char *)(xendev + 1); 461 strcpy(tmpstring, nodename); 462 xendev->nodename = tmpstring; 463 464 tmpstring += strlen(tmpstring) + 1; 465 strcpy(tmpstring, type); 466 xendev->devicetype = tmpstring; 467 init_completion(&xendev->down); 468 469 xendev->dev.bus = &bus->bus; 470 xendev->dev.release = xenbus_dev_release; 471 472 err = bus->get_bus_id(devname, xendev->nodename); 473 if (err) 474 goto fail; 475 476 dev_set_name(&xendev->dev, "%s", devname); 477 sema_init(&xendev->reclaim_sem, 1); 478 479 /* Register with generic device framework. */ 480 err = device_register(&xendev->dev); 481 if (err) { 482 put_device(&xendev->dev); 483 xendev = NULL; 484 goto fail; 485 } 486 487 return 0; 488 fail: 489 kfree(xendev); 490 return err; 491 } 492 EXPORT_SYMBOL_GPL(xenbus_probe_node); 493 494 static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type) 495 { 496 int err = 0; 497 char **dir; 498 unsigned int dir_n = 0; 499 int i; 500 501 dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n); 502 if (IS_ERR(dir)) 503 return PTR_ERR(dir); 504 505 for (i = 0; i < dir_n; i++) { 506 err = bus->probe(bus, type, dir[i]); 507 if (err) 508 break; 509 } 510 511 kfree(dir); 512 return err; 513 } 514 515 int xenbus_probe_devices(struct xen_bus_type *bus) 516 { 517 int err = 0; 518 char **dir; 519 unsigned int i, dir_n; 520 521 dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n); 522 if (IS_ERR(dir)) 523 return PTR_ERR(dir); 524 525 for (i = 0; i < dir_n; i++) { 526 err = xenbus_probe_device_type(bus, dir[i]); 527 if (err) 528 break; 529 } 530 531 kfree(dir); 532 return err; 533 } 534 EXPORT_SYMBOL_GPL(xenbus_probe_devices); 535 536 static unsigned int char_count(const char *str, char c) 537 { 538 unsigned int i, ret = 0; 539 540 for (i = 0; str[i]; i++) 541 if (str[i] == c) 542 ret++; 543 return ret; 544 } 545 546 static int strsep_len(const char *str, char c, unsigned int len) 547 { 548 unsigned int i; 549 550 for (i = 0; str[i]; i++) 551 if (str[i] == c) { 552 if (len == 0) 553 return i; 554 len--; 555 } 556 return (len == 0) ? i : -ERANGE; 557 } 558 559 void xenbus_dev_changed(const char *node, struct xen_bus_type *bus) 560 { 561 int exists, rootlen; 562 struct xenbus_device *dev; 563 char type[XEN_BUS_ID_SIZE]; 564 const char *p, *root; 565 566 if (char_count(node, '/') < 2) 567 return; 568 569 exists = xenbus_exists(XBT_NIL, node, ""); 570 if (!exists) { 571 xenbus_cleanup_devices(node, &bus->bus); 572 return; 573 } 574 575 /* backend/<type>/... or device/<type>/... */ 576 p = strchr(node, '/') + 1; 577 snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p); 578 type[XEN_BUS_ID_SIZE-1] = '\0'; 579 580 rootlen = strsep_len(node, '/', bus->levels); 581 if (rootlen < 0) 582 return; 583 root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node); 584 if (!root) 585 return; 586 587 dev = xenbus_device_find(root, &bus->bus); 588 if (!dev) 589 xenbus_probe_node(bus, type, root); 590 else 591 put_device(&dev->dev); 592 593 kfree(root); 594 } 595 EXPORT_SYMBOL_GPL(xenbus_dev_changed); 596 597 int xenbus_dev_suspend(struct device *dev) 598 { 599 int err = 0; 600 struct xenbus_driver *drv; 601 struct xenbus_device *xdev 602 = container_of(dev, struct xenbus_device, dev); 603 604 DPRINTK("%s", xdev->nodename); 605 606 if (dev->driver == NULL) 607 return 0; 608 drv = to_xenbus_driver(dev->driver); 609 if (drv->suspend) 610 err = drv->suspend(xdev); 611 if (err) 612 dev_warn(dev, "suspend failed: %i\n", err); 613 return 0; 614 } 615 EXPORT_SYMBOL_GPL(xenbus_dev_suspend); 616 617 int xenbus_dev_resume(struct device *dev) 618 { 619 int err; 620 struct xenbus_driver *drv; 621 struct xenbus_device *xdev 622 = container_of(dev, struct xenbus_device, dev); 623 624 DPRINTK("%s", xdev->nodename); 625 626 if (dev->driver == NULL) 627 return 0; 628 drv = to_xenbus_driver(dev->driver); 629 err = talk_to_otherend(xdev); 630 if (err) { 631 dev_warn(dev, "resume (talk_to_otherend) failed: %i\n", err); 632 return err; 633 } 634 635 xdev->state = XenbusStateInitialising; 636 637 if (drv->resume) { 638 err = drv->resume(xdev); 639 if (err) { 640 dev_warn(dev, "resume failed: %i\n", err); 641 return err; 642 } 643 } 644 645 err = watch_otherend(xdev); 646 if (err) { 647 dev_warn(dev, "resume (watch_otherend) failed: %d\n", err); 648 return err; 649 } 650 651 return 0; 652 } 653 EXPORT_SYMBOL_GPL(xenbus_dev_resume); 654 655 int xenbus_dev_cancel(struct device *dev) 656 { 657 /* Do nothing */ 658 DPRINTK("cancel"); 659 return 0; 660 } 661 EXPORT_SYMBOL_GPL(xenbus_dev_cancel); 662 663 /* A flag to determine if xenstored is 'ready' (i.e. has started) */ 664 int xenstored_ready; 665 666 667 int register_xenstore_notifier(struct notifier_block *nb) 668 { 669 int ret = 0; 670 671 if (xenstored_ready > 0) 672 ret = nb->notifier_call(nb, 0, NULL); 673 else 674 blocking_notifier_chain_register(&xenstore_chain, nb); 675 676 return ret; 677 } 678 EXPORT_SYMBOL_GPL(register_xenstore_notifier); 679 680 void unregister_xenstore_notifier(struct notifier_block *nb) 681 { 682 blocking_notifier_chain_unregister(&xenstore_chain, nb); 683 } 684 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier); 685 686 void xenbus_probe(void) 687 { 688 xenstored_ready = 1; 689 690 /* 691 * In the HVM case, xenbus_init() deferred its call to 692 * xs_init() in case callbacks were not operational yet. 693 * So do it now. 694 */ 695 if (xen_store_domain_type == XS_HVM) 696 xs_init(); 697 698 /* Notify others that xenstore is up */ 699 blocking_notifier_call_chain(&xenstore_chain, 0, NULL); 700 } 701 702 /* 703 * Returns true when XenStore init must be deferred in order to 704 * allow the PCI platform device to be initialised, before we 705 * can actually have event channel interrupts working. 706 */ 707 static bool xs_hvm_defer_init_for_callback(void) 708 { 709 #ifdef CONFIG_XEN_PVHVM 710 return xen_store_domain_type == XS_HVM && 711 !xen_have_vector_callback; 712 #else 713 return false; 714 #endif 715 } 716 717 static int __init xenbus_probe_initcall(void) 718 { 719 /* 720 * Probe XenBus here in the XS_PV case, and also XS_HVM unless we 721 * need to wait for the platform PCI device to come up. 722 */ 723 if (xen_store_domain_type == XS_PV || 724 (xen_store_domain_type == XS_HVM && 725 !xs_hvm_defer_init_for_callback())) 726 xenbus_probe(); 727 728 return 0; 729 } 730 device_initcall(xenbus_probe_initcall); 731 732 int xen_set_callback_via(uint64_t via) 733 { 734 struct xen_hvm_param a; 735 int ret; 736 737 a.domid = DOMID_SELF; 738 a.index = HVM_PARAM_CALLBACK_IRQ; 739 a.value = via; 740 741 ret = HYPERVISOR_hvm_op(HVMOP_set_param, &a); 742 if (ret) 743 return ret; 744 745 /* 746 * If xenbus_probe_initcall() deferred the xenbus_probe() 747 * due to the callback not functioning yet, we can do it now. 748 */ 749 if (!xenstored_ready && xs_hvm_defer_init_for_callback()) 750 xenbus_probe(); 751 752 return ret; 753 } 754 EXPORT_SYMBOL_GPL(xen_set_callback_via); 755 756 /* Set up event channel for xenstored which is run as a local process 757 * (this is normally used only in dom0) 758 */ 759 static int __init xenstored_local_init(void) 760 { 761 int err = -ENOMEM; 762 unsigned long page = 0; 763 struct evtchn_alloc_unbound alloc_unbound; 764 765 /* Allocate Xenstore page */ 766 page = get_zeroed_page(GFP_KERNEL); 767 if (!page) 768 goto out_err; 769 770 xen_store_gfn = virt_to_gfn((void *)page); 771 772 /* Next allocate a local port which xenstored can bind to */ 773 alloc_unbound.dom = DOMID_SELF; 774 alloc_unbound.remote_dom = DOMID_SELF; 775 776 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, 777 &alloc_unbound); 778 if (err == -ENOSYS) 779 goto out_err; 780 781 BUG_ON(err); 782 xen_store_evtchn = alloc_unbound.port; 783 784 return 0; 785 786 out_err: 787 if (page != 0) 788 free_page(page); 789 return err; 790 } 791 792 static int xenbus_resume_cb(struct notifier_block *nb, 793 unsigned long action, void *data) 794 { 795 int err = 0; 796 797 if (xen_hvm_domain()) { 798 uint64_t v = 0; 799 800 err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); 801 if (!err && v) 802 xen_store_evtchn = v; 803 else 804 pr_warn("Cannot update xenstore event channel: %d\n", 805 err); 806 } else 807 xen_store_evtchn = xen_start_info->store_evtchn; 808 809 return err; 810 } 811 812 static struct notifier_block xenbus_resume_nb = { 813 .notifier_call = xenbus_resume_cb, 814 }; 815 816 static int __init xenbus_init(void) 817 { 818 int err = 0; 819 uint64_t v = 0; 820 xen_store_domain_type = XS_UNKNOWN; 821 822 if (!xen_domain()) 823 return -ENODEV; 824 825 xenbus_ring_ops_init(); 826 827 if (xen_pv_domain()) 828 xen_store_domain_type = XS_PV; 829 if (xen_hvm_domain()) 830 xen_store_domain_type = XS_HVM; 831 if (xen_hvm_domain() && xen_initial_domain()) 832 xen_store_domain_type = XS_LOCAL; 833 if (xen_pv_domain() && !xen_start_info->store_evtchn) 834 xen_store_domain_type = XS_LOCAL; 835 if (xen_pv_domain() && xen_start_info->store_evtchn) 836 xenstored_ready = 1; 837 838 switch (xen_store_domain_type) { 839 case XS_LOCAL: 840 err = xenstored_local_init(); 841 if (err) 842 goto out_error; 843 xen_store_interface = gfn_to_virt(xen_store_gfn); 844 break; 845 case XS_PV: 846 xen_store_evtchn = xen_start_info->store_evtchn; 847 xen_store_gfn = xen_start_info->store_mfn; 848 xen_store_interface = gfn_to_virt(xen_store_gfn); 849 break; 850 case XS_HVM: 851 err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); 852 if (err) 853 goto out_error; 854 xen_store_evtchn = (int)v; 855 err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v); 856 if (err) 857 goto out_error; 858 xen_store_gfn = (unsigned long)v; 859 xen_store_interface = 860 xen_remap(xen_store_gfn << XEN_PAGE_SHIFT, 861 XEN_PAGE_SIZE); 862 break; 863 default: 864 pr_warn("Xenstore state unknown\n"); 865 break; 866 } 867 868 /* 869 * HVM domains may not have a functional callback yet. In that 870 * case let xs_init() be called from xenbus_probe(), which will 871 * get invoked at an appropriate time. 872 */ 873 if (xen_store_domain_type != XS_HVM) { 874 err = xs_init(); 875 if (err) { 876 pr_warn("Error initializing xenstore comms: %i\n", err); 877 goto out_error; 878 } 879 } 880 881 if ((xen_store_domain_type != XS_LOCAL) && 882 (xen_store_domain_type != XS_UNKNOWN)) 883 xen_resume_notifier_register(&xenbus_resume_nb); 884 885 #ifdef CONFIG_XEN_COMPAT_XENFS 886 /* 887 * Create xenfs mountpoint in /proc for compatibility with 888 * utilities that expect to find "xenbus" under "/proc/xen". 889 */ 890 proc_create_mount_point("xen"); 891 #endif 892 893 out_error: 894 return err; 895 } 896 897 postcore_initcall(xenbus_init); 898 899 MODULE_LICENSE("GPL"); 900