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