grant_table.h 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341
  1. /******************************************************************************
  2. * grant_table.h
  3. *
  4. * Two sets of functionality:
  5. * 1. Granting foreign access to our memory reservation.
  6. * 2. Accessing others' memory reservations via grant references.
  7. * (i.e., mechanisms for both sender and recipient of grant references)
  8. *
  9. * Copyright (c) 2004-2005, K A Fraser
  10. * Copyright (c) 2005, Christopher Clark
  11. *
  12. * This program is free software; you can redistribute it and/or
  13. * modify it under the terms of the GNU General Public License version 2
  14. * as published by the Free Software Foundation; or, when distributed
  15. * separately from the Linux kernel or incorporated into other
  16. * software packages, subject to the following license:
  17. *
  18. * Permission is hereby granted, free of charge, to any person obtaining a copy
  19. * of this source file (the "Software"), to deal in the Software without
  20. * restriction, including without limitation the rights to use, copy, modify,
  21. * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  22. * and to permit persons to whom the Software is furnished to do so, subject to
  23. * the following conditions:
  24. *
  25. * The above copyright notice and this permission notice shall be included in
  26. * all copies or substantial portions of the Software.
  27. *
  28. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  29. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  30. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  31. * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  32. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  33. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  34. * IN THE SOFTWARE.
  35. */
  36. #ifndef __ASM_GNTTAB_H__
  37. #define __ASM_GNTTAB_H__
  38. #include <asm/page.h>
  39. #include <xen/interface/xen.h>
  40. #include <xen/interface/grant_table.h>
  41. #include <asm/xen/hypervisor.h>
  42. #include <xen/features.h>
  43. #include <xen/page.h>
  44. #include <linux/mm_types.h>
  45. #include <linux/page-flags.h>
  46. #include <linux/kernel.h>
  47. /*
  48. * Technically there's no reliably invalid grant reference or grant handle,
  49. * so pick the value that is the most unlikely one to be observed valid.
  50. */
  51. #define INVALID_GRANT_REF ((grant_ref_t)-1)
  52. #define INVALID_GRANT_HANDLE ((grant_handle_t)-1)
  53. /* NR_GRANT_FRAMES must be less than or equal to that configured in Xen */
  54. #define NR_GRANT_FRAMES 4
  55. struct gnttab_free_callback {
  56. struct gnttab_free_callback *next;
  57. void (*fn)(void *);
  58. void *arg;
  59. u16 count;
  60. };
  61. struct gntab_unmap_queue_data;
  62. typedef void (*gnttab_unmap_refs_done)(int result, struct gntab_unmap_queue_data *data);
  63. struct gntab_unmap_queue_data
  64. {
  65. struct delayed_work gnttab_work;
  66. void *data;
  67. gnttab_unmap_refs_done done;
  68. struct gnttab_unmap_grant_ref *unmap_ops;
  69. struct gnttab_unmap_grant_ref *kunmap_ops;
  70. struct page **pages;
  71. unsigned int count;
  72. unsigned int age;
  73. };
  74. int gnttab_init(void);
  75. int gnttab_suspend(void);
  76. int gnttab_resume(void);
  77. int gnttab_grant_foreign_access(domid_t domid, unsigned long frame,
  78. int readonly);
  79. /*
  80. * End access through the given grant reference, iff the grant entry is no
  81. * longer in use. Return 1 if the grant entry was freed, 0 if it is still in
  82. * use.
  83. */
  84. int gnttab_end_foreign_access_ref(grant_ref_t ref);
  85. /*
  86. * Eventually end access through the given grant reference, and once that
  87. * access has been ended, free the given page too. Access will be ended
  88. * immediately iff the grant entry is not in use, otherwise it will happen
  89. * some time later. page may be NULL, in which case no freeing will occur.
  90. * Note that the granted page might still be accessed (read or write) by the
  91. * other side after gnttab_end_foreign_access() returns, so even if page was
  92. * specified as NULL it is not allowed to just reuse the page for other
  93. * purposes immediately. gnttab_end_foreign_access() will take an additional
  94. * reference to the granted page in this case, which is dropped only after
  95. * the grant is no longer in use.
  96. * This requires that multi page allocations for areas subject to
  97. * gnttab_end_foreign_access() are done via alloc_pages_exact() (and freeing
  98. * via free_pages_exact()) in order to avoid high order pages.
  99. */
  100. void gnttab_end_foreign_access(grant_ref_t ref, struct page *page);
  101. /*
  102. * End access through the given grant reference, iff the grant entry is
  103. * no longer in use. In case of success ending foreign access, the
  104. * grant reference is deallocated.
  105. * Return 1 if the grant entry was freed, 0 if it is still in use.
  106. */
  107. int gnttab_try_end_foreign_access(grant_ref_t ref);
  108. /*
  109. * operations on reserved batches of grant references
  110. */
  111. int gnttab_alloc_grant_references(u16 count, grant_ref_t *pprivate_head);
  112. int gnttab_alloc_grant_reference_seq(unsigned int count, grant_ref_t *first);
  113. void gnttab_free_grant_reference(grant_ref_t ref);
  114. void gnttab_free_grant_references(grant_ref_t head);
  115. void gnttab_free_grant_reference_seq(grant_ref_t head, unsigned int count);
  116. int gnttab_empty_grant_references(const grant_ref_t *pprivate_head);
  117. int gnttab_claim_grant_reference(grant_ref_t *pprivate_head);
  118. void gnttab_release_grant_reference(grant_ref_t *private_head,
  119. grant_ref_t release);
  120. void gnttab_request_free_callback(struct gnttab_free_callback *callback,
  121. void (*fn)(void *), void *arg, u16 count);
  122. void gnttab_cancel_free_callback(struct gnttab_free_callback *callback);
  123. void gnttab_grant_foreign_access_ref(grant_ref_t ref, domid_t domid,
  124. unsigned long frame, int readonly);
  125. /* Give access to the first 4K of the page */
  126. static inline void gnttab_page_grant_foreign_access_ref_one(
  127. grant_ref_t ref, domid_t domid,
  128. struct page *page, int readonly)
  129. {
  130. gnttab_grant_foreign_access_ref(ref, domid, xen_page_to_gfn(page),
  131. readonly);
  132. }
  133. static inline void
  134. gnttab_set_map_op(struct gnttab_map_grant_ref *map, phys_addr_t addr,
  135. uint32_t flags, grant_ref_t ref, domid_t domid)
  136. {
  137. if (flags & GNTMAP_contains_pte)
  138. map->host_addr = addr;
  139. else if (xen_feature(XENFEAT_auto_translated_physmap))
  140. map->host_addr = __pa(addr);
  141. else
  142. map->host_addr = addr;
  143. map->flags = flags;
  144. map->ref = ref;
  145. map->dom = domid;
  146. map->status = 1; /* arbitrary positive value */
  147. }
  148. static inline void
  149. gnttab_set_unmap_op(struct gnttab_unmap_grant_ref *unmap, phys_addr_t addr,
  150. uint32_t flags, grant_handle_t handle)
  151. {
  152. if (flags & GNTMAP_contains_pte)
  153. unmap->host_addr = addr;
  154. else if (xen_feature(XENFEAT_auto_translated_physmap))
  155. unmap->host_addr = __pa(addr);
  156. else
  157. unmap->host_addr = addr;
  158. unmap->handle = handle;
  159. unmap->dev_bus_addr = 0;
  160. }
  161. int arch_gnttab_init(unsigned long nr_shared, unsigned long nr_status);
  162. int arch_gnttab_map_shared(xen_pfn_t *frames, unsigned long nr_gframes,
  163. unsigned long max_nr_gframes,
  164. void **__shared);
  165. int arch_gnttab_map_status(uint64_t *frames, unsigned long nr_gframes,
  166. unsigned long max_nr_gframes,
  167. grant_status_t **__shared);
  168. void arch_gnttab_unmap(void *shared, unsigned long nr_gframes);
  169. struct grant_frames {
  170. xen_pfn_t *pfn;
  171. unsigned int count;
  172. void *vaddr;
  173. };
  174. extern struct grant_frames xen_auto_xlat_grant_frames;
  175. unsigned int gnttab_max_grant_frames(void);
  176. int gnttab_setup_auto_xlat_frames(phys_addr_t addr);
  177. void gnttab_free_auto_xlat_frames(void);
  178. #define gnttab_map_vaddr(map) ((void *)(map.host_virt_addr))
  179. int gnttab_alloc_pages(int nr_pages, struct page **pages);
  180. void gnttab_free_pages(int nr_pages, struct page **pages);
  181. struct gnttab_page_cache {
  182. spinlock_t lock;
  183. #ifdef CONFIG_XEN_UNPOPULATED_ALLOC
  184. struct page *pages;
  185. #else
  186. struct list_head pages;
  187. #endif
  188. unsigned int num_pages;
  189. };
  190. void gnttab_page_cache_init(struct gnttab_page_cache *cache);
  191. int gnttab_page_cache_get(struct gnttab_page_cache *cache, struct page **page);
  192. void gnttab_page_cache_put(struct gnttab_page_cache *cache, struct page **page,
  193. unsigned int num);
  194. void gnttab_page_cache_shrink(struct gnttab_page_cache *cache,
  195. unsigned int num);
  196. #ifdef CONFIG_XEN_GRANT_DMA_ALLOC
  197. struct gnttab_dma_alloc_args {
  198. /* Device for which DMA memory will be/was allocated. */
  199. struct device *dev;
  200. /* If set then DMA buffer is coherent and write-combine otherwise. */
  201. bool coherent;
  202. int nr_pages;
  203. struct page **pages;
  204. xen_pfn_t *frames;
  205. void *vaddr;
  206. dma_addr_t dev_bus_addr;
  207. };
  208. int gnttab_dma_alloc_pages(struct gnttab_dma_alloc_args *args);
  209. int gnttab_dma_free_pages(struct gnttab_dma_alloc_args *args);
  210. #endif
  211. int gnttab_pages_set_private(int nr_pages, struct page **pages);
  212. void gnttab_pages_clear_private(int nr_pages, struct page **pages);
  213. int gnttab_map_refs(struct gnttab_map_grant_ref *map_ops,
  214. struct gnttab_map_grant_ref *kmap_ops,
  215. struct page **pages, unsigned int count);
  216. int gnttab_unmap_refs(struct gnttab_unmap_grant_ref *unmap_ops,
  217. struct gnttab_unmap_grant_ref *kunmap_ops,
  218. struct page **pages, unsigned int count);
  219. void gnttab_unmap_refs_async(struct gntab_unmap_queue_data* item);
  220. int gnttab_unmap_refs_sync(struct gntab_unmap_queue_data *item);
  221. /* Perform a batch of grant map/copy operations. Retry every batch slot
  222. * for which the hypervisor returns GNTST_eagain. This is typically due
  223. * to paged out target frames.
  224. *
  225. * Will retry for 1, 2, ... 255 ms, i.e. 256 times during 32 seconds.
  226. *
  227. * Return value in each iand every status field of the batch guaranteed
  228. * to not be GNTST_eagain.
  229. */
  230. void gnttab_batch_map(struct gnttab_map_grant_ref *batch, unsigned count);
  231. void gnttab_batch_copy(struct gnttab_copy *batch, unsigned count);
  232. struct xen_page_foreign {
  233. domid_t domid;
  234. grant_ref_t gref;
  235. };
  236. static inline struct xen_page_foreign *xen_page_foreign(struct page *page)
  237. {
  238. if (!PageForeign(page))
  239. return NULL;
  240. #if BITS_PER_LONG < 64
  241. return (struct xen_page_foreign *)page->private;
  242. #else
  243. BUILD_BUG_ON(sizeof(struct xen_page_foreign) > BITS_PER_LONG);
  244. return (struct xen_page_foreign *)&page->private;
  245. #endif
  246. }
  247. /* Split Linux page in chunk of the size of the grant and call fn
  248. *
  249. * Parameters of fn:
  250. * gfn: guest frame number
  251. * offset: offset in the grant
  252. * len: length of the data in the grant.
  253. * data: internal information
  254. */
  255. typedef void (*xen_grant_fn_t)(unsigned long gfn, unsigned int offset,
  256. unsigned int len, void *data);
  257. void gnttab_foreach_grant_in_range(struct page *page,
  258. unsigned int offset,
  259. unsigned int len,
  260. xen_grant_fn_t fn,
  261. void *data);
  262. /* Helper to get to call fn only on the first "grant chunk" */
  263. static inline void gnttab_for_one_grant(struct page *page, unsigned int offset,
  264. unsigned len, xen_grant_fn_t fn,
  265. void *data)
  266. {
  267. /* The first request is limited to the size of one grant */
  268. len = min_t(unsigned int, XEN_PAGE_SIZE - (offset & ~XEN_PAGE_MASK),
  269. len);
  270. gnttab_foreach_grant_in_range(page, offset, len, fn, data);
  271. }
  272. /* Get @nr_grefs grants from an array of page and call fn for each grant */
  273. void gnttab_foreach_grant(struct page **pages,
  274. unsigned int nr_grefs,
  275. xen_grant_fn_t fn,
  276. void *data);
  277. /* Get the number of grant in a specified region
  278. *
  279. * start: Offset from the beginning of the first page
  280. * len: total length of data (can cross multiple page)
  281. */
  282. static inline unsigned int gnttab_count_grant(unsigned int start,
  283. unsigned int len)
  284. {
  285. return XEN_PFN_UP(xen_offset_in_page(start) + len);
  286. }
  287. #endif /* __ASM_GNTTAB_H__ */