2 * Inter-VM Shared Memory PCI device.
5 * Cam Macdonell <cam@cs.ualberta.ca>
7 * Based On: cirrus_vga.c
8 * Copyright (c) 2004 Fabrice Bellard
9 * Copyright (c) 2004 Makoto Suzuki (suzu)
12 * Copyright (c) 2006 Igor Kovalenko
14 * This code is licensed under the GNU GPL v2.
16 * Contributions after 2012-01-13 are licensed under the terms of the
17 * GNU GPL, version 2 or (at your option) any later version.
19 #include "qemu/osdep.h"
21 #include "hw/i386/pc.h"
22 #include "hw/pci/pci.h"
23 #include "hw/pci/msi.h"
24 #include "hw/pci/msix.h"
25 #include "sysemu/kvm.h"
26 #include "migration/migration.h"
27 #include "qemu/error-report.h"
28 #include "qemu/event_notifier.h"
29 #include "qemu/fifo8.h"
30 #include "sysemu/char.h"
31 #include "sysemu/hostmem.h"
32 #include "qapi/visitor.h"
33 #include "exec/ram_addr.h"
35 #include "hw/misc/ivshmem.h"
39 #define PCI_VENDOR_ID_IVSHMEM PCI_VENDOR_ID_REDHAT_QUMRANET
40 #define PCI_DEVICE_ID_IVSHMEM 0x1110
42 #define IVSHMEM_MAX_PEERS G_MAXUINT16
43 #define IVSHMEM_IOEVENTFD 0
46 #define IVSHMEM_PEER 0
47 #define IVSHMEM_MASTER 1
49 #define IVSHMEM_REG_BAR_SIZE 0x100
51 #define IVSHMEM_DEBUG 0
52 #define IVSHMEM_DPRINTF(fmt, ...) \
54 if (IVSHMEM_DEBUG) { \
55 printf("IVSHMEM: " fmt, ## __VA_ARGS__); \
59 #define TYPE_IVSHMEM "ivshmem"
60 #define IVSHMEM(obj) \
61 OBJECT_CHECK(IVShmemState, (obj), TYPE_IVSHMEM)
65 EventNotifier
*eventfds
;
68 typedef struct MSIVector
{
73 typedef struct IVShmemState
{
78 HostMemoryBackend
*hostmem
;
82 CharDriverState
*server_chr
;
84 MemoryRegion ivshmem_mmio
;
86 /* We might need to register the BAR before we actually have the memory.
87 * So prepare a container MemoryRegion for the BAR immediately and
88 * add a subregion when we have the memory.
92 uint64_t ivshmem_size
; /* size of shared memory region */
93 uint32_t ivshmem_64bit
;
96 int nb_peers
; /* how many peers we have space for */
101 MSIVector
*msi_vectors
;
103 Error
*migration_blocker
;
108 int role_val
; /* scalar to avoid multiple string comparisons */
111 /* registers for the Inter-VM shared memory device */
112 enum ivshmem_registers
{
119 static inline uint32_t ivshmem_has_feature(IVShmemState
*ivs
,
120 unsigned int feature
) {
121 return (ivs
->features
& (1 << feature
));
124 /* accessing registers - based on rtl8139 */
125 static void ivshmem_update_irq(IVShmemState
*s
)
127 PCIDevice
*d
= PCI_DEVICE(s
);
129 isr
= (s
->intrstatus
& s
->intrmask
) & 0xffffffff;
131 /* don't print ISR resets */
133 IVSHMEM_DPRINTF("Set IRQ to %d (%04x %04x)\n",
134 isr
? 1 : 0, s
->intrstatus
, s
->intrmask
);
137 pci_set_irq(d
, (isr
!= 0));
140 static void ivshmem_IntrMask_write(IVShmemState
*s
, uint32_t val
)
142 IVSHMEM_DPRINTF("IntrMask write(w) val = 0x%04x\n", val
);
146 ivshmem_update_irq(s
);
149 static uint32_t ivshmem_IntrMask_read(IVShmemState
*s
)
151 uint32_t ret
= s
->intrmask
;
153 IVSHMEM_DPRINTF("intrmask read(w) val = 0x%04x\n", ret
);
158 static void ivshmem_IntrStatus_write(IVShmemState
*s
, uint32_t val
)
160 IVSHMEM_DPRINTF("IntrStatus write(w) val = 0x%04x\n", val
);
164 ivshmem_update_irq(s
);
167 static uint32_t ivshmem_IntrStatus_read(IVShmemState
*s
)
169 uint32_t ret
= s
->intrstatus
;
171 /* reading ISR clears all interrupts */
174 ivshmem_update_irq(s
);
179 static void ivshmem_io_write(void *opaque
, hwaddr addr
,
180 uint64_t val
, unsigned size
)
182 IVShmemState
*s
= opaque
;
184 uint16_t dest
= val
>> 16;
185 uint16_t vector
= val
& 0xff;
189 IVSHMEM_DPRINTF("writing to addr " TARGET_FMT_plx
"\n", addr
);
193 ivshmem_IntrMask_write(s
, val
);
197 ivshmem_IntrStatus_write(s
, val
);
201 /* check that dest VM ID is reasonable */
202 if (dest
>= s
->nb_peers
) {
203 IVSHMEM_DPRINTF("Invalid destination VM ID (%d)\n", dest
);
207 /* check doorbell range */
208 if (vector
< s
->peers
[dest
].nb_eventfds
) {
209 IVSHMEM_DPRINTF("Notifying VM %d on vector %d\n", dest
, vector
);
210 event_notifier_set(&s
->peers
[dest
].eventfds
[vector
]);
212 IVSHMEM_DPRINTF("Invalid destination vector %d on VM %d\n",
217 IVSHMEM_DPRINTF("Unhandled write " TARGET_FMT_plx
"\n", addr
);
221 static uint64_t ivshmem_io_read(void *opaque
, hwaddr addr
,
225 IVShmemState
*s
= opaque
;
231 ret
= ivshmem_IntrMask_read(s
);
235 ret
= ivshmem_IntrStatus_read(s
);
239 /* return my VM ID if the memory is mapped */
240 if (memory_region_is_mapped(&s
->ivshmem
)) {
248 IVSHMEM_DPRINTF("why are we reading " TARGET_FMT_plx
"\n", addr
);
255 static const MemoryRegionOps ivshmem_mmio_ops
= {
256 .read
= ivshmem_io_read
,
257 .write
= ivshmem_io_write
,
258 .endianness
= DEVICE_NATIVE_ENDIAN
,
260 .min_access_size
= 4,
261 .max_access_size
= 4,
265 static int ivshmem_can_receive(void * opaque
)
267 return sizeof(int64_t);
270 static void ivshmem_vector_notify(void *opaque
)
272 MSIVector
*entry
= opaque
;
273 PCIDevice
*pdev
= entry
->pdev
;
274 IVShmemState
*s
= IVSHMEM(pdev
);
275 int vector
= entry
- s
->msi_vectors
;
276 EventNotifier
*n
= &s
->peers
[s
->vm_id
].eventfds
[vector
];
278 if (!event_notifier_test_and_clear(n
)) {
282 IVSHMEM_DPRINTF("interrupt on vector %p %d\n", pdev
, vector
);
283 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
284 msix_notify(pdev
, vector
);
286 ivshmem_IntrStatus_write(s
, 1);
290 static int ivshmem_vector_unmask(PCIDevice
*dev
, unsigned vector
,
293 IVShmemState
*s
= IVSHMEM(dev
);
294 EventNotifier
*n
= &s
->peers
[s
->vm_id
].eventfds
[vector
];
295 MSIVector
*v
= &s
->msi_vectors
[vector
];
298 IVSHMEM_DPRINTF("vector unmask %p %d\n", dev
, vector
);
300 ret
= kvm_irqchip_update_msi_route(kvm_state
, v
->virq
, msg
, dev
);
305 return kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, n
, NULL
, v
->virq
);
308 static void ivshmem_vector_mask(PCIDevice
*dev
, unsigned vector
)
310 IVShmemState
*s
= IVSHMEM(dev
);
311 EventNotifier
*n
= &s
->peers
[s
->vm_id
].eventfds
[vector
];
314 IVSHMEM_DPRINTF("vector mask %p %d\n", dev
, vector
);
316 ret
= kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, n
,
317 s
->msi_vectors
[vector
].virq
);
319 error_report("remove_irqfd_notifier_gsi failed");
323 static void ivshmem_vector_poll(PCIDevice
*dev
,
324 unsigned int vector_start
,
325 unsigned int vector_end
)
327 IVShmemState
*s
= IVSHMEM(dev
);
330 IVSHMEM_DPRINTF("vector poll %p %d-%d\n", dev
, vector_start
, vector_end
);
332 vector_end
= MIN(vector_end
, s
->vectors
);
334 for (vector
= vector_start
; vector
< vector_end
; vector
++) {
335 EventNotifier
*notifier
= &s
->peers
[s
->vm_id
].eventfds
[vector
];
337 if (!msix_is_masked(dev
, vector
)) {
341 if (event_notifier_test_and_clear(notifier
)) {
342 msix_set_pending(dev
, vector
);
347 static void watch_vector_notifier(IVShmemState
*s
, EventNotifier
*n
,
350 int eventfd
= event_notifier_get_fd(n
);
352 /* if MSI is supported we need multiple interrupts */
353 s
->msi_vectors
[vector
].pdev
= PCI_DEVICE(s
);
355 qemu_set_fd_handler(eventfd
, ivshmem_vector_notify
,
356 NULL
, &s
->msi_vectors
[vector
]);
359 static int check_shm_size(IVShmemState
*s
, int fd
, Error
**errp
)
361 /* check that the guest isn't going to try and map more memory than the
362 * the object has allocated return -1 to indicate error */
366 if (fstat(fd
, &buf
) < 0) {
367 error_setg(errp
, "exiting: fstat on fd %d failed: %s",
368 fd
, strerror(errno
));
372 if (s
->ivshmem_size
> buf
.st_size
) {
373 error_setg(errp
, "Requested memory size greater"
374 " than shared object size (%" PRIu64
" > %" PRIu64
")",
375 s
->ivshmem_size
, (uint64_t)buf
.st_size
);
382 /* create the shared memory BAR when we are not using the server, so we can
383 * create the BAR and map the memory immediately */
384 static int create_shared_memory_BAR(IVShmemState
*s
, int fd
, uint8_t attr
,
389 ptr
= mmap(0, s
->ivshmem_size
, PROT_READ
|PROT_WRITE
, MAP_SHARED
, fd
, 0);
390 if (ptr
== MAP_FAILED
) {
391 error_setg_errno(errp
, errno
, "Failed to mmap shared memory");
395 memory_region_init_ram_ptr(&s
->ivshmem
, OBJECT(s
), "ivshmem.bar2",
396 s
->ivshmem_size
, ptr
);
397 qemu_set_ram_fd(memory_region_get_ram_addr(&s
->ivshmem
), fd
);
398 vmstate_register_ram(&s
->ivshmem
, DEVICE(s
));
399 memory_region_add_subregion(&s
->bar
, 0, &s
->ivshmem
);
401 /* region for shared memory */
402 pci_register_bar(PCI_DEVICE(s
), 2, attr
, &s
->bar
);
407 static void ivshmem_add_eventfd(IVShmemState
*s
, int posn
, int i
)
409 memory_region_add_eventfd(&s
->ivshmem_mmio
,
414 &s
->peers
[posn
].eventfds
[i
]);
417 static void ivshmem_del_eventfd(IVShmemState
*s
, int posn
, int i
)
419 memory_region_del_eventfd(&s
->ivshmem_mmio
,
424 &s
->peers
[posn
].eventfds
[i
]);
427 static void close_peer_eventfds(IVShmemState
*s
, int posn
)
431 if (!ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
)) {
434 if (posn
< 0 || posn
>= s
->nb_peers
) {
435 error_report("invalid peer %d", posn
);
439 n
= s
->peers
[posn
].nb_eventfds
;
441 memory_region_transaction_begin();
442 for (i
= 0; i
< n
; i
++) {
443 ivshmem_del_eventfd(s
, posn
, i
);
445 memory_region_transaction_commit();
446 for (i
= 0; i
< n
; i
++) {
447 event_notifier_cleanup(&s
->peers
[posn
].eventfds
[i
]);
450 g_free(s
->peers
[posn
].eventfds
);
451 s
->peers
[posn
].nb_eventfds
= 0;
454 /* this function increase the dynamic storage need to store data about other
456 static int resize_peers(IVShmemState
*s
, int new_min_size
)
461 /* limit number of max peers */
462 if (new_min_size
<= 0 || new_min_size
> IVSHMEM_MAX_PEERS
) {
465 if (new_min_size
<= s
->nb_peers
) {
469 old_size
= s
->nb_peers
;
470 s
->nb_peers
= new_min_size
;
472 IVSHMEM_DPRINTF("bumping storage to %d peers\n", s
->nb_peers
);
474 s
->peers
= g_realloc(s
->peers
, s
->nb_peers
* sizeof(Peer
));
476 for (j
= old_size
; j
< s
->nb_peers
; j
++) {
477 s
->peers
[j
].eventfds
= g_new0(EventNotifier
, s
->vectors
);
478 s
->peers
[j
].nb_eventfds
= 0;
484 static bool fifo_update_and_get(IVShmemState
*s
, const uint8_t *buf
, int size
,
485 void *data
, size_t len
)
490 assert(len
<= sizeof(int64_t)); /* limitation of the fifo */
491 if (fifo8_is_empty(&s
->incoming_fifo
) && size
== len
) {
492 memcpy(data
, buf
, size
);
496 IVSHMEM_DPRINTF("short read of %d bytes\n", size
);
498 num
= MIN(size
, sizeof(int64_t) - fifo8_num_used(&s
->incoming_fifo
));
499 fifo8_push_all(&s
->incoming_fifo
, buf
, num
);
501 if (fifo8_num_used(&s
->incoming_fifo
) < len
) {
508 p
= fifo8_pop_buf(&s
->incoming_fifo
, len
, &num
);
511 memcpy(data
, p
, len
);
514 fifo8_push_all(&s
->incoming_fifo
, buf
, size
);
520 static bool fifo_update_and_get_i64(IVShmemState
*s
,
521 const uint8_t *buf
, int size
, int64_t *i64
)
523 if (fifo_update_and_get(s
, buf
, size
, i64
, sizeof(*i64
))) {
524 *i64
= GINT64_FROM_LE(*i64
);
531 static int ivshmem_add_kvm_msi_virq(IVShmemState
*s
, int vector
)
533 PCIDevice
*pdev
= PCI_DEVICE(s
);
534 MSIMessage msg
= msix_get_message(pdev
, vector
);
537 IVSHMEM_DPRINTF("ivshmem_add_kvm_msi_virq vector:%d\n", vector
);
539 if (s
->msi_vectors
[vector
].pdev
!= NULL
) {
543 ret
= kvm_irqchip_add_msi_route(kvm_state
, msg
, pdev
);
545 error_report("ivshmem: kvm_irqchip_add_msi_route failed");
549 s
->msi_vectors
[vector
].virq
= ret
;
550 s
->msi_vectors
[vector
].pdev
= pdev
;
555 static void setup_interrupt(IVShmemState
*s
, int vector
)
557 EventNotifier
*n
= &s
->peers
[s
->vm_id
].eventfds
[vector
];
558 bool with_irqfd
= kvm_msi_via_irqfd_enabled() &&
559 ivshmem_has_feature(s
, IVSHMEM_MSI
);
560 PCIDevice
*pdev
= PCI_DEVICE(s
);
562 IVSHMEM_DPRINTF("setting up interrupt for vector: %d\n", vector
);
565 IVSHMEM_DPRINTF("with eventfd\n");
566 watch_vector_notifier(s
, n
, vector
);
567 } else if (msix_enabled(pdev
)) {
568 IVSHMEM_DPRINTF("with irqfd\n");
569 if (ivshmem_add_kvm_msi_virq(s
, vector
) < 0) {
573 if (!msix_is_masked(pdev
, vector
)) {
574 kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, n
, NULL
,
575 s
->msi_vectors
[vector
].virq
);
578 /* it will be delayed until msix is enabled, in write_config */
579 IVSHMEM_DPRINTF("with irqfd, delayed until msix enabled\n");
583 static void ivshmem_read(void *opaque
, const uint8_t *buf
, int size
)
585 IVShmemState
*s
= opaque
;
588 int64_t incoming_posn
;
592 if (!fifo_update_and_get_i64(s
, buf
, size
, &incoming_posn
)) {
596 if (incoming_posn
< -1) {
597 IVSHMEM_DPRINTF("invalid incoming_posn %" PRId64
"\n", incoming_posn
);
601 /* pick off s->server_chr->msgfd and store it, posn should accompany msg */
602 incoming_fd
= qemu_chr_fe_get_msgfd(s
->server_chr
);
603 IVSHMEM_DPRINTF("posn is %" PRId64
", fd is %d\n",
604 incoming_posn
, incoming_fd
);
606 /* make sure we have enough space for this peer */
607 if (incoming_posn
>= s
->nb_peers
) {
608 if (resize_peers(s
, incoming_posn
+ 1) < 0) {
609 error_report("failed to resize peers array");
610 if (incoming_fd
!= -1) {
617 peer
= &s
->peers
[incoming_posn
];
619 if (incoming_fd
== -1) {
620 /* if posn is positive and unseen before then this is our posn*/
621 if (incoming_posn
>= 0 && s
->vm_id
== -1) {
622 /* receive our posn */
623 s
->vm_id
= incoming_posn
;
625 /* otherwise an fd == -1 means an existing peer has gone away */
626 IVSHMEM_DPRINTF("posn %" PRId64
" has gone away\n", incoming_posn
);
627 close_peer_eventfds(s
, incoming_posn
);
632 /* if the position is -1, then it's shared memory region fd */
633 if (incoming_posn
== -1) {
636 if (memory_region_is_mapped(&s
->ivshmem
)) {
637 error_report("shm already initialized");
642 if (check_shm_size(s
, incoming_fd
, &err
) == -1) {
643 error_report_err(err
);
648 /* mmap the region and map into the BAR2 */
649 map_ptr
= mmap(0, s
->ivshmem_size
, PROT_READ
|PROT_WRITE
, MAP_SHARED
,
651 if (map_ptr
== MAP_FAILED
) {
652 error_report("Failed to mmap shared memory %s", strerror(errno
));
656 memory_region_init_ram_ptr(&s
->ivshmem
, OBJECT(s
),
657 "ivshmem.bar2", s
->ivshmem_size
, map_ptr
);
658 qemu_set_ram_fd(memory_region_get_ram_addr(&s
->ivshmem
),
660 vmstate_register_ram(&s
->ivshmem
, DEVICE(s
));
662 IVSHMEM_DPRINTF("guest h/w addr = %p, size = %" PRIu64
"\n",
663 map_ptr
, s
->ivshmem_size
);
665 memory_region_add_subregion(&s
->bar
, 0, &s
->ivshmem
);
670 /* each peer has an associated array of eventfds, and we keep
671 * track of how many eventfds received so far */
672 /* get a new eventfd: */
673 if (peer
->nb_eventfds
>= s
->vectors
) {
674 error_report("Too many eventfd received, device has %d vectors",
680 new_eventfd
= peer
->nb_eventfds
++;
682 /* this is an eventfd for a particular peer VM */
683 IVSHMEM_DPRINTF("eventfds[%" PRId64
"][%d] = %d\n", incoming_posn
,
684 new_eventfd
, incoming_fd
);
685 event_notifier_init_fd(&peer
->eventfds
[new_eventfd
], incoming_fd
);
686 fcntl_setfl(incoming_fd
, O_NONBLOCK
); /* msix/irqfd poll non block */
688 if (incoming_posn
== s
->vm_id
) {
689 setup_interrupt(s
, new_eventfd
);
692 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
)) {
693 ivshmem_add_eventfd(s
, incoming_posn
, new_eventfd
);
697 static void ivshmem_check_version(void *opaque
, const uint8_t * buf
, int size
)
699 IVShmemState
*s
= opaque
;
703 if (!fifo_update_and_get_i64(s
, buf
, size
, &version
)) {
707 tmp
= qemu_chr_fe_get_msgfd(s
->server_chr
);
708 if (tmp
!= -1 || version
!= IVSHMEM_PROTOCOL_VERSION
) {
709 fprintf(stderr
, "incompatible version, you are connecting to a ivshmem-"
710 "server using a different protocol please check your setup\n");
711 qemu_chr_add_handlers(s
->server_chr
, NULL
, NULL
, NULL
, s
);
715 IVSHMEM_DPRINTF("version check ok, switch to real chardev handler\n");
716 qemu_chr_add_handlers(s
->server_chr
, ivshmem_can_receive
, ivshmem_read
,
720 /* Select the MSI-X vectors used by device.
721 * ivshmem maps events to vectors statically, so
722 * we just enable all vectors on init and after reset. */
723 static void ivshmem_use_msix(IVShmemState
* s
)
725 PCIDevice
*d
= PCI_DEVICE(s
);
728 IVSHMEM_DPRINTF("%s, msix present: %d\n", __func__
, msix_present(d
));
729 if (!msix_present(d
)) {
733 for (i
= 0; i
< s
->vectors
; i
++) {
734 msix_vector_use(d
, i
);
738 static void ivshmem_reset(DeviceState
*d
)
740 IVShmemState
*s
= IVSHMEM(d
);
747 static int ivshmem_setup_interrupts(IVShmemState
*s
)
749 /* allocate QEMU callback data for receiving interrupts */
750 s
->msi_vectors
= g_malloc0(s
->vectors
* sizeof(MSIVector
));
752 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
753 if (msix_init_exclusive_bar(PCI_DEVICE(s
), s
->vectors
, 1)) {
757 IVSHMEM_DPRINTF("msix initialized (%d vectors)\n", s
->vectors
);
764 static void ivshmem_enable_irqfd(IVShmemState
*s
)
766 PCIDevice
*pdev
= PCI_DEVICE(s
);
769 for (i
= 0; i
< s
->peers
[s
->vm_id
].nb_eventfds
; i
++) {
770 ivshmem_add_kvm_msi_virq(s
, i
);
773 if (msix_set_vector_notifiers(pdev
,
774 ivshmem_vector_unmask
,
776 ivshmem_vector_poll
)) {
777 error_report("ivshmem: msix_set_vector_notifiers failed");
781 static void ivshmem_remove_kvm_msi_virq(IVShmemState
*s
, int vector
)
783 IVSHMEM_DPRINTF("ivshmem_remove_kvm_msi_virq vector:%d\n", vector
);
785 if (s
->msi_vectors
[vector
].pdev
== NULL
) {
789 /* it was cleaned when masked in the frontend. */
790 kvm_irqchip_release_virq(kvm_state
, s
->msi_vectors
[vector
].virq
);
792 s
->msi_vectors
[vector
].pdev
= NULL
;
795 static void ivshmem_disable_irqfd(IVShmemState
*s
)
797 PCIDevice
*pdev
= PCI_DEVICE(s
);
800 for (i
= 0; i
< s
->peers
[s
->vm_id
].nb_eventfds
; i
++) {
801 ivshmem_remove_kvm_msi_virq(s
, i
);
804 msix_unset_vector_notifiers(pdev
);
807 static void ivshmem_write_config(PCIDevice
*pdev
, uint32_t address
,
808 uint32_t val
, int len
)
810 IVShmemState
*s
= IVSHMEM(pdev
);
811 int is_enabled
, was_enabled
= msix_enabled(pdev
);
813 pci_default_write_config(pdev
, address
, val
, len
);
814 is_enabled
= msix_enabled(pdev
);
816 if (kvm_msi_via_irqfd_enabled() && s
->vm_id
!= -1) {
817 if (!was_enabled
&& is_enabled
) {
818 ivshmem_enable_irqfd(s
);
819 } else if (was_enabled
&& !is_enabled
) {
820 ivshmem_disable_irqfd(s
);
825 static void pci_ivshmem_realize(PCIDevice
*dev
, Error
**errp
)
827 IVShmemState
*s
= IVSHMEM(dev
);
830 uint8_t attr
= PCI_BASE_ADDRESS_SPACE_MEMORY
|
831 PCI_BASE_ADDRESS_MEM_PREFETCH
;
833 if (!!s
->server_chr
+ !!s
->shmobj
+ !!s
->hostmem
!= 1) {
835 "You must specify either 'shm', 'chardev' or 'x-memdev'");
843 g_warning("size argument ignored with hostmem");
846 mr
= host_memory_backend_get_memory(s
->hostmem
, &error_abort
);
847 s
->ivshmem_size
= memory_region_size(mr
);
848 } else if (s
->sizearg
== NULL
) {
849 s
->ivshmem_size
= 4 << 20; /* 4 MB default */
852 int64_t size
= qemu_strtosz(s
->sizearg
, &end
);
853 if (size
< 0 || *end
!= '\0' || !is_power_of_2(size
)) {
854 error_setg(errp
, "Invalid size %s", s
->sizearg
);
857 s
->ivshmem_size
= size
;
860 /* IRQFD requires MSI */
861 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
) &&
862 !ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
863 error_setg(errp
, "ioeventfd/irqfd requires MSI");
867 /* check that role is reasonable */
869 if (strncmp(s
->role
, "peer", 5) == 0) {
870 s
->role_val
= IVSHMEM_PEER
;
871 } else if (strncmp(s
->role
, "master", 7) == 0) {
872 s
->role_val
= IVSHMEM_MASTER
;
874 error_setg(errp
, "'role' must be 'peer' or 'master'");
878 s
->role_val
= IVSHMEM_MASTER
; /* default */
881 pci_conf
= dev
->config
;
882 pci_conf
[PCI_COMMAND
] = PCI_COMMAND_IO
| PCI_COMMAND_MEMORY
;
884 pci_config_set_interrupt_pin(pci_conf
, 1);
886 memory_region_init_io(&s
->ivshmem_mmio
, OBJECT(s
), &ivshmem_mmio_ops
, s
,
887 "ivshmem-mmio", IVSHMEM_REG_BAR_SIZE
);
889 /* region for registers*/
890 pci_register_bar(dev
, 0, PCI_BASE_ADDRESS_SPACE_MEMORY
,
893 memory_region_init(&s
->bar
, OBJECT(s
), "ivshmem-bar2-container", s
->ivshmem_size
);
894 if (s
->ivshmem_64bit
) {
895 attr
|= PCI_BASE_ADDRESS_MEM_TYPE_64
;
898 if (s
->hostmem
!= NULL
) {
901 IVSHMEM_DPRINTF("using hostmem\n");
903 mr
= host_memory_backend_get_memory(MEMORY_BACKEND(s
->hostmem
),
905 vmstate_register_ram(mr
, DEVICE(s
));
906 memory_region_add_subregion(&s
->bar
, 0, mr
);
907 pci_register_bar(PCI_DEVICE(s
), 2, attr
, &s
->bar
);
908 } else if (s
->server_chr
!= NULL
) {
909 /* FIXME do not rely on what chr drivers put into filename */
910 if (strncmp(s
->server_chr
->filename
, "unix:", 5)) {
911 error_setg(errp
, "chardev is not a unix client socket");
915 /* if we get a UNIX socket as the parameter we will talk
916 * to the ivshmem server to receive the memory region */
918 IVSHMEM_DPRINTF("using shared memory server (socket = %s)\n",
919 s
->server_chr
->filename
);
921 if (ivshmem_setup_interrupts(s
) < 0) {
922 error_setg(errp
, "failed to initialize interrupts");
926 /* we allocate enough space for 16 peers and grow as needed */
930 pci_register_bar(dev
, 2, attr
, &s
->bar
);
932 qemu_chr_add_handlers(s
->server_chr
, ivshmem_can_receive
,
933 ivshmem_check_version
, NULL
, s
);
935 /* just map the file immediately, we're not using a server */
938 IVSHMEM_DPRINTF("using shm_open (shm object = %s)\n", s
->shmobj
);
940 /* try opening with O_EXCL and if it succeeds zero the memory
941 * by truncating to 0 */
942 if ((fd
= shm_open(s
->shmobj
, O_CREAT
|O_RDWR
|O_EXCL
,
943 S_IRWXU
|S_IRWXG
|S_IRWXO
)) > 0) {
944 /* truncate file to length PCI device's memory */
945 if (ftruncate(fd
, s
->ivshmem_size
) != 0) {
946 error_report("could not truncate shared file");
949 } else if ((fd
= shm_open(s
->shmobj
, O_CREAT
|O_RDWR
,
950 S_IRWXU
|S_IRWXG
|S_IRWXO
)) < 0) {
951 error_setg(errp
, "could not open shared file");
955 if (check_shm_size(s
, fd
, errp
) == -1) {
959 create_shared_memory_BAR(s
, fd
, attr
, &err
);
961 error_propagate(errp
, err
);
966 fifo8_create(&s
->incoming_fifo
, sizeof(int64_t));
968 if (s
->role_val
== IVSHMEM_PEER
) {
969 error_setg(&s
->migration_blocker
,
970 "Migration is disabled when using feature 'peer mode' in device 'ivshmem'");
971 migrate_add_blocker(s
->migration_blocker
);
975 static void pci_ivshmem_exit(PCIDevice
*dev
)
977 IVShmemState
*s
= IVSHMEM(dev
);
980 fifo8_destroy(&s
->incoming_fifo
);
982 if (s
->migration_blocker
) {
983 migrate_del_blocker(s
->migration_blocker
);
984 error_free(s
->migration_blocker
);
987 if (memory_region_is_mapped(&s
->ivshmem
)) {
989 void *addr
= memory_region_get_ram_ptr(&s
->ivshmem
);
992 if (munmap(addr
, s
->ivshmem_size
) == -1) {
993 error_report("Failed to munmap shared memory %s",
997 fd
= qemu_get_ram_fd(memory_region_get_ram_addr(&s
->ivshmem
));
1003 vmstate_unregister_ram(&s
->ivshmem
, DEVICE(dev
));
1004 memory_region_del_subregion(&s
->bar
, &s
->ivshmem
);
1008 for (i
= 0; i
< s
->nb_peers
; i
++) {
1009 close_peer_eventfds(s
, i
);
1014 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
1015 msix_uninit_exclusive_bar(dev
);
1018 g_free(s
->msi_vectors
);
1021 static bool test_msix(void *opaque
, int version_id
)
1023 IVShmemState
*s
= opaque
;
1025 return ivshmem_has_feature(s
, IVSHMEM_MSI
);
1028 static bool test_no_msix(void *opaque
, int version_id
)
1030 return !test_msix(opaque
, version_id
);
1033 static int ivshmem_pre_load(void *opaque
)
1035 IVShmemState
*s
= opaque
;
1037 if (s
->role_val
== IVSHMEM_PEER
) {
1038 error_report("'peer' devices are not migratable");
1045 static int ivshmem_post_load(void *opaque
, int version_id
)
1047 IVShmemState
*s
= opaque
;
1049 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
1050 ivshmem_use_msix(s
);
1056 static int ivshmem_load_old(QEMUFile
*f
, void *opaque
, int version_id
)
1058 IVShmemState
*s
= opaque
;
1059 PCIDevice
*pdev
= PCI_DEVICE(s
);
1062 IVSHMEM_DPRINTF("ivshmem_load_old\n");
1064 if (version_id
!= 0) {
1068 if (s
->role_val
== IVSHMEM_PEER
) {
1069 error_report("'peer' devices are not migratable");
1073 ret
= pci_device_load(pdev
, f
);
1078 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
1080 ivshmem_use_msix(s
);
1082 s
->intrstatus
= qemu_get_be32(f
);
1083 s
->intrmask
= qemu_get_be32(f
);
1089 static const VMStateDescription ivshmem_vmsd
= {
1092 .minimum_version_id
= 1,
1093 .pre_load
= ivshmem_pre_load
,
1094 .post_load
= ivshmem_post_load
,
1095 .fields
= (VMStateField
[]) {
1096 VMSTATE_PCI_DEVICE(parent_obj
, IVShmemState
),
1098 VMSTATE_MSIX_TEST(parent_obj
, IVShmemState
, test_msix
),
1099 VMSTATE_UINT32_TEST(intrstatus
, IVShmemState
, test_no_msix
),
1100 VMSTATE_UINT32_TEST(intrmask
, IVShmemState
, test_no_msix
),
1102 VMSTATE_END_OF_LIST()
1104 .load_state_old
= ivshmem_load_old
,
1105 .minimum_version_id_old
= 0
1108 static Property ivshmem_properties
[] = {
1109 DEFINE_PROP_CHR("chardev", IVShmemState
, server_chr
),
1110 DEFINE_PROP_STRING("size", IVShmemState
, sizearg
),
1111 DEFINE_PROP_UINT32("vectors", IVShmemState
, vectors
, 1),
1112 DEFINE_PROP_BIT("ioeventfd", IVShmemState
, features
, IVSHMEM_IOEVENTFD
, false),
1113 DEFINE_PROP_BIT("msi", IVShmemState
, features
, IVSHMEM_MSI
, true),
1114 DEFINE_PROP_STRING("shm", IVShmemState
, shmobj
),
1115 DEFINE_PROP_STRING("role", IVShmemState
, role
),
1116 DEFINE_PROP_UINT32("use64", IVShmemState
, ivshmem_64bit
, 1),
1117 DEFINE_PROP_END_OF_LIST(),
1120 static void ivshmem_class_init(ObjectClass
*klass
, void *data
)
1122 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1123 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1125 k
->realize
= pci_ivshmem_realize
;
1126 k
->exit
= pci_ivshmem_exit
;
1127 k
->config_write
= ivshmem_write_config
;
1128 k
->vendor_id
= PCI_VENDOR_ID_IVSHMEM
;
1129 k
->device_id
= PCI_DEVICE_ID_IVSHMEM
;
1130 k
->class_id
= PCI_CLASS_MEMORY_RAM
;
1131 dc
->reset
= ivshmem_reset
;
1132 dc
->props
= ivshmem_properties
;
1133 dc
->vmsd
= &ivshmem_vmsd
;
1134 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
1135 dc
->desc
= "Inter-VM shared memory";
1138 static void ivshmem_check_memdev_is_busy(Object
*obj
, const char *name
,
1139 Object
*val
, Error
**errp
)
1143 mr
= host_memory_backend_get_memory(MEMORY_BACKEND(val
), &error_abort
);
1144 if (memory_region_is_mapped(mr
)) {
1145 char *path
= object_get_canonical_path_component(val
);
1146 error_setg(errp
, "can't use already busy memdev: %s", path
);
1149 qdev_prop_allow_set_link_before_realize(obj
, name
, val
, errp
);
1153 static void ivshmem_init(Object
*obj
)
1155 IVShmemState
*s
= IVSHMEM(obj
);
1157 object_property_add_link(obj
, "x-memdev", TYPE_MEMORY_BACKEND
,
1158 (Object
**)&s
->hostmem
,
1159 ivshmem_check_memdev_is_busy
,
1160 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1164 static const TypeInfo ivshmem_info
= {
1165 .name
= TYPE_IVSHMEM
,
1166 .parent
= TYPE_PCI_DEVICE
,
1167 .instance_size
= sizeof(IVShmemState
),
1168 .instance_init
= ivshmem_init
,
1169 .class_init
= ivshmem_class_init
,
1172 static void ivshmem_register_types(void)
1174 type_register_static(&ivshmem_info
);
1177 type_init(ivshmem_register_types
)