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.
20 #include "hw/i386/pc.h"
21 #include "hw/pci/pci.h"
22 #include "hw/pci/msix.h"
23 #include "sysemu/kvm.h"
24 #include "migration/migration.h"
25 #include "qemu/error-report.h"
26 #include "qemu/event_notifier.h"
27 #include "qemu/fifo8.h"
28 #include "sysemu/char.h"
29 #include "sysemu/hostmem.h"
30 #include "qapi/visitor.h"
32 #include "hw/misc/ivshmem.h"
35 #include <sys/types.h>
38 #define PCI_VENDOR_ID_IVSHMEM PCI_VENDOR_ID_REDHAT_QUMRANET
39 #define PCI_DEVICE_ID_IVSHMEM 0x1110
41 #define IVSHMEM_MAX_PEERS G_MAXUINT16
42 #define IVSHMEM_IOEVENTFD 0
45 #define IVSHMEM_PEER 0
46 #define IVSHMEM_MASTER 1
48 #define IVSHMEM_REG_BAR_SIZE 0x100
50 //#define DEBUG_IVSHMEM
52 #define IVSHMEM_DPRINTF(fmt, ...) \
53 do {printf("IVSHMEM: " fmt, ## __VA_ARGS__); } while (0)
55 #define IVSHMEM_DPRINTF(fmt, ...)
58 #define TYPE_IVSHMEM "ivshmem"
59 #define IVSHMEM(obj) \
60 OBJECT_CHECK(IVShmemState, (obj), TYPE_IVSHMEM)
62 #define IVSHMEM_MEMDEV_PROP "memdev"
66 EventNotifier
*eventfds
;
69 typedef struct EventfdEntry
{
74 typedef struct IVShmemState
{
79 HostMemoryBackend
*hostmem
;
83 CharDriverState
**eventfd_chr
;
84 CharDriverState
*server_chr
;
86 MemoryRegion ivshmem_mmio
;
88 /* We might need to register the BAR before we actually have the memory.
89 * So prepare a container MemoryRegion for the BAR immediately and
90 * add a subregion when we have the memory.
94 uint64_t ivshmem_size
; /* size of shared memory region */
95 uint32_t ivshmem_64bit
;
98 int nb_peers
; /* how many peers we have space for */
103 EventfdEntry
*eventfd_table
;
105 Error
*migration_blocker
;
110 int role_val
; /* scalar to avoid multiple string comparisons */
113 /* registers for the Inter-VM shared memory device */
114 enum ivshmem_registers
{
121 static inline uint32_t ivshmem_has_feature(IVShmemState
*ivs
,
122 unsigned int feature
) {
123 return (ivs
->features
& (1 << feature
));
126 /* accessing registers - based on rtl8139 */
127 static void ivshmem_update_irq(IVShmemState
*s
)
129 PCIDevice
*d
= PCI_DEVICE(s
);
131 isr
= (s
->intrstatus
& s
->intrmask
) & 0xffffffff;
133 /* don't print ISR resets */
135 IVSHMEM_DPRINTF("Set IRQ to %d (%04x %04x)\n",
136 isr
? 1 : 0, s
->intrstatus
, s
->intrmask
);
139 pci_set_irq(d
, (isr
!= 0));
142 static void ivshmem_IntrMask_write(IVShmemState
*s
, uint32_t val
)
144 IVSHMEM_DPRINTF("IntrMask write(w) val = 0x%04x\n", val
);
148 ivshmem_update_irq(s
);
151 static uint32_t ivshmem_IntrMask_read(IVShmemState
*s
)
153 uint32_t ret
= s
->intrmask
;
155 IVSHMEM_DPRINTF("intrmask read(w) val = 0x%04x\n", ret
);
160 static void ivshmem_IntrStatus_write(IVShmemState
*s
, uint32_t val
)
162 IVSHMEM_DPRINTF("IntrStatus write(w) val = 0x%04x\n", val
);
166 ivshmem_update_irq(s
);
169 static uint32_t ivshmem_IntrStatus_read(IVShmemState
*s
)
171 uint32_t ret
= s
->intrstatus
;
173 /* reading ISR clears all interrupts */
176 ivshmem_update_irq(s
);
181 static void ivshmem_io_write(void *opaque
, hwaddr addr
,
182 uint64_t val
, unsigned size
)
184 IVShmemState
*s
= opaque
;
186 uint16_t dest
= val
>> 16;
187 uint16_t vector
= val
& 0xff;
191 IVSHMEM_DPRINTF("writing to addr " TARGET_FMT_plx
"\n", addr
);
195 ivshmem_IntrMask_write(s
, val
);
199 ivshmem_IntrStatus_write(s
, val
);
203 /* check that dest VM ID is reasonable */
204 if (dest
>= s
->nb_peers
) {
205 IVSHMEM_DPRINTF("Invalid destination VM ID (%d)\n", dest
);
209 /* check doorbell range */
210 if (vector
< s
->peers
[dest
].nb_eventfds
) {
211 IVSHMEM_DPRINTF("Notifying VM %d on vector %d\n", dest
, vector
);
212 event_notifier_set(&s
->peers
[dest
].eventfds
[vector
]);
214 IVSHMEM_DPRINTF("Invalid destination vector %d on VM %d\n",
219 IVSHMEM_DPRINTF("Unhandled write " TARGET_FMT_plx
"\n", addr
);
223 static uint64_t ivshmem_io_read(void *opaque
, hwaddr addr
,
227 IVShmemState
*s
= opaque
;
233 ret
= ivshmem_IntrMask_read(s
);
237 ret
= ivshmem_IntrStatus_read(s
);
241 /* return my VM ID if the memory is mapped */
242 if (memory_region_is_mapped(&s
->ivshmem
)) {
250 IVSHMEM_DPRINTF("why are we reading " TARGET_FMT_plx
"\n", addr
);
257 static const MemoryRegionOps ivshmem_mmio_ops
= {
258 .read
= ivshmem_io_read
,
259 .write
= ivshmem_io_write
,
260 .endianness
= DEVICE_NATIVE_ENDIAN
,
262 .min_access_size
= 4,
263 .max_access_size
= 4,
267 static void ivshmem_receive(void *opaque
, const uint8_t *buf
, int size
)
269 IVShmemState
*s
= opaque
;
271 IVSHMEM_DPRINTF("ivshmem_receive 0x%02x size: %d\n", *buf
, size
);
273 ivshmem_IntrStatus_write(s
, *buf
);
276 static int ivshmem_can_receive(void * opaque
)
281 static void ivshmem_event(void *opaque
, int event
)
283 IVSHMEM_DPRINTF("ivshmem_event %d\n", event
);
286 static void fake_irqfd(void *opaque
, const uint8_t *buf
, int size
) {
288 EventfdEntry
*entry
= opaque
;
289 PCIDevice
*pdev
= entry
->pdev
;
291 IVSHMEM_DPRINTF("interrupt on vector %p %d\n", pdev
, entry
->vector
);
292 msix_notify(pdev
, entry
->vector
);
295 static CharDriverState
* create_eventfd_chr_device(void * opaque
, EventNotifier
*n
,
298 /* create a event character device based on the passed eventfd */
299 IVShmemState
*s
= opaque
;
300 CharDriverState
* chr
;
301 int eventfd
= event_notifier_get_fd(n
);
303 chr
= qemu_chr_open_eventfd(eventfd
);
306 error_report("creating chardriver for eventfd %d failed", eventfd
);
309 qemu_chr_fe_claim_no_fail(chr
);
311 /* if MSI is supported we need multiple interrupts */
312 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
313 s
->eventfd_table
[vector
].pdev
= PCI_DEVICE(s
);
314 s
->eventfd_table
[vector
].vector
= vector
;
316 qemu_chr_add_handlers(chr
, ivshmem_can_receive
, fake_irqfd
,
317 ivshmem_event
, &s
->eventfd_table
[vector
]);
319 qemu_chr_add_handlers(chr
, ivshmem_can_receive
, ivshmem_receive
,
327 static int check_shm_size(IVShmemState
*s
, int fd
, Error
**errp
)
329 /* check that the guest isn't going to try and map more memory than the
330 * the object has allocated return -1 to indicate error */
334 if (fstat(fd
, &buf
) < 0) {
335 error_setg(errp
, "exiting: fstat on fd %d failed: %s",
336 fd
, strerror(errno
));
340 if (s
->ivshmem_size
> buf
.st_size
) {
341 error_setg(errp
, "Requested memory size greater"
342 " than shared object size (%" PRIu64
" > %" PRIu64
")",
343 s
->ivshmem_size
, (uint64_t)buf
.st_size
);
350 /* create the shared memory BAR when we are not using the server, so we can
351 * create the BAR and map the memory immediately */
352 static int create_shared_memory_BAR(IVShmemState
*s
, int fd
, uint8_t attr
,
357 ptr
= mmap(0, s
->ivshmem_size
, PROT_READ
|PROT_WRITE
, MAP_SHARED
, fd
, 0);
358 if (ptr
== MAP_FAILED
) {
359 error_setg_errno(errp
, errno
, "Failed to mmap shared memory");
363 memory_region_init_ram_ptr(&s
->ivshmem
, OBJECT(s
), "ivshmem.bar2",
364 s
->ivshmem_size
, ptr
);
365 vmstate_register_ram(&s
->ivshmem
, DEVICE(s
));
366 memory_region_add_subregion(&s
->bar
, 0, &s
->ivshmem
);
368 /* region for shared memory */
369 pci_register_bar(PCI_DEVICE(s
), 2, attr
, &s
->bar
);
374 static void ivshmem_add_eventfd(IVShmemState
*s
, int posn
, int i
)
376 memory_region_add_eventfd(&s
->ivshmem_mmio
,
381 &s
->peers
[posn
].eventfds
[i
]);
384 static void ivshmem_del_eventfd(IVShmemState
*s
, int posn
, int i
)
386 memory_region_del_eventfd(&s
->ivshmem_mmio
,
391 &s
->peers
[posn
].eventfds
[i
]);
394 static void close_peer_eventfds(IVShmemState
*s
, int posn
)
398 if (!ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
)) {
401 if (posn
< 0 || posn
>= s
->nb_peers
) {
402 error_report("invalid peer %d", posn
);
406 n
= s
->peers
[posn
].nb_eventfds
;
408 memory_region_transaction_begin();
409 for (i
= 0; i
< n
; i
++) {
410 ivshmem_del_eventfd(s
, posn
, i
);
412 memory_region_transaction_commit();
413 for (i
= 0; i
< n
; i
++) {
414 event_notifier_cleanup(&s
->peers
[posn
].eventfds
[i
]);
417 g_free(s
->peers
[posn
].eventfds
);
418 s
->peers
[posn
].nb_eventfds
= 0;
421 /* this function increase the dynamic storage need to store data about other
423 static int resize_peers(IVShmemState
*s
, int new_min_size
)
428 /* limit number of max peers */
429 if (new_min_size
<= 0 || new_min_size
> IVSHMEM_MAX_PEERS
) {
432 if (new_min_size
<= s
->nb_peers
) {
436 old_size
= s
->nb_peers
;
437 s
->nb_peers
= new_min_size
;
439 IVSHMEM_DPRINTF("bumping storage to %d peers\n", s
->nb_peers
);
441 s
->peers
= g_realloc(s
->peers
, s
->nb_peers
* sizeof(Peer
));
443 for (j
= old_size
; j
< s
->nb_peers
; j
++) {
444 s
->peers
[j
].eventfds
= g_new0(EventNotifier
, s
->vectors
);
445 s
->peers
[j
].nb_eventfds
= 0;
451 static bool fifo_update_and_get(IVShmemState
*s
, const uint8_t *buf
, int size
,
452 void *data
, size_t len
)
457 assert(len
<= sizeof(long)); /* limitation of the fifo */
458 if (fifo8_is_empty(&s
->incoming_fifo
) && size
== len
) {
459 memcpy(data
, buf
, size
);
463 IVSHMEM_DPRINTF("short read of %d bytes\n", size
);
465 num
= MIN(size
, sizeof(long) - fifo8_num_used(&s
->incoming_fifo
));
466 fifo8_push_all(&s
->incoming_fifo
, buf
, num
);
468 if (fifo8_num_used(&s
->incoming_fifo
) < len
) {
475 p
= fifo8_pop_buf(&s
->incoming_fifo
, len
, &num
);
478 memcpy(data
, p
, len
);
481 fifo8_push_all(&s
->incoming_fifo
, buf
, size
);
487 static void ivshmem_read(void *opaque
, const uint8_t *buf
, int size
)
489 IVShmemState
*s
= opaque
;
496 if (!fifo_update_and_get(s
, buf
, size
,
497 &incoming_posn
, sizeof(incoming_posn
))) {
501 if (incoming_posn
< -1) {
502 IVSHMEM_DPRINTF("invalid incoming_posn %ld\n", incoming_posn
);
506 /* pick off s->server_chr->msgfd and store it, posn should accompany msg */
507 incoming_fd
= qemu_chr_fe_get_msgfd(s
->server_chr
);
508 IVSHMEM_DPRINTF("posn is %ld, fd is %d\n", incoming_posn
, incoming_fd
);
510 /* make sure we have enough space for this peer */
511 if (incoming_posn
>= s
->nb_peers
) {
512 if (resize_peers(s
, incoming_posn
+ 1) < 0) {
513 error_report("failed to resize peers array");
514 if (incoming_fd
!= -1) {
521 peer
= &s
->peers
[incoming_posn
];
523 if (incoming_fd
== -1) {
524 /* if posn is positive and unseen before then this is our posn*/
525 if (incoming_posn
>= 0 && s
->vm_id
== -1) {
526 /* receive our posn */
527 s
->vm_id
= incoming_posn
;
529 /* otherwise an fd == -1 means an existing peer has gone away */
530 IVSHMEM_DPRINTF("posn %ld has gone away\n", incoming_posn
);
531 close_peer_eventfds(s
, incoming_posn
);
536 /* if the position is -1, then it's shared memory region fd */
537 if (incoming_posn
== -1) {
540 if (memory_region_is_mapped(&s
->ivshmem
)) {
541 error_report("shm already initialized");
546 if (check_shm_size(s
, incoming_fd
, &err
) == -1) {
547 error_report_err(err
);
552 /* mmap the region and map into the BAR2 */
553 map_ptr
= mmap(0, s
->ivshmem_size
, PROT_READ
|PROT_WRITE
, MAP_SHARED
,
555 if (map_ptr
== MAP_FAILED
) {
556 error_report("Failed to mmap shared memory %s", strerror(errno
));
560 memory_region_init_ram_ptr(&s
->ivshmem
, OBJECT(s
),
561 "ivshmem.bar2", s
->ivshmem_size
, map_ptr
);
562 vmstate_register_ram(&s
->ivshmem
, DEVICE(s
));
564 IVSHMEM_DPRINTF("guest h/w addr = %p, size = %" PRIu64
"\n",
565 map_ptr
, s
->ivshmem_size
);
567 memory_region_add_subregion(&s
->bar
, 0, &s
->ivshmem
);
573 /* each peer has an associated array of eventfds, and we keep
574 * track of how many eventfds received so far */
575 /* get a new eventfd: */
576 if (peer
->nb_eventfds
>= s
->vectors
) {
577 error_report("Too many eventfd received, device has %d vectors",
583 new_eventfd
= peer
->nb_eventfds
++;
585 /* this is an eventfd for a particular peer VM */
586 IVSHMEM_DPRINTF("eventfds[%ld][%d] = %d\n", incoming_posn
,
587 new_eventfd
, incoming_fd
);
588 event_notifier_init_fd(&peer
->eventfds
[new_eventfd
], incoming_fd
);
590 if (incoming_posn
== s
->vm_id
) {
591 s
->eventfd_chr
[new_eventfd
] = create_eventfd_chr_device(s
,
592 &s
->peers
[s
->vm_id
].eventfds
[new_eventfd
],
596 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
)) {
597 ivshmem_add_eventfd(s
, incoming_posn
, new_eventfd
);
601 static void ivshmem_check_version(void *opaque
, const uint8_t * buf
, int size
)
603 IVShmemState
*s
= opaque
;
607 if (!fifo_update_and_get(s
, buf
, size
,
608 &version
, sizeof(version
))) {
612 tmp
= qemu_chr_fe_get_msgfd(s
->server_chr
);
613 if (tmp
!= -1 || version
!= IVSHMEM_PROTOCOL_VERSION
) {
614 fprintf(stderr
, "incompatible version, you are connecting to a ivshmem-"
615 "server using a different protocol please check your setup\n");
616 qemu_chr_delete(s
->server_chr
);
617 s
->server_chr
= NULL
;
621 IVSHMEM_DPRINTF("version check ok, switch to real chardev handler\n");
622 qemu_chr_add_handlers(s
->server_chr
, ivshmem_can_receive
, ivshmem_read
,
626 /* Select the MSI-X vectors used by device.
627 * ivshmem maps events to vectors statically, so
628 * we just enable all vectors on init and after reset. */
629 static void ivshmem_use_msix(IVShmemState
* s
)
631 PCIDevice
*d
= PCI_DEVICE(s
);
634 IVSHMEM_DPRINTF("%s, msix present: %d\n", __func__
, msix_present(d
));
635 if (!msix_present(d
)) {
639 for (i
= 0; i
< s
->vectors
; i
++) {
640 msix_vector_use(d
, i
);
644 static void ivshmem_reset(DeviceState
*d
)
646 IVShmemState
*s
= IVSHMEM(d
);
653 static int ivshmem_setup_msi(IVShmemState
* s
)
655 if (msix_init_exclusive_bar(PCI_DEVICE(s
), s
->vectors
, 1)) {
659 IVSHMEM_DPRINTF("msix initialized (%d vectors)\n", s
->vectors
);
661 /* allocate QEMU char devices for receiving interrupts */
662 s
->eventfd_table
= g_malloc0(s
->vectors
* sizeof(EventfdEntry
));
668 static void ivshmem_write_config(PCIDevice
*pci_dev
, uint32_t address
,
669 uint32_t val
, int len
)
671 pci_default_write_config(pci_dev
, address
, val
, len
);
674 static void pci_ivshmem_realize(PCIDevice
*dev
, Error
**errp
)
676 IVShmemState
*s
= IVSHMEM(dev
);
678 uint8_t attr
= PCI_BASE_ADDRESS_SPACE_MEMORY
|
679 PCI_BASE_ADDRESS_MEM_PREFETCH
;
681 if (!!s
->server_chr
+ !!s
->shmobj
+ !!s
->hostmem
!= 1) {
682 error_setg(errp
, "You must specify either a shmobj, a chardev"
691 g_warning("size argument ignored with hostmem");
694 mr
= host_memory_backend_get_memory(s
->hostmem
, errp
);
695 s
->ivshmem_size
= memory_region_size(mr
);
696 } else if (s
->sizearg
== NULL
) {
697 s
->ivshmem_size
= 4 << 20; /* 4 MB default */
700 int64_t size
= qemu_strtosz(s
->sizearg
, &end
);
701 if (size
< 0 || *end
!= '\0' || !is_power_of_2(size
)) {
702 error_setg(errp
, "Invalid size %s", s
->sizearg
);
705 s
->ivshmem_size
= size
;
708 fifo8_create(&s
->incoming_fifo
, sizeof(long));
710 /* IRQFD requires MSI */
711 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
) &&
712 !ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
713 error_setg(errp
, "ioeventfd/irqfd requires MSI");
717 /* check that role is reasonable */
719 if (strncmp(s
->role
, "peer", 5) == 0) {
720 s
->role_val
= IVSHMEM_PEER
;
721 } else if (strncmp(s
->role
, "master", 7) == 0) {
722 s
->role_val
= IVSHMEM_MASTER
;
724 error_setg(errp
, "'role' must be 'peer' or 'master'");
728 s
->role_val
= IVSHMEM_MASTER
; /* default */
731 if (s
->role_val
== IVSHMEM_PEER
) {
732 error_setg(&s
->migration_blocker
,
733 "Migration is disabled when using feature 'peer mode' in device 'ivshmem'");
734 migrate_add_blocker(s
->migration_blocker
);
737 pci_conf
= dev
->config
;
738 pci_conf
[PCI_COMMAND
] = PCI_COMMAND_IO
| PCI_COMMAND_MEMORY
;
740 pci_config_set_interrupt_pin(pci_conf
, 1);
742 memory_region_init_io(&s
->ivshmem_mmio
, OBJECT(s
), &ivshmem_mmio_ops
, s
,
743 "ivshmem-mmio", IVSHMEM_REG_BAR_SIZE
);
745 /* region for registers*/
746 pci_register_bar(dev
, 0, PCI_BASE_ADDRESS_SPACE_MEMORY
,
749 memory_region_init(&s
->bar
, OBJECT(s
), "ivshmem-bar2-container", s
->ivshmem_size
);
750 if (s
->ivshmem_64bit
) {
751 attr
|= PCI_BASE_ADDRESS_MEM_TYPE_64
;
754 if (s
->hostmem
!= NULL
) {
757 IVSHMEM_DPRINTF("using hostmem\n");
759 mr
= host_memory_backend_get_memory(MEMORY_BACKEND(s
->hostmem
), errp
);
760 vmstate_register_ram(mr
, DEVICE(s
));
761 memory_region_add_subregion(&s
->bar
, 0, mr
);
762 pci_register_bar(PCI_DEVICE(s
), 2, attr
, &s
->bar
);
763 } else if (s
->server_chr
!= NULL
) {
764 if (strncmp(s
->server_chr
->filename
, "unix:", 5)) {
765 error_setg(errp
, "chardev is not a unix client socket");
769 /* if we get a UNIX socket as the parameter we will talk
770 * to the ivshmem server to receive the memory region */
772 IVSHMEM_DPRINTF("using shared memory server (socket = %s)\n",
773 s
->server_chr
->filename
);
775 if (ivshmem_has_feature(s
, IVSHMEM_MSI
) &&
776 ivshmem_setup_msi(s
)) {
777 error_setg(errp
, "msix initialization failed");
781 /* we allocate enough space for 16 peers and grow as needed */
785 pci_register_bar(dev
, 2, attr
, &s
->bar
);
787 s
->eventfd_chr
= g_malloc0(s
->vectors
* sizeof(CharDriverState
*));
789 qemu_chr_add_handlers(s
->server_chr
, ivshmem_can_receive
,
790 ivshmem_check_version
, ivshmem_event
, s
);
792 /* just map the file immediately, we're not using a server */
795 IVSHMEM_DPRINTF("using shm_open (shm object = %s)\n", s
->shmobj
);
797 /* try opening with O_EXCL and if it succeeds zero the memory
798 * by truncating to 0 */
799 if ((fd
= shm_open(s
->shmobj
, O_CREAT
|O_RDWR
|O_EXCL
,
800 S_IRWXU
|S_IRWXG
|S_IRWXO
)) > 0) {
801 /* truncate file to length PCI device's memory */
802 if (ftruncate(fd
, s
->ivshmem_size
) != 0) {
803 error_report("could not truncate shared file");
806 } else if ((fd
= shm_open(s
->shmobj
, O_CREAT
|O_RDWR
,
807 S_IRWXU
|S_IRWXG
|S_IRWXO
)) < 0) {
808 error_setg(errp
, "could not open shared file");
812 if (check_shm_size(s
, fd
, errp
) == -1) {
816 create_shared_memory_BAR(s
, fd
, attr
, errp
);
821 static void pci_ivshmem_exit(PCIDevice
*dev
)
823 IVShmemState
*s
= IVSHMEM(dev
);
826 fifo8_destroy(&s
->incoming_fifo
);
828 if (s
->migration_blocker
) {
829 migrate_del_blocker(s
->migration_blocker
);
830 error_free(s
->migration_blocker
);
833 if (memory_region_is_mapped(&s
->ivshmem
)) {
835 void *addr
= memory_region_get_ram_ptr(&s
->ivshmem
);
837 if (munmap(addr
, s
->ivshmem_size
) == -1) {
838 error_report("Failed to munmap shared memory %s",
843 vmstate_unregister_ram(&s
->ivshmem
, DEVICE(dev
));
844 memory_region_del_subregion(&s
->bar
, &s
->ivshmem
);
847 if (s
->eventfd_chr
) {
848 for (i
= 0; i
< s
->vectors
; i
++) {
849 if (s
->eventfd_chr
[i
]) {
850 qemu_chr_free(s
->eventfd_chr
[i
]);
853 g_free(s
->eventfd_chr
);
857 for (i
= 0; i
< s
->nb_peers
; i
++) {
858 close_peer_eventfds(s
, i
);
863 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
864 msix_uninit_exclusive_bar(dev
);
867 g_free(s
->eventfd_table
);
870 static bool test_msix(void *opaque
, int version_id
)
872 IVShmemState
*s
= opaque
;
874 return ivshmem_has_feature(s
, IVSHMEM_MSI
);
877 static bool test_no_msix(void *opaque
, int version_id
)
879 return !test_msix(opaque
, version_id
);
882 static int ivshmem_pre_load(void *opaque
)
884 IVShmemState
*s
= opaque
;
886 if (s
->role_val
== IVSHMEM_PEER
) {
887 error_report("'peer' devices are not migratable");
894 static int ivshmem_post_load(void *opaque
, int version_id
)
896 IVShmemState
*s
= opaque
;
898 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
905 static int ivshmem_load_old(QEMUFile
*f
, void *opaque
, int version_id
)
907 IVShmemState
*s
= opaque
;
908 PCIDevice
*pdev
= PCI_DEVICE(s
);
911 IVSHMEM_DPRINTF("ivshmem_load_old\n");
913 if (version_id
!= 0) {
917 if (s
->role_val
== IVSHMEM_PEER
) {
918 error_report("'peer' devices are not migratable");
922 ret
= pci_device_load(pdev
, f
);
927 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
931 s
->intrstatus
= qemu_get_be32(f
);
932 s
->intrmask
= qemu_get_be32(f
);
938 static const VMStateDescription ivshmem_vmsd
= {
941 .minimum_version_id
= 1,
942 .pre_load
= ivshmem_pre_load
,
943 .post_load
= ivshmem_post_load
,
944 .fields
= (VMStateField
[]) {
945 VMSTATE_PCI_DEVICE(parent_obj
, IVShmemState
),
947 VMSTATE_MSIX_TEST(parent_obj
, IVShmemState
, test_msix
),
948 VMSTATE_UINT32_TEST(intrstatus
, IVShmemState
, test_no_msix
),
949 VMSTATE_UINT32_TEST(intrmask
, IVShmemState
, test_no_msix
),
951 VMSTATE_END_OF_LIST()
953 .load_state_old
= ivshmem_load_old
,
954 .minimum_version_id_old
= 0
957 static Property ivshmem_properties
[] = {
958 DEFINE_PROP_CHR("chardev", IVShmemState
, server_chr
),
959 DEFINE_PROP_STRING("size", IVShmemState
, sizearg
),
960 DEFINE_PROP_UINT32("vectors", IVShmemState
, vectors
, 1),
961 DEFINE_PROP_BIT("ioeventfd", IVShmemState
, features
, IVSHMEM_IOEVENTFD
, false),
962 DEFINE_PROP_BIT("msi", IVShmemState
, features
, IVSHMEM_MSI
, true),
963 DEFINE_PROP_STRING("shm", IVShmemState
, shmobj
),
964 DEFINE_PROP_STRING("role", IVShmemState
, role
),
965 DEFINE_PROP_UINT32("use64", IVShmemState
, ivshmem_64bit
, 1),
966 DEFINE_PROP_END_OF_LIST(),
969 static void ivshmem_class_init(ObjectClass
*klass
, void *data
)
971 DeviceClass
*dc
= DEVICE_CLASS(klass
);
972 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
974 k
->realize
= pci_ivshmem_realize
;
975 k
->exit
= pci_ivshmem_exit
;
976 k
->config_write
= ivshmem_write_config
;
977 k
->vendor_id
= PCI_VENDOR_ID_IVSHMEM
;
978 k
->device_id
= PCI_DEVICE_ID_IVSHMEM
;
979 k
->class_id
= PCI_CLASS_MEMORY_RAM
;
980 dc
->reset
= ivshmem_reset
;
981 dc
->props
= ivshmem_properties
;
982 dc
->vmsd
= &ivshmem_vmsd
;
983 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
984 dc
->desc
= "Inter-VM shared memory";
987 static void ivshmem_check_memdev_is_busy(Object
*obj
, const char *name
,
988 Object
*val
, Error
**errp
)
992 mr
= host_memory_backend_get_memory(MEMORY_BACKEND(val
), errp
);
993 if (memory_region_is_mapped(mr
)) {
994 char *path
= object_get_canonical_path_component(val
);
995 error_setg(errp
, "can't use already busy memdev: %s", path
);
998 qdev_prop_allow_set_link_before_realize(obj
, name
, val
, errp
);
1002 static void ivshmem_init(Object
*obj
)
1004 IVShmemState
*s
= IVSHMEM(obj
);
1006 object_property_add_link(obj
, IVSHMEM_MEMDEV_PROP
, TYPE_MEMORY_BACKEND
,
1007 (Object
**)&s
->hostmem
,
1008 ivshmem_check_memdev_is_busy
,
1009 OBJ_PROP_LINK_UNREF_ON_RELEASE
,
1013 static const TypeInfo ivshmem_info
= {
1014 .name
= TYPE_IVSHMEM
,
1015 .parent
= TYPE_PCI_DEVICE
,
1016 .instance_size
= sizeof(IVShmemState
),
1017 .instance_init
= ivshmem_init
,
1018 .class_init
= ivshmem_class_init
,
1021 static void ivshmem_register_types(void)
1023 type_register_static(&ivshmem_info
);
1026 type_init(ivshmem_register_types
)