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 35 #define DPRINTK(fmt, args...) \ 36 pr_debug("xenbus_probe (%s:%d) " fmt ".\n", \ 37 __func__, __LINE__, ##args) 38 39 #include <linux/kernel.h> 40 #include <linux/err.h> 41 #include <linux/string.h> 42 #include <linux/ctype.h> 43 #include <linux/fcntl.h> 44 #include <linux/mm.h> 45 #include <linux/proc_fs.h> 46 #include <linux/notifier.h> 47 #include <linux/kthread.h> 48 #include <linux/mutex.h> 49 #include <linux/io.h> 50 #include <linux/slab.h> 51 #include <linux/module.h> 52 53 #include <asm/page.h> 54 #include <asm/pgtable.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_comms.h" 66 #include "xenbus_probe.h" 67 68 69 int xen_store_evtchn; 70 EXPORT_SYMBOL_GPL(xen_store_evtchn); 71 72 struct xenstore_domain_interface *xen_store_interface; 73 EXPORT_SYMBOL_GPL(xen_store_interface); 74 75 enum xenstore_init xen_store_domain_type; 76 EXPORT_SYMBOL_GPL(xen_store_domain_type); 77 78 static unsigned long xen_store_gfn; 79 80 static BLOCKING_NOTIFIER_HEAD(xenstore_chain); 81 82 /* If something in array of ids matches this device, return it. */ 83 static const struct xenbus_device_id * 84 match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev) 85 { 86 for (; *arr->devicetype != '\0'; arr++) { 87 if (!strcmp(arr->devicetype, dev->devicetype)) 88 return arr; 89 } 90 return NULL; 91 } 92 93 int xenbus_match(struct device *_dev, struct device_driver *_drv) 94 { 95 struct xenbus_driver *drv = to_xenbus_driver(_drv); 96 97 if (!drv->ids) 98 return 0; 99 100 return match_device(drv->ids, to_xenbus_device(_dev)) != NULL; 101 } 102 EXPORT_SYMBOL_GPL(xenbus_match); 103 104 105 static void free_otherend_details(struct xenbus_device *dev) 106 { 107 kfree(dev->otherend); 108 dev->otherend = NULL; 109 } 110 111 112 static void free_otherend_watch(struct xenbus_device *dev) 113 { 114 if (dev->otherend_watch.node) { 115 unregister_xenbus_watch(&dev->otherend_watch); 116 kfree(dev->otherend_watch.node); 117 dev->otherend_watch.node = NULL; 118 } 119 } 120 121 122 static int talk_to_otherend(struct xenbus_device *dev) 123 { 124 struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver); 125 126 free_otherend_watch(dev); 127 free_otherend_details(dev); 128 129 return drv->read_otherend_details(dev); 130 } 131 132 133 134 static int watch_otherend(struct xenbus_device *dev) 135 { 136 struct xen_bus_type *bus = 137 container_of(dev->dev.bus, struct xen_bus_type, bus); 138 139 return xenbus_watch_pathfmt(dev, &dev->otherend_watch, 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 **vec, unsigned int len, 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, vec[XS_WATCH_PATH], 185 strlen(dev->otherend))) { 186 dev_dbg(&dev->dev, "Ignoring watch at %s\n", 187 vec[XS_WATCH_PATH]); 188 return; 189 } 190 191 state = xenbus_read_driver_state(dev->otherend); 192 193 dev_dbg(&dev->dev, "state is %d, (%s), %s, %s\n", 194 state, xenbus_strstate(state), dev->otherend_watch.node, 195 vec[XS_WATCH_PATH]); 196 197 /* 198 * Ignore xenbus transitions during shutdown. This prevents us doing 199 * work that can fail e.g., when the rootfs is gone. 200 */ 201 if (system_state > SYSTEM_RUNNING) { 202 if (ignore_on_shutdown && (state == XenbusStateClosing)) 203 xenbus_frontend_closed(dev); 204 return; 205 } 206 207 if (drv->otherend_changed) 208 drv->otherend_changed(dev, state); 209 } 210 EXPORT_SYMBOL_GPL(xenbus_otherend_changed); 211 212 int xenbus_dev_probe(struct device *_dev) 213 { 214 struct xenbus_device *dev = to_xenbus_device(_dev); 215 struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); 216 const struct xenbus_device_id *id; 217 int err; 218 219 DPRINTK("%s", dev->nodename); 220 221 if (!drv->probe) { 222 err = -ENODEV; 223 goto fail; 224 } 225 226 id = match_device(drv->ids, dev); 227 if (!id) { 228 err = -ENODEV; 229 goto fail; 230 } 231 232 err = talk_to_otherend(dev); 233 if (err) { 234 dev_warn(&dev->dev, "talk_to_otherend on %s failed.\n", 235 dev->nodename); 236 return err; 237 } 238 239 err = drv->probe(dev, id); 240 if (err) 241 goto fail; 242 243 err = watch_otherend(dev); 244 if (err) { 245 dev_warn(&dev->dev, "watch_otherend on %s failed.\n", 246 dev->nodename); 247 return err; 248 } 249 250 return 0; 251 fail: 252 xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename); 253 xenbus_switch_state(dev, XenbusStateClosed); 254 return err; 255 } 256 EXPORT_SYMBOL_GPL(xenbus_dev_probe); 257 258 int xenbus_dev_remove(struct device *_dev) 259 { 260 struct xenbus_device *dev = to_xenbus_device(_dev); 261 struct xenbus_driver *drv = to_xenbus_driver(_dev->driver); 262 263 DPRINTK("%s", dev->nodename); 264 265 free_otherend_watch(dev); 266 267 if (drv->remove) 268 drv->remove(dev); 269 270 free_otherend_details(dev); 271 272 xenbus_switch_state(dev, XenbusStateClosed); 273 return 0; 274 } 275 EXPORT_SYMBOL_GPL(xenbus_dev_remove); 276 277 void xenbus_dev_shutdown(struct device *_dev) 278 { 279 struct xenbus_device *dev = to_xenbus_device(_dev); 280 unsigned long timeout = 5*HZ; 281 282 DPRINTK("%s", dev->nodename); 283 284 get_device(&dev->dev); 285 if (dev->state != XenbusStateConnected) { 286 pr_info("%s: %s: %s != Connected, skipping\n", 287 __func__, dev->nodename, xenbus_strstate(dev->state)); 288 goto out; 289 } 290 xenbus_switch_state(dev, XenbusStateClosing); 291 timeout = wait_for_completion_timeout(&dev->down, timeout); 292 if (!timeout) 293 pr_info("%s: %s timeout closing device\n", 294 __func__, dev->nodename); 295 out: 296 put_device(&dev->dev); 297 } 298 EXPORT_SYMBOL_GPL(xenbus_dev_shutdown); 299 300 int xenbus_register_driver_common(struct xenbus_driver *drv, 301 struct xen_bus_type *bus, 302 struct module *owner, const char *mod_name) 303 { 304 drv->driver.name = drv->name ? drv->name : drv->ids[0].devicetype; 305 drv->driver.bus = &bus->bus; 306 drv->driver.owner = owner; 307 drv->driver.mod_name = mod_name; 308 309 return driver_register(&drv->driver); 310 } 311 EXPORT_SYMBOL_GPL(xenbus_register_driver_common); 312 313 void xenbus_unregister_driver(struct xenbus_driver *drv) 314 { 315 driver_unregister(&drv->driver); 316 } 317 EXPORT_SYMBOL_GPL(xenbus_unregister_driver); 318 319 struct xb_find_info { 320 struct xenbus_device *dev; 321 const char *nodename; 322 }; 323 324 static int cmp_dev(struct device *dev, void *data) 325 { 326 struct xenbus_device *xendev = to_xenbus_device(dev); 327 struct xb_find_info *info = data; 328 329 if (!strcmp(xendev->nodename, info->nodename)) { 330 info->dev = xendev; 331 get_device(dev); 332 return 1; 333 } 334 return 0; 335 } 336 337 static struct xenbus_device *xenbus_device_find(const char *nodename, 338 struct bus_type *bus) 339 { 340 struct xb_find_info info = { .dev = NULL, .nodename = nodename }; 341 342 bus_for_each_dev(bus, NULL, &info, cmp_dev); 343 return info.dev; 344 } 345 346 static int cleanup_dev(struct device *dev, void *data) 347 { 348 struct xenbus_device *xendev = to_xenbus_device(dev); 349 struct xb_find_info *info = data; 350 int len = strlen(info->nodename); 351 352 DPRINTK("%s", info->nodename); 353 354 /* Match the info->nodename path, or any subdirectory of that path. */ 355 if (strncmp(xendev->nodename, info->nodename, len)) 356 return 0; 357 358 /* If the node name is longer, ensure it really is a subdirectory. */ 359 if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/')) 360 return 0; 361 362 info->dev = xendev; 363 get_device(dev); 364 return 1; 365 } 366 367 static void xenbus_cleanup_devices(const char *path, struct bus_type *bus) 368 { 369 struct xb_find_info info = { .nodename = path }; 370 371 do { 372 info.dev = NULL; 373 bus_for_each_dev(bus, NULL, &info, cleanup_dev); 374 if (info.dev) { 375 device_unregister(&info.dev->dev); 376 put_device(&info.dev->dev); 377 } 378 } while (info.dev); 379 } 380 381 static void xenbus_dev_release(struct device *dev) 382 { 383 if (dev) 384 kfree(to_xenbus_device(dev)); 385 } 386 387 static ssize_t nodename_show(struct device *dev, 388 struct device_attribute *attr, char *buf) 389 { 390 return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename); 391 } 392 static DEVICE_ATTR_RO(nodename); 393 394 static ssize_t devtype_show(struct device *dev, 395 struct device_attribute *attr, char *buf) 396 { 397 return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype); 398 } 399 static DEVICE_ATTR_RO(devtype); 400 401 static ssize_t modalias_show(struct device *dev, 402 struct device_attribute *attr, char *buf) 403 { 404 return sprintf(buf, "%s:%s\n", dev->bus->name, 405 to_xenbus_device(dev)->devicetype); 406 } 407 static DEVICE_ATTR_RO(modalias); 408 409 static struct attribute *xenbus_dev_attrs[] = { 410 &dev_attr_nodename.attr, 411 &dev_attr_devtype.attr, 412 &dev_attr_modalias.attr, 413 NULL, 414 }; 415 416 static const struct attribute_group xenbus_dev_group = { 417 .attrs = xenbus_dev_attrs, 418 }; 419 420 const struct attribute_group *xenbus_dev_groups[] = { 421 &xenbus_dev_group, 422 NULL, 423 }; 424 EXPORT_SYMBOL_GPL(xenbus_dev_groups); 425 426 int xenbus_probe_node(struct xen_bus_type *bus, 427 const char *type, 428 const char *nodename) 429 { 430 char devname[XEN_BUS_ID_SIZE]; 431 int err; 432 struct xenbus_device *xendev; 433 size_t stringlen; 434 char *tmpstring; 435 436 enum xenbus_state state = xenbus_read_driver_state(nodename); 437 438 if (state != XenbusStateInitialising) { 439 /* Device is not new, so ignore it. This can happen if a 440 device is going away after switching to Closed. */ 441 return 0; 442 } 443 444 stringlen = strlen(nodename) + 1 + strlen(type) + 1; 445 xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL); 446 if (!xendev) 447 return -ENOMEM; 448 449 xendev->state = XenbusStateInitialising; 450 451 /* Copy the strings into the extra space. */ 452 453 tmpstring = (char *)(xendev + 1); 454 strcpy(tmpstring, nodename); 455 xendev->nodename = tmpstring; 456 457 tmpstring += strlen(tmpstring) + 1; 458 strcpy(tmpstring, type); 459 xendev->devicetype = tmpstring; 460 init_completion(&xendev->down); 461 462 xendev->dev.bus = &bus->bus; 463 xendev->dev.release = xenbus_dev_release; 464 465 err = bus->get_bus_id(devname, xendev->nodename); 466 if (err) 467 goto fail; 468 469 dev_set_name(&xendev->dev, "%s", devname); 470 471 /* Register with generic device framework. */ 472 err = device_register(&xendev->dev); 473 if (err) 474 goto fail; 475 476 return 0; 477 fail: 478 kfree(xendev); 479 return err; 480 } 481 EXPORT_SYMBOL_GPL(xenbus_probe_node); 482 483 static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type) 484 { 485 int err = 0; 486 char **dir; 487 unsigned int dir_n = 0; 488 int i; 489 490 dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n); 491 if (IS_ERR(dir)) 492 return PTR_ERR(dir); 493 494 for (i = 0; i < dir_n; i++) { 495 err = bus->probe(bus, type, dir[i]); 496 if (err) 497 break; 498 } 499 500 kfree(dir); 501 return err; 502 } 503 504 int xenbus_probe_devices(struct xen_bus_type *bus) 505 { 506 int err = 0; 507 char **dir; 508 unsigned int i, dir_n; 509 510 dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n); 511 if (IS_ERR(dir)) 512 return PTR_ERR(dir); 513 514 for (i = 0; i < dir_n; i++) { 515 err = xenbus_probe_device_type(bus, dir[i]); 516 if (err) 517 break; 518 } 519 520 kfree(dir); 521 return err; 522 } 523 EXPORT_SYMBOL_GPL(xenbus_probe_devices); 524 525 static unsigned int char_count(const char *str, char c) 526 { 527 unsigned int i, ret = 0; 528 529 for (i = 0; str[i]; i++) 530 if (str[i] == c) 531 ret++; 532 return ret; 533 } 534 535 static int strsep_len(const char *str, char c, unsigned int len) 536 { 537 unsigned int i; 538 539 for (i = 0; str[i]; i++) 540 if (str[i] == c) { 541 if (len == 0) 542 return i; 543 len--; 544 } 545 return (len == 0) ? i : -ERANGE; 546 } 547 548 void xenbus_dev_changed(const char *node, struct xen_bus_type *bus) 549 { 550 int exists, rootlen; 551 struct xenbus_device *dev; 552 char type[XEN_BUS_ID_SIZE]; 553 const char *p, *root; 554 555 if (char_count(node, '/') < 2) 556 return; 557 558 exists = xenbus_exists(XBT_NIL, node, ""); 559 if (!exists) { 560 xenbus_cleanup_devices(node, &bus->bus); 561 return; 562 } 563 564 /* backend/<type>/... or device/<type>/... */ 565 p = strchr(node, '/') + 1; 566 snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p); 567 type[XEN_BUS_ID_SIZE-1] = '\0'; 568 569 rootlen = strsep_len(node, '/', bus->levels); 570 if (rootlen < 0) 571 return; 572 root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node); 573 if (!root) 574 return; 575 576 dev = xenbus_device_find(root, &bus->bus); 577 if (!dev) 578 xenbus_probe_node(bus, type, root); 579 else 580 put_device(&dev->dev); 581 582 kfree(root); 583 } 584 EXPORT_SYMBOL_GPL(xenbus_dev_changed); 585 586 int xenbus_dev_suspend(struct device *dev) 587 { 588 int err = 0; 589 struct xenbus_driver *drv; 590 struct xenbus_device *xdev 591 = container_of(dev, struct xenbus_device, dev); 592 593 DPRINTK("%s", xdev->nodename); 594 595 if (dev->driver == NULL) 596 return 0; 597 drv = to_xenbus_driver(dev->driver); 598 if (drv->suspend) 599 err = drv->suspend(xdev); 600 if (err) 601 pr_warn("suspend %s failed: %i\n", dev_name(dev), err); 602 return 0; 603 } 604 EXPORT_SYMBOL_GPL(xenbus_dev_suspend); 605 606 int xenbus_dev_resume(struct device *dev) 607 { 608 int err; 609 struct xenbus_driver *drv; 610 struct xenbus_device *xdev 611 = container_of(dev, struct xenbus_device, dev); 612 613 DPRINTK("%s", xdev->nodename); 614 615 if (dev->driver == NULL) 616 return 0; 617 drv = to_xenbus_driver(dev->driver); 618 err = talk_to_otherend(xdev); 619 if (err) { 620 pr_warn("resume (talk_to_otherend) %s failed: %i\n", 621 dev_name(dev), err); 622 return err; 623 } 624 625 xdev->state = XenbusStateInitialising; 626 627 if (drv->resume) { 628 err = drv->resume(xdev); 629 if (err) { 630 pr_warn("resume %s failed: %i\n", dev_name(dev), err); 631 return err; 632 } 633 } 634 635 err = watch_otherend(xdev); 636 if (err) { 637 pr_warn("resume (watch_otherend) %s failed: %d.\n", 638 dev_name(dev), err); 639 return err; 640 } 641 642 return 0; 643 } 644 EXPORT_SYMBOL_GPL(xenbus_dev_resume); 645 646 int xenbus_dev_cancel(struct device *dev) 647 { 648 /* Do nothing */ 649 DPRINTK("cancel"); 650 return 0; 651 } 652 EXPORT_SYMBOL_GPL(xenbus_dev_cancel); 653 654 /* A flag to determine if xenstored is 'ready' (i.e. has started) */ 655 int xenstored_ready; 656 657 658 int register_xenstore_notifier(struct notifier_block *nb) 659 { 660 int ret = 0; 661 662 if (xenstored_ready > 0) 663 ret = nb->notifier_call(nb, 0, NULL); 664 else 665 blocking_notifier_chain_register(&xenstore_chain, nb); 666 667 return ret; 668 } 669 EXPORT_SYMBOL_GPL(register_xenstore_notifier); 670 671 void unregister_xenstore_notifier(struct notifier_block *nb) 672 { 673 blocking_notifier_chain_unregister(&xenstore_chain, nb); 674 } 675 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier); 676 677 void xenbus_probe(struct work_struct *unused) 678 { 679 xenstored_ready = 1; 680 681 /* Notify others that xenstore is up */ 682 blocking_notifier_call_chain(&xenstore_chain, 0, NULL); 683 } 684 EXPORT_SYMBOL_GPL(xenbus_probe); 685 686 static int __init xenbus_probe_initcall(void) 687 { 688 if (!xen_domain()) 689 return -ENODEV; 690 691 if (xen_initial_domain() || xen_hvm_domain()) 692 return 0; 693 694 xenbus_probe(NULL); 695 return 0; 696 } 697 698 device_initcall(xenbus_probe_initcall); 699 700 /* Set up event channel for xenstored which is run as a local process 701 * (this is normally used only in dom0) 702 */ 703 static int __init xenstored_local_init(void) 704 { 705 int err = 0; 706 unsigned long page = 0; 707 struct evtchn_alloc_unbound alloc_unbound; 708 709 /* Allocate Xenstore page */ 710 page = get_zeroed_page(GFP_KERNEL); 711 if (!page) 712 goto out_err; 713 714 xen_store_gfn = xen_start_info->store_mfn = virt_to_gfn((void *)page); 715 716 /* Next allocate a local port which xenstored can bind to */ 717 alloc_unbound.dom = DOMID_SELF; 718 alloc_unbound.remote_dom = DOMID_SELF; 719 720 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, 721 &alloc_unbound); 722 if (err == -ENOSYS) 723 goto out_err; 724 725 BUG_ON(err); 726 xen_store_evtchn = xen_start_info->store_evtchn = 727 alloc_unbound.port; 728 729 return 0; 730 731 out_err: 732 if (page != 0) 733 free_page(page); 734 return err; 735 } 736 737 static int xenbus_resume_cb(struct notifier_block *nb, 738 unsigned long action, void *data) 739 { 740 int err = 0; 741 742 if (xen_hvm_domain()) { 743 uint64_t v = 0; 744 745 err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); 746 if (!err && v) 747 xen_store_evtchn = v; 748 else 749 pr_warn("Cannot update xenstore event channel: %d\n", 750 err); 751 } else 752 xen_store_evtchn = xen_start_info->store_evtchn; 753 754 return err; 755 } 756 757 static struct notifier_block xenbus_resume_nb = { 758 .notifier_call = xenbus_resume_cb, 759 }; 760 761 static int __init xenbus_init(void) 762 { 763 int err = 0; 764 uint64_t v = 0; 765 xen_store_domain_type = XS_UNKNOWN; 766 767 if (!xen_domain()) 768 return -ENODEV; 769 770 xenbus_ring_ops_init(); 771 772 if (xen_pv_domain()) 773 xen_store_domain_type = XS_PV; 774 if (xen_hvm_domain()) 775 xen_store_domain_type = XS_HVM; 776 if (xen_hvm_domain() && xen_initial_domain()) 777 xen_store_domain_type = XS_LOCAL; 778 if (xen_pv_domain() && !xen_start_info->store_evtchn) 779 xen_store_domain_type = XS_LOCAL; 780 if (xen_pv_domain() && xen_start_info->store_evtchn) 781 xenstored_ready = 1; 782 783 switch (xen_store_domain_type) { 784 case XS_LOCAL: 785 err = xenstored_local_init(); 786 if (err) 787 goto out_error; 788 xen_store_interface = gfn_to_virt(xen_store_gfn); 789 break; 790 case XS_PV: 791 xen_store_evtchn = xen_start_info->store_evtchn; 792 xen_store_gfn = xen_start_info->store_mfn; 793 xen_store_interface = gfn_to_virt(xen_store_gfn); 794 break; 795 case XS_HVM: 796 err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); 797 if (err) 798 goto out_error; 799 xen_store_evtchn = (int)v; 800 err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v); 801 if (err) 802 goto out_error; 803 xen_store_gfn = (unsigned long)v; 804 xen_store_interface = 805 xen_remap(xen_store_gfn << XEN_PAGE_SHIFT, 806 XEN_PAGE_SIZE); 807 break; 808 default: 809 pr_warn("Xenstore state unknown\n"); 810 break; 811 } 812 813 /* Initialize the interface to xenstore. */ 814 err = xs_init(); 815 if (err) { 816 pr_warn("Error initializing xenstore comms: %i\n", err); 817 goto out_error; 818 } 819 820 if ((xen_store_domain_type != XS_LOCAL) && 821 (xen_store_domain_type != XS_UNKNOWN)) 822 xen_resume_notifier_register(&xenbus_resume_nb); 823 824 #ifdef CONFIG_XEN_COMPAT_XENFS 825 /* 826 * Create xenfs mountpoint in /proc for compatibility with 827 * utilities that expect to find "xenbus" under "/proc/xen". 828 */ 829 proc_mkdir("xen", NULL); 830 #endif 831 832 out_error: 833 return err; 834 } 835 836 postcore_initcall(xenbus_init); 837 838 MODULE_LICENSE("GPL"); 839