1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * KVM coalesced MMIO 4 * 5 * Copyright (c) 2008 Bull S.A.S. 6 * Copyright 2009 Red Hat, Inc. and/or its affiliates. 7 * 8 * Author: Laurent Vivier <Laurent.Vivier@bull.net> 9 * 10 */ 11 12 #include <kvm/iodev.h> 13 14 #include <linux/kvm_host.h> 15 #include <linux/slab.h> 16 #include <linux/kvm.h> 17 18 #include "coalesced_mmio.h" 19 20 static inline struct kvm_coalesced_mmio_dev *to_mmio(struct kvm_io_device *dev) 21 { 22 return container_of(dev, struct kvm_coalesced_mmio_dev, dev); 23 } 24 25 static int coalesced_mmio_in_range(struct kvm_coalesced_mmio_dev *dev, 26 gpa_t addr, int len) 27 { 28 /* is it in a batchable area ? 29 * (addr,len) is fully included in 30 * (zone->addr, zone->size) 31 */ 32 if (len < 0) 33 return 0; 34 if (addr + len < addr) 35 return 0; 36 if (addr < dev->zone.addr) 37 return 0; 38 if (addr + len > dev->zone.addr + dev->zone.size) 39 return 0; 40 return 1; 41 } 42 43 static int coalesced_mmio_has_room(struct kvm_coalesced_mmio_dev *dev, u32 last) 44 { 45 struct kvm_coalesced_mmio_ring *ring; 46 unsigned avail; 47 48 /* Are we able to batch it ? */ 49 50 /* last is the first free entry 51 * check if we don't meet the first used entry 52 * there is always one unused entry in the buffer 53 */ 54 ring = dev->kvm->coalesced_mmio_ring; 55 avail = (ring->first - last - 1) % KVM_COALESCED_MMIO_MAX; 56 if (avail == 0) { 57 /* full */ 58 return 0; 59 } 60 61 return 1; 62 } 63 64 static int coalesced_mmio_write(struct kvm_vcpu *vcpu, 65 struct kvm_io_device *this, gpa_t addr, 66 int len, const void *val) 67 { 68 struct kvm_coalesced_mmio_dev *dev = to_mmio(this); 69 struct kvm_coalesced_mmio_ring *ring = dev->kvm->coalesced_mmio_ring; 70 __u32 insert; 71 72 if (!coalesced_mmio_in_range(dev, addr, len)) 73 return -EOPNOTSUPP; 74 75 spin_lock(&dev->kvm->ring_lock); 76 77 insert = READ_ONCE(ring->last); 78 if (!coalesced_mmio_has_room(dev, insert) || 79 insert >= KVM_COALESCED_MMIO_MAX) { 80 spin_unlock(&dev->kvm->ring_lock); 81 return -EOPNOTSUPP; 82 } 83 84 /* copy data in first free entry of the ring */ 85 86 ring->coalesced_mmio[insert].phys_addr = addr; 87 ring->coalesced_mmio[insert].len = len; 88 memcpy(ring->coalesced_mmio[insert].data, val, len); 89 ring->coalesced_mmio[insert].pio = dev->zone.pio; 90 smp_wmb(); 91 ring->last = (insert + 1) % KVM_COALESCED_MMIO_MAX; 92 spin_unlock(&dev->kvm->ring_lock); 93 return 0; 94 } 95 96 static 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 105 static const struct kvm_io_device_ops coalesced_mmio_ops = { 106 .write = coalesced_mmio_write, 107 .destructor = coalesced_mmio_destructor, 108 }; 109 110 int kvm_coalesced_mmio_init(struct kvm *kvm) 111 { 112 struct page *page; 113 int ret; 114 115 ret = -ENOMEM; 116 page = alloc_page(GFP_KERNEL | __GFP_ZERO); 117 if (!page) 118 goto out_err; 119 120 ret = 0; 121 kvm->coalesced_mmio_ring = page_address(page); 122 123 /* 124 * We're using this spinlock to sync access to the coalesced ring. 125 * The list doesn't need it's own lock since device registration and 126 * unregistration should only happen when kvm->slots_lock is held. 127 */ 128 spin_lock_init(&kvm->ring_lock); 129 INIT_LIST_HEAD(&kvm->coalesced_zones); 130 131 out_err: 132 return ret; 133 } 134 135 void kvm_coalesced_mmio_free(struct kvm *kvm) 136 { 137 if (kvm->coalesced_mmio_ring) 138 free_page((unsigned long)kvm->coalesced_mmio_ring); 139 } 140 141 int kvm_vm_ioctl_register_coalesced_mmio(struct kvm *kvm, 142 struct kvm_coalesced_mmio_zone *zone) 143 { 144 int ret; 145 struct kvm_coalesced_mmio_dev *dev; 146 147 if (zone->pio != 1 && zone->pio != 0) 148 return -EINVAL; 149 150 dev = kzalloc(sizeof(struct kvm_coalesced_mmio_dev), 151 GFP_KERNEL_ACCOUNT); 152 if (!dev) 153 return -ENOMEM; 154 155 kvm_iodevice_init(&dev->dev, &coalesced_mmio_ops); 156 dev->kvm = kvm; 157 dev->zone = *zone; 158 159 mutex_lock(&kvm->slots_lock); 160 ret = kvm_io_bus_register_dev(kvm, 161 zone->pio ? KVM_PIO_BUS : KVM_MMIO_BUS, 162 zone->addr, zone->size, &dev->dev); 163 if (ret < 0) 164 goto out_free_dev; 165 list_add_tail(&dev->list, &kvm->coalesced_zones); 166 mutex_unlock(&kvm->slots_lock); 167 168 return 0; 169 170 out_free_dev: 171 mutex_unlock(&kvm->slots_lock); 172 kfree(dev); 173 174 return ret; 175 } 176 177 int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm, 178 struct kvm_coalesced_mmio_zone *zone) 179 { 180 struct kvm_coalesced_mmio_dev *dev, *tmp; 181 182 if (zone->pio != 1 && zone->pio != 0) 183 return -EINVAL; 184 185 mutex_lock(&kvm->slots_lock); 186 187 list_for_each_entry_safe(dev, tmp, &kvm->coalesced_zones, list) 188 if (zone->pio == dev->zone.pio && 189 coalesced_mmio_in_range(dev, zone->addr, zone->size)) { 190 kvm_io_bus_unregister_dev(kvm, 191 zone->pio ? KVM_PIO_BUS : KVM_MMIO_BUS, &dev->dev); 192 kvm_iodevice_destructor(&dev->dev); 193 } 194 195 mutex_unlock(&kvm->slots_lock); 196 197 return 0; 198 } 199