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_probe.h"
  51
  52 struct xenbus_map_node {
  53         struct list_head next;
  54         union {
  55                 struct {
  56                         struct vm_struct *area;
  57                 } pv;
  58                 struct {
  59                         struct page *pages[XENBUS_MAX_RING_PAGES];
  60                         void *addr;
  61                 } hvm;
  62         };
  63         grant_handle_t handles[XENBUS_MAX_RING_PAGES];
  64         unsigned int   nr_handles;
  65 };
  66
  67 static DEFINE_SPINLOCK(xenbus_valloc_lock);
  68 static LIST_HEAD(xenbus_valloc_pages);
  69
  70 struct xenbus_ring_ops {
  71         int (*map)(struct xenbus_device *dev,
  72                    grant_ref_t *gnt_refs, unsigned int nr_grefs,
  73                    void **vaddr);
  74         int (*unmap)(struct xenbus_device *dev, void *vaddr);
  75 };
  76
  77 static const struct xenbus_ring_ops *ring_ops __read_mostly;
  78
  79 const char *xenbus_strstate(enum xenbus_state state)
  80 {
  81         static const char *const name[] = {
  82                 [ XenbusStateUnknown      ] = "Unknown",
  83                 [ XenbusStateInitialising ] = "Initialising",
  84                 [ XenbusStateInitWait     ] = "InitWait",
  85                 [ XenbusStateInitialised  ] = "Initialised",
  86                 [ XenbusStateConnected    ] = "Connected",
  87                 [ XenbusStateClosing      ] = "Closing",
  88                 [ XenbusStateClosed       ] = "Closed",
  89                 [XenbusStateReconfiguring] = "Reconfiguring",
  90                 [XenbusStateReconfigured] = "Reconfigured",
  91         };
  92         return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
  93 }
  94 EXPORT_SYMBOL_GPL(xenbus_strstate);
  95
  96 /**
  97  * xenbus_watch_path - register a watch
  98  * @dev: xenbus device
  99  * @path: path to watch
 100  * @watch: watch to register
 101  * @callback: callback to register
 102  *
 103  * Register a @watch on the given path, using the given xenbus_watch structure
 104  * for storage, and the given @callback function as the callback.  Return 0 on
 105  * success, or -errno on error.  On success, the given @path will be saved as
 106  * @watch->node, and remains the caller's to free.  On error, @watch->node will
 107  * be NULL, the device will switch to %XenbusStateClosing, and the error will
 108  * be saved in the store.
 109  */
 110 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
 111                       struct xenbus_watch *watch,
 112                       void (*callback)(struct xenbus_watch *,
 113                                        const char **, unsigned int))
 114 {
 115         int err;
 116
 117         watch->node = path;
 118         watch->callback = callback;
 119
 120         err = register_xenbus_watch(watch);
 121
 122         if (err) {
 123                 watch->node = NULL;
 124                 watch->callback = NULL;
 125                 xenbus_dev_fatal(dev, err, "adding watch on %s", path);
 126         }
 127
 128         return err;
 129 }
 130 EXPORT_SYMBOL_GPL(xenbus_watch_path);
 131
 132
 133 /**
 134  * xenbus_watch_pathfmt - register a watch on a sprintf-formatted path
 135  * @dev: xenbus device
 136  * @watch: watch to register
 137  * @callback: callback to register
 138  * @pathfmt: format of path to watch
 139  *
 140  * Register a watch on the given @path, using the given xenbus_watch
 141  * structure for storage, and the given @callback function as the callback.
 142  * Return 0 on success, or -errno on error.  On success, the watched path
 143  * (@path/@path2) will be saved as @watch->node, and becomes the caller's to
 144  * kfree().  On error, watch->node will be NULL, so the caller has nothing to
 145  * free, the device will switch to %XenbusStateClosing, and the error will be
 146  * saved in the store.
 147  */
 148 int xenbus_watch_pathfmt(struct xenbus_device *dev,
 149                          struct xenbus_watch *watch,
 150                          void (*callback)(struct xenbus_watch *,
 151                                         const char **, unsigned int),
 152                          const char *pathfmt, ...)
 153 {
 154         int err;
 155         va_list ap;
 156         char *path;
 157
 158         va_start(ap, pathfmt);
 159         path = kvasprintf(GFP_NOIO | __GFP_HIGH, pathfmt, ap);
 160         va_end(ap);
 161
 162         if (!path) {
 163                 xenbus_dev_fatal(dev, -ENOMEM, "allocating path for watch");
 164                 return -ENOMEM;
 165         }
 166         err = xenbus_watch_path(dev, path, watch, callback);
 167
 168         if (err)
 169                 kfree(path);
 170         return err;
 171 }
 172 EXPORT_SYMBOL_GPL(xenbus_watch_pathfmt);
 173
 174 static void xenbus_switch_fatal(struct xenbus_device *, int, int,
 175                                 const char *, ...);
 176
 177 static int
 178 __xenbus_switch_state(struct xenbus_device *dev,
 179                       enum xenbus_state state, int depth)
 180 {
 181         /* We check whether the state is currently set to the given value, and
 182            if not, then the state is set.  We don't want to unconditionally
 183            write the given state, because we don't want to fire watches
 184            unnecessarily.  Furthermore, if the node has gone, we don't write
 185            to it, as the device will be tearing down, and we don't want to
 186            resurrect that directory.
 187
 188            Note that, because of this cached value of our state, this
 189            function will not take a caller's Xenstore transaction
 190            (something it was trying to in the past) because dev->state
 191            would not get reset if the transaction was aborted.
 192          */
 193
 194         struct xenbus_transaction xbt;
 195         int current_state;
 196         int err, abort;
 197
 198         if (state == dev->state)
 199                 return 0;
 200
 201 again:
 202         abort = 1;
 203
 204         err = xenbus_transaction_start(&xbt);
 205         if (err) {
 206                 xenbus_switch_fatal(dev, depth, err, "starting transaction");
 207                 return 0;
 208         }
 209
 210         err = xenbus_scanf(xbt, dev->nodename, "state", "%d", &current_state);
 211         if (err != 1)
 212                 goto abort;
 213
 214         err = xenbus_printf(xbt, dev->nodename, "state", "%d", state);
 215         if (err) {
 216                 xenbus_switch_fatal(dev, depth, err, "writing new state");
 217                 goto abort;
 218         }
 219
 220         abort = 0;
 221 abort:
 222         err = xenbus_transaction_end(xbt, abort);
 223         if (err) {
 224                 if (err == -EAGAIN && !abort)
 225                         goto again;
 226                 xenbus_switch_fatal(dev, depth, err, "ending transaction");
 227         } else
 228                 dev->state = state;
 229
 230         return 0;
 231 }
 232
 233 /**
 234  * xenbus_switch_state
 235  * @dev: xenbus device
 236  * @state: new state
 237  *
 238  * Advertise in the store a change of the given driver to the given new_state.
 239  * Return 0 on success, or -errno on error.  On error, the device will switch
 240  * to XenbusStateClosing, and the error will be saved in the store.
 241  */
 242 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
 243 {
 244         return __xenbus_switch_state(dev, state, 0);
 245 }
 246
 247 EXPORT_SYMBOL_GPL(xenbus_switch_state);
 248
 249 int xenbus_frontend_closed(struct xenbus_device *dev)
 250 {
 251         xenbus_switch_state(dev, XenbusStateClosed);
 252         complete(&dev->down);
 253         return 0;
 254 }
 255 EXPORT_SYMBOL_GPL(xenbus_frontend_closed);
 256
 257 /**
 258  * Return the path to the error node for the given device, or NULL on failure.
 259  * If the value returned is non-NULL, then it is the caller's to kfree.
 260  */
 261 static char *error_path(struct xenbus_device *dev)
 262 {
 263         return kasprintf(GFP_KERNEL, "error/%s", dev->nodename);
 264 }
 265
 266
 267 static void xenbus_va_dev_error(struct xenbus_device *dev, int err,
 268                                 const char *fmt, va_list ap)
 269 {
 270         unsigned int len;
 271         char *printf_buffer = NULL;
 272         char *path_buffer = NULL;
 273
 274 #define PRINTF_BUFFER_SIZE 4096
 275         printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
 276         if (printf_buffer == NULL)
 277                 goto fail;
 278
 279         len = sprintf(printf_buffer, "%i ", -err);
 280         vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
 281
 282         dev_err(&dev->dev, "%s\n", printf_buffer);
 283
 284         path_buffer = error_path(dev);
 285
 286         if (path_buffer == NULL) {
 287                 dev_err(&dev->dev, "failed to write error node for %s (%s)\n",
 288                        dev->nodename, printf_buffer);
 289                 goto fail;
 290         }
 291
 292         if (xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer) != 0) {
 293                 dev_err(&dev->dev, "failed to write error node for %s (%s)\n",
 294                        dev->nodename, printf_buffer);
 295                 goto fail;
 296         }
 297
 298 fail:
 299         kfree(printf_buffer);
 300         kfree(path_buffer);
 301 }
 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 + 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, int *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, int 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 %d", 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 GNTST_*
 460  * (see xen/include/interface/grant_table.h) or -ENOMEM / -EINVAL on
 461  * error. If an error is returned, device will switch to
 462  * XenbusStateClosing and the error message will be saved in XenStore.
 463  */
 464 int xenbus_map_ring_valloc(struct xenbus_device *dev, grant_ref_t *gnt_refs,
 465                            unsigned int nr_grefs, void **vaddr)
 466 {
 467         return ring_ops->map(dev, gnt_refs, nr_grefs, vaddr);
 468 }
 469 EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
 470
 471 /* N.B. sizeof(phys_addr_t) doesn't always equal to sizeof(unsigned
 472  * long), e.g. 32-on-64.  Caller is responsible for preparing the
 473  * right array to feed into this function */
 474 static int __xenbus_map_ring(struct xenbus_device *dev,
 475                              grant_ref_t *gnt_refs,
 476                              unsigned int nr_grefs,
 477                              grant_handle_t *handles,
 478                              phys_addr_t *addrs,
 479                              unsigned int flags,
 480                              bool *leaked)
 481 {
 482         struct gnttab_map_grant_ref map[XENBUS_MAX_RING_PAGES];
 483         struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_PAGES];
 484         int i, j;
 485         int err = GNTST_okay;
 486
 487         if (nr_grefs > XENBUS_MAX_RING_PAGES)
 488                 return -EINVAL;
 489
 490         for (i = 0; i < nr_grefs; i++) {
 491                 memset(&map[i], 0, sizeof(map[i]));
 492                 gnttab_set_map_op(&map[i], addrs[i], flags, gnt_refs[i],
 493                                   dev->otherend_id);
 494                 handles[i] = INVALID_GRANT_HANDLE;
 495         }
 496
 497         gnttab_batch_map(map, i);
 498
 499         for (i = 0; i < nr_grefs; i++) {
 500                 if (map[i].status != GNTST_okay) {
 501                         err = map[i].status;
 502                         xenbus_dev_fatal(dev, map[i].status,
 503                                          "mapping in shared page %d from domain %d",
 504                                          gnt_refs[i], dev->otherend_id);
 505                         goto fail;
 506                 } else
 507                         handles[i] = map[i].handle;
 508         }
 509
 510         return GNTST_okay;
 511
 512  fail:
 513         for (i = j = 0; i < nr_grefs; i++) {
 514                 if (handles[i] != INVALID_GRANT_HANDLE) {
 515                         memset(&unmap[j], 0, sizeof(unmap[j]));
 516                         gnttab_set_unmap_op(&unmap[j], (phys_addr_t)addrs[i],
 517                                             GNTMAP_host_map, handles[i]);
 518                         j++;
 519                 }
 520         }
 521
 522         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, j))
 523                 BUG();
 524
 525         *leaked = false;
 526         for (i = 0; i < j; i++) {
 527                 if (unmap[i].status != GNTST_okay) {
 528                         *leaked = true;
 529                         break;
 530                 }
 531         }
 532
 533         return err;
 534 }
 535
 536 static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,
 537                                      grant_ref_t *gnt_refs,
 538                                      unsigned int nr_grefs,
 539                                      void **vaddr)
 540 {
 541         struct xenbus_map_node *node;
 542         struct vm_struct *area;
 543         pte_t *ptes[XENBUS_MAX_RING_PAGES];
 544         phys_addr_t phys_addrs[XENBUS_MAX_RING_PAGES];
 545         int err = GNTST_okay;
 546         int i;
 547         bool leaked;
 548
 549         *vaddr = NULL;
 550
 551         if (nr_grefs > XENBUS_MAX_RING_PAGES)
 552                 return -EINVAL;
 553
 554         node = kzalloc(sizeof(*node), GFP_KERNEL);
 555         if (!node)
 556                 return -ENOMEM;
 557
 558         area = alloc_vm_area(PAGE_SIZE * nr_grefs, ptes);
 559         if (!area) {
 560                 kfree(node);
 561                 return -ENOMEM;
 562         }
 563
 564         for (i = 0; i < nr_grefs; i++)
 565                 phys_addrs[i] = arbitrary_virt_to_machine(ptes[i]).maddr;
 566
 567         err = __xenbus_map_ring(dev, gnt_refs, nr_grefs, node->handles,
 568                                 phys_addrs,
 569                                 GNTMAP_host_map | GNTMAP_contains_pte,
 570                                 &leaked);
 571         if (err)
 572                 goto failed;
 573
 574         node->nr_handles = nr_grefs;
 575         node->pv.area = area;
 576
 577         spin_lock(&xenbus_valloc_lock);
 578         list_add(&node->next, &xenbus_valloc_pages);
 579         spin_unlock(&xenbus_valloc_lock);
 580
 581         *vaddr = area->addr;
 582         return 0;
 583
 584 failed:
 585         if (!leaked)
 586                 free_vm_area(area);
 587         else
 588                 pr_alert("leaking VM area %p size %u page(s)", area, nr_grefs);
 589
 590         kfree(node);
 591         return err;
 592 }
 593
 594 static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
 595                                       grant_ref_t *gnt_ref,
 596                                       unsigned int nr_grefs,
 597                                       void **vaddr)
 598 {
 599         struct xenbus_map_node *node;
 600         int i;
 601         int err;
 602         void *addr;
 603         bool leaked = false;
 604         /* Why do we need two arrays? See comment of __xenbus_map_ring */
 605         phys_addr_t phys_addrs[XENBUS_MAX_RING_PAGES];
 606         unsigned long addrs[XENBUS_MAX_RING_PAGES];
 607
 608         if (nr_grefs > XENBUS_MAX_RING_PAGES)
 609                 return -EINVAL;
 610
 611         *vaddr = NULL;
 612
 613         node = kzalloc(sizeof(*node), GFP_KERNEL);
 614         if (!node)
 615                 return -ENOMEM;
 616
 617         err = alloc_xenballooned_pages(nr_grefs, node->hvm.pages);
 618         if (err)
 619                 goto out_err;
 620
 621         for (i = 0; i < nr_grefs; i++) {
 622                 unsigned long pfn = page_to_pfn(node->hvm.pages[i]);
 623                 phys_addrs[i] = (unsigned long)pfn_to_kaddr(pfn);
 624                 addrs[i] = (unsigned long)pfn_to_kaddr(pfn);
 625         }
 626
 627         err = __xenbus_map_ring(dev, gnt_ref, nr_grefs, node->handles,
 628                                 phys_addrs, GNTMAP_host_map, &leaked);
 629         node->nr_handles = nr_grefs;
 630
 631         if (err)
 632                 goto out_free_ballooned_pages;
 633
 634         addr = vmap(node->hvm.pages, nr_grefs, VM_MAP | VM_IOREMAP,
 635                     PAGE_KERNEL);
 636         if (!addr) {
 637                 err = -ENOMEM;
 638                 goto out_xenbus_unmap_ring;
 639         }
 640
 641         node->hvm.addr = addr;
 642
 643         spin_lock(&xenbus_valloc_lock);
 644         list_add(&node->next, &xenbus_valloc_pages);
 645         spin_unlock(&xenbus_valloc_lock);
 646
 647         *vaddr = addr;
 648         return 0;
 649
 650  out_xenbus_unmap_ring:
 651         if (!leaked)
 652                 xenbus_unmap_ring(dev, node->handles, node->nr_handles,
 653                                   addrs);
 654         else
 655                 pr_alert("leaking %p size %u page(s)",
 656                          addr, nr_grefs);
 657  out_free_ballooned_pages:
 658         if (!leaked)
 659                 free_xenballooned_pages(nr_grefs, node->hvm.pages);
 660  out_err:
 661         kfree(node);
 662         return err;
 663 }
 664
 665
 666 /**
 667  * xenbus_map_ring
 668  * @dev: xenbus device
 669  * @gnt_refs: grant reference array
 670  * @nr_grefs: number of grant reference
 671  * @handles: pointer to grant handle to be filled
 672  * @vaddrs: addresses to be mapped to
 673  * @leaked: fail to clean up a failed map, caller should not free vaddr
 674  *
 675  * Map pages of memory into this domain from another domain's grant table.
 676  * xenbus_map_ring does not allocate the virtual address space (you must do
 677  * this yourself!). It only maps in the pages to the specified address.
 678  * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h)
 679  * or -ENOMEM / -EINVAL on error. If an error is returned, device will switch to
 680  * XenbusStateClosing and the first error message will be saved in XenStore.
 681  * Further more if we fail to map the ring, caller should check @leaked.
 682  * If @leaked is not zero it means xenbus_map_ring fails to clean up, caller
 683  * should not free the address space of @vaddr.
 684  */
 685 int xenbus_map_ring(struct xenbus_device *dev, grant_ref_t *gnt_refs,
 686                     unsigned int nr_grefs, grant_handle_t *handles,
 687                     unsigned long *vaddrs, bool *leaked)
 688 {
 689         phys_addr_t phys_addrs[XENBUS_MAX_RING_PAGES];
 690         int i;
 691
 692         if (nr_grefs > XENBUS_MAX_RING_PAGES)
 693                 return -EINVAL;
 694
 695         for (i = 0; i < nr_grefs; i++)
 696                 phys_addrs[i] = (unsigned long)vaddrs[i];
 697
 698         return __xenbus_map_ring(dev, gnt_refs, nr_grefs, handles,
 699                                  phys_addrs, GNTMAP_host_map, leaked);
 700 }
 701 EXPORT_SYMBOL_GPL(xenbus_map_ring);
 702
 703
 704 /**
 705  * xenbus_unmap_ring_vfree
 706  * @dev: xenbus device
 707  * @vaddr: addr to unmap
 708  *
 709  * Based on Rusty Russell's skeleton driver's unmap_page.
 710  * Unmap a page of memory in this domain that was imported from another domain.
 711  * Use xenbus_unmap_ring_vfree if you mapped in your memory with
 712  * xenbus_map_ring_valloc (it will free the virtual address space).
 713  * Returns 0 on success and returns GNTST_* on error
 714  * (see xen/include/interface/grant_table.h).
 715  */
 716 int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr)
 717 {
 718         return ring_ops->unmap(dev, vaddr);
 719 }
 720 EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
 721
 722 static int xenbus_unmap_ring_vfree_pv(struct xenbus_device *dev, void *vaddr)
 723 {
 724         struct xenbus_map_node *node;
 725         struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_PAGES];
 726         unsigned int level;
 727         int i;
 728         bool leaked = false;
 729         int err;
 730
 731         spin_lock(&xenbus_valloc_lock);
 732         list_for_each_entry(node, &xenbus_valloc_pages, next) {
 733                 if (node->pv.area->addr == vaddr) {
 734                         list_del(&node->next);
 735                         goto found;
 736                 }
 737         }
 738         node = NULL;
 739  found:
 740         spin_unlock(&xenbus_valloc_lock);
 741
 742         if (!node) {
 743                 xenbus_dev_error(dev, -ENOENT,
 744                                  "can't find mapped virtual address %p", vaddr);
 745                 return GNTST_bad_virt_addr;
 746         }
 747
 748         for (i = 0; i < node->nr_handles; i++) {
 749                 unsigned long addr;
 750
 751                 memset(&unmap[i], 0, sizeof(unmap[i]));
 752                 addr = (unsigned long)vaddr + (PAGE_SIZE * i);
 753                 unmap[i].host_addr = arbitrary_virt_to_machine(
 754                         lookup_address(addr, &level)).maddr;
 755                 unmap[i].dev_bus_addr = 0;
 756                 unmap[i].handle = node->handles[i];
 757         }
 758
 759         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, i))
 760                 BUG();
 761
 762         err = GNTST_okay;
 763         leaked = false;
 764         for (i = 0; i < node->nr_handles; i++) {
 765                 if (unmap[i].status != GNTST_okay) {
 766                         leaked = true;
 767                         xenbus_dev_error(dev, unmap[i].status,
 768                                          "unmapping page at handle %d error %d",
 769                                          node->handles[i], unmap[i].status);
 770                         err = unmap[i].status;
 771                         break;
 772                 }
 773         }
 774
 775         if (!leaked)
 776                 free_vm_area(node->pv.area);
 777         else
 778                 pr_alert("leaking VM area %p size %u page(s)",
 779                          node->pv.area, node->nr_handles);
 780
 781         kfree(node);
 782         return err;
 783 }
 784
 785 static int xenbus_unmap_ring_vfree_hvm(struct xenbus_device *dev, void *vaddr)
 786 {
 787         int rv;
 788         struct xenbus_map_node *node;
 789         void *addr;
 790         unsigned long addrs[XENBUS_MAX_RING_PAGES];
 791         int i;
 792
 793         spin_lock(&xenbus_valloc_lock);
 794         list_for_each_entry(node, &xenbus_valloc_pages, next) {
 795                 addr = node->hvm.addr;
 796                 if (addr == vaddr) {
 797                         list_del(&node->next);
 798                         goto found;
 799                 }
 800         }
 801         node = addr = NULL;
 802  found:
 803         spin_unlock(&xenbus_valloc_lock);
 804
 805         if (!node) {
 806                 xenbus_dev_error(dev, -ENOENT,
 807                                  "can't find mapped virtual address %p", vaddr);
 808                 return GNTST_bad_virt_addr;
 809         }
 810
 811         for (i = 0; i < node->nr_handles; i++)
 812                 addrs[i] = (unsigned long)pfn_to_kaddr(page_to_pfn(node->hvm.pages[i]));
 813
 814         rv = xenbus_unmap_ring(dev, node->handles, node->nr_handles,
 815                                addrs);
 816         if (!rv) {
 817                 vunmap(vaddr);
 818                 free_xenballooned_pages(node->nr_handles, node->hvm.pages);
 819         }
 820         else
 821                 WARN(1, "Leaking %p, size %u page(s)\n", vaddr,
 822                      node->nr_handles);
 823
 824         kfree(node);
 825         return rv;
 826 }
 827
 828 /**
 829  * xenbus_unmap_ring
 830  * @dev: xenbus device
 831  * @handles: grant handle array
 832  * @nr_handles: number of handles in the array
 833  * @vaddrs: addresses to unmap
 834  *
 835  * Unmap memory in this domain that was imported from another domain.
 836  * Returns 0 on success and returns GNTST_* on error
 837  * (see xen/include/interface/grant_table.h).
 838  */
 839 int xenbus_unmap_ring(struct xenbus_device *dev,
 840                       grant_handle_t *handles, unsigned int nr_handles,
 841                       unsigned long *vaddrs)
 842 {
 843         struct gnttab_unmap_grant_ref unmap[XENBUS_MAX_RING_PAGES];
 844         int i;
 845         int err;
 846
 847         if (nr_handles > XENBUS_MAX_RING_PAGES)
 848                 return -EINVAL;
 849
 850         for (i = 0; i < nr_handles; i++)
 851                 gnttab_set_unmap_op(&unmap[i], vaddrs[i],
 852                                     GNTMAP_host_map, handles[i]);
 853
 854         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, unmap, i))
 855                 BUG();
 856
 857         err = GNTST_okay;
 858         for (i = 0; i < nr_handles; i++) {
 859                 if (unmap[i].status != GNTST_okay) {
 860                         xenbus_dev_error(dev, unmap[i].status,
 861                                          "unmapping page at handle %d error %d",
 862                                          handles[i], unmap[i].status);
 863                         err = unmap[i].status;
 864                         break;
 865                 }
 866         }
 867
 868         return err;
 869 }
 870 EXPORT_SYMBOL_GPL(xenbus_unmap_ring);
 871
 872
 873 /**
 874  * xenbus_read_driver_state
 875  * @path: path for driver
 876  *
 877  * Return the state of the driver rooted at the given store path, or
 878  * XenbusStateUnknown if no state can be read.
 879  */
 880 enum xenbus_state xenbus_read_driver_state(const char *path)
 881 {
 882         enum xenbus_state result;
 883         int err = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
 884         if (err)
 885                 result = XenbusStateUnknown;
 886
 887         return result;
 888 }
 889 EXPORT_SYMBOL_GPL(xenbus_read_driver_state);
 890
 891 static const struct xenbus_ring_ops ring_ops_pv = {
 892         .map = xenbus_map_ring_valloc_pv,
 893         .unmap = xenbus_unmap_ring_vfree_pv,
 894 };
 895
 896 static const struct xenbus_ring_ops ring_ops_hvm = {
 897         .map = xenbus_map_ring_valloc_hvm,
 898         .unmap = xenbus_unmap_ring_vfree_hvm,
 899 };
 900
 901 void __init xenbus_ring_ops_init(void)
 902 {
 903         if (!xen_feature(XENFEAT_auto_translated_physmap))
 904                 ring_ops = &ring_ops_pv;
 905         else
 906                 ring_ops = &ring_ops_hvm;
 907 }