Skip to content

L
linux
Commit 823a19e0 authored by David S. Miller's avatar David S. Miller
Browse files
Options

Merge branch 'xen-netback' 

Wei Liu says:

====================
xen-netback: switch to NAPI + kthread 1:1 model

This series implements NAPI + kthread 1:1 model for Xen netback.

This model
 - provides better scheduling fairness among vifs
 - is prerequisite for implementing multiqueue for Xen network driver

The second patch has the real meat:
 - make use of NAPI to mitigate interrupt
 - kthreads are not bound to CPUs any more, so that we can take
   advantage of backend scheduler and trust it to do the right thing

Benchmark is done on a Dell T3400 workstation with 4 cores, running 4
DomUs. Netserver runs in Dom0. DomUs do netperf to Dom0 with
following command: /root/netperf -H Dom0 -fm -l120

IRQs are distributed to 4 cores by hand in the new model, while in the
old model vifs are automatically distributed to 4 kthreads.

* New model
%Cpu0  :  0.5 us, 20.3 sy,  0.0 ni, 28.9 id,  0.0 wa,  0.0 hi, 24.4 si, 25.9 st
%Cpu1  :  0.5 us, 17.8 sy,  0.0 ni, 28.8 id,  0.0 wa,  0.0 hi, 27.7 si, 25.1 st
%Cpu2  :  0.5 us, 18.8 sy,  0.0 ni, 30.7 id,  0.0 wa,  0.0 hi, 22.9 si, 27.1 st
%Cpu3  :  0.0 us, 20.1 sy,  0.0 ni, 30.4 id,  0.0 wa,  0.0 hi, 22.7 si, 26.8 st
Throughputs: 2027.89 2025.95 2018.57 2016.23 aggregated: 8088.64

* Old model
%Cpu0  :  0.5 us, 68.8 sy,  0.0 ni, 16.1 id,  0.5 wa,  0.0 hi,  2.8 si, 11.5 st
%Cpu1  :  0.4 us, 45.1 sy,  0.0 ni, 31.1 id,  0.4 wa,  0.0 hi,  2.1 si, 20.9 st
%Cpu2  :  0.9 us, 44.8 sy,  0.0 ni, 30.9 id,  0.0 wa,  0.0 hi,  1.3 si, 22.2 st
%Cpu3  :  0.8 us, 46.4 sy,  0.0 ni, 28.3 id,  1.3 wa,  0.0 hi,  2.1 si, 21.1 st
Throughputs: 1899.14 2280.43 1963.33 1893.47 aggregated: 8036.37

