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