1226035Sgabor// SPDX-License-Identifier: GPL-2.0 2226035Sgabor/* 3226035Sgabor * KVM coalesced MMIO 4226035Sgabor * 5226035Sgabor * Copyright (c) 2008 Bull S.A.S. 6226035Sgabor * Copyright 2009 Red Hat, Inc. and/or its affiliates. 7226035Sgabor * 8226035Sgabor * Author: Laurent Vivier <Laurent.Vivier@bull.net> 9226035Sgabor * 10226035Sgabor */ 11226035Sgabor 12226035Sgabor#include <kvm/iodev.h> 13226035Sgabor 14226035Sgabor#include <linux/kvm_host.h> 15226035Sgabor#include <linux/slab.h> 16226035Sgabor#include <linux/kvm.h> 17226035Sgabor 18226035Sgabor#include "coalesced_mmio.h" 19226035Sgabor 20226035Sgaborstatic inline struct kvm_coalesced_mmio_dev *to_mmio(struct kvm_io_device *dev) 21226035Sgabor{ 22226035Sgabor return container_of(dev, struct kvm_coalesced_mmio_dev, dev); 23226035Sgabor} 24226035Sgabor 25226035Sgaborstatic int coalesced_mmio_in_range(struct kvm_coalesced_mmio_dev *dev, 26226035Sgabor gpa_t addr, int len) 27226035Sgabor{ 28226035Sgabor /* is it in a batchable area ? 29226035Sgabor * (addr,len) is fully included in 30226035Sgabor * (zone->addr, zone->size) 31226035Sgabor */ 32226035Sgabor if (len < 0) 33226035Sgabor return 0; 34226035Sgabor if (addr + len < addr) 35226035Sgabor return 0; 36226035Sgabor if (addr < dev->zone.addr) 37226035Sgabor return 0; 38226035Sgabor if (addr + len > dev->zone.addr + dev->zone.size) 39226035Sgabor return 0; 40226035Sgabor return 1; 41226035Sgabor} 42226035Sgabor 43226035Sgaborstatic int coalesced_mmio_has_room(struct kvm_coalesced_mmio_dev *dev, u32 last) 44226035Sgabor{ 45226035Sgabor struct kvm_coalesced_mmio_ring *ring; 46226035Sgabor unsigned avail; 47226035Sgabor 48226035Sgabor /* Are we able to batch it ? */ 49226035Sgabor 50226035Sgabor /* last is the first free entry 51226035Sgabor * check if we don't meet the first used entry 52226035Sgabor * there is always one unused entry in the buffer 53226035Sgabor */ 54226035Sgabor ring = dev->kvm->coalesced_mmio_ring; 55226035Sgabor avail = (ring->first - last - 1) % KVM_COALESCED_MMIO_MAX; 56226035Sgabor if (avail == 0) { 57226035Sgabor /* full */ 58226035Sgabor return 0; 59226035Sgabor } 60226035Sgabor 61226035Sgabor return 1; 62226035Sgabor} 63226035Sgabor 64226035Sgaborstatic int coalesced_mmio_write(struct kvm_vcpu *vcpu, 65226035Sgabor struct kvm_io_device *this, gpa_t addr, 66226035Sgabor int len, const void *val) 67226035Sgabor{ 68226035Sgabor struct kvm_coalesced_mmio_dev *dev = to_mmio(this); 69226035Sgabor struct kvm_coalesced_mmio_ring *ring = dev->kvm->coalesced_mmio_ring; 70226035Sgabor __u32 insert; 71226035Sgabor 72226035Sgabor if (!coalesced_mmio_in_range(dev, addr, len)) 73226035Sgabor return -EOPNOTSUPP; 74226035Sgabor 75226035Sgabor spin_lock(&dev->kvm->ring_lock); 76226035Sgabor 77226035Sgabor insert = READ_ONCE(ring->last); 78226035Sgabor if (!coalesced_mmio_has_room(dev, insert) || 79226035Sgabor insert >= KVM_COALESCED_MMIO_MAX) { 80226035Sgabor spin_unlock(&dev->kvm->ring_lock); 81226035Sgabor return -EOPNOTSUPP; 82226035Sgabor } 83226035Sgabor 84226035Sgabor /* copy data in first free entry of the ring */ 85226035Sgabor 86226035Sgabor ring->coalesced_mmio[insert].phys_addr = addr; 87226035Sgabor ring->coalesced_mmio[insert].len = len; 88226035Sgabor memcpy(ring->coalesced_mmio[insert].data, val, len); 89226035Sgabor ring->coalesced_mmio[insert].pio = dev->zone.pio; 90226035Sgabor smp_wmb(); 91226035Sgabor ring->last = (insert + 1) % KVM_COALESCED_MMIO_MAX; 92226035Sgabor spin_unlock(&dev->kvm->ring_lock); 93226035Sgabor return 0; 94226035Sgabor} 95226035Sgabor 96static void coalesced_mmio_destructor(struct kvm_io_device *this) 97{ 98 struct kvm_coalesced_mmio_dev *dev = to_mmio(this); 99 100 list_del(&dev->list); 101 102 kfree(dev); 103} 104 105static const struct kvm_io_device_ops coalesced_mmio_ops = { 106 .write = coalesced_mmio_write, 107 .destructor = coalesced_mmio_destructor, 108}; 109 110int kvm_coalesced_mmio_init(struct kvm *kvm) 111{ 112 struct page *page; 113 114 page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO); 115 if (!page) 116 return -ENOMEM; 117 118 kvm->coalesced_mmio_ring = page_address(page); 119 120 /* 121 * We're using this spinlock to sync access to the coalesced ring. 122 * The list doesn't need its own lock since device registration and 123 * unregistration should only happen when kvm->slots_lock is held. 124 */ 125 spin_lock_init(&kvm->ring_lock); 126 INIT_LIST_HEAD(&kvm->coalesced_zones); 127 128 return 0; 129} 130 131void kvm_coalesced_mmio_free(struct kvm *kvm) 132{ 133 if (kvm->coalesced_mmio_ring) 134 free_page((unsigned long)kvm->coalesced_mmio_ring); 135} 136 137int kvm_vm_ioctl_register_coalesced_mmio(struct kvm *kvm, 138 struct kvm_coalesced_mmio_zone *zone) 139{ 140 int ret; 141 struct kvm_coalesced_mmio_dev *dev; 142 143 if (zone->pio != 1 && zone->pio != 0) 144 return -EINVAL; 145 146 dev = kzalloc(sizeof(struct kvm_coalesced_mmio_dev), 147 GFP_KERNEL_ACCOUNT); 148 if (!dev) 149 return -ENOMEM; 150 151 kvm_iodevice_init(&dev->dev, &coalesced_mmio_ops); 152 dev->kvm = kvm; 153 dev->zone = *zone; 154 155 mutex_lock(&kvm->slots_lock); 156 ret = kvm_io_bus_register_dev(kvm, 157 zone->pio ? KVM_PIO_BUS : KVM_MMIO_BUS, 158 zone->addr, zone->size, &dev->dev); 159 if (ret < 0) 160 goto out_free_dev; 161 list_add_tail(&dev->list, &kvm->coalesced_zones); 162 mutex_unlock(&kvm->slots_lock); 163 164 return 0; 165 166out_free_dev: 167 mutex_unlock(&kvm->slots_lock); 168 kfree(dev); 169 170 return ret; 171} 172 173int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm, 174 struct kvm_coalesced_mmio_zone *zone) 175{ 176 struct kvm_coalesced_mmio_dev *dev, *tmp; 177 int r; 178 179 if (zone->pio != 1 && zone->pio != 0) 180 return -EINVAL; 181 182 mutex_lock(&kvm->slots_lock); 183 184 list_for_each_entry_safe(dev, tmp, &kvm->coalesced_zones, list) { 185 if (zone->pio == dev->zone.pio && 186 coalesced_mmio_in_range(dev, zone->addr, zone->size)) { 187 r = kvm_io_bus_unregister_dev(kvm, 188 zone->pio ? KVM_PIO_BUS : KVM_MMIO_BUS, &dev->dev); 189 /* 190 * On failure, unregister destroys all devices on the 191 * bus, including the target device. There's no need 192 * to restart the walk as there aren't any zones left. 193 */ 194 if (r) 195 break; 196 } 197 } 198 199 mutex_unlock(&kvm->slots_lock); 200 201 /* 202 * Ignore the result of kvm_io_bus_unregister_dev(), from userspace's 203 * perspective, the coalesced MMIO is most definitely unregistered. 204 */ 205 return 0; 206} 207