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