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 "qapi/qmp/qerror.h"
26 #include "qemu/error-report.h"
27 #include "qemu/event_notifier.h"
28 #include "qemu/fifo8.h"
29 #include "sysemu/char.h"
32 #include <sys/types.h>
35 #define PCI_VENDOR_ID_IVSHMEM PCI_VENDOR_ID_REDHAT_QUMRANET
36 #define PCI_DEVICE_ID_IVSHMEM 0x1110
38 #define IVSHMEM_IOEVENTFD 0
41 #define IVSHMEM_PEER 0
42 #define IVSHMEM_MASTER 1
44 #define IVSHMEM_REG_BAR_SIZE 0x100
46 //#define DEBUG_IVSHMEM
48 #define IVSHMEM_DPRINTF(fmt, ...) \
49 do {printf("IVSHMEM: " fmt, ## __VA_ARGS__); } while (0)
51 #define IVSHMEM_DPRINTF(fmt, ...)
54 #define TYPE_IVSHMEM "ivshmem"
55 #define IVSHMEM(obj) \
56 OBJECT_CHECK(IVShmemState, (obj), TYPE_IVSHMEM)
60 EventNotifier
*eventfds
;
63 typedef struct EventfdEntry
{
68 typedef struct IVShmemState
{
77 CharDriverState
**eventfd_chr
;
78 CharDriverState
*server_chr
;
80 MemoryRegion ivshmem_mmio
;
82 /* We might need to register the BAR before we actually have the memory.
83 * So prepare a container MemoryRegion for the BAR immediately and
84 * add a subregion when we have the memory.
88 uint64_t ivshmem_size
; /* size of shared memory region */
89 uint32_t ivshmem_attr
;
90 uint32_t ivshmem_64bit
;
91 int shm_fd
; /* shared memory file descriptor */
94 int nb_peers
; /* how many guests we have space for */
95 int max_peer
; /* maximum numbered peer */
100 EventfdEntry
*eventfd_table
;
102 Error
*migration_blocker
;
107 int role_val
; /* scalar to avoid multiple string comparisons */
110 /* registers for the Inter-VM shared memory device */
111 enum ivshmem_registers
{
118 static inline uint32_t ivshmem_has_feature(IVShmemState
*ivs
,
119 unsigned int feature
) {
120 return (ivs
->features
& (1 << feature
));
123 static inline bool is_power_of_two(uint64_t x
) {
124 return (x
& (x
- 1)) == 0;
127 /* accessing registers - based on rtl8139 */
128 static void ivshmem_update_irq(IVShmemState
*s
, int val
)
130 PCIDevice
*d
= PCI_DEVICE(s
);
132 isr
= (s
->intrstatus
& s
->intrmask
) & 0xffffffff;
134 /* don't print ISR resets */
136 IVSHMEM_DPRINTF("Set IRQ to %d (%04x %04x)\n",
137 isr
? 1 : 0, s
->intrstatus
, s
->intrmask
);
140 pci_set_irq(d
, (isr
!= 0));
143 static void ivshmem_IntrMask_write(IVShmemState
*s
, uint32_t val
)
145 IVSHMEM_DPRINTF("IntrMask write(w) val = 0x%04x\n", val
);
149 ivshmem_update_irq(s
, val
);
152 static uint32_t ivshmem_IntrMask_read(IVShmemState
*s
)
154 uint32_t ret
= s
->intrmask
;
156 IVSHMEM_DPRINTF("intrmask read(w) val = 0x%04x\n", ret
);
161 static void ivshmem_IntrStatus_write(IVShmemState
*s
, uint32_t val
)
163 IVSHMEM_DPRINTF("IntrStatus write(w) val = 0x%04x\n", val
);
167 ivshmem_update_irq(s
, val
);
170 static uint32_t ivshmem_IntrStatus_read(IVShmemState
*s
)
172 uint32_t ret
= s
->intrstatus
;
174 /* reading ISR clears all interrupts */
177 ivshmem_update_irq(s
, 0);
182 static void ivshmem_io_write(void *opaque
, hwaddr addr
,
183 uint64_t val
, unsigned size
)
185 IVShmemState
*s
= opaque
;
187 uint16_t dest
= val
>> 16;
188 uint16_t vector
= val
& 0xff;
192 IVSHMEM_DPRINTF("writing to addr " TARGET_FMT_plx
"\n", addr
);
196 ivshmem_IntrMask_write(s
, val
);
200 ivshmem_IntrStatus_write(s
, val
);
204 /* check that dest VM ID is reasonable */
205 if (dest
> s
->max_peer
) {
206 IVSHMEM_DPRINTF("Invalid destination VM ID (%d)\n", dest
);
210 /* check doorbell range */
211 if (vector
< s
->peers
[dest
].nb_eventfds
) {
212 IVSHMEM_DPRINTF("Notifying VM %d on vector %d\n", dest
, vector
);
213 event_notifier_set(&s
->peers
[dest
].eventfds
[vector
]);
217 IVSHMEM_DPRINTF("Invalid VM Doorbell VM %d\n", dest
);
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 */
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 void ivshmem_receive(void *opaque
, const uint8_t *buf
, int size
)
267 IVShmemState
*s
= opaque
;
269 ivshmem_IntrStatus_write(s
, *buf
);
271 IVSHMEM_DPRINTF("ivshmem_receive 0x%02x\n", *buf
);
274 static int ivshmem_can_receive(void * opaque
)
279 static void ivshmem_event(void *opaque
, int event
)
281 IVSHMEM_DPRINTF("ivshmem_event %d\n", event
);
284 static void fake_irqfd(void *opaque
, const uint8_t *buf
, int size
) {
286 EventfdEntry
*entry
= opaque
;
287 PCIDevice
*pdev
= entry
->pdev
;
289 IVSHMEM_DPRINTF("interrupt on vector %p %d\n", pdev
, entry
->vector
);
290 msix_notify(pdev
, entry
->vector
);
293 static CharDriverState
* create_eventfd_chr_device(void * opaque
, EventNotifier
*n
,
296 /* create a event character device based on the passed eventfd */
297 IVShmemState
*s
= opaque
;
298 CharDriverState
* chr
;
299 int eventfd
= event_notifier_get_fd(n
);
301 chr
= qemu_chr_open_eventfd(eventfd
);
304 error_report("creating eventfd for eventfd %d failed", eventfd
);
307 qemu_chr_fe_claim_no_fail(chr
);
309 /* if MSI is supported we need multiple interrupts */
310 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
311 s
->eventfd_table
[vector
].pdev
= PCI_DEVICE(s
);
312 s
->eventfd_table
[vector
].vector
= vector
;
314 qemu_chr_add_handlers(chr
, ivshmem_can_receive
, fake_irqfd
,
315 ivshmem_event
, &s
->eventfd_table
[vector
]);
317 qemu_chr_add_handlers(chr
, ivshmem_can_receive
, ivshmem_receive
,
325 static int check_shm_size(IVShmemState
*s
, int fd
) {
326 /* check that the guest isn't going to try and map more memory than the
327 * the object has allocated return -1 to indicate error */
331 if (fstat(fd
, &buf
) < 0) {
332 error_report("exiting: fstat on fd %d failed: %s",
333 fd
, strerror(errno
));
337 if (s
->ivshmem_size
> buf
.st_size
) {
338 error_report("Requested memory size greater"
339 " than shared object size (%" PRIu64
" > %" PRIu64
")",
340 s
->ivshmem_size
, (uint64_t)buf
.st_size
);
347 /* create the shared memory BAR when we are not using the server, so we can
348 * create the BAR and map the memory immediately */
349 static void create_shared_memory_BAR(IVShmemState
*s
, int fd
) {
355 ptr
= mmap(0, s
->ivshmem_size
, PROT_READ
|PROT_WRITE
, MAP_SHARED
, fd
, 0);
357 memory_region_init_ram_ptr(&s
->ivshmem
, OBJECT(s
), "ivshmem.bar2",
358 s
->ivshmem_size
, ptr
);
359 vmstate_register_ram(&s
->ivshmem
, DEVICE(s
));
360 memory_region_add_subregion(&s
->bar
, 0, &s
->ivshmem
);
362 /* region for shared memory */
363 pci_register_bar(PCI_DEVICE(s
), 2, s
->ivshmem_attr
, &s
->bar
);
366 static void ivshmem_add_eventfd(IVShmemState
*s
, int posn
, int i
)
368 memory_region_add_eventfd(&s
->ivshmem_mmio
,
373 &s
->peers
[posn
].eventfds
[i
]);
376 static void ivshmem_del_eventfd(IVShmemState
*s
, int posn
, int i
)
378 memory_region_del_eventfd(&s
->ivshmem_mmio
,
383 &s
->peers
[posn
].eventfds
[i
]);
386 static void close_guest_eventfds(IVShmemState
*s
, int posn
)
388 int i
, guest_curr_max
;
390 if (!ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
)) {
393 if (posn
< 0 || posn
>= s
->nb_peers
) {
397 guest_curr_max
= s
->peers
[posn
].nb_eventfds
;
399 memory_region_transaction_begin();
400 for (i
= 0; i
< guest_curr_max
; i
++) {
401 ivshmem_del_eventfd(s
, posn
, i
);
403 memory_region_transaction_commit();
404 for (i
= 0; i
< guest_curr_max
; i
++) {
405 event_notifier_cleanup(&s
->peers
[posn
].eventfds
[i
]);
408 g_free(s
->peers
[posn
].eventfds
);
409 s
->peers
[posn
].nb_eventfds
= 0;
412 /* this function increase the dynamic storage need to store data about other
414 static int increase_dynamic_storage(IVShmemState
*s
, int new_min_size
)
419 /* check for integer overflow */
420 if (new_min_size
>= INT_MAX
/ sizeof(Peer
) - 1 || new_min_size
<= 0) {
424 old_nb_alloc
= s
->nb_peers
;
426 if (new_min_size
>= s
->nb_peers
) {
427 /* +1 because #new_min_size is used as last array index */
428 s
->nb_peers
= new_min_size
+ 1;
433 IVSHMEM_DPRINTF("bumping storage to %d guests\n", s
->nb_peers
);
434 s
->peers
= g_realloc(s
->peers
, s
->nb_peers
* sizeof(Peer
));
436 /* zero out new pointers */
437 for (j
= old_nb_alloc
; j
< s
->nb_peers
; j
++) {
438 s
->peers
[j
].eventfds
= NULL
;
439 s
->peers
[j
].nb_eventfds
= 0;
445 static void ivshmem_read(void *opaque
, const uint8_t *buf
, int size
)
447 IVShmemState
*s
= opaque
;
448 int incoming_fd
, tmp_fd
;
449 int guest_max_eventfd
;
452 if (fifo8_is_empty(&s
->incoming_fifo
) && size
== sizeof(incoming_posn
)) {
453 memcpy(&incoming_posn
, buf
, size
);
458 IVSHMEM_DPRINTF("short read of %d bytes\n", size
);
459 num
= MAX(size
, sizeof(long) - fifo8_num_used(&s
->incoming_fifo
));
460 fifo8_push_all(&s
->incoming_fifo
, buf
, num
);
461 if (fifo8_num_used(&s
->incoming_fifo
) < sizeof(incoming_posn
)) {
466 p
= fifo8_pop_buf(&s
->incoming_fifo
, sizeof(incoming_posn
), &num
);
467 g_assert(num
== sizeof(incoming_posn
));
468 memcpy(&incoming_posn
, p
, sizeof(incoming_posn
));
470 fifo8_push_all(&s
->incoming_fifo
, buf
, size
);
474 if (incoming_posn
< -1) {
475 IVSHMEM_DPRINTF("invalid incoming_posn %ld\n", incoming_posn
);
479 /* pick off s->server_chr->msgfd and store it, posn should accompany msg */
480 tmp_fd
= qemu_chr_fe_get_msgfd(s
->server_chr
);
481 IVSHMEM_DPRINTF("posn is %ld, fd is %d\n", incoming_posn
, tmp_fd
);
483 /* make sure we have enough space for this guest */
484 if (incoming_posn
>= s
->nb_peers
) {
485 if (increase_dynamic_storage(s
, incoming_posn
) < 0) {
486 error_report("increase_dynamic_storage() failed");
495 /* if posn is positive and unseen before then this is our posn*/
496 if ((incoming_posn
>= 0) &&
497 (s
->peers
[incoming_posn
].eventfds
== NULL
)) {
498 /* receive our posn */
499 s
->vm_id
= incoming_posn
;
502 /* otherwise an fd == -1 means an existing guest has gone away */
503 IVSHMEM_DPRINTF("posn %ld has gone away\n", incoming_posn
);
504 close_guest_eventfds(s
, incoming_posn
);
509 /* because of the implementation of get_msgfd, we need a dup */
510 incoming_fd
= dup(tmp_fd
);
512 if (incoming_fd
== -1) {
513 error_report("could not allocate file descriptor %s", strerror(errno
));
518 /* if the position is -1, then it's shared memory region fd */
519 if (incoming_posn
== -1) {
525 if (check_shm_size(s
, incoming_fd
) == -1) {
529 /* mmap the region and map into the BAR2 */
530 map_ptr
= mmap(0, s
->ivshmem_size
, PROT_READ
|PROT_WRITE
, MAP_SHARED
,
532 memory_region_init_ram_ptr(&s
->ivshmem
, OBJECT(s
),
533 "ivshmem.bar2", s
->ivshmem_size
, map_ptr
);
534 vmstate_register_ram(&s
->ivshmem
, DEVICE(s
));
536 IVSHMEM_DPRINTF("guest h/w addr = %p, size = %" PRIu64
"\n",
537 map_ptr
, s
->ivshmem_size
);
539 memory_region_add_subregion(&s
->bar
, 0, &s
->ivshmem
);
541 /* only store the fd if it is successfully mapped */
542 s
->shm_fd
= incoming_fd
;
547 /* each guest has an array of eventfds, and we keep track of how many
548 * guests for each VM */
549 guest_max_eventfd
= s
->peers
[incoming_posn
].nb_eventfds
;
551 if (guest_max_eventfd
== 0) {
552 /* one eventfd per MSI vector */
553 s
->peers
[incoming_posn
].eventfds
= g_new(EventNotifier
, s
->vectors
);
556 /* this is an eventfd for a particular guest VM */
557 IVSHMEM_DPRINTF("eventfds[%ld][%d] = %d\n", incoming_posn
,
558 guest_max_eventfd
, incoming_fd
);
559 event_notifier_init_fd(&s
->peers
[incoming_posn
].eventfds
[guest_max_eventfd
],
562 /* increment count for particular guest */
563 s
->peers
[incoming_posn
].nb_eventfds
++;
565 /* keep track of the maximum VM ID */
566 if (incoming_posn
> s
->max_peer
) {
567 s
->max_peer
= incoming_posn
;
570 if (incoming_posn
== s
->vm_id
) {
571 s
->eventfd_chr
[guest_max_eventfd
] = create_eventfd_chr_device(s
,
572 &s
->peers
[s
->vm_id
].eventfds
[guest_max_eventfd
],
576 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
)) {
577 ivshmem_add_eventfd(s
, incoming_posn
, guest_max_eventfd
);
581 /* Select the MSI-X vectors used by device.
582 * ivshmem maps events to vectors statically, so
583 * we just enable all vectors on init and after reset. */
584 static void ivshmem_use_msix(IVShmemState
* s
)
586 PCIDevice
*d
= PCI_DEVICE(s
);
589 if (!msix_present(d
)) {
593 for (i
= 0; i
< s
->vectors
; i
++) {
594 msix_vector_use(d
, i
);
598 static void ivshmem_reset(DeviceState
*d
)
600 IVShmemState
*s
= IVSHMEM(d
);
606 static uint64_t ivshmem_get_size(IVShmemState
* s
) {
611 value
= strtoull(s
->sizearg
, &ptr
, 10);
613 case 0: case 'M': case 'm':
620 error_report("invalid ram size: %s", s
->sizearg
);
624 /* BARs must be a power of 2 */
625 if (!is_power_of_two(value
)) {
626 error_report("size must be power of 2");
633 static void ivshmem_setup_msi(IVShmemState
* s
)
635 if (msix_init_exclusive_bar(PCI_DEVICE(s
), s
->vectors
, 1)) {
636 IVSHMEM_DPRINTF("msix initialization failed\n");
640 IVSHMEM_DPRINTF("msix initialized (%d vectors)\n", s
->vectors
);
642 /* allocate QEMU char devices for receiving interrupts */
643 s
->eventfd_table
= g_malloc0(s
->vectors
* sizeof(EventfdEntry
));
648 static void ivshmem_save(QEMUFile
* f
, void *opaque
)
650 IVShmemState
*proxy
= opaque
;
651 PCIDevice
*pci_dev
= PCI_DEVICE(proxy
);
653 IVSHMEM_DPRINTF("ivshmem_save\n");
654 pci_device_save(pci_dev
, f
);
656 if (ivshmem_has_feature(proxy
, IVSHMEM_MSI
)) {
657 msix_save(pci_dev
, f
);
659 qemu_put_be32(f
, proxy
->intrstatus
);
660 qemu_put_be32(f
, proxy
->intrmask
);
665 static int ivshmem_load(QEMUFile
* f
, void *opaque
, int version_id
)
667 IVSHMEM_DPRINTF("ivshmem_load\n");
669 IVShmemState
*proxy
= opaque
;
670 PCIDevice
*pci_dev
= PCI_DEVICE(proxy
);
673 if (version_id
> 0) {
677 if (proxy
->role_val
== IVSHMEM_PEER
) {
678 error_report("'peer' devices are not migratable");
682 ret
= pci_device_load(pci_dev
, f
);
687 if (ivshmem_has_feature(proxy
, IVSHMEM_MSI
)) {
688 msix_load(pci_dev
, f
);
689 ivshmem_use_msix(proxy
);
691 proxy
->intrstatus
= qemu_get_be32(f
);
692 proxy
->intrmask
= qemu_get_be32(f
);
698 static void ivshmem_write_config(PCIDevice
*pci_dev
, uint32_t address
,
699 uint32_t val
, int len
)
701 pci_default_write_config(pci_dev
, address
, val
, len
);
704 static int pci_ivshmem_init(PCIDevice
*dev
)
706 IVShmemState
*s
= IVSHMEM(dev
);
709 if (s
->sizearg
== NULL
)
710 s
->ivshmem_size
= 4 << 20; /* 4 MB default */
712 s
->ivshmem_size
= ivshmem_get_size(s
);
715 fifo8_create(&s
->incoming_fifo
, sizeof(long));
717 register_savevm(DEVICE(dev
), "ivshmem", 0, 0, ivshmem_save
, ivshmem_load
,
720 /* IRQFD requires MSI */
721 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
) &&
722 !ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
723 error_report("ioeventfd/irqfd requires MSI");
727 /* check that role is reasonable */
729 if (strncmp(s
->role
, "peer", 5) == 0) {
730 s
->role_val
= IVSHMEM_PEER
;
731 } else if (strncmp(s
->role
, "master", 7) == 0) {
732 s
->role_val
= IVSHMEM_MASTER
;
734 error_report("'role' must be 'peer' or 'master'");
738 s
->role_val
= IVSHMEM_MASTER
; /* default */
741 if (s
->role_val
== IVSHMEM_PEER
) {
742 error_setg(&s
->migration_blocker
,
743 "Migration is disabled when using feature 'peer mode' in device 'ivshmem'");
744 migrate_add_blocker(s
->migration_blocker
);
747 pci_conf
= dev
->config
;
748 pci_conf
[PCI_COMMAND
] = PCI_COMMAND_IO
| PCI_COMMAND_MEMORY
;
750 pci_config_set_interrupt_pin(pci_conf
, 1);
754 memory_region_init_io(&s
->ivshmem_mmio
, OBJECT(s
), &ivshmem_mmio_ops
, s
,
755 "ivshmem-mmio", IVSHMEM_REG_BAR_SIZE
);
757 /* region for registers*/
758 pci_register_bar(dev
, 0, PCI_BASE_ADDRESS_SPACE_MEMORY
,
761 memory_region_init(&s
->bar
, OBJECT(s
), "ivshmem-bar2-container", s
->ivshmem_size
);
762 s
->ivshmem_attr
= PCI_BASE_ADDRESS_SPACE_MEMORY
|
763 PCI_BASE_ADDRESS_MEM_PREFETCH
;
764 if (s
->ivshmem_64bit
) {
765 s
->ivshmem_attr
|= PCI_BASE_ADDRESS_MEM_TYPE_64
;
768 if ((s
->server_chr
!= NULL
) &&
769 (strncmp(s
->server_chr
->filename
, "unix:", 5) == 0)) {
770 /* if we get a UNIX socket as the parameter we will talk
771 * to the ivshmem server to receive the memory region */
773 if (s
->shmobj
!= NULL
) {
774 error_report("WARNING: do not specify both 'chardev' "
775 "and 'shm' with ivshmem");
778 IVSHMEM_DPRINTF("using shared memory server (socket = %s)\n",
779 s
->server_chr
->filename
);
781 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
782 ivshmem_setup_msi(s
);
785 /* we allocate enough space for 16 guests and grow as needed */
789 /* allocate/initialize space for interrupt handling */
790 s
->peers
= g_malloc0(s
->nb_peers
* sizeof(Peer
));
792 pci_register_bar(dev
, 2, s
->ivshmem_attr
, &s
->bar
);
794 s
->eventfd_chr
= g_malloc0(s
->vectors
* sizeof(CharDriverState
*));
796 qemu_chr_add_handlers(s
->server_chr
, ivshmem_can_receive
, ivshmem_read
,
799 /* just map the file immediately, we're not using a server */
802 if (s
->shmobj
== NULL
) {
803 error_report("Must specify 'chardev' or 'shm' to ivshmem");
807 IVSHMEM_DPRINTF("using shm_open (shm object = %s)\n", s
->shmobj
);
809 /* try opening with O_EXCL and if it succeeds zero the memory
810 * by truncating to 0 */
811 if ((fd
= shm_open(s
->shmobj
, O_CREAT
|O_RDWR
|O_EXCL
,
812 S_IRWXU
|S_IRWXG
|S_IRWXO
)) > 0) {
813 /* truncate file to length PCI device's memory */
814 if (ftruncate(fd
, s
->ivshmem_size
) != 0) {
815 error_report("could not truncate shared file");
818 } else if ((fd
= shm_open(s
->shmobj
, O_CREAT
|O_RDWR
,
819 S_IRWXU
|S_IRWXG
|S_IRWXO
)) < 0) {
820 error_report("could not open shared file");
825 if (check_shm_size(s
, fd
) == -1) {
829 create_shared_memory_BAR(s
, fd
);
833 dev
->config_write
= ivshmem_write_config
;
838 static void pci_ivshmem_uninit(PCIDevice
*dev
)
840 IVShmemState
*s
= IVSHMEM(dev
);
842 if (s
->migration_blocker
) {
843 migrate_del_blocker(s
->migration_blocker
);
844 error_free(s
->migration_blocker
);
847 memory_region_del_subregion(&s
->bar
, &s
->ivshmem
);
848 vmstate_unregister_ram(&s
->ivshmem
, DEVICE(dev
));
849 unregister_savevm(DEVICE(dev
), "ivshmem", s
);
850 fifo8_destroy(&s
->incoming_fifo
);
853 static Property ivshmem_properties
[] = {
854 DEFINE_PROP_CHR("chardev", IVShmemState
, server_chr
),
855 DEFINE_PROP_STRING("size", IVShmemState
, sizearg
),
856 DEFINE_PROP_UINT32("vectors", IVShmemState
, vectors
, 1),
857 DEFINE_PROP_BIT("ioeventfd", IVShmemState
, features
, IVSHMEM_IOEVENTFD
, false),
858 DEFINE_PROP_BIT("msi", IVShmemState
, features
, IVSHMEM_MSI
, true),
859 DEFINE_PROP_STRING("shm", IVShmemState
, shmobj
),
860 DEFINE_PROP_STRING("role", IVShmemState
, role
),
861 DEFINE_PROP_UINT32("use64", IVShmemState
, ivshmem_64bit
, 1),
862 DEFINE_PROP_END_OF_LIST(),
865 static void ivshmem_class_init(ObjectClass
*klass
, void *data
)
867 DeviceClass
*dc
= DEVICE_CLASS(klass
);
868 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
870 k
->init
= pci_ivshmem_init
;
871 k
->exit
= pci_ivshmem_uninit
;
872 k
->vendor_id
= PCI_VENDOR_ID_IVSHMEM
;
873 k
->device_id
= PCI_DEVICE_ID_IVSHMEM
;
874 k
->class_id
= PCI_CLASS_MEMORY_RAM
;
875 dc
->reset
= ivshmem_reset
;
876 dc
->props
= ivshmem_properties
;
877 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
880 static const TypeInfo ivshmem_info
= {
881 .name
= TYPE_IVSHMEM
,
882 .parent
= TYPE_PCI_DEVICE
,
883 .instance_size
= sizeof(IVShmemState
),
884 .class_init
= ivshmem_class_init
,
887 static void ivshmem_register_types(void)
889 type_register_static(&ivshmem_info
);
892 type_init(ivshmem_register_types
)