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