1 /* 2 * virtio ccw target implementation 3 * 4 * Copyright 2012,2015 IBM Corp. 5 * Author(s): Cornelia Huck <cornelia.huck@de.ibm.com> 6 * Pierre Morel <pmorel@linux.vnet.ibm.com> 7 * 8 * This work is licensed under the terms of the GNU GPL, version 2 or (at 9 * your option) any later version. See the COPYING file in the top-level 10 * directory. 11 */ 12 13 #include "qemu/osdep.h" 14 #include "qapi/error.h" 15 #include "hw/hw.h" 16 #include "sysemu/block-backend.h" 17 #include "sysemu/blockdev.h" 18 #include "sysemu/sysemu.h" 19 #include "sysemu/kvm.h" 20 #include "net/net.h" 21 #include "hw/virtio/virtio.h" 22 #include "hw/virtio/virtio-serial.h" 23 #include "hw/virtio/virtio-net.h" 24 #include "hw/sysbus.h" 25 #include "qemu/bitops.h" 26 #include "qemu/error-report.h" 27 #include "hw/virtio/virtio-access.h" 28 #include "hw/virtio/virtio-bus.h" 29 #include "hw/s390x/adapter.h" 30 #include "hw/s390x/s390_flic.h" 31 32 #include "hw/s390x/ioinst.h" 33 #include "hw/s390x/css.h" 34 #include "virtio-ccw.h" 35 #include "trace.h" 36 #include "hw/s390x/css-bridge.h" 37 38 #define NR_CLASSIC_INDICATOR_BITS 64 39 40 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size, 41 VirtioCcwDevice *dev); 42 43 VirtIODevice *virtio_ccw_get_vdev(SubchDev *sch) 44 { 45 VirtIODevice *vdev = NULL; 46 VirtioCcwDevice *dev = sch->driver_data; 47 48 if (dev) { 49 vdev = virtio_bus_get_device(&dev->bus); 50 } 51 return vdev; 52 } 53 54 static void virtio_ccw_start_ioeventfd(VirtioCcwDevice *dev) 55 { 56 virtio_bus_start_ioeventfd(&dev->bus); 57 } 58 59 static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice *dev) 60 { 61 virtio_bus_stop_ioeventfd(&dev->bus); 62 } 63 64 static bool virtio_ccw_ioeventfd_enabled(DeviceState *d) 65 { 66 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 67 68 return (dev->flags & VIRTIO_CCW_FLAG_USE_IOEVENTFD) != 0; 69 } 70 71 static int virtio_ccw_ioeventfd_assign(DeviceState *d, EventNotifier *notifier, 72 int n, bool assign) 73 { 74 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 75 CcwDevice *ccw_dev = CCW_DEVICE(dev); 76 SubchDev *sch = ccw_dev->sch; 77 uint32_t sch_id = (css_build_subchannel_id(sch) << 16) | sch->schid; 78 79 return s390_assign_subch_ioeventfd(notifier, sch_id, n, assign); 80 } 81 82 /* Communication blocks used by several channel commands. */ 83 typedef struct VqInfoBlockLegacy { 84 uint64_t queue; 85 uint32_t align; 86 uint16_t index; 87 uint16_t num; 88 } QEMU_PACKED VqInfoBlockLegacy; 89 90 typedef struct VqInfoBlock { 91 uint64_t desc; 92 uint32_t res0; 93 uint16_t index; 94 uint16_t num; 95 uint64_t avail; 96 uint64_t used; 97 } QEMU_PACKED VqInfoBlock; 98 99 typedef struct VqConfigBlock { 100 uint16_t index; 101 uint16_t num_max; 102 } QEMU_PACKED VqConfigBlock; 103 104 typedef struct VirtioFeatDesc { 105 uint32_t features; 106 uint8_t index; 107 } QEMU_PACKED VirtioFeatDesc; 108 109 typedef struct VirtioThinintInfo { 110 hwaddr summary_indicator; 111 hwaddr device_indicator; 112 uint64_t ind_bit; 113 uint8_t isc; 114 } QEMU_PACKED VirtioThinintInfo; 115 116 typedef struct VirtioRevInfo { 117 uint16_t revision; 118 uint16_t length; 119 uint8_t data[0]; 120 } QEMU_PACKED VirtioRevInfo; 121 122 /* Specify where the virtqueues for the subchannel are in guest memory. */ 123 static int virtio_ccw_set_vqs(SubchDev *sch, VqInfoBlock *info, 124 VqInfoBlockLegacy *linfo) 125 { 126 VirtIODevice *vdev = virtio_ccw_get_vdev(sch); 127 uint16_t index = info ? info->index : linfo->index; 128 uint16_t num = info ? info->num : linfo->num; 129 uint64_t desc = info ? info->desc : linfo->queue; 130 131 if (index >= VIRTIO_QUEUE_MAX) { 132 return -EINVAL; 133 } 134 135 /* Current code in virtio.c relies on 4K alignment. */ 136 if (linfo && desc && (linfo->align != 4096)) { 137 return -EINVAL; 138 } 139 140 if (!vdev) { 141 return -EINVAL; 142 } 143 144 if (info) { 145 virtio_queue_set_rings(vdev, index, desc, info->avail, info->used); 146 } else { 147 virtio_queue_set_addr(vdev, index, desc); 148 } 149 if (!desc) { 150 virtio_queue_set_vector(vdev, index, VIRTIO_NO_VECTOR); 151 } else { 152 if (info) { 153 /* virtio-1 allows changing the ring size. */ 154 if (virtio_queue_get_max_num(vdev, index) < num) { 155 /* Fail if we exceed the maximum number. */ 156 return -EINVAL; 157 } 158 virtio_queue_set_num(vdev, index, num); 159 } else if (virtio_queue_get_num(vdev, index) > num) { 160 /* Fail if we don't have a big enough queue. */ 161 return -EINVAL; 162 } 163 /* We ignore possible increased num for legacy for compatibility. */ 164 virtio_queue_set_vector(vdev, index, index); 165 } 166 /* tell notify handler in case of config change */ 167 vdev->config_vector = VIRTIO_QUEUE_MAX; 168 return 0; 169 } 170 171 static void virtio_ccw_reset_virtio(VirtioCcwDevice *dev, VirtIODevice *vdev) 172 { 173 CcwDevice *ccw_dev = CCW_DEVICE(dev); 174 175 virtio_ccw_stop_ioeventfd(dev); 176 virtio_reset(vdev); 177 if (dev->indicators) { 178 release_indicator(&dev->routes.adapter, dev->indicators); 179 dev->indicators = NULL; 180 } 181 if (dev->indicators2) { 182 release_indicator(&dev->routes.adapter, dev->indicators2); 183 dev->indicators2 = NULL; 184 } 185 if (dev->summary_indicator) { 186 release_indicator(&dev->routes.adapter, dev->summary_indicator); 187 dev->summary_indicator = NULL; 188 } 189 ccw_dev->sch->thinint_active = false; 190 } 191 192 static int virtio_ccw_handle_set_vq(SubchDev *sch, CCW1 ccw, bool check_len, 193 bool is_legacy) 194 { 195 int ret; 196 VqInfoBlock info; 197 VqInfoBlockLegacy linfo; 198 size_t info_len = is_legacy ? sizeof(linfo) : sizeof(info); 199 200 if (check_len) { 201 if (ccw.count != info_len) { 202 return -EINVAL; 203 } 204 } else if (ccw.count < info_len) { 205 /* Can't execute command. */ 206 return -EINVAL; 207 } 208 if (!ccw.cda) { 209 return -EFAULT; 210 } 211 if (is_legacy) { 212 linfo.queue = address_space_ldq_be(&address_space_memory, ccw.cda, 213 MEMTXATTRS_UNSPECIFIED, NULL); 214 linfo.align = address_space_ldl_be(&address_space_memory, 215 ccw.cda + sizeof(linfo.queue), 216 MEMTXATTRS_UNSPECIFIED, 217 NULL); 218 linfo.index = address_space_lduw_be(&address_space_memory, 219 ccw.cda + sizeof(linfo.queue) 220 + sizeof(linfo.align), 221 MEMTXATTRS_UNSPECIFIED, 222 NULL); 223 linfo.num = address_space_lduw_be(&address_space_memory, 224 ccw.cda + sizeof(linfo.queue) 225 + sizeof(linfo.align) 226 + sizeof(linfo.index), 227 MEMTXATTRS_UNSPECIFIED, 228 NULL); 229 ret = virtio_ccw_set_vqs(sch, NULL, &linfo); 230 } else { 231 info.desc = address_space_ldq_be(&address_space_memory, ccw.cda, 232 MEMTXATTRS_UNSPECIFIED, NULL); 233 info.index = address_space_lduw_be(&address_space_memory, 234 ccw.cda + sizeof(info.desc) 235 + sizeof(info.res0), 236 MEMTXATTRS_UNSPECIFIED, NULL); 237 info.num = address_space_lduw_be(&address_space_memory, 238 ccw.cda + sizeof(info.desc) 239 + sizeof(info.res0) 240 + sizeof(info.index), 241 MEMTXATTRS_UNSPECIFIED, NULL); 242 info.avail = address_space_ldq_be(&address_space_memory, 243 ccw.cda + sizeof(info.desc) 244 + sizeof(info.res0) 245 + sizeof(info.index) 246 + sizeof(info.num), 247 MEMTXATTRS_UNSPECIFIED, NULL); 248 info.used = address_space_ldq_be(&address_space_memory, 249 ccw.cda + sizeof(info.desc) 250 + sizeof(info.res0) 251 + sizeof(info.index) 252 + sizeof(info.num) 253 + sizeof(info.avail), 254 MEMTXATTRS_UNSPECIFIED, NULL); 255 ret = virtio_ccw_set_vqs(sch, &info, NULL); 256 } 257 sch->curr_status.scsw.count = 0; 258 return ret; 259 } 260 261 static int virtio_ccw_cb(SubchDev *sch, CCW1 ccw) 262 { 263 int ret; 264 VirtioRevInfo revinfo; 265 uint8_t status; 266 VirtioFeatDesc features; 267 void *config; 268 hwaddr indicators; 269 VqConfigBlock vq_config; 270 VirtioCcwDevice *dev = sch->driver_data; 271 VirtIODevice *vdev = virtio_ccw_get_vdev(sch); 272 bool check_len; 273 int len; 274 hwaddr hw_len; 275 VirtioThinintInfo *thinint; 276 277 if (!dev) { 278 return -EINVAL; 279 } 280 281 trace_virtio_ccw_interpret_ccw(sch->cssid, sch->ssid, sch->schid, 282 ccw.cmd_code); 283 check_len = !((ccw.flags & CCW_FLAG_SLI) && !(ccw.flags & CCW_FLAG_DC)); 284 285 if (dev->force_revision_1 && dev->revision < 0 && 286 ccw.cmd_code != CCW_CMD_SET_VIRTIO_REV) { 287 /* 288 * virtio-1 drivers must start with negotiating to a revision >= 1, 289 * so post a command reject for all other commands 290 */ 291 return -ENOSYS; 292 } 293 294 /* Look at the command. */ 295 switch (ccw.cmd_code) { 296 case CCW_CMD_SET_VQ: 297 ret = virtio_ccw_handle_set_vq(sch, ccw, check_len, dev->revision < 1); 298 break; 299 case CCW_CMD_VDEV_RESET: 300 virtio_ccw_reset_virtio(dev, vdev); 301 ret = 0; 302 break; 303 case CCW_CMD_READ_FEAT: 304 if (check_len) { 305 if (ccw.count != sizeof(features)) { 306 ret = -EINVAL; 307 break; 308 } 309 } else if (ccw.count < sizeof(features)) { 310 /* Can't execute command. */ 311 ret = -EINVAL; 312 break; 313 } 314 if (!ccw.cda) { 315 ret = -EFAULT; 316 } else { 317 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev); 318 319 features.index = address_space_ldub(&address_space_memory, 320 ccw.cda 321 + sizeof(features.features), 322 MEMTXATTRS_UNSPECIFIED, 323 NULL); 324 if (features.index == 0) { 325 if (dev->revision >= 1) { 326 /* Don't offer legacy features for modern devices. */ 327 features.features = (uint32_t) 328 (vdev->host_features & ~vdc->legacy_features); 329 } else { 330 features.features = (uint32_t)vdev->host_features; 331 } 332 } else if ((features.index == 1) && (dev->revision >= 1)) { 333 /* 334 * Only offer feature bits beyond 31 if the guest has 335 * negotiated at least revision 1. 336 */ 337 features.features = (uint32_t)(vdev->host_features >> 32); 338 } else { 339 /* Return zeroes if the guest supports more feature bits. */ 340 features.features = 0; 341 } 342 address_space_stl_le(&address_space_memory, ccw.cda, 343 features.features, MEMTXATTRS_UNSPECIFIED, 344 NULL); 345 sch->curr_status.scsw.count = ccw.count - sizeof(features); 346 ret = 0; 347 } 348 break; 349 case CCW_CMD_WRITE_FEAT: 350 if (check_len) { 351 if (ccw.count != sizeof(features)) { 352 ret = -EINVAL; 353 break; 354 } 355 } else if (ccw.count < sizeof(features)) { 356 /* Can't execute command. */ 357 ret = -EINVAL; 358 break; 359 } 360 if (!ccw.cda) { 361 ret = -EFAULT; 362 } else { 363 features.index = address_space_ldub(&address_space_memory, 364 ccw.cda 365 + sizeof(features.features), 366 MEMTXATTRS_UNSPECIFIED, 367 NULL); 368 features.features = address_space_ldl_le(&address_space_memory, 369 ccw.cda, 370 MEMTXATTRS_UNSPECIFIED, 371 NULL); 372 if (features.index == 0) { 373 virtio_set_features(vdev, 374 (vdev->guest_features & 0xffffffff00000000ULL) | 375 features.features); 376 } else if ((features.index == 1) && (dev->revision >= 1)) { 377 /* 378 * If the guest did not negotiate at least revision 1, 379 * we did not offer it any feature bits beyond 31. Such a 380 * guest passing us any bit here is therefore buggy. 381 */ 382 virtio_set_features(vdev, 383 (vdev->guest_features & 0x00000000ffffffffULL) | 384 ((uint64_t)features.features << 32)); 385 } else { 386 /* 387 * If the guest supports more feature bits, assert that it 388 * passes us zeroes for those we don't support. 389 */ 390 if (features.features) { 391 fprintf(stderr, "Guest bug: features[%i]=%x (expected 0)\n", 392 features.index, features.features); 393 /* XXX: do a unit check here? */ 394 } 395 } 396 sch->curr_status.scsw.count = ccw.count - sizeof(features); 397 ret = 0; 398 } 399 break; 400 case CCW_CMD_READ_CONF: 401 if (check_len) { 402 if (ccw.count > vdev->config_len) { 403 ret = -EINVAL; 404 break; 405 } 406 } 407 len = MIN(ccw.count, vdev->config_len); 408 if (!ccw.cda) { 409 ret = -EFAULT; 410 } else { 411 virtio_bus_get_vdev_config(&dev->bus, vdev->config); 412 /* XXX config space endianness */ 413 cpu_physical_memory_write(ccw.cda, vdev->config, len); 414 sch->curr_status.scsw.count = ccw.count - len; 415 ret = 0; 416 } 417 break; 418 case CCW_CMD_WRITE_CONF: 419 if (check_len) { 420 if (ccw.count > vdev->config_len) { 421 ret = -EINVAL; 422 break; 423 } 424 } 425 len = MIN(ccw.count, vdev->config_len); 426 hw_len = len; 427 if (!ccw.cda) { 428 ret = -EFAULT; 429 } else { 430 config = cpu_physical_memory_map(ccw.cda, &hw_len, 0); 431 if (!config) { 432 ret = -EFAULT; 433 } else { 434 len = hw_len; 435 /* XXX config space endianness */ 436 memcpy(vdev->config, config, len); 437 cpu_physical_memory_unmap(config, hw_len, 0, hw_len); 438 virtio_bus_set_vdev_config(&dev->bus, vdev->config); 439 sch->curr_status.scsw.count = ccw.count - len; 440 ret = 0; 441 } 442 } 443 break; 444 case CCW_CMD_READ_STATUS: 445 if (check_len) { 446 if (ccw.count != sizeof(status)) { 447 ret = -EINVAL; 448 break; 449 } 450 } else if (ccw.count < sizeof(status)) { 451 /* Can't execute command. */ 452 ret = -EINVAL; 453 break; 454 } 455 if (!ccw.cda) { 456 ret = -EFAULT; 457 } else { 458 address_space_stb(&address_space_memory, ccw.cda, vdev->status, 459 MEMTXATTRS_UNSPECIFIED, NULL); 460 sch->curr_status.scsw.count = ccw.count - sizeof(vdev->status);; 461 ret = 0; 462 } 463 break; 464 case CCW_CMD_WRITE_STATUS: 465 if (check_len) { 466 if (ccw.count != sizeof(status)) { 467 ret = -EINVAL; 468 break; 469 } 470 } else if (ccw.count < sizeof(status)) { 471 /* Can't execute command. */ 472 ret = -EINVAL; 473 break; 474 } 475 if (!ccw.cda) { 476 ret = -EFAULT; 477 } else { 478 status = address_space_ldub(&address_space_memory, ccw.cda, 479 MEMTXATTRS_UNSPECIFIED, NULL); 480 if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) { 481 virtio_ccw_stop_ioeventfd(dev); 482 } 483 if (virtio_set_status(vdev, status) == 0) { 484 if (vdev->status == 0) { 485 virtio_ccw_reset_virtio(dev, vdev); 486 } 487 if (status & VIRTIO_CONFIG_S_DRIVER_OK) { 488 virtio_ccw_start_ioeventfd(dev); 489 } 490 sch->curr_status.scsw.count = ccw.count - sizeof(status); 491 ret = 0; 492 } else { 493 /* Trigger a command reject. */ 494 ret = -ENOSYS; 495 } 496 } 497 break; 498 case CCW_CMD_SET_IND: 499 if (check_len) { 500 if (ccw.count != sizeof(indicators)) { 501 ret = -EINVAL; 502 break; 503 } 504 } else if (ccw.count < sizeof(indicators)) { 505 /* Can't execute command. */ 506 ret = -EINVAL; 507 break; 508 } 509 if (sch->thinint_active) { 510 /* Trigger a command reject. */ 511 ret = -ENOSYS; 512 break; 513 } 514 if (virtio_get_num_queues(vdev) > NR_CLASSIC_INDICATOR_BITS) { 515 /* More queues than indicator bits --> trigger a reject */ 516 ret = -ENOSYS; 517 break; 518 } 519 if (!ccw.cda) { 520 ret = -EFAULT; 521 } else { 522 indicators = address_space_ldq_be(&address_space_memory, ccw.cda, 523 MEMTXATTRS_UNSPECIFIED, NULL); 524 dev->indicators = get_indicator(indicators, sizeof(uint64_t)); 525 sch->curr_status.scsw.count = ccw.count - sizeof(indicators); 526 ret = 0; 527 } 528 break; 529 case CCW_CMD_SET_CONF_IND: 530 if (check_len) { 531 if (ccw.count != sizeof(indicators)) { 532 ret = -EINVAL; 533 break; 534 } 535 } else if (ccw.count < sizeof(indicators)) { 536 /* Can't execute command. */ 537 ret = -EINVAL; 538 break; 539 } 540 if (!ccw.cda) { 541 ret = -EFAULT; 542 } else { 543 indicators = address_space_ldq_be(&address_space_memory, ccw.cda, 544 MEMTXATTRS_UNSPECIFIED, NULL); 545 dev->indicators2 = get_indicator(indicators, sizeof(uint64_t)); 546 sch->curr_status.scsw.count = ccw.count - sizeof(indicators); 547 ret = 0; 548 } 549 break; 550 case CCW_CMD_READ_VQ_CONF: 551 if (check_len) { 552 if (ccw.count != sizeof(vq_config)) { 553 ret = -EINVAL; 554 break; 555 } 556 } else if (ccw.count < sizeof(vq_config)) { 557 /* Can't execute command. */ 558 ret = -EINVAL; 559 break; 560 } 561 if (!ccw.cda) { 562 ret = -EFAULT; 563 } else { 564 vq_config.index = address_space_lduw_be(&address_space_memory, 565 ccw.cda, 566 MEMTXATTRS_UNSPECIFIED, 567 NULL); 568 if (vq_config.index >= VIRTIO_QUEUE_MAX) { 569 ret = -EINVAL; 570 break; 571 } 572 vq_config.num_max = virtio_queue_get_num(vdev, 573 vq_config.index); 574 address_space_stw_be(&address_space_memory, 575 ccw.cda + sizeof(vq_config.index), 576 vq_config.num_max, 577 MEMTXATTRS_UNSPECIFIED, 578 NULL); 579 sch->curr_status.scsw.count = ccw.count - sizeof(vq_config); 580 ret = 0; 581 } 582 break; 583 case CCW_CMD_SET_IND_ADAPTER: 584 if (check_len) { 585 if (ccw.count != sizeof(*thinint)) { 586 ret = -EINVAL; 587 break; 588 } 589 } else if (ccw.count < sizeof(*thinint)) { 590 /* Can't execute command. */ 591 ret = -EINVAL; 592 break; 593 } 594 len = sizeof(*thinint); 595 hw_len = len; 596 if (!ccw.cda) { 597 ret = -EFAULT; 598 } else if (dev->indicators && !sch->thinint_active) { 599 /* Trigger a command reject. */ 600 ret = -ENOSYS; 601 } else { 602 thinint = cpu_physical_memory_map(ccw.cda, &hw_len, 0); 603 if (!thinint) { 604 ret = -EFAULT; 605 } else { 606 uint64_t ind_bit = ldq_be_p(&thinint->ind_bit); 607 608 len = hw_len; 609 dev->summary_indicator = 610 get_indicator(ldq_be_p(&thinint->summary_indicator), 611 sizeof(uint8_t)); 612 dev->indicators = 613 get_indicator(ldq_be_p(&thinint->device_indicator), 614 ind_bit / 8 + 1); 615 dev->thinint_isc = thinint->isc; 616 dev->routes.adapter.ind_offset = ind_bit; 617 dev->routes.adapter.summary_offset = 7; 618 cpu_physical_memory_unmap(thinint, hw_len, 0, hw_len); 619 dev->routes.adapter.adapter_id = css_get_adapter_id( 620 CSS_IO_ADAPTER_VIRTIO, 621 dev->thinint_isc); 622 sch->thinint_active = ((dev->indicators != NULL) && 623 (dev->summary_indicator != NULL)); 624 sch->curr_status.scsw.count = ccw.count - len; 625 ret = 0; 626 } 627 } 628 break; 629 case CCW_CMD_SET_VIRTIO_REV: 630 len = sizeof(revinfo); 631 if (ccw.count < len) { 632 ret = -EINVAL; 633 break; 634 } 635 if (!ccw.cda) { 636 ret = -EFAULT; 637 break; 638 } 639 revinfo.revision = 640 address_space_lduw_be(&address_space_memory, ccw.cda, 641 MEMTXATTRS_UNSPECIFIED, NULL); 642 revinfo.length = 643 address_space_lduw_be(&address_space_memory, 644 ccw.cda + sizeof(revinfo.revision), 645 MEMTXATTRS_UNSPECIFIED, NULL); 646 if (ccw.count < len + revinfo.length || 647 (check_len && ccw.count > len + revinfo.length)) { 648 ret = -EINVAL; 649 break; 650 } 651 /* 652 * Once we start to support revisions with additional data, we'll 653 * need to fetch it here. Nothing to do for now, though. 654 */ 655 if (dev->revision >= 0 || 656 revinfo.revision > virtio_ccw_rev_max(dev) || 657 (dev->force_revision_1 && !revinfo.revision)) { 658 ret = -ENOSYS; 659 break; 660 } 661 ret = 0; 662 dev->revision = revinfo.revision; 663 break; 664 default: 665 ret = -ENOSYS; 666 break; 667 } 668 return ret; 669 } 670 671 static void virtio_sch_disable_cb(SubchDev *sch) 672 { 673 VirtioCcwDevice *dev = sch->driver_data; 674 675 dev->revision = -1; 676 } 677 678 static void virtio_ccw_device_realize(VirtioCcwDevice *dev, Error **errp) 679 { 680 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_GET_CLASS(dev); 681 CcwDevice *ccw_dev = CCW_DEVICE(dev); 682 CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev); 683 DeviceState *parent = DEVICE(ccw_dev); 684 BusState *qbus = qdev_get_parent_bus(parent); 685 VirtualCssBus *cbus = VIRTUAL_CSS_BUS(qbus); 686 SubchDev *sch; 687 Error *err = NULL; 688 689 sch = css_create_sch(ccw_dev->devno, true, cbus->squash_mcss, errp); 690 if (!sch) { 691 return; 692 } 693 if (!virtio_ccw_rev_max(dev) && dev->force_revision_1) { 694 error_setg(&err, "Invalid value of property max_rev " 695 "(is %d expected >= 1)", virtio_ccw_rev_max(dev)); 696 goto out_err; 697 } 698 699 sch->driver_data = dev; 700 sch->ccw_cb = virtio_ccw_cb; 701 sch->disable_cb = virtio_sch_disable_cb; 702 sch->id.reserved = 0xff; 703 sch->id.cu_type = VIRTIO_CCW_CU_TYPE; 704 sch->do_subchannel_work = do_subchannel_work_virtual; 705 ccw_dev->sch = sch; 706 dev->indicators = NULL; 707 dev->revision = -1; 708 css_sch_build_virtual_schib(sch, 0, VIRTIO_CCW_CHPID_TYPE); 709 710 trace_virtio_ccw_new_device( 711 sch->cssid, sch->ssid, sch->schid, sch->devno, 712 ccw_dev->devno.valid ? "user-configured" : "auto-configured"); 713 714 if (!kvm_eventfds_enabled()) { 715 dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD; 716 } 717 718 if (k->realize) { 719 k->realize(dev, &err); 720 if (err) { 721 goto out_err; 722 } 723 } 724 725 ck->realize(ccw_dev, &err); 726 if (err) { 727 goto out_err; 728 } 729 730 return; 731 732 out_err: 733 error_propagate(errp, err); 734 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL); 735 ccw_dev->sch = NULL; 736 g_free(sch); 737 } 738 739 static int virtio_ccw_exit(VirtioCcwDevice *dev) 740 { 741 CcwDevice *ccw_dev = CCW_DEVICE(dev); 742 SubchDev *sch = ccw_dev->sch; 743 744 if (sch) { 745 css_subch_assign(sch->cssid, sch->ssid, sch->schid, sch->devno, NULL); 746 g_free(sch); 747 } 748 if (dev->indicators) { 749 release_indicator(&dev->routes.adapter, dev->indicators); 750 dev->indicators = NULL; 751 } 752 return 0; 753 } 754 755 static void virtio_ccw_net_realize(VirtioCcwDevice *ccw_dev, Error **errp) 756 { 757 DeviceState *qdev = DEVICE(ccw_dev); 758 VirtIONetCcw *dev = VIRTIO_NET_CCW(ccw_dev); 759 DeviceState *vdev = DEVICE(&dev->vdev); 760 761 virtio_net_set_netclient_name(&dev->vdev, qdev->id, 762 object_get_typename(OBJECT(qdev))); 763 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 764 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 765 } 766 767 static void virtio_ccw_net_instance_init(Object *obj) 768 { 769 VirtIONetCcw *dev = VIRTIO_NET_CCW(obj); 770 771 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 772 TYPE_VIRTIO_NET); 773 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev), 774 "bootindex", &error_abort); 775 } 776 777 static void virtio_ccw_blk_realize(VirtioCcwDevice *ccw_dev, Error **errp) 778 { 779 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(ccw_dev); 780 DeviceState *vdev = DEVICE(&dev->vdev); 781 782 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 783 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 784 } 785 786 static void virtio_ccw_blk_instance_init(Object *obj) 787 { 788 VirtIOBlkCcw *dev = VIRTIO_BLK_CCW(obj); 789 790 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 791 TYPE_VIRTIO_BLK); 792 object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev),"iothread", 793 &error_abort); 794 object_property_add_alias(obj, "bootindex", OBJECT(&dev->vdev), 795 "bootindex", &error_abort); 796 } 797 798 static void virtio_ccw_serial_realize(VirtioCcwDevice *ccw_dev, Error **errp) 799 { 800 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(ccw_dev); 801 DeviceState *vdev = DEVICE(&dev->vdev); 802 DeviceState *proxy = DEVICE(ccw_dev); 803 char *bus_name; 804 805 /* 806 * For command line compatibility, this sets the virtio-serial-device bus 807 * name as before. 808 */ 809 if (proxy->id) { 810 bus_name = g_strdup_printf("%s.0", proxy->id); 811 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 812 g_free(bus_name); 813 } 814 815 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 816 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 817 } 818 819 820 static void virtio_ccw_serial_instance_init(Object *obj) 821 { 822 VirtioSerialCcw *dev = VIRTIO_SERIAL_CCW(obj); 823 824 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 825 TYPE_VIRTIO_SERIAL); 826 } 827 828 static void virtio_ccw_balloon_realize(VirtioCcwDevice *ccw_dev, Error **errp) 829 { 830 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(ccw_dev); 831 DeviceState *vdev = DEVICE(&dev->vdev); 832 833 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 834 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 835 } 836 837 static void virtio_ccw_balloon_instance_init(Object *obj) 838 { 839 VirtIOBalloonCcw *dev = VIRTIO_BALLOON_CCW(obj); 840 841 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 842 TYPE_VIRTIO_BALLOON); 843 object_property_add_alias(obj, "guest-stats", OBJECT(&dev->vdev), 844 "guest-stats", &error_abort); 845 object_property_add_alias(obj, "guest-stats-polling-interval", 846 OBJECT(&dev->vdev), 847 "guest-stats-polling-interval", &error_abort); 848 } 849 850 static void virtio_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp) 851 { 852 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(ccw_dev); 853 DeviceState *vdev = DEVICE(&dev->vdev); 854 DeviceState *qdev = DEVICE(ccw_dev); 855 char *bus_name; 856 857 /* 858 * For command line compatibility, this sets the virtio-scsi-device bus 859 * name as before. 860 */ 861 if (qdev->id) { 862 bus_name = g_strdup_printf("%s.0", qdev->id); 863 virtio_device_set_child_bus_name(VIRTIO_DEVICE(vdev), bus_name); 864 g_free(bus_name); 865 } 866 867 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 868 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 869 } 870 871 static void virtio_ccw_scsi_instance_init(Object *obj) 872 { 873 VirtIOSCSICcw *dev = VIRTIO_SCSI_CCW(obj); 874 875 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 876 TYPE_VIRTIO_SCSI); 877 object_property_add_alias(obj, "iothread", OBJECT(&dev->vdev), "iothread", 878 &error_abort); 879 } 880 881 #ifdef CONFIG_VHOST_SCSI 882 static void vhost_ccw_scsi_realize(VirtioCcwDevice *ccw_dev, Error **errp) 883 { 884 VHostSCSICcw *dev = VHOST_SCSI_CCW(ccw_dev); 885 DeviceState *vdev = DEVICE(&dev->vdev); 886 887 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 888 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 889 } 890 891 static void vhost_ccw_scsi_instance_init(Object *obj) 892 { 893 VHostSCSICcw *dev = VHOST_SCSI_CCW(obj); 894 895 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 896 TYPE_VHOST_SCSI); 897 } 898 #endif 899 900 static void virtio_ccw_rng_realize(VirtioCcwDevice *ccw_dev, Error **errp) 901 { 902 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(ccw_dev); 903 DeviceState *vdev = DEVICE(&dev->vdev); 904 Error *err = NULL; 905 906 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 907 object_property_set_bool(OBJECT(vdev), true, "realized", &err); 908 if (err) { 909 error_propagate(errp, err); 910 return; 911 } 912 913 object_property_set_link(OBJECT(dev), 914 OBJECT(dev->vdev.conf.rng), "rng", 915 NULL); 916 } 917 918 static void virtio_ccw_crypto_realize(VirtioCcwDevice *ccw_dev, Error **errp) 919 { 920 VirtIOCryptoCcw *dev = VIRTIO_CRYPTO_CCW(ccw_dev); 921 DeviceState *vdev = DEVICE(&dev->vdev); 922 Error *err = NULL; 923 924 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 925 object_property_set_bool(OBJECT(vdev), true, "realized", &err); 926 if (err) { 927 error_propagate(errp, err); 928 return; 929 } 930 931 object_property_set_link(OBJECT(vdev), 932 OBJECT(dev->vdev.conf.cryptodev), "cryptodev", 933 NULL); 934 } 935 936 /* DeviceState to VirtioCcwDevice. Note: used on datapath, 937 * be careful and test performance if you change this. 938 */ 939 static inline VirtioCcwDevice *to_virtio_ccw_dev_fast(DeviceState *d) 940 { 941 CcwDevice *ccw_dev = to_ccw_dev_fast(d); 942 943 return container_of(ccw_dev, VirtioCcwDevice, parent_obj); 944 } 945 946 static uint8_t virtio_set_ind_atomic(SubchDev *sch, uint64_t ind_loc, 947 uint8_t to_be_set) 948 { 949 uint8_t ind_old, ind_new; 950 hwaddr len = 1; 951 uint8_t *ind_addr; 952 953 ind_addr = cpu_physical_memory_map(ind_loc, &len, 1); 954 if (!ind_addr) { 955 error_report("%s(%x.%x.%04x): unable to access indicator", 956 __func__, sch->cssid, sch->ssid, sch->schid); 957 return -1; 958 } 959 do { 960 ind_old = *ind_addr; 961 ind_new = ind_old | to_be_set; 962 } while (atomic_cmpxchg(ind_addr, ind_old, ind_new) != ind_old); 963 trace_virtio_ccw_set_ind(ind_loc, ind_old, ind_new); 964 cpu_physical_memory_unmap(ind_addr, len, 1, len); 965 966 return ind_old; 967 } 968 969 static void virtio_ccw_notify(DeviceState *d, uint16_t vector) 970 { 971 VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d); 972 CcwDevice *ccw_dev = to_ccw_dev_fast(d); 973 SubchDev *sch = ccw_dev->sch; 974 uint64_t indicators; 975 976 /* queue indicators + secondary indicators */ 977 if (vector >= VIRTIO_QUEUE_MAX + 64) { 978 return; 979 } 980 981 if (vector < VIRTIO_QUEUE_MAX) { 982 if (!dev->indicators) { 983 return; 984 } 985 if (sch->thinint_active) { 986 /* 987 * In the adapter interrupt case, indicators points to a 988 * memory area that may be (way) larger than 64 bit and 989 * ind_bit indicates the start of the indicators in a big 990 * endian notation. 991 */ 992 uint64_t ind_bit = dev->routes.adapter.ind_offset; 993 994 virtio_set_ind_atomic(sch, dev->indicators->addr + 995 (ind_bit + vector) / 8, 996 0x80 >> ((ind_bit + vector) % 8)); 997 if (!virtio_set_ind_atomic(sch, dev->summary_indicator->addr, 998 0x01)) { 999 css_adapter_interrupt(dev->thinint_isc); 1000 } 1001 } else { 1002 indicators = address_space_ldq(&address_space_memory, 1003 dev->indicators->addr, 1004 MEMTXATTRS_UNSPECIFIED, 1005 NULL); 1006 indicators |= 1ULL << vector; 1007 address_space_stq(&address_space_memory, dev->indicators->addr, 1008 indicators, MEMTXATTRS_UNSPECIFIED, NULL); 1009 css_conditional_io_interrupt(sch); 1010 } 1011 } else { 1012 if (!dev->indicators2) { 1013 return; 1014 } 1015 vector = 0; 1016 indicators = address_space_ldq(&address_space_memory, 1017 dev->indicators2->addr, 1018 MEMTXATTRS_UNSPECIFIED, 1019 NULL); 1020 indicators |= 1ULL << vector; 1021 address_space_stq(&address_space_memory, dev->indicators2->addr, 1022 indicators, MEMTXATTRS_UNSPECIFIED, NULL); 1023 css_conditional_io_interrupt(sch); 1024 } 1025 } 1026 1027 static void virtio_ccw_reset(DeviceState *d) 1028 { 1029 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1030 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1031 CcwDevice *ccw_dev = CCW_DEVICE(d); 1032 1033 virtio_ccw_reset_virtio(dev, vdev); 1034 css_reset_sch(ccw_dev->sch); 1035 } 1036 1037 static void virtio_ccw_vmstate_change(DeviceState *d, bool running) 1038 { 1039 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1040 1041 if (running) { 1042 virtio_ccw_start_ioeventfd(dev); 1043 } else { 1044 virtio_ccw_stop_ioeventfd(dev); 1045 } 1046 } 1047 1048 static bool virtio_ccw_query_guest_notifiers(DeviceState *d) 1049 { 1050 CcwDevice *dev = CCW_DEVICE(d); 1051 1052 return !!(dev->sch->curr_status.pmcw.flags & PMCW_FLAGS_MASK_ENA); 1053 } 1054 1055 static int virtio_ccw_get_mappings(VirtioCcwDevice *dev) 1056 { 1057 int r; 1058 CcwDevice *ccw_dev = CCW_DEVICE(dev); 1059 1060 if (!ccw_dev->sch->thinint_active) { 1061 return -EINVAL; 1062 } 1063 1064 r = map_indicator(&dev->routes.adapter, dev->summary_indicator); 1065 if (r) { 1066 return r; 1067 } 1068 r = map_indicator(&dev->routes.adapter, dev->indicators); 1069 if (r) { 1070 return r; 1071 } 1072 dev->routes.adapter.summary_addr = dev->summary_indicator->map; 1073 dev->routes.adapter.ind_addr = dev->indicators->map; 1074 1075 return 0; 1076 } 1077 1078 static int virtio_ccw_setup_irqroutes(VirtioCcwDevice *dev, int nvqs) 1079 { 1080 int i; 1081 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1082 int ret; 1083 S390FLICState *fs = s390_get_flic(); 1084 S390FLICStateClass *fsc = S390_FLIC_COMMON_GET_CLASS(fs); 1085 1086 ret = virtio_ccw_get_mappings(dev); 1087 if (ret) { 1088 return ret; 1089 } 1090 for (i = 0; i < nvqs; i++) { 1091 if (!virtio_queue_get_num(vdev, i)) { 1092 break; 1093 } 1094 } 1095 dev->routes.num_routes = i; 1096 return fsc->add_adapter_routes(fs, &dev->routes); 1097 } 1098 1099 static void virtio_ccw_release_irqroutes(VirtioCcwDevice *dev, int nvqs) 1100 { 1101 S390FLICState *fs = s390_get_flic(); 1102 S390FLICStateClass *fsc = S390_FLIC_COMMON_GET_CLASS(fs); 1103 1104 fsc->release_adapter_routes(fs, &dev->routes); 1105 } 1106 1107 static int virtio_ccw_add_irqfd(VirtioCcwDevice *dev, int n) 1108 { 1109 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1110 VirtQueue *vq = virtio_get_queue(vdev, n); 1111 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 1112 1113 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state, notifier, NULL, 1114 dev->routes.gsi[n]); 1115 } 1116 1117 static void virtio_ccw_remove_irqfd(VirtioCcwDevice *dev, int n) 1118 { 1119 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1120 VirtQueue *vq = virtio_get_queue(vdev, n); 1121 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 1122 int ret; 1123 1124 ret = kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state, notifier, 1125 dev->routes.gsi[n]); 1126 assert(ret == 0); 1127 } 1128 1129 static int virtio_ccw_set_guest_notifier(VirtioCcwDevice *dev, int n, 1130 bool assign, bool with_irqfd) 1131 { 1132 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1133 VirtQueue *vq = virtio_get_queue(vdev, n); 1134 EventNotifier *notifier = virtio_queue_get_guest_notifier(vq); 1135 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev); 1136 1137 if (assign) { 1138 int r = event_notifier_init(notifier, 0); 1139 1140 if (r < 0) { 1141 return r; 1142 } 1143 virtio_queue_set_guest_notifier_fd_handler(vq, true, with_irqfd); 1144 if (with_irqfd) { 1145 r = virtio_ccw_add_irqfd(dev, n); 1146 if (r) { 1147 virtio_queue_set_guest_notifier_fd_handler(vq, false, 1148 with_irqfd); 1149 return r; 1150 } 1151 } 1152 /* 1153 * We do not support individual masking for channel devices, so we 1154 * need to manually trigger any guest masking callbacks here. 1155 */ 1156 if (k->guest_notifier_mask && vdev->use_guest_notifier_mask) { 1157 k->guest_notifier_mask(vdev, n, false); 1158 } 1159 /* get lost events and re-inject */ 1160 if (k->guest_notifier_pending && 1161 k->guest_notifier_pending(vdev, n)) { 1162 event_notifier_set(notifier); 1163 } 1164 } else { 1165 if (k->guest_notifier_mask && vdev->use_guest_notifier_mask) { 1166 k->guest_notifier_mask(vdev, n, true); 1167 } 1168 if (with_irqfd) { 1169 virtio_ccw_remove_irqfd(dev, n); 1170 } 1171 virtio_queue_set_guest_notifier_fd_handler(vq, false, with_irqfd); 1172 event_notifier_cleanup(notifier); 1173 } 1174 return 0; 1175 } 1176 1177 static int virtio_ccw_set_guest_notifiers(DeviceState *d, int nvqs, 1178 bool assigned) 1179 { 1180 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1181 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1182 CcwDevice *ccw_dev = CCW_DEVICE(d); 1183 bool with_irqfd = ccw_dev->sch->thinint_active && kvm_irqfds_enabled(); 1184 int r, n; 1185 1186 if (with_irqfd && assigned) { 1187 /* irq routes need to be set up before assigning irqfds */ 1188 r = virtio_ccw_setup_irqroutes(dev, nvqs); 1189 if (r < 0) { 1190 goto irqroute_error; 1191 } 1192 } 1193 for (n = 0; n < nvqs; n++) { 1194 if (!virtio_queue_get_num(vdev, n)) { 1195 break; 1196 } 1197 r = virtio_ccw_set_guest_notifier(dev, n, assigned, with_irqfd); 1198 if (r < 0) { 1199 goto assign_error; 1200 } 1201 } 1202 if (with_irqfd && !assigned) { 1203 /* release irq routes after irqfds have been released */ 1204 virtio_ccw_release_irqroutes(dev, nvqs); 1205 } 1206 return 0; 1207 1208 assign_error: 1209 while (--n >= 0) { 1210 virtio_ccw_set_guest_notifier(dev, n, !assigned, false); 1211 } 1212 irqroute_error: 1213 if (with_irqfd && assigned) { 1214 virtio_ccw_release_irqroutes(dev, nvqs); 1215 } 1216 return r; 1217 } 1218 1219 static void virtio_ccw_save_queue(DeviceState *d, int n, QEMUFile *f) 1220 { 1221 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1222 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1223 1224 qemu_put_be16(f, virtio_queue_vector(vdev, n)); 1225 } 1226 1227 static int virtio_ccw_load_queue(DeviceState *d, int n, QEMUFile *f) 1228 { 1229 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1230 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1231 uint16_t vector; 1232 1233 qemu_get_be16s(f, &vector); 1234 virtio_queue_set_vector(vdev, n , vector); 1235 1236 return 0; 1237 } 1238 1239 static void virtio_ccw_save_config(DeviceState *d, QEMUFile *f) 1240 { 1241 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1242 CcwDevice *ccw_dev = CCW_DEVICE(d); 1243 SubchDev *s = ccw_dev->sch; 1244 VirtIODevice *vdev = virtio_ccw_get_vdev(s); 1245 1246 subch_device_save(s, f); 1247 if (dev->indicators != NULL) { 1248 qemu_put_be32(f, dev->indicators->len); 1249 qemu_put_be64(f, dev->indicators->addr); 1250 } else { 1251 qemu_put_be32(f, 0); 1252 qemu_put_be64(f, 0UL); 1253 } 1254 if (dev->indicators2 != NULL) { 1255 qemu_put_be32(f, dev->indicators2->len); 1256 qemu_put_be64(f, dev->indicators2->addr); 1257 } else { 1258 qemu_put_be32(f, 0); 1259 qemu_put_be64(f, 0UL); 1260 } 1261 if (dev->summary_indicator != NULL) { 1262 qemu_put_be32(f, dev->summary_indicator->len); 1263 qemu_put_be64(f, dev->summary_indicator->addr); 1264 } else { 1265 qemu_put_be32(f, 0); 1266 qemu_put_be64(f, 0UL); 1267 } 1268 qemu_put_be16(f, vdev->config_vector); 1269 qemu_put_be64(f, dev->routes.adapter.ind_offset); 1270 qemu_put_byte(f, dev->thinint_isc); 1271 qemu_put_be32(f, dev->revision); 1272 } 1273 1274 static int virtio_ccw_load_config(DeviceState *d, QEMUFile *f) 1275 { 1276 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1277 CcwDevice *ccw_dev = CCW_DEVICE(d); 1278 CCWDeviceClass *ck = CCW_DEVICE_GET_CLASS(ccw_dev); 1279 SubchDev *s = ccw_dev->sch; 1280 VirtIODevice *vdev = virtio_ccw_get_vdev(s); 1281 int len; 1282 int ret; 1283 1284 s->driver_data = dev; 1285 ret = subch_device_load(s, f); 1286 if (ret) { 1287 return ret; 1288 } 1289 /* Re-fill subch_id after loading the subchannel states.*/ 1290 if (ck->refill_ids) { 1291 ck->refill_ids(ccw_dev); 1292 } 1293 len = qemu_get_be32(f); 1294 if (len != 0) { 1295 dev->indicators = get_indicator(qemu_get_be64(f), len); 1296 } else { 1297 qemu_get_be64(f); 1298 dev->indicators = NULL; 1299 } 1300 len = qemu_get_be32(f); 1301 if (len != 0) { 1302 dev->indicators2 = get_indicator(qemu_get_be64(f), len); 1303 } else { 1304 qemu_get_be64(f); 1305 dev->indicators2 = NULL; 1306 } 1307 len = qemu_get_be32(f); 1308 if (len != 0) { 1309 dev->summary_indicator = get_indicator(qemu_get_be64(f), len); 1310 } else { 1311 qemu_get_be64(f); 1312 dev->summary_indicator = NULL; 1313 } 1314 qemu_get_be16s(f, &vdev->config_vector); 1315 dev->routes.adapter.ind_offset = qemu_get_be64(f); 1316 dev->thinint_isc = qemu_get_byte(f); 1317 dev->revision = qemu_get_be32(f); 1318 if (s->thinint_active) { 1319 dev->routes.adapter.adapter_id = css_get_adapter_id( 1320 CSS_IO_ADAPTER_VIRTIO, 1321 dev->thinint_isc); 1322 } 1323 1324 return 0; 1325 } 1326 1327 static void virtio_ccw_pre_plugged(DeviceState *d, Error **errp) 1328 { 1329 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1330 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1331 1332 if (dev->max_rev >= 1) { 1333 virtio_add_feature(&vdev->host_features, VIRTIO_F_VERSION_1); 1334 } 1335 } 1336 1337 /* This is called by virtio-bus just after the device is plugged. */ 1338 static void virtio_ccw_device_plugged(DeviceState *d, Error **errp) 1339 { 1340 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1341 VirtIODevice *vdev = virtio_bus_get_device(&dev->bus); 1342 CcwDevice *ccw_dev = CCW_DEVICE(d); 1343 SubchDev *sch = ccw_dev->sch; 1344 int n = virtio_get_num_queues(vdev); 1345 S390FLICState *flic = s390_get_flic(); 1346 1347 if (!virtio_has_feature(vdev->host_features, VIRTIO_F_VERSION_1)) { 1348 dev->max_rev = 0; 1349 } 1350 1351 if (virtio_get_num_queues(vdev) > VIRTIO_QUEUE_MAX) { 1352 error_setg(errp, "The number of virtqueues %d " 1353 "exceeds virtio limit %d", n, 1354 VIRTIO_QUEUE_MAX); 1355 return; 1356 } 1357 if (virtio_get_num_queues(vdev) > flic->adapter_routes_max_batch) { 1358 error_setg(errp, "The number of virtqueues %d " 1359 "exceeds flic adapter route limit %d", n, 1360 flic->adapter_routes_max_batch); 1361 return; 1362 } 1363 1364 sch->id.cu_model = virtio_bus_get_vdev_id(&dev->bus); 1365 1366 1367 css_generate_sch_crws(sch->cssid, sch->ssid, sch->schid, 1368 d->hotplugged, 1); 1369 } 1370 1371 static void virtio_ccw_device_unplugged(DeviceState *d) 1372 { 1373 VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d); 1374 1375 virtio_ccw_stop_ioeventfd(dev); 1376 } 1377 /**************** Virtio-ccw Bus Device Descriptions *******************/ 1378 1379 static Property virtio_ccw_net_properties[] = { 1380 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1381 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1382 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1383 VIRTIO_CCW_MAX_REV), 1384 DEFINE_PROP_END_OF_LIST(), 1385 }; 1386 1387 static void virtio_ccw_net_class_init(ObjectClass *klass, void *data) 1388 { 1389 DeviceClass *dc = DEVICE_CLASS(klass); 1390 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1391 1392 k->realize = virtio_ccw_net_realize; 1393 k->exit = virtio_ccw_exit; 1394 dc->reset = virtio_ccw_reset; 1395 dc->props = virtio_ccw_net_properties; 1396 set_bit(DEVICE_CATEGORY_NETWORK, dc->categories); 1397 } 1398 1399 static const TypeInfo virtio_ccw_net = { 1400 .name = TYPE_VIRTIO_NET_CCW, 1401 .parent = TYPE_VIRTIO_CCW_DEVICE, 1402 .instance_size = sizeof(VirtIONetCcw), 1403 .instance_init = virtio_ccw_net_instance_init, 1404 .class_init = virtio_ccw_net_class_init, 1405 }; 1406 1407 static Property virtio_ccw_blk_properties[] = { 1408 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1409 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1410 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1411 VIRTIO_CCW_MAX_REV), 1412 DEFINE_PROP_END_OF_LIST(), 1413 }; 1414 1415 static void virtio_ccw_blk_class_init(ObjectClass *klass, void *data) 1416 { 1417 DeviceClass *dc = DEVICE_CLASS(klass); 1418 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1419 1420 k->realize = virtio_ccw_blk_realize; 1421 k->exit = virtio_ccw_exit; 1422 dc->reset = virtio_ccw_reset; 1423 dc->props = virtio_ccw_blk_properties; 1424 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1425 } 1426 1427 static const TypeInfo virtio_ccw_blk = { 1428 .name = TYPE_VIRTIO_BLK_CCW, 1429 .parent = TYPE_VIRTIO_CCW_DEVICE, 1430 .instance_size = sizeof(VirtIOBlkCcw), 1431 .instance_init = virtio_ccw_blk_instance_init, 1432 .class_init = virtio_ccw_blk_class_init, 1433 }; 1434 1435 static Property virtio_ccw_serial_properties[] = { 1436 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1437 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1438 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1439 VIRTIO_CCW_MAX_REV), 1440 DEFINE_PROP_END_OF_LIST(), 1441 }; 1442 1443 static void virtio_ccw_serial_class_init(ObjectClass *klass, void *data) 1444 { 1445 DeviceClass *dc = DEVICE_CLASS(klass); 1446 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1447 1448 k->realize = virtio_ccw_serial_realize; 1449 k->exit = virtio_ccw_exit; 1450 dc->reset = virtio_ccw_reset; 1451 dc->props = virtio_ccw_serial_properties; 1452 set_bit(DEVICE_CATEGORY_INPUT, dc->categories); 1453 } 1454 1455 static const TypeInfo virtio_ccw_serial = { 1456 .name = TYPE_VIRTIO_SERIAL_CCW, 1457 .parent = TYPE_VIRTIO_CCW_DEVICE, 1458 .instance_size = sizeof(VirtioSerialCcw), 1459 .instance_init = virtio_ccw_serial_instance_init, 1460 .class_init = virtio_ccw_serial_class_init, 1461 }; 1462 1463 static Property virtio_ccw_balloon_properties[] = { 1464 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1465 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1466 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1467 VIRTIO_CCW_MAX_REV), 1468 DEFINE_PROP_END_OF_LIST(), 1469 }; 1470 1471 static void virtio_ccw_balloon_class_init(ObjectClass *klass, void *data) 1472 { 1473 DeviceClass *dc = DEVICE_CLASS(klass); 1474 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1475 1476 k->realize = virtio_ccw_balloon_realize; 1477 k->exit = virtio_ccw_exit; 1478 dc->reset = virtio_ccw_reset; 1479 dc->props = virtio_ccw_balloon_properties; 1480 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1481 } 1482 1483 static const TypeInfo virtio_ccw_balloon = { 1484 .name = TYPE_VIRTIO_BALLOON_CCW, 1485 .parent = TYPE_VIRTIO_CCW_DEVICE, 1486 .instance_size = sizeof(VirtIOBalloonCcw), 1487 .instance_init = virtio_ccw_balloon_instance_init, 1488 .class_init = virtio_ccw_balloon_class_init, 1489 }; 1490 1491 static Property virtio_ccw_scsi_properties[] = { 1492 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1493 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1494 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1495 VIRTIO_CCW_MAX_REV), 1496 DEFINE_PROP_END_OF_LIST(), 1497 }; 1498 1499 static void virtio_ccw_scsi_class_init(ObjectClass *klass, void *data) 1500 { 1501 DeviceClass *dc = DEVICE_CLASS(klass); 1502 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1503 1504 k->realize = virtio_ccw_scsi_realize; 1505 k->exit = virtio_ccw_exit; 1506 dc->reset = virtio_ccw_reset; 1507 dc->props = virtio_ccw_scsi_properties; 1508 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1509 } 1510 1511 static const TypeInfo virtio_ccw_scsi = { 1512 .name = TYPE_VIRTIO_SCSI_CCW, 1513 .parent = TYPE_VIRTIO_CCW_DEVICE, 1514 .instance_size = sizeof(VirtIOSCSICcw), 1515 .instance_init = virtio_ccw_scsi_instance_init, 1516 .class_init = virtio_ccw_scsi_class_init, 1517 }; 1518 1519 #ifdef CONFIG_VHOST_SCSI 1520 static Property vhost_ccw_scsi_properties[] = { 1521 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1522 VIRTIO_CCW_MAX_REV), 1523 DEFINE_PROP_END_OF_LIST(), 1524 }; 1525 1526 static void vhost_ccw_scsi_class_init(ObjectClass *klass, void *data) 1527 { 1528 DeviceClass *dc = DEVICE_CLASS(klass); 1529 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1530 1531 k->realize = vhost_ccw_scsi_realize; 1532 k->exit = virtio_ccw_exit; 1533 dc->reset = virtio_ccw_reset; 1534 dc->props = vhost_ccw_scsi_properties; 1535 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1536 } 1537 1538 static const TypeInfo vhost_ccw_scsi = { 1539 .name = TYPE_VHOST_SCSI_CCW, 1540 .parent = TYPE_VIRTIO_CCW_DEVICE, 1541 .instance_size = sizeof(VHostSCSICcw), 1542 .instance_init = vhost_ccw_scsi_instance_init, 1543 .class_init = vhost_ccw_scsi_class_init, 1544 }; 1545 #endif 1546 1547 static void virtio_ccw_rng_instance_init(Object *obj) 1548 { 1549 VirtIORNGCcw *dev = VIRTIO_RNG_CCW(obj); 1550 1551 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1552 TYPE_VIRTIO_RNG); 1553 object_property_add_alias(obj, "rng", OBJECT(&dev->vdev), 1554 "rng", &error_abort); 1555 } 1556 1557 static Property virtio_ccw_rng_properties[] = { 1558 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1559 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1560 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1561 VIRTIO_CCW_MAX_REV), 1562 DEFINE_PROP_END_OF_LIST(), 1563 }; 1564 1565 static void virtio_ccw_rng_class_init(ObjectClass *klass, void *data) 1566 { 1567 DeviceClass *dc = DEVICE_CLASS(klass); 1568 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1569 1570 k->realize = virtio_ccw_rng_realize; 1571 k->exit = virtio_ccw_exit; 1572 dc->reset = virtio_ccw_reset; 1573 dc->props = virtio_ccw_rng_properties; 1574 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1575 } 1576 1577 static const TypeInfo virtio_ccw_rng = { 1578 .name = TYPE_VIRTIO_RNG_CCW, 1579 .parent = TYPE_VIRTIO_CCW_DEVICE, 1580 .instance_size = sizeof(VirtIORNGCcw), 1581 .instance_init = virtio_ccw_rng_instance_init, 1582 .class_init = virtio_ccw_rng_class_init, 1583 }; 1584 1585 static Property virtio_ccw_crypto_properties[] = { 1586 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1587 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1588 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1589 VIRTIO_CCW_MAX_REV), 1590 DEFINE_PROP_END_OF_LIST(), 1591 }; 1592 1593 static void virtio_ccw_crypto_instance_init(Object *obj) 1594 { 1595 VirtIOCryptoCcw *dev = VIRTIO_CRYPTO_CCW(obj); 1596 VirtioCcwDevice *ccw_dev = VIRTIO_CCW_DEVICE(obj); 1597 1598 ccw_dev->force_revision_1 = true; 1599 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1600 TYPE_VIRTIO_CRYPTO); 1601 1602 object_property_add_alias(obj, "cryptodev", OBJECT(&dev->vdev), 1603 "cryptodev", &error_abort); 1604 } 1605 1606 static void virtio_ccw_crypto_class_init(ObjectClass *klass, void *data) 1607 { 1608 DeviceClass *dc = DEVICE_CLASS(klass); 1609 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1610 1611 k->realize = virtio_ccw_crypto_realize; 1612 k->exit = virtio_ccw_exit; 1613 dc->reset = virtio_ccw_reset; 1614 dc->props = virtio_ccw_crypto_properties; 1615 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1616 } 1617 1618 static const TypeInfo virtio_ccw_crypto = { 1619 .name = TYPE_VIRTIO_CRYPTO_CCW, 1620 .parent = TYPE_VIRTIO_CCW_DEVICE, 1621 .instance_size = sizeof(VirtIOCryptoCcw), 1622 .instance_init = virtio_ccw_crypto_instance_init, 1623 .class_init = virtio_ccw_crypto_class_init, 1624 }; 1625 1626 static void virtio_ccw_busdev_realize(DeviceState *dev, Error **errp) 1627 { 1628 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1629 1630 virtio_ccw_bus_new(&_dev->bus, sizeof(_dev->bus), _dev); 1631 virtio_ccw_device_realize(_dev, errp); 1632 } 1633 1634 static int virtio_ccw_busdev_exit(DeviceState *dev) 1635 { 1636 VirtioCcwDevice *_dev = (VirtioCcwDevice *)dev; 1637 VirtIOCCWDeviceClass *_info = VIRTIO_CCW_DEVICE_GET_CLASS(dev); 1638 1639 return _info->exit(_dev); 1640 } 1641 1642 static void virtio_ccw_busdev_unplug(HotplugHandler *hotplug_dev, 1643 DeviceState *dev, Error **errp) 1644 { 1645 VirtioCcwDevice *_dev = to_virtio_ccw_dev_fast(dev); 1646 1647 virtio_ccw_stop_ioeventfd(_dev); 1648 } 1649 1650 static void virtio_ccw_device_class_init(ObjectClass *klass, void *data) 1651 { 1652 DeviceClass *dc = DEVICE_CLASS(klass); 1653 CCWDeviceClass *k = CCW_DEVICE_CLASS(dc); 1654 1655 k->unplug = virtio_ccw_busdev_unplug; 1656 dc->realize = virtio_ccw_busdev_realize; 1657 dc->exit = virtio_ccw_busdev_exit; 1658 dc->bus_type = TYPE_VIRTUAL_CSS_BUS; 1659 } 1660 1661 static const TypeInfo virtio_ccw_device_info = { 1662 .name = TYPE_VIRTIO_CCW_DEVICE, 1663 .parent = TYPE_CCW_DEVICE, 1664 .instance_size = sizeof(VirtioCcwDevice), 1665 .class_init = virtio_ccw_device_class_init, 1666 .class_size = sizeof(VirtIOCCWDeviceClass), 1667 .abstract = true, 1668 }; 1669 1670 /* virtio-ccw-bus */ 1671 1672 static void virtio_ccw_bus_new(VirtioBusState *bus, size_t bus_size, 1673 VirtioCcwDevice *dev) 1674 { 1675 DeviceState *qdev = DEVICE(dev); 1676 char virtio_bus_name[] = "virtio-bus"; 1677 1678 qbus_create_inplace(bus, bus_size, TYPE_VIRTIO_CCW_BUS, 1679 qdev, virtio_bus_name); 1680 } 1681 1682 static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data) 1683 { 1684 VirtioBusClass *k = VIRTIO_BUS_CLASS(klass); 1685 BusClass *bus_class = BUS_CLASS(klass); 1686 1687 bus_class->max_dev = 1; 1688 k->notify = virtio_ccw_notify; 1689 k->vmstate_change = virtio_ccw_vmstate_change; 1690 k->query_guest_notifiers = virtio_ccw_query_guest_notifiers; 1691 k->set_guest_notifiers = virtio_ccw_set_guest_notifiers; 1692 k->save_queue = virtio_ccw_save_queue; 1693 k->load_queue = virtio_ccw_load_queue; 1694 k->save_config = virtio_ccw_save_config; 1695 k->load_config = virtio_ccw_load_config; 1696 k->pre_plugged = virtio_ccw_pre_plugged; 1697 k->device_plugged = virtio_ccw_device_plugged; 1698 k->device_unplugged = virtio_ccw_device_unplugged; 1699 k->ioeventfd_enabled = virtio_ccw_ioeventfd_enabled; 1700 k->ioeventfd_assign = virtio_ccw_ioeventfd_assign; 1701 } 1702 1703 static const TypeInfo virtio_ccw_bus_info = { 1704 .name = TYPE_VIRTIO_CCW_BUS, 1705 .parent = TYPE_VIRTIO_BUS, 1706 .instance_size = sizeof(VirtioCcwBusState), 1707 .class_init = virtio_ccw_bus_class_init, 1708 }; 1709 1710 #ifdef CONFIG_VIRTFS 1711 static Property virtio_ccw_9p_properties[] = { 1712 DEFINE_PROP_BIT("ioeventfd", VirtioCcwDevice, flags, 1713 VIRTIO_CCW_FLAG_USE_IOEVENTFD_BIT, true), 1714 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1715 VIRTIO_CCW_MAX_REV), 1716 DEFINE_PROP_END_OF_LIST(), 1717 }; 1718 1719 static void virtio_ccw_9p_realize(VirtioCcwDevice *ccw_dev, Error **errp) 1720 { 1721 V9fsCCWState *dev = VIRTIO_9P_CCW(ccw_dev); 1722 DeviceState *vdev = DEVICE(&dev->vdev); 1723 1724 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 1725 object_property_set_bool(OBJECT(vdev), true, "realized", errp); 1726 } 1727 1728 static void virtio_ccw_9p_class_init(ObjectClass *klass, void *data) 1729 { 1730 DeviceClass *dc = DEVICE_CLASS(klass); 1731 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1732 1733 k->exit = virtio_ccw_exit; 1734 k->realize = virtio_ccw_9p_realize; 1735 dc->reset = virtio_ccw_reset; 1736 dc->props = virtio_ccw_9p_properties; 1737 set_bit(DEVICE_CATEGORY_STORAGE, dc->categories); 1738 } 1739 1740 static void virtio_ccw_9p_instance_init(Object *obj) 1741 { 1742 V9fsCCWState *dev = VIRTIO_9P_CCW(obj); 1743 1744 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1745 TYPE_VIRTIO_9P); 1746 } 1747 1748 static const TypeInfo virtio_ccw_9p_info = { 1749 .name = TYPE_VIRTIO_9P_CCW, 1750 .parent = TYPE_VIRTIO_CCW_DEVICE, 1751 .instance_size = sizeof(V9fsCCWState), 1752 .instance_init = virtio_ccw_9p_instance_init, 1753 .class_init = virtio_ccw_9p_class_init, 1754 }; 1755 #endif 1756 1757 #ifdef CONFIG_VHOST_VSOCK 1758 1759 static Property vhost_vsock_ccw_properties[] = { 1760 DEFINE_PROP_UINT32("max_revision", VirtioCcwDevice, max_rev, 1761 VIRTIO_CCW_MAX_REV), 1762 DEFINE_PROP_END_OF_LIST(), 1763 }; 1764 1765 static void vhost_vsock_ccw_realize(VirtioCcwDevice *ccw_dev, Error **errp) 1766 { 1767 VHostVSockCCWState *dev = VHOST_VSOCK_CCW(ccw_dev); 1768 DeviceState *vdev = DEVICE(&dev->vdev); 1769 Error *err = NULL; 1770 1771 qdev_set_parent_bus(vdev, BUS(&ccw_dev->bus)); 1772 object_property_set_bool(OBJECT(vdev), true, "realized", &err); 1773 error_propagate(errp, err); 1774 } 1775 1776 static void vhost_vsock_ccw_class_init(ObjectClass *klass, void *data) 1777 { 1778 DeviceClass *dc = DEVICE_CLASS(klass); 1779 VirtIOCCWDeviceClass *k = VIRTIO_CCW_DEVICE_CLASS(klass); 1780 1781 k->realize = vhost_vsock_ccw_realize; 1782 k->exit = virtio_ccw_exit; 1783 set_bit(DEVICE_CATEGORY_MISC, dc->categories); 1784 dc->props = vhost_vsock_ccw_properties; 1785 dc->reset = virtio_ccw_reset; 1786 } 1787 1788 static void vhost_vsock_ccw_instance_init(Object *obj) 1789 { 1790 VHostVSockCCWState *dev = VHOST_VSOCK_CCW(obj); 1791 1792 virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), 1793 TYPE_VHOST_VSOCK); 1794 } 1795 1796 static const TypeInfo vhost_vsock_ccw_info = { 1797 .name = TYPE_VHOST_VSOCK_CCW, 1798 .parent = TYPE_VIRTIO_CCW_DEVICE, 1799 .instance_size = sizeof(VHostVSockCCWState), 1800 .instance_init = vhost_vsock_ccw_instance_init, 1801 .class_init = vhost_vsock_ccw_class_init, 1802 }; 1803 #endif 1804 1805 static void virtio_ccw_register(void) 1806 { 1807 type_register_static(&virtio_ccw_bus_info); 1808 type_register_static(&virtio_ccw_device_info); 1809 type_register_static(&virtio_ccw_serial); 1810 type_register_static(&virtio_ccw_blk); 1811 type_register_static(&virtio_ccw_net); 1812 type_register_static(&virtio_ccw_balloon); 1813 type_register_static(&virtio_ccw_scsi); 1814 #ifdef CONFIG_VHOST_SCSI 1815 type_register_static(&vhost_ccw_scsi); 1816 #endif 1817 type_register_static(&virtio_ccw_rng); 1818 #ifdef CONFIG_VIRTFS 1819 type_register_static(&virtio_ccw_9p_info); 1820 #endif 1821 #ifdef CONFIG_VHOST_VSOCK 1822 type_register_static(&vhost_vsock_ccw_info); 1823 #endif 1824 type_register_static(&virtio_ccw_crypto); 1825 } 1826 1827 type_init(virtio_ccw_register) 1828