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