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.
24 #include "migration.h"
26 #include "event_notifier.h"
29 #include <sys/types.h>
31 #define IVSHMEM_IOEVENTFD 0
34 #define IVSHMEM_PEER 0
35 #define IVSHMEM_MASTER 1
37 #define IVSHMEM_REG_BAR_SIZE 0x100
39 //#define DEBUG_IVSHMEM
41 #define IVSHMEM_DPRINTF(fmt, ...) \
42 do {printf("IVSHMEM: " fmt, ## __VA_ARGS__); } while (0)
44 #define IVSHMEM_DPRINTF(fmt, ...)
49 EventNotifier
*eventfds
;
52 typedef struct EventfdEntry
{
57 typedef struct IVShmemState
{
63 CharDriverState
**eventfd_chr
;
64 CharDriverState
*server_chr
;
65 MemoryRegion ivshmem_mmio
;
67 /* We might need to register the BAR before we actually have the memory.
68 * So prepare a container MemoryRegion for the BAR immediately and
69 * add a subregion when we have the memory.
73 MemoryRegion msix_bar
;
74 uint64_t ivshmem_size
; /* size of shared memory region */
75 int shm_fd
; /* shared memory file descriptor */
78 int nb_peers
; /* how many guests we have space for */
79 int max_peer
; /* maximum numbered peer */
84 EventfdEntry
*eventfd_table
;
86 Error
*migration_blocker
;
91 int role_val
; /* scalar to avoid multiple string comparisons */
94 /* registers for the Inter-VM shared memory device */
95 enum ivshmem_registers
{
102 static inline uint32_t ivshmem_has_feature(IVShmemState
*ivs
,
103 unsigned int feature
) {
104 return (ivs
->features
& (1 << feature
));
107 static inline bool is_power_of_two(uint64_t x
) {
108 return (x
& (x
- 1)) == 0;
111 /* accessing registers - based on rtl8139 */
112 static void ivshmem_update_irq(IVShmemState
*s
, int val
)
115 isr
= (s
->intrstatus
& s
->intrmask
) & 0xffffffff;
117 /* don't print ISR resets */
119 IVSHMEM_DPRINTF("Set IRQ to %d (%04x %04x)\n",
120 isr
? 1 : 0, s
->intrstatus
, s
->intrmask
);
123 qemu_set_irq(s
->dev
.irq
[0], (isr
!= 0));
126 static void ivshmem_IntrMask_write(IVShmemState
*s
, uint32_t val
)
128 IVSHMEM_DPRINTF("IntrMask write(w) val = 0x%04x\n", val
);
132 ivshmem_update_irq(s
, val
);
135 static uint32_t ivshmem_IntrMask_read(IVShmemState
*s
)
137 uint32_t ret
= s
->intrmask
;
139 IVSHMEM_DPRINTF("intrmask read(w) val = 0x%04x\n", ret
);
144 static void ivshmem_IntrStatus_write(IVShmemState
*s
, uint32_t val
)
146 IVSHMEM_DPRINTF("IntrStatus write(w) val = 0x%04x\n", val
);
150 ivshmem_update_irq(s
, val
);
154 static uint32_t ivshmem_IntrStatus_read(IVShmemState
*s
)
156 uint32_t ret
= s
->intrstatus
;
158 /* reading ISR clears all interrupts */
161 ivshmem_update_irq(s
, 0);
166 static void ivshmem_io_write(void *opaque
, target_phys_addr_t addr
,
167 uint64_t val
, unsigned size
)
169 IVShmemState
*s
= opaque
;
171 uint16_t dest
= val
>> 16;
172 uint16_t vector
= val
& 0xff;
176 IVSHMEM_DPRINTF("writing to addr " TARGET_FMT_plx
"\n", addr
);
180 ivshmem_IntrMask_write(s
, val
);
184 ivshmem_IntrStatus_write(s
, val
);
188 /* check that dest VM ID is reasonable */
189 if (dest
> s
->max_peer
) {
190 IVSHMEM_DPRINTF("Invalid destination VM ID (%d)\n", dest
);
194 /* check doorbell range */
195 if (vector
< s
->peers
[dest
].nb_eventfds
) {
196 IVSHMEM_DPRINTF("Notifying VM %d on vector %d\n", dest
, vector
);
197 event_notifier_set(&s
->peers
[dest
].eventfds
[vector
]);
201 IVSHMEM_DPRINTF("Invalid VM Doorbell VM %d\n", dest
);
205 static uint64_t ivshmem_io_read(void *opaque
, target_phys_addr_t addr
,
209 IVShmemState
*s
= opaque
;
215 ret
= ivshmem_IntrMask_read(s
);
219 ret
= ivshmem_IntrStatus_read(s
);
223 /* return my VM ID if the memory is mapped */
232 IVSHMEM_DPRINTF("why are we reading " TARGET_FMT_plx
"\n", addr
);
239 static const MemoryRegionOps ivshmem_mmio_ops
= {
240 .read
= ivshmem_io_read
,
241 .write
= ivshmem_io_write
,
242 .endianness
= DEVICE_NATIVE_ENDIAN
,
244 .min_access_size
= 4,
245 .max_access_size
= 4,
249 static void ivshmem_receive(void *opaque
, const uint8_t *buf
, int size
)
251 IVShmemState
*s
= opaque
;
253 ivshmem_IntrStatus_write(s
, *buf
);
255 IVSHMEM_DPRINTF("ivshmem_receive 0x%02x\n", *buf
);
258 static int ivshmem_can_receive(void * opaque
)
263 static void ivshmem_event(void *opaque
, int event
)
265 IVSHMEM_DPRINTF("ivshmem_event %d\n", event
);
268 static void fake_irqfd(void *opaque
, const uint8_t *buf
, int size
) {
270 EventfdEntry
*entry
= opaque
;
271 PCIDevice
*pdev
= entry
->pdev
;
273 IVSHMEM_DPRINTF("interrupt on vector %p %d\n", pdev
, entry
->vector
);
274 msix_notify(pdev
, entry
->vector
);
277 static CharDriverState
* create_eventfd_chr_device(void * opaque
, EventNotifier
*n
,
280 /* create a event character device based on the passed eventfd */
281 IVShmemState
*s
= opaque
;
282 CharDriverState
* chr
;
283 int eventfd
= event_notifier_get_fd(n
);
285 chr
= qemu_chr_open_eventfd(eventfd
);
288 fprintf(stderr
, "creating eventfd for eventfd %d failed\n", eventfd
);
292 /* if MSI is supported we need multiple interrupts */
293 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
294 s
->eventfd_table
[vector
].pdev
= &s
->dev
;
295 s
->eventfd_table
[vector
].vector
= vector
;
297 qemu_chr_add_handlers(chr
, ivshmem_can_receive
, fake_irqfd
,
298 ivshmem_event
, &s
->eventfd_table
[vector
]);
300 qemu_chr_add_handlers(chr
, ivshmem_can_receive
, ivshmem_receive
,
308 static int check_shm_size(IVShmemState
*s
, int fd
) {
309 /* check that the guest isn't going to try and map more memory than the
310 * the object has allocated return -1 to indicate error */
316 if (s
->ivshmem_size
> buf
.st_size
) {
318 "IVSHMEM ERROR: Requested memory size greater"
319 " than shared object size (%" PRIu64
" > %" PRIu64
")\n",
320 s
->ivshmem_size
, (uint64_t)buf
.st_size
);
327 /* create the shared memory BAR when we are not using the server, so we can
328 * create the BAR and map the memory immediately */
329 static void create_shared_memory_BAR(IVShmemState
*s
, int fd
) {
335 ptr
= mmap(0, s
->ivshmem_size
, PROT_READ
|PROT_WRITE
, MAP_SHARED
, fd
, 0);
337 memory_region_init_ram_ptr(&s
->ivshmem
, "ivshmem.bar2",
338 s
->ivshmem_size
, ptr
);
339 vmstate_register_ram(&s
->ivshmem
, &s
->dev
.qdev
);
340 memory_region_add_subregion(&s
->bar
, 0, &s
->ivshmem
);
342 /* region for shared memory */
343 pci_register_bar(&s
->dev
, 2, PCI_BASE_ADDRESS_SPACE_MEMORY
, &s
->bar
);
346 static void ivshmem_add_eventfd(IVShmemState
*s
, int posn
, int i
)
348 memory_region_add_eventfd(&s
->ivshmem_mmio
,
353 event_notifier_get_fd(&s
->peers
[posn
].eventfds
[i
]));
356 static void ivshmem_del_eventfd(IVShmemState
*s
, int posn
, int i
)
358 memory_region_del_eventfd(&s
->ivshmem_mmio
,
363 event_notifier_get_fd(&s
->peers
[posn
].eventfds
[i
]));
366 static void close_guest_eventfds(IVShmemState
*s
, int posn
)
368 int i
, guest_curr_max
;
370 guest_curr_max
= s
->peers
[posn
].nb_eventfds
;
372 for (i
= 0; i
< guest_curr_max
; i
++) {
373 ivshmem_del_eventfd(s
, posn
, i
);
374 event_notifier_cleanup(&s
->peers
[posn
].eventfds
[i
]);
377 g_free(s
->peers
[posn
].eventfds
);
378 s
->peers
[posn
].nb_eventfds
= 0;
381 static void setup_ioeventfds(IVShmemState
*s
) {
385 for (i
= 0; i
<= s
->max_peer
; i
++) {
386 for (j
= 0; j
< s
->peers
[i
].nb_eventfds
; j
++) {
387 ivshmem_add_eventfd(s
, i
, j
);
392 /* this function increase the dynamic storage need to store data about other
394 static void increase_dynamic_storage(IVShmemState
*s
, int new_min_size
) {
398 old_nb_alloc
= s
->nb_peers
;
400 while (new_min_size
>= s
->nb_peers
)
401 s
->nb_peers
= s
->nb_peers
* 2;
403 IVSHMEM_DPRINTF("bumping storage to %d guests\n", s
->nb_peers
);
404 s
->peers
= g_realloc(s
->peers
, s
->nb_peers
* sizeof(Peer
));
406 /* zero out new pointers */
407 for (j
= old_nb_alloc
; j
< s
->nb_peers
; j
++) {
408 s
->peers
[j
].eventfds
= NULL
;
409 s
->peers
[j
].nb_eventfds
= 0;
413 static void ivshmem_read(void *opaque
, const uint8_t * buf
, int flags
)
415 IVShmemState
*s
= opaque
;
416 int incoming_fd
, tmp_fd
;
417 int guest_max_eventfd
;
420 memcpy(&incoming_posn
, buf
, sizeof(long));
421 /* pick off s->server_chr->msgfd and store it, posn should accompany msg */
422 tmp_fd
= qemu_chr_fe_get_msgfd(s
->server_chr
);
423 IVSHMEM_DPRINTF("posn is %ld, fd is %d\n", incoming_posn
, tmp_fd
);
425 /* make sure we have enough space for this guest */
426 if (incoming_posn
>= s
->nb_peers
) {
427 increase_dynamic_storage(s
, incoming_posn
);
431 /* if posn is positive and unseen before then this is our posn*/
432 if ((incoming_posn
>= 0) &&
433 (s
->peers
[incoming_posn
].eventfds
== NULL
)) {
434 /* receive our posn */
435 s
->vm_id
= incoming_posn
;
438 /* otherwise an fd == -1 means an existing guest has gone away */
439 IVSHMEM_DPRINTF("posn %ld has gone away\n", incoming_posn
);
440 close_guest_eventfds(s
, incoming_posn
);
445 /* because of the implementation of get_msgfd, we need a dup */
446 incoming_fd
= dup(tmp_fd
);
448 if (incoming_fd
== -1) {
449 fprintf(stderr
, "could not allocate file descriptor %s\n",
454 /* if the position is -1, then it's shared memory region fd */
455 if (incoming_posn
== -1) {
461 if (check_shm_size(s
, incoming_fd
) == -1) {
465 /* mmap the region and map into the BAR2 */
466 map_ptr
= mmap(0, s
->ivshmem_size
, PROT_READ
|PROT_WRITE
, MAP_SHARED
,
468 memory_region_init_ram_ptr(&s
->ivshmem
,
469 "ivshmem.bar2", s
->ivshmem_size
, map_ptr
);
470 vmstate_register_ram(&s
->ivshmem
, &s
->dev
.qdev
);
472 IVSHMEM_DPRINTF("guest h/w addr = %" PRIu64
", size = %" PRIu64
"\n",
473 s
->ivshmem_offset
, s
->ivshmem_size
);
475 memory_region_add_subregion(&s
->bar
, 0, &s
->ivshmem
);
477 /* only store the fd if it is successfully mapped */
478 s
->shm_fd
= incoming_fd
;
483 /* each guest has an array of eventfds, and we keep track of how many
484 * guests for each VM */
485 guest_max_eventfd
= s
->peers
[incoming_posn
].nb_eventfds
;
487 if (guest_max_eventfd
== 0) {
488 /* one eventfd per MSI vector */
489 s
->peers
[incoming_posn
].eventfds
= g_new(EventNotifier
, s
->vectors
);
492 /* this is an eventfd for a particular guest VM */
493 IVSHMEM_DPRINTF("eventfds[%ld][%d] = %d\n", incoming_posn
,
494 guest_max_eventfd
, incoming_fd
);
495 event_notifier_init_fd(&s
->peers
[incoming_posn
].eventfds
[guest_max_eventfd
],
498 /* increment count for particular guest */
499 s
->peers
[incoming_posn
].nb_eventfds
++;
501 /* keep track of the maximum VM ID */
502 if (incoming_posn
> s
->max_peer
) {
503 s
->max_peer
= incoming_posn
;
506 if (incoming_posn
== s
->vm_id
) {
507 s
->eventfd_chr
[guest_max_eventfd
] = create_eventfd_chr_device(s
,
508 &s
->peers
[s
->vm_id
].eventfds
[guest_max_eventfd
],
512 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
)) {
513 ivshmem_add_eventfd(s
, incoming_posn
, guest_max_eventfd
);
519 /* Select the MSI-X vectors used by device.
520 * ivshmem maps events to vectors statically, so
521 * we just enable all vectors on init and after reset. */
522 static void ivshmem_use_msix(IVShmemState
* s
)
526 if (!msix_present(&s
->dev
)) {
530 for (i
= 0; i
< s
->vectors
; i
++) {
531 msix_vector_use(&s
->dev
, i
);
535 static void ivshmem_reset(DeviceState
*d
)
537 IVShmemState
*s
= DO_UPCAST(IVShmemState
, dev
.qdev
, d
);
544 static uint64_t ivshmem_get_size(IVShmemState
* s
) {
549 value
= strtoull(s
->sizearg
, &ptr
, 10);
551 case 0: case 'M': case 'm':
558 fprintf(stderr
, "qemu: invalid ram size: %s\n", s
->sizearg
);
562 /* BARs must be a power of 2 */
563 if (!is_power_of_two(value
)) {
564 fprintf(stderr
, "ivshmem: size must be power of 2\n");
571 static void ivshmem_setup_msi(IVShmemState
* s
)
573 memory_region_init(&s
->msix_bar
, "ivshmem-msix", 4096);
574 if (!msix_init(&s
->dev
, s
->vectors
, &s
->msix_bar
, 1, 0)) {
575 pci_register_bar(&s
->dev
, 1, PCI_BASE_ADDRESS_SPACE_MEMORY
,
577 IVSHMEM_DPRINTF("msix initialized (%d vectors)\n", s
->vectors
);
579 IVSHMEM_DPRINTF("msix initialization failed\n");
583 /* allocate QEMU char devices for receiving interrupts */
584 s
->eventfd_table
= g_malloc0(s
->vectors
* sizeof(EventfdEntry
));
589 static void ivshmem_save(QEMUFile
* f
, void *opaque
)
591 IVShmemState
*proxy
= opaque
;
593 IVSHMEM_DPRINTF("ivshmem_save\n");
594 pci_device_save(&proxy
->dev
, f
);
596 if (ivshmem_has_feature(proxy
, IVSHMEM_MSI
)) {
597 msix_save(&proxy
->dev
, f
);
599 qemu_put_be32(f
, proxy
->intrstatus
);
600 qemu_put_be32(f
, proxy
->intrmask
);
605 static int ivshmem_load(QEMUFile
* f
, void *opaque
, int version_id
)
607 IVSHMEM_DPRINTF("ivshmem_load\n");
609 IVShmemState
*proxy
= opaque
;
612 if (version_id
> 0) {
616 if (proxy
->role_val
== IVSHMEM_PEER
) {
617 fprintf(stderr
, "ivshmem: 'peer' devices are not migratable\n");
621 ret
= pci_device_load(&proxy
->dev
, f
);
626 if (ivshmem_has_feature(proxy
, IVSHMEM_MSI
)) {
627 msix_load(&proxy
->dev
, f
);
628 ivshmem_use_msix(proxy
);
630 proxy
->intrstatus
= qemu_get_be32(f
);
631 proxy
->intrmask
= qemu_get_be32(f
);
637 static void ivshmem_write_config(PCIDevice
*pci_dev
, uint32_t address
,
638 uint32_t val
, int len
)
640 pci_default_write_config(pci_dev
, address
, val
, len
);
641 msix_write_config(pci_dev
, address
, val
, len
);
644 static int pci_ivshmem_init(PCIDevice
*dev
)
646 IVShmemState
*s
= DO_UPCAST(IVShmemState
, dev
, dev
);
649 if (s
->sizearg
== NULL
)
650 s
->ivshmem_size
= 4 << 20; /* 4 MB default */
652 s
->ivshmem_size
= ivshmem_get_size(s
);
655 register_savevm(&s
->dev
.qdev
, "ivshmem", 0, 0, ivshmem_save
, ivshmem_load
,
658 /* IRQFD requires MSI */
659 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
) &&
660 !ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
661 fprintf(stderr
, "ivshmem: ioeventfd/irqfd requires MSI\n");
665 /* check that role is reasonable */
667 if (strncmp(s
->role
, "peer", 5) == 0) {
668 s
->role_val
= IVSHMEM_PEER
;
669 } else if (strncmp(s
->role
, "master", 7) == 0) {
670 s
->role_val
= IVSHMEM_MASTER
;
672 fprintf(stderr
, "ivshmem: 'role' must be 'peer' or 'master'\n");
676 s
->role_val
= IVSHMEM_MASTER
; /* default */
679 if (s
->role_val
== IVSHMEM_PEER
) {
680 error_set(&s
->migration_blocker
, QERR_DEVICE_FEATURE_BLOCKS_MIGRATION
, "ivshmem", "peer mode");
681 migrate_add_blocker(s
->migration_blocker
);
684 pci_conf
= s
->dev
.config
;
685 pci_conf
[PCI_COMMAND
] = PCI_COMMAND_IO
| PCI_COMMAND_MEMORY
;
687 pci_config_set_interrupt_pin(pci_conf
, 1);
691 memory_region_init_io(&s
->ivshmem_mmio
, &ivshmem_mmio_ops
, s
,
692 "ivshmem-mmio", IVSHMEM_REG_BAR_SIZE
);
694 if (ivshmem_has_feature(s
, IVSHMEM_IOEVENTFD
)) {
698 /* region for registers*/
699 pci_register_bar(&s
->dev
, 0, PCI_BASE_ADDRESS_SPACE_MEMORY
,
702 memory_region_init(&s
->bar
, "ivshmem-bar2-container", s
->ivshmem_size
);
704 if ((s
->server_chr
!= NULL
) &&
705 (strncmp(s
->server_chr
->filename
, "unix:", 5) == 0)) {
706 /* if we get a UNIX socket as the parameter we will talk
707 * to the ivshmem server to receive the memory region */
709 if (s
->shmobj
!= NULL
) {
710 fprintf(stderr
, "WARNING: do not specify both 'chardev' "
711 "and 'shm' with ivshmem\n");
714 IVSHMEM_DPRINTF("using shared memory server (socket = %s)\n",
715 s
->server_chr
->filename
);
717 if (ivshmem_has_feature(s
, IVSHMEM_MSI
)) {
718 ivshmem_setup_msi(s
);
721 /* we allocate enough space for 16 guests and grow as needed */
725 /* allocate/initialize space for interrupt handling */
726 s
->peers
= g_malloc0(s
->nb_peers
* sizeof(Peer
));
728 pci_register_bar(&s
->dev
, 2,
729 PCI_BASE_ADDRESS_SPACE_MEMORY
, &s
->bar
);
731 s
->eventfd_chr
= g_malloc0(s
->vectors
* sizeof(CharDriverState
*));
733 qemu_chr_add_handlers(s
->server_chr
, ivshmem_can_receive
, ivshmem_read
,
736 /* just map the file immediately, we're not using a server */
739 if (s
->shmobj
== NULL
) {
740 fprintf(stderr
, "Must specify 'chardev' or 'shm' to ivshmem\n");
743 IVSHMEM_DPRINTF("using shm_open (shm object = %s)\n", s
->shmobj
);
745 /* try opening with O_EXCL and if it succeeds zero the memory
746 * by truncating to 0 */
747 if ((fd
= shm_open(s
->shmobj
, O_CREAT
|O_RDWR
|O_EXCL
,
748 S_IRWXU
|S_IRWXG
|S_IRWXO
)) > 0) {
749 /* truncate file to length PCI device's memory */
750 if (ftruncate(fd
, s
->ivshmem_size
) != 0) {
751 fprintf(stderr
, "ivshmem: could not truncate shared file\n");
754 } else if ((fd
= shm_open(s
->shmobj
, O_CREAT
|O_RDWR
,
755 S_IRWXU
|S_IRWXG
|S_IRWXO
)) < 0) {
756 fprintf(stderr
, "ivshmem: could not open shared file\n");
761 if (check_shm_size(s
, fd
) == -1) {
765 create_shared_memory_BAR(s
, fd
);
769 s
->dev
.config_write
= ivshmem_write_config
;
774 static int pci_ivshmem_uninit(PCIDevice
*dev
)
776 IVShmemState
*s
= DO_UPCAST(IVShmemState
, dev
, dev
);
778 if (s
->migration_blocker
) {
779 migrate_del_blocker(s
->migration_blocker
);
780 error_free(s
->migration_blocker
);
783 memory_region_destroy(&s
->ivshmem_mmio
);
784 memory_region_del_subregion(&s
->bar
, &s
->ivshmem
);
785 vmstate_unregister_ram(&s
->ivshmem
, &s
->dev
.qdev
);
786 memory_region_destroy(&s
->ivshmem
);
787 memory_region_destroy(&s
->bar
);
788 unregister_savevm(&dev
->qdev
, "ivshmem", s
);
793 static Property ivshmem_properties
[] = {
794 DEFINE_PROP_CHR("chardev", IVShmemState
, server_chr
),
795 DEFINE_PROP_STRING("size", IVShmemState
, sizearg
),
796 DEFINE_PROP_UINT32("vectors", IVShmemState
, vectors
, 1),
797 DEFINE_PROP_BIT("ioeventfd", IVShmemState
, features
, IVSHMEM_IOEVENTFD
, false),
798 DEFINE_PROP_BIT("msi", IVShmemState
, features
, IVSHMEM_MSI
, true),
799 DEFINE_PROP_STRING("shm", IVShmemState
, shmobj
),
800 DEFINE_PROP_STRING("role", IVShmemState
, role
),
801 DEFINE_PROP_END_OF_LIST(),
804 static void ivshmem_class_init(ObjectClass
*klass
, void *data
)
806 DeviceClass
*dc
= DEVICE_CLASS(klass
);
807 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
809 k
->init
= pci_ivshmem_init
;
810 k
->exit
= pci_ivshmem_uninit
;
811 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
812 k
->device_id
= 0x1110;
813 k
->class_id
= PCI_CLASS_MEMORY_RAM
;
814 dc
->reset
= ivshmem_reset
;
815 dc
->props
= ivshmem_properties
;
818 static TypeInfo ivshmem_info
= {
820 .parent
= TYPE_PCI_DEVICE
,
821 .instance_size
= sizeof(IVShmemState
),
822 .class_init
= ivshmem_class_init
,
825 static void ivshmem_register_types(void)
827 type_register_static(&ivshmem_info
);
830 type_init(ivshmem_register_types
)