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