We can see that the impact is mainly on CPU usage. The new model moves
processing from kthread to NAPI (software interrupt).
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 5b2941b1 7376419a
Hide whitespace changes
Inline Side-by-side
Showing with 445 additions and 673 deletions
drivers/net/xen-netback/common.h
View file @ 823a19e0
...@@ -45,31 +45,109 @@ ...@@ -45,31 +45,109 @@
#include <xen/grant_table.h> #include <xen/grant_table.h>
#include <xen/xenbus.h> #include <xen/xenbus.h>
struct xen_netbk; typedef unsigned int pending_ring_idx_t;
#define INVALID_PENDING_RING_IDX (~0U)
/* For the head field in pending_tx_info: it is used to indicate
* whether this tx info is the head of one or more coalesced requests.
*
* When head != INVALID_PENDING_RING_IDX, it means the start of a new
* tx requests queue and the end of previous queue.
*
* An example sequence of head fields (I = INVALID_PENDING_RING_IDX):
*
* ...|0 I I I|5 I|9 I I I|...
* -->|<-INUSE----------------
*
* After consuming the first slot(s) we have:
*
* ...|V V V V|5 I|9 I I I|...
* -----FREE->|<-INUSE--------
*
* where V stands for "valid pending ring index". Any number other
* than INVALID_PENDING_RING_IDX is OK. These entries are considered
* free and can contain any number other than
* INVALID_PENDING_RING_IDX. In practice we use 0.
*
* The in use non-INVALID_PENDING_RING_IDX (say 0, 5 and 9 in the
* above example) number is the index into pending_tx_info and
* mmap_pages arrays.
*/
struct pending_tx_info {
struct xen_netif_tx_request req; /* coalesced tx request */
pending_ring_idx_t head; /* head != INVALID_PENDING_RING_IDX
* if it is head of one or more tx
* reqs
*/
};
#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;
int gso_size;
};
/* Discriminate from any valid pending_idx value. */
#define INVALID_PENDING_IDX 0xFFFF
#define MAX_BUFFER_OFFSET PAGE_SIZE
#define MAX_PENDING_REQS 256
struct xenvif { struct xenvif {
/* Unique identifier for this interface. */ /* Unique identifier for this interface. */
domid_t domid; domid_t domid;
unsigned int handle; unsigned int handle;
/* Reference to netback processing backend. */ /* Use NAPI for guest TX */
struct xen_netbk *netbk; 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 */
char tx_irq_name[IFNAMSIZ+4]; /* DEVNAME-tx */
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];
/* Coalescing tx requests before copying makes number of grant
* copy ops greater or equal to number of slots required. In
* worst case a tx request consumes 2 gnttab_copy.
*/
struct gnttab_copy tx_copy_ops[2*MAX_PENDING_REQS];
u8 fe_dev_addr[6];
/* Use kthread for guest RX */
struct task_struct *task;
wait_queue_head_t wq;
/* When feature-split-event-channels = 0, tx_irq = rx_irq. */ /* When feature-split-event-channels = 0, tx_irq = rx_irq. */
unsigned int tx_irq;
unsigned int rx_irq; unsigned int rx_irq;
/* Only used when feature-split-event-channels = 1 */ /* Only used when feature-split-event-channels = 1 */
char tx_irq_name[IFNAMSIZ+4]; /* DEVNAME-tx */
char rx_irq_name[IFNAMSIZ+4]; /* DEVNAME-rx */ char rx_irq_name[IFNAMSIZ+4]; /* DEVNAME-rx */
struct xen_netif_rx_back_ring rx;
struct sk_buff_head rx_queue;
/* List of frontends to notify after a batch of frames sent. */ /* Allow xenvif_start_xmit() to peek ahead in the rx request
struct list_head notify_list; * ring. This is a prediction of what rx_req_cons will be
* once all queued skbs are put on the ring.
*/
RING_IDX rx_req_cons_peek;
/* Given MAX_BUFFER_OFFSET of 4096 the worst case is that each
* head/fragment page uses 2 copy operations because it
* straddles two buffers in the frontend.
*/
struct gnttab_copy grant_copy_op[2*XEN_NETIF_RX_RING_SIZE];
struct xenvif_rx_meta meta[2*XEN_NETIF_RX_RING_SIZE];
/* The shared rings and indexes. */
struct xen_netif_tx_back_ring tx; u8 fe_dev_addr[6];
struct xen_netif_rx_back_ring rx;
/* Frontend feature information. */ /* Frontend feature information. */
u8 can_sg:1; u8 can_sg:1;
...@@ -80,13 +158,6 @@ struct xenvif { ...@@ -80,13 +158,6 @@ struct xenvif {
/* Internal feature information. */ /* Internal feature information. */
u8 can_queue:1; /* can queue packets for receiver? */ u8 can_queue:1; /* can queue packets for receiver? */
/*
* Allow xenvif_start_xmit() to peek ahead in the rx request
* ring. This is a prediction of what rx_req_cons will be
* once all queued skbs are put on the ring.
*/
RING_IDX rx_req_cons_peek;
/* Transmit shaping: allow 'credit_bytes' every 'credit_usec'. */ /* Transmit shaping: allow 'credit_bytes' every 'credit_usec'. */
unsigned long credit_bytes; unsigned long credit_bytes;
unsigned long credit_usec; unsigned long credit_usec;
...@@ -97,11 +168,7 @@ struct xenvif { ...@@ -97,11 +168,7 @@ struct xenvif {
unsigned long rx_gso_checksum_fixup; unsigned long rx_gso_checksum_fixup;
/* Miscellaneous private stuff. */ /* Miscellaneous private stuff. */
struct list_head schedule_list;
atomic_t refcnt;
struct net_device *dev; struct net_device *dev;
wait_queue_head_t waiting_to_free;
}; };
static inline struct xenbus_device *xenvif_to_xenbus_device(struct xenvif *vif) static inline struct xenbus_device *xenvif_to_xenbus_device(struct xenvif *vif)
...@@ -109,9 +176,6 @@ static inline struct xenbus_device *xenvif_to_xenbus_device(struct xenvif *vif) ...@@ -109,9 +176,6 @@ static inline struct xenbus_device *xenvif_to_xenbus_device(struct xenvif *vif)
return to_xenbus_device(vif->dev->dev.parent); return to_xenbus_device(vif->dev->dev.parent);
} }
#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 *xenvif_alloc(struct device *parent, struct xenvif *xenvif_alloc(struct device *parent,
domid_t domid, domid_t domid,
unsigned int handle); unsigned int handle);
...@@ -121,39 +185,26 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref, ...@@ -121,39 +185,26 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
unsigned int rx_evtchn); unsigned int rx_evtchn);
void xenvif_disconnect(struct xenvif *vif); void xenvif_disconnect(struct xenvif *vif);
void xenvif_get(struct xenvif *vif);
void xenvif_put(struct xenvif *vif);
int xenvif_xenbus_init(void); int xenvif_xenbus_init(void);
void xenvif_xenbus_fini(void); void xenvif_xenbus_fini(void);
int xenvif_schedulable(struct xenvif *vif); int xenvif_schedulable(struct xenvif *vif);
int xen_netbk_rx_ring_full(struct xenvif *vif); int xenvif_rx_ring_full(struct xenvif *vif);
int xen_netbk_must_stop_queue(struct xenvif *vif); int xenvif_must_stop_queue(struct xenvif *vif);
/* (Un)Map communication rings. */ /* (Un)Map communication rings. */
void xen_netbk_unmap_frontend_rings(struct xenvif *vif); void xenvif_unmap_frontend_rings(struct xenvif *vif);
int xen_netbk_map_frontend_rings(struct xenvif *vif, int xenvif_map_frontend_rings(struct xenvif *vif,
grant_ref_t tx_ring_ref, grant_ref_t tx_ring_ref,
grant_ref_t rx_ring_ref); grant_ref_t rx_ring_ref);
/* (De)Register a xenvif with the netback backend. */
void xen_netbk_add_xenvif(struct xenvif *vif);
void xen_netbk_remove_xenvif(struct xenvif *vif);
/* (De)Schedule backend processing for a xenvif */
void xen_netbk_schedule_xenvif(struct xenvif *vif);
void xen_netbk_deschedule_xenvif(struct xenvif *vif);
/* Check for SKBs from frontend and schedule backend processing */ /* Check for SKBs from frontend and schedule backend processing */
void xen_netbk_check_rx_xenvif(struct xenvif *vif); void xenvif_check_rx_xenvif(struct xenvif *vif);
/* Receive an SKB from the frontend */
void xenvif_receive_skb(struct xenvif *vif, struct sk_buff *skb);
/* Queue an SKB for transmission to the frontend */ /* Queue an SKB for transmission to the frontend */
void xen_netbk_queue_tx_skb(struct xenvif *vif, struct sk_buff *skb); void xenvif_queue_tx_skb(struct xenvif *vif, struct sk_buff *skb);
/* Notify xenvif that ring now has space to send an skb to the frontend */ /* Notify xenvif that ring now has space to send an skb to the frontend */
void xenvif_notify_tx_completion(struct xenvif *vif); void xenvif_notify_tx_completion(struct xenvif *vif);
...@@ -161,7 +212,12 @@ void xenvif_notify_tx_completion(struct xenvif *vif); ...@@ -161,7 +212,12 @@ void xenvif_notify_tx_completion(struct xenvif *vif);
void xenvif_carrier_off(struct xenvif *vif); void xenvif_carrier_off(struct xenvif *vif);
/* Returns number of ring slots required to send an skb to the frontend */ /* Returns number of ring slots required to send an skb to the frontend */
unsigned int xen_netbk_count_skb_slots(struct xenvif *vif, struct sk_buff *skb); unsigned int xenvif_count_skb_slots(struct xenvif *vif, struct sk_buff *skb);
int xenvif_tx_action(struct xenvif *vif, int budget);
void xenvif_rx_action(struct xenvif *vif);
int xenvif_kthread(void *data);
extern bool separate_tx_rx_irq; extern bool separate_tx_rx_irq;
......
drivers/net/xen-netback/interface.c
View file @ 823a19e0
...@@ -30,6 +30,7 @@ ...@@ -30,6 +30,7 @@
#include "common.h" #include "common.h"
#include <linux/kthread.h>
#include <linux/ethtool.h> #include <linux/ethtool.h>
#include <linux/rtnetlink.h> #include <linux/rtnetlink.h>
#include <linux/if_vlan.h> #include <linux/if_vlan.h>
...@@ -38,17 +39,7 @@ ...@@ -38,17 +39,7 @@
#include <asm/xen/hypercall.h> #include <asm/xen/hypercall.h>
#define XENVIF_QUEUE_LENGTH 32 #define XENVIF_QUEUE_LENGTH 32
#define XENVIF_NAPI_WEIGHT 64
void xenvif_get(struct xenvif *vif)
{
atomic_inc(&vif->refcnt);
}
void xenvif_put(struct xenvif *vif)
{
if (atomic_dec_and_test(&vif->refcnt))
wake_up(&vif->waiting_to_free);
}
int xenvif_schedulable(struct xenvif *vif) int xenvif_schedulable(struct xenvif *vif)
{ {
...@@ -57,28 +48,62 @@ int xenvif_schedulable(struct xenvif *vif) ...@@ -57,28 +48,62 @@ int xenvif_schedulable(struct xenvif *vif)
static int xenvif_rx_schedulable(struct xenvif *vif) static int xenvif_rx_schedulable(struct xenvif *vif)
{ {
return xenvif_schedulable(vif) && !xen_netbk_rx_ring_full(vif); return xenvif_schedulable(vif) && !xenvif_rx_ring_full(vif);
} }
static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id) static irqreturn_t xenvif_tx_interrupt(int irq, void *dev_id)
{ {
struct xenvif *vif = dev_id; struct xenvif *vif = dev_id;
if (vif->netbk == NULL) if (RING_HAS_UNCONSUMED_REQUESTS(&vif->tx))
return IRQ_HANDLED; napi_schedule(&vif->napi);
xen_netbk_schedule_xenvif(vif);
return IRQ_HANDLED; return IRQ_HANDLED;
} }
static int xenvif_poll(struct napi_struct *napi, int budget)
{
struct xenvif *vif = container_of(napi, struct xenvif, napi);
int work_done;
work_done = xenvif_tx_action(vif, budget);
if (work_done < budget) {
int more_to_do = 0;
unsigned long flags;
/* It is necessary to disable IRQ before calling
* RING_HAS_UNCONSUMED_REQUESTS. Otherwise we might
* lose event from the frontend.
*
* Consider:
* RING_HAS_UNCONSUMED_REQUESTS
* <frontend generates event to trigger napi_schedule>
* __napi_complete
*
* This handler is still in scheduled state so the
* event has no effect at all. After __napi_complete
* this handler is descheduled and cannot get
* scheduled again. We lose event in this case and the ring
* will be completely stalled.
*/
local_irq_save(flags);
RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, more_to_do);
if (!more_to_do)
__napi_complete(napi);
local_irq_restore(flags);
}
return work_done;
}
static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id) static irqreturn_t xenvif_rx_interrupt(int irq, void *dev_id)
{ {
struct xenvif *vif = dev_id; struct xenvif *vif = dev_id;
if (vif->netbk == NULL)
return IRQ_HANDLED;
if (xenvif_rx_schedulable(vif)) if (xenvif_rx_schedulable(vif))
netif_wake_queue(vif->dev); netif_wake_queue(vif->dev);
...@@ -99,7 +124,8 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev) ...@@ -99,7 +124,8 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
BUG_ON(skb->dev != dev); BUG_ON(skb->dev != dev);
if (vif->netbk == NULL) /* Drop the packet if vif is not ready */
if (vif->task == NULL)
goto drop; goto drop;
/* Drop the packet if the target domain has no receive buffers. */ /* Drop the packet if the target domain has no receive buffers. */
...@@ -107,13 +133,12 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev) ...@@ -107,13 +133,12 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
goto drop; goto drop;
/* Reserve ring slots for the worst-case number of fragments. */ /* Reserve ring slots for the worst-case number of fragments. */
vif->rx_req_cons_peek += xen_netbk_count_skb_slots(vif, skb); vif->rx_req_cons_peek += xenvif_count_skb_slots(vif, skb);
xenvif_get(vif);
if (vif->can_queue && xen_netbk_must_stop_queue(vif)) if (vif->can_queue && xenvif_must_stop_queue(vif))
netif_stop_queue(dev); netif_stop_queue(dev);
xen_netbk_queue_tx_skb(vif, skb); xenvif_queue_tx_skb(vif, skb);
return NETDEV_TX_OK; return NETDEV_TX_OK;
...@@ -123,11 +148,6 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev) ...@@ -123,11 +148,6 @@ static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
return NETDEV_TX_OK; return NETDEV_TX_OK;
} }
void xenvif_receive_skb(struct xenvif *vif, struct sk_buff *skb)
{
netif_rx_ni(skb);
}
void xenvif_notify_tx_completion(struct xenvif *vif) void xenvif_notify_tx_completion(struct xenvif *vif)
{ {
if (netif_queue_stopped(vif->dev) && xenvif_rx_schedulable(vif)) if (netif_queue_stopped(vif->dev) && xenvif_rx_schedulable(vif))
...@@ -142,21 +162,20 @@ static struct net_device_stats *xenvif_get_stats(struct net_device *dev) ...@@ -142,21 +162,20 @@ static struct net_device_stats *xenvif_get_stats(struct net_device *dev)
static void xenvif_up(struct xenvif *vif) static void xenvif_up(struct xenvif *vif)
{ {
xen_netbk_add_xenvif(vif); napi_enable(&vif->napi);
enable_irq(vif->tx_irq); enable_irq(vif->tx_irq);
if (vif->tx_irq != vif->rx_irq) if (vif->tx_irq != vif->rx_irq)
enable_irq(vif->rx_irq); enable_irq(vif->rx_irq);
xen_netbk_check_rx_xenvif(vif); xenvif_check_rx_xenvif(vif);
} }
static void xenvif_down(struct xenvif *vif) static void xenvif_down(struct xenvif *vif)
{ {
napi_disable(&vif->napi);
disable_irq(vif->tx_irq); disable_irq(vif->tx_irq);
if (vif->tx_irq != vif->rx_irq) if (vif->tx_irq != vif->rx_irq)
disable_irq(vif->rx_irq); disable_irq(vif->rx_irq);
del_timer_sync(&vif->credit_timeout); del_timer_sync(&vif->credit_timeout);
xen_netbk_deschedule_xenvif(vif);
xen_netbk_remove_xenvif(vif);
} }
static int xenvif_open(struct net_device *dev) static int xenvif_open(struct net_device *dev)
...@@ -272,11 +291,12 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, ...@@ -272,11 +291,12 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
struct net_device *dev; struct net_device *dev;
struct xenvif *vif; struct xenvif *vif;
char name[IFNAMSIZ] = {}; char name[IFNAMSIZ] = {};
int i;
snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle); snprintf(name, IFNAMSIZ - 1, "vif%u.%u", domid, handle);
dev = alloc_netdev(sizeof(struct xenvif), name, ether_setup); dev = alloc_netdev(sizeof(struct xenvif), name, ether_setup);
if (dev == NULL) { if (dev == NULL) {
pr_warn("Could not allocate netdev\n"); pr_warn("Could not allocate netdev for %s\n", name);
return ERR_PTR(-ENOMEM); return ERR_PTR(-ENOMEM);
} }
...@@ -285,14 +305,9 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, ...@@ -285,14 +305,9 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
vif = netdev_priv(dev); vif = netdev_priv(dev);
vif->domid = domid; vif->domid = domid;
vif->handle = handle; vif->handle = handle;
vif->netbk = NULL;
vif->can_sg = 1; vif->can_sg = 1;
vif->csum = 1; vif->csum = 1;
atomic_set(&vif->refcnt, 1);
init_waitqueue_head(&vif->waiting_to_free);
vif->dev = dev; vif->dev = dev;
INIT_LIST_HEAD(&vif->schedule_list);
INIT_LIST_HEAD(&vif->notify_list);
vif->credit_bytes = vif->remaining_credit = ~0UL; vif->credit_bytes = vif->remaining_credit = ~0UL;
vif->credit_usec = 0UL; vif->credit_usec = 0UL;
...@@ -307,6 +322,16 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, ...@@ -307,6 +322,16 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
dev->tx_queue_len = XENVIF_QUEUE_LENGTH; dev->tx_queue_len = XENVIF_QUEUE_LENGTH;
skb_queue_head_init(&vif->rx_queue);
skb_queue_head_init(&vif->tx_queue);
vif->pending_cons = 0;
vif->pending_prod = MAX_PENDING_REQS;
for (i = 0; i < MAX_PENDING_REQS; i++)
vif->pending_ring[i] = i;
for (i = 0; i < MAX_PENDING_REQS; i++)
vif->mmap_pages[i] = NULL;
/* /*
* Initialise a dummy MAC address. We choose the numerically * Initialise a dummy MAC address. We choose the numerically
* largest non-broadcast address to prevent the address getting * largest non-broadcast address to prevent the address getting
...@@ -316,6 +341,8 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid, ...@@ -316,6 +341,8 @@ struct xenvif *xenvif_alloc(struct device *parent, domid_t domid,
memset(dev->dev_addr, 0xFF, ETH_ALEN); memset(dev->dev_addr, 0xFF, ETH_ALEN);
dev->dev_addr[0] &= ~0x01; dev->dev_addr[0] &= ~0x01;
netif_napi_add(dev, &vif->napi, xenvif_poll, XENVIF_NAPI_WEIGHT);
netif_carrier_off(dev); netif_carrier_off(dev);
err = register_netdev(dev); err = register_netdev(dev);
...@@ -341,7 +368,7 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref, ...@@ -341,7 +368,7 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
__module_get(THIS_MODULE); __module_get(THIS_MODULE);
err = xen_netbk_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref); err = xenvif_map_frontend_rings(vif, tx_ring_ref, rx_ring_ref);
if (err < 0) if (err < 0)
goto err; goto err;
...@@ -377,7 +404,14 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref, ...@@ -377,7 +404,14 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
disable_irq(vif->rx_irq); disable_irq(vif->rx_irq);
} }
xenvif_get(vif); init_waitqueue_head(&vif->wq);
vif->task = kthread_create(xenvif_kthread,
(void *)vif, vif->dev->name);
if (IS_ERR(vif->task)) {
pr_warn("Could not allocate kthread for %s\n", vif->dev->name);
err = PTR_ERR(vif->task);
goto err_rx_unbind;
}
rtnl_lock(); rtnl_lock();
if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN) if (!vif->can_sg && vif->dev->mtu > ETH_DATA_LEN)
...@@ -388,12 +422,18 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref, ...@@ -388,12 +422,18 @@ int xenvif_connect(struct xenvif *vif, unsigned long tx_ring_ref,
xenvif_up(vif); xenvif_up(vif);
rtnl_unlock(); rtnl_unlock();
wake_up_process(vif->task);
return 0; return 0;
err_rx_unbind:
unbind_from_irqhandler(vif->rx_irq, vif);
vif->rx_irq = 0;
err_tx_unbind: err_tx_unbind:
unbind_from_irqhandler(vif->tx_irq, vif); unbind_from_irqhandler(vif->tx_irq, vif);
vif->tx_irq = 0; vif->tx_irq = 0;
err_unmap: err_unmap:
xen_netbk_unmap_frontend_rings(vif); xenvif_unmap_frontend_rings(vif);
err: err:
module_put(THIS_MODULE); module_put(THIS_MODULE);
return err; return err;
...@@ -408,7 +448,6 @@ void xenvif_carrier_off(struct xenvif *vif) ...@@ -408,7 +448,6 @@ void xenvif_carrier_off(struct xenvif *vif)
if (netif_running(dev)) if (netif_running(dev))
xenvif_down(vif); xenvif_down(vif);
rtnl_unlock(); rtnl_unlock();
xenvif_put(vif);
} }
void xenvif_disconnect(struct xenvif *vif) void xenvif_disconnect(struct xenvif *vif)
...@@ -422,9 +461,6 @@ void xenvif_disconnect(struct xenvif *vif) ...@@ -422,9 +461,6 @@ void xenvif_disconnect(struct xenvif *vif)
if (netif_carrier_ok(vif->dev)) if (netif_carrier_ok(vif->dev))
xenvif_carrier_off(vif); xenvif_carrier_off(vif);
atomic_dec(&vif->refcnt);
wait_event(vif->waiting_to_free, atomic_read(&vif->refcnt) == 0);
if (vif->tx_irq) { if (vif->tx_irq) {
if (vif->tx_irq == vif->rx_irq) if (vif->tx_irq == vif->rx_irq)
unbind_from_irqhandler(vif->tx_irq, vif); unbind_from_irqhandler(vif->tx_irq, vif);
...@@ -438,9 +474,14 @@ void xenvif_disconnect(struct xenvif *vif) ...@@ -438,9 +474,14 @@ void xenvif_disconnect(struct xenvif *vif)
need_module_put = 1; need_module_put = 1;
} }
if (vif->task)
kthread_stop(vif->task);
netif_napi_del(&vif->napi);
unregister_netdev(vif->dev); unregister_netdev(vif->dev);
xen_netbk_unmap_frontend_rings(vif); xenvif_unmap_frontend_rings(vif);
free_netdev(vif->dev); free_netdev(vif->dev);
......
drivers/net/xen-netback/netback.c
View file @ 823a19e0
...@@ -70,131 +70,26 @@ module_param(fatal_skb_slots, uint, 0444); ...@@ -70,131 +70,26 @@ module_param(fatal_skb_slots, uint, 0444);
*/ */
#define XEN_NETBK_LEGACY_SLOTS_MAX XEN_NETIF_NR_SLOTS_MIN #define XEN_NETBK_LEGACY_SLOTS_MAX XEN_NETIF_NR_SLOTS_MIN
typedef unsigned int pending_ring_idx_t;
#define INVALID_PENDING_RING_IDX (~0U)
struct pending_tx_info {
struct xen_netif_tx_request req; /* coalesced tx request */
struct xenvif *vif;
pending_ring_idx_t head; /* head != INVALID_PENDING_RING_IDX
* if it is head of one or more tx
* reqs
*/
};
struct netbk_rx_meta {
int id;
int size;
int gso_size;
};
#define MAX_PENDING_REQS 256
/* Discriminate from any valid pending_idx value. */
#define INVALID_PENDING_IDX 0xFFFF
#define MAX_BUFFER_OFFSET PAGE_SIZE
/* extra field used in struct page */
union page_ext {
struct {
#if BITS_PER_LONG < 64
#define IDX_WIDTH 8
#define GROUP_WIDTH (BITS_PER_LONG - IDX_WIDTH)
unsigned int group:GROUP_WIDTH;
unsigned int idx:IDX_WIDTH;
#else
unsigned int group, idx;
#endif
} e;
void *mapping;
};
struct xen_netbk {
wait_queue_head_t wq;
struct task_struct *task;
struct sk_buff_head rx_queue;
struct sk_buff_head tx_queue;
struct timer_list net_timer;
struct page *mmap_pages[MAX_PENDING_REQS];
pending_ring_idx_t pending_prod;
pending_ring_idx_t pending_cons;
struct list_head net_schedule_list;
/* Protect the net_schedule_list in netif. */
spinlock_t net_schedule_list_lock;
atomic_t netfront_count;
struct pending_tx_info pending_tx_info[MAX_PENDING_REQS];
/* Coalescing tx requests before copying makes number of grant
* copy ops greater or equal to number of slots required. In
* worst case a tx request consumes 2 gnttab_copy.
*/
struct gnttab_copy tx_copy_ops[2*MAX_PENDING_REQS];
u16 pending_ring[MAX_PENDING_REQS];
/*
* Given MAX_BUFFER_OFFSET of 4096 the worst case is that each
* head/fragment page uses 2 copy operations because it
* straddles two buffers in the frontend.
*/
struct gnttab_copy grant_copy_op[2*XEN_NETIF_RX_RING_SIZE];
struct netbk_rx_meta meta[2*XEN_NETIF_RX_RING_SIZE];
};
static struct xen_netbk *xen_netbk;
static int xen_netbk_group_nr;
/* /*
* If head != INVALID_PENDING_RING_IDX, it means this tx request is head of * If head != INVALID_PENDING_RING_IDX, it means this tx request is head of
* one or more merged tx requests, otherwise it is the continuation of * one or more merged tx requests, otherwise it is the continuation of
* previous tx request. * previous tx request.
*/ */
static inline int pending_tx_is_head(struct xen_netbk *netbk, RING_IDX idx) static inline int pending_tx_is_head(struct xenvif *vif, RING_IDX idx)
{
return netbk->pending_tx_info[idx].head != INVALID_PENDING_RING_IDX;
}
void xen_netbk_add_xenvif(struct xenvif *vif)
{ {
int i; return vif->pending_tx_info[idx].head != INVALID_PENDING_RING_IDX;
int min_netfront_count;
int min_group = 0;
struct xen_netbk *netbk;
min_netfront_count = atomic_read(&xen_netbk[0].netfront_count);
for (i = 0; i < xen_netbk_group_nr; i++) {
int netfront_count = atomic_read(&xen_netbk[i].netfront_count);
if (netfront_count < min_netfront_count) {
min_group = i;
min_netfront_count = netfront_count;
}
}
netbk = &xen_netbk[min_group];
vif->netbk = netbk;
atomic_inc(&netbk->netfront_count);
} }
void xen_netbk_remove_xenvif(struct xenvif *vif) static void xenvif_idx_release(struct xenvif *vif, u16 pending_idx,
{ u8 status);
struct xen_netbk *netbk = vif->netbk;
vif->netbk = NULL;
atomic_dec(&netbk->netfront_count);
}
static void xen_netbk_idx_release(struct xen_netbk *netbk, u16 pending_idx,
u8 status);
static void make_tx_response(struct xenvif *vif, static void make_tx_response(struct xenvif *vif,
struct xen_netif_tx_request *txp, struct xen_netif_tx_request *txp,
s8 st); s8 st);
static inline int tx_work_todo(struct xenvif *vif);
static inline int rx_work_todo(struct xenvif *vif);
static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif, static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif,
u16 id, u16 id,
s8 st, s8 st,
...@@ -202,55 +97,16 @@ static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif, ...@@ -202,55 +97,16 @@ static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif,
u16 size, u16 size,
u16 flags); u16 flags);
static inline unsigned long idx_to_pfn(struct xen_netbk *netbk, static inline unsigned long idx_to_pfn(struct xenvif *vif,
u16 idx) u16 idx)
{ {
return page_to_pfn(netbk->mmap_pages[idx]); return page_to_pfn(vif->mmap_pages[idx]);
} }
static inline unsigned long idx_to_kaddr(struct xen_netbk *netbk, static inline unsigned long idx_to_kaddr(struct xenvif *vif,
u16 idx) u16 idx)
{ {
return (unsigned long)pfn_to_kaddr(idx_to_pfn(netbk, idx)); return (unsigned long)pfn_to_kaddr(idx_to_pfn(vif, idx));
}
/* extra field used in struct page */
static inline void set_page_ext(struct page *pg, struct xen_netbk *netbk,
unsigned int idx)
{
unsigned int group = netbk - xen_netbk;
union page_ext ext = { .e = { .group = group + 1, .idx = idx } };
BUILD_BUG_ON(sizeof(ext) > sizeof(ext.mapping));
pg->mapping = ext.mapping;
}
static int get_page_ext(struct page *pg,
unsigned int *pgroup, unsigned int *pidx)
{
union page_ext ext = { .mapping = pg->mapping };
struct xen_netbk *netbk;
unsigned int group, idx;
group = ext.e.group - 1;
if (group < 0 || group >= xen_netbk_group_nr)
return 0;
netbk = &xen_netbk[group];
idx = ext.e.idx;
if ((idx < 0) || (idx >= MAX_PENDING_REQS))
return 0;
if (netbk->mmap_pages[idx] != pg)
return 0;
*pgroup = group;
*pidx = idx;
return 1;
} }
/* /*
...@@ -278,15 +134,10 @@ static inline pending_ring_idx_t pending_index(unsigned i) ...@@ -278,15 +134,10 @@ static inline pending_ring_idx_t pending_index(unsigned i)
return i & (MAX_PENDING_REQS-1); return i & (MAX_PENDING_REQS-1);
} }
static inline pending_ring_idx_t nr_pending_reqs(struct xen_netbk *netbk) static inline pending_ring_idx_t nr_pending_reqs(struct xenvif *vif)
{ {
return MAX_PENDING_REQS - return MAX_PENDING_REQS -
netbk->pending_prod + netbk->pending_cons; vif->pending_prod + vif->pending_cons;
}
static void xen_netbk_kick_thread(struct xen_netbk *netbk)
{
wake_up(&netbk->wq);
} }
static int max_required_rx_slots(struct xenvif *vif) static int max_required_rx_slots(struct xenvif *vif)
...@@ -300,7 +151,7 @@ static int max_required_rx_slots(struct xenvif *vif) ...@@ -300,7 +151,7 @@ static int max_required_rx_slots(struct xenvif *vif)
return max; return max;
} }
int xen_netbk_rx_ring_full(struct xenvif *vif) int xenvif_rx_ring_full(struct xenvif *vif)
{ {
RING_IDX peek = vif->rx_req_cons_peek; RING_IDX peek = vif->rx_req_cons_peek;
RING_IDX needed = max_required_rx_slots(vif); RING_IDX needed = max_required_rx_slots(vif);
...@@ -309,16 +160,16 @@ int xen_netbk_rx_ring_full(struct xenvif *vif) ...@@ -309,16 +160,16 @@ int xen_netbk_rx_ring_full(struct xenvif *vif)
((vif->rx.rsp_prod_pvt + XEN_NETIF_RX_RING_SIZE - peek) < needed); ((vif->rx.rsp_prod_pvt + XEN_NETIF_RX_RING_SIZE - peek) < needed);
} }
int xen_netbk_must_stop_queue(struct xenvif *vif) int xenvif_must_stop_queue(struct xenvif *vif)
{ {
if (!xen_netbk_rx_ring_full(vif)) if (!xenvif_rx_ring_full(vif))
return 0; return 0;
vif->rx.sring->req_event = vif->rx_req_cons_peek + vif->rx.sring->req_event = vif->rx_req_cons_peek +
max_required_rx_slots(vif); max_required_rx_slots(vif);
mb(); /* request notification /then/ check the queue */ mb(); /* request notification /then/ check the queue */
return xen_netbk_rx_ring_full(vif); return xenvif_rx_ring_full(vif);
} }
/* /*
...@@ -364,9 +215,9 @@ static bool start_new_rx_buffer(int offset, unsigned long size, int head) ...@@ -364,9 +215,9 @@ static bool start_new_rx_buffer(int offset, unsigned long size, int head)
/* /*
* Figure out how many ring slots we're going to need to send @skb to * Figure out how many ring slots we're going to need to send @skb to
* the guest. This function is essentially a dry run of * the guest. This function is essentially a dry run of
* netbk_gop_frag_copy. * xenvif_gop_frag_copy.
*/ */
unsigned int xen_netbk_count_skb_slots(struct xenvif *vif, struct sk_buff *skb) unsigned int xenvif_count_skb_slots(struct xenvif *vif, struct sk_buff *skb)
{ {
unsigned int count; unsigned int count;
int i, copy_off; int i, copy_off;
...@@ -418,15 +269,15 @@ struct netrx_pending_operations { ...@@ -418,15 +269,15 @@ struct netrx_pending_operations {
unsigned copy_prod, copy_cons; unsigned copy_prod, copy_cons;
unsigned meta_prod, meta_cons; unsigned meta_prod, meta_cons;
struct gnttab_copy *copy; struct gnttab_copy *copy;
struct netbk_rx_meta *meta; struct xenvif_rx_meta *meta;
int copy_off; int copy_off;
grant_ref_t copy_gref; grant_ref_t copy_gref;
}; };
static struct netbk_rx_meta *get_next_rx_buffer(struct xenvif *vif, static struct xenvif_rx_meta *get_next_rx_buffer(struct xenvif *vif,
struct netrx_pending_operations *npo) struct netrx_pending_operations *npo)
{ {
struct netbk_rx_meta *meta; struct xenvif_rx_meta *meta;
struct xen_netif_rx_request *req; struct xen_netif_rx_request *req;
req = RING_GET_REQUEST(&vif->rx, vif->rx.req_cons++); req = RING_GET_REQUEST(&vif->rx, vif->rx.req_cons++);
...@@ -446,19 +297,13 @@ static struct netbk_rx_meta *get_next_rx_buffer(struct xenvif *vif, ...@@ -446,19 +297,13 @@ static struct netbk_rx_meta *get_next_rx_buffer(struct xenvif *vif,
* Set up the grant operations for this fragment. If it's a flipping * Set up the grant operations for this fragment. If it's a flipping
* interface, we also set up the unmap request from here. * interface, we also set up the unmap request from here.
*/ */
static void netbk_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb, static void xenvif_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb,
struct netrx_pending_operations *npo, struct netrx_pending_operations *npo,
struct page *page, unsigned long size, struct page *page, unsigned long size,
unsigned long offset, int *head) unsigned long offset, int *head)
{ {
struct gnttab_copy *copy_gop; struct gnttab_copy *copy_gop;
struct netbk_rx_meta *meta; struct xenvif_rx_meta *meta;
/*
* These variables are used iff get_page_ext returns true,
* in which case they are guaranteed to be initialized.
*/
unsigned int uninitialized_var(group), uninitialized_var(idx);
int foreign = get_page_ext(page, &group, &idx);
unsigned long bytes; unsigned long bytes;
/* Data must not cross a page boundary. */ /* Data must not cross a page boundary. */
...@@ -494,26 +339,15 @@ static void netbk_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb, ...@@ -494,26 +339,15 @@ static void netbk_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb,
copy_gop = npo->copy + npo->copy_prod++; copy_gop = npo->copy + npo->copy_prod++;
copy_gop->flags = GNTCOPY_dest_gref; copy_gop->flags = GNTCOPY_dest_gref;
if (foreign) { copy_gop->len = bytes;
struct xen_netbk *netbk = &xen_netbk[group];
struct pending_tx_info *src_pend;
src_pend = &netbk->pending_tx_info[idx];
copy_gop->source.domid = src_pend->vif->domid; copy_gop->source.domid = DOMID_SELF;
copy_gop->source.u.ref = src_pend->req.gref; copy_gop->source.u.gmfn = virt_to_mfn(page_address(page));
copy_gop->flags |= GNTCOPY_source_gref;
} else {
void *vaddr = page_address(page);
copy_gop->source.domid = DOMID_SELF;
copy_gop->source.u.gmfn = virt_to_mfn(vaddr);
}
copy_gop->source.offset = offset; copy_gop->source.offset = offset;
copy_gop->dest.domid = vif->domid;
copy_gop->dest.domid = vif->domid;
copy_gop->dest.offset = npo->copy_off; copy_gop->dest.offset = npo->copy_off;
copy_gop->dest.u.ref = npo->copy_gref; copy_gop->dest.u.ref = npo->copy_gref;
copy_gop->len = bytes;
npo->copy_off += bytes; npo->copy_off += bytes;
meta->size += bytes; meta->size += bytes;
...@@ -549,14 +383,14 @@ static void netbk_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb, ...@@ -549,14 +383,14 @@ static void netbk_gop_frag_copy(struct xenvif *vif, struct sk_buff *skb,
* zero GSO descriptors (for non-GSO packets) or one descriptor (for * zero GSO descriptors (for non-GSO packets) or one descriptor (for
* frontend-side LRO). * frontend-side LRO).
*/ */
static int netbk_gop_skb(struct sk_buff *skb, static int xenvif_gop_skb(struct sk_buff *skb,
struct netrx_pending_operations *npo) struct netrx_pending_operations *npo)
{ {
struct xenvif *vif = netdev_priv(skb->dev); struct xenvif *vif = netdev_priv(skb->dev);
int nr_frags = skb_shinfo(skb)->nr_frags; int nr_frags = skb_shinfo(skb)->nr_frags;
int i; int i;
struct xen_netif_rx_request *req; struct xen_netif_rx_request *req;
struct netbk_rx_meta *meta; struct xenvif_rx_meta *meta;
unsigned char *data; unsigned char *data;
int head = 1; int head = 1;
int old_meta_prod; int old_meta_prod;
...@@ -593,30 +427,30 @@ static int netbk_gop_skb(struct sk_buff *skb, ...@@ -593,30 +427,30 @@ static int netbk_gop_skb(struct sk_buff *skb,
if (data + len > skb_tail_pointer(skb)) if (data + len > skb_tail_pointer(skb))
len = skb_tail_pointer(skb) - data; len = skb_tail_pointer(skb) - data;
netbk_gop_frag_copy(vif, skb, npo, xenvif_gop_frag_copy(vif, skb, npo,
virt_to_page(data), len, offset, &head); virt_to_page(data), len, offset, &head);
data += len; data += len;
} }
for (i = 0; i < nr_frags; i++) { for (i = 0; i < nr_frags; i++) {
netbk_gop_frag_copy(vif, skb, npo, xenvif_gop_frag_copy(vif, skb, npo,
skb_frag_page(&skb_shinfo(skb)->frags[i]), skb_frag_page(&skb_shinfo(skb)->frags[i]),
skb_frag_size(&skb_shinfo(skb)->frags[i]), skb_frag_size(&skb_shinfo(skb)->frags[i]),
skb_shinfo(skb)->frags[i].page_offset, skb_shinfo(skb)->frags[i].page_offset,
&head); &head);
} }
return npo->meta_prod - old_meta_prod; return npo->meta_prod - old_meta_prod;
} }
/* /*
* This is a twin to netbk_gop_skb. Assume that netbk_gop_skb was * This is a twin to xenvif_gop_skb. Assume that xenvif_gop_skb was
* used to set up the operations on the top of * used to set up the operations on the top of
* netrx_pending_operations, which have since been done. Check that * netrx_pending_operations, which have since been done. Check that
* they didn't give any errors and advance over them. * they didn't give any errors and advance over them.
*/ */
static int netbk_check_gop(struct xenvif *vif, int nr_meta_slots, static int xenvif_check_gop(struct xenvif *vif, int nr_meta_slots,
struct netrx_pending_operations *npo) struct netrx_pending_operations *npo)
{ {
struct gnttab_copy *copy_op; struct gnttab_copy *copy_op;
int status = XEN_NETIF_RSP_OKAY; int status = XEN_NETIF_RSP_OKAY;
...@@ -635,9 +469,9 @@ static int netbk_check_gop(struct xenvif *vif, int nr_meta_slots, ...@@ -635,9 +469,9 @@ static int netbk_check_gop(struct xenvif *vif, int nr_meta_slots,
return status; return status;
} }
static void netbk_add_frag_responses(struct xenvif *vif, int status, static void xenvif_add_frag_responses(struct xenvif *vif, int status,
struct netbk_rx_meta *meta, struct xenvif_rx_meta *meta,
int nr_meta_slots) int nr_meta_slots)
{ {
int i; int i;
unsigned long offset; unsigned long offset;
...@@ -665,9 +499,13 @@ struct skb_cb_overlay { ...@@ -665,9 +499,13 @@ struct skb_cb_overlay {
int meta_slots_used; int meta_slots_used;
}; };
static void xen_netbk_rx_action(struct xen_netbk *netbk) static void xenvif_kick_thread(struct xenvif *vif)
{
wake_up(&vif->wq);
}
void xenvif_rx_action(struct xenvif *vif)
{ {
struct xenvif *vif = NULL, *tmp;
s8 status; s8 status;
u16 flags; u16 flags;
struct xen_netif_rx_response *resp; struct xen_netif_rx_response *resp;
...@@ -679,22 +517,23 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk) ...@@ -679,22 +517,23 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
int count; int count;
unsigned long offset; unsigned long offset;
struct skb_cb_overlay *sco; struct skb_cb_overlay *sco;
int need_to_notify = 0;
struct netrx_pending_operations npo = { struct netrx_pending_operations npo = {
.copy = netbk->grant_copy_op, .copy = vif->grant_copy_op,
.meta = netbk->meta, .meta = vif->meta,
}; };
skb_queue_head_init(&rxq); skb_queue_head_init(&rxq);
count = 0; count = 0;
while ((skb = skb_dequeue(&netbk->rx_queue)) != NULL) { while ((skb = skb_dequeue(&vif->rx_queue)) != NULL) {
vif = netdev_priv(skb->dev); vif = netdev_priv(skb->dev);
nr_frags = skb_shinfo(skb)->nr_frags; nr_frags = skb_shinfo(skb)->nr_frags;
sco = (struct skb_cb_overlay *)skb->cb; sco = (struct skb_cb_overlay *)skb->cb;
sco->meta_slots_used = netbk_gop_skb(skb, &npo); sco->meta_slots_used = xenvif_gop_skb(skb, &npo);
count += nr_frags + 1; count += nr_frags + 1;
...@@ -706,27 +545,27 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk) ...@@ -706,27 +545,27 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
break; break;
} }
BUG_ON(npo.meta_prod > ARRAY_SIZE(netbk->meta)); BUG_ON(npo.meta_prod > ARRAY_SIZE(vif->meta));
if (!npo.copy_prod) if (!npo.copy_prod)
return; return;
BUG_ON(npo.copy_prod > ARRAY_SIZE(netbk->grant_copy_op)); BUG_ON(npo.copy_prod > ARRAY_SIZE(vif->grant_copy_op));
gnttab_batch_copy(netbk->grant_copy_op, npo.copy_prod); gnttab_batch_copy(vif->grant_copy_op, npo.copy_prod);
while ((skb = __skb_dequeue(&rxq)) != NULL) { while ((skb = __skb_dequeue(&rxq)) != NULL) {
sco = (struct skb_cb_overlay *)skb->cb; sco = (struct skb_cb_overlay *)skb->cb;
vif = netdev_priv(skb->dev); vif = netdev_priv(skb->dev);
if (netbk->meta[npo.meta_cons].gso_size && vif->gso_prefix) { if (vif->meta[npo.meta_cons].gso_size && vif->gso_prefix) {
resp = RING_GET_RESPONSE(&vif->rx, resp = RING_GET_RESPONSE(&vif->rx,
vif->rx.rsp_prod_pvt++); vif->rx.rsp_prod_pvt++);
resp->flags = XEN_NETRXF_gso_prefix | XEN_NETRXF_more_data; resp->flags = XEN_NETRXF_gso_prefix | XEN_NETRXF_more_data;
resp->offset = netbk->meta[npo.meta_cons].gso_size; resp->offset = vif->meta[npo.meta_cons].gso_size;
resp->id = netbk->meta[npo.meta_cons].id; resp->id = vif->meta[npo.meta_cons].id;
resp->status = sco->meta_slots_used; resp->status = sco->meta_slots_used;
npo.meta_cons++; npo.meta_cons++;
...@@ -737,7 +576,7 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk) ...@@ -737,7 +576,7 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
vif->dev->stats.tx_bytes += skb->len; vif->dev->stats.tx_bytes += skb->len;
vif->dev->stats.tx_packets++; vif->dev->stats.tx_packets++;
status = netbk_check_gop(vif, sco->meta_slots_used, &npo); status = xenvif_check_gop(vif, sco->meta_slots_used, &npo);
if (sco->meta_slots_used == 1) if (sco->meta_slots_used == 1)
flags = 0; flags = 0;
...@@ -751,12 +590,12 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk) ...@@ -751,12 +590,12 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
flags |= XEN_NETRXF_data_validated; flags |= XEN_NETRXF_data_validated;
offset = 0; offset = 0;
resp = make_rx_response(vif, netbk->meta[npo.meta_cons].id, resp = make_rx_response(vif, vif->meta[npo.meta_cons].id,
status, offset, status, offset,
netbk->meta[npo.meta_cons].size, vif->meta[npo.meta_cons].size,
flags); flags);
if (netbk->meta[npo.meta_cons].gso_size && !vif->gso_prefix) { if (vif->meta[npo.meta_cons].gso_size && !vif->gso_prefix) {
struct xen_netif_extra_info *gso = struct xen_netif_extra_info *gso =
(struct xen_netif_extra_info *) (struct xen_netif_extra_info *)
RING_GET_RESPONSE(&vif->rx, RING_GET_RESPONSE(&vif->rx,
...@@ -764,7 +603,7 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk) ...@@ -764,7 +603,7 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
resp->flags |= XEN_NETRXF_extra_info; resp->flags |= XEN_NETRXF_extra_info;
gso->u.gso.size = netbk->meta[npo.meta_cons].gso_size; gso->u.gso.size = vif->meta[npo.meta_cons].gso_size;
gso->u.gso.type = XEN_NETIF_GSO_TYPE_TCPV4; gso->u.gso.type = XEN_NETIF_GSO_TYPE_TCPV4;
gso->u.gso.pad = 0; gso->u.gso.pad = 0;
gso->u.gso.features = 0; gso->u.gso.features = 0;
...@@ -773,123 +612,44 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk) ...@@ -773,123 +612,44 @@ static void xen_netbk_rx_action(struct xen_netbk *netbk)
gso->flags = 0; gso->flags = 0;
} }
netbk_add_frag_responses(vif, status, xenvif_add_frag_responses(vif, status,
netbk->meta + npo.meta_cons + 1, vif->meta + npo.meta_cons + 1,
sco->meta_slots_used); sco->meta_slots_used);
RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&vif->rx, ret); RING_PUSH_RESPONSES_AND_CHECK_NOTIFY(&vif->rx, ret);
if (ret)
need_to_notify = 1;
xenvif_notify_tx_completion(vif); xenvif_notify_tx_completion(vif);
if (ret && list_empty(&vif->notify_list))
list_add_tail(&vif->notify_list, &notify);
else
xenvif_put(vif);
npo.meta_cons += sco->meta_slots_used; npo.meta_cons += sco->meta_slots_used;
dev_kfree_skb(skb); dev_kfree_skb(skb);
} }
list_for_each_entry_safe(vif, tmp, &notify, notify_list) { if (need_to_notify)
notify_remote_via_irq(vif->rx_irq); notify_remote_via_irq(vif->rx_irq);
list_del_init(&vif->notify_list);
xenvif_put(vif);
}
/* More work to do? */ /* More work to do? */
if (!skb_queue_empty(&netbk->rx_queue) && if (!skb_queue_empty(&vif->rx_queue))
!timer_pending(&netbk->net_timer)) xenvif_kick_thread(vif);
xen_netbk_kick_thread(netbk);
}
void xen_netbk_queue_tx_skb(struct xenvif *vif, struct sk_buff *skb)
{
struct xen_netbk *netbk = vif->netbk;
skb_queue_tail(&netbk->rx_queue, skb);
xen_netbk_kick_thread(netbk);
}
static void xen_netbk_alarm(unsigned long data)
{
struct xen_netbk *netbk = (struct xen_netbk *)data;
xen_netbk_kick_thread(netbk);
}
static int __on_net_schedule_list(struct xenvif *vif)
{
return !list_empty(&vif->schedule_list);
}
/* Must be called with net_schedule_list_lock held */
static void remove_from_net_schedule_list(struct xenvif *vif)
{
if (likely(__on_net_schedule_list(vif))) {
list_del_init(&vif->schedule_list);
xenvif_put(vif);
}
}
static struct xenvif *poll_net_schedule_list(struct xen_netbk *netbk)
{
struct xenvif *vif = NULL;
spin_lock_irq(&netbk->net_schedule_list_lock);
if (list_empty(&netbk->net_schedule_list))
goto out;
vif = list_first_entry(&netbk->net_schedule_list,
struct xenvif, schedule_list);
if (!vif)
goto out;
xenvif_get(vif);
remove_from_net_schedule_list(vif);
out:
spin_unlock_irq(&netbk->net_schedule_list_lock);
return vif;
} }
void xen_netbk_schedule_xenvif(struct xenvif *vif) void xenvif_queue_tx_skb(struct xenvif *vif, struct sk_buff *skb)
{ {
unsigned long flags; skb_queue_tail(&vif->rx_queue, skb);
struct xen_netbk *netbk = vif->netbk;
if (__on_net_schedule_list(vif))
goto kick;
spin_lock_irqsave(&netbk->net_schedule_list_lock, flags);
if (!__on_net_schedule_list(vif) &&
likely(xenvif_schedulable(vif))) {
list_add_tail(&vif->schedule_list, &netbk->net_schedule_list);
xenvif_get(vif);
}
spin_unlock_irqrestore(&netbk->net_schedule_list_lock, flags);
kick:
smp_mb();
if ((nr_pending_reqs(netbk) < (MAX_PENDING_REQS/2)) &&
!list_empty(&netbk->net_schedule_list))
xen_netbk_kick_thread(netbk);
}
void xen_netbk_deschedule_xenvif(struct xenvif *vif) xenvif_kick_thread(vif);
{
struct xen_netbk *netbk = vif->netbk;
spin_lock_irq(&netbk->net_schedule_list_lock);
remove_from_net_schedule_list(vif);
spin_unlock_irq(&netbk->net_schedule_list_lock);
} }
void xen_netbk_check_rx_xenvif(struct xenvif *vif) void xenvif_check_rx_xenvif(struct xenvif *vif)
{ {
int more_to_do; int more_to_do;
RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, more_to_do); RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, more_to_do);
if (more_to_do) if (more_to_do)
xen_netbk_schedule_xenvif(vif); napi_schedule(&vif->napi);
} }
static void tx_add_credit(struct xenvif *vif) static void tx_add_credit(struct xenvif *vif)
...@@ -916,11 +676,11 @@ static void tx_credit_callback(unsigned long data) ...@@ -916,11 +676,11 @@ static void tx_credit_callback(unsigned long data)
{ {
struct xenvif *vif = (struct xenvif *)data; struct xenvif *vif = (struct xenvif *)data;
tx_add_credit(vif); tx_add_credit(vif);
xen_netbk_check_rx_xenvif(vif); xenvif_check_rx_xenvif(vif);
} }
static void netbk_tx_err(struct xenvif *vif, static void xenvif_tx_err(struct xenvif *vif,
struct xen_netif_tx_request *txp, RING_IDX end) struct xen_netif_tx_request *txp, RING_IDX end)
{ {
RING_IDX cons = vif->tx.req_cons; RING_IDX cons = vif->tx.req_cons;
...@@ -931,21 +691,18 @@ static void netbk_tx_err(struct xenvif *vif, ...@@ -931,21 +691,18 @@ static void netbk_tx_err(struct xenvif *vif,
txp = RING_GET_REQUEST(&vif->tx, cons++); txp = RING_GET_REQUEST(&vif->tx, cons++);
} while (1); } while (1);
vif->tx.req_cons = cons; vif->tx.req_cons = cons;
xen_netbk_check_rx_xenvif(vif);
xenvif_put(vif);
} }
static void netbk_fatal_tx_err(struct xenvif *vif) static void xenvif_fatal_tx_err(struct xenvif *vif)
{ {
netdev_err(vif->dev, "fatal error; disabling device\n"); netdev_err(vif->dev, "fatal error; disabling device\n");
xenvif_carrier_off(vif); xenvif_carrier_off(vif);
xenvif_put(vif);
} }
static int netbk_count_requests(struct xenvif *vif, static int xenvif_count_requests(struct xenvif *vif,
struct xen_netif_tx_request *first, struct xen_netif_tx_request *first,
struct xen_netif_tx_request *txp, struct xen_netif_tx_request *txp,
int work_to_do) int work_to_do)
{ {
RING_IDX cons = vif->tx.req_cons; RING_IDX cons = vif->tx.req_cons;
int slots = 0; int slots = 0;
...@@ -962,7 +719,7 @@ static int netbk_count_requests(struct xenvif *vif, ...@@ -962,7 +719,7 @@ static int netbk_count_requests(struct xenvif *vif,
netdev_err(vif->dev, netdev_err(vif->dev,
"Asked for %d slots but exceeds this limit\n", "Asked for %d slots but exceeds this limit\n",
work_to_do); work_to_do);
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
return -ENODATA; return -ENODATA;
} }
...@@ -973,7 +730,7 @@ static int netbk_count_requests(struct xenvif *vif, ...@@ -973,7 +730,7 @@ static int netbk_count_requests(struct xenvif *vif,
netdev_err(vif->dev, netdev_err(vif->dev,
"Malicious frontend using %d slots, threshold %u\n", "Malicious frontend using %d slots, threshold %u\n",
slots, fatal_skb_slots); slots, fatal_skb_slots);
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
return -E2BIG; return -E2BIG;
} }
...@@ -1021,7 +778,7 @@ static int netbk_count_requests(struct xenvif *vif, ...@@ -1021,7 +778,7 @@ static int netbk_count_requests(struct xenvif *vif,
if (unlikely((txp->offset + txp->size) > PAGE_SIZE)) { if (unlikely((txp->offset + txp->size) > PAGE_SIZE)) {
netdev_err(vif->dev, "Cross page boundary, txp->offset: %x, size: %u\n", netdev_err(vif->dev, "Cross page boundary, txp->offset: %x, size: %u\n",
txp->offset, txp->size); txp->offset, txp->size);
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
return -EINVAL; return -EINVAL;
} }
...@@ -1033,30 +790,30 @@ static int netbk_count_requests(struct xenvif *vif, ...@@ -1033,30 +790,30 @@ static int netbk_count_requests(struct xenvif *vif,
} while (more_data); } while (more_data);
if (drop_err) { if (drop_err) {
netbk_tx_err(vif, first, cons + slots); xenvif_tx_err(vif, first, cons + slots);
return drop_err; return drop_err;
} }
return slots; return slots;
} }
static struct page *xen_netbk_alloc_page(struct xen_netbk *netbk, static struct page *xenvif_alloc_page(struct xenvif *vif,
u16 pending_idx) u16 pending_idx)
{ {
struct page *page; struct page *page;
page = alloc_page(GFP_KERNEL|__GFP_COLD);
page = alloc_page(GFP_ATOMIC|__GFP_COLD);
if (!page) if (!page)
return NULL; return NULL;
set_page_ext(page, netbk, pending_idx); vif->mmap_pages[pending_idx] = page;
netbk->mmap_pages[pending_idx] = page;
return page; return page;
} }
static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk, static struct gnttab_copy *xenvif_get_requests(struct xenvif *vif,
struct xenvif *vif, struct sk_buff *skb,
struct sk_buff *skb, struct xen_netif_tx_request *txp,
struct xen_netif_tx_request *txp, struct gnttab_copy *gop)
struct gnttab_copy *gop)
{ {
struct skb_shared_info *shinfo = skb_shinfo(skb); struct skb_shared_info *shinfo = skb_shinfo(skb);
skb_frag_t *frags = shinfo->frags; skb_frag_t *frags = shinfo->frags;
...@@ -1079,14 +836,14 @@ static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk, ...@@ -1079,14 +836,14 @@ static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk,
/* Coalesce tx requests, at this point the packet passed in /* Coalesce tx requests, at this point the packet passed in
* should be <= 64K. Any packets larger than 64K have been * should be <= 64K. Any packets larger than 64K have been
* handled in netbk_count_requests(). * handled in xenvif_count_requests().
*/ */
for (shinfo->nr_frags = slot = start; slot < nr_slots; for (shinfo->nr_frags = slot = start; slot < nr_slots;
shinfo->nr_frags++) { shinfo->nr_frags++) {
struct pending_tx_info *pending_tx_info = struct pending_tx_info *pending_tx_info =
netbk->pending_tx_info; vif->pending_tx_info;
page = alloc_page(GFP_KERNEL|__GFP_COLD); page = alloc_page(GFP_ATOMIC|__GFP_COLD);
if (!page) if (!page)
goto err; goto err;
...@@ -1121,21 +878,18 @@ static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk, ...@@ -1121,21 +878,18 @@ static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk,
gop->len = txp->size; gop->len = txp->size;
dst_offset += gop->len; dst_offset += gop->len;
index = pending_index(netbk->pending_cons++); index = pending_index(vif->pending_cons++);
pending_idx = netbk->pending_ring[index]; pending_idx = vif->pending_ring[index];
memcpy(&pending_tx_info[pending_idx].req, txp, memcpy(&pending_tx_info[pending_idx].req, txp,
sizeof(*txp)); sizeof(*txp));
xenvif_get(vif);
pending_tx_info[pending_idx].vif = vif;
/* Poison these fields, corresponding /* Poison these fields, corresponding
* fields for head tx req will be set * fields for head tx req will be set
* to correct values after the loop. * to correct values after the loop.
*/ */
netbk->mmap_pages[pending_idx] = (void *)(~0UL); vif->mmap_pages[pending_idx] = (void *)(~0UL);
pending_tx_info[pending_idx].head = pending_tx_info[pending_idx].head =
INVALID_PENDING_RING_IDX; INVALID_PENDING_RING_IDX;
...@@ -1155,8 +909,7 @@ static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk, ...@@ -1155,8 +909,7 @@ static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk,
first->req.offset = 0; first->req.offset = 0;
first->req.size = dst_offset; first->req.size = dst_offset;
first->head = start_idx; first->head = start_idx;
set_page_ext(page, netbk, head_idx); vif->mmap_pages[head_idx] = page;
netbk->mmap_pages[head_idx] = page;
frag_set_pending_idx(&frags[shinfo->nr_frags], head_idx); frag_set_pending_idx(&frags[shinfo->nr_frags], head_idx);
} }
...@@ -1166,20 +919,20 @@ static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk, ...@@ -1166,20 +919,20 @@ static struct gnttab_copy *xen_netbk_get_requests(struct xen_netbk *netbk,
err: err:
/* Unwind, freeing all pages and sending error responses. */ /* Unwind, freeing all pages and sending error responses. */
while (shinfo->nr_frags-- > start) { while (shinfo->nr_frags-- > start) {
xen_netbk_idx_release(netbk, xenvif_idx_release(vif,
frag_get_pending_idx(&frags[shinfo->nr_frags]), frag_get_pending_idx(&frags[shinfo->nr_frags]),
XEN_NETIF_RSP_ERROR); XEN_NETIF_RSP_ERROR);
} }
/* The head too, if necessary. */ /* The head too, if necessary. */
if (start) if (start)
xen_netbk_idx_release(netbk, pending_idx, XEN_NETIF_RSP_ERROR); xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_ERROR);
return NULL; return NULL;
} }
static int xen_netbk_tx_check_gop(struct xen_netbk *netbk, static int xenvif_tx_check_gop(struct xenvif *vif,
struct sk_buff *skb, struct sk_buff *skb,
struct gnttab_copy **gopp) struct gnttab_copy **gopp)
{ {
struct gnttab_copy *gop = *gopp; struct gnttab_copy *gop = *gopp;
u16 pending_idx = *((u16 *)skb->data); u16 pending_idx = *((u16 *)skb->data);
...@@ -1192,7 +945,7 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk, ...@@ -1192,7 +945,7 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk,
/* Check status of header. */ /* Check status of header. */
err = gop->status; err = gop->status;
if (unlikely(err)) if (unlikely(err))
xen_netbk_idx_release(netbk, pending_idx, XEN_NETIF_RSP_ERROR); xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_ERROR);
/* Skip first skb fragment if it is on same page as header fragment. */ /* Skip first skb fragment if it is on same page as header fragment. */
start = (frag_get_pending_idx(&shinfo->frags[0]) == pending_idx); start = (frag_get_pending_idx(&shinfo->frags[0]) == pending_idx);
...@@ -1202,7 +955,7 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk, ...@@ -1202,7 +955,7 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk,
pending_ring_idx_t head; pending_ring_idx_t head;
pending_idx = frag_get_pending_idx(&shinfo->frags[i]); pending_idx = frag_get_pending_idx(&shinfo->frags[i]);
tx_info = &netbk->pending_tx_info[pending_idx]; tx_info = &vif->pending_tx_info[pending_idx];
head = tx_info->head; head = tx_info->head;
/* Check error status: if okay then remember grant handle. */ /* Check error status: if okay then remember grant handle. */
...@@ -1210,18 +963,19 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk, ...@@ -1210,18 +963,19 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk,
newerr = (++gop)->status; newerr = (++gop)->status;
if (newerr) if (newerr)
break; break;
peek = netbk->pending_ring[pending_index(++head)]; peek = vif->pending_ring[pending_index(++head)];
} while (!pending_tx_is_head(netbk, peek)); } while (!pending_tx_is_head(vif, peek));
if (likely(!newerr)) { if (likely(!newerr)) {
/* Had a previous error? Invalidate this fragment. */ /* Had a previous error? Invalidate this fragment. */
if (unlikely(err)) if (unlikely(err))
xen_netbk_idx_release(netbk, pending_idx, XEN_NETIF_RSP_OKAY); xenvif_idx_release(vif, pending_idx,
XEN_NETIF_RSP_OKAY);
continue; continue;
} }
/* Error on this fragment: respond to client with an error. */ /* Error on this fragment: respond to client with an error. */
xen_netbk_idx_release(netbk, pending_idx, XEN_NETIF_RSP_ERROR); xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_ERROR);
/* Not the first error? Preceding frags already invalidated. */ /* Not the first error? Preceding frags already invalidated. */
if (err) if (err)
...@@ -1229,10 +983,11 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk, ...@@ -1229,10 +983,11 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk,
/* First error: invalidate header and preceding fragments. */ /* First error: invalidate header and preceding fragments. */
pending_idx = *((u16 *)skb->data); pending_idx = *((u16 *)skb->data);
xen_netbk_idx_release(netbk, pending_idx, XEN_NETIF_RSP_OKAY); xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_OKAY);
for (j = start; j < i; j++) { for (j = start; j < i; j++) {
pending_idx = frag_get_pending_idx(&shinfo->frags[j]); pending_idx = frag_get_pending_idx(&shinfo->frags[j]);
xen_netbk_idx_release(netbk, pending_idx, XEN_NETIF_RSP_OKAY); xenvif_idx_release(vif, pending_idx,
XEN_NETIF_RSP_OKAY);
} }
/* Remember the error: invalidate all subsequent fragments. */ /* Remember the error: invalidate all subsequent fragments. */
...@@ -1243,7 +998,7 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk, ...@@ -1243,7 +998,7 @@ static int xen_netbk_tx_check_gop(struct xen_netbk *netbk,
return err; return err;
} }
static void xen_netbk_fill_frags(struct xen_netbk *netbk, struct sk_buff *skb) static void xenvif_fill_frags(struct xenvif *vif, struct sk_buff *skb)
{ {
struct skb_shared_info *shinfo = skb_shinfo(skb); struct skb_shared_info *shinfo = skb_shinfo(skb);
int nr_frags = shinfo->nr_frags; int nr_frags = shinfo->nr_frags;
...@@ -1257,20 +1012,20 @@ static void xen_netbk_fill_frags(struct xen_netbk *netbk, struct sk_buff *skb) ...@@ -1257,20 +1012,20 @@ static void xen_netbk_fill_frags(struct xen_netbk *netbk, struct sk_buff *skb)
pending_idx = frag_get_pending_idx(frag); pending_idx = frag_get_pending_idx(frag);
txp = &netbk->pending_tx_info[pending_idx].req; txp = &vif->pending_tx_info[pending_idx].req;
page = virt_to_page(idx_to_kaddr(netbk, pending_idx)); page = virt_to_page(idx_to_kaddr(vif, pending_idx));
__skb_fill_page_desc(skb, i, page, txp->offset, txp->size); __skb_fill_page_desc(skb, i, page, txp->offset, txp->size);
skb->len += txp->size; skb->len += txp->size;
skb->data_len += txp->size; skb->data_len += txp->size;
skb->truesize += txp->size; skb->truesize += txp->size;
/* Take an extra reference to offset xen_netbk_idx_release */ /* Take an extra reference to offset xenvif_idx_release */
get_page(netbk->mmap_pages[pending_idx]); get_page(vif->mmap_pages[pending_idx]);
xen_netbk_idx_release(netbk, pending_idx, XEN_NETIF_RSP_OKAY); xenvif_idx_release(vif, pending_idx, XEN_NETIF_RSP_OKAY);
} }
} }
static int xen_netbk_get_extras(struct xenvif *vif, static int xenvif_get_extras(struct xenvif *vif,
struct xen_netif_extra_info *extras, struct xen_netif_extra_info *extras,
int work_to_do) int work_to_do)
{ {
...@@ -1280,7 +1035,7 @@ static int xen_netbk_get_extras(struct xenvif *vif, ...@@ -1280,7 +1035,7 @@ static int xen_netbk_get_extras(struct xenvif *vif,
do { do {
if (unlikely(work_to_do-- <= 0)) { if (unlikely(work_to_do-- <= 0)) {
netdev_err(vif->dev, "Missing extra info\n"); netdev_err(vif->dev, "Missing extra info\n");
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
return -EBADR; return -EBADR;
} }
...@@ -1291,7 +1046,7 @@ static int xen_netbk_get_extras(struct xenvif *vif, ...@@ -1291,7 +1046,7 @@ static int xen_netbk_get_extras(struct xenvif *vif,
vif->tx.req_cons = ++cons; vif->tx.req_cons = ++cons;
netdev_err(vif->dev, netdev_err(vif->dev,
"Invalid extra type: %d\n", extra.type); "Invalid extra type: %d\n", extra.type);
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
return -EINVAL; return -EINVAL;
} }
...@@ -1302,20 +1057,20 @@ static int xen_netbk_get_extras(struct xenvif *vif, ...@@ -1302,20 +1057,20 @@ static int xen_netbk_get_extras(struct xenvif *vif,
return work_to_do; return work_to_do;
} }
static int netbk_set_skb_gso(struct xenvif *vif, static int xenvif_set_skb_gso(struct xenvif *vif,
struct sk_buff *skb, struct sk_buff *skb,
struct xen_netif_extra_info *gso) struct xen_netif_extra_info *gso)
{ {
if (!gso->u.gso.size) { if (!gso->u.gso.size) {
netdev_err(vif->dev, "GSO size must not be zero.\n"); netdev_err(vif->dev, "GSO size must not be zero.\n");
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
return -EINVAL; return -EINVAL;
} }
/* Currently only TCPv4 S.O. is supported. */ /* Currently only TCPv4 S.O. is supported. */
if (gso->u.gso.type != XEN_NETIF_GSO_TYPE_TCPV4) { if (gso->u.gso.type != XEN_NETIF_GSO_TYPE_TCPV4) {
netdev_err(vif->dev, "Bad GSO type %d.\n", gso->u.gso.type); netdev_err(vif->dev, "Bad GSO type %d.\n", gso->u.gso.type);
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
return -EINVAL; return -EINVAL;
} }
...@@ -1426,16 +1181,14 @@ static bool tx_credit_exceeded(struct xenvif *vif, unsigned size) ...@@ -1426,16 +1181,14 @@ static bool tx_credit_exceeded(struct xenvif *vif, unsigned size)
return false; return false;
} }
static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) static unsigned xenvif_tx_build_gops(struct xenvif *vif)
{ {
struct gnttab_copy *gop = netbk->tx_copy_ops, *request_gop; struct gnttab_copy *gop = vif->tx_copy_ops, *request_gop;
struct sk_buff *skb; struct sk_buff *skb;
int ret; int ret;
while ((nr_pending_reqs(netbk) + XEN_NETBK_LEGACY_SLOTS_MAX while ((nr_pending_reqs(vif) + XEN_NETBK_LEGACY_SLOTS_MAX
< MAX_PENDING_REQS) && < MAX_PENDING_REQS)) {
!list_empty(&netbk->net_schedule_list)) {
struct xenvif *vif;
struct xen_netif_tx_request txreq; struct xen_netif_tx_request txreq;
struct xen_netif_tx_request txfrags[XEN_NETBK_LEGACY_SLOTS_MAX]; struct xen_netif_tx_request txfrags[XEN_NETBK_LEGACY_SLOTS_MAX];
struct page *page; struct page *page;
...@@ -1446,16 +1199,6 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1446,16 +1199,6 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
unsigned int data_len; unsigned int data_len;
pending_ring_idx_t index; pending_ring_idx_t index;
/* Get a netif from the list with work to do. */
vif = poll_net_schedule_list(netbk);
/* This can sometimes happen because the test of
* list_empty(net_schedule_list) at the top of the
* loop is unlocked. Just go back and have another
* look.
*/
if (!vif)
continue;
if (vif->tx.sring->req_prod - vif->tx.req_cons > if (vif->tx.sring->req_prod - vif->tx.req_cons >
XEN_NETIF_TX_RING_SIZE) { XEN_NETIF_TX_RING_SIZE) {
netdev_err(vif->dev, netdev_err(vif->dev,
...@@ -1463,15 +1206,13 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1463,15 +1206,13 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
"req_prod %d, req_cons %d, size %ld\n", "req_prod %d, req_cons %d, size %ld\n",
vif->tx.sring->req_prod, vif->tx.req_cons, vif->tx.sring->req_prod, vif->tx.req_cons,
XEN_NETIF_TX_RING_SIZE); XEN_NETIF_TX_RING_SIZE);
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
continue; continue;
} }
RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, work_to_do); RING_FINAL_CHECK_FOR_REQUESTS(&vif->tx, work_to_do);
if (!work_to_do) { if (!work_to_do)
xenvif_put(vif); break;
continue;
}
idx = vif->tx.req_cons; idx = vif->tx.req_cons;
rmb(); /* Ensure that we see the request before we copy it. */ rmb(); /* Ensure that we see the request before we copy it. */
...@@ -1479,10 +1220,8 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1479,10 +1220,8 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
/* Credit-based scheduling. */ /* Credit-based scheduling. */
if (txreq.size > vif->remaining_credit && if (txreq.size > vif->remaining_credit &&
tx_credit_exceeded(vif, txreq.size)) { tx_credit_exceeded(vif, txreq.size))
xenvif_put(vif); break;
continue;
}
vif->remaining_credit -= txreq.size; vif->remaining_credit -= txreq.size;
...@@ -1491,24 +1230,24 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1491,24 +1230,24 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
memset(extras, 0, sizeof(extras)); memset(extras, 0, sizeof(extras));
if (txreq.flags & XEN_NETTXF_extra_info) { if (txreq.flags & XEN_NETTXF_extra_info) {
work_to_do = xen_netbk_get_extras(vif, extras, work_to_do = xenvif_get_extras(vif, extras,
work_to_do); work_to_do);
idx = vif->tx.req_cons; idx = vif->tx.req_cons;
if (unlikely(work_to_do < 0)) if (unlikely(work_to_do < 0))
continue; break;
} }
ret = netbk_count_requests(vif, &txreq, txfrags, work_to_do); ret = xenvif_count_requests(vif, &txreq, txfrags, work_to_do);
if (unlikely(ret < 0)) if (unlikely(ret < 0))
continue; break;
idx += ret; idx += ret;
if (unlikely(txreq.size < ETH_HLEN)) { if (unlikely(txreq.size < ETH_HLEN)) {
netdev_dbg(vif->dev, netdev_dbg(vif->dev,
"Bad packet size: %d\n", txreq.size); "Bad packet size: %d\n", txreq.size);
netbk_tx_err(vif, &txreq, idx); xenvif_tx_err(vif, &txreq, idx);
continue; break;
} }
/* No crossing a page as the payload mustn't fragment. */ /* No crossing a page as the payload mustn't fragment. */
...@@ -1517,12 +1256,12 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1517,12 +1256,12 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
"txreq.offset: %x, size: %u, end: %lu\n", "txreq.offset: %x, size: %u, end: %lu\n",
txreq.offset, txreq.size, txreq.offset, txreq.size,
(txreq.offset&~PAGE_MASK) + txreq.size); (txreq.offset&~PAGE_MASK) + txreq.size);
netbk_fatal_tx_err(vif); xenvif_fatal_tx_err(vif);
continue; break;
} }
index = pending_index(netbk->pending_cons); index = pending_index(vif->pending_cons);
pending_idx = netbk->pending_ring[index]; pending_idx = vif->pending_ring[index];
data_len = (txreq.size > PKT_PROT_LEN && data_len = (txreq.size > PKT_PROT_LEN &&
ret < XEN_NETBK_LEGACY_SLOTS_MAX) ? ret < XEN_NETBK_LEGACY_SLOTS_MAX) ?
...@@ -1533,7 +1272,7 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1533,7 +1272,7 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
if (unlikely(skb == NULL)) { if (unlikely(skb == NULL)) {
netdev_dbg(vif->dev, netdev_dbg(vif->dev,
"Can't allocate a skb in start_xmit.\n"); "Can't allocate a skb in start_xmit.\n");
netbk_tx_err(vif, &txreq, idx); xenvif_tx_err(vif, &txreq, idx);
break; break;
} }
...@@ -1544,19 +1283,19 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1544,19 +1283,19 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
struct xen_netif_extra_info *gso; struct xen_netif_extra_info *gso;
gso = &extras[XEN_NETIF_EXTRA_TYPE_GSO - 1]; gso = &extras[XEN_NETIF_EXTRA_TYPE_GSO - 1];
if (netbk_set_skb_gso(vif, skb, gso)) { if (xenvif_set_skb_gso(vif, skb, gso)) {
/* Failure in netbk_set_skb_gso is fatal. */ /* Failure in xenvif_set_skb_gso is fatal. */
kfree_skb(skb); kfree_skb(skb);
continue; break;
} }
} }
/* XXX could copy straight to head */ /* XXX could copy straight to head */
page = xen_netbk_alloc_page(netbk, pending_idx); page = xenvif_alloc_page(vif, pending_idx);
if (!page) { if (!page) {
kfree_skb(skb); kfree_skb(skb);
netbk_tx_err(vif, &txreq, idx); xenvif_tx_err(vif, &txreq, idx);
continue; break;
} }
gop->source.u.ref = txreq.gref; gop->source.u.ref = txreq.gref;
...@@ -1572,10 +1311,9 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1572,10 +1311,9 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
gop++; gop++;
memcpy(&netbk->pending_tx_info[pending_idx].req, memcpy(&vif->pending_tx_info[pending_idx].req,
&txreq, sizeof(txreq)); &txreq, sizeof(txreq));
netbk->pending_tx_info[pending_idx].vif = vif; vif->pending_tx_info[pending_idx].head = index;
netbk->pending_tx_info[pending_idx].head = index;
*((u16 *)skb->data) = pending_idx; *((u16 *)skb->data) = pending_idx;
__skb_put(skb, data_len); __skb_put(skb, data_len);
...@@ -1590,46 +1328,45 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk) ...@@ -1590,46 +1328,45 @@ static unsigned xen_netbk_tx_build_gops(struct xen_netbk *netbk)
INVALID_PENDING_IDX); INVALID_PENDING_IDX);
} }
netbk->pending_cons++; vif->pending_cons++;
request_gop = xen_netbk_get_requests(netbk, vif, request_gop = xenvif_get_requests(vif, skb, txfrags, gop);
skb, txfrags, gop);
if (request_gop == NULL) { if (request_gop == NULL) {
kfree_skb(skb); kfree_skb(skb);
netbk_tx_err(vif, &txreq, idx); xenvif_tx_err(vif, &txreq, idx);
continue; break;
} }
gop = request_gop; gop = request_gop;
__skb_queue_tail(&netbk->tx_queue, skb); __skb_queue_tail(&vif->tx_queue, skb);
vif->tx.req_cons = idx; vif->tx.req_cons = idx;
xen_netbk_check_rx_xenvif(vif);
if ((gop-netbk->tx_copy_ops) >= ARRAY_SIZE(netbk->tx_copy_ops)) if ((gop-vif->tx_copy_ops) >= ARRAY_SIZE(vif->tx_copy_ops))
break; break;
} }
return gop - netbk->tx_copy_ops; return gop - vif->tx_copy_ops;
} }
static void xen_netbk_tx_submit(struct xen_netbk *netbk)
static int xenvif_tx_submit(struct xenvif *vif, int budget)
{ {
struct gnttab_copy *gop = netbk->tx_copy_ops; struct gnttab_copy *gop = vif->tx_copy_ops;
struct sk_buff *skb; struct sk_buff *skb;
int work_done = 0;
while ((skb = __skb_dequeue(&netbk->tx_queue)) != NULL) { while (work_done < budget &&
(skb = __skb_dequeue(&vif->tx_queue)) != NULL) {
struct xen_netif_tx_request *txp; struct xen_netif_tx_request *txp;
struct xenvif *vif;
u16 pending_idx; u16 pending_idx;
unsigned data_len; unsigned data_len;
pending_idx = *((u16 *)skb->data); pending_idx = *((u16 *)skb->data);
vif = netbk->pending_tx_info[pending_idx].vif; txp = &vif->pending_tx_info[pending_idx].req;
txp = &netbk->pending_tx_info[pending_idx].req;
/* Check the remap error code. */ /* Check the remap error code. */
if (unlikely(xen_netbk_tx_check_gop(netbk, skb, &gop))) { if (unlikely(xenvif_tx_check_gop(vif, skb, &gop))) {
netdev_dbg(vif->dev, "netback grant failed.\n"); netdev_dbg(vif->dev, "netback grant failed.\n");
skb_shinfo(skb)->nr_frags = 0; skb_shinfo(skb)->nr_frags = 0;
kfree_skb(skb); kfree_skb(skb);
...@@ -1638,7 +1375,7 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk) ...@@ -1638,7 +1375,7 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk)
data_len = skb->len; data_len = skb->len;
memcpy(skb->data, memcpy(skb->data,
(void *)(idx_to_kaddr(netbk, pending_idx)|txp->offset), (void *)(idx_to_kaddr(vif, pending_idx)|txp->offset),
data_len); data_len);
if (data_len < txp->size) { if (data_len < txp->size) {
/* Append the packet payload as a fragment. */ /* Append the packet payload as a fragment. */
...@@ -1646,7 +1383,8 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk) ...@@ -1646,7 +1383,8 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk)
txp->size -= data_len; txp->size -= data_len;
} else { } else {
/* Schedule a response immediately. */ /* Schedule a response immediately. */
xen_netbk_idx_release(netbk, pending_idx, XEN_NETIF_RSP_OKAY); xenvif_idx_release(vif, pending_idx,
XEN_NETIF_RSP_OKAY);
} }
if (txp->flags & XEN_NETTXF_csum_blank) if (txp->flags & XEN_NETTXF_csum_blank)
...@@ -1654,7 +1392,7 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk) ...@@ -1654,7 +1392,7 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk)
else if (txp->flags & XEN_NETTXF_data_validated) else if (txp->flags & XEN_NETTXF_data_validated)
skb->ip_summed = CHECKSUM_UNNECESSARY; skb->ip_summed = CHECKSUM_UNNECESSARY;
xen_netbk_fill_frags(netbk, skb); xenvif_fill_frags(vif, skb);
/* /*
* If the initial fragment was < PKT_PROT_LEN then * If the initial fragment was < PKT_PROT_LEN then
...@@ -1682,53 +1420,61 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk) ...@@ -1682,53 +1420,61 @@ static void xen_netbk_tx_submit(struct xen_netbk *netbk)
vif->dev->stats.rx_bytes += skb->len; vif->dev->stats.rx_bytes += skb->len;
vif->dev->stats.rx_packets++; vif->dev->stats.rx_packets++;
xenvif_receive_skb(vif, skb); work_done++;
netif_receive_skb(skb);
} }
return work_done;
} }
/* Called after netfront has transmitted */ /* Called after netfront has transmitted */
static void xen_netbk_tx_action(struct xen_netbk *netbk) int xenvif_tx_action(struct xenvif *vif, int budget)
{ {
unsigned nr_gops; unsigned nr_gops;
int work_done;
if (unlikely(!tx_work_todo(vif)))
return 0;
nr_gops = xen_netbk_tx_build_gops(netbk); nr_gops = xenvif_tx_build_gops(vif);
if (nr_gops == 0) if (nr_gops == 0)
return; return 0;
gnttab_batch_copy(netbk->tx_copy_ops, nr_gops); gnttab_batch_copy(vif->tx_copy_ops, nr_gops);
xen_netbk_tx_submit(netbk); work_done = xenvif_tx_submit(vif, nr_gops);
return work_done;
} }
static void xen_netbk_idx_release(struct xen_netbk *netbk, u16 pending_idx, static void xenvif_idx_release(struct xenvif *vif, u16 pending_idx,
u8 status) u8 status)
{ {
struct xenvif *vif;
struct pending_tx_info *pending_tx_info; struct pending_tx_info *pending_tx_info;
pending_ring_idx_t head; pending_ring_idx_t head;
u16 peek; /* peek into next tx request */ u16 peek; /* peek into next tx request */
BUG_ON(netbk->mmap_pages[pending_idx] == (void *)(~0UL)); BUG_ON(vif->mmap_pages[pending_idx] == (void *)(~0UL));
/* Already complete? */ /* Already complete? */
if (netbk->mmap_pages[pending_idx] == NULL) if (vif->mmap_pages[pending_idx] == NULL)
return; return;
pending_tx_info = &netbk->pending_tx_info[pending_idx]; pending_tx_info = &vif->pending_tx_info[pending_idx];
vif = pending_tx_info->vif;
head = pending_tx_info->head; head = pending_tx_info->head;
BUG_ON(!pending_tx_is_head(netbk, head)); BUG_ON(!pending_tx_is_head(vif, head));
BUG_ON(netbk->pending_ring[pending_index(head)] != pending_idx); BUG_ON(vif->pending_ring[pending_index(head)] != pending_idx);
do { do {
pending_ring_idx_t index; pending_ring_idx_t index;
pending_ring_idx_t idx = pending_index(head); pending_ring_idx_t idx = pending_index(head);
u16 info_idx = netbk->pending_ring[idx]; u16 info_idx = vif->pending_ring[idx];
pending_tx_info = &netbk->pending_tx_info[info_idx]; pending_tx_info = &vif->pending_tx_info[info_idx];
make_tx_response(vif, &pending_tx_info->req, status); make_tx_response(vif, &pending_tx_info->req, status);
/* Setting any number other than /* Setting any number other than
...@@ -1737,18 +1483,15 @@ static void xen_netbk_idx_release(struct xen_netbk *netbk, u16 pending_idx, ...@@ -1737,18 +1483,15 @@ static void xen_netbk_idx_release(struct xen_netbk *netbk, u16 pending_idx,
*/ */
pending_tx_info->head = 0; pending_tx_info->head = 0;
index = pending_index(netbk->pending_prod++); index = pending_index(vif->pending_prod++);
netbk->pending_ring[index] = netbk->pending_ring[info_idx]; vif->pending_ring[index] = vif->pending_ring[info_idx];
xenvif_put(vif);
peek = netbk->pending_ring[pending_index(++head)]; peek = vif->pending_ring[pending_index(++head)];
} while (!pending_tx_is_head(netbk, peek)); } while (!pending_tx_is_head(vif, peek));
netbk->mmap_pages[pending_idx]->mapping = 0; put_page(vif->mmap_pages[pending_idx]);
put_page(netbk->mmap_pages[pending_idx]); vif->mmap_pages[pending_idx] = NULL;
netbk->mmap_pages[pending_idx] = NULL;
} }
...@@ -1796,46 +1539,23 @@ static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif, ...@@ -1796,46 +1539,23 @@ static struct xen_netif_rx_response *make_rx_response(struct xenvif *vif,
return resp; return resp;
} }
static inline int rx_work_todo(struct xen_netbk *netbk) static inline int rx_work_todo(struct xenvif *vif)
{ {
return !skb_queue_empty(&netbk->rx_queue); return !skb_queue_empty(&vif->rx_queue);
} }
static inline int tx_work_todo(struct xen_netbk *netbk) static inline int tx_work_todo(struct xenvif *vif)
{ {
if ((nr_pending_reqs(netbk) + XEN_NETBK_LEGACY_SLOTS_MAX if (likely(RING_HAS_UNCONSUMED_REQUESTS(&vif->tx)) &&
< MAX_PENDING_REQS) && (nr_pending_reqs(vif) + XEN_NETBK_LEGACY_SLOTS_MAX
!list_empty(&netbk->net_schedule_list)) < MAX_PENDING_REQS))
return 1; return 1;
return 0; return 0;
} }
static int xen_netbk_kthread(void *data) void xenvif_unmap_frontend_rings(struct xenvif *vif)
{
struct xen_netbk *netbk = data;
while (!kthread_should_stop()) {
wait_event_interruptible(netbk->wq,
rx_work_todo(netbk) ||
tx_work_todo(netbk) ||
kthread_should_stop());
cond_resched();
if (kthread_should_stop())
break;
if (rx_work_todo(netbk))
xen_netbk_rx_action(netbk);
if (tx_work_todo(netbk))
xen_netbk_tx_action(netbk);
}
return 0;
}
void xen_netbk_unmap_frontend_rings(struct xenvif *vif)
{ {
if (vif->tx.sring) if (vif->tx.sring)
xenbus_unmap_ring_vfree(xenvif_to_xenbus_device(vif), xenbus_unmap_ring_vfree(xenvif_to_xenbus_device(vif),
...@@ -1845,9 +1565,9 @@ void xen_netbk_unmap_frontend_rings(struct xenvif *vif) ...@@ -1845,9 +1565,9 @@ void xen_netbk_unmap_frontend_rings(struct xenvif *vif)
vif->rx.sring); vif->rx.sring);
} }
int xen_netbk_map_frontend_rings(struct xenvif *vif, int xenvif_map_frontend_rings(struct xenvif *vif,
grant_ref_t tx_ring_ref, grant_ref_t tx_ring_ref,
grant_ref_t rx_ring_ref) grant_ref_t rx_ring_ref)
{ {
void *addr; void *addr;
struct xen_netif_tx_sring *txs; struct xen_netif_tx_sring *txs;
...@@ -1876,15 +1596,33 @@ int xen_netbk_map_frontend_rings(struct xenvif *vif, ...@@ -1876,15 +1596,33 @@ int xen_netbk_map_frontend_rings(struct xenvif *vif,
return 0; return 0;
err: err:
xen_netbk_unmap_frontend_rings(vif); xenvif_unmap_frontend_rings(vif);
return err; return err;
} }
int xenvif_kthread(void *data)
{
struct xenvif *vif = data;
while (!kthread_should_stop()) {
wait_event_interruptible(vif->wq,
rx_work_todo(vif) ||
kthread_should_stop());
if (kthread_should_stop())
break;
if (rx_work_todo(vif))
xenvif_rx_action(vif);
cond_resched();
}
return 0;
}
static int __init netback_init(void) static int __init netback_init(void)
{ {
int i;
int rc = 0; int rc = 0;
int group;
if (!xen_domain()) if (!xen_domain())
return -ENODEV; return -ENODEV;
...@@ -1895,48 +1633,6 @@ static int __init netback_init(void) ...@@ -1895,48 +1633,6 @@ static int __init netback_init(void)
fatal_skb_slots = XEN_NETBK_LEGACY_SLOTS_MAX; fatal_skb_slots = XEN_NETBK_LEGACY_SLOTS_MAX;
} }
xen_netbk_group_nr = num_online_cpus();
xen_netbk = vzalloc(sizeof(struct xen_netbk) * xen_netbk_group_nr);
if (!xen_netbk)
return -ENOMEM;
for (group = 0; group < xen_netbk_group_nr; group++) {
struct xen_netbk *netbk = &xen_netbk[group];
skb_queue_head_init(&netbk->rx_queue);
skb_queue_head_init(&netbk->tx_queue);
init_timer(&netbk->net_timer);
netbk->net_timer.data = (unsigned long)netbk;
netbk->net_timer.function = xen_netbk_alarm;
netbk->pending_cons = 0;
netbk->pending_prod = MAX_PENDING_REQS;
for (i = 0; i < MAX_PENDING_REQS; i++)
netbk->pending_ring[i] = i;
init_waitqueue_head(&netbk->wq);
netbk->task = kthread_create(xen_netbk_kthread,
(void *)netbk,
"netback/%u", group);
if (IS_ERR(netbk->task)) {
pr_alert("kthread_create() fails at netback\n");
del_timer(&netbk->net_timer);
rc = PTR_ERR(netbk->task);
goto failed_init;
}
kthread_bind(netbk->task, group);
INIT_LIST_HEAD(&netbk->net_schedule_list);
spin_lock_init(&netbk->net_schedule_list_lock);
atomic_set(&netbk->netfront_count, 0);
wake_up_process(netbk->task);
}
rc = xenvif_xenbus_init(); rc = xenvif_xenbus_init();
if (rc) if (rc)
goto failed_init; goto failed_init;
...@@ -1944,35 +1640,14 @@ static int __init netback_init(void) ...@@ -1944,35 +1640,14 @@ static int __init netback_init(void)
return 0; return 0;
failed_init: failed_init:
while (--group >= 0) {
struct xen_netbk *netbk = &xen_netbk[group];
del_timer(&netbk->net_timer);
kthread_stop(netbk->task);
}
vfree(xen_netbk);
return rc; return rc;
} }
module_init(netback_init); module_init(netback_init);
static void __exit netback_fini(void) static void __exit netback_fini(void)
{ {
int i, j;
xenvif_xenbus_fini(); xenvif_xenbus_fini();
for (i = 0; i < xen_netbk_group_nr; i++) {
struct xen_netbk *netbk = &xen_netbk[i];
del_timer_sync(&netbk->net_timer);
kthread_stop(netbk->task);
for (j = 0; j < MAX_PENDING_REQS; j++) {
if (netbk->mmap_pages[j])
__free_page(netbk->mmap_pages[j]);
}
}
vfree(xen_netbk);
} }
module_exit(netback_fini); module_exit(netback_fini);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7