gzvm_ioeventfd.c 5.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (c) 2023 MediaTek Inc.
  4. */
  5. #include <linux/eventfd.h>
  6. #include <linux/file.h>
  7. #include <linux/syscalls.h>
  8. #include <linux/gzvm.h>
  9. #include <linux/gzvm_drv.h>
  10. #include <linux/wait.h>
  11. #include <linux/poll.h>
  12. #include <linux/module.h>
  13. #include <linux/slab.h>
  14. struct gzvm_ioevent {
  15. struct list_head list;
  16. __u64 addr;
  17. __u32 len;
  18. struct eventfd_ctx *evt_ctx;
  19. __u64 datamatch;
  20. bool wildcard;
  21. };
  22. /**
  23. * ioeventfd_check_collision() - Check collison assumes gzvm->slots_lock held.
  24. * @gzvm: Pointer to gzvm.
  25. * @p: Pointer to gzvm_ioevent.
  26. *
  27. * Return:
  28. * * true - collison found
  29. * * false - no collison
  30. */
  31. static bool ioeventfd_check_collision(struct gzvm *gzvm, struct gzvm_ioevent *p)
  32. {
  33. struct gzvm_ioevent *_p;
  34. list_for_each_entry(_p, &gzvm->ioevents, list) {
  35. if (_p->addr == p->addr &&
  36. (!_p->len || !p->len ||
  37. (_p->len == p->len &&
  38. (_p->wildcard || p->wildcard ||
  39. _p->datamatch == p->datamatch))))
  40. return true;
  41. if (p->addr >= _p->addr && p->addr < _p->addr + _p->len)
  42. return true;
  43. }
  44. return false;
  45. }
  46. static void gzvm_ioevent_release(struct gzvm_ioevent *p)
  47. {
  48. eventfd_ctx_put(p->evt_ctx);
  49. list_del(&p->list);
  50. kfree(p);
  51. }
  52. static bool gzvm_ioevent_in_range(struct gzvm_ioevent *p, __u64 addr, int len,
  53. const void *val)
  54. {
  55. u64 _val;
  56. if (addr != p->addr)
  57. /* address must be precise for a hit */
  58. return false;
  59. if (!p->len)
  60. /* length = 0 means only look at the address, so always a hit */
  61. return true;
  62. if (len != p->len)
  63. /* address-range must be precise for a hit */
  64. return false;
  65. if (p->wildcard)
  66. /* all else equal, wildcard is always a hit */
  67. return true;
  68. /* otherwise, we have to actually compare the data */
  69. WARN_ON_ONCE(!IS_ALIGNED((unsigned long)val, len));
  70. switch (len) {
  71. case 1:
  72. _val = *(u8 *)val;
  73. break;
  74. case 2:
  75. _val = *(u16 *)val;
  76. break;
  77. case 4:
  78. _val = *(u32 *)val;
  79. break;
  80. case 8:
  81. _val = *(u64 *)val;
  82. break;
  83. default:
  84. return false;
  85. }
  86. return _val == p->datamatch;
  87. }
  88. static int gzvm_deassign_ioeventfd(struct gzvm *gzvm,
  89. struct gzvm_ioeventfd *args)
  90. {
  91. struct gzvm_ioevent *p, *tmp;
  92. struct eventfd_ctx *evt_ctx;
  93. int ret = -ENOENT;
  94. bool wildcard;
  95. evt_ctx = eventfd_ctx_fdget(args->fd);
  96. if (IS_ERR(evt_ctx))
  97. return PTR_ERR(evt_ctx);
  98. wildcard = !(args->flags & GZVM_IOEVENTFD_FLAG_DATAMATCH);
  99. mutex_lock(&gzvm->lock);
  100. list_for_each_entry_safe(p, tmp, &gzvm->ioevents, list) {
  101. if (p->evt_ctx != evt_ctx ||
  102. p->addr != args->addr ||
  103. p->len != args->len ||
  104. p->wildcard != wildcard)
  105. continue;
  106. if (!p->wildcard && p->datamatch != args->datamatch)
  107. continue;
  108. gzvm_ioevent_release(p);
  109. ret = 0;
  110. break;
  111. }
  112. mutex_unlock(&gzvm->lock);
  113. /* got in the front of this function */
  114. eventfd_ctx_put(evt_ctx);
  115. return ret;
  116. }
  117. static int gzvm_assign_ioeventfd(struct gzvm *gzvm, struct gzvm_ioeventfd *args)
  118. {
  119. struct eventfd_ctx *evt_ctx;
  120. struct gzvm_ioevent *evt;
  121. int ret;
  122. evt_ctx = eventfd_ctx_fdget(args->fd);
  123. if (IS_ERR(evt_ctx))
  124. return PTR_ERR(evt_ctx);
  125. evt = kmalloc(sizeof(*evt), GFP_KERNEL);
  126. if (!evt)
  127. return -ENOMEM;
  128. *evt = (struct gzvm_ioevent) {
  129. .addr = args->addr,
  130. .len = args->len,
  131. .evt_ctx = evt_ctx,
  132. };
  133. if (args->flags & GZVM_IOEVENTFD_FLAG_DATAMATCH) {
  134. evt->datamatch = args->datamatch;
  135. evt->wildcard = false;
  136. } else {
  137. evt->wildcard = true;
  138. }
  139. if (ioeventfd_check_collision(gzvm, evt)) {
  140. ret = -EEXIST;
  141. goto err_free;
  142. }
  143. mutex_lock(&gzvm->lock);
  144. list_add_tail(&evt->list, &gzvm->ioevents);
  145. mutex_unlock(&gzvm->lock);
  146. return 0;
  147. err_free:
  148. kfree(evt);
  149. eventfd_ctx_put(evt_ctx);
  150. return ret;
  151. }
  152. /**
  153. * gzvm_ioeventfd_check_valid() - Check user arguments is valid.
  154. * @args: Pointer to gzvm_ioeventfd.
  155. *
  156. * Return:
  157. * * true if user arguments are valid.
  158. * * false if user arguments are invalid.
  159. */
  160. static bool gzvm_ioeventfd_check_valid(struct gzvm_ioeventfd *args)
  161. {
  162. /* must be natural-word sized, or 0 to ignore length */
  163. switch (args->len) {
  164. case 0:
  165. case 1:
  166. case 2:
  167. case 4:
  168. case 8:
  169. break;
  170. default:
  171. return false;
  172. }
  173. /* check for range overflow */
  174. if (args->addr + args->len < args->addr)
  175. return false;
  176. /* check for extra flags that we don't understand */
  177. if (args->flags & ~GZVM_IOEVENTFD_VALID_FLAG_MASK)
  178. return false;
  179. /* ioeventfd with no length can't be combined with DATAMATCH */
  180. if (!args->len && (args->flags & GZVM_IOEVENTFD_FLAG_DATAMATCH))
  181. return false;
  182. /* gzvm does not support pio bus ioeventfd */
  183. if (args->flags & GZVM_IOEVENTFD_FLAG_PIO)
  184. return false;
  185. return true;
  186. }
  187. /**
  188. * gzvm_ioeventfd() - Register ioevent to ioevent list.
  189. * @gzvm: Pointer to gzvm.
  190. * @args: Pointer to gzvm_ioeventfd.
  191. *
  192. * Return:
  193. * * 0 - Success.
  194. * * Negative - Failure.
  195. */
  196. int gzvm_ioeventfd(struct gzvm *gzvm, struct gzvm_ioeventfd *args)
  197. {
  198. if (gzvm_ioeventfd_check_valid(args) == false)
  199. return -EINVAL;
  200. if (args->flags & GZVM_IOEVENTFD_FLAG_DEASSIGN)
  201. return gzvm_deassign_ioeventfd(gzvm, args);
  202. return gzvm_assign_ioeventfd(gzvm, args);
  203. }
  204. /**
  205. * gzvm_ioevent_write() - Travers this vm's registered ioeventfd to see if
  206. * need notifying it.
  207. * @vcpu: Pointer to vcpu.
  208. * @addr: mmio address.
  209. * @len: mmio size.
  210. * @val: Pointer to void.
  211. *
  212. * Return:
  213. * * true if this io is already sent to ioeventfd's listener.
  214. * * false if we cannot find any ioeventfd registering this mmio write.
  215. */
  216. bool gzvm_ioevent_write(struct gzvm_vcpu *vcpu, __u64 addr, int len,
  217. const void *val)
  218. {
  219. struct gzvm_ioevent *e;
  220. list_for_each_entry(e, &vcpu->gzvm->ioevents, list) {
  221. if (gzvm_ioevent_in_range(e, addr, len, val)) {
  222. eventfd_signal(e->evt_ctx, 1);
  223. return true;
  224. }
  225. }
  226. return false;
  227. }
  228. int gzvm_init_ioeventfd(struct gzvm *gzvm)
  229. {
  230. INIT_LIST_HEAD(&gzvm->ioevents);
  231. return 0;
  232. }