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/slab.h>
  34 #include <linux/types.h>
  35 #include <linux/spinlock.h>
  36 #include <linux/vmalloc.h>
  37 #include <linux/export.h>
  38 #include <asm/xen/hypervisor.h>
  39 #include <asm/xen/page.h>
  40 #include <xen/interface/xen.h>
  41 #include <xen/interface/event_channel.h>
  42 #include <xen/balloon.h>
  43 #include <xen/events.h>
  44 #include <xen/grant_table.h>
  45 #include <xen/xenbus.h>
  46 #include <xen/xen.h>
  47
  48 #include "xenbus_probe.h"
  49
  50 struct xenbus_map_node {
  51         struct list_head next;
  52         union {
  53                 struct vm_struct *area; /* PV */
  54                 struct page *page;     /* HVM */
  55         };
  56         grant_handle_t handle;
  57 };
  58
  59 static DEFINE_SPINLOCK(xenbus_valloc_lock);
  60 static LIST_HEAD(xenbus_valloc_pages);
  61
  62 struct xenbus_ring_ops {
  63         int (*map)(struct xenbus_device *dev, int gnt, void **vaddr);
  64         int (*unmap)(struct xenbus_device *dev, void *vaddr);
  65 };
  66
  67 static const struct xenbus_ring_ops *ring_ops __read_mostly;
  68
  69 const char *xenbus_strstate(enum xenbus_state state)
  70 {
  71         static const char *const name[] = {
  72                 [ XenbusStateUnknown      ] = "Unknown",
  73                 [ XenbusStateInitialising ] = "Initialising",
  74                 [ XenbusStateInitWait     ] = "InitWait",
  75                 [ XenbusStateInitialised  ] = "Initialised",
  76                 [ XenbusStateConnected    ] = "Connected",
  77                 [ XenbusStateClosing      ] = "Closing",
  78                 [ XenbusStateClosed       ] = "Closed",
  79                 [XenbusStateReconfiguring] = "Reconfiguring",
  80                 [XenbusStateReconfigured] = "Reconfigured",
  81         };
  82         return (state < ARRAY_SIZE(name)) ? name[state] : "INVALID";
  83 }
  84 EXPORT_SYMBOL_GPL(xenbus_strstate);
  85
  86 /**
  87  * xenbus_watch_path - register a watch
  88  * @dev: xenbus device
  89  * @path: path to watch
  90  * @watch: watch to register
  91  * @callback: callback to register
  92  *
  93  * Register a @watch on the given path, using the given xenbus_watch structure
  94  * for storage, and the given @callback function as the callback.  Return 0 on
  95  * success, or -errno on error.  On success, the given @path will be saved as
  96  * @watch->node, and remains the caller's to free.  On error, @watch->node will
  97  * be NULL, the device will switch to %XenbusStateClosing, and the error will
  98  * be saved in the store.
  99  */
 100 int xenbus_watch_path(struct xenbus_device *dev, const char *path,
 101                       struct xenbus_watch *watch,
 102                       void (*callback)(struct xenbus_watch *,
 103                                        const char **, unsigned int))
 104 {
 105         int err;
 106
 107         watch->node = path;
 108         watch->callback = callback;
 109
 110         err = register_xenbus_watch(watch);
 111
 112         if (err) {
 113                 watch->node = NULL;
 114                 watch->callback = NULL;
 115                 xenbus_dev_fatal(dev, err, "adding watch on %s", path);
 116         }
 117
 118         return err;
 119 }
 120 EXPORT_SYMBOL_GPL(xenbus_watch_path);
 121
 122
 123 /**
 124  * xenbus_watch_pathfmt - register a watch on a sprintf-formatted path
 125  * @dev: xenbus device
 126  * @watch: watch to register
 127  * @callback: callback to register
 128  * @pathfmt: format of path to watch
 129  *
 130  * Register a watch on the given @path, using the given xenbus_watch
 131  * structure for storage, and the given @callback function as the callback.
 132  * Return 0 on success, or -errno on error.  On success, the watched path
 133  * (@path/@path2) will be saved as @watch->node, and becomes the caller's to
 134  * kfree().  On error, watch->node will be NULL, so the caller has nothing to
 135  * free, the device will switch to %XenbusStateClosing, and the error will be
 136  * saved in the store.
 137  */
 138 int xenbus_watch_pathfmt(struct xenbus_device *dev,
 139                          struct xenbus_watch *watch,
 140                          void (*callback)(struct xenbus_watch *,
 141                                         const char **, unsigned int),
 142                          const char *pathfmt, ...)
 143 {
 144         int err;
 145         va_list ap;
 146         char *path;
 147
 148         va_start(ap, pathfmt);
 149         path = kvasprintf(GFP_NOIO | __GFP_HIGH, pathfmt, ap);
 150         va_end(ap);
 151
 152         if (!path) {
 153                 xenbus_dev_fatal(dev, -ENOMEM, "allocating path for watch");
 154                 return -ENOMEM;
 155         }
 156         err = xenbus_watch_path(dev, path, watch, callback);
 157
 158         if (err)
 159                 kfree(path);
 160         return err;
 161 }
 162 EXPORT_SYMBOL_GPL(xenbus_watch_pathfmt);
 163
 164 static void xenbus_switch_fatal(struct xenbus_device *, int, int,
 165                                 const char *, ...);
 166
 167 static int
 168 __xenbus_switch_state(struct xenbus_device *dev,
 169                       enum xenbus_state state, int depth)
 170 {
 171         /* We check whether the state is currently set to the given value, and
 172            if not, then the state is set.  We don't want to unconditionally
 173            write the given state, because we don't want to fire watches
 174            unnecessarily.  Furthermore, if the node has gone, we don't write
 175            to it, as the device will be tearing down, and we don't want to
 176            resurrect that directory.
 177
 178            Note that, because of this cached value of our state, this
 179            function will not take a caller's Xenstore transaction
 180            (something it was trying to in the past) because dev->state
 181            would not get reset if the transaction was aborted.
 182          */
 183
 184         struct xenbus_transaction xbt;
 185         int current_state;
 186         int err, abort;
 187
 188         if (state == dev->state)
 189                 return 0;
 190
 191 again:
 192         abort = 1;
 193
 194         err = xenbus_transaction_start(&xbt);
 195         if (err) {
 196                 xenbus_switch_fatal(dev, depth, err, "starting transaction");
 197                 return 0;
 198         }
 199
 200         err = xenbus_scanf(xbt, dev->nodename, "state", "%d", &current_state);
 201         if (err != 1)
 202                 goto abort;
 203
 204         err = xenbus_printf(xbt, dev->nodename, "state", "%d", state);
 205         if (err) {
 206                 xenbus_switch_fatal(dev, depth, err, "writing new state");
 207                 goto abort;
 208         }
 209
 210         abort = 0;
 211 abort:
 212         err = xenbus_transaction_end(xbt, abort);
 213         if (err) {
 214                 if (err == -EAGAIN && !abort)
 215                         goto again;
 216                 xenbus_switch_fatal(dev, depth, err, "ending transaction");
 217         } else
 218                 dev->state = state;
 219
 220         return 0;
 221 }
 222
 223 /**
 224  * xenbus_switch_state
 225  * @dev: xenbus device
 226  * @state: new state
 227  *
 228  * Advertise in the store a change of the given driver to the given new_state.
 229  * Return 0 on success, or -errno on error.  On error, the device will switch
 230  * to XenbusStateClosing, and the error will be saved in the store.
 231  */
 232 int xenbus_switch_state(struct xenbus_device *dev, enum xenbus_state state)
 233 {
 234         return __xenbus_switch_state(dev, state, 0);
 235 }
 236
 237 EXPORT_SYMBOL_GPL(xenbus_switch_state);
 238
 239 int xenbus_frontend_closed(struct xenbus_device *dev)
 240 {
 241         xenbus_switch_state(dev, XenbusStateClosed);
 242         complete(&dev->down);
 243         return 0;
 244 }
 245 EXPORT_SYMBOL_GPL(xenbus_frontend_closed);
 246
 247 /**
 248  * Return the path to the error node for the given device, or NULL on failure.
 249  * If the value returned is non-NULL, then it is the caller's to kfree.
 250  */
 251 static char *error_path(struct xenbus_device *dev)
 252 {
 253         return kasprintf(GFP_KERNEL, "error/%s", dev->nodename);
 254 }
 255
 256
 257 static void xenbus_va_dev_error(struct xenbus_device *dev, int err,
 258                                 const char *fmt, va_list ap)
 259 {
 260         int ret;
 261         unsigned int len;
 262         char *printf_buffer = NULL;
 263         char *path_buffer = NULL;
 264
 265 #define PRINTF_BUFFER_SIZE 4096
 266         printf_buffer = kmalloc(PRINTF_BUFFER_SIZE, GFP_KERNEL);
 267         if (printf_buffer == NULL)
 268                 goto fail;
 269
 270         len = sprintf(printf_buffer, "%i ", -err);
 271         ret = vsnprintf(printf_buffer+len, PRINTF_BUFFER_SIZE-len, fmt, ap);
 272
 273         BUG_ON(len + ret > PRINTF_BUFFER_SIZE-1);
 274
 275         dev_err(&dev->dev, "%s\n", printf_buffer);
 276
 277         path_buffer = error_path(dev);
 278
 279         if (path_buffer == NULL) {
 280                 dev_err(&dev->dev, "failed to write error node for %s (%s)\n",
 281                        dev->nodename, printf_buffer);
 282                 goto fail;
 283         }
 284
 285         if (xenbus_write(XBT_NIL, path_buffer, "error", printf_buffer) != 0) {
 286                 dev_err(&dev->dev, "failed to write error node for %s (%s)\n",
 287                        dev->nodename, printf_buffer);
 288                 goto fail;
 289         }
 290
 291 fail:
 292         kfree(printf_buffer);
 293         kfree(path_buffer);
 294 }
 295
 296
 297 /**
 298  * xenbus_dev_error
 299  * @dev: xenbus device
 300  * @err: error to report
 301  * @fmt: error message format
 302  *
 303  * Report the given negative errno into the store, along with the given
 304  * formatted message.
 305  */
 306 void xenbus_dev_error(struct xenbus_device *dev, int err, const char *fmt, ...)
 307 {
 308         va_list ap;
 309
 310         va_start(ap, fmt);
 311         xenbus_va_dev_error(dev, err, fmt, ap);
 312         va_end(ap);
 313 }
 314 EXPORT_SYMBOL_GPL(xenbus_dev_error);
 315
 316 /**
 317  * xenbus_dev_fatal
 318  * @dev: xenbus device
 319  * @err: error to report
 320  * @fmt: error message format
 321  *
 322  * Equivalent to xenbus_dev_error(dev, err, fmt, args), followed by
 323  * xenbus_switch_state(dev, XenbusStateClosing) to schedule an orderly
 324  * closedown of this driver and its peer.
 325  */
 326
 327 void xenbus_dev_fatal(struct xenbus_device *dev, int err, const char *fmt, ...)
 328 {
 329         va_list ap;
 330
 331         va_start(ap, fmt);
 332         xenbus_va_dev_error(dev, err, fmt, ap);
 333         va_end(ap);
 334
 335         xenbus_switch_state(dev, XenbusStateClosing);
 336 }
 337 EXPORT_SYMBOL_GPL(xenbus_dev_fatal);
 338
 339 /**
 340  * Equivalent to xenbus_dev_fatal(dev, err, fmt, args), but helps
 341  * avoiding recursion within xenbus_switch_state.
 342  */
 343 static void xenbus_switch_fatal(struct xenbus_device *dev, int depth, int err,
 344                                 const char *fmt, ...)
 345 {
 346         va_list ap;
 347
 348         va_start(ap, fmt);
 349         xenbus_va_dev_error(dev, err, fmt, ap);
 350         va_end(ap);
 351
 352         if (!depth)
 353                 __xenbus_switch_state(dev, XenbusStateClosing, 1);
 354 }
 355
 356 /**
 357  * xenbus_grant_ring
 358  * @dev: xenbus device
 359  * @ring_mfn: mfn of ring to grant
 360
 361  * Grant access to the given @ring_mfn to the peer of the given device.  Return
 362  * 0 on success, or -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, unsigned long ring_mfn)
 366 {
 367         int err = gnttab_grant_foreign_access(dev->otherend_id, ring_mfn, 0);
 368         if (err < 0)
 369                 xenbus_dev_fatal(dev, err, "granting access to ring page");
 370         return err;
 371 }
 372 EXPORT_SYMBOL_GPL(xenbus_grant_ring);
 373
 374
 375 /**
 376  * Allocate an event channel for the given xenbus_device, assigning the newly
 377  * created local port to *port.  Return 0 on success, or -errno on error.  On
 378  * error, the device will switch to XenbusStateClosing, and the error will be
 379  * saved in the store.
 380  */
 381 int xenbus_alloc_evtchn(struct xenbus_device *dev, int *port)
 382 {
 383         struct evtchn_alloc_unbound alloc_unbound;
 384         int err;
 385
 386         alloc_unbound.dom = DOMID_SELF;
 387         alloc_unbound.remote_dom = dev->otherend_id;
 388
 389         err = HYPERVISOR_event_channel_op(EVTCHNOP_alloc_unbound,
 390                                           &alloc_unbound);
 391         if (err)
 392                 xenbus_dev_fatal(dev, err, "allocating event channel");
 393         else
 394                 *port = alloc_unbound.port;
 395
 396         return err;
 397 }
 398 EXPORT_SYMBOL_GPL(xenbus_alloc_evtchn);
 399
 400
 401 /**
 402  * Bind to an existing interdomain event channel in another domain. Returns 0
 403  * on success and stores the local port in *port. On error, returns -errno,
 404  * switches the device to XenbusStateClosing, and saves the error in XenStore.
 405  */
 406 int xenbus_bind_evtchn(struct xenbus_device *dev, int remote_port, int *port)
 407 {
 408         struct evtchn_bind_interdomain bind_interdomain;
 409         int err;
 410
 411         bind_interdomain.remote_dom = dev->otherend_id;
 412         bind_interdomain.remote_port = remote_port;
 413
 414         err = HYPERVISOR_event_channel_op(EVTCHNOP_bind_interdomain,
 415                                           &bind_interdomain);
 416         if (err)
 417                 xenbus_dev_fatal(dev, err,
 418                                  "binding to event channel %d from domain %d",
 419                                  remote_port, dev->otherend_id);
 420         else
 421                 *port = bind_interdomain.local_port;
 422
 423         return err;
 424 }
 425 EXPORT_SYMBOL_GPL(xenbus_bind_evtchn);
 426
 427
 428 /**
 429  * Free an existing event channel. Returns 0 on success or -errno on error.
 430  */
 431 int xenbus_free_evtchn(struct xenbus_device *dev, int port)
 432 {
 433         struct evtchn_close close;
 434         int err;
 435
 436         close.port = port;
 437
 438         err = HYPERVISOR_event_channel_op(EVTCHNOP_close, &close);
 439         if (err)
 440                 xenbus_dev_error(dev, err, "freeing event channel %d", port);
 441
 442         return err;
 443 }
 444 EXPORT_SYMBOL_GPL(xenbus_free_evtchn);
 445
 446
 447 /**
 448  * xenbus_map_ring_valloc
 449  * @dev: xenbus device
 450  * @gnt_ref: grant reference
 451  * @vaddr: pointer to address to be filled out by mapping
 452  *
 453  * Based on Rusty Russell's skeleton driver's map_page.
 454  * Map a page of memory into this domain from another domain's grant table.
 455  * xenbus_map_ring_valloc allocates a page of virtual address space, maps the
 456  * page to that address, and sets *vaddr to that address.
 457  * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h)
 458  * or -ENOMEM on error. If an error is returned, device will switch to
 459  * XenbusStateClosing and the error message will be saved in XenStore.
 460  */
 461 int xenbus_map_ring_valloc(struct xenbus_device *dev, int gnt_ref, void **vaddr)
 462 {
 463         return ring_ops->map(dev, gnt_ref, vaddr);
 464 }
 465 EXPORT_SYMBOL_GPL(xenbus_map_ring_valloc);
 466
 467 static int xenbus_map_ring_valloc_pv(struct xenbus_device *dev,
 468                                      int gnt_ref, void **vaddr)
 469 {
 470         struct gnttab_map_grant_ref op = {
 471                 .flags = GNTMAP_host_map | GNTMAP_contains_pte,
 472                 .ref   = gnt_ref,
 473                 .dom   = dev->otherend_id,
 474         };
 475         struct xenbus_map_node *node;
 476         struct vm_struct *area;
 477         pte_t *pte;
 478
 479         *vaddr = NULL;
 480
 481         node = kzalloc(sizeof(*node), GFP_KERNEL);
 482         if (!node)
 483                 return -ENOMEM;
 484
 485         area = alloc_vm_area(PAGE_SIZE, &pte);
 486         if (!area) {
 487                 kfree(node);
 488                 return -ENOMEM;
 489         }
 490
 491         op.host_addr = arbitrary_virt_to_machine(pte).maddr;
 492
 493         if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
 494                 BUG();
 495
 496         if (op.status != GNTST_okay) {
 497                 free_vm_area(area);
 498                 kfree(node);
 499                 xenbus_dev_fatal(dev, op.status,
 500                                  "mapping in shared page %d from domain %d",
 501                                  gnt_ref, dev->otherend_id);
 502                 return op.status;
 503         }
 504
 505         node->handle = op.handle;
 506         node->area = area;
 507
 508         spin_lock(&xenbus_valloc_lock);
 509         list_add(&node->next, &xenbus_valloc_pages);
 510         spin_unlock(&xenbus_valloc_lock);
 511
 512         *vaddr = area->addr;
 513         return 0;
 514 }
 515
 516 static int xenbus_map_ring_valloc_hvm(struct xenbus_device *dev,
 517                                       int gnt_ref, void **vaddr)
 518 {
 519         struct xenbus_map_node *node;
 520         int err;
 521         void *addr;
 522
 523         *vaddr = NULL;
 524
 525         node = kzalloc(sizeof(*node), GFP_KERNEL);
 526         if (!node)
 527                 return -ENOMEM;
 528
 529         err = alloc_xenballooned_pages(1, &node->page, false /* lowmem */);
 530         if (err)
 531                 goto out_err;
 532
 533         addr = pfn_to_kaddr(page_to_pfn(node->page));
 534
 535         err = xenbus_map_ring(dev, gnt_ref, &node->handle, addr);
 536         if (err)
 537                 goto out_err;
 538
 539         spin_lock(&xenbus_valloc_lock);
 540         list_add(&node->next, &xenbus_valloc_pages);
 541         spin_unlock(&xenbus_valloc_lock);
 542
 543         *vaddr = addr;
 544         return 0;
 545
 546  out_err:
 547         free_xenballooned_pages(1, &node->page);
 548         kfree(node);
 549         return err;
 550 }
 551
 552
 553 /**
 554  * xenbus_map_ring
 555  * @dev: xenbus device
 556  * @gnt_ref: grant reference
 557  * @handle: pointer to grant handle to be filled
 558  * @vaddr: address to be mapped to
 559  *
 560  * Map a page of memory into this domain from another domain's grant table.
 561  * xenbus_map_ring does not allocate the virtual address space (you must do
 562  * this yourself!). It only maps in the page to the specified address.
 563  * Returns 0 on success, and GNTST_* (see xen/include/interface/grant_table.h)
 564  * or -ENOMEM on error. If an error is returned, device will switch to
 565  * XenbusStateClosing and the error message will be saved in XenStore.
 566  */
 567 int xenbus_map_ring(struct xenbus_device *dev, int gnt_ref,
 568                     grant_handle_t *handle, void *vaddr)
 569 {
 570         struct gnttab_map_grant_ref op;
 571
 572         gnttab_set_map_op(&op, (unsigned long)vaddr, GNTMAP_host_map, gnt_ref,
 573                           dev->otherend_id);
 574
 575         if (HYPERVISOR_grant_table_op(GNTTABOP_map_grant_ref, &op, 1))
 576                 BUG();
 577
 578         if (op.status != GNTST_okay) {
 579                 xenbus_dev_fatal(dev, op.status,
 580                                  "mapping in shared page %d from domain %d",
 581                                  gnt_ref, dev->otherend_id);
 582         } else
 583                 *handle = op.handle;
 584
 585         return op.status;
 586 }
 587 EXPORT_SYMBOL_GPL(xenbus_map_ring);
 588
 589
 590 /**
 591  * xenbus_unmap_ring_vfree
 592  * @dev: xenbus device
 593  * @vaddr: addr to unmap
 594  *
 595  * Based on Rusty Russell's skeleton driver's unmap_page.
 596  * Unmap a page of memory in this domain that was imported from another domain.
 597  * Use xenbus_unmap_ring_vfree if you mapped in your memory with
 598  * xenbus_map_ring_valloc (it will free the virtual address space).
 599  * Returns 0 on success and returns GNTST_* on error
 600  * (see xen/include/interface/grant_table.h).
 601  */
 602 int xenbus_unmap_ring_vfree(struct xenbus_device *dev, void *vaddr)
 603 {
 604         return ring_ops->unmap(dev, vaddr);
 605 }
 606 EXPORT_SYMBOL_GPL(xenbus_unmap_ring_vfree);
 607
 608 static int xenbus_unmap_ring_vfree_pv(struct xenbus_device *dev, void *vaddr)
 609 {
 610         struct xenbus_map_node *node;
 611         struct gnttab_unmap_grant_ref op = {
 612                 .host_addr = (unsigned long)vaddr,
 613         };
 614         unsigned int level;
 615
 616         spin_lock(&xenbus_valloc_lock);
 617         list_for_each_entry(node, &xenbus_valloc_pages, next) {
 618                 if (node->area->addr == vaddr) {
 619                         list_del(&node->next);
 620                         goto found;
 621                 }
 622         }
 623         node = NULL;
 624  found:
 625         spin_unlock(&xenbus_valloc_lock);
 626
 627         if (!node) {
 628                 xenbus_dev_error(dev, -ENOENT,
 629                                  "can't find mapped virtual address %p", vaddr);
 630                 return GNTST_bad_virt_addr;
 631         }
 632
 633         op.handle = node->handle;
 634         op.host_addr = arbitrary_virt_to_machine(
 635                 lookup_address((unsigned long)vaddr, &level)).maddr;
 636
 637         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
 638                 BUG();
 639
 640         if (op.status == GNTST_okay)
 641                 free_vm_area(node->area);
 642         else
 643                 xenbus_dev_error(dev, op.status,
 644                                  "unmapping page at handle %d error %d",
 645                                  node->handle, op.status);
 646
 647         kfree(node);
 648         return op.status;
 649 }
 650
 651 static int xenbus_unmap_ring_vfree_hvm(struct xenbus_device *dev, void *vaddr)
 652 {
 653         int rv;
 654         struct xenbus_map_node *node;
 655         void *addr;
 656
 657         spin_lock(&xenbus_valloc_lock);
 658         list_for_each_entry(node, &xenbus_valloc_pages, next) {
 659                 addr = pfn_to_kaddr(page_to_pfn(node->page));
 660                 if (addr == vaddr) {
 661                         list_del(&node->next);
 662                         goto found;
 663                 }
 664         }
 665         node = addr = NULL;
 666  found:
 667         spin_unlock(&xenbus_valloc_lock);
 668
 669         if (!node) {
 670                 xenbus_dev_error(dev, -ENOENT,
 671                                  "can't find mapped virtual address %p", vaddr);
 672                 return GNTST_bad_virt_addr;
 673         }
 674
 675         rv = xenbus_unmap_ring(dev, node->handle, addr);
 676
 677         if (!rv)
 678                 free_xenballooned_pages(1, &node->page);
 679         else
 680                 WARN(1, "Leaking %p\n", vaddr);
 681
 682         kfree(node);
 683         return rv;
 684 }
 685
 686 /**
 687  * xenbus_unmap_ring
 688  * @dev: xenbus device
 689  * @handle: grant handle
 690  * @vaddr: addr to unmap
 691  *
 692  * Unmap a page of memory in this domain that was imported from another domain.
 693  * Returns 0 on success and returns GNTST_* on error
 694  * (see xen/include/interface/grant_table.h).
 695  */
 696 int xenbus_unmap_ring(struct xenbus_device *dev,
 697                       grant_handle_t handle, void *vaddr)
 698 {
 699         struct gnttab_unmap_grant_ref op;
 700
 701         gnttab_set_unmap_op(&op, (unsigned long)vaddr, GNTMAP_host_map, handle);
 702
 703         if (HYPERVISOR_grant_table_op(GNTTABOP_unmap_grant_ref, &op, 1))
 704                 BUG();
 705
 706         if (op.status != GNTST_okay)
 707                 xenbus_dev_error(dev, op.status,
 708                                  "unmapping page at handle %d error %d",
 709                                  handle, op.status);
 710
 711         return op.status;
 712 }
 713 EXPORT_SYMBOL_GPL(xenbus_unmap_ring);
 714
 715
 716 /**
 717  * xenbus_read_driver_state
 718  * @path: path for driver
 719  *
 720  * Return the state of the driver rooted at the given store path, or
 721  * XenbusStateUnknown if no state can be read.
 722  */
 723 enum xenbus_state xenbus_read_driver_state(const char *path)
 724 {
 725         enum xenbus_state result;
 726         int err = xenbus_gather(XBT_NIL, path, "state", "%d", &result, NULL);
 727         if (err)
 728                 result = XenbusStateUnknown;
 729
 730         return result;
 731 }
 732 EXPORT_SYMBOL_GPL(xenbus_read_driver_state);
 733
 734 static const struct xenbus_ring_ops ring_ops_pv = {
 735         .map = xenbus_map_ring_valloc_pv,
 736         .unmap = xenbus_unmap_ring_vfree_pv,
 737 };
 738
 739 static const struct xenbus_ring_ops ring_ops_hvm = {
 740         .map = xenbus_map_ring_valloc_hvm,
 741         .unmap = xenbus_unmap_ring_vfree_hvm,
 742 };
 743
 744 void __init xenbus_ring_ops_init(void)
 745 {
 746         if (xen_pv_domain())
 747                 ring_ops = &ring_ops_pv;
 748         else
 749                 ring_ops = &ring_ops_hvm;
 750 }