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