common.h 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348
  1. /*
  2. * This program is free software; you can redistribute it and/or
  3. * modify it under the terms of the GNU General Public License version 2
  4. * as published by the Free Software Foundation; or, when distributed
  5. * separately from the Linux kernel or incorporated into other
  6. * software packages, subject to the following license:
  7. *
  8. * Permission is hereby granted, free of charge, to any person obtaining a copy
  9. * of this source file (the "Software"), to deal in the Software without
  10. * restriction, including without limitation the rights to use, copy, modify,
  11. * merge, publish, distribute, sublicense, and/or sell copies of the Software,
  12. * and to permit persons to whom the Software is furnished to do so, subject to
  13. * the following conditions:
  14. *
  15. * The above copyright notice and this permission notice shall be included in
  16. * all copies or substantial portions of the Software.
  17. *
  18. * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19. * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20. * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21. * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22. * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23. * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  24. * IN THE SOFTWARE.
  25. */
  26. #ifndef __XEN_NETBACK__COMMON_H__
  27. #define __XEN_NETBACK__COMMON_H__
  28. #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
  29. #include <linux/module.h>
  30. #include <linux/interrupt.h>
  31. #include <linux/slab.h>
  32. #include <linux/ip.h>
  33. #include <linux/in.h>
  34. #include <linux/io.h>
  35. #include <linux/netdevice.h>
  36. #include <linux/etherdevice.h>
  37. #include <linux/wait.h>
  38. #include <linux/sched.h>
  39. #include <xen/interface/io/netif.h>
  40. #include <xen/interface/grant_table.h>
  41. #include <xen/grant_table.h>
  42. #include <xen/xenbus.h>
  43. #include <linux/debugfs.h>
  44. typedef unsigned int pending_ring_idx_t;
  45. #define INVALID_PENDING_RING_IDX (~0U)
  46. struct pending_tx_info {
  47. struct xen_netif_tx_request req; /* tx request */
  48. /* Callback data for released SKBs. The callback is always
  49. * xenvif_zerocopy_callback, desc contains the pending_idx, which is
  50. * also an index in pending_tx_info array. It is initialized in
  51. * xenvif_alloc and it never changes.
  52. * skb_shinfo(skb)->destructor_arg points to the first mapped slot's
  53. * callback_struct in this array of struct pending_tx_info's, then ctx
  54. * to the next, or NULL if there is no more slot for this skb.
  55. * ubuf_to_vif is a helper which finds the struct xenvif from a pointer
  56. * to this field.
  57. */
  58. struct ubuf_info callback_struct;
  59. };
  60. #define XEN_NETIF_TX_RING_SIZE __CONST_RING_SIZE(xen_netif_tx, PAGE_SIZE)
  61. #define XEN_NETIF_RX_RING_SIZE __CONST_RING_SIZE(xen_netif_rx, PAGE_SIZE)
  62. struct xenvif_rx_meta {
  63. int id;
  64. int size;
  65. int gso_type;
  66. int gso_size;
  67. };
  68. #define GSO_BIT(type) \
  69. (1 << XEN_NETIF_GSO_TYPE_ ## type)
  70. /* Discriminate from any valid pending_idx value. */
  71. #define INVALID_PENDING_IDX 0xFFFF
  72. #define MAX_BUFFER_OFFSET PAGE_SIZE
  73. #define MAX_PENDING_REQS XEN_NETIF_TX_RING_SIZE
  74. /* It's possible for an skb to have a maximal number of frags
  75. * but still be less than MAX_BUFFER_OFFSET in size. Thus the
  76. * worst-case number of copy operations is MAX_SKB_FRAGS per
  77. * ring slot.
  78. */
  79. #define MAX_GRANT_COPY_OPS (MAX_SKB_FRAGS * XEN_NETIF_RX_RING_SIZE)
  80. #define NETBACK_INVALID_HANDLE -1
  81. /* To avoid confusion, we define XEN_NETBK_LEGACY_SLOTS_MAX indicating
  82. * the maximum slots a valid packet can use. Now this value is defined
  83. * to be XEN_NETIF_NR_SLOTS_MIN, which is supposed to be supported by
  84. * all backend.
  85. */
  86. #define XEN_NETBK_LEGACY_SLOTS_MAX XEN_NETIF_NR_SLOTS_MIN
  87. /* Queue name is interface name with "-qNNN" appended */
  88. #define QUEUE_NAME_SIZE (IFNAMSIZ + 5)
  89. /* IRQ name is queue name with "-tx" or "-rx" appended */
  90. #define IRQ_NAME_SIZE (QUEUE_NAME_SIZE + 3)
  91. struct xenvif;
  92. struct xenvif_stats {
  93. /* Stats fields to be updated per-queue.
  94. * A subset of struct net_device_stats that contains only the
  95. * fields that are updated in netback.c for each queue.
  96. */
  97. unsigned int rx_bytes;
  98. unsigned int rx_packets;
  99. unsigned int tx_bytes;
  100. unsigned int tx_packets;
  101. /* Additional stats used by xenvif */
  102. unsigned long rx_gso_checksum_fixup;
  103. unsigned long tx_zerocopy_sent;
  104. unsigned long tx_zerocopy_success;
  105. unsigned long tx_zerocopy_fail;
  106. unsigned long tx_frag_overflow;
  107. };
  108. struct xenvif_queue { /* Per-queue data for xenvif */
  109. unsigned int id; /* Queue ID, 0-based */
  110. char name[QUEUE_NAME_SIZE]; /* DEVNAME-qN */
  111. struct xenvif *vif; /* Parent VIF */
  112. /* Use NAPI for guest TX */
  113. struct napi_struct napi;
  114. /* When feature-split-event-channels = 0, tx_irq = rx_irq. */
  115. unsigned int tx_irq;
  116. /* Only used when feature-split-event-channels = 1 */
  117. char tx_irq_name[IRQ_NAME_SIZE]; /* DEVNAME-qN-tx */
  118. struct xen_netif_tx_back_ring tx;
  119. struct sk_buff_head tx_queue;
  120. struct page *mmap_pages[MAX_PENDING_REQS];
  121. pending_ring_idx_t pending_prod;
  122. pending_ring_idx_t pending_cons;
  123. u16 pending_ring[MAX_PENDING_REQS];
  124. struct pending_tx_info pending_tx_info[MAX_PENDING_REQS];
  125. grant_handle_t grant_tx_handle[MAX_PENDING_REQS];
  126. struct gnttab_copy tx_copy_ops[MAX_PENDING_REQS];
  127. struct gnttab_map_grant_ref tx_map_ops[MAX_PENDING_REQS];
  128. struct gnttab_unmap_grant_ref tx_unmap_ops[MAX_PENDING_REQS];
  129. /* passed to gnttab_[un]map_refs with pages under (un)mapping */
  130. struct page *pages_to_map[MAX_PENDING_REQS];
  131. struct page *pages_to_unmap[MAX_PENDING_REQS];
  132. /* This prevents zerocopy callbacks to race over dealloc_ring */
  133. spinlock_t callback_lock;
  134. /* This prevents dealloc thread and NAPI instance to race over response
  135. * creation and pending_ring in xenvif_idx_release. In xenvif_tx_err
  136. * it only protect response creation
  137. */
  138. spinlock_t response_lock;
  139. pending_ring_idx_t dealloc_prod;
  140. pending_ring_idx_t dealloc_cons;
  141. u16 dealloc_ring[MAX_PENDING_REQS];
  142. struct task_struct *dealloc_task;
  143. wait_queue_head_t dealloc_wq;
  144. atomic_t inflight_packets;
  145. /* Use kthread for guest RX */
  146. struct task_struct *task;
  147. wait_queue_head_t wq;
  148. /* When feature-split-event-channels = 0, tx_irq = rx_irq. */
  149. unsigned int rx_irq;
  150. /* Only used when feature-split-event-channels = 1 */
  151. char rx_irq_name[IRQ_NAME_SIZE]; /* DEVNAME-qN-rx */
  152. struct xen_netif_rx_back_ring rx;
  153. struct sk_buff_head rx_queue;
  154. unsigned int rx_queue_max;
  155. unsigned int rx_queue_len;
  156. unsigned long last_rx_time;
  157. bool stalled;
  158. struct gnttab_copy grant_copy_op[MAX_GRANT_COPY_OPS];
  159. /* We create one meta structure per ring request we consume, so
  160. * the maximum number is the same as the ring size.
  161. */
  162. struct xenvif_rx_meta meta[XEN_NETIF_RX_RING_SIZE];
  163. /* Transmit shaping: allow 'credit_bytes' every 'credit_usec'. */
  164. unsigned long credit_bytes;
  165. unsigned long credit_usec;
  166. unsigned long remaining_credit;
  167. struct timer_list credit_timeout;
  168. u64 credit_window_start;
  169. /* Statistics */
  170. struct xenvif_stats stats;
  171. };
  172. /* Maximum number of Rx slots a to-guest packet may use, including the
  173. * slot needed for GSO meta-data.
  174. */
  175. #define XEN_NETBK_RX_SLOTS_MAX (MAX_SKB_FRAGS + 1)
  176. enum state_bit_shift {
  177. /* This bit marks that the vif is connected */
  178. VIF_STATUS_CONNECTED,
  179. };
  180. struct xenvif {
  181. /* Unique identifier for this interface. */
  182. domid_t domid;
  183. unsigned int handle;
  184. u8 fe_dev_addr[6];
  185. /* Frontend feature information. */
  186. int gso_mask;
  187. int gso_prefix_mask;
  188. u8 can_sg:1;
  189. u8 ip_csum:1;
  190. u8 ipv6_csum:1;
  191. /* Is this interface disabled? True when backend discovers
  192. * frontend is rogue.
  193. */
  194. bool disabled;
  195. unsigned long status;
  196. unsigned long drain_timeout;
  197. unsigned long stall_timeout;
  198. /* Queues */
  199. struct xenvif_queue *queues;
  200. unsigned int num_queues; /* active queues, resource allocated */
  201. unsigned int stalled_queues;
  202. struct xenbus_watch credit_watch;
  203. spinlock_t lock;
  204. #ifdef CONFIG_DEBUG_FS
  205. struct dentry *xenvif_dbg_root;
  206. #endif
  207. /* Miscellaneous private stuff. */
  208. struct net_device *dev;
  209. };
  210. struct xenvif_rx_cb {
  211. unsigned long expires;
  212. int meta_slots_used;
  213. };
  214. #define XENVIF_RX_CB(skb) ((struct xenvif_rx_cb *)(skb)->cb)
  215. static inline struct xenbus_device *xenvif_to_xenbus_device(struct xenvif *vif)
  216. {
  217. return to_xenbus_device(vif->dev->dev.parent);
  218. }
  219. void xenvif_tx_credit_callback(unsigned long data);
  220. struct xenvif *xenvif_alloc(struct device *parent,
  221. domid_t domid,
  222. unsigned int handle);
  223. int xenvif_init_queue(struct xenvif_queue *queue);
  224. void xenvif_deinit_queue(struct xenvif_queue *queue);
  225. int xenvif_connect(struct xenvif_queue *queue, unsigned long tx_ring_ref,
  226. unsigned long rx_ring_ref, unsigned int tx_evtchn,
  227. unsigned int rx_evtchn);
  228. void xenvif_disconnect(struct xenvif *vif);
  229. void xenvif_free(struct xenvif *vif);
  230. int xenvif_xenbus_init(void);
  231. void xenvif_xenbus_fini(void);
  232. int xenvif_schedulable(struct xenvif *vif);
  233. int xenvif_queue_stopped(struct xenvif_queue *queue);
  234. void xenvif_wake_queue(struct xenvif_queue *queue);
  235. /* (Un)Map communication rings. */
  236. void xenvif_unmap_frontend_rings(struct xenvif_queue *queue);
  237. int xenvif_map_frontend_rings(struct xenvif_queue *queue,
  238. grant_ref_t tx_ring_ref,
  239. grant_ref_t rx_ring_ref);
  240. /* Check for SKBs from frontend and schedule backend processing */
  241. void xenvif_napi_schedule_or_enable_events(struct xenvif_queue *queue);
  242. /* Prevent the device from generating any further traffic. */
  243. void xenvif_carrier_off(struct xenvif *vif);
  244. int xenvif_tx_action(struct xenvif_queue *queue, int budget);
  245. int xenvif_kthread_guest_rx(void *data);
  246. void xenvif_kick_thread(struct xenvif_queue *queue);
  247. int xenvif_dealloc_kthread(void *data);
  248. void xenvif_rx_queue_tail(struct xenvif_queue *queue, struct sk_buff *skb);
  249. /* Determine whether the needed number of slots (req) are available,
  250. * and set req_event if not.
  251. */
  252. bool xenvif_rx_ring_slots_available(struct xenvif_queue *queue, int needed);
  253. void xenvif_carrier_on(struct xenvif *vif);
  254. /* Callback from stack when TX packet can be released */
  255. void xenvif_zerocopy_callback(struct ubuf_info *ubuf, bool zerocopy_success);
  256. /* Unmap a pending page and release it back to the guest */
  257. void xenvif_idx_unmap(struct xenvif_queue *queue, u16 pending_idx);
  258. static inline pending_ring_idx_t nr_pending_reqs(struct xenvif_queue *queue)
  259. {
  260. return MAX_PENDING_REQS -
  261. queue->pending_prod + queue->pending_cons;
  262. }
  263. /* Callback from stack when TX packet can be released */
  264. void xenvif_zerocopy_callback(struct ubuf_info *ubuf, bool zerocopy_success);
  265. irqreturn_t xenvif_interrupt(int irq, void *dev_id);
  266. extern bool separate_tx_rx_irq;
  267. extern unsigned int rx_drain_timeout_msecs;
  268. extern unsigned int rx_stall_timeout_msecs;
  269. extern unsigned int xenvif_max_queues;
  270. #ifdef CONFIG_DEBUG_FS
  271. extern struct dentry *xen_netback_dbg_root;
  272. #endif
  273. void xenvif_skb_zerocopy_prepare(struct xenvif_queue *queue,
  274. struct sk_buff *skb);
  275. void xenvif_skb_zerocopy_complete(struct xenvif_queue *queue);
  276. #endif /* __XEN_NETBACK__COMMON_H__ */