[mirror_ubuntu-bionic-kernel.git] / virt / kvm / coalesced_mmio.c

/*
 * KVM coalesced MMIO
 *
 * Copyright (c) 2008 Bull S.A.S.
 *
 *  Author: Laurent Vivier <Laurent.Vivier@bull.net>
 *
 */

#include "iodev.h"

#include <linux/kvm_host.h>
#include <linux/kvm.h>

#include "coalesced_mmio.h"

static int coalesced_mmio_in_range(struct kvm_io_device *this,
				   gpa_t addr, int len, int is_write)
{
	struct kvm_coalesced_mmio_dev *dev =
				(struct kvm_coalesced_mmio_dev*)this->private;
	struct kvm_coalesced_mmio_zone *zone;
	int next;
	int i;

	if (!is_write)
		return 0;

	/* kvm->lock is taken by the caller and must be not released before
         * dev.read/write
         */

	/* Are we able to batch it ? */

	/* last is the first free entry
	 * check if we don't meet the first used entry
	 * there is always one unused entry in the buffer
	 */

	next = (dev->kvm->coalesced_mmio_ring->last + 1) %
							KVM_COALESCED_MMIO_MAX;
	if (next == dev->kvm->coalesced_mmio_ring->first) {
		/* full */
		return 0;
	}

	/* is it in a batchable area ? */

	for (i = 0; i < dev->nb_zones; i++) {
		zone = &dev->zone[i];

		/* (addr,len) is fully included in
		 * (zone->addr, zone->size)
		 */

		if (zone->addr <= addr &&
		    addr + len <= zone->addr + zone->size)
			return 1;
	}
	return 0;
}

static void coalesced_mmio_write(struct kvm_io_device *this,
				 gpa_t addr, int len, const void *val)
{
	struct kvm_coalesced_mmio_dev *dev =
				(struct kvm_coalesced_mmio_dev*)this->private;
	struct kvm_coalesced_mmio_ring *ring = dev->kvm->coalesced_mmio_ring;

	/* kvm->lock must be taken by caller before call to in_range()*/

	/* copy data in first free entry of the ring */

	ring->coalesced_mmio[ring->last].phys_addr = addr;
	ring->coalesced_mmio[ring->last].len = len;
	memcpy(ring->coalesced_mmio[ring->last].data, val, len);
	smp_wmb();
	ring->last = (ring->last + 1) % KVM_COALESCED_MMIO_MAX;
}

static void coalesced_mmio_destructor(struct kvm_io_device *this)
{
	struct kvm_coalesced_mmio_dev *dev =
		(struct kvm_coalesced_mmio_dev *)this->private;

	kfree(dev);
}

int kvm_coalesced_mmio_init(struct kvm *kvm)
{
	struct kvm_coalesced_mmio_dev *dev;

	dev = kzalloc(sizeof(struct kvm_coalesced_mmio_dev), GFP_KERNEL);
	if (!dev)
		return -ENOMEM;
	dev->dev.write  = coalesced_mmio_write;
	dev->dev.in_range  = coalesced_mmio_in_range;
	dev->dev.destructor  = coalesced_mmio_destructor;
	dev->dev.private  = dev;
	dev->kvm = kvm;
	kvm->coalesced_mmio_dev = dev;
	kvm_io_bus_register_dev(&kvm->mmio_bus, &dev->dev);

	return 0;
}

int kvm_vm_ioctl_register_coalesced_mmio(struct kvm *kvm,
				         struct kvm_coalesced_mmio_zone *zone)
{
	struct kvm_coalesced_mmio_dev *dev = kvm->coalesced_mmio_dev;

	if (dev == NULL)
		return -EINVAL;

	mutex_lock(&kvm->lock);
	if (dev->nb_zones >= KVM_COALESCED_MMIO_ZONE_MAX) {
		mutex_unlock(&kvm->lock);
		return -ENOBUFS;
	}

	dev->zone[dev->nb_zones] = *zone;
	dev->nb_zones++;

	mutex_unlock(&kvm->lock);
	return 0;
}

int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm,
					   struct kvm_coalesced_mmio_zone *zone)
{
	int i;
	struct kvm_coalesced_mmio_dev *dev = kvm->coalesced_mmio_dev;
	struct kvm_coalesced_mmio_zone *z;

	if (dev == NULL)
		return -EINVAL;

	mutex_lock(&kvm->lock);

	i = dev->nb_zones;
	while(i) {
		z = &dev->zone[i - 1];

		/* unregister all zones
		 * included in (zone->addr, zone->size)
		 */

		if (zone->addr <= z->addr &&
		    z->addr + z->size <= zone->addr + zone->size) {
			dev->nb_zones--;
			*z = dev->zone[dev->nb_zones];
		}
		i--;
	}

	mutex_unlock(&kvm->lock);

	return 0;
}
Commit	Line	Data
5f94c174 LV	1	/*
	2	* KVM coalesced MMIO
	3	*
	4	* Copyright (c) 2008 Bull S.A.S.
	5	*
	6	* Author: Laurent Vivier <Laurent.Vivier@bull.net>
	7	*
	8	*/
	9
	10	#include "iodev.h"
	11
	12	#include <linux/kvm_host.h>
	13	#include <linux/kvm.h>
	14
	15	#include "coalesced_mmio.h"
	16
	17	static int coalesced_mmio_in_range(struct kvm_io_device *this,
	18	gpa_t addr, int len, int is_write)
	19	{
	20	struct kvm_coalesced_mmio_dev *dev =
	21	(struct kvm_coalesced_mmio_dev*)this->private;
	22	struct kvm_coalesced_mmio_zone *zone;
	23	int next;
	24	int i;
	25
	26	if (!is_write)
	27	return 0;
	28
	29	/* kvm->lock is taken by the caller and must be not released before
	30	* dev.read/write
	31	*/
	32
	33	/* Are we able to batch it ? */
	34
	35	/* last is the first free entry
	36	* check if we don't meet the first used entry
	37	* there is always one unused entry in the buffer
	38	*/
	39
	40	next = (dev->kvm->coalesced_mmio_ring->last + 1) %
	41	KVM_COALESCED_MMIO_MAX;
	42	if (next == dev->kvm->coalesced_mmio_ring->first) {
	43	/* full */
	44	return 0;
	45	}
	46
	47	/* is it in a batchable area ? */
	48
	49	for (i = 0; i < dev->nb_zones; i++) {
	50	zone = &dev->zone[i];
	51
	52	/* (addr,len) is fully included in
	53	* (zone->addr, zone->size)
	54	*/
	55
	56	if (zone->addr <= addr &&
	57	addr + len <= zone->addr + zone->size)
	58	return 1;
	59	}
	60	return 0;
	61	}
	62
	63	static void coalesced_mmio_write(struct kvm_io_device *this,
	64	gpa_t addr, int len, const void *val)
65	{
66	struct kvm_coalesced_mmio_dev *dev =
67	(struct kvm_coalesced_mmio_dev*)this->private;
68	struct kvm_coalesced_mmio_ring *ring = dev->kvm->coalesced_mmio_ring;
69
70	/* kvm->lock must be taken by caller before call to in_range()*/
71
72	/* copy data in first free entry of the ring */
73
74	ring->coalesced_mmio[ring->last].phys_addr = addr;
75	ring->coalesced_mmio[ring->last].len = len;
76	memcpy(ring->coalesced_mmio[ring->last].data, val, len);
77	smp_wmb();
78	ring->last = (ring->last + 1) % KVM_COALESCED_MMIO_MAX;
79	}
80
81	static void coalesced_mmio_destructor(struct kvm_io_device *this)
82	{
787a660a GH	83	struct kvm_coalesced_mmio_dev *dev =
	84	(struct kvm_coalesced_mmio_dev *)this->private;
	85
	86	kfree(dev);
5f94c174 LV	87	}
	88
	89	int kvm_coalesced_mmio_init(struct kvm *kvm)
	90	{
	91	struct kvm_coalesced_mmio_dev *dev;
	92
	93	dev = kzalloc(sizeof(struct kvm_coalesced_mmio_dev), GFP_KERNEL);
	94	if (!dev)
	95	return -ENOMEM;
	96	dev->dev.write = coalesced_mmio_write;
	97	dev->dev.in_range = coalesced_mmio_in_range;
	98	dev->dev.destructor = coalesced_mmio_destructor;
	99	dev->dev.private = dev;
	100	dev->kvm = kvm;
	101	kvm->coalesced_mmio_dev = dev;
	102	kvm_io_bus_register_dev(&kvm->mmio_bus, &dev->dev);
	103
	104	return 0;
	105	}
	106
	107	int kvm_vm_ioctl_register_coalesced_mmio(struct kvm *kvm,
	108	struct kvm_coalesced_mmio_zone *zone)
	109	{
	110	struct kvm_coalesced_mmio_dev *dev = kvm->coalesced_mmio_dev;
	111
	112	if (dev == NULL)
	113	return -EINVAL;
	114
	115	mutex_lock(&kvm->lock);
	116	if (dev->nb_zones >= KVM_COALESCED_MMIO_ZONE_MAX) {
	117	mutex_unlock(&kvm->lock);
	118	return -ENOBUFS;
	119	}
	120
	121	dev->zone[dev->nb_zones] = *zone;
	122	dev->nb_zones++;
	123
	124	mutex_unlock(&kvm->lock);
	125	return 0;
	126	}
	127
	128	int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm,
	129	struct kvm_coalesced_mmio_zone *zone)
	130	{
	131	int i;
	132	struct kvm_coalesced_mmio_dev *dev = kvm->coalesced_mmio_dev;
	133	struct kvm_coalesced_mmio_zone *z;
	134
	135	if (dev == NULL)
	136	return -EINVAL;
	137
	138	mutex_lock(&kvm->lock);
	139
	140	i = dev->nb_zones;
	141	while(i) {
	142	z = &dev->zone[i - 1];
	143
	144	/* unregister all zones
	145	* included in (zone->addr, zone->size)
	146	*/
	147
	148	if (zone->addr <= z->addr &&
	149	z->addr + z->size <= zone->addr + zone->size) {
	150	dev->nb_zones--;
151	*z = dev->zone[dev->nb_zones];
152	}
153	i--;
154	}
155
156	mutex_unlock(&kvm->lock);
157
158	return 0;
159	}