2011-03-15 00:06:18 +00:00
|
|
|
/*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License version 2
|
|
|
|
* as published by the Free Software Foundation; or, when distributed
|
|
|
|
* separately from the Linux kernel or incorporated into other
|
|
|
|
* software packages, subject to the following license:
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
* of this source file (the "Software"), to deal in the Software without
|
|
|
|
* restriction, including without limitation the rights to use, copy, modify,
|
|
|
|
* merge, publish, distribute, sublicense, and/or sell copies of the Software,
|
|
|
|
* and to permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice shall be included in
|
|
|
|
* all copies or substantial portions of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
|
* IN THE SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __XEN_NETBACK__COMMON_H__
|
|
|
|
#define __XEN_NETBACK__COMMON_H__
|
|
|
|
|
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
|
|
|
|
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/ip.h>
|
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
|
|
|
#include <xen/interface/io/netif.h>
|
|
|
|
#include <xen/interface/grant_table.h>
|
|
|
|
#include <xen/grant_table.h>
|
|
|
|
#include <xen/xenbus.h>
|
2014-07-08 18:49:14 +00:00
|
|
|
#include <linux/debugfs.h>
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2013-08-26 11:59:38 +00:00
|
|
|
typedef unsigned int pending_ring_idx_t;
|
|
|
|
#define INVALID_PENDING_RING_IDX (~0U)
|
|
|
|
|
|
|
|
struct pending_tx_info {
|
2014-03-06 21:48:27 +00:00
|
|
|
struct xen_netif_tx_request req; /* tx request */
|
2014-03-06 21:48:26 +00:00
|
|
|
/* Callback data for released SKBs. The callback is always
|
|
|
|
* xenvif_zerocopy_callback, desc contains the pending_idx, which is
|
|
|
|
* also an index in pending_tx_info array. It is initialized in
|
|
|
|
* xenvif_alloc and it never changes.
|
|
|
|
* skb_shinfo(skb)->destructor_arg points to the first mapped slot's
|
|
|
|
* callback_struct in this array of struct pending_tx_info's, then ctx
|
|
|
|
* to the next, or NULL if there is no more slot for this skb.
|
|
|
|
* ubuf_to_vif is a helper which finds the struct xenvif from a pointer
|
|
|
|
* to this field.
|
|
|
|
*/
|
|
|
|
struct ubuf_info callback_struct;
|
2013-08-26 11:59:38 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define XEN_NETIF_TX_RING_SIZE __CONST_RING_SIZE(xen_netif_tx, PAGE_SIZE)
|
|
|
|
#define XEN_NETIF_RX_RING_SIZE __CONST_RING_SIZE(xen_netif_rx, PAGE_SIZE)
|
|
|
|
|
|
|
|
struct xenvif_rx_meta {
|
|
|
|
int id;
|
|
|
|
int size;
|
2013-10-16 16:50:32 +00:00
|
|
|
int gso_type;
|
2013-08-26 11:59:38 +00:00
|
|
|
int gso_size;
|
|
|
|
};
|
|
|
|
|
2013-10-16 16:50:32 +00:00
|
|
|
#define GSO_BIT(type) \
|
|
|
|
(1 << XEN_NETIF_GSO_TYPE_ ## type)
|
|
|
|
|
2013-08-26 11:59:38 +00:00
|
|
|
/* Discriminate from any valid pending_idx value. */
|
|
|
|
#define INVALID_PENDING_IDX 0xFFFF
|
|
|
|
|
|
|
|
#define MAX_BUFFER_OFFSET PAGE_SIZE
|
|
|
|
|
2014-03-24 23:59:49 +00:00
|
|
|
#define MAX_PENDING_REQS XEN_NETIF_TX_RING_SIZE
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2013-12-23 09:27:17 +00:00
|
|
|
/* It's possible for an skb to have a maximal number of frags
|
|
|
|
* but still be less than MAX_BUFFER_OFFSET in size. Thus the
|
|
|
|
* worst-case number of copy operations is MAX_SKB_FRAGS per
|
|
|
|
* ring slot.
|
|
|
|
*/
|
|
|
|
#define MAX_GRANT_COPY_OPS (MAX_SKB_FRAGS * XEN_NETIF_RX_RING_SIZE)
|
|
|
|
|
2014-03-06 21:48:24 +00:00
|
|
|
#define NETBACK_INVALID_HANDLE -1
|
|
|
|
|
|
|
|
/* To avoid confusion, we define XEN_NETBK_LEGACY_SLOTS_MAX indicating
|
|
|
|
* the maximum slots a valid packet can use. Now this value is defined
|
|
|
|
* to be XEN_NETIF_NR_SLOTS_MIN, which is supposed to be supported by
|
|
|
|
* all backend.
|
|
|
|
*/
|
|
|
|
#define XEN_NETBK_LEGACY_SLOTS_MAX XEN_NETIF_NR_SLOTS_MIN
|
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
/* Queue name is interface name with "-qNNN" appended */
|
|
|
|
#define QUEUE_NAME_SIZE (IFNAMSIZ + 5)
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
/* IRQ name is queue name with "-tx" or "-rx" appended */
|
|
|
|
#define IRQ_NAME_SIZE (QUEUE_NAME_SIZE + 3)
|
|
|
|
|
|
|
|
struct xenvif;
|
|
|
|
|
|
|
|
struct xenvif_stats {
|
|
|
|
/* Stats fields to be updated per-queue.
|
|
|
|
* A subset of struct net_device_stats that contains only the
|
|
|
|
* fields that are updated in netback.c for each queue.
|
2014-04-01 11:46:12 +00:00
|
|
|
*/
|
2014-06-04 09:30:42 +00:00
|
|
|
unsigned int rx_bytes;
|
|
|
|
unsigned int rx_packets;
|
|
|
|
unsigned int tx_bytes;
|
|
|
|
unsigned int tx_packets;
|
|
|
|
|
|
|
|
/* Additional stats used by xenvif */
|
|
|
|
unsigned long rx_gso_checksum_fixup;
|
|
|
|
unsigned long tx_zerocopy_sent;
|
|
|
|
unsigned long tx_zerocopy_success;
|
|
|
|
unsigned long tx_zerocopy_fail;
|
|
|
|
unsigned long tx_frag_overflow;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct xenvif_queue { /* Per-queue data for xenvif */
|
|
|
|
unsigned int id; /* Queue ID, 0-based */
|
|
|
|
char name[QUEUE_NAME_SIZE]; /* DEVNAME-qN */
|
|
|
|
struct xenvif *vif; /* Parent VIF */
|
2014-04-01 11:46:12 +00:00
|
|
|
|
2013-08-26 11:59:38 +00:00
|
|
|
/* Use NAPI for guest TX */
|
|
|
|
struct napi_struct napi;
|
|
|
|
/* When feature-split-event-channels = 0, tx_irq = rx_irq. */
|
|
|
|
unsigned int tx_irq;
|
|
|
|
/* Only used when feature-split-event-channels = 1 */
|
2014-06-04 09:30:42 +00:00
|
|
|
char tx_irq_name[IRQ_NAME_SIZE]; /* DEVNAME-qN-tx */
|
2013-08-26 11:59:38 +00:00
|
|
|
struct xen_netif_tx_back_ring tx;
|
|
|
|
struct sk_buff_head tx_queue;
|
|
|
|
struct page *mmap_pages[MAX_PENDING_REQS];
|
|
|
|
pending_ring_idx_t pending_prod;
|
|
|
|
pending_ring_idx_t pending_cons;
|
|
|
|
u16 pending_ring[MAX_PENDING_REQS];
|
|
|
|
struct pending_tx_info pending_tx_info[MAX_PENDING_REQS];
|
2014-03-06 21:48:26 +00:00
|
|
|
grant_handle_t grant_tx_handle[MAX_PENDING_REQS];
|
2013-08-26 11:59:38 +00:00
|
|
|
|
2014-04-02 17:04:58 +00:00
|
|
|
struct gnttab_copy tx_copy_ops[MAX_PENDING_REQS];
|
2014-03-06 21:48:26 +00:00
|
|
|
struct gnttab_map_grant_ref tx_map_ops[MAX_PENDING_REQS];
|
|
|
|
struct gnttab_unmap_grant_ref tx_unmap_ops[MAX_PENDING_REQS];
|
|
|
|
/* passed to gnttab_[un]map_refs with pages under (un)mapping */
|
|
|
|
struct page *pages_to_map[MAX_PENDING_REQS];
|
|
|
|
struct page *pages_to_unmap[MAX_PENDING_REQS];
|
|
|
|
|
|
|
|
/* This prevents zerocopy callbacks to race over dealloc_ring */
|
|
|
|
spinlock_t callback_lock;
|
|
|
|
/* This prevents dealloc thread and NAPI instance to race over response
|
|
|
|
* creation and pending_ring in xenvif_idx_release. In xenvif_tx_err
|
|
|
|
* it only protect response creation
|
|
|
|
*/
|
|
|
|
spinlock_t response_lock;
|
|
|
|
pending_ring_idx_t dealloc_prod;
|
|
|
|
pending_ring_idx_t dealloc_cons;
|
|
|
|
u16 dealloc_ring[MAX_PENDING_REQS];
|
|
|
|
struct task_struct *dealloc_task;
|
|
|
|
wait_queue_head_t dealloc_wq;
|
2014-08-12 10:48:07 +00:00
|
|
|
atomic_t inflight_packets;
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2013-08-26 11:59:38 +00:00
|
|
|
/* Use kthread for guest RX */
|
|
|
|
struct task_struct *task;
|
|
|
|
wait_queue_head_t wq;
|
2013-05-22 06:34:45 +00:00
|
|
|
/* When feature-split-event-channels = 0, tx_irq = rx_irq. */
|
|
|
|
unsigned int rx_irq;
|
|
|
|
/* Only used when feature-split-event-channels = 1 */
|
2014-06-04 09:30:42 +00:00
|
|
|
char rx_irq_name[IRQ_NAME_SIZE]; /* DEVNAME-qN-rx */
|
2013-08-26 11:59:38 +00:00
|
|
|
struct xen_netif_rx_back_ring rx;
|
|
|
|
struct sk_buff_head rx_queue;
|
2014-03-06 21:48:30 +00:00
|
|
|
|
2014-10-22 13:08:54 +00:00
|
|
|
unsigned int rx_queue_max;
|
|
|
|
unsigned int rx_queue_len;
|
2014-10-22 13:08:55 +00:00
|
|
|
unsigned long last_rx_time;
|
|
|
|
bool stalled;
|
2013-08-26 11:59:38 +00:00
|
|
|
|
2014-06-04 09:30:41 +00:00
|
|
|
struct gnttab_copy grant_copy_op[MAX_GRANT_COPY_OPS];
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2013-12-23 09:27:17 +00:00
|
|
|
/* We create one meta structure per ring request we consume, so
|
|
|
|
* the maximum number is the same as the ring size.
|
|
|
|
*/
|
|
|
|
struct xenvif_rx_meta meta[XEN_NETIF_RX_RING_SIZE];
|
2013-08-26 11:59:38 +00:00
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
/* Transmit shaping: allow 'credit_bytes' every 'credit_usec'. */
|
|
|
|
unsigned long credit_bytes;
|
|
|
|
unsigned long credit_usec;
|
|
|
|
unsigned long remaining_credit;
|
|
|
|
struct timer_list credit_timeout;
|
|
|
|
u64 credit_window_start;
|
|
|
|
|
|
|
|
/* Statistics */
|
|
|
|
struct xenvif_stats stats;
|
|
|
|
};
|
|
|
|
|
2014-10-22 13:08:54 +00:00
|
|
|
/* Maximum number of Rx slots a to-guest packet may use, including the
|
|
|
|
* slot needed for GSO meta-data.
|
|
|
|
*/
|
|
|
|
#define XEN_NETBK_RX_SLOTS_MAX (MAX_SKB_FRAGS + 1)
|
|
|
|
|
2014-08-04 15:20:57 +00:00
|
|
|
enum state_bit_shift {
|
|
|
|
/* This bit marks that the vif is connected */
|
xen-netback: Turn off the carrier if the guest is not able to receive
Currently when the guest is not able to receive more packets, qdisc layer starts
a timer, and when it goes off, qdisc is started again to deliver a packet again.
This is a very slow way to drain the queues, consumes unnecessary resources and
slows down other guests shutdown.
This patch change the behaviour by turning the carrier off when that timer
fires, so all the packets are freed up which were stucked waiting for that vif.
Instead of the rx_queue_purge bool it uses the VIF_STATUS_RX_PURGE_EVENT bit to
signal the thread that either the timeout happened or an RX interrupt arrived,
so the thread can check what it should do. It also disables NAPI, so the guest
can't transmit, but leaves the interrupts on, so it can resurrect.
Only the queues which brought down the interface can enable it again, the bit
QUEUE_STATUS_RX_STALLED makes sure of that.
Signed-off-by: Zoltan Kiss <zoltan.kiss@citrix.com>
Signed-off-by: David Vrabel <david.vrabel@citrix.com>
Cc: netdev@vger.kernel.org
Cc: linux-kernel@vger.kernel.org
Cc: xen-devel@lists.xenproject.org
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-08-04 15:20:58 +00:00
|
|
|
VIF_STATUS_CONNECTED,
|
2014-08-04 15:20:57 +00:00
|
|
|
};
|
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
struct xenvif {
|
|
|
|
/* Unique identifier for this interface. */
|
|
|
|
domid_t domid;
|
|
|
|
unsigned int handle;
|
|
|
|
|
2013-08-26 11:59:38 +00:00
|
|
|
u8 fe_dev_addr[6];
|
2011-03-15 00:06:18 +00:00
|
|
|
|
|
|
|
/* Frontend feature information. */
|
2013-10-16 16:50:32 +00:00
|
|
|
int gso_mask;
|
|
|
|
int gso_prefix_mask;
|
|
|
|
|
2011-03-15 00:06:18 +00:00
|
|
|
u8 can_sg:1;
|
2013-10-16 16:50:28 +00:00
|
|
|
u8 ip_csum:1;
|
|
|
|
u8 ipv6_csum:1;
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
/* Is this interface disabled? True when backend discovers
|
|
|
|
* frontend is rogue.
|
|
|
|
*/
|
|
|
|
bool disabled;
|
2014-08-04 15:20:57 +00:00
|
|
|
unsigned long status;
|
2014-12-18 11:13:06 +00:00
|
|
|
unsigned long drain_timeout;
|
|
|
|
unsigned long stall_timeout;
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
/* Queues */
|
|
|
|
struct xenvif_queue *queues;
|
2014-06-23 09:50:17 +00:00
|
|
|
unsigned int num_queues; /* active queues, resource allocated */
|
2014-10-22 13:08:55 +00:00
|
|
|
unsigned int stalled_queues;
|
|
|
|
|
2015-03-19 10:05:42 +00:00
|
|
|
struct xenbus_watch credit_watch;
|
|
|
|
|
2014-10-22 13:08:55 +00:00
|
|
|
spinlock_t lock;
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2014-07-08 18:49:14 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
struct dentry *xenvif_dbg_root;
|
|
|
|
#endif
|
|
|
|
|
2011-03-15 00:06:18 +00:00
|
|
|
/* Miscellaneous private stuff. */
|
|
|
|
struct net_device *dev;
|
|
|
|
};
|
|
|
|
|
2014-10-22 13:08:54 +00:00
|
|
|
struct xenvif_rx_cb {
|
|
|
|
unsigned long expires;
|
|
|
|
int meta_slots_used;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define XENVIF_RX_CB(skb) ((struct xenvif_rx_cb *)(skb)->cb)
|
|
|
|
|
2011-09-29 15:53:31 +00:00
|
|
|
static inline struct xenbus_device *xenvif_to_xenbus_device(struct xenvif *vif)
|
|
|
|
{
|
|
|
|
return to_xenbus_device(vif->dev->dev.parent);
|
|
|
|
}
|
|
|
|
|
2015-03-19 10:05:42 +00:00
|
|
|
void xenvif_tx_credit_callback(unsigned long data);
|
|
|
|
|
2011-03-15 00:06:18 +00:00
|
|
|
struct xenvif *xenvif_alloc(struct device *parent,
|
|
|
|
domid_t domid,
|
|
|
|
unsigned int handle);
|
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
int xenvif_init_queue(struct xenvif_queue *queue);
|
2014-06-04 09:30:43 +00:00
|
|
|
void xenvif_deinit_queue(struct xenvif_queue *queue);
|
2014-06-04 09:30:42 +00:00
|
|
|
|
|
|
|
int xenvif_connect(struct xenvif_queue *queue, unsigned long tx_ring_ref,
|
2013-05-22 06:34:45 +00:00
|
|
|
unsigned long rx_ring_ref, unsigned int tx_evtchn,
|
|
|
|
unsigned int rx_evtchn);
|
2011-03-15 00:06:18 +00:00
|
|
|
void xenvif_disconnect(struct xenvif *vif);
|
2013-09-17 16:46:08 +00:00
|
|
|
void xenvif_free(struct xenvif *vif);
|
2011-03-15 00:06:18 +00:00
|
|
|
|
|
|
|
int xenvif_xenbus_init(void);
|
2013-05-16 23:26:11 +00:00
|
|
|
void xenvif_xenbus_fini(void);
|
2011-03-15 00:06:18 +00:00
|
|
|
|
|
|
|
int xenvif_schedulable(struct xenvif *vif);
|
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
int xenvif_queue_stopped(struct xenvif_queue *queue);
|
|
|
|
void xenvif_wake_queue(struct xenvif_queue *queue);
|
2011-03-15 00:06:18 +00:00
|
|
|
|
|
|
|
/* (Un)Map communication rings. */
|
2014-06-04 09:30:42 +00:00
|
|
|
void xenvif_unmap_frontend_rings(struct xenvif_queue *queue);
|
|
|
|
int xenvif_map_frontend_rings(struct xenvif_queue *queue,
|
2013-08-26 11:59:39 +00:00
|
|
|
grant_ref_t tx_ring_ref,
|
|
|
|
grant_ref_t rx_ring_ref);
|
2011-03-15 00:06:18 +00:00
|
|
|
|
|
|
|
/* Check for SKBs from frontend and schedule backend processing */
|
2014-06-04 09:30:42 +00:00
|
|
|
void xenvif_napi_schedule_or_enable_events(struct xenvif_queue *queue);
|
2011-03-15 00:06:18 +00:00
|
|
|
|
2013-02-06 23:41:35 +00:00
|
|
|
/* Prevent the device from generating any further traffic. */
|
|
|
|
void xenvif_carrier_off(struct xenvif *vif);
|
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
int xenvif_tx_action(struct xenvif_queue *queue, int budget);
|
2013-08-26 11:59:38 +00:00
|
|
|
|
2014-03-06 21:48:24 +00:00
|
|
|
int xenvif_kthread_guest_rx(void *data);
|
2014-06-04 09:30:42 +00:00
|
|
|
void xenvif_kick_thread(struct xenvif_queue *queue);
|
xen-netback: improve guest-receive-side flow control
The way that flow control works without this patch is that, in start_xmit()
the code uses xenvif_count_skb_slots() to predict how many slots
xenvif_gop_skb() will consume and then adds this to a 'req_cons_peek'
counter which it then uses to determine if the shared ring has that amount
of space available by checking whether 'req_prod' has passed that value.
If the ring doesn't have space the tx queue is stopped.
xenvif_gop_skb() will then consume slots and update 'req_cons' and issue
responses, updating 'rsp_prod' as it goes. The frontend will consume those
responses and post new requests, by updating req_prod. So, req_prod chases
req_cons which chases rsp_prod, and can never exceed that value. Thus if
xenvif_count_skb_slots() ever returns a number of slots greater than
xenvif_gop_skb() uses, req_cons_peek will get to a value that req_prod cannot
possibly achieve (since it's limited by the 'real' req_cons) and, if this
happens enough times, req_cons_peek gets more than a ring size ahead of
req_cons and the tx queue then remains stopped forever waiting for an
unachievable amount of space to become available in the ring.
Having two routines trying to calculate the same value is always going to be
fragile, so this patch does away with that. All we essentially need to do is
make sure that we have 'enough stuff' on our internal queue without letting
it build up uncontrollably. So start_xmit() makes a cheap optimistic check
of how much space is needed for an skb and only turns the queue off if that
is unachievable. net_rx_action() is the place where we could do with an
accurate predicition but, since that has proven tricky to calculate, a cheap
worse-case (but not too bad) estimate is all we really need since the only
thing we *must* prevent is xenvif_gop_skb() consuming more slots than are
available.
Without this patch I can trivially stall netback permanently by just doing
a large guest to guest file copy between two Windows Server 2008R2 VMs on a
single host.
Patch tested with frontends in:
- Windows Server 2008R2
- CentOS 6.0
- Debian Squeeze
- Debian Wheezy
- SLES11
Signed-off-by: Paul Durrant <paul.durrant@citrix.com>
Cc: Wei Liu <wei.liu2@citrix.com>
Cc: Ian Campbell <ian.campbell@citrix.com>
Cc: David Vrabel <david.vrabel@citrix.com>
Cc: Annie Li <annie.li@oracle.com>
Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Acked-by: Wei Liu <wei.liu2@citrix.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-12-06 16:36:07 +00:00
|
|
|
|
2014-03-06 21:48:26 +00:00
|
|
|
int xenvif_dealloc_kthread(void *data);
|
|
|
|
|
2014-10-22 13:08:54 +00:00
|
|
|
void xenvif_rx_queue_tail(struct xenvif_queue *queue, struct sk_buff *skb);
|
|
|
|
|
xen-netback: improve guest-receive-side flow control
The way that flow control works without this patch is that, in start_xmit()
the code uses xenvif_count_skb_slots() to predict how many slots
xenvif_gop_skb() will consume and then adds this to a 'req_cons_peek'
counter which it then uses to determine if the shared ring has that amount
of space available by checking whether 'req_prod' has passed that value.
If the ring doesn't have space the tx queue is stopped.
xenvif_gop_skb() will then consume slots and update 'req_cons' and issue
responses, updating 'rsp_prod' as it goes. The frontend will consume those
responses and post new requests, by updating req_prod. So, req_prod chases
req_cons which chases rsp_prod, and can never exceed that value. Thus if
xenvif_count_skb_slots() ever returns a number of slots greater than
xenvif_gop_skb() uses, req_cons_peek will get to a value that req_prod cannot
possibly achieve (since it's limited by the 'real' req_cons) and, if this
happens enough times, req_cons_peek gets more than a ring size ahead of
req_cons and the tx queue then remains stopped forever waiting for an
unachievable amount of space to become available in the ring.
Having two routines trying to calculate the same value is always going to be
fragile, so this patch does away with that. All we essentially need to do is
make sure that we have 'enough stuff' on our internal queue without letting
it build up uncontrollably. So start_xmit() makes a cheap optimistic check
of how much space is needed for an skb and only turns the queue off if that
is unachievable. net_rx_action() is the place where we could do with an
accurate predicition but, since that has proven tricky to calculate, a cheap
worse-case (but not too bad) estimate is all we really need since the only
thing we *must* prevent is xenvif_gop_skb() consuming more slots than are
available.
Without this patch I can trivially stall netback permanently by just doing
a large guest to guest file copy between two Windows Server 2008R2 VMs on a
single host.
Patch tested with frontends in:
- Windows Server 2008R2
- CentOS 6.0
- Debian Squeeze
- Debian Wheezy
- SLES11
Signed-off-by: Paul Durrant <paul.durrant@citrix.com>
Cc: Wei Liu <wei.liu2@citrix.com>
Cc: Ian Campbell <ian.campbell@citrix.com>
Cc: David Vrabel <david.vrabel@citrix.com>
Cc: Annie Li <annie.li@oracle.com>
Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Acked-by: Wei Liu <wei.liu2@citrix.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-12-06 16:36:07 +00:00
|
|
|
/* Determine whether the needed number of slots (req) are available,
|
|
|
|
* and set req_event if not.
|
|
|
|
*/
|
2014-06-04 09:30:42 +00:00
|
|
|
bool xenvif_rx_ring_slots_available(struct xenvif_queue *queue, int needed);
|
xen-netback: improve guest-receive-side flow control
The way that flow control works without this patch is that, in start_xmit()
the code uses xenvif_count_skb_slots() to predict how many slots
xenvif_gop_skb() will consume and then adds this to a 'req_cons_peek'
counter which it then uses to determine if the shared ring has that amount
of space available by checking whether 'req_prod' has passed that value.
If the ring doesn't have space the tx queue is stopped.
xenvif_gop_skb() will then consume slots and update 'req_cons' and issue
responses, updating 'rsp_prod' as it goes. The frontend will consume those
responses and post new requests, by updating req_prod. So, req_prod chases
req_cons which chases rsp_prod, and can never exceed that value. Thus if
xenvif_count_skb_slots() ever returns a number of slots greater than
xenvif_gop_skb() uses, req_cons_peek will get to a value that req_prod cannot
possibly achieve (since it's limited by the 'real' req_cons) and, if this
happens enough times, req_cons_peek gets more than a ring size ahead of
req_cons and the tx queue then remains stopped forever waiting for an
unachievable amount of space to become available in the ring.
Having two routines trying to calculate the same value is always going to be
fragile, so this patch does away with that. All we essentially need to do is
make sure that we have 'enough stuff' on our internal queue without letting
it build up uncontrollably. So start_xmit() makes a cheap optimistic check
of how much space is needed for an skb and only turns the queue off if that
is unachievable. net_rx_action() is the place where we could do with an
accurate predicition but, since that has proven tricky to calculate, a cheap
worse-case (but not too bad) estimate is all we really need since the only
thing we *must* prevent is xenvif_gop_skb() consuming more slots than are
available.
Without this patch I can trivially stall netback permanently by just doing
a large guest to guest file copy between two Windows Server 2008R2 VMs on a
single host.
Patch tested with frontends in:
- Windows Server 2008R2
- CentOS 6.0
- Debian Squeeze
- Debian Wheezy
- SLES11
Signed-off-by: Paul Durrant <paul.durrant@citrix.com>
Cc: Wei Liu <wei.liu2@citrix.com>
Cc: Ian Campbell <ian.campbell@citrix.com>
Cc: David Vrabel <david.vrabel@citrix.com>
Cc: Annie Li <annie.li@oracle.com>
Cc: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Acked-by: Wei Liu <wei.liu2@citrix.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2013-12-06 16:36:07 +00:00
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
void xenvif_carrier_on(struct xenvif *vif);
|
2013-08-26 11:59:38 +00:00
|
|
|
|
2014-03-06 21:48:26 +00:00
|
|
|
/* Callback from stack when TX packet can be released */
|
|
|
|
void xenvif_zerocopy_callback(struct ubuf_info *ubuf, bool zerocopy_success);
|
|
|
|
|
|
|
|
/* Unmap a pending page and release it back to the guest */
|
2014-06-04 09:30:42 +00:00
|
|
|
void xenvif_idx_unmap(struct xenvif_queue *queue, u16 pending_idx);
|
2014-03-06 21:48:26 +00:00
|
|
|
|
2014-06-04 09:30:42 +00:00
|
|
|
static inline pending_ring_idx_t nr_pending_reqs(struct xenvif_queue *queue)
|
2014-03-06 21:48:24 +00:00
|
|
|
{
|
|
|
|
return MAX_PENDING_REQS -
|
2014-06-04 09:30:42 +00:00
|
|
|
queue->pending_prod + queue->pending_cons;
|
2014-03-06 21:48:24 +00:00
|
|
|
}
|
|
|
|
|
2014-03-06 21:48:25 +00:00
|
|
|
/* Callback from stack when TX packet can be released */
|
|
|
|
void xenvif_zerocopy_callback(struct ubuf_info *ubuf, bool zerocopy_success);
|
|
|
|
|
2014-07-08 18:49:14 +00:00
|
|
|
irqreturn_t xenvif_interrupt(int irq, void *dev_id);
|
|
|
|
|
2013-05-22 06:34:45 +00:00
|
|
|
extern bool separate_tx_rx_irq;
|
|
|
|
|
2014-03-06 21:48:30 +00:00
|
|
|
extern unsigned int rx_drain_timeout_msecs;
|
2014-12-18 11:13:06 +00:00
|
|
|
extern unsigned int rx_stall_timeout_msecs;
|
2014-06-04 09:30:43 +00:00
|
|
|
extern unsigned int xenvif_max_queues;
|
2014-03-06 21:48:30 +00:00
|
|
|
|
2014-07-08 18:49:14 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
extern struct dentry *xen_netback_dbg_root;
|
|
|
|
#endif
|
|
|
|
|
2014-08-12 10:48:07 +00:00
|
|
|
void xenvif_skb_zerocopy_prepare(struct xenvif_queue *queue,
|
|
|
|
struct sk_buff *skb);
|
|
|
|
void xenvif_skb_zerocopy_complete(struct xenvif_queue *queue);
|
|
|
|
|
2011-03-15 00:06:18 +00:00
|
|
|
#endif /* __XEN_NETBACK__COMMON_H__ */
|