xen-bus.c (38941B)
1 /* 2 * Copyright (c) 2018 Citrix Systems Inc. 3 * 4 * This work is licensed under the terms of the GNU GPL, version 2 or later. 5 * See the COPYING file in the top-level directory. 6 */ 7 8 #include "qemu/osdep.h" 9 #include "qemu/main-loop.h" 10 #include "qemu/module.h" 11 #include "qemu/uuid.h" 12 #include "hw/qdev-properties.h" 13 #include "hw/sysbus.h" 14 #include "hw/xen/xen.h" 15 #include "hw/xen/xen-backend.h" 16 #include "hw/xen/xen-bus.h" 17 #include "hw/xen/xen-bus-helper.h" 18 #include "monitor/monitor.h" 19 #include "qapi/error.h" 20 #include "qapi/qmp/qdict.h" 21 #include "sysemu/sysemu.h" 22 #include "trace.h" 23 24 static char *xen_device_get_backend_path(XenDevice *xendev) 25 { 26 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 27 XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); 28 const char *type = object_get_typename(OBJECT(xendev)); 29 const char *backend = xendev_class->backend; 30 31 if (!backend) { 32 backend = type; 33 } 34 35 return g_strdup_printf("/local/domain/%u/backend/%s/%u/%s", 36 xenbus->backend_id, backend, xendev->frontend_id, 37 xendev->name); 38 } 39 40 static char *xen_device_get_frontend_path(XenDevice *xendev) 41 { 42 XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); 43 const char *type = object_get_typename(OBJECT(xendev)); 44 const char *device = xendev_class->device; 45 46 if (!device) { 47 device = type; 48 } 49 50 return g_strdup_printf("/local/domain/%u/device/%s/%s", 51 xendev->frontend_id, device, xendev->name); 52 } 53 54 static void xen_device_unplug(XenDevice *xendev, Error **errp) 55 { 56 ERRP_GUARD(); 57 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 58 const char *type = object_get_typename(OBJECT(xendev)); 59 xs_transaction_t tid; 60 61 trace_xen_device_unplug(type, xendev->name); 62 63 /* Mimic the way the Xen toolstack does an unplug */ 64 again: 65 tid = xs_transaction_start(xenbus->xsh); 66 if (tid == XBT_NULL) { 67 error_setg_errno(errp, errno, "failed xs_transaction_start"); 68 return; 69 } 70 71 xs_node_printf(xenbus->xsh, tid, xendev->backend_path, "online", 72 errp, "%u", 0); 73 if (*errp) { 74 goto abort; 75 } 76 77 xs_node_printf(xenbus->xsh, tid, xendev->backend_path, "state", 78 errp, "%u", XenbusStateClosing); 79 if (*errp) { 80 goto abort; 81 } 82 83 if (!xs_transaction_end(xenbus->xsh, tid, false)) { 84 if (errno == EAGAIN) { 85 goto again; 86 } 87 88 error_setg_errno(errp, errno, "failed xs_transaction_end"); 89 } 90 91 return; 92 93 abort: 94 /* 95 * We only abort if there is already a failure so ignore any error 96 * from ending the transaction. 97 */ 98 xs_transaction_end(xenbus->xsh, tid, true); 99 } 100 101 static void xen_bus_print_dev(Monitor *mon, DeviceState *dev, int indent) 102 { 103 XenDevice *xendev = XEN_DEVICE(dev); 104 105 monitor_printf(mon, "%*sname = '%s' frontend_id = %u\n", 106 indent, "", xendev->name, xendev->frontend_id); 107 } 108 109 static char *xen_bus_get_dev_path(DeviceState *dev) 110 { 111 return xen_device_get_backend_path(XEN_DEVICE(dev)); 112 } 113 114 struct XenWatch { 115 char *node, *key; 116 char *token; 117 XenWatchHandler handler; 118 void *opaque; 119 Notifier notifier; 120 }; 121 122 static void watch_notify(Notifier *n, void *data) 123 { 124 XenWatch *watch = container_of(n, XenWatch, notifier); 125 const char *token = data; 126 127 if (!strcmp(watch->token, token)) { 128 watch->handler(watch->opaque); 129 } 130 } 131 132 static XenWatch *new_watch(const char *node, const char *key, 133 XenWatchHandler handler, void *opaque) 134 { 135 XenWatch *watch = g_new0(XenWatch, 1); 136 QemuUUID uuid; 137 138 qemu_uuid_generate(&uuid); 139 140 watch->token = qemu_uuid_unparse_strdup(&uuid); 141 watch->node = g_strdup(node); 142 watch->key = g_strdup(key); 143 watch->handler = handler; 144 watch->opaque = opaque; 145 watch->notifier.notify = watch_notify; 146 147 return watch; 148 } 149 150 static void free_watch(XenWatch *watch) 151 { 152 g_free(watch->token); 153 g_free(watch->key); 154 g_free(watch->node); 155 156 g_free(watch); 157 } 158 159 struct XenWatchList { 160 struct xs_handle *xsh; 161 NotifierList notifiers; 162 }; 163 164 static void watch_list_event(void *opaque) 165 { 166 XenWatchList *watch_list = opaque; 167 char **v; 168 const char *token; 169 170 v = xs_check_watch(watch_list->xsh); 171 if (!v) { 172 return; 173 } 174 175 token = v[XS_WATCH_TOKEN]; 176 177 notifier_list_notify(&watch_list->notifiers, (void *)token); 178 179 free(v); 180 } 181 182 static XenWatchList *watch_list_create(struct xs_handle *xsh) 183 { 184 XenWatchList *watch_list = g_new0(XenWatchList, 1); 185 186 g_assert(xsh); 187 188 watch_list->xsh = xsh; 189 notifier_list_init(&watch_list->notifiers); 190 qemu_set_fd_handler(xs_fileno(watch_list->xsh), watch_list_event, NULL, 191 watch_list); 192 193 return watch_list; 194 } 195 196 static void watch_list_destroy(XenWatchList *watch_list) 197 { 198 g_assert(notifier_list_empty(&watch_list->notifiers)); 199 qemu_set_fd_handler(xs_fileno(watch_list->xsh), NULL, NULL, NULL); 200 g_free(watch_list); 201 } 202 203 static XenWatch *watch_list_add(XenWatchList *watch_list, const char *node, 204 const char *key, XenWatchHandler handler, 205 void *opaque, Error **errp) 206 { 207 ERRP_GUARD(); 208 XenWatch *watch = new_watch(node, key, handler, opaque); 209 210 notifier_list_add(&watch_list->notifiers, &watch->notifier); 211 212 xs_node_watch(watch_list->xsh, node, key, watch->token, errp); 213 if (*errp) { 214 notifier_remove(&watch->notifier); 215 free_watch(watch); 216 217 return NULL; 218 } 219 220 return watch; 221 } 222 223 static void watch_list_remove(XenWatchList *watch_list, XenWatch *watch, 224 Error **errp) 225 { 226 xs_node_unwatch(watch_list->xsh, watch->node, watch->key, watch->token, 227 errp); 228 229 notifier_remove(&watch->notifier); 230 free_watch(watch); 231 } 232 233 static XenWatch *xen_bus_add_watch(XenBus *xenbus, const char *node, 234 const char *key, XenWatchHandler handler, 235 Error **errp) 236 { 237 trace_xen_bus_add_watch(node, key); 238 239 return watch_list_add(xenbus->watch_list, node, key, handler, xenbus, 240 errp); 241 } 242 243 static void xen_bus_remove_watch(XenBus *xenbus, XenWatch *watch, 244 Error **errp) 245 { 246 trace_xen_bus_remove_watch(watch->node, watch->key); 247 248 watch_list_remove(xenbus->watch_list, watch, errp); 249 } 250 251 static void xen_bus_backend_create(XenBus *xenbus, const char *type, 252 const char *name, char *path, 253 Error **errp) 254 { 255 ERRP_GUARD(); 256 xs_transaction_t tid; 257 char **key; 258 QDict *opts; 259 unsigned int i, n; 260 261 trace_xen_bus_backend_create(type, path); 262 263 again: 264 tid = xs_transaction_start(xenbus->xsh); 265 if (tid == XBT_NULL) { 266 error_setg(errp, "failed xs_transaction_start"); 267 return; 268 } 269 270 key = xs_directory(xenbus->xsh, tid, path, &n); 271 if (!key) { 272 if (!xs_transaction_end(xenbus->xsh, tid, true)) { 273 error_setg_errno(errp, errno, "failed xs_transaction_end"); 274 } 275 return; 276 } 277 278 opts = qdict_new(); 279 for (i = 0; i < n; i++) { 280 char *val; 281 282 /* 283 * Assume anything found in the xenstore backend area, other than 284 * the keys created for a generic XenDevice, are parameters 285 * to be used to configure the backend. 286 */ 287 if (!strcmp(key[i], "state") || 288 !strcmp(key[i], "online") || 289 !strcmp(key[i], "frontend") || 290 !strcmp(key[i], "frontend-id") || 291 !strcmp(key[i], "hotplug-status")) 292 continue; 293 294 if (xs_node_scanf(xenbus->xsh, tid, path, key[i], NULL, "%ms", 295 &val) == 1) { 296 qdict_put_str(opts, key[i], val); 297 free(val); 298 } 299 } 300 301 free(key); 302 303 if (!xs_transaction_end(xenbus->xsh, tid, false)) { 304 qobject_unref(opts); 305 306 if (errno == EAGAIN) { 307 goto again; 308 } 309 310 error_setg_errno(errp, errno, "failed xs_transaction_end"); 311 return; 312 } 313 314 xen_backend_device_create(xenbus, type, name, opts, errp); 315 qobject_unref(opts); 316 317 if (*errp) { 318 error_prepend(errp, "failed to create '%s' device '%s': ", type, name); 319 } 320 } 321 322 static void xen_bus_type_enumerate(XenBus *xenbus, const char *type) 323 { 324 char *domain_path = g_strdup_printf("backend/%s/%u", type, xen_domid); 325 char **backend; 326 unsigned int i, n; 327 328 trace_xen_bus_type_enumerate(type); 329 330 backend = xs_directory(xenbus->xsh, XBT_NULL, domain_path, &n); 331 if (!backend) { 332 goto out; 333 } 334 335 for (i = 0; i < n; i++) { 336 char *backend_path = g_strdup_printf("%s/%s", domain_path, 337 backend[i]); 338 enum xenbus_state state; 339 unsigned int online; 340 341 if (xs_node_scanf(xenbus->xsh, XBT_NULL, backend_path, "state", 342 NULL, "%u", &state) != 1) 343 state = XenbusStateUnknown; 344 345 if (xs_node_scanf(xenbus->xsh, XBT_NULL, backend_path, "online", 346 NULL, "%u", &online) != 1) 347 online = 0; 348 349 if (online && state == XenbusStateInitialising) { 350 Error *local_err = NULL; 351 352 xen_bus_backend_create(xenbus, type, backend[i], backend_path, 353 &local_err); 354 if (local_err) { 355 error_report_err(local_err); 356 } 357 } 358 359 g_free(backend_path); 360 } 361 362 free(backend); 363 364 out: 365 g_free(domain_path); 366 } 367 368 static void xen_bus_enumerate(XenBus *xenbus) 369 { 370 char **type; 371 unsigned int i, n; 372 373 trace_xen_bus_enumerate(); 374 375 type = xs_directory(xenbus->xsh, XBT_NULL, "backend", &n); 376 if (!type) { 377 return; 378 } 379 380 for (i = 0; i < n; i++) { 381 xen_bus_type_enumerate(xenbus, type[i]); 382 } 383 384 free(type); 385 } 386 387 static void xen_bus_device_cleanup(XenDevice *xendev) 388 { 389 const char *type = object_get_typename(OBJECT(xendev)); 390 Error *local_err = NULL; 391 392 trace_xen_bus_device_cleanup(type, xendev->name); 393 394 g_assert(!xendev->backend_online); 395 396 if (!xen_backend_try_device_destroy(xendev, &local_err)) { 397 object_unparent(OBJECT(xendev)); 398 } 399 400 if (local_err) { 401 error_report_err(local_err); 402 } 403 } 404 405 static void xen_bus_cleanup(XenBus *xenbus) 406 { 407 XenDevice *xendev, *next; 408 409 trace_xen_bus_cleanup(); 410 411 QLIST_FOREACH_SAFE(xendev, &xenbus->inactive_devices, list, next) { 412 g_assert(xendev->inactive); 413 QLIST_REMOVE(xendev, list); 414 xen_bus_device_cleanup(xendev); 415 } 416 } 417 418 static void xen_bus_backend_changed(void *opaque) 419 { 420 XenBus *xenbus = opaque; 421 422 xen_bus_enumerate(xenbus); 423 xen_bus_cleanup(xenbus); 424 } 425 426 static void xen_bus_unrealize(BusState *bus) 427 { 428 XenBus *xenbus = XEN_BUS(bus); 429 430 trace_xen_bus_unrealize(); 431 432 if (xenbus->backend_watch) { 433 unsigned int i; 434 435 for (i = 0; i < xenbus->backend_types; i++) { 436 if (xenbus->backend_watch[i]) { 437 xen_bus_remove_watch(xenbus, xenbus->backend_watch[i], NULL); 438 } 439 } 440 441 g_free(xenbus->backend_watch); 442 xenbus->backend_watch = NULL; 443 } 444 445 if (xenbus->watch_list) { 446 watch_list_destroy(xenbus->watch_list); 447 xenbus->watch_list = NULL; 448 } 449 450 if (xenbus->xsh) { 451 xs_close(xenbus->xsh); 452 } 453 } 454 455 static void xen_bus_realize(BusState *bus, Error **errp) 456 { 457 char *key = g_strdup_printf("%u", xen_domid); 458 XenBus *xenbus = XEN_BUS(bus); 459 unsigned int domid; 460 const char **type; 461 unsigned int i; 462 Error *local_err = NULL; 463 464 trace_xen_bus_realize(); 465 466 xenbus->xsh = xs_open(0); 467 if (!xenbus->xsh) { 468 error_setg_errno(errp, errno, "failed xs_open"); 469 goto fail; 470 } 471 472 if (xs_node_scanf(xenbus->xsh, XBT_NULL, "", /* domain root node */ 473 "domid", NULL, "%u", &domid) == 1) { 474 xenbus->backend_id = domid; 475 } else { 476 xenbus->backend_id = 0; /* Assume lack of node means dom0 */ 477 } 478 479 xenbus->watch_list = watch_list_create(xenbus->xsh); 480 481 module_call_init(MODULE_INIT_XEN_BACKEND); 482 483 type = xen_backend_get_types(&xenbus->backend_types); 484 xenbus->backend_watch = g_new(XenWatch *, xenbus->backend_types); 485 486 for (i = 0; i < xenbus->backend_types; i++) { 487 char *node = g_strdup_printf("backend/%s", type[i]); 488 489 xenbus->backend_watch[i] = 490 xen_bus_add_watch(xenbus, node, key, xen_bus_backend_changed, 491 &local_err); 492 if (local_err) { 493 /* This need not be treated as a hard error so don't propagate */ 494 error_reportf_err(local_err, 495 "failed to set up '%s' enumeration watch: ", 496 type[i]); 497 } 498 499 g_free(node); 500 } 501 502 g_free(type); 503 g_free(key); 504 return; 505 506 fail: 507 xen_bus_unrealize(bus); 508 g_free(key); 509 } 510 511 static void xen_bus_unplug_request(HotplugHandler *hotplug, 512 DeviceState *dev, 513 Error **errp) 514 { 515 XenDevice *xendev = XEN_DEVICE(dev); 516 517 xen_device_unplug(xendev, errp); 518 } 519 520 static void xen_bus_class_init(ObjectClass *class, void *data) 521 { 522 BusClass *bus_class = BUS_CLASS(class); 523 HotplugHandlerClass *hotplug_class = HOTPLUG_HANDLER_CLASS(class); 524 525 bus_class->print_dev = xen_bus_print_dev; 526 bus_class->get_dev_path = xen_bus_get_dev_path; 527 bus_class->realize = xen_bus_realize; 528 bus_class->unrealize = xen_bus_unrealize; 529 530 hotplug_class->unplug_request = xen_bus_unplug_request; 531 } 532 533 static const TypeInfo xen_bus_type_info = { 534 .name = TYPE_XEN_BUS, 535 .parent = TYPE_BUS, 536 .instance_size = sizeof(XenBus), 537 .class_size = sizeof(XenBusClass), 538 .class_init = xen_bus_class_init, 539 .interfaces = (InterfaceInfo[]) { 540 { TYPE_HOTPLUG_HANDLER }, 541 { } 542 }, 543 }; 544 545 void xen_device_backend_printf(XenDevice *xendev, const char *key, 546 const char *fmt, ...) 547 { 548 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 549 Error *local_err = NULL; 550 va_list ap; 551 552 g_assert(xenbus->xsh); 553 554 va_start(ap, fmt); 555 xs_node_vprintf(xenbus->xsh, XBT_NULL, xendev->backend_path, key, 556 &local_err, fmt, ap); 557 va_end(ap); 558 559 if (local_err) { 560 error_report_err(local_err); 561 } 562 } 563 564 static int xen_device_backend_scanf(XenDevice *xendev, const char *key, 565 const char *fmt, ...) 566 { 567 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 568 va_list ap; 569 int rc; 570 571 g_assert(xenbus->xsh); 572 573 va_start(ap, fmt); 574 rc = xs_node_vscanf(xenbus->xsh, XBT_NULL, xendev->backend_path, key, 575 NULL, fmt, ap); 576 va_end(ap); 577 578 return rc; 579 } 580 581 void xen_device_backend_set_state(XenDevice *xendev, 582 enum xenbus_state state) 583 { 584 const char *type = object_get_typename(OBJECT(xendev)); 585 586 if (xendev->backend_state == state) { 587 return; 588 } 589 590 trace_xen_device_backend_state(type, xendev->name, 591 xs_strstate(state)); 592 593 xendev->backend_state = state; 594 xen_device_backend_printf(xendev, "state", "%u", state); 595 } 596 597 enum xenbus_state xen_device_backend_get_state(XenDevice *xendev) 598 { 599 return xendev->backend_state; 600 } 601 602 static void xen_device_backend_set_online(XenDevice *xendev, bool online) 603 { 604 const char *type = object_get_typename(OBJECT(xendev)); 605 606 if (xendev->backend_online == online) { 607 return; 608 } 609 610 trace_xen_device_backend_online(type, xendev->name, online); 611 612 xendev->backend_online = online; 613 xen_device_backend_printf(xendev, "online", "%u", online); 614 } 615 616 /* 617 * Tell from the state whether the frontend is likely alive, 618 * i.e. it will react to a change of state of the backend. 619 */ 620 static bool xen_device_frontend_is_active(XenDevice *xendev) 621 { 622 switch (xendev->frontend_state) { 623 case XenbusStateInitWait: 624 case XenbusStateInitialised: 625 case XenbusStateConnected: 626 case XenbusStateClosing: 627 return true; 628 default: 629 return false; 630 } 631 } 632 633 static void xen_device_backend_changed(void *opaque) 634 { 635 XenDevice *xendev = opaque; 636 const char *type = object_get_typename(OBJECT(xendev)); 637 enum xenbus_state state; 638 unsigned int online; 639 640 trace_xen_device_backend_changed(type, xendev->name); 641 642 if (xen_device_backend_scanf(xendev, "state", "%u", &state) != 1) { 643 state = XenbusStateUnknown; 644 } 645 646 xen_device_backend_set_state(xendev, state); 647 648 if (xen_device_backend_scanf(xendev, "online", "%u", &online) != 1) { 649 online = 0; 650 } 651 652 xen_device_backend_set_online(xendev, !!online); 653 654 /* 655 * If the toolstack (or unplug request callback) has set the backend 656 * state to Closing, but there is no active frontend then set the 657 * backend state to Closed. 658 */ 659 if (state == XenbusStateClosing && 660 !xen_device_frontend_is_active(xendev)) { 661 xen_device_backend_set_state(xendev, XenbusStateClosed); 662 } 663 664 /* 665 * If a backend is still 'online' then we should leave it alone but, 666 * if a backend is not 'online', then the device is a candidate 667 * for destruction. Hence add it to the 'inactive' list to be cleaned 668 * by xen_bus_cleanup(). 669 */ 670 if (!online && 671 (state == XenbusStateClosed || state == XenbusStateInitialising || 672 state == XenbusStateInitWait || state == XenbusStateUnknown) && 673 !xendev->inactive) { 674 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 675 676 xendev->inactive = true; 677 QLIST_INSERT_HEAD(&xenbus->inactive_devices, xendev, list); 678 679 /* 680 * Re-write the state to cause a XenBus backend_watch notification, 681 * resulting in a call to xen_bus_cleanup(). 682 */ 683 xen_device_backend_printf(xendev, "state", "%u", state); 684 } 685 } 686 687 static XenWatch *xen_device_add_watch(XenDevice *xendev, const char *node, 688 const char *key, 689 XenWatchHandler handler, 690 Error **errp) 691 { 692 const char *type = object_get_typename(OBJECT(xendev)); 693 694 trace_xen_device_add_watch(type, xendev->name, node, key); 695 696 return watch_list_add(xendev->watch_list, node, key, handler, xendev, 697 errp); 698 } 699 700 static void xen_device_remove_watch(XenDevice *xendev, XenWatch *watch, 701 Error **errp) 702 { 703 const char *type = object_get_typename(OBJECT(xendev)); 704 705 trace_xen_device_remove_watch(type, xendev->name, watch->node, 706 watch->key); 707 708 watch_list_remove(xendev->watch_list, watch, errp); 709 } 710 711 712 static void xen_device_backend_create(XenDevice *xendev, Error **errp) 713 { 714 ERRP_GUARD(); 715 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 716 struct xs_permissions perms[2]; 717 718 xendev->backend_path = xen_device_get_backend_path(xendev); 719 720 perms[0].id = xenbus->backend_id; 721 perms[0].perms = XS_PERM_NONE; 722 perms[1].id = xendev->frontend_id; 723 perms[1].perms = XS_PERM_READ; 724 725 g_assert(xenbus->xsh); 726 727 xs_node_create(xenbus->xsh, XBT_NULL, xendev->backend_path, perms, 728 ARRAY_SIZE(perms), errp); 729 if (*errp) { 730 error_prepend(errp, "failed to create backend: "); 731 return; 732 } 733 734 xendev->backend_state_watch = 735 xen_device_add_watch(xendev, xendev->backend_path, 736 "state", xen_device_backend_changed, 737 errp); 738 if (*errp) { 739 error_prepend(errp, "failed to watch backend state: "); 740 return; 741 } 742 743 xendev->backend_online_watch = 744 xen_device_add_watch(xendev, xendev->backend_path, 745 "online", xen_device_backend_changed, 746 errp); 747 if (*errp) { 748 error_prepend(errp, "failed to watch backend online: "); 749 return; 750 } 751 } 752 753 static void xen_device_backend_destroy(XenDevice *xendev) 754 { 755 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 756 Error *local_err = NULL; 757 758 if (xendev->backend_online_watch) { 759 xen_device_remove_watch(xendev, xendev->backend_online_watch, NULL); 760 xendev->backend_online_watch = NULL; 761 } 762 763 if (xendev->backend_state_watch) { 764 xen_device_remove_watch(xendev, xendev->backend_state_watch, NULL); 765 xendev->backend_state_watch = NULL; 766 } 767 768 if (!xendev->backend_path) { 769 return; 770 } 771 772 g_assert(xenbus->xsh); 773 774 xs_node_destroy(xenbus->xsh, XBT_NULL, xendev->backend_path, 775 &local_err); 776 g_free(xendev->backend_path); 777 xendev->backend_path = NULL; 778 779 if (local_err) { 780 error_report_err(local_err); 781 } 782 } 783 784 void xen_device_frontend_printf(XenDevice *xendev, const char *key, 785 const char *fmt, ...) 786 { 787 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 788 Error *local_err = NULL; 789 va_list ap; 790 791 g_assert(xenbus->xsh); 792 793 va_start(ap, fmt); 794 xs_node_vprintf(xenbus->xsh, XBT_NULL, xendev->frontend_path, key, 795 &local_err, fmt, ap); 796 va_end(ap); 797 798 if (local_err) { 799 error_report_err(local_err); 800 } 801 } 802 803 int xen_device_frontend_scanf(XenDevice *xendev, const char *key, 804 const char *fmt, ...) 805 { 806 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 807 va_list ap; 808 int rc; 809 810 g_assert(xenbus->xsh); 811 812 va_start(ap, fmt); 813 rc = xs_node_vscanf(xenbus->xsh, XBT_NULL, xendev->frontend_path, key, 814 NULL, fmt, ap); 815 va_end(ap); 816 817 return rc; 818 } 819 820 static void xen_device_frontend_set_state(XenDevice *xendev, 821 enum xenbus_state state, 822 bool publish) 823 { 824 const char *type = object_get_typename(OBJECT(xendev)); 825 826 if (xendev->frontend_state == state) { 827 return; 828 } 829 830 trace_xen_device_frontend_state(type, xendev->name, 831 xs_strstate(state)); 832 833 xendev->frontend_state = state; 834 if (publish) { 835 xen_device_frontend_printf(xendev, "state", "%u", state); 836 } 837 } 838 839 static void xen_device_frontend_changed(void *opaque) 840 { 841 XenDevice *xendev = opaque; 842 XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); 843 const char *type = object_get_typename(OBJECT(xendev)); 844 enum xenbus_state state; 845 846 trace_xen_device_frontend_changed(type, xendev->name); 847 848 if (xen_device_frontend_scanf(xendev, "state", "%u", &state) != 1) { 849 state = XenbusStateUnknown; 850 } 851 852 xen_device_frontend_set_state(xendev, state, false); 853 854 if (state == XenbusStateInitialising && 855 xendev->backend_state == XenbusStateClosed && 856 xendev->backend_online) { 857 /* 858 * The frontend is re-initializing so switch back to 859 * InitWait. 860 */ 861 xen_device_backend_set_state(xendev, XenbusStateInitWait); 862 return; 863 } 864 865 if (xendev_class->frontend_changed) { 866 Error *local_err = NULL; 867 868 xendev_class->frontend_changed(xendev, state, &local_err); 869 870 if (local_err) { 871 error_reportf_err(local_err, "frontend change error: "); 872 } 873 } 874 } 875 876 static bool xen_device_frontend_exists(XenDevice *xendev) 877 { 878 enum xenbus_state state; 879 880 return (xen_device_frontend_scanf(xendev, "state", "%u", &state) == 1); 881 } 882 883 static void xen_device_frontend_create(XenDevice *xendev, Error **errp) 884 { 885 ERRP_GUARD(); 886 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 887 struct xs_permissions perms[2]; 888 889 xendev->frontend_path = xen_device_get_frontend_path(xendev); 890 891 /* 892 * The frontend area may have already been created by a legacy 893 * toolstack. 894 */ 895 if (!xen_device_frontend_exists(xendev)) { 896 perms[0].id = xendev->frontend_id; 897 perms[0].perms = XS_PERM_NONE; 898 perms[1].id = xenbus->backend_id; 899 perms[1].perms = XS_PERM_READ | XS_PERM_WRITE; 900 901 g_assert(xenbus->xsh); 902 903 xs_node_create(xenbus->xsh, XBT_NULL, xendev->frontend_path, perms, 904 ARRAY_SIZE(perms), errp); 905 if (*errp) { 906 error_prepend(errp, "failed to create frontend: "); 907 return; 908 } 909 } 910 911 xendev->frontend_state_watch = 912 xen_device_add_watch(xendev, xendev->frontend_path, "state", 913 xen_device_frontend_changed, errp); 914 if (*errp) { 915 error_prepend(errp, "failed to watch frontend state: "); 916 } 917 } 918 919 static void xen_device_frontend_destroy(XenDevice *xendev) 920 { 921 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 922 Error *local_err = NULL; 923 924 if (xendev->frontend_state_watch) { 925 xen_device_remove_watch(xendev, xendev->frontend_state_watch, 926 NULL); 927 xendev->frontend_state_watch = NULL; 928 } 929 930 if (!xendev->frontend_path) { 931 return; 932 } 933 934 g_assert(xenbus->xsh); 935 936 xs_node_destroy(xenbus->xsh, XBT_NULL, xendev->frontend_path, 937 &local_err); 938 g_free(xendev->frontend_path); 939 xendev->frontend_path = NULL; 940 941 if (local_err) { 942 error_report_err(local_err); 943 } 944 } 945 946 void xen_device_set_max_grant_refs(XenDevice *xendev, unsigned int nr_refs, 947 Error **errp) 948 { 949 if (xengnttab_set_max_grants(xendev->xgth, nr_refs)) { 950 error_setg_errno(errp, errno, "xengnttab_set_max_grants failed"); 951 } 952 } 953 954 void *xen_device_map_grant_refs(XenDevice *xendev, uint32_t *refs, 955 unsigned int nr_refs, int prot, 956 Error **errp) 957 { 958 void *map = xengnttab_map_domain_grant_refs(xendev->xgth, nr_refs, 959 xendev->frontend_id, refs, 960 prot); 961 962 if (!map) { 963 error_setg_errno(errp, errno, 964 "xengnttab_map_domain_grant_refs failed"); 965 } 966 967 return map; 968 } 969 970 void xen_device_unmap_grant_refs(XenDevice *xendev, void *map, 971 unsigned int nr_refs, Error **errp) 972 { 973 if (xengnttab_unmap(xendev->xgth, map, nr_refs)) { 974 error_setg_errno(errp, errno, "xengnttab_unmap failed"); 975 } 976 } 977 978 static void compat_copy_grant_refs(XenDevice *xendev, bool to_domain, 979 XenDeviceGrantCopySegment segs[], 980 unsigned int nr_segs, Error **errp) 981 { 982 uint32_t *refs = g_new(uint32_t, nr_segs); 983 int prot = to_domain ? PROT_WRITE : PROT_READ; 984 void *map; 985 unsigned int i; 986 987 for (i = 0; i < nr_segs; i++) { 988 XenDeviceGrantCopySegment *seg = &segs[i]; 989 990 refs[i] = to_domain ? seg->dest.foreign.ref : 991 seg->source.foreign.ref; 992 } 993 994 map = xengnttab_map_domain_grant_refs(xendev->xgth, nr_segs, 995 xendev->frontend_id, refs, 996 prot); 997 if (!map) { 998 error_setg_errno(errp, errno, 999 "xengnttab_map_domain_grant_refs failed"); 1000 goto done; 1001 } 1002 1003 for (i = 0; i < nr_segs; i++) { 1004 XenDeviceGrantCopySegment *seg = &segs[i]; 1005 void *page = map + (i * XC_PAGE_SIZE); 1006 1007 if (to_domain) { 1008 memcpy(page + seg->dest.foreign.offset, seg->source.virt, 1009 seg->len); 1010 } else { 1011 memcpy(seg->dest.virt, page + seg->source.foreign.offset, 1012 seg->len); 1013 } 1014 } 1015 1016 if (xengnttab_unmap(xendev->xgth, map, nr_segs)) { 1017 error_setg_errno(errp, errno, "xengnttab_unmap failed"); 1018 } 1019 1020 done: 1021 g_free(refs); 1022 } 1023 1024 void xen_device_copy_grant_refs(XenDevice *xendev, bool to_domain, 1025 XenDeviceGrantCopySegment segs[], 1026 unsigned int nr_segs, Error **errp) 1027 { 1028 xengnttab_grant_copy_segment_t *xengnttab_segs; 1029 unsigned int i; 1030 1031 if (!xendev->feature_grant_copy) { 1032 compat_copy_grant_refs(xendev, to_domain, segs, nr_segs, errp); 1033 return; 1034 } 1035 1036 xengnttab_segs = g_new0(xengnttab_grant_copy_segment_t, nr_segs); 1037 1038 for (i = 0; i < nr_segs; i++) { 1039 XenDeviceGrantCopySegment *seg = &segs[i]; 1040 xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i]; 1041 1042 if (to_domain) { 1043 xengnttab_seg->flags = GNTCOPY_dest_gref; 1044 xengnttab_seg->dest.foreign.domid = xendev->frontend_id; 1045 xengnttab_seg->dest.foreign.ref = seg->dest.foreign.ref; 1046 xengnttab_seg->dest.foreign.offset = seg->dest.foreign.offset; 1047 xengnttab_seg->source.virt = seg->source.virt; 1048 } else { 1049 xengnttab_seg->flags = GNTCOPY_source_gref; 1050 xengnttab_seg->source.foreign.domid = xendev->frontend_id; 1051 xengnttab_seg->source.foreign.ref = seg->source.foreign.ref; 1052 xengnttab_seg->source.foreign.offset = 1053 seg->source.foreign.offset; 1054 xengnttab_seg->dest.virt = seg->dest.virt; 1055 } 1056 1057 xengnttab_seg->len = seg->len; 1058 } 1059 1060 if (xengnttab_grant_copy(xendev->xgth, nr_segs, xengnttab_segs)) { 1061 error_setg_errno(errp, errno, "xengnttab_grant_copy failed"); 1062 goto done; 1063 } 1064 1065 for (i = 0; i < nr_segs; i++) { 1066 xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i]; 1067 1068 if (xengnttab_seg->status != GNTST_okay) { 1069 error_setg(errp, "xengnttab_grant_copy seg[%u] failed", i); 1070 break; 1071 } 1072 } 1073 1074 done: 1075 g_free(xengnttab_segs); 1076 } 1077 1078 struct XenEventChannel { 1079 QLIST_ENTRY(XenEventChannel) list; 1080 AioContext *ctx; 1081 xenevtchn_handle *xeh; 1082 evtchn_port_t local_port; 1083 XenEventHandler handler; 1084 void *opaque; 1085 }; 1086 1087 static bool xen_device_poll(void *opaque) 1088 { 1089 XenEventChannel *channel = opaque; 1090 1091 return channel->handler(channel->opaque); 1092 } 1093 1094 static void xen_device_event(void *opaque) 1095 { 1096 XenEventChannel *channel = opaque; 1097 unsigned long port = xenevtchn_pending(channel->xeh); 1098 1099 if (port == channel->local_port) { 1100 xen_device_poll(channel); 1101 1102 xenevtchn_unmask(channel->xeh, port); 1103 } 1104 } 1105 1106 void xen_device_set_event_channel_context(XenDevice *xendev, 1107 XenEventChannel *channel, 1108 AioContext *ctx, 1109 Error **errp) 1110 { 1111 if (!channel) { 1112 error_setg(errp, "bad channel"); 1113 return; 1114 } 1115 1116 if (channel->ctx) 1117 aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true, 1118 NULL, NULL, NULL, NULL, NULL); 1119 1120 channel->ctx = ctx; 1121 aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true, 1122 xen_device_event, NULL, xen_device_poll, NULL, channel); 1123 } 1124 1125 XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev, 1126 unsigned int port, 1127 XenEventHandler handler, 1128 void *opaque, Error **errp) 1129 { 1130 XenEventChannel *channel = g_new0(XenEventChannel, 1); 1131 xenevtchn_port_or_error_t local_port; 1132 1133 channel->xeh = xenevtchn_open(NULL, 0); 1134 if (!channel->xeh) { 1135 error_setg_errno(errp, errno, "failed xenevtchn_open"); 1136 goto fail; 1137 } 1138 1139 local_port = xenevtchn_bind_interdomain(channel->xeh, 1140 xendev->frontend_id, 1141 port); 1142 if (local_port < 0) { 1143 error_setg_errno(errp, errno, "xenevtchn_bind_interdomain failed"); 1144 goto fail; 1145 } 1146 1147 channel->local_port = local_port; 1148 channel->handler = handler; 1149 channel->opaque = opaque; 1150 1151 /* Only reason for failure is a NULL channel */ 1152 xen_device_set_event_channel_context(xendev, channel, 1153 qemu_get_aio_context(), 1154 &error_abort); 1155 1156 QLIST_INSERT_HEAD(&xendev->event_channels, channel, list); 1157 1158 return channel; 1159 1160 fail: 1161 if (channel->xeh) { 1162 xenevtchn_close(channel->xeh); 1163 } 1164 1165 g_free(channel); 1166 1167 return NULL; 1168 } 1169 1170 void xen_device_notify_event_channel(XenDevice *xendev, 1171 XenEventChannel *channel, 1172 Error **errp) 1173 { 1174 if (!channel) { 1175 error_setg(errp, "bad channel"); 1176 return; 1177 } 1178 1179 if (xenevtchn_notify(channel->xeh, channel->local_port) < 0) { 1180 error_setg_errno(errp, errno, "xenevtchn_notify failed"); 1181 } 1182 } 1183 1184 void xen_device_unbind_event_channel(XenDevice *xendev, 1185 XenEventChannel *channel, 1186 Error **errp) 1187 { 1188 if (!channel) { 1189 error_setg(errp, "bad channel"); 1190 return; 1191 } 1192 1193 QLIST_REMOVE(channel, list); 1194 1195 aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true, 1196 NULL, NULL, NULL, NULL, NULL); 1197 1198 if (xenevtchn_unbind(channel->xeh, channel->local_port) < 0) { 1199 error_setg_errno(errp, errno, "xenevtchn_unbind failed"); 1200 } 1201 1202 xenevtchn_close(channel->xeh); 1203 g_free(channel); 1204 } 1205 1206 static void xen_device_unrealize(DeviceState *dev) 1207 { 1208 XenDevice *xendev = XEN_DEVICE(dev); 1209 XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); 1210 const char *type = object_get_typename(OBJECT(xendev)); 1211 XenEventChannel *channel, *next; 1212 1213 if (!xendev->name) { 1214 return; 1215 } 1216 1217 trace_xen_device_unrealize(type, xendev->name); 1218 1219 if (xendev->exit.notify) { 1220 qemu_remove_exit_notifier(&xendev->exit); 1221 xendev->exit.notify = NULL; 1222 } 1223 1224 if (xendev_class->unrealize) { 1225 xendev_class->unrealize(xendev); 1226 } 1227 1228 /* Make sure all event channels are cleaned up */ 1229 QLIST_FOREACH_SAFE(channel, &xendev->event_channels, list, next) { 1230 xen_device_unbind_event_channel(xendev, channel, NULL); 1231 } 1232 1233 xen_device_frontend_destroy(xendev); 1234 xen_device_backend_destroy(xendev); 1235 1236 if (xendev->xgth) { 1237 xengnttab_close(xendev->xgth); 1238 xendev->xgth = NULL; 1239 } 1240 1241 if (xendev->watch_list) { 1242 watch_list_destroy(xendev->watch_list); 1243 xendev->watch_list = NULL; 1244 } 1245 1246 if (xendev->xsh) { 1247 xs_close(xendev->xsh); 1248 xendev->xsh = NULL; 1249 } 1250 1251 g_free(xendev->name); 1252 xendev->name = NULL; 1253 } 1254 1255 static void xen_device_exit(Notifier *n, void *data) 1256 { 1257 XenDevice *xendev = container_of(n, XenDevice, exit); 1258 1259 xen_device_unrealize(DEVICE(xendev)); 1260 } 1261 1262 static void xen_device_realize(DeviceState *dev, Error **errp) 1263 { 1264 ERRP_GUARD(); 1265 XenDevice *xendev = XEN_DEVICE(dev); 1266 XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); 1267 XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); 1268 const char *type = object_get_typename(OBJECT(xendev)); 1269 1270 if (xendev->frontend_id == DOMID_INVALID) { 1271 xendev->frontend_id = xen_domid; 1272 } 1273 1274 if (xendev->frontend_id >= DOMID_FIRST_RESERVED) { 1275 error_setg(errp, "invalid frontend-id"); 1276 goto unrealize; 1277 } 1278 1279 if (!xendev_class->get_name) { 1280 error_setg(errp, "get_name method not implemented"); 1281 goto unrealize; 1282 } 1283 1284 xendev->name = xendev_class->get_name(xendev, errp); 1285 if (*errp) { 1286 error_prepend(errp, "failed to get device name: "); 1287 goto unrealize; 1288 } 1289 1290 trace_xen_device_realize(type, xendev->name); 1291 1292 xendev->xsh = xs_open(0); 1293 if (!xendev->xsh) { 1294 error_setg_errno(errp, errno, "failed xs_open"); 1295 goto unrealize; 1296 } 1297 1298 xendev->watch_list = watch_list_create(xendev->xsh); 1299 1300 xendev->xgth = xengnttab_open(NULL, 0); 1301 if (!xendev->xgth) { 1302 error_setg_errno(errp, errno, "failed xengnttab_open"); 1303 goto unrealize; 1304 } 1305 1306 xendev->feature_grant_copy = 1307 (xengnttab_grant_copy(xendev->xgth, 0, NULL) == 0); 1308 1309 xen_device_backend_create(xendev, errp); 1310 if (*errp) { 1311 goto unrealize; 1312 } 1313 1314 xen_device_frontend_create(xendev, errp); 1315 if (*errp) { 1316 goto unrealize; 1317 } 1318 1319 if (xendev_class->realize) { 1320 xendev_class->realize(xendev, errp); 1321 if (*errp) { 1322 goto unrealize; 1323 } 1324 } 1325 1326 xen_device_backend_printf(xendev, "frontend", "%s", 1327 xendev->frontend_path); 1328 xen_device_backend_printf(xendev, "frontend-id", "%u", 1329 xendev->frontend_id); 1330 xen_device_backend_printf(xendev, "hotplug-status", "connected"); 1331 1332 xen_device_backend_set_online(xendev, true); 1333 xen_device_backend_set_state(xendev, XenbusStateInitWait); 1334 1335 if (!xen_device_frontend_exists(xendev)) { 1336 xen_device_frontend_printf(xendev, "backend", "%s", 1337 xendev->backend_path); 1338 xen_device_frontend_printf(xendev, "backend-id", "%u", 1339 xenbus->backend_id); 1340 1341 xen_device_frontend_set_state(xendev, XenbusStateInitialising, true); 1342 } 1343 1344 xendev->exit.notify = xen_device_exit; 1345 qemu_add_exit_notifier(&xendev->exit); 1346 return; 1347 1348 unrealize: 1349 xen_device_unrealize(dev); 1350 } 1351 1352 static Property xen_device_props[] = { 1353 DEFINE_PROP_UINT16("frontend-id", XenDevice, frontend_id, 1354 DOMID_INVALID), 1355 DEFINE_PROP_END_OF_LIST() 1356 }; 1357 1358 static void xen_device_class_init(ObjectClass *class, void *data) 1359 { 1360 DeviceClass *dev_class = DEVICE_CLASS(class); 1361 1362 dev_class->realize = xen_device_realize; 1363 dev_class->unrealize = xen_device_unrealize; 1364 device_class_set_props(dev_class, xen_device_props); 1365 dev_class->bus_type = TYPE_XEN_BUS; 1366 } 1367 1368 static const TypeInfo xen_device_type_info = { 1369 .name = TYPE_XEN_DEVICE, 1370 .parent = TYPE_DEVICE, 1371 .instance_size = sizeof(XenDevice), 1372 .abstract = true, 1373 .class_size = sizeof(XenDeviceClass), 1374 .class_init = xen_device_class_init, 1375 }; 1376 1377 typedef struct XenBridge { 1378 SysBusDevice busdev; 1379 } XenBridge; 1380 1381 #define TYPE_XEN_BRIDGE "xen-bridge" 1382 1383 static const TypeInfo xen_bridge_type_info = { 1384 .name = TYPE_XEN_BRIDGE, 1385 .parent = TYPE_SYS_BUS_DEVICE, 1386 .instance_size = sizeof(XenBridge), 1387 }; 1388 1389 static void xen_register_types(void) 1390 { 1391 type_register_static(&xen_bridge_type_info); 1392 type_register_static(&xen_bus_type_info); 1393 type_register_static(&xen_device_type_info); 1394 } 1395 1396 type_init(xen_register_types) 1397 1398 void xen_bus_init(void) 1399 { 1400 DeviceState *dev = qdev_new(TYPE_XEN_BRIDGE); 1401 BusState *bus = qbus_new(TYPE_XEN_BUS, dev, NULL); 1402 1403 sysbus_realize_and_unref(SYS_BUS_DEVICE(dev), &error_fatal); 1404 qbus_set_bus_hotplug_handler(bus); 1405 }