1 #include "kvm/virtio-pci.h" 2 3 #include "kvm/ioport.h" 4 #include "kvm/kvm.h" 5 #include "kvm/kvm-cpu.h" 6 #include "kvm/virtio-pci-dev.h" 7 #include "kvm/irq.h" 8 #include "kvm/virtio.h" 9 #include "kvm/ioeventfd.h" 10 #include "kvm/util.h" 11 12 #include <sys/ioctl.h> 13 #include <linux/virtio_pci.h> 14 #include <linux/byteorder.h> 15 #include <assert.h> 16 #include <string.h> 17 18 #define ALIGN_UP(x, s) ALIGN((x) + (s) - 1, (s)) 19 #define VIRTIO_NR_MSIX (VIRTIO_PCI_MAX_VQ + VIRTIO_PCI_MAX_CONFIG) 20 #define VIRTIO_MSIX_TABLE_SIZE (VIRTIO_NR_MSIX * 16) 21 #define VIRTIO_MSIX_PBA_SIZE (ALIGN_UP(VIRTIO_MSIX_TABLE_SIZE, 64) / 8) 22 #define VIRTIO_MSIX_BAR_SIZE (1UL << fls_long(VIRTIO_MSIX_TABLE_SIZE + \ 23 VIRTIO_MSIX_PBA_SIZE)) 24 25 static u16 virtio_pci__port_addr(struct virtio_pci *vpci) 26 { 27 return pci__bar_address(&vpci->pci_hdr, 0); 28 } 29 30 static u32 virtio_pci__mmio_addr(struct virtio_pci *vpci) 31 { 32 return pci__bar_address(&vpci->pci_hdr, 1); 33 } 34 35 static u32 virtio_pci__msix_io_addr(struct virtio_pci *vpci) 36 { 37 return pci__bar_address(&vpci->pci_hdr, 2); 38 } 39 40 static void virtio_pci__ioevent_callback(struct kvm *kvm, void *param) 41 { 42 struct virtio_pci_ioevent_param *ioeventfd = param; 43 struct virtio_pci *vpci = ioeventfd->vdev->virtio; 44 45 ioeventfd->vdev->ops->notify_vq(kvm, vpci->dev, ioeventfd->vq); 46 } 47 48 static int virtio_pci__init_ioeventfd(struct kvm *kvm, struct virtio_device *vdev, u32 vq) 49 { 50 struct ioevent ioevent; 51 struct virtio_pci *vpci = vdev->virtio; 52 u32 mmio_addr = virtio_pci__mmio_addr(vpci); 53 u16 port_addr = virtio_pci__port_addr(vpci); 54 int r, flags = 0; 55 int fd; 56 57 vpci->ioeventfds[vq] = (struct virtio_pci_ioevent_param) { 58 .vdev = vdev, 59 .vq = vq, 60 }; 61 62 ioevent = (struct ioevent) { 63 .fn = virtio_pci__ioevent_callback, 64 .fn_ptr = &vpci->ioeventfds[vq], 65 .datamatch = vq, 66 .fn_kvm = kvm, 67 }; 68 69 /* 70 * Vhost will poll the eventfd in host kernel side, otherwise we 71 * need to poll in userspace. 72 */ 73 if (!vdev->use_vhost) 74 flags |= IOEVENTFD_FLAG_USER_POLL; 75 76 /* ioport */ 77 ioevent.io_addr = port_addr + VIRTIO_PCI_QUEUE_NOTIFY; 78 ioevent.io_len = sizeof(u16); 79 ioevent.fd = fd = eventfd(0, 0); 80 r = ioeventfd__add_event(&ioevent, flags | IOEVENTFD_FLAG_PIO); 81 if (r) 82 return r; 83 84 /* mmio */ 85 ioevent.io_addr = mmio_addr + VIRTIO_PCI_QUEUE_NOTIFY; 86 ioevent.io_len = sizeof(u16); 87 ioevent.fd = eventfd(0, 0); 88 r = ioeventfd__add_event(&ioevent, flags); 89 if (r) 90 goto free_ioport_evt; 91 92 if (vdev->ops->notify_vq_eventfd) 93 vdev->ops->notify_vq_eventfd(kvm, vpci->dev, vq, fd); 94 return 0; 95 96 free_ioport_evt: 97 ioeventfd__del_event(port_addr + VIRTIO_PCI_QUEUE_NOTIFY, vq); 98 return r; 99 } 100 101 static void virtio_pci_exit_vq(struct kvm *kvm, struct virtio_device *vdev, 102 int vq) 103 { 104 struct virtio_pci *vpci = vdev->virtio; 105 u32 mmio_addr = virtio_pci__mmio_addr(vpci); 106 u16 port_addr = virtio_pci__port_addr(vpci); 107 108 ioeventfd__del_event(mmio_addr + VIRTIO_PCI_QUEUE_NOTIFY, vq); 109 ioeventfd__del_event(port_addr + VIRTIO_PCI_QUEUE_NOTIFY, vq); 110 virtio_exit_vq(kvm, vdev, vpci->dev, vq); 111 } 112 113 static inline bool virtio_pci__msix_enabled(struct virtio_pci *vpci) 114 { 115 return vpci->pci_hdr.msix.ctrl & cpu_to_le16(PCI_MSIX_FLAGS_ENABLE); 116 } 117 118 static bool virtio_pci__specific_data_in(struct kvm *kvm, struct virtio_device *vdev, 119 void *data, int size, unsigned long offset) 120 { 121 u32 config_offset; 122 struct virtio_pci *vpci = vdev->virtio; 123 int type = virtio__get_dev_specific_field(offset - 20, 124 virtio_pci__msix_enabled(vpci), 125 &config_offset); 126 if (type == VIRTIO_PCI_O_MSIX) { 127 switch (offset) { 128 case VIRTIO_MSI_CONFIG_VECTOR: 129 ioport__write16(data, vpci->config_vector); 130 break; 131 case VIRTIO_MSI_QUEUE_VECTOR: 132 ioport__write16(data, vpci->vq_vector[vpci->queue_selector]); 133 break; 134 }; 135 136 return true; 137 } else if (type == VIRTIO_PCI_O_CONFIG) { 138 u8 cfg; 139 140 cfg = vdev->ops->get_config(kvm, vpci->dev)[config_offset]; 141 ioport__write8(data, cfg); 142 return true; 143 } 144 145 return false; 146 } 147 148 static bool virtio_pci__data_in(struct kvm_cpu *vcpu, struct virtio_device *vdev, 149 unsigned long offset, void *data, int size) 150 { 151 bool ret = true; 152 struct virtio_pci *vpci; 153 struct virt_queue *vq; 154 struct kvm *kvm; 155 u32 val; 156 157 kvm = vcpu->kvm; 158 vpci = vdev->virtio; 159 160 switch (offset) { 161 case VIRTIO_PCI_HOST_FEATURES: 162 val = vdev->ops->get_host_features(kvm, vpci->dev); 163 ioport__write32(data, val); 164 break; 165 case VIRTIO_PCI_QUEUE_PFN: 166 vq = vdev->ops->get_vq(kvm, vpci->dev, vpci->queue_selector); 167 ioport__write32(data, vq->pfn); 168 break; 169 case VIRTIO_PCI_QUEUE_NUM: 170 val = vdev->ops->get_size_vq(kvm, vpci->dev, vpci->queue_selector); 171 ioport__write16(data, val); 172 break; 173 case VIRTIO_PCI_STATUS: 174 ioport__write8(data, vpci->status); 175 break; 176 case VIRTIO_PCI_ISR: 177 ioport__write8(data, vpci->isr); 178 kvm__irq_line(kvm, vpci->legacy_irq_line, VIRTIO_IRQ_LOW); 179 vpci->isr = VIRTIO_IRQ_LOW; 180 break; 181 default: 182 ret = virtio_pci__specific_data_in(kvm, vdev, data, size, offset); 183 break; 184 }; 185 186 return ret; 187 } 188 189 static void update_msix_map(struct virtio_pci *vpci, 190 struct msix_table *msix_entry, u32 vecnum) 191 { 192 u32 gsi, i; 193 194 /* Find the GSI number used for that vector */ 195 if (vecnum == vpci->config_vector) { 196 gsi = vpci->config_gsi; 197 } else { 198 for (i = 0; i < VIRTIO_PCI_MAX_VQ; i++) 199 if (vpci->vq_vector[i] == vecnum) 200 break; 201 if (i == VIRTIO_PCI_MAX_VQ) 202 return; 203 gsi = vpci->gsis[i]; 204 } 205 206 if (gsi == 0) 207 return; 208 209 msix_entry = &msix_entry[vecnum]; 210 irq__update_msix_route(vpci->kvm, gsi, &msix_entry->msg); 211 } 212 213 static bool virtio_pci__specific_data_out(struct kvm *kvm, struct virtio_device *vdev, 214 void *data, int size, unsigned long offset) 215 { 216 struct virtio_pci *vpci = vdev->virtio; 217 u32 config_offset, vec; 218 int gsi; 219 int type = virtio__get_dev_specific_field(offset - 20, virtio_pci__msix_enabled(vpci), 220 &config_offset); 221 if (type == VIRTIO_PCI_O_MSIX) { 222 switch (offset) { 223 case VIRTIO_MSI_CONFIG_VECTOR: 224 vec = vpci->config_vector = ioport__read16(data); 225 if (vec == VIRTIO_MSI_NO_VECTOR) 226 break; 227 228 gsi = irq__add_msix_route(kvm, 229 &vpci->msix_table[vec].msg, 230 vpci->dev_hdr.dev_num << 3); 231 /* 232 * We don't need IRQ routing if we can use 233 * MSI injection via the KVM_SIGNAL_MSI ioctl. 234 */ 235 if (gsi == -ENXIO && 236 vpci->features & VIRTIO_PCI_F_SIGNAL_MSI) 237 break; 238 239 if (gsi < 0) { 240 die("failed to configure MSIs"); 241 break; 242 } 243 244 vpci->config_gsi = gsi; 245 break; 246 case VIRTIO_MSI_QUEUE_VECTOR: 247 vec = ioport__read16(data); 248 vpci->vq_vector[vpci->queue_selector] = vec; 249 250 if (vec == VIRTIO_MSI_NO_VECTOR) 251 break; 252 253 gsi = irq__add_msix_route(kvm, 254 &vpci->msix_table[vec].msg, 255 vpci->dev_hdr.dev_num << 3); 256 /* 257 * We don't need IRQ routing if we can use 258 * MSI injection via the KVM_SIGNAL_MSI ioctl. 259 */ 260 if (gsi == -ENXIO && 261 vpci->features & VIRTIO_PCI_F_SIGNAL_MSI) 262 break; 263 264 if (gsi < 0) { 265 die("failed to configure MSIs"); 266 break; 267 } 268 269 vpci->gsis[vpci->queue_selector] = gsi; 270 if (vdev->ops->notify_vq_gsi) 271 vdev->ops->notify_vq_gsi(kvm, vpci->dev, 272 vpci->queue_selector, 273 gsi); 274 break; 275 }; 276 277 return true; 278 } else if (type == VIRTIO_PCI_O_CONFIG) { 279 vdev->ops->get_config(kvm, vpci->dev)[config_offset] = *(u8 *)data; 280 281 return true; 282 } 283 284 return false; 285 } 286 287 static bool virtio_pci__data_out(struct kvm_cpu *vcpu, struct virtio_device *vdev, 288 unsigned long offset, void *data, int size) 289 { 290 bool ret = true; 291 struct virtio_pci *vpci; 292 struct kvm *kvm; 293 u32 val; 294 295 kvm = vcpu->kvm; 296 vpci = vdev->virtio; 297 298 switch (offset) { 299 case VIRTIO_PCI_GUEST_FEATURES: 300 val = ioport__read32(data); 301 virtio_set_guest_features(kvm, vdev, vpci->dev, val); 302 break; 303 case VIRTIO_PCI_QUEUE_PFN: 304 val = ioport__read32(data); 305 if (val) { 306 virtio_pci__init_ioeventfd(kvm, vdev, 307 vpci->queue_selector); 308 vdev->ops->init_vq(kvm, vpci->dev, vpci->queue_selector, 309 1 << VIRTIO_PCI_QUEUE_ADDR_SHIFT, 310 VIRTIO_PCI_VRING_ALIGN, val); 311 } else { 312 virtio_pci_exit_vq(kvm, vdev, vpci->queue_selector); 313 } 314 break; 315 case VIRTIO_PCI_QUEUE_SEL: 316 vpci->queue_selector = ioport__read16(data); 317 break; 318 case VIRTIO_PCI_QUEUE_NOTIFY: 319 val = ioport__read16(data); 320 vdev->ops->notify_vq(kvm, vpci->dev, val); 321 break; 322 case VIRTIO_PCI_STATUS: 323 vpci->status = ioport__read8(data); 324 if (!vpci->status) /* Sample endianness on reset */ 325 vdev->endian = kvm_cpu__get_endianness(vcpu); 326 virtio_notify_status(kvm, vdev, vpci->dev, vpci->status); 327 break; 328 default: 329 ret = virtio_pci__specific_data_out(kvm, vdev, data, size, offset); 330 break; 331 }; 332 333 return ret; 334 } 335 336 static void virtio_pci__msix_mmio_callback(struct kvm_cpu *vcpu, 337 u64 addr, u8 *data, u32 len, 338 u8 is_write, void *ptr) 339 { 340 struct virtio_device *vdev = ptr; 341 struct virtio_pci *vpci = vdev->virtio; 342 struct msix_table *table; 343 u32 msix_io_addr = virtio_pci__msix_io_addr(vpci); 344 u32 pba_offset; 345 int vecnum; 346 size_t offset; 347 348 BUILD_BUG_ON(VIRTIO_NR_MSIX > (sizeof(vpci->msix_pba) * 8)); 349 350 pba_offset = vpci->pci_hdr.msix.pba_offset & ~PCI_MSIX_TABLE_BIR; 351 if (addr >= msix_io_addr + pba_offset) { 352 /* Read access to PBA */ 353 if (is_write) 354 return; 355 offset = addr - (msix_io_addr + pba_offset); 356 if ((offset + len) > sizeof (vpci->msix_pba)) 357 return; 358 memcpy(data, (void *)&vpci->msix_pba + offset, len); 359 return; 360 } 361 362 table = vpci->msix_table; 363 offset = addr - msix_io_addr; 364 365 vecnum = offset / sizeof(struct msix_table); 366 offset = offset % sizeof(struct msix_table); 367 368 if (!is_write) { 369 memcpy(data, (void *)&table[vecnum] + offset, len); 370 return; 371 } 372 373 memcpy((void *)&table[vecnum] + offset, data, len); 374 375 /* Did we just update the address or payload? */ 376 if (offset < offsetof(struct msix_table, ctrl)) 377 update_msix_map(vpci, table, vecnum); 378 } 379 380 static void virtio_pci__signal_msi(struct kvm *kvm, struct virtio_pci *vpci, 381 int vec) 382 { 383 struct kvm_msi msi = { 384 .address_lo = vpci->msix_table[vec].msg.address_lo, 385 .address_hi = vpci->msix_table[vec].msg.address_hi, 386 .data = vpci->msix_table[vec].msg.data, 387 }; 388 389 if (kvm->msix_needs_devid) { 390 msi.flags = KVM_MSI_VALID_DEVID; 391 msi.devid = vpci->dev_hdr.dev_num << 3; 392 } 393 394 irq__signal_msi(kvm, &msi); 395 } 396 397 int virtio_pci__signal_vq(struct kvm *kvm, struct virtio_device *vdev, u32 vq) 398 { 399 struct virtio_pci *vpci = vdev->virtio; 400 int tbl = vpci->vq_vector[vq]; 401 402 if (virtio_pci__msix_enabled(vpci) && tbl != VIRTIO_MSI_NO_VECTOR) { 403 if (vpci->pci_hdr.msix.ctrl & cpu_to_le16(PCI_MSIX_FLAGS_MASKALL) || 404 vpci->msix_table[tbl].ctrl & cpu_to_le16(PCI_MSIX_ENTRY_CTRL_MASKBIT)) { 405 406 vpci->msix_pba |= 1 << tbl; 407 return 0; 408 } 409 410 if (vpci->features & VIRTIO_PCI_F_SIGNAL_MSI) 411 virtio_pci__signal_msi(kvm, vpci, vpci->vq_vector[vq]); 412 else 413 kvm__irq_trigger(kvm, vpci->gsis[vq]); 414 } else { 415 vpci->isr = VIRTIO_IRQ_HIGH; 416 kvm__irq_line(kvm, vpci->legacy_irq_line, VIRTIO_IRQ_HIGH); 417 } 418 return 0; 419 } 420 421 int virtio_pci__signal_config(struct kvm *kvm, struct virtio_device *vdev) 422 { 423 struct virtio_pci *vpci = vdev->virtio; 424 int tbl = vpci->config_vector; 425 426 if (virtio_pci__msix_enabled(vpci) && tbl != VIRTIO_MSI_NO_VECTOR) { 427 if (vpci->pci_hdr.msix.ctrl & cpu_to_le16(PCI_MSIX_FLAGS_MASKALL) || 428 vpci->msix_table[tbl].ctrl & cpu_to_le16(PCI_MSIX_ENTRY_CTRL_MASKBIT)) { 429 430 vpci->msix_pba |= 1 << tbl; 431 return 0; 432 } 433 434 if (vpci->features & VIRTIO_PCI_F_SIGNAL_MSI) 435 virtio_pci__signal_msi(kvm, vpci, tbl); 436 else 437 kvm__irq_trigger(kvm, vpci->config_gsi); 438 } else { 439 vpci->isr = VIRTIO_PCI_ISR_CONFIG; 440 kvm__irq_trigger(kvm, vpci->legacy_irq_line); 441 } 442 443 return 0; 444 } 445 446 static void virtio_pci__io_mmio_callback(struct kvm_cpu *vcpu, 447 u64 addr, u8 *data, u32 len, 448 u8 is_write, void *ptr) 449 { 450 struct virtio_device *vdev = ptr; 451 struct virtio_pci *vpci = vdev->virtio; 452 u32 ioport_addr = virtio_pci__port_addr(vpci); 453 u32 base_addr; 454 455 if (addr >= ioport_addr && 456 addr < ioport_addr + pci__bar_size(&vpci->pci_hdr, 0)) 457 base_addr = ioport_addr; 458 else 459 base_addr = virtio_pci__mmio_addr(vpci); 460 461 if (!is_write) 462 virtio_pci__data_in(vcpu, vdev, addr - base_addr, data, len); 463 else 464 virtio_pci__data_out(vcpu, vdev, addr - base_addr, data, len); 465 } 466 467 static int virtio_pci__bar_activate(struct kvm *kvm, 468 struct pci_device_header *pci_hdr, 469 int bar_num, void *data) 470 { 471 struct virtio_device *vdev = data; 472 u32 bar_addr, bar_size; 473 int r = -EINVAL; 474 475 assert(bar_num <= 2); 476 477 bar_addr = pci__bar_address(pci_hdr, bar_num); 478 bar_size = pci__bar_size(pci_hdr, bar_num); 479 480 switch (bar_num) { 481 case 0: 482 r = kvm__register_pio(kvm, bar_addr, bar_size, 483 virtio_pci__io_mmio_callback, vdev); 484 break; 485 case 1: 486 r = kvm__register_mmio(kvm, bar_addr, bar_size, false, 487 virtio_pci__io_mmio_callback, vdev); 488 break; 489 case 2: 490 r = kvm__register_mmio(kvm, bar_addr, bar_size, false, 491 virtio_pci__msix_mmio_callback, vdev); 492 break; 493 } 494 495 return r; 496 } 497 498 static int virtio_pci__bar_deactivate(struct kvm *kvm, 499 struct pci_device_header *pci_hdr, 500 int bar_num, void *data) 501 { 502 u32 bar_addr; 503 bool success; 504 int r = -EINVAL; 505 506 assert(bar_num <= 2); 507 508 bar_addr = pci__bar_address(pci_hdr, bar_num); 509 510 switch (bar_num) { 511 case 0: 512 r = kvm__deregister_pio(kvm, bar_addr); 513 break; 514 case 1: 515 case 2: 516 success = kvm__deregister_mmio(kvm, bar_addr); 517 /* kvm__deregister_mmio fails when the region is not found. */ 518 r = (success ? 0 : -ENOENT); 519 break; 520 } 521 522 return r; 523 } 524 525 int virtio_pci__init(struct kvm *kvm, void *dev, struct virtio_device *vdev, 526 int device_id, int subsys_id, int class) 527 { 528 struct virtio_pci *vpci = vdev->virtio; 529 u32 mmio_addr, msix_io_block; 530 u16 port_addr; 531 int r; 532 533 vpci->kvm = kvm; 534 vpci->dev = dev; 535 536 BUILD_BUG_ON(!is_power_of_two(PCI_IO_SIZE)); 537 538 port_addr = pci_get_io_port_block(PCI_IO_SIZE); 539 mmio_addr = pci_get_mmio_block(PCI_IO_SIZE); 540 msix_io_block = pci_get_mmio_block(VIRTIO_MSIX_BAR_SIZE); 541 542 vpci->pci_hdr = (struct pci_device_header) { 543 .vendor_id = cpu_to_le16(PCI_VENDOR_ID_REDHAT_QUMRANET), 544 .device_id = cpu_to_le16(device_id), 545 .command = PCI_COMMAND_IO | PCI_COMMAND_MEMORY, 546 .header_type = PCI_HEADER_TYPE_NORMAL, 547 .revision_id = 0, 548 .class[0] = class & 0xff, 549 .class[1] = (class >> 8) & 0xff, 550 .class[2] = (class >> 16) & 0xff, 551 .subsys_vendor_id = cpu_to_le16(PCI_SUBSYSTEM_VENDOR_ID_REDHAT_QUMRANET), 552 .subsys_id = cpu_to_le16(subsys_id), 553 .bar[0] = cpu_to_le32(port_addr 554 | PCI_BASE_ADDRESS_SPACE_IO), 555 .bar[1] = cpu_to_le32(mmio_addr 556 | PCI_BASE_ADDRESS_SPACE_MEMORY), 557 .bar[2] = cpu_to_le32(msix_io_block 558 | PCI_BASE_ADDRESS_SPACE_MEMORY), 559 .status = cpu_to_le16(PCI_STATUS_CAP_LIST), 560 .capabilities = (void *)&vpci->pci_hdr.msix - (void *)&vpci->pci_hdr, 561 .bar_size[0] = cpu_to_le32(PCI_IO_SIZE), 562 .bar_size[1] = cpu_to_le32(PCI_IO_SIZE), 563 .bar_size[2] = cpu_to_le32(VIRTIO_MSIX_BAR_SIZE), 564 }; 565 566 r = pci__register_bar_regions(kvm, &vpci->pci_hdr, 567 virtio_pci__bar_activate, 568 virtio_pci__bar_deactivate, vdev); 569 if (r < 0) 570 return r; 571 572 vpci->dev_hdr = (struct device_header) { 573 .bus_type = DEVICE_BUS_PCI, 574 .data = &vpci->pci_hdr, 575 }; 576 577 vpci->pci_hdr.msix.cap = PCI_CAP_ID_MSIX; 578 vpci->pci_hdr.msix.next = 0; 579 /* 580 * We at most have VIRTIO_NR_MSIX entries (VIRTIO_PCI_MAX_VQ 581 * entries for virt queue, VIRTIO_PCI_MAX_CONFIG entries for 582 * config). 583 * 584 * To quote the PCI spec: 585 * 586 * System software reads this field to determine the 587 * MSI-X Table Size N, which is encoded as N-1. 588 * For example, a returned value of "00000000011" 589 * indicates a table size of 4. 590 */ 591 vpci->pci_hdr.msix.ctrl = cpu_to_le16(VIRTIO_NR_MSIX - 1); 592 593 /* Both table and PBA are mapped to the same BAR (2) */ 594 vpci->pci_hdr.msix.table_offset = cpu_to_le32(2); 595 vpci->pci_hdr.msix.pba_offset = cpu_to_le32(2 | VIRTIO_MSIX_TABLE_SIZE); 596 vpci->config_vector = 0; 597 598 if (irq__can_signal_msi(kvm)) 599 vpci->features |= VIRTIO_PCI_F_SIGNAL_MSI; 600 601 vpci->legacy_irq_line = pci__assign_irq(&vpci->pci_hdr); 602 603 r = device__register(&vpci->dev_hdr); 604 if (r < 0) 605 return r; 606 607 return 0; 608 } 609 610 int virtio_pci__reset(struct kvm *kvm, struct virtio_device *vdev) 611 { 612 int vq; 613 struct virtio_pci *vpci = vdev->virtio; 614 615 for (vq = 0; vq < vdev->ops->get_vq_count(kvm, vpci->dev); vq++) 616 virtio_pci_exit_vq(kvm, vdev, vq); 617 618 return 0; 619 } 620 621 int virtio_pci__exit(struct kvm *kvm, struct virtio_device *vdev) 622 { 623 struct virtio_pci *vpci = vdev->virtio; 624 625 virtio_pci__reset(kvm, vdev); 626 kvm__deregister_mmio(kvm, virtio_pci__mmio_addr(vpci)); 627 kvm__deregister_mmio(kvm, virtio_pci__msix_io_addr(vpci)); 628 kvm__deregister_pio(kvm, virtio_pci__port_addr(vpci)); 629 630 return 0; 631 } 632