drivers/xen/xenbus/xenbus_probe.c

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