drivers/xen/xenbus/xenbus_client.c

   1 /******************************************************************************
   2  * Client-facing interface for the Xenbus driver.  In other words, the
   3  * interface between the Xenbus and the device-specific code, be it the
   4  * frontend or the backend of that driver.
   5  *
   6  * Copyright (C) 2005 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 #include <linux/mm.h>
  34 #include <linux/slab.h>
  35 #include <linux/types.h>
  36 #include <linux/spinlock.h>
  37 #include <linux/vmalloc.h>
  38 #include <linux/export.h>
  39 #include <asm/xen/hypervisor.h>
  40 #include <xen/page.h>
  41 #include <xen/interface/xen.h>
  42 #include <xen/interface/event_channel.h>
  43 #include <xen/balloon.h>
  44 #include <xen/events.h>
  45 #include <xen/grant_table.h>
  46 #include <xen/xenbus.h>
  47 #include <xen/xen.h>
  48 #include <xen/features.h>
  49
  50 #include "xenbus.h"
  51
  52 #define XENBUS_PAGES(_grants)   (DIV_ROUND_UP(_grants, XEN_PFN_PER_PAGE))
  53
  54 #define XENBUS_MAX_RING_PAGES   (XENBUS_PAGES(XENBUS_MAX_RING_GRANTS))
  55
  56 struct xenbus_map_node {
  57         struct list_head next;
  58         union {
  59                 struct {
  60                         struct vm_struct *area;
  61                 } pv;
  62                 struct {
  63                         struct page *pages[XENBUS_MAX_RING_PAGES];
  64                         unsigned long addrs[XENBUS_MAX_RING_GRANTS];
  65                         void *addr;
  66                 } hvm;
  67         };
  68         grant_handle_t handles[XENBUS_MAX_RING_GRANTS];
  69         unsigned int   nr_handles;
  70 };
  71
  72 struct map_ring_valloc {
  73         struct xenbus_map_node *node;
  74
  75         /* Why do we need two arrays? See comment of __xenbus_map_ring */
  76         unsigned long addrs[XENBUS_MAX_RING_GRANTS];
  77         phys_addr_t phys_addrs[XENBUS_MAX_RING_GRANTS];
  78
  79         struct gnttab_map_grant_ref map[XENBUS_MAX_RING_GRANTS];
  80         struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
  81
  82         unsigned int idx;
  83 };
  84
  85 static DEFINE_SPINLOCK(xenbus_valloc_lock);
  86 static LIST_HEAD(xenbus_valloc_pages);
  87
  88 struct xenbus_ring_ops {
  89         int (*map)(struct xenbus_device *dev, struct map_ring_valloc *info,
  90                    grant_ref_t *gnt_refs, unsigned int nr_grefs,
  91                    void **vaddr);
  92         int (*unmap)(struct xenbus_device *dev, void *vaddr);
  93 };
  94
  95 static const struct xenbus_ring_ops *ring_ops __read_mostly;
  96
  97 const char *xenbus_strstate(enum xenbus_state state)
  98 {
  99         static const char *const name[] = {
 100                 [ XenbusStateUnknown      ] = "Unknown",
 101                 [ XenbusStateInitialising ] = "Initialising",
 102                 [ XenbusStateInitWait     ] = "InitWait",
 103                 [ XenbusStateInitialised  ] = "Initialised",
 104                 [ XenbusStateConnected    ] = "Connected",
 105                 [ XenbusStateClosing      ] = "Closing",
 106                 [ XenbusStateClosed       ] = "Closed",
 107                 [XenbusStateReconfiguring] = "Reconfiguring",
 108                 [XenbusStateReconfigured] = "Reconfigured",
 109         };
 110         return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
 111 }
 112 EXPORT_SYMBOL_GPL(xenbus_strstate);
 113
 114 /**
 115  * xenbus_watch_path - register a watch
 116  * @dev: xenbus device
 117  * @path: path to watch
 118  * @watch: watch to register
 119  * @callback: callback to register
 120  *
 121  * Register a @watch on the given path, using the given xenbus_watch structure
 122  * for storage, and the given @callback function as the callback.  Return 0 on
 123  * success, or -errno on error.  On success, the given @path will be saved as
 124  * @watch->node, and remains the caller's to free.  On error, @watch->node will
 125  * be NULL, the device will switch to %XenbusStateClosing, and the error will
 126  * be saved in the store.
 127  */
 128 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
 129                       struct xenbus_watch *watch,
 130                       bool (*will_handle)(struct xenbus_watch *,
 131                                           const char *, const char *),
 132                       void (*callback)(struct xenbus_watch *,
 133                                        const char *, const char *))
 134 {
 135         int err;
 136
 137         watch->node = path;
 138         watch->will_handle = will_handle;
 139         watch->callback = callback;
 140
 141         err = register_xenbus_watch(watch);
 142
 143         if (err) {
 144                 watch->node = NULL;
 145                 watch->will_handle = NULL;
 146                 watch->callback = NULL;
 147                 xenbus_dev_fatal(dev, err, "adding watch on %s", path);
 148         }
 149
 150         return err;
 151 }
 152 EXPORT_SYMBOL_GPL(xenbus_watch_path);
 153
 154
 155 /**
 156  * xenbus_watch_pathfmt - register a watch on a sprintf-formatted path
 157  * @dev: xenbus device
 158  * @watch: watch to register
 159  * @callback: callback to register
 160  * @pathfmt: format of path to watch
 161  *
 162  * Register a watch on the given @path, using the given xenbus_watch
 163  * structure for storage, and the given @callback function as the callback.
 164  * Return 0 on success, or -errno on error.  On success, the watched path
 165  * (@path/@path2) will be saved as @watch->node, and becomes the caller's to
 166  * kfree().  On error, watch->node will be NULL, so the caller has nothing to
 167  * free, the device will switch to %XenbusStateClosing, and the error will be
 168  * saved in the store.
 169  */
 170 int xenbus_watch_pathfmt(struct xenbus_device *dev,
 171                          struct xenbus_watch *watch,
 172                          bool (*will_handle)(struct xenbus_watch *,
 173                                         const char *, const char *),
 174                          void (*callback)(struct xenbus_watch *,
 175                                           const char *, const char *),
 176                          const char *pathfmt, ...)
 177 {
 178         int err;
 179         va_list ap;
 180         char *path;
 181
 182         va_start(ap, pathfmt);
 183         path = kvasprintf(GFP_NOIO | __GFP_HIGH, pathfmt, ap);
 184         va_end(ap);
 185
 186         if (!path) {
 187                 xenbus_dev_fatal(dev, -ENOMEM, "allocating path for watch");
 188                 return -ENOMEM;
 189         }
 190         err = xenbus_watch_path(dev, path, watch, will_handle, callback);
 191
 192         if (err)
 193                 kfree(path);
 194         return err;
 195 }
 196 EXPORT_SYMBOL_GPL(xenbus_watch_pathfmt);
 197
 198 static void xenbus_switch_fatal(struct xenbus_device *, int, int,
 199                                 const char *, ...);
 200
 201 static int
 202 __xenbus_switch_state(struct xenbus_device *dev,
 203                       enum xenbus_state state, int depth)
 204 {
 205         /* We check whether the state is currently set to the given value, and
 206            if not, then the state is set.  We don't want to unconditionally
 207            write the given state, because we don't want to fire watches
 208            unnecessarily.  Furthermore, if the node has gone, we don't write
 209            to it, as the device will be tearing down, and we don't want to
 210            resurrect that directory.
 211
 212            Note that, because of this cached value of our state, this
 213            function will not take a caller's Xenstore transaction
 214            (something it was trying to in the past) because dev->state
 215            would not get reset if the transaction was aborted.
 216          */
 217
 218         struct xenbus_transaction xbt;
 219         int current_state;
 220         int err, abort;
 221
 222         if (state == dev->state)
 223                 return 0;
 224
 225 again:
 226         abort = 1;
 227
 228         err = xenbus_transaction_start(&xbt);
 229         if (err) {
 230                 xenbus_switch_fatal(dev, depth, err, "starting transaction");
 231                 return 0;
 232         }
 233
 234         err = xenbus_scanf(xbt, dev->nodename, "state", "%d", &current_state);
 235         if (err != 1)
 236                 goto abort;
 237
 238         err = xenbus_printf(xbt, dev->nodename, "state", "%d", state);
 239         if (err) {
 240                 xenbus_switch_fatal(dev, depth, err, "writing new state");
 241                 goto abort;
 242         }
 243
 244         abort = 0;
 245 abort:
 246         err = xenbus_transaction_end(xbt, abort);
 247         if (err) {
 248                 if (err == -EAGAIN && !abort)
 249                         goto again;
 250                 xenbus_switch_fatal(dev, depth, err, "ending transaction");
 251         } else
 252                 dev->state = state;
 253
 254         return 0;
 255 }
 256
 257 /**
 258  * xenbus_switch_state
 259  * @dev: xenbus device
 260  * @state: new state
 261  *
 262  * Advertise in the store a change of the given driver to the given new_state.
 263  * Return 0 on success, or -errno on error.  On error, the device will switch
 264  * to XenbusStateClosing, and the error will be saved in the store.
 265  */
 266 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
 267 {
 268         return __xenbus_switch_state(dev, state, 0);
 269 }
 270
 271 EXPORT_SYMBOL_GPL(xenbus_switch_state);
 272
 273 int xenbus_frontend_closed(struct xenbus_device *dev)
 274 {
 275         xenbus_switch_state(dev, XenbusStateClosed);
 276         complete(&dev->down);
 277         return 0;
 278 }
 279 EXPORT_SYMBOL_GPL(xenbus_frontend_closed);
 280
 281 static void xenbus_va_dev_error(struct xenbus_device *dev, int err,
 282                                 const char *fmt, va_list ap)
 283 {
 284         unsigned int len;
 285         char *printf_buffer;
 286         char *path_buffer;
 287
 288 #define PRINTF_BUFFER_SIZE 4096
 289
 290         printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
 291         if (!printf_buffer)
 292                 return;
 293
 294         len = sprintf(printf_buffer, "%i ", -err);
 295         vsnprintf(printf_buffer + len, PRINTF_BUFFER_SIZE - len, fmt, ap);
 296
 297         dev_err(&dev->dev, "%s\n", printf_buffer);
 298
 299         path_buffer = kasprintf(GFP_KERNEL, "error/%s", dev->nodename);
 300         if (path_buffer)
 301                 xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer);
 302
 303         kfree(printf_buffer);
 304         kfree(path_buffer);
 305 }
 306
 307 /**
 308  * xenbus_dev_error
 309  * @dev: xenbus device
 310  * @err: error to report
 311  * @fmt: error message format
 312  *
 313  * Report the given negative errno into the store, along with the given
 314  * formatted message.
 315  */
 316 void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, ...)
 317 {
 318         va_list ap;
 319
 320         va_start(ap, fmt);
 321         xenbus_va_dev_error(dev, err, fmt, ap);
 322         va_end(ap);
 323 }
 324 EXPORT_SYMBOL_GPL(xenbus_dev_error);
 325
 326 /**
 327  * xenbus_dev_fatal
 328  * @dev: xenbus device
 329  * @err: error to report
 330  * @fmt: error message format
 331  *
 332  * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
 333  * xenbus_switch_state(dev, XenbusStateClosing) to schedule an orderly
 334  * closedown of this driver and its peer.
 335  */
 336
 337 void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...)
 338 {
 339         va_list ap;
 340
 341         va_start(ap, fmt);
 342         xenbus_va_dev_error(dev, err, fmt, ap);
 343         va_end(ap);
 344
 345         xenbus_switch_state(dev, XenbusStateClosing);
 346 }
 347 EXPORT_SYMBOL_GPL(xenbus_dev_fatal);
 348
 349 /**
 350  * Equivalent to xenbus_dev_fatal(dev, err, fmt, args), but helps
 351  * avoiding recursion within xenbus_switch_state.
 352  */
 353 static void xenbus_switch_fatal(struct xenbus_device *dev, int depth, int err,
 354                                 const char *fmt, ...)
 355 {
 356         va_list ap;
 357
 358         va_start(ap, fmt);
 359         xenbus_va_dev_error(dev, err, fmt, ap);
 360         va_end(ap);
 361
 362         if (!depth)
 363                 __xenbus_switch_state(dev, XenbusStateClosing, 1);
 364 }
 365
 366 /**
 367  * xenbus_grant_ring
 368  * @dev: xenbus device
 369  * @vaddr: starting virtual address of the ring
 370  * @nr_pages: number of pages to be granted
 371  * @grefs: grant reference array to be filled in
 372  *
 373  * Grant access to the given @vaddr to the peer of the given device.
 374  * Then fill in @grefs with grant references.  Return 0 on success, or
 375  * -errno on error.  On error, the device will switch to
 376  * XenbusStateClosing, and the error will be saved in the store.
 377  */
 378 int xenbus_grant_ring(struct xenbus_device *dev, void *vaddr,
 379                       unsigned int nr_pages, grant_ref_t *grefs)
 380 {
 381         int err;
 382         int i, j;
 383
 384         for (i = 0; i < nr_pages; i++) {
 385                 unsigned long gfn;
 386
 387                 if (is_vmalloc_addr(vaddr))
 388                         gfn = pfn_to_gfn(vmalloc_to_pfn(vaddr));
 389                 else
 390                         gfn = virt_to_gfn(vaddr);
 391
 392                 err = gnttab_grant_foreign_access(dev->otherend_id, gfn, 0);
 393                 if (err < 0) {
 394                         xenbus_dev_fatal(dev, err,
 395                                          "granting access to ring page");
 396                         goto fail;
 397                 }
 398                 grefs[i] = err;
 399
 400                 vaddr = vaddr + XEN_PAGE_SIZE;
 401         }
 402
 403         return 0;
 404
 405 fail:
 406         for (j = 0; j < i; j++)
 407                 gnttab_end_foreign_access_ref(grefs[j], 0);
 408         return err;
 409 }
 410 EXPORT_SYMBOL_GPL(xenbus_grant_ring);
 411
 412
 413 /**
 414  * Allocate an event channel for the given xenbus_device, assigning the newly
 415  * created local port to *port.  Return 0 on success, or -errno on error.  On
 416  * error, the device will switch to XenbusStateClosing, and the error will be
 417  * saved in the store.
 418  */
 419 int xenbus_alloc_evtchn(struct xenbus_device *dev, evtchn_port_t *port)
 420 {
 421         struct evtchn_alloc_unbound alloc_unbound;
 422         int err;
 423
 424         alloc_unbound.dom = DOMID_SELF;
 425         alloc_unbound.remote_dom = dev->otherend_id;
 426
 427         err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
 428                                           &alloc_unbound);
 429         if (err)
 430                 xenbus_dev_fatal(dev, err, "allocating event channel");
 431         else
 432                 *port = alloc_unbound.port;
 433
 434         return err;
 435 }
 436 EXPORT_SYMBOL_GPL(xenbus_alloc_evtchn);
 437
 438
 439 /**
 440  * Free an existing event channel. Returns 0 on success or -errno on error.
 441  */
 442 int xenbus_free_evtchn(struct xenbus_device *dev, evtchn_port_t port)
 443 {
 444         struct evtchn_close close;
 445         int err;
 446
 447         close.port = port;
 448
 449         err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
 450         if (err)
 451                 xenbus_dev_error(dev, err, "freeing event channel %u", port);
 452
 453         return err;
 454 }
 455 EXPORT_SYMBOL_GPL(xenbus_free_evtchn);
 456
 457
 458 /**
 459  * xenbus_map_ring_valloc
 460  * @dev: xenbus device
 461  * @gnt_refs: grant reference array
 462  * @nr_grefs: number of grant references
 463  * @vaddr: pointer to address to be filled out by mapping
 464  *
 465  * Map @nr_grefs pages of memory into this domain from another
 466  * domain's grant table.  xenbus_map_ring_valloc allocates @nr_grefs
 467  * pages of virtual address space, maps the pages to that address, and
 468  * sets *vaddr to that address.  Returns 0 on success, and -errno on
 469  * error. If an error is returned, device will switch to
 470  * XenbusStateClosing and the error message will be saved in XenStore.
 471  */
 472 int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs,
 473                            unsigned int nr_grefs, void **vaddr)
 474 {
 475         int err;
 476         struct map_ring_valloc *info;
 477
 478         *vaddr = NULL;
 479
 480         if (nr_grefs > XENBUS_MAX_RING_GRANTS)
 481                 return -EINVAL;
 482
 483         info = kzalloc(sizeof(*info), GFP_KERNEL);
 484         if (!info)
 485                 return -ENOMEM;
 486
 487         info->node = kzalloc(sizeof(*info->node), GFP_KERNEL);
 488         if (!info->node)
 489                 err = -ENOMEM;
 490         else
 491                 err = ring_ops->map(dev, info, gnt_refs, nr_grefs, vaddr);
 492
 493         kfree(info->node);
 494         kfree(info);
 495         return err;
 496 }
 497 EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
 498
 499 /* N.B. sizeof(phys_addr_t) doesn't always equal to sizeof(unsigned
 500  * long), e.g. 32-on-64.  Caller is responsible for preparing the
 501  * right array to feed into this function */
 502 static int __xenbus_map_ring(struct xenbus_device *dev,
 503                              grant_ref_t *gnt_refs,
 504                              unsigned int nr_grefs,
 505                              grant_handle_t *handles,
 506                              struct map_ring_valloc *info,
 507                              unsigned int flags,
 508                              bool *leaked)
 509 {
 510         int i, j;
 511
 512         if (nr_grefs > XENBUS_MAX_RING_GRANTS)
 513                 return -EINVAL;
 514
 515         for (i = 0; i < nr_grefs; i++) {
 516                 gnttab_set_map_op(&info->map[i], info->phys_addrs[i], flags,
 517                                   gnt_refs[i], dev->otherend_id);
 518                 handles[i] = INVALID_GRANT_HANDLE;
 519         }
 520
 521         gnttab_batch_map(info->map, i);
 522
 523         for (i = 0; i < nr_grefs; i++) {
 524                 if (info->map[i].status != GNTST_okay) {
 525                         xenbus_dev_fatal(dev, info->map[i].status,
 526                                          "mapping in shared page %d from domain %d",
 527                                          gnt_refs[i], dev->otherend_id);
 528                         goto fail;
 529                 } else
 530                         handles[i] = info->map[i].handle;
 531         }
 532
 533         return 0;
 534
 535  fail:
 536         for (i = j = 0; i < nr_grefs; i++) {
 537                 if (handles[i] != INVALID_GRANT_HANDLE) {
 538                         gnttab_set_unmap_op(&info->unmap[j],
 539                                             info->phys_addrs[i],
 540                                             GNTMAP_host_map, handles[i]);
 541                         j++;
 542                 }
 543         }
 544
 545         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, info->unmap, j))
 546                 BUG();
 547
 548         *leaked = false;
 549         for (i = 0; i < j; i++) {
 550                 if (info->unmap[i].status != GNTST_okay) {
 551                         *leaked = true;
 552                         break;
 553                 }
 554         }
 555
 556         return -ENOENT;
 557 }
 558
 559 /**
 560  * xenbus_unmap_ring
 561  * @dev: xenbus device
 562  * @handles: grant handle array
 563  * @nr_handles: number of handles in the array
 564  * @vaddrs: addresses to unmap
 565  *
 566  * Unmap memory in this domain that was imported from another domain.
 567  * Returns 0 on success and returns GNTST_* on error
 568  * (see xen/include/interface/grant_table.h).
 569  */
 570 static int xenbus_unmap_ring(struct xenbus_device *dev, grant_handle_t *handles,
 571                              unsigned int nr_handles, unsigned long *vaddrs)
 572 {
 573         struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
 574         int i;
 575         int err;
 576
 577         if (nr_handles > XENBUS_MAX_RING_GRANTS)
 578                 return -EINVAL;
 579
 580         for (i = 0; i < nr_handles; i++)
 581                 gnttab_set_unmap_op(&unmap[i], vaddrs[i],
 582                                     GNTMAP_host_map, handles[i]);
 583
 584         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, i))
 585                 BUG();
 586
 587         err = GNTST_okay;
 588         for (i = 0; i < nr_handles; i++) {
 589                 if (unmap[i].status != GNTST_okay) {
 590                         xenbus_dev_error(dev, unmap[i].status,
 591                                          "unmapping page at handle %d error %d",
 592                                          handles[i], unmap[i].status);
 593                         err = unmap[i].status;
 594                         break;
 595                 }
 596         }
 597
 598         return err;
 599 }
 600
 601 static void xenbus_map_ring_setup_grant_hvm(unsigned long gfn,
 602                                             unsigned int goffset,
 603                                             unsigned int len,
 604                                             void *data)
 605 {
 606         struct map_ring_valloc *info = data;
 607         unsigned long vaddr = (unsigned long)gfn_to_virt(gfn);
 608
 609         info->phys_addrs[info->idx] = vaddr;
 610         info->addrs[info->idx] = vaddr;
 611
 612         info->idx++;
 613 }
 614
 615 static int xenbus_map_ring_hvm(struct xenbus_device *dev,
 616                                struct map_ring_valloc *info,
 617                                grant_ref_t *gnt_ref,
 618                                unsigned int nr_grefs,
 619                                void **vaddr)
 620 {
 621         struct xenbus_map_node *node = info->node;
 622         int err;
 623         void *addr;
 624         bool leaked = false;
 625         unsigned int nr_pages = XENBUS_PAGES(nr_grefs);
 626
 627         err = xen_alloc_unpopulated_pages(nr_pages, node->hvm.pages);
 628         if (err)
 629                 goto out_err;
 630
 631         gnttab_foreach_grant(node->hvm.pages, nr_grefs,
 632                              xenbus_map_ring_setup_grant_hvm,
 633                              info);
 634
 635         err = __xenbus_map_ring(dev, gnt_ref, nr_grefs, node->handles,
 636                                 info, GNTMAP_host_map, &leaked);
 637         node->nr_handles = nr_grefs;
 638
 639         if (err)
 640                 goto out_free_ballooned_pages;
 641
 642         addr = vmap(node->hvm.pages, nr_pages, VM_MAP | VM_IOREMAP,
 643                     PAGE_KERNEL);
 644         if (!addr) {
 645                 err = -ENOMEM;
 646                 goto out_xenbus_unmap_ring;
 647         }
 648
 649         node->hvm.addr = addr;
 650
 651         spin_lock(&xenbus_valloc_lock);
 652         list_add(&node->next, &xenbus_valloc_pages);
 653         spin_unlock(&xenbus_valloc_lock);
 654
 655         *vaddr = addr;
 656         info->node = NULL;
 657
 658         return 0;
 659
 660  out_xenbus_unmap_ring:
 661         if (!leaked)
 662                 xenbus_unmap_ring(dev, node->handles, nr_grefs, info->addrs);
 663         else
 664                 pr_alert("leaking %p size %u page(s)",
 665                          addr, nr_pages);
 666  out_free_ballooned_pages:
 667         if (!leaked)
 668                 xen_free_unpopulated_pages(nr_pages, node->hvm.pages);
 669  out_err:
 670         return err;
 671 }
 672
 673 /**
 674  * xenbus_unmap_ring_vfree
 675  * @dev: xenbus device
 676  * @vaddr: addr to unmap
 677  *
 678  * Based on Rusty Russell's skeleton driver's unmap_page.
 679  * Unmap a page of memory in this domain that was imported from another domain.
 680  * Use xenbus_unmap_ring_vfree if you mapped in your memory with
 681  * xenbus_map_ring_valloc (it will free the virtual address space).
 682  * Returns 0 on success and returns GNTST_* on error
 683  * (see xen/include/interface/grant_table.h).
 684  */
 685 int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr)
 686 {
 687         return ring_ops->unmap(dev, vaddr);
 688 }
 689 EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
 690
 691 #ifdef CONFIG_XEN_PV
 692 static int map_ring_apply(pte_t *pte, unsigned long addr, void *data)
 693 {
 694         struct map_ring_valloc *info = data;
 695
 696         info->phys_addrs[info->idx++] = arbitrary_virt_to_machine(pte).maddr;
 697         return 0;
 698 }
 699
 700 static int xenbus_map_ring_pv(struct xenbus_device *dev,
 701                               struct map_ring_valloc *info,
 702                               grant_ref_t *gnt_refs,
 703                               unsigned int nr_grefs,
 704                               void **vaddr)
 705 {
 706         struct xenbus_map_node *node = info->node;
 707         struct vm_struct *area;
 708         bool leaked = false;
 709         int err = -ENOMEM;
 710
 711         area = get_vm_area(XEN_PAGE_SIZE * nr_grefs, VM_IOREMAP);
 712         if (!area)
 713                 return -ENOMEM;
 714         if (apply_to_page_range(&init_mm, (unsigned long)area->addr,
 715                                 XEN_PAGE_SIZE * nr_grefs, map_ring_apply, info))
 716                 goto failed;
 717         err = __xenbus_map_ring(dev, gnt_refs, nr_grefs, node->handles,
 718                                 info, GNTMAP_host_map | GNTMAP_contains_pte,
 719                                 &leaked);
 720         if (err)
 721                 goto failed;
 722
 723         node->nr_handles = nr_grefs;
 724         node->pv.area = area;
 725
 726         spin_lock(&xenbus_valloc_lock);
 727         list_add(&node->next, &xenbus_valloc_pages);
 728         spin_unlock(&xenbus_valloc_lock);
 729
 730         *vaddr = area->addr;
 731         info->node = NULL;
 732
 733         return 0;
 734
 735 failed:
 736         if (!leaked)
 737                 free_vm_area(area);
 738         else
 739                 pr_alert("leaking VM area %p size %u page(s)", area, nr_grefs);
 740
 741         return err;
 742 }
 743
 744 static int xenbus_unmap_ring_pv(struct xenbus_device *dev, void *vaddr)
 745 {
 746         struct xenbus_map_node *node;
 747         struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_GRANTS];
 748         unsigned int level;
 749         int i;
 750         bool leaked = false;
 751         int err;
 752
 753         spin_lock(&xenbus_valloc_lock);
 754         list_for_each_entry(node, &xenbus_valloc_pages, next) {
 755                 if (node->pv.area->addr == vaddr) {
 756                         list_del(&node->next);
 757                         goto found;
 758                 }
 759         }
 760         node = NULL;
 761  found:
 762         spin_unlock(&xenbus_valloc_lock);
 763
 764         if (!node) {
 765                 xenbus_dev_error(dev, -ENOENT,
 766                                  "can't find mapped virtual address %p", vaddr);
 767                 return GNTST_bad_virt_addr;
 768         }
 769
 770         for (i = 0; i < node->nr_handles; i++) {
 771                 unsigned long addr;
 772
 773                 memset(&unmap[i], 0, sizeof(unmap[i]));
 774                 addr = (unsigned long)vaddr + (XEN_PAGE_SIZE * i);
 775                 unmap[i].host_addr = arbitrary_virt_to_machine(
 776                         lookup_address(addr, &level)).maddr;
 777                 unmap[i].dev_bus_addr = 0;
 778                 unmap[i].handle = node->handles[i];
 779         }
 780
 781         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, i))
 782                 BUG();
 783
 784         err = GNTST_okay;
 785         leaked = false;
 786         for (i = 0; i < node->nr_handles; i++) {
 787                 if (unmap[i].status != GNTST_okay) {
 788                         leaked = true;
 789                         xenbus_dev_error(dev, unmap[i].status,
 790                                          "unmapping page at handle %d error %d",
 791                                          node->handles[i], unmap[i].status);
 792                         err = unmap[i].status;
 793                         break;
 794                 }
 795         }
 796
 797         if (!leaked)
 798                 free_vm_area(node->pv.area);
 799         else
 800                 pr_alert("leaking VM area %p size %u page(s)",
 801                          node->pv.area, node->nr_handles);
 802
 803         kfree(node);
 804         return err;
 805 }
 806
 807 static const struct xenbus_ring_ops ring_ops_pv = {
 808         .map = xenbus_map_ring_pv,
 809         .unmap = xenbus_unmap_ring_pv,
 810 };
 811 #endif
 812
 813 struct unmap_ring_hvm
 814 {
 815         unsigned int idx;
 816         unsigned long addrs[XENBUS_MAX_RING_GRANTS];
 817 };
 818
 819 static void xenbus_unmap_ring_setup_grant_hvm(unsigned long gfn,
 820                                               unsigned int goffset,
 821                                               unsigned int len,
 822                                               void *data)
 823 {
 824         struct unmap_ring_hvm *info = data;
 825
 826         info->addrs[info->idx] = (unsigned long)gfn_to_virt(gfn);
 827
 828         info->idx++;
 829 }
 830
 831 static int xenbus_unmap_ring_hvm(struct xenbus_device *dev, void *vaddr)
 832 {
 833         int rv;
 834         struct xenbus_map_node *node;
 835         void *addr;
 836         struct unmap_ring_hvm info = {
 837                 .idx = 0,
 838         };
 839         unsigned int nr_pages;
 840
 841         spin_lock(&xenbus_valloc_lock);
 842         list_for_each_entry(node, &xenbus_valloc_pages, next) {
 843                 addr = node->hvm.addr;
 844                 if (addr == vaddr) {
 845                         list_del(&node->next);
 846                         goto found;
 847                 }
 848         }
 849         node = addr = NULL;
 850  found:
 851         spin_unlock(&xenbus_valloc_lock);
 852
 853         if (!node) {
 854                 xenbus_dev_error(dev, -ENOENT,
 855                                  "can't find mapped virtual address %p", vaddr);
 856                 return GNTST_bad_virt_addr;
 857         }
 858
 859         nr_pages = XENBUS_PAGES(node->nr_handles);
 860
 861         gnttab_foreach_grant(node->hvm.pages, node->nr_handles,
 862                              xenbus_unmap_ring_setup_grant_hvm,
 863                              &info);
 864
 865         rv = xenbus_unmap_ring(dev, node->handles, node->nr_handles,
 866                                info.addrs);
 867         if (!rv) {
 868                 vunmap(vaddr);
 869                 xen_free_unpopulated_pages(nr_pages, node->hvm.pages);
 870         }
 871         else
 872                 WARN(1, "Leaking %p, size %u page(s)\n", vaddr, nr_pages);
 873
 874         kfree(node);
 875         return rv;
 876 }
 877
 878 /**
 879  * xenbus_read_driver_state
 880  * @path: path for driver
 881  *
 882  * Return the state of the driver rooted at the given store path, or
 883  * XenbusStateUnknown if no state can be read.
 884  */
 885 enum xenbus_state xenbus_read_driver_state(const char *path)
 886 {
 887         enum xenbus_state result;
 888         int err = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
 889         if (err)
 890                 result = XenbusStateUnknown;
 891
 892         return result;
 893 }
 894 EXPORT_SYMBOL_GPL(xenbus_read_driver_state);
 895
 896 static const struct xenbus_ring_ops ring_ops_hvm = {
 897         .map = xenbus_map_ring_hvm,
 898         .unmap = xenbus_unmap_ring_hvm,
 899 };
 900
 901 void __init xenbus_ring_ops_init(void)
 902 {
 903 #ifdef CONFIG_XEN_PV
 904         if (!xen_feature(XENFEAT_auto_translated_physmap))
 905                 ring_ops = &ring_ops_pv;
 906         else
 907 #endif
 908                 ring_ops = &ring_ops_hvm;
 909 }