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