coalesced_mmio.c 4.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211
  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 <[email protected]>
  9. *
  10. */
  11. #include <kvm/iodev.h>
  12. #include <linux/kvm_host.h>
  13. #include <linux/slab.h>
  14. #include <linux/kvm.h>
  15. #include "coalesced_mmio.h"
  16. static inline struct kvm_coalesced_mmio_dev *to_mmio(struct kvm_io_device *dev)
  17. {
  18. return container_of(dev, struct kvm_coalesced_mmio_dev, dev);
  19. }
  20. static int coalesced_mmio_in_range(struct kvm_coalesced_mmio_dev *dev,
  21. gpa_t addr, int len)
  22. {
  23. /* is it in a batchable area ?
  24. * (addr,len) is fully included in
  25. * (zone->addr, zone->size)
  26. */
  27. if (len < 0)
  28. return 0;
  29. if (addr + len < addr)
  30. return 0;
  31. if (addr < dev->zone.addr)
  32. return 0;
  33. if (addr + len > dev->zone.addr + dev->zone.size)
  34. return 0;
  35. return 1;
  36. }
  37. static int coalesced_mmio_has_room(struct kvm_coalesced_mmio_dev *dev, u32 last)
  38. {
  39. struct kvm_coalesced_mmio_ring *ring;
  40. unsigned avail;
  41. /* Are we able to batch it ? */
  42. /* last is the first free entry
  43. * check if we don't meet the first used entry
  44. * there is always one unused entry in the buffer
  45. */
  46. ring = dev->kvm->coalesced_mmio_ring;
  47. avail = (ring->first - last - 1) % KVM_COALESCED_MMIO_MAX;
  48. if (avail == 0) {
  49. /* full */
  50. return 0;
  51. }
  52. return 1;
  53. }
  54. static int coalesced_mmio_write(struct kvm_vcpu *vcpu,
  55. struct kvm_io_device *this, gpa_t addr,
  56. int len, const void *val)
  57. {
  58. struct kvm_coalesced_mmio_dev *dev = to_mmio(this);
  59. struct kvm_coalesced_mmio_ring *ring = dev->kvm->coalesced_mmio_ring;
  60. __u32 insert;
  61. if (!coalesced_mmio_in_range(dev, addr, len))
  62. return -EOPNOTSUPP;
  63. spin_lock(&dev->kvm->ring_lock);
  64. insert = READ_ONCE(ring->last);
  65. if (!coalesced_mmio_has_room(dev, insert) ||
  66. insert >= KVM_COALESCED_MMIO_MAX) {
  67. spin_unlock(&dev->kvm->ring_lock);
  68. return -EOPNOTSUPP;
  69. }
  70. /* copy data in first free entry of the ring */
  71. ring->coalesced_mmio[insert].phys_addr = addr;
  72. ring->coalesced_mmio[insert].len = len;
  73. memcpy(ring->coalesced_mmio[insert].data, val, len);
  74. ring->coalesced_mmio[insert].pio = dev->zone.pio;
  75. smp_wmb();
  76. ring->last = (insert + 1) % KVM_COALESCED_MMIO_MAX;
  77. spin_unlock(&dev->kvm->ring_lock);
  78. return 0;
  79. }
  80. static void coalesced_mmio_destructor(struct kvm_io_device *this)
  81. {
  82. struct kvm_coalesced_mmio_dev *dev = to_mmio(this);
  83. list_del(&dev->list);
  84. kfree(dev);
  85. }
  86. static const struct kvm_io_device_ops coalesced_mmio_ops = {
  87. .write = coalesced_mmio_write,
  88. .destructor = coalesced_mmio_destructor,
  89. };
  90. int kvm_coalesced_mmio_init(struct kvm *kvm)
  91. {
  92. struct page *page;
  93. page = alloc_page(GFP_KERNEL_ACCOUNT | __GFP_ZERO);
  94. if (!page)
  95. return -ENOMEM;
  96. kvm->coalesced_mmio_ring = page_address(page);
  97. /*
  98. * We're using this spinlock to sync access to the coalesced ring.
  99. * The list doesn't need its own lock since device registration and
  100. * unregistration should only happen when kvm->slots_lock is held.
  101. */
  102. spin_lock_init(&kvm->ring_lock);
  103. INIT_LIST_HEAD(&kvm->coalesced_zones);
  104. return 0;
  105. }
  106. void kvm_coalesced_mmio_free(struct kvm *kvm)
  107. {
  108. if (kvm->coalesced_mmio_ring)
  109. free_page((unsigned long)kvm->coalesced_mmio_ring);
  110. }
  111. int kvm_vm_ioctl_register_coalesced_mmio(struct kvm *kvm,
  112. struct kvm_coalesced_mmio_zone *zone)
  113. {
  114. int ret;
  115. struct kvm_coalesced_mmio_dev *dev;
  116. if (zone->pio != 1 && zone->pio != 0)
  117. return -EINVAL;
  118. dev = kzalloc(sizeof(struct kvm_coalesced_mmio_dev),
  119. GFP_KERNEL_ACCOUNT);
  120. if (!dev)
  121. return -ENOMEM;
  122. kvm_iodevice_init(&dev->dev, &coalesced_mmio_ops);
  123. dev->kvm = kvm;
  124. dev->zone = *zone;
  125. mutex_lock(&kvm->slots_lock);
  126. ret = kvm_io_bus_register_dev(kvm,
  127. zone->pio ? KVM_PIO_BUS : KVM_MMIO_BUS,
  128. zone->addr, zone->size, &dev->dev);
  129. if (ret < 0)
  130. goto out_free_dev;
  131. list_add_tail(&dev->list, &kvm->coalesced_zones);
  132. mutex_unlock(&kvm->slots_lock);
  133. return 0;
  134. out_free_dev:
  135. mutex_unlock(&kvm->slots_lock);
  136. kfree(dev);
  137. return ret;
  138. }
  139. int kvm_vm_ioctl_unregister_coalesced_mmio(struct kvm *kvm,
  140. struct kvm_coalesced_mmio_zone *zone)
  141. {
  142. struct kvm_coalesced_mmio_dev *dev, *tmp;
  143. int r;
  144. if (zone->pio != 1 && zone->pio != 0)
  145. return -EINVAL;
  146. mutex_lock(&kvm->slots_lock);
  147. list_for_each_entry_safe(dev, tmp, &kvm->coalesced_zones, list) {
  148. if (zone->pio == dev->zone.pio &&
  149. coalesced_mmio_in_range(dev, zone->addr, zone->size)) {
  150. r = kvm_io_bus_unregister_dev(kvm,
  151. zone->pio ? KVM_PIO_BUS : KVM_MMIO_BUS, &dev->dev);
  152. kvm_iodevice_destructor(&dev->dev);
  153. /*
  154. * On failure, unregister destroys all devices on the
  155. * bus _except_ the target device, i.e. coalesced_zones
  156. * has been modified. Bail after destroying the target
  157. * device, there's no need to restart the walk as there
  158. * aren't any zones left.
  159. */
  160. if (r)
  161. break;
  162. }
  163. }
  164. mutex_unlock(&kvm->slots_lock);
  165. /*
  166. * Ignore the result of kvm_io_bus_unregister_dev(), from userspace's
  167. * perspective, the coalesced MMIO is most definitely unregistered.
  168. */
  169. return 0;
  170. }