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