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