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