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