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 { 296 drv->driver.bus = &bus->bus; 297 298 return driver_register(&drv->driver); 299 } 300 EXPORT_SYMBOL_GPL(xenbus_register_driver_common); 301 302 void xenbus_unregister_driver(struct xenbus_driver *drv) 303 { 304 driver_unregister(&drv->driver); 305 } 306 EXPORT_SYMBOL_GPL(xenbus_unregister_driver); 307 308 struct xb_find_info { 309 struct xenbus_device *dev; 310 const char *nodename; 311 }; 312 313 static int cmp_dev(struct device *dev, void *data) 314 { 315 struct xenbus_device *xendev = to_xenbus_device(dev); 316 struct xb_find_info *info = data; 317 318 if (!strcmp(xendev->nodename, info->nodename)) { 319 info->dev = xendev; 320 get_device(dev); 321 return 1; 322 } 323 return 0; 324 } 325 326 struct xenbus_device *xenbus_device_find(const char *nodename, 327 struct bus_type *bus) 328 { 329 struct xb_find_info info = { .dev = NULL, .nodename = nodename }; 330 331 bus_for_each_dev(bus, NULL, &info, cmp_dev); 332 return info.dev; 333 } 334 335 static int cleanup_dev(struct device *dev, void *data) 336 { 337 struct xenbus_device *xendev = to_xenbus_device(dev); 338 struct xb_find_info *info = data; 339 int len = strlen(info->nodename); 340 341 DPRINTK("%s", info->nodename); 342 343 /* Match the info->nodename path, or any subdirectory of that path. */ 344 if (strncmp(xendev->nodename, info->nodename, len)) 345 return 0; 346 347 /* If the node name is longer, ensure it really is a subdirectory. */ 348 if ((strlen(xendev->nodename) > len) && (xendev->nodename[len] != '/')) 349 return 0; 350 351 info->dev = xendev; 352 get_device(dev); 353 return 1; 354 } 355 356 static void xenbus_cleanup_devices(const char *path, struct bus_type *bus) 357 { 358 struct xb_find_info info = { .nodename = path }; 359 360 do { 361 info.dev = NULL; 362 bus_for_each_dev(bus, NULL, &info, cleanup_dev); 363 if (info.dev) { 364 device_unregister(&info.dev->dev); 365 put_device(&info.dev->dev); 366 } 367 } while (info.dev); 368 } 369 370 static void xenbus_dev_release(struct device *dev) 371 { 372 if (dev) 373 kfree(to_xenbus_device(dev)); 374 } 375 376 static ssize_t nodename_show(struct device *dev, 377 struct device_attribute *attr, char *buf) 378 { 379 return sprintf(buf, "%s\n", to_xenbus_device(dev)->nodename); 380 } 381 382 static ssize_t devtype_show(struct device *dev, 383 struct device_attribute *attr, char *buf) 384 { 385 return sprintf(buf, "%s\n", to_xenbus_device(dev)->devicetype); 386 } 387 388 static ssize_t modalias_show(struct device *dev, 389 struct device_attribute *attr, char *buf) 390 { 391 return sprintf(buf, "%s:%s\n", dev->bus->name, 392 to_xenbus_device(dev)->devicetype); 393 } 394 395 struct device_attribute xenbus_dev_attrs[] = { 396 __ATTR_RO(nodename), 397 __ATTR_RO(devtype), 398 __ATTR_RO(modalias), 399 __ATTR_NULL 400 }; 401 EXPORT_SYMBOL_GPL(xenbus_dev_attrs); 402 403 int xenbus_probe_node(struct xen_bus_type *bus, 404 const char *type, 405 const char *nodename) 406 { 407 char devname[XEN_BUS_ID_SIZE]; 408 int err; 409 struct xenbus_device *xendev; 410 size_t stringlen; 411 char *tmpstring; 412 413 enum xenbus_state state = xenbus_read_driver_state(nodename); 414 415 if (state != XenbusStateInitialising) { 416 /* Device is not new, so ignore it. This can happen if a 417 device is going away after switching to Closed. */ 418 return 0; 419 } 420 421 stringlen = strlen(nodename) + 1 + strlen(type) + 1; 422 xendev = kzalloc(sizeof(*xendev) + stringlen, GFP_KERNEL); 423 if (!xendev) 424 return -ENOMEM; 425 426 xendev->state = XenbusStateInitialising; 427 428 /* Copy the strings into the extra space. */ 429 430 tmpstring = (char *)(xendev + 1); 431 strcpy(tmpstring, nodename); 432 xendev->nodename = tmpstring; 433 434 tmpstring += strlen(tmpstring) + 1; 435 strcpy(tmpstring, type); 436 xendev->devicetype = tmpstring; 437 init_completion(&xendev->down); 438 439 xendev->dev.bus = &bus->bus; 440 xendev->dev.release = xenbus_dev_release; 441 442 err = bus->get_bus_id(devname, xendev->nodename); 443 if (err) 444 goto fail; 445 446 dev_set_name(&xendev->dev, devname); 447 448 /* Register with generic device framework. */ 449 err = device_register(&xendev->dev); 450 if (err) 451 goto fail; 452 453 return 0; 454 fail: 455 kfree(xendev); 456 return err; 457 } 458 EXPORT_SYMBOL_GPL(xenbus_probe_node); 459 460 static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type) 461 { 462 int err = 0; 463 char **dir; 464 unsigned int dir_n = 0; 465 int i; 466 467 dir = xenbus_directory(XBT_NIL, bus->root, type, &dir_n); 468 if (IS_ERR(dir)) 469 return PTR_ERR(dir); 470 471 for (i = 0; i < dir_n; i++) { 472 err = bus->probe(bus, type, dir[i]); 473 if (err) 474 break; 475 } 476 477 kfree(dir); 478 return err; 479 } 480 481 int xenbus_probe_devices(struct xen_bus_type *bus) 482 { 483 int err = 0; 484 char **dir; 485 unsigned int i, dir_n; 486 487 dir = xenbus_directory(XBT_NIL, bus->root, "", &dir_n); 488 if (IS_ERR(dir)) 489 return PTR_ERR(dir); 490 491 for (i = 0; i < dir_n; i++) { 492 err = xenbus_probe_device_type(bus, dir[i]); 493 if (err) 494 break; 495 } 496 497 kfree(dir); 498 return err; 499 } 500 EXPORT_SYMBOL_GPL(xenbus_probe_devices); 501 502 static unsigned int char_count(const char *str, char c) 503 { 504 unsigned int i, ret = 0; 505 506 for (i = 0; str[i]; i++) 507 if (str[i] == c) 508 ret++; 509 return ret; 510 } 511 512 static int strsep_len(const char *str, char c, unsigned int len) 513 { 514 unsigned int i; 515 516 for (i = 0; str[i]; i++) 517 if (str[i] == c) { 518 if (len == 0) 519 return i; 520 len--; 521 } 522 return (len == 0) ? i : -ERANGE; 523 } 524 525 void xenbus_dev_changed(const char *node, struct xen_bus_type *bus) 526 { 527 int exists, rootlen; 528 struct xenbus_device *dev; 529 char type[XEN_BUS_ID_SIZE]; 530 const char *p, *root; 531 532 if (char_count(node, '/') < 2) 533 return; 534 535 exists = xenbus_exists(XBT_NIL, node, ""); 536 if (!exists) { 537 xenbus_cleanup_devices(node, &bus->bus); 538 return; 539 } 540 541 /* backend/<type>/... or device/<type>/... */ 542 p = strchr(node, '/') + 1; 543 snprintf(type, XEN_BUS_ID_SIZE, "%.*s", (int)strcspn(p, "/"), p); 544 type[XEN_BUS_ID_SIZE-1] = '\0'; 545 546 rootlen = strsep_len(node, '/', bus->levels); 547 if (rootlen < 0) 548 return; 549 root = kasprintf(GFP_KERNEL, "%.*s", rootlen, node); 550 if (!root) 551 return; 552 553 dev = xenbus_device_find(root, &bus->bus); 554 if (!dev) 555 xenbus_probe_node(bus, type, root); 556 else 557 put_device(&dev->dev); 558 559 kfree(root); 560 } 561 EXPORT_SYMBOL_GPL(xenbus_dev_changed); 562 563 int xenbus_dev_suspend(struct device *dev) 564 { 565 int err = 0; 566 struct xenbus_driver *drv; 567 struct xenbus_device *xdev 568 = container_of(dev, struct xenbus_device, dev); 569 570 DPRINTK("%s", xdev->nodename); 571 572 if (dev->driver == NULL) 573 return 0; 574 drv = to_xenbus_driver(dev->driver); 575 if (drv->suspend) 576 err = drv->suspend(xdev); 577 if (err) 578 printk(KERN_WARNING 579 "xenbus: suspend %s failed: %i\n", dev_name(dev), err); 580 return 0; 581 } 582 EXPORT_SYMBOL_GPL(xenbus_dev_suspend); 583 584 int xenbus_dev_resume(struct device *dev) 585 { 586 int err; 587 struct xenbus_driver *drv; 588 struct xenbus_device *xdev 589 = container_of(dev, struct xenbus_device, dev); 590 591 DPRINTK("%s", xdev->nodename); 592 593 if (dev->driver == NULL) 594 return 0; 595 drv = to_xenbus_driver(dev->driver); 596 err = talk_to_otherend(xdev); 597 if (err) { 598 printk(KERN_WARNING 599 "xenbus: resume (talk_to_otherend) %s failed: %i\n", 600 dev_name(dev), err); 601 return err; 602 } 603 604 xdev->state = XenbusStateInitialising; 605 606 if (drv->resume) { 607 err = drv->resume(xdev); 608 if (err) { 609 printk(KERN_WARNING 610 "xenbus: resume %s failed: %i\n", 611 dev_name(dev), err); 612 return err; 613 } 614 } 615 616 err = watch_otherend(xdev); 617 if (err) { 618 printk(KERN_WARNING 619 "xenbus_probe: resume (watch_otherend) %s failed: " 620 "%d.\n", dev_name(dev), err); 621 return err; 622 } 623 624 return 0; 625 } 626 EXPORT_SYMBOL_GPL(xenbus_dev_resume); 627 628 int xenbus_dev_cancel(struct device *dev) 629 { 630 /* Do nothing */ 631 DPRINTK("cancel"); 632 return 0; 633 } 634 EXPORT_SYMBOL_GPL(xenbus_dev_cancel); 635 636 /* A flag to determine if xenstored is 'ready' (i.e. has started) */ 637 int xenstored_ready; 638 639 640 int register_xenstore_notifier(struct notifier_block *nb) 641 { 642 int ret = 0; 643 644 if (xenstored_ready > 0) 645 ret = nb->notifier_call(nb, 0, NULL); 646 else 647 blocking_notifier_chain_register(&xenstore_chain, nb); 648 649 return ret; 650 } 651 EXPORT_SYMBOL_GPL(register_xenstore_notifier); 652 653 void unregister_xenstore_notifier(struct notifier_block *nb) 654 { 655 blocking_notifier_chain_unregister(&xenstore_chain, nb); 656 } 657 EXPORT_SYMBOL_GPL(unregister_xenstore_notifier); 658 659 void xenbus_probe(struct work_struct *unused) 660 { 661 xenstored_ready = 1; 662 663 /* Notify others that xenstore is up */ 664 blocking_notifier_call_chain(&xenstore_chain, 0, NULL); 665 } 666 EXPORT_SYMBOL_GPL(xenbus_probe); 667 668 static int __init xenbus_probe_initcall(void) 669 { 670 if (!xen_domain()) 671 return -ENODEV; 672 673 if (xen_initial_domain() || xen_hvm_domain()) 674 return 0; 675 676 xenbus_probe(NULL); 677 return 0; 678 } 679 680 device_initcall(xenbus_probe_initcall); 681 682 /* Set up event channel for xenstored which is run as a local process 683 * (this is normally used only in dom0) 684 */ 685 static int __init xenstored_local_init(void) 686 { 687 int err = 0; 688 unsigned long page = 0; 689 struct evtchn_alloc_unbound alloc_unbound; 690 691 /* Allocate Xenstore page */ 692 page = get_zeroed_page(GFP_KERNEL); 693 if (!page) 694 goto out_err; 695 696 xen_store_mfn = xen_start_info->store_mfn = 697 pfn_to_mfn(virt_to_phys((void *)page) >> 698 PAGE_SHIFT); 699 700 /* Next allocate a local port which xenstored can bind to */ 701 alloc_unbound.dom = DOMID_SELF; 702 alloc_unbound.remote_dom = DOMID_SELF; 703 704 err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound, 705 &alloc_unbound); 706 if (err == -ENOSYS) 707 goto out_err; 708 709 BUG_ON(err); 710 xen_store_evtchn = xen_start_info->store_evtchn = 711 alloc_unbound.port; 712 713 return 0; 714 715 out_err: 716 if (page != 0) 717 free_page(page); 718 return err; 719 } 720 721 static int __init xenbus_init(void) 722 { 723 int err = 0; 724 725 if (!xen_domain()) 726 return -ENODEV; 727 728 xenbus_ring_ops_init(); 729 730 if (xen_hvm_domain()) { 731 uint64_t v = 0; 732 err = hvm_get_parameter(HVM_PARAM_STORE_EVTCHN, &v); 733 if (err) 734 goto out_error; 735 xen_store_evtchn = (int)v; 736 err = hvm_get_parameter(HVM_PARAM_STORE_PFN, &v); 737 if (err) 738 goto out_error; 739 xen_store_mfn = (unsigned long)v; 740 xen_store_interface = ioremap(xen_store_mfn << PAGE_SHIFT, PAGE_SIZE); 741 } else { 742 xen_store_evtchn = xen_start_info->store_evtchn; 743 xen_store_mfn = xen_start_info->store_mfn; 744 if (xen_store_evtchn) 745 xenstored_ready = 1; 746 else { 747 err = xenstored_local_init(); 748 if (err) 749 goto out_error; 750 } 751 xen_store_interface = mfn_to_virt(xen_store_mfn); 752 } 753 754 /* Initialize the interface to xenstore. */ 755 err = xs_init(); 756 if (err) { 757 printk(KERN_WARNING 758 "XENBUS: Error initializing xenstore comms: %i\n", err); 759 goto out_error; 760 } 761 762 #ifdef CONFIG_XEN_COMPAT_XENFS 763 /* 764 * Create xenfs mountpoint in /proc for compatibility with 765 * utilities that expect to find "xenbus" under "/proc/xen". 766 */ 767 proc_mkdir("xen", NULL); 768 #endif 769 770 out_error: 771 return err; 772 } 773 774 postcore_initcall(xenbus_init); 775 776 MODULE_LICENSE("GPL"); 777