PF_RING-5.6.0/vPF_RING/host/qemu-kvm-1.1.1-vpfring-diff/hw/vnplug-dev.c - vendor/opensource/pf_ring - Git at Google

 /*
  * vNPlugDev (PCI Device)
  *
  * Authors:
  *
  * 	Alfredo Cardigliano <cardigliano@ntop.org>
  *
  * This work is licensed under the terms of the GNU GPL version 2.
  *
  */

 #include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/eventfd.h>

 #include "hw.h"
 #include "pc.h"
 #include "pci.h"
 #include "msix.h"
 #include "kvm.h"
 #include "migration.h"
 #include "qerror.h"

 #include "vnplug.h"
 #include "vnplug-dev.h"

 //#define VNPLUGDEV_DEBUG

 #ifdef VNPLUGDEV_DEBUG
 #define VNPLUGDEV_DEBUG_PRINTF(fmt, ...)	do {printf("[vNPlugDev] " fmt, ## __VA_ARGS__); } while (0)
 #else
 #define VNPLUGDEV_DEBUG_PRINTF(fmt, ...)
 #endif

 static uint32_t vnplug_device_id_counter = 0;

 /* ******************************************************************************************* */

 /* called when the guest writes to the registers region */
 static void vnplug_dev_io_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size)
 {
 	struct vNPlugDev *s = opaque;

 	addr &= 0xffc;

 	VNPLUGDEV_DEBUG_PRINTF("io_writel: registers[" TARGET_FMT_plx "] = %" PRIu64 "\n", addr, val);

 	if (!((struct vNPlugDevClientInfo *) s->dev_client)->io_writel_handler)
 		fprintf(stderr, "[vNPlugDev] io_writel: client handler undefined\n");
 	else
 		((struct vNPlugDevClientInfo *) s->dev_client)->io_writel_handler((struct vNPlugDevClientInfo *) s->dev_client, addr, val);
 }

 /* ******************************************************************************************* */

 /* called when the guest reads from the registers region */
 static uint64_t vnplug_dev_io_read(void *opaque, target_phys_addr_t addr, unsigned size)
 {
 	struct vNPlugDev *s = opaque;
 	uint32_t ret = 0;

 	addr &= 0xffc;

 	if (addr == VNPLUGDEV_REG_OFF_ID){
 		ret = s->dev_id;
 		goto return_ret;
 	}

 	if ( addr >= VNPLUGDEV_REG_OFF_BASE_MM_SIZE &&
 	     addr <  VNPLUGDEV_REG_OFF_BASE_MM_SIZE + VNPLUGDEV_MAX_MM_BARS * sizeof(uint32_t) &&
 	   !(addr &  0x3)){
 		ret = s->mm_dev_size[(addr-VNPLUGDEV_REG_OFF_BASE_MM_SIZE)>>2];
 		goto return_ret;
 	}

 	if (((struct vNPlugDevClientInfo *) s->dev_client)->io_readl_handler){
 		ret = ((struct vNPlugDevClientInfo *) s->dev_client)->io_readl_handler((struct vNPlugDevClientInfo *) s->dev_client, addr);
 		goto return_ret;
 	}

 	fprintf(stderr, "[vNPlugDev] io_read: client handler undefined\n");
 	ret = 0;

 return_ret:
 	VNPLUGDEV_DEBUG_PRINTF("io_read: registers[" TARGET_FMT_plx "] value=%u\n", addr, ret);
 	return ret;
 }

 /* ******************************************************************************************* */

 static const MemoryRegionOps vnplug_dev_mmio_ops = {
 	.read = vnplug_dev_io_read,
 	.write = vnplug_dev_io_write,
 	.endianness = DEVICE_NATIVE_ENDIAN,
 	.impl = {
 		.min_access_size = 4,
 		.max_access_size = 4,
 	},
 };

 /* ******************************************************************************************* */

 /* to setup irqfds use on=1, to unset them use on=0 */
 static int setup_irqfds(struct vNPlugDev *s, int on) {
 	int i, err = 0;

 	for (i = 0; i < s->vectors; i++) {
 		/* irqfd support: interrupts are injected when a signal on an eventfd occurs */
 		if ( ( err = kvm_set_irqfd(s->dev.msix_irq_entries[i].gsi, s->backend_eventfds[i], on) ) < 0)
 			fprintf(stderr, "[vNPlugDev] irqfd warning (err=%d). Not available, or already set?\n", err);
 		else {
 			VNPLUGDEV_DEBUG_PRINTF("irqfd %s for host event %d [gsi=%u]\n", on ? "on" : "off", i, s->dev.msix_irq_entries[i].gsi);
 		}
 	}

 	return err;
 }

 /* ******************************************************************************************* */

 /* to setup ioeventfds use on=1, to unset them use on=0 */
 static int setup_ioeventfds(struct vNPlugDev *s, int on) {
 	int i, err = 0;

 	for (i = 0; i < s->guest_events_n; i++) {
 		/*  setting ioeventfd support to raise an event when a write on
 		 *  mmio_pci_addr + VNPLUGDEV_REG_OFF_DOORBELL occurs, passing i as the value to match
 		 *  (the relative io_writel handler will not be called) */

 		/* TODO Check if ioeventfds are working with this code */

 		if (on) memory_region_add_eventfd(&s->mmio, VNPLUGDEV_REG_OFF_DOORBELL, 4, true, i, s->guest_eventfds[i]);
 		else    memory_region_del_eventfd(&s->mmio, VNPLUGDEV_REG_OFF_DOORBELL, 4, true, i, s->guest_eventfds[i]);

 		//if ( (err = kvm_set_ioeventfd_mmio(s->guest_eventfds[i], s->mmio_pci_addr + VNPLUGDEV_REG_OFF_DOORBELL, i, on, 4 /* long */)) < 0) {
 		//	fprintf(stderr, "[vNPlugDev] ioeventfd warning (err=%d). Not available, or already set?\n", err);
 		//} else {
 		VNPLUGDEV_DEBUG_PRINTF("ioeventfd %s for guest event %d\n", on ? "on" : "off", i);
 		//}
 	}

 	return err;
 }

 /* ******************************************************************************************* */

 static void vnplug_dev_reset(DeviceState *d)
 {
 	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev.qdev, d);
 	int i;

 	VNPLUGDEV_DEBUG_PRINTF("reset called\n");

 	msix_reset(&s->dev);
 	for (i = 0; i < s->vectors; i++) {
 		if (msix_vector_use(&s->dev, i) != 0) {
 			VNPLUGDEV_DEBUG_PRINTF("error setting msix vector to used\n");
 		}
 	}

 	return;
 }

 /* ******************************************************************************************* */

 static void vnplug_dev_setup_msix(struct vNPlugDev * s)
 {
 	int i;

 	memory_region_init(&s->msix_bar, "vnplug-dev-msix", 0x1000 /* MSIX_PAGE_SIZE */);

 	if (msix_init(&s->dev, s->vectors, &s->msix_bar, 1, 0) == 0) {
 		/* MSI region */
 		pci_register_bar(&s->dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->msix_bar);

 		VNPLUGDEV_DEBUG_PRINTF("msix initialized (%d vectors)\n", s->vectors);
 	} else {
 		VNPLUGDEV_DEBUG_PRINTF("msix initialization failed\n");
 		exit(1);
 	}

 	for (i = 0; i < s->vectors; i++) {
 		if (msix_vector_use(&s->dev, i) != 0) {
 			VNPLUGDEV_DEBUG_PRINTF("error setting msix vector to used\n");
 		}
 	}
 }

 /* ******************************************************************************************* */

 static const VMStateDescription vmstate_vnplug_device = {
 	.name = "vnplug-dev",
 	.fields = (VMStateField []) {
 		VMSTATE_END_OF_LIST()
 	}
 };

 /* ******************************************************************************************* */

 static void vnplug_dev_write_config(PCIDevice *pci_dev, uint32_t address, uint32_t val, int len)
 {
 	pci_default_write_config(pci_dev, address, val, len);
 	msix_write_config(pci_dev, address, val, len);
 }

 /* ******************************************************************************************* */

 static int pci_vnplug_dev_init(PCIDevice *dev)
 {
 	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev, dev);
 	uint8_t *pci_conf;
 	int i;
 	char ram_block_name[32];

 	struct vNPlugDevClientInfo *client = (struct vNPlugDevClientInfo *) s->dev_client;
 	if (!client){
 		fprintf(stderr, "[vNPlugDev] undefined vNPlug-dev client info\n");
 		exit(-1);
 	}

 	s->dev_id = vnplug_device_id_counter++;

 	vmstate_register(&dev->qdev, s->dev_id, &vmstate_vnplug_device, s);

 	error_set(&s->migration_blocker, QERR_DEVICE_FEATURE_BLOCKS_MIGRATION, "vnplug-dev", "not supported");
 	migrate_add_blocker(s->migration_blocker);

 	pci_conf = s->dev.config;
 	pci_conf[PCI_COMMAND] = PCI_COMMAND_IO | PCI_COMMAND_MEMORY;
 	pci_conf[PCI_HEADER_TYPE] = PCI_HEADER_TYPE_NORMAL;
 	pci_config_set_interrupt_pin(pci_conf, 1);

 	s->mm_dev_size   [0] = s->mm_dev_size_0;
 	s->mm_dev_vma_ptr[0] = s->mm_dev_vma_ptr_0;
 	s->mm_dev_size   [1] = s->mm_dev_size_1;
 	s->mm_dev_vma_ptr[1] = s->mm_dev_vma_ptr_1;
 	s->mm_dev_size   [2] = s->mm_dev_size_2;
 	s->mm_dev_vma_ptr[2] = s->mm_dev_vma_ptr_2;
 	s->mm_dev_size   [3] = s->mm_dev_size_3;
 	s->mm_dev_vma_ptr[3] = s->mm_dev_vma_ptr_3;

 	s->vectors = s->backend_events_n;

 	VNPLUGDEV_DEBUG_PRINTF("setting up %d guest eventdfds\n", s->guest_events_n);

 	s->guest_eventfds	= g_malloc0(s->guest_events_n * sizeof(int));
 	for (i=0;i<s->guest_events_n;i++){
 		if ((s->guest_eventfds[i] = eventfd(0, 0)) < 0) {
 			fprintf(stderr, "[vNPlugDev] failed to create eventfd\n");
 			exit(-1);
 		}
 	}

 	VNPLUGDEV_DEBUG_PRINTF("setting up %d backend eventdfds\n", s->vectors);

 	s->backend_eventfds = g_malloc0(s->vectors * sizeof(int));
 	for (i=0;i<s->vectors;i++){
 		if ((s->backend_eventfds[i] = eventfd(0, 0)) < 0) {
 			fprintf(stderr, "[vNPlugDev] failed to create eventfd\n");
 			exit(-1);
 		}
 	}

 	VNPLUGDEV_DEBUG_PRINTF("setting mmio read/write handlers for device %u [ passing opaque (struct vNPlugDev *) = %p ]\n", s->dev_id, s);

 	memory_region_init_io(&s->mmio, &vnplug_dev_mmio_ops, s, "vnplug-dev-mmio", VNPLUGDEV_REG_BAR_SIZE);

 	/* setup guest to host events via ioeventfd */

 	setup_ioeventfds(s, 1);

 	/* region for registers */
 	pci_register_bar(&s->dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mmio);

 	/* setup host to guest events via MSI */

 	VNPLUGDEV_DEBUG_PRINTF("setting up %d MSI-X vectors\n", s->vectors);

 	/* region for msi and msix initialization */
 	vnplug_dev_setup_msix(s);

 	VNPLUGDEV_DEBUG_PRINTF("setting up the irqfd support\n");

 	setup_irqfds(s, 1);

 	for (i=0; i<VNPLUGDEV_MAX_MM_BARS; i++)
 		if (s->mm_dev_size[i] && s->mm_dev_vma_ptr[i]){

 			/* Checking size (it must be power of two) */
 			if ((s->mm_dev_size[i] & (s->mm_dev_size[i] - 1)) != 0){
 				fprintf(stderr, "[vNPlugDev] device memory %d size is not power of 2\n", i);
 				exit(-1);
 			}

 			/* ram block with mmapped memory to share */
 			snprintf(ram_block_name, 32, "vnplug-dev-%u.bar%d", s->dev_id, VNPLUGDEV_BASE_MM_BAR+i);

 			memory_region_init_ram_ptr(&s->mm[i], ram_block_name, s->mm_dev_size[i], (void *) s->mm_dev_vma_ptr[i]);

 			vmstate_register_ram(&s->mm[i], &s->dev.qdev);

 			VNPLUGDEV_DEBUG_PRINTF("ram block %d allocated from ptr %" PRIu64 " and size %u at ram addr %" PRIu64 "\n",
 			                       i, s->mm_dev_vma_ptr[i], s->mm_dev_size[i], s->mm[i].ram_addr);

 			/* region for shared memory */
 			pci_register_bar(&s->dev, VNPLUGDEV_BASE_MM_BAR+i, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mm[i]);
 		}

 	if (!s->dev_client || !(client->set_init_data_handler)){
 		fprintf(stderr, "[vNPlugDev] client or client handlers undefined\n");
 		exit(-1);
 	}

 	s->dev.config_write = vnplug_dev_write_config;

 	/* setting dev id and eventfds on client */
 	client->set_init_data_handler(client, s->dev_id, s->backend_events_n, s->backend_eventfds, s->guest_events_n, s->guest_eventfds);

 	return 0;
 }

 /* ******************************************************************************************* */

 static int pci_vnplug_dev_uninit(PCIDevice *dev)
 {
 	int i;
 	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev, dev);
 	struct vNPlugDevClientInfo *client = (struct vNPlugDevClientInfo *) s->dev_client;

 	if (client && client->pre_unplug_handler)
 		client->pre_unplug_handler(client);

 	migrate_del_blocker(s->migration_blocker);
 	error_free(s->migration_blocker);

 	setup_irqfds(s, 0);

 	setup_ioeventfds(s, 0);

 	for (i=0; i<VNPLUGDEV_MAX_MM_BARS; i++) {
 		if (s->mm_dev_size[i] && s->mm_dev_vma_ptr[i]){
 			vmstate_unregister_ram(&s->mm[i], &s->dev.qdev);
 			memory_region_destroy(&s->mm[i]);
 			VNPLUGDEV_DEBUG_PRINTF("BAR%d unmapped\n", VNPLUGDEV_BASE_MM_BAR+i);
 		}
 	}

 	msix_unuse_all_vectors(dev);
 	msix_uninit(dev, &s->msix_bar);
 	memory_region_destroy(&s->msix_bar);

 	VNPLUGDEV_DEBUG_PRINTF("BAR1 (MSIX) uninitialized and unmapped\n");

 	memory_region_destroy(&s->mmio);

 	VNPLUGDEV_DEBUG_PRINTF("BAR0 (registers) unmapped\n");

 	for (i = 0; i < s->vectors; i++)
 		close(s->backend_eventfds[i]);

 	VNPLUGDEV_DEBUG_PRINTF("backend eventfds closed\n");

 	for (i = 0; i < s->guest_events_n; i++)
 		close(s->guest_eventfds[i]);

 	VNPLUGDEV_DEBUG_PRINTF("guest eventfds closed\n");

 	g_free(s->backend_eventfds);
 	g_free(s->guest_eventfds);

 	vmstate_unregister(&dev->qdev, &vmstate_vnplug_device, s);

 	if (client && client->post_unplug_handler)
 		client->post_unplug_handler(client);

 	VNPLUGDEV_DEBUG_PRINTF("uninitalization done\n");

 	return 0;
 }

 /* ******************************************************************************************* */

 static Property vnplug_dev_properties[] = {

 	/* Note:
 	 * - generated in pci_vnplug_dev_init: DEFINE_PROP_UINT32("dev_id", struct vNPlugDev, dev_id, 0),
 	 * - ptrs changed to uint64: DEFINE_PROP_PTR("vma_ptr", struct vNPlugDev, mm_dev_vma_ptr),
 	 */

 	DEFINE_PROP_UINT32("backend_events_n", struct vNPlugDev, backend_events_n, 1),
 	DEFINE_PROP_UINT32("guest_events_n", struct vNPlugDev, guest_events_n, 1),

 	DEFINE_PROP_UINT32("vma_size", struct vNPlugDev, mm_dev_size_0, 0),
 	DEFINE_PROP_UINT64("vma_ptr",  struct vNPlugDev, mm_dev_vma_ptr_0, 0),

 	DEFINE_PROP_UINT32("vma_size_1", struct vNPlugDev, mm_dev_size_1, 0),
 	DEFINE_PROP_UINT64("vma_ptr_1",  struct vNPlugDev, mm_dev_vma_ptr_1, 0),

 	DEFINE_PROP_UINT32("vma_size_2", struct vNPlugDev, mm_dev_size_2, 0),
 	DEFINE_PROP_UINT64("vma_ptr_2",  struct vNPlugDev, mm_dev_vma_ptr_2, 0),

 	DEFINE_PROP_UINT32("vma_size_3", struct vNPlugDev, mm_dev_size_3, 0),
 	DEFINE_PROP_UINT64("vma_ptr_3",  struct vNPlugDev, mm_dev_vma_ptr_3, 0),

 	DEFINE_PROP_UINT64("client_info_ptr", struct vNPlugDev, dev_client, 0),
 	DEFINE_PROP_END_OF_LIST(),
 };

 static void vnplug_dev_class_init(ObjectClass *klass, void *data)
 {
 	DeviceClass *dc = DEVICE_CLASS(klass);
 	PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);

 	k->init = pci_vnplug_dev_init;
 	k->exit = pci_vnplug_dev_uninit;
 	k->vendor_id = PCI_VENDOR_ID_SILICOM;
 	k->device_id = PCI_DEVICE_ID_VNPLUG_DEV;
 	k->class_id = PCI_CLASS_MEMORY_RAM;
 	dc->reset = vnplug_dev_reset;
 	dc->props = vnplug_dev_properties;
 }

 static TypeInfo vnplug_dev_info = {
 	.name          = "vnplug-dev",
 	.parent        = TYPE_PCI_DEVICE,
 	.instance_size = sizeof(struct vNPlugDev),
 	.class_init    = vnplug_dev_class_init,
 };

 static void vnplug_dev_register_types(void)
 {
 	type_register_static(&vnplug_dev_info);
 }

 type_init(vnplug_dev_register_types)
	/*
	* vNPlugDev (PCI Device)
	*
	* Authors:
	*
	* Alfredo Cardigliano <cardigliano@ntop.org>
	*
	* This work is licensed under the terms of the GNU GPL version 2.
	*
	*/

	#include <sys/mman.h>
	#include <sys/types.h>
	#include <sys/eventfd.h>

	#include "hw.h"
	#include "pc.h"
	#include "pci.h"
	#include "msix.h"
	#include "kvm.h"
	#include "migration.h"
	#include "qerror.h"

	#include "vnplug.h"
	#include "vnplug-dev.h"

	//#define VNPLUGDEV_DEBUG

	#ifdef VNPLUGDEV_DEBUG
	#define VNPLUGDEV_DEBUG_PRINTF(fmt, ...) do {printf("[vNPlugDev] " fmt, ## __VA_ARGS__); } while (0)
	#else
	#define VNPLUGDEV_DEBUG_PRINTF(fmt, ...)
	#endif

	static uint32_t vnplug_device_id_counter = 0;

	/* ******************************************************************************************* */

	/* called when the guest writes to the registers region */
	static void vnplug_dev_io_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size)
	{
	struct vNPlugDev *s = opaque;

	addr &= 0xffc;

	VNPLUGDEV_DEBUG_PRINTF("io_writel: registers[" TARGET_FMT_plx "] = %" PRIu64 "\n", addr, val);

	if (!((struct vNPlugDevClientInfo *) s->dev_client)->io_writel_handler)
	fprintf(stderr, "[vNPlugDev] io_writel: client handler undefined\n");
	else
	((struct vNPlugDevClientInfo ) s->dev_client)->io_writel_handler((struct vNPlugDevClientInfo ) s->dev_client, addr, val);
	}

	/* ******************************************************************************************* */

	/* called when the guest reads from the registers region */
	static uint64_t vnplug_dev_io_read(void *opaque, target_phys_addr_t addr, unsigned size)
	{
	struct vNPlugDev *s = opaque;
	uint32_t ret = 0;

	addr &= 0xffc;

	if (addr == VNPLUGDEV_REG_OFF_ID){
	ret = s->dev_id;
	goto return_ret;
	}

	if ( addr >= VNPLUGDEV_REG_OFF_BASE_MM_SIZE &&
	addr < VNPLUGDEV_REG_OFF_BASE_MM_SIZE + VNPLUGDEV_MAX_MM_BARS * sizeof(uint32_t) &&
	!(addr & 0x3)){
	ret = s->mm_dev_size[(addr-VNPLUGDEV_REG_OFF_BASE_MM_SIZE)>>2];
	goto return_ret;
	}

	if (((struct vNPlugDevClientInfo *) s->dev_client)->io_readl_handler){
	ret = ((struct vNPlugDevClientInfo ) s->dev_client)->io_readl_handler((struct vNPlugDevClientInfo ) s->dev_client, addr);
	goto return_ret;
	}

	fprintf(stderr, "[vNPlugDev] io_read: client handler undefined\n");
	ret = 0;

	return_ret:
	VNPLUGDEV_DEBUG_PRINTF("io_read: registers[" TARGET_FMT_plx "] value=%u\n", addr, ret);
	return ret;
	}

	/* ******************************************************************************************* */

	static const MemoryRegionOps vnplug_dev_mmio_ops = {
	.read = vnplug_dev_io_read,
	.write = vnplug_dev_io_write,
	.endianness = DEVICE_NATIVE_ENDIAN,
	.impl = {
	.min_access_size = 4,
	.max_access_size = 4,
	},
	};

	/* ******************************************************************************************* */

	/* to setup irqfds use on=1, to unset them use on=0 */
	static int setup_irqfds(struct vNPlugDev *s, int on) {
	int i, err = 0;

	for (i = 0; i < s->vectors; i++) {
	/* irqfd support: interrupts are injected when a signal on an eventfd occurs */
	if ( ( err = kvm_set_irqfd(s->dev.msix_irq_entries[i].gsi, s->backend_eventfds[i], on) ) < 0)
	fprintf(stderr, "[vNPlugDev] irqfd warning (err=%d). Not available, or already set?\n", err);
	else {
	VNPLUGDEV_DEBUG_PRINTF("irqfd %s for host event %d [gsi=%u]\n", on ? "on" : "off", i, s->dev.msix_irq_entries[i].gsi);
	}
	}

	return err;
	}

	/* ******************************************************************************************* */

	/* to setup ioeventfds use on=1, to unset them use on=0 */
	static int setup_ioeventfds(struct vNPlugDev *s, int on) {
	int i, err = 0;

	for (i = 0; i < s->guest_events_n; i++) {
	/* setting ioeventfd support to raise an event when a write on
	* mmio_pci_addr + VNPLUGDEV_REG_OFF_DOORBELL occurs, passing i as the value to match
	* (the relative io_writel handler will not be called) */

	/* TODO Check if ioeventfds are working with this code */

	if (on) memory_region_add_eventfd(&s->mmio, VNPLUGDEV_REG_OFF_DOORBELL, 4, true, i, s->guest_eventfds[i]);
	else memory_region_del_eventfd(&s->mmio, VNPLUGDEV_REG_OFF_DOORBELL, 4, true, i, s->guest_eventfds[i]);

	//if ( (err = kvm_set_ioeventfd_mmio(s->guest_eventfds[i], s->mmio_pci_addr + VNPLUGDEV_REG_OFF_DOORBELL, i, on, 4 /* long */)) < 0) {
	// fprintf(stderr, "[vNPlugDev] ioeventfd warning (err=%d). Not available, or already set?\n", err);
	//} else {
	VNPLUGDEV_DEBUG_PRINTF("ioeventfd %s for guest event %d\n", on ? "on" : "off", i);
	//}
	}

	return err;
	}

	/* ******************************************************************************************* */

	static void vnplug_dev_reset(DeviceState *d)
	{
	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev.qdev, d);
	int i;

	VNPLUGDEV_DEBUG_PRINTF("reset called\n");

	msix_reset(&s->dev);
	for (i = 0; i < s->vectors; i++) {
	if (msix_vector_use(&s->dev, i) != 0) {
	VNPLUGDEV_DEBUG_PRINTF("error setting msix vector to used\n");
	}
	}

	return;
	}

	/* ******************************************************************************************* */

	static void vnplug_dev_setup_msix(struct vNPlugDev * s)
	{
	int i;

	memory_region_init(&s->msix_bar, "vnplug-dev-msix", 0x1000 /* MSIX_PAGE_SIZE */);

	if (msix_init(&s->dev, s->vectors, &s->msix_bar, 1, 0) == 0) {
	/* MSI region */
	pci_register_bar(&s->dev, 1, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->msix_bar);

	VNPLUGDEV_DEBUG_PRINTF("msix initialized (%d vectors)\n", s->vectors);
	} else {
	VNPLUGDEV_DEBUG_PRINTF("msix initialization failed\n");
	exit(1);
	}

	for (i = 0; i < s->vectors; i++) {
	if (msix_vector_use(&s->dev, i) != 0) {
	VNPLUGDEV_DEBUG_PRINTF("error setting msix vector to used\n");
	}
	}
	}

	/* ******************************************************************************************* */

	static const VMStateDescription vmstate_vnplug_device = {
	.name = "vnplug-dev",
	.fields = (VMStateField []) {
	VMSTATE_END_OF_LIST()
	}
	};

	/* ******************************************************************************************* */

	static void vnplug_dev_write_config(PCIDevice *pci_dev, uint32_t address, uint32_t val, int len)
	{
	pci_default_write_config(pci_dev, address, val, len);
	msix_write_config(pci_dev, address, val, len);
	}

	/* ******************************************************************************************* */

	static int pci_vnplug_dev_init(PCIDevice *dev)
	{
	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev, dev);
	uint8_t *pci_conf;
	int i;
	char ram_block_name[32];

	struct vNPlugDevClientInfo client = (struct vNPlugDevClientInfo ) s->dev_client;
	if (!client){
	fprintf(stderr, "[vNPlugDev] undefined vNPlug-dev client info\n");
	exit(-1);
	}

	s->dev_id = vnplug_device_id_counter++;

	vmstate_register(&dev->qdev, s->dev_id, &vmstate_vnplug_device, s);

	error_set(&s->migration_blocker, QERR_DEVICE_FEATURE_BLOCKS_MIGRATION, "vnplug-dev", "not supported");
	migrate_add_blocker(s->migration_blocker);

	pci_conf = s->dev.config;
	pci_conf[PCI_COMMAND] = PCI_COMMAND_IO \| PCI_COMMAND_MEMORY;
	pci_conf[PCI_HEADER_TYPE] = PCI_HEADER_TYPE_NORMAL;
	pci_config_set_interrupt_pin(pci_conf, 1);

	s->mm_dev_size [0] = s->mm_dev_size_0;
	s->mm_dev_vma_ptr[0] = s->mm_dev_vma_ptr_0;
	s->mm_dev_size [1] = s->mm_dev_size_1;
	s->mm_dev_vma_ptr[1] = s->mm_dev_vma_ptr_1;
	s->mm_dev_size [2] = s->mm_dev_size_2;
	s->mm_dev_vma_ptr[2] = s->mm_dev_vma_ptr_2;
	s->mm_dev_size [3] = s->mm_dev_size_3;
	s->mm_dev_vma_ptr[3] = s->mm_dev_vma_ptr_3;

	s->vectors = s->backend_events_n;

	VNPLUGDEV_DEBUG_PRINTF("setting up %d guest eventdfds\n", s->guest_events_n);

	s->guest_eventfds = g_malloc0(s->guest_events_n * sizeof(int));
	for (i=0;i<s->guest_events_n;i++){
	if ((s->guest_eventfds[i] = eventfd(0, 0)) < 0) {
	fprintf(stderr, "[vNPlugDev] failed to create eventfd\n");
	exit(-1);
	}
	}

	VNPLUGDEV_DEBUG_PRINTF("setting up %d backend eventdfds\n", s->vectors);

	s->backend_eventfds = g_malloc0(s->vectors * sizeof(int));
	for (i=0;i<s->vectors;i++){
	if ((s->backend_eventfds[i] = eventfd(0, 0)) < 0) {
	fprintf(stderr, "[vNPlugDev] failed to create eventfd\n");
	exit(-1);
	}
	}

	VNPLUGDEV_DEBUG_PRINTF("setting mmio read/write handlers for device %u [ passing opaque (struct vNPlugDev *) = %p ]\n", s->dev_id, s);

	memory_region_init_io(&s->mmio, &vnplug_dev_mmio_ops, s, "vnplug-dev-mmio", VNPLUGDEV_REG_BAR_SIZE);

	/* setup guest to host events via ioeventfd */

	setup_ioeventfds(s, 1);

	/* region for registers */
	pci_register_bar(&s->dev, 0, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mmio);

	/* setup host to guest events via MSI */

	VNPLUGDEV_DEBUG_PRINTF("setting up %d MSI-X vectors\n", s->vectors);

	/* region for msi and msix initialization */
	vnplug_dev_setup_msix(s);

	VNPLUGDEV_DEBUG_PRINTF("setting up the irqfd support\n");

	setup_irqfds(s, 1);

	for (i=0; i<VNPLUGDEV_MAX_MM_BARS; i++)
	if (s->mm_dev_size[i] && s->mm_dev_vma_ptr[i]){

	/* Checking size (it must be power of two) */
	if ((s->mm_dev_size[i] & (s->mm_dev_size[i] - 1)) != 0){
	fprintf(stderr, "[vNPlugDev] device memory %d size is not power of 2\n", i);
	exit(-1);
	}

	/* ram block with mmapped memory to share */
	snprintf(ram_block_name, 32, "vnplug-dev-%u.bar%d", s->dev_id, VNPLUGDEV_BASE_MM_BAR+i);

	memory_region_init_ram_ptr(&s->mm[i], ram_block_name, s->mm_dev_size[i], (void *) s->mm_dev_vma_ptr[i]);

	vmstate_register_ram(&s->mm[i], &s->dev.qdev);

	VNPLUGDEV_DEBUG_PRINTF("ram block %d allocated from ptr %" PRIu64 " and size %u at ram addr %" PRIu64 "\n",
	i, s->mm_dev_vma_ptr[i], s->mm_dev_size[i], s->mm[i].ram_addr);

	/* region for shared memory */
	pci_register_bar(&s->dev, VNPLUGDEV_BASE_MM_BAR+i, PCI_BASE_ADDRESS_SPACE_MEMORY, &s->mm[i]);
	}

	if (!s->dev_client \|\| !(client->set_init_data_handler)){
	fprintf(stderr, "[vNPlugDev] client or client handlers undefined\n");
	exit(-1);
	}

	s->dev.config_write = vnplug_dev_write_config;

	/* setting dev id and eventfds on client */
	client->set_init_data_handler(client, s->dev_id, s->backend_events_n, s->backend_eventfds, s->guest_events_n, s->guest_eventfds);

	return 0;
	}

	/* ******************************************************************************************* */

	static int pci_vnplug_dev_uninit(PCIDevice *dev)
	{
	int i;
	struct vNPlugDev *s = DO_UPCAST(struct vNPlugDev, dev, dev);
	struct vNPlugDevClientInfo client = (struct vNPlugDevClientInfo ) s->dev_client;

	if (client && client->pre_unplug_handler)
	client->pre_unplug_handler(client);

	migrate_del_blocker(s->migration_blocker);
	error_free(s->migration_blocker);

	setup_irqfds(s, 0);

	setup_ioeventfds(s, 0);

	for (i=0; i<VNPLUGDEV_MAX_MM_BARS; i++) {
	if (s->mm_dev_size[i] && s->mm_dev_vma_ptr[i]){
	vmstate_unregister_ram(&s->mm[i], &s->dev.qdev);
	memory_region_destroy(&s->mm[i]);
	VNPLUGDEV_DEBUG_PRINTF("BAR%d unmapped\n", VNPLUGDEV_BASE_MM_BAR+i);
	}
	}

	msix_unuse_all_vectors(dev);
	msix_uninit(dev, &s->msix_bar);
	memory_region_destroy(&s->msix_bar);

	VNPLUGDEV_DEBUG_PRINTF("BAR1 (MSIX) uninitialized and unmapped\n");

	memory_region_destroy(&s->mmio);

	VNPLUGDEV_DEBUG_PRINTF("BAR0 (registers) unmapped\n");

	for (i = 0; i < s->vectors; i++)
	close(s->backend_eventfds[i]);

	VNPLUGDEV_DEBUG_PRINTF("backend eventfds closed\n");

	for (i = 0; i < s->guest_events_n; i++)
	close(s->guest_eventfds[i]);

	VNPLUGDEV_DEBUG_PRINTF("guest eventfds closed\n");

	g_free(s->backend_eventfds);
	g_free(s->guest_eventfds);

	vmstate_unregister(&dev->qdev, &vmstate_vnplug_device, s);

	if (client && client->post_unplug_handler)
	client->post_unplug_handler(client);

	VNPLUGDEV_DEBUG_PRINTF("uninitalization done\n");

	return 0;
	}

	/* ******************************************************************************************* */

	static Property vnplug_dev_properties[] = {

	/* Note:
	* - generated in pci_vnplug_dev_init: DEFINE_PROP_UINT32("dev_id", struct vNPlugDev, dev_id, 0),
	* - ptrs changed to uint64: DEFINE_PROP_PTR("vma_ptr", struct vNPlugDev, mm_dev_vma_ptr),
	*/

	DEFINE_PROP_UINT32("backend_events_n", struct vNPlugDev, backend_events_n, 1),
	DEFINE_PROP_UINT32("guest_events_n", struct vNPlugDev, guest_events_n, 1),

	DEFINE_PROP_UINT32("vma_size", struct vNPlugDev, mm_dev_size_0, 0),
	DEFINE_PROP_UINT64("vma_ptr", struct vNPlugDev, mm_dev_vma_ptr_0, 0),

	DEFINE_PROP_UINT32("vma_size_1", struct vNPlugDev, mm_dev_size_1, 0),
	DEFINE_PROP_UINT64("vma_ptr_1", struct vNPlugDev, mm_dev_vma_ptr_1, 0),

	DEFINE_PROP_UINT32("vma_size_2", struct vNPlugDev, mm_dev_size_2, 0),
	DEFINE_PROP_UINT64("vma_ptr_2", struct vNPlugDev, mm_dev_vma_ptr_2, 0),

	DEFINE_PROP_UINT32("vma_size_3", struct vNPlugDev, mm_dev_size_3, 0),
	DEFINE_PROP_UINT64("vma_ptr_3", struct vNPlugDev, mm_dev_vma_ptr_3, 0),

	DEFINE_PROP_UINT64("client_info_ptr", struct vNPlugDev, dev_client, 0),
	DEFINE_PROP_END_OF_LIST(),
	};

	static void vnplug_dev_class_init(ObjectClass klass, void data)
	{
	DeviceClass *dc = DEVICE_CLASS(klass);
	PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);

	k->init = pci_vnplug_dev_init;
	k->exit = pci_vnplug_dev_uninit;
	k->vendor_id = PCI_VENDOR_ID_SILICOM;
	k->device_id = PCI_DEVICE_ID_VNPLUG_DEV;
	k->class_id = PCI_CLASS_MEMORY_RAM;
	dc->reset = vnplug_dev_reset;
	dc->props = vnplug_dev_properties;
	}

	static TypeInfo vnplug_dev_info = {
	.name = "vnplug-dev",
	.parent = TYPE_PCI_DEVICE,
	.instance_size = sizeof(struct vNPlugDev),
	.class_init = vnplug_dev_class_init,
	};

	static void vnplug_dev_register_types(void)
	{
	type_register_static(&vnplug_dev_info);
	}

	type_init(vnplug_dev_register_types)