1/* 2 * PCI Backend Xenbus Setup - handles setup with frontend and xend 3 * 4 * Author: Ryan Wilson <hap9@epoch.ncsc.mil> 5 */ 6 7#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 8 9#include <linux/module.h> 10#include <linux/init.h> 11#include <linux/list.h> 12#include <linux/vmalloc.h> 13#include <linux/workqueue.h> 14#include <xen/xenbus.h> 15#include <xen/events.h> 16#include <asm/xen/pci.h> 17#include "pciback.h" 18 19#define INVALID_EVTCHN_IRQ (-1) 20struct workqueue_struct *xen_pcibk_wq; 21 22static bool __read_mostly passthrough; 23module_param(passthrough, bool, S_IRUGO); 24MODULE_PARM_DESC(passthrough, 25 "Option to specify how to export PCI topology to guest:\n"\ 26 " 0 - (default) Hide the true PCI topology and makes the frontend\n"\ 27 " there is a single PCI bus with only the exported devices on it.\n"\ 28 " For example, a device at 03:05.0 will be re-assigned to 00:00.0\n"\ 29 " while second device at 02:1a.1 will be re-assigned to 00:01.1.\n"\ 30 " 1 - Passthrough provides a real view of the PCI topology to the\n"\ 31 " frontend (for example, a device at 06:01.b will still appear at\n"\ 32 " 06:01.b to the frontend). This is similar to how Xen 2.0.x\n"\ 33 " exposed PCI devices to its driver domains. This may be required\n"\ 34 " for drivers which depend on finding their hardward in certain\n"\ 35 " bus/slot locations."); 36 37static struct xen_pcibk_device *alloc_pdev(struct xenbus_device *xdev) 38{ 39 struct xen_pcibk_device *pdev; 40 41 pdev = kzalloc(sizeof(struct xen_pcibk_device), GFP_KERNEL); 42 if (pdev == NULL) 43 goto out; 44 dev_dbg(&xdev->dev, "allocated pdev @ 0x%p\n", pdev); 45 46 pdev->xdev = xdev; 47 dev_set_drvdata(&xdev->dev, pdev); 48 49 mutex_init(&pdev->dev_lock); 50 51 pdev->sh_info = NULL; 52 pdev->evtchn_irq = INVALID_EVTCHN_IRQ; 53 pdev->be_watching = 0; 54 55 INIT_WORK(&pdev->op_work, xen_pcibk_do_op); 56 57 if (xen_pcibk_init_devices(pdev)) { 58 kfree(pdev); 59 pdev = NULL; 60 } 61out: 62 return pdev; 63} 64 65static void xen_pcibk_disconnect(struct xen_pcibk_device *pdev) 66{ 67 mutex_lock(&pdev->dev_lock); 68 /* Ensure the guest can't trigger our handler before removing devices */ 69 if (pdev->evtchn_irq != INVALID_EVTCHN_IRQ) { 70 unbind_from_irqhandler(pdev->evtchn_irq, pdev); 71 pdev->evtchn_irq = INVALID_EVTCHN_IRQ; 72 } 73 74 /* If the driver domain started an op, make sure we complete it 75 * before releasing the shared memory */ 76 77 /* Note, the workqueue does not use spinlocks at all.*/ 78 flush_workqueue(xen_pcibk_wq); 79 80 if (pdev->sh_info != NULL) { 81 xenbus_unmap_ring_vfree(pdev->xdev, pdev->sh_info); 82 pdev->sh_info = NULL; 83 } 84 mutex_unlock(&pdev->dev_lock); 85} 86 87static void free_pdev(struct xen_pcibk_device *pdev) 88{ 89 if (pdev->be_watching) { 90 unregister_xenbus_watch(&pdev->be_watch); 91 pdev->be_watching = 0; 92 } 93 94 xen_pcibk_disconnect(pdev); 95 96 /* N.B. This calls pcistub_put_pci_dev which does the FLR on all 97 * of the PCIe devices. */ 98 xen_pcibk_release_devices(pdev); 99 100 dev_set_drvdata(&pdev->xdev->dev, NULL); 101 pdev->xdev = NULL; 102 103 kfree(pdev); 104} 105 106static int xen_pcibk_do_attach(struct xen_pcibk_device *pdev, int gnt_ref, 107 int remote_evtchn) 108{ 109 int err = 0; 110 void *vaddr; 111 112 dev_dbg(&pdev->xdev->dev, 113 "Attaching to frontend resources - gnt_ref=%d evtchn=%d\n", 114 gnt_ref, remote_evtchn); 115 116 err = xenbus_map_ring_valloc(pdev->xdev, &gnt_ref, 1, &vaddr); 117 if (err < 0) { 118 xenbus_dev_fatal(pdev->xdev, err, 119 "Error mapping other domain page in ours."); 120 goto out; 121 } 122 123 pdev->sh_info = vaddr; 124 125 err = bind_interdomain_evtchn_to_irqhandler( 126 pdev->xdev->otherend_id, remote_evtchn, xen_pcibk_handle_event, 127 0, DRV_NAME, pdev); 128 if (err < 0) { 129 xenbus_dev_fatal(pdev->xdev, err, 130 "Error binding event channel to IRQ"); 131 goto out; 132 } 133 pdev->evtchn_irq = err; 134 err = 0; 135 136 dev_dbg(&pdev->xdev->dev, "Attached!\n"); 137out: 138 return err; 139} 140 141static int xen_pcibk_attach(struct xen_pcibk_device *pdev) 142{ 143 int err = 0; 144 int gnt_ref, remote_evtchn; 145 char *magic = NULL; 146 147 148 mutex_lock(&pdev->dev_lock); 149 /* Make sure we only do this setup once */ 150 if (xenbus_read_driver_state(pdev->xdev->nodename) != 151 XenbusStateInitialised) 152 goto out; 153 154 /* Wait for frontend to state that it has published the configuration */ 155 if (xenbus_read_driver_state(pdev->xdev->otherend) != 156 XenbusStateInitialised) 157 goto out; 158 159 dev_dbg(&pdev->xdev->dev, "Reading frontend config\n"); 160 161 err = xenbus_gather(XBT_NIL, pdev->xdev->otherend, 162 "pci-op-ref", "%u", &gnt_ref, 163 "event-channel", "%u", &remote_evtchn, 164 "magic", NULL, &magic, NULL); 165 if (err) { 166 /* If configuration didn't get read correctly, wait longer */ 167 xenbus_dev_fatal(pdev->xdev, err, 168 "Error reading configuration from frontend"); 169 goto out; 170 } 171 172 if (magic == NULL || strcmp(magic, XEN_PCI_MAGIC) != 0) { 173 xenbus_dev_fatal(pdev->xdev, -EFAULT, 174 "version mismatch (%s/%s) with pcifront - " 175 "halting " DRV_NAME, 176 magic, XEN_PCI_MAGIC); 177 err = -EFAULT; 178 goto out; 179 } 180 181 err = xen_pcibk_do_attach(pdev, gnt_ref, remote_evtchn); 182 if (err) 183 goto out; 184 185 dev_dbg(&pdev->xdev->dev, "Connecting...\n"); 186 187 err = xenbus_switch_state(pdev->xdev, XenbusStateConnected); 188 if (err) 189 xenbus_dev_fatal(pdev->xdev, err, 190 "Error switching to connected state!"); 191 192 dev_dbg(&pdev->xdev->dev, "Connected? %d\n", err); 193out: 194 mutex_unlock(&pdev->dev_lock); 195 196 kfree(magic); 197 198 return err; 199} 200 201static int xen_pcibk_publish_pci_dev(struct xen_pcibk_device *pdev, 202 unsigned int domain, unsigned int bus, 203 unsigned int devfn, unsigned int devid) 204{ 205 int err; 206 int len; 207 char str[64]; 208 209 len = snprintf(str, sizeof(str), "vdev-%d", devid); 210 if (unlikely(len >= (sizeof(str) - 1))) { 211 err = -ENOMEM; 212 goto out; 213 } 214 215 /* Note: The PV protocol uses %02x, don't change it */ 216 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, str, 217 "%04x:%02x:%02x.%02x", domain, bus, 218 PCI_SLOT(devfn), PCI_FUNC(devfn)); 219 220out: 221 return err; 222} 223 224static int xen_pcibk_export_device(struct xen_pcibk_device *pdev, 225 int domain, int bus, int slot, int func, 226 int devid) 227{ 228 struct pci_dev *dev; 229 int err = 0; 230 231 dev_dbg(&pdev->xdev->dev, "exporting dom %x bus %x slot %x func %x\n", 232 domain, bus, slot, func); 233 234 dev = pcistub_get_pci_dev_by_slot(pdev, domain, bus, slot, func); 235 if (!dev) { 236 err = -EINVAL; 237 xenbus_dev_fatal(pdev->xdev, err, 238 "Couldn't locate PCI device " 239 "(%04x:%02x:%02x.%d)! " 240 "perhaps already in-use?", 241 domain, bus, slot, func); 242 goto out; 243 } 244 245 err = xen_pcibk_add_pci_dev(pdev, dev, devid, 246 xen_pcibk_publish_pci_dev); 247 if (err) 248 goto out; 249 250 dev_info(&dev->dev, "registering for %d\n", pdev->xdev->otherend_id); 251 if (xen_register_device_domain_owner(dev, 252 pdev->xdev->otherend_id) != 0) { 253 dev_err(&dev->dev, "Stealing ownership from dom%d.\n", 254 xen_find_device_domain_owner(dev)); 255 xen_unregister_device_domain_owner(dev); 256 xen_register_device_domain_owner(dev, pdev->xdev->otherend_id); 257 } 258 259 /* TODO: It'd be nice to export a bridge and have all of its children 260 * get exported with it. This may be best done in xend (which will 261 * have to calculate resource usage anyway) but we probably want to 262 * put something in here to ensure that if a bridge gets given to a 263 * driver domain, that all devices under that bridge are not given 264 * to other driver domains (as he who controls the bridge can disable 265 * it and stop the other devices from working). 266 */ 267out: 268 return err; 269} 270 271static int xen_pcibk_remove_device(struct xen_pcibk_device *pdev, 272 int domain, int bus, int slot, int func) 273{ 274 int err = 0; 275 struct pci_dev *dev; 276 277 dev_dbg(&pdev->xdev->dev, "removing dom %x bus %x slot %x func %x\n", 278 domain, bus, slot, func); 279 280 dev = xen_pcibk_get_pci_dev(pdev, domain, bus, PCI_DEVFN(slot, func)); 281 if (!dev) { 282 err = -EINVAL; 283 dev_dbg(&pdev->xdev->dev, "Couldn't locate PCI device " 284 "(%04x:%02x:%02x.%d)! not owned by this domain\n", 285 domain, bus, slot, func); 286 goto out; 287 } 288 289 dev_dbg(&dev->dev, "unregistering for %d\n", pdev->xdev->otherend_id); 290 xen_unregister_device_domain_owner(dev); 291 292 /* N.B. This ends up calling pcistub_put_pci_dev which ends up 293 * doing the FLR. */ 294 xen_pcibk_release_pci_dev(pdev, dev, true /* use the lock. */); 295 296out: 297 return err; 298} 299 300static int xen_pcibk_publish_pci_root(struct xen_pcibk_device *pdev, 301 unsigned int domain, unsigned int bus) 302{ 303 unsigned int d, b; 304 int i, root_num, len, err; 305 char str[64]; 306 307 dev_dbg(&pdev->xdev->dev, "Publishing pci roots\n"); 308 309 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, 310 "root_num", "%d", &root_num); 311 if (err == 0 || err == -ENOENT) 312 root_num = 0; 313 else if (err < 0) 314 goto out; 315 316 /* Verify that we haven't already published this pci root */ 317 for (i = 0; i < root_num; i++) { 318 len = snprintf(str, sizeof(str), "root-%d", i); 319 if (unlikely(len >= (sizeof(str) - 1))) { 320 err = -ENOMEM; 321 goto out; 322 } 323 324 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, 325 str, "%x:%x", &d, &b); 326 if (err < 0) 327 goto out; 328 if (err != 2) { 329 err = -EINVAL; 330 goto out; 331 } 332 333 if (d == domain && b == bus) { 334 err = 0; 335 goto out; 336 } 337 } 338 339 len = snprintf(str, sizeof(str), "root-%d", root_num); 340 if (unlikely(len >= (sizeof(str) - 1))) { 341 err = -ENOMEM; 342 goto out; 343 } 344 345 dev_dbg(&pdev->xdev->dev, "writing root %d at %04x:%02x\n", 346 root_num, domain, bus); 347 348 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, str, 349 "%04x:%02x", domain, bus); 350 if (err) 351 goto out; 352 353 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, 354 "root_num", "%d", (root_num + 1)); 355 356out: 357 return err; 358} 359 360static int xen_pcibk_reconfigure(struct xen_pcibk_device *pdev) 361{ 362 int err = 0; 363 int num_devs; 364 int domain, bus, slot, func; 365 int substate; 366 int i, len; 367 char state_str[64]; 368 char dev_str[64]; 369 370 371 dev_dbg(&pdev->xdev->dev, "Reconfiguring device ...\n"); 372 373 mutex_lock(&pdev->dev_lock); 374 /* Make sure we only reconfigure once */ 375 if (xenbus_read_driver_state(pdev->xdev->nodename) != 376 XenbusStateReconfiguring) 377 goto out; 378 379 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, "num_devs", "%d", 380 &num_devs); 381 if (err != 1) { 382 if (err >= 0) 383 err = -EINVAL; 384 xenbus_dev_fatal(pdev->xdev, err, 385 "Error reading number of devices"); 386 goto out; 387 } 388 389 for (i = 0; i < num_devs; i++) { 390 len = snprintf(state_str, sizeof(state_str), "state-%d", i); 391 if (unlikely(len >= (sizeof(state_str) - 1))) { 392 err = -ENOMEM; 393 xenbus_dev_fatal(pdev->xdev, err, 394 "String overflow while reading " 395 "configuration"); 396 goto out; 397 } 398 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, state_str, 399 "%d", &substate); 400 if (err != 1) 401 substate = XenbusStateUnknown; 402 403 switch (substate) { 404 case XenbusStateInitialising: 405 dev_dbg(&pdev->xdev->dev, "Attaching dev-%d ...\n", i); 406 407 len = snprintf(dev_str, sizeof(dev_str), "dev-%d", i); 408 if (unlikely(len >= (sizeof(dev_str) - 1))) { 409 err = -ENOMEM; 410 xenbus_dev_fatal(pdev->xdev, err, 411 "String overflow while " 412 "reading configuration"); 413 goto out; 414 } 415 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, 416 dev_str, "%x:%x:%x.%x", 417 &domain, &bus, &slot, &func); 418 if (err < 0) { 419 xenbus_dev_fatal(pdev->xdev, err, 420 "Error reading device " 421 "configuration"); 422 goto out; 423 } 424 if (err != 4) { 425 err = -EINVAL; 426 xenbus_dev_fatal(pdev->xdev, err, 427 "Error parsing pci device " 428 "configuration"); 429 goto out; 430 } 431 432 err = xen_pcibk_export_device(pdev, domain, bus, slot, 433 func, i); 434 if (err) 435 goto out; 436 437 /* Publish pci roots. */ 438 err = xen_pcibk_publish_pci_roots(pdev, 439 xen_pcibk_publish_pci_root); 440 if (err) { 441 xenbus_dev_fatal(pdev->xdev, err, 442 "Error while publish PCI root" 443 "buses for frontend"); 444 goto out; 445 } 446 447 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, 448 state_str, "%d", 449 XenbusStateInitialised); 450 if (err) { 451 xenbus_dev_fatal(pdev->xdev, err, 452 "Error switching substate of " 453 "dev-%d\n", i); 454 goto out; 455 } 456 break; 457 458 case XenbusStateClosing: 459 dev_dbg(&pdev->xdev->dev, "Detaching dev-%d ...\n", i); 460 461 len = snprintf(dev_str, sizeof(dev_str), "vdev-%d", i); 462 if (unlikely(len >= (sizeof(dev_str) - 1))) { 463 err = -ENOMEM; 464 xenbus_dev_fatal(pdev->xdev, err, 465 "String overflow while " 466 "reading configuration"); 467 goto out; 468 } 469 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, 470 dev_str, "%x:%x:%x.%x", 471 &domain, &bus, &slot, &func); 472 if (err < 0) { 473 xenbus_dev_fatal(pdev->xdev, err, 474 "Error reading device " 475 "configuration"); 476 goto out; 477 } 478 if (err != 4) { 479 err = -EINVAL; 480 xenbus_dev_fatal(pdev->xdev, err, 481 "Error parsing pci device " 482 "configuration"); 483 goto out; 484 } 485 486 err = xen_pcibk_remove_device(pdev, domain, bus, slot, 487 func); 488 if (err) 489 goto out; 490 491 /* TODO: If at some point we implement support for pci 492 * root hot-remove on pcifront side, we'll need to 493 * remove unnecessary xenstore nodes of pci roots here. 494 */ 495 496 break; 497 498 default: 499 break; 500 } 501 } 502 503 err = xenbus_switch_state(pdev->xdev, XenbusStateReconfigured); 504 if (err) { 505 xenbus_dev_fatal(pdev->xdev, err, 506 "Error switching to reconfigured state!"); 507 goto out; 508 } 509 510out: 511 mutex_unlock(&pdev->dev_lock); 512 return 0; 513} 514 515static void xen_pcibk_frontend_changed(struct xenbus_device *xdev, 516 enum xenbus_state fe_state) 517{ 518 struct xen_pcibk_device *pdev = dev_get_drvdata(&xdev->dev); 519 520 dev_dbg(&xdev->dev, "fe state changed %d\n", fe_state); 521 522 switch (fe_state) { 523 case XenbusStateInitialised: 524 xen_pcibk_attach(pdev); 525 break; 526 527 case XenbusStateReconfiguring: 528 xen_pcibk_reconfigure(pdev); 529 break; 530 531 case XenbusStateConnected: 532 /* pcifront switched its state from reconfiguring to connected. 533 * Then switch to connected state. 534 */ 535 xenbus_switch_state(xdev, XenbusStateConnected); 536 break; 537 538 case XenbusStateClosing: 539 xen_pcibk_disconnect(pdev); 540 xenbus_switch_state(xdev, XenbusStateClosing); 541 break; 542 543 case XenbusStateClosed: 544 xen_pcibk_disconnect(pdev); 545 xenbus_switch_state(xdev, XenbusStateClosed); 546 if (xenbus_dev_is_online(xdev)) 547 break; 548 /* fall through if not online */ 549 case XenbusStateUnknown: 550 dev_dbg(&xdev->dev, "frontend is gone! unregister device\n"); 551 device_unregister(&xdev->dev); 552 break; 553 554 default: 555 break; 556 } 557} 558 559static int xen_pcibk_setup_backend(struct xen_pcibk_device *pdev) 560{ 561 /* Get configuration from xend (if available now) */ 562 int domain, bus, slot, func; 563 int err = 0; 564 int i, num_devs; 565 char dev_str[64]; 566 char state_str[64]; 567 568 mutex_lock(&pdev->dev_lock); 569 /* It's possible we could get the call to setup twice, so make sure 570 * we're not already connected. 571 */ 572 if (xenbus_read_driver_state(pdev->xdev->nodename) != 573 XenbusStateInitWait) 574 goto out; 575 576 dev_dbg(&pdev->xdev->dev, "getting be setup\n"); 577 578 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, "num_devs", "%d", 579 &num_devs); 580 if (err != 1) { 581 if (err >= 0) 582 err = -EINVAL; 583 xenbus_dev_fatal(pdev->xdev, err, 584 "Error reading number of devices"); 585 goto out; 586 } 587 588 for (i = 0; i < num_devs; i++) { 589 int l = snprintf(dev_str, sizeof(dev_str), "dev-%d", i); 590 if (unlikely(l >= (sizeof(dev_str) - 1))) { 591 err = -ENOMEM; 592 xenbus_dev_fatal(pdev->xdev, err, 593 "String overflow while reading " 594 "configuration"); 595 goto out; 596 } 597 598 err = xenbus_scanf(XBT_NIL, pdev->xdev->nodename, dev_str, 599 "%x:%x:%x.%x", &domain, &bus, &slot, &func); 600 if (err < 0) { 601 xenbus_dev_fatal(pdev->xdev, err, 602 "Error reading device configuration"); 603 goto out; 604 } 605 if (err != 4) { 606 err = -EINVAL; 607 xenbus_dev_fatal(pdev->xdev, err, 608 "Error parsing pci device " 609 "configuration"); 610 goto out; 611 } 612 613 err = xen_pcibk_export_device(pdev, domain, bus, slot, func, i); 614 if (err) 615 goto out; 616 617 /* Switch substate of this device. */ 618 l = snprintf(state_str, sizeof(state_str), "state-%d", i); 619 if (unlikely(l >= (sizeof(state_str) - 1))) { 620 err = -ENOMEM; 621 xenbus_dev_fatal(pdev->xdev, err, 622 "String overflow while reading " 623 "configuration"); 624 goto out; 625 } 626 err = xenbus_printf(XBT_NIL, pdev->xdev->nodename, state_str, 627 "%d", XenbusStateInitialised); 628 if (err) { 629 xenbus_dev_fatal(pdev->xdev, err, "Error switching " 630 "substate of dev-%d\n", i); 631 goto out; 632 } 633 } 634 635 err = xen_pcibk_publish_pci_roots(pdev, xen_pcibk_publish_pci_root); 636 if (err) { 637 xenbus_dev_fatal(pdev->xdev, err, 638 "Error while publish PCI root buses " 639 "for frontend"); 640 goto out; 641 } 642 643 err = xenbus_switch_state(pdev->xdev, XenbusStateInitialised); 644 if (err) 645 xenbus_dev_fatal(pdev->xdev, err, 646 "Error switching to initialised state!"); 647 648out: 649 mutex_unlock(&pdev->dev_lock); 650 if (!err) 651 /* see if pcifront is already configured (if not, we'll wait) */ 652 xen_pcibk_attach(pdev); 653 return err; 654} 655 656static void xen_pcibk_be_watch(struct xenbus_watch *watch, 657 const char **vec, unsigned int len) 658{ 659 struct xen_pcibk_device *pdev = 660 container_of(watch, struct xen_pcibk_device, be_watch); 661 662 switch (xenbus_read_driver_state(pdev->xdev->nodename)) { 663 case XenbusStateInitWait: 664 xen_pcibk_setup_backend(pdev); 665 break; 666 667 default: 668 break; 669 } 670} 671 672static int xen_pcibk_xenbus_probe(struct xenbus_device *dev, 673 const struct xenbus_device_id *id) 674{ 675 int err = 0; 676 struct xen_pcibk_device *pdev = alloc_pdev(dev); 677 678 if (pdev == NULL) { 679 err = -ENOMEM; 680 xenbus_dev_fatal(dev, err, 681 "Error allocating xen_pcibk_device struct"); 682 goto out; 683 } 684 685 /* wait for xend to configure us */ 686 err = xenbus_switch_state(dev, XenbusStateInitWait); 687 if (err) 688 goto out; 689 690 /* watch the backend node for backend configuration information */ 691 err = xenbus_watch_path(dev, dev->nodename, &pdev->be_watch, 692 xen_pcibk_be_watch); 693 if (err) 694 goto out; 695 696 pdev->be_watching = 1; 697 698 /* We need to force a call to our callback here in case 699 * xend already configured us! 700 */ 701 xen_pcibk_be_watch(&pdev->be_watch, NULL, 0); 702 703out: 704 return err; 705} 706 707static int xen_pcibk_xenbus_remove(struct xenbus_device *dev) 708{ 709 struct xen_pcibk_device *pdev = dev_get_drvdata(&dev->dev); 710 711 if (pdev != NULL) 712 free_pdev(pdev); 713 714 return 0; 715} 716 717static const struct xenbus_device_id xen_pcibk_ids[] = { 718 {"pci"}, 719 {""}, 720}; 721 722static struct xenbus_driver xen_pcibk_driver = { 723 .name = DRV_NAME, 724 .ids = xen_pcibk_ids, 725 .probe = xen_pcibk_xenbus_probe, 726 .remove = xen_pcibk_xenbus_remove, 727 .otherend_changed = xen_pcibk_frontend_changed, 728}; 729 730const struct xen_pcibk_backend *__read_mostly xen_pcibk_backend; 731 732int __init xen_pcibk_xenbus_register(void) 733{ 734 xen_pcibk_wq = create_workqueue("xen_pciback_workqueue"); 735 if (!xen_pcibk_wq) { 736 pr_err("%s: create xen_pciback_workqueue failed\n", __func__); 737 return -EFAULT; 738 } 739 xen_pcibk_backend = &xen_pcibk_vpci_backend; 740 if (passthrough) 741 xen_pcibk_backend = &xen_pcibk_passthrough_backend; 742 pr_info("backend is %s\n", xen_pcibk_backend->name); 743 return xenbus_register_backend(&xen_pcibk_driver); 744} 745 746void __exit xen_pcibk_xenbus_unregister(void) 747{ 748 destroy_workqueue(xen_pcibk_wq); 749 xenbus_unregister_driver(&xen_pcibk_driver); 750} 